source/mupen64launcher/src/unzip/unzip.c

   1 /* unzip.c -- IO for uncompress .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 of Unzip for Zip64
   8          Copyright (C) 2007-2008 Even Rouault
   9
  10          Modifications for Zip64 support on both zip and unzip
  11          Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
  12
  13          For more info read MiniZip_info.txt
  14
  15
  16   ------------------------------------------------------------------------------------
  17   Decryption code comes from crypt.c by Info-ZIP but has been greatly reduced in terms of
  18   compatibility with older software. The following is from the original crypt.c.
  19   Code woven in by Terry Thorsen 1/2003.
  20
  21   Copyright (c) 1990-2000 Info-ZIP.  All rights reserved.
  22
  23   See the accompanying file LICENSE, version 2000-Apr-09 or later
  24   (the contents of which are also included in zip.h) for terms of use.
  25   If, for some reason, all these files are missing, the Info-ZIP license
  26   also may be found at:  ftp://ftp.info-zip.org/pub/infozip/license.html
  27
  28         crypt.c (full version) by Info-ZIP.      Last revised:  [see crypt.h]
  29
  30   The encryption/decryption parts of this source code (as opposed to the
  31   non-echoing password parts) were originally written in Europe.  The
  32   whole source package can be freely distributed, including from the USA.
  33   (Prior to January 2000, re-export from the US was a violation of US law.)
  34
  35         This encryption code is a direct transcription of the algorithm from
  36   Roger Schlafly, described by Phil Katz in the file appnote.txt.  This
  37   file (appnote.txt) is distributed with the PKZIP program (even in the
  38   version without encryption capabilities).
  39
  40         ------------------------------------------------------------------------------------
  41
  42         Changes in unzip.c
  43
  44         2007-2008 - Even Rouault - Addition of cpl_unzGetCurrentFileZStreamPos
  45   2007-2008 - Even Rouault - Decoration of symbol names unz* -> cpl_unz*
  46   2007-2008 - Even Rouault - Remove old C style function prototypes
  47   2007-2008 - Even Rouault - Add unzip support for ZIP64
  48
  49         Copyright (C) 2007-2008 Even Rouault
  50
  51
  52         Oct-2009 - Mathias Svensson - Removed cpl_* from symbol names (Even Rouault added them but since this is now moved to a new project (minizip64) I renamed them again).
  53   Oct-2009 - Mathias Svensson - Fixed problem if uncompressed size was > 4G and compressed size was <4G
  54                                 should only read the compressed/uncompressed size from the Zip64 format if
  55                                 the size from normal header was 0xFFFFFFFF
  56   Oct-2009 - Mathias Svensson - Applied some bug fixes from paches recived from Gilles Vollant
  57         Oct-2009 - Mathias Svensson - Applied support to unzip files with compression mathod BZIP2 (bzip2 lib is required)
  58                                 Patch created by Daniel Borca
  59
  60   Jan-2010 - back to unzip and minizip 1.0 name scheme, with compatibility layer
  61
  62   Copyright (C) 1998 - 2010 Gilles Vollant, Even Rouault, Mathias Svensson
  63
  64 */
  65
  66
  67 #include <stdio.h>
  68 #include <stdlib.h>
  69 #include <string.h>
  70
  71 #ifndef NOUNCRYPT
  72         #define NOUNCRYPT
  73 #endif
  74
  75 #include "zlib.h"
  76 #include "unzip.h"
  77
  78 #ifdef STDC
  79 #  include <stddef.h>
  80 #  include <string.h>
  81 #  include <stdlib.h>
  82 #endif
  83 #ifdef NO_ERRNO_H
  84     extern int errno;
  85 #else
  86 #   include <errno.h>
  87 #endif
  88
  89
  90 #ifndef local
  91 #  define local static
  92 #endif
  93 /* compile with -Dlocal if your debugger can't find static symbols */
  94
  95
  96 #ifndef CASESENSITIVITYDEFAULT_NO
  97 #  if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES)
  98 #    define CASESENSITIVITYDEFAULT_NO
  99 #  endif
 100 #endif
 101
 102
 103 #ifndef UNZ_BUFSIZE
 104 #define UNZ_BUFSIZE (16384)
 105 #endif
 106
 107 #ifndef UNZ_MAXFILENAMEINZIP
 108 #define UNZ_MAXFILENAMEINZIP (256)
 109 #endif
 110
 111 #ifndef ALLOC
 112 # define ALLOC(size) (malloc(size))
 113 #endif
 114 #ifndef TRYFREE
 115 # define TRYFREE(p) {if (p) free(p);}
 116 #endif
 117
 118 #define SIZECENTRALDIRITEM (0x2e)
 119 #define SIZEZIPLOCALHEADER (0x1e)
 120
 121
 122 const char unz_copyright[] =
 123    " unzip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll";
 124
 125 /* unz_file_info_interntal contain internal info about a file in zipfile*/
 126 typedef struct unz_file_info64_internal_s
 127 {
 128     ZPOS64_T offset_curfile;/* relative offset of local header 8 bytes */
 129 } unz_file_info64_internal;
 130
 131
 132 /* file_in_zip_read_info_s contain internal information about a file in zipfile,
 133     when reading and decompress it */
 134 typedef struct
 135 {
 136     char  *read_buffer;         /* internal buffer for compressed data */
 137     z_stream stream;            /* zLib stream structure for inflate */
 138
 139 #ifdef HAVE_BZIP2
 140     bz_stream bstream;          /* bzLib stream structure for bziped */
 141 #endif
 142
 143     ZPOS64_T pos_in_zipfile;       /* position in byte on the zipfile, for fseek*/
 144     uLong stream_initialised;   /* flag set if stream structure is initialised*/
 145
 146     ZPOS64_T offset_local_extrafield;/* offset of the local extra field */
 147     uInt  size_local_extrafield;/* size of the local extra field */
 148     ZPOS64_T pos_local_extrafield;   /* position in the local extra field in read*/
 149     ZPOS64_T total_out_64;
 150
 151     uLong crc32;                /* crc32 of all data uncompressed */
 152     uLong crc32_wait;           /* crc32 we must obtain after decompress all */
 153     ZPOS64_T rest_read_compressed; /* number of byte to be decompressed */
 154     ZPOS64_T rest_read_uncompressed;/*number of byte to be obtained after decomp*/
 155     zlib_filefunc64_32_def z_filefunc;
 156     voidpf filestream;        /* io structore of the zipfile */
 157     uLong compression_method;   /* compression method (0==store) */
 158     ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
 159     int   raw;
 160 } file_in_zip64_read_info_s;
 161
 162
 163 /* unz64_s contain internal information about the zipfile
 164 */
 165 typedef struct
 166 {
 167     zlib_filefunc64_32_def z_filefunc;
 168     int is64bitOpenFunction;
 169     voidpf filestream;        /* io structore of the zipfile */
 170     unz_global_info64 gi;       /* public global information */
 171     ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
 172     ZPOS64_T num_file;             /* number of the current file in the zipfile*/
 173     ZPOS64_T pos_in_central_dir;   /* pos of the current file in the central dir*/
 174     ZPOS64_T current_file_ok;      /* flag about the usability of the current file*/
 175     ZPOS64_T central_pos;          /* position of the beginning of the central dir*/
 176
 177     ZPOS64_T size_central_dir;     /* size of the central directory  */
 178     ZPOS64_T offset_central_dir;   /* offset of start of central directory with
 179                                    respect to the starting disk number */
 180
 181     unz_file_info64 cur_file_info; /* public info about the current file in zip*/
 182     unz_file_info64_internal cur_file_info_internal; /* private info about it*/
 183     file_in_zip64_read_info_s* pfile_in_zip_read; /* structure about the current
 184                                         file if we are decompressing it */
 185     int encrypted;
 186
 187     int isZip64;
 188
 189 #    ifndef NOUNCRYPT
 190     unsigned long keys[3];     /* keys defining the pseudo-random sequence */
 191     const unsigned long* pcrc_32_tab;
 192 #    endif
 193 } unz64_s;
 194
 195
 196 #ifndef NOUNCRYPT
 197 #include "crypt.h"
 198 #endif
 199
 200 /* ===========================================================================
 201      Read a byte from a gz_stream; update next_in and avail_in. Return EOF
 202    for end of file.
 203    IN assertion: the stream s has been sucessfully opened for reading.
 204 */
 205
 206
 207 local int unz64local_getByte OF((
 208     const zlib_filefunc64_32_def* pzlib_filefunc_def,
 209     voidpf filestream,
 210     int *pi));
 211
 212 local int unz64local_getByte(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, int *pi)
 213 {
 214     unsigned char c;
 215     int err = (int)ZREAD64(*pzlib_filefunc_def,filestream,&c,1);
 216     if (err==1)
 217     {
 218         *pi = (int)c;
 219         return UNZ_OK;
 220     }
 221     else
 222     {
 223         if (ZERROR64(*pzlib_filefunc_def,filestream))
 224             return UNZ_ERRNO;
 225         else
 226             return UNZ_EOF;
 227     }
 228 }
 229
 230
 231 /* ===========================================================================
 232    Reads a long in LSB order from the given gz_stream. Sets
 233 */
 234 local int unz64local_getShort OF((
 235     const zlib_filefunc64_32_def* pzlib_filefunc_def,
 236     voidpf filestream,
 237     uLong *pX));
 238
 239 local int unz64local_getShort (const zlib_filefunc64_32_def* pzlib_filefunc_def,
 240                              voidpf filestream,
 241                              uLong *pX)
 242 {
 243     uLong x ;
 244     int i = 0;
 245     int err;
 246
 247     err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
 248     x = (uLong)i;
 249
 250     if (err==UNZ_OK)
 251         err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
 252     x |= ((uLong)i)<<8;
 253
 254     if (err==UNZ_OK)
 255         *pX = x;
 256     else
 257         *pX = 0;
 258     return err;
 259 }
 260
 261 local int unz64local_getLong OF((
 262     const zlib_filefunc64_32_def* pzlib_filefunc_def,
 263     voidpf filestream,
 264     uLong *pX));
 265
 266 local int unz64local_getLong (const zlib_filefunc64_32_def* pzlib_filefunc_def,
 267                             voidpf filestream,
 268                             uLong *pX)
 269 {
 270     uLong x ;
 271     int i = 0;
 272     int err;
 273
 274     err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
 275     x = (uLong)i;
 276
 277     if (err==UNZ_OK)
 278         err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
 279     x |= ((uLong)i)<<8;
 280
 281     if (err==UNZ_OK)
 282         err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
 283     x |= ((uLong)i)<<16;
 284
 285     if (err==UNZ_OK)
 286         err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
 287     x += ((uLong)i)<<24;
 288
 289     if (err==UNZ_OK)
 290         *pX = x;
 291     else
 292         *pX = 0;
 293     return err;
 294 }
 295
 296 local int unz64local_getLong64 OF((
 297     const zlib_filefunc64_32_def* pzlib_filefunc_def,
 298     voidpf filestream,
 299     ZPOS64_T *pX));
 300
 301
 302 local int unz64local_getLong64 (const zlib_filefunc64_32_def* pzlib_filefunc_def,
 303                             voidpf filestream,
 304                             ZPOS64_T *pX)
 305 {
 306     ZPOS64_T x ;
 307     int i = 0;
 308     int err;
 309
 310     err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
 311     x = (ZPOS64_T)i;
 312
 313     if (err==UNZ_OK)
 314         err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
 315     x |= ((ZPOS64_T)i)<<8;
 316
 317     if (err==UNZ_OK)
 318         err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
 319     x |= ((ZPOS64_T)i)<<16;
 320
 321     if (err==UNZ_OK)
 322         err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
 323     x |= ((ZPOS64_T)i)<<24;
 324
 325     if (err==UNZ_OK)
 326         err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
 327     x |= ((ZPOS64_T)i)<<32;
 328
 329     if (err==UNZ_OK)
 330         err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
 331     x |= ((ZPOS64_T)i)<<40;
 332
 333     if (err==UNZ_OK)
 334         err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
 335     x |= ((ZPOS64_T)i)<<48;
 336
 337     if (err==UNZ_OK)
 338         err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
 339     x |= ((ZPOS64_T)i)<<56;
 340
 341     if (err==UNZ_OK)
 342         *pX = x;
 343     else
 344         *pX = 0;
 345     return err;
 346 }
 347
 348 /* My own strcmpi / strcasecmp */
 349 local int strcmpcasenosensitive_internal (const char* fileName1, const char* fileName2)
 350 {
 351     for (;;)
 352     {
 353         char c1=*(fileName1++);
 354         char c2=*(fileName2++);
 355         if ((c1>='a') && (c1<='z'))
 356             c1 -= 0x20;
 357         if ((c2>='a') && (c2<='z'))
 358             c2 -= 0x20;
 359         if (c1=='\0')
 360             return ((c2=='\0') ? 0 : -1);
 361         if (c2=='\0')
 362             return 1;
 363         if (c1<c2)
 364             return -1;
 365         if (c1>c2)
 366             return 1;
 367     }
 368 }
 369
 370
 371 #ifdef  CASESENSITIVITYDEFAULT_NO
 372 #define CASESENSITIVITYDEFAULTVALUE 2
 373 #else
 374 #define CASESENSITIVITYDEFAULTVALUE 1
 375 #endif
 376
 377 #ifndef STRCMPCASENOSENTIVEFUNCTION
 378 #define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal
 379 #endif
 380
 381 /*
 382    Compare two filename (fileName1,fileName2).
 383    If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
 384    If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
 385                                                                 or strcasecmp)
 386    If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
 387         (like 1 on Unix, 2 on Windows)
 388
 389 */
 390 extern int ZEXPORT unzStringFileNameCompare (const char*  fileName1,
 391                                                  const char*  fileName2,
 392                                                  int iCaseSensitivity)
 393
 394 {
 395     if (iCaseSensitivity==0)
 396         iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE;
 397
 398     if (iCaseSensitivity==1)
 399         return strcmp(fileName1,fileName2);
 400
 401     return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2);
 402 }
 403
 404 #ifndef BUFREADCOMMENT
 405 #define BUFREADCOMMENT (0x400)
 406 #endif
 407
 408 /*
 409   Locate the Central directory of a zipfile (at the end, just before
 410     the global comment)
 411 */
 412 local ZPOS64_T unz64local_SearchCentralDir OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream));
 413 local ZPOS64_T unz64local_SearchCentralDir(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)
 414 {
 415     unsigned char* buf;
 416     ZPOS64_T uSizeFile;
 417     ZPOS64_T uBackRead;
 418     ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
 419     ZPOS64_T uPosFound=0;
 420
 421     if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
 422         return 0;
 423
 424
 425     uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);
 426
 427     if (uMaxBack>uSizeFile)
 428         uMaxBack = uSizeFile;
 429
 430     buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
 431     if (buf==NULL)
 432         return 0;
 433
 434     uBackRead = 4;
 435     while (uBackRead<uMaxBack)
 436     {
 437         uLong uReadSize;
 438         ZPOS64_T uReadPos ;
 439         int i;
 440         if (uBackRead+BUFREADCOMMENT>uMaxBack)
 441             uBackRead = uMaxBack;
 442         else
 443             uBackRead+=BUFREADCOMMENT;
 444         uReadPos = uSizeFile-uBackRead ;
 445
 446         uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
 447                      (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);
 448         if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
 449             break;
 450
 451         if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
 452             break;
 453
 454         for (i=(int)uReadSize-3; (i--)>0;)
 455             if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
 456                 ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
 457             {
 458                 uPosFound = uReadPos+i;
 459                 break;
 460             }
 461
 462         if (uPosFound!=0)
 463             break;
 464     }
 465     TRYFREE(buf);
 466     return uPosFound;
 467 }
 468
 469
 470 /*
 471   Locate the Central directory 64 of a zipfile (at the end, just before
 472     the global comment)
 473 */
 474 local ZPOS64_T unz64local_SearchCentralDir64 OF((
 475     const zlib_filefunc64_32_def* pzlib_filefunc_def,
 476     voidpf filestream));
 477
 478 local ZPOS64_T unz64local_SearchCentralDir64(const zlib_filefunc64_32_def* pzlib_filefunc_def,
 479                                       voidpf filestream)
 480 {
 481     unsigned char* buf;
 482     ZPOS64_T uSizeFile;
 483     ZPOS64_T uBackRead;
 484     ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
 485     ZPOS64_T uPosFound=0;
 486     uLong uL;
 487                 ZPOS64_T relativeOffset;
 488
 489     if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
 490         return 0;
 491
 492
 493     uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);
 494
 495     if (uMaxBack>uSizeFile)
 496         uMaxBack = uSizeFile;
 497
 498     buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
 499     if (buf==NULL)
 500         return 0;
 501
 502     uBackRead = 4;
 503     while (uBackRead<uMaxBack)
 504     {
 505         uLong uReadSize;
 506         ZPOS64_T uReadPos;
 507         int i;
 508         if (uBackRead+BUFREADCOMMENT>uMaxBack)
 509             uBackRead = uMaxBack;
 510         else
 511             uBackRead+=BUFREADCOMMENT;
 512         uReadPos = uSizeFile-uBackRead ;
 513
 514         uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
 515                      (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);
 516         if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
 517             break;
 518
 519         if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
 520             break;
 521
 522         for (i=(int)uReadSize-3; (i--)>0;)
 523             if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
 524                 ((*(buf+i+2))==0x06) && ((*(buf+i+3))==0x07))
 525             {
 526                 uPosFound = uReadPos+i;
 527                 break;
 528             }
 529
 530         if (uPosFound!=0)
 531             break;
 532     }
 533     TRYFREE(buf);
 534     if (uPosFound == 0)
 535         return 0;
 536
 537     /* Zip64 end of central directory locator */
 538     if (ZSEEK64(*pzlib_filefunc_def,filestream, uPosFound,ZLIB_FILEFUNC_SEEK_SET)!=0)
 539         return 0;
 540
 541     /* the signature, already checked */
 542     if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
 543         return 0;
 544
 545     /* number of the disk with the start of the zip64 end of  central directory */
 546     if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
 547         return 0;
 548     if (uL != 0)
 549         return 0;
 550
 551     /* relative offset of the zip64 end of central directory record */
 552     if (unz64local_getLong64(pzlib_filefunc_def,filestream,&relativeOffset)!=UNZ_OK)
 553         return 0;
 554
 555     /* total number of disks */
 556     if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
 557         return 0;
 558     if (uL != 1)
 559         return 0;
 560
 561     /* Goto end of central directory record */
 562     if (ZSEEK64(*pzlib_filefunc_def,filestream, relativeOffset,ZLIB_FILEFUNC_SEEK_SET)!=0)
 563         return 0;
 564
 565      /* the signature */
 566     if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
 567         return 0;
 568
 569     if (uL != 0x06064b50)
 570         return 0;
 571
 572     return relativeOffset;
 573 }
 574
 575 /*
 576   Open a Zip file. path contain the full pathname (by example,
 577      on a Windows NT computer "c:\\test\\zlib114.zip" or on an Unix computer
 578      "zlib/zlib114.zip".
 579      If the zipfile cannot be opened (file doesn't exist or in not valid), the
 580        return value is NULL.
 581      Else, the return value is a unzFile Handle, usable with other function
 582        of this unzip package.
 583 */
 584 local unzFile unzOpenInternal (const void *path,
 585                                zlib_filefunc64_32_def* pzlib_filefunc64_32_def,
 586                                int is64bitOpenFunction)
 587 {
 588     unz64_s us;
 589     unz64_s *s;
 590     ZPOS64_T central_pos;
 591     uLong   uL;
 592
 593     uLong number_disk;          /* number of the current dist, used for
 594                                    spaning ZIP, unsupported, always 0*/
 595     uLong number_disk_with_CD;  /* number the the disk with central dir, used
 596                                    for spaning ZIP, unsupported, always 0*/
 597     ZPOS64_T number_entry_CD;      /* total number of entries in
 598                                    the central dir
 599                                    (same than number_entry on nospan) */
 600
 601     int err=UNZ_OK;
 602
 603     if (unz_copyright[0]!=' ')
 604         return NULL;
 605
 606     us.z_filefunc.zseek32_file = NULL;
 607     us.z_filefunc.ztell32_file = NULL;
 608     if (pzlib_filefunc64_32_def==NULL)
 609         fill_fopen64_filefunc(&us.z_filefunc.zfile_func64);
 610     else
 611         us.z_filefunc = *pzlib_filefunc64_32_def;
 612     us.is64bitOpenFunction = is64bitOpenFunction;
 613
 614
 615
 616     us.filestream = ZOPEN64(us.z_filefunc,
 617                                                  path,
 618                                                  ZLIB_FILEFUNC_MODE_READ |
 619                                                  ZLIB_FILEFUNC_MODE_EXISTING);
 620     if (us.filestream==NULL)
 621         return NULL;
 622
 623     central_pos = unz64local_SearchCentralDir64(&us.z_filefunc,us.filestream);
 624     if (central_pos)
 625     {
 626         uLong uS;
 627         ZPOS64_T uL64;
 628
 629         us.isZip64 = 1;
 630
 631         if (ZSEEK64(us.z_filefunc, us.filestream,
 632                                       central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
 633         err=UNZ_ERRNO;
 634
 635         /* the signature, already checked */
 636         if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
 637             err=UNZ_ERRNO;
 638
 639         /* size of zip64 end of central directory record */
 640         if (unz64local_getLong64(&us.z_filefunc, us.filestream,&uL64)!=UNZ_OK)
 641             err=UNZ_ERRNO;
 642
 643         /* version made by */
 644         if (unz64local_getShort(&us.z_filefunc, us.filestream,&uS)!=UNZ_OK)
 645             err=UNZ_ERRNO;
 646
 647         /* version needed to extract */
 648         if (unz64local_getShort(&us.z_filefunc, us.filestream,&uS)!=UNZ_OK)
 649             err=UNZ_ERRNO;
 650
 651         /* number of this disk */
 652         if (unz64local_getLong(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK)
 653             err=UNZ_ERRNO;
 654
 655         /* number of the disk with the start of the central directory */
 656         if (unz64local_getLong(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK)
 657             err=UNZ_ERRNO;
 658
 659         /* total number of entries in the central directory on this disk */
 660         if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.gi.number_entry)!=UNZ_OK)
 661             err=UNZ_ERRNO;
 662
 663         /* total number of entries in the central directory */
 664         if (unz64local_getLong64(&us.z_filefunc, us.filestream,&number_entry_CD)!=UNZ_OK)
 665             err=UNZ_ERRNO;
 666
 667         if ((number_entry_CD!=us.gi.number_entry) ||
 668             (number_disk_with_CD!=0) ||
 669             (number_disk!=0))
 670             err=UNZ_BADZIPFILE;
 671
 672         /* size of the central directory */
 673         if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.size_central_dir)!=UNZ_OK)
 674             err=UNZ_ERRNO;
 675
 676         /* offset of start of central directory with respect to the
 677           starting disk number */
 678         if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.offset_central_dir)!=UNZ_OK)
 679             err=UNZ_ERRNO;
 680
 681         us.gi.size_comment = 0;
 682     }
 683     else
 684     {
 685         central_pos = unz64local_SearchCentralDir(&us.z_filefunc,us.filestream);
 686         if (central_pos==0)
 687             err=UNZ_ERRNO;
 688
 689         us.isZip64 = 0;
 690
 691         if (ZSEEK64(us.z_filefunc, us.filestream,
 692                                         central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
 693             err=UNZ_ERRNO;
 694
 695         /* the signature, already checked */
 696         if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
 697             err=UNZ_ERRNO;
 698
 699         /* number of this disk */
 700         if (unz64local_getShort(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK)
 701             err=UNZ_ERRNO;
 702
 703         /* number of the disk with the start of the central directory */
 704         if (unz64local_getShort(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK)
 705             err=UNZ_ERRNO;
 706
 707         /* total number of entries in the central dir on this disk */
 708         if (unz64local_getShort(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
 709             err=UNZ_ERRNO;
 710         us.gi.number_entry = uL;
 711
 712         /* total number of entries in the central dir */
 713         if (unz64local_getShort(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
 714             err=UNZ_ERRNO;
 715         number_entry_CD = uL;
 716
 717         if ((number_entry_CD!=us.gi.number_entry) ||
 718             (number_disk_with_CD!=0) ||
 719             (number_disk!=0))
 720             err=UNZ_BADZIPFILE;
 721
 722         /* size of the central directory */
 723         if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
 724             err=UNZ_ERRNO;
 725         us.size_central_dir = uL;
 726
 727         /* offset of start of central directory with respect to the
 728             starting disk number */
 729         if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
 730             err=UNZ_ERRNO;
 731         us.offset_central_dir = uL;
 732
 733         /* zipfile comment length */
 734         if (unz64local_getShort(&us.z_filefunc, us.filestream,&us.gi.size_comment)!=UNZ_OK)
 735             err=UNZ_ERRNO;
 736     }
 737
 738     if ((central_pos<us.offset_central_dir+us.size_central_dir) &&
 739         (err==UNZ_OK))
 740         err=UNZ_BADZIPFILE;
 741
 742     if (err!=UNZ_OK)
 743     {
 744         ZCLOSE64(us.z_filefunc, us.filestream);
 745         return NULL;
 746     }
 747
 748     us.byte_before_the_zipfile = central_pos -
 749                             (us.offset_central_dir+us.size_central_dir);
 750     us.central_pos = central_pos;
 751     us.pfile_in_zip_read = NULL;
 752     us.encrypted = 0;
 753
 754
 755     s=(unz64_s*)ALLOC(sizeof(unz64_s));
 756     if( s != NULL)
 757     {
 758         *s=us;
 759         unzGoToFirstFile((unzFile)s);
 760     }
 761     return (unzFile)s;
 762 }
 763
 764
 765 extern unzFile ZEXPORT unzOpen2 (const char *path,
 766                                         zlib_filefunc_def* pzlib_filefunc32_def)
 767 {
 768     if (pzlib_filefunc32_def != NULL)
 769     {
 770         zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
 771         fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill,pzlib_filefunc32_def);
 772         return unzOpenInternal(path, &zlib_filefunc64_32_def_fill, 0);
 773     }
 774     else
 775         return unzOpenInternal(path, NULL, 0);
 776 }
 777
 778 extern unzFile ZEXPORT unzOpen2_64 (const void *path,
 779                                      zlib_filefunc64_def* pzlib_filefunc_def)
 780 {
 781     if (pzlib_filefunc_def != NULL)
 782     {
 783         zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
 784         zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def;
 785         zlib_filefunc64_32_def_fill.ztell32_file = NULL;
 786         zlib_filefunc64_32_def_fill.zseek32_file = NULL;
 787         return unzOpenInternal(path, &zlib_filefunc64_32_def_fill, 1);
 788     }
 789     else
 790         return unzOpenInternal(path, NULL, 1);
 791 }
 792
 793 extern unzFile ZEXPORT unzOpen (const char *path)
 794 {
 795     return unzOpenInternal(path, NULL, 0);
 796 }
 797
 798 extern unzFile ZEXPORT unzOpen64 (const void *path)
 799 {
 800     return unzOpenInternal(path, NULL, 1);
 801 }
 802
 803 /*
 804   Close a ZipFile opened with unzipOpen.
 805   If there is files inside the .Zip opened with unzipOpenCurrentFile (see later),
 806     these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
 807   return UNZ_OK if there is no problem. */
 808 extern int ZEXPORT unzClose (unzFile file)
 809 {
 810     unz64_s* s;
 811     if (file==NULL)
 812         return UNZ_PARAMERROR;
 813     s=(unz64_s*)file;
 814
 815     if (s->pfile_in_zip_read!=NULL)
 816         unzCloseCurrentFile(file);
 817
 818     ZCLOSE64(s->z_filefunc, s->filestream);
 819     TRYFREE(s);
 820     return UNZ_OK;
 821 }
 822
 823
 824 /*
 825   Write info about the ZipFile in the *pglobal_info structure.
 826   No preparation of the structure is needed
 827   return UNZ_OK if there is no problem. */
 828 extern int ZEXPORT unzGetGlobalInfo64 (unzFile file, unz_global_info64* pglobal_info)
 829 {
 830     unz64_s* s;
 831     if (file==NULL)
 832         return UNZ_PARAMERROR;
 833     s=(unz64_s*)file;
 834     *pglobal_info=s->gi;
 835     return UNZ_OK;
 836 }
 837
 838 extern int ZEXPORT unzGetGlobalInfo (unzFile file, unz_global_info* pglobal_info32)
 839 {
 840     unz64_s* s;
 841     if (file==NULL)
 842         return UNZ_PARAMERROR;
 843     s=(unz64_s*)file;
 844     /* to do : check if number_entry is not truncated */
 845     pglobal_info32->number_entry = (uLong)s->gi.number_entry;
 846     pglobal_info32->size_comment = s->gi.size_comment;
 847     return UNZ_OK;
 848 }
 849 /*
 850    Translate date/time from Dos format to tm_unz (readable more easilty)
 851 */
 852 local void unz64local_DosDateToTmuDate (ZPOS64_T ulDosDate, tm_unz* ptm)
 853 {
 854     ZPOS64_T uDate;
 855     uDate = (ZPOS64_T)(ulDosDate>>16);
 856     ptm->tm_mday = (uInt)(uDate&0x1f) ;
 857     ptm->tm_mon =  (uInt)((((uDate)&0x1E0)/0x20)-1) ;
 858     ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ;
 859
 860     ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800);
 861     ptm->tm_min =  (uInt) ((ulDosDate&0x7E0)/0x20) ;
 862     ptm->tm_sec =  (uInt) (2*(ulDosDate&0x1f)) ;
 863 }
 864
 865 /*
 866   Get Info about the current file in the zipfile, with internal only info
 867 */
 868 local int unz64local_GetCurrentFileInfoInternal OF((unzFile file,
 869                                                   unz_file_info64 *pfile_info,
 870                                                   unz_file_info64_internal
 871                                                   *pfile_info_internal,
 872                                                   char *szFileName,
 873                                                   uLong fileNameBufferSize,
 874                                                   void *extraField,
 875                                                   uLong extraFieldBufferSize,
 876                                                   char *szComment,
 877                                                   uLong commentBufferSize));
 878
 879 local int unz64local_GetCurrentFileInfoInternal (unzFile file,
 880                                                   unz_file_info64 *pfile_info,
 881                                                   unz_file_info64_internal
 882                                                   *pfile_info_internal,
 883                                                   char *szFileName,
 884                                                   uLong fileNameBufferSize,
 885                                                   void *extraField,
 886                                                   uLong extraFieldBufferSize,
 887                                                   char *szComment,
 888                                                   uLong commentBufferSize)
 889 {
 890     unz64_s* s;
 891     unz_file_info64 file_info;
 892     unz_file_info64_internal file_info_internal;
 893     int err=UNZ_OK;
 894     uLong uMagic;
 895     long lSeek=0;
 896     uLong uL;
 897
 898     if (file==NULL)
 899         return UNZ_PARAMERROR;
 900     s=(unz64_s*)file;
 901     if (ZSEEK64(s->z_filefunc, s->filestream,
 902               s->pos_in_central_dir+s->byte_before_the_zipfile,
 903               ZLIB_FILEFUNC_SEEK_SET)!=0)
 904         err=UNZ_ERRNO;
 905
 906
 907     /* we check the magic */
 908     if (err==UNZ_OK)
 909     {
 910         if (unz64local_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)
 911             err=UNZ_ERRNO;
 912         else if (uMagic!=0x02014b50)
 913             err=UNZ_BADZIPFILE;
 914     }
 915
 916     if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.version) != UNZ_OK)
 917         err=UNZ_ERRNO;
 918
 919     if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.version_needed) != UNZ_OK)
 920         err=UNZ_ERRNO;
 921
 922     if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.flag) != UNZ_OK)
 923         err=UNZ_ERRNO;
 924
 925     if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.compression_method) != UNZ_OK)
 926         err=UNZ_ERRNO;
 927
 928     if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.dosDate) != UNZ_OK)
 929         err=UNZ_ERRNO;
 930
 931     unz64local_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date);
 932
 933     if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.crc) != UNZ_OK)
 934         err=UNZ_ERRNO;
 935
 936     if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)
 937         err=UNZ_ERRNO;
 938     file_info.compressed_size = uL;
 939
 940     if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)
 941         err=UNZ_ERRNO;
 942     file_info.uncompressed_size = uL;
 943
 944     if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_filename) != UNZ_OK)
 945         err=UNZ_ERRNO;
 946
 947     if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_extra) != UNZ_OK)
 948         err=UNZ_ERRNO;
 949
 950     if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_comment) != UNZ_OK)
 951         err=UNZ_ERRNO;
 952
 953     if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.disk_num_start) != UNZ_OK)
 954         err=UNZ_ERRNO;
 955
 956     if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.internal_fa) != UNZ_OK)
 957         err=UNZ_ERRNO;
 958
 959     if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.external_fa) != UNZ_OK)
 960         err=UNZ_ERRNO;
 961
 962                 // relative offset of local header
 963     if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)
 964         err=UNZ_ERRNO;
 965     file_info_internal.offset_curfile = uL;
 966
 967     lSeek+=file_info.size_filename;
 968     if ((err==UNZ_OK) && (szFileName!=NULL))
 969     {
 970         uLong uSizeRead ;
 971         if (file_info.size_filename<fileNameBufferSize)
 972         {
 973             *(szFileName+file_info.size_filename)='\0';
 974             uSizeRead = file_info.size_filename;
 975         }
 976         else
 977             uSizeRead = fileNameBufferSize;
 978
 979         if ((file_info.size_filename>0) && (fileNameBufferSize>0))
 980             if (ZREAD64(s->z_filefunc, s->filestream,szFileName,uSizeRead)!=uSizeRead)
 981                 err=UNZ_ERRNO;
 982         lSeek -= uSizeRead;
 983     }
 984
 985     // Read extrafield
 986     if ((err==UNZ_OK) && (extraField!=NULL))
 987     {
 988         ZPOS64_T uSizeRead ;
 989         if (file_info.size_file_extra<extraFieldBufferSize)
 990             uSizeRead = file_info.size_file_extra;
 991         else
 992             uSizeRead = extraFieldBufferSize;
 993
 994         if (lSeek!=0)
 995         {
 996             if (ZSEEK64(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
 997                 lSeek=0;
 998             else
 999                 err=UNZ_ERRNO;
1000         }
1001
1002         if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0))
1003             if (ZREAD64(s->z_filefunc, s->filestream,extraField,(uLong)uSizeRead)!=uSizeRead)
1004                 err=UNZ_ERRNO;
1005
1006         lSeek += file_info.size_file_extra - (uLong)uSizeRead;
1007     }
1008     else
1009         lSeek += file_info.size_file_extra;
1010
1011
1012     if ((err==UNZ_OK) && (file_info.size_file_extra != 0))
1013     {
1014                                 uLong acc = 0;
1015
1016         // since lSeek now points to after the extra field we need to move back
1017         lSeek -= file_info.size_file_extra;
1018
1019         if (lSeek!=0)
1020         {
1021             if (ZSEEK64(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
1022                 lSeek=0;
1023             else
1024                 err=UNZ_ERRNO;
1025         }
1026
1027         while(acc < file_info.size_file_extra)
1028         {
1029             uLong headerId;
1030                                                 uLong dataSize;
1031
1032             if (unz64local_getShort(&s->z_filefunc, s->filestream,&headerId) != UNZ_OK)
1033                 err=UNZ_ERRNO;
1034
1035             if (unz64local_getShort(&s->z_filefunc, s->filestream,&dataSize) != UNZ_OK)
1036                 err=UNZ_ERRNO;
1037
1038             /* ZIP64 extra fields */
1039             if (headerId == 0x0001)
1040             {
1041                                                         uLong uL;
1042
1043                                                                 if(file_info.uncompressed_size == (ZPOS64_T)(unsigned long)-1)
1044                                                                 {
1045                                                                         if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info.uncompressed_size) != UNZ_OK)
1046                                                                                         err=UNZ_ERRNO;
1047                                                                 }
1048
1049                                                                 if(file_info.compressed_size == (ZPOS64_T)(unsigned long)-1)
1050                                                                 {
1051                                                                         if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info.compressed_size) != UNZ_OK)
1052                                                                                   err=UNZ_ERRNO;
1053                                                                 }
1054
1055                                                                 if(file_info_internal.offset_curfile == (ZPOS64_T)(unsigned long)-1)
1056                                                                 {
1057                                                                         /* Relative Header offset */
1058                                                                         if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info_internal.offset_curfile) != UNZ_OK)
1059                                                                                 err=UNZ_ERRNO;
1060                                                                 }
1061
1062                                                                 if(file_info.disk_num_start == (unsigned long)-1)
1063                                                                 {
1064                                                                         /* Disk Start Number */
1065                                                                         if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)
1066                                                                                 err=UNZ_ERRNO;
1067                                                                 }
1068
1069             }
1070             else
1071             {
1072                 if (ZSEEK64(s->z_filefunc, s->filestream,dataSize,ZLIB_FILEFUNC_SEEK_CUR)!=0)
1073                     err=UNZ_ERRNO;
1074             }
1075
1076             acc += 2 + 2 + dataSize;
1077         }
1078     }
1079
1080     if ((err==UNZ_OK) && (szComment!=NULL))
1081     {
1082         uLong uSizeRead ;
1083         if (file_info.size_file_comment<commentBufferSize)
1084         {
1085             *(szComment+file_info.size_file_comment)='\0';
1086             uSizeRead = file_info.size_file_comment;
1087         }
1088         else
1089             uSizeRead = commentBufferSize;
1090
1091         if (lSeek!=0)
1092         {
1093             if (ZSEEK64(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
1094                 lSeek=0;
1095             else
1096                 err=UNZ_ERRNO;
1097         }
1098
1099         if ((file_info.size_file_comment>0) && (commentBufferSize>0))
1100             if (ZREAD64(s->z_filefunc, s->filestream,szComment,uSizeRead)!=uSizeRead)
1101                 err=UNZ_ERRNO;
1102         lSeek+=file_info.size_file_comment - uSizeRead;
1103     }
1104     else
1105         lSeek+=file_info.size_file_comment;
1106
1107
1108     if ((err==UNZ_OK) && (pfile_info!=NULL))
1109         *pfile_info=file_info;
1110
1111     if ((err==UNZ_OK) && (pfile_info_internal!=NULL))
1112         *pfile_info_internal=file_info_internal;
1113
1114     return err;
1115 }
1116
1117
1118
1119 /*
1120   Write info about the ZipFile in the *pglobal_info structure.
1121   No preparation of the structure is needed
1122   return UNZ_OK if there is no problem.
1123 */
1124 extern int ZEXPORT unzGetCurrentFileInfo64 (unzFile file,
1125                                           unz_file_info64 * pfile_info,
1126                                           char * szFileName, uLong fileNameBufferSize,
1127                                           void *extraField, uLong extraFieldBufferSize,
1128                                           char* szComment,  uLong commentBufferSize)
1129 {
1130     return unz64local_GetCurrentFileInfoInternal(file,pfile_info,NULL,
1131                                                 szFileName,fileNameBufferSize,
1132                                                 extraField,extraFieldBufferSize,
1133                                                 szComment,commentBufferSize);
1134 }
1135
1136 extern int ZEXPORT unzGetCurrentFileInfo (unzFile file,
1137                                           unz_file_info * pfile_info,
1138                                           char * szFileName, uLong fileNameBufferSize,
1139                                           void *extraField, uLong extraFieldBufferSize,
1140                                           char* szComment,  uLong commentBufferSize)
1141 {
1142     int err;
1143     unz_file_info64 file_info64;
1144     err = unz64local_GetCurrentFileInfoInternal(file,&file_info64,NULL,
1145                                                 szFileName,fileNameBufferSize,
1146                                                 extraField,extraFieldBufferSize,
1147                                                 szComment,commentBufferSize);
1148     if (err==UNZ_OK)
1149     {
1150         pfile_info->version = file_info64.version;
1151         pfile_info->version_needed = file_info64.version_needed;
1152         pfile_info->flag = file_info64.flag;
1153         pfile_info->compression_method = file_info64.compression_method;
1154         pfile_info->dosDate = file_info64.dosDate;
1155         pfile_info->crc = file_info64.crc;
1156
1157         pfile_info->size_filename = file_info64.size_filename;
1158         pfile_info->size_file_extra = file_info64.size_file_extra;
1159         pfile_info->size_file_comment = file_info64.size_file_comment;
1160
1161         pfile_info->disk_num_start = file_info64.disk_num_start;
1162         pfile_info->internal_fa = file_info64.internal_fa;
1163         pfile_info->external_fa = file_info64.external_fa;
1164
1165         pfile_info->tmu_date = file_info64.tmu_date,
1166
1167
1168         pfile_info->compressed_size = (uLong)file_info64.compressed_size;
1169         pfile_info->uncompressed_size = (uLong)file_info64.uncompressed_size;
1170
1171     }
1172     return err;
1173 }
1174 /*
1175   Set the current file of the zipfile to the first file.
1176   return UNZ_OK if there is no problem
1177 */
1178 extern int ZEXPORT unzGoToFirstFile (unzFile file)
1179 {
1180     int err=UNZ_OK;
1181     unz64_s* s;
1182     if (file==NULL)
1183         return UNZ_PARAMERROR;
1184     s=(unz64_s*)file;
1185     s->pos_in_central_dir=s->offset_central_dir;
1186     s->num_file=0;
1187     err=unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,
1188                                              &s->cur_file_info_internal,
1189                                              NULL,0,NULL,0,NULL,0);
1190     s->current_file_ok = (err == UNZ_OK);
1191     return err;
1192 }
1193
1194 /*
1195   Set the current file of the zipfile to the next file.
1196   return UNZ_OK if there is no problem
1197   return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
1198 */
1199 extern int ZEXPORT unzGoToNextFile (unzFile  file)
1200 {
1201     unz64_s* s;
1202     int err;
1203
1204     if (file==NULL)
1205         return UNZ_PARAMERROR;
1206     s=(unz64_s*)file;
1207     if (!s->current_file_ok)
1208         return UNZ_END_OF_LIST_OF_FILE;
1209     if (s->gi.number_entry != 0xffff)    /* 2^16 files overflow hack */
1210       if (s->num_file+1==s->gi.number_entry)
1211         return UNZ_END_OF_LIST_OF_FILE;
1212
1213     s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +
1214             s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ;
1215     s->num_file++;
1216     err = unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,
1217                                                &s->cur_file_info_internal,
1218                                                NULL,0,NULL,0,NULL,0);
1219     s->current_file_ok = (err == UNZ_OK);
1220     return err;
1221 }
1222
1223
1224 /*
1225   Try locate the file szFileName in the zipfile.
1226   For the iCaseSensitivity signification, see unzipStringFileNameCompare
1227
1228   return value :
1229   UNZ_OK if the file is found. It becomes the current file.
1230   UNZ_END_OF_LIST_OF_FILE if the file is not found
1231 */
1232 extern int ZEXPORT unzLocateFile (unzFile file, const char *szFileName, int iCaseSensitivity)
1233 {
1234     unz64_s* s;
1235     int err;
1236
1237     /* We remember the 'current' position in the file so that we can jump
1238      * back there if we fail.
1239      */
1240     unz_file_info64 cur_file_infoSaved;
1241     unz_file_info64_internal cur_file_info_internalSaved;
1242     ZPOS64_T num_fileSaved;
1243     ZPOS64_T pos_in_central_dirSaved;
1244
1245
1246     if (file==NULL)
1247         return UNZ_PARAMERROR;
1248
1249     if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP)
1250         return UNZ_PARAMERROR;
1251
1252     s=(unz64_s*)file;
1253     if (!s->current_file_ok)
1254         return UNZ_END_OF_LIST_OF_FILE;
1255
1256     /* Save the current state */
1257     num_fileSaved = s->num_file;
1258     pos_in_central_dirSaved = s->pos_in_central_dir;
1259     cur_file_infoSaved = s->cur_file_info;
1260     cur_file_info_internalSaved = s->cur_file_info_internal;
1261
1262     err = unzGoToFirstFile(file);
1263
1264     while (err == UNZ_OK)
1265     {
1266         char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1];
1267         err = unzGetCurrentFileInfo64(file,NULL,
1268                                     szCurrentFileName,sizeof(szCurrentFileName)-1,
1269                                     NULL,0,NULL,0);
1270         if (err == UNZ_OK)
1271         {
1272             if (unzStringFileNameCompare(szCurrentFileName,
1273                                             szFileName,iCaseSensitivity)==0)
1274                 return UNZ_OK;
1275             err = unzGoToNextFile(file);
1276         }
1277     }
1278
1279     /* We failed, so restore the state of the 'current file' to where we
1280      * were.
1281      */
1282     s->num_file = num_fileSaved ;
1283     s->pos_in_central_dir = pos_in_central_dirSaved ;
1284     s->cur_file_info = cur_file_infoSaved;
1285     s->cur_file_info_internal = cur_file_info_internalSaved;
1286     return err;
1287 }
1288
1289
1290 /*
1291 ///////////////////////////////////////////
1292 // Contributed by Ryan Haksi (mailto://cryogen@infoserve.net)
1293 // I need random access
1294 //
1295 // Further optimization could be realized by adding an ability
1296 // to cache the directory in memory. The goal being a single
1297 // comprehensive file read to put the file I need in a memory.
1298 */
1299
1300 /*
1301 typedef struct unz_file_pos_s
1302 {
1303     ZPOS64_T pos_in_zip_directory;   // offset in file
1304     ZPOS64_T num_of_file;            // # of file
1305 } unz_file_pos;
1306 */
1307
1308 extern int ZEXPORT unzGetFilePos64(unzFile file, unz64_file_pos*  file_pos)
1309 {
1310     unz64_s* s;
1311
1312     if (file==NULL || file_pos==NULL)
1313         return UNZ_PARAMERROR;
1314     s=(unz64_s*)file;
1315     if (!s->current_file_ok)
1316         return UNZ_END_OF_LIST_OF_FILE;
1317
1318     file_pos->pos_in_zip_directory  = s->pos_in_central_dir;
1319     file_pos->num_of_file           = s->num_file;
1320
1321     return UNZ_OK;
1322 }
1323
1324 extern int ZEXPORT unzGetFilePos(
1325     unzFile file,
1326     unz_file_pos* file_pos)
1327 {
1328     unz64_file_pos file_pos64;
1329     int err = unzGetFilePos64(file,&file_pos64);
1330     if (err==UNZ_OK)
1331     {
1332         file_pos->pos_in_zip_directory = (uLong)file_pos64.pos_in_zip_directory;
1333         file_pos->num_of_file = (uLong)file_pos64.num_of_file;
1334     }
1335     return err;
1336 }
1337
1338 extern int ZEXPORT unzGoToFilePos64(unzFile file, const unz64_file_pos* file_pos)
1339 {
1340     unz64_s* s;
1341     int err;
1342
1343     if (file==NULL || file_pos==NULL)
1344         return UNZ_PARAMERROR;
1345     s=(unz64_s*)file;
1346
1347     /* jump to the right spot */
1348     s->pos_in_central_dir = file_pos->pos_in_zip_directory;
1349     s->num_file           = file_pos->num_of_file;
1350
1351     /* set the current file */
1352     err = unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,
1353                                                &s->cur_file_info_internal,
1354                                                NULL,0,NULL,0,NULL,0);
1355     /* return results */
1356     s->current_file_ok = (err == UNZ_OK);
1357     return err;
1358 }
1359
1360 extern int ZEXPORT unzGoToFilePos(
1361     unzFile file,
1362     unz_file_pos* file_pos)
1363 {
1364     unz64_file_pos file_pos64;
1365     if (file_pos == NULL)
1366         return UNZ_PARAMERROR;
1367
1368     file_pos64.pos_in_zip_directory = file_pos->pos_in_zip_directory;
1369     file_pos64.num_of_file = file_pos->num_of_file;
1370     return unzGoToFilePos64(file,&file_pos64);
1371 }
1372
1373 /*
1374 // Unzip Helper Functions - should be here?
1375 ///////////////////////////////////////////
1376 */
1377
1378 /*
1379   Read the local header of the current zipfile
1380   Check the coherency of the local header and info in the end of central
1381         directory about this file
1382   store in *piSizeVar the size of extra info in local header
1383         (filename and size of extra field data)
1384 */
1385 local int unz64local_CheckCurrentFileCoherencyHeader (unz64_s* s, uInt* piSizeVar,
1386                                                     ZPOS64_T * poffset_local_extrafield,
1387                                                     uInt  * psize_local_extrafield)
1388 {
1389     uLong uMagic,uData,uFlags;
1390     uLong size_filename;
1391     uLong size_extra_field;
1392     int err=UNZ_OK;
1393
1394     *piSizeVar = 0;
1395     *poffset_local_extrafield = 0;
1396     *psize_local_extrafield = 0;
1397
1398     if (ZSEEK64(s->z_filefunc, s->filestream,s->cur_file_info_internal.offset_curfile +
1399                                 s->byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0)
1400         return UNZ_ERRNO;
1401
1402
1403     if (err==UNZ_OK)
1404     {
1405         if (unz64local_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)
1406             err=UNZ_ERRNO;
1407         else if (uMagic!=0x04034b50)
1408             err=UNZ_BADZIPFILE;
1409     }
1410
1411     if (unz64local_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
1412         err=UNZ_ERRNO;
1413 /*
1414     else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
1415         err=UNZ_BADZIPFILE;
1416 */
1417     if (unz64local_getShort(&s->z_filefunc, s->filestream,&uFlags) != UNZ_OK)
1418         err=UNZ_ERRNO;
1419
1420     if (unz64local_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
1421         err=UNZ_ERRNO;
1422     else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method))
1423         err=UNZ_BADZIPFILE;
1424
1425     if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) &&
1426 /* #ifdef HAVE_BZIP2 */
1427                          (s->cur_file_info.compression_method!=Z_BZIP2ED) &&
1428 /* #endif */
1429                          (s->cur_file_info.compression_method!=Z_DEFLATED))
1430         err=UNZ_BADZIPFILE;
1431
1432     if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* date/time */
1433         err=UNZ_ERRNO;
1434
1435     if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* crc */
1436         err=UNZ_ERRNO;
1437     else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) && ((uFlags & 8)==0))
1438         err=UNZ_BADZIPFILE;
1439
1440     if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size compr */
1441         err=UNZ_ERRNO;
1442     else if (uData != 0xFFFFFFFF && (err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) && ((uFlags & 8)==0))
1443         err=UNZ_BADZIPFILE;
1444
1445     if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size uncompr */
1446         err=UNZ_ERRNO;
1447     else if (uData != 0xFFFFFFFF && (err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) && ((uFlags & 8)==0))
1448         err=UNZ_BADZIPFILE;
1449
1450     if (unz64local_getShort(&s->z_filefunc, s->filestream,&size_filename) != UNZ_OK)
1451         err=UNZ_ERRNO;
1452     else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename))
1453         err=UNZ_BADZIPFILE;
1454
1455     *piSizeVar += (uInt)size_filename;
1456
1457     if (unz64local_getShort(&s->z_filefunc, s->filestream,&size_extra_field) != UNZ_OK)
1458         err=UNZ_ERRNO;
1459     *poffset_local_extrafield= s->cur_file_info_internal.offset_curfile +
1460                                     SIZEZIPLOCALHEADER + size_filename;
1461     *psize_local_extrafield = (uInt)size_extra_field;
1462
1463     *piSizeVar += (uInt)size_extra_field;
1464
1465     return err;
1466 }
1467
1468 /*
1469   Open for reading data the current file in the zipfile.
1470   If there is no error and the file is opened, the return value is UNZ_OK.
1471 */
1472 extern int ZEXPORT unzOpenCurrentFile3 (unzFile file, int* method,
1473                                             int* level, int raw, const char* password)
1474 {
1475     int err=UNZ_OK;
1476     uInt iSizeVar;
1477     unz64_s* s;
1478     file_in_zip64_read_info_s* pfile_in_zip_read_info;
1479     ZPOS64_T offset_local_extrafield;  /* offset of the local extra field */
1480     uInt  size_local_extrafield;    /* size of the local extra field */
1481 #    ifndef NOUNCRYPT
1482     char source[12];
1483 #    else
1484     if (password != NULL)
1485         return UNZ_PARAMERROR;
1486 #    endif
1487
1488     if (file==NULL)
1489         return UNZ_PARAMERROR;
1490     s=(unz64_s*)file;
1491     if (!s->current_file_ok)
1492         return UNZ_PARAMERROR;
1493
1494     if (s->pfile_in_zip_read != NULL)
1495         unzCloseCurrentFile(file);
1496
1497     if (unz64local_CheckCurrentFileCoherencyHeader(s,&iSizeVar, &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK)
1498         return UNZ_BADZIPFILE;
1499
1500     pfile_in_zip_read_info = (file_in_zip64_read_info_s*)ALLOC(sizeof(file_in_zip64_read_info_s));
1501     if (pfile_in_zip_read_info==NULL)
1502         return UNZ_INTERNALERROR;
1503
1504     pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE);
1505     pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;
1506     pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
1507     pfile_in_zip_read_info->pos_local_extrafield=0;
1508     pfile_in_zip_read_info->raw=raw;
1509
1510     if (pfile_in_zip_read_info->read_buffer==NULL)
1511     {
1512         TRYFREE(pfile_in_zip_read_info);
1513         return UNZ_INTERNALERROR;
1514     }
1515
1516     pfile_in_zip_read_info->stream_initialised=0;
1517
1518     if (method!=NULL)
1519         *method = (int)s->cur_file_info.compression_method;
1520
1521     if (level!=NULL)
1522     {
1523         *level = 6;
1524         switch (s->cur_file_info.flag & 0x06)
1525         {
1526           case 6 : *level = 1; break;
1527           case 4 : *level = 2; break;
1528           case 2 : *level = 9; break;
1529         }
1530     }
1531
1532     if ((s->cur_file_info.compression_method!=0) &&
1533 /* #ifdef HAVE_BZIP2 */
1534         (s->cur_file_info.compression_method!=Z_BZIP2ED) &&
1535 /* #endif */
1536         (s->cur_file_info.compression_method!=Z_DEFLATED))
1537
1538         err=UNZ_BADZIPFILE;
1539
1540     pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc;
1541     pfile_in_zip_read_info->crc32=0;
1542     pfile_in_zip_read_info->total_out_64=0;
1543     pfile_in_zip_read_info->compression_method = s->cur_file_info.compression_method;
1544     pfile_in_zip_read_info->filestream=s->filestream;
1545     pfile_in_zip_read_info->z_filefunc=s->z_filefunc;
1546     pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile;
1547
1548     pfile_in_zip_read_info->stream.total_out = 0;
1549
1550     if ((s->cur_file_info.compression_method==Z_BZIP2ED) && (!raw))
1551     {
1552 #ifdef HAVE_BZIP2
1553       pfile_in_zip_read_info->bstream.bzalloc = (void *(*) (void *, int, int))0;
1554       pfile_in_zip_read_info->bstream.bzfree = (free_func)0;
1555       pfile_in_zip_read_info->bstream.opaque = (voidpf)0;
1556       pfile_in_zip_read_info->bstream.state = (voidpf)0;
1557
1558       pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
1559       pfile_in_zip_read_info->stream.zfree = (free_func)0;
1560       pfile_in_zip_read_info->stream.opaque = (voidpf)0;
1561       pfile_in_zip_read_info->stream.next_in = (voidpf)0;
1562       pfile_in_zip_read_info->stream.avail_in = 0;
1563
1564       err=BZ2_bzDecompressInit(&pfile_in_zip_read_info->bstream, 0, 0);
1565       if (err == Z_OK)
1566         pfile_in_zip_read_info->stream_initialised=Z_BZIP2ED;
1567       else
1568       {
1569         TRYFREE(pfile_in_zip_read_info);
1570         return err;
1571       }
1572 #else
1573       pfile_in_zip_read_info->raw=1;
1574 #endif
1575     }
1576     else if ((s->cur_file_info.compression_method==Z_DEFLATED) && (!raw))
1577     {
1578       pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
1579       pfile_in_zip_read_info->stream.zfree = (free_func)0;
1580       pfile_in_zip_read_info->stream.opaque = (voidpf)0;
1581       pfile_in_zip_read_info->stream.next_in = 0;
1582       pfile_in_zip_read_info->stream.avail_in = 0;
1583
1584       err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);
1585       if (err == Z_OK)
1586         pfile_in_zip_read_info->stream_initialised=Z_DEFLATED;
1587       else
1588       {
1589         TRYFREE(pfile_in_zip_read_info);
1590         return err;
1591       }
1592         /* windowBits is passed < 0 to tell that there is no zlib header.
1593          * Note that in this case inflate *requires* an extra "dummy" byte
1594          * after the compressed stream in order to complete decompression and
1595          * return Z_STREAM_END.
1596          * In unzip, i don't wait absolutely Z_STREAM_END because I known the
1597          * size of both compressed and uncompressed data
1598          */
1599     }
1600     pfile_in_zip_read_info->rest_read_compressed =
1601             s->cur_file_info.compressed_size ;
1602     pfile_in_zip_read_info->rest_read_uncompressed =
1603             s->cur_file_info.uncompressed_size ;
1604
1605
1606     pfile_in_zip_read_info->pos_in_zipfile =
1607             s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER +
1608               iSizeVar;
1609
1610     pfile_in_zip_read_info->stream.avail_in = (uInt)0;
1611
1612     s->pfile_in_zip_read = pfile_in_zip_read_info;
1613                 s->encrypted = 0;
1614
1615 #    ifndef NOUNCRYPT
1616     if (password != NULL)
1617     {
1618         int i;
1619         s->pcrc_32_tab = get_crc_table();
1620         init_keys(password,s->keys,s->pcrc_32_tab);
1621         if (ZSEEK64(s->z_filefunc, s->filestream,
1622                   s->pfile_in_zip_read->pos_in_zipfile +
1623                      s->pfile_in_zip_read->byte_before_the_zipfile,
1624                   SEEK_SET)!=0)
1625             return UNZ_INTERNALERROR;
1626         if(ZREAD64(s->z_filefunc, s->filestream,source, 12)<12)
1627             return UNZ_INTERNALERROR;
1628
1629         for (i = 0; i<12; i++)
1630             zdecode(s->keys,s->pcrc_32_tab,source[i]);
1631
1632         s->pfile_in_zip_read->pos_in_zipfile+=12;
1633         s->encrypted=1;
1634     }
1635 #    endif
1636
1637
1638     return UNZ_OK;
1639 }
1640
1641 extern int ZEXPORT unzOpenCurrentFile (unzFile file)
1642 {
1643     return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL);
1644 }
1645
1646 extern int ZEXPORT unzOpenCurrentFilePassword (unzFile file, const char*  password)
1647 {
1648     return unzOpenCurrentFile3(file, NULL, NULL, 0, password);
1649 }
1650
1651 extern int ZEXPORT unzOpenCurrentFile2 (unzFile file, int* method, int* level, int raw)
1652 {
1653     return unzOpenCurrentFile3(file, method, level, raw, NULL);
1654 }
1655
1656 /** Addition for GDAL : START */
1657
1658 extern ZPOS64_T ZEXPORT unzGetCurrentFileZStreamPos64( unzFile file)
1659 {
1660     unz64_s* s;
1661     file_in_zip64_read_info_s* pfile_in_zip_read_info;
1662     s=(unz64_s*)file;
1663     if (file==NULL)
1664         return 0; //UNZ_PARAMERROR;
1665     pfile_in_zip_read_info=s->pfile_in_zip_read;
1666     if (pfile_in_zip_read_info==NULL)
1667         return 0; //UNZ_PARAMERROR;
1668     return pfile_in_zip_read_info->pos_in_zipfile +
1669                          pfile_in_zip_read_info->byte_before_the_zipfile;
1670 }
1671
1672 /** Addition for GDAL : END */
1673
1674 /*
1675   Read bytes from the current file.
1676   buf contain buffer where data must be copied
1677   len the size of buf.
1678
1679   return the number of byte copied if somes bytes are copied
1680   return 0 if the end of file was reached
1681   return <0 with error code if there is an error
1682     (UNZ_ERRNO for IO error, or zLib error for uncompress error)
1683 */
1684 extern int ZEXPORT unzReadCurrentFile  (unzFile file, voidp buf, unsigned len)
1685 {
1686     int err=UNZ_OK;
1687     uInt iRead = 0;
1688     unz64_s* s;
1689     file_in_zip64_read_info_s* pfile_in_zip_read_info;
1690     if (file==NULL)
1691         return UNZ_PARAMERROR;
1692     s=(unz64_s*)file;
1693     pfile_in_zip_read_info=s->pfile_in_zip_read;
1694
1695     if (pfile_in_zip_read_info==NULL)
1696         return UNZ_PARAMERROR;
1697
1698
1699     if ((pfile_in_zip_read_info->read_buffer == NULL))
1700         return UNZ_END_OF_LIST_OF_FILE;
1701     if (len==0)
1702         return 0;
1703
1704     pfile_in_zip_read_info->stream.next_out = (Bytef*)buf;
1705
1706     pfile_in_zip_read_info->stream.avail_out = (uInt)len;
1707
1708     if ((len>pfile_in_zip_read_info->rest_read_uncompressed) &&
1709         (!(pfile_in_zip_read_info->raw)))
1710         pfile_in_zip_read_info->stream.avail_out =
1711             (uInt)pfile_in_zip_read_info->rest_read_uncompressed;
1712
1713     if ((len>pfile_in_zip_read_info->rest_read_compressed+
1714            pfile_in_zip_read_info->stream.avail_in) &&
1715          (pfile_in_zip_read_info->raw))
1716         pfile_in_zip_read_info->stream.avail_out =
1717             (uInt)pfile_in_zip_read_info->rest_read_compressed+
1718             pfile_in_zip_read_info->stream.avail_in;
1719
1720     while (pfile_in_zip_read_info->stream.avail_out>0)
1721     {
1722         if ((pfile_in_zip_read_info->stream.avail_in==0) &&
1723             (pfile_in_zip_read_info->rest_read_compressed>0))
1724         {
1725             uInt uReadThis = UNZ_BUFSIZE;
1726             if (pfile_in_zip_read_info->rest_read_compressed<uReadThis)
1727                 uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed;
1728             if (uReadThis == 0)
1729                 return UNZ_EOF;
1730             if (ZSEEK64(pfile_in_zip_read_info->z_filefunc,
1731                       pfile_in_zip_read_info->filestream,
1732                       pfile_in_zip_read_info->pos_in_zipfile +
1733                          pfile_in_zip_read_info->byte_before_the_zipfile,
1734                          ZLIB_FILEFUNC_SEEK_SET)!=0)
1735                 return UNZ_ERRNO;
1736             if (ZREAD64(pfile_in_zip_read_info->z_filefunc,
1737                       pfile_in_zip_read_info->filestream,
1738                       pfile_in_zip_read_info->read_buffer,
1739                       uReadThis)!=uReadThis)
1740                 return UNZ_ERRNO;
1741
1742
1743 #            ifndef NOUNCRYPT
1744             if(s->encrypted)
1745             {
1746                 uInt i;
1747                 for(i=0;i<uReadThis;i++)
1748                   pfile_in_zip_read_info->read_buffer[i] =
1749                       zdecode(s->keys,s->pcrc_32_tab,
1750                               pfile_in_zip_read_info->read_buffer[i]);
1751             }
1752 #            endif
1753
1754
1755             pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
1756
1757             pfile_in_zip_read_info->rest_read_compressed-=uReadThis;
1758
1759             pfile_in_zip_read_info->stream.next_in =
1760                 (Bytef*)pfile_in_zip_read_info->read_buffer;
1761             pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis;
1762         }
1763
1764         if ((pfile_in_zip_read_info->compression_method==0) || (pfile_in_zip_read_info->raw))
1765         {
1766             uInt uDoCopy,i ;
1767
1768             if ((pfile_in_zip_read_info->stream.avail_in == 0) &&
1769                 (pfile_in_zip_read_info->rest_read_compressed == 0))
1770                 return (iRead==0) ? UNZ_EOF : iRead;
1771
1772             if (pfile_in_zip_read_info->stream.avail_out <
1773                             pfile_in_zip_read_info->stream.avail_in)
1774                 uDoCopy = pfile_in_zip_read_info->stream.avail_out ;
1775             else
1776                 uDoCopy = pfile_in_zip_read_info->stream.avail_in ;
1777
1778             for (i=0;i<uDoCopy;i++)
1779                 *(pfile_in_zip_read_info->stream.next_out+i) =
1780                         *(pfile_in_zip_read_info->stream.next_in+i);
1781
1782             pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uDoCopy;
1783
1784             pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,
1785                                 pfile_in_zip_read_info->stream.next_out,
1786                                 uDoCopy);
1787             pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy;
1788             pfile_in_zip_read_info->stream.avail_in -= uDoCopy;
1789             pfile_in_zip_read_info->stream.avail_out -= uDoCopy;
1790             pfile_in_zip_read_info->stream.next_out += uDoCopy;
1791             pfile_in_zip_read_info->stream.next_in += uDoCopy;
1792             pfile_in_zip_read_info->stream.total_out += uDoCopy;
1793             iRead += uDoCopy;
1794         }
1795         else if (pfile_in_zip_read_info->compression_method==Z_BZIP2ED)
1796         {
1797 #ifdef HAVE_BZIP2
1798             uLong uTotalOutBefore,uTotalOutAfter;
1799             const Bytef *bufBefore;
1800             uLong uOutThis;
1801
1802             pfile_in_zip_read_info->bstream.next_in        = (char*)pfile_in_zip_read_info->stream.next_in;
1803             pfile_in_zip_read_info->bstream.avail_in       = pfile_in_zip_read_info->stream.avail_in;
1804             pfile_in_zip_read_info->bstream.total_in_lo32  = pfile_in_zip_read_info->stream.total_in;
1805             pfile_in_zip_read_info->bstream.total_in_hi32  = 0;
1806             pfile_in_zip_read_info->bstream.next_out       = (char*)pfile_in_zip_read_info->stream.next_out;
1807             pfile_in_zip_read_info->bstream.avail_out      = pfile_in_zip_read_info->stream.avail_out;
1808             pfile_in_zip_read_info->bstream.total_out_lo32 = pfile_in_zip_read_info->stream.total_out;
1809             pfile_in_zip_read_info->bstream.total_out_hi32 = 0;
1810
1811             uTotalOutBefore = pfile_in_zip_read_info->bstream.total_out_lo32;
1812             bufBefore = (const Bytef *)pfile_in_zip_read_info->bstream.next_out;
1813
1814             err=BZ2_bzDecompress(&pfile_in_zip_read_info->bstream);
1815
1816             uTotalOutAfter = pfile_in_zip_read_info->bstream.total_out_lo32;
1817             uOutThis = uTotalOutAfter-uTotalOutBefore;
1818
1819             pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uOutThis;
1820
1821             pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,bufBefore, (uInt)(uOutThis));
1822             pfile_in_zip_read_info->rest_read_uncompressed -= uOutThis;
1823             iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
1824
1825             pfile_in_zip_read_info->stream.next_in   = (Bytef*)pfile_in_zip_read_info->bstream.next_in;
1826             pfile_in_zip_read_info->stream.avail_in  = pfile_in_zip_read_info->bstream.avail_in;
1827             pfile_in_zip_read_info->stream.total_in  = pfile_in_zip_read_info->bstream.total_in_lo32;
1828             pfile_in_zip_read_info->stream.next_out  = (Bytef*)pfile_in_zip_read_info->bstream.next_out;
1829             pfile_in_zip_read_info->stream.avail_out = pfile_in_zip_read_info->bstream.avail_out;
1830             pfile_in_zip_read_info->stream.total_out = pfile_in_zip_read_info->bstream.total_out_lo32;
1831
1832             if (err==BZ_STREAM_END)
1833               return (iRead==0) ? UNZ_EOF : iRead;
1834             if (err!=BZ_OK)
1835               break;
1836 #endif
1837         } // end Z_BZIP2ED
1838         else
1839         {
1840             ZPOS64_T uTotalOutBefore,uTotalOutAfter;
1841             const Bytef *bufBefore;
1842             ZPOS64_T uOutThis;
1843             int flush=Z_SYNC_FLUSH;
1844
1845             uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;
1846             bufBefore = pfile_in_zip_read_info->stream.next_out;
1847
1848             /*
1849             if ((pfile_in_zip_read_info->rest_read_uncompressed ==
1850                      pfile_in_zip_read_info->stream.avail_out) &&
1851                 (pfile_in_zip_read_info->rest_read_compressed == 0))
1852                 flush = Z_FINISH;
1853             */
1854             err=inflate(&pfile_in_zip_read_info->stream,flush);
1855
1856             if ((err>=0) && (pfile_in_zip_read_info->stream.msg!=NULL))
1857               err = Z_DATA_ERROR;
1858
1859             uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;
1860             uOutThis = uTotalOutAfter-uTotalOutBefore;
1861
1862             pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uOutThis;
1863
1864             pfile_in_zip_read_info->crc32 =
1865                 crc32(pfile_in_zip_read_info->crc32,bufBefore,
1866                         (uInt)(uOutThis));
1867
1868             pfile_in_zip_read_info->rest_read_uncompressed -=
1869                 uOutThis;
1870
1871             iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
1872
1873             if (err==Z_STREAM_END)
1874                 return (iRead==0) ? UNZ_EOF : iRead;
1875             if (err!=Z_OK)
1876                 break;
1877         }
1878     }
1879
1880     if (err==Z_OK)
1881         return iRead;
1882     return err;
1883 }
1884
1885
1886 /*
1887   Give the current position in uncompressed data
1888 */
1889 extern z_off_t ZEXPORT unztell (unzFile file)
1890 {
1891     unz64_s* s;
1892     file_in_zip64_read_info_s* pfile_in_zip_read_info;
1893     if (file==NULL)
1894         return UNZ_PARAMERROR;
1895     s=(unz64_s*)file;
1896     pfile_in_zip_read_info=s->pfile_in_zip_read;
1897
1898     if (pfile_in_zip_read_info==NULL)
1899         return UNZ_PARAMERROR;
1900
1901     return (z_off_t)pfile_in_zip_read_info->stream.total_out;
1902 }
1903
1904 extern ZPOS64_T ZEXPORT unztell64 (unzFile file)
1905 {
1906
1907     unz64_s* s;
1908     file_in_zip64_read_info_s* pfile_in_zip_read_info;
1909     if (file==NULL)
1910         return (ZPOS64_T)-1;
1911     s=(unz64_s*)file;
1912     pfile_in_zip_read_info=s->pfile_in_zip_read;
1913
1914     if (pfile_in_zip_read_info==NULL)
1915         return (ZPOS64_T)-1;
1916
1917     return pfile_in_zip_read_info->total_out_64;
1918 }
1919
1920
1921 /*
1922   return 1 if the end of file was reached, 0 elsewhere
1923 */
1924 extern int ZEXPORT unzeof (unzFile file)
1925 {
1926     unz64_s* s;
1927     file_in_zip64_read_info_s* pfile_in_zip_read_info;
1928     if (file==NULL)
1929         return UNZ_PARAMERROR;
1930     s=(unz64_s*)file;
1931     pfile_in_zip_read_info=s->pfile_in_zip_read;
1932
1933     if (pfile_in_zip_read_info==NULL)
1934         return UNZ_PARAMERROR;
1935
1936     if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
1937         return 1;
1938     else
1939         return 0;
1940 }
1941
1942
1943
1944 /*
1945 Read extra field from the current file (opened by unzOpenCurrentFile)
1946 This is the local-header version of the extra field (sometimes, there is
1947 more info in the local-header version than in the central-header)
1948
1949   if buf==NULL, it return the size of the local extra field that can be read
1950
1951   if buf!=NULL, len is the size of the buffer, the extra header is copied in
1952     buf.
1953   the return value is the number of bytes copied in buf, or (if <0)
1954     the error code
1955 */
1956 extern int ZEXPORT unzGetLocalExtrafield (unzFile file, voidp buf, unsigned len)
1957 {
1958     unz64_s* s;
1959     file_in_zip64_read_info_s* pfile_in_zip_read_info;
1960     uInt read_now;
1961     ZPOS64_T size_to_read;
1962
1963     if (file==NULL)
1964         return UNZ_PARAMERROR;
1965     s=(unz64_s*)file;
1966     pfile_in_zip_read_info=s->pfile_in_zip_read;
1967
1968     if (pfile_in_zip_read_info==NULL)
1969         return UNZ_PARAMERROR;
1970
1971     size_to_read = (pfile_in_zip_read_info->size_local_extrafield -
1972                 pfile_in_zip_read_info->pos_local_extrafield);
1973
1974     if (buf==NULL)
1975         return (int)size_to_read;
1976
1977     if (len>size_to_read)
1978         read_now = (uInt)size_to_read;
1979     else
1980         read_now = (uInt)len ;
1981
1982     if (read_now==0)
1983         return 0;
1984
1985     if (ZSEEK64(pfile_in_zip_read_info->z_filefunc,
1986               pfile_in_zip_read_info->filestream,
1987               pfile_in_zip_read_info->offset_local_extrafield +
1988               pfile_in_zip_read_info->pos_local_extrafield,
1989               ZLIB_FILEFUNC_SEEK_SET)!=0)
1990         return UNZ_ERRNO;
1991
1992     if (ZREAD64(pfile_in_zip_read_info->z_filefunc,
1993               pfile_in_zip_read_info->filestream,
1994               buf,read_now)!=read_now)
1995         return UNZ_ERRNO;
1996
1997     return (int)read_now;
1998 }
1999
2000 /*
2001   Close the file in zip opened with unzipOpenCurrentFile
2002   Return UNZ_CRCERROR if all the file was read but the CRC is not good
2003 */
2004 extern int ZEXPORT unzCloseCurrentFile (unzFile file)
2005 {
2006     int err=UNZ_OK;
2007
2008     unz64_s* s;
2009     file_in_zip64_read_info_s* pfile_in_zip_read_info;
2010     if (file==NULL)
2011         return UNZ_PARAMERROR;
2012     s=(unz64_s*)file;
2013     pfile_in_zip_read_info=s->pfile_in_zip_read;
2014
2015     if (pfile_in_zip_read_info==NULL)
2016         return UNZ_PARAMERROR;
2017
2018
2019     if ((pfile_in_zip_read_info->rest_read_uncompressed == 0) &&
2020         (!pfile_in_zip_read_info->raw))
2021     {
2022         if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait)
2023             err=UNZ_CRCERROR;
2024     }
2025
2026
2027     TRYFREE(pfile_in_zip_read_info->read_buffer);
2028     pfile_in_zip_read_info->read_buffer = NULL;
2029     if (pfile_in_zip_read_info->stream_initialised == Z_DEFLATED)
2030         inflateEnd(&pfile_in_zip_read_info->stream);
2031 #ifdef HAVE_BZIP2
2032     else if (pfile_in_zip_read_info->stream_initialised == Z_BZIP2ED)
2033         BZ2_bzDecompressEnd(&pfile_in_zip_read_info->bstream);
2034 #endif
2035
2036
2037     pfile_in_zip_read_info->stream_initialised = 0;
2038     TRYFREE(pfile_in_zip_read_info);
2039
2040     s->pfile_in_zip_read=NULL;
2041
2042     return err;
2043 }
2044
2045
2046 /*
2047   Get the global comment string of the ZipFile, in the szComment buffer.
2048   uSizeBuf is the size of the szComment buffer.
2049   return the number of byte copied or an error code <0
2050 */
2051 extern int ZEXPORT unzGetGlobalComment (unzFile file, char * szComment, uLong uSizeBuf)
2052 {
2053     unz64_s* s;
2054     uLong uReadThis ;
2055     if (file==NULL)
2056         return (int)UNZ_PARAMERROR;
2057     s=(unz64_s*)file;
2058
2059     uReadThis = uSizeBuf;
2060     if (uReadThis>s->gi.size_comment)
2061         uReadThis = s->gi.size_comment;
2062
2063     if (ZSEEK64(s->z_filefunc,s->filestream,s->central_pos+22,ZLIB_FILEFUNC_SEEK_SET)!=0)
2064         return UNZ_ERRNO;
2065
2066     if (uReadThis>0)
2067     {
2068       *szComment='\0';
2069       if (ZREAD64(s->z_filefunc,s->filestream,szComment,uReadThis)!=uReadThis)
2070         return UNZ_ERRNO;
2071     }
2072
2073     if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment))
2074         *(szComment+s->gi.size_comment)='\0';
2075     return (int)uReadThis;
2076 }
2077
2078 /* Additions by RX '2004 */
2079 extern ZPOS64_T ZEXPORT unzGetOffset64(unzFile file)
2080 {
2081     unz64_s* s;
2082
2083     if (file==NULL)
2084           return 0; //UNZ_PARAMERROR;
2085     s=(unz64_s*)file;
2086     if (!s->current_file_ok)
2087       return 0;
2088     if (s->gi.number_entry != 0 && s->gi.number_entry != 0xffff)
2089       if (s->num_file==s->gi.number_entry)
2090          return 0;
2091     return s->pos_in_central_dir;
2092 }
2093
2094 extern uLong ZEXPORT unzGetOffset (unzFile file)
2095 {
2096     ZPOS64_T offset64;
2097
2098     if (file==NULL)
2099           return 0; //UNZ_PARAMERROR;
2100     offset64 = unzGetOffset64(file);
2101     return (uLong)offset64;
2102 }
2103
2104 extern int ZEXPORT unzSetOffset64(unzFile file, ZPOS64_T pos)
2105 {
2106     unz64_s* s;
2107     int err;
2108
2109     if (file==NULL)
2110         return UNZ_PARAMERROR;
2111     s=(unz64_s*)file;
2112
2113     s->pos_in_central_dir = pos;
2114     s->num_file = s->gi.number_entry;      /* hack */
2115     err = unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,
2116                                               &s->cur_file_info_internal,
2117                                               NULL,0,NULL,0,NULL,0);
2118     s->current_file_ok = (err == UNZ_OK);
2119     return err;
2120 }
2121
2122 extern int ZEXPORT unzSetOffset (unzFile file, uLong pos)
2123 {
2124     return unzSetOffset64(file,pos);
2125 }