/* unzip.c -- IO for uncompress .zip files using zlib

   Version 1.1, February 14h, 2010

   part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )

         Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )

         Modifications of Unzip for Zip64

         Copyright (C) 2007-2008 Even Rouault

         Modifications for Zip64 support on both zip and unzip

         Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )

         For more info read MiniZip_info.txt

  ------------------------------------------------------------------------------------

  Decryption code comes from crypt.c by Info-ZIP but has been greatly reduced in terms of

  compatibility with older software. The following is from the original crypt.c.

  Code woven in by Terry Thorsen 1/2003.

  Copyright (c) 1990-2000 Info-ZIP.  All rights reserved.

  See the accompanying file LICENSE, version 2000-Apr-09 or later

  (the contents of which are also included in zip.h) for terms of use.

  If, for some reason, all these files are missing, the Info-ZIP license

  also may be found at:  ftp://ftp.info-zip.org/pub/infozip/license.html

        crypt.c (full version) by Info-ZIP.      Last revised:  [see crypt.h]

  The encryption/decryption parts of this source code (as opposed to the

  non-echoing password parts) were originally written in Europe.  The

  whole source package can be freely distributed, including from the USA.

  (Prior to January 2000, re-export from the US was a violation of US law.)

        This encryption code is a direct transcription of the algorithm from

  Roger Schlafly, described by Phil Katz in the file appnote.txt.  This

  file (appnote.txt) is distributed with the PKZIP program (even in the

  version without encryption capabilities).

        ------------------------------------------------------------------------------------

        Changes in unzip.c

        2007-2008 - Even Rouault - Addition of cpl_unzGetCurrentFileZStreamPos

  2007-2008 - Even Rouault - Decoration of symbol names unz* -> cpl_unz*

  2007-2008 - Even Rouault - Remove old C style function prototypes

  2007-2008 - Even Rouault - Add unzip support for ZIP64

        Copyright (C) 2007-2008 Even Rouault

        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).

  Oct-2009 - Mathias Svensson - Fixed problem if uncompressed size was > 4G and compressed size was <4G

                                should only read the compressed/uncompressed size from the Zip64 format if

                                the size from normal header was 0xFFFFFFFF

  Oct-2009 - Mathias Svensson - Applied some bug fixes from paches recived from Gilles Vollant

        Oct-2009 - Mathias Svensson - Applied support to unzip files with compression mathod BZIP2 (bzip2 lib is required)

                                Patch created by Daniel Borca

  Jan-2010 - back to unzip and minizip 1.0 name scheme, with compatibility layer

  Copyright (C) 1998 - 2010 Gilles Vollant, Even Rouault, Mathias Svensson

*/

#include <stdio.h></stdio.h>

#include <stdlib.h></stdlib.h>

#include <string.h></string.h>

#ifndef NOUNCRYPT

        #define NOUNCRYPT

#endif

#include "zlib.h"

#include "unzip.h"

#ifdef STDC

#  include <stddef.h></stddef.h>

#  include <string.h></string.h>

#  include <stdlib.h></stdlib.h>

#endif

#ifdef NO_ERRNO_H

    extern int errno;

#else

#   include <errno.h></errno.h>

#endif

#ifndef local

#  define local static

#endif

/* compile with -Dlocal if your debugger can't find static symbols */

#ifndef CASESENSITIVITYDEFAULT_NO

#  if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES)

#    define CASESENSITIVITYDEFAULT_NO

#  endif

#endif

#ifndef UNZ_BUFSIZE

#define UNZ_BUFSIZE (16384)

#endif

#ifndef UNZ_MAXFILENAMEINZIP

#define UNZ_MAXFILENAMEINZIP (256)

#endif

#ifndef ALLOC

# define ALLOC(size) (malloc(size))

#endif

#ifndef TRYFREE

# define TRYFREE(p) {if (p) free(p);}

#endif

#define SIZECENTRALDIRITEM (0x2e)

#define SIZEZIPLOCALHEADER (0x1e)

const char unz_copyright[] =

   " unzip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll";

/* unz_file_info_interntal contain internal info about a file in zipfile*/

typedef struct unz_file_info64_internal_s

{

    ZPOS64_T offset_curfile;/* relative offset of local header 8 bytes */

} unz_file_info64_internal;

/* file_in_zip_read_info_s contain internal information about a file in zipfile,

    when reading and decompress it */

typedef struct

{

    char  *read_buffer;         /* internal buffer for compressed data */

    z_stream stream;            /* zLib stream structure for inflate */

#ifdef HAVE_BZIP2

    bz_stream bstream;          /* bzLib stream structure for bziped */

#endif

    ZPOS64_T pos_in_zipfile;       /* position in byte on the zipfile, for fseek*/

    uLong stream_initialised;   /* flag set if stream structure is initialised*/

    ZPOS64_T offset_local_extrafield;/* offset of the local extra field */

    uInt  size_local_extrafield;/* size of the local extra field */

    ZPOS64_T pos_local_extrafield;   /* position in the local extra field in read*/

    ZPOS64_T total_out_64;

    uLong crc32;                /* crc32 of all data uncompressed */

    uLong crc32_wait;           /* crc32 we must obtain after decompress all */

    ZPOS64_T rest_read_compressed; /* number of byte to be decompressed */

    ZPOS64_T rest_read_uncompressed;/*number of byte to be obtained after decomp*/

    zlib_filefunc64_32_def z_filefunc;

    voidpf filestream;        /* io structore of the zipfile */

    uLong compression_method;   /* compression method (0==store) */

    ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/

    int   raw;

} file_in_zip64_read_info_s;

/* unz64_s contain internal information about the zipfile

*/

typedef struct

{

    zlib_filefunc64_32_def z_filefunc;

    int is64bitOpenFunction;

    voidpf filestream;        /* io structore of the zipfile */

    unz_global_info64 gi;       /* public global information */

    ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/

    ZPOS64_T num_file;             /* number of the current file in the zipfile*/

    ZPOS64_T pos_in_central_dir;   /* pos of the current file in the central dir*/

    ZPOS64_T current_file_ok;      /* flag about the usability of the current file*/

    ZPOS64_T central_pos;          /* position of the beginning of the central dir*/

    ZPOS64_T size_central_dir;     /* size of the central directory  */

    ZPOS64_T offset_central_dir;   /* offset of start of central directory with

                                   respect to the starting disk number */

    unz_file_info64 cur_file_info; /* public info about the current file in zip*/

    unz_file_info64_internal cur_file_info_internal; /* private info about it*/

    file_in_zip64_read_info_s* pfile_in_zip_read; /* structure about the current

                                        file if we are decompressing it */

    int encrypted;

    int isZip64;

#    ifndef NOUNCRYPT

    unsigned long keys[3];     /* keys defining the pseudo-random sequence */

    const z_crc_t* pcrc_32_tab;

#    endif

} unz64_s;

#ifndef NOUNCRYPT

#include "crypt.h"

#endif

/* ===========================================================================

     Read a byte from a gz_stream; update next_in and avail_in. Return EOF

   for end of file.

   IN assertion: the stream s has been sucessfully opened for reading.

*/

local int unz64local_getByte OF((

    const zlib_filefunc64_32_def* pzlib_filefunc_def,

    voidpf filestream,

    int *pi));

local int unz64local_getByte(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, int *pi)

{

    unsigned char c;

    int err = (int)ZREAD64(*pzlib_filefunc_def,filestream,&c,1);

    if (err==1)

    {

        *pi = (int)c;

        return UNZ_OK;

    }

    else

    {

        if (ZERROR64(*pzlib_filefunc_def,filestream))

            return UNZ_ERRNO;

        else

            return UNZ_EOF;

    }

}

/* ===========================================================================

   Reads a long in LSB order from the given gz_stream. Sets

*/

local int unz64local_getShort OF((

    const zlib_filefunc64_32_def* pzlib_filefunc_def,

    voidpf filestream,

    uLong *pX));

local int unz64local_getShort (const zlib_filefunc64_32_def* pzlib_filefunc_def,

                             voidpf filestream,

                             uLong *pX)

{

    uLong x ;

    int i = 0;

    int err;

    err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);

    x = (uLong)i;

    if (err==UNZ_OK)

        err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);

    x |= ((uLong)i)<<8;

    if (err==UNZ_OK)

        *pX = x;

    else

        *pX = 0;

    return err;

}

local int unz64local_getLong OF((

    const zlib_filefunc64_32_def* pzlib_filefunc_def,

    voidpf filestream,

    uLong *pX));

local int unz64local_getLong (const zlib_filefunc64_32_def* pzlib_filefunc_def,

                            voidpf filestream,

                            uLong *pX)

{

    uLong x ;

    int i = 0;

    int err;

    err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);

    x = (uLong)i;

    if (err==UNZ_OK)

        err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);

    x |= ((uLong)i)<<8;

    if (err==UNZ_OK)

        err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);

    x |= ((uLong)i)<<16;

    if (err==UNZ_OK)

        err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);

    x += ((uLong)i)<<24;

    if (err==UNZ_OK)

        *pX = x;

    else

        *pX = 0;

    return err;

}

local int unz64local_getLong64 OF((

    const zlib_filefunc64_32_def* pzlib_filefunc_def,

    voidpf filestream,

    ZPOS64_T *pX));

local int unz64local_getLong64 (const zlib_filefunc64_32_def* pzlib_filefunc_def,

                            voidpf filestream,

                            ZPOS64_T *pX)

{

    ZPOS64_T x ;

    int i = 0;

    int err;

    err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);

    x = (ZPOS64_T)i;

    if (err==UNZ_OK)

        err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);

    x |= ((ZPOS64_T)i)<<8;

    if (err==UNZ_OK)

        err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);

    x |= ((ZPOS64_T)i)<<16;

    if (err==UNZ_OK)

        err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);

    x |= ((ZPOS64_T)i)<<24;

    if (err==UNZ_OK)

        err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);

    x |= ((ZPOS64_T)i)<<32;

    if (err==UNZ_OK)

        err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);

    x |= ((ZPOS64_T)i)<<40;

    if (err==UNZ_OK)

        err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);

    x |= ((ZPOS64_T)i)<<48;

    if (err==UNZ_OK)

        err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);

    x |= ((ZPOS64_T)i)<<56;

    if (err==UNZ_OK)

        *pX = x;

    else

        *pX = 0;

    return err;

}

/* My own strcmpi / strcasecmp */

local int strcmpcasenosensitive_internal (const char* fileName1, const char* fileName2)

{

    for (;;)

    {

        char c1=*(fileName1++);

        char c2=*(fileName2++);

        if ((c1>='a') && (c1<='z'))

            c1 -= 0x20;

        if ((c2>='a') && (c2<='z'))

            c2 -= 0x20;

        if (c1=='\0')

            return ((c2=='\0') ? 0 : -1);

        if (c2=='\0')

            return 1;

        if (c1

            return -1;

        if (c1>c2)

            return 1;

    }

}

#ifdef  CASESENSITIVITYDEFAULT_NO

#define CASESENSITIVITYDEFAULTVALUE 2

#else

#define CASESENSITIVITYDEFAULTVALUE 1

#endif

#ifndef STRCMPCASENOSENTIVEFUNCTION

#define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal

#endif

/*

   Compare two filename (fileName1,fileName2).

   If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)

   If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi

                                                                or strcasecmp)

   If iCaseSenisivity = 0, case sensitivity is defaut of your operating system

        (like 1 on Unix, 2 on Windows)

*/

extern int ZEXPORT unzStringFileNameCompare (const char*  fileName1,

                                                 const char*  fileName2,

                                                 int iCaseSensitivity)

{

    if (iCaseSensitivity==0)

        iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE;

    if (iCaseSensitivity==1)

        return strcmp(fileName1,fileName2);

    return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2);

}

#ifndef BUFREADCOMMENT

#define BUFREADCOMMENT (0x400)

#endif

/*

  Locate the Central directory of a zipfile (at the end, just before

    the global comment)

*/

local ZPOS64_T unz64local_SearchCentralDir OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream));

local ZPOS64_T unz64local_SearchCentralDir(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)

{

    unsigned char* buf;

    ZPOS64_T uSizeFile;

    ZPOS64_T uBackRead;

    ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */

    ZPOS64_T uPosFound=0;

    if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)

        return 0;

    uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);

    if (uMaxBack>uSizeFile)

        uMaxBack = uSizeFile;

    buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);

    if (buf==NULL)

        return 0;

    uBackRead = 4;

    while (uBackRead

    {

        uLong uReadSize;

        ZPOS64_T uReadPos ;

        int i;

        if (uBackRead+BUFREADCOMMENT>uMaxBack)

            uBackRead = uMaxBack;

        else

            uBackRead+=BUFREADCOMMENT;

        uReadPos = uSizeFile-uBackRead ;

        uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?

                     (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);

        if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)

            break;

        if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)

            break;

        for (i=(int)uReadSize-3; (i--)>0;)

            if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&

                ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))

            {

                uPosFound = uReadPos+i;

                break;

            }

        if (uPosFound!=0)

            break;

    }

    TRYFREE(buf);

    return uPosFound;

}

/*

  Locate the Central directory 64 of a zipfile (at the end, just before

    the global comment)

*/

local ZPOS64_T unz64local_SearchCentralDir64 OF((

    const zlib_filefunc64_32_def* pzlib_filefunc_def,

    voidpf filestream));

local ZPOS64_T unz64local_SearchCentralDir64(const zlib_filefunc64_32_def* pzlib_filefunc_def,

                                      voidpf filestream)

{

    unsigned char* buf;

    ZPOS64_T uSizeFile;

    ZPOS64_T uBackRead;

    ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */

    ZPOS64_T uPosFound=0;

    uLong uL;

                ZPOS64_T relativeOffset;

    if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)

        return 0;

    uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);

    if (uMaxBack>uSizeFile)

        uMaxBack = uSizeFile;

    buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);

    if (buf==NULL)

        return 0;

    uBackRead = 4;

    while (uBackRead

    {

        uLong uReadSize;

        ZPOS64_T uReadPos;

        int i;

        if (uBackRead+BUFREADCOMMENT>uMaxBack)

            uBackRead = uMaxBack;

        else

            uBackRead+=BUFREADCOMMENT;

        uReadPos = uSizeFile-uBackRead ;

        uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?

                     (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);

        if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)

            break;

        if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)

            break;

        for (i=(int)uReadSize-3; (i--)>0;)

            if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&

                ((*(buf+i+2))==0x06) && ((*(buf+i+3))==0x07))

            {

                uPosFound = uReadPos+i;

                break;

            }

        if (uPosFound!=0)

            break;

    }

    TRYFREE(buf);

    if (uPosFound == 0)

        return 0;

    /* Zip64 end of central directory locator */

    if (ZSEEK64(*pzlib_filefunc_def,filestream, uPosFound,ZLIB_FILEFUNC_SEEK_SET)!=0)

        return 0;

    /* the signature, already checked */

    if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)

        return 0;

    /* number of the disk with the start of the zip64 end of  central directory */

    if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)

        return 0;

    if (uL != 0)

        return 0;

    /* relative offset of the zip64 end of central directory record */

    if (unz64local_getLong64(pzlib_filefunc_def,filestream,&relativeOffset)!=UNZ_OK)

        return 0;

    /* total number of disks */

    if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)

        return 0;

    if (uL != 1)

        return 0;

    /* Goto end of central directory record */

    if (ZSEEK64(*pzlib_filefunc_def,filestream, relativeOffset,ZLIB_FILEFUNC_SEEK_SET)!=0)

        return 0;

     /* the signature */

    if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)

        return 0;

    if (uL != 0x06064b50)

        return 0;

    return relativeOffset;

}

/*

  Open a Zip file. path contain the full pathname (by example,

     on a Windows NT computer "c:\\test\\zlib114.zip" or on an Unix computer

     "zlib/zlib114.zip".

     If the zipfile cannot be opened (file doesn't exist or in not valid), the

       return value is NULL.

     Else, the return value is a unzFile Handle, usable with other function

       of this unzip package.

*/

local unzFile unzOpenInternal (const void *path,

                               zlib_filefunc64_32_def* pzlib_filefunc64_32_def,

                               int is64bitOpenFunction)

{

    unz64_s us;

    unz64_s *s;

    ZPOS64_T central_pos;

    uLong   uL;

    uLong number_disk;          /* number of the current dist, used for

                                   spaning ZIP, unsupported, always 0*/

    uLong number_disk_with_CD;  /* number the the disk with central dir, used

                                   for spaning ZIP, unsupported, always 0*/

    ZPOS64_T number_entry_CD;      /* total number of entries in

                                   the central dir

                                   (same than number_entry on nospan) */

    int err=UNZ_OK;

    if (unz_copyright[0]!=' ')

        return NULL;

    us.z_filefunc.zseek32_file = NULL;

    us.z_filefunc.ztell32_file = NULL;

    if (pzlib_filefunc64_32_def==NULL)

        fill_fopen64_filefunc(&us.z_filefunc.zfile_func64);

    else

        us.z_filefunc = *pzlib_filefunc64_32_def;

    us.is64bitOpenFunction = is64bitOpenFunction;

    us.filestream = ZOPEN64(us.z_filefunc,

                                                 path,

                                                 ZLIB_FILEFUNC_MODE_READ |

                                                 ZLIB_FILEFUNC_MODE_EXISTING);

    if (us.filestream==NULL)

        return NULL;

    central_pos = unz64local_SearchCentralDir64(&us.z_filefunc,us.filestream);

    if (central_pos)

    {

        uLong uS;

        ZPOS64_T uL64;

        us.isZip64 = 1;

        if (ZSEEK64(us.z_filefunc, us.filestream,

                                      central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)

        err=UNZ_ERRNO;

        /* the signature, already checked */

        if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)

            err=UNZ_ERRNO;

        /* size of zip64 end of central directory record */

        if (unz64local_getLong64(&us.z_filefunc, us.filestream,&uL64)!=UNZ_OK)

            err=UNZ_ERRNO;

        /* version made by */

        if (unz64local_getShort(&us.z_filefunc, us.filestream,&uS)!=UNZ_OK)

            err=UNZ_ERRNO;

        /* version needed to extract */

        if (unz64local_getShort(&us.z_filefunc, us.filestream,&uS)!=UNZ_OK)

            err=UNZ_ERRNO;

        /* number of this disk */

        if (unz64local_getLong(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK)

            err=UNZ_ERRNO;

        /* number of the disk with the start of the central directory */

        if (unz64local_getLong(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK)

            err=UNZ_ERRNO;

        /* total number of entries in the central directory on this disk */

        if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.gi.number_entry)!=UNZ_OK)

            err=UNZ_ERRNO;

        /* total number of entries in the central directory */

        if (unz64local_getLong64(&us.z_filefunc, us.filestream,&number_entry_CD)!=UNZ_OK)

            err=UNZ_ERRNO;

        if ((number_entry_CD!=us.gi.number_entry) ||

            (number_disk_with_CD!=0) ||

            (number_disk!=0))

            err=UNZ_BADZIPFILE;

        /* size of the central directory */

        if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.size_central_dir)!=UNZ_OK)

            err=UNZ_ERRNO;

        /* offset of start of central directory with respect to the

          starting disk number */

        if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.offset_central_dir)!=UNZ_OK)

            err=UNZ_ERRNO;

        us.gi.size_comment = 0;

    }

    else

    {

        central_pos = unz64local_SearchCentralDir(&us.z_filefunc,us.filestream);

        if (central_pos==0)

            err=UNZ_ERRNO;

        us.isZip64 = 0;

        if (ZSEEK64(us.z_filefunc, us.filestream,

                                        central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)

            err=UNZ_ERRNO;

        /* the signature, already checked */

        if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)

            err=UNZ_ERRNO;

        /* number of this disk */

        if (unz64local_getShort(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK)

            err=UNZ_ERRNO;

        /* number of the disk with the start of the central directory */

        if (unz64local_getShort(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK)

            err=UNZ_ERRNO;

        /* total number of entries in the central dir on this disk */

        if (unz64local_getShort(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)

            err=UNZ_ERRNO;

        us.gi.number_entry = uL;

        /* total number of entries in the central dir */

        if (unz64local_getShort(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)

            err=UNZ_ERRNO;

        number_entry_CD = uL;

        if ((number_entry_CD!=us.gi.number_entry) ||

            (number_disk_with_CD!=0) ||

            (number_disk!=0))

            err=UNZ_BADZIPFILE;

        /* size of the central directory */

        if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)

            err=UNZ_ERRNO;

        us.size_central_dir = uL;

        /* offset of start of central directory with respect to the

            starting disk number */

        if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)

            err=UNZ_ERRNO;

        us.offset_central_dir = uL;

        /* zipfile comment length */

        if (unz64local_getShort(&us.z_filefunc, us.filestream,&us.gi.size_comment)!=UNZ_OK)

            err=UNZ_ERRNO;

    }

    if ((central_pos

        (err==UNZ_OK))

        err=UNZ_BADZIPFILE;

    if (err!=UNZ_OK)

    {

        ZCLOSE64(us.z_filefunc, us.filestream);

        return NULL;

    }

    us.byte_before_the_zipfile = central_pos -

                            (us.offset_central_dir+us.size_central_dir);

    us.central_pos = central_pos;

    us.pfile_in_zip_read = NULL;

    us.encrypted = 0;

    s=(unz64_s*)ALLOC(sizeof(unz64_s));

    if( s != NULL)

    {

        *s=us;

        unzGoToFirstFile((unzFile)s);

    }

    return (unzFile)s;

}

extern unzFile ZEXPORT unzOpen2 (const char *path,

                                        zlib_filefunc_def* pzlib_filefunc32_def)

{

    if (pzlib_filefunc32_def != NULL)

    {

        zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;

        fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill,pzlib_filefunc32_def);

        return unzOpenInternal(path, &zlib_filefunc64_32_def_fill, 0);

    }

    else

        return unzOpenInternal(path, NULL, 0);

}

extern unzFile ZEXPORT unzOpen2_64 (const void *path,

                                     zlib_filefunc64_def* pzlib_filefunc_def)

{

    if (pzlib_filefunc_def != NULL)

    {

        zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;

        zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def;

        zlib_filefunc64_32_def_fill.ztell32_file = NULL;

        zlib_filefunc64_32_def_fill.zseek32_file = NULL;

        return unzOpenInternal(path, &zlib_filefunc64_32_def_fill, 1);

    }

    else

        return unzOpenInternal(path, NULL, 1);

}

extern unzFile ZEXPORT unzOpen (const char *path)

{

    return unzOpenInternal(path, NULL, 0);

}

extern unzFile ZEXPORT unzOpen64 (const void *path)

{

    return unzOpenInternal(path, NULL, 1);

}

/*

  Close a ZipFile opened with unzOpen.

  If there is files inside the .Zip opened with unzOpenCurrentFile (see later),

    these files MUST be closed with unzCloseCurrentFile before call unzClose.

  return UNZ_OK if there is no problem. */

extern int ZEXPORT unzClose (unzFile file)

{

    unz64_s* s;

    if (file==NULL)

        return UNZ_PARAMERROR;

    s=(unz64_s*)file;

    if (s->pfile_in_zip_read!=NULL)

        unzCloseCurrentFile(file);

    ZCLOSE64(s->z_filefunc, s->filestream);

    TRYFREE(s);

    return UNZ_OK;

}

/*

  Write info about the ZipFile in the *pglobal_info structure.

  No preparation of the structure is needed

  return UNZ_OK if there is no problem. */

extern int ZEXPORT unzGetGlobalInfo64 (unzFile file, unz_global_info64* pglobal_info)

{

    unz64_s* s;

    if (file==NULL)

        return UNZ_PARAMERROR;

    s=(unz64_s*)file;

    *pglobal_info=s->gi;

    return UNZ_OK;

}

extern int ZEXPORT unzGetGlobalInfo (unzFile file, unz_global_info* pglobal_info32)

{

    unz64_s* s;

    if (file==NULL)

        return UNZ_PARAMERROR;

    s=(unz64_s*)file;

    /* to do : check if number_entry is not truncated */

    pglobal_info32->number_entry = (uLong)s->gi.number_entry;

    pglobal_info32->size_comment = s->gi.size_comment;

    return UNZ_OK;

}

/*

   Translate date/time from Dos format to tm_unz (readable more easilty)

*/

local void unz64local_DosDateToTmuDate (ZPOS64_T ulDosDate, tm_unz* ptm)

{

    ZPOS64_T uDate;

    uDate = (ZPOS64_T)(ulDosDate>>16);

    ptm->tm_mday = (uInt)(uDate&0x1f) ;

    ptm->tm_mon =  (uInt)((((uDate)&0x1E0)/0x20)-1) ;

    ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ;

    ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800);

    ptm->tm_min =  (uInt) ((ulDosDate&0x7E0)/0x20) ;

    ptm->tm_sec =  (uInt) (2*(ulDosDate&0x1f)) ;

}

/*

  Get Info about the current file in the zipfile, with internal only info

*/

local int unz64local_GetCurrentFileInfoInternal OF((unzFile file,

                                                  unz_file_info64 *pfile_info,

                                                  unz_file_info64_internal

                                                  *pfile_info_internal,

                                                  char *szFileName,

                                                  uLong fileNameBufferSize,

                                                  void *extraField,

                                                  uLong extraFieldBufferSize,

                                                  char *szComment,

                                                  uLong commentBufferSize));