diff options
author | Mark Adler <madler@alumni.caltech.edu> | 2011-09-09 23:25:17 -0700 |
---|---|---|
committer | Mark Adler <madler@alumni.caltech.edu> | 2011-09-09 23:25:17 -0700 |
commit | abf180a067223611620dd97dd5681df7c7fa7c9b (patch) | |
tree | 48ce6022aa1670380c098bd0abed2ac4aa1d9ca0 /contrib/minizip/zip.c | |
parent | 9c3a5830218c4e7fff23b8fc4386269db77a03a9 (diff) | |
download | zlib-1.2.3.tar.gz zlib-1.2.3.tar.bz2 zlib-1.2.3.zip |
zlib 1.2.3v1.2.3
Diffstat (limited to 'contrib/minizip/zip.c')
-rw-r--r-- | contrib/minizip/zip.c | 2438 |
1 files changed, 1219 insertions, 1219 deletions
diff --git a/contrib/minizip/zip.c b/contrib/minizip/zip.c index 400e2ba..7fbe002 100644 --- a/contrib/minizip/zip.c +++ b/contrib/minizip/zip.c | |||
@@ -1,1219 +1,1219 @@ | |||
1 | /* zip.c -- IO on .zip files using zlib | 1 | /* zip.c -- IO on .zip files using zlib |
2 | Version 1.01e, February 12th, 2005 | 2 | Version 1.01e, February 12th, 2005 |
3 | 3 | ||
4 | 27 Dec 2004 Rolf Kalbermatter | 4 | 27 Dec 2004 Rolf Kalbermatter |
5 | Modification to zipOpen2 to support globalComment retrieval. | 5 | Modification to zipOpen2 to support globalComment retrieval. |
6 | 6 | ||
7 | Copyright (C) 1998-2005 Gilles Vollant | 7 | Copyright (C) 1998-2005 Gilles Vollant |
8 | 8 | ||
9 | Read zip.h for more info | 9 | Read zip.h for more info |
10 | */ | 10 | */ |
11 | 11 | ||
12 | 12 | ||
13 | #include <stdio.h> | 13 | #include <stdio.h> |
14 | #include <stdlib.h> | 14 | #include <stdlib.h> |
15 | #include <string.h> | 15 | #include <string.h> |
16 | #include <time.h> | 16 | #include <time.h> |
17 | #include "zlib.h" | 17 | #include "zlib.h" |
18 | #include "zip.h" | 18 | #include "zip.h" |
19 | 19 | ||
20 | #ifdef STDC | 20 | #ifdef STDC |
21 | # include <stddef.h> | 21 | # include <stddef.h> |
22 | # include <string.h> | 22 | # include <string.h> |
23 | # include <stdlib.h> | 23 | # include <stdlib.h> |
24 | #endif | 24 | #endif |
25 | #ifdef NO_ERRNO_H | 25 | #ifdef NO_ERRNO_H |
26 | extern int errno; | 26 | extern int errno; |
27 | #else | 27 | #else |
28 | # include <errno.h> | 28 | # include <errno.h> |
29 | #endif | 29 | #endif |
30 | 30 | ||
31 | 31 | ||
32 | #ifndef local | 32 | #ifndef local |
33 | # define local static | 33 | # define local static |
34 | #endif | 34 | #endif |
35 | /* compile with -Dlocal if your debugger can't find static symbols */ | 35 | /* compile with -Dlocal if your debugger can't find static symbols */ |
36 | 36 | ||
37 | #ifndef VERSIONMADEBY | 37 | #ifndef VERSIONMADEBY |
38 | # define VERSIONMADEBY (0x0) /* platform depedent */ | 38 | # define VERSIONMADEBY (0x0) /* platform depedent */ |
39 | #endif | 39 | #endif |
40 | 40 | ||
41 | #ifndef Z_BUFSIZE | 41 | #ifndef Z_BUFSIZE |
42 | #define Z_BUFSIZE (16384) | 42 | #define Z_BUFSIZE (16384) |
43 | #endif | 43 | #endif |
44 | 44 | ||
45 | #ifndef Z_MAXFILENAMEINZIP | 45 | #ifndef Z_MAXFILENAMEINZIP |
46 | #define Z_MAXFILENAMEINZIP (256) | 46 | #define Z_MAXFILENAMEINZIP (256) |
47 | #endif | 47 | #endif |
48 | 48 | ||
49 | #ifndef ALLOC | 49 | #ifndef ALLOC |
50 | # define ALLOC(size) (malloc(size)) | 50 | # define ALLOC(size) (malloc(size)) |
51 | #endif | 51 | #endif |
52 | #ifndef TRYFREE | 52 | #ifndef TRYFREE |
53 | # define TRYFREE(p) {if (p) free(p);} | 53 | # define TRYFREE(p) {if (p) free(p);} |
54 | #endif | 54 | #endif |
55 | 55 | ||
56 | /* | 56 | /* |
57 | #define SIZECENTRALDIRITEM (0x2e) | 57 | #define SIZECENTRALDIRITEM (0x2e) |
58 | #define SIZEZIPLOCALHEADER (0x1e) | 58 | #define SIZEZIPLOCALHEADER (0x1e) |
59 | */ | 59 | */ |
60 | 60 | ||
61 | /* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */ | 61 | /* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */ |
62 | 62 | ||
63 | #ifndef SEEK_CUR | 63 | #ifndef SEEK_CUR |
64 | #define SEEK_CUR 1 | 64 | #define SEEK_CUR 1 |
65 | #endif | 65 | #endif |
66 | 66 | ||
67 | #ifndef SEEK_END | 67 | #ifndef SEEK_END |
68 | #define SEEK_END 2 | 68 | #define SEEK_END 2 |
69 | #endif | 69 | #endif |
70 | 70 | ||
71 | #ifndef SEEK_SET | 71 | #ifndef SEEK_SET |
72 | #define SEEK_SET 0 | 72 | #define SEEK_SET 0 |
73 | #endif | 73 | #endif |
74 | 74 | ||
75 | #ifndef DEF_MEM_LEVEL | 75 | #ifndef DEF_MEM_LEVEL |
76 | #if MAX_MEM_LEVEL >= 8 | 76 | #if MAX_MEM_LEVEL >= 8 |
77 | # define DEF_MEM_LEVEL 8 | 77 | # define DEF_MEM_LEVEL 8 |
78 | #else | 78 | #else |
79 | # define DEF_MEM_LEVEL MAX_MEM_LEVEL | 79 | # define DEF_MEM_LEVEL MAX_MEM_LEVEL |
80 | #endif | 80 | #endif |
81 | #endif | 81 | #endif |
82 | const char zip_copyright[] = | 82 | const char zip_copyright[] = |
83 | " zip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll"; | 83 | " zip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll"; |
84 | 84 | ||
85 | 85 | ||
86 | #define SIZEDATA_INDATABLOCK (4096-(4*4)) | 86 | #define SIZEDATA_INDATABLOCK (4096-(4*4)) |
87 | 87 | ||
88 | #define LOCALHEADERMAGIC (0x04034b50) | 88 | #define LOCALHEADERMAGIC (0x04034b50) |
89 | #define CENTRALHEADERMAGIC (0x02014b50) | 89 | #define CENTRALHEADERMAGIC (0x02014b50) |
90 | #define ENDHEADERMAGIC (0x06054b50) | 90 | #define ENDHEADERMAGIC (0x06054b50) |
91 | 91 | ||
92 | #define FLAG_LOCALHEADER_OFFSET (0x06) | 92 | #define FLAG_LOCALHEADER_OFFSET (0x06) |
93 | #define CRC_LOCALHEADER_OFFSET (0x0e) | 93 | #define CRC_LOCALHEADER_OFFSET (0x0e) |
94 | 94 | ||
95 | #define SIZECENTRALHEADER (0x2e) /* 46 */ | 95 | #define SIZECENTRALHEADER (0x2e) /* 46 */ |
96 | 96 | ||
97 | typedef struct linkedlist_datablock_internal_s | 97 | typedef struct linkedlist_datablock_internal_s |
98 | { | 98 | { |
99 | struct linkedlist_datablock_internal_s* next_datablock; | 99 | struct linkedlist_datablock_internal_s* next_datablock; |
100 | uLong avail_in_this_block; | 100 | uLong avail_in_this_block; |
101 | uLong filled_in_this_block; | 101 | uLong filled_in_this_block; |
102 | uLong unused; /* for future use and alignement */ | 102 | uLong unused; /* for future use and alignement */ |
103 | unsigned char data[SIZEDATA_INDATABLOCK]; | 103 | unsigned char data[SIZEDATA_INDATABLOCK]; |
104 | } linkedlist_datablock_internal; | 104 | } linkedlist_datablock_internal; |
105 | 105 | ||
106 | typedef struct linkedlist_data_s | 106 | typedef struct linkedlist_data_s |
107 | { | 107 | { |
108 | linkedlist_datablock_internal* first_block; | 108 | linkedlist_datablock_internal* first_block; |
109 | linkedlist_datablock_internal* last_block; | 109 | linkedlist_datablock_internal* last_block; |
110 | } linkedlist_data; | 110 | } linkedlist_data; |
111 | 111 | ||
112 | 112 | ||
113 | typedef struct | 113 | typedef struct |
114 | { | 114 | { |
115 | z_stream stream; /* zLib stream structure for inflate */ | 115 | z_stream stream; /* zLib stream structure for inflate */ |
116 | int stream_initialised; /* 1 is stream is initialised */ | 116 | int stream_initialised; /* 1 is stream is initialised */ |
117 | uInt pos_in_buffered_data; /* last written byte in buffered_data */ | 117 | uInt pos_in_buffered_data; /* last written byte in buffered_data */ |
118 | 118 | ||
119 | uLong pos_local_header; /* offset of the local header of the file | 119 | uLong pos_local_header; /* offset of the local header of the file |
120 | currenty writing */ | 120 | currenty writing */ |
121 | char* central_header; /* central header data for the current file */ | 121 | char* central_header; /* central header data for the current file */ |
122 | uLong size_centralheader; /* size of the central header for cur file */ | 122 | uLong size_centralheader; /* size of the central header for cur file */ |
123 | uLong flag; /* flag of the file currently writing */ | 123 | uLong flag; /* flag of the file currently writing */ |
124 | 124 | ||
125 | int method; /* compression method of file currenty wr.*/ | 125 | int method; /* compression method of file currenty wr.*/ |
126 | int raw; /* 1 for directly writing raw data */ | 126 | int raw; /* 1 for directly writing raw data */ |
127 | Byte buffered_data[Z_BUFSIZE];/* buffer contain compressed data to be writ*/ | 127 | Byte buffered_data[Z_BUFSIZE];/* buffer contain compressed data to be writ*/ |
128 | uLong dosDate; | 128 | uLong dosDate; |
129 | uLong crc32; | 129 | uLong crc32; |
130 | int encrypt; | 130 | int encrypt; |
131 | #ifndef NOCRYPT | 131 | #ifndef NOCRYPT |
132 | unsigned long keys[3]; /* keys defining the pseudo-random sequence */ | 132 | unsigned long keys[3]; /* keys defining the pseudo-random sequence */ |
133 | const unsigned long* pcrc_32_tab; | 133 | const unsigned long* pcrc_32_tab; |
134 | int crypt_header_size; | 134 | int crypt_header_size; |
135 | #endif | 135 | #endif |
136 | } curfile_info; | 136 | } curfile_info; |
137 | 137 | ||
138 | typedef struct | 138 | typedef struct |
139 | { | 139 | { |
140 | zlib_filefunc_def z_filefunc; | 140 | zlib_filefunc_def z_filefunc; |
141 | voidpf filestream; /* io structore of the zipfile */ | 141 | voidpf filestream; /* io structore of the zipfile */ |
142 | linkedlist_data central_dir;/* datablock with central dir in construction*/ | 142 | linkedlist_data central_dir;/* datablock with central dir in construction*/ |
143 | int in_opened_file_inzip; /* 1 if a file in the zip is currently writ.*/ | 143 | int in_opened_file_inzip; /* 1 if a file in the zip is currently writ.*/ |
144 | curfile_info ci; /* info on the file curretly writing */ | 144 | curfile_info ci; /* info on the file curretly writing */ |
145 | 145 | ||
146 | uLong begin_pos; /* position of the beginning of the zipfile */ | 146 | uLong begin_pos; /* position of the beginning of the zipfile */ |
147 | uLong add_position_when_writting_offset; | 147 | uLong add_position_when_writting_offset; |
148 | uLong number_entry; | 148 | uLong number_entry; |
149 | #ifndef NO_ADDFILEINEXISTINGZIP | 149 | #ifndef NO_ADDFILEINEXISTINGZIP |
150 | char *globalcomment; | 150 | char *globalcomment; |
151 | #endif | 151 | #endif |
152 | } zip_internal; | 152 | } zip_internal; |
153 | 153 | ||
154 | 154 | ||
155 | 155 | ||
156 | #ifndef NOCRYPT | 156 | #ifndef NOCRYPT |
157 | #define INCLUDECRYPTINGCODE_IFCRYPTALLOWED | 157 | #define INCLUDECRYPTINGCODE_IFCRYPTALLOWED |
158 | #include "crypt.h" | 158 | #include "crypt.h" |
159 | #endif | 159 | #endif |
160 | 160 | ||
161 | local linkedlist_datablock_internal* allocate_new_datablock() | 161 | local linkedlist_datablock_internal* allocate_new_datablock() |
162 | { | 162 | { |
163 | linkedlist_datablock_internal* ldi; | 163 | linkedlist_datablock_internal* ldi; |
164 | ldi = (linkedlist_datablock_internal*) | 164 | ldi = (linkedlist_datablock_internal*) |
165 | ALLOC(sizeof(linkedlist_datablock_internal)); | 165 | ALLOC(sizeof(linkedlist_datablock_internal)); |
166 | if (ldi!=NULL) | 166 | if (ldi!=NULL) |
167 | { | 167 | { |
168 | ldi->next_datablock = NULL ; | 168 | ldi->next_datablock = NULL ; |
169 | ldi->filled_in_this_block = 0 ; | 169 | ldi->filled_in_this_block = 0 ; |
170 | ldi->avail_in_this_block = SIZEDATA_INDATABLOCK ; | 170 | ldi->avail_in_this_block = SIZEDATA_INDATABLOCK ; |
171 | } | 171 | } |
172 | return ldi; | 172 | return ldi; |
173 | } | 173 | } |
174 | 174 | ||
175 | local void free_datablock(ldi) | 175 | local void free_datablock(ldi) |
176 | linkedlist_datablock_internal* ldi; | 176 | linkedlist_datablock_internal* ldi; |
177 | { | 177 | { |
178 | while (ldi!=NULL) | 178 | while (ldi!=NULL) |
179 | { | 179 | { |
180 | linkedlist_datablock_internal* ldinext = ldi->next_datablock; | 180 | linkedlist_datablock_internal* ldinext = ldi->next_datablock; |
181 | TRYFREE(ldi); | 181 | TRYFREE(ldi); |
182 | ldi = ldinext; | 182 | ldi = ldinext; |
183 | } | 183 | } |
184 | } | 184 | } |
185 | 185 | ||
186 | local void init_linkedlist(ll) | 186 | local void init_linkedlist(ll) |
187 | linkedlist_data* ll; | 187 | linkedlist_data* ll; |
188 | { | 188 | { |
189 | ll->first_block = ll->last_block = NULL; | 189 | ll->first_block = ll->last_block = NULL; |
190 | } | 190 | } |
191 | 191 | ||
192 | local void free_linkedlist(ll) | 192 | local void free_linkedlist(ll) |
193 | linkedlist_data* ll; | 193 | linkedlist_data* ll; |
194 | { | 194 | { |
195 | free_datablock(ll->first_block); | 195 | free_datablock(ll->first_block); |
196 | ll->first_block = ll->last_block = NULL; | 196 | ll->first_block = ll->last_block = NULL; |
197 | } | 197 | } |
198 | 198 | ||
199 | 199 | ||
200 | local int add_data_in_datablock(ll,buf,len) | 200 | local int add_data_in_datablock(ll,buf,len) |
201 | linkedlist_data* ll; | 201 | linkedlist_data* ll; |
202 | const void* buf; | 202 | const void* buf; |
203 | uLong len; | 203 | uLong len; |
204 | { | 204 | { |
205 | linkedlist_datablock_internal* ldi; | 205 | linkedlist_datablock_internal* ldi; |
206 | const unsigned char* from_copy; | 206 | const unsigned char* from_copy; |
207 | 207 | ||
208 | if (ll==NULL) | 208 | if (ll==NULL) |
209 | return ZIP_INTERNALERROR; | 209 | return ZIP_INTERNALERROR; |
210 | 210 | ||
211 | if (ll->last_block == NULL) | 211 | if (ll->last_block == NULL) |
212 | { | 212 | { |
213 | ll->first_block = ll->last_block = allocate_new_datablock(); | 213 | ll->first_block = ll->last_block = allocate_new_datablock(); |
214 | if (ll->first_block == NULL) | 214 | if (ll->first_block == NULL) |
215 | return ZIP_INTERNALERROR; | 215 | return ZIP_INTERNALERROR; |
216 | } | 216 | } |
217 | 217 | ||
218 | ldi = ll->last_block; | 218 | ldi = ll->last_block; |
219 | from_copy = (unsigned char*)buf; | 219 | from_copy = (unsigned char*)buf; |
220 | 220 | ||
221 | while (len>0) | 221 | while (len>0) |
222 | { | 222 | { |
223 | uInt copy_this; | 223 | uInt copy_this; |
224 | uInt i; | 224 | uInt i; |
225 | unsigned char* to_copy; | 225 | unsigned char* to_copy; |
226 | 226 | ||
227 | if (ldi->avail_in_this_block==0) | 227 | if (ldi->avail_in_this_block==0) |
228 | { | 228 | { |
229 | ldi->next_datablock = allocate_new_datablock(); | 229 | ldi->next_datablock = allocate_new_datablock(); |
230 | if (ldi->next_datablock == NULL) | 230 | if (ldi->next_datablock == NULL) |
231 | return ZIP_INTERNALERROR; | 231 | return ZIP_INTERNALERROR; |
232 | ldi = ldi->next_datablock ; | 232 | ldi = ldi->next_datablock ; |
233 | ll->last_block = ldi; | 233 | ll->last_block = ldi; |
234 | } | 234 | } |
235 | 235 | ||
236 | if (ldi->avail_in_this_block < len) | 236 | if (ldi->avail_in_this_block < len) |
237 | copy_this = (uInt)ldi->avail_in_this_block; | 237 | copy_this = (uInt)ldi->avail_in_this_block; |
238 | else | 238 | else |
239 | copy_this = (uInt)len; | 239 | copy_this = (uInt)len; |
240 | 240 | ||
241 | to_copy = &(ldi->data[ldi->filled_in_this_block]); | 241 | to_copy = &(ldi->data[ldi->filled_in_this_block]); |
242 | 242 | ||
243 | for (i=0;i<copy_this;i++) | 243 | for (i=0;i<copy_this;i++) |
244 | *(to_copy+i)=*(from_copy+i); | 244 | *(to_copy+i)=*(from_copy+i); |
245 | 245 | ||
246 | ldi->filled_in_this_block += copy_this; | 246 | ldi->filled_in_this_block += copy_this; |
247 | ldi->avail_in_this_block -= copy_this; | 247 | ldi->avail_in_this_block -= copy_this; |
248 | from_copy += copy_this ; | 248 | from_copy += copy_this ; |
249 | len -= copy_this; | 249 | len -= copy_this; |
250 | } | 250 | } |
251 | return ZIP_OK; | 251 | return ZIP_OK; |
252 | } | 252 | } |
253 | 253 | ||
254 | 254 | ||
255 | 255 | ||
256 | /****************************************************************************/ | 256 | /****************************************************************************/ |
257 | 257 | ||
258 | #ifndef NO_ADDFILEINEXISTINGZIP | 258 | #ifndef NO_ADDFILEINEXISTINGZIP |
259 | /* =========================================================================== | 259 | /* =========================================================================== |
260 | Inputs a long in LSB order to the given file | 260 | Inputs a long in LSB order to the given file |
261 | nbByte == 1, 2 or 4 (byte, short or long) | 261 | nbByte == 1, 2 or 4 (byte, short or long) |
262 | */ | 262 | */ |
263 | 263 | ||
264 | local int ziplocal_putValue OF((const zlib_filefunc_def* pzlib_filefunc_def, | 264 | local int ziplocal_putValue OF((const zlib_filefunc_def* pzlib_filefunc_def, |
265 | voidpf filestream, uLong x, int nbByte)); | 265 | voidpf filestream, uLong x, int nbByte)); |
266 | local int ziplocal_putValue (pzlib_filefunc_def, filestream, x, nbByte) | 266 | local int ziplocal_putValue (pzlib_filefunc_def, filestream, x, nbByte) |
267 | const zlib_filefunc_def* pzlib_filefunc_def; | 267 | const zlib_filefunc_def* pzlib_filefunc_def; |
268 | voidpf filestream; | 268 | voidpf filestream; |
269 | uLong x; | 269 | uLong x; |
270 | int nbByte; | 270 | int nbByte; |
271 | { | 271 | { |
272 | unsigned char buf[4]; | 272 | unsigned char buf[4]; |
273 | int n; | 273 | int n; |
274 | for (n = 0; n < nbByte; n++) | 274 | for (n = 0; n < nbByte; n++) |
275 | { | 275 | { |
276 | buf[n] = (unsigned char)(x & 0xff); | 276 | buf[n] = (unsigned char)(x & 0xff); |
277 | x >>= 8; | 277 | x >>= 8; |
278 | } | 278 | } |
279 | if (x != 0) | 279 | if (x != 0) |
280 | { /* data overflow - hack for ZIP64 (X Roche) */ | 280 | { /* data overflow - hack for ZIP64 (X Roche) */ |
281 | for (n = 0; n < nbByte; n++) | 281 | for (n = 0; n < nbByte; n++) |
282 | { | 282 | { |
283 | buf[n] = 0xff; | 283 | buf[n] = 0xff; |
284 | } | 284 | } |
285 | } | 285 | } |
286 | 286 | ||
287 | if (ZWRITE(*pzlib_filefunc_def,filestream,buf,nbByte)!=(uLong)nbByte) | 287 | if (ZWRITE(*pzlib_filefunc_def,filestream,buf,nbByte)!=(uLong)nbByte) |
288 | return ZIP_ERRNO; | 288 | return ZIP_ERRNO; |
289 | else | 289 | else |
290 | return ZIP_OK; | 290 | return ZIP_OK; |
291 | } | 291 | } |
292 | 292 | ||
293 | local void ziplocal_putValue_inmemory OF((void* dest, uLong x, int nbByte)); | 293 | local void ziplocal_putValue_inmemory OF((void* dest, uLong x, int nbByte)); |
294 | local void ziplocal_putValue_inmemory (dest, x, nbByte) | 294 | local void ziplocal_putValue_inmemory (dest, x, nbByte) |
295 | void* dest; | 295 | void* dest; |
296 | uLong x; | 296 | uLong x; |
297 | int nbByte; | 297 | int nbByte; |
298 | { | 298 | { |
299 | unsigned char* buf=(unsigned char*)dest; | 299 | unsigned char* buf=(unsigned char*)dest; |
300 | int n; | 300 | int n; |
301 | for (n = 0; n < nbByte; n++) { | 301 | for (n = 0; n < nbByte; n++) { |
302 | buf[n] = (unsigned char)(x & 0xff); | 302 | buf[n] = (unsigned char)(x & 0xff); |
303 | x >>= 8; | 303 | x >>= 8; |
304 | } | 304 | } |
305 | 305 | ||
306 | if (x != 0) | 306 | if (x != 0) |
307 | { /* data overflow - hack for ZIP64 */ | 307 | { /* data overflow - hack for ZIP64 */ |
308 | for (n = 0; n < nbByte; n++) | 308 | for (n = 0; n < nbByte; n++) |
309 | { | 309 | { |
310 | buf[n] = 0xff; | 310 | buf[n] = 0xff; |
311 | } | 311 | } |
312 | } | 312 | } |
313 | } | 313 | } |
314 | 314 | ||
315 | /****************************************************************************/ | 315 | /****************************************************************************/ |
316 | 316 | ||
317 | 317 | ||
318 | local uLong ziplocal_TmzDateToDosDate(ptm,dosDate) | 318 | local uLong ziplocal_TmzDateToDosDate(ptm,dosDate) |
319 | const tm_zip* ptm; | 319 | const tm_zip* ptm; |
320 | uLong dosDate; | 320 | uLong dosDate; |
321 | { | 321 | { |
322 | uLong year = (uLong)ptm->tm_year; | 322 | uLong year = (uLong)ptm->tm_year; |
323 | if (year>1980) | 323 | if (year>1980) |
324 | year-=1980; | 324 | year-=1980; |
325 | else if (year>80) | 325 | else if (year>80) |
326 | year-=80; | 326 | year-=80; |
327 | return | 327 | return |
328 | (uLong) (((ptm->tm_mday) + (32 * (ptm->tm_mon+1)) + (512 * year)) << 16) | | 328 | (uLong) (((ptm->tm_mday) + (32 * (ptm->tm_mon+1)) + (512 * year)) << 16) | |
329 | ((ptm->tm_sec/2) + (32* ptm->tm_min) + (2048 * (uLong)ptm->tm_hour)); | 329 | ((ptm->tm_sec/2) + (32* ptm->tm_min) + (2048 * (uLong)ptm->tm_hour)); |
330 | } | 330 | } |
331 | 331 | ||
332 | 332 | ||
333 | /****************************************************************************/ | 333 | /****************************************************************************/ |
334 | 334 | ||
335 | local int ziplocal_getByte OF(( | 335 | local int ziplocal_getByte OF(( |
336 | const zlib_filefunc_def* pzlib_filefunc_def, | 336 | const zlib_filefunc_def* pzlib_filefunc_def, |
337 | voidpf filestream, | 337 | voidpf filestream, |
338 | int *pi)); | 338 | int *pi)); |
339 | 339 | ||
340 | local int ziplocal_getByte(pzlib_filefunc_def,filestream,pi) | 340 | local int ziplocal_getByte(pzlib_filefunc_def,filestream,pi) |
341 | const zlib_filefunc_def* pzlib_filefunc_def; | 341 | const zlib_filefunc_def* pzlib_filefunc_def; |
342 | voidpf filestream; | 342 | voidpf filestream; |
343 | int *pi; | 343 | int *pi; |
344 | { | 344 | { |
345 | unsigned char c; | 345 | unsigned char c; |
346 | int err = (int)ZREAD(*pzlib_filefunc_def,filestream,&c,1); | 346 | int err = (int)ZREAD(*pzlib_filefunc_def,filestream,&c,1); |
347 | if (err==1) | 347 | if (err==1) |
348 | { | 348 | { |
349 | *pi = (int)c; | 349 | *pi = (int)c; |
350 | return ZIP_OK; | 350 | return ZIP_OK; |
351 | } | 351 | } |
352 | else | 352 | else |
353 | { | 353 | { |
354 | if (ZERROR(*pzlib_filefunc_def,filestream)) | 354 | if (ZERROR(*pzlib_filefunc_def,filestream)) |
355 | return ZIP_ERRNO; | 355 | return ZIP_ERRNO; |
356 | else | 356 | else |
357 | return ZIP_EOF; | 357 | return ZIP_EOF; |
358 | } | 358 | } |
359 | } | 359 | } |
360 | 360 | ||
361 | 361 | ||
362 | /* =========================================================================== | 362 | /* =========================================================================== |
363 | Reads a long in LSB order from the given gz_stream. Sets | 363 | Reads a long in LSB order from the given gz_stream. Sets |
364 | */ | 364 | */ |
365 | local int ziplocal_getShort OF(( | 365 | local int ziplocal_getShort OF(( |
366 | const zlib_filefunc_def* pzlib_filefunc_def, | 366 | const zlib_filefunc_def* pzlib_filefunc_def, |
367 | voidpf filestream, | 367 | voidpf filestream, |
368 | uLong *pX)); | 368 | uLong *pX)); |
369 | 369 | ||
370 | local int ziplocal_getShort (pzlib_filefunc_def,filestream,pX) | 370 | local int ziplocal_getShort (pzlib_filefunc_def,filestream,pX) |
371 | const zlib_filefunc_def* pzlib_filefunc_def; | 371 | const zlib_filefunc_def* pzlib_filefunc_def; |
372 | voidpf filestream; | 372 | voidpf filestream; |
373 | uLong *pX; | 373 | uLong *pX; |
374 | { | 374 | { |
375 | uLong x ; | 375 | uLong x ; |
376 | int i; | 376 | int i; |
377 | int err; | 377 | int err; |
378 | 378 | ||
379 | err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); | 379 | err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); |
380 | x = (uLong)i; | 380 | x = (uLong)i; |
381 | 381 | ||
382 | if (err==ZIP_OK) | 382 | if (err==ZIP_OK) |
383 | err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); | 383 | err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); |
384 | x += ((uLong)i)<<8; | 384 | x += ((uLong)i)<<8; |
385 | 385 | ||
386 | if (err==ZIP_OK) | 386 | if (err==ZIP_OK) |
387 | *pX = x; | 387 | *pX = x; |
388 | else | 388 | else |
389 | *pX = 0; | 389 | *pX = 0; |
390 | return err; | 390 | return err; |
391 | } | 391 | } |
392 | 392 | ||
393 | local int ziplocal_getLong OF(( | 393 | local int ziplocal_getLong OF(( |
394 | const zlib_filefunc_def* pzlib_filefunc_def, | 394 | const zlib_filefunc_def* pzlib_filefunc_def, |
395 | voidpf filestream, | 395 | voidpf filestream, |
396 | uLong *pX)); | 396 | uLong *pX)); |
397 | 397 | ||
398 | local int ziplocal_getLong (pzlib_filefunc_def,filestream,pX) | 398 | local int ziplocal_getLong (pzlib_filefunc_def,filestream,pX) |
399 | const zlib_filefunc_def* pzlib_filefunc_def; | 399 | const zlib_filefunc_def* pzlib_filefunc_def; |
400 | voidpf filestream; | 400 | voidpf filestream; |
401 | uLong *pX; | 401 | uLong *pX; |
402 | { | 402 | { |
403 | uLong x ; | 403 | uLong x ; |
404 | int i; | 404 | int i; |
405 | int err; | 405 | int err; |
406 | 406 | ||
407 | err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); | 407 | err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); |
408 | x = (uLong)i; | 408 | x = (uLong)i; |
409 | 409 | ||
410 | if (err==ZIP_OK) | 410 | if (err==ZIP_OK) |
411 | err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); | 411 | err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); |
412 | x += ((uLong)i)<<8; | 412 | x += ((uLong)i)<<8; |
413 | 413 | ||
414 | if (err==ZIP_OK) | 414 | if (err==ZIP_OK) |
415 | err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); | 415 | err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); |
416 | x += ((uLong)i)<<16; | 416 | x += ((uLong)i)<<16; |
417 | 417 | ||
418 | if (err==ZIP_OK) | 418 | if (err==ZIP_OK) |
419 | err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); | 419 | err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); |
420 | x += ((uLong)i)<<24; | 420 | x += ((uLong)i)<<24; |
421 | 421 | ||
422 | if (err==ZIP_OK) | 422 | if (err==ZIP_OK) |
423 | *pX = x; | 423 | *pX = x; |
424 | else | 424 | else |
425 | *pX = 0; | 425 | *pX = 0; |
426 | return err; | 426 | return err; |
427 | } | 427 | } |
428 | 428 | ||
429 | #ifndef BUFREADCOMMENT | 429 | #ifndef BUFREADCOMMENT |
430 | #define BUFREADCOMMENT (0x400) | 430 | #define BUFREADCOMMENT (0x400) |
431 | #endif | 431 | #endif |
432 | /* | 432 | /* |
433 | Locate the Central directory of a zipfile (at the end, just before | 433 | Locate the Central directory of a zipfile (at the end, just before |
434 | the global comment) | 434 | the global comment) |
435 | */ | 435 | */ |
436 | local uLong ziplocal_SearchCentralDir OF(( | 436 | local uLong ziplocal_SearchCentralDir OF(( |
437 | const zlib_filefunc_def* pzlib_filefunc_def, | 437 | const zlib_filefunc_def* pzlib_filefunc_def, |
438 | voidpf filestream)); | 438 | voidpf filestream)); |
439 | 439 | ||
440 | local uLong ziplocal_SearchCentralDir(pzlib_filefunc_def,filestream) | 440 | local uLong ziplocal_SearchCentralDir(pzlib_filefunc_def,filestream) |
441 | const zlib_filefunc_def* pzlib_filefunc_def; | 441 | const zlib_filefunc_def* pzlib_filefunc_def; |
442 | voidpf filestream; | 442 | voidpf filestream; |
443 | { | 443 | { |
444 | unsigned char* buf; | 444 | unsigned char* buf; |
445 | uLong uSizeFile; | 445 | uLong uSizeFile; |
446 | uLong uBackRead; | 446 | uLong uBackRead; |
447 | uLong uMaxBack=0xffff; /* maximum size of global comment */ | 447 | uLong uMaxBack=0xffff; /* maximum size of global comment */ |
448 | uLong uPosFound=0; | 448 | uLong uPosFound=0; |
449 | 449 | ||
450 | if (ZSEEK(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0) | 450 | if (ZSEEK(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0) |
451 | return 0; | 451 | return 0; |
452 | 452 | ||
453 | 453 | ||
454 | uSizeFile = ZTELL(*pzlib_filefunc_def,filestream); | 454 | uSizeFile = ZTELL(*pzlib_filefunc_def,filestream); |
455 | 455 | ||
456 | if (uMaxBack>uSizeFile) | 456 | if (uMaxBack>uSizeFile) |
457 | uMaxBack = uSizeFile; | 457 | uMaxBack = uSizeFile; |
458 | 458 | ||
459 | buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4); | 459 | buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4); |
460 | if (buf==NULL) | 460 | if (buf==NULL) |
461 | return 0; | 461 | return 0; |
462 | 462 | ||
463 | uBackRead = 4; | 463 | uBackRead = 4; |
464 | while (uBackRead<uMaxBack) | 464 | while (uBackRead<uMaxBack) |
465 | { | 465 | { |
466 | uLong uReadSize,uReadPos ; | 466 | uLong uReadSize,uReadPos ; |
467 | int i; | 467 | int i; |
468 | if (uBackRead+BUFREADCOMMENT>uMaxBack) | 468 | if (uBackRead+BUFREADCOMMENT>uMaxBack) |
469 | uBackRead = uMaxBack; | 469 | uBackRead = uMaxBack; |
470 | else | 470 | else |
471 | uBackRead+=BUFREADCOMMENT; | 471 | uBackRead+=BUFREADCOMMENT; |
472 | uReadPos = uSizeFile-uBackRead ; | 472 | uReadPos = uSizeFile-uBackRead ; |
473 | 473 | ||
474 | uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ? | 474 | uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ? |
475 | (BUFREADCOMMENT+4) : (uSizeFile-uReadPos); | 475 | (BUFREADCOMMENT+4) : (uSizeFile-uReadPos); |
476 | if (ZSEEK(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0) | 476 | if (ZSEEK(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0) |
477 | break; | 477 | break; |
478 | 478 | ||
479 | if (ZREAD(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize) | 479 | if (ZREAD(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize) |
480 | break; | 480 | break; |
481 | 481 | ||
482 | for (i=(int)uReadSize-3; (i--)>0;) | 482 | for (i=(int)uReadSize-3; (i--)>0;) |
483 | if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && | 483 | if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && |
484 | ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06)) | 484 | ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06)) |
485 | { | 485 | { |
486 | uPosFound = uReadPos+i; | 486 | uPosFound = uReadPos+i; |
487 | break; | 487 | break; |
488 | } | 488 | } |
489 | 489 | ||
490 | if (uPosFound!=0) | 490 | if (uPosFound!=0) |
491 | break; | 491 | break; |
492 | } | 492 | } |
493 | TRYFREE(buf); | 493 | TRYFREE(buf); |
494 | return uPosFound; | 494 | return uPosFound; |
495 | } | 495 | } |
496 | #endif /* !NO_ADDFILEINEXISTINGZIP*/ | 496 | #endif /* !NO_ADDFILEINEXISTINGZIP*/ |
497 | 497 | ||
498 | /************************************************************/ | 498 | /************************************************************/ |
499 | extern zipFile ZEXPORT zipOpen2 (pathname, append, globalcomment, pzlib_filefunc_def) | 499 | extern zipFile ZEXPORT zipOpen2 (pathname, append, globalcomment, pzlib_filefunc_def) |
500 | const char *pathname; | 500 | const char *pathname; |
501 | int append; | 501 | int append; |
502 | zipcharpc* globalcomment; | 502 | zipcharpc* globalcomment; |
503 | zlib_filefunc_def* pzlib_filefunc_def; | 503 | zlib_filefunc_def* pzlib_filefunc_def; |
504 | { | 504 | { |
505 | zip_internal ziinit; | 505 | zip_internal ziinit; |
506 | zip_internal* zi; | 506 | zip_internal* zi; |
507 | int err=ZIP_OK; | 507 | int err=ZIP_OK; |
508 | 508 | ||
509 | 509 | ||
510 | if (pzlib_filefunc_def==NULL) | 510 | if (pzlib_filefunc_def==NULL) |
511 | fill_fopen_filefunc(&ziinit.z_filefunc); | 511 | fill_fopen_filefunc(&ziinit.z_filefunc); |
512 | else | 512 | else |
513 | ziinit.z_filefunc = *pzlib_filefunc_def; | 513 | ziinit.z_filefunc = *pzlib_filefunc_def; |
514 | 514 | ||
515 | ziinit.filestream = (*(ziinit.z_filefunc.zopen_file)) | 515 | ziinit.filestream = (*(ziinit.z_filefunc.zopen_file)) |
516 | (ziinit.z_filefunc.opaque, | 516 | (ziinit.z_filefunc.opaque, |
517 | pathname, | 517 | pathname, |
518 | (append == APPEND_STATUS_CREATE) ? | 518 | (append == APPEND_STATUS_CREATE) ? |
519 | (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE) : | 519 | (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE) : |
520 | (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING)); | 520 | (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING)); |
521 | 521 | ||
522 | if (ziinit.filestream == NULL) | 522 | if (ziinit.filestream == NULL) |
523 | return NULL; | 523 | return NULL; |
524 | ziinit.begin_pos = ZTELL(ziinit.z_filefunc,ziinit.filestream); | 524 | ziinit.begin_pos = ZTELL(ziinit.z_filefunc,ziinit.filestream); |
525 | ziinit.in_opened_file_inzip = 0; | 525 | ziinit.in_opened_file_inzip = 0; |
526 | ziinit.ci.stream_initialised = 0; | 526 | ziinit.ci.stream_initialised = 0; |
527 | ziinit.number_entry = 0; | 527 | ziinit.number_entry = 0; |
528 | ziinit.add_position_when_writting_offset = 0; | 528 | ziinit.add_position_when_writting_offset = 0; |
529 | init_linkedlist(&(ziinit.central_dir)); | 529 | init_linkedlist(&(ziinit.central_dir)); |
530 | 530 | ||
531 | 531 | ||
532 | zi = (zip_internal*)ALLOC(sizeof(zip_internal)); | 532 | zi = (zip_internal*)ALLOC(sizeof(zip_internal)); |
533 | if (zi==NULL) | 533 | if (zi==NULL) |
534 | { | 534 | { |
535 | ZCLOSE(ziinit.z_filefunc,ziinit.filestream); | 535 | ZCLOSE(ziinit.z_filefunc,ziinit.filestream); |
536 | return NULL; | 536 | return NULL; |
537 | } | 537 | } |
538 | 538 | ||
539 | /* now we add file in a zipfile */ | 539 | /* now we add file in a zipfile */ |
540 | # ifndef NO_ADDFILEINEXISTINGZIP | 540 | # ifndef NO_ADDFILEINEXISTINGZIP |
541 | ziinit.globalcomment = NULL; | 541 | ziinit.globalcomment = NULL; |
542 | if (append == APPEND_STATUS_ADDINZIP) | 542 | if (append == APPEND_STATUS_ADDINZIP) |
543 | { | 543 | { |
544 | uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/ | 544 | uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/ |
545 | 545 | ||
546 | uLong size_central_dir; /* size of the central directory */ | 546 | uLong size_central_dir; /* size of the central directory */ |
547 | uLong offset_central_dir; /* offset of start of central directory */ | 547 | uLong offset_central_dir; /* offset of start of central directory */ |
548 | uLong central_pos,uL; | 548 | uLong central_pos,uL; |
549 | 549 | ||
550 | uLong number_disk; /* number of the current dist, used for | 550 | uLong number_disk; /* number of the current dist, used for |
551 | spaning ZIP, unsupported, always 0*/ | 551 | spaning ZIP, unsupported, always 0*/ |
552 | uLong number_disk_with_CD; /* number the the disk with central dir, used | 552 | uLong number_disk_with_CD; /* number the the disk with central dir, used |
553 | for spaning ZIP, unsupported, always 0*/ | 553 | for spaning ZIP, unsupported, always 0*/ |
554 | uLong number_entry; | 554 | uLong number_entry; |
555 | uLong number_entry_CD; /* total number of entries in | 555 | uLong number_entry_CD; /* total number of entries in |
556 | the central dir | 556 | the central dir |
557 | (same than number_entry on nospan) */ | 557 | (same than number_entry on nospan) */ |
558 | uLong size_comment; | 558 | uLong size_comment; |
559 | 559 | ||
560 | central_pos = ziplocal_SearchCentralDir(&ziinit.z_filefunc,ziinit.filestream); | 560 | central_pos = ziplocal_SearchCentralDir(&ziinit.z_filefunc,ziinit.filestream); |
561 | if (central_pos==0) | 561 | if (central_pos==0) |
562 | err=ZIP_ERRNO; | 562 | err=ZIP_ERRNO; |
563 | 563 | ||
564 | if (ZSEEK(ziinit.z_filefunc, ziinit.filestream, | 564 | if (ZSEEK(ziinit.z_filefunc, ziinit.filestream, |
565 | central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0) | 565 | central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0) |
566 | err=ZIP_ERRNO; | 566 | err=ZIP_ERRNO; |
567 | 567 | ||
568 | /* the signature, already checked */ | 568 | /* the signature, already checked */ |
569 | if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&uL)!=ZIP_OK) | 569 | if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&uL)!=ZIP_OK) |
570 | err=ZIP_ERRNO; | 570 | err=ZIP_ERRNO; |
571 | 571 | ||
572 | /* number of this disk */ | 572 | /* number of this disk */ |
573 | if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_disk)!=ZIP_OK) | 573 | if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_disk)!=ZIP_OK) |
574 | err=ZIP_ERRNO; | 574 | err=ZIP_ERRNO; |
575 | 575 | ||
576 | /* number of the disk with the start of the central directory */ | 576 | /* number of the disk with the start of the central directory */ |
577 | if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_disk_with_CD)!=ZIP_OK) | 577 | if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_disk_with_CD)!=ZIP_OK) |
578 | err=ZIP_ERRNO; | 578 | err=ZIP_ERRNO; |
579 | 579 | ||
580 | /* total number of entries in the central dir on this disk */ | 580 | /* total number of entries in the central dir on this disk */ |
581 | if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_entry)!=ZIP_OK) | 581 | if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_entry)!=ZIP_OK) |
582 | err=ZIP_ERRNO; | 582 | err=ZIP_ERRNO; |
583 | 583 | ||
584 | /* total number of entries in the central dir */ | 584 | /* total number of entries in the central dir */ |
585 | if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_entry_CD)!=ZIP_OK) | 585 | if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_entry_CD)!=ZIP_OK) |
586 | err=ZIP_ERRNO; | 586 | err=ZIP_ERRNO; |
587 | 587 | ||
588 | if ((number_entry_CD!=number_entry) || | 588 | if ((number_entry_CD!=number_entry) || |
589 | (number_disk_with_CD!=0) || | 589 | (number_disk_with_CD!=0) || |
590 | (number_disk!=0)) | 590 | (number_disk!=0)) |
591 | err=ZIP_BADZIPFILE; | 591 | err=ZIP_BADZIPFILE; |
592 | 592 | ||
593 | /* size of the central directory */ | 593 | /* size of the central directory */ |
594 | if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&size_central_dir)!=ZIP_OK) | 594 | if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&size_central_dir)!=ZIP_OK) |
595 | err=ZIP_ERRNO; | 595 | err=ZIP_ERRNO; |
596 | 596 | ||
597 | /* offset of start of central directory with respect to the | 597 | /* offset of start of central directory with respect to the |
598 | starting disk number */ | 598 | starting disk number */ |
599 | if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&offset_central_dir)!=ZIP_OK) | 599 | if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&offset_central_dir)!=ZIP_OK) |
600 | err=ZIP_ERRNO; | 600 | err=ZIP_ERRNO; |
601 | 601 | ||
602 | /* zipfile global comment length */ | 602 | /* zipfile global comment length */ |
603 | if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&size_comment)!=ZIP_OK) | 603 | if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&size_comment)!=ZIP_OK) |
604 | err=ZIP_ERRNO; | 604 | err=ZIP_ERRNO; |
605 | 605 | ||
606 | if ((central_pos<offset_central_dir+size_central_dir) && | 606 | if ((central_pos<offset_central_dir+size_central_dir) && |
607 | (err==ZIP_OK)) | 607 | (err==ZIP_OK)) |
608 | err=ZIP_BADZIPFILE; | 608 | err=ZIP_BADZIPFILE; |
609 | 609 | ||
610 | if (err!=ZIP_OK) | 610 | if (err!=ZIP_OK) |
611 | { | 611 | { |
612 | ZCLOSE(ziinit.z_filefunc, ziinit.filestream); | 612 | ZCLOSE(ziinit.z_filefunc, ziinit.filestream); |
613 | return NULL; | 613 | return NULL; |
614 | } | 614 | } |
615 | 615 | ||
616 | if (size_comment>0) | 616 | if (size_comment>0) |
617 | { | 617 | { |
618 | ziinit.globalcomment = ALLOC(size_comment+1); | 618 | ziinit.globalcomment = ALLOC(size_comment+1); |
619 | if (ziinit.globalcomment) | 619 | if (ziinit.globalcomment) |
620 | { | 620 | { |
621 | size_comment = ZREAD(ziinit.z_filefunc, ziinit.filestream,ziinit.globalcomment,size_comment); | 621 | size_comment = ZREAD(ziinit.z_filefunc, ziinit.filestream,ziinit.globalcomment,size_comment); |
622 | ziinit.globalcomment[size_comment]=0; | 622 | ziinit.globalcomment[size_comment]=0; |
623 | } | 623 | } |
624 | } | 624 | } |
625 | 625 | ||
626 | byte_before_the_zipfile = central_pos - | 626 | byte_before_the_zipfile = central_pos - |
627 | (offset_central_dir+size_central_dir); | 627 | (offset_central_dir+size_central_dir); |
628 | ziinit.add_position_when_writting_offset = byte_before_the_zipfile; | 628 | ziinit.add_position_when_writting_offset = byte_before_the_zipfile; |
629 | 629 | ||
630 | { | 630 | { |
631 | uLong size_central_dir_to_read = size_central_dir; | 631 | uLong size_central_dir_to_read = size_central_dir; |
632 | size_t buf_size = SIZEDATA_INDATABLOCK; | 632 | size_t buf_size = SIZEDATA_INDATABLOCK; |
633 | void* buf_read = (void*)ALLOC(buf_size); | 633 | void* buf_read = (void*)ALLOC(buf_size); |
634 | if (ZSEEK(ziinit.z_filefunc, ziinit.filestream, | 634 | if (ZSEEK(ziinit.z_filefunc, ziinit.filestream, |
635 | offset_central_dir + byte_before_the_zipfile, | 635 | offset_central_dir + byte_before_the_zipfile, |
636 | ZLIB_FILEFUNC_SEEK_SET) != 0) | 636 | ZLIB_FILEFUNC_SEEK_SET) != 0) |
637 | err=ZIP_ERRNO; | 637 | err=ZIP_ERRNO; |
638 | 638 | ||
639 | while ((size_central_dir_to_read>0) && (err==ZIP_OK)) | 639 | while ((size_central_dir_to_read>0) && (err==ZIP_OK)) |
640 | { | 640 | { |
641 | uLong read_this = SIZEDATA_INDATABLOCK; | 641 | uLong read_this = SIZEDATA_INDATABLOCK; |
642 | if (read_this > size_central_dir_to_read) | 642 | if (read_this > size_central_dir_to_read) |
643 | read_this = size_central_dir_to_read; | 643 | read_this = size_central_dir_to_read; |
644 | if (ZREAD(ziinit.z_filefunc, ziinit.filestream,buf_read,read_this) != read_this) | 644 | if (ZREAD(ziinit.z_filefunc, ziinit.filestream,buf_read,read_this) != read_this) |
645 | err=ZIP_ERRNO; | 645 | err=ZIP_ERRNO; |
646 | 646 | ||
647 | if (err==ZIP_OK) | 647 | if (err==ZIP_OK) |
648 | err = add_data_in_datablock(&ziinit.central_dir,buf_read, | 648 | err = add_data_in_datablock(&ziinit.central_dir,buf_read, |
649 | (uLong)read_this); | 649 | (uLong)read_this); |
650 | size_central_dir_to_read-=read_this; | 650 | size_central_dir_to_read-=read_this; |
651 | } | 651 | } |
652 | TRYFREE(buf_read); | 652 | TRYFREE(buf_read); |
653 | } | 653 | } |
654 | ziinit.begin_pos = byte_before_the_zipfile; | 654 | ziinit.begin_pos = byte_before_the_zipfile; |
655 | ziinit.number_entry = number_entry_CD; | 655 | ziinit.number_entry = number_entry_CD; |
656 | 656 | ||
657 | if (ZSEEK(ziinit.z_filefunc, ziinit.filestream, | 657 | if (ZSEEK(ziinit.z_filefunc, ziinit.filestream, |
658 | offset_central_dir+byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0) | 658 | offset_central_dir+byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0) |
659 | err=ZIP_ERRNO; | 659 | err=ZIP_ERRNO; |
660 | } | 660 | } |
661 | 661 | ||
662 | if (globalcomment) | 662 | if (globalcomment) |
663 | { | 663 | { |
664 | *globalcomment = ziinit.globalcomment; | 664 | *globalcomment = ziinit.globalcomment; |
665 | } | 665 | } |
666 | # endif /* !NO_ADDFILEINEXISTINGZIP*/ | 666 | # endif /* !NO_ADDFILEINEXISTINGZIP*/ |
667 | 667 | ||
668 | if (err != ZIP_OK) | 668 | if (err != ZIP_OK) |
669 | { | 669 | { |
670 | # ifndef NO_ADDFILEINEXISTINGZIP | 670 | # ifndef NO_ADDFILEINEXISTINGZIP |
671 | TRYFREE(ziinit.globalcomment); | 671 | TRYFREE(ziinit.globalcomment); |
672 | # endif /* !NO_ADDFILEINEXISTINGZIP*/ | 672 | # endif /* !NO_ADDFILEINEXISTINGZIP*/ |
673 | TRYFREE(zi); | 673 | TRYFREE(zi); |
674 | return NULL; | 674 | return NULL; |
675 | } | 675 | } |
676 | else | 676 | else |
677 | { | 677 | { |
678 | *zi = ziinit; | 678 | *zi = ziinit; |
679 | return (zipFile)zi; | 679 | return (zipFile)zi; |
680 | } | 680 | } |
681 | } | 681 | } |
682 | 682 | ||
683 | extern zipFile ZEXPORT zipOpen (pathname, append) | 683 | extern zipFile ZEXPORT zipOpen (pathname, append) |
684 | const char *pathname; | 684 | const char *pathname; |
685 | int append; | 685 | int append; |
686 | { | 686 | { |
687 | return zipOpen2(pathname,append,NULL,NULL); | 687 | return zipOpen2(pathname,append,NULL,NULL); |
688 | } | 688 | } |
689 | 689 | ||
690 | extern int ZEXPORT zipOpenNewFileInZip3 (file, filename, zipfi, | 690 | extern int ZEXPORT zipOpenNewFileInZip3 (file, filename, zipfi, |
691 | extrafield_local, size_extrafield_local, | 691 | extrafield_local, size_extrafield_local, |
692 | extrafield_global, size_extrafield_global, | 692 | extrafield_global, size_extrafield_global, |
693 | comment, method, level, raw, | 693 | comment, method, level, raw, |
694 | windowBits, memLevel, strategy, | 694 | windowBits, memLevel, strategy, |
695 | password, crcForCrypting) | 695 | password, crcForCrypting) |
696 | zipFile file; | 696 | zipFile file; |
697 | const char* filename; | 697 | const char* filename; |
698 | const zip_fileinfo* zipfi; | 698 | const zip_fileinfo* zipfi; |
699 | const void* extrafield_local; | 699 | const void* extrafield_local; |
700 | uInt size_extrafield_local; | 700 | uInt size_extrafield_local; |
701 | const void* extrafield_global; | 701 | const void* extrafield_global; |
702 | uInt size_extrafield_global; | 702 | uInt size_extrafield_global; |
703 | const char* comment; | 703 | const char* comment; |
704 | int method; | 704 | int method; |
705 | int level; | 705 | int level; |
706 | int raw; | 706 | int raw; |
707 | int windowBits; | 707 | int windowBits; |
708 | int memLevel; | 708 | int memLevel; |
709 | int strategy; | 709 | int strategy; |
710 | const char* password; | 710 | const char* password; |
711 | uLong crcForCrypting; | 711 | uLong crcForCrypting; |
712 | { | 712 | { |
713 | zip_internal* zi; | 713 | zip_internal* zi; |
714 | uInt size_filename; | 714 | uInt size_filename; |
715 | uInt size_comment; | 715 | uInt size_comment; |
716 | uInt i; | 716 | uInt i; |
717 | int err = ZIP_OK; | 717 | int err = ZIP_OK; |
718 | 718 | ||
719 | # ifdef NOCRYPT | 719 | # ifdef NOCRYPT |
720 | if (password != NULL) | 720 | if (password != NULL) |
721 | return ZIP_PARAMERROR; | 721 | return ZIP_PARAMERROR; |
722 | # endif | 722 | # endif |
723 | 723 | ||
724 | if (file == NULL) | 724 | if (file == NULL) |
725 | return ZIP_PARAMERROR; | 725 | return ZIP_PARAMERROR; |
726 | if ((method!=0) && (method!=Z_DEFLATED)) | 726 | if ((method!=0) && (method!=Z_DEFLATED)) |
727 | return ZIP_PARAMERROR; | 727 | return ZIP_PARAMERROR; |
728 | 728 | ||
729 | zi = (zip_internal*)file; | 729 | zi = (zip_internal*)file; |
730 | 730 | ||
731 | if (zi->in_opened_file_inzip == 1) | 731 | if (zi->in_opened_file_inzip == 1) |
732 | { | 732 | { |
733 | err = zipCloseFileInZip (file); | 733 | err = zipCloseFileInZip (file); |
734 | if (err != ZIP_OK) | 734 | if (err != ZIP_OK) |
735 | return err; | 735 | return err; |
736 | } | 736 | } |
737 | 737 | ||
738 | 738 | ||
739 | if (filename==NULL) | 739 | if (filename==NULL) |
740 | filename="-"; | 740 | filename="-"; |
741 | 741 | ||
742 | if (comment==NULL) | 742 | if (comment==NULL) |
743 | size_comment = 0; | 743 | size_comment = 0; |
744 | else | 744 | else |
745 | size_comment = (uInt)strlen(comment); | 745 | size_comment = (uInt)strlen(comment); |
746 | 746 | ||
747 | size_filename = (uInt)strlen(filename); | 747 | size_filename = (uInt)strlen(filename); |
748 | 748 | ||
749 | if (zipfi == NULL) | 749 | if (zipfi == NULL) |
750 | zi->ci.dosDate = 0; | 750 | zi->ci.dosDate = 0; |
751 | else | 751 | else |
752 | { | 752 | { |
753 | if (zipfi->dosDate != 0) | 753 | if (zipfi->dosDate != 0) |
754 | zi->ci.dosDate = zipfi->dosDate; | 754 | zi->ci.dosDate = zipfi->dosDate; |
755 | else zi->ci.dosDate = ziplocal_TmzDateToDosDate(&zipfi->tmz_date,zipfi->dosDate); | 755 | else zi->ci.dosDate = ziplocal_TmzDateToDosDate(&zipfi->tmz_date,zipfi->dosDate); |
756 | } | 756 | } |
757 | 757 | ||
758 | zi->ci.flag = 0; | 758 | zi->ci.flag = 0; |
759 | if ((level==8) || (level==9)) | 759 | if ((level==8) || (level==9)) |
760 | zi->ci.flag |= 2; | 760 | zi->ci.flag |= 2; |
761 | if ((level==2)) | 761 | if ((level==2)) |
762 | zi->ci.flag |= 4; | 762 | zi->ci.flag |= 4; |
763 | if ((level==1)) | 763 | if ((level==1)) |
764 | zi->ci.flag |= 6; | 764 | zi->ci.flag |= 6; |
765 | if (password != NULL) | 765 | if (password != NULL) |
766 | zi->ci.flag |= 1; | 766 | zi->ci.flag |= 1; |
767 | 767 | ||
768 | zi->ci.crc32 = 0; | 768 | zi->ci.crc32 = 0; |
769 | zi->ci.method = method; | 769 | zi->ci.method = method; |
770 | zi->ci.encrypt = 0; | 770 | zi->ci.encrypt = 0; |
771 | zi->ci.stream_initialised = 0; | 771 | zi->ci.stream_initialised = 0; |
772 | zi->ci.pos_in_buffered_data = 0; | 772 | zi->ci.pos_in_buffered_data = 0; |
773 | zi->ci.raw = raw; | 773 | zi->ci.raw = raw; |
774 | zi->ci.pos_local_header = ZTELL(zi->z_filefunc,zi->filestream) ; | 774 | zi->ci.pos_local_header = ZTELL(zi->z_filefunc,zi->filestream) ; |
775 | zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename + | 775 | zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename + |
776 | size_extrafield_global + size_comment; | 776 | size_extrafield_global + size_comment; |
777 | zi->ci.central_header = (char*)ALLOC((uInt)zi->ci.size_centralheader); | 777 | zi->ci.central_header = (char*)ALLOC((uInt)zi->ci.size_centralheader); |
778 | 778 | ||
779 | ziplocal_putValue_inmemory(zi->ci.central_header,(uLong)CENTRALHEADERMAGIC,4); | 779 | ziplocal_putValue_inmemory(zi->ci.central_header,(uLong)CENTRALHEADERMAGIC,4); |
780 | /* version info */ | 780 | /* version info */ |
781 | ziplocal_putValue_inmemory(zi->ci.central_header+4,(uLong)VERSIONMADEBY,2); | 781 | ziplocal_putValue_inmemory(zi->ci.central_header+4,(uLong)VERSIONMADEBY,2); |
782 | ziplocal_putValue_inmemory(zi->ci.central_header+6,(uLong)20,2); | 782 | ziplocal_putValue_inmemory(zi->ci.central_header+6,(uLong)20,2); |
783 | ziplocal_putValue_inmemory(zi->ci.central_header+8,(uLong)zi->ci.flag,2); | 783 | ziplocal_putValue_inmemory(zi->ci.central_header+8,(uLong)zi->ci.flag,2); |
784 | ziplocal_putValue_inmemory(zi->ci.central_header+10,(uLong)zi->ci.method,2); | 784 | ziplocal_putValue_inmemory(zi->ci.central_header+10,(uLong)zi->ci.method,2); |
785 | ziplocal_putValue_inmemory(zi->ci.central_header+12,(uLong)zi->ci.dosDate,4); | 785 | ziplocal_putValue_inmemory(zi->ci.central_header+12,(uLong)zi->ci.dosDate,4); |
786 | ziplocal_putValue_inmemory(zi->ci.central_header+16,(uLong)0,4); /*crc*/ | 786 | ziplocal_putValue_inmemory(zi->ci.central_header+16,(uLong)0,4); /*crc*/ |
787 | ziplocal_putValue_inmemory(zi->ci.central_header+20,(uLong)0,4); /*compr size*/ | 787 | ziplocal_putValue_inmemory(zi->ci.central_header+20,(uLong)0,4); /*compr size*/ |
788 | ziplocal_putValue_inmemory(zi->ci.central_header+24,(uLong)0,4); /*uncompr size*/ | 788 | ziplocal_putValue_inmemory(zi->ci.central_header+24,(uLong)0,4); /*uncompr size*/ |
789 | ziplocal_putValue_inmemory(zi->ci.central_header+28,(uLong)size_filename,2); | 789 | ziplocal_putValue_inmemory(zi->ci.central_header+28,(uLong)size_filename,2); |
790 | ziplocal_putValue_inmemory(zi->ci.central_header+30,(uLong)size_extrafield_global,2); | 790 | ziplocal_putValue_inmemory(zi->ci.central_header+30,(uLong)size_extrafield_global,2); |
791 | ziplocal_putValue_inmemory(zi->ci.central_header+32,(uLong)size_comment,2); | 791 | ziplocal_putValue_inmemory(zi->ci.central_header+32,(uLong)size_comment,2); |
792 | ziplocal_putValue_inmemory(zi->ci.central_header+34,(uLong)0,2); /*disk nm start*/ | 792 | ziplocal_putValue_inmemory(zi->ci.central_header+34,(uLong)0,2); /*disk nm start*/ |
793 | 793 | ||
794 | if (zipfi==NULL) | 794 | if (zipfi==NULL) |
795 | ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)0,2); | 795 | ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)0,2); |
796 | else | 796 | else |
797 | ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)zipfi->internal_fa,2); | 797 | ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)zipfi->internal_fa,2); |
798 | 798 | ||
799 | if (zipfi==NULL) | 799 | if (zipfi==NULL) |
800 | ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)0,4); | 800 | ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)0,4); |
801 | else | 801 | else |
802 | ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)zipfi->external_fa,4); | 802 | ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)zipfi->external_fa,4); |
803 | 803 | ||
804 | ziplocal_putValue_inmemory(zi->ci.central_header+42,(uLong)zi->ci.pos_local_header- zi->add_position_when_writting_offset,4); | 804 | ziplocal_putValue_inmemory(zi->ci.central_header+42,(uLong)zi->ci.pos_local_header- zi->add_position_when_writting_offset,4); |
805 | 805 | ||
806 | for (i=0;i<size_filename;i++) | 806 | for (i=0;i<size_filename;i++) |
807 | *(zi->ci.central_header+SIZECENTRALHEADER+i) = *(filename+i); | 807 | *(zi->ci.central_header+SIZECENTRALHEADER+i) = *(filename+i); |
808 | 808 | ||
809 | for (i=0;i<size_extrafield_global;i++) | 809 | for (i=0;i<size_extrafield_global;i++) |
810 | *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+i) = | 810 | *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+i) = |
811 | *(((const char*)extrafield_global)+i); | 811 | *(((const char*)extrafield_global)+i); |
812 | 812 | ||
813 | for (i=0;i<size_comment;i++) | 813 | for (i=0;i<size_comment;i++) |
814 | *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+ | 814 | *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+ |
815 | size_extrafield_global+i) = *(comment+i); | 815 | size_extrafield_global+i) = *(comment+i); |
816 | if (zi->ci.central_header == NULL) | 816 | if (zi->ci.central_header == NULL) |
817 | return ZIP_INTERNALERROR; | 817 | return ZIP_INTERNALERROR; |
818 | 818 | ||
819 | /* write the local header */ | 819 | /* write the local header */ |
820 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)LOCALHEADERMAGIC,4); | 820 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)LOCALHEADERMAGIC,4); |
821 | 821 | ||
822 | if (err==ZIP_OK) | 822 | if (err==ZIP_OK) |
823 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)20,2);/* version needed to extract */ | 823 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)20,2);/* version needed to extract */ |
824 | if (err==ZIP_OK) | 824 | if (err==ZIP_OK) |
825 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.flag,2); | 825 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.flag,2); |
826 | 826 | ||
827 | if (err==ZIP_OK) | 827 | if (err==ZIP_OK) |
828 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.method,2); | 828 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.method,2); |
829 | 829 | ||
830 | if (err==ZIP_OK) | 830 | if (err==ZIP_OK) |
831 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.dosDate,4); | 831 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.dosDate,4); |
832 | 832 | ||
833 | if (err==ZIP_OK) | 833 | if (err==ZIP_OK) |
834 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* crc 32, unknown */ | 834 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* crc 32, unknown */ |
835 | if (err==ZIP_OK) | 835 | if (err==ZIP_OK) |
836 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* compressed size, unknown */ | 836 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* compressed size, unknown */ |
837 | if (err==ZIP_OK) | 837 | if (err==ZIP_OK) |
838 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* uncompressed size, unknown */ | 838 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* uncompressed size, unknown */ |
839 | 839 | ||
840 | if (err==ZIP_OK) | 840 | if (err==ZIP_OK) |
841 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_filename,2); | 841 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_filename,2); |
842 | 842 | ||
843 | if (err==ZIP_OK) | 843 | if (err==ZIP_OK) |
844 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_extrafield_local,2); | 844 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_extrafield_local,2); |
845 | 845 | ||
846 | if ((err==ZIP_OK) && (size_filename>0)) | 846 | if ((err==ZIP_OK) && (size_filename>0)) |
847 | if (ZWRITE(zi->z_filefunc,zi->filestream,filename,size_filename)!=size_filename) | 847 | if (ZWRITE(zi->z_filefunc,zi->filestream,filename,size_filename)!=size_filename) |
848 | err = ZIP_ERRNO; | 848 | err = ZIP_ERRNO; |
849 | 849 | ||
850 | if ((err==ZIP_OK) && (size_extrafield_local>0)) | 850 | if ((err==ZIP_OK) && (size_extrafield_local>0)) |
851 | if (ZWRITE(zi->z_filefunc,zi->filestream,extrafield_local,size_extrafield_local) | 851 | if (ZWRITE(zi->z_filefunc,zi->filestream,extrafield_local,size_extrafield_local) |
852 | !=size_extrafield_local) | 852 | !=size_extrafield_local) |
853 | err = ZIP_ERRNO; | 853 | err = ZIP_ERRNO; |
854 | 854 | ||
855 | zi->ci.stream.avail_in = (uInt)0; | 855 | zi->ci.stream.avail_in = (uInt)0; |
856 | zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; | 856 | zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; |
857 | zi->ci.stream.next_out = zi->ci.buffered_data; | 857 | zi->ci.stream.next_out = zi->ci.buffered_data; |
858 | zi->ci.stream.total_in = 0; | 858 | zi->ci.stream.total_in = 0; |
859 | zi->ci.stream.total_out = 0; | 859 | zi->ci.stream.total_out = 0; |
860 | 860 | ||
861 | if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) | 861 | if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) |
862 | { | 862 | { |
863 | zi->ci.stream.zalloc = (alloc_func)0; | 863 | zi->ci.stream.zalloc = (alloc_func)0; |
864 | zi->ci.stream.zfree = (free_func)0; | 864 | zi->ci.stream.zfree = (free_func)0; |
865 | zi->ci.stream.opaque = (voidpf)0; | 865 | zi->ci.stream.opaque = (voidpf)0; |
866 | 866 | ||
867 | if (windowBits>0) | 867 | if (windowBits>0) |
868 | windowBits = -windowBits; | 868 | windowBits = -windowBits; |
869 | 869 | ||
870 | err = deflateInit2(&zi->ci.stream, level, | 870 | err = deflateInit2(&zi->ci.stream, level, |
871 | Z_DEFLATED, windowBits, memLevel, strategy); | 871 | Z_DEFLATED, windowBits, memLevel, strategy); |
872 | 872 | ||
873 | if (err==Z_OK) | 873 | if (err==Z_OK) |
874 | zi->ci.stream_initialised = 1; | 874 | zi->ci.stream_initialised = 1; |
875 | } | 875 | } |
876 | # ifndef NOCRYPT | 876 | # ifndef NOCRYPT |
877 | zi->ci.crypt_header_size = 0; | 877 | zi->ci.crypt_header_size = 0; |
878 | if ((err==Z_OK) && (password != NULL)) | 878 | if ((err==Z_OK) && (password != NULL)) |
879 | { | 879 | { |
880 | unsigned char bufHead[RAND_HEAD_LEN]; | 880 | unsigned char bufHead[RAND_HEAD_LEN]; |
881 | unsigned int sizeHead; | 881 | unsigned int sizeHead; |
882 | zi->ci.encrypt = 1; | 882 | zi->ci.encrypt = 1; |
883 | zi->ci.pcrc_32_tab = get_crc_table(); | 883 | zi->ci.pcrc_32_tab = get_crc_table(); |
884 | /*init_keys(password,zi->ci.keys,zi->ci.pcrc_32_tab);*/ | 884 | /*init_keys(password,zi->ci.keys,zi->ci.pcrc_32_tab);*/ |
885 | 885 | ||
886 | sizeHead=crypthead(password,bufHead,RAND_HEAD_LEN,zi->ci.keys,zi->ci.pcrc_32_tab,crcForCrypting); | 886 | sizeHead=crypthead(password,bufHead,RAND_HEAD_LEN,zi->ci.keys,zi->ci.pcrc_32_tab,crcForCrypting); |
887 | zi->ci.crypt_header_size = sizeHead; | 887 | zi->ci.crypt_header_size = sizeHead; |
888 | 888 | ||
889 | if (ZWRITE(zi->z_filefunc,zi->filestream,bufHead,sizeHead) != sizeHead) | 889 | if (ZWRITE(zi->z_filefunc,zi->filestream,bufHead,sizeHead) != sizeHead) |
890 | err = ZIP_ERRNO; | 890 | err = ZIP_ERRNO; |
891 | } | 891 | } |
892 | # endif | 892 | # endif |
893 | 893 | ||
894 | if (err==Z_OK) | 894 | if (err==Z_OK) |
895 | zi->in_opened_file_inzip = 1; | 895 | zi->in_opened_file_inzip = 1; |
896 | return err; | 896 | return err; |
897 | } | 897 | } |
898 | 898 | ||
899 | extern int ZEXPORT zipOpenNewFileInZip2(file, filename, zipfi, | 899 | extern int ZEXPORT zipOpenNewFileInZip2(file, filename, zipfi, |
900 | extrafield_local, size_extrafield_local, | 900 | extrafield_local, size_extrafield_local, |
901 | extrafield_global, size_extrafield_global, | 901 | extrafield_global, size_extrafield_global, |
902 | comment, method, level, raw) | 902 | comment, method, level, raw) |
903 | zipFile file; | 903 | zipFile file; |
904 | const char* filename; | 904 | const char* filename; |
905 | const zip_fileinfo* zipfi; | 905 | const zip_fileinfo* zipfi; |
906 | const void* extrafield_local; | 906 | const void* extrafield_local; |
907 | uInt size_extrafield_local; | 907 | uInt size_extrafield_local; |
908 | const void* extrafield_global; | 908 | const void* extrafield_global; |
909 | uInt size_extrafield_global; | 909 | uInt size_extrafield_global; |
910 | const char* comment; | 910 | const char* comment; |
911 | int method; | 911 | int method; |
912 | int level; | 912 | int level; |
913 | int raw; | 913 | int raw; |
914 | { | 914 | { |
915 | return zipOpenNewFileInZip3 (file, filename, zipfi, | 915 | return zipOpenNewFileInZip3 (file, filename, zipfi, |
916 | extrafield_local, size_extrafield_local, | 916 | extrafield_local, size_extrafield_local, |
917 | extrafield_global, size_extrafield_global, | 917 | extrafield_global, size_extrafield_global, |
918 | comment, method, level, raw, | 918 | comment, method, level, raw, |
919 | -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, | 919 | -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, |
920 | NULL, 0); | 920 | NULL, 0); |
921 | } | 921 | } |
922 | 922 | ||
923 | extern int ZEXPORT zipOpenNewFileInZip (file, filename, zipfi, | 923 | extern int ZEXPORT zipOpenNewFileInZip (file, filename, zipfi, |
924 | extrafield_local, size_extrafield_local, | 924 | extrafield_local, size_extrafield_local, |
925 | extrafield_global, size_extrafield_global, | 925 | extrafield_global, size_extrafield_global, |
926 | comment, method, level) | 926 | comment, method, level) |
927 | zipFile file; | 927 | zipFile file; |
928 | const char* filename; | 928 | const char* filename; |
929 | const zip_fileinfo* zipfi; | 929 | const zip_fileinfo* zipfi; |
930 | const void* extrafield_local; | 930 | const void* extrafield_local; |
931 | uInt size_extrafield_local; | 931 | uInt size_extrafield_local; |
932 | const void* extrafield_global; | 932 | const void* extrafield_global; |
933 | uInt size_extrafield_global; | 933 | uInt size_extrafield_global; |
934 | const char* comment; | 934 | const char* comment; |
935 | int method; | 935 | int method; |
936 | int level; | 936 | int level; |
937 | { | 937 | { |
938 | return zipOpenNewFileInZip2 (file, filename, zipfi, | 938 | return zipOpenNewFileInZip2 (file, filename, zipfi, |
939 | extrafield_local, size_extrafield_local, | 939 | extrafield_local, size_extrafield_local, |
940 | extrafield_global, size_extrafield_global, | 940 | extrafield_global, size_extrafield_global, |
941 | comment, method, level, 0); | 941 | comment, method, level, 0); |
942 | } | 942 | } |
943 | 943 | ||
944 | local int zipFlushWriteBuffer(zi) | 944 | local int zipFlushWriteBuffer(zi) |
945 | zip_internal* zi; | 945 | zip_internal* zi; |
946 | { | 946 | { |
947 | int err=ZIP_OK; | 947 | int err=ZIP_OK; |
948 | 948 | ||
949 | if (zi->ci.encrypt != 0) | 949 | if (zi->ci.encrypt != 0) |
950 | { | 950 | { |
951 | #ifndef NOCRYPT | 951 | #ifndef NOCRYPT |
952 | uInt i; | 952 | uInt i; |
953 | int t; | 953 | int t; |
954 | for (i=0;i<zi->ci.pos_in_buffered_data;i++) | 954 | for (i=0;i<zi->ci.pos_in_buffered_data;i++) |
955 | zi->ci.buffered_data[i] = zencode(zi->ci.keys, zi->ci.pcrc_32_tab, | 955 | zi->ci.buffered_data[i] = zencode(zi->ci.keys, zi->ci.pcrc_32_tab, |
956 | zi->ci.buffered_data[i],t); | 956 | zi->ci.buffered_data[i],t); |
957 | #endif | 957 | #endif |
958 | } | 958 | } |
959 | if (ZWRITE(zi->z_filefunc,zi->filestream,zi->ci.buffered_data,zi->ci.pos_in_buffered_data) | 959 | if (ZWRITE(zi->z_filefunc,zi->filestream,zi->ci.buffered_data,zi->ci.pos_in_buffered_data) |
960 | !=zi->ci.pos_in_buffered_data) | 960 | !=zi->ci.pos_in_buffered_data) |
961 | err = ZIP_ERRNO; | 961 | err = ZIP_ERRNO; |
962 | zi->ci.pos_in_buffered_data = 0; | 962 | zi->ci.pos_in_buffered_data = 0; |
963 | return err; | 963 | return err; |
964 | } | 964 | } |
965 | 965 | ||
966 | extern int ZEXPORT zipWriteInFileInZip (file, buf, len) | 966 | extern int ZEXPORT zipWriteInFileInZip (file, buf, len) |
967 | zipFile file; | 967 | zipFile file; |
968 | const void* buf; | 968 | const void* buf; |
969 | unsigned len; | 969 | unsigned len; |
970 | { | 970 | { |
971 | zip_internal* zi; | 971 | zip_internal* zi; |
972 | int err=ZIP_OK; | 972 | int err=ZIP_OK; |
973 | 973 | ||
974 | if (file == NULL) | 974 | if (file == NULL) |
975 | return ZIP_PARAMERROR; | 975 | return ZIP_PARAMERROR; |
976 | zi = (zip_internal*)file; | 976 | zi = (zip_internal*)file; |
977 | 977 | ||
978 | if (zi->in_opened_file_inzip == 0) | 978 | if (zi->in_opened_file_inzip == 0) |
979 | return ZIP_PARAMERROR; | 979 | return ZIP_PARAMERROR; |
980 | 980 | ||
981 | zi->ci.stream.next_in = (void*)buf; | 981 | zi->ci.stream.next_in = (void*)buf; |
982 | zi->ci.stream.avail_in = len; | 982 | zi->ci.stream.avail_in = len; |
983 | zi->ci.crc32 = crc32(zi->ci.crc32,buf,len); | 983 | zi->ci.crc32 = crc32(zi->ci.crc32,buf,len); |
984 | 984 | ||
985 | while ((err==ZIP_OK) && (zi->ci.stream.avail_in>0)) | 985 | while ((err==ZIP_OK) && (zi->ci.stream.avail_in>0)) |
986 | { | 986 | { |
987 | if (zi->ci.stream.avail_out == 0) | 987 | if (zi->ci.stream.avail_out == 0) |
988 | { | 988 | { |
989 | if (zipFlushWriteBuffer(zi) == ZIP_ERRNO) | 989 | if (zipFlushWriteBuffer(zi) == ZIP_ERRNO) |
990 | err = ZIP_ERRNO; | 990 | err = ZIP_ERRNO; |
991 | zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; | 991 | zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; |
992 | zi->ci.stream.next_out = zi->ci.buffered_data; | 992 | zi->ci.stream.next_out = zi->ci.buffered_data; |
993 | } | 993 | } |
994 | 994 | ||
995 | 995 | ||
996 | if(err != ZIP_OK) | 996 | if(err != ZIP_OK) |
997 | break; | 997 | break; |
998 | 998 | ||
999 | if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) | 999 | if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) |
1000 | { | 1000 | { |
1001 | uLong uTotalOutBefore = zi->ci.stream.total_out; | 1001 | uLong uTotalOutBefore = zi->ci.stream.total_out; |
1002 | err=deflate(&zi->ci.stream, Z_NO_FLUSH); | 1002 | err=deflate(&zi->ci.stream, Z_NO_FLUSH); |
1003 | zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ; | 1003 | zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ; |
1004 | 1004 | ||
1005 | } | 1005 | } |
1006 | else | 1006 | else |
1007 | { | 1007 | { |
1008 | uInt copy_this,i; | 1008 | uInt copy_this,i; |
1009 | if (zi->ci.stream.avail_in < zi->ci.stream.avail_out) | 1009 | if (zi->ci.stream.avail_in < zi->ci.stream.avail_out) |
1010 | copy_this = zi->ci.stream.avail_in; | 1010 | copy_this = zi->ci.stream.avail_in; |
1011 | else | 1011 | else |
1012 | copy_this = zi->ci.stream.avail_out; | 1012 | copy_this = zi->ci.stream.avail_out; |
1013 | for (i=0;i<copy_this;i++) | 1013 | for (i=0;i<copy_this;i++) |
1014 | *(((char*)zi->ci.stream.next_out)+i) = | 1014 | *(((char*)zi->ci.stream.next_out)+i) = |
1015 | *(((const char*)zi->ci.stream.next_in)+i); | 1015 | *(((const char*)zi->ci.stream.next_in)+i); |
1016 | { | 1016 | { |
1017 | zi->ci.stream.avail_in -= copy_this; | 1017 | zi->ci.stream.avail_in -= copy_this; |
1018 | zi->ci.stream.avail_out-= copy_this; | 1018 | zi->ci.stream.avail_out-= copy_this; |
1019 | zi->ci.stream.next_in+= copy_this; | 1019 | zi->ci.stream.next_in+= copy_this; |
1020 | zi->ci.stream.next_out+= copy_this; | 1020 | zi->ci.stream.next_out+= copy_this; |
1021 | zi->ci.stream.total_in+= copy_this; | 1021 | zi->ci.stream.total_in+= copy_this; |
1022 | zi->ci.stream.total_out+= copy_this; | 1022 | zi->ci.stream.total_out+= copy_this; |
1023 | zi->ci.pos_in_buffered_data += copy_this; | 1023 | zi->ci.pos_in_buffered_data += copy_this; |
1024 | } | 1024 | } |
1025 | } | 1025 | } |
1026 | } | 1026 | } |
1027 | 1027 | ||
1028 | return err; | 1028 | return err; |
1029 | } | 1029 | } |
1030 | 1030 | ||
1031 | extern int ZEXPORT zipCloseFileInZipRaw (file, uncompressed_size, crc32) | 1031 | extern int ZEXPORT zipCloseFileInZipRaw (file, uncompressed_size, crc32) |
1032 | zipFile file; | 1032 | zipFile file; |
1033 | uLong uncompressed_size; | 1033 | uLong uncompressed_size; |
1034 | uLong crc32; | 1034 | uLong crc32; |
1035 | { | 1035 | { |
1036 | zip_internal* zi; | 1036 | zip_internal* zi; |
1037 | uLong compressed_size; | 1037 | uLong compressed_size; |
1038 | int err=ZIP_OK; | 1038 | int err=ZIP_OK; |
1039 | 1039 | ||
1040 | if (file == NULL) | 1040 | if (file == NULL) |
1041 | return ZIP_PARAMERROR; | 1041 | return ZIP_PARAMERROR; |
1042 | zi = (zip_internal*)file; | 1042 | zi = (zip_internal*)file; |
1043 | 1043 | ||
1044 | if (zi->in_opened_file_inzip == 0) | 1044 | if (zi->in_opened_file_inzip == 0) |
1045 | return ZIP_PARAMERROR; | 1045 | return ZIP_PARAMERROR; |
1046 | zi->ci.stream.avail_in = 0; | 1046 | zi->ci.stream.avail_in = 0; |
1047 | 1047 | ||
1048 | if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) | 1048 | if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) |
1049 | while (err==ZIP_OK) | 1049 | while (err==ZIP_OK) |
1050 | { | 1050 | { |
1051 | uLong uTotalOutBefore; | 1051 | uLong uTotalOutBefore; |
1052 | if (zi->ci.stream.avail_out == 0) | 1052 | if (zi->ci.stream.avail_out == 0) |
1053 | { | 1053 | { |
1054 | if (zipFlushWriteBuffer(zi) == ZIP_ERRNO) | 1054 | if (zipFlushWriteBuffer(zi) == ZIP_ERRNO) |
1055 | err = ZIP_ERRNO; | 1055 | err = ZIP_ERRNO; |
1056 | zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; | 1056 | zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; |
1057 | zi->ci.stream.next_out = zi->ci.buffered_data; | 1057 | zi->ci.stream.next_out = zi->ci.buffered_data; |
1058 | } | 1058 | } |
1059 | uTotalOutBefore = zi->ci.stream.total_out; | 1059 | uTotalOutBefore = zi->ci.stream.total_out; |
1060 | err=deflate(&zi->ci.stream, Z_FINISH); | 1060 | err=deflate(&zi->ci.stream, Z_FINISH); |
1061 | zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ; | 1061 | zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ; |
1062 | } | 1062 | } |
1063 | 1063 | ||
1064 | if (err==Z_STREAM_END) | 1064 | if (err==Z_STREAM_END) |
1065 | err=ZIP_OK; /* this is normal */ | 1065 | err=ZIP_OK; /* this is normal */ |
1066 | 1066 | ||
1067 | if ((zi->ci.pos_in_buffered_data>0) && (err==ZIP_OK)) | 1067 | if ((zi->ci.pos_in_buffered_data>0) && (err==ZIP_OK)) |
1068 | if (zipFlushWriteBuffer(zi)==ZIP_ERRNO) | 1068 | if (zipFlushWriteBuffer(zi)==ZIP_ERRNO) |
1069 | err = ZIP_ERRNO; | 1069 | err = ZIP_ERRNO; |
1070 | 1070 | ||
1071 | if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) | 1071 | if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) |
1072 | { | 1072 | { |
1073 | err=deflateEnd(&zi->ci.stream); | 1073 | err=deflateEnd(&zi->ci.stream); |
1074 | zi->ci.stream_initialised = 0; | 1074 | zi->ci.stream_initialised = 0; |
1075 | } | 1075 | } |
1076 | 1076 | ||
1077 | if (!zi->ci.raw) | 1077 | if (!zi->ci.raw) |
1078 | { | 1078 | { |
1079 | crc32 = (uLong)zi->ci.crc32; | 1079 | crc32 = (uLong)zi->ci.crc32; |
1080 | uncompressed_size = (uLong)zi->ci.stream.total_in; | 1080 | uncompressed_size = (uLong)zi->ci.stream.total_in; |
1081 | } | 1081 | } |
1082 | compressed_size = (uLong)zi->ci.stream.total_out; | 1082 | compressed_size = (uLong)zi->ci.stream.total_out; |
1083 | # ifndef NOCRYPT | 1083 | # ifndef NOCRYPT |
1084 | compressed_size += zi->ci.crypt_header_size; | 1084 | compressed_size += zi->ci.crypt_header_size; |
1085 | # endif | 1085 | # endif |
1086 | 1086 | ||
1087 | ziplocal_putValue_inmemory(zi->ci.central_header+16,crc32,4); /*crc*/ | 1087 | ziplocal_putValue_inmemory(zi->ci.central_header+16,crc32,4); /*crc*/ |
1088 | ziplocal_putValue_inmemory(zi->ci.central_header+20, | 1088 | ziplocal_putValue_inmemory(zi->ci.central_header+20, |
1089 | compressed_size,4); /*compr size*/ | 1089 | compressed_size,4); /*compr size*/ |
1090 | if (zi->ci.stream.data_type == Z_ASCII) | 1090 | if (zi->ci.stream.data_type == Z_ASCII) |
1091 | ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)Z_ASCII,2); | 1091 | ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)Z_ASCII,2); |
1092 | ziplocal_putValue_inmemory(zi->ci.central_header+24, | 1092 | ziplocal_putValue_inmemory(zi->ci.central_header+24, |
1093 | uncompressed_size,4); /*uncompr size*/ | 1093 | uncompressed_size,4); /*uncompr size*/ |
1094 | 1094 | ||
1095 | if (err==ZIP_OK) | 1095 | if (err==ZIP_OK) |
1096 | err = add_data_in_datablock(&zi->central_dir,zi->ci.central_header, | 1096 | err = add_data_in_datablock(&zi->central_dir,zi->ci.central_header, |
1097 | (uLong)zi->ci.size_centralheader); | 1097 | (uLong)zi->ci.size_centralheader); |
1098 | free(zi->ci.central_header); | 1098 | free(zi->ci.central_header); |
1099 | 1099 | ||
1100 | if (err==ZIP_OK) | 1100 | if (err==ZIP_OK) |
1101 | { | 1101 | { |
1102 | long cur_pos_inzip = ZTELL(zi->z_filefunc,zi->filestream); | 1102 | long cur_pos_inzip = ZTELL(zi->z_filefunc,zi->filestream); |
1103 | if (ZSEEK(zi->z_filefunc,zi->filestream, | 1103 | if (ZSEEK(zi->z_filefunc,zi->filestream, |
1104 | zi->ci.pos_local_header + 14,ZLIB_FILEFUNC_SEEK_SET)!=0) | 1104 | zi->ci.pos_local_header + 14,ZLIB_FILEFUNC_SEEK_SET)!=0) |
1105 | err = ZIP_ERRNO; | 1105 | err = ZIP_ERRNO; |
1106 | 1106 | ||
1107 | if (err==ZIP_OK) | 1107 | if (err==ZIP_OK) |
1108 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,crc32,4); /* crc 32, unknown */ | 1108 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,crc32,4); /* crc 32, unknown */ |
1109 | 1109 | ||
1110 | if (err==ZIP_OK) /* compressed size, unknown */ | 1110 | if (err==ZIP_OK) /* compressed size, unknown */ |
1111 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,compressed_size,4); | 1111 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,compressed_size,4); |
1112 | 1112 | ||
1113 | if (err==ZIP_OK) /* uncompressed size, unknown */ | 1113 | if (err==ZIP_OK) /* uncompressed size, unknown */ |
1114 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,uncompressed_size,4); | 1114 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,uncompressed_size,4); |
1115 | 1115 | ||
1116 | if (ZSEEK(zi->z_filefunc,zi->filestream, | 1116 | if (ZSEEK(zi->z_filefunc,zi->filestream, |
1117 | cur_pos_inzip,ZLIB_FILEFUNC_SEEK_SET)!=0) | 1117 | cur_pos_inzip,ZLIB_FILEFUNC_SEEK_SET)!=0) |
1118 | err = ZIP_ERRNO; | 1118 | err = ZIP_ERRNO; |
1119 | } | 1119 | } |
1120 | 1120 | ||
1121 | zi->number_entry ++; | 1121 | zi->number_entry ++; |
1122 | zi->in_opened_file_inzip = 0; | 1122 | zi->in_opened_file_inzip = 0; |
1123 | 1123 | ||
1124 | return err; | 1124 | return err; |
1125 | } | 1125 | } |
1126 | 1126 | ||
1127 | extern int ZEXPORT zipCloseFileInZip (file) | 1127 | extern int ZEXPORT zipCloseFileInZip (file) |
1128 | zipFile file; | 1128 | zipFile file; |
1129 | { | 1129 | { |
1130 | return zipCloseFileInZipRaw (file,0,0); | 1130 | return zipCloseFileInZipRaw (file,0,0); |
1131 | } | 1131 | } |
1132 | 1132 | ||
1133 | extern int ZEXPORT zipClose (file, global_comment) | 1133 | extern int ZEXPORT zipClose (file, global_comment) |
1134 | zipFile file; | 1134 | zipFile file; |
1135 | const char* global_comment; | 1135 | const char* global_comment; |
1136 | { | 1136 | { |
1137 | zip_internal* zi; | 1137 | zip_internal* zi; |
1138 | int err = 0; | 1138 | int err = 0; |
1139 | uLong size_centraldir = 0; | 1139 | uLong size_centraldir = 0; |
1140 | uLong centraldir_pos_inzip; | 1140 | uLong centraldir_pos_inzip; |
1141 | uInt size_global_comment; | 1141 | uInt size_global_comment; |
1142 | if (file == NULL) | 1142 | if (file == NULL) |
1143 | return ZIP_PARAMERROR; | 1143 | return ZIP_PARAMERROR; |
1144 | zi = (zip_internal*)file; | 1144 | zi = (zip_internal*)file; |
1145 | 1145 | ||
1146 | if (zi->in_opened_file_inzip == 1) | 1146 | if (zi->in_opened_file_inzip == 1) |
1147 | { | 1147 | { |
1148 | err = zipCloseFileInZip (file); | 1148 | err = zipCloseFileInZip (file); |
1149 | } | 1149 | } |
1150 | 1150 | ||
1151 | #ifndef NO_ADDFILEINEXISTINGZIP | 1151 | #ifndef NO_ADDFILEINEXISTINGZIP |
1152 | if (global_comment==NULL) | 1152 | if (global_comment==NULL) |
1153 | global_comment = zi->globalcomment; | 1153 | global_comment = zi->globalcomment; |
1154 | #endif | 1154 | #endif |
1155 | if (global_comment==NULL) | 1155 | if (global_comment==NULL) |
1156 | size_global_comment = 0; | 1156 | size_global_comment = 0; |
1157 | else | 1157 | else |
1158 | size_global_comment = (uInt)strlen(global_comment); | 1158 | size_global_comment = (uInt)strlen(global_comment); |
1159 | 1159 | ||
1160 | centraldir_pos_inzip = ZTELL(zi->z_filefunc,zi->filestream); | 1160 | centraldir_pos_inzip = ZTELL(zi->z_filefunc,zi->filestream); |
1161 | if (err==ZIP_OK) | 1161 | if (err==ZIP_OK) |
1162 | { | 1162 | { |
1163 | linkedlist_datablock_internal* ldi = zi->central_dir.first_block ; | 1163 | linkedlist_datablock_internal* ldi = zi->central_dir.first_block ; |
1164 | while (ldi!=NULL) | 1164 | while (ldi!=NULL) |
1165 | { | 1165 | { |
1166 | if ((err==ZIP_OK) && (ldi->filled_in_this_block>0)) | 1166 | if ((err==ZIP_OK) && (ldi->filled_in_this_block>0)) |
1167 | if (ZWRITE(zi->z_filefunc,zi->filestream, | 1167 | if (ZWRITE(zi->z_filefunc,zi->filestream, |
1168 | ldi->data,ldi->filled_in_this_block) | 1168 | ldi->data,ldi->filled_in_this_block) |
1169 | !=ldi->filled_in_this_block ) | 1169 | !=ldi->filled_in_this_block ) |
1170 | err = ZIP_ERRNO; | 1170 | err = ZIP_ERRNO; |
1171 | 1171 | ||
1172 | size_centraldir += ldi->filled_in_this_block; | 1172 | size_centraldir += ldi->filled_in_this_block; |
1173 | ldi = ldi->next_datablock; | 1173 | ldi = ldi->next_datablock; |
1174 | } | 1174 | } |
1175 | } | 1175 | } |
1176 | free_datablock(zi->central_dir.first_block); | 1176 | free_datablock(zi->central_dir.first_block); |
1177 | 1177 | ||
1178 | if (err==ZIP_OK) /* Magic End */ | 1178 | if (err==ZIP_OK) /* Magic End */ |
1179 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)ENDHEADERMAGIC,4); | 1179 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)ENDHEADERMAGIC,4); |
1180 | 1180 | ||
1181 | if (err==ZIP_OK) /* number of this disk */ | 1181 | if (err==ZIP_OK) /* number of this disk */ |
1182 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2); | 1182 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2); |
1183 | 1183 | ||
1184 | if (err==ZIP_OK) /* number of the disk with the start of the central directory */ | 1184 | if (err==ZIP_OK) /* number of the disk with the start of the central directory */ |
1185 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2); | 1185 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2); |
1186 | 1186 | ||
1187 | if (err==ZIP_OK) /* total number of entries in the central dir on this disk */ | 1187 | if (err==ZIP_OK) /* total number of entries in the central dir on this disk */ |
1188 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2); | 1188 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2); |
1189 | 1189 | ||
1190 | if (err==ZIP_OK) /* total number of entries in the central dir */ | 1190 | if (err==ZIP_OK) /* total number of entries in the central dir */ |
1191 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2); | 1191 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2); |
1192 | 1192 | ||
1193 | if (err==ZIP_OK) /* size of the central directory */ | 1193 | if (err==ZIP_OK) /* size of the central directory */ |
1194 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_centraldir,4); | 1194 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_centraldir,4); |
1195 | 1195 | ||
1196 | if (err==ZIP_OK) /* offset of start of central directory with respect to the | 1196 | if (err==ZIP_OK) /* offset of start of central directory with respect to the |
1197 | starting disk number */ | 1197 | starting disk number */ |
1198 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream, | 1198 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream, |
1199 | (uLong)(centraldir_pos_inzip - zi->add_position_when_writting_offset),4); | 1199 | (uLong)(centraldir_pos_inzip - zi->add_position_when_writting_offset),4); |
1200 | 1200 | ||
1201 | if (err==ZIP_OK) /* zipfile comment length */ | 1201 | if (err==ZIP_OK) /* zipfile comment length */ |
1202 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_global_comment,2); | 1202 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_global_comment,2); |
1203 | 1203 | ||
1204 | if ((err==ZIP_OK) && (size_global_comment>0)) | 1204 | if ((err==ZIP_OK) && (size_global_comment>0)) |
1205 | if (ZWRITE(zi->z_filefunc,zi->filestream, | 1205 | if (ZWRITE(zi->z_filefunc,zi->filestream, |
1206 | global_comment,size_global_comment) != size_global_comment) | 1206 | global_comment,size_global_comment) != size_global_comment) |
1207 | err = ZIP_ERRNO; | 1207 | err = ZIP_ERRNO; |
1208 | 1208 | ||
1209 | if (ZCLOSE(zi->z_filefunc,zi->filestream) != 0) | 1209 | if (ZCLOSE(zi->z_filefunc,zi->filestream) != 0) |
1210 | if (err == ZIP_OK) | 1210 | if (err == ZIP_OK) |
1211 | err = ZIP_ERRNO; | 1211 | err = ZIP_ERRNO; |
1212 | 1212 | ||
1213 | #ifndef NO_ADDFILEINEXISTINGZIP | 1213 | #ifndef NO_ADDFILEINEXISTINGZIP |
1214 | TRYFREE(zi->globalcomment); | 1214 | TRYFREE(zi->globalcomment); |
1215 | #endif | 1215 | #endif |
1216 | TRYFREE(zi); | 1216 | TRYFREE(zi); |
1217 | 1217 | ||
1218 | return err; | 1218 | return err; |
1219 | } | 1219 | } |