Home | History | Annotate | Download | only in minizip
      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 
     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
     98 const 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 
    114 typedef 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 alignement */
    120   unsigned char data[SIZEDATA_INDATABLOCK];
    121 } linkedlist_datablock_internal;
    122 
    123 typedef struct linkedlist_data_s
    124 {
    125     linkedlist_datablock_internal* first_block;
    126     linkedlist_datablock_internal* last_block;
    127 } linkedlist_data;
    128 
    129 
    130 typedef 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 unsigned long* pcrc_32_tab;
    161     int crypt_header_size;
    162 #endif
    163 } curfile64_info;
    164 
    165 typedef 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_writting_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 
    189 local 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 
    203 local 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 
    213 local void init_linkedlist(linkedlist_data* ll)
    214 {
    215     ll->first_block = ll->last_block = NULL;
    216 }
    217 
    218 local void free_linkedlist(linkedlist_data* ll)
    219 {
    220     free_datablock(ll->first_block);
    221     ll->first_block = ll->last_block = NULL;
    222 }
    223 
    224 
    225 local 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 
    286 local int zip64local_putValue OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T x, int nbByte));
    287 local 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 
    310 local void zip64local_putValue_inmemory OF((void* dest, ZPOS64_T x, int nbByte));
    311 local 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 
    332 local 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 
    347 local int zip64local_getByte OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, int *pi));
    348 
    349 local 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 */
    371 local int zip64local_getShort OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong *pX));
    372 
    373 local 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 
    393 local int zip64local_getLong OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong *pX));
    394 
    395 local 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 
    423 local int zip64local_getLong64 OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T *pX));
    424 
    425 
    426 local 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 */
    478 local ZPOS64_T zip64local_SearchCentralDir OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream));
    479 
    480 local 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 /*
    537 Locate the End of Zip64 Central directory locator and from there find the CD of a zipfile (at the end, just before
    538 the global comment)
    539 */
    540 local ZPOS64_T zip64local_SearchCentralDir64 OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream));
    541 
    542 local 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 
    640 int 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_writting_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 /************************************************************/
    849 extern 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_writting_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 
    920 extern 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 
    932 extern 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 
    948 extern zipFile ZEXPORT zipOpen (const char* pathname, int append)
    949 {
    950     return zipOpen3((const void*)pathname,append,NULL,NULL);
    951 }
    952 
    953 extern zipFile ZEXPORT zipOpen64 (const void* pathname, int append)
    954 {
    955     return zipOpen3(pathname,append,NULL,NULL);
    956 }
    957 
    958 int 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  */
   1055 extern 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_writting_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 
   1265 extern 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 
   1281 extern 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 
   1296 extern 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 
   1311 extern 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 
   1324 extern 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 
   1337 extern 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 
   1350 extern 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 
   1363 local 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 
   1402 extern 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 
   1509 extern int ZEXPORT zipCloseFileInZipRaw (zipFile file, uLong uncompressed_size, uLong crc32)
   1510 {
   1511     return zipCloseFileInZipRaw64 (file, uncompressed_size, crc32);
   1512 }
   1513 
   1514 extern 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 
   1750 extern int ZEXPORT zipCloseFileInZip (zipFile file)
   1751 {
   1752     return zipCloseFileInZipRaw (file,0,0);
   1753 }
   1754 
   1755 int 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_writting_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 
   1777 int 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_writting_offset;
   1812     err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (ZPOS64_T)pos,8);
   1813   }
   1814   return err;
   1815 }
   1816 int 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_writting_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_writting_offset),4);
   1859   }
   1860 
   1861    return err;
   1862 }
   1863 
   1864 int 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 
   1882 extern 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_writting_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 
   1951 extern 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