/* 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>

#include <stdlib.h>

#include <string.h>

#ifndef NOUNCRYPT

#define NOUNCRYPT

#endif

#include "zlib.h"

#include "unzip.h"

#ifdef STDC

# include <stddef.h>

# include <string.h>

# include <stdlib.h>

#endif

#ifdef NO_ERRNO_H

extern int errno;

#else

# include <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 successfully 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<c2)

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

{

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

{

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<us.offset_central_dir+us.size_central_dir) &&

(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));

local int unz64local_GetCurrentFileInfoInternal (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)

{

unz64_s* s;

unz_file_info64 file_info;

unz_file_info64_internal file_info_internal;

int err=UNZ_OK;

uLong uMagic;

long lSeek=0;

uLong uL;

if (file==NULL)

return UNZ_PARAMERROR;

s=(unz64_s*)file;

if (ZSEEK64(s->z_filefunc, s->filestream,

s->pos_in_central_dir+s->byte_before_the_zipfile,

ZLIB_FILEFUNC_SEEK_SET)!=0)

err=UNZ_ERRNO;

/* we check the magic */

if (err==UNZ_OK)

{

if (unz64local_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)

err=UNZ_ERRNO;

else if (uMagic!=0x02014b50)

err=UNZ_BADZIPFILE;

}

if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.version) != UNZ_OK)

err=UNZ_ERRNO;

if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.version_needed) != UNZ_OK)

err=UNZ_ERRNO;

if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.flag) != UNZ_OK)

err=UNZ_ERRNO;

if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.compression_method) != UNZ_OK)

err=UNZ_ERRNO;

if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.dosDate) != UNZ_OK)

err=UNZ_ERRNO;

unz64local_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date);

if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.crc) != UNZ_OK)

err=UNZ_ERRNO;

if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)

err=UNZ_ERRNO;

file_info.compressed_size = uL;

if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)

err=UNZ_ERRNO;

file_info.uncompressed_size = uL;

if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_filename) != UNZ_OK)

err=UNZ_ERRNO;

if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_extra) != UNZ_OK)

err=UNZ_ERRNO;

if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_comment) != UNZ_OK)

err=UNZ_ERRNO;

if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.disk_num_start) != UNZ_OK)

err=UNZ_ERRNO;

if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.internal_fa) != UNZ_OK)

err=UNZ_ERRNO;

if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.external_fa) != UNZ_OK)

err=UNZ_ERRNO;

// relative offset of local header

if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)

err=UNZ_ERRNO;

file_info_internal.offset_curfile = uL;

lSeek+=file_info.size_filename;

if ((err==UNZ_OK) && (szFileName!=NULL))

{

uLong uSizeRead ;

if (file_info.size_filename<fileNameBufferSize)

{

*(szFileName+file_info.size_filename)='\0';

uSizeRead = file_info.size_filename;

}

else

uSizeRead = fileNameBufferSize;

if ((file_info.size_filename>0) && (fileNameBufferSize>0))

if (ZREAD64(s->z_filefunc, s->filestream,szFileName,uSizeRead)!=uSizeRead)

err=UNZ_ERRNO;

lSeek -= uSizeRead;

}

// Read extrafield

if ((err==UNZ_OK) && (extraField!=NULL))

{

ZPOS64_T uSizeRead ;

if (file_info.size_file_extra<extraFieldBufferSize)

uSizeRead = file_info.size_file_extra;

else

uSizeRead = extraFieldBufferSize;

if (lSeek!=0)

{

if (ZSEEK64(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)

lSeek=0;

else

err=UNZ_ERRNO;

}