fix for Super Mario RPG, minor bug fixes, auto update feature

Makefile.gc

@@ -18,9 +18,8 @@ include $(DEVKITPPC)/gamecube_rules
 TARGET		:=	snes9xgx-gc
 TARGETDIR   :=  executables
 BUILD		:=	build_gc
-SOURCES		:=	source/snes9x source/ngc source/sz
+SOURCES		:=	source/snes9x source/ngc source/sz source/unzip
-DATA		:=	data  
+INCLUDES	:=	source/snes9x source/ngc source/unzip
-INCLUDES	:=	source/snes9x source/ngc
 
 #---------------------------------------------------------------------------------
 # options for code generation

Makefile.wii

@@ -18,9 +18,8 @@ include $(DEVKITPPC)/wii_rules
 TARGET		:=	snes9xgx-wii
 TARGETDIR   :=  executables
 BUILD		:=	build_wii
-SOURCES		:=	source/snes9x source/ngc source/sz
+SOURCES		:=	source/snes9x source/ngc source/sz source/unzip
-DATA		:=	data  
+INCLUDES	:=	source/snes9x source/ngc source/unzip
-INCLUDES	:=	source/snes9x source/ngc
 
 #---------------------------------------------------------------------------------
 # options for code generation

source/ngc/dvd.cpp

@@ -24,7 +24,7 @@ extern "C" {
 #endif
 
 #include "menudraw.h"
-#include "unzip.h"
+#include "gcunzip.h"
 #include "filesel.h"
 #include "snes9xGX.h"
 

source/ngc/fileop.cpp

@@ -8,7 +8,7 @@
  *
  * fileop.cpp
  *
- * FAT File operations
+ * File operations
  ***************************************************************************/
 
 #include <gccore.h>
@@ -25,10 +25,10 @@
 
 #include "snes9xGX.h"
 #include "fileop.h"
-#include "smbop.h"
+#include "networkop.h"
 #include "dvd.h"
 #include "memcardop.h"
-#include "unzip.h"
+#include "gcunzip.h"
 #include "video.h"
 #include "menudraw.h"
 #include "filesel.h"
@@ -83,6 +83,7 @@ devicecallback (void *arg)
 		}
 
 		InitializeNetwork(SILENT);
+		UpdateCheck();
 #else
 		if(isMounted[METHOD_SD_SLOTA])
 		{
@@ -103,7 +104,6 @@ devicecallback (void *arg)
 #endif
 		usleep(500000); // suspend thread for 1/2 sec
 	}
-
 	return NULL;
 }
 
@@ -126,11 +126,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
 }
 
@@ -179,7 +179,7 @@ bool MountFAT(int method)
 	if(unmountRequired[method])
 	{
 		unmountRequired[method] = false;
-		fatUnmount(name);
+		fatUnmount(rootdir);
 		disc->shutdown();
 	}
 	if(!isMounted[method])
@@ -505,4 +505,3 @@ u32 SaveFile(char filepath[], u32 datasize, int method, bool silent)
 {
 	return SaveFile((char *)savebuffer, filepath, datasize, method, silent);
 }
-

source/ngc/fileop.h

@@ -35,6 +35,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.cpp

@@ -34,11 +34,11 @@ extern "C" {
 #include "menudraw.h"
 #include "video.h"
 #include "aram.h"
-#include "smbop.h"
+#include "networkop.h"
 #include "fileop.h"
 #include "memcardop.h"
 #include "input.h"
-#include "unzip.h"
+#include "gcunzip.h"
 
 int offset;
 int selection;
@@ -108,7 +108,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;
 }
 
@@ -137,7 +138,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/filesel.h

@@ -15,6 +15,7 @@
 #define _NGCFILESEL_
 
 #include <unistd.h>
+#include <gccore.h>
 
 #define SAVEBUFFERSIZE (512 * 1024)
 #define MAXJOLIET 255

source/ngc/freeze.cpp

@@ -154,7 +154,7 @@ NGCFreezeGame (int method, bool silent)
 		// And the freezecomment
 		memset(freezecomment, 0, 64);
 
-		sprintf (freezecomment[0], "%s Freeze", VERSIONSTR);
+		sprintf (freezecomment[0], "%s Freeze", APPVERSION);
 		sprintf (freezecomment[1], Memory.ROMName);
 		memcpy (savebuffer + woffset, freezecomment, 64);
 		woffset += 64;

source/ngc/gcunzip.cpp

@@ -24,11 +24,11 @@ extern "C" {
 
 #include "snes9xGX.h"
 #include "dvd.h"
-#include "smbop.h"
+#include "networkop.h"
 #include "fileop.h"
 #include "video.h"
 #include "menudraw.h"
-#include "unzip.h"
+#include "gcunzip.h"
 
 /*
   * PKWare Zip Header - adopted into zip standard

source/ngc/gcunzip.h

@@ -5,14 +5,12 @@
  * Michniewski 2008
  * Tantric September 2008
  *
- * unzip.h
+ * gcunzip.h
  *
  * File unzip routines
  ****************************************************************************/
-#ifndef _UNZIP_
+#ifndef _GCUNZIP_H_
-#define _UNZIP_
+#define _GCUNZIP_H_
-
-#include <smb.h>
 
 extern int IsZipFile (char *buffer);
 char * GetFirstZipFilename(int method);

source/ngc/http.cpp

@@ -0,0 +1,432 @@
+/****************************************************************************
+ * Snes9x 1.51 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,32 @@
+/****************************************************************************
+ * Snes9x 1.51 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.cpp

@@ -271,7 +271,6 @@ LoadMCFile (char *buf, int slot, char *filename, bool silent)
 	return bytesread;
 }
 
-
 /****************************************************************************
  * SaveMCFile
  * Write savebuffer to Memory Card file
@@ -284,6 +283,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 ("SNES", "00");
@@ -296,122 +298,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 SRAM");
 	}
 	else
 		if (slot == CARD_SLOTA)
@@ -420,5 +416,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.cpp

@@ -41,8 +41,8 @@ extern "C" {
 #include "snes9xGX.h"
 #include "video.h"
 #include "filesel.h"
-#include "unzip.h"
+#include "gcunzip.h"
-#include "smbop.h"
+#include "networkop.h"
 #include "memcardop.h"
 #include "fileop.h"
 #include "freeze.h"

source/ngc/menudraw.cpp

@@ -32,6 +32,7 @@
 #include "aram.h"
 #include "images/gfx_bg.h"
 #include "input.h"
+#include "networkop.h"
 
 /*** Globals ***/
 FT_Library ftlibrary;
@@ -490,7 +491,9 @@ DrawMenu (char items[][50], const char *title, int maxitems, int selected, int f
 	}
 
 	setfontsize (12);
-	DrawText (510, screenheight - 20, (char *)VERSIONSTR);
+	char versionText[50];
+	sprintf(versionText, "%s %s", APPNAME, APPVERSION);
+	DrawText (510, screenheight - 20, versionText);
 
 	// Draw menu items
 
@@ -570,6 +573,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
@@ -587,7 +598,6 @@ RunMenu (char items[][50], int maxitems, const char *title, int fontsize, int x)
 		wp = WPAD_ButtonsDown (0);
 #endif
 
-
 		VIDEO_WaitVSync();	// slow things down a bit so we don't overread the pads
 
         /*** Look for up ***/

source/ngc/networkop.cpp

@@ -0,0 +1,254 @@
+/****************************************************************************
+ * Snes9x 1.51 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 "snes9xGX.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://snes9x-gx.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
+			char * versionstr;
+			item = mxmlFindElement(xml, xml, "app", "version", NULL, MXML_DESCEND);
+			if(item) // a version entry exists
+			{
+				versionstr = (char *)mxmlElementGetAttr(item, "version");
+
+				int version = atoi(versionstr);
+				int currVersion = atoi(APPVERSION);
+
+				if(version > currVersion) // a new version is available
+				{
+					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

@@ -1,20 +1,22 @@
 /****************************************************************************
  * Snes9x 1.51 Nintendo Wii/Gamecube Port
  *
- * softdev July 2006
+ * Tantric December 2008
- * crunchy2 May 2007
- * Tantric August 2008
  *
- * smbload.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.cpp

@@ -123,7 +123,7 @@ preparePrefsData (int method)
 
 		// And the comments
 		memset(prefscomment, 0, 64);
-		sprintf (prefscomment[0], "%s Prefs", VERSIONSTR);
+		sprintf (prefscomment[0], "%s Prefs", APPNAME);
 		sprintf (prefscomment[1], "Preferences");
 		memcpy (savebuffer + offset, prefscomment, 64);
 		offset += 64;
@@ -133,7 +133,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");
 
@@ -188,11 +189,11 @@ preparePrefsData (int method)
  * Load XML elements into variables for an individual variable
  ***************************************************************************/
 
-void loadXMLSetting(char * var, const char * name)
+void loadXMLSetting(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 loadXMLSetting(int * var, const char * name)
 {
@@ -270,17 +271,17 @@ decodePrefsData (int method)
 	loadXMLSetting(&GCSettings.AutoSave, "AutoSave");
 	loadXMLSetting(&GCSettings.LoadMethod, "LoadMethod");
 	loadXMLSetting(&GCSettings.SaveMethod, "SaveMethod");
-	loadXMLSetting(GCSettings.LoadFolder, "LoadFolder");
+	loadXMLSetting(GCSettings.LoadFolder, "LoadFolder", sizeof(GCSettings.LoadFolder));
-	loadXMLSetting(GCSettings.SaveFolder, "SaveFolder");
+	loadXMLSetting(GCSettings.SaveFolder, "SaveFolder", sizeof(GCSettings.SaveFolder));
-	loadXMLSetting(GCSettings.CheatFolder, "CheatFolder");
+	loadXMLSetting(GCSettings.CheatFolder, "CheatFolder", sizeof(GCSettings.CheatFolder));
 	loadXMLSetting(&GCSettings.VerifySaves, "VerifySaves");
 
 	// Network Settings
 
-	loadXMLSetting(GCSettings.smbip, "smbip");
+	loadXMLSetting(GCSettings.smbip, "smbip", sizeof(GCSettings.smbip));
-	loadXMLSetting(GCSettings.smbshare, "smbshare");
+	loadXMLSetting(GCSettings.smbshare, "smbshare", sizeof(GCSettings.smbshare));
-	loadXMLSetting(GCSettings.smbuser, "smbuser");
+	loadXMLSetting(GCSettings.smbuser, "smbuser", sizeof(GCSettings.smbuser));
-	loadXMLSetting(GCSettings.smbpwd, "smbpwd");
+	loadXMLSetting(GCSettings.smbpwd, "smbpwd", sizeof(GCSettings.smbpwd));
 
 	// Emulation Settings
 

source/ngc/smbop.cpp

@@ -1,143 +0,0 @@
-/****************************************************************************
- * Snes9x 1.51 Nintendo Wii/Gamecube Port
- *
- * softdev July 2006
- * crunchy2 May 2007
- * Tantric August 2008
- *
- * smbload.cpp
- *
- * SMB support routines
- ****************************************************************************/
-
-#include <gccore.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <ogcsys.h>
-#include <network.h>
-#include <smb.h>
-#include <zlib.h>
-#include <errno.h>
-
-#include "snes9xGX.h"
-#include "fileop.h"
-#include "unzip.h"
-#include "video.h"
-#include "menudraw.h"
-#include "filesel.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/ngc/snes9xGX.cpp

@@ -43,7 +43,7 @@ extern "C" {
 #include "snes9xGX.h"
 #include "aram.h"
 #include "dvd.h"
-#include "smbop.h"
+#include "networkop.h"
 #include "video.h"
 #include "menudraw.h"
 #include "s9xconfig.h"
@@ -75,6 +75,7 @@ extern unsigned int timediffallowed;
 
 void ExitCleanup()
 {
+	LWP_SuspendThread (devicethread);
 	UnmountAllFAT();
 	CloseShare();
 

source/ngc/snes9xGX.h

@@ -14,12 +14,11 @@
 #ifndef _SNES9XGX_H_
 #define _SNES9XGX_H_
 
-#include <gccore.h>
 #include "snes9x.h"
 
-#define VERSIONNUM "007"
+#define APPNAME 		"Snes9x GX"
-#define VERSIONSTR "Snes9x GX 007"
+#define APPVERSION 		"008"
-#define PREF_FILE_NAME "settings.xml"
+#define PREF_FILE_NAME 	"settings.xml"
 
 #define NOTSILENT 0
 #define SILENT 1
@@ -73,6 +72,7 @@ struct SGCSettings{
 void ExitToLoader();
 void Reboot();
 void ShutdownWii();
+void ReloadApp();
 extern struct SGCSettings GCSettings;
 extern int ConfigRequested;
 extern int ShutdownRequested;

source/ngc/sram.cpp

@@ -50,7 +50,7 @@ preparesavedata (int method)
 
 	// Copy in the sramcomments
 	memset(sramcomment, 0, 64);
-	sprintf (sramcomment[0], "%s SRAM", VERSIONSTR);
+	sprintf (sramcomment[0], "%s SRAM", APPNAME);
 	sprintf (sramcomment[1], Memory.ROMName);
 	memcpy (savebuffer + offset, sramcomment, 64);
 	offset += 64;

source/snes9x/memmap.cpp

@@ -3036,6 +3036,8 @@ void CMemory::ApplyROMFixes (void)
 		match_na("PRIMAL RAGE")     || // Primal Rage
 		match_na("CLAY FIGHTER")    || // Clay Fighter
 		match_na("ClayFighter 2")   || // Clay Fighter 2
+		match_id("ARWJ") 			|| // Super Mario RPG (J)
+		match_id("ARWE")			|| // Super Mario RPG (U)
 		match_na("WeaponLord")      || // Weapon Lord
 		match_nn("WAR 2410")        || // War 2410
 		match_id("ARF")             || // Star Ocean

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

@@ -0,0 +1,354 @@
+/* unzip.h -- IO for uncompress .zip files using zlib
+   Version 1.01e, February 12th, 2005
+
+   Copyright (C) 1998-2005 Gilles Vollant
+
+   This unzip package allow extract file from .ZIP file, compatible with PKZip 2.04g
+     WinZip, InfoZip tools and compatible.
+
+   Multi volume ZipFile (span) are not supported.
+   Encryption compatible with pkzip 2.04g only supported
+   Old compressions used by old PKZip 1.x are not supported
+
+
+   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 :
+
+  This software is provided 'as-is', without any express or implied
+  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
+  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
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     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
+      http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip
+      http://www.info-zip.org/pub/infozip/doc/
+   PkWare has also a specification at :
+      ftp://ftp.pkware.com/probdesc.zip
+*/
+
+#ifndef _unz_H
+#define _unz_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef _ZLIB_H
+#include "zlib.h"
+#endif
+
+#ifndef _ZLIBIOAPI_H
+#include "ioapi.h"
+#endif
+
+#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP)
+/* like the STRICT of WIN32, we define a pointer that cannot be converted
+    from (void*) without cast */
+typedef struct TagunzFile__ { int unused; } unzFile__;
+typedef unzFile__ *unzFile;
+#else
+typedef voidp unzFile;
+#endif
+
+
+#define UNZ_OK                          (0)
+#define UNZ_END_OF_LIST_OF_FILE         (-100)
+#define UNZ_ERRNO                       (Z_ERRNO)
+#define UNZ_EOF                         (0)
+#define UNZ_PARAMERROR                  (-102)
+#define UNZ_BADZIPFILE                  (-103)
+#define UNZ_INTERNALERROR               (-104)
+#define UNZ_CRCERROR                    (-105)
+
+/* tm_unz contain date/time info */
+typedef struct tm_unz_s
+{
+    uInt tm_sec;            /* seconds after the minute - [0,59] */
+    uInt tm_min;            /* minutes after the hour - [0,59] */
+    uInt tm_hour;           /* hours since midnight - [0,23] */
+    uInt tm_mday;           /* day of the month - [1,31] */
+    uInt tm_mon;            /* months since January - [0,11] */
+    uInt tm_year;           /* years - [1980..2044] */
+} tm_unz;
+
+/* unz_global_info structure contain global data about the ZIPfile
+   These data comes from the end of central dir */
+typedef struct unz_global_info_s
+{
+    uLong number_entry;         /* total number of entries in
+                       the central dir on this disk */
+    uLong size_comment;         /* size of the global comment of the zipfile */
+} unz_global_info;
+
+
+/* unz_file_info contain information about a file in the zipfile */
+typedef struct unz_file_info_s
+{
+    uLong version;              /* version made by                 2 bytes */
+    uLong version_needed;       /* version needed to extract       2 bytes */
+    uLong flag;                 /* general purpose bit flag        2 bytes */
+    uLong compression_method;   /* compression method              2 bytes */
+    uLong dosDate;              /* last mod file date in Dos fmt   4 bytes */
+    uLong crc;                  /* crc-32                          4 bytes */
+    uLong compressed_size;      /* compressed size                 4 bytes */
+    uLong uncompressed_size;    /* uncompressed size               4 bytes */
+    uLong size_filename;        /* filename length                 2 bytes */
+    uLong size_file_extra;      /* extra field length              2 bytes */
+    uLong size_file_comment;    /* file comment length             2 bytes */
+
+    uLong disk_num_start;       /* disk number start               2 bytes */
+    uLong internal_fa;          /* internal file attributes        2 bytes */
+    uLong external_fa;          /* external file attributes        4 bytes */
+
+    tm_unz tmu_date;
+} unz_file_info;
+
+extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1,
+                                                 const char* fileName2,
+                                                 int iCaseSensitivity));
+/*
+   Compare two filename (fileName1,fileName2).
+   If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
+   If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
+                                or strcasecmp)
+   If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
+    (like 1 on Unix, 2 on Windows)
+*/
+
+
+extern unzFile ZEXPORT unzOpen OF((const char *path));
+/*
+  Open a Zip file. path contain the full pathname (by example,
+     on a Windows XP computer "c:\\zlib\\zlib113.zip" or on an Unix computer
+     "zlib/zlib113.zip".
+     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 unzOpen2 OF((const char *path,
+                                    zlib_filefunc_def* pzlib_filefunc_def));
+/*
+   Open a Zip file, like unzOpen, but provide a set of file low level API
+      for read/write the zip file (see ioapi.h)
+*/
+
+extern int ZEXPORT unzClose OF((unzFile file));
+/*
+  Close a ZipFile opened with unzipOpen.
+  If there is files inside the .Zip opened with unzOpenCurrentFile (see later),
+    these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
+  return UNZ_OK if there is no problem. */
+
+extern int ZEXPORT unzGetGlobalInfo OF((unzFile file,
+                                        unz_global_info *pglobal_info));
+/*
+  Write info about the ZipFile in the *pglobal_info structure.
+  No preparation of the structure is needed
+  return UNZ_OK if there is no problem. */
+
+
+extern int ZEXPORT unzGetGlobalComment OF((unzFile file,
+                                           char *szComment,
+                                           uLong uSizeBuf));
+/*
+  Get the global comment string of the ZipFile, in the szComment buffer.
+  uSizeBuf is the size of the szComment buffer.
+  return the number of byte copied or an error code <0
+*/
+
+
+/***************************************************************************/
+/* Unzip package allow you browse the directory of the zipfile */
+
+extern int ZEXPORT unzGoToFirstFile OF((unzFile file));
+/*
+  Set the current file of the zipfile to the first file.
+  return UNZ_OK if there is no problem
+*/
+
+extern int ZEXPORT unzGoToNextFile OF((unzFile file));
+/*
+  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 unzLocateFile OF((unzFile file,
+                     const char *szFileName,
+                     int iCaseSensitivity));
+/*
+  Try locate the file szFileName in the zipfile.
+  For the iCaseSensitivity signification, see unzStringFileNameCompare
+
+  return value :
+  UNZ_OK if the file is found. It becomes the current file.
+  UNZ_END_OF_LIST_OF_FILE if the file is not found
+*/
+
+
+/* ****************************************** */
+/* Ryan supplied functions */
+/* unz_file_info contain information about a file in the zipfile */
+typedef struct unz_file_pos_s
+{
+    uLong pos_in_zip_directory;   /* offset in zip file directory */
+    uLong num_of_file;            /* # of file */
+} unz_file_pos;
+
+extern int ZEXPORT unzGetFilePos(
+    unzFile file,
+    unz_file_pos* file_pos);
+
+extern int ZEXPORT unzGoToFilePos(
+    unzFile file,
+    unz_file_pos* file_pos);
+
+/* ****************************************** */
+
+extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file,
+                         unz_file_info *pfile_info,
+                         char *szFileName,
+                         uLong fileNameBufferSize,
+                         void *extraField,
+                         uLong extraFieldBufferSize,
+                         char *szComment,
+                         uLong commentBufferSize));
+/*
+  Get Info about the current file
+  if pfile_info!=NULL, the *pfile_info structure will contain somes info about
+        the current file
+  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
+  if szComment!=NULL, the comment string of the file will be copied in szComment
+            (commentBufferSize is the size of the buffer)
+*/
+
+/***************************************************************************/
+/* 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 unzOpenCurrentFile OF((unzFile file));
+/*
+  Open for reading data the current file in the zipfile.
+  If there is no error, the return value is UNZ_OK.
+*/
+
+extern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file,
+                                                  const char* password));
+/*
+  Open for reading data the current file in the zipfile.
+  password is a crypting password
+  If there is no error, the return value is UNZ_OK.
+*/
+
+extern int ZEXPORT unzOpenCurrentFile2 OF((unzFile file,
+                                           int* method,
+                                           int* level,
+                                           int raw));
+/*
+  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 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="008">
+<file url="http://snes9x-gx.googlecode.com/files/Snes9x%20GX%20007.zip"></file>
+</app>