summaryrefslogtreecommitdiff
path: root/contrib/minizip
diff options
context:
space:
mode:
Diffstat (limited to 'contrib/minizip')
-rw-r--r--contrib/minizip/ChangeLogUnzip102
-rw-r--r--contrib/minizip/Makefile50
-rw-r--r--contrib/minizip/crypt.h208
-rw-r--r--contrib/minizip/ioapi.c354
-rw-r--r--contrib/minizip/ioapi.h150
-rw-r--r--contrib/minizip/iowin32.c541
-rw-r--r--contrib/minizip/iowin32.h40
-rw-r--r--contrib/minizip/miniunz.c1112
-rw-r--r--contrib/minizip/minizip.c794
-rw-r--r--contrib/minizip/unzip.c3092
-rw-r--r--contrib/minizip/unzip.h684
-rw-r--r--contrib/minizip/zip.c2336
-rw-r--r--contrib/minizip/zip.h470
13 files changed, 4967 insertions, 4966 deletions
diff --git a/contrib/minizip/ChangeLogUnzip b/contrib/minizip/ChangeLogUnzip
index 45fd099..cfabd61 100644
--- a/contrib/minizip/ChangeLogUnzip
+++ b/contrib/minizip/ChangeLogUnzip
@@ -1,51 +1,51 @@
1Change in 0.22: (19 May 03) 1Change in 0.22: (19 May 03)
2- crypting support (unless you define NOCRYPT) 2- crypting support (unless you define NOCRYPT)
3- append file in existing zipfile 3- append file in existing zipfile
4 4
5Change in 0.21: (10 Mar 03) 5Change in 0.21: (10 Mar 03)
6- bug fixes 6- bug fixes
7 7
8Change in 0.17: (27 Jan 02) 8Change in 0.17: (27 Jan 02)
9- bug fixes 9- bug fixes
10 10
11Change in 0.16: (19 Jan 02) 11Change in 0.16: (19 Jan 02)
12- Support of ioapi for virtualize zip file access 12- Support of ioapi for virtualize zip file access
13 13
14Change in 0.15: (19 Mar 98) 14Change in 0.15: (19 Mar 98)
15- fix memory leak in minizip.c 15- fix memory leak in minizip.c
16 16
17Change in 0.14: (10 Mar 98) 17Change in 0.14: (10 Mar 98)
18- fix bugs in minizip.c sample for zipping big file 18- fix bugs in minizip.c sample for zipping big file
19- fix problem in month in date handling 19- fix problem in month in date handling
20- fix bug in unzlocal_GetCurrentFileInfoInternal in unzip.c for 20- fix bug in unzlocal_GetCurrentFileInfoInternal in unzip.c for
21 comment handling 21 comment handling
22 22
23Change in 0.13: (6 Mar 98) 23Change in 0.13: (6 Mar 98)
24- fix bugs in zip.c 24- fix bugs in zip.c
25- add real minizip sample 25- add real minizip sample
26 26
27Change in 0.12: (4 Mar 98) 27Change in 0.12: (4 Mar 98)
28- add zip.c and zip.h for creates .zip file 28- add zip.c and zip.h for creates .zip file
29- fix change_file_date in miniunz.c for Unix (Jean-loup Gailly) 29- fix change_file_date in miniunz.c for Unix (Jean-loup Gailly)
30- fix miniunz.c for file without specific record for directory 30- fix miniunz.c for file without specific record for directory
31 31
32Change in 0.11: (3 Mar 98) 32Change in 0.11: (3 Mar 98)
33- fix bug in unzGetCurrentFileInfo for get extra field and comment 33- fix bug in unzGetCurrentFileInfo for get extra field and comment
34- enhance miniunz sample, remove the bad unztst.c sample 34- enhance miniunz sample, remove the bad unztst.c sample
35 35
36Change in 0.10: (2 Mar 98) 36Change in 0.10: (2 Mar 98)
37- fix bug in unzReadCurrentFile 37- fix bug in unzReadCurrentFile
38- rename unzip* to unz* function and structure 38- rename unzip* to unz* function and structure
39- remove Windows-like hungary notation variable name 39- remove Windows-like hungary notation variable name
40- modify some structure in unzip.h 40- modify some structure in unzip.h
41- add somes comment in source 41- add somes comment in source
42- remove unzipGetcCurrentFile function 42- remove unzipGetcCurrentFile function
43- replace ZUNZEXPORT by ZEXPORT 43- replace ZUNZEXPORT by ZEXPORT
44- add unzGetLocalExtrafield for get the local extrafield info 44- add unzGetLocalExtrafield for get the local extrafield info
45- add a new sample, miniunz.c 45- add a new sample, miniunz.c
46 46
47Change in 0.4: (25 Feb 98) 47Change in 0.4: (25 Feb 98)
48- suppress the type unzipFileInZip. 48- suppress the type unzipFileInZip.
49 Only on file in the zipfile can be open at the same time 49 Only on file in the zipfile can be open at the same time
50- fix somes typo in code 50- fix somes typo in code
51- added tm_unz structure in unzip_file_info (date/time in readable format) 51- added tm_unz structure in unzip_file_info (date/time in readable format)
diff --git a/contrib/minizip/Makefile b/contrib/minizip/Makefile
index fbba3ac..84eaad2 100644
--- a/contrib/minizip/Makefile
+++ b/contrib/minizip/Makefile
@@ -1,25 +1,25 @@
1CC=cc 1CC=cc
2CFLAGS=-O -I../.. 2CFLAGS=-O -I../..
3 3
4UNZ_OBJS = miniunz.o unzip.o ioapi.o ../../libz.a 4UNZ_OBJS = miniunz.o unzip.o ioapi.o ../../libz.a
5ZIP_OBJS = minizip.o zip.o ioapi.o ../../libz.a 5ZIP_OBJS = minizip.o zip.o ioapi.o ../../libz.a
6 6
7.c.o: 7.c.o:
8 $(CC) -c $(CFLAGS) $*.c 8 $(CC) -c $(CFLAGS) $*.c
9 9
10all: miniunz minizip 10all: miniunz minizip
11 11
12miniunz: $(UNZ_OBJS) 12miniunz: $(UNZ_OBJS)
13 $(CC) $(CFLAGS) -o $@ $(UNZ_OBJS) 13 $(CC) $(CFLAGS) -o $@ $(UNZ_OBJS)
14 14
15minizip: $(ZIP_OBJS) 15minizip: $(ZIP_OBJS)
16 $(CC) $(CFLAGS) -o $@ $(ZIP_OBJS) 16 $(CC) $(CFLAGS) -o $@ $(ZIP_OBJS)
17 17
18test: miniunz minizip 18test: miniunz minizip
19 ./minizip test readme.txt 19 ./minizip test readme.txt
20 ./miniunz -l test.zip 20 ./miniunz -l test.zip
21 mv readme.txt readme.old 21 mv readme.txt readme.old
22 ./miniunz test.zip 22 ./miniunz test.zip
23 23
24clean: 24clean:
25 /bin/rm -f *.o *~ minizip miniunz 25 /bin/rm -f *.o *~ minizip miniunz
diff --git a/contrib/minizip/crypt.h b/contrib/minizip/crypt.h
index 83e763c..a02bf0b 100644
--- a/contrib/minizip/crypt.h
+++ b/contrib/minizip/crypt.h
@@ -1,104 +1,104 @@
1 1
2#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8)) 2#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8))
3 3
4/*********************************************************************** 4/***********************************************************************
5 * Return the next byte in the pseudo-random sequence 5 * Return the next byte in the pseudo-random sequence
6 */ 6 */
7static int decrypt_byte(unsigned long* pkeys, const unsigned long* pcrc_32_tab) 7static int decrypt_byte(unsigned long* pkeys, const unsigned long* pcrc_32_tab)
8{ 8{
9 unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an 9 unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an
10 * unpredictable manner on 16-bit systems; not a problem 10 * unpredictable manner on 16-bit systems; not a problem
11 * with any known compiler so far, though */ 11 * with any known compiler so far, though */
12 12
13 temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2; 13 temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2;
14 return (int)(((temp * (temp ^ 1)) >> 8) & 0xff); 14 return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);
15} 15}
16 16
17/*********************************************************************** 17/***********************************************************************
18 * Update the encryption keys with the next byte of plain text 18 * Update the encryption keys with the next byte of plain text
19 */ 19 */
20static int update_keys(unsigned long* pkeys,const unsigned long* pcrc_32_tab,int c) 20static int update_keys(unsigned long* pkeys,const unsigned long* pcrc_32_tab,int c)
21{ 21{
22 (*(pkeys+0)) = CRC32((*(pkeys+0)), c); 22 (*(pkeys+0)) = CRC32((*(pkeys+0)), c);
23 (*(pkeys+1)) += (*(pkeys+0)) & 0xff; 23 (*(pkeys+1)) += (*(pkeys+0)) & 0xff;
24 (*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1; 24 (*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1;
25 { 25 {
26 register int keyshift = (int)((*(pkeys+1)) >> 24); 26 register int keyshift = (int)((*(pkeys+1)) >> 24);
27 (*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift); 27 (*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift);
28 } 28 }
29 return c; 29 return c;
30} 30}
31 31
32 32
33/*********************************************************************** 33/***********************************************************************
34 * Initialize the encryption keys and the random header according to 34 * Initialize the encryption keys and the random header according to
35 * the given password. 35 * the given password.
36 */ 36 */
37static void init_keys(const char* passwd,unsigned long* pkeys,const unsigned long* pcrc_32_tab) 37static void init_keys(const char* passwd,unsigned long* pkeys,const unsigned long* pcrc_32_tab)
38{ 38{
39 *(pkeys+0) = 305419896L; 39 *(pkeys+0) = 305419896L;
40 *(pkeys+1) = 591751049L; 40 *(pkeys+1) = 591751049L;
41 *(pkeys+2) = 878082192L; 41 *(pkeys+2) = 878082192L;
42 while (*passwd != '\0') { 42 while (*passwd != '\0') {
43 update_keys(pkeys,pcrc_32_tab,(int)*passwd); 43 update_keys(pkeys,pcrc_32_tab,(int)*passwd);
44 passwd++; 44 passwd++;
45 } 45 }
46} 46}
47 47
48#define zdecode(pkeys,pcrc_32_tab,c) \ 48#define zdecode(pkeys,pcrc_32_tab,c) \
49 (update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab))) 49 (update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab)))
50 50
51#define zencode(pkeys,pcrc_32_tab,c,t) \ 51#define zencode(pkeys,pcrc_32_tab,c,t) \
52 (t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c)) 52 (t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c))
53 53
54#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED 54#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED
55 55
56#define RAND_HEAD_LEN 12 56#define RAND_HEAD_LEN 12
57 /* "last resort" source for second part of crypt seed pattern */ 57 /* "last resort" source for second part of crypt seed pattern */
58# ifndef ZCR_SEED2 58# ifndef ZCR_SEED2
59# define ZCR_SEED2 (unsigned long)3141592654L /* use PI as default pattern */ 59# define ZCR_SEED2 3141592654UL /* use PI as default pattern */
60# endif 60# endif
61 61
62static int crypthead(passwd, buf, bufSize, pkeys, pcrc_32_tab, crcForCrypting) 62static int crypthead(passwd, buf, bufSize, pkeys, pcrc_32_tab, crcForCrypting)
63 const char *passwd; /* password string */ 63 const char *passwd; /* password string */
64 unsigned char *buf; /* where to write header */ 64 unsigned char *buf; /* where to write header */
65 int bufSize; 65 int bufSize;
66 unsigned long* pkeys; 66 unsigned long* pkeys;
67 const unsigned long* pcrc_32_tab; 67 const unsigned long* pcrc_32_tab;
68 unsigned long crcForCrypting; 68 unsigned long crcForCrypting;
69{ 69{
70 int n; /* index in random header */ 70 int n; /* index in random header */
71 int t; /* temporary */ 71 int t; /* temporary */
72 int c; /* random byte */ 72 int c; /* random byte */
73 unsigned char header[RAND_HEAD_LEN-2]; /* random header */ 73 unsigned char header[RAND_HEAD_LEN-2]; /* random header */
74 static unsigned calls = 0; /* ensure different random header each time */ 74 static unsigned calls = 0; /* ensure different random header each time */
75 75
76 if (bufSize<RAND_HEAD_LEN) 76 if (bufSize<RAND_HEAD_LEN)
77 return 0; 77 return 0;
78 78
79 /* First generate RAND_HEAD_LEN-2 random bytes. We encrypt the 79 /* First generate RAND_HEAD_LEN-2 random bytes. We encrypt the
80 * output of rand() to get less predictability, since rand() is 80 * output of rand() to get less predictability, since rand() is
81 * often poorly implemented. 81 * often poorly implemented.
82 */ 82 */
83 if (++calls == 1) 83 if (++calls == 1)
84 { 84 {
85 srand((unsigned)(time(NULL) ^ ZCR_SEED2)); 85 srand((unsigned)(time(NULL) ^ ZCR_SEED2));
86 } 86 }
87 init_keys(passwd, pkeys, pcrc_32_tab); 87 init_keys(passwd, pkeys, pcrc_32_tab);
88 for (n = 0; n < RAND_HEAD_LEN-2; n++) 88 for (n = 0; n < RAND_HEAD_LEN-2; n++)
89 { 89 {
90 c = (rand() >> 7) & 0xff; 90 c = (rand() >> 7) & 0xff;
91 header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t); 91 header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t);
92 } 92 }
93 /* Encrypt random header (last two bytes is high word of crc) */ 93 /* Encrypt random header (last two bytes is high word of crc) */
94 init_keys(passwd, pkeys, pcrc_32_tab); 94 init_keys(passwd, pkeys, pcrc_32_tab);
95 for (n = 0; n < RAND_HEAD_LEN-2; n++) 95 for (n = 0; n < RAND_HEAD_LEN-2; n++)
96 { 96 {
97 buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t); 97 buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t);
98 } 98 }
99 buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t); 99 buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t);
100 buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t); 100 buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t);
101 return n; 101 return n;
102} 102}
103 103
104#endif 104#endif
diff --git a/contrib/minizip/ioapi.c b/contrib/minizip/ioapi.c
index 61c6e2b..ea9ee30 100644
--- a/contrib/minizip/ioapi.c
+++ b/contrib/minizip/ioapi.c
@@ -1,177 +1,177 @@
1/* ioapi.c -- IO base function header for compress/uncompress .zip 1/* ioapi.c -- IO base function header for compress/uncompress .zip
2 files using zlib + zip or unzip API 2 files using zlib + zip or unzip API
3 3
4 Version 0.22, May 19th, 2003 4 Version 0.22, May 19th, 2003
5 5
6 Copyright (C) 1998-2003 Gilles Vollant 6 Copyright (C) 1998-2003 Gilles Vollant
7*/ 7*/
8 8
9#include <stdio.h> 9#include <stdio.h>
10#include <stdlib.h> 10#include <stdlib.h>
11#include <string.h> 11#include <string.h>
12 12
13#include "zlib.h" 13#include "zlib.h"
14#include "ioapi.h" 14#include "ioapi.h"
15 15
16 16
17 17
18/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */ 18/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
19 19
20#ifndef SEEK_CUR 20#ifndef SEEK_CUR
21#define SEEK_CUR 1 21#define SEEK_CUR 1
22#endif 22#endif
23 23
24#ifndef SEEK_END 24#ifndef SEEK_END
25#define SEEK_END 2 25#define SEEK_END 2
26#endif 26#endif
27 27
28#ifndef SEEK_SET 28#ifndef SEEK_SET
29#define SEEK_SET 0 29#define SEEK_SET 0
30#endif 30#endif
31 31
32voidpf ZCALLBACK fopen_file_func OF(( 32voidpf ZCALLBACK fopen_file_func OF((
33 voidpf opaque, 33 voidpf opaque,
34 const char* filename, 34 const char* filename,
35 int mode)); 35 int mode));
36 36
37uLong ZCALLBACK fread_file_func OF(( 37uLong ZCALLBACK fread_file_func OF((
38 voidpf opaque, 38 voidpf opaque,
39 voidpf stream, 39 voidpf stream,
40 void* buf, 40 void* buf,
41 uLong size)); 41 uLong size));
42 42
43uLong ZCALLBACK fwrite_file_func OF(( 43uLong ZCALLBACK fwrite_file_func OF((
44 voidpf opaque, 44 voidpf opaque,
45 voidpf stream, 45 voidpf stream,
46 const void* buf, 46 const void* buf,
47 uLong size)); 47 uLong size));
48 48
49long ZCALLBACK ftell_file_func OF(( 49long ZCALLBACK ftell_file_func OF((
50 voidpf opaque, 50 voidpf opaque,
51 voidpf stream)); 51 voidpf stream));
52 52
53long ZCALLBACK fseek_file_func OF(( 53long ZCALLBACK fseek_file_func OF((
54 voidpf opaque, 54 voidpf opaque,
55 voidpf stream, 55 voidpf stream,
56 uLong offset, 56 uLong offset,
57 int origin)); 57 int origin));
58 58
59int ZCALLBACK fclose_file_func OF(( 59int ZCALLBACK fclose_file_func OF((
60 voidpf opaque, 60 voidpf opaque,
61 voidpf stream)); 61 voidpf stream));
62 62
63int ZCALLBACK ferror_file_func OF(( 63int ZCALLBACK ferror_file_func OF((
64 voidpf opaque, 64 voidpf opaque,
65 voidpf stream)); 65 voidpf stream));
66 66
67 67
68voidpf ZCALLBACK fopen_file_func (opaque, filename, mode) 68voidpf ZCALLBACK fopen_file_func (opaque, filename, mode)
69 voidpf opaque; 69 voidpf opaque;
70 const char* filename; 70 const char* filename;
71 int mode; 71 int mode;
72{ 72{
73 FILE* file = NULL; 73 FILE* file = NULL;
74 const char* mode_fopen = NULL; 74 const char* mode_fopen = NULL;
75 if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ) 75 if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
76 mode_fopen = "rb"; 76 mode_fopen = "rb";
77 else 77 else
78 if (mode & ZLIB_FILEFUNC_MODE_EXISTING) 78 if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
79 mode_fopen = "r+b"; 79 mode_fopen = "r+b";
80 else 80 else
81 if (mode & ZLIB_FILEFUNC_MODE_CREATE) 81 if (mode & ZLIB_FILEFUNC_MODE_CREATE)
82 mode_fopen = "wb"; 82 mode_fopen = "wb";
83 83
84 if ((filename!=NULL) && (mode_fopen != NULL)) 84 if ((filename!=NULL) && (mode_fopen != NULL))
85 file = fopen(filename, mode_fopen); 85 file = fopen(filename, mode_fopen);
86 return file; 86 return file;
87} 87}
88 88
89 89
90uLong ZCALLBACK fread_file_func (opaque, stream, buf, size) 90uLong ZCALLBACK fread_file_func (opaque, stream, buf, size)
91 voidpf opaque; 91 voidpf opaque;
92 voidpf stream; 92 voidpf stream;
93 void* buf; 93 void* buf;
94 uLong size; 94 uLong size;
95{ 95{
96 uLong ret; 96 uLong ret;
97 ret = fread(buf, 1, (size_t)size, (FILE *)stream); 97 ret = fread(buf, 1, (size_t)size, (FILE *)stream);
98 return ret; 98 return ret;
99} 99}
100 100
101 101
102uLong ZCALLBACK fwrite_file_func (opaque, stream, buf, size) 102uLong ZCALLBACK fwrite_file_func (opaque, stream, buf, size)
103 voidpf opaque; 103 voidpf opaque;
104 voidpf stream; 104 voidpf stream;
105 const void* buf; 105 const void* buf;
106 uLong size; 106 uLong size;
107{ 107{
108 uLong ret; 108 uLong ret;
109 ret = fwrite(buf, 1, (size_t)size, (FILE *)stream); 109 ret = fwrite(buf, 1, (size_t)size, (FILE *)stream);
110 return ret; 110 return ret;
111} 111}
112 112
113long ZCALLBACK ftell_file_func (opaque, stream) 113long ZCALLBACK ftell_file_func (opaque, stream)
114 voidpf opaque; 114 voidpf opaque;
115 voidpf stream; 115 voidpf stream;
116{ 116{
117 long ret; 117 long ret;
118 ret = ftell((FILE *)stream); 118 ret = ftell((FILE *)stream);
119 return ret; 119 return ret;
120} 120}
121 121
122long ZCALLBACK fseek_file_func (opaque, stream, offset, origin) 122long ZCALLBACK fseek_file_func (opaque, stream, offset, origin)
123 voidpf opaque; 123 voidpf opaque;
124 voidpf stream; 124 voidpf stream;
125 uLong offset; 125 uLong offset;
126 int origin; 126 int origin;
127{ 127{
128 int fseek_origin=0; 128 int fseek_origin=0;
129 long ret; 129 long ret;
130 switch (origin) 130 switch (origin)
131 { 131 {
132 case ZLIB_FILEFUNC_SEEK_CUR : 132 case ZLIB_FILEFUNC_SEEK_CUR :
133 fseek_origin = SEEK_CUR; 133 fseek_origin = SEEK_CUR;
134 break; 134 break;
135 case ZLIB_FILEFUNC_SEEK_END : 135 case ZLIB_FILEFUNC_SEEK_END :
136 fseek_origin = SEEK_END; 136 fseek_origin = SEEK_END;
137 break; 137 break;
138 case ZLIB_FILEFUNC_SEEK_SET : 138 case ZLIB_FILEFUNC_SEEK_SET :
139 fseek_origin = SEEK_SET; 139 fseek_origin = SEEK_SET;
140 break; 140 break;
141 default: return -1; 141 default: return -1;
142 } 142 }
143 ret = 0; 143 ret = 0;
144 fseek((FILE *)stream, offset, fseek_origin); 144 fseek((FILE *)stream, offset, fseek_origin);
145 return ret; 145 return ret;
146} 146}
147 147
148int ZCALLBACK fclose_file_func (opaque, stream) 148int ZCALLBACK fclose_file_func (opaque, stream)
149 voidpf opaque; 149 voidpf opaque;
150 voidpf stream; 150 voidpf stream;
151{ 151{
152 int ret; 152 int ret;
153 ret = fclose((FILE *)stream); 153 ret = fclose((FILE *)stream);
154 return ret; 154 return ret;
155} 155}
156 156
157int ZCALLBACK ferror_file_func (opaque, stream) 157int ZCALLBACK ferror_file_func (opaque, stream)
158 voidpf opaque; 158 voidpf opaque;
159 voidpf stream; 159 voidpf stream;
160{ 160{
161 int ret; 161 int ret;
162 ret = ferror((FILE *)stream); 162 ret = ferror((FILE *)stream);
163 return ret; 163 return ret;
164} 164}
165 165
166void fill_fopen_filefunc (pzlib_filefunc_def) 166void fill_fopen_filefunc (pzlib_filefunc_def)
167 zlib_filefunc_def* pzlib_filefunc_def; 167 zlib_filefunc_def* pzlib_filefunc_def;
168{ 168{
169 pzlib_filefunc_def->zopen_file = fopen_file_func; 169 pzlib_filefunc_def->zopen_file = fopen_file_func;
170 pzlib_filefunc_def->zread_file = fread_file_func; 170 pzlib_filefunc_def->zread_file = fread_file_func;
171 pzlib_filefunc_def->zwrite_file = fwrite_file_func; 171 pzlib_filefunc_def->zwrite_file = fwrite_file_func;
172 pzlib_filefunc_def->ztell_file = ftell_file_func; 172 pzlib_filefunc_def->ztell_file = ftell_file_func;
173 pzlib_filefunc_def->zseek_file = fseek_file_func; 173 pzlib_filefunc_def->zseek_file = fseek_file_func;
174 pzlib_filefunc_def->zclose_file = fclose_file_func; 174 pzlib_filefunc_def->zclose_file = fclose_file_func;
175 pzlib_filefunc_def->zerror_file = ferror_file_func; 175 pzlib_filefunc_def->zerror_file = ferror_file_func;
176 pzlib_filefunc_def->opaque = NULL; 176 pzlib_filefunc_def->opaque = NULL;
177} 177}
diff --git a/contrib/minizip/ioapi.h b/contrib/minizip/ioapi.h
index 6b8f1f1..13f4f21 100644
--- a/contrib/minizip/ioapi.h
+++ b/contrib/minizip/ioapi.h
@@ -1,75 +1,75 @@
1/* ioapi.h -- IO base function header for compress/uncompress .zip 1/* ioapi.h -- IO base function header for compress/uncompress .zip
2 files using zlib + zip or unzip API 2 files using zlib + zip or unzip API
3 3
4 Version 0.22, May 19th, 2003 4 Version 0.22, May 19th, 2003
5 5
6 Copyright (C) 1998-2003 Gilles Vollant 6 Copyright (C) 1998-2003 Gilles Vollant
7*/ 7*/
8 8
9#ifndef _ZLIBIOAPI_H 9#ifndef _ZLIBIOAPI_H
10#define _ZLIBIOAPI_H 10#define _ZLIBIOAPI_H
11 11
12 12
13#define ZLIB_FILEFUNC_SEEK_CUR (1) 13#define ZLIB_FILEFUNC_SEEK_CUR (1)
14#define ZLIB_FILEFUNC_SEEK_END (2) 14#define ZLIB_FILEFUNC_SEEK_END (2)
15#define ZLIB_FILEFUNC_SEEK_SET (0) 15#define ZLIB_FILEFUNC_SEEK_SET (0)
16 16
17#define ZLIB_FILEFUNC_MODE_READ (1) 17#define ZLIB_FILEFUNC_MODE_READ (1)
18#define ZLIB_FILEFUNC_MODE_WRITE (2) 18#define ZLIB_FILEFUNC_MODE_WRITE (2)
19#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3) 19#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3)
20 20
21#define ZLIB_FILEFUNC_MODE_EXISTING (4) 21#define ZLIB_FILEFUNC_MODE_EXISTING (4)
22#define ZLIB_FILEFUNC_MODE_CREATE (8) 22#define ZLIB_FILEFUNC_MODE_CREATE (8)
23 23
24 24
25#ifndef ZCALLBACK 25#ifndef ZCALLBACK
26 26
27#if (defined(WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK) 27#if (defined(WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK)
28#define ZCALLBACK CALLBACK 28#define ZCALLBACK CALLBACK
29#else 29#else
30#define ZCALLBACK 30#define ZCALLBACK
31#endif 31#endif
32#endif 32#endif
33 33
34#ifdef __cplusplus 34#ifdef __cplusplus
35extern "C" { 35extern "C" {
36#endif 36#endif
37 37
38typedef voidpf (ZCALLBACK *open_file_func) OF((voidpf opaque, const char* filename, int mode)); 38typedef voidpf (ZCALLBACK *open_file_func) OF((voidpf opaque, const char* filename, int mode));
39typedef uLong (ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void* buf, uLong size)); 39typedef uLong (ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void* buf, uLong size));
40typedef uLong (ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void* buf, uLong size)); 40typedef uLong (ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void* buf, uLong size));
41typedef long (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream)); 41typedef long (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream));
42typedef long (ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin)); 42typedef long (ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin));
43typedef int (ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream)); 43typedef int (ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream));
44typedef int (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream)); 44typedef int (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream));
45 45
46typedef struct zlib_filefunc_def_s 46typedef struct zlib_filefunc_def_s
47{ 47{
48 open_file_func zopen_file; 48 open_file_func zopen_file;
49 read_file_func zread_file; 49 read_file_func zread_file;
50 write_file_func zwrite_file; 50 write_file_func zwrite_file;
51 tell_file_func ztell_file; 51 tell_file_func ztell_file;
52 seek_file_func zseek_file; 52 seek_file_func zseek_file;
53 close_file_func zclose_file; 53 close_file_func zclose_file;
54 testerror_file_func zerror_file; 54 testerror_file_func zerror_file;
55 voidpf opaque; 55 voidpf opaque;
56} zlib_filefunc_def; 56} zlib_filefunc_def;
57 57
58 58
59 59
60void fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def)); 60void fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
61 61
62#define ZREAD(filefunc,filestream,buf,size) ((*((filefunc).zread_file))((filefunc).opaque,filestream,buf,size)) 62#define ZREAD(filefunc,filestream,buf,size) ((*((filefunc).zread_file))((filefunc).opaque,filestream,buf,size))
63#define ZWRITE(filefunc,filestream,buf,size) ((*((filefunc).zwrite_file))((filefunc).opaque,filestream,buf,size)) 63#define ZWRITE(filefunc,filestream,buf,size) ((*((filefunc).zwrite_file))((filefunc).opaque,filestream,buf,size))
64#define ZTELL(filefunc,filestream) ((*((filefunc).ztell_file))((filefunc).opaque,filestream)) 64#define ZTELL(filefunc,filestream) ((*((filefunc).ztell_file))((filefunc).opaque,filestream))
65#define ZSEEK(filefunc,filestream,pos,mode) ((*((filefunc).zseek_file))((filefunc).opaque,filestream,pos,mode)) 65#define ZSEEK(filefunc,filestream,pos,mode) ((*((filefunc).zseek_file))((filefunc).opaque,filestream,pos,mode))
66#define ZCLOSE(filefunc,filestream) ((*((filefunc).zclose_file))((filefunc).opaque,filestream)) 66#define ZCLOSE(filefunc,filestream) ((*((filefunc).zclose_file))((filefunc).opaque,filestream))
67#define ZERROR(filefunc,filestream) ((*((filefunc).zerror_file))((filefunc).opaque,filestream)) 67#define ZERROR(filefunc,filestream) ((*((filefunc).zerror_file))((filefunc).opaque,filestream))
68 68
69 69
70#ifdef __cplusplus 70#ifdef __cplusplus
71} 71}
72#endif 72#endif
73 73
74#endif 74#endif
75 75
diff --git a/contrib/minizip/iowin32.c b/contrib/minizip/iowin32.c
index 53198b6..8e6d43d 100644
--- a/contrib/minizip/iowin32.c
+++ b/contrib/minizip/iowin32.c
@@ -1,271 +1,270 @@
1/* iowin32.c -- IO base function header for compress/uncompress .zip 1/* iowin32.c -- IO base function header for compress/uncompress .zip
2 files using zlib + zip or unzip API 2 files using zlib + zip or unzip API
3 This IO API version uses the Win32 API (for Microsoft Windows) 3 This IO API version uses the Win32 API (for Microsoft Windows)
4 4
5 Version 0.22, May 19th, 2003 5 Version 0.22, May 19th, 2003
6 6
7 Copyright (C) 1998-2003 Gilles Vollant 7 Copyright (C) 1998-2003 Gilles Vollant
8*/ 8*/
9 9
10#include <windows.h> 10#include <stdlib.h>
11#include <stdlib.h> 11
12 12#include "zlib.h"
13#include "zlib.h" 13#include "ioapi.h"
14#include "ioapi.h" 14#include "iowin32.h"
15#include "iowin32.h" 15
16 16#ifndef INVALID_HANDLE_VALUE
17#ifndef INVALID_HANDLE_VALUE 17#define INVALID_HANDLE_VALUE (0xFFFFFFFF)
18#define INVALID_HANDLE_VALUE (0xFFFFFFFF) 18#endif
19#endif 19
20 20#ifndef INVALID_SET_FILE_POINTER
21#ifndef INVALID_SET_FILE_POINTER 21#define INVALID_SET_FILE_POINTER ((DWORD)-1)
22#define INVALID_SET_FILE_POINTER ((DWORD)-1) 22#endif
23#endif 23
24 24voidpf ZCALLBACK win32_open_file_func OF((
25voidpf ZCALLBACK win32_open_file_func OF(( 25 voidpf opaque,
26 voidpf opaque, 26 const char* filename,
27 const char* filename, 27 int mode));
28 int mode)); 28
29 29uLong ZCALLBACK win32_read_file_func OF((
30uLong ZCALLBACK win32_read_file_func OF(( 30 voidpf opaque,
31 voidpf opaque, 31 voidpf stream,
32 voidpf stream, 32 void* buf,
33 void* buf, 33 uLong size));
34 uLong size)); 34
35 35uLong ZCALLBACK win32_write_file_func OF((
36uLong ZCALLBACK win32_write_file_func OF(( 36 voidpf opaque,
37 voidpf opaque, 37 voidpf stream,
38 voidpf stream, 38 const void* buf,
39 const void* buf, 39 uLong size));
40 uLong size)); 40
41 41long ZCALLBACK win32_tell_file_func OF((
42long ZCALLBACK win32_tell_file_func OF(( 42 voidpf opaque,
43 voidpf opaque, 43 voidpf stream));
44 voidpf stream)); 44
45 45long ZCALLBACK win32_seek_file_func OF((
46long ZCALLBACK win32_seek_file_func OF(( 46 voidpf opaque,
47 voidpf opaque, 47 voidpf stream,
48 voidpf stream, 48 uLong offset,
49 uLong offset, 49 int origin));
50 int origin)); 50
51 51int ZCALLBACK win32_close_file_func OF((
52long ZCALLBACK win32_close_file_func OF(( 52 voidpf opaque,
53 voidpf opaque, 53 voidpf stream));
54 voidpf stream)); 54
55 55int ZCALLBACK win32_error_file_func OF((
56int ZCALLBACK win32_error_file_func OF(( 56 voidpf opaque,
57 voidpf opaque, 57 voidpf stream));
58 voidpf stream)); 58
59 59typedef struct
60typedef struct 60{
61{ 61 HANDLE hf;
62 HANDLE hf; 62 int error;
63 int error; 63} WIN32FILE_IOWIN;
64} WIN32FILE_IOWIN; 64
65 65voidpf ZCALLBACK win32_open_file_func (opaque, filename, mode)
66voidpf ZCALLBACK win32_open_file_func (opaque, filename, mode) 66 voidpf opaque;
67 voidpf opaque; 67 const char* filename;
68 const char* filename; 68 int mode;
69 int mode; 69{
70{ 70 const char* mode_fopen = NULL;
71 const char* mode_fopen = NULL; 71 DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
72 DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ; 72 HANDLE hFile = 0;
73 HANDLE hFile = 0; 73 voidpf ret=NULL;
74 voidpf ret=NULL; 74
75 75 dwDesiredAccess = dwShareMode = dwFlagsAndAttributes = 0;
76 dwDesiredAccess = dwShareMode = dwFlagsAndAttributes = 0; 76
77 77 if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
78 if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ) 78 {
79 { 79 dwDesiredAccess = GENERIC_READ;
80 dwDesiredAccess = GENERIC_READ; 80 dwCreationDisposition = OPEN_EXISTING;
81 dwCreationDisposition = OPEN_EXISTING; 81 dwShareMode = FILE_SHARE_READ;
82 dwShareMode = FILE_SHARE_READ; 82 }
83 } 83 else
84 else 84 if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
85 if (mode & ZLIB_FILEFUNC_MODE_EXISTING) 85 {
86 { 86 dwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
87 dwDesiredAccess = GENERIC_WRITE | GENERIC_READ; 87 dwCreationDisposition = OPEN_EXISTING;
88 dwCreationDisposition = OPEN_EXISTING; 88 }
89 } 89 else
90 else 90 if (mode & ZLIB_FILEFUNC_MODE_CREATE)
91 if (mode & ZLIB_FILEFUNC_MODE_CREATE) 91 {
92 { 92 dwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
93 dwDesiredAccess = GENERIC_WRITE | GENERIC_READ; 93 dwCreationDisposition = CREATE_ALWAYS;
94 dwCreationDisposition = CREATE_ALWAYS; 94 }
95 } 95
96 96 if ((filename!=NULL) && (dwDesiredAccess != 0))
97 if ((filename!=NULL) && (dwDesiredAccess != 0)) 97 hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL,
98 hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, 98 dwCreationDisposition, dwFlagsAndAttributes, NULL);
99 dwCreationDisposition, dwFlagsAndAttributes, NULL); 99
100 100 if (hFile == INVALID_HANDLE_VALUE)
101 if (hFile == INVALID_HANDLE_VALUE) 101 hFile = NULL;
102 hFile = NULL; 102
103 103 if (hFile != NULL)
104 if (hFile != NULL) 104 {
105 { 105 WIN32FILE_IOWIN w32fiow;
106 WIN32FILE_IOWIN w32fiow; 106 w32fiow.hf = hFile;
107 w32fiow.hf = hFile; 107 w32fiow.error = 0;
108 w32fiow.error = 0; 108 ret = malloc(sizeof(WIN32FILE_IOWIN));
109 ret = malloc(sizeof(WIN32FILE_IOWIN)); 109 if (ret==NULL)
110 if (ret==NULL) 110 CloseHandle(hFile);
111 CloseHandle(hFile); 111 else *((WIN32FILE_IOWIN*)ret) = w32fiow;
112 else *((WIN32FILE_IOWIN*)ret) = w32fiow; 112 }
113 } 113 return ret;
114 return ret; 114}
115} 115
116 116
117 117uLong ZCALLBACK win32_read_file_func (opaque, stream, buf, size)
118uLong ZCALLBACK win32_read_file_func (opaque, stream, buf, size) 118 voidpf opaque;
119 voidpf opaque; 119 voidpf stream;
120 voidpf stream; 120 void* buf;
121 void* buf; 121 uLong size;
122 uLong size; 122{
123{ 123 uLong ret=0;
124 uLong ret=0; 124 HANDLE hFile = NULL;
125 HANDLE hFile = NULL; 125 if (stream!=NULL)
126 if (stream!=NULL) 126 hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
127 hFile = ((WIN32FILE_IOWIN*)stream) -> hf; 127 if (hFile != NULL)
128 if (hFile != NULL) 128 if (!ReadFile(hFile, buf, size, &ret, NULL))
129 if (!ReadFile(hFile, buf, size, &ret, NULL)) 129 {
130 { 130 DWORD dwErr = GetLastError();
131 DWORD dwErr = GetLastError(); 131 if (dwErr == ERROR_HANDLE_EOF)
132 if (dwErr == ERROR_HANDLE_EOF) 132 dwErr = 0;
133 dwErr = 0; 133 ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
134 ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; 134 }
135 } 135
136 136 return ret;
137 return ret; 137}
138} 138
139 139
140 140uLong ZCALLBACK win32_write_file_func (opaque, stream, buf, size)
141uLong ZCALLBACK win32_write_file_func (opaque, stream, buf, size) 141 voidpf opaque;
142 voidpf opaque; 142 voidpf stream;
143 voidpf stream; 143 const void* buf;
144 const void* buf; 144 uLong size;
145 uLong size; 145{
146{ 146 uLong ret=0;
147 uLong ret=0; 147 HANDLE hFile = NULL;
148 HANDLE hFile = NULL; 148 if (stream!=NULL)
149 if (stream!=NULL) 149 hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
150 hFile = ((WIN32FILE_IOWIN*)stream) -> hf; 150
151 151 if (hFile !=NULL)
152 if (hFile !=NULL) 152 if (!WriteFile(hFile, buf, size, &ret, NULL))
153 if (!WriteFile(hFile, buf, size, &ret, NULL)) 153 {
154 { 154 DWORD dwErr = GetLastError();
155 DWORD dwErr = GetLastError(); 155 if (dwErr == ERROR_HANDLE_EOF)
156 if (dwErr == ERROR_HANDLE_EOF) 156 dwErr = 0;
157 dwErr = 0; 157 ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
158 ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; 158 }
159 } 159
160 160 return ret;
161 return ret; 161}
162} 162
163 163long ZCALLBACK win32_tell_file_func (opaque, stream)
164long ZCALLBACK win32_tell_file_func (opaque, stream) 164 voidpf opaque;
165 voidpf opaque; 165 voidpf stream;
166 voidpf stream; 166{
167{ 167 long ret=-1;
168 long ret=-1; 168 HANDLE hFile = NULL;
169 HANDLE hFile = NULL; 169 if (stream!=NULL)
170 if (stream!=NULL) 170 hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
171 hFile = ((WIN32FILE_IOWIN*)stream) -> hf; 171 if (hFile != NULL)
172 if (hFile != NULL) 172 {
173 { 173 DWORD dwSet = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
174 DWORD dwSet = SetFilePointer(hFile, 0, NULL, FILE_CURRENT); 174 if (dwSet == INVALID_SET_FILE_POINTER)
175 if (dwSet == INVALID_SET_FILE_POINTER) 175 {
176 { 176 DWORD dwErr = GetLastError();
177 DWORD dwErr = GetLastError(); 177 ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
178 ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; 178 ret = -1;
179 ret = -1; 179 }
180 } 180 else
181 else 181 ret=(long)dwSet;
182 ret=(long)dwSet; 182 }
183 } 183 return ret;
184 return ret; 184}
185} 185
186 186long ZCALLBACK win32_seek_file_func (opaque, stream, offset, origin)
187long ZCALLBACK win32_seek_file_func (opaque, stream, offset, origin) 187 voidpf opaque;
188 voidpf opaque; 188 voidpf stream;
189 voidpf stream; 189 uLong offset;
190 uLong offset; 190 int origin;
191 int origin; 191{
192{ 192 DWORD dwMoveMethod=0xFFFFFFFF;
193 DWORD dwMoveMethod=0xFFFFFFFF; 193 HANDLE hFile = NULL;
194 HANDLE hFile = NULL; 194
195 195 long ret=-1;
196 long ret=-1; 196 if (stream!=NULL)
197 if (stream!=NULL) 197 hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
198 hFile = ((WIN32FILE_IOWIN*)stream) -> hf; 198 switch (origin)
199 switch (origin) 199 {
200 { 200 case ZLIB_FILEFUNC_SEEK_CUR :
201 case ZLIB_FILEFUNC_SEEK_CUR : 201 dwMoveMethod = FILE_CURRENT;
202 dwMoveMethod = FILE_CURRENT; 202 break;
203 break; 203 case ZLIB_FILEFUNC_SEEK_END :
204 case ZLIB_FILEFUNC_SEEK_END : 204 dwMoveMethod = FILE_END;
205 dwMoveMethod = FILE_END; 205 break;
206 break; 206 case ZLIB_FILEFUNC_SEEK_SET :
207 case ZLIB_FILEFUNC_SEEK_SET : 207 dwMoveMethod = FILE_BEGIN;
208 dwMoveMethod = FILE_BEGIN; 208 break;
209 break; 209 default: return -1;
210 default: return -1; 210 }
211 } 211
212 212 if (hFile != NULL)
213 if (hFile != NULL) 213 {
214 { 214 DWORD dwSet = SetFilePointer(hFile, offset, NULL, dwMoveMethod);
215 DWORD dwSet = SetFilePointer(hFile, offset, NULL, dwMoveMethod); 215 if (dwSet == INVALID_SET_FILE_POINTER)
216 if (dwSet == INVALID_SET_FILE_POINTER) 216 {
217 { 217 DWORD dwErr = GetLastError();
218 DWORD dwErr = GetLastError(); 218 ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
219 ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; 219 ret = -1;
220 ret = -1; 220 }
221 } 221 else
222 else 222 ret=0;
223 ret=0; 223 }
224 } 224 return ret;
225 return ret; 225}
226} 226
227 227int ZCALLBACK win32_close_file_func (opaque, stream)
228long ZCALLBACK win32_close_file_func (opaque, stream) 228 voidpf opaque;
229 voidpf opaque; 229 voidpf stream;
230 voidpf stream; 230{
231{ 231 int ret=-1;
232 long ret=-1; 232
233 233 if (stream!=NULL)
234 if (stream!=NULL) 234 {
235 { 235 HANDLE hFile;
236 HANDLE hFile; 236 hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
237 hFile = ((WIN32FILE_IOWIN*)stream) -> hf; 237 if (hFile != NULL)
238 if (hFile != NULL) 238 {
239 { 239 CloseHandle(hFile);
240 CloseHandle(hFile); 240 ret=0;
241 ret=0; 241 }
242 } 242 free(stream);
243 free(stream); 243 }
244 } 244 return ret;
245 return ret; 245}
246} 246
247 247int ZCALLBACK win32_error_file_func (opaque, stream)
248int ZCALLBACK win32_error_file_func (opaque, stream) 248 voidpf opaque;
249 voidpf opaque; 249 voidpf stream;
250 voidpf stream; 250{
251{ 251 int ret=-1;
252 int ret=-1; 252 if (stream!=NULL)
253 if (stream!=NULL) 253 {
254 { 254 ret = ((WIN32FILE_IOWIN*)stream) -> error;
255 ret = ((WIN32FILE_IOWIN*)stream) -> error; 255 }
256 } 256 return ret;
257 return ret; 257}
258} 258
259 259void fill_win32_filefunc (pzlib_filefunc_def)
260void fill_win32_filefunc (pzlib_filefunc_def) 260 zlib_filefunc_def* pzlib_filefunc_def;
261 zlib_filefunc_def* pzlib_filefunc_def; 261{
262{ 262 pzlib_filefunc_def->zopen_file = win32_open_file_func;
263 pzlib_filefunc_def->zopen_file = win32_open_file_func; 263 pzlib_filefunc_def->zread_file = win32_read_file_func;
264 pzlib_filefunc_def->zread_file = win32_read_file_func; 264 pzlib_filefunc_def->zwrite_file = win32_write_file_func;
265 pzlib_filefunc_def->zwrite_file = win32_write_file_func; 265 pzlib_filefunc_def->ztell_file = win32_tell_file_func;
266 pzlib_filefunc_def->ztell_file = win32_tell_file_func; 266 pzlib_filefunc_def->zseek_file = win32_seek_file_func;
267 pzlib_filefunc_def->zseek_file = win32_seek_file_func; 267 pzlib_filefunc_def->zclose_file = win32_close_file_func;
268 pzlib_filefunc_def->zclose_file = win32_close_file_func; 268 pzlib_filefunc_def->zerror_file = win32_error_file_func;
269 pzlib_filefunc_def->zerror_file = win32_error_file_func; 269 pzlib_filefunc_def->opaque=NULL;
270 pzlib_filefunc_def->opaque=NULL; 270}
271}
diff --git a/contrib/minizip/iowin32.h b/contrib/minizip/iowin32.h
index 713fc02..94aa1aa 100644
--- a/contrib/minizip/iowin32.h
+++ b/contrib/minizip/iowin32.h
@@ -1,19 +1,21 @@
1/* iowin32.h -- IO base function header for compress/uncompress .zip 1/* iowin32.h -- IO base function header for compress/uncompress .zip
2 files using zlib + zip or unzip API 2 files using zlib + zip or unzip API
3 This IO API version uses the Win32 API (for Microsoft Windows) 3 This IO API version uses the Win32 API (for Microsoft Windows)
4 4
5 Version 0.22, May 19th, 2003 5 Version 0.22, May 19th, 2003
6 6
7 Copyright (C) 1998-2003 Gilles Vollant 7 Copyright (C) 1998-2003 Gilles Vollant
8*/ 8*/
9 9
10#ifdef __cplusplus 10#include <windows.h>
11extern "C" { 11
12#endif 12
13 13#ifdef __cplusplus
14void fill_win32_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def)); 14extern "C" {
15 15#endif
16 16
17#ifdef __cplusplus 17void fill_win32_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
18} 18
19#endif 19#ifdef __cplusplus
20}
21#endif
diff --git a/contrib/minizip/miniunz.c b/contrib/minizip/miniunz.c
index ea23e40..57601e1 100644
--- a/contrib/minizip/miniunz.c
+++ b/contrib/minizip/miniunz.c
@@ -1,556 +1,556 @@
1#include <stdio.h> 1#include <stdio.h>
2#include <stdlib.h> 2#include <stdlib.h>
3#include <string.h> 3#include <string.h>
4#include <time.h> 4#include <time.h>
5#include <errno.h> 5#include <errno.h>
6#include <fcntl.h> 6#include <fcntl.h>
7 7
8#ifdef unix 8#ifdef unix
9# include <unistd.h> 9# include <unistd.h>
10# include <utime.h> 10# include <utime.h>
11#else 11#else
12# include <direct.h> 12# include <direct.h>
13# include <io.h> 13# include <io.h>
14#endif 14#endif
15 15
16#include "unzip.h" 16#include "unzip.h"
17 17
18#define CASESENSITIVITY (0) 18#define CASESENSITIVITY (0)
19#define WRITEBUFFERSIZE (8192) 19#define WRITEBUFFERSIZE (8192)
20#define MAXFILENAME (256) 20#define MAXFILENAME (256)
21 21
22#ifdef WIN32 22#ifdef WIN32
23#define USEWIN32IOAPI 23#define USEWIN32IOAPI
24#include "iowin32.h" 24#include "iowin32.h"
25#endif 25#endif
26/* 26/*
27 mini unzip, demo of unzip package 27 mini unzip, demo of unzip package
28 28
29 usage : 29 usage :
30 Usage : miniunz [-exvlo] file.zip [file_to_extract] 30 Usage : miniunz [-exvlo] file.zip [file_to_extract]
31 31
32 list the file in the zipfile, and print the content of FILE_ID.ZIP or README.TXT 32 list the file in the zipfile, and print the content of FILE_ID.ZIP or README.TXT
33 if it exists 33 if it exists
34*/ 34*/
35 35
36 36
37/* change_file_date : change the date/time of a file 37/* change_file_date : change the date/time of a file
38 filename : the filename of the file where date/time must be modified 38 filename : the filename of the file where date/time must be modified
39 dosdate : the new date at the MSDos format (4 bytes) 39 dosdate : the new date at the MSDos format (4 bytes)
40 tmu_date : the SAME new date at the tm_unz format */ 40 tmu_date : the SAME new date at the tm_unz format */
41void change_file_date(filename,dosdate,tmu_date) 41void change_file_date(filename,dosdate,tmu_date)
42 const char *filename; 42 const char *filename;
43 uLong dosdate; 43 uLong dosdate;
44 tm_unz tmu_date; 44 tm_unz tmu_date;
45{ 45{
46#ifdef WIN32 46#ifdef WIN32
47 HANDLE hFile; 47 HANDLE hFile;
48 FILETIME ftm,ftLocal,ftCreate,ftLastAcc,ftLastWrite; 48 FILETIME ftm,ftLocal,ftCreate,ftLastAcc,ftLastWrite;
49 49
50 hFile = CreateFile(filename,GENERIC_READ | GENERIC_WRITE, 50 hFile = CreateFile(filename,GENERIC_READ | GENERIC_WRITE,
51 0,NULL,OPEN_EXISTING,0,NULL); 51 0,NULL,OPEN_EXISTING,0,NULL);
52 GetFileTime(hFile,&ftCreate,&ftLastAcc,&ftLastWrite); 52 GetFileTime(hFile,&ftCreate,&ftLastAcc,&ftLastWrite);
53 DosDateTimeToFileTime((WORD)(dosdate>>16),(WORD)dosdate,&ftLocal); 53 DosDateTimeToFileTime((WORD)(dosdate>>16),(WORD)dosdate,&ftLocal);
54 LocalFileTimeToFileTime(&ftLocal,&ftm); 54 LocalFileTimeToFileTime(&ftLocal,&ftm);
55 SetFileTime(hFile,&ftm,&ftLastAcc,&ftm); 55 SetFileTime(hFile,&ftm,&ftLastAcc,&ftm);
56 CloseHandle(hFile); 56 CloseHandle(hFile);
57#else 57#else
58#ifdef unix 58#ifdef unix
59 struct utimbuf ut; 59 struct utimbuf ut;
60 struct tm newdate; 60 struct tm newdate;
61 newdate.tm_sec = tmu_date.tm_sec; 61 newdate.tm_sec = tmu_date.tm_sec;
62 newdate.tm_min=tmu_date.tm_min; 62 newdate.tm_min=tmu_date.tm_min;
63 newdate.tm_hour=tmu_date.tm_hour; 63 newdate.tm_hour=tmu_date.tm_hour;
64 newdate.tm_mday=tmu_date.tm_mday; 64 newdate.tm_mday=tmu_date.tm_mday;
65 newdate.tm_mon=tmu_date.tm_mon; 65 newdate.tm_mon=tmu_date.tm_mon;
66 if (tmu_date.tm_year > 1900) 66 if (tmu_date.tm_year > 1900)
67 newdate.tm_year=tmu_date.tm_year - 1900; 67 newdate.tm_year=tmu_date.tm_year - 1900;
68 else 68 else
69 newdate.tm_year=tmu_date.tm_year ; 69 newdate.tm_year=tmu_date.tm_year ;
70 newdate.tm_isdst=-1; 70 newdate.tm_isdst=-1;
71 71
72 ut.actime=ut.modtime=mktime(&newdate); 72 ut.actime=ut.modtime=mktime(&newdate);
73 utime(filename,&ut); 73 utime(filename,&ut);
74#endif 74#endif
75#endif 75#endif
76} 76}
77 77
78 78
79/* mymkdir and change_file_date are not 100 % portable 79/* mymkdir and change_file_date are not 100 % portable
80 As I don't know well Unix, I wait feedback for the unix portion */ 80 As I don't know well Unix, I wait feedback for the unix portion */
81 81
82int mymkdir(dirname) 82int mymkdir(dirname)
83 const char* dirname; 83 const char* dirname;
84{ 84{
85 int ret=0; 85 int ret=0;
86#ifdef WIN32 86#ifdef WIN32
87 ret = mkdir(dirname); 87 ret = mkdir(dirname);
88#else 88#else
89#ifdef unix 89#ifdef unix
90 ret = mkdir (dirname,0775); 90 ret = mkdir (dirname,0775);
91#endif 91#endif
92#endif 92#endif
93 return ret; 93 return ret;
94} 94}
95 95
96int makedir (newdir) 96int makedir (newdir)
97 char *newdir; 97 char *newdir;
98{ 98{
99 char *buffer ; 99 char *buffer ;
100 char *p; 100 char *p;
101 int len = (int)strlen(newdir); 101 int len = (int)strlen(newdir);
102 102
103 if (len <= 0) 103 if (len <= 0)
104 return 0; 104 return 0;
105 105
106 buffer = (char*)malloc(len+1); 106 buffer = (char*)malloc(len+1);
107 strcpy(buffer,newdir); 107 strcpy(buffer,newdir);
108 108
109 if (buffer[len-1] == '/') { 109 if (buffer[len-1] == '/') {
110 buffer[len-1] = '\0'; 110 buffer[len-1] = '\0';
111 } 111 }
112 if (mymkdir(buffer) == 0) 112 if (mymkdir(buffer) == 0)
113 { 113 {
114 free(buffer); 114 free(buffer);
115 return 1; 115 return 1;
116 } 116 }
117 117
118 p = buffer+1; 118 p = buffer+1;
119 while (1) 119 while (1)
120 { 120 {
121 char hold; 121 char hold;
122 122
123 while(*p && *p != '\\' && *p != '/') 123 while(*p && *p != '\\' && *p != '/')
124 p++; 124 p++;
125 hold = *p; 125 hold = *p;
126 *p = 0; 126 *p = 0;
127 if ((mymkdir(buffer) == -1) && (errno == ENOENT)) 127 if ((mymkdir(buffer) == -1) && (errno == ENOENT))
128 { 128 {
129 printf("couldn't create directory %s\n",buffer); 129 printf("couldn't create directory %s\n",buffer);
130 free(buffer); 130 free(buffer);
131 return 0; 131 return 0;
132 } 132 }
133 if (hold == 0) 133 if (hold == 0)
134 break; 134 break;
135 *p++ = hold; 135 *p++ = hold;
136 } 136 }
137 free(buffer); 137 free(buffer);
138 return 1; 138 return 1;
139} 139}
140 140
141void do_banner() 141void do_banner()
142{ 142{
143 printf("MiniUnz 0.22, demo of zLib + Unz package written by Gilles Vollant\n"); 143 printf("MiniUnz 0.22, demo of zLib + Unz package written by Gilles Vollant\n");
144 printf("more info at http://www.winimage.com/zLibDll/unzip.html\n\n"); 144 printf("more info at http://www.winimage.com/zLibDll/unzip.html\n\n");
145} 145}
146 146
147void do_help() 147void do_help()
148{ 148{
149 printf("Usage : miniunz [-e] [-x] [-v] [-l] [-o] [-p password] file.zip [file_to_extr.]\n\n" \ 149 printf("Usage : miniunz [-e] [-x] [-v] [-l] [-o] [-p password] file.zip [file_to_extr.]\n\n" \
150 " -e Extract without pathname (junk paths)\n" \ 150 " -e Extract without pathname (junk paths)\n" \
151 " -x Extract with pathname\n" \ 151 " -x Extract with pathname\n" \
152 " -v list files\n" \ 152 " -v list files\n" \
153 " -l list files\n" \ 153 " -l list files\n" \
154 " -o overwrite files without prompting\n" \ 154 " -o overwrite files without prompting\n" \
155 " -p extract crypted file using password\n\n"); 155 " -p extract crypted file using password\n\n");
156} 156}
157 157
158 158
159int do_list(uf) 159int do_list(uf)
160 unzFile uf; 160 unzFile uf;
161{ 161{
162 uLong i; 162 uLong i;
163 unz_global_info gi; 163 unz_global_info gi;
164 int err; 164 int err;
165 165
166 err = unzGetGlobalInfo (uf,&gi); 166 err = unzGetGlobalInfo (uf,&gi);
167 if (err!=UNZ_OK) 167 if (err!=UNZ_OK)
168 printf("error %d with zipfile in unzGetGlobalInfo \n",err); 168 printf("error %d with zipfile in unzGetGlobalInfo \n",err);
169 printf(" Length Method Size Ratio Date Time CRC-32 Name\n"); 169 printf(" Length Method Size Ratio Date Time CRC-32 Name\n");
170 printf(" ------ ------ ---- ----- ---- ---- ------ ----\n"); 170 printf(" ------ ------ ---- ----- ---- ---- ------ ----\n");
171 for (i=0;i<gi.number_entry;i++) 171 for (i=0;i<gi.number_entry;i++)
172 { 172 {
173 char filename_inzip[256]; 173 char filename_inzip[256];
174 unz_file_info file_info; 174 unz_file_info file_info;
175 uLong ratio=0; 175 uLong ratio=0;
176 const char *string_method; 176 const char *string_method;
177 char charCrypt=' '; 177 char charCrypt=' ';
178 err = unzGetCurrentFileInfo(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0); 178 err = unzGetCurrentFileInfo(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0);
179 if (err!=UNZ_OK) 179 if (err!=UNZ_OK)
180 { 180 {
181 printf("error %d with zipfile in unzGetCurrentFileInfo\n",err); 181 printf("error %d with zipfile in unzGetCurrentFileInfo\n",err);
182 break; 182 break;
183 } 183 }
184 if (file_info.uncompressed_size>0) 184 if (file_info.uncompressed_size>0)
185 ratio = (file_info.compressed_size*100)/file_info.uncompressed_size; 185 ratio = (file_info.compressed_size*100)/file_info.uncompressed_size;
186 186
187 /* display a '*' if the file is crypted */ 187 /* display a '*' if the file is crypted */
188 if ((file_info.flag & 1) != 0) 188 if ((file_info.flag & 1) != 0)
189 charCrypt='*'; 189 charCrypt='*';
190 190
191 if (file_info.compression_method==0) 191 if (file_info.compression_method==0)
192 string_method="Stored"; 192 string_method="Stored";
193 else 193 else
194 if (file_info.compression_method==Z_DEFLATED) 194 if (file_info.compression_method==Z_DEFLATED)
195 { 195 {
196 uInt iLevel=(uInt)((file_info.flag & 0x6)/2); 196 uInt iLevel=(uInt)((file_info.flag & 0x6)/2);
197 if (iLevel==0) 197 if (iLevel==0)
198 string_method="Defl:N"; 198 string_method="Defl:N";
199 else if (iLevel==1) 199 else if (iLevel==1)
200 string_method="Defl:X"; 200 string_method="Defl:X";
201 else if ((iLevel==2) || (iLevel==3)) 201 else if ((iLevel==2) || (iLevel==3))
202 string_method="Defl:F"; /* 2:fast , 3 : extra fast*/ 202 string_method="Defl:F"; /* 2:fast , 3 : extra fast*/
203 } 203 }
204 else 204 else
205 string_method="Unkn. "; 205 string_method="Unkn. ";
206 206
207 printf("%7lu %6s%c%7lu %3lu%% %2.2lu-%2.2lu-%2.2lu %2.2lu:%2.2lu %8.8lx %s\n", 207 printf("%7lu %6s%c%7lu %3lu%% %2.2lu-%2.2lu-%2.2lu %2.2lu:%2.2lu %8.8lx %s\n",
208 file_info.uncompressed_size,string_method, 208 file_info.uncompressed_size,string_method,
209 charCrypt, 209 charCrypt,
210 file_info.compressed_size, 210 file_info.compressed_size,
211 ratio, 211 ratio,
212 (uLong)file_info.tmu_date.tm_mon + 1, 212 (uLong)file_info.tmu_date.tm_mon + 1,
213 (uLong)file_info.tmu_date.tm_mday, 213 (uLong)file_info.tmu_date.tm_mday,
214 (uLong)file_info.tmu_date.tm_year % 100, 214 (uLong)file_info.tmu_date.tm_year % 100,
215 (uLong)file_info.tmu_date.tm_hour,(uLong)file_info.tmu_date.tm_min, 215 (uLong)file_info.tmu_date.tm_hour,(uLong)file_info.tmu_date.tm_min,
216 (uLong)file_info.crc,filename_inzip); 216 (uLong)file_info.crc,filename_inzip);
217 if ((i+1)<gi.number_entry) 217 if ((i+1)<gi.number_entry)
218 { 218 {
219 err = unzGoToNextFile(uf); 219 err = unzGoToNextFile(uf);
220 if (err!=UNZ_OK) 220 if (err!=UNZ_OK)
221 { 221 {
222 printf("error %d with zipfile in unzGoToNextFile\n",err); 222 printf("error %d with zipfile in unzGoToNextFile\n",err);
223 break; 223 break;
224 } 224 }
225 } 225 }
226 } 226 }
227 227
228 return 0; 228 return 0;
229} 229}
230 230
231 231
232int do_extract_currentfile(uf,popt_extract_without_path,popt_overwrite,password) 232int do_extract_currentfile(uf,popt_extract_without_path,popt_overwrite,password)
233 unzFile uf; 233 unzFile uf;
234 const int* popt_extract_without_path; 234 const int* popt_extract_without_path;
235 int* popt_overwrite; 235 int* popt_overwrite;
236 const char* password; 236 const char* password;
237{ 237{
238 char filename_inzip[256]; 238 char filename_inzip[256];
239 char* filename_withoutpath; 239 char* filename_withoutpath;
240 char* p; 240 char* p;
241 int err=UNZ_OK; 241 int err=UNZ_OK;
242 FILE *fout=NULL; 242 FILE *fout=NULL;
243 void* buf; 243 void* buf;
244 uInt size_buf; 244 uInt size_buf;
245 245
246 unz_file_info file_info; 246 unz_file_info file_info;
247 uLong ratio=0; 247 uLong ratio=0;
248 err = unzGetCurrentFileInfo(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0); 248 err = unzGetCurrentFileInfo(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0);
249 249
250 if (err!=UNZ_OK) 250 if (err!=UNZ_OK)
251 { 251 {
252 printf("error %d with zipfile in unzGetCurrentFileInfo\n",err); 252 printf("error %d with zipfile in unzGetCurrentFileInfo\n",err);
253 return err; 253 return err;
254 } 254 }
255 255
256 size_buf = WRITEBUFFERSIZE; 256 size_buf = WRITEBUFFERSIZE;
257 buf = (void*)malloc(size_buf); 257 buf = (void*)malloc(size_buf);
258 if (buf==NULL) 258 if (buf==NULL)
259 { 259 {
260 printf("Error allocating memory\n"); 260 printf("Error allocating memory\n");
261 return UNZ_INTERNALERROR; 261 return UNZ_INTERNALERROR;
262 } 262 }
263 263
264 p = filename_withoutpath = filename_inzip; 264 p = filename_withoutpath = filename_inzip;
265 while ((*p) != '\0') 265 while ((*p) != '\0')
266 { 266 {
267 if (((*p)=='/') || ((*p)=='\\')) 267 if (((*p)=='/') || ((*p)=='\\'))
268 filename_withoutpath = p+1; 268 filename_withoutpath = p+1;
269 p++; 269 p++;
270 } 270 }
271 271
272 if ((*filename_withoutpath)=='\0') 272 if ((*filename_withoutpath)=='\0')
273 { 273 {
274 if ((*popt_extract_without_path)==0) 274 if ((*popt_extract_without_path)==0)
275 { 275 {
276 printf("creating directory: %s\n",filename_inzip); 276 printf("creating directory: %s\n",filename_inzip);
277 mymkdir(filename_inzip); 277 mymkdir(filename_inzip);
278 } 278 }
279 } 279 }
280 else 280 else
281 { 281 {
282 const char* write_filename; 282 const char* write_filename;
283 int skip=0; 283 int skip=0;
284 284
285 if ((*popt_extract_without_path)==0) 285 if ((*popt_extract_without_path)==0)
286 write_filename = filename_inzip; 286 write_filename = filename_inzip;
287 else 287 else
288 write_filename = filename_withoutpath; 288 write_filename = filename_withoutpath;
289 289
290 err = unzOpenCurrentFilePassword(uf,password); 290 err = unzOpenCurrentFilePassword(uf,password);
291 if (err!=UNZ_OK) 291 if (err!=UNZ_OK)
292 { 292 {
293 printf("error %d with zipfile in unzOpenCurrentFilePassword\n",err); 293 printf("error %d with zipfile in unzOpenCurrentFilePassword\n",err);
294 } 294 }
295 295
296 if (((*popt_overwrite)==0) && (err==UNZ_OK)) 296 if (((*popt_overwrite)==0) && (err==UNZ_OK))
297 { 297 {
298 char rep=0; 298 char rep=0;
299 FILE* ftestexist; 299 FILE* ftestexist;
300 ftestexist = fopen(write_filename,"rb"); 300 ftestexist = fopen(write_filename,"rb");
301 if (ftestexist!=NULL) 301 if (ftestexist!=NULL)
302 { 302 {
303 fclose(ftestexist); 303 fclose(ftestexist);
304 do 304 do
305 { 305 {
306 char answer[128]; 306 char answer[128];
307 printf("The file %s exist. Overwrite ? [y]es, [n]o, [A]ll: ",write_filename); 307 printf("The file %s exist. Overwrite ? [y]es, [n]o, [A]ll: ",write_filename);
308 scanf("%1s",answer); 308 scanf("%1s",answer);
309 rep = answer[0] ; 309 rep = answer[0] ;
310 if ((rep>='a') && (rep<='z')) 310 if ((rep>='a') && (rep<='z'))
311 rep -= 0x20; 311 rep -= 0x20;
312 } 312 }
313 while ((rep!='Y') && (rep!='N') && (rep!='A')); 313 while ((rep!='Y') && (rep!='N') && (rep!='A'));
314 } 314 }
315 315
316 if (rep == 'N') 316 if (rep == 'N')
317 skip = 1; 317 skip = 1;
318 318
319 if (rep == 'A') 319 if (rep == 'A')
320 *popt_overwrite=1; 320 *popt_overwrite=1;
321 } 321 }
322 322
323 if ((skip==0) && (err==UNZ_OK)) 323 if ((skip==0) && (err==UNZ_OK))
324 { 324 {
325 fout=fopen(write_filename,"wb"); 325 fout=fopen(write_filename,"wb");
326 326
327 /* some zipfile don't contain directory alone before file */ 327 /* some zipfile don't contain directory alone before file */
328 if ((fout==NULL) && ((*popt_extract_without_path)==0) && 328 if ((fout==NULL) && ((*popt_extract_without_path)==0) &&
329 (filename_withoutpath!=(char*)filename_inzip)) 329 (filename_withoutpath!=(char*)filename_inzip))
330 { 330 {
331 char c=*(filename_withoutpath-1); 331 char c=*(filename_withoutpath-1);
332 *(filename_withoutpath-1)='\0'; 332 *(filename_withoutpath-1)='\0';
333 makedir(write_filename); 333 makedir(write_filename);
334 *(filename_withoutpath-1)=c; 334 *(filename_withoutpath-1)=c;
335 fout=fopen(write_filename,"wb"); 335 fout=fopen(write_filename,"wb");
336 } 336 }
337 337
338 if (fout==NULL) 338 if (fout==NULL)
339 { 339 {
340 printf("error opening %s\n",write_filename); 340 printf("error opening %s\n",write_filename);
341 } 341 }
342 } 342 }
343 343
344 if (fout!=NULL) 344 if (fout!=NULL)
345 { 345 {
346 printf(" extracting: %s\n",write_filename); 346 printf(" extracting: %s\n",write_filename);
347 347
348 do 348 do
349 { 349 {
350 err = unzReadCurrentFile(uf,buf,size_buf); 350 err = unzReadCurrentFile(uf,buf,size_buf);
351 if (err<0) 351 if (err<0)
352 { 352 {
353 printf("error %d with zipfile in unzReadCurrentFile\n",err); 353 printf("error %d with zipfile in unzReadCurrentFile\n",err);
354 break; 354 break;
355 } 355 }
356 if (err>0) 356 if (err>0)
357 if (fwrite(buf,err,1,fout)!=1) 357 if (fwrite(buf,err,1,fout)!=1)
358 { 358 {
359 printf("error in writing extracted file\n"); 359 printf("error in writing extracted file\n");
360 err=UNZ_ERRNO; 360 err=UNZ_ERRNO;
361 break; 361 break;
362 } 362 }
363 } 363 }
364 while (err>0); 364 while (err>0);
365 if (fout) 365 if (fout)
366 fclose(fout); 366 fclose(fout);
367 367
368 if (err==0) 368 if (err==0)
369 change_file_date(write_filename,file_info.dosDate, 369 change_file_date(write_filename,file_info.dosDate,
370 file_info.tmu_date); 370 file_info.tmu_date);
371 } 371 }
372 372
373 if (err==UNZ_OK) 373 if (err==UNZ_OK)
374 { 374 {
375 err = unzCloseCurrentFile (uf); 375 err = unzCloseCurrentFile (uf);
376 if (err!=UNZ_OK) 376 if (err!=UNZ_OK)
377 { 377 {
378 printf("error %d with zipfile in unzCloseCurrentFile\n",err); 378 printf("error %d with zipfile in unzCloseCurrentFile\n",err);
379 } 379 }
380 } 380 }
381 else 381 else
382 unzCloseCurrentFile(uf); /* don't lose the error */ 382 unzCloseCurrentFile(uf); /* don't lose the error */
383 } 383 }
384 384
385 free(buf); 385 free(buf);
386 return err; 386 return err;
387} 387}
388 388
389 389
390int do_extract(uf,opt_extract_without_path,opt_overwrite,password) 390int do_extract(uf,opt_extract_without_path,opt_overwrite,password)
391 unzFile uf; 391 unzFile uf;
392 int opt_extract_without_path; 392 int opt_extract_without_path;
393 int opt_overwrite; 393 int opt_overwrite;
394 const char* password; 394 const char* password;
395{ 395{
396 uLong i; 396 uLong i;
397 unz_global_info gi; 397 unz_global_info gi;
398 int err; 398 int err;
399 FILE* fout=NULL; 399 FILE* fout=NULL;
400 400
401 err = unzGetGlobalInfo (uf,&gi); 401 err = unzGetGlobalInfo (uf,&gi);
402 if (err!=UNZ_OK) 402 if (err!=UNZ_OK)
403 printf("error %d with zipfile in unzGetGlobalInfo \n",err); 403 printf("error %d with zipfile in unzGetGlobalInfo \n",err);
404 404
405 for (i=0;i<gi.number_entry;i++) 405 for (i=0;i<gi.number_entry;i++)
406 { 406 {
407 if (do_extract_currentfile(uf,&opt_extract_without_path, 407 if (do_extract_currentfile(uf,&opt_extract_without_path,
408 &opt_overwrite, 408 &opt_overwrite,
409 password) != UNZ_OK) 409 password) != UNZ_OK)
410 break; 410 break;
411 411
412 if ((i+1)<gi.number_entry) 412 if ((i+1)<gi.number_entry)
413 { 413 {
414 err = unzGoToNextFile(uf); 414 err = unzGoToNextFile(uf);
415 if (err!=UNZ_OK) 415 if (err!=UNZ_OK)
416 { 416 {
417 printf("error %d with zipfile in unzGoToNextFile\n",err); 417 printf("error %d with zipfile in unzGoToNextFile\n",err);
418 break; 418 break;
419 } 419 }
420 } 420 }
421 } 421 }
422 422
423 return 0; 423 return 0;
424} 424}
425 425
426int do_extract_onefile(uf,filename,opt_extract_without_path,opt_overwrite,password) 426int do_extract_onefile(uf,filename,opt_extract_without_path,opt_overwrite,password)
427 unzFile uf; 427 unzFile uf;
428 const char* filename; 428 const char* filename;
429 int opt_extract_without_path; 429 int opt_extract_without_path;
430 int opt_overwrite; 430 int opt_overwrite;
431 const char* password; 431 const char* password;
432{ 432{
433 int err = UNZ_OK; 433 int err = UNZ_OK;
434 if (unzLocateFile(uf,filename,CASESENSITIVITY)!=UNZ_OK) 434 if (unzLocateFile(uf,filename,CASESENSITIVITY)!=UNZ_OK)
435 { 435 {
436 printf("file %s not found in the zipfile\n",filename); 436 printf("file %s not found in the zipfile\n",filename);
437 return 2; 437 return 2;
438 } 438 }
439 439
440 if (do_extract_currentfile(uf,&opt_extract_without_path, 440 if (do_extract_currentfile(uf,&opt_extract_without_path,
441 &opt_overwrite, 441 &opt_overwrite,
442 password) == UNZ_OK) 442 password) == UNZ_OK)
443 return 0; 443 return 0;
444 else 444 else
445 return 1; 445 return 1;
446} 446}
447 447
448 448
449int main(argc,argv) 449int main(argc,argv)
450 int argc; 450 int argc;
451 char *argv[]; 451 char *argv[];
452{ 452{
453 const char *zipfilename=NULL; 453 const char *zipfilename=NULL;
454 const char *filename_to_extract=NULL; 454 const char *filename_to_extract=NULL;
455 const char *password=NULL; 455 const char *password=NULL;
456 char filename_try[MAXFILENAME+16] = ""; 456 char filename_try[MAXFILENAME+16] = "";
457 int i; 457 int i;
458 int opt_do_list=0; 458 int opt_do_list=0;
459 int opt_do_extract=1; 459 int opt_do_extract=1;
460 int opt_do_extract_withoutpath=0; 460 int opt_do_extract_withoutpath=0;
461 int opt_overwrite=0; 461 int opt_overwrite=0;
462 unzFile uf=NULL; 462 unzFile uf=NULL;
463 463
464 do_banner(); 464 do_banner();
465 if (argc==1) 465 if (argc==1)
466 { 466 {
467 do_help(); 467 do_help();
468 return 0; 468 return 0;
469 } 469 }
470 else 470 else
471 { 471 {
472 for (i=1;i<argc;i++) 472 for (i=1;i<argc;i++)
473 { 473 {
474 if ((*argv[i])=='-') 474 if ((*argv[i])=='-')
475 { 475 {
476 const char *p=argv[i]+1; 476 const char *p=argv[i]+1;
477 477
478 while ((*p)!='\0') 478 while ((*p)!='\0')
479 { 479 {
480 char c=*(p++);; 480 char c=*(p++);;
481 if ((c=='l') || (c=='L')) 481 if ((c=='l') || (c=='L'))
482 opt_do_list = 1; 482 opt_do_list = 1;
483 if ((c=='v') || (c=='V')) 483 if ((c=='v') || (c=='V'))
484 opt_do_list = 1; 484 opt_do_list = 1;
485 if ((c=='x') || (c=='X')) 485 if ((c=='x') || (c=='X'))
486 opt_do_extract = 1; 486 opt_do_extract = 1;
487 if ((c=='e') || (c=='E')) 487 if ((c=='e') || (c=='E'))
488 opt_do_extract = opt_do_extract_withoutpath = 1; 488 opt_do_extract = opt_do_extract_withoutpath = 1;
489 if ((c=='o') || (c=='O')) 489 if ((c=='o') || (c=='O'))
490 opt_overwrite=1; 490 opt_overwrite=1;
491 if (((c=='p') || (c=='P')) && (i+1<argc)) 491 if (((c=='p') || (c=='P')) && (i+1<argc))
492 { 492 {
493 password=argv[i+1]; 493 password=argv[i+1];
494 i++; 494 i++;
495 } 495 }
496 } 496 }
497 } 497 }
498 else 498 else
499 { 499 {
500 if (zipfilename == NULL) 500 if (zipfilename == NULL)
501 zipfilename = argv[i]; 501 zipfilename = argv[i];
502 else if (filename_to_extract==NULL) 502 else if (filename_to_extract==NULL)
503 filename_to_extract = argv[i] ; 503 filename_to_extract = argv[i] ;
504 } 504 }
505 } 505 }
506 } 506 }
507 507
508 if (zipfilename!=NULL) 508 if (zipfilename!=NULL)
509 { 509 {
510 510
511 #ifdef USEWIN32IOAPI 511# ifdef USEWIN32IOAPI
512 zlib_filefunc_def ffunc; 512 zlib_filefunc_def ffunc;
513 #endif 513# endif
514 514
515 strncpy(filename_try, zipfilename,MAXFILENAME-1); 515 strncpy(filename_try, zipfilename,MAXFILENAME-1);
516 /* strncpy doesnt append the trailing NULL, of the string is too long. */ 516 /* strncpy doesnt append the trailing NULL, of the string is too long. */
517 filename_try[ MAXFILENAME ] = '\0'; 517 filename_try[ MAXFILENAME ] = '\0';
518 518
519 #ifdef USEWIN32IOAPI 519# ifdef USEWIN32IOAPI
520 fill_win32_filefunc(&ffunc); 520 fill_win32_filefunc(&ffunc);
521 uf = unzOpen2(zipfilename,&ffunc); 521 uf = unzOpen2(zipfilename,&ffunc);
522 #else 522# else
523 uf = unzOpen(zipfilename); 523 uf = unzOpen(zipfilename);
524 #endif 524# endif
525 if (uf==NULL) 525 if (uf==NULL)
526 { 526 {
527 strcat(filename_try,".zip"); 527 strcat(filename_try,".zip");
528 #ifdef USEWIN32IOAPI 528# ifdef USEWIN32IOAPI
529 uf = unzOpen2(filename_try,&ffunc); 529 uf = unzOpen2(filename_try,&ffunc);
530 #else 530# else
531 uf = unzOpen(filename_try); 531 uf = unzOpen(filename_try);
532 #endif 532# endif
533 } 533 }
534 } 534 }
535 535
536 if (uf==NULL) 536 if (uf==NULL)
537 { 537 {
538 printf("Cannot open %s or %s.zip\n",zipfilename,zipfilename); 538 printf("Cannot open %s or %s.zip\n",zipfilename,zipfilename);
539 return 1; 539 return 1;
540 } 540 }
541 printf("%s opened\n",filename_try); 541 printf("%s opened\n",filename_try);
542 542
543 if (opt_do_list==1) 543 if (opt_do_list==1)
544 return do_list(uf); 544 return do_list(uf);
545 else if (opt_do_extract==1) 545 else if (opt_do_extract==1)
546 { 546 {
547 if (filename_to_extract == NULL) 547 if (filename_to_extract == NULL)
548 return do_extract(uf,opt_do_extract_withoutpath,opt_overwrite,password); 548 return do_extract(uf,opt_do_extract_withoutpath,opt_overwrite,password);
549 else 549 else
550 return do_extract_onefile(uf,filename_to_extract, 550 return do_extract_onefile(uf,filename_to_extract,
551 opt_do_extract_withoutpath,opt_overwrite,password); 551 opt_do_extract_withoutpath,opt_overwrite,password);
552 } 552 }
553 unzCloseCurrentFile(uf); 553 unzCloseCurrentFile(uf);
554 554
555 return 0; 555 return 0;
556} 556}
diff --git a/contrib/minizip/minizip.c b/contrib/minizip/minizip.c
index 79e541d..7e2ce36 100644
--- a/contrib/minizip/minizip.c
+++ b/contrib/minizip/minizip.c
@@ -1,397 +1,397 @@
1#include <stdio.h> 1#include <stdio.h>
2#include <stdlib.h> 2#include <stdlib.h>
3#include <string.h> 3#include <string.h>
4#include <time.h> 4#include <time.h>
5#include <errno.h> 5#include <errno.h>
6#include <fcntl.h> 6#include <fcntl.h>
7 7
8#ifdef unix 8#ifdef unix
9# include <unistd.h> 9# include <unistd.h>
10# include <utime.h> 10# include <utime.h>
11# include <sys/types.h> 11# include <sys/types.h>
12# include <sys/stat.h> 12# include <sys/stat.h>
13#else 13#else
14# include <direct.h> 14# include <direct.h>
15# include <io.h> 15# include <io.h>
16#endif 16#endif
17 17
18#include "zip.h" 18#include "zip.h"
19 19
20#ifdef WIN32 20#ifdef WIN32
21#define USEWIN32IOAPI 21#define USEWIN32IOAPI
22#include "iowin32.h" 22#include "iowin32.h"
23#endif 23#endif
24 24
25 25
26 26
27#define WRITEBUFFERSIZE (16384) 27#define WRITEBUFFERSIZE (16384)
28#define MAXFILENAME (256) 28#define MAXFILENAME (256)
29 29
30#ifdef WIN32 30#ifdef WIN32
31uLong filetime(f, tmzip, dt) 31uLong filetime(f, tmzip, dt)
32 char *f; /* name of file to get info on */ 32 char *f; /* name of file to get info on */
33 tm_zip *tmzip; /* return value: access, modific. and creation times */ 33 tm_zip *tmzip; /* return value: access, modific. and creation times */
34 uLong *dt; /* dostime */ 34 uLong *dt; /* dostime */
35{ 35{
36 int ret = 0; 36 int ret = 0;
37 { 37 {
38 FILETIME ftLocal; 38 FILETIME ftLocal;
39 HANDLE hFind; 39 HANDLE hFind;
40 WIN32_FIND_DATA ff32; 40 WIN32_FIND_DATA ff32;
41 41
42 hFind = FindFirstFile(f,&ff32); 42 hFind = FindFirstFile(f,&ff32);
43 if (hFind != INVALID_HANDLE_VALUE) 43 if (hFind != INVALID_HANDLE_VALUE)
44 { 44 {
45 FileTimeToLocalFileTime(&(ff32.ftLastWriteTime),&ftLocal); 45 FileTimeToLocalFileTime(&(ff32.ftLastWriteTime),&ftLocal);
46 FileTimeToDosDateTime(&ftLocal,((LPWORD)dt)+1,((LPWORD)dt)+0); 46 FileTimeToDosDateTime(&ftLocal,((LPWORD)dt)+1,((LPWORD)dt)+0);
47 FindClose(hFind); 47 FindClose(hFind);
48 ret = 1; 48 ret = 1;
49 } 49 }
50 } 50 }
51 return ret; 51 return ret;
52} 52}
53#else 53#else
54#ifdef unix 54#ifdef unix
55uLong filetime(f, tmzip, dt) 55uLong filetime(f, tmzip, dt)
56 char *f; /* name of file to get info on */ 56 char *f; /* name of file to get info on */
57 tm_zip *tmzip; /* return value: access, modific. and creation times */ 57 tm_zip *tmzip; /* return value: access, modific. and creation times */
58 uLong *dt; /* dostime */ 58 uLong *dt; /* dostime */
59{ 59{
60 int ret=0; 60 int ret=0;
61 struct stat s; /* results of stat() */ 61 struct stat s; /* results of stat() */
62 struct tm* filedate; 62 struct tm* filedate;
63 time_t tm_t=0; 63 time_t tm_t=0;
64 64
65 if (strcmp(f,"-")!=0) 65 if (strcmp(f,"-")!=0)
66 { 66 {
67 char name[MAXFILENAME+1]; 67 char name[MAXFILENAME+1];
68 int len = strlen(f); 68 int len = strlen(f);
69 69
70 strncpy(name, f,MAXFILENAME-1); 70 strncpy(name, f,MAXFILENAME-1);
71 /* strncpy doesnt append the trailing NULL, of the string is too long. */ 71 /* strncpy doesnt append the trailing NULL, of the string is too long. */
72 name[ MAXFILENAME ] = '\0'; 72 name[ MAXFILENAME ] = '\0';
73 73
74 if (name[len - 1] == '/') 74 if (name[len - 1] == '/')
75 name[len - 1] = '\0'; 75 name[len - 1] = '\0';
76 /* not all systems allow stat'ing a file with / appended */ 76 /* not all systems allow stat'ing a file with / appended */
77 if (stat(name,&s)==0) 77 if (stat(name,&s)==0)
78 { 78 {
79 tm_t = s.st_mtime; 79 tm_t = s.st_mtime;
80 ret = 1; 80 ret = 1;
81 } 81 }
82 } 82 }
83 filedate = localtime(&tm_t); 83 filedate = localtime(&tm_t);
84 84
85 tmzip->tm_sec = filedate->tm_sec; 85 tmzip->tm_sec = filedate->tm_sec;
86 tmzip->tm_min = filedate->tm_min; 86 tmzip->tm_min = filedate->tm_min;
87 tmzip->tm_hour = filedate->tm_hour; 87 tmzip->tm_hour = filedate->tm_hour;
88 tmzip->tm_mday = filedate->tm_mday; 88 tmzip->tm_mday = filedate->tm_mday;
89 tmzip->tm_mon = filedate->tm_mon ; 89 tmzip->tm_mon = filedate->tm_mon ;
90 tmzip->tm_year = filedate->tm_year; 90 tmzip->tm_year = filedate->tm_year;
91 91
92 return ret; 92 return ret;
93} 93}
94#else 94#else
95uLong filetime(f, tmzip, dt) 95uLong filetime(f, tmzip, dt)
96 char *f; /* name of file to get info on */ 96 char *f; /* name of file to get info on */
97 tm_zip *tmzip; /* return value: access, modific. and creation times */ 97 tm_zip *tmzip; /* return value: access, modific. and creation times */
98 uLong *dt; /* dostime */ 98 uLong *dt; /* dostime */
99{ 99{
100 return 0; 100 return 0;
101} 101}
102#endif 102#endif
103#endif 103#endif
104 104
105 105
106 106
107 107
108int check_exist_file(filename) 108int check_exist_file(filename)
109 const char* filename; 109 const char* filename;
110{ 110{
111 FILE* ftestexist; 111 FILE* ftestexist;
112 int ret = 1; 112 int ret = 1;
113 ftestexist = fopen(filename,"rb"); 113 ftestexist = fopen(filename,"rb");
114 if (ftestexist==NULL) 114 if (ftestexist==NULL)
115 ret = 0; 115 ret = 0;
116 else 116 else
117 fclose(ftestexist); 117 fclose(ftestexist);
118 return ret; 118 return ret;
119} 119}
120 120
121void do_banner() 121void do_banner()
122{ 122{
123 printf("MiniZip 0.22, demo of zLib + Zip package written by Gilles Vollant\n"); 123 printf("MiniZip 0.22, demo of zLib + Zip package written by Gilles Vollant\n");
124 printf("more info at http://www.winimage.com/zLibDll/unzip.html\n\n"); 124 printf("more info at http://www.winimage.com/zLibDll/unzip.html\n\n");
125} 125}
126 126
127void do_help() 127void do_help()
128{ 128{
129 printf("Usage : minizip [-o] [-a] [-0 to -9] [-p password] file.zip [files_to_add]\n\n" \ 129 printf("Usage : minizip [-o] [-a] [-0 to -9] [-p password] file.zip [files_to_add]\n\n" \
130 " -o Overwrite existing file.zip\n" \ 130 " -o Overwrite existing file.zip\n" \
131 " -a Append to existing file.zip\n" \ 131 " -a Append to existing file.zip\n" \
132 " -0 Store only\n" \ 132 " -0 Store only\n" \
133 " -1 Compress faster\n" \ 133 " -1 Compress faster\n" \
134 " -9 Compress better\n\n"); 134 " -9 Compress better\n\n");
135} 135}
136 136
137/* calculate the CRC32 of a file, 137/* calculate the CRC32 of a file,
138 because to encrypt a file, we need known the CRC32 of the file before */ 138 because to encrypt a file, we need known the CRC32 of the file before */
139int getFileCrc(const char* filenameinzip,void*buf,unsigned long size_buf,unsigned long* result_crc) 139int getFileCrc(const char* filenameinzip,void*buf,unsigned long size_buf,unsigned long* result_crc)
140{ 140{
141 unsigned long calculate_crc=0; 141 unsigned long calculate_crc=0;
142 int err=ZIP_OK; 142 int err=ZIP_OK;
143 FILE * fin = fopen(filenameinzip,"rb"); 143 FILE * fin = fopen(filenameinzip,"rb");
144 unsigned long size_read = 0; 144 unsigned long size_read = 0;
145 unsigned long total_read = 0; 145 unsigned long total_read = 0;
146 if (fin==NULL) 146 if (fin==NULL)
147 { 147 {
148 err = ZIP_ERRNO; 148 err = ZIP_ERRNO;
149 } 149 }
150 150
151 if (err == ZIP_OK) 151 if (err == ZIP_OK)
152 do 152 do
153 { 153 {
154 err = ZIP_OK; 154 err = ZIP_OK;
155 size_read = (int)fread(buf,1,size_buf,fin); 155 size_read = (int)fread(buf,1,size_buf,fin);
156 if (size_read < size_buf) 156 if (size_read < size_buf)
157 if (feof(fin)==0) 157 if (feof(fin)==0)
158 { 158 {
159 printf("error in reading %s\n",filenameinzip); 159 printf("error in reading %s\n",filenameinzip);
160 err = ZIP_ERRNO; 160 err = ZIP_ERRNO;
161 } 161 }
162 162
163 if (size_read>0) 163 if (size_read>0)
164 calculate_crc = crc32(calculate_crc,buf,size_read); 164 calculate_crc = crc32(calculate_crc,buf,size_read);
165 total_read += size_read; 165 total_read += size_read;
166 166
167 } while ((err == ZIP_OK) && (size_read>0)); 167 } while ((err == ZIP_OK) && (size_read>0));
168 168
169 if (fin) 169 if (fin)
170 fclose(fin); 170 fclose(fin);
171 171
172 *result_crc=calculate_crc; 172 *result_crc=calculate_crc;
173 printf("file %s crc %x\n",filenameinzip,calculate_crc); 173 printf("file %s crc %x\n",filenameinzip,calculate_crc);
174 return err; 174 return err;
175} 175}
176 176
177int main(argc,argv) 177int main(argc,argv)
178 int argc; 178 int argc;
179 char *argv[]; 179 char *argv[];
180{ 180{
181 int i; 181 int i;
182 int opt_overwrite=0; 182 int opt_overwrite=0;
183 int opt_compress_level=Z_DEFAULT_COMPRESSION; 183 int opt_compress_level=Z_DEFAULT_COMPRESSION;
184 int zipfilenamearg = 0; 184 int zipfilenamearg = 0;
185 char filename_try[MAXFILENAME+16]; 185 char filename_try[MAXFILENAME+16];
186 int zipok; 186 int zipok;
187 int err=0; 187 int err=0;
188 int size_buf=0; 188 int size_buf=0;
189 void* buf=NULL; 189 void* buf=NULL;
190 const char* password=NULL; 190 const char* password=NULL;
191 191
192 192
193 do_banner(); 193 do_banner();
194 if (argc==1) 194 if (argc==1)
195 { 195 {
196 do_help(); 196 do_help();
197 return 0; 197 return 0;
198 } 198 }
199 else 199 else
200 { 200 {
201 for (i=1;i<argc;i++) 201 for (i=1;i<argc;i++)
202 { 202 {
203 if ((*argv[i])=='-') 203 if ((*argv[i])=='-')
204 { 204 {
205 const char *p=argv[i]+1; 205 const char *p=argv[i]+1;
206 206
207 while ((*p)!='\0') 207 while ((*p)!='\0')
208 { 208 {
209 char c=*(p++);; 209 char c=*(p++);;
210 if ((c=='o') || (c=='O')) 210 if ((c=='o') || (c=='O'))
211 opt_overwrite = 1; 211 opt_overwrite = 1;
212 if ((c=='a') || (c=='A')) 212 if ((c=='a') || (c=='A'))
213 opt_overwrite = 2; 213 opt_overwrite = 2;
214 if ((c>='0') && (c<='9')) 214 if ((c>='0') && (c<='9'))
215 opt_compress_level = c-'0'; 215 opt_compress_level = c-'0';
216 216
217 if (((c=='p') || (c=='P')) && (i+1<argc)) 217 if (((c=='p') || (c=='P')) && (i+1<argc))
218 { 218 {
219 password=argv[i+1]; 219 password=argv[i+1];
220 i++; 220 i++;
221 } 221 }
222 } 222 }
223 } 223 }
224 else 224 else
225 if (zipfilenamearg == 0) 225 if (zipfilenamearg == 0)
226 zipfilenamearg = i ; 226 zipfilenamearg = i ;
227 } 227 }
228 } 228 }
229 229
230 size_buf = WRITEBUFFERSIZE; 230 size_buf = WRITEBUFFERSIZE;
231 buf = (void*)malloc(size_buf); 231 buf = (void*)malloc(size_buf);
232 if (buf==NULL) 232 if (buf==NULL)
233 { 233 {
234 printf("Error allocating memory\n"); 234 printf("Error allocating memory\n");
235 return ZIP_INTERNALERROR; 235 return ZIP_INTERNALERROR;
236 } 236 }
237 237
238 if (zipfilenamearg==0) 238 if (zipfilenamearg==0)
239 zipok=0; 239 zipok=0;
240 else 240 else
241 { 241 {
242 int i,len; 242 int i,len;
243 int dot_found=0; 243 int dot_found=0;
244 244
245 zipok = 1 ; 245 zipok = 1 ;
246 strncpy(filename_try, argv[zipfilenamearg],MAXFILENAME-1); 246 strncpy(filename_try, argv[zipfilenamearg],MAXFILENAME-1);
247 /* strncpy doesnt append the trailing NULL, of the string is too long. */ 247 /* strncpy doesnt append the trailing NULL, of the string is too long. */
248 filename_try[ MAXFILENAME ] = '\0'; 248 filename_try[ MAXFILENAME ] = '\0';
249 249
250 len=(int)strlen(filename_try); 250 len=(int)strlen(filename_try);
251 for (i=0;i<len;i++) 251 for (i=0;i<len;i++)
252 if (filename_try[i]=='.') 252 if (filename_try[i]=='.')
253 dot_found=1; 253 dot_found=1;
254 254
255 if (dot_found==0) 255 if (dot_found==0)
256 strcat(filename_try,".zip"); 256 strcat(filename_try,".zip");
257 257
258 if (opt_overwrite==2) 258 if (opt_overwrite==2)
259 { 259 {
260 /* if the file don't exist, we not append file */ 260 /* if the file don't exist, we not append file */
261 if (check_exist_file(filename_try)==0) 261 if (check_exist_file(filename_try)==0)
262 opt_overwrite=1; 262 opt_overwrite=1;
263 } 263 }
264 else 264 else
265 if (opt_overwrite==0) 265 if (opt_overwrite==0)
266 if (check_exist_file(filename_try)!=0) 266 if (check_exist_file(filename_try)!=0)
267 { 267 {
268 char rep=0; 268 char rep=0;
269 do 269 do
270 { 270 {
271 char answer[128]; 271 char answer[128];
272 printf("The file %s exist. Overwrite ? [y]es, [n]o, [a]ppend : ",filename_try); 272 printf("The file %s exist. Overwrite ? [y]es, [n]o, [a]ppend : ",filename_try);
273 scanf("%1s",answer); 273 scanf("%1s",answer);
274 rep = answer[0] ; 274 rep = answer[0] ;
275 if ((rep>='a') && (rep<='z')) 275 if ((rep>='a') && (rep<='z'))
276 rep -= 0x20; 276 rep -= 0x20;
277 } 277 }
278 while ((rep!='Y') && (rep!='N') && (rep!='A')); 278 while ((rep!='Y') && (rep!='N') && (rep!='A'));
279 if (rep=='N') 279 if (rep=='N')
280 zipok = 0; 280 zipok = 0;
281 if (rep=='A') 281 if (rep=='A')
282 opt_overwrite = 2; 282 opt_overwrite = 2;
283 } 283 }
284 } 284 }
285 285
286 if (zipok==1) 286 if (zipok==1)
287 { 287 {
288 zipFile zf; 288 zipFile zf;
289 int errclose; 289 int errclose;
290 #ifdef USEWIN32IOAPI 290# ifdef USEWIN32IOAPI
291 zlib_filefunc_def ffunc; 291 zlib_filefunc_def ffunc;
292 fill_win32_filefunc(&ffunc); 292 fill_win32_filefunc(&ffunc);
293 zf = zipOpen2(filename_try,(opt_overwrite==2) ? 2 : 0,NULL,&ffunc); 293 zf = zipOpen2(filename_try,(opt_overwrite==2) ? 2 : 0,NULL,&ffunc);
294 #else 294# else
295 zf = zipOpen(filename_try,(opt_overwrite==2) ? 2 : 0); 295 zf = zipOpen(filename_try,(opt_overwrite==2) ? 2 : 0);
296 #endif 296# endif
297 297
298 if (zf == NULL) 298 if (zf == NULL)
299 { 299 {
300 printf("error opening %s\n",filename_try); 300 printf("error opening %s\n",filename_try);
301 err= ZIP_ERRNO; 301 err= ZIP_ERRNO;
302 } 302 }
303 else 303 else
304 printf("creating %s\n",filename_try); 304 printf("creating %s\n",filename_try);
305 305
306 for (i=zipfilenamearg+1;(i<argc) && (err==ZIP_OK);i++) 306 for (i=zipfilenamearg+1;(i<argc) && (err==ZIP_OK);i++)
307 { 307 {
308 if (((*(argv[i]))!='-') && ((*(argv[i]))!='/')) 308 if (((*(argv[i]))!='-') && ((*(argv[i]))!='/'))
309 { 309 {
310 FILE * fin; 310 FILE * fin;
311 int size_read; 311 int size_read;
312 const char* filenameinzip = argv[i]; 312 const char* filenameinzip = argv[i];
313 zip_fileinfo zi; 313 zip_fileinfo zi;
314 unsigned long crcFile=0; 314 unsigned long crcFile=0;
315 315
316 zi.tmz_date.tm_sec = zi.tmz_date.tm_min = zi.tmz_date.tm_hour = 316 zi.tmz_date.tm_sec = zi.tmz_date.tm_min = zi.tmz_date.tm_hour =
317 zi.tmz_date.tm_mday = zi.tmz_date.tm_mon = zi.tmz_date.tm_year = 0; 317 zi.tmz_date.tm_mday = zi.tmz_date.tm_mon = zi.tmz_date.tm_year = 0;
318 zi.dosDate = 0; 318 zi.dosDate = 0;
319 zi.internal_fa = 0; 319 zi.internal_fa = 0;
320 zi.external_fa = 0; 320 zi.external_fa = 0;
321 filetime(filenameinzip,&zi.tmz_date,&zi.dosDate); 321 filetime(filenameinzip,&zi.tmz_date,&zi.dosDate);
322 322
323/* 323/*
324 err = zipOpenNewFileInZip(zf,filenameinzip,&zi, 324 err = zipOpenNewFileInZip(zf,filenameinzip,&zi,
325 NULL,0,NULL,0,NULL / * comment * /, 325 NULL,0,NULL,0,NULL / * comment * /,
326 (opt_compress_level != 0) ? Z_DEFLATED : 0, 326 (opt_compress_level != 0) ? Z_DEFLATED : 0,
327 opt_compress_level); 327 opt_compress_level);
328*/ 328*/
329 if ((password != NULL) && (err==ZIP_OK)) 329 if ((password != NULL) && (err==ZIP_OK))
330 err = getFileCrc(filenameinzip,buf,size_buf,&crcFile); 330 err = getFileCrc(filenameinzip,buf,size_buf,&crcFile);
331 331
332 err = zipOpenNewFileInZip3(zf,filenameinzip,&zi, 332 err = zipOpenNewFileInZip3(zf,filenameinzip,&zi,
333 NULL,0,NULL,0,NULL /* comment*/, 333 NULL,0,NULL,0,NULL /* comment*/,
334 (opt_compress_level != 0) ? Z_DEFLATED : 0, 334 (opt_compress_level != 0) ? Z_DEFLATED : 0,
335 opt_compress_level,0, 335 opt_compress_level,0,
336 /* -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, */ 336 /* -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, */
337 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, 337 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
338 password,crcFile); 338 password,crcFile);
339 339
340 if (err != ZIP_OK) 340 if (err != ZIP_OK)
341 printf("error in opening %s in zipfile\n",filenameinzip); 341 printf("error in opening %s in zipfile\n",filenameinzip);
342 else 342 else
343 { 343 {
344 fin = fopen(filenameinzip,"rb"); 344 fin = fopen(filenameinzip,"rb");
345 if (fin==NULL) 345 if (fin==NULL)
346 { 346 {
347 err=ZIP_ERRNO; 347 err=ZIP_ERRNO;
348 printf("error in opening %s for reading\n",filenameinzip); 348 printf("error in opening %s for reading\n",filenameinzip);
349 } 349 }
350 } 350 }
351 351
352 if (err == ZIP_OK) 352 if (err == ZIP_OK)
353 do 353 do
354 { 354 {
355 err = ZIP_OK; 355 err = ZIP_OK;
356 size_read = (int)fread(buf,1,size_buf,fin); 356 size_read = (int)fread(buf,1,size_buf,fin);
357 if (size_read < size_buf) 357 if (size_read < size_buf)
358 if (feof(fin)==0) 358 if (feof(fin)==0)
359 { 359 {
360 printf("error in reading %s\n",filenameinzip); 360 printf("error in reading %s\n",filenameinzip);
361 err = ZIP_ERRNO; 361 err = ZIP_ERRNO;
362 } 362 }
363 363
364 if (size_read>0) 364 if (size_read>0)
365 { 365 {
366 err = zipWriteInFileInZip (zf,buf,size_read); 366 err = zipWriteInFileInZip (zf,buf,size_read);
367 if (err<0) 367 if (err<0)
368 { 368 {
369 printf("error in writing %s in the zipfile\n", 369 printf("error in writing %s in the zipfile\n",
370 filenameinzip); 370 filenameinzip);
371 } 371 }
372 372
373 } 373 }
374 } while ((err == ZIP_OK) && (size_read>0)); 374 } while ((err == ZIP_OK) && (size_read>0));
375 375
376 if (fin) 376 if (fin)
377 fclose(fin); 377 fclose(fin);
378 378
379 if (err<0) 379 if (err<0)
380 err=ZIP_ERRNO; 380 err=ZIP_ERRNO;
381 else 381 else
382 { 382 {
383 err = zipCloseFileInZip(zf); 383 err = zipCloseFileInZip(zf);
384 if (err!=ZIP_OK) 384 if (err!=ZIP_OK)
385 printf("error in closing %s in the zipfile\n", 385 printf("error in closing %s in the zipfile\n",
386 filenameinzip); 386 filenameinzip);
387 } 387 }
388 } 388 }
389 } 389 }
390 errclose = zipClose(zf,NULL); 390 errclose = zipClose(zf,NULL);
391 if (errclose != ZIP_OK) 391 if (errclose != ZIP_OK)
392 printf("error in closing %s\n",filename_try); 392 printf("error in closing %s\n",filename_try);
393 } 393 }
394 394
395 free(buf); 395 free(buf);
396 return 0; 396 return 0;
397} 397}
diff --git a/contrib/minizip/unzip.c b/contrib/minizip/unzip.c
index 96f9f33..81c8c28 100644
--- a/contrib/minizip/unzip.c
+++ b/contrib/minizip/unzip.c
@@ -1,1546 +1,1546 @@
1/* unzip.c -- IO for uncompress .zip files using zlib 1/* unzip.c -- IO for uncompress .zip files using zlib
2 Version 0.22, May 19th, 2003 2 Version 0.22, May 19th, 2003
3 3
4 Copyright (C) 1998-2003 Gilles Vollant 4 Copyright (C) 1998-2003 Gilles Vollant
5 5
6 Read unzip.h for more info 6 Read unzip.h for more info
7*/ 7*/
8 8
9/* Decryption code comes from crypt.c by Info-ZIP but has been greatly reduced in terms of 9/* Decryption code comes from crypt.c by Info-ZIP but has been greatly reduced in terms of
10compatibility with older software. The following is from the original crypt.c. Code 10compatibility with older software. The following is from the original crypt.c. Code
11woven in by Terry Thorsen 1/2003. 11woven in by Terry Thorsen 1/2003.
12*/ 12*/
13/* 13/*
14 Copyright (c) 1990-2000 Info-ZIP. All rights reserved. 14 Copyright (c) 1990-2000 Info-ZIP. All rights reserved.
15 15
16 See the accompanying file LICENSE, version 2000-Apr-09 or later 16 See the accompanying file LICENSE, version 2000-Apr-09 or later
17 (the contents of which are also included in zip.h) for terms of use. 17 (the contents of which are also included in zip.h) for terms of use.
18 If, for some reason, all these files are missing, the Info-ZIP license 18 If, for some reason, all these files are missing, the Info-ZIP license
19 also may be found at: ftp://ftp.info-zip.org/pub/infozip/license.html 19 also may be found at: ftp://ftp.info-zip.org/pub/infozip/license.html
20*/ 20*/
21/* 21/*
22 crypt.c (full version) by Info-ZIP. Last revised: [see crypt.h] 22 crypt.c (full version) by Info-ZIP. Last revised: [see crypt.h]
23 23
24 The encryption/decryption parts of this source code (as opposed to the 24 The encryption/decryption parts of this source code (as opposed to the
25 non-echoing password parts) were originally written in Europe. The 25 non-echoing password parts) were originally written in Europe. The
26 whole source package can be freely distributed, including from the USA. 26 whole source package can be freely distributed, including from the USA.
27 (Prior to January 2000, re-export from the US was a violation of US law.) 27 (Prior to January 2000, re-export from the US was a violation of US law.)
28 */ 28 */
29 29
30/* 30/*
31 This encryption code is a direct transcription of the algorithm from 31 This encryption code is a direct transcription of the algorithm from
32 Roger Schlafly, described by Phil Katz in the file appnote.txt. This 32 Roger Schlafly, described by Phil Katz in the file appnote.txt. This
33 file (appnote.txt) is distributed with the PKZIP program (even in the 33 file (appnote.txt) is distributed with the PKZIP program (even in the
34 version without encryption capabilities). 34 version without encryption capabilities).
35 */ 35 */
36 36
37 37
38#include <stdio.h> 38#include <stdio.h>
39#include <stdlib.h> 39#include <stdlib.h>
40#include <string.h> 40#include <string.h>
41#include "zlib.h" 41#include "zlib.h"
42#include "unzip.h" 42#include "unzip.h"
43 43
44#ifdef STDC 44#ifdef STDC
45# include <stddef.h> 45# include <stddef.h>
46# include <string.h> 46# include <string.h>
47# include <stdlib.h> 47# include <stdlib.h>
48#endif 48#endif
49#ifdef NO_ERRNO_H 49#ifdef NO_ERRNO_H
50 extern int errno; 50 extern int errno;
51#else 51#else
52# include <errno.h> 52# include <errno.h>
53#endif 53#endif
54 54
55 55
56#ifndef local 56#ifndef local
57# define local static 57# define local static
58#endif 58#endif
59/* compile with -Dlocal if your debugger can't find static symbols */ 59/* compile with -Dlocal if your debugger can't find static symbols */
60 60
61 61
62 62#ifndef CASESENSITIVITYDEFAULT_NO
63#if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES) && \ 63# if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES)
64 !defined(CASESENSITIVITYDEFAULT_NO) 64# define CASESENSITIVITYDEFAULT_NO
65#define CASESENSITIVITYDEFAULT_NO 65# endif
66#endif 66#endif
67 67
68 68
69#ifndef UNZ_BUFSIZE 69#ifndef UNZ_BUFSIZE
70#define UNZ_BUFSIZE (16384) 70#define UNZ_BUFSIZE (16384)
71#endif 71#endif
72 72
73#ifndef UNZ_MAXFILENAMEINZIP 73#ifndef UNZ_MAXFILENAMEINZIP
74#define UNZ_MAXFILENAMEINZIP (256) 74#define UNZ_MAXFILENAMEINZIP (256)
75#endif 75#endif
76 76
77#ifndef ALLOC 77#ifndef ALLOC
78# define ALLOC(size) (malloc(size)) 78# define ALLOC(size) (malloc(size))
79#endif 79#endif
80#ifndef TRYFREE 80#ifndef TRYFREE
81# define TRYFREE(p) {if (p) free(p);} 81# define TRYFREE(p) {if (p) free(p);}
82#endif 82#endif
83 83
84#define SIZECENTRALDIRITEM (0x2e) 84#define SIZECENTRALDIRITEM (0x2e)
85#define SIZEZIPLOCALHEADER (0x1e) 85#define SIZEZIPLOCALHEADER (0x1e)
86 86
87 87
88 88
89 89
90const char unz_copyright[] = 90const char unz_copyright[] =
91 " unzip 0.22 Copyright 1998-2003 Gilles Vollant - http://www.winimage.com/zLibDll"; 91 " unzip 0.22 Copyright 1998-2003 Gilles Vollant - http://www.winimage.com/zLibDll";
92 92
93/* unz_file_info_interntal contain internal info about a file in zipfile*/ 93/* unz_file_info_interntal contain internal info about a file in zipfile*/
94typedef struct unz_file_info_internal_s 94typedef struct unz_file_info_internal_s
95{ 95{
96 uLong offset_curfile;/* relative offset of local header 4 bytes */ 96 uLong offset_curfile;/* relative offset of local header 4 bytes */
97} unz_file_info_internal; 97} unz_file_info_internal;
98 98
99 99
100/* file_in_zip_read_info_s contain internal information about a file in zipfile, 100/* file_in_zip_read_info_s contain internal information about a file in zipfile,
101 when reading and decompress it */ 101 when reading and decompress it */
102typedef struct 102typedef struct
103{ 103{
104 char *read_buffer; /* internal buffer for compressed data */ 104 char *read_buffer; /* internal buffer for compressed data */
105 z_stream stream; /* zLib stream structure for inflate */ 105 z_stream stream; /* zLib stream structure for inflate */
106 106
107 uLong pos_in_zipfile; /* position in byte on the zipfile, for fseek*/ 107 uLong pos_in_zipfile; /* position in byte on the zipfile, for fseek*/
108 uLong stream_initialised; /* flag set if stream structure is initialised*/ 108 uLong stream_initialised; /* flag set if stream structure is initialised*/
109 109
110 uLong offset_local_extrafield;/* offset of the local extra field */ 110 uLong offset_local_extrafield;/* offset of the local extra field */
111 uInt size_local_extrafield;/* size of the local extra field */ 111 uInt size_local_extrafield;/* size of the local extra field */
112 uLong pos_local_extrafield; /* position in the local extra field in read*/ 112 uLong pos_local_extrafield; /* position in the local extra field in read*/
113 113
114 uLong crc32; /* crc32 of all data uncompressed */ 114 uLong crc32; /* crc32 of all data uncompressed */
115 uLong crc32_wait; /* crc32 we must obtain after decompress all */ 115 uLong crc32_wait; /* crc32 we must obtain after decompress all */
116 uLong rest_read_compressed; /* number of byte to be decompressed */ 116 uLong rest_read_compressed; /* number of byte to be decompressed */
117 uLong rest_read_uncompressed;/*number of byte to be obtained after decomp*/ 117 uLong rest_read_uncompressed;/*number of byte to be obtained after decomp*/
118 zlib_filefunc_def z_filefunc; 118 zlib_filefunc_def z_filefunc;
119 voidpf filestream; /* io structore of the zipfile */ 119 voidpf filestream; /* io structore of the zipfile */
120 uLong compression_method; /* compression method (0==store) */ 120 uLong compression_method; /* compression method (0==store) */
121 uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/ 121 uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
122 int raw; 122 int raw;
123} file_in_zip_read_info_s; 123} file_in_zip_read_info_s;
124 124
125 125
126/* unz_s contain internal information about the zipfile 126/* unz_s contain internal information about the zipfile
127*/ 127*/
128typedef struct 128typedef struct
129{ 129{
130 zlib_filefunc_def z_filefunc; 130 zlib_filefunc_def z_filefunc;
131 voidpf filestream; /* io structore of the zipfile */ 131 voidpf filestream; /* io structore of the zipfile */
132 unz_global_info gi; /* public global information */ 132 unz_global_info gi; /* public global information */
133 uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/ 133 uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
134 uLong num_file; /* number of the current file in the zipfile*/ 134 uLong num_file; /* number of the current file in the zipfile*/
135 uLong pos_in_central_dir; /* pos of the current file in the central dir*/ 135 uLong pos_in_central_dir; /* pos of the current file in the central dir*/
136 uLong current_file_ok; /* flag about the usability of the current file*/ 136 uLong current_file_ok; /* flag about the usability of the current file*/
137 uLong central_pos; /* position of the beginning of the central dir*/ 137 uLong central_pos; /* position of the beginning of the central dir*/
138 138
139 uLong size_central_dir; /* size of the central directory */ 139 uLong size_central_dir; /* size of the central directory */
140 uLong offset_central_dir; /* offset of start of central directory with 140 uLong offset_central_dir; /* offset of start of central directory with
141 respect to the starting disk number */ 141 respect to the starting disk number */
142 142
143 unz_file_info cur_file_info; /* public info about the current file in zip*/ 143 unz_file_info cur_file_info; /* public info about the current file in zip*/
144 unz_file_info_internal cur_file_info_internal; /* private info about it*/ 144 unz_file_info_internal cur_file_info_internal; /* private info about it*/
145 file_in_zip_read_info_s* pfile_in_zip_read; /* structure about the current 145 file_in_zip_read_info_s* pfile_in_zip_read; /* structure about the current
146 file if we are decompressing it */ 146 file if we are decompressing it */
147 int encrypted; 147 int encrypted;
148 #ifndef NOUNCRYPT 148# ifndef NOUNCRYPT
149 unsigned long keys[3]; /* keys defining the pseudo-random sequence */ 149 unsigned long keys[3]; /* keys defining the pseudo-random sequence */
150 const unsigned long* pcrc_32_tab; 150 const unsigned long* pcrc_32_tab;
151 #endif 151# endif
152} unz_s; 152} unz_s;
153 153
154 154
155#ifndef NOUNCRYPT 155#ifndef NOUNCRYPT
156#include "crypt.h" 156#include "crypt.h"
157#endif 157#endif
158 158
159/* =========================================================================== 159/* ===========================================================================
160 Read a byte from a gz_stream; update next_in and avail_in. Return EOF 160 Read a byte from a gz_stream; update next_in and avail_in. Return EOF
161 for end of file. 161 for end of file.
162 IN assertion: the stream s has been sucessfully opened for reading. 162 IN assertion: the stream s has been sucessfully opened for reading.
163*/ 163*/
164 164
165 165
166local int unzlocal_getByte OF(( 166local int unzlocal_getByte OF((
167 const zlib_filefunc_def* pzlib_filefunc_def, 167 const zlib_filefunc_def* pzlib_filefunc_def,
168 voidpf filestream, 168 voidpf filestream,
169 int *pi)); 169 int *pi));
170 170
171local int unzlocal_getByte(pzlib_filefunc_def,filestream,pi) 171local int unzlocal_getByte(pzlib_filefunc_def,filestream,pi)
172 const zlib_filefunc_def* pzlib_filefunc_def; 172 const zlib_filefunc_def* pzlib_filefunc_def;
173 voidpf filestream; 173 voidpf filestream;
174 int *pi; 174 int *pi;
175{ 175{
176 unsigned char c; 176 unsigned char c;
177 int err = (int)ZREAD(*pzlib_filefunc_def,filestream,&c,1); 177 int err = (int)ZREAD(*pzlib_filefunc_def,filestream,&c,1);
178 if (err==1) 178 if (err==1)
179 { 179 {
180 *pi = (int)c; 180 *pi = (int)c;
181 return UNZ_OK; 181 return UNZ_OK;
182 } 182 }
183 else 183 else
184 { 184 {
185 if (ZERROR(*pzlib_filefunc_def,filestream)) 185 if (ZERROR(*pzlib_filefunc_def,filestream))
186 return UNZ_ERRNO; 186 return UNZ_ERRNO;
187 else 187 else
188 return UNZ_EOF; 188 return UNZ_EOF;
189 } 189 }
190} 190}
191 191
192 192
193/* =========================================================================== 193/* ===========================================================================
194 Reads a long in LSB order from the given gz_stream. Sets 194 Reads a long in LSB order from the given gz_stream. Sets
195*/ 195*/
196local int unzlocal_getShort OF(( 196local int unzlocal_getShort OF((
197 const zlib_filefunc_def* pzlib_filefunc_def, 197 const zlib_filefunc_def* pzlib_filefunc_def,
198 voidpf filestream, 198 voidpf filestream,
199 uLong *pX)); 199 uLong *pX));
200 200
201local int unzlocal_getShort (pzlib_filefunc_def,filestream,pX) 201local int unzlocal_getShort (pzlib_filefunc_def,filestream,pX)
202 const zlib_filefunc_def* pzlib_filefunc_def; 202 const zlib_filefunc_def* pzlib_filefunc_def;
203 voidpf filestream; 203 voidpf filestream;
204 uLong *pX; 204 uLong *pX;
205{ 205{
206 uLong x ; 206 uLong x ;
207 int i; 207 int i;
208 int err; 208 int err;
209 209
210 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i); 210 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
211 x = (uLong)i; 211 x = (uLong)i;
212 212
213 if (err==UNZ_OK) 213 if (err==UNZ_OK)
214 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i); 214 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
215 x += ((uLong)i)<<8; 215 x += ((uLong)i)<<8;
216 216
217 if (err==UNZ_OK) 217 if (err==UNZ_OK)
218 *pX = x; 218 *pX = x;
219 else 219 else
220 *pX = 0; 220 *pX = 0;
221 return err; 221 return err;
222} 222}
223 223
224local int unzlocal_getLong OF(( 224local int unzlocal_getLong OF((
225 const zlib_filefunc_def* pzlib_filefunc_def, 225 const zlib_filefunc_def* pzlib_filefunc_def,
226 voidpf filestream, 226 voidpf filestream,
227 uLong *pX)); 227 uLong *pX));
228 228
229local int unzlocal_getLong (pzlib_filefunc_def,filestream,pX) 229local int unzlocal_getLong (pzlib_filefunc_def,filestream,pX)
230 const zlib_filefunc_def* pzlib_filefunc_def; 230 const zlib_filefunc_def* pzlib_filefunc_def;
231 voidpf filestream; 231 voidpf filestream;
232 uLong *pX; 232 uLong *pX;
233{ 233{
234 uLong x ; 234 uLong x ;
235 int i; 235 int i;
236 int err; 236 int err;
237 237
238 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i); 238 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
239 x = (uLong)i; 239 x = (uLong)i;
240 240
241 if (err==UNZ_OK) 241 if (err==UNZ_OK)
242 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i); 242 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
243 x += ((uLong)i)<<8; 243 x += ((uLong)i)<<8;
244 244
245 if (err==UNZ_OK) 245 if (err==UNZ_OK)
246 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i); 246 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
247 x += ((uLong)i)<<16; 247 x += ((uLong)i)<<16;
248 248
249 if (err==UNZ_OK) 249 if (err==UNZ_OK)
250 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i); 250 err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
251 x += ((uLong)i)<<24; 251 x += ((uLong)i)<<24;
252 252
253 if (err==UNZ_OK) 253 if (err==UNZ_OK)
254 *pX = x; 254 *pX = x;
255 else 255 else
256 *pX = 0; 256 *pX = 0;
257 return err; 257 return err;
258} 258}
259 259
260 260
261/* My own strcmpi / strcasecmp */ 261/* My own strcmpi / strcasecmp */
262local int strcmpcasenosensitive_internal (fileName1,fileName2) 262local int strcmpcasenosensitive_internal (fileName1,fileName2)
263 const char* fileName1; 263 const char* fileName1;
264 const char* fileName2; 264 const char* fileName2;
265{ 265{
266 for (;;) 266 for (;;)
267 { 267 {
268 char c1=*(fileName1++); 268 char c1=*(fileName1++);
269 char c2=*(fileName2++); 269 char c2=*(fileName2++);
270 if ((c1>='a') && (c1<='z')) 270 if ((c1>='a') && (c1<='z'))
271 c1 -= 0x20; 271 c1 -= 0x20;
272 if ((c2>='a') && (c2<='z')) 272 if ((c2>='a') && (c2<='z'))
273 c2 -= 0x20; 273 c2 -= 0x20;
274 if (c1=='\0') 274 if (c1=='\0')
275 return ((c2=='\0') ? 0 : -1); 275 return ((c2=='\0') ? 0 : -1);
276 if (c2=='\0') 276 if (c2=='\0')
277 return 1; 277 return 1;
278 if (c1<c2) 278 if (c1<c2)
279 return -1; 279 return -1;
280 if (c1>c2) 280 if (c1>c2)
281 return 1; 281 return 1;
282 } 282 }
283} 283}
284 284
285 285
286#ifdef CASESENSITIVITYDEFAULT_NO 286#ifdef CASESENSITIVITYDEFAULT_NO
287#define CASESENSITIVITYDEFAULTVALUE 2 287#define CASESENSITIVITYDEFAULTVALUE 2
288#else 288#else
289#define CASESENSITIVITYDEFAULTVALUE 1 289#define CASESENSITIVITYDEFAULTVALUE 1
290#endif 290#endif
291 291
292#ifndef STRCMPCASENOSENTIVEFUNCTION 292#ifndef STRCMPCASENOSENTIVEFUNCTION
293#define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal 293#define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal
294#endif 294#endif
295 295
296/* 296/*
297 Compare two filename (fileName1,fileName2). 297 Compare two filename (fileName1,fileName2).
298 If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp) 298 If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
299 If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi 299 If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
300 or strcasecmp) 300 or strcasecmp)
301 If iCaseSenisivity = 0, case sensitivity is defaut of your operating system 301 If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
302 (like 1 on Unix, 2 on Windows) 302 (like 1 on Unix, 2 on Windows)
303 303
304*/ 304*/
305extern int ZEXPORT unzStringFileNameCompare (fileName1,fileName2,iCaseSensitivity) 305extern int ZEXPORT unzStringFileNameCompare (fileName1,fileName2,iCaseSensitivity)
306 const char* fileName1; 306 const char* fileName1;
307 const char* fileName2; 307 const char* fileName2;
308 int iCaseSensitivity; 308 int iCaseSensitivity;
309{ 309{
310 if (iCaseSensitivity==0) 310 if (iCaseSensitivity==0)
311 iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE; 311 iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE;
312 312
313 if (iCaseSensitivity==1) 313 if (iCaseSensitivity==1)
314 return strcmp(fileName1,fileName2); 314 return strcmp(fileName1,fileName2);
315 315
316 return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2); 316 return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2);
317} 317}
318 318
319#ifndef BUFREADCOMMENT 319#ifndef BUFREADCOMMENT
320#define BUFREADCOMMENT (0x400) 320#define BUFREADCOMMENT (0x400)
321#endif 321#endif
322 322
323/* 323/*
324 Locate the Central directory of a zipfile (at the end, just before 324 Locate the Central directory of a zipfile (at the end, just before
325 the global comment) 325 the global comment)
326*/ 326*/
327local uLong unzlocal_SearchCentralDir OF(( 327local uLong unzlocal_SearchCentralDir OF((
328 const zlib_filefunc_def* pzlib_filefunc_def, 328 const zlib_filefunc_def* pzlib_filefunc_def,
329 voidpf filestream)); 329 voidpf filestream));
330 330
331local uLong unzlocal_SearchCentralDir(pzlib_filefunc_def,filestream) 331local uLong unzlocal_SearchCentralDir(pzlib_filefunc_def,filestream)
332 const zlib_filefunc_def* pzlib_filefunc_def; 332 const zlib_filefunc_def* pzlib_filefunc_def;
333 voidpf filestream; 333 voidpf filestream;
334{ 334{
335 unsigned char* buf; 335 unsigned char* buf;
336 uLong uSizeFile; 336 uLong uSizeFile;
337 uLong uBackRead; 337 uLong uBackRead;
338 uLong uMaxBack=0xffff; /* maximum size of global comment */ 338 uLong uMaxBack=0xffff; /* maximum size of global comment */
339 uLong uPosFound=0; 339 uLong uPosFound=0;
340 340
341 if (ZSEEK(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0) 341 if (ZSEEK(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
342 return 0; 342 return 0;
343 343
344 344
345 uSizeFile = ZTELL(*pzlib_filefunc_def,filestream); 345 uSizeFile = ZTELL(*pzlib_filefunc_def,filestream);
346 346
347 if (uMaxBack>uSizeFile) 347 if (uMaxBack>uSizeFile)
348 uMaxBack = uSizeFile; 348 uMaxBack = uSizeFile;
349 349
350 buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4); 350 buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
351 if (buf==NULL) 351 if (buf==NULL)
352 return 0; 352 return 0;
353 353
354 uBackRead = 4; 354 uBackRead = 4;
355 while (uBackRead<uMaxBack) 355 while (uBackRead<uMaxBack)
356 { 356 {
357 uLong uReadSize,uReadPos ; 357 uLong uReadSize,uReadPos ;
358 int i; 358 int i;
359 if (uBackRead+BUFREADCOMMENT>uMaxBack) 359 if (uBackRead+BUFREADCOMMENT>uMaxBack)
360 uBackRead = uMaxBack; 360 uBackRead = uMaxBack;
361 else 361 else
362 uBackRead+=BUFREADCOMMENT; 362 uBackRead+=BUFREADCOMMENT;
363 uReadPos = uSizeFile-uBackRead ; 363 uReadPos = uSizeFile-uBackRead ;
364 364
365 uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ? 365 uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
366 (BUFREADCOMMENT+4) : (uSizeFile-uReadPos); 366 (BUFREADCOMMENT+4) : (uSizeFile-uReadPos);
367 if (ZSEEK(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0) 367 if (ZSEEK(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
368 break; 368 break;
369 369
370 if (ZREAD(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize) 370 if (ZREAD(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
371 break; 371 break;
372 372
373 for (i=(int)uReadSize-3; (i--)>0;) 373 for (i=(int)uReadSize-3; (i--)>0;)
374 if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && 374 if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
375 ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06)) 375 ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
376 { 376 {
377 uPosFound = uReadPos+i; 377 uPosFound = uReadPos+i;
378 break; 378 break;
379 } 379 }
380 380
381 if (uPosFound!=0) 381 if (uPosFound!=0)
382 break; 382 break;
383 } 383 }
384 TRYFREE(buf); 384 TRYFREE(buf);
385 return uPosFound; 385 return uPosFound;
386} 386}
387 387
388/* 388/*
389 Open a Zip file. path contain the full pathname (by example, 389 Open a Zip file. path contain the full pathname (by example,
390 on a Windows NT computer "c:\\test\\zlib114.zip" or on an Unix computer 390 on a Windows NT computer "c:\\test\\zlib114.zip" or on an Unix computer
391 "zlib/zlib114.zip". 391 "zlib/zlib114.zip".
392 If the zipfile cannot be opened (file doesn't exist or in not valid), the 392 If the zipfile cannot be opened (file doesn't exist or in not valid), the
393 return value is NULL. 393 return value is NULL.
394 Else, the return value is a unzFile Handle, usable with other function 394 Else, the return value is a unzFile Handle, usable with other function
395 of this unzip package. 395 of this unzip package.
396*/ 396*/
397extern unzFile ZEXPORT unzOpen2 (path, pzlib_filefunc_def) 397extern unzFile ZEXPORT unzOpen2 (path, pzlib_filefunc_def)
398 const char *path; 398 const char *path;
399 zlib_filefunc_def* pzlib_filefunc_def; 399 zlib_filefunc_def* pzlib_filefunc_def;
400{ 400{
401 unz_s us; 401 unz_s us;
402 unz_s *s; 402 unz_s *s;
403 uLong central_pos,uL; 403 uLong central_pos,uL;
404 404
405 uLong number_disk; /* number of the current dist, used for 405 uLong number_disk; /* number of the current dist, used for
406 spaning ZIP, unsupported, always 0*/ 406 spaning ZIP, unsupported, always 0*/
407 uLong number_disk_with_CD; /* number the the disk with central dir, used 407 uLong number_disk_with_CD; /* number the the disk with central dir, used
408 for spaning ZIP, unsupported, always 0*/ 408 for spaning ZIP, unsupported, always 0*/
409 uLong number_entry_CD; /* total number of entries in 409 uLong number_entry_CD; /* total number of entries in
410 the central dir 410 the central dir
411 (same than number_entry on nospan) */ 411 (same than number_entry on nospan) */
412 412
413 int err=UNZ_OK; 413 int err=UNZ_OK;
414 414
415 if (unz_copyright[0]!=' ') 415 if (unz_copyright[0]!=' ')
416 return NULL; 416 return NULL;
417 417
418 if (pzlib_filefunc_def==NULL) 418 if (pzlib_filefunc_def==NULL)
419 fill_fopen_filefunc(&us.z_filefunc); 419 fill_fopen_filefunc(&us.z_filefunc);
420 else 420 else
421 us.z_filefunc = *pzlib_filefunc_def; 421 us.z_filefunc = *pzlib_filefunc_def;
422 422
423 us.filestream= (*(us.z_filefunc.zopen_file))(us.z_filefunc.opaque, 423 us.filestream= (*(us.z_filefunc.zopen_file))(us.z_filefunc.opaque,
424 path, 424 path,
425 ZLIB_FILEFUNC_MODE_READ | 425 ZLIB_FILEFUNC_MODE_READ |
426 ZLIB_FILEFUNC_MODE_EXISTING); 426 ZLIB_FILEFUNC_MODE_EXISTING);
427 if (us.filestream==NULL) 427 if (us.filestream==NULL)
428 return NULL; 428 return NULL;
429 429
430 central_pos = unzlocal_SearchCentralDir(&us.z_filefunc,us.filestream); 430 central_pos = unzlocal_SearchCentralDir(&us.z_filefunc,us.filestream);
431 if (central_pos==0) 431 if (central_pos==0)
432 err=UNZ_ERRNO; 432 err=UNZ_ERRNO;
433 433
434 if (ZSEEK(us.z_filefunc, us.filestream, 434 if (ZSEEK(us.z_filefunc, us.filestream,
435 central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0) 435 central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
436 err=UNZ_ERRNO; 436 err=UNZ_ERRNO;
437 437
438 /* the signature, already checked */ 438 /* the signature, already checked */
439 if (unzlocal_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK) 439 if (unzlocal_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
440 err=UNZ_ERRNO; 440 err=UNZ_ERRNO;
441 441
442 /* number of this disk */ 442 /* number of this disk */
443 if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK) 443 if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK)
444 err=UNZ_ERRNO; 444 err=UNZ_ERRNO;
445 445
446 /* number of the disk with the start of the central directory */ 446 /* number of the disk with the start of the central directory */
447 if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK) 447 if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK)
448 err=UNZ_ERRNO; 448 err=UNZ_ERRNO;
449 449
450 /* total number of entries in the central dir on this disk */ 450 /* total number of entries in the central dir on this disk */
451 if (unzlocal_getShort(&us.z_filefunc, us.filestream,&us.gi.number_entry)!=UNZ_OK) 451 if (unzlocal_getShort(&us.z_filefunc, us.filestream,&us.gi.number_entry)!=UNZ_OK)
452 err=UNZ_ERRNO; 452 err=UNZ_ERRNO;
453 453
454 /* total number of entries in the central dir */ 454 /* total number of entries in the central dir */
455 if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_entry_CD)!=UNZ_OK) 455 if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_entry_CD)!=UNZ_OK)
456 err=UNZ_ERRNO; 456 err=UNZ_ERRNO;
457 457
458 if ((number_entry_CD!=us.gi.number_entry) || 458 if ((number_entry_CD!=us.gi.number_entry) ||
459 (number_disk_with_CD!=0) || 459 (number_disk_with_CD!=0) ||
460 (number_disk!=0)) 460 (number_disk!=0))
461 err=UNZ_BADZIPFILE; 461 err=UNZ_BADZIPFILE;
462 462
463 /* size of the central directory */ 463 /* size of the central directory */
464 if (unzlocal_getLong(&us.z_filefunc, us.filestream,&us.size_central_dir)!=UNZ_OK) 464 if (unzlocal_getLong(&us.z_filefunc, us.filestream,&us.size_central_dir)!=UNZ_OK)
465 err=UNZ_ERRNO; 465 err=UNZ_ERRNO;
466 466
467 /* offset of start of central directory with respect to the 467 /* offset of start of central directory with respect to the
468 starting disk number */ 468 starting disk number */
469 if (unzlocal_getLong(&us.z_filefunc, us.filestream,&us.offset_central_dir)!=UNZ_OK) 469 if (unzlocal_getLong(&us.z_filefunc, us.filestream,&us.offset_central_dir)!=UNZ_OK)
470 err=UNZ_ERRNO; 470 err=UNZ_ERRNO;
471 471
472 /* zipfile comment length */ 472 /* zipfile comment length */
473 if (unzlocal_getShort(&us.z_filefunc, us.filestream,&us.gi.size_comment)!=UNZ_OK) 473 if (unzlocal_getShort(&us.z_filefunc, us.filestream,&us.gi.size_comment)!=UNZ_OK)
474 err=UNZ_ERRNO; 474 err=UNZ_ERRNO;
475 475
476 if ((central_pos<us.offset_central_dir+us.size_central_dir) && 476 if ((central_pos<us.offset_central_dir+us.size_central_dir) &&
477 (err==UNZ_OK)) 477 (err==UNZ_OK))
478 err=UNZ_BADZIPFILE; 478 err=UNZ_BADZIPFILE;
479 479
480 if (err!=UNZ_OK) 480 if (err!=UNZ_OK)
481 { 481 {
482 ZCLOSE(us.z_filefunc, us.filestream); 482 ZCLOSE(us.z_filefunc, us.filestream);
483 return NULL; 483 return NULL;
484 } 484 }
485 485
486 us.byte_before_the_zipfile = central_pos - 486 us.byte_before_the_zipfile = central_pos -
487 (us.offset_central_dir+us.size_central_dir); 487 (us.offset_central_dir+us.size_central_dir);
488 us.central_pos = central_pos; 488 us.central_pos = central_pos;
489 us.pfile_in_zip_read = NULL; 489 us.pfile_in_zip_read = NULL;
490 us.encrypted = 0; 490 us.encrypted = 0;
491 491
492 492
493 s=(unz_s*)ALLOC(sizeof(unz_s)); 493 s=(unz_s*)ALLOC(sizeof(unz_s));
494 *s=us; 494 *s=us;
495 unzGoToFirstFile((unzFile)s); 495 unzGoToFirstFile((unzFile)s);
496 return (unzFile)s; 496 return (unzFile)s;
497} 497}
498 498
499 499
500extern unzFile ZEXPORT unzOpen (path) 500extern unzFile ZEXPORT unzOpen (path)
501 const char *path; 501 const char *path;
502{ 502{
503 return unzOpen2(path, NULL); 503 return unzOpen2(path, NULL);
504} 504}
505 505
506/* 506/*
507 Close a ZipFile opened with unzipOpen. 507 Close a ZipFile opened with unzipOpen.
508 If there is files inside the .Zip opened with unzipOpenCurrentFile (see later), 508 If there is files inside the .Zip opened with unzipOpenCurrentFile (see later),
509 these files MUST be closed with unzipCloseCurrentFile before call unzipClose. 509 these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
510 return UNZ_OK if there is no problem. */ 510 return UNZ_OK if there is no problem. */
511extern int ZEXPORT unzClose (file) 511extern int ZEXPORT unzClose (file)
512 unzFile file; 512 unzFile file;
513{ 513{
514 unz_s* s; 514 unz_s* s;
515 if (file==NULL) 515 if (file==NULL)
516 return UNZ_PARAMERROR; 516 return UNZ_PARAMERROR;
517 s=(unz_s*)file; 517 s=(unz_s*)file;
518 518
519 if (s->pfile_in_zip_read!=NULL) 519 if (s->pfile_in_zip_read!=NULL)
520 unzCloseCurrentFile(file); 520 unzCloseCurrentFile(file);
521 521
522 ZCLOSE(s->z_filefunc, s->filestream); 522 ZCLOSE(s->z_filefunc, s->filestream);
523 TRYFREE(s); 523 TRYFREE(s);
524 return UNZ_OK; 524 return UNZ_OK;
525} 525}
526 526
527 527
528/* 528/*
529 Write info about the ZipFile in the *pglobal_info structure. 529 Write info about the ZipFile in the *pglobal_info structure.
530 No preparation of the structure is needed 530 No preparation of the structure is needed
531 return UNZ_OK if there is no problem. */ 531 return UNZ_OK if there is no problem. */
532extern int ZEXPORT unzGetGlobalInfo (file,pglobal_info) 532extern int ZEXPORT unzGetGlobalInfo (file,pglobal_info)
533 unzFile file; 533 unzFile file;
534 unz_global_info *pglobal_info; 534 unz_global_info *pglobal_info;
535{ 535{
536 unz_s* s; 536 unz_s* s;
537 if (file==NULL) 537 if (file==NULL)
538 return UNZ_PARAMERROR; 538 return UNZ_PARAMERROR;
539 s=(unz_s*)file; 539 s=(unz_s*)file;
540 *pglobal_info=s->gi; 540 *pglobal_info=s->gi;
541 return UNZ_OK; 541 return UNZ_OK;
542} 542}
543 543
544 544
545/* 545/*
546 Translate date/time from Dos format to tm_unz (readable more easilty) 546 Translate date/time from Dos format to tm_unz (readable more easilty)
547*/ 547*/
548local void unzlocal_DosDateToTmuDate (ulDosDate, ptm) 548local void unzlocal_DosDateToTmuDate (ulDosDate, ptm)
549 uLong ulDosDate; 549 uLong ulDosDate;
550 tm_unz* ptm; 550 tm_unz* ptm;
551{ 551{
552 uLong uDate; 552 uLong uDate;
553 uDate = (uLong)(ulDosDate>>16); 553 uDate = (uLong)(ulDosDate>>16);
554 ptm->tm_mday = (uInt)(uDate&0x1f) ; 554 ptm->tm_mday = (uInt)(uDate&0x1f) ;
555 ptm->tm_mon = (uInt)((((uDate)&0x1E0)/0x20)-1) ; 555 ptm->tm_mon = (uInt)((((uDate)&0x1E0)/0x20)-1) ;
556 ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ; 556 ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ;
557 557
558 ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800); 558 ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800);
559 ptm->tm_min = (uInt) ((ulDosDate&0x7E0)/0x20) ; 559 ptm->tm_min = (uInt) ((ulDosDate&0x7E0)/0x20) ;
560 ptm->tm_sec = (uInt) (2*(ulDosDate&0x1f)) ; 560 ptm->tm_sec = (uInt) (2*(ulDosDate&0x1f)) ;
561} 561}
562 562
563/* 563/*
564 Get Info about the current file in the zipfile, with internal only info 564 Get Info about the current file in the zipfile, with internal only info
565*/ 565*/
566local int unzlocal_GetCurrentFileInfoInternal OF((unzFile file, 566local int unzlocal_GetCurrentFileInfoInternal OF((unzFile file,
567 unz_file_info *pfile_info, 567 unz_file_info *pfile_info,
568 unz_file_info_internal 568 unz_file_info_internal
569 *pfile_info_internal, 569 *pfile_info_internal,
570 char *szFileName, 570 char *szFileName,
571 uLong fileNameBufferSize, 571 uLong fileNameBufferSize,
572 void *extraField, 572 void *extraField,
573 uLong extraFieldBufferSize, 573 uLong extraFieldBufferSize,
574 char *szComment, 574 char *szComment,
575 uLong commentBufferSize)); 575 uLong commentBufferSize));
576 576
577local int unzlocal_GetCurrentFileInfoInternal (file, 577local int unzlocal_GetCurrentFileInfoInternal (file,
578 pfile_info, 578 pfile_info,
579 pfile_info_internal, 579 pfile_info_internal,
580 szFileName, fileNameBufferSize, 580 szFileName, fileNameBufferSize,
581 extraField, extraFieldBufferSize, 581 extraField, extraFieldBufferSize,
582 szComment, commentBufferSize) 582 szComment, commentBufferSize)
583 unzFile file; 583 unzFile file;
584 unz_file_info *pfile_info; 584 unz_file_info *pfile_info;
585 unz_file_info_internal *pfile_info_internal; 585 unz_file_info_internal *pfile_info_internal;
586 char *szFileName; 586 char *szFileName;
587 uLong fileNameBufferSize; 587 uLong fileNameBufferSize;
588 void *extraField; 588 void *extraField;
589 uLong extraFieldBufferSize; 589 uLong extraFieldBufferSize;
590 char *szComment; 590 char *szComment;
591 uLong commentBufferSize; 591 uLong commentBufferSize;
592{ 592{
593 unz_s* s; 593 unz_s* s;
594 unz_file_info file_info; 594 unz_file_info file_info;
595 unz_file_info_internal file_info_internal; 595 unz_file_info_internal file_info_internal;
596 int err=UNZ_OK; 596 int err=UNZ_OK;
597 uLong uMagic; 597 uLong uMagic;
598 long lSeek=0; 598 long lSeek=0;
599 599
600 if (file==NULL) 600 if (file==NULL)
601 return UNZ_PARAMERROR; 601 return UNZ_PARAMERROR;
602 s=(unz_s*)file; 602 s=(unz_s*)file;
603 if (ZSEEK(s->z_filefunc, s->filestream, 603 if (ZSEEK(s->z_filefunc, s->filestream,
604 s->pos_in_central_dir+s->byte_before_the_zipfile, 604 s->pos_in_central_dir+s->byte_before_the_zipfile,
605 ZLIB_FILEFUNC_SEEK_SET)!=0) 605 ZLIB_FILEFUNC_SEEK_SET)!=0)
606 err=UNZ_ERRNO; 606 err=UNZ_ERRNO;
607 607
608 608
609 /* we check the magic */ 609 /* we check the magic */
610 if (err==UNZ_OK) 610 if (err==UNZ_OK)
611 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK) 611 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)
612 err=UNZ_ERRNO; 612 err=UNZ_ERRNO;
613 else if (uMagic!=0x02014b50) 613 else if (uMagic!=0x02014b50)
614 err=UNZ_BADZIPFILE; 614 err=UNZ_BADZIPFILE;
615 615
616 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.version) != UNZ_OK) 616 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.version) != UNZ_OK)
617 err=UNZ_ERRNO; 617 err=UNZ_ERRNO;
618 618
619 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.version_needed) != UNZ_OK) 619 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.version_needed) != UNZ_OK)
620 err=UNZ_ERRNO; 620 err=UNZ_ERRNO;
621 621
622 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.flag) != UNZ_OK) 622 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.flag) != UNZ_OK)
623 err=UNZ_ERRNO; 623 err=UNZ_ERRNO;
624 624
625 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.compression_method) != UNZ_OK) 625 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.compression_method) != UNZ_OK)
626 err=UNZ_ERRNO; 626 err=UNZ_ERRNO;
627 627
628 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.dosDate) != UNZ_OK) 628 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.dosDate) != UNZ_OK)
629 err=UNZ_ERRNO; 629 err=UNZ_ERRNO;
630 630
631 unzlocal_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date); 631 unzlocal_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date);
632 632
633 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.crc) != UNZ_OK) 633 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.crc) != UNZ_OK)
634 err=UNZ_ERRNO; 634 err=UNZ_ERRNO;
635 635
636 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.compressed_size) != UNZ_OK) 636 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.compressed_size) != UNZ_OK)
637 err=UNZ_ERRNO; 637 err=UNZ_ERRNO;
638 638
639 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.uncompressed_size) != UNZ_OK) 639 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.uncompressed_size) != UNZ_OK)
640 err=UNZ_ERRNO; 640 err=UNZ_ERRNO;
641 641
642 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_filename) != UNZ_OK) 642 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_filename) != UNZ_OK)
643 err=UNZ_ERRNO; 643 err=UNZ_ERRNO;
644 644
645 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_extra) != UNZ_OK) 645 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_extra) != UNZ_OK)
646 err=UNZ_ERRNO; 646 err=UNZ_ERRNO;
647 647
648 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_comment) != UNZ_OK) 648 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_comment) != UNZ_OK)
649 err=UNZ_ERRNO; 649 err=UNZ_ERRNO;
650 650
651 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.disk_num_start) != UNZ_OK) 651 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.disk_num_start) != UNZ_OK)
652 err=UNZ_ERRNO; 652 err=UNZ_ERRNO;
653 653
654 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.internal_fa) != UNZ_OK) 654 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.internal_fa) != UNZ_OK)
655 err=UNZ_ERRNO; 655 err=UNZ_ERRNO;
656 656
657 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.external_fa) != UNZ_OK) 657 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.external_fa) != UNZ_OK)
658 err=UNZ_ERRNO; 658 err=UNZ_ERRNO;
659 659
660 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info_internal.offset_curfile) != UNZ_OK) 660 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info_internal.offset_curfile) != UNZ_OK)
661 err=UNZ_ERRNO; 661 err=UNZ_ERRNO;
662 662
663 lSeek+=file_info.size_filename; 663 lSeek+=file_info.size_filename;
664 if ((err==UNZ_OK) && (szFileName!=NULL)) 664 if ((err==UNZ_OK) && (szFileName!=NULL))
665 { 665 {
666 uLong uSizeRead ; 666 uLong uSizeRead ;
667 if (file_info.size_filename<fileNameBufferSize) 667 if (file_info.size_filename<fileNameBufferSize)
668 { 668 {
669 *(szFileName+file_info.size_filename)='\0'; 669 *(szFileName+file_info.size_filename)='\0';
670 uSizeRead = file_info.size_filename; 670 uSizeRead = file_info.size_filename;
671 } 671 }
672 else 672 else
673 uSizeRead = fileNameBufferSize; 673 uSizeRead = fileNameBufferSize;
674 674
675 if ((file_info.size_filename>0) && (fileNameBufferSize>0)) 675 if ((file_info.size_filename>0) && (fileNameBufferSize>0))
676 if (ZREAD(s->z_filefunc, s->filestream,szFileName,uSizeRead)!=uSizeRead) 676 if (ZREAD(s->z_filefunc, s->filestream,szFileName,uSizeRead)!=uSizeRead)
677 err=UNZ_ERRNO; 677 err=UNZ_ERRNO;
678 lSeek -= uSizeRead; 678 lSeek -= uSizeRead;
679 } 679 }
680 680
681 681
682 if ((err==UNZ_OK) && (extraField!=NULL)) 682 if ((err==UNZ_OK) && (extraField!=NULL))
683 { 683 {
684 uLong uSizeRead ; 684 uLong uSizeRead ;
685 if (file_info.size_file_extra<extraFieldBufferSize) 685 if (file_info.size_file_extra<extraFieldBufferSize)
686 uSizeRead = file_info.size_file_extra; 686 uSizeRead = file_info.size_file_extra;
687 else 687 else
688 uSizeRead = extraFieldBufferSize; 688 uSizeRead = extraFieldBufferSize;
689 689
690 if (lSeek!=0) 690 if (lSeek!=0)
691 if (ZSEEK(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0) 691 if (ZSEEK(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
692 lSeek=0; 692 lSeek=0;
693 else 693 else
694 err=UNZ_ERRNO; 694 err=UNZ_ERRNO;
695 if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0)) 695 if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0))
696 if (ZREAD(s->z_filefunc, s->filestream,extraField,uSizeRead)!=uSizeRead) 696 if (ZREAD(s->z_filefunc, s->filestream,extraField,uSizeRead)!=uSizeRead)
697 err=UNZ_ERRNO; 697 err=UNZ_ERRNO;
698 lSeek += file_info.size_file_extra - uSizeRead; 698 lSeek += file_info.size_file_extra - uSizeRead;
699 } 699 }
700 else 700 else
701 lSeek+=file_info.size_file_extra; 701 lSeek+=file_info.size_file_extra;
702 702
703 703
704 if ((err==UNZ_OK) && (szComment!=NULL)) 704 if ((err==UNZ_OK) && (szComment!=NULL))
705 { 705 {
706 uLong uSizeRead ; 706 uLong uSizeRead ;
707 if (file_info.size_file_comment<commentBufferSize) 707 if (file_info.size_file_comment<commentBufferSize)
708 { 708 {
709 *(szComment+file_info.size_file_comment)='\0'; 709 *(szComment+file_info.size_file_comment)='\0';
710 uSizeRead = file_info.size_file_comment; 710 uSizeRead = file_info.size_file_comment;
711 } 711 }
712 else 712 else
713 uSizeRead = commentBufferSize; 713 uSizeRead = commentBufferSize;
714 714
715 if (lSeek!=0) 715 if (lSeek!=0)
716 if (ZSEEK(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0) 716 if (ZSEEK(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
717 lSeek=0; 717 lSeek=0;
718 else 718 else
719 err=UNZ_ERRNO; 719 err=UNZ_ERRNO;
720 if ((file_info.size_file_comment>0) && (commentBufferSize>0)) 720 if ((file_info.size_file_comment>0) && (commentBufferSize>0))
721 if (ZREAD(s->z_filefunc, s->filestream,szComment,uSizeRead)!=uSizeRead) 721 if (ZREAD(s->z_filefunc, s->filestream,szComment,uSizeRead)!=uSizeRead)
722 err=UNZ_ERRNO; 722 err=UNZ_ERRNO;
723 lSeek+=file_info.size_file_comment - uSizeRead; 723 lSeek+=file_info.size_file_comment - uSizeRead;
724 } 724 }
725 else 725 else
726 lSeek+=file_info.size_file_comment; 726 lSeek+=file_info.size_file_comment;
727 727
728 if ((err==UNZ_OK) && (pfile_info!=NULL)) 728 if ((err==UNZ_OK) && (pfile_info!=NULL))
729 *pfile_info=file_info; 729 *pfile_info=file_info;
730 730
731 if ((err==UNZ_OK) && (pfile_info_internal!=NULL)) 731 if ((err==UNZ_OK) && (pfile_info_internal!=NULL))
732 *pfile_info_internal=file_info_internal; 732 *pfile_info_internal=file_info_internal;
733 733
734 return err; 734 return err;
735} 735}
736 736
737 737
738 738
739/* 739/*
740 Write info about the ZipFile in the *pglobal_info structure. 740 Write info about the ZipFile in the *pglobal_info structure.
741 No preparation of the structure is needed 741 No preparation of the structure is needed
742 return UNZ_OK if there is no problem. 742 return UNZ_OK if there is no problem.
743*/ 743*/
744extern int ZEXPORT unzGetCurrentFileInfo (file, 744extern int ZEXPORT unzGetCurrentFileInfo (file,
745 pfile_info, 745 pfile_info,
746 szFileName, fileNameBufferSize, 746 szFileName, fileNameBufferSize,
747 extraField, extraFieldBufferSize, 747 extraField, extraFieldBufferSize,
748 szComment, commentBufferSize) 748 szComment, commentBufferSize)
749 unzFile file; 749 unzFile file;
750 unz_file_info *pfile_info; 750 unz_file_info *pfile_info;
751 char *szFileName; 751 char *szFileName;
752 uLong fileNameBufferSize; 752 uLong fileNameBufferSize;
753 void *extraField; 753 void *extraField;
754 uLong extraFieldBufferSize; 754 uLong extraFieldBufferSize;
755 char *szComment; 755 char *szComment;
756 uLong commentBufferSize; 756 uLong commentBufferSize;
757{ 757{
758 return unzlocal_GetCurrentFileInfoInternal(file,pfile_info,NULL, 758 return unzlocal_GetCurrentFileInfoInternal(file,pfile_info,NULL,
759 szFileName,fileNameBufferSize, 759 szFileName,fileNameBufferSize,
760 extraField,extraFieldBufferSize, 760 extraField,extraFieldBufferSize,
761 szComment,commentBufferSize); 761 szComment,commentBufferSize);
762} 762}
763 763
764/* 764/*
765 Set the current file of the zipfile to the first file. 765 Set the current file of the zipfile to the first file.
766 return UNZ_OK if there is no problem 766 return UNZ_OK if there is no problem
767*/ 767*/
768extern int ZEXPORT unzGoToFirstFile (file) 768extern int ZEXPORT unzGoToFirstFile (file)
769 unzFile file; 769 unzFile file;
770{ 770{
771 int err=UNZ_OK; 771 int err=UNZ_OK;
772 unz_s* s; 772 unz_s* s;
773 if (file==NULL) 773 if (file==NULL)
774 return UNZ_PARAMERROR; 774 return UNZ_PARAMERROR;
775 s=(unz_s*)file; 775 s=(unz_s*)file;
776 s->pos_in_central_dir=s->offset_central_dir; 776 s->pos_in_central_dir=s->offset_central_dir;
777 s->num_file=0; 777 s->num_file=0;
778 err=unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info, 778 err=unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
779 &s->cur_file_info_internal, 779 &s->cur_file_info_internal,
780 NULL,0,NULL,0,NULL,0); 780 NULL,0,NULL,0,NULL,0);
781 s->current_file_ok = (err == UNZ_OK); 781 s->current_file_ok = (err == UNZ_OK);
782 return err; 782 return err;
783} 783}
784 784
785/* 785/*
786 Set the current file of the zipfile to the next file. 786 Set the current file of the zipfile to the next file.
787 return UNZ_OK if there is no problem 787 return UNZ_OK if there is no problem
788 return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest. 788 return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
789*/ 789*/
790extern int ZEXPORT unzGoToNextFile (file) 790extern int ZEXPORT unzGoToNextFile (file)
791 unzFile file; 791 unzFile file;
792{ 792{
793 unz_s* s; 793 unz_s* s;
794 int err; 794 int err;
795 795
796 if (file==NULL) 796 if (file==NULL)
797 return UNZ_PARAMERROR; 797 return UNZ_PARAMERROR;
798 s=(unz_s*)file; 798 s=(unz_s*)file;
799 if (!s->current_file_ok) 799 if (!s->current_file_ok)
800 return UNZ_END_OF_LIST_OF_FILE; 800 return UNZ_END_OF_LIST_OF_FILE;
801 if (s->num_file+1==s->gi.number_entry) 801 if (s->num_file+1==s->gi.number_entry)
802 return UNZ_END_OF_LIST_OF_FILE; 802 return UNZ_END_OF_LIST_OF_FILE;
803 803
804 s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename + 804 s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +
805 s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ; 805 s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ;
806 s->num_file++; 806 s->num_file++;
807 err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info, 807 err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
808 &s->cur_file_info_internal, 808 &s->cur_file_info_internal,
809 NULL,0,NULL,0,NULL,0); 809 NULL,0,NULL,0,NULL,0);
810 s->current_file_ok = (err == UNZ_OK); 810 s->current_file_ok = (err == UNZ_OK);
811 return err; 811 return err;
812} 812}
813 813
814 814
815/* 815/*
816 Try locate the file szFileName in the zipfile. 816 Try locate the file szFileName in the zipfile.
817 For the iCaseSensitivity signification, see unzipStringFileNameCompare 817 For the iCaseSensitivity signification, see unzipStringFileNameCompare
818 818
819 return value : 819 return value :
820 UNZ_OK if the file is found. It becomes the current file. 820 UNZ_OK if the file is found. It becomes the current file.
821 UNZ_END_OF_LIST_OF_FILE if the file is not found 821 UNZ_END_OF_LIST_OF_FILE if the file is not found
822*/ 822*/
823extern int ZEXPORT unzLocateFile (file, szFileName, iCaseSensitivity) 823extern int ZEXPORT unzLocateFile (file, szFileName, iCaseSensitivity)
824 unzFile file; 824 unzFile file;
825 const char *szFileName; 825 const char *szFileName;
826 int iCaseSensitivity; 826 int iCaseSensitivity;
827{ 827{
828 unz_s* s; 828 unz_s* s;
829 int err; 829 int err;
830 830
831 /* We remember the 'current' position in the file so that we can jump 831 /* We remember the 'current' position in the file so that we can jump
832 * back there if we fail. 832 * back there if we fail.
833 */ 833 */
834 unz_file_info cur_file_infoSaved; 834 unz_file_info cur_file_infoSaved;
835 unz_file_info_internal cur_file_info_internalSaved; 835 unz_file_info_internal cur_file_info_internalSaved;
836 uLong num_fileSaved; 836 uLong num_fileSaved;
837 uLong pos_in_central_dirSaved; 837 uLong pos_in_central_dirSaved;
838 838
839 839
840 if (file==NULL) 840 if (file==NULL)
841 return UNZ_PARAMERROR; 841 return UNZ_PARAMERROR;
842 842
843 if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP) 843 if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP)
844 return UNZ_PARAMERROR; 844 return UNZ_PARAMERROR;
845 845
846 s=(unz_s*)file; 846 s=(unz_s*)file;
847 if (!s->current_file_ok) 847 if (!s->current_file_ok)
848 return UNZ_END_OF_LIST_OF_FILE; 848 return UNZ_END_OF_LIST_OF_FILE;
849 849
850 /* Save the current state */ 850 /* Save the current state */
851 num_fileSaved = s->num_file; 851 num_fileSaved = s->num_file;
852 pos_in_central_dirSaved = s->pos_in_central_dir; 852 pos_in_central_dirSaved = s->pos_in_central_dir;
853 cur_file_infoSaved = s->cur_file_info; 853 cur_file_infoSaved = s->cur_file_info;
854 cur_file_info_internalSaved = s->cur_file_info_internal; 854 cur_file_info_internalSaved = s->cur_file_info_internal;
855 855
856 err = unzGoToFirstFile(file); 856 err = unzGoToFirstFile(file);
857 857
858 while (err == UNZ_OK) 858 while (err == UNZ_OK)
859 { 859 {
860 char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1]; 860 char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1];
861 err = unzGetCurrentFileInfo(file,NULL, 861 err = unzGetCurrentFileInfo(file,NULL,
862 szCurrentFileName,sizeof(szCurrentFileName)-1, 862 szCurrentFileName,sizeof(szCurrentFileName)-1,
863 NULL,0,NULL,0); 863 NULL,0,NULL,0);
864 if (err == UNZ_OK) 864 if (err == UNZ_OK)
865 { 865 {
866 if (unzStringFileNameCompare(szCurrentFileName, 866 if (unzStringFileNameCompare(szCurrentFileName,
867 szFileName,iCaseSensitivity)==0) 867 szFileName,iCaseSensitivity)==0)
868 return UNZ_OK; 868 return UNZ_OK;
869 err = unzGoToNextFile(file); 869 err = unzGoToNextFile(file);
870 } 870 }
871 } 871 }
872 872
873 /* We failed, so restore the state of the 'current file' to where we 873 /* We failed, so restore the state of the 'current file' to where we
874 * were. 874 * were.
875 */ 875 */
876 s->num_file = num_fileSaved ; 876 s->num_file = num_fileSaved ;
877 s->pos_in_central_dir = pos_in_central_dirSaved ; 877 s->pos_in_central_dir = pos_in_central_dirSaved ;
878 s->cur_file_info = cur_file_infoSaved; 878 s->cur_file_info = cur_file_infoSaved;
879 s->cur_file_info_internal = cur_file_info_internalSaved; 879 s->cur_file_info_internal = cur_file_info_internalSaved;
880 return err; 880 return err;
881} 881}
882 882
883 883
884/* 884/*
885/////////////////////////////////////////// 885///////////////////////////////////////////
886// Contributed by Ryan Haksi (mailto://cryogen@infoserve.net) 886// Contributed by Ryan Haksi (mailto://cryogen@infoserve.net)
887// I need random access 887// I need random access
888// 888//
889// Further optimization could be realized by adding an ability 889// Further optimization could be realized by adding an ability
890// to cache the directory in memory. The goal being a single 890// to cache the directory in memory. The goal being a single
891// comprehensive file read to put the file I need in a memory. 891// comprehensive file read to put the file I need in a memory.
892*/ 892*/
893 893
894/* 894/*
895typedef struct unz_file_pos_s 895typedef struct unz_file_pos_s
896{ 896{
897 uLong pos_in_zip_directory; // offset in file 897 uLong pos_in_zip_directory; // offset in file
898 uLong num_of_file; // # of file 898 uLong num_of_file; // # of file
899} unz_file_pos; 899} unz_file_pos;
900*/ 900*/
901 901
902extern int ZEXPORT unzGetFilePos(file, file_pos) 902extern int ZEXPORT unzGetFilePos(file, file_pos)
903 unzFile file; 903 unzFile file;
904 unz_file_pos* file_pos; 904 unz_file_pos* file_pos;
905{ 905{
906 unz_s* s; 906 unz_s* s;
907 907
908 if (file==NULL || file_pos==NULL) 908 if (file==NULL || file_pos==NULL)
909 return UNZ_PARAMERROR; 909 return UNZ_PARAMERROR;
910 s=(unz_s*)file; 910 s=(unz_s*)file;
911 if (!s->current_file_ok) 911 if (!s->current_file_ok)
912 return UNZ_END_OF_LIST_OF_FILE; 912 return UNZ_END_OF_LIST_OF_FILE;
913 913
914 file_pos->pos_in_zip_directory = s->pos_in_central_dir; 914 file_pos->pos_in_zip_directory = s->pos_in_central_dir;
915 file_pos->num_of_file = s->num_file; 915 file_pos->num_of_file = s->num_file;
916 916
917 return UNZ_OK; 917 return UNZ_OK;
918} 918}
919 919
920extern int ZEXPORT unzGoToFilePos(file, file_pos) 920extern int ZEXPORT unzGoToFilePos(file, file_pos)
921 unzFile file; 921 unzFile file;
922 unz_file_pos* file_pos; 922 unz_file_pos* file_pos;
923{ 923{
924 unz_s* s; 924 unz_s* s;
925 int err; 925 int err;
926 926
927 if (file==NULL || file_pos==NULL) 927 if (file==NULL || file_pos==NULL)
928 return UNZ_PARAMERROR; 928 return UNZ_PARAMERROR;
929 s=(unz_s*)file; 929 s=(unz_s*)file;
930 930
931 /* jump to the right spot */ 931 /* jump to the right spot */
932 s->pos_in_central_dir = file_pos->pos_in_zip_directory; 932 s->pos_in_central_dir = file_pos->pos_in_zip_directory;
933 s->num_file = file_pos->num_of_file; 933 s->num_file = file_pos->num_of_file;
934 934
935 /* set the current file */ 935 /* set the current file */
936 err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info, 936 err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
937 &s->cur_file_info_internal, 937 &s->cur_file_info_internal,
938 NULL,0,NULL,0,NULL,0); 938 NULL,0,NULL,0,NULL,0);
939 /* return results */ 939 /* return results */
940 s->current_file_ok = (err == UNZ_OK); 940 s->current_file_ok = (err == UNZ_OK);
941 return err; 941 return err;
942} 942}
943 943
944/* 944/*
945// Unzip Helper Functions - should be here? 945// Unzip Helper Functions - should be here?
946/////////////////////////////////////////// 946///////////////////////////////////////////
947*/ 947*/
948 948
949/* 949/*
950 Read the local header of the current zipfile 950 Read the local header of the current zipfile
951 Check the coherency of the local header and info in the end of central 951 Check the coherency of the local header and info in the end of central
952 directory about this file 952 directory about this file
953 store in *piSizeVar the size of extra info in local header 953 store in *piSizeVar the size of extra info in local header
954 (filename and size of extra field data) 954 (filename and size of extra field data)
955*/ 955*/
956local int unzlocal_CheckCurrentFileCoherencyHeader (s,piSizeVar, 956local int unzlocal_CheckCurrentFileCoherencyHeader (s,piSizeVar,
957 poffset_local_extrafield, 957 poffset_local_extrafield,
958 psize_local_extrafield) 958 psize_local_extrafield)
959 unz_s* s; 959 unz_s* s;
960 uInt* piSizeVar; 960 uInt* piSizeVar;
961 uLong *poffset_local_extrafield; 961 uLong *poffset_local_extrafield;
962 uInt *psize_local_extrafield; 962 uInt *psize_local_extrafield;
963{ 963{
964 uLong uMagic,uData,uFlags; 964 uLong uMagic,uData,uFlags;
965 uLong size_filename; 965 uLong size_filename;
966 uLong size_extra_field; 966 uLong size_extra_field;
967 int err=UNZ_OK; 967 int err=UNZ_OK;
968 968
969 *piSizeVar = 0; 969 *piSizeVar = 0;
970 *poffset_local_extrafield = 0; 970 *poffset_local_extrafield = 0;
971 *psize_local_extrafield = 0; 971 *psize_local_extrafield = 0;
972 972
973 if (ZSEEK(s->z_filefunc, s->filestream,s->cur_file_info_internal.offset_curfile + 973 if (ZSEEK(s->z_filefunc, s->filestream,s->cur_file_info_internal.offset_curfile +
974 s->byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0) 974 s->byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0)
975 return UNZ_ERRNO; 975 return UNZ_ERRNO;
976 976
977 977
978 if (err==UNZ_OK) 978 if (err==UNZ_OK)
979 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK) 979 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)
980 err=UNZ_ERRNO; 980 err=UNZ_ERRNO;
981 else if (uMagic!=0x04034b50) 981 else if (uMagic!=0x04034b50)
982 err=UNZ_BADZIPFILE; 982 err=UNZ_BADZIPFILE;
983 983
984 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) 984 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
985 err=UNZ_ERRNO; 985 err=UNZ_ERRNO;
986/* 986/*
987 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion)) 987 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
988 err=UNZ_BADZIPFILE; 988 err=UNZ_BADZIPFILE;
989*/ 989*/
990 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uFlags) != UNZ_OK) 990 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uFlags) != UNZ_OK)
991 err=UNZ_ERRNO; 991 err=UNZ_ERRNO;
992 992
993 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) 993 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
994 err=UNZ_ERRNO; 994 err=UNZ_ERRNO;
995 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method)) 995 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method))
996 err=UNZ_BADZIPFILE; 996 err=UNZ_BADZIPFILE;
997 997
998 if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) && 998 if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) &&
999 (s->cur_file_info.compression_method!=Z_DEFLATED)) 999 (s->cur_file_info.compression_method!=Z_DEFLATED))
1000 err=UNZ_BADZIPFILE; 1000 err=UNZ_BADZIPFILE;
1001 1001
1002 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* date/time */ 1002 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* date/time */
1003 err=UNZ_ERRNO; 1003 err=UNZ_ERRNO;
1004 1004
1005 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* crc */ 1005 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* crc */
1006 err=UNZ_ERRNO; 1006 err=UNZ_ERRNO;
1007 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) && 1007 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) &&
1008 ((uFlags & 8)==0)) 1008 ((uFlags & 8)==0))
1009 err=UNZ_BADZIPFILE; 1009 err=UNZ_BADZIPFILE;
1010 1010
1011 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size compr */ 1011 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size compr */
1012 err=UNZ_ERRNO; 1012 err=UNZ_ERRNO;
1013 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) && 1013 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) &&
1014 ((uFlags & 8)==0)) 1014 ((uFlags & 8)==0))
1015 err=UNZ_BADZIPFILE; 1015 err=UNZ_BADZIPFILE;
1016 1016
1017 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size uncompr */ 1017 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size uncompr */
1018 err=UNZ_ERRNO; 1018 err=UNZ_ERRNO;
1019 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) && 1019 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) &&
1020 ((uFlags & 8)==0)) 1020 ((uFlags & 8)==0))
1021 err=UNZ_BADZIPFILE; 1021 err=UNZ_BADZIPFILE;
1022 1022
1023 1023
1024 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&size_filename) != UNZ_OK) 1024 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&size_filename) != UNZ_OK)
1025 err=UNZ_ERRNO; 1025 err=UNZ_ERRNO;
1026 else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename)) 1026 else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename))
1027 err=UNZ_BADZIPFILE; 1027 err=UNZ_BADZIPFILE;
1028 1028
1029 *piSizeVar += (uInt)size_filename; 1029 *piSizeVar += (uInt)size_filename;
1030 1030
1031 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&size_extra_field) != UNZ_OK) 1031 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&size_extra_field) != UNZ_OK)
1032 err=UNZ_ERRNO; 1032 err=UNZ_ERRNO;
1033 *poffset_local_extrafield= s->cur_file_info_internal.offset_curfile + 1033 *poffset_local_extrafield= s->cur_file_info_internal.offset_curfile +
1034 SIZEZIPLOCALHEADER + size_filename; 1034 SIZEZIPLOCALHEADER + size_filename;
1035 *psize_local_extrafield = (uInt)size_extra_field; 1035 *psize_local_extrafield = (uInt)size_extra_field;
1036 1036
1037 *piSizeVar += (uInt)size_extra_field; 1037 *piSizeVar += (uInt)size_extra_field;
1038 1038
1039 return err; 1039 return err;
1040} 1040}
1041 1041
1042/* 1042/*
1043 Open for reading data the current file in the zipfile. 1043 Open for reading data the current file in the zipfile.
1044 If there is no error and the file is opened, the return value is UNZ_OK. 1044 If there is no error and the file is opened, the return value is UNZ_OK.
1045*/ 1045*/
1046extern int ZEXPORT unzOpenCurrentFile3 (file, method, level, raw, password) 1046extern int ZEXPORT unzOpenCurrentFile3 (file, method, level, raw, password)
1047 unzFile file; 1047 unzFile file;
1048 int* method; 1048 int* method;
1049 int* level; 1049 int* level;
1050 int raw; 1050 int raw;
1051 const char* password; 1051 const char* password;
1052{ 1052{
1053 int err=UNZ_OK; 1053 int err=UNZ_OK;
1054 uInt iSizeVar; 1054 uInt iSizeVar;
1055 unz_s* s; 1055 unz_s* s;
1056 file_in_zip_read_info_s* pfile_in_zip_read_info; 1056 file_in_zip_read_info_s* pfile_in_zip_read_info;
1057 uLong offset_local_extrafield; /* offset of the local extra field */ 1057 uLong offset_local_extrafield; /* offset of the local extra field */
1058 uInt size_local_extrafield; /* size of the local extra field */ 1058 uInt size_local_extrafield; /* size of the local extra field */
1059 #ifndef NOUNCRYPT 1059# ifndef NOUNCRYPT
1060 char source[12]; 1060 char source[12];
1061 #else 1061# else
1062 if (password != NULL) 1062 if (password != NULL)
1063 return UNZ_PARAMERROR; 1063 return UNZ_PARAMERROR;
1064 #endif 1064# endif
1065 1065
1066 if (file==NULL) 1066 if (file==NULL)
1067 return UNZ_PARAMERROR; 1067 return UNZ_PARAMERROR;
1068 s=(unz_s*)file; 1068 s=(unz_s*)file;
1069 if (!s->current_file_ok) 1069 if (!s->current_file_ok)
1070 return UNZ_PARAMERROR; 1070 return UNZ_PARAMERROR;
1071 1071
1072 if (s->pfile_in_zip_read != NULL) 1072 if (s->pfile_in_zip_read != NULL)
1073 unzCloseCurrentFile(file); 1073 unzCloseCurrentFile(file);
1074 1074
1075 if (unzlocal_CheckCurrentFileCoherencyHeader(s,&iSizeVar, 1075 if (unzlocal_CheckCurrentFileCoherencyHeader(s,&iSizeVar,
1076 &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK) 1076 &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK)
1077 return UNZ_BADZIPFILE; 1077 return UNZ_BADZIPFILE;
1078 1078
1079 pfile_in_zip_read_info = (file_in_zip_read_info_s*) 1079 pfile_in_zip_read_info = (file_in_zip_read_info_s*)
1080 ALLOC(sizeof(file_in_zip_read_info_s)); 1080 ALLOC(sizeof(file_in_zip_read_info_s));
1081 if (pfile_in_zip_read_info==NULL) 1081 if (pfile_in_zip_read_info==NULL)
1082 return UNZ_INTERNALERROR; 1082 return UNZ_INTERNALERROR;
1083 1083
1084 pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE); 1084 pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE);
1085 pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield; 1085 pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;
1086 pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield; 1086 pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
1087 pfile_in_zip_read_info->pos_local_extrafield=0; 1087 pfile_in_zip_read_info->pos_local_extrafield=0;
1088 pfile_in_zip_read_info->raw=raw; 1088 pfile_in_zip_read_info->raw=raw;
1089 1089
1090 if (pfile_in_zip_read_info->read_buffer==NULL) 1090 if (pfile_in_zip_read_info->read_buffer==NULL)
1091 { 1091 {
1092 TRYFREE(pfile_in_zip_read_info); 1092 TRYFREE(pfile_in_zip_read_info);
1093 return UNZ_INTERNALERROR; 1093 return UNZ_INTERNALERROR;
1094 } 1094 }
1095 1095
1096 pfile_in_zip_read_info->stream_initialised=0; 1096 pfile_in_zip_read_info->stream_initialised=0;
1097 1097
1098 if (method!=NULL) 1098 if (method!=NULL)
1099 *method = (int)s->cur_file_info.compression_method; 1099 *method = (int)s->cur_file_info.compression_method;
1100 1100
1101 if (level!=NULL) 1101 if (level!=NULL)
1102 { 1102 {
1103 *level = 6; 1103 *level = 6;
1104 switch (s->cur_file_info.flag & 0x06) 1104 switch (s->cur_file_info.flag & 0x06)
1105 { 1105 {
1106 case 6 : *level = 1; break; 1106 case 6 : *level = 1; break;
1107 case 4 : *level = 2; break; 1107 case 4 : *level = 2; break;
1108 case 2 : *level = 9; break; 1108 case 2 : *level = 9; break;
1109 } 1109 }
1110 } 1110 }
1111 1111
1112 if ((s->cur_file_info.compression_method!=0) && 1112 if ((s->cur_file_info.compression_method!=0) &&
1113 (s->cur_file_info.compression_method!=Z_DEFLATED)) 1113 (s->cur_file_info.compression_method!=Z_DEFLATED))
1114 err=UNZ_BADZIPFILE; 1114 err=UNZ_BADZIPFILE;
1115 1115
1116 pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc; 1116 pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc;
1117 pfile_in_zip_read_info->crc32=0; 1117 pfile_in_zip_read_info->crc32=0;
1118 pfile_in_zip_read_info->compression_method = 1118 pfile_in_zip_read_info->compression_method =
1119 s->cur_file_info.compression_method; 1119 s->cur_file_info.compression_method;
1120 pfile_in_zip_read_info->filestream=s->filestream; 1120 pfile_in_zip_read_info->filestream=s->filestream;
1121 pfile_in_zip_read_info->z_filefunc=s->z_filefunc; 1121 pfile_in_zip_read_info->z_filefunc=s->z_filefunc;
1122 pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile; 1122 pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile;
1123 1123
1124 pfile_in_zip_read_info->stream.total_out = 0; 1124 pfile_in_zip_read_info->stream.total_out = 0;
1125 1125
1126 if ((s->cur_file_info.compression_method==Z_DEFLATED) && 1126 if ((s->cur_file_info.compression_method==Z_DEFLATED) &&
1127 (!raw)) 1127 (!raw))
1128 { 1128 {
1129 pfile_in_zip_read_info->stream.zalloc = (alloc_func)0; 1129 pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
1130 pfile_in_zip_read_info->stream.zfree = (free_func)0; 1130 pfile_in_zip_read_info->stream.zfree = (free_func)0;
1131 pfile_in_zip_read_info->stream.opaque = (voidpf)0; 1131 pfile_in_zip_read_info->stream.opaque = (voidpf)0;
1132 pfile_in_zip_read_info->stream.next_in = (voidpf)0; 1132 pfile_in_zip_read_info->stream.next_in = (voidpf)0;
1133 pfile_in_zip_read_info->stream.avail_in = 0; 1133 pfile_in_zip_read_info->stream.avail_in = 0;
1134 1134
1135 err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS); 1135 err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);
1136 if (err == Z_OK) 1136 if (err == Z_OK)
1137 pfile_in_zip_read_info->stream_initialised=1; 1137 pfile_in_zip_read_info->stream_initialised=1;
1138 else 1138 else
1139 return err; 1139 return err;
1140 /* windowBits is passed < 0 to tell that there is no zlib header. 1140 /* windowBits is passed < 0 to tell that there is no zlib header.
1141 * Note that in this case inflate *requires* an extra "dummy" byte 1141 * Note that in this case inflate *requires* an extra "dummy" byte
1142 * after the compressed stream in order to complete decompression and 1142 * after the compressed stream in order to complete decompression and
1143 * return Z_STREAM_END. 1143 * return Z_STREAM_END.
1144 * In unzip, i don't wait absolutely Z_STREAM_END because I known the 1144 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
1145 * size of both compressed and uncompressed data 1145 * size of both compressed and uncompressed data
1146 */ 1146 */
1147 } 1147 }
1148 pfile_in_zip_read_info->rest_read_compressed = 1148 pfile_in_zip_read_info->rest_read_compressed =
1149 s->cur_file_info.compressed_size ; 1149 s->cur_file_info.compressed_size ;
1150 pfile_in_zip_read_info->rest_read_uncompressed = 1150 pfile_in_zip_read_info->rest_read_uncompressed =
1151 s->cur_file_info.uncompressed_size ; 1151 s->cur_file_info.uncompressed_size ;
1152 1152
1153 1153
1154 pfile_in_zip_read_info->pos_in_zipfile = 1154 pfile_in_zip_read_info->pos_in_zipfile =
1155 s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER + 1155 s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER +
1156 iSizeVar; 1156 iSizeVar;
1157 1157
1158 pfile_in_zip_read_info->stream.avail_in = (uInt)0; 1158 pfile_in_zip_read_info->stream.avail_in = (uInt)0;
1159 1159
1160 s->pfile_in_zip_read = pfile_in_zip_read_info; 1160 s->pfile_in_zip_read = pfile_in_zip_read_info;
1161 1161
1162 #ifndef NOUNCRYPT 1162# ifndef NOUNCRYPT
1163 if (password != NULL) 1163 if (password != NULL)
1164 { 1164 {
1165 int i; 1165 int i;
1166 s->pcrc_32_tab = get_crc_table(); 1166 s->pcrc_32_tab = get_crc_table();
1167 init_keys(password,s->keys,s->pcrc_32_tab); 1167 init_keys(password,s->keys,s->pcrc_32_tab);
1168 if (ZSEEK(s->z_filefunc, s->filestream, 1168 if (ZSEEK(s->z_filefunc, s->filestream,
1169 s->pfile_in_zip_read->pos_in_zipfile + 1169 s->pfile_in_zip_read->pos_in_zipfile +
1170 s->pfile_in_zip_read->byte_before_the_zipfile, 1170 s->pfile_in_zip_read->byte_before_the_zipfile,
1171 SEEK_SET)!=0) 1171 SEEK_SET)!=0)
1172 return UNZ_INTERNALERROR; 1172 return UNZ_INTERNALERROR;
1173 if(ZREAD(s->z_filefunc, s->filestream,source, 12)<12) 1173 if(ZREAD(s->z_filefunc, s->filestream,source, 12)<12)
1174 return UNZ_INTERNALERROR; 1174 return UNZ_INTERNALERROR;
1175 1175
1176 for (i = 0; i<12; i++) 1176 for (i = 0; i<12; i++)
1177 zdecode(s->keys,s->pcrc_32_tab,source[i]); 1177 zdecode(s->keys,s->pcrc_32_tab,source[i]);
1178 1178
1179 s->pfile_in_zip_read->pos_in_zipfile+=12; 1179 s->pfile_in_zip_read->pos_in_zipfile+=12;
1180 s->encrypted=1; 1180 s->encrypted=1;
1181 } 1181 }
1182 #endif 1182# endif
1183 1183
1184 1184
1185 return UNZ_OK; 1185 return UNZ_OK;
1186} 1186}
1187 1187
1188extern int ZEXPORT unzOpenCurrentFile (file) 1188extern int ZEXPORT unzOpenCurrentFile (file)
1189 unzFile file; 1189 unzFile file;
1190{ 1190{
1191 return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL); 1191 return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL);
1192} 1192}
1193 1193
1194extern int ZEXPORT unzOpenCurrentFilePassword (file, password) 1194extern int ZEXPORT unzOpenCurrentFilePassword (file, password)
1195 unzFile file; 1195 unzFile file;
1196 const char* password; 1196 const char* password;
1197{ 1197{
1198 return unzOpenCurrentFile3(file, NULL, NULL, 0, password); 1198 return unzOpenCurrentFile3(file, NULL, NULL, 0, password);
1199} 1199}
1200 1200
1201extern int ZEXPORT unzOpenCurrentFile2 (file,method,level,raw) 1201extern int ZEXPORT unzOpenCurrentFile2 (file,method,level,raw)
1202 unzFile file; 1202 unzFile file;
1203 int* method; 1203 int* method;
1204 int* level; 1204 int* level;
1205 int raw; 1205 int raw;
1206{ 1206{
1207 return unzOpenCurrentFile3(file, method, level, raw, NULL); 1207 return unzOpenCurrentFile3(file, method, level, raw, NULL);
1208} 1208}
1209 1209
1210/* 1210/*
1211 Read bytes from the current file. 1211 Read bytes from the current file.
1212 buf contain buffer where data must be copied 1212 buf contain buffer where data must be copied
1213 len the size of buf. 1213 len the size of buf.
1214 1214
1215 return the number of byte copied if somes bytes are copied 1215 return the number of byte copied if somes bytes are copied
1216 return 0 if the end of file was reached 1216 return 0 if the end of file was reached
1217 return <0 with error code if there is an error 1217 return <0 with error code if there is an error
1218 (UNZ_ERRNO for IO error, or zLib error for uncompress error) 1218 (UNZ_ERRNO for IO error, or zLib error for uncompress error)
1219*/ 1219*/
1220extern int ZEXPORT unzReadCurrentFile (file, buf, len) 1220extern int ZEXPORT unzReadCurrentFile (file, buf, len)
1221 unzFile file; 1221 unzFile file;
1222 voidp buf; 1222 voidp buf;
1223 unsigned len; 1223 unsigned len;
1224{ 1224{
1225 int err=UNZ_OK; 1225 int err=UNZ_OK;
1226 uInt iRead = 0; 1226 uInt iRead = 0;
1227 unz_s* s; 1227 unz_s* s;
1228 file_in_zip_read_info_s* pfile_in_zip_read_info; 1228 file_in_zip_read_info_s* pfile_in_zip_read_info;
1229 if (file==NULL) 1229 if (file==NULL)
1230 return UNZ_PARAMERROR; 1230 return UNZ_PARAMERROR;
1231 s=(unz_s*)file; 1231 s=(unz_s*)file;
1232 pfile_in_zip_read_info=s->pfile_in_zip_read; 1232 pfile_in_zip_read_info=s->pfile_in_zip_read;
1233 1233
1234 if (pfile_in_zip_read_info==NULL) 1234 if (pfile_in_zip_read_info==NULL)
1235 return UNZ_PARAMERROR; 1235 return UNZ_PARAMERROR;
1236 1236
1237 1237
1238 if ((pfile_in_zip_read_info->read_buffer == NULL)) 1238 if ((pfile_in_zip_read_info->read_buffer == NULL))
1239 return UNZ_END_OF_LIST_OF_FILE; 1239 return UNZ_END_OF_LIST_OF_FILE;
1240 if (len==0) 1240 if (len==0)
1241 return 0; 1241 return 0;
1242 1242
1243 pfile_in_zip_read_info->stream.next_out = (Bytef*)buf; 1243 pfile_in_zip_read_info->stream.next_out = (Bytef*)buf;
1244 1244
1245 pfile_in_zip_read_info->stream.avail_out = (uInt)len; 1245 pfile_in_zip_read_info->stream.avail_out = (uInt)len;
1246 1246
1247 if (len>pfile_in_zip_read_info->rest_read_uncompressed) 1247 if (len>pfile_in_zip_read_info->rest_read_uncompressed)
1248 pfile_in_zip_read_info->stream.avail_out = 1248 pfile_in_zip_read_info->stream.avail_out =
1249 (uInt)pfile_in_zip_read_info->rest_read_uncompressed; 1249 (uInt)pfile_in_zip_read_info->rest_read_uncompressed;
1250 1250
1251 while (pfile_in_zip_read_info->stream.avail_out>0) 1251 while (pfile_in_zip_read_info->stream.avail_out>0)
1252 { 1252 {
1253 if ((pfile_in_zip_read_info->stream.avail_in==0) && 1253 if ((pfile_in_zip_read_info->stream.avail_in==0) &&
1254 (pfile_in_zip_read_info->rest_read_compressed>0)) 1254 (pfile_in_zip_read_info->rest_read_compressed>0))
1255 { 1255 {
1256 uInt uReadThis = UNZ_BUFSIZE; 1256 uInt uReadThis = UNZ_BUFSIZE;
1257 if (pfile_in_zip_read_info->rest_read_compressed<uReadThis) 1257 if (pfile_in_zip_read_info->rest_read_compressed<uReadThis)
1258 uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed; 1258 uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed;
1259 if (uReadThis == 0) 1259 if (uReadThis == 0)
1260 return UNZ_EOF; 1260 return UNZ_EOF;
1261 if (ZSEEK(pfile_in_zip_read_info->z_filefunc, 1261 if (ZSEEK(pfile_in_zip_read_info->z_filefunc,
1262 pfile_in_zip_read_info->filestream, 1262 pfile_in_zip_read_info->filestream,
1263 pfile_in_zip_read_info->pos_in_zipfile + 1263 pfile_in_zip_read_info->pos_in_zipfile +
1264 pfile_in_zip_read_info->byte_before_the_zipfile, 1264 pfile_in_zip_read_info->byte_before_the_zipfile,
1265 ZLIB_FILEFUNC_SEEK_SET)!=0) 1265 ZLIB_FILEFUNC_SEEK_SET)!=0)
1266 return UNZ_ERRNO; 1266 return UNZ_ERRNO;
1267 if (ZREAD(pfile_in_zip_read_info->z_filefunc, 1267 if (ZREAD(pfile_in_zip_read_info->z_filefunc,
1268 pfile_in_zip_read_info->filestream, 1268 pfile_in_zip_read_info->filestream,
1269 pfile_in_zip_read_info->read_buffer, 1269 pfile_in_zip_read_info->read_buffer,
1270 uReadThis)!=uReadThis) 1270 uReadThis)!=uReadThis)
1271 return UNZ_ERRNO; 1271 return UNZ_ERRNO;
1272 1272
1273 1273
1274 #ifndef NOUNCRYPT 1274# ifndef NOUNCRYPT
1275 if(s->encrypted) 1275 if(s->encrypted)
1276 { 1276 {
1277 uInt i; 1277 uInt i;
1278 for(i=0;i<uReadThis;i++) 1278 for(i=0;i<uReadThis;i++)
1279 pfile_in_zip_read_info->read_buffer[i] = 1279 pfile_in_zip_read_info->read_buffer[i] =
1280 zdecode(s->keys,s->pcrc_32_tab, 1280 zdecode(s->keys,s->pcrc_32_tab,
1281 pfile_in_zip_read_info->read_buffer[i]); 1281 pfile_in_zip_read_info->read_buffer[i]);
1282 } 1282 }
1283 #endif 1283# endif
1284 1284
1285 1285
1286 pfile_in_zip_read_info->pos_in_zipfile += uReadThis; 1286 pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
1287 1287
1288 pfile_in_zip_read_info->rest_read_compressed-=uReadThis; 1288 pfile_in_zip_read_info->rest_read_compressed-=uReadThis;
1289 1289
1290 pfile_in_zip_read_info->stream.next_in = 1290 pfile_in_zip_read_info->stream.next_in =
1291 (Bytef*)pfile_in_zip_read_info->read_buffer; 1291 (Bytef*)pfile_in_zip_read_info->read_buffer;
1292 pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis; 1292 pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis;
1293 } 1293 }
1294 1294
1295 if ((pfile_in_zip_read_info->compression_method==0) || (pfile_in_zip_read_info->raw)) 1295 if ((pfile_in_zip_read_info->compression_method==0) || (pfile_in_zip_read_info->raw))
1296 { 1296 {
1297 uInt uDoCopy,i ; 1297 uInt uDoCopy,i ;
1298 1298
1299 if ((pfile_in_zip_read_info->stream.avail_in == 0) && 1299 if ((pfile_in_zip_read_info->stream.avail_in == 0) &&
1300 (pfile_in_zip_read_info->rest_read_compressed == 0)) 1300 (pfile_in_zip_read_info->rest_read_compressed == 0))
1301 return (iRead==0) ? UNZ_EOF : iRead; 1301 return (iRead==0) ? UNZ_EOF : iRead;
1302 1302
1303 if (pfile_in_zip_read_info->stream.avail_out < 1303 if (pfile_in_zip_read_info->stream.avail_out <
1304 pfile_in_zip_read_info->stream.avail_in) 1304 pfile_in_zip_read_info->stream.avail_in)
1305 uDoCopy = pfile_in_zip_read_info->stream.avail_out ; 1305 uDoCopy = pfile_in_zip_read_info->stream.avail_out ;
1306 else 1306 else
1307 uDoCopy = pfile_in_zip_read_info->stream.avail_in ; 1307 uDoCopy = pfile_in_zip_read_info->stream.avail_in ;
1308 1308
1309 for (i=0;i<uDoCopy;i++) 1309 for (i=0;i<uDoCopy;i++)
1310 *(pfile_in_zip_read_info->stream.next_out+i) = 1310 *(pfile_in_zip_read_info->stream.next_out+i) =
1311 *(pfile_in_zip_read_info->stream.next_in+i); 1311 *(pfile_in_zip_read_info->stream.next_in+i);
1312 1312
1313 pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32, 1313 pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,
1314 pfile_in_zip_read_info->stream.next_out, 1314 pfile_in_zip_read_info->stream.next_out,
1315 uDoCopy); 1315 uDoCopy);
1316 pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy; 1316 pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy;
1317 pfile_in_zip_read_info->stream.avail_in -= uDoCopy; 1317 pfile_in_zip_read_info->stream.avail_in -= uDoCopy;
1318 pfile_in_zip_read_info->stream.avail_out -= uDoCopy; 1318 pfile_in_zip_read_info->stream.avail_out -= uDoCopy;
1319 pfile_in_zip_read_info->stream.next_out += uDoCopy; 1319 pfile_in_zip_read_info->stream.next_out += uDoCopy;
1320 pfile_in_zip_read_info->stream.next_in += uDoCopy; 1320 pfile_in_zip_read_info->stream.next_in += uDoCopy;
1321 pfile_in_zip_read_info->stream.total_out += uDoCopy; 1321 pfile_in_zip_read_info->stream.total_out += uDoCopy;
1322 iRead += uDoCopy; 1322 iRead += uDoCopy;
1323 } 1323 }
1324 else 1324 else
1325 { 1325 {
1326 uLong uTotalOutBefore,uTotalOutAfter; 1326 uLong uTotalOutBefore,uTotalOutAfter;
1327 const Bytef *bufBefore; 1327 const Bytef *bufBefore;
1328 uLong uOutThis; 1328 uLong uOutThis;
1329 int flush=Z_SYNC_FLUSH; 1329 int flush=Z_SYNC_FLUSH;
1330 1330
1331 uTotalOutBefore = pfile_in_zip_read_info->stream.total_out; 1331 uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;
1332 bufBefore = pfile_in_zip_read_info->stream.next_out; 1332 bufBefore = pfile_in_zip_read_info->stream.next_out;
1333 1333
1334 /* 1334 /*
1335 if ((pfile_in_zip_read_info->rest_read_uncompressed == 1335 if ((pfile_in_zip_read_info->rest_read_uncompressed ==
1336 pfile_in_zip_read_info->stream.avail_out) && 1336 pfile_in_zip_read_info->stream.avail_out) &&
1337 (pfile_in_zip_read_info->rest_read_compressed == 0)) 1337 (pfile_in_zip_read_info->rest_read_compressed == 0))
1338 flush = Z_FINISH; 1338 flush = Z_FINISH;
1339 */ 1339 */
1340 err=inflate(&pfile_in_zip_read_info->stream,flush); 1340 err=inflate(&pfile_in_zip_read_info->stream,flush);
1341 1341
1342 uTotalOutAfter = pfile_in_zip_read_info->stream.total_out; 1342 uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;
1343 uOutThis = uTotalOutAfter-uTotalOutBefore; 1343 uOutThis = uTotalOutAfter-uTotalOutBefore;
1344 1344
1345 pfile_in_zip_read_info->crc32 = 1345 pfile_in_zip_read_info->crc32 =
1346 crc32(pfile_in_zip_read_info->crc32,bufBefore, 1346 crc32(pfile_in_zip_read_info->crc32,bufBefore,
1347 (uInt)(uOutThis)); 1347 (uInt)(uOutThis));
1348 1348
1349 pfile_in_zip_read_info->rest_read_uncompressed -= 1349 pfile_in_zip_read_info->rest_read_uncompressed -=
1350 uOutThis; 1350 uOutThis;
1351 1351
1352 iRead += (uInt)(uTotalOutAfter - uTotalOutBefore); 1352 iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
1353 1353
1354 if (err==Z_STREAM_END) 1354 if (err==Z_STREAM_END)
1355 return (iRead==0) ? UNZ_EOF : iRead; 1355 return (iRead==0) ? UNZ_EOF : iRead;
1356 if (err!=Z_OK) 1356 if (err!=Z_OK)
1357 break; 1357 break;
1358 } 1358 }
1359 } 1359 }
1360 1360
1361 if (err==Z_OK) 1361 if (err==Z_OK)
1362 return iRead; 1362 return iRead;
1363 return err; 1363 return err;
1364} 1364}
1365 1365
1366 1366
1367/* 1367/*
1368 Give the current position in uncompressed data 1368 Give the current position in uncompressed data
1369*/ 1369*/
1370extern z_off_t ZEXPORT unztell (file) 1370extern z_off_t ZEXPORT unztell (file)
1371 unzFile file; 1371 unzFile file;
1372{ 1372{
1373 unz_s* s; 1373 unz_s* s;
1374 file_in_zip_read_info_s* pfile_in_zip_read_info; 1374 file_in_zip_read_info_s* pfile_in_zip_read_info;
1375 if (file==NULL) 1375 if (file==NULL)
1376 return UNZ_PARAMERROR; 1376 return UNZ_PARAMERROR;
1377 s=(unz_s*)file; 1377 s=(unz_s*)file;
1378 pfile_in_zip_read_info=s->pfile_in_zip_read; 1378 pfile_in_zip_read_info=s->pfile_in_zip_read;
1379 1379
1380 if (pfile_in_zip_read_info==NULL) 1380 if (pfile_in_zip_read_info==NULL)
1381 return UNZ_PARAMERROR; 1381 return UNZ_PARAMERROR;
1382 1382
1383 return (z_off_t)pfile_in_zip_read_info->stream.total_out; 1383 return (z_off_t)pfile_in_zip_read_info->stream.total_out;
1384} 1384}
1385 1385
1386 1386
1387/* 1387/*
1388 return 1 if the end of file was reached, 0 elsewhere 1388 return 1 if the end of file was reached, 0 elsewhere
1389*/ 1389*/
1390extern int ZEXPORT unzeof (file) 1390extern int ZEXPORT unzeof (file)
1391 unzFile file; 1391 unzFile file;
1392{ 1392{
1393 unz_s* s; 1393 unz_s* s;
1394 file_in_zip_read_info_s* pfile_in_zip_read_info; 1394 file_in_zip_read_info_s* pfile_in_zip_read_info;
1395 if (file==NULL) 1395 if (file==NULL)
1396 return UNZ_PARAMERROR; 1396 return UNZ_PARAMERROR;
1397 s=(unz_s*)file; 1397 s=(unz_s*)file;
1398 pfile_in_zip_read_info=s->pfile_in_zip_read; 1398 pfile_in_zip_read_info=s->pfile_in_zip_read;
1399 1399
1400 if (pfile_in_zip_read_info==NULL) 1400 if (pfile_in_zip_read_info==NULL)
1401 return UNZ_PARAMERROR; 1401 return UNZ_PARAMERROR;
1402 1402
1403 if (pfile_in_zip_read_info->rest_read_uncompressed == 0) 1403 if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
1404 return 1; 1404 return 1;
1405 else 1405 else
1406 return 0; 1406 return 0;
1407} 1407}
1408 1408
1409 1409
1410 1410
1411/* 1411/*
1412 Read extra field from the current file (opened by unzOpenCurrentFile) 1412 Read extra field from the current file (opened by unzOpenCurrentFile)
1413 This is the local-header version of the extra field (sometimes, there is 1413 This is the local-header version of the extra field (sometimes, there is
1414 more info in the local-header version than in the central-header) 1414 more info in the local-header version than in the central-header)
1415 1415
1416 if buf==NULL, it return the size of the local extra field that can be read 1416 if buf==NULL, it return the size of the local extra field that can be read
1417 1417
1418 if buf!=NULL, len is the size of the buffer, the extra header is copied in 1418 if buf!=NULL, len is the size of the buffer, the extra header is copied in
1419 buf. 1419 buf.
1420 the return value is the number of bytes copied in buf, or (if <0) 1420 the return value is the number of bytes copied in buf, or (if <0)
1421 the error code 1421 the error code
1422*/ 1422*/
1423extern int ZEXPORT unzGetLocalExtrafield (file,buf,len) 1423extern int ZEXPORT unzGetLocalExtrafield (file,buf,len)
1424 unzFile file; 1424 unzFile file;
1425 voidp buf; 1425 voidp buf;
1426 unsigned len; 1426 unsigned len;
1427{ 1427{
1428 unz_s* s; 1428 unz_s* s;
1429 file_in_zip_read_info_s* pfile_in_zip_read_info; 1429 file_in_zip_read_info_s* pfile_in_zip_read_info;
1430 uInt read_now; 1430 uInt read_now;
1431 uLong size_to_read; 1431 uLong size_to_read;
1432 1432
1433 if (file==NULL) 1433 if (file==NULL)
1434 return UNZ_PARAMERROR; 1434 return UNZ_PARAMERROR;
1435 s=(unz_s*)file; 1435 s=(unz_s*)file;
1436 pfile_in_zip_read_info=s->pfile_in_zip_read; 1436 pfile_in_zip_read_info=s->pfile_in_zip_read;
1437 1437
1438 if (pfile_in_zip_read_info==NULL) 1438 if (pfile_in_zip_read_info==NULL)
1439 return UNZ_PARAMERROR; 1439 return UNZ_PARAMERROR;
1440 1440
1441 size_to_read = (pfile_in_zip_read_info->size_local_extrafield - 1441 size_to_read = (pfile_in_zip_read_info->size_local_extrafield -
1442 pfile_in_zip_read_info->pos_local_extrafield); 1442 pfile_in_zip_read_info->pos_local_extrafield);
1443 1443
1444 if (buf==NULL) 1444 if (buf==NULL)
1445 return (int)size_to_read; 1445 return (int)size_to_read;
1446 1446
1447 if (len>size_to_read) 1447 if (len>size_to_read)
1448 read_now = (uInt)size_to_read; 1448 read_now = (uInt)size_to_read;
1449 else 1449 else
1450 read_now = (uInt)len ; 1450 read_now = (uInt)len ;
1451 1451
1452 if (read_now==0) 1452 if (read_now==0)
1453 return 0; 1453 return 0;
1454 1454
1455 if (ZSEEK(pfile_in_zip_read_info->z_filefunc, 1455 if (ZSEEK(pfile_in_zip_read_info->z_filefunc,
1456 pfile_in_zip_read_info->filestream, 1456 pfile_in_zip_read_info->filestream,
1457 pfile_in_zip_read_info->offset_local_extrafield + 1457 pfile_in_zip_read_info->offset_local_extrafield +
1458 pfile_in_zip_read_info->pos_local_extrafield, 1458 pfile_in_zip_read_info->pos_local_extrafield,
1459 ZLIB_FILEFUNC_SEEK_SET)!=0) 1459 ZLIB_FILEFUNC_SEEK_SET)!=0)
1460 return UNZ_ERRNO; 1460 return UNZ_ERRNO;
1461 1461
1462 if (ZREAD(pfile_in_zip_read_info->z_filefunc, 1462 if (ZREAD(pfile_in_zip_read_info->z_filefunc,
1463 pfile_in_zip_read_info->filestream, 1463 pfile_in_zip_read_info->filestream,
1464 buf,size_to_read)!=size_to_read) 1464 buf,size_to_read)!=size_to_read)
1465 return UNZ_ERRNO; 1465 return UNZ_ERRNO;
1466 1466
1467 return (int)read_now; 1467 return (int)read_now;
1468} 1468}
1469 1469
1470/* 1470/*
1471 Close the file in zip opened with unzipOpenCurrentFile 1471 Close the file in zip opened with unzipOpenCurrentFile
1472 Return UNZ_CRCERROR if all the file was read but the CRC is not good 1472 Return UNZ_CRCERROR if all the file was read but the CRC is not good
1473*/ 1473*/
1474extern int ZEXPORT unzCloseCurrentFile (file) 1474extern int ZEXPORT unzCloseCurrentFile (file)
1475 unzFile file; 1475 unzFile file;
1476{ 1476{
1477 int err=UNZ_OK; 1477 int err=UNZ_OK;
1478 1478
1479 unz_s* s; 1479 unz_s* s;
1480 file_in_zip_read_info_s* pfile_in_zip_read_info; 1480 file_in_zip_read_info_s* pfile_in_zip_read_info;
1481 if (file==NULL) 1481 if (file==NULL)
1482 return UNZ_PARAMERROR; 1482 return UNZ_PARAMERROR;
1483 s=(unz_s*)file; 1483 s=(unz_s*)file;
1484 pfile_in_zip_read_info=s->pfile_in_zip_read; 1484 pfile_in_zip_read_info=s->pfile_in_zip_read;
1485 1485
1486 if (pfile_in_zip_read_info==NULL) 1486 if (pfile_in_zip_read_info==NULL)
1487 return UNZ_PARAMERROR; 1487 return UNZ_PARAMERROR;
1488 1488
1489 1489
1490 if ((pfile_in_zip_read_info->rest_read_uncompressed == 0) && 1490 if ((pfile_in_zip_read_info->rest_read_uncompressed == 0) &&
1491 (!pfile_in_zip_read_info->raw)) 1491 (!pfile_in_zip_read_info->raw))
1492 { 1492 {
1493 if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait) 1493 if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait)
1494 err=UNZ_CRCERROR; 1494 err=UNZ_CRCERROR;
1495 } 1495 }
1496 1496
1497 1497
1498 TRYFREE(pfile_in_zip_read_info->read_buffer); 1498 TRYFREE(pfile_in_zip_read_info->read_buffer);
1499 pfile_in_zip_read_info->read_buffer = NULL; 1499 pfile_in_zip_read_info->read_buffer = NULL;
1500 if (pfile_in_zip_read_info->stream_initialised) 1500 if (pfile_in_zip_read_info->stream_initialised)
1501 inflateEnd(&pfile_in_zip_read_info->stream); 1501 inflateEnd(&pfile_in_zip_read_info->stream);
1502 1502
1503 pfile_in_zip_read_info->stream_initialised = 0; 1503 pfile_in_zip_read_info->stream_initialised = 0;
1504 TRYFREE(pfile_in_zip_read_info); 1504 TRYFREE(pfile_in_zip_read_info);
1505 1505
1506 s->pfile_in_zip_read=NULL; 1506 s->pfile_in_zip_read=NULL;
1507 1507
1508 return err; 1508 return err;
1509} 1509}
1510 1510
1511 1511
1512/* 1512/*
1513 Get the global comment string of the ZipFile, in the szComment buffer. 1513 Get the global comment string of the ZipFile, in the szComment buffer.
1514 uSizeBuf is the size of the szComment buffer. 1514 uSizeBuf is the size of the szComment buffer.
1515 return the number of byte copied or an error code <0 1515 return the number of byte copied or an error code <0
1516*/ 1516*/
1517extern int ZEXPORT unzGetGlobalComment (file, szComment, uSizeBuf) 1517extern int ZEXPORT unzGetGlobalComment (file, szComment, uSizeBuf)
1518 unzFile file; 1518 unzFile file;
1519 char *szComment; 1519 char *szComment;
1520 uLong uSizeBuf; 1520 uLong uSizeBuf;
1521{ 1521{
1522 int err=UNZ_OK; 1522 int err=UNZ_OK;
1523 unz_s* s; 1523 unz_s* s;
1524 uLong uReadThis ; 1524 uLong uReadThis ;
1525 if (file==NULL) 1525 if (file==NULL)
1526 return UNZ_PARAMERROR; 1526 return UNZ_PARAMERROR;
1527 s=(unz_s*)file; 1527 s=(unz_s*)file;
1528 1528
1529 uReadThis = uSizeBuf; 1529 uReadThis = uSizeBuf;
1530 if (uReadThis>s->gi.size_comment) 1530 if (uReadThis>s->gi.size_comment)
1531 uReadThis = s->gi.size_comment; 1531 uReadThis = s->gi.size_comment;
1532 1532
1533 if (ZSEEK(s->z_filefunc,s->filestream,s->central_pos+22,ZLIB_FILEFUNC_SEEK_SET)!=0) 1533 if (ZSEEK(s->z_filefunc,s->filestream,s->central_pos+22,ZLIB_FILEFUNC_SEEK_SET)!=0)
1534 return UNZ_ERRNO; 1534 return UNZ_ERRNO;
1535 1535
1536 if (uReadThis>0) 1536 if (uReadThis>0)
1537 { 1537 {
1538 *szComment='\0'; 1538 *szComment='\0';
1539 if (ZREAD(s->z_filefunc,s->filestream,szComment,uReadThis)!=uReadThis) 1539 if (ZREAD(s->z_filefunc,s->filestream,szComment,uReadThis)!=uReadThis)
1540 return UNZ_ERRNO; 1540 return UNZ_ERRNO;
1541 } 1541 }
1542 1542
1543 if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment)) 1543 if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment))
1544 *(szComment+s->gi.size_comment)='\0'; 1544 *(szComment+s->gi.size_comment)='\0';
1545 return (int)uReadThis; 1545 return (int)uReadThis;
1546} 1546}
diff --git a/contrib/minizip/unzip.h b/contrib/minizip/unzip.h
index 48e6832..4c2f5e1 100644
--- a/contrib/minizip/unzip.h
+++ b/contrib/minizip/unzip.h
@@ -1,342 +1,342 @@
1/* unzip.h -- IO for uncompress .zip files using zlib 1/* unzip.h -- IO for uncompress .zip files using zlib
2 Version 0.22, May 19th, 2003 2 Version 0.22, May 19th, 2003
3 3
4 Copyright (C) 1998-2003 Gilles Vollant 4 Copyright (C) 1998-2003 Gilles Vollant
5 5
6 This unzip package allow extract file from .ZIP file, compatible with PKZip 2.04g 6 This unzip package allow extract file from .ZIP file, compatible with PKZip 2.04g
7 WinZip, InfoZip tools and compatible. 7 WinZip, InfoZip tools and compatible.
8 Encryption and multi volume ZipFile (span) are not supported. 8 Encryption and multi volume ZipFile (span) are not supported.
9 Old compressions used by old PKZip 1.x are not supported 9 Old compressions used by old PKZip 1.x are not supported
10 10
11 11
12 I WAIT FEEDBACK at mail info@winimage.com 12 I WAIT FEEDBACK at mail info@winimage.com
13 Visit also http://www.winimage.com/zLibDll/unzip.htm for evolution 13 Visit also http://www.winimage.com/zLibDll/unzip.htm for evolution
14 14
15 Condition of use and distribution are the same than zlib : 15 Condition of use and distribution are the same than zlib :
16 16
17 This software is provided 'as-is', without any express or implied 17 This software is provided 'as-is', without any express or implied
18 warranty. In no event will the authors be held liable for any damages 18 warranty. In no event will the authors be held liable for any damages
19 arising from the use of this software. 19 arising from the use of this software.
20 20
21 Permission is granted to anyone to use this software for any purpose, 21 Permission is granted to anyone to use this software for any purpose,
22 including commercial applications, and to alter it and redistribute it 22 including commercial applications, and to alter it and redistribute it
23 freely, subject to the following restrictions: 23 freely, subject to the following restrictions:
24 24
25 1. The origin of this software must not be misrepresented; you must not 25 1. The origin of this software must not be misrepresented; you must not
26 claim that you wrote the original software. If you use this software 26 claim that you wrote the original software. If you use this software
27 in a product, an acknowledgment in the product documentation would be 27 in a product, an acknowledgment in the product documentation would be
28 appreciated but is not required. 28 appreciated but is not required.
29 2. Altered source versions must be plainly marked as such, and must not be 29 2. Altered source versions must be plainly marked as such, and must not be
30 misrepresented as being the original software. 30 misrepresented as being the original software.
31 3. This notice may not be removed or altered from any source distribution. 31 3. This notice may not be removed or altered from any source distribution.
32 32
33 33
34*/ 34*/
35 35
36/* for more info about .ZIP format, see 36/* for more info about .ZIP format, see
37 http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip 37 http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip
38 http://www.info-zip.org/pub/infozip/doc/ 38 http://www.info-zip.org/pub/infozip/doc/
39 PkWare has also a specification at : 39 PkWare has also a specification at :
40 ftp://ftp.pkware.com/probdesc.zip 40 ftp://ftp.pkware.com/probdesc.zip
41*/ 41*/
42 42
43#ifndef _unz_H 43#ifndef _unz_H
44#define _unz_H 44#define _unz_H
45 45
46#ifdef __cplusplus 46#ifdef __cplusplus
47extern "C" { 47extern "C" {
48#endif 48#endif
49 49
50#ifndef _ZLIB_H 50#ifndef _ZLIB_H
51#include "zlib.h" 51#include "zlib.h"
52#endif 52#endif
53 53
54#ifndef _ZLIBIOAPI_H 54#ifndef _ZLIBIOAPI_H
55#include "ioapi.h" 55#include "ioapi.h"
56#endif 56#endif
57 57
58#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP) 58#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP)
59/* like the STRICT of WIN32, we define a pointer that cannot be converted 59/* like the STRICT of WIN32, we define a pointer that cannot be converted
60 from (void*) without cast */ 60 from (void*) without cast */
61typedef struct TagunzFile__ { int unused; } unzFile__; 61typedef struct TagunzFile__ { int unused; } unzFile__;
62typedef unzFile__ *unzFile; 62typedef unzFile__ *unzFile;
63#else 63#else
64typedef voidp unzFile; 64typedef voidp unzFile;
65#endif 65#endif
66 66
67 67
68#define UNZ_OK (0) 68#define UNZ_OK (0)
69#define UNZ_END_OF_LIST_OF_FILE (-100) 69#define UNZ_END_OF_LIST_OF_FILE (-100)
70#define UNZ_ERRNO (Z_ERRNO) 70#define UNZ_ERRNO (Z_ERRNO)
71#define UNZ_EOF (0) 71#define UNZ_EOF (0)
72#define UNZ_PARAMERROR (-102) 72#define UNZ_PARAMERROR (-102)
73#define UNZ_BADZIPFILE (-103) 73#define UNZ_BADZIPFILE (-103)
74#define UNZ_INTERNALERROR (-104) 74#define UNZ_INTERNALERROR (-104)
75#define UNZ_CRCERROR (-105) 75#define UNZ_CRCERROR (-105)
76 76
77/* tm_unz contain date/time info */ 77/* tm_unz contain date/time info */
78typedef struct tm_unz_s 78typedef struct tm_unz_s
79{ 79{
80 uInt tm_sec; /* seconds after the minute - [0,59] */ 80 uInt tm_sec; /* seconds after the minute - [0,59] */
81 uInt tm_min; /* minutes after the hour - [0,59] */ 81 uInt tm_min; /* minutes after the hour - [0,59] */
82 uInt tm_hour; /* hours since midnight - [0,23] */ 82 uInt tm_hour; /* hours since midnight - [0,23] */
83 uInt tm_mday; /* day of the month - [1,31] */ 83 uInt tm_mday; /* day of the month - [1,31] */
84 uInt tm_mon; /* months since January - [0,11] */ 84 uInt tm_mon; /* months since January - [0,11] */
85 uInt tm_year; /* years - [1980..2044] */ 85 uInt tm_year; /* years - [1980..2044] */
86} tm_unz; 86} tm_unz;
87 87
88/* unz_global_info structure contain global data about the ZIPfile 88/* unz_global_info structure contain global data about the ZIPfile
89 These data comes from the end of central dir */ 89 These data comes from the end of central dir */
90typedef struct unz_global_info_s 90typedef struct unz_global_info_s
91{ 91{
92 uLong number_entry; /* total number of entries in 92 uLong number_entry; /* total number of entries in
93 the central dir on this disk */ 93 the central dir on this disk */
94 uLong size_comment; /* size of the global comment of the zipfile */ 94 uLong size_comment; /* size of the global comment of the zipfile */
95} unz_global_info; 95} unz_global_info;
96 96
97 97
98/* unz_file_info contain information about a file in the zipfile */ 98/* unz_file_info contain information about a file in the zipfile */
99typedef struct unz_file_info_s 99typedef struct unz_file_info_s
100{ 100{
101 uLong version; /* version made by 2 bytes */ 101 uLong version; /* version made by 2 bytes */
102 uLong version_needed; /* version needed to extract 2 bytes */ 102 uLong version_needed; /* version needed to extract 2 bytes */
103 uLong flag; /* general purpose bit flag 2 bytes */ 103 uLong flag; /* general purpose bit flag 2 bytes */
104 uLong compression_method; /* compression method 2 bytes */ 104 uLong compression_method; /* compression method 2 bytes */
105 uLong dosDate; /* last mod file date in Dos fmt 4 bytes */ 105 uLong dosDate; /* last mod file date in Dos fmt 4 bytes */
106 uLong crc; /* crc-32 4 bytes */ 106 uLong crc; /* crc-32 4 bytes */
107 uLong compressed_size; /* compressed size 4 bytes */ 107 uLong compressed_size; /* compressed size 4 bytes */
108 uLong uncompressed_size; /* uncompressed size 4 bytes */ 108 uLong uncompressed_size; /* uncompressed size 4 bytes */
109 uLong size_filename; /* filename length 2 bytes */ 109 uLong size_filename; /* filename length 2 bytes */
110 uLong size_file_extra; /* extra field length 2 bytes */ 110 uLong size_file_extra; /* extra field length 2 bytes */
111 uLong size_file_comment; /* file comment length 2 bytes */ 111 uLong size_file_comment; /* file comment length 2 bytes */
112 112
113 uLong disk_num_start; /* disk number start 2 bytes */ 113 uLong disk_num_start; /* disk number start 2 bytes */
114 uLong internal_fa; /* internal file attributes 2 bytes */ 114 uLong internal_fa; /* internal file attributes 2 bytes */
115 uLong external_fa; /* external file attributes 4 bytes */ 115 uLong external_fa; /* external file attributes 4 bytes */
116 116
117 tm_unz tmu_date; 117 tm_unz tmu_date;
118} unz_file_info; 118} unz_file_info;
119 119
120extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1, 120extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1,
121 const char* fileName2, 121 const char* fileName2,
122 int iCaseSensitivity)); 122 int iCaseSensitivity));
123/* 123/*
124 Compare two filename (fileName1,fileName2). 124 Compare two filename (fileName1,fileName2).
125 If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp) 125 If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
126 If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi 126 If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
127 or strcasecmp) 127 or strcasecmp)
128 If iCaseSenisivity = 0, case sensitivity is defaut of your operating system 128 If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
129 (like 1 on Unix, 2 on Windows) 129 (like 1 on Unix, 2 on Windows)
130*/ 130*/
131 131
132 132
133extern unzFile ZEXPORT unzOpen OF((const char *path)); 133extern unzFile ZEXPORT unzOpen OF((const char *path));
134/* 134/*
135 Open a Zip file. path contain the full pathname (by example, 135 Open a Zip file. path contain the full pathname (by example,
136 on a Windows XP computer "c:\\zlib\\zlib113.zip" or on an Unix computer 136 on a Windows XP computer "c:\\zlib\\zlib113.zip" or on an Unix computer
137 "zlib/zlib113.zip". 137 "zlib/zlib113.zip".
138 If the zipfile cannot be opened (file don't exist or in not valid), the 138 If the zipfile cannot be opened (file don't exist or in not valid), the
139 return value is NULL. 139 return value is NULL.
140 Else, the return value is a unzFile Handle, usable with other function 140 Else, the return value is a unzFile Handle, usable with other function
141 of this unzip package. 141 of this unzip package.
142*/ 142*/
143 143
144extern unzFile ZEXPORT unzOpen2 OF((const char *path, 144extern unzFile ZEXPORT unzOpen2 OF((const char *path,
145 zlib_filefunc_def* pzlib_filefunc_def)); 145 zlib_filefunc_def* pzlib_filefunc_def));
146/* 146/*
147 Open a Zip file, like unzOpen, but provide a set of file low level API 147 Open a Zip file, like unzOpen, but provide a set of file low level API
148 for read/write the zip file (see ioapi.h) 148 for read/write the zip file (see ioapi.h)
149*/ 149*/
150 150
151extern int ZEXPORT unzClose OF((unzFile file)); 151extern int ZEXPORT unzClose OF((unzFile file));
152/* 152/*
153 Close a ZipFile opened with unzipOpen. 153 Close a ZipFile opened with unzipOpen.
154 If there is files inside the .Zip opened with unzOpenCurrentFile (see later), 154 If there is files inside the .Zip opened with unzOpenCurrentFile (see later),
155 these files MUST be closed with unzipCloseCurrentFile before call unzipClose. 155 these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
156 return UNZ_OK if there is no problem. */ 156 return UNZ_OK if there is no problem. */
157 157
158extern int ZEXPORT unzGetGlobalInfo OF((unzFile file, 158extern int ZEXPORT unzGetGlobalInfo OF((unzFile file,
159 unz_global_info *pglobal_info)); 159 unz_global_info *pglobal_info));
160/* 160/*
161 Write info about the ZipFile in the *pglobal_info structure. 161 Write info about the ZipFile in the *pglobal_info structure.
162 No preparation of the structure is needed 162 No preparation of the structure is needed
163 return UNZ_OK if there is no problem. */ 163 return UNZ_OK if there is no problem. */
164 164
165 165
166extern int ZEXPORT unzGetGlobalComment OF((unzFile file, 166extern int ZEXPORT unzGetGlobalComment OF((unzFile file,
167 char *szComment, 167 char *szComment,
168 uLong uSizeBuf)); 168 uLong uSizeBuf));
169/* 169/*
170 Get the global comment string of the ZipFile, in the szComment buffer. 170 Get the global comment string of the ZipFile, in the szComment buffer.
171 uSizeBuf is the size of the szComment buffer. 171 uSizeBuf is the size of the szComment buffer.
172 return the number of byte copied or an error code <0 172 return the number of byte copied or an error code <0
173*/ 173*/
174 174
175 175
176/***************************************************************************/ 176/***************************************************************************/
177/* Unzip package allow you browse the directory of the zipfile */ 177/* Unzip package allow you browse the directory of the zipfile */
178 178
179extern int ZEXPORT unzGoToFirstFile OF((unzFile file)); 179extern int ZEXPORT unzGoToFirstFile OF((unzFile file));
180/* 180/*
181 Set the current file of the zipfile to the first file. 181 Set the current file of the zipfile to the first file.
182 return UNZ_OK if there is no problem 182 return UNZ_OK if there is no problem
183*/ 183*/
184 184
185extern int ZEXPORT unzGoToNextFile OF((unzFile file)); 185extern int ZEXPORT unzGoToNextFile OF((unzFile file));
186/* 186/*
187 Set the current file of the zipfile to the next file. 187 Set the current file of the zipfile to the next file.
188 return UNZ_OK if there is no problem 188 return UNZ_OK if there is no problem
189 return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest. 189 return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
190*/ 190*/
191 191
192extern int ZEXPORT unzLocateFile OF((unzFile file, 192extern int ZEXPORT unzLocateFile OF((unzFile file,
193 const char *szFileName, 193 const char *szFileName,
194 int iCaseSensitivity)); 194 int iCaseSensitivity));
195/* 195/*
196 Try locate the file szFileName in the zipfile. 196 Try locate the file szFileName in the zipfile.
197 For the iCaseSensitivity signification, see unzStringFileNameCompare 197 For the iCaseSensitivity signification, see unzStringFileNameCompare
198 198
199 return value : 199 return value :
200 UNZ_OK if the file is found. It becomes the current file. 200 UNZ_OK if the file is found. It becomes the current file.
201 UNZ_END_OF_LIST_OF_FILE if the file is not found 201 UNZ_END_OF_LIST_OF_FILE if the file is not found
202*/ 202*/
203 203
204 204
205/* ****************************************** */ 205/* ****************************************** */
206/* Ryan supplied functions */ 206/* Ryan supplied functions */
207/* unz_file_info contain information about a file in the zipfile */ 207/* unz_file_info contain information about a file in the zipfile */
208typedef struct unz_file_pos_s 208typedef struct unz_file_pos_s
209{ 209{
210 uLong pos_in_zip_directory; /* offset in zip file directory */ 210 uLong pos_in_zip_directory; /* offset in zip file directory */
211 uLong num_of_file; /* # of file */ 211 uLong num_of_file; /* # of file */
212} unz_file_pos; 212} unz_file_pos;
213 213
214extern int ZEXPORT unzGetFilePos( 214extern int ZEXPORT unzGetFilePos(
215 unzFile file, 215 unzFile file,
216 unz_file_pos* file_pos); 216 unz_file_pos* file_pos);
217 217
218extern int ZEXPORT unzGoToFilePos( 218extern int ZEXPORT unzGoToFilePos(
219 unzFile file, 219 unzFile file,
220 unz_file_pos* file_pos); 220 unz_file_pos* file_pos);
221 221
222/* ****************************************** */ 222/* ****************************************** */
223 223
224extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file, 224extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file,
225 unz_file_info *pfile_info, 225 unz_file_info *pfile_info,
226 char *szFileName, 226 char *szFileName,
227 uLong fileNameBufferSize, 227 uLong fileNameBufferSize,
228 void *extraField, 228 void *extraField,
229 uLong extraFieldBufferSize, 229 uLong extraFieldBufferSize,
230 char *szComment, 230 char *szComment,
231 uLong commentBufferSize)); 231 uLong commentBufferSize));
232/* 232/*
233 Get Info about the current file 233 Get Info about the current file
234 if pfile_info!=NULL, the *pfile_info structure will contain somes info about 234 if pfile_info!=NULL, the *pfile_info structure will contain somes info about
235 the current file 235 the current file
236 if szFileName!=NULL, the filemane string will be copied in szFileName 236 if szFileName!=NULL, the filemane string will be copied in szFileName
237 (fileNameBufferSize is the size of the buffer) 237 (fileNameBufferSize is the size of the buffer)
238 if extraField!=NULL, the extra field information will be copied in extraField 238 if extraField!=NULL, the extra field information will be copied in extraField
239 (extraFieldBufferSize is the size of the buffer). 239 (extraFieldBufferSize is the size of the buffer).
240 This is the Central-header version of the extra field 240 This is the Central-header version of the extra field
241 if szComment!=NULL, the comment string of the file will be copied in szComment 241 if szComment!=NULL, the comment string of the file will be copied in szComment
242 (commentBufferSize is the size of the buffer) 242 (commentBufferSize is the size of the buffer)
243*/ 243*/
244 244
245/***************************************************************************/ 245/***************************************************************************/
246/* for reading the content of the current zipfile, you can open it, read data 246/* for reading the content of the current zipfile, you can open it, read data
247 from it, and close it (you can close it before reading all the file) 247 from it, and close it (you can close it before reading all the file)
248 */ 248 */
249 249
250extern int ZEXPORT unzOpenCurrentFile OF((unzFile file)); 250extern int ZEXPORT unzOpenCurrentFile OF((unzFile file));
251/* 251/*
252 Open for reading data the current file in the zipfile. 252 Open for reading data the current file in the zipfile.
253 If there is no error, the return value is UNZ_OK. 253 If there is no error, the return value is UNZ_OK.
254*/ 254*/
255 255
256extern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file, 256extern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file,
257 const char* password)); 257 const char* password));
258/* 258/*
259 Open for reading data the current file in the zipfile. 259 Open for reading data the current file in the zipfile.
260 password is a crypting password 260 password is a crypting password
261 If there is no error, the return value is UNZ_OK. 261 If there is no error, the return value is UNZ_OK.
262*/ 262*/
263 263
264extern int ZEXPORT unzOpenCurrentFile2 OF((unzFile file, 264extern int ZEXPORT unzOpenCurrentFile2 OF((unzFile file,
265 int* method, 265 int* method,
266 int* level, 266 int* level,
267 int raw)); 267 int raw));
268/* 268/*
269 Same than unzOpenCurrentFile, but open for read raw the file (not uncompress) 269 Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
270 if raw==1 270 if raw==1
271 *method will receive method of compression, *level will receive level of 271 *method will receive method of compression, *level will receive level of
272 compression 272 compression
273 note : you can set level parameter as NULL (if you did not want known level, 273 note : you can set level parameter as NULL (if you did not want known level,
274 but you CANNOT set method parameter as NULL 274 but you CANNOT set method parameter as NULL
275*/ 275*/
276 276
277extern int ZEXPORT unzOpenCurrentFile3 OF((unzFile file, 277extern int ZEXPORT unzOpenCurrentFile3 OF((unzFile file,
278 int* method, 278 int* method,
279 int* level, 279 int* level,
280 int raw, 280 int raw,
281 const char* password)); 281 const char* password));
282/* 282/*
283 Same than unzOpenCurrentFile, but open for read raw the file (not uncompress) 283 Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
284 if raw==1 284 if raw==1
285 *method will receive method of compression, *level will receive level of 285 *method will receive method of compression, *level will receive level of
286 compression 286 compression
287 note : you can set level parameter as NULL (if you did not want known level, 287 note : you can set level parameter as NULL (if you did not want known level,
288 but you CANNOT set method parameter as NULL 288 but you CANNOT set method parameter as NULL
289*/ 289*/
290 290
291 291
292extern int ZEXPORT unzCloseCurrentFile OF((unzFile file)); 292extern int ZEXPORT unzCloseCurrentFile OF((unzFile file));
293/* 293/*
294 Close the file in zip opened with unzOpenCurrentFile 294 Close the file in zip opened with unzOpenCurrentFile
295 Return UNZ_CRCERROR if all the file was read but the CRC is not good 295 Return UNZ_CRCERROR if all the file was read but the CRC is not good
296*/ 296*/
297 297
298extern int ZEXPORT unzReadCurrentFile OF((unzFile file, 298extern int ZEXPORT unzReadCurrentFile OF((unzFile file,
299 voidp buf, 299 voidp buf,
300 unsigned len)); 300 unsigned len));
301/* 301/*
302 Read bytes from the current file (opened by unzOpenCurrentFile) 302 Read bytes from the current file (opened by unzOpenCurrentFile)
303 buf contain buffer where data must be copied 303 buf contain buffer where data must be copied
304 len the size of buf. 304 len the size of buf.
305 305
306 return the number of byte copied if somes bytes are copied 306 return the number of byte copied if somes bytes are copied
307 return 0 if the end of file was reached 307 return 0 if the end of file was reached
308 return <0 with error code if there is an error 308 return <0 with error code if there is an error
309 (UNZ_ERRNO for IO error, or zLib error for uncompress error) 309 (UNZ_ERRNO for IO error, or zLib error for uncompress error)
310*/ 310*/
311 311
312extern z_off_t ZEXPORT unztell OF((unzFile file)); 312extern z_off_t ZEXPORT unztell OF((unzFile file));
313/* 313/*
314 Give the current position in uncompressed data 314 Give the current position in uncompressed data
315*/ 315*/
316 316
317extern int ZEXPORT unzeof OF((unzFile file)); 317extern int ZEXPORT unzeof OF((unzFile file));
318/* 318/*
319 return 1 if the end of file was reached, 0 elsewhere 319 return 1 if the end of file was reached, 0 elsewhere
320*/ 320*/
321 321
322extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file, 322extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file,
323 voidp buf, 323 voidp buf,
324 unsigned len)); 324 unsigned len));
325/* 325/*
326 Read extra field from the current file (opened by unzOpenCurrentFile) 326 Read extra field from the current file (opened by unzOpenCurrentFile)
327 This is the local-header version of the extra field (sometimes, there is 327 This is the local-header version of the extra field (sometimes, there is
328 more info in the local-header version than in the central-header) 328 more info in the local-header version than in the central-header)
329 329
330 if buf==NULL, it return the size of the local extra field 330 if buf==NULL, it return the size of the local extra field
331 331
332 if buf!=NULL, len is the size of the buffer, the extra header is copied in 332 if buf!=NULL, len is the size of the buffer, the extra header is copied in
333 buf. 333 buf.
334 the return value is the number of bytes copied in buf, or (if <0) 334 the return value is the number of bytes copied in buf, or (if <0)
335 the error code 335 the error code
336*/ 336*/
337 337
338#ifdef __cplusplus 338#ifdef __cplusplus
339} 339}
340#endif 340#endif
341 341
342#endif /* _unz_H */ 342#endif /* _unz_H */
diff --git a/contrib/minizip/zip.c b/contrib/minizip/zip.c
index 00587fb..193c539 100644
--- a/contrib/minizip/zip.c
+++ b/contrib/minizip/zip.c
@@ -1,1168 +1,1168 @@
1/* zip.c -- IO on .zip files using zlib 1/* zip.c -- IO on .zip files using zlib
2 Version 0.22, May 19th, 2003 2 Version 0.22, May 19th, 2003
3 3
4 Read zip.h for more info 4 Read zip.h for more info
5*/ 5*/
6 6
7 7
8#include <stdio.h> 8#include <stdio.h>
9#include <stdlib.h> 9#include <stdlib.h>
10#include <string.h> 10#include <string.h>
11#include <time.h> 11#include <time.h>
12#include "zlib.h" 12#include "zlib.h"
13#include "zip.h" 13#include "zip.h"
14 14
15#ifdef STDC 15#ifdef STDC
16# include <stddef.h> 16# include <stddef.h>
17# include <string.h> 17# include <string.h>
18# include <stdlib.h> 18# include <stdlib.h>
19#endif 19#endif
20#ifdef NO_ERRNO_H 20#ifdef NO_ERRNO_H
21 extern int errno; 21 extern int errno;
22#else 22#else
23# include <errno.h> 23# include <errno.h>
24#endif 24#endif
25 25
26 26
27#ifndef local 27#ifndef local
28# define local static 28# define local static
29#endif 29#endif
30/* compile with -Dlocal if your debugger can't find static symbols */ 30/* compile with -Dlocal if your debugger can't find static symbols */
31 31
32#ifndef VERSIONMADEBY 32#ifndef VERSIONMADEBY
33# define VERSIONMADEBY (0x0) /* platform depedent */ 33# define VERSIONMADEBY (0x0) /* platform depedent */
34#endif 34#endif
35 35
36#ifndef Z_BUFSIZE 36#ifndef Z_BUFSIZE
37#define Z_BUFSIZE (16384) 37#define Z_BUFSIZE (16384)
38#endif 38#endif
39 39
40#ifndef Z_MAXFILENAMEINZIP 40#ifndef Z_MAXFILENAMEINZIP
41#define Z_MAXFILENAMEINZIP (256) 41#define Z_MAXFILENAMEINZIP (256)
42#endif 42#endif
43 43
44#ifndef ALLOC 44#ifndef ALLOC
45# define ALLOC(size) (malloc(size)) 45# define ALLOC(size) (malloc(size))
46#endif 46#endif
47#ifndef TRYFREE 47#ifndef TRYFREE
48# define TRYFREE(p) {if (p) free(p);} 48# define TRYFREE(p) {if (p) free(p);}
49#endif 49#endif
50 50
51/* 51/*
52#define SIZECENTRALDIRITEM (0x2e) 52#define SIZECENTRALDIRITEM (0x2e)
53#define SIZEZIPLOCALHEADER (0x1e) 53#define SIZEZIPLOCALHEADER (0x1e)
54*/ 54*/
55 55
56/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */ 56/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
57 57
58#ifndef SEEK_CUR 58#ifndef SEEK_CUR
59#define SEEK_CUR 1 59#define SEEK_CUR 1
60#endif 60#endif
61 61
62#ifndef SEEK_END 62#ifndef SEEK_END
63#define SEEK_END 2 63#define SEEK_END 2
64#endif 64#endif
65 65
66#ifndef SEEK_SET 66#ifndef SEEK_SET
67#define SEEK_SET 0 67#define SEEK_SET 0
68#endif 68#endif
69 69
70#ifndef DEF_MEM_LEVEL 70#ifndef DEF_MEM_LEVEL
71#if MAX_MEM_LEVEL >= 8 71#if MAX_MEM_LEVEL >= 8
72# define DEF_MEM_LEVEL 8 72# define DEF_MEM_LEVEL 8
73#else 73#else
74# define DEF_MEM_LEVEL MAX_MEM_LEVEL 74# define DEF_MEM_LEVEL MAX_MEM_LEVEL
75#endif 75#endif
76#endif 76#endif
77const char zip_copyright[] = 77const char zip_copyright[] =
78 " zip 0.22 Copyright 1998-2003 Gilles Vollant - http://www.winimage.com/zLibDll"; 78 " zip 0.22 Copyright 1998-2003 Gilles Vollant - http://www.winimage.com/zLibDll";
79 79
80 80
81#define SIZEDATA_INDATABLOCK (4096-(4*4)) 81#define SIZEDATA_INDATABLOCK (4096-(4*4))
82 82
83#define LOCALHEADERMAGIC (0x04034b50) 83#define LOCALHEADERMAGIC (0x04034b50)
84#define CENTRALHEADERMAGIC (0x02014b50) 84#define CENTRALHEADERMAGIC (0x02014b50)
85#define ENDHEADERMAGIC (0x06054b50) 85#define ENDHEADERMAGIC (0x06054b50)
86 86
87#define FLAG_LOCALHEADER_OFFSET (0x06) 87#define FLAG_LOCALHEADER_OFFSET (0x06)
88#define CRC_LOCALHEADER_OFFSET (0x0e) 88#define CRC_LOCALHEADER_OFFSET (0x0e)
89 89
90#define SIZECENTRALHEADER (0x2e) /* 46 */ 90#define SIZECENTRALHEADER (0x2e) /* 46 */
91 91
92typedef struct linkedlist_datablock_internal_s 92typedef struct linkedlist_datablock_internal_s
93{ 93{
94 struct linkedlist_datablock_internal_s* next_datablock; 94 struct linkedlist_datablock_internal_s* next_datablock;
95 uLong avail_in_this_block; 95 uLong avail_in_this_block;
96 uLong filled_in_this_block; 96 uLong filled_in_this_block;
97 uLong unused; /* for future use and alignement */ 97 uLong unused; /* for future use and alignement */
98 unsigned char data[SIZEDATA_INDATABLOCK]; 98 unsigned char data[SIZEDATA_INDATABLOCK];
99} linkedlist_datablock_internal; 99} linkedlist_datablock_internal;
100 100
101typedef struct linkedlist_data_s 101typedef struct linkedlist_data_s
102{ 102{
103 linkedlist_datablock_internal* first_block; 103 linkedlist_datablock_internal* first_block;
104 linkedlist_datablock_internal* last_block; 104 linkedlist_datablock_internal* last_block;
105} linkedlist_data; 105} linkedlist_data;
106 106
107 107
108typedef struct 108typedef struct
109{ 109{
110 z_stream stream; /* zLib stream structure for inflate */ 110 z_stream stream; /* zLib stream structure for inflate */
111 int stream_initialised; /* 1 is stream is initialised */ 111 int stream_initialised; /* 1 is stream is initialised */
112 uInt pos_in_buffered_data; /* last written byte in buffered_data */ 112 uInt pos_in_buffered_data; /* last written byte in buffered_data */
113 113
114 uLong pos_local_header; /* offset of the local header of the file 114 uLong pos_local_header; /* offset of the local header of the file
115 currenty writing */ 115 currenty writing */
116 char* central_header; /* central header data for the current file */ 116 char* central_header; /* central header data for the current file */
117 uLong size_centralheader; /* size of the central header for cur file */ 117 uLong size_centralheader; /* size of the central header for cur file */
118 uLong flag; /* flag of the file currently writing */ 118 uLong flag; /* flag of the file currently writing */
119 119
120 int method; /* compression method of file currenty wr.*/ 120 int method; /* compression method of file currenty wr.*/
121 int raw; /* 1 for directly writing raw data */ 121 int raw; /* 1 for directly writing raw data */
122 Byte buffered_data[Z_BUFSIZE];/* buffer contain compressed data to be writ*/ 122 Byte buffered_data[Z_BUFSIZE];/* buffer contain compressed data to be writ*/
123 uLong dosDate; 123 uLong dosDate;
124 uLong crc32; 124 uLong crc32;
125 int encrypt; 125 int encrypt;
126#ifndef NOCRYPT 126#ifndef NOCRYPT
127 unsigned long keys[3]; /* keys defining the pseudo-random sequence */ 127 unsigned long keys[3]; /* keys defining the pseudo-random sequence */
128 const unsigned long* pcrc_32_tab; 128 const unsigned long* pcrc_32_tab;
129 int crypt_header_size; 129 int crypt_header_size;
130#endif 130#endif
131} curfile_info; 131} curfile_info;
132 132
133typedef struct 133typedef struct
134{ 134{
135 zlib_filefunc_def z_filefunc; 135 zlib_filefunc_def z_filefunc;
136 voidpf filestream; /* io structore of the zipfile */ 136 voidpf filestream; /* io structore of the zipfile */
137 linkedlist_data central_dir;/* datablock with central dir in construction*/ 137 linkedlist_data central_dir;/* datablock with central dir in construction*/
138 int in_opened_file_inzip; /* 1 if a file in the zip is currently writ.*/ 138 int in_opened_file_inzip; /* 1 if a file in the zip is currently writ.*/
139 curfile_info ci; /* info on the file curretly writing */ 139 curfile_info ci; /* info on the file curretly writing */
140 140
141 uLong begin_pos; /* position of the beginning of the zipfile */ 141 uLong begin_pos; /* position of the beginning of the zipfile */
142 uLong add_position_when_writting_offset; 142 uLong add_position_when_writting_offset;
143 uLong number_entry; 143 uLong number_entry;
144} zip_internal; 144} zip_internal;
145 145
146 146
147 147
148#ifndef NOCRYPT 148#ifndef NOCRYPT
149#define INCLUDECRYPTINGCODE_IFCRYPTALLOWED 149#define INCLUDECRYPTINGCODE_IFCRYPTALLOWED
150#include "crypt.h" 150#include "crypt.h"
151#endif 151#endif
152 152
153local linkedlist_datablock_internal* allocate_new_datablock() 153local linkedlist_datablock_internal* allocate_new_datablock()
154{ 154{
155 linkedlist_datablock_internal* ldi; 155 linkedlist_datablock_internal* ldi;
156 ldi = (linkedlist_datablock_internal*) 156 ldi = (linkedlist_datablock_internal*)
157 ALLOC(sizeof(linkedlist_datablock_internal)); 157 ALLOC(sizeof(linkedlist_datablock_internal));
158 if (ldi!=NULL) 158 if (ldi!=NULL)
159 { 159 {
160 ldi->next_datablock = NULL ; 160 ldi->next_datablock = NULL ;
161 ldi->filled_in_this_block = 0 ; 161 ldi->filled_in_this_block = 0 ;
162 ldi->avail_in_this_block = SIZEDATA_INDATABLOCK ; 162 ldi->avail_in_this_block = SIZEDATA_INDATABLOCK ;
163 } 163 }
164 return ldi; 164 return ldi;
165} 165}
166 166
167local void free_datablock(ldi) 167local void free_datablock(ldi)
168 linkedlist_datablock_internal* ldi; 168 linkedlist_datablock_internal* ldi;
169{ 169{
170 while (ldi!=NULL) 170 while (ldi!=NULL)
171 { 171 {
172 linkedlist_datablock_internal* ldinext = ldi->next_datablock; 172 linkedlist_datablock_internal* ldinext = ldi->next_datablock;
173 TRYFREE(ldi); 173 TRYFREE(ldi);
174 ldi = ldinext; 174 ldi = ldinext;
175 } 175 }
176} 176}
177 177
178local void init_linkedlist(ll) 178local void init_linkedlist(ll)
179 linkedlist_data* ll; 179 linkedlist_data* ll;
180{ 180{
181 ll->first_block = ll->last_block = NULL; 181 ll->first_block = ll->last_block = NULL;
182} 182}
183 183
184local void free_linkedlist(ll) 184local void free_linkedlist(ll)
185 linkedlist_data* ll; 185 linkedlist_data* ll;
186{ 186{
187 free_datablock(ll->first_block); 187 free_datablock(ll->first_block);
188 ll->first_block = ll->last_block = NULL; 188 ll->first_block = ll->last_block = NULL;
189} 189}
190 190
191 191
192local int add_data_in_datablock(ll,buf,len) 192local int add_data_in_datablock(ll,buf,len)
193 linkedlist_data* ll; 193 linkedlist_data* ll;
194 const void* buf; 194 const void* buf;
195 uLong len; 195 uLong len;
196{ 196{
197 linkedlist_datablock_internal* ldi; 197 linkedlist_datablock_internal* ldi;
198 const unsigned char* from_copy; 198 const unsigned char* from_copy;
199 199
200 if (ll==NULL) 200 if (ll==NULL)
201 return ZIP_INTERNALERROR; 201 return ZIP_INTERNALERROR;
202 202
203 if (ll->last_block == NULL) 203 if (ll->last_block == NULL)
204 { 204 {
205 ll->first_block = ll->last_block = allocate_new_datablock(); 205 ll->first_block = ll->last_block = allocate_new_datablock();
206 if (ll->first_block == NULL) 206 if (ll->first_block == NULL)
207 return ZIP_INTERNALERROR; 207 return ZIP_INTERNALERROR;
208 } 208 }
209 209
210 ldi = ll->last_block; 210 ldi = ll->last_block;
211 from_copy = (unsigned char*)buf; 211 from_copy = (unsigned char*)buf;
212 212
213 while (len>0) 213 while (len>0)
214 { 214 {
215 uInt copy_this; 215 uInt copy_this;
216 uInt i; 216 uInt i;
217 unsigned char* to_copy; 217 unsigned char* to_copy;
218 218
219 if (ldi->avail_in_this_block==0) 219 if (ldi->avail_in_this_block==0)
220 { 220 {
221 ldi->next_datablock = allocate_new_datablock(); 221 ldi->next_datablock = allocate_new_datablock();
222 if (ldi->next_datablock == NULL) 222 if (ldi->next_datablock == NULL)
223 return ZIP_INTERNALERROR; 223 return ZIP_INTERNALERROR;
224 ldi = ldi->next_datablock ; 224 ldi = ldi->next_datablock ;
225 ll->last_block = ldi; 225 ll->last_block = ldi;
226 } 226 }
227 227
228 if (ldi->avail_in_this_block < len) 228 if (ldi->avail_in_this_block < len)
229 copy_this = (uInt)ldi->avail_in_this_block; 229 copy_this = (uInt)ldi->avail_in_this_block;
230 else 230 else
231 copy_this = (uInt)len; 231 copy_this = (uInt)len;
232 232
233 to_copy = &(ldi->data[ldi->filled_in_this_block]); 233 to_copy = &(ldi->data[ldi->filled_in_this_block]);
234 234
235 for (i=0;i<copy_this;i++) 235 for (i=0;i<copy_this;i++)
236 *(to_copy+i)=*(from_copy+i); 236 *(to_copy+i)=*(from_copy+i);
237 237
238 ldi->filled_in_this_block += copy_this; 238 ldi->filled_in_this_block += copy_this;
239 ldi->avail_in_this_block -= copy_this; 239 ldi->avail_in_this_block -= copy_this;
240 from_copy += copy_this ; 240 from_copy += copy_this ;
241 len -= copy_this; 241 len -= copy_this;
242 } 242 }
243 return ZIP_OK; 243 return ZIP_OK;
244} 244}
245 245
246 246
247 247
248/****************************************************************************/ 248/****************************************************************************/
249 249
250#ifndef NO_ADDFILEINEXISTINGZIP 250#ifndef NO_ADDFILEINEXISTINGZIP
251/* =========================================================================== 251/* ===========================================================================
252 Inputs a long in LSB order to the given file 252 Inputs a long in LSB order to the given file
253 nbByte == 1, 2 or 4 (byte, short or long) 253 nbByte == 1, 2 or 4 (byte, short or long)
254*/ 254*/
255 255
256local int ziplocal_putValue OF((const zlib_filefunc_def* pzlib_filefunc_def, 256local int ziplocal_putValue OF((const zlib_filefunc_def* pzlib_filefunc_def,
257 voidpf filestream, uLong x, int nbByte)); 257 voidpf filestream, uLong x, int nbByte));
258local int ziplocal_putValue (pzlib_filefunc_def, filestream, x, nbByte) 258local int ziplocal_putValue (pzlib_filefunc_def, filestream, x, nbByte)
259 const zlib_filefunc_def* pzlib_filefunc_def; 259 const zlib_filefunc_def* pzlib_filefunc_def;
260 voidpf filestream; 260 voidpf filestream;
261 uLong x; 261 uLong x;
262 int nbByte; 262 int nbByte;
263{ 263{
264 unsigned char buf[4]; 264 unsigned char buf[4];
265 int n; 265 int n;
266 for (n = 0; n < nbByte; n++) { 266 for (n = 0; n < nbByte; n++) {
267 buf[n] = (unsigned char)(x & 0xff); 267 buf[n] = (unsigned char)(x & 0xff);
268 x >>= 8; 268 x >>= 8;
269 } 269 }
270 if (ZWRITE(*pzlib_filefunc_def,filestream,buf,nbByte)!=(uLong)nbByte) 270 if (ZWRITE(*pzlib_filefunc_def,filestream,buf,nbByte)!=(uLong)nbByte)
271 return ZIP_ERRNO; 271 return ZIP_ERRNO;
272 else 272 else
273 return ZIP_OK; 273 return ZIP_OK;
274} 274}
275 275
276local void ziplocal_putValue_inmemory OF((void* dest, uLong x, int nbByte)); 276local void ziplocal_putValue_inmemory OF((void* dest, uLong x, int nbByte));
277local void ziplocal_putValue_inmemory (dest, x, nbByte) 277local void ziplocal_putValue_inmemory (dest, x, nbByte)
278 void* dest; 278 void* dest;
279 uLong x; 279 uLong x;
280 int nbByte; 280 int nbByte;
281{ 281{
282 unsigned char* buf=(unsigned char*)dest; 282 unsigned char* buf=(unsigned char*)dest;
283 int n; 283 int n;
284 for (n = 0; n < nbByte; n++) { 284 for (n = 0; n < nbByte; n++) {
285 buf[n] = (unsigned char)(x & 0xff); 285 buf[n] = (unsigned char)(x & 0xff);
286 x >>= 8; 286 x >>= 8;
287 } 287 }
288} 288}
289/****************************************************************************/ 289/****************************************************************************/
290 290
291 291
292local uLong ziplocal_TmzDateToDosDate(ptm,dosDate) 292local uLong ziplocal_TmzDateToDosDate(ptm,dosDate)
293 const tm_zip* ptm; 293 const tm_zip* ptm;
294 uLong dosDate; 294 uLong dosDate;
295{ 295{
296 uLong year = (uLong)ptm->tm_year; 296 uLong year = (uLong)ptm->tm_year;
297 if (year>1980) 297 if (year>1980)
298 year-=1980; 298 year-=1980;
299 else if (year>80) 299 else if (year>80)
300 year-=80; 300 year-=80;
301 return 301 return
302 (uLong) (((ptm->tm_mday) + (32 * (ptm->tm_mon+1)) + (512 * year)) << 16) | 302 (uLong) (((ptm->tm_mday) + (32 * (ptm->tm_mon+1)) + (512 * year)) << 16) |
303 ((ptm->tm_sec/2) + (32* ptm->tm_min) + (2048 * (uLong)ptm->tm_hour)); 303 ((ptm->tm_sec/2) + (32* ptm->tm_min) + (2048 * (uLong)ptm->tm_hour));
304} 304}
305 305
306 306
307/****************************************************************************/ 307/****************************************************************************/
308 308
309local int ziplocal_getByte OF(( 309local int ziplocal_getByte OF((
310 const zlib_filefunc_def* pzlib_filefunc_def, 310 const zlib_filefunc_def* pzlib_filefunc_def,
311 voidpf filestream, 311 voidpf filestream,
312 int *pi)); 312 int *pi));
313 313
314local int ziplocal_getByte(pzlib_filefunc_def,filestream,pi) 314local int ziplocal_getByte(pzlib_filefunc_def,filestream,pi)
315 const zlib_filefunc_def* pzlib_filefunc_def; 315 const zlib_filefunc_def* pzlib_filefunc_def;
316 voidpf filestream; 316 voidpf filestream;
317 int *pi; 317 int *pi;
318{ 318{
319 unsigned char c; 319 unsigned char c;
320 int err = (int)ZREAD(*pzlib_filefunc_def,filestream,&c,1); 320 int err = (int)ZREAD(*pzlib_filefunc_def,filestream,&c,1);
321 if (err==1) 321 if (err==1)
322 { 322 {
323 *pi = (int)c; 323 *pi = (int)c;
324 return ZIP_OK; 324 return ZIP_OK;
325 } 325 }
326 else 326 else
327 { 327 {
328 if (ZERROR(*pzlib_filefunc_def,filestream)) 328 if (ZERROR(*pzlib_filefunc_def,filestream))
329 return ZIP_ERRNO; 329 return ZIP_ERRNO;
330 else 330 else
331 return ZIP_EOF; 331 return ZIP_EOF;
332 } 332 }
333} 333}
334 334
335 335
336/* =========================================================================== 336/* ===========================================================================
337 Reads a long in LSB order from the given gz_stream. Sets 337 Reads a long in LSB order from the given gz_stream. Sets
338*/ 338*/
339local int ziplocal_getShort OF(( 339local int ziplocal_getShort OF((
340 const zlib_filefunc_def* pzlib_filefunc_def, 340 const zlib_filefunc_def* pzlib_filefunc_def,
341 voidpf filestream, 341 voidpf filestream,
342 uLong *pX)); 342 uLong *pX));
343 343
344local int ziplocal_getShort (pzlib_filefunc_def,filestream,pX) 344local int ziplocal_getShort (pzlib_filefunc_def,filestream,pX)
345 const zlib_filefunc_def* pzlib_filefunc_def; 345 const zlib_filefunc_def* pzlib_filefunc_def;
346 voidpf filestream; 346 voidpf filestream;
347 uLong *pX; 347 uLong *pX;
348{ 348{
349 uLong x ; 349 uLong x ;
350 int i; 350 int i;
351 int err; 351 int err;
352 352
353 err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); 353 err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
354 x = (uLong)i; 354 x = (uLong)i;
355 355
356 if (err==ZIP_OK) 356 if (err==ZIP_OK)
357 err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); 357 err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
358 x += ((uLong)i)<<8; 358 x += ((uLong)i)<<8;
359 359
360 if (err==ZIP_OK) 360 if (err==ZIP_OK)
361 *pX = x; 361 *pX = x;
362 else 362 else
363 *pX = 0; 363 *pX = 0;
364 return err; 364 return err;
365} 365}
366 366
367local int ziplocal_getLong OF(( 367local int ziplocal_getLong OF((
368 const zlib_filefunc_def* pzlib_filefunc_def, 368 const zlib_filefunc_def* pzlib_filefunc_def,
369 voidpf filestream, 369 voidpf filestream,
370 uLong *pX)); 370 uLong *pX));
371 371
372local int ziplocal_getLong (pzlib_filefunc_def,filestream,pX) 372local int ziplocal_getLong (pzlib_filefunc_def,filestream,pX)
373 const zlib_filefunc_def* pzlib_filefunc_def; 373 const zlib_filefunc_def* pzlib_filefunc_def;
374 voidpf filestream; 374 voidpf filestream;
375 uLong *pX; 375 uLong *pX;
376{ 376{
377 uLong x ; 377 uLong x ;
378 int i; 378 int i;
379 int err; 379 int err;
380 380
381 err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); 381 err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
382 x = (uLong)i; 382 x = (uLong)i;
383 383
384 if (err==ZIP_OK) 384 if (err==ZIP_OK)
385 err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); 385 err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
386 x += ((uLong)i)<<8; 386 x += ((uLong)i)<<8;
387 387
388 if (err==ZIP_OK) 388 if (err==ZIP_OK)
389 err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); 389 err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
390 x += ((uLong)i)<<16; 390 x += ((uLong)i)<<16;
391 391
392 if (err==ZIP_OK) 392 if (err==ZIP_OK)
393 err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); 393 err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
394 x += ((uLong)i)<<24; 394 x += ((uLong)i)<<24;
395 395
396 if (err==ZIP_OK) 396 if (err==ZIP_OK)
397 *pX = x; 397 *pX = x;
398 else 398 else
399 *pX = 0; 399 *pX = 0;
400 return err; 400 return err;
401} 401}
402 402
403#ifndef BUFREADCOMMENT 403#ifndef BUFREADCOMMENT
404#define BUFREADCOMMENT (0x400) 404#define BUFREADCOMMENT (0x400)
405#endif 405#endif
406/* 406/*
407 Locate the Central directory of a zipfile (at the end, just before 407 Locate the Central directory of a zipfile (at the end, just before
408 the global comment) 408 the global comment)
409*/ 409*/
410local uLong ziplocal_SearchCentralDir OF(( 410local uLong ziplocal_SearchCentralDir OF((
411 const zlib_filefunc_def* pzlib_filefunc_def, 411 const zlib_filefunc_def* pzlib_filefunc_def,
412 voidpf filestream)); 412 voidpf filestream));
413 413
414local uLong ziplocal_SearchCentralDir(pzlib_filefunc_def,filestream) 414local uLong ziplocal_SearchCentralDir(pzlib_filefunc_def,filestream)
415 const zlib_filefunc_def* pzlib_filefunc_def; 415 const zlib_filefunc_def* pzlib_filefunc_def;
416 voidpf filestream; 416 voidpf filestream;
417{ 417{
418 unsigned char* buf; 418 unsigned char* buf;
419 uLong uSizeFile; 419 uLong uSizeFile;
420 uLong uBackRead; 420 uLong uBackRead;
421 uLong uMaxBack=0xffff; /* maximum size of global comment */ 421 uLong uMaxBack=0xffff; /* maximum size of global comment */
422 uLong uPosFound=0; 422 uLong uPosFound=0;
423 423
424 if (ZSEEK(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0) 424 if (ZSEEK(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
425 return 0; 425 return 0;
426 426
427 427
428 uSizeFile = ZTELL(*pzlib_filefunc_def,filestream); 428 uSizeFile = ZTELL(*pzlib_filefunc_def,filestream);
429 429
430 if (uMaxBack>uSizeFile) 430 if (uMaxBack>uSizeFile)
431 uMaxBack = uSizeFile; 431 uMaxBack = uSizeFile;
432 432
433 buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4); 433 buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
434 if (buf==NULL) 434 if (buf==NULL)
435 return 0; 435 return 0;
436 436
437 uBackRead = 4; 437 uBackRead = 4;
438 while (uBackRead<uMaxBack) 438 while (uBackRead<uMaxBack)
439 { 439 {
440 uLong uReadSize,uReadPos ; 440 uLong uReadSize,uReadPos ;
441 int i; 441 int i;
442 if (uBackRead+BUFREADCOMMENT>uMaxBack) 442 if (uBackRead+BUFREADCOMMENT>uMaxBack)
443 uBackRead = uMaxBack; 443 uBackRead = uMaxBack;
444 else 444 else
445 uBackRead+=BUFREADCOMMENT; 445 uBackRead+=BUFREADCOMMENT;
446 uReadPos = uSizeFile-uBackRead ; 446 uReadPos = uSizeFile-uBackRead ;
447 447
448 uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ? 448 uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
449 (BUFREADCOMMENT+4) : (uSizeFile-uReadPos); 449 (BUFREADCOMMENT+4) : (uSizeFile-uReadPos);
450 if (ZSEEK(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0) 450 if (ZSEEK(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
451 break; 451 break;
452 452
453 if (ZREAD(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize) 453 if (ZREAD(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
454 break; 454 break;
455 455
456 for (i=(int)uReadSize-3; (i--)>0;) 456 for (i=(int)uReadSize-3; (i--)>0;)
457 if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && 457 if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
458 ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06)) 458 ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
459 { 459 {
460 uPosFound = uReadPos+i; 460 uPosFound = uReadPos+i;
461 break; 461 break;
462 } 462 }
463 463
464 if (uPosFound!=0) 464 if (uPosFound!=0)
465 break; 465 break;
466 } 466 }
467 TRYFREE(buf); 467 TRYFREE(buf);
468 return uPosFound; 468 return uPosFound;
469} 469}
470#endif /* !NO_ADDFILEINEXISTINGZIP*/ 470#endif /* !NO_ADDFILEINEXISTINGZIP*/
471 471
472/************************************************************/ 472/************************************************************/
473extern zipFile ZEXPORT zipOpen2 (pathname, append, globalcomment, pzlib_filefunc_def) 473extern zipFile ZEXPORT zipOpen2 (pathname, append, globalcomment, pzlib_filefunc_def)
474 const char *pathname; 474 const char *pathname;
475 int append; 475 int append;
476 zipcharpc* globalcomment; 476 zipcharpc* globalcomment;
477 zlib_filefunc_def* pzlib_filefunc_def; 477 zlib_filefunc_def* pzlib_filefunc_def;
478{ 478{
479 zip_internal ziinit; 479 zip_internal ziinit;
480 zip_internal* zi; 480 zip_internal* zi;
481 int err=ZIP_OK; 481 int err=ZIP_OK;
482 482
483 483
484 if (pzlib_filefunc_def==NULL) 484 if (pzlib_filefunc_def==NULL)
485 fill_fopen_filefunc(&ziinit.z_filefunc); 485 fill_fopen_filefunc(&ziinit.z_filefunc);
486 else 486 else
487 ziinit.z_filefunc = *pzlib_filefunc_def; 487 ziinit.z_filefunc = *pzlib_filefunc_def;
488 488
489 ziinit.filestream = (*(ziinit.z_filefunc.zopen_file)) 489 ziinit.filestream = (*(ziinit.z_filefunc.zopen_file))
490 (ziinit.z_filefunc.opaque, 490 (ziinit.z_filefunc.opaque,
491 pathname, 491 pathname,
492 (append == APPEND_STATUS_CREATE) ? 492 (append == APPEND_STATUS_CREATE) ?
493 (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE) : 493 (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE) :
494 (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING)); 494 (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING));
495 495
496 if (ziinit.filestream == NULL) 496 if (ziinit.filestream == NULL)
497 return NULL; 497 return NULL;
498 ziinit.begin_pos = ZTELL(ziinit.z_filefunc,ziinit.filestream); 498 ziinit.begin_pos = ZTELL(ziinit.z_filefunc,ziinit.filestream);
499 ziinit.in_opened_file_inzip = 0; 499 ziinit.in_opened_file_inzip = 0;
500 ziinit.ci.stream_initialised = 0; 500 ziinit.ci.stream_initialised = 0;
501 ziinit.number_entry = 0; 501 ziinit.number_entry = 0;
502 ziinit.add_position_when_writting_offset = 0; 502 ziinit.add_position_when_writting_offset = 0;
503 init_linkedlist(&(ziinit.central_dir)); 503 init_linkedlist(&(ziinit.central_dir));
504 504
505 505
506 zi = (zip_internal*)ALLOC(sizeof(zip_internal)); 506 zi = (zip_internal*)ALLOC(sizeof(zip_internal));
507 if (zi==NULL) 507 if (zi==NULL)
508 { 508 {
509 ZCLOSE(ziinit.z_filefunc,ziinit.filestream); 509 ZCLOSE(ziinit.z_filefunc,ziinit.filestream);
510 return NULL; 510 return NULL;
511 } 511 }
512 512
513 /* now we add file in a zipfile */ 513 /* now we add file in a zipfile */
514 #ifndef NO_ADDFILEINEXISTINGZIP 514# ifndef NO_ADDFILEINEXISTINGZIP
515 if (append == APPEND_STATUS_ADDINZIP) 515 if (append == APPEND_STATUS_ADDINZIP)
516 { 516 {
517 uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/ 517 uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
518 518
519 uLong size_central_dir; /* size of the central directory */ 519 uLong size_central_dir; /* size of the central directory */
520 uLong offset_central_dir; /* offset of start of central directory */ 520 uLong offset_central_dir; /* offset of start of central directory */
521 uLong central_pos,uL; 521 uLong central_pos,uL;
522 522
523 uLong number_disk; /* number of the current dist, used for 523 uLong number_disk; /* number of the current dist, used for
524 spaning ZIP, unsupported, always 0*/ 524 spaning ZIP, unsupported, always 0*/
525 uLong number_disk_with_CD; /* number the the disk with central dir, used 525 uLong number_disk_with_CD; /* number the the disk with central dir, used
526 for spaning ZIP, unsupported, always 0*/ 526 for spaning ZIP, unsupported, always 0*/
527 uLong number_entry; 527 uLong number_entry;
528 uLong number_entry_CD; /* total number of entries in 528 uLong number_entry_CD; /* total number of entries in
529 the central dir 529 the central dir
530 (same than number_entry on nospan) */ 530 (same than number_entry on nospan) */
531 uLong size_comment; 531 uLong size_comment;
532 532
533 central_pos = ziplocal_SearchCentralDir(&ziinit.z_filefunc,ziinit.filestream); 533 central_pos = ziplocal_SearchCentralDir(&ziinit.z_filefunc,ziinit.filestream);
534 if (central_pos==0) 534 if (central_pos==0)
535 err=ZIP_ERRNO; 535 err=ZIP_ERRNO;
536 536
537 if (ZSEEK(ziinit.z_filefunc, ziinit.filestream, 537 if (ZSEEK(ziinit.z_filefunc, ziinit.filestream,
538 central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0) 538 central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
539 err=ZIP_ERRNO; 539 err=ZIP_ERRNO;
540 540
541 /* the signature, already checked */ 541 /* the signature, already checked */
542 if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&uL)!=ZIP_OK) 542 if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&uL)!=ZIP_OK)
543 err=ZIP_ERRNO; 543 err=ZIP_ERRNO;
544 544
545 /* number of this disk */ 545 /* number of this disk */
546 if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_disk)!=ZIP_OK) 546 if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_disk)!=ZIP_OK)
547 err=ZIP_ERRNO; 547 err=ZIP_ERRNO;
548 548
549 /* number of the disk with the start of the central directory */ 549 /* number of the disk with the start of the central directory */
550 if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_disk_with_CD)!=ZIP_OK) 550 if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_disk_with_CD)!=ZIP_OK)
551 err=ZIP_ERRNO; 551 err=ZIP_ERRNO;
552 552
553 /* total number of entries in the central dir on this disk */ 553 /* total number of entries in the central dir on this disk */
554 if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_entry)!=ZIP_OK) 554 if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_entry)!=ZIP_OK)
555 err=ZIP_ERRNO; 555 err=ZIP_ERRNO;
556 556
557 /* total number of entries in the central dir */ 557 /* total number of entries in the central dir */
558 if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_entry_CD)!=ZIP_OK) 558 if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_entry_CD)!=ZIP_OK)
559 err=ZIP_ERRNO; 559 err=ZIP_ERRNO;
560 560
561 if ((number_entry_CD!=number_entry) || 561 if ((number_entry_CD!=number_entry) ||
562 (number_disk_with_CD!=0) || 562 (number_disk_with_CD!=0) ||
563 (number_disk!=0)) 563 (number_disk!=0))
564 err=ZIP_BADZIPFILE; 564 err=ZIP_BADZIPFILE;
565 565
566 /* size of the central directory */ 566 /* size of the central directory */
567 if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&size_central_dir)!=ZIP_OK) 567 if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&size_central_dir)!=ZIP_OK)
568 err=ZIP_ERRNO; 568 err=ZIP_ERRNO;
569 569
570 /* offset of start of central directory with respect to the 570 /* offset of start of central directory with respect to the
571 starting disk number */ 571 starting disk number */
572 if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&offset_central_dir)!=ZIP_OK) 572 if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&offset_central_dir)!=ZIP_OK)
573 err=ZIP_ERRNO; 573 err=ZIP_ERRNO;
574 574
575 /* zipfile comment length */ 575 /* zipfile comment length */
576 if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&size_comment)!=ZIP_OK) 576 if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&size_comment)!=ZIP_OK)
577 err=ZIP_ERRNO; 577 err=ZIP_ERRNO;
578 578
579 if ((central_pos<offset_central_dir+size_central_dir) && 579 if ((central_pos<offset_central_dir+size_central_dir) &&
580 (err==ZIP_OK)) 580 (err==ZIP_OK))
581 err=ZIP_BADZIPFILE; 581 err=ZIP_BADZIPFILE;
582 582
583 if (err!=ZIP_OK) 583 if (err!=ZIP_OK)
584 { 584 {
585 ZCLOSE(ziinit.z_filefunc, ziinit.filestream); 585 ZCLOSE(ziinit.z_filefunc, ziinit.filestream);
586 return NULL; 586 return NULL;
587 } 587 }
588 588
589 byte_before_the_zipfile = central_pos - 589 byte_before_the_zipfile = central_pos -
590 (offset_central_dir+size_central_dir); 590 (offset_central_dir+size_central_dir);
591 ziinit.add_position_when_writting_offset = byte_before_the_zipfile ; 591 ziinit.add_position_when_writting_offset = byte_before_the_zipfile ;
592 592
593 { 593 {
594 uLong size_central_dir_to_read = size_central_dir; 594 uLong size_central_dir_to_read = size_central_dir;
595 size_t buf_size = SIZEDATA_INDATABLOCK; 595 size_t buf_size = SIZEDATA_INDATABLOCK;
596 void* buf_read = (void*)ALLOC(buf_size); 596 void* buf_read = (void*)ALLOC(buf_size);
597 if (ZSEEK(ziinit.z_filefunc, ziinit.filestream, 597 if (ZSEEK(ziinit.z_filefunc, ziinit.filestream,
598 offset_central_dir + byte_before_the_zipfile, 598 offset_central_dir + byte_before_the_zipfile,
599 ZLIB_FILEFUNC_SEEK_SET) != 0) 599 ZLIB_FILEFUNC_SEEK_SET) != 0)
600 err=ZIP_ERRNO; 600 err=ZIP_ERRNO;
601 601
602 while ((size_central_dir_to_read>0) && (err==ZIP_OK)) 602 while ((size_central_dir_to_read>0) && (err==ZIP_OK))
603 { 603 {
604 uLong read_this = SIZEDATA_INDATABLOCK; 604 uLong read_this = SIZEDATA_INDATABLOCK;
605 if (read_this > size_central_dir_to_read) 605 if (read_this > size_central_dir_to_read)
606 read_this = size_central_dir_to_read; 606 read_this = size_central_dir_to_read;
607 if (ZREAD(ziinit.z_filefunc, ziinit.filestream,buf_read,read_this) != read_this) 607 if (ZREAD(ziinit.z_filefunc, ziinit.filestream,buf_read,read_this) != read_this)
608 err=ZIP_ERRNO; 608 err=ZIP_ERRNO;
609 609
610 if (err==ZIP_OK) 610 if (err==ZIP_OK)
611 err = add_data_in_datablock(&ziinit.central_dir,buf_read, 611 err = add_data_in_datablock(&ziinit.central_dir,buf_read,
612 (uLong)read_this); 612 (uLong)read_this);
613 size_central_dir_to_read-=read_this; 613 size_central_dir_to_read-=read_this;
614 } 614 }
615 TRYFREE(buf_read); 615 TRYFREE(buf_read);
616 } 616 }
617 ziinit.begin_pos = byte_before_the_zipfile; 617 ziinit.begin_pos = byte_before_the_zipfile;
618 ziinit.number_entry = number_entry_CD; 618 ziinit.number_entry = number_entry_CD;
619 619
620 if (ZSEEK(ziinit.z_filefunc, ziinit.filestream, 620 if (ZSEEK(ziinit.z_filefunc, ziinit.filestream,
621 offset_central_dir+byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0) 621 offset_central_dir+byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0)
622 err=ZIP_ERRNO; 622 err=ZIP_ERRNO;
623 } 623 }
624 #endif /* !NO_ADDFILEINEXISTINGZIP*/ 624# endif /* !NO_ADDFILEINEXISTINGZIP*/
625 625
626 if (err != ZIP_OK) 626 if (err != ZIP_OK)
627 { 627 {
628 TRYFREE(zi); 628 TRYFREE(zi);
629 return NULL; 629 return NULL;
630 } 630 }
631 else 631 else
632 { 632 {
633 *zi = ziinit; 633 *zi = ziinit;
634 return (zipFile)zi; 634 return (zipFile)zi;
635 } 635 }
636} 636}
637 637
638extern zipFile ZEXPORT zipOpen (pathname, append) 638extern zipFile ZEXPORT zipOpen (pathname, append)
639 const char *pathname; 639 const char *pathname;
640 int append; 640 int append;
641{ 641{
642 return zipOpen2(pathname,append,NULL,NULL); 642 return zipOpen2(pathname,append,NULL,NULL);
643} 643}
644 644
645extern int ZEXPORT zipOpenNewFileInZip3 (file, filename, zipfi, 645extern int ZEXPORT zipOpenNewFileInZip3 (file, filename, zipfi,
646 extrafield_local, size_extrafield_local, 646 extrafield_local, size_extrafield_local,
647 extrafield_global, size_extrafield_global, 647 extrafield_global, size_extrafield_global,
648 comment, method, level, raw, 648 comment, method, level, raw,
649 windowBits, memLevel, strategy, 649 windowBits, memLevel, strategy,
650 password, crcForCrypting) 650 password, crcForCrypting)
651 zipFile file; 651 zipFile file;
652 const char* filename; 652 const char* filename;
653 const zip_fileinfo* zipfi; 653 const zip_fileinfo* zipfi;
654 const void* extrafield_local; 654 const void* extrafield_local;
655 uInt size_extrafield_local; 655 uInt size_extrafield_local;
656 const void* extrafield_global; 656 const void* extrafield_global;
657 uInt size_extrafield_global; 657 uInt size_extrafield_global;
658 const char* comment; 658 const char* comment;
659 int method; 659 int method;
660 int level; 660 int level;
661 int raw; 661 int raw;
662 int windowBits; 662 int windowBits;
663 int memLevel; 663 int memLevel;
664 int strategy; 664 int strategy;
665 const char* password; 665 const char* password;
666 uLong crcForCrypting; 666 uLong crcForCrypting;
667{ 667{
668 zip_internal* zi; 668 zip_internal* zi;
669 uInt size_filename; 669 uInt size_filename;
670 uInt size_comment; 670 uInt size_comment;
671 uInt i; 671 uInt i;
672 int err = ZIP_OK; 672 int err = ZIP_OK;
673 673
674 #ifdef NOCRYPT 674# ifdef NOCRYPT
675 if (password != NULL) 675 if (password != NULL)
676 return ZIP_PARAMERROR; 676 return ZIP_PARAMERROR;
677 #endif 677# endif
678 678
679 if (file == NULL) 679 if (file == NULL)
680 return ZIP_PARAMERROR; 680 return ZIP_PARAMERROR;
681 if ((method!=0) && (method!=Z_DEFLATED)) 681 if ((method!=0) && (method!=Z_DEFLATED))
682 return ZIP_PARAMERROR; 682 return ZIP_PARAMERROR;
683 683
684 zi = (zip_internal*)file; 684 zi = (zip_internal*)file;
685 685
686 if (zi->in_opened_file_inzip == 1) 686 if (zi->in_opened_file_inzip == 1)
687 { 687 {
688 err = zipCloseFileInZip (file); 688 err = zipCloseFileInZip (file);
689 if (err != ZIP_OK) 689 if (err != ZIP_OK)
690 return err; 690 return err;
691 } 691 }
692 692
693 693
694 if (filename==NULL) 694 if (filename==NULL)
695 filename="-"; 695 filename="-";
696 696
697 if (comment==NULL) 697 if (comment==NULL)
698 size_comment = 0; 698 size_comment = 0;
699 else 699 else
700 size_comment = strlen(comment); 700 size_comment = strlen(comment);
701 701
702 size_filename = strlen(filename); 702 size_filename = strlen(filename);
703 703
704 if (zipfi == NULL) 704 if (zipfi == NULL)
705 zi->ci.dosDate = 0; 705 zi->ci.dosDate = 0;
706 else 706 else
707 { 707 {
708 if (zipfi->dosDate != 0) 708 if (zipfi->dosDate != 0)
709 zi->ci.dosDate = zipfi->dosDate; 709 zi->ci.dosDate = zipfi->dosDate;
710 else zi->ci.dosDate = ziplocal_TmzDateToDosDate(&zipfi->tmz_date,zipfi->dosDate); 710 else zi->ci.dosDate = ziplocal_TmzDateToDosDate(&zipfi->tmz_date,zipfi->dosDate);
711 } 711 }
712 712
713 zi->ci.flag = 0; 713 zi->ci.flag = 0;
714 if ((level==8) || (level==9)) 714 if ((level==8) || (level==9))
715 zi->ci.flag |= 2; 715 zi->ci.flag |= 2;
716 if ((level==2)) 716 if ((level==2))
717 zi->ci.flag |= 4; 717 zi->ci.flag |= 4;
718 if ((level==1)) 718 if ((level==1))
719 zi->ci.flag |= 6; 719 zi->ci.flag |= 6;
720 if (password != NULL) 720 if (password != NULL)
721 zi->ci.flag |= 1; 721 zi->ci.flag |= 1;
722 722
723 zi->ci.crc32 = 0; 723 zi->ci.crc32 = 0;
724 zi->ci.method = method; 724 zi->ci.method = method;
725 zi->ci.encrypt = 0; 725 zi->ci.encrypt = 0;
726 zi->ci.stream_initialised = 0; 726 zi->ci.stream_initialised = 0;
727 zi->ci.pos_in_buffered_data = 0; 727 zi->ci.pos_in_buffered_data = 0;
728 zi->ci.raw = raw; 728 zi->ci.raw = raw;
729 zi->ci.pos_local_header = ZTELL(zi->z_filefunc,zi->filestream) ; 729 zi->ci.pos_local_header = ZTELL(zi->z_filefunc,zi->filestream) ;
730 zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename + 730 zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename +
731 size_extrafield_global + size_comment; 731 size_extrafield_global + size_comment;
732 zi->ci.central_header = (char*)ALLOC((uInt)zi->ci.size_centralheader); 732 zi->ci.central_header = (char*)ALLOC((uInt)zi->ci.size_centralheader);
733 733
734 ziplocal_putValue_inmemory(zi->ci.central_header,(uLong)CENTRALHEADERMAGIC,4); 734 ziplocal_putValue_inmemory(zi->ci.central_header,(uLong)CENTRALHEADERMAGIC,4);
735 /* version info */ 735 /* version info */
736 ziplocal_putValue_inmemory(zi->ci.central_header+4,(uLong)VERSIONMADEBY,2); 736 ziplocal_putValue_inmemory(zi->ci.central_header+4,(uLong)VERSIONMADEBY,2);
737 ziplocal_putValue_inmemory(zi->ci.central_header+6,(uLong)20,2); 737 ziplocal_putValue_inmemory(zi->ci.central_header+6,(uLong)20,2);
738 ziplocal_putValue_inmemory(zi->ci.central_header+8,(uLong)zi->ci.flag,2); 738 ziplocal_putValue_inmemory(zi->ci.central_header+8,(uLong)zi->ci.flag,2);
739 ziplocal_putValue_inmemory(zi->ci.central_header+10,(uLong)zi->ci.method,2); 739 ziplocal_putValue_inmemory(zi->ci.central_header+10,(uLong)zi->ci.method,2);
740 ziplocal_putValue_inmemory(zi->ci.central_header+12,(uLong)zi->ci.dosDate,4); 740 ziplocal_putValue_inmemory(zi->ci.central_header+12,(uLong)zi->ci.dosDate,4);
741 ziplocal_putValue_inmemory(zi->ci.central_header+16,(uLong)0,4); /*crc*/ 741 ziplocal_putValue_inmemory(zi->ci.central_header+16,(uLong)0,4); /*crc*/
742 ziplocal_putValue_inmemory(zi->ci.central_header+20,(uLong)0,4); /*compr size*/ 742 ziplocal_putValue_inmemory(zi->ci.central_header+20,(uLong)0,4); /*compr size*/
743 ziplocal_putValue_inmemory(zi->ci.central_header+24,(uLong)0,4); /*uncompr size*/ 743 ziplocal_putValue_inmemory(zi->ci.central_header+24,(uLong)0,4); /*uncompr size*/
744 ziplocal_putValue_inmemory(zi->ci.central_header+28,(uLong)size_filename,2); 744 ziplocal_putValue_inmemory(zi->ci.central_header+28,(uLong)size_filename,2);
745 ziplocal_putValue_inmemory(zi->ci.central_header+30,(uLong)size_extrafield_global,2); 745 ziplocal_putValue_inmemory(zi->ci.central_header+30,(uLong)size_extrafield_global,2);
746 ziplocal_putValue_inmemory(zi->ci.central_header+32,(uLong)size_comment,2); 746 ziplocal_putValue_inmemory(zi->ci.central_header+32,(uLong)size_comment,2);
747 ziplocal_putValue_inmemory(zi->ci.central_header+34,(uLong)0,2); /*disk nm start*/ 747 ziplocal_putValue_inmemory(zi->ci.central_header+34,(uLong)0,2); /*disk nm start*/
748 748
749 if (zipfi==NULL) 749 if (zipfi==NULL)
750 ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)0,2); 750 ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)0,2);
751 else 751 else
752 ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)zipfi->internal_fa,2); 752 ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)zipfi->internal_fa,2);
753 753
754 if (zipfi==NULL) 754 if (zipfi==NULL)
755 ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)0,4); 755 ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)0,4);
756 else 756 else
757 ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)zipfi->external_fa,4); 757 ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)zipfi->external_fa,4);
758 758
759 ziplocal_putValue_inmemory(zi->ci.central_header+42,(uLong)zi->ci.pos_local_header- zi->add_position_when_writting_offset,4); 759 ziplocal_putValue_inmemory(zi->ci.central_header+42,(uLong)zi->ci.pos_local_header- zi->add_position_when_writting_offset,4);
760 760
761 for (i=0;i<size_filename;i++) 761 for (i=0;i<size_filename;i++)
762 *(zi->ci.central_header+SIZECENTRALHEADER+i) = *(filename+i); 762 *(zi->ci.central_header+SIZECENTRALHEADER+i) = *(filename+i);
763 763
764 for (i=0;i<size_extrafield_global;i++) 764 for (i=0;i<size_extrafield_global;i++)
765 *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+i) = 765 *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+i) =
766 *(((const char*)extrafield_global)+i); 766 *(((const char*)extrafield_global)+i);
767 767
768 for (i=0;i<size_comment;i++) 768 for (i=0;i<size_comment;i++)
769 *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+ 769 *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+
770 size_extrafield_global+i) = *(comment+i); 770 size_extrafield_global+i) = *(comment+i);
771 if (zi->ci.central_header == NULL) 771 if (zi->ci.central_header == NULL)
772 return ZIP_INTERNALERROR; 772 return ZIP_INTERNALERROR;
773 773
774 /* write the local header */ 774 /* write the local header */
775 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)LOCALHEADERMAGIC,4); 775 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)LOCALHEADERMAGIC,4);
776 776
777 if (err==ZIP_OK) 777 if (err==ZIP_OK)
778 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)20,2);/* version needed to extract */ 778 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)20,2);/* version needed to extract */
779 if (err==ZIP_OK) 779 if (err==ZIP_OK)
780 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.flag,2); 780 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.flag,2);
781 781
782 if (err==ZIP_OK) 782 if (err==ZIP_OK)
783 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.method,2); 783 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.method,2);
784 784
785 if (err==ZIP_OK) 785 if (err==ZIP_OK)
786 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.dosDate,4); 786 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.dosDate,4);
787 787
788 if (err==ZIP_OK) 788 if (err==ZIP_OK)
789 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* crc 32, unknown */ 789 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* crc 32, unknown */
790 if (err==ZIP_OK) 790 if (err==ZIP_OK)
791 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* compressed size, unknown */ 791 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* compressed size, unknown */
792 if (err==ZIP_OK) 792 if (err==ZIP_OK)
793 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* uncompressed size, unknown */ 793 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* uncompressed size, unknown */
794 794
795 if (err==ZIP_OK) 795 if (err==ZIP_OK)
796 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_filename,2); 796 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_filename,2);
797 797
798 if (err==ZIP_OK) 798 if (err==ZIP_OK)
799 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_extrafield_local,2); 799 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_extrafield_local,2);
800 800
801 if ((err==ZIP_OK) && (size_filename>0)) 801 if ((err==ZIP_OK) && (size_filename>0))
802 if (ZWRITE(zi->z_filefunc,zi->filestream,filename,size_filename)!=size_filename) 802 if (ZWRITE(zi->z_filefunc,zi->filestream,filename,size_filename)!=size_filename)
803 err = ZIP_ERRNO; 803 err = ZIP_ERRNO;
804 804
805 if ((err==ZIP_OK) && (size_extrafield_local>0)) 805 if ((err==ZIP_OK) && (size_extrafield_local>0))
806 if (ZWRITE(zi->z_filefunc,zi->filestream,extrafield_local,size_extrafield_local) 806 if (ZWRITE(zi->z_filefunc,zi->filestream,extrafield_local,size_extrafield_local)
807 !=size_extrafield_local) 807 !=size_extrafield_local)
808 err = ZIP_ERRNO; 808 err = ZIP_ERRNO;
809 809
810 zi->ci.stream.avail_in = (uInt)0; 810 zi->ci.stream.avail_in = (uInt)0;
811 zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; 811 zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
812 zi->ci.stream.next_out = zi->ci.buffered_data; 812 zi->ci.stream.next_out = zi->ci.buffered_data;
813 zi->ci.stream.total_in = 0; 813 zi->ci.stream.total_in = 0;
814 zi->ci.stream.total_out = 0; 814 zi->ci.stream.total_out = 0;
815 815
816 if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) 816 if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
817 { 817 {
818 zi->ci.stream.zalloc = (alloc_func)0; 818 zi->ci.stream.zalloc = (alloc_func)0;
819 zi->ci.stream.zfree = (free_func)0; 819 zi->ci.stream.zfree = (free_func)0;
820 zi->ci.stream.opaque = (voidpf)0; 820 zi->ci.stream.opaque = (voidpf)0;
821 821
822 if (windowBits>0) 822 if (windowBits>0)
823 windowBits = -windowBits; 823 windowBits = -windowBits;
824 824
825 err = deflateInit2(&zi->ci.stream, level, 825 err = deflateInit2(&zi->ci.stream, level,
826 Z_DEFLATED, windowBits, memLevel, strategy); 826 Z_DEFLATED, windowBits, memLevel, strategy);
827 827
828 if (err==Z_OK) 828 if (err==Z_OK)
829 zi->ci.stream_initialised = 1; 829 zi->ci.stream_initialised = 1;
830 } 830 }
831 #ifndef NOCRYPT 831# ifndef NOCRYPT
832 zi->ci.crypt_header_size = 0; 832 zi->ci.crypt_header_size = 0;
833 if ((err==Z_OK) && (password != NULL)) 833 if ((err==Z_OK) && (password != NULL))
834 { 834 {
835 unsigned char bufHead[RAND_HEAD_LEN]; 835 unsigned char bufHead[RAND_HEAD_LEN];
836 unsigned int sizeHead; 836 unsigned int sizeHead;
837 zi->ci.encrypt = 1; 837 zi->ci.encrypt = 1;
838 zi->ci.pcrc_32_tab = get_crc_table(); 838 zi->ci.pcrc_32_tab = get_crc_table();
839 /*init_keys(password,zi->ci.keys,zi->ci.pcrc_32_tab);*/ 839 /*init_keys(password,zi->ci.keys,zi->ci.pcrc_32_tab);*/
840 840
841 sizeHead=crypthead(password,bufHead,RAND_HEAD_LEN,zi->ci.keys,zi->ci.pcrc_32_tab,crcForCrypting); 841 sizeHead=crypthead(password,bufHead,RAND_HEAD_LEN,zi->ci.keys,zi->ci.pcrc_32_tab,crcForCrypting);
842 zi->ci.crypt_header_size = sizeHead; 842 zi->ci.crypt_header_size = sizeHead;
843 843
844 if (ZWRITE(zi->z_filefunc,zi->filestream,bufHead,sizeHead) != sizeHead) 844 if (ZWRITE(zi->z_filefunc,zi->filestream,bufHead,sizeHead) != sizeHead)
845 err = ZIP_ERRNO; 845 err = ZIP_ERRNO;
846 } 846 }
847 #endif 847# endif
848 848
849 if (err==Z_OK) 849 if (err==Z_OK)
850 zi->in_opened_file_inzip = 1; 850 zi->in_opened_file_inzip = 1;
851 return err; 851 return err;
852} 852}
853 853
854extern int ZEXPORT zipOpenNewFileInZip2(file, filename, zipfi, 854extern int ZEXPORT zipOpenNewFileInZip2(file, filename, zipfi,
855 extrafield_local, size_extrafield_local, 855 extrafield_local, size_extrafield_local,
856 extrafield_global, size_extrafield_global, 856 extrafield_global, size_extrafield_global,
857 comment, method, level, raw) 857 comment, method, level, raw)
858 zipFile file; 858 zipFile file;
859 const char* filename; 859 const char* filename;
860 const zip_fileinfo* zipfi; 860 const zip_fileinfo* zipfi;
861 const void* extrafield_local; 861 const void* extrafield_local;
862 uInt size_extrafield_local; 862 uInt size_extrafield_local;
863 const void* extrafield_global; 863 const void* extrafield_global;
864 uInt size_extrafield_global; 864 uInt size_extrafield_global;
865 const char* comment; 865 const char* comment;
866 int method; 866 int method;
867 int level; 867 int level;
868 int raw; 868 int raw;
869{ 869{
870 return zipOpenNewFileInZip3 (file, filename, zipfi, 870 return zipOpenNewFileInZip3 (file, filename, zipfi,
871 extrafield_local, size_extrafield_local, 871 extrafield_local, size_extrafield_local,
872 extrafield_global, size_extrafield_global, 872 extrafield_global, size_extrafield_global,
873 comment, method, level, raw, 873 comment, method, level, raw,
874 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, 874 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
875 NULL, 0); 875 NULL, 0);
876} 876}
877 877
878extern int ZEXPORT zipOpenNewFileInZip (file, filename, zipfi, 878extern int ZEXPORT zipOpenNewFileInZip (file, filename, zipfi,
879 extrafield_local, size_extrafield_local, 879 extrafield_local, size_extrafield_local,
880 extrafield_global, size_extrafield_global, 880 extrafield_global, size_extrafield_global,
881 comment, method, level) 881 comment, method, level)
882 zipFile file; 882 zipFile file;
883 const char* filename; 883 const char* filename;
884 const zip_fileinfo* zipfi; 884 const zip_fileinfo* zipfi;
885 const void* extrafield_local; 885 const void* extrafield_local;
886 uInt size_extrafield_local; 886 uInt size_extrafield_local;
887 const void* extrafield_global; 887 const void* extrafield_global;
888 uInt size_extrafield_global; 888 uInt size_extrafield_global;
889 const char* comment; 889 const char* comment;
890 int method; 890 int method;
891 int level; 891 int level;
892{ 892{
893 return zipOpenNewFileInZip2 (file, filename, zipfi, 893 return zipOpenNewFileInZip2 (file, filename, zipfi,
894 extrafield_local, size_extrafield_local, 894 extrafield_local, size_extrafield_local,
895 extrafield_global, size_extrafield_global, 895 extrafield_global, size_extrafield_global,
896 comment, method, level, 0); 896 comment, method, level, 0);
897} 897}
898 898
899local int zipFlushWriteBuffer(zi) 899local int zipFlushWriteBuffer(zi)
900 zip_internal* zi; 900 zip_internal* zi;
901{ 901{
902 int err=ZIP_OK; 902 int err=ZIP_OK;
903 903
904 if (zi->ci.encrypt != 0) 904 if (zi->ci.encrypt != 0)
905 { 905 {
906#ifndef NOCRYPT 906#ifndef NOCRYPT
907 uInt i; 907 uInt i;
908 int t; 908 int t;
909 for (i=0;i<zi->ci.pos_in_buffered_data;i++) 909 for (i=0;i<zi->ci.pos_in_buffered_data;i++)
910 zi->ci.buffered_data[i] = zencode(zi->ci.keys, zi->ci.pcrc_32_tab, 910 zi->ci.buffered_data[i] = zencode(zi->ci.keys, zi->ci.pcrc_32_tab,
911 zi->ci.buffered_data[i],t); 911 zi->ci.buffered_data[i],t);
912#endif 912#endif
913 } 913 }
914 if (ZWRITE(zi->z_filefunc,zi->filestream,zi->ci.buffered_data,zi->ci.pos_in_buffered_data) 914 if (ZWRITE(zi->z_filefunc,zi->filestream,zi->ci.buffered_data,zi->ci.pos_in_buffered_data)
915 !=zi->ci.pos_in_buffered_data) 915 !=zi->ci.pos_in_buffered_data)
916 err = ZIP_ERRNO; 916 err = ZIP_ERRNO;
917 zi->ci.pos_in_buffered_data = 0; 917 zi->ci.pos_in_buffered_data = 0;
918 return err; 918 return err;
919} 919}
920 920
921extern int ZEXPORT zipWriteInFileInZip (file, buf, len) 921extern int ZEXPORT zipWriteInFileInZip (file, buf, len)
922 zipFile file; 922 zipFile file;
923 const void* buf; 923 const void* buf;
924 unsigned len; 924 unsigned len;
925{ 925{
926 zip_internal* zi; 926 zip_internal* zi;
927 int err=ZIP_OK; 927 int err=ZIP_OK;
928 928
929 if (file == NULL) 929 if (file == NULL)
930 return ZIP_PARAMERROR; 930 return ZIP_PARAMERROR;
931 zi = (zip_internal*)file; 931 zi = (zip_internal*)file;
932 932
933 if (zi->in_opened_file_inzip == 0) 933 if (zi->in_opened_file_inzip == 0)
934 return ZIP_PARAMERROR; 934 return ZIP_PARAMERROR;
935 935
936 zi->ci.stream.next_in = (void*)buf; 936 zi->ci.stream.next_in = (void*)buf;
937 zi->ci.stream.avail_in = len; 937 zi->ci.stream.avail_in = len;
938 zi->ci.crc32 = crc32(zi->ci.crc32,buf,len); 938 zi->ci.crc32 = crc32(zi->ci.crc32,buf,len);
939 939
940 while ((err==ZIP_OK) && (zi->ci.stream.avail_in>0)) 940 while ((err==ZIP_OK) && (zi->ci.stream.avail_in>0))
941 { 941 {
942 if (zi->ci.stream.avail_out == 0) 942 if (zi->ci.stream.avail_out == 0)
943 { 943 {
944 if (zipFlushWriteBuffer(zi) == ZIP_ERRNO) 944 if (zipFlushWriteBuffer(zi) == ZIP_ERRNO)
945 err = ZIP_ERRNO; 945 err = ZIP_ERRNO;
946 zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; 946 zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
947 zi->ci.stream.next_out = zi->ci.buffered_data; 947 zi->ci.stream.next_out = zi->ci.buffered_data;
948 } 948 }
949 949
950 950
951 if(err != ZIP_OK) 951 if(err != ZIP_OK)
952 break; 952 break;
953 953
954 if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) 954 if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
955 { 955 {
956 uLong uTotalOutBefore = zi->ci.stream.total_out; 956 uLong uTotalOutBefore = zi->ci.stream.total_out;
957 err=deflate(&zi->ci.stream, Z_NO_FLUSH); 957 err=deflate(&zi->ci.stream, Z_NO_FLUSH);
958 zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ; 958 zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
959 959
960 } 960 }
961 else 961 else
962 { 962 {
963 uInt copy_this,i; 963 uInt copy_this,i;
964 if (zi->ci.stream.avail_in < zi->ci.stream.avail_out) 964 if (zi->ci.stream.avail_in < zi->ci.stream.avail_out)
965 copy_this = zi->ci.stream.avail_in; 965 copy_this = zi->ci.stream.avail_in;
966 else 966 else
967 copy_this = zi->ci.stream.avail_out; 967 copy_this = zi->ci.stream.avail_out;
968 for (i=0;i<copy_this;i++) 968 for (i=0;i<copy_this;i++)
969 *(((char*)zi->ci.stream.next_out)+i) = 969 *(((char*)zi->ci.stream.next_out)+i) =
970 *(((const char*)zi->ci.stream.next_in)+i); 970 *(((const char*)zi->ci.stream.next_in)+i);
971 { 971 {
972 zi->ci.stream.avail_in -= copy_this; 972 zi->ci.stream.avail_in -= copy_this;
973 zi->ci.stream.avail_out-= copy_this; 973 zi->ci.stream.avail_out-= copy_this;
974 zi->ci.stream.next_in+= copy_this; 974 zi->ci.stream.next_in+= copy_this;
975 zi->ci.stream.next_out+= copy_this; 975 zi->ci.stream.next_out+= copy_this;
976 zi->ci.stream.total_in+= copy_this; 976 zi->ci.stream.total_in+= copy_this;
977 zi->ci.stream.total_out+= copy_this; 977 zi->ci.stream.total_out+= copy_this;
978 zi->ci.pos_in_buffered_data += copy_this; 978 zi->ci.pos_in_buffered_data += copy_this;
979 } 979 }
980 } 980 }
981 } 981 }
982 982
983 return err; 983 return err;
984} 984}
985 985
986extern int ZEXPORT zipCloseFileInZipRaw (file, uncompressed_size, crc32) 986extern int ZEXPORT zipCloseFileInZipRaw (file, uncompressed_size, crc32)
987 zipFile file; 987 zipFile file;
988 uLong uncompressed_size; 988 uLong uncompressed_size;
989 uLong crc32; 989 uLong crc32;
990{ 990{
991 zip_internal* zi; 991 zip_internal* zi;
992 uLong compressed_size; 992 uLong compressed_size;
993 int err=ZIP_OK; 993 int err=ZIP_OK;
994 994
995 if (file == NULL) 995 if (file == NULL)
996 return ZIP_PARAMERROR; 996 return ZIP_PARAMERROR;
997 zi = (zip_internal*)file; 997 zi = (zip_internal*)file;
998 998
999 if (zi->in_opened_file_inzip == 0) 999 if (zi->in_opened_file_inzip == 0)
1000 return ZIP_PARAMERROR; 1000 return ZIP_PARAMERROR;
1001 zi->ci.stream.avail_in = 0; 1001 zi->ci.stream.avail_in = 0;
1002 1002
1003 if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) 1003 if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
1004 while (err==ZIP_OK) 1004 while (err==ZIP_OK)
1005 { 1005 {
1006 uLong uTotalOutBefore; 1006 uLong uTotalOutBefore;
1007 if (zi->ci.stream.avail_out == 0) 1007 if (zi->ci.stream.avail_out == 0)
1008 { 1008 {
1009 if (zipFlushWriteBuffer(zi) == ZIP_ERRNO) 1009 if (zipFlushWriteBuffer(zi) == ZIP_ERRNO)
1010 err = ZIP_ERRNO; 1010 err = ZIP_ERRNO;
1011 zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; 1011 zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
1012 zi->ci.stream.next_out = zi->ci.buffered_data; 1012 zi->ci.stream.next_out = zi->ci.buffered_data;
1013 } 1013 }
1014 uTotalOutBefore = zi->ci.stream.total_out; 1014 uTotalOutBefore = zi->ci.stream.total_out;
1015 err=deflate(&zi->ci.stream, Z_FINISH); 1015 err=deflate(&zi->ci.stream, Z_FINISH);
1016 zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ; 1016 zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
1017 } 1017 }
1018 1018
1019 if (err==Z_STREAM_END) 1019 if (err==Z_STREAM_END)
1020 err=ZIP_OK; /* this is normal */ 1020 err=ZIP_OK; /* this is normal */
1021 1021
1022 if ((zi->ci.pos_in_buffered_data>0) && (err==ZIP_OK)) 1022 if ((zi->ci.pos_in_buffered_data>0) && (err==ZIP_OK))
1023 if (zipFlushWriteBuffer(zi)==ZIP_ERRNO) 1023 if (zipFlushWriteBuffer(zi)==ZIP_ERRNO)
1024 err = ZIP_ERRNO; 1024 err = ZIP_ERRNO;
1025 1025
1026 if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) 1026 if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
1027 { 1027 {
1028 err=deflateEnd(&zi->ci.stream); 1028 err=deflateEnd(&zi->ci.stream);
1029 zi->ci.stream_initialised = 0; 1029 zi->ci.stream_initialised = 0;
1030 } 1030 }
1031 1031
1032 if (!zi->ci.raw) 1032 if (!zi->ci.raw)
1033 { 1033 {
1034 crc32 = (uLong)zi->ci.crc32; 1034 crc32 = (uLong)zi->ci.crc32;
1035 uncompressed_size = (uLong)zi->ci.stream.total_in; 1035 uncompressed_size = (uLong)zi->ci.stream.total_in;
1036 } 1036 }
1037 compressed_size = (uLong)zi->ci.stream.total_out; 1037 compressed_size = (uLong)zi->ci.stream.total_out;
1038 #ifndef NOCRYPT 1038# ifndef NOCRYPT
1039 compressed_size += zi->ci.crypt_header_size; 1039 compressed_size += zi->ci.crypt_header_size;
1040 #endif 1040# endif
1041 1041
1042 ziplocal_putValue_inmemory(zi->ci.central_header+16,crc32,4); /*crc*/ 1042 ziplocal_putValue_inmemory(zi->ci.central_header+16,crc32,4); /*crc*/
1043 ziplocal_putValue_inmemory(zi->ci.central_header+20, 1043 ziplocal_putValue_inmemory(zi->ci.central_header+20,
1044 compressed_size,4); /*compr size*/ 1044 compressed_size,4); /*compr size*/
1045 if (zi->ci.stream.data_type == Z_ASCII) 1045 if (zi->ci.stream.data_type == Z_ASCII)
1046 ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)Z_ASCII,2); 1046 ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)Z_ASCII,2);
1047 ziplocal_putValue_inmemory(zi->ci.central_header+24, 1047 ziplocal_putValue_inmemory(zi->ci.central_header+24,
1048 uncompressed_size,4); /*uncompr size*/ 1048 uncompressed_size,4); /*uncompr size*/
1049 1049
1050 if (err==ZIP_OK) 1050 if (err==ZIP_OK)
1051 err = add_data_in_datablock(&zi->central_dir,zi->ci.central_header, 1051 err = add_data_in_datablock(&zi->central_dir,zi->ci.central_header,
1052 (uLong)zi->ci.size_centralheader); 1052 (uLong)zi->ci.size_centralheader);
1053 free(zi->ci.central_header); 1053 free(zi->ci.central_header);
1054 1054
1055 if (err==ZIP_OK) 1055 if (err==ZIP_OK)
1056 { 1056 {
1057 long cur_pos_inzip = ZTELL(zi->z_filefunc,zi->filestream); 1057 long cur_pos_inzip = ZTELL(zi->z_filefunc,zi->filestream);
1058 if (ZSEEK(zi->z_filefunc,zi->filestream, 1058 if (ZSEEK(zi->z_filefunc,zi->filestream,
1059 zi->ci.pos_local_header + 14,ZLIB_FILEFUNC_SEEK_SET)!=0) 1059 zi->ci.pos_local_header + 14,ZLIB_FILEFUNC_SEEK_SET)!=0)
1060 err = ZIP_ERRNO; 1060 err = ZIP_ERRNO;
1061 1061
1062 if (err==ZIP_OK) 1062 if (err==ZIP_OK)
1063 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,crc32,4); /* crc 32, unknown */ 1063 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,crc32,4); /* crc 32, unknown */
1064 1064
1065 if (err==ZIP_OK) /* compressed size, unknown */ 1065 if (err==ZIP_OK) /* compressed size, unknown */
1066 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,compressed_size,4); 1066 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,compressed_size,4);
1067 1067
1068 if (err==ZIP_OK) /* uncompressed size, unknown */ 1068 if (err==ZIP_OK) /* uncompressed size, unknown */
1069 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,uncompressed_size,4); 1069 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,uncompressed_size,4);
1070 1070
1071 if (ZSEEK(zi->z_filefunc,zi->filestream, 1071 if (ZSEEK(zi->z_filefunc,zi->filestream,
1072 cur_pos_inzip,ZLIB_FILEFUNC_SEEK_SET)!=0) 1072 cur_pos_inzip,ZLIB_FILEFUNC_SEEK_SET)!=0)
1073 err = ZIP_ERRNO; 1073 err = ZIP_ERRNO;
1074 } 1074 }
1075 1075
1076 zi->number_entry ++; 1076 zi->number_entry ++;
1077 zi->in_opened_file_inzip = 0; 1077 zi->in_opened_file_inzip = 0;
1078 1078
1079 return err; 1079 return err;
1080} 1080}
1081 1081
1082extern int ZEXPORT zipCloseFileInZip (file) 1082extern int ZEXPORT zipCloseFileInZip (file)
1083 zipFile file; 1083 zipFile file;
1084{ 1084{
1085 return zipCloseFileInZipRaw (file,0,0); 1085 return zipCloseFileInZipRaw (file,0,0);
1086} 1086}
1087 1087
1088extern int ZEXPORT zipClose (file, global_comment) 1088extern int ZEXPORT zipClose (file, global_comment)
1089 zipFile file; 1089 zipFile file;
1090 const char* global_comment; 1090 const char* global_comment;
1091{ 1091{
1092 zip_internal* zi; 1092 zip_internal* zi;
1093 int err = 0; 1093 int err = 0;
1094 uLong size_centraldir = 0; 1094 uLong size_centraldir = 0;
1095 uLong centraldir_pos_inzip ; 1095 uLong centraldir_pos_inzip ;
1096 uInt size_global_comment; 1096 uInt size_global_comment;
1097 if (file == NULL) 1097 if (file == NULL)
1098 return ZIP_PARAMERROR; 1098 return ZIP_PARAMERROR;
1099 zi = (zip_internal*)file; 1099 zi = (zip_internal*)file;
1100 1100
1101 if (zi->in_opened_file_inzip == 1) 1101 if (zi->in_opened_file_inzip == 1)
1102 { 1102 {
1103 err = zipCloseFileInZip (file); 1103 err = zipCloseFileInZip (file);
1104 } 1104 }
1105 1105
1106 if (global_comment==NULL) 1106 if (global_comment==NULL)
1107 size_global_comment = 0; 1107 size_global_comment = 0;
1108 else 1108 else
1109 size_global_comment = strlen(global_comment); 1109 size_global_comment = strlen(global_comment);
1110 1110
1111 1111
1112 centraldir_pos_inzip = ZTELL(zi->z_filefunc,zi->filestream); 1112 centraldir_pos_inzip = ZTELL(zi->z_filefunc,zi->filestream);
1113 if (err==ZIP_OK) 1113 if (err==ZIP_OK)
1114 { 1114 {
1115 linkedlist_datablock_internal* ldi = zi->central_dir.first_block ; 1115 linkedlist_datablock_internal* ldi = zi->central_dir.first_block ;
1116 while (ldi!=NULL) 1116 while (ldi!=NULL)
1117 { 1117 {
1118 if ((err==ZIP_OK) && (ldi->filled_in_this_block>0)) 1118 if ((err==ZIP_OK) && (ldi->filled_in_this_block>0))
1119 if (ZWRITE(zi->z_filefunc,zi->filestream, 1119 if (ZWRITE(zi->z_filefunc,zi->filestream,
1120 ldi->data,ldi->filled_in_this_block) 1120 ldi->data,ldi->filled_in_this_block)
1121 !=ldi->filled_in_this_block ) 1121 !=ldi->filled_in_this_block )
1122 err = ZIP_ERRNO; 1122 err = ZIP_ERRNO;
1123 1123
1124 size_centraldir += ldi->filled_in_this_block; 1124 size_centraldir += ldi->filled_in_this_block;
1125 ldi = ldi->next_datablock; 1125 ldi = ldi->next_datablock;
1126 } 1126 }
1127 } 1127 }
1128 free_datablock(zi->central_dir.first_block); 1128 free_datablock(zi->central_dir.first_block);
1129 1129
1130 if (err==ZIP_OK) /* Magic End */ 1130 if (err==ZIP_OK) /* Magic End */
1131 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)ENDHEADERMAGIC,4); 1131 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)ENDHEADERMAGIC,4);
1132 1132
1133 if (err==ZIP_OK) /* number of this disk */ 1133 if (err==ZIP_OK) /* number of this disk */
1134 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2); 1134 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);
1135 1135
1136 if (err==ZIP_OK) /* number of the disk with the start of the central directory */ 1136 if (err==ZIP_OK) /* number of the disk with the start of the central directory */
1137 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2); 1137 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);
1138 1138
1139 if (err==ZIP_OK) /* total number of entries in the central dir on this disk */ 1139 if (err==ZIP_OK) /* total number of entries in the central dir on this disk */
1140 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2); 1140 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
1141 1141
1142 if (err==ZIP_OK) /* total number of entries in the central dir */ 1142 if (err==ZIP_OK) /* total number of entries in the central dir */
1143 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2); 1143 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
1144 1144
1145 if (err==ZIP_OK) /* size of the central directory */ 1145 if (err==ZIP_OK) /* size of the central directory */
1146 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_centraldir,4); 1146 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_centraldir,4);
1147 1147
1148 if (err==ZIP_OK) /* offset of start of central directory with respect to the 1148 if (err==ZIP_OK) /* offset of start of central directory with respect to the
1149 starting disk number */ 1149 starting disk number */
1150 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream, 1150 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,
1151 (uLong)(centraldir_pos_inzip - zi->add_position_when_writting_offset),4); 1151 (uLong)(centraldir_pos_inzip - zi->add_position_when_writting_offset),4);
1152 1152
1153 if (err==ZIP_OK) /* zipfile comment length */ 1153 if (err==ZIP_OK) /* zipfile comment length */
1154 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_global_comment,2); 1154 err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_global_comment,2);
1155 1155
1156 if ((err==ZIP_OK) && (size_global_comment>0)) 1156 if ((err==ZIP_OK) && (size_global_comment>0))
1157 if (ZWRITE(zi->z_filefunc,zi->filestream, 1157 if (ZWRITE(zi->z_filefunc,zi->filestream,
1158 global_comment,size_global_comment) != size_global_comment) 1158 global_comment,size_global_comment) != size_global_comment)
1159 err = ZIP_ERRNO; 1159 err = ZIP_ERRNO;
1160 1160
1161 if (ZCLOSE(zi->z_filefunc,zi->filestream) != 0) 1161 if (ZCLOSE(zi->z_filefunc,zi->filestream) != 0)
1162 if (err == ZIP_OK) 1162 if (err == ZIP_OK)
1163 err = ZIP_ERRNO; 1163 err = ZIP_ERRNO;
1164 1164
1165 TRYFREE(zi); 1165 TRYFREE(zi);
1166 1166
1167 return err; 1167 return err;
1168} 1168}
diff --git a/contrib/minizip/zip.h b/contrib/minizip/zip.h
index d863e1a..5a75fc6 100644
--- a/contrib/minizip/zip.h
+++ b/contrib/minizip/zip.h
@@ -1,235 +1,235 @@
1/* zip.h -- IO for compress .zip files using zlib 1/* zip.h -- IO for compress .zip files using zlib
2 Version 0.22, May 19th, 2003 2 Version 0.22, May 19th, 2003
3 3
4 Copyright (C) 1998-2003 Gilles Vollant 4 Copyright (C) 1998-2003 Gilles Vollant
5 5
6 This unzip package allow creates .ZIP file, compatible with PKZip 2.04g 6 This unzip package allow creates .ZIP file, compatible with PKZip 2.04g
7 WinZip, InfoZip tools and compatible. 7 WinZip, InfoZip tools and compatible.
8 Encryption and multi volume ZipFile (span) are not supported. 8 Encryption and multi volume ZipFile (span) are not supported.
9 Old compressions used by old PKZip 1.x are not supported 9 Old compressions used by old PKZip 1.x are not supported
10 10
11 For uncompress .zip file, look at unzip.h 11 For uncompress .zip file, look at unzip.h
12 12
13 13
14 I WAIT FEEDBACK at mail info@winimage.com 14 I WAIT FEEDBACK at mail info@winimage.com
15 Visit also http://www.winimage.com/zLibDll/unzip.html for evolution 15 Visit also http://www.winimage.com/zLibDll/unzip.html for evolution
16 16
17 Condition of use and distribution are the same than zlib : 17 Condition of use and distribution are the same than zlib :
18 18
19 This software is provided 'as-is', without any express or implied 19 This software is provided 'as-is', without any express or implied
20 warranty. In no event will the authors be held liable for any damages 20 warranty. In no event will the authors be held liable for any damages
21 arising from the use of this software. 21 arising from the use of this software.
22 22
23 Permission is granted to anyone to use this software for any purpose, 23 Permission is granted to anyone to use this software for any purpose,
24 including commercial applications, and to alter it and redistribute it 24 including commercial applications, and to alter it and redistribute it
25 freely, subject to the following restrictions: 25 freely, subject to the following restrictions:
26 26
27 1. The origin of this software must not be misrepresented; you must not 27 1. The origin of this software must not be misrepresented; you must not
28 claim that you wrote the original software. If you use this software 28 claim that you wrote the original software. If you use this software
29 in a product, an acknowledgment in the product documentation would be 29 in a product, an acknowledgment in the product documentation would be
30 appreciated but is not required. 30 appreciated but is not required.
31 2. Altered source versions must be plainly marked as such, and must not be 31 2. Altered source versions must be plainly marked as such, and must not be
32 misrepresented as being the original software. 32 misrepresented as being the original software.
33 3. This notice may not be removed or altered from any source distribution. 33 3. This notice may not be removed or altered from any source distribution.
34 34
35 35
36*/ 36*/
37 37
38/* for more info about .ZIP format, see 38/* for more info about .ZIP format, see
39 http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip 39 http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip
40 http://www.info-zip.org/pub/infozip/doc/ 40 http://www.info-zip.org/pub/infozip/doc/
41 PkWare has also a specification at : 41 PkWare has also a specification at :
42 ftp://ftp.pkware.com/probdesc.zip 42 ftp://ftp.pkware.com/probdesc.zip
43*/ 43*/
44 44
45#ifndef _zip_H 45#ifndef _zip_H
46#define _zip_H 46#define _zip_H
47 47
48#ifdef __cplusplus 48#ifdef __cplusplus
49extern "C" { 49extern "C" {
50#endif 50#endif
51 51
52#ifndef _ZLIB_H 52#ifndef _ZLIB_H
53#include "zlib.h" 53#include "zlib.h"
54#endif 54#endif
55 55
56#ifndef _ZLIBIOAPI_H 56#ifndef _ZLIBIOAPI_H
57#include "ioapi.h" 57#include "ioapi.h"
58#endif 58#endif
59 59
60#if defined(STRICTZIP) || defined(STRICTZIPUNZIP) 60#if defined(STRICTZIP) || defined(STRICTZIPUNZIP)
61/* like the STRICT of WIN32, we define a pointer that cannot be converted 61/* like the STRICT of WIN32, we define a pointer that cannot be converted
62 from (void*) without cast */ 62 from (void*) without cast */
63typedef struct TagzipFile__ { int unused; } zipFile__; 63typedef struct TagzipFile__ { int unused; } zipFile__;
64typedef zipFile__ *zipFile; 64typedef zipFile__ *zipFile;
65#else 65#else
66typedef voidp zipFile; 66typedef voidp zipFile;
67#endif 67#endif
68 68
69#define ZIP_OK (0) 69#define ZIP_OK (0)
70#define ZIP_EOF (0) 70#define ZIP_EOF (0)
71#define ZIP_ERRNO (Z_ERRNO) 71#define ZIP_ERRNO (Z_ERRNO)
72#define ZIP_PARAMERROR (-102) 72#define ZIP_PARAMERROR (-102)
73#define ZIP_BADZIPFILE (-103) 73#define ZIP_BADZIPFILE (-103)
74#define ZIP_INTERNALERROR (-104) 74#define ZIP_INTERNALERROR (-104)
75 75
76#ifndef DEF_MEM_LEVEL 76#ifndef DEF_MEM_LEVEL
77# if MAX_MEM_LEVEL >= 8 77# if MAX_MEM_LEVEL >= 8
78# define DEF_MEM_LEVEL 8 78# define DEF_MEM_LEVEL 8
79# else 79# else
80# define DEF_MEM_LEVEL MAX_MEM_LEVEL 80# define DEF_MEM_LEVEL MAX_MEM_LEVEL
81# endif 81# endif
82#endif 82#endif
83/* default memLevel */ 83/* default memLevel */
84 84
85/* tm_zip contain date/time info */ 85/* tm_zip contain date/time info */
86typedef struct tm_zip_s 86typedef struct tm_zip_s
87{ 87{
88 uInt tm_sec; /* seconds after the minute - [0,59] */ 88 uInt tm_sec; /* seconds after the minute - [0,59] */
89 uInt tm_min; /* minutes after the hour - [0,59] */ 89 uInt tm_min; /* minutes after the hour - [0,59] */
90 uInt tm_hour; /* hours since midnight - [0,23] */ 90 uInt tm_hour; /* hours since midnight - [0,23] */
91 uInt tm_mday; /* day of the month - [1,31] */ 91 uInt tm_mday; /* day of the month - [1,31] */
92 uInt tm_mon; /* months since January - [0,11] */ 92 uInt tm_mon; /* months since January - [0,11] */
93 uInt tm_year; /* years - [1980..2044] */ 93 uInt tm_year; /* years - [1980..2044] */
94} tm_zip; 94} tm_zip;
95 95
96typedef struct 96typedef struct
97{ 97{
98 tm_zip tmz_date; /* date in understandable format */ 98 tm_zip tmz_date; /* date in understandable format */
99 uLong dosDate; /* if dos_date == 0, tmu_date is used */ 99 uLong dosDate; /* if dos_date == 0, tmu_date is used */
100/* uLong flag; */ /* general purpose bit flag 2 bytes */ 100/* uLong flag; */ /* general purpose bit flag 2 bytes */
101 101
102 uLong internal_fa; /* internal file attributes 2 bytes */ 102 uLong internal_fa; /* internal file attributes 2 bytes */
103 uLong external_fa; /* external file attributes 4 bytes */ 103 uLong external_fa; /* external file attributes 4 bytes */
104} zip_fileinfo; 104} zip_fileinfo;
105 105
106typedef const char* zipcharpc; 106typedef const char* zipcharpc;
107 107
108 108
109#define APPEND_STATUS_CREATE (0) 109#define APPEND_STATUS_CREATE (0)
110#define APPEND_STATUS_CREATEAFTER (1) 110#define APPEND_STATUS_CREATEAFTER (1)
111#define APPEND_STATUS_ADDINZIP (2) 111#define APPEND_STATUS_ADDINZIP (2)
112 112
113extern zipFile ZEXPORT zipOpen OF((const char *pathname, int append)); 113extern zipFile ZEXPORT zipOpen OF((const char *pathname, int append));
114/* 114/*
115 Create a zipfile. 115 Create a zipfile.
116 pathname contain on Windows XP a filename like "c:\\zlib\\zlib113.zip" or on 116 pathname contain on Windows XP a filename like "c:\\zlib\\zlib113.zip" or on
117 an Unix computer "zlib/zlib113.zip". 117 an Unix computer "zlib/zlib113.zip".
118 if the file pathname exist and append==APPEND_STATUS_CREATEAFTER, the zip 118 if the file pathname exist and append==APPEND_STATUS_CREATEAFTER, the zip
119 will be created at the end of the file. 119 will be created at the end of the file.
120 (useful if the file contain a self extractor code) 120 (useful if the file contain a self extractor code)
121 if the file pathname exist and append==APPEND_STATUS_ADDINZIP, we will 121 if the file pathname exist and append==APPEND_STATUS_ADDINZIP, we will
122 add files in existing zip (be sure you don't add file that doesn't exist) 122 add files in existing zip (be sure you don't add file that doesn't exist)
123 If the zipfile cannot be opened, the return value is NULL. 123 If the zipfile cannot be opened, the return value is NULL.
124 Else, the return value is a zipFile Handle, usable with other function 124 Else, the return value is a zipFile Handle, usable with other function
125 of this zip package. 125 of this zip package.
126*/ 126*/
127 127
128/* Note : there is no delete function into a zipfile. 128/* Note : there is no delete function into a zipfile.
129 If you want delete file into a zipfile, you must open a zipfile, and create another 129 If you want delete file into a zipfile, you must open a zipfile, and create another
130 Of couse, you can use RAW reading and writing to copy the file you did not want delte 130 Of couse, you can use RAW reading and writing to copy the file you did not want delte
131*/ 131*/
132 132
133extern zipFile ZEXPORT zipOpen2 OF((const char *pathname, 133extern zipFile ZEXPORT zipOpen2 OF((const char *pathname,
134 int append, 134 int append,
135 zipcharpc* globalcomment, 135 zipcharpc* globalcomment,
136 zlib_filefunc_def* pzlib_filefunc_def)); 136 zlib_filefunc_def* pzlib_filefunc_def));
137 137
138extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file, 138extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file,
139 const char* filename, 139 const char* filename,
140 const zip_fileinfo* zipfi, 140 const zip_fileinfo* zipfi,
141 const void* extrafield_local, 141 const void* extrafield_local,
142 uInt size_extrafield_local, 142 uInt size_extrafield_local,
143 const void* extrafield_global, 143 const void* extrafield_global,
144 uInt size_extrafield_global, 144 uInt size_extrafield_global,
145 const char* comment, 145 const char* comment,
146 int method, 146 int method,
147 int level)); 147 int level));
148/* 148/*
149 Open a file in the ZIP for writing. 149 Open a file in the ZIP for writing.
150 filename : the filename in zip (if NULL, '-' without quote will be used 150 filename : the filename in zip (if NULL, '-' without quote will be used
151 *zipfi contain supplemental information 151 *zipfi contain supplemental information
152 if extrafield_local!=NULL and size_extrafield_local>0, extrafield_local 152 if extrafield_local!=NULL and size_extrafield_local>0, extrafield_local
153 contains the extrafield data the the local header 153 contains the extrafield data the the local header
154 if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global 154 if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global
155 contains the extrafield data the the local header 155 contains the extrafield data the the local header
156 if comment != NULL, comment contain the comment string 156 if comment != NULL, comment contain the comment string
157 method contain the compression method (0 for store, Z_DEFLATED for deflate) 157 method contain the compression method (0 for store, Z_DEFLATED for deflate)
158 level contain the level of compression (can be Z_DEFAULT_COMPRESSION) 158 level contain the level of compression (can be Z_DEFAULT_COMPRESSION)
159*/ 159*/
160 160
161 161
162extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file, 162extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file,
163 const char* filename, 163 const char* filename,
164 const zip_fileinfo* zipfi, 164 const zip_fileinfo* zipfi,
165 const void* extrafield_local, 165 const void* extrafield_local,
166 uInt size_extrafield_local, 166 uInt size_extrafield_local,
167 const void* extrafield_global, 167 const void* extrafield_global,
168 uInt size_extrafield_global, 168 uInt size_extrafield_global,
169 const char* comment, 169 const char* comment,
170 int method, 170 int method,
171 int level, 171 int level,
172 int raw)); 172 int raw));
173 173
174/* 174/*
175 Same than zipOpenNewFileInZip, except if raw=1, we write raw file 175 Same than zipOpenNewFileInZip, except if raw=1, we write raw file
176 */ 176 */
177 177
178extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file, 178extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file,
179 const char* filename, 179 const char* filename,
180 const zip_fileinfo* zipfi, 180 const zip_fileinfo* zipfi,
181 const void* extrafield_local, 181 const void* extrafield_local,
182 uInt size_extrafield_local, 182 uInt size_extrafield_local,
183 const void* extrafield_global, 183 const void* extrafield_global,
184 uInt size_extrafield_global, 184 uInt size_extrafield_global,
185 const char* comment, 185 const char* comment,
186 int method, 186 int method,
187 int level, 187 int level,
188 int raw, 188 int raw,
189 int windowBits, 189 int windowBits,
190 int memLevel, 190 int memLevel,
191 int strategy, 191 int strategy,
192 const char* password, 192 const char* password,
193 uLong crcForCtypting)); 193 uLong crcForCtypting));
194 194
195/* 195/*
196 Same than zipOpenNewFileInZip2, except 196 Same than zipOpenNewFileInZip2, except
197 windowBits,memLevel,,strategy : see parameter strategy in deflateInit2 197 windowBits,memLevel,,strategy : see parameter strategy in deflateInit2
198 password : crypting password (NULL for no crypting) 198 password : crypting password (NULL for no crypting)
199 crcForCtypting : crc of file to compress (needed for crypting) 199 crcForCtypting : crc of file to compress (needed for crypting)
200 */ 200 */
201 201
202 202
203extern int ZEXPORT zipWriteInFileInZip OF((zipFile file, 203extern int ZEXPORT zipWriteInFileInZip OF((zipFile file,
204 const void* buf, 204 const void* buf,
205 unsigned len)); 205 unsigned len));
206/* 206/*
207 Write data in the zipfile 207 Write data in the zipfile
208*/ 208*/
209 209
210extern int ZEXPORT zipCloseFileInZip OF((zipFile file)); 210extern int ZEXPORT zipCloseFileInZip OF((zipFile file));
211/* 211/*
212 Close the current file in the zipfile 212 Close the current file in the zipfile
213*/ 213*/
214 214
215 215
216extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file, 216extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file,
217 uLong uncompressed_size, 217 uLong uncompressed_size,
218 uLong crc32)); 218 uLong crc32));
219/* 219/*
220 Close the current file in the zipfile, for fiel opened with 220 Close the current file in the zipfile, for fiel opened with
221 parameter raw=1 in zipOpenNewFileInZip2 221 parameter raw=1 in zipOpenNewFileInZip2
222 uncompressed_size and crc32 are value for the uncompressed size 222 uncompressed_size and crc32 are value for the uncompressed size
223*/ 223*/
224 224
225extern int ZEXPORT zipClose OF((zipFile file, 225extern int ZEXPORT zipClose OF((zipFile file,
226 const char* global_comment)); 226 const char* global_comment));
227/* 227/*
228 Close the zipfile 228 Close the zipfile
229*/ 229*/
230 230
231#ifdef __cplusplus 231#ifdef __cplusplus
232} 232}
233#endif 233#endif
234 234
235#endif /* _zip_H */ 235#endif /* _zip_H */
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-03-16 07:19:11 +0000