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

Version 1.1, February 14h, 2010

part of the MiniZip project

Copyright (C) 1998-2010 Gilles Vollant

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

Modifications for AES, PKWARE disk spanning

Copyright (C) 2010-2014 Nathan Moinvaziri

This program is distributed under the terms of the same license as zlib.

See the accompanying LICENSE file for the full text of the license.

*/

#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

#ifdef HAVE_AES

# define AES_METHOD (99)

# define AES_PWVERIFYSIZE (2)

# define AES_MAXSALTLENGTH (16)

# define AES_AUTHCODESIZE (10)

# define AES_HEADERSIZE (11)

# define AES_KEYSIZE(mode) (64 + (mode * 64))

# include "aes/aes.h"

# include "aes/fileenc.h"

#endif

#ifndef NOUNCRYPT

# include "crypt.h"

#endif

#ifndef local

# define local static

#endif

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

#define DISKHEADERMAGIC (0x08074b50)

#define LOCALHEADERMAGIC (0x04034b50)

#define CENTRALHEADERMAGIC (0x02014b50)

#define ENDHEADERMAGIC (0x06054b50)

#define ZIP64ENDHEADERMAGIC (0x06064b50)

#define ZIP64ENDLOCHEADERMAGIC (0x07064b50)

#define SIZECENTRALDIRITEM (0x2e)

#define SIZECENTRALHEADERLOCATOR (0x14) /* 20 */

#define SIZEZIPLOCALHEADER (0x1e)

#ifndef BUFREADCOMMENT

# define BUFREADCOMMENT (0x400)

#endif

#ifndef UNZ_BUFSIZE

# define UNZ_BUFSIZE (64 * 1024)

#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

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

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

#ifdef HAVE_AES

uLong aes_encryption_mode;

uLong aes_compression_method;

uLong aes_version;

#endif

} unz_file_info64_internal;

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

typedef struct

{

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

#ifdef HAVE_AES

fcrypt_ctx aes_ctx;

#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;

voidpf filestream; /* io structure of the current zipfile */

voidpf filestream_with_CD; /* io structure of the disk with the central directory */

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

uLong number_disk; /* number of the current disk, used for spanning ZIP*/

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 isZip64; /* is the current file zip64 */

#ifndef NOUNCRYPT

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

const unsigned long* pcrc_32_tab;

#endif

} unz64_s;

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

local void unz64local_DosDateToTmuDate (ZPOS64_T ulDosDate, tm_unz* ptm)

{

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

#define unz64local_in_range(min, max, value) ((min) <= (value) && (value) <= (max))

if (!unz64local_in_range(0, 11, ptm->tm_mon) ||

!unz64local_in_range(1, 31, ptm->tm_mday) ||

!unz64local_in_range(0, 23, ptm->tm_hour) ||

!unz64local_in_range(0, 59, ptm->tm_min) ||

!unz64local_in_range(0, 59, ptm->tm_sec))

/* Invalid date stored, so don't return it. */

memset(ptm, 0, sizeof(tm_unz));

#undef unz64local_in_range

}

/* Read a byte from a gz_stream; Return EOF for end of file. */

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;

}

*pi = 0;

if (ZERROR64(*pzlib_filefunc_def, filestream))

return UNZ_ERRNO;

return UNZ_EOF;

}

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;

}

/* Locate the Central directory of a zip file (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 file_size;

ZPOS64_T back_read = 4;

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

ZPOS64_T pos_found = 0;

uLong read_size;

ZPOS64_T read_pos;

int i;

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

if (buf == NULL)

return 0;

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

{

TRYFREE(buf);

return 0;

}

file_size = ZTELL64(*pzlib_filefunc_def, filestream);

if (max_back > file_size)

max_back = file_size;

while (back_read < max_back)

{

if (back_read + BUFREADCOMMENT > max_back)

back_read = max_back;

else

back_read += BUFREADCOMMENT;

read_pos = file_size - back_read;

read_size = ((BUFREADCOMMENT + 4) < (file_size - read_pos)) ?

(BUFREADCOMMENT + 4) : (uLong)(file_size - read_pos);

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

break;

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

break;

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

if (((*(buf+i)) == (ENDHEADERMAGIC & 0xff)) &&

((*(buf+i+1)) == (ENDHEADERMAGIC >> 8 & 0xff)) &&

((*(buf+i+2)) == (ENDHEADERMAGIC >> 16 & 0xff)) &&

((*(buf+i+3)) == (ENDHEADERMAGIC >> 24 & 0xff)))

{

pos_found = read_pos+i;

break;

}

if (pos_found != 0)

break;

}

TRYFREE(buf);

return pos_found;

}

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

const ZPOS64_T endcentraloffset));

local ZPOS64_T unz64local_SearchCentralDir64(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream,

const ZPOS64_T endcentraloffset)

{

ZPOS64_T offset;

uLong uL;

/* Zip64 end of central directory locator */

if (ZSEEK64(*pzlib_filefunc_def, filestream, endcentraloffset - SIZECENTRALHEADERLOCATOR, ZLIB_FILEFUNC_SEEK_SET) != 0)

return 0;

/* read locator signature */

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

return 0;

if (uL != ZIP64ENDLOCHEADERMAGIC)

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;

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

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

return 0;

/* total number of disks */

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

return 0;

/* Goto end of central directory record */

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

return 0;

/* the signature */

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

return 0;

if (uL != ZIP64ENDHEADERMAGIC)

return 0;

return offset;

}

local unzFile unzOpenInternal(const void *path, zlib_filefunc64_32_def* pzlib_filefunc64_32_def)

{

unz64_s us;

unz64_s *s;

ZPOS64_T central_pos;

uLong uL;

voidpf filestream = NULL;

ZPOS64_T number_entry_CD;

int err = UNZ_OK;

if (unz_copyright[0]!=' ')

return NULL;

us.filestream = NULL;

us.filestream_with_CD = 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.filestream = ZOPEN64(us.z_filefunc, path, ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_EXISTING);

if (us.filestream == NULL)

return NULL;

us.filestream_with_CD = us.filestream;

us.isZip64 = 0;

/* Use unz64local_SearchCentralDir first. Only based on the result

is it necessary to locate the unz64local_SearchCentralDir64 */

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

if (central_pos)

{

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, &uL) != UNZ_OK)

err = UNZ_ERRNO;

us.number_disk = uL;

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

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

err = UNZ_ERRNO;

us.gi.number_disk_with_CD = uL;

/* total number of entries in the central directory 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 directory */

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)

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 ((err == UNZ_OK) &&

((us.gi.number_entry == 0xffff) || (us.size_central_dir == 0xffff) || (us.offset_central_dir == 0xffffffff)))

{

/* Format should be Zip64, as the central directory or file size is too large */

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

if (central_pos)

{

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, &uL) != UNZ_OK)

err = UNZ_ERRNO;

/* version needed to extract */

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

err = UNZ_ERRNO;

/* number of this disk */

if (unz64local_getLong(&us.z_filefunc, us.filestream, &us.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, &us.gi.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)

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;

}

else

err = UNZ_BADZIPFILE;

}

}

else

err = UNZ_ERRNO;

if ((err == UNZ_OK) && (central_pos < us.offset_central_dir + us.size_central_dir))

err = UNZ_BADZIPFILE;

if (err != UNZ_OK)

{

ZCLOSE64(us.z_filefunc, us.filestream);

return NULL;

}

if (us.gi.number_disk_with_CD == 0)

{

/* If there is only one disk open another stream so we don't have to seek between the CD

and the file headers constantly */

filestream = ZOPEN64(us.z_filefunc, path, ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_EXISTING);

if (filestream != NULL)

us.filestream = filestream;

}

/* Hack for zip files that have no respect for zip64

if ((central_pos > 0xffffffff) && (us.offset_central_dir < 0xffffffff))

us.offset_central_dir = central_pos - us.size_central_dir;*/

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;

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

}

return unzOpenInternal(path, NULL);

}

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

}

return unzOpenInternal(path, NULL);

}

extern unzFile ZEXPORT unzOpen(const char *path)

{

return unzOpenInternal(path, NULL);

}

extern unzFile ZEXPORT unzOpen64(const void *path)

{

return unzOpenInternal(path, NULL);

}

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

if ((s->filestream != NULL) && (s->filestream != s->filestream_with_CD))

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

if (s->filestream_with_CD != NULL)

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

s->filestream = NULL;

s->filestream_with_CD = NULL;

TRYFREE(s);

return UNZ_OK;

}

/* Goto to the next available disk for spanned archives */

local int unzGoToNextDisk OF((unzFile file));

local int unzGoToNextDisk(unzFile file)

{

unz64_s* s;

uLong number_disk_next = 0;

s = (unz64_s*)file;

if (s == NULL)

return UNZ_PARAMERROR;

number_disk_next = s->number_disk;

if ((s->pfile_in_zip_read != NULL) && (s->pfile_in_zip_read->rest_read_uncompressed > 0))

/* We are currently reading a file and we need the next sequential disk */

number_disk_next += 1;

else

/* Goto the disk for the current file */

number_disk_next = s->cur_file_info.disk_num_start;

if (number_disk_next != s->number_disk)

{

/* Switch disks */

if ((s->filestream != NULL) && (s->filestream != s->filestream_with_CD))

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

if (number_disk_next == s->gi.number_disk_with_CD)

{

s->filestream = s->filestream_with_CD;

}

else

{

s->filestream = ZOPENDISK64(s->z_filefunc, s->filestream_with_CD, (int)number_disk_next,

ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_EXISTING);

}

if (s->filestream == NULL)

return UNZ_ERRNO;

s->number_disk = number_disk_next;

}

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;

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

return UNZ_OK;

}

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 unzGetGlobalComment(unzFile file, char *comment, uLong comment_size)

{

unz64_s* s;

uLong bytes_to_read = comment_size;

if (file == NULL)

return (int)UNZ_PARAMERROR;

s = (unz64_s*)file;

if (bytes_to_read > s->gi.size_comment)

bytes_to_read = s->gi.size_comment;

if (ZSEEK64(s->z_filefunc, s->filestream_with_CD, s->central_pos + 22, ZLIB_FILEFUNC_SEEK_SET) != 0)

return UNZ_ERRNO;

if (bytes_to_read>0)

{

*comment = 0;

if (ZREAD64(s->z_filefunc, s->filestream_with_CD, comment, bytes_to_read) != bytes_to_read)

return UNZ_ERRNO;

}

if ((comment != NULL) && (comment_size > s->gi.size_comment))

*(comment+s->gi.size_comment) = 0;

return (int)bytes_to_read;

}

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

local int unz64local_GetCurrentFileInfoInternal(unzFile file, unz_file_info64 *pfile_info,

unz_file_info64_internal *pfile_info_internal, char *filename, uLong filename_size, void *extrafield,

uLong extrafield_size, char *comment, uLong comment_size)

{

unz64_s* s;

unz_file_info64 file_info;

unz_file_info64_internal file_info_internal;

ZPOS64_T bytes_to_read;

int err = UNZ_OK;

uLong uMagic;

long lSeek = 0;

ZPOS64_T current_pos = 0;

uLong acc = 0;

uLong uL;

ZPOS64_T uL64;

if (file == NULL)

return UNZ_PARAMERROR;

s = (unz64_s*)file;

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

s->pos_in_central_dir + s->byte_before_the_zipfile, ZLIB_FILEFUNC_SEEK_SET) != 0)

err = UNZ_ERRNO;

/* Check the magic */

if (err == UNZ_OK)

{

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

err = UNZ_ERRNO;

else if (uMagic != CENTRALHEADERMAGIC)

err = UNZ_BADZIPFILE;

}

/* Read central directory header */

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

err = UNZ_ERRNO;

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

err = UNZ_ERRNO;

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

err = UNZ_ERRNO;

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

err = UNZ_ERRNO;

if (unz64local_getLong(&s->z_filefunc, s->filestream_with_CD, &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_with_CD, &file_info.crc) != UNZ_OK)

err = UNZ_ERRNO;

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

err = UNZ_ERRNO;

file_info.compressed_size = uL;

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

err = UNZ_ERRNO;

file_info.uncompressed_size = uL;

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

err = UNZ_ERRNO;

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

err = UNZ_ERRNO;

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

err = UNZ_ERRNO;

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

err = UNZ_ERRNO;

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

err = UNZ_ERRNO;

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

err = UNZ_ERRNO;

/* Relative offset of local header */

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

err = UNZ_ERRNO;

file_info.size_file_extra_internal = 0;

file_info.disk_offset = uL;

file_info_internal.offset_curfile = uL;

#ifdef HAVE_AES

file_info_internal.aes_compression_method = 0;

file_info_internal.aes_encryption_mode = 0;

file_info_internal.aes_version = 0;

#endif

lSeek += file_info.size_filename;

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

{

if (file_info.size_filename < filename_size)

{

*(filename+file_info.size_filename) = 0;

bytes_to_read = file_info.size_filename;

}

else

bytes_to_read = filename_size;

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

if (ZREAD64(s->z_filefunc, s->filestream_with_CD,filename, (uLong)bytes_to_read) != bytes_to_read)

err = UNZ_ERRNO;

lSeek -= (uLong)bytes_to_read;

}

/* Read extrafield */

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

{

if (file_info.size_file_extra < extrafield_size)

bytes_to_read = file_info.size_file_extra;

else

bytes_to_read = extrafield_size;

if (lSeek != 0)

{

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

lSeek=0;

else

err = UNZ_ERRNO;

}

if ((file_info.size_file_extra > 0) && (extrafield_size > 0))

if (ZREAD64(s->z_filefunc, s->filestream_with_CD, extrafield, (uLong)bytes_to_read) != bytes_to_read)

err = UNZ_ERRNO;

lSeek += file_info.size_file_extra - (uLong)bytes_to_read;

}

else

lSeek += file_info.size_file_extra;

if ((err == UNZ_OK) && (file_info.size_file_extra != 0))

{

if (lSeek != 0)

{

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

lSeek=0;

else

err = UNZ_ERRNO;

}

/* We are going to parse the extra field so we need to move back */

current_pos = ZTELL64(s->z_filefunc, s->filestream_with_CD);

if (current_pos < file_info.size_file_extra)

err = UNZ_ERRNO;

current_pos -= file_info.size_file_extra;

if (ZSEEK64(s->z_filefunc, s->filestream_with_CD, current_pos, ZLIB_FILEFUNC_SEEK_SET) != 0)

err = UNZ_ERRNO;

while((err != UNZ_ERRNO) && (acc < file_info.size_file_extra))

{

uLong headerid;

uLong datasize;

if (unz64local_getShort(&s->z_filefunc, s->filestream_with_CD, &headerid) != UNZ_OK)

err = UNZ_ERRNO;

if (unz64local_getShort(&s->z_filefunc, s->filestream_with_CD, &datasize) != UNZ_OK)

err = UNZ_ERRNO;

/* ZIP64 extra fields */

if (headerid == 0x0001)

{

/* Subtract size of ZIP64 field, since ZIP64 is handled internally */

file_info.size_file_extra_internal += 2 + 2 + datasize;

if (file_info.uncompressed_size == 0xffffffff)

{

if (unz64local_getLong64(&s->z_filefunc, s->filestream_with_CD, &file_info.uncompressed_size) != UNZ_OK)

err = UNZ_ERRNO;

}

if (file_info.compressed_size == 0xffffffff)

{

if (unz64local_getLong64(&s->z_filefunc, s->filestream_with_CD, &file_info.compressed_size) != UNZ_OK)

err = UNZ_ERRNO;

}

if (file_info_internal.offset_curfile == 0xffffffff)

{

/* Relative Header offset */

if (unz64local_getLong64(&s->z_filefunc, s->filestream_with_CD, &uL64) != UNZ_OK)

err = UNZ_ERRNO;

file_info_internal.offset_curfile = uL64;

file_info.disk_offset = uL64;

}

if (file_info.disk_num_start == 0xffffffff)

{

/* Disk Start Number */

if (unz64local_getLong(&s->z_filefunc, s->filestream_with_CD, &file_info.disk_num_start) != UNZ_OK)

err = UNZ_ERRNO;

}

}

#ifdef HAVE_AES

/* AES header */

else if (headerid == 0x9901)

{

/* Subtract size of AES field, since AES is handled internally */

file_info.size_file_extra_internal += 2 + 2 + datasize;

/* Verify version info */

if (unz64local_getShort(&s->z_filefunc, s->filestream_with_CD, &uL) != UNZ_OK)

err = UNZ_ERRNO;

/* Support AE-1 and AE-2 */

if (uL != 1 && uL != 2)

err = UNZ_ERRNO;

file_info_internal.aes_version = uL;

if (unz64local_getByte(&s->z_filefunc, s->filestream_with_CD, &uL) != UNZ_OK)

err = UNZ_ERRNO;

if ((char)uL != 'A')

err = UNZ_ERRNO;

if (unz64local_getByte(&s->z_filefunc, s->filestream_with_CD, &uL) != UNZ_OK)

err = UNZ_ERRNO;

if ((char)uL != 'E')

err = UNZ_ERRNO;

/* Get AES encryption strength and actual compression method */

if (unz64local_getByte(&s->z_filefunc, s->filestream_with_CD, &uL) != UNZ_OK)

err = UNZ_ERRNO;

file_info_internal.aes_encryption_mode = uL;

if (unz64local_getShort(&s->z_filefunc, s->filestream_with_CD, &uL) != UNZ_OK)

err = UNZ_ERRNO;

file_info_internal.aes_compression_method = uL;

}

#endif

else

{

if (ZSEEK64(s->z_filefunc, s->filestream_with_CD,datasize, ZLIB_FILEFUNC_SEEK_CUR) != 0)

err = UNZ_ERRNO;

}

acc += 2 + 2 + datasize;

}

}

if (file_info.disk_num_start == s->gi.number_disk_with_CD)

file_info_internal.byte_before_the_zipfile = s->byte_before_the_zipfile;

else

file_info_internal.byte_before_the_zipfile = 0;

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

{

if (file_info.size_file_comment < comment_size)

{

*(comment+file_info.size_file_comment) = 0;

bytes_to_read = file_info.size_file_comment;

}

else

bytes_to_read = comment_size;

if (lSeek != 0)

{

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

err = UNZ_ERRNO;

}

if ((file_info.size_file_comment > 0) && (comment_size > 0))

if (ZREAD64(s->z_filefunc, s->filestream_with_CD, comment, (uLong)bytes_to_read) != bytes_to_read)

err = UNZ_ERRNO;

lSeek += file_info.size_file_comment - (uLong)bytes_to_read;

}

else

lSeek += file_info.size_file_comment;

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

*pfile_info = file_info;

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

*pfile_info_internal = file_info_internal;

return err;

}

extern int ZEXPORT unzGetCurrentFileInfo(unzFile file, unz_file_info * pfile_info, char *filename,

uLong filename_size, void *extrafield, uLong extrafield_size, char* comment, uLong comment_size)

{

unz_file_info64 file_info64;

int err;

err = unz64local_GetCurrentFileInfoInternal(file, &file_info64, NULL, filename, filename_size,

extrafield, extrafield_size, comment, comment_size);

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

{

pfile_info->version = file_info64.version;

pfile_info->version_needed = file_info64.version_needed;

pfile_info->flag = file_info64.flag;

pfile_info->compression_method = file_info64.compression_method;

pfile_info->dosDate = file_info64.dosDate;

pfile_info->crc = file_info64.crc;

pfile_info->size_filename = file_info64.size_filename;

pfile_info->size_file_extra = file_info64.size_file_extra - file_info64.size_file_extra_internal;

pfile_info->size_file_comment = file_info64.size_file_comment;

pfile_info->disk_num_start = file_info64.disk_num_start;

pfile_info->internal_fa = file_info64.internal_fa;

pfile_info->external_fa = file_info64.external_fa;

pfile_info->tmu_date = file_info64.tmu_date;

pfile_info->compressed_size = (uLong)file_info64.compressed_size;

pfile_info->uncompressed_size = (uLong)file_info64.uncompressed_size;

}

return err;

}

extern int ZEXPORT unzGetCurrentFileInfo64(unzFile file, unz_file_info64 * pfile_info, char *filename,

uLong filename_size, void *extrafield, uLong extrafield_size, char* comment, uLong comment_size)

{

return unz64local_GetCurrentFileInfoInternal(file, pfile_info, NULL, filename, filename_size,

extrafield, extrafield_size, comment,comment_size);

}