src/support/minizip/zip.c

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