From: Holger Schemel Date: Wed, 9 Jan 2019 23:05:48 +0000 (+0100) Subject: added generic support for listing and extracting zip files (using minizip) X-Git-Tag: 4.1.2.0~58 X-Git-Url: https://git.artsoft.org/?p=rocksndiamonds.git;a=commitdiff_plain;h=fb81506227581bcc04cd4835b8e3f41a109d1f97 added generic support for listing and extracting zip files (using minizip) --- diff --git a/src/Android.mk b/src/Android.mk index a5b714e0..a9b75064 100644 --- a/src/Android.mk +++ b/src/Android.mk @@ -47,6 +47,10 @@ LOCAL_SRC_FILES := $(SDL_PATH)/src/main/android/SDL_android_main.c \ libgame/setup.c \ libgame/misc.c \ libgame/sdl.c \ + libgame/zip/ioapi.c \ + libgame/zip/iowin32.c \ + libgame/zip/unzip.c \ + libgame/zip/miniunz.c \ game_em/cave.c \ game_em/convert.c \ game_em/graphics.c \ @@ -107,6 +111,6 @@ LOCAL_SRC_FILES := $(SDL_PATH)/src/main/android/SDL_android_main.c \ LOCAL_SHARED_LIBRARIES := SDL2 SDL2_image SDL2_mixer SDL2_net smpeg2 -LOCAL_LDLIBS := -lGLESv1_CM -lGLESv2 -llog +LOCAL_LDLIBS := -lGLESv1_CM -lGLESv2 -llog -lz include $(BUILD_SHARED_LIBRARY) diff --git a/src/Makefile b/src/Makefile index 0c195c0c..e42d5370 100644 --- a/src/Makefile +++ b/src/Makefile @@ -114,7 +114,7 @@ OPTIONS = -O3 -Wall endif CFLAGS = $(OPTIONS) $(SYS_CFLAGS) $(EXTRA_CFLAGS) $(CONFIG) -LDFLAGS = $(SYS_LDFLAGS) $(EXTRA_LDFLAGS) -lm +LDFLAGS = $(SYS_LDFLAGS) $(EXTRA_LDFLAGS) -lm -lz SRCS = main.c \ diff --git a/src/libgame/Makefile b/src/libgame/Makefile index 4693c226..8b2b6024 100644 --- a/src/libgame/Makefile +++ b/src/libgame/Makefile @@ -24,7 +24,11 @@ SRCS = system.c \ hash.c \ setup.c \ misc.c \ - sdl.c + sdl.c \ + zip/ioapi.c \ + zip/iowin32.c \ + zip/unzip.c \ + zip/miniunz.c OBJS = system.o \ gadgets.o \ @@ -37,7 +41,11 @@ OBJS = system.o \ hash.o \ setup.o \ misc.o \ - sdl.o + sdl.o \ + zip/ioapi.o \ + zip/iowin32.o \ + zip/unzip.o \ + zip/miniunz.o LIBGAME = libgame.a @@ -53,7 +61,7 @@ $(LIBGAME): $(OBJS) $(RANLIB) $(LIBGAME) .c.o: - $(CC) $(PROFILING) $(CFLAGS) -c $*.c + $(CC) $(PROFILING) $(CFLAGS) -c $*.c -o $*.o clean: $(RM) $(OBJS) diff --git a/src/libgame/libgame.h b/src/libgame/libgame.h index 419d3b71..e5aab80d 100644 --- a/src/libgame/libgame.h +++ b/src/libgame/libgame.h @@ -26,5 +26,6 @@ #include "image.h" #include "setup.h" #include "misc.h" +#include "zip/miniunz.h" #endif // LIBGAME_H diff --git a/src/libgame/zip/ioapi.c b/src/libgame/zip/ioapi.c new file mode 100644 index 00000000..5b6fcc63 --- /dev/null +++ b/src/libgame/zip/ioapi.c @@ -0,0 +1,353 @@ +/* ioapi.c -- IO base function header for compress/uncompress .zip + part of the MiniZip project + + Copyright (C) 2012-2017 Nathan Moinvaziri + https://github.com/nmoinvaz/minizip + Modifications for Zip64 support + Copyright (C) 2009-2010 Mathias Svensson + http://result42.com + Copyright (C) 1998-2010 Gilles Vollant + http://www.winimage.com/zLibDll/minizip.html + + 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 +#include + +#if defined unix || defined __APPLE__ +#include +#include +#endif + +#include "ioapi.h" + +#if defined(_WIN32) +# define snprintf _snprintf +#endif + +voidpf call_zopen64(const zlib_filefunc64_32_def *pfilefunc, const void *filename, int mode) +{ + if (pfilefunc->zfile_func64.zopen64_file != NULL) + return (*(pfilefunc->zfile_func64.zopen64_file)) (pfilefunc->zfile_func64.opaque, filename, mode); + return (*(pfilefunc->zopen32_file))(pfilefunc->zfile_func64.opaque, (const char*)filename, mode); +} + +voidpf call_zopendisk64(const zlib_filefunc64_32_def *pfilefunc, voidpf filestream, uint32_t number_disk, int mode) +{ + if (pfilefunc->zfile_func64.zopendisk64_file != NULL) + return (*(pfilefunc->zfile_func64.zopendisk64_file)) (pfilefunc->zfile_func64.opaque, filestream, number_disk, mode); + return (*(pfilefunc->zopendisk32_file))(pfilefunc->zfile_func64.opaque, filestream, number_disk, mode); +} + +long call_zseek64(const zlib_filefunc64_32_def *pfilefunc, voidpf filestream, uint64_t offset, int origin) +{ + uint32_t offset_truncated = 0; + if (pfilefunc->zfile_func64.zseek64_file != NULL) + return (*(pfilefunc->zfile_func64.zseek64_file)) (pfilefunc->zfile_func64.opaque,filestream,offset,origin); + offset_truncated = (uint32_t)offset; + if (offset_truncated != offset) + return -1; + return (*(pfilefunc->zseek32_file))(pfilefunc->zfile_func64.opaque,filestream, offset_truncated, origin); +} + +uint64_t call_ztell64(const zlib_filefunc64_32_def *pfilefunc, voidpf filestream) +{ + uint64_t position; + if (pfilefunc->zfile_func64.zseek64_file != NULL) + return (*(pfilefunc->zfile_func64.ztell64_file)) (pfilefunc->zfile_func64.opaque, filestream); + position = (*(pfilefunc->ztell32_file))(pfilefunc->zfile_func64.opaque, filestream); + if ((position) == UINT32_MAX) + return (uint64_t)-1; + return position; +} + +void fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def *p_filefunc64_32, const zlib_filefunc_def *p_filefunc32) +{ + p_filefunc64_32->zfile_func64.zopen64_file = NULL; + p_filefunc64_32->zfile_func64.zopendisk64_file = NULL; + p_filefunc64_32->zopen32_file = p_filefunc32->zopen_file; + p_filefunc64_32->zopendisk32_file = p_filefunc32->zopendisk_file; + p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file; + p_filefunc64_32->zfile_func64.zread_file = p_filefunc32->zread_file; + p_filefunc64_32->zfile_func64.zwrite_file = p_filefunc32->zwrite_file; + p_filefunc64_32->zfile_func64.ztell64_file = NULL; + p_filefunc64_32->zfile_func64.zseek64_file = NULL; + p_filefunc64_32->zfile_func64.zclose_file = p_filefunc32->zclose_file; + p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file; + p_filefunc64_32->zfile_func64.opaque = p_filefunc32->opaque; + p_filefunc64_32->zseek32_file = p_filefunc32->zseek_file; + p_filefunc64_32->ztell32_file = p_filefunc32->ztell_file; +} + +static voidpf ZCALLBACK fopen_file_func(ZIP_UNUSED voidpf opaque, const char *filename, int mode); +static uint32_t ZCALLBACK fread_file_func(voidpf opaque, voidpf stream, void* buf, uint32_t size); +static uint32_t ZCALLBACK fwrite_file_func(voidpf opaque, voidpf stream, const void *buf, uint32_t size); +static uint64_t ZCALLBACK ftell64_file_func(voidpf opaque, voidpf stream); +static long ZCALLBACK fseek64_file_func(voidpf opaque, voidpf stream, uint64_t offset, int origin); +static int ZCALLBACK fclose_file_func(voidpf opaque, voidpf stream); +static int ZCALLBACK ferror_file_func(voidpf opaque, voidpf stream); + +typedef struct +{ + FILE *file; + int filenameLength; + void *filename; +} FILE_IOPOSIX; + +static voidpf file_build_ioposix(FILE *file, const char *filename) +{ + FILE_IOPOSIX *ioposix = NULL; + if (file == NULL) + return NULL; + ioposix = (FILE_IOPOSIX*)malloc(sizeof(FILE_IOPOSIX)); + ioposix->file = file; + ioposix->filenameLength = (int)strlen(filename) + 1; + ioposix->filename = (char*)malloc(ioposix->filenameLength * sizeof(char)); + strncpy((char*)ioposix->filename, filename, ioposix->filenameLength); + return (voidpf)ioposix; +} + +static voidpf ZCALLBACK fopen_file_func(ZIP_UNUSED voidpf opaque, const char *filename, int mode) +{ + FILE* file = NULL; + const char *mode_fopen = NULL; + if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER) == ZLIB_FILEFUNC_MODE_READ) + mode_fopen = "rb"; + else if (mode & ZLIB_FILEFUNC_MODE_EXISTING) + mode_fopen = "r+b"; + else if (mode & ZLIB_FILEFUNC_MODE_CREATE) + mode_fopen = "wb"; + + if ((filename != NULL) && (mode_fopen != NULL)) + { + file = fopen(filename, mode_fopen); + return file_build_ioposix(file, filename); + } + return file; +} + +static voidpf ZCALLBACK fopen64_file_func(ZIP_UNUSED voidpf opaque, const void *filename, int mode) +{ + FILE* file = NULL; + const char *mode_fopen = NULL; + if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER) == ZLIB_FILEFUNC_MODE_READ) + mode_fopen = "rb"; + else if (mode & ZLIB_FILEFUNC_MODE_EXISTING) + mode_fopen = "r+b"; + else if (mode & ZLIB_FILEFUNC_MODE_CREATE) + mode_fopen = "wb"; + + if ((filename != NULL) && (mode_fopen != NULL)) + { + file = fopen64((const char*)filename, mode_fopen); + return file_build_ioposix(file, (const char*)filename); + } + return file; +} + +static voidpf ZCALLBACK fopendisk64_file_func(voidpf opaque, voidpf stream, uint32_t number_disk, int mode) +{ + FILE_IOPOSIX *ioposix = NULL; + char *diskFilename = NULL; + voidpf ret = NULL; + int i = 0; + + if (stream == NULL) + return NULL; + ioposix = (FILE_IOPOSIX*)stream; + diskFilename = (char*)malloc(ioposix->filenameLength * sizeof(char)); + strncpy(diskFilename, (const char*)ioposix->filename, ioposix->filenameLength); + for (i = ioposix->filenameLength - 1; i >= 0; i -= 1) + { + if (diskFilename[i] != '.') + continue; + snprintf(&diskFilename[i], ioposix->filenameLength - i, ".z%02u", number_disk + 1); + break; + } + if (i >= 0) + ret = fopen64_file_func(opaque, diskFilename, mode); + free(diskFilename); + return ret; +} + +static voidpf ZCALLBACK fopendisk_file_func(voidpf opaque, voidpf stream, uint32_t number_disk, int mode) +{ + FILE_IOPOSIX *ioposix = NULL; + char *diskFilename = NULL; + voidpf ret = NULL; + int i = 0; + + if (stream == NULL) + return NULL; + ioposix = (FILE_IOPOSIX*)stream; + diskFilename = (char*)malloc(ioposix->filenameLength * sizeof(char)); + strncpy(diskFilename, (const char*)ioposix->filename, ioposix->filenameLength); + for (i = ioposix->filenameLength - 1; i >= 0; i -= 1) + { + if (diskFilename[i] != '.') + continue; + snprintf(&diskFilename[i], ioposix->filenameLength - i, ".z%02u", number_disk + 1); + break; + } + if (i >= 0) + ret = fopen_file_func(opaque, diskFilename, mode); + free(diskFilename); + return ret; +} + +static uint32_t ZCALLBACK fread_file_func(ZIP_UNUSED voidpf opaque, voidpf stream, void* buf, uint32_t size) +{ + FILE_IOPOSIX *ioposix = NULL; + uint32_t read = (uint32_t)-1; + if (stream == NULL) + return read; + ioposix = (FILE_IOPOSIX*)stream; + read = (uint32_t)fread(buf, 1, (size_t)size, ioposix->file); + return read; +} + +static uint32_t ZCALLBACK fwrite_file_func(ZIP_UNUSED voidpf opaque, voidpf stream, const void *buf, uint32_t size) +{ + FILE_IOPOSIX *ioposix = NULL; + uint32_t written = (uint32_t)-1; + if (stream == NULL) + return written; + ioposix = (FILE_IOPOSIX*)stream; + written = (uint32_t)fwrite(buf, 1, (size_t)size, ioposix->file); + return written; +} + +static long ZCALLBACK ftell_file_func(ZIP_UNUSED voidpf opaque, voidpf stream) +{ + FILE_IOPOSIX *ioposix = NULL; + long ret = -1; + if (stream == NULL) + return ret; + ioposix = (FILE_IOPOSIX*)stream; + ret = ftell(ioposix->file); + return ret; +} + +static uint64_t ZCALLBACK ftell64_file_func(ZIP_UNUSED voidpf opaque, voidpf stream) +{ + FILE_IOPOSIX *ioposix = NULL; + uint64_t ret = (uint64_t)-1; + if (stream == NULL) + return ret; + ioposix = (FILE_IOPOSIX*)stream; + ret = ftello64(ioposix->file); + return ret; +} + +static long ZCALLBACK fseek_file_func(ZIP_UNUSED voidpf opaque, voidpf stream, uint32_t offset, int origin) +{ + FILE_IOPOSIX *ioposix = NULL; + int fseek_origin = 0; + long ret = 0; + + if (stream == NULL) + return -1; + ioposix = (FILE_IOPOSIX*)stream; + + switch (origin) + { + case ZLIB_FILEFUNC_SEEK_CUR: + fseek_origin = SEEK_CUR; + break; + case ZLIB_FILEFUNC_SEEK_END: + fseek_origin = SEEK_END; + break; + case ZLIB_FILEFUNC_SEEK_SET: + fseek_origin = SEEK_SET; + break; + default: + return -1; + } + if (fseek(ioposix->file, offset, fseek_origin) != 0) + ret = -1; + return ret; +} + +static long ZCALLBACK fseek64_file_func(ZIP_UNUSED voidpf opaque, voidpf stream, uint64_t offset, int origin) +{ + FILE_IOPOSIX *ioposix = NULL; + int fseek_origin = 0; + long ret = 0; + + if (stream == NULL) + return -1; + ioposix = (FILE_IOPOSIX*)stream; + + switch (origin) + { + case ZLIB_FILEFUNC_SEEK_CUR: + fseek_origin = SEEK_CUR; + break; + case ZLIB_FILEFUNC_SEEK_END: + fseek_origin = SEEK_END; + break; + case ZLIB_FILEFUNC_SEEK_SET: + fseek_origin = SEEK_SET; + break; + default: + return -1; + } + + if (fseeko64(ioposix->file, offset, fseek_origin) != 0) + ret = -1; + + return ret; +} + +static int ZCALLBACK fclose_file_func(ZIP_UNUSED voidpf opaque, voidpf stream) +{ + FILE_IOPOSIX *ioposix = NULL; + int ret = -1; + if (stream == NULL) + return ret; + ioposix = (FILE_IOPOSIX*)stream; + if (ioposix->filename != NULL) + free(ioposix->filename); + ret = fclose(ioposix->file); + free(ioposix); + return ret; +} + +static int ZCALLBACK ferror_file_func(ZIP_UNUSED voidpf opaque, voidpf stream) +{ + FILE_IOPOSIX *ioposix = NULL; + int ret = -1; + if (stream == NULL) + return ret; + ioposix = (FILE_IOPOSIX*)stream; + ret = ferror(ioposix->file); + return ret; +} + +void fill_fopen_filefunc(zlib_filefunc_def *pzlib_filefunc_def) +{ + pzlib_filefunc_def->zopen_file = fopen_file_func; + pzlib_filefunc_def->zopendisk_file = fopendisk_file_func; + pzlib_filefunc_def->zread_file = fread_file_func; + pzlib_filefunc_def->zwrite_file = fwrite_file_func; + pzlib_filefunc_def->ztell_file = ftell_file_func; + pzlib_filefunc_def->zseek_file = fseek_file_func; + pzlib_filefunc_def->zclose_file = fclose_file_func; + pzlib_filefunc_def->zerror_file = ferror_file_func; + pzlib_filefunc_def->opaque = NULL; +} + +void fill_fopen64_filefunc(zlib_filefunc64_def *pzlib_filefunc_def) +{ + pzlib_filefunc_def->zopen64_file = fopen64_file_func; + pzlib_filefunc_def->zopendisk64_file = fopendisk64_file_func; + pzlib_filefunc_def->zread_file = fread_file_func; + pzlib_filefunc_def->zwrite_file = fwrite_file_func; + pzlib_filefunc_def->ztell64_file = ftell64_file_func; + pzlib_filefunc_def->zseek64_file = fseek64_file_func; + pzlib_filefunc_def->zclose_file = fclose_file_func; + pzlib_filefunc_def->zerror_file = ferror_file_func; + pzlib_filefunc_def->opaque = NULL; +} diff --git a/src/libgame/zip/ioapi.h b/src/libgame/zip/ioapi.h new file mode 100644 index 00000000..3527ad63 --- /dev/null +++ b/src/libgame/zip/ioapi.h @@ -0,0 +1,170 @@ +/* ioapi.h -- IO base function header for compress/uncompress .zip + part of the MiniZip project + + Copyright (C) 2012-2017 Nathan Moinvaziri + https://github.com/nmoinvaz/minizip + Copyright (C) 2009-2010 Mathias Svensson + Modifications for Zip64 support + http://result42.com + Copyright (C) 1998-2010 Gilles Vollant + http://www.winimage.com/zLibDll/minizip.html + + 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. +*/ + +#ifndef _ZLIBIOAPI64_H +#define _ZLIBIOAPI64_H + +#if defined(__linux__) +// Linux needs this to support file operation on files larger then 4+GB +# ifndef __USE_FILE_OFFSET64 +# define __USE_FILE_OFFSET64 +# endif +# ifndef __USE_LARGEFILE64 +# define __USE_LARGEFILE64 +# endif +# ifndef _LARGEFILE64_SOURCE +# define _LARGEFILE64_SOURCE +# endif +# ifndef _FILE_OFFSET_BIT +# define _FILE_OFFSET_BIT 64 +# endif +#endif + +#include +#include +#include + +#include "zlib.h" + +#ifdef __GNUC__ +# define ZIP_UNUSED __attribute__((__unused__)) +#else +# define ZIP_UNUSED +#endif + +#if defined(USE_FILE32API) +# define fopen64 fopen +# define ftello64 ftell +# define fseeko64 fseek +#else +# if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__DragonFly__) || defined(__OpenBSD__) || defined(__APPLE__) || defined(__ANDROID__) +# define fopen64 fopen +# define ftello64 ftello +# define fseeko64 fseeko +# endif +# ifdef _MSC_VER +# define fopen64 fopen +# if (_MSC_VER >= 1400) && (!(defined(NO_MSCVER_FILE64_FUNC))) +# define ftello64 _ftelli64 +# define fseeko64 _fseeki64 +# else /* old MSC */ +# define ftello64 ftell +# define fseeko64 fseek +# endif +# endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#define ZLIB_FILEFUNC_SEEK_CUR (1) +#define ZLIB_FILEFUNC_SEEK_END (2) +#define ZLIB_FILEFUNC_SEEK_SET (0) + +#define ZLIB_FILEFUNC_MODE_READ (1) +#define ZLIB_FILEFUNC_MODE_WRITE (2) +#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3) +#define ZLIB_FILEFUNC_MODE_EXISTING (4) +#define ZLIB_FILEFUNC_MODE_CREATE (8) + +#ifndef ZCALLBACK +# if (defined(WIN32) || defined(_WIN32) || defined (WINDOWS) || \ + defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK) +# define ZCALLBACK CALLBACK +# else +# define ZCALLBACK +# endif +#endif + +typedef voidpf (ZCALLBACK *open_file_func) (voidpf opaque, const char *filename, int mode); +typedef voidpf (ZCALLBACK *opendisk_file_func) (voidpf opaque, voidpf stream, uint32_t number_disk, int mode); +typedef uint32_t (ZCALLBACK *read_file_func) (voidpf opaque, voidpf stream, void* buf, uint32_t size); +typedef uint32_t (ZCALLBACK *write_file_func) (voidpf opaque, voidpf stream, const void *buf, uint32_t size); +typedef int (ZCALLBACK *close_file_func) (voidpf opaque, voidpf stream); +typedef int (ZCALLBACK *error_file_func) (voidpf opaque, voidpf stream); + +typedef long (ZCALLBACK *tell_file_func) (voidpf opaque, voidpf stream); +typedef long (ZCALLBACK *seek_file_func) (voidpf opaque, voidpf stream, uint32_t offset, int origin); + +/* here is the "old" 32 bits structure structure */ +typedef struct zlib_filefunc_def_s +{ + open_file_func zopen_file; + opendisk_file_func zopendisk_file; + read_file_func zread_file; + write_file_func zwrite_file; + tell_file_func ztell_file; + seek_file_func zseek_file; + close_file_func zclose_file; + error_file_func zerror_file; + voidpf opaque; +} zlib_filefunc_def; + +typedef uint64_t (ZCALLBACK *tell64_file_func) (voidpf opaque, voidpf stream); +typedef long (ZCALLBACK *seek64_file_func) (voidpf opaque, voidpf stream, uint64_t offset, int origin); +typedef voidpf (ZCALLBACK *open64_file_func) (voidpf opaque, const void *filename, int mode); +typedef voidpf (ZCALLBACK *opendisk64_file_func)(voidpf opaque, voidpf stream, uint32_t number_disk, int mode); + +typedef struct zlib_filefunc64_def_s +{ + open64_file_func zopen64_file; + opendisk64_file_func zopendisk64_file; + read_file_func zread_file; + write_file_func zwrite_file; + tell64_file_func ztell64_file; + seek64_file_func zseek64_file; + close_file_func zclose_file; + error_file_func zerror_file; + voidpf opaque; +} zlib_filefunc64_def; + +void fill_fopen_filefunc(zlib_filefunc_def *pzlib_filefunc_def); +void fill_fopen64_filefunc(zlib_filefunc64_def *pzlib_filefunc_def); + +/* now internal definition, only for zip.c and unzip.h */ +typedef struct zlib_filefunc64_32_def_s +{ + zlib_filefunc64_def zfile_func64; + open_file_func zopen32_file; + opendisk_file_func zopendisk32_file; + tell_file_func ztell32_file; + seek_file_func zseek32_file; +} zlib_filefunc64_32_def; + +#define ZREAD64(filefunc,filestream,buf,size) ((*((filefunc).zfile_func64.zread_file)) ((filefunc).zfile_func64.opaque,filestream,buf,size)) +#define ZWRITE64(filefunc,filestream,buf,size) ((*((filefunc).zfile_func64.zwrite_file)) ((filefunc).zfile_func64.opaque,filestream,buf,size)) +/*#define ZTELL64(filefunc,filestream) ((*((filefunc).ztell64_file)) ((filefunc).opaque,filestream))*/ +/*#define ZSEEK64(filefunc,filestream,pos,mode) ((*((filefunc).zseek64_file)) ((filefunc).opaque,filestream,pos,mode))*/ +#define ZCLOSE64(filefunc,filestream) ((*((filefunc).zfile_func64.zclose_file)) ((filefunc).zfile_func64.opaque,filestream)) +#define ZERROR64(filefunc,filestream) ((*((filefunc).zfile_func64.zerror_file)) ((filefunc).zfile_func64.opaque,filestream)) + +voidpf call_zopen64(const zlib_filefunc64_32_def *pfilefunc,const void*filename, int mode); +voidpf call_zopendisk64(const zlib_filefunc64_32_def *pfilefunc, voidpf filestream, uint32_t number_disk, int mode); +long call_zseek64(const zlib_filefunc64_32_def *pfilefunc, voidpf filestream, uint64_t offset, int origin); +uint64_t call_ztell64(const zlib_filefunc64_32_def *pfilefunc, voidpf filestream); + +void fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def *p_filefunc64_32, const zlib_filefunc_def *p_filefunc32); + +#define ZOPEN64(filefunc,filename,mode) (call_zopen64((&(filefunc)),(filename),(mode))) +#define ZOPENDISK64(filefunc,filestream,diskn,mode) (call_zopendisk64((&(filefunc)),(filestream),(diskn),(mode))) +#define ZTELL64(filefunc,filestream) (call_ztell64((&(filefunc)),(filestream))) +#define ZSEEK64(filefunc,filestream,pos,mode) (call_zseek64((&(filefunc)),(filestream),(pos),(mode))) + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/libgame/zip/iowin32.c b/src/libgame/zip/iowin32.c new file mode 100644 index 00000000..53a96e65 --- /dev/null +++ b/src/libgame/zip/iowin32.c @@ -0,0 +1,591 @@ +/* iowin32.c -- IO base function header for compress/uncompress .zip + Version 1.2.0, September 16th, 2017 + part of the MiniZip project + + Copyright (C) 2012-2017 Nathan Moinvaziri + https://github.com/nmoinvaz/minizip + Copyright (C) 2009-2010 Mathias Svensson + Modifications for Zip64 support + http://result42.com + Copyright (C) 1998-2010 Gilles Vollant + http://www.winimage.com/zLibDll/minizip.html + + 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. +*/ + +#ifdef _WIN32 + +#include +#include + +#include "zlib.h" +#include "ioapi.h" +#include "iowin32.h" + +#ifndef INVALID_HANDLE_VALUE +# define INVALID_HANDLE_VALUE (0xFFFFFFFF) +#endif + +#ifndef INVALID_SET_FILE_POINTER +# define INVALID_SET_FILE_POINTER ((DWORD)-1) +#endif + +#if defined(WINAPI_FAMILY_PARTITION) && (!(defined(IOWIN32_USING_WINRT_API))) +# if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +# define IOWIN32_USING_WINRT_API 1 +# endif +#endif + +voidpf ZCALLBACK win32_open_file_func (voidpf opaque, const char *filename, int mode); +uint32_t ZCALLBACK win32_read_file_func (voidpf opaque, voidpf stream, void* buf, uint32_t size); +uint32_t ZCALLBACK win32_write_file_func (voidpf opaque, voidpf stream, const void *buf, uint32_t size); +uint64_t ZCALLBACK win32_tell64_file_func (voidpf opaque, voidpf stream); +long ZCALLBACK win32_seek64_file_func (voidpf opaque, voidpf stream, uint64_t offset, int origin); +int ZCALLBACK win32_close_file_func (voidpf opaque, voidpf stream); +int ZCALLBACK win32_error_file_func (voidpf opaque, voidpf stream); + +typedef struct +{ + HANDLE hf; + int error; + void *filename; + int filenameLength; +} WIN32FILE_IOWIN; + + +static void win32_translate_open_mode(int mode, + DWORD* lpdwDesiredAccess, + DWORD* lpdwCreationDisposition, + DWORD* lpdwShareMode, + DWORD* lpdwFlagsAndAttributes) +{ + *lpdwDesiredAccess = 0; + *lpdwShareMode = 0; + *lpdwCreationDisposition = 0; + *lpdwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL; + + if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER) == ZLIB_FILEFUNC_MODE_READ) + { + *lpdwDesiredAccess = GENERIC_READ; + *lpdwCreationDisposition = OPEN_EXISTING; + *lpdwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE; + } + else if (mode & ZLIB_FILEFUNC_MODE_EXISTING) + { + *lpdwDesiredAccess = GENERIC_WRITE | GENERIC_READ; + *lpdwCreationDisposition = OPEN_EXISTING; + } + else if (mode & ZLIB_FILEFUNC_MODE_CREATE) + { + *lpdwDesiredAccess = GENERIC_WRITE | GENERIC_READ; + *lpdwCreationDisposition = CREATE_ALWAYS; + } +} + +static voidpf win32_build_iowin(HANDLE hFile) +{ + WIN32FILE_IOWIN *iowin = NULL; + + if ((hFile != NULL) && (hFile != INVALID_HANDLE_VALUE)) + { + iowin = (WIN32FILE_IOWIN *)malloc(sizeof(WIN32FILE_IOWIN)); + if (iowin == NULL) + { + CloseHandle(hFile); + return NULL; + } + memset(iowin, 0, sizeof(WIN32FILE_IOWIN)); + iowin->hf = hFile; + } + return (voidpf)iowin; +} + +static voidpf ZCALLBACK win32_open64_file_func(voidpf opaque, const void *filename, int mode) +{ + DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes; + HANDLE hFile = NULL; + WIN32FILE_IOWIN *iowin = NULL; + + win32_translate_open_mode(mode, &dwDesiredAccess, &dwCreationDisposition, &dwShareMode, &dwFlagsAndAttributes); + + if ((filename != NULL) && (dwDesiredAccess != 0)) + { +#ifdef IOWIN32_USING_WINRT_API +#ifdef UNICODE + hFile = CreateFile2((LPCTSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL); +#else + WCHAR filenameW[FILENAME_MAX + 0x200 + 1]; + MultiByteToWideChar(CP_ACP, 0, (const char*)filename, -1, filenameW, FILENAME_MAX + 0x200); + hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL); +#endif +#else + hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL); +#endif + } + + iowin = win32_build_iowin(hFile); + if (iowin == NULL) + return NULL; + iowin->filenameLength = _tcslen(filename) + 1; + iowin->filename = (void*)malloc(iowin->filenameLength * sizeof(TCHAR)); + _tcsncpy(iowin->filename, filename, iowin->filenameLength); + return iowin; +} + +static voidpf ZCALLBACK win32_open64_file_funcA(voidpf opaque, const void *filename, int mode) +{ + DWORD dwDesiredAccess, dwCreationDisposition, dwShareMode, dwFlagsAndAttributes ; + HANDLE hFile = NULL; + WIN32FILE_IOWIN *iowin = NULL; + + win32_translate_open_mode(mode, &dwDesiredAccess, &dwCreationDisposition, &dwShareMode, &dwFlagsAndAttributes); + + if ((filename != NULL) && (dwDesiredAccess != 0)) + { +#ifdef IOWIN32_USING_WINRT_API + WCHAR filenameW[FILENAME_MAX + 0x200 + 1]; + MultiByteToWideChar(CP_ACP, 0, (const char*)filename, -1, filenameW, FILENAME_MAX + 0x200); + hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL); +#else + hFile = CreateFileA((LPCSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL); +#endif + } + + iowin = win32_build_iowin(hFile); + if (iowin == NULL) + return NULL; + iowin->filenameLength = strlen(filename) + 1; + iowin->filename = (void*)malloc(iowin->filenameLength * sizeof(char)); + strncpy(iowin->filename, filename, iowin->filenameLength); + return iowin; +} + +static voidpf ZCALLBACK win32_open64_file_funcW(voidpf opaque, const void *filename, int mode) +{ + DWORD dwDesiredAccess, dwCreationDisposition, dwShareMode, dwFlagsAndAttributes; + HANDLE hFile = NULL; + WIN32FILE_IOWIN *iowin = NULL; + + win32_translate_open_mode(mode, &dwDesiredAccess, &dwCreationDisposition, &dwShareMode, &dwFlagsAndAttributes); + + if ((filename != NULL) && (dwDesiredAccess != 0)) + { +#ifdef IOWIN32_USING_WINRT_API + hFile = CreateFile2((LPCWSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL); +#else + hFile = CreateFileW((LPCWSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL); +#endif + } + + iowin = win32_build_iowin(hFile); + if (iowin == NULL) + return NULL; + if (iowin->filename == NULL) + { + iowin->filenameLength = wcslen(filename) + 1; + iowin->filename = (void*)malloc(iowin->filenameLength * sizeof(WCHAR)); + wcsncpy(iowin->filename, filename, iowin->filenameLength); + } + return iowin; +} + +voidpf ZCALLBACK win32_open_file_func(voidpf opaque, const char *filename, int mode) +{ + DWORD dwDesiredAccess, dwCreationDisposition, dwShareMode, dwFlagsAndAttributes ; + HANDLE hFile = NULL; + WIN32FILE_IOWIN *iowin = NULL; + + win32_translate_open_mode(mode, &dwDesiredAccess, &dwCreationDisposition, &dwShareMode, &dwFlagsAndAttributes); + + if ((filename != NULL) && (dwDesiredAccess != 0)) + { +#ifdef IOWIN32_USING_WINRT_API +#ifdef UNICODE + hFile = CreateFile2((LPCTSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL); +#else + WCHAR filenameW[FILENAME_MAX + 0x200 + 1]; + MultiByteToWideChar(CP_ACP, 0, (const char*)filename, -1, filenameW, FILENAME_MAX + 0x200); + hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL); +#endif +#else + hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL); +#endif + } + + iowin = win32_build_iowin(hFile); + if (iowin == NULL) + return NULL; + iowin->filenameLength = _tcslen((TCHAR*)filename) + 1; + iowin->filename = (void*)malloc(iowin->filenameLength * sizeof(TCHAR)); + _tcsncpy(iowin->filename, (TCHAR*)filename, iowin->filenameLength); + return iowin; +} + +static voidpf ZCALLBACK win32_opendisk64_file_func(voidpf opaque, voidpf stream, uint32_t number_disk, int mode) +{ + WIN32FILE_IOWIN *iowin = NULL; + TCHAR *diskFilename = NULL; + voidpf ret = NULL; + int i = 0; + + if (stream == NULL) + return NULL; + iowin = (WIN32FILE_IOWIN*)stream; + diskFilename = (TCHAR*)malloc(iowin->filenameLength * sizeof(TCHAR)); + _tcsncpy(diskFilename, iowin->filename, iowin->filenameLength); + for (i = iowin->filenameLength - 1; i >= 0; i -= 1) + { + if (diskFilename[i] != _T('.')) + continue; + _sntprintf(&diskFilename[i], iowin->filenameLength - i, _T(".z%02d"), number_disk + 1); + break; + } + if (i >= 0) + ret = win32_open64_file_func(opaque, (char*)diskFilename, mode); + free(diskFilename); + return ret; +} + +static voidpf ZCALLBACK win32_opendisk64_file_funcW(voidpf opaque, voidpf stream, uint32_t number_disk, int mode) +{ + WIN32FILE_IOWIN *iowin = NULL; + WCHAR *diskFilename = NULL; + voidpf ret = NULL; + int i = 0; + + if (stream == NULL) + return NULL; + iowin = (WIN32FILE_IOWIN*)stream; + diskFilename = (WCHAR*)malloc((iowin->filenameLength + 10) * sizeof(WCHAR)); + wcsncpy(diskFilename, iowin->filename, iowin->filenameLength); + for (i = iowin->filenameLength - 1; i >= 0; i -= 1) + { + if (diskFilename[i] != L'.') + continue; + _snwprintf(&diskFilename[i], (iowin->filenameLength + 10) - i, L".z%02d", number_disk + 1); + break; + } + if (i >= 0) + ret = win32_open64_file_funcW(opaque, diskFilename, mode); + free(diskFilename); + return ret; +} + +static voidpf ZCALLBACK win32_opendisk64_file_funcA(voidpf opaque, voidpf stream, uint32_t number_disk, int mode) +{ + WIN32FILE_IOWIN *iowin = NULL; + char *diskFilename = NULL; + voidpf ret = NULL; + int i = 0; + + if (stream == NULL) + return NULL; + iowin = (WIN32FILE_IOWIN*)stream; + diskFilename = (char*)malloc(iowin->filenameLength * sizeof(char)); + strncpy(diskFilename, iowin->filename, iowin->filenameLength); + for (i = iowin->filenameLength - 1; i >= 0; i -= 1) + { + if (diskFilename[i] != '.') + continue; + _snprintf(&diskFilename[i], iowin->filenameLength - i, ".z%02d", number_disk + 1); + break; + } + if (i >= 0) + ret = win32_open64_file_funcA(opaque, diskFilename, mode); + free(diskFilename); + return ret; +} + +static voidpf ZCALLBACK win32_opendisk_file_func(voidpf opaque, voidpf stream, uint32_t number_disk, int mode) +{ + WIN32FILE_IOWIN *iowin = NULL; + TCHAR *diskFilename = NULL; + voidpf ret = NULL; + int i = 0; + + if (stream == NULL) + return NULL; + iowin = (WIN32FILE_IOWIN*)stream; + diskFilename = (TCHAR*)malloc(iowin->filenameLength * sizeof(TCHAR)); + _tcsncpy(diskFilename, iowin->filename, iowin->filenameLength); + for (i = iowin->filenameLength - 1; i >= 0; i -= 1) + { + if (diskFilename[i] != _T('.')) + continue; + _sntprintf(&diskFilename[i], iowin->filenameLength - i, _T(".z%02d"), number_disk + 1); + break; + } + if (i >= 0) + ret = win32_open_file_func(opaque, (char*)diskFilename, mode); + free(diskFilename); + return ret; +} + +uint32_t ZCALLBACK win32_read_file_func(voidpf opaque, voidpf stream, void* buf, uint32_t size) +{ + DWORD ret = 0; + HANDLE hFile = NULL; + if (stream != NULL) + hFile = ((WIN32FILE_IOWIN*)stream)->hf; + + if (hFile != NULL) + { + if (!ReadFile(hFile, buf, size, &ret, NULL)) + { + DWORD dwErr = GetLastError(); + if (dwErr == ERROR_HANDLE_EOF) + dwErr = 0; + ((WIN32FILE_IOWIN*)stream)->error = (int)dwErr; + } + } + + return (uint32_t)ret; +} + +uint32_t ZCALLBACK win32_write_file_func(voidpf opaque, voidpf stream, const void *buf, uint32_t size) +{ + DWORD ret = 0; + HANDLE hFile = NULL; + if (stream != NULL) + hFile = ((WIN32FILE_IOWIN*)stream)->hf; + + if (hFile != NULL) + { + if (!WriteFile(hFile, buf, size, &ret, NULL)) + { + DWORD dwErr = GetLastError(); + if (dwErr == ERROR_HANDLE_EOF) + dwErr = 0; + ((WIN32FILE_IOWIN*)stream)->error = (int)dwErr; + } + } + + return (uint32_t)ret; +} + +static BOOL win32_setfilepointer_internal(HANDLE hFile, LARGE_INTEGER pos, LARGE_INTEGER *newPos, DWORD dwMoveMethod) +{ +#ifdef IOWIN32_USING_WINRT_API + return SetFilePointerEx(hFile, pos, newPos, dwMoveMethod); +#else + LONG lHigh = pos.HighPart; + BOOL ret = TRUE; + DWORD dwNewPos = SetFilePointer(hFile, pos.LowPart, &lHigh, dwMoveMethod); + if ((dwNewPos == INVALID_SET_FILE_POINTER) && (GetLastError() != NO_ERROR)) + ret = FALSE; + if ((newPos != NULL) && (ret)) + { + newPos->LowPart = dwNewPos; + newPos->HighPart = lHigh; + } + return ret; +#endif +} + +static long ZCALLBACK win32_tell_file_func(voidpf opaque, voidpf stream) +{ + long ret = -1; + HANDLE hFile = NULL; + if (stream != NULL) + hFile = ((WIN32FILE_IOWIN*)stream)->hf; + if (hFile != NULL) + { + LARGE_INTEGER pos; + pos.QuadPart = 0; + if (!win32_setfilepointer_internal(hFile, pos, &pos, FILE_CURRENT)) + { + DWORD dwErr = GetLastError(); + ((WIN32FILE_IOWIN*)stream)->error = (int)dwErr; + ret = -1; + } + else + ret = (long)pos.LowPart; + } + return ret; +} + +uint64_t ZCALLBACK win32_tell64_file_func(voidpf opaque, voidpf stream) +{ + uint64_t ret = (uint64_t)-1; + HANDLE hFile = NULL; + if (stream != NULL) + hFile = ((WIN32FILE_IOWIN*)stream)->hf; + + if (hFile) + { + LARGE_INTEGER pos; + pos.QuadPart = 0; + if (!win32_setfilepointer_internal(hFile, pos, &pos, FILE_CURRENT)) + { + DWORD dwErr = GetLastError(); + ((WIN32FILE_IOWIN*)stream)->error = (int)dwErr; + ret = (uint64_t)-1; + } + else + ret = pos.QuadPart; + } + return ret; +} + +static long ZCALLBACK win32_seek_file_func(voidpf opaque, voidpf stream, uint32_t offset, int origin) +{ + DWORD dwMoveMethod = 0xFFFFFFFF; + HANDLE hFile = NULL; + long ret = -1; + + if (stream != NULL) + hFile = ((WIN32FILE_IOWIN*)stream)->hf; + + switch (origin) + { + case ZLIB_FILEFUNC_SEEK_CUR: + dwMoveMethod = FILE_CURRENT; + break; + case ZLIB_FILEFUNC_SEEK_END: + dwMoveMethod = FILE_END; + break; + case ZLIB_FILEFUNC_SEEK_SET: + dwMoveMethod = FILE_BEGIN; + break; + default: + return -1; + } + + if (hFile != NULL) + { + LARGE_INTEGER pos; + pos.QuadPart = offset; + if (!win32_setfilepointer_internal(hFile, pos, NULL, dwMoveMethod)) + { + DWORD dwErr = GetLastError(); + ((WIN32FILE_IOWIN*)stream)->error = (int)dwErr; + ret = -1; + } + else + ret = 0; + } + return ret; +} + +long ZCALLBACK win32_seek64_file_func(voidpf opaque, voidpf stream, uint64_t offset, int origin) +{ + DWORD dwMoveMethod = 0xFFFFFFFF; + HANDLE hFile = NULL; + long ret = -1; + + if (stream != NULL) + hFile = ((WIN32FILE_IOWIN*)stream)->hf; + + switch (origin) + { + case ZLIB_FILEFUNC_SEEK_CUR: + dwMoveMethod = FILE_CURRENT; + break; + case ZLIB_FILEFUNC_SEEK_END: + dwMoveMethod = FILE_END; + break; + case ZLIB_FILEFUNC_SEEK_SET: + dwMoveMethod = FILE_BEGIN; + break; + default: + return -1; + } + + if (hFile) + { + LARGE_INTEGER pos; + pos.QuadPart = offset; + if (!win32_setfilepointer_internal(hFile, pos, NULL, dwMoveMethod)) + { + DWORD dwErr = GetLastError(); + ((WIN32FILE_IOWIN*)stream)->error = (int)dwErr; + ret = -1; + } + else + ret = 0; + } + return ret; +} + +int ZCALLBACK win32_close_file_func(voidpf opaque, voidpf stream) +{ + WIN32FILE_IOWIN* iowin = NULL; + int ret = -1; + + if (stream == NULL) + return ret; + iowin = ((WIN32FILE_IOWIN*)stream); + if (iowin->filename != NULL) + free(iowin->filename); + if (iowin->hf != NULL) + { + CloseHandle(iowin->hf); + ret=0; + } + free(stream); + return ret; +} + +int ZCALLBACK win32_error_file_func(voidpf opaque, voidpf stream) +{ + int ret = -1; + if (stream == NULL) + return ret; + ret = ((WIN32FILE_IOWIN*)stream)->error; + return ret; +} + +void fill_win32_filefunc(zlib_filefunc_def *pzlib_filefunc_def) +{ + pzlib_filefunc_def->zopen_file = win32_open_file_func; + pzlib_filefunc_def->zopendisk_file = win32_opendisk_file_func; + pzlib_filefunc_def->zread_file = win32_read_file_func; + pzlib_filefunc_def->zwrite_file = win32_write_file_func; + pzlib_filefunc_def->ztell_file = win32_tell_file_func; + pzlib_filefunc_def->zseek_file = win32_seek_file_func; + pzlib_filefunc_def->zclose_file = win32_close_file_func; + pzlib_filefunc_def->zerror_file = win32_error_file_func; + pzlib_filefunc_def->opaque = NULL; +} + +void fill_win32_filefunc64(zlib_filefunc64_def *pzlib_filefunc_def) +{ + pzlib_filefunc_def->zopen64_file = win32_open64_file_func; + pzlib_filefunc_def->zopendisk64_file = win32_opendisk64_file_func; + pzlib_filefunc_def->zread_file = win32_read_file_func; + pzlib_filefunc_def->zwrite_file = win32_write_file_func; + pzlib_filefunc_def->ztell64_file = win32_tell64_file_func; + pzlib_filefunc_def->zseek64_file = win32_seek64_file_func; + pzlib_filefunc_def->zclose_file = win32_close_file_func; + pzlib_filefunc_def->zerror_file = win32_error_file_func; + pzlib_filefunc_def->opaque = NULL; +} + +void fill_win32_filefunc64A(zlib_filefunc64_def *pzlib_filefunc_def) +{ + pzlib_filefunc_def->zopen64_file = win32_open64_file_funcA; + pzlib_filefunc_def->zopendisk64_file = win32_opendisk64_file_funcA; + pzlib_filefunc_def->zread_file = win32_read_file_func; + pzlib_filefunc_def->zwrite_file = win32_write_file_func; + pzlib_filefunc_def->ztell64_file = win32_tell64_file_func; + pzlib_filefunc_def->zseek64_file = win32_seek64_file_func; + pzlib_filefunc_def->zclose_file = win32_close_file_func; + pzlib_filefunc_def->zerror_file = win32_error_file_func; + pzlib_filefunc_def->opaque = NULL; +} + +void fill_win32_filefunc64W(zlib_filefunc64_def *pzlib_filefunc_def) +{ + pzlib_filefunc_def->zopen64_file = win32_open64_file_funcW; + pzlib_filefunc_def->zopendisk64_file = win32_opendisk64_file_funcW; + pzlib_filefunc_def->zread_file = win32_read_file_func; + pzlib_filefunc_def->zwrite_file = win32_write_file_func; + pzlib_filefunc_def->ztell64_file = win32_tell64_file_func; + pzlib_filefunc_def->zseek64_file = win32_seek64_file_func; + pzlib_filefunc_def->zclose_file = win32_close_file_func; + pzlib_filefunc_def->zerror_file = win32_error_file_func; + pzlib_filefunc_def->opaque = NULL; +} + +#endif // _WIN32 diff --git a/src/libgame/zip/iowin32.h b/src/libgame/zip/iowin32.h new file mode 100644 index 00000000..7ce4fc9f --- /dev/null +++ b/src/libgame/zip/iowin32.h @@ -0,0 +1,35 @@ +/* iowin32.h -- IO base function header for compress/uncompress .zip + Version 1.2.0, September 16th, 2017 + part of the MiniZip project + + Copyright (C) 2012-2017 Nathan Moinvaziri + https://github.com/nmoinvaz/minizip + Copyright (C) 2009-2010 Mathias Svensson + Modifications for Zip64 support + http://result42.com + Copyright (C) 1998-2010 Gilles Vollant + http://www.winimage.com/zLibDll/minizip.html + + 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. +*/ + +#ifndef _IOWIN32_H +#define _IOWIN32_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +void fill_win32_filefunc(zlib_filefunc_def *pzlib_filefunc_def); +void fill_win32_filefunc64(zlib_filefunc64_def *pzlib_filefunc_def); +void fill_win32_filefunc64A(zlib_filefunc64_def *pzlib_filefunc_def); +void fill_win32_filefunc64W(zlib_filefunc64_def *pzlib_filefunc_def); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/src/libgame/zip/miniunz.c b/src/libgame/zip/miniunz.c new file mode 100644 index 00000000..478d4a8f --- /dev/null +++ b/src/libgame/zip/miniunz.c @@ -0,0 +1,666 @@ +/* miniunz.c + Version 1.2.0, September 16th, 2017 + sample part of the MiniZip project + + Copyright (C) 2012-2017 Nathan Moinvaziri + https://github.com/nmoinvaz/minizip + Copyright (C) 2009-2010 Mathias Svensson + Modifications for Zip64 support + http://result42.com + Copyright (C) 2007-2008 Even Rouault + Modifications of Unzip for Zip64 + Copyright (C) 1998-2010 Gilles Vollant + http://www.winimage.com/zLibDll/minizip.html + + 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. +*/ + +#if defined(__linux__) +// Linux needs this to support file operation on files larger then 4+GB +# ifndef __USE_FILE_OFFSET64 +# define __USE_FILE_OFFSET64 +# endif +# ifndef __USE_LARGEFILE64 +# define __USE_LARGEFILE64 +# endif +# ifndef _LARGEFILE64_SOURCE +# define _LARGEFILE64_SOURCE +# endif +# ifndef _FILE_OFFSET_BIT +# define _FILE_OFFSET_BIT 64 +# endif +#endif + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "zlib.h" +#include "ioapi.h" + +#ifdef _WIN32 +# include +# include +#else +# include +#endif + +#include "unzip.h" + +#ifdef _WIN32 +# define USEWIN32IOAPI +# include "iowin32.h" +#endif + +#include "miniunz.h" + +#ifdef _WIN32 +# define MKDIR(d) _mkdir(d) +# define CHDIR(d) _chdir(d) +#else +# define MKDIR(d) mkdir(d, 0775) +# define CHDIR(d) chdir(d) +#endif + + +#define DEBUG_PRINTF 0 +#define debug_printf(...) \ + do { if (DEBUG_PRINTF) fprintf(stderr, __VA_ARGS__); } while (0) + + +static char **zip_entries = NULL; +static int num_zip_entries = 0; +static int max_zip_entries = 0; +static const int max_alloc_zip_entries = 256; + +static void add_zip_entry(const char *s) +{ + if (zip_entries == NULL) + { + max_zip_entries = max_alloc_zip_entries; + + zip_entries = malloc(max_zip_entries * sizeof(char *)); + + if (zip_entries == NULL) + exit(1); + + num_zip_entries = 0; + } + + if (num_zip_entries >= max_zip_entries - 1) + { + max_zip_entries += max_alloc_zip_entries; + + zip_entries = realloc(zip_entries, max_zip_entries * sizeof(char *)); + + if (zip_entries == NULL) + exit(1); + } + + zip_entries[num_zip_entries++] = strdup(s); + zip_entries[num_zip_entries] = NULL; // ensure NULL terminated list +} + +static void free_zip_entries(void) +{ + if (zip_entries == NULL) + return; + + int i; + + for (i = 0; i < num_zip_entries; i++) + free(zip_entries[i]); + + num_zip_entries = 0; + max_zip_entries = 0; + + free(zip_entries); + + zip_entries = NULL; +} + +static int invalid_date(const struct tm *ptm) +{ +#define datevalue_in_range(min, max, value) ((min) <= (value) && (value) <= (max)) + return (!datevalue_in_range(0, 207, ptm->tm_year) || + !datevalue_in_range(0, 11, ptm->tm_mon) || + !datevalue_in_range(1, 31, ptm->tm_mday) || + !datevalue_in_range(0, 23, ptm->tm_hour) || + !datevalue_in_range(0, 59, ptm->tm_min) || + !datevalue_in_range(0, 59, ptm->tm_sec)); +#undef datevalue_in_range +} + +// Conversion without validation +static void dosdate_to_raw_tm(uint64_t dos_date, struct tm *ptm) +{ + uint64_t date = (uint64_t)(dos_date >> 16); + + ptm->tm_mday = (uint16_t)(date & 0x1f); + ptm->tm_mon = (uint16_t)(((date & 0x1E0) / 0x20) - 1); + ptm->tm_year = (uint16_t)(((date & 0x0FE00) / 0x0200) + 80); + ptm->tm_hour = (uint16_t)((dos_date & 0xF800) / 0x800); + ptm->tm_min = (uint16_t)((dos_date & 0x7E0) / 0x20); + ptm->tm_sec = (uint16_t)(2 * (dos_date & 0x1f)); + ptm->tm_isdst = -1; +} + +static int dosdate_to_tm(uint64_t dos_date, struct tm *ptm) +{ + dosdate_to_raw_tm(dos_date, ptm); + + if (invalid_date(ptm)) + { + // Invalid date stored, so don't return it. + memset(ptm, 0, sizeof(struct tm)); + return -1; + } + return 0; +} + +#ifndef _WIN32 +static time_t dosdate_to_time_t(uint64_t dos_date) +{ + struct tm ptm; + dosdate_to_raw_tm(dos_date, &ptm); + return mktime(&ptm); +} +#endif + +static void change_file_date(const char *path, uint32_t dos_date) +{ +#ifdef _WIN32 + HANDLE handle = NULL; + FILETIME ftm, ftm_local, ftm_create, ftm_access, ftm_modified; + + handle = CreateFileA(path, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL); + if (handle != INVALID_HANDLE_VALUE) + { + GetFileTime(handle, &ftm_create, &ftm_access, &ftm_modified); + DosDateTimeToFileTime((WORD)(dos_date >> 16), (WORD)dos_date, &ftm_local); + LocalFileTimeToFileTime(&ftm_local, &ftm); + SetFileTime(handle, &ftm, &ftm_access, &ftm); + CloseHandle(handle); + } +#else + struct utimbuf ut; + ut.actime = ut.modtime = dosdate_to_time_t(dos_date); + utime(path, &ut); +#endif +} + +static int makedir(const char *newdir) +{ + char *buffer = NULL; + char *p = NULL; + int len = (int)strlen(newdir); + + if (len <= 0) + return 0; + + buffer = (char*)malloc(len + 1); + if (buffer == NULL) + { + debug_printf("Error allocating memory\n"); + return -1; + } + + strcpy(buffer, newdir); + + if (buffer[len - 1] == '/') + buffer[len - 1] = 0; + + if (MKDIR(buffer) == 0) + { + free(buffer); + return 1; + } + + p = buffer + 1; + while (1) + { + char hold; + while (*p && *p != '\\' && *p != '/') + p++; + hold = *p; + *p = 0; + + if ((MKDIR(buffer) == -1) && (errno == ENOENT)) + { + debug_printf("couldn't create directory %s (%d)\n", buffer, errno); + free(buffer); + return 0; + } + + if (hold == 0) + break; + + *p++ = hold; + } + + free(buffer); + return 1; +} + +static FILE *get_file_handle(const char *path) +{ + FILE *handle = NULL; +#if defined(WIN32) + wchar_t *pathWide = NULL; + int pathLength = 0; + + pathLength = MultiByteToWideChar(CP_UTF8, 0, path, -1, NULL, 0) + 1; + pathWide = (wchar_t*)calloc(pathLength, sizeof(wchar_t)); + MultiByteToWideChar(CP_UTF8, 0, path, -1, pathWide, pathLength); + handle = _wfopen((const wchar_t*)pathWide, L"rb"); + free(pathWide); +#else + handle = fopen64(path, "rb"); +#endif + + return handle; +} + +static int check_file_exists(const char *path) +{ + FILE *handle = get_file_handle(path); + if (handle == NULL) + return 0; + fclose(handle); + return 1; +} + +static void display_zpos64(uint64_t n, int size_char) +{ + /* To avoid compatibility problem we do here the conversion */ + char number[21] = { 0 }; + int offset = 19; + int pos_string = 19; + int size_display_string = 19; + + while (1) + { + number[offset] = (char)((n % 10) + '0'); + if (number[offset] != '0') + pos_string = offset; + n /= 10; + if (offset == 0) + break; + offset--; + } + + size_display_string -= pos_string; + while (size_char-- > size_display_string) + debug_printf(" "); + debug_printf("%s", &number[pos_string]); +} + +static int miniunz_list(unzFile uf) +{ + free_zip_entries(); + + int err = unzGoToFirstFile(uf); + if (err != UNZ_OK) + { + debug_printf("error %d with zipfile in unzGoToFirstFile\n", err); + return 1; + } + + debug_printf(" Length Method Size Ratio Date Time CRC-32 Name\n"); + debug_printf(" ------ ------ ---- ----- ---- ---- ------ ----\n"); + + do + { + char filename_inzip[256] = {0}; + unz_file_info64 file_info = {0}; + uint32_t ratio = 0; + struct tm tmu_date = { 0 }; + const char *string_method = NULL; + char char_crypt = ' '; + + err = unzGetCurrentFileInfo64(uf, &file_info, filename_inzip, sizeof(filename_inzip), NULL, 0, NULL, 0); + if (err != UNZ_OK) + { + debug_printf("error %d with zipfile in unzGetCurrentFileInfo\n", err); + break; + } + + add_zip_entry(filename_inzip); + + if (file_info.uncompressed_size > 0) + ratio = (uint32_t)((file_info.compressed_size * 100) / file_info.uncompressed_size); + + /* Display a '*' if the file is encrypted */ + if ((file_info.flag & 1) != 0) + char_crypt = '*'; + + if (file_info.compression_method == 0) + string_method = "Stored"; + else if (file_info.compression_method == Z_DEFLATED) + { + uint16_t level = (uint16_t)((file_info.flag & 0x6) / 2); + if (level == 0) + string_method = "Defl:N"; + else if (level == 1) + string_method = "Defl:X"; + else if ((level == 2) || (level == 3)) + string_method = "Defl:F"; /* 2:fast , 3 : extra fast*/ + else + string_method = "Unkn. "; + } + else if (file_info.compression_method == Z_BZIP2ED) + { + string_method = "BZip2 "; + } + else + string_method = "Unkn. "; + + display_zpos64(file_info.uncompressed_size, 7); + debug_printf(" %6s%c", string_method, char_crypt); + display_zpos64(file_info.compressed_size, 7); + + dosdate_to_tm(file_info.dos_date, &tmu_date); + debug_printf(" %3u%% %2.2u-%2.2u-%2.2u %2.2u:%2.2u %8.8x %s\n", ratio, + (uint32_t)tmu_date.tm_mon + 1, (uint32_t)tmu_date.tm_mday, + (uint32_t)tmu_date.tm_year % 100, + (uint32_t)tmu_date.tm_hour, (uint32_t)tmu_date.tm_min, + file_info.crc, filename_inzip); + + err = unzGoToNextFile(uf); + } + while (err == UNZ_OK); + + if (err != UNZ_END_OF_LIST_OF_FILE && err != UNZ_OK) + { + debug_printf("error %d with zipfile in unzGoToNextFile\n", err); + return err; + } + + return 0; +} + +static int miniunz_extract_currentfile(unzFile uf, int opt_extract_without_path, int *popt_overwrite, const char *password) +{ + unz_file_info64 file_info = {0}; + FILE* fout = NULL; + void* buf = NULL; + uint16_t size_buf = 8192; + int err = UNZ_OK; + int errclose = UNZ_OK; + int skip = 0; + char filename_inzip[256] = {0}; + char *filename_withoutpath = NULL; + const char *write_filename = NULL; + char *p = NULL; + + err = unzGetCurrentFileInfo64(uf, &file_info, filename_inzip, sizeof(filename_inzip), NULL, 0, NULL, 0); + if (err != UNZ_OK) + { + debug_printf("error %d with zipfile in unzGetCurrentFileInfo\n",err); + return err; + } + + add_zip_entry(filename_inzip); + + p = filename_withoutpath = filename_inzip; + while (*p != 0) + { + if ((*p == '/') || (*p == '\\')) + filename_withoutpath = p+1; + p++; + } + + /* If zip entry is a directory then create it on disk */ + if (*filename_withoutpath == 0) + { + if (opt_extract_without_path == 0) + { + debug_printf("creating directory: %s\n", filename_inzip); + MKDIR(filename_inzip); + } + return err; + } + + buf = (void*)malloc(size_buf); + if (buf == NULL) + { + debug_printf("Error allocating memory\n"); + return UNZ_INTERNALERROR; + } + + err = unzOpenCurrentFilePassword(uf, password); + if (err != UNZ_OK) + debug_printf("error %d with zipfile in unzOpenCurrentFilePassword\n", err); + + if (opt_extract_without_path) + write_filename = filename_withoutpath; + else + write_filename = filename_inzip; + + /* Determine if the file should be overwritten or not and ask the user if needed */ + if ((err == UNZ_OK) && (*popt_overwrite == 0) && (check_file_exists(write_filename))) + { + char rep = 0; + do + { + char answer[128]; + debug_printf("The file %s exists. Overwrite ? [y]es, [n]o, [A]ll: ", write_filename); + if (scanf("%1s", answer) != 1) + exit(EXIT_FAILURE); + rep = answer[0]; + if ((rep >= 'a') && (rep <= 'z')) + rep -= 0x20; + } + while ((rep != 'Y') && (rep != 'N') && (rep != 'A')); + + if (rep == 'N') + skip = 1; + if (rep == 'A') + *popt_overwrite = 1; + } + + /* Create the file on disk so we can unzip to it */ + if ((skip == 0) && (err == UNZ_OK)) + { + fout = fopen64(write_filename, "wb"); + /* Some zips don't contain directory alone before file */ + if ((fout == NULL) && (opt_extract_without_path == 0) && + (filename_withoutpath != (char*)filename_inzip)) + { + char c = *(filename_withoutpath-1); + *(filename_withoutpath-1) = 0; + makedir(write_filename); + *(filename_withoutpath-1) = c; + fout = fopen64(write_filename, "wb"); + } + if (fout == NULL) + debug_printf("error opening %s\n", write_filename); + } + + /* Read from the zip, unzip to buffer, and write to disk */ + if (fout != NULL) + { + debug_printf(" extracting: %s\n", write_filename); + + do + { + err = unzReadCurrentFile(uf, buf, size_buf); + if (err < 0) + { + debug_printf("error %d with zipfile in unzReadCurrentFile\n", err); + break; + } + if (err == 0) + break; + if (fwrite(buf, err, 1, fout) != 1) + { + debug_printf("error %d in writing extracted file\n", errno); + err = UNZ_ERRNO; + break; + } + } + while (err > 0); + + if (fout) + fclose(fout); + + /* Set the time of the file that has been unzipped */ + if (err == 0) + change_file_date(write_filename, file_info.dos_date); + } + + errclose = unzCloseCurrentFile(uf); + if (errclose != UNZ_OK) + debug_printf("error %d with zipfile in unzCloseCurrentFile\n", errclose); + + free(buf); + return err; +} + +static int miniunz_extract_all(unzFile uf, int opt_extract_without_path, int opt_overwrite, const char *password) +{ + free_zip_entries(); + + int err = unzGoToFirstFile(uf); + if (err != UNZ_OK) + { + debug_printf("error %d with zipfile in unzGoToFirstFile\n", err); + return 1; + } + + do + { + err = miniunz_extract_currentfile(uf, opt_extract_without_path, &opt_overwrite, password); + if (err != UNZ_OK) + break; + err = unzGoToNextFile(uf); + } + while (err == UNZ_OK); + + if (err != UNZ_END_OF_LIST_OF_FILE) + { + debug_printf("error %d with zipfile in unzGoToNextFile\n", err); + return 1; + } + return 0; +} + +char **zip_list(char *filename) +{ + if (filename == NULL) + { + debug_printf("No filename specified!\n"); + + return NULL; + } + +#ifdef USEWIN32IOAPI + zlib_filefunc64_def ffunc; + fill_win32_filefunc64A(&ffunc); + unzFile uf = unzOpen2_64(filename, &ffunc); +#else + unzFile uf = unzOpen64(filename); +#endif + + if (uf == NULL) + { + debug_printf("Cannot open file '%s'!\n", filename); + + return NULL; + } + + debug_printf("File '%s' opened.\n", filename); + + int success = (miniunz_list(uf) == UNZ_OK); + + unzClose(uf); + + if (!success) + return NULL; + + return zip_entries; +} + +char **zip_extract(char *filename, char *directory) +{ + if (filename == NULL) + { + debug_printf("No zip filename specified!\n"); + + return NULL; + } + + if (directory == NULL) + { + debug_printf("No target directory specified!\n"); + + return NULL; + } + + struct stat file_status; + + if (stat(directory, &file_status) != 0 || !S_ISDIR(file_status.st_mode)) + { + debug_printf("Directory '%s' does not exist!\n", directory); + + return NULL; + } + +#ifdef USEWIN32IOAPI + zlib_filefunc64_def ffunc; + fill_win32_filefunc64A(&ffunc); + unzFile uf = unzOpen2_64(filename, &ffunc); +#else + unzFile uf = unzOpen64(filename); +#endif + + if (uf == NULL) + { + debug_printf("Cannot open file '%s'!\n", filename); + + return NULL; + } + + debug_printf("File '%s' opened.\n", filename); + + int max_directory_size = 1024; + char last_directory[max_directory_size]; + + if (getcwd(last_directory, max_directory_size) == NULL) + { + debug_printf("Cannot get current directory!\n"); + + unzClose(uf); + + return NULL; + } + + if (CHDIR(directory)) // change to target directory + { + debug_printf("Cannot change to directory '%s'!\n", directory); + + unzClose(uf); + + return NULL; + } + + int success = (miniunz_extract_all(uf, 0, 1, NULL) == UNZ_OK); + + CHDIR(last_directory); // change back to previous directory + + unzClose(uf); + + if (!success) + return NULL; + + return zip_entries; +} diff --git a/src/libgame/zip/miniunz.h b/src/libgame/zip/miniunz.h new file mode 100644 index 00000000..a61fbfb3 --- /dev/null +++ b/src/libgame/zip/miniunz.h @@ -0,0 +1,11 @@ +// ============================================================================ +// miniunz.h +// ============================================================================ + +#ifndef MINIUNZ_H +#define MINIUNZ_H + +char **zip_list(char *); +char **zip_extract(char *, char *); + +#endif // MINIUNZ_H diff --git a/src/libgame/zip/unzip.c b/src/libgame/zip/unzip.c new file mode 100644 index 00000000..5f1cb151 --- /dev/null +++ b/src/libgame/zip/unzip.c @@ -0,0 +1,2009 @@ +/* unzip.c -- IO for uncompress .zip files using zlib + Version 1.2.0, September 16th, 2017 + part of the MiniZip project + + Copyright (C) 2010-2017 Nathan Moinvaziri + Modifications for AES, PKWARE disk spanning + https://github.com/nmoinvaz/minizip + Copyright (C) 2009-2010 Mathias Svensson + Modifications for Zip64 support on both zip and unzip + http://result42.com + Copyright (C) 2007-2008 Even Rouault + Modifications of Unzip for Zip64 + Copyright (C) 1998-2010 Gilles Vollant + http://www.winimage.com/zLibDll/minizip.html + + 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 +#include +#include +#include +#include +#include +#include + +#define NOUNCRYPT + +#include "zlib.h" +#include "unzip.h" + +#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 +#ifdef HAVE_APPLE_COMPRESSION +# include +#endif + +#ifndef NOUNCRYPT +# include "crypt.h" +#endif + +#define DISKHEADERMAGIC (0x08074b50) +#define LOCALHEADERMAGIC (0x04034b50) +#define CENTRALHEADERMAGIC (0x02014b50) +#define ENDHEADERMAGIC (0x06054b50) +#define ZIP64ENDHEADERMAGIC (0x06064b50) +#define ZIP64ENDLOCHEADERMAGIC (0x07064b50) + +#define SIZECENTRALDIRITEM (0x2e) +#define SIZECENTRALHEADERLOCATOR (0x14) +#define SIZEZIPLOCALHEADER (0x1e) + +#ifndef BUFREADCOMMENT +# define BUFREADCOMMENT (0x400) +#endif + +#ifndef UNZ_BUFSIZE +# define UNZ_BUFSIZE (UINT16_MAX) +#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.2.0 Copyright 1998-2017 - https://github.com/nmoinvaz/minizip"; + +/* unz_file_info_internal contain internal info about a file in zipfile*/ +typedef struct unz_file_info64_internal_s +{ + uint64_t offset_curfile; /* relative offset of local header 8 bytes */ + uint64_t byte_before_the_zipfile; /* byte before the zipfile, (>0 for sfx) */ +#ifdef HAVE_AES + uint8_t aes_encryption_mode; + uint16_t aes_compression_method; + uint16_t aes_version; +#endif +} unz_file_info64_internal; + +/* file_in_zip_read_info_s contain internal information about a file in zipfile */ +typedef struct +{ + uint8_t *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_APPLE_COMPRESSION + compression_stream astream; /* libcompression stream structure */ +#endif +#ifdef HAVE_AES + fcrypt_ctx aes_ctx; +#endif + uint64_t pos_in_zipfile; /* position in byte on the zipfile, for fseek */ + uint8_t stream_initialised; /* flag set if stream structure is initialised */ + + uint64_t offset_local_extrafield; /* offset of the local extra field */ + uint16_t size_local_extrafield; /* size of the local extra field */ + uint64_t pos_local_extrafield; /* position in the local extra field in read */ + uint64_t total_out_64; + + uint32_t crc32; /* crc32 of all data uncompressed */ + uint32_t crc32_expected; /* crc32 we must obtain after decompress all */ + uint64_t rest_read_compressed; /* number of byte to be decompressed */ + uint64_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 */ + uint16_t compression_method; /* compression method (0==store) */ + uint64_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 */ + + uint64_t byte_before_the_zipfile; /* byte before the zipfile, (>0 for sfx) */ + uint64_t num_file; /* number of the current file in the zipfile */ + uint64_t pos_in_central_dir; /* pos of the current file in the central dir */ + uint64_t current_file_ok; /* flag about the usability of the current file */ + uint64_t central_pos; /* position of the beginning of the central dir */ + uint32_t number_disk; /* number of the current disk, used for spanning ZIP */ + uint64_t size_central_dir; /* size of the central directory */ + uint64_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 is_zip64; /* is the current file zip64 */ +#ifndef NOUNCRYPT + uint32_t keys[3]; /* keys defining the pseudo-random sequence */ + const z_crc_t *pcrc_32_tab; +#endif +} unz64_internal; + +/* Read a byte from a gz_stream; Return EOF for end of file. */ +static int unzReadUInt8(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, uint8_t *value) +{ + uint8_t c = 0; + if (ZREAD64(*pzlib_filefunc_def, filestream, &c, 1) == 1) + { + *value = (uint8_t)c; + return UNZ_OK; + } + *value = 0; + if (ZERROR64(*pzlib_filefunc_def, filestream)) + return UNZ_ERRNO; + return UNZ_EOF; +} + +static int unzReadUInt16(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, uint16_t *value) +{ + uint16_t x; + uint8_t c = 0; + int err = UNZ_OK; + + err = unzReadUInt8(pzlib_filefunc_def, filestream, &c); + x = (uint16_t)c; + if (err == UNZ_OK) + err = unzReadUInt8(pzlib_filefunc_def, filestream, &c); + x |= ((uint16_t)c) << 8; + + if (err == UNZ_OK) + *value = x; + else + *value = 0; + return err; +} + +static int unzReadUInt32(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, uint32_t *value) +{ + uint32_t x = 0; + uint8_t c = 0; + int err = UNZ_OK; + + err = unzReadUInt8(pzlib_filefunc_def, filestream, &c); + x = (uint32_t)c; + if (err == UNZ_OK) + err = unzReadUInt8(pzlib_filefunc_def, filestream, &c); + x |= ((uint32_t)c) << 8; + if (err == UNZ_OK) + err = unzReadUInt8(pzlib_filefunc_def, filestream, &c); + x |= ((uint32_t)c) << 16; + if (err == UNZ_OK) + err = unzReadUInt8(pzlib_filefunc_def, filestream, &c); + x += ((uint32_t)c) << 24; + + if (err == UNZ_OK) + *value = x; + else + *value = 0; + return err; +} + +static int unzReadUInt64(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, uint64_t *value) +{ + uint64_t x = 0; + uint8_t i = 0; + int err = UNZ_OK; + + err = unzReadUInt8(pzlib_filefunc_def, filestream, &i); + x = (uint64_t)i; + if (err == UNZ_OK) + err = unzReadUInt8(pzlib_filefunc_def, filestream, &i); + x |= ((uint64_t)i) << 8; + if (err == UNZ_OK) + err = unzReadUInt8(pzlib_filefunc_def, filestream, &i); + x |= ((uint64_t)i) << 16; + if (err == UNZ_OK) + err = unzReadUInt8(pzlib_filefunc_def, filestream, &i); + x |= ((uint64_t)i) << 24; + if (err == UNZ_OK) + err = unzReadUInt8(pzlib_filefunc_def, filestream, &i); + x |= ((uint64_t)i) << 32; + if (err == UNZ_OK) + err = unzReadUInt8(pzlib_filefunc_def, filestream, &i); + x |= ((uint64_t)i) << 40; + if (err == UNZ_OK) + err = unzReadUInt8(pzlib_filefunc_def, filestream, &i); + x |= ((uint64_t)i) << 48; + if (err == UNZ_OK) + err = unzReadUInt8(pzlib_filefunc_def, filestream, &i); + x |= ((uint64_t)i) << 56; + + if (err == UNZ_OK) + *value = x; + else + *value = 0; + return err; +} + +/* Locate the Central directory of a zip file (at the end, just before the global comment) */ +static int unzSearchCentralDir(const zlib_filefunc64_32_def *pzlib_filefunc_def, uint64_t *pos_found, voidpf filestream) +{ + uint8_t buf[BUFREADCOMMENT + 4]; + uint64_t file_size = 0; + uint64_t back_read = 4; + uint64_t max_back = UINT16_MAX; /* maximum size of global comment */ + uint32_t read_size = 0; + uint64_t read_pos = 0; + uint32_t i = 0; + *pos_found = 0; + + if (ZSEEK64(*pzlib_filefunc_def, filestream, 0, ZLIB_FILEFUNC_SEEK_END) != 0) + return UNZ_ERRNO; + + 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) : (uint32_t)(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 = 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; + return UNZ_OK; + } + } + + return UNZ_ERRNO; +} + +/* Locate the Central directory 64 of a zipfile (at the end, just before the global comment) */ +static int unzSearchCentralDir64(const zlib_filefunc64_32_def *pzlib_filefunc_def, uint64_t *offset, voidpf filestream, + const uint64_t endcentraloffset) +{ + uint32_t value32 = 0; + *offset = 0; + + /* Zip64 end of central directory locator */ + if (ZSEEK64(*pzlib_filefunc_def, filestream, endcentraloffset - SIZECENTRALHEADERLOCATOR, ZLIB_FILEFUNC_SEEK_SET) != 0) + return UNZ_ERRNO; + + /* Read locator signature */ + if (unzReadUInt32(pzlib_filefunc_def, filestream, &value32) != UNZ_OK) + return UNZ_ERRNO; + if (value32 != ZIP64ENDLOCHEADERMAGIC) + return UNZ_ERRNO; + /* Number of the disk with the start of the zip64 end of central directory */ + if (unzReadUInt32(pzlib_filefunc_def, filestream, &value32) != UNZ_OK) + return UNZ_ERRNO; + /* Relative offset of the zip64 end of central directory record */ + if (unzReadUInt64(pzlib_filefunc_def, filestream, offset) != UNZ_OK) + return UNZ_ERRNO; + /* Total number of disks */ + if (unzReadUInt32(pzlib_filefunc_def, filestream, &value32) != UNZ_OK) + return UNZ_ERRNO; + /* Goto end of central directory record */ + if (ZSEEK64(*pzlib_filefunc_def, filestream, *offset, ZLIB_FILEFUNC_SEEK_SET) != 0) + return UNZ_ERRNO; + /* The signature */ + if (unzReadUInt32(pzlib_filefunc_def, filestream, &value32) != UNZ_OK) + return UNZ_ERRNO; + if (value32 != ZIP64ENDHEADERMAGIC) + return UNZ_ERRNO; + + return UNZ_OK; +} + +static unzFile unzOpenInternal(const void *path, zlib_filefunc64_32_def *pzlib_filefunc64_32_def) +{ + unz64_internal us = {{{ 0 }}}; // (prevent warning from GCC bug 53119) + unz64_internal *s = NULL; + uint64_t central_pos = 0; + uint64_t central_pos64 = 0; + uint64_t number_entry_CD = 0; + uint16_t value16 = 0; + uint32_t value32 = 0; + uint64_t value64 = 0; + voidpf filestream = NULL; + int err = UNZ_OK; + int err64 = UNZ_OK; + + if (pzlib_filefunc64_32_def == NULL) + fill_fopen64_filefunc(&us.z_filefunc.zfile_func64); + else + { + assert((pzlib_filefunc64_32_def->zopen32_file || pzlib_filefunc64_32_def->zfile_func64.zopen64_file) && + (pzlib_filefunc64_32_def->zopendisk32_file || pzlib_filefunc64_32_def->zfile_func64.zopendisk64_file) && + (pzlib_filefunc64_32_def->ztell32_file || pzlib_filefunc64_32_def->zfile_func64.ztell64_file) && + (pzlib_filefunc64_32_def->zseek32_file || pzlib_filefunc64_32_def->zfile_func64.zseek64_file)); + 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; + + /* Search for end of central directory header */ + err = unzSearchCentralDir(&us.z_filefunc, ¢ral_pos, us.filestream); + if (err == UNZ_OK) + { + if (ZSEEK64(us.z_filefunc, us.filestream, central_pos, ZLIB_FILEFUNC_SEEK_SET) != 0) + err = UNZ_ERRNO; + + /* The signature, already checked */ + if (unzReadUInt32(&us.z_filefunc, us.filestream, &value32) != UNZ_OK) + err = UNZ_ERRNO; + /* Number of this disk */ + if (unzReadUInt16(&us.z_filefunc, us.filestream, &value16) != UNZ_OK) + err = UNZ_ERRNO; + us.number_disk = value16; + /* Number of the disk with the start of the central directory */ + if (unzReadUInt16(&us.z_filefunc, us.filestream, &value16) != UNZ_OK) + err = UNZ_ERRNO; + us.gi.number_disk_with_CD = value16; + /* Total number of entries in the central directory on this disk */ + if (unzReadUInt16(&us.z_filefunc, us.filestream, &value16) != UNZ_OK) + err = UNZ_ERRNO; + us.gi.number_entry = value16; + /* Total number of entries in the central directory */ + if (unzReadUInt16(&us.z_filefunc, us.filestream, &value16) != UNZ_OK) + err = UNZ_ERRNO; + number_entry_CD = value16; + if (number_entry_CD != us.gi.number_entry) + err = UNZ_BADZIPFILE; + /* Size of the central directory */ + if (unzReadUInt32(&us.z_filefunc, us.filestream, &value32) != UNZ_OK) + err = UNZ_ERRNO; + us.size_central_dir = value32; + /* Offset of start of central directory with respect to the starting disk number */ + if (unzReadUInt32(&us.z_filefunc, us.filestream, &value32) != UNZ_OK) + err = UNZ_ERRNO; + us.offset_central_dir = value32; + /* Zipfile comment length */ + if (unzReadUInt16(&us.z_filefunc, us.filestream, &us.gi.size_comment) != UNZ_OK) + err = UNZ_ERRNO; + + if (err == UNZ_OK) + { + /* Search for Zip64 end of central directory header */ + err64 = unzSearchCentralDir64(&us.z_filefunc, ¢ral_pos64, us.filestream, central_pos); + if (err64 == UNZ_OK) + { + central_pos = central_pos64; + us.is_zip64 = 1; + + if (ZSEEK64(us.z_filefunc, us.filestream, central_pos, ZLIB_FILEFUNC_SEEK_SET) != 0) + err = UNZ_ERRNO; + + /* the signature, already checked */ + if (unzReadUInt32(&us.z_filefunc, us.filestream, &value32) != UNZ_OK) + err = UNZ_ERRNO; + /* size of zip64 end of central directory record */ + if (unzReadUInt64(&us.z_filefunc, us.filestream, &value64) != UNZ_OK) + err = UNZ_ERRNO; + /* version made by */ + if (unzReadUInt16(&us.z_filefunc, us.filestream, &value16) != UNZ_OK) + err = UNZ_ERRNO; + /* version needed to extract */ + if (unzReadUInt16(&us.z_filefunc, us.filestream, &value16) != UNZ_OK) + err = UNZ_ERRNO; + /* number of this disk */ + if (unzReadUInt32(&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 (unzReadUInt32(&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 (unzReadUInt64(&us.z_filefunc, us.filestream, &us.gi.number_entry) != UNZ_OK) + err = UNZ_ERRNO; + /* total number of entries in the central directory */ + if (unzReadUInt64(&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 (unzReadUInt64(&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 (unzReadUInt64(&us.z_filefunc, us.filestream, &us.offset_central_dir) != UNZ_OK) + err = UNZ_ERRNO; + } + else if ((us.size_central_dir == UINT16_MAX) || (us.offset_central_dir == UINT32_MAX)) + 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; + + s = (unz64_internal*)ALLOC(sizeof(unz64_internal)); + if (s != NULL) + { + *s = us; + if (err64 != UNZ_OK) + // workaround incorrect count #184 + s->gi.number_entry = unzCountEntries(s); + + 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 = {{ 0 }}; + 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 = {{ 0 }}; + zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def; + 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_internal *s; + if (file == NULL) + return UNZ_PARAMERROR; + s = (unz64_internal*)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 */ +static int unzGoToNextDisk(unzFile file) +{ + unz64_internal *s; + uint32_t number_disk_next = 0; + + s = (unz64_internal*)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, 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_internal *s = NULL; + if (file == NULL) + return UNZ_PARAMERROR; + s = (unz64_internal*)file; + + pglobal_info32->number_entry = (uint32_t)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_internal *s = NULL; + if (file == NULL) + return UNZ_PARAMERROR; + s = (unz64_internal*)file; + *pglobal_info = s->gi; + return UNZ_OK; +} + +extern int ZEXPORT unzGetGlobalComment(unzFile file, char *comment, uint16_t comment_size) +{ + unz64_internal *s = NULL; + uint16_t bytes_to_read = comment_size; + if (file == NULL) + return (int)UNZ_PARAMERROR; + s = (unz64_internal*)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; +} + +static int unzGetCurrentFileInfoField(unzFile file, uint32_t *seek, void *field, uint16_t field_size, uint16_t size_file_field, int null_terminated_field) +{ + unz64_internal *s = NULL; + uint32_t bytes_to_read = 0; + int err = UNZ_OK; + + if (file == NULL) + return (int)UNZ_PARAMERROR; + s = (unz64_internal*)file; + + /* Read field */ + if (field != NULL) + { + if (size_file_field < field_size) + { + if (null_terminated_field) + *((char *)field+size_file_field) = 0; + + bytes_to_read = size_file_field; + } + else + bytes_to_read = field_size; + + if (*seek != 0) + { + if (ZSEEK64(s->z_filefunc, s->filestream_with_CD, *seek, ZLIB_FILEFUNC_SEEK_CUR) == 0) + *seek = 0; + else + err = UNZ_ERRNO; + } + + if ((size_file_field > 0) && (field_size > 0)) + { + if (ZREAD64(s->z_filefunc, s->filestream_with_CD, field, bytes_to_read) != bytes_to_read) + err = UNZ_ERRNO; + } + *seek += size_file_field - bytes_to_read; + } + else + { + *seek += size_file_field; + } + + return err; +} + +/* Get info about the current file in the zipfile, with internal only info */ +static int unzGetCurrentFileInfoInternal(unzFile file, unz_file_info64 *pfile_info, + unz_file_info64_internal *pfile_info_internal, char *filename, uint16_t filename_size, void *extrafield, + uint16_t extrafield_size, char *comment, uint16_t comment_size) +{ + unz64_internal *s = NULL; + unz_file_info64 file_info; + unz_file_info64_internal file_info_internal; + uint32_t magic = 0; + uint64_t current_pos = 0; + uint32_t seek = 0; + uint32_t extra_pos = 0; + uint16_t extra_header_id = 0; + uint16_t extra_data_size = 0; + uint16_t value16 = 0; + uint32_t value32 = 0; + uint64_t value64 = 0; + int err = UNZ_OK; + + if (file == NULL) + return UNZ_PARAMERROR; + s = (unz64_internal*)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 (unzReadUInt32(&s->z_filefunc, s->filestream_with_CD, &magic) != UNZ_OK) + err = UNZ_ERRNO; + else if (magic != CENTRALHEADERMAGIC) + err = UNZ_BADZIPFILE; + } + + /* Read central directory header */ + if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &file_info.version) != UNZ_OK) + err = UNZ_ERRNO; + if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &file_info.version_needed) != UNZ_OK) + err = UNZ_ERRNO; + if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &file_info.flag) != UNZ_OK) + err = UNZ_ERRNO; + if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &file_info.compression_method) != UNZ_OK) + err = UNZ_ERRNO; + if (unzReadUInt32(&s->z_filefunc, s->filestream_with_CD, &file_info.dos_date) != UNZ_OK) + err = UNZ_ERRNO; + if (unzReadUInt32(&s->z_filefunc, s->filestream_with_CD, &file_info.crc) != UNZ_OK) + err = UNZ_ERRNO; + if (unzReadUInt32(&s->z_filefunc, s->filestream_with_CD, &value32) != UNZ_OK) + err = UNZ_ERRNO; + file_info.compressed_size = value32; + if (unzReadUInt32(&s->z_filefunc, s->filestream_with_CD, &value32) != UNZ_OK) + err = UNZ_ERRNO; + file_info.uncompressed_size = value32; + if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &file_info.size_filename) != UNZ_OK) + err = UNZ_ERRNO; + if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &file_info.size_file_extra) != UNZ_OK) + err = UNZ_ERRNO; + if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &file_info.size_file_comment) != UNZ_OK) + err = UNZ_ERRNO; + if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &value16) != UNZ_OK) + err = UNZ_ERRNO; + file_info.disk_num_start = value16; + if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &file_info.internal_fa) != UNZ_OK) + err = UNZ_ERRNO; + if (unzReadUInt32(&s->z_filefunc, s->filestream_with_CD, &file_info.external_fa) != UNZ_OK) + err = UNZ_ERRNO; + /* Relative offset of local header */ + if (unzReadUInt32(&s->z_filefunc, s->filestream_with_CD, &value32) != UNZ_OK) + err = UNZ_ERRNO; + + file_info.size_file_extra_internal = 0; + file_info.disk_offset = value32; + file_info_internal.offset_curfile = value32; +#ifdef HAVE_AES + file_info_internal.aes_compression_method = 0; + file_info_internal.aes_encryption_mode = 0; + file_info_internal.aes_version = 0; +#endif + + if (err == UNZ_OK) + err = unzGetCurrentFileInfoField(file, &seek, filename, filename_size, file_info.size_filename, 1); + + /* Read extrafield */ + if (err == UNZ_OK) + err = unzGetCurrentFileInfoField(file, &seek, extrafield, extrafield_size, file_info.size_file_extra, 0); + + if ((err == UNZ_OK) && (file_info.size_file_extra != 0)) + { + if (seek != 0) + { + if (ZSEEK64(s->z_filefunc, s->filestream_with_CD, seek, ZLIB_FILEFUNC_SEEK_CUR) == 0) + seek = 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) && (extra_pos < file_info.size_file_extra)) + { + if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &extra_header_id) != UNZ_OK) + err = UNZ_ERRNO; + if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &extra_data_size) != UNZ_OK) + err = UNZ_ERRNO; + + /* ZIP64 extra fields */ + if (extra_header_id == 0x0001) + { + /* Subtract size of ZIP64 field, since ZIP64 is handled internally */ + file_info.size_file_extra_internal += 2 + 2 + extra_data_size; + + if (file_info.uncompressed_size == UINT32_MAX) + { + if (unzReadUInt64(&s->z_filefunc, s->filestream_with_CD, &file_info.uncompressed_size) != UNZ_OK) + err = UNZ_ERRNO; + } + if (file_info.compressed_size == UINT32_MAX) + { + if (unzReadUInt64(&s->z_filefunc, s->filestream_with_CD, &file_info.compressed_size) != UNZ_OK) + err = UNZ_ERRNO; + } + if (file_info_internal.offset_curfile == UINT32_MAX) + { + /* Relative Header offset */ + if (unzReadUInt64(&s->z_filefunc, s->filestream_with_CD, &value64) != UNZ_OK) + err = UNZ_ERRNO; + file_info_internal.offset_curfile = value64; + file_info.disk_offset = value64; + } + if (file_info.disk_num_start == UINT32_MAX) + { + /* Disk Start Number */ + if (unzReadUInt32(&s->z_filefunc, s->filestream_with_CD, &file_info.disk_num_start) != UNZ_OK) + err = UNZ_ERRNO; + } + } +#ifdef HAVE_AES + /* AES header */ + else if (extra_header_id == 0x9901) + { + uint8_t value8 = 0; + + /* Subtract size of AES field, since AES is handled internally */ + file_info.size_file_extra_internal += 2 + 2 + extra_data_size; + + /* Verify version info */ + if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &value16) != UNZ_OK) + err = UNZ_ERRNO; + /* Support AE-1 and AE-2 */ + if (value16 != 1 && value16 != 2) + err = UNZ_ERRNO; + file_info_internal.aes_version = value16; + if (unzReadUInt8(&s->z_filefunc, s->filestream_with_CD, &value8) != UNZ_OK) + err = UNZ_ERRNO; + if ((char)value8 != 'A') + err = UNZ_ERRNO; + if (unzReadUInt8(&s->z_filefunc, s->filestream_with_CD, &value8) != UNZ_OK) + err = UNZ_ERRNO; + if ((char)value8 != 'E') + err = UNZ_ERRNO; + /* Get AES encryption strength and actual compression method */ + if (unzReadUInt8(&s->z_filefunc, s->filestream_with_CD, &value8) != UNZ_OK) + err = UNZ_ERRNO; + file_info_internal.aes_encryption_mode = value8; + if (unzReadUInt16(&s->z_filefunc, s->filestream_with_CD, &value16) != UNZ_OK) + err = UNZ_ERRNO; + file_info_internal.aes_compression_method = value16; + } +#endif + else + { + if (ZSEEK64(s->z_filefunc, s->filestream_with_CD, extra_data_size, ZLIB_FILEFUNC_SEEK_CUR) != 0) + err = UNZ_ERRNO; + } + + extra_pos += 2 + 2 + extra_data_size; + } + } + + 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) + err = unzGetCurrentFileInfoField(file, &seek, comment, comment_size, file_info.size_file_comment, 1); + + 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, + uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size) +{ + unz_file_info64 file_info64; + int err = UNZ_OK; + + err = unzGetCurrentFileInfoInternal(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->dos_date = file_info64.dos_date; + 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 = (uint16_t)file_info64.disk_num_start; + pfile_info->internal_fa = file_info64.internal_fa; + pfile_info->external_fa = file_info64.external_fa; + + pfile_info->compressed_size = (uint32_t)file_info64.compressed_size; + pfile_info->uncompressed_size = (uint32_t)file_info64.uncompressed_size; + } + return err; +} + +extern int ZEXPORT unzGetCurrentFileInfo64(unzFile file, unz_file_info64 * pfile_info, char *filename, + uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size) +{ + return unzGetCurrentFileInfoInternal(file, pfile_info, NULL, filename, filename_size, + extrafield, extrafield_size, comment, comment_size); +} + +/* Read the local header of the current zipfile. Check the coherency of the local header and info in the + end of central directory about this file store in *piSizeVar the size of extra info in local header + (filename and size of extra field data) */ +static int unzCheckCurrentFileCoherencyHeader(unz64_internal *s, uint32_t *psize_variable, uint64_t *poffset_local_extrafield, + uint16_t *psize_local_extrafield) +{ + uint32_t magic = 0; + uint16_t value16 = 0; + uint32_t value32 = 0; + uint32_t flags = 0; + uint16_t size_filename = 0; + uint16_t size_extra_field = 0; + uint16_t compression_method = 0; + int err = UNZ_OK; + + if (psize_variable == NULL) + return UNZ_PARAMERROR; + *psize_variable = 0; + if (poffset_local_extrafield == NULL) + return UNZ_PARAMERROR; + *poffset_local_extrafield = 0; + if (psize_local_extrafield == NULL) + return UNZ_PARAMERROR; + *psize_local_extrafield = 0; + + err = unzGoToNextDisk((unzFile)s); + if (err != UNZ_OK) + return err; + + if (ZSEEK64(s->z_filefunc, s->filestream, s->cur_file_info_internal.offset_curfile + + s->cur_file_info_internal.byte_before_the_zipfile, ZLIB_FILEFUNC_SEEK_SET) != 0) + return UNZ_ERRNO; + + if (err == UNZ_OK) + { + if (unzReadUInt32(&s->z_filefunc, s->filestream, &magic) != UNZ_OK) + err = UNZ_ERRNO; + else if (magic != LOCALHEADERMAGIC) + err = UNZ_BADZIPFILE; + } + + if (unzReadUInt16(&s->z_filefunc, s->filestream, &value16) != UNZ_OK) + err = UNZ_ERRNO; + if (unzReadUInt16(&s->z_filefunc, s->filestream, &value16) != UNZ_OK) + err = UNZ_ERRNO; + flags = value16; + if (unzReadUInt16(&s->z_filefunc, s->filestream, &value16) != UNZ_OK) + err = UNZ_ERRNO; + else if ((err == UNZ_OK) && (value16 != s->cur_file_info.compression_method)) + err = UNZ_BADZIPFILE; + + compression_method = s->cur_file_info.compression_method; +#ifdef HAVE_AES + if (compression_method == AES_METHOD) + compression_method = s->cur_file_info_internal.aes_compression_method; +#endif + + if ((err == UNZ_OK) && (compression_method != 0) && (compression_method != Z_DEFLATED)) + { +#ifdef HAVE_BZIP2 + if (compression_method != Z_BZIP2ED) +#endif + err = UNZ_BADZIPFILE; + } + + if (unzReadUInt32(&s->z_filefunc, s->filestream, &value32) != UNZ_OK) /* date/time */ + err = UNZ_ERRNO; + if (unzReadUInt32(&s->z_filefunc, s->filestream, &value32) != UNZ_OK) /* crc */ + err = UNZ_ERRNO; + else if ((err == UNZ_OK) && (value32 != s->cur_file_info.crc) && ((flags & 8) == 0)) + err = UNZ_BADZIPFILE; + if (unzReadUInt32(&s->z_filefunc, s->filestream, &value32) != UNZ_OK) /* size compr */ + err = UNZ_ERRNO; + else if ((value32 != UINT32_MAX) && (err == UNZ_OK) && (value32 != s->cur_file_info.compressed_size) && ((flags & 8) == 0)) + err = UNZ_BADZIPFILE; + if (unzReadUInt32(&s->z_filefunc, s->filestream, &value32) != UNZ_OK) /* size uncompr */ + err = UNZ_ERRNO; + else if ((value32 != UINT32_MAX) && (err == UNZ_OK) && (value32 != s->cur_file_info.uncompressed_size) && ((flags & 8) == 0)) + err = UNZ_BADZIPFILE; + if (unzReadUInt16(&s->z_filefunc, s->filestream, &size_filename) != UNZ_OK) + err = UNZ_ERRNO; + + *psize_variable += size_filename; + + if (unzReadUInt16(&s->z_filefunc, s->filestream, &size_extra_field) != UNZ_OK) + err = UNZ_ERRNO; + + *poffset_local_extrafield = s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER + size_filename; + *psize_local_extrafield = size_extra_field; + *psize_variable += size_extra_field; + + return err; +} + +extern uint64_t ZEXPORT unzCountEntries(const unzFile file) +{ + if (file == NULL) + return 0; + + unz64_internal s = *(unz64_internal*)file; + + s.pos_in_central_dir = s.offset_central_dir; + s.num_file = 0; + while (UNZ_OK == unzGetCurrentFileInfoInternal(&s, + &s.cur_file_info, + &s.cur_file_info_internal, + NULL, 0, NULL, 0, NULL, 0)) + { + s.pos_in_central_dir += SIZECENTRALDIRITEM + + s.cur_file_info.size_filename + + s.cur_file_info.size_file_extra + + s.cur_file_info.size_file_comment; + s.num_file += 1; + } + return s.num_file; +} + +/* + Open for reading data the current file in the zipfile. + If there is no error and the file is opened, the return value is UNZ_OK. +*/ +extern int ZEXPORT unzOpenCurrentFile3(unzFile file, int *method, int *level, int raw, const char *password) +{ + unz64_internal *s = NULL; + file_in_zip64_read_info_s *pfile_in_zip_read_info = NULL; + uint16_t compression_method = 0; + uint64_t offset_local_extrafield = 0; + uint16_t size_local_extrafield = 0; + uint32_t size_variable = 0; + int err = UNZ_OK; +#ifndef NOUNCRYPT + char source[12]; +#else + if (password != NULL) + return UNZ_PARAMERROR; +#endif + if (file == NULL) + return UNZ_PARAMERROR; + s = (unz64_internal*)file; + if (!s->current_file_ok) + return UNZ_PARAMERROR; + + if (s->pfile_in_zip_read != NULL) + unzCloseCurrentFile(file); + + if (unzCheckCurrentFileCoherencyHeader(s, &size_variable, &offset_local_extrafield, &size_local_extrafield) != UNZ_OK) + return UNZ_BADZIPFILE; + + compression_method = s->cur_file_info.compression_method; +#ifdef HAVE_AES + if (compression_method == AES_METHOD) + { + compression_method = s->cur_file_info_internal.aes_compression_method; + if (password == NULL) + { + return UNZ_PARAMERROR; + } + } +#endif + + if (method != NULL) + *method = compression_method; + + if (level != NULL) + { + *level = 6; + switch (s->cur_file_info.flag & 0x06) + { + case 6 : *level = 1; break; + case 4 : *level = 2; break; + case 2 : *level = 9; break; + } + } + + if ((compression_method != 0) && (compression_method != Z_DEFLATED)) + { +#ifdef HAVE_BZIP2 + if (compression_method != Z_BZIP2ED) +#endif + { + return UNZ_BADZIPFILE; + } + } + + pfile_in_zip_read_info = (file_in_zip64_read_info_s*)ALLOC(sizeof(file_in_zip64_read_info_s)); + if (pfile_in_zip_read_info == NULL) + return UNZ_INTERNALERROR; + + pfile_in_zip_read_info->read_buffer = (uint8_t*)ALLOC(UNZ_BUFSIZE); + if (pfile_in_zip_read_info->read_buffer == NULL) + { + TRYFREE(pfile_in_zip_read_info); + return UNZ_INTERNALERROR; + } + + pfile_in_zip_read_info->stream_initialised = 0; + + pfile_in_zip_read_info->filestream = s->filestream; + pfile_in_zip_read_info->z_filefunc = s->z_filefunc; + + pfile_in_zip_read_info->raw = raw; + pfile_in_zip_read_info->crc32 = 0; + pfile_in_zip_read_info->crc32_expected = s->cur_file_info.crc; + pfile_in_zip_read_info->total_out_64 = 0; + pfile_in_zip_read_info->compression_method = compression_method; + + pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield; + pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield; + pfile_in_zip_read_info->pos_local_extrafield = 0; + + pfile_in_zip_read_info->rest_read_compressed = s->cur_file_info.compressed_size; + pfile_in_zip_read_info->rest_read_uncompressed = s->cur_file_info.uncompressed_size; + pfile_in_zip_read_info->byte_before_the_zipfile = 0; + + if (s->number_disk == s->gi.number_disk_with_CD) + pfile_in_zip_read_info->byte_before_the_zipfile = s->byte_before_the_zipfile; + + pfile_in_zip_read_info->pos_in_zipfile = s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER + size_variable; + + pfile_in_zip_read_info->stream.zalloc = (alloc_func)0; + pfile_in_zip_read_info->stream.zfree = (free_func)0; + pfile_in_zip_read_info->stream.opaque = (voidpf)s; + pfile_in_zip_read_info->stream.total_out = 0; + pfile_in_zip_read_info->stream.total_in = 0; + pfile_in_zip_read_info->stream.next_in = NULL; + pfile_in_zip_read_info->stream.avail_in = 0; + + if (!raw) + { + if (compression_method == Z_BZIP2ED) + { +#ifdef HAVE_BZIP2 + pfile_in_zip_read_info->bstream.bzalloc = (void *(*) (void *, int, int))0; + pfile_in_zip_read_info->bstream.bzfree = (free_func)0; + pfile_in_zip_read_info->bstream.opaque = (voidpf)0; + pfile_in_zip_read_info->bstream.state = (voidpf)0; + + err = BZ2_bzDecompressInit(&pfile_in_zip_read_info->bstream, 0, 0); + if (err == Z_OK) + { + pfile_in_zip_read_info->stream_initialised = Z_BZIP2ED; + } + else + { + TRYFREE(pfile_in_zip_read_info); + return err; + } +#else + pfile_in_zip_read_info->raw = 1; +#endif + } + else if (compression_method == Z_DEFLATED) + { +#ifdef HAVE_APPLE_COMPRESSION + err = compression_stream_init(&pfile_in_zip_read_info->astream, COMPRESSION_STREAM_DECODE, COMPRESSION_ZLIB); + if (err == COMPRESSION_STATUS_ERROR) + err = UNZ_INTERNALERROR; + else + err = Z_OK; +#else + err = inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS); +#endif + if (err == Z_OK) + { + pfile_in_zip_read_info->stream_initialised = Z_DEFLATED; + } + else + { + TRYFREE(pfile_in_zip_read_info); + return err; + } + /* windowBits is passed < 0 to tell that there is no zlib header. + * Note that in this case inflate *requires* an extra "dummy" byte + * after the compressed stream in order to complete decompression and + * return Z_STREAM_END. + * In unzip, i don't wait absolutely Z_STREAM_END because I known the + * size of both compressed and uncompressed data + */ + } + } + + s->pfile_in_zip_read = pfile_in_zip_read_info; + +#ifndef NOUNCRYPT + s->pcrc_32_tab = NULL; + + if ((password != NULL) && ((s->cur_file_info.flag & 1) != 0)) + { + if (ZSEEK64(s->z_filefunc, s->filestream, + s->pfile_in_zip_read->pos_in_zipfile + s->pfile_in_zip_read->byte_before_the_zipfile, + ZLIB_FILEFUNC_SEEK_SET) != 0) + return UNZ_INTERNALERROR; +#ifdef HAVE_AES + if (s->cur_file_info.compression_method == AES_METHOD) + { + unsigned char passverify_archive[AES_PWVERIFYSIZE]; + unsigned char passverify_password[AES_PWVERIFYSIZE]; + unsigned char salt_value[AES_MAXSALTLENGTH]; + uint32_t salt_length = 0; + + if ((s->cur_file_info_internal.aes_encryption_mode < 1) || + (s->cur_file_info_internal.aes_encryption_mode > 3)) + return UNZ_INTERNALERROR; + + salt_length = SALT_LENGTH(s->cur_file_info_internal.aes_encryption_mode); + + if (ZREAD64(s->z_filefunc, s->filestream, salt_value, salt_length) != salt_length) + return UNZ_INTERNALERROR; + if (ZREAD64(s->z_filefunc, s->filestream, passverify_archive, AES_PWVERIFYSIZE) != AES_PWVERIFYSIZE) + return UNZ_INTERNALERROR; + + fcrypt_init(s->cur_file_info_internal.aes_encryption_mode, (uint8_t *)password, + (uint32_t)strlen(password), salt_value, passverify_password, &s->pfile_in_zip_read->aes_ctx); + + if (memcmp(passverify_archive, passverify_password, AES_PWVERIFYSIZE) != 0) + return UNZ_BADPASSWORD; + + s->pfile_in_zip_read->rest_read_compressed -= salt_length + AES_PWVERIFYSIZE; + s->pfile_in_zip_read->rest_read_compressed -= AES_AUTHCODESIZE; + + s->pfile_in_zip_read->pos_in_zipfile += salt_length + AES_PWVERIFYSIZE; + } + else +#endif + { + int i; + s->pcrc_32_tab = (const z_crc_t*)get_crc_table(); + init_keys(password, s->keys, s->pcrc_32_tab); + + if (ZREAD64(s->z_filefunc, s->filestream, source, 12) < 12) + return UNZ_INTERNALERROR; + + for (i = 0; i < 12; i++) + zdecode(s->keys, s->pcrc_32_tab, source[i]); + uint8_t expected = (s->cur_file_info.flag & (1 << 3)) ? + s->cur_file_info.dos_date >> 8 : + s->cur_file_info.crc >> 24; + uint8_t actual = (uint8_t)source[11]; + if (expected != actual) { + return UNZ_BADPASSWORD; + } + + s->pfile_in_zip_read->rest_read_compressed -= 12; + s->pfile_in_zip_read->pos_in_zipfile += 12; + } + } +#endif + + return UNZ_OK; +} + +extern int ZEXPORT unzOpenCurrentFile(unzFile file) +{ + return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL); +} + +extern int ZEXPORT unzOpenCurrentFilePassword(unzFile file, const char *password) +{ + return unzOpenCurrentFile3(file, NULL, NULL, 0, password); +} + +extern int ZEXPORT unzOpenCurrentFile2(unzFile file, int *method, int *level, int raw) +{ + return unzOpenCurrentFile3(file, method, level, raw, NULL); +} + +/* Read bytes from the current file. + buf contain buffer where data must be copied + len the size of buf. + + return the number of byte copied if some bytes are copied + return 0 if the end of file was reached + return <0 with error code if there is an error (UNZ_ERRNO for IO error, or zLib error for uncompress error) */ +extern int ZEXPORT unzReadCurrentFile(unzFile file, voidp buf, uint32_t len) +{ + unz64_internal *s = NULL; + uint32_t read = 0; + int err = UNZ_OK; + + if (file == NULL) + return UNZ_PARAMERROR; + s = (unz64_internal*)file; + + if (s->pfile_in_zip_read == NULL) + return UNZ_PARAMERROR; + if (s->pfile_in_zip_read->read_buffer == NULL) + return UNZ_END_OF_LIST_OF_FILE; + if (len == 0) + return 0; + // avail_out is uInt, so uint32_t len might allow requesting a larger buffer than zlib can support + if (len > UINT_MAX) + return UNZ_PARAMERROR; + + s->pfile_in_zip_read->stream.next_out = (uint8_t*)buf; + s->pfile_in_zip_read->stream.avail_out = (uInt)len; + + if ((s->pfile_in_zip_read->compression_method == 0) || (s->pfile_in_zip_read->raw)) + { + if (len > s->pfile_in_zip_read->rest_read_compressed + s->pfile_in_zip_read->stream.avail_in) + s->pfile_in_zip_read->stream.avail_out = (uInt)s->pfile_in_zip_read->rest_read_compressed + + s->pfile_in_zip_read->stream.avail_in; + } + + do + { + if (s->pfile_in_zip_read->stream.avail_in == 0) + { + uint32_t bytes_to_read = UNZ_BUFSIZE; + uint32_t bytes_not_read = 0; + uint32_t bytes_read = 0; + uint32_t total_bytes_read = 0; + + if (s->pfile_in_zip_read->stream.next_in != NULL) + bytes_not_read = (uint32_t)(s->pfile_in_zip_read->read_buffer + UNZ_BUFSIZE - + s->pfile_in_zip_read->stream.next_in); + bytes_to_read -= bytes_not_read; + if (bytes_not_read > 0) + memmove(s->pfile_in_zip_read->read_buffer, s->pfile_in_zip_read->stream.next_in, bytes_not_read); + if (s->pfile_in_zip_read->rest_read_compressed < bytes_to_read) + bytes_to_read = (uint32_t)s->pfile_in_zip_read->rest_read_compressed; + + while (total_bytes_read != bytes_to_read) + { + if (ZSEEK64(s->pfile_in_zip_read->z_filefunc, s->pfile_in_zip_read->filestream, + s->pfile_in_zip_read->pos_in_zipfile + s->pfile_in_zip_read->byte_before_the_zipfile, + ZLIB_FILEFUNC_SEEK_SET) != 0) + return UNZ_ERRNO; + + bytes_read = ZREAD64(s->pfile_in_zip_read->z_filefunc, s->pfile_in_zip_read->filestream, + s->pfile_in_zip_read->read_buffer + bytes_not_read + total_bytes_read, + bytes_to_read - total_bytes_read); + + total_bytes_read += bytes_read; + s->pfile_in_zip_read->pos_in_zipfile += bytes_read; + + if (bytes_read == 0) + { + if (ZERROR64(s->pfile_in_zip_read->z_filefunc, s->pfile_in_zip_read->filestream)) + return UNZ_ERRNO; + + err = unzGoToNextDisk(file); + if (err != UNZ_OK) + return err; + + s->pfile_in_zip_read->pos_in_zipfile = 0; + s->pfile_in_zip_read->filestream = s->filestream; + } + } + +#ifndef NOUNCRYPT + if ((s->cur_file_info.flag & 1) != 0) + { +#ifdef HAVE_AES + if (s->cur_file_info.compression_method == AES_METHOD) + { + fcrypt_decrypt(s->pfile_in_zip_read->read_buffer, bytes_to_read, &s->pfile_in_zip_read->aes_ctx); + } + else +#endif + if (s->pcrc_32_tab != NULL) + { + uint32_t i = 0; + + for (i = 0; i < total_bytes_read; i++) + s->pfile_in_zip_read->read_buffer[i] = + zdecode(s->keys, s->pcrc_32_tab, s->pfile_in_zip_read->read_buffer[i]); + } + } +#endif + + s->pfile_in_zip_read->rest_read_compressed -= total_bytes_read; + s->pfile_in_zip_read->stream.next_in = (uint8_t*)s->pfile_in_zip_read->read_buffer; + s->pfile_in_zip_read->stream.avail_in = (uInt)(bytes_not_read + total_bytes_read); + } + + if ((s->pfile_in_zip_read->compression_method == 0) || (s->pfile_in_zip_read->raw)) + { + uint32_t i = 0; + uint32_t copy = 0; + + if ((s->pfile_in_zip_read->stream.avail_in == 0) && + (s->pfile_in_zip_read->rest_read_compressed == 0)) + return (read == 0) ? UNZ_EOF : read; + + if (s->pfile_in_zip_read->stream.avail_out < s->pfile_in_zip_read->stream.avail_in) + copy = s->pfile_in_zip_read->stream.avail_out; + else + copy = s->pfile_in_zip_read->stream.avail_in; + + for (i = 0; i < copy; i++) + *(s->pfile_in_zip_read->stream.next_out + i) = + *(s->pfile_in_zip_read->stream.next_in + i); + + s->pfile_in_zip_read->total_out_64 = s->pfile_in_zip_read->total_out_64 + copy; + s->pfile_in_zip_read->rest_read_uncompressed -= copy; + s->pfile_in_zip_read->crc32 = (uint32_t)crc32(s->pfile_in_zip_read->crc32, + s->pfile_in_zip_read->stream.next_out, copy); + + s->pfile_in_zip_read->stream.avail_in -= copy; + s->pfile_in_zip_read->stream.avail_out -= copy; + s->pfile_in_zip_read->stream.next_out += copy; + s->pfile_in_zip_read->stream.next_in += copy; + s->pfile_in_zip_read->stream.total_out += copy; + + read += copy; + } + else if (s->pfile_in_zip_read->compression_method == Z_BZIP2ED) + { +#ifdef HAVE_BZIP2 + uint64_t total_out_before = 0; + uint64_t total_out_after = 0; + uint64_t out_bytes = 0; + const uint8_t *buf_before = NULL; + + s->pfile_in_zip_read->bstream.next_in = (char*)s->pfile_in_zip_read->stream.next_in; + s->pfile_in_zip_read->bstream.avail_in = s->pfile_in_zip_read->stream.avail_in; + s->pfile_in_zip_read->bstream.total_in_lo32 = (uint32_t)s->pfile_in_zip_read->stream.total_in; + s->pfile_in_zip_read->bstream.total_in_hi32 = s->pfile_in_zip_read->stream.total_in >> 32; + + s->pfile_in_zip_read->bstream.next_out = (char*)s->pfile_in_zip_read->stream.next_out; + s->pfile_in_zip_read->bstream.avail_out = s->pfile_in_zip_read->stream.avail_out; + s->pfile_in_zip_read->bstream.total_out_lo32 = (uint32_t)s->pfile_in_zip_read->stream.total_out; + s->pfile_in_zip_read->bstream.total_out_hi32 = s->pfile_in_zip_read->stream.total_out >> 32; + + total_out_before = s->pfile_in_zip_read->bstream.total_out_lo32 + + (((uint32_t)s->pfile_in_zip_read->bstream.total_out_hi32) << 32); + buf_before = (const uint8_t*)s->pfile_in_zip_read->bstream.next_out; + + err = BZ2_bzDecompress(&s->pfile_in_zip_read->bstream); + + total_out_after = s->pfile_in_zip_read->bstream.total_out_lo32 + + (((uint32_t)s->pfile_in_zip_read->bstream.total_out_hi32) << 32); + + out_bytes = total_out_after - total_out_before; + + s->pfile_in_zip_read->total_out_64 = s->pfile_in_zip_read->total_out_64 + out_bytes; + s->pfile_in_zip_read->rest_read_uncompressed -= out_bytes; + s->pfile_in_zip_read->crc32 = crc32(s->pfile_in_zip_read->crc32, buf_before, (uint32_t)out_bytes); + + read += (uint32_t)out_bytes; + + s->pfile_in_zip_read->stream.next_in = (uint8_t*)s->pfile_in_zip_read->bstream.next_in; + s->pfile_in_zip_read->stream.avail_in = s->pfile_in_zip_read->bstream.avail_in; + s->pfile_in_zip_read->stream.total_in = s->pfile_in_zip_read->bstream.total_in_lo32; + s->pfile_in_zip_read->stream.next_out = (uint8_t*)s->pfile_in_zip_read->bstream.next_out; + s->pfile_in_zip_read->stream.avail_out = s->pfile_in_zip_read->bstream.avail_out; + s->pfile_in_zip_read->stream.total_out = s->pfile_in_zip_read->bstream.total_out_lo32; + + if (err == BZ_STREAM_END) + return (read == 0) ? UNZ_EOF : read; + if (err != BZ_OK) + break; +#endif + } +#ifdef HAVE_APPLE_COMPRESSION + else + { + uint64_t total_out_before = 0; + uint64_t total_out_after = 0; + uint64_t out_bytes = 0; + const uint8_t *buf_before = NULL; + + s->pfile_in_zip_read->astream.src_ptr = s->pfile_in_zip_read->stream.next_in; + s->pfile_in_zip_read->astream.src_size = s->pfile_in_zip_read->stream.avail_in; + s->pfile_in_zip_read->astream.dst_ptr = s->pfile_in_zip_read->stream.next_out; + s->pfile_in_zip_read->astream.dst_size = len; + + total_out_before = s->pfile_in_zip_read->stream.total_out; + buf_before = s->pfile_in_zip_read->stream.next_out; + + compression_status status; + compression_stream_flags flags; + + if (s->pfile_in_zip_read->stream.avail_in == 0) + { + flags = COMPRESSION_STREAM_FINALIZE; + } + + status = compression_stream_process(&s->pfile_in_zip_read->astream, flags); + + total_out_after = len - s->pfile_in_zip_read->astream.dst_size; + out_bytes = total_out_after - total_out_before; + + s->pfile_in_zip_read->total_out_64 += out_bytes; + s->pfile_in_zip_read->rest_read_uncompressed -= out_bytes; + s->pfile_in_zip_read->crc32 = + crc32(s->pfile_in_zip_read->crc32, buf_before, (uint32_t)out_bytes); + + read += (uint32_t)out_bytes; + + s->pfile_in_zip_read->stream.next_in = s->pfile_in_zip_read->astream.src_ptr; + s->pfile_in_zip_read->stream.avail_in = s->pfile_in_zip_read->astream.src_size; + s->pfile_in_zip_read->stream.next_out = s->pfile_in_zip_read->astream.dst_ptr; + s->pfile_in_zip_read->stream.avail_out = s->pfile_in_zip_read->astream.dst_size; + + if (status == COMPRESSION_STATUS_END) + return (read == 0) ? UNZ_EOF : read; + if (status == COMPRESSION_STATUS_ERROR) + return Z_DATA_ERROR; + return read; + } +#else + else + { + uint64_t total_out_before = 0; + uint64_t total_out_after = 0; + uint64_t out_bytes = 0; + const uint8_t *buf_before = NULL; + int flush = Z_SYNC_FLUSH; + + total_out_before = s->pfile_in_zip_read->stream.total_out; + buf_before = s->pfile_in_zip_read->stream.next_out; + + /* + if ((pfile_in_zip_read_info->rest_read_uncompressed == + pfile_in_zip_read_info->stream.avail_out) && + (pfile_in_zip_read_info->rest_read_compressed == 0)) + flush = Z_FINISH; + */ + err = inflate(&s->pfile_in_zip_read->stream, flush); + + if ((err >= 0) && (s->pfile_in_zip_read->stream.msg != NULL)) + err = Z_DATA_ERROR; + + total_out_after = s->pfile_in_zip_read->stream.total_out; + out_bytes = total_out_after - total_out_before; + + s->pfile_in_zip_read->total_out_64 += out_bytes; + s->pfile_in_zip_read->rest_read_uncompressed -= out_bytes; + s->pfile_in_zip_read->crc32 = + (uint32_t)crc32(s->pfile_in_zip_read->crc32, buf_before, (uint32_t)out_bytes); + + read += (uint32_t)out_bytes; + + if (err == Z_STREAM_END) + return (read == 0) ? UNZ_EOF : read; + if (err != Z_OK) + break; + } +#endif + } + while (s->pfile_in_zip_read->stream.avail_out > 0); + + if (err == Z_OK) + return read; + return err; +} + +extern int ZEXPORT unzGetLocalExtrafield(unzFile file, voidp buf, uint32_t len) +{ + unz64_internal *s = NULL; + uint64_t size_to_read = 0; + uint32_t read_now = 0; + + if (file == NULL) + return UNZ_PARAMERROR; + s = (unz64_internal*)file; + if (s->pfile_in_zip_read == NULL) + return UNZ_PARAMERROR; + + size_to_read = s->pfile_in_zip_read->size_local_extrafield - s->pfile_in_zip_read->pos_local_extrafield; + + if (buf == NULL) + return (int)size_to_read; + + if (len > size_to_read) + read_now = (uint32_t)size_to_read; + else + read_now = len; + + if (read_now == 0) + return 0; + + if (ZSEEK64(s->pfile_in_zip_read->z_filefunc, s->pfile_in_zip_read->filestream, + s->pfile_in_zip_read->offset_local_extrafield + s->pfile_in_zip_read->pos_local_extrafield, + ZLIB_FILEFUNC_SEEK_SET) != 0) + return UNZ_ERRNO; + + if (ZREAD64(s->pfile_in_zip_read->z_filefunc, s->pfile_in_zip_read->filestream, buf, read_now) != read_now) + return UNZ_ERRNO; + + return (int)read_now; +} + +extern int ZEXPORT unzCloseCurrentFile(unzFile file) +{ + unz64_internal *s = NULL; + file_in_zip64_read_info_s *pfile_in_zip_read_info = NULL; + int err = UNZ_OK; + + if (file == NULL) + return UNZ_PARAMERROR; + s = (unz64_internal*)file; + pfile_in_zip_read_info = s->pfile_in_zip_read; + if (pfile_in_zip_read_info == NULL) + return UNZ_PARAMERROR; + +#ifdef HAVE_AES + if (s->cur_file_info.compression_method == AES_METHOD) + { + unsigned char authcode[AES_AUTHCODESIZE]; + unsigned char rauthcode[AES_AUTHCODESIZE]; + + if (ZREAD64(s->z_filefunc, s->filestream, authcode, AES_AUTHCODESIZE) != AES_AUTHCODESIZE) + return UNZ_ERRNO; + + if (fcrypt_end(rauthcode, &s->pfile_in_zip_read->aes_ctx) != AES_AUTHCODESIZE) + err = UNZ_CRCERROR; + if (memcmp(authcode, rauthcode, AES_AUTHCODESIZE) != 0) + err = UNZ_CRCERROR; + } + /* AES zip version AE-1 will expect a valid crc as well */ + if ((s->cur_file_info.compression_method != AES_METHOD) || + (s->cur_file_info_internal.aes_version == 0x0001)) +#endif + { + if ((pfile_in_zip_read_info->rest_read_uncompressed == 0) && + (!pfile_in_zip_read_info->raw)) + { + if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_expected) + err = UNZ_CRCERROR; + } + } + + TRYFREE(pfile_in_zip_read_info->read_buffer); + pfile_in_zip_read_info->read_buffer = NULL; + if (pfile_in_zip_read_info->stream_initialised == Z_DEFLATED) + { +#ifdef HAVE_APPLE_COMPRESSION + if (compression_stream_destroy) + compression_stream_destroy(&pfile_in_zip_read_info->astream); +#else + inflateEnd(&pfile_in_zip_read_info->stream); +#endif + } +#ifdef HAVE_BZIP2 + else if (pfile_in_zip_read_info->stream_initialised == Z_BZIP2ED) + BZ2_bzDecompressEnd(&pfile_in_zip_read_info->bstream); +#endif + + pfile_in_zip_read_info->stream_initialised = 0; + TRYFREE(pfile_in_zip_read_info); + + s->pfile_in_zip_read = NULL; + + return err; +} + +extern int ZEXPORT unzGoToFirstFile2(unzFile file, unz_file_info64 *pfile_info, char *filename, + uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size) +{ + unz64_internal *s = NULL; + int err = UNZ_OK; + + if (file == NULL) + return UNZ_PARAMERROR; + s = (unz64_internal*)file; + + if (s->gi.number_entry == 0) + return UNZ_END_OF_LIST_OF_FILE; + + s->pos_in_central_dir = s->offset_central_dir; + s->num_file = 0; + + err = unzGetCurrentFileInfoInternal(file, &s->cur_file_info, &s->cur_file_info_internal, + filename, filename_size, extrafield, extrafield_size, comment, comment_size); + + s->current_file_ok = (err == UNZ_OK); + if ((err == UNZ_OK) && (pfile_info != NULL)) + memcpy(pfile_info, &s->cur_file_info, sizeof(unz_file_info64)); + + return err; +} + +extern int ZEXPORT unzGoToFirstFile(unzFile file) +{ + return unzGoToFirstFile2(file, NULL, NULL, 0, NULL, 0, NULL, 0); +} + +extern int ZEXPORT unzGoToNextFile2(unzFile file, unz_file_info64 *pfile_info, char *filename, + uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size) +{ + unz64_internal *s = NULL; + int err = UNZ_OK; + + if (file == NULL) + return UNZ_PARAMERROR; + s = (unz64_internal*)file; + + if (!s->current_file_ok) + return UNZ_END_OF_LIST_OF_FILE; + if (s->gi.number_entry != UINT16_MAX) /* 2^16 files overflow hack */ + { + if (s->num_file+1 == s->gi.number_entry) + return UNZ_END_OF_LIST_OF_FILE; + } + + s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename + + s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment; + s->num_file += 1; + + err = unzGetCurrentFileInfoInternal(file, &s->cur_file_info, &s->cur_file_info_internal, + filename, filename_size, extrafield, extrafield_size, comment, comment_size); + + s->current_file_ok = (err == UNZ_OK); + if ((err == UNZ_OK) && (pfile_info != NULL)) + memcpy(pfile_info, &s->cur_file_info, sizeof(unz_file_info64)); + + return err; +} + +extern int ZEXPORT unzGoToNextFile(unzFile file) +{ + return unzGoToNextFile2(file, NULL, NULL, 0, NULL, 0, NULL, 0); +} + +extern int ZEXPORT unzLocateFile(unzFile file, const char *filename, unzFileNameComparer filename_compare_func) +{ + unz64_internal *s = NULL; + unz_file_info64 cur_file_info_saved; + unz_file_info64_internal cur_file_info_internal_saved; + uint64_t num_file_saved = 0; + uint64_t pos_in_central_dir_saved = 0; + char current_filename[UNZ_MAXFILENAMEINZIP+1]; + int err = UNZ_OK; + + if (file == NULL) + return UNZ_PARAMERROR; + if (strlen(filename) >= UNZ_MAXFILENAMEINZIP) + return UNZ_PARAMERROR; + s = (unz64_internal*)file; + if (!s->current_file_ok) + return UNZ_END_OF_LIST_OF_FILE; + + /* Save the current state */ + num_file_saved = s->num_file; + pos_in_central_dir_saved = s->pos_in_central_dir; + cur_file_info_saved = s->cur_file_info; + cur_file_info_internal_saved = s->cur_file_info_internal; + + err = unzGoToFirstFile2(file, NULL, current_filename, sizeof(current_filename)-1, NULL, 0, NULL, 0); + + while (err == UNZ_OK) + { + if (filename_compare_func != NULL) + err = filename_compare_func(file, current_filename, filename); + else + err = strcmp(current_filename, filename); + if (err == 0) + return UNZ_OK; + err = unzGoToNextFile2(file, NULL, current_filename, sizeof(current_filename)-1, NULL, 0, NULL, 0); + } + + /* We failed, so restore the state of the 'current file' to where we were. */ + s->num_file = num_file_saved; + s->pos_in_central_dir = pos_in_central_dir_saved; + s->cur_file_info = cur_file_info_saved; + s->cur_file_info_internal = cur_file_info_internal_saved; + return err; +} + +extern int ZEXPORT unzGetFilePos(unzFile file, unz_file_pos *file_pos) +{ + unz64_file_pos file_pos64; + int err = unzGetFilePos64(file, &file_pos64); + if (err == UNZ_OK) + { + file_pos->pos_in_zip_directory = (uint32_t)file_pos64.pos_in_zip_directory; + file_pos->num_of_file = (uint32_t)file_pos64.num_of_file; + } + return err; +} + +extern int ZEXPORT unzGoToFilePos(unzFile file, unz_file_pos *file_pos) +{ + unz64_file_pos file_pos64; + if (file_pos == NULL) + return UNZ_PARAMERROR; + file_pos64.pos_in_zip_directory = file_pos->pos_in_zip_directory; + file_pos64.num_of_file = file_pos->num_of_file; + return unzGoToFilePos64(file, &file_pos64); +} + +extern int ZEXPORT unzGetFilePos64(unzFile file, unz64_file_pos *file_pos) +{ + unz64_internal *s = NULL; + + if (file == NULL || file_pos == NULL) + return UNZ_PARAMERROR; + s = (unz64_internal*)file; + if (!s->current_file_ok) + return UNZ_END_OF_LIST_OF_FILE; + + file_pos->pos_in_zip_directory = s->pos_in_central_dir; + file_pos->num_of_file = s->num_file; + return UNZ_OK; +} + +extern int ZEXPORT unzGoToFilePos64(unzFile file, const unz64_file_pos *file_pos) +{ + unz64_internal *s = NULL; + int err = UNZ_OK; + + if (file == NULL || file_pos == NULL) + return UNZ_PARAMERROR; + s = (unz64_internal*)file; + + /* Jump to the right spot */ + s->pos_in_central_dir = file_pos->pos_in_zip_directory; + s->num_file = file_pos->num_of_file; + + /* Set the current file */ + err = unzGetCurrentFileInfoInternal(file, &s->cur_file_info, &s->cur_file_info_internal, NULL, 0, NULL, 0, NULL, 0); + /* Return results */ + s->current_file_ok = (err == UNZ_OK); + return err; +} + +extern int32_t ZEXPORT unzGetOffset(unzFile file) +{ + uint64_t offset64 = 0; + + if (file == NULL) + return UNZ_PARAMERROR; + offset64 = unzGetOffset64(file); + return (int32_t)offset64; +} + +extern int64_t ZEXPORT unzGetOffset64(unzFile file) +{ + unz64_internal *s = NULL; + + if (file == NULL) + return UNZ_PARAMERROR; + s = (unz64_internal*)file; + if (!s->current_file_ok) + return 0; + if (s->gi.number_entry != 0 && s->gi.number_entry != UINT16_MAX) + { + if (s->num_file == s->gi.number_entry) + return 0; + } + return s->pos_in_central_dir; +} + +extern int ZEXPORT unzSetOffset(unzFile file, uint32_t pos) +{ + return unzSetOffset64(file, pos); +} + +extern int ZEXPORT unzSetOffset64(unzFile file, uint64_t pos) +{ + unz64_internal *s = NULL; + int err = UNZ_OK; + + if (file == NULL) + return UNZ_PARAMERROR; + s = (unz64_internal*)file; + s->pos_in_central_dir = pos; + s->num_file = s->gi.number_entry; /* hack */ + + err = unzGetCurrentFileInfoInternal(file, &s->cur_file_info, &s->cur_file_info_internal, NULL, 0, NULL, 0, NULL, 0); + + s->current_file_ok = (err == UNZ_OK); + return err; +} + +extern int32_t ZEXPORT unzTell(unzFile file) +{ + unz64_internal *s = NULL; + if (file == NULL) + return UNZ_PARAMERROR; + s = (unz64_internal*)file; + if (s->pfile_in_zip_read == NULL) + return UNZ_PARAMERROR; + return (int32_t)s->pfile_in_zip_read->stream.total_out; +} + +extern int64_t ZEXPORT unzTell64(unzFile file) +{ + unz64_internal *s = NULL; + if (file == NULL) + return UNZ_PARAMERROR; + s = (unz64_internal*)file; + if (s->pfile_in_zip_read == NULL) + return UNZ_PARAMERROR; + return s->pfile_in_zip_read->total_out_64; +} + +extern int ZEXPORT unzSeek(unzFile file, uint32_t offset, int origin) +{ + return unzSeek64(file, offset, origin); +} + +extern int ZEXPORT unzSeek64(unzFile file, uint64_t offset, int origin) +{ + unz64_internal *s = NULL; + uint64_t stream_pos_begin = 0; + uint64_t stream_pos_end = 0; + uint64_t position = 0; + int is_within_buffer = 0; + + if (file == NULL) + return UNZ_PARAMERROR; + s = (unz64_internal*)file; + + if (s->pfile_in_zip_read == NULL) + return UNZ_ERRNO; + if (s->pfile_in_zip_read->compression_method != 0) + return UNZ_ERRNO; + + if (origin == SEEK_SET) + position = offset; + else if (origin == SEEK_CUR) + position = s->pfile_in_zip_read->total_out_64 + offset; + else if (origin == SEEK_END) + position = s->cur_file_info.compressed_size + offset; + else + return UNZ_PARAMERROR; + + if (position > s->cur_file_info.compressed_size) + return UNZ_PARAMERROR; + + stream_pos_end = s->pfile_in_zip_read->pos_in_zipfile; + stream_pos_begin = stream_pos_end; + + if (stream_pos_begin > UNZ_BUFSIZE) + stream_pos_begin -= UNZ_BUFSIZE; + else + stream_pos_begin = 0; + + is_within_buffer = + (s->pfile_in_zip_read->stream.avail_in != 0) && + (s->pfile_in_zip_read->rest_read_compressed != 0 || s->cur_file_info.compressed_size < UNZ_BUFSIZE) && + (position >= stream_pos_begin && position < stream_pos_end); + + if (is_within_buffer) + { + s->pfile_in_zip_read->stream.next_in += position - s->pfile_in_zip_read->total_out_64; + s->pfile_in_zip_read->stream.avail_in = (uInt)(stream_pos_end - position); + } + else + { + s->pfile_in_zip_read->stream.avail_in = 0; + s->pfile_in_zip_read->stream.next_in = 0; + + s->pfile_in_zip_read->pos_in_zipfile = s->pfile_in_zip_read->offset_local_extrafield + position; + s->pfile_in_zip_read->rest_read_compressed = s->cur_file_info.compressed_size - position; + } + + s->pfile_in_zip_read->rest_read_uncompressed -= (position - s->pfile_in_zip_read->total_out_64); + s->pfile_in_zip_read->stream.total_out = (uint32_t)position; + s->pfile_in_zip_read->total_out_64 = position; + + return UNZ_OK; +} + +extern int ZEXPORT unzEndOfFile(unzFile file) +{ + unz64_internal *s = NULL; + if (file == NULL) + return UNZ_PARAMERROR; + s = (unz64_internal*)file; + if (s->pfile_in_zip_read == NULL) + return UNZ_PARAMERROR; + if (s->pfile_in_zip_read->rest_read_uncompressed == 0) + return 1; + return 0; +} diff --git a/src/libgame/zip/unzip.h b/src/libgame/zip/unzip.h new file mode 100644 index 00000000..4aa047ea --- /dev/null +++ b/src/libgame/zip/unzip.h @@ -0,0 +1,311 @@ +/* unzip.h -- IO for uncompress .zip files using zlib + Version 1.2.0, September 16th, 2017 + part of the MiniZip project + + Copyright (C) 2012-2017 Nathan Moinvaziri + https://github.com/nmoinvaz/minizip + Copyright (C) 2009-2010 Mathias Svensson + Modifications for Zip64 support on both zip and unzip + http://result42.com + Copyright (C) 2007-2008 Even Rouault + Modifications of Unzip for Zip64 + Copyright (C) 1998-2010 Gilles Vollant + http://www.winimage.com/zLibDll/minizip.html + + 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. +*/ + +#ifndef _UNZ_H +#define _UNZ_H + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef _ZLIB_H +#include "zlib.h" +#endif + +#ifndef _ZLIBIOAPI_H +#include "ioapi.h" +#endif + +#ifdef HAVE_BZIP2 +#include "bzlib.h" +#endif + +#define Z_BZIP2ED 12 + +#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP) +/* like the STRICT of WIN32, we define a pointer that cannot be converted + from (void*) without cast */ +typedef struct TagunzFile__ { int unused; } unz_file__; +typedef unz_file__ *unzFile; +#else +typedef voidp unzFile; +#endif + +#define UNZ_OK (0) +#define UNZ_END_OF_LIST_OF_FILE (-100) +#define UNZ_ERRNO (Z_ERRNO) +#define UNZ_EOF (0) +#define UNZ_PARAMERROR (-102) +#define UNZ_BADZIPFILE (-103) +#define UNZ_INTERNALERROR (-104) +#define UNZ_CRCERROR (-105) +#define UNZ_BADPASSWORD (-106) + +/* unz_global_info structure contain global data about the ZIPfile + These data comes from the end of central dir */ +typedef struct unz_global_info64_s +{ + uint64_t number_entry; /* total number of entries in the central dir on this disk */ + uint32_t number_disk_with_CD; /* number the the disk with central dir, used for spanning ZIP*/ + uint16_t size_comment; /* size of the global comment of the zipfile */ +} unz_global_info64; + +typedef struct unz_global_info_s +{ + uint32_t number_entry; /* total number of entries in the central dir on this disk */ + uint32_t number_disk_with_CD; /* number the the disk with central dir, used for spanning ZIP*/ + uint16_t size_comment; /* size of the global comment of the zipfile */ +} unz_global_info; + +/* unz_file_info contain information about a file in the zipfile */ +/* https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT */ +typedef struct unz_file_info64_s +{ + uint16_t version; /* version made by 2 bytes */ + uint16_t version_needed; /* version needed to extract 2 bytes */ + uint16_t flag; /* general purpose bit flag 2 bytes */ + uint16_t compression_method; /* compression method 2 bytes */ + uint32_t dos_date; /* last mod file date in Dos fmt 4 bytes */ + uint32_t crc; /* crc-32 4 bytes */ + uint64_t compressed_size; /* compressed size 8 bytes */ + uint64_t uncompressed_size; /* uncompressed size 8 bytes */ + uint16_t size_filename; /* filename length 2 bytes */ + uint16_t size_file_extra; /* extra field length 2 bytes */ + uint16_t size_file_comment; /* file comment length 2 bytes */ + + uint32_t disk_num_start; /* disk number start 4 bytes */ + uint16_t internal_fa; /* internal file attributes 2 bytes */ + uint32_t external_fa; /* external file attributes 4 bytes */ + + uint64_t disk_offset; + + uint16_t size_file_extra_internal; +} unz_file_info64; + +typedef struct unz_file_info_s +{ + uint16_t version; /* version made by 2 bytes */ + uint16_t version_needed; /* version needed to extract 2 bytes */ + uint16_t flag; /* general purpose bit flag 2 bytes */ + uint16_t compression_method; /* compression method 2 bytes */ + uint32_t dos_date; /* last mod file date in Dos fmt 4 bytes */ + uint32_t crc; /* crc-32 4 bytes */ + uint32_t compressed_size; /* compressed size 4 bytes */ + uint32_t uncompressed_size; /* uncompressed size 4 bytes */ + uint16_t size_filename; /* filename length 2 bytes */ + uint16_t size_file_extra; /* extra field length 2 bytes */ + uint16_t size_file_comment; /* file comment length 2 bytes */ + + uint16_t disk_num_start; /* disk number start 2 bytes */ + uint16_t internal_fa; /* internal file attributes 2 bytes */ + uint32_t external_fa; /* external file attributes 4 bytes */ + + uint64_t disk_offset; +} unz_file_info; + +/***************************************************************************/ +/* Opening and close a zip file */ + +extern unzFile ZEXPORT unzOpen(const char *path); +extern unzFile ZEXPORT unzOpen64(const void *path); +/* Open a Zip file. + + path should contain the full path (by example, on a Windows XP computer + "c:\\zlib\\zlib113.zip" or on an Unix computer "zlib/zlib113.zip". + return NULL if zipfile cannot be opened or doesn't exist + return unzFile handle if no error + + NOTE: The "64" function take a const void *pointer, because the path is just the value passed to the + open64_file_func callback. Under Windows, if UNICODE is defined, using fill_fopen64_filefunc, the path + is a pointer to a wide unicode string (LPCTSTR is LPCWSTR), so const char *does not describe the reality */ + +extern unzFile ZEXPORT unzOpen2(const char *path, zlib_filefunc_def *pzlib_filefunc_def); +/* Open a Zip file, like unzOpen, but provide a set of file low level API for read/write operations */ +extern unzFile ZEXPORT unzOpen2_64(const void *path, zlib_filefunc64_def *pzlib_filefunc_def); +/* Open a Zip file, like unz64Open, but provide a set of file low level API for read/write 64-bit operations */ + +extern int ZEXPORT unzClose(unzFile file); +/* Close a ZipFile opened with unzOpen. If there is files inside the .Zip opened with unzOpenCurrentFile, + these files MUST be closed with unzipCloseCurrentFile before call unzipClose. + + return UNZ_OK if there is no error */ + +extern int ZEXPORT unzGetGlobalInfo(unzFile file, unz_global_info *pglobal_info); +extern int ZEXPORT unzGetGlobalInfo64(unzFile file, unz_global_info64 *pglobal_info); +/* Write info about the ZipFile in the *pglobal_info structure. + + return UNZ_OK if no error */ + +extern int ZEXPORT unzGetGlobalComment(unzFile file, char *comment, uint16_t comment_size); +/* Get the global comment string of the ZipFile, in the comment buffer. + + uSizeBuf is the size of the szComment buffer. + return the number of byte copied or an error code <0 */ + +extern uint64_t ZEXPORT unzCountEntries(const unzFile file); + +/***************************************************************************/ +/* Reading the content of the current zipfile, you can open it, read data from it, and close it + (you can close it before reading all the file) */ + +extern int ZEXPORT unzOpenCurrentFile(unzFile file); +/* Open for reading data the current file in the zipfile. + + return UNZ_OK if no error */ + +extern int ZEXPORT unzOpenCurrentFilePassword(unzFile file, const char *password); +/* Open for reading data the current file in the zipfile. + password is a crypting password + + return UNZ_OK if no error */ + +extern int ZEXPORT unzOpenCurrentFile2(unzFile file, int *method, int *level, int raw); +/* Same as unzOpenCurrentFile, but open for read raw the file (not uncompress) + if raw==1 *method will receive method of compression, *level will receive level of compression + + NOTE: you can set level parameter as NULL (if you did not want known level, + but you CANNOT set method parameter as NULL */ + +extern int ZEXPORT unzOpenCurrentFile3(unzFile file, int *method, int *level, int raw, const char *password); +/* Same as unzOpenCurrentFile, but takes extra parameter password for encrypted files */ + +extern int ZEXPORT unzReadCurrentFile(unzFile file, voidp buf, uint32_t len); +/* Read bytes from the current file (opened by unzOpenCurrentFile) + buf contain buffer where data must be copied + len the size of buf. + + return the number of byte copied if somes bytes are copied + return 0 if the end of file was reached + return <0 with error code if there is an error (UNZ_ERRNO for IO error, or zLib error for uncompress error) */ + +extern int ZEXPORT unzGetCurrentFileInfo(unzFile file, unz_file_info *pfile_info, char *filename, + uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size); +extern int ZEXPORT unzGetCurrentFileInfo64(unzFile file, unz_file_info64 *pfile_info, char *filename, + uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size); +/* Get Info about the current file + + pfile_info if != NULL, the *pfile_info structure will contain somes info about the current file + filename if != NULL, the file name string will be copied in filename + filename_size is the size of the filename buffer + extrafield if != NULL, the extra field information from the central header will be copied in to + extrafield_size is the size of the extraField buffer + comment if != NULL, the comment string of the file will be copied in to + comment_size is the size of the comment buffer */ + +extern int ZEXPORT unzGetLocalExtrafield(unzFile file, voidp buf, uint32_t len); +/* Read extra field from the current file (opened by unzOpenCurrentFile) + This is the local-header version of the extra field (sometimes, there is + more info in the local-header version than in the central-header) + + if buf == NULL, it return the size of the local extra field + if buf != NULL, len is the size of the buffer, the extra header is copied in buf. + + return number of bytes copied in buf, or (if <0) the error code */ + +extern int ZEXPORT unzCloseCurrentFile(unzFile file); +/* Close the file in zip opened with unzOpenCurrentFile + + return UNZ_CRCERROR if all the file was read but the CRC is not good */ + +/***************************************************************************/ +/* Browse the directory of the zipfile */ + +typedef int (*unzFileNameComparer)(unzFile file, const char *filename1, const char *filename2); +typedef int (*unzIteratorFunction)(unzFile file); +typedef int (*unzIteratorFunction2)(unzFile file, unz_file_info64 *pfile_info, char *filename, + uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size); + +extern int ZEXPORT unzGoToFirstFile(unzFile file); +/* Set the current file of the zipfile to the first file. + + return UNZ_OK if no error */ + +extern int ZEXPORT unzGoToFirstFile2(unzFile file, unz_file_info64 *pfile_info, char *filename, + uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size); +/* Set the current file of the zipfile to the first file and retrieves the current info on success. + Not as seek intensive as unzGoToFirstFile + unzGetCurrentFileInfo. + + return UNZ_OK if no error */ + +extern int ZEXPORT unzGoToNextFile(unzFile file); +/* Set the current file of the zipfile to the next file. + + return UNZ_OK if no error + return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest */ + +extern int ZEXPORT unzGoToNextFile2(unzFile file, unz_file_info64 *pfile_info, char *filename, + uint16_t filename_size, void *extrafield, uint16_t extrafield_size, char *comment, uint16_t comment_size); +/* Set the current file of the zipfile to the next file and retrieves the current + info on success. Does less seeking around than unzGotoNextFile + unzGetCurrentFileInfo. + + return UNZ_OK if no error + return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest */ + +extern int ZEXPORT unzLocateFile(unzFile file, const char *filename, unzFileNameComparer filename_compare_func); +/* Try locate the file szFileName in the zipfile. For custom filename comparison pass in comparison function. + + return UNZ_OK if the file is found (it becomes the current file) + return UNZ_END_OF_LIST_OF_FILE if the file is not found */ + +/***************************************************************************/ +/* Raw access to zip file */ + +typedef struct unz_file_pos_s +{ + uint32_t pos_in_zip_directory; /* offset in zip file directory */ + uint32_t num_of_file; /* # of file */ +} unz_file_pos; + +extern int ZEXPORT unzGetFilePos(unzFile file, unz_file_pos *file_pos); +extern int ZEXPORT unzGoToFilePos(unzFile file, unz_file_pos *file_pos); + +typedef struct unz64_file_pos_s +{ + uint64_t pos_in_zip_directory; /* offset in zip file directory */ + uint64_t num_of_file; /* # of file */ +} unz64_file_pos; + +extern int ZEXPORT unzGetFilePos64(unzFile file, unz64_file_pos *file_pos); +extern int ZEXPORT unzGoToFilePos64(unzFile file, const unz64_file_pos *file_pos); + +extern int32_t ZEXPORT unzGetOffset(unzFile file); +extern int64_t ZEXPORT unzGetOffset64(unzFile file); +/* Get the current file offset */ + +extern int ZEXPORT unzSetOffset(unzFile file, uint32_t pos); +extern int ZEXPORT unzSetOffset64(unzFile file, uint64_t pos); +/* Set the current file offset */ + +extern int32_t ZEXPORT unzTell(unzFile file); +extern int64_t ZEXPORT unzTell64(unzFile file); +/* return current position in uncompressed data */ + +extern int ZEXPORT unzSeek(unzFile file, uint32_t offset, int origin); +extern int ZEXPORT unzSeek64(unzFile file, uint64_t offset, int origin); +/* Seek within the uncompressed data if compression method is storage */ + +extern int ZEXPORT unzEndOfFile(unzFile file); +/* return 1 if the end of file was reached, 0 elsewhere */ + +/***************************************************************************/ + +#ifdef __cplusplus +} +#endif + +#endif /* _UNZ_H */