From 0f2eb9658e3a62e1d19ccc943139360c6414eaa9 Mon Sep 17 00:00:00 2001 From: patrikjuvonen <22572159+patrikjuvonen@users.noreply.github.com> Date: Sun, 17 Apr 2022 21:36:17 +0300 Subject: [PATCH 1/2] Upgrade minizip 1.01e to minizip-ng 1.2 --- vendor/zip/crypt.h | 154 +-- vendor/zip/ioapi.c | 390 ++++-- vendor/zip/ioapi.h | 160 ++- vendor/zip/ioapi_buf.c | 452 +++++++ vendor/zip/ioapi_buf.h | 52 + vendor/zip/ioapi_mem.c | 167 +++ vendor/zip/ioapi_mem.h | 52 + vendor/zip/iowin32.c | 617 ++++++--- vendor/zip/iowin32.h | 26 +- vendor/zip/unzip.c | 2887 +++++++++++++++++++++++----------------- vendor/zip/unzip.h | 496 ++++--- vendor/zip/zip.c | 2403 ++++++++++++++++++++++----------- vendor/zip/zip.h | 349 +++-- 13 files changed, 5283 insertions(+), 2922 deletions(-) create mode 100644 vendor/zip/ioapi_buf.c create mode 100644 vendor/zip/ioapi_buf.h create mode 100644 vendor/zip/ioapi_mem.c create mode 100644 vendor/zip/ioapi_mem.h diff --git a/vendor/zip/crypt.h b/vendor/zip/crypt.h index 622f4bc2ec..4f16bdf4af 100644 --- a/vendor/zip/crypt.h +++ b/vendor/zip/crypt.h @@ -1,132 +1,66 @@ -/* crypt.h -- base code for crypt/uncrypt ZIPfile +/* crypt.h -- base code for traditional PKWARE encryption + Version 1.2.0, September 16th, 2017 + Copyright (C) 2012-2017 Nathan Moinvaziri + https://github.com/nmoinvaz/minizip + Copyright (C) 1998-2005 Gilles Vollant + Modifications for Info-ZIP crypting + http://www.winimage.com/zLibDll/minizip.html + Copyright (C) 2003 Terry Thorsen - Version 1.01e, February 12th, 2005 + This code is a modified version of crypting code in Info-ZIP distribution - Copyright (C) 1998-2005 Gilles Vollant + Copyright (C) 1990-2000 Info-ZIP. All rights reserved. - This code is a modified version of crypting code in Infozip distribution + 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. +*/ - The encryption/decryption parts of this source code (as opposed to the - non-echoing password parts) were originally written in Europe. The - whole source package can be freely distributed, including from the USA. - (Prior to January 2000, re-export from the US was a violation of US law.) +#ifndef _MINICRYPT_H +#define _MINICRYPT_H - This encryption code is a direct transcription of the algorithm from - Roger Schlafly, described by Phil Katz in the file appnote.txt. This - file (appnote.txt) is distributed with the PKZIP program (even in the - version without encryption capabilities). +#if ZLIB_VERNUM < 0x1270 +typedef unsigned long z_crc_t; +#endif - If you don't need crypting in your application, just define symbols - NOCRYPT and NOUNCRYPT. +#ifdef __cplusplus +extern "C" { +#endif - This code support the "Traditional PKWARE Encryption". +#define RAND_HEAD_LEN 12 - The new AES encryption added on Zip format by Winzip (see the page - http://www.winzip.com/aes_info.htm ) and PKWare PKZip 5.x Strong - Encryption is not supported. -*/ +/***************************************************************************/ -#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8)) +#define zdecode(pkeys,pcrc_32_tab,c) \ + (update_keys(pkeys,pcrc_32_tab, c ^= decrypt_byte(pkeys))) -/*********************************************************************** - * Return the next byte in the pseudo-random sequence - */ -static int decrypt_byte(unsigned long* pkeys, const unsigned long* pcrc_32_tab) -{ - unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an - * unpredictable manner on 16-bit systems; not a problem - * with any known compiler so far, though */ +#define zencode(pkeys,pcrc_32_tab,c,t) \ + (t = decrypt_byte(pkeys), update_keys(pkeys,pcrc_32_tab,c), t^(c)) - temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2; - return (int)(((temp * (temp ^ 1)) >> 8) & 0xff); -} +/***************************************************************************/ -/*********************************************************************** - * Update the encryption keys with the next byte of plain text - */ -static int update_keys(unsigned long* pkeys,const unsigned long* pcrc_32_tab,int c) -{ - (*(pkeys+0)) = CRC32((*(pkeys+0)), c); - (*(pkeys+1)) += (*(pkeys+0)) & 0xff; - (*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1; - { - register int keyshift = (int)((*(pkeys+1)) >> 24); - (*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift); - } - return c; -} +/* Return the next byte in the pseudo-random sequence */ +uint8_t decrypt_byte(uint32_t *pkeys); +/* Update the encryption keys with the next byte of plain text */ +uint8_t update_keys(uint32_t *pkeys, const z_crc_t *pcrc_32_tab, int32_t c); -/*********************************************************************** - * Initialize the encryption keys and the random header according to - * the given password. - */ -static void init_keys(const char* passwd,unsigned long* pkeys,const unsigned long* pcrc_32_tab) -{ - *(pkeys+0) = 305419896L; - *(pkeys+1) = 591751049L; - *(pkeys+2) = 878082192L; - while (*passwd != '\0') { - update_keys(pkeys,pcrc_32_tab,(int)*passwd); - passwd++; - } -} +/* Initialize the encryption keys and the random header according to the given password. */ +void init_keys(const char *passwd, uint32_t *pkeys, const z_crc_t *pcrc_32_tab); -#define zdecode(pkeys,pcrc_32_tab,c) \ - (update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab))) +#ifndef NOCRYPT +/* Generate cryptographically secure random numbers */ +int cryptrand(unsigned char *buf, unsigned int len); -#define zencode(pkeys,pcrc_32_tab,c,t) \ - (t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c)) +/* Create encryption header */ +int crypthead(const char *passwd, uint8_t *buf, int buf_size, uint32_t *pkeys, + const z_crc_t *pcrc_32_tab, uint8_t verify1, uint8_t verify2); +#endif -#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED +/***************************************************************************/ -#define RAND_HEAD_LEN 12 - /* "last resort" source for second part of crypt seed pattern */ -# ifndef ZCR_SEED2 -# define ZCR_SEED2 3141592654UL /* use PI as default pattern */ -# endif - -static int crypthead(passwd, buf, bufSize, pkeys, pcrc_32_tab, crcForCrypting) - const char *passwd; /* password string */ - unsigned char *buf; /* where to write header */ - int bufSize; - unsigned long* pkeys; - const unsigned long* pcrc_32_tab; - unsigned long crcForCrypting; -{ - int n; /* index in random header */ - int t; /* temporary */ - int c; /* random byte */ - unsigned char header[RAND_HEAD_LEN-2]; /* random header */ - static unsigned calls = 0; /* ensure different random header each time */ - - if (bufSize> 7) & 0xff; - header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t); - } - /* Encrypt random header (last two bytes is high word of crc) */ - init_keys(passwd, pkeys, pcrc_32_tab); - for (n = 0; n < RAND_HEAD_LEN-2; n++) - { - buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t); - } - buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t); - buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t); - return n; +#ifdef __cplusplus } +#endif #endif diff --git a/vendor/zip/ioapi.c b/vendor/zip/ioapi.c index f1bee23e64..239bb05a4d 100644 --- a/vendor/zip/ioapi.c +++ b/vendor/zip/ioapi.c @@ -1,172 +1,335 @@ /* ioapi.c -- IO base function header for compress/uncompress .zip - files using zlib + zip or unzip API + part of the MiniZip project - Version 1.01e, February 12th, 2005 + 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 - Copyright (C) 1998-2005 Gilles Vollant + 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 "zlib.h" -#include "ioapi.h" - - - -/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */ - -#ifndef SEEK_CUR -#define SEEK_CUR 1 +#if defined unix || defined __APPLE__ +#include +#include #endif -#ifndef SEEK_END -#define SEEK_END 2 -#endif +#include "ioapi.h" -#ifndef SEEK_SET -#define SEEK_SET 0 +#if defined(_WIN32) +# define snprintf _snprintf #endif -voidpf ZCALLBACK fopen_file_func OF(( - voidpf opaque, - const char* filename, - int mode)); +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); +} -uLong ZCALLBACK fread_file_func OF(( - voidpf opaque, - voidpf stream, - void* buf, - uLong size)); +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); +} -uLong ZCALLBACK fwrite_file_func OF(( - voidpf opaque, - voidpf stream, - const void* buf, - uLong size)); +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); +} -long ZCALLBACK ftell_file_func OF(( - voidpf opaque, - voidpf stream)); +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; +} -long ZCALLBACK fseek_file_func OF(( - voidpf opaque, - voidpf stream, - uLong offset, - int origin)); +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; +} -int ZCALLBACK fclose_file_func OF(( - voidpf opaque, - voidpf stream)); +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); -int ZCALLBACK ferror_file_func OF(( - 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; +} -voidpf ZCALLBACK fopen_file_func (opaque, filename, mode) - voidpf opaque; - const char* filename; - int mode; +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) + 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) + else if (mode & ZLIB_FILEFUNC_MODE_EXISTING) mode_fopen = "r+b"; - else - if (mode & ZLIB_FILEFUNC_MODE_CREATE) + else if (mode & ZLIB_FILEFUNC_MODE_CREATE) mode_fopen = "wb"; - if ((filename!=NULL) && (mode_fopen != NULL)) + 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; +} -uLong ZCALLBACK fread_file_func (opaque, stream, buf, size) - voidpf opaque; - voidpf stream; - void* buf; - uLong size; +static voidpf ZCALLBACK fopendisk64_file_func(voidpf opaque, voidpf stream, uint32_t number_disk, int mode) { - uLong ret; - ret = (uLong)fread(buf, 1, (size_t)size, (FILE *)stream); + 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; -uLong ZCALLBACK fwrite_file_func (opaque, stream, buf, size) - voidpf opaque; - voidpf stream; - const void* buf; - uLong size; + 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) { - uLong ret; - ret = (uLong)fwrite(buf, 1, (size_t)size, (FILE *)stream); + 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; } -long ZCALLBACK ftell_file_func (opaque, stream) - voidpf opaque; - voidpf stream; +static uint64_t ZCALLBACK ftell64_file_func(ZIP_UNUSED voidpf opaque, voidpf stream) { - long ret; - ret = ftell((FILE *)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; } -long ZCALLBACK fseek_file_func (opaque, stream, offset, origin) - voidpf opaque; - voidpf stream; - uLong offset; - int origin; +static long ZCALLBACK fseek_file_func(ZIP_UNUSED voidpf opaque, voidpf stream, uint32_t offset, int origin) { - int fseek_origin=0; - long ret; + 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; + 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; } - ret = 0; - fseek((FILE *)stream, offset, fseek_origin); + + if (fseeko64(ioposix->file, offset, fseek_origin) != 0) + ret = -1; + return ret; } -int ZCALLBACK fclose_file_func (opaque, stream) - voidpf opaque; - voidpf stream; +static int ZCALLBACK fclose_file_func(ZIP_UNUSED voidpf opaque, voidpf stream) { - int ret; - ret = fclose((FILE *)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; } -int ZCALLBACK ferror_file_func (opaque, stream) - voidpf opaque; - voidpf stream; +static int ZCALLBACK ferror_file_func(ZIP_UNUSED voidpf opaque, voidpf stream) { - int ret; - ret = ferror((FILE *)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 (pzlib_filefunc_def) - zlib_filefunc_def* pzlib_filefunc_def; +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; @@ -175,3 +338,16 @@ void fill_fopen_filefunc (pzlib_filefunc_def) 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/vendor/zip/ioapi.h b/vendor/zip/ioapi.h index 7d457baab3..b4a0d461da 100644 --- a/vendor/zip/ioapi.h +++ b/vendor/zip/ioapi.h @@ -1,75 +1,153 @@ /* ioapi.h -- IO base function header for compress/uncompress .zip - files using zlib + zip or unzip API + 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. +*/ - Version 1.01e, February 12th, 2005 +#ifndef _ZLIBIOAPI64_H +#define _ZLIBIOAPI64_H - Copyright (C) 1998-2005 Gilles Vollant -*/ +#include +#include +#include -#ifndef _ZLIBIOAPI_H -#define _ZLIBIOAPI_H +#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(_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 +# else +# define fopen64 fopen +# define ftello64 ftello +# define fseeko64 fseeko +# 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) - +#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 (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK) -#define ZCALLBACK CALLBACK -#else -#define ZCALLBACK -#endif +# if (defined(WIN32) || defined(_WIN32) || defined (WINDOWS) || \ + defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK) +# define ZCALLBACK CALLBACK +# else +# define ZCALLBACK +# endif #endif -#ifdef __cplusplus -extern "C" { -#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 voidpf (ZCALLBACK *open_file_func) OF((voidpf opaque, const char* filename, int mode)); -typedef uLong (ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void* buf, uLong size)); -typedef uLong (ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void* buf, uLong size)); -typedef long (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream)); -typedef long (ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin)); -typedef int (ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream)); -typedef int (ZCALLBACK *testerror_file_func) OF((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; - testerror_file_func zerror_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); - -void fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def)); - -#define ZREAD(filefunc,filestream,buf,size) ((*((filefunc).zread_file))((filefunc).opaque,filestream,buf,size)) -#define ZWRITE(filefunc,filestream,buf,size) ((*((filefunc).zwrite_file))((filefunc).opaque,filestream,buf,size)) -#define ZTELL(filefunc,filestream) ((*((filefunc).ztell_file))((filefunc).opaque,filestream)) -#define ZSEEK(filefunc,filestream,pos,mode) ((*((filefunc).zseek_file))((filefunc).opaque,filestream,pos,mode)) -#define ZCLOSE(filefunc,filestream) ((*((filefunc).zclose_file))((filefunc).opaque,filestream)) -#define ZERROR(filefunc,filestream) ((*((filefunc).zerror_file))((filefunc).opaque,filestream)) - +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/vendor/zip/ioapi_buf.c b/vendor/zip/ioapi_buf.c new file mode 100644 index 0000000000..d7aca9f0d5 --- /dev/null +++ b/vendor/zip/ioapi_buf.c @@ -0,0 +1,452 @@ +/* ioapi_buf.c -- IO base function header for compress/uncompress .zip + files using zlib + zip or unzip API + + This version of ioapi is designed to buffer IO. + + Copyright (C) 2012-2017 Nathan Moinvaziri + https://github.com/nmoinvaz/minizip + + 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 "zlib.h" +#include "ioapi.h" + +#include "ioapi_buf.h" + +#ifndef IOBUF_BUFFERSIZE +# define IOBUF_BUFFERSIZE (UINT16_MAX) +#endif + +#if defined(_WIN32) +# include +# define PRINTF _cprintf +# define VPRINTF _vcprintf +#else +# define PRINTF printf +# define VPRINTF vprintf +#endif + +//#define IOBUF_VERBOSE + +typedef struct ourstream_s { + char readbuf[IOBUF_BUFFERSIZE]; + uint32_t readbuf_len; + uint32_t readbuf_pos; + uint32_t readbuf_hits; + uint32_t readbuf_misses; + char writebuf[IOBUF_BUFFERSIZE]; + uint32_t writebuf_len; + uint32_t writebuf_pos; + uint32_t writebuf_hits; + uint32_t writebuf_misses; + uint64_t position; + voidpf stream; +} ourstream_t; + +#if defined(IOBUF_VERBOSE) +# define print_buf(o,s,f,...) print_buf_internal(o,s,f,__VA_ARGS__); +#else +# define print_buf(o,s,f,...) +#endif + +void print_buf_internal(ZIP_UNUSED voidpf opaque, voidpf stream, char *format, ...) +{ + ourstream_t *streamio = (ourstream_t *)stream; + va_list arglist; + PRINTF("Buf stream %p - ", streamio); + va_start(arglist, format); + VPRINTF(format, arglist); + va_end(arglist); +} + +voidpf fopen_buf_internal_func(ZIP_UNUSED voidpf opaque, voidpf stream, ZIP_UNUSED uint32_t number_disk, ZIP_UNUSED int mode) +{ + ourstream_t *streamio = NULL; + if (stream == NULL) + return NULL; + streamio = (ourstream_t *)malloc(sizeof(ourstream_t)); + if (streamio == NULL) + return NULL; + memset(streamio, 0, sizeof(ourstream_t)); + streamio->stream = stream; + print_buf(opaque, streamio, "open [num %d mode %d]\n", number_disk, mode); + return streamio; +} + +voidpf ZCALLBACK fopen_buf_func(voidpf opaque, const char *filename, int mode) +{ + ourbuffer_t *bufio = (ourbuffer_t *)opaque; + voidpf stream = bufio->filefunc.zopen_file(bufio->filefunc.opaque, filename, mode); + return fopen_buf_internal_func(opaque, stream, 0, mode); +} + +voidpf ZCALLBACK fopen64_buf_func(voidpf opaque, const void *filename, int mode) +{ + ourbuffer_t *bufio = (ourbuffer_t *)opaque; + voidpf stream = bufio->filefunc64.zopen64_file(bufio->filefunc64.opaque, filename, mode); + return fopen_buf_internal_func(opaque, stream, 0, mode); +} + +voidpf ZCALLBACK fopendisk_buf_func(voidpf opaque, voidpf stream_cd, uint32_t number_disk, int mode) +{ + ourbuffer_t *bufio = (ourbuffer_t *)opaque; + ourstream_t *streamio = (ourstream_t *)stream_cd; + voidpf *stream = bufio->filefunc.zopendisk_file(bufio->filefunc.opaque, streamio->stream, number_disk, mode); + return fopen_buf_internal_func(opaque, stream, number_disk, mode); +} + +voidpf ZCALLBACK fopendisk64_buf_func(voidpf opaque, voidpf stream_cd, uint32_t number_disk, int mode) +{ + ourbuffer_t *bufio = (ourbuffer_t *)opaque; + ourstream_t *streamio = (ourstream_t *)stream_cd; + voidpf stream = bufio->filefunc64.zopendisk64_file(bufio->filefunc64.opaque, streamio->stream, number_disk, mode); + return fopen_buf_internal_func(opaque, stream, number_disk, mode); +} + +long fflush_buf(voidpf opaque, voidpf stream) +{ + ourbuffer_t *bufio = (ourbuffer_t *)opaque; + ourstream_t *streamio = (ourstream_t *)stream; + uint32_t total_bytes_to_write = 0; + uint32_t bytes_to_write = streamio->writebuf_len; + uint32_t bytes_left_to_write = streamio->writebuf_len; + long bytes_written = 0; + + while (bytes_left_to_write > 0) + { + if (bufio->filefunc64.zwrite_file != NULL) + bytes_written = bufio->filefunc64.zwrite_file(bufio->filefunc64.opaque, streamio->stream, streamio->writebuf + (bytes_to_write - bytes_left_to_write), bytes_left_to_write); + else + bytes_written = bufio->filefunc.zwrite_file(bufio->filefunc.opaque, streamio->stream, streamio->writebuf + (bytes_to_write - bytes_left_to_write), bytes_left_to_write); + + streamio->writebuf_misses += 1; + + print_buf(opaque, stream, "write flush [%d:%d len %d]\n", bytes_to_write, bytes_left_to_write, streamio->writebuf_len); + + if (bytes_written < 0) + return bytes_written; + + total_bytes_to_write += bytes_written; + bytes_left_to_write -= bytes_written; + streamio->position += bytes_written; + } + streamio->writebuf_len = 0; + streamio->writebuf_pos = 0; + return total_bytes_to_write; +} + +uint32_t ZCALLBACK fread_buf_func(voidpf opaque, voidpf stream, void *buf, uint32_t size) +{ + ourbuffer_t *bufio = (ourbuffer_t *)opaque; + ourstream_t *streamio = (ourstream_t *)stream; + uint32_t buf_len = 0; + uint32_t bytes_to_read = 0; + uint32_t bytes_to_copy = 0; + uint32_t bytes_left_to_read = size; + uint32_t bytes_read = 0; + + print_buf(opaque, stream, "read [size %ld pos %lld]\n", size, streamio->position); + + if (streamio->writebuf_len > 0) + { + print_buf(opaque, stream, "switch from write to read, not yet supported [%lld]\n", streamio->position); + } + + while (bytes_left_to_read > 0) + { + if ((streamio->readbuf_len == 0) || (streamio->readbuf_pos == streamio->readbuf_len)) + { + if (streamio->readbuf_len == IOBUF_BUFFERSIZE) + { + streamio->readbuf_pos = 0; + streamio->readbuf_len = 0; + } + + bytes_to_read = IOBUF_BUFFERSIZE - (streamio->readbuf_len - streamio->readbuf_pos); + + if (bufio->filefunc64.zread_file != NULL) + bytes_read = bufio->filefunc64.zread_file(bufio->filefunc64.opaque, streamio->stream, streamio->readbuf + streamio->readbuf_pos, bytes_to_read); + else + bytes_read = bufio->filefunc.zread_file(bufio->filefunc.opaque, streamio->stream, streamio->readbuf + streamio->readbuf_pos, bytes_to_read); + + streamio->readbuf_misses += 1; + streamio->readbuf_len += bytes_read; + streamio->position += bytes_read; + + print_buf(opaque, stream, "filled [read %d/%d buf %d:%d pos %lld]\n", bytes_read, bytes_to_read, streamio->readbuf_pos, streamio->readbuf_len, streamio->position); + + if (bytes_read == 0) + break; + } + + if ((streamio->readbuf_len - streamio->readbuf_pos) > 0) + { + bytes_to_copy = streamio->readbuf_len - streamio->readbuf_pos; + if (bytes_to_copy > bytes_left_to_read) + bytes_to_copy = bytes_left_to_read; + + memcpy((char *)buf + buf_len, streamio->readbuf + streamio->readbuf_pos, bytes_to_copy); + + buf_len += bytes_to_copy; + bytes_left_to_read -= bytes_to_copy; + + streamio->readbuf_hits += 1; + streamio->readbuf_pos += bytes_to_copy; + + print_buf(opaque, stream, "emptied [copied %d remaining %d buf %d:%d pos %lld]\n", bytes_to_copy, bytes_left_to_read, streamio->readbuf_pos, streamio->readbuf_len, streamio->position); + } + } + + return size - bytes_left_to_read; +} + +uint32_t ZCALLBACK fwrite_buf_func(voidpf opaque, voidpf stream, const void *buf, uint32_t size) +{ + ourbuffer_t *bufio = (ourbuffer_t *)opaque; + ourstream_t *streamio = (ourstream_t *)stream; + uint32_t bytes_to_write = size; + uint32_t bytes_left_to_write = size; + uint32_t bytes_to_copy = 0; + uint32_t bytes_used = 0; + int64_t ret = 0; + + print_buf(opaque, stream, "write [size %ld len %d pos %lld]\n", size, streamio->writebuf_len, streamio->position); + + if (streamio->readbuf_len > 0) + { + streamio->position -= streamio->readbuf_len; + streamio->position += streamio->readbuf_pos; + + streamio->readbuf_len = 0; + streamio->readbuf_pos = 0; + + print_buf(opaque, stream, "switch from read to write [%lld]\n", streamio->position); + + if (bufio->filefunc64.zseek64_file != NULL) + ret = bufio->filefunc64.zseek64_file(bufio->filefunc64.opaque, streamio->stream, streamio->position, ZLIB_FILEFUNC_SEEK_SET); + else + ret = bufio->filefunc.zseek_file(bufio->filefunc.opaque, streamio->stream, (uint32_t)streamio->position, ZLIB_FILEFUNC_SEEK_SET); + + if (ret != 0) + return (uint32_t)-1; + } + + while (bytes_left_to_write > 0) + { + bytes_used = streamio->writebuf_len; + if (bytes_used > streamio->writebuf_pos) + bytes_used = streamio->writebuf_pos; + bytes_to_copy = (uint32_t)(IOBUF_BUFFERSIZE - bytes_used); + if (bytes_to_copy > bytes_left_to_write) + bytes_to_copy = bytes_left_to_write; + + if (bytes_to_copy == 0) + { + if (fflush_buf(opaque, stream) <= 0) + return 0; + + continue; + } + + memcpy(streamio->writebuf + streamio->writebuf_pos, (char *)buf + (bytes_to_write - bytes_left_to_write), bytes_to_copy); + + print_buf(opaque, stream, "write copy [remaining %d write %d:%d len %d]\n", bytes_to_copy, bytes_to_write, bytes_left_to_write, streamio->writebuf_len); + + bytes_left_to_write -= bytes_to_copy; + + streamio->writebuf_pos += bytes_to_copy; + streamio->writebuf_hits += 1; + if (streamio->writebuf_pos > streamio->writebuf_len) + streamio->writebuf_len += streamio->writebuf_pos - streamio->writebuf_len; + } + + return size - bytes_left_to_write; +} + +uint64_t ftell_buf_internal_func(ZIP_UNUSED voidpf opaque, voidpf stream, uint64_t position) +{ + ourstream_t *streamio = (ourstream_t *)stream; + streamio->position = position; + print_buf(opaque, stream, "tell [pos %llu readpos %d writepos %d err %d]\n", streamio->position, streamio->readbuf_pos, streamio->writebuf_pos, errno); + if (streamio->readbuf_len > 0) + position -= (streamio->readbuf_len - streamio->readbuf_pos); + if (streamio->writebuf_len > 0) + position += streamio->writebuf_pos; + return position; +} + +long ZCALLBACK ftell_buf_func(voidpf opaque, voidpf stream) +{ + ourbuffer_t *bufio = (ourbuffer_t *)opaque; + ourstream_t *streamio = (ourstream_t *)stream; + uint64_t position = bufio->filefunc.ztell_file(bufio->filefunc.opaque, streamio->stream); + return (long)ftell_buf_internal_func(opaque, stream, position); +} + +uint64_t ZCALLBACK ftell64_buf_func(voidpf opaque, voidpf stream) +{ + ourbuffer_t *bufio = (ourbuffer_t *)opaque; + ourstream_t *streamio = (ourstream_t *)stream; + uint64_t position = bufio->filefunc64.ztell64_file(bufio->filefunc64.opaque, streamio->stream); + return ftell_buf_internal_func(opaque, stream, position); +} + +int fseek_buf_internal_func(voidpf opaque, voidpf stream, uint64_t offset, int origin) +{ + ourstream_t *streamio = (ourstream_t *)stream; + + print_buf(opaque, stream, "seek [origin %d offset %llu pos %lld]\n", origin, offset, streamio->position); + + switch (origin) + { + case ZLIB_FILEFUNC_SEEK_SET: + + if (streamio->writebuf_len > 0) + { + if ((offset >= streamio->position) && (offset <= streamio->position + streamio->writebuf_len)) + { + streamio->writebuf_pos = (uint32_t)(offset - streamio->position); + return 0; + } + } + if ((streamio->readbuf_len > 0) && (offset < streamio->position) && (offset >= streamio->position - streamio->readbuf_len)) + { + streamio->readbuf_pos = (uint32_t)(offset - (streamio->position - streamio->readbuf_len)); + return 0; + } + if (fflush_buf(opaque, stream) < 0) + return -1; + streamio->position = offset; + break; + + case ZLIB_FILEFUNC_SEEK_CUR: + + if (streamio->readbuf_len > 0) + { + if (offset <= (streamio->readbuf_len - streamio->readbuf_pos)) + { + streamio->readbuf_pos += (uint32_t)offset; + return 0; + } + offset -= (streamio->readbuf_len - streamio->readbuf_pos); + streamio->position += offset; + } + if (streamio->writebuf_len > 0) + { + if (offset <= (streamio->writebuf_len - streamio->writebuf_pos)) + { + streamio->writebuf_pos += (uint32_t)offset; + return 0; + } + //offset -= (streamio->writebuf_len - streamio->writebuf_pos); + } + + if (fflush_buf(opaque, stream) < 0) + return -1; + + break; + + case ZLIB_FILEFUNC_SEEK_END: + + if (streamio->writebuf_len > 0) + { + streamio->writebuf_pos = streamio->writebuf_len; + return 0; + } + break; + } + + streamio->readbuf_len = 0; + streamio->readbuf_pos = 0; + streamio->writebuf_len = 0; + streamio->writebuf_pos = 0; + return 1; +} + +long ZCALLBACK fseek_buf_func(voidpf opaque, voidpf stream, uint32_t offset, int origin) +{ + ourbuffer_t *bufio = (ourbuffer_t *)opaque; + ourstream_t *streamio = (ourstream_t *)stream; + long ret = -1; + if (bufio->filefunc.zseek_file == NULL) + return ret; + ret = fseek_buf_internal_func(opaque, stream, offset, origin); + if (ret == 1) + ret = bufio->filefunc.zseek_file(bufio->filefunc.opaque, streamio->stream, offset, origin); + return ret; +} + +long ZCALLBACK fseek64_buf_func(voidpf opaque, voidpf stream, uint64_t offset, int origin) +{ + ourbuffer_t *bufio = (ourbuffer_t *)opaque; + ourstream_t *streamio = (ourstream_t *)stream; + long ret = -1; + if (bufio->filefunc64.zseek64_file == NULL) + return ret; + ret = fseek_buf_internal_func(opaque, stream, offset, origin); + if (ret == 1) + ret = bufio->filefunc64.zseek64_file(bufio->filefunc64.opaque, streamio->stream, offset, origin); + return ret; +} + +int ZCALLBACK fclose_buf_func(voidpf opaque, voidpf stream) +{ + ourbuffer_t *bufio = (ourbuffer_t *)opaque; + ourstream_t *streamio = (ourstream_t *)stream; + int ret = 0; + fflush_buf(opaque, stream); + print_buf(opaque, stream, "close\n"); + if (streamio->readbuf_hits + streamio->readbuf_misses > 0) + print_buf(opaque, stream, "read efficency %.02f%%\n", (streamio->readbuf_hits / ((float)streamio->readbuf_hits + streamio->readbuf_misses)) * 100); + if (streamio->writebuf_hits + streamio->writebuf_misses > 0) + print_buf(opaque, stream, "write efficency %.02f%%\n", (streamio->writebuf_hits / ((float)streamio->writebuf_hits + streamio->writebuf_misses)) * 100); + if (bufio->filefunc64.zclose_file != NULL) + ret = bufio->filefunc64.zclose_file(bufio->filefunc64.opaque, streamio->stream); + else + ret = bufio->filefunc.zclose_file(bufio->filefunc.opaque, streamio->stream); + free(streamio); + return ret; +} + +int ZCALLBACK ferror_buf_func(voidpf opaque, voidpf stream) +{ + ourbuffer_t *bufio = (ourbuffer_t *)opaque; + ourstream_t *streamio = (ourstream_t *)stream; + if (bufio->filefunc64.zerror_file != NULL) + return bufio->filefunc64.zerror_file(bufio->filefunc64.opaque, streamio->stream); + return bufio->filefunc.zerror_file(bufio->filefunc.opaque, streamio->stream); +} + +void fill_buffer_filefunc(zlib_filefunc_def *pzlib_filefunc_def, ourbuffer_t *ourbuf) +{ + pzlib_filefunc_def->zopen_file = fopen_buf_func; + pzlib_filefunc_def->zopendisk_file = fopendisk_buf_func; + pzlib_filefunc_def->zread_file = fread_buf_func; + pzlib_filefunc_def->zwrite_file = fwrite_buf_func; + pzlib_filefunc_def->ztell_file = ftell_buf_func; + pzlib_filefunc_def->zseek_file = fseek_buf_func; + pzlib_filefunc_def->zclose_file = fclose_buf_func; + pzlib_filefunc_def->zerror_file = ferror_buf_func; + pzlib_filefunc_def->opaque = ourbuf; +} + +void fill_buffer_filefunc64(zlib_filefunc64_def *pzlib_filefunc_def, ourbuffer_t *ourbuf) +{ + pzlib_filefunc_def->zopen64_file = fopen64_buf_func; + pzlib_filefunc_def->zopendisk64_file = fopendisk64_buf_func; + pzlib_filefunc_def->zread_file = fread_buf_func; + pzlib_filefunc_def->zwrite_file = fwrite_buf_func; + pzlib_filefunc_def->ztell64_file = ftell64_buf_func; + pzlib_filefunc_def->zseek64_file = fseek64_buf_func; + pzlib_filefunc_def->zclose_file = fclose_buf_func; + pzlib_filefunc_def->zerror_file = ferror_buf_func; + pzlib_filefunc_def->opaque = ourbuf; +} diff --git a/vendor/zip/ioapi_buf.h b/vendor/zip/ioapi_buf.h new file mode 100644 index 0000000000..b0e7698e59 --- /dev/null +++ b/vendor/zip/ioapi_buf.h @@ -0,0 +1,52 @@ +/* ioapi_buf.h -- IO base function header for compress/uncompress .zip + files using zlib + zip or unzip API + + This version of ioapi is designed to buffer IO. + + Copyright (C) 2012-2017 Nathan Moinvaziri + https://github.com/nmoinvaz/minizip + + 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 _IOAPI_BUF_H +#define _IOAPI_BUF_H + +#include +#include +#include + +#include "zlib.h" +#include "ioapi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +voidpf ZCALLBACK fopen_buf_func(voidpf opaque, const char* filename, int mode); +voidpf ZCALLBACK fopen64_buf_func(voidpf opaque, const void* filename, int mode); +voidpf ZCALLBACK fopendisk_buf_func(voidpf opaque, voidpf stream_cd, uint32_t number_disk, int mode); +voidpf ZCALLBACK fopendisk64_buf_func(voidpf opaque, voidpf stream_cd, uint32_t number_disk, int mode); +uint32_t ZCALLBACK fread_buf_func(voidpf opaque, voidpf stream, void* buf, uint32_t size); +uint32_t ZCALLBACK fwrite_buf_func(voidpf opaque, voidpf stream, const void* buf, uint32_t size); +long ZCALLBACK ftell_buf_func(voidpf opaque, voidpf stream); +uint64_t ZCALLBACK ftell64_buf_func(voidpf opaque, voidpf stream); +long ZCALLBACK fseek_buf_func(voidpf opaque, voidpf stream, uint32_t offset, int origin); +long ZCALLBACK fseek64_buf_func(voidpf opaque, voidpf stream, uint64_t offset, int origin); +int ZCALLBACK fclose_buf_func(voidpf opaque,voidpf stream); +int ZCALLBACK ferror_buf_func(voidpf opaque,voidpf stream); + +typedef struct ourbuffer_s { + zlib_filefunc_def filefunc; + zlib_filefunc64_def filefunc64; +} ourbuffer_t; + +void fill_buffer_filefunc(zlib_filefunc_def* pzlib_filefunc_def, ourbuffer_t *ourbuf); +void fill_buffer_filefunc64(zlib_filefunc64_def* pzlib_filefunc_def, ourbuffer_t *ourbuf); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/vendor/zip/ioapi_mem.c b/vendor/zip/ioapi_mem.c new file mode 100644 index 0000000000..ed5334597c --- /dev/null +++ b/vendor/zip/ioapi_mem.c @@ -0,0 +1,167 @@ +/* ioapi_mem.c -- IO base function header for compress/uncompress .zip + files using zlib + zip or unzip API + + This version of ioapi is designed to access memory rather than files. + We do use a region of memory to put data in to and take it out of. We do + not have auto-extending buffers and do not inform anyone else that the + data has been written. It is really intended for accessing a zip archive + embedded in an application such that I can write an installer with no + external files. Creation of archives has not been attempted, although + parts of the framework are present. + + Based on Unzip ioapi.c version 0.22, May 19th, 2003 + + Copyright (C) 2012-2017 Nathan Moinvaziri + https://github.com/nmoinvaz/minizip + Copyright (C) 2003 Justin Fletcher + Copyright (C) 1998-2003 Gilles Vollant + http://www.winimage.com/zLibDll/minizip.html + + This file is under the same license as the Unzip tool it is distributed + with. +*/ + + +#include +#include +#include + +#include "zlib.h" +#include "ioapi.h" + +#include "ioapi_mem.h" + +#ifndef IOMEM_BUFFERSIZE +# define IOMEM_BUFFERSIZE (UINT16_MAX) +#endif + +voidpf ZCALLBACK fopen_mem_func(voidpf opaque, ZIP_UNUSED const char *filename, int mode) +{ + ourmemory_t *mem = (ourmemory_t *)opaque; + if (mem == NULL) + return NULL; /* Mem structure passed in was null */ + + if (mode & ZLIB_FILEFUNC_MODE_CREATE) + { + if (mem->grow) + { + mem->size = IOMEM_BUFFERSIZE; + mem->base = (char *)malloc(mem->size); + } + + mem->limit = 0; /* When writing we start with 0 bytes written */ + } + else + mem->limit = mem->size; + + mem->cur_offset = 0; + + return mem; +} + +voidpf ZCALLBACK fopendisk_mem_func(ZIP_UNUSED voidpf opaque, ZIP_UNUSED voidpf stream, ZIP_UNUSED uint32_t number_disk, ZIP_UNUSED int mode) +{ + /* Not used */ + return NULL; +} + +uint32_t ZCALLBACK fread_mem_func(ZIP_UNUSED voidpf opaque, voidpf stream, void *buf, uint32_t size) +{ + ourmemory_t *mem = (ourmemory_t *)stream; + + if (size > mem->size - mem->cur_offset) + size = mem->size - mem->cur_offset; + + memcpy(buf, mem->base + mem->cur_offset, size); + mem->cur_offset += size; + + return size; +} + +uint32_t ZCALLBACK fwrite_mem_func(ZIP_UNUSED voidpf opaque, voidpf stream, const void *buf, uint32_t size) +{ + ourmemory_t *mem = (ourmemory_t *)stream; + uint32_t newmemsize = 0; + char *newbase = NULL; + + if (size > mem->size - mem->cur_offset) + { + if (mem->grow) + { + newmemsize = mem->size; + if (size < IOMEM_BUFFERSIZE) + newmemsize += IOMEM_BUFFERSIZE; + else + newmemsize += size; + newbase = (char *)malloc(newmemsize); + memcpy(newbase, mem->base, mem->size); + free(mem->base); + mem->base = newbase; + mem->size = newmemsize; + } + else + size = mem->size - mem->cur_offset; + } + memcpy(mem->base + mem->cur_offset, buf, size); + mem->cur_offset += size; + if (mem->cur_offset > mem->limit) + mem->limit = mem->cur_offset; + + return size; +} + +long ZCALLBACK ftell_mem_func(ZIP_UNUSED voidpf opaque, voidpf stream) +{ + ourmemory_t *mem = (ourmemory_t *)stream; + return mem->cur_offset; +} + +long ZCALLBACK fseek_mem_func(ZIP_UNUSED voidpf opaque, voidpf stream, uint32_t offset, int origin) +{ + ourmemory_t *mem = (ourmemory_t *)stream; + uint32_t new_pos = 0; + switch (origin) + { + case ZLIB_FILEFUNC_SEEK_CUR: + new_pos = mem->cur_offset + offset; + break; + case ZLIB_FILEFUNC_SEEK_END: + new_pos = mem->limit + offset; + break; + case ZLIB_FILEFUNC_SEEK_SET: + new_pos = offset; + break; + default: + return -1; + } + + if (new_pos > mem->size) + return 1; /* Failed to seek that far */ + mem->cur_offset = new_pos; + return 0; +} + +int ZCALLBACK fclose_mem_func(ZIP_UNUSED voidpf opaque, ZIP_UNUSED voidpf stream) +{ + /* Even with grow = 1, caller must always free() memory */ + return 0; +} + +int ZCALLBACK ferror_mem_func(ZIP_UNUSED voidpf opaque, ZIP_UNUSED voidpf stream) +{ + /* We never return errors */ + return 0; +} + +void fill_memory_filefunc(zlib_filefunc_def *pzlib_filefunc_def, ourmemory_t *ourmem) +{ + pzlib_filefunc_def->zopen_file = fopen_mem_func; + pzlib_filefunc_def->zopendisk_file = fopendisk_mem_func; + pzlib_filefunc_def->zread_file = fread_mem_func; + pzlib_filefunc_def->zwrite_file = fwrite_mem_func; + pzlib_filefunc_def->ztell_file = ftell_mem_func; + pzlib_filefunc_def->zseek_file = fseek_mem_func; + pzlib_filefunc_def->zclose_file = fclose_mem_func; + pzlib_filefunc_def->zerror_file = ferror_mem_func; + pzlib_filefunc_def->opaque = ourmem; +} diff --git a/vendor/zip/ioapi_mem.h b/vendor/zip/ioapi_mem.h new file mode 100644 index 0000000000..7061d6fae5 --- /dev/null +++ b/vendor/zip/ioapi_mem.h @@ -0,0 +1,52 @@ +/* ioapi_mem.h -- IO base function header for compress/uncompress .zip + files using zlib + zip or unzip API + + This version of ioapi is designed to access memory rather than files. + We do use a region of memory to put data in to and take it out of. + + Copyright (C) 2012-2017 Nathan Moinvaziri (https://github.com/nmoinvaz/minizip) + (C) 2003 Justin Fletcher + (C) 1998-2003 Gilles Vollant + + 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 _IOAPI_MEM_H +#define _IOAPI_MEM_H + +#include +#include +#include + +#include "zlib.h" +#include "ioapi.h" + +#ifdef __cplusplus +extern "C" { +#endif + +voidpf ZCALLBACK fopen_mem_func(voidpf opaque, const char* filename, int mode); +voidpf ZCALLBACK fopendisk_mem_func(voidpf opaque, voidpf stream, uint32_t number_disk, int mode); +uint32_t ZCALLBACK fread_mem_func(voidpf opaque, voidpf stream, void* buf, uint32_t size); +uint32_t ZCALLBACK fwrite_mem_func(voidpf opaque, voidpf stream, const void* buf, uint32_t size); +long ZCALLBACK ftell_mem_func(voidpf opaque, voidpf stream); +long ZCALLBACK fseek_mem_func(voidpf opaque, voidpf stream, uint32_t offset, int origin); +int ZCALLBACK fclose_mem_func(voidpf opaque, voidpf stream); +int ZCALLBACK ferror_mem_func(voidpf opaque, voidpf stream); + +typedef struct ourmemory_s { + char *base; /* Base of the region of memory we're using */ + uint32_t size; /* Size of the region of memory we're using */ + uint32_t limit; /* Furthest we've written */ + uint32_t cur_offset; /* Current offset in the area */ + int grow; /* Growable memory buffer */ +} ourmemory_t; + +void fill_memory_filefunc(zlib_filefunc_def* pzlib_filefunc_def, ourmemory_t *ourmem); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/vendor/zip/iowin32.c b/vendor/zip/iowin32.c index a9b5f78399..91d9e819dc 100644 --- a/vendor/zip/iowin32.c +++ b/vendor/zip/iowin32.c @@ -1,270 +1,587 @@ /* iowin32.c -- IO base function header for compress/uncompress .zip - files using zlib + zip or unzip API - This IO API version uses the Win32 API (for Microsoft Windows) - - Version 1.01e, February 12th, 2005 - - Copyright (C) 1998-2005 Gilles Vollant + 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. */ #include +#include #include "zlib.h" #include "ioapi.h" #include "iowin32.h" #ifndef INVALID_HANDLE_VALUE -#define INVALID_HANDLE_VALUE (0xFFFFFFFF) +# define INVALID_HANDLE_VALUE (0xFFFFFFFF) #endif #ifndef INVALID_SET_FILE_POINTER -#define INVALID_SET_FILE_POINTER ((DWORD)-1) +# define INVALID_SET_FILE_POINTER ((DWORD)-1) #endif -voidpf ZCALLBACK win32_open_file_func OF(( - voidpf opaque, - const char* filename, - int mode)); - -uLong ZCALLBACK win32_read_file_func OF(( - voidpf opaque, - voidpf stream, - void* buf, - uLong size)); - -uLong ZCALLBACK win32_write_file_func OF(( - voidpf opaque, - voidpf stream, - const void* buf, - uLong size)); - -long ZCALLBACK win32_tell_file_func OF(( - voidpf opaque, - voidpf stream)); - -long ZCALLBACK win32_seek_file_func OF(( - voidpf opaque, - voidpf stream, - uLong offset, - int origin)); - -int ZCALLBACK win32_close_file_func OF(( - voidpf opaque, - voidpf stream)); - -int ZCALLBACK win32_error_file_func OF(( - voidpf opaque, - voidpf stream)); +#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; -voidpf ZCALLBACK win32_open_file_func (opaque, filename, mode) - voidpf opaque; - const char* filename; - int mode; + +static void win32_translate_open_mode(int mode, + DWORD* lpdwDesiredAccess, + DWORD* lpdwCreationDisposition, + DWORD* lpdwShareMode, + DWORD* lpdwFlagsAndAttributes) { - const char* mode_fopen = NULL; - DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ; - HANDLE hFile = 0; - voidpf ret=NULL; + *lpdwDesiredAccess = 0; + *lpdwShareMode = 0; + *lpdwCreationDisposition = 0; + *lpdwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL; - dwDesiredAccess = dwShareMode = dwFlagsAndAttributes = 0; + 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; + } +} - if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ) +static voidpf win32_build_iowin(HANDLE hFile) +{ + WIN32FILE_IOWIN *iowin = NULL; + + if ((hFile != NULL) && (hFile != INVALID_HANDLE_VALUE)) { - dwDesiredAccess = GENERIC_READ; - dwCreationDisposition = OPEN_EXISTING; - dwShareMode = FILE_SHARE_READ; + iowin = (WIN32FILE_IOWIN *)malloc(sizeof(WIN32FILE_IOWIN)); + if (iowin == NULL) + { + CloseHandle(hFile); + return NULL; + } + memset(iowin, 0, sizeof(WIN32FILE_IOWIN)); + iowin->hf = hFile; } - else - if (mode & ZLIB_FILEFUNC_MODE_EXISTING) + return (voidpf)iowin; +} + +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)) { - dwDesiredAccess = GENERIC_WRITE | GENERIC_READ; - dwCreationDisposition = OPEN_EXISTING; +#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 } - else - if (mode & ZLIB_FILEFUNC_MODE_CREATE) + + 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; +} + +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)) { - dwDesiredAccess = GENERIC_WRITE | GENERIC_READ; - dwCreationDisposition = CREATE_ALWAYS; +#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 } - if ((filename!=NULL) && (dwDesiredAccess != 0)) - hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, - dwCreationDisposition, dwFlagsAndAttributes, NULL); + 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; +} - if (hFile == INVALID_HANDLE_VALUE) - hFile = NULL; +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; - if (hFile != NULL) + win32_translate_open_mode(mode, &dwDesiredAccess, &dwCreationDisposition, &dwShareMode, &dwFlagsAndAttributes); + + if ((filename != NULL) && (dwDesiredAccess != 0)) { - WIN32FILE_IOWIN w32fiow; - w32fiow.hf = hFile; - w32fiow.error = 0; - ret = malloc(sizeof(WIN32FILE_IOWIN)); - if (ret==NULL) - CloseHandle(hFile); - else *((WIN32FILE_IOWIN*)ret) = w32fiow; +#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; +} + +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; +} + +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; } +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; +} -uLong ZCALLBACK win32_read_file_func (opaque, stream, buf, size) - voidpf opaque; - voidpf stream; - void* buf; - uLong size; +voidpf ZCALLBACK win32_opendisk_file_func(voidpf opaque, voidpf stream, uint32_t number_disk, int mode) { - uLong ret=0; + 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 (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; + ((WIN32FILE_IOWIN*)stream)->error = (int)dwErr; } + } - return ret; + return (uint32_t)ret; } - -uLong ZCALLBACK win32_write_file_func (opaque, stream, buf, size) - voidpf opaque; - voidpf stream; - const void* buf; - uLong size; +uint32_t ZCALLBACK win32_write_file_func(voidpf opaque, voidpf stream, const void *buf, uint32_t size) { - uLong ret=0; + DWORD ret = 0; HANDLE hFile = NULL; - if (stream!=NULL) - hFile = ((WIN32FILE_IOWIN*)stream) -> hf; + if (stream != NULL) + hFile = ((WIN32FILE_IOWIN*)stream)->hf; - if (hFile !=NULL) + 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; + ((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 } -long ZCALLBACK win32_tell_file_func (opaque, stream) - voidpf opaque; - voidpf stream; +long ZCALLBACK win32_tell_file_func(voidpf opaque, voidpf stream) { - long ret=-1; + long ret = -1; HANDLE hFile = NULL; - if (stream!=NULL) - hFile = ((WIN32FILE_IOWIN*)stream) -> hf; + if (stream != NULL) + hFile = ((WIN32FILE_IOWIN*)stream)->hf; if (hFile != NULL) { - DWORD dwSet = SetFilePointer(hFile, 0, NULL, FILE_CURRENT); - if (dwSet == INVALID_SET_FILE_POINTER) + LARGE_INTEGER pos; + pos.QuadPart = 0; + if (!win32_setfilepointer_internal(hFile, pos, &pos, FILE_CURRENT)) { DWORD dwErr = GetLastError(); - ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; + ((WIN32FILE_IOWIN*)stream)->error = (int)dwErr; ret = -1; } else - ret=(long)dwSet; + 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; } -long ZCALLBACK win32_seek_file_func (opaque, stream, offset, origin) - voidpf opaque; - voidpf stream; - uLong offset; - int origin; +long ZCALLBACK win32_seek_file_func(voidpf opaque, voidpf stream, uint32_t offset, int origin) { - DWORD dwMoveMethod=0xFFFFFFFF; + DWORD dwMoveMethod = 0xFFFFFFFF; HANDLE hFile = NULL; + long ret = -1; + + if (stream != NULL) + hFile = ((WIN32FILE_IOWIN*)stream)->hf; - 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; + 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) { - DWORD dwSet = SetFilePointer(hFile, offset, NULL, dwMoveMethod); - if (dwSet == INVALID_SET_FILE_POINTER) + LARGE_INTEGER pos; + pos.QuadPart = offset; + if (!win32_setfilepointer_internal(hFile, pos, NULL, dwMoveMethod)) { DWORD dwErr = GetLastError(); - ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr; + ((WIN32FILE_IOWIN*)stream)->error = (int)dwErr; ret = -1; } else - ret=0; + ret = 0; } return ret; } -int ZCALLBACK win32_close_file_func (opaque, stream) - voidpf opaque; - voidpf stream; +long ZCALLBACK win32_seek64_file_func(voidpf opaque, voidpf stream, uint64_t offset, int origin) { - int ret=-1; + DWORD dwMoveMethod = 0xFFFFFFFF; + HANDLE hFile = NULL; + long ret = -1; + + if (stream != NULL) + hFile = ((WIN32FILE_IOWIN*)stream)->hf; - if (stream!=NULL) + switch (origin) { - HANDLE hFile; - hFile = ((WIN32FILE_IOWIN*)stream) -> hf; - if (hFile != NULL) + 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)) { - CloseHandle(hFile); - ret=0; + DWORD dwErr = GetLastError(); + ((WIN32FILE_IOWIN*)stream)->error = (int)dwErr; + ret = -1; } - free(stream); + else + ret = 0; } return ret; } -int ZCALLBACK win32_error_file_func (opaque, stream) - voidpf opaque; - voidpf stream; +int ZCALLBACK win32_close_file_func(voidpf opaque, voidpf stream) { - int ret=-1; - if (stream!=NULL) + 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) { - ret = ((WIN32FILE_IOWIN*)stream) -> error; + CloseHandle(iowin->hf); + ret=0; } + free(stream); return ret; } -void fill_win32_filefunc (pzlib_filefunc_def) - zlib_filefunc_def* pzlib_filefunc_def; +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; + 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; } diff --git a/vendor/zip/iowin32.h b/vendor/zip/iowin32.h index a3a437adf8..7ce4fc9f35 100644 --- a/vendor/zip/iowin32.h +++ b/vendor/zip/iowin32.h @@ -1,21 +1,35 @@ /* iowin32.h -- IO base function header for compress/uncompress .zip - files using zlib + zip or unzip API - This IO API version uses the Win32 API (for Microsoft Windows) + Version 1.2.0, September 16th, 2017 + part of the MiniZip project - Version 1.01e, February 12th, 2005 + 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 - Copyright (C) 1998-2005 Gilles Vollant + 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 +#ifndef _IOWIN32_H +#define _IOWIN32_H +#include #ifdef __cplusplus extern "C" { #endif -void fill_win32_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def)); +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/vendor/zip/unzip.c b/vendor/zip/unzip.c index 9ad4766d8d..b4cbd05cee 100644 --- a/vendor/zip/unzip.c +++ b/vendor/zip/unzip.c @@ -1,1041 +1,1028 @@ /* unzip.c -- IO for uncompress .zip files using zlib - Version 1.01e, February 12th, 2005 - - Copyright (C) 1998-2005 Gilles Vollant - - Read unzip.h for more info -*/ - -/* Decryption code comes from crypt.c by Info-ZIP but has been greatly reduced in terms of -compatibility with older software. The following is from the original crypt.c. Code -woven in by Terry Thorsen 1/2003. + 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. */ -/* - Copyright (c) 1990-2000 Info-ZIP. All rights reserved. - - See the accompanying file LICENSE, version 2000-Apr-09 or later - (the contents of which are also included in zip.h) for terms of use. - If, for some reason, all these files are missing, the Info-ZIP license - also may be found at: ftp://ftp.info-zip.org/pub/infozip/license.html -*/ -/* - crypt.c (full version) by Info-ZIP. Last revised: [see crypt.h] - - The encryption/decryption parts of this source code (as opposed to the - non-echoing password parts) were originally written in Europe. The - whole source package can be freely distributed, including from the USA. - (Prior to January 2000, re-export from the US was a violation of US law.) - */ - -/* - This encryption code is a direct transcription of the algorithm from - Roger Schlafly, described by Phil Katz in the file appnote.txt. This - file (appnote.txt) is distributed with the PKZIP program (even in the - version without encryption capabilities). - */ - #include #include +#include #include +#include +#include + #include "zlib.h" #include "unzip.h" -#ifdef STDC -# include -# include -# include +#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 NO_ERRNO_H - extern int errno; -#else -# include +#ifdef HAVE_APPLE_COMPRESSION +# include #endif - -#ifndef local -# define local static +#ifndef NOUNCRYPT +# include "crypt.h" #endif -/* compile with -Dlocal if your debugger can't find static symbols */ +#define DISKHEADERMAGIC (0x08074b50) +#define LOCALHEADERMAGIC (0x04034b50) +#define CENTRALHEADERMAGIC (0x02014b50) +#define ENDHEADERMAGIC (0x06054b50) +#define ZIP64ENDHEADERMAGIC (0x06064b50) +#define ZIP64ENDLOCHEADERMAGIC (0x07064b50) -#ifndef CASESENSITIVITYDEFAULT_NO -# if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES) -# define CASESENSITIVITYDEFAULT_NO -# endif -#endif +#define SIZECENTRALDIRITEM (0x2e) +#define SIZECENTRALHEADERLOCATOR (0x14) +#define SIZEZIPLOCALHEADER (0x1e) +#ifndef BUFREADCOMMENT +# define BUFREADCOMMENT (0x400) +#endif #ifndef UNZ_BUFSIZE -#define UNZ_BUFSIZE (16384) +# define UNZ_BUFSIZE (UINT16_MAX) #endif - #ifndef UNZ_MAXFILENAMEINZIP -#define UNZ_MAXFILENAMEINZIP (256) +# define UNZ_MAXFILENAMEINZIP (256) #endif #ifndef ALLOC -# define ALLOC(size) (malloc(size)) +# define ALLOC(size) (malloc(size)) #endif #ifndef TRYFREE -# define TRYFREE(p) {if (p) free(p);} +# define TRYFREE(p) {if (p) free(p);} #endif -#define SIZECENTRALDIRITEM (0x2e) -#define SIZEZIPLOCALHEADER (0x1e) - - - +const char unz_copyright[] = " unzip 1.2.0 Copyright 1998-2017 - https://github.com/nmoinvaz/minizip"; -const char unz_copyright[] = - " unzip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll"; - -/* unz_file_info_interntal contain internal info about a file in zipfile*/ -typedef struct unz_file_info_internal_s +/* unz_file_info_internal contain internal info about a file in zipfile*/ +typedef struct unz_file_info64_internal_s { - uLong offset_curfile;/* relative offset of local header 4 bytes */ -} unz_file_info_internal; - + 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, - when reading and decompress it */ +/* file_in_zip_read_info_s contain internal information about a file in zipfile */ typedef struct { - char *read_buffer; /* internal buffer for compressed data */ - z_stream stream; /* zLib stream structure for inflate */ + 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 */ - uLong pos_in_zipfile; /* position in byte on the zipfile, for fseek*/ - uLong 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; - uLong offset_local_extrafield;/* offset of the local extra field */ - uInt size_local_extrafield;/* size of the local extra field */ - uLong pos_local_extrafield; /* position in the local extra field in read*/ + 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 */ - uLong crc32; /* crc32 of all data uncompressed */ - uLong crc32_wait; /* crc32 we must obtain after decompress all */ - uLong rest_read_compressed; /* number of byte to be decompressed */ - uLong rest_read_uncompressed;/*number of byte to be obtained after decomp*/ - zlib_filefunc_def z_filefunc; - voidpf filestream; /* io structore of the zipfile */ - uLong compression_method; /* compression method (0==store) */ - uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/ - int raw; -} file_in_zip_read_info_s; + 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; -/* unz_s contain internal information about the zipfile -*/ +/* unz64_s contain internal information about the zipfile */ typedef struct { - zlib_filefunc_def z_filefunc; - voidpf filestream; /* io structore of the zipfile */ - unz_global_info gi; /* public global information */ - uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/ - uLong num_file; /* number of the current file in the zipfile*/ - uLong pos_in_central_dir; /* pos of the current file in the central dir*/ - uLong current_file_ok; /* flag about the usability of the current file*/ - uLong central_pos; /* position of the beginning of the central dir*/ - - uLong size_central_dir; /* size of the central directory */ - uLong offset_central_dir; /* offset of start of central directory with - respect to the starting disk number */ - - unz_file_info cur_file_info; /* public info about the current file in zip*/ - unz_file_info_internal cur_file_info_internal; /* private info about it*/ - file_in_zip_read_info_s* pfile_in_zip_read; /* structure about the current - file if we are decompressing it */ - int encrypted; -# ifndef NOUNCRYPT - unsigned long keys[3]; /* keys defining the pseudo-random sequence */ - const unsigned long* pcrc_32_tab; -# endif -} unz_s; - - + 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 -#include "crypt.h" + 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; update next_in and avail_in. Return EOF - for end of file. - IN assertion: the stream s has been sucessfully opened for reading. -*/ - - -local int unzlocal_getByte OF(( - const zlib_filefunc_def* pzlib_filefunc_def, - voidpf filestream, - int *pi)); - -local int unzlocal_getByte(pzlib_filefunc_def,filestream,pi) - const zlib_filefunc_def* pzlib_filefunc_def; - voidpf filestream; - int *pi; +/* 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) { - unsigned char c; - int err = (int)ZREAD(*pzlib_filefunc_def,filestream,&c,1); - if (err==1) + uint8_t c = 0; + if (ZREAD64(*pzlib_filefunc_def, filestream, &c, 1) == 1) { - *pi = (int)c; + *value = (uint8_t)c; return UNZ_OK; } - else - { - if (ZERROR(*pzlib_filefunc_def,filestream)) - return UNZ_ERRNO; - else - return UNZ_EOF; - } + *value = 0; + if (ZERROR64(*pzlib_filefunc_def, filestream)) + return UNZ_ERRNO; + return UNZ_EOF; } - -/* =========================================================================== - Reads a long in LSB order from the given gz_stream. Sets -*/ -local int unzlocal_getShort OF(( - const zlib_filefunc_def* pzlib_filefunc_def, - voidpf filestream, - uLong *pX)); - -local int unzlocal_getShort (pzlib_filefunc_def,filestream,pX) - const zlib_filefunc_def* pzlib_filefunc_def; - voidpf filestream; - uLong *pX; +static int unzReadUInt16(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, uint16_t *value) { - uLong x ; - int i; - int err; - - err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i); - x = (uLong)i; - - if (err==UNZ_OK) - err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i); - x += ((uLong)i)<<8; - - if (err==UNZ_OK) - *pX = x; + 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 - *pX = 0; + *value = 0; return err; } -local int unzlocal_getLong OF(( - const zlib_filefunc_def* pzlib_filefunc_def, - voidpf filestream, - uLong *pX)); - -local int unzlocal_getLong (pzlib_filefunc_def,filestream,pX) - const zlib_filefunc_def* pzlib_filefunc_def; - voidpf filestream; - uLong *pX; +static int unzReadUInt32(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, uint32_t *value) { - uLong x ; - int i; - int err; - - err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i); - x = (uLong)i; - - if (err==UNZ_OK) - err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i); - x += ((uLong)i)<<8; - - if (err==UNZ_OK) - err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i); - x += ((uLong)i)<<16; - - if (err==UNZ_OK) - err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i); - x += ((uLong)i)<<24; - - if (err==UNZ_OK) - *pX = x; + 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 - *pX = 0; + *value = 0; return err; } - -/* My own strcmpi / strcasecmp */ -local int strcmpcasenosensitive_internal (fileName1,fileName2) - const char* fileName1; - const char* fileName2; -{ - for (;;) - { - char c1=*(fileName1++); - char c2=*(fileName2++); - if ((c1>='a') && (c1<='z')) - c1 -= 0x20; - if ((c2>='a') && (c2<='z')) - c2 -= 0x20; - if (c1=='\0') - return ((c2=='\0') ? 0 : -1); - if (c2=='\0') - return 1; - if (c1c2) - return 1; - } -} - - -#ifdef CASESENSITIVITYDEFAULT_NO -#define CASESENSITIVITYDEFAULTVALUE 2 -#else -#define CASESENSITIVITYDEFAULTVALUE 1 -#endif - -#ifndef STRCMPCASENOSENTIVEFUNCTION -#define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal -#endif - -/* - Compare two filename (fileName1,fileName2). - If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp) - If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi - or strcasecmp) - If iCaseSenisivity = 0, case sensitivity is defaut of your operating system - (like 1 on Unix, 2 on Windows) - -*/ -extern int ZEXPORT unzStringFileNameCompare (fileName1,fileName2,iCaseSensitivity) - const char* fileName1; - const char* fileName2; - int iCaseSensitivity; +static int unzReadUInt64(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, uint64_t *value) { - if (iCaseSensitivity==0) - iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE; - - if (iCaseSensitivity==1) - return strcmp(fileName1,fileName2); - - return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2); + 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; } -#ifndef BUFREADCOMMENT -#define BUFREADCOMMENT (0x400) -#endif - -/* - Locate the Central directory of a zipfile (at the end, just before - the global comment) -*/ -local uLong unzlocal_SearchCentralDir OF(( - const zlib_filefunc_def* pzlib_filefunc_def, - voidpf filestream)); - -local uLong unzlocal_SearchCentralDir(pzlib_filefunc_def,filestream) - const zlib_filefunc_def* pzlib_filefunc_def; - voidpf filestream; +/* 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) { - unsigned char* buf; - uLong uSizeFile; - uLong uBackRead; - uLong uMaxBack=0xffff; /* maximum size of global comment */ - uLong uPosFound=0; - - if (ZSEEK(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0) - return 0; - - - uSizeFile = ZTELL(*pzlib_filefunc_def,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; - if (uMaxBack>uSizeFile) - uMaxBack = uSizeFile; + file_size = ZTELL64(*pzlib_filefunc_def, filestream); - buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4); - if (buf==NULL) - return 0; + if (max_back > file_size) + max_back = file_size; - uBackRead = 4; - while (uBackReaduMaxBack) - uBackRead = uMaxBack; + if (back_read + BUFREADCOMMENT > max_back) + back_read = max_back; else - uBackRead+=BUFREADCOMMENT; - uReadPos = uSizeFile-uBackRead ; + back_read += BUFREADCOMMENT; - uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ? - (BUFREADCOMMENT+4) : (uSizeFile-uReadPos); - if (ZSEEK(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0) - break; + read_pos = file_size - back_read; + read_size = ((BUFREADCOMMENT + 4) < (file_size - read_pos)) ? + (BUFREADCOMMENT + 4) : (uint32_t)(file_size - read_pos); - if (ZREAD(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize) + if (ZSEEK64(*pzlib_filefunc_def, filestream, read_pos, ZLIB_FILEFUNC_SEEK_SET) != 0) + break; + if (ZREAD64(*pzlib_filefunc_def, filestream, buf, read_size) != read_size) break; - for (i=(int)uReadSize-3; (i--)>0;) - if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && - ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06)) + 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))) { - uPosFound = uReadPos+i; - break; + *pos_found = read_pos+i; + return UNZ_OK; } - - if (uPosFound!=0) - break; } - TRYFREE(buf); - return uPosFound; + + return UNZ_ERRNO; } -/* - Open a Zip file. path contain the full pathname (by example, - on a Windows NT computer "c:\\test\\zlib114.zip" or on an Unix computer - "zlib/zlib114.zip". - If the zipfile cannot be opened (file doesn't exist or in not valid), the - return value is NULL. - Else, the return value is a unzFile Handle, usable with other function - of this unzip package. -*/ -extern unzFile ZEXPORT unzOpen2 (path, pzlib_filefunc_def) - const char *path; - zlib_filefunc_def* pzlib_filefunc_def; +/* 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) { - unz_s us; - unz_s *s; - uLong central_pos,uL; + uint32_t value32 = 0; + *offset = 0; - uLong number_disk; /* number of the current dist, used for - spaning ZIP, unsupported, always 0*/ - uLong number_disk_with_CD; /* number the the disk with central dir, used - for spaning ZIP, unsupported, always 0*/ - uLong number_entry_CD; /* total number of entries in - the central dir - (same than number_entry on nospan) */ + /* Zip64 end of central directory locator */ + if (ZSEEK64(*pzlib_filefunc_def, filestream, endcentraloffset - SIZECENTRALHEADERLOCATOR, ZLIB_FILEFUNC_SEEK_SET) != 0) + return UNZ_ERRNO; - int err=UNZ_OK; + /* 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; - if (unz_copyright[0]!=' ') - return NULL; + return UNZ_OK; +} - if (pzlib_filefunc_def==NULL) - fill_fopen_filefunc(&us.z_filefunc); +static unzFile unzOpenInternal(const void *path, zlib_filefunc64_32_def *pzlib_filefunc64_32_def) +{ + unz64_internal us; + 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; + + us.filestream = NULL; + us.filestream_with_CD = NULL; + us.z_filefunc.zseek32_file = NULL; + us.z_filefunc.ztell32_file = NULL; + + if (pzlib_filefunc64_32_def == NULL) + fill_fopen64_filefunc(&us.z_filefunc.zfile_func64); else - us.z_filefunc = *pzlib_filefunc_def; - - us.filestream= (*(us.z_filefunc.zopen_file))(us.z_filefunc.opaque, - path, - ZLIB_FILEFUNC_MODE_READ | - ZLIB_FILEFUNC_MODE_EXISTING); - if (us.filestream==NULL) - return NULL; - - central_pos = unzlocal_SearchCentralDir(&us.z_filefunc,us.filestream); - if (central_pos==0) - err=UNZ_ERRNO; - - if (ZSEEK(us.z_filefunc, us.filestream, - central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0) - err=UNZ_ERRNO; - - /* the signature, already checked */ - if (unzlocal_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK) - err=UNZ_ERRNO; + us.z_filefunc = *pzlib_filefunc64_32_def; - /* number of this disk */ - if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK) - err=UNZ_ERRNO; + us.filestream = ZOPEN64(us.z_filefunc, path, ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_EXISTING); - /* number of the disk with the start of the central directory */ - if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK) - err=UNZ_ERRNO; - - /* total number of entries in the central dir on this disk */ - if (unzlocal_getShort(&us.z_filefunc, us.filestream,&us.gi.number_entry)!=UNZ_OK) - err=UNZ_ERRNO; - - /* total number of entries in the central dir */ - if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_entry_CD)!=UNZ_OK) - err=UNZ_ERRNO; - - if ((number_entry_CD!=us.gi.number_entry) || - (number_disk_with_CD!=0) || - (number_disk!=0)) - err=UNZ_BADZIPFILE; + if (us.filestream == NULL) + return NULL; - /* size of the central directory */ - if (unzlocal_getLong(&us.z_filefunc, us.filestream,&us.size_central_dir)!=UNZ_OK) - err=UNZ_ERRNO; + us.filestream_with_CD = us.filestream; + us.is_zip64 = 0; - /* offset of start of central directory with respect to the - starting disk number */ - if (unzlocal_getLong(&us.z_filefunc, us.filestream,&us.offset_central_dir)!=UNZ_OK) - err=UNZ_ERRNO; + /* 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; - /* zipfile comment length */ - if (unzlocal_getShort(&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 */ + int 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.gi.number_entry == UINT16_MAX) || (us.size_central_dir == UINT16_MAX) || (us.offset_central_dir == UINT32_MAX)) + err = UNZ_BADZIPFILE; + } + } + else + err = UNZ_ERRNO; - if ((central_pos 0xffffffff) && (us.offset_central_dir < 0xffffffff)) + us.offset_central_dir = central_pos - us.size_central_dir;*/ + + us.byte_before_the_zipfile = central_pos - (us.offset_central_dir + us.size_central_dir); us.central_pos = central_pos; us.pfile_in_zip_read = NULL; - us.encrypted = 0; - - s=(unz_s*)ALLOC(sizeof(unz_s)); - *s=us; - unzGoToFirstFile((unzFile)s); + s = (unz64_internal*)ALLOC(sizeof(unz64_internal)); + if (s != NULL) + { + *s = us; + unzGoToFirstFile((unzFile)s); + } return (unzFile)s; } - -extern unzFile ZEXPORT unzOpen (path) - const char *path; +extern unzFile ZEXPORT unzOpen2(const char *path, zlib_filefunc_def *pzlib_filefunc32_def) { - return unzOpen2(path, NULL); + if (pzlib_filefunc32_def != NULL) + { + zlib_filefunc64_32_def zlib_filefunc64_32_def_fill; + fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill, pzlib_filefunc32_def); + return unzOpenInternal(path, &zlib_filefunc64_32_def_fill); + } + return unzOpenInternal(path, NULL); } -/* - Close a ZipFile opened with unzipOpen. - If there is files inside the .Zip opened with unzipOpenCurrentFile (see later), - these files MUST be closed with unzipCloseCurrentFile before call unzipClose. - return UNZ_OK if there is no problem. */ -extern int ZEXPORT unzClose (file) - unzFile file; +extern unzFile ZEXPORT unzOpen2_64(const void *path, zlib_filefunc64_def *pzlib_filefunc_def) { - unz_s* s; - if (file==NULL) - return UNZ_PARAMERROR; - s=(unz_s*)file; - - if (s->pfile_in_zip_read!=NULL) - unzCloseCurrentFile(file); + if (pzlib_filefunc_def != NULL) + { + zlib_filefunc64_32_def zlib_filefunc64_32_def_fill; + zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def; + zlib_filefunc64_32_def_fill.ztell32_file = NULL; + zlib_filefunc64_32_def_fill.zseek32_file = NULL; + return unzOpenInternal(path, &zlib_filefunc64_32_def_fill); + } + return unzOpenInternal(path, NULL); +} - ZCLOSE(s->z_filefunc, s->filestream); - TRYFREE(s); - return UNZ_OK; +extern unzFile ZEXPORT unzOpen(const char *path) +{ + return unzOpenInternal(path, NULL); } +extern unzFile ZEXPORT unzOpen64(const void *path) +{ + return unzOpenInternal(path, NULL); +} -/* - Write info about the ZipFile in the *pglobal_info structure. - No preparation of the structure is needed - return UNZ_OK if there is no problem. */ -extern int ZEXPORT unzGetGlobalInfo (file,pglobal_info) - unzFile file; - unz_global_info *pglobal_info; +extern int ZEXPORT unzClose(unzFile file) { - unz_s* s; - if (file==NULL) + unz64_internal *s; + if (file == NULL) return UNZ_PARAMERROR; - s=(unz_s*)file; - *pglobal_info=s->gi; - return UNZ_OK; -} + s = (unz64_internal*)file; + if (s->pfile_in_zip_read != NULL) + unzCloseCurrentFile(file); -/* - Translate date/time from Dos format to tm_unz (readable more easilty) -*/ -local void unzlocal_DosDateToTmuDate (ulDosDate, ptm) - uLong ulDosDate; - tm_unz* ptm; -{ - uLong uDate; - uDate = (uLong)(ulDosDate>>16); - ptm->tm_mday = (uInt)(uDate&0x1f) ; - ptm->tm_mon = (uInt)((((uDate)&0x1E0)/0x20)-1) ; - ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ; - - ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800); - ptm->tm_min = (uInt) ((ulDosDate&0x7E0)/0x20) ; - ptm->tm_sec = (uInt) (2*(ulDosDate&0x1f)) ; + 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; } -/* - Get Info about the current file in the zipfile, with internal only info -*/ -local int unzlocal_GetCurrentFileInfoInternal OF((unzFile file, - unz_file_info *pfile_info, - unz_file_info_internal - *pfile_info_internal, - char *szFileName, - uLong fileNameBufferSize, - void *extraField, - uLong extraFieldBufferSize, - char *szComment, - uLong commentBufferSize)); - -local int unzlocal_GetCurrentFileInfoInternal (file, - pfile_info, - pfile_info_internal, - szFileName, fileNameBufferSize, - extraField, extraFieldBufferSize, - szComment, commentBufferSize) - unzFile file; - unz_file_info *pfile_info; - unz_file_info_internal *pfile_info_internal; - char *szFileName; - uLong fileNameBufferSize; - void *extraField; - uLong extraFieldBufferSize; - char *szComment; - uLong commentBufferSize; +/* Goto to the next available disk for spanned archives */ +static int unzGoToNextDisk(unzFile file) { - unz_s* s; - unz_file_info file_info; - unz_file_info_internal file_info_internal; - int err=UNZ_OK; - uLong uMagic; - long lSeek=0; - - if (file==NULL) - return UNZ_PARAMERROR; - s=(unz_s*)file; - if (ZSEEK(s->z_filefunc, s->filestream, - s->pos_in_central_dir+s->byte_before_the_zipfile, - ZLIB_FILEFUNC_SEEK_SET)!=0) - err=UNZ_ERRNO; + 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; - /* we check the magic */ - if (err==UNZ_OK) - if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK) - err=UNZ_ERRNO; - else if (uMagic!=0x02014b50) - err=UNZ_BADZIPFILE; + 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 (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.version) != UNZ_OK) - err=UNZ_ERRNO; + 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 (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.version_needed) != UNZ_OK) - err=UNZ_ERRNO; + 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 (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.flag) != UNZ_OK) - err=UNZ_ERRNO; + if (s->filestream == NULL) + return UNZ_ERRNO; - if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.compression_method) != UNZ_OK) - err=UNZ_ERRNO; + s->number_disk = number_disk_next; + } - if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.dosDate) != UNZ_OK) - err=UNZ_ERRNO; + return UNZ_OK; +} - unzlocal_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date); +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; - if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.crc) != UNZ_OK) - err=UNZ_ERRNO; + 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; +} - if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.compressed_size) != UNZ_OK) - err=UNZ_ERRNO; +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; +} - if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.uncompressed_size) != UNZ_OK) - err=UNZ_ERRNO; +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 (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_filename) != UNZ_OK) - err=UNZ_ERRNO; + if (bytes_to_read > s->gi.size_comment) + bytes_to_read = s->gi.size_comment; - if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_extra) != UNZ_OK) - err=UNZ_ERRNO; + if (ZSEEK64(s->z_filefunc, s->filestream_with_CD, s->central_pos + 22, ZLIB_FILEFUNC_SEEK_SET) != 0) + return UNZ_ERRNO; - if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_comment) != UNZ_OK) - err=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 (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.disk_num_start) != UNZ_OK) - err=UNZ_ERRNO; + if ((comment != NULL) && (comment_size > s->gi.size_comment)) + *(comment + s->gi.size_comment) = 0; - if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.internal_fa) != UNZ_OK) - err=UNZ_ERRNO; + return (int)bytes_to_read; +} - if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.external_fa) != UNZ_OK) - err=UNZ_ERRNO; +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 (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info_internal.offset_curfile) != UNZ_OK) - err=UNZ_ERRNO; + if (file == NULL) + return (int)UNZ_PARAMERROR; + s = (unz64_internal*)file; - lSeek+=file_info.size_filename; - if ((err==UNZ_OK) && (szFileName!=NULL)) + /* Read field */ + if (field != NULL) { - uLong uSizeRead ; - if (file_info.size_filename0) && (fileNameBufferSize>0)) - if (ZREAD(s->z_filefunc, s->filestream,szFileName,uSizeRead)!=uSizeRead) - err=UNZ_ERRNO; - lSeek -= uSizeRead; + 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; +} - if ((err==UNZ_OK) && (extraField!=NULL)) - { - uLong uSizeRead ; - if (file_info.size_file_extraz_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0) - lSeek=0; - else - err=UNZ_ERRNO; - if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0)) - if (ZREAD(s->z_filefunc, s->filestream,extraField,uSizeRead)!=uSizeRead) - err=UNZ_ERRNO; - lSeek += file_info.size_file_extra - uSizeRead; + 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; } - else - lSeek+=file_info.size_file_extra; + /* 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) && (szComment!=NULL)) + if ((err == UNZ_OK) && (file_info.size_file_extra != 0)) { - uLong uSizeRead ; - if (file_info.size_file_commentz_filefunc, s->filestream_with_CD, seek, ZLIB_FILEFUNC_SEEK_CUR) == 0) + seek = 0; + else + err = UNZ_ERRNO; } - else - uSizeRead = commentBufferSize; - if (lSeek!=0) - if (ZSEEK(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0) - lSeek=0; + /* 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 - err=UNZ_ERRNO; - if ((file_info.size_file_comment>0) && (commentBufferSize>0)) - if (ZREAD(s->z_filefunc, s->filestream,szComment,uSizeRead)!=uSizeRead) - err=UNZ_ERRNO; - lSeek+=file_info.size_file_comment - uSizeRead; + { + 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 - lSeek+=file_info.size_file_comment; + file_info_internal.byte_before_the_zipfile = 0; - if ((err==UNZ_OK) && (pfile_info!=NULL)) - *pfile_info=file_info; + if (err == UNZ_OK) + err = unzGetCurrentFileInfoField(file, &seek, comment, comment_size, file_info.size_file_comment, 1); - if ((err==UNZ_OK) && (pfile_info_internal!=NULL)) - *pfile_info_internal=file_info_internal; + 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); -/* - Write info about the ZipFile in the *pglobal_info structure. - No preparation of the structure is needed - return UNZ_OK if there is no problem. -*/ -extern int ZEXPORT unzGetCurrentFileInfo (file, - pfile_info, - szFileName, fileNameBufferSize, - extraField, extraFieldBufferSize, - szComment, commentBufferSize) - unzFile file; - unz_file_info *pfile_info; - char *szFileName; - uLong fileNameBufferSize; - void *extraField; - uLong extraFieldBufferSize; - char *szComment; - uLong commentBufferSize; -{ - return unzlocal_GetCurrentFileInfoInternal(file,pfile_info,NULL, - szFileName,fileNameBufferSize, - extraField,extraFieldBufferSize, - szComment,commentBufferSize); + 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; } -/* - Set the current file of the zipfile to the first file. - return UNZ_OK if there is no problem -*/ -extern int ZEXPORT unzGoToFirstFile (file) - unzFile file; +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) { - int err=UNZ_OK; - unz_s* s; - if (file==NULL) - return UNZ_PARAMERROR; - s=(unz_s*)file; - s->pos_in_central_dir=s->offset_central_dir; - s->num_file=0; - err=unzlocal_GetCurrentFileInfoInternal(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; + return unzGetCurrentFileInfoInternal(file, pfile_info, NULL, filename, filename_size, + extrafield, extrafield_size, comment,comment_size); } -/* - Set the current file of the zipfile to the next file. - return UNZ_OK if there is no problem - return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest. -*/ -extern int ZEXPORT unzGoToNextFile (file) - unzFile file; +/* 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) { - unz_s* s; - int err; - - if (file==NULL) + 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; - s=(unz_s*)file; - if (!s->current_file_ok) - return UNZ_END_OF_LIST_OF_FILE; - if (s->gi.number_entry != 0xffff) /* 2^16 files overflow hack */ - if (s->num_file+1==s->gi.number_entry) - return UNZ_END_OF_LIST_OF_FILE; + *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; - 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++; - err = unzlocal_GetCurrentFileInfoInternal(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; -} + 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; -/* - Try locate the file szFileName in the zipfile. - For the iCaseSensitivity signification, see unzipStringFileNameCompare + if (err == UNZ_OK) + { + if (unzReadUInt32(&s->z_filefunc, s->filestream, &magic) != UNZ_OK) + err = UNZ_ERRNO; + else if (magic != LOCALHEADERMAGIC) + err = UNZ_BADZIPFILE; + } - return value : - UNZ_OK if the file is found. It becomes the current file. - UNZ_END_OF_LIST_OF_FILE if the file is not found -*/ -extern int ZEXPORT unzLocateFile (file, szFileName, iCaseSensitivity) - unzFile file; - const char *szFileName; - int iCaseSensitivity; -{ - unz_s* s; - int err; - - /* We remember the 'current' position in the file so that we can jump - * back there if we fail. - */ - unz_file_info cur_file_infoSaved; - unz_file_info_internal cur_file_info_internalSaved; - uLong num_fileSaved; - uLong pos_in_central_dirSaved; - - - if (file==NULL) - return UNZ_PARAMERROR; - - if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP) - return UNZ_PARAMERROR; - - s=(unz_s*)file; - if (!s->current_file_ok) - return UNZ_END_OF_LIST_OF_FILE; - - /* Save the current state */ - num_fileSaved = s->num_file; - pos_in_central_dirSaved = s->pos_in_central_dir; - cur_file_infoSaved = s->cur_file_info; - cur_file_info_internalSaved = s->cur_file_info_internal; - - err = unzGoToFirstFile(file); + 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 - while (err == UNZ_OK) + if ((err == UNZ_OK) && (compression_method != 0) && (compression_method != Z_DEFLATED)) { - char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1]; - err = unzGetCurrentFileInfo(file,NULL, - szCurrentFileName,sizeof(szCurrentFileName)-1, - NULL,0,NULL,0); - if (err == UNZ_OK) - { - if (unzStringFileNameCompare(szCurrentFileName, - szFileName,iCaseSensitivity)==0) - return UNZ_OK; - err = unzGoToNextFile(file); - } +#ifdef HAVE_BZIP2 + if (compression_method != Z_BZIP2ED) +#endif + err = UNZ_BADZIPFILE; } - /* We failed, so restore the state of the 'current file' to where we - * were. - */ - s->num_file = num_fileSaved ; - s->pos_in_central_dir = pos_in_central_dirSaved ; - s->cur_file_info = cur_file_infoSaved; - s->cur_file_info_internal = cur_file_info_internalSaved; - return err; -} - - -/* -/////////////////////////////////////////// -// Contributed by Ryan Haksi (mailto://cryogen@infoserve.net) -// I need random access -// -// Further optimization could be realized by adding an ability -// to cache the directory in memory. The goal being a single -// comprehensive file read to put the file I need in a memory. -*/ - -/* -typedef struct unz_file_pos_s -{ - uLong pos_in_zip_directory; // offset in file - uLong num_of_file; // # of file -} unz_file_pos; -*/ - -extern int ZEXPORT unzGetFilePos(file, file_pos) - unzFile file; - unz_file_pos* file_pos; -{ - unz_s* s; - - if (file==NULL || file_pos==NULL) - return UNZ_PARAMERROR; - s=(unz_s*)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 unzGoToFilePos(file, file_pos) - unzFile file; - unz_file_pos* file_pos; -{ - unz_s* s; - int err; - - if (file==NULL || file_pos==NULL) - return UNZ_PARAMERROR; - s=(unz_s*)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 = unzlocal_GetCurrentFileInfoInternal(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; -} - -/* -// Unzip Helper Functions - should be here? -/////////////////////////////////////////// -*/ - -/* - 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) -*/ -local int unzlocal_CheckCurrentFileCoherencyHeader (s,piSizeVar, - poffset_local_extrafield, - psize_local_extrafield) - unz_s* s; - uInt* piSizeVar; - uLong *poffset_local_extrafield; - uInt *psize_local_extrafield; -{ - uLong uMagic,uData,uFlags; - uLong size_filename; - uLong size_extra_field; - int err=UNZ_OK; - - *piSizeVar = 0; - *poffset_local_extrafield = 0; - *psize_local_extrafield = 0; - - if (ZSEEK(s->z_filefunc, s->filestream,s->cur_file_info_internal.offset_curfile + - s->byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0) - return UNZ_ERRNO; - - - if (err==UNZ_OK) - if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK) - err=UNZ_ERRNO; - else if (uMagic!=0x04034b50) - err=UNZ_BADZIPFILE; - - if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) - err=UNZ_ERRNO; -/* - else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion)) - err=UNZ_BADZIPFILE; -*/ - if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uFlags) != UNZ_OK) - err=UNZ_ERRNO; - - if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) - err=UNZ_ERRNO; - else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method)) - err=UNZ_BADZIPFILE; - - if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) && - (s->cur_file_info.compression_method!=Z_DEFLATED)) - err=UNZ_BADZIPFILE; - - if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* date/time */ - err=UNZ_ERRNO; - - if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* crc */ - err=UNZ_ERRNO; - else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) && - ((uFlags & 8)==0)) - err=UNZ_BADZIPFILE; - - if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size compr */ - err=UNZ_ERRNO; - else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) && - ((uFlags & 8)==0)) - err=UNZ_BADZIPFILE; - - if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size uncompr */ - err=UNZ_ERRNO; - else if ((err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) && - ((uFlags & 8)==0)) - err=UNZ_BADZIPFILE; - - - if (unzlocal_getShort(&s->z_filefunc, s->filestream,&size_filename) != UNZ_OK) - err=UNZ_ERRNO; - else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename)) - err=UNZ_BADZIPFILE; - - *piSizeVar += (uInt)size_filename; - - if (unzlocal_getShort(&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 = (uInt)size_extra_field; - - *piSizeVar += (uInt)size_extra_field; + 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; } @@ -1044,62 +1031,49 @@ local int unzlocal_CheckCurrentFileCoherencyHeader (s,piSizeVar, 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 (file, method, level, raw, password) - unzFile file; - int* method; - int* level; - int raw; - const char* password; +extern int ZEXPORT unzOpenCurrentFile3(unzFile file, int *method, int *level, int raw, const char *password) { - int err=UNZ_OK; - uInt iSizeVar; - unz_s* s; - file_in_zip_read_info_s* pfile_in_zip_read_info; - uLong offset_local_extrafield; /* offset of the local extra field */ - uInt size_local_extrafield; /* size of the local extra field */ -# ifndef NOUNCRYPT + 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 +#else if (password != NULL) return UNZ_PARAMERROR; -# endif - - if (file==NULL) +#endif + if (file == NULL) return UNZ_PARAMERROR; - s=(unz_s*)file; + s = (unz64_internal*)file; if (!s->current_file_ok) return UNZ_PARAMERROR; if (s->pfile_in_zip_read != NULL) unzCloseCurrentFile(file); - if (unzlocal_CheckCurrentFileCoherencyHeader(s,&iSizeVar, - &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK) + if (unzCheckCurrentFileCoherencyHeader(s, &size_variable, &offset_local_extrafield, &size_local_extrafield) != UNZ_OK) return UNZ_BADZIPFILE; - - pfile_in_zip_read_info = (file_in_zip_read_info_s*) - ALLOC(sizeof(file_in_zip_read_info_s)); - if (pfile_in_zip_read_info==NULL) - return UNZ_INTERNALERROR; - - pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE); - 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->raw=raw; - - if (pfile_in_zip_read_info->read_buffer==NULL) + + compression_method = s->cur_file_info.compression_method; +#ifdef HAVE_AES + if (compression_method == AES_METHOD) { - TRYFREE(pfile_in_zip_read_info); - return UNZ_INTERNALERROR; + compression_method = s->cur_file_info_internal.aes_compression_method; + if (password == NULL) + { + return UNZ_PARAMERROR; + } } +#endif - pfile_in_zip_read_info->stream_initialised=0; - - if (method!=NULL) - *method = (int)s->cur_file_info.compression_method; + if (method != NULL) + *method = compression_method; - if (level!=NULL) + if (level != NULL) { *level = 6; switch (s->cur_file_info.flag & 0x06) @@ -1110,238 +1084,447 @@ extern int ZEXPORT unzOpenCurrentFile3 (file, method, level, raw, password) } } - if ((s->cur_file_info.compression_method!=0) && - (s->cur_file_info.compression_method!=Z_DEFLATED)) - err=UNZ_BADZIPFILE; - - pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc; - pfile_in_zip_read_info->crc32=0; - pfile_in_zip_read_info->compression_method = - s->cur_file_info.compression_method; - pfile_in_zip_read_info->filestream=s->filestream; - pfile_in_zip_read_info->z_filefunc=s->z_filefunc; - pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile; - - pfile_in_zip_read_info->stream.total_out = 0; + 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; - if ((s->cur_file_info.compression_method==Z_DEFLATED) && - (!raw)) + pfile_in_zip_read_info->read_buffer = (uint8_t*)ALLOC(UNZ_BUFSIZE); + if (pfile_in_zip_read_info->read_buffer == NULL) { - 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)0; - pfile_in_zip_read_info->stream.next_in = (voidpf)0; - pfile_in_zip_read_info->stream.avail_in = 0; - - err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS); - if (err == Z_OK) - pfile_in_zip_read_info->stream_initialised=1; - 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 - */ + return UNZ_INTERNALERROR; } - 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->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; - pfile_in_zip_read_info->pos_in_zipfile = - s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER + - iSizeVar; + 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.avail_in = (uInt)0; + 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 - if (password != NULL) +#ifndef NOUNCRYPT + s->pcrc_32_tab = NULL; + + if ((password != NULL) && ((s->cur_file_info.flag & 1) != 0)) { - int i; - s->pcrc_32_tab = get_crc_table(); - init_keys(password,s->keys,s->pcrc_32_tab); - if (ZSEEK(s->z_filefunc, s->filestream, - s->pfile_in_zip_read->pos_in_zipfile + - s->pfile_in_zip_read->byte_before_the_zipfile, - SEEK_SET)!=0) - return UNZ_INTERNALERROR; - if(ZREAD(s->z_filefunc, s->filestream,source, 12)<12) + 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; - for (i = 0; i<12; i++) - zdecode(s->keys,s->pcrc_32_tab,source[i]); + if ((s->cur_file_info_internal.aes_encryption_mode < 1) || + (s->cur_file_info_internal.aes_encryption_mode > 3)) + return UNZ_INTERNALERROR; - s->pfile_in_zip_read->pos_in_zipfile+=12; - s->encrypted=1; - } -# endif + 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; + uint8_t expected; + uint8_t actual; + + 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]); + expected = (s->cur_file_info.flag & (1 << 3)) ? + s->cur_file_info.dos_date >> 8 : + s->cur_file_info.crc >> 24; + actual = (uint8_t)source[11]; + if ((actual != 0) && (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 (file) - unzFile file; +extern int ZEXPORT unzOpenCurrentFile(unzFile file) { return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL); } -extern int ZEXPORT unzOpenCurrentFilePassword (file, password) - unzFile file; - const char* password; +extern int ZEXPORT unzOpenCurrentFilePassword(unzFile file, const char *password) { return unzOpenCurrentFile3(file, NULL, NULL, 0, password); } -extern int ZEXPORT unzOpenCurrentFile2 (file,method,level,raw) - unzFile file; - int* method; - int* level; - int raw; +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 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 unzReadCurrentFile (file, buf, len) - unzFile file; - voidp buf; - unsigned len; +/* 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) { - int err=UNZ_OK; - uInt iRead = 0; - unz_s* s; - file_in_zip_read_info_s* pfile_in_zip_read_info; - if (file==NULL) - return UNZ_PARAMERROR; - s=(unz_s*)file; - pfile_in_zip_read_info=s->pfile_in_zip_read; + unz64_internal *s = NULL; + uint32_t read = 0; + int err = UNZ_OK; - if (pfile_in_zip_read_info==NULL) + if (file == NULL) return UNZ_PARAMERROR; + s = (unz64_internal*)file; - - if ((pfile_in_zip_read_info->read_buffer == NULL)) + 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) + 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; - pfile_in_zip_read_info->stream.next_out = (Bytef*)buf; - - pfile_in_zip_read_info->stream.avail_out = (uInt)len; - - if ((len>pfile_in_zip_read_info->rest_read_uncompressed) && - (!(pfile_in_zip_read_info->raw))) - pfile_in_zip_read_info->stream.avail_out = - (uInt)pfile_in_zip_read_info->rest_read_uncompressed; + s->pfile_in_zip_read->stream.next_out = (uint8_t*)buf; + s->pfile_in_zip_read->stream.avail_out = (uInt)len; - if ((len>pfile_in_zip_read_info->rest_read_compressed+ - pfile_in_zip_read_info->stream.avail_in) && - (pfile_in_zip_read_info->raw)) - pfile_in_zip_read_info->stream.avail_out = - (uInt)pfile_in_zip_read_info->rest_read_compressed+ - pfile_in_zip_read_info->stream.avail_in; + 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; + } - while (pfile_in_zip_read_info->stream.avail_out>0) + do { - if ((pfile_in_zip_read_info->stream.avail_in==0) && - (pfile_in_zip_read_info->rest_read_compressed>0)) + if (s->pfile_in_zip_read->stream.avail_in == 0) { - uInt uReadThis = UNZ_BUFSIZE; - if (pfile_in_zip_read_info->rest_read_compressedrest_read_compressed; - if (uReadThis == 0) - return UNZ_EOF; - if (ZSEEK(pfile_in_zip_read_info->z_filefunc, - pfile_in_zip_read_info->filestream, - pfile_in_zip_read_info->pos_in_zipfile + - pfile_in_zip_read_info->byte_before_the_zipfile, - ZLIB_FILEFUNC_SEEK_SET)!=0) - return UNZ_ERRNO; - if (ZREAD(pfile_in_zip_read_info->z_filefunc, - pfile_in_zip_read_info->filestream, - pfile_in_zip_read_info->read_buffer, - uReadThis)!=uReadThis) - return UNZ_ERRNO; - - -# ifndef NOUNCRYPT - if(s->encrypted) + 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) { - uInt i; - for(i=0;iread_buffer[i] = - zdecode(s->keys,s->pcrc_32_tab, - pfile_in_zip_read_info->read_buffer[i]); + 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; + } } -# endif - - pfile_in_zip_read_info->pos_in_zipfile += uReadThis; - - pfile_in_zip_read_info->rest_read_compressed-=uReadThis; +#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 - pfile_in_zip_read_info->stream.next_in = - (Bytef*)pfile_in_zip_read_info->read_buffer; - pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis; + 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 ((pfile_in_zip_read_info->compression_method==0) || (pfile_in_zip_read_info->raw)) + if ((s->pfile_in_zip_read->compression_method == 0) || (s->pfile_in_zip_read->raw)) { - uInt uDoCopy,i ; + uint32_t i = 0; + uint32_t copy = 0; - if ((pfile_in_zip_read_info->stream.avail_in == 0) && - (pfile_in_zip_read_info->rest_read_compressed == 0)) - return (iRead==0) ? UNZ_EOF : iRead; + 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 (pfile_in_zip_read_info->stream.avail_out < - pfile_in_zip_read_info->stream.avail_in) - uDoCopy = pfile_in_zip_read_info->stream.avail_out ; + 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 - uDoCopy = pfile_in_zip_read_info->stream.avail_in ; - - for (i=0;istream.next_out+i) = - *(pfile_in_zip_read_info->stream.next_in+i); - - pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32, - pfile_in_zip_read_info->stream.next_out, - uDoCopy); - pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy; - pfile_in_zip_read_info->stream.avail_in -= uDoCopy; - pfile_in_zip_read_info->stream.avail_out -= uDoCopy; - pfile_in_zip_read_info->stream.next_out += uDoCopy; - pfile_in_zip_read_info->stream.next_in += uDoCopy; - pfile_in_zip_read_info->stream.total_out += uDoCopy; - iRead += uDoCopy; + 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 { - uLong uTotalOutBefore,uTotalOutAfter; - const Bytef *bufBefore; - uLong uOutThis; - int flush=Z_SYNC_FLUSH; + 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; - uTotalOutBefore = pfile_in_zip_read_info->stream.total_out; - bufBefore = pfile_in_zip_read_info->stream.next_out; + 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 == @@ -1349,250 +1532,454 @@ extern int ZEXPORT unzReadCurrentFile (file, buf, len) (pfile_in_zip_read_info->rest_read_compressed == 0)) flush = Z_FINISH; */ - err=inflate(&pfile_in_zip_read_info->stream,flush); - - if ((err>=0) && (pfile_in_zip_read_info->stream.msg!=NULL)) - err = Z_DATA_ERROR; + err = inflate(&s->pfile_in_zip_read->stream, flush); - uTotalOutAfter = pfile_in_zip_read_info->stream.total_out; - uOutThis = uTotalOutAfter-uTotalOutBefore; + if ((err >= 0) && (s->pfile_in_zip_read->stream.msg != NULL)) + err = Z_DATA_ERROR; - pfile_in_zip_read_info->crc32 = - crc32(pfile_in_zip_read_info->crc32,bufBefore, - (uInt)(uOutThis)); + total_out_after = s->pfile_in_zip_read->stream.total_out; + out_bytes = total_out_after - total_out_before; - pfile_in_zip_read_info->rest_read_uncompressed -= - uOutThis; + 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); - iRead += (uInt)(uTotalOutAfter - uTotalOutBefore); + read += (uint32_t)out_bytes; - if (err==Z_STREAM_END) - return (iRead==0) ? UNZ_EOF : iRead; - if (err!=Z_OK) + 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 iRead; + 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; -/* - Give the current position in uncompressed data -*/ -extern z_off_t ZEXPORT unztell (file) - unzFile file; + 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) { - unz_s* s; - file_in_zip_read_info_s* pfile_in_zip_read_info; - if (file==NULL) + 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; - s=(unz_s*)file; - pfile_in_zip_read_info=s->pfile_in_zip_read; - if (pfile_in_zip_read_info==NULL) +#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 (z_off_t)pfile_in_zip_read_info->stream.total_out; + return err; } +extern int ZEXPORT unzGoToFirstFile(unzFile file) +{ + return unzGoToFirstFile2(file, NULL, NULL, 0, NULL, 0, NULL, 0); +} -/* - return 1 if the end of file was reached, 0 elsewhere -*/ -extern int ZEXPORT unzeof (file) - unzFile file; +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) { - unz_s* s; - file_in_zip_read_info_s* pfile_in_zip_read_info; - if (file==NULL) - return UNZ_PARAMERROR; - s=(unz_s*)file; - pfile_in_zip_read_info=s->pfile_in_zip_read; + unz64_internal *s = NULL; + int err = UNZ_OK; - if (pfile_in_zip_read_info==NULL) + if (file == NULL) return UNZ_PARAMERROR; + s = (unz64_internal*)file; - if (pfile_in_zip_read_info->rest_read_uncompressed == 0) - return 1; - else - return 0; -} + 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); -/* - 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) + 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)); - if buf==NULL, it return the size of the local extra field that can be read + return err; +} - if buf!=NULL, len is the size of the buffer, the extra header is copied in - buf. - the return value is the number of bytes copied in buf, or (if <0) - the error code -*/ -extern int ZEXPORT unzGetLocalExtrafield (file,buf,len) - unzFile file; - voidp buf; - unsigned len; +extern int ZEXPORT unzGoToNextFile(unzFile file) { - unz_s* s; - file_in_zip_read_info_s* pfile_in_zip_read_info; - uInt read_now; - uLong size_to_read; + return unzGoToNextFile2(file, NULL, NULL, 0, NULL, 0, NULL, 0); +} - if (file==NULL) +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; - s=(unz_s*)file; - pfile_in_zip_read_info=s->pfile_in_zip_read; - - if (pfile_in_zip_read_info==NULL) + if (strlen(filename) >= UNZ_MAXFILENAMEINZIP) return UNZ_PARAMERROR; + s = (unz64_internal*)file; + if (!s->current_file_ok) + return UNZ_END_OF_LIST_OF_FILE; - size_to_read = (pfile_in_zip_read_info->size_local_extrafield - - pfile_in_zip_read_info->pos_local_extrafield); + /* 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; - if (buf==NULL) - return (int)size_to_read; + err = unzGoToFirstFile2(file, NULL, current_filename, sizeof(current_filename)-1, NULL, 0, NULL, 0); - if (len>size_to_read) - read_now = (uInt)size_to_read; - else - read_now = (uInt)len ; + 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); + } - if (read_now==0) - return 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; +} - if (ZSEEK(pfile_in_zip_read_info->z_filefunc, - pfile_in_zip_read_info->filestream, - pfile_in_zip_read_info->offset_local_extrafield + - pfile_in_zip_read_info->pos_local_extrafield, - ZLIB_FILEFUNC_SEEK_SET)!=0) - return UNZ_ERRNO; +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; +} - if (ZREAD(pfile_in_zip_read_info->z_filefunc, - pfile_in_zip_read_info->filestream, - buf,read_now)!=read_now) - return UNZ_ERRNO; +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); +} - return (int)read_now; +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; } -/* - Close the file in zip opened with unzipOpenCurrentFile - Return UNZ_CRCERROR if all the file was read but the CRC is not good -*/ -extern int ZEXPORT unzCloseCurrentFile (file) - unzFile file; +extern int ZEXPORT unzGoToFilePos64(unzFile file, const unz64_file_pos *file_pos) { - int err=UNZ_OK; + unz64_internal *s = NULL; + int err = UNZ_OK; - unz_s* s; - file_in_zip_read_info_s* pfile_in_zip_read_info; - if (file==NULL) + if (file == NULL || file_pos == NULL) return UNZ_PARAMERROR; - s=(unz_s*)file; - pfile_in_zip_read_info=s->pfile_in_zip_read; + 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 (pfile_in_zip_read_info==NULL) + 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 ((pfile_in_zip_read_info->rest_read_uncompressed == 0) && - (!pfile_in_zip_read_info->raw)) + 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 (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait) - err=UNZ_CRCERROR; + 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); +} - TRYFREE(pfile_in_zip_read_info->read_buffer); - pfile_in_zip_read_info->read_buffer = NULL; - if (pfile_in_zip_read_info->stream_initialised) - inflateEnd(&pfile_in_zip_read_info->stream); +extern int ZEXPORT unzSetOffset64(unzFile file, uint64_t pos) +{ + unz64_internal *s = NULL; + int err = UNZ_OK; - pfile_in_zip_read_info->stream_initialised = 0; - TRYFREE(pfile_in_zip_read_info); + if (file == NULL) + return UNZ_PARAMERROR; + s = (unz64_internal*)file; + s->pos_in_central_dir = pos; + s->num_file = s->gi.number_entry; /* hack */ - s->pfile_in_zip_read=NULL; + 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; +} -/* - Get the global comment string of the ZipFile, in the szComment buffer. - uSizeBuf is the size of the szComment buffer. - return the number of byte copied or an error code <0 -*/ -extern int ZEXPORT unzGetGlobalComment (file, szComment, uSizeBuf) - unzFile file; - char *szComment; - uLong uSizeBuf; +extern int64_t ZEXPORT unzTell64(unzFile file) { - int err=UNZ_OK; - unz_s* s; - uLong uReadThis ; - if (file==NULL) + unz64_internal *s = NULL; + if (file == NULL) + return UNZ_PARAMERROR; + s = (unz64_internal*)file; + if (s->pfile_in_zip_read == NULL) return UNZ_PARAMERROR; - s=(unz_s*)file; + 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); +} - uReadThis = uSizeBuf; - if (uReadThis>s->gi.size_comment) - uReadThis = s->gi.size_comment; +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 (ZSEEK(s->z_filefunc,s->filestream,s->central_pos+22,ZLIB_FILEFUNC_SEEK_SET)!=0) + if (s->pfile_in_zip_read == NULL) + return UNZ_ERRNO; + if (s->pfile_in_zip_read->compression_method != 0) return UNZ_ERRNO; - if (uReadThis>0) + 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) { - *szComment='\0'; - if (ZREAD(s->z_filefunc,s->filestream,szComment,uReadThis)!=uReadThis) - return UNZ_ERRNO; + 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; - if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment)) - *(szComment+s->gi.size_comment)='\0'; - return (int)uReadThis; -} + 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; + } -/* Additions by RX '2004 */ -extern uLong ZEXPORT unzGetOffset (file) - unzFile file; -{ - unz_s* s; + 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; - if (file==NULL) - return UNZ_PARAMERROR; - s=(unz_s*)file; - if (!s->current_file_ok) - return 0; - if (s->gi.number_entry != 0 && s->gi.number_entry != 0xffff) - if (s->num_file==s->gi.number_entry) - return 0; - return s->pos_in_central_dir; + return UNZ_OK; } -extern int ZEXPORT unzSetOffset (file, pos) - unzFile file; - uLong pos; +extern int ZEXPORT unzEndOfFile(unzFile file) { - unz_s* s; - int err; - - if (file==NULL) + unz64_internal *s = NULL; + if (file == NULL) return UNZ_PARAMERROR; - s=(unz_s*)file; - - s->pos_in_central_dir = pos; - s->num_file = s->gi.number_entry; /* hack */ - err = unzlocal_GetCurrentFileInfoInternal(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; + 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/vendor/zip/unzip.h b/vendor/zip/unzip.h index b247937c80..8889333c84 100644 --- a/vendor/zip/unzip.h +++ b/vendor/zip/unzip.h @@ -1,49 +1,23 @@ /* unzip.h -- IO for uncompress .zip files using zlib - Version 1.01e, February 12th, 2005 - - Copyright (C) 1998-2005 Gilles Vollant - - This unzip package allow extract file from .ZIP file, compatible with PKZip 2.04g - WinZip, InfoZip tools and compatible. - - Multi volume ZipFile (span) are not supported. - Encryption compatible with pkzip 2.04g only supported - Old compressions used by old PKZip 1.x are not supported - - - I WAIT FEEDBACK at mail info@winimage.com - Visit also http://www.winimage.com/zLibDll/unzip.htm for evolution - - Condition of use and distribution are the same than zlib : - - This software is provided 'as-is', without any express or implied - warranty. In no event will the authors be held liable for any damages - arising from the use of this software. - - Permission is granted to anyone to use this software for any purpose, - including commercial applications, and to alter it and redistribute it - freely, subject to the following restrictions: - - 1. The origin of this software must not be misrepresented; you must not - claim that you wrote the original software. If you use this software - in a product, an acknowledgment in the product documentation would be - appreciated but is not required. - 2. Altered source versions must be plainly marked as such, and must not be - misrepresented as being the original software. - 3. This notice may not be removed or altered from any source distribution. - - + 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. */ -/* for more info about .ZIP format, see - http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip - http://www.info-zip.org/pub/infozip/doc/ - PkWare has also a specification at : - ftp://ftp.pkware.com/probdesc.zip -*/ - -#ifndef _unz_H -#define _unz_H +#ifndef _UNZ_H +#define _UNZ_H #ifdef __cplusplus extern "C" { @@ -57,16 +31,21 @@ extern "C" { #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; } unzFile__; -typedef unzFile__ *unzFile; +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) @@ -75,280 +54,255 @@ typedef voidp unzFile; #define UNZ_BADZIPFILE (-103) #define UNZ_INTERNALERROR (-104) #define UNZ_CRCERROR (-105) - -/* tm_unz contain date/time info */ -typedef struct tm_unz_s -{ - uInt tm_sec; /* seconds after the minute - [0,59] */ - uInt tm_min; /* minutes after the hour - [0,59] */ - uInt tm_hour; /* hours since midnight - [0,23] */ - uInt tm_mday; /* day of the month - [1,31] */ - uInt tm_mon; /* months since January - [0,11] */ - uInt tm_year; /* years - [1980..2044] */ -} tm_unz; +#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 { - uLong number_entry; /* total number of entries in - the central dir on this disk */ - uLong size_comment; /* size of the global comment of the zipfile */ + 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 */ +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 { - uLong version; /* version made by 2 bytes */ - uLong version_needed; /* version needed to extract 2 bytes */ - uLong flag; /* general purpose bit flag 2 bytes */ - uLong compression_method; /* compression method 2 bytes */ - uLong dosDate; /* last mod file date in Dos fmt 4 bytes */ - uLong crc; /* crc-32 4 bytes */ - uLong compressed_size; /* compressed size 4 bytes */ - uLong uncompressed_size; /* uncompressed size 4 bytes */ - uLong size_filename; /* filename length 2 bytes */ - uLong size_file_extra; /* extra field length 2 bytes */ - uLong size_file_comment; /* file comment length 2 bytes */ - - uLong disk_num_start; /* disk number start 2 bytes */ - uLong internal_fa; /* internal file attributes 2 bytes */ - uLong external_fa; /* external file attributes 4 bytes */ - - tm_unz tmu_date; + 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; -extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1, - const char* fileName2, - int iCaseSensitivity)); -/* - Compare two filename (fileName1,fileName2). - If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp) - If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi - or strcasecmp) - If iCaseSenisivity = 0, case sensitivity is defaut of your operating system - (like 1 on Unix, 2 on Windows) -*/ +/***************************************************************************/ +/* Opening and close a zip file */ +extern unzFile ZEXPORT unzOpen(const char *path); +extern unzFile ZEXPORT unzOpen64(const void *path); +/* Open a Zip file. -extern unzFile ZEXPORT unzOpen OF((const char *path)); -/* - Open a Zip file. path contain the full pathname (by example, - on a Windows XP computer "c:\\zlib\\zlib113.zip" or on an Unix computer - "zlib/zlib113.zip". - If the zipfile cannot be opened (file don't exist or in not valid), the - return value is NULL. - Else, the return value is a unzFile Handle, usable with other function - of this unzip package. -*/ + 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 -extern unzFile ZEXPORT unzOpen2 OF((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 the zip file (see ioapi.h) -*/ + 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 int ZEXPORT unzClose OF((unzFile file)); -/* - Close a ZipFile opened with unzipOpen. - If there is files inside the .Zip opened with unzOpenCurrentFile (see later), - these files MUST be closed with unzipCloseCurrentFile before call unzipClose. - return UNZ_OK if there is no problem. */ - -extern int ZEXPORT unzGetGlobalInfo OF((unzFile file, - unz_global_info *pglobal_info)); -/* - Write info about the ZipFile in the *pglobal_info structure. - No preparation of the structure is needed - return UNZ_OK if there is no problem. */ - - -extern int ZEXPORT unzGetGlobalComment OF((unzFile file, - char *szComment, - uLong uSizeBuf)); -/* - Get the global comment string of the ZipFile, in the szComment buffer. - uSizeBuf is the size of the szComment buffer. - return the number of byte copied or an error code <0 -*/ +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 */ /***************************************************************************/ -/* Unzip package allow you browse the directory of the zipfile */ +/* 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 unzGoToFirstFile OF((unzFile file)); -/* - Set the current file of the zipfile to the first file. - return UNZ_OK if there is no problem -*/ +extern int ZEXPORT unzOpenCurrentFile(unzFile file); +/* Open for reading data the current file in the zipfile. -extern int ZEXPORT unzGoToNextFile OF((unzFile file)); -/* - Set the current file of the zipfile to the next file. - return UNZ_OK if there is no problem - return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest. -*/ + return UNZ_OK if no error */ -extern int ZEXPORT unzLocateFile OF((unzFile file, - const char *szFileName, - int iCaseSensitivity)); -/* - Try locate the file szFileName in the zipfile. - For the iCaseSensitivity signification, see unzStringFileNameCompare +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 value : - UNZ_OK if the file is found. It becomes the current file. - UNZ_END_OF_LIST_OF_FILE if the file is not found -*/ + 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 -/* ****************************************** */ -/* Ryan supplied functions */ -/* unz_file_info contain information about a file in the zipfile */ -typedef struct unz_file_pos_s -{ - uLong pos_in_zip_directory; /* offset in zip file directory */ - uLong num_of_file; /* # of file */ -} unz_file_pos; + 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 unzGetFilePos( - unzFile file, - unz_file_pos* file_pos); - -extern int ZEXPORT unzGoToFilePos( - unzFile file, - unz_file_pos* file_pos); - -/* ****************************************** */ - -extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file, - unz_file_info *pfile_info, - char *szFileName, - uLong fileNameBufferSize, - void *extraField, - uLong extraFieldBufferSize, - char *szComment, - uLong commentBufferSize)); -/* - Get Info about the current file - if pfile_info!=NULL, the *pfile_info structure will contain somes info about - the current file - if szFileName!=NULL, the filemane string will be copied in szFileName - (fileNameBufferSize is the size of the buffer) - if extraField!=NULL, the extra field information will be copied in extraField - (extraFieldBufferSize is the size of the buffer). - This is the Central-header version of the extra field - if szComment!=NULL, the comment string of the file will be copied in szComment - (commentBufferSize is the size of the buffer) -*/ +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 */ /***************************************************************************/ -/* for 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 OF((unzFile file)); -/* - Open for reading data the current file in the zipfile. - If there is no error, the return value is UNZ_OK. -*/ +/* Browse the directory of the zipfile */ -extern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file, - const char* password)); -/* - Open for reading data the current file in the zipfile. - password is a crypting password - If there is no error, the return value is UNZ_OK. -*/ +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 unzOpenCurrentFile2 OF((unzFile file, - int* method, - int* level, - int raw)); -/* - Same than 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 unzGoToFirstFile(unzFile file); +/* Set the current file of the zipfile to the first file. -extern int ZEXPORT unzOpenCurrentFile3 OF((unzFile file, - int* method, - int* level, - int raw, - const char* password)); -/* - Same than 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 -*/ + 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. -extern int ZEXPORT unzCloseCurrentFile OF((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 -*/ + return UNZ_OK if no error */ -extern int ZEXPORT unzReadCurrentFile OF((unzFile file, - voidp buf, - unsigned 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 unzGoToNextFile(unzFile file); +/* Set the current file of the zipfile to the next file. -extern z_off_t ZEXPORT unztell OF((unzFile file)); -/* - Give the current position in uncompressed data -*/ + return UNZ_OK if no error + return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest */ -extern int ZEXPORT unzeof OF((unzFile file)); -/* - return 1 if the end of file was reached, 0 elsewhere -*/ +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. -extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file, - voidp buf, - unsigned 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) + return UNZ_OK if no error + return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest */ - if buf==NULL, it return the size of the local extra field +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. - if buf!=NULL, len is the size of the buffer, the extra header is copied in - buf. - the return value is the number of bytes copied in buf, or (if <0) - the error code -*/ + 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 uLong ZEXPORT unzGetOffset (unzFile file); +extern int ZEXPORT unzSetOffset(unzFile file, uint32_t pos); +extern int ZEXPORT unzSetOffset64(unzFile file, uint64_t pos); /* Set the current file offset */ -extern int ZEXPORT unzSetOffset (unzFile file, uLong pos); +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 */ +#endif /* _UNZ_H */ diff --git a/vendor/zip/zip.c b/vendor/zip/zip.c index 7fbe002743..d6eabd06bd 100644 --- a/vendor/zip/zip.c +++ b/vendor/zip/zip.c @@ -1,211 +1,221 @@ /* zip.c -- IO on .zip files using zlib - Version 1.01e, February 12th, 2005 - - 27 Dec 2004 Rolf Kalbermatter - Modification to zipOpen2 to support globalComment retrieval. - - Copyright (C) 1998-2005 Gilles Vollant - - Read zip.h for more info + 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 + 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 +#include #include -#include +#include +#include + #include "zlib.h" #include "zip.h" -#ifdef STDC -# include -# include -# include +#ifdef HAVE_AES +# define AES_METHOD (99) +# define AES_PWVERIFYSIZE (2) +# define AES_AUTHCODESIZE (10) +# define AES_MAXSALTLENGTH (16) +# define AES_VERSION (0x0001) +# define AES_ENCRYPTIONMODE (0x03) + +# include "aes/aes.h" +# include "aes/fileenc.h" +# include "aes/prng.h" #endif -#ifdef NO_ERRNO_H - extern int errno; -#else -# include +#ifdef HAVE_APPLE_COMPRESSION +# include #endif - -#ifndef local -# define local static +#ifndef NOCRYPT +# include "crypt.h" #endif -/* compile with -Dlocal if your debugger can't find static symbols */ +#define SIZEDATA_INDATABLOCK (4096-(4*4)) + +#define DISKHEADERMAGIC (0x08074b50) +#define LOCALHEADERMAGIC (0x04034b50) +#define CENTRALHEADERMAGIC (0x02014b50) +#define ENDHEADERMAGIC (0x06054b50) +#define ZIP64ENDHEADERMAGIC (0x06064b50) +#define ZIP64ENDLOCHEADERMAGIC (0x07064b50) +#define DATADESCRIPTORMAGIC (0x08074b50) + +#define FLAG_LOCALHEADER_OFFSET (0x06) +#define CRC_LOCALHEADER_OFFSET (0x0e) + +#define SIZECENTRALHEADER (0x2e) /* 46 */ +#define SIZECENTRALHEADERLOCATOR (0x14) /* 20 */ +#define SIZECENTRALDIRITEM (0x2e) +#define SIZEZIPLOCALHEADER (0x1e) + +#ifndef BUFREADCOMMENT +# define BUFREADCOMMENT (0x400) +#endif #ifndef VERSIONMADEBY -# define VERSIONMADEBY (0x0) /* platform depedent */ +# define VERSIONMADEBY (0x0) /* platform dependent */ #endif #ifndef Z_BUFSIZE -#define Z_BUFSIZE (16384) -#endif - -#ifndef Z_MAXFILENAMEINZIP -#define Z_MAXFILENAMEINZIP (256) +# define Z_BUFSIZE (UINT16_MAX) #endif #ifndef ALLOC -# define ALLOC(size) (malloc(size)) +# define ALLOC(size) (malloc(size)) #endif #ifndef TRYFREE -# define TRYFREE(p) {if (p) free(p);} +# define TRYFREE(p) {if (p) free(p);} #endif -/* -#define SIZECENTRALDIRITEM (0x2e) -#define SIZEZIPLOCALHEADER (0x1e) -*/ - -/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */ - -#ifndef SEEK_CUR -#define SEEK_CUR 1 -#endif - -#ifndef SEEK_END -#define SEEK_END 2 -#endif - -#ifndef SEEK_SET -#define SEEK_SET 0 -#endif +/* NOT sure that this work on ALL platform */ +#define MAKEULONG64(a, b) ((uint64_t)(((unsigned long)(a)) | ((uint64_t)((unsigned long)(b))) << 32)) #ifndef DEF_MEM_LEVEL -#if MAX_MEM_LEVEL >= 8 -# define DEF_MEM_LEVEL 8 -#else -# define DEF_MEM_LEVEL MAX_MEM_LEVEL -#endif +# if MAX_MEM_LEVEL >= 8 +# define DEF_MEM_LEVEL 8 +# else +# define DEF_MEM_LEVEL MAX_MEM_LEVEL +# endif #endif -const char zip_copyright[] = - " zip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll"; - - -#define SIZEDATA_INDATABLOCK (4096-(4*4)) -#define LOCALHEADERMAGIC (0x04034b50) -#define CENTRALHEADERMAGIC (0x02014b50) -#define ENDHEADERMAGIC (0x06054b50) - -#define FLAG_LOCALHEADER_OFFSET (0x06) -#define CRC_LOCALHEADER_OFFSET (0x0e) - -#define SIZECENTRALHEADER (0x2e) /* 46 */ +const char zip_copyright[] = " zip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll"; typedef struct linkedlist_datablock_internal_s { - struct linkedlist_datablock_internal_s* next_datablock; - uLong avail_in_this_block; - uLong filled_in_this_block; - uLong unused; /* for future use and alignement */ - unsigned char data[SIZEDATA_INDATABLOCK]; + struct linkedlist_datablock_internal_s *next_datablock; + uint32_t avail_in_this_block; + uint32_t filled_in_this_block; + uint32_t unused; /* for future use and alignment */ + uint8_t data[SIZEDATA_INDATABLOCK]; } linkedlist_datablock_internal; typedef struct linkedlist_data_s { - linkedlist_datablock_internal* first_block; - linkedlist_datablock_internal* last_block; + linkedlist_datablock_internal *first_block; + linkedlist_datablock_internal *last_block; } linkedlist_data; - typedef struct { - z_stream stream; /* zLib stream structure for inflate */ - int stream_initialised; /* 1 is stream is initialised */ - uInt pos_in_buffered_data; /* last written byte in buffered_data */ - - uLong pos_local_header; /* offset of the local header of the file - currenty writing */ - char* central_header; /* central header data for the current file */ - uLong size_centralheader; /* size of the central header for cur file */ - uLong flag; /* flag of the file currently writing */ - - int method; /* compression method of file currenty wr.*/ - int raw; /* 1 for directly writing raw data */ - Byte buffered_data[Z_BUFSIZE];/* buffer contain compressed data to be writ*/ - uLong dosDate; - uLong crc32; - int encrypt; + 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; + prng_ctx aes_rng[1]; +#endif + int stream_initialised; /* 1 is stream is initialized */ + uint32_t pos_in_buffered_data; /* last written byte in buffered_data */ + + uint64_t pos_local_header; /* offset of the local header of the file currently writing */ + char *central_header; /* central header data for the current file */ + uint16_t size_centralextra; + uint16_t size_centralheader; /* size of the central header for cur file */ + uint16_t size_centralextrafree; /* Extra bytes allocated to the central header but that are not used */ + uint16_t size_comment; + uint16_t flag; /* flag of the file currently writing */ + + uint16_t method; /* compression method written to file.*/ + uint16_t compression_method; /* compression method to use */ + int raw; /* 1 for directly writing raw data */ + uint8_t buffered_data[Z_BUFSIZE]; /* buffer contain compressed data to be writ*/ + uint32_t dos_date; + uint32_t crc32; + int zip64; /* add ZIP64 extended information in the extra field */ + uint32_t number_disk; /* number of current disk used for spanning ZIP */ + uint64_t total_compressed; + uint64_t total_uncompressed; #ifndef NOCRYPT - unsigned long keys[3]; /* keys defining the pseudo-random sequence */ - const unsigned long* pcrc_32_tab; - int crypt_header_size; + uint32_t keys[3]; /* keys defining the pseudo-random sequence */ + const z_crc_t *pcrc_32_tab; #endif -} curfile_info; +} curfile64_info; typedef struct { - zlib_filefunc_def z_filefunc; - voidpf filestream; /* io structore of the zipfile */ - linkedlist_data central_dir;/* datablock with central dir in construction*/ - int in_opened_file_inzip; /* 1 if a file in the zip is currently writ.*/ - curfile_info ci; /* info on the file curretly writing */ - - uLong begin_pos; /* position of the beginning of the zipfile */ - uLong add_position_when_writting_offset; - uLong number_entry; + zlib_filefunc64_32_def z_filefunc; + voidpf filestream; /* io structure of the zipfile */ + voidpf filestream_with_CD; /* io structure of the zipfile with the central dir */ + linkedlist_data central_dir; /* datablock with central dir in construction*/ + int in_opened_file_inzip; /* 1 if a file in the zip is currently writ.*/ + int append; /* append mode */ + curfile64_info ci; /* info on the file currently writing */ + + uint64_t add_position_when_writting_offset; + uint64_t number_entry; + uint64_t disk_size; /* size of each disk */ + uint32_t number_disk; /* number of the current disk, used for spanning ZIP */ + uint32_t number_disk_with_CD; /* number the the disk with central dir, used for spanning ZIP */ #ifndef NO_ADDFILEINEXISTINGZIP char *globalcomment; #endif -} zip_internal; - +} zip64_internal; +/* Allocate a new data block */ +static linkedlist_datablock_internal *allocate_new_datablock(void) +{ + linkedlist_datablock_internal *ldi = NULL; -#ifndef NOCRYPT -#define INCLUDECRYPTINGCODE_IFCRYPTALLOWED -#include "crypt.h" -#endif + ldi = (linkedlist_datablock_internal*)ALLOC(sizeof(linkedlist_datablock_internal)); -local linkedlist_datablock_internal* allocate_new_datablock() -{ - linkedlist_datablock_internal* ldi; - ldi = (linkedlist_datablock_internal*) - ALLOC(sizeof(linkedlist_datablock_internal)); - if (ldi!=NULL) + if (ldi != NULL) { - ldi->next_datablock = NULL ; - ldi->filled_in_this_block = 0 ; - ldi->avail_in_this_block = SIZEDATA_INDATABLOCK ; + ldi->next_datablock = NULL; + ldi->filled_in_this_block = 0; + ldi->avail_in_this_block = SIZEDATA_INDATABLOCK; } return ldi; } -local void free_datablock(ldi) - linkedlist_datablock_internal* ldi; +/* Free data block in linked list */ +static void free_datablock(linkedlist_datablock_internal *ldi) { - while (ldi!=NULL) + while (ldi != NULL) { - linkedlist_datablock_internal* ldinext = ldi->next_datablock; + linkedlist_datablock_internal *ldinext = ldi->next_datablock; TRYFREE(ldi); ldi = ldinext; } } -local void init_linkedlist(ll) - linkedlist_data* ll; +/* Initialize linked list */ +static void init_linkedlist(linkedlist_data *ll) { ll->first_block = ll->last_block = NULL; } -local void free_linkedlist(ll) - linkedlist_data* ll; +/* Free entire linked list and all data blocks */ +static void free_linkedlist(linkedlist_data *ll) { free_datablock(ll->first_block); ll->first_block = ll->last_block = NULL; } - -local int add_data_in_datablock(ll,buf,len) - linkedlist_data* ll; - const void* buf; - uLong len; +/* Add data to linked list data block */ +static int add_data_in_datablock(linkedlist_data *ll, const void *buf, uint32_t len) { - linkedlist_datablock_internal* ldi; - const unsigned char* from_copy; + linkedlist_datablock_internal *ldi = NULL; + const unsigned char *from_copy = NULL; - if (ll==NULL) + if (ll == NULL) return ZIP_INTERNALERROR; if (ll->last_block == NULL) @@ -218,13 +228,13 @@ local int add_data_in_datablock(ll,buf,len) ldi = ll->last_block; from_copy = (unsigned char*)buf; - while (len>0) + while (len > 0) { - uInt copy_this; - uInt i; - unsigned char* to_copy; + uint32_t copy_this = 0; + uint32_t i = 0; + unsigned char *to_copy = NULL; - if (ldi->avail_in_this_block==0) + if (ldi->avail_in_this_block == 0) { ldi->next_datablock = allocate_new_datablock(); if (ldi->next_datablock == NULL) @@ -234,499 +244,718 @@ local int add_data_in_datablock(ll,buf,len) } if (ldi->avail_in_this_block < len) - copy_this = (uInt)ldi->avail_in_this_block; + copy_this = ldi->avail_in_this_block; else - copy_this = (uInt)len; + copy_this = len; to_copy = &(ldi->data[ldi->filled_in_this_block]); - for (i=0;ifilled_in_this_block += copy_this; ldi->avail_in_this_block -= copy_this; - from_copy += copy_this ; + from_copy += copy_this; len -= copy_this; } return ZIP_OK; } - - -/****************************************************************************/ - -#ifndef NO_ADDFILEINEXISTINGZIP -/* =========================================================================== - Inputs a long in LSB order to the given file - nbByte == 1, 2 or 4 (byte, short or long) -*/ - -local int ziplocal_putValue OF((const zlib_filefunc_def* pzlib_filefunc_def, - voidpf filestream, uLong x, int nbByte)); -local int ziplocal_putValue (pzlib_filefunc_def, filestream, x, nbByte) - const zlib_filefunc_def* pzlib_filefunc_def; - voidpf filestream; - uLong x; - int nbByte; +/* Inputs a long in LSB order to the given file: nbByte == 1, 2 ,4 or 8 (byte, short or long, uint64_t) */ +static int zipWriteValue(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, + uint64_t x, uint32_t len) { - unsigned char buf[4]; - int n; - for (n = 0; n < nbByte; n++) + unsigned char buf[8]; + uint32_t n = 0; + + for (n = 0; n < len; n++) { buf[n] = (unsigned char)(x & 0xff); x >>= 8; } + if (x != 0) - { /* data overflow - hack for ZIP64 (X Roche) */ - for (n = 0; n < nbByte; n++) + { + /* Data overflow - hack for ZIP64 (X Roche) */ + for (n = 0; n < len; n++) { - buf[n] = 0xff; + buf[n] = 0xff; } - } + } - if (ZWRITE(*pzlib_filefunc_def,filestream,buf,nbByte)!=(uLong)nbByte) + if (ZWRITE64(*pzlib_filefunc_def, filestream, buf, len) != len) return ZIP_ERRNO; - else - return ZIP_OK; + + return ZIP_OK; } -local void ziplocal_putValue_inmemory OF((void* dest, uLong x, int nbByte)); -local void ziplocal_putValue_inmemory (dest, x, nbByte) - void* dest; - uLong x; - int nbByte; +static void zipWriteValueToMemory(void* dest, uint64_t x, uint32_t len) { - unsigned char* buf=(unsigned char*)dest; - int n; - for (n = 0; n < nbByte; n++) { + unsigned char *buf = (unsigned char*)dest; + uint32_t n = 0; + + for (n = 0; n < len; n++) + { buf[n] = (unsigned char)(x & 0xff); x >>= 8; } if (x != 0) - { /* data overflow - hack for ZIP64 */ - for (n = 0; n < nbByte; n++) + { + /* data overflow - hack for ZIP64 */ + for (n = 0; n < len; n++) { buf[n] = 0xff; } } } -/****************************************************************************/ - - -local uLong ziplocal_TmzDateToDosDate(ptm,dosDate) - const tm_zip* ptm; - uLong dosDate; +static void zipWriteValueToMemoryAndMove(unsigned char **dest_ptr, uint64_t x, uint32_t len) { - uLong year = (uLong)ptm->tm_year; - if (year>1980) - year-=1980; - else if (year>80) - year-=80; - return - (uLong) (((ptm->tm_mday) + (32 * (ptm->tm_mon+1)) + (512 * year)) << 16) | - ((ptm->tm_sec/2) + (32* ptm->tm_min) + (2048 * (uLong)ptm->tm_hour)); + zipWriteValueToMemory(*dest_ptr, x, len); + *dest_ptr += len; } - -/****************************************************************************/ - -local int ziplocal_getByte OF(( - const zlib_filefunc_def* pzlib_filefunc_def, - voidpf filestream, - int *pi)); - -local int ziplocal_getByte(pzlib_filefunc_def,filestream,pi) - const zlib_filefunc_def* pzlib_filefunc_def; - voidpf filestream; - int *pi; +static int zipReadUInt8(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, uint8_t *value) { - unsigned char c; - int err = (int)ZREAD(*pzlib_filefunc_def,filestream,&c,1); - if (err==1) + uint8_t c = 0; + if (ZREAD64(*pzlib_filefunc_def, filestream, &c, 1) == 1) { - *pi = (int)c; + *value = (uint8_t)c; return ZIP_OK; } - else - { - if (ZERROR(*pzlib_filefunc_def,filestream)) - return ZIP_ERRNO; - else - return ZIP_EOF; - } + if (ZERROR64(*pzlib_filefunc_def, filestream)) + return ZIP_ERRNO; + return ZIP_EOF; } +static int zipReadUInt16(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, uint16_t *value) +{ + uint16_t x = 0; + uint8_t c = 0; + int err = ZIP_OK; + + err = zipReadUInt8(pzlib_filefunc_def, filestream, &c); + x = (uint16_t)c; + if (err == ZIP_OK) + err = zipReadUInt8(pzlib_filefunc_def, filestream, &c); + x += ((uint16_t)c) << 8; -/* =========================================================================== - Reads a long in LSB order from the given gz_stream. Sets -*/ -local int ziplocal_getShort OF(( - const zlib_filefunc_def* pzlib_filefunc_def, - voidpf filestream, - uLong *pX)); - -local int ziplocal_getShort (pzlib_filefunc_def,filestream,pX) - const zlib_filefunc_def* pzlib_filefunc_def; - voidpf filestream; - uLong *pX; + if (err == ZIP_OK) + *value = x; + else + *value = 0; + return err; +} + +static int zipReadUInt32(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, uint32_t *value) { - uLong x ; - int i; - int err; + uint32_t x = 0; + uint8_t c = 0; + int err = ZIP_OK; - err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); - x = (uLong)i; + err = zipReadUInt8(pzlib_filefunc_def, filestream, &c); + x = (uint32_t)c; + if (err == ZIP_OK) + err = zipReadUInt8(pzlib_filefunc_def, filestream, &c); + x += ((uint32_t)c) << 8; + if (err == ZIP_OK) + err = zipReadUInt8(pzlib_filefunc_def, filestream, &c); + x += ((uint32_t)c) << 16; + if (err == ZIP_OK) + err = zipReadUInt8(pzlib_filefunc_def, filestream, &c); + x += ((uint32_t)c) << 24; + + if (err == ZIP_OK) + *value = x; + else + *value = 0; + return err; +} - if (err==ZIP_OK) - err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); - x += ((uLong)i)<<8; +static int zipReadUInt64(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, uint64_t *value) +{ + uint64_t x = 0; + uint8_t c = 0; + int err = ZIP_OK; - if (err==ZIP_OK) - *pX = x; + err = zipReadUInt8(pzlib_filefunc_def, filestream, &c); + x = (uint64_t)c; + if (err == ZIP_OK) + err = zipReadUInt8(pzlib_filefunc_def, filestream, &c); + x += ((uint64_t)c) << 8; + if (err == ZIP_OK) + err = zipReadUInt8(pzlib_filefunc_def, filestream, &c); + x += ((uint64_t)c) << 16; + if (err == ZIP_OK) + err = zipReadUInt8(pzlib_filefunc_def, filestream, &c); + x += ((uint64_t)c) << 24; + if (err == ZIP_OK) + err = zipReadUInt8(pzlib_filefunc_def, filestream, &c); + x += ((uint64_t)c) << 32; + if (err == ZIP_OK) + err = zipReadUInt8(pzlib_filefunc_def, filestream, &c); + x += ((uint64_t)c) << 40; + if (err == ZIP_OK) + err = zipReadUInt8(pzlib_filefunc_def, filestream, &c); + x += ((uint64_t)c) << 48; + if (err == ZIP_OK) + err = zipReadUInt8(pzlib_filefunc_def, filestream, &c); + x += ((uint64_t)c) << 56; + + if (err == ZIP_OK) + *value = x; else - *pX = 0; + *value = 0; + return err; } -local int ziplocal_getLong OF(( - const zlib_filefunc_def* pzlib_filefunc_def, - voidpf filestream, - uLong *pX)); +/* Gets the amount of bytes left to write to the current disk for spanning archives */ +static void zipGetDiskSizeAvailable(zipFile file, uint64_t *size_available) +{ + zip64_internal *zi = NULL; + uint64_t current_disk_size = 0; + + zi = (zip64_internal*)file; + ZSEEK64(zi->z_filefunc, zi->filestream, 0, ZLIB_FILEFUNC_SEEK_END); + current_disk_size = ZTELL64(zi->z_filefunc, zi->filestream); + *size_available = zi->disk_size - current_disk_size; +} -local int ziplocal_getLong (pzlib_filefunc_def,filestream,pX) - const zlib_filefunc_def* pzlib_filefunc_def; - voidpf filestream; - uLong *pX; +/* Goes to a specific disk number for spanning archives */ +static int zipGoToSpecificDisk(zipFile file, uint32_t number_disk, int open_existing) { - uLong x ; - int i; - int err; + zip64_internal *zi = NULL; + int err = ZIP_OK; - err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); - x = (uLong)i; + zi = (zip64_internal*)file; + if (zi->disk_size == 0) + return err; - if (err==ZIP_OK) - err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); - x += ((uLong)i)<<8; + if ((zi->filestream != NULL) && (zi->filestream != zi->filestream_with_CD)) + ZCLOSE64(zi->z_filefunc, zi->filestream); - if (err==ZIP_OK) - err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); - x += ((uLong)i)<<16; + zi->filestream = ZOPENDISK64(zi->z_filefunc, zi->filestream_with_CD, number_disk, (open_existing == 1) ? + (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING) : + (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE)); - if (err==ZIP_OK) - err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); - x += ((uLong)i)<<24; + if (zi->filestream == NULL) + err = ZIP_ERRNO; - if (err==ZIP_OK) - *pX = x; - else - *pX = 0; return err; } -#ifndef BUFREADCOMMENT -#define BUFREADCOMMENT (0x400) -#endif -/* - Locate the Central directory of a zipfile (at the end, just before - the global comment) -*/ -local uLong ziplocal_SearchCentralDir OF(( - const zlib_filefunc_def* pzlib_filefunc_def, - voidpf filestream)); +/* Goes to the first disk in a spanned archive */ +static int zipGoToFirstDisk(zipFile file) +{ + zip64_internal *zi = NULL; + uint32_t number_disk_next = 0; + int err = ZIP_OK; -local uLong ziplocal_SearchCentralDir(pzlib_filefunc_def,filestream) - const zlib_filefunc_def* pzlib_filefunc_def; - voidpf filestream; + zi = (zip64_internal*)file; + + if (zi->disk_size == 0) + return err; + number_disk_next = 0; + if (zi->number_disk_with_CD > 0) + number_disk_next = zi->number_disk_with_CD - 1; + err = zipGoToSpecificDisk(file, number_disk_next, (zi->append == APPEND_STATUS_ADDINZIP)); + if ((err == ZIP_ERRNO) && (zi->append == APPEND_STATUS_ADDINZIP)) + err = zipGoToSpecificDisk(file, number_disk_next, 0); + if (err == ZIP_OK) + zi->number_disk = number_disk_next; + ZSEEK64(zi->z_filefunc, zi->filestream, 0, ZLIB_FILEFUNC_SEEK_END); + return err; +} + +/* Goes to the next disk in a spanned archive */ +static int zipGoToNextDisk(zipFile file) { - unsigned char* buf; - uLong uSizeFile; - uLong uBackRead; - uLong uMaxBack=0xffff; /* maximum size of global comment */ - uLong uPosFound=0; + zip64_internal *zi = NULL; + uint64_t size_available_in_disk = 0; + uint32_t number_disk_next = 0; + int err = ZIP_OK; - if (ZSEEK(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0) - return 0; + zi = (zip64_internal*)file; + if (zi->disk_size == 0) + return err; + + number_disk_next = zi->number_disk + 1; + + do + { + err = zipGoToSpecificDisk(file, number_disk_next, (zi->append == APPEND_STATUS_ADDINZIP)); + if ((err == ZIP_ERRNO) && (zi->append == APPEND_STATUS_ADDINZIP)) + err = zipGoToSpecificDisk(file, number_disk_next, 0); + if (err != ZIP_OK) + break; + zipGetDiskSizeAvailable(file, &size_available_in_disk); + zi->number_disk = number_disk_next; + zi->number_disk_with_CD = zi->number_disk + 1; + number_disk_next += 1; + } + while (size_available_in_disk <= 0); - uSizeFile = ZTELL(*pzlib_filefunc_def,filestream); + return err; +} - if (uMaxBack>uSizeFile) - uMaxBack = uSizeFile; +/* Locate the Central directory of a zipfile (at the end, just before the global comment) */ +static uint64_t zipSearchCentralDir(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream) +{ + unsigned char *buf = NULL; + uint64_t file_size = 0; + uint64_t back_read = 4; + uint64_t max_back = UINT16_MAX; /* maximum size of global comment */ + uint64_t pos_found = 0; + uint32_t read_size = 0; + uint64_t read_pos = 0; + uint32_t i = 0; buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4); - if (buf==NULL) + if (buf == NULL) return 0; - uBackRead = 4; - while (uBackReaduMaxBack) - uBackRead = uMaxBack; + TRYFREE(buf); + return 0; + } + + file_size = ZTELL64(*pzlib_filefunc_def, filestream); + + if (max_back > file_size) + max_back = file_size; + + while (back_read < max_back) + { + if (back_read + BUFREADCOMMENT > max_back) + back_read = max_back; else - uBackRead+=BUFREADCOMMENT; - uReadPos = uSizeFile-uBackRead ; + back_read += BUFREADCOMMENT; - uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ? - (BUFREADCOMMENT+4) : (uSizeFile-uReadPos); - if (ZSEEK(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0) - break; + read_pos = file_size-back_read; + read_size = ((BUFREADCOMMENT+4) < (file_size - read_pos)) ? + (BUFREADCOMMENT+4) : (uint32_t)(file_size - read_pos); - if (ZREAD(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize) + if (ZSEEK64(*pzlib_filefunc_def, filestream, read_pos, ZLIB_FILEFUNC_SEEK_SET) != 0) + break; + if (ZREAD64(*pzlib_filefunc_def, filestream, buf, read_size) != read_size) break; - for (i=(int)uReadSize-3; (i--)>0;) - if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && - ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06)) + 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)) { - uPosFound = uReadPos+i; + pos_found = read_pos+i; break; } - if (uPosFound!=0) + if (pos_found != 0) break; } TRYFREE(buf); - return uPosFound; + return pos_found; } -#endif /* !NO_ADDFILEINEXISTINGZIP*/ - -/************************************************************/ -extern zipFile ZEXPORT zipOpen2 (pathname, append, globalcomment, pzlib_filefunc_def) - const char *pathname; - int append; - zipcharpc* globalcomment; - zlib_filefunc_def* pzlib_filefunc_def; + +/* Locate the Central directory 64 of a zipfile (at the end, just before the global comment) */ +static uint64_t zipSearchCentralDir64(const zlib_filefunc64_32_def *pzlib_filefunc_def, voidpf filestream, + const uint64_t endcentraloffset) { - zip_internal ziinit; - zip_internal* zi; - int err=ZIP_OK; + uint64_t offset = 0; + uint32_t value32 = 0; + /* Zip64 end of central directory locator */ + if (ZSEEK64(*pzlib_filefunc_def, filestream, endcentraloffset - SIZECENTRALHEADERLOCATOR, ZLIB_FILEFUNC_SEEK_SET) != 0) + return 0; - if (pzlib_filefunc_def==NULL) - fill_fopen_filefunc(&ziinit.z_filefunc); + /* Read locator signature */ + if (zipReadUInt32(pzlib_filefunc_def, filestream, &value32) != ZIP_OK) + return 0; + if (value32 != ZIP64ENDLOCHEADERMAGIC) + return 0; + /* Number of the disk with the start of the zip64 end of central directory */ + if (zipReadUInt32(pzlib_filefunc_def, filestream, &value32) != ZIP_OK) + return 0; + /* Relative offset of the zip64 end of central directory record */ + if (zipReadUInt64(pzlib_filefunc_def, filestream, &offset) != ZIP_OK) + return 0; + /* Total number of disks */ + if (zipReadUInt32(pzlib_filefunc_def, filestream, &value32) != ZIP_OK) + return 0; + /* Goto end of central directory record */ + if (ZSEEK64(*pzlib_filefunc_def,filestream, offset, ZLIB_FILEFUNC_SEEK_SET) != 0) + return 0; + /* The signature */ + if (zipReadUInt32(pzlib_filefunc_def, filestream, &value32) != ZIP_OK) + return 0; + if (value32 != ZIP64ENDHEADERMAGIC) + return 0; + + return offset; +} + +extern zipFile ZEXPORT zipOpen4(const void *path, int append, uint64_t disk_size, const char **globalcomment, + zlib_filefunc64_32_def *pzlib_filefunc64_32_def) +{ + zip64_internal ziinit; + zip64_internal *zi = NULL; +#ifndef NO_ADDFILEINEXISTINGZIP + uint64_t byte_before_the_zipfile = 0; /* byte before the zipfile, (>0 for sfx)*/ + uint64_t size_central_dir = 0; /* size of the central directory */ + uint64_t offset_central_dir = 0; /* offset of start of central directory */ + uint64_t number_entry_CD = 0; /* total number of entries in the central dir */ + uint64_t number_entry = 0; + uint64_t central_pos = 0; + uint64_t size_central_dir_to_read = 0; + uint16_t value16 = 0; + uint32_t value32 = 0; + uint16_t size_comment = 0; + size_t buf_size = SIZEDATA_INDATABLOCK; + void *buf_read = NULL; +#endif + int err = ZIP_OK; + int mode = 0; + + ziinit.z_filefunc.zseek32_file = NULL; + ziinit.z_filefunc.ztell32_file = NULL; + + if (pzlib_filefunc64_32_def == NULL) + fill_fopen64_filefunc(&ziinit.z_filefunc.zfile_func64); else - ziinit.z_filefunc = *pzlib_filefunc_def; + ziinit.z_filefunc = *pzlib_filefunc64_32_def; - ziinit.filestream = (*(ziinit.z_filefunc.zopen_file)) - (ziinit.z_filefunc.opaque, - pathname, - (append == APPEND_STATUS_CREATE) ? - (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE) : - (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING)); + if (append == APPEND_STATUS_CREATE) + mode = (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE); + else + mode = (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING); + ziinit.filestream = ZOPEN64(ziinit.z_filefunc, path, mode); if (ziinit.filestream == NULL) return NULL; - ziinit.begin_pos = ZTELL(ziinit.z_filefunc,ziinit.filestream); + + if (append == APPEND_STATUS_CREATEAFTER) + { + /* Don't support spanning ZIP with APPEND_STATUS_CREATEAFTER */ + if (disk_size > 0) + return NULL; + + ZSEEK64(ziinit.z_filefunc,ziinit.filestream,0,SEEK_END); + } + + ziinit.filestream_with_CD = ziinit.filestream; + ziinit.append = append; + ziinit.number_disk = 0; + ziinit.number_disk_with_CD = 0; + ziinit.disk_size = disk_size; ziinit.in_opened_file_inzip = 0; ziinit.ci.stream_initialised = 0; ziinit.number_entry = 0; ziinit.add_position_when_writting_offset = 0; init_linkedlist(&(ziinit.central_dir)); - - zi = (zip_internal*)ALLOC(sizeof(zip_internal)); - if (zi==NULL) + zi = (zip64_internal*)ALLOC(sizeof(zip64_internal)); + if (zi == NULL) { - ZCLOSE(ziinit.z_filefunc,ziinit.filestream); + ZCLOSE64(ziinit.z_filefunc,ziinit.filestream); return NULL; } - /* now we add file in a zipfile */ -# ifndef NO_ADDFILEINEXISTINGZIP +#ifndef NO_ADDFILEINEXISTINGZIP + /* Add file in a zipfile */ ziinit.globalcomment = NULL; if (append == APPEND_STATUS_ADDINZIP) { - uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/ - - uLong size_central_dir; /* size of the central directory */ - uLong offset_central_dir; /* offset of start of central directory */ - uLong central_pos,uL; - - uLong number_disk; /* number of the current dist, used for - spaning ZIP, unsupported, always 0*/ - uLong number_disk_with_CD; /* number the the disk with central dir, used - for spaning ZIP, unsupported, always 0*/ - uLong number_entry; - uLong number_entry_CD; /* total number of entries in - the central dir - (same than number_entry on nospan) */ - uLong size_comment; - - central_pos = ziplocal_SearchCentralDir(&ziinit.z_filefunc,ziinit.filestream); - if (central_pos==0) - err=ZIP_ERRNO; - - if (ZSEEK(ziinit.z_filefunc, ziinit.filestream, - central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0) - err=ZIP_ERRNO; - - /* the signature, already checked */ - if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&uL)!=ZIP_OK) - err=ZIP_ERRNO; - - /* number of this disk */ - if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_disk)!=ZIP_OK) - err=ZIP_ERRNO; - - /* number of the disk with the start of the central directory */ - if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_disk_with_CD)!=ZIP_OK) - err=ZIP_ERRNO; - - /* total number of entries in the central dir on this disk */ - if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_entry)!=ZIP_OK) - err=ZIP_ERRNO; - - /* total number of entries in the central dir */ - if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_entry_CD)!=ZIP_OK) - err=ZIP_ERRNO; - - if ((number_entry_CD!=number_entry) || - (number_disk_with_CD!=0) || - (number_disk!=0)) - err=ZIP_BADZIPFILE; - - /* size of the central directory */ - if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&size_central_dir)!=ZIP_OK) - err=ZIP_ERRNO; - - /* offset of start of central directory with respect to the - starting disk number */ - if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&offset_central_dir)!=ZIP_OK) - err=ZIP_ERRNO; - - /* zipfile global comment length */ - if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&size_comment)!=ZIP_OK) - err=ZIP_ERRNO; - - if ((central_pos0) + if ((err == ZIP_OK) && (central_pos < offset_central_dir + size_central_dir)) + err = ZIP_BADZIPFILE; + + if ((err == ZIP_OK) && (size_comment > 0)) { - ziinit.globalcomment = ALLOC(size_comment+1); + ziinit.globalcomment = (char*)ALLOC(size_comment+1); if (ziinit.globalcomment) { - size_comment = ZREAD(ziinit.z_filefunc, ziinit.filestream,ziinit.globalcomment,size_comment); - ziinit.globalcomment[size_comment]=0; + if (ZREAD64(ziinit.z_filefunc, ziinit.filestream, ziinit.globalcomment, size_comment) != size_comment) + err = ZIP_ERRNO; + else + ziinit.globalcomment[size_comment] = 0; } } - byte_before_the_zipfile = central_pos - - (offset_central_dir+size_central_dir); + if (err != ZIP_OK) + { + ZCLOSE64(ziinit.z_filefunc, ziinit.filestream); + TRYFREE(ziinit.globalcomment); + TRYFREE(zi); + return NULL; + } + + byte_before_the_zipfile = central_pos - (offset_central_dir+size_central_dir); ziinit.add_position_when_writting_offset = byte_before_the_zipfile; + /* Store central directory in memory */ + size_central_dir_to_read = size_central_dir; + buf_size = SIZEDATA_INDATABLOCK; + buf_read = (void*)ALLOC(buf_size); + + if (ZSEEK64(ziinit.z_filefunc, ziinit.filestream, + offset_central_dir + byte_before_the_zipfile, ZLIB_FILEFUNC_SEEK_SET) != 0) + err = ZIP_ERRNO; + + while ((size_central_dir_to_read > 0) && (err == ZIP_OK)) { - uLong size_central_dir_to_read = size_central_dir; - size_t buf_size = SIZEDATA_INDATABLOCK; - void* buf_read = (void*)ALLOC(buf_size); - if (ZSEEK(ziinit.z_filefunc, ziinit.filestream, - offset_central_dir + byte_before_the_zipfile, - ZLIB_FILEFUNC_SEEK_SET) != 0) - err=ZIP_ERRNO; - - while ((size_central_dir_to_read>0) && (err==ZIP_OK)) - { - uLong read_this = SIZEDATA_INDATABLOCK; - if (read_this > size_central_dir_to_read) - read_this = size_central_dir_to_read; - if (ZREAD(ziinit.z_filefunc, ziinit.filestream,buf_read,read_this) != read_this) - err=ZIP_ERRNO; - - if (err==ZIP_OK) - err = add_data_in_datablock(&ziinit.central_dir,buf_read, - (uLong)read_this); - size_central_dir_to_read-=read_this; - } - TRYFREE(buf_read); + uint64_t read_this = SIZEDATA_INDATABLOCK; + if (read_this > size_central_dir_to_read) + read_this = size_central_dir_to_read; + + if (ZREAD64(ziinit.z_filefunc, ziinit.filestream, buf_read, (uint32_t)read_this) != read_this) + err = ZIP_ERRNO; + + if (err == ZIP_OK) + err = add_data_in_datablock(&ziinit.central_dir, buf_read, (uint32_t)read_this); + + size_central_dir_to_read -= read_this; } - ziinit.begin_pos = byte_before_the_zipfile; + TRYFREE(buf_read); + ziinit.number_entry = number_entry_CD; - if (ZSEEK(ziinit.z_filefunc, ziinit.filestream, - offset_central_dir+byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0) - err=ZIP_ERRNO; + if (ZSEEK64(ziinit.z_filefunc, ziinit.filestream, + offset_central_dir+byte_before_the_zipfile, ZLIB_FILEFUNC_SEEK_SET) != 0) + err = ZIP_ERRNO; } if (globalcomment) - { - *globalcomment = ziinit.globalcomment; - } -# endif /* !NO_ADDFILEINEXISTINGZIP*/ + *globalcomment = ziinit.globalcomment; +#endif if (err != ZIP_OK) { -# ifndef NO_ADDFILEINEXISTINGZIP +#ifndef NO_ADDFILEINEXISTINGZIP TRYFREE(ziinit.globalcomment); -# endif /* !NO_ADDFILEINEXISTINGZIP*/ +#endif TRYFREE(zi); return NULL; } - else + + *zi = ziinit; + zipGoToFirstDisk((zipFile)zi); + return(zipFile)zi; +} + +extern zipFile ZEXPORT zipOpen2(const char *path, int append, const char **globalcomment, + zlib_filefunc_def *pzlib_filefunc32_def) +{ + if (pzlib_filefunc32_def != NULL) + { + zlib_filefunc64_32_def zlib_filefunc64_32_def_fill; + fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill,pzlib_filefunc32_def); + return zipOpen4(path, append, 0, globalcomment, &zlib_filefunc64_32_def_fill); + } + return zipOpen4(path, append, 0, globalcomment, NULL); +} + +extern zipFile ZEXPORT zipOpen2_64(const void *path, int append, const char **globalcomment, + zlib_filefunc64_def *pzlib_filefunc_def) +{ + if (pzlib_filefunc_def != NULL) { - *zi = ziinit; - return (zipFile)zi; + zlib_filefunc64_32_def zlib_filefunc64_32_def_fill; + zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def; + zlib_filefunc64_32_def_fill.ztell32_file = NULL; + zlib_filefunc64_32_def_fill.zseek32_file = NULL; + return zipOpen4(path, append, 0, globalcomment, &zlib_filefunc64_32_def_fill); } + return zipOpen4(path, append, 0, globalcomment, NULL); } -extern zipFile ZEXPORT zipOpen (pathname, append) - const char *pathname; - int append; +extern zipFile ZEXPORT zipOpen3(const char *path, int append, uint64_t disk_size, const char **globalcomment, + zlib_filefunc_def *pzlib_filefunc32_def) { - return zipOpen2(pathname,append,NULL,NULL); + if (pzlib_filefunc32_def != NULL) + { + zlib_filefunc64_32_def zlib_filefunc64_32_def_fill; + fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill,pzlib_filefunc32_def); + return zipOpen4(path, append, disk_size, globalcomment, &zlib_filefunc64_32_def_fill); + } + return zipOpen4(path, append, disk_size, globalcomment, NULL); } -extern int ZEXPORT zipOpenNewFileInZip3 (file, filename, zipfi, - extrafield_local, size_extrafield_local, - extrafield_global, size_extrafield_global, - comment, method, level, raw, - windowBits, memLevel, strategy, - password, crcForCrypting) - zipFile file; - const char* filename; - const zip_fileinfo* zipfi; - const void* extrafield_local; - uInt size_extrafield_local; - const void* extrafield_global; - uInt size_extrafield_global; - const char* comment; - int method; - int level; - int raw; - int windowBits; - int memLevel; - int strategy; - const char* password; - uLong crcForCrypting; +extern zipFile ZEXPORT zipOpen3_64(const void *path, int append, uint64_t disk_size, const char **globalcomment, + zlib_filefunc64_def *pzlib_filefunc_def) { - zip_internal* zi; - uInt size_filename; - uInt size_comment; - uInt i; + if (pzlib_filefunc_def != NULL) + { + zlib_filefunc64_32_def zlib_filefunc64_32_def_fill; + zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def; + zlib_filefunc64_32_def_fill.ztell32_file = NULL; + zlib_filefunc64_32_def_fill.zseek32_file = NULL; + return zipOpen4(path, append, disk_size, globalcomment, &zlib_filefunc64_32_def_fill); + } + return zipOpen4(path, append, disk_size, globalcomment, NULL); +} + +extern zipFile ZEXPORT zipOpen(const char *path, int append) +{ + return zipOpen3(path, append, 0, NULL, NULL); +} + +extern zipFile ZEXPORT zipOpen64(const void *path, int append) +{ + return zipOpen3_64(path, append, 0, NULL, NULL); +} + +extern int ZEXPORT zipOpenNewFileInZip_internal(zipFile file, + const char *filename, + const zip_fileinfo *zipfi, + const void *extrafield_local, + uint16_t size_extrafield_local, + const void *extrafield_global, + uint16_t size_extrafield_global, + const char *comment, + uint16_t flag_base, + int zip64, + uint16_t method, + int level, + int raw, + int windowBits, + int memLevel, + int strategy, + const char *password, + int aes, + uint16_t version_madeby) +{ + zip64_internal *zi = NULL; + uint64_t size_available = 0; + uint64_t size_needed = 0; + uint16_t size_filename = 0; + uint16_t size_comment = 0; + uint16_t i = 0; + unsigned char *central_dir = NULL; int err = ZIP_OK; -# ifdef NOCRYPT +#ifdef NOCRYPT if (password != NULL) return ZIP_PARAMERROR; -# endif +#endif if (file == NULL) return ZIP_PARAMERROR; - if ((method!=0) && (method!=Z_DEFLATED)) + + if ((method != 0) && +#ifdef HAVE_BZIP2 + (method != Z_BZIP2ED) && +#endif + (method != Z_DEFLATED)) return ZIP_PARAMERROR; - zi = (zip_internal*)file; + zi = (zip64_internal*)file; if (zi->in_opened_file_inzip == 1) { @@ -735,291 +964,600 @@ extern int ZEXPORT zipOpenNewFileInZip3 (file, filename, zipfi, return err; } + if (filename == NULL) + filename = "-"; + if (comment != NULL) + size_comment = (uint16_t)strlen(comment); - if (filename==NULL) - filename="-"; + size_filename = (uint16_t)strlen(filename); - if (comment==NULL) - size_comment = 0; + if (zipfi == NULL) + zi->ci.dos_date = 0; else - size_comment = (uInt)strlen(comment); + zi->ci.dos_date = zipfi->dos_date; - size_filename = (uInt)strlen(filename); + zi->ci.method = method; + zi->ci.compression_method = method; + zi->ci.raw = raw; + zi->ci.flag = flag_base | 8; + if ((level == 8) || (level == 9)) + zi->ci.flag |= 2; + if (level == 2) + zi->ci.flag |= 4; + if (level == 1) + zi->ci.flag |= 6; - if (zipfi == NULL) - zi->ci.dosDate = 0; + if (password != NULL) + { + zi->ci.flag |= 1; +#ifdef HAVE_AES + if (aes) + zi->ci.method = AES_METHOD; +#endif + } else { - if (zipfi->dosDate != 0) - zi->ci.dosDate = zipfi->dosDate; - else zi->ci.dosDate = ziplocal_TmzDateToDosDate(&zipfi->tmz_date,zipfi->dosDate); + zi->ci.flag &= ~1; } - zi->ci.flag = 0; - if ((level==8) || (level==9)) - zi->ci.flag |= 2; - if ((level==2)) - zi->ci.flag |= 4; - if ((level==1)) - zi->ci.flag |= 6; - if (password != NULL) - zi->ci.flag |= 1; + if (zi->disk_size > 0) + { + if ((zi->number_disk == 0) && (zi->number_entry == 0)) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, (uint32_t)DISKHEADERMAGIC, 4); + + /* Make sure enough space available on current disk for local header */ + zipGetDiskSizeAvailable((zipFile)zi, &size_available); + size_needed = 30 + size_filename + size_extrafield_local; +#ifdef HAVE_AES + if (zi->ci.method == AES_METHOD) + size_needed += 11; +#endif + if (size_available < size_needed) + zipGoToNextDisk((zipFile)zi); + } - zi->ci.crc32 = 0; - zi->ci.method = method; - zi->ci.encrypt = 0; - zi->ci.stream_initialised = 0; - zi->ci.pos_in_buffered_data = 0; - zi->ci.raw = raw; - zi->ci.pos_local_header = ZTELL(zi->z_filefunc,zi->filestream) ; - zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename + - size_extrafield_global + size_comment; - zi->ci.central_header = (char*)ALLOC((uInt)zi->ci.size_centralheader); - - ziplocal_putValue_inmemory(zi->ci.central_header,(uLong)CENTRALHEADERMAGIC,4); - /* version info */ - ziplocal_putValue_inmemory(zi->ci.central_header+4,(uLong)VERSIONMADEBY,2); - ziplocal_putValue_inmemory(zi->ci.central_header+6,(uLong)20,2); - ziplocal_putValue_inmemory(zi->ci.central_header+8,(uLong)zi->ci.flag,2); - ziplocal_putValue_inmemory(zi->ci.central_header+10,(uLong)zi->ci.method,2); - ziplocal_putValue_inmemory(zi->ci.central_header+12,(uLong)zi->ci.dosDate,4); - ziplocal_putValue_inmemory(zi->ci.central_header+16,(uLong)0,4); /*crc*/ - ziplocal_putValue_inmemory(zi->ci.central_header+20,(uLong)0,4); /*compr size*/ - ziplocal_putValue_inmemory(zi->ci.central_header+24,(uLong)0,4); /*uncompr size*/ - ziplocal_putValue_inmemory(zi->ci.central_header+28,(uLong)size_filename,2); - ziplocal_putValue_inmemory(zi->ci.central_header+30,(uLong)size_extrafield_global,2); - ziplocal_putValue_inmemory(zi->ci.central_header+32,(uLong)size_comment,2); - ziplocal_putValue_inmemory(zi->ci.central_header+34,(uLong)0,2); /*disk nm start*/ - - if (zipfi==NULL) - ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)0,2); - else - ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)zipfi->internal_fa,2); + zi->ci.zip64 = zip64; + + zi->ci.pos_local_header = ZTELL64(zi->z_filefunc, zi->filestream); + if (zi->ci.pos_local_header >= UINT32_MAX) + zi->ci.zip64 = 1; - if (zipfi==NULL) - ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)0,4); + zi->ci.size_comment = size_comment; + zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename + size_extrafield_global; + zi->ci.size_centralextra = size_extrafield_global; + zi->ci.size_centralextrafree = 32; /* Extra space reserved for ZIP64 extra info */ +#ifdef HAVE_AES + if (zi->ci.method == AES_METHOD) + zi->ci.size_centralextrafree += 11; /* Extra space reserved for AES extra info */ +#endif + zi->ci.central_header = (char*)ALLOC((uint32_t)zi->ci.size_centralheader + zi->ci.size_centralextrafree + size_comment); + zi->ci.number_disk = zi->number_disk; + + /* Write central directory header */ + central_dir = (unsigned char*)zi->ci.central_header; + zipWriteValueToMemoryAndMove(¢ral_dir, (uint32_t)CENTRALHEADERMAGIC, 4); + zipWriteValueToMemoryAndMove(¢ral_dir, version_madeby, 2); + if (zi->ci.zip64) + zipWriteValueToMemoryAndMove(¢ral_dir, (uint16_t)45, 2); else - ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)zipfi->external_fa,4); + zipWriteValueToMemoryAndMove(¢ral_dir, (uint16_t)20, 2); + zipWriteValueToMemoryAndMove(¢ral_dir, zi->ci.flag, 2); + zipWriteValueToMemoryAndMove(¢ral_dir, zi->ci.method, 2); + zipWriteValueToMemoryAndMove(¢ral_dir, zi->ci.dos_date, 4); + zipWriteValueToMemoryAndMove(¢ral_dir, (uint32_t)0, 4); /*crc*/ + zipWriteValueToMemoryAndMove(¢ral_dir, (uint32_t)0, 4); /*compr size*/ + zipWriteValueToMemoryAndMove(¢ral_dir, (uint32_t)0, 4); /*uncompr size*/ + zipWriteValueToMemoryAndMove(¢ral_dir, size_filename, 2); + zipWriteValueToMemoryAndMove(¢ral_dir, size_extrafield_global, 2); + zipWriteValueToMemoryAndMove(¢ral_dir, size_comment, 2); + zipWriteValueToMemoryAndMove(¢ral_dir, (uint16_t)zi->ci.number_disk, 2); /*disk nm start*/ - ziplocal_putValue_inmemory(zi->ci.central_header+42,(uLong)zi->ci.pos_local_header- zi->add_position_when_writting_offset,4); + if (zipfi == NULL) + zipWriteValueToMemoryAndMove(¢ral_dir, (uint16_t)0, 2); + else + zipWriteValueToMemoryAndMove(¢ral_dir, zipfi->internal_fa, 2); + if (zipfi == NULL) + zipWriteValueToMemoryAndMove(¢ral_dir, (uint32_t)0, 4); + else + zipWriteValueToMemoryAndMove(¢ral_dir, zipfi->external_fa, 4); + if (zi->ci.pos_local_header >= UINT32_MAX) + zipWriteValueToMemoryAndMove(¢ral_dir, UINT32_MAX, 4); + else + zipWriteValueToMemoryAndMove(¢ral_dir, + (uint32_t)(zi->ci.pos_local_header - zi->add_position_when_writting_offset), 4); - for (i=0;ici.central_header+SIZECENTRALHEADER+i) = *(filename+i); + for (i = 0; i < size_filename; i++) + zi->ci.central_header[SIZECENTRALHEADER+i] = filename[i]; + for (i = 0; i < size_extrafield_global; i++) + zi->ci.central_header[SIZECENTRALHEADER+size_filename+i] = + ((const char*)extrafield_global)[i]; - for (i=0;ici.central_header+SIZECENTRALHEADER+size_filename+i) = - *(((const char*)extrafield_global)+i); + /* Store comment at the end for later repositioning */ + for (i = 0; i < size_comment; i++) + zi->ci.central_header[zi->ci.size_centralheader+ + zi->ci.size_centralextrafree+i] = comment[i]; - for (i=0;ici.central_header+SIZECENTRALHEADER+size_filename+ - size_extrafield_global+i) = *(comment+i); if (zi->ci.central_header == NULL) return ZIP_INTERNALERROR; - /* write the local header */ - err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)LOCALHEADERMAGIC,4); - - if (err==ZIP_OK) - err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)20,2);/* version needed to extract */ - if (err==ZIP_OK) - err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.flag,2); - - if (err==ZIP_OK) - err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.method,2); - - if (err==ZIP_OK) - err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.dosDate,4); + /* Write the local header */ + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, (uint32_t)LOCALHEADERMAGIC, 4); - if (err==ZIP_OK) - err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* crc 32, unknown */ - if (err==ZIP_OK) - err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* compressed size, unknown */ - if (err==ZIP_OK) - err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* uncompressed size, unknown */ - - if (err==ZIP_OK) - err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_filename,2); + if (err == ZIP_OK) + { + if (zi->ci.zip64) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, (uint16_t)45, 2); /* version needed to extract */ + else + err = zipWriteValue(&zi->z_filefunc, zi->filestream, (uint16_t)20, 2); /* version needed to extract */ + } + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, zi->ci.flag, 2); + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, zi->ci.method, 2); + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, zi->ci.dos_date, 4); + + /* CRC & compressed size & uncompressed size is in data descriptor */ + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, (uint32_t)0, 4); /* crc 32, unknown */ + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, (uint32_t)0, 4); /* compressed size, unknown */ + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, (uint32_t)0, 4); /* uncompressed size, unknown */ + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, size_filename, 2); + if (err == ZIP_OK) + { + uint64_t size_extrafield = size_extrafield_local; +#ifdef HAVE_AES + if (zi->ci.method == AES_METHOD) + size_extrafield += 11; +#endif + err = zipWriteValue(&zi->z_filefunc, zi->filestream, (uint16_t)size_extrafield, 2); + } + if ((err == ZIP_OK) && (size_filename > 0)) + { + if (ZWRITE64(zi->z_filefunc, zi->filestream, filename, size_filename) != size_filename) + err = ZIP_ERRNO; + } + if ((err == ZIP_OK) && (size_extrafield_local > 0)) + { + if (ZWRITE64(zi->z_filefunc, zi->filestream, extrafield_local, size_extrafield_local) != size_extrafield_local) + err = ZIP_ERRNO; + } - if (err==ZIP_OK) - err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_extrafield_local,2); +#ifdef HAVE_AES + /* Write the AES extended info */ + if ((err == ZIP_OK) && (zi->ci.method == AES_METHOD)) + { + int headerid = 0x9901; + short datasize = 7; - if ((err==ZIP_OK) && (size_filename>0)) - if (ZWRITE(zi->z_filefunc,zi->filestream,filename,size_filename)!=size_filename) - err = ZIP_ERRNO; + err = zipWriteValue(&zi->z_filefunc, zi->filestream, headerid, 2); + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, datasize, 2); + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, AES_VERSION, 2); + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, 'A', 1); + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, 'E', 1); + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, AES_ENCRYPTIONMODE, 1); + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, zi->ci.compression_method, 2); + } +#endif - if ((err==ZIP_OK) && (size_extrafield_local>0)) - if (ZWRITE(zi->z_filefunc,zi->filestream,extrafield_local,size_extrafield_local) - !=size_extrafield_local) - err = ZIP_ERRNO; + zi->ci.crc32 = 0; + zi->ci.stream_initialised = 0; + zi->ci.pos_in_buffered_data = 0; + zi->ci.total_compressed = 0; + zi->ci.total_uncompressed = 0; + +#ifdef HAVE_BZIP2 + zi->ci.bstream.avail_in = (uint16_t)0; + zi->ci.bstream.avail_out = (uint16_t)Z_BUFSIZE; + zi->ci.bstream.next_out = (char*)zi->ci.buffered_data; + zi->ci.bstream.total_in_hi32 = 0; + zi->ci.bstream.total_in_lo32 = 0; + zi->ci.bstream.total_out_hi32 = 0; + zi->ci.bstream.total_out_lo32 = 0; +#endif - zi->ci.stream.avail_in = (uInt)0; - zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; + zi->ci.stream.avail_in = (uint16_t)0; + zi->ci.stream.avail_out = Z_BUFSIZE; zi->ci.stream.next_out = zi->ci.buffered_data; zi->ci.stream.total_in = 0; zi->ci.stream.total_out = 0; + zi->ci.stream.data_type = Z_BINARY; - if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) + if ((err == ZIP_OK) && (!zi->ci.raw)) { - zi->ci.stream.zalloc = (alloc_func)0; - zi->ci.stream.zfree = (free_func)0; - zi->ci.stream.opaque = (voidpf)0; - - if (windowBits>0) - windowBits = -windowBits; + if (method == Z_DEFLATED) + { + zi->ci.stream.zalloc = (alloc_func)0; + zi->ci.stream.zfree = (free_func)0; + zi->ci.stream.opaque = (voidpf)zi; - err = deflateInit2(&zi->ci.stream, level, - Z_DEFLATED, windowBits, memLevel, strategy); + if (windowBits > 0) + windowBits = -windowBits; - if (err==Z_OK) - zi->ci.stream_initialised = 1; +#ifdef HAVE_APPLE_COMPRESSION + err = compression_stream_init(&zi->ci.astream, COMPRESSION_STREAM_ENCODE, COMPRESSION_ZLIB); + if (err == COMPRESSION_STATUS_ERROR) + err = Z_ERRNO; + else + err = Z_OK; +#else + err = deflateInit2(&zi->ci.stream, level, Z_DEFLATED, windowBits, memLevel, strategy); +#endif + if (err == Z_OK) + zi->ci.stream_initialised = Z_DEFLATED; + } + else if (method == Z_BZIP2ED) + { +#ifdef HAVE_BZIP2 + zi->ci.bstream.bzalloc = 0; + zi->ci.bstream.bzfree = 0; + zi->ci.bstream.opaque = (voidpf)0; + + err = BZ2_bzCompressInit(&zi->ci.bstream, level, 0, 35); + if (err == BZ_OK) + zi->ci.stream_initialised = Z_BZIP2ED; +#endif + } } -# ifndef NOCRYPT - zi->ci.crypt_header_size = 0; - if ((err==Z_OK) && (password != NULL)) + +#ifndef NOCRYPT + if ((err == Z_OK) && (password != NULL)) { - unsigned char bufHead[RAND_HEAD_LEN]; - unsigned int sizeHead; - zi->ci.encrypt = 1; - zi->ci.pcrc_32_tab = get_crc_table(); - /*init_keys(password,zi->ci.keys,zi->ci.pcrc_32_tab);*/ +#ifdef HAVE_AES + if (zi->ci.method == AES_METHOD) + { + unsigned char passverify[AES_PWVERIFYSIZE]; + unsigned char saltvalue[AES_MAXSALTLENGTH]; + uint16_t saltlength = 0; + + if ((AES_ENCRYPTIONMODE < 1) || (AES_ENCRYPTIONMODE > 3)) + return Z_ERRNO; + + saltlength = SALT_LENGTH(AES_ENCRYPTIONMODE); + + prng_init(cryptrand, zi->ci.aes_rng); + prng_rand(saltvalue, saltlength, zi->ci.aes_rng); + prng_end(zi->ci.aes_rng); + + fcrypt_init(AES_ENCRYPTIONMODE, (uint8_t *)password, (uint32_t)strlen(password), saltvalue, passverify, &zi->ci.aes_ctx); + + if (ZWRITE64(zi->z_filefunc, zi->filestream, saltvalue, saltlength) != saltlength) + err = ZIP_ERRNO; + if (ZWRITE64(zi->z_filefunc, zi->filestream, passverify, AES_PWVERIFYSIZE) != AES_PWVERIFYSIZE) + err = ZIP_ERRNO; + + zi->ci.total_compressed += saltlength + AES_PWVERIFYSIZE + AES_AUTHCODESIZE; + } + else +#endif + { + unsigned char buf_head[RAND_HEAD_LEN]; + uint32_t size_head = 0; + uint8_t verify1 = 0; + uint8_t verify2 = 0; + + zi->ci.pcrc_32_tab = get_crc_table(); + + /* + Info-ZIP modification to ZipCrypto format: + If bit 3 of the general purpose bit flag is set, it uses high byte of 16-bit File Time. + */ + verify1 = (uint8_t)((zi->ci.dos_date >> 16) & 0xff); + verify2 = (uint8_t)((zi->ci.dos_date >> 8) & 0xff); - sizeHead=crypthead(password,bufHead,RAND_HEAD_LEN,zi->ci.keys,zi->ci.pcrc_32_tab,crcForCrypting); - zi->ci.crypt_header_size = sizeHead; + size_head = crypthead(password, buf_head, RAND_HEAD_LEN, zi->ci.keys, zi->ci.pcrc_32_tab, verify1, verify2); + zi->ci.total_compressed += size_head; - if (ZWRITE(zi->z_filefunc,zi->filestream,bufHead,sizeHead) != sizeHead) + if (ZWRITE64(zi->z_filefunc, zi->filestream, buf_head, size_head) != size_head) err = ZIP_ERRNO; + } } -# endif +#endif - if (err==Z_OK) + if (err == Z_OK) zi->in_opened_file_inzip = 1; return err; } -extern int ZEXPORT zipOpenNewFileInZip2(file, filename, zipfi, - extrafield_local, size_extrafield_local, - extrafield_global, size_extrafield_global, - comment, method, level, raw) - zipFile file; - const char* filename; - const zip_fileinfo* zipfi; - const void* extrafield_local; - uInt size_extrafield_local; - const void* extrafield_global; - uInt size_extrafield_global; - const char* comment; - int method; - int level; - int raw; +extern int ZEXPORT zipOpenNewFileInZip5(zipFile file, const char *filename, const zip_fileinfo *zipfi, + const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, + uint16_t size_extrafield_global, const char *comment, uint16_t flag_base, int zip64, uint16_t method, int level, int raw, + int windowBits, int memLevel, int strategy, const char *password, int aes) +{ + return zipOpenNewFileInZip_internal(file, filename, zipfi, extrafield_local, size_extrafield_local, extrafield_global, + size_extrafield_global, comment, flag_base, zip64, method, level, raw, windowBits, memLevel, strategy, password, aes, + VERSIONMADEBY); +} + +extern int ZEXPORT zipOpenNewFileInZip4_64(zipFile file, const char *filename, const zip_fileinfo *zipfi, + const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, + uint16_t size_extrafield_global, const char *comment, uint16_t method, int level, int raw, int windowBits, int memLevel, + int strategy, const char *password, ZIP_UNUSED uint32_t crc_for_crypting, uint16_t version_madeby, uint16_t flag_base, int zip64) +{ + uint8_t aes = 0; +#ifdef HAVE_AES + aes = 1; +#endif + return zipOpenNewFileInZip_internal(file, filename, zipfi, extrafield_local, size_extrafield_local, extrafield_global, + size_extrafield_global, comment, flag_base, zip64, method, level, raw, windowBits, memLevel, strategy, password, aes, + version_madeby); +} + +extern int ZEXPORT zipOpenNewFileInZip4(zipFile file, const char *filename, const zip_fileinfo *zipfi, + const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, + uint16_t size_extrafield_global, const char *comment, uint16_t method, int level, int raw, int windowBits, + int memLevel, int strategy, const char *password, ZIP_UNUSED uint32_t crc_for_crypting, uint16_t version_madeby, uint16_t flag_base) +{ + return zipOpenNewFileInZip4_64(file, filename, zipfi, extrafield_local, size_extrafield_local, + extrafield_global, size_extrafield_global, comment, method, level, raw, windowBits, memLevel, + strategy, password, crc_for_crypting, version_madeby, flag_base, 0); +} + +extern int ZEXPORT zipOpenNewFileInZip3(zipFile file, const char *filename, const zip_fileinfo *zipfi, + const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, + uint16_t size_extrafield_global, const char *comment, uint16_t method, int level, int raw, int windowBits, + int memLevel, int strategy, const char *password, ZIP_UNUSED uint32_t crc_for_crypting) +{ + return zipOpenNewFileInZip4_64(file, filename, zipfi, extrafield_local, size_extrafield_local, + extrafield_global, size_extrafield_global, comment, method, level, raw, windowBits, memLevel, + strategy, password, crc_for_crypting, VERSIONMADEBY, 0, 0); +} + +extern int ZEXPORT zipOpenNewFileInZip3_64(zipFile file, const char *filename, const zip_fileinfo *zipfi, + const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, + uint16_t size_extrafield_global, const char *comment, uint16_t method, int level, int raw, int windowBits, + int memLevel, int strategy, const char *password, ZIP_UNUSED uint32_t crc_for_crypting, int zip64) { - return zipOpenNewFileInZip3 (file, filename, zipfi, - extrafield_local, size_extrafield_local, - extrafield_global, size_extrafield_global, - comment, method, level, raw, - -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, - NULL, 0); + return zipOpenNewFileInZip4_64(file, filename, zipfi, extrafield_local, size_extrafield_local, + extrafield_global, size_extrafield_global, comment, method, level, raw, windowBits, memLevel, strategy, + password, crc_for_crypting, VERSIONMADEBY, 0, zip64); } -extern int ZEXPORT zipOpenNewFileInZip (file, filename, zipfi, - extrafield_local, size_extrafield_local, - extrafield_global, size_extrafield_global, - comment, method, level) - zipFile file; - const char* filename; - const zip_fileinfo* zipfi; - const void* extrafield_local; - uInt size_extrafield_local; - const void* extrafield_global; - uInt size_extrafield_global; - const char* comment; - int method; - int level; +extern int ZEXPORT zipOpenNewFileInZip2(zipFile file, const char *filename, const zip_fileinfo *zipfi, + const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, + uint16_t size_extrafield_global, const char *comment, uint16_t method, int level, int raw) { - return zipOpenNewFileInZip2 (file, filename, zipfi, - extrafield_local, size_extrafield_local, - extrafield_global, size_extrafield_global, - comment, method, level, 0); + return zipOpenNewFileInZip4_64(file, filename, zipfi, extrafield_local, size_extrafield_local, + extrafield_global, size_extrafield_global, comment, method, level, raw, -MAX_WBITS, DEF_MEM_LEVEL, + Z_DEFAULT_STRATEGY, NULL, 0, VERSIONMADEBY, 0, 0); } -local int zipFlushWriteBuffer(zi) - zip_internal* zi; +extern int ZEXPORT zipOpenNewFileInZip2_64(zipFile file, const char *filename, const zip_fileinfo *zipfi, + const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, + uint16_t size_extrafield_global, const char *comment, uint16_t method, int level, int raw, int zip64) { - int err=ZIP_OK; + return zipOpenNewFileInZip4_64(file, filename, zipfi, extrafield_local, size_extrafield_local, + extrafield_global, size_extrafield_global, comment, method, level, raw, -MAX_WBITS, DEF_MEM_LEVEL, + Z_DEFAULT_STRATEGY, NULL, 0, VERSIONMADEBY, 0, zip64); +} + +extern int ZEXPORT zipOpenNewFileInZip64(zipFile file, const char *filename, const zip_fileinfo *zipfi, + const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, + uint16_t size_extrafield_global, const char *comment, uint16_t method, int level, int zip64) +{ + return zipOpenNewFileInZip4_64(file, filename, zipfi, extrafield_local, size_extrafield_local, + extrafield_global, size_extrafield_global, comment, method, level, 0, -MAX_WBITS, DEF_MEM_LEVEL, + Z_DEFAULT_STRATEGY, NULL, 0, VERSIONMADEBY, 0, zip64); +} + +extern int ZEXPORT zipOpenNewFileInZip(zipFile file, const char *filename, const zip_fileinfo *zipfi, + const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, + uint16_t size_extrafield_global, const char *comment, uint16_t method, int level) +{ + return zipOpenNewFileInZip4_64(file, filename, zipfi, extrafield_local, size_extrafield_local, + extrafield_global, size_extrafield_global, comment, method, level, 0, -MAX_WBITS, DEF_MEM_LEVEL, + Z_DEFAULT_STRATEGY, NULL, 0, VERSIONMADEBY, 0, 0); +} + +/* Flushes the write buffer to disk */ +static int zipFlushWriteBuffer(zip64_internal *zi) +{ + uint64_t size_available = 0; + uint32_t written = 0; + uint32_t total_written = 0; + uint32_t write = 0; + uint32_t max_write = 0; + int err = ZIP_OK; - if (zi->ci.encrypt != 0) + if ((zi->ci.flag & 1) != 0) { #ifndef NOCRYPT - uInt i; - int t; - for (i=0;ici.pos_in_buffered_data;i++) - zi->ci.buffered_data[i] = zencode(zi->ci.keys, zi->ci.pcrc_32_tab, - zi->ci.buffered_data[i],t); +#ifdef HAVE_AES + if (zi->ci.method == AES_METHOD) + { + fcrypt_encrypt(zi->ci.buffered_data, zi->ci.pos_in_buffered_data, &zi->ci.aes_ctx); + } + else +#endif + { + uint32_t i = 0; + uint8_t t = 0; + + for (i = 0; i < zi->ci.pos_in_buffered_data; i++) + zi->ci.buffered_data[i] = (uint8_t)zencode(zi->ci.keys, zi->ci.pcrc_32_tab, zi->ci.buffered_data[i], t); + } +#endif + } + + write = zi->ci.pos_in_buffered_data; + + do + { + max_write = write; + + if (zi->disk_size > 0) + { + zipGetDiskSizeAvailable((zipFile)zi, &size_available); + + if (size_available == 0) + { + err = zipGoToNextDisk((zipFile)zi); + if (err != ZIP_OK) + return err; + } + + if (size_available < (uint64_t)max_write) + max_write = (uint32_t)size_available; + } + + written = ZWRITE64(zi->z_filefunc, zi->filestream, zi->ci.buffered_data + total_written, max_write); + if (written != max_write) + { + err = ZIP_ERRNO; + break; + } + + total_written += written; + write -= written; + } + while (write > 0); + + zi->ci.total_compressed += zi->ci.pos_in_buffered_data; + +#ifdef HAVE_BZIP2 + if (zi->ci.compression_method == Z_BZIP2ED) + { + zi->ci.total_uncompressed += zi->ci.bstream.total_in_lo32; + zi->ci.bstream.total_in_lo32 = 0; + zi->ci.bstream.total_in_hi32 = 0; + } + else #endif + { + zi->ci.total_uncompressed += zi->ci.stream.total_in; + zi->ci.stream.total_in = 0; } - if (ZWRITE(zi->z_filefunc,zi->filestream,zi->ci.buffered_data,zi->ci.pos_in_buffered_data) - !=zi->ci.pos_in_buffered_data) - err = ZIP_ERRNO; + zi->ci.pos_in_buffered_data = 0; + return err; } -extern int ZEXPORT zipWriteInFileInZip (file, buf, len) - zipFile file; - const void* buf; - unsigned len; +extern int ZEXPORT zipWriteInFileInZip(zipFile file, const void *buf, uint32_t len) { - zip_internal* zi; - int err=ZIP_OK; + zip64_internal *zi = NULL; + int err = ZIP_OK; if (file == NULL) return ZIP_PARAMERROR; - zi = (zip_internal*)file; + zi = (zip64_internal*)file; if (zi->in_opened_file_inzip == 0) return ZIP_PARAMERROR; - zi->ci.stream.next_in = (void*)buf; - zi->ci.stream.avail_in = len; - zi->ci.crc32 = crc32(zi->ci.crc32,buf,len); + zi->ci.crc32 = (uint32_t)crc32(zi->ci.crc32, buf, len); - while ((err==ZIP_OK) && (zi->ci.stream.avail_in>0)) +#ifdef HAVE_BZIP2 + if ((zi->ci.compression_method == Z_BZIP2ED) && (!zi->ci.raw)) { - if (zi->ci.stream.avail_out == 0) + zi->ci.bstream.next_in = (void*)buf; + zi->ci.bstream.avail_in = len; + err = BZ_RUN_OK; + + while ((err == BZ_RUN_OK) && (zi->ci.bstream.avail_in > 0)) { - if (zipFlushWriteBuffer(zi) == ZIP_ERRNO) - err = ZIP_ERRNO; - zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; - zi->ci.stream.next_out = zi->ci.buffered_data; - } + if (zi->ci.bstream.avail_out == 0) + { + err = zipFlushWriteBuffer(zi); + + zi->ci.bstream.avail_out = (uint16_t)Z_BUFSIZE; + zi->ci.bstream.next_out = (char*)zi->ci.buffered_data; + } + else + { + uint32_t total_out_before_lo = zi->ci.bstream.total_out_lo32; + uint32_t total_out_before_hi = zi->ci.bstream.total_out_hi32; + err = BZ2_bzCompress(&zi->ci.bstream, BZ_RUN); - if(err != ZIP_OK) - break; + zi->ci.pos_in_buffered_data += (uint16_t)(zi->ci.bstream.total_out_lo32 - total_out_before_lo); + } + } - if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) - { - uLong uTotalOutBefore = zi->ci.stream.total_out; - err=deflate(&zi->ci.stream, Z_NO_FLUSH); - zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ; + if (err == BZ_RUN_OK) + err = ZIP_OK; + } + else +#endif + { + zi->ci.stream.next_in = (uint8_t*)buf; + zi->ci.stream.avail_in = len; - } - else + while ((err == ZIP_OK) && (zi->ci.stream.avail_in > 0)) { - uInt copy_this,i; - if (zi->ci.stream.avail_in < zi->ci.stream.avail_out) - copy_this = zi->ci.stream.avail_in; + if (zi->ci.stream.avail_out == 0) + { + err = zipFlushWriteBuffer(zi); + + zi->ci.stream.avail_out = Z_BUFSIZE; + zi->ci.stream.next_out = zi->ci.buffered_data; + } + + if (err != ZIP_OK) + break; + + if ((zi->ci.compression_method == Z_DEFLATED) && (!zi->ci.raw)) + { +#ifdef HAVE_APPLE_COMPRESSION + uint32_t total_out_before = (uint32_t)zi->ci.stream.total_out; + + zi->ci.astream.src_ptr = zi->ci.stream.next_in; + zi->ci.astream.src_size = zi->ci.stream.avail_in; + zi->ci.astream.dst_ptr = zi->ci.stream.next_out; + zi->ci.astream.dst_size = zi->ci.stream.avail_out; + + compression_status status = 0; + compression_stream_flags flags = 0; + + status = compression_stream_process(&zi->ci.astream, flags); + + uint32_t total_out_after = len - zi->ci.astream.src_size; + + zi->ci.stream.next_in = zi->ci.astream.src_ptr; + zi->ci.stream.avail_in = zi->ci.astream.src_size; + zi->ci.stream.next_out = zi->ci.astream.dst_ptr; + zi->ci.stream.avail_out = zi->ci.astream.dst_size; + zi->ci.stream.total_in += total_out_after; + //zi->ci.stream.total_out += copy_this; + zi->ci.pos_in_buffered_data += total_out_after; + + if (status == COMPRESSION_STATUS_ERROR) + err = ZIP_INTERNALERROR; +#else + uint32_t total_out_before = (uint32_t)zi->ci.stream.total_out; + err = deflate(&zi->ci.stream, Z_NO_FLUSH); + zi->ci.pos_in_buffered_data += (uint32_t)(zi->ci.stream.total_out - total_out_before); +#endif + } else - copy_this = zi->ci.stream.avail_out; - for (i=0;ici.stream.next_out)+i) = - *(((const char*)zi->ci.stream.next_in)+i); { + uint32_t copy_this = 0; + uint32_t i = 0; + if (zi->ci.stream.avail_in < zi->ci.stream.avail_out) + copy_this = zi->ci.stream.avail_in; + else + copy_this = zi->ci.stream.avail_out; + + for (i = 0; i < copy_this; i++) + *(((char*)zi->ci.stream.next_out)+i) = + *(((const char*)zi->ci.stream.next_in)+i); + zi->ci.stream.avail_in -= copy_this; - zi->ci.stream.avail_out-= copy_this; - zi->ci.stream.next_in+= copy_this; - zi->ci.stream.next_out+= copy_this; - zi->ci.stream.total_in+= copy_this; - zi->ci.stream.total_out+= copy_this; + zi->ci.stream.avail_out -= copy_this; + zi->ci.stream.next_in += copy_this; + zi->ci.stream.next_out += copy_this; + zi->ci.stream.total_in += copy_this; + zi->ci.stream.total_out += copy_this; zi->ci.pos_in_buffered_data += copy_this; } } @@ -1028,187 +1566,450 @@ extern int ZEXPORT zipWriteInFileInZip (file, buf, len) return err; } -extern int ZEXPORT zipCloseFileInZipRaw (file, uncompressed_size, crc32) - zipFile file; - uLong uncompressed_size; - uLong crc32; +extern int ZEXPORT zipCloseFileInZipRaw64(zipFile file, uint64_t uncompressed_size, uint32_t crc32) { - zip_internal* zi; - uLong compressed_size; - int err=ZIP_OK; + zip64_internal *zi = NULL; + uint16_t extra_data_size = 0; + uint32_t i = 0; + unsigned char *extra_info = NULL; + int err = ZIP_OK; if (file == NULL) return ZIP_PARAMERROR; - zi = (zip_internal*)file; + zi = (zip64_internal*)file; if (zi->in_opened_file_inzip == 0) return ZIP_PARAMERROR; zi->ci.stream.avail_in = 0; - if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) - while (err==ZIP_OK) + if (!zi->ci.raw) { - uLong uTotalOutBefore; - if (zi->ci.stream.avail_out == 0) + if (zi->ci.compression_method == Z_DEFLATED) { - if (zipFlushWriteBuffer(zi) == ZIP_ERRNO) - err = ZIP_ERRNO; - zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; - zi->ci.stream.next_out = zi->ci.buffered_data; + while (err == ZIP_OK) + { + uint32_t total_out_before = 0; + + if (zi->ci.stream.avail_out == 0) + { + err = zipFlushWriteBuffer(zi); + + zi->ci.stream.avail_out = Z_BUFSIZE; + zi->ci.stream.next_out = zi->ci.buffered_data; + } + + if (err != ZIP_OK) + break; + +#ifdef HAVE_APPLE_COMPRESSION + total_out_before = zi->ci.stream.total_out; + + zi->ci.astream.src_ptr = zi->ci.stream.next_in; + zi->ci.astream.src_size = zi->ci.stream.avail_in; + zi->ci.astream.dst_ptr = zi->ci.stream.next_out; + zi->ci.astream.dst_size = zi->ci.stream.avail_out; + + compression_status status = 0; + status = compression_stream_process(&zi->ci.astream, COMPRESSION_STREAM_FINALIZE); + + uint32_t total_out_after = Z_BUFSIZE - zi->ci.astream.dst_size; + + zi->ci.stream.next_in = zi->ci.astream.src_ptr; + zi->ci.stream.avail_in = zi->ci.astream.src_size; + zi->ci.stream.next_out = zi->ci.astream.dst_ptr; + zi->ci.stream.avail_out = zi->ci.astream.dst_size; + //zi->ci.stream.total_in += total_out_after; + //zi->ci.stream.total_out += copy_this; + zi->ci.pos_in_buffered_data += total_out_after; + + if (status == COMPRESSION_STATUS_ERROR) + { + err = ZIP_INTERNALERROR; + } + else if (status == COMPRESSION_STATUS_END) + { + err = Z_STREAM_END; + } +#else + total_out_before = (uint32_t)zi->ci.stream.total_out; + err = deflate(&zi->ci.stream, Z_FINISH); + zi->ci.pos_in_buffered_data += (uint16_t)(zi->ci.stream.total_out - total_out_before); +#endif + } + } + else if (zi->ci.compression_method == Z_BZIP2ED) + { +#ifdef HAVE_BZIP2 + err = BZ_FINISH_OK; + while (err == BZ_FINISH_OK) + { + uint32_t total_out_before = 0; + + if (zi->ci.bstream.avail_out == 0) + { + err = zipFlushWriteBuffer(zi); + + zi->ci.bstream.avail_out = (uint16_t)Z_BUFSIZE; + zi->ci.bstream.next_out = (char*)zi->ci.buffered_data; + } + + total_out_before = zi->ci.bstream.total_out_lo32; + err = BZ2_bzCompress(&zi->ci.bstream, BZ_FINISH); + if (err == BZ_STREAM_END) + err = Z_STREAM_END; + zi->ci.pos_in_buffered_data += (uint16_t)(zi->ci.bstream.total_out_lo32 - total_out_before); + } + + if (err == BZ_FINISH_OK) + err = ZIP_OK; +#endif } - uTotalOutBefore = zi->ci.stream.total_out; - err=deflate(&zi->ci.stream, Z_FINISH); - zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ; } - if (err==Z_STREAM_END) - err=ZIP_OK; /* this is normal */ + if (err == Z_STREAM_END) + err = ZIP_OK; /* this is normal */ - if ((zi->ci.pos_in_buffered_data>0) && (err==ZIP_OK)) - if (zipFlushWriteBuffer(zi)==ZIP_ERRNO) - err = ZIP_ERRNO; + if ((zi->ci.pos_in_buffered_data > 0) && (err == ZIP_OK)) + { + err = zipFlushWriteBuffer(zi); + } - if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) +#ifdef HAVE_AES + if (zi->ci.method == AES_METHOD) { - err=deflateEnd(&zi->ci.stream); - zi->ci.stream_initialised = 0; + unsigned char authcode[AES_AUTHCODESIZE]; + + fcrypt_end(authcode, &zi->ci.aes_ctx); + + if (ZWRITE64(zi->z_filefunc, zi->filestream, authcode, AES_AUTHCODESIZE) != AES_AUTHCODESIZE) + err = ZIP_ERRNO; } +#endif if (!zi->ci.raw) { - crc32 = (uLong)zi->ci.crc32; - uncompressed_size = (uLong)zi->ci.stream.total_in; + if (zi->ci.compression_method == Z_DEFLATED) + { + int tmp_err = 0; +#ifdef HAVE_APPLE_COMPRESSION + tmp_err = compression_stream_destroy(&zi->ci.astream); +#else + tmp_err = deflateEnd(&zi->ci.stream); +#endif + if (err == ZIP_OK) + err = tmp_err; + zi->ci.stream_initialised = 0; + } +#ifdef HAVE_BZIP2 + else if (zi->ci.compression_method == Z_BZIP2ED) + { + int tmperr = BZ2_bzCompressEnd(&zi->ci.bstream); + if (err == ZIP_OK) + err = tmperr; + zi->ci.stream_initialised = 0; + } +#endif + + crc32 = zi->ci.crc32; + uncompressed_size = zi->ci.total_uncompressed; } - compressed_size = (uLong)zi->ci.stream.total_out; -# ifndef NOCRYPT - compressed_size += zi->ci.crypt_header_size; -# endif - - ziplocal_putValue_inmemory(zi->ci.central_header+16,crc32,4); /*crc*/ - ziplocal_putValue_inmemory(zi->ci.central_header+20, - compressed_size,4); /*compr size*/ + + /* Write data descriptor */ + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, (uint32_t)DATADESCRIPTORMAGIC, 4); + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, crc32, 4); + if (err == ZIP_OK) + { + if (zi->ci.zip64) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, zi->ci.total_compressed, 8); + else + err = zipWriteValue(&zi->z_filefunc, zi->filestream, (uint32_t)zi->ci.total_compressed, 4); + } + if (err == ZIP_OK) + { + if (zi->ci.zip64) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, uncompressed_size, 8); + else + err = zipWriteValue(&zi->z_filefunc, zi->filestream, (uint32_t)uncompressed_size, 4); + } + + /* Update crc and sizes to central directory */ + zipWriteValueToMemory(zi->ci.central_header + 16, crc32, 4); /* crc */ + if (zi->ci.total_compressed >= UINT32_MAX) + zipWriteValueToMemory(zi->ci.central_header + 20, UINT32_MAX, 4); /* compr size */ + else + zipWriteValueToMemory(zi->ci.central_header + 20, zi->ci.total_compressed, 4); /* compr size */ + if (uncompressed_size >= UINT32_MAX) + zipWriteValueToMemory(zi->ci.central_header + 24, UINT32_MAX, 4); /* uncompr size */ + else + zipWriteValueToMemory(zi->ci.central_header + 24, uncompressed_size, 4); /* uncompr size */ if (zi->ci.stream.data_type == Z_ASCII) - ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)Z_ASCII,2); - ziplocal_putValue_inmemory(zi->ci.central_header+24, - uncompressed_size,4); /*uncompr size*/ + zipWriteValueToMemory(zi->ci.central_header + 36, (uint16_t)Z_ASCII, 2); /* internal file attrib */ + + /* Add ZIP64 extra info field for uncompressed size */ + if (uncompressed_size >= UINT32_MAX) + extra_data_size += 8; + /* Add ZIP64 extra info field for compressed size */ + if (zi->ci.total_compressed >= UINT32_MAX) + extra_data_size += 8; + /* Add ZIP64 extra info field for relative offset to local file header of current file */ + if (zi->ci.pos_local_header >= UINT32_MAX) + extra_data_size += 8; + + /* Add ZIP64 extra info header to central directory */ + if (extra_data_size > 0) + { + if ((uint32_t)(extra_data_size + 4) > zi->ci.size_centralextrafree) + return ZIP_BADZIPFILE; - if (err==ZIP_OK) - err = add_data_in_datablock(&zi->central_dir,zi->ci.central_header, - (uLong)zi->ci.size_centralheader); - free(zi->ci.central_header); + extra_info = (unsigned char*)zi->ci.central_header + zi->ci.size_centralheader; + + zipWriteValueToMemoryAndMove(&extra_info, 0x0001, 2); + zipWriteValueToMemoryAndMove(&extra_info, extra_data_size, 2); + + if (uncompressed_size >= UINT32_MAX) + zipWriteValueToMemoryAndMove(&extra_info, uncompressed_size, 8); + if (zi->ci.total_compressed >= UINT32_MAX) + zipWriteValueToMemoryAndMove(&extra_info, zi->ci.total_compressed, 8); + if (zi->ci.pos_local_header >= UINT32_MAX) + zipWriteValueToMemoryAndMove(&extra_info, zi->ci.pos_local_header, 8); + + zi->ci.size_centralextrafree -= extra_data_size + 4; + zi->ci.size_centralheader += extra_data_size + 4; + zi->ci.size_centralextra += extra_data_size + 4; + + zipWriteValueToMemory(zi->ci.central_header + 30, zi->ci.size_centralextra, 2); + } - if (err==ZIP_OK) +#ifdef HAVE_AES + /* Write AES extra info header to central directory */ + if (zi->ci.method == AES_METHOD) { - long cur_pos_inzip = ZTELL(zi->z_filefunc,zi->filestream); - if (ZSEEK(zi->z_filefunc,zi->filestream, - zi->ci.pos_local_header + 14,ZLIB_FILEFUNC_SEEK_SET)!=0) - err = ZIP_ERRNO; + extra_info = (unsigned char*)zi->ci.central_header + zi->ci.size_centralheader; + extra_data_size = 7; - if (err==ZIP_OK) - err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,crc32,4); /* crc 32, unknown */ + if ((uint32_t)(extra_data_size + 4) > zi->ci.size_centralextrafree) + return ZIP_BADZIPFILE; - if (err==ZIP_OK) /* compressed size, unknown */ - err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,compressed_size,4); + zipWriteValueToMemoryAndMove(&extra_info, 0x9901, 2); + zipWriteValueToMemoryAndMove(&extra_info, extra_data_size, 2); + zipWriteValueToMemoryAndMove(&extra_info, AES_VERSION, 2); + zipWriteValueToMemoryAndMove(&extra_info, 'A', 1); + zipWriteValueToMemoryAndMove(&extra_info, 'E', 1); + zipWriteValueToMemoryAndMove(&extra_info, AES_ENCRYPTIONMODE, 1); + zipWriteValueToMemoryAndMove(&extra_info, zi->ci.compression_method, 2); - if (err==ZIP_OK) /* uncompressed size, unknown */ - err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,uncompressed_size,4); + zi->ci.size_centralextrafree -= extra_data_size + 4; + zi->ci.size_centralheader += extra_data_size + 4; + zi->ci.size_centralextra += extra_data_size + 4; - if (ZSEEK(zi->z_filefunc,zi->filestream, - cur_pos_inzip,ZLIB_FILEFUNC_SEEK_SET)!=0) - err = ZIP_ERRNO; + zipWriteValueToMemory(zi->ci.central_header + 30, zi->ci.size_centralextra, 2); } +#endif + /* Restore comment to correct position */ + for (i = 0; i < zi->ci.size_comment; i++) + zi->ci.central_header[zi->ci.size_centralheader+i] = + zi->ci.central_header[zi->ci.size_centralheader+zi->ci.size_centralextrafree+i]; + zi->ci.size_centralheader += zi->ci.size_comment; + + if (err == ZIP_OK) + err = add_data_in_datablock(&zi->central_dir, zi->ci.central_header, zi->ci.size_centralheader); - zi->number_entry ++; + free(zi->ci.central_header); + + zi->number_entry++; zi->in_opened_file_inzip = 0; return err; } -extern int ZEXPORT zipCloseFileInZip (file) - zipFile file; +extern int ZEXPORT zipCloseFileInZipRaw(zipFile file, uint32_t uncompressed_size, uint32_t crc32) +{ + return zipCloseFileInZipRaw64(file, uncompressed_size, crc32); +} + +extern int ZEXPORT zipCloseFileInZip(zipFile file) +{ + return zipCloseFileInZipRaw(file, 0, 0); +} + +extern int ZEXPORT zipClose(zipFile file, const char *global_comment) { - return zipCloseFileInZipRaw (file,0,0); + return zipClose_64(file, global_comment); } -extern int ZEXPORT zipClose (file, global_comment) - zipFile file; - const char* global_comment; +extern int ZEXPORT zipClose_64(zipFile file, const char *global_comment) { - zip_internal* zi; - int err = 0; - uLong size_centraldir = 0; - uLong centraldir_pos_inzip; - uInt size_global_comment; + return zipClose2_64(file, global_comment, VERSIONMADEBY); +} + +extern int ZEXPORT zipClose2_64(zipFile file, const char *global_comment, uint16_t version_madeby) +{ + zip64_internal *zi = NULL; + uint32_t size_centraldir = 0; + uint16_t size_global_comment = 0; + uint64_t centraldir_pos_inzip = 0; + uint64_t pos = 0; + uint64_t cd_pos = 0; + uint32_t write = 0; + int err = ZIP_OK; + if (file == NULL) return ZIP_PARAMERROR; - zi = (zip_internal*)file; + zi = (zip64_internal*)file; if (zi->in_opened_file_inzip == 1) - { - err = zipCloseFileInZip (file); - } + err = zipCloseFileInZip(file); #ifndef NO_ADDFILEINEXISTINGZIP - if (global_comment==NULL) + if (global_comment == NULL) global_comment = zi->globalcomment; #endif - if (global_comment==NULL) - size_global_comment = 0; - else - size_global_comment = (uInt)strlen(global_comment); - centraldir_pos_inzip = ZTELL(zi->z_filefunc,zi->filestream); - if (err==ZIP_OK) + if (zi->filestream != zi->filestream_with_CD) { - linkedlist_datablock_internal* ldi = zi->central_dir.first_block ; - while (ldi!=NULL) + if (ZCLOSE64(zi->z_filefunc, zi->filestream) != 0) + if (err == ZIP_OK) + err = ZIP_ERRNO; + if (zi->disk_size > 0) + zi->number_disk_with_CD = zi->number_disk + 1; + zi->filestream = zi->filestream_with_CD; + } + + centraldir_pos_inzip = ZTELL64(zi->z_filefunc, zi->filestream); + + if (err == ZIP_OK) + { + linkedlist_datablock_internal *ldi = zi->central_dir.first_block; + while (ldi != NULL) { - if ((err==ZIP_OK) && (ldi->filled_in_this_block>0)) - if (ZWRITE(zi->z_filefunc,zi->filestream, - ldi->data,ldi->filled_in_this_block) - !=ldi->filled_in_this_block ) + if ((err == ZIP_OK) && (ldi->filled_in_this_block > 0)) + { + write = ZWRITE64(zi->z_filefunc, zi->filestream, ldi->data, ldi->filled_in_this_block); + if (write != ldi->filled_in_this_block) err = ZIP_ERRNO; + } size_centraldir += ldi->filled_in_this_block; ldi = ldi->next_datablock; } } - free_datablock(zi->central_dir.first_block); - if (err==ZIP_OK) /* Magic End */ - err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)ENDHEADERMAGIC,4); + free_linkedlist(&(zi->central_dir)); - if (err==ZIP_OK) /* number of this disk */ - err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2); + pos = centraldir_pos_inzip - zi->add_position_when_writting_offset; - if (err==ZIP_OK) /* number of the disk with the start of the central directory */ - err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2); + /* Write the ZIP64 central directory header */ + if (pos >= UINT32_MAX || zi->number_entry > UINT16_MAX) + { + uint64_t zip64_eocd_pos_inzip = ZTELL64(zi->z_filefunc, zi->filestream); + uint32_t zip64_datasize = 44; - if (err==ZIP_OK) /* total number of entries in the central dir on this disk */ - err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2); + err = zipWriteValue(&zi->z_filefunc, zi->filestream, (uint32_t)ZIP64ENDHEADERMAGIC, 4); - if (err==ZIP_OK) /* total number of entries in the central dir */ - err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2); + /* Size of this 'zip64 end of central directory' */ + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, (uint64_t)zip64_datasize, 8); + /* Version made by */ + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, version_madeby, 2); + /* version needed */ + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, (uint16_t)45, 2); + /* Number of this disk */ + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, zi->number_disk_with_CD, 4); + /* Number of the disk with the start of the central directory */ + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, zi->number_disk_with_CD, 4); + /* Total number of entries in the central dir on this disk */ + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, zi->number_entry, 8); + /* Total number of entries in the central dir */ + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, zi->number_entry, 8); + /* Size of the central directory */ + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, (uint64_t)size_centraldir, 8); - if (err==ZIP_OK) /* size of the central directory */ - err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_centraldir,4); + if (err == ZIP_OK) + { + /* Offset of start of central directory with respect to the starting disk number */ + cd_pos = centraldir_pos_inzip - zi->add_position_when_writting_offset; + err = zipWriteValue(&zi->z_filefunc, zi->filestream, cd_pos, 8); + } + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, (uint32_t)ZIP64ENDLOCHEADERMAGIC, 4); - if (err==ZIP_OK) /* offset of start of central directory with respect to the - starting disk number */ - err = ziplocal_putValue(&zi->z_filefunc,zi->filestream, - (uLong)(centraldir_pos_inzip - zi->add_position_when_writting_offset),4); + /* Number of the disk with the start of the central directory */ + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, zi->number_disk_with_CD, 4); + /* Relative offset to the Zip64EndOfCentralDirectory */ + if (err == ZIP_OK) + { + cd_pos = zip64_eocd_pos_inzip - zi->add_position_when_writting_offset; + err = zipWriteValue(&zi->z_filefunc, zi->filestream, cd_pos, 8); + } + /* Number of the disk with the start of the central directory */ + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, zi->number_disk_with_CD + 1, 4); + } - if (err==ZIP_OK) /* zipfile comment length */ - err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_global_comment,2); + /* Write the central directory header */ + + /* Signature */ + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, (uint32_t)ENDHEADERMAGIC, 4); + /* Number of this disk */ + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, (uint16_t)zi->number_disk_with_CD, 2); + /* Number of the disk with the start of the central directory */ + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, (uint16_t)zi->number_disk_with_CD, 2); + /* Total number of entries in the central dir on this disk */ + if (err == ZIP_OK) + { + if (zi->number_entry >= UINT16_MAX) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, UINT16_MAX, 2); /* use value in ZIP64 record */ + else + err = zipWriteValue(&zi->z_filefunc, zi->filestream, (uint16_t)zi->number_entry, 2); + } + /* Total number of entries in the central dir */ + if (err == ZIP_OK) + { + if (zi->number_entry >= UINT16_MAX) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, UINT16_MAX, 2); /* use value in ZIP64 record */ + else + err = zipWriteValue(&zi->z_filefunc, zi->filestream, (uint16_t)zi->number_entry, 2); + } + /* Size of the central directory */ + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, size_centraldir, 4); + /* Offset of start of central directory with respect to the starting disk number */ + if (err == ZIP_OK) + { + cd_pos = centraldir_pos_inzip - zi->add_position_when_writting_offset; + if (pos >= UINT32_MAX) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, UINT32_MAX, 4); + else + err = zipWriteValue(&zi->z_filefunc, zi->filestream, (uint32_t)cd_pos, 4); + } - if ((err==ZIP_OK) && (size_global_comment>0)) - if (ZWRITE(zi->z_filefunc,zi->filestream, - global_comment,size_global_comment) != size_global_comment) - err = ZIP_ERRNO; + /* Write global comment */ - if (ZCLOSE(zi->z_filefunc,zi->filestream) != 0) - if (err == ZIP_OK) + if (global_comment != NULL) + size_global_comment = (uint16_t)strlen(global_comment); + if (err == ZIP_OK) + err = zipWriteValue(&zi->z_filefunc, zi->filestream, size_global_comment, 2); + if (err == ZIP_OK && size_global_comment > 0) + { + if (ZWRITE64(zi->z_filefunc, zi->filestream, global_comment, size_global_comment) != size_global_comment) err = ZIP_ERRNO; + } + + if ((ZCLOSE64(zi->z_filefunc, zi->filestream) != 0) && (err == ZIP_OK)) + err = ZIP_ERRNO; #ifndef NO_ADDFILEINEXISTINGZIP TRYFREE(zi->globalcomment); diff --git a/vendor/zip/zip.h b/vendor/zip/zip.h index acacce83b9..c90806f7a6 100644 --- a/vendor/zip/zip.h +++ b/vendor/zip/zip.h @@ -1,68 +1,45 @@ -/* zip.h -- IO for compress .zip files using zlib - Version 1.01e, February 12th, 2005 - - Copyright (C) 1998-2005 Gilles Vollant - - This unzip package allow creates .ZIP file, compatible with PKZip 2.04g - WinZip, InfoZip tools and compatible. - Multi volume ZipFile (span) are not supported. - Encryption compatible with pkzip 2.04g only supported - Old compressions used by old PKZip 1.x are not supported - - For uncompress .zip file, look at unzip.h - - - I WAIT FEEDBACK at mail info@winimage.com - Visit also http://www.winimage.com/zLibDll/unzip.html for evolution - - Condition of use and distribution are the same than zlib : - - This software is provided 'as-is', without any express or implied - warranty. In no event will the authors be held liable for any damages - arising from the use of this software. - - Permission is granted to anyone to use this software for any purpose, - including commercial applications, and to alter it and redistribute it - freely, subject to the following restrictions: - - 1. The origin of this software must not be misrepresented; you must not - claim that you wrote the original software. If you use this software - in a product, an acknowledgment in the product documentation would be - appreciated but is not required. - 2. Altered source versions must be plainly marked as such, and must not be - misrepresented as being the original software. - 3. This notice may not be removed or altered from any source distribution. - - -*/ - -/* for more info about .ZIP format, see - http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip - http://www.info-zip.org/pub/infozip/doc/ - PkWare has also a specification at : - ftp://ftp.pkware.com/probdesc.zip +/* zip.h -- IO on .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 + 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 _zip_H -#define _zip_H +#ifndef _ZIP_H +#define _ZIP_H #ifdef __cplusplus extern "C" { #endif #ifndef _ZLIB_H -#include "zlib.h" +# include "zlib.h" #endif #ifndef _ZLIBIOAPI_H -#include "ioapi.h" +# include "ioapi.h" +#endif + +#ifdef HAVE_BZIP2 +# include "bzlib.h" #endif +#define Z_BZIP2ED 12 + #if defined(STRICTZIP) || defined(STRICTZIPUNZIP) /* like the STRICT of WIN32, we define a pointer that cannot be converted from (void*) without cast */ -typedef struct TagzipFile__ { int unused; } zipFile__; -typedef zipFile__ *zipFile; +typedef struct TagzipFile__ { int unused; } zip_file__; +typedef zip_file__ *zipFile; #else typedef voidp zipFile; #endif @@ -81,155 +58,155 @@ typedef voidp zipFile; # define DEF_MEM_LEVEL MAX_MEM_LEVEL # endif #endif -/* default memLevel */ - -/* tm_zip contain date/time info */ -typedef struct tm_zip_s -{ - uInt tm_sec; /* seconds after the minute - [0,59] */ - uInt tm_min; /* minutes after the hour - [0,59] */ - uInt tm_hour; /* hours since midnight - [0,23] */ - uInt tm_mday; /* day of the month - [1,31] */ - uInt tm_mon; /* months since January - [0,11] */ - uInt tm_year; /* years - [1980..2044] */ -} tm_zip; typedef struct { - tm_zip tmz_date; /* date in understandable format */ - uLong dosDate; /* if dos_date == 0, tmu_date is used */ -/* uLong flag; */ /* general purpose bit flag 2 bytes */ - - uLong internal_fa; /* internal file attributes 2 bytes */ - uLong external_fa; /* external file attributes 4 bytes */ + uint32_t dos_date; + uint16_t internal_fa; /* internal file attributes 2 bytes */ + uint32_t external_fa; /* external file attributes 4 bytes */ } zip_fileinfo; -typedef const char* zipcharpc; - - #define APPEND_STATUS_CREATE (0) #define APPEND_STATUS_CREATEAFTER (1) #define APPEND_STATUS_ADDINZIP (2) -extern zipFile ZEXPORT zipOpen OF((const char *pathname, int append)); -/* - Create a zipfile. - pathname contain on Windows XP a filename like "c:\\zlib\\zlib113.zip" or on - an Unix computer "zlib/zlib113.zip". - if the file pathname exist and append==APPEND_STATUS_CREATEAFTER, the zip - will be created at the end of the file. - (useful if the file contain a self extractor code) - if the file pathname exist and append==APPEND_STATUS_ADDINZIP, we will - add files in existing zip (be sure you don't add file that doesn't exist) - If the zipfile cannot be opened, the return value is NULL. - Else, the return value is a zipFile Handle, usable with other function - of this zip package. -*/ - -/* Note : there is no delete function into a zipfile. - If you want delete file into a zipfile, you must open a zipfile, and create another - Of couse, you can use RAW reading and writing to copy the file you did not want delte -*/ - -extern zipFile ZEXPORT zipOpen2 OF((const char *pathname, - int append, - zipcharpc* globalcomment, - zlib_filefunc_def* pzlib_filefunc_def)); - -extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file, - const char* filename, - const zip_fileinfo* zipfi, - const void* extrafield_local, - uInt size_extrafield_local, - const void* extrafield_global, - uInt size_extrafield_global, - const char* comment, - int method, - int level)); -/* - Open a file in the ZIP for writing. - filename : the filename in zip (if NULL, '-' without quote will be used - *zipfi contain supplemental information - if extrafield_local!=NULL and size_extrafield_local>0, extrafield_local - contains the extrafield data the the local header - if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global - contains the extrafield data the the local header - if comment != NULL, comment contain the comment string - method contain the compression method (0 for store, Z_DEFLATED for deflate) - level contain the level of compression (can be Z_DEFAULT_COMPRESSION) -*/ - - -extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file, - const char* filename, - const zip_fileinfo* zipfi, - const void* extrafield_local, - uInt size_extrafield_local, - const void* extrafield_global, - uInt size_extrafield_global, - const char* comment, - int method, - int level, - int raw)); - -/* - Same than zipOpenNewFileInZip, except if raw=1, we write raw file - */ - -extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file, - const char* filename, - const zip_fileinfo* zipfi, - const void* extrafield_local, - uInt size_extrafield_local, - const void* extrafield_global, - uInt size_extrafield_global, - const char* comment, - int method, - int level, - int raw, - int windowBits, - int memLevel, - int strategy, - const char* password, - uLong crcForCtypting)); - -/* - Same than zipOpenNewFileInZip2, except - windowBits,memLevel,,strategy : see parameter strategy in deflateInit2 +/***************************************************************************/ +/* Writing a zip file */ + +extern zipFile ZEXPORT zipOpen(const char *path, int append); +extern zipFile ZEXPORT zipOpen64(const void *path, int append); +/* Create a zipfile. + + 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 + return zipFile handle if no error + + If the file path exist and append == APPEND_STATUS_CREATEAFTER, the zip + will be created at the end of the file. (useful if the file contain a self extractor code) + If the file path exist and append == APPEND_STATUS_ADDINZIP, we will add files in existing + zip (be sure you don't add file that doesn't exist) + + NOTE: There is no delete function into a zipfile. If you want delete file into a zipfile, + you must open a zipfile, and create another. Of course, you can use RAW reading and writing to copy + the file you did not want delete. */ + +extern zipFile ZEXPORT zipOpen2(const char *path, int append, const char **globalcomment, + zlib_filefunc_def *pzlib_filefunc_def); + +extern zipFile ZEXPORT zipOpen2_64(const void *path, int append, const char **globalcomment, + zlib_filefunc64_def *pzlib_filefunc_def); + +extern zipFile ZEXPORT zipOpen3(const char *path, int append, uint64_t disk_size, + const char **globalcomment, zlib_filefunc_def *pzlib_filefunc_def); +/* Same as zipOpen2 but allows specification of spanned zip size */ + +extern zipFile ZEXPORT zipOpen3_64(const void *path, int append, uint64_t disk_size, + const char **globalcomment, zlib_filefunc64_def *pzlib_filefunc_def); + +extern int ZEXPORT zipOpenNewFileInZip(zipFile file, const char *filename, const zip_fileinfo *zipfi, + const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, + uint16_t size_extrafield_global, const char *comment, uint16_t method, int level); +/* Open a file in the ZIP for writing. + + filename : the filename in zip (if NULL, '-' without quote will be used + *zipfi contain supplemental information + extrafield_local buffer to store the local header extra field data, can be NULL + size_extrafield_local size of extrafield_local buffer + extrafield_global buffer to store the global header extra field data, can be NULL + size_extrafield_global size of extrafield_local buffer + comment buffer for comment string + method contain the compression method (0 for store, Z_DEFLATED for deflate) + level contain the level of compression (can be Z_DEFAULT_COMPRESSION) + zip64 is set to 1 if a zip64 extended information block should be added to the local file header. + this MUST be '1' if the uncompressed size is >= 0xffffffff. */ + +extern int ZEXPORT zipOpenNewFileInZip64(zipFile file, const char *filename, const zip_fileinfo *zipfi, + const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, + uint16_t size_extrafield_global, const char *comment, uint16_t method, int level, int zip64); +/* Same as zipOpenNewFileInZip with zip64 support */ + +extern int ZEXPORT zipOpenNewFileInZip2(zipFile file, const char *filename, const zip_fileinfo *zipfi, + const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, + uint16_t size_extrafield_global, const char *comment, uint16_t method, int level, int raw); +/* Same as zipOpenNewFileInZip, except if raw=1, we write raw file */ + +extern int ZEXPORT zipOpenNewFileInZip2_64(zipFile file, const char *filename, const zip_fileinfo *zipfi, + const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, + uint16_t size_extrafield_global, const char *comment, uint16_t method, int level, int raw, int zip64); +/* Same as zipOpenNewFileInZip3 with zip64 support */ + +extern int ZEXPORT zipOpenNewFileInZip3(zipFile file, const char *filename, const zip_fileinfo *zipfi, + const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, + uint16_t size_extrafield_global, const char *comment, uint16_t method, int level, int raw, int windowBits, int memLevel, + int strategy, const char *password, ZIP_UNUSED uint32_t crc_for_crypting); +/* Same as zipOpenNewFileInZip2, except + windowBits, memLevel, strategy : see parameter strategy in deflateInit2 password : crypting password (NULL for no crypting) - crcForCtypting : crc of file to compress (needed for crypting) - */ - - -extern int ZEXPORT zipWriteInFileInZip OF((zipFile file, - const void* buf, - unsigned len)); -/* - Write data in the zipfile -*/ - -extern int ZEXPORT zipCloseFileInZip OF((zipFile file)); -/* - Close the current file in the zipfile -*/ - -extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file, - uLong uncompressed_size, - uLong crc32)); -/* - Close the current file in the zipfile, for fiel opened with - parameter raw=1 in zipOpenNewFileInZip2 - uncompressed_size and crc32 are value for the uncompressed size -*/ - -extern int ZEXPORT zipClose OF((zipFile file, - const char* global_comment)); -/* - Close the zipfile -*/ + crc_for_crypting : crc of file to compress (needed for crypting) */ + +extern int ZEXPORT zipOpenNewFileInZip3_64(zipFile file, const char *filename, const zip_fileinfo *zipfi, + const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, + uint16_t size_extrafield_global, const char *comment, uint16_t method, int level, int raw, int windowBits, int memLevel, + int strategy, const char *password, ZIP_UNUSED uint32_t crc_for_crypting, int zip64); +/* Same as zipOpenNewFileInZip3 with zip64 support */ + +extern int ZEXPORT zipOpenNewFileInZip4(zipFile file, const char *filename, const zip_fileinfo *zipfi, + const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, + uint16_t size_extrafield_global, const char *comment, uint16_t method, int level, int raw, int windowBits, int memLevel, + int strategy, const char *password, ZIP_UNUSED uint32_t crc_for_crypting, uint16_t version_madeby, uint16_t flag_base); +/* Same as zipOpenNewFileInZip3 except versionMadeBy & flag fields */ + +extern int ZEXPORT zipOpenNewFileInZip4_64(zipFile file, const char *filename, const zip_fileinfo *zipfi, + const void *extrafield_local, uint16_t size_extrafield_local, const void *extrafield_global, + uint16_t size_extrafield_global, const char *comment, uint16_t method, int level, int raw, int windowBits, int memLevel, + int strategy, const char *password, ZIP_UNUSED uint32_t crc_for_crypting, uint16_t version_madeby, uint16_t flag_base, int zip64); +/* Same as zipOpenNewFileInZip4 with zip64 support */ + +extern int ZEXPORT zipOpenNewFileInZip5(zipFile file, + const char *filename, + const zip_fileinfo *zipfi, + const void *extrafield_local, + uint16_t size_extrafield_local, + const void *extrafield_global, + uint16_t size_extrafield_global, + const char *comment, + uint16_t flag_base, + int zip64, + uint16_t method, + int level, + int raw, + int windowBits, + int memLevel, + int strategy, + const char *password, + int aes); +/* Allowing optional aes */ + +extern int ZEXPORT zipWriteInFileInZip(zipFile file, const void *buf, uint32_t len); +/* Write data in the zipfile */ + +extern int ZEXPORT zipCloseFileInZip(zipFile file); +/* Close the current file in the zipfile */ + +extern int ZEXPORT zipCloseFileInZipRaw(zipFile file, uint32_t uncompressed_size, uint32_t crc32); +extern int ZEXPORT zipCloseFileInZipRaw64(zipFile file, uint64_t uncompressed_size, uint32_t crc32); +/* Close the current file in the zipfile, for file opened with parameter raw=1 in zipOpenNewFileInZip2 + where raw is compressed data. Parameters uncompressed_size and crc32 are value for the uncompressed data. */ + +extern int ZEXPORT zipClose(zipFile file, const char *global_comment); +/* Close the zipfile */ + +extern int ZEXPORT zipClose_64(zipFile file, const char *global_comment); + +extern int ZEXPORT zipClose2_64(zipFile file, const char *global_comment, uint16_t version_madeby); +/* Same as zipClose_64 except version_madeby field */ + +/***************************************************************************/ #ifdef __cplusplus } #endif -#endif /* _zip_H */ +#endif /* _ZIP_H */ From 9659ff8a226c96982106670a7ee69b4d1f175f42 Mon Sep 17 00:00:00 2001 From: patrikjuvonen <22572159+patrikjuvonen@users.noreply.github.com> Date: Mon, 18 Apr 2022 18:09:39 +0300 Subject: [PATCH 2/2] Fix build errors --- Server/mods/deathmatch/logic/CResource.cpp | 40 +-- .../deathmatch/logic/CResourceChecker.cpp | 6 +- Server/mods/deathmatch/utils/CZipMaker.cpp | 9 +- vendor/zip/crypt.c | 146 +++++++++ vendor/zip/minishared.c | 292 ++++++++++++++++++ vendor/zip/minishared.h | 51 +++ vendor/zip/premake5.lua | 2 +- 7 files changed, 496 insertions(+), 50 deletions(-) create mode 100644 vendor/zip/crypt.c create mode 100644 vendor/zip/minishared.c create mode 100644 vendor/zip/minishared.h diff --git a/Server/mods/deathmatch/logic/CResource.cpp b/Server/mods/deathmatch/logic/CResource.cpp index 2bc21a6d2a..180dc398c5 100644 --- a/Server/mods/deathmatch/logic/CResource.cpp +++ b/Server/mods/deathmatch/logic/CResource.cpp @@ -17,6 +17,7 @@ #ifndef WIN32 #include #endif +#include #ifndef MAX_PATH #define MAX_PATH 260 @@ -3023,43 +3024,6 @@ int makedir(char* newdir) return 1; } -/* change_file_date : change the date/time of a file - filename : the filename of the file where date/time must be modified - dosdate : the new date at the MSDos format (4 bytes) - tmu_date : the SAME new date at the tm_unz format */ -void change_file_date(const char* filename, uLong dosdate, tm_unz tmu_date) -{ -#ifdef WIN32 - HANDLE hFile; - FILETIME ftm, ftLocal, ftCreate, ftLastAcc, ftLastWrite; - - hFile = CreateFile(filename, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL); - GetFileTime(hFile, &ftCreate, &ftLastAcc, &ftLastWrite); - DosDateTimeToFileTime((WORD)(dosdate >> 16), (WORD)dosdate, &ftLocal); - LocalFileTimeToFileTime(&ftLocal, &ftm); - SetFileTime(hFile, &ftm, &ftLastAcc, &ftm); - CloseHandle(hFile); -#else -#ifdef unix - struct utimbuf ut; - struct tm newdate; - newdate.tm_sec = tmu_date.tm_sec; - newdate.tm_min = tmu_date.tm_min; - newdate.tm_hour = tmu_date.tm_hour; - newdate.tm_mday = tmu_date.tm_mday; - newdate.tm_mon = tmu_date.tm_mon; - if (tmu_date.tm_year > 1900) - newdate.tm_year = tmu_date.tm_year - 1900; - else - newdate.tm_year = tmu_date.tm_year; - newdate.tm_isdst = -1; - - ut.actime = ut.modtime = mktime(&newdate); - utime(filename, &ut); -#endif -#endif -} - #define WRITEBUFFERSIZE (8192) int do_extract_currentfile(unzFile uf, const int* popt_extract_without_path, int* popt_overwrite, const char* password, const char* szFilePath) { @@ -3191,7 +3155,7 @@ int do_extract_currentfile(unzFile uf, const int* popt_extract_without_path, int fclose(fout); if (err == 0) - change_file_date(write_filename, file_info.dosDate, file_info.tmu_date); + change_file_date(write_filename, file_info.dos_date); } if (err == UNZ_OK) diff --git a/Server/mods/deathmatch/logic/CResourceChecker.cpp b/Server/mods/deathmatch/logic/CResourceChecker.cpp index 498295b9d8..d3c6f63e03 100644 --- a/Server/mods/deathmatch/logic/CResourceChecker.cpp +++ b/Server/mods/deathmatch/logic/CResourceChecker.cpp @@ -938,8 +938,7 @@ int CResourceChecker::ReplaceFilesInZIP(const string& strOrigZip, const string& // open destination file zip_fileinfo zfi; - memcpy(&zfi.tmz_date, &unzfi.tmu_date, sizeof(tm_unz)); - zfi.dosDate = unzfi.dosDate; + zfi.dos_date = unzfi.dos_date; zfi.internal_fa = unzfi.internal_fa; zfi.external_fa = unzfi.external_fa; @@ -1057,8 +1056,7 @@ int CResourceChecker::ReplaceFilesInZIP(const string& strOrigZip, const string& // open destination file zip_fileinfo zfi; - memcpy(&zfi.tmz_date, &unzfi.tmu_date, sizeof(tm_unz)); - zfi.dosDate = unzfi.dosDate; + zfi.dos_date = unzfi.dos_date; zfi.internal_fa = unzfi.internal_fa; zfi.external_fa = unzfi.external_fa; diff --git a/Server/mods/deathmatch/utils/CZipMaker.cpp b/Server/mods/deathmatch/utils/CZipMaker.cpp index 58e2a07994..a1f082837f 100644 --- a/Server/mods/deathmatch/utils/CZipMaker.cpp +++ b/Server/mods/deathmatch/utils/CZipMaker.cpp @@ -9,6 +9,7 @@ *****************************************************************************/ #include "StdInc.h" +#include /////////////////////////////////////////////////////////////// // @@ -139,13 +140,7 @@ bool CZipMaker::AddFile(const SString& strDest, const std::vector& buffer) time_t secondsNow = time(NULL); tm* tmp = gmtime(&secondsNow); - zfi.dosDate = 0; - zfi.tmz_date.tm_year = tmp->tm_year + 1900; - zfi.tmz_date.tm_mon = tmp->tm_mon; - zfi.tmz_date.tm_mday = tmp->tm_mday; - zfi.tmz_date.tm_hour = tmp->tm_hour; - zfi.tmz_date.tm_min = tmp->tm_min; - zfi.tmz_date.tm_sec = tmp->tm_sec; + zfi.dos_date = tm_to_dosdate(tmp); int iResult = zipOpenNewFileInZip(m_uzFile, strDest, &zfi, NULL, 0, NULL, 0, NULL, Z_DEFLATED, Z_DEFAULT_COMPRESSION); diff --git a/vendor/zip/crypt.c b/vendor/zip/crypt.c new file mode 100644 index 0000000000..a074b8f08b --- /dev/null +++ b/vendor/zip/crypt.c @@ -0,0 +1,146 @@ +/* crypt.c -- base code for traditional PKWARE encryption + Version 1.2.0, September 16th, 2017 + + Copyright (C) 2012-2017 Nathan Moinvaziri + https://github.com/nmoinvaz/minizip + Copyright (C) 1998-2005 Gilles Vollant + Modifications for Info-ZIP crypting + http://www.winimage.com/zLibDll/minizip.html + Copyright (C) 2003 Terry Thorsen + + This code is a modified version of crypting code in Info-ZIP distribution + + Copyright (C) 1990-2000 Info-ZIP. All rights reserved. + + 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. + + This encryption code is a direct transcription of the algorithm from + Roger Schlafly, described by Phil Katz in the file appnote.txt. This + file (appnote.txt) is distributed with the PKZIP program (even in the + version without encryption capabilities). + + If you don't need crypting in your application, just define symbols + NOCRYPT and NOUNCRYPT. +*/ + +#include +#include +#include +#include + +#ifdef _WIN32 +# include +# include +#else +# include +# include +# include +#endif + +#include "zlib.h" + +#include "crypt.h" + +/***************************************************************************/ + +#define CRC32(c, b) ((*(pcrc_32_tab+(((uint32_t)(c) ^ (b)) & 0xff))) ^ ((c) >> 8)) + +/***************************************************************************/ + +uint8_t decrypt_byte(uint32_t *pkeys) +{ + unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an + * unpredictable manner on 16-bit systems; not a problem + * with any known compiler so far, though */ + + temp = ((uint32_t)(*(pkeys+2)) & 0xffff) | 2; + return (uint8_t)(((temp * (temp ^ 1)) >> 8) & 0xff); +} + +uint8_t update_keys(uint32_t *pkeys, const z_crc_t *pcrc_32_tab, int32_t c) +{ + (*(pkeys+0)) = (uint32_t)CRC32((*(pkeys+0)), c); + (*(pkeys+1)) += (*(pkeys+0)) & 0xff; + (*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1; + { + register int32_t keyshift = (int32_t)((*(pkeys + 1)) >> 24); + (*(pkeys+2)) = (uint32_t)CRC32((*(pkeys+2)), keyshift); + } + return c; +} + +void init_keys(const char *passwd, uint32_t *pkeys, const z_crc_t *pcrc_32_tab) +{ + *(pkeys+0) = 305419896L; + *(pkeys+1) = 591751049L; + *(pkeys+2) = 878082192L; + while (*passwd != 0) + { + update_keys(pkeys, pcrc_32_tab, *passwd); + passwd += 1; + } +} + +/***************************************************************************/ + +#ifndef NOCRYPT +int cryptrand(unsigned char *buf, unsigned int len) +{ +#ifdef _WIN32 + HCRYPTPROV provider; + unsigned __int64 pentium_tsc[1]; + int rlen = 0; + int result = 0; + + + if (CryptAcquireContext(&provider, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT | CRYPT_SILENT)) + { + result = CryptGenRandom(provider, len, buf); + CryptReleaseContext(provider, 0); + if (result) + return len; + } + + for (rlen = 0; rlen < (int)len; ++rlen) + { + if (rlen % 8 == 0) + QueryPerformanceCounter((LARGE_INTEGER *)pentium_tsc); + buf[rlen] = ((unsigned char*)pentium_tsc)[rlen % 8]; + } + + return rlen; +#else + arc4random_buf(buf, len); + return len; +#endif +} + +int crypthead(const char *passwd, uint8_t *buf, int buf_size, uint32_t *pkeys, + const z_crc_t *pcrc_32_tab, uint8_t verify1, uint8_t verify2) +{ + uint8_t n = 0; /* index in random header */ + uint8_t header[RAND_HEAD_LEN-2]; /* random header */ + uint16_t t = 0; /* temporary */ + + if (buf_size < RAND_HEAD_LEN) + return 0; + + init_keys(passwd, pkeys, pcrc_32_tab); + + /* First generate RAND_HEAD_LEN-2 random bytes. */ + cryptrand(header, RAND_HEAD_LEN-2); + + /* Encrypt random header (last two bytes is high word of crc) */ + init_keys(passwd, pkeys, pcrc_32_tab); + + for (n = 0; n < RAND_HEAD_LEN-2; n++) + buf[n] = (uint8_t)zencode(pkeys, pcrc_32_tab, header[n], t); + + buf[n++] = (uint8_t)zencode(pkeys, pcrc_32_tab, verify1, t); + buf[n++] = (uint8_t)zencode(pkeys, pcrc_32_tab, verify2, t); + return n; +} +#endif + +/***************************************************************************/ diff --git a/vendor/zip/minishared.c b/vendor/zip/minishared.c new file mode 100644 index 0000000000..6cec3a2778 --- /dev/null +++ b/vendor/zip/minishared.c @@ -0,0 +1,292 @@ +#include +#include +#include +#include +#include +#include +#include + +#include "zlib.h" +#include "ioapi.h" + +#ifdef _WIN32 +# include +# include +#else +# include +# include +# include +# include +#endif + +#include "minishared.h" + +#ifdef _WIN32 +# define USEWIN32IOAPI +# include "iowin32.h" +#endif + +uint32_t get_file_date(const char *path, uint32_t *dos_date) +{ + int ret = 0; +#ifdef _WIN32 + FILETIME ftm_local; + HANDLE find = NULL; + WIN32_FIND_DATAA ff32; + + find = FindFirstFileA(path, &ff32); + if (find != INVALID_HANDLE_VALUE) + { + FileTimeToLocalFileTime(&(ff32.ftLastWriteTime), &ftm_local); + FileTimeToDosDateTime(&ftm_local, ((LPWORD)dos_date) + 1, ((LPWORD)dos_date) + 0); + FindClose(find); + ret = 1; + } +#else + struct stat s; + struct tm *filedate = NULL; + time_t tm_t = 0; + + memset(&s, 0, sizeof(s)); + + if (strcmp(path, "-") != 0) + { + size_t len = strlen(path); + char *name = (char *)malloc(len + 1); + strncpy(name, path, len + 1); + name[len] = 0; + if (name[len - 1] == '/') + name[len - 1] = 0; + + /* Not all systems allow stat'ing a file with / appended */ + if (stat(name, &s) == 0) + { + tm_t = s.st_mtime; + ret = 1; + } + free(name); + } + + filedate = localtime(&tm_t); + *dos_date = tm_to_dosdate(filedate); +#endif + return ret; +} + +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 +} + +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 +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; +} + +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; +} + +time_t dosdate_to_time_t(uint64_t dos_date) +{ + struct tm ptm; + dosdate_to_raw_tm(dos_date, &ptm); + return mktime(&ptm); +} + +uint32_t tm_to_dosdate(const struct tm *ptm) +{ + struct tm fixed_tm; + + /* Years supported: + * [00, 79] (assumed to be between 2000 and 2079) + * [80, 207] (assumed to be between 1980 and 2107, typical output of old + software that does 'year-1900' to get a double digit year) + * [1980, 2107] (due to the date format limitations, only years between 1980 and 2107 can be stored.) + */ + + memcpy(&fixed_tm, ptm, sizeof(struct tm)); + if (fixed_tm.tm_year >= 1980) /* range [1980, 2107] */ + fixed_tm.tm_year -= 1980; + else if (fixed_tm.tm_year >= 80) /* range [80, 99] */ + fixed_tm.tm_year -= 80; + else /* range [00, 79] */ + fixed_tm.tm_year += 20; + + if (invalid_date(&fixed_tm)) + return 0; + + return (uint32_t)(((fixed_tm.tm_mday) + (32 * (fixed_tm.tm_mon + 1)) + (512 * fixed_tm.tm_year)) << 16) | + ((fixed_tm.tm_sec / 2) + (32 * fixed_tm.tm_min) + (2048 * (uint32_t)fixed_tm.tm_hour)); +} + +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) + { + 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)) + { + printf("couldn't create directory %s (%d)\n", buffer, errno); + free(buffer); + return 0; + } + + if (hold == 0) + break; + + *p++ = hold; + } + + free(buffer); + return 1; +} + +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; +} + +int check_file_exists(const char *path) +{ + FILE *handle = get_file_handle(path); + if (handle == NULL) + return 0; + fclose(handle); + return 1; +} + +int is_large_file(const char *path) +{ + FILE* handle = NULL; + uint64_t pos = 0; + + handle = get_file_handle(path); + if (handle == NULL) + return 0; + + fseeko64(handle, 0, SEEK_END); + pos = ftello64(handle); + fclose(handle); + + printf("file : %s is %lld bytes\n", path, pos); + + return (pos >= UINT32_MAX); +} + +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) + printf(" "); + printf("%s", &number[pos_string]); +} diff --git a/vendor/zip/minishared.h b/vendor/zip/minishared.h new file mode 100644 index 0000000000..32fccb6664 --- /dev/null +++ b/vendor/zip/minishared.h @@ -0,0 +1,51 @@ +#ifndef _MINISHARED_H +#define _MINISHARED_H + +#ifdef __cplusplus +extern "C" { +#endif + +#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 + +/***************************************************************************/ + +/* Get a file's date and time in dos format */ +uint32_t get_file_date(const char *path, uint32_t *dos_date); + +/* Sets a file's date and time in dos format */ +void change_file_date(const char *path, uint32_t dos_date); + +/* Convert dos date/time format to struct tm */ +int dosdate_to_tm(uint64_t dos_date, struct tm *ptm); + +/* Convert dos date/time format to time_t */ +time_t dosdate_to_time_t(uint64_t dos_date); + +/* Convert struct tm to dos date/time format */ +uint32_t tm_to_dosdate(const struct tm *ptm); + +/* Create a directory and all subdirectories */ +int makedir(const char *newdir); + +/* Check to see if a file exists */ +int check_file_exists(const char *path); + +/* Check to see if a file is over 4GB and needs ZIP64 extension */ +int is_large_file(const char *path); + +/* Print a 64-bit number for compatibility */ +void display_zpos64(uint64_t n, int size_char); + +/***************************************************************************/ + +#ifdef __cplusplus +} +#endif + +#endif /* _MINISHARED_H */ \ No newline at end of file diff --git a/vendor/zip/premake5.lua b/vendor/zip/premake5.lua index 10b2d46423..930b0bfca5 100644 --- a/vendor/zip/premake5.lua +++ b/vendor/zip/premake5.lua @@ -6,7 +6,7 @@ project "zip" includedirs { "../zlib" } vpaths { - ["Headers/*"] = "**.h", + ["Headers"] = "*.h", ["Sources"] = "*.c", ["*"] = "premake5.lua" }