Home | History | Annotate | Download | only in minizip
      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 == MAXU32)
   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 == MAXU32)
   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 == MAXU32)
   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 == MAXU32)
   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) && (pfile_info != NULL))
   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 (at) 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 }
   2126