summaryrefslogtreecommitdiff
path: root/contrib/minizip
diff options
context:
space:
mode:
Diffstat (limited to 'contrib/minizip')
-rw-r--r--contrib/minizip/ChangeLogUnzip98
-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.c542
-rw-r--r--contrib/minizip/iowin32.h38
-rw-r--r--contrib/minizip/miniunz.c1099
-rw-r--r--contrib/minizip/minizip.c789
-rw-r--r--contrib/minizip/unzip.c3060
-rw-r--r--contrib/minizip/unzip.h684
-rw-r--r--contrib/minizip/zconf.h326
-rw-r--r--contrib/minizip/zip.c2336
-rw-r--r--contrib/minizip/zip.h470
14 files changed, 5277 insertions, 4927 deletions
diff --git a/contrib/minizip/ChangeLogUnzip b/contrib/minizip/ChangeLogUnzip
index 18316fc..45fd099 100644
--- a/contrib/minizip/ChangeLogUnzip
+++ b/contrib/minizip/ChangeLogUnzip
@@ -1,47 +1,51 @@
1Change in 0.21: (10 Mar 03) 1Change in 0.22: (19 May 03)
2- bug fixes 2- crypting support (unless you define NOCRYPT)
3 3- append file in existing zipfile
4Change in 0.17: (27 Jan 02) 4
5- bug fixes 5Change in 0.21: (10 Mar 03)
6 6- bug fixes
7Change in 0.16: (19 Jan 02) 7
8- Support of ioapi for virtualize zip file access 8Change in 0.17: (27 Jan 02)
9 9- bug fixes
10Change in 0.15: (19 Mar 98) 10
11- fix memory leak in minizip.c 11Change in 0.16: (19 Jan 02)
12 12- Support of ioapi for virtualize zip file access
13Change in 0.14: (10 Mar 98) 13
14- fix bugs in minizip.c sample for zipping big file 14Change in 0.15: (19 Mar 98)
15- fix problem in month in date handling 15- fix memory leak in minizip.c
16- fix bug in unzlocal_GetCurrentFileInfoInternal in unzip.c for 16
17 comment handling 17Change in 0.14: (10 Mar 98)
18 18- fix bugs in minizip.c sample for zipping big file
19Change in 0.13: (6 Mar 98) 19- fix problem in month in date handling
20- fix bugs in zip.c 20- fix bug in unzlocal_GetCurrentFileInfoInternal in unzip.c for
21- add real minizip sample 21 comment handling
22 22
23Change in 0.12: (4 Mar 98) 23Change in 0.13: (6 Mar 98)
24- add zip.c and zip.h for creates .zip file 24- fix bugs in zip.c
25- fix change_file_date in miniunz.c for Unix (Jean-loup Gailly) 25- add real minizip sample
26- fix miniunz.c for file without specific record for directory 26
27 27Change in 0.12: (4 Mar 98)
28Change in 0.11: (3 Mar 98) 28- add zip.c and zip.h for creates .zip file
29- fix bug in unzGetCurrentFileInfo for get extra field and comment 29- fix change_file_date in miniunz.c for Unix (Jean-loup Gailly)
30- enhance miniunz sample, remove the bad unztst.c sample 30- fix miniunz.c for file without specific record for directory
31 31
32Change in 0.10: (2 Mar 98) 32Change in 0.11: (3 Mar 98)
33- fix bug in unzReadCurrentFile 33- fix bug in unzGetCurrentFileInfo for get extra field and comment
34- rename unzip* to unz* function and structure 34- enhance miniunz sample, remove the bad unztst.c sample
35- remove Windows-like hungary notation variable name 35
36- modify some structure in unzip.h 36Change in 0.10: (2 Mar 98)
37- add somes comment in source 37- fix bug in unzReadCurrentFile
38- remove unzipGetcCurrentFile function 38- rename unzip* to unz* function and structure
39- replace ZUNZEXPORT by ZEXPORT 39- remove Windows-like hungary notation variable name
40- add unzGetLocalExtrafield for get the local extrafield info 40- modify some structure in unzip.h
41- add a new sample, miniunz.c 41- add somes comment in source
42 42- remove unzipGetcCurrentFile function
43Change in 0.4: (25 Feb 98) 43- replace ZUNZEXPORT by ZEXPORT
44- suppress the type unzipFileInZip. 44- add unzGetLocalExtrafield for get the local extrafield info
45 Only on file in the zipfile can be open at the same time 45- add a new sample, miniunz.c
46- fix somes typo in code 46
47- added tm_unz structure in unzip_file_info (date/time in readable format) 47Change in 0.4: (25 Feb 98)
48- suppress the type unzipFileInZip.
49 Only on file in the zipfile can be open at the same time
50- fix somes typo in code
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 84eaad2..fbba3ac 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 e5bc627..83e763c 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 (unsigned long)3141592654L /* 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 d35d5f5..61c6e2b 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.21, March 10th, 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 f30fe7a..6b8f1f1 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.21, March 10th, 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 f1f5546..53198b6 100644
--- a/contrib/minizip/iowin32.c
+++ b/contrib/minizip/iowin32.c
@@ -1,271 +1,271 @@
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.21, March 10th, 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 <windows.h>
11#include <stdlib.h> 11#include <stdlib.h>
12 12
13#include "zlib.h" 13#include "zlib.h"
14#include "ioapi.h" 14#include "ioapi.h"
15#include "iowin32.h" 15#include "iowin32.h"
16 16
17#ifndef INVALID_HANDLE_VALUE 17#ifndef INVALID_HANDLE_VALUE
18#define INVALID_HANDLE_VALUE (0xFFFFFFFF) 18#define INVALID_HANDLE_VALUE (0xFFFFFFFF)
19#endif 19#endif
20 20
21#ifndef INVALID_SET_FILE_POINTER 21#ifndef INVALID_SET_FILE_POINTER
22#define INVALID_SET_FILE_POINTER ((DWORD)-1) 22#define INVALID_SET_FILE_POINTER ((DWORD)-1)
23#endif 23#endif
24 24
25voidpf ZCALLBACK win32_open_file_func OF(( 25voidpf ZCALLBACK win32_open_file_func OF((
26 voidpf opaque, 26 voidpf opaque,
27 const char* filename, 27 const char* filename,
28 int mode)); 28 int mode));
29 29
30uLong ZCALLBACK win32_read_file_func OF(( 30uLong ZCALLBACK win32_read_file_func OF((
31 voidpf opaque, 31 voidpf opaque,
32 voidpf stream, 32 voidpf stream,
33 void* buf, 33 void* buf,
34 uLong size)); 34 uLong size));
35 35
36uLong ZCALLBACK win32_write_file_func OF(( 36uLong ZCALLBACK win32_write_file_func OF((
37 voidpf opaque, 37 voidpf opaque,
38 voidpf stream, 38 voidpf stream,
39 const void* buf, 39 const void* buf,
40 uLong size)); 40 uLong size));
41 41
42long ZCALLBACK win32_tell_file_func OF(( 42long ZCALLBACK win32_tell_file_func OF((
43 voidpf opaque, 43 voidpf opaque,
44 voidpf stream)); 44 voidpf stream));
45 45
46long ZCALLBACK win32_seek_file_func OF(( 46long ZCALLBACK win32_seek_file_func OF((
47 voidpf opaque, 47 voidpf opaque,
48 voidpf stream, 48 voidpf stream,
49 uLong offset, 49 uLong offset,
50 int origin)); 50 int origin));
51 51
52long ZCALLBACK win32_close_file_func OF(( 52long ZCALLBACK win32_close_file_func OF((
53 voidpf opaque, 53 voidpf opaque,
54 voidpf stream)); 54 voidpf stream));
55 55
56int ZCALLBACK win32_error_file_func OF(( 56int ZCALLBACK win32_error_file_func OF((
57 voidpf opaque, 57 voidpf opaque,
58 voidpf stream)); 58 voidpf stream));
59 59
60typedef struct 60typedef struct
61{ 61{
62 HANDLE hf; 62 HANDLE hf;
63 int error; 63 int error;
64} WIN32FILE_IOWIN; 64} WIN32FILE_IOWIN;
65 65
66voidpf ZCALLBACK win32_open_file_func (opaque, filename, mode) 66voidpf ZCALLBACK win32_open_file_func (opaque, filename, mode)
67 voidpf opaque; 67 voidpf opaque;
68 const char* filename; 68 const char* filename;
69 int mode; 69 int mode;
70{ 70{
71 const char* mode_fopen = NULL; 71 const char* mode_fopen = NULL;
72 DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ; 72 DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
73 HANDLE hFile = 0; 73 HANDLE hFile = 0;
74 voidpf ret=NULL; 74 voidpf ret=NULL;
75 75
76 dwDesiredAccess = dwShareMode = dwFlagsAndAttributes = 0; 76 dwDesiredAccess = dwShareMode = dwFlagsAndAttributes = 0;
77 77
78 if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ) 78 if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
79 { 79 {
80 dwDesiredAccess = GENERIC_READ; 80 dwDesiredAccess = GENERIC_READ;
81 dwCreationDisposition = OPEN_EXISTING; 81 dwCreationDisposition = OPEN_EXISTING;
82 dwShareMode = FILE_SHARE_READ; 82 dwShareMode = FILE_SHARE_READ;
83 } 83 }
84 else 84 else
85 if (mode & ZLIB_FILEFUNC_MODE_EXISTING) 85 if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
86 { 86 {
87 dwDesiredAccess = GENERIC_WRITE | GENERIC_READ; 87 dwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
88 dwCreationDisposition = OPEN_EXISTING; 88 dwCreationDisposition = OPEN_EXISTING;
89 } 89 }
90 else 90 else
91 if (mode & ZLIB_FILEFUNC_MODE_CREATE) 91 if (mode & ZLIB_FILEFUNC_MODE_CREATE)
92 { 92 {
93 dwDesiredAccess = GENERIC_WRITE | GENERIC_READ; 93 dwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
94 dwCreationDisposition = CREATE_ALWAYS; 94 dwCreationDisposition = CREATE_ALWAYS;
95 } 95 }
96 96
97 if ((filename!=NULL) && (dwDesiredAccess != 0)) 97 if ((filename!=NULL) && (dwDesiredAccess != 0))
98 hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, 98 hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL,
99 dwCreationDisposition, dwFlagsAndAttributes, NULL); 99 dwCreationDisposition, dwFlagsAndAttributes, NULL);
100 100
101 if (hFile == INVALID_HANDLE_VALUE) 101 if (hFile == INVALID_HANDLE_VALUE)
102 hFile = NULL; 102 hFile = NULL;
103 103
104 if (hFile != NULL) 104 if (hFile != NULL)
105 { 105 {
106 WIN32FILE_IOWIN w32fiow; 106 WIN32FILE_IOWIN w32fiow;
107 w32fiow.hf = hFile; 107 w32fiow.hf = hFile;
108 w32fiow.error = 0; 108 w32fiow.error = 0;
109 ret = malloc(sizeof(WIN32FILE_IOWIN)); 109 ret = malloc(sizeof(WIN32FILE_IOWIN));
110 if (ret==NULL) 110 if (ret==NULL)
111 CloseHandle(hFile); 111 CloseHandle(hFile);
112 else *((WIN32FILE_IOWIN*)ret) = w32fiow; 112 else *((WIN32FILE_IOWIN*)ret) = w32fiow;
113 } 113 }
114 return ret; 114 return ret;
115} 115}
116 116
117 117
118uLong ZCALLBACK win32_read_file_func (opaque, stream, buf, size) 118uLong ZCALLBACK win32_read_file_func (opaque, stream, buf, size)
119 voidpf opaque; 119 voidpf opaque;
120 voidpf stream; 120 voidpf stream;
121 void* buf; 121 void* buf;
122 uLong size; 122 uLong size;
123{ 123{
124 uLong ret=0; 124 uLong ret=0;
125 HANDLE hFile = NULL; 125 HANDLE hFile = NULL;
126 if (stream!=NULL) 126 if (stream!=NULL)
127 hFile = ((WIN32FILE_IOWIN*)stream) -> hf; 127 hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
128 if (hFile != NULL) 128 if (hFile != NULL)
129 if (!ReadFile(hFile, buf, size, &ret, NULL)) 129 if (!ReadFile(hFile, buf, size, &ret, NULL))
130 { 130 {
131 DWORD dwErr = GetLastError(); 131 DWORD dwErr = GetLastError();
132 if (dwErr == ERROR_HANDLE_EOF) 132 if (dwErr == ERROR_HANDLE_EOF)
133 dwErr = 0; 133 dwErr = 0;
134 ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; 134 ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
135 } 135 }
136 136
137 return ret; 137 return ret;
138} 138}
139 139
140 140
141uLong ZCALLBACK win32_write_file_func (opaque, stream, buf, size) 141uLong ZCALLBACK win32_write_file_func (opaque, stream, buf, size)
142 voidpf opaque; 142 voidpf opaque;
143 voidpf stream; 143 voidpf stream;
144 const void* buf; 144 const void* buf;
145 uLong size; 145 uLong size;
146{ 146{
147 uLong ret=0; 147 uLong ret=0;
148 HANDLE hFile = NULL; 148 HANDLE hFile = NULL;
149 if (stream!=NULL) 149 if (stream!=NULL)
150 hFile = ((WIN32FILE_IOWIN*)stream) -> hf; 150 hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
151 151
152 if (hFile !=NULL) 152 if (hFile !=NULL)
153 if (!WriteFile(hFile, buf, size, &ret, NULL)) 153 if (!WriteFile(hFile, buf, size, &ret, NULL))
154 { 154 {
155 DWORD dwErr = GetLastError(); 155 DWORD dwErr = GetLastError();
156 if (dwErr == ERROR_HANDLE_EOF) 156 if (dwErr == ERROR_HANDLE_EOF)
157 dwErr = 0; 157 dwErr = 0;
158 ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; 158 ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
159 } 159 }
160 160
161 return ret; 161 return ret;
162} 162}
163 163
164long ZCALLBACK win32_tell_file_func (opaque, stream) 164long ZCALLBACK win32_tell_file_func (opaque, stream)
165 voidpf opaque; 165 voidpf opaque;
166 voidpf stream; 166 voidpf stream;
167{ 167{
168 long ret=-1; 168 long ret=-1;
169 HANDLE hFile = NULL; 169 HANDLE hFile = NULL;
170 if (stream!=NULL) 170 if (stream!=NULL)
171 hFile = ((WIN32FILE_IOWIN*)stream) -> hf; 171 hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
172 if (hFile != NULL) 172 if (hFile != NULL)
173 { 173 {
174 DWORD dwSet = SetFilePointer(hFile, 0, NULL, FILE_CURRENT); 174 DWORD dwSet = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
175 if (dwSet == INVALID_SET_FILE_POINTER) 175 if (dwSet == INVALID_SET_FILE_POINTER)
176 { 176 {
177 DWORD dwErr = GetLastError(); 177 DWORD dwErr = GetLastError();
178 ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; 178 ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
179 ret = -1; 179 ret = -1;
180 } 180 }
181 else 181 else
182 ret=(long)dwSet; 182 ret=(long)dwSet;
183 } 183 }
184 return ret; 184 return ret;
185} 185}
186 186
187long ZCALLBACK win32_seek_file_func (opaque, stream, offset, origin) 187long ZCALLBACK win32_seek_file_func (opaque, stream, offset, origin)
188 voidpf opaque; 188 voidpf opaque;
189 voidpf stream; 189 voidpf stream;
190 uLong offset; 190 uLong offset;
191 int origin; 191 int origin;
192{ 192{
193 DWORD dwMoveMethod=0xFFFFFFFF; 193 DWORD dwMoveMethod=0xFFFFFFFF;
194 HANDLE hFile = NULL; 194 HANDLE hFile = NULL;
195 195
196 long ret=-1; 196 long ret=-1;
197 if (stream!=NULL) 197 if (stream!=NULL)
198 hFile = ((WIN32FILE_IOWIN*)stream) -> hf; 198 hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
199 switch (origin) 199 switch (origin)
200 { 200 {
201 case ZLIB_FILEFUNC_SEEK_CUR : 201 case ZLIB_FILEFUNC_SEEK_CUR :
202 dwMoveMethod = FILE_CURRENT; 202 dwMoveMethod = FILE_CURRENT;
203 break; 203 break;
204 case ZLIB_FILEFUNC_SEEK_END : 204 case ZLIB_FILEFUNC_SEEK_END :
205 dwMoveMethod = FILE_END; 205 dwMoveMethod = FILE_END;
206 break; 206 break;
207 case ZLIB_FILEFUNC_SEEK_SET : 207 case ZLIB_FILEFUNC_SEEK_SET :
208 dwMoveMethod = FILE_BEGIN; 208 dwMoveMethod = FILE_BEGIN;
209 break; 209 break;
210 default: return -1; 210 default: return -1;
211 } 211 }
212 212
213 if (hFile != NULL) 213 if (hFile != NULL)
214 { 214 {
215 DWORD dwSet = SetFilePointer(hFile, offset, NULL, dwMoveMethod); 215 DWORD dwSet = SetFilePointer(hFile, offset, NULL, dwMoveMethod);
216 if (dwSet == INVALID_SET_FILE_POINTER) 216 if (dwSet == INVALID_SET_FILE_POINTER)
217 { 217 {
218 DWORD dwErr = GetLastError(); 218 DWORD dwErr = GetLastError();
219 ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; 219 ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
220 ret = -1; 220 ret = -1;
221 } 221 }
222 else 222 else
223 ret=0; 223 ret=0;
224 } 224 }
225 return ret; 225 return ret;
226} 226}
227 227
228long ZCALLBACK win32_close_file_func (opaque, stream) 228long ZCALLBACK win32_close_file_func (opaque, stream)
229 voidpf opaque; 229 voidpf opaque;
230 voidpf stream; 230 voidpf stream;
231{ 231{
232 long ret=-1; 232 long ret=-1;
233 233
234 if (stream!=NULL) 234 if (stream!=NULL)
235 { 235 {
236 HANDLE hFile; 236 HANDLE hFile;
237 hFile = ((WIN32FILE_IOWIN*)stream) -> hf; 237 hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
238 if (hFile != NULL) 238 if (hFile != NULL)
239 { 239 {
240 CloseHandle(hFile); 240 CloseHandle(hFile);
241 ret=0; 241 ret=0;
242 } 242 }
243 free(stream); 243 free(stream);
244 } 244 }
245 return ret; 245 return ret;
246} 246}
247 247
248int ZCALLBACK win32_error_file_func (opaque, stream) 248int ZCALLBACK win32_error_file_func (opaque, stream)
249 voidpf opaque; 249 voidpf opaque;
250 voidpf stream; 250 voidpf stream;
251{ 251{
252 int ret=-1; 252 int ret=-1;
253 if (stream!=NULL) 253 if (stream!=NULL)
254 { 254 {
255 ret = ((WIN32FILE_IOWIN*)stream) -> error; 255 ret = ((WIN32FILE_IOWIN*)stream) -> error;
256 } 256 }
257 return ret; 257 return ret;
258} 258}
259 259
260void fill_win32_filefunc (pzlib_filefunc_def) 260void fill_win32_filefunc (pzlib_filefunc_def)
261 zlib_filefunc_def* pzlib_filefunc_def; 261 zlib_filefunc_def* pzlib_filefunc_def;
262{ 262{
263 pzlib_filefunc_def->zopen_file = win32_open_file_func; 263 pzlib_filefunc_def->zopen_file = win32_open_file_func;
264 pzlib_filefunc_def->zread_file = win32_read_file_func; 264 pzlib_filefunc_def->zread_file = win32_read_file_func;
265 pzlib_filefunc_def->zwrite_file = win32_write_file_func; 265 pzlib_filefunc_def->zwrite_file = win32_write_file_func;
266 pzlib_filefunc_def->ztell_file = win32_tell_file_func; 266 pzlib_filefunc_def->ztell_file = win32_tell_file_func;
267 pzlib_filefunc_def->zseek_file = win32_seek_file_func; 267 pzlib_filefunc_def->zseek_file = win32_seek_file_func;
268 pzlib_filefunc_def->zclose_file = win32_close_file_func; 268 pzlib_filefunc_def->zclose_file = win32_close_file_func;
269 pzlib_filefunc_def->zerror_file = win32_error_file_func; 269 pzlib_filefunc_def->zerror_file = win32_error_file_func;
270 pzlib_filefunc_def->opaque=NULL; 270 pzlib_filefunc_def->opaque=NULL;
271} 271}
diff --git a/contrib/minizip/iowin32.h b/contrib/minizip/iowin32.h
index d2f5e37..713fc02 100644
--- a/contrib/minizip/iowin32.h
+++ b/contrib/minizip/iowin32.h
@@ -1,19 +1,19 @@
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.21, March 10th, 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#ifdef __cplusplus
11extern "C" { 11extern "C" {
12#endif 12#endif
13 13
14void fill_win32_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def)); 14void fill_win32_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
15 15
16 16
17#ifdef __cplusplus 17#ifdef __cplusplus
18} 18}
19#endif 19#endif
diff --git a/contrib/minizip/miniunz.c b/contrib/minizip/miniunz.c
index 938d4ef..ea23e40 100644
--- a/contrib/minizip/miniunz.c
+++ b/contrib/minizip/miniunz.c
@@ -1,543 +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.15, 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 [-exvlo] file.zip [file_to_extract]\n\n") ; 149 printf("Usage : miniunz [-e] [-x] [-v] [-l] [-o] [-p password] file.zip [file_to_extr.]\n\n" \
150} 150 " -e Extract without pathname (junk paths)\n" \
151 151 " -x Extract with pathname\n" \
152 152 " -v list files\n" \
153int do_list(uf) 153 " -l list files\n" \
154 unzFile uf; 154 " -o overwrite files without prompting\n" \
155{ 155 " -p extract crypted file using password\n\n");
156 uLong i; 156}
157 unz_global_info gi; 157
158 int err; 158
159 159int do_list(uf)
160 err = unzGetGlobalInfo (uf,&gi); 160 unzFile uf;
161 if (err!=UNZ_OK) 161{
162 printf("error %d with zipfile in unzGetGlobalInfo \n",err); 162 uLong i;
163 printf(" Length Method Size Ratio Date Time CRC-32 Name\n"); 163 unz_global_info gi;
164 printf(" ------ ------ ---- ----- ---- ---- ------ ----\n"); 164 int err;
165 for (i=0;i<gi.number_entry;i++) 165
166 { 166 err = unzGetGlobalInfo (uf,&gi);
167 char filename_inzip[256]; 167 if (err!=UNZ_OK)
168 unz_file_info file_info; 168 printf("error %d with zipfile in unzGetGlobalInfo \n",err);
169 uLong ratio=0; 169 printf(" Length Method Size Ratio Date Time CRC-32 Name\n");
170 const char *string_method; 170 printf(" ------ ------ ---- ----- ---- ---- ------ ----\n");
171 err = unzGetCurrentFileInfo(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0); 171 for (i=0;i<gi.number_entry;i++)
172 if (err!=UNZ_OK) 172 {
173 { 173 char filename_inzip[256];
174 printf("error %d with zipfile in unzGetCurrentFileInfo\n",err); 174 unz_file_info file_info;
175 break; 175 uLong ratio=0;
176 } 176 const char *string_method;
177 if (file_info.uncompressed_size>0) 177 char charCrypt=' ';
178 ratio = (file_info.compressed_size*100)/file_info.uncompressed_size; 178 err = unzGetCurrentFileInfo(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0);
179 179 if (err!=UNZ_OK)
180 if (file_info.compression_method==0) 180 {
181 string_method="Stored"; 181 printf("error %d with zipfile in unzGetCurrentFileInfo\n",err);
182 else 182 break;
183 if (file_info.compression_method==Z_DEFLATED) 183 }
184 { 184 if (file_info.uncompressed_size>0)
185 uInt iLevel=(uInt)((file_info.flag & 0x6)/2); 185 ratio = (file_info.compressed_size*100)/file_info.uncompressed_size;
186 if (iLevel==0) 186
187 string_method="Defl:N"; 187 /* display a '*' if the file is crypted */
188 else if (iLevel==1) 188 if ((file_info.flag & 1) != 0)
189 string_method="Defl:X"; 189 charCrypt='*';
190 else if ((iLevel==2) || (iLevel==3)) 190
191 string_method="Defl:F"; /* 2:fast , 3 : extra fast*/ 191 if (file_info.compression_method==0)
192 } 192 string_method="Stored";
193 else 193 else
194 string_method="Unkn. "; 194 if (file_info.compression_method==Z_DEFLATED)
195 195 {
196 printf("%7lu %6s %7lu %3lu%% %2.2lu-%2.2lu-%2.2lu %2.2lu:%2.2lu %8.8lx %s\n", 196 uInt iLevel=(uInt)((file_info.flag & 0x6)/2);
197 file_info.uncompressed_size,string_method,file_info.compressed_size, 197 if (iLevel==0)
198 ratio, 198 string_method="Defl:N";
199 (uLong)file_info.tmu_date.tm_mon + 1, 199 else if (iLevel==1)
200 (uLong)file_info.tmu_date.tm_mday, 200 string_method="Defl:X";
201 (uLong)file_info.tmu_date.tm_year % 100, 201 else if ((iLevel==2) || (iLevel==3))
202 (uLong)file_info.tmu_date.tm_hour,(uLong)file_info.tmu_date.tm_min, 202 string_method="Defl:F"; /* 2:fast , 3 : extra fast*/
203 (uLong)file_info.crc,filename_inzip); 203 }
204 if ((i+1)<gi.number_entry) 204 else
205 { 205 string_method="Unkn. ";
206 err = unzGoToNextFile(uf); 206
207 if (err!=UNZ_OK) 207 printf("%7lu %6s%c%7lu %3lu%% %2.2lu-%2.2lu-%2.2lu %2.2lu:%2.2lu %8.8lx %s\n",
208 { 208 file_info.uncompressed_size,string_method,
209 printf("error %d with zipfile in unzGoToNextFile\n",err); 209 charCrypt,
210 break; 210 file_info.compressed_size,
211 } 211 ratio,
212 } 212 (uLong)file_info.tmu_date.tm_mon + 1,
213 } 213 (uLong)file_info.tmu_date.tm_mday,
214 214 (uLong)file_info.tmu_date.tm_year % 100,
215 return 0; 215 (uLong)file_info.tmu_date.tm_hour,(uLong)file_info.tmu_date.tm_min,
216} 216 (uLong)file_info.crc,filename_inzip);
217 217 if ((i+1)<gi.number_entry)
218 218 {
219int do_extract_currentfile(uf,popt_extract_without_path,popt_overwrite,password) 219 err = unzGoToNextFile(uf);
220 unzFile uf; 220 if (err!=UNZ_OK)
221 const int* popt_extract_without_path; 221 {
222 int* popt_overwrite; 222 printf("error %d with zipfile in unzGoToNextFile\n",err);
223 const char* password; 223 break;
224{ 224 }
225 char filename_inzip[256]; 225 }
226 char* filename_withoutpath; 226 }
227 char* p; 227
228 int err=UNZ_OK; 228 return 0;
229 FILE *fout=NULL; 229}
230 void* buf; 230
231 uInt size_buf; 231
232 232int do_extract_currentfile(uf,popt_extract_without_path,popt_overwrite,password)
233 unz_file_info file_info; 233 unzFile uf;
234 uLong ratio=0; 234 const int* popt_extract_without_path;
235 err = unzGetCurrentFileInfo(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0); 235 int* popt_overwrite;
236 236 const char* password;
237 if (err!=UNZ_OK) 237{
238 { 238 char filename_inzip[256];
239 printf("error %d with zipfile in unzGetCurrentFileInfo\n",err); 239 char* filename_withoutpath;
240 return err; 240 char* p;
241 } 241 int err=UNZ_OK;
242 242 FILE *fout=NULL;
243 size_buf = WRITEBUFFERSIZE; 243 void* buf;
244 buf = (void*)malloc(size_buf); 244 uInt size_buf;
245 if (buf==NULL) 245
246 { 246 unz_file_info file_info;
247 printf("Error allocating memory\n"); 247 uLong ratio=0;
248 return UNZ_INTERNALERROR; 248 err = unzGetCurrentFileInfo(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0);
249 } 249
250 250 if (err!=UNZ_OK)
251 p = filename_withoutpath = filename_inzip; 251 {
252 while ((*p) != '\0') 252 printf("error %d with zipfile in unzGetCurrentFileInfo\n",err);
253 { 253 return err;
254 if (((*p)=='/') || ((*p)=='\\')) 254 }
255 filename_withoutpath = p+1; 255
256 p++; 256 size_buf = WRITEBUFFERSIZE;
257 } 257 buf = (void*)malloc(size_buf);
258 258 if (buf==NULL)
259 if ((*filename_withoutpath)=='\0') 259 {
260 { 260 printf("Error allocating memory\n");
261 if ((*popt_extract_without_path)==0) 261 return UNZ_INTERNALERROR;
262 { 262 }
263 printf("creating directory: %s\n",filename_inzip); 263
264 mymkdir(filename_inzip); 264 p = filename_withoutpath = filename_inzip;
265 } 265 while ((*p) != '\0')
266 } 266 {
267 else 267 if (((*p)=='/') || ((*p)=='\\'))
268 { 268 filename_withoutpath = p+1;
269 const char* write_filename; 269 p++;
270 int skip=0; 270 }
271 271
272 if ((*popt_extract_without_path)==0) 272 if ((*filename_withoutpath)=='\0')
273 write_filename = filename_inzip; 273 {
274 else 274 if ((*popt_extract_without_path)==0)
275 write_filename = filename_withoutpath; 275 {
276 276 printf("creating directory: %s\n",filename_inzip);
277 err = unzOpenCurrentFilePassword(uf,password); 277 mymkdir(filename_inzip);
278 if (err!=UNZ_OK) 278 }
279 { 279 }
280 printf("error %d with zipfile in unzOpenCurrentFilePassword\n",err); 280 else
281 } 281 {
282 282 const char* write_filename;
283 if (((*popt_overwrite)==0) && (err==UNZ_OK)) 283 int skip=0;
284 { 284
285 char rep=0; 285 if ((*popt_extract_without_path)==0)
286 FILE* ftestexist; 286 write_filename = filename_inzip;
287 ftestexist = fopen(write_filename,"rb"); 287 else
288 if (ftestexist!=NULL) 288 write_filename = filename_withoutpath;
289 { 289
290 fclose(ftestexist); 290 err = unzOpenCurrentFilePassword(uf,password);
291 do 291 if (err!=UNZ_OK)
292 { 292 {
293 char answer[128]; 293 printf("error %d with zipfile in unzOpenCurrentFilePassword\n",err);
294 printf("The file %s exist. Overwrite ? [y]es, [n]o, [A]ll: ",write_filename); 294 }
295 scanf("%1s",answer); 295
296 rep = answer[0] ; 296 if (((*popt_overwrite)==0) && (err==UNZ_OK))
297 if ((rep>='a') && (rep<='z')) 297 {
298 rep -= 0x20; 298 char rep=0;
299 } 299 FILE* ftestexist;
300 while ((rep!='Y') && (rep!='N') && (rep!='A')); 300 ftestexist = fopen(write_filename,"rb");
301 } 301 if (ftestexist!=NULL)
302 302 {
303 if (rep == 'N') 303 fclose(ftestexist);
304 skip = 1; 304 do
305 305 {
306 if (rep == 'A') 306 char answer[128];
307 *popt_overwrite=1; 307 printf("The file %s exist. Overwrite ? [y]es, [n]o, [A]ll: ",write_filename);
308 } 308 scanf("%1s",answer);
309 309 rep = answer[0] ;
310 if ((skip==0) && (err==UNZ_OK)) 310 if ((rep>='a') && (rep<='z'))
311 { 311 rep -= 0x20;
312 fout=fopen(write_filename,"wb"); 312 }
313 313 while ((rep!='Y') && (rep!='N') && (rep!='A'));
314 /* some zipfile don't contain directory alone before file */ 314 }
315 if ((fout==NULL) && ((*popt_extract_without_path)==0) && 315
316 (filename_withoutpath!=(char*)filename_inzip)) 316 if (rep == 'N')
317 { 317 skip = 1;
318 char c=*(filename_withoutpath-1); 318
319 *(filename_withoutpath-1)='\0'; 319 if (rep == 'A')
320 makedir(write_filename); 320 *popt_overwrite=1;
321 *(filename_withoutpath-1)=c; 321 }
322 fout=fopen(write_filename,"wb"); 322
323 } 323 if ((skip==0) && (err==UNZ_OK))
324 324 {
325 if (fout==NULL) 325 fout=fopen(write_filename,"wb");
326 { 326
327 printf("error opening %s\n",write_filename); 327 /* some zipfile don't contain directory alone before file */
328 } 328 if ((fout==NULL) && ((*popt_extract_without_path)==0) &&
329 } 329 (filename_withoutpath!=(char*)filename_inzip))
330 330 {
331 if (fout!=NULL) 331 char c=*(filename_withoutpath-1);
332 { 332 *(filename_withoutpath-1)='\0';
333 printf(" extracting: %s\n",write_filename); 333 makedir(write_filename);
334 334 *(filename_withoutpath-1)=c;
335 do 335 fout=fopen(write_filename,"wb");
336 { 336 }
337 err = unzReadCurrentFile(uf,buf,size_buf); 337
338 if (err<0) 338 if (fout==NULL)
339 { 339 {
340 printf("error %d with zipfile in unzReadCurrentFile\n",err); 340 printf("error opening %s\n",write_filename);
341 break; 341 }
342 } 342 }
343 if (err>0) 343
344 if (fwrite(buf,err,1,fout)!=1) 344 if (fout!=NULL)
345 { 345 {
346 printf("error in writing extracted file\n"); 346 printf(" extracting: %s\n",write_filename);
347 err=UNZ_ERRNO; 347
348 break; 348 do
349 } 349 {
350 } 350 err = unzReadCurrentFile(uf,buf,size_buf);
351 while (err>0); 351 if (err<0)
352 if (fout) 352 {
353 fclose(fout); 353 printf("error %d with zipfile in unzReadCurrentFile\n",err);
354 354 break;
355 if (err==0) 355 }
356 change_file_date(write_filename,file_info.dosDate, 356 if (err>0)
357 file_info.tmu_date); 357 if (fwrite(buf,err,1,fout)!=1)
358 } 358 {
359 359 printf("error in writing extracted file\n");
360 if (err==UNZ_OK) 360 err=UNZ_ERRNO;
361 { 361 break;
362 err = unzCloseCurrentFile (uf); 362 }
363 if (err!=UNZ_OK) 363 }
364 { 364 while (err>0);
365 printf("error %d with zipfile in unzCloseCurrentFile\n",err); 365 if (fout)
366 } 366 fclose(fout);
367 } 367
368 else 368 if (err==0)
369 unzCloseCurrentFile(uf); /* don't lose the error */ 369 change_file_date(write_filename,file_info.dosDate,
370 } 370 file_info.tmu_date);
371 371 }
372 free(buf); 372
373 return err; 373 if (err==UNZ_OK)
374} 374 {
375 375 err = unzCloseCurrentFile (uf);
376 376 if (err!=UNZ_OK)
377int do_extract(uf,opt_extract_without_path,opt_overwrite,password) 377 {
378 unzFile uf; 378 printf("error %d with zipfile in unzCloseCurrentFile\n",err);
379 int opt_extract_without_path; 379 }
380 int opt_overwrite; 380 }
381 const char* password; 381 else
382{ 382 unzCloseCurrentFile(uf); /* don't lose the error */
383 uLong i; 383 }
384 unz_global_info gi; 384
385 int err; 385 free(buf);
386 FILE* fout=NULL; 386 return err;
387 387}
388 err = unzGetGlobalInfo (uf,&gi); 388
389 if (err!=UNZ_OK) 389
390 printf("error %d with zipfile in unzGetGlobalInfo \n",err); 390int do_extract(uf,opt_extract_without_path,opt_overwrite,password)
391 391 unzFile uf;
392 for (i=0;i<gi.number_entry;i++) 392 int opt_extract_without_path;
393 { 393 int opt_overwrite;
394 if (do_extract_currentfile(uf,&opt_extract_without_path, 394 const char* password;
395 &opt_overwrite, 395{
396 password) != UNZ_OK) 396 uLong i;
397 break; 397 unz_global_info gi;
398 398 int err;
399 if ((i+1)<gi.number_entry) 399 FILE* fout=NULL;
400 { 400
401 err = unzGoToNextFile(uf); 401 err = unzGetGlobalInfo (uf,&gi);
402 if (err!=UNZ_OK) 402 if (err!=UNZ_OK)
403 { 403 printf("error %d with zipfile in unzGetGlobalInfo \n",err);
404 printf("error %d with zipfile in unzGoToNextFile\n",err); 404
405 break; 405 for (i=0;i<gi.number_entry;i++)
406 } 406 {
407 } 407 if (do_extract_currentfile(uf,&opt_extract_without_path,
408 } 408 &opt_overwrite,
409 409 password) != UNZ_OK)
410 return 0; 410 break;
411} 411
412 412 if ((i+1)<gi.number_entry)
413int do_extract_onefile(uf,filename,opt_extract_without_path,opt_overwrite,password) 413 {
414 unzFile uf; 414 err = unzGoToNextFile(uf);
415 const char* filename; 415 if (err!=UNZ_OK)
416 int opt_extract_without_path; 416 {
417 int opt_overwrite; 417 printf("error %d with zipfile in unzGoToNextFile\n",err);
418 const char* password; 418 break;
419{ 419 }
420 int err = UNZ_OK; 420 }
421 if (unzLocateFile(uf,filename,CASESENSITIVITY)!=UNZ_OK) 421 }
422 { 422
423 printf("file %s not found in the zipfile\n",filename); 423 return 0;
424 return 2; 424}
425 } 425
426 426int do_extract_onefile(uf,filename,opt_extract_without_path,opt_overwrite,password)
427 if (do_extract_currentfile(uf,&opt_extract_without_path, 427 unzFile uf;
428 &opt_overwrite, 428 const char* filename;
429 password) == UNZ_OK) 429 int opt_extract_without_path;
430 return 0; 430 int opt_overwrite;
431 else 431 const char* password;
432 return 1; 432{
433} 433 int err = UNZ_OK;
434 434 if (unzLocateFile(uf,filename,CASESENSITIVITY)!=UNZ_OK)
435 435 {
436int main(argc,argv) 436 printf("file %s not found in the zipfile\n",filename);
437 int argc; 437 return 2;
438 char *argv[]; 438 }
439{ 439
440 const char *zipfilename=NULL; 440 if (do_extract_currentfile(uf,&opt_extract_without_path,
441 const char *filename_to_extract=NULL; 441 &opt_overwrite,
442 const char *password=NULL; 442 password) == UNZ_OK)
443 char filename_try[MAXFILENAME+16] = ""; 443 return 0;
444 int i; 444 else
445 int opt_do_list=0; 445 return 1;
446 int opt_do_extract=1; 446}
447 int opt_do_extract_withoutpath=0; 447
448 int opt_overwrite=0; 448
449 unzFile uf=NULL; 449int main(argc,argv)
450 450 int argc;
451 do_banner(); 451 char *argv[];
452 if (argc==1) 452{
453 { 453 const char *zipfilename=NULL;
454 do_help(); 454 const char *filename_to_extract=NULL;
455 return 0; 455 const char *password=NULL;
456 } 456 char filename_try[MAXFILENAME+16] = "";
457 else 457 int i;
458 { 458 int opt_do_list=0;
459 for (i=1;i<argc;i++) 459 int opt_do_extract=1;
460 { 460 int opt_do_extract_withoutpath=0;
461 if ((*argv[i])=='-') 461 int opt_overwrite=0;
462 { 462 unzFile uf=NULL;
463 const char *p=argv[i]+1; 463
464 464 do_banner();
465 while ((*p)!='\0') 465 if (argc==1)
466 { 466 {
467 char c=*(p++);; 467 do_help();
468 if ((c=='l') || (c=='L')) 468 return 0;
469 opt_do_list = 1; 469 }
470 if ((c=='v') || (c=='V')) 470 else
471 opt_do_list = 1; 471 {
472 if ((c=='x') || (c=='X')) 472 for (i=1;i<argc;i++)
473 opt_do_extract = 1; 473 {
474 if ((c=='e') || (c=='E')) 474 if ((*argv[i])=='-')
475 opt_do_extract = opt_do_extract_withoutpath = 1; 475 {
476 if ((c=='o') || (c=='O')) 476 const char *p=argv[i]+1;
477 opt_overwrite=1; 477
478 if (((c=='p') || (c=='P')) && (i+1<argc)) 478 while ((*p)!='\0')
479 { 479 {
480 password=argv[i+1]; 480 char c=*(p++);;
481 i++; 481 if ((c=='l') || (c=='L'))
482 } 482 opt_do_list = 1;
483 } 483 if ((c=='v') || (c=='V'))
484 } 484 opt_do_list = 1;
485 else 485 if ((c=='x') || (c=='X'))
486 { 486 opt_do_extract = 1;
487 if (zipfilename == NULL) 487 if ((c=='e') || (c=='E'))
488 zipfilename = argv[i]; 488 opt_do_extract = opt_do_extract_withoutpath = 1;
489 else if (filename_to_extract==NULL) 489 if ((c=='o') || (c=='O'))
490 filename_to_extract = argv[i] ; 490 opt_overwrite=1;
491 } 491 if (((c=='p') || (c=='P')) && (i+1<argc))
492 } 492 {
493 } 493 password=argv[i+1];
494 494 i++;
495 if (zipfilename!=NULL) 495 }
496 { 496 }
497 497 }
498 #ifdef USEWIN32IOAPI 498 else
499 zlib_filefunc_def ffunc; 499 {
500 #endif 500 if (zipfilename == NULL)
501 501 zipfilename = argv[i];
502 strncpy(filename_try, zipfilename,MAXFILENAME-1); 502 else if (filename_to_extract==NULL)
503 /* strncpy doesnt append the trailing NULL, of the string is too long. */ 503 filename_to_extract = argv[i] ;
504 filename_try[ MAXFILENAME ] = '\0'; 504 }
505 505 }
506 #ifdef USEWIN32IOAPI 506 }
507 fill_win32_filefunc(&ffunc); 507
508 uf = unzOpen2(zipfilename,&ffunc); 508 if (zipfilename!=NULL)
509 #else 509 {
510 uf = unzOpen(zipfilename); 510
511 #endif 511 #ifdef USEWIN32IOAPI
512 if (uf==NULL) 512 zlib_filefunc_def ffunc;
513 { 513 #endif
514 strcat(filename_try,".zip"); 514
515 #ifdef USEWIN32IOAPI 515 strncpy(filename_try, zipfilename,MAXFILENAME-1);
516 uf = unzOpen2(filename_try,&ffunc); 516 /* strncpy doesnt append the trailing NULL, of the string is too long. */
517 #else 517 filename_try[ MAXFILENAME ] = '\0';
518 uf = unzOpen(filename_try); 518
519 #endif 519 #ifdef USEWIN32IOAPI
520 } 520 fill_win32_filefunc(&ffunc);
521 } 521 uf = unzOpen2(zipfilename,&ffunc);
522 522 #else
523 if (uf==NULL) 523 uf = unzOpen(zipfilename);
524 { 524 #endif
525 printf("Cannot open %s or %s.zip\n",zipfilename,zipfilename); 525 if (uf==NULL)
526 return 1; 526 {
527 } 527 strcat(filename_try,".zip");
528 printf("%s opened\n",filename_try); 528 #ifdef USEWIN32IOAPI
529 529 uf = unzOpen2(filename_try,&ffunc);
530 if (opt_do_list==1) 530 #else
531 return do_list(uf); 531 uf = unzOpen(filename_try);
532 else if (opt_do_extract==1) 532 #endif
533 { 533 }
534 if (filename_to_extract == NULL) 534 }
535 return do_extract(uf,opt_do_extract_withoutpath,opt_overwrite,password); 535
536 else 536 if (uf==NULL)
537 return do_extract_onefile(uf,filename_to_extract, 537 {
538 opt_do_extract_withoutpath,opt_overwrite,password); 538 printf("Cannot open %s or %s.zip\n",zipfilename,zipfilename);
539 } 539 return 1;
540 unzCloseCurrentFile(uf); 540 }
541 541 printf("%s opened\n",filename_try);
542 return 0; 542
543} 543 if (opt_do_list==1)
544 return do_list(uf);
545 else if (opt_do_extract==1)
546 {
547 if (filename_to_extract == NULL)
548 return do_extract(uf,opt_do_extract_withoutpath,opt_overwrite,password);
549 else
550 return do_extract_onefile(uf,filename_to_extract,
551 opt_do_extract_withoutpath,opt_overwrite,password);
552 }
553 unzCloseCurrentFile(uf);
554
555 return 0;
556}
diff --git a/contrib/minizip/minizip.c b/contrib/minizip/minizip.c
index 5792a1e..79e541d 100644
--- a/contrib/minizip/minizip.c
+++ b/contrib/minizip/minizip.c
@@ -1,392 +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.15, 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] 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} 130 " -o Overwrite existing file.zip\n" \
131 131 " -a Append to existing file.zip\n" \
132/* calculate the CRC32 of a file, 132 " -0 Store only\n" \
133 because to encrypt a file, we need known the CRC32 of the file before */ 133 " -1 Compress faster\n" \
134int getFileCrc(const char* filenameinzip,void*buf,unsigned long size_buf,unsigned long* result_crc) 134 " -9 Compress better\n\n");
135{ 135}
136 unsigned long calculate_crc=0; 136
137 int err=ZIP_OK; 137/* calculate the CRC32 of a file,
138 FILE * fin = fopen(filenameinzip,"rb"); 138 because to encrypt a file, we need known the CRC32 of the file before */
139 unsigned long size_read = 0; 139int getFileCrc(const char* filenameinzip,void*buf,unsigned long size_buf,unsigned long* result_crc)
140 unsigned long total_read = 0; 140{
141 if (fin==NULL) 141 unsigned long calculate_crc=0;
142 { 142 int err=ZIP_OK;
143 err = ZIP_ERRNO; 143 FILE * fin = fopen(filenameinzip,"rb");
144 } 144 unsigned long size_read = 0;
145 145 unsigned long total_read = 0;
146 if (err == ZIP_OK) 146 if (fin==NULL)
147 do 147 {
148 { 148 err = ZIP_ERRNO;
149 err = ZIP_OK; 149 }
150 size_read = (int)fread(buf,1,size_buf,fin); 150
151 if (size_read < size_buf) 151 if (err == ZIP_OK)
152 if (feof(fin)==0) 152 do
153 { 153 {
154 printf("error in reading %s\n",filenameinzip); 154 err = ZIP_OK;
155 err = ZIP_ERRNO; 155 size_read = (int)fread(buf,1,size_buf,fin);
156 } 156 if (size_read < size_buf)
157 157 if (feof(fin)==0)
158 if (size_read>0) 158 {
159 calculate_crc = crc32(calculate_crc,buf,size_read); 159 printf("error in reading %s\n",filenameinzip);
160 total_read += size_read; 160 err = ZIP_ERRNO;
161 161 }
162 } while ((err == ZIP_OK) && (size_read>0)); 162
163 163 if (size_read>0)
164 if (fin) 164 calculate_crc = crc32(calculate_crc,buf,size_read);
165 fclose(fin); 165 total_read += size_read;
166 166
167 *result_crc=calculate_crc; 167 } while ((err == ZIP_OK) && (size_read>0));
168 printf("file %s crc %x\n",filenameinzip,calculate_crc); 168
169 return err; 169 if (fin)
170} 170 fclose(fin);
171 171
172int main(argc,argv) 172 *result_crc=calculate_crc;
173 int argc; 173 printf("file %s crc %x\n",filenameinzip,calculate_crc);
174 char *argv[]; 174 return err;
175{ 175}
176 int i; 176
177 int opt_overwrite=0; 177int main(argc,argv)
178 int opt_compress_level=Z_DEFAULT_COMPRESSION; 178 int argc;
179 int zipfilenamearg = 0; 179 char *argv[];
180 char filename_try[MAXFILENAME+16]; 180{
181 int zipok; 181 int i;
182 int err=0; 182 int opt_overwrite=0;
183 int size_buf=0; 183 int opt_compress_level=Z_DEFAULT_COMPRESSION;
184 void* buf=NULL; 184 int zipfilenamearg = 0;
185 const char* password=NULL; 185 char filename_try[MAXFILENAME+16];
186 186 int zipok;
187 187 int err=0;
188 do_banner(); 188 int size_buf=0;
189 if (argc==1) 189 void* buf=NULL;
190 { 190 const char* password=NULL;
191 do_help(); 191
192 return 0; 192
193 } 193 do_banner();
194 else 194 if (argc==1)
195 { 195 {
196 for (i=1;i<argc;i++) 196 do_help();
197 { 197 return 0;
198 if ((*argv[i])=='-') 198 }
199 { 199 else
200 const char *p=argv[i]+1; 200 {
201 201 for (i=1;i<argc;i++)
202 while ((*p)!='\0') 202 {
203 { 203 if ((*argv[i])=='-')
204 char c=*(p++);; 204 {
205 if ((c=='o') || (c=='O')) 205 const char *p=argv[i]+1;
206 opt_overwrite = 1; 206
207 if ((c=='a') || (c=='A')) 207 while ((*p)!='\0')
208 opt_overwrite = 2; 208 {
209 if ((c>='0') && (c<='9')) 209 char c=*(p++);;
210 opt_compress_level = c-'0'; 210 if ((c=='o') || (c=='O'))
211 211 opt_overwrite = 1;
212 if (((c=='p') || (c=='P')) && (i+1<argc)) 212 if ((c=='a') || (c=='A'))
213 { 213 opt_overwrite = 2;
214 password=argv[i+1]; 214 if ((c>='0') && (c<='9'))
215 i++; 215 opt_compress_level = c-'0';
216 } 216
217 } 217 if (((c=='p') || (c=='P')) && (i+1<argc))
218 } 218 {
219 else 219 password=argv[i+1];
220 if (zipfilenamearg == 0) 220 i++;
221 zipfilenamearg = i ; 221 }
222 } 222 }
223 } 223 }
224 224 else
225 size_buf = WRITEBUFFERSIZE; 225 if (zipfilenamearg == 0)
226 buf = (void*)malloc(size_buf); 226 zipfilenamearg = i ;
227 if (buf==NULL) 227 }
228 { 228 }
229 printf("Error allocating memory\n"); 229
230 return ZIP_INTERNALERROR; 230 size_buf = WRITEBUFFERSIZE;
231 } 231 buf = (void*)malloc(size_buf);
232 232 if (buf==NULL)
233 if (zipfilenamearg==0) 233 {
234 zipok=0; 234 printf("Error allocating memory\n");
235 else 235 return ZIP_INTERNALERROR;
236 { 236 }
237 int i,len; 237
238 int dot_found=0; 238 if (zipfilenamearg==0)
239 239 zipok=0;
240 zipok = 1 ; 240 else
241 strncpy(filename_try, argv[zipfilenamearg],MAXFILENAME-1); 241 {
242 /* strncpy doesnt append the trailing NULL, of the string is too long. */ 242 int i,len;
243 filename_try[ MAXFILENAME ] = '\0'; 243 int dot_found=0;
244 244
245 len=(int)strlen(filename_try); 245 zipok = 1 ;
246 for (i=0;i<len;i++) 246 strncpy(filename_try, argv[zipfilenamearg],MAXFILENAME-1);
247 if (filename_try[i]=='.') 247 /* strncpy doesnt append the trailing NULL, of the string is too long. */
248 dot_found=1; 248 filename_try[ MAXFILENAME ] = '\0';
249 249
250 if (dot_found==0) 250 len=(int)strlen(filename_try);
251 strcat(filename_try,".zip"); 251 for (i=0;i<len;i++)
252 252 if (filename_try[i]=='.')
253 if (opt_overwrite==2) 253 dot_found=1;
254 { 254
255 /* if the file don't exist, we not append file */ 255 if (dot_found==0)
256 if (check_exist_file(filename_try)==0) 256 strcat(filename_try,".zip");
257 opt_overwrite=1; 257
258 } 258 if (opt_overwrite==2)
259 else 259 {
260 if (opt_overwrite==0) 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 { 262 opt_overwrite=1;
263 char rep=0; 263 }
264 do 264 else
265 { 265 if (opt_overwrite==0)
266 char answer[128]; 266 if (check_exist_file(filename_try)!=0)
267 printf("The file %s exist. Overwrite ? [y]es, [n]o, [a]ppend : ",filename_try); 267 {
268 scanf("%1s",answer); 268 char rep=0;
269 rep = answer[0] ; 269 do
270 if ((rep>='a') && (rep<='z')) 270 {
271 rep -= 0x20; 271 char answer[128];
272 } 272 printf("The file %s exist. Overwrite ? [y]es, [n]o, [a]ppend : ",filename_try);
273 while ((rep!='Y') && (rep!='N') && (rep!='A')); 273 scanf("%1s",answer);
274 if (rep=='N') 274 rep = answer[0] ;
275 zipok = 0; 275 if ((rep>='a') && (rep<='z'))
276 if (rep=='A') 276 rep -= 0x20;
277 opt_overwrite = 2; 277 }
278 } 278 while ((rep!='Y') && (rep!='N') && (rep!='A'));
279 } 279 if (rep=='N')
280 280 zipok = 0;
281 if (zipok==1) 281 if (rep=='A')
282 { 282 opt_overwrite = 2;
283 zipFile zf; 283 }
284 int errclose; 284 }
285 #ifdef USEWIN32IOAPI 285
286 zlib_filefunc_def ffunc; 286 if (zipok==1)
287 fill_win32_filefunc(&ffunc); 287 {
288 zf = zipOpen2(filename_try,(opt_overwrite==2) ? 2 : 0,NULL,&ffunc); 288 zipFile zf;
289 #else 289 int errclose;
290 zf = zipOpen(filename_try,(opt_overwrite==2) ? 2 : 0); 290 #ifdef USEWIN32IOAPI
291 #endif 291 zlib_filefunc_def ffunc;
292 292 fill_win32_filefunc(&ffunc);
293 if (zf == NULL) 293 zf = zipOpen2(filename_try,(opt_overwrite==2) ? 2 : 0,NULL,&ffunc);
294 { 294 #else
295 printf("error opening %s\n",filename_try); 295 zf = zipOpen(filename_try,(opt_overwrite==2) ? 2 : 0);
296 err= ZIP_ERRNO; 296 #endif
297 } 297
298 else 298 if (zf == NULL)
299 printf("creating %s\n",filename_try); 299 {
300 300 printf("error opening %s\n",filename_try);
301 for (i=zipfilenamearg+1;(i<argc) && (err==ZIP_OK);i++) 301 err= ZIP_ERRNO;
302 { 302 }
303 if (((*(argv[i]))!='-') && ((*(argv[i]))!='/')) 303 else
304 { 304 printf("creating %s\n",filename_try);
305 FILE * fin; 305
306 int size_read; 306 for (i=zipfilenamearg+1;(i<argc) && (err==ZIP_OK);i++)
307 const char* filenameinzip = argv[i]; 307 {
308 zip_fileinfo zi; 308 if (((*(argv[i]))!='-') && ((*(argv[i]))!='/'))
309 unsigned long crcFile=0; 309 {
310 310 FILE * fin;
311 zi.tmz_date.tm_sec = zi.tmz_date.tm_min = zi.tmz_date.tm_hour = 311 int size_read;
312 zi.tmz_date.tm_mday = zi.tmz_date.tm_mon = zi.tmz_date.tm_year = 0; 312 const char* filenameinzip = argv[i];
313 zi.dosDate = 0; 313 zip_fileinfo zi;
314 zi.internal_fa = 0; 314 unsigned long crcFile=0;
315 zi.external_fa = 0; 315
316 filetime(filenameinzip,&zi.tmz_date,&zi.dosDate); 316 zi.tmz_date.tm_sec = zi.tmz_date.tm_min = zi.tmz_date.tm_hour =
317 317 zi.tmz_date.tm_mday = zi.tmz_date.tm_mon = zi.tmz_date.tm_year = 0;
318/* 318 zi.dosDate = 0;
319 err = zipOpenNewFileInZip(zf,filenameinzip,&zi, 319 zi.internal_fa = 0;
320 NULL,0,NULL,0,NULL / * comment * /, 320 zi.external_fa = 0;
321 (opt_compress_level != 0) ? Z_DEFLATED : 0, 321 filetime(filenameinzip,&zi.tmz_date,&zi.dosDate);
322 opt_compress_level); 322
323*/ 323/*
324 if ((password != NULL) && (err==ZIP_OK)) 324 err = zipOpenNewFileInZip(zf,filenameinzip,&zi,
325 err = getFileCrc(filenameinzip,buf,size_buf,&crcFile); 325 NULL,0,NULL,0,NULL / * comment * /,
326 326 (opt_compress_level != 0) ? Z_DEFLATED : 0,
327 err = zipOpenNewFileInZip3(zf,filenameinzip,&zi, 327 opt_compress_level);
328 NULL,0,NULL,0,NULL /* comment*/, 328*/
329 (opt_compress_level != 0) ? Z_DEFLATED : 0, 329 if ((password != NULL) && (err==ZIP_OK))
330 opt_compress_level,0, 330 err = getFileCrc(filenameinzip,buf,size_buf,&crcFile);
331 /* -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, */ 331
332 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, 332 err = zipOpenNewFileInZip3(zf,filenameinzip,&zi,
333 password,crcFile); 333 NULL,0,NULL,0,NULL /* comment*/,
334 334 (opt_compress_level != 0) ? Z_DEFLATED : 0,
335 if (err != ZIP_OK) 335 opt_compress_level,0,
336 printf("error in opening %s in zipfile\n",filenameinzip); 336 /* -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, */
337 else 337 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
338 { 338 password,crcFile);
339 fin = fopen(filenameinzip,"rb"); 339
340 if (fin==NULL) 340 if (err != ZIP_OK)
341 { 341 printf("error in opening %s in zipfile\n",filenameinzip);
342 err=ZIP_ERRNO; 342 else
343 printf("error in opening %s for reading\n",filenameinzip); 343 {
344 } 344 fin = fopen(filenameinzip,"rb");
345 } 345 if (fin==NULL)
346 346 {
347 if (err == ZIP_OK) 347 err=ZIP_ERRNO;
348 do 348 printf("error in opening %s for reading\n",filenameinzip);
349 { 349 }
350 err = ZIP_OK; 350 }
351 size_read = (int)fread(buf,1,size_buf,fin); 351
352 if (size_read < size_buf) 352 if (err == ZIP_OK)
353 if (feof(fin)==0) 353 do
354 { 354 {
355 printf("error in reading %s\n",filenameinzip); 355 err = ZIP_OK;
356 err = ZIP_ERRNO; 356 size_read = (int)fread(buf,1,size_buf,fin);
357 } 357 if (size_read < size_buf)
358 358 if (feof(fin)==0)
359 if (size_read>0) 359 {
360 { 360 printf("error in reading %s\n",filenameinzip);
361 err = zipWriteInFileInZip (zf,buf,size_read); 361 err = ZIP_ERRNO;
362 if (err<0) 362 }
363 { 363
364 printf("error in writing %s in the zipfile\n", 364 if (size_read>0)
365 filenameinzip); 365 {
366 } 366 err = zipWriteInFileInZip (zf,buf,size_read);
367 367 if (err<0)
368 } 368 {
369 } while ((err == ZIP_OK) && (size_read>0)); 369 printf("error in writing %s in the zipfile\n",
370 370 filenameinzip);
371 if (fin) 371 }
372 fclose(fin); 372
373 373 }
374 if (err<0) 374 } while ((err == ZIP_OK) && (size_read>0));
375 err=ZIP_ERRNO; 375
376 else 376 if (fin)
377 { 377 fclose(fin);
378 err = zipCloseFileInZip(zf); 378
379 if (err!=ZIP_OK) 379 if (err<0)
380 printf("error in closing %s in the zipfile\n", 380 err=ZIP_ERRNO;
381 filenameinzip); 381 else
382 } 382 {
383 } 383 err = zipCloseFileInZip(zf);
384 } 384 if (err!=ZIP_OK)
385 errclose = zipClose(zf,NULL); 385 printf("error in closing %s in the zipfile\n",
386 if (errclose != ZIP_OK) 386 filenameinzip);
387 printf("error in closing %s\n",filename_try); 387 }
388 } 388 }
389 389 }
390 free(buf); 390 errclose = zipClose(zf,NULL);
391 return 0; 391 if (errclose != ZIP_OK)
392} 392 printf("error in closing %s\n",filename_try);
393 }
394
395 free(buf);
396 return 0;
397}
diff --git a/contrib/minizip/unzip.c b/contrib/minizip/unzip.c
index 7244523..07d869e 100644
--- a/contrib/minizip/unzip.c
+++ b/contrib/minizip/unzip.c
@@ -1,1529 +1,1531 @@
1/* unzip.c -- IO for uncompress .zip files using zlib 1/* unzip.c -- IO for uncompress .zip files using zlib
2 Version 0.21 with encryption, March 10th, 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
63#if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES) && \ 63#if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES) && \
64 !defined(CASESENSITIVITYDEFAULT_NO) 64 !defined(CASESENSITIVITYDEFAULT_NO)
65#define CASESENSITIVITYDEFAULT_NO 65#define CASESENSITIVITYDEFAULT_NO
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.21 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 NOUNCRPYT 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 NOUNCRPYT 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 831
832 uLong num_fileSaved; 832 uLong num_fileSaved;
833 uLong pos_in_central_dirSaved; 833 uLong pos_in_central_dirSaved;
834 834
835 835
836 if (file==NULL) 836 if (file==NULL)
837 return UNZ_PARAMERROR; 837 return UNZ_PARAMERROR;
838 838
839 if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP) 839 if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP)
840 return UNZ_PARAMERROR; 840 return UNZ_PARAMERROR;
841 841
842 s=(unz_s*)file; 842 s=(unz_s*)file;
843 if (!s->current_file_ok) 843 if (!s->current_file_ok)
844 return UNZ_END_OF_LIST_OF_FILE; 844 return UNZ_END_OF_LIST_OF_FILE;
845 845
846 num_fileSaved = s->num_file; 846 num_fileSaved = s->num_file;
847 pos_in_central_dirSaved = s->pos_in_central_dir; 847 pos_in_central_dirSaved = s->pos_in_central_dir;
848 848
849 err = unzGoToFirstFile(file); 849 err = unzGoToFirstFile(file);
850 850
851 while (err == UNZ_OK) 851 while (err == UNZ_OK)
852 { 852 {
853 char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1]; 853 char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1];
854 unzGetCurrentFileInfo(file,NULL, 854 unzGetCurrentFileInfo(file,NULL,
855 szCurrentFileName,sizeof(szCurrentFileName)-1, 855 szCurrentFileName,sizeof(szCurrentFileName)-1,
856 NULL,0,NULL,0); 856 NULL,0,NULL,0);
857 if (unzStringFileNameCompare(szCurrentFileName, 857 if (unzStringFileNameCompare(szCurrentFileName,
858 szFileName,iCaseSensitivity)==0) 858 szFileName,iCaseSensitivity)==0)
859 return UNZ_OK; 859 return UNZ_OK;
860 err = unzGoToNextFile(file); 860 err = unzGoToNextFile(file);
861 } 861 }
862 862
863 s->num_file = num_fileSaved ; 863 s->num_file = num_fileSaved ;
864 s->pos_in_central_dir = pos_in_central_dirSaved ; 864 s->pos_in_central_dir = pos_in_central_dirSaved ;
865 return err; 865 return err;
866} 866}
867 867
868 868
869/* 869/*
870/////////////////////////////////////////// 870///////////////////////////////////////////
871// Contributed by Ryan Haksi (mailto://cryogen@infoserve.net) 871// Contributed by Ryan Haksi (mailto://cryogen@infoserve.net)
872// I need random access 872// I need random access
873// 873//
874// Further optimization could be realized by adding an ability 874// Further optimization could be realized by adding an ability
875// to cache the directory in memory. The goal being a single 875// to cache the directory in memory. The goal being a single
876// comprehensive file read to put the file I need in a memory. 876// comprehensive file read to put the file I need in a memory.
877*/ 877*/
878 878
879/* 879/*
880typedef struct unz_file_pos_s 880typedef struct unz_file_pos_s
881{ 881{
882 uLong pos_in_zip_directory; // offset in file 882 uLong pos_in_zip_directory; // offset in file
883 uLong num_of_file; // # of file 883 uLong num_of_file; // # of file
884} unz_file_pos; 884} unz_file_pos;
885*/ 885*/
886 886
887extern int ZEXPORT unzGetFilePos(file, file_pos) 887extern int ZEXPORT unzGetFilePos(file, file_pos)
888 unzFile file; 888 unzFile file;
889 unz_file_pos* file_pos; 889 unz_file_pos* file_pos;
890{ 890{
891 unz_s* s; 891 unz_s* s;
892 892
893 if (file==NULL || file_pos==NULL) 893 if (file==NULL || file_pos==NULL)
894 return UNZ_PARAMERROR; 894 return UNZ_PARAMERROR;
895 s=(unz_s*)file; 895 s=(unz_s*)file;
896 if (!s->current_file_ok) 896 if (!s->current_file_ok)
897 return UNZ_END_OF_LIST_OF_FILE; 897 return UNZ_END_OF_LIST_OF_FILE;
898 898
899 file_pos->pos_in_zip_directory = s->pos_in_central_dir; 899 file_pos->pos_in_zip_directory = s->pos_in_central_dir;
900 file_pos->num_of_file = s->num_file; 900 file_pos->num_of_file = s->num_file;
901 901
902 return UNZ_OK; 902 return UNZ_OK;
903} 903}
904 904
905extern int ZEXPORT unzGoToFilePos(file, file_pos) 905extern int ZEXPORT unzGoToFilePos(file, file_pos)
906 unzFile file; 906 unzFile file;
907 unz_file_pos* file_pos; 907 unz_file_pos* file_pos;
908{ 908{
909 unz_s* s; 909 unz_s* s;
910 int err; 910 int err;
911 911
912 if (file==NULL || file_pos==NULL) 912 if (file==NULL || file_pos==NULL)
913 return UNZ_PARAMERROR; 913 return UNZ_PARAMERROR;
914 s=(unz_s*)file; 914 s=(unz_s*)file;
915 915
916 /* jump to the right spot */ 916 /* jump to the right spot */
917 s->pos_in_central_dir = file_pos->pos_in_zip_directory; 917 s->pos_in_central_dir = file_pos->pos_in_zip_directory;
918 s->num_file = file_pos->num_of_file; 918 s->num_file = file_pos->num_of_file;
919 919
920 /* set the current file */ 920 /* set the current file */
921 err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info, 921 err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
922 &s->cur_file_info_internal, 922 &s->cur_file_info_internal,
923 NULL,0,NULL,0,NULL,0); 923 NULL,0,NULL,0,NULL,0);
924 /* return results */ 924 /* return results */
925 s->current_file_ok = (err == UNZ_OK); 925 s->current_file_ok = (err == UNZ_OK);
926 return err; 926 return err;
927} 927}
928 928
929/* 929/*
930// Unzip Helper Functions - should be here? 930// Unzip Helper Functions - should be here?
931/////////////////////////////////////////// 931///////////////////////////////////////////
932*/ 932*/
933 933
934/* 934/*
935 Read the local header of the current zipfile 935 Read the local header of the current zipfile
936 Check the coherency of the local header and info in the end of central 936 Check the coherency of the local header and info in the end of central
937 directory about this file 937 directory about this file
938 store in *piSizeVar the size of extra info in local header 938 store in *piSizeVar the size of extra info in local header
939 (filename and size of extra field data) 939 (filename and size of extra field data)
940*/ 940*/
941local int unzlocal_CheckCurrentFileCoherencyHeader (s,piSizeVar, 941local int unzlocal_CheckCurrentFileCoherencyHeader (s,piSizeVar,
942 poffset_local_extrafield, 942 poffset_local_extrafield,
943 psize_local_extrafield) 943 psize_local_extrafield)
944 unz_s* s; 944 unz_s* s;
945 uInt* piSizeVar; 945 uInt* piSizeVar;
946 uLong *poffset_local_extrafield; 946 uLong *poffset_local_extrafield;
947 uInt *psize_local_extrafield; 947 uInt *psize_local_extrafield;
948{ 948{
949 uLong uMagic,uData,uFlags; 949 uLong uMagic,uData,uFlags;
950 uLong size_filename; 950 uLong size_filename;
951 uLong size_extra_field; 951 uLong size_extra_field;
952 int err=UNZ_OK; 952 int err=UNZ_OK;
953 953
954 *piSizeVar = 0; 954 *piSizeVar = 0;
955 *poffset_local_extrafield = 0; 955 *poffset_local_extrafield = 0;
956 *psize_local_extrafield = 0; 956 *psize_local_extrafield = 0;
957 957
958 if (ZSEEK(s->z_filefunc, s->filestream,s->cur_file_info_internal.offset_curfile + 958 if (ZSEEK(s->z_filefunc, s->filestream,s->cur_file_info_internal.offset_curfile +
959 s->byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0) 959 s->byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0)
960 return UNZ_ERRNO; 960 return UNZ_ERRNO;
961 961
962 962
963 if (err==UNZ_OK) 963 if (err==UNZ_OK)
964 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK) 964 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)
965 err=UNZ_ERRNO; 965 err=UNZ_ERRNO;
966 else if (uMagic!=0x04034b50) 966 else if (uMagic!=0x04034b50)
967 err=UNZ_BADZIPFILE; 967 err=UNZ_BADZIPFILE;
968 968
969 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) 969 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
970 err=UNZ_ERRNO; 970 err=UNZ_ERRNO;
971/* 971/*
972 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion)) 972 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
973 err=UNZ_BADZIPFILE; 973 err=UNZ_BADZIPFILE;
974*/ 974*/
975 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uFlags) != UNZ_OK) 975 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uFlags) != UNZ_OK)
976 err=UNZ_ERRNO; 976 err=UNZ_ERRNO;
977 977
978 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) 978 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
979 err=UNZ_ERRNO; 979 err=UNZ_ERRNO;
980 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method)) 980 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method))
981 err=UNZ_BADZIPFILE; 981 err=UNZ_BADZIPFILE;
982 982
983 if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) && 983 if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) &&
984 (s->cur_file_info.compression_method!=Z_DEFLATED)) 984 (s->cur_file_info.compression_method!=Z_DEFLATED))
985 err=UNZ_BADZIPFILE; 985 err=UNZ_BADZIPFILE;
986 986
987 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* date/time */ 987 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* date/time */
988 err=UNZ_ERRNO; 988 err=UNZ_ERRNO;
989 989
990 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* crc */ 990 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* crc */
991 err=UNZ_ERRNO; 991 err=UNZ_ERRNO;
992 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) && 992 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) &&
993 ((uFlags & 8)==0)) 993 ((uFlags & 8)==0))
994 err=UNZ_BADZIPFILE; 994 err=UNZ_BADZIPFILE;
995 995
996 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size compr */ 996 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size compr */
997 err=UNZ_ERRNO; 997 err=UNZ_ERRNO;
998 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) && 998 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) &&
999 ((uFlags & 8)==0)) 999 ((uFlags & 8)==0))
1000 err=UNZ_BADZIPFILE; 1000 err=UNZ_BADZIPFILE;
1001 1001
1002 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size uncompr */ 1002 if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size uncompr */
1003 err=UNZ_ERRNO; 1003 err=UNZ_ERRNO;
1004 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) && 1004 else if ((err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) &&
1005 ((uFlags & 8)==0)) 1005 ((uFlags & 8)==0))
1006 err=UNZ_BADZIPFILE; 1006 err=UNZ_BADZIPFILE;
1007 1007
1008 1008
1009 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&size_filename) != UNZ_OK) 1009 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&size_filename) != UNZ_OK)
1010 err=UNZ_ERRNO; 1010 err=UNZ_ERRNO;
1011 else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename)) 1011 else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename))
1012 err=UNZ_BADZIPFILE; 1012 err=UNZ_BADZIPFILE;
1013 1013
1014 *piSizeVar += (uInt)size_filename; 1014 *piSizeVar += (uInt)size_filename;
1015 1015
1016 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&size_extra_field) != UNZ_OK) 1016 if (unzlocal_getShort(&s->z_filefunc, s->filestream,&size_extra_field) != UNZ_OK)
1017 err=UNZ_ERRNO; 1017 err=UNZ_ERRNO;
1018 *poffset_local_extrafield= s->cur_file_info_internal.offset_curfile + 1018 *poffset_local_extrafield= s->cur_file_info_internal.offset_curfile +
1019 SIZEZIPLOCALHEADER + size_filename; 1019 SIZEZIPLOCALHEADER + size_filename;
1020 *psize_local_extrafield = (uInt)size_extra_field; 1020 *psize_local_extrafield = (uInt)size_extra_field;
1021 1021
1022 *piSizeVar += (uInt)size_extra_field; 1022 *piSizeVar += (uInt)size_extra_field;
1023 1023
1024 return err; 1024 return err;
1025} 1025}
1026 1026
1027/* 1027/*
1028 Open for reading data the current file in the zipfile. 1028 Open for reading data the current file in the zipfile.
1029 If there is no error and the file is opened, the return value is UNZ_OK. 1029 If there is no error and the file is opened, the return value is UNZ_OK.
1030*/ 1030*/
1031extern int ZEXPORT unzOpenCurrentFile3 (file, method, level, raw, password) 1031extern int ZEXPORT unzOpenCurrentFile3 (file, method, level, raw, password)
1032 unzFile file; 1032 unzFile file;
1033 int* method; 1033 int* method;
1034 int* level; 1034 int* level;
1035 int raw; 1035 int raw;
1036 const char* password; 1036 const char* password;
1037{ 1037{
1038 int err=UNZ_OK; 1038 int err=UNZ_OK;
1039 uInt iSizeVar; 1039 uInt iSizeVar;
1040 unz_s* s; 1040 unz_s* s;
1041 file_in_zip_read_info_s* pfile_in_zip_read_info; 1041 file_in_zip_read_info_s* pfile_in_zip_read_info;
1042 uLong offset_local_extrafield; /* offset of the local extra field */ 1042 uLong offset_local_extrafield; /* offset of the local extra field */
1043 uInt size_local_extrafield; /* size of the local extra field */ 1043 uInt size_local_extrafield; /* size of the local extra field */
1044 #ifndef NOUNCRPYT 1044 #ifndef NOUNCRYPT
1045 char source[12]; 1045 char source[12];
1046 #else 1046 #else
1047 if (password != NULL) 1047 if (password != NULL)
1048 return UNZ_PARAMERROR; 1048 return UNZ_PARAMERROR;
1049 #endif 1049 #endif
1050 1050
1051 if (file==NULL) 1051 if (file==NULL)
1052 return UNZ_PARAMERROR; 1052 return UNZ_PARAMERROR;
1053 s=(unz_s*)file; 1053 s=(unz_s*)file;
1054 if (!s->current_file_ok) 1054 if (!s->current_file_ok)
1055 return UNZ_PARAMERROR; 1055 return UNZ_PARAMERROR;
1056 1056
1057 if (s->pfile_in_zip_read != NULL) 1057 if (s->pfile_in_zip_read != NULL)
1058 unzCloseCurrentFile(file); 1058 unzCloseCurrentFile(file);
1059 1059
1060 if (unzlocal_CheckCurrentFileCoherencyHeader(s,&iSizeVar, 1060 if (unzlocal_CheckCurrentFileCoherencyHeader(s,&iSizeVar,
1061 &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK) 1061 &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK)
1062 return UNZ_BADZIPFILE; 1062 return UNZ_BADZIPFILE;
1063 1063
1064 pfile_in_zip_read_info = (file_in_zip_read_info_s*) 1064 pfile_in_zip_read_info = (file_in_zip_read_info_s*)
1065 ALLOC(sizeof(file_in_zip_read_info_s)); 1065 ALLOC(sizeof(file_in_zip_read_info_s));
1066 if (pfile_in_zip_read_info==NULL) 1066 if (pfile_in_zip_read_info==NULL)
1067 return UNZ_INTERNALERROR; 1067 return UNZ_INTERNALERROR;
1068 1068
1069 pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE); 1069 pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE);
1070 pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield; 1070 pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;
1071 pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield; 1071 pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
1072 pfile_in_zip_read_info->pos_local_extrafield=0; 1072 pfile_in_zip_read_info->pos_local_extrafield=0;
1073 pfile_in_zip_read_info->raw=raw; 1073 pfile_in_zip_read_info->raw=raw;
1074 1074
1075 if (pfile_in_zip_read_info->read_buffer==NULL) 1075 if (pfile_in_zip_read_info->read_buffer==NULL)
1076 { 1076 {
1077 TRYFREE(pfile_in_zip_read_info); 1077 TRYFREE(pfile_in_zip_read_info);
1078 return UNZ_INTERNALERROR; 1078 return UNZ_INTERNALERROR;
1079 } 1079 }
1080 1080
1081 pfile_in_zip_read_info->stream_initialised=0; 1081 pfile_in_zip_read_info->stream_initialised=0;
1082 1082
1083 if (method!=NULL) 1083 if (method!=NULL)
1084 *method = (int)s->cur_file_info.compression_method; 1084 *method = (int)s->cur_file_info.compression_method;
1085 1085
1086 if (level!=NULL) 1086 if (level!=NULL)
1087 { 1087 {
1088 *level = 6; 1088 *level = 6;
1089 switch (s->cur_file_info.flag & 0x06) 1089 switch (s->cur_file_info.flag & 0x06)
1090 { 1090 {
1091 case 6 : *level = 1; break; 1091 case 6 : *level = 1; break;
1092 case 4 : *level = 2; break; 1092 case 4 : *level = 2; break;
1093 case 2 : *level = 9; break; 1093 case 2 : *level = 9; break;
1094 } 1094 }
1095 } 1095 }
1096 1096
1097 if ((s->cur_file_info.compression_method!=0) && 1097 if ((s->cur_file_info.compression_method!=0) &&
1098 (s->cur_file_info.compression_method!=Z_DEFLATED)) 1098 (s->cur_file_info.compression_method!=Z_DEFLATED))
1099 err=UNZ_BADZIPFILE; 1099 err=UNZ_BADZIPFILE;
1100 1100
1101 pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc; 1101 pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc;
1102 pfile_in_zip_read_info->crc32=0; 1102 pfile_in_zip_read_info->crc32=0;
1103 pfile_in_zip_read_info->compression_method = 1103 pfile_in_zip_read_info->compression_method =
1104 s->cur_file_info.compression_method; 1104 s->cur_file_info.compression_method;
1105 pfile_in_zip_read_info->filestream=s->filestream; 1105 pfile_in_zip_read_info->filestream=s->filestream;
1106 pfile_in_zip_read_info->z_filefunc=s->z_filefunc; 1106 pfile_in_zip_read_info->z_filefunc=s->z_filefunc;
1107 pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile; 1107 pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile;
1108 1108
1109 pfile_in_zip_read_info->stream.total_out = 0; 1109 pfile_in_zip_read_info->stream.total_out = 0;
1110 1110
1111 if ((s->cur_file_info.compression_method==Z_DEFLATED) && 1111 if ((s->cur_file_info.compression_method==Z_DEFLATED) &&
1112 (!raw)) 1112 (!raw))
1113 { 1113 {
1114 pfile_in_zip_read_info->stream.zalloc = (alloc_func)0; 1114 pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
1115 pfile_in_zip_read_info->stream.zfree = (free_func)0; 1115 pfile_in_zip_read_info->stream.zfree = (free_func)0;
1116 pfile_in_zip_read_info->stream.opaque = (voidpf)0; 1116 pfile_in_zip_read_info->stream.opaque = (voidpf)0;
1117 1117 pfile_in_zip_read_info->stream.next_in = (voidpf)0;
1118 err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS); 1118 pfile_in_zip_read_info->stream.avail_in = 0;
1119 if (err == Z_OK) 1119
1120 pfile_in_zip_read_info->stream_initialised=1; 1120 err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);
1121 else 1121 if (err == Z_OK)
1122 return err; 1122 pfile_in_zip_read_info->stream_initialised=1;
1123 /* windowBits is passed < 0 to tell that there is no zlib header. 1123 else
1124 * Note that in this case inflate *requires* an extra "dummy" byte 1124 return err;
1125 * after the compressed stream in order to complete decompression and 1125 /* windowBits is passed < 0 to tell that there is no zlib header.
1126 * return Z_STREAM_END. 1126 * Note that in this case inflate *requires* an extra "dummy" byte
1127 * In unzip, i don't wait absolutely Z_STREAM_END because I known the 1127 * after the compressed stream in order to complete decompression and
1128 * size of both compressed and uncompressed data 1128 * return Z_STREAM_END.
1129 */ 1129 * In unzip, i don't wait absolutely Z_STREAM_END because I known the
1130 } 1130 * size of both compressed and uncompressed data
1131 pfile_in_zip_read_info->rest_read_compressed = 1131 */
1132 s->cur_file_info.compressed_size ; 1132 }
1133 pfile_in_zip_read_info->rest_read_uncompressed = 1133 pfile_in_zip_read_info->rest_read_compressed =
1134 s->cur_file_info.uncompressed_size ; 1134 s->cur_file_info.compressed_size ;
1135 1135 pfile_in_zip_read_info->rest_read_uncompressed =
1136 1136 s->cur_file_info.uncompressed_size ;
1137 pfile_in_zip_read_info->pos_in_zipfile = 1137
1138 s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER + 1138
1139 iSizeVar; 1139 pfile_in_zip_read_info->pos_in_zipfile =
1140 1140 s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER +
1141 pfile_in_zip_read_info->stream.avail_in = (uInt)0; 1141 iSizeVar;
1142 1142
1143 s->pfile_in_zip_read = pfile_in_zip_read_info; 1143 pfile_in_zip_read_info->stream.avail_in = (uInt)0;
1144 1144
1145 #ifndef NOUNCRPYT 1145 s->pfile_in_zip_read = pfile_in_zip_read_info;
1146 if (password != NULL) 1146
1147 { 1147 #ifndef NOUNCRYPT
1148 int i; 1148 if (password != NULL)
1149 s->pcrc_32_tab = get_crc_table(); 1149 {
1150 init_keys(password,s->keys,s->pcrc_32_tab); 1150 int i;
1151 if (ZSEEK(s->z_filefunc, s->filestream, 1151 s->pcrc_32_tab = get_crc_table();
1152 s->pfile_in_zip_read->pos_in_zipfile + 1152 init_keys(password,s->keys,s->pcrc_32_tab);
1153 s->pfile_in_zip_read->byte_before_the_zipfile, 1153 if (ZSEEK(s->z_filefunc, s->filestream,
1154 SEEK_SET)!=0) 1154 s->pfile_in_zip_read->pos_in_zipfile +
1155 return UNZ_INTERNALERROR; 1155 s->pfile_in_zip_read->byte_before_the_zipfile,
1156 if(ZREAD(s->z_filefunc, s->filestream,source, 12)<12) 1156 SEEK_SET)!=0)
1157 return UNZ_INTERNALERROR; 1157 return UNZ_INTERNALERROR;
1158 1158 if(ZREAD(s->z_filefunc, s->filestream,source, 12)<12)
1159 for (i = 0; i<12; i++) 1159 return UNZ_INTERNALERROR;
1160 zdecode(s->keys,s->pcrc_32_tab,source[i]); 1160
1161 1161 for (i = 0; i<12; i++)
1162 s->pfile_in_zip_read->pos_in_zipfile+=12; 1162 zdecode(s->keys,s->pcrc_32_tab,source[i]);
1163 s->encrypted=1; 1163
1164 } 1164 s->pfile_in_zip_read->pos_in_zipfile+=12;
1165 #endif 1165 s->encrypted=1;
1166 1166 }
1167 1167 #endif
1168 return UNZ_OK; 1168
1169} 1169
1170 1170 return UNZ_OK;
1171extern int ZEXPORT unzOpenCurrentFile (file) 1171}
1172 unzFile file; 1172
1173{ 1173extern int ZEXPORT unzOpenCurrentFile (file)
1174 return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL); 1174 unzFile file;
1175} 1175{
1176 1176 return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL);
1177extern int ZEXPORT unzOpenCurrentFilePassword (file, password) 1177}
1178 unzFile file; 1178
1179 const char* password; 1179extern int ZEXPORT unzOpenCurrentFilePassword (file, password)
1180{ 1180 unzFile file;
1181 return unzOpenCurrentFile3(file, NULL, NULL, 0, password); 1181 const char* password;
1182} 1182{
1183 1183 return unzOpenCurrentFile3(file, NULL, NULL, 0, password);
1184extern int ZEXPORT unzOpenCurrentFile2 (file,method,level,raw) 1184}
1185 unzFile file; 1185
1186 int* method; 1186extern int ZEXPORT unzOpenCurrentFile2 (file,method,level,raw)
1187 int* level; 1187 unzFile file;
1188 int raw; 1188 int* method;
1189{ 1189 int* level;
1190 return unzOpenCurrentFile3(file, method, level, raw, NULL); 1190 int raw;
1191} 1191{
1192 1192 return unzOpenCurrentFile3(file, method, level, raw, NULL);
1193/* 1193}
1194 Read bytes from the current file. 1194
1195 buf contain buffer where data must be copied 1195/*
1196 len the size of buf. 1196 Read bytes from the current file.
1197 1197 buf contain buffer where data must be copied
1198 return the number of byte copied if somes bytes are copied 1198 len the size of buf.
1199 return 0 if the end of file was reached 1199
1200 return <0 with error code if there is an error 1200 return the number of byte copied if somes bytes are copied
1201 (UNZ_ERRNO for IO error, or zLib error for uncompress error) 1201 return 0 if the end of file was reached
1202*/ 1202 return <0 with error code if there is an error
1203extern int ZEXPORT unzReadCurrentFile (file, buf, len) 1203 (UNZ_ERRNO for IO error, or zLib error for uncompress error)
1204 unzFile file; 1204*/
1205 voidp buf; 1205extern int ZEXPORT unzReadCurrentFile (file, buf, len)
1206 unsigned len; 1206 unzFile file;
1207{ 1207 voidp buf;
1208 int err=UNZ_OK; 1208 unsigned len;
1209 uInt iRead = 0; 1209{
1210 unz_s* s; 1210 int err=UNZ_OK;
1211 file_in_zip_read_info_s* pfile_in_zip_read_info; 1211 uInt iRead = 0;
1212 if (file==NULL) 1212 unz_s* s;
1213 return UNZ_PARAMERROR; 1213 file_in_zip_read_info_s* pfile_in_zip_read_info;
1214 s=(unz_s*)file; 1214 if (file==NULL)
1215 pfile_in_zip_read_info=s->pfile_in_zip_read; 1215 return UNZ_PARAMERROR;
1216 1216 s=(unz_s*)file;
1217 if (pfile_in_zip_read_info==NULL) 1217 pfile_in_zip_read_info=s->pfile_in_zip_read;
1218 return UNZ_PARAMERROR; 1218
1219 1219 if (pfile_in_zip_read_info==NULL)
1220 1220 return UNZ_PARAMERROR;
1221 if ((pfile_in_zip_read_info->read_buffer == NULL)) 1221
1222 return UNZ_END_OF_LIST_OF_FILE; 1222
1223 if (len==0) 1223 if ((pfile_in_zip_read_info->read_buffer == NULL))
1224 return 0; 1224 return UNZ_END_OF_LIST_OF_FILE;
1225 1225 if (len==0)
1226 pfile_in_zip_read_info->stream.next_out = (Bytef*)buf; 1226 return 0;
1227 1227
1228 pfile_in_zip_read_info->stream.avail_out = (uInt)len; 1228 pfile_in_zip_read_info->stream.next_out = (Bytef*)buf;
1229 1229
1230 if (len>pfile_in_zip_read_info->rest_read_uncompressed) 1230 pfile_in_zip_read_info->stream.avail_out = (uInt)len;
1231 pfile_in_zip_read_info->stream.avail_out = 1231
1232 (uInt)pfile_in_zip_read_info->rest_read_uncompressed; 1232 if (len>pfile_in_zip_read_info->rest_read_uncompressed)
1233 1233 pfile_in_zip_read_info->stream.avail_out =
1234 while (pfile_in_zip_read_info->stream.avail_out>0) 1234 (uInt)pfile_in_zip_read_info->rest_read_uncompressed;
1235 { 1235
1236 if ((pfile_in_zip_read_info->stream.avail_in==0) && 1236 while (pfile_in_zip_read_info->stream.avail_out>0)
1237 (pfile_in_zip_read_info->rest_read_compressed>0)) 1237 {
1238 { 1238 if ((pfile_in_zip_read_info->stream.avail_in==0) &&
1239 uInt uReadThis = UNZ_BUFSIZE; 1239 (pfile_in_zip_read_info->rest_read_compressed>0))
1240 if (pfile_in_zip_read_info->rest_read_compressed<uReadThis) 1240 {
1241 uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed; 1241 uInt uReadThis = UNZ_BUFSIZE;
1242 if (uReadThis == 0) 1242 if (pfile_in_zip_read_info->rest_read_compressed<uReadThis)
1243 return UNZ_EOF; 1243 uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed;
1244 if (ZSEEK(pfile_in_zip_read_info->z_filefunc, 1244 if (uReadThis == 0)
1245 pfile_in_zip_read_info->filestream, 1245 return UNZ_EOF;
1246 pfile_in_zip_read_info->pos_in_zipfile + 1246 if (ZSEEK(pfile_in_zip_read_info->z_filefunc,
1247 pfile_in_zip_read_info->byte_before_the_zipfile, 1247 pfile_in_zip_read_info->filestream,
1248 ZLIB_FILEFUNC_SEEK_SET)!=0) 1248 pfile_in_zip_read_info->pos_in_zipfile +
1249 return UNZ_ERRNO; 1249 pfile_in_zip_read_info->byte_before_the_zipfile,
1250 if (ZREAD(pfile_in_zip_read_info->z_filefunc, 1250 ZLIB_FILEFUNC_SEEK_SET)!=0)
1251 pfile_in_zip_read_info->filestream, 1251 return UNZ_ERRNO;
1252 pfile_in_zip_read_info->read_buffer, 1252 if (ZREAD(pfile_in_zip_read_info->z_filefunc,
1253 uReadThis)!=uReadThis) 1253 pfile_in_zip_read_info->filestream,
1254 return UNZ_ERRNO; 1254 pfile_in_zip_read_info->read_buffer,
1255 1255 uReadThis)!=uReadThis)
1256 1256 return UNZ_ERRNO;
1257 #ifndef NOUNCRPYT 1257
1258 if(s->encrypted) 1258
1259 { 1259 #ifndef NOUNCRYPT
1260 uInt i; 1260 if(s->encrypted)
1261 for(i=0;i<uReadThis;i++) 1261 {
1262 pfile_in_zip_read_info->read_buffer[i] = 1262 uInt i;
1263 zdecode(s->keys,s->pcrc_32_tab, 1263 for(i=0;i<uReadThis;i++)
1264 pfile_in_zip_read_info->read_buffer[i]); 1264 pfile_in_zip_read_info->read_buffer[i] =
1265 } 1265 zdecode(s->keys,s->pcrc_32_tab,
1266 #endif 1266 pfile_in_zip_read_info->read_buffer[i]);
1267 1267 }
1268 1268 #endif
1269 pfile_in_zip_read_info->pos_in_zipfile += uReadThis; 1269
1270 1270
1271 pfile_in_zip_read_info->rest_read_compressed-=uReadThis; 1271 pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
1272 1272
1273 pfile_in_zip_read_info->stream.next_in = 1273 pfile_in_zip_read_info->rest_read_compressed-=uReadThis;
1274 (Bytef*)pfile_in_zip_read_info->read_buffer; 1274
1275 pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis; 1275 pfile_in_zip_read_info->stream.next_in =
1276 } 1276 (Bytef*)pfile_in_zip_read_info->read_buffer;
1277 1277 pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis;
1278 if ((pfile_in_zip_read_info->compression_method==0) || (pfile_in_zip_read_info->raw)) 1278 }
1279 { 1279
1280 uInt uDoCopy,i ; 1280 if ((pfile_in_zip_read_info->compression_method==0) || (pfile_in_zip_read_info->raw))
1281 1281 {
1282 if ((pfile_in_zip_read_info->stream.avail_in == 0) && 1282 uInt uDoCopy,i ;
1283 (pfile_in_zip_read_info->rest_read_compressed == 0)) 1283
1284 return (iRead==0) ? UNZ_EOF : iRead; 1284 if ((pfile_in_zip_read_info->stream.avail_in == 0) &&
1285 1285 (pfile_in_zip_read_info->rest_read_compressed == 0))
1286 if (pfile_in_zip_read_info->stream.avail_out < 1286 return (iRead==0) ? UNZ_EOF : iRead;
1287 pfile_in_zip_read_info->stream.avail_in) 1287
1288 uDoCopy = pfile_in_zip_read_info->stream.avail_out ; 1288 if (pfile_in_zip_read_info->stream.avail_out <
1289 else 1289 pfile_in_zip_read_info->stream.avail_in)
1290 uDoCopy = pfile_in_zip_read_info->stream.avail_in ; 1290 uDoCopy = pfile_in_zip_read_info->stream.avail_out ;
1291 1291 else
1292 for (i=0;i<uDoCopy;i++) 1292 uDoCopy = pfile_in_zip_read_info->stream.avail_in ;
1293 *(pfile_in_zip_read_info->stream.next_out+i) = 1293
1294 *(pfile_in_zip_read_info->stream.next_in+i); 1294 for (i=0;i<uDoCopy;i++)
1295 1295 *(pfile_in_zip_read_info->stream.next_out+i) =
1296 pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32, 1296 *(pfile_in_zip_read_info->stream.next_in+i);
1297 pfile_in_zip_read_info->stream.next_out, 1297
1298 uDoCopy); 1298 pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,
1299 pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy; 1299 pfile_in_zip_read_info->stream.next_out,
1300 pfile_in_zip_read_info->stream.avail_in -= uDoCopy; 1300 uDoCopy);
1301 pfile_in_zip_read_info->stream.avail_out -= uDoCopy; 1301 pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy;
1302 pfile_in_zip_read_info->stream.next_out += uDoCopy; 1302 pfile_in_zip_read_info->stream.avail_in -= uDoCopy;
1303 pfile_in_zip_read_info->stream.next_in += uDoCopy; 1303 pfile_in_zip_read_info->stream.avail_out -= uDoCopy;
1304 pfile_in_zip_read_info->stream.total_out += uDoCopy; 1304 pfile_in_zip_read_info->stream.next_out += uDoCopy;
1305 iRead += uDoCopy; 1305 pfile_in_zip_read_info->stream.next_in += uDoCopy;
1306 } 1306 pfile_in_zip_read_info->stream.total_out += uDoCopy;
1307 else 1307 iRead += uDoCopy;
1308 { 1308 }
1309 uLong uTotalOutBefore,uTotalOutAfter; 1309 else
1310 const Bytef *bufBefore; 1310 {
1311 uLong uOutThis; 1311 uLong uTotalOutBefore,uTotalOutAfter;
1312 int flush=Z_SYNC_FLUSH; 1312 const Bytef *bufBefore;
1313 1313 uLong uOutThis;
1314 uTotalOutBefore = pfile_in_zip_read_info->stream.total_out; 1314 int flush=Z_SYNC_FLUSH;
1315 bufBefore = pfile_in_zip_read_info->stream.next_out; 1315
1316 1316 uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;
1317 /* 1317 bufBefore = pfile_in_zip_read_info->stream.next_out;
1318 if ((pfile_in_zip_read_info->rest_read_uncompressed == 1318
1319 pfile_in_zip_read_info->stream.avail_out) && 1319 /*
1320 (pfile_in_zip_read_info->rest_read_compressed == 0)) 1320 if ((pfile_in_zip_read_info->rest_read_uncompressed ==
1321 flush = Z_FINISH; 1321 pfile_in_zip_read_info->stream.avail_out) &&
1322 */ 1322 (pfile_in_zip_read_info->rest_read_compressed == 0))
1323 err=inflate(&pfile_in_zip_read_info->stream,flush); 1323 flush = Z_FINISH;
1324 1324 */
1325 uTotalOutAfter = pfile_in_zip_read_info->stream.total_out; 1325 err=inflate(&pfile_in_zip_read_info->stream,flush);
1326 uOutThis = uTotalOutAfter-uTotalOutBefore; 1326
1327 1327 uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;
1328 pfile_in_zip_read_info->crc32 = 1328 uOutThis = uTotalOutAfter-uTotalOutBefore;
1329 crc32(pfile_in_zip_read_info->crc32,bufBefore, 1329
1330 (uInt)(uOutThis)); 1330 pfile_in_zip_read_info->crc32 =
1331 1331 crc32(pfile_in_zip_read_info->crc32,bufBefore,
1332 pfile_in_zip_read_info->rest_read_uncompressed -= 1332 (uInt)(uOutThis));
1333 uOutThis; 1333
1334 1334 pfile_in_zip_read_info->rest_read_uncompressed -=
1335 iRead += (uInt)(uTotalOutAfter - uTotalOutBefore); 1335 uOutThis;
1336 1336
1337 if (err==Z_STREAM_END) 1337 iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
1338 return (iRead==0) ? UNZ_EOF : iRead; 1338
1339 if (err!=Z_OK) 1339 if (err==Z_STREAM_END)
1340 break; 1340 return (iRead==0) ? UNZ_EOF : iRead;
1341 } 1341 if (err!=Z_OK)
1342 } 1342 break;
1343 1343 }
1344 if (err==Z_OK) 1344 }
1345 return iRead; 1345
1346 return err; 1346 if (err==Z_OK)
1347} 1347 return iRead;
1348 1348 return err;
1349 1349}
1350/* 1350
1351 Give the current position in uncompressed data 1351
1352*/ 1352/*
1353extern z_off_t ZEXPORT unztell (file) 1353 Give the current position in uncompressed data
1354 unzFile file; 1354*/
1355{ 1355extern z_off_t ZEXPORT unztell (file)
1356 unz_s* s; 1356 unzFile file;
1357 file_in_zip_read_info_s* pfile_in_zip_read_info; 1357{
1358 if (file==NULL) 1358 unz_s* s;
1359 return UNZ_PARAMERROR; 1359 file_in_zip_read_info_s* pfile_in_zip_read_info;
1360 s=(unz_s*)file; 1360 if (file==NULL)
1361 pfile_in_zip_read_info=s->pfile_in_zip_read; 1361 return UNZ_PARAMERROR;
1362 1362 s=(unz_s*)file;
1363 if (pfile_in_zip_read_info==NULL) 1363 pfile_in_zip_read_info=s->pfile_in_zip_read;
1364 return UNZ_PARAMERROR; 1364
1365 1365 if (pfile_in_zip_read_info==NULL)
1366 return (z_off_t)pfile_in_zip_read_info->stream.total_out; 1366 return UNZ_PARAMERROR;
1367} 1367
1368 1368 return (z_off_t)pfile_in_zip_read_info->stream.total_out;
1369 1369}
1370/* 1370
1371 return 1 if the end of file was reached, 0 elsewhere 1371
1372*/ 1372/*
1373extern int ZEXPORT unzeof (file) 1373 return 1 if the end of file was reached, 0 elsewhere
1374 unzFile file; 1374*/
1375{ 1375extern int ZEXPORT unzeof (file)
1376 unz_s* s; 1376 unzFile file;
1377 file_in_zip_read_info_s* pfile_in_zip_read_info; 1377{
1378 if (file==NULL) 1378 unz_s* s;
1379 return UNZ_PARAMERROR; 1379 file_in_zip_read_info_s* pfile_in_zip_read_info;
1380 s=(unz_s*)file; 1380 if (file==NULL)
1381 pfile_in_zip_read_info=s->pfile_in_zip_read; 1381 return UNZ_PARAMERROR;
1382 1382 s=(unz_s*)file;
1383 if (pfile_in_zip_read_info==NULL) 1383 pfile_in_zip_read_info=s->pfile_in_zip_read;
1384 return UNZ_PARAMERROR; 1384
1385 1385 if (pfile_in_zip_read_info==NULL)
1386 if (pfile_in_zip_read_info->rest_read_uncompressed == 0) 1386 return UNZ_PARAMERROR;
1387 return 1; 1387
1388 else 1388 if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
1389 return 0; 1389 return 1;
1390} 1390 else
1391 1391 return 0;
1392 1392}
1393 1393
1394/* 1394
1395 Read extra field from the current file (opened by unzOpenCurrentFile) 1395
1396 This is the local-header version of the extra field (sometimes, there is 1396/*
1397 more info in the local-header version than in the central-header) 1397 Read extra field from the current file (opened by unzOpenCurrentFile)
1398 1398 This is the local-header version of the extra field (sometimes, there is
1399 if buf==NULL, it return the size of the local extra field that can be read 1399 more info in the local-header version than in the central-header)
1400 1400
1401 if buf!=NULL, len is the size of the buffer, the extra header is copied in 1401 if buf==NULL, it return the size of the local extra field that can be read
1402 buf. 1402
1403 the return value is the number of bytes copied in buf, or (if <0) 1403 if buf!=NULL, len is the size of the buffer, the extra header is copied in
1404 the error code 1404 buf.
1405*/ 1405 the return value is the number of bytes copied in buf, or (if <0)
1406extern int ZEXPORT unzGetLocalExtrafield (file,buf,len) 1406 the error code
1407 unzFile file; 1407*/
1408 voidp buf; 1408extern int ZEXPORT unzGetLocalExtrafield (file,buf,len)
1409 unsigned len; 1409 unzFile file;
1410{ 1410 voidp buf;
1411 unz_s* s; 1411 unsigned len;
1412 file_in_zip_read_info_s* pfile_in_zip_read_info; 1412{
1413 uInt read_now; 1413 unz_s* s;
1414 uLong size_to_read; 1414 file_in_zip_read_info_s* pfile_in_zip_read_info;
1415 1415 uInt read_now;
1416 if (file==NULL) 1416 uLong size_to_read;
1417 return UNZ_PARAMERROR; 1417
1418 s=(unz_s*)file; 1418 if (file==NULL)
1419 pfile_in_zip_read_info=s->pfile_in_zip_read; 1419 return UNZ_PARAMERROR;
1420 1420 s=(unz_s*)file;
1421 if (pfile_in_zip_read_info==NULL) 1421 pfile_in_zip_read_info=s->pfile_in_zip_read;
1422 return UNZ_PARAMERROR; 1422
1423 1423 if (pfile_in_zip_read_info==NULL)
1424 size_to_read = (pfile_in_zip_read_info->size_local_extrafield - 1424 return UNZ_PARAMERROR;
1425 pfile_in_zip_read_info->pos_local_extrafield); 1425
1426 1426 size_to_read = (pfile_in_zip_read_info->size_local_extrafield -
1427 if (buf==NULL) 1427 pfile_in_zip_read_info->pos_local_extrafield);
1428 return (int)size_to_read; 1428
1429 1429 if (buf==NULL)
1430 if (len>size_to_read) 1430 return (int)size_to_read;
1431 read_now = (uInt)size_to_read; 1431
1432 else 1432 if (len>size_to_read)
1433 read_now = (uInt)len ; 1433 read_now = (uInt)size_to_read;
1434 1434 else
1435 if (read_now==0) 1435 read_now = (uInt)len ;
1436 return 0; 1436
1437 1437 if (read_now==0)
1438 if (ZSEEK(pfile_in_zip_read_info->z_filefunc, 1438 return 0;
1439 pfile_in_zip_read_info->filestream, 1439
1440 pfile_in_zip_read_info->offset_local_extrafield + 1440 if (ZSEEK(pfile_in_zip_read_info->z_filefunc,
1441 pfile_in_zip_read_info->pos_local_extrafield, 1441 pfile_in_zip_read_info->filestream,
1442 ZLIB_FILEFUNC_SEEK_SET)!=0) 1442 pfile_in_zip_read_info->offset_local_extrafield +
1443 return UNZ_ERRNO; 1443 pfile_in_zip_read_info->pos_local_extrafield,
1444 1444 ZLIB_FILEFUNC_SEEK_SET)!=0)
1445 if (ZREAD(pfile_in_zip_read_info->z_filefunc, 1445 return UNZ_ERRNO;
1446 pfile_in_zip_read_info->filestream, 1446
1447 buf,size_to_read)!=size_to_read) 1447 if (ZREAD(pfile_in_zip_read_info->z_filefunc,
1448 return UNZ_ERRNO; 1448 pfile_in_zip_read_info->filestream,
1449 1449 buf,size_to_read)!=size_to_read)
1450 return (int)read_now; 1450 return UNZ_ERRNO;
1451} 1451
1452 1452 return (int)read_now;
1453/* 1453}
1454 Close the file in zip opened with unzipOpenCurrentFile 1454
1455 Return UNZ_CRCERROR if all the file was read but the CRC is not good 1455/*
1456*/ 1456 Close the file in zip opened with unzipOpenCurrentFile
1457extern int ZEXPORT unzCloseCurrentFile (file) 1457 Return UNZ_CRCERROR if all the file was read but the CRC is not good
1458 unzFile file; 1458*/
1459{ 1459extern int ZEXPORT unzCloseCurrentFile (file)
1460 int err=UNZ_OK; 1460 unzFile file;
1461 1461{
1462 unz_s* s; 1462 int err=UNZ_OK;
1463 file_in_zip_read_info_s* pfile_in_zip_read_info; 1463
1464 if (file==NULL) 1464 unz_s* s;
1465 return UNZ_PARAMERROR; 1465 file_in_zip_read_info_s* pfile_in_zip_read_info;
1466 s=(unz_s*)file; 1466 if (file==NULL)
1467 pfile_in_zip_read_info=s->pfile_in_zip_read; 1467 return UNZ_PARAMERROR;
1468 1468 s=(unz_s*)file;
1469 if (pfile_in_zip_read_info==NULL) 1469 pfile_in_zip_read_info=s->pfile_in_zip_read;
1470 return UNZ_PARAMERROR; 1470
1471 1471 if (pfile_in_zip_read_info==NULL)
1472 1472 return UNZ_PARAMERROR;
1473 if ((pfile_in_zip_read_info->rest_read_uncompressed == 0) && 1473
1474 (!pfile_in_zip_read_info->raw)) 1474
1475 { 1475 if ((pfile_in_zip_read_info->rest_read_uncompressed == 0) &&
1476 if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait) 1476 (!pfile_in_zip_read_info->raw))
1477 err=UNZ_CRCERROR; 1477 {
1478 } 1478 if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait)
1479 1479 err=UNZ_CRCERROR;
1480 1480 }
1481 TRYFREE(pfile_in_zip_read_info->read_buffer); 1481
1482 pfile_in_zip_read_info->read_buffer = NULL; 1482
1483 if (pfile_in_zip_read_info->stream_initialised) 1483 TRYFREE(pfile_in_zip_read_info->read_buffer);
1484 inflateEnd(&pfile_in_zip_read_info->stream); 1484 pfile_in_zip_read_info->read_buffer = NULL;
1485 1485 if (pfile_in_zip_read_info->stream_initialised)
1486 pfile_in_zip_read_info->stream_initialised = 0; 1486 inflateEnd(&pfile_in_zip_read_info->stream);
1487 TRYFREE(pfile_in_zip_read_info); 1487
1488 1488 pfile_in_zip_read_info->stream_initialised = 0;
1489 s->pfile_in_zip_read=NULL; 1489 TRYFREE(pfile_in_zip_read_info);
1490 1490
1491 return err; 1491 s->pfile_in_zip_read=NULL;
1492} 1492
1493 1493 return err;
1494 1494}
1495/* 1495
1496 Get the global comment string of the ZipFile, in the szComment buffer. 1496
1497 uSizeBuf is the size of the szComment buffer. 1497/*
1498 return the number of byte copied or an error code <0 1498 Get the global comment string of the ZipFile, in the szComment buffer.
1499*/ 1499 uSizeBuf is the size of the szComment buffer.
1500extern int ZEXPORT unzGetGlobalComment (file, szComment, uSizeBuf) 1500 return the number of byte copied or an error code <0
1501 unzFile file; 1501*/
1502 char *szComment; 1502extern int ZEXPORT unzGetGlobalComment (file, szComment, uSizeBuf)
1503 uLong uSizeBuf; 1503 unzFile file;
1504{ 1504 char *szComment;
1505 int err=UNZ_OK; 1505 uLong uSizeBuf;
1506 unz_s* s; 1506{
1507 uLong uReadThis ; 1507 int err=UNZ_OK;
1508 if (file==NULL) 1508 unz_s* s;
1509 return UNZ_PARAMERROR; 1509 uLong uReadThis ;
1510 s=(unz_s*)file; 1510 if (file==NULL)
1511 1511 return UNZ_PARAMERROR;
1512 uReadThis = uSizeBuf; 1512 s=(unz_s*)file;
1513 if (uReadThis>s->gi.size_comment) 1513
1514 uReadThis = s->gi.size_comment; 1514 uReadThis = uSizeBuf;
1515 1515 if (uReadThis>s->gi.size_comment)
1516 if (ZSEEK(s->z_filefunc,s->filestream,s->central_pos+22,ZLIB_FILEFUNC_SEEK_SET)!=0) 1516 uReadThis = s->gi.size_comment;
1517 return UNZ_ERRNO; 1517
1518 1518 if (ZSEEK(s->z_filefunc,s->filestream,s->central_pos+22,ZLIB_FILEFUNC_SEEK_SET)!=0)
1519 if (uReadThis>0) 1519 return UNZ_ERRNO;
1520 { 1520
1521 *szComment='\0'; 1521 if (uReadThis>0)
1522 if (ZREAD(s->z_filefunc,s->filestream,szComment,uReadThis)!=uReadThis) 1522 {
1523 return UNZ_ERRNO; 1523 *szComment='\0';
1524 } 1524 if (ZREAD(s->z_filefunc,s->filestream,szComment,uReadThis)!=uReadThis)
1525 1525 return UNZ_ERRNO;
1526 if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment)) 1526 }
1527 *(szComment+s->gi.size_comment)='\0'; 1527
1528 return (int)uReadThis; 1528 if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment))
1529} 1529 *(szComment+s->gi.size_comment)='\0';
1530 return (int)uReadThis;
1531}
diff --git a/contrib/minizip/unzip.h b/contrib/minizip/unzip.h
index 67ca851..48e6832 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.21, March 10th, 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/zconf.h b/contrib/minizip/zconf.h
new file mode 100644
index 0000000..8e6215a
--- /dev/null
+++ b/contrib/minizip/zconf.h
@@ -0,0 +1,326 @@
1/* zconf.h -- configuration of the zlib compression library
2 * Copyright (C) 1995-2003 Jean-loup Gailly.
3 * For conditions of distribution and use, see copyright notice in zlib.h
4 */
5
6/* @(#) $Id$ */
7
8#ifndef _ZCONF_H
9#define _ZCONF_H
10
11/*
12 * If you *really* need a unique prefix for all types and library functions,
13 * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
14 */
15#ifdef Z_PREFIX
16# define deflateInit_ z_deflateInit_
17# define deflate z_deflate
18# define deflateEnd z_deflateEnd
19# define inflateInit_ z_inflateInit_
20# define inflate z_inflate
21# define inflateEnd z_inflateEnd
22# define deflateInit2_ z_deflateInit2_
23# define deflateSetDictionary z_deflateSetDictionary
24# define deflateCopy z_deflateCopy
25# define deflateReset z_deflateReset
26# define deflateParams z_deflateParams
27# define deflateBound z_deflateBound
28# define inflateInit2_ z_inflateInit2_
29# define inflateSetDictionary z_inflateSetDictionary
30# define inflateSync z_inflateSync
31# define inflateSyncPoint z_inflateSyncPoint
32# define inflateCopy z_inflateCopy
33# define inflateReset z_inflateReset
34# define compress z_compress
35# define compress2 z_compress2
36# define compressBound z_compressBound
37# define uncompress z_uncompress
38# define adler32 z_adler32
39# define crc32 z_crc32
40# define get_crc_table z_get_crc_table
41
42# define Byte z_Byte
43# define uInt z_uInt
44# define uLong z_uLong
45# define Bytef z_Bytef
46# define charf z_charf
47# define intf z_intf
48# define uIntf z_uIntf
49# define uLongf z_uLongf
50# define voidpf z_voidpf
51# define voidp z_voidp
52#endif
53
54
55#ifdef __STDC_VERSION__
56# ifndef STDC
57# define STDC
58# endif
59# if __STDC_VERSION__ >= 199901L
60# ifndef STDC99
61# define STDC99
62# endif
63# endif
64#endif
65
66
67#if (defined(_WIN32) || defined(__WIN32__)) && !defined(WIN32)
68# define WIN32
69#endif
70#if defined(__GNUC__) || defined(WIN32) || defined(__386__) || defined(i386)
71# ifndef __32BIT__
72# define __32BIT__
73# endif
74#endif
75#if defined(__MSDOS__) && !defined(MSDOS)
76# define MSDOS
77#endif
78
79/*
80 * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
81 * than 64k bytes at a time (needed on systems with 16-bit int).
82 */
83#if defined(MSDOS) && !defined(__32BIT__)
84# define MAXSEG_64K
85#endif
86#ifdef MSDOS
87# define UNALIGNED_OK
88#endif
89
90#if (defined(MSDOS) || defined(_WINDOWS) || defined(WIN32)) && !defined(STDC)
91# define STDC
92#endif
93#if defined(__STDC__) || defined(__cplusplus) || defined(__OS2__)
94# ifndef STDC
95# define STDC
96# endif
97#endif
98
99#if defined __HOS_AIX__
100# ifndef STDC
101# define STDC
102# endif
103#endif
104
105#ifndef STDC
106# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
107# define const /* note: need a more gentle solution here */
108# endif
109#endif
110
111/* Some Mac compilers merge all .h files incorrectly: */
112#if defined(__MWERKS__) || defined(applec) ||defined(THINK_C) ||defined(__SC__)
113# define NO_DUMMY_DECL
114#endif
115
116/* Old Borland C incorrectly complains about missing returns: */
117#if defined(__BORLANDC__) && (__BORLANDC__ < 0x460)
118# define NEED_DUMMY_RETURN
119#endif
120#if defined(__TURBOC__) && !defined(__BORLANDC__)
121# define NEED_DUMMY_RETURN
122#endif
123
124
125/* Maximum value for memLevel in deflateInit2 */
126#ifndef MAX_MEM_LEVEL
127# ifdef MAXSEG_64K
128# define MAX_MEM_LEVEL 8
129# else
130# define MAX_MEM_LEVEL 9
131# endif
132#endif
133
134/* Maximum value for windowBits in deflateInit2 and inflateInit2.
135 * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
136 * created by gzip. (Files created by minigzip can still be extracted by
137 * gzip.)
138 */
139#ifndef MAX_WBITS
140# define MAX_WBITS 15 /* 32K LZ77 window */
141#endif
142
143/* The memory requirements for deflate are (in bytes):
144 (1 << (windowBits+2)) + (1 << (memLevel+9))
145 that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values)
146 plus a few kilobytes for small objects. For example, if you want to reduce
147 the default memory requirements from 256K to 128K, compile with
148 make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
149 Of course this will generally degrade compression (there's no free lunch).
150
151 The memory requirements for inflate are (in bytes) 1 << windowBits
152 that is, 32K for windowBits=15 (default value) plus a few kilobytes
153 for small objects.
154*/
155
156 /* Type declarations */
157
158#ifndef OF /* function prototypes */
159# ifdef STDC
160# define OF(args) args
161# else
162# define OF(args) ()
163# endif
164#endif
165
166/*
167 * Microsoft Visual Studio define _vsnprintf but not vsnprintf
168 */
169#if !defined(STDC99) && !(defined(__TURBOC__) && __TURBOC__ >= 0x550) && !defined(VSNPRINTF_DEFINED)
170# ifdef MSDOS
171 /* vsnprintf may exist on some MS-DOS compilers (DJGPP?),
172 but for now we just assume it doesn't. */
173# define NO_vsnprintf
174# endif
175# ifdef WIN32
176 /* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */
177# if !defined(vsnprintf) && !defined(__TURBOC__)
178# define vsnprintf _vsnprintf
179# endif
180# endif
181# ifdef __TURBOC__
182# define NO_vsnprintf
183# endif
184#endif
185
186/* The following definitions for FAR are needed only for MSDOS mixed
187 * model programming (small or medium model with some far allocations).
188 * This was tested only with MSC; for other MSDOS compilers you may have
189 * to define NO_MEMCPY in zutil.h. If you don't need the mixed model,
190 * just define FAR to be empty.
191 */
192#if (defined(M_I86SM) || defined(M_I86MM)) && !defined(__32BIT__)
193 /* MSC small or medium model */
194# define SMALL_MEDIUM
195# ifdef _MSC_VER
196# define FAR _far
197# else
198# define FAR far
199# endif
200#endif
201#if defined(__BORLANDC__) && (defined(__SMALL__) || defined(__MEDIUM__))
202# ifndef __32BIT__
203# define SMALL_MEDIUM
204# define FAR _far
205# endif
206#endif
207
208#if defined(WIN32) && (!defined(ZLIB_WIN32_NODLL)) && (!defined(ZLIB_DLL))
209# define ZLIB_DLL
210#endif
211
212/* Compile with -DZLIB_DLL for Windows DLL support */
213#if defined(ZLIB_DLL)
214# if defined(_WINDOWS) || defined(WINDOWS) || defined(WIN32)
215# ifndef WINAPIV
216# ifdef FAR
217# undef FAR
218# endif
219# include <windows.h>
220# endif
221# ifdef WIN32
222# define ZEXPORT WINAPI
223# define ZEXPORTVA WINAPIV
224# else
225# define ZEXPORT WINAPI _export
226# define ZEXPORTVA FAR _cdecl _export
227# endif
228# endif
229# if defined (__BORLANDC__)
230# if (__BORLANDC__ >= 0x0500) && defined (WIN32)
231# include <windows.h>
232# define ZEXPORT __declspec(dllexport) WINAPI
233# define ZEXPORTVA __declspec(dllexport) WINAPIV
234# else
235# if defined (_Windows) && defined (__DLL__)
236# define ZEXPORT _export
237# define ZEXPORTVA _export
238# endif
239# endif
240# endif
241#endif
242
243#if defined (__BEOS__)
244# if defined (ZLIB_DLL)
245# define ZEXTERN extern __declspec(dllexport)
246# else
247# define ZEXTERN extern __declspec(dllimport)
248# endif
249#endif
250
251#ifndef ZEXPORT
252# define ZEXPORT
253#endif
254#ifndef ZEXPORTVA
255# define ZEXPORTVA
256#endif
257#ifndef ZEXTERN
258# define ZEXTERN extern
259#endif
260
261#ifndef FAR
262# define FAR
263#endif
264
265#if !defined(__MACTYPES__)
266typedef unsigned char Byte; /* 8 bits */
267#endif
268typedef unsigned int uInt; /* 16 bits or more */
269typedef unsigned long uLong; /* 32 bits or more */
270
271#ifdef SMALL_MEDIUM
272 /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
273# define Bytef Byte FAR
274#else
275 typedef Byte FAR Bytef;
276#endif
277typedef char FAR charf;
278typedef int FAR intf;
279typedef uInt FAR uIntf;
280typedef uLong FAR uLongf;
281
282#ifdef STDC
283 typedef void const *voidpc;
284 typedef void FAR *voidpf;
285 typedef void *voidp;
286#else
287 typedef Byte const *voidpc;
288 typedef Byte FAR *voidpf;
289 typedef Byte *voidp;
290#endif
291
292#if 0 /* HAVE_UNISTD_H -- this line is updated by ./configure */
293# include <sys/types.h> /* for off_t */
294# include <unistd.h> /* for SEEK_* and off_t */
295# ifdef VMS
296# include <unixio.h> /* for off_t */
297# endif
298# define z_off_t off_t
299#endif
300#ifndef SEEK_SET
301# define SEEK_SET 0 /* Seek from beginning of file. */
302# define SEEK_CUR 1 /* Seek from current position. */
303# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */
304#endif
305#ifndef z_off_t
306# define z_off_t long
307#endif
308
309/* MVS linker does not support external names larger than 8 bytes */
310#if defined(__MVS__)
311# pragma map(deflateInit_,"DEIN")
312# pragma map(deflateInit2_,"DEIN2")
313# pragma map(deflateEnd,"DEEND")
314# pragma map(deflateBound,"DEBND")
315# pragma map(inflateInit_,"ININ")
316# pragma map(inflateInit2_,"ININ2")
317# pragma map(inflateEnd,"INEND")
318# pragma map(inflateSync,"INSY")
319# pragma map(inflateSetDictionary,"INSEDI")
320# pragma map(compressBound,"CMBND")
321# pragma map(inflate_table,"INTABL")
322# pragma map(inflate_fast,"INFA")
323# pragma map(inflate_copyright,"INCOPY")
324#endif
325
326#endif /* _ZCONF_H */
diff --git a/contrib/minizip/zip.c b/contrib/minizip/zip.c
index 29c17d8..00587fb 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.21, March 10th, 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.21 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 NOCRPYT 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 NOCRPYT 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 NOCRPYT 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 NOCRPYT 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 849 if (err==Z_OK)
850 850 zi->in_opened_file_inzip = 1;
851 if (err==Z_OK) 851 return err;
852 zi->in_opened_file_inzip = 1; 852}
853 return err; 853
854} 854extern int ZEXPORT zipOpenNewFileInZip2(file, filename, zipfi,
855 855 extrafield_local, size_extrafield_local,
856extern int ZEXPORT zipOpenNewFileInZip2(file, filename, zipfi, 856 extrafield_global, size_extrafield_global,
857 extrafield_local, size_extrafield_local, 857 comment, method, level, raw)
858 extrafield_global, size_extrafield_global, 858 zipFile file;
859 comment, method, level, raw) 859 const char* filename;
860 zipFile file; 860 const zip_fileinfo* zipfi;
861 const char* filename; 861 const void* extrafield_local;
862 const zip_fileinfo* zipfi; 862 uInt size_extrafield_local;
863 const void* extrafield_local; 863 const void* extrafield_global;
864 uInt size_extrafield_local; 864 uInt size_extrafield_global;
865 const void* extrafield_global; 865 const char* comment;
866 uInt size_extrafield_global; 866 int method;
867 const char* comment; 867 int level;
868 int method; 868 int raw;
869 int level; 869{
870 int raw; 870 return zipOpenNewFileInZip3 (file, filename, zipfi,
871{ 871 extrafield_local, size_extrafield_local,
872 return zipOpenNewFileInZip3 (file, filename, zipfi, 872 extrafield_global, size_extrafield_global,
873 extrafield_local, size_extrafield_local, 873 comment, method, level, raw,
874 extrafield_global, size_extrafield_global, 874 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
875 comment, method, level, raw, 875 NULL, 0);
876 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, 876}
877 NULL, 0); 877
878} 878extern int ZEXPORT zipOpenNewFileInZip (file, filename, zipfi,
879 879 extrafield_local, size_extrafield_local,
880extern int ZEXPORT zipOpenNewFileInZip (file, filename, zipfi, 880 extrafield_global, size_extrafield_global,
881 extrafield_local, size_extrafield_local, 881 comment, method, level)
882 extrafield_global, size_extrafield_global, 882 zipFile file;
883 comment, method, level) 883 const char* filename;
884 zipFile file; 884 const zip_fileinfo* zipfi;
885 const char* filename; 885 const void* extrafield_local;
886 const zip_fileinfo* zipfi; 886 uInt size_extrafield_local;
887 const void* extrafield_local; 887 const void* extrafield_global;
888 uInt size_extrafield_local; 888 uInt size_extrafield_global;
889 const void* extrafield_global; 889 const char* comment;
890 uInt size_extrafield_global; 890 int method;
891 const char* comment; 891 int level;
892 int method; 892{
893 int level; 893 return zipOpenNewFileInZip2 (file, filename, zipfi,
894{ 894 extrafield_local, size_extrafield_local,
895 return zipOpenNewFileInZip2 (file, filename, zipfi, 895 extrafield_global, size_extrafield_global,
896 extrafield_local, size_extrafield_local, 896 comment, method, level, 0);
897 extrafield_global, size_extrafield_global, 897}
898 comment, method, level, 0); 898
899} 899local int zipFlushWriteBuffer(zi)
900 900 zip_internal* zi;
901local int zipFlushWriteBuffer(zi) 901{
902 zip_internal* zi; 902 int err=ZIP_OK;
903{ 903
904 int err=ZIP_OK; 904 if (zi->ci.encrypt != 0)
905 905 {
906 if (zi->ci.encrypt != 0) 906#ifndef NOCRYPT
907 { 907 uInt i;
908 uInt i; 908 int t;
909 int t; 909 for (i=0;i<zi->ci.pos_in_buffered_data;i++)
910 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,
911 zi->ci.buffered_data[i] = zencode(zi->ci.keys, zi->ci.pcrc_32_tab, 911 zi->ci.buffered_data[i],t);
912 zi->ci.buffered_data[i],t); 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 NOCRPYT 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 4bc6aa4..d863e1a 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.21, March 10th, 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 06:23:19 +0000