From 0dfae7b296130955bbed3414e56ed4d82fc1692a Mon Sep 17 00:00:00 2001 From: hzhreal <142254293+hzhreal@users.noreply.github.com> Date: Fri, 21 Jun 2024 03:03:38 +0200 Subject: [PATCH] GTA V & RDR 2 (#12) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * add support for title checksum * add support for title checksum for ps4 saves * add sample * add working sample * add miniz.h * add clauses for key size * add ps4-terraria-decrypter * use realloc instead of creating new array * Update Makefile * update info * Update main.c --------- Co-authored-by: Damián Parrino --- Makefile | 4 +- README.md | 2 + common/aes.h | 13 +- common/miniz.h | 9936 +++++++++++++++++ gta5-decrypter/main.c | 44 +- gta5-decrypter/samples/SGTA50000.dec | Bin 0 -> 534244 bytes gta5-decrypter/samples/SGTA50000.enc | Bin 0 -> 534244 bytes ps4-rdr2-decrypter/main.c | 50 +- ps4-terraria-decrypter/Makefile | 7 + ps4-terraria-decrypter/README.md | 22 + ps4-terraria-decrypter/main.c | 163 + .../samples/World4.wld.comp | Bin 0 -> 64938 bytes .../samples/World4.wld.decomp | Bin 0 -> 433786 bytes ps4-terraria-decrypter/samples/magic.plr.dec | Bin 0 -> 2240 bytes ps4-terraria-decrypter/samples/magic.plr.enc | Bin 0 -> 2240 bytes 15 files changed, 10221 insertions(+), 20 deletions(-) create mode 100644 common/miniz.h create mode 100644 gta5-decrypter/samples/SGTA50000.dec create mode 100644 gta5-decrypter/samples/SGTA50000.enc create mode 100644 ps4-terraria-decrypter/Makefile create mode 100644 ps4-terraria-decrypter/README.md create mode 100644 ps4-terraria-decrypter/main.c create mode 100644 ps4-terraria-decrypter/samples/World4.wld.comp create mode 100644 ps4-terraria-decrypter/samples/World4.wld.decomp create mode 100644 ps4-terraria-decrypter/samples/magic.plr.dec create mode 100644 ps4-terraria-decrypter/samples/magic.plr.enc diff --git a/Makefile b/Makefile index c8997cb..8372c85 100644 --- a/Makefile +++ b/Makefile @@ -26,8 +26,9 @@ all: $(MAKE) -C nfs-undercover-decrypter $(MAKE) -C prototype-checksum-fixer $(MAKE) -C ps4-borderlands3-decrypter - $(MAKE) -C ps4-re-rev2-decrypter $(MAKE) -C ps4-rdr2-decrypter + $(MAKE) -C ps4-re-rev2-decrypter + $(MAKE) -C ps4-terraria-decrypter $(MAKE) -C re-remaster-decrypter $(MAKE) -C re-revelations2-decrypter $(MAKE) -C silent-hill3-decrypter @@ -62,6 +63,7 @@ clean: $(MAKE) clean -C ps4-borderlands3-decrypter $(MAKE) clean -C ps4-rdr2-decrypter $(MAKE) clean -C ps4-re-rev2-decrypter + $(MAKE) clean -C ps4-terraria-decrypter $(MAKE) clean -C re-remaster-decrypter $(MAKE) clean -C re-revelations2-decrypter $(MAKE) clean -C silent-hill3-decrypter diff --git a/README.md b/README.md index 9e6e2b7..bb9d894 100644 --- a/README.md +++ b/README.md @@ -60,6 +60,8 @@ Tools to decrypt specific PS4 save-games: - Red Dead Redemption 2 (PS4) - [ps4-re-rev2-decrypter](./ps4-re-rev2-decrypter) - Resident Evil Revelations 2 (PS4) +- [ps4-terraria-decrypter](./ps4-terraria-decrypter) + - Terraria (PS4) ## Checksum fixers diff --git a/common/aes.h b/common/aes.h index cf60060..e184ba9 100644 --- a/common/aes.h +++ b/common/aes.h @@ -22,10 +22,17 @@ #define CTR 0 #endif +#ifndef AES128 + #define AES128 0 +#endif + +#ifndef AES192 + #define AES192 0 +#endif -//#define AES128 1 -//#define AES192 1 -#define AES256 1 +#ifndef AES256 + #define AES256 1 +#endif #define AES_BLOCKLEN 16 // Block length in bytes - AES is 128b block only diff --git a/common/miniz.h b/common/miniz.h new file mode 100644 index 0000000..0bc6d69 --- /dev/null +++ b/common/miniz.h @@ -0,0 +1,9936 @@ +#define MINIZ_EXPORT +/* miniz.c 2.2.0 - public domain deflate/inflate, zlib-subset, ZIP + reading/writing/appending, PNG writing See "unlicense" statement at the end + of this file. Rich Geldreich , last updated Oct. 13, + 2013 Implements RFC 1950: http://www.ietf.org/rfc/rfc1950.txt and RFC 1951: + http://www.ietf.org/rfc/rfc1951.txt + + Most API's defined in miniz.c are optional. For example, to disable the + archive related functions just define MINIZ_NO_ARCHIVE_APIS, or to get rid of + all stdio usage define MINIZ_NO_STDIO (see the list below for more macros). + + * Low-level Deflate/Inflate implementation notes: + + Compression: Use the "tdefl" API's. The compressor supports raw, static, + and dynamic blocks, lazy or greedy parsing, match length filtering, RLE-only, + and Huffman-only streams. It performs and compresses approximately as well as + zlib. + + Decompression: Use the "tinfl" API's. The entire decompressor is + implemented as a single function coroutine: see tinfl_decompress(). It + supports decompression into a 32KB (or larger power of 2) wrapping buffer, or + into a memory block large enough to hold the entire file. + + The low-level tdefl/tinfl API's do not make any use of dynamic memory + allocation. + + * zlib-style API notes: + + miniz.c implements a fairly large subset of zlib. There's enough + functionality present for it to be a drop-in zlib replacement in many apps: + The z_stream struct, optional memory allocation callbacks + deflateInit/deflateInit2/deflate/deflateReset/deflateEnd/deflateBound + inflateInit/inflateInit2/inflate/inflateReset/inflateEnd + compress, compress2, compressBound, uncompress + CRC-32, Adler-32 - Using modern, minimal code size, CPU cache friendly + routines. Supports raw deflate streams or standard zlib streams with adler-32 + checking. + + Limitations: + The callback API's are not implemented yet. No support for gzip headers or + zlib static dictionaries. I've tried to closely emulate zlib's various + flavors of stream flushing and return status codes, but there are no + guarantees that miniz.c pulls this off perfectly. + + * PNG writing: See the tdefl_write_image_to_png_file_in_memory() function, + originally written by Alex Evans. Supports 1-4 bytes/pixel images. + + * ZIP archive API notes: + + The ZIP archive API's where designed with simplicity and efficiency in + mind, with just enough abstraction to get the job done with minimal fuss. + There are simple API's to retrieve file information, read files from existing + archives, create new archives, append new files to existing archives, or + clone archive data from one archive to another. It supports archives located + in memory or the heap, on disk (using stdio.h), or you can specify custom + file read/write callbacks. + + - Archive reading: Just call this function to read a single file from a + disk archive: + + void *mz_zip_extract_archive_file_to_heap(const char *pZip_filename, const + char *pArchive_name, size_t *pSize, mz_uint zip_flags); + + For more complex cases, use the "mz_zip_reader" functions. Upon opening an + archive, the entire central directory is located and read as-is into memory, + and subsequent file access only occurs when reading individual files. + + - Archives file scanning: The simple way is to use this function to scan a + loaded archive for a specific file: + + int mz_zip_reader_locate_file(mz_zip_archive *pZip, const char *pName, + const char *pComment, mz_uint flags); + + The locate operation can optionally check file comments too, which (as one + example) can be used to identify multiple versions of the same file in an + archive. This function uses a simple linear search through the central + directory, so it's not very fast. + + Alternately, you can iterate through all the files in an archive (using + mz_zip_reader_get_num_files()) and retrieve detailed info on each file by + calling mz_zip_reader_file_stat(). + + - Archive creation: Use the "mz_zip_writer" functions. The ZIP writer + immediately writes compressed file data to disk and builds an exact image of + the central directory in memory. The central directory image is written all + at once at the end of the archive file when the archive is finalized. + + The archive writer can optionally align each file's local header and file + data to any power of 2 alignment, which can be useful when the archive will + be read from optical media. Also, the writer supports placing arbitrary data + blobs at the very beginning of ZIP archives. Archives written using either + feature are still readable by any ZIP tool. + + - Archive appending: The simple way to add a single file to an archive is + to call this function: + + mz_bool mz_zip_add_mem_to_archive_file_in_place(const char *pZip_filename, + const char *pArchive_name, const void *pBuf, size_t buf_size, const void + *pComment, mz_uint16 comment_size, mz_uint level_and_flags); + + The archive will be created if it doesn't already exist, otherwise it'll be + appended to. Note the appending is done in-place and is not an atomic + operation, so if something goes wrong during the operation it's possible the + archive could be left without a central directory (although the local file + headers and file data will be fine, so the archive will be recoverable). + + For more complex archive modification scenarios: + 1. The safest way is to use a mz_zip_reader to read the existing archive, + cloning only those bits you want to preserve into a new archive using using + the mz_zip_writer_add_from_zip_reader() function (which compiles the + compressed file data as-is). When you're done, delete the old archive and + rename the newly written archive, and you're done. This is safe but requires + a bunch of temporary disk space or heap memory. + + 2. Or, you can convert an mz_zip_reader in-place to an mz_zip_writer using + mz_zip_writer_init_from_reader(), append new files as needed, then finalize + the archive which will write an updated central directory to the original + archive. (This is basically what mz_zip_add_mem_to_archive_file_in_place() + does.) There's a possibility that the archive's central directory could be + lost with this method if anything goes wrong, though. + + - ZIP archive support limitations: + No spanning support. Extraction functions can only handle unencrypted, + stored or deflated files. Requires streams capable of seeking. + + * This is a header file library, like stb_image.c. To get only a header file, + either cut and paste the below header, or create miniz.h, #define + MINIZ_HEADER_FILE_ONLY, and then include miniz.c from it. + + * Important: For best perf. be sure to customize the below macros for your + target platform: #define MINIZ_USE_UNALIGNED_LOADS_AND_STORES 1 #define + MINIZ_LITTLE_ENDIAN 1 #define MINIZ_HAS_64BIT_REGISTERS 1 + + * On platforms using glibc, Be sure to "#define _LARGEFILE64_SOURCE 1" before + including miniz.c to ensure miniz uses the 64-bit variants: fopen64(), + stat64(), etc. Otherwise you won't be able to process large files (i.e. + 32-bit stat() fails for me on files > 0x7FFFFFFF bytes). +*/ +#pragma once + +/* Defines to completely disable specific portions of miniz.c: + If all macros here are defined the only functionality remaining will be + CRC-32, adler-32, tinfl, and tdefl. */ + +/* Define MINIZ_NO_STDIO to disable all usage and any functions which rely on + * stdio for file I/O. */ +/*#define MINIZ_NO_STDIO */ + +/* If MINIZ_NO_TIME is specified then the ZIP archive functions will not be able + * to get the current time, or */ +/* get/set file times, and the C run-time funcs that get/set times won't be + * called. */ +/* The current downside is the times written to your archives will be from 1979. + */ +#define MINIZ_NO_TIME + +/* Define MINIZ_NO_ARCHIVE_APIS to disable all ZIP archive API's. */ +/*#define MINIZ_NO_ARCHIVE_APIS */ + +/* Define MINIZ_NO_ARCHIVE_WRITING_APIS to disable all writing related ZIP + * archive API's. */ +/*#define MINIZ_NO_ARCHIVE_WRITING_APIS */ + +/* Define MINIZ_NO_ZLIB_APIS to remove all ZLIB-style compression/decompression + * API's. */ +#define MINIZ_NO_ZLIB_APIS + +/* Define MINIZ_NO_ZLIB_COMPATIBLE_NAME to disable zlib names, to prevent + * conflicts against stock zlib. */ +#define MINIZ_NO_ZLIB_COMPATIBLE_NAMES + +/* Define MINIZ_NO_MALLOC to disable all calls to malloc, free, and realloc. + Note if MINIZ_NO_MALLOC is defined then the user must always provide custom + user alloc/free/realloc callbacks to the zlib and archive API's, and a few + stand-alone helper API's which don't provide custom user functions (such as + tdefl_compress_mem_to_heap() and tinfl_decompress_mem_to_heap()) won't work. + */ +/*#define MINIZ_NO_MALLOC */ + +#if defined(__TINYC__) && (defined(__linux) || defined(__linux__)) +/* TODO: Work around "error: include file 'sys\utime.h' when compiling with tcc + * on Linux */ +#define MINIZ_NO_TIME +#endif + +#include + +#if !defined(MINIZ_NO_TIME) && !defined(MINIZ_NO_ARCHIVE_APIS) +#include +#endif + +#if defined(_M_IX86) || defined(_M_X64) || defined(__i386__) || \ + defined(__i386) || defined(__i486__) || defined(__i486) || \ + defined(i386) || defined(__ia64__) || defined(__x86_64__) +/* MINIZ_X86_OR_X64_CPU is only used to help set the below macros. */ +#define MINIZ_X86_OR_X64_CPU 1 +#else +#define MINIZ_X86_OR_X64_CPU 0 +#endif + +#if (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) || MINIZ_X86_OR_X64_CPU +/* Set MINIZ_LITTLE_ENDIAN to 1 if the processor is little endian. */ +#define MINIZ_LITTLE_ENDIAN 1 +#else +#define MINIZ_LITTLE_ENDIAN 0 +#endif + +/* Set MINIZ_USE_UNALIGNED_LOADS_AND_STORES only if not set */ +#if !defined(MINIZ_USE_UNALIGNED_LOADS_AND_STORES) +#if MINIZ_X86_OR_X64_CPU +/* Set MINIZ_USE_UNALIGNED_LOADS_AND_STORES to 1 on CPU's that permit efficient + * integer loads and stores from unaligned addresses. */ +#define MINIZ_USE_UNALIGNED_LOADS_AND_STORES 1 +#define MINIZ_UNALIGNED_USE_MEMCPY +#else +#define MINIZ_USE_UNALIGNED_LOADS_AND_STORES 0 +#endif +#endif + +#if defined(_M_X64) || defined(_WIN64) || defined(__MINGW64__) || \ + defined(_LP64) || defined(__LP64__) || defined(__ia64__) || \ + defined(__x86_64__) +/* Set MINIZ_HAS_64BIT_REGISTERS to 1 if operations on 64-bit integers are + * reasonably fast (and don't involve compiler generated calls to helper + * functions). */ +#define MINIZ_HAS_64BIT_REGISTERS 1 +#else +#define MINIZ_HAS_64BIT_REGISTERS 0 +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/* ------------------- zlib-style API Definitions. */ + +/* For more compatibility with zlib, miniz.c uses unsigned long for some + * parameters/struct members. Beware: mz_ulong can be either 32 or 64-bits! */ +typedef unsigned long mz_ulong; + +/* mz_free() internally uses the MZ_FREE() macro (which by default calls free() + * unless you've modified the MZ_MALLOC macro) to release a block allocated from + * the heap. */ +MINIZ_EXPORT void mz_free(void *p); + +#define MZ_ADLER32_INIT (1) +/* mz_adler32() returns the initial adler-32 value to use when called with + * ptr==NULL. */ +MINIZ_EXPORT mz_ulong mz_adler32(mz_ulong adler, const unsigned char *ptr, + size_t buf_len); + +#define MZ_CRC32_INIT (0) +/* mz_crc32() returns the initial CRC-32 value to use when called with + * ptr==NULL. */ +MINIZ_EXPORT mz_ulong mz_crc32(mz_ulong crc, const unsigned char *ptr, + size_t buf_len); + +/* Compression strategies. */ +enum { + MZ_DEFAULT_STRATEGY = 0, + MZ_FILTERED = 1, + MZ_HUFFMAN_ONLY = 2, + MZ_RLE = 3, + MZ_FIXED = 4 +}; + +/* Method */ +#define MZ_DEFLATED 8 + +/* Heap allocation callbacks. +Note that mz_alloc_func parameter types purposely differ from zlib's: items/size +is size_t, not unsigned long. */ +typedef void *(*mz_alloc_func)(void *opaque, size_t items, size_t size); +typedef void (*mz_free_func)(void *opaque, void *address); +typedef void *(*mz_realloc_func)(void *opaque, void *address, size_t items, + size_t size); + +/* Compression levels: 0-9 are the standard zlib-style levels, 10 is best + * possible compression (not zlib compatible, and may be very slow), + * MZ_DEFAULT_COMPRESSION=MZ_DEFAULT_LEVEL. */ +enum { + MZ_NO_COMPRESSION = 0, + MZ_BEST_SPEED = 1, + MZ_BEST_COMPRESSION = 9, + MZ_UBER_COMPRESSION = 10, + MZ_DEFAULT_LEVEL = 6, + MZ_DEFAULT_COMPRESSION = -1 +}; + +#define MZ_VERSION "10.2.0" +#define MZ_VERNUM 0xA100 +#define MZ_VER_MAJOR 10 +#define MZ_VER_MINOR 2 +#define MZ_VER_REVISION 0 +#define MZ_VER_SUBREVISION 0 + +#ifndef MINIZ_NO_ZLIB_APIS + +/* Flush values. For typical usage you only need MZ_NO_FLUSH and MZ_FINISH. The + * other values are for advanced use (refer to the zlib docs). */ +enum { + MZ_NO_FLUSH = 0, + MZ_PARTIAL_FLUSH = 1, + MZ_SYNC_FLUSH = 2, + MZ_FULL_FLUSH = 3, + MZ_FINISH = 4, + MZ_BLOCK = 5 +}; + +/* Return status codes. MZ_PARAM_ERROR is non-standard. */ +enum { + MZ_OK = 0, + MZ_STREAM_END = 1, + MZ_NEED_DICT = 2, + MZ_ERRNO = -1, + MZ_STREAM_ERROR = -2, + MZ_DATA_ERROR = -3, + MZ_MEM_ERROR = -4, + MZ_BUF_ERROR = -5, + MZ_VERSION_ERROR = -6, + MZ_PARAM_ERROR = -10000 +}; + +/* Window bits */ +#define MZ_DEFAULT_WINDOW_BITS 15 + +struct mz_internal_state; + +/* Compression/decompression stream struct. */ +typedef struct mz_stream_s { + const unsigned char *next_in; /* pointer to next byte to read */ + unsigned int avail_in; /* number of bytes available at next_in */ + mz_ulong total_in; /* total number of bytes consumed so far */ + + unsigned char *next_out; /* pointer to next byte to write */ + unsigned int avail_out; /* number of bytes that can be written to next_out */ + mz_ulong total_out; /* total number of bytes produced so far */ + + char *msg; /* error msg (unused) */ + struct mz_internal_state + *state; /* internal state, allocated by zalloc/zfree */ + + mz_alloc_func + zalloc; /* optional heap allocation function (defaults to malloc) */ + mz_free_func zfree; /* optional heap free function (defaults to free) */ + void *opaque; /* heap alloc function user pointer */ + + int data_type; /* data_type (unused) */ + mz_ulong adler; /* adler32 of the source or uncompressed data */ + mz_ulong reserved; /* not used */ +} mz_stream; + +typedef mz_stream *mz_streamp; + +/* Returns the version string of miniz.c. */ +MINIZ_EXPORT const char *mz_version(void); + +/* mz_deflateInit() initializes a compressor with default options: */ +/* Parameters: */ +/* pStream must point to an initialized mz_stream struct. */ +/* level must be between [MZ_NO_COMPRESSION, MZ_BEST_COMPRESSION]. */ +/* level 1 enables a specially optimized compression function that's been + * optimized purely for performance, not ratio. */ +/* (This special func. is currently only enabled when + * MINIZ_USE_UNALIGNED_LOADS_AND_STORES and MINIZ_LITTLE_ENDIAN are defined.) */ +/* Return values: */ +/* MZ_OK on success. */ +/* MZ_STREAM_ERROR if the stream is bogus. */ +/* MZ_PARAM_ERROR if the input parameters are bogus. */ +/* MZ_MEM_ERROR on out of memory. */ +MINIZ_EXPORT int mz_deflateInit(mz_streamp pStream, int level); + +/* mz_deflateInit2() is like mz_deflate(), except with more control: */ +/* Additional parameters: */ +/* method must be MZ_DEFLATED */ +/* window_bits must be MZ_DEFAULT_WINDOW_BITS (to wrap the deflate stream with + * zlib header/adler-32 footer) or -MZ_DEFAULT_WINDOW_BITS (raw deflate/no + * header or footer) */ +/* mem_level must be between [1, 9] (it's checked but ignored by miniz.c) */ +MINIZ_EXPORT int mz_deflateInit2(mz_streamp pStream, int level, int method, + int window_bits, int mem_level, int strategy); + +/* Quickly resets a compressor without having to reallocate anything. Same as + * calling mz_deflateEnd() followed by mz_deflateInit()/mz_deflateInit2(). */ +MINIZ_EXPORT int mz_deflateReset(mz_streamp pStream); + +/* mz_deflate() compresses the input to output, consuming as much of the input + * and producing as much output as possible. */ +/* Parameters: */ +/* pStream is the stream to read from and write to. You must initialize/update + * the next_in, avail_in, next_out, and avail_out members. */ +/* flush may be MZ_NO_FLUSH, MZ_PARTIAL_FLUSH/MZ_SYNC_FLUSH, MZ_FULL_FLUSH, or + * MZ_FINISH. */ +/* Return values: */ +/* MZ_OK on success (when flushing, or if more input is needed but not + * available, and/or there's more output to be written but the output buffer is + * full). */ +/* MZ_STREAM_END if all input has been consumed and all output bytes have been + * written. Don't call mz_deflate() on the stream anymore. */ +/* MZ_STREAM_ERROR if the stream is bogus. */ +/* MZ_PARAM_ERROR if one of the parameters is invalid. */ +/* MZ_BUF_ERROR if no forward progress is possible because the input and/or + * output buffers are empty. (Fill up the input buffer or free up some output + * space and try again.) */ +MINIZ_EXPORT int mz_deflate(mz_streamp pStream, int flush); + +/* mz_deflateEnd() deinitializes a compressor: */ +/* Return values: */ +/* MZ_OK on success. */ +/* MZ_STREAM_ERROR if the stream is bogus. */ +MINIZ_EXPORT int mz_deflateEnd(mz_streamp pStream); + +/* mz_deflateBound() returns a (very) conservative upper bound on the amount of + * data that could be generated by deflate(), assuming flush is set to only + * MZ_NO_FLUSH or MZ_FINISH. */ +MINIZ_EXPORT mz_ulong mz_deflateBound(mz_streamp pStream, mz_ulong source_len); + +/* Single-call compression functions mz_compress() and mz_compress2(): */ +/* Returns MZ_OK on success, or one of the error codes from mz_deflate() on + * failure. */ +MINIZ_EXPORT int mz_compress(unsigned char *pDest, mz_ulong *pDest_len, + const unsigned char *pSource, mz_ulong source_len); +MINIZ_EXPORT int mz_compress2(unsigned char *pDest, mz_ulong *pDest_len, + const unsigned char *pSource, mz_ulong source_len, + int level); + +/* mz_compressBound() returns a (very) conservative upper bound on the amount of + * data that could be generated by calling mz_compress(). */ +MINIZ_EXPORT mz_ulong mz_compressBound(mz_ulong source_len); + +/* Initializes a decompressor. */ +MINIZ_EXPORT int mz_inflateInit(mz_streamp pStream); + +/* mz_inflateInit2() is like mz_inflateInit() with an additional option that + * controls the window size and whether or not the stream has been wrapped with + * a zlib header/footer: */ +/* window_bits must be MZ_DEFAULT_WINDOW_BITS (to parse zlib header/footer) or + * -MZ_DEFAULT_WINDOW_BITS (raw deflate). */ +MINIZ_EXPORT int mz_inflateInit2(mz_streamp pStream, int window_bits); + +/* Quickly resets a compressor without having to reallocate anything. Same as + * calling mz_inflateEnd() followed by mz_inflateInit()/mz_inflateInit2(). */ +MINIZ_EXPORT int mz_inflateReset(mz_streamp pStream); + +/* Decompresses the input stream to the output, consuming only as much of the + * input as needed, and writing as much to the output as possible. */ +/* Parameters: */ +/* pStream is the stream to read from and write to. You must initialize/update + * the next_in, avail_in, next_out, and avail_out members. */ +/* flush may be MZ_NO_FLUSH, MZ_SYNC_FLUSH, or MZ_FINISH. */ +/* On the first call, if flush is MZ_FINISH it's assumed the input and output + * buffers are both sized large enough to decompress the entire stream in a + * single call (this is slightly faster). */ +/* MZ_FINISH implies that there are no more source bytes available beside + * what's already in the input buffer, and that the output buffer is large + * enough to hold the rest of the decompressed data. */ +/* Return values: */ +/* MZ_OK on success. Either more input is needed but not available, and/or + * there's more output to be written but the output buffer is full. */ +/* MZ_STREAM_END if all needed input has been consumed and all output bytes + * have been written. For zlib streams, the adler-32 of the decompressed data + * has also been verified. */ +/* MZ_STREAM_ERROR if the stream is bogus. */ +/* MZ_DATA_ERROR if the deflate stream is invalid. */ +/* MZ_PARAM_ERROR if one of the parameters is invalid. */ +/* MZ_BUF_ERROR if no forward progress is possible because the input buffer is + * empty but the inflater needs more input to continue, or if the output buffer + * is not large enough. Call mz_inflate() again */ +/* with more input data, or with more room in the output buffer (except when + * using single call decompression, described above). */ +MINIZ_EXPORT int mz_inflate(mz_streamp pStream, int flush); + +/* Deinitializes a decompressor. */ +MINIZ_EXPORT int mz_inflateEnd(mz_streamp pStream); + +/* Single-call decompression. */ +/* Returns MZ_OK on success, or one of the error codes from mz_inflate() on + * failure. */ +MINIZ_EXPORT int mz_uncompress(unsigned char *pDest, mz_ulong *pDest_len, + const unsigned char *pSource, + mz_ulong source_len); +MINIZ_EXPORT int mz_uncompress2(unsigned char *pDest, mz_ulong *pDest_len, + const unsigned char *pSource, + mz_ulong *pSource_len); + +/* Returns a string description of the specified error code, or NULL if the + * error code is invalid. */ +MINIZ_EXPORT const char *mz_error(int err); + +/* Redefine zlib-compatible names to miniz equivalents, so miniz.c can be used + * as a drop-in replacement for the subset of zlib that miniz.c supports. */ +/* Define MINIZ_NO_ZLIB_COMPATIBLE_NAMES to disable zlib-compatibility if you + * use zlib in the same project. */ +#ifndef MINIZ_NO_ZLIB_COMPATIBLE_NAMES +typedef unsigned char Byte; +typedef unsigned int uInt; +typedef mz_ulong uLong; +typedef Byte Bytef; +typedef uInt uIntf; +typedef char charf; +typedef int intf; +typedef void *voidpf; +typedef uLong uLongf; +typedef void *voidp; +typedef void *const voidpc; +#define Z_NULL 0 +#define Z_NO_FLUSH MZ_NO_FLUSH +#define Z_PARTIAL_FLUSH MZ_PARTIAL_FLUSH +#define Z_SYNC_FLUSH MZ_SYNC_FLUSH +#define Z_FULL_FLUSH MZ_FULL_FLUSH +#define Z_FINISH MZ_FINISH +#define Z_BLOCK MZ_BLOCK +#define Z_OK MZ_OK +#define Z_STREAM_END MZ_STREAM_END +#define Z_NEED_DICT MZ_NEED_DICT +#define Z_ERRNO MZ_ERRNO +#define Z_STREAM_ERROR MZ_STREAM_ERROR +#define Z_DATA_ERROR MZ_DATA_ERROR +#define Z_MEM_ERROR MZ_MEM_ERROR +#define Z_BUF_ERROR MZ_BUF_ERROR +#define Z_VERSION_ERROR MZ_VERSION_ERROR +#define Z_PARAM_ERROR MZ_PARAM_ERROR +#define Z_NO_COMPRESSION MZ_NO_COMPRESSION +#define Z_BEST_SPEED MZ_BEST_SPEED +#define Z_BEST_COMPRESSION MZ_BEST_COMPRESSION +#define Z_DEFAULT_COMPRESSION MZ_DEFAULT_COMPRESSION +#define Z_DEFAULT_STRATEGY MZ_DEFAULT_STRATEGY +#define Z_FILTERED MZ_FILTERED +#define Z_HUFFMAN_ONLY MZ_HUFFMAN_ONLY +#define Z_RLE MZ_RLE +#define Z_FIXED MZ_FIXED +#define Z_DEFLATED MZ_DEFLATED +#define Z_DEFAULT_WINDOW_BITS MZ_DEFAULT_WINDOW_BITS +#define alloc_func mz_alloc_func +#define free_func mz_free_func +#define internal_state mz_internal_state +#define z_stream mz_stream +#define deflateInit mz_deflateInit +#define deflateInit2 mz_deflateInit2 +#define deflateReset mz_deflateReset +#define deflate mz_deflate +#define deflateEnd mz_deflateEnd +#define deflateBound mz_deflateBound +#define compress mz_compress +#define compress2 mz_compress2 +#define compressBound mz_compressBound +#define inflateInit mz_inflateInit +#define inflateInit2 mz_inflateInit2 +#define inflateReset mz_inflateReset +#define inflate mz_inflate +#define inflateEnd mz_inflateEnd +#define uncompress mz_uncompress +#define uncompress2 mz_uncompress2 +#define crc32 mz_crc32 +#define adler32 mz_adler32 +#define MAX_WBITS 15 +#define MAX_MEM_LEVEL 9 +#define zError mz_error +#define ZLIB_VERSION MZ_VERSION +#define ZLIB_VERNUM MZ_VERNUM +#define ZLIB_VER_MAJOR MZ_VER_MAJOR +#define ZLIB_VER_MINOR MZ_VER_MINOR +#define ZLIB_VER_REVISION MZ_VER_REVISION +#define ZLIB_VER_SUBREVISION MZ_VER_SUBREVISION +#define zlibVersion mz_version +#define zlib_version mz_version() +#endif /* #ifndef MINIZ_NO_ZLIB_COMPATIBLE_NAMES */ + +#endif /* MINIZ_NO_ZLIB_APIS */ + +#ifdef __cplusplus +} +#endif + +#pragma once +#include +#include +#include +#include + +/* ------------------- Types and macros */ +typedef unsigned char mz_uint8; +typedef signed short mz_int16; +typedef unsigned short mz_uint16; +typedef unsigned int mz_uint32; +typedef unsigned int mz_uint; +typedef int64_t mz_int64; +typedef uint64_t mz_uint64; +typedef int mz_bool; + +#define MZ_FALSE (0) +#define MZ_TRUE (1) + +/* Works around MSVC's spammy "warning C4127: conditional expression is + * constant" message. */ +#ifdef _MSC_VER +#define MZ_MACRO_END while (0, 0) +#else +#define MZ_MACRO_END while (0) +#endif + +#ifdef MINIZ_NO_STDIO +#define MZ_FILE void * +#else +#include +#define MZ_FILE FILE +#endif /* #ifdef MINIZ_NO_STDIO */ + +#ifdef MINIZ_NO_TIME +typedef struct mz_dummy_time_t_tag { + int m_dummy; +} mz_dummy_time_t; +#define MZ_TIME_T mz_dummy_time_t +#else +#define MZ_TIME_T time_t +#endif + +#define MZ_ASSERT(x) assert(x) + +#ifdef MINIZ_NO_MALLOC +#define MZ_MALLOC(x) NULL +#define MZ_FREE(x) (void)x, ((void)0) +#define MZ_REALLOC(p, x) NULL +#else +#define MZ_MALLOC(x) malloc(x) +#define MZ_FREE(x) free(x) +#define MZ_REALLOC(p, x) realloc(p, x) +#endif + +#define MZ_MAX(a, b) (((a) > (b)) ? (a) : (b)) +#define MZ_MIN(a, b) (((a) < (b)) ? (a) : (b)) +#define MZ_CLEAR_OBJ(obj) memset(&(obj), 0, sizeof(obj)) + +#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN +#define MZ_READ_LE16(p) *((const mz_uint16 *)(p)) +#define MZ_READ_LE32(p) *((const mz_uint32 *)(p)) +#else +#define MZ_READ_LE16(p) \ + ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ + ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U)) +#define MZ_READ_LE32(p) \ + ((mz_uint32)(((const mz_uint8 *)(p))[0]) | \ + ((mz_uint32)(((const mz_uint8 *)(p))[1]) << 8U) | \ + ((mz_uint32)(((const mz_uint8 *)(p))[2]) << 16U) | \ + ((mz_uint32)(((const mz_uint8 *)(p))[3]) << 24U)) +#endif + +#define MZ_READ_LE64(p) \ + (((mz_uint64)MZ_READ_LE32(p)) | \ + (((mz_uint64)MZ_READ_LE32((const mz_uint8 *)(p) + sizeof(mz_uint32))) \ + << 32U)) + +#ifdef _MSC_VER +#define MZ_FORCEINLINE __forceinline +#elif defined(__GNUC__) +#define MZ_FORCEINLINE __inline__ __attribute__((__always_inline__)) +#else +#define MZ_FORCEINLINE inline +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +extern MINIZ_EXPORT void *miniz_def_alloc_func(void *opaque, size_t items, + size_t size); +extern MINIZ_EXPORT void miniz_def_free_func(void *opaque, void *address); +extern MINIZ_EXPORT void *miniz_def_realloc_func(void *opaque, void *address, + size_t items, size_t size); + +#define MZ_UINT16_MAX (0xFFFFU) +#define MZ_UINT32_MAX (0xFFFFFFFFU) + +#ifdef __cplusplus +} +#endif +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif +/* ------------------- Low-level Compression API Definitions */ + +/* Set TDEFL_LESS_MEMORY to 1 to use less memory (compression will be slightly + * slower, and raw/dynamic blocks will be output more frequently). */ +#define TDEFL_LESS_MEMORY 0 + +/* tdefl_init() compression flags logically OR'd together (low 12 bits contain + * the max. number of probes per dictionary search): */ +/* TDEFL_DEFAULT_MAX_PROBES: The compressor defaults to 128 dictionary probes + * per dictionary search. 0=Huffman only, 1=Huffman+LZ (fastest/crap + * compression), 4095=Huffman+LZ (slowest/best compression). */ +enum { + TDEFL_HUFFMAN_ONLY = 0, + TDEFL_DEFAULT_MAX_PROBES = 128, + TDEFL_MAX_PROBES_MASK = 0xFFF +}; + +/* TDEFL_WRITE_ZLIB_HEADER: If set, the compressor outputs a zlib header before + * the deflate data, and the Adler-32 of the source data at the end. Otherwise, + * you'll get raw deflate data. */ +/* TDEFL_COMPUTE_ADLER32: Always compute the adler-32 of the input data (even + * when not writing zlib headers). */ +/* TDEFL_GREEDY_PARSING_FLAG: Set to use faster greedy parsing, instead of more + * efficient lazy parsing. */ +/* TDEFL_NONDETERMINISTIC_PARSING_FLAG: Enable to decrease the compressor's + * initialization time to the minimum, but the output may vary from run to run + * given the same input (depending on the contents of memory). */ +/* TDEFL_RLE_MATCHES: Only look for RLE matches (matches with a distance of 1) + */ +/* TDEFL_FILTER_MATCHES: Discards matches <= 5 chars if enabled. */ +/* TDEFL_FORCE_ALL_STATIC_BLOCKS: Disable usage of optimized Huffman tables. */ +/* TDEFL_FORCE_ALL_RAW_BLOCKS: Only use raw (uncompressed) deflate blocks. */ +/* The low 12 bits are reserved to control the max # of hash probes per + * dictionary lookup (see TDEFL_MAX_PROBES_MASK). */ +enum { + TDEFL_WRITE_ZLIB_HEADER = 0x01000, + TDEFL_COMPUTE_ADLER32 = 0x02000, + TDEFL_GREEDY_PARSING_FLAG = 0x04000, + TDEFL_NONDETERMINISTIC_PARSING_FLAG = 0x08000, + TDEFL_RLE_MATCHES = 0x10000, + TDEFL_FILTER_MATCHES = 0x20000, + TDEFL_FORCE_ALL_STATIC_BLOCKS = 0x40000, + TDEFL_FORCE_ALL_RAW_BLOCKS = 0x80000 +}; + +/* High level compression functions: */ +/* tdefl_compress_mem_to_heap() compresses a block in memory to a heap block + * allocated via malloc(). */ +/* On entry: */ +/* pSrc_buf, src_buf_len: Pointer and size of source block to compress. */ +/* flags: The max match finder probes (default is 128) logically OR'd against + * the above flags. Higher probes are slower but improve compression. */ +/* On return: */ +/* Function returns a pointer to the compressed data, or NULL on failure. */ +/* *pOut_len will be set to the compressed data's size, which could be larger + * than src_buf_len on uncompressible data. */ +/* The caller must free() the returned block when it's no longer needed. */ +MINIZ_EXPORT void *tdefl_compress_mem_to_heap(const void *pSrc_buf, + size_t src_buf_len, + size_t *pOut_len, int flags); + +/* tdefl_compress_mem_to_mem() compresses a block in memory to another block in + * memory. */ +/* Returns 0 on failure. */ +MINIZ_EXPORT size_t tdefl_compress_mem_to_mem(void *pOut_buf, + size_t out_buf_len, + const void *pSrc_buf, + size_t src_buf_len, int flags); + +/* Compresses an image to a compressed PNG file in memory. */ +/* On entry: */ +/* pImage, w, h, and num_chans describe the image to compress. num_chans may be + * 1, 2, 3, or 4. */ +/* The image pitch in bytes per scanline will be w*num_chans. The leftmost + * pixel on the top scanline is stored first in memory. */ +/* level may range from [0,10], use MZ_NO_COMPRESSION, MZ_BEST_SPEED, + * MZ_BEST_COMPRESSION, etc. or a decent default is MZ_DEFAULT_LEVEL */ +/* If flip is true, the image will be flipped on the Y axis (useful for OpenGL + * apps). */ +/* On return: */ +/* Function returns a pointer to the compressed data, or NULL on failure. */ +/* *pLen_out will be set to the size of the PNG image file. */ +/* The caller must mz_free() the returned heap block (which will typically be + * larger than *pLen_out) when it's no longer needed. */ +MINIZ_EXPORT void * +tdefl_write_image_to_png_file_in_memory_ex(const void *pImage, int w, int h, + int num_chans, size_t *pLen_out, + mz_uint level, mz_bool flip); +MINIZ_EXPORT void *tdefl_write_image_to_png_file_in_memory(const void *pImage, + int w, int h, + int num_chans, + size_t *pLen_out); + +/* Output stream interface. The compressor uses this interface to write + * compressed data. It'll typically be called TDEFL_OUT_BUF_SIZE at a time. */ +typedef mz_bool (*tdefl_put_buf_func_ptr)(const void *pBuf, int len, + void *pUser); + +/* tdefl_compress_mem_to_output() compresses a block to an output stream. The + * above helpers use this function internally. */ +MINIZ_EXPORT mz_bool tdefl_compress_mem_to_output( + const void *pBuf, size_t buf_len, tdefl_put_buf_func_ptr pPut_buf_func, + void *pPut_buf_user, int flags); + +enum { + TDEFL_MAX_HUFF_TABLES = 3, + TDEFL_MAX_HUFF_SYMBOLS_0 = 288, + TDEFL_MAX_HUFF_SYMBOLS_1 = 32, + TDEFL_MAX_HUFF_SYMBOLS_2 = 19, + TDEFL_LZ_DICT_SIZE = 32768, + TDEFL_LZ_DICT_SIZE_MASK = TDEFL_LZ_DICT_SIZE - 1, + TDEFL_MIN_MATCH_LEN = 3, + TDEFL_MAX_MATCH_LEN = 258 +}; + +/* TDEFL_OUT_BUF_SIZE MUST be large enough to hold a single entire compressed + * output block (using static/fixed Huffman codes). */ +#if TDEFL_LESS_MEMORY +enum { + TDEFL_LZ_CODE_BUF_SIZE = 24 * 1024, + TDEFL_OUT_BUF_SIZE = (TDEFL_LZ_CODE_BUF_SIZE * 13) / 10, + TDEFL_MAX_HUFF_SYMBOLS = 288, + TDEFL_LZ_HASH_BITS = 12, + TDEFL_LEVEL1_HASH_SIZE_MASK = 4095, + TDEFL_LZ_HASH_SHIFT = (TDEFL_LZ_HASH_BITS + 2) / 3, + TDEFL_LZ_HASH_SIZE = 1 << TDEFL_LZ_HASH_BITS +}; +#else +enum { + TDEFL_LZ_CODE_BUF_SIZE = 64 * 1024, + TDEFL_OUT_BUF_SIZE = (TDEFL_LZ_CODE_BUF_SIZE * 13) / 10, + TDEFL_MAX_HUFF_SYMBOLS = 288, + TDEFL_LZ_HASH_BITS = 15, + TDEFL_LEVEL1_HASH_SIZE_MASK = 4095, + TDEFL_LZ_HASH_SHIFT = (TDEFL_LZ_HASH_BITS + 2) / 3, + TDEFL_LZ_HASH_SIZE = 1 << TDEFL_LZ_HASH_BITS +}; +#endif + +/* The low-level tdefl functions below may be used directly if the above helper + * functions aren't flexible enough. The low-level functions don't make any heap + * allocations, unlike the above helper functions. */ +typedef enum { + TDEFL_STATUS_BAD_PARAM = -2, + TDEFL_STATUS_PUT_BUF_FAILED = -1, + TDEFL_STATUS_OKAY = 0, + TDEFL_STATUS_DONE = 1 +} tdefl_status; + +/* Must map to MZ_NO_FLUSH, MZ_SYNC_FLUSH, etc. enums */ +typedef enum { + TDEFL_NO_FLUSH = 0, + TDEFL_SYNC_FLUSH = 2, + TDEFL_FULL_FLUSH = 3, + TDEFL_FINISH = 4 +} tdefl_flush; + +/* tdefl's compression state structure. */ +typedef struct { + tdefl_put_buf_func_ptr m_pPut_buf_func; + void *m_pPut_buf_user; + mz_uint m_flags, m_max_probes[2]; + int m_greedy_parsing; + mz_uint m_adler32, m_lookahead_pos, m_lookahead_size, m_dict_size; + mz_uint8 *m_pLZ_code_buf, *m_pLZ_flags, *m_pOutput_buf, *m_pOutput_buf_end; + mz_uint m_num_flags_left, m_total_lz_bytes, m_lz_code_buf_dict_pos, m_bits_in, + m_bit_buffer; + mz_uint m_saved_match_dist, m_saved_match_len, m_saved_lit, + m_output_flush_ofs, m_output_flush_remaining, m_finished, m_block_index, + m_wants_to_finish; + tdefl_status m_prev_return_status; + const void *m_pIn_buf; + void *m_pOut_buf; + size_t *m_pIn_buf_size, *m_pOut_buf_size; + tdefl_flush m_flush; + const mz_uint8 *m_pSrc; + size_t m_src_buf_left, m_out_buf_ofs; + mz_uint8 m_dict[TDEFL_LZ_DICT_SIZE + TDEFL_MAX_MATCH_LEN - 1]; + mz_uint16 m_huff_count[TDEFL_MAX_HUFF_TABLES][TDEFL_MAX_HUFF_SYMBOLS]; + mz_uint16 m_huff_codes[TDEFL_MAX_HUFF_TABLES][TDEFL_MAX_HUFF_SYMBOLS]; + mz_uint8 m_huff_code_sizes[TDEFL_MAX_HUFF_TABLES][TDEFL_MAX_HUFF_SYMBOLS]; + mz_uint8 m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE]; + mz_uint16 m_next[TDEFL_LZ_DICT_SIZE]; + mz_uint16 m_hash[TDEFL_LZ_HASH_SIZE]; + mz_uint8 m_output_buf[TDEFL_OUT_BUF_SIZE]; +} tdefl_compressor; + +/* Initializes the compressor. */ +/* There is no corresponding deinit() function because the tdefl API's do not + * dynamically allocate memory. */ +/* pBut_buf_func: If NULL, output data will be supplied to the specified + * callback. In this case, the user should call the tdefl_compress_buffer() API + * for compression. */ +/* If pBut_buf_func is NULL the user should always call the tdefl_compress() + * API. */ +/* flags: See the above enums (TDEFL_HUFFMAN_ONLY, TDEFL_WRITE_ZLIB_HEADER, + * etc.) */ +MINIZ_EXPORT tdefl_status tdefl_init(tdefl_compressor *d, + tdefl_put_buf_func_ptr pPut_buf_func, + void *pPut_buf_user, int flags); + +/* Compresses a block of data, consuming as much of the specified input buffer + * as possible, and writing as much compressed data to the specified output + * buffer as possible. */ +MINIZ_EXPORT tdefl_status tdefl_compress(tdefl_compressor *d, + const void *pIn_buf, + size_t *pIn_buf_size, void *pOut_buf, + size_t *pOut_buf_size, + tdefl_flush flush); + +/* tdefl_compress_buffer() is only usable when the tdefl_init() is called with a + * non-NULL tdefl_put_buf_func_ptr. */ +/* tdefl_compress_buffer() always consumes the entire input buffer. */ +MINIZ_EXPORT tdefl_status tdefl_compress_buffer(tdefl_compressor *d, + const void *pIn_buf, + size_t in_buf_size, + tdefl_flush flush); + +MINIZ_EXPORT tdefl_status tdefl_get_prev_return_status(tdefl_compressor *d); +MINIZ_EXPORT mz_uint32 tdefl_get_adler32(tdefl_compressor *d); + +/* Create tdefl_compress() flags given zlib-style compression parameters. */ +/* level may range from [0,10] (where 10 is absolute max compression, but may be + * much slower on some files) */ +/* window_bits may be -15 (raw deflate) or 15 (zlib) */ +/* strategy may be either MZ_DEFAULT_STRATEGY, MZ_FILTERED, MZ_HUFFMAN_ONLY, + * MZ_RLE, or MZ_FIXED */ +MINIZ_EXPORT mz_uint tdefl_create_comp_flags_from_zip_params(int level, + int window_bits, + int strategy); + +#ifndef MINIZ_NO_MALLOC +/* Allocate the tdefl_compressor structure in C so that */ +/* non-C language bindings to tdefl_ API don't need to worry about */ +/* structure size and allocation mechanism. */ +MINIZ_EXPORT tdefl_compressor *tdefl_compressor_alloc(void); +MINIZ_EXPORT void tdefl_compressor_free(tdefl_compressor *pComp); +#endif + +#ifdef __cplusplus +} +#endif +#pragma once + +/* ------------------- Low-level Decompression API Definitions */ + +#ifdef __cplusplus +extern "C" { +#endif +/* Decompression flags used by tinfl_decompress(). */ +/* TINFL_FLAG_PARSE_ZLIB_HEADER: If set, the input has a valid zlib header and + * ends with an adler32 checksum (it's a valid zlib stream). Otherwise, the + * input is a raw deflate stream. */ +/* TINFL_FLAG_HAS_MORE_INPUT: If set, there are more input bytes available + * beyond the end of the supplied input buffer. If clear, the input buffer + * contains all remaining input. */ +/* TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF: If set, the output buffer is large + * enough to hold the entire decompressed stream. If clear, the output buffer is + * at least the size of the dictionary (typically 32KB). */ +/* TINFL_FLAG_COMPUTE_ADLER32: Force adler-32 checksum computation of the + * decompressed bytes. */ +enum { + TINFL_FLAG_PARSE_ZLIB_HEADER = 1, + TINFL_FLAG_HAS_MORE_INPUT = 2, + TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF = 4, + TINFL_FLAG_COMPUTE_ADLER32 = 8 +}; + +/* High level decompression functions: */ +/* tinfl_decompress_mem_to_heap() decompresses a block in memory to a heap block + * allocated via malloc(). */ +/* On entry: */ +/* pSrc_buf, src_buf_len: Pointer and size of the Deflate or zlib source data + * to decompress. */ +/* On return: */ +/* Function returns a pointer to the decompressed data, or NULL on failure. */ +/* *pOut_len will be set to the decompressed data's size, which could be larger + * than src_buf_len on uncompressible data. */ +/* The caller must call mz_free() on the returned block when it's no longer + * needed. */ +MINIZ_EXPORT void *tinfl_decompress_mem_to_heap(const void *pSrc_buf, + size_t src_buf_len, + size_t *pOut_len, int flags); + +/* tinfl_decompress_mem_to_mem() decompresses a block in memory to another block + * in memory. */ +/* Returns TINFL_DECOMPRESS_MEM_TO_MEM_FAILED on failure, or the number of bytes + * written on success. */ +#define TINFL_DECOMPRESS_MEM_TO_MEM_FAILED ((size_t)(-1)) +MINIZ_EXPORT size_t tinfl_decompress_mem_to_mem(void *pOut_buf, + size_t out_buf_len, + const void *pSrc_buf, + size_t src_buf_len, int flags); + +/* tinfl_decompress_mem_to_callback() decompresses a block in memory to an + * internal 32KB buffer, and a user provided callback function will be called to + * flush the buffer. */ +/* Returns 1 on success or 0 on failure. */ +typedef int (*tinfl_put_buf_func_ptr)(const void *pBuf, int len, void *pUser); +MINIZ_EXPORT int +tinfl_decompress_mem_to_callback(const void *pIn_buf, size_t *pIn_buf_size, + tinfl_put_buf_func_ptr pPut_buf_func, + void *pPut_buf_user, int flags); + +struct tinfl_decompressor_tag; +typedef struct tinfl_decompressor_tag tinfl_decompressor; + +#ifndef MINIZ_NO_MALLOC +/* Allocate the tinfl_decompressor structure in C so that */ +/* non-C language bindings to tinfl_ API don't need to worry about */ +/* structure size and allocation mechanism. */ +MINIZ_EXPORT tinfl_decompressor *tinfl_decompressor_alloc(void); +MINIZ_EXPORT void tinfl_decompressor_free(tinfl_decompressor *pDecomp); +#endif + +/* Max size of LZ dictionary. */ +#define TINFL_LZ_DICT_SIZE 32768 + +/* Return status. */ +typedef enum { + /* This flags indicates the inflator needs 1 or more input bytes to make + forward progress, but the caller is indicating that no more are available. + The compressed data */ + /* is probably corrupted. If you call the inflator again with more bytes it'll + try to continue processing the input but this is a BAD sign (either the + data is corrupted or you called it incorrectly). */ + /* If you call it again with no input you'll just get + TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS again. */ + TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS = -4, + + /* This flag indicates that one or more of the input parameters was obviously + bogus. (You can try calling it again, but if you get this error the calling + code is wrong.) */ + TINFL_STATUS_BAD_PARAM = -3, + + /* This flags indicate the inflator is finished but the adler32 check of the + uncompressed data didn't match. If you call it again it'll return + TINFL_STATUS_DONE. */ + TINFL_STATUS_ADLER32_MISMATCH = -2, + + /* This flags indicate the inflator has somehow failed (bad code, corrupted + input, etc.). If you call it again without resetting via tinfl_init() it + it'll just keep on returning the same status failure code. */ + TINFL_STATUS_FAILED = -1, + + /* Any status code less than TINFL_STATUS_DONE must indicate a failure. */ + + /* This flag indicates the inflator has returned every byte of uncompressed + data that it can, has consumed every byte that it needed, has successfully + reached the end of the deflate stream, and */ + /* if zlib headers and adler32 checking enabled that it has successfully + checked the uncompressed data's adler32. If you call it again you'll just + get TINFL_STATUS_DONE over and over again. */ + TINFL_STATUS_DONE = 0, + + /* This flag indicates the inflator MUST have more input data (even 1 byte) + before it can make any more forward progress, or you need to clear the + TINFL_FLAG_HAS_MORE_INPUT */ + /* flag on the next call if you don't have any more source data. If the source + data was somehow corrupted it's also possible (but unlikely) for the + inflator to keep on demanding input to */ + /* proceed, so be sure to properly set the TINFL_FLAG_HAS_MORE_INPUT flag. */ + TINFL_STATUS_NEEDS_MORE_INPUT = 1, + + /* This flag indicates the inflator definitely has 1 or more bytes of + uncompressed data available, but it cannot write this data into the output + buffer. */ + /* Note if the source compressed data was corrupted it's possible for the + inflator to return a lot of uncompressed data to the caller. I've been + assuming you know how much uncompressed data to expect */ + /* (either exact or worst case) and will stop calling the inflator and fail + after receiving too much. In pure streaming scenarios where you have no + idea how many bytes to expect this may not be possible */ + /* so I may need to add some code to address this. */ + TINFL_STATUS_HAS_MORE_OUTPUT = 2 +} tinfl_status; + +/* Initializes the decompressor to its initial state. */ +#define tinfl_init(r) \ + do { \ + (r)->m_state = 0; \ + } \ + MZ_MACRO_END +#define tinfl_get_adler32(r) (r)->m_check_adler32 + +/* Main low-level decompressor coroutine function. This is the only function + * actually needed for decompression. All the other functions are just + * high-level helpers for improved usability. */ +/* This is a universal API, i.e. it can be used as a building block to build any + * desired higher level decompression API. In the limit case, it can be called + * once per every byte input or output. */ +MINIZ_EXPORT tinfl_status tinfl_decompress( + tinfl_decompressor *r, const mz_uint8 *pIn_buf_next, size_t *pIn_buf_size, + mz_uint8 *pOut_buf_start, mz_uint8 *pOut_buf_next, size_t *pOut_buf_size, + const mz_uint32 decomp_flags); + +/* Internal/private bits follow. */ +enum { + TINFL_MAX_HUFF_TABLES = 3, + TINFL_MAX_HUFF_SYMBOLS_0 = 288, + TINFL_MAX_HUFF_SYMBOLS_1 = 32, + TINFL_MAX_HUFF_SYMBOLS_2 = 19, + TINFL_FAST_LOOKUP_BITS = 10, + TINFL_FAST_LOOKUP_SIZE = 1 << TINFL_FAST_LOOKUP_BITS +}; + +typedef struct { + mz_uint8 m_code_size[TINFL_MAX_HUFF_SYMBOLS_0]; + mz_int16 m_look_up[TINFL_FAST_LOOKUP_SIZE], + m_tree[TINFL_MAX_HUFF_SYMBOLS_0 * 2]; +} tinfl_huff_table; + +#if MINIZ_HAS_64BIT_REGISTERS +#define TINFL_USE_64BIT_BITBUF 1 +#else +#define TINFL_USE_64BIT_BITBUF 0 +#endif + +#if TINFL_USE_64BIT_BITBUF +typedef mz_uint64 tinfl_bit_buf_t; +#define TINFL_BITBUF_SIZE (64) +#else +typedef mz_uint32 tinfl_bit_buf_t; +#define TINFL_BITBUF_SIZE (32) +#endif + +struct tinfl_decompressor_tag { + mz_uint32 m_state, m_num_bits, m_zhdr0, m_zhdr1, m_z_adler32, m_final, m_type, + m_check_adler32, m_dist, m_counter, m_num_extra, + m_table_sizes[TINFL_MAX_HUFF_TABLES]; + tinfl_bit_buf_t m_bit_buf; + size_t m_dist_from_out_buf_start; + tinfl_huff_table m_tables[TINFL_MAX_HUFF_TABLES]; + mz_uint8 m_raw_header[4], + m_len_codes[TINFL_MAX_HUFF_SYMBOLS_0 + TINFL_MAX_HUFF_SYMBOLS_1 + 137]; +}; + +#ifdef __cplusplus +} +#endif + +#pragma once + +/* ------------------- ZIP archive reading/writing */ + +#ifndef MINIZ_NO_ARCHIVE_APIS + +#ifdef __cplusplus +extern "C" { +#endif + +enum { + /* Note: These enums can be reduced as needed to save memory or stack space - + they are pretty conservative. */ + MZ_ZIP_MAX_IO_BUF_SIZE = 8 * 1024, + MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE = 512, + MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE = 512 +}; + +typedef struct { + /* Central directory file index. */ + mz_uint32 m_file_index; + + /* Byte offset of this entry in the archive's central directory. Note we + * currently only support up to UINT_MAX or less bytes in the central dir. */ + mz_uint64 m_central_dir_ofs; + + /* These fields are copied directly from the zip's central dir. */ + mz_uint16 m_version_made_by; + mz_uint16 m_version_needed; + mz_uint16 m_bit_flag; + mz_uint16 m_method; + +#ifndef MINIZ_NO_TIME + MZ_TIME_T m_time; +#endif + + /* CRC-32 of uncompressed data. */ + mz_uint32 m_crc32; + + /* File's compressed size. */ + mz_uint64 m_comp_size; + + /* File's uncompressed size. Note, I've seen some old archives where directory + * entries had 512 bytes for their uncompressed sizes, but when you try to + * unpack them you actually get 0 bytes. */ + mz_uint64 m_uncomp_size; + + /* Zip internal and external file attributes. */ + mz_uint16 m_internal_attr; + mz_uint32 m_external_attr; + + /* Entry's local header file offset in bytes. */ + mz_uint64 m_local_header_ofs; + + /* Size of comment in bytes. */ + mz_uint32 m_comment_size; + + /* MZ_TRUE if the entry appears to be a directory. */ + mz_bool m_is_directory; + + /* MZ_TRUE if the entry uses encryption/strong encryption (which miniz_zip + * doesn't support) */ + mz_bool m_is_encrypted; + + /* MZ_TRUE if the file is not encrypted, a patch file, and if it uses a + * compression method we support. */ + mz_bool m_is_supported; + + /* Filename. If string ends in '/' it's a subdirectory entry. */ + /* Guaranteed to be zero terminated, may be truncated to fit. */ + char m_filename[MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE]; + + /* Comment field. */ + /* Guaranteed to be zero terminated, may be truncated to fit. */ + char m_comment[MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE]; + +} mz_zip_archive_file_stat; + +typedef size_t (*mz_file_read_func)(void *pOpaque, mz_uint64 file_ofs, + void *pBuf, size_t n); +typedef size_t (*mz_file_write_func)(void *pOpaque, mz_uint64 file_ofs, + const void *pBuf, size_t n); +typedef mz_bool (*mz_file_needs_keepalive)(void *pOpaque); + +struct mz_zip_internal_state_tag; +typedef struct mz_zip_internal_state_tag mz_zip_internal_state; + +typedef enum { + MZ_ZIP_MODE_INVALID = 0, + MZ_ZIP_MODE_READING = 1, + MZ_ZIP_MODE_WRITING = 2, + MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED = 3 +} mz_zip_mode; + +typedef enum { + MZ_ZIP_FLAG_CASE_SENSITIVE = 0x0100, + MZ_ZIP_FLAG_IGNORE_PATH = 0x0200, + MZ_ZIP_FLAG_COMPRESSED_DATA = 0x0400, + MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY = 0x0800, + MZ_ZIP_FLAG_VALIDATE_LOCATE_FILE_FLAG = + 0x1000, /* if enabled, mz_zip_reader_locate_file() will be called on each + file as its validated to ensure the func finds the file in the + central dir (intended for testing) */ + MZ_ZIP_FLAG_VALIDATE_HEADERS_ONLY = + 0x2000, /* validate the local headers, but don't decompress the entire + file and check the crc32 */ + MZ_ZIP_FLAG_WRITE_ZIP64 = + 0x4000, /* always use the zip64 file format, instead of the original zip + file format with automatic switch to zip64. Use as flags + parameter with mz_zip_writer_init*_v2 */ + MZ_ZIP_FLAG_WRITE_ALLOW_READING = 0x8000, + MZ_ZIP_FLAG_ASCII_FILENAME = 0x10000, + /*After adding a compressed file, seek back + to local file header and set the correct sizes*/ + MZ_ZIP_FLAG_WRITE_HEADER_SET_SIZE = 0x20000 +} mz_zip_flags; + +typedef enum { + MZ_ZIP_TYPE_INVALID = 0, + MZ_ZIP_TYPE_USER, + MZ_ZIP_TYPE_MEMORY, + MZ_ZIP_TYPE_HEAP, + MZ_ZIP_TYPE_FILE, + MZ_ZIP_TYPE_CFILE, + MZ_ZIP_TOTAL_TYPES +} mz_zip_type; + +/* miniz error codes. Be sure to update mz_zip_get_error_string() if you add or + * modify this enum. */ +typedef enum { + MZ_ZIP_NO_ERROR = 0, + MZ_ZIP_UNDEFINED_ERROR, + MZ_ZIP_TOO_MANY_FILES, + MZ_ZIP_FILE_TOO_LARGE, + MZ_ZIP_UNSUPPORTED_METHOD, + MZ_ZIP_UNSUPPORTED_ENCRYPTION, + MZ_ZIP_UNSUPPORTED_FEATURE, + MZ_ZIP_FAILED_FINDING_CENTRAL_DIR, + MZ_ZIP_NOT_AN_ARCHIVE, + MZ_ZIP_INVALID_HEADER_OR_CORRUPTED, + MZ_ZIP_UNSUPPORTED_MULTIDISK, + MZ_ZIP_DECOMPRESSION_FAILED, + MZ_ZIP_COMPRESSION_FAILED, + MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE, + MZ_ZIP_CRC_CHECK_FAILED, + MZ_ZIP_UNSUPPORTED_CDIR_SIZE, + MZ_ZIP_ALLOC_FAILED, + MZ_ZIP_FILE_OPEN_FAILED, + MZ_ZIP_FILE_CREATE_FAILED, + MZ_ZIP_FILE_WRITE_FAILED, + MZ_ZIP_FILE_READ_FAILED, + MZ_ZIP_FILE_CLOSE_FAILED, + MZ_ZIP_FILE_SEEK_FAILED, + MZ_ZIP_FILE_STAT_FAILED, + MZ_ZIP_INVALID_PARAMETER, + MZ_ZIP_INVALID_FILENAME, + MZ_ZIP_BUF_TOO_SMALL, + MZ_ZIP_INTERNAL_ERROR, + MZ_ZIP_FILE_NOT_FOUND, + MZ_ZIP_ARCHIVE_TOO_LARGE, + MZ_ZIP_VALIDATION_FAILED, + MZ_ZIP_WRITE_CALLBACK_FAILED, + MZ_ZIP_TOTAL_ERRORS +} mz_zip_error; + +typedef struct { + mz_uint64 m_archive_size; + mz_uint64 m_central_directory_file_ofs; + + /* We only support up to UINT32_MAX files in zip64 mode. */ + mz_uint32 m_total_files; + mz_zip_mode m_zip_mode; + mz_zip_type m_zip_type; + mz_zip_error m_last_error; + + mz_uint64 m_file_offset_alignment; + + mz_alloc_func m_pAlloc; + mz_free_func m_pFree; + mz_realloc_func m_pRealloc; + void *m_pAlloc_opaque; + + mz_file_read_func m_pRead; + mz_file_write_func m_pWrite; + mz_file_needs_keepalive m_pNeeds_keepalive; + void *m_pIO_opaque; + + mz_zip_internal_state *m_pState; + +} mz_zip_archive; + +typedef struct { + mz_zip_archive *pZip; + mz_uint flags; + + int status; +#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS + mz_uint file_crc32; +#endif + mz_uint64 read_buf_size, read_buf_ofs, read_buf_avail, comp_remaining, + out_buf_ofs, cur_file_ofs; + mz_zip_archive_file_stat file_stat; + void *pRead_buf; + void *pWrite_buf; + + size_t out_blk_remain; + + tinfl_decompressor inflator; + +} mz_zip_reader_extract_iter_state; + +/* -------- ZIP reading */ + +/* Inits a ZIP archive reader. */ +/* These functions read and validate the archive's central directory. */ +MINIZ_EXPORT mz_bool mz_zip_reader_init(mz_zip_archive *pZip, mz_uint64 size, + mz_uint flags); + +MINIZ_EXPORT mz_bool mz_zip_reader_init_mem(mz_zip_archive *pZip, + const void *pMem, size_t size, + mz_uint flags); + +#ifndef MINIZ_NO_STDIO +/* Read a archive from a disk file. */ +/* file_start_ofs is the file offset where the archive actually begins, or 0. */ +/* actual_archive_size is the true total size of the archive, which may be + * smaller than the file's actual size on disk. If zero the entire file is + * treated as the archive. */ +MINIZ_EXPORT mz_bool mz_zip_reader_init_file(mz_zip_archive *pZip, + const char *pFilename, + mz_uint32 flags); +MINIZ_EXPORT mz_bool mz_zip_reader_init_file_v2(mz_zip_archive *pZip, + const char *pFilename, + mz_uint flags, + mz_uint64 file_start_ofs, + mz_uint64 archive_size); + +/* Read an archive from an already opened FILE, beginning at the current file + * position. */ +/* The archive is assumed to be archive_size bytes long. If archive_size is 0, + * then the entire rest of the file is assumed to contain the archive. */ +/* The FILE will NOT be closed when mz_zip_reader_end() is called. */ +MINIZ_EXPORT mz_bool mz_zip_reader_init_cfile(mz_zip_archive *pZip, + MZ_FILE *pFile, + mz_uint64 archive_size, + mz_uint flags); +#endif + +/* Ends archive reading, freeing all allocations, and closing the input archive + * file if mz_zip_reader_init_file() was used. */ +MINIZ_EXPORT mz_bool mz_zip_reader_end(mz_zip_archive *pZip); + +/* -------- ZIP reading or writing */ + +/* Clears a mz_zip_archive struct to all zeros. */ +/* Important: This must be done before passing the struct to any mz_zip + * functions. */ +MINIZ_EXPORT void mz_zip_zero_struct(mz_zip_archive *pZip); + +MINIZ_EXPORT mz_zip_mode mz_zip_get_mode(mz_zip_archive *pZip); +MINIZ_EXPORT mz_zip_type mz_zip_get_type(mz_zip_archive *pZip); + +/* Returns the total number of files in the archive. */ +MINIZ_EXPORT mz_uint mz_zip_reader_get_num_files(mz_zip_archive *pZip); + +MINIZ_EXPORT mz_uint64 mz_zip_get_archive_size(mz_zip_archive *pZip); +MINIZ_EXPORT mz_uint64 +mz_zip_get_archive_file_start_offset(mz_zip_archive *pZip); +MINIZ_EXPORT MZ_FILE *mz_zip_get_cfile(mz_zip_archive *pZip); + +/* Reads n bytes of raw archive data, starting at file offset file_ofs, to pBuf. + */ +MINIZ_EXPORT size_t mz_zip_read_archive_data(mz_zip_archive *pZip, + mz_uint64 file_ofs, void *pBuf, + size_t n); + +/* All mz_zip funcs set the m_last_error field in the mz_zip_archive struct. + * These functions retrieve/manipulate this field. */ +/* Note that the m_last_error functionality is not thread safe. */ +MINIZ_EXPORT mz_zip_error mz_zip_set_last_error(mz_zip_archive *pZip, + mz_zip_error err_num); +MINIZ_EXPORT mz_zip_error mz_zip_peek_last_error(mz_zip_archive *pZip); +MINIZ_EXPORT mz_zip_error mz_zip_clear_last_error(mz_zip_archive *pZip); +MINIZ_EXPORT mz_zip_error mz_zip_get_last_error(mz_zip_archive *pZip); +MINIZ_EXPORT const char *mz_zip_get_error_string(mz_zip_error mz_err); + +/* MZ_TRUE if the archive file entry is a directory entry. */ +MINIZ_EXPORT mz_bool mz_zip_reader_is_file_a_directory(mz_zip_archive *pZip, + mz_uint file_index); + +/* MZ_TRUE if the file is encrypted/strong encrypted. */ +MINIZ_EXPORT mz_bool mz_zip_reader_is_file_encrypted(mz_zip_archive *pZip, + mz_uint file_index); + +/* MZ_TRUE if the compression method is supported, and the file is not + * encrypted, and the file is not a compressed patch file. */ +MINIZ_EXPORT mz_bool mz_zip_reader_is_file_supported(mz_zip_archive *pZip, + mz_uint file_index); + +/* Retrieves the filename of an archive file entry. */ +/* Returns the number of bytes written to pFilename, or if filename_buf_size is + * 0 this function returns the number of bytes needed to fully store the + * filename. */ +MINIZ_EXPORT mz_uint mz_zip_reader_get_filename(mz_zip_archive *pZip, + mz_uint file_index, + char *pFilename, + mz_uint filename_buf_size); + +/* Attempts to locates a file in the archive's central directory. */ +/* Valid flags: MZ_ZIP_FLAG_CASE_SENSITIVE, MZ_ZIP_FLAG_IGNORE_PATH */ +/* Returns -1 if the file cannot be found. */ +MINIZ_EXPORT int mz_zip_reader_locate_file(mz_zip_archive *pZip, + const char *pName, + const char *pComment, mz_uint flags); +MINIZ_EXPORT mz_bool mz_zip_reader_locate_file_v2(mz_zip_archive *pZip, + const char *pName, + const char *pComment, + mz_uint flags, + mz_uint32 *file_index); + +/* Returns detailed information about an archive file entry. */ +MINIZ_EXPORT mz_bool mz_zip_reader_file_stat(mz_zip_archive *pZip, + mz_uint file_index, + mz_zip_archive_file_stat *pStat); + +/* MZ_TRUE if the file is in zip64 format. */ +/* A file is considered zip64 if it contained a zip64 end of central directory + * marker, or if it contained any zip64 extended file information fields in the + * central directory. */ +MINIZ_EXPORT mz_bool mz_zip_is_zip64(mz_zip_archive *pZip); + +/* Returns the total central directory size in bytes. */ +/* The current max supported size is <= MZ_UINT32_MAX. */ +MINIZ_EXPORT size_t mz_zip_get_central_dir_size(mz_zip_archive *pZip); + +/* Extracts a archive file to a memory buffer using no memory allocation. */ +/* There must be at least enough room on the stack to store the inflator's state + * (~34KB or so). */ +MINIZ_EXPORT mz_bool mz_zip_reader_extract_to_mem_no_alloc( + mz_zip_archive *pZip, mz_uint file_index, void *pBuf, size_t buf_size, + mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size); +MINIZ_EXPORT mz_bool mz_zip_reader_extract_file_to_mem_no_alloc( + mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size, + mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size); + +/* Extracts a archive file to a memory buffer. */ +MINIZ_EXPORT mz_bool mz_zip_reader_extract_to_mem(mz_zip_archive *pZip, + mz_uint file_index, + void *pBuf, size_t buf_size, + mz_uint flags); +MINIZ_EXPORT mz_bool mz_zip_reader_extract_file_to_mem(mz_zip_archive *pZip, + const char *pFilename, + void *pBuf, + size_t buf_size, + mz_uint flags); + +/* Extracts a archive file to a dynamically allocated heap buffer. */ +/* The memory will be allocated via the mz_zip_archive's alloc/realloc + * functions. */ +/* Returns NULL and sets the last error on failure. */ +MINIZ_EXPORT void *mz_zip_reader_extract_to_heap(mz_zip_archive *pZip, + mz_uint file_index, + size_t *pSize, mz_uint flags); +MINIZ_EXPORT void *mz_zip_reader_extract_file_to_heap(mz_zip_archive *pZip, + const char *pFilename, + size_t *pSize, + mz_uint flags); + +/* Extracts a archive file using a callback function to output the file's data. + */ +MINIZ_EXPORT mz_bool mz_zip_reader_extract_to_callback( + mz_zip_archive *pZip, mz_uint file_index, mz_file_write_func pCallback, + void *pOpaque, mz_uint flags); +MINIZ_EXPORT mz_bool mz_zip_reader_extract_file_to_callback( + mz_zip_archive *pZip, const char *pFilename, mz_file_write_func pCallback, + void *pOpaque, mz_uint flags); + +/* Extract a file iteratively */ +MINIZ_EXPORT mz_zip_reader_extract_iter_state * +mz_zip_reader_extract_iter_new(mz_zip_archive *pZip, mz_uint file_index, + mz_uint flags); +MINIZ_EXPORT mz_zip_reader_extract_iter_state * +mz_zip_reader_extract_file_iter_new(mz_zip_archive *pZip, const char *pFilename, + mz_uint flags); +MINIZ_EXPORT size_t mz_zip_reader_extract_iter_read( + mz_zip_reader_extract_iter_state *pState, void *pvBuf, size_t buf_size); +MINIZ_EXPORT mz_bool +mz_zip_reader_extract_iter_free(mz_zip_reader_extract_iter_state *pState); + +#ifndef MINIZ_NO_STDIO +/* Extracts a archive file to a disk file and sets its last accessed and + * modified times. */ +/* This function only extracts files, not archive directory records. */ +MINIZ_EXPORT mz_bool mz_zip_reader_extract_to_file(mz_zip_archive *pZip, + mz_uint file_index, + const char *pDst_filename, + mz_uint flags); +MINIZ_EXPORT mz_bool mz_zip_reader_extract_file_to_file( + mz_zip_archive *pZip, const char *pArchive_filename, + const char *pDst_filename, mz_uint flags); + +/* Extracts a archive file starting at the current position in the destination + * FILE stream. */ +MINIZ_EXPORT mz_bool mz_zip_reader_extract_to_cfile(mz_zip_archive *pZip, + mz_uint file_index, + MZ_FILE *File, + mz_uint flags); +MINIZ_EXPORT mz_bool mz_zip_reader_extract_file_to_cfile( + mz_zip_archive *pZip, const char *pArchive_filename, MZ_FILE *pFile, + mz_uint flags); +#endif + +#if 0 +/* TODO */ + typedef void *mz_zip_streaming_extract_state_ptr; + mz_zip_streaming_extract_state_ptr mz_zip_streaming_extract_begin(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags); + uint64_t mz_zip_streaming_extract_get_size(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState); + uint64_t mz_zip_streaming_extract_get_cur_ofs(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState); + mz_bool mz_zip_streaming_extract_seek(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState, uint64_t new_ofs); + size_t mz_zip_streaming_extract_read(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState, void *pBuf, size_t buf_size); + mz_bool mz_zip_streaming_extract_end(mz_zip_archive *pZip, mz_zip_streaming_extract_state_ptr pState); +#endif + +/* This function compares the archive's local headers, the optional local zip64 + * extended information block, and the optional descriptor following the + * compressed data vs. the data in the central directory. */ +/* It also validates that each file can be successfully uncompressed unless the + * MZ_ZIP_FLAG_VALIDATE_HEADERS_ONLY is specified. */ +MINIZ_EXPORT mz_bool mz_zip_validate_file(mz_zip_archive *pZip, + mz_uint file_index, mz_uint flags); + +/* Validates an entire archive by calling mz_zip_validate_file() on each file. + */ +MINIZ_EXPORT mz_bool mz_zip_validate_archive(mz_zip_archive *pZip, + mz_uint flags); + +/* Misc utils/helpers, valid for ZIP reading or writing */ +MINIZ_EXPORT mz_bool mz_zip_validate_mem_archive(const void *pMem, size_t size, + mz_uint flags, + mz_zip_error *pErr); +MINIZ_EXPORT mz_bool mz_zip_validate_file_archive(const char *pFilename, + mz_uint flags, + mz_zip_error *pErr); + +/* Universal end function - calls either mz_zip_reader_end() or + * mz_zip_writer_end(). */ +MINIZ_EXPORT mz_bool mz_zip_end(mz_zip_archive *pZip); + +/* -------- ZIP writing */ + +#ifndef MINIZ_NO_ARCHIVE_WRITING_APIS + +/* Inits a ZIP archive writer. */ +/*Set pZip->m_pWrite (and pZip->m_pIO_opaque) before calling mz_zip_writer_init + * or mz_zip_writer_init_v2*/ +/*The output is streamable, i.e. file_ofs in mz_file_write_func always increases + * only by n*/ +MINIZ_EXPORT mz_bool mz_zip_writer_init(mz_zip_archive *pZip, + mz_uint64 existing_size); +MINIZ_EXPORT mz_bool mz_zip_writer_init_v2(mz_zip_archive *pZip, + mz_uint64 existing_size, + mz_uint flags); + +MINIZ_EXPORT mz_bool mz_zip_writer_init_heap( + mz_zip_archive *pZip, size_t size_to_reserve_at_beginning, + size_t initial_allocation_size); +MINIZ_EXPORT mz_bool mz_zip_writer_init_heap_v2( + mz_zip_archive *pZip, size_t size_to_reserve_at_beginning, + size_t initial_allocation_size, mz_uint flags); + +#ifndef MINIZ_NO_STDIO +MINIZ_EXPORT mz_bool +mz_zip_writer_init_file(mz_zip_archive *pZip, const char *pFilename, + mz_uint64 size_to_reserve_at_beginning); +MINIZ_EXPORT mz_bool mz_zip_writer_init_file_v2( + mz_zip_archive *pZip, const char *pFilename, + mz_uint64 size_to_reserve_at_beginning, mz_uint flags); +MINIZ_EXPORT mz_bool mz_zip_writer_init_cfile(mz_zip_archive *pZip, + MZ_FILE *pFile, mz_uint flags); +#endif + +/* Converts a ZIP archive reader object into a writer object, to allow efficient + * in-place file appends to occur on an existing archive. */ +/* For archives opened using mz_zip_reader_init_file, pFilename must be the + * archive's filename so it can be reopened for writing. If the file can't be + * reopened, mz_zip_reader_end() will be called. */ +/* For archives opened using mz_zip_reader_init_mem, the memory block must be + * growable using the realloc callback (which defaults to realloc unless you've + * overridden it). */ +/* Finally, for archives opened using mz_zip_reader_init, the mz_zip_archive's + * user provided m_pWrite function cannot be NULL. */ +/* Note: In-place archive modification is not recommended unless you know what + * you're doing, because if execution stops or something goes wrong before */ +/* the archive is finalized the file's central directory will be hosed. */ +MINIZ_EXPORT mz_bool mz_zip_writer_init_from_reader(mz_zip_archive *pZip, + const char *pFilename); +MINIZ_EXPORT mz_bool mz_zip_writer_init_from_reader_v2(mz_zip_archive *pZip, + const char *pFilename, + mz_uint flags); + +/* Adds the contents of a memory buffer to an archive. These functions record + * the current local time into the archive. */ +/* To add a directory entry, call this method with an archive name ending in a + * forwardslash with an empty buffer. */ +/* level_and_flags - compression level (0-10, see MZ_BEST_SPEED, + * MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or + * just set to MZ_DEFAULT_COMPRESSION. */ +MINIZ_EXPORT mz_bool mz_zip_writer_add_mem(mz_zip_archive *pZip, + const char *pArchive_name, + const void *pBuf, size_t buf_size, + mz_uint level_and_flags); + +/* Like mz_zip_writer_add_mem(), except you can specify a file comment field, + * and optionally supply the function with already compressed data. */ +/* uncomp_size/uncomp_crc32 are only used if the MZ_ZIP_FLAG_COMPRESSED_DATA + * flag is specified. */ +MINIZ_EXPORT mz_bool mz_zip_writer_add_mem_ex( + mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, + size_t buf_size, const void *pComment, mz_uint16 comment_size, + mz_uint level_and_flags, mz_uint64 uncomp_size, mz_uint32 uncomp_crc32); + +MINIZ_EXPORT mz_bool mz_zip_writer_add_mem_ex_v2( + mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, + size_t buf_size, const void *pComment, mz_uint16 comment_size, + mz_uint level_and_flags, mz_uint64 uncomp_size, mz_uint32 uncomp_crc32, + MZ_TIME_T *last_modified, const char *user_extra_data_local, + mz_uint user_extra_data_local_len, const char *user_extra_data_central, + mz_uint user_extra_data_central_len); + +/* Adds the contents of a file to an archive. This function also records the + * disk file's modified time into the archive. */ +/* File data is supplied via a read callback function. User + * mz_zip_writer_add_(c)file to add a file directly.*/ +MINIZ_EXPORT mz_bool mz_zip_writer_add_read_buf_callback( + mz_zip_archive *pZip, const char *pArchive_name, + mz_file_read_func read_callback, void *callback_opaque, mz_uint64 max_size, + const MZ_TIME_T *pFile_time, const void *pComment, mz_uint16 comment_size, + mz_uint level_and_flags, mz_uint32 ext_attributes, + const char *user_extra_data_local, mz_uint user_extra_data_local_len, + const char *user_extra_data_central, mz_uint user_extra_data_central_len); + +#ifndef MINIZ_NO_STDIO +/* Adds the contents of a disk file to an archive. This function also records + * the disk file's modified time into the archive. */ +/* level_and_flags - compression level (0-10, see MZ_BEST_SPEED, + * MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or + * just set to MZ_DEFAULT_COMPRESSION. */ +MINIZ_EXPORT mz_bool mz_zip_writer_add_file( + mz_zip_archive *pZip, const char *pArchive_name, const char *pSrc_filename, + const void *pComment, mz_uint16 comment_size, mz_uint level_and_flags, + mz_uint32 ext_attributes); + +/* Like mz_zip_writer_add_file(), except the file data is read from the + * specified FILE stream. */ +MINIZ_EXPORT mz_bool mz_zip_writer_add_cfile( + mz_zip_archive *pZip, const char *pArchive_name, MZ_FILE *pSrc_file, + mz_uint64 max_size, const MZ_TIME_T *pFile_time, const void *pComment, + mz_uint16 comment_size, mz_uint level_and_flags, mz_uint32 ext_attributes, + const char *user_extra_data_local, mz_uint user_extra_data_local_len, + const char *user_extra_data_central, mz_uint user_extra_data_central_len); +#endif + +/* Adds a file to an archive by fully cloning the data from another archive. */ +/* This function fully clones the source file's compressed data (no + * recompression), along with its full filename, extra data (it may add or + * modify the zip64 local header extra data field), and the optional descriptor + * following the compressed data. */ +MINIZ_EXPORT mz_bool mz_zip_writer_add_from_zip_reader( + mz_zip_archive *pZip, mz_zip_archive *pSource_zip, mz_uint src_file_index); + +/* Finalizes the archive by writing the central directory records followed by + * the end of central directory record. */ +/* After an archive is finalized, the only valid call on the mz_zip_archive + * struct is mz_zip_writer_end(). */ +/* An archive must be manually finalized by calling this function for it to be + * valid. */ +MINIZ_EXPORT mz_bool mz_zip_writer_finalize_archive(mz_zip_archive *pZip); + +/* Finalizes a heap archive, returning a poiner to the heap block and its size. + */ +/* The heap block will be allocated using the mz_zip_archive's alloc/realloc + * callbacks. */ +MINIZ_EXPORT mz_bool mz_zip_writer_finalize_heap_archive(mz_zip_archive *pZip, + void **ppBuf, + size_t *pSize); + +/* Ends archive writing, freeing all allocations, and closing the output file if + * mz_zip_writer_init_file() was used. */ +/* Note for the archive to be valid, it *must* have been finalized before ending + * (this function will not do it for you). */ +MINIZ_EXPORT mz_bool mz_zip_writer_end(mz_zip_archive *pZip); + +/* -------- Misc. high-level helper functions: */ + +/* mz_zip_add_mem_to_archive_file_in_place() efficiently (but not atomically) + * appends a memory blob to a ZIP archive. */ +/* Note this is NOT a fully safe operation. If it crashes or dies in some way + * your archive can be left in a screwed up state (without a central directory). + */ +/* level_and_flags - compression level (0-10, see MZ_BEST_SPEED, + * MZ_BEST_COMPRESSION, etc.) logically OR'd with zero or more mz_zip_flags, or + * just set to MZ_DEFAULT_COMPRESSION. */ +/* TODO: Perhaps add an option to leave the existing central dir in place in + * case the add dies? We could then truncate the file (so the old central dir + * would be at the end) if something goes wrong. */ +MINIZ_EXPORT mz_bool mz_zip_add_mem_to_archive_file_in_place( + const char *pZip_filename, const char *pArchive_name, const void *pBuf, + size_t buf_size, const void *pComment, mz_uint16 comment_size, + mz_uint level_and_flags); +MINIZ_EXPORT mz_bool mz_zip_add_mem_to_archive_file_in_place_v2( + const char *pZip_filename, const char *pArchive_name, const void *pBuf, + size_t buf_size, const void *pComment, mz_uint16 comment_size, + mz_uint level_and_flags, mz_zip_error *pErr); + +/* Reads a single file from an archive into a heap block. */ +/* If pComment is not NULL, only the file with the specified comment will be + * extracted. */ +/* Returns NULL on failure. */ +MINIZ_EXPORT void * +mz_zip_extract_archive_file_to_heap(const char *pZip_filename, + const char *pArchive_name, size_t *pSize, + mz_uint flags); +MINIZ_EXPORT void *mz_zip_extract_archive_file_to_heap_v2( + const char *pZip_filename, const char *pArchive_name, const char *pComment, + size_t *pSize, mz_uint flags, mz_zip_error *pErr); + +#endif /* #ifndef MINIZ_NO_ARCHIVE_WRITING_APIS */ + +#ifdef __cplusplus +} +#endif + +#endif /* MINIZ_NO_ARCHIVE_APIS */ +/************************************************************************** + * + * Copyright 2013-2014 RAD Game Tools and Valve Software + * Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + +typedef unsigned char mz_validate_uint16[sizeof(mz_uint16) == 2 ? 1 : -1]; +typedef unsigned char mz_validate_uint32[sizeof(mz_uint32) == 4 ? 1 : -1]; +typedef unsigned char mz_validate_uint64[sizeof(mz_uint64) == 8 ? 1 : -1]; + +#ifdef __cplusplus +extern "C" { +#endif + +/* ------------------- zlib-style API's */ + +mz_ulong mz_adler32(mz_ulong adler, const unsigned char *ptr, size_t buf_len) { + mz_uint32 i, s1 = (mz_uint32)(adler & 0xffff), s2 = (mz_uint32)(adler >> 16); + size_t block_len = buf_len % 5552; + if (!ptr) + return MZ_ADLER32_INIT; + while (buf_len) { + for (i = 0; i + 7 < block_len; i += 8, ptr += 8) { + s1 += ptr[0], s2 += s1; + s1 += ptr[1], s2 += s1; + s1 += ptr[2], s2 += s1; + s1 += ptr[3], s2 += s1; + s1 += ptr[4], s2 += s1; + s1 += ptr[5], s2 += s1; + s1 += ptr[6], s2 += s1; + s1 += ptr[7], s2 += s1; + } + for (; i < block_len; ++i) + s1 += *ptr++, s2 += s1; + s1 %= 65521U, s2 %= 65521U; + buf_len -= block_len; + block_len = 5552; + } + return (s2 << 16) + s1; +} + +/* Karl Malbrain's compact CRC-32. See "A compact CCITT crc16 and crc32 C + * implementation that balances processor cache usage against speed": + * http://www.geocities.com/malbrain/ */ +#if 0 + mz_ulong mz_crc32(mz_ulong crc, const mz_uint8 *ptr, size_t buf_len) + { + static const mz_uint32 s_crc32[16] = { 0, 0x1db71064, 0x3b6e20c8, 0x26d930ac, 0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c, + 0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c, 0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c }; + mz_uint32 crcu32 = (mz_uint32)crc; + if (!ptr) + return MZ_CRC32_INIT; + crcu32 = ~crcu32; + while (buf_len--) + { + mz_uint8 b = *ptr++; + crcu32 = (crcu32 >> 4) ^ s_crc32[(crcu32 & 0xF) ^ (b & 0xF)]; + crcu32 = (crcu32 >> 4) ^ s_crc32[(crcu32 & 0xF) ^ (b >> 4)]; + } + return ~crcu32; + } +#elif defined(USE_EXTERNAL_MZCRC) +/* If USE_EXTERNAL_CRC is defined, an external module will export the + * mz_crc32() symbol for us to use, e.g. an SSE-accelerated version. + * Depending on the impl, it may be necessary to ~ the input/output crc values. + */ +mz_ulong mz_crc32(mz_ulong crc, const mz_uint8 *ptr, size_t buf_len); +#else +/* Faster, but larger CPU cache footprint. + */ +mz_ulong mz_crc32(mz_ulong crc, const mz_uint8 *ptr, size_t buf_len) { + static const mz_uint32 s_crc_table[256] = { + 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, + 0xE963A535, 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, + 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2, + 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, + 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, + 0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, + 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x35B5A8FA, 0x42B2986C, + 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, + 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, + 0xCFBA9599, 0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, + 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, 0x76DC4190, 0x01DB7106, + 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433, + 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, + 0x91646C97, 0xE6635C01, 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, + 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950, + 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, + 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, + 0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, + 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA, + 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F, + 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, + 0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, + 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84, + 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, + 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, + 0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, + 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 0xD6D6A3E8, 0xA1D1937E, + 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B, + 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, + 0x316E8EEF, 0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, + 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28, + 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, + 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, + 0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, + 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242, + 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, + 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, + 0x616BFFD3, 0x166CCF45, 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, + 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC, + 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, + 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, + 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, + 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D}; + + mz_uint32 crc32 = (mz_uint32)crc ^ 0xFFFFFFFF; + const mz_uint8 *pByte_buf = (const mz_uint8 *)ptr; + + while (buf_len >= 4) { + crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[0]) & 0xFF]; + crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[1]) & 0xFF]; + crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[2]) & 0xFF]; + crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[3]) & 0xFF]; + pByte_buf += 4; + buf_len -= 4; + } + + while (buf_len) { + crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[0]) & 0xFF]; + ++pByte_buf; + --buf_len; + } + + return ~crc32; +} +#endif + +void mz_free(void *p) { MZ_FREE(p); } + +MINIZ_EXPORT void *miniz_def_alloc_func(void *opaque, size_t items, + size_t size) { + (void)opaque, (void)items, (void)size; + return MZ_MALLOC(items * size); +} +MINIZ_EXPORT void miniz_def_free_func(void *opaque, void *address) { + (void)opaque, (void)address; + MZ_FREE(address); +} +MINIZ_EXPORT void *miniz_def_realloc_func(void *opaque, void *address, + size_t items, size_t size) { + (void)opaque, (void)address, (void)items, (void)size; + return MZ_REALLOC(address, items * size); +} + +const char *mz_version(void) { return MZ_VERSION; } + +#ifndef MINIZ_NO_ZLIB_APIS + +int mz_deflateInit(mz_streamp pStream, int level) { + return mz_deflateInit2(pStream, level, MZ_DEFLATED, MZ_DEFAULT_WINDOW_BITS, 9, + MZ_DEFAULT_STRATEGY); +} + +int mz_deflateInit2(mz_streamp pStream, int level, int method, int window_bits, + int mem_level, int strategy) { + tdefl_compressor *pComp; + mz_uint comp_flags = + TDEFL_COMPUTE_ADLER32 | + tdefl_create_comp_flags_from_zip_params(level, window_bits, strategy); + + if (!pStream) + return MZ_STREAM_ERROR; + if ((method != MZ_DEFLATED) || ((mem_level < 1) || (mem_level > 9)) || + ((window_bits != MZ_DEFAULT_WINDOW_BITS) && + (-window_bits != MZ_DEFAULT_WINDOW_BITS))) + return MZ_PARAM_ERROR; + + pStream->data_type = 0; + pStream->adler = MZ_ADLER32_INIT; + pStream->msg = NULL; + pStream->reserved = 0; + pStream->total_in = 0; + pStream->total_out = 0; + if (!pStream->zalloc) + pStream->zalloc = miniz_def_alloc_func; + if (!pStream->zfree) + pStream->zfree = miniz_def_free_func; + + pComp = (tdefl_compressor *)pStream->zalloc(pStream->opaque, 1, + sizeof(tdefl_compressor)); + if (!pComp) + return MZ_MEM_ERROR; + + pStream->state = (struct mz_internal_state *)pComp; + + if (tdefl_init(pComp, NULL, NULL, comp_flags) != TDEFL_STATUS_OKAY) { + mz_deflateEnd(pStream); + return MZ_PARAM_ERROR; + } + + return MZ_OK; +} + +int mz_deflateReset(mz_streamp pStream) { + if ((!pStream) || (!pStream->state) || (!pStream->zalloc) || + (!pStream->zfree)) + return MZ_STREAM_ERROR; + pStream->total_in = pStream->total_out = 0; + tdefl_init((tdefl_compressor *)pStream->state, NULL, NULL, + ((tdefl_compressor *)pStream->state)->m_flags); + return MZ_OK; +} + +int mz_deflate(mz_streamp pStream, int flush) { + size_t in_bytes, out_bytes; + mz_ulong orig_total_in, orig_total_out; + int mz_status = MZ_OK; + + if ((!pStream) || (!pStream->state) || (flush < 0) || (flush > MZ_FINISH) || + (!pStream->next_out)) + return MZ_STREAM_ERROR; + if (!pStream->avail_out) + return MZ_BUF_ERROR; + + if (flush == MZ_PARTIAL_FLUSH) + flush = MZ_SYNC_FLUSH; + + if (((tdefl_compressor *)pStream->state)->m_prev_return_status == + TDEFL_STATUS_DONE) + return (flush == MZ_FINISH) ? MZ_STREAM_END : MZ_BUF_ERROR; + + orig_total_in = pStream->total_in; + orig_total_out = pStream->total_out; + for (;;) { + tdefl_status defl_status; + in_bytes = pStream->avail_in; + out_bytes = pStream->avail_out; + + defl_status = tdefl_compress((tdefl_compressor *)pStream->state, + pStream->next_in, &in_bytes, pStream->next_out, + &out_bytes, (tdefl_flush)flush); + pStream->next_in += (mz_uint)in_bytes; + pStream->avail_in -= (mz_uint)in_bytes; + pStream->total_in += (mz_uint)in_bytes; + pStream->adler = tdefl_get_adler32((tdefl_compressor *)pStream->state); + + pStream->next_out += (mz_uint)out_bytes; + pStream->avail_out -= (mz_uint)out_bytes; + pStream->total_out += (mz_uint)out_bytes; + + if (defl_status < 0) { + mz_status = MZ_STREAM_ERROR; + break; + } else if (defl_status == TDEFL_STATUS_DONE) { + mz_status = MZ_STREAM_END; + break; + } else if (!pStream->avail_out) + break; + else if ((!pStream->avail_in) && (flush != MZ_FINISH)) { + if ((flush) || (pStream->total_in != orig_total_in) || + (pStream->total_out != orig_total_out)) + break; + return MZ_BUF_ERROR; /* Can't make forward progress without some input. + */ + } + } + return mz_status; +} + +int mz_deflateEnd(mz_streamp pStream) { + if (!pStream) + return MZ_STREAM_ERROR; + if (pStream->state) { + pStream->zfree(pStream->opaque, pStream->state); + pStream->state = NULL; + } + return MZ_OK; +} + +mz_ulong mz_deflateBound(mz_streamp pStream, mz_ulong source_len) { + (void)pStream; + /* This is really over conservative. (And lame, but it's actually pretty + * tricky to compute a true upper bound given the way tdefl's blocking works.) + */ + return MZ_MAX(128 + (source_len * 110) / 100, + 128 + source_len + ((source_len / (31 * 1024)) + 1) * 5); +} + +int mz_compress2(unsigned char *pDest, mz_ulong *pDest_len, + const unsigned char *pSource, mz_ulong source_len, int level) { + int status; + mz_stream stream; + memset(&stream, 0, sizeof(stream)); + + /* In case mz_ulong is 64-bits (argh I hate longs). */ + if ((source_len | *pDest_len) > 0xFFFFFFFFU) + return MZ_PARAM_ERROR; + + stream.next_in = pSource; + stream.avail_in = (mz_uint32)source_len; + stream.next_out = pDest; + stream.avail_out = (mz_uint32)*pDest_len; + + status = mz_deflateInit(&stream, level); + if (status != MZ_OK) + return status; + + status = mz_deflate(&stream, MZ_FINISH); + if (status != MZ_STREAM_END) { + mz_deflateEnd(&stream); + return (status == MZ_OK) ? MZ_BUF_ERROR : status; + } + + *pDest_len = stream.total_out; + return mz_deflateEnd(&stream); +} + +int mz_compress(unsigned char *pDest, mz_ulong *pDest_len, + const unsigned char *pSource, mz_ulong source_len) { + return mz_compress2(pDest, pDest_len, pSource, source_len, + MZ_DEFAULT_COMPRESSION); +} + +mz_ulong mz_compressBound(mz_ulong source_len) { + return mz_deflateBound(NULL, source_len); +} + +typedef struct { + tinfl_decompressor m_decomp; + mz_uint m_dict_ofs, m_dict_avail, m_first_call, m_has_flushed; + int m_window_bits; + mz_uint8 m_dict[TINFL_LZ_DICT_SIZE]; + tinfl_status m_last_status; +} inflate_state; + +int mz_inflateInit2(mz_streamp pStream, int window_bits) { + inflate_state *pDecomp; + if (!pStream) + return MZ_STREAM_ERROR; + if ((window_bits != MZ_DEFAULT_WINDOW_BITS) && + (-window_bits != MZ_DEFAULT_WINDOW_BITS)) + return MZ_PARAM_ERROR; + + pStream->data_type = 0; + pStream->adler = 0; + pStream->msg = NULL; + pStream->total_in = 0; + pStream->total_out = 0; + pStream->reserved = 0; + if (!pStream->zalloc) + pStream->zalloc = miniz_def_alloc_func; + if (!pStream->zfree) + pStream->zfree = miniz_def_free_func; + + pDecomp = (inflate_state *)pStream->zalloc(pStream->opaque, 1, + sizeof(inflate_state)); + if (!pDecomp) + return MZ_MEM_ERROR; + + pStream->state = (struct mz_internal_state *)pDecomp; + + tinfl_init(&pDecomp->m_decomp); + pDecomp->m_dict_ofs = 0; + pDecomp->m_dict_avail = 0; + pDecomp->m_last_status = TINFL_STATUS_NEEDS_MORE_INPUT; + pDecomp->m_first_call = 1; + pDecomp->m_has_flushed = 0; + pDecomp->m_window_bits = window_bits; + + return MZ_OK; +} + +int mz_inflateInit(mz_streamp pStream) { + return mz_inflateInit2(pStream, MZ_DEFAULT_WINDOW_BITS); +} + +int mz_inflateReset(mz_streamp pStream) { + inflate_state *pDecomp; + if (!pStream) + return MZ_STREAM_ERROR; + + pStream->data_type = 0; + pStream->adler = 0; + pStream->msg = NULL; + pStream->total_in = 0; + pStream->total_out = 0; + pStream->reserved = 0; + + pDecomp = (inflate_state *)pStream->state; + + tinfl_init(&pDecomp->m_decomp); + pDecomp->m_dict_ofs = 0; + pDecomp->m_dict_avail = 0; + pDecomp->m_last_status = TINFL_STATUS_NEEDS_MORE_INPUT; + pDecomp->m_first_call = 1; + pDecomp->m_has_flushed = 0; + /* pDecomp->m_window_bits = window_bits */; + + return MZ_OK; +} + +int mz_inflate(mz_streamp pStream, int flush) { + inflate_state *pState; + mz_uint n, first_call, decomp_flags = TINFL_FLAG_COMPUTE_ADLER32; + size_t in_bytes, out_bytes, orig_avail_in; + tinfl_status status; + + if ((!pStream) || (!pStream->state)) + return MZ_STREAM_ERROR; + if (flush == MZ_PARTIAL_FLUSH) + flush = MZ_SYNC_FLUSH; + if ((flush) && (flush != MZ_SYNC_FLUSH) && (flush != MZ_FINISH)) + return MZ_STREAM_ERROR; + + pState = (inflate_state *)pStream->state; + if (pState->m_window_bits > 0) + decomp_flags |= TINFL_FLAG_PARSE_ZLIB_HEADER; + orig_avail_in = pStream->avail_in; + + first_call = pState->m_first_call; + pState->m_first_call = 0; + if (pState->m_last_status < 0) + return MZ_DATA_ERROR; + + if (pState->m_has_flushed && (flush != MZ_FINISH)) + return MZ_STREAM_ERROR; + pState->m_has_flushed |= (flush == MZ_FINISH); + + if ((flush == MZ_FINISH) && (first_call)) { + /* MZ_FINISH on the first call implies that the input and output buffers are + * large enough to hold the entire compressed/decompressed file. */ + decomp_flags |= TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF; + in_bytes = pStream->avail_in; + out_bytes = pStream->avail_out; + status = tinfl_decompress(&pState->m_decomp, pStream->next_in, &in_bytes, + pStream->next_out, pStream->next_out, &out_bytes, + decomp_flags); + pState->m_last_status = status; + pStream->next_in += (mz_uint)in_bytes; + pStream->avail_in -= (mz_uint)in_bytes; + pStream->total_in += (mz_uint)in_bytes; + pStream->adler = tinfl_get_adler32(&pState->m_decomp); + pStream->next_out += (mz_uint)out_bytes; + pStream->avail_out -= (mz_uint)out_bytes; + pStream->total_out += (mz_uint)out_bytes; + + if (status < 0) + return MZ_DATA_ERROR; + else if (status != TINFL_STATUS_DONE) { + pState->m_last_status = TINFL_STATUS_FAILED; + return MZ_BUF_ERROR; + } + return MZ_STREAM_END; + } + /* flush != MZ_FINISH then we must assume there's more input. */ + if (flush != MZ_FINISH) + decomp_flags |= TINFL_FLAG_HAS_MORE_INPUT; + + if (pState->m_dict_avail) { + n = MZ_MIN(pState->m_dict_avail, pStream->avail_out); + memcpy(pStream->next_out, pState->m_dict + pState->m_dict_ofs, n); + pStream->next_out += n; + pStream->avail_out -= n; + pStream->total_out += n; + pState->m_dict_avail -= n; + pState->m_dict_ofs = (pState->m_dict_ofs + n) & (TINFL_LZ_DICT_SIZE - 1); + return ((pState->m_last_status == TINFL_STATUS_DONE) && + (!pState->m_dict_avail)) + ? MZ_STREAM_END + : MZ_OK; + } + + for (;;) { + in_bytes = pStream->avail_in; + out_bytes = TINFL_LZ_DICT_SIZE - pState->m_dict_ofs; + + status = tinfl_decompress( + &pState->m_decomp, pStream->next_in, &in_bytes, pState->m_dict, + pState->m_dict + pState->m_dict_ofs, &out_bytes, decomp_flags); + pState->m_last_status = status; + + pStream->next_in += (mz_uint)in_bytes; + pStream->avail_in -= (mz_uint)in_bytes; + pStream->total_in += (mz_uint)in_bytes; + pStream->adler = tinfl_get_adler32(&pState->m_decomp); + + pState->m_dict_avail = (mz_uint)out_bytes; + + n = MZ_MIN(pState->m_dict_avail, pStream->avail_out); + memcpy(pStream->next_out, pState->m_dict + pState->m_dict_ofs, n); + pStream->next_out += n; + pStream->avail_out -= n; + pStream->total_out += n; + pState->m_dict_avail -= n; + pState->m_dict_ofs = (pState->m_dict_ofs + n) & (TINFL_LZ_DICT_SIZE - 1); + + if (status < 0) + return MZ_DATA_ERROR; /* Stream is corrupted (there could be some + uncompressed data left in the output dictionary - + oh well). */ + else if ((status == TINFL_STATUS_NEEDS_MORE_INPUT) && (!orig_avail_in)) + return MZ_BUF_ERROR; /* Signal caller that we can't make forward progress + without supplying more input or by setting flush + to MZ_FINISH. */ + else if (flush == MZ_FINISH) { + /* The output buffer MUST be large to hold the remaining uncompressed data + * when flush==MZ_FINISH. */ + if (status == TINFL_STATUS_DONE) + return pState->m_dict_avail ? MZ_BUF_ERROR : MZ_STREAM_END; + /* status here must be TINFL_STATUS_HAS_MORE_OUTPUT, which means there's + * at least 1 more byte on the way. If there's no more room left in the + * output buffer then something is wrong. */ + else if (!pStream->avail_out) + return MZ_BUF_ERROR; + } else if ((status == TINFL_STATUS_DONE) || (!pStream->avail_in) || + (!pStream->avail_out) || (pState->m_dict_avail)) + break; + } + + return ((status == TINFL_STATUS_DONE) && (!pState->m_dict_avail)) + ? MZ_STREAM_END + : MZ_OK; +} + +int mz_inflateEnd(mz_streamp pStream) { + if (!pStream) + return MZ_STREAM_ERROR; + if (pStream->state) { + pStream->zfree(pStream->opaque, pStream->state); + pStream->state = NULL; + } + return MZ_OK; +} +int mz_uncompress2(unsigned char *pDest, mz_ulong *pDest_len, + const unsigned char *pSource, mz_ulong *pSource_len) { + mz_stream stream; + int status; + memset(&stream, 0, sizeof(stream)); + + /* In case mz_ulong is 64-bits (argh I hate longs). */ + if ((*pSource_len | *pDest_len) > 0xFFFFFFFFU) + return MZ_PARAM_ERROR; + + stream.next_in = pSource; + stream.avail_in = (mz_uint32)*pSource_len; + stream.next_out = pDest; + stream.avail_out = (mz_uint32)*pDest_len; + + status = mz_inflateInit(&stream); + if (status != MZ_OK) + return status; + + status = mz_inflate(&stream, MZ_FINISH); + *pSource_len = *pSource_len - stream.avail_in; + if (status != MZ_STREAM_END) { + mz_inflateEnd(&stream); + return ((status == MZ_BUF_ERROR) && (!stream.avail_in)) ? MZ_DATA_ERROR + : status; + } + *pDest_len = stream.total_out; + + return mz_inflateEnd(&stream); +} + +int mz_uncompress(unsigned char *pDest, mz_ulong *pDest_len, + const unsigned char *pSource, mz_ulong source_len) { + return mz_uncompress2(pDest, pDest_len, pSource, &source_len); +} + +const char *mz_error(int err) { + static struct { + int m_err; + const char *m_pDesc; + } s_error_descs[] = {{MZ_OK, ""}, + {MZ_STREAM_END, "stream end"}, + {MZ_NEED_DICT, "need dictionary"}, + {MZ_ERRNO, "file error"}, + {MZ_STREAM_ERROR, "stream error"}, + {MZ_DATA_ERROR, "data error"}, + {MZ_MEM_ERROR, "out of memory"}, + {MZ_BUF_ERROR, "buf error"}, + {MZ_VERSION_ERROR, "version error"}, + {MZ_PARAM_ERROR, "parameter error"}}; + mz_uint i; + for (i = 0; i < sizeof(s_error_descs) / sizeof(s_error_descs[0]); ++i) + if (s_error_descs[i].m_err == err) + return s_error_descs[i].m_pDesc; + return NULL; +} + +#endif /*MINIZ_NO_ZLIB_APIS */ + +#ifdef __cplusplus +} +#endif + +/* + This is free and unencumbered software released into the public domain. + + Anyone is free to copy, modify, publish, use, compile, sell, or + distribute this software, either in source code form or as a compiled + binary, for any purpose, commercial or non-commercial, and by any + means. + + In jurisdictions that recognize copyright laws, the author or authors + of this software dedicate any and all copyright interest in the + software to the public domain. We make this dedication for the benefit + of the public at large and to the detriment of our heirs and + successors. We intend this dedication to be an overt act of + relinquishment in perpetuity of all present and future rights to this + software under copyright law. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR + OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + OTHER DEALINGS IN THE SOFTWARE. + + For more information, please refer to +*/ +/************************************************************************** + * + * Copyright 2013-2014 RAD Game Tools and Valve Software + * Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + +#ifdef __cplusplus +extern "C" { +#endif + +/* ------------------- Low-level Compression (independent from all decompression + * API's) */ + +/* Purposely making these tables static for faster init and thread safety. */ +static const mz_uint16 s_tdefl_len_sym[256] = { + 257, 258, 259, 260, 261, 262, 263, 264, 265, 265, 266, 266, 267, 267, 268, + 268, 269, 269, 269, 269, 270, 270, 270, 270, 271, 271, 271, 271, 272, 272, + 272, 272, 273, 273, 273, 273, 273, 273, 273, 273, 274, 274, 274, 274, 274, + 274, 274, 274, 275, 275, 275, 275, 275, 275, 275, 275, 276, 276, 276, 276, + 276, 276, 276, 276, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, 277, + 277, 277, 277, 277, 277, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, + 278, 278, 278, 278, 278, 278, 279, 279, 279, 279, 279, 279, 279, 279, 279, + 279, 279, 279, 279, 279, 279, 279, 280, 280, 280, 280, 280, 280, 280, 280, + 280, 280, 280, 280, 280, 280, 280, 280, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, 283, 283, 283, + 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, + 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 283, 284, + 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, + 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, 284, + 285}; + +static const mz_uint8 s_tdefl_len_extra[256] = { + 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 0}; + +static const mz_uint8 s_tdefl_small_dist_sym[512] = { + 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, + 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, + 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, + 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, + 12, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, + 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, + 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, + 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, + 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, + 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, + 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, + 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, + 15, 15, 15, 15, 15, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, + 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, + 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, + 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, + 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, + 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, + 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17}; + +static const mz_uint8 s_tdefl_small_dist_extra[512] = { + 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, + 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7}; + +static const mz_uint8 s_tdefl_large_dist_sym[128] = { + 0, 0, 18, 19, 20, 20, 21, 21, 22, 22, 22, 22, 23, 23, 23, 23, 24, 24, 24, + 24, 24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, + 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, + 27, 27, 27, 27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, + 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, + 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29}; + +static const mz_uint8 s_tdefl_large_dist_extra[128] = { + 0, 0, 8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, + 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, + 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, + 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, + 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, + 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, + 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13}; + +/* Radix sorts tdefl_sym_freq[] array by 16-bit key m_key. Returns ptr to sorted + * values. */ +typedef struct { + mz_uint16 m_key, m_sym_index; +} tdefl_sym_freq; +static tdefl_sym_freq *tdefl_radix_sort_syms(mz_uint num_syms, + tdefl_sym_freq *pSyms0, + tdefl_sym_freq *pSyms1) { + mz_uint32 total_passes = 2, pass_shift, pass, i, hist[256 * 2]; + tdefl_sym_freq *pCur_syms = pSyms0, *pNew_syms = pSyms1; + MZ_CLEAR_OBJ(hist); + for (i = 0; i < num_syms; i++) { + mz_uint freq = pSyms0[i].m_key; + hist[freq & 0xFF]++; + hist[256 + ((freq >> 8) & 0xFF)]++; + } + while ((total_passes > 1) && (num_syms == hist[(total_passes - 1) * 256])) + total_passes--; + for (pass_shift = 0, pass = 0; pass < total_passes; pass++, pass_shift += 8) { + const mz_uint32 *pHist = &hist[pass << 8]; + mz_uint offsets[256], cur_ofs = 0; + for (i = 0; i < 256; i++) { + offsets[i] = cur_ofs; + cur_ofs += pHist[i]; + } + for (i = 0; i < num_syms; i++) + pNew_syms[offsets[(pCur_syms[i].m_key >> pass_shift) & 0xFF]++] = + pCur_syms[i]; + { + tdefl_sym_freq *t = pCur_syms; + pCur_syms = pNew_syms; + pNew_syms = t; + } + } + return pCur_syms; +} + +/* tdefl_calculate_minimum_redundancy() originally written by: Alistair Moffat, + * alistair@cs.mu.oz.au, Jyrki Katajainen, jyrki@diku.dk, November 1996. */ +static void tdefl_calculate_minimum_redundancy(tdefl_sym_freq *A, int n) { + int root, leaf, next, avbl, used, dpth; + if (n == 0) + return; + else if (n == 1) { + A[0].m_key = 1; + return; + } + A[0].m_key += A[1].m_key; + root = 0; + leaf = 2; + for (next = 1; next < n - 1; next++) { + if (leaf >= n || A[root].m_key < A[leaf].m_key) { + A[next].m_key = A[root].m_key; + A[root++].m_key = (mz_uint16)next; + } else + A[next].m_key = A[leaf++].m_key; + if (leaf >= n || (root < next && A[root].m_key < A[leaf].m_key)) { + A[next].m_key = (mz_uint16)(A[next].m_key + A[root].m_key); + A[root++].m_key = (mz_uint16)next; + } else + A[next].m_key = (mz_uint16)(A[next].m_key + A[leaf++].m_key); + } + A[n - 2].m_key = 0; + for (next = n - 3; next >= 0; next--) + A[next].m_key = A[A[next].m_key].m_key + 1; + avbl = 1; + used = dpth = 0; + root = n - 2; + next = n - 1; + while (avbl > 0) { + while (root >= 0 && (int)A[root].m_key == dpth) { + used++; + root--; + } + while (avbl > used) { + A[next--].m_key = (mz_uint16)(dpth); + avbl--; + } + avbl = 2 * used; + dpth++; + used = 0; + } +} + +/* Limits canonical Huffman code table's max code size. */ +enum { TDEFL_MAX_SUPPORTED_HUFF_CODESIZE = 32 }; +static void tdefl_huffman_enforce_max_code_size(int *pNum_codes, + int code_list_len, + int max_code_size) { + int i; + mz_uint32 total = 0; + if (code_list_len <= 1) + return; + for (i = max_code_size + 1; i <= TDEFL_MAX_SUPPORTED_HUFF_CODESIZE; i++) + pNum_codes[max_code_size] += pNum_codes[i]; + for (i = max_code_size; i > 0; i--) + total += (((mz_uint32)pNum_codes[i]) << (max_code_size - i)); + while (total != (1UL << max_code_size)) { + pNum_codes[max_code_size]--; + for (i = max_code_size - 1; i > 0; i--) + if (pNum_codes[i]) { + pNum_codes[i]--; + pNum_codes[i + 1] += 2; + break; + } + total--; + } +} + +static void tdefl_optimize_huffman_table(tdefl_compressor *d, int table_num, + int table_len, int code_size_limit, + int static_table) { + int i, j, l, num_codes[1 + TDEFL_MAX_SUPPORTED_HUFF_CODESIZE]; + mz_uint next_code[TDEFL_MAX_SUPPORTED_HUFF_CODESIZE + 1]; + MZ_CLEAR_OBJ(num_codes); + if (static_table) { + for (i = 0; i < table_len; i++) + num_codes[d->m_huff_code_sizes[table_num][i]]++; + } else { + tdefl_sym_freq syms0[TDEFL_MAX_HUFF_SYMBOLS], syms1[TDEFL_MAX_HUFF_SYMBOLS], + *pSyms; + int num_used_syms = 0; + const mz_uint16 *pSym_count = &d->m_huff_count[table_num][0]; + for (i = 0; i < table_len; i++) + if (pSym_count[i]) { + syms0[num_used_syms].m_key = (mz_uint16)pSym_count[i]; + syms0[num_used_syms++].m_sym_index = (mz_uint16)i; + } + + pSyms = tdefl_radix_sort_syms(num_used_syms, syms0, syms1); + tdefl_calculate_minimum_redundancy(pSyms, num_used_syms); + + for (i = 0; i < num_used_syms; i++) + num_codes[pSyms[i].m_key]++; + + tdefl_huffman_enforce_max_code_size(num_codes, num_used_syms, + code_size_limit); + + MZ_CLEAR_OBJ(d->m_huff_code_sizes[table_num]); + MZ_CLEAR_OBJ(d->m_huff_codes[table_num]); + for (i = 1, j = num_used_syms; i <= code_size_limit; i++) + for (l = num_codes[i]; l > 0; l--) + d->m_huff_code_sizes[table_num][pSyms[--j].m_sym_index] = (mz_uint8)(i); + } + + next_code[1] = 0; + for (j = 0, i = 2; i <= code_size_limit; i++) + next_code[i] = j = ((j + num_codes[i - 1]) << 1); + + for (i = 0; i < table_len; i++) { + mz_uint rev_code = 0, code, code_size; + if ((code_size = d->m_huff_code_sizes[table_num][i]) == 0) + continue; + code = next_code[code_size]++; + for (l = code_size; l > 0; l--, code >>= 1) + rev_code = (rev_code << 1) | (code & 1); + d->m_huff_codes[table_num][i] = (mz_uint16)rev_code; + } +} + +#define TDEFL_PUT_BITS(b, l) \ + do { \ + mz_uint bits = b; \ + mz_uint len = l; \ + MZ_ASSERT(bits <= ((1U << len) - 1U)); \ + d->m_bit_buffer |= (bits << d->m_bits_in); \ + d->m_bits_in += len; \ + while (d->m_bits_in >= 8) { \ + if (d->m_pOutput_buf < d->m_pOutput_buf_end) \ + *d->m_pOutput_buf++ = (mz_uint8)(d->m_bit_buffer); \ + d->m_bit_buffer >>= 8; \ + d->m_bits_in -= 8; \ + } \ + } \ + MZ_MACRO_END + +#define TDEFL_RLE_PREV_CODE_SIZE() \ + { \ + if (rle_repeat_count) { \ + if (rle_repeat_count < 3) { \ + d->m_huff_count[2][prev_code_size] = \ + (mz_uint16)(d->m_huff_count[2][prev_code_size] + \ + rle_repeat_count); \ + while (rle_repeat_count--) \ + packed_code_sizes[num_packed_code_sizes++] = prev_code_size; \ + } else { \ + d->m_huff_count[2][16] = (mz_uint16)(d->m_huff_count[2][16] + 1); \ + packed_code_sizes[num_packed_code_sizes++] = 16; \ + packed_code_sizes[num_packed_code_sizes++] = \ + (mz_uint8)(rle_repeat_count - 3); \ + } \ + rle_repeat_count = 0; \ + } \ + } + +#define TDEFL_RLE_ZERO_CODE_SIZE() \ + { \ + if (rle_z_count) { \ + if (rle_z_count < 3) { \ + d->m_huff_count[2][0] = \ + (mz_uint16)(d->m_huff_count[2][0] + rle_z_count); \ + while (rle_z_count--) \ + packed_code_sizes[num_packed_code_sizes++] = 0; \ + } else if (rle_z_count <= 10) { \ + d->m_huff_count[2][17] = (mz_uint16)(d->m_huff_count[2][17] + 1); \ + packed_code_sizes[num_packed_code_sizes++] = 17; \ + packed_code_sizes[num_packed_code_sizes++] = \ + (mz_uint8)(rle_z_count - 3); \ + } else { \ + d->m_huff_count[2][18] = (mz_uint16)(d->m_huff_count[2][18] + 1); \ + packed_code_sizes[num_packed_code_sizes++] = 18; \ + packed_code_sizes[num_packed_code_sizes++] = \ + (mz_uint8)(rle_z_count - 11); \ + } \ + rle_z_count = 0; \ + } \ + } + +static mz_uint8 s_tdefl_packed_code_size_syms_swizzle[] = { + 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; + +static void tdefl_start_dynamic_block(tdefl_compressor *d) { + int num_lit_codes, num_dist_codes, num_bit_lengths; + mz_uint i, total_code_sizes_to_pack, num_packed_code_sizes, rle_z_count, + rle_repeat_count, packed_code_sizes_index; + mz_uint8 + code_sizes_to_pack[TDEFL_MAX_HUFF_SYMBOLS_0 + TDEFL_MAX_HUFF_SYMBOLS_1], + packed_code_sizes[TDEFL_MAX_HUFF_SYMBOLS_0 + TDEFL_MAX_HUFF_SYMBOLS_1], + prev_code_size = 0xFF; + + d->m_huff_count[0][256] = 1; + + tdefl_optimize_huffman_table(d, 0, TDEFL_MAX_HUFF_SYMBOLS_0, 15, MZ_FALSE); + tdefl_optimize_huffman_table(d, 1, TDEFL_MAX_HUFF_SYMBOLS_1, 15, MZ_FALSE); + + for (num_lit_codes = 286; num_lit_codes > 257; num_lit_codes--) + if (d->m_huff_code_sizes[0][num_lit_codes - 1]) + break; + for (num_dist_codes = 30; num_dist_codes > 1; num_dist_codes--) + if (d->m_huff_code_sizes[1][num_dist_codes - 1]) + break; + + memcpy(code_sizes_to_pack, &d->m_huff_code_sizes[0][0], num_lit_codes); + memcpy(code_sizes_to_pack + num_lit_codes, &d->m_huff_code_sizes[1][0], + num_dist_codes); + total_code_sizes_to_pack = num_lit_codes + num_dist_codes; + num_packed_code_sizes = 0; + rle_z_count = 0; + rle_repeat_count = 0; + + memset(&d->m_huff_count[2][0], 0, + sizeof(d->m_huff_count[2][0]) * TDEFL_MAX_HUFF_SYMBOLS_2); + for (i = 0; i < total_code_sizes_to_pack; i++) { + mz_uint8 code_size = code_sizes_to_pack[i]; + if (!code_size) { + TDEFL_RLE_PREV_CODE_SIZE(); + if (++rle_z_count == 138) { + TDEFL_RLE_ZERO_CODE_SIZE(); + } + } else { + TDEFL_RLE_ZERO_CODE_SIZE(); + if (code_size != prev_code_size) { + TDEFL_RLE_PREV_CODE_SIZE(); + d->m_huff_count[2][code_size] = + (mz_uint16)(d->m_huff_count[2][code_size] + 1); + packed_code_sizes[num_packed_code_sizes++] = code_size; + } else if (++rle_repeat_count == 6) { + TDEFL_RLE_PREV_CODE_SIZE(); + } + } + prev_code_size = code_size; + } + if (rle_repeat_count) { + TDEFL_RLE_PREV_CODE_SIZE(); + } else { + TDEFL_RLE_ZERO_CODE_SIZE(); + } + + tdefl_optimize_huffman_table(d, 2, TDEFL_MAX_HUFF_SYMBOLS_2, 7, MZ_FALSE); + + TDEFL_PUT_BITS(2, 2); + + TDEFL_PUT_BITS(num_lit_codes - 257, 5); + TDEFL_PUT_BITS(num_dist_codes - 1, 5); + + for (num_bit_lengths = 18; num_bit_lengths >= 0; num_bit_lengths--) + if (d->m_huff_code_sizes + [2][s_tdefl_packed_code_size_syms_swizzle[num_bit_lengths]]) + break; + num_bit_lengths = MZ_MAX(4, (num_bit_lengths + 1)); + TDEFL_PUT_BITS(num_bit_lengths - 4, 4); + for (i = 0; (int)i < num_bit_lengths; i++) + TDEFL_PUT_BITS( + d->m_huff_code_sizes[2][s_tdefl_packed_code_size_syms_swizzle[i]], 3); + + for (packed_code_sizes_index = 0; + packed_code_sizes_index < num_packed_code_sizes;) { + mz_uint code = packed_code_sizes[packed_code_sizes_index++]; + MZ_ASSERT(code < TDEFL_MAX_HUFF_SYMBOLS_2); + TDEFL_PUT_BITS(d->m_huff_codes[2][code], d->m_huff_code_sizes[2][code]); + if (code >= 16) + TDEFL_PUT_BITS(packed_code_sizes[packed_code_sizes_index++], + "\02\03\07"[code - 16]); + } +} + +static void tdefl_start_static_block(tdefl_compressor *d) { + mz_uint i; + mz_uint8 *p = &d->m_huff_code_sizes[0][0]; + + for (i = 0; i <= 143; ++i) + *p++ = 8; + for (; i <= 255; ++i) + *p++ = 9; + for (; i <= 279; ++i) + *p++ = 7; + for (; i <= 287; ++i) + *p++ = 8; + + memset(d->m_huff_code_sizes[1], 5, 32); + + tdefl_optimize_huffman_table(d, 0, 288, 15, MZ_TRUE); + tdefl_optimize_huffman_table(d, 1, 32, 15, MZ_TRUE); + + TDEFL_PUT_BITS(1, 2); +} + +static const mz_uint mz_bitmasks[17] = { + 0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF, + 0x01FF, 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF}; + +#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN && \ + MINIZ_HAS_64BIT_REGISTERS +static mz_bool tdefl_compress_lz_codes(tdefl_compressor *d) { + mz_uint flags; + mz_uint8 *pLZ_codes; + mz_uint8 *pOutput_buf = d->m_pOutput_buf; + mz_uint8 *pLZ_code_buf_end = d->m_pLZ_code_buf; + mz_uint64 bit_buffer = d->m_bit_buffer; + mz_uint bits_in = d->m_bits_in; + +#define TDEFL_PUT_BITS_FAST(b, l) \ + { \ + bit_buffer |= (((mz_uint64)(b)) << bits_in); \ + bits_in += (l); \ + } + + flags = 1; + for (pLZ_codes = d->m_lz_code_buf; pLZ_codes < pLZ_code_buf_end; + flags >>= 1) { + if (flags == 1) + flags = *pLZ_codes++ | 0x100; + + if (flags & 1) { + mz_uint s0, s1, n0, n1, sym, num_extra_bits; + mz_uint match_len = pLZ_codes[0], + match_dist = *(const mz_uint16 *)(pLZ_codes + 1); + pLZ_codes += 3; + + MZ_ASSERT(d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]); + TDEFL_PUT_BITS_FAST(d->m_huff_codes[0][s_tdefl_len_sym[match_len]], + d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]); + TDEFL_PUT_BITS_FAST(match_len & mz_bitmasks[s_tdefl_len_extra[match_len]], + s_tdefl_len_extra[match_len]); + + /* This sequence coaxes MSVC into using cmov's vs. jmp's. */ + s0 = s_tdefl_small_dist_sym[match_dist & 511]; + n0 = s_tdefl_small_dist_extra[match_dist & 511]; + s1 = s_tdefl_large_dist_sym[match_dist >> 8]; + n1 = s_tdefl_large_dist_extra[match_dist >> 8]; + sym = (match_dist < 512) ? s0 : s1; + num_extra_bits = (match_dist < 512) ? n0 : n1; + + MZ_ASSERT(d->m_huff_code_sizes[1][sym]); + TDEFL_PUT_BITS_FAST(d->m_huff_codes[1][sym], + d->m_huff_code_sizes[1][sym]); + TDEFL_PUT_BITS_FAST(match_dist & mz_bitmasks[num_extra_bits], + num_extra_bits); + } else { + mz_uint lit = *pLZ_codes++; + MZ_ASSERT(d->m_huff_code_sizes[0][lit]); + TDEFL_PUT_BITS_FAST(d->m_huff_codes[0][lit], + d->m_huff_code_sizes[0][lit]); + + if (((flags & 2) == 0) && (pLZ_codes < pLZ_code_buf_end)) { + flags >>= 1; + lit = *pLZ_codes++; + MZ_ASSERT(d->m_huff_code_sizes[0][lit]); + TDEFL_PUT_BITS_FAST(d->m_huff_codes[0][lit], + d->m_huff_code_sizes[0][lit]); + + if (((flags & 2) == 0) && (pLZ_codes < pLZ_code_buf_end)) { + flags >>= 1; + lit = *pLZ_codes++; + MZ_ASSERT(d->m_huff_code_sizes[0][lit]); + TDEFL_PUT_BITS_FAST(d->m_huff_codes[0][lit], + d->m_huff_code_sizes[0][lit]); + } + } + } + + if (pOutput_buf >= d->m_pOutput_buf_end) + return MZ_FALSE; + + *(mz_uint64 *)pOutput_buf = bit_buffer; + pOutput_buf += (bits_in >> 3); + bit_buffer >>= (bits_in & ~7); + bits_in &= 7; + } + +#undef TDEFL_PUT_BITS_FAST + + d->m_pOutput_buf = pOutput_buf; + d->m_bits_in = 0; + d->m_bit_buffer = 0; + + while (bits_in) { + mz_uint32 n = MZ_MIN(bits_in, 16); + TDEFL_PUT_BITS((mz_uint)bit_buffer & mz_bitmasks[n], n); + bit_buffer >>= n; + bits_in -= n; + } + + TDEFL_PUT_BITS(d->m_huff_codes[0][256], d->m_huff_code_sizes[0][256]); + + return (d->m_pOutput_buf < d->m_pOutput_buf_end); +} +#else +static mz_bool tdefl_compress_lz_codes(tdefl_compressor *d) { + mz_uint flags; + mz_uint8 *pLZ_codes; + + flags = 1; + for (pLZ_codes = d->m_lz_code_buf; pLZ_codes < d->m_pLZ_code_buf; + flags >>= 1) { + if (flags == 1) + flags = *pLZ_codes++ | 0x100; + if (flags & 1) { + mz_uint sym, num_extra_bits; + mz_uint match_len = pLZ_codes[0], + match_dist = (pLZ_codes[1] | (pLZ_codes[2] << 8)); + pLZ_codes += 3; + + MZ_ASSERT(d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]); + TDEFL_PUT_BITS(d->m_huff_codes[0][s_tdefl_len_sym[match_len]], + d->m_huff_code_sizes[0][s_tdefl_len_sym[match_len]]); + TDEFL_PUT_BITS(match_len & mz_bitmasks[s_tdefl_len_extra[match_len]], + s_tdefl_len_extra[match_len]); + + if (match_dist < 512) { + sym = s_tdefl_small_dist_sym[match_dist]; + num_extra_bits = s_tdefl_small_dist_extra[match_dist]; + } else { + sym = s_tdefl_large_dist_sym[match_dist >> 8]; + num_extra_bits = s_tdefl_large_dist_extra[match_dist >> 8]; + } + MZ_ASSERT(d->m_huff_code_sizes[1][sym]); + TDEFL_PUT_BITS(d->m_huff_codes[1][sym], d->m_huff_code_sizes[1][sym]); + TDEFL_PUT_BITS(match_dist & mz_bitmasks[num_extra_bits], num_extra_bits); + } else { + mz_uint lit = *pLZ_codes++; + MZ_ASSERT(d->m_huff_code_sizes[0][lit]); + TDEFL_PUT_BITS(d->m_huff_codes[0][lit], d->m_huff_code_sizes[0][lit]); + } + } + + TDEFL_PUT_BITS(d->m_huff_codes[0][256], d->m_huff_code_sizes[0][256]); + + return (d->m_pOutput_buf < d->m_pOutput_buf_end); +} +#endif /* MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN && \ + MINIZ_HAS_64BIT_REGISTERS */ + +static mz_bool tdefl_compress_block(tdefl_compressor *d, mz_bool static_block) { + if (static_block) + tdefl_start_static_block(d); + else + tdefl_start_dynamic_block(d); + return tdefl_compress_lz_codes(d); +} + +static int tdefl_flush_block(tdefl_compressor *d, int flush) { + mz_uint saved_bit_buf, saved_bits_in; + mz_uint8 *pSaved_output_buf; + mz_bool comp_block_succeeded = MZ_FALSE; + int n, use_raw_block = + ((d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS) != 0) && + (d->m_lookahead_pos - d->m_lz_code_buf_dict_pos) <= d->m_dict_size; + mz_uint8 *pOutput_buf_start = + ((d->m_pPut_buf_func == NULL) && + ((*d->m_pOut_buf_size - d->m_out_buf_ofs) >= TDEFL_OUT_BUF_SIZE)) + ? ((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs) + : d->m_output_buf; + + d->m_pOutput_buf = pOutput_buf_start; + d->m_pOutput_buf_end = d->m_pOutput_buf + TDEFL_OUT_BUF_SIZE - 16; + + MZ_ASSERT(!d->m_output_flush_remaining); + d->m_output_flush_ofs = 0; + d->m_output_flush_remaining = 0; + + *d->m_pLZ_flags = (mz_uint8)(*d->m_pLZ_flags >> d->m_num_flags_left); + d->m_pLZ_code_buf -= (d->m_num_flags_left == 8); + + if ((d->m_flags & TDEFL_WRITE_ZLIB_HEADER) && (!d->m_block_index)) { + TDEFL_PUT_BITS(0x78, 8); + TDEFL_PUT_BITS(0x01, 8); + } + + TDEFL_PUT_BITS(flush == TDEFL_FINISH, 1); + + pSaved_output_buf = d->m_pOutput_buf; + saved_bit_buf = d->m_bit_buffer; + saved_bits_in = d->m_bits_in; + + if (!use_raw_block) + comp_block_succeeded = + tdefl_compress_block(d, (d->m_flags & TDEFL_FORCE_ALL_STATIC_BLOCKS) || + (d->m_total_lz_bytes < 48)); + + /* If the block gets expanded, forget the current contents of the output + * buffer and send a raw block instead. */ + if (((use_raw_block) || + ((d->m_total_lz_bytes) && ((d->m_pOutput_buf - pSaved_output_buf + 1U) >= + d->m_total_lz_bytes))) && + ((d->m_lookahead_pos - d->m_lz_code_buf_dict_pos) <= d->m_dict_size)) { + mz_uint i; + d->m_pOutput_buf = pSaved_output_buf; + d->m_bit_buffer = saved_bit_buf, d->m_bits_in = saved_bits_in; + TDEFL_PUT_BITS(0, 2); + if (d->m_bits_in) { + TDEFL_PUT_BITS(0, 8 - d->m_bits_in); + } + for (i = 2; i; --i, d->m_total_lz_bytes ^= 0xFFFF) { + TDEFL_PUT_BITS(d->m_total_lz_bytes & 0xFFFF, 16); + } + for (i = 0; i < d->m_total_lz_bytes; ++i) { + TDEFL_PUT_BITS( + d->m_dict[(d->m_lz_code_buf_dict_pos + i) & TDEFL_LZ_DICT_SIZE_MASK], + 8); + } + } + /* Check for the extremely unlikely (if not impossible) case of the compressed + block not fitting into the output buffer when using dynamic codes. */ + else if (!comp_block_succeeded) { + d->m_pOutput_buf = pSaved_output_buf; + d->m_bit_buffer = saved_bit_buf, d->m_bits_in = saved_bits_in; + tdefl_compress_block(d, MZ_TRUE); + } + + if (flush) { + if (flush == TDEFL_FINISH) { + if (d->m_bits_in) { + TDEFL_PUT_BITS(0, 8 - d->m_bits_in); + } + if (d->m_flags & TDEFL_WRITE_ZLIB_HEADER) { + mz_uint i, a = d->m_adler32; + for (i = 0; i < 4; i++) { + TDEFL_PUT_BITS((a >> 24) & 0xFF, 8); + a <<= 8; + } + } + } else { + mz_uint i, z = 0; + TDEFL_PUT_BITS(0, 3); + if (d->m_bits_in) { + TDEFL_PUT_BITS(0, 8 - d->m_bits_in); + } + for (i = 2; i; --i, z ^= 0xFFFF) { + TDEFL_PUT_BITS(z & 0xFFFF, 16); + } + } + } + + MZ_ASSERT(d->m_pOutput_buf < d->m_pOutput_buf_end); + + memset(&d->m_huff_count[0][0], 0, + sizeof(d->m_huff_count[0][0]) * TDEFL_MAX_HUFF_SYMBOLS_0); + memset(&d->m_huff_count[1][0], 0, + sizeof(d->m_huff_count[1][0]) * TDEFL_MAX_HUFF_SYMBOLS_1); + + d->m_pLZ_code_buf = d->m_lz_code_buf + 1; + d->m_pLZ_flags = d->m_lz_code_buf; + d->m_num_flags_left = 8; + d->m_lz_code_buf_dict_pos += d->m_total_lz_bytes; + d->m_total_lz_bytes = 0; + d->m_block_index++; + + if ((n = (int)(d->m_pOutput_buf - pOutput_buf_start)) != 0) { + if (d->m_pPut_buf_func) { + *d->m_pIn_buf_size = d->m_pSrc - (const mz_uint8 *)d->m_pIn_buf; + if (!(*d->m_pPut_buf_func)(d->m_output_buf, n, d->m_pPut_buf_user)) + return (d->m_prev_return_status = TDEFL_STATUS_PUT_BUF_FAILED); + } else if (pOutput_buf_start == d->m_output_buf) { + int bytes_to_copy = (int)MZ_MIN( + (size_t)n, (size_t)(*d->m_pOut_buf_size - d->m_out_buf_ofs)); + memcpy((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs, d->m_output_buf, + bytes_to_copy); + d->m_out_buf_ofs += bytes_to_copy; + if ((n -= bytes_to_copy) != 0) { + d->m_output_flush_ofs = bytes_to_copy; + d->m_output_flush_remaining = n; + } + } else { + d->m_out_buf_ofs += n; + } + } + + return d->m_output_flush_remaining; +} + +#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES +#ifdef MINIZ_UNALIGNED_USE_MEMCPY +static mz_uint16 TDEFL_READ_UNALIGNED_WORD(const mz_uint8 *p) { + mz_uint16 ret; + memcpy(&ret, p, sizeof(mz_uint16)); + return ret; +} +static mz_uint16 TDEFL_READ_UNALIGNED_WORD2(const mz_uint16 *p) { + mz_uint16 ret; + memcpy(&ret, p, sizeof(mz_uint16)); + return ret; +} +#else +#define TDEFL_READ_UNALIGNED_WORD(p) *(const mz_uint16 *)(p) +#define TDEFL_READ_UNALIGNED_WORD2(p) *(const mz_uint16 *)(p) +#endif +static MZ_FORCEINLINE void +tdefl_find_match(tdefl_compressor *d, mz_uint lookahead_pos, mz_uint max_dist, + mz_uint max_match_len, mz_uint *pMatch_dist, + mz_uint *pMatch_len) { + mz_uint dist, pos = lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK, + match_len = *pMatch_len, probe_pos = pos, next_probe_pos, + probe_len; + mz_uint num_probes_left = d->m_max_probes[match_len >= 32]; + const mz_uint16 *s = (const mz_uint16 *)(d->m_dict + pos), *p, *q; + mz_uint16 c01 = TDEFL_READ_UNALIGNED_WORD(&d->m_dict[pos + match_len - 1]), + s01 = TDEFL_READ_UNALIGNED_WORD2(s); + MZ_ASSERT(max_match_len <= TDEFL_MAX_MATCH_LEN); + if (max_match_len <= match_len) + return; + for (;;) { + for (;;) { + if (--num_probes_left == 0) + return; +#define TDEFL_PROBE \ + next_probe_pos = d->m_next[probe_pos]; \ + if ((!next_probe_pos) || \ + ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist)) \ + return; \ + probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK; \ + if (TDEFL_READ_UNALIGNED_WORD(&d->m_dict[probe_pos + match_len - 1]) == c01) \ + break; + TDEFL_PROBE; + TDEFL_PROBE; + TDEFL_PROBE; + } + if (!dist) + break; + q = (const mz_uint16 *)(d->m_dict + probe_pos); + if (TDEFL_READ_UNALIGNED_WORD2(q) != s01) + continue; + p = s; + probe_len = 32; + do { + } while ( + (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && + (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && + (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && + (TDEFL_READ_UNALIGNED_WORD2(++p) == TDEFL_READ_UNALIGNED_WORD2(++q)) && + (--probe_len > 0)); + if (!probe_len) { + *pMatch_dist = dist; + *pMatch_len = MZ_MIN(max_match_len, (mz_uint)TDEFL_MAX_MATCH_LEN); + break; + } else if ((probe_len = ((mz_uint)(p - s) * 2) + + (mz_uint)(*(const mz_uint8 *)p == + *(const mz_uint8 *)q)) > match_len) { + *pMatch_dist = dist; + if ((*pMatch_len = match_len = MZ_MIN(max_match_len, probe_len)) == + max_match_len) + break; + c01 = TDEFL_READ_UNALIGNED_WORD(&d->m_dict[pos + match_len - 1]); + } + } +} +#else +static MZ_FORCEINLINE void +tdefl_find_match(tdefl_compressor *d, mz_uint lookahead_pos, mz_uint max_dist, + mz_uint max_match_len, mz_uint *pMatch_dist, + mz_uint *pMatch_len) { + mz_uint dist, pos = lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK, + match_len = *pMatch_len, probe_pos = pos, next_probe_pos, + probe_len; + mz_uint num_probes_left = d->m_max_probes[match_len >= 32]; + const mz_uint8 *s = d->m_dict + pos, *p, *q; + mz_uint8 c0 = d->m_dict[pos + match_len], c1 = d->m_dict[pos + match_len - 1]; + MZ_ASSERT(max_match_len <= TDEFL_MAX_MATCH_LEN); + if (max_match_len <= match_len) + return; + for (;;) { + for (;;) { + if (--num_probes_left == 0) + return; +#define TDEFL_PROBE \ + next_probe_pos = d->m_next[probe_pos]; \ + if ((!next_probe_pos) || \ + ((dist = (mz_uint16)(lookahead_pos - next_probe_pos)) > max_dist)) \ + return; \ + probe_pos = next_probe_pos & TDEFL_LZ_DICT_SIZE_MASK; \ + if ((d->m_dict[probe_pos + match_len] == c0) && \ + (d->m_dict[probe_pos + match_len - 1] == c1)) \ + break; + TDEFL_PROBE; + TDEFL_PROBE; + TDEFL_PROBE; + } + if (!dist) + break; + p = s; + q = d->m_dict + probe_pos; + for (probe_len = 0; probe_len < max_match_len; probe_len++) + if (*p++ != *q++) + break; + if (probe_len > match_len) { + *pMatch_dist = dist; + if ((*pMatch_len = match_len = probe_len) == max_match_len) + return; + c0 = d->m_dict[pos + match_len]; + c1 = d->m_dict[pos + match_len - 1]; + } + } +} +#endif /* #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES */ + +#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN +#ifdef MINIZ_UNALIGNED_USE_MEMCPY +static mz_uint32 TDEFL_READ_UNALIGNED_WORD32(const mz_uint8 *p) { + mz_uint32 ret; + memcpy(&ret, p, sizeof(mz_uint32)); + return ret; +} +#else +#define TDEFL_READ_UNALIGNED_WORD32(p) *(const mz_uint32 *)(p) +#endif +static mz_bool tdefl_compress_fast(tdefl_compressor *d) { + /* Faster, minimally featured LZRW1-style match+parse loop with better + * register utilization. Intended for applications where raw throughput is + * valued more highly than ratio. */ + mz_uint lookahead_pos = d->m_lookahead_pos, + lookahead_size = d->m_lookahead_size, dict_size = d->m_dict_size, + total_lz_bytes = d->m_total_lz_bytes, + num_flags_left = d->m_num_flags_left; + mz_uint8 *pLZ_code_buf = d->m_pLZ_code_buf, *pLZ_flags = d->m_pLZ_flags; + mz_uint cur_pos = lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK; + + while ((d->m_src_buf_left) || ((d->m_flush) && (lookahead_size))) { + const mz_uint TDEFL_COMP_FAST_LOOKAHEAD_SIZE = 4096; + mz_uint dst_pos = + (lookahead_pos + lookahead_size) & TDEFL_LZ_DICT_SIZE_MASK; + mz_uint num_bytes_to_process = (mz_uint)MZ_MIN( + d->m_src_buf_left, TDEFL_COMP_FAST_LOOKAHEAD_SIZE - lookahead_size); + d->m_src_buf_left -= num_bytes_to_process; + lookahead_size += num_bytes_to_process; + + while (num_bytes_to_process) { + mz_uint32 n = MZ_MIN(TDEFL_LZ_DICT_SIZE - dst_pos, num_bytes_to_process); + memcpy(d->m_dict + dst_pos, d->m_pSrc, n); + if (dst_pos < (TDEFL_MAX_MATCH_LEN - 1)) + memcpy(d->m_dict + TDEFL_LZ_DICT_SIZE + dst_pos, d->m_pSrc, + MZ_MIN(n, (TDEFL_MAX_MATCH_LEN - 1) - dst_pos)); + d->m_pSrc += n; + dst_pos = (dst_pos + n) & TDEFL_LZ_DICT_SIZE_MASK; + num_bytes_to_process -= n; + } + + dict_size = MZ_MIN(TDEFL_LZ_DICT_SIZE - lookahead_size, dict_size); + if ((!d->m_flush) && (lookahead_size < TDEFL_COMP_FAST_LOOKAHEAD_SIZE)) + break; + + while (lookahead_size >= 4) { + mz_uint cur_match_dist, cur_match_len = 1; + mz_uint8 *pCur_dict = d->m_dict + cur_pos; + mz_uint first_trigram = TDEFL_READ_UNALIGNED_WORD32(pCur_dict) & 0xFFFFFF; + mz_uint hash = + (first_trigram ^ (first_trigram >> (24 - (TDEFL_LZ_HASH_BITS - 8)))) & + TDEFL_LEVEL1_HASH_SIZE_MASK; + mz_uint probe_pos = d->m_hash[hash]; + d->m_hash[hash] = (mz_uint16)lookahead_pos; + + if (((cur_match_dist = (mz_uint16)(lookahead_pos - probe_pos)) <= + dict_size) && + ((TDEFL_READ_UNALIGNED_WORD32( + d->m_dict + (probe_pos &= TDEFL_LZ_DICT_SIZE_MASK)) & + 0xFFFFFF) == first_trigram)) { + const mz_uint16 *p = (const mz_uint16 *)pCur_dict; + const mz_uint16 *q = (const mz_uint16 *)(d->m_dict + probe_pos); + mz_uint32 probe_len = 32; + do { + } while ((TDEFL_READ_UNALIGNED_WORD2(++p) == + TDEFL_READ_UNALIGNED_WORD2(++q)) && + (TDEFL_READ_UNALIGNED_WORD2(++p) == + TDEFL_READ_UNALIGNED_WORD2(++q)) && + (TDEFL_READ_UNALIGNED_WORD2(++p) == + TDEFL_READ_UNALIGNED_WORD2(++q)) && + (TDEFL_READ_UNALIGNED_WORD2(++p) == + TDEFL_READ_UNALIGNED_WORD2(++q)) && + (--probe_len > 0)); + cur_match_len = ((mz_uint)(p - (const mz_uint16 *)pCur_dict) * 2) + + (mz_uint)(*(const mz_uint8 *)p == *(const mz_uint8 *)q); + if (!probe_len) + cur_match_len = cur_match_dist ? TDEFL_MAX_MATCH_LEN : 0; + + if ((cur_match_len < TDEFL_MIN_MATCH_LEN) || + ((cur_match_len == TDEFL_MIN_MATCH_LEN) && + (cur_match_dist >= 8U * 1024U))) { + cur_match_len = 1; + *pLZ_code_buf++ = (mz_uint8)first_trigram; + *pLZ_flags = (mz_uint8)(*pLZ_flags >> 1); + d->m_huff_count[0][(mz_uint8)first_trigram]++; + } else { + mz_uint32 s0, s1; + cur_match_len = MZ_MIN(cur_match_len, lookahead_size); + + MZ_ASSERT((cur_match_len >= TDEFL_MIN_MATCH_LEN) && + (cur_match_dist >= 1) && + (cur_match_dist <= TDEFL_LZ_DICT_SIZE)); + + cur_match_dist--; + + pLZ_code_buf[0] = (mz_uint8)(cur_match_len - TDEFL_MIN_MATCH_LEN); +#ifdef MINIZ_UNALIGNED_USE_MEMCPY + memcpy(&pLZ_code_buf[1], &cur_match_dist, sizeof(cur_match_dist)); +#else + *(mz_uint16 *)(&pLZ_code_buf[1]) = (mz_uint16)cur_match_dist; +#endif + pLZ_code_buf += 3; + *pLZ_flags = (mz_uint8)((*pLZ_flags >> 1) | 0x80); + + s0 = s_tdefl_small_dist_sym[cur_match_dist & 511]; + s1 = s_tdefl_large_dist_sym[cur_match_dist >> 8]; + d->m_huff_count[1][(cur_match_dist < 512) ? s0 : s1]++; + + d->m_huff_count[0][s_tdefl_len_sym[cur_match_len - + TDEFL_MIN_MATCH_LEN]]++; + } + } else { + *pLZ_code_buf++ = (mz_uint8)first_trigram; + *pLZ_flags = (mz_uint8)(*pLZ_flags >> 1); + d->m_huff_count[0][(mz_uint8)first_trigram]++; + } + + if (--num_flags_left == 0) { + num_flags_left = 8; + pLZ_flags = pLZ_code_buf++; + } + + total_lz_bytes += cur_match_len; + lookahead_pos += cur_match_len; + dict_size = + MZ_MIN(dict_size + cur_match_len, (mz_uint)TDEFL_LZ_DICT_SIZE); + cur_pos = (cur_pos + cur_match_len) & TDEFL_LZ_DICT_SIZE_MASK; + MZ_ASSERT(lookahead_size >= cur_match_len); + lookahead_size -= cur_match_len; + + if (pLZ_code_buf > &d->m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE - 8]) { + int n; + d->m_lookahead_pos = lookahead_pos; + d->m_lookahead_size = lookahead_size; + d->m_dict_size = dict_size; + d->m_total_lz_bytes = total_lz_bytes; + d->m_pLZ_code_buf = pLZ_code_buf; + d->m_pLZ_flags = pLZ_flags; + d->m_num_flags_left = num_flags_left; + if ((n = tdefl_flush_block(d, 0)) != 0) + return (n < 0) ? MZ_FALSE : MZ_TRUE; + total_lz_bytes = d->m_total_lz_bytes; + pLZ_code_buf = d->m_pLZ_code_buf; + pLZ_flags = d->m_pLZ_flags; + num_flags_left = d->m_num_flags_left; + } + } + + while (lookahead_size) { + mz_uint8 lit = d->m_dict[cur_pos]; + + total_lz_bytes++; + *pLZ_code_buf++ = lit; + *pLZ_flags = (mz_uint8)(*pLZ_flags >> 1); + if (--num_flags_left == 0) { + num_flags_left = 8; + pLZ_flags = pLZ_code_buf++; + } + + d->m_huff_count[0][lit]++; + + lookahead_pos++; + dict_size = MZ_MIN(dict_size + 1, (mz_uint)TDEFL_LZ_DICT_SIZE); + cur_pos = (cur_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK; + lookahead_size--; + + if (pLZ_code_buf > &d->m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE - 8]) { + int n; + d->m_lookahead_pos = lookahead_pos; + d->m_lookahead_size = lookahead_size; + d->m_dict_size = dict_size; + d->m_total_lz_bytes = total_lz_bytes; + d->m_pLZ_code_buf = pLZ_code_buf; + d->m_pLZ_flags = pLZ_flags; + d->m_num_flags_left = num_flags_left; + if ((n = tdefl_flush_block(d, 0)) != 0) + return (n < 0) ? MZ_FALSE : MZ_TRUE; + total_lz_bytes = d->m_total_lz_bytes; + pLZ_code_buf = d->m_pLZ_code_buf; + pLZ_flags = d->m_pLZ_flags; + num_flags_left = d->m_num_flags_left; + } + } + } + + d->m_lookahead_pos = lookahead_pos; + d->m_lookahead_size = lookahead_size; + d->m_dict_size = dict_size; + d->m_total_lz_bytes = total_lz_bytes; + d->m_pLZ_code_buf = pLZ_code_buf; + d->m_pLZ_flags = pLZ_flags; + d->m_num_flags_left = num_flags_left; + return MZ_TRUE; +} +#endif /* MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN */ + +static MZ_FORCEINLINE void tdefl_record_literal(tdefl_compressor *d, + mz_uint8 lit) { + d->m_total_lz_bytes++; + *d->m_pLZ_code_buf++ = lit; + *d->m_pLZ_flags = (mz_uint8)(*d->m_pLZ_flags >> 1); + if (--d->m_num_flags_left == 0) { + d->m_num_flags_left = 8; + d->m_pLZ_flags = d->m_pLZ_code_buf++; + } + d->m_huff_count[0][lit]++; +} + +static MZ_FORCEINLINE void +tdefl_record_match(tdefl_compressor *d, mz_uint match_len, mz_uint match_dist) { + mz_uint32 s0, s1; + + MZ_ASSERT((match_len >= TDEFL_MIN_MATCH_LEN) && (match_dist >= 1) && + (match_dist <= TDEFL_LZ_DICT_SIZE)); + + d->m_total_lz_bytes += match_len; + + d->m_pLZ_code_buf[0] = (mz_uint8)(match_len - TDEFL_MIN_MATCH_LEN); + + match_dist -= 1; + d->m_pLZ_code_buf[1] = (mz_uint8)(match_dist & 0xFF); + d->m_pLZ_code_buf[2] = (mz_uint8)(match_dist >> 8); + d->m_pLZ_code_buf += 3; + + *d->m_pLZ_flags = (mz_uint8)((*d->m_pLZ_flags >> 1) | 0x80); + if (--d->m_num_flags_left == 0) { + d->m_num_flags_left = 8; + d->m_pLZ_flags = d->m_pLZ_code_buf++; + } + + s0 = s_tdefl_small_dist_sym[match_dist & 511]; + s1 = s_tdefl_large_dist_sym[(match_dist >> 8) & 127]; + d->m_huff_count[1][(match_dist < 512) ? s0 : s1]++; + d->m_huff_count[0][s_tdefl_len_sym[match_len - TDEFL_MIN_MATCH_LEN]]++; +} + +static mz_bool tdefl_compress_normal(tdefl_compressor *d) { + const mz_uint8 *pSrc = d->m_pSrc; + size_t src_buf_left = d->m_src_buf_left; + tdefl_flush flush = d->m_flush; + + while ((src_buf_left) || ((flush) && (d->m_lookahead_size))) { + mz_uint len_to_move, cur_match_dist, cur_match_len, cur_pos; + /* Update dictionary and hash chains. Keeps the lookahead size equal to + * TDEFL_MAX_MATCH_LEN. */ + if ((d->m_lookahead_size + d->m_dict_size) >= (TDEFL_MIN_MATCH_LEN - 1)) { + mz_uint dst_pos = (d->m_lookahead_pos + d->m_lookahead_size) & + TDEFL_LZ_DICT_SIZE_MASK, + ins_pos = d->m_lookahead_pos + d->m_lookahead_size - 2; + mz_uint hash = (d->m_dict[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] + << TDEFL_LZ_HASH_SHIFT) ^ + d->m_dict[(ins_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK]; + mz_uint num_bytes_to_process = (mz_uint)MZ_MIN( + src_buf_left, TDEFL_MAX_MATCH_LEN - d->m_lookahead_size); + const mz_uint8 *pSrc_end = pSrc + num_bytes_to_process; + src_buf_left -= num_bytes_to_process; + d->m_lookahead_size += num_bytes_to_process; + while (pSrc != pSrc_end) { + mz_uint8 c = *pSrc++; + d->m_dict[dst_pos] = c; + if (dst_pos < (TDEFL_MAX_MATCH_LEN - 1)) + d->m_dict[TDEFL_LZ_DICT_SIZE + dst_pos] = c; + hash = ((hash << TDEFL_LZ_HASH_SHIFT) ^ c) & (TDEFL_LZ_HASH_SIZE - 1); + d->m_next[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] = d->m_hash[hash]; + d->m_hash[hash] = (mz_uint16)(ins_pos); + dst_pos = (dst_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK; + ins_pos++; + } + } else { + while ((src_buf_left) && (d->m_lookahead_size < TDEFL_MAX_MATCH_LEN)) { + mz_uint8 c = *pSrc++; + mz_uint dst_pos = (d->m_lookahead_pos + d->m_lookahead_size) & + TDEFL_LZ_DICT_SIZE_MASK; + src_buf_left--; + d->m_dict[dst_pos] = c; + if (dst_pos < (TDEFL_MAX_MATCH_LEN - 1)) + d->m_dict[TDEFL_LZ_DICT_SIZE + dst_pos] = c; + if ((++d->m_lookahead_size + d->m_dict_size) >= TDEFL_MIN_MATCH_LEN) { + mz_uint ins_pos = d->m_lookahead_pos + (d->m_lookahead_size - 1) - 2; + mz_uint hash = ((d->m_dict[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] + << (TDEFL_LZ_HASH_SHIFT * 2)) ^ + (d->m_dict[(ins_pos + 1) & TDEFL_LZ_DICT_SIZE_MASK] + << TDEFL_LZ_HASH_SHIFT) ^ + c) & + (TDEFL_LZ_HASH_SIZE - 1); + d->m_next[ins_pos & TDEFL_LZ_DICT_SIZE_MASK] = d->m_hash[hash]; + d->m_hash[hash] = (mz_uint16)(ins_pos); + } + } + } + d->m_dict_size = + MZ_MIN(TDEFL_LZ_DICT_SIZE - d->m_lookahead_size, d->m_dict_size); + if ((!flush) && (d->m_lookahead_size < TDEFL_MAX_MATCH_LEN)) + break; + + /* Simple lazy/greedy parsing state machine. */ + len_to_move = 1; + cur_match_dist = 0; + cur_match_len = + d->m_saved_match_len ? d->m_saved_match_len : (TDEFL_MIN_MATCH_LEN - 1); + cur_pos = d->m_lookahead_pos & TDEFL_LZ_DICT_SIZE_MASK; + if (d->m_flags & (TDEFL_RLE_MATCHES | TDEFL_FORCE_ALL_RAW_BLOCKS)) { + if ((d->m_dict_size) && (!(d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS))) { + mz_uint8 c = d->m_dict[(cur_pos - 1) & TDEFL_LZ_DICT_SIZE_MASK]; + cur_match_len = 0; + while (cur_match_len < d->m_lookahead_size) { + if (d->m_dict[cur_pos + cur_match_len] != c) + break; + cur_match_len++; + } + if (cur_match_len < TDEFL_MIN_MATCH_LEN) + cur_match_len = 0; + else + cur_match_dist = 1; + } + } else { + tdefl_find_match(d, d->m_lookahead_pos, d->m_dict_size, + d->m_lookahead_size, &cur_match_dist, &cur_match_len); + } + if (((cur_match_len == TDEFL_MIN_MATCH_LEN) && + (cur_match_dist >= 8U * 1024U)) || + (cur_pos == cur_match_dist) || + ((d->m_flags & TDEFL_FILTER_MATCHES) && (cur_match_len <= 5))) { + cur_match_dist = cur_match_len = 0; + } + if (d->m_saved_match_len) { + if (cur_match_len > d->m_saved_match_len) { + tdefl_record_literal(d, (mz_uint8)d->m_saved_lit); + if (cur_match_len >= 128) { + tdefl_record_match(d, cur_match_len, cur_match_dist); + d->m_saved_match_len = 0; + len_to_move = cur_match_len; + } else { + d->m_saved_lit = d->m_dict[cur_pos]; + d->m_saved_match_dist = cur_match_dist; + d->m_saved_match_len = cur_match_len; + } + } else { + tdefl_record_match(d, d->m_saved_match_len, d->m_saved_match_dist); + len_to_move = d->m_saved_match_len - 1; + d->m_saved_match_len = 0; + } + } else if (!cur_match_dist) + tdefl_record_literal(d, + d->m_dict[MZ_MIN(cur_pos, sizeof(d->m_dict) - 1)]); + else if ((d->m_greedy_parsing) || (d->m_flags & TDEFL_RLE_MATCHES) || + (cur_match_len >= 128)) { + tdefl_record_match(d, cur_match_len, cur_match_dist); + len_to_move = cur_match_len; + } else { + d->m_saved_lit = d->m_dict[MZ_MIN(cur_pos, sizeof(d->m_dict) - 1)]; + d->m_saved_match_dist = cur_match_dist; + d->m_saved_match_len = cur_match_len; + } + /* Move the lookahead forward by len_to_move bytes. */ + d->m_lookahead_pos += len_to_move; + MZ_ASSERT(d->m_lookahead_size >= len_to_move); + d->m_lookahead_size -= len_to_move; + d->m_dict_size = + MZ_MIN(d->m_dict_size + len_to_move, (mz_uint)TDEFL_LZ_DICT_SIZE); + /* Check if it's time to flush the current LZ codes to the internal output + * buffer. */ + if ((d->m_pLZ_code_buf > &d->m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE - 8]) || + ((d->m_total_lz_bytes > 31 * 1024) && + (((((mz_uint)(d->m_pLZ_code_buf - d->m_lz_code_buf) * 115) >> 7) >= + d->m_total_lz_bytes) || + (d->m_flags & TDEFL_FORCE_ALL_RAW_BLOCKS)))) { + int n; + d->m_pSrc = pSrc; + d->m_src_buf_left = src_buf_left; + if ((n = tdefl_flush_block(d, 0)) != 0) + return (n < 0) ? MZ_FALSE : MZ_TRUE; + } + } + + d->m_pSrc = pSrc; + d->m_src_buf_left = src_buf_left; + return MZ_TRUE; +} + +static tdefl_status tdefl_flush_output_buffer(tdefl_compressor *d) { + if (d->m_pIn_buf_size) { + *d->m_pIn_buf_size = d->m_pSrc - (const mz_uint8 *)d->m_pIn_buf; + } + + if (d->m_pOut_buf_size) { + size_t n = MZ_MIN(*d->m_pOut_buf_size - d->m_out_buf_ofs, + d->m_output_flush_remaining); + memcpy((mz_uint8 *)d->m_pOut_buf + d->m_out_buf_ofs, + d->m_output_buf + d->m_output_flush_ofs, n); + d->m_output_flush_ofs += (mz_uint)n; + d->m_output_flush_remaining -= (mz_uint)n; + d->m_out_buf_ofs += n; + + *d->m_pOut_buf_size = d->m_out_buf_ofs; + } + + return (d->m_finished && !d->m_output_flush_remaining) ? TDEFL_STATUS_DONE + : TDEFL_STATUS_OKAY; +} + +tdefl_status tdefl_compress(tdefl_compressor *d, const void *pIn_buf, + size_t *pIn_buf_size, void *pOut_buf, + size_t *pOut_buf_size, tdefl_flush flush) { + if (!d) { + if (pIn_buf_size) + *pIn_buf_size = 0; + if (pOut_buf_size) + *pOut_buf_size = 0; + return TDEFL_STATUS_BAD_PARAM; + } + + d->m_pIn_buf = pIn_buf; + d->m_pIn_buf_size = pIn_buf_size; + d->m_pOut_buf = pOut_buf; + d->m_pOut_buf_size = pOut_buf_size; + d->m_pSrc = (const mz_uint8 *)(pIn_buf); + d->m_src_buf_left = pIn_buf_size ? *pIn_buf_size : 0; + d->m_out_buf_ofs = 0; + d->m_flush = flush; + + if (((d->m_pPut_buf_func != NULL) == + ((pOut_buf != NULL) || (pOut_buf_size != NULL))) || + (d->m_prev_return_status != TDEFL_STATUS_OKAY) || + (d->m_wants_to_finish && (flush != TDEFL_FINISH)) || + (pIn_buf_size && *pIn_buf_size && !pIn_buf) || + (pOut_buf_size && *pOut_buf_size && !pOut_buf)) { + if (pIn_buf_size) + *pIn_buf_size = 0; + if (pOut_buf_size) + *pOut_buf_size = 0; + return (d->m_prev_return_status = TDEFL_STATUS_BAD_PARAM); + } + d->m_wants_to_finish |= (flush == TDEFL_FINISH); + + if ((d->m_output_flush_remaining) || (d->m_finished)) + return (d->m_prev_return_status = tdefl_flush_output_buffer(d)); + +#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN + if (((d->m_flags & TDEFL_MAX_PROBES_MASK) == 1) && + ((d->m_flags & TDEFL_GREEDY_PARSING_FLAG) != 0) && + ((d->m_flags & (TDEFL_FILTER_MATCHES | TDEFL_FORCE_ALL_RAW_BLOCKS | + TDEFL_RLE_MATCHES)) == 0)) { + if (!tdefl_compress_fast(d)) + return d->m_prev_return_status; + } else +#endif /* #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN */ + { + if (!tdefl_compress_normal(d)) + return d->m_prev_return_status; + } + + if ((d->m_flags & (TDEFL_WRITE_ZLIB_HEADER | TDEFL_COMPUTE_ADLER32)) && + (pIn_buf)) + d->m_adler32 = + (mz_uint32)mz_adler32(d->m_adler32, (const mz_uint8 *)pIn_buf, + d->m_pSrc - (const mz_uint8 *)pIn_buf); + + if ((flush) && (!d->m_lookahead_size) && (!d->m_src_buf_left) && + (!d->m_output_flush_remaining)) { + if (tdefl_flush_block(d, flush) < 0) + return d->m_prev_return_status; + d->m_finished = (flush == TDEFL_FINISH); + if (flush == TDEFL_FULL_FLUSH) { + MZ_CLEAR_OBJ(d->m_hash); + MZ_CLEAR_OBJ(d->m_next); + d->m_dict_size = 0; + } + } + + return (d->m_prev_return_status = tdefl_flush_output_buffer(d)); +} + +tdefl_status tdefl_compress_buffer(tdefl_compressor *d, const void *pIn_buf, + size_t in_buf_size, tdefl_flush flush) { + MZ_ASSERT(d->m_pPut_buf_func); + return tdefl_compress(d, pIn_buf, &in_buf_size, NULL, NULL, flush); +} + +tdefl_status tdefl_init(tdefl_compressor *d, + tdefl_put_buf_func_ptr pPut_buf_func, + void *pPut_buf_user, int flags) { + d->m_pPut_buf_func = pPut_buf_func; + d->m_pPut_buf_user = pPut_buf_user; + d->m_flags = (mz_uint)(flags); + d->m_max_probes[0] = 1 + ((flags & 0xFFF) + 2) / 3; + d->m_greedy_parsing = (flags & TDEFL_GREEDY_PARSING_FLAG) != 0; + d->m_max_probes[1] = 1 + (((flags & 0xFFF) >> 2) + 2) / 3; + if (!(flags & TDEFL_NONDETERMINISTIC_PARSING_FLAG)) + MZ_CLEAR_OBJ(d->m_hash); + d->m_lookahead_pos = d->m_lookahead_size = d->m_dict_size = + d->m_total_lz_bytes = d->m_lz_code_buf_dict_pos = d->m_bits_in = 0; + d->m_output_flush_ofs = d->m_output_flush_remaining = d->m_finished = + d->m_block_index = d->m_bit_buffer = d->m_wants_to_finish = 0; + d->m_pLZ_code_buf = d->m_lz_code_buf + 1; + d->m_pLZ_flags = d->m_lz_code_buf; + *d->m_pLZ_flags = 0; + d->m_num_flags_left = 8; + d->m_pOutput_buf = d->m_output_buf; + d->m_pOutput_buf_end = d->m_output_buf; + d->m_prev_return_status = TDEFL_STATUS_OKAY; + d->m_saved_match_dist = d->m_saved_match_len = d->m_saved_lit = 0; + d->m_adler32 = 1; + d->m_pIn_buf = NULL; + d->m_pOut_buf = NULL; + d->m_pIn_buf_size = NULL; + d->m_pOut_buf_size = NULL; + d->m_flush = TDEFL_NO_FLUSH; + d->m_pSrc = NULL; + d->m_src_buf_left = 0; + d->m_out_buf_ofs = 0; + if (!(flags & TDEFL_NONDETERMINISTIC_PARSING_FLAG)) + MZ_CLEAR_OBJ(d->m_dict); + memset(&d->m_huff_count[0][0], 0, + sizeof(d->m_huff_count[0][0]) * TDEFL_MAX_HUFF_SYMBOLS_0); + memset(&d->m_huff_count[1][0], 0, + sizeof(d->m_huff_count[1][0]) * TDEFL_MAX_HUFF_SYMBOLS_1); + return TDEFL_STATUS_OKAY; +} + +tdefl_status tdefl_get_prev_return_status(tdefl_compressor *d) { + return d->m_prev_return_status; +} + +mz_uint32 tdefl_get_adler32(tdefl_compressor *d) { return d->m_adler32; } + +mz_bool tdefl_compress_mem_to_output(const void *pBuf, size_t buf_len, + tdefl_put_buf_func_ptr pPut_buf_func, + void *pPut_buf_user, int flags) { + tdefl_compressor *pComp; + mz_bool succeeded; + if (((buf_len) && (!pBuf)) || (!pPut_buf_func)) + return MZ_FALSE; + pComp = (tdefl_compressor *)MZ_MALLOC(sizeof(tdefl_compressor)); + if (!pComp) + return MZ_FALSE; + succeeded = (tdefl_init(pComp, pPut_buf_func, pPut_buf_user, flags) == + TDEFL_STATUS_OKAY); + succeeded = + succeeded && (tdefl_compress_buffer(pComp, pBuf, buf_len, TDEFL_FINISH) == + TDEFL_STATUS_DONE); + MZ_FREE(pComp); + return succeeded; +} + +typedef struct { + size_t m_size, m_capacity; + mz_uint8 *m_pBuf; + mz_bool m_expandable; +} tdefl_output_buffer; + +static mz_bool tdefl_output_buffer_putter(const void *pBuf, int len, + void *pUser) { + tdefl_output_buffer *p = (tdefl_output_buffer *)pUser; + size_t new_size = p->m_size + len; + if (new_size > p->m_capacity) { + size_t new_capacity = p->m_capacity; + mz_uint8 *pNew_buf; + if (!p->m_expandable) + return MZ_FALSE; + do { + new_capacity = MZ_MAX(128U, new_capacity << 1U); + } while (new_size > new_capacity); + pNew_buf = (mz_uint8 *)MZ_REALLOC(p->m_pBuf, new_capacity); + if (!pNew_buf) + return MZ_FALSE; + p->m_pBuf = pNew_buf; + p->m_capacity = new_capacity; + } + memcpy((mz_uint8 *)p->m_pBuf + p->m_size, pBuf, len); + p->m_size = new_size; + return MZ_TRUE; +} + +void *tdefl_compress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, + size_t *pOut_len, int flags) { + tdefl_output_buffer out_buf; + MZ_CLEAR_OBJ(out_buf); + if (!pOut_len) + return MZ_FALSE; + else + *pOut_len = 0; + out_buf.m_expandable = MZ_TRUE; + if (!tdefl_compress_mem_to_output( + pSrc_buf, src_buf_len, tdefl_output_buffer_putter, &out_buf, flags)) + return NULL; + *pOut_len = out_buf.m_size; + return out_buf.m_pBuf; +} + +size_t tdefl_compress_mem_to_mem(void *pOut_buf, size_t out_buf_len, + const void *pSrc_buf, size_t src_buf_len, + int flags) { + tdefl_output_buffer out_buf; + MZ_CLEAR_OBJ(out_buf); + if (!pOut_buf) + return 0; + out_buf.m_pBuf = (mz_uint8 *)pOut_buf; + out_buf.m_capacity = out_buf_len; + if (!tdefl_compress_mem_to_output( + pSrc_buf, src_buf_len, tdefl_output_buffer_putter, &out_buf, flags)) + return 0; + return out_buf.m_size; +} + +static const mz_uint s_tdefl_num_probes[11] = {0, 1, 6, 32, 16, 32, + 128, 256, 512, 768, 1500}; + +/* level may actually range from [0,10] (10 is a "hidden" max level, where we + * want a bit more compression and it's fine if throughput to fall off a cliff + * on some files). */ +mz_uint tdefl_create_comp_flags_from_zip_params(int level, int window_bits, + int strategy) { + mz_uint comp_flags = + s_tdefl_num_probes[(level >= 0) ? MZ_MIN(10, level) : MZ_DEFAULT_LEVEL] | + ((level <= 3) ? TDEFL_GREEDY_PARSING_FLAG : 0); + if (window_bits > 0) + comp_flags |= TDEFL_WRITE_ZLIB_HEADER; + + if (!level) + comp_flags |= TDEFL_FORCE_ALL_RAW_BLOCKS; + else if (strategy == MZ_FILTERED) + comp_flags |= TDEFL_FILTER_MATCHES; + else if (strategy == MZ_HUFFMAN_ONLY) + comp_flags &= ~TDEFL_MAX_PROBES_MASK; + else if (strategy == MZ_FIXED) + comp_flags |= TDEFL_FORCE_ALL_STATIC_BLOCKS; + else if (strategy == MZ_RLE) + comp_flags |= TDEFL_RLE_MATCHES; + + return comp_flags; +} + +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable : 4204) /* nonstandard extension used : non-constant \ + aggregate initializer (also supported by \ + GNU C and C99, so no big deal) */ +#endif + +/* Simple PNG writer function by Alex Evans, 2011. Released into the public + domain: https://gist.github.com/908299, more context at + http://altdevblogaday.org/2011/04/06/a-smaller-jpg-encoder/. + This is actually a modification of Alex's original code so PNG files generated + by this function pass pngcheck. */ +void *tdefl_write_image_to_png_file_in_memory_ex(const void *pImage, int w, + int h, int num_chans, + size_t *pLen_out, + mz_uint level, mz_bool flip) { + /* Using a local copy of this array here in case MINIZ_NO_ZLIB_APIS was + * defined. */ + static const mz_uint s_tdefl_png_num_probes[11] = { + 0, 1, 6, 32, 16, 32, 128, 256, 512, 768, 1500}; + tdefl_compressor *pComp = + (tdefl_compressor *)MZ_MALLOC(sizeof(tdefl_compressor)); + tdefl_output_buffer out_buf; + int i, bpl = w * num_chans, y, z; + mz_uint32 c; + *pLen_out = 0; + if (!pComp) + return NULL; + MZ_CLEAR_OBJ(out_buf); + out_buf.m_expandable = MZ_TRUE; + out_buf.m_capacity = 57 + MZ_MAX(64, (1 + bpl) * h); + if (NULL == (out_buf.m_pBuf = (mz_uint8 *)MZ_MALLOC(out_buf.m_capacity))) { + MZ_FREE(pComp); + return NULL; + } + /* write dummy header */ + for (z = 41; z; --z) + tdefl_output_buffer_putter(&z, 1, &out_buf); + /* compress image data */ + tdefl_init(pComp, tdefl_output_buffer_putter, &out_buf, + s_tdefl_png_num_probes[MZ_MIN(10, level)] | + TDEFL_WRITE_ZLIB_HEADER); + for (y = 0; y < h; ++y) { + tdefl_compress_buffer(pComp, &z, 1, TDEFL_NO_FLUSH); + tdefl_compress_buffer(pComp, + (mz_uint8 *)pImage + (flip ? (h - 1 - y) : y) * bpl, + bpl, TDEFL_NO_FLUSH); + } + if (tdefl_compress_buffer(pComp, NULL, 0, TDEFL_FINISH) != + TDEFL_STATUS_DONE) { + MZ_FREE(pComp); + MZ_FREE(out_buf.m_pBuf); + return NULL; + } + /* write real header */ + *pLen_out = out_buf.m_size - 41; + { + static const mz_uint8 chans[] = {0x00, 0x00, 0x04, 0x02, 0x06}; + mz_uint8 pnghdr[41] = {0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, + 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x49, 0x44, 0x41, 0x54}; + pnghdr[18] = (mz_uint8)(w >> 8); + pnghdr[19] = (mz_uint8)w; + pnghdr[22] = (mz_uint8)(h >> 8); + pnghdr[23] = (mz_uint8)h; + pnghdr[25] = chans[num_chans]; + pnghdr[33] = (mz_uint8)(*pLen_out >> 24); + pnghdr[34] = (mz_uint8)(*pLen_out >> 16); + pnghdr[35] = (mz_uint8)(*pLen_out >> 8); + pnghdr[36] = (mz_uint8)*pLen_out; + c = (mz_uint32)mz_crc32(MZ_CRC32_INIT, pnghdr + 12, 17); + for (i = 0; i < 4; ++i, c <<= 8) + ((mz_uint8 *)(pnghdr + 29))[i] = (mz_uint8)(c >> 24); + memcpy(out_buf.m_pBuf, pnghdr, 41); + } + /* write footer (IDAT CRC-32, followed by IEND chunk) */ + if (!tdefl_output_buffer_putter( + "\0\0\0\0\0\0\0\0\x49\x45\x4e\x44\xae\x42\x60\x82", 16, &out_buf)) { + *pLen_out = 0; + MZ_FREE(pComp); + MZ_FREE(out_buf.m_pBuf); + return NULL; + } + c = (mz_uint32)mz_crc32(MZ_CRC32_INIT, out_buf.m_pBuf + 41 - 4, + *pLen_out + 4); + for (i = 0; i < 4; ++i, c <<= 8) + (out_buf.m_pBuf + out_buf.m_size - 16)[i] = (mz_uint8)(c >> 24); + /* compute final size of file, grab compressed data buffer and return */ + *pLen_out += 57; + MZ_FREE(pComp); + return out_buf.m_pBuf; +} +void *tdefl_write_image_to_png_file_in_memory(const void *pImage, int w, int h, + int num_chans, size_t *pLen_out) { + /* Level 6 corresponds to TDEFL_DEFAULT_MAX_PROBES or MZ_DEFAULT_LEVEL (but we + * can't depend on MZ_DEFAULT_LEVEL being available in case the zlib API's + * where #defined out) */ + return tdefl_write_image_to_png_file_in_memory_ex(pImage, w, h, num_chans, + pLen_out, 6, MZ_FALSE); +} + +#ifndef MINIZ_NO_MALLOC +/* Allocate the tdefl_compressor and tinfl_decompressor structures in C so that + */ +/* non-C language bindings to tdefL_ and tinfl_ API don't need to worry about */ +/* structure size and allocation mechanism. */ +tdefl_compressor *tdefl_compressor_alloc() { + return (tdefl_compressor *)MZ_MALLOC(sizeof(tdefl_compressor)); +} + +void tdefl_compressor_free(tdefl_compressor *pComp) { MZ_FREE(pComp); } +#endif + +#ifdef _MSC_VER +#pragma warning(pop) +#endif + +#ifdef __cplusplus +} +#endif +/************************************************************************** + * + * Copyright 2013-2014 RAD Game Tools and Valve Software + * Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + +#ifdef __cplusplus +extern "C" { +#endif + +/* ------------------- Low-level Decompression (completely independent from all + * compression API's) */ + +#define TINFL_MEMCPY(d, s, l) memcpy(d, s, l) +#define TINFL_MEMSET(p, c, l) memset(p, c, l) + +#define TINFL_CR_BEGIN \ + switch (r->m_state) { \ + case 0: +#define TINFL_CR_RETURN(state_index, result) \ + do { \ + status = result; \ + r->m_state = state_index; \ + goto common_exit; \ + case state_index:; \ + } \ + MZ_MACRO_END +#define TINFL_CR_RETURN_FOREVER(state_index, result) \ + do { \ + for (;;) { \ + TINFL_CR_RETURN(state_index, result); \ + } \ + } \ + MZ_MACRO_END +#define TINFL_CR_FINISH } + +#define TINFL_GET_BYTE(state_index, c) \ + do { \ + while (pIn_buf_cur >= pIn_buf_end) { \ + TINFL_CR_RETURN(state_index, \ + (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) \ + ? TINFL_STATUS_NEEDS_MORE_INPUT \ + : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); \ + } \ + c = *pIn_buf_cur++; \ + } \ + MZ_MACRO_END + +#define TINFL_NEED_BITS(state_index, n) \ + do { \ + mz_uint c; \ + TINFL_GET_BYTE(state_index, c); \ + bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ + num_bits += 8; \ + } while (num_bits < (mz_uint)(n)) +#define TINFL_SKIP_BITS(state_index, n) \ + do { \ + if (num_bits < (mz_uint)(n)) { \ + TINFL_NEED_BITS(state_index, n); \ + } \ + bit_buf >>= (n); \ + num_bits -= (n); \ + } \ + MZ_MACRO_END +#define TINFL_GET_BITS(state_index, b, n) \ + do { \ + if (num_bits < (mz_uint)(n)) { \ + TINFL_NEED_BITS(state_index, n); \ + } \ + b = bit_buf & ((1 << (n)) - 1); \ + bit_buf >>= (n); \ + num_bits -= (n); \ + } \ + MZ_MACRO_END + +/* TINFL_HUFF_BITBUF_FILL() is only used rarely, when the number of bytes + * remaining in the input buffer falls below 2. */ +/* It reads just enough bytes from the input stream that are needed to decode + * the next Huffman code (and absolutely no more). It works by trying to fully + * decode a */ +/* Huffman code by using whatever bits are currently present in the bit buffer. + * If this fails, it reads another byte, and tries again until it succeeds or + * until the */ +/* bit buffer contains >=15 bits (deflate's max. Huffman code size). */ +#define TINFL_HUFF_BITBUF_FILL(state_index, pHuff) \ + do { \ + temp = (pHuff)->m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]; \ + if (temp >= 0) { \ + code_len = temp >> 9; \ + if ((code_len) && (num_bits >= code_len)) \ + break; \ + } else if (num_bits > TINFL_FAST_LOOKUP_BITS) { \ + code_len = TINFL_FAST_LOOKUP_BITS; \ + do { \ + temp = (pHuff)->m_tree[~temp + ((bit_buf >> code_len++) & 1)]; \ + } while ((temp < 0) && (num_bits >= (code_len + 1))); \ + if (temp >= 0) \ + break; \ + } \ + TINFL_GET_BYTE(state_index, c); \ + bit_buf |= (((tinfl_bit_buf_t)c) << num_bits); \ + num_bits += 8; \ + } while (num_bits < 15); + +/* TINFL_HUFF_DECODE() decodes the next Huffman coded symbol. It's more complex + * than you would initially expect because the zlib API expects the decompressor + * to never read */ +/* beyond the final byte of the deflate stream. (In other words, when this macro + * wants to read another byte from the input, it REALLY needs another byte in + * order to fully */ +/* decode the next Huffman code.) Handling this properly is particularly + * important on raw deflate (non-zlib) streams, which aren't followed by a byte + * aligned adler-32. */ +/* The slow path is only executed at the very end of the input buffer. */ +/* v1.16: The original macro handled the case at the very end of the passed-in + * input buffer, but we also need to handle the case where the user passes in + * 1+zillion bytes */ +/* following the deflate data and our non-conservative read-ahead path won't + * kick in here on this code. This is much trickier. */ +#define TINFL_HUFF_DECODE(state_index, sym, pHuff) \ + do { \ + int temp; \ + mz_uint code_len, c; \ + if (num_bits < 15) { \ + if ((pIn_buf_end - pIn_buf_cur) < 2) { \ + TINFL_HUFF_BITBUF_FILL(state_index, pHuff); \ + } else { \ + bit_buf |= (((tinfl_bit_buf_t)pIn_buf_cur[0]) << num_bits) | \ + (((tinfl_bit_buf_t)pIn_buf_cur[1]) << (num_bits + 8)); \ + pIn_buf_cur += 2; \ + num_bits += 16; \ + } \ + } \ + if ((temp = (pHuff)->m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= \ + 0) \ + code_len = temp >> 9, temp &= 511; \ + else { \ + code_len = TINFL_FAST_LOOKUP_BITS; \ + do { \ + temp = (pHuff)->m_tree[~temp + ((bit_buf >> code_len++) & 1)]; \ + } while (temp < 0); \ + } \ + sym = temp; \ + bit_buf >>= code_len; \ + num_bits -= code_len; \ + } \ + MZ_MACRO_END + +tinfl_status tinfl_decompress(tinfl_decompressor *r, + const mz_uint8 *pIn_buf_next, + size_t *pIn_buf_size, mz_uint8 *pOut_buf_start, + mz_uint8 *pOut_buf_next, size_t *pOut_buf_size, + const mz_uint32 decomp_flags) { + static const int s_length_base[31] = { + 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, + 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0}; + static const int s_length_extra[31] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, + 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, + 4, 4, 5, 5, 5, 5, 0, 0, 0}; + static const int s_dist_base[32] = { + 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, + 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, + 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 0, 0}; + static const int s_dist_extra[32] = {0, 0, 0, 0, 1, 1, 2, 2, 3, 3, + 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, + 9, 9, 10, 10, 11, 11, 12, 12, 13, 13}; + static const mz_uint8 s_length_dezigzag[19] = { + 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; + static const int s_min_table_sizes[3] = {257, 1, 4}; + + tinfl_status status = TINFL_STATUS_FAILED; + mz_uint32 num_bits, dist, counter, num_extra; + tinfl_bit_buf_t bit_buf; + const mz_uint8 *pIn_buf_cur = pIn_buf_next, *const pIn_buf_end = + pIn_buf_next + *pIn_buf_size; + mz_uint8 *pOut_buf_cur = pOut_buf_next, *const pOut_buf_end = + pOut_buf_next + *pOut_buf_size; + size_t out_buf_size_mask = + (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF) + ? (size_t)-1 + : ((pOut_buf_next - pOut_buf_start) + *pOut_buf_size) - 1, + dist_from_out_buf_start; + + /* Ensure the output buffer's size is a power of 2, unless the output buffer + * is large enough to hold the entire output file (in which case it doesn't + * matter). */ + if (((out_buf_size_mask + 1) & out_buf_size_mask) || + (pOut_buf_next < pOut_buf_start)) { + *pIn_buf_size = *pOut_buf_size = 0; + return TINFL_STATUS_BAD_PARAM; + } + + num_bits = r->m_num_bits; + bit_buf = r->m_bit_buf; + dist = r->m_dist; + counter = r->m_counter; + num_extra = r->m_num_extra; + dist_from_out_buf_start = r->m_dist_from_out_buf_start; + TINFL_CR_BEGIN + + bit_buf = num_bits = dist = counter = num_extra = r->m_zhdr0 = r->m_zhdr1 = 0; + r->m_z_adler32 = r->m_check_adler32 = 1; + if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) { + TINFL_GET_BYTE(1, r->m_zhdr0); + TINFL_GET_BYTE(2, r->m_zhdr1); + counter = (((r->m_zhdr0 * 256 + r->m_zhdr1) % 31 != 0) || + (r->m_zhdr1 & 32) || ((r->m_zhdr0 & 15) != 8)); + if (!(decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)) + counter |= (((1U << (8U + (r->m_zhdr0 >> 4))) > 32768U) || + ((out_buf_size_mask + 1) < + (size_t)(1U << (8U + (r->m_zhdr0 >> 4))))); + if (counter) { + TINFL_CR_RETURN_FOREVER(36, TINFL_STATUS_FAILED); + } + } + + do { + TINFL_GET_BITS(3, r->m_final, 3); + r->m_type = r->m_final >> 1; + if (r->m_type == 0) { + TINFL_SKIP_BITS(5, num_bits & 7); + for (counter = 0; counter < 4; ++counter) { + if (num_bits) + TINFL_GET_BITS(6, r->m_raw_header[counter], 8); + else + TINFL_GET_BYTE(7, r->m_raw_header[counter]); + } + if ((counter = (r->m_raw_header[0] | (r->m_raw_header[1] << 8))) != + (mz_uint)(0xFFFF ^ + (r->m_raw_header[2] | (r->m_raw_header[3] << 8)))) { + TINFL_CR_RETURN_FOREVER(39, TINFL_STATUS_FAILED); + } + while ((counter) && (num_bits)) { + TINFL_GET_BITS(51, dist, 8); + while (pOut_buf_cur >= pOut_buf_end) { + TINFL_CR_RETURN(52, TINFL_STATUS_HAS_MORE_OUTPUT); + } + *pOut_buf_cur++ = (mz_uint8)dist; + counter--; + } + while (counter) { + size_t n; + while (pOut_buf_cur >= pOut_buf_end) { + TINFL_CR_RETURN(9, TINFL_STATUS_HAS_MORE_OUTPUT); + } + while (pIn_buf_cur >= pIn_buf_end) { + TINFL_CR_RETURN(38, (decomp_flags & TINFL_FLAG_HAS_MORE_INPUT) + ? TINFL_STATUS_NEEDS_MORE_INPUT + : TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS); + } + n = MZ_MIN(MZ_MIN((size_t)(pOut_buf_end - pOut_buf_cur), + (size_t)(pIn_buf_end - pIn_buf_cur)), + counter); + TINFL_MEMCPY(pOut_buf_cur, pIn_buf_cur, n); + pIn_buf_cur += n; + pOut_buf_cur += n; + counter -= (mz_uint)n; + } + } else if (r->m_type == 3) { + TINFL_CR_RETURN_FOREVER(10, TINFL_STATUS_FAILED); + } else { + if (r->m_type == 1) { + mz_uint8 *p = r->m_tables[0].m_code_size; + mz_uint i; + r->m_table_sizes[0] = 288; + r->m_table_sizes[1] = 32; + TINFL_MEMSET(r->m_tables[1].m_code_size, 5, 32); + for (i = 0; i <= 143; ++i) + *p++ = 8; + for (; i <= 255; ++i) + *p++ = 9; + for (; i <= 279; ++i) + *p++ = 7; + for (; i <= 287; ++i) + *p++ = 8; + } else { + for (counter = 0; counter < 3; counter++) { + TINFL_GET_BITS(11, r->m_table_sizes[counter], "\05\05\04"[counter]); + r->m_table_sizes[counter] += s_min_table_sizes[counter]; + } + MZ_CLEAR_OBJ(r->m_tables[2].m_code_size); + for (counter = 0; counter < r->m_table_sizes[2]; counter++) { + mz_uint s; + TINFL_GET_BITS(14, s, 3); + r->m_tables[2].m_code_size[s_length_dezigzag[counter]] = (mz_uint8)s; + } + r->m_table_sizes[2] = 19; + } + for (; (int)r->m_type >= 0; r->m_type--) { + int tree_next, tree_cur; + tinfl_huff_table *pTable; + mz_uint i, j, used_syms, total, sym_index, next_code[17], + total_syms[16]; + pTable = &r->m_tables[r->m_type]; + MZ_CLEAR_OBJ(total_syms); + MZ_CLEAR_OBJ(pTable->m_look_up); + MZ_CLEAR_OBJ(pTable->m_tree); + for (i = 0; i < r->m_table_sizes[r->m_type]; ++i) + total_syms[pTable->m_code_size[i]]++; + used_syms = 0, total = 0; + next_code[0] = next_code[1] = 0; + for (i = 1; i <= 15; ++i) { + used_syms += total_syms[i]; + next_code[i + 1] = (total = ((total + total_syms[i]) << 1)); + } + if ((65536 != total) && (used_syms > 1)) { + TINFL_CR_RETURN_FOREVER(35, TINFL_STATUS_FAILED); + } + for (tree_next = -1, sym_index = 0; + sym_index < r->m_table_sizes[r->m_type]; ++sym_index) { + mz_uint rev_code = 0, l, cur_code, + code_size = pTable->m_code_size[sym_index]; + + if (!code_size) + continue; + cur_code = next_code[code_size]++; + for (l = code_size; l > 0; l--, cur_code >>= 1) + rev_code = (rev_code << 1) | (cur_code & 1); + if (code_size <= TINFL_FAST_LOOKUP_BITS) { + mz_int16 k = (mz_int16)((code_size << 9) | sym_index); + while (rev_code < TINFL_FAST_LOOKUP_SIZE) { + pTable->m_look_up[rev_code] = k; + rev_code += (1 << code_size); + } + continue; + } + if (0 == + (tree_cur = pTable->m_look_up[rev_code & + (TINFL_FAST_LOOKUP_SIZE - 1)])) { + pTable->m_look_up[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)] = + (mz_int16)tree_next; + tree_cur = tree_next; + tree_next -= 2; + } + rev_code >>= (TINFL_FAST_LOOKUP_BITS - 1); + for (j = code_size; j > (TINFL_FAST_LOOKUP_BITS + 1); j--) { + tree_cur -= ((rev_code >>= 1) & 1); + if (!pTable->m_tree[-tree_cur - 1]) { + pTable->m_tree[-tree_cur - 1] = (mz_int16)tree_next; + tree_cur = tree_next; + tree_next -= 2; + } else + tree_cur = pTable->m_tree[-tree_cur - 1]; + } + tree_cur -= ((rev_code >>= 1) & 1); + (void)rev_code; // unused + pTable->m_tree[-tree_cur - 1] = (mz_int16)sym_index; + } + if (r->m_type == 2) { + for (counter = 0; + counter < (r->m_table_sizes[0] + r->m_table_sizes[1]);) { + mz_uint s; + TINFL_HUFF_DECODE(16, dist, &r->m_tables[2]); + if (dist < 16) { + r->m_len_codes[counter++] = (mz_uint8)dist; + continue; + } + if ((dist == 16) && (!counter)) { + TINFL_CR_RETURN_FOREVER(17, TINFL_STATUS_FAILED); + } + num_extra = "\02\03\07"[dist - 16]; + TINFL_GET_BITS(18, s, num_extra); + s += "\03\03\013"[dist - 16]; + TINFL_MEMSET(r->m_len_codes + counter, + (dist == 16) ? r->m_len_codes[counter - 1] : 0, s); + counter += s; + } + if ((r->m_table_sizes[0] + r->m_table_sizes[1]) != counter) { + TINFL_CR_RETURN_FOREVER(21, TINFL_STATUS_FAILED); + } + TINFL_MEMCPY(r->m_tables[0].m_code_size, r->m_len_codes, + r->m_table_sizes[0]); + TINFL_MEMCPY(r->m_tables[1].m_code_size, + r->m_len_codes + r->m_table_sizes[0], + r->m_table_sizes[1]); + } + } + for (;;) { + mz_uint8 *pSrc; + for (;;) { + if (((pIn_buf_end - pIn_buf_cur) < 4) || + ((pOut_buf_end - pOut_buf_cur) < 2)) { + TINFL_HUFF_DECODE(23, counter, &r->m_tables[0]); + if (counter >= 256) + break; + while (pOut_buf_cur >= pOut_buf_end) { + TINFL_CR_RETURN(24, TINFL_STATUS_HAS_MORE_OUTPUT); + } + *pOut_buf_cur++ = (mz_uint8)counter; + } else { + int sym2; + mz_uint code_len; +#if TINFL_USE_64BIT_BITBUF + if (num_bits < 30) { + bit_buf |= + (((tinfl_bit_buf_t)MZ_READ_LE32(pIn_buf_cur)) << num_bits); + pIn_buf_cur += 4; + num_bits += 32; + } +#else + if (num_bits < 15) { + bit_buf |= + (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits); + pIn_buf_cur += 2; + num_bits += 16; + } +#endif + if ((sym2 = + r->m_tables[0] + .m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= + 0) + code_len = sym2 >> 9; + else { + code_len = TINFL_FAST_LOOKUP_BITS; + do { + sym2 = r->m_tables[0] + .m_tree[~sym2 + ((bit_buf >> code_len++) & 1)]; + } while (sym2 < 0); + } + counter = sym2; + bit_buf >>= code_len; + num_bits -= code_len; + if (counter & 256) + break; + +#if !TINFL_USE_64BIT_BITBUF + if (num_bits < 15) { + bit_buf |= + (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits); + pIn_buf_cur += 2; + num_bits += 16; + } +#endif + if ((sym2 = + r->m_tables[0] + .m_look_up[bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= + 0) + code_len = sym2 >> 9; + else { + code_len = TINFL_FAST_LOOKUP_BITS; + do { + sym2 = r->m_tables[0] + .m_tree[~sym2 + ((bit_buf >> code_len++) & 1)]; + } while (sym2 < 0); + } + bit_buf >>= code_len; + num_bits -= code_len; + + pOut_buf_cur[0] = (mz_uint8)counter; + if (sym2 & 256) { + pOut_buf_cur++; + counter = sym2; + break; + } + pOut_buf_cur[1] = (mz_uint8)sym2; + pOut_buf_cur += 2; + } + } + if ((counter &= 511) == 256) + break; + + num_extra = s_length_extra[counter - 257]; + counter = s_length_base[counter - 257]; + if (num_extra) { + mz_uint extra_bits; + TINFL_GET_BITS(25, extra_bits, num_extra); + counter += extra_bits; + } + + TINFL_HUFF_DECODE(26, dist, &r->m_tables[1]); + num_extra = s_dist_extra[dist]; + dist = s_dist_base[dist]; + if (num_extra) { + mz_uint extra_bits; + TINFL_GET_BITS(27, extra_bits, num_extra); + dist += extra_bits; + } + + dist_from_out_buf_start = pOut_buf_cur - pOut_buf_start; + if ((dist == 0 || dist > dist_from_out_buf_start || + dist_from_out_buf_start == 0) && + (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF)) { + TINFL_CR_RETURN_FOREVER(37, TINFL_STATUS_FAILED); + } + + pSrc = pOut_buf_start + + ((dist_from_out_buf_start - dist) & out_buf_size_mask); + + if ((MZ_MAX(pOut_buf_cur, pSrc) + counter) > pOut_buf_end) { + while (counter--) { + while (pOut_buf_cur >= pOut_buf_end) { + TINFL_CR_RETURN(53, TINFL_STATUS_HAS_MORE_OUTPUT); + } + *pOut_buf_cur++ = + pOut_buf_start[(dist_from_out_buf_start++ - dist) & + out_buf_size_mask]; + } + continue; + } +#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES + else if ((counter >= 9) && (counter <= dist)) { + const mz_uint8 *pSrc_end = pSrc + (counter & ~7); + do { +#ifdef MINIZ_UNALIGNED_USE_MEMCPY + memcpy(pOut_buf_cur, pSrc, sizeof(mz_uint32) * 2); +#else + ((mz_uint32 *)pOut_buf_cur)[0] = ((const mz_uint32 *)pSrc)[0]; + ((mz_uint32 *)pOut_buf_cur)[1] = ((const mz_uint32 *)pSrc)[1]; +#endif + pOut_buf_cur += 8; + } while ((pSrc += 8) < pSrc_end); + if ((counter &= 7) < 3) { + if (counter) { + pOut_buf_cur[0] = pSrc[0]; + if (counter > 1) + pOut_buf_cur[1] = pSrc[1]; + pOut_buf_cur += counter; + } + continue; + } + } +#endif + while (counter > 2) { + pOut_buf_cur[0] = pSrc[0]; + pOut_buf_cur[1] = pSrc[1]; + pOut_buf_cur[2] = pSrc[2]; + pOut_buf_cur += 3; + pSrc += 3; + counter -= 3; + } + if (counter > 0) { + pOut_buf_cur[0] = pSrc[0]; + if (counter > 1) + pOut_buf_cur[1] = pSrc[1]; + pOut_buf_cur += counter; + } + } + } + } while (!(r->m_final & 1)); + + /* Ensure byte alignment and put back any bytes from the bitbuf if we've + * looked ahead too far on gzip, or other Deflate streams followed by + * arbitrary data. */ + /* I'm being super conservative here. A number of simplifications can be made + * to the byte alignment part, and the Adler32 check shouldn't ever need to + * worry about reading from the bitbuf now. */ + TINFL_SKIP_BITS(32, num_bits & 7); + while ((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8)) { + --pIn_buf_cur; + num_bits -= 8; + } + bit_buf &= (tinfl_bit_buf_t)((((mz_uint64)1) << num_bits) - (mz_uint64)1); + MZ_ASSERT(!num_bits); /* if this assert fires then we've read beyond the end + of non-deflate/zlib streams with following data (such + as gzip streams). */ + + if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) { + for (counter = 0; counter < 4; ++counter) { + mz_uint s; + if (num_bits) + TINFL_GET_BITS(41, s, 8); + else + TINFL_GET_BYTE(42, s); + r->m_z_adler32 = (r->m_z_adler32 << 8) | s; + } + } + TINFL_CR_RETURN_FOREVER(34, TINFL_STATUS_DONE); + + TINFL_CR_FINISH + +common_exit: + /* As long as we aren't telling the caller that we NEED more input to make + * forward progress: */ + /* Put back any bytes from the bitbuf in case we've looked ahead too far on + * gzip, or other Deflate streams followed by arbitrary data. */ + /* We need to be very careful here to NOT push back any bytes we definitely + * know we need to make forward progress, though, or we'll lock the caller up + * into an inf loop. */ + if ((status != TINFL_STATUS_NEEDS_MORE_INPUT) && + (status != TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS)) { + while ((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8)) { + --pIn_buf_cur; + num_bits -= 8; + } + } + r->m_num_bits = num_bits; + r->m_bit_buf = + bit_buf & (tinfl_bit_buf_t)((((mz_uint64)1) << num_bits) - (mz_uint64)1); + r->m_dist = dist; + r->m_counter = counter; + r->m_num_extra = num_extra; + r->m_dist_from_out_buf_start = dist_from_out_buf_start; + *pIn_buf_size = pIn_buf_cur - pIn_buf_next; + *pOut_buf_size = pOut_buf_cur - pOut_buf_next; + if ((decomp_flags & + (TINFL_FLAG_PARSE_ZLIB_HEADER | TINFL_FLAG_COMPUTE_ADLER32)) && + (status >= 0)) { + const mz_uint8 *ptr = pOut_buf_next; + size_t buf_len = *pOut_buf_size; + mz_uint32 i, s1 = r->m_check_adler32 & 0xffff, + s2 = r->m_check_adler32 >> 16; + size_t block_len = buf_len % 5552; + while (buf_len) { + for (i = 0; i + 7 < block_len; i += 8, ptr += 8) { + s1 += ptr[0], s2 += s1; + s1 += ptr[1], s2 += s1; + s1 += ptr[2], s2 += s1; + s1 += ptr[3], s2 += s1; + s1 += ptr[4], s2 += s1; + s1 += ptr[5], s2 += s1; + s1 += ptr[6], s2 += s1; + s1 += ptr[7], s2 += s1; + } + for (; i < block_len; ++i) + s1 += *ptr++, s2 += s1; + s1 %= 65521U, s2 %= 65521U; + buf_len -= block_len; + block_len = 5552; + } + r->m_check_adler32 = (s2 << 16) + s1; + if ((status == TINFL_STATUS_DONE) && + (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) && + (r->m_check_adler32 != r->m_z_adler32)) + status = TINFL_STATUS_ADLER32_MISMATCH; + } + return status; +} + +/* Higher level helper functions. */ +void *tinfl_decompress_mem_to_heap(const void *pSrc_buf, size_t src_buf_len, + size_t *pOut_len, int flags) { + tinfl_decompressor decomp; + void *pBuf = NULL, *pNew_buf; + size_t src_buf_ofs = 0, out_buf_capacity = 0; + *pOut_len = 0; + tinfl_init(&decomp); + for (;;) { + size_t src_buf_size = src_buf_len - src_buf_ofs, + dst_buf_size = out_buf_capacity - *pOut_len, new_out_buf_capacity; + tinfl_status status = tinfl_decompress( + &decomp, (const mz_uint8 *)pSrc_buf + src_buf_ofs, &src_buf_size, + (mz_uint8 *)pBuf, pBuf ? (mz_uint8 *)pBuf + *pOut_len : NULL, + &dst_buf_size, + (flags & ~TINFL_FLAG_HAS_MORE_INPUT) | + TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF); + if ((status < 0) || (status == TINFL_STATUS_NEEDS_MORE_INPUT)) { + MZ_FREE(pBuf); + *pOut_len = 0; + return NULL; + } + src_buf_ofs += src_buf_size; + *pOut_len += dst_buf_size; + if (status == TINFL_STATUS_DONE) + break; + new_out_buf_capacity = out_buf_capacity * 2; + if (new_out_buf_capacity < 128) + new_out_buf_capacity = 128; + pNew_buf = MZ_REALLOC(pBuf, new_out_buf_capacity); + if (!pNew_buf) { + MZ_FREE(pBuf); + *pOut_len = 0; + return NULL; + } + pBuf = pNew_buf; + out_buf_capacity = new_out_buf_capacity; + } + return pBuf; +} + +size_t tinfl_decompress_mem_to_mem(void *pOut_buf, size_t out_buf_len, + const void *pSrc_buf, size_t src_buf_len, + int flags) { + tinfl_decompressor decomp; + tinfl_status status; + tinfl_init(&decomp); + status = + tinfl_decompress(&decomp, (const mz_uint8 *)pSrc_buf, &src_buf_len, + (mz_uint8 *)pOut_buf, (mz_uint8 *)pOut_buf, &out_buf_len, + (flags & ~TINFL_FLAG_HAS_MORE_INPUT) | + TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF); + return (status != TINFL_STATUS_DONE) ? TINFL_DECOMPRESS_MEM_TO_MEM_FAILED + : out_buf_len; +} + +int tinfl_decompress_mem_to_callback(const void *pIn_buf, size_t *pIn_buf_size, + tinfl_put_buf_func_ptr pPut_buf_func, + void *pPut_buf_user, int flags) { + int result = 0; + tinfl_decompressor decomp; + mz_uint8 *pDict = (mz_uint8 *)MZ_MALLOC(TINFL_LZ_DICT_SIZE); + size_t in_buf_ofs = 0, dict_ofs = 0; + if (!pDict) + return TINFL_STATUS_FAILED; + tinfl_init(&decomp); + for (;;) { + size_t in_buf_size = *pIn_buf_size - in_buf_ofs, + dst_buf_size = TINFL_LZ_DICT_SIZE - dict_ofs; + tinfl_status status = + tinfl_decompress(&decomp, (const mz_uint8 *)pIn_buf + in_buf_ofs, + &in_buf_size, pDict, pDict + dict_ofs, &dst_buf_size, + (flags & ~(TINFL_FLAG_HAS_MORE_INPUT | + TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF))); + in_buf_ofs += in_buf_size; + if ((dst_buf_size) && + (!(*pPut_buf_func)(pDict + dict_ofs, (int)dst_buf_size, pPut_buf_user))) + break; + if (status != TINFL_STATUS_HAS_MORE_OUTPUT) { + result = (status == TINFL_STATUS_DONE); + break; + } + dict_ofs = (dict_ofs + dst_buf_size) & (TINFL_LZ_DICT_SIZE - 1); + } + MZ_FREE(pDict); + *pIn_buf_size = in_buf_ofs; + return result; +} + +#ifndef MINIZ_NO_MALLOC +tinfl_decompressor *tinfl_decompressor_alloc() { + tinfl_decompressor *pDecomp = + (tinfl_decompressor *)MZ_MALLOC(sizeof(tinfl_decompressor)); + if (pDecomp) + tinfl_init(pDecomp); + return pDecomp; +} + +void tinfl_decompressor_free(tinfl_decompressor *pDecomp) { MZ_FREE(pDecomp); } +#endif + +#ifdef __cplusplus +} +#endif +/************************************************************************** + * + * Copyright 2013-2014 RAD Game Tools and Valve Software + * Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC + * Copyright 2016 Martin Raiber + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + +#ifndef MINIZ_NO_ARCHIVE_APIS + +#ifdef __cplusplus +extern "C" { +#endif + +/* ------------------- .ZIP archive reading */ + +#ifdef MINIZ_NO_STDIO +#define MZ_FILE void * +#else +#include + +#if defined(_MSC_VER) || defined(__MINGW64__) + +#include + +static wchar_t *str2wstr(const char *str) { + size_t len = strlen(str) + 1; + wchar_t *wstr = (wchar_t *)malloc(len * sizeof(wchar_t)); + MultiByteToWideChar(CP_UTF8, 0, str, (int)(len * sizeof(char)), wstr, + (int)len); + return wstr; +} + +static FILE *mz_fopen(const char *pFilename, const char *pMode) { + wchar_t *wFilename = str2wstr(pFilename); + wchar_t *wMode = str2wstr(pMode); + FILE *pFile = _wfopen(wFilename, wMode); + + free(wFilename); + free(wMode); + + return pFile; +} + +static FILE *mz_freopen(const char *pPath, const char *pMode, FILE *pStream) { + wchar_t *wPath = str2wstr(pPath); + wchar_t *wMode = str2wstr(pMode); + FILE *pFile = _wfreopen(wPath, wMode, pStream); + + free(wPath); + free(wMode); + + return pFile; +} + +static int mz_stat(const char *pPath, struct _stat64 *buffer) { + wchar_t *wPath = str2wstr(pPath); + int res = _wstat64(wPath, buffer); + + free(wPath); + + return res; +} + +static int mz_mkdir(const char *pDirname) { + wchar_t *wDirname = str2wstr(pDirname); + int res = _wmkdir(wDirname); + + free(wDirname); + + return res; +} + +#ifndef MINIZ_NO_TIME +#include +#endif +#define MZ_FOPEN mz_fopen +#define MZ_FCLOSE fclose +#define MZ_FREAD fread +#define MZ_FWRITE fwrite +#define MZ_FTELL64 _ftelli64 +#define MZ_FSEEK64 _fseeki64 +#define MZ_FILE_STAT_STRUCT _stat64 +#define MZ_FILE_STAT mz_stat +#define MZ_FFLUSH fflush +#define MZ_FREOPEN mz_freopen +#define MZ_DELETE_FILE remove +#define MZ_MKDIR(d) mz_mkdir(d) +#elif defined(__MINGW32__) +#ifndef MINIZ_NO_TIME +#include +#endif +#define MZ_FOPEN(f, m) fopen(f, m) +#define MZ_FCLOSE fclose +#define MZ_FREAD fread +#define MZ_FWRITE fwrite +#define MZ_FTELL64 ftello64 +#define MZ_FSEEK64 fseeko64 +#define MZ_FILE_STAT_STRUCT _stat +#define MZ_FILE_STAT _stat +#define MZ_FFLUSH fflush +#define MZ_FREOPEN(f, m, s) freopen(f, m, s) +#define MZ_DELETE_FILE remove +#define MZ_MKDIR(d) _mkdir(d) +#elif defined(__TINYC__) +#ifndef MINIZ_NO_TIME +#include +#endif +#define MZ_FOPEN(f, m) fopen(f, m) +#define MZ_FCLOSE fclose +#define MZ_FREAD fread +#define MZ_FWRITE fwrite +#define MZ_FTELL64 ftell +#define MZ_FSEEK64 fseek +#define MZ_FILE_STAT_STRUCT stat +#define MZ_FILE_STAT stat +#define MZ_FFLUSH fflush +#define MZ_FREOPEN(f, m, s) freopen(f, m, s) +#define MZ_DELETE_FILE remove +#define MZ_MKDIR(d) mkdir(d, 0755) +#elif defined(__USE_LARGEFILE64) /* gcc, clang */ +#ifndef MINIZ_NO_TIME +#include +#endif +#define MZ_FOPEN(f, m) fopen64(f, m) +#define MZ_FCLOSE fclose +#define MZ_FREAD fread +#define MZ_FWRITE fwrite +#define MZ_FTELL64 ftello64 +#define MZ_FSEEK64 fseeko64 +#define MZ_FILE_STAT_STRUCT stat64 +#define MZ_FILE_STAT stat64 +#define MZ_FFLUSH fflush +#define MZ_FREOPEN(p, m, s) freopen64(p, m, s) +#define MZ_DELETE_FILE remove +#define MZ_MKDIR(d) mkdir(d, 0755) +#elif defined(__APPLE__) +#ifndef MINIZ_NO_TIME +#include +#endif +#define MZ_FOPEN(f, m) fopen(f, m) +#define MZ_FCLOSE fclose +#define MZ_FREAD fread +#define MZ_FWRITE fwrite +#define MZ_FTELL64 ftello +#define MZ_FSEEK64 fseeko +#define MZ_FILE_STAT_STRUCT stat +#define MZ_FILE_STAT stat +#define MZ_FFLUSH fflush +#define MZ_FREOPEN(p, m, s) freopen(p, m, s) +#define MZ_DELETE_FILE remove +#define MZ_MKDIR(d) mkdir(d, 0755) + +#else +#pragma message( \ + "Using fopen, ftello, fseeko, stat() etc. path for file I/O - this path may not support large files.") +#ifndef MINIZ_NO_TIME +#include +#endif +#define MZ_FOPEN(f, m) fopen(f, m) +#define MZ_FCLOSE fclose +#define MZ_FREAD fread +#define MZ_FWRITE fwrite +#ifdef __STRICT_ANSI__ +#define MZ_FTELL64 ftell +#define MZ_FSEEK64 fseek +#else +#define MZ_FTELL64 ftello +#define MZ_FSEEK64 fseeko +#endif +#define MZ_FILE_STAT_STRUCT stat +#define MZ_FILE_STAT stat +#define MZ_FFLUSH fflush +#define MZ_FREOPEN(f, m, s) freopen(f, m, s) +#define MZ_DELETE_FILE remove +#define MZ_MKDIR(d) mkdir(d, 0755) +#endif /* #ifdef _MSC_VER */ +#endif /* #ifdef MINIZ_NO_STDIO */ + +#define MZ_TOLOWER(c) ((((c) >= 'A') && ((c) <= 'Z')) ? ((c) - 'A' + 'a') : (c)) + +/* Various ZIP archive enums. To completely avoid cross platform compiler + * alignment and platform endian issues, miniz.c doesn't use structs for any of + * this stuff. */ +enum { + /* ZIP archive identifiers and record sizes */ + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG = 0x06054b50, + MZ_ZIP_CENTRAL_DIR_HEADER_SIG = 0x02014b50, + MZ_ZIP_LOCAL_DIR_HEADER_SIG = 0x04034b50, + MZ_ZIP_LOCAL_DIR_HEADER_SIZE = 30, + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE = 46, + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE = 22, + + /* ZIP64 archive identifier and record sizes */ + MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG = 0x06064b50, + MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG = 0x07064b50, + MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE = 56, + MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE = 20, + MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID = 0x0001, + MZ_ZIP_DATA_DESCRIPTOR_ID = 0x08074b50, + MZ_ZIP_DATA_DESCRIPTER_SIZE64 = 24, + MZ_ZIP_DATA_DESCRIPTER_SIZE32 = 16, + + /* Central directory header record offsets */ + MZ_ZIP_CDH_SIG_OFS = 0, + MZ_ZIP_CDH_VERSION_MADE_BY_OFS = 4, + MZ_ZIP_CDH_VERSION_NEEDED_OFS = 6, + MZ_ZIP_CDH_BIT_FLAG_OFS = 8, + MZ_ZIP_CDH_METHOD_OFS = 10, + MZ_ZIP_CDH_FILE_TIME_OFS = 12, + MZ_ZIP_CDH_FILE_DATE_OFS = 14, + MZ_ZIP_CDH_CRC32_OFS = 16, + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS = 20, + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS = 24, + MZ_ZIP_CDH_FILENAME_LEN_OFS = 28, + MZ_ZIP_CDH_EXTRA_LEN_OFS = 30, + MZ_ZIP_CDH_COMMENT_LEN_OFS = 32, + MZ_ZIP_CDH_DISK_START_OFS = 34, + MZ_ZIP_CDH_INTERNAL_ATTR_OFS = 36, + MZ_ZIP_CDH_EXTERNAL_ATTR_OFS = 38, + MZ_ZIP_CDH_LOCAL_HEADER_OFS = 42, + + /* Local directory header offsets */ + MZ_ZIP_LDH_SIG_OFS = 0, + MZ_ZIP_LDH_VERSION_NEEDED_OFS = 4, + MZ_ZIP_LDH_BIT_FLAG_OFS = 6, + MZ_ZIP_LDH_METHOD_OFS = 8, + MZ_ZIP_LDH_FILE_TIME_OFS = 10, + MZ_ZIP_LDH_FILE_DATE_OFS = 12, + MZ_ZIP_LDH_CRC32_OFS = 14, + MZ_ZIP_LDH_COMPRESSED_SIZE_OFS = 18, + MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS = 22, + MZ_ZIP_LDH_FILENAME_LEN_OFS = 26, + MZ_ZIP_LDH_EXTRA_LEN_OFS = 28, + MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR = 1 << 3, + + /* End of central directory offsets */ + MZ_ZIP_ECDH_SIG_OFS = 0, + MZ_ZIP_ECDH_NUM_THIS_DISK_OFS = 4, + MZ_ZIP_ECDH_NUM_DISK_CDIR_OFS = 6, + MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS = 8, + MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS = 10, + MZ_ZIP_ECDH_CDIR_SIZE_OFS = 12, + MZ_ZIP_ECDH_CDIR_OFS_OFS = 16, + MZ_ZIP_ECDH_COMMENT_SIZE_OFS = 20, + + /* ZIP64 End of central directory locator offsets */ + MZ_ZIP64_ECDL_SIG_OFS = 0, /* 4 bytes */ + MZ_ZIP64_ECDL_NUM_DISK_CDIR_OFS = 4, /* 4 bytes */ + MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS = 8, /* 8 bytes */ + MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS = 16, /* 4 bytes */ + + /* ZIP64 End of central directory header offsets */ + MZ_ZIP64_ECDH_SIG_OFS = 0, /* 4 bytes */ + MZ_ZIP64_ECDH_SIZE_OF_RECORD_OFS = 4, /* 8 bytes */ + MZ_ZIP64_ECDH_VERSION_MADE_BY_OFS = 12, /* 2 bytes */ + MZ_ZIP64_ECDH_VERSION_NEEDED_OFS = 14, /* 2 bytes */ + MZ_ZIP64_ECDH_NUM_THIS_DISK_OFS = 16, /* 4 bytes */ + MZ_ZIP64_ECDH_NUM_DISK_CDIR_OFS = 20, /* 4 bytes */ + MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS = 24, /* 8 bytes */ + MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS = 32, /* 8 bytes */ + MZ_ZIP64_ECDH_CDIR_SIZE_OFS = 40, /* 8 bytes */ + MZ_ZIP64_ECDH_CDIR_OFS_OFS = 48, /* 8 bytes */ + MZ_ZIP_VERSION_MADE_BY_DOS_FILESYSTEM_ID = 0, + MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG = 0x10, + MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED = 1, + MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG = 32, + MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION = 64, + MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_LOCAL_DIR_IS_MASKED = 8192, + MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8 = 1 << 11 +}; + +typedef struct { + void *m_p; + size_t m_size, m_capacity; + mz_uint m_element_size; +} mz_zip_array; + +struct mz_zip_internal_state_tag { + mz_zip_array m_central_dir; + mz_zip_array m_central_dir_offsets; + mz_zip_array m_sorted_central_dir_offsets; + + /* The flags passed in when the archive is initially opened. */ + uint32_t m_init_flags; + + /* MZ_TRUE if the archive has a zip64 end of central directory headers, etc. + */ + mz_bool m_zip64; + + /* MZ_TRUE if we found zip64 extended info in the central directory (m_zip64 + * will also be slammed to true too, even if we didn't find a zip64 end of + * central dir header, etc.) */ + mz_bool m_zip64_has_extended_info_fields; + + /* These fields are used by the file, FILE, memory, and memory/heap read/write + * helpers. */ + MZ_FILE *m_pFile; + mz_uint64 m_file_archive_start_ofs; + + void *m_pMem; + size_t m_mem_size; + size_t m_mem_capacity; +}; + +#define MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(array_ptr, element_size) \ + (array_ptr)->m_element_size = element_size + +#if defined(DEBUG) || defined(_DEBUG) +static MZ_FORCEINLINE mz_uint +mz_zip_array_range_check(const mz_zip_array *pArray, mz_uint index) { + MZ_ASSERT(index < pArray->m_size); + return index; +} +#define MZ_ZIP_ARRAY_ELEMENT(array_ptr, element_type, index) \ + ((element_type *)((array_ptr) \ + ->m_p))[mz_zip_array_range_check(array_ptr, index)] +#else +#define MZ_ZIP_ARRAY_ELEMENT(array_ptr, element_type, index) \ + ((element_type *)((array_ptr)->m_p))[index] +#endif + +static MZ_FORCEINLINE void mz_zip_array_init(mz_zip_array *pArray, + mz_uint32 element_size) { + memset(pArray, 0, sizeof(mz_zip_array)); + pArray->m_element_size = element_size; +} + +static MZ_FORCEINLINE void mz_zip_array_clear(mz_zip_archive *pZip, + mz_zip_array *pArray) { + pZip->m_pFree(pZip->m_pAlloc_opaque, pArray->m_p); + memset(pArray, 0, sizeof(mz_zip_array)); +} + +static mz_bool mz_zip_array_ensure_capacity(mz_zip_archive *pZip, + mz_zip_array *pArray, + size_t min_new_capacity, + mz_uint growing) { + void *pNew_p; + size_t new_capacity = min_new_capacity; + MZ_ASSERT(pArray->m_element_size); + if (pArray->m_capacity >= min_new_capacity) + return MZ_TRUE; + if (growing) { + new_capacity = MZ_MAX(1, pArray->m_capacity); + while (new_capacity < min_new_capacity) + new_capacity *= 2; + } + if (NULL == (pNew_p = pZip->m_pRealloc(pZip->m_pAlloc_opaque, pArray->m_p, + pArray->m_element_size, new_capacity))) + return MZ_FALSE; + pArray->m_p = pNew_p; + pArray->m_capacity = new_capacity; + return MZ_TRUE; +} + +static MZ_FORCEINLINE mz_bool mz_zip_array_reserve(mz_zip_archive *pZip, + mz_zip_array *pArray, + size_t new_capacity, + mz_uint growing) { + if (new_capacity > pArray->m_capacity) { + if (!mz_zip_array_ensure_capacity(pZip, pArray, new_capacity, growing)) + return MZ_FALSE; + } + return MZ_TRUE; +} + +static MZ_FORCEINLINE mz_bool mz_zip_array_resize(mz_zip_archive *pZip, + mz_zip_array *pArray, + size_t new_size, + mz_uint growing) { + if (new_size > pArray->m_capacity) { + if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing)) + return MZ_FALSE; + } + pArray->m_size = new_size; + return MZ_TRUE; +} + +static MZ_FORCEINLINE mz_bool mz_zip_array_ensure_room(mz_zip_archive *pZip, + mz_zip_array *pArray, + size_t n) { + return mz_zip_array_reserve(pZip, pArray, pArray->m_size + n, MZ_TRUE); +} + +static MZ_FORCEINLINE mz_bool mz_zip_array_push_back(mz_zip_archive *pZip, + mz_zip_array *pArray, + const void *pElements, + size_t n) { + size_t orig_size = pArray->m_size; + if (!mz_zip_array_resize(pZip, pArray, orig_size + n, MZ_TRUE)) + return MZ_FALSE; + if (n > 0) + memcpy((mz_uint8 *)pArray->m_p + orig_size * pArray->m_element_size, + pElements, n * pArray->m_element_size); + return MZ_TRUE; +} + +#ifndef MINIZ_NO_TIME +static MZ_TIME_T mz_zip_dos_to_time_t(int dos_time, int dos_date) { + struct tm tm; + memset(&tm, 0, sizeof(tm)); + tm.tm_isdst = -1; + tm.tm_year = ((dos_date >> 9) & 127) + 1980 - 1900; + tm.tm_mon = ((dos_date >> 5) & 15) - 1; + tm.tm_mday = dos_date & 31; + tm.tm_hour = (dos_time >> 11) & 31; + tm.tm_min = (dos_time >> 5) & 63; + tm.tm_sec = (dos_time << 1) & 62; + return mktime(&tm); +} + +#ifndef MINIZ_NO_ARCHIVE_WRITING_APIS +static void mz_zip_time_t_to_dos_time(MZ_TIME_T time, mz_uint16 *pDOS_time, + mz_uint16 *pDOS_date) { +#ifdef _MSC_VER + struct tm tm_struct; + struct tm *tm = &tm_struct; + errno_t err = localtime_s(tm, &time); + if (err) { + *pDOS_date = 0; + *pDOS_time = 0; + return; + } +#else + struct tm *tm = localtime(&time); +#endif /* #ifdef _MSC_VER */ + + *pDOS_time = (mz_uint16)(((tm->tm_hour) << 11) + ((tm->tm_min) << 5) + + ((tm->tm_sec) >> 1)); + *pDOS_date = (mz_uint16)(((tm->tm_year + 1900 - 1980) << 9) + + ((tm->tm_mon + 1) << 5) + tm->tm_mday); +} +#endif /* MINIZ_NO_ARCHIVE_WRITING_APIS */ + +#ifndef MINIZ_NO_STDIO +#ifndef MINIZ_NO_ARCHIVE_WRITING_APIS +static mz_bool mz_zip_get_file_modified_time(const char *pFilename, + MZ_TIME_T *pTime) { + struct MZ_FILE_STAT_STRUCT file_stat; + + /* On Linux with x86 glibc, this call will fail on large files (I think >= + * 0x80000000 bytes) unless you compiled with _LARGEFILE64_SOURCE. Argh. */ + if (MZ_FILE_STAT(pFilename, &file_stat) != 0) + return MZ_FALSE; + + *pTime = file_stat.st_mtime; + + return MZ_TRUE; +} +#endif /* #ifndef MINIZ_NO_ARCHIVE_WRITING_APIS*/ + +static mz_bool mz_zip_set_file_times(const char *pFilename, + MZ_TIME_T access_time, + MZ_TIME_T modified_time) { + struct utimbuf t; + + memset(&t, 0, sizeof(t)); + t.actime = access_time; + t.modtime = modified_time; + + return !utime(pFilename, &t); +} +#endif /* #ifndef MINIZ_NO_STDIO */ +#endif /* #ifndef MINIZ_NO_TIME */ + +static MZ_FORCEINLINE mz_bool mz_zip_set_error(mz_zip_archive *pZip, + mz_zip_error err_num) { + if (pZip) + pZip->m_last_error = err_num; + return MZ_FALSE; +} + +static mz_bool mz_zip_reader_init_internal(mz_zip_archive *pZip, + mz_uint flags) { + (void)flags; + if ((!pZip) || (pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_INVALID)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + if (!pZip->m_pAlloc) + pZip->m_pAlloc = miniz_def_alloc_func; + if (!pZip->m_pFree) + pZip->m_pFree = miniz_def_free_func; + if (!pZip->m_pRealloc) + pZip->m_pRealloc = miniz_def_realloc_func; + + pZip->m_archive_size = 0; + pZip->m_central_directory_file_ofs = 0; + pZip->m_total_files = 0; + pZip->m_last_error = MZ_ZIP_NO_ERROR; + + if (NULL == (pZip->m_pState = (mz_zip_internal_state *)pZip->m_pAlloc( + pZip->m_pAlloc_opaque, 1, sizeof(mz_zip_internal_state)))) + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + + memset(pZip->m_pState, 0, sizeof(mz_zip_internal_state)); + MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir, + sizeof(mz_uint8)); + MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir_offsets, + sizeof(mz_uint32)); + MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_sorted_central_dir_offsets, + sizeof(mz_uint32)); + pZip->m_pState->m_init_flags = flags; + pZip->m_pState->m_zip64 = MZ_FALSE; + pZip->m_pState->m_zip64_has_extended_info_fields = MZ_FALSE; + + pZip->m_zip_mode = MZ_ZIP_MODE_READING; + + return MZ_TRUE; +} + +static MZ_FORCEINLINE mz_bool +mz_zip_reader_filename_less(const mz_zip_array *pCentral_dir_array, + const mz_zip_array *pCentral_dir_offsets, + mz_uint l_index, mz_uint r_index) { + const mz_uint8 *pL = &MZ_ZIP_ARRAY_ELEMENT( + pCentral_dir_array, mz_uint8, + MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_offsets, mz_uint32, + l_index)), + *pE; + const mz_uint8 *pR = &MZ_ZIP_ARRAY_ELEMENT( + pCentral_dir_array, mz_uint8, + MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_offsets, mz_uint32, r_index)); + mz_uint l_len = MZ_READ_LE16(pL + MZ_ZIP_CDH_FILENAME_LEN_OFS), + r_len = MZ_READ_LE16(pR + MZ_ZIP_CDH_FILENAME_LEN_OFS); + mz_uint8 l = 0, r = 0; + pL += MZ_ZIP_CENTRAL_DIR_HEADER_SIZE; + pR += MZ_ZIP_CENTRAL_DIR_HEADER_SIZE; + pE = pL + MZ_MIN(l_len, r_len); + while (pL < pE) { + if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR))) + break; + pL++; + pR++; + } + return (pL == pE) ? (l_len < r_len) : (l < r); +} + +#define MZ_SWAP_UINT32(a, b) \ + do { \ + mz_uint32 t = a; \ + a = b; \ + b = t; \ + } \ + MZ_MACRO_END + +/* Heap sort of lowercased filenames, used to help accelerate plain central + * directory searches by mz_zip_reader_locate_file(). (Could also use qsort(), + * but it could allocate memory.) */ +static void +mz_zip_reader_sort_central_dir_offsets_by_filename(mz_zip_archive *pZip) { + mz_zip_internal_state *pState = pZip->m_pState; + const mz_zip_array *pCentral_dir_offsets = &pState->m_central_dir_offsets; + const mz_zip_array *pCentral_dir = &pState->m_central_dir; + mz_uint32 *pIndices; + mz_uint32 start, end; + const mz_uint32 size = pZip->m_total_files; + + if (size <= 1U) + return; + + pIndices = &MZ_ZIP_ARRAY_ELEMENT(&pState->m_sorted_central_dir_offsets, + mz_uint32, 0); + + start = (size - 2U) >> 1U; + for (;;) { + mz_uint64 child, root = start; + for (;;) { + if ((child = (root << 1U) + 1U) >= size) + break; + child += (((child + 1U) < size) && + (mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, + pIndices[child], + pIndices[child + 1U]))); + if (!mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, + pIndices[root], pIndices[child])) + break; + MZ_SWAP_UINT32(pIndices[root], pIndices[child]); + root = child; + } + if (!start) + break; + start--; + } + + end = size - 1; + while (end > 0) { + mz_uint64 child, root = 0; + MZ_SWAP_UINT32(pIndices[end], pIndices[0]); + for (;;) { + if ((child = (root << 1U) + 1U) >= end) + break; + child += + (((child + 1U) < end) && + mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, + pIndices[child], pIndices[child + 1U])); + if (!mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, + pIndices[root], pIndices[child])) + break; + MZ_SWAP_UINT32(pIndices[root], pIndices[child]); + root = child; + } + end--; + } +} + +static mz_bool mz_zip_reader_locate_header_sig(mz_zip_archive *pZip, + mz_uint32 record_sig, + mz_uint32 record_size, + mz_int64 *pOfs) { + mz_int64 cur_file_ofs; + mz_uint32 buf_u32[4096 / sizeof(mz_uint32)]; + mz_uint8 *pBuf = (mz_uint8 *)buf_u32; + + /* Basic sanity checks - reject files which are too small */ + if (pZip->m_archive_size < record_size) + return MZ_FALSE; + + /* Find the record by scanning the file from the end towards the beginning. */ + cur_file_ofs = + MZ_MAX((mz_int64)pZip->m_archive_size - (mz_int64)sizeof(buf_u32), 0); + for (;;) { + int i, + n = (int)MZ_MIN(sizeof(buf_u32), pZip->m_archive_size - cur_file_ofs); + + if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf, n) != (mz_uint)n) + return MZ_FALSE; + + for (i = n - 4; i >= 0; --i) { + mz_uint s = MZ_READ_LE32(pBuf + i); + if (s == record_sig) { + if ((pZip->m_archive_size - (cur_file_ofs + i)) >= record_size) + break; + } + } + + if (i >= 0) { + cur_file_ofs += i; + break; + } + + /* Give up if we've searched the entire file, or we've gone back "too far" + * (~64kb) */ + if ((!cur_file_ofs) || ((pZip->m_archive_size - cur_file_ofs) >= + (MZ_UINT16_MAX + record_size))) + return MZ_FALSE; + + cur_file_ofs = MZ_MAX(cur_file_ofs - (sizeof(buf_u32) - 3), 0); + } + + *pOfs = cur_file_ofs; + return MZ_TRUE; +} + +static mz_bool mz_zip_reader_read_central_dir(mz_zip_archive *pZip, + mz_uint flags) { + mz_uint cdir_size = 0, cdir_entries_on_this_disk = 0, num_this_disk = 0, + cdir_disk_index = 0; + mz_uint64 cdir_ofs = 0; + mz_int64 cur_file_ofs = 0; + const mz_uint8 *p; + + mz_uint32 buf_u32[4096 / sizeof(mz_uint32)]; + mz_uint8 *pBuf = (mz_uint8 *)buf_u32; + mz_bool sort_central_dir = + ((flags & MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY) == 0); + mz_uint32 zip64_end_of_central_dir_locator_u32 + [(MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE + sizeof(mz_uint32) - 1) / + sizeof(mz_uint32)]; + mz_uint8 *pZip64_locator = (mz_uint8 *)zip64_end_of_central_dir_locator_u32; + + mz_uint32 zip64_end_of_central_dir_header_u32 + [(MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / + sizeof(mz_uint32)]; + mz_uint8 *pZip64_end_of_central_dir = + (mz_uint8 *)zip64_end_of_central_dir_header_u32; + + mz_uint64 zip64_end_of_central_dir_ofs = 0; + + /* Basic sanity checks - reject files which are too small, and check the first + * 4 bytes of the file to make sure a local header is there. */ + if (pZip->m_archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) + return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE); + + if (!mz_zip_reader_locate_header_sig( + pZip, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG, + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE, &cur_file_ofs)) + return mz_zip_set_error(pZip, MZ_ZIP_FAILED_FINDING_CENTRAL_DIR); + + /* Read and verify the end of central directory record. */ + if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf, + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) != + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + + if (MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_SIG_OFS) != + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG) + return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE); + + if (cur_file_ofs >= (MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE + + MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE)) { + if (pZip->m_pRead(pZip->m_pIO_opaque, + cur_file_ofs - MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE, + pZip64_locator, + MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE) == + MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE) { + if (MZ_READ_LE32(pZip64_locator + MZ_ZIP64_ECDL_SIG_OFS) == + MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG) { + zip64_end_of_central_dir_ofs = MZ_READ_LE64( + pZip64_locator + MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS); + if (zip64_end_of_central_dir_ofs > + (pZip->m_archive_size - MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE)) + return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE); + + if (pZip->m_pRead(pZip->m_pIO_opaque, zip64_end_of_central_dir_ofs, + pZip64_end_of_central_dir, + MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) == + MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) { + if (MZ_READ_LE32(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_SIG_OFS) == + MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG) { + pZip->m_pState->m_zip64 = MZ_TRUE; + } + } + } + } + } + + pZip->m_total_files = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS); + cdir_entries_on_this_disk = + MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS); + num_this_disk = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_NUM_THIS_DISK_OFS); + cdir_disk_index = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_NUM_DISK_CDIR_OFS); + cdir_size = MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_CDIR_SIZE_OFS); + cdir_ofs = MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_CDIR_OFS_OFS); + + if (pZip->m_pState->m_zip64) { + mz_uint32 zip64_total_num_of_disks = + MZ_READ_LE32(pZip64_locator + MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS); + mz_uint64 zip64_cdir_total_entries = MZ_READ_LE64( + pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS); + mz_uint64 zip64_cdir_total_entries_on_this_disk = MZ_READ_LE64( + pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS); + mz_uint64 zip64_size_of_end_of_central_dir_record = MZ_READ_LE64( + pZip64_end_of_central_dir + MZ_ZIP64_ECDH_SIZE_OF_RECORD_OFS); + mz_uint64 zip64_size_of_central_directory = + MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_SIZE_OFS); + + if (zip64_size_of_end_of_central_dir_record < + (MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE - 12)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + if (zip64_total_num_of_disks != 1U) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK); + + /* Check for miniz's practical limits */ + if (zip64_cdir_total_entries > MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); + + pZip->m_total_files = (mz_uint32)zip64_cdir_total_entries; + + if (zip64_cdir_total_entries_on_this_disk > MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); + + cdir_entries_on_this_disk = + (mz_uint32)zip64_cdir_total_entries_on_this_disk; + + /* Check for miniz's current practical limits (sorry, this should be enough + * for millions of files) */ + if (zip64_size_of_central_directory > MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE); + + cdir_size = (mz_uint32)zip64_size_of_central_directory; + + num_this_disk = MZ_READ_LE32(pZip64_end_of_central_dir + + MZ_ZIP64_ECDH_NUM_THIS_DISK_OFS); + + cdir_disk_index = MZ_READ_LE32(pZip64_end_of_central_dir + + MZ_ZIP64_ECDH_NUM_DISK_CDIR_OFS); + + cdir_ofs = + MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_OFS_OFS); + } + + if (pZip->m_total_files != cdir_entries_on_this_disk) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK); + + if (((num_this_disk | cdir_disk_index) != 0) && + ((num_this_disk != 1) || (cdir_disk_index != 1))) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK); + + if (cdir_size < pZip->m_total_files * MZ_ZIP_CENTRAL_DIR_HEADER_SIZE) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + if ((cdir_ofs + (mz_uint64)cdir_size) > pZip->m_archive_size) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + pZip->m_central_directory_file_ofs = cdir_ofs; + + if (pZip->m_total_files) { + mz_uint i, n; + /* Read the entire central directory into a heap block, and allocate another + * heap block to hold the unsorted central dir file record offsets, and + * possibly another to hold the sorted indices. */ + if ((!mz_zip_array_resize(pZip, &pZip->m_pState->m_central_dir, cdir_size, + MZ_FALSE)) || + (!mz_zip_array_resize(pZip, &pZip->m_pState->m_central_dir_offsets, + pZip->m_total_files, MZ_FALSE))) + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + + if (sort_central_dir) { + if (!mz_zip_array_resize(pZip, + &pZip->m_pState->m_sorted_central_dir_offsets, + pZip->m_total_files, MZ_FALSE)) + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + } + + if (pZip->m_pRead(pZip->m_pIO_opaque, cdir_ofs, + pZip->m_pState->m_central_dir.m_p, + cdir_size) != cdir_size) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + + /* Now create an index into the central directory file records, do some + * basic sanity checking on each record */ + p = (const mz_uint8 *)pZip->m_pState->m_central_dir.m_p; + for (n = cdir_size, i = 0; i < pZip->m_total_files; ++i) { + mz_uint total_header_size, disk_index, bit_flags, filename_size, + ext_data_size; + mz_uint64 comp_size, decomp_size, local_header_ofs; + + if ((n < MZ_ZIP_CENTRAL_DIR_HEADER_SIZE) || + (MZ_READ_LE32(p) != MZ_ZIP_CENTRAL_DIR_HEADER_SIG)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets, mz_uint32, + i) = + (mz_uint32)(p - (const mz_uint8 *)pZip->m_pState->m_central_dir.m_p); + + if (sort_central_dir) + MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_sorted_central_dir_offsets, + mz_uint32, i) = i; + + comp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS); + decomp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS); + local_header_ofs = MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS); + filename_size = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS); + ext_data_size = MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS); + + if ((!pZip->m_pState->m_zip64_has_extended_info_fields) && + (ext_data_size) && + (MZ_MAX(MZ_MAX(comp_size, decomp_size), local_header_ofs) == + MZ_UINT32_MAX)) { + /* Attempt to find zip64 extended information field in the entry's extra + * data */ + mz_uint32 extra_size_remaining = ext_data_size; + + if (extra_size_remaining) { + const mz_uint8 *pExtra_data; + void *buf = NULL; + + if (MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size + ext_data_size > + n) { + buf = MZ_MALLOC(ext_data_size); + if (buf == NULL) + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + + if (pZip->m_pRead(pZip->m_pIO_opaque, + cdir_ofs + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + + filename_size, + buf, ext_data_size) != ext_data_size) { + MZ_FREE(buf); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + } + + pExtra_data = (mz_uint8 *)buf; + } else { + pExtra_data = p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size; + } + + do { + mz_uint32 field_id; + mz_uint32 field_data_size; + + if (extra_size_remaining < (sizeof(mz_uint16) * 2)) { + MZ_FREE(buf); + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + } + + field_id = MZ_READ_LE16(pExtra_data); + field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16)); + + if ((field_data_size + sizeof(mz_uint16) * 2) > + extra_size_remaining) { + MZ_FREE(buf); + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + } + + if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID) { + /* Ok, the archive didn't have any zip64 headers but it uses a + * zip64 extended information field so mark it as zip64 anyway + * (this can occur with infozip's zip util when it reads + * compresses files from stdin). */ + pZip->m_pState->m_zip64 = MZ_TRUE; + pZip->m_pState->m_zip64_has_extended_info_fields = MZ_TRUE; + break; + } + + pExtra_data += sizeof(mz_uint16) * 2 + field_data_size; + extra_size_remaining = + extra_size_remaining - sizeof(mz_uint16) * 2 - field_data_size; + } while (extra_size_remaining); + + MZ_FREE(buf); + } + } + + /* I've seen archives that aren't marked as zip64 that uses zip64 ext + * data, argh */ + if ((comp_size != MZ_UINT32_MAX) && (decomp_size != MZ_UINT32_MAX)) { + if (((!MZ_READ_LE32(p + MZ_ZIP_CDH_METHOD_OFS)) && + (decomp_size != comp_size)) || + (decomp_size && !comp_size)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + } + + disk_index = MZ_READ_LE16(p + MZ_ZIP_CDH_DISK_START_OFS); + if ((disk_index == MZ_UINT16_MAX) || + ((disk_index != num_this_disk) && (disk_index != 1))) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK); + + if (comp_size != MZ_UINT32_MAX) { + if (((mz_uint64)MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS) + + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + comp_size) > pZip->m_archive_size) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + } + + bit_flags = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS); + if (bit_flags & MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_LOCAL_DIR_IS_MASKED) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION); + + if ((total_header_size = MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + + MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS) + + MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS) + + MZ_READ_LE16(p + MZ_ZIP_CDH_COMMENT_LEN_OFS)) > + n) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + n -= total_header_size; + p += total_header_size; + } + } + + if (sort_central_dir) + mz_zip_reader_sort_central_dir_offsets_by_filename(pZip); + + return MZ_TRUE; +} + +void mz_zip_zero_struct(mz_zip_archive *pZip) { + if (pZip) + MZ_CLEAR_OBJ(*pZip); +} + +static mz_bool mz_zip_reader_end_internal(mz_zip_archive *pZip, + mz_bool set_last_error) { + mz_bool status = MZ_TRUE; + + if (!pZip) + return MZ_FALSE; + + if ((!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || + (pZip->m_zip_mode != MZ_ZIP_MODE_READING)) { + if (set_last_error) + pZip->m_last_error = MZ_ZIP_INVALID_PARAMETER; + + return MZ_FALSE; + } + + if (pZip->m_pState) { + mz_zip_internal_state *pState = pZip->m_pState; + pZip->m_pState = NULL; + + mz_zip_array_clear(pZip, &pState->m_central_dir); + mz_zip_array_clear(pZip, &pState->m_central_dir_offsets); + mz_zip_array_clear(pZip, &pState->m_sorted_central_dir_offsets); + +#ifndef MINIZ_NO_STDIO + if (pState->m_pFile) { + if (pZip->m_zip_type == MZ_ZIP_TYPE_FILE) { + if (MZ_FCLOSE(pState->m_pFile) == EOF) { + if (set_last_error) + pZip->m_last_error = MZ_ZIP_FILE_CLOSE_FAILED; + status = MZ_FALSE; + } + } + pState->m_pFile = NULL; + } +#endif /* #ifndef MINIZ_NO_STDIO */ + + pZip->m_pFree(pZip->m_pAlloc_opaque, pState); + } + pZip->m_zip_mode = MZ_ZIP_MODE_INVALID; + + return status; +} + +mz_bool mz_zip_reader_end(mz_zip_archive *pZip) { + return mz_zip_reader_end_internal(pZip, MZ_TRUE); +} +mz_bool mz_zip_reader_init(mz_zip_archive *pZip, mz_uint64 size, + mz_uint flags) { + if ((!pZip) || (!pZip->m_pRead)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + if (!mz_zip_reader_init_internal(pZip, flags)) + return MZ_FALSE; + + pZip->m_zip_type = MZ_ZIP_TYPE_USER; + pZip->m_archive_size = size; + + if (!mz_zip_reader_read_central_dir(pZip, flags)) { + mz_zip_reader_end_internal(pZip, MZ_FALSE); + return MZ_FALSE; + } + + return MZ_TRUE; +} + +static size_t mz_zip_mem_read_func(void *pOpaque, mz_uint64 file_ofs, + void *pBuf, size_t n) { + mz_zip_archive *pZip = (mz_zip_archive *)pOpaque; + size_t s = (file_ofs >= pZip->m_archive_size) + ? 0 + : (size_t)MZ_MIN(pZip->m_archive_size - file_ofs, n); + memcpy(pBuf, (const mz_uint8 *)pZip->m_pState->m_pMem + file_ofs, s); + return s; +} + +mz_bool mz_zip_reader_init_mem(mz_zip_archive *pZip, const void *pMem, + size_t size, mz_uint flags) { + if (!pMem) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + if (size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) + return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE); + + if (!mz_zip_reader_init_internal(pZip, flags)) + return MZ_FALSE; + + pZip->m_zip_type = MZ_ZIP_TYPE_MEMORY; + pZip->m_archive_size = size; + pZip->m_pRead = mz_zip_mem_read_func; + pZip->m_pIO_opaque = pZip; + pZip->m_pNeeds_keepalive = NULL; + +#ifdef __cplusplus + pZip->m_pState->m_pMem = const_cast(pMem); +#else + pZip->m_pState->m_pMem = (void *)pMem; +#endif + + pZip->m_pState->m_mem_size = size; + + if (!mz_zip_reader_read_central_dir(pZip, flags)) { + mz_zip_reader_end_internal(pZip, MZ_FALSE); + return MZ_FALSE; + } + + return MZ_TRUE; +} + +#ifndef MINIZ_NO_STDIO +static size_t mz_zip_file_read_func(void *pOpaque, mz_uint64 file_ofs, + void *pBuf, size_t n) { + mz_zip_archive *pZip = (mz_zip_archive *)pOpaque; + mz_int64 cur_ofs = MZ_FTELL64(pZip->m_pState->m_pFile); + + file_ofs += pZip->m_pState->m_file_archive_start_ofs; + + if (((mz_int64)file_ofs < 0) || + (((cur_ofs != (mz_int64)file_ofs)) && + (MZ_FSEEK64(pZip->m_pState->m_pFile, (mz_int64)file_ofs, SEEK_SET)))) + return 0; + + return MZ_FREAD(pBuf, 1, n, pZip->m_pState->m_pFile); +} + +mz_bool mz_zip_reader_init_file(mz_zip_archive *pZip, const char *pFilename, + mz_uint32 flags) { + return mz_zip_reader_init_file_v2(pZip, pFilename, flags, 0, 0); +} + +mz_bool mz_zip_reader_init_file_v2(mz_zip_archive *pZip, const char *pFilename, + mz_uint flags, mz_uint64 file_start_ofs, + mz_uint64 archive_size) { + mz_uint64 file_size; + MZ_FILE *pFile; + + if ((!pZip) || (!pFilename) || + ((archive_size) && + (archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE))) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + pFile = MZ_FOPEN(pFilename, "rb"); + if (!pFile) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED); + + file_size = archive_size; + if (!file_size) { + if (MZ_FSEEK64(pFile, 0, SEEK_END)) { + MZ_FCLOSE(pFile); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_SEEK_FAILED); + } + + file_size = MZ_FTELL64(pFile); + } + + /* TODO: Better sanity check archive_size and the # of actual remaining bytes + */ + + if (file_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) { + MZ_FCLOSE(pFile); + return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE); + } + + if (!mz_zip_reader_init_internal(pZip, flags)) { + MZ_FCLOSE(pFile); + return MZ_FALSE; + } + + pZip->m_zip_type = MZ_ZIP_TYPE_FILE; + pZip->m_pRead = mz_zip_file_read_func; + pZip->m_pIO_opaque = pZip; + pZip->m_pState->m_pFile = pFile; + pZip->m_archive_size = file_size; + pZip->m_pState->m_file_archive_start_ofs = file_start_ofs; + + if (!mz_zip_reader_read_central_dir(pZip, flags)) { + mz_zip_reader_end_internal(pZip, MZ_FALSE); + return MZ_FALSE; + } + + return MZ_TRUE; +} + +mz_bool mz_zip_reader_init_cfile(mz_zip_archive *pZip, MZ_FILE *pFile, + mz_uint64 archive_size, mz_uint flags) { + mz_uint64 cur_file_ofs; + + if ((!pZip) || (!pFile)) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED); + + cur_file_ofs = MZ_FTELL64(pFile); + + if (!archive_size) { + if (MZ_FSEEK64(pFile, 0, SEEK_END)) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_SEEK_FAILED); + + archive_size = MZ_FTELL64(pFile) - cur_file_ofs; + + if (archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) + return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE); + } + + if (!mz_zip_reader_init_internal(pZip, flags)) + return MZ_FALSE; + + pZip->m_zip_type = MZ_ZIP_TYPE_CFILE; + pZip->m_pRead = mz_zip_file_read_func; + + pZip->m_pIO_opaque = pZip; + pZip->m_pState->m_pFile = pFile; + pZip->m_archive_size = archive_size; + pZip->m_pState->m_file_archive_start_ofs = cur_file_ofs; + + if (!mz_zip_reader_read_central_dir(pZip, flags)) { + mz_zip_reader_end_internal(pZip, MZ_FALSE); + return MZ_FALSE; + } + + return MZ_TRUE; +} + +#endif /* #ifndef MINIZ_NO_STDIO */ + +static MZ_FORCEINLINE const mz_uint8 *mz_zip_get_cdh(mz_zip_archive *pZip, + mz_uint file_index) { + if ((!pZip) || (!pZip->m_pState) || (file_index >= pZip->m_total_files)) + return NULL; + return &MZ_ZIP_ARRAY_ELEMENT( + &pZip->m_pState->m_central_dir, mz_uint8, + MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets, mz_uint32, + file_index)); +} + +mz_bool mz_zip_reader_is_file_encrypted(mz_zip_archive *pZip, + mz_uint file_index) { + mz_uint m_bit_flag; + const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index); + if (!p) { + mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + return MZ_FALSE; + } + + m_bit_flag = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS); + return (m_bit_flag & + (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | + MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION)) != 0; +} + +mz_bool mz_zip_reader_is_file_supported(mz_zip_archive *pZip, + mz_uint file_index) { + mz_uint bit_flag; + mz_uint method; + + const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index); + if (!p) { + mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + return MZ_FALSE; + } + + method = MZ_READ_LE16(p + MZ_ZIP_CDH_METHOD_OFS); + bit_flag = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS); + + if ((method != 0) && (method != MZ_DEFLATED)) { + mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD); + return MZ_FALSE; + } + + if (bit_flag & (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | + MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION)) { + mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION); + return MZ_FALSE; + } + + if (bit_flag & MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG) { + mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_FEATURE); + return MZ_FALSE; + } + + return MZ_TRUE; +} + +mz_bool mz_zip_reader_is_file_a_directory(mz_zip_archive *pZip, + mz_uint file_index) { + mz_uint filename_len, attribute_mapping_id, external_attr; + const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index); + if (!p) { + mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + return MZ_FALSE; + } + + filename_len = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS); + if (filename_len) { + if (*(p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_len - 1) == '/') + return MZ_TRUE; + } + + /* Bugfix: This code was also checking if the internal attribute was non-zero, + * which wasn't correct. */ + /* Most/all zip writers (hopefully) set DOS file/directory attributes in the + * low 16-bits, so check for the DOS directory flag and ignore the source OS + * ID in the created by field. */ + /* FIXME: Remove this check? Is it necessary - we already check the filename. + */ + attribute_mapping_id = MZ_READ_LE16(p + MZ_ZIP_CDH_VERSION_MADE_BY_OFS) >> 8; + (void)attribute_mapping_id; + + external_attr = MZ_READ_LE32(p + MZ_ZIP_CDH_EXTERNAL_ATTR_OFS); + if ((external_attr & MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG) != 0) { + return MZ_TRUE; + } + + return MZ_FALSE; +} + +static mz_bool mz_zip_file_stat_internal(mz_zip_archive *pZip, + mz_uint file_index, + const mz_uint8 *pCentral_dir_header, + mz_zip_archive_file_stat *pStat, + mz_bool *pFound_zip64_extra_data) { + mz_uint n; + const mz_uint8 *p = pCentral_dir_header; + + if (pFound_zip64_extra_data) + *pFound_zip64_extra_data = MZ_FALSE; + + if ((!p) || (!pStat)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + /* Extract fields from the central directory record. */ + pStat->m_file_index = file_index; + pStat->m_central_dir_ofs = MZ_ZIP_ARRAY_ELEMENT( + &pZip->m_pState->m_central_dir_offsets, mz_uint32, file_index); + pStat->m_version_made_by = MZ_READ_LE16(p + MZ_ZIP_CDH_VERSION_MADE_BY_OFS); + pStat->m_version_needed = MZ_READ_LE16(p + MZ_ZIP_CDH_VERSION_NEEDED_OFS); + pStat->m_bit_flag = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS); + pStat->m_method = MZ_READ_LE16(p + MZ_ZIP_CDH_METHOD_OFS); +#ifndef MINIZ_NO_TIME + pStat->m_time = + mz_zip_dos_to_time_t(MZ_READ_LE16(p + MZ_ZIP_CDH_FILE_TIME_OFS), + MZ_READ_LE16(p + MZ_ZIP_CDH_FILE_DATE_OFS)); +#endif + pStat->m_crc32 = MZ_READ_LE32(p + MZ_ZIP_CDH_CRC32_OFS); + pStat->m_comp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS); + pStat->m_uncomp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS); + pStat->m_internal_attr = MZ_READ_LE16(p + MZ_ZIP_CDH_INTERNAL_ATTR_OFS); + pStat->m_external_attr = MZ_READ_LE32(p + MZ_ZIP_CDH_EXTERNAL_ATTR_OFS); + pStat->m_local_header_ofs = MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS); + + /* Copy as much of the filename and comment as possible. */ + n = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS); + n = MZ_MIN(n, MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE - 1); + memcpy(pStat->m_filename, p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, n); + pStat->m_filename[n] = '\0'; + + n = MZ_READ_LE16(p + MZ_ZIP_CDH_COMMENT_LEN_OFS); + n = MZ_MIN(n, MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE - 1); + pStat->m_comment_size = n; + memcpy(pStat->m_comment, + p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + + MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS) + + MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS), + n); + pStat->m_comment[n] = '\0'; + + /* Set some flags for convienance */ + pStat->m_is_directory = mz_zip_reader_is_file_a_directory(pZip, file_index); + pStat->m_is_encrypted = mz_zip_reader_is_file_encrypted(pZip, file_index); + pStat->m_is_supported = mz_zip_reader_is_file_supported(pZip, file_index); + + /* See if we need to read any zip64 extended information fields. */ + /* Confusingly, these zip64 fields can be present even on non-zip64 archives + * (Debian zip on a huge files from stdin piped to stdout creates them). */ + if (MZ_MAX(MZ_MAX(pStat->m_comp_size, pStat->m_uncomp_size), + pStat->m_local_header_ofs) == MZ_UINT32_MAX) { + /* Attempt to find zip64 extended information field in the entry's extra + * data */ + mz_uint32 extra_size_remaining = MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS); + + if (extra_size_remaining) { + const mz_uint8 *pExtra_data = + p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + + MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS); + + do { + mz_uint32 field_id; + mz_uint32 field_data_size; + + if (extra_size_remaining < (sizeof(mz_uint16) * 2)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + field_id = MZ_READ_LE16(pExtra_data); + field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16)); + + if ((field_data_size + sizeof(mz_uint16) * 2) > extra_size_remaining) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID) { + const mz_uint8 *pField_data = pExtra_data + sizeof(mz_uint16) * 2; + mz_uint32 field_data_remaining = field_data_size; + + if (pFound_zip64_extra_data) + *pFound_zip64_extra_data = MZ_TRUE; + + if (pStat->m_uncomp_size == MZ_UINT32_MAX) { + if (field_data_remaining < sizeof(mz_uint64)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + pStat->m_uncomp_size = MZ_READ_LE64(pField_data); + pField_data += sizeof(mz_uint64); + field_data_remaining -= sizeof(mz_uint64); + } + + if (pStat->m_comp_size == MZ_UINT32_MAX) { + if (field_data_remaining < sizeof(mz_uint64)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + pStat->m_comp_size = MZ_READ_LE64(pField_data); + pField_data += sizeof(mz_uint64); + field_data_remaining -= sizeof(mz_uint64); + } + + if (pStat->m_local_header_ofs == MZ_UINT32_MAX) { + if (field_data_remaining < sizeof(mz_uint64)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + pStat->m_local_header_ofs = MZ_READ_LE64(pField_data); + pField_data += sizeof(mz_uint64); + (void)pField_data; // unused + + field_data_remaining -= sizeof(mz_uint64); + (void)field_data_remaining; // unused + } + + break; + } + + pExtra_data += sizeof(mz_uint16) * 2 + field_data_size; + extra_size_remaining = + extra_size_remaining - sizeof(mz_uint16) * 2 - field_data_size; + } while (extra_size_remaining); + } + } + + return MZ_TRUE; +} + +static MZ_FORCEINLINE mz_bool mz_zip_string_equal(const char *pA, + const char *pB, mz_uint len, + mz_uint flags) { + mz_uint i; + if (flags & MZ_ZIP_FLAG_CASE_SENSITIVE) + return 0 == memcmp(pA, pB, len); + for (i = 0; i < len; ++i) + if (MZ_TOLOWER(pA[i]) != MZ_TOLOWER(pB[i])) + return MZ_FALSE; + return MZ_TRUE; +} + +static MZ_FORCEINLINE int +mz_zip_filename_compare(const mz_zip_array *pCentral_dir_array, + const mz_zip_array *pCentral_dir_offsets, + mz_uint l_index, const char *pR, mz_uint r_len) { + const mz_uint8 *pL = &MZ_ZIP_ARRAY_ELEMENT( + pCentral_dir_array, mz_uint8, + MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_offsets, mz_uint32, + l_index)), + *pE; + mz_uint l_len = MZ_READ_LE16(pL + MZ_ZIP_CDH_FILENAME_LEN_OFS); + mz_uint8 l = 0, r = 0; + pL += MZ_ZIP_CENTRAL_DIR_HEADER_SIZE; + pE = pL + MZ_MIN(l_len, r_len); + while (pL < pE) { + if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR))) + break; + pL++; + pR++; + } + return (pL == pE) ? (int)(l_len - r_len) : (l - r); +} + +static mz_bool mz_zip_locate_file_binary_search(mz_zip_archive *pZip, + const char *pFilename, + mz_uint32 *pIndex) { + mz_zip_internal_state *pState = pZip->m_pState; + const mz_zip_array *pCentral_dir_offsets = &pState->m_central_dir_offsets; + const mz_zip_array *pCentral_dir = &pState->m_central_dir; + mz_uint32 *pIndices = &MZ_ZIP_ARRAY_ELEMENT( + &pState->m_sorted_central_dir_offsets, mz_uint32, 0); + const uint32_t size = pZip->m_total_files; + const mz_uint filename_len = (mz_uint)strlen(pFilename); + + if (pIndex) + *pIndex = 0; + + if (size) { + /* yes I could use uint32_t's, but then we would have to add some special + * case checks in the loop, argh, and */ + /* honestly the major expense here on 32-bit CPU's will still be the + * filename compare */ + mz_int64 l = 0, h = (mz_int64)size - 1; + + while (l <= h) { + mz_int64 m = l + ((h - l) >> 1); + uint32_t file_index = pIndices[(uint32_t)m]; + + int comp = mz_zip_filename_compare(pCentral_dir, pCentral_dir_offsets, + file_index, pFilename, filename_len); + if (!comp) { + if (pIndex) + *pIndex = file_index; + return MZ_TRUE; + } else if (comp < 0) + l = m + 1; + else + h = m - 1; + } + } + + return mz_zip_set_error(pZip, MZ_ZIP_FILE_NOT_FOUND); +} + +int mz_zip_reader_locate_file(mz_zip_archive *pZip, const char *pName, + const char *pComment, mz_uint flags) { + mz_uint32 index; + if (!mz_zip_reader_locate_file_v2(pZip, pName, pComment, flags, &index)) + return -1; + else + return (int)index; +} + +mz_bool mz_zip_reader_locate_file_v2(mz_zip_archive *pZip, const char *pName, + const char *pComment, mz_uint flags, + mz_uint32 *pIndex) { + mz_uint file_index; + size_t name_len, comment_len; + + if (pIndex) + *pIndex = 0; + + if ((!pZip) || (!pZip->m_pState) || (!pName)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + /* See if we can use a binary search */ + if (((pZip->m_pState->m_init_flags & + MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY) == 0) && + (pZip->m_zip_mode == MZ_ZIP_MODE_READING) && + ((flags & (MZ_ZIP_FLAG_IGNORE_PATH | MZ_ZIP_FLAG_CASE_SENSITIVE)) == 0) && + (!pComment) && (pZip->m_pState->m_sorted_central_dir_offsets.m_size)) { + return mz_zip_locate_file_binary_search(pZip, pName, pIndex); + } + + /* Locate the entry by scanning the entire central directory */ + name_len = strlen(pName); + if (name_len > MZ_UINT16_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + comment_len = pComment ? strlen(pComment) : 0; + if (comment_len > MZ_UINT16_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + for (file_index = 0; file_index < pZip->m_total_files; file_index++) { + const mz_uint8 *pHeader = &MZ_ZIP_ARRAY_ELEMENT( + &pZip->m_pState->m_central_dir, mz_uint8, + MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets, mz_uint32, + file_index)); + mz_uint filename_len = MZ_READ_LE16(pHeader + MZ_ZIP_CDH_FILENAME_LEN_OFS); + const char *pFilename = + (const char *)pHeader + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE; + if (filename_len < name_len) + continue; + if (comment_len) { + mz_uint file_extra_len = MZ_READ_LE16(pHeader + MZ_ZIP_CDH_EXTRA_LEN_OFS), + file_comment_len = + MZ_READ_LE16(pHeader + MZ_ZIP_CDH_COMMENT_LEN_OFS); + const char *pFile_comment = pFilename + filename_len + file_extra_len; + if ((file_comment_len != comment_len) || + (!mz_zip_string_equal(pComment, pFile_comment, file_comment_len, + flags))) + continue; + } + if ((flags & MZ_ZIP_FLAG_IGNORE_PATH) && (filename_len)) { + int ofs = filename_len - 1; + do { + if ((pFilename[ofs] == '/') || (pFilename[ofs] == '\\') || + (pFilename[ofs] == ':')) + break; + } while (--ofs >= 0); + ofs++; + pFilename += ofs; + filename_len -= ofs; + } + if ((filename_len == name_len) && + (mz_zip_string_equal(pName, pFilename, filename_len, flags))) { + if (pIndex) + *pIndex = file_index; + return MZ_TRUE; + } + } + + return mz_zip_set_error(pZip, MZ_ZIP_FILE_NOT_FOUND); +} + +mz_bool mz_zip_reader_extract_to_mem_no_alloc(mz_zip_archive *pZip, + mz_uint file_index, void *pBuf, + size_t buf_size, mz_uint flags, + void *pUser_read_buf, + size_t user_read_buf_size) { + int status = TINFL_STATUS_DONE; + mz_uint64 needed_size, cur_file_ofs, comp_remaining, + out_buf_ofs = 0, read_buf_size, read_buf_ofs = 0, read_buf_avail; + mz_zip_archive_file_stat file_stat; + void *pRead_buf; + mz_uint32 + local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / + sizeof(mz_uint32)]; + mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32; + tinfl_decompressor inflator; + + if ((!pZip) || (!pZip->m_pState) || ((buf_size) && (!pBuf)) || + ((user_read_buf_size) && (!pUser_read_buf)) || (!pZip->m_pRead)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat)) + return MZ_FALSE; + + /* A directory or zero length file */ + if (file_stat.m_is_directory || (!file_stat.m_comp_size)) + return MZ_TRUE; + + /* Encryption and patch files are not supported. */ + if (file_stat.m_bit_flag & + (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | + MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION | + MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG)) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION); + + /* This function only supports decompressing stored and deflate. */ + if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (file_stat.m_method != 0) && + (file_stat.m_method != MZ_DEFLATED)) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD); + + /* Ensure supplied output buffer is large enough. */ + needed_size = (flags & MZ_ZIP_FLAG_COMPRESSED_DATA) ? file_stat.m_comp_size + : file_stat.m_uncomp_size; + if (buf_size < needed_size) + return mz_zip_set_error(pZip, MZ_ZIP_BUF_TOO_SMALL); + + /* Read and parse the local directory entry. */ + cur_file_ofs = file_stat.m_local_header_ofs; + if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pLocal_header, + MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != + MZ_ZIP_LOCAL_DIR_HEADER_SIZE) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + + if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + cur_file_ofs += MZ_ZIP_LOCAL_DIR_HEADER_SIZE + + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS) + + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS); + if ((cur_file_ofs + file_stat.m_comp_size) > pZip->m_archive_size) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + if ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!file_stat.m_method)) { + /* The file is stored or the caller has requested the compressed data. */ + if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf, + (size_t)needed_size) != needed_size) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + +#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS + if ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) == 0) { + if (mz_crc32(MZ_CRC32_INIT, (const mz_uint8 *)pBuf, + (size_t)file_stat.m_uncomp_size) != file_stat.m_crc32) + return mz_zip_set_error(pZip, MZ_ZIP_CRC_CHECK_FAILED); + } +#endif + + return MZ_TRUE; + } + + /* Decompress the file either directly from memory or from a file input + * buffer. */ + tinfl_init(&inflator); + + if (pZip->m_pState->m_pMem) { + /* Read directly from the archive in memory. */ + pRead_buf = (mz_uint8 *)pZip->m_pState->m_pMem + cur_file_ofs; + read_buf_size = read_buf_avail = file_stat.m_comp_size; + comp_remaining = 0; + } else if (pUser_read_buf) { + /* Use a user provided read buffer. */ + if (!user_read_buf_size) + return MZ_FALSE; + pRead_buf = (mz_uint8 *)pUser_read_buf; + read_buf_size = user_read_buf_size; + read_buf_avail = 0; + comp_remaining = file_stat.m_comp_size; + } else { + /* Temporarily allocate a read buffer. */ + read_buf_size = + MZ_MIN(file_stat.m_comp_size, (mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE); + if (((sizeof(size_t) == sizeof(mz_uint32))) && (read_buf_size > 0x7FFFFFFF)) + return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR); + + if (NULL == (pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, + (size_t)read_buf_size))) + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + + read_buf_avail = 0; + comp_remaining = file_stat.m_comp_size; + } + + do { + /* The size_t cast here should be OK because we've verified that the output + * buffer is >= file_stat.m_uncomp_size above */ + size_t in_buf_size, + out_buf_size = (size_t)(file_stat.m_uncomp_size - out_buf_ofs); + if ((!read_buf_avail) && (!pZip->m_pState->m_pMem)) { + read_buf_avail = MZ_MIN(read_buf_size, comp_remaining); + if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pRead_buf, + (size_t)read_buf_avail) != read_buf_avail) { + status = TINFL_STATUS_FAILED; + mz_zip_set_error(pZip, MZ_ZIP_DECOMPRESSION_FAILED); + break; + } + cur_file_ofs += read_buf_avail; + comp_remaining -= read_buf_avail; + read_buf_ofs = 0; + } + in_buf_size = (size_t)read_buf_avail; + status = tinfl_decompress( + &inflator, (mz_uint8 *)pRead_buf + read_buf_ofs, &in_buf_size, + (mz_uint8 *)pBuf, (mz_uint8 *)pBuf + out_buf_ofs, &out_buf_size, + TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF | + (comp_remaining ? TINFL_FLAG_HAS_MORE_INPUT : 0)); + read_buf_avail -= in_buf_size; + read_buf_ofs += in_buf_size; + out_buf_ofs += out_buf_size; + } while (status == TINFL_STATUS_NEEDS_MORE_INPUT); + + if (status == TINFL_STATUS_DONE) { + /* Make sure the entire file was decompressed, and check its CRC. */ + if (out_buf_ofs != file_stat.m_uncomp_size) { + mz_zip_set_error(pZip, MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE); + status = TINFL_STATUS_FAILED; + } +#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS + else if (mz_crc32(MZ_CRC32_INIT, (const mz_uint8 *)pBuf, + (size_t)file_stat.m_uncomp_size) != file_stat.m_crc32) { + mz_zip_set_error(pZip, MZ_ZIP_CRC_CHECK_FAILED); + status = TINFL_STATUS_FAILED; + } +#endif + } + + if ((!pZip->m_pState->m_pMem) && (!pUser_read_buf)) + pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf); + + return status == TINFL_STATUS_DONE; +} + +mz_bool mz_zip_reader_extract_file_to_mem_no_alloc( + mz_zip_archive *pZip, const char *pFilename, void *pBuf, size_t buf_size, + mz_uint flags, void *pUser_read_buf, size_t user_read_buf_size) { + mz_uint32 file_index; + if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index)) + return MZ_FALSE; + return mz_zip_reader_extract_to_mem_no_alloc(pZip, file_index, pBuf, buf_size, + flags, pUser_read_buf, + user_read_buf_size); +} + +mz_bool mz_zip_reader_extract_to_mem(mz_zip_archive *pZip, mz_uint file_index, + void *pBuf, size_t buf_size, + mz_uint flags) { + return mz_zip_reader_extract_to_mem_no_alloc(pZip, file_index, pBuf, buf_size, + flags, NULL, 0); +} + +mz_bool mz_zip_reader_extract_file_to_mem(mz_zip_archive *pZip, + const char *pFilename, void *pBuf, + size_t buf_size, mz_uint flags) { + return mz_zip_reader_extract_file_to_mem_no_alloc(pZip, pFilename, pBuf, + buf_size, flags, NULL, 0); +} + +void *mz_zip_reader_extract_to_heap(mz_zip_archive *pZip, mz_uint file_index, + size_t *pSize, mz_uint flags) { + mz_uint64 comp_size, uncomp_size, alloc_size; + const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index); + void *pBuf; + + if (pSize) + *pSize = 0; + + if (!p) { + mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + return NULL; + } + + comp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS); + uncomp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS); + + alloc_size = (flags & MZ_ZIP_FLAG_COMPRESSED_DATA) ? comp_size : uncomp_size; + if (((sizeof(size_t) == sizeof(mz_uint32))) && (alloc_size > 0x7FFFFFFF)) { + mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR); + return NULL; + } + + if (NULL == + (pBuf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)alloc_size))) { + mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + return NULL; + } + + if (!mz_zip_reader_extract_to_mem(pZip, file_index, pBuf, (size_t)alloc_size, + flags)) { + pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf); + return NULL; + } + + if (pSize) + *pSize = (size_t)alloc_size; + return pBuf; +} + +void *mz_zip_reader_extract_file_to_heap(mz_zip_archive *pZip, + const char *pFilename, size_t *pSize, + mz_uint flags) { + mz_uint32 file_index; + if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, + &file_index)) { + if (pSize) + *pSize = 0; + return MZ_FALSE; + } + return mz_zip_reader_extract_to_heap(pZip, file_index, pSize, flags); +} + +mz_bool mz_zip_reader_extract_to_callback(mz_zip_archive *pZip, + mz_uint file_index, + mz_file_write_func pCallback, + void *pOpaque, mz_uint flags) { + int status = TINFL_STATUS_DONE; +#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS + mz_uint file_crc32 = MZ_CRC32_INIT; +#endif + mz_uint64 read_buf_size, read_buf_ofs = 0, read_buf_avail, comp_remaining, + out_buf_ofs = 0, cur_file_ofs; + mz_zip_archive_file_stat file_stat; + void *pRead_buf = NULL; + void *pWrite_buf = NULL; + mz_uint32 + local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / + sizeof(mz_uint32)]; + mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32; + + if ((!pZip) || (!pZip->m_pState) || (!pCallback) || (!pZip->m_pRead)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat)) + return MZ_FALSE; + + /* A directory or zero length file */ + if (file_stat.m_is_directory || (!file_stat.m_comp_size)) + return MZ_TRUE; + + /* Encryption and patch files are not supported. */ + if (file_stat.m_bit_flag & + (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | + MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION | + MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG)) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION); + + /* This function only supports decompressing stored and deflate. */ + if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (file_stat.m_method != 0) && + (file_stat.m_method != MZ_DEFLATED)) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD); + + /* Read and do some minimal validation of the local directory entry (this + * doesn't crack the zip64 stuff, which we already have from the central dir) + */ + cur_file_ofs = file_stat.m_local_header_ofs; + if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pLocal_header, + MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != + MZ_ZIP_LOCAL_DIR_HEADER_SIZE) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + + if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + cur_file_ofs += MZ_ZIP_LOCAL_DIR_HEADER_SIZE + + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS) + + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS); + if ((cur_file_ofs + file_stat.m_comp_size) > pZip->m_archive_size) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + /* Decompress the file either directly from memory or from a file input + * buffer. */ + if (pZip->m_pState->m_pMem) { + pRead_buf = (mz_uint8 *)pZip->m_pState->m_pMem + cur_file_ofs; + read_buf_size = read_buf_avail = file_stat.m_comp_size; + comp_remaining = 0; + } else { + read_buf_size = + MZ_MIN(file_stat.m_comp_size, (mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE); + if (NULL == (pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, + (size_t)read_buf_size))) + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + + read_buf_avail = 0; + comp_remaining = file_stat.m_comp_size; + } + + if ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!file_stat.m_method)) { + /* The file is stored or the caller has requested the compressed data. */ + if (pZip->m_pState->m_pMem) { + if (((sizeof(size_t) == sizeof(mz_uint32))) && + (file_stat.m_comp_size > MZ_UINT32_MAX)) + return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR); + + if (pCallback(pOpaque, out_buf_ofs, pRead_buf, + (size_t)file_stat.m_comp_size) != file_stat.m_comp_size) { + mz_zip_set_error(pZip, MZ_ZIP_WRITE_CALLBACK_FAILED); + status = TINFL_STATUS_FAILED; + } else if (!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) { +#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS + file_crc32 = + (mz_uint32)mz_crc32(file_crc32, (const mz_uint8 *)pRead_buf, + (size_t)file_stat.m_comp_size); +#endif + } + + cur_file_ofs += file_stat.m_comp_size; + out_buf_ofs += file_stat.m_comp_size; + comp_remaining = 0; + } else { + while (comp_remaining) { + read_buf_avail = MZ_MIN(read_buf_size, comp_remaining); + if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pRead_buf, + (size_t)read_buf_avail) != read_buf_avail) { + mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + status = TINFL_STATUS_FAILED; + break; + } + +#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS + if (!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) { + file_crc32 = (mz_uint32)mz_crc32( + file_crc32, (const mz_uint8 *)pRead_buf, (size_t)read_buf_avail); + } +#endif + + if (pCallback(pOpaque, out_buf_ofs, pRead_buf, + (size_t)read_buf_avail) != read_buf_avail) { + mz_zip_set_error(pZip, MZ_ZIP_WRITE_CALLBACK_FAILED); + status = TINFL_STATUS_FAILED; + break; + } + + cur_file_ofs += read_buf_avail; + out_buf_ofs += read_buf_avail; + comp_remaining -= read_buf_avail; + } + } + } else { + tinfl_decompressor inflator; + tinfl_init(&inflator); + + if (NULL == (pWrite_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, + TINFL_LZ_DICT_SIZE))) { + mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + status = TINFL_STATUS_FAILED; + } else { + do { + mz_uint8 *pWrite_buf_cur = + (mz_uint8 *)pWrite_buf + (out_buf_ofs & (TINFL_LZ_DICT_SIZE - 1)); + size_t in_buf_size, + out_buf_size = + TINFL_LZ_DICT_SIZE - (out_buf_ofs & (TINFL_LZ_DICT_SIZE - 1)); + if ((!read_buf_avail) && (!pZip->m_pState->m_pMem)) { + read_buf_avail = MZ_MIN(read_buf_size, comp_remaining); + if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pRead_buf, + (size_t)read_buf_avail) != read_buf_avail) { + mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + status = TINFL_STATUS_FAILED; + break; + } + cur_file_ofs += read_buf_avail; + comp_remaining -= read_buf_avail; + read_buf_ofs = 0; + } + + in_buf_size = (size_t)read_buf_avail; + status = tinfl_decompress( + &inflator, (const mz_uint8 *)pRead_buf + read_buf_ofs, &in_buf_size, + (mz_uint8 *)pWrite_buf, pWrite_buf_cur, &out_buf_size, + comp_remaining ? TINFL_FLAG_HAS_MORE_INPUT : 0); + read_buf_avail -= in_buf_size; + read_buf_ofs += in_buf_size; + + if (out_buf_size) { + if (pCallback(pOpaque, out_buf_ofs, pWrite_buf_cur, out_buf_size) != + out_buf_size) { + mz_zip_set_error(pZip, MZ_ZIP_WRITE_CALLBACK_FAILED); + status = TINFL_STATUS_FAILED; + break; + } + +#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS + file_crc32 = + (mz_uint32)mz_crc32(file_crc32, pWrite_buf_cur, out_buf_size); +#endif + if ((out_buf_ofs += out_buf_size) > file_stat.m_uncomp_size) { + mz_zip_set_error(pZip, MZ_ZIP_DECOMPRESSION_FAILED); + status = TINFL_STATUS_FAILED; + break; + } + } + } while ((status == TINFL_STATUS_NEEDS_MORE_INPUT) || + (status == TINFL_STATUS_HAS_MORE_OUTPUT)); + } + } + + if ((status == TINFL_STATUS_DONE) && + (!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA))) { + /* Make sure the entire file was decompressed, and check its CRC. */ + if (out_buf_ofs != file_stat.m_uncomp_size) { + mz_zip_set_error(pZip, MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE); + status = TINFL_STATUS_FAILED; + } +#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS + else if (file_crc32 != file_stat.m_crc32) { + mz_zip_set_error(pZip, MZ_ZIP_DECOMPRESSION_FAILED); + status = TINFL_STATUS_FAILED; + } +#endif + } + + if (!pZip->m_pState->m_pMem) + pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf); + + if (pWrite_buf) + pZip->m_pFree(pZip->m_pAlloc_opaque, pWrite_buf); + + return status == TINFL_STATUS_DONE; +} + +mz_bool mz_zip_reader_extract_file_to_callback(mz_zip_archive *pZip, + const char *pFilename, + mz_file_write_func pCallback, + void *pOpaque, mz_uint flags) { + mz_uint32 file_index; + if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index)) + return MZ_FALSE; + + return mz_zip_reader_extract_to_callback(pZip, file_index, pCallback, pOpaque, + flags); +} + +mz_zip_reader_extract_iter_state * +mz_zip_reader_extract_iter_new(mz_zip_archive *pZip, mz_uint file_index, + mz_uint flags) { + mz_zip_reader_extract_iter_state *pState; + mz_uint32 + local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / + sizeof(mz_uint32)]; + mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32; + + /* Argument sanity check */ + if ((!pZip) || (!pZip->m_pState)) + return NULL; + + /* Allocate an iterator status structure */ + pState = (mz_zip_reader_extract_iter_state *)pZip->m_pAlloc( + pZip->m_pAlloc_opaque, 1, sizeof(mz_zip_reader_extract_iter_state)); + if (!pState) { + mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + return NULL; + } + + /* Fetch file details */ + if (!mz_zip_reader_file_stat(pZip, file_index, &pState->file_stat)) { + pZip->m_pFree(pZip->m_pAlloc_opaque, pState); + return NULL; + } + + /* Encryption and patch files are not supported. */ + if (pState->file_stat.m_bit_flag & + (MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED | + MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION | + MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG)) { + mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION); + pZip->m_pFree(pZip->m_pAlloc_opaque, pState); + return NULL; + } + + /* This function only supports decompressing stored and deflate. */ + if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && + (pState->file_stat.m_method != 0) && + (pState->file_stat.m_method != MZ_DEFLATED)) { + mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD); + pZip->m_pFree(pZip->m_pAlloc_opaque, pState); + return NULL; + } + + /* Init state - save args */ + pState->pZip = pZip; + pState->flags = flags; + + /* Init state - reset variables to defaults */ + pState->status = TINFL_STATUS_DONE; +#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS + pState->file_crc32 = MZ_CRC32_INIT; +#endif + pState->read_buf_ofs = 0; + pState->out_buf_ofs = 0; + pState->pRead_buf = NULL; + pState->pWrite_buf = NULL; + pState->out_blk_remain = 0; + + /* Read and parse the local directory entry. */ + pState->cur_file_ofs = pState->file_stat.m_local_header_ofs; + if (pZip->m_pRead(pZip->m_pIO_opaque, pState->cur_file_ofs, pLocal_header, + MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != + MZ_ZIP_LOCAL_DIR_HEADER_SIZE) { + mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + pZip->m_pFree(pZip->m_pAlloc_opaque, pState); + return NULL; + } + + if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG) { + mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + pZip->m_pFree(pZip->m_pAlloc_opaque, pState); + return NULL; + } + + pState->cur_file_ofs += + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS) + + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS); + if ((pState->cur_file_ofs + pState->file_stat.m_comp_size) > + pZip->m_archive_size) { + mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + pZip->m_pFree(pZip->m_pAlloc_opaque, pState); + return NULL; + } + + /* Decompress the file either directly from memory or from a file input + * buffer. */ + if (pZip->m_pState->m_pMem) { + pState->pRead_buf = + (mz_uint8 *)pZip->m_pState->m_pMem + pState->cur_file_ofs; + pState->read_buf_size = pState->read_buf_avail = + pState->file_stat.m_comp_size; + pState->comp_remaining = pState->file_stat.m_comp_size; + } else { + if (!((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || + (!pState->file_stat.m_method))) { + /* Decompression required, therefore intermediate read buffer required */ + pState->read_buf_size = MZ_MIN(pState->file_stat.m_comp_size, + (mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE); + if (NULL == + (pState->pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, + (size_t)pState->read_buf_size))) { + mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + pZip->m_pFree(pZip->m_pAlloc_opaque, pState); + return NULL; + } + } else { + /* Decompression not required - we will be reading directly into user + * buffer, no temp buf required */ + pState->read_buf_size = 0; + } + pState->read_buf_avail = 0; + pState->comp_remaining = pState->file_stat.m_comp_size; + } + + if (!((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || + (!pState->file_stat.m_method))) { + /* Decompression required, init decompressor */ + tinfl_init(&pState->inflator); + + /* Allocate write buffer */ + if (NULL == (pState->pWrite_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, + TINFL_LZ_DICT_SIZE))) { + mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + if (pState->pRead_buf) + pZip->m_pFree(pZip->m_pAlloc_opaque, pState->pRead_buf); + pZip->m_pFree(pZip->m_pAlloc_opaque, pState); + return NULL; + } + } + + return pState; +} + +mz_zip_reader_extract_iter_state * +mz_zip_reader_extract_file_iter_new(mz_zip_archive *pZip, const char *pFilename, + mz_uint flags) { + mz_uint32 file_index; + + /* Locate file index by name */ + if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index)) + return NULL; + + /* Construct iterator */ + return mz_zip_reader_extract_iter_new(pZip, file_index, flags); +} + +size_t mz_zip_reader_extract_iter_read(mz_zip_reader_extract_iter_state *pState, + void *pvBuf, size_t buf_size) { + size_t copied_to_caller = 0; + + /* Argument sanity check */ + if ((!pState) || (!pState->pZip) || (!pState->pZip->m_pState) || (!pvBuf)) + return 0; + + if ((pState->flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || + (!pState->file_stat.m_method)) { + /* The file is stored or the caller has requested the compressed data, calc + * amount to return. */ + copied_to_caller = (size_t)MZ_MIN(buf_size, pState->comp_remaining); + + /* Zip is in memory....or requires reading from a file? */ + if (pState->pZip->m_pState->m_pMem) { + /* Copy data to caller's buffer */ + memcpy(pvBuf, pState->pRead_buf, copied_to_caller); + pState->pRead_buf = ((mz_uint8 *)pState->pRead_buf) + copied_to_caller; + } else { + /* Read directly into caller's buffer */ + if (pState->pZip->m_pRead(pState->pZip->m_pIO_opaque, + pState->cur_file_ofs, pvBuf, + copied_to_caller) != copied_to_caller) { + /* Failed to read all that was asked for, flag failure and alert user */ + mz_zip_set_error(pState->pZip, MZ_ZIP_FILE_READ_FAILED); + pState->status = TINFL_STATUS_FAILED; + copied_to_caller = 0; + } + } + +#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS + /* Compute CRC if not returning compressed data only */ + if (!(pState->flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) + pState->file_crc32 = (mz_uint32)mz_crc32( + pState->file_crc32, (const mz_uint8 *)pvBuf, copied_to_caller); +#endif + + /* Advance offsets, dec counters */ + pState->cur_file_ofs += copied_to_caller; + pState->out_buf_ofs += copied_to_caller; + pState->comp_remaining -= copied_to_caller; + } else { + do { + /* Calc ptr to write buffer - given current output pos and block size */ + mz_uint8 *pWrite_buf_cur = + (mz_uint8 *)pState->pWrite_buf + + (pState->out_buf_ofs & (TINFL_LZ_DICT_SIZE - 1)); + + /* Calc max output size - given current output pos and block size */ + size_t in_buf_size, + out_buf_size = TINFL_LZ_DICT_SIZE - + (pState->out_buf_ofs & (TINFL_LZ_DICT_SIZE - 1)); + + if (!pState->out_blk_remain) { + /* Read more data from file if none available (and reading from file) */ + if ((!pState->read_buf_avail) && (!pState->pZip->m_pState->m_pMem)) { + /* Calc read size */ + pState->read_buf_avail = + MZ_MIN(pState->read_buf_size, pState->comp_remaining); + if (pState->pZip->m_pRead(pState->pZip->m_pIO_opaque, + pState->cur_file_ofs, pState->pRead_buf, + (size_t)pState->read_buf_avail) != + pState->read_buf_avail) { + mz_zip_set_error(pState->pZip, MZ_ZIP_FILE_READ_FAILED); + pState->status = TINFL_STATUS_FAILED; + break; + } + + /* Advance offsets, dec counters */ + pState->cur_file_ofs += pState->read_buf_avail; + pState->comp_remaining -= pState->read_buf_avail; + pState->read_buf_ofs = 0; + } + + /* Perform decompression */ + in_buf_size = (size_t)pState->read_buf_avail; + pState->status = tinfl_decompress( + &pState->inflator, + (const mz_uint8 *)pState->pRead_buf + pState->read_buf_ofs, + &in_buf_size, (mz_uint8 *)pState->pWrite_buf, pWrite_buf_cur, + &out_buf_size, + pState->comp_remaining ? TINFL_FLAG_HAS_MORE_INPUT : 0); + pState->read_buf_avail -= in_buf_size; + pState->read_buf_ofs += in_buf_size; + + /* Update current output block size remaining */ + pState->out_blk_remain = out_buf_size; + } + + if (pState->out_blk_remain) { + /* Calc amount to return. */ + size_t to_copy = + MZ_MIN((buf_size - copied_to_caller), pState->out_blk_remain); + + /* Copy data to caller's buffer */ + memcpy((uint8_t *)pvBuf + copied_to_caller, pWrite_buf_cur, to_copy); + +#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS + /* Perform CRC */ + pState->file_crc32 = + (mz_uint32)mz_crc32(pState->file_crc32, pWrite_buf_cur, to_copy); +#endif + + /* Decrement data consumed from block */ + pState->out_blk_remain -= to_copy; + + /* Inc output offset, while performing sanity check */ + if ((pState->out_buf_ofs += to_copy) > + pState->file_stat.m_uncomp_size) { + mz_zip_set_error(pState->pZip, MZ_ZIP_DECOMPRESSION_FAILED); + pState->status = TINFL_STATUS_FAILED; + break; + } + + /* Increment counter of data copied to caller */ + copied_to_caller += to_copy; + } + } while ((copied_to_caller < buf_size) && + ((pState->status == TINFL_STATUS_NEEDS_MORE_INPUT) || + (pState->status == TINFL_STATUS_HAS_MORE_OUTPUT))); + } + + /* Return how many bytes were copied into user buffer */ + return copied_to_caller; +} + +mz_bool +mz_zip_reader_extract_iter_free(mz_zip_reader_extract_iter_state *pState) { + int status; + + /* Argument sanity check */ + if ((!pState) || (!pState->pZip) || (!pState->pZip->m_pState)) + return MZ_FALSE; + + /* Was decompression completed and requested? */ + if ((pState->status == TINFL_STATUS_DONE) && + (!(pState->flags & MZ_ZIP_FLAG_COMPRESSED_DATA))) { + /* Make sure the entire file was decompressed, and check its CRC. */ + if (pState->out_buf_ofs != pState->file_stat.m_uncomp_size) { + mz_zip_set_error(pState->pZip, MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE); + pState->status = TINFL_STATUS_FAILED; + } +#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS + else if (pState->file_crc32 != pState->file_stat.m_crc32) { + mz_zip_set_error(pState->pZip, MZ_ZIP_DECOMPRESSION_FAILED); + pState->status = TINFL_STATUS_FAILED; + } +#endif + } + + /* Free buffers */ + if (!pState->pZip->m_pState->m_pMem) + pState->pZip->m_pFree(pState->pZip->m_pAlloc_opaque, pState->pRead_buf); + if (pState->pWrite_buf) + pState->pZip->m_pFree(pState->pZip->m_pAlloc_opaque, pState->pWrite_buf); + + /* Save status */ + status = pState->status; + + /* Free context */ + pState->pZip->m_pFree(pState->pZip->m_pAlloc_opaque, pState); + + return status == TINFL_STATUS_DONE; +} + +#ifndef MINIZ_NO_STDIO +static size_t mz_zip_file_write_callback(void *pOpaque, mz_uint64 ofs, + const void *pBuf, size_t n) { + (void)ofs; + + return MZ_FWRITE(pBuf, 1, n, (MZ_FILE *)pOpaque); +} + +mz_bool mz_zip_reader_extract_to_file(mz_zip_archive *pZip, mz_uint file_index, + const char *pDst_filename, + mz_uint flags) { + mz_bool status; + mz_zip_archive_file_stat file_stat; + MZ_FILE *pFile; + + if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat)) + return MZ_FALSE; + + if (file_stat.m_is_directory || (!file_stat.m_is_supported)) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_FEATURE); + + pFile = MZ_FOPEN(pDst_filename, "wb"); + if (!pFile) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED); + + status = mz_zip_reader_extract_to_callback( + pZip, file_index, mz_zip_file_write_callback, pFile, flags); + + if (MZ_FCLOSE(pFile) == EOF) { + if (status) + mz_zip_set_error(pZip, MZ_ZIP_FILE_CLOSE_FAILED); + + status = MZ_FALSE; + } + +#if !defined(MINIZ_NO_TIME) && !defined(MINIZ_NO_STDIO) + if (status) + mz_zip_set_file_times(pDst_filename, file_stat.m_time, file_stat.m_time); +#endif + + return status; +} + +mz_bool mz_zip_reader_extract_file_to_file(mz_zip_archive *pZip, + const char *pArchive_filename, + const char *pDst_filename, + mz_uint flags) { + mz_uint32 file_index; + if (!mz_zip_reader_locate_file_v2(pZip, pArchive_filename, NULL, flags, + &file_index)) + return MZ_FALSE; + + return mz_zip_reader_extract_to_file(pZip, file_index, pDst_filename, flags); +} + +mz_bool mz_zip_reader_extract_to_cfile(mz_zip_archive *pZip, mz_uint file_index, + MZ_FILE *pFile, mz_uint flags) { + mz_zip_archive_file_stat file_stat; + + if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat)) + return MZ_FALSE; + + if (file_stat.m_is_directory || (!file_stat.m_is_supported)) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_FEATURE); + + return mz_zip_reader_extract_to_callback( + pZip, file_index, mz_zip_file_write_callback, pFile, flags); +} + +mz_bool mz_zip_reader_extract_file_to_cfile(mz_zip_archive *pZip, + const char *pArchive_filename, + MZ_FILE *pFile, mz_uint flags) { + mz_uint32 file_index; + if (!mz_zip_reader_locate_file_v2(pZip, pArchive_filename, NULL, flags, + &file_index)) + return MZ_FALSE; + + return mz_zip_reader_extract_to_cfile(pZip, file_index, pFile, flags); +} +#endif /* #ifndef MINIZ_NO_STDIO */ + +static size_t mz_zip_compute_crc32_callback(void *pOpaque, mz_uint64 file_ofs, + const void *pBuf, size_t n) { + mz_uint32 *p = (mz_uint32 *)pOpaque; + (void)file_ofs; + *p = (mz_uint32)mz_crc32(*p, (const mz_uint8 *)pBuf, n); + return n; +} + +mz_bool mz_zip_validate_file(mz_zip_archive *pZip, mz_uint file_index, + mz_uint flags) { + mz_zip_archive_file_stat file_stat; + mz_zip_internal_state *pState; + const mz_uint8 *pCentral_dir_header; + mz_bool found_zip64_ext_data_in_cdir = MZ_FALSE; + mz_bool found_zip64_ext_data_in_ldir = MZ_FALSE; + mz_uint32 + local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / + sizeof(mz_uint32)]; + mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32; + mz_uint64 local_header_ofs = 0; + mz_uint32 local_header_filename_len, local_header_extra_len, + local_header_crc32; + mz_uint64 local_header_comp_size, local_header_uncomp_size; + mz_uint32 uncomp_crc32 = MZ_CRC32_INIT; + mz_bool has_data_descriptor; + mz_uint32 local_header_bit_flags; + + mz_zip_array file_data_array; + mz_zip_array_init(&file_data_array, 1); + + if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || + (!pZip->m_pRead)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + if (file_index > pZip->m_total_files) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + pState = pZip->m_pState; + + pCentral_dir_header = mz_zip_get_cdh(pZip, file_index); + + if (!mz_zip_file_stat_internal(pZip, file_index, pCentral_dir_header, + &file_stat, &found_zip64_ext_data_in_cdir)) + return MZ_FALSE; + + /* A directory or zero length file */ + if (file_stat.m_is_directory || (!file_stat.m_uncomp_size)) + return MZ_TRUE; + + /* Encryption and patch files are not supported. */ + if (file_stat.m_is_encrypted) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION); + + /* This function only supports stored and deflate. */ + if ((file_stat.m_method != 0) && (file_stat.m_method != MZ_DEFLATED)) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_METHOD); + + if (!file_stat.m_is_supported) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_FEATURE); + + /* Read and parse the local directory entry. */ + local_header_ofs = file_stat.m_local_header_ofs; + if (pZip->m_pRead(pZip->m_pIO_opaque, local_header_ofs, pLocal_header, + MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != + MZ_ZIP_LOCAL_DIR_HEADER_SIZE) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + + if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + local_header_filename_len = + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS); + local_header_extra_len = + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS); + local_header_comp_size = + MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_COMPRESSED_SIZE_OFS); + local_header_uncomp_size = + MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS); + local_header_crc32 = MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_CRC32_OFS); + local_header_bit_flags = + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_BIT_FLAG_OFS); + has_data_descriptor = (local_header_bit_flags & 8) != 0; + + if (local_header_filename_len != strlen(file_stat.m_filename)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + if ((local_header_ofs + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + + local_header_filename_len + local_header_extra_len + + file_stat.m_comp_size) > pZip->m_archive_size) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + if (!mz_zip_array_resize( + pZip, &file_data_array, + MZ_MAX(local_header_filename_len, local_header_extra_len), + MZ_FALSE)) { + mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + goto handle_failure; + } + + if (local_header_filename_len) { + if (pZip->m_pRead(pZip->m_pIO_opaque, + local_header_ofs + MZ_ZIP_LOCAL_DIR_HEADER_SIZE, + file_data_array.m_p, + local_header_filename_len) != local_header_filename_len) { + mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + goto handle_failure; + } + + /* I've seen 1 archive that had the same pathname, but used backslashes in + * the local dir and forward slashes in the central dir. Do we care about + * this? For now, this case will fail validation. */ + if (memcmp(file_stat.m_filename, file_data_array.m_p, + local_header_filename_len) != 0) { + mz_zip_set_error(pZip, MZ_ZIP_VALIDATION_FAILED); + goto handle_failure; + } + } + + if ((local_header_extra_len) && + ((local_header_comp_size == MZ_UINT32_MAX) || + (local_header_uncomp_size == MZ_UINT32_MAX))) { + mz_uint32 extra_size_remaining = local_header_extra_len; + const mz_uint8 *pExtra_data = (const mz_uint8 *)file_data_array.m_p; + + if (pZip->m_pRead(pZip->m_pIO_opaque, + local_header_ofs + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + + local_header_filename_len, + file_data_array.m_p, + local_header_extra_len) != local_header_extra_len) { + mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + goto handle_failure; + } + + do { + mz_uint32 field_id, field_data_size, field_total_size; + + if (extra_size_remaining < (sizeof(mz_uint16) * 2)) { + mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + goto handle_failure; + } + + field_id = MZ_READ_LE16(pExtra_data); + field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16)); + field_total_size = field_data_size + sizeof(mz_uint16) * 2; + + if (field_total_size > extra_size_remaining) { + mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + goto handle_failure; + } + + if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID) { + const mz_uint8 *pSrc_field_data = pExtra_data + sizeof(mz_uint32); + + if (field_data_size < sizeof(mz_uint64) * 2) { + mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + goto handle_failure; + } + + local_header_uncomp_size = MZ_READ_LE64(pSrc_field_data); + local_header_comp_size = + MZ_READ_LE64(pSrc_field_data + sizeof(mz_uint64)); + + found_zip64_ext_data_in_ldir = MZ_TRUE; + break; + } + + pExtra_data += field_total_size; + extra_size_remaining -= field_total_size; + } while (extra_size_remaining); + } + + /* TODO: parse local header extra data when local_header_comp_size is + * 0xFFFFFFFF! (big_descriptor.zip) */ + /* I've seen zips in the wild with the data descriptor bit set, but proper + * local header values and bogus data descriptors */ + if ((has_data_descriptor) && (!local_header_comp_size) && + (!local_header_crc32)) { + mz_uint8 descriptor_buf[32]; + mz_bool has_id; + const mz_uint8 *pSrc; + mz_uint32 file_crc32; + mz_uint64 comp_size = 0, uncomp_size = 0; + + mz_uint32 num_descriptor_uint32s = + ((pState->m_zip64) || (found_zip64_ext_data_in_ldir)) ? 6 : 4; + + if (pZip->m_pRead(pZip->m_pIO_opaque, + local_header_ofs + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + + local_header_filename_len + local_header_extra_len + + file_stat.m_comp_size, + descriptor_buf, + sizeof(mz_uint32) * num_descriptor_uint32s) != + (sizeof(mz_uint32) * num_descriptor_uint32s)) { + mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + goto handle_failure; + } + + has_id = (MZ_READ_LE32(descriptor_buf) == MZ_ZIP_DATA_DESCRIPTOR_ID); + pSrc = has_id ? (descriptor_buf + sizeof(mz_uint32)) : descriptor_buf; + + file_crc32 = MZ_READ_LE32(pSrc); + + if ((pState->m_zip64) || (found_zip64_ext_data_in_ldir)) { + comp_size = MZ_READ_LE64(pSrc + sizeof(mz_uint32)); + uncomp_size = MZ_READ_LE64(pSrc + sizeof(mz_uint32) + sizeof(mz_uint64)); + } else { + comp_size = MZ_READ_LE32(pSrc + sizeof(mz_uint32)); + uncomp_size = MZ_READ_LE32(pSrc + sizeof(mz_uint32) + sizeof(mz_uint32)); + } + + if ((file_crc32 != file_stat.m_crc32) || + (comp_size != file_stat.m_comp_size) || + (uncomp_size != file_stat.m_uncomp_size)) { + mz_zip_set_error(pZip, MZ_ZIP_VALIDATION_FAILED); + goto handle_failure; + } + } else { + if ((local_header_crc32 != file_stat.m_crc32) || + (local_header_comp_size != file_stat.m_comp_size) || + (local_header_uncomp_size != file_stat.m_uncomp_size)) { + mz_zip_set_error(pZip, MZ_ZIP_VALIDATION_FAILED); + goto handle_failure; + } + } + + mz_zip_array_clear(pZip, &file_data_array); + + if ((flags & MZ_ZIP_FLAG_VALIDATE_HEADERS_ONLY) == 0) { + if (!mz_zip_reader_extract_to_callback( + pZip, file_index, mz_zip_compute_crc32_callback, &uncomp_crc32, 0)) + return MZ_FALSE; + + /* 1 more check to be sure, although the extract checks too. */ + if (uncomp_crc32 != file_stat.m_crc32) { + mz_zip_set_error(pZip, MZ_ZIP_VALIDATION_FAILED); + return MZ_FALSE; + } + } + + return MZ_TRUE; + +handle_failure: + mz_zip_array_clear(pZip, &file_data_array); + return MZ_FALSE; +} + +mz_bool mz_zip_validate_archive(mz_zip_archive *pZip, mz_uint flags) { + mz_zip_internal_state *pState; + uint32_t i; + + if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || + (!pZip->m_pRead)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + pState = pZip->m_pState; + + /* Basic sanity checks */ + if (!pState->m_zip64) { + if (pZip->m_total_files > MZ_UINT16_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); + + if (pZip->m_archive_size > MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); + } else { + if (pZip->m_total_files >= MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); + + if (pState->m_central_dir.m_size >= MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); + } + + for (i = 0; i < pZip->m_total_files; i++) { + if (MZ_ZIP_FLAG_VALIDATE_LOCATE_FILE_FLAG & flags) { + mz_uint32 found_index; + mz_zip_archive_file_stat stat; + + if (!mz_zip_reader_file_stat(pZip, i, &stat)) + return MZ_FALSE; + + if (!mz_zip_reader_locate_file_v2(pZip, stat.m_filename, NULL, 0, + &found_index)) + return MZ_FALSE; + + /* This check can fail if there are duplicate filenames in the archive + * (which we don't check for when writing - that's up to the user) */ + if (found_index != i) + return mz_zip_set_error(pZip, MZ_ZIP_VALIDATION_FAILED); + } + + if (!mz_zip_validate_file(pZip, i, flags)) + return MZ_FALSE; + } + + return MZ_TRUE; +} + +mz_bool mz_zip_validate_mem_archive(const void *pMem, size_t size, + mz_uint flags, mz_zip_error *pErr) { + mz_bool success = MZ_TRUE; + mz_zip_archive zip; + mz_zip_error actual_err = MZ_ZIP_NO_ERROR; + + if ((!pMem) || (!size)) { + if (pErr) + *pErr = MZ_ZIP_INVALID_PARAMETER; + return MZ_FALSE; + } + + mz_zip_zero_struct(&zip); + + if (!mz_zip_reader_init_mem(&zip, pMem, size, flags)) { + if (pErr) + *pErr = zip.m_last_error; + return MZ_FALSE; + } + + if (!mz_zip_validate_archive(&zip, flags)) { + actual_err = zip.m_last_error; + success = MZ_FALSE; + } + + if (!mz_zip_reader_end_internal(&zip, success)) { + if (!actual_err) + actual_err = zip.m_last_error; + success = MZ_FALSE; + } + + if (pErr) + *pErr = actual_err; + + return success; +} + +#ifndef MINIZ_NO_STDIO +mz_bool mz_zip_validate_file_archive(const char *pFilename, mz_uint flags, + mz_zip_error *pErr) { + mz_bool success = MZ_TRUE; + mz_zip_archive zip; + mz_zip_error actual_err = MZ_ZIP_NO_ERROR; + + if (!pFilename) { + if (pErr) + *pErr = MZ_ZIP_INVALID_PARAMETER; + return MZ_FALSE; + } + + mz_zip_zero_struct(&zip); + + if (!mz_zip_reader_init_file_v2(&zip, pFilename, flags, 0, 0)) { + if (pErr) + *pErr = zip.m_last_error; + return MZ_FALSE; + } + + if (!mz_zip_validate_archive(&zip, flags)) { + actual_err = zip.m_last_error; + success = MZ_FALSE; + } + + if (!mz_zip_reader_end_internal(&zip, success)) { + if (!actual_err) + actual_err = zip.m_last_error; + success = MZ_FALSE; + } + + if (pErr) + *pErr = actual_err; + + return success; +} +#endif /* #ifndef MINIZ_NO_STDIO */ + +/* ------------------- .ZIP archive writing */ + +#ifndef MINIZ_NO_ARCHIVE_WRITING_APIS + +static MZ_FORCEINLINE void mz_write_le16(mz_uint8 *p, mz_uint16 v) { + p[0] = (mz_uint8)v; + p[1] = (mz_uint8)(v >> 8); +} +static MZ_FORCEINLINE void mz_write_le32(mz_uint8 *p, mz_uint32 v) { + p[0] = (mz_uint8)v; + p[1] = (mz_uint8)(v >> 8); + p[2] = (mz_uint8)(v >> 16); + p[3] = (mz_uint8)(v >> 24); +} +static MZ_FORCEINLINE void mz_write_le64(mz_uint8 *p, mz_uint64 v) { + mz_write_le32(p, (mz_uint32)v); + mz_write_le32(p + sizeof(mz_uint32), (mz_uint32)(v >> 32)); +} + +#define MZ_WRITE_LE16(p, v) mz_write_le16((mz_uint8 *)(p), (mz_uint16)(v)) +#define MZ_WRITE_LE32(p, v) mz_write_le32((mz_uint8 *)(p), (mz_uint32)(v)) +#define MZ_WRITE_LE64(p, v) mz_write_le64((mz_uint8 *)(p), (mz_uint64)(v)) + +static size_t mz_zip_heap_write_func(void *pOpaque, mz_uint64 file_ofs, + const void *pBuf, size_t n) { + mz_zip_archive *pZip = (mz_zip_archive *)pOpaque; + mz_zip_internal_state *pState = pZip->m_pState; + mz_uint64 new_size = MZ_MAX(file_ofs + n, pState->m_mem_size); + + if (!n) + return 0; + + /* An allocation this big is likely to just fail on 32-bit systems, so don't + * even go there. */ + if ((sizeof(size_t) == sizeof(mz_uint32)) && (new_size > 0x7FFFFFFF)) { + mz_zip_set_error(pZip, MZ_ZIP_FILE_TOO_LARGE); + return 0; + } + + if (new_size > pState->m_mem_capacity) { + void *pNew_block; + size_t new_capacity = MZ_MAX(64, pState->m_mem_capacity); + + while (new_capacity < new_size) + new_capacity *= 2; + + if (NULL == (pNew_block = pZip->m_pRealloc( + pZip->m_pAlloc_opaque, pState->m_pMem, 1, new_capacity))) { + mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + return 0; + } + + pState->m_pMem = pNew_block; + pState->m_mem_capacity = new_capacity; + } + memcpy((mz_uint8 *)pState->m_pMem + file_ofs, pBuf, n); + pState->m_mem_size = (size_t)new_size; + return n; +} + +static mz_bool mz_zip_writer_end_internal(mz_zip_archive *pZip, + mz_bool set_last_error) { + mz_zip_internal_state *pState; + mz_bool status = MZ_TRUE; + + if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || + ((pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) && + (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED))) { + if (set_last_error) + mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + return MZ_FALSE; + } + + pState = pZip->m_pState; + pZip->m_pState = NULL; + mz_zip_array_clear(pZip, &pState->m_central_dir); + mz_zip_array_clear(pZip, &pState->m_central_dir_offsets); + mz_zip_array_clear(pZip, &pState->m_sorted_central_dir_offsets); + +#ifndef MINIZ_NO_STDIO + if (pState->m_pFile) { + if (pZip->m_zip_type == MZ_ZIP_TYPE_FILE) { + if (MZ_FCLOSE(pState->m_pFile) == EOF) { + if (set_last_error) + mz_zip_set_error(pZip, MZ_ZIP_FILE_CLOSE_FAILED); + status = MZ_FALSE; + } + } + + pState->m_pFile = NULL; + } +#endif /* #ifndef MINIZ_NO_STDIO */ + + if ((pZip->m_pWrite == mz_zip_heap_write_func) && (pState->m_pMem)) { + pZip->m_pFree(pZip->m_pAlloc_opaque, pState->m_pMem); + pState->m_pMem = NULL; + } + + pZip->m_pFree(pZip->m_pAlloc_opaque, pState); + pZip->m_zip_mode = MZ_ZIP_MODE_INVALID; + return status; +} + +mz_bool mz_zip_writer_init_v2(mz_zip_archive *pZip, mz_uint64 existing_size, + mz_uint flags) { + mz_bool zip64 = (flags & MZ_ZIP_FLAG_WRITE_ZIP64) != 0; + + if ((!pZip) || (pZip->m_pState) || (!pZip->m_pWrite) || + (pZip->m_zip_mode != MZ_ZIP_MODE_INVALID)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + if (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING) { + if (!pZip->m_pRead) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + } + + if (pZip->m_file_offset_alignment) { + /* Ensure user specified file offset alignment is a power of 2. */ + if (pZip->m_file_offset_alignment & (pZip->m_file_offset_alignment - 1)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + } + + if (!pZip->m_pAlloc) + pZip->m_pAlloc = miniz_def_alloc_func; + if (!pZip->m_pFree) + pZip->m_pFree = miniz_def_free_func; + if (!pZip->m_pRealloc) + pZip->m_pRealloc = miniz_def_realloc_func; + + pZip->m_archive_size = existing_size; + pZip->m_central_directory_file_ofs = 0; + pZip->m_total_files = 0; + + if (NULL == (pZip->m_pState = (mz_zip_internal_state *)pZip->m_pAlloc( + pZip->m_pAlloc_opaque, 1, sizeof(mz_zip_internal_state)))) + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + + memset(pZip->m_pState, 0, sizeof(mz_zip_internal_state)); + + MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir, + sizeof(mz_uint8)); + MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir_offsets, + sizeof(mz_uint32)); + MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_sorted_central_dir_offsets, + sizeof(mz_uint32)); + + pZip->m_pState->m_zip64 = zip64; + pZip->m_pState->m_zip64_has_extended_info_fields = zip64; + + pZip->m_zip_type = MZ_ZIP_TYPE_USER; + pZip->m_zip_mode = MZ_ZIP_MODE_WRITING; + + return MZ_TRUE; +} + +mz_bool mz_zip_writer_init(mz_zip_archive *pZip, mz_uint64 existing_size) { + return mz_zip_writer_init_v2(pZip, existing_size, 0); +} + +mz_bool mz_zip_writer_init_heap_v2(mz_zip_archive *pZip, + size_t size_to_reserve_at_beginning, + size_t initial_allocation_size, + mz_uint flags) { + pZip->m_pWrite = mz_zip_heap_write_func; + pZip->m_pNeeds_keepalive = NULL; + + if (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING) + pZip->m_pRead = mz_zip_mem_read_func; + + pZip->m_pIO_opaque = pZip; + + if (!mz_zip_writer_init_v2(pZip, size_to_reserve_at_beginning, flags)) + return MZ_FALSE; + + pZip->m_zip_type = MZ_ZIP_TYPE_HEAP; + + if (0 != (initial_allocation_size = MZ_MAX(initial_allocation_size, + size_to_reserve_at_beginning))) { + if (NULL == (pZip->m_pState->m_pMem = pZip->m_pAlloc( + pZip->m_pAlloc_opaque, 1, initial_allocation_size))) { + mz_zip_writer_end_internal(pZip, MZ_FALSE); + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + } + pZip->m_pState->m_mem_capacity = initial_allocation_size; + } + + return MZ_TRUE; +} + +mz_bool mz_zip_writer_init_heap(mz_zip_archive *pZip, + size_t size_to_reserve_at_beginning, + size_t initial_allocation_size) { + return mz_zip_writer_init_heap_v2(pZip, size_to_reserve_at_beginning, + initial_allocation_size, 0); +} + +#ifndef MINIZ_NO_STDIO +static size_t mz_zip_file_write_func(void *pOpaque, mz_uint64 file_ofs, + const void *pBuf, size_t n) { + mz_zip_archive *pZip = (mz_zip_archive *)pOpaque; + mz_int64 cur_ofs = MZ_FTELL64(pZip->m_pState->m_pFile); + + file_ofs += pZip->m_pState->m_file_archive_start_ofs; + + if (((mz_int64)file_ofs < 0) || + (((cur_ofs != (mz_int64)file_ofs)) && + (MZ_FSEEK64(pZip->m_pState->m_pFile, (mz_int64)file_ofs, SEEK_SET)))) { + mz_zip_set_error(pZip, MZ_ZIP_FILE_SEEK_FAILED); + return 0; + } + + return MZ_FWRITE(pBuf, 1, n, pZip->m_pState->m_pFile); +} + +mz_bool mz_zip_writer_init_file(mz_zip_archive *pZip, const char *pFilename, + mz_uint64 size_to_reserve_at_beginning) { + return mz_zip_writer_init_file_v2(pZip, pFilename, + size_to_reserve_at_beginning, 0); +} + +mz_bool mz_zip_writer_init_file_v2(mz_zip_archive *pZip, const char *pFilename, + mz_uint64 size_to_reserve_at_beginning, + mz_uint flags) { + MZ_FILE *pFile; + + pZip->m_pWrite = mz_zip_file_write_func; + pZip->m_pNeeds_keepalive = NULL; + + if (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING) + pZip->m_pRead = mz_zip_file_read_func; + + pZip->m_pIO_opaque = pZip; + + if (!mz_zip_writer_init_v2(pZip, size_to_reserve_at_beginning, flags)) + return MZ_FALSE; + + if (NULL == (pFile = MZ_FOPEN( + pFilename, + (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING) ? "w+b" : "wb"))) { + mz_zip_writer_end(pZip); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED); + } + + pZip->m_pState->m_pFile = pFile; + pZip->m_zip_type = MZ_ZIP_TYPE_FILE; + + if (size_to_reserve_at_beginning) { + mz_uint64 cur_ofs = 0; + char buf[4096]; + + MZ_CLEAR_OBJ(buf); + + do { + size_t n = (size_t)MZ_MIN(sizeof(buf), size_to_reserve_at_beginning); + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_ofs, buf, n) != n) { + mz_zip_writer_end(pZip); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + } + cur_ofs += n; + size_to_reserve_at_beginning -= n; + } while (size_to_reserve_at_beginning); + } + + return MZ_TRUE; +} + +mz_bool mz_zip_writer_init_cfile(mz_zip_archive *pZip, MZ_FILE *pFile, + mz_uint flags) { + pZip->m_pWrite = mz_zip_file_write_func; + pZip->m_pNeeds_keepalive = NULL; + + if (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING) + pZip->m_pRead = mz_zip_file_read_func; + + pZip->m_pIO_opaque = pZip; + + if (!mz_zip_writer_init_v2(pZip, 0, flags)) + return MZ_FALSE; + + pZip->m_pState->m_pFile = pFile; + pZip->m_pState->m_file_archive_start_ofs = + MZ_FTELL64(pZip->m_pState->m_pFile); + pZip->m_zip_type = MZ_ZIP_TYPE_CFILE; + + return MZ_TRUE; +} +#endif /* #ifndef MINIZ_NO_STDIO */ + +mz_bool mz_zip_writer_init_from_reader_v2(mz_zip_archive *pZip, + const char *pFilename, + mz_uint flags) { + mz_zip_internal_state *pState; + + if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_READING)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + if (flags & MZ_ZIP_FLAG_WRITE_ZIP64) { + /* We don't support converting a non-zip64 file to zip64 - this seems like + * more trouble than it's worth. (What about the existing 32-bit data + * descriptors that could follow the compressed data?) */ + if (!pZip->m_pState->m_zip64) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + } + + /* No sense in trying to write to an archive that's already at the support max + * size */ + if (pZip->m_pState->m_zip64) { + if (pZip->m_total_files == MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); + } else { + if (pZip->m_total_files == MZ_UINT16_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); + + if ((pZip->m_archive_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + + MZ_ZIP_LOCAL_DIR_HEADER_SIZE) > MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_TOO_LARGE); + } + + pState = pZip->m_pState; + + if (pState->m_pFile) { +#ifdef MINIZ_NO_STDIO + (void)pFilename; + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); +#else + if (pZip->m_pIO_opaque != pZip) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + if (pZip->m_zip_type == MZ_ZIP_TYPE_FILE) { + if (!pFilename) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + /* Archive is being read from stdio and was originally opened only for + * reading. Try to reopen as writable. */ + if (NULL == + (pState->m_pFile = MZ_FREOPEN(pFilename, "r+b", pState->m_pFile))) { + /* The mz_zip_archive is now in a bogus state because pState->m_pFile is + * NULL, so just close it. */ + mz_zip_reader_end_internal(pZip, MZ_FALSE); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED); + } + } + + pZip->m_pWrite = mz_zip_file_write_func; + pZip->m_pNeeds_keepalive = NULL; +#endif /* #ifdef MINIZ_NO_STDIO */ + } else if (pState->m_pMem) { + /* Archive lives in a memory block. Assume it's from the heap that we can + * resize using the realloc callback. */ + if (pZip->m_pIO_opaque != pZip) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + pState->m_mem_capacity = pState->m_mem_size; + pZip->m_pWrite = mz_zip_heap_write_func; + pZip->m_pNeeds_keepalive = NULL; + } + /* Archive is being read via a user provided read function - make sure the + user has specified a write function too. */ + else if (!pZip->m_pWrite) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + /* Start writing new files at the archive's current central directory + * location. */ + /* TODO: We could add a flag that lets the user start writing immediately + * AFTER the existing central dir - this would be safer. */ + pZip->m_archive_size = pZip->m_central_directory_file_ofs; + pZip->m_central_directory_file_ofs = 0; + + /* Clear the sorted central dir offsets, they aren't useful or maintained now. + */ + /* Even though we're now in write mode, files can still be extracted and + * verified, but file locates will be slow. */ + /* TODO: We could easily maintain the sorted central directory offsets. */ + mz_zip_array_clear(pZip, &pZip->m_pState->m_sorted_central_dir_offsets); + + pZip->m_zip_mode = MZ_ZIP_MODE_WRITING; + + return MZ_TRUE; +} + +mz_bool mz_zip_writer_init_from_reader(mz_zip_archive *pZip, + const char *pFilename) { + return mz_zip_writer_init_from_reader_v2(pZip, pFilename, 0); +} + +/* TODO: pArchive_name is a terrible name here! */ +mz_bool mz_zip_writer_add_mem(mz_zip_archive *pZip, const char *pArchive_name, + const void *pBuf, size_t buf_size, + mz_uint level_and_flags) { + return mz_zip_writer_add_mem_ex(pZip, pArchive_name, pBuf, buf_size, NULL, 0, + level_and_flags, 0, 0); +} + +typedef struct { + mz_zip_archive *m_pZip; + mz_uint64 m_cur_archive_file_ofs; + mz_uint64 m_comp_size; +} mz_zip_writer_add_state; + +static mz_bool mz_zip_writer_add_put_buf_callback(const void *pBuf, int len, + void *pUser) { + mz_zip_writer_add_state *pState = (mz_zip_writer_add_state *)pUser; + if ((int)pState->m_pZip->m_pWrite(pState->m_pZip->m_pIO_opaque, + pState->m_cur_archive_file_ofs, pBuf, + len) != len) + return MZ_FALSE; + + pState->m_cur_archive_file_ofs += len; + pState->m_comp_size += len; + return MZ_TRUE; +} + +#define MZ_ZIP64_MAX_LOCAL_EXTRA_FIELD_SIZE \ + (sizeof(mz_uint16) * 2 + sizeof(mz_uint64) * 2) +#define MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE \ + (sizeof(mz_uint16) * 2 + sizeof(mz_uint64) * 3) +static mz_uint32 +mz_zip_writer_create_zip64_extra_data(mz_uint8 *pBuf, mz_uint64 *pUncomp_size, + mz_uint64 *pComp_size, + mz_uint64 *pLocal_header_ofs) { + mz_uint8 *pDst = pBuf; + mz_uint32 field_size = 0; + + MZ_WRITE_LE16(pDst + 0, MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID); + MZ_WRITE_LE16(pDst + 2, 0); + pDst += sizeof(mz_uint16) * 2; + + if (pUncomp_size) { + MZ_WRITE_LE64(pDst, *pUncomp_size); + pDst += sizeof(mz_uint64); + field_size += sizeof(mz_uint64); + } + + if (pComp_size) { + MZ_WRITE_LE64(pDst, *pComp_size); + pDst += sizeof(mz_uint64); + field_size += sizeof(mz_uint64); + } + + if (pLocal_header_ofs) { + MZ_WRITE_LE64(pDst, *pLocal_header_ofs); + pDst += sizeof(mz_uint64); + field_size += sizeof(mz_uint64); + } + + MZ_WRITE_LE16(pBuf + 2, field_size); + + return (mz_uint32)(pDst - pBuf); +} + +static mz_bool mz_zip_writer_create_local_dir_header( + mz_zip_archive *pZip, mz_uint8 *pDst, mz_uint16 filename_size, + mz_uint16 extra_size, mz_uint64 uncomp_size, mz_uint64 comp_size, + mz_uint32 uncomp_crc32, mz_uint16 method, mz_uint16 bit_flags, + mz_uint16 dos_time, mz_uint16 dos_date) { + (void)pZip; + memset(pDst, 0, MZ_ZIP_LOCAL_DIR_HEADER_SIZE); + MZ_WRITE_LE32(pDst + MZ_ZIP_LDH_SIG_OFS, MZ_ZIP_LOCAL_DIR_HEADER_SIG); + MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_VERSION_NEEDED_OFS, method ? 20 : 0); + MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_BIT_FLAG_OFS, bit_flags); + MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_METHOD_OFS, method); + MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_FILE_TIME_OFS, dos_time); + MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_FILE_DATE_OFS, dos_date); + MZ_WRITE_LE32(pDst + MZ_ZIP_LDH_CRC32_OFS, uncomp_crc32); + MZ_WRITE_LE32(pDst + MZ_ZIP_LDH_COMPRESSED_SIZE_OFS, + MZ_MIN(comp_size, MZ_UINT32_MAX)); + MZ_WRITE_LE32(pDst + MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS, + MZ_MIN(uncomp_size, MZ_UINT32_MAX)); + MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_FILENAME_LEN_OFS, filename_size); + MZ_WRITE_LE16(pDst + MZ_ZIP_LDH_EXTRA_LEN_OFS, extra_size); + return MZ_TRUE; +} + +static mz_bool mz_zip_writer_create_central_dir_header( + mz_zip_archive *pZip, mz_uint8 *pDst, mz_uint16 filename_size, + mz_uint16 extra_size, mz_uint16 comment_size, mz_uint64 uncomp_size, + mz_uint64 comp_size, mz_uint32 uncomp_crc32, mz_uint16 method, + mz_uint16 bit_flags, mz_uint16 dos_time, mz_uint16 dos_date, + mz_uint64 local_header_ofs, mz_uint32 ext_attributes) { + (void)pZip; + memset(pDst, 0, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE); + MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_SIG_OFS, MZ_ZIP_CENTRAL_DIR_HEADER_SIG); + MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_VERSION_NEEDED_OFS, method ? 20 : 0); + MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_BIT_FLAG_OFS, bit_flags); + MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_METHOD_OFS, method); + MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_FILE_TIME_OFS, dos_time); + MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_FILE_DATE_OFS, dos_date); + MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_CRC32_OFS, uncomp_crc32); + MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS, + MZ_MIN(comp_size, MZ_UINT32_MAX)); + MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS, + MZ_MIN(uncomp_size, MZ_UINT32_MAX)); + MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_FILENAME_LEN_OFS, filename_size); + MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_EXTRA_LEN_OFS, extra_size); + MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_COMMENT_LEN_OFS, comment_size); + MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_EXTERNAL_ATTR_OFS, ext_attributes); + MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_LOCAL_HEADER_OFS, + MZ_MIN(local_header_ofs, MZ_UINT32_MAX)); + return MZ_TRUE; +} + +static mz_bool mz_zip_writer_add_to_central_dir( + mz_zip_archive *pZip, const char *pFilename, mz_uint16 filename_size, + const void *pExtra, mz_uint16 extra_size, const void *pComment, + mz_uint16 comment_size, mz_uint64 uncomp_size, mz_uint64 comp_size, + mz_uint32 uncomp_crc32, mz_uint16 method, mz_uint16 bit_flags, + mz_uint16 dos_time, mz_uint16 dos_date, mz_uint64 local_header_ofs, + mz_uint32 ext_attributes, const char *user_extra_data, + mz_uint user_extra_data_len) { + mz_zip_internal_state *pState = pZip->m_pState; + mz_uint32 central_dir_ofs = (mz_uint32)pState->m_central_dir.m_size; + size_t orig_central_dir_size = pState->m_central_dir.m_size; + mz_uint8 central_dir_header[MZ_ZIP_CENTRAL_DIR_HEADER_SIZE]; + + if (!pZip->m_pState->m_zip64) { + if (local_header_ofs > 0xFFFFFFFF) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_TOO_LARGE); + } + + /* miniz doesn't support central dirs >= MZ_UINT32_MAX bytes yet */ + if (((mz_uint64)pState->m_central_dir.m_size + + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size + extra_size + + user_extra_data_len + comment_size) >= MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE); + + if (!mz_zip_writer_create_central_dir_header( + pZip, central_dir_header, filename_size, + (mz_uint16)(extra_size + user_extra_data_len), comment_size, + uncomp_size, comp_size, uncomp_crc32, method, bit_flags, dos_time, + dos_date, local_header_ofs, ext_attributes)) + return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR); + + if ((!mz_zip_array_push_back(pZip, &pState->m_central_dir, central_dir_header, + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE)) || + (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pFilename, + filename_size)) || + (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pExtra, + extra_size)) || + (!mz_zip_array_push_back(pZip, &pState->m_central_dir, user_extra_data, + user_extra_data_len)) || + (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pComment, + comment_size)) || + (!mz_zip_array_push_back(pZip, &pState->m_central_dir_offsets, + ¢ral_dir_ofs, 1))) { + /* Try to resize the central directory array back into its original state. + */ + mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, + MZ_FALSE); + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + } + + return MZ_TRUE; +} + +static mz_bool mz_zip_writer_validate_archive_name(const char *pArchive_name) { + /* Basic ZIP archive filename validity checks: Valid filenames cannot start + * with a forward slash, cannot contain a drive letter, and cannot use + * DOS-style backward slashes. */ + if (*pArchive_name == '/') + return MZ_FALSE; + + /* Making sure the name does not contain drive letters or DOS style backward + * slashes is the responsibility of the program using miniz*/ + + return MZ_TRUE; +} + +static mz_uint +mz_zip_writer_compute_padding_needed_for_file_alignment(mz_zip_archive *pZip) { + mz_uint32 n; + if (!pZip->m_file_offset_alignment) + return 0; + n = (mz_uint32)(pZip->m_archive_size & (pZip->m_file_offset_alignment - 1)); + return (mz_uint)((pZip->m_file_offset_alignment - n) & + (pZip->m_file_offset_alignment - 1)); +} + +static mz_bool mz_zip_writer_write_zeros(mz_zip_archive *pZip, + mz_uint64 cur_file_ofs, mz_uint32 n) { + char buf[4096]; + memset(buf, 0, MZ_MIN(sizeof(buf), n)); + while (n) { + mz_uint32 s = MZ_MIN(sizeof(buf), n); + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_file_ofs, buf, s) != s) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + + cur_file_ofs += s; + n -= s; + } + return MZ_TRUE; +} + +mz_bool mz_zip_writer_add_mem_ex(mz_zip_archive *pZip, + const char *pArchive_name, const void *pBuf, + size_t buf_size, const void *pComment, + mz_uint16 comment_size, + mz_uint level_and_flags, mz_uint64 uncomp_size, + mz_uint32 uncomp_crc32) { + return mz_zip_writer_add_mem_ex_v2( + pZip, pArchive_name, pBuf, buf_size, pComment, comment_size, + level_and_flags, uncomp_size, uncomp_crc32, NULL, NULL, 0, NULL, 0); +} + +mz_bool mz_zip_writer_add_mem_ex_v2( + mz_zip_archive *pZip, const char *pArchive_name, const void *pBuf, + size_t buf_size, const void *pComment, mz_uint16 comment_size, + mz_uint level_and_flags, mz_uint64 uncomp_size, mz_uint32 uncomp_crc32, + MZ_TIME_T *last_modified, const char *user_extra_data, + mz_uint user_extra_data_len, const char *user_extra_data_central, + mz_uint user_extra_data_central_len) { + mz_uint16 method = 0, dos_time = 0, dos_date = 0; + mz_uint level, ext_attributes = 0, num_alignment_padding_bytes; + mz_uint64 local_dir_header_ofs = pZip->m_archive_size, + cur_archive_file_ofs = pZip->m_archive_size, comp_size = 0; + size_t archive_name_size; + mz_uint8 local_dir_header[MZ_ZIP_LOCAL_DIR_HEADER_SIZE]; + tdefl_compressor *pComp = NULL; + mz_bool store_data_uncompressed; + mz_zip_internal_state *pState; + mz_uint8 *pExtra_data = NULL; + mz_uint32 extra_size = 0; + mz_uint8 extra_data[MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE]; + mz_uint16 bit_flags = 0; + + if ((int)level_and_flags < 0) + level_and_flags = MZ_DEFAULT_LEVEL; + + if (uncomp_size || + (buf_size && !(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA))) + bit_flags |= MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR; + + if (!(level_and_flags & MZ_ZIP_FLAG_ASCII_FILENAME)) + bit_flags |= MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8; + + level = level_and_flags & 0xF; + store_data_uncompressed = + ((!level) || (level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)); + + if ((!pZip) || (!pZip->m_pState) || + (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || ((buf_size) && (!pBuf)) || + (!pArchive_name) || ((comment_size) && (!pComment)) || + (level > MZ_UBER_COMPRESSION)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + pState = pZip->m_pState; + + if (pState->m_zip64) { + if (pZip->m_total_files == MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); + } else { + if (pZip->m_total_files == MZ_UINT16_MAX) { + pState->m_zip64 = MZ_TRUE; + /*return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); */ + } + if ((buf_size > 0xFFFFFFFF) || (uncomp_size > 0xFFFFFFFF)) { + pState->m_zip64 = MZ_TRUE; + /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */ + } + } + + if ((!(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (uncomp_size)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + if (!mz_zip_writer_validate_archive_name(pArchive_name)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_FILENAME); + +#ifndef MINIZ_NO_TIME + if (last_modified != NULL) { + mz_zip_time_t_to_dos_time(*last_modified, &dos_time, &dos_date); + } else { + MZ_TIME_T cur_time; + time(&cur_time); + mz_zip_time_t_to_dos_time(cur_time, &dos_time, &dos_date); + } +#endif /* #ifndef MINIZ_NO_TIME */ + + if (!(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) { + uncomp_crc32 = + (mz_uint32)mz_crc32(MZ_CRC32_INIT, (const mz_uint8 *)pBuf, buf_size); + uncomp_size = buf_size; + if (uncomp_size <= 3) { + level = 0; + store_data_uncompressed = MZ_TRUE; + } + } + + archive_name_size = strlen(pArchive_name); + if (archive_name_size > MZ_UINT16_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_FILENAME); + + num_alignment_padding_bytes = + mz_zip_writer_compute_padding_needed_for_file_alignment(pZip); + + /* miniz doesn't support central dirs >= MZ_UINT32_MAX bytes yet */ + if (((mz_uint64)pState->m_central_dir.m_size + + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + + MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE + comment_size) >= MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE); + + if (!pState->m_zip64) { + /* Bail early if the archive would obviously become too large */ + if ((pZip->m_archive_size + num_alignment_padding_bytes + + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + archive_name_size + + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + comment_size + + user_extra_data_len + pState->m_central_dir.m_size + + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE + user_extra_data_central_len + + MZ_ZIP_DATA_DESCRIPTER_SIZE32) > 0xFFFFFFFF) { + pState->m_zip64 = MZ_TRUE; + /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */ + } + } + + if ((archive_name_size) && (pArchive_name[archive_name_size - 1] == '/')) { + /* Set DOS Subdirectory attribute bit. */ + ext_attributes |= MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG; + + /* Subdirectories cannot contain data. */ + if ((buf_size) || (uncomp_size)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + } + + /* Try to do any allocations before writing to the archive, so if an + * allocation fails the file remains unmodified. (A good idea if we're doing + * an in-place modification.) */ + if ((!mz_zip_array_ensure_room( + pZip, &pState->m_central_dir, + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + comment_size + + (pState->m_zip64 ? MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE : 0))) || + (!mz_zip_array_ensure_room(pZip, &pState->m_central_dir_offsets, 1))) + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + + if ((!store_data_uncompressed) && (buf_size)) { + if (NULL == (pComp = (tdefl_compressor *)pZip->m_pAlloc( + pZip->m_pAlloc_opaque, 1, sizeof(tdefl_compressor)))) + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + } + + if (!mz_zip_writer_write_zeros(pZip, cur_archive_file_ofs, + num_alignment_padding_bytes)) { + pZip->m_pFree(pZip->m_pAlloc_opaque, pComp); + return MZ_FALSE; + } + + local_dir_header_ofs += num_alignment_padding_bytes; + if (pZip->m_file_offset_alignment) { + MZ_ASSERT((local_dir_header_ofs & (pZip->m_file_offset_alignment - 1)) == + 0); + } + cur_archive_file_ofs += num_alignment_padding_bytes; + + MZ_CLEAR_OBJ(local_dir_header); + + if (!store_data_uncompressed || + (level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) { + method = MZ_DEFLATED; + } + + if (pState->m_zip64) { + if (uncomp_size >= MZ_UINT32_MAX || local_dir_header_ofs >= MZ_UINT32_MAX) { + pExtra_data = extra_data; + extra_size = mz_zip_writer_create_zip64_extra_data( + extra_data, (uncomp_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL, + (uncomp_size >= MZ_UINT32_MAX) ? &comp_size : NULL, + (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs + : NULL); + } + + if (!mz_zip_writer_create_local_dir_header( + pZip, local_dir_header, (mz_uint16)archive_name_size, + (mz_uint16)(extra_size + user_extra_data_len), 0, 0, 0, method, + bit_flags, dos_time, dos_date)) + return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR); + + if (pZip->m_pWrite(pZip->m_pIO_opaque, local_dir_header_ofs, + local_dir_header, + sizeof(local_dir_header)) != sizeof(local_dir_header)) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + + cur_archive_file_ofs += sizeof(local_dir_header); + + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, + archive_name_size) != archive_name_size) { + pZip->m_pFree(pZip->m_pAlloc_opaque, pComp); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + } + cur_archive_file_ofs += archive_name_size; + + if (pExtra_data != NULL) { + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, extra_data, + extra_size) != extra_size) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + + cur_archive_file_ofs += extra_size; + } + } else { + if ((comp_size > MZ_UINT32_MAX) || (cur_archive_file_ofs > MZ_UINT32_MAX)) + return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); + if (!mz_zip_writer_create_local_dir_header( + pZip, local_dir_header, (mz_uint16)archive_name_size, + (mz_uint16)user_extra_data_len, 0, 0, 0, method, bit_flags, + dos_time, dos_date)) + return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR); + + if (pZip->m_pWrite(pZip->m_pIO_opaque, local_dir_header_ofs, + local_dir_header, + sizeof(local_dir_header)) != sizeof(local_dir_header)) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + + cur_archive_file_ofs += sizeof(local_dir_header); + + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, + archive_name_size) != archive_name_size) { + pZip->m_pFree(pZip->m_pAlloc_opaque, pComp); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + } + cur_archive_file_ofs += archive_name_size; + } + + if (user_extra_data_len > 0) { + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, + user_extra_data, + user_extra_data_len) != user_extra_data_len) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + + cur_archive_file_ofs += user_extra_data_len; + } + + if (store_data_uncompressed) { + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pBuf, + buf_size) != buf_size) { + pZip->m_pFree(pZip->m_pAlloc_opaque, pComp); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + } + + cur_archive_file_ofs += buf_size; + comp_size = buf_size; + } else if (buf_size) { + mz_zip_writer_add_state state; + + state.m_pZip = pZip; + state.m_cur_archive_file_ofs = cur_archive_file_ofs; + state.m_comp_size = 0; + + if ((tdefl_init(pComp, mz_zip_writer_add_put_buf_callback, &state, + tdefl_create_comp_flags_from_zip_params( + level, -15, MZ_DEFAULT_STRATEGY)) != + TDEFL_STATUS_OKAY) || + (tdefl_compress_buffer(pComp, pBuf, buf_size, TDEFL_FINISH) != + TDEFL_STATUS_DONE)) { + pZip->m_pFree(pZip->m_pAlloc_opaque, pComp); + return mz_zip_set_error(pZip, MZ_ZIP_COMPRESSION_FAILED); + } + + comp_size = state.m_comp_size; + cur_archive_file_ofs = state.m_cur_archive_file_ofs; + } + + pZip->m_pFree(pZip->m_pAlloc_opaque, pComp); + pComp = NULL; + + if (uncomp_size) { + mz_uint8 local_dir_footer[MZ_ZIP_DATA_DESCRIPTER_SIZE64]; + mz_uint32 local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE32; + + MZ_ASSERT(bit_flags & MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR); + + MZ_WRITE_LE32(local_dir_footer + 0, MZ_ZIP_DATA_DESCRIPTOR_ID); + MZ_WRITE_LE32(local_dir_footer + 4, uncomp_crc32); + if (pExtra_data == NULL) { + if (comp_size > MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); + + MZ_WRITE_LE32(local_dir_footer + 8, comp_size); + MZ_WRITE_LE32(local_dir_footer + 12, uncomp_size); + } else { + MZ_WRITE_LE64(local_dir_footer + 8, comp_size); + MZ_WRITE_LE64(local_dir_footer + 16, uncomp_size); + local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE64; + } + + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, + local_dir_footer, + local_dir_footer_size) != local_dir_footer_size) + return MZ_FALSE; + + cur_archive_file_ofs += local_dir_footer_size; + } + + if (pExtra_data != NULL) { + extra_size = mz_zip_writer_create_zip64_extra_data( + extra_data, (uncomp_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL, + (uncomp_size >= MZ_UINT32_MAX) ? &comp_size : NULL, + (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL); + } + + if (!mz_zip_writer_add_to_central_dir( + pZip, pArchive_name, (mz_uint16)archive_name_size, pExtra_data, + (mz_uint16)extra_size, pComment, comment_size, uncomp_size, comp_size, + uncomp_crc32, method, bit_flags, dos_time, dos_date, + local_dir_header_ofs, ext_attributes, user_extra_data_central, + user_extra_data_central_len)) + return MZ_FALSE; + + pZip->m_total_files++; + pZip->m_archive_size = cur_archive_file_ofs; + + return MZ_TRUE; +} + +mz_bool mz_zip_writer_add_read_buf_callback( + mz_zip_archive *pZip, const char *pArchive_name, + mz_file_read_func read_callback, void *callback_opaque, mz_uint64 max_size, + const MZ_TIME_T *pFile_time, const void *pComment, mz_uint16 comment_size, + mz_uint level_and_flags, mz_uint32 ext_attributes, + const char *user_extra_data, mz_uint user_extra_data_len, + const char *user_extra_data_central, mz_uint user_extra_data_central_len) { + mz_uint16 gen_flags = (level_and_flags & MZ_ZIP_FLAG_WRITE_HEADER_SET_SIZE) + ? 0 + : MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR; + mz_uint uncomp_crc32 = MZ_CRC32_INIT, level, num_alignment_padding_bytes; + mz_uint16 method = 0, dos_time = 0, dos_date = 0; + mz_uint64 local_dir_header_ofs, cur_archive_file_ofs = pZip->m_archive_size, + uncomp_size = 0, comp_size = 0; + size_t archive_name_size; + mz_uint8 local_dir_header[MZ_ZIP_LOCAL_DIR_HEADER_SIZE]; + mz_uint8 *pExtra_data = NULL; + mz_uint32 extra_size = 0; + mz_uint8 extra_data[MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE]; + mz_zip_internal_state *pState; + mz_uint64 file_ofs = 0, cur_archive_header_file_ofs; + + if (!(level_and_flags & MZ_ZIP_FLAG_ASCII_FILENAME)) + gen_flags |= MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8; + + if ((int)level_and_flags < 0) + level_and_flags = MZ_DEFAULT_LEVEL; + level = level_and_flags & 0xF; + + /* Sanity checks */ + if ((!pZip) || (!pZip->m_pState) || + (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || (!pArchive_name) || + ((comment_size) && (!pComment)) || (level > MZ_UBER_COMPRESSION)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + pState = pZip->m_pState; + + if ((!pState->m_zip64) && (max_size > MZ_UINT32_MAX)) { + /* Source file is too large for non-zip64 */ + /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */ + pState->m_zip64 = MZ_TRUE; + } + + /* We could support this, but why? */ + if (level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + if (!mz_zip_writer_validate_archive_name(pArchive_name)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_FILENAME); + + if (pState->m_zip64) { + if (pZip->m_total_files == MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); + } else { + if (pZip->m_total_files == MZ_UINT16_MAX) { + pState->m_zip64 = MZ_TRUE; + /*return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); */ + } + } + + archive_name_size = strlen(pArchive_name); + if (archive_name_size > MZ_UINT16_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_FILENAME); + + num_alignment_padding_bytes = + mz_zip_writer_compute_padding_needed_for_file_alignment(pZip); + + /* miniz doesn't support central dirs >= MZ_UINT32_MAX bytes yet */ + if (((mz_uint64)pState->m_central_dir.m_size + + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + + MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE + comment_size) >= MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE); + + if (!pState->m_zip64) { + /* Bail early if the archive would obviously become too large */ + if ((pZip->m_archive_size + num_alignment_padding_bytes + + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + archive_name_size + + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + comment_size + + user_extra_data_len + pState->m_central_dir.m_size + + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE + 1024 + + MZ_ZIP_DATA_DESCRIPTER_SIZE32 + user_extra_data_central_len) > + 0xFFFFFFFF) { + pState->m_zip64 = MZ_TRUE; + /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */ + } + } + +#ifndef MINIZ_NO_TIME + if (pFile_time) { + mz_zip_time_t_to_dos_time(*pFile_time, &dos_time, &dos_date); + } +#endif + + if (max_size <= 3) + level = 0; + + if (!mz_zip_writer_write_zeros(pZip, cur_archive_file_ofs, + num_alignment_padding_bytes)) { + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + } + + cur_archive_file_ofs += num_alignment_padding_bytes; + local_dir_header_ofs = cur_archive_file_ofs; + + if (pZip->m_file_offset_alignment) { + MZ_ASSERT((cur_archive_file_ofs & (pZip->m_file_offset_alignment - 1)) == + 0); + } + + if (max_size && level) { + method = MZ_DEFLATED; + } + + MZ_CLEAR_OBJ(local_dir_header); + if (pState->m_zip64) { + if (max_size >= MZ_UINT32_MAX || local_dir_header_ofs >= MZ_UINT32_MAX) { + pExtra_data = extra_data; + if (level_and_flags & MZ_ZIP_FLAG_WRITE_HEADER_SET_SIZE) + extra_size = mz_zip_writer_create_zip64_extra_data( + extra_data, (max_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL, + (max_size >= MZ_UINT32_MAX) ? &comp_size : NULL, + (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs + : NULL); + else + extra_size = mz_zip_writer_create_zip64_extra_data( + extra_data, NULL, NULL, + (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs + : NULL); + } + + if (!mz_zip_writer_create_local_dir_header( + pZip, local_dir_header, (mz_uint16)archive_name_size, + (mz_uint16)(extra_size + user_extra_data_len), 0, 0, 0, method, + gen_flags, dos_time, dos_date)) + return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR); + + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, + local_dir_header, + sizeof(local_dir_header)) != sizeof(local_dir_header)) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + + cur_archive_file_ofs += sizeof(local_dir_header); + + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, + archive_name_size) != archive_name_size) { + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + } + + cur_archive_file_ofs += archive_name_size; + + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, extra_data, + extra_size) != extra_size) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + + cur_archive_file_ofs += extra_size; + } else { + if ((comp_size > MZ_UINT32_MAX) || (cur_archive_file_ofs > MZ_UINT32_MAX)) + return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); + if (!mz_zip_writer_create_local_dir_header( + pZip, local_dir_header, (mz_uint16)archive_name_size, + (mz_uint16)user_extra_data_len, 0, 0, 0, method, gen_flags, + dos_time, dos_date)) + return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR); + + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, + local_dir_header, + sizeof(local_dir_header)) != sizeof(local_dir_header)) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + + cur_archive_file_ofs += sizeof(local_dir_header); + + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, + archive_name_size) != archive_name_size) { + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + } + + cur_archive_file_ofs += archive_name_size; + } + + if (user_extra_data_len > 0) { + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, + user_extra_data, + user_extra_data_len) != user_extra_data_len) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + + cur_archive_file_ofs += user_extra_data_len; + } + + if (max_size) { + void *pRead_buf = + pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, MZ_ZIP_MAX_IO_BUF_SIZE); + if (!pRead_buf) { + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + } + + if (!level) { + while (1) { + size_t n = read_callback(callback_opaque, file_ofs, pRead_buf, + MZ_ZIP_MAX_IO_BUF_SIZE); + if (n == 0) + break; + + if ((n > MZ_ZIP_MAX_IO_BUF_SIZE) || (file_ofs + n > max_size)) { + pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + } + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pRead_buf, + n) != n) { + pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + } + file_ofs += n; + uncomp_crc32 = + (mz_uint32)mz_crc32(uncomp_crc32, (const mz_uint8 *)pRead_buf, n); + cur_archive_file_ofs += n; + } + uncomp_size = file_ofs; + comp_size = uncomp_size; + } else { + mz_bool result = MZ_FALSE; + mz_zip_writer_add_state state; + tdefl_compressor *pComp = (tdefl_compressor *)pZip->m_pAlloc( + pZip->m_pAlloc_opaque, 1, sizeof(tdefl_compressor)); + if (!pComp) { + pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf); + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + } + + state.m_pZip = pZip; + state.m_cur_archive_file_ofs = cur_archive_file_ofs; + state.m_comp_size = 0; + + if (tdefl_init(pComp, mz_zip_writer_add_put_buf_callback, &state, + tdefl_create_comp_flags_from_zip_params( + level, -15, MZ_DEFAULT_STRATEGY)) != + TDEFL_STATUS_OKAY) { + pZip->m_pFree(pZip->m_pAlloc_opaque, pComp); + pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf); + return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR); + } + + for (;;) { + tdefl_status status; + tdefl_flush flush = TDEFL_NO_FLUSH; + + size_t n = read_callback(callback_opaque, file_ofs, pRead_buf, + MZ_ZIP_MAX_IO_BUF_SIZE); + if ((n > MZ_ZIP_MAX_IO_BUF_SIZE) || (file_ofs + n > max_size)) { + mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + break; + } + + file_ofs += n; + uncomp_crc32 = + (mz_uint32)mz_crc32(uncomp_crc32, (const mz_uint8 *)pRead_buf, n); + + if (pZip->m_pNeeds_keepalive != NULL && + pZip->m_pNeeds_keepalive(pZip->m_pIO_opaque)) + flush = TDEFL_FULL_FLUSH; + + if (n == 0) + flush = TDEFL_FINISH; + + status = tdefl_compress_buffer(pComp, pRead_buf, n, flush); + if (status == TDEFL_STATUS_DONE) { + result = MZ_TRUE; + break; + } else if (status != TDEFL_STATUS_OKAY) { + mz_zip_set_error(pZip, MZ_ZIP_COMPRESSION_FAILED); + break; + } + } + + pZip->m_pFree(pZip->m_pAlloc_opaque, pComp); + + if (!result) { + pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf); + return MZ_FALSE; + } + + uncomp_size = file_ofs; + comp_size = state.m_comp_size; + cur_archive_file_ofs = state.m_cur_archive_file_ofs; + } + + pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf); + } + + if (!(level_and_flags & MZ_ZIP_FLAG_WRITE_HEADER_SET_SIZE)) { + mz_uint8 local_dir_footer[MZ_ZIP_DATA_DESCRIPTER_SIZE64]; + mz_uint32 local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE32; + + MZ_WRITE_LE32(local_dir_footer + 0, MZ_ZIP_DATA_DESCRIPTOR_ID); + MZ_WRITE_LE32(local_dir_footer + 4, uncomp_crc32); + if (pExtra_data == NULL) { + if (comp_size > MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); + + MZ_WRITE_LE32(local_dir_footer + 8, comp_size); + MZ_WRITE_LE32(local_dir_footer + 12, uncomp_size); + } else { + MZ_WRITE_LE64(local_dir_footer + 8, comp_size); + MZ_WRITE_LE64(local_dir_footer + 16, uncomp_size); + local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE64; + } + + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, + local_dir_footer, + local_dir_footer_size) != local_dir_footer_size) + return MZ_FALSE; + + cur_archive_file_ofs += local_dir_footer_size; + } + + if (level_and_flags & MZ_ZIP_FLAG_WRITE_HEADER_SET_SIZE) { + if (pExtra_data != NULL) { + extra_size = mz_zip_writer_create_zip64_extra_data( + extra_data, (max_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL, + (max_size >= MZ_UINT32_MAX) ? &comp_size : NULL, + (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs + : NULL); + } + + if (!mz_zip_writer_create_local_dir_header( + pZip, local_dir_header, (mz_uint16)archive_name_size, + (mz_uint16)(extra_size + user_extra_data_len), + (max_size >= MZ_UINT32_MAX) ? MZ_UINT32_MAX : uncomp_size, + (max_size >= MZ_UINT32_MAX) ? MZ_UINT32_MAX : comp_size, + uncomp_crc32, method, gen_flags, dos_time, dos_date)) + return mz_zip_set_error(pZip, MZ_ZIP_INTERNAL_ERROR); + + cur_archive_header_file_ofs = local_dir_header_ofs; + + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_header_file_ofs, + local_dir_header, + sizeof(local_dir_header)) != sizeof(local_dir_header)) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + + if (pExtra_data != NULL) { + cur_archive_header_file_ofs += sizeof(local_dir_header); + + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_header_file_ofs, + pArchive_name, + archive_name_size) != archive_name_size) { + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + } + + cur_archive_header_file_ofs += archive_name_size; + + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_header_file_ofs, + extra_data, extra_size) != extra_size) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + + cur_archive_header_file_ofs += extra_size; + } + } + + if (pExtra_data != NULL) { + extra_size = mz_zip_writer_create_zip64_extra_data( + extra_data, (uncomp_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL, + (uncomp_size >= MZ_UINT32_MAX) ? &comp_size : NULL, + (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL); + } + + if (!mz_zip_writer_add_to_central_dir( + pZip, pArchive_name, (mz_uint16)archive_name_size, pExtra_data, + (mz_uint16)extra_size, pComment, comment_size, uncomp_size, comp_size, + uncomp_crc32, method, gen_flags, dos_time, dos_date, + local_dir_header_ofs, ext_attributes, user_extra_data_central, + user_extra_data_central_len)) + return MZ_FALSE; + + pZip->m_total_files++; + pZip->m_archive_size = cur_archive_file_ofs; + + return MZ_TRUE; +} + +#ifndef MINIZ_NO_STDIO + +static size_t mz_file_read_func_stdio(void *pOpaque, mz_uint64 file_ofs, + void *pBuf, size_t n) { + MZ_FILE *pSrc_file = (MZ_FILE *)pOpaque; + mz_int64 cur_ofs = MZ_FTELL64(pSrc_file); + + if (((mz_int64)file_ofs < 0) || + (((cur_ofs != (mz_int64)file_ofs)) && + (MZ_FSEEK64(pSrc_file, (mz_int64)file_ofs, SEEK_SET)))) + return 0; + + return MZ_FREAD(pBuf, 1, n, pSrc_file); +} + +mz_bool mz_zip_writer_add_cfile( + mz_zip_archive *pZip, const char *pArchive_name, MZ_FILE *pSrc_file, + mz_uint64 max_size, const MZ_TIME_T *pFile_time, const void *pComment, + mz_uint16 comment_size, mz_uint level_and_flags, mz_uint32 ext_attributes, + const char *user_extra_data, mz_uint user_extra_data_len, + const char *user_extra_data_central, mz_uint user_extra_data_central_len) { + return mz_zip_writer_add_read_buf_callback( + pZip, pArchive_name, mz_file_read_func_stdio, pSrc_file, max_size, + pFile_time, pComment, comment_size, level_and_flags, ext_attributes, + user_extra_data, user_extra_data_len, user_extra_data_central, + user_extra_data_central_len); +} + +mz_bool mz_zip_writer_add_file(mz_zip_archive *pZip, const char *pArchive_name, + const char *pSrc_filename, const void *pComment, + mz_uint16 comment_size, mz_uint level_and_flags, + mz_uint32 ext_attributes) { + MZ_FILE *pSrc_file = NULL; + mz_uint64 uncomp_size = 0; + MZ_TIME_T file_modified_time; + MZ_TIME_T *pFile_time = NULL; + mz_bool status; + + memset(&file_modified_time, 0, sizeof(file_modified_time)); + +#if !defined(MINIZ_NO_TIME) && !defined(MINIZ_NO_STDIO) + pFile_time = &file_modified_time; + if (!mz_zip_get_file_modified_time(pSrc_filename, &file_modified_time)) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_STAT_FAILED); +#endif + + pSrc_file = MZ_FOPEN(pSrc_filename, "rb"); + if (!pSrc_file) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED); + + MZ_FSEEK64(pSrc_file, 0, SEEK_END); + uncomp_size = MZ_FTELL64(pSrc_file); + MZ_FSEEK64(pSrc_file, 0, SEEK_SET); + + status = mz_zip_writer_add_cfile( + pZip, pArchive_name, pSrc_file, uncomp_size, pFile_time, pComment, + comment_size, level_and_flags, ext_attributes, NULL, 0, NULL, 0); + + MZ_FCLOSE(pSrc_file); + + return status; +} +#endif /* #ifndef MINIZ_NO_STDIO */ + +static mz_bool mz_zip_writer_update_zip64_extension_block( + mz_zip_array *pNew_ext, mz_zip_archive *pZip, const mz_uint8 *pExt, + uint32_t ext_len, mz_uint64 *pComp_size, mz_uint64 *pUncomp_size, + mz_uint64 *pLocal_header_ofs, mz_uint32 *pDisk_start) { + /* + 64 should be enough for any new zip64 data */ + if (!mz_zip_array_reserve(pZip, pNew_ext, ext_len + 64, MZ_FALSE)) + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + + mz_zip_array_resize(pZip, pNew_ext, 0, MZ_FALSE); + + if ((pUncomp_size) || (pComp_size) || (pLocal_header_ofs) || (pDisk_start)) { + mz_uint8 new_ext_block[64]; + mz_uint8 *pDst = new_ext_block; + mz_write_le16(pDst, MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID); + mz_write_le16(pDst + sizeof(mz_uint16), 0); + pDst += sizeof(mz_uint16) * 2; + + if (pUncomp_size) { + mz_write_le64(pDst, *pUncomp_size); + pDst += sizeof(mz_uint64); + } + + if (pComp_size) { + mz_write_le64(pDst, *pComp_size); + pDst += sizeof(mz_uint64); + } + + if (pLocal_header_ofs) { + mz_write_le64(pDst, *pLocal_header_ofs); + pDst += sizeof(mz_uint64); + } + + if (pDisk_start) { + mz_write_le32(pDst, *pDisk_start); + pDst += sizeof(mz_uint32); + } + + mz_write_le16(new_ext_block + sizeof(mz_uint16), + (mz_uint16)((pDst - new_ext_block) - sizeof(mz_uint16) * 2)); + + if (!mz_zip_array_push_back(pZip, pNew_ext, new_ext_block, + pDst - new_ext_block)) + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + } + + if ((pExt) && (ext_len)) { + mz_uint32 extra_size_remaining = ext_len; + const mz_uint8 *pExtra_data = pExt; + + do { + mz_uint32 field_id, field_data_size, field_total_size; + + if (extra_size_remaining < (sizeof(mz_uint16) * 2)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + field_id = MZ_READ_LE16(pExtra_data); + field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16)); + field_total_size = field_data_size + sizeof(mz_uint16) * 2; + + if (field_total_size > extra_size_remaining) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + if (field_id != MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID) { + if (!mz_zip_array_push_back(pZip, pNew_ext, pExtra_data, + field_total_size)) + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + } + + pExtra_data += field_total_size; + extra_size_remaining -= field_total_size; + } while (extra_size_remaining); + } + + return MZ_TRUE; +} + +/* TODO: This func is now pretty freakin complex due to zip64, split it up? */ +mz_bool mz_zip_writer_add_from_zip_reader(mz_zip_archive *pZip, + mz_zip_archive *pSource_zip, + mz_uint src_file_index) { + mz_uint n, bit_flags, num_alignment_padding_bytes, + src_central_dir_following_data_size; + mz_uint64 src_archive_bytes_remaining, local_dir_header_ofs; + mz_uint64 cur_src_file_ofs, cur_dst_file_ofs; + mz_uint32 + local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / + sizeof(mz_uint32)]; + mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32; + mz_uint8 new_central_header[MZ_ZIP_CENTRAL_DIR_HEADER_SIZE]; + size_t orig_central_dir_size; + mz_zip_internal_state *pState; + void *pBuf; + const mz_uint8 *pSrc_central_header; + mz_zip_archive_file_stat src_file_stat; + mz_uint32 src_filename_len, src_comment_len, src_ext_len; + mz_uint32 local_header_filename_size, local_header_extra_len; + mz_uint64 local_header_comp_size, local_header_uncomp_size; + mz_bool found_zip64_ext_data_in_ldir = MZ_FALSE; + + /* Sanity checks */ + if ((!pZip) || (!pZip->m_pState) || + (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || (!pSource_zip->m_pRead)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + pState = pZip->m_pState; + + /* Don't support copying files from zip64 archives to non-zip64, even though + * in some cases this is possible */ + if ((pSource_zip->m_pState->m_zip64) && (!pZip->m_pState->m_zip64)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + /* Get pointer to the source central dir header and crack it */ + if (NULL == + (pSrc_central_header = mz_zip_get_cdh(pSource_zip, src_file_index))) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + if (MZ_READ_LE32(pSrc_central_header + MZ_ZIP_CDH_SIG_OFS) != + MZ_ZIP_CENTRAL_DIR_HEADER_SIG) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + src_filename_len = + MZ_READ_LE16(pSrc_central_header + MZ_ZIP_CDH_FILENAME_LEN_OFS); + src_comment_len = + MZ_READ_LE16(pSrc_central_header + MZ_ZIP_CDH_COMMENT_LEN_OFS); + src_ext_len = MZ_READ_LE16(pSrc_central_header + MZ_ZIP_CDH_EXTRA_LEN_OFS); + src_central_dir_following_data_size = + src_filename_len + src_ext_len + src_comment_len; + + /* TODO: We don't support central dir's >= MZ_UINT32_MAX bytes right now (+32 + * fudge factor in case we need to add more extra data) */ + if ((pState->m_central_dir.m_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + + src_central_dir_following_data_size + 32) >= MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE); + + num_alignment_padding_bytes = + mz_zip_writer_compute_padding_needed_for_file_alignment(pZip); + + if (!pState->m_zip64) { + if (pZip->m_total_files == MZ_UINT16_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); + } else { + /* TODO: Our zip64 support still has some 32-bit limits that may not be + * worth fixing. */ + if (pZip->m_total_files == MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); + } + + if (!mz_zip_file_stat_internal(pSource_zip, src_file_index, + pSrc_central_header, &src_file_stat, NULL)) + return MZ_FALSE; + + cur_src_file_ofs = src_file_stat.m_local_header_ofs; + cur_dst_file_ofs = pZip->m_archive_size; + + /* Read the source archive's local dir header */ + if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, + pLocal_header, MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != + MZ_ZIP_LOCAL_DIR_HEADER_SIZE) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + + if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + + cur_src_file_ofs += MZ_ZIP_LOCAL_DIR_HEADER_SIZE; + + /* Compute the total size we need to copy (filename+extra data+compressed + * data) */ + local_header_filename_size = + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS); + local_header_extra_len = + MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS); + local_header_comp_size = + MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_COMPRESSED_SIZE_OFS); + local_header_uncomp_size = + MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS); + src_archive_bytes_remaining = local_header_filename_size + + local_header_extra_len + + src_file_stat.m_comp_size; + + /* Try to find a zip64 extended information field */ + if ((local_header_extra_len) && + ((local_header_comp_size == MZ_UINT32_MAX) || + (local_header_uncomp_size == MZ_UINT32_MAX))) { + mz_zip_array file_data_array; + const mz_uint8 *pExtra_data; + mz_uint32 extra_size_remaining = local_header_extra_len; + + mz_zip_array_init(&file_data_array, 1); + if (!mz_zip_array_resize(pZip, &file_data_array, local_header_extra_len, + MZ_FALSE)) { + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + } + + if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, + src_file_stat.m_local_header_ofs + + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + + local_header_filename_size, + file_data_array.m_p, local_header_extra_len) != + local_header_extra_len) { + mz_zip_array_clear(pZip, &file_data_array); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + } + + pExtra_data = (const mz_uint8 *)file_data_array.m_p; + + do { + mz_uint32 field_id, field_data_size, field_total_size; + + if (extra_size_remaining < (sizeof(mz_uint16) * 2)) { + mz_zip_array_clear(pZip, &file_data_array); + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + } + + field_id = MZ_READ_LE16(pExtra_data); + field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16)); + field_total_size = field_data_size + sizeof(mz_uint16) * 2; + + if (field_total_size > extra_size_remaining) { + mz_zip_array_clear(pZip, &file_data_array); + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + } + + if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID) { + const mz_uint8 *pSrc_field_data = pExtra_data + sizeof(mz_uint32); + + if (field_data_size < sizeof(mz_uint64) * 2) { + mz_zip_array_clear(pZip, &file_data_array); + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED); + } + + local_header_uncomp_size = MZ_READ_LE64(pSrc_field_data); + local_header_comp_size = MZ_READ_LE64( + pSrc_field_data + + sizeof(mz_uint64)); /* may be 0 if there's a descriptor */ + + found_zip64_ext_data_in_ldir = MZ_TRUE; + break; + } + + pExtra_data += field_total_size; + extra_size_remaining -= field_total_size; + } while (extra_size_remaining); + + mz_zip_array_clear(pZip, &file_data_array); + } + + if (!pState->m_zip64) { + /* Try to detect if the new archive will most likely wind up too big and + * bail early (+(sizeof(mz_uint32) * 4) is for the optional descriptor which + * could be present, +64 is a fudge factor). */ + /* We also check when the archive is finalized so this doesn't need to be + * perfect. */ + mz_uint64 approx_new_archive_size = + cur_dst_file_ofs + num_alignment_padding_bytes + + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + src_archive_bytes_remaining + + (sizeof(mz_uint32) * 4) + pState->m_central_dir.m_size + + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + src_central_dir_following_data_size + + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE + 64; + + if (approx_new_archive_size >= MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); + } + + /* Write dest archive padding */ + if (!mz_zip_writer_write_zeros(pZip, cur_dst_file_ofs, + num_alignment_padding_bytes)) + return MZ_FALSE; + + cur_dst_file_ofs += num_alignment_padding_bytes; + + local_dir_header_ofs = cur_dst_file_ofs; + if (pZip->m_file_offset_alignment) { + MZ_ASSERT((local_dir_header_ofs & (pZip->m_file_offset_alignment - 1)) == + 0); + } + + /* The original zip's local header+ext block doesn't change, even with zip64, + * so we can just copy it over to the dest zip */ + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_dst_file_ofs, pLocal_header, + MZ_ZIP_LOCAL_DIR_HEADER_SIZE) != + MZ_ZIP_LOCAL_DIR_HEADER_SIZE) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + + cur_dst_file_ofs += MZ_ZIP_LOCAL_DIR_HEADER_SIZE; + + /* Copy over the source archive bytes to the dest archive, also ensure we have + * enough buf space to handle optional data descriptor */ + if (NULL == (pBuf = pZip->m_pAlloc( + pZip->m_pAlloc_opaque, 1, + (size_t)MZ_MAX(32U, MZ_MIN((mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE, + src_archive_bytes_remaining))))) + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + + while (src_archive_bytes_remaining) { + n = (mz_uint)MZ_MIN((mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE, + src_archive_bytes_remaining); + if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf, + n) != n) { + pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + } + cur_src_file_ofs += n; + + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_dst_file_ofs, pBuf, n) != n) { + pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + } + cur_dst_file_ofs += n; + + src_archive_bytes_remaining -= n; + } + + /* Now deal with the optional data descriptor */ + bit_flags = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_BIT_FLAG_OFS); + if (bit_flags & 8) { + /* Copy data descriptor */ + if ((pSource_zip->m_pState->m_zip64) || (found_zip64_ext_data_in_ldir)) { + /* src is zip64, dest must be zip64 */ + + /* name uint32_t's */ + /* id 1 (optional in zip64?) */ + /* crc 1 */ + /* comp_size 2 */ + /* uncomp_size 2 */ + if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, + pBuf, (sizeof(mz_uint32) * 6)) != + (sizeof(mz_uint32) * 6)) { + pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + } + + n = sizeof(mz_uint32) * + ((MZ_READ_LE32(pBuf) == MZ_ZIP_DATA_DESCRIPTOR_ID) ? 6 : 5); + } else { + /* src is NOT zip64 */ + mz_bool has_id; + + if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, + pBuf, sizeof(mz_uint32) * 4) != + sizeof(mz_uint32) * 4) { + pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED); + } + + has_id = (MZ_READ_LE32(pBuf) == MZ_ZIP_DATA_DESCRIPTOR_ID); + + if (pZip->m_pState->m_zip64) { + /* dest is zip64, so upgrade the data descriptor */ + const mz_uint32 *pSrc_descriptor = + (const mz_uint32 *)((const mz_uint8 *)pBuf + + (has_id ? sizeof(mz_uint32) : 0)); + const mz_uint32 src_crc32 = pSrc_descriptor[0]; + const mz_uint64 src_comp_size = pSrc_descriptor[1]; + const mz_uint64 src_uncomp_size = pSrc_descriptor[2]; + + mz_write_le32((mz_uint8 *)pBuf, MZ_ZIP_DATA_DESCRIPTOR_ID); + mz_write_le32((mz_uint8 *)pBuf + sizeof(mz_uint32) * 1, src_crc32); + mz_write_le64((mz_uint8 *)pBuf + sizeof(mz_uint32) * 2, src_comp_size); + mz_write_le64((mz_uint8 *)pBuf + sizeof(mz_uint32) * 4, + src_uncomp_size); + + n = sizeof(mz_uint32) * 6; + } else { + /* dest is NOT zip64, just copy it as-is */ + n = sizeof(mz_uint32) * (has_id ? 4 : 3); + } + } + + if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_dst_file_ofs, pBuf, n) != n) { + pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf); + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + } + + cur_src_file_ofs += n; + cur_dst_file_ofs += n; + } + pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf); + + /* Finally, add the new central dir header */ + orig_central_dir_size = pState->m_central_dir.m_size; + + memcpy(new_central_header, pSrc_central_header, + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE); + + if (pState->m_zip64) { + /* This is the painful part: We need to write a new central dir header + ext + * block with updated zip64 fields, and ensure the old fields (if any) are + * not included. */ + const mz_uint8 *pSrc_ext = + pSrc_central_header + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + src_filename_len; + mz_zip_array new_ext_block; + + mz_zip_array_init(&new_ext_block, sizeof(mz_uint8)); + + MZ_WRITE_LE32(new_central_header + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS, + MZ_UINT32_MAX); + MZ_WRITE_LE32(new_central_header + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS, + MZ_UINT32_MAX); + MZ_WRITE_LE32(new_central_header + MZ_ZIP_CDH_LOCAL_HEADER_OFS, + MZ_UINT32_MAX); + + if (!mz_zip_writer_update_zip64_extension_block( + &new_ext_block, pZip, pSrc_ext, src_ext_len, + &src_file_stat.m_comp_size, &src_file_stat.m_uncomp_size, + &local_dir_header_ofs, NULL)) { + mz_zip_array_clear(pZip, &new_ext_block); + return MZ_FALSE; + } + + MZ_WRITE_LE16(new_central_header + MZ_ZIP_CDH_EXTRA_LEN_OFS, + new_ext_block.m_size); + + if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, + new_central_header, + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE)) { + mz_zip_array_clear(pZip, &new_ext_block); + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + } + + if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, + pSrc_central_header + + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, + src_filename_len)) { + mz_zip_array_clear(pZip, &new_ext_block); + mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, + MZ_FALSE); + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + } + + if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, new_ext_block.m_p, + new_ext_block.m_size)) { + mz_zip_array_clear(pZip, &new_ext_block); + mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, + MZ_FALSE); + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + } + + if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, + pSrc_central_header + + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + + src_filename_len + src_ext_len, + src_comment_len)) { + mz_zip_array_clear(pZip, &new_ext_block); + mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, + MZ_FALSE); + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + } + + mz_zip_array_clear(pZip, &new_ext_block); + } else { + /* sanity checks */ + if (cur_dst_file_ofs > MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); + + if (local_dir_header_ofs >= MZ_UINT32_MAX) + return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); + + MZ_WRITE_LE32(new_central_header + MZ_ZIP_CDH_LOCAL_HEADER_OFS, + local_dir_header_ofs); + + if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, + new_central_header, + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE)) + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + + if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, + pSrc_central_header + + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, + src_central_dir_following_data_size)) { + mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, + MZ_FALSE); + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + } + } + + /* This shouldn't trigger unless we screwed up during the initial sanity + * checks */ + if (pState->m_central_dir.m_size >= MZ_UINT32_MAX) { + /* TODO: Support central dirs >= 32-bits in size */ + mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, + MZ_FALSE); + return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE); + } + + n = (mz_uint32)orig_central_dir_size; + if (!mz_zip_array_push_back(pZip, &pState->m_central_dir_offsets, &n, 1)) { + mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, + MZ_FALSE); + return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED); + } + + pZip->m_total_files++; + pZip->m_archive_size = cur_dst_file_ofs; + + return MZ_TRUE; +} + +mz_bool mz_zip_writer_finalize_archive(mz_zip_archive *pZip) { + mz_zip_internal_state *pState; + mz_uint64 central_dir_ofs, central_dir_size; + mz_uint8 hdr[256]; + + if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + pState = pZip->m_pState; + + if (pState->m_zip64) { + if ((pZip->m_total_files > MZ_UINT32_MAX) || + (pState->m_central_dir.m_size >= MZ_UINT32_MAX)) + return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); + } else { + if ((pZip->m_total_files > MZ_UINT16_MAX) || + ((pZip->m_archive_size + pState->m_central_dir.m_size + + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) > MZ_UINT32_MAX)) + return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); + } + + central_dir_ofs = 0; + central_dir_size = 0; + if (pZip->m_total_files) { + /* Write central directory */ + central_dir_ofs = pZip->m_archive_size; + central_dir_size = pState->m_central_dir.m_size; + pZip->m_central_directory_file_ofs = central_dir_ofs; + if (pZip->m_pWrite(pZip->m_pIO_opaque, central_dir_ofs, + pState->m_central_dir.m_p, + (size_t)central_dir_size) != central_dir_size) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + + pZip->m_archive_size += central_dir_size; + } + + if (pState->m_zip64) { + /* Write zip64 end of central directory header */ + mz_uint64 rel_ofs_to_zip64_ecdr = pZip->m_archive_size; + + MZ_CLEAR_OBJ(hdr); + MZ_WRITE_LE32(hdr + MZ_ZIP64_ECDH_SIG_OFS, + MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG); + MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_SIZE_OF_RECORD_OFS, + MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE - sizeof(mz_uint32) - + sizeof(mz_uint64)); + MZ_WRITE_LE16(hdr + MZ_ZIP64_ECDH_VERSION_MADE_BY_OFS, + 0x031E); /* TODO: always Unix */ + MZ_WRITE_LE16(hdr + MZ_ZIP64_ECDH_VERSION_NEEDED_OFS, 0x002D); + MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS, + pZip->m_total_files); + MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS, + pZip->m_total_files); + MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_CDIR_SIZE_OFS, central_dir_size); + MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_CDIR_OFS_OFS, central_dir_ofs); + if (pZip->m_pWrite(pZip->m_pIO_opaque, pZip->m_archive_size, hdr, + MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) != + MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + + pZip->m_archive_size += MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE; + + /* Write zip64 end of central directory locator */ + MZ_CLEAR_OBJ(hdr); + MZ_WRITE_LE32(hdr + MZ_ZIP64_ECDL_SIG_OFS, + MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG); + MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS, + rel_ofs_to_zip64_ecdr); + MZ_WRITE_LE32(hdr + MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS, 1); + if (pZip->m_pWrite(pZip->m_pIO_opaque, pZip->m_archive_size, hdr, + MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE) != + MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + + pZip->m_archive_size += MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE; + } + + /* Write end of central directory record */ + MZ_CLEAR_OBJ(hdr); + MZ_WRITE_LE32(hdr + MZ_ZIP_ECDH_SIG_OFS, + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG); + MZ_WRITE_LE16(hdr + MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS, + MZ_MIN(MZ_UINT16_MAX, pZip->m_total_files)); + MZ_WRITE_LE16(hdr + MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS, + MZ_MIN(MZ_UINT16_MAX, pZip->m_total_files)); + MZ_WRITE_LE32(hdr + MZ_ZIP_ECDH_CDIR_SIZE_OFS, + MZ_MIN(MZ_UINT32_MAX, central_dir_size)); + MZ_WRITE_LE32(hdr + MZ_ZIP_ECDH_CDIR_OFS_OFS, + MZ_MIN(MZ_UINT32_MAX, central_dir_ofs)); + + if (pZip->m_pWrite(pZip->m_pIO_opaque, pZip->m_archive_size, hdr, + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) != + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_WRITE_FAILED); + +#ifndef MINIZ_NO_STDIO + if ((pState->m_pFile) && (MZ_FFLUSH(pState->m_pFile) == EOF)) + return mz_zip_set_error(pZip, MZ_ZIP_FILE_CLOSE_FAILED); +#endif /* #ifndef MINIZ_NO_STDIO */ + + pZip->m_archive_size += MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE; + + pZip->m_zip_mode = MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED; + return MZ_TRUE; +} + +mz_bool mz_zip_writer_finalize_heap_archive(mz_zip_archive *pZip, void **ppBuf, + size_t *pSize) { + if ((!ppBuf) || (!pSize)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + *ppBuf = NULL; + *pSize = 0; + + if ((!pZip) || (!pZip->m_pState)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + if (pZip->m_pWrite != mz_zip_heap_write_func) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + if (!mz_zip_writer_finalize_archive(pZip)) + return MZ_FALSE; + + *ppBuf = pZip->m_pState->m_pMem; + *pSize = pZip->m_pState->m_mem_size; + pZip->m_pState->m_pMem = NULL; + pZip->m_pState->m_mem_size = pZip->m_pState->m_mem_capacity = 0; + + return MZ_TRUE; +} + +mz_bool mz_zip_writer_end(mz_zip_archive *pZip) { + return mz_zip_writer_end_internal(pZip, MZ_TRUE); +} + +#ifndef MINIZ_NO_STDIO +mz_bool mz_zip_add_mem_to_archive_file_in_place( + const char *pZip_filename, const char *pArchive_name, const void *pBuf, + size_t buf_size, const void *pComment, mz_uint16 comment_size, + mz_uint level_and_flags) { + return mz_zip_add_mem_to_archive_file_in_place_v2( + pZip_filename, pArchive_name, pBuf, buf_size, pComment, comment_size, + level_and_flags, NULL); +} + +mz_bool mz_zip_add_mem_to_archive_file_in_place_v2( + const char *pZip_filename, const char *pArchive_name, const void *pBuf, + size_t buf_size, const void *pComment, mz_uint16 comment_size, + mz_uint level_and_flags, mz_zip_error *pErr) { + mz_bool status, created_new_archive = MZ_FALSE; + mz_zip_archive zip_archive; + struct MZ_FILE_STAT_STRUCT file_stat; + mz_zip_error actual_err = MZ_ZIP_NO_ERROR; + + mz_zip_zero_struct(&zip_archive); + if ((int)level_and_flags < 0) + level_and_flags = MZ_DEFAULT_LEVEL; + + if ((!pZip_filename) || (!pArchive_name) || ((buf_size) && (!pBuf)) || + ((comment_size) && (!pComment)) || + ((level_and_flags & 0xF) > MZ_UBER_COMPRESSION)) { + if (pErr) + *pErr = MZ_ZIP_INVALID_PARAMETER; + return MZ_FALSE; + } + + if (!mz_zip_writer_validate_archive_name(pArchive_name)) { + if (pErr) + *pErr = MZ_ZIP_INVALID_FILENAME; + return MZ_FALSE; + } + + /* Important: The regular non-64 bit version of stat() can fail here if the + * file is very large, which could cause the archive to be overwritten. */ + /* So be sure to compile with _LARGEFILE64_SOURCE 1 */ + if (MZ_FILE_STAT(pZip_filename, &file_stat) != 0) { + /* Create a new archive. */ + if (!mz_zip_writer_init_file_v2(&zip_archive, pZip_filename, 0, + level_and_flags)) { + if (pErr) + *pErr = zip_archive.m_last_error; + return MZ_FALSE; + } + + created_new_archive = MZ_TRUE; + } else { + /* Append to an existing archive. */ + if (!mz_zip_reader_init_file_v2( + &zip_archive, pZip_filename, + level_and_flags | MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY, 0, + 0)) { + if (pErr) + *pErr = zip_archive.m_last_error; + return MZ_FALSE; + } + + if (!mz_zip_writer_init_from_reader_v2(&zip_archive, pZip_filename, + level_and_flags)) { + if (pErr) + *pErr = zip_archive.m_last_error; + + mz_zip_reader_end_internal(&zip_archive, MZ_FALSE); + + return MZ_FALSE; + } + } + + status = + mz_zip_writer_add_mem_ex(&zip_archive, pArchive_name, pBuf, buf_size, + pComment, comment_size, level_and_flags, 0, 0); + actual_err = zip_archive.m_last_error; + + /* Always finalize, even if adding failed for some reason, so we have a valid + * central directory. (This may not always succeed, but we can try.) */ + if (!mz_zip_writer_finalize_archive(&zip_archive)) { + if (!actual_err) + actual_err = zip_archive.m_last_error; + + status = MZ_FALSE; + } + + if (!mz_zip_writer_end_internal(&zip_archive, status)) { + if (!actual_err) + actual_err = zip_archive.m_last_error; + + status = MZ_FALSE; + } + + if ((!status) && (created_new_archive)) { + /* It's a new archive and something went wrong, so just delete it. */ + int ignoredStatus = MZ_DELETE_FILE(pZip_filename); + (void)ignoredStatus; + } + + if (pErr) + *pErr = actual_err; + + return status; +} + +void *mz_zip_extract_archive_file_to_heap_v2(const char *pZip_filename, + const char *pArchive_name, + const char *pComment, + size_t *pSize, mz_uint flags, + mz_zip_error *pErr) { + mz_uint32 file_index; + mz_zip_archive zip_archive; + void *p = NULL; + + if (pSize) + *pSize = 0; + + if ((!pZip_filename) || (!pArchive_name)) { + if (pErr) + *pErr = MZ_ZIP_INVALID_PARAMETER; + + return NULL; + } + + mz_zip_zero_struct(&zip_archive); + if (!mz_zip_reader_init_file_v2( + &zip_archive, pZip_filename, + flags | MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY, 0, 0)) { + if (pErr) + *pErr = zip_archive.m_last_error; + + return NULL; + } + + if (mz_zip_reader_locate_file_v2(&zip_archive, pArchive_name, pComment, flags, + &file_index)) { + p = mz_zip_reader_extract_to_heap(&zip_archive, file_index, pSize, flags); + } + + mz_zip_reader_end_internal(&zip_archive, p != NULL); + + if (pErr) + *pErr = zip_archive.m_last_error; + + return p; +} + +void *mz_zip_extract_archive_file_to_heap(const char *pZip_filename, + const char *pArchive_name, + size_t *pSize, mz_uint flags) { + return mz_zip_extract_archive_file_to_heap_v2(pZip_filename, pArchive_name, + NULL, pSize, flags, NULL); +} + +#endif /* #ifndef MINIZ_NO_STDIO */ + +#endif /* #ifndef MINIZ_NO_ARCHIVE_WRITING_APIS */ + +/* ------------------- Misc utils */ + +mz_zip_mode mz_zip_get_mode(mz_zip_archive *pZip) { + return pZip ? pZip->m_zip_mode : MZ_ZIP_MODE_INVALID; +} + +mz_zip_type mz_zip_get_type(mz_zip_archive *pZip) { + return pZip ? pZip->m_zip_type : MZ_ZIP_TYPE_INVALID; +} + +mz_zip_error mz_zip_set_last_error(mz_zip_archive *pZip, mz_zip_error err_num) { + mz_zip_error prev_err; + + if (!pZip) + return MZ_ZIP_INVALID_PARAMETER; + + prev_err = pZip->m_last_error; + + pZip->m_last_error = err_num; + return prev_err; +} + +mz_zip_error mz_zip_peek_last_error(mz_zip_archive *pZip) { + if (!pZip) + return MZ_ZIP_INVALID_PARAMETER; + + return pZip->m_last_error; +} + +mz_zip_error mz_zip_clear_last_error(mz_zip_archive *pZip) { + return mz_zip_set_last_error(pZip, MZ_ZIP_NO_ERROR); +} + +mz_zip_error mz_zip_get_last_error(mz_zip_archive *pZip) { + mz_zip_error prev_err; + + if (!pZip) + return MZ_ZIP_INVALID_PARAMETER; + + prev_err = pZip->m_last_error; + + pZip->m_last_error = MZ_ZIP_NO_ERROR; + return prev_err; +} + +const char *mz_zip_get_error_string(mz_zip_error mz_err) { + switch (mz_err) { + case MZ_ZIP_NO_ERROR: + return "no error"; + case MZ_ZIP_UNDEFINED_ERROR: + return "undefined error"; + case MZ_ZIP_TOO_MANY_FILES: + return "too many files"; + case MZ_ZIP_FILE_TOO_LARGE: + return "file too large"; + case MZ_ZIP_UNSUPPORTED_METHOD: + return "unsupported method"; + case MZ_ZIP_UNSUPPORTED_ENCRYPTION: + return "unsupported encryption"; + case MZ_ZIP_UNSUPPORTED_FEATURE: + return "unsupported feature"; + case MZ_ZIP_FAILED_FINDING_CENTRAL_DIR: + return "failed finding central directory"; + case MZ_ZIP_NOT_AN_ARCHIVE: + return "not a ZIP archive"; + case MZ_ZIP_INVALID_HEADER_OR_CORRUPTED: + return "invalid header or archive is corrupted"; + case MZ_ZIP_UNSUPPORTED_MULTIDISK: + return "unsupported multidisk archive"; + case MZ_ZIP_DECOMPRESSION_FAILED: + return "decompression failed or archive is corrupted"; + case MZ_ZIP_COMPRESSION_FAILED: + return "compression failed"; + case MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE: + return "unexpected decompressed size"; + case MZ_ZIP_CRC_CHECK_FAILED: + return "CRC-32 check failed"; + case MZ_ZIP_UNSUPPORTED_CDIR_SIZE: + return "unsupported central directory size"; + case MZ_ZIP_ALLOC_FAILED: + return "allocation failed"; + case MZ_ZIP_FILE_OPEN_FAILED: + return "file open failed"; + case MZ_ZIP_FILE_CREATE_FAILED: + return "file create failed"; + case MZ_ZIP_FILE_WRITE_FAILED: + return "file write failed"; + case MZ_ZIP_FILE_READ_FAILED: + return "file read failed"; + case MZ_ZIP_FILE_CLOSE_FAILED: + return "file close failed"; + case MZ_ZIP_FILE_SEEK_FAILED: + return "file seek failed"; + case MZ_ZIP_FILE_STAT_FAILED: + return "file stat failed"; + case MZ_ZIP_INVALID_PARAMETER: + return "invalid parameter"; + case MZ_ZIP_INVALID_FILENAME: + return "invalid filename"; + case MZ_ZIP_BUF_TOO_SMALL: + return "buffer too small"; + case MZ_ZIP_INTERNAL_ERROR: + return "internal error"; + case MZ_ZIP_FILE_NOT_FOUND: + return "file not found"; + case MZ_ZIP_ARCHIVE_TOO_LARGE: + return "archive is too large"; + case MZ_ZIP_VALIDATION_FAILED: + return "validation failed"; + case MZ_ZIP_WRITE_CALLBACK_FAILED: + return "write calledback failed"; + default: + break; + } + + return "unknown error"; +} + +/* Note: Just because the archive is not zip64 doesn't necessarily mean it + * doesn't have Zip64 extended information extra field, argh. */ +mz_bool mz_zip_is_zip64(mz_zip_archive *pZip) { + if ((!pZip) || (!pZip->m_pState)) + return MZ_FALSE; + + return pZip->m_pState->m_zip64; +} + +size_t mz_zip_get_central_dir_size(mz_zip_archive *pZip) { + if ((!pZip) || (!pZip->m_pState)) + return 0; + + return pZip->m_pState->m_central_dir.m_size; +} + +mz_uint mz_zip_reader_get_num_files(mz_zip_archive *pZip) { + return pZip ? pZip->m_total_files : 0; +} + +mz_uint64 mz_zip_get_archive_size(mz_zip_archive *pZip) { + if (!pZip) + return 0; + return pZip->m_archive_size; +} + +mz_uint64 mz_zip_get_archive_file_start_offset(mz_zip_archive *pZip) { + if ((!pZip) || (!pZip->m_pState)) + return 0; + return pZip->m_pState->m_file_archive_start_ofs; +} + +MZ_FILE *mz_zip_get_cfile(mz_zip_archive *pZip) { + if ((!pZip) || (!pZip->m_pState)) + return 0; + return pZip->m_pState->m_pFile; +} + +size_t mz_zip_read_archive_data(mz_zip_archive *pZip, mz_uint64 file_ofs, + void *pBuf, size_t n) { + if ((!pZip) || (!pZip->m_pState) || (!pBuf) || (!pZip->m_pRead)) + return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + + return pZip->m_pRead(pZip->m_pIO_opaque, file_ofs, pBuf, n); +} + +mz_uint mz_zip_reader_get_filename(mz_zip_archive *pZip, mz_uint file_index, + char *pFilename, mz_uint filename_buf_size) { + mz_uint n; + const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index); + if (!p) { + if (filename_buf_size) + pFilename[0] = '\0'; + mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER); + return 0; + } + n = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS); + if (filename_buf_size) { + n = MZ_MIN(n, filename_buf_size - 1); + memcpy(pFilename, p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, n); + pFilename[n] = '\0'; + } + return n + 1; +} + +mz_bool mz_zip_reader_file_stat(mz_zip_archive *pZip, mz_uint file_index, + mz_zip_archive_file_stat *pStat) { + return mz_zip_file_stat_internal( + pZip, file_index, mz_zip_get_cdh(pZip, file_index), pStat, NULL); +} + +mz_bool mz_zip_end(mz_zip_archive *pZip) { + if (!pZip) + return MZ_FALSE; + + if (pZip->m_zip_mode == MZ_ZIP_MODE_READING) + return mz_zip_reader_end(pZip); +#ifndef MINIZ_NO_ARCHIVE_WRITING_APIS + else if ((pZip->m_zip_mode == MZ_ZIP_MODE_WRITING) || + (pZip->m_zip_mode == MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED)) + return mz_zip_writer_end(pZip); +#endif + + return MZ_FALSE; +} + +#ifdef __cplusplus +} +#endif + +#endif /*#ifndef MINIZ_NO_ARCHIVE_APIS*/ diff --git a/gta5-decrypter/main.c b/gta5-decrypter/main.c index 577c818..af28038 100644 --- a/gta5-decrypter/main.c +++ b/gta5-decrypter/main.c @@ -1,12 +1,14 @@ /* * -* GTA 5 PS3 Save Decrypter - (c) 2021 by Bucanero - www.bucanero.com.ar +* GTA 5 PS3/PS4 Save Decrypter - (c) 2021 by Bucanero - www.bucanero.com.ar * */ #include "../common/iofile.c" #include "../common/aes.c" +#define CHECKSUM_SEED 0x3FAC7125 + const u8 GTAV_PS3_KEY[32] = { 0x16, 0x85, 0xFF, 0xA3, 0x8D, 0x01, 0x0F, 0x0D, 0xFE, 0x66, 0x1C, 0xF9, 0xB5, 0x57, 0x2C, 0x50, 0x0D, 0x80, 0x26, 0x48, 0xDB, 0x37, 0xB9, 0xED, 0x0F, 0x48, 0xC5, 0x73, 0x42, 0xC0, 0x22, 0xF5 @@ -85,7 +87,7 @@ int main(int argc, char **argv) u8* data; char *opt, *bak; - printf("\nGTA5 PS3/PS4 Save Decrypter 0.2.0 - (c) 2021 by Bucanero\n\n"); + printf("\nGTA5 PS3/PS4 Save Decrypter 0.3.0 - (c) 2021 by Bucanero\n\n"); if (--argc < 2) { @@ -109,13 +111,43 @@ int main(int argc, char **argv) asprintf(&bak, "%s.bak", argv[2]); write_buffer(bak, data, len); - int isPS4 = (data[0] == 0 && data[1] == 0 && data[2] == 0) ? *(int*)(data + 0x108) : 0; + int isPS4 = (data[0] == 0 && data[1] == 0 && data[2] == 0); printf("[i] Platform Type: %s\n\n", isPS4 ? "PS4" : "PS3"); if (*opt == 'd') - decrypt_data(data + (isPS4 ? 0x114 : 0), (isPS4 ? ES32(isPS4) : len)); + decrypt_data(data + (isPS4 ? 0x114 : 0), (isPS4 ? (len - 0x114) : len)); else { + if (isPS4) + { + // fix title checksum + uint32_t seed; // must be 00 00 00 01 + uint8_t title[0x100]; + + // read first 4 bytes of file and reverse + memcpy(&seed, data, sizeof(uint32_t)); + seed = ES32(seed); + + // read title from offset 0x04 to 0x104 + memcpy(title, data + 0x04, sizeof(title)); + + // generate seed + seed = jenkins_one_at_a_time_hash((uint8_t*) &seed, sizeof(uint32_t), 0); + + // use generated seed to calculate title checksum + uint32_t title_chks = jenkins_one_at_a_time_hash(title, sizeof(title), seed); + + printf(" - Title Seed : %08X\n", seed); + printf(" - Old Checksum: %08X\n", ES32(*(uint32_t*)(data + 0x104))); + printf(" + New Checksum: %08X\n\n", title_chks); + title_chks = ES32(title_chks); + + // finally, fix the 4 byte checksum at 0x104 + memcpy(data + 0x104, &title_chks, sizeof(uint32_t)); + } + + // fix general checksum + uint32_t chks, chks_len; int chks_off = search_data(data, len, 0, "CHKS", 5); @@ -136,7 +168,7 @@ int main(int argc, char **argv) printf(" - Old Checksum: %08X\n", ES32(*(uint32_t*)(data + chks_off + 0xC))); memset(data + chks_off + 8, 0, 8); - chks = jenkins_one_at_a_time_hash(data + (chks_off - chks_len + 0x14), chks_len, 0x3FAC7125); + chks = jenkins_one_at_a_time_hash(data + (chks_off - chks_len + 0x14), chks_len, CHECKSUM_SEED); printf(" + New Checksum: %08X\n\n", chks); chks = ES32(chks); @@ -144,7 +176,7 @@ int main(int argc, char **argv) memcpy(data + chks_off + 0xC, &chks, sizeof(uint32_t)); memcpy(data + chks_off + 0x8, &chks_len, sizeof(uint32_t)); - encrypt_data(data + (isPS4 ? 0x114 : 0), (isPS4 ? ES32(isPS4) : len)); + encrypt_data(data + (isPS4 ? 0x114 : 0), (isPS4 ? (len - 0x114) : len)); } write_buffer(argv[2], data, len); diff --git a/gta5-decrypter/samples/SGTA50000.dec b/gta5-decrypter/samples/SGTA50000.dec new file mode 100644 index 0000000000000000000000000000000000000000..adad9db66d38296e25360413a1651490932d0cc1 GIT binary patch literal 534244 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

MBe@cd>pe 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 z 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

fQO||7 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

YBP3XUH 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 a&BU&2ta2-q0G!O9bE@ZqoOtbbmi-TlPdnBC literal 0 HcmV?d00001 diff --git a/ps4-rdr2-decrypter/main.c b/ps4-rdr2-decrypter/main.c index 00c1f39..2e64e1f 100644 --- a/ps4-rdr2-decrypter/main.c +++ b/ps4-rdr2-decrypter/main.c @@ -7,6 +7,8 @@ #include "../common/iofile.c" #include "../common/aes.c" +#define CHECKSUM_SEED 0x3FAC7125 + // same as GTA5 PS3 Key const u8 RDR2_PS4_KEY[32] = { 0x16, 0x85, 0xFF, 0xA3, 0x8D, 0x01, 0x0F, 0x0D, 0xFE, 0x66, 0x1C, 0xF9, 0xB5, 0x57, 0x2C, 0x50, @@ -23,18 +25,19 @@ int search_data(const u8* data, size_t size, int start, const char* search, int } // https://github.com/Zhaxxy/rdr2_enc_dec/blob/main/rdr2_enc_dec.py#L10 -uint32_t rockstar_chks(const char* data, int len) +// https://www.burtleburtle.net/bob/hash/doobs.html +uint32_t jenkins_one_at_a_time_hash(const uint8_t* data, size_t length, uint32_t hash) { - uint32_t checksum = 0x3FAC7125; - - while (len--) + while (length--) { - checksum = ((checksum + (signed char) *data++) * 0x401) & 0xFFFFFFFF; - checksum = (checksum >> 6 ^ checksum) & 0xFFFFFFFF; + hash += (signed char) *data++; + hash += hash << 10; + hash ^= hash >> 6; } - checksum = (checksum*9) & 0xFFFFFFFF; - - return (((checksum >> 11 ^ checksum) * 0x8001) & 0xFFFFFFFF); + hash += hash << 3; + hash ^= hash >> 11; + hash += hash << 15; + return hash; } void decrypt_data(u8* data, u32 size) @@ -112,6 +115,33 @@ int main(int argc, char **argv) decrypt_data(data + 0x120, len - 0x120); else { + // fix title checksum + uint32_t seed; // must be 00 00 00 04 + uint8_t title[0x100]; + + // read first 4 bytes of file and reverse + memcpy(&seed, data, sizeof(uint32_t)); + seed = ES32(seed); + + // read title from offset 0x04 to 0x104 + memcpy(title, data + 0x04, sizeof(title)); + + // generate seed + seed = jenkins_one_at_a_time_hash((uint8_t *) &seed, sizeof(uint32_t), 0); + + // use generated seed to calculate title checksum + uint32_t title_chks = jenkins_one_at_a_time_hash((uint8_t *)title, sizeof(title), seed); + + printf(" - Title Seed : %08X\n", seed); + printf(" - Old Checksum: %08X\n", ES32(*(uint32_t*)(data + 0x104))); + printf(" + New Checksum: %08X\n\n", title_chks); + title_chks = ES32(title_chks); + + // finally, fix the 4 byte checksum at 0x104 + memcpy(data + 0x104, &title_chks, sizeof(uint32_t)); + + // fix general checksum + uint32_t chks, chks_len; int chks_off = search_data(data, len, 0, "CHKS", 5); @@ -134,7 +164,7 @@ int main(int argc, char **argv) printf(" - Old Checksum: %08X\n", ES32(*(uint32_t*)(data + chks_off + 0xC))); memset(data + chks_off + 8, 0, 8); - chks = rockstar_chks((char*) data + (chks_off - chks_len + 0x14), chks_len); + chks = jenkins_one_at_a_time_hash(data + (chks_off - chks_len + 0x14), chks_len, CHECKSUM_SEED); printf(" + New Checksum: %08X\n\n", chks); chks = ES32(chks); diff --git a/ps4-terraria-decrypter/Makefile b/ps4-terraria-decrypter/Makefile new file mode 100644 index 0000000..c416169 --- /dev/null +++ b/ps4-terraria-decrypter/Makefile @@ -0,0 +1,7 @@ +all: decrypter + +decrypter: + gcc -D _GNU_SOURCE -o ps4-terraria-decrypter main.c + +clean: + -rm -f ps4-terraria-decrypter \ No newline at end of file diff --git a/ps4-terraria-decrypter/README.md b/ps4-terraria-decrypter/README.md new file mode 100644 index 0000000..55af91b --- /dev/null +++ b/ps4-terraria-decrypter/README.md @@ -0,0 +1,22 @@ +# ps4-terraria-decrypter + +A tool to decrypt/decompress Terraria PS4 `.plr` & `.wld` files. + +``` +USAGE: ./ps4-terraria-decrypter [option] [type] filename + +OPTIONS Explanation: + -d Decrypt/Decompress File + -e Encrypt/Compress File +TYPES Explanation: + 1 .plr + 2 .wld +``` + +### Notes + +- Not all `.wld` files are compatible + +### Credits + +This tool was created by [hzh](https://github.com/hzhreal/) \ No newline at end of file diff --git a/ps4-terraria-decrypter/main.c b/ps4-terraria-decrypter/main.c new file mode 100644 index 0000000..efaa0be --- /dev/null +++ b/ps4-terraria-decrypter/main.c @@ -0,0 +1,163 @@ +/* +* Terraria PS4 Decrypter / Unpacker - (c) 2024 by hzh +* https://github.com/hzhreal/ +*/ + +#define CBC 1 +#define AES128 1 +#define AES256 0 + +#include "../common/iofile.c" +#include "../common/aes.c" +#include "../common/miniz.h" + +const uint8_t SECRET_KEY[] = { + 0x68, 0x00, 0x33, 0x00, 0x79, 0x00, 0x5F, 0x00, + 0x67, 0x00, 0x55, 0x00, 0x79, 0x00, 0x5A, 0x00 +}; +const uint32_t COMP_MAGIC = 0x1AA2227E; + +void decrypt_data(uint8_t* data, size_t size) +{ + struct AES_ctx ctx; + AES_init_ctx_iv(&ctx, SECRET_KEY, SECRET_KEY); + + printf("[*] Total Decrypted Size Is 0x%X (%zu bytes)\n", size, size); + + AES_CBC_decrypt_buffer(&ctx, data, size); + + printf("[*] Decrypted File Successfully!\n\n"); + return; +} + +void encrypt_data(uint8_t* data, size_t size) +{ + struct AES_ctx ctx; + AES_init_ctx_iv(&ctx, SECRET_KEY, SECRET_KEY); + + printf("[*] Total Encrypted Size Is 0x%X (%zu bytes)\n", size, size); + + AES_CBC_encrypt_buffer(&ctx, data, size); + + printf("[*] Encrypted File Successfully!\n\n"); + return; +} + +void print_usage(const char* argv0) +{ + printf("USAGE: %s [option] [type] filename\n\n", argv0); + printf("OPTIONS Explanation:\n"); + printf(" -d Decrypt/Decompress File\n"); + printf(" -e Encrypt/Compress File\n\n"); + printf("TYPES Explanation:\n"); + printf(" 1 .plr\n"); + printf(" 2 .wld\n\n"); + return; +} + +int main(int argc, char **argv) +{ + uint8_t *data; + size_t len; + char *opt, *bak, type; + + printf("\nTerraria (PS4) decrypter\n\n"); + + if (--argc < 3) + { + print_usage(argv[0]); + return -1; + } + char *filename = argv[3]; + + opt = argv[1]; + if (*opt++ != '-' || (*opt != 'd' && *opt != 'e')) + { + print_usage(argv[0]); + return -1; + } + + type = *argv[2]; + if (type != '1' && type != '2') { + print_usage(argv[0]); + return -1; + } + + if (read_buffer(filename, &data, &len) != 0) + { + printf("[*] Could Not Access The File (%s)\n", filename); + return -1; + } + // Save a file backup + asprintf(&bak, "%s.bak", filename); + write_buffer(bak, data, len); + + switch (type) + { + case '1': + { + len &= ~15; // just to be safe + if (*opt++ == 'd') + decrypt_data(data, len); + + else + encrypt_data(data, len); + + write_buffer(filename, data, len); + + break; + } + + case '2': + { + if (*opt++ == 'd') + { + if (memcmp(data, &COMP_MAGIC, 4) != 0) { + printf("This .wld file is incompatible!\n"); + break; + } + uint32_t expected_len; + memcpy(&expected_len, data + 4, sizeof(uint32_t)); + + uint8_t *decomp; + size_t decomp_len; + + decomp = tinfl_decompress_mem_to_heap(data + 0x08, len - 0x08, &decomp_len, TINFL_FLAG_PARSE_ZLIB_HEADER); + if (!decomp || decomp_len != expected_len) { + printf("Decompression failed! Expected size: %u, decompressed size: %zu\n", expected_len, decomp_len); + break; + } + + write_buffer(filename, decomp, decomp_len); + free(decomp); + } + else + { + uint8_t *comp; + size_t comp_len; + + comp = tdefl_compress_mem_to_heap(data, len, &comp_len, TINFL_FLAG_PARSE_ZLIB_HEADER); + if (!comp) { + printf("Compression failed!\n"); + break; + } + + data = (uint8_t *)realloc(data, (4 + 4) + comp_len); + len = (uint32_t)len; + + memcpy(data, &COMP_MAGIC, 4); + memcpy(data + 4, &len, 4); + memcpy(data + 8, comp, comp_len); + + write_buffer(filename, data, (4 + 4) + comp_len); + free(comp); + } + + break; + } + + } + + free(data); + free(bak); +} diff --git a/ps4-terraria-decrypter/samples/World4.wld.comp b/ps4-terraria-decrypter/samples/World4.wld.comp new file mode 100644 index 0000000000000000000000000000000000000000..f0714c13aec2d8bb55bebca40e9861acfb013c12 GIT binary patch literal 64938 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 Ehs|iIu>b%7 literal 0 HcmV?d00001 diff --git a/ps4-terraria-decrypter/samples/magic.plr.dec b/ps4-terraria-decrypter/samples/magic.plr.dec new file mode 100644 index 0000000000000000000000000000000000000000..f1aead5d629bfd3f58ee4e23649965d85fa2e5eb GIT binary patch literal 2240 zcmaFO%)n5TnvKKS6z@}W~WnlPU&%hAO@CnYE z0%u)=vv698CUFC*gMnco2gGDF1ytqM0|OD{`cXhi2zUV%LqZKd>pe6sgBTDjTVQeo z=?!9F1?D3N3v4$y)%^tOfTTZ3I7=PQ+6u}XV0B;}qr_+kjE2By2#^p0=YeXE>|T&M YROtUefa<;HD6J1vIdmRKEe8|;0REwz=Kufz literal 0 HcmV?d00001 diff --git a/ps4-terraria-decrypter/samples/magic.plr.enc b/ps4-terraria-decrypter/samples/magic.plr.enc new file mode 100644 index 0000000000000000000000000000000000000000..1b6859e43e16218c5b8a9f541411716a9de70912 GIT binary patch literal 2240 zcmV;x2tW7L<(Hs6=M8;5zl^Q?W9W9>iCCh(dC**J54woK461=VFLa4^Cr59NN9fUD zu=cQCOaCo0TNaKA33YIZFvmdy$W(Jz$A3=-WXcnap^mPZ|?P|N9sL2WK@45vYAMxqW*dC#7b z-Hc5JEgRIL*(RfTXZol#O>HkcJ&#XNdOVumE4peORJ>Co#;gC@(ov!d74b!6h~iHR*{-(<;lQ!bN0=KwnulqXaS43{S+17yplsC= zD3RnU8hysM94Kw3cp^tU6a>2T7ZoFxPniBTQ$-+9uHZdjI_szMWfv*UenK#gj!+}E zYEB|BpTZ(VT?Z@y`(14J&d%*pX}$o*_C6njKLA!nRSlDlGi5t2g{}4`PGy%0b5_R*AW0?cf9|&w7D*J z+s;z<%TOcpSEQA%qyVXqO@7>hETKGw`<58cex+w4PIJaMH^K5O5QJz8z%fQ=Tv%-NaraW(JJhsc0J~kx#9FeZrLtXH#n%W*yQZZ2| zBfi5(l{J_-px$y899|=)$u@>7OVOYefb3L)b*yJgZ97IQ`LuSUml7p>Dm4?Y-VM1I ziwi;_04SzYFbZLYBxgt(x+h&Rm?)BuI(xRMT)7?TEbjtiX*=igG3bV58H~sy z{)Jm>g0Ul|Y|PEK>;A^_E)1FERN+0Yitw`4(=fG^e7sNLnUK%&K!1c++{Ib+j9hnf zF8S05{mwMUdK0~fx)UAnYV3Orf0WKHJ2Sprl87p$ZpnXt4)1nFJETeD}*cLF; z9he&&S`t-a^(iEqx^Bw2ISKvz6Ae$OCavJAdmPD#b#~rMdN~C17pWYH7LC*s+8fCo zGc~_dWRk%a8?ADXG+B;T@fl<@ zWT(q8WVSsP_Sm?r9q-)>usFRy`tOs^JMA_z8SeIaaFI1#8v^|rbiOT{si#Pj#qKU< zs7@->v!#^{ri&-gIC?+|KH%m+B94*D`%Bqrh9!4|@|uj}Q44za6oMI0(61vx1Q16< zS42J-%LAV4@#3qXSFV6T|J7vmM2IB95=I6W(6~x|>_;br$H$SFN;h(TO|2ZIEiA;` zskqpP%27l$A>|Kb!#{Y3hz|s5wsh24J@1Y(3cWF=z9DgmA(L!^EB!-E1uSL-3F~yR zb-321-9b_6FXKFf=H>4^?korJcN%zzmYn^yo&qF!KHNZ?PivK^X5;49f{fDu&@}iD z#=Te;M|?@m{XhN!R*G3M1*0|(@>;)tc3K?iw6#$h?kj$h7J&^mf&s8p3(bWSzK zhkZ)rjexDwF&SuL@&10~o;=83_q95B`cPlk&MoS{dGdFLL2;G~rkZLQUX~`_p#DO6 zo1`97K7%q3FZBV!DsW}6Dd@EE^K3Fpiftdd=*xWtAS~7{$Rk~ys&b(U>KVA>{FScyoWJF6R9UDtLM2Nq6^GNYu3V9C3Yg|sl=9f8Q- zc$fx)GR>2u9C(4M9Kr_Y3ao{sj3K}Vw%71~@oMF%?-iI!?iQed(Z2App4qiC5x_4* OA^4Lv?qb|;cmR?ljZ85B literal 0 HcmV?d00001