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