?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge pull request #110 from tesselode/fixes
[wdl/wdl-ol.git] / WDL / zlib / zip.c
blob3af20849e2972e9945703ed55669ac87880c160b
1 /* zip.c -- IO on .zip files using zlib
2 Version 1.1, February 14h, 2010
3 part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
4
5 Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
6
7 Modifications for Zip64 support
8 Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
9
10 For more info read MiniZip_info.txt
11
12 Changes
13 Oct-2009 - Mathias Svensson - Remove old C style function prototypes
14 Oct-2009 - Mathias Svensson - Added Zip64 Support when creating new file archives
15 Oct-2009 - Mathias Svensson - Did some code cleanup and refactoring to get better overview of some functions.
16 Oct-2009 - Mathias Svensson - Added zipRemoveExtraInfoBlock to strip extra field data from its ZIP64 data
17 It is used when recreting zip archive with RAW when deleting items from a zip.
18 ZIP64 data is automaticly added to items that needs it, and existing ZIP64 data need to be removed.
19 Oct-2009 - Mathias Svensson - Added support for BZIP2 as compression mode (bzip2 lib is required)
20 Jan-2010 - back to unzip and minizip 1.0 name scheme, with compatibility layer
21
22 */
23
24
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <time.h>
29 #include "zlib.h"
30 #include "zip.h"
31
32 #ifdef STDC
33 # include <stddef.h>
34 # include <string.h>
35 # include <stdlib.h>
36 #endif
37 #ifdef NO_ERRNO_H
38 extern int errno;
39 #else
40 # include <errno.h>
41 #endif
42
43 #if !defined(NOCRYPT) && !defined(WANTCRYPT)
44 #define NOCRYPT
45 #endif
46
47 #ifndef local
48 # define local static
49 #endif
50 /* compile with -Dlocal if your debugger can't find static symbols */
51
52 #ifndef VERSIONMADEBY
53 # define VERSIONMADEBY (0x0) /* platform depedent */
54 #endif
55
56 #ifndef Z_BUFSIZE
57 #define Z_BUFSIZE (64*1024) //(16384)
58 #endif
59
60 #ifndef Z_MAXFILENAMEINZIP
61 #define Z_MAXFILENAMEINZIP (256)
62 #endif
63
64 #ifndef ALLOC
65 # define ALLOC(size) (malloc(size))
66 #endif
67 #ifndef TRYFREE
68 # define TRYFREE(p) {if (p) free(p);}
69 #endif
70
71 /*
72 #define SIZECENTRALDIRITEM (0x2e)
73 #define SIZEZIPLOCALHEADER (0x1e)
74 */
75
76 /* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
77
78
79 // NOT sure that this work on ALL platform
80 #define MAKEULONG64(a, b) ((ZPOS64_T)(((unsigned long)(a)) | ((ZPOS64_T)((unsigned long)(b))) << 32))
81
82 #ifndef SEEK_CUR
83 #define SEEK_CUR 1
84 #endif
85
86 #ifndef SEEK_END
87 #define SEEK_END 2
88 #endif
89
90 #ifndef SEEK_SET
91 #define SEEK_SET 0
92 #endif
93
94 #ifndef DEF_MEM_LEVEL
95 #if MAX_MEM_LEVEL >= 8
96 # define DEF_MEM_LEVEL 8
97 #else
98 # define DEF_MEM_LEVEL MAX_MEM_LEVEL
99 #endif
100 #endif
101 const char zip_copyright[] =" zip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll";
102
103
104 #define SIZEDATA_INDATABLOCK (4096-(4*4))
105
106 #define LOCALHEADERMAGIC (0x04034b50)
107 #define CENTRALHEADERMAGIC (0x02014b50)
108 #define ENDHEADERMAGIC (0x06054b50)
109 #define ZIP64ENDHEADERMAGIC (0x6064b50)
110 #define ZIP64ENDLOCHEADERMAGIC (0x7064b50)
111
112 #define FLAG_LOCALHEADER_OFFSET (0x06)
113 #define CRC_LOCALHEADER_OFFSET (0x0e)
114
115 #define SIZECENTRALHEADER (0x2e) /* 46 */
116
117 typedef struct linkedlist_datablock_internal_s
118 {
119 struct linkedlist_datablock_internal_s* next_datablock;
120 uLong avail_in_this_block;
121 uLong filled_in_this_block;
122 uLong unused; /* for future use and alignement */
123 unsigned char data[SIZEDATA_INDATABLOCK];
124 } linkedlist_datablock_internal;
125
126 typedef struct linkedlist_data_s
127 {
128 linkedlist_datablock_internal* first_block;
129 linkedlist_datablock_internal* last_block;
130 } linkedlist_data;
131
132
133 typedef struct
134 {
135 z_stream stream; /* zLib stream structure for inflate */
136 #ifdef HAVE_BZIP2
137 bz_stream bstream; /* bzLib stream structure for bziped */
138 #endif
139
140 int stream_initialised; /* 1 is stream is initialised */
141 uInt pos_in_buffered_data; /* last written byte in buffered_data */
142
143 ZPOS64_T pos_local_header; /* offset of the local header of the file
144 currenty writing */
145 char* central_header; /* central header data for the current file */
146 uLong size_centralExtra;
147 uLong size_centralheader; /* size of the central header for cur file */
148 uLong size_centralExtraFree; /* Extra bytes allocated to the centralheader but that are not used */
149 uLong flag; /* flag of the file currently writing */
150
151 int method; /* compression method of file currenty wr.*/
152 int raw; /* 1 for directly writing raw data */
153 Byte buffered_data[Z_BUFSIZE];/* buffer contain compressed data to be writ*/
154 uLong dosDate;
155 uLong crc32;
156 int encrypt;
157 int zip64; /* Add ZIP64 extened information in the extra field */
158 ZPOS64_T pos_zip64extrainfo;
159 ZPOS64_T totalCompressedData;
160 ZPOS64_T totalUncompressedData;
161 #ifndef NOCRYPT
162 unsigned long keys[3]; /* keys defining the pseudo-random sequence */
163 const z_crc_t* pcrc_32_tab;
164 int crypt_header_size;
165 #endif
166 } curfile64_info;
167
168 typedef struct
169 {
170 zlib_filefunc64_32_def z_filefunc;
171 voidpf filestream; /* io structore of the zipfile */
172 linkedlist_data central_dir;/* datablock with central dir in construction*/
173 int in_opened_file_inzip; /* 1 if a file in the zip is currently writ.*/
174 curfile64_info ci; /* info on the file curretly writing */
175
176 ZPOS64_T begin_pos; /* position of the beginning of the zipfile */
177 ZPOS64_T add_position_when_writting_offset;
178 ZPOS64_T number_entry;
179
180 #ifndef NO_ADDFILEINEXISTINGZIP
181 char *globalcomment;
182 #endif
183
184 } zip64_internal;
185
186
187 #ifndef NOCRYPT
188 #define INCLUDECRYPTINGCODE_IFCRYPTALLOWED
189 #include "crypt.h"
190 #endif
191
192 local linkedlist_datablock_internal* allocate_new_datablock()
193 {
194 linkedlist_datablock_internal* ldi;
195 ldi = (linkedlist_datablock_internal*)
196 ALLOC(sizeof(linkedlist_datablock_internal));
197 if (ldi!=NULL)
198 {
199 ldi->next_datablock = NULL ;
200 ldi->filled_in_this_block = 0 ;
201 ldi->avail_in_this_block = SIZEDATA_INDATABLOCK ;
202 }
203 return ldi;
204 }
205
206 local void free_datablock(linkedlist_datablock_internal* ldi)
207 {
208 while (ldi!=NULL)
209 {
210 linkedlist_datablock_internal* ldinext = ldi->next_datablock;
211 TRYFREE(ldi);
212 ldi = ldinext;
213 }
214 }
215
216 local void init_linkedlist(linkedlist_data* ll)
217 {
218 ll->first_block = ll->last_block = NULL;
219 }
220
221 local void free_linkedlist(linkedlist_data* ll)
222 {
223 free_datablock(ll->first_block);
224 ll->first_block = ll->last_block = NULL;
225 }
226
227
228 local int add_data_in_datablock(linkedlist_data* ll, const void* buf, uLong len)
229 {
230 linkedlist_datablock_internal* ldi;
231 const unsigned char* from_copy;
232
233 if (ll==NULL)
234 return ZIP_INTERNALERROR;
235
236 if (ll->last_block == NULL)
237 {
238 ll->first_block = ll->last_block = allocate_new_datablock();
239 if (ll->first_block == NULL)
240 return ZIP_INTERNALERROR;
241 }
242
243 ldi = ll->last_block;
244 from_copy = (unsigned char*)buf;
245
246 while (len>0)
247 {
248 uInt copy_this;
249 uInt i;
250 unsigned char* to_copy;
251
252 if (ldi->avail_in_this_block==0)
253 {
254 ldi->next_datablock = allocate_new_datablock();
255 if (ldi->next_datablock == NULL)
256 return ZIP_INTERNALERROR;
257 ldi = ldi->next_datablock ;
258 ll->last_block = ldi;
259 }
260
261 if (ldi->avail_in_this_block < len)
262 copy_this = (uInt)ldi->avail_in_this_block;
263 else
264 copy_this = (uInt)len;
265
266 to_copy = &(ldi->data[ldi->filled_in_this_block]);
267
268 for (i=0;i<copy_this;i++)
269 *(to_copy+i)=*(from_copy+i);
270
271 ldi->filled_in_this_block += copy_this;
272 ldi->avail_in_this_block -= copy_this;
273 from_copy += copy_this ;
274 len -= copy_this;
275 }
276 return ZIP_OK;
277 }
278
279
280
281 /****************************************************************************/
282
283 #ifndef NO_ADDFILEINEXISTINGZIP
284 /* ===========================================================================
285 Inputs a long in LSB order to the given file
286 nbByte == 1, 2 ,4 or 8 (byte, short or long, ZPOS64_T)
287 */
288
289 local int zip64local_putValue OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T x, int nbByte));
290 local int zip64local_putValue (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T x, int nbByte)
291 {
292 unsigned char buf[8];
293 int n;
294 for (n = 0; n < nbByte; n++)
295 {
296 buf[n] = (unsigned char)(x & 0xff);
297 x >>= 8;
298 }
299 if (x != 0)
300 { /* data overflow - hack for ZIP64 (X Roche) */
301 for (n = 0; n < nbByte; n++)
302 {
303 buf[n] = 0xff;
304 }
305 }
306
307 if (ZWRITE64(*pzlib_filefunc_def,filestream,buf,nbByte)!=(uLong)nbByte)
308 return ZIP_ERRNO;
309 else
310 return ZIP_OK;
311 }
312
313 local void zip64local_putValue_inmemory OF((void* dest, ZPOS64_T x, int nbByte));
314 local void zip64local_putValue_inmemory (void* dest, ZPOS64_T x, int nbByte)
315 {
316 unsigned char* buf=(unsigned char*)dest;
317 int n;
318 for (n = 0; n < nbByte; n++) {
319 buf[n] = (unsigned char)(x & 0xff);
320 x >>= 8;
321 }
322
323 if (x != 0)
324 { /* data overflow - hack for ZIP64 */
325 for (n = 0; n < nbByte; n++)
326 {
327 buf[n] = 0xff;
328 }
329 }
330 }
331
332 /****************************************************************************/
333
334
335 local uLong zip64local_TmzDateToDosDate(const tm_zip* ptm)
336 {
337 uLong year = (uLong)ptm->tm_year;
338 if (year>=1980)
339 year-=1980;
340 else if (year>=80)
341 year-=80;
342 return
343 (uLong) (((ptm->tm_mday) + (32 * (ptm->tm_mon+1)) + (512 * year)) << 16) |
344 ((ptm->tm_sec/2) + (32* ptm->tm_min) + (2048 * (uLong)ptm->tm_hour));
345 }
346
347
348 /****************************************************************************/
349
350 local int zip64local_getByte OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, int *pi));
351
352 local int zip64local_getByte(const zlib_filefunc64_32_def* pzlib_filefunc_def,voidpf filestream,int* pi)
353 {
354 unsigned char c;
355 int err = (int)ZREAD64(*pzlib_filefunc_def,filestream,&c,1);
356 if (err==1)
357 {
358 *pi = (int)c;
359 return ZIP_OK;
360 }
361 else
362 {
363 if (ZERROR64(*pzlib_filefunc_def,filestream))
364 return ZIP_ERRNO;
365 else
366 return ZIP_EOF;
367 }
368 }
369
370
371 /* ===========================================================================
372 Reads a long in LSB order from the given gz_stream. Sets
373 */
374 local int zip64local_getShort OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong *pX));
375
376 local int zip64local_getShort (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong* pX)
377 {
378 uLong x ;
379 int i = 0;
380 int err;
381
382 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
383 x = (uLong)i;
384
385 if (err==ZIP_OK)
386 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
387 x += ((uLong)i)<<8;
388
389 if (err==ZIP_OK)
390 *pX = x;
391 else
392 *pX = 0;
393 return err;
394 }
395
396 local int zip64local_getLong OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong *pX));
397
398 local int zip64local_getLong (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong* pX)
399 {
400 uLong x ;
401 int i = 0;
402 int err;
403
404 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
405 x = (uLong)i;
406
407 if (err==ZIP_OK)
408 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
409 x += ((uLong)i)<<8;
410
411 if (err==ZIP_OK)
412 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
413 x += ((uLong)i)<<16;
414
415 if (err==ZIP_OK)
416 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
417 x += ((uLong)i)<<24;
418
419 if (err==ZIP_OK)
420 *pX = x;
421 else
422 *pX = 0;
423 return err;
424 }
425
426 local int zip64local_getLong64 OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T *pX));
427
428
429 local int zip64local_getLong64 (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T *pX)
430 {
431 ZPOS64_T x;
432 int i = 0;
433 int err;
434
435 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
436 x = (ZPOS64_T)i;
437
438 if (err==ZIP_OK)
439 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
440 x += ((ZPOS64_T)i)<<8;
441
442 if (err==ZIP_OK)
443 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
444 x += ((ZPOS64_T)i)<<16;
445
446 if (err==ZIP_OK)
447 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
448 x += ((ZPOS64_T)i)<<24;
449
450 if (err==ZIP_OK)
451 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
452 x += ((ZPOS64_T)i)<<32;
453
454 if (err==ZIP_OK)
455 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
456 x += ((ZPOS64_T)i)<<40;
457
458 if (err==ZIP_OK)
459 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
460 x += ((ZPOS64_T)i)<<48;
461
462 if (err==ZIP_OK)
463 err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
464 x += ((ZPOS64_T)i)<<56;
465
466 if (err==ZIP_OK)
467 *pX = x;
468 else
469 *pX = 0;
470
471 return err;
472 }
473
474 #ifndef BUFREADCOMMENT
475 #define BUFREADCOMMENT (0x400)
476 #endif
477 /*
478 Locate the Central directory of a zipfile (at the end, just before
479 the global comment)
480 */
481 local ZPOS64_T zip64local_SearchCentralDir OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream));
482
483 local ZPOS64_T zip64local_SearchCentralDir(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)
484 {
485 unsigned char* buf;
486 ZPOS64_T uSizeFile;
487 ZPOS64_T uBackRead;
488 ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
489 ZPOS64_T uPosFound=0;
490
491 if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
492 return 0;
493
494
495 uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);
496
497 if (uMaxBack>uSizeFile)
498 uMaxBack = uSizeFile;
499
500 buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
501 if (buf==NULL)
502 return 0;
503
504 uBackRead = 4;
505 while (uBackRead<uMaxBack)
506 {
507 uLong uReadSize;
508 ZPOS64_T uReadPos ;
509 int i;
510 if (uBackRead+BUFREADCOMMENT>uMaxBack)
511 uBackRead = uMaxBack;
512 else
513 uBackRead+=BUFREADCOMMENT;
514 uReadPos = uSizeFile-uBackRead ;
515
516 uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
517 (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);
518 if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
519 break;
520
521 if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
522 break;
523
524 for (i=(int)uReadSize-3; (i--)>0;)
525 if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
526 ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
527 {
528 uPosFound = uReadPos+i;
529 break;
530 }
531
532 if (uPosFound!=0)
533 break;
534 }
535 TRYFREE(buf);
536 return uPosFound;
537 }
538
539 /*
540 Locate the End of Zip64 Central directory locator and from there find the CD of a zipfile (at the end, just before
541 the global comment)
542 */
543 local ZPOS64_T zip64local_SearchCentralDir64 OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream));
544
545 local ZPOS64_T zip64local_SearchCentralDir64(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)
546 {
547 unsigned char* buf;
548 ZPOS64_T uSizeFile;
549 ZPOS64_T uBackRead;
550 ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
551 ZPOS64_T uPosFound=0;
552 uLong uL;
553 ZPOS64_T relativeOffset;
554
555 if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
556 return 0;
557
558 uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);
559
560 if (uMaxBack>uSizeFile)
561 uMaxBack = uSizeFile;
562
563 buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
564 if (buf==NULL)
565 return 0;
566
567 uBackRead = 4;
568 while (uBackRead<uMaxBack)
569 {
570 uLong uReadSize;
571 ZPOS64_T uReadPos;
572 int i;
573 if (uBackRead+BUFREADCOMMENT>uMaxBack)
574 uBackRead = uMaxBack;
575 else
576 uBackRead+=BUFREADCOMMENT;
577 uReadPos = uSizeFile-uBackRead ;
578
579 uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
580 (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);
581 if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
582 break;
583
584 if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
585 break;
586
587 for (i=(int)uReadSize-3; (i--)>0;)
588 {
589 // Signature "0x07064b50" Zip64 end of central directory locater
590 if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && ((*(buf+i+2))==0x06) && ((*(buf+i+3))==0x07))
591 {
592 uPosFound = uReadPos+i;
593 break;
594 }
595 }
596
597 if (uPosFound!=0)
598 break;
599 }
600
601 TRYFREE(buf);
602 if (uPosFound == 0)
603 return 0;
604
605 /* Zip64 end of central directory locator */
606 if (ZSEEK64(*pzlib_filefunc_def,filestream, uPosFound,ZLIB_FILEFUNC_SEEK_SET)!=0)
607 return 0;
608
609 /* the signature, already checked */
610 if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK)
611 return 0;
612
613 /* number of the disk with the start of the zip64 end of central directory */
614 if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK)
615 return 0;
616 if (uL != 0)
617 return 0;
618
619 /* relative offset of the zip64 end of central directory record */
620 if (zip64local_getLong64(pzlib_filefunc_def,filestream,&relativeOffset)!=ZIP_OK)
621 return 0;
622
623 /* total number of disks */
624 if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK)
625 return 0;
626 if (uL != 1)
627 return 0;
628
629 /* Goto Zip64 end of central directory record */
630 if (ZSEEK64(*pzlib_filefunc_def,filestream, relativeOffset,ZLIB_FILEFUNC_SEEK_SET)!=0)
631 return 0;
632
633 /* the signature */
634 if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK)
635 return 0;
636
637 if (uL != 0x06064b50) // signature of 'Zip64 end of central directory'
638 return 0;
639
640 return relativeOffset;
641 }
642
643 int LoadCentralDirectoryRecord(zip64_internal* pziinit)
644 {
645 int err=ZIP_OK;
646 ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
647
648 ZPOS64_T size_central_dir; /* size of the central directory */
649 ZPOS64_T offset_central_dir; /* offset of start of central directory */
650 ZPOS64_T central_pos;
651 uLong uL;
652
653 uLong number_disk; /* number of the current dist, used for
654 spaning ZIP, unsupported, always 0*/
655 uLong number_disk_with_CD; /* number the the disk with central dir, used
656 for spaning ZIP, unsupported, always 0*/
657 ZPOS64_T number_entry;
658 ZPOS64_T number_entry_CD; /* total number of entries in
659 the central dir
660 (same than number_entry on nospan) */
661 uLong VersionMadeBy;
662 uLong VersionNeeded;
663 uLong size_comment;
664
665 int hasZIP64Record = 0;
666
667 // check first if we find a ZIP64 record
668 central_pos = zip64local_SearchCentralDir64(&pziinit->z_filefunc,pziinit->filestream);
669 if(central_pos > 0)
670 {
671 hasZIP64Record = 1;
672 }
673 else if(central_pos == 0)
674 {
675 central_pos = zip64local_SearchCentralDir(&pziinit->z_filefunc,pziinit->filestream);
676 }
677
678 /* disable to allow appending to empty ZIP archive
679 if (central_pos==0)
680 err=ZIP_ERRNO;
681 */
682
683 if(hasZIP64Record)
684 {
685 ZPOS64_T sizeEndOfCentralDirectory;
686 if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, central_pos, ZLIB_FILEFUNC_SEEK_SET) != 0)
687 err=ZIP_ERRNO;
688
689 /* the signature, already checked */
690 if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&uL)!=ZIP_OK)
691 err=ZIP_ERRNO;
692
693 /* size of zip64 end of central directory record */
694 if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream, &sizeEndOfCentralDirectory)!=ZIP_OK)
695 err=ZIP_ERRNO;
696
697 /* version made by */
698 if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &VersionMadeBy)!=ZIP_OK)
699 err=ZIP_ERRNO;
700
701 /* version needed to extract */
702 if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &VersionNeeded)!=ZIP_OK)
703 err=ZIP_ERRNO;
704
705 /* number of this disk */
706 if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&number_disk)!=ZIP_OK)
707 err=ZIP_ERRNO;
708
709 /* number of the disk with the start of the central directory */
710 if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&number_disk_with_CD)!=ZIP_OK)
711 err=ZIP_ERRNO;
712
713 /* total number of entries in the central directory on this disk */
714 if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream, &number_entry)!=ZIP_OK)
715 err=ZIP_ERRNO;
716
717 /* total number of entries in the central directory */
718 if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&number_entry_CD)!=ZIP_OK)
719 err=ZIP_ERRNO;
720
721 if ((number_entry_CD!=number_entry) || (number_disk_with_CD!=0) || (number_disk!=0))
722 err=ZIP_BADZIPFILE;
723
724 /* size of the central directory */
725 if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&size_central_dir)!=ZIP_OK)
726 err=ZIP_ERRNO;
727
728 /* offset of start of central directory with respect to the
729 starting disk number */
730 if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&offset_central_dir)!=ZIP_OK)
731 err=ZIP_ERRNO;
732
733 // TODO..
734 // read the comment from the standard central header.
735 size_comment = 0;
736 }
737 else
738 {
739 // Read End of central Directory info
740 if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
741 err=ZIP_ERRNO;
742
743 /* the signature, already checked */
744 if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&uL)!=ZIP_OK)
745 err=ZIP_ERRNO;
746
747 /* number of this disk */
748 if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream,&number_disk)!=ZIP_OK)
749 err=ZIP_ERRNO;
750
751 /* number of the disk with the start of the central directory */
752 if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream,&number_disk_with_CD)!=ZIP_OK)
753 err=ZIP_ERRNO;
754
755 /* total number of entries in the central dir on this disk */
756 number_entry = 0;
757 if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK)
758 err=ZIP_ERRNO;
759 else
760 number_entry = uL;
761
762 /* total number of entries in the central dir */
763 number_entry_CD = 0;
764 if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK)
765 err=ZIP_ERRNO;
766 else
767 number_entry_CD = uL;
768
769 if ((number_entry_CD!=number_entry) || (number_disk_with_CD!=0) || (number_disk!=0))
770 err=ZIP_BADZIPFILE;
771
772 /* size of the central directory */
773 size_central_dir = 0;
774 if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK)
775 err=ZIP_ERRNO;
776 else
777 size_central_dir = uL;
778
779 /* offset of start of central directory with respect to the starting disk number */
780 offset_central_dir = 0;
781 if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK)
782 err=ZIP_ERRNO;
783 else
784 offset_central_dir = uL;
785
786
787 /* zipfile global comment length */
788 if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &size_comment)!=ZIP_OK)
789 err=ZIP_ERRNO;
790 }
791
792 if ((central_pos<offset_central_dir+size_central_dir) &&
793 (err==ZIP_OK))
794 err=ZIP_BADZIPFILE;
795
796 if (err!=ZIP_OK)
797 {
798 ZCLOSE64(pziinit->z_filefunc, pziinit->filestream);
799 return ZIP_ERRNO;
800 }
801
802 if (size_comment>0)
803 {
804 pziinit->globalcomment = (char*)ALLOC(size_comment+1);
805 if (pziinit->globalcomment)
806 {
807 size_comment = ZREAD64(pziinit->z_filefunc, pziinit->filestream, pziinit->globalcomment,size_comment);
808 pziinit->globalcomment[size_comment]=0;
809 }
810 }
811
812 byte_before_the_zipfile = central_pos - (offset_central_dir+size_central_dir);
813 pziinit->add_position_when_writting_offset = byte_before_the_zipfile;
814
815 {
816 ZPOS64_T size_central_dir_to_read = size_central_dir;
817 size_t buf_size = SIZEDATA_INDATABLOCK;
818 void* buf_read = (void*)ALLOC(buf_size);
819 if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, offset_central_dir + byte_before_the_zipfile, ZLIB_FILEFUNC_SEEK_SET) != 0)
820 err=ZIP_ERRNO;
821
822 while ((size_central_dir_to_read>0) && (err==ZIP_OK))
823 {
824 ZPOS64_T read_this = SIZEDATA_INDATABLOCK;
825 if (read_this > size_central_dir_to_read)
826 read_this = size_central_dir_to_read;
827
828 if (ZREAD64(pziinit->z_filefunc, pziinit->filestream,buf_read,(uLong)read_this) != read_this)
829 err=ZIP_ERRNO;
830
831 if (err==ZIP_OK)
832 err = add_data_in_datablock(&pziinit->central_dir,buf_read, (uLong)read_this);
833
834 size_central_dir_to_read-=read_this;
835 }
836 TRYFREE(buf_read);
837 }
838 pziinit->begin_pos = byte_before_the_zipfile;
839 pziinit->number_entry = number_entry_CD;
840
841 if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, offset_central_dir+byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET) != 0)
842 err=ZIP_ERRNO;
843
844 return err;
845 }
846
847
848 #endif /* !NO_ADDFILEINEXISTINGZIP*/
849
850
851 /************************************************************/
852 extern zipFile ZEXPORT zipOpen3 (const void *pathname, int append, zipcharpc* globalcomment, zlib_filefunc64_32_def* pzlib_filefunc64_32_def)
853 {
854 zip64_internal ziinit;
855 zip64_internal* zi;
856 int err=ZIP_OK;
857
858 ziinit.z_filefunc.zseek32_file = NULL;
859 ziinit.z_filefunc.ztell32_file = NULL;
860 if (pzlib_filefunc64_32_def==NULL)
861 fill_fopen64_filefunc(&ziinit.z_filefunc.zfile_func64);
862 else
863 ziinit.z_filefunc = *pzlib_filefunc64_32_def;
864
865 ziinit.filestream = ZOPEN64(ziinit.z_filefunc,
866 pathname,
867 (append == APPEND_STATUS_CREATE) ?
868 (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE) :
869 (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING));
870
871 if (ziinit.filestream == NULL)
872 return NULL;
873
874 if (append == APPEND_STATUS_CREATEAFTER)
875 ZSEEK64(ziinit.z_filefunc,ziinit.filestream,0,SEEK_END);
876
877 ziinit.begin_pos = ZTELL64(ziinit.z_filefunc,ziinit.filestream);
878 ziinit.in_opened_file_inzip = 0;
879 ziinit.ci.stream_initialised = 0;
880 ziinit.number_entry = 0;
881 ziinit.add_position_when_writting_offset = 0;
882 init_linkedlist(&(ziinit.central_dir));
883
884
885
886 zi = (zip64_internal*)ALLOC(sizeof(zip64_internal));
887 if (zi==NULL)
888 {
889 ZCLOSE64(ziinit.z_filefunc,ziinit.filestream);
890 return NULL;
891 }
892
893 /* now we add file in a zipfile */
894 # ifndef NO_ADDFILEINEXISTINGZIP
895 ziinit.globalcomment = NULL;
896 if (append == APPEND_STATUS_ADDINZIP)
897 {
898 // Read and Cache Central Directory Records
899 err = LoadCentralDirectoryRecord(&ziinit);
900 }
901
902 if (globalcomment)
903 {
904 *globalcomment = ziinit.globalcomment;
905 }
906 # endif /* !NO_ADDFILEINEXISTINGZIP*/
907
908 if (err != ZIP_OK)
909 {
910 # ifndef NO_ADDFILEINEXISTINGZIP
911 TRYFREE(ziinit.globalcomment);
912 # endif /* !NO_ADDFILEINEXISTINGZIP*/
913 TRYFREE(zi);
914 return NULL;
915 }
916 else
917 {
918 *zi = ziinit;
919 return (zipFile)zi;
920 }
921 }
922
923 extern zipFile ZEXPORT zipOpen2 (const char *pathname, int append, zipcharpc* globalcomment, zlib_filefunc_def* pzlib_filefunc32_def)
924 {
925 if (pzlib_filefunc32_def != NULL)
926 {
927 zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
928 fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill,pzlib_filefunc32_def);
929 return zipOpen3(pathname, append, globalcomment, &zlib_filefunc64_32_def_fill);
930 }
931 else
932 return zipOpen3(pathname, append, globalcomment, NULL);
933 }
934
935 extern zipFile ZEXPORT zipOpen2_64 (const void *pathname, int append, zipcharpc* globalcomment, zlib_filefunc64_def* pzlib_filefunc_def)
936 {
937 if (pzlib_filefunc_def != NULL)
938 {
939 zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
940 zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def;
941 zlib_filefunc64_32_def_fill.ztell32_file = NULL;
942 zlib_filefunc64_32_def_fill.zseek32_file = NULL;
943 return zipOpen3(pathname, append, globalcomment, &zlib_filefunc64_32_def_fill);
944 }
945 else
946 return zipOpen3(pathname, append, globalcomment, NULL);
947 }
948
949
950
951 extern zipFile ZEXPORT zipOpen (const char* pathname, int append)
952 {
953 return zipOpen3((const void*)pathname,append,NULL,NULL);
954 }
955
956 extern zipFile ZEXPORT zipOpen64 (const void* pathname, int append)
957 {
958 return zipOpen3(pathname,append,NULL,NULL);
959 }
960
961 int Write_LocalFileHeader(zip64_internal* zi, const char* filename, uInt size_extrafield_local, const void* extrafield_local)
962 {
963 /* write the local header */
964 int err;
965 uInt size_filename = (uInt)strlen(filename);
966 uInt size_extrafield = size_extrafield_local;
967
968 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)LOCALHEADERMAGIC, 4);
969
970 if (err==ZIP_OK)
971 {
972 if(zi->ci.zip64)
973 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2);/* version needed to extract */
974 else
975 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)20,2);/* version needed to extract */
976 }
977
978 if (err==ZIP_OK)
979 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.flag,2);
980
981 if (err==ZIP_OK)
982 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.method,2);
983
984 if (err==ZIP_OK)
985 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.dosDate,4);
986
987 // CRC / Compressed size / Uncompressed size will be filled in later and rewritten later
988 if (err==ZIP_OK)
989 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* crc 32, unknown */
990 if (err==ZIP_OK)
991 {
992 if(zi->ci.zip64)
993 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xFFFFFFFF,4); /* compressed size, unknown */
994 else
995 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* compressed size, unknown */
996 }
997 if (err==ZIP_OK)
998 {
999 if(zi->ci.zip64)
1000 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xFFFFFFFF,4); /* uncompressed size, unknown */
1001 else
1002 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* uncompressed size, unknown */
1003 }
1004
1005 if (err==ZIP_OK)
1006 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_filename,2);
1007
1008 if(zi->ci.zip64)
1009 {
1010 size_extrafield += 20;
1011 }
1012
1013 if (err==ZIP_OK)
1014 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_extrafield,2);
1015
1016 if ((err==ZIP_OK) && (size_filename > 0))
1017 {
1018 if (ZWRITE64(zi->z_filefunc,zi->filestream,filename,size_filename)!=size_filename)
1019 err = ZIP_ERRNO;
1020 }
1021
1022 if ((err==ZIP_OK) && (size_extrafield_local > 0))
1023 {
1024 if (ZWRITE64(zi->z_filefunc, zi->filestream, extrafield_local, size_extrafield_local) != size_extrafield_local)
1025 err = ZIP_ERRNO;
1026 }
1027
1028
1029 if ((err==ZIP_OK) && (zi->ci.zip64))
1030 {
1031 // write the Zip64 extended info
1032 short HeaderID = 1;
1033 short DataSize = 16;
1034 ZPOS64_T CompressedSize = 0;
1035 ZPOS64_T UncompressedSize = 0;
1036
1037 // Remember position of Zip64 extended info for the local file header. (needed when we update size after done with file)
1038 zi->ci.pos_zip64extrainfo = ZTELL64(zi->z_filefunc,zi->filestream);
1039
1040 err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (short)HeaderID,2);
1041 err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (short)DataSize,2);
1042
1043 err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)UncompressedSize,8);
1044 err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)CompressedSize,8);
1045 }
1046
1047 return err;
1048 }
1049
1050 /*
1051 NOTE.
1052 When writing RAW the ZIP64 extended information in extrafield_local and extrafield_global needs to be stripped
1053 before calling this function it can be done with zipRemoveExtraInfoBlock
1054
1055 It is not done here because then we need to realloc a new buffer since parameters are 'const' and I want to minimize
1056 unnecessary allocations.
1057 */
1058 extern int ZEXPORT zipOpenNewFileInZip4_64 (zipFile file, const char* filename, const zip_fileinfo* zipfi,
1059 const void* extrafield_local, uInt size_extrafield_local,
1060 const void* extrafield_global, uInt size_extrafield_global,
1061 const char* comment, int method, int level, int raw,
1062 int windowBits,int memLevel, int strategy,
1063 const char* password, uLong crcForCrypting,
1064 uLong versionMadeBy, uLong flagBase, int zip64)
1065 {
1066 zip64_internal* zi;
1067 uInt size_filename;
1068 uInt size_comment;
1069 uInt i;
1070 int err = ZIP_OK;
1071
1072 # ifdef NOCRYPT
1073 // (crcForCrypting);
1074 if (password != NULL)
1075 return ZIP_PARAMERROR;
1076 # endif
1077
1078 if (file == NULL)
1079 return ZIP_PARAMERROR;
1080
1081 #ifdef HAVE_BZIP2
1082 if ((method!=0) && (method!=Z_DEFLATED) && (method!=Z_BZIP2ED))
1083 return ZIP_PARAMERROR;
1084 #else
1085 if ((method!=0) && (method!=Z_DEFLATED))
1086 return ZIP_PARAMERROR;
1087 #endif
1088
1089 zi = (zip64_internal*)file;
1090
1091 if (zi->in_opened_file_inzip == 1)
1092 {
1093 err = zipCloseFileInZip (file);
1094 if (err != ZIP_OK)
1095 return err;
1096 }
1097
1098 if (filename==NULL)
1099 filename="-";
1100
1101 if (comment==NULL)
1102 size_comment = 0;
1103 else
1104 size_comment = (uInt)strlen(comment);
1105
1106 size_filename = (uInt)strlen(filename);
1107
1108 if (zipfi == NULL)
1109 zi->ci.dosDate = 0;
1110 else
1111 {
1112 if (zipfi->dosDate != 0)
1113 zi->ci.dosDate = zipfi->dosDate;
1114 else
1115 zi->ci.dosDate = zip64local_TmzDateToDosDate(&zipfi->tmz_date);
1116 }
1117
1118 zi->ci.flag = flagBase;
1119 if ((level==8) || (level==9))
1120 zi->ci.flag |= 2;
1121 if (level==2)
1122 zi->ci.flag |= 4;
1123 if (level==1)
1124 zi->ci.flag |= 6;
1125 if (password != NULL)
1126 zi->ci.flag |= 1;
1127
1128 zi->ci.crc32 = 0;
1129 zi->ci.method = method;
1130 zi->ci.encrypt = 0;
1131 zi->ci.stream_initialised = 0;
1132 zi->ci.pos_in_buffered_data = 0;
1133 zi->ci.raw = raw;
1134 zi->ci.pos_local_header = ZTELL64(zi->z_filefunc,zi->filestream);
1135
1136 zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename + size_extrafield_global + size_comment;
1137 zi->ci.size_centralExtraFree = 32; // Extra space we have reserved in case we need to add ZIP64 extra info data
1138
1139 zi->ci.central_header = (char*)ALLOC((uInt)zi->ci.size_centralheader + zi->ci.size_centralExtraFree);
1140
1141 zi->ci.size_centralExtra = size_extrafield_global;
1142 zip64local_putValue_inmemory(zi->ci.central_header,(uLong)CENTRALHEADERMAGIC,4);
1143 /* version info */
1144 zip64local_putValue_inmemory(zi->ci.central_header+4,(uLong)versionMadeBy,2);
1145 zip64local_putValue_inmemory(zi->ci.central_header+6,(uLong)20,2);
1146 zip64local_putValue_inmemory(zi->ci.central_header+8,(uLong)zi->ci.flag,2);
1147 zip64local_putValue_inmemory(zi->ci.central_header+10,(uLong)zi->ci.method,2);
1148 zip64local_putValue_inmemory(zi->ci.central_header+12,(uLong)zi->ci.dosDate,4);
1149 zip64local_putValue_inmemory(zi->ci.central_header+16,(uLong)0,4); /*crc*/
1150 zip64local_putValue_inmemory(zi->ci.central_header+20,(uLong)0,4); /*compr size*/
1151 zip64local_putValue_inmemory(zi->ci.central_header+24,(uLong)0,4); /*uncompr size*/
1152 zip64local_putValue_inmemory(zi->ci.central_header+28,(uLong)size_filename,2);
1153 zip64local_putValue_inmemory(zi->ci.central_header+30,(uLong)size_extrafield_global,2);
1154 zip64local_putValue_inmemory(zi->ci.central_header+32,(uLong)size_comment,2);
1155 zip64local_putValue_inmemory(zi->ci.central_header+34,(uLong)0,2); /*disk nm start*/
1156
1157 if (zipfi==NULL)
1158 zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)0,2);
1159 else
1160 zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)zipfi->internal_fa,2);
1161
1162 if (zipfi==NULL)
1163 zip64local_putValue_inmemory(zi->ci.central_header+38,(uLong)0,4);
1164 else
1165 zip64local_putValue_inmemory(zi->ci.central_header+38,(uLong)zipfi->external_fa,4);
1166
1167 if(zi->ci.pos_local_header >= 0xffffffff)
1168 zip64local_putValue_inmemory(zi->ci.central_header+42,(uLong)0xffffffff,4);
1169 else
1170 zip64local_putValue_inmemory(zi->ci.central_header+42,(uLong)zi->ci.pos_local_header - zi->add_position_when_writting_offset,4);
1171
1172 for (i=0;i<size_filename;i++)
1173 *(zi->ci.central_header+SIZECENTRALHEADER+i) = *(filename+i);
1174
1175 for (i=0;i<size_extrafield_global;i++)
1176 *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+i) =
1177 *(((const char*)extrafield_global)+i);
1178
1179 for (i=0;i<size_comment;i++)
1180 *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+
1181 size_extrafield_global+i) = *(comment+i);
1182 if (zi->ci.central_header == NULL)
1183 return ZIP_INTERNALERROR;
1184
1185 zi->ci.zip64 = zip64;
1186 zi->ci.totalCompressedData = 0;
1187 zi->ci.totalUncompressedData = 0;
1188 zi->ci.pos_zip64extrainfo = 0;
1189
1190 err = Write_LocalFileHeader(zi, filename, size_extrafield_local, extrafield_local);
1191
1192 #ifdef HAVE_BZIP2
1193 zi->ci.bstream.avail_in = (uInt)0;
1194 zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE;
1195 zi->ci.bstream.next_out = (char*)zi->ci.buffered_data;
1196 zi->ci.bstream.total_in_hi32 = 0;
1197 zi->ci.bstream.total_in_lo32 = 0;
1198 zi->ci.bstream.total_out_hi32 = 0;
1199 zi->ci.bstream.total_out_lo32 = 0;
1200 #endif
1201
1202 zi->ci.stream.avail_in = (uInt)0;
1203 zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
1204 zi->ci.stream.next_out = zi->ci.buffered_data;
1205 zi->ci.stream.total_in = 0;
1206 zi->ci.stream.total_out = 0;
1207 zi->ci.stream.data_type = Z_BINARY;
1208
1209 #ifdef HAVE_BZIP2
1210 if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED || zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw))
1211 #else
1212 if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
1213 #endif
1214 {
1215 if(zi->ci.method == Z_DEFLATED)
1216 {
1217 zi->ci.stream.zalloc = (alloc_func)0;
1218 zi->ci.stream.zfree = (free_func)0;
1219 zi->ci.stream.opaque = (voidpf)0;
1220
1221 if (windowBits>0)
1222 windowBits = -windowBits;
1223
1224 err = deflateInit2(&zi->ci.stream, level, Z_DEFLATED, windowBits, memLevel, strategy);
1225
1226 if (err==Z_OK)
1227 zi->ci.stream_initialised = Z_DEFLATED;
1228 }
1229 else if(zi->ci.method == Z_BZIP2ED)
1230 {
1231 #ifdef HAVE_BZIP2
1232 // Init BZip stuff here
1233 zi->ci.bstream.bzalloc = 0;
1234 zi->ci.bstream.bzfree = 0;
1235 zi->ci.bstream.opaque = (voidpf)0;
1236
1237 err = BZ2_bzCompressInit(&zi->ci.bstream, level, 0,35);
1238 if(err == BZ_OK)
1239 zi->ci.stream_initialised = Z_BZIP2ED;
1240 #endif
1241 }
1242
1243 }
1244
1245 # ifndef NOCRYPT
1246 zi->ci.crypt_header_size = 0;
1247 if ((err==Z_OK) && (password != NULL))
1248 {
1249 unsigned char bufHead[RAND_HEAD_LEN];
1250 unsigned int sizeHead;
1251 zi->ci.encrypt = 1;
1252 zi->ci.pcrc_32_tab = get_crc_table();
1253 /*init_keys(password,zi->ci.keys,zi->ci.pcrc_32_tab);*/
1254
1255 sizeHead=crypthead(password,bufHead,RAND_HEAD_LEN,zi->ci.keys,zi->ci.pcrc_32_tab,crcForCrypting);
1256 zi->ci.crypt_header_size = sizeHead;
1257
1258 if (ZWRITE64(zi->z_filefunc,zi->filestream,bufHead,sizeHead) != sizeHead)
1259 err = ZIP_ERRNO;
1260 }
1261 # endif
1262
1263 if (err==Z_OK)
1264 zi->in_opened_file_inzip = 1;
1265 return err;
1266 }
1267
1268 extern int ZEXPORT zipOpenNewFileInZip4 (zipFile file, const char* filename, const zip_fileinfo* zipfi,
1269 const void* extrafield_local, uInt size_extrafield_local,
1270 const void* extrafield_global, uInt size_extrafield_global,
1271 const char* comment, int method, int level, int raw,
1272 int windowBits,int memLevel, int strategy,
1273 const char* password, uLong crcForCrypting,
1274 uLong versionMadeBy, uLong flagBase)
1275 {
1276 return zipOpenNewFileInZip4_64 (file, filename, zipfi,
1277 extrafield_local, size_extrafield_local,
1278 extrafield_global, size_extrafield_global,
1279 comment, method, level, raw,
1280 windowBits, memLevel, strategy,
1281 password, crcForCrypting, versionMadeBy, flagBase, 0);
1282 }
1283
1284 extern int ZEXPORT zipOpenNewFileInZip3 (zipFile file, const char* filename, const zip_fileinfo* zipfi,
1285 const void* extrafield_local, uInt size_extrafield_local,
1286 const void* extrafield_global, uInt size_extrafield_global,
1287 const char* comment, int method, int level, int raw,
1288 int windowBits,int memLevel, int strategy,
1289 const char* password, uLong crcForCrypting)
1290 {
1291 return zipOpenNewFileInZip4_64 (file, filename, zipfi,
1292 extrafield_local, size_extrafield_local,
1293 extrafield_global, size_extrafield_global,
1294 comment, method, level, raw,
1295 windowBits, memLevel, strategy,
1296 password, crcForCrypting, VERSIONMADEBY, 0, 0);
1297 }
1298
1299 extern int ZEXPORT zipOpenNewFileInZip3_64(zipFile file, const char* filename, const zip_fileinfo* zipfi,
1300 const void* extrafield_local, uInt size_extrafield_local,
1301 const void* extrafield_global, uInt size_extrafield_global,
1302 const char* comment, int method, int level, int raw,
1303 int windowBits,int memLevel, int strategy,
1304 const char* password, uLong crcForCrypting, int zip64)
1305 {
1306 return zipOpenNewFileInZip4_64 (file, filename, zipfi,
1307 extrafield_local, size_extrafield_local,
1308 extrafield_global, size_extrafield_global,
1309 comment, method, level, raw,
1310 windowBits, memLevel, strategy,
1311 password, crcForCrypting, VERSIONMADEBY, 0, zip64);
1312 }
1313
1314 extern int ZEXPORT zipOpenNewFileInZip2(zipFile file, const char* filename, const zip_fileinfo* zipfi,
1315 const void* extrafield_local, uInt size_extrafield_local,
1316 const void* extrafield_global, uInt size_extrafield_global,
1317 const char* comment, int method, int level, int raw)
1318 {
1319 return zipOpenNewFileInZip4_64 (file, filename, zipfi,
1320 extrafield_local, size_extrafield_local,
1321 extrafield_global, size_extrafield_global,
1322 comment, method, level, raw,
1323 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
1324 NULL, 0, VERSIONMADEBY, 0, 0);
1325 }
1326
1327 extern int ZEXPORT zipOpenNewFileInZip2_64(zipFile file, const char* filename, const zip_fileinfo* zipfi,
1328 const void* extrafield_local, uInt size_extrafield_local,
1329 const void* extrafield_global, uInt size_extrafield_global,
1330 const char* comment, int method, int level, int raw, int zip64)
1331 {
1332 return zipOpenNewFileInZip4_64 (file, filename, zipfi,
1333 extrafield_local, size_extrafield_local,
1334 extrafield_global, size_extrafield_global,
1335 comment, method, level, raw,
1336 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
1337 NULL, 0, VERSIONMADEBY, 0, zip64);
1338 }
1339
1340 extern int ZEXPORT zipOpenNewFileInZip64 (zipFile file, const char* filename, const zip_fileinfo* zipfi,
1341 const void* extrafield_local, uInt size_extrafield_local,
1342 const void*extrafield_global, uInt size_extrafield_global,
1343 const char* comment, int method, int level, int zip64)
1344 {
1345 return zipOpenNewFileInZip4_64 (file, filename, zipfi,
1346 extrafield_local, size_extrafield_local,
1347 extrafield_global, size_extrafield_global,
1348 comment, method, level, 0,
1349 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
1350 NULL, 0, VERSIONMADEBY, 0, zip64);
1351 }
1352
1353 extern int ZEXPORT zipOpenNewFileInZip (zipFile file, const char* filename, const zip_fileinfo* zipfi,
1354 const void* extrafield_local, uInt size_extrafield_local,
1355 const void*extrafield_global, uInt size_extrafield_global,
1356 const char* comment, int method, int level)
1357 {
1358 return zipOpenNewFileInZip4_64 (file, filename, zipfi,
1359 extrafield_local, size_extrafield_local,
1360 extrafield_global, size_extrafield_global,
1361 comment, method, level, 0,
1362 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
1363 NULL, 0, VERSIONMADEBY, 0, 0);
1364 }
1365
1366 local int zip64FlushWriteBuffer(zip64_internal* zi)
1367 {
1368 int err=ZIP_OK;
1369
1370 if (zi->ci.encrypt != 0)
1371 {
1372 #ifndef NOCRYPT
1373 uInt i;
1374 int t;
1375 for (i=0;i<zi->ci.pos_in_buffered_data;i++)
1376 zi->ci.buffered_data[i] = zencode(zi->ci.keys, zi->ci.pcrc_32_tab, zi->ci.buffered_data[i],t);
1377 #endif
1378 }
1379
1380 if (ZWRITE64(zi->z_filefunc,zi->filestream,zi->ci.buffered_data,zi->ci.pos_in_buffered_data) != zi->ci.pos_in_buffered_data)
1381 err = ZIP_ERRNO;
1382
1383 zi->ci.totalCompressedData += zi->ci.pos_in_buffered_data;
1384
1385 #ifdef HAVE_BZIP2
1386 if(zi->ci.method == Z_BZIP2ED)
1387 {
1388 zi->ci.totalUncompressedData += zi->ci.bstream.total_in_lo32;
1389 zi->ci.bstream.total_in_lo32 = 0;
1390 zi->ci.bstream.total_in_hi32 = 0;
1391 }
1392 else
1393 #endif
1394 {
1395 zi->ci.totalUncompressedData += zi->ci.stream.total_in;
1396 zi->ci.stream.total_in = 0;
1397 }
1398
1399
1400 zi->ci.pos_in_buffered_data = 0;
1401
1402 return err;
1403 }
1404
1405 extern int ZEXPORT zipWriteInFileInZip (zipFile file,const void* buf,unsigned int len)
1406 {
1407 zip64_internal* zi;
1408 int err=ZIP_OK;
1409
1410 if (file == NULL)
1411 return ZIP_PARAMERROR;
1412 zi = (zip64_internal*)file;
1413
1414 if (zi->in_opened_file_inzip == 0)
1415 return ZIP_PARAMERROR;
1416
1417 zi->ci.crc32 = crc32(zi->ci.crc32,buf,(uInt)len);
1418
1419 #ifdef HAVE_BZIP2
1420 if(zi->ci.method == Z_BZIP2ED && (!zi->ci.raw))
1421 {
1422 zi->ci.bstream.next_in = (void*)buf;
1423 zi->ci.bstream.avail_in = len;
1424 err = BZ_RUN_OK;
1425
1426 while ((err==BZ_RUN_OK) && (zi->ci.bstream.avail_in>0))
1427 {
1428 if (zi->ci.bstream.avail_out == 0)
1429 {
1430 if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO)
1431 err = ZIP_ERRNO;
1432 zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE;
1433 zi->ci.bstream.next_out = (char*)zi->ci.buffered_data;
1434 }
1435
1436
1437 if(err != BZ_RUN_OK)
1438 break;
1439
1440 if ((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw))
1441 {
1442 uLong uTotalOutBefore_lo = zi->ci.bstream.total_out_lo32;
1443 // uLong uTotalOutBefore_hi = zi->ci.bstream.total_out_hi32;
1444 err=BZ2_bzCompress(&zi->ci.bstream, BZ_RUN);
1445
1446 zi->ci.pos_in_buffered_data += (uInt)(zi->ci.bstream.total_out_lo32 - uTotalOutBefore_lo) ;
1447 }
1448 }
1449
1450 if(err == BZ_RUN_OK)
1451 err = ZIP_OK;
1452 }
1453 else
1454 #endif
1455 {
1456 zi->ci.stream.next_in = (Bytef*)buf;
1457 zi->ci.stream.avail_in = len;
1458
1459 while ((err==ZIP_OK) && (zi->ci.stream.avail_in>0))
1460 {
1461 if (zi->ci.stream.avail_out == 0)
1462 {
1463 if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO)
1464 err = ZIP_ERRNO;
1465 zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
1466 zi->ci.stream.next_out = zi->ci.buffered_data;
1467 }
1468
1469
1470 if(err != ZIP_OK)
1471 break;
1472
1473 if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
1474 {
1475 uLong uTotalOutBefore = zi->ci.stream.total_out;
1476 err=deflate(&zi->ci.stream, Z_NO_FLUSH);
1477 if(uTotalOutBefore > zi->ci.stream.total_out)
1478 {
1479 int bBreak = 0;
1480 bBreak++;
1481 }
1482
1483 zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
1484 }
1485 else
1486 {
1487 uInt copy_this,i;
1488 if (zi->ci.stream.avail_in < zi->ci.stream.avail_out)
1489 copy_this = zi->ci.stream.avail_in;
1490 else
1491 copy_this = zi->ci.stream.avail_out;
1492
1493 for (i = 0; i < copy_this; i++)
1494 *(((char*)zi->ci.stream.next_out)+i) =
1495 *(((const char*)zi->ci.stream.next_in)+i);
1496 {
1497 zi->ci.stream.avail_in -= copy_this;
1498 zi->ci.stream.avail_out-= copy_this;
1499 zi->ci.stream.next_in+= copy_this;
1500 zi->ci.stream.next_out+= copy_this;
1501 zi->ci.stream.total_in+= copy_this;
1502 zi->ci.stream.total_out+= copy_this;
1503 zi->ci.pos_in_buffered_data += copy_this;
1504 }
1505 }
1506 }// while(...)
1507 }
1508
1509 return err;
1510 }
1511
1512 extern int ZEXPORT zipCloseFileInZipRaw (zipFile file, uLong uncompressed_size, uLong crc32)
1513 {
1514 return zipCloseFileInZipRaw64 (file, uncompressed_size, crc32);
1515 }
1516
1517 extern int ZEXPORT zipCloseFileInZipRaw64 (zipFile file, ZPOS64_T uncompressed_size, uLong crc32)
1518 {
1519 zip64_internal* zi;
1520 ZPOS64_T compressed_size;
1521 uLong invalidValue = 0xffffffff;
1522 short datasize = 0;
1523 int err=ZIP_OK;
1524
1525 if (file == NULL)
1526 return ZIP_PARAMERROR;
1527 zi = (zip64_internal*)file;
1528
1529 if (zi->in_opened_file_inzip == 0)
1530 return ZIP_PARAMERROR;
1531 zi->ci.stream.avail_in = 0;
1532
1533 if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
1534 {
1535 while (err==ZIP_OK)
1536 {
1537 uLong uTotalOutBefore;
1538 if (zi->ci.stream.avail_out == 0)
1539 {
1540 if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO)
1541 err = ZIP_ERRNO;
1542 zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
1543 zi->ci.stream.next_out = zi->ci.buffered_data;
1544 }
1545 uTotalOutBefore = zi->ci.stream.total_out;
1546 err=deflate(&zi->ci.stream, Z_FINISH);
1547 zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
1548 }
1549 }
1550 else if ((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw))
1551 {
1552 #ifdef HAVE_BZIP2
1553 err = BZ_FINISH_OK;
1554 while (err==BZ_FINISH_OK)
1555 {
1556 uLong uTotalOutBefore;
1557 if (zi->ci.bstream.avail_out == 0)
1558 {
1559 if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO)
1560 err = ZIP_ERRNO;
1561 zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE;
1562 zi->ci.bstream.next_out = (char*)zi->ci.buffered_data;
1563 }
1564 uTotalOutBefore = zi->ci.bstream.total_out_lo32;
1565 err=BZ2_bzCompress(&zi->ci.bstream, BZ_FINISH);
1566 if(err == BZ_STREAM_END)
1567 err = Z_STREAM_END;
1568
1569 zi->ci.pos_in_buffered_data += (uInt)(zi->ci.bstream.total_out_lo32 - uTotalOutBefore);
1570 }
1571
1572 if(err == BZ_FINISH_OK)
1573 err = ZIP_OK;
1574 #endif
1575 }
1576
1577 if (err==Z_STREAM_END)
1578 err=ZIP_OK; /* this is normal */
1579
1580 if ((zi->ci.pos_in_buffered_data>0) && (err==ZIP_OK))
1581 {
1582 if (zip64FlushWriteBuffer(zi)==ZIP_ERRNO)
1583 err = ZIP_ERRNO;
1584 }
1585
1586 if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
1587 {
1588 int tmp_err = deflateEnd(&zi->ci.stream);
1589 if (err == ZIP_OK)
1590 err = tmp_err;
1591 zi->ci.stream_initialised = 0;
1592 }
1593 #ifdef HAVE_BZIP2
1594 else if((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw))
1595 {
1596 int tmperr = BZ2_bzCompressEnd(&zi->ci.bstream);
1597 if (err==ZIP_OK)
1598 err = tmperr;
1599 zi->ci.stream_initialised = 0;
1600 }
1601 #endif
1602
1603 if (!zi->ci.raw)
1604 {
1605 crc32 = (uLong)zi->ci.crc32;
1606 uncompressed_size = zi->ci.totalUncompressedData;
1607 }
1608 compressed_size = zi->ci.totalCompressedData;
1609
1610 # ifndef NOCRYPT
1611 compressed_size += zi->ci.crypt_header_size;
1612 # endif
1613
1614 // update Current Item crc and sizes,
1615 if(compressed_size >= 0xffffffff || uncompressed_size >= 0xffffffff || zi->ci.pos_local_header >= 0xffffffff)
1616 {
1617 /*version Made by*/
1618 zip64local_putValue_inmemory(zi->ci.central_header+4,(uLong)45,2);
1619 /*version needed*/
1620 zip64local_putValue_inmemory(zi->ci.central_header+6,(uLong)45,2);
1621
1622 }
1623
1624 zip64local_putValue_inmemory(zi->ci.central_header+16,crc32,4); /*crc*/
1625
1626
1627 if(compressed_size >= 0xffffffff)
1628 zip64local_putValue_inmemory(zi->ci.central_header+20, invalidValue,4); /*compr size*/
1629 else
1630 zip64local_putValue_inmemory(zi->ci.central_header+20, compressed_size,4); /*compr size*/
1631
1632 /// set internal file attributes field
1633 if (zi->ci.stream.data_type == Z_ASCII)
1634 zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)Z_ASCII,2);
1635
1636 if(uncompressed_size >= 0xffffffff)
1637 zip64local_putValue_inmemory(zi->ci.central_header+24, invalidValue,4); /*uncompr size*/
1638 else
1639 zip64local_putValue_inmemory(zi->ci.central_header+24, uncompressed_size,4); /*uncompr size*/
1640
1641 // Add ZIP64 extra info field for uncompressed size
1642 if(uncompressed_size >= 0xffffffff)
1643 datasize += 8;
1644
1645 // Add ZIP64 extra info field for compressed size
1646 if(compressed_size >= 0xffffffff)
1647 datasize += 8;
1648
1649 // Add ZIP64 extra info field for relative offset to local file header of current file
1650 if(zi->ci.pos_local_header >= 0xffffffff)
1651 datasize += 8;
1652
1653 if(datasize > 0)
1654 {
1655 char* p = NULL;
1656
1657 if((uLong)(datasize + 4) > zi->ci.size_centralExtraFree)
1658 {
1659 // we can not write more data to the buffer that we have room for.
1660 return ZIP_BADZIPFILE;
1661 }
1662
1663 p = zi->ci.central_header + zi->ci.size_centralheader;
1664
1665 // Add Extra Information Header for 'ZIP64 information'
1666 zip64local_putValue_inmemory(p, 0x0001, 2); // HeaderID
1667 p += 2;
1668 zip64local_putValue_inmemory(p, datasize, 2); // DataSize
1669 p += 2;
1670
1671 if(uncompressed_size >= 0xffffffff)
1672 {
1673 zip64local_putValue_inmemory(p, uncompressed_size, 8);
1674 p += 8;
1675 }
1676
1677 if(compressed_size >= 0xffffffff)
1678 {
1679 zip64local_putValue_inmemory(p, compressed_size, 8);
1680 p += 8;
1681 }
1682
1683 if(zi->ci.pos_local_header >= 0xffffffff)
1684 {
1685 zip64local_putValue_inmemory(p, zi->ci.pos_local_header, 8);
1686 p += 8;
1687 }
1688
1689 // Update how much extra free space we got in the memory buffer
1690 // and increase the centralheader size so the new ZIP64 fields are included
1691 // ( 4 below is the size of HeaderID and DataSize field )
1692 zi->ci.size_centralExtraFree -= datasize + 4;
1693 zi->ci.size_centralheader += datasize + 4;
1694
1695 // Update the extra info size field
1696 zi->ci.size_centralExtra += datasize + 4;
1697 zip64local_putValue_inmemory(zi->ci.central_header+30,(uLong)zi->ci.size_centralExtra,2);
1698 }
1699
1700 if (err==ZIP_OK)
1701 err = add_data_in_datablock(&zi->central_dir, zi->ci.central_header, (uLong)zi->ci.size_centralheader);
1702
1703 free(zi->ci.central_header);
1704
1705 if (err==ZIP_OK)
1706 {
1707 // Update the LocalFileHeader with the new values.
1708
1709 ZPOS64_T cur_pos_inzip = ZTELL64(zi->z_filefunc,zi->filestream);
1710
1711 if (ZSEEK64(zi->z_filefunc,zi->filestream, zi->ci.pos_local_header + 14,ZLIB_FILEFUNC_SEEK_SET)!=0)
1712 err = ZIP_ERRNO;
1713
1714 if (err==ZIP_OK)
1715 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,crc32,4); /* crc 32, unknown */
1716
1717 if(uncompressed_size >= 0xffffffff || compressed_size >= 0xffffffff )
1718 {
1719 if(zi->ci.pos_zip64extrainfo > 0)
1720 {
1721 // Update the size in the ZIP64 extended field.
1722 if (ZSEEK64(zi->z_filefunc,zi->filestream, zi->ci.pos_zip64extrainfo + 4,ZLIB_FILEFUNC_SEEK_SET)!=0)
1723 err = ZIP_ERRNO;
1724
1725 if (err==ZIP_OK) /* compressed size, unknown */
1726 err = zip64local_putValue(&zi->z_filefunc, zi->filestream, uncompressed_size, 8);
1727
1728 if (err==ZIP_OK) /* uncompressed size, unknown */
1729 err = zip64local_putValue(&zi->z_filefunc, zi->filestream, compressed_size, 8);
1730 }
1731 else
1732 err = ZIP_BADZIPFILE; // Caller passed zip64 = 0, so no room for zip64 info -> fatal
1733 }
1734 else
1735 {
1736 if (err==ZIP_OK) /* compressed size, unknown */
1737 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,compressed_size,4);
1738
1739 if (err==ZIP_OK) /* uncompressed size, unknown */
1740 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,uncompressed_size,4);
1741 }
1742
1743 if (ZSEEK64(zi->z_filefunc,zi->filestream, cur_pos_inzip,ZLIB_FILEFUNC_SEEK_SET)!=0)
1744 err = ZIP_ERRNO;
1745 }
1746
1747 zi->number_entry ++;
1748 zi->in_opened_file_inzip = 0;
1749
1750 return err;
1751 }
1752
1753 extern int ZEXPORT zipCloseFileInZip (zipFile file)
1754 {
1755 return zipCloseFileInZipRaw (file,0,0);
1756 }
1757
1758 int Write_Zip64EndOfCentralDirectoryLocator(zip64_internal* zi, ZPOS64_T zip64eocd_pos_inzip)
1759 {
1760 int err = ZIP_OK;
1761 ZPOS64_T pos = zip64eocd_pos_inzip - zi->add_position_when_writting_offset;
1762
1763 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ZIP64ENDLOCHEADERMAGIC,4);
1764
1765 /*num disks*/
1766 if (err==ZIP_OK) /* number of the disk with the start of the central directory */
1767 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4);
1768
1769 /*relative offset*/
1770 if (err==ZIP_OK) /* Relative offset to the Zip64EndOfCentralDirectory */
1771 err = zip64local_putValue(&zi->z_filefunc,zi->filestream, pos,8);
1772
1773 /*total disks*/ /* Do not support spawning of disk so always say 1 here*/
1774 if (err==ZIP_OK) /* number of the disk with the start of the central directory */
1775 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)1,4);
1776
1777 return err;
1778 }
1779
1780 int Write_Zip64EndOfCentralDirectoryRecord(zip64_internal* zi, uLong size_centraldir, ZPOS64_T centraldir_pos_inzip)
1781 {
1782 int err = ZIP_OK;
1783
1784 uLong Zip64DataSize = 44;
1785
1786 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ZIP64ENDHEADERMAGIC,4);
1787
1788 if (err==ZIP_OK) /* size of this 'zip64 end of central directory' */
1789 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(ZPOS64_T)Zip64DataSize,8); // why ZPOS64_T of this ?
1790
1791 if (err==ZIP_OK) /* version made by */
1792 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2);
1793
1794 if (err==ZIP_OK) /* version needed */
1795 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2);
1796
1797 if (err==ZIP_OK) /* number of this disk */
1798 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4);
1799
1800 if (err==ZIP_OK) /* number of the disk with the start of the central directory */
1801 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4);
1802
1803 if (err==ZIP_OK) /* total number of entries in the central dir on this disk */
1804 err = zip64local_putValue(&zi->z_filefunc, zi->filestream, zi->number_entry, 8);
1805
1806 if (err==ZIP_OK) /* total number of entries in the central dir */
1807 err = zip64local_putValue(&zi->z_filefunc, zi->filestream, zi->number_entry, 8);
1808
1809 if (err==ZIP_OK) /* size of the central directory */
1810 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(ZPOS64_T)size_centraldir,8);
1811
1812 if (err==ZIP_OK) /* offset of start of central directory with respect to the starting disk number */
1813 {
1814 ZPOS64_T pos = centraldir_pos_inzip - zi->add_position_when_writting_offset;
1815 err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (ZPOS64_T)pos,8);
1816 }
1817 return err;
1818 }
1819 int Write_EndOfCentralDirectoryRecord(zip64_internal* zi, uLong size_centraldir, ZPOS64_T centraldir_pos_inzip)
1820 {
1821 int err = ZIP_OK;
1822
1823 /*signature*/
1824 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ENDHEADERMAGIC,4);
1825
1826 if (err==ZIP_OK) /* number of this disk */
1827 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);
1828
1829 if (err==ZIP_OK) /* number of the disk with the start of the central directory */
1830 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);
1831
1832 if (err==ZIP_OK) /* total number of entries in the central dir on this disk */
1833 {
1834 {
1835 if(zi->number_entry >= 0xFFFF)
1836 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xffff,2); // use value in ZIP64 record
1837 else
1838 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
1839 }
1840 }
1841
1842 if (err==ZIP_OK) /* total number of entries in the central dir */
1843 {
1844 if(zi->number_entry >= 0xFFFF)
1845 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xffff,2); // use value in ZIP64 record
1846 else
1847 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
1848 }
1849
1850 if (err==ZIP_OK) /* size of the central directory */
1851 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_centraldir,4);
1852
1853 if (err==ZIP_OK) /* offset of start of central directory with respect to the starting disk number */
1854 {
1855 ZPOS64_T pos = centraldir_pos_inzip - zi->add_position_when_writting_offset;
1856 if(pos >= 0xffffffff)
1857 {
1858 err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (uLong)0xffffffff,4);
1859 }
1860 else
1861 err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (uLong)(centraldir_pos_inzip - zi->add_position_when_writting_offset),4);
1862 }
1863
1864 return err;
1865 }
1866
1867 int Write_GlobalComment(zip64_internal* zi, const char* global_comment)
1868 {
1869 int err = ZIP_OK;
1870 uInt size_global_comment = 0;
1871
1872 if(global_comment != NULL)
1873 size_global_comment = (uInt)strlen(global_comment);
1874
1875 err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_global_comment,2);
1876
1877 if (err == ZIP_OK && size_global_comment > 0)
1878 {
1879 if (ZWRITE64(zi->z_filefunc,zi->filestream, global_comment, size_global_comment) != size_global_comment)
1880 err = ZIP_ERRNO;
1881 }
1882 return err;
1883 }
1884
1885 extern int ZEXPORT zipClose (zipFile file, const char* global_comment)
1886 {
1887 zip64_internal* zi;
1888 int err = 0;
1889 uLong size_centraldir = 0;
1890 ZPOS64_T centraldir_pos_inzip;
1891 ZPOS64_T pos;
1892
1893 if (file == NULL)
1894 return ZIP_PARAMERROR;
1895
1896 zi = (zip64_internal*)file;
1897
1898 if (zi->in_opened_file_inzip == 1)
1899 {
1900 err = zipCloseFileInZip (file);
1901 }
1902
1903 #ifndef NO_ADDFILEINEXISTINGZIP
1904 if (global_comment==NULL)
1905 global_comment = zi->globalcomment;
1906 #endif
1907
1908 centraldir_pos_inzip = ZTELL64(zi->z_filefunc,zi->filestream);
1909
1910 if (err==ZIP_OK)
1911 {
1912 linkedlist_datablock_internal* ldi = zi->central_dir.first_block;
1913 while (ldi!=NULL)
1914 {
1915 if ((err==ZIP_OK) && (ldi->filled_in_this_block>0))
1916 {
1917 if (ZWRITE64(zi->z_filefunc,zi->filestream, ldi->data, ldi->filled_in_this_block) != ldi->filled_in_this_block)
1918 err = ZIP_ERRNO;
1919 }
1920
1921 size_centraldir += ldi->filled_in_this_block;
1922 ldi = ldi->next_datablock;
1923 }
1924 }
1925 free_linkedlist(&(zi->central_dir));
1926
1927 pos = centraldir_pos_inzip - zi->add_position_when_writting_offset;
1928 if(pos >= 0xffffffff || zi->number_entry > 0xFFFF)
1929 {
1930 ZPOS64_T Zip64EOCDpos = ZTELL64(zi->z_filefunc,zi->filestream);
1931 Write_Zip64EndOfCentralDirectoryRecord(zi, size_centraldir, centraldir_pos_inzip);
1932
1933 Write_Zip64EndOfCentralDirectoryLocator(zi, Zip64EOCDpos);
1934 }
1935
1936 if (err==ZIP_OK)
1937 err = Write_EndOfCentralDirectoryRecord(zi, size_centraldir, centraldir_pos_inzip);
1938
1939 if(err == ZIP_OK)
1940 err = Write_GlobalComment(zi, global_comment);
1941
1942 if (ZCLOSE64(zi->z_filefunc,zi->filestream) != 0)
1943 if (err == ZIP_OK)
1944 err = ZIP_ERRNO;
1945
1946 #ifndef NO_ADDFILEINEXISTINGZIP
1947 TRYFREE(zi->globalcomment);
1948 #endif
1949 TRYFREE(zi);
1950
1951 return err;
1952 }
1953
1954 extern int ZEXPORT zipRemoveExtraInfoBlock (char* pData, int* dataLen, short sHeader)
1955 {
1956 char* p = pData;
1957 int size = 0;
1958 char* pNewHeader;
1959 char* pTmp;
1960 short header;
1961 short dataSize;
1962
1963 int retVal = ZIP_OK;
1964
1965 if(pData == NULL || *dataLen < 4)
1966 return ZIP_PARAMERROR;
1967
1968 pNewHeader = (char*)ALLOC(*dataLen);
1969 pTmp = pNewHeader;
1970
1971 while(p < (pData + *dataLen))
1972 {
1973 header = *(short*)p;
1974 dataSize = *(((short*)p)+1);
1975
1976 if( header == sHeader ) // Header found.
1977 {
1978 p += dataSize + 4; // skip it. do not copy to temp buffer
1979 }
1980 else
1981 {
1982 // Extra Info block should not be removed, So copy it to the temp buffer.
1983 memcpy(pTmp, p, dataSize + 4);
1984 p += dataSize + 4;
1985 size += dataSize + 4;
1986 }
1987
1988 }
1989
1990 if(size < *dataLen)
1991 {
1992 // clean old extra info block.
1993 memset(pData,0, *dataLen);
1994
1995 // copy the new extra info block over the old
1996 if(size > 0)
1997 memcpy(pData, pNewHeader, size);
1998
1999 // set the new extra info size
2000 *dataLen = size;
2001
2002 retVal = ZIP_OK;
2003 }
2004 else
2005 retVal = ZIP_ERRNO;
2006
2007 TRYFREE(pNewHeader);
2008
2009 return retVal;
2010 }
Enhanced version of Cockos' IPlug - A simple-to-use C++ framework for developing cross platform audio plugins and targeting multiple plugin APIs with the same code. VST / VST3 / Audiounit / RTAS / AAX (Native) formats supported. (git mirror)