minor bug fixes, auto-update feature

Makefile.gc

@@ -21,10 +21,8 @@ BUILD		:=	build_gc
 SOURCES		:=	source/fceultra source/fceultra/boards \
 				source/fceultra/drivers/common source/fceultra/input \
 				source/fceultra/mappers source/fceultra/mbshare \
-				source/ngc source/sz
+				source/ngc source/sz source/unzip
-DATA		:=	data
+INCLUDES	:=	source/fceultra source/ngc source/unzip
-INCLUDES	:=	source/fceultra source/ngc
-LANG		:=	ENGLISH # Supported languages: ENGLISH
 
 #---------------------------------------------------------------------------------
 # options for code generation

Makefile.wii

@@ -21,10 +21,8 @@ BUILD		:=	build_wii
 SOURCES		:=	source/fceultra source/fceultra/boards \
 				source/fceultra/drivers/common source/fceultra/input \
 				source/fceultra/mappers source/fceultra/mbshare \
-				source/ngc source/sz
+				source/ngc source/sz source/unzip
-DATA		:=	data  
+INCLUDES	:=	source/fceultra source/ngc source/unzip
-INCLUDES	:=	source/fceultra source/ngc
-LANG		:=	ENGLISH # Supported languages: ENGLISH
 
 #---------------------------------------------------------------------------------
 # options for code generation

source/ngc/fceugx.c

@@ -30,7 +30,7 @@
 #include "menu.h"
 #include "preferences.h"
 #include "fileop.h"
-#include "smbop.h"
+#include "networkop.h"
 #include "gcaudio.h"
 #include "gcvideo.h"
 #include "pad.h"
@@ -62,6 +62,7 @@ void FCEUD_Update(uint8 *XBuf, int32 *Buffer, int Count);
 
 void ExitCleanup()
 {
+	LWP_SuspendThread (devicethread);
 	UnmountAllFAT();
 	CloseShare();
 

source/ngc/fceugx.h

@@ -12,9 +12,9 @@
 #ifndef _FCEUGX_H_
 #define _FCEUGX_H_
 
-#define VERSIONNUM "2.0.7"
+#define APPNAME			"FCE Ultra GX"
-#define VERSIONSTR "FCE Ultra GX 2.0.7"
+#define APPVERSION		"2.0.8"
-#define PREF_FILE_NAME "settings.xml"
+#define PREF_FILE_NAME	"settings.xml"
 
 #define NOTSILENT 0
 #define SILENT 1

source/ngc/fceuload.c

@@ -31,7 +31,6 @@
 #include "menudraw.h"
 #include "fileop.h"
 #include "filesel.h"
-#include "smbop.h"
 
 unsigned char *nesrom;
 bool romLoaded = false;

source/ngc/fceuram.c

@@ -37,7 +37,6 @@
 #include "filesel.h"
 #include "memcardop.h"
 #include "fileop.h"
-#include "smbop.h"
 
 extern const unsigned short saveicon[1024];
 extern u32 iNESGameCRC32;
@@ -61,7 +60,7 @@ int NGCFCEU_GameSave(CartInfo *LocalHWInfo, int operation, int method)
 			offset += sizeof(saveicon);
 
 			// And the comments
-			sprintf (comment[0], "%s RAM", VERSIONSTR);
+			sprintf (comment[0], "%s RAM", APPNAME);
 			strncpy (comment[1],romFilename,31); // we only have 32 chars to work with!
 			comment[1][31] = 0;
 			memcpy(savebuffer+offset, comment, 64);

source/ngc/fceustate.c

@@ -28,7 +28,6 @@
 #include "filesel.h"
 #include "memcardop.h"
 #include "fileop.h"
-#include "smbop.h"
 
 /*** External functions ***/
 extern void FCEUPPU_SaveState(void);
@@ -277,7 +276,7 @@ int GCFCEUSS_Save(int method)
 		totalsize += sizeof(saveicon);
 
 		// And the comments
-		sprintf (comment[0], "%s State", VERSIONSTR);
+		sprintf (comment[0], "%s State", APPNAME);
 		strncpy (comment[1],romFilename,31); // we only have 32 chars to work with!
 		comment[1][31] = 0;
 		memfwrite(&comment[0], 64);

source/ngc/fileop.c

@@ -26,7 +26,7 @@
 #include "fceugx.h"
 #include "fileop.h"
 #include "memcardop.h"
-#include "smbop.h"
+#include "networkop.h"
 #include "gcunzip.h"
 #include "menudraw.h"
 #include "filesel.h"
@@ -80,6 +80,7 @@ devicecallback (void *arg)
 		}
 
 		InitializeNetwork(SILENT);
+		UpdateCheck();
 #else
 		if(isMounted[METHOD_SD_SLOTA])
 		{
@@ -123,11 +124,11 @@ InitDeviceThread()
 void UnmountAllFAT()
 {
 #ifdef HW_RVL
-	fatUnmount("sd");
+	fatUnmount("sd:/");
-	fatUnmount("usb");
+	fatUnmount("usb:/");
 #else
-	fatUnmount("carda");
+	fatUnmount("carda:/");
-	fatUnmount("cardb");
+	fatUnmount("cardb:/");
 #endif
 }
 
@@ -176,7 +177,7 @@ bool MountFAT(int method)
 	if(unmountRequired[method])
 	{
 		unmountRequired[method] = false;
-		fatUnmount(name);
+		fatUnmount(rootdir);
 		disc->shutdown();
 	}
 	if(!isMounted[method])

source/ngc/fileop.h

@@ -32,6 +32,7 @@ u32 SaveFile(char filepath[], u32 datasize, int method, bool silent);
 extern char currFATdir[MAXPATHLEN];
 extern FILE * file;
 extern bool unmountRequired[];
+extern bool isMounted[];
 extern lwp_t devicethread;
 
 #endif

source/ngc/filesel.c

@@ -24,7 +24,7 @@
 #include "dvd.h"
 #include "menudraw.h"
 #include "filesel.h"
-#include "smbop.h"
+#include "networkop.h"
 #include "fileop.h"
 #include "memcardop.h"
 #include "pad.h"
@@ -96,7 +96,8 @@ int autoLoadMethod()
 	else
 		WaitPrompt("Unable to auto-determine load method!");
 
-	GCSettings.LoadMethod = method; // save method found for later use
+	if(GCSettings.LoadMethod == METHOD_AUTO)
+		GCSettings.LoadMethod = method; // save method found for later use
 	return method;
 }
 
@@ -125,7 +126,8 @@ int autoSaveMethod(bool silent)
 	else if(!silent)
 		WaitPrompt("Unable to auto-determine save method!");
 
-	GCSettings.SaveMethod = method; // save method found for later use
+	if(GCSettings.SaveMethod == METHOD_AUTO)
+		GCSettings.SaveMethod = method; // save method found for later use
 	return method;
 }
 

source/ngc/gcunzip.c

@@ -21,7 +21,6 @@
 
 #include "fceugx.h"
 #include "dvd.h"
-#include "smbop.h"
 #include "fileop.h"
 #include "menudraw.h"
 #include "gcunzip.h"

source/ngc/http.c

@@ -0,0 +1,432 @@
+/****************************************************************************
+ * FCE Ultra 0.98.12
+ * Nintendo Wii/Gamecube Port
+ *
+ * Tantric December 2008
+ *
+ * http.cpp
+ *
+ * HTTP operations
+ * Copyright (C) 2008 bushing
+ ***************************************************************************/
+
+#include <malloc.h>
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#include <ogcsys.h>
+#include <network.h>
+#include <ogc/lwp_watchdog.h>
+
+#include <sys/types.h>
+#include <sys/errno.h>
+#include <fcntl.h>
+
+#include "menudraw.h"
+#include "http.h"
+
+static s32 tcp_socket(void)
+{
+	s32 s, res;
+
+	s = net_socket(PF_INET, SOCK_STREAM, 0);
+	if (s < 0)
+	{
+
+		return s;
+	}
+
+	res = net_fcntl(s, F_GETFL, 0);
+	if (res < 0)
+	{
+
+		net_close(s);
+		return res;
+	}
+
+	res = net_fcntl(s, F_SETFL, res | 4);
+	if (res < 0)
+	{
+
+		net_close(s);
+		return res;
+	}
+
+	return s;
+}
+
+static s32 tcp_connect(char *host, const u16 port)
+{
+	struct hostent *hp;
+	struct sockaddr_in sa;
+	s32 s, res;
+	s64 t;
+
+	hp = net_gethostbyname(host);
+	if (!hp || !(hp->h_addrtype == PF_INET))
+	{
+
+		return errno;
+	}
+
+	s = tcp_socket();
+	if (s < 0)
+		return s;
+
+	memset(&sa, 0, sizeof(struct sockaddr_in));
+	sa.sin_family = PF_INET;
+	sa.sin_len = sizeof(struct sockaddr_in);
+	sa.sin_port = htons(port);
+	memcpy((char *) &sa.sin_addr, hp->h_addr_list[0], hp->h_length);
+
+	t = gettime();
+	while (true)
+	{
+		if (ticks_to_millisecs(diff_ticks(t, gettime())) > TCP_CONNECT_TIMEOUT)
+		{
+
+			net_close(s);
+
+			return -ETIMEDOUT;
+		}
+
+		res = net_connect(s, (struct sockaddr *) &sa,
+				sizeof(struct sockaddr_in));
+
+		if (res < 0)
+		{
+			if (res == -EISCONN)
+				break;
+
+			if (res == -EINPROGRESS || res == -EALREADY)
+			{
+				usleep(20 * 1000);
+
+				continue;
+			}
+
+			net_close(s);
+
+			return res;
+		}
+
+		break;
+	}
+
+	return s;
+}
+
+static char * tcp_readln(const s32 s, const u16 max_length, const u64 start_time,
+		const u16 timeout)
+{
+	char *buf;
+	u16 c;
+	s32 res;
+	char *ret;
+
+	buf = (char *) malloc(max_length);
+
+	c = 0;
+	ret = NULL;
+	while (true)
+	{
+		if (ticks_to_millisecs(diff_ticks(start_time, gettime())) > timeout)
+			break;
+
+		res = net_read(s, &buf[c], 1);
+
+		if ((res == 0) || (res == -EAGAIN))
+		{
+			usleep(20 * 1000);
+
+			continue;
+		}
+
+		if (res < 0)
+		{
+
+			break;
+		}
+
+		if ((c > 0) && (buf[c - 1] == '\r') && (buf[c] == '\n'))
+		{
+			if (c == 1)
+			{
+				ret = strdup("");
+
+				break;
+			}
+
+			ret = strndup(buf, c - 1);
+
+			break;
+		}
+
+		c++;
+
+		if (c == max_length)
+			break;
+	}
+
+	free(buf);
+	return ret;
+}
+
+static bool tcp_read(const s32 s, u8 **buffer, const u32 length)
+{
+	u8 *p;
+	u32 step, left, block, received;
+	s64 t;
+	s32 res;
+
+	step = 0;
+	p = *buffer;
+	left = length;
+	received = 0;
+
+	t = gettime();
+	while (left)
+	{
+		if (ticks_to_millisecs(diff_ticks(t, gettime()))
+				> TCP_BLOCK_RECV_TIMEOUT)
+		{
+			break;
+		}
+
+		block = left;
+		if (block > 2048)
+			block = 2048;
+
+		res = net_read(s, p, block);
+
+		if ((res == 0) || (res == -EAGAIN))
+		{
+			usleep(20 * 1000);
+
+			continue;
+		}
+
+		if (res < 0)
+		{
+			break;
+		}
+
+		received += res;
+		left -= res;
+		p += res;
+
+		if ((received / TCP_BLOCK_SIZE) > step)
+		{
+			t = gettime();
+			step++;
+		}
+	}
+
+	return left == 0;
+}
+
+static bool tcp_write(const s32 s, const u8 *buffer, const u32 length)
+{
+	const u8 *p;
+	u32 step, left, block, sent;
+	s64 t;
+	s32 res;
+
+	step = 0;
+	p = buffer;
+	left = length;
+	sent = 0;
+
+	t = gettime();
+	while (left)
+	{
+		if (ticks_to_millisecs(diff_ticks(t, gettime()))
+				> TCP_BLOCK_SEND_TIMEOUT)
+		{
+
+			break;
+		}
+
+		block = left;
+		if (block > 2048)
+			block = 2048;
+
+		res = net_write(s, p, block);
+
+		if ((res == 0) || (res == -56))
+		{
+			usleep(20 * 1000);
+			continue;
+		}
+
+		if (res < 0)
+		{
+
+			break;
+		}
+
+		sent += res;
+		left -= res;
+		p += res;
+
+		if ((sent / TCP_BLOCK_SIZE) > step)
+		{
+			t = gettime();
+			step++;
+		}
+	}
+
+	return left == 0;
+}
+static bool http_split_url(char **host, char **path, const char *url)
+{
+	const char *p;
+	char *c;
+
+	if (strncasecmp(url, "http://", 7))
+		return false;
+
+	p = url + 7;
+	c = strchr(p, '/');
+
+	if (c[0] == 0)
+		return false;
+
+	*host = strndup(p, c - p);
+	*path = strdup(c);
+
+	return true;
+}
+
+/****************************************************************************
+ * http_request
+ * Retrieves the specified URL, and stores it in the specified file or buffer
+ ***************************************************************************/
+bool http_request(const char *url, FILE * hfile, u8 * buffer,
+		const u32 max_size)
+{
+	char *http_host;
+	u16 http_port;
+	char *http_path;
+
+	http_res result;
+	u32 http_status;
+	u32 content_length = 0;
+
+	int linecount;
+	if (!http_split_url(&http_host, &http_path, url))
+		return false;
+
+	if (hfile == NULL && buffer == NULL)
+		return false;
+
+	http_port = 80;
+	http_status = 404;
+
+	int s = tcp_connect(http_host, http_port);
+
+	if (s < 0)
+	{
+		result = HTTPR_ERR_CONNECT;
+		return false;
+	}
+
+	char *request = (char *) malloc(1024);
+	char *r = request;
+	r += sprintf(r, "GET %s HTTP/1.1\r\n", http_path);
+	r += sprintf(r, "Host: %s\r\n", http_host);
+	r += sprintf(r, "Cache-Control: no-cache\r\n\r\n");
+
+	bool b = tcp_write(s, (u8 *) request, strlen(request));
+
+	free(request);
+	linecount = 0;
+
+	for (linecount = 0; linecount < 32; linecount++)
+	{
+		char *line = tcp_readln(s, 0xff, gettime(), (const u16) HTTP_TIMEOUT);
+
+		if (!line)
+		{
+			http_status = 404;
+			result = HTTPR_ERR_REQUEST;
+			break;
+		}
+
+		if (strlen(line) < 1)
+		{
+			free(line);
+			line = NULL;
+			break;
+		}
+
+		sscanf(line, "HTTP/1.%*u %u", &http_status);
+		sscanf(line, "Content-Length: %u", &content_length);
+
+		free(line);
+		line = NULL;
+
+	}
+
+	if (linecount == 32 || !content_length)
+		http_status = 404;
+	if (http_status != 200)
+	{
+		result = HTTPR_ERR_STATUS;
+		net_close(s);
+		return false;
+	}
+	if (content_length > max_size)
+	{
+		result = HTTPR_ERR_TOOBIG;
+		net_close(s);
+		return false;
+	}
+
+	int res = 1;
+
+	if (buffer != NULL)
+	{
+		b = tcp_read(s, &buffer, content_length);
+	}
+	else
+	{
+		// read into file
+		u32 bufSize = (1026 * 256);
+		u32 bytesLeft = content_length;
+		u32 readSize;
+
+		u8 * fbuffer = (u8 *) malloc(bufSize);
+		ShowProgress("Downloading...", 0, content_length);
+		while (bytesLeft > 0)
+		{
+			if (bytesLeft < bufSize)
+				readSize = bytesLeft;
+			else
+				readSize = bufSize;
+
+			b = tcp_read(s, &fbuffer, readSize);
+			if (!b)
+				break;
+			res = fwrite(fbuffer, 1, readSize, hfile);
+			if (!res)
+				break;
+
+			bytesLeft -= readSize;
+			ShowProgress("Downloading...", (content_length - bytesLeft),
+					content_length);
+		}
+	}
+
+	if (!b || !res)
+	{
+		result = HTTPR_ERR_RECEIVE;
+		net_close(s);
+		return false;
+	}
+
+	result = HTTPR_OK;
+	net_close(s);
+	return true;
+}

source/ngc/http.h

@@ -0,0 +1,33 @@
+/****************************************************************************
+ * FCE Ultra 0.98.12
+ * Nintendo Wii/Gamecube Port
+ *
+ * Tantric December 2008
+ *
+ * http.h
+ *
+ * HTTP operations
+ * Copyright (C) 2008 bushing
+ ***************************************************************************/
+
+#ifndef _HTTP_H_
+#define _HTTP_H_
+
+#define TCP_CONNECT_TIMEOUT 5000
+#define TCP_BLOCK_SIZE (16 * 1024)
+#define TCP_BLOCK_RECV_TIMEOUT 4000
+#define TCP_BLOCK_SEND_TIMEOUT 4000
+#define HTTP_TIMEOUT 300000
+
+typedef enum {
+	HTTPR_OK,
+	HTTPR_ERR_CONNECT,
+	HTTPR_ERR_REQUEST,
+	HTTPR_ERR_STATUS,
+	HTTPR_ERR_TOOBIG,
+	HTTPR_ERR_RECEIVE
+} http_res;
+
+bool http_request (const char *url, FILE * hfile, u8 * buffer, const u32 max_size);
+
+#endif

source/ngc/memcardop.c

@@ -266,7 +266,6 @@ LoadMCFile (char *buf, int slot, char *filename, bool silent)
 	return bytesread;
 }
 
-
 /****************************************************************************
  * SaveMCFile
  * Write savebuffer to Memory Card file
@@ -279,6 +278,9 @@ SaveMCFile (char *buf, int slot, char *filename, int datasize, bool silent)
 	unsigned int SectorSize;
 	char msg[80];
 
+	if(datasize <= 0)
+		return 0;
+
 	/*** Initialize Card System ***/
 	memset (SysArea, 0, CARD_WORKAREA);
 	CARD_Init ("FCEU", "00");
@@ -291,122 +293,116 @@ SaveMCFile (char *buf, int slot, char *filename, int datasize, bool silent)
 		/*** Get Sector Size ***/
 		CARD_GetSectorSize (slot, &SectorSize);
 
-		if (datasize)
+		/*** Calculate number of blocks required ***/
-		{
+		blocks = (datasize / SectorSize) * SectorSize;
-			/*** Calculate number of blocks required ***/
+		if (datasize % SectorSize)
-			blocks = (datasize / SectorSize) * SectorSize;
+			blocks += SectorSize;
-			if (datasize % SectorSize)
-				blocks += SectorSize;
 
-			/*** Does this file exist ? ***/
+		/*** Does this file exist ? ***/
-			if (CardFileExists (filename, slot))
+		if (CardFileExists (filename, slot))
+		{
+			/*** Try to open the file ***/
+			CardError = CARD_Open (slot, filename, &CardFile);
+			if (CardError)
 			{
-				/*** Try to open the file ***/
+				CARD_Unmount (slot);
-				CardError = CARD_Open (slot, filename, &CardFile);
+				WaitPrompt("Unable to open card file!");
+				return 0;
+			}
+
+			if ( (s32)blocks > CardFile.len )  /*** new data is longer ***/
+			{
+				CARD_Close (&CardFile);
+
+				/*** Try to create temp file to check available space ***/
+				CardError = CARD_Create (slot, "TEMPFILESNES9XGX201", blocks, &CardFile);
 				if (CardError)
 				{
-                    CARD_Unmount (slot);
+					CARD_Unmount (slot);
-					WaitPrompt("Unable to open card file!");
+					WaitPrompt("Not enough space to update file!");
 					return 0;
 				}
 
-				if ( (s32)blocks > CardFile.len )  /*** new data is longer ***/
+				/*** Delete the temporary file ***/
+				CARD_Close (&CardFile);
+				CardError = CARD_Delete(slot, "TEMPFILESNES9XGX201");
+				if (CardError)
 				{
-                    CARD_Close (&CardFile);
+					CARD_Unmount (slot);
+					WaitPrompt("Unable to delete temporary file!");
+					return 0;
+				}
 
-                    /*** Try to create temp file to check available space ***/
+				/*** Delete the existing shorter file ***/
-                    CardError = CARD_Create (slot, "TEMPFILESNES9XGX201", blocks, &CardFile);
+				CardError = CARD_Delete(slot, filename);
-                    if (CardError)
+				if (CardError)
-                    {
+				{
-                        CARD_Unmount (slot);
+					CARD_Unmount (slot);
-                        WaitPrompt("Not enough space to update file!");
+					WaitPrompt("Unable to delete existing file!");
-                        return 0;
+					return 0;
-                    }
+				}
 
-                    /*** Delete the temporary file ***/
+				/*** Create new, longer file ***/
-                    CARD_Close (&CardFile);
+				CardError = CARD_Create (slot, filename, blocks, &CardFile);
-                    CardError = CARD_Delete(slot, "TEMPFILESNES9XGX201");
+				if (CardError)
-                    if (CardError)
+				{
-                    {
+					CARD_Unmount (slot);
-                        CARD_Unmount (slot);
+					WaitPrompt("Unable to create updated card file!");
-                        WaitPrompt("Unable to delete temporary file!");
+					return 0;
-                        return 0;
-                    }
-
-                    /*** Delete the existing shorter file ***/
-                    CardError = CARD_Delete(slot, filename);
-                    if (CardError)
-                    {
-                        CARD_Unmount (slot);
-                        WaitPrompt("Unable to delete existing file!");
-                        return 0;
-                    }
-
-                    /*** Create new, longer file ***/
-                    CardError = CARD_Create (slot, filename, blocks, &CardFile);
-                    if (CardError)
-                    {
-                        CARD_Unmount (slot);
-                        WaitPrompt("Unable to create updated card file!");
-                        return 0;
-                    }
 				}
 			}
-			else  /*** no file existed, create new one ***/
+		}
+		else  /*** no file existed, create new one ***/
+		{
+			/*** Create new file ***/
+			CardError = CARD_Create (slot, filename, blocks, &CardFile);
+			if (CardError)
 			{
-                /*** Create new file ***/
+				CARD_Unmount (slot);
-                CardError = CARD_Create (slot, filename, blocks, &CardFile);
+				if ( CardError == CARD_ERROR_INSSPACE )
-                if (CardError)
+					WaitPrompt("Not enough space to create file!");
-                {
+				else
-                    CARD_Unmount (slot);
+					WaitPrompt("Unable to create card file!");
-                    if ( CardError == CARD_ERROR_INSSPACE )
+				return 0;
-                        WaitPrompt("Not enough space to create file!");
-                    else
-                        WaitPrompt("Unable to create card file!");
-                    return 0;
-                }
-            }
-
-			/*** Now, have an open file handle, ready to send out the data ***/
-			CARD_GetStatus (slot, CardFile.filenum, &CardStatus);
-			CardStatus.icon_addr = 0x0;
-			CardStatus.icon_fmt = 2;
-			CardStatus.icon_speed = 1;
-			CardStatus.comment_addr = 2048;
-			CARD_SetStatus (slot, CardFile.filenum, &CardStatus);
-
-			int byteswritten = 0;
-			int bytesleft = blocks;
-			while (bytesleft > 0)
-			{
-				CardError =
-					CARD_Write (&CardFile, buf + byteswritten,
-                                SectorSize, byteswritten);
-				bytesleft -= SectorSize;
-				byteswritten += SectorSize;
-
-                sprintf (msg, "Wrote %d of %d bytes", byteswritten, blocks);
-                ShowProgress (msg, byteswritten, blocks);
 			}
+		}
 
-			CARD_Close (&CardFile);
+		/*** Now, have an open file handle, ready to send out the data ***/
-			CARD_Unmount (slot);
+		CARD_GetStatus (slot, CardFile.filenum, &CardStatus);
+		CardStatus.icon_addr = 0x0;
+		CardStatus.icon_fmt = 2;
+		CardStatus.icon_speed = 1;
+		CardStatus.comment_addr = 2048;
+		CARD_SetStatus (slot, CardFile.filenum, &CardStatus);
 
-			if ( GCSettings.VerifySaves )
+		int byteswritten = 0;
-			{
+		int bytesleft = blocks;
-			    /*** Verify the written file, but only up to the length we wrote
+		while (bytesleft > 0)
-			         because the file could be longer due to past writes    ***/
+		{
-                if ( VerifyMCFile (buf, slot, filename, byteswritten) )
+			CardError =
-                    return byteswritten;
+				CARD_Write (&CardFile, buf + byteswritten,
-                else
+							SectorSize, byteswritten);
-                    return 0;
+			bytesleft -= SectorSize;
-            }
+			byteswritten += SectorSize;
-            else
+
-                return byteswritten;
+			sprintf (msg, "Wrote %d of %d bytes", byteswritten, blocks);
+			ShowProgress (msg, byteswritten, blocks);
+		}
+
+		CARD_Close (&CardFile);
+		CARD_Unmount (slot);
+
+		if ( GCSettings.VerifySaves )
+		{
+			/*** Verify the written file, but only up to the length we wrote
+				 because the file could be longer due to past writes    ***/
+			if ( VerifyMCFile (buf, slot, filename, byteswritten) )
+				return byteswritten;
+			else
+				return 0;
 		}
 		else
-			if ( !silent )
+			return byteswritten;
-				WaitPrompt("This game does not appear to use RAM");
 	}
 	else
 		if (slot == CARD_SLOTA)
@@ -415,5 +411,4 @@ SaveMCFile (char *buf, int slot, char *filename, int datasize, bool silent)
 			WaitPrompt("Unable to Mount Slot B Memory Card!");
 
 	return 0;
-
 }

source/ngc/menu.c

@@ -27,7 +27,7 @@
 #include "button_mapping.h"
 #include "filesel.h"
 #include "gcunzip.h"
-#include "smbop.h"
+#include "networkop.h"
 #include "memcardop.h"
 #include "fileop.h"
 #include "dvd.h"

source/ngc/menudraw.c

@@ -26,6 +26,7 @@
 #include "filesel.h"
 #include "dvd.h"
 #include "pad.h"
+#include "networkop.h"
 
 /*** Globals ***/
 FT_Library ftlibrary;
@@ -422,7 +423,9 @@ DrawMenu (char items[][50], const char *title, int maxitems, int selected, int f
 	}
 
 	setfontsize (12);
-	DrawText (510, screenheight - 40, VERSIONSTR);
+	char versionText[50];
+	sprintf(versionText, "%s %s", APPNAME, APPVERSION);
+	DrawText (510, screenheight - 40, versionText);
 
 	// Draw menu items
 
@@ -502,6 +505,14 @@ RunMenu (char items[][50], int maxitems, const char *title, int fontsize, int x)
     while (quit == 0)
     {
 		#ifdef HW_RVL
+    	if(updateFound)
+		{
+			updateFound = WaitPromptChoice("An update is available!", "Update later", "Update now");
+			if(updateFound)
+				if(DownloadUpdate())
+					ExitToLoader();
+		}
+
 		if(ShutdownRequested)
 			ShutdownWii();
 		#endif

source/ngc/networkop.c

@@ -0,0 +1,264 @@
+/****************************************************************************
+ * FCE Ultra 0.98.12
+ * Nintendo Wii/Gamecube Port
+ *
+ * Tantric December 2008
+ *
+ * networkop.cpp
+ *
+ * Network and SMB support routines
+ ****************************************************************************/
+
+#include <network.h>
+#include <smb.h>
+#include <mxml.h>
+
+#include "unzip.h"
+#include "miniunz.h"
+
+#include "fceugx.h"
+#include "menudraw.h"
+#include "fileop.h"
+#include "http.h"
+
+bool networkInit = false;
+bool autoNetworkInit = true;
+bool networkShareInit = false;
+bool updateChecked = false; // true if checked for app update
+static char updateURL[128]; // URL of app update
+bool updateFound = false; // true if an app update was found
+
+/****************************************************************************
+ * UpdateCheck
+ * Checks for an update for the application
+ ***************************************************************************/
+
+void UpdateCheck()
+{
+	// we can only check for the update if we have internet + SD
+	if(!updateChecked && networkInit && isMounted[METHOD_SD])
+	{
+		static char url[128];
+		int retval;
+
+		updateChecked = true;
+
+		snprintf(url, 128, "http://fceugc.googlecode.com/svn/trunk/update.xml");
+
+		AllocSaveBuffer ();
+		retval = http_request(url, NULL, (u8 *)savebuffer, SAVEBUFFERSIZE);
+		memset(url, 0, 128);
+
+		if (retval)
+		{
+			mxml_node_t *xml;
+			mxml_node_t *item;
+
+			xml = mxmlLoadString(NULL, (char *)savebuffer, MXML_TEXT_CALLBACK);
+
+			// check settings version
+			item = mxmlFindElement(xml, xml, "app", "version", NULL, MXML_DESCEND);
+			if(item) // a version entry exists
+			{
+				char * version = (char *)mxmlElementGetAttr(item, "version");
+
+				int verMajor = version[0] - '0';
+				int verMinor = version[2] - '0';
+				int verPoint = version[4] - '0';
+				int curMajor = APPVERSION[0] - '0';
+				int curMinor = APPVERSION[2] - '0';
+				int curPoint = APPVERSION[4] - '0';
+
+				// check that the versioning is valid and is a newer version
+				if((verMajor >= 0 && verMajor <= 9 &&
+					verMinor >= 0 && verMinor <= 9 &&
+					verPoint >= 0 && verPoint <= 9) &&
+					(verMajor > curMajor ||
+					verMinor > curMinor ||
+					verPoint > curPoint))
+				{
+					item = mxmlFindElement(xml, xml, "file", NULL, NULL, MXML_DESCEND);
+					if(item)
+					{
+						snprintf(updateURL, 128, "%s", mxmlElementGetAttr(item, "url"));
+						updateFound = true;
+					}
+				}
+			}
+		}
+		FreeSaveBuffer();
+	}
+}
+
+bool unzipArchive(char * zipfilepath, char * unzipfolderpath)
+{
+	unzFile uf = unzOpen(zipfilepath);
+	if (uf==NULL)
+		return false;
+
+	if(chdir(unzipfolderpath)) // can't access dir
+	{
+		makedir(unzipfolderpath); // attempt to make dir
+		if(chdir(unzipfolderpath)) // still can't access dir
+			return false;
+	}
+
+	extractZip(uf,0,1,0);
+
+	unzCloseCurrentFile(uf);
+	return true;
+}
+
+bool DownloadUpdate()
+{
+	bool result = false;
+	if(strlen(updateURL) > 0)
+	{
+		// stop checking if devices were removed/inserted
+		// since we're saving a file
+		LWP_SuspendThread (devicethread);
+
+		FILE * hfile;
+		char updateFile[50];
+		sprintf(updateFile, "sd:/%s Update.zip", APPNAME);
+		hfile = fopen (updateFile, "wb");
+
+		if (hfile > 0)
+		{
+			int retval;
+			retval = http_request(updateURL, hfile, NULL, (1024*1024*5));
+			fclose (hfile);
+		}
+		ShowAction("Unzipping...");
+		bool unzipResult = unzipArchive(updateFile, (char *)"sd:/");
+		remove(updateFile); // delete update file
+
+		if(unzipResult)
+		{
+			result = true;
+			WaitPrompt("Update successful!");
+		}
+		else
+		{
+			result = false;
+			WaitPrompt("Update failed!");
+		}
+
+		updateFound = false; // updating is finished (successful or not!)
+
+		// go back to checking if devices were inserted/removed
+		LWP_ResumeThread (devicethread);
+	}
+	return result;
+}
+
+/****************************************************************************
+ * InitializeNetwork
+ * Initializes the Wii/GameCube network interface
+ ***************************************************************************/
+
+void InitializeNetwork(bool silent)
+{
+	// stop if we're already initialized, or if auto-init has failed before
+	// in which case, manual initialization is required
+	if(networkInit || !autoNetworkInit)
+		return;
+
+	if(!silent)
+		ShowAction ("Initializing network...");
+
+	char ip[16];
+	s32 initResult = if_config(ip, NULL, NULL, true);
+
+	if(initResult == 0)
+	{
+		networkInit = true;
+	}
+	else
+	{
+		// do not automatically attempt a reconnection
+		autoNetworkInit = false;
+
+		if(!silent)
+		{
+			char msg[150];
+			sprintf(msg, "Unable to initialize network (Error #: %i)", initResult);
+			WaitPrompt(msg);
+		}
+	}
+}
+
+void CloseShare()
+{
+	if(networkShareInit)
+		smbClose();
+	networkShareInit = false;
+}
+
+/****************************************************************************
+ * Mount SMB Share
+ ****************************************************************************/
+
+bool
+ConnectShare (bool silent)
+{
+	// Crashes or stalls system in GameCube mode - so disable
+	#ifndef HW_RVL
+	return false;
+	#endif
+
+	int chkU = (strlen(GCSettings.smbuser) > 0) ? 0:1;
+	int chkP = (strlen(GCSettings.smbpwd) > 0) ? 0:1;
+	int chkS = (strlen(GCSettings.smbshare) > 0) ? 0:1;
+	int chkI = (strlen(GCSettings.smbip) > 0) ? 0:1;
+
+	// check that all parameters have been set
+	if(chkU + chkP + chkS + chkI > 0)
+	{
+		if(!silent)
+		{
+			char msg[50];
+			char msg2[100];
+			if(chkU + chkP + chkS + chkI > 1) // more than one thing is wrong
+				sprintf(msg, "Check settings.xml.");
+			else if(chkU)
+				sprintf(msg, "Username is blank.");
+			else if(chkP)
+				sprintf(msg, "Password is blank.");
+			else if(chkS)
+				sprintf(msg, "Share name is blank.");
+			else if(chkI)
+				sprintf(msg, "Share IP is blank.");
+
+			sprintf(msg2, "Invalid network settings - %s", msg);
+			WaitPrompt(msg2);
+		}
+		return false;
+	}
+
+	if(!networkInit)
+		InitializeNetwork(silent);
+
+	if(networkInit)
+	{
+		if(unmountRequired[METHOD_SMB])
+			CloseShare();
+
+		if(!networkShareInit)
+		{
+			if(!silent)
+				ShowAction ("Connecting to network share...");
+
+			if(smbInit(GCSettings.smbuser, GCSettings.smbpwd,
+					GCSettings.smbshare, GCSettings.smbip))
+			{
+				networkShareInit = true;
+			}
+		}
+
+		if(!networkShareInit && !silent)
+			WaitPrompt ("Failed to connect to network share.");
+	}
+
+	return networkShareInit;
+}

source/ngc/networkop.h

@@ -2,18 +2,22 @@
  * FCE Ultra 0.98.12
  * Nintendo Wii/Gamecube Port
  *
- * Tantric September 2008
+ * Tantric December 2008
  *
- * smbop.h
+ * networkop.h
  *
- * SMB support routines
+ * Network and SMB support routines
  ****************************************************************************/
 
-#ifndef _NGCSMB_
+#ifndef _NETWORKOP_H_
-#define _NGCSMB_
+#define _NETWORKOP_H_
 
+void UpdateCheck();
+bool DownloadUpdate();
 void InitializeNetwork(bool silent);
 bool ConnectShare (bool silent);
 void CloseShare();
 
+extern bool updateFound;
+
 #endif

source/ngc/preferences.c

@@ -131,7 +131,7 @@ preparePrefsData (int method)
 		memcpy (savebuffer, saveicon, offset);
 
 		// And the comments
-		sprintf (prefscomment[0], "%s Prefs", VERSIONSTR);
+		sprintf (prefscomment[0], "%s Prefs", APPNAME);
 		sprintf (prefscomment[1], "Preferences");
 		memcpy (savebuffer + offset, prefscomment, 64);
 		offset += 64;
@@ -141,7 +141,8 @@ preparePrefsData (int method)
 	mxmlSetWrapMargin(0); // disable line wrapping
 
 	data = mxmlNewElement(xml, "file");
-	mxmlElementSetAttr(data, "version",VERSIONSTR);
+	mxmlElementSetAttr(data, "app",APPNAME);
+	mxmlElementSetAttr(data, "version",APPVERSION);
 
 	createXMLSection("File", "File Settings");
 
@@ -151,7 +152,7 @@ preparePrefsData (int method)
 	createXMLSetting("SaveMethod", "Save Method", toStr(GCSettings.SaveMethod));
 	createXMLSetting("LoadFolder", "Load Folder", GCSettings.LoadFolder);
 	createXMLSetting("SaveFolder", "Save Folder", GCSettings.SaveFolder);
-	createXMLSetting("CheatFolder", "Cheats Folder", GCSettings.CheatFolder);
+	//createXMLSetting("CheatFolder", "Cheats Folder", GCSettings.CheatFolder);
 	createXMLSetting("VerifySaves", "Verify Memory Card Saves", toStr(GCSettings.VerifySaves));
 
 	createXMLSection("Network", "Network Settings");
@@ -193,11 +194,11 @@ preparePrefsData (int method)
 /****************************************************************************
  * Decode Preferences Data
  ****************************************************************************/
-void loadXMLSettingStr(char * var, const char * name)
+void loadXMLSettingStr(char * var, const char * name, int maxsize)
 {
 	item = mxmlFindElement(xml, xml, "setting", "name", name, MXML_DESCEND);
 	if(item)
-		sprintf(var, "%s", mxmlElementGetAttr(item, "value"));
+		snprintf(var, maxsize, "%s", mxmlElementGetAttr(item, "value"));
 }
 void loadXMLSettingInt(int * var, const char * name)
 {
@@ -261,13 +262,22 @@ decodePrefsData (int method)
 
 	// this code assumes version in format X.X.X
 	// XX.X.X, X.XX.X, or X.X.XX will NOT work
-	char verMajor = version[13];
+	int verMajor = version[0] - '0';
-	char verMinor = version[15];
+	int verMinor = version[2] - '0';
-	char verPoint = version[17];
+	int verPoint = version[4] - '0';
+	int curMajor = APPVERSION[0] - '0';
+	int curMinor = APPVERSION[2] - '0';
+	int curPoint = APPVERSION[4] - '0';
 
-	if(verMajor == '2' && verPoint < '7') // less than version 2.0.7
+	// first we'll check that the versioning is valid
+	if(!(verMajor >= 0 && verMajor <= 9 &&
+		verMinor >= 0 && verMinor <= 9 &&
+		verPoint >= 0 && verPoint <= 9))
+		return false;
+
+	if(verMajor == 2 && verPoint < 7) // less than version 2.0.7
 		return false; // reset settings
-	else if(verMajor > '2' || verMinor > '0' || verPoint > '7') // some future version
+	else if(verMajor > curMajor || verMinor > curMinor || verPoint > curPoint) // some future version
 		return false; // reset settings
 
 	// File Settings
@@ -276,17 +286,17 @@ decodePrefsData (int method)
 	loadXMLSettingInt(&GCSettings.AutoSave, "AutoSave");
 	loadXMLSettingInt(&GCSettings.LoadMethod, "LoadMethod");
 	loadXMLSettingInt(&GCSettings.SaveMethod, "SaveMethod");
-	loadXMLSettingStr(GCSettings.LoadFolder, "LoadFolder");
+	loadXMLSettingStr(GCSettings.LoadFolder, "LoadFolder", sizeof(GCSettings.LoadFolder));
-	loadXMLSettingStr(GCSettings.SaveFolder, "SaveFolder");
+	loadXMLSettingStr(GCSettings.SaveFolder, "SaveFolder", sizeof(GCSettings.SaveFolder));
-	loadXMLSettingStr(GCSettings.CheatFolder, "CheatFolder");
+	//loadXMLSettingStr(GCSettings.CheatFolder, "CheatFolder", sizeof(GCSettings.CheatFolder));
 	loadXMLSettingInt(&GCSettings.VerifySaves, "VerifySaves");
 
 	// Network Settings
 
-	loadXMLSettingStr(GCSettings.smbip, "smbip");
+	loadXMLSettingStr(GCSettings.smbip, "smbip", sizeof(GCSettings.smbip));
-	loadXMLSettingStr(GCSettings.smbshare, "smbshare");
+	loadXMLSettingStr(GCSettings.smbshare, "smbshare", sizeof(GCSettings.smbshare));
-	loadXMLSettingStr(GCSettings.smbuser, "smbuser");
+	loadXMLSettingStr(GCSettings.smbuser, "smbuser", sizeof(GCSettings.smbuser));
-	loadXMLSettingStr(GCSettings.smbpwd, "smbpwd");
+	loadXMLSettingStr(GCSettings.smbpwd, "smbpwd", sizeof(GCSettings.smbpwd));
 
 	// Emulation Settings
 

source/ngc/smbop.c

@@ -1,132 +0,0 @@
-/****************************************************************************
- * FCE Ultra 0.98.12
- * Nintendo Wii/Gamecube Port
- *
- * Tantric September 2008
- *
- * smbload.c
- *
- * SMB support routines
- ****************************************************************************/
-
-#include <network.h>
-#include <smb.h>
-
-#include "fceugx.h"
-#include "fileop.h"
-#include "menudraw.h"
-
-bool networkInit = false;
-bool autoNetworkInit = true;
-bool networkShareInit = false;
-
-/****************************************************************************
- * InitializeNetwork
- * Initializes the Wii/GameCube network interface
- ****************************************************************************/
-
-void InitializeNetwork(bool silent)
-{
-	// stop if we're already initialized, or if auto-init has failed before
-	// in which case, manual initialization is required
-	if(networkInit || !autoNetworkInit)
-		return;
-
-	if(!silent)
-		ShowAction ("Initializing network...");
-
-	char ip[16];
-	s32 initResult = if_config(ip, NULL, NULL, true);
-
-	if(initResult == 0)
-	{
-		networkInit = true;
-	}
-	else
-	{
-		// do not automatically attempt a reconnection
-		autoNetworkInit = false;
-
-		if(!silent)
-		{
-			char msg[150];
-			sprintf(msg, "Unable to initialize network (Error #: %i)", initResult);
-			WaitPrompt(msg);
-		}
-	}
-}
-
-void CloseShare()
-{
-	if(networkShareInit)
-		smbClose();
-	networkShareInit = false;
-}
-
-/****************************************************************************
- * Mount SMB Share
- ****************************************************************************/
-
-bool
-ConnectShare (bool silent)
-{
-	// Crashes or stalls system in GameCube mode - so disable
-	#ifndef HW_RVL
-	return false;
-	#endif
-
-	int chkU = (strlen(GCSettings.smbuser) > 0) ? 0:1;
-	int chkP = (strlen(GCSettings.smbpwd) > 0) ? 0:1;
-	int chkS = (strlen(GCSettings.smbshare) > 0) ? 0:1;
-	int chkI = (strlen(GCSettings.smbip) > 0) ? 0:1;
-
-	// check that all parameters have been set
-	if(chkU + chkP + chkS + chkI > 0)
-	{
-		if(!silent)
-		{
-			char msg[50];
-			char msg2[100];
-			if(chkU + chkP + chkS + chkI > 1) // more than one thing is wrong
-				sprintf(msg, "Check settings.xml.");
-			else if(chkU)
-				sprintf(msg, "Username is blank.");
-			else if(chkP)
-				sprintf(msg, "Password is blank.");
-			else if(chkS)
-				sprintf(msg, "Share name is blank.");
-			else if(chkI)
-				sprintf(msg, "Share IP is blank.");
-
-			sprintf(msg2, "Invalid network settings - %s", msg);
-			WaitPrompt(msg2);
-		}
-		return false;
-	}
-
-	if(!networkInit)
-		InitializeNetwork(silent);
-
-	if(networkInit)
-	{
-		if(unmountRequired[METHOD_SMB])
-			CloseShare();
-
-		if(!networkShareInit)
-		{
-			if(!silent)
-				ShowAction ("Connecting to network share...");
-
-			if(smbInit(GCSettings.smbuser, GCSettings.smbpwd,
-					GCSettings.smbshare, GCSettings.smbip))
-			{
-				networkShareInit = true;
-			}
-		}
-
-		if(!networkShareInit && !silent)
-			WaitPrompt ("Failed to connect to network share.");
-	}
-
-	return networkShareInit;
-}

source/unzip/crypt.h

@@ -0,0 +1,132 @@
+/* crypt.h -- base code for crypt/uncrypt ZIPfile
+
+
+   Version 1.01e, February 12th, 2005
+
+   Copyright (C) 1998-2005 Gilles Vollant
+
+   This code is a modified version of crypting code in Infozip distribution
+
+   The encryption/decryption parts of this source code (as opposed to the
+   non-echoing password parts) were originally written in Europe.  The
+   whole source package can be freely distributed, including from the USA.
+   (Prior to January 2000, re-export from the US was a violation of US law.)
+
+   This encryption code is a direct transcription of the algorithm from
+   Roger Schlafly, described by Phil Katz in the file appnote.txt.  This
+   file (appnote.txt) is distributed with the PKZIP program (even in the
+   version without encryption capabilities).
+
+   If you don't need crypting in your application, just define symbols
+   NOCRYPT and NOUNCRYPT.
+
+   This code support the "Traditional PKWARE Encryption".
+
+   The new AES encryption added on Zip format by Winzip (see the page
+   http://www.winzip.com/aes_info.htm ) and PKWare PKZip 5.x Strong
+   Encryption is not supported.
+*/
+
+#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8))
+
+/***********************************************************************
+ * Return the next byte in the pseudo-random sequence
+ */
+static int decrypt_byte(unsigned long* pkeys, const unsigned long* pcrc_32_tab)
+{
+    unsigned temp;  /* POTENTIAL BUG:  temp*(temp^1) may overflow in an
+                     * unpredictable manner on 16-bit systems; not a problem
+                     * with any known compiler so far, though */
+
+    temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2;
+    return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);
+}
+
+/***********************************************************************
+ * Update the encryption keys with the next byte of plain text
+ */
+static int update_keys(unsigned long* pkeys,const unsigned long* pcrc_32_tab,int c)
+{
+    (*(pkeys+0)) = CRC32((*(pkeys+0)), c);
+    (*(pkeys+1)) += (*(pkeys+0)) & 0xff;
+    (*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1;
+    {
+      register int keyshift = (int)((*(pkeys+1)) >> 24);
+      (*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift);
+    }
+    return c;
+}
+
+
+/***********************************************************************
+ * Initialize the encryption keys and the random header according to
+ * the given password.
+ */
+static void init_keys(const char* passwd,unsigned long* pkeys,const unsigned long* pcrc_32_tab)
+{
+    *(pkeys+0) = 305419896L;
+    *(pkeys+1) = 591751049L;
+    *(pkeys+2) = 878082192L;
+    while (*passwd != '\0') {
+        update_keys(pkeys,pcrc_32_tab,(int)*passwd);
+        passwd++;
+    }
+}
+
+#define zdecode(pkeys,pcrc_32_tab,c) \
+    (update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab)))
+
+#define zencode(pkeys,pcrc_32_tab,c,t) \
+    (t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c))
+
+#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED
+
+#define RAND_HEAD_LEN  12
+   /* "last resort" source for second part of crypt seed pattern */
+#  ifndef ZCR_SEED2
+#    define ZCR_SEED2 3141592654UL     /* use PI as default pattern */
+#  endif
+
+static int crypthead(passwd, buf, bufSize, pkeys, pcrc_32_tab, crcForCrypting)
+    const char *passwd;         /* password string */
+    unsigned char *buf;         /* where to write header */
+    int bufSize;
+    unsigned long* pkeys;
+    const unsigned long* pcrc_32_tab;
+    unsigned long crcForCrypting;
+{
+    int n;                       /* index in random header */
+    int t;                       /* temporary */
+    int c;                       /* random byte */
+    unsigned char header[RAND_HEAD_LEN-2]; /* random header */
+    static unsigned calls = 0;   /* ensure different random header each time */
+
+    if (bufSize<RAND_HEAD_LEN)
+      return 0;
+
+    /* First generate RAND_HEAD_LEN-2 random bytes. We encrypt the
+     * output of rand() to get less predictability, since rand() is
+     * often poorly implemented.
+     */
+    if (++calls == 1)
+    {
+        srand((unsigned)(time(NULL) ^ ZCR_SEED2));
+    }
+    init_keys(passwd, pkeys, pcrc_32_tab);
+    for (n = 0; n < RAND_HEAD_LEN-2; n++)
+    {
+        c = (rand() >> 7) & 0xff;
+        header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t);
+    }
+    /* Encrypt random header (last two bytes is high word of crc) */
+    init_keys(passwd, pkeys, pcrc_32_tab);
+    for (n = 0; n < RAND_HEAD_LEN-2; n++)
+    {
+        buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t);
+    }
+    buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t);
+    buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t);
+    return n;
+}
+
+#endif

source/unzip/ioapi.c

@@ -0,0 +1,177 @@
+/* ioapi.c -- IO base function header for compress/uncompress .zip
+   files using zlib + zip or unzip API
+
+   Version 1.01e, February 12th, 2005
+
+   Copyright (C) 1998-2005 Gilles Vollant
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "zlib.h"
+#include "ioapi.h"
+
+
+
+/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
+
+#ifndef SEEK_CUR
+#define SEEK_CUR    1
+#endif
+
+#ifndef SEEK_END
+#define SEEK_END    2
+#endif
+
+#ifndef SEEK_SET
+#define SEEK_SET    0
+#endif
+
+voidpf ZCALLBACK fopen_file_func OF((
+   voidpf opaque,
+   const char* filename,
+   int mode));
+
+uLong ZCALLBACK fread_file_func OF((
+   voidpf opaque,
+   voidpf stream,
+   void* buf,
+   uLong size));
+
+uLong ZCALLBACK fwrite_file_func OF((
+   voidpf opaque,
+   voidpf stream,
+   const void* buf,
+   uLong size));
+
+long ZCALLBACK ftell_file_func OF((
+   voidpf opaque,
+   voidpf stream));
+
+long ZCALLBACK fseek_file_func OF((
+   voidpf opaque,
+   voidpf stream,
+   uLong offset,
+   int origin));
+
+int ZCALLBACK fclose_file_func OF((
+   voidpf opaque,
+   voidpf stream));
+
+int ZCALLBACK ferror_file_func OF((
+   voidpf opaque,
+   voidpf stream));
+
+
+voidpf ZCALLBACK fopen_file_func (opaque, filename, mode)
+   voidpf opaque;
+   const char* filename;
+   int mode;
+{
+    FILE* file = NULL;
+    const char* mode_fopen = NULL;
+    if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
+        mode_fopen = "rb";
+    else
+    if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
+        mode_fopen = "r+b";
+    else
+    if (mode & ZLIB_FILEFUNC_MODE_CREATE)
+        mode_fopen = "wb";
+
+    if ((filename!=NULL) && (mode_fopen != NULL))
+        file = fopen(filename, mode_fopen);
+    return file;
+}
+
+
+uLong ZCALLBACK fread_file_func (opaque, stream, buf, size)
+   voidpf opaque;
+   voidpf stream;
+   void* buf;
+   uLong size;
+{
+    uLong ret;
+    ret = (uLong)fread(buf, 1, (size_t)size, (FILE *)stream);
+    return ret;
+}
+
+
+uLong ZCALLBACK fwrite_file_func (opaque, stream, buf, size)
+   voidpf opaque;
+   voidpf stream;
+   const void* buf;
+   uLong size;
+{
+    uLong ret;
+    ret = (uLong)fwrite(buf, 1, (size_t)size, (FILE *)stream);
+    return ret;
+}
+
+long ZCALLBACK ftell_file_func (opaque, stream)
+   voidpf opaque;
+   voidpf stream;
+{
+    long ret;
+    ret = ftell((FILE *)stream);
+    return ret;
+}
+
+long ZCALLBACK fseek_file_func (opaque, stream, offset, origin)
+   voidpf opaque;
+   voidpf stream;
+   uLong offset;
+   int origin;
+{
+    int fseek_origin=0;
+    long ret;
+    switch (origin)
+    {
+    case ZLIB_FILEFUNC_SEEK_CUR :
+        fseek_origin = SEEK_CUR;
+        break;
+    case ZLIB_FILEFUNC_SEEK_END :
+        fseek_origin = SEEK_END;
+        break;
+    case ZLIB_FILEFUNC_SEEK_SET :
+        fseek_origin = SEEK_SET;
+        break;
+    default: return -1;
+    }
+    ret = 0;
+    fseek((FILE *)stream, offset, fseek_origin);
+    return ret;
+}
+
+int ZCALLBACK fclose_file_func (opaque, stream)
+   voidpf opaque;
+   voidpf stream;
+{
+    int ret;
+    ret = fclose((FILE *)stream);
+    return ret;
+}
+
+int ZCALLBACK ferror_file_func (opaque, stream)
+   voidpf opaque;
+   voidpf stream;
+{
+    int ret;
+    ret = ferror((FILE *)stream);
+    return ret;
+}
+
+void fill_fopen_filefunc (pzlib_filefunc_def)
+  zlib_filefunc_def* pzlib_filefunc_def;
+{
+    pzlib_filefunc_def->zopen_file = fopen_file_func;
+    pzlib_filefunc_def->zread_file = fread_file_func;
+    pzlib_filefunc_def->zwrite_file = fwrite_file_func;
+    pzlib_filefunc_def->ztell_file = ftell_file_func;
+    pzlib_filefunc_def->zseek_file = fseek_file_func;
+    pzlib_filefunc_def->zclose_file = fclose_file_func;
+    pzlib_filefunc_def->zerror_file = ferror_file_func;
+    pzlib_filefunc_def->opaque = NULL;
+}

source/unzip/ioapi.h

@@ -0,0 +1,75 @@
+/* ioapi.h -- IO base function header for compress/uncompress .zip
+   files using zlib + zip or unzip API
+
+   Version 1.01e, February 12th, 2005
+
+   Copyright (C) 1998-2005 Gilles Vollant
+*/
+
+#ifndef _ZLIBIOAPI_H
+#define _ZLIBIOAPI_H
+
+
+#define ZLIB_FILEFUNC_SEEK_CUR (1)
+#define ZLIB_FILEFUNC_SEEK_END (2)
+#define ZLIB_FILEFUNC_SEEK_SET (0)
+
+#define ZLIB_FILEFUNC_MODE_READ      (1)
+#define ZLIB_FILEFUNC_MODE_WRITE     (2)
+#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3)
+
+#define ZLIB_FILEFUNC_MODE_EXISTING (4)
+#define ZLIB_FILEFUNC_MODE_CREATE   (8)
+
+
+#ifndef ZCALLBACK
+
+#if (defined(WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK)
+#define ZCALLBACK CALLBACK
+#else
+#define ZCALLBACK
+#endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef voidpf (ZCALLBACK *open_file_func) OF((voidpf opaque, const char* filename, int mode));
+typedef uLong  (ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void* buf, uLong size));
+typedef uLong  (ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void* buf, uLong size));
+typedef long   (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream));
+typedef long   (ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin));
+typedef int    (ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream));
+typedef int    (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream));
+
+typedef struct zlib_filefunc_def_s
+{
+    open_file_func      zopen_file;
+    read_file_func      zread_file;
+    write_file_func     zwrite_file;
+    tell_file_func      ztell_file;
+    seek_file_func      zseek_file;
+    close_file_func     zclose_file;
+    testerror_file_func zerror_file;
+    voidpf              opaque;
+} zlib_filefunc_def;
+
+
+
+void fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
+
+#define ZREAD(filefunc,filestream,buf,size) ((*((filefunc).zread_file))((filefunc).opaque,filestream,buf,size))
+#define ZWRITE(filefunc,filestream,buf,size) ((*((filefunc).zwrite_file))((filefunc).opaque,filestream,buf,size))
+#define ZTELL(filefunc,filestream) ((*((filefunc).ztell_file))((filefunc).opaque,filestream))
+#define ZSEEK(filefunc,filestream,pos,mode) ((*((filefunc).zseek_file))((filefunc).opaque,filestream,pos,mode))
+#define ZCLOSE(filefunc,filestream) ((*((filefunc).zclose_file))((filefunc).opaque,filestream))
+#define ZERROR(filefunc,filestream) ((*((filefunc).zerror_file))((filefunc).opaque,filestream))
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+

source/unzip/miniunz.c

@@ -0,0 +1,276 @@
+/*
+   miniunz.c
+   Version 1.01e, February 12th, 2005
+
+   Copyright (C) 1998-2005 Gilles Vollant
+*/
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <errno.h>
+#include <fcntl.h>
+# include <unistd.h>
+# include <utime.h>
+
+#include "unzip.h"
+
+#define CASESENSITIVITY (0)
+#define WRITEBUFFERSIZE (1024*256)
+#define MAXFILENAME (256)
+
+static int mymkdir(const char* dirname)
+{
+    int ret=0;
+    ret = mkdir (dirname,0775);
+    return ret;
+}
+
+int makedir (char *newdir)
+{
+  char *buffer ;
+  char *p;
+  int  len = (int)strlen(newdir);
+
+  if (len <= 0)
+    return 0;
+
+  buffer = (char*)malloc(len+1);
+  strcpy(buffer,newdir);
+
+  if (buffer[len-1] == '/') {
+    buffer[len-1] = '\0';
+  }
+  if (mymkdir(buffer) == 0)
+    {
+      free(buffer);
+      return 1;
+    }
+
+  p = buffer+1;
+  while (1)
+    {
+      char hold;
+
+      while(*p && *p != '\\' && *p != '/')
+        p++;
+      hold = *p;
+      *p = 0;
+      if ((mymkdir(buffer) == -1) && (errno == ENOENT))
+        {
+          //printf("couldn't create directory %s\n",buffer);
+          free(buffer);
+          return 0;
+        }
+      if (hold == 0)
+        break;
+      *p++ = hold;
+    }
+  free(buffer);
+  return 1;
+}
+
+static int do_extract_currentfile(unzFile uf,const int* popt_extract_without_path,int* popt_overwrite,const char* password)
+{
+    char filename_inzip[256];
+    char* filename_withoutpath;
+    char* p;
+    int err=UNZ_OK;
+    FILE *fout=NULL;
+    void* buf;
+    uInt size_buf;
+
+    unz_file_info file_info;
+    err = unzGetCurrentFileInfo(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0);
+
+    if (err!=UNZ_OK)
+    {
+        //printf("error %d with zipfile in unzGetCurrentFileInfo\n",err);
+        return err;
+    }
+
+    size_buf = WRITEBUFFERSIZE;
+    buf = (void*)malloc(size_buf);
+    if (buf==NULL)
+    {
+        //printf("Error allocating memory\n");
+        return UNZ_INTERNALERROR;
+    }
+
+    p = filename_withoutpath = filename_inzip;
+    while ((*p) != '\0')
+    {
+        if (((*p)=='/') || ((*p)=='\\'))
+            filename_withoutpath = p+1;
+        p++;
+    }
+
+    if ((*filename_withoutpath)=='\0')
+    {
+        if ((*popt_extract_without_path)==0)
+        {
+            //printf("creating directory: %s\n",filename_inzip);
+            mymkdir(filename_inzip);
+        }
+    }
+    else
+    {
+        char* write_filename;
+        int skip=0;
+
+        if ((*popt_extract_without_path)==0)
+            write_filename = filename_inzip;
+        else
+            write_filename = filename_withoutpath;
+
+        err = unzOpenCurrentFilePassword(uf,password);
+        if (err!=UNZ_OK)
+        {
+            //printf("error %d with zipfile in unzOpenCurrentFilePassword\n",err);
+        }
+
+        if (((*popt_overwrite)==0) && (err==UNZ_OK))
+        {
+            char rep=0;
+            FILE* ftestexist;
+            ftestexist = fopen(write_filename,"rb");
+            if (ftestexist!=NULL)
+            {
+                fclose(ftestexist);
+                do
+                {
+                    char answer[128];
+                    int ret;
+
+                    printf("The file %s exists. Overwrite ? [y]es, [n]o, [A]ll: ",write_filename);
+                    ret = scanf("%1s",answer);
+                    if (ret != 1)
+                    {
+                       exit(EXIT_FAILURE);
+                    }
+                    rep = answer[0] ;
+                    if ((rep>='a') && (rep<='z'))
+                        rep -= 0x20;
+                }
+                while ((rep!='Y') && (rep!='N') && (rep!='A'));
+            }
+
+            if (rep == 'N')
+                skip = 1;
+
+            if (rep == 'A')
+                *popt_overwrite=1;
+        }
+
+        if ((skip==0) && (err==UNZ_OK))
+        {
+            fout=fopen(write_filename,"wb");
+
+            /* some zipfile don't contain directory alone before file */
+            if ((fout==NULL) && ((*popt_extract_without_path)==0) &&
+                                (filename_withoutpath!=(char*)filename_inzip))
+            {
+                char c=*(filename_withoutpath-1);
+                *(filename_withoutpath-1)='\0';
+                makedir(write_filename);
+                *(filename_withoutpath-1)=c;
+                fout=fopen(write_filename,"wb");
+            }
+
+            if (fout==NULL)
+            {
+                //printf("error opening %s\n",write_filename);
+            }
+        }
+
+        if (fout!=NULL)
+        {
+            //printf(" extracting: %s\n",write_filename);
+
+            do
+            {
+                err = unzReadCurrentFile(uf,buf,size_buf);
+                if (err<0)
+                {
+                    //printf("error %d with zipfile in unzReadCurrentFile\n",err);
+                    break;
+                }
+                if (err>0)
+                    if (fwrite(buf,err,1,fout)!=1)
+                    {
+                        //printf("error in writing extracted file\n");
+                        err=UNZ_ERRNO;
+                        break;
+                    }
+            }
+            while (err>0);
+            if (fout)
+                    fclose(fout);
+
+        }
+
+        if (err==UNZ_OK)
+        {
+            err = unzCloseCurrentFile (uf);
+            if (err!=UNZ_OK)
+            {
+                //printf("error %d with zipfile in unzCloseCurrentFile\n",err);
+            }
+        }
+        else
+            unzCloseCurrentFile(uf); /* don't lose the error */
+    }
+
+    free(buf);
+    return err;
+}
+
+
+int extractZip(unzFile uf,int opt_extract_without_path,int opt_overwrite,const char* password)
+{
+    uLong i;
+    unz_global_info gi;
+    int err;
+
+    err = unzGetGlobalInfo (uf,&gi);
+    //if (err!=UNZ_OK)
+    //    printf("error %d with zipfile in unzGetGlobalInfo \n",err);
+
+    for (i=0;i<gi.number_entry;i++)
+    {
+        if (do_extract_currentfile(uf,&opt_extract_without_path,
+                                      &opt_overwrite,
+                                      password) != UNZ_OK)
+            break;
+
+        if ((i+1)<gi.number_entry)
+        {
+            err = unzGoToNextFile(uf);
+            if (err!=UNZ_OK)
+            {
+                //printf("error %d with zipfile in unzGoToNextFile\n",err);
+                break;
+            }
+        }
+    }
+
+    return 0;
+}
+
+int extractZipOnefile(unzFile uf,const char* filename,int opt_extract_without_path,int opt_overwrite,const char* password)
+{
+    if (unzLocateFile(uf,filename,CASESENSITIVITY)!=UNZ_OK)
+    {
+        //printf("file %s not found in the zipfile\n",filename);
+        return 2;
+    }
+
+    if (do_extract_currentfile(uf,&opt_extract_without_path,
+                                      &opt_overwrite,
+                                      password) == UNZ_OK)
+        return 0;
+    else
+        return 1;
+}

source/unzip/miniunz.h

@@ -0,0 +1,17 @@
+
+#ifndef _miniunz_H
+#define _miniunz_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int extractZip(unzFile uf,int opt_extract_without_path,int opt_overwrite,const char* password);
+int extractZipOnefile(unzFile uf,const char* filename,int opt_extract_without_path,int opt_overwrite,const char* password);
+int makedir(char *newdir);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

source/unzip/unzip.h

@@ -1,275 +1,354 @@
-/* unzip.h -- IO for uncompress .zip files using zlib 
+/* unzip.h -- IO for uncompress .zip files using zlib
-   Version 0.15 beta, Mar 19th, 1998,
+   Version 1.01e, February 12th, 2005
-
+
-   Copyright (C) 1998 Gilles Vollant
+   Copyright (C) 1998-2005 Gilles Vollant
-
+
-   This unzip package allow extract file from .ZIP file, compatible with PKZip 2.04g
+   This unzip package allow extract file from .ZIP file, compatible with PKZip 2.04g
-     WinZip, InfoZip tools and compatible.
+     WinZip, InfoZip tools and compatible.
-   Encryption and multi volume ZipFile (span) are not supported.
+
-   Old compressions used by old PKZip 1.x are not supported
+   Multi volume ZipFile (span) are not supported.
-
+   Encryption compatible with pkzip 2.04g only supported
-   THIS IS AN ALPHA VERSION. AT THIS STAGE OF DEVELOPPEMENT, SOMES API OR STRUCTURE
+   Old compressions used by old PKZip 1.x are not supported
-   CAN CHANGE IN FUTURE VERSION !!
+
-   I WAIT FEEDBACK at mail info@winimage.com
+
-   Visit also http://www.winimage.com/zLibDll/unzip.htm for evolution
+   I WAIT FEEDBACK at mail info@winimage.com
-
+   Visit also http://www.winimage.com/zLibDll/unzip.htm for evolution
-   Condition of use and distribution are the same than zlib :
+
-
+   Condition of use and distribution are the same than zlib :
-  This software is provided 'as-is', without any express or implied
+
-  warranty.  In no event will the authors be held liable for any damages
+  This software is provided 'as-is', without any express or implied
-  arising from the use of this software.
+  warranty.  In no event will the authors be held liable for any damages
-
+  arising from the use of this software.
-  Permission is granted to anyone to use this software for any purpose,
+
-  including commercial applications, and to alter it and redistribute it
+  Permission is granted to anyone to use this software for any purpose,
-  freely, subject to the following restrictions:
+  including commercial applications, and to alter it and redistribute it
-
+  freely, subject to the following restrictions:
-  1. The origin of this software must not be misrepresented; you must not
+
-     claim that you wrote the original software. If you use this software
+  1. The origin of this software must not be misrepresented; you must not
-     in a product, an acknowledgment in the product documentation would be
+     claim that you wrote the original software. If you use this software
-     appreciated but is not required.
+     in a product, an acknowledgment in the product documentation would be
-  2. Altered source versions must be plainly marked as such, and must not be
+     appreciated but is not required.
-     misrepresented as being the original software.
+  2. Altered source versions must be plainly marked as such, and must not be
-  3. This notice may not be removed or altered from any source distribution.
+     misrepresented as being the original software.
-
+  3. This notice may not be removed or altered from any source distribution.
-
+
-*/
+
-/* for more info about .ZIP format, see 
+*/
-      ftp://ftp.cdrom.com/pub/infozip/doc/appnote-970311-iz.zip
+
-   PkWare has also a specification at :
+/* for more info about .ZIP format, see
-      ftp://ftp.pkware.com/probdesc.zip */
+      http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip
-
+      http://www.info-zip.org/pub/infozip/doc/
-#ifndef _unz_H
+   PkWare has also a specification at :
-#define _unz_H
+      ftp://ftp.pkware.com/probdesc.zip
-
+*/
-#ifdef __cplusplus
+
-extern "C" {
+#ifndef _unz_H
-#endif
+#define _unz_H
-
+
-#ifndef _ZLIB_H
+#ifdef __cplusplus
-#include "zlib.h"
+extern "C" {
-#endif
+#endif
-
+
-#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP)
+#ifndef _ZLIB_H
-/* like the STRICT of WIN32, we define a pointer that cannot be converted
+#include "zlib.h"
-    from (void*) without cast */
+#endif
-typedef struct TagunzFile__ { int unused; } unzFile__; 
+
-typedef unzFile__ *unzFile;
+#ifndef _ZLIBIOAPI_H
-#else
+#include "ioapi.h"
-typedef voidp unzFile;
+#endif
-#endif
+
-
+#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP)
-
+/* like the STRICT of WIN32, we define a pointer that cannot be converted
-#define UNZ_OK                                  (0)
+    from (void*) without cast */
-#define UNZ_END_OF_LIST_OF_FILE (-100)
+typedef struct TagunzFile__ { int unused; } unzFile__;
-#define UNZ_ERRNO               (Z_ERRNO)
+typedef unzFile__ *unzFile;
-#define UNZ_EOF                 (0)
+#else
-#define UNZ_PARAMERROR                  (-102)
+typedef voidp unzFile;
-#define UNZ_BADZIPFILE                  (-103)
+#endif
-#define UNZ_INTERNALERROR               (-104)
+
-#define UNZ_CRCERROR                    (-105)
+
-
+#define UNZ_OK                          (0)
-/* tm_unz contain date/time info */
+#define UNZ_END_OF_LIST_OF_FILE         (-100)
-typedef struct tm_unz_s 
+#define UNZ_ERRNO                       (Z_ERRNO)
-{
+#define UNZ_EOF                         (0)
-	uInt tm_sec;            /* seconds after the minute - [0,59] */
+#define UNZ_PARAMERROR                  (-102)
-	uInt tm_min;            /* minutes after the hour - [0,59] */
+#define UNZ_BADZIPFILE                  (-103)
-	uInt tm_hour;           /* hours since midnight - [0,23] */
+#define UNZ_INTERNALERROR               (-104)
-	uInt tm_mday;           /* day of the month - [1,31] */
+#define UNZ_CRCERROR                    (-105)
-	uInt tm_mon;            /* months since January - [0,11] */
+
-	uInt tm_year;           /* years - [1980..2044] */
+/* tm_unz contain date/time info */
-} tm_unz;
+typedef struct tm_unz_s
-
+{
-/* unz_global_info structure contain global data about the ZIPfile
+    uInt tm_sec;            /* seconds after the minute - [0,59] */
-   These data comes from the end of central dir */
+    uInt tm_min;            /* minutes after the hour - [0,59] */
-typedef struct unz_global_info_s
+    uInt tm_hour;           /* hours since midnight - [0,23] */
-{
+    uInt tm_mday;           /* day of the month - [1,31] */
-	uLong number_entry;         /* total number of entries in
+    uInt tm_mon;            /* months since January - [0,11] */
-				       the central dir on this disk */
+    uInt tm_year;           /* years - [1980..2044] */
-	uLong size_comment;         /* size of the global comment of the zipfile */
+} tm_unz;
-} unz_global_info;
+
-
+/* unz_global_info structure contain global data about the ZIPfile
-
+   These data comes from the end of central dir */
-/* unz_file_info contain information about a file in the zipfile */
+typedef struct unz_global_info_s
-typedef struct unz_file_info_s
+{
-{
+    uLong number_entry;         /* total number of entries in
-    uLong version;              /* version made by                 2 bytes */
+                       the central dir on this disk */
-    uLong version_needed;       /* version needed to extract       2 bytes */
+    uLong size_comment;         /* size of the global comment of the zipfile */
-    uLong flag;                 /* general purpose bit flag        2 bytes */
+} unz_global_info;
-    uLong compression_method;   /* compression method              2 bytes */
+
-    uLong dosDate;              /* last mod file date in Dos fmt   4 bytes */
+
-    uLong crc;                  /* crc-32                          4 bytes */
+/* unz_file_info contain information about a file in the zipfile */
-    uLong compressed_size;      /* compressed size                 4 bytes */ 
+typedef struct unz_file_info_s
-    uLong uncompressed_size;    /* uncompressed size               4 bytes */ 
+{
-    uLong size_filename;        /* filename length                 2 bytes */
+    uLong version;              /* version made by                 2 bytes */
-    uLong size_file_extra;      /* extra field length              2 bytes */
+    uLong version_needed;       /* version needed to extract       2 bytes */
-    uLong size_file_comment;    /* file comment length             2 bytes */
+    uLong flag;                 /* general purpose bit flag        2 bytes */
-
+    uLong compression_method;   /* compression method              2 bytes */
-    uLong disk_num_start;       /* disk number start               2 bytes */
+    uLong dosDate;              /* last mod file date in Dos fmt   4 bytes */
-    uLong internal_fa;          /* internal file attributes        2 bytes */
+    uLong crc;                  /* crc-32                          4 bytes */
-    uLong external_fa;          /* external file attributes        4 bytes */
+    uLong compressed_size;      /* compressed size                 4 bytes */
-
+    uLong uncompressed_size;    /* uncompressed size               4 bytes */
-    tm_unz tmu_date;
+    uLong size_filename;        /* filename length                 2 bytes */
-} unz_file_info;
+    uLong size_file_extra;      /* extra field length              2 bytes */
-
+    uLong size_file_comment;    /* file comment length             2 bytes */
-extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1,
+
-												 const char* fileName2,
+    uLong disk_num_start;       /* disk number start               2 bytes */
-												 int iCaseSensitivity));
+    uLong internal_fa;          /* internal file attributes        2 bytes */
-/*
+    uLong external_fa;          /* external file attributes        4 bytes */
-   Compare two filename (fileName1,fileName2).
+
-   If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
+    tm_unz tmu_date;
-   If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
+} unz_file_info;
-								or strcasecmp)
+
-   If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
+extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1,
-	(like 1 on Unix, 2 on Windows)
+                                                 const char* fileName2,
-*/
+                                                 int iCaseSensitivity));
-
+/*
-
+   Compare two filename (fileName1,fileName2).
-extern unzFile ZEXPORT unzOpen OF((const char *path));
+   If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
-/*
+   If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
-  Open a Zip file. path contain the full pathname (by example,
+                                or strcasecmp)
-     on a Windows NT computer "c:\\zlib\\zlib111.zip" or on an Unix computer
+   If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
-	 "zlib/zlib111.zip".
+    (like 1 on Unix, 2 on Windows)
-	 If the zipfile cannot be opened (file don't exist or in not valid), the
+*/
-	   return value is NULL.
+
-     Else, the return value is a unzFile Handle, usable with other function
+
-	   of this unzip package.
+extern unzFile ZEXPORT unzOpen OF((const char *path));
-*/
+/*
-
+  Open a Zip file. path contain the full pathname (by example,
-extern int ZEXPORT unzClose OF((unzFile file));
+     on a Windows XP computer "c:\\zlib\\zlib113.zip" or on an Unix computer
-/*
+     "zlib/zlib113.zip".
-  Close a ZipFile opened with unzipOpen.
+     If the zipfile cannot be opened (file don't exist or in not valid), the
-  If there is files inside the .Zip opened with unzOpenCurrentFile (see later),
+       return value is NULL.
-    these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
+     Else, the return value is a unzFile Handle, usable with other function
-  return UNZ_OK if there is no problem. */
+       of this unzip package.
-
+*/
-extern int ZEXPORT unzGetGlobalInfo OF((unzFile file,
+
-					unz_global_info *pglobal_info));
+extern unzFile ZEXPORT unzOpen2 OF((const char *path,
-/*
+                                    zlib_filefunc_def* pzlib_filefunc_def));
-  Write info about the ZipFile in the *pglobal_info structure.
+/*
-  No preparation of the structure is needed
+   Open a Zip file, like unzOpen, but provide a set of file low level API
-  return UNZ_OK if there is no problem. */
+      for read/write the zip file (see ioapi.h)
-
+*/
-
+
-extern int ZEXPORT unzGetGlobalComment OF((unzFile file,
+extern int ZEXPORT unzClose OF((unzFile file));
-										   char *szComment,
+/*
-					   uLong uSizeBuf));
+  Close a ZipFile opened with unzipOpen.
-/*
+  If there is files inside the .Zip opened with unzOpenCurrentFile (see later),
-  Get the global comment string of the ZipFile, in the szComment buffer.
+    these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
-  uSizeBuf is the size of the szComment buffer.
+  return UNZ_OK if there is no problem. */
-  return the number of byte copied or an error code <0
+
-*/
+extern int ZEXPORT unzGetGlobalInfo OF((unzFile file,
-
+                                        unz_global_info *pglobal_info));
-
+/*
-/***************************************************************************/
+  Write info about the ZipFile in the *pglobal_info structure.
-/* Unzip package allow you browse the directory of the zipfile */
+  No preparation of the structure is needed
-
+  return UNZ_OK if there is no problem. */
-extern int ZEXPORT unzGoToFirstFile OF((unzFile file));
+
-/*
+
-  Set the current file of the zipfile to the first file.
+extern int ZEXPORT unzGetGlobalComment OF((unzFile file,
-  return UNZ_OK if there is no problem
+                                           char *szComment,
-*/
+                                           uLong uSizeBuf));
-
+/*
-extern int ZEXPORT unzGoToNextFile OF((unzFile file));
+  Get the global comment string of the ZipFile, in the szComment buffer.
-/*
+  uSizeBuf is the size of the szComment buffer.
-  Set the current file of the zipfile to the next file.
+  return the number of byte copied or an error code <0
-  return UNZ_OK if there is no problem
+*/
-  return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
+
-*/
+
-
+/***************************************************************************/
-extern int ZEXPORT unzLocateFile OF((unzFile file, 
+/* Unzip package allow you browse the directory of the zipfile */
-				     const char *szFileName,
+
-				     int iCaseSensitivity));
+extern int ZEXPORT unzGoToFirstFile OF((unzFile file));
-/*
+/*
-  Try locate the file szFileName in the zipfile.
+  Set the current file of the zipfile to the first file.
-  For the iCaseSensitivity signification, see unzStringFileNameCompare
+  return UNZ_OK if there is no problem
-
+*/
-  return value :
+
-  UNZ_OK if the file is found. It becomes the current file.
+extern int ZEXPORT unzGoToNextFile OF((unzFile file));
-  UNZ_END_OF_LIST_OF_FILE if the file is not found
+/*
-*/
+  Set the current file of the zipfile to the next file.
-
+  return UNZ_OK if there is no problem
-
+  return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
-extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file,
+*/
-					     unz_file_info *pfile_info,
+
-					     char *szFileName,
+extern int ZEXPORT unzLocateFile OF((unzFile file,
-					     uLong fileNameBufferSize,
+                     const char *szFileName,
-					     void *extraField,
+                     int iCaseSensitivity));
-					     uLong extraFieldBufferSize,
+/*
-					     char *szComment,
+  Try locate the file szFileName in the zipfile.
-					     uLong commentBufferSize));
+  For the iCaseSensitivity signification, see unzStringFileNameCompare
-/*
+
-  Get Info about the current file
+  return value :
-  if pfile_info!=NULL, the *pfile_info structure will contain somes info about
+  UNZ_OK if the file is found. It becomes the current file.
-	    the current file
+  UNZ_END_OF_LIST_OF_FILE if the file is not found
-  if szFileName!=NULL, the filemane string will be copied in szFileName
+*/
-			(fileNameBufferSize is the size of the buffer)
+
-  if extraField!=NULL, the extra field information will be copied in extraField
+
-			(extraFieldBufferSize is the size of the buffer).
+/* ****************************************** */
-			This is the Central-header version of the extra field
+/* Ryan supplied functions */
-  if szComment!=NULL, the comment string of the file will be copied in szComment
+/* unz_file_info contain information about a file in the zipfile */
-			(commentBufferSize is the size of the buffer)
+typedef struct unz_file_pos_s
-*/
+{
-
+    uLong pos_in_zip_directory;   /* offset in zip file directory */
-/***************************************************************************/
+    uLong num_of_file;            /* # of file */
-/* for reading the content of the current zipfile, you can open it, read data
+} unz_file_pos;
-   from it, and close it (you can close it before reading all the file)
+
-   */
+extern int ZEXPORT unzGetFilePos(
-
+    unzFile file,
-extern int ZEXPORT unzOpenCurrentFile OF((unzFile file));
+    unz_file_pos* file_pos);
-/*
+
-  Open for reading data the current file in the zipfile.
+extern int ZEXPORT unzGoToFilePos(
-  If there is no error, the return value is UNZ_OK.
+    unzFile file,
-*/
+    unz_file_pos* file_pos);
-
+
-extern int ZEXPORT unzCloseCurrentFile OF((unzFile file));
+/* ****************************************** */
-/*
+
-  Close the file in zip opened with unzOpenCurrentFile
+extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file,
-  Return UNZ_CRCERROR if all the file was read but the CRC is not good
+                         unz_file_info *pfile_info,
-*/
+                         char *szFileName,
-
+                         uLong fileNameBufferSize,
-												
+                         void *extraField,
-extern int ZEXPORT unzReadCurrentFile OF((unzFile file, 
+                         uLong extraFieldBufferSize,
-					  voidp buf,
+                         char *szComment,
-					  unsigned len));
+                         uLong commentBufferSize));
-/*
+/*
-  Read bytes from the current file (opened by unzOpenCurrentFile)
+  Get Info about the current file
-  buf contain buffer where data must be copied
+  if pfile_info!=NULL, the *pfile_info structure will contain somes info about
-  len the size of buf.
+        the current file
-
+  if szFileName!=NULL, the filemane string will be copied in szFileName
-  return the number of byte copied if somes bytes are copied
+            (fileNameBufferSize is the size of the buffer)
-  return 0 if the end of file was reached
+  if extraField!=NULL, the extra field information will be copied in extraField
-  return <0 with error code if there is an error
+            (extraFieldBufferSize is the size of the buffer).
-    (UNZ_ERRNO for IO error, or zLib error for uncompress error)
+            This is the Central-header version of the extra field
-*/
+  if szComment!=NULL, the comment string of the file will be copied in szComment
-
+            (commentBufferSize is the size of the buffer)
-extern z_off_t ZEXPORT unztell OF((unzFile file));
+*/
-/*
+
-  Give the current position in uncompressed data
+/***************************************************************************/
-*/
+/* for reading the content of the current zipfile, you can open it, read data
-
+   from it, and close it (you can close it before reading all the file)
-extern int ZEXPORT unzeof OF((unzFile file));
+   */
-/*
+
-  return 1 if the end of file was reached, 0 elsewhere 
+extern int ZEXPORT unzOpenCurrentFile OF((unzFile file));
-*/
+/*
-
+  Open for reading data the current file in the zipfile.
-extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file,
+  If there is no error, the return value is UNZ_OK.
-											 voidp buf,
+*/
-											 unsigned len));
+
-/*
+extern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file,
-  Read extra field from the current file (opened by unzOpenCurrentFile)
+                                                  const char* password));
-  This is the local-header version of the extra field (sometimes, there is
+/*
-    more info in the local-header version than in the central-header)
+  Open for reading data the current file in the zipfile.
-
+  password is a crypting password
-  if buf==NULL, it return the size of the local extra field
+  If there is no error, the return value is UNZ_OK.
-
+*/
-  if buf!=NULL, len is the size of the buffer, the extra header is copied in
+
-	buf.
+extern int ZEXPORT unzOpenCurrentFile2 OF((unzFile file,
-  the return value is the number of bytes copied in buf, or (if <0) 
+                                           int* method,
-	the error code
+                                           int* level,
-*/
+                                           int raw));
-
+/*
-#ifdef __cplusplus
+  Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
-}
+    if raw==1
-#endif
+  *method will receive method of compression, *level will receive level of
-
+     compression
-#endif /* _unz_H */
+  note : you can set level parameter as NULL (if you did not want known level,
+         but you CANNOT set method parameter as NULL
+*/
+
+extern int ZEXPORT unzOpenCurrentFile3 OF((unzFile file,
+                                           int* method,
+                                           int* level,
+                                           int raw,
+                                           const char* password));
+/*
+  Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
+    if raw==1
+  *method will receive method of compression, *level will receive level of
+     compression
+  note : you can set level parameter as NULL (if you did not want known level,
+         but you CANNOT set method parameter as NULL
+*/
+
+
+extern int ZEXPORT unzCloseCurrentFile OF((unzFile file));
+/*
+  Close the file in zip opened with unzOpenCurrentFile
+  Return UNZ_CRCERROR if all the file was read but the CRC is not good
+*/
+
+extern int ZEXPORT unzReadCurrentFile OF((unzFile file,
+                      voidp buf,
+                      unsigned len));
+/*
+  Read bytes from the current file (opened by unzOpenCurrentFile)
+  buf contain buffer where data must be copied
+  len the size of buf.
+
+  return the number of byte copied if somes bytes are copied
+  return 0 if the end of file was reached
+  return <0 with error code if there is an error
+    (UNZ_ERRNO for IO error, or zLib error for uncompress error)
+*/
+
+extern z_off_t ZEXPORT unztell OF((unzFile file));
+/*
+  Give the current position in uncompressed data
+*/
+
+extern int ZEXPORT unzeof OF((unzFile file));
+/*
+  return 1 if the end of file was reached, 0 elsewhere
+*/
+
+extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file,
+                                             voidp buf,
+                                             unsigned len));
+/*
+  Read extra field from the current file (opened by unzOpenCurrentFile)
+  This is the local-header version of the extra field (sometimes, there is
+    more info in the local-header version than in the central-header)
+
+  if buf==NULL, it return the size of the local extra field
+
+  if buf!=NULL, len is the size of the buffer, the extra header is copied in
+    buf.
+  the return value is the number of bytes copied in buf, or (if <0)
+    the error code
+*/
+
+/***************************************************************************/
+
+/* Get the current file offset */
+extern uLong ZEXPORT unzGetOffset (unzFile file);
+
+/* Set the current file offset */
+extern int ZEXPORT unzSetOffset (unzFile file, uLong pos);
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _unz_H */

update.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<app version="2.0.8">
+<file url="http://fceugc.googlecode.com/files/FCE%20Ultra%20GX%202.0.7.zip"></file>
+</app>