Substitute bool with unsigned char, added zip browsing

Makefile

@@ -17,7 +17,7 @@ include $(DEVKITPPC)/wii_rules
 #---------------------------------------------------------------------------------
 TARGET		:=	fbzx
 BUILD		:=	build
-SOURCES		:=	src src/z80free
+SOURCES		:=	src src/z80free src/minizip
 DATA		:=	 
 INCLUDES	:=	
 

src/emulator.c

@@ -38,6 +38,8 @@
 #include "tape.h"
 #include "microdrive.h"
 #include "menu_sdl.h"
+#include <dirent.h>
+
 
 #ifdef GEKKO
 #include <gccore.h>
@@ -71,14 +73,16 @@ char path_mdrs[2049];
 char path_scr[2049];
 char path_confs[2049];
 char path_poke[2049];
+char path_tmp[2049];
 unsigned int colors[80];
 unsigned int jump_frames,curr_frames;
 char *filenames[5];
 static SDL_Surface *image;
 
-bool usbismount = false;
+unsigned char usbismount = 0;
-bool networkisinit = false;
+unsigned char networkisinit = 0;
-bool smbismount = false; 
+unsigned char smbismount = 0;
+unsigned char tmpismade = 0; 
 
 extern int FULL_DISPLAY_X; //640
 extern int FULL_DISPLAY_Y; //480
@@ -90,11 +94,11 @@ extern int RATIO;
  * Mount SMB Share
  ****************************************************************************/
 
-bool ConnectShare ()
+unsigned char ConnectShare ()
 {
 	
 	if(smbismount)
-		return true;
+		return 1;
 		printf("user:  %s\n", ordenador.SmbUser);
 		printf("pass:  %s\n", ordenador.SmbPwd);
 		printf("share: %s\n", ordenador.SmbShare);
@@ -103,7 +107,7 @@ bool ConnectShare ()
 		int a;
 		for (a=0;a<3;a++)
 		if(smbInit(ordenador.SmbUser, ordenador.SmbPwd,ordenador.SmbShare, ordenador.SmbIp))
-			{smbismount = true;	break;}
+			{smbismount = 1;	break;}
 			
 		
 		if(!smbismount) printf("Failed to connect to SMB share\n");
@@ -121,26 +125,26 @@ void CloseShare()
 	printf("Disconnected from SMB share\n");
 	smbClose("smb");
 	}
-	smbismount = false;
+	smbismount = 0;
 }
 
 /****************************************************************************
  * init and deinit USB device functions
  ****************************************************************************/
  
-bool InitUSB()
+unsigned char InitUSB()
 { 
 	printf("Initializing USB FAT subsytem ...\n");
 	fatUnmount("usb:");
 	
 	// This should wake up the drive
-	bool isMounted = fatMountSimple("usb", &__io_usbstorage);
+	unsigned char isMounted = fatMountSimple("usb", &__io_usbstorage);
 	
-	bool isInserted = __io_usbstorage.isInserted();
+	unsigned char isInserted = __io_usbstorage.isInserted();
 	if (!isInserted) 
 	{
 	printf("USB device not found\n");
-	return false;
+	return 0;
 	}
  
 	// USB Drive may be "sleeeeping" 
@@ -165,19 +169,19 @@ bool InitUSB()
 	__io_usbstorage.shutdown(); 
 }
 
-bool InitNetwork()
+unsigned char InitNetwork()
 {
         char myIP[16];
 
         memset(myIP, 0, sizeof(myIP));
 	printf("Getting IP address via DHCP...\n");
 
-	if (if_config(myIP, NULL, NULL, true) < 0) {
+	if (if_config(myIP, NULL, NULL, 1) < 0) {
 	        	printf("No DHCP reply\n");
-	        	return false;
+	        	return 0;
         }
 	printf("Got an address: %s\n",myIP);
-	return true;
+	return 1;
 }
 
 #endif
@@ -202,6 +206,41 @@ if (ordenador.mustlock) {
 return 1;
 } 
 
+int remove_dir(char *dir)
+{
+	DIR *dp;
+    struct dirent *ep;
+	struct stat st;
+
+    dp = opendir (dir);
+	char str[2049];
+	
+    if (dp != NULL) 
+		{
+          while ((ep = readdir (dp)))
+			{
+				if (!strcmp(".", ep->d_name)||!strcmp("..", ep->d_name)) continue;
+				strcpy (str,dir);
+				strcat (str,"/");
+				strcat (str,ep->d_name);
+				if (stat(str, &st) < 0) continue;
+				if (S_ISDIR(st.st_mode)) remove_dir (str); //recursive call
+				else unlink (str); //remove file
+			}
+			(void) closedir(dp);
+		}
+    else
+		{
+          printf("can't access the directory\n");
+		}
+
+	if (rmdir(dir)) {printf("Can't remove the directory\n"); return (-1);} 
+	
+	return 0; 
+		  
+} 		  
+
+
 void SDL_Fullscreen_Switch()
 {
 	Uint32 flags = screen->flags;
@@ -1129,12 +1168,22 @@ int main(int argc,char *argv[]) {
 	strcpy(path_scr,path_snaps);
 	strcpy(path_confs,path_snaps);
 	strcpy(path_poke,path_snaps);
+	strcpy(path_tmp,path_snaps);
 	strcat(path_snaps,"snapshots");
 	strcat(path_taps,"tapes");
 	strcat(path_mdrs,"microdrives");
 	strcat(path_scr,"scr");
 	strcat(path_confs,"configurations");
 	strcat(path_poke,"poke");
+	strcat(path_tmp,"tmp");
+	
+	//Remove and make tmp dir
+	
+	if (!chdir(path_tmp)) remove_dir(path_tmp); //remove the tmp directory if it exists
+	
+	if (!mkdir(path_tmp,0777)){printf("Making tmp directory\n"); tmpismade=1;} 
+	else {printf("Can't make tmp directory\n"); tmpismade=0;}
+
 	
 	#ifdef GEKKO
 	if ((ordenador.port==1)&&usbismount) {
@@ -1283,6 +1332,8 @@ int main(int argc,char *argv[]) {
 		}
 	}
 	
+	if (!chdir(path_tmp)) remove_dir(path_tmp); //remove the tmp directory if it exists
+	
 	#ifdef GEKKO
 	if (smbismount) CloseShare ();
 	DeInitUSB();

src/emulator.h

@@ -38,8 +38,10 @@ extern char path_mdrs[2049];
 extern char path_scr[2049];
 extern char path_confs[2049];
 extern char path_poke[2049];
+extern char path_tmp[2049];
 extern unsigned int colors[80];
 extern unsigned int jump_frames,curr_frames;
+extern unsigned char usbismount, smbismount, tmpismade;
 
 void SDL_Fullscreen_Switch(void);
 void load_rom(char);
@@ -52,5 +54,6 @@ void init_sdl();
 void init_sound();
 void init_screen(int resx,int resy,int depth,int fullscreen,int dblbuffer,int hwsurface);
 int set_video_mode();
+int remove_dir(char *dir);
 
 #endif

src/gui_sdl.c

@@ -39,8 +39,6 @@
 #define ID_BUTTON_OFFSET 0
 #define ID_AXIS_OFFSET 32
 
-extern int usbismount, smbismount;
-
 #ifdef DEBUG
 extern FILE *fdebug;
 #define printf(...) fprintf(fdebug,__VA_ARGS__)

src/menu_sdl.c

@@ -40,6 +40,16 @@
 
 #include "characters.h"
 
+#include "minizip/unzip.h"
+
+#ifdef DEBUG
+extern FILE *fdebug;
+#define printf(...) fprintf(fdebug,__VA_ARGS__)
+#else
+ #ifdef GEKKO
+ #define printf(...)
+ #endif
+#endif
 
 typedef struct
 {
@@ -261,6 +271,67 @@ static int ext_matches_list(const char *name, const char **exts)
 	return 0;
 }
 
+static const char **get_file_list_zip(const char *path)
+{
+	unzFile uf = unzOpen(path);
+	unz_global_info gi;
+	const char **file_list;
+	int err, cur=0;
+	
+	if (!uf) return NULL;
+
+	err = unzGetGlobalInfo (uf,&gi);
+    if (err!=UNZ_OK) printf("error %d with zipfile in unzGetGlobalInfo \n",err);
+	
+	file_list = (const char**)malloc((gi.number_entry +3) * sizeof(char*));
+	file_list[cur++] = strdup("None");
+	file_list[cur++] = strdup("[..]");
+	file_list[cur] = NULL;
+
+	for (cur=2;cur<gi.number_entry+2;cur++)
+    {
+        char filename_inzip[1024];
+        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);
+            break;
+        }
+		
+		const char *exts[] = {".tap", ".TAP", ".tzx", ".TZX", ".z80",".Z80",".sna", ".SNA",
+				".mdr", ".MDR", ".scr", ".SCR", ".conf", ".CONF",".pok", ".POK" ,NULL};
+
+		if (ext_matches_list(filename_inzip, exts))
+		{
+			char *p;
+
+			p = strdup(filename_inzip);
+			file_list[cur] = p;
+			file_list[cur+1] = NULL;
+		}
+		
+		if (cur<gi.number_entry+1)
+        {
+            err = unzGoToNextFile(uf);
+            if (err!=UNZ_OK)
+            {
+                printf("error %d with zipfile in unzGoToNextFile\n",err);
+                break;
+            }
+        }
+
+	}
+	
+	unzClose(uf);
+
+    //qsort(&file_list[2], gi.number_entry, sizeof(const char *), cmpstringp);
+
+    return file_list;
+}
+
+
 static const char **get_file_list(const char *base_dir)
 {
 	DIR *d = opendir(base_dir);
@@ -282,7 +353,7 @@ static const char **get_file_list(const char *base_dir)
 	{
 		char buf[255];
 		const char *exts[] = {".tap", ".TAP", ".tzx", ".TZX", ".z80",".Z80",".sna", ".SNA",
-				".mdr", ".MDR", ".scr", ".SCR", ".conf", ".CONF",".pok", ".POK", NULL};
+				".mdr", ".MDR", ".scr", ".SCR", ".conf", ".CONF",".pok", ".POK", ".zip", ".ZIP",NULL};
 		struct stat st;
 
 		snprintf(buf, 255, "%s/%s", base_dir, de->d_name);
@@ -927,12 +998,129 @@ int menu_select(const char **msgs, int *submenus)
 	return menu_select_title("", msgs, submenus);
 }
 
+static const char *menu_select_file_internal_zip(char *path,
+		int x, int y, int x2, int y2, const char *selected_file, int which)
+{
+	const char **file_list = get_file_list_zip(path);
+	char *sel;
+	const char *ptr_selected_file;
+	int opt;
+	int i;
+	int err;
+	char buf[64];
+	
+	if (file_list == NULL) {free(path); return NULL;}
+
+	if (selected_file) 
+	{
+		ptr_selected_file= strrchr(selected_file,'/');
+		if (ptr_selected_file) ptr_selected_file++;
+		else ptr_selected_file = selected_file;
+		snprintf(buf,64,"file:%s",ptr_selected_file);
+		opt = menu_select_sized(buf, file_list, NULL, 0, x, y, x2, y2, NULL, NULL, 16);
+	}
+	else opt = menu_select_sized("Select file", file_list, NULL, 0, x, y, x2, y2, NULL, NULL ,16);
+	
+	if (opt < 0) {free(path); return NULL;}
+			
+	sel = strdup(file_list[opt]);
+
+	/* Cleanup everything - file_list is NULL-terminated */
+        for ( i = 0; file_list[i]; i++ )
+        	free((void*)file_list[i]);
+        free(file_list);
+
+	if (!sel) {free(path); return NULL;}
+	
+	if (opt==0||opt==1) {free(path); return sel;} //"None" or "[..]"
+		
+  	unzFile uf = unzOpen(path);
+	
+	if (unzLocateFile (uf, sel, 1)!= UNZ_OK) {printf ("File not found in zip/n"); unzClose(path); free(path);free (sel);return NULL;}
+	
+	free(path); //It does need anymore
+	
+	char* filename_withoutpath;
+	char* write_filename;
+    char* p;
+	
+	p = filename_withoutpath = sel;
+    while ((*p) != '\0')
+    {
+        if (((*p)=='/') || ((*p)=='\\'))
+            filename_withoutpath = p+1;
+        p++;
+    }
+	
+	if ((*filename_withoutpath)=='\0') filename_withoutpath = sel;
+	
+	write_filename = (char*)malloc(strlen(path_tmp) + strlen(filename_withoutpath) + 4);
+	
+	snprintf(write_filename, strlen(path_tmp) + strlen(filename_withoutpath) + 4, "%s/%s", path_tmp, filename_withoutpath);
+	
+	err = unzOpenCurrentFile(uf);
+        if (err!=UNZ_OK)
+        {
+            printf("error %d with zipfile in unzOpenCurrentFile\n",err);
+        }
+
+	void* buf2;
+    unsigned int size_buf = 8192;
+	FILE *fout=NULL;
+	
+    buf2 = (void*)malloc(size_buf);
+    if (buf2==NULL)
+    {
+        printf("Error allocating memory\n");
+		free(sel);
+		free(write_filename);
+        return NULL;
+    }
+
+	//unlink(write_filename);
+	
+	fout=fopen(write_filename,"wb"); 
+
+	if (fout!=NULL)
+        {
+            printf("Extracting: %s in %s\n",sel, write_filename);
+
+            do
+            {
+                err = unzReadCurrentFile(uf,buf2,size_buf);
+                if (err<0)
+                {
+                    printf("Error %d with zipfile in unzReadCurrentFile\n",err);
+                    break;
+                }
+                if (err>0)
+                    if (fwrite(buf2,err,1,fout)!=1)
+                    {
+                        printf("Error in writing extracted file\n");
+                        err=UNZ_ERRNO;
+                        break;
+                    }
+            }
+            while (err>0);
+            
+			if (fout) fclose(fout);
+        }
+	
+	unzCloseCurrentFile(uf); 
+	free(buf2);
+	free(sel);
+	
+	
+	return write_filename;
+}
+
 static const char *menu_select_file_internal(const char *dir_path,
 		int x, int y, int x2, int y2, const char *selected_file, int which)
 {
 	const char **file_list = get_file_list(dir_path);
 	char *sel;
 	char *out;
+	char *out_zip;
 	const char *ptr_selected_file;
 	int opt;
 	int i;
@@ -980,13 +1168,26 @@ static const char *menu_select_file_internal(const char *dir_path,
         		return NULL;
         	return menu_select_file(buf, selected_file, which);
         }
+		
+		
 
 	out = (char*)malloc(strlen(dir_path) + strlen(sel) + 4);
 	snprintf(out, strlen(dir_path) + strlen(sel) + 4,
 			"%s/%s", dir_path, sel);
 
 	free(sel);
-        return out;
+	
+	if ((ext_matches(out, ".zip")||ext_matches(out, ".ZIP"))&&(tmpismade))
+	{out_zip = (char *) menu_select_file_internal_zip (out, x, y, x2, y2, selected_file, which);
+	if (!out_zip) return NULL;
+	if(!strcmp(out_zip,"[..]")) 
+		{
+		free(out_zip);
+		return menu_select_file_internal (dir_path, x, y, x2, y2, selected_file, which);
+		}
+	else return out_zip;
+	}
+    else return out;
 }
 
 /*

src/minizip/crypt.h

@@ -0,0 +1,132 @@
+/* crypt.h -- base code for crypt/uncrypt ZIPfile
+
+
+   Version 1.01h, December 28th, 2009
+
+   Copyright (C) 1998-2009 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

src/minizip/ioapi.c

@@ -0,0 +1,178 @@
+/* ioapi.c -- IO base function header for compress/uncompress .zip
+   files using zlib + zip or unzip API
+
+   Version 1.01h, December 28th, 2009
+
+   Copyright (C) 1998-2009 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;
+    if (fseek((FILE *)stream, offset, fseek_origin) != 0)
+        ret = -1;
+    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;
+}

src/minizip/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.01h, December 28th, 2009
+
+   Copyright (C) 1998-2009 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
+

src/minizip/unzip.h

@@ -0,0 +1,360 @@
+/* unzip.h -- IO for uncompress .zip files using zlib
+   Version 1.01h, December 28th, 2009
+
+   Copyright (C) 1998-2009 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
+
+#ifdef HAVE_BZIP2
+#include "bzlib.h"
+#endif
+
+#define Z_BZIP2ED 12
+
+#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 */