Oolite 1.91.0.7645-241119-222d325
Loading...
Searching...
No Matches
miniz.h File Reference
#include <stddef.h>
#include <time.h>
#include <assert.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
+ Include dependency graph for miniz.h:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  mz_stream_s
 
struct  tdefl_compressor
 
struct  tinfl_decompressor_tag
 
struct  mz_zip_archive_file_stat
 
struct  mz_zip_archive
 
struct  mz_zip_reader_extract_iter_state
 

Macros

#define MINIZ_X86_OR_X64_CPU   0
 
#define MINIZ_LITTLE_ENDIAN   0
 
#define MINIZ_USE_UNALIGNED_LOADS_AND_STORES   0
 
#define MINIZ_HAS_64BIT_REGISTERS   0
 
#define MZ_ADLER32_INIT   (1)
 
#define MZ_CRC32_INIT   (0)
 
#define MZ_DEFLATED   8
 
#define MZ_VERSION   "11.0.2"
 
#define MZ_VERNUM   0xB002
 
#define MZ_VER_MAJOR   11
 
#define MZ_VER_MINOR   2
 
#define MZ_VER_REVISION   0
 
#define MZ_VER_SUBREVISION   0
 
#define MZ_DEFAULT_WINDOW_BITS   15
 
#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()
 
#define MZ_FALSE   (0)
 
#define MZ_TRUE   (1)
 
#define MZ_MACRO_END   while (0)
 
#define MZ_FILE   FILE
 
#define MZ_TIME_T   time_t
 
#define MZ_ASSERT(x)
 
#define MZ_MALLOC(x)
 
#define MZ_FREE(x)
 
#define MZ_REALLOC(p, x)
 
#define MZ_MAX(a, b)
 
#define MZ_MIN(a, b)
 
#define MZ_CLEAR_OBJ(obj)
 
#define MZ_CLEAR_ARR(obj)
 
#define MZ_CLEAR_PTR(obj)
 
#define MZ_READ_LE16(p)
 
#define MZ_READ_LE32(p)
 
#define MZ_READ_LE64(p)
 
#define MZ_FORCEINLINE   inline
 
#define MZ_UINT16_MAX   (0xFFFFU)
 
#define MZ_UINT32_MAX   (0xFFFFFFFFU)
 
#define TDEFL_LESS_MEMORY   0
 
#define TINFL_DECOMPRESS_MEM_TO_MEM_FAILED   ((size_t)(-1))
 
#define TINFL_LZ_DICT_SIZE   32768
 
#define tinfl_init(r)
 
#define tinfl_get_adler32(r)
 
#define TINFL_USE_64BIT_BITBUF   0
 
#define TINFL_BITBUF_SIZE   (32)
 

Typedefs

typedef unsigned long mz_ulong
 
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)
 
typedef struct mz_stream_s mz_stream
 
typedef mz_streammz_streamp
 
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
 
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
 
typedef mz_bool(* tdefl_put_buf_func_ptr) (const void *pBuf, int len, void *pUser)
 
typedef int(* tinfl_put_buf_func_ptr) (const void *pBuf, int len, void *pUser)
 
typedef struct tinfl_decompressor_tag tinfl_decompressor
 
typedef mz_uint32 tinfl_bit_buf_t
 
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)
 
typedef struct mz_zip_internal_state_tag mz_zip_internal_state
 

Enumerations

enum  {
  MZ_DEFAULT_STRATEGY = 0 , MZ_FILTERED = 1 , MZ_HUFFMAN_ONLY = 2 , MZ_RLE = 3 ,
  MZ_FIXED = 4
}
 
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
}
 
enum  {
  MZ_NO_FLUSH = 0 , MZ_PARTIAL_FLUSH = 1 , MZ_SYNC_FLUSH = 2 , MZ_FULL_FLUSH = 3 ,
  MZ_FINISH = 4 , MZ_BLOCK = 5
}
 
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
}
 
enum  { TDEFL_HUFFMAN_ONLY = 0 , TDEFL_DEFAULT_MAX_PROBES = 128 , TDEFL_MAX_PROBES_MASK = 0xFFF }
 
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
}
 
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
}
 
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
}
 
enum  tdefl_status { TDEFL_STATUS_BAD_PARAM = -2 , TDEFL_STATUS_PUT_BUF_FAILED = -1 , TDEFL_STATUS_OKAY = 0 , TDEFL_STATUS_DONE = 1 }
 
enum  tdefl_flush { TDEFL_NO_FLUSH = 0 , TDEFL_SYNC_FLUSH = 2 , TDEFL_FULL_FLUSH = 3 , TDEFL_FINISH = 4 }
 
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 }
 
enum  tinfl_status {
  TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS = -4 , TINFL_STATUS_BAD_PARAM = -3 , TINFL_STATUS_ADLER32_MISMATCH = -2 , TINFL_STATUS_FAILED = -1 ,
  TINFL_STATUS_DONE = 0 , TINFL_STATUS_NEEDS_MORE_INPUT = 1 , TINFL_STATUS_HAS_MORE_OUTPUT = 2
}
 
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
}
 
enum  { MZ_ZIP_MAX_IO_BUF_SIZE = 64 * 1024 , MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE = 512 , MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE = 512 }
 
enum  mz_zip_mode { MZ_ZIP_MODE_INVALID = 0 , MZ_ZIP_MODE_READING = 1 , MZ_ZIP_MODE_WRITING = 2 , MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED = 3 }
 
enum  mz_zip_flags {
  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 , MZ_ZIP_FLAG_VALIDATE_HEADERS_ONLY = 0x2000 , MZ_ZIP_FLAG_WRITE_ZIP64 = 0x4000 , MZ_ZIP_FLAG_WRITE_ALLOW_READING = 0x8000 ,
  MZ_ZIP_FLAG_ASCII_FILENAME = 0x10000 , MZ_ZIP_FLAG_WRITE_HEADER_SET_SIZE = 0x20000
}
 
enum  mz_zip_type {
  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
}
 
enum  mz_zip_error {
  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
}
 

Functions

MINIZ_EXPORT void mz_free (void *p)
 
MINIZ_EXPORT mz_ulong mz_adler32 (mz_ulong adler, const unsigned char *ptr, size_t buf_len)
 
MINIZ_EXPORT mz_ulong mz_crc32 (mz_ulong crc, const unsigned char *ptr, size_t buf_len)
 
MINIZ_EXPORT const char * mz_version (void)
 
MINIZ_EXPORT int mz_deflateInit (mz_streamp pStream, int level)
 
MINIZ_EXPORT int mz_deflateInit2 (mz_streamp pStream, int level, int method, int window_bits, int mem_level, int strategy)
 
MINIZ_EXPORT int mz_deflateReset (mz_streamp pStream)
 
MINIZ_EXPORT int mz_deflate (mz_streamp pStream, int flush)
 
MINIZ_EXPORT int mz_deflateEnd (mz_streamp pStream)
 
MINIZ_EXPORT mz_ulong mz_deflateBound (mz_streamp pStream, mz_ulong source_len)
 
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)
 
MINIZ_EXPORT mz_ulong mz_compressBound (mz_ulong source_len)
 
MINIZ_EXPORT int mz_inflateInit (mz_streamp pStream)
 
MINIZ_EXPORT int mz_inflateInit2 (mz_streamp pStream, int window_bits)
 
MINIZ_EXPORT int mz_inflateReset (mz_streamp pStream)
 
MINIZ_EXPORT int mz_inflate (mz_streamp pStream, int flush)
 
MINIZ_EXPORT int mz_inflateEnd (mz_streamp pStream)
 
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)
 
MINIZ_EXPORT const char * mz_error (int err)
 
MINIZ_EXPORT void * miniz_def_alloc_func (void *opaque, size_t items, size_t size)
 
MINIZ_EXPORT void miniz_def_free_func (void *opaque, void *address)
 
MINIZ_EXPORT void * miniz_def_realloc_func (void *opaque, void *address, size_t items, size_t size)
 
MINIZ_EXPORT void * tdefl_compress_mem_to_heap (const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags)
 
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)
 
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)
 
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)
 
MINIZ_EXPORT tdefl_status tdefl_init (tdefl_compressor *d, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)
 
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)
 
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)
 
MINIZ_EXPORT mz_uint tdefl_create_comp_flags_from_zip_params (int level, int window_bits, int strategy)
 
MINIZ_EXPORT tdefl_compressortdefl_compressor_alloc (void)
 
MINIZ_EXPORT void tdefl_compressor_free (tdefl_compressor *pComp)
 
MINIZ_EXPORT void * tinfl_decompress_mem_to_heap (const void *pSrc_buf, size_t src_buf_len, size_t *pOut_len, int flags)
 
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)
 
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)
 
MINIZ_EXPORT tinfl_decompressortinfl_decompressor_alloc (void)
 
MINIZ_EXPORT void tinfl_decompressor_free (tinfl_decompressor *pDecomp)
 
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)
 
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)
 
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)
 
MINIZ_EXPORT mz_bool mz_zip_reader_init_cfile (mz_zip_archive *pZip, MZ_FILE *pFile, mz_uint64 archive_size, mz_uint flags)
 
MINIZ_EXPORT mz_bool mz_zip_reader_end (mz_zip_archive *pZip)
 
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)
 
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_FILEmz_zip_get_cfile (mz_zip_archive *pZip)
 
MINIZ_EXPORT size_t mz_zip_read_archive_data (mz_zip_archive *pZip, mz_uint64 file_ofs, void *pBuf, size_t n)
 
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)
 
MINIZ_EXPORT mz_bool mz_zip_reader_is_file_a_directory (mz_zip_archive *pZip, mz_uint file_index)
 
MINIZ_EXPORT mz_bool mz_zip_reader_is_file_encrypted (mz_zip_archive *pZip, mz_uint file_index)
 
MINIZ_EXPORT mz_bool mz_zip_reader_is_file_supported (mz_zip_archive *pZip, mz_uint file_index)
 
MINIZ_EXPORT mz_uint mz_zip_reader_get_filename (mz_zip_archive *pZip, mz_uint file_index, char *pFilename, mz_uint filename_buf_size)
 
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)
 
MINIZ_EXPORT mz_bool mz_zip_reader_file_stat (mz_zip_archive *pZip, mz_uint file_index, mz_zip_archive_file_stat *pStat)
 
MINIZ_EXPORT mz_bool mz_zip_is_zip64 (mz_zip_archive *pZip)
 
MINIZ_EXPORT size_t mz_zip_get_central_dir_size (mz_zip_archive *pZip)
 
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)
 
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)
 
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)
 
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)
 
MINIZ_EXPORT mz_zip_reader_extract_iter_statemz_zip_reader_extract_iter_new (mz_zip_archive *pZip, mz_uint file_index, mz_uint flags)
 
MINIZ_EXPORT mz_zip_reader_extract_iter_statemz_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)
 
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)
 
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)
 
MINIZ_EXPORT mz_bool mz_zip_validate_file (mz_zip_archive *pZip, mz_uint file_index, mz_uint flags)
 
MINIZ_EXPORT mz_bool mz_zip_validate_archive (mz_zip_archive *pZip, mz_uint flags)
 
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)
 
MINIZ_EXPORT mz_bool mz_zip_end (mz_zip_archive *pZip)
 
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)
 
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)
 
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)
 
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)
 
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)
 
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, 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)
 
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)
 
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, 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)
 
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)
 
MINIZ_EXPORT mz_bool mz_zip_writer_finalize_archive (mz_zip_archive *pZip)
 
MINIZ_EXPORT mz_bool mz_zip_writer_finalize_heap_archive (mz_zip_archive *pZip, void **ppBuf, size_t *pSize)
 
MINIZ_EXPORT mz_bool mz_zip_writer_end (mz_zip_archive *pZip)
 
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)
 
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)
 

Macro Definition Documentation

◆ adler32

#define adler32   mz_adler32

Definition at line 512 of file miniz.h.

◆ alloc_func

#define alloc_func   mz_alloc_func

Definition at line 484 of file miniz.h.

Referenced by unzOpenCurrentFile3().

◆ compress

#define compress   mz_compress

Definition at line 496 of file miniz.h.

◆ compress2

#define compress2   mz_compress2

Definition at line 497 of file miniz.h.

◆ compressBound

#define compressBound   mz_compressBound

Definition at line 498 of file miniz.h.

◆ crc32

#define crc32   mz_crc32

Definition at line 511 of file miniz.h.

Referenced by mz_crc32(), and unzReadCurrentFile().

◆ deflate

#define deflate   mz_deflate

Definition at line 493 of file miniz.h.

◆ deflateBound

#define deflateBound   mz_deflateBound

Definition at line 495 of file miniz.h.

◆ deflateEnd

#define deflateEnd   mz_deflateEnd

Definition at line 494 of file miniz.h.

◆ deflateInit

#define deflateInit   mz_deflateInit

Definition at line 490 of file miniz.h.

◆ deflateInit2

#define deflateInit2   mz_deflateInit2

Definition at line 491 of file miniz.h.

◆ deflateReset

#define deflateReset   mz_deflateReset

Definition at line 492 of file miniz.h.

◆ free_func

#define free_func   mz_free_func

Definition at line 485 of file miniz.h.

Referenced by unzOpenCurrentFile3().

◆ inflate

#define inflate   mz_inflate

Definition at line 505 of file miniz.h.

Referenced by unzReadCurrentFile().

◆ inflateEnd

#define inflateEnd   mz_inflateEnd

Definition at line 506 of file miniz.h.

Referenced by unzCloseCurrentFile().

◆ inflateInit

#define inflateInit   mz_inflateInit

Definition at line 502 of file miniz.h.

◆ inflateInit2

#define inflateInit2   mz_inflateInit2

Definition at line 503 of file miniz.h.

Referenced by unzOpenCurrentFile3().

◆ inflateReset

#define inflateReset   mz_inflateReset

Definition at line 504 of file miniz.h.

◆ internal_state

#define internal_state   mz_internal_state

Definition at line 486 of file miniz.h.

◆ MAX_MEM_LEVEL

#define MAX_MEM_LEVEL   9

Definition at line 514 of file miniz.h.

◆ MAX_WBITS

#define MAX_WBITS   15

Definition at line 513 of file miniz.h.

Referenced by unzOpenCurrentFile3().

◆ MINIZ_HAS_64BIT_REGISTERS

#define MINIZ_HAS_64BIT_REGISTERS   0

Definition at line 225 of file miniz.h.

◆ MINIZ_LITTLE_ENDIAN

#define MINIZ_LITTLE_ENDIAN   0

Definition at line 197 of file miniz.h.

◆ MINIZ_USE_UNALIGNED_LOADS_AND_STORES

#define MINIZ_USE_UNALIGNED_LOADS_AND_STORES   0

Definition at line 217 of file miniz.h.

◆ MINIZ_X86_OR_X64_CPU

#define MINIZ_X86_OR_X64_CPU   0

Definition at line 178 of file miniz.h.

◆ MZ_ADLER32_INIT

#define MZ_ADLER32_INIT   (1)

Definition at line 240 of file miniz.h.

Referenced by mz_adler32(), and mz_deflateInit2().

◆ MZ_ASSERT

◆ MZ_CLEAR_ARR

◆ MZ_CLEAR_OBJ

#define MZ_CLEAR_OBJ ( obj)
Value:
memset(&(obj), 0, sizeof(obj))

Definition at line 596 of file miniz.h.

Referenced by tdefl_compress_mem_to_heap(), tdefl_compress_mem_to_mem(), and tdefl_write_image_to_png_file_in_memory_ex().

◆ MZ_CLEAR_PTR

#define MZ_CLEAR_PTR ( obj)
Value:
memset((obj), 0, sizeof(*obj))

Definition at line 598 of file miniz.h.

Referenced by mz_zip_zero_struct().

◆ MZ_CRC32_INIT

◆ MZ_DEFAULT_WINDOW_BITS

#define MZ_DEFAULT_WINDOW_BITS   15

Definition at line 314 of file miniz.h.

Referenced by mz_deflateInit(), mz_deflateInit2(), mz_inflateInit(), and mz_inflateInit2().

◆ MZ_DEFLATED

◆ MZ_FALSE

#define MZ_FALSE   (0)

Definition at line 554 of file miniz.h.

Referenced by mz_zip_add_mem_to_archive_file_in_place_v2(), mz_zip_array_ensure_capacity(), mz_zip_array_push_back(), mz_zip_array_reserve(), mz_zip_array_resize(), mz_zip_end(), mz_zip_file_stat_internal(), mz_zip_get_file_modified_time(), mz_zip_is_zip64(), mz_zip_reader_end_internal(), mz_zip_reader_extract_file_to_callback(), mz_zip_reader_extract_file_to_cfile(), mz_zip_reader_extract_file_to_file(), mz_zip_reader_extract_file_to_heap(), mz_zip_reader_extract_file_to_mem_no_alloc(), mz_zip_reader_extract_iter_free(), mz_zip_reader_extract_to_callback(), mz_zip_reader_extract_to_cfile(), mz_zip_reader_extract_to_file(), mz_zip_reader_extract_to_mem_no_alloc1(), mz_zip_reader_init(), mz_zip_reader_init_cfile(), mz_zip_reader_init_file_v2(), mz_zip_reader_init_internal(), mz_zip_reader_init_mem(), mz_zip_reader_is_file_a_directory(), mz_zip_reader_is_file_encrypted(), mz_zip_reader_is_file_supported(), mz_zip_reader_locate_header_sig(), mz_zip_reader_read_central_dir(), mz_zip_set_error(), mz_zip_string_equal(), mz_zip_validate_archive(), mz_zip_validate_file(), mz_zip_validate_file_archive(), mz_zip_validate_mem_archive(), mz_zip_writer_add_from_zip_reader(), mz_zip_writer_add_mem_ex_v2(), mz_zip_writer_add_put_buf_callback(), mz_zip_writer_add_read_buf_callback(), mz_zip_writer_add_to_central_dir(), mz_zip_writer_end_internal(), mz_zip_writer_finalize_heap_archive(), mz_zip_writer_init_cfile(), mz_zip_writer_init_file_v2(), mz_zip_writer_init_from_reader_v2(), mz_zip_writer_init_heap_v2(), mz_zip_writer_update_zip64_extension_block(), mz_zip_writer_validate_archive_name(), tdefl_compress_mem_to_heap(), tdefl_compress_mem_to_output(), tdefl_compress_normal(), tdefl_flush_block(), tdefl_output_buffer_putter(), tdefl_start_dynamic_block(), and tdefl_write_image_to_png_file_in_memory().

◆ MZ_FILE

◆ MZ_FORCEINLINE

#define MZ_FORCEINLINE   inline

Definition at line 615 of file miniz.h.

◆ MZ_FREE

◆ MZ_MACRO_END

#define MZ_MACRO_END   while (0)

Definition at line 561 of file miniz.h.

◆ MZ_MALLOC

◆ MZ_MAX

◆ MZ_MIN

◆ MZ_READ_LE16

◆ MZ_READ_LE32

◆ MZ_READ_LE64

#define MZ_READ_LE64 ( p)
Value:
(((mz_uint64)MZ_READ_LE32(p)) | (((mz_uint64)MZ_READ_LE32((const mz_uint8 *)(p) + sizeof(mz_uint32))) << 32U))
uint64_t mz_uint64
Definition miniz.h:551
#define MZ_READ_LE32(p)
Definition miniz.h:605

Definition at line 608 of file miniz.h.

Referenced by mz_zip_file_stat_internal(), mz_zip_reader_read_central_dir(), mz_zip_validate_file(), and mz_zip_writer_add_from_zip_reader().

◆ MZ_REALLOC

#define MZ_REALLOC ( p,
x )
Value:
realloc(p, x)

Definition at line 591 of file miniz.h.

Referenced by miniz_def_realloc_func(), tdefl_output_buffer_putter(), and tinfl_decompress_mem_to_heap().

◆ MZ_TIME_T

#define MZ_TIME_T   time_t

Definition at line 579 of file miniz.h.

Referenced by mz_zip_writer_add_file(), and mz_zip_writer_add_mem_ex_v2().

◆ MZ_TRUE

#define MZ_TRUE   (1)

Definition at line 555 of file miniz.h.

Referenced by mz_zip_add_mem_to_archive_file_in_place_v2(), mz_zip_array_ensure_capacity(), mz_zip_array_ensure_room(), mz_zip_array_push_back(), mz_zip_array_reserve(), mz_zip_array_resize(), mz_zip_file_stat_internal(), mz_zip_get_file_modified_time(), mz_zip_locate_file_binary_search(), mz_zip_reader_end(), mz_zip_reader_end_internal(), mz_zip_reader_extract_to_callback(), mz_zip_reader_extract_to_mem_no_alloc1(), mz_zip_reader_init(), mz_zip_reader_init_cfile(), mz_zip_reader_init_file_v2(), mz_zip_reader_init_internal(), mz_zip_reader_init_mem(), mz_zip_reader_is_file_a_directory(), mz_zip_reader_is_file_supported(), mz_zip_reader_locate_file_v2(), mz_zip_reader_locate_header_sig(), mz_zip_reader_read_central_dir(), mz_zip_string_equal(), mz_zip_validate_archive(), mz_zip_validate_file(), mz_zip_validate_file_archive(), mz_zip_validate_mem_archive(), mz_zip_writer_add_from_zip_reader(), mz_zip_writer_add_mem_ex_v2(), mz_zip_writer_add_put_buf_callback(), mz_zip_writer_add_read_buf_callback(), mz_zip_writer_add_to_central_dir(), mz_zip_writer_create_central_dir_header(), mz_zip_writer_create_local_dir_header(), mz_zip_writer_end(), mz_zip_writer_end_internal(), mz_zip_writer_finalize_archive(), mz_zip_writer_finalize_heap_archive(), mz_zip_writer_init_cfile(), mz_zip_writer_init_file_v2(), mz_zip_writer_init_from_reader_v2(), mz_zip_writer_init_heap_v2(), mz_zip_writer_init_v2(), mz_zip_writer_update_zip64_extension_block(), mz_zip_writer_validate_archive_name(), mz_zip_writer_write_zeros(), tdefl_compress_mem_to_heap(), tdefl_compress_normal(), tdefl_flush_block(), tdefl_output_buffer_putter(), tdefl_start_static_block(), and tdefl_write_image_to_png_file_in_memory_ex().

◆ MZ_UINT16_MAX

◆ MZ_UINT32_MAX

◆ MZ_VER_MAJOR

#define MZ_VER_MAJOR   11

Definition at line 280 of file miniz.h.

◆ MZ_VER_MINOR

#define MZ_VER_MINOR   2

Definition at line 281 of file miniz.h.

◆ MZ_VER_REVISION

#define MZ_VER_REVISION   0

Definition at line 282 of file miniz.h.

◆ MZ_VER_SUBREVISION

#define MZ_VER_SUBREVISION   0

Definition at line 283 of file miniz.h.

◆ MZ_VERNUM

#define MZ_VERNUM   0xB002

Definition at line 279 of file miniz.h.

◆ MZ_VERSION

#define MZ_VERSION   "11.0.2"

Definition at line 278 of file miniz.h.

Referenced by mz_version().

◆ TDEFL_LESS_MEMORY

#define TDEFL_LESS_MEMORY   0

Definition at line 643 of file miniz.h.

◆ TINFL_BITBUF_SIZE

#define TINFL_BITBUF_SIZE   (32)

Definition at line 951 of file miniz.h.

◆ TINFL_DECOMPRESS_MEM_TO_MEM_FAILED

#define TINFL_DECOMPRESS_MEM_TO_MEM_FAILED   ((size_t)(-1))

Definition at line 860 of file miniz.h.

Referenced by tinfl_decompress_mem_to_mem().

◆ tinfl_get_adler32

#define tinfl_get_adler32 ( r)
Value:
(r)->m_check_adler32

Definition at line 923 of file miniz.h.

Referenced by mz_inflate().

◆ tinfl_init

#define tinfl_init ( r)
Value:
do \
{ \
(r)->m_state = 0; \
} \
#define MZ_MACRO_END
Definition miniz.h:561

Definition at line 917 of file miniz.h.

917#define tinfl_init(r) \
918 do \
919 { \
920 (r)->m_state = 0; \
921 } \
922 MZ_MACRO_END

Referenced by mz_inflateInit2(), mz_inflateReset(), mz_zip_reader_extract_iter_new(), mz_zip_reader_extract_to_callback(), mz_zip_reader_extract_to_mem_no_alloc1(), tinfl_decompress_mem_to_callback(), tinfl_decompress_mem_to_heap(), tinfl_decompress_mem_to_mem(), and tinfl_decompressor_alloc().

◆ TINFL_LZ_DICT_SIZE

◆ TINFL_USE_64BIT_BITBUF

#define TINFL_USE_64BIT_BITBUF   0

Definition at line 943 of file miniz.h.

◆ uncompress

#define uncompress   mz_uncompress

Definition at line 507 of file miniz.h.

◆ uncompress2

#define uncompress2   mz_uncompress2

Definition at line 508 of file miniz.h.

◆ Z_BEST_COMPRESSION

#define Z_BEST_COMPRESSION   MZ_BEST_COMPRESSION

Definition at line 475 of file miniz.h.

◆ Z_BEST_SPEED

#define Z_BEST_SPEED   MZ_BEST_SPEED

Definition at line 474 of file miniz.h.

◆ Z_BLOCK

#define Z_BLOCK   MZ_BLOCK

Definition at line 462 of file miniz.h.

◆ Z_BUF_ERROR

#define Z_BUF_ERROR   MZ_BUF_ERROR

Definition at line 470 of file miniz.h.

◆ Z_DATA_ERROR

#define Z_DATA_ERROR   MZ_DATA_ERROR

Definition at line 468 of file miniz.h.

Referenced by unzReadCurrentFile().

◆ Z_DEFAULT_COMPRESSION

#define Z_DEFAULT_COMPRESSION   MZ_DEFAULT_COMPRESSION

Definition at line 476 of file miniz.h.

◆ Z_DEFAULT_STRATEGY

#define Z_DEFAULT_STRATEGY   MZ_DEFAULT_STRATEGY

Definition at line 477 of file miniz.h.

◆ Z_DEFAULT_WINDOW_BITS

#define Z_DEFAULT_WINDOW_BITS   MZ_DEFAULT_WINDOW_BITS

Definition at line 483 of file miniz.h.

◆ Z_DEFLATED

#define Z_DEFLATED   MZ_DEFLATED

◆ Z_ERRNO

#define Z_ERRNO   MZ_ERRNO

Definition at line 466 of file miniz.h.

◆ Z_FILTERED

#define Z_FILTERED   MZ_FILTERED

Definition at line 478 of file miniz.h.

◆ Z_FINISH

#define Z_FINISH   MZ_FINISH

Definition at line 461 of file miniz.h.

◆ Z_FIXED

#define Z_FIXED   MZ_FIXED

Definition at line 481 of file miniz.h.

◆ Z_FULL_FLUSH

#define Z_FULL_FLUSH   MZ_FULL_FLUSH

Definition at line 460 of file miniz.h.

◆ Z_HUFFMAN_ONLY

#define Z_HUFFMAN_ONLY   MZ_HUFFMAN_ONLY

Definition at line 479 of file miniz.h.

◆ Z_MEM_ERROR

#define Z_MEM_ERROR   MZ_MEM_ERROR

Definition at line 469 of file miniz.h.

◆ Z_NEED_DICT

#define Z_NEED_DICT   MZ_NEED_DICT

Definition at line 465 of file miniz.h.

◆ Z_NO_COMPRESSION

#define Z_NO_COMPRESSION   MZ_NO_COMPRESSION

Definition at line 473 of file miniz.h.

◆ Z_NO_FLUSH

#define Z_NO_FLUSH   MZ_NO_FLUSH

Definition at line 457 of file miniz.h.

◆ Z_NULL

#define Z_NULL   0

Definition at line 456 of file miniz.h.

◆ Z_OK

#define Z_OK   MZ_OK

Definition at line 463 of file miniz.h.

Referenced by unzOpenCurrentFile3(), and unzReadCurrentFile().

◆ Z_PARAM_ERROR

#define Z_PARAM_ERROR   MZ_PARAM_ERROR

Definition at line 472 of file miniz.h.

◆ Z_PARTIAL_FLUSH

#define Z_PARTIAL_FLUSH   MZ_PARTIAL_FLUSH

Definition at line 458 of file miniz.h.

◆ Z_RLE

#define Z_RLE   MZ_RLE

Definition at line 480 of file miniz.h.

◆ z_stream

#define z_stream   mz_stream

Definition at line 487 of file miniz.h.

◆ Z_STREAM_END

#define Z_STREAM_END   MZ_STREAM_END

Definition at line 464 of file miniz.h.

Referenced by unzReadCurrentFile().

◆ Z_STREAM_ERROR

#define Z_STREAM_ERROR   MZ_STREAM_ERROR

Definition at line 467 of file miniz.h.

◆ Z_SYNC_FLUSH

#define Z_SYNC_FLUSH   MZ_SYNC_FLUSH

Definition at line 459 of file miniz.h.

Referenced by unzReadCurrentFile().

◆ Z_VERSION_ERROR

#define Z_VERSION_ERROR   MZ_VERSION_ERROR

Definition at line 471 of file miniz.h.

◆ zError

#define zError   mz_error

Definition at line 515 of file miniz.h.

◆ ZLIB_VER_MAJOR

#define ZLIB_VER_MAJOR   MZ_VER_MAJOR

Definition at line 518 of file miniz.h.

◆ ZLIB_VER_MINOR

#define ZLIB_VER_MINOR   MZ_VER_MINOR

Definition at line 519 of file miniz.h.

◆ ZLIB_VER_REVISION

#define ZLIB_VER_REVISION   MZ_VER_REVISION

Definition at line 520 of file miniz.h.

◆ ZLIB_VER_SUBREVISION

#define ZLIB_VER_SUBREVISION   MZ_VER_SUBREVISION

Definition at line 521 of file miniz.h.

◆ ZLIB_VERNUM

#define ZLIB_VERNUM   MZ_VERNUM

Definition at line 517 of file miniz.h.

◆ ZLIB_VERSION

#define ZLIB_VERSION   MZ_VERSION

Definition at line 516 of file miniz.h.

◆ zlib_version

#define zlib_version   mz_version()

Definition at line 523 of file miniz.h.

◆ zlibVersion

#define zlibVersion   mz_version

Definition at line 522 of file miniz.h.

Typedef Documentation

◆ Byte

typedef unsigned char Byte

Definition at line 445 of file miniz.h.

◆ Bytef

typedef Byte Bytef

Definition at line 448 of file miniz.h.

◆ charf

typedef char charf

Definition at line 450 of file miniz.h.

◆ intf

typedef int intf

Definition at line 451 of file miniz.h.

◆ mz_alloc_func

typedef void *(* mz_alloc_func) (void *opaque, size_t items, size_t size)

Definition at line 263 of file miniz.h.

◆ mz_bool

typedef int mz_bool

Definition at line 552 of file miniz.h.

◆ mz_file_needs_keepalive

typedef mz_bool(* mz_file_needs_keepalive) (void *pOpaque)

Definition at line 1053 of file miniz.h.

◆ mz_file_read_func

typedef size_t(* mz_file_read_func) (void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n)

Definition at line 1051 of file miniz.h.

◆ mz_file_write_func

typedef size_t(* mz_file_write_func) (void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n)

Definition at line 1052 of file miniz.h.

◆ mz_free_func

typedef void(* mz_free_func) (void *opaque, void *address)

Definition at line 264 of file miniz.h.

◆ mz_int16

typedef signed short mz_int16

Definition at line 546 of file miniz.h.

◆ mz_int64

typedef int64_t mz_int64

Definition at line 550 of file miniz.h.

◆ mz_realloc_func

typedef void *(* mz_realloc_func) (void *opaque, void *address, size_t items, size_t size)

Definition at line 265 of file miniz.h.

◆ mz_stream

typedef struct mz_stream_s mz_stream

◆ mz_streamp

Definition at line 341 of file miniz.h.

◆ mz_uint

typedef unsigned int mz_uint

Definition at line 549 of file miniz.h.

◆ mz_uint16

typedef unsigned short mz_uint16

Definition at line 547 of file miniz.h.

◆ mz_uint32

typedef unsigned int mz_uint32

Definition at line 548 of file miniz.h.

◆ mz_uint64

typedef uint64_t mz_uint64

Definition at line 551 of file miniz.h.

◆ mz_uint8

typedef unsigned char mz_uint8

Definition at line 545 of file miniz.h.

◆ mz_ulong

typedef unsigned long mz_ulong

Definition at line 235 of file miniz.h.

◆ mz_zip_internal_state

Definition at line 1056 of file miniz.h.

◆ tdefl_put_buf_func_ptr

typedef mz_bool(* tdefl_put_buf_func_ptr) (const void *pBuf, int len, void *pUser)

Definition at line 704 of file miniz.h.

◆ tinfl_bit_buf_t

Definition at line 950 of file miniz.h.

◆ tinfl_decompressor

Definition at line 869 of file miniz.h.

◆ tinfl_put_buf_func_ptr

typedef int(* tinfl_put_buf_func_ptr) (const void *pBuf, int len, void *pUser)

Definition at line 865 of file miniz.h.

◆ uInt

typedef unsigned int uInt

Definition at line 446 of file miniz.h.

◆ uIntf

typedef uInt uIntf

Definition at line 449 of file miniz.h.

◆ uLong

typedef uLong

Definition at line 447 of file miniz.h.

◆ uLongf

typedef uLong uLongf

Definition at line 453 of file miniz.h.

◆ voidp

typedef void* voidp

Definition at line 454 of file miniz.h.

◆ voidpc

typedef void* const voidpc

Definition at line 455 of file miniz.h.

◆ voidpf

typedef voidpf

Definition at line 452 of file miniz.h.

Enumeration Type Documentation

◆ anonymous enum

anonymous enum
Enumerator
MZ_OK 
MZ_STREAM_END 
MZ_NEED_DICT 
MZ_ERRNO 
MZ_STREAM_ERROR 
MZ_DATA_ERROR 
MZ_MEM_ERROR 
MZ_BUF_ERROR 
MZ_VERSION_ERROR 
MZ_PARAM_ERROR 

Definition at line 299 of file miniz.h.

300{
301 MZ_OK = 0,
302 MZ_STREAM_END = 1,
303 MZ_NEED_DICT = 2,
304 MZ_ERRNO = -1,
305 MZ_STREAM_ERROR = -2,
306 MZ_DATA_ERROR = -3,
307 MZ_MEM_ERROR = -4,
308 MZ_BUF_ERROR = -5,
309 MZ_VERSION_ERROR = -6,
310 MZ_PARAM_ERROR = -10000
311};
@ MZ_MEM_ERROR
Definition miniz.h:307
@ MZ_PARAM_ERROR
Definition miniz.h:310
@ MZ_NEED_DICT
Definition miniz.h:303
@ MZ_VERSION_ERROR
Definition miniz.h:309
@ MZ_STREAM_END
Definition miniz.h:302
@ MZ_ERRNO
Definition miniz.h:304
@ MZ_OK
Definition miniz.h:301
@ MZ_BUF_ERROR
Definition miniz.h:308
@ MZ_STREAM_ERROR
Definition miniz.h:305
@ MZ_DATA_ERROR
Definition miniz.h:306

◆ anonymous enum

anonymous enum
Enumerator
TDEFL_HUFFMAN_ONLY 
TDEFL_DEFAULT_MAX_PROBES 
TDEFL_MAX_PROBES_MASK 

Definition at line 647 of file miniz.h.

648{
652};
@ TDEFL_DEFAULT_MAX_PROBES
Definition miniz.h:650
@ TDEFL_HUFFMAN_ONLY
Definition miniz.h:649
@ TDEFL_MAX_PROBES_MASK
Definition miniz.h:651

◆ anonymous enum

anonymous enum
Enumerator
TDEFL_WRITE_ZLIB_HEADER 
TDEFL_COMPUTE_ADLER32 
TDEFL_GREEDY_PARSING_FLAG 
TDEFL_NONDETERMINISTIC_PARSING_FLAG 
TDEFL_RLE_MATCHES 
TDEFL_FILTER_MATCHES 
TDEFL_FORCE_ALL_STATIC_BLOCKS 
TDEFL_FORCE_ALL_RAW_BLOCKS 

Definition at line 663 of file miniz.h.

664{
665 TDEFL_WRITE_ZLIB_HEADER = 0x01000,
666 TDEFL_COMPUTE_ADLER32 = 0x02000,
669 TDEFL_RLE_MATCHES = 0x10000,
670 TDEFL_FILTER_MATCHES = 0x20000,
673};
@ TDEFL_FORCE_ALL_RAW_BLOCKS
Definition miniz.h:672
@ TDEFL_GREEDY_PARSING_FLAG
Definition miniz.h:667
@ TDEFL_FORCE_ALL_STATIC_BLOCKS
Definition miniz.h:671
@ TDEFL_COMPUTE_ADLER32
Definition miniz.h:666
@ TDEFL_FILTER_MATCHES
Definition miniz.h:670
@ TDEFL_WRITE_ZLIB_HEADER
Definition miniz.h:665
@ TDEFL_NONDETERMINISTIC_PARSING_FLAG
Definition miniz.h:668
@ TDEFL_RLE_MATCHES
Definition miniz.h:669

◆ anonymous enum

anonymous enum
Enumerator
TDEFL_MAX_HUFF_TABLES 
TDEFL_MAX_HUFF_SYMBOLS_0 
TDEFL_MAX_HUFF_SYMBOLS_1 
TDEFL_MAX_HUFF_SYMBOLS_2 
TDEFL_LZ_DICT_SIZE 
TDEFL_LZ_DICT_SIZE_MASK 
TDEFL_MIN_MATCH_LEN 
TDEFL_MAX_MATCH_LEN 

Definition at line 709 of file miniz.h.

710{
715 TDEFL_LZ_DICT_SIZE = 32768,
719};
@ TDEFL_MAX_MATCH_LEN
Definition miniz.h:718
@ TDEFL_MAX_HUFF_TABLES
Definition miniz.h:711
@ TDEFL_MAX_HUFF_SYMBOLS_0
Definition miniz.h:712
@ TDEFL_LZ_DICT_SIZE_MASK
Definition miniz.h:716
@ TDEFL_LZ_DICT_SIZE
Definition miniz.h:715
@ TDEFL_MIN_MATCH_LEN
Definition miniz.h:717
@ TDEFL_MAX_HUFF_SYMBOLS_1
Definition miniz.h:713
@ TDEFL_MAX_HUFF_SYMBOLS_2
Definition miniz.h:714

◆ anonymous enum

anonymous enum
Enumerator
TDEFL_LZ_CODE_BUF_SIZE 
TDEFL_OUT_BUF_SIZE 
TDEFL_MAX_HUFF_SYMBOLS 
TDEFL_LZ_HASH_BITS 
TDEFL_LEVEL1_HASH_SIZE_MASK 
TDEFL_LZ_HASH_SHIFT 
TDEFL_LZ_HASH_SIZE 

Definition at line 734 of file miniz.h.

735{
736 TDEFL_LZ_CODE_BUF_SIZE = 64 * 1024,
743};
@ TDEFL_MAX_HUFF_SYMBOLS
Definition miniz.h:738
@ TDEFL_LEVEL1_HASH_SIZE_MASK
Definition miniz.h:740
@ TDEFL_LZ_HASH_BITS
Definition miniz.h:739
@ TDEFL_LZ_HASH_SIZE
Definition miniz.h:742
@ TDEFL_LZ_CODE_BUF_SIZE
Definition miniz.h:736
@ TDEFL_LZ_HASH_SHIFT
Definition miniz.h:741
@ TDEFL_OUT_BUF_SIZE
Definition miniz.h:737

◆ anonymous enum

anonymous enum
Enumerator
TINFL_FLAG_PARSE_ZLIB_HEADER 
TINFL_FLAG_HAS_MORE_INPUT 
TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF 
TINFL_FLAG_COMPUTE_ADLER32 

Definition at line 840 of file miniz.h.

841{
846};
@ TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF
Definition miniz.h:844
@ TINFL_FLAG_HAS_MORE_INPUT
Definition miniz.h:843
@ TINFL_FLAG_COMPUTE_ADLER32
Definition miniz.h:845
@ TINFL_FLAG_PARSE_ZLIB_HEADER
Definition miniz.h:842

◆ anonymous enum

anonymous enum
Enumerator
TINFL_MAX_HUFF_TABLES 
TINFL_MAX_HUFF_SYMBOLS_0 
TINFL_MAX_HUFF_SYMBOLS_1 
TINFL_MAX_HUFF_SYMBOLS_2 
TINFL_FAST_LOOKUP_BITS 
TINFL_FAST_LOOKUP_SIZE 

Definition at line 930 of file miniz.h.

931{
938};
@ TINFL_MAX_HUFF_SYMBOLS_2
Definition miniz.h:935
@ TINFL_FAST_LOOKUP_SIZE
Definition miniz.h:937
@ TINFL_MAX_HUFF_SYMBOLS_0
Definition miniz.h:933
@ TINFL_MAX_HUFF_SYMBOLS_1
Definition miniz.h:934
@ TINFL_MAX_HUFF_TABLES
Definition miniz.h:932
@ TINFL_FAST_LOOKUP_BITS
Definition miniz.h:936

◆ anonymous enum

anonymous enum
Enumerator
MZ_ZIP_MAX_IO_BUF_SIZE 
MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE 
MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE 

Definition at line 986 of file miniz.h.

987{
988 /* Note: These enums can be reduced as needed to save memory or stack space - they are pretty conservative. */
989 MZ_ZIP_MAX_IO_BUF_SIZE = 64 * 1024,
992};
@ MZ_ZIP_MAX_ARCHIVE_FILE_COMMENT_SIZE
Definition miniz.h:991
@ MZ_ZIP_MAX_IO_BUF_SIZE
Definition miniz.h:989
@ MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE
Definition miniz.h:990

◆ anonymous enum

anonymous enum
Enumerator
MZ_DEFAULT_STRATEGY 
MZ_FILTERED 
MZ_HUFFMAN_ONLY 
MZ_RLE 
MZ_FIXED 

Definition at line 249 of file miniz.h.

250{
252 MZ_FILTERED = 1,
253 MZ_HUFFMAN_ONLY = 2,
254 MZ_RLE = 3,
255 MZ_FIXED = 4
256};
@ MZ_FILTERED
Definition miniz.h:252
@ MZ_FIXED
Definition miniz.h:255
@ MZ_DEFAULT_STRATEGY
Definition miniz.h:251
@ MZ_RLE
Definition miniz.h:254
@ MZ_HUFFMAN_ONLY
Definition miniz.h:253

◆ anonymous enum

anonymous enum
Enumerator
MZ_NO_COMPRESSION 
MZ_BEST_SPEED 
MZ_BEST_COMPRESSION 
MZ_UBER_COMPRESSION 
MZ_DEFAULT_LEVEL 
MZ_DEFAULT_COMPRESSION 

Definition at line 268 of file miniz.h.

269{
271 MZ_BEST_SPEED = 1,
276};
@ MZ_BEST_SPEED
Definition miniz.h:271
@ MZ_NO_COMPRESSION
Definition miniz.h:270
@ MZ_UBER_COMPRESSION
Definition miniz.h:273
@ MZ_DEFAULT_LEVEL
Definition miniz.h:274
@ MZ_BEST_COMPRESSION
Definition miniz.h:272
@ MZ_DEFAULT_COMPRESSION
Definition miniz.h:275

◆ anonymous enum

anonymous enum
Enumerator
MZ_NO_FLUSH 
MZ_PARTIAL_FLUSH 
MZ_SYNC_FLUSH 
MZ_FULL_FLUSH 
MZ_FINISH 
MZ_BLOCK 

Definition at line 288 of file miniz.h.

289{
290 MZ_NO_FLUSH = 0,
292 MZ_SYNC_FLUSH = 2,
293 MZ_FULL_FLUSH = 3,
294 MZ_FINISH = 4,
295 MZ_BLOCK = 5
296};
@ MZ_SYNC_FLUSH
Definition miniz.h:292
@ MZ_BLOCK
Definition miniz.h:295
@ MZ_FULL_FLUSH
Definition miniz.h:293
@ MZ_FINISH
Definition miniz.h:294
@ MZ_PARTIAL_FLUSH
Definition miniz.h:291
@ MZ_NO_FLUSH
Definition miniz.h:290

◆ mz_zip_error

Enumerator
MZ_ZIP_NO_ERROR 
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 

Definition at line 1091 of file miniz.h.

1091 {
1092 MZ_ZIP_NO_ERROR = 0,
1125} mz_zip_error;
mz_zip_error
Definition miniz.h:1091
@ MZ_ZIP_UNSUPPORTED_METHOD
Definition miniz.h:1096
@ MZ_ZIP_UNSUPPORTED_FEATURE
Definition miniz.h:1098
@ MZ_ZIP_FILE_OPEN_FAILED
Definition miniz.h:1109
@ MZ_ZIP_FILE_TOO_LARGE
Definition miniz.h:1095
@ MZ_ZIP_WRITE_CALLBACK_FAILED
Definition miniz.h:1123
@ MZ_ZIP_CRC_CHECK_FAILED
Definition miniz.h:1106
@ MZ_ZIP_INTERNAL_ERROR
Definition miniz.h:1119
@ MZ_ZIP_FILE_CLOSE_FAILED
Definition miniz.h:1113
@ MZ_ZIP_FILE_CREATE_FAILED
Definition miniz.h:1110
@ MZ_ZIP_BUF_TOO_SMALL
Definition miniz.h:1118
@ MZ_ZIP_VALIDATION_FAILED
Definition miniz.h:1122
@ MZ_ZIP_FILE_STAT_FAILED
Definition miniz.h:1115
@ MZ_ZIP_INVALID_FILENAME
Definition miniz.h:1117
@ MZ_ZIP_COMPRESSION_FAILED
Definition miniz.h:1104
@ MZ_ZIP_NO_ERROR
Definition miniz.h:1092
@ MZ_ZIP_UNSUPPORTED_ENCRYPTION
Definition miniz.h:1097
@ MZ_ZIP_TOO_MANY_FILES
Definition miniz.h:1094
@ MZ_ZIP_UNDEFINED_ERROR
Definition miniz.h:1093
@ MZ_ZIP_UNSUPPORTED_MULTIDISK
Definition miniz.h:1102
@ MZ_ZIP_ALLOC_FAILED
Definition miniz.h:1108
@ MZ_ZIP_ARCHIVE_TOO_LARGE
Definition miniz.h:1121
@ MZ_ZIP_DECOMPRESSION_FAILED
Definition miniz.h:1103
@ MZ_ZIP_FILE_WRITE_FAILED
Definition miniz.h:1111
@ MZ_ZIP_INVALID_PARAMETER
Definition miniz.h:1116
@ MZ_ZIP_INVALID_HEADER_OR_CORRUPTED
Definition miniz.h:1101
@ MZ_ZIP_UNSUPPORTED_CDIR_SIZE
Definition miniz.h:1107
@ MZ_ZIP_FILE_READ_FAILED
Definition miniz.h:1112
@ MZ_ZIP_FILE_NOT_FOUND
Definition miniz.h:1120
@ MZ_ZIP_FAILED_FINDING_CENTRAL_DIR
Definition miniz.h:1099
@ MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE
Definition miniz.h:1105
@ MZ_ZIP_NOT_AN_ARCHIVE
Definition miniz.h:1100
@ MZ_ZIP_TOTAL_ERRORS
Definition miniz.h:1124
@ MZ_ZIP_FILE_SEEK_FAILED
Definition miniz.h:1114

◆ mz_zip_flags

Enumerator
MZ_ZIP_FLAG_CASE_SENSITIVE 
MZ_ZIP_FLAG_IGNORE_PATH 
MZ_ZIP_FLAG_COMPRESSED_DATA 
MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY 
MZ_ZIP_FLAG_VALIDATE_LOCATE_FILE_FLAG 
MZ_ZIP_FLAG_VALIDATE_HEADERS_ONLY 
MZ_ZIP_FLAG_WRITE_ZIP64 
MZ_ZIP_FLAG_WRITE_ALLOW_READING 
MZ_ZIP_FLAG_ASCII_FILENAME 
MZ_ZIP_FLAG_WRITE_HEADER_SET_SIZE 

Definition at line 1065 of file miniz.h.

1065 {
1067 MZ_ZIP_FLAG_IGNORE_PATH = 0x0200,
1070 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) */
1071 MZ_ZIP_FLAG_VALIDATE_HEADERS_ONLY = 0x2000, /* validate the local headers, but don't decompress the entire file and check the crc32 */
1072 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 */
1075 /*After adding a compressed file, seek back
1076 to local file header and set the correct sizes*/
1078} mz_zip_flags;
mz_zip_flags
Definition miniz.h:1065
@ MZ_ZIP_FLAG_ASCII_FILENAME
Definition miniz.h:1074
@ MZ_ZIP_FLAG_WRITE_HEADER_SET_SIZE
Definition miniz.h:1077
@ MZ_ZIP_FLAG_WRITE_ZIP64
Definition miniz.h:1072
@ MZ_ZIP_FLAG_WRITE_ALLOW_READING
Definition miniz.h:1073
@ MZ_ZIP_FLAG_VALIDATE_HEADERS_ONLY
Definition miniz.h:1071
@ MZ_ZIP_FLAG_VALIDATE_LOCATE_FILE_FLAG
Definition miniz.h:1070
@ MZ_ZIP_FLAG_COMPRESSED_DATA
Definition miniz.h:1068
@ MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY
Definition miniz.h:1069
@ MZ_ZIP_FLAG_CASE_SENSITIVE
Definition miniz.h:1066
@ MZ_ZIP_FLAG_IGNORE_PATH
Definition miniz.h:1067

◆ mz_zip_mode

Enumerator
MZ_ZIP_MODE_INVALID 
MZ_ZIP_MODE_READING 
MZ_ZIP_MODE_WRITING 
MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED 

Definition at line 1058 of file miniz.h.

1058 {
1063} mz_zip_mode;
mz_zip_mode
Definition miniz.h:1058
@ MZ_ZIP_MODE_WRITING
Definition miniz.h:1061
@ MZ_ZIP_MODE_READING
Definition miniz.h:1060
@ MZ_ZIP_MODE_INVALID
Definition miniz.h:1059
@ MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED
Definition miniz.h:1062

◆ mz_zip_type

Enumerator
MZ_ZIP_TYPE_INVALID 
MZ_ZIP_TYPE_USER 
MZ_ZIP_TYPE_MEMORY 
MZ_ZIP_TYPE_HEAP 
MZ_ZIP_TYPE_FILE 
MZ_ZIP_TYPE_CFILE 
MZ_ZIP_TOTAL_TYPES 

Definition at line 1080 of file miniz.h.

1080 {
1088} mz_zip_type;
mz_zip_type
Definition miniz.h:1080
@ MZ_ZIP_TYPE_USER
Definition miniz.h:1082
@ MZ_ZIP_TYPE_FILE
Definition miniz.h:1085
@ MZ_ZIP_TYPE_HEAP
Definition miniz.h:1084
@ MZ_ZIP_TOTAL_TYPES
Definition miniz.h:1087
@ MZ_ZIP_TYPE_MEMORY
Definition miniz.h:1083
@ MZ_ZIP_TYPE_CFILE
Definition miniz.h:1086
@ MZ_ZIP_TYPE_INVALID
Definition miniz.h:1081

◆ tdefl_flush

Enumerator
TDEFL_NO_FLUSH 
TDEFL_SYNC_FLUSH 
TDEFL_FULL_FLUSH 
TDEFL_FINISH 

Definition at line 755 of file miniz.h.

755 {
756 TDEFL_NO_FLUSH = 0,
759 TDEFL_FINISH = 4
tdefl_flush
Definition miniz.h:755
@ TDEFL_SYNC_FLUSH
Definition miniz.h:757
@ TDEFL_NO_FLUSH
Definition miniz.h:756
@ TDEFL_FULL_FLUSH
Definition miniz.h:758
@ TDEFL_FINISH
Definition miniz.h:759

◆ tdefl_status

Enumerator
TDEFL_STATUS_BAD_PARAM 
TDEFL_STATUS_PUT_BUF_FAILED 
TDEFL_STATUS_OKAY 
TDEFL_STATUS_DONE 

Definition at line 747 of file miniz.h.

747 {
tdefl_status
Definition miniz.h:747
@ TDEFL_STATUS_OKAY
Definition miniz.h:750
@ TDEFL_STATUS_DONE
Definition miniz.h:751
@ TDEFL_STATUS_BAD_PARAM
Definition miniz.h:748
@ TDEFL_STATUS_PUT_BUF_FAILED
Definition miniz.h:749

◆ tinfl_status

Enumerator
TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS 
TINFL_STATUS_BAD_PARAM 
TINFL_STATUS_ADLER32_MISMATCH 
TINFL_STATUS_FAILED 
TINFL_STATUS_DONE 
TINFL_STATUS_NEEDS_MORE_INPUT 
TINFL_STATUS_HAS_MORE_OUTPUT 

Definition at line 883 of file miniz.h.

883 {
884 /* 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 */
885 /* 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). */
886 /* If you call it again with no input you'll just get TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS again. */
888
889 /* 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.) */
891
892 /* 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. */
894
895 /* 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. */
897
898 /* Any status code less than TINFL_STATUS_DONE must indicate a failure. */
899
900 /* 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 */
901 /* 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. */
903
904 /* 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 */
905 /* 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 */
906 /* proceed, so be sure to properly set the TINFL_FLAG_HAS_MORE_INPUT flag. */
908
909 /* 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. */
910 /* 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 */
911 /* (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 */
912 /* so I may need to add some code to address this. */
tinfl_status
Definition miniz.h:883
@ TINFL_STATUS_ADLER32_MISMATCH
Definition miniz.h:893
@ TINFL_STATUS_FAILED
Definition miniz.h:896
@ TINFL_STATUS_NEEDS_MORE_INPUT
Definition miniz.h:907
@ TINFL_STATUS_HAS_MORE_OUTPUT
Definition miniz.h:913
@ TINFL_STATUS_BAD_PARAM
Definition miniz.h:890
@ TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS
Definition miniz.h:887
@ TINFL_STATUS_DONE
Definition miniz.h:902

Function Documentation

◆ miniz_def_alloc_func()

MINIZ_EXPORT void * miniz_def_alloc_func ( void * opaque,
size_t items,
size_t size )
extern

Definition at line 168 of file miniz.c.

169{
170 (void)opaque, (void)items, (void)size;
171 return MZ_MALLOC(items * size);
172}
voidpf void uLong size
Definition ioapi.h:134
#define MZ_MALLOC(x)
Definition miniz.h:589

References MZ_MALLOC.

Referenced by mz_deflateInit2(), mz_inflateInit2(), mz_zip_reader_init_internal(), and mz_zip_writer_init_v2().

+ Here is the caller graph for this function:

◆ miniz_def_free_func()

MINIZ_EXPORT void miniz_def_free_func ( void * opaque,
void * address )
extern

Definition at line 173 of file miniz.c.

174{
175 (void)opaque, (void)address;
176 MZ_FREE(address);
177}
#define MZ_FREE(x)
Definition miniz.h:590

References MZ_FREE.

Referenced by mz_deflateInit2(), mz_inflateInit2(), mz_zip_reader_init_internal(), and mz_zip_writer_init_v2().

+ Here is the caller graph for this function:

◆ miniz_def_realloc_func()

MINIZ_EXPORT void * miniz_def_realloc_func ( void * opaque,
void * address,
size_t items,
size_t size )
extern

Definition at line 178 of file miniz.c.

179{
180 (void)opaque, (void)address, (void)items, (void)size;
181 return MZ_REALLOC(address, items * size);
182}
#define MZ_REALLOC(p, x)
Definition miniz.h:591

References MZ_REALLOC.

Referenced by mz_zip_reader_init_internal(), and mz_zip_writer_init_v2().

+ Here is the caller graph for this function:

◆ mz_adler32()

MINIZ_EXPORT mz_ulong mz_adler32 ( mz_ulong adler,
const unsigned char * ptr,
size_t buf_len )

Definition at line 41 of file miniz.c.

42{
43 mz_uint32 i, s1 = (mz_uint32)(adler & 0xffff), s2 = (mz_uint32)(adler >> 16);
44 size_t block_len = buf_len % 5552;
45 if (!ptr)
46 return MZ_ADLER32_INIT;
47 while (buf_len)
48 {
49 for (i = 0; i + 7 < block_len; i += 8, ptr += 8)
50 {
51 s1 += ptr[0], s2 += s1;
52 s1 += ptr[1], s2 += s1;
53 s1 += ptr[2], s2 += s1;
54 s1 += ptr[3], s2 += s1;
55 s1 += ptr[4], s2 += s1;
56 s1 += ptr[5], s2 += s1;
57 s1 += ptr[6], s2 += s1;
58 s1 += ptr[7], s2 += s1;
59 }
60 for (; i < block_len; ++i)
61 s1 += *ptr++, s2 += s1;
62 s1 %= 65521U, s2 %= 65521U;
63 buf_len -= block_len;
64 block_len = 5552;
65 }
66 return (s2 << 16) + s1;
67}
#define MZ_ADLER32_INIT
Definition miniz.h:240

References MZ_ADLER32_INIT.

Referenced by tdefl_compress().

+ Here is the caller graph for this function:

◆ mz_compress()

MINIZ_EXPORT int mz_compress ( unsigned char * pDest,
mz_ulong * pDest_len,
const unsigned char * pSource,
mz_ulong source_len )

Definition at line 350 of file miniz.c.

351{
352 return mz_compress2(pDest, pDest_len, pSource, source_len, MZ_DEFAULT_COMPRESSION);
353}
int mz_compress2(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong source_len, int level)
Definition miniz.c:320

References mz_compress2(), and MZ_DEFAULT_COMPRESSION.

+ Here is the call graph for this function:

◆ mz_compress2()

MINIZ_EXPORT int mz_compress2 ( unsigned char * pDest,
mz_ulong * pDest_len,
const unsigned char * pSource,
mz_ulong source_len,
int level )

Definition at line 320 of file miniz.c.

321{
322 int status;
324 memset(&stream, 0, sizeof(stream));
325
326 /* In case mz_ulong is 64-bits (argh I hate longs). */
327 if ((mz_uint64)(source_len | *pDest_len) > 0xFFFFFFFFU)
328 return MZ_PARAM_ERROR;
329
330 stream.next_in = pSource;
331 stream.avail_in = (mz_uint32)source_len;
332 stream.next_out = pDest;
333 stream.avail_out = (mz_uint32)*pDest_len;
334
335 status = mz_deflateInit(&stream, level);
336 if (status != MZ_OK)
337 return status;
338
339 status = mz_deflate(&stream, MZ_FINISH);
340 if (status != MZ_STREAM_END)
341 {
343 return (status == MZ_OK) ? MZ_BUF_ERROR : status;
344 }
345
346 *pDest_len = stream.total_out;
347 return mz_deflateEnd(&stream);
348}
voidpf stream
Definition ioapi.h:134
int mz_deflateEnd(mz_streamp pStream)
Definition miniz.c:301
int mz_deflateInit(mz_streamp pStream, int level)
Definition miniz.c:193
int mz_deflate(mz_streamp pStream, int flush)
Definition miniz.c:243

References MZ_BUF_ERROR, mz_deflate(), mz_deflateEnd(), mz_deflateInit(), MZ_FINISH, MZ_OK, MZ_PARAM_ERROR, and MZ_STREAM_END.

Referenced by mz_compress().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_compressBound()

MINIZ_EXPORT mz_ulong mz_compressBound ( mz_ulong source_len)

Definition at line 355 of file miniz.c.

356{
357 return mz_deflateBound(NULL, source_len);
358}
mz_ulong mz_deflateBound(mz_streamp pStream, mz_ulong source_len)
Definition miniz.c:313

References mz_deflateBound().

+ Here is the call graph for this function:

◆ mz_crc32()

MINIZ_EXPORT mz_ulong mz_crc32 ( mz_ulong crc,
const unsigned char * ptr,
size_t buf_len )

Definition at line 96 of file miniz.c.

97{
98 static const mz_uint32 s_crc_table[256] =
99 {
100 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535,
101 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD,
102 0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D,
103 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
104 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4,
105 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x35B5A8FA, 0x42B2986C,
106 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, 0x26D930AC,
107 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
108 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB,
109 0xB6662D3D, 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F,
110 0x9FBFE4A5, 0xE8B8D433, 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB,
111 0x086D3D2D, 0x91646C97, 0xE6635C01, 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
112 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA,
113 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, 0x4DB26158, 0x3AB551CE,
114 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A,
115 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
116 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409,
117 0xCE61E49F, 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81,
118 0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739,
119 0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
120 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, 0xF00F9344, 0x8708A3D2, 0x1E01F268,
121 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0,
122 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 0xD6D6A3E8,
123 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
124 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF,
125 0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703,
126 0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7,
127 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
128 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE,
129 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242,
130 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, 0x88085AE6,
131 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
132 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D,
133 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5,
134 0x47B2CF7F, 0x30B5FFE9, 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605,
135 0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
136 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
137 };
138
139 mz_uint32 crc32 = (mz_uint32)crc ^ 0xFFFFFFFF;
140 const mz_uint8 *pByte_buf = (const mz_uint8 *)ptr;
141
142 while (buf_len >= 4)
143 {
144 crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[0]) & 0xFF];
145 crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[1]) & 0xFF];
146 crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[2]) & 0xFF];
147 crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[3]) & 0xFF];
148 pByte_buf += 4;
149 buf_len -= 4;
150 }
151
152 while (buf_len)
153 {
154 crc32 = (crc32 >> 8) ^ s_crc_table[(crc32 ^ pByte_buf[0]) & 0xFF];
155 ++pByte_buf;
156 --buf_len;
157 }
158
159 return ~crc32;
160}
#define crc32
Definition miniz.h:511

References crc32.

Referenced by mz_zip_compute_crc32_callback(), mz_zip_reader_extract_iter_read(), mz_zip_reader_extract_to_callback(), mz_zip_reader_extract_to_mem_no_alloc1(), mz_zip_writer_add_mem_ex_v2(), mz_zip_writer_add_read_buf_callback(), and tdefl_write_image_to_png_file_in_memory_ex().

+ Here is the caller graph for this function:

◆ mz_deflate()

MINIZ_EXPORT int mz_deflate ( mz_streamp pStream,
int flush )

Definition at line 243 of file miniz.c.

244{
245 size_t in_bytes, out_bytes;
246 mz_ulong orig_total_in, orig_total_out;
247 int mz_status = MZ_OK;
248
249 if ((!pStream) || (!pStream->state) || (flush < 0) || (flush > MZ_FINISH) || (!pStream->next_out))
250 return MZ_STREAM_ERROR;
251 if (!pStream->avail_out)
252 return MZ_BUF_ERROR;
253
254 if (flush == MZ_PARTIAL_FLUSH)
255 flush = MZ_SYNC_FLUSH;
256
257 if (((tdefl_compressor *)pStream->state)->m_prev_return_status == TDEFL_STATUS_DONE)
258 return (flush == MZ_FINISH) ? MZ_STREAM_END : MZ_BUF_ERROR;
259
260 orig_total_in = pStream->total_in;
261 orig_total_out = pStream->total_out;
262 for (;;)
263 {
264 tdefl_status defl_status;
265 in_bytes = pStream->avail_in;
266 out_bytes = pStream->avail_out;
267
268 defl_status = tdefl_compress((tdefl_compressor *)pStream->state, pStream->next_in, &in_bytes, pStream->next_out, &out_bytes, (tdefl_flush)flush);
269 pStream->next_in += (mz_uint)in_bytes;
270 pStream->avail_in -= (mz_uint)in_bytes;
271 pStream->total_in += (mz_uint)in_bytes;
272 pStream->adler = tdefl_get_adler32((tdefl_compressor *)pStream->state);
273
274 pStream->next_out += (mz_uint)out_bytes;
275 pStream->avail_out -= (mz_uint)out_bytes;
276 pStream->total_out += (mz_uint)out_bytes;
277
278 if (defl_status < 0)
279 {
280 mz_status = MZ_STREAM_ERROR;
281 break;
282 }
283 else if (defl_status == TDEFL_STATUS_DONE)
284 {
285 mz_status = MZ_STREAM_END;
286 break;
287 }
288 else if (!pStream->avail_out)
289 break;
290 else if ((!pStream->avail_in) && (flush != MZ_FINISH))
291 {
292 if ((flush) || (pStream->total_in != orig_total_in) || (pStream->total_out != orig_total_out))
293 break;
294 return MZ_BUF_ERROR; /* Can't make forward progress without some input.
295 */
296 }
297 }
298 return mz_status;
299}
mz_uint32 tdefl_get_adler32(tdefl_compressor *d)
Definition miniz.c:2034
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)
Definition miniz.c:1919
unsigned long mz_ulong
Definition miniz.h:235
unsigned int mz_uint
Definition miniz.h:549
mz_ulong adler
Definition miniz.h:337
unsigned char * next_out
Definition miniz.h:325
mz_ulong total_out
Definition miniz.h:327
unsigned int avail_out
Definition miniz.h:326
struct mz_internal_state * state
Definition miniz.h:330
const unsigned char * next_in
Definition miniz.h:321
unsigned int avail_in
Definition miniz.h:322
mz_ulong total_in
Definition miniz.h:323

References mz_stream_s::adler, mz_stream_s::avail_in, mz_stream_s::avail_out, MZ_BUF_ERROR, MZ_FINISH, MZ_OK, MZ_PARTIAL_FLUSH, MZ_STREAM_END, MZ_STREAM_ERROR, MZ_SYNC_FLUSH, mz_stream_s::next_in, mz_stream_s::next_out, mz_stream_s::state, tdefl_compress(), tdefl_get_adler32(), TDEFL_STATUS_DONE, mz_stream_s::total_in, and mz_stream_s::total_out.

Referenced by mz_compress2().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_deflateBound()

MINIZ_EXPORT mz_ulong mz_deflateBound ( mz_streamp pStream,
mz_ulong source_len )

Definition at line 313 of file miniz.c.

314{
315 (void)pStream;
316 /* 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.) */
317 return MZ_MAX(128 + (source_len * 110) / 100, 128 + source_len + ((source_len / (31 * 1024)) + 1) * 5);
318}
#define MZ_MAX(a, b)
Definition miniz.h:594

References MZ_MAX.

Referenced by mz_compressBound().

+ Here is the caller graph for this function:

◆ mz_deflateEnd()

MINIZ_EXPORT int mz_deflateEnd ( mz_streamp pStream)

Definition at line 301 of file miniz.c.

302{
303 if (!pStream)
304 return MZ_STREAM_ERROR;
305 if (pStream->state)
306 {
307 pStream->zfree(pStream->opaque, pStream->state);
308 pStream->state = NULL;
309 }
310 return MZ_OK;
311}
void * opaque
Definition miniz.h:334
mz_free_func zfree
Definition miniz.h:333

References MZ_OK, MZ_STREAM_ERROR, mz_stream_s::opaque, mz_stream_s::state, and mz_stream_s::zfree.

Referenced by mz_compress2(), and mz_deflateInit2().

+ Here is the caller graph for this function:

◆ mz_deflateInit()

MINIZ_EXPORT int mz_deflateInit ( mz_streamp pStream,
int level )

Definition at line 193 of file miniz.c.

194{
196}
int mz_deflateInit2(mz_streamp pStream, int level, int method, int window_bits, int mem_level, int strategy)
Definition miniz.c:198
#define MZ_DEFLATED
Definition miniz.h:259
#define MZ_DEFAULT_WINDOW_BITS
Definition miniz.h:314

References MZ_DEFAULT_STRATEGY, MZ_DEFAULT_WINDOW_BITS, MZ_DEFLATED, and mz_deflateInit2().

Referenced by mz_compress2().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_deflateInit2()

MINIZ_EXPORT int mz_deflateInit2 ( mz_streamp pStream,
int level,
int method,
int window_bits,
int mem_level,
int strategy )

Definition at line 198 of file miniz.c.

199{
200 tdefl_compressor *pComp;
201 mz_uint comp_flags = TDEFL_COMPUTE_ADLER32 | tdefl_create_comp_flags_from_zip_params(level, window_bits, strategy);
202
203 if (!pStream)
204 return MZ_STREAM_ERROR;
205 if ((method != MZ_DEFLATED) || ((mem_level < 1) || (mem_level > 9)) || ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS)))
206 return MZ_PARAM_ERROR;
207
208 pStream->data_type = 0;
209 pStream->adler = MZ_ADLER32_INIT;
210 pStream->msg = NULL;
211 pStream->reserved = 0;
212 pStream->total_in = 0;
213 pStream->total_out = 0;
214 if (!pStream->zalloc)
215 pStream->zalloc = miniz_def_alloc_func;
216 if (!pStream->zfree)
217 pStream->zfree = miniz_def_free_func;
218
219 pComp = (tdefl_compressor *)pStream->zalloc(pStream->opaque, 1, sizeof(tdefl_compressor));
220 if (!pComp)
221 return MZ_MEM_ERROR;
222
223 pStream->state = (struct mz_internal_state *)pComp;
224
225 if (tdefl_init(pComp, NULL, NULL, comp_flags) != TDEFL_STATUS_OKAY)
226 {
227 mz_deflateEnd(pStream);
228 return MZ_PARAM_ERROR;
229 }
230
231 return MZ_OK;
232}
MINIZ_EXPORT void * miniz_def_alloc_func(void *opaque, size_t items, size_t size)
Definition miniz.c:168
tdefl_status tdefl_init(tdefl_compressor *d, tdefl_put_buf_func_ptr pPut_buf_func, void *pPut_buf_user, int flags)
Definition miniz.c:1993
MINIZ_EXPORT void miniz_def_free_func(void *opaque, void *address)
Definition miniz.c:173
mz_uint tdefl_create_comp_flags_from_zip_params(int level, int window_bits, int strategy)
Definition miniz.c:2117
int data_type
Definition miniz.h:336
mz_alloc_func zalloc
Definition miniz.h:332
char * msg
Definition miniz.h:329
mz_ulong reserved
Definition miniz.h:338

References mz_stream_s::adler, mz_stream_s::data_type, miniz_def_alloc_func(), miniz_def_free_func(), mz_stream_s::msg, MZ_ADLER32_INIT, MZ_DEFAULT_WINDOW_BITS, MZ_DEFLATED, mz_deflateEnd(), MZ_MEM_ERROR, MZ_OK, MZ_PARAM_ERROR, MZ_STREAM_ERROR, mz_stream_s::opaque, mz_stream_s::reserved, mz_stream_s::state, TDEFL_COMPUTE_ADLER32, tdefl_create_comp_flags_from_zip_params(), tdefl_init(), TDEFL_STATUS_OKAY, mz_stream_s::total_in, mz_stream_s::total_out, mz_stream_s::zalloc, and mz_stream_s::zfree.

Referenced by mz_deflateInit().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_deflateReset()

MINIZ_EXPORT int mz_deflateReset ( mz_streamp pStream)

Definition at line 234 of file miniz.c.

235{
236 if ((!pStream) || (!pStream->state) || (!pStream->zalloc) || (!pStream->zfree))
237 return MZ_STREAM_ERROR;
238 pStream->total_in = pStream->total_out = 0;
239 tdefl_init((tdefl_compressor *)pStream->state, NULL, NULL, ((tdefl_compressor *)pStream->state)->m_flags);
240 return MZ_OK;
241}

References MZ_OK, MZ_STREAM_ERROR, mz_stream_s::state, tdefl_init(), mz_stream_s::total_in, mz_stream_s::total_out, mz_stream_s::zalloc, and mz_stream_s::zfree.

+ Here is the call graph for this function:

◆ mz_error()

MINIZ_EXPORT const char * mz_error ( int err)

Definition at line 601 of file miniz.c.

602{
603 static struct
604 {
605 int m_err;
606 const char *m_pDesc;
607 } s_error_descs[] =
608 {
609 { 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" }
610 };
611 mz_uint i;
612 for (i = 0; i < sizeof(s_error_descs) / sizeof(s_error_descs[0]); ++i)
613 if (s_error_descs[i].m_err == err)
614 return s_error_descs[i].m_pDesc;
615 return NULL;
616}

References MZ_BUF_ERROR, MZ_DATA_ERROR, MZ_ERRNO, MZ_MEM_ERROR, MZ_NEED_DICT, MZ_OK, MZ_PARAM_ERROR, MZ_STREAM_END, MZ_STREAM_ERROR, and MZ_VERSION_ERROR.

◆ mz_free()

MINIZ_EXPORT void mz_free ( void * p)

Definition at line 163 of file miniz.c.

164{
165 MZ_FREE(p);
166}

References MZ_FREE.

◆ mz_inflate()

MINIZ_EXPORT int mz_inflate ( mz_streamp pStream,
int flush )

Definition at line 440 of file miniz.c.

441{
442 inflate_state *pState;
443 mz_uint n, first_call, decomp_flags = TINFL_FLAG_COMPUTE_ADLER32;
444 size_t in_bytes, out_bytes, orig_avail_in;
445 tinfl_status status;
446
447 if ((!pStream) || (!pStream->state))
448 return MZ_STREAM_ERROR;
449 if (flush == MZ_PARTIAL_FLUSH)
450 flush = MZ_SYNC_FLUSH;
451 if ((flush) && (flush != MZ_SYNC_FLUSH) && (flush != MZ_FINISH))
452 return MZ_STREAM_ERROR;
453
454 pState = (inflate_state *)pStream->state;
455 if (pState->m_window_bits > 0)
456 decomp_flags |= TINFL_FLAG_PARSE_ZLIB_HEADER;
457 orig_avail_in = pStream->avail_in;
458
459 first_call = pState->m_first_call;
460 pState->m_first_call = 0;
461 if (pState->m_last_status < 0)
462 return MZ_DATA_ERROR;
463
464 if (pState->m_has_flushed && (flush != MZ_FINISH))
465 return MZ_STREAM_ERROR;
466 pState->m_has_flushed |= (flush == MZ_FINISH);
467
468 if ((flush == MZ_FINISH) && (first_call))
469 {
470 /* MZ_FINISH on the first call implies that the input and output buffers are large enough to hold the entire compressed/decompressed file. */
472 in_bytes = pStream->avail_in;
473 out_bytes = pStream->avail_out;
474 status = tinfl_decompress(&pState->m_decomp, pStream->next_in, &in_bytes, pStream->next_out, pStream->next_out, &out_bytes, decomp_flags);
475 pState->m_last_status = status;
476 pStream->next_in += (mz_uint)in_bytes;
477 pStream->avail_in -= (mz_uint)in_bytes;
478 pStream->total_in += (mz_uint)in_bytes;
479 pStream->adler = tinfl_get_adler32(&pState->m_decomp);
480 pStream->next_out += (mz_uint)out_bytes;
481 pStream->avail_out -= (mz_uint)out_bytes;
482 pStream->total_out += (mz_uint)out_bytes;
483
484 if (status < 0)
485 return MZ_DATA_ERROR;
486 else if (status != TINFL_STATUS_DONE)
487 {
489 return MZ_BUF_ERROR;
490 }
491 return MZ_STREAM_END;
492 }
493 /* flush != MZ_FINISH then we must assume there's more input. */
494 if (flush != MZ_FINISH)
495 decomp_flags |= TINFL_FLAG_HAS_MORE_INPUT;
496
497 if (pState->m_dict_avail)
498 {
499 n = MZ_MIN(pState->m_dict_avail, pStream->avail_out);
500 memcpy(pStream->next_out, pState->m_dict + pState->m_dict_ofs, n);
501 pStream->next_out += n;
502 pStream->avail_out -= n;
503 pStream->total_out += n;
504 pState->m_dict_avail -= n;
505 pState->m_dict_ofs = (pState->m_dict_ofs + n) & (TINFL_LZ_DICT_SIZE - 1);
506 return ((pState->m_last_status == TINFL_STATUS_DONE) && (!pState->m_dict_avail)) ? MZ_STREAM_END : MZ_OK;
507 }
508
509 for (;;)
510 {
511 in_bytes = pStream->avail_in;
512 out_bytes = TINFL_LZ_DICT_SIZE - pState->m_dict_ofs;
513
514 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);
515 pState->m_last_status = status;
516
517 pStream->next_in += (mz_uint)in_bytes;
518 pStream->avail_in -= (mz_uint)in_bytes;
519 pStream->total_in += (mz_uint)in_bytes;
520 pStream->adler = tinfl_get_adler32(&pState->m_decomp);
521
522 pState->m_dict_avail = (mz_uint)out_bytes;
523
524 n = MZ_MIN(pState->m_dict_avail, pStream->avail_out);
525 memcpy(pStream->next_out, pState->m_dict + pState->m_dict_ofs, n);
526 pStream->next_out += n;
527 pStream->avail_out -= n;
528 pStream->total_out += n;
529 pState->m_dict_avail -= n;
530 pState->m_dict_ofs = (pState->m_dict_ofs + n) & (TINFL_LZ_DICT_SIZE - 1);
531
532 if (status < 0)
533 return MZ_DATA_ERROR; /* Stream is corrupted (there could be some uncompressed data left in the output dictionary - oh well). */
534 else if ((status == TINFL_STATUS_NEEDS_MORE_INPUT) && (!orig_avail_in))
535 return MZ_BUF_ERROR; /* Signal caller that we can't make forward progress without supplying more input or by setting flush to MZ_FINISH. */
536 else if (flush == MZ_FINISH)
537 {
538 /* The output buffer MUST be large to hold the remaining uncompressed data when flush==MZ_FINISH. */
539 if (status == TINFL_STATUS_DONE)
540 return pState->m_dict_avail ? MZ_BUF_ERROR : MZ_STREAM_END;
541 /* 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. */
542 else if (!pStream->avail_out)
543 return MZ_BUF_ERROR;
544 }
545 else if ((status == TINFL_STATUS_DONE) || (!pStream->avail_in) || (!pStream->avail_out) || (pState->m_dict_avail))
546 break;
547 }
548
549 return ((status == TINFL_STATUS_DONE) && (!pState->m_dict_avail)) ? MZ_STREAM_END : MZ_OK;
550}
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)
Definition miniz.c:2438
#define TINFL_LZ_DICT_SIZE
Definition miniz.h:880
#define tinfl_get_adler32(r)
Definition miniz.h:923
#define MZ_MIN(a, b)
Definition miniz.h:595
int m_window_bits
Definition miniz.c:368
mz_uint m_dict_ofs
Definition miniz.c:367
mz_uint m_has_flushed
Definition miniz.c:367
mz_uint m_dict_avail
Definition miniz.c:367
mz_uint8 m_dict[TINFL_LZ_DICT_SIZE]
Definition miniz.c:369
mz_uint m_first_call
Definition miniz.c:367
tinfl_status m_last_status
Definition miniz.c:370
tinfl_decompressor m_decomp
Definition miniz.c:366

References mz_stream_s::adler, mz_stream_s::avail_in, mz_stream_s::avail_out, inflate_state::m_decomp, inflate_state::m_dict, inflate_state::m_dict_avail, inflate_state::m_dict_ofs, inflate_state::m_first_call, inflate_state::m_has_flushed, inflate_state::m_last_status, inflate_state::m_window_bits, MZ_BUF_ERROR, MZ_DATA_ERROR, MZ_FINISH, MZ_MIN, MZ_OK, MZ_PARTIAL_FLUSH, MZ_STREAM_END, MZ_STREAM_ERROR, MZ_SYNC_FLUSH, mz_stream_s::next_in, mz_stream_s::next_out, mz_stream_s::state, tinfl_decompress(), TINFL_FLAG_COMPUTE_ADLER32, TINFL_FLAG_HAS_MORE_INPUT, TINFL_FLAG_PARSE_ZLIB_HEADER, TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF, tinfl_get_adler32, TINFL_LZ_DICT_SIZE, TINFL_STATUS_DONE, TINFL_STATUS_FAILED, TINFL_STATUS_NEEDS_MORE_INPUT, mz_stream_s::total_in, and mz_stream_s::total_out.

Referenced by mz_uncompress2().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_inflateEnd()

MINIZ_EXPORT int mz_inflateEnd ( mz_streamp pStream)

Definition at line 552 of file miniz.c.

553{
554 if (!pStream)
555 return MZ_STREAM_ERROR;
556 if (pStream->state)
557 {
558 pStream->zfree(pStream->opaque, pStream->state);
559 pStream->state = NULL;
560 }
561 return MZ_OK;
562}

References MZ_OK, MZ_STREAM_ERROR, mz_stream_s::opaque, mz_stream_s::state, and mz_stream_s::zfree.

Referenced by mz_uncompress2().

+ Here is the caller graph for this function:

◆ mz_inflateInit()

MINIZ_EXPORT int mz_inflateInit ( mz_streamp pStream)

Definition at line 409 of file miniz.c.

410{
412}
int mz_inflateInit2(mz_streamp pStream, int window_bits)
Definition miniz.c:373

References MZ_DEFAULT_WINDOW_BITS, and mz_inflateInit2().

Referenced by mz_uncompress2().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_inflateInit2()

MINIZ_EXPORT int mz_inflateInit2 ( mz_streamp pStream,
int window_bits )

Definition at line 373 of file miniz.c.

374{
375 inflate_state *pDecomp;
376 if (!pStream)
377 return MZ_STREAM_ERROR;
378 if ((window_bits != MZ_DEFAULT_WINDOW_BITS) && (-window_bits != MZ_DEFAULT_WINDOW_BITS))
379 return MZ_PARAM_ERROR;
380
381 pStream->data_type = 0;
382 pStream->adler = 0;
383 pStream->msg = NULL;
384 pStream->total_in = 0;
385 pStream->total_out = 0;
386 pStream->reserved = 0;
387 if (!pStream->zalloc)
388 pStream->zalloc = miniz_def_alloc_func;
389 if (!pStream->zfree)
390 pStream->zfree = miniz_def_free_func;
391
392 pDecomp = (inflate_state *)pStream->zalloc(pStream->opaque, 1, sizeof(inflate_state));
393 if (!pDecomp)
394 return MZ_MEM_ERROR;
395
396 pStream->state = (struct mz_internal_state *)pDecomp;
397
398 tinfl_init(&pDecomp->m_decomp);
399 pDecomp->m_dict_ofs = 0;
400 pDecomp->m_dict_avail = 0;
402 pDecomp->m_first_call = 1;
403 pDecomp->m_has_flushed = 0;
404 pDecomp->m_window_bits = window_bits;
405
406 return MZ_OK;
407}
#define tinfl_init(r)
Definition miniz.h:917

References mz_stream_s::adler, mz_stream_s::data_type, inflate_state::m_decomp, inflate_state::m_dict_avail, inflate_state::m_dict_ofs, inflate_state::m_first_call, inflate_state::m_has_flushed, inflate_state::m_last_status, inflate_state::m_window_bits, miniz_def_alloc_func(), miniz_def_free_func(), mz_stream_s::msg, MZ_DEFAULT_WINDOW_BITS, MZ_MEM_ERROR, MZ_OK, MZ_PARAM_ERROR, MZ_STREAM_ERROR, mz_stream_s::opaque, mz_stream_s::reserved, mz_stream_s::state, tinfl_init, TINFL_STATUS_NEEDS_MORE_INPUT, mz_stream_s::total_in, mz_stream_s::total_out, mz_stream_s::zalloc, and mz_stream_s::zfree.

Referenced by mz_inflateInit().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_inflateReset()

MINIZ_EXPORT int mz_inflateReset ( mz_streamp pStream)

Definition at line 414 of file miniz.c.

415{
416 inflate_state *pDecomp;
417 if (!pStream)
418 return MZ_STREAM_ERROR;
419
420 pStream->data_type = 0;
421 pStream->adler = 0;
422 pStream->msg = NULL;
423 pStream->total_in = 0;
424 pStream->total_out = 0;
425 pStream->reserved = 0;
426
427 pDecomp = (inflate_state *)pStream->state;
428
429 tinfl_init(&pDecomp->m_decomp);
430 pDecomp->m_dict_ofs = 0;
431 pDecomp->m_dict_avail = 0;
433 pDecomp->m_first_call = 1;
434 pDecomp->m_has_flushed = 0;
435 /* pDecomp->m_window_bits = window_bits */;
436
437 return MZ_OK;
438}

References mz_stream_s::adler, mz_stream_s::data_type, inflate_state::m_decomp, inflate_state::m_dict_avail, inflate_state::m_dict_ofs, inflate_state::m_first_call, inflate_state::m_has_flushed, inflate_state::m_last_status, mz_stream_s::msg, MZ_OK, MZ_STREAM_ERROR, mz_stream_s::reserved, mz_stream_s::state, tinfl_init, TINFL_STATUS_NEEDS_MORE_INPUT, mz_stream_s::total_in, and mz_stream_s::total_out.

◆ mz_uncompress()

MINIZ_EXPORT int mz_uncompress ( unsigned char * pDest,
mz_ulong * pDest_len,
const unsigned char * pSource,
mz_ulong source_len )

Definition at line 594 of file miniz.c.

595{
596 return mz_uncompress2(pDest, pDest_len, pSource, &source_len);
597}
int mz_uncompress2(unsigned char *pDest, mz_ulong *pDest_len, const unsigned char *pSource, mz_ulong *pSource_len)
Definition miniz.c:563

References mz_uncompress2().

+ Here is the call graph for this function:

◆ mz_uncompress2()

MINIZ_EXPORT int mz_uncompress2 ( unsigned char * pDest,
mz_ulong * pDest_len,
const unsigned char * pSource,
mz_ulong * pSource_len )

Definition at line 563 of file miniz.c.

564{
566 int status;
567 memset(&stream, 0, sizeof(stream));
568
569 /* In case mz_ulong is 64-bits (argh I hate longs). */
570 if ((mz_uint64)(*pSource_len | *pDest_len) > 0xFFFFFFFFU)
571 return MZ_PARAM_ERROR;
572
573 stream.next_in = pSource;
574 stream.avail_in = (mz_uint32)*pSource_len;
575 stream.next_out = pDest;
576 stream.avail_out = (mz_uint32)*pDest_len;
577
578 status = mz_inflateInit(&stream);
579 if (status != MZ_OK)
580 return status;
581
582 status = mz_inflate(&stream, MZ_FINISH);
583 *pSource_len = *pSource_len - stream.avail_in;
584 if (status != MZ_STREAM_END)
585 {
587 return ((status == MZ_BUF_ERROR) && (!stream.avail_in)) ? MZ_DATA_ERROR : status;
588 }
589 *pDest_len = stream.total_out;
590
591 return mz_inflateEnd(&stream);
592}
int mz_inflateInit(mz_streamp pStream)
Definition miniz.c:409
int mz_inflate(mz_streamp pStream, int flush)
Definition miniz.c:440
int mz_inflateEnd(mz_streamp pStream)
Definition miniz.c:552

References MZ_BUF_ERROR, MZ_DATA_ERROR, MZ_FINISH, mz_inflate(), mz_inflateEnd(), mz_inflateInit(), MZ_OK, MZ_PARAM_ERROR, and MZ_STREAM_END.

Referenced by mz_uncompress().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_version()

MINIZ_EXPORT const char * mz_version ( void )

Definition at line 184 of file miniz.c.

185{
186 return MZ_VERSION;
187}
#define MZ_VERSION
Definition miniz.h:278

References MZ_VERSION.

◆ mz_zip_add_mem_to_archive_file_in_place()

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 )

Definition at line 7483 of file miniz.c.

7484{
7485 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);
7486}
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)
Definition miniz.c:7488

References mz_zip_add_mem_to_archive_file_in_place_v2().

+ Here is the call graph for this function:

◆ mz_zip_add_mem_to_archive_file_in_place_v2()

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 )

Definition at line 7488 of file miniz.c.

7489{
7490 mz_bool status, created_new_archive = MZ_FALSE;
7491 mz_zip_archive zip_archive;
7492 struct MZ_FILE_STAT_STRUCT file_stat;
7493 mz_zip_error actual_err = MZ_ZIP_NO_ERROR;
7494
7495 mz_zip_zero_struct(&zip_archive);
7496 if ((int)level_and_flags < 0)
7497 level_and_flags = MZ_DEFAULT_LEVEL;
7498
7499 if ((!pZip_filename) || (!pArchive_name) || ((buf_size) && (!pBuf)) || ((comment_size) && (!pComment)) || ((level_and_flags & 0xF) > MZ_UBER_COMPRESSION))
7500 {
7501 if (pErr)
7503 return MZ_FALSE;
7504 }
7505
7506 if (!mz_zip_writer_validate_archive_name(pArchive_name))
7507 {
7508 if (pErr)
7510 return MZ_FALSE;
7511 }
7512
7513 /* 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. */
7514 /* So be sure to compile with _LARGEFILE64_SOURCE 1 */
7515 if (MZ_FILE_STAT(pZip_filename, &file_stat) != 0)
7516 {
7517 /* Create a new archive. */
7518 if (!mz_zip_writer_init_file_v2(&zip_archive, pZip_filename, 0, level_and_flags))
7519 {
7520 if (pErr)
7521 *pErr = zip_archive.m_last_error;
7522 return MZ_FALSE;
7523 }
7524
7525 created_new_archive = MZ_TRUE;
7526 }
7527 else
7528 {
7529 /* Append to an existing archive. */
7530 if (!mz_zip_reader_init_file_v2(&zip_archive, pZip_filename, level_and_flags | MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY, 0, 0))
7531 {
7532 if (pErr)
7533 *pErr = zip_archive.m_last_error;
7534 return MZ_FALSE;
7535 }
7536
7537 if (!mz_zip_writer_init_from_reader_v2(&zip_archive, pZip_filename, level_and_flags))
7538 {
7539 if (pErr)
7540 *pErr = zip_archive.m_last_error;
7541
7542 mz_zip_reader_end_internal(&zip_archive, MZ_FALSE);
7543
7544 return MZ_FALSE;
7545 }
7546 }
7547
7548 status = mz_zip_writer_add_mem_ex(&zip_archive, pArchive_name, pBuf, buf_size, pComment, comment_size, level_and_flags, 0, 0);
7549 actual_err = zip_archive.m_last_error;
7550
7551 /* 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.) */
7552 if (!mz_zip_writer_finalize_archive(&zip_archive))
7553 {
7554 if (!actual_err)
7555 actual_err = zip_archive.m_last_error;
7556
7557 status = MZ_FALSE;
7558 }
7559
7560 if (!mz_zip_writer_end_internal(&zip_archive, status))
7561 {
7562 if (!actual_err)
7563 actual_err = zip_archive.m_last_error;
7564
7565 status = MZ_FALSE;
7566 }
7567
7568 if ((!status) && (created_new_archive))
7569 {
7570 /* It's a new archive and something went wrong, so just delete it. */
7571 int ignoredStatus = MZ_DELETE_FILE(pZip_filename);
7572 (void)ignoredStatus;
7573 }
7574
7575 if (pErr)
7576 *pErr = actual_err;
7577
7578 return status;
7579}
#define MZ_FILE_STAT
Definition miniz.c:3221
mz_bool mz_zip_writer_finalize_archive(mz_zip_archive *pZip)
Definition miniz.c:7364
static mz_bool mz_zip_writer_end_internal(mz_zip_archive *pZip, mz_bool set_last_error)
Definition miniz.c:5723
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)
Definition miniz.c:5878
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)
Definition miniz.c:6218
static mz_bool mz_zip_reader_end_internal(mz_zip_archive *pZip, mz_bool set_last_error)
Definition miniz.c:3924
void mz_zip_zero_struct(mz_zip_archive *pZip)
Definition miniz.c:3918
static mz_bool mz_zip_writer_validate_archive_name(const char *pArchive_name)
Definition miniz.c:6182
mz_bool mz_zip_writer_init_from_reader_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint flags)
Definition miniz.c:5946
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)
Definition miniz.c:4056
#define MZ_FILE_STAT_STRUCT
Definition miniz.c:3220
#define MZ_DELETE_FILE
Definition miniz.c:3224
#define MZ_FALSE
Definition miniz.h:554
int mz_bool
Definition miniz.h:552
#define MZ_TRUE
Definition miniz.h:555
mz_zip_error m_last_error
Definition miniz.h:1136

References mz_zip_archive::m_last_error, MZ_DEFAULT_LEVEL, MZ_DELETE_FILE, MZ_FALSE, MZ_FILE_STAT, MZ_FILE_STAT_STRUCT, MZ_TRUE, MZ_UBER_COMPRESSION, MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY, MZ_ZIP_INVALID_FILENAME, MZ_ZIP_INVALID_PARAMETER, MZ_ZIP_NO_ERROR, mz_zip_reader_end_internal(), mz_zip_reader_init_file_v2(), mz_zip_writer_add_mem_ex(), mz_zip_writer_end_internal(), mz_zip_writer_finalize_archive(), mz_zip_writer_init_file_v2(), mz_zip_writer_init_from_reader_v2(), mz_zip_writer_validate_archive_name(), and mz_zip_zero_struct().

Referenced by mz_zip_add_mem_to_archive_file_in_place().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_zip_clear_last_error()

MINIZ_EXPORT mz_zip_error mz_zip_clear_last_error ( mz_zip_archive * pZip)

Definition at line 7662 of file miniz.c.

7663{
7665}
mz_zip_error mz_zip_set_last_error(mz_zip_archive *pZip, mz_zip_error err_num)
Definition miniz.c:7641

References MZ_ZIP_NO_ERROR, and mz_zip_set_last_error().

+ Here is the call graph for this function:

◆ mz_zip_end()

MINIZ_EXPORT mz_bool mz_zip_end ( mz_zip_archive * pZip)

Definition at line 7834 of file miniz.c.

7835{
7836 if (!pZip)
7837 return MZ_FALSE;
7838
7839 if (pZip->m_zip_mode == MZ_ZIP_MODE_READING)
7840 return mz_zip_reader_end(pZip);
7841#ifndef MINIZ_NO_ARCHIVE_WRITING_APIS
7843 return mz_zip_writer_end(pZip);
7844#endif
7845
7846 return MZ_FALSE;
7847}
mz_bool mz_zip_reader_end(mz_zip_archive *pZip)
Definition miniz.c:3971
mz_bool mz_zip_writer_end(mz_zip_archive *pZip)
Definition miniz.c:7477
mz_zip_mode m_zip_mode
Definition miniz.h:1134

References mz_zip_archive::m_zip_mode, MZ_FALSE, MZ_ZIP_MODE_READING, MZ_ZIP_MODE_WRITING, MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED, mz_zip_reader_end(), and mz_zip_writer_end().

+ Here is the call graph for this function:

◆ mz_zip_extract_archive_file_to_heap()

MINIZ_EXPORT void * mz_zip_extract_archive_file_to_heap ( const char * pZip_filename,
const char * pArchive_name,
size_t * pSize,
mz_uint flags )

Definition at line 7620 of file miniz.c.

7621{
7622 return mz_zip_extract_archive_file_to_heap_v2(pZip_filename, pArchive_name, NULL, pSize, flags, NULL);
7623}
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)
Definition miniz.c:7581

References mz_zip_extract_archive_file_to_heap_v2().

+ Here is the call graph for this function:

◆ mz_zip_extract_archive_file_to_heap_v2()

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 )

Definition at line 7581 of file miniz.c.

7582{
7583 mz_uint32 file_index;
7584 mz_zip_archive zip_archive;
7585 void *p = NULL;
7586
7587 if (pSize)
7588 *pSize = 0;
7589
7590 if ((!pZip_filename) || (!pArchive_name))
7591 {
7592 if (pErr)
7594
7595 return NULL;
7596 }
7597
7598 mz_zip_zero_struct(&zip_archive);
7599 if (!mz_zip_reader_init_file_v2(&zip_archive, pZip_filename, flags | MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY, 0, 0))
7600 {
7601 if (pErr)
7602 *pErr = zip_archive.m_last_error;
7603
7604 return NULL;
7605 }
7606
7607 if (mz_zip_reader_locate_file_v2(&zip_archive, pArchive_name, pComment, flags, &file_index))
7608 {
7609 p = mz_zip_reader_extract_to_heap(&zip_archive, file_index, pSize, flags);
7610 }
7611
7612 mz_zip_reader_end_internal(&zip_archive, p != NULL);
7613
7614 if (pErr)
7615 *pErr = zip_archive.m_last_error;
7616
7617 return p;
7618}
mz_bool mz_zip_reader_locate_file_v2(mz_zip_archive *pZip, const char *pName, const char *pComment, mz_uint flags, mz_uint32 *pIndex)
Definition miniz.c:4438
void * mz_zip_reader_extract_to_heap(mz_zip_archive *pZip, mz_uint file_index, size_t *pSize, mz_uint flags)
Definition miniz.c:4673

References mz_zip_archive::m_last_error, MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY, MZ_ZIP_INVALID_PARAMETER, mz_zip_reader_end_internal(), mz_zip_reader_extract_to_heap(), mz_zip_reader_init_file_v2(), mz_zip_reader_locate_file_v2(), and mz_zip_zero_struct().

Referenced by mz_zip_extract_archive_file_to_heap().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_zip_get_archive_file_start_offset()

MINIZ_EXPORT mz_uint64 mz_zip_get_archive_file_start_offset ( mz_zip_archive * pZip)

Definition at line 7786 of file miniz.c.

7787{
7788 if ((!pZip) || (!pZip->m_pState))
7789 return 0;
7790 return pZip->m_pState->m_file_archive_start_ofs;
7791}
mz_zip_internal_state * m_pState
Definition miniz.h:1150
mz_uint64 m_file_archive_start_ofs
Definition miniz.c:3344

References mz_zip_internal_state_tag::m_file_archive_start_ofs, and mz_zip_archive::m_pState.

◆ mz_zip_get_archive_size()

MINIZ_EXPORT mz_uint64 mz_zip_get_archive_size ( mz_zip_archive * pZip)

Definition at line 7779 of file miniz.c.

7780{
7781 if (!pZip)
7782 return 0;
7783 return pZip->m_archive_size;
7784}
mz_uint64 m_archive_size
Definition miniz.h:1129

References mz_zip_archive::m_archive_size.

◆ mz_zip_get_central_dir_size()

MINIZ_EXPORT size_t mz_zip_get_central_dir_size ( mz_zip_archive * pZip)

Definition at line 7766 of file miniz.c.

7767{
7768 if ((!pZip) || (!pZip->m_pState))
7769 return 0;
7770
7771 return pZip->m_pState->m_central_dir.m_size;
7772}
size_t m_size
Definition miniz.c:3323
mz_zip_array m_central_dir
Definition miniz.c:3329

References mz_zip_internal_state_tag::m_central_dir, mz_zip_archive::m_pState, and mz_zip_array::m_size.

◆ mz_zip_get_cfile()

MINIZ_EXPORT MZ_FILE * mz_zip_get_cfile ( mz_zip_archive * pZip)

Definition at line 7793 of file miniz.c.

7794{
7795 if ((!pZip) || (!pZip->m_pState))
7796 return 0;
7797 return pZip->m_pState->m_pFile;
7798}

References mz_zip_internal_state_tag::m_pFile, and mz_zip_archive::m_pState.

◆ mz_zip_get_error_string()

MINIZ_EXPORT const char * mz_zip_get_error_string ( mz_zip_error mz_err)

Definition at line 7680 of file miniz.c.

7681{
7682 switch (mz_err)
7683 {
7684 case MZ_ZIP_NO_ERROR:
7685 return "no error";
7687 return "undefined error";
7689 return "too many files";
7691 return "file too large";
7693 return "unsupported method";
7695 return "unsupported encryption";
7697 return "unsupported feature";
7699 return "failed finding central directory";
7701 return "not a ZIP archive";
7703 return "invalid header or archive is corrupted";
7705 return "unsupported multidisk archive";
7707 return "decompression failed or archive is corrupted";
7709 return "compression failed";
7711 return "unexpected decompressed size";
7713 return "CRC-32 check failed";
7715 return "unsupported central directory size";
7717 return "allocation failed";
7719 return "file open failed";
7721 return "file create failed";
7723 return "file write failed";
7725 return "file read failed";
7727 return "file close failed";
7729 return "file seek failed";
7731 return "file stat failed";
7733 return "invalid parameter";
7735 return "invalid filename";
7737 return "buffer too small";
7739 return "internal error";
7741 return "file not found";
7743 return "archive is too large";
7745 return "validation failed";
7747 return "write callback failed";
7749 return "total errors";
7750 default:
7751 break;
7752 }
7753
7754 return "unknown error";
7755}

References MZ_ZIP_ALLOC_FAILED, MZ_ZIP_ARCHIVE_TOO_LARGE, MZ_ZIP_BUF_TOO_SMALL, MZ_ZIP_COMPRESSION_FAILED, MZ_ZIP_CRC_CHECK_FAILED, MZ_ZIP_DECOMPRESSION_FAILED, MZ_ZIP_FAILED_FINDING_CENTRAL_DIR, MZ_ZIP_FILE_CLOSE_FAILED, MZ_ZIP_FILE_CREATE_FAILED, MZ_ZIP_FILE_NOT_FOUND, MZ_ZIP_FILE_OPEN_FAILED, MZ_ZIP_FILE_READ_FAILED, MZ_ZIP_FILE_SEEK_FAILED, MZ_ZIP_FILE_STAT_FAILED, MZ_ZIP_FILE_TOO_LARGE, MZ_ZIP_FILE_WRITE_FAILED, MZ_ZIP_INTERNAL_ERROR, MZ_ZIP_INVALID_FILENAME, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED, MZ_ZIP_INVALID_PARAMETER, MZ_ZIP_NO_ERROR, MZ_ZIP_NOT_AN_ARCHIVE, MZ_ZIP_TOO_MANY_FILES, MZ_ZIP_TOTAL_ERRORS, MZ_ZIP_UNDEFINED_ERROR, MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE, MZ_ZIP_UNSUPPORTED_CDIR_SIZE, MZ_ZIP_UNSUPPORTED_ENCRYPTION, MZ_ZIP_UNSUPPORTED_FEATURE, MZ_ZIP_UNSUPPORTED_METHOD, MZ_ZIP_UNSUPPORTED_MULTIDISK, MZ_ZIP_VALIDATION_FAILED, and MZ_ZIP_WRITE_CALLBACK_FAILED.

◆ mz_zip_get_last_error()

MINIZ_EXPORT mz_zip_error mz_zip_get_last_error ( mz_zip_archive * pZip)

Definition at line 7667 of file miniz.c.

7668{
7669 mz_zip_error prev_err;
7670
7671 if (!pZip)
7673
7674 prev_err = pZip->m_last_error;
7675
7677 return prev_err;
7678}

References mz_zip_archive::m_last_error, MZ_ZIP_INVALID_PARAMETER, and MZ_ZIP_NO_ERROR.

◆ mz_zip_get_mode()

MINIZ_EXPORT mz_zip_mode mz_zip_get_mode ( mz_zip_archive * pZip)

Definition at line 7631 of file miniz.c.

7632{
7633 return pZip ? pZip->m_zip_mode : MZ_ZIP_MODE_INVALID;
7634}

References mz_zip_archive::m_zip_mode, and MZ_ZIP_MODE_INVALID.

◆ mz_zip_get_type()

MINIZ_EXPORT mz_zip_type mz_zip_get_type ( mz_zip_archive * pZip)

Definition at line 7636 of file miniz.c.

7637{
7638 return pZip ? pZip->m_zip_type : MZ_ZIP_TYPE_INVALID;
7639}
mz_zip_type m_zip_type
Definition miniz.h:1135

References mz_zip_archive::m_zip_type, and MZ_ZIP_TYPE_INVALID.

◆ mz_zip_is_zip64()

MINIZ_EXPORT mz_bool mz_zip_is_zip64 ( mz_zip_archive * pZip)

Definition at line 7758 of file miniz.c.

7759{
7760 if ((!pZip) || (!pZip->m_pState))
7761 return MZ_FALSE;
7762
7763 return pZip->m_pState->m_zip64;
7764}

References mz_zip_archive::m_pState, mz_zip_internal_state_tag::m_zip64, and MZ_FALSE.

◆ mz_zip_peek_last_error()

MINIZ_EXPORT mz_zip_error mz_zip_peek_last_error ( mz_zip_archive * pZip)

Definition at line 7654 of file miniz.c.

7655{
7656 if (!pZip)
7658
7659 return pZip->m_last_error;
7660}

References mz_zip_archive::m_last_error, and MZ_ZIP_INVALID_PARAMETER.

◆ mz_zip_read_archive_data()

MINIZ_EXPORT size_t mz_zip_read_archive_data ( mz_zip_archive * pZip,
mz_uint64 file_ofs,
void * pBuf,
size_t n )

Definition at line 7800 of file miniz.c.

7801{
7802 if ((!pZip) || (!pZip->m_pState) || (!pBuf) || (!pZip->m_pRead))
7804
7805 return pZip->m_pRead(pZip->m_pIO_opaque, file_ofs, pBuf, n);
7806}
static MZ_FORCEINLINE mz_bool mz_zip_set_error(mz_zip_archive *pZip, mz_zip_error err_num)
Definition miniz.c:3498
void * m_pIO_opaque
Definition miniz.h:1148
mz_file_read_func m_pRead
Definition miniz.h:1145

References mz_zip_archive::m_pIO_opaque, mz_zip_archive::m_pRead, mz_zip_archive::m_pState, MZ_ZIP_INVALID_PARAMETER, and mz_zip_set_error().

+ Here is the call graph for this function:

◆ mz_zip_reader_end()

MINIZ_EXPORT mz_bool mz_zip_reader_end ( mz_zip_archive * pZip)

Definition at line 3971 of file miniz.c.

3972{
3973 return mz_zip_reader_end_internal(pZip, MZ_TRUE);
3974}

References MZ_TRUE, and mz_zip_reader_end_internal().

Referenced by mz_zip_end().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_zip_reader_extract_file_iter_new()

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 )

Definition at line 5058 of file miniz.c.

5059{
5060 mz_uint32 file_index;
5061
5062 /* Locate file index by name */
5063 if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index))
5064 return NULL;
5065
5066 /* Construct iterator */
5067 return mz_zip_reader_extract_iter_new(pZip, file_index, flags);
5068}
mz_zip_reader_extract_iter_state * mz_zip_reader_extract_iter_new(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags)
Definition miniz.c:4930

References mz_zip_reader_extract_iter_new(), and mz_zip_reader_locate_file_v2().

+ Here is the call graph for this function:

◆ mz_zip_reader_extract_file_to_callback()

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 )

Definition at line 4921 of file miniz.c.

4922{
4923 mz_uint32 file_index;
4924 if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index))
4925 return MZ_FALSE;
4926
4927 return mz_zip_reader_extract_to_callback(pZip, file_index, pCallback, pOpaque, flags);
4928}
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)
Definition miniz.c:4721

References MZ_FALSE, mz_zip_reader_extract_to_callback(), and mz_zip_reader_locate_file_v2().

+ Here is the call graph for this function:

◆ mz_zip_reader_extract_file_to_cfile()

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 )

Definition at line 5292 of file miniz.c.

5293{
5294 mz_uint32 file_index;
5295 if (!mz_zip_reader_locate_file_v2(pZip, pArchive_filename, NULL, flags, &file_index))
5296 return MZ_FALSE;
5297
5298 return mz_zip_reader_extract_to_cfile(pZip, file_index, pFile, flags);
5299}
mz_bool mz_zip_reader_extract_to_cfile(mz_zip_archive *pZip, mz_uint file_index, MZ_FILE *pFile, mz_uint flags)
Definition miniz.c:5279

References MZ_FALSE, mz_zip_reader_extract_to_cfile(), and mz_zip_reader_locate_file_v2().

+ Here is the call graph for this function:

◆ mz_zip_reader_extract_file_to_file()

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 )

Definition at line 5270 of file miniz.c.

5271{
5272 mz_uint32 file_index;
5273 if (!mz_zip_reader_locate_file_v2(pZip, pArchive_filename, NULL, flags, &file_index))
5274 return MZ_FALSE;
5275
5276 return mz_zip_reader_extract_to_file(pZip, file_index, pDst_filename, flags);
5277}
mz_bool mz_zip_reader_extract_to_file(mz_zip_archive *pZip, mz_uint file_index, const char *pDst_filename, mz_uint flags)
Definition miniz.c:5236

References MZ_FALSE, mz_zip_reader_extract_to_file(), and mz_zip_reader_locate_file_v2().

+ Here is the call graph for this function:

◆ mz_zip_reader_extract_file_to_heap()

MINIZ_EXPORT void * mz_zip_reader_extract_file_to_heap ( mz_zip_archive * pZip,
const char * pFilename,
size_t * pSize,
mz_uint flags )

Definition at line 4709 of file miniz.c.

4710{
4711 mz_uint32 file_index;
4712 if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index))
4713 {
4714 if (pSize)
4715 *pSize = 0;
4716 return MZ_FALSE;
4717 }
4718 return mz_zip_reader_extract_to_heap(pZip, file_index, pSize, flags);
4719}

References MZ_FALSE, mz_zip_reader_extract_to_heap(), and mz_zip_reader_locate_file_v2().

+ Here is the call graph for this function:

◆ mz_zip_reader_extract_file_to_mem()

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 )

Definition at line 4668 of file miniz.c.

4669{
4670 return mz_zip_reader_extract_file_to_mem_no_alloc(pZip, pFilename, pBuf, buf_size, flags, NULL, 0);
4671}
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)
Definition miniz.c:4655

References mz_zip_reader_extract_file_to_mem_no_alloc().

+ Here is the call graph for this function:

◆ mz_zip_reader_extract_file_to_mem_no_alloc()

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 )

Definition at line 4655 of file miniz.c.

4656{
4657 mz_uint32 file_index;
4658 if (!mz_zip_reader_locate_file_v2(pZip, pFilename, NULL, flags, &file_index))
4659 return MZ_FALSE;
4660 return mz_zip_reader_extract_to_mem_no_alloc1(pZip, file_index, pBuf, buf_size, flags, pUser_read_buf, user_read_buf_size, NULL);
4661}
static mz_bool mz_zip_reader_extract_to_mem_no_alloc1(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, const mz_zip_archive_file_stat *st)
Definition miniz.c:4504

References MZ_FALSE, mz_zip_reader_extract_to_mem_no_alloc1(), and mz_zip_reader_locate_file_v2().

Referenced by mz_zip_reader_extract_file_to_mem().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_zip_reader_extract_iter_free()

MINIZ_EXPORT mz_bool mz_zip_reader_extract_iter_free ( mz_zip_reader_extract_iter_state * pState)

Definition at line 5187 of file miniz.c.

5188{
5189 int status;
5190
5191 /* Argument sanity check */
5192 if ((!pState) || (!pState->pZip) || (!pState->pZip->m_pState))
5193 return MZ_FALSE;
5194
5195 /* Was decompression completed and requested? */
5196 if ((pState->status == TINFL_STATUS_DONE) && (!(pState->flags & MZ_ZIP_FLAG_COMPRESSED_DATA)))
5197 {
5198 /* Make sure the entire file was decompressed, and check its CRC. */
5199 if (pState->out_buf_ofs != pState->file_stat.m_uncomp_size)
5200 {
5202 pState->status = TINFL_STATUS_FAILED;
5203 }
5204#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
5205 else if (pState->file_crc32 != pState->file_stat.m_crc32)
5206 {
5208 pState->status = TINFL_STATUS_FAILED;
5209 }
5210#endif
5211 }
5212
5213 /* Free buffers */
5214 if (!pState->pZip->m_pState->m_pMem)
5215 pState->pZip->m_pFree(pState->pZip->m_pAlloc_opaque, pState->pRead_buf);
5216 if (pState->pWrite_buf)
5217 pState->pZip->m_pFree(pState->pZip->m_pAlloc_opaque, pState->pWrite_buf);
5218
5219 /* Save status */
5220 status = pState->status;
5221
5222 /* Free context */
5223 pState->pZip->m_pFree(pState->pZip->m_pAlloc_opaque, pState);
5224
5225 return status == TINFL_STATUS_DONE;
5226}
mz_uint64 m_uncomp_size
Definition miniz.h:1015
void * m_pAlloc_opaque
Definition miniz.h:1143
mz_free_func m_pFree
Definition miniz.h:1141
mz_zip_archive_file_stat file_stat
Definition miniz.h:1162

References mz_zip_reader_extract_iter_state::file_crc32, mz_zip_reader_extract_iter_state::file_stat, mz_zip_reader_extract_iter_state::flags, mz_zip_archive_file_stat::m_crc32, mz_zip_archive::m_pAlloc_opaque, mz_zip_archive::m_pFree, mz_zip_internal_state_tag::m_pMem, mz_zip_archive::m_pState, mz_zip_archive_file_stat::m_uncomp_size, MZ_FALSE, MZ_ZIP_DECOMPRESSION_FAILED, MZ_ZIP_FLAG_COMPRESSED_DATA, mz_zip_set_error(), MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE, mz_zip_reader_extract_iter_state::out_buf_ofs, mz_zip_reader_extract_iter_state::pRead_buf, mz_zip_reader_extract_iter_state::pWrite_buf, mz_zip_reader_extract_iter_state::pZip, mz_zip_reader_extract_iter_state::status, TINFL_STATUS_DONE, and TINFL_STATUS_FAILED.

+ Here is the call graph for this function:

◆ mz_zip_reader_extract_iter_new()

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 )

Definition at line 4930 of file miniz.c.

4931{
4933 mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];
4934 mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32;
4935
4936 /* Argument sanity check */
4937 if ((!pZip) || (!pZip->m_pState))
4938 return NULL;
4939
4940 /* Allocate an iterator status structure */
4942 if (!pState)
4943 {
4945 return NULL;
4946 }
4947
4948 /* Fetch file details */
4949 if (!mz_zip_reader_file_stat(pZip, file_index, &pState->file_stat))
4950 {
4951 pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
4952 return NULL;
4953 }
4954
4955 /* Encryption and patch files are not supported. */
4957 {
4959 pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
4960 return NULL;
4961 }
4962
4963 /* This function only supports decompressing stored and deflate. */
4964 if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (pState->file_stat.m_method != 0) && (pState->file_stat.m_method != MZ_DEFLATED))
4965 {
4967 pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
4968 return NULL;
4969 }
4970
4971 /* Init state - save args */
4972 pState->pZip = pZip;
4973 pState->flags = flags;
4974
4975 /* Init state - reset variables to defaults */
4976 pState->status = TINFL_STATUS_DONE;
4977#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
4978 pState->file_crc32 = MZ_CRC32_INIT;
4979#endif
4980 pState->read_buf_ofs = 0;
4981 pState->out_buf_ofs = 0;
4982 pState->pRead_buf = NULL;
4983 pState->pWrite_buf = NULL;
4984 pState->out_blk_remain = 0;
4985
4986 /* Read and parse the local directory entry. */
4987 pState->cur_file_ofs = pState->file_stat.m_local_header_ofs;
4989 {
4991 pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
4992 return NULL;
4993 }
4994
4995 if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG)
4996 {
4998 pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
4999 return NULL;
5000 }
5001
5003 if ((pState->cur_file_ofs + pState->file_stat.m_comp_size) > pZip->m_archive_size)
5004 {
5006 pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
5007 return NULL;
5008 }
5009
5010 /* Decompress the file either directly from memory or from a file input buffer. */
5011 if (pZip->m_pState->m_pMem)
5012 {
5013 pState->pRead_buf = (mz_uint8 *)pZip->m_pState->m_pMem + pState->cur_file_ofs;
5014 pState->read_buf_size = pState->read_buf_avail = pState->file_stat.m_comp_size;
5015 pState->comp_remaining = pState->file_stat.m_comp_size;
5016 }
5017 else
5018 {
5019 if (!((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!pState->file_stat.m_method)))
5020 {
5021 /* Decompression required, therefore intermediate read buffer required */
5023 if (NULL == (pState->pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)pState->read_buf_size)))
5024 {
5026 pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
5027 return NULL;
5028 }
5029 }
5030 else
5031 {
5032 /* Decompression not required - we will be reading directly into user buffer, no temp buf required */
5033 pState->read_buf_size = 0;
5034 }
5035 pState->read_buf_avail = 0;
5036 pState->comp_remaining = pState->file_stat.m_comp_size;
5037 }
5038
5039 if (!((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!pState->file_stat.m_method)))
5040 {
5041 /* Decompression required, init decompressor */
5042 tinfl_init( &pState->inflator );
5043
5044 /* Allocate write buffer */
5045 if (NULL == (pState->pWrite_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, TINFL_LZ_DICT_SIZE)))
5046 {
5048 if (pState->pRead_buf)
5049 pZip->m_pFree(pZip->m_pAlloc_opaque, pState->pRead_buf);
5050 pZip->m_pFree(pZip->m_pAlloc_opaque, pState);
5051 return NULL;
5052 }
5053 }
5054
5055 return pState;
5056}
@ MZ_ZIP_LOCAL_DIR_HEADER_SIG
Definition miniz.c:3236
@ MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG
Definition miniz.c:3314
@ MZ_ZIP_LDH_FILENAME_LEN_OFS
Definition miniz.c:3280
@ MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION
Definition miniz.c:3315
@ MZ_ZIP_LDH_EXTRA_LEN_OFS
Definition miniz.c:3281
@ MZ_ZIP_LOCAL_DIR_HEADER_SIZE
Definition miniz.c:3237
@ MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED
Definition miniz.c:3313
mz_bool mz_zip_reader_file_stat(mz_zip_archive *pZip, mz_uint file_index, mz_zip_archive_file_stat *pStat)
Definition miniz.c:7829
#define MZ_READ_LE16(p)
Definition miniz.h:604
#define MZ_CRC32_INIT
Definition miniz.h:244
mz_uint64 m_local_header_ofs
Definition miniz.h:1022
mz_alloc_func m_pAlloc
Definition miniz.h:1140
tinfl_decompressor inflator
Definition miniz.h:1168

References mz_zip_reader_extract_iter_state::comp_remaining, mz_zip_reader_extract_iter_state::cur_file_ofs, mz_zip_reader_extract_iter_state::file_crc32, mz_zip_reader_extract_iter_state::file_stat, mz_zip_reader_extract_iter_state::flags, mz_zip_reader_extract_iter_state::inflator, mz_zip_archive::m_archive_size, mz_zip_archive_file_stat::m_bit_flag, mz_zip_archive_file_stat::m_comp_size, mz_zip_archive_file_stat::m_local_header_ofs, mz_zip_archive_file_stat::m_method, mz_zip_archive::m_pAlloc, mz_zip_archive::m_pAlloc_opaque, mz_zip_archive::m_pFree, mz_zip_archive::m_pIO_opaque, mz_zip_internal_state_tag::m_pMem, mz_zip_archive::m_pRead, mz_zip_archive::m_pState, MZ_CRC32_INIT, MZ_DEFLATED, MZ_MIN, MZ_READ_LE16, MZ_READ_LE32, MZ_ZIP_ALLOC_FAILED, MZ_ZIP_FILE_READ_FAILED, MZ_ZIP_FLAG_COMPRESSED_DATA, MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG, MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED, MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED, MZ_ZIP_LDH_EXTRA_LEN_OFS, MZ_ZIP_LDH_FILENAME_LEN_OFS, MZ_ZIP_LOCAL_DIR_HEADER_SIG, MZ_ZIP_LOCAL_DIR_HEADER_SIZE, MZ_ZIP_MAX_IO_BUF_SIZE, mz_zip_reader_file_stat(), mz_zip_set_error(), MZ_ZIP_UNSUPPORTED_ENCRYPTION, MZ_ZIP_UNSUPPORTED_METHOD, mz_zip_reader_extract_iter_state::out_blk_remain, mz_zip_reader_extract_iter_state::out_buf_ofs, mz_zip_reader_extract_iter_state::pRead_buf, mz_zip_reader_extract_iter_state::pWrite_buf, mz_zip_reader_extract_iter_state::pZip, mz_zip_reader_extract_iter_state::read_buf_avail, mz_zip_reader_extract_iter_state::read_buf_ofs, mz_zip_reader_extract_iter_state::read_buf_size, mz_zip_reader_extract_iter_state::status, tinfl_init, TINFL_LZ_DICT_SIZE, and TINFL_STATUS_DONE.

Referenced by mz_zip_reader_extract_file_iter_new().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_zip_reader_extract_iter_read()

MINIZ_EXPORT size_t mz_zip_reader_extract_iter_read ( mz_zip_reader_extract_iter_state * pState,
void * pvBuf,
size_t buf_size )

Definition at line 5070 of file miniz.c.

5071{
5072 size_t copied_to_caller = 0;
5073
5074 /* Argument sanity check */
5075 if ((!pState) || (!pState->pZip) || (!pState->pZip->m_pState) || (!pvBuf))
5076 return 0;
5077
5078 if ((pState->flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!pState->file_stat.m_method))
5079 {
5080 /* The file is stored or the caller has requested the compressed data, calc amount to return. */
5081 copied_to_caller = (size_t)MZ_MIN( buf_size, pState->comp_remaining );
5082
5083 /* Zip is in memory....or requires reading from a file? */
5084 if (pState->pZip->m_pState->m_pMem)
5085 {
5086 /* Copy data to caller's buffer */
5087 memcpy( pvBuf, pState->pRead_buf, copied_to_caller );
5088 pState->pRead_buf = ((mz_uint8*)pState->pRead_buf) + copied_to_caller;
5089 }
5090 else
5091 {
5092 /* Read directly into caller's buffer */
5093 if (pState->pZip->m_pRead(pState->pZip->m_pIO_opaque, pState->cur_file_ofs, pvBuf, copied_to_caller) != copied_to_caller)
5094 {
5095 /* Failed to read all that was asked for, flag failure and alert user */
5097 pState->status = TINFL_STATUS_FAILED;
5098 copied_to_caller = 0;
5099 }
5100 }
5101
5102#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
5103 /* Compute CRC if not returning compressed data only */
5104 if (!(pState->flags & MZ_ZIP_FLAG_COMPRESSED_DATA))
5105 pState->file_crc32 = (mz_uint32)mz_crc32(pState->file_crc32, (const mz_uint8 *)pvBuf, copied_to_caller);
5106#endif
5107
5108 /* Advance offsets, dec counters */
5109 pState->cur_file_ofs += copied_to_caller;
5110 pState->out_buf_ofs += copied_to_caller;
5111 pState->comp_remaining -= copied_to_caller;
5112 }
5113 else
5114 {
5115 do
5116 {
5117 /* Calc ptr to write buffer - given current output pos and block size */
5118 mz_uint8 *pWrite_buf_cur = (mz_uint8 *)pState->pWrite_buf + (pState->out_buf_ofs & (TINFL_LZ_DICT_SIZE - 1));
5119
5120 /* Calc max output size - given current output pos and block size */
5121 size_t in_buf_size, out_buf_size = TINFL_LZ_DICT_SIZE - (pState->out_buf_ofs & (TINFL_LZ_DICT_SIZE - 1));
5122
5123 if (!pState->out_blk_remain)
5124 {
5125 /* Read more data from file if none available (and reading from file) */
5126 if ((!pState->read_buf_avail) && (!pState->pZip->m_pState->m_pMem))
5127 {
5128 /* Calc read size */
5129 pState->read_buf_avail = MZ_MIN(pState->read_buf_size, pState->comp_remaining);
5130 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)
5131 {
5133 pState->status = TINFL_STATUS_FAILED;
5134 break;
5135 }
5136
5137 /* Advance offsets, dec counters */
5138 pState->cur_file_ofs += pState->read_buf_avail;
5139 pState->comp_remaining -= pState->read_buf_avail;
5140 pState->read_buf_ofs = 0;
5141 }
5142
5143 /* Perform decompression */
5144 in_buf_size = (size_t)pState->read_buf_avail;
5145 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);
5146 pState->read_buf_avail -= in_buf_size;
5147 pState->read_buf_ofs += in_buf_size;
5148
5149 /* Update current output block size remaining */
5150 pState->out_blk_remain = out_buf_size;
5151 }
5152
5153 if (pState->out_blk_remain)
5154 {
5155 /* Calc amount to return. */
5156 size_t to_copy = MZ_MIN( (buf_size - copied_to_caller), pState->out_blk_remain );
5157
5158 /* Copy data to caller's buffer */
5159 memcpy( (mz_uint8*)pvBuf + copied_to_caller, pWrite_buf_cur, to_copy );
5160
5161#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
5162 /* Perform CRC */
5163 pState->file_crc32 = (mz_uint32)mz_crc32(pState->file_crc32, pWrite_buf_cur, to_copy);
5164#endif
5165
5166 /* Decrement data consumed from block */
5167 pState->out_blk_remain -= to_copy;
5168
5169 /* Inc output offset, while performing sanity check */
5170 if ((pState->out_buf_ofs += to_copy) > pState->file_stat.m_uncomp_size)
5171 {
5173 pState->status = TINFL_STATUS_FAILED;
5174 break;
5175 }
5176
5177 /* Increment counter of data copied to caller */
5178 copied_to_caller += to_copy;
5179 }
5180 } while ( (copied_to_caller < buf_size) && ((pState->status == TINFL_STATUS_NEEDS_MORE_INPUT) || (pState->status == TINFL_STATUS_HAS_MORE_OUTPUT)) );
5181 }
5182
5183 /* Return how many bytes were copied into user buffer */
5184 return copied_to_caller;
5185}
mz_ulong mz_crc32(mz_ulong crc, const mz_uint8 *ptr, size_t buf_len)
Definition miniz.c:96

References mz_zip_reader_extract_iter_state::comp_remaining, mz_zip_reader_extract_iter_state::cur_file_ofs, mz_zip_reader_extract_iter_state::file_crc32, mz_zip_reader_extract_iter_state::file_stat, mz_zip_reader_extract_iter_state::flags, mz_zip_reader_extract_iter_state::inflator, mz_zip_archive_file_stat::m_method, mz_zip_archive::m_pIO_opaque, mz_zip_internal_state_tag::m_pMem, mz_zip_archive::m_pRead, mz_zip_archive::m_pState, mz_zip_archive_file_stat::m_uncomp_size, mz_crc32(), MZ_MIN, MZ_ZIP_DECOMPRESSION_FAILED, MZ_ZIP_FILE_READ_FAILED, MZ_ZIP_FLAG_COMPRESSED_DATA, mz_zip_set_error(), mz_zip_reader_extract_iter_state::out_blk_remain, mz_zip_reader_extract_iter_state::out_buf_ofs, mz_zip_reader_extract_iter_state::pRead_buf, mz_zip_reader_extract_iter_state::pWrite_buf, mz_zip_reader_extract_iter_state::pZip, mz_zip_reader_extract_iter_state::read_buf_avail, mz_zip_reader_extract_iter_state::read_buf_ofs, mz_zip_reader_extract_iter_state::read_buf_size, mz_zip_reader_extract_iter_state::status, tinfl_decompress(), TINFL_FLAG_HAS_MORE_INPUT, TINFL_LZ_DICT_SIZE, TINFL_STATUS_FAILED, TINFL_STATUS_HAS_MORE_OUTPUT, and TINFL_STATUS_NEEDS_MORE_INPUT.

+ Here is the call graph for this function:

◆ mz_zip_reader_extract_to_callback()

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 )

Definition at line 4721 of file miniz.c.

4722{
4723 int status = TINFL_STATUS_DONE;
4724#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
4725 mz_uint file_crc32 = MZ_CRC32_INIT;
4726#endif
4727 mz_uint64 read_buf_size, read_buf_ofs = 0, read_buf_avail, comp_remaining, out_buf_ofs = 0, cur_file_ofs;
4728 mz_zip_archive_file_stat file_stat;
4729 void *pRead_buf = NULL;
4730 void *pWrite_buf = NULL;
4731 mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];
4732 mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32;
4733
4734 if ((!pZip) || (!pZip->m_pState) || (!pCallback) || (!pZip->m_pRead))
4736
4737 if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat))
4738 return MZ_FALSE;
4739
4740 /* A directory or zero length file */
4741 if ((file_stat.m_is_directory) || (!file_stat.m_comp_size))
4742 return MZ_TRUE;
4743
4744 /* Encryption and patch files are not supported. */
4747
4748 /* This function only supports decompressing stored and deflate. */
4749 if ((!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (file_stat.m_method != 0) && (file_stat.m_method != MZ_DEFLATED))
4751
4752 /* 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) */
4753 cur_file_ofs = file_stat.m_local_header_ofs;
4754 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)
4756
4757 if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG)
4759
4761 if ((cur_file_ofs + file_stat.m_comp_size) > pZip->m_archive_size)
4763
4764 /* Decompress the file either directly from memory or from a file input buffer. */
4765 if (pZip->m_pState->m_pMem)
4766 {
4767 pRead_buf = (mz_uint8 *)pZip->m_pState->m_pMem + cur_file_ofs;
4768 read_buf_size = read_buf_avail = file_stat.m_comp_size;
4769 comp_remaining = 0;
4770 }
4771 else
4772 {
4773 read_buf_size = MZ_MIN(file_stat.m_comp_size, (mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE);
4774 if (NULL == (pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)read_buf_size)))
4776
4777 read_buf_avail = 0;
4778 comp_remaining = file_stat.m_comp_size;
4779 }
4780
4781 if ((flags & MZ_ZIP_FLAG_COMPRESSED_DATA) || (!file_stat.m_method))
4782 {
4783 /* The file is stored or the caller has requested the compressed data. */
4784 if (pZip->m_pState->m_pMem)
4785 {
4786 if (((sizeof(size_t) == sizeof(mz_uint32))) && (file_stat.m_comp_size > MZ_UINT32_MAX))
4788
4789 if (pCallback(pOpaque, out_buf_ofs, pRead_buf, (size_t)file_stat.m_comp_size) != file_stat.m_comp_size)
4790 {
4792 status = TINFL_STATUS_FAILED;
4793 }
4794 else if (!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA))
4795 {
4796#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
4797 file_crc32 = (mz_uint32)mz_crc32(file_crc32, (const mz_uint8 *)pRead_buf, (size_t)file_stat.m_comp_size);
4798#endif
4799 }
4800
4801 cur_file_ofs += file_stat.m_comp_size;
4802 out_buf_ofs += file_stat.m_comp_size;
4803 comp_remaining = 0;
4804 }
4805 else
4806 {
4807 while (comp_remaining)
4808 {
4809 read_buf_avail = MZ_MIN(read_buf_size, comp_remaining);
4810 if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pRead_buf, (size_t)read_buf_avail) != read_buf_avail)
4811 {
4813 status = TINFL_STATUS_FAILED;
4814 break;
4815 }
4816
4817#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
4818 if (!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA))
4819 {
4820 file_crc32 = (mz_uint32)mz_crc32(file_crc32, (const mz_uint8 *)pRead_buf, (size_t)read_buf_avail);
4821 }
4822#endif
4823
4824 if (pCallback(pOpaque, out_buf_ofs, pRead_buf, (size_t)read_buf_avail) != read_buf_avail)
4825 {
4827 status = TINFL_STATUS_FAILED;
4828 break;
4829 }
4830
4831 cur_file_ofs += read_buf_avail;
4832 out_buf_ofs += read_buf_avail;
4833 comp_remaining -= read_buf_avail;
4834 }
4835 }
4836 }
4837 else
4838 {
4839 tinfl_decompressor inflator;
4840 tinfl_init(&inflator);
4841
4842 if (NULL == (pWrite_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, TINFL_LZ_DICT_SIZE)))
4843 {
4845 status = TINFL_STATUS_FAILED;
4846 }
4847 else
4848 {
4849 do
4850 {
4851 mz_uint8 *pWrite_buf_cur = (mz_uint8 *)pWrite_buf + (out_buf_ofs & (TINFL_LZ_DICT_SIZE - 1));
4852 size_t in_buf_size, out_buf_size = TINFL_LZ_DICT_SIZE - (out_buf_ofs & (TINFL_LZ_DICT_SIZE - 1));
4853 if ((!read_buf_avail) && (!pZip->m_pState->m_pMem))
4854 {
4855 read_buf_avail = MZ_MIN(read_buf_size, comp_remaining);
4856 if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pRead_buf, (size_t)read_buf_avail) != read_buf_avail)
4857 {
4859 status = TINFL_STATUS_FAILED;
4860 break;
4861 }
4862 cur_file_ofs += read_buf_avail;
4863 comp_remaining -= read_buf_avail;
4864 read_buf_ofs = 0;
4865 }
4866
4867 in_buf_size = (size_t)read_buf_avail;
4868 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);
4869 read_buf_avail -= in_buf_size;
4870 read_buf_ofs += in_buf_size;
4871
4872 if (out_buf_size)
4873 {
4874 if (pCallback(pOpaque, out_buf_ofs, pWrite_buf_cur, out_buf_size) != out_buf_size)
4875 {
4877 status = TINFL_STATUS_FAILED;
4878 break;
4879 }
4880
4881#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
4882 file_crc32 = (mz_uint32)mz_crc32(file_crc32, pWrite_buf_cur, out_buf_size);
4883#endif
4884 if ((out_buf_ofs += out_buf_size) > file_stat.m_uncomp_size)
4885 {
4887 status = TINFL_STATUS_FAILED;
4888 break;
4889 }
4890 }
4891 } while ((status == TINFL_STATUS_NEEDS_MORE_INPUT) || (status == TINFL_STATUS_HAS_MORE_OUTPUT));
4892 }
4893 }
4894
4895 if ((status == TINFL_STATUS_DONE) && (!(flags & MZ_ZIP_FLAG_COMPRESSED_DATA)))
4896 {
4897 /* Make sure the entire file was decompressed, and check its CRC. */
4898 if (out_buf_ofs != file_stat.m_uncomp_size)
4899 {
4901 status = TINFL_STATUS_FAILED;
4902 }
4903#ifndef MINIZ_DISABLE_ZIP_READER_CRC32_CHECKS
4904 else if (file_crc32 != file_stat.m_crc32)
4905 {
4907 status = TINFL_STATUS_FAILED;
4908 }
4909#endif
4910 }
4911
4912 if (!pZip->m_pState->m_pMem)
4913 pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
4914
4915 if (pWrite_buf)
4916 pZip->m_pFree(pZip->m_pAlloc_opaque, pWrite_buf);
4917
4918 return status == TINFL_STATUS_DONE;
4919}
#define MZ_UINT32_MAX
Definition miniz.h:627

References mz_zip_archive::m_archive_size, mz_zip_archive_file_stat::m_bit_flag, mz_zip_archive_file_stat::m_comp_size, mz_zip_archive_file_stat::m_crc32, mz_zip_archive_file_stat::m_is_directory, mz_zip_archive_file_stat::m_local_header_ofs, mz_zip_archive_file_stat::m_method, mz_zip_archive::m_pAlloc, mz_zip_archive::m_pAlloc_opaque, mz_zip_archive::m_pFree, mz_zip_archive::m_pIO_opaque, mz_zip_internal_state_tag::m_pMem, mz_zip_archive::m_pRead, mz_zip_archive::m_pState, mz_zip_archive_file_stat::m_uncomp_size, mz_crc32(), MZ_CRC32_INIT, MZ_DEFLATED, MZ_FALSE, MZ_MIN, MZ_READ_LE16, MZ_READ_LE32, MZ_TRUE, MZ_UINT32_MAX, MZ_ZIP_ALLOC_FAILED, MZ_ZIP_DECOMPRESSION_FAILED, MZ_ZIP_FILE_READ_FAILED, MZ_ZIP_FLAG_COMPRESSED_DATA, MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG, MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED, MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION, MZ_ZIP_INTERNAL_ERROR, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED, MZ_ZIP_INVALID_PARAMETER, MZ_ZIP_LDH_EXTRA_LEN_OFS, MZ_ZIP_LDH_FILENAME_LEN_OFS, MZ_ZIP_LOCAL_DIR_HEADER_SIG, MZ_ZIP_LOCAL_DIR_HEADER_SIZE, MZ_ZIP_MAX_IO_BUF_SIZE, mz_zip_reader_file_stat(), mz_zip_set_error(), MZ_ZIP_UNEXPECTED_DECOMPRESSED_SIZE, MZ_ZIP_UNSUPPORTED_ENCRYPTION, MZ_ZIP_UNSUPPORTED_METHOD, MZ_ZIP_WRITE_CALLBACK_FAILED, tinfl_decompress(), TINFL_FLAG_HAS_MORE_INPUT, tinfl_init, TINFL_LZ_DICT_SIZE, TINFL_STATUS_DONE, TINFL_STATUS_FAILED, TINFL_STATUS_HAS_MORE_OUTPUT, and TINFL_STATUS_NEEDS_MORE_INPUT.

Referenced by mz_zip_reader_extract_file_to_callback(), mz_zip_reader_extract_to_cfile(), mz_zip_reader_extract_to_file(), and mz_zip_validate_file().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_zip_reader_extract_to_cfile()

MINIZ_EXPORT mz_bool mz_zip_reader_extract_to_cfile ( mz_zip_archive * pZip,
mz_uint file_index,
MZ_FILE * File,
mz_uint flags )

Definition at line 5279 of file miniz.c.

5280{
5281 mz_zip_archive_file_stat file_stat;
5282
5283 if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat))
5284 return MZ_FALSE;
5285
5286 if ((file_stat.m_is_directory) || (!file_stat.m_is_supported))
5288
5289 return mz_zip_reader_extract_to_callback(pZip, file_index, mz_zip_file_write_callback, pFile, flags);
5290}
static size_t mz_zip_file_write_callback(void *pOpaque, mz_uint64 ofs, const void *pBuf, size_t n)
Definition miniz.c:5229

References mz_zip_archive_file_stat::m_is_directory, mz_zip_archive_file_stat::m_is_supported, MZ_FALSE, mz_zip_file_write_callback(), mz_zip_reader_extract_to_callback(), mz_zip_reader_file_stat(), mz_zip_set_error(), and MZ_ZIP_UNSUPPORTED_FEATURE.

Referenced by mz_zip_reader_extract_file_to_cfile().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_zip_reader_extract_to_file()

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 )

Definition at line 5236 of file miniz.c.

5237{
5238 mz_bool status;
5239 mz_zip_archive_file_stat file_stat;
5240 MZ_FILE *pFile;
5241
5242 if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat))
5243 return MZ_FALSE;
5244
5245 if ((file_stat.m_is_directory) || (!file_stat.m_is_supported))
5247
5248 pFile = MZ_FOPEN(pDst_filename, "wb");
5249 if (!pFile)
5251
5252 status = mz_zip_reader_extract_to_callback(pZip, file_index, mz_zip_file_write_callback, pFile, flags);
5253
5254 if (MZ_FCLOSE(pFile) == EOF)
5255 {
5256 if (status)
5258
5259 status = MZ_FALSE;
5260 }
5261
5262#if !defined(MINIZ_NO_TIME) && !defined(MINIZ_NO_STDIO)
5263 if (status)
5264 mz_zip_set_file_times(pDst_filename, file_stat.m_time, file_stat.m_time);
5265#endif
5266
5267 return status;
5268}
static mz_bool mz_zip_set_file_times(const char *pFilename, MZ_TIME_T access_time, MZ_TIME_T modified_time)
Definition miniz.c:3485
#define MZ_FOPEN(f, m)
Definition miniz.c:3209
#define MZ_FCLOSE
Definition miniz.c:3210
#define MZ_FILE
Definition miniz.h:568

References mz_zip_archive_file_stat::m_is_directory, mz_zip_archive_file_stat::m_is_supported, mz_zip_archive_file_stat::m_time, MZ_FALSE, MZ_FCLOSE, MZ_FILE, MZ_FOPEN, MZ_ZIP_FILE_CLOSE_FAILED, MZ_ZIP_FILE_OPEN_FAILED, mz_zip_file_write_callback(), mz_zip_reader_extract_to_callback(), mz_zip_reader_file_stat(), mz_zip_set_error(), mz_zip_set_file_times(), and MZ_ZIP_UNSUPPORTED_FEATURE.

Referenced by mz_zip_reader_extract_file_to_file().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_zip_reader_extract_to_heap()

MINIZ_EXPORT void * mz_zip_reader_extract_to_heap ( mz_zip_archive * pZip,
mz_uint file_index,
size_t * pSize,
mz_uint flags )

Definition at line 4673 of file miniz.c.

4674{
4675 mz_zip_archive_file_stat file_stat;
4676 mz_uint64 alloc_size;
4677 void *pBuf;
4678
4679 if (pSize)
4680 *pSize = 0;
4681
4682 if (!mz_zip_reader_file_stat(pZip, file_index, &file_stat))
4683 return NULL;
4684
4685 alloc_size = (flags & MZ_ZIP_FLAG_COMPRESSED_DATA) ? file_stat.m_comp_size : file_stat.m_uncomp_size;
4686 if (((sizeof(size_t) == sizeof(mz_uint32))) && (alloc_size > 0x7FFFFFFF))
4687 {
4689 return NULL;
4690 }
4691
4692 if (NULL == (pBuf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, (size_t)alloc_size)))
4693 {
4695 return NULL;
4696 }
4697
4698 if (!mz_zip_reader_extract_to_mem_no_alloc1(pZip, file_index, pBuf, (size_t)alloc_size, flags, NULL, 0, &file_stat))
4699 {
4700 pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
4701 return NULL;
4702 }
4703
4704 if (pSize)
4705 *pSize = (size_t)alloc_size;
4706 return pBuf;
4707}

References mz_zip_archive_file_stat::m_comp_size, mz_zip_archive::m_pAlloc, mz_zip_archive::m_pAlloc_opaque, mz_zip_archive::m_pFree, mz_zip_archive_file_stat::m_uncomp_size, MZ_ZIP_ALLOC_FAILED, MZ_ZIP_FLAG_COMPRESSED_DATA, MZ_ZIP_INTERNAL_ERROR, mz_zip_reader_extract_to_mem_no_alloc1(), mz_zip_reader_file_stat(), and mz_zip_set_error().

Referenced by mz_zip_extract_archive_file_to_heap_v2(), and mz_zip_reader_extract_file_to_heap().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_zip_reader_extract_to_mem()

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 )

Definition at line 4663 of file miniz.c.

4664{
4665 return mz_zip_reader_extract_to_mem_no_alloc1(pZip, file_index, pBuf, buf_size, flags, NULL, 0, NULL);
4666}

References mz_zip_reader_extract_to_mem_no_alloc1().

+ Here is the call graph for this function:

◆ mz_zip_reader_extract_to_mem_no_alloc()

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 )

Definition at line 4650 of file miniz.c.

4651{
4652 return mz_zip_reader_extract_to_mem_no_alloc1(pZip, file_index, pBuf, buf_size, flags, pUser_read_buf, user_read_buf_size, NULL);
4653}

References mz_zip_reader_extract_to_mem_no_alloc1().

+ Here is the call graph for this function:

◆ mz_zip_reader_file_stat()

MINIZ_EXPORT mz_bool mz_zip_reader_file_stat ( mz_zip_archive * pZip,
mz_uint file_index,
mz_zip_archive_file_stat * pStat )

Definition at line 7829 of file miniz.c.

7830{
7831 return mz_zip_file_stat_internal(pZip, file_index, mz_zip_get_cdh(pZip, file_index), pStat, NULL);
7832}
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)
Definition miniz.c:4241
static MZ_FORCEINLINE const mz_uint8 * mz_zip_get_cdh(mz_zip_archive *pZip, mz_uint file_index)
Definition miniz.c:4152

References mz_zip_file_stat_internal(), and mz_zip_get_cdh().

Referenced by mz_zip_reader_extract_iter_new(), mz_zip_reader_extract_to_callback(), mz_zip_reader_extract_to_cfile(), mz_zip_reader_extract_to_file(), mz_zip_reader_extract_to_heap(), mz_zip_reader_extract_to_mem_no_alloc1(), and mz_zip_validate_archive().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_zip_reader_get_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 )

Definition at line 7808 of file miniz.c.

7809{
7810 mz_uint n;
7811 const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index);
7812 if (!p)
7813 {
7814 if (filename_buf_size)
7815 pFilename[0] = '\0';
7817 return 0;
7818 }
7820 if (filename_buf_size)
7821 {
7822 n = MZ_MIN(n, filename_buf_size - 1);
7823 memcpy(pFilename, p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, n);
7824 pFilename[n] = '\0';
7825 }
7826 return n + 1;
7827}
@ MZ_ZIP_CDH_FILENAME_LEN_OFS
Definition miniz.c:3262
@ MZ_ZIP_CENTRAL_DIR_HEADER_SIZE
Definition miniz.c:3238

References MZ_MIN, MZ_READ_LE16, MZ_ZIP_CDH_FILENAME_LEN_OFS, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, mz_zip_get_cdh(), MZ_ZIP_INVALID_PARAMETER, and mz_zip_set_error().

+ Here is the call graph for this function:

◆ mz_zip_reader_get_num_files()

MINIZ_EXPORT mz_uint mz_zip_reader_get_num_files ( mz_zip_archive * pZip)

Definition at line 7774 of file miniz.c.

7775{
7776 return pZip ? pZip->m_total_files : 0;
7777}
mz_uint32 m_total_files
Definition miniz.h:1133

References mz_zip_archive::m_total_files.

◆ mz_zip_reader_init()

MINIZ_EXPORT mz_bool mz_zip_reader_init ( mz_zip_archive * pZip,
mz_uint64 size,
mz_uint flags )

Definition at line 3975 of file miniz.c.

3976{
3977 if ((!pZip) || (!pZip->m_pRead))
3979
3980 if (!mz_zip_reader_init_internal(pZip, flags))
3981 return MZ_FALSE;
3982
3984 pZip->m_archive_size = size;
3985
3986 if (!mz_zip_reader_read_central_dir(pZip, flags))
3987 {
3989 return MZ_FALSE;
3990 }
3991
3992 return MZ_TRUE;
3993}
static mz_bool mz_zip_reader_init_internal(mz_zip_archive *pZip, mz_uint flags)
Definition miniz.c:3505
static mz_bool mz_zip_reader_read_central_dir(mz_zip_archive *pZip, mz_uint flags)
Definition miniz.c:3666

References mz_zip_archive::m_archive_size, mz_zip_archive::m_pRead, mz_zip_archive::m_zip_type, MZ_FALSE, MZ_TRUE, MZ_ZIP_INVALID_PARAMETER, mz_zip_reader_end_internal(), mz_zip_reader_init_internal(), mz_zip_reader_read_central_dir(), mz_zip_set_error(), and MZ_ZIP_TYPE_USER.

+ Here is the call graph for this function:

◆ mz_zip_reader_init_cfile()

MINIZ_EXPORT mz_bool mz_zip_reader_init_cfile ( mz_zip_archive * pZip,
MZ_FILE * pFile,
mz_uint64 archive_size,
mz_uint flags )

Definition at line 4110 of file miniz.c.

4111{
4112 mz_uint64 cur_file_ofs;
4113
4114 if ((!pZip) || (!pFile))
4116
4117 cur_file_ofs = MZ_FTELL64(pFile);
4118
4119 if (!archive_size)
4120 {
4121 if (MZ_FSEEK64(pFile, 0, SEEK_END))
4123
4124 archive_size = MZ_FTELL64(pFile) - cur_file_ofs;
4125
4126 if (archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)
4128 }
4129
4130 if (!mz_zip_reader_init_internal(pZip, flags))
4131 return MZ_FALSE;
4132
4135
4136 pZip->m_pIO_opaque = pZip;
4137 pZip->m_pState->m_pFile = pFile;
4138 pZip->m_archive_size = archive_size;
4139 pZip->m_pState->m_file_archive_start_ofs = cur_file_ofs;
4140
4141 if (!mz_zip_reader_read_central_dir(pZip, flags))
4142 {
4144 return MZ_FALSE;
4145 }
4146
4147 return MZ_TRUE;
4148}
@ MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE
Definition miniz.c:3239
static size_t mz_zip_file_read_func(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n)
Definition miniz.c:4038
#define MZ_FSEEK64
Definition miniz.c:3218
#define MZ_FTELL64
Definition miniz.c:3217

References mz_zip_archive::m_archive_size, mz_zip_internal_state_tag::m_file_archive_start_ofs, mz_zip_internal_state_tag::m_pFile, mz_zip_archive::m_pIO_opaque, mz_zip_archive::m_pRead, mz_zip_archive::m_pState, mz_zip_archive::m_zip_type, MZ_FALSE, MZ_FSEEK64, MZ_FTELL64, MZ_TRUE, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE, MZ_ZIP_FILE_OPEN_FAILED, mz_zip_file_read_func(), MZ_ZIP_FILE_SEEK_FAILED, MZ_ZIP_NOT_AN_ARCHIVE, mz_zip_reader_end_internal(), mz_zip_reader_init_internal(), mz_zip_reader_read_central_dir(), mz_zip_set_error(), and MZ_ZIP_TYPE_CFILE.

+ Here is the call graph for this function:

◆ mz_zip_reader_init_file()

MINIZ_EXPORT mz_bool mz_zip_reader_init_file ( mz_zip_archive * pZip,
const char * pFilename,
mz_uint32 flags )

Definition at line 4051 of file miniz.c.

4052{
4053 return mz_zip_reader_init_file_v2(pZip, pFilename, flags, 0, 0);
4054}

References mz_zip_reader_init_file_v2().

+ Here is the call graph for this function:

◆ mz_zip_reader_init_file_v2()

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 )

Definition at line 4056 of file miniz.c.

4057{
4058 mz_uint64 file_size;
4059 MZ_FILE *pFile;
4060
4061 if ((!pZip) || (!pFilename) || ((archive_size) && (archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)))
4063
4064 pFile = MZ_FOPEN(pFilename, "rb");
4065 if (!pFile)
4067
4068 file_size = archive_size;
4069 if (!file_size)
4070 {
4071 if (MZ_FSEEK64(pFile, 0, SEEK_END))
4072 {
4073 MZ_FCLOSE(pFile);
4075 }
4076
4077 file_size = MZ_FTELL64(pFile);
4078 }
4079
4080 /* TODO: Better sanity check archive_size and the # of actual remaining bytes */
4081
4083 {
4084 MZ_FCLOSE(pFile);
4086 }
4087
4088 if (!mz_zip_reader_init_internal(pZip, flags))
4089 {
4090 MZ_FCLOSE(pFile);
4091 return MZ_FALSE;
4092 }
4093
4096 pZip->m_pIO_opaque = pZip;
4097 pZip->m_pState->m_pFile = pFile;
4098 pZip->m_archive_size = file_size;
4099 pZip->m_pState->m_file_archive_start_ofs = file_start_ofs;
4100
4101 if (!mz_zip_reader_read_central_dir(pZip, flags))
4102 {
4104 return MZ_FALSE;
4105 }
4106
4107 return MZ_TRUE;
4108}

References mz_zip_archive::m_archive_size, mz_zip_internal_state_tag::m_file_archive_start_ofs, mz_zip_internal_state_tag::m_pFile, mz_zip_archive::m_pIO_opaque, mz_zip_archive::m_pRead, mz_zip_archive::m_pState, mz_zip_archive::m_zip_type, MZ_FALSE, MZ_FCLOSE, MZ_FILE, MZ_FOPEN, MZ_FSEEK64, MZ_FTELL64, MZ_TRUE, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE, MZ_ZIP_FILE_OPEN_FAILED, mz_zip_file_read_func(), MZ_ZIP_FILE_SEEK_FAILED, MZ_ZIP_INVALID_PARAMETER, MZ_ZIP_NOT_AN_ARCHIVE, mz_zip_reader_end_internal(), mz_zip_reader_init_internal(), mz_zip_reader_read_central_dir(), mz_zip_set_error(), and MZ_ZIP_TYPE_FILE.

Referenced by mz_zip_add_mem_to_archive_file_in_place_v2(), mz_zip_extract_archive_file_to_heap_v2(), mz_zip_reader_init_file(), and mz_zip_validate_file_archive().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_zip_reader_init_mem()

MINIZ_EXPORT mz_bool mz_zip_reader_init_mem ( mz_zip_archive * pZip,
const void * pMem,
size_t size,
mz_uint flags )

Definition at line 4003 of file miniz.c.

4004{
4005 if (!pMem)
4007
4010
4011 if (!mz_zip_reader_init_internal(pZip, flags))
4012 return MZ_FALSE;
4013
4015 pZip->m_archive_size = size;
4017 pZip->m_pIO_opaque = pZip;
4018 pZip->m_pNeeds_keepalive = NULL;
4019
4020#ifdef __cplusplus
4021 pZip->m_pState->m_pMem = const_cast<void *>(pMem);
4022#else
4023 pZip->m_pState->m_pMem = (void *)pMem;
4024#endif
4025
4026 pZip->m_pState->m_mem_size = size;
4027
4028 if (!mz_zip_reader_read_central_dir(pZip, flags))
4029 {
4031 return MZ_FALSE;
4032 }
4033
4034 return MZ_TRUE;
4035}
static size_t mz_zip_mem_read_func(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n)
Definition miniz.c:3995
mz_file_needs_keepalive m_pNeeds_keepalive
Definition miniz.h:1147

References mz_zip_archive::m_archive_size, mz_zip_internal_state_tag::m_mem_size, mz_zip_archive::m_pIO_opaque, mz_zip_internal_state_tag::m_pMem, mz_zip_archive::m_pNeeds_keepalive, mz_zip_archive::m_pRead, mz_zip_archive::m_pState, mz_zip_archive::m_zip_type, MZ_FALSE, MZ_TRUE, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE, MZ_ZIP_INVALID_PARAMETER, mz_zip_mem_read_func(), MZ_ZIP_NOT_AN_ARCHIVE, mz_zip_reader_end_internal(), mz_zip_reader_init_internal(), mz_zip_reader_read_central_dir(), mz_zip_set_error(), and MZ_ZIP_TYPE_MEMORY.

Referenced by mz_zip_validate_mem_archive().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_zip_reader_is_file_a_directory()

MINIZ_EXPORT mz_bool mz_zip_reader_is_file_a_directory ( mz_zip_archive * pZip,
mz_uint file_index )

Definition at line 4209 of file miniz.c.

4210{
4211 mz_uint filename_len, attribute_mapping_id, external_attr;
4212 const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index);
4213 if (!p)
4214 {
4216 return MZ_FALSE;
4217 }
4218
4219 filename_len = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS);
4220 if (filename_len)
4221 {
4222 if (*(p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_len - 1) == '/')
4223 return MZ_TRUE;
4224 }
4225
4226 /* Bugfix: This code was also checking if the internal attribute was non-zero, which wasn't correct. */
4227 /* 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. */
4228 /* FIXME: Remove this check? Is it necessary - we already check the filename. */
4229 attribute_mapping_id = MZ_READ_LE16(p + MZ_ZIP_CDH_VERSION_MADE_BY_OFS) >> 8;
4230 (void)attribute_mapping_id;
4231
4232 external_attr = MZ_READ_LE32(p + MZ_ZIP_CDH_EXTERNAL_ATTR_OFS);
4233 if ((external_attr & MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG) != 0)
4234 {
4235 return MZ_TRUE;
4236 }
4237
4238 return MZ_FALSE;
4239}
@ MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG
Definition miniz.c:3312
@ MZ_ZIP_CDH_EXTERNAL_ATTR_OFS
Definition miniz.c:3267
@ MZ_ZIP_CDH_VERSION_MADE_BY_OFS
Definition miniz.c:3253

References MZ_FALSE, MZ_READ_LE16, MZ_READ_LE32, MZ_TRUE, MZ_ZIP_CDH_EXTERNAL_ATTR_OFS, MZ_ZIP_CDH_FILENAME_LEN_OFS, MZ_ZIP_CDH_VERSION_MADE_BY_OFS, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG, mz_zip_get_cdh(), MZ_ZIP_INVALID_PARAMETER, and mz_zip_set_error().

Referenced by mz_zip_file_stat_internal().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_zip_reader_is_file_encrypted()

MINIZ_EXPORT mz_bool mz_zip_reader_is_file_encrypted ( mz_zip_archive * pZip,
mz_uint file_index )

Definition at line 4159 of file miniz.c.

4160{
4161 mz_uint m_bit_flag;
4162 const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index);
4163 if (!p)
4164 {
4166 return MZ_FALSE;
4167 }
4168
4169 m_bit_flag = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS);
4171}
@ MZ_ZIP_CDH_BIT_FLAG_OFS
Definition miniz.c:3255

References MZ_FALSE, MZ_READ_LE16, MZ_ZIP_CDH_BIT_FLAG_OFS, MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED, MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION, mz_zip_get_cdh(), MZ_ZIP_INVALID_PARAMETER, and mz_zip_set_error().

Referenced by mz_zip_file_stat_internal().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_zip_reader_is_file_supported()

MINIZ_EXPORT mz_bool mz_zip_reader_is_file_supported ( mz_zip_archive * pZip,
mz_uint file_index )

Definition at line 4173 of file miniz.c.

4174{
4175 mz_uint bit_flag;
4176 mz_uint method;
4177
4178 const mz_uint8 *p = mz_zip_get_cdh(pZip, file_index);
4179 if (!p)
4180 {
4182 return MZ_FALSE;
4183 }
4184
4185 method = MZ_READ_LE16(p + MZ_ZIP_CDH_METHOD_OFS);
4186 bit_flag = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS);
4187
4188 if ((method != 0) && (method != MZ_DEFLATED))
4189 {
4191 return MZ_FALSE;
4192 }
4193
4195 {
4197 return MZ_FALSE;
4198 }
4199
4201 {
4203 return MZ_FALSE;
4204 }
4205
4206 return MZ_TRUE;
4207}
@ MZ_ZIP_CDH_METHOD_OFS
Definition miniz.c:3256

References MZ_DEFLATED, MZ_FALSE, MZ_READ_LE16, MZ_TRUE, MZ_ZIP_CDH_BIT_FLAG_OFS, MZ_ZIP_CDH_METHOD_OFS, MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG, MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED, MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION, mz_zip_get_cdh(), MZ_ZIP_INVALID_PARAMETER, mz_zip_set_error(), MZ_ZIP_UNSUPPORTED_ENCRYPTION, MZ_ZIP_UNSUPPORTED_FEATURE, and MZ_ZIP_UNSUPPORTED_METHOD.

Referenced by mz_zip_file_stat_internal().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_zip_reader_locate_file()

MINIZ_EXPORT int mz_zip_reader_locate_file ( mz_zip_archive * pZip,
const char * pName,
const char * pComment,
mz_uint flags )

Definition at line 4429 of file miniz.c.

4430{
4431 mz_uint32 index;
4432 if (!mz_zip_reader_locate_file_v2(pZip, pName, pComment, flags, &index))
4433 return -1;
4434 else
4435 return (int)index;
4436}

References mz_zip_reader_locate_file_v2().

+ Here is the call graph for this function:

◆ mz_zip_reader_locate_file_v2()

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 )

Definition at line 4438 of file miniz.c.

4439{
4440 mz_uint file_index;
4441 size_t name_len, comment_len;
4442
4443 if (pIndex)
4444 *pIndex = 0;
4445
4446 if ((!pZip) || (!pZip->m_pState) || (!pName))
4448
4449 /* See if we can use a binary search */
4451 (pZip->m_zip_mode == MZ_ZIP_MODE_READING) &&
4453 {
4454 return mz_zip_locate_file_binary_search(pZip, pName, pIndex);
4455 }
4456
4457 /* Locate the entry by scanning the entire central directory */
4458 name_len = strlen(pName);
4459 if (name_len > MZ_UINT16_MAX)
4461
4462 comment_len = pComment ? strlen(pComment) : 0;
4463 if (comment_len > MZ_UINT16_MAX)
4465
4466 for (file_index = 0; file_index < pZip->m_total_files; file_index++)
4467 {
4469 mz_uint filename_len = MZ_READ_LE16(pHeader + MZ_ZIP_CDH_FILENAME_LEN_OFS);
4470 const char *pFilename = (const char *)pHeader + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE;
4471 if (filename_len < name_len)
4472 continue;
4473 if (comment_len)
4474 {
4475 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);
4476 const char *pFile_comment = pFilename + filename_len + file_extra_len;
4477 if ((file_comment_len != comment_len) || (!mz_zip_string_equal(pComment, pFile_comment, file_comment_len, flags)))
4478 continue;
4479 }
4480 if ((flags & MZ_ZIP_FLAG_IGNORE_PATH) && (filename_len))
4481 {
4482 int ofs = filename_len - 1;
4483 do
4484 {
4485 if ((pFilename[ofs] == '/') || (pFilename[ofs] == '\\') || (pFilename[ofs] == ':'))
4486 break;
4487 } while (--ofs >= 0);
4488 ofs++;
4489 pFilename += ofs;
4490 filename_len -= ofs;
4491 }
4492 if ((filename_len == name_len) && (mz_zip_string_equal(pName, pFilename, filename_len, flags)))
4493 {
4494 if (pIndex)
4495 *pIndex = file_index;
4496 return MZ_TRUE;
4497 }
4498 }
4499
4501}
@ MZ_ZIP_CDH_EXTRA_LEN_OFS
Definition miniz.c:3263
@ MZ_ZIP_CDH_COMMENT_LEN_OFS
Definition miniz.c:3264
static mz_bool mz_zip_locate_file_binary_search(mz_zip_archive *pZip, const char *pFilename, mz_uint32 *pIndex)
Definition miniz.c:4389
static MZ_FORCEINLINE mz_bool mz_zip_string_equal(const char *pA, const char *pB, mz_uint len, mz_uint flags)
Definition miniz.c:4361
#define MZ_ZIP_ARRAY_ELEMENT(array_ptr, element_type, index)
Definition miniz.c:3361
#define MZ_UINT16_MAX
Definition miniz.h:626
mz_zip_array m_sorted_central_dir_offsets
Definition miniz.c:3331
mz_zip_array m_central_dir_offsets
Definition miniz.c:3330

References mz_zip_internal_state_tag::m_central_dir, mz_zip_internal_state_tag::m_central_dir_offsets, mz_zip_internal_state_tag::m_init_flags, mz_zip_archive::m_pState, mz_zip_array::m_size, mz_zip_internal_state_tag::m_sorted_central_dir_offsets, mz_zip_archive::m_total_files, mz_zip_archive::m_zip_mode, MZ_READ_LE16, MZ_TRUE, MZ_UINT16_MAX, MZ_ZIP_ARRAY_ELEMENT, MZ_ZIP_CDH_COMMENT_LEN_OFS, MZ_ZIP_CDH_EXTRA_LEN_OFS, MZ_ZIP_CDH_FILENAME_LEN_OFS, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, MZ_ZIP_FILE_NOT_FOUND, MZ_ZIP_FLAG_CASE_SENSITIVE, MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY, MZ_ZIP_FLAG_IGNORE_PATH, MZ_ZIP_INVALID_PARAMETER, mz_zip_locate_file_binary_search(), MZ_ZIP_MODE_READING, mz_zip_set_error(), and mz_zip_string_equal().

Referenced by mz_zip_extract_archive_file_to_heap_v2(), mz_zip_reader_extract_file_iter_new(), mz_zip_reader_extract_file_to_callback(), mz_zip_reader_extract_file_to_cfile(), mz_zip_reader_extract_file_to_file(), mz_zip_reader_extract_file_to_heap(), mz_zip_reader_extract_file_to_mem_no_alloc(), mz_zip_reader_locate_file(), and mz_zip_validate_archive().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_zip_set_last_error()

MINIZ_EXPORT mz_zip_error mz_zip_set_last_error ( mz_zip_archive * pZip,
mz_zip_error err_num )

Definition at line 7641 of file miniz.c.

7642{
7643 mz_zip_error prev_err;
7644
7645 if (!pZip)
7647
7648 prev_err = pZip->m_last_error;
7649
7650 pZip->m_last_error = err_num;
7651 return prev_err;
7652}

References mz_zip_archive::m_last_error, and MZ_ZIP_INVALID_PARAMETER.

Referenced by mz_zip_clear_last_error().

+ Here is the caller graph for this function:

◆ mz_zip_validate_archive()

MINIZ_EXPORT mz_bool mz_zip_validate_archive ( mz_zip_archive * pZip,
mz_uint flags )

Definition at line 5525 of file miniz.c.

5526{
5527 mz_zip_internal_state *pState;
5528 mz_uint32 i;
5529
5530 if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (!pZip->m_pRead))
5532
5533 pState = pZip->m_pState;
5534
5535 /* Basic sanity checks */
5536 if (!pState->m_zip64)
5537 {
5538 if (pZip->m_total_files > MZ_UINT16_MAX)
5540
5541 if (pZip->m_archive_size > MZ_UINT32_MAX)
5543 }
5544 else
5545 {
5546 if (pState->m_central_dir.m_size >= MZ_UINT32_MAX)
5548 }
5549
5550 for (i = 0; i < pZip->m_total_files; i++)
5551 {
5553 {
5554 mz_uint32 found_index;
5556
5557 if (!mz_zip_reader_file_stat(pZip, i, &stat))
5558 return MZ_FALSE;
5559
5560 if (!mz_zip_reader_locate_file_v2(pZip, stat.m_filename, NULL, 0, &found_index))
5561 return MZ_FALSE;
5562
5563 /* 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) */
5564 if (found_index != i)
5566 }
5567
5568 if (!mz_zip_validate_file(pZip, i, flags))
5569 return MZ_FALSE;
5570 }
5571
5572 return MZ_TRUE;
5573}
mz_bool mz_zip_validate_file(mz_zip_archive *pZip, mz_uint file_index, mz_uint flags)
Definition miniz.c:5310
char m_filename[MZ_ZIP_MAX_ARCHIVE_FILENAME_SIZE]
Definition miniz.h:1038

References mz_zip_archive::m_archive_size, mz_zip_internal_state_tag::m_central_dir, mz_zip_archive_file_stat::m_filename, mz_zip_archive::m_pAlloc, mz_zip_archive::m_pFree, mz_zip_archive::m_pRead, mz_zip_archive::m_pState, mz_zip_array::m_size, mz_zip_archive::m_total_files, mz_zip_internal_state_tag::m_zip64, MZ_FALSE, MZ_TRUE, MZ_UINT16_MAX, MZ_UINT32_MAX, MZ_ZIP_ARCHIVE_TOO_LARGE, MZ_ZIP_FLAG_VALIDATE_LOCATE_FILE_FLAG, MZ_ZIP_INVALID_PARAMETER, mz_zip_reader_file_stat(), mz_zip_reader_locate_file_v2(), mz_zip_set_error(), mz_zip_validate_file(), and MZ_ZIP_VALIDATION_FAILED.

Referenced by mz_zip_validate_file_archive(), and mz_zip_validate_mem_archive().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_zip_validate_file()

MINIZ_EXPORT mz_bool mz_zip_validate_file ( mz_zip_archive * pZip,
mz_uint file_index,
mz_uint flags )

Definition at line 5310 of file miniz.c.

5311{
5312 mz_zip_archive_file_stat file_stat;
5313 mz_zip_internal_state *pState;
5314 const mz_uint8 *pCentral_dir_header;
5315 mz_bool found_zip64_ext_data_in_cdir = MZ_FALSE;
5316 mz_bool found_zip64_ext_data_in_ldir = MZ_FALSE;
5317 mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];
5318 mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32;
5319 mz_uint64 local_header_ofs = 0;
5320 mz_uint32 local_header_filename_len, local_header_extra_len, local_header_crc32;
5321 mz_uint64 local_header_comp_size, local_header_uncomp_size;
5322 mz_uint32 uncomp_crc32 = MZ_CRC32_INIT;
5323 mz_bool has_data_descriptor;
5324 mz_uint32 local_header_bit_flags;
5325
5326 mz_zip_array file_data_array;
5327 mz_zip_array_init(&file_data_array, 1);
5328
5329 if ((!pZip) || (!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (!pZip->m_pRead))
5331
5332 if (file_index > pZip->m_total_files)
5334
5335 pState = pZip->m_pState;
5336
5337 pCentral_dir_header = mz_zip_get_cdh(pZip, file_index);
5338
5339 if (!mz_zip_file_stat_internal(pZip, file_index, pCentral_dir_header, &file_stat, &found_zip64_ext_data_in_cdir))
5340 return MZ_FALSE;
5341
5342 /* A directory or zero length file */
5343 if ((file_stat.m_is_directory) || (!file_stat.m_uncomp_size))
5344 return MZ_TRUE;
5345
5346 /* Encryption and patch files are not supported. */
5347 if (file_stat.m_is_encrypted)
5349
5350 /* This function only supports stored and deflate. */
5351 if ((file_stat.m_method != 0) && (file_stat.m_method != MZ_DEFLATED))
5353
5354 if (!file_stat.m_is_supported)
5356
5357 /* Read and parse the local directory entry. */
5358 local_header_ofs = file_stat.m_local_header_ofs;
5359 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)
5361
5362 if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG)
5364
5365 local_header_filename_len = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS);
5366 local_header_extra_len = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS);
5367 local_header_comp_size = MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_COMPRESSED_SIZE_OFS);
5368 local_header_uncomp_size = MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS);
5369 local_header_crc32 = MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_CRC32_OFS);
5370 local_header_bit_flags = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_BIT_FLAG_OFS);
5371 has_data_descriptor = (local_header_bit_flags & 8) != 0;
5372
5373 if (local_header_filename_len != strlen(file_stat.m_filename))
5375
5376 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)
5378
5379 if (!mz_zip_array_resize(pZip, &file_data_array, MZ_MAX(local_header_filename_len, local_header_extra_len), MZ_FALSE))
5380 {
5382 goto handle_failure;
5383 }
5384
5385 if (local_header_filename_len)
5386 {
5387 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)
5388 {
5390 goto handle_failure;
5391 }
5392
5393 /* 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. */
5394 if (memcmp(file_stat.m_filename, file_data_array.m_p, local_header_filename_len) != 0)
5395 {
5397 goto handle_failure;
5398 }
5399 }
5400
5401 if ((local_header_extra_len) && ((local_header_comp_size == MZ_UINT32_MAX) || (local_header_uncomp_size == MZ_UINT32_MAX)))
5402 {
5403 mz_uint32 extra_size_remaining = local_header_extra_len;
5404 const mz_uint8 *pExtra_data = (const mz_uint8 *)file_data_array.m_p;
5405
5406 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)
5407 {
5409 goto handle_failure;
5410 }
5411
5412 do
5413 {
5414 mz_uint32 field_id, field_data_size, field_total_size;
5415
5416 if (extra_size_remaining < (sizeof(mz_uint16) * 2))
5417 {
5419 goto handle_failure;
5420 }
5421
5422 field_id = MZ_READ_LE16(pExtra_data);
5423 field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16));
5424 field_total_size = field_data_size + sizeof(mz_uint16) * 2;
5425
5426 if (field_total_size > extra_size_remaining)
5427 {
5429 goto handle_failure;
5430 }
5431
5433 {
5434 const mz_uint8 *pSrc_field_data = pExtra_data + sizeof(mz_uint32);
5435
5436 if (field_data_size < sizeof(mz_uint64) * 2)
5437 {
5439 goto handle_failure;
5440 }
5441
5442 local_header_uncomp_size = MZ_READ_LE64(pSrc_field_data);
5443 local_header_comp_size = MZ_READ_LE64(pSrc_field_data + sizeof(mz_uint64));
5444
5445 found_zip64_ext_data_in_ldir = MZ_TRUE;
5446 break;
5447 }
5448
5449 pExtra_data += field_total_size;
5450 extra_size_remaining -= field_total_size;
5451 } while (extra_size_remaining);
5452 }
5453
5454 /* TODO: parse local header extra data when local_header_comp_size is 0xFFFFFFFF! (big_descriptor.zip) */
5455 /* I've seen zips in the wild with the data descriptor bit set, but proper local header values and bogus data descriptors */
5456 if ((has_data_descriptor) && (!local_header_comp_size) && (!local_header_crc32))
5457 {
5458 mz_uint8 descriptor_buf[32];
5459 mz_bool has_id;
5460 const mz_uint8 *pSrc;
5461 mz_uint32 file_crc32;
5462 mz_uint64 comp_size = 0, uncomp_size = 0;
5463
5464 mz_uint32 num_descriptor_uint32s = ((pState->m_zip64) || (found_zip64_ext_data_in_ldir)) ? 6 : 4;
5465
5466 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))
5467 {
5469 goto handle_failure;
5470 }
5471
5472 has_id = (MZ_READ_LE32(descriptor_buf) == MZ_ZIP_DATA_DESCRIPTOR_ID);
5473 pSrc = has_id ? (descriptor_buf + sizeof(mz_uint32)) : descriptor_buf;
5474
5475 file_crc32 = MZ_READ_LE32(pSrc);
5476
5477 if ((pState->m_zip64) || (found_zip64_ext_data_in_ldir))
5478 {
5479 comp_size = MZ_READ_LE64(pSrc + sizeof(mz_uint32));
5480 uncomp_size = MZ_READ_LE64(pSrc + sizeof(mz_uint32) + sizeof(mz_uint64));
5481 }
5482 else
5483 {
5484 comp_size = MZ_READ_LE32(pSrc + sizeof(mz_uint32));
5485 uncomp_size = MZ_READ_LE32(pSrc + sizeof(mz_uint32) + sizeof(mz_uint32));
5486 }
5487
5488 if ((file_crc32 != file_stat.m_crc32) || (comp_size != file_stat.m_comp_size) || (uncomp_size != file_stat.m_uncomp_size))
5489 {
5491 goto handle_failure;
5492 }
5493 }
5494 else
5495 {
5496 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))
5497 {
5499 goto handle_failure;
5500 }
5501 }
5502
5503 mz_zip_array_clear(pZip, &file_data_array);
5504
5505 if ((flags & MZ_ZIP_FLAG_VALIDATE_HEADERS_ONLY) == 0)
5506 {
5507 if (!mz_zip_reader_extract_to_callback(pZip, file_index, mz_zip_compute_crc32_callback, &uncomp_crc32, 0))
5508 return MZ_FALSE;
5509
5510 /* 1 more check to be sure, although the extract checks too. */
5511 if (uncomp_crc32 != file_stat.m_crc32)
5512 {
5514 return MZ_FALSE;
5515 }
5516 }
5517
5518 return MZ_TRUE;
5519
5520handle_failure:
5521 mz_zip_array_clear(pZip, &file_data_array);
5522 return MZ_FALSE;
5523}
@ MZ_ZIP_LDH_CRC32_OFS
Definition miniz.c:3277
@ MZ_ZIP_LDH_BIT_FLAG_OFS
Definition miniz.c:3273
@ MZ_ZIP_LDH_COMPRESSED_SIZE_OFS
Definition miniz.c:3278
@ MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID
Definition miniz.c:3246
@ MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS
Definition miniz.c:3279
@ MZ_ZIP_DATA_DESCRIPTOR_ID
Definition miniz.c:3247
static MZ_FORCEINLINE void mz_zip_array_init(mz_zip_array *pArray, mz_uint32 element_size)
Definition miniz.c:3364
static MZ_FORCEINLINE void mz_zip_array_clear(mz_zip_archive *pZip, mz_zip_array *pArray)
Definition miniz.c:3370
static size_t mz_zip_compute_crc32_callback(void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n)
Definition miniz.c:5302
static MZ_FORCEINLINE mz_bool mz_zip_array_resize(mz_zip_archive *pZip, mz_zip_array *pArray, size_t new_size, mz_uint growing)
Definition miniz.c:3406
unsigned short mz_uint16
Definition miniz.h:547
#define MZ_READ_LE64(p)
Definition miniz.h:608
void * m_p
Definition miniz.c:3322

References mz_zip_archive::m_archive_size, mz_zip_archive_file_stat::m_comp_size, mz_zip_archive_file_stat::m_crc32, mz_zip_archive_file_stat::m_filename, mz_zip_archive_file_stat::m_is_directory, mz_zip_archive_file_stat::m_is_encrypted, mz_zip_archive_file_stat::m_is_supported, mz_zip_archive_file_stat::m_local_header_ofs, mz_zip_archive_file_stat::m_method, mz_zip_array::m_p, mz_zip_archive::m_pAlloc, mz_zip_archive::m_pFree, mz_zip_archive::m_pIO_opaque, mz_zip_archive::m_pRead, mz_zip_archive::m_pState, mz_zip_archive::m_total_files, mz_zip_archive_file_stat::m_uncomp_size, mz_zip_internal_state_tag::m_zip64, MZ_CRC32_INIT, MZ_DEFLATED, MZ_FALSE, MZ_MAX, MZ_READ_LE16, MZ_READ_LE32, MZ_READ_LE64, MZ_TRUE, MZ_UINT32_MAX, MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID, MZ_ZIP_ALLOC_FAILED, mz_zip_array_clear(), mz_zip_array_init(), mz_zip_array_resize(), mz_zip_compute_crc32_callback(), MZ_ZIP_DATA_DESCRIPTOR_ID, MZ_ZIP_FILE_READ_FAILED, mz_zip_file_stat_internal(), MZ_ZIP_FLAG_VALIDATE_HEADERS_ONLY, mz_zip_get_cdh(), MZ_ZIP_INVALID_HEADER_OR_CORRUPTED, MZ_ZIP_INVALID_PARAMETER, MZ_ZIP_LDH_BIT_FLAG_OFS, MZ_ZIP_LDH_COMPRESSED_SIZE_OFS, MZ_ZIP_LDH_CRC32_OFS, MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS, MZ_ZIP_LDH_EXTRA_LEN_OFS, MZ_ZIP_LDH_FILENAME_LEN_OFS, MZ_ZIP_LOCAL_DIR_HEADER_SIG, MZ_ZIP_LOCAL_DIR_HEADER_SIZE, mz_zip_reader_extract_to_callback(), mz_zip_set_error(), MZ_ZIP_UNSUPPORTED_ENCRYPTION, MZ_ZIP_UNSUPPORTED_FEATURE, MZ_ZIP_UNSUPPORTED_METHOD, and MZ_ZIP_VALIDATION_FAILED.

Referenced by mz_zip_validate_archive().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_zip_validate_file_archive()

MINIZ_EXPORT mz_bool mz_zip_validate_file_archive ( const char * pFilename,
mz_uint flags,
mz_zip_error * pErr )

Definition at line 5617 of file miniz.c.

5618{
5619 mz_bool success = MZ_TRUE;
5620 mz_zip_archive zip;
5621 mz_zip_error actual_err = MZ_ZIP_NO_ERROR;
5622
5623 if (!pFilename)
5624 {
5625 if (pErr)
5627 return MZ_FALSE;
5628 }
5629
5630 mz_zip_zero_struct(&zip);
5631
5632 if (!mz_zip_reader_init_file_v2(&zip, pFilename, flags, 0, 0))
5633 {
5634 if (pErr)
5635 *pErr = zip.m_last_error;
5636 return MZ_FALSE;
5637 }
5638
5639 if (!mz_zip_validate_archive(&zip, flags))
5640 {
5641 actual_err = zip.m_last_error;
5642 success = MZ_FALSE;
5643 }
5644
5645 if (!mz_zip_reader_end_internal(&zip, success))
5646 {
5647 if (!actual_err)
5648 actual_err = zip.m_last_error;
5649 success = MZ_FALSE;
5650 }
5651
5652 if (pErr)
5653 *pErr = actual_err;
5654
5655 return success;
5656}
mz_bool mz_zip_validate_archive(mz_zip_archive *pZip, mz_uint flags)
Definition miniz.c:5525

References mz_zip_archive::m_last_error, MZ_FALSE, MZ_TRUE, MZ_ZIP_INVALID_PARAMETER, MZ_ZIP_NO_ERROR, mz_zip_reader_end_internal(), mz_zip_reader_init_file_v2(), mz_zip_validate_archive(), and mz_zip_zero_struct().

+ Here is the call graph for this function:

◆ mz_zip_validate_mem_archive()

MINIZ_EXPORT mz_bool mz_zip_validate_mem_archive ( const void * pMem,
size_t size,
mz_uint flags,
mz_zip_error * pErr )

Definition at line 5575 of file miniz.c.

5576{
5577 mz_bool success = MZ_TRUE;
5578 mz_zip_archive zip;
5579 mz_zip_error actual_err = MZ_ZIP_NO_ERROR;
5580
5581 if ((!pMem) || (!size))
5582 {
5583 if (pErr)
5585 return MZ_FALSE;
5586 }
5587
5588 mz_zip_zero_struct(&zip);
5589
5590 if (!mz_zip_reader_init_mem(&zip, pMem, size, flags))
5591 {
5592 if (pErr)
5593 *pErr = zip.m_last_error;
5594 return MZ_FALSE;
5595 }
5596
5597 if (!mz_zip_validate_archive(&zip, flags))
5598 {
5599 actual_err = zip.m_last_error;
5600 success = MZ_FALSE;
5601 }
5602
5603 if (!mz_zip_reader_end_internal(&zip, success))
5604 {
5605 if (!actual_err)
5606 actual_err = zip.m_last_error;
5607 success = MZ_FALSE;
5608 }
5609
5610 if (pErr)
5611 *pErr = actual_err;
5612
5613 return success;
5614}
mz_bool mz_zip_reader_init_mem(mz_zip_archive *pZip, const void *pMem, size_t size, mz_uint flags)
Definition miniz.c:4003

References mz_zip_archive::m_last_error, MZ_FALSE, MZ_TRUE, MZ_ZIP_INVALID_PARAMETER, MZ_ZIP_NO_ERROR, mz_zip_reader_end_internal(), mz_zip_reader_init_mem(), mz_zip_validate_archive(), and mz_zip_zero_struct().

+ Here is the call graph for this function:

◆ mz_zip_writer_add_cfile()

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

Definition at line 6883 of file miniz.c.

6885{
6886 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,
6887 user_extra_data, user_extra_data_len, user_extra_data_central, user_extra_data_central_len);
6888}
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, const char *user_extra_data, mz_uint user_extra_data_len, const char *user_extra_data_central, mz_uint user_extra_data_central_len)
Definition miniz.c:6510
static size_t mz_file_read_func_stdio(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n)
Definition miniz.c:6872

References mz_file_read_func_stdio(), and mz_zip_writer_add_read_buf_callback().

Referenced by mz_zip_writer_add_file().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_zip_writer_add_file()

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 )

Definition at line 6890 of file miniz.c.

6891{
6892 MZ_FILE *pSrc_file = NULL;
6893 mz_uint64 uncomp_size = 0;
6894 MZ_TIME_T file_modified_time;
6895 MZ_TIME_T *pFile_time = NULL;
6896 mz_bool status;
6897
6898 memset(&file_modified_time, 0, sizeof(file_modified_time));
6899
6900#if !defined(MINIZ_NO_TIME) && !defined(MINIZ_NO_STDIO)
6901 pFile_time = &file_modified_time;
6902 if (!mz_zip_get_file_modified_time(pSrc_filename, &file_modified_time))
6904#endif
6905
6906 pSrc_file = MZ_FOPEN(pSrc_filename, "rb");
6907 if (!pSrc_file)
6909
6910 MZ_FSEEK64(pSrc_file, 0, SEEK_END);
6911 uncomp_size = MZ_FTELL64(pSrc_file);
6912 MZ_FSEEK64(pSrc_file, 0, SEEK_SET);
6913
6914 status = mz_zip_writer_add_cfile(pZip, pArchive_name, pSrc_file, uncomp_size, pFile_time, pComment, comment_size, level_and_flags, NULL, 0, NULL, 0);
6915
6916 MZ_FCLOSE(pSrc_file);
6917
6918 return status;
6919}
static mz_bool mz_zip_get_file_modified_time(const char *pFilename, MZ_TIME_T *pTime)
Definition miniz.c:3471
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, const char *user_extra_data, mz_uint user_extra_data_len, const char *user_extra_data_central, mz_uint user_extra_data_central_len)
Definition miniz.c:6883
#define MZ_TIME_T
Definition miniz.h:579

References MZ_FCLOSE, MZ_FILE, MZ_FOPEN, MZ_FSEEK64, MZ_FTELL64, MZ_TIME_T, MZ_ZIP_FILE_OPEN_FAILED, MZ_ZIP_FILE_STAT_FAILED, mz_zip_get_file_modified_time(), mz_zip_set_error(), and mz_zip_writer_add_cfile().

+ Here is the call graph for this function:

◆ mz_zip_writer_add_from_zip_reader()

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 )

Definition at line 7002 of file miniz.c.

7003{
7004 mz_uint n, bit_flags, num_alignment_padding_bytes, src_central_dir_following_data_size;
7005 mz_uint64 src_archive_bytes_remaining, local_dir_header_ofs;
7006 mz_uint64 cur_src_file_ofs, cur_dst_file_ofs;
7007 mz_uint32 local_header_u32[(MZ_ZIP_LOCAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];
7008 mz_uint8 *pLocal_header = (mz_uint8 *)local_header_u32;
7009 mz_uint8 new_central_header[MZ_ZIP_CENTRAL_DIR_HEADER_SIZE];
7010 size_t orig_central_dir_size;
7011 mz_zip_internal_state *pState;
7012 void *pBuf;
7013 const mz_uint8 *pSrc_central_header;
7014 mz_zip_archive_file_stat src_file_stat;
7015 mz_uint32 src_filename_len, src_comment_len, src_ext_len;
7016 mz_uint32 local_header_filename_size, local_header_extra_len;
7017 mz_uint64 local_header_comp_size, local_header_uncomp_size;
7018 mz_bool found_zip64_ext_data_in_ldir = MZ_FALSE;
7019
7020 /* Sanity checks */
7021 if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || (!pSource_zip->m_pRead))
7023
7024 pState = pZip->m_pState;
7025
7026 /* Don't support copying files from zip64 archives to non-zip64, even though in some cases this is possible */
7027 if ((pSource_zip->m_pState->m_zip64) && (!pZip->m_pState->m_zip64))
7029
7030 /* Get pointer to the source central dir header and crack it */
7031 if (NULL == (pSrc_central_header = mz_zip_get_cdh(pSource_zip, src_file_index)))
7033
7036
7037 src_filename_len = MZ_READ_LE16(pSrc_central_header + MZ_ZIP_CDH_FILENAME_LEN_OFS);
7038 src_comment_len = MZ_READ_LE16(pSrc_central_header + MZ_ZIP_CDH_COMMENT_LEN_OFS);
7039 src_ext_len = MZ_READ_LE16(pSrc_central_header + MZ_ZIP_CDH_EXTRA_LEN_OFS);
7040 src_central_dir_following_data_size = src_filename_len + src_ext_len + src_comment_len;
7041
7042 /* 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) */
7043 if ((pState->m_central_dir.m_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + src_central_dir_following_data_size + 32) >= MZ_UINT32_MAX)
7045
7046 num_alignment_padding_bytes = mz_zip_writer_compute_padding_needed_for_file_alignment(pZip);
7047
7048 if (!pState->m_zip64)
7049 {
7050 if (pZip->m_total_files == MZ_UINT16_MAX)
7052 }
7053 else
7054 {
7055 /* TODO: Our zip64 support still has some 32-bit limits that may not be worth fixing. */
7056 if (pZip->m_total_files == MZ_UINT32_MAX)
7058 }
7059
7060 if (!mz_zip_file_stat_internal(pSource_zip, src_file_index, pSrc_central_header, &src_file_stat, NULL))
7061 return MZ_FALSE;
7062
7063 cur_src_file_ofs = src_file_stat.m_local_header_ofs;
7064 cur_dst_file_ofs = pZip->m_archive_size;
7065
7066 /* Read the source archive's local dir header */
7067 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)
7069
7070 if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG)
7072
7073 cur_src_file_ofs += MZ_ZIP_LOCAL_DIR_HEADER_SIZE;
7074
7075 /* Compute the total size we need to copy (filename+extra data+compressed data) */
7076 local_header_filename_size = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS);
7077 local_header_extra_len = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS);
7078 local_header_comp_size = MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_COMPRESSED_SIZE_OFS);
7079 local_header_uncomp_size = MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS);
7080 src_archive_bytes_remaining = src_file_stat.m_comp_size + local_header_filename_size + local_header_extra_len ;
7081
7082 /* Try to find a zip64 extended information field */
7083 if ((local_header_extra_len) && ((local_header_comp_size == MZ_UINT32_MAX) || (local_header_uncomp_size == MZ_UINT32_MAX)))
7084 {
7085 mz_zip_array file_data_array;
7086 const mz_uint8 *pExtra_data;
7087 mz_uint32 extra_size_remaining = local_header_extra_len;
7088
7089 mz_zip_array_init(&file_data_array, 1);
7090 if (!mz_zip_array_resize(pZip, &file_data_array, local_header_extra_len, MZ_FALSE))
7091 {
7093 }
7094
7095 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)
7096 {
7097 mz_zip_array_clear(pZip, &file_data_array);
7099 }
7100
7101 pExtra_data = (const mz_uint8 *)file_data_array.m_p;
7102
7103 do
7104 {
7105 mz_uint32 field_id, field_data_size, field_total_size;
7106
7107 if (extra_size_remaining < (sizeof(mz_uint16) * 2))
7108 {
7109 mz_zip_array_clear(pZip, &file_data_array);
7111 }
7112
7113 field_id = MZ_READ_LE16(pExtra_data);
7114 field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16));
7115 field_total_size = field_data_size + sizeof(mz_uint16) * 2;
7116
7117 if (field_total_size > extra_size_remaining)
7118 {
7119 mz_zip_array_clear(pZip, &file_data_array);
7121 }
7122
7124 {
7125 const mz_uint8 *pSrc_field_data = pExtra_data + sizeof(mz_uint32);
7126
7127 if (field_data_size < sizeof(mz_uint64) * 2)
7128 {
7129 mz_zip_array_clear(pZip, &file_data_array);
7131 }
7132
7133 local_header_uncomp_size = MZ_READ_LE64(pSrc_field_data);
7134 local_header_comp_size = MZ_READ_LE64(pSrc_field_data + sizeof(mz_uint64)); /* may be 0 if there's a descriptor */
7135
7136 found_zip64_ext_data_in_ldir = MZ_TRUE;
7137 break;
7138 }
7139
7140 pExtra_data += field_total_size;
7141 extra_size_remaining -= field_total_size;
7142 } while (extra_size_remaining);
7143
7144 mz_zip_array_clear(pZip, &file_data_array);
7145 }
7146
7147 if (!pState->m_zip64)
7148 {
7149 /* 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). */
7150 /* We also check when the archive is finalized so this doesn't need to be perfect. */
7151 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) +
7152 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;
7153
7154 if (approx_new_archive_size >= MZ_UINT32_MAX)
7156 }
7157
7158 /* Write dest archive padding */
7159 if (!mz_zip_writer_write_zeros(pZip, cur_dst_file_ofs, num_alignment_padding_bytes))
7160 return MZ_FALSE;
7161
7162 cur_dst_file_ofs += num_alignment_padding_bytes;
7163
7164 local_dir_header_ofs = cur_dst_file_ofs;
7165 if (pZip->m_file_offset_alignment)
7166 {
7167 MZ_ASSERT((local_dir_header_ofs & (pZip->m_file_offset_alignment - 1)) == 0);
7168 }
7169
7170 /* 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 */
7171 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)
7173
7174 cur_dst_file_ofs += MZ_ZIP_LOCAL_DIR_HEADER_SIZE;
7175
7176 /* Copy over the source archive bytes to the dest archive, also ensure we have enough buf space to handle optional data descriptor */
7177 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)))))
7179
7180 while (src_archive_bytes_remaining)
7181 {
7182 n = (mz_uint)MZ_MIN((mz_uint64)MZ_ZIP_MAX_IO_BUF_SIZE, src_archive_bytes_remaining);
7183 if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf, n) != n)
7184 {
7185 pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
7187 }
7188 cur_src_file_ofs += n;
7189
7190 if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_dst_file_ofs, pBuf, n) != n)
7191 {
7192 pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
7194 }
7195 cur_dst_file_ofs += n;
7196
7197 src_archive_bytes_remaining -= n;
7198 }
7199
7200 /* Now deal with the optional data descriptor */
7201 bit_flags = MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_BIT_FLAG_OFS);
7202 if (bit_flags & 8)
7203 {
7204 /* Copy data descriptor */
7205 if ((pSource_zip->m_pState->m_zip64) || (found_zip64_ext_data_in_ldir))
7206 {
7207 /* src is zip64, dest must be zip64 */
7208
7209 /* name uint32_t's */
7210 /* id 1 (optional in zip64?) */
7211 /* crc 1 */
7212 /* comp_size 2 */
7213 /* uncomp_size 2 */
7214 if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf, (sizeof(mz_uint32) * 6)) != (sizeof(mz_uint32) * 6))
7215 {
7216 pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
7218 }
7219
7220 n = sizeof(mz_uint32) * ((MZ_READ_LE32(pBuf) == MZ_ZIP_DATA_DESCRIPTOR_ID) ? 6 : 5);
7221 }
7222 else
7223 {
7224 /* src is NOT zip64 */
7225 mz_bool has_id;
7226
7227 if (pSource_zip->m_pRead(pSource_zip->m_pIO_opaque, cur_src_file_ofs, pBuf, sizeof(mz_uint32) * 4) != sizeof(mz_uint32) * 4)
7228 {
7229 pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
7231 }
7232
7233 has_id = (MZ_READ_LE32(pBuf) == MZ_ZIP_DATA_DESCRIPTOR_ID);
7234
7235 if (pZip->m_pState->m_zip64)
7236 {
7237 /* dest is zip64, so upgrade the data descriptor */
7238 const mz_uint8 *pSrc_descriptor = (const mz_uint8 *)pBuf + (has_id ? sizeof(mz_uint32) : 0);
7239 const mz_uint32 src_crc32 = MZ_READ_LE32(pSrc_descriptor);
7240 const mz_uint64 src_comp_size = MZ_READ_LE32(pSrc_descriptor + sizeof(mz_uint32));
7241 const mz_uint64 src_uncomp_size = MZ_READ_LE32(pSrc_descriptor + 2*sizeof(mz_uint32));
7242
7244 mz_write_le32((mz_uint8 *)pBuf + sizeof(mz_uint32) * 1, src_crc32);
7245 mz_write_le64((mz_uint8 *)pBuf + sizeof(mz_uint32) * 2, src_comp_size);
7246 mz_write_le64((mz_uint8 *)pBuf + sizeof(mz_uint32) * 4, src_uncomp_size);
7247
7248 n = sizeof(mz_uint32) * 6;
7249 }
7250 else
7251 {
7252 /* dest is NOT zip64, just copy it as-is */
7253 n = sizeof(mz_uint32) * (has_id ? 4 : 3);
7254 }
7255 }
7256
7257 if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_dst_file_ofs, pBuf, n) != n)
7258 {
7259 pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
7261 }
7262
7263 cur_src_file_ofs += n;
7264 cur_dst_file_ofs += n;
7265 }
7266 pZip->m_pFree(pZip->m_pAlloc_opaque, pBuf);
7267
7268 /* Finally, add the new central dir header */
7269 orig_central_dir_size = pState->m_central_dir.m_size;
7270
7271 memcpy(new_central_header, pSrc_central_header, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE);
7272
7273 if (pState->m_zip64)
7274 {
7275 /* 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. */
7276 const mz_uint8 *pSrc_ext = pSrc_central_header + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + src_filename_len;
7277 mz_zip_array new_ext_block;
7278
7279 mz_zip_array_init(&new_ext_block, sizeof(mz_uint8));
7280
7284
7285 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))
7286 {
7287 mz_zip_array_clear(pZip, &new_ext_block);
7288 return MZ_FALSE;
7289 }
7290
7291 MZ_WRITE_LE16(new_central_header + MZ_ZIP_CDH_EXTRA_LEN_OFS, new_ext_block.m_size);
7292
7293 if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, new_central_header, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE))
7294 {
7295 mz_zip_array_clear(pZip, &new_ext_block);
7297 }
7298
7299 if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, pSrc_central_header + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, src_filename_len))
7300 {
7301 mz_zip_array_clear(pZip, &new_ext_block);
7302 mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
7304 }
7305
7306 if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, new_ext_block.m_p, new_ext_block.m_size))
7307 {
7308 mz_zip_array_clear(pZip, &new_ext_block);
7309 mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
7311 }
7312
7313 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))
7314 {
7315 mz_zip_array_clear(pZip, &new_ext_block);
7316 mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
7318 }
7319
7320 mz_zip_array_clear(pZip, &new_ext_block);
7321 }
7322 else
7323 {
7324 /* sanity checks */
7325 if (cur_dst_file_ofs > MZ_UINT32_MAX)
7327
7328 if (local_dir_header_ofs >= MZ_UINT32_MAX)
7330
7331 MZ_WRITE_LE32(new_central_header + MZ_ZIP_CDH_LOCAL_HEADER_OFS, local_dir_header_ofs);
7332
7333 if (!mz_zip_array_push_back(pZip, &pState->m_central_dir, new_central_header, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE))
7335
7336 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))
7337 {
7338 mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
7340 }
7341 }
7342
7343 /* This shouldn't trigger unless we screwed up during the initial sanity checks */
7344 if (pState->m_central_dir.m_size >= MZ_UINT32_MAX)
7345 {
7346 /* TODO: Support central dirs >= 32-bits in size */
7347 mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
7349 }
7350
7351 n = (mz_uint32)orig_central_dir_size;
7352 if (!mz_zip_array_push_back(pZip, &pState->m_central_dir_offsets, &n, 1))
7353 {
7354 mz_zip_array_resize(pZip, &pState->m_central_dir, orig_central_dir_size, MZ_FALSE);
7356 }
7357
7358 pZip->m_total_files++;
7359 pZip->m_archive_size = cur_dst_file_ofs;
7360
7361 return MZ_TRUE;
7362}
#define MZ_WRITE_LE32(p, v)
Definition miniz.c:5682
@ MZ_ZIP_CDH_LOCAL_HEADER_OFS
Definition miniz.c:3268
@ MZ_ZIP_CDH_COMPRESSED_SIZE_OFS
Definition miniz.c:3260
@ MZ_ZIP_CDH_SIG_OFS
Definition miniz.c:3252
@ MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS
Definition miniz.c:3261
@ MZ_ZIP_CENTRAL_DIR_HEADER_SIG
Definition miniz.c:3235
static MZ_FORCEINLINE void mz_write_le32(mz_uint8 *p, mz_uint32 v)
Definition miniz.c:5668
#define MZ_WRITE_LE16(p, v)
Definition miniz.c:5681
static MZ_FORCEINLINE mz_bool mz_zip_array_push_back(mz_zip_archive *pZip, mz_zip_array *pArray, const void *pElements, size_t n)
Definition miniz.c:3422
static mz_bool mz_zip_writer_update_zip64_extension_block(mz_zip_array *pNew_ext, mz_zip_archive *pZip, const mz_uint8 *pExt, mz_uint32 ext_len, mz_uint64 *pComp_size, mz_uint64 *pUncomp_size, mz_uint64 *pLocal_header_ofs, mz_uint32 *pDisk_start)
Definition miniz.c:6922
static mz_uint mz_zip_writer_compute_padding_needed_for_file_alignment(mz_zip_archive *pZip)
Definition miniz.c:6193
static mz_bool mz_zip_writer_write_zeros(mz_zip_archive *pZip, mz_uint64 cur_file_ofs, mz_uint32 n)
Definition miniz.c:6202
static MZ_FORCEINLINE void mz_write_le64(mz_uint8 *p, mz_uint64 v)
Definition miniz.c:5675
#define MZ_ASSERT(x)
Definition miniz.h:582
mz_file_write_func m_pWrite
Definition miniz.h:1146
mz_uint64 m_file_offset_alignment
Definition miniz.h:1138

References mz_zip_archive::m_archive_size, mz_zip_internal_state_tag::m_central_dir, mz_zip_internal_state_tag::m_central_dir_offsets, mz_zip_archive_file_stat::m_comp_size, mz_zip_archive::m_file_offset_alignment, mz_zip_archive_file_stat::m_local_header_ofs, mz_zip_array::m_p, mz_zip_archive::m_pAlloc, mz_zip_archive::m_pAlloc_opaque, mz_zip_archive::m_pFree, mz_zip_archive::m_pIO_opaque, mz_zip_archive::m_pRead, mz_zip_archive::m_pState, mz_zip_archive::m_pWrite, mz_zip_array::m_size, mz_zip_archive::m_total_files, mz_zip_archive_file_stat::m_uncomp_size, mz_zip_internal_state_tag::m_zip64, mz_zip_archive::m_zip_mode, MZ_ASSERT, MZ_FALSE, MZ_MAX, MZ_MIN, MZ_READ_LE16, MZ_READ_LE32, MZ_READ_LE64, MZ_TRUE, MZ_UINT16_MAX, MZ_UINT32_MAX, MZ_WRITE_LE16, MZ_WRITE_LE32, mz_write_le32(), mz_write_le64(), MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID, MZ_ZIP_ALLOC_FAILED, MZ_ZIP_ARCHIVE_TOO_LARGE, mz_zip_array_clear(), mz_zip_array_init(), mz_zip_array_push_back(), mz_zip_array_resize(), MZ_ZIP_CDH_COMMENT_LEN_OFS, MZ_ZIP_CDH_COMPRESSED_SIZE_OFS, MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS, MZ_ZIP_CDH_EXTRA_LEN_OFS, MZ_ZIP_CDH_FILENAME_LEN_OFS, MZ_ZIP_CDH_LOCAL_HEADER_OFS, MZ_ZIP_CDH_SIG_OFS, MZ_ZIP_CENTRAL_DIR_HEADER_SIG, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, MZ_ZIP_DATA_DESCRIPTOR_ID, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE, MZ_ZIP_FILE_READ_FAILED, mz_zip_file_stat_internal(), MZ_ZIP_FILE_WRITE_FAILED, mz_zip_get_cdh(), MZ_ZIP_INVALID_HEADER_OR_CORRUPTED, MZ_ZIP_INVALID_PARAMETER, MZ_ZIP_LDH_BIT_FLAG_OFS, MZ_ZIP_LDH_COMPRESSED_SIZE_OFS, MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS, MZ_ZIP_LDH_EXTRA_LEN_OFS, MZ_ZIP_LDH_FILENAME_LEN_OFS, MZ_ZIP_LOCAL_DIR_HEADER_SIG, MZ_ZIP_LOCAL_DIR_HEADER_SIZE, MZ_ZIP_MAX_IO_BUF_SIZE, MZ_ZIP_MODE_WRITING, mz_zip_set_error(), MZ_ZIP_TOO_MANY_FILES, MZ_ZIP_UNSUPPORTED_CDIR_SIZE, mz_zip_writer_compute_padding_needed_for_file_alignment(), mz_zip_writer_update_zip64_extension_block(), and mz_zip_writer_write_zeros().

+ Here is the call graph for this function:

◆ mz_zip_writer_add_mem()

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 )

Definition at line 6039 of file miniz.c.

6040{
6041 return mz_zip_writer_add_mem_ex(pZip, pArchive_name, pBuf, buf_size, NULL, 0, level_and_flags, 0, 0);
6042}

References mz_zip_writer_add_mem_ex().

+ Here is the call graph for this function:

◆ mz_zip_writer_add_mem_ex()

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 )

Definition at line 6218 of file miniz.c.

6220{
6221 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);
6222}
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)
Definition miniz.c:6224

References mz_zip_writer_add_mem_ex_v2().

Referenced by mz_zip_add_mem_to_archive_file_in_place_v2(), and mz_zip_writer_add_mem().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_zip_writer_add_mem_ex_v2()

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 )

Definition at line 6224 of file miniz.c.

6227{
6228 mz_uint16 method = 0, dos_time = 0, dos_date = 0;
6229 mz_uint level, ext_attributes = 0, num_alignment_padding_bytes;
6230 mz_uint64 local_dir_header_ofs = pZip->m_archive_size, cur_archive_file_ofs = pZip->m_archive_size, comp_size = 0;
6231 size_t archive_name_size;
6232 mz_uint8 local_dir_header[MZ_ZIP_LOCAL_DIR_HEADER_SIZE];
6233 tdefl_compressor *pComp = NULL;
6234 mz_bool store_data_uncompressed;
6235 mz_zip_internal_state *pState;
6236 mz_uint8 *pExtra_data = NULL;
6237 mz_uint32 extra_size = 0;
6239 mz_uint16 bit_flags = 0;
6240
6241 if ((int)level_and_flags < 0)
6242 level_and_flags = MZ_DEFAULT_LEVEL;
6243
6244 if (uncomp_size || (buf_size && !(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)))
6246
6247 if (!(level_and_flags & MZ_ZIP_FLAG_ASCII_FILENAME))
6249
6250 level = level_and_flags & 0xF;
6251 store_data_uncompressed = ((!level) || (level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA));
6252
6253 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))
6255
6256 pState = pZip->m_pState;
6257
6258 if (pState->m_zip64)
6259 {
6260 if (pZip->m_total_files == MZ_UINT32_MAX)
6262 }
6263 else
6264 {
6265 if (pZip->m_total_files == MZ_UINT16_MAX)
6266 {
6267 pState->m_zip64 = MZ_TRUE;
6268 /*return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); */
6269 }
6270 if (((mz_uint64)buf_size > 0xFFFFFFFF) || (uncomp_size > 0xFFFFFFFF))
6271 {
6272 pState->m_zip64 = MZ_TRUE;
6273 /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */
6274 }
6275 }
6276
6277 if ((!(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) && (uncomp_size))
6279
6280 if (!mz_zip_writer_validate_archive_name(pArchive_name))
6282
6283#ifndef MINIZ_NO_TIME
6284 if (last_modified != NULL)
6285 {
6286 mz_zip_time_t_to_dos_time(*last_modified, &dos_time, &dos_date);
6287 }
6288 else
6289 {
6290 MZ_TIME_T cur_time;
6291 time(&cur_time);
6292 mz_zip_time_t_to_dos_time(cur_time, &dos_time, &dos_date);
6293 }
6294#endif /* #ifndef MINIZ_NO_TIME */
6295
6296 if (!(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA))
6297 {
6298 uncomp_crc32 = (mz_uint32)mz_crc32(MZ_CRC32_INIT, (const mz_uint8 *)pBuf, buf_size);
6299 uncomp_size = buf_size;
6300 if (uncomp_size <= 3)
6301 {
6302 level = 0;
6303 store_data_uncompressed = MZ_TRUE;
6304 }
6305 }
6306
6307 archive_name_size = strlen(pArchive_name);
6308 if (archive_name_size > MZ_UINT16_MAX)
6310
6311 num_alignment_padding_bytes = mz_zip_writer_compute_padding_needed_for_file_alignment(pZip);
6312
6313 /* miniz doesn't support central dirs >= MZ_UINT32_MAX bytes yet */
6316
6317 if (!pState->m_zip64)
6318 {
6319 /* Bail early if the archive would obviously become too large */
6320 if ((pZip->m_archive_size + num_alignment_padding_bytes + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + archive_name_size
6321 + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + archive_name_size + comment_size + user_extra_data_len +
6322 pState->m_central_dir.m_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE + user_extra_data_central_len
6323 + MZ_ZIP_DATA_DESCRIPTER_SIZE32) > 0xFFFFFFFF)
6324 {
6325 pState->m_zip64 = MZ_TRUE;
6326 /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */
6327 }
6328 }
6329
6330 if ((archive_name_size) && (pArchive_name[archive_name_size - 1] == '/'))
6331 {
6332 /* Set DOS Subdirectory attribute bit. */
6333 ext_attributes |= MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG;
6334
6335 /* Subdirectories cannot contain data. */
6336 if ((buf_size) || (uncomp_size))
6338 }
6339
6340 /* 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.) */
6341 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)))
6343
6344 if ((!store_data_uncompressed) && (buf_size))
6345 {
6346 if (NULL == (pComp = (tdefl_compressor *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(tdefl_compressor))))
6348 }
6349
6350 if (!mz_zip_writer_write_zeros(pZip, cur_archive_file_ofs, num_alignment_padding_bytes))
6351 {
6352 pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
6353 return MZ_FALSE;
6354 }
6355
6356 local_dir_header_ofs += num_alignment_padding_bytes;
6357 if (pZip->m_file_offset_alignment)
6358 {
6359 MZ_ASSERT((local_dir_header_ofs & (pZip->m_file_offset_alignment - 1)) == 0);
6360 }
6361 cur_archive_file_ofs += num_alignment_padding_bytes;
6362
6363 MZ_CLEAR_ARR(local_dir_header);
6364
6365 if (!store_data_uncompressed || (level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA))
6366 {
6367 method = MZ_DEFLATED;
6368 }
6369
6370 if (pState->m_zip64)
6371 {
6372 if (uncomp_size >= MZ_UINT32_MAX || local_dir_header_ofs >= MZ_UINT32_MAX)
6373 {
6374 pExtra_data = extra_data;
6375 extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (uncomp_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL,
6376 (uncomp_size >= MZ_UINT32_MAX) ? &comp_size : NULL, (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL);
6377 }
6378
6379 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))
6381
6382 if (pZip->m_pWrite(pZip->m_pIO_opaque, local_dir_header_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header))
6384
6385 cur_archive_file_ofs += sizeof(local_dir_header);
6386
6387 if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size)
6388 {
6389 pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
6391 }
6392 cur_archive_file_ofs += archive_name_size;
6393
6394 if (pExtra_data != NULL)
6395 {
6396 if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, extra_data, extra_size) != extra_size)
6398
6399 cur_archive_file_ofs += extra_size;
6400 }
6401 }
6402 else
6403 {
6404 if ((comp_size > MZ_UINT32_MAX) || (cur_archive_file_ofs > MZ_UINT32_MAX))
6406 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))
6408
6409 if (pZip->m_pWrite(pZip->m_pIO_opaque, local_dir_header_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header))
6411
6412 cur_archive_file_ofs += sizeof(local_dir_header);
6413
6414 if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size)
6415 {
6416 pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
6418 }
6419 cur_archive_file_ofs += archive_name_size;
6420 }
6421
6422 if (user_extra_data_len > 0)
6423 {
6424 if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, user_extra_data, user_extra_data_len) != user_extra_data_len)
6426
6427 cur_archive_file_ofs += user_extra_data_len;
6428 }
6429
6430 if (store_data_uncompressed)
6431 {
6432 if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pBuf, buf_size) != buf_size)
6433 {
6434 pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
6436 }
6437
6438 cur_archive_file_ofs += buf_size;
6439 comp_size = buf_size;
6440 }
6441 else if (buf_size)
6442 {
6444
6445 state.m_pZip = pZip;
6446 state.m_cur_archive_file_ofs = cur_archive_file_ofs;
6447 state.m_comp_size = 0;
6448
6450 (tdefl_compress_buffer(pComp, pBuf, buf_size, TDEFL_FINISH) != TDEFL_STATUS_DONE))
6451 {
6452 pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
6454 }
6455
6456 comp_size = state.m_comp_size;
6457 cur_archive_file_ofs = state.m_cur_archive_file_ofs;
6458 }
6459
6460 pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
6461 pComp = NULL;
6462
6463 if (uncomp_size)
6464 {
6465 mz_uint8 local_dir_footer[MZ_ZIP_DATA_DESCRIPTER_SIZE64];
6466 mz_uint32 local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE32;
6467
6469
6470 MZ_WRITE_LE32(local_dir_footer + 0, MZ_ZIP_DATA_DESCRIPTOR_ID);
6471 MZ_WRITE_LE32(local_dir_footer + 4, uncomp_crc32);
6472 if (pExtra_data == NULL)
6473 {
6474 if (comp_size > MZ_UINT32_MAX)
6476
6477 MZ_WRITE_LE32(local_dir_footer + 8, comp_size);
6478 MZ_WRITE_LE32(local_dir_footer + 12, uncomp_size);
6479 }
6480 else
6481 {
6482 MZ_WRITE_LE64(local_dir_footer + 8, comp_size);
6483 MZ_WRITE_LE64(local_dir_footer + 16, uncomp_size);
6484 local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE64;
6485 }
6486
6487 if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, local_dir_footer, local_dir_footer_size) != local_dir_footer_size)
6488 return MZ_FALSE;
6489
6490 cur_archive_file_ofs += local_dir_footer_size;
6491 }
6492
6493 if (pExtra_data != NULL)
6494 {
6495 extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (uncomp_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL,
6496 (uncomp_size >= MZ_UINT32_MAX) ? &comp_size : NULL, (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL);
6497 }
6498
6499 if (!mz_zip_writer_add_to_central_dir(pZip, pArchive_name, (mz_uint16)archive_name_size, pExtra_data, (mz_uint16)extra_size, pComment,
6500 comment_size, uncomp_size, comp_size, uncomp_crc32, method, bit_flags, dos_time, dos_date, local_dir_header_ofs, ext_attributes,
6501 user_extra_data_central, user_extra_data_central_len))
6502 return MZ_FALSE;
6503
6504 pZip->m_total_files++;
6505 pZip->m_archive_size = cur_archive_file_ofs;
6506
6507 return MZ_TRUE;
6508}
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)
Definition miniz.c:6142
@ MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR
Definition miniz.c:3282
@ MZ_ZIP_DATA_DESCRIPTER_SIZE64
Definition miniz.c:3248
@ MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8
Definition miniz.c:3317
@ MZ_ZIP_DATA_DESCRIPTER_SIZE32
Definition miniz.c:3249
static MZ_FORCEINLINE mz_bool mz_zip_array_ensure_room(mz_zip_archive *pZip, mz_zip_array *pArray, size_t n)
Definition miniz.c:3417
tdefl_status tdefl_compress_buffer(tdefl_compressor *d, const void *pIn_buf, size_t in_buf_size, tdefl_flush flush)
Definition miniz.c:1987
static void mz_zip_time_t_to_dos_time(MZ_TIME_T time, mz_uint16 *pDOS_time, mz_uint16 *pDOS_date)
Definition miniz.c:3448
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)
Definition miniz.c:6064
static mz_bool mz_zip_writer_add_put_buf_callback(const void *pBuf, int len, void *pUser)
Definition miniz.c:6051
#define MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE
Definition miniz.c:6063
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)
Definition miniz.c:6099
#define MZ_WRITE_LE64(p, v)
Definition miniz.c:5683
#define MZ_CLEAR_ARR(obj)
Definition miniz.h:597
mz_uint64 m_cur_archive_file_ofs
Definition miniz.c:6047
mz_uint64 m_comp_size
Definition miniz.c:6048
mz_zip_archive * m_pZip
Definition miniz.c:6046

References mz_zip_archive::m_archive_size, mz_zip_internal_state_tag::m_central_dir, mz_zip_internal_state_tag::m_central_dir_offsets, mz_zip_writer_add_state::m_comp_size, mz_zip_writer_add_state::m_cur_archive_file_ofs, mz_zip_archive::m_file_offset_alignment, mz_zip_archive::m_pAlloc, mz_zip_archive::m_pAlloc_opaque, mz_zip_archive::m_pFree, mz_zip_archive::m_pIO_opaque, mz_zip_archive::m_pState, mz_zip_archive::m_pWrite, mz_zip_writer_add_state::m_pZip, mz_zip_array::m_size, mz_zip_archive::m_total_files, mz_zip_internal_state_tag::m_zip64, mz_zip_archive::m_zip_mode, MZ_ASSERT, MZ_CLEAR_ARR, mz_crc32(), MZ_CRC32_INIT, MZ_DEFAULT_LEVEL, MZ_DEFAULT_STRATEGY, MZ_DEFLATED, MZ_FALSE, MZ_TIME_T, MZ_TRUE, MZ_UBER_COMPRESSION, MZ_UINT16_MAX, MZ_UINT32_MAX, MZ_WRITE_LE32, MZ_WRITE_LE64, MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE, MZ_ZIP_ALLOC_FAILED, MZ_ZIP_ARCHIVE_TOO_LARGE, mz_zip_array_ensure_room(), MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, MZ_ZIP_COMPRESSION_FAILED, MZ_ZIP_DATA_DESCRIPTER_SIZE32, MZ_ZIP_DATA_DESCRIPTER_SIZE64, MZ_ZIP_DATA_DESCRIPTOR_ID, MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE, MZ_ZIP_FILE_WRITE_FAILED, MZ_ZIP_FLAG_ASCII_FILENAME, MZ_ZIP_FLAG_COMPRESSED_DATA, MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8, MZ_ZIP_INTERNAL_ERROR, MZ_ZIP_INVALID_FILENAME, MZ_ZIP_INVALID_PARAMETER, MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR, MZ_ZIP_LOCAL_DIR_HEADER_SIZE, MZ_ZIP_MODE_WRITING, mz_zip_set_error(), mz_zip_time_t_to_dos_time(), MZ_ZIP_TOO_MANY_FILES, MZ_ZIP_UNSUPPORTED_CDIR_SIZE, mz_zip_writer_add_put_buf_callback(), mz_zip_writer_add_to_central_dir(), mz_zip_writer_compute_padding_needed_for_file_alignment(), mz_zip_writer_create_local_dir_header(), mz_zip_writer_create_zip64_extra_data(), mz_zip_writer_validate_archive_name(), mz_zip_writer_write_zeros(), tdefl_compress_buffer(), tdefl_create_comp_flags_from_zip_params(), TDEFL_FINISH, tdefl_init(), TDEFL_STATUS_DONE, and TDEFL_STATUS_OKAY.

Referenced by mz_zip_writer_add_mem_ex().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_zip_writer_add_read_buf_callback()

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

Definition at line 6510 of file miniz.c.

6512{
6513 mz_uint16 gen_flags;
6514 mz_uint uncomp_crc32 = MZ_CRC32_INIT, level, num_alignment_padding_bytes;
6515 mz_uint16 method = 0, dos_time = 0, dos_date = 0, ext_attributes = 0;
6516 mz_uint64 local_dir_header_ofs, cur_archive_file_ofs = pZip->m_archive_size, uncomp_size = 0, comp_size = 0;
6517 size_t archive_name_size;
6518 mz_uint8 local_dir_header[MZ_ZIP_LOCAL_DIR_HEADER_SIZE];
6519 mz_uint8 *pExtra_data = NULL;
6520 mz_uint32 extra_size = 0;
6522 mz_zip_internal_state *pState;
6523 mz_uint64 file_ofs = 0, cur_archive_header_file_ofs;
6524
6525 if ((int)level_and_flags < 0)
6526 level_and_flags = MZ_DEFAULT_LEVEL;
6527 level = level_and_flags & 0xF;
6528
6529 gen_flags = (level_and_flags & MZ_ZIP_FLAG_WRITE_HEADER_SET_SIZE) ? 0 : MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR;
6530
6531 if (!(level_and_flags & MZ_ZIP_FLAG_ASCII_FILENAME))
6533
6534 /* Sanity checks */
6535 if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING) || (!pArchive_name) || ((comment_size) && (!pComment)) || (level > MZ_UBER_COMPRESSION))
6537
6538 pState = pZip->m_pState;
6539
6540 if ((!pState->m_zip64) && (max_size > MZ_UINT32_MAX))
6541 {
6542 /* Source file is too large for non-zip64 */
6543 /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */
6544 pState->m_zip64 = MZ_TRUE;
6545 }
6546
6547 /* We could support this, but why? */
6548 if (level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)
6550
6551 if (!mz_zip_writer_validate_archive_name(pArchive_name))
6553
6554 if (pState->m_zip64)
6555 {
6556 if (pZip->m_total_files == MZ_UINT32_MAX)
6558 }
6559 else
6560 {
6561 if (pZip->m_total_files == MZ_UINT16_MAX)
6562 {
6563 pState->m_zip64 = MZ_TRUE;
6564 /*return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES); */
6565 }
6566 }
6567
6568 archive_name_size = strlen(pArchive_name);
6569 if (archive_name_size > MZ_UINT16_MAX)
6571
6572 num_alignment_padding_bytes = mz_zip_writer_compute_padding_needed_for_file_alignment(pZip);
6573
6574 /* miniz doesn't support central dirs >= MZ_UINT32_MAX bytes yet */
6577
6578 if (!pState->m_zip64)
6579 {
6580 /* Bail early if the archive would obviously become too large */
6581 if ((pZip->m_archive_size + num_alignment_padding_bytes + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + archive_name_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE
6582 + archive_name_size + comment_size + user_extra_data_len + pState->m_central_dir.m_size + MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE + 1024
6583 + MZ_ZIP_DATA_DESCRIPTER_SIZE32 + user_extra_data_central_len) > 0xFFFFFFFF)
6584 {
6585 pState->m_zip64 = MZ_TRUE;
6586 /*return mz_zip_set_error(pZip, MZ_ZIP_ARCHIVE_TOO_LARGE); */
6587 }
6588 }
6589
6590#ifndef MINIZ_NO_TIME
6591 if (pFile_time)
6592 {
6593 mz_zip_time_t_to_dos_time(*pFile_time, &dos_time, &dos_date);
6594 }
6595#endif
6596
6597 if (max_size <= 3)
6598 level = 0;
6599
6600 if (!mz_zip_writer_write_zeros(pZip, cur_archive_file_ofs, num_alignment_padding_bytes))
6601 {
6603 }
6604
6605 cur_archive_file_ofs += num_alignment_padding_bytes;
6606 local_dir_header_ofs = cur_archive_file_ofs;
6607
6608 if (pZip->m_file_offset_alignment)
6609 {
6610 MZ_ASSERT((cur_archive_file_ofs & (pZip->m_file_offset_alignment - 1)) == 0);
6611 }
6612
6613 if (max_size && level)
6614 {
6615 method = MZ_DEFLATED;
6616 }
6617
6618 MZ_CLEAR_ARR(local_dir_header);
6619 if (pState->m_zip64)
6620 {
6621 if (max_size >= MZ_UINT32_MAX || local_dir_header_ofs >= MZ_UINT32_MAX)
6622 {
6623 pExtra_data = extra_data;
6624 if (level_and_flags & MZ_ZIP_FLAG_WRITE_HEADER_SET_SIZE)
6625 extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (max_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL,
6626 (max_size >= MZ_UINT32_MAX) ? &comp_size : NULL,
6627 (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL);
6628 else
6629 extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, NULL,
6630 NULL,
6631 (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL);
6632 }
6633
6634 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))
6636
6637 if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header))
6639
6640 cur_archive_file_ofs += sizeof(local_dir_header);
6641
6642 if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size)
6643 {
6645 }
6646
6647 cur_archive_file_ofs += archive_name_size;
6648
6649 if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, extra_data, extra_size) != extra_size)
6651
6652 cur_archive_file_ofs += extra_size;
6653 }
6654 else
6655 {
6656 if ((comp_size > MZ_UINT32_MAX) || (cur_archive_file_ofs > MZ_UINT32_MAX))
6658 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))
6660
6661 if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header))
6663
6664 cur_archive_file_ofs += sizeof(local_dir_header);
6665
6666 if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pArchive_name, archive_name_size) != archive_name_size)
6667 {
6669 }
6670
6671 cur_archive_file_ofs += archive_name_size;
6672 }
6673
6674 if (user_extra_data_len > 0)
6675 {
6676 if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, user_extra_data, user_extra_data_len) != user_extra_data_len)
6678
6679 cur_archive_file_ofs += user_extra_data_len;
6680 }
6681
6682 if (max_size)
6683 {
6684 void *pRead_buf = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, MZ_ZIP_MAX_IO_BUF_SIZE);
6685 if (!pRead_buf)
6686 {
6688 }
6689
6690 if (!level)
6691 {
6692 while (1)
6693 {
6694 size_t n = read_callback(callback_opaque, file_ofs, pRead_buf, MZ_ZIP_MAX_IO_BUF_SIZE);
6695 if (n == 0)
6696 break;
6697
6698 if ((n > MZ_ZIP_MAX_IO_BUF_SIZE) || (file_ofs + n > max_size))
6699 {
6700 pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
6702 }
6703 if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, pRead_buf, n) != n)
6704 {
6705 pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
6707 }
6708 file_ofs += n;
6709 uncomp_crc32 = (mz_uint32)mz_crc32(uncomp_crc32, (const mz_uint8 *)pRead_buf, n);
6710 cur_archive_file_ofs += n;
6711 }
6712 uncomp_size = file_ofs;
6713 comp_size = uncomp_size;
6714 }
6715 else
6716 {
6717 mz_bool result = MZ_FALSE;
6719 tdefl_compressor *pComp = (tdefl_compressor *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(tdefl_compressor));
6720 if (!pComp)
6721 {
6722 pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
6724 }
6725
6726 state.m_pZip = pZip;
6727 state.m_cur_archive_file_ofs = cur_archive_file_ofs;
6728 state.m_comp_size = 0;
6729
6731 {
6732 pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
6733 pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
6735 }
6736
6737 for (;;)
6738 {
6739 tdefl_status status;
6741
6742 size_t n = read_callback(callback_opaque, file_ofs, pRead_buf, MZ_ZIP_MAX_IO_BUF_SIZE);
6743 if ((n > MZ_ZIP_MAX_IO_BUF_SIZE) || (file_ofs + n > max_size))
6744 {
6746 break;
6747 }
6748
6749 file_ofs += n;
6750 uncomp_crc32 = (mz_uint32)mz_crc32(uncomp_crc32, (const mz_uint8 *)pRead_buf, n);
6751
6752 if (pZip->m_pNeeds_keepalive != NULL && pZip->m_pNeeds_keepalive(pZip->m_pIO_opaque))
6753 flush = TDEFL_FULL_FLUSH;
6754
6755 if (n == 0)
6756 flush = TDEFL_FINISH;
6757
6758 status = tdefl_compress_buffer(pComp, pRead_buf, n, flush);
6759 if (status == TDEFL_STATUS_DONE)
6760 {
6761 result = MZ_TRUE;
6762 break;
6763 }
6764 else if (status != TDEFL_STATUS_OKAY)
6765 {
6767 break;
6768 }
6769 }
6770
6771 pZip->m_pFree(pZip->m_pAlloc_opaque, pComp);
6772
6773 if (!result)
6774 {
6775 pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
6776 return MZ_FALSE;
6777 }
6778
6779 uncomp_size = file_ofs;
6780 comp_size = state.m_comp_size;
6781 cur_archive_file_ofs = state.m_cur_archive_file_ofs;
6782 }
6783
6784 pZip->m_pFree(pZip->m_pAlloc_opaque, pRead_buf);
6785 }
6786
6787 if (!(level_and_flags & MZ_ZIP_FLAG_WRITE_HEADER_SET_SIZE))
6788 {
6789 mz_uint8 local_dir_footer[MZ_ZIP_DATA_DESCRIPTER_SIZE64];
6790 mz_uint32 local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE32;
6791
6792 MZ_WRITE_LE32(local_dir_footer + 0, MZ_ZIP_DATA_DESCRIPTOR_ID);
6793 MZ_WRITE_LE32(local_dir_footer + 4, uncomp_crc32);
6794 if (pExtra_data == NULL)
6795 {
6796 if (comp_size > MZ_UINT32_MAX)
6798
6799 MZ_WRITE_LE32(local_dir_footer + 8, comp_size);
6800 MZ_WRITE_LE32(local_dir_footer + 12, uncomp_size);
6801 }
6802 else
6803 {
6804 MZ_WRITE_LE64(local_dir_footer + 8, comp_size);
6805 MZ_WRITE_LE64(local_dir_footer + 16, uncomp_size);
6806 local_dir_footer_size = MZ_ZIP_DATA_DESCRIPTER_SIZE64;
6807 }
6808
6809 if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_file_ofs, local_dir_footer, local_dir_footer_size) != local_dir_footer_size)
6810 return MZ_FALSE;
6811
6812 cur_archive_file_ofs += local_dir_footer_size;
6813 }
6814
6815 if (level_and_flags & MZ_ZIP_FLAG_WRITE_HEADER_SET_SIZE)
6816 {
6817 if (pExtra_data != NULL)
6818 {
6819 extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (max_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL,
6820 (max_size >= MZ_UINT32_MAX) ? &comp_size : NULL, (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL);
6821 }
6822
6823 if (!mz_zip_writer_create_local_dir_header(pZip, local_dir_header,
6824 (mz_uint16)archive_name_size, (mz_uint16)(extra_size + user_extra_data_len),
6825 (max_size >= MZ_UINT32_MAX) ? MZ_UINT32_MAX : uncomp_size,
6826 (max_size >= MZ_UINT32_MAX) ? MZ_UINT32_MAX : comp_size,
6827 uncomp_crc32, method, gen_flags, dos_time, dos_date))
6829
6830 cur_archive_header_file_ofs = local_dir_header_ofs;
6831
6832 if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_header_file_ofs, local_dir_header, sizeof(local_dir_header)) != sizeof(local_dir_header))
6834
6835 if (pExtra_data != NULL)
6836 {
6837 cur_archive_header_file_ofs += sizeof(local_dir_header);
6838
6839 if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_header_file_ofs, pArchive_name, archive_name_size) != archive_name_size)
6840 {
6842 }
6843
6844 cur_archive_header_file_ofs += archive_name_size;
6845
6846 if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_archive_header_file_ofs, extra_data, extra_size) != extra_size)
6848
6849 cur_archive_header_file_ofs += extra_size;
6850 }
6851 }
6852
6853 if (pExtra_data != NULL)
6854 {
6855 extra_size = mz_zip_writer_create_zip64_extra_data(extra_data, (uncomp_size >= MZ_UINT32_MAX) ? &uncomp_size : NULL,
6856 (uncomp_size >= MZ_UINT32_MAX) ? &comp_size : NULL, (local_dir_header_ofs >= MZ_UINT32_MAX) ? &local_dir_header_ofs : NULL);
6857 }
6858
6859 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,
6860 uncomp_size, comp_size, uncomp_crc32, method, gen_flags, dos_time, dos_date, local_dir_header_ofs, ext_attributes,
6861 user_extra_data_central, user_extra_data_central_len))
6862 return MZ_FALSE;
6863
6864 pZip->m_total_files++;
6865 pZip->m_archive_size = cur_archive_file_ofs;
6866
6867 return MZ_TRUE;
6868}

References mz_zip_archive::m_archive_size, mz_zip_internal_state_tag::m_central_dir, mz_zip_writer_add_state::m_comp_size, mz_zip_writer_add_state::m_cur_archive_file_ofs, mz_zip_archive::m_file_offset_alignment, mz_zip_archive::m_pAlloc, mz_zip_archive::m_pAlloc_opaque, mz_zip_archive::m_pFree, mz_zip_archive::m_pIO_opaque, mz_zip_archive::m_pNeeds_keepalive, mz_zip_archive::m_pState, mz_zip_archive::m_pWrite, mz_zip_writer_add_state::m_pZip, mz_zip_array::m_size, mz_zip_archive::m_total_files, mz_zip_internal_state_tag::m_zip64, mz_zip_archive::m_zip_mode, MZ_ASSERT, MZ_CLEAR_ARR, mz_crc32(), MZ_CRC32_INIT, MZ_DEFAULT_LEVEL, MZ_DEFAULT_STRATEGY, MZ_DEFLATED, MZ_FALSE, MZ_TRUE, MZ_UBER_COMPRESSION, MZ_UINT16_MAX, MZ_UINT32_MAX, MZ_WRITE_LE32, MZ_WRITE_LE64, MZ_ZIP64_MAX_CENTRAL_EXTRA_FIELD_SIZE, MZ_ZIP_ALLOC_FAILED, MZ_ZIP_ARCHIVE_TOO_LARGE, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, MZ_ZIP_COMPRESSION_FAILED, MZ_ZIP_DATA_DESCRIPTER_SIZE32, MZ_ZIP_DATA_DESCRIPTER_SIZE64, MZ_ZIP_DATA_DESCRIPTOR_ID, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE, MZ_ZIP_FILE_READ_FAILED, MZ_ZIP_FILE_WRITE_FAILED, MZ_ZIP_FLAG_ASCII_FILENAME, MZ_ZIP_FLAG_COMPRESSED_DATA, MZ_ZIP_FLAG_WRITE_HEADER_SET_SIZE, MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8, MZ_ZIP_INTERNAL_ERROR, MZ_ZIP_INVALID_FILENAME, MZ_ZIP_INVALID_PARAMETER, MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR, MZ_ZIP_LOCAL_DIR_HEADER_SIZE, MZ_ZIP_MAX_IO_BUF_SIZE, MZ_ZIP_MODE_WRITING, mz_zip_set_error(), mz_zip_time_t_to_dos_time(), MZ_ZIP_TOO_MANY_FILES, MZ_ZIP_UNSUPPORTED_CDIR_SIZE, mz_zip_writer_add_put_buf_callback(), mz_zip_writer_add_to_central_dir(), mz_zip_writer_compute_padding_needed_for_file_alignment(), mz_zip_writer_create_local_dir_header(), mz_zip_writer_create_zip64_extra_data(), mz_zip_writer_validate_archive_name(), mz_zip_writer_write_zeros(), tdefl_compress_buffer(), tdefl_create_comp_flags_from_zip_params(), TDEFL_FINISH, TDEFL_FULL_FLUSH, tdefl_init(), TDEFL_NO_FLUSH, TDEFL_STATUS_DONE, and TDEFL_STATUS_OKAY.

Referenced by mz_zip_writer_add_cfile().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_zip_writer_end()

MINIZ_EXPORT mz_bool mz_zip_writer_end ( mz_zip_archive * pZip)

Definition at line 7477 of file miniz.c.

7478{
7479 return mz_zip_writer_end_internal(pZip, MZ_TRUE);
7480}

References MZ_TRUE, and mz_zip_writer_end_internal().

Referenced by mz_zip_end(), and mz_zip_writer_init_file_v2().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_zip_writer_finalize_archive()

MINIZ_EXPORT mz_bool mz_zip_writer_finalize_archive ( mz_zip_archive * pZip)

Definition at line 7364 of file miniz.c.

7365{
7366 mz_zip_internal_state *pState;
7367 mz_uint64 central_dir_ofs, central_dir_size;
7368 mz_uint8 hdr[256];
7369
7370 if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_WRITING))
7372
7373 pState = pZip->m_pState;
7374
7375 if (pState->m_zip64)
7376 {
7379 }
7380 else
7381 {
7384 }
7385
7386 central_dir_ofs = 0;
7387 central_dir_size = 0;
7388 if (pZip->m_total_files)
7389 {
7390 /* Write central directory */
7391 central_dir_ofs = pZip->m_archive_size;
7392 central_dir_size = pState->m_central_dir.m_size;
7393 pZip->m_central_directory_file_ofs = central_dir_ofs;
7394 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)
7396
7397 pZip->m_archive_size += central_dir_size;
7398 }
7399
7400 if (pState->m_zip64)
7401 {
7402 /* Write zip64 end of central directory header */
7403 mz_uint64 rel_ofs_to_zip64_ecdr = pZip->m_archive_size;
7404
7405 MZ_CLEAR_ARR(hdr);
7408 MZ_WRITE_LE16(hdr + MZ_ZIP64_ECDH_VERSION_MADE_BY_OFS, 0x031E); /* TODO: always Unix */
7412 MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_CDIR_SIZE_OFS, central_dir_size);
7413 MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDH_CDIR_OFS_OFS, central_dir_ofs);
7416
7418
7419 /* Write zip64 end of central directory locator */
7420 MZ_CLEAR_ARR(hdr);
7422 MZ_WRITE_LE64(hdr + MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS, rel_ofs_to_zip64_ecdr);
7426
7428 }
7429
7430 /* Write end of central directory record */
7431 MZ_CLEAR_ARR(hdr);
7437
7440
7441#ifndef MINIZ_NO_STDIO
7442 if ((pState->m_pFile) && (MZ_FFLUSH(pState->m_pFile) == EOF))
7444#endif /* #ifndef MINIZ_NO_STDIO */
7445
7447
7449 return MZ_TRUE;
7450}
@ MZ_ZIP64_ECDH_VERSION_MADE_BY_OFS
Definition miniz.c:3303
@ MZ_ZIP64_ECDH_SIG_OFS
Definition miniz.c:3301
@ MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG
Definition miniz.c:3242
@ MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS
Definition miniz.c:3288
@ MZ_ZIP_ECDH_CDIR_SIZE_OFS
Definition miniz.c:3290
@ MZ_ZIP64_ECDL_SIG_OFS
Definition miniz.c:3295
@ MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE
Definition miniz.c:3245
@ MZ_ZIP64_ECDH_VERSION_NEEDED_OFS
Definition miniz.c:3304
@ MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS
Definition miniz.c:3297
@ MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS
Definition miniz.c:3307
@ MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS
Definition miniz.c:3289
@ MZ_ZIP_ECDH_SIG_OFS
Definition miniz.c:3285
@ MZ_ZIP64_ECDH_CDIR_SIZE_OFS
Definition miniz.c:3309
@ MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS
Definition miniz.c:3298
@ MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG
Definition miniz.c:3234
@ MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS
Definition miniz.c:3308
@ MZ_ZIP_ECDH_CDIR_OFS_OFS
Definition miniz.c:3291
@ MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG
Definition miniz.c:3243
@ MZ_ZIP64_ECDH_CDIR_OFS_OFS
Definition miniz.c:3310
@ MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE
Definition miniz.c:3244
@ MZ_ZIP64_ECDH_SIZE_OF_RECORD_OFS
Definition miniz.c:3302
#define MZ_FFLUSH
Definition miniz.c:3222
mz_uint64 m_central_directory_file_ofs
Definition miniz.h:1130

References mz_zip_archive::m_archive_size, mz_zip_internal_state_tag::m_central_dir, mz_zip_archive::m_central_directory_file_ofs, mz_zip_array::m_p, mz_zip_internal_state_tag::m_pFile, mz_zip_archive::m_pIO_opaque, mz_zip_archive::m_pState, mz_zip_archive::m_pWrite, mz_zip_array::m_size, mz_zip_archive::m_total_files, mz_zip_internal_state_tag::m_zip64, mz_zip_archive::m_zip_mode, MZ_CLEAR_ARR, MZ_FFLUSH, MZ_MIN, MZ_TRUE, MZ_UINT16_MAX, MZ_UINT32_MAX, MZ_WRITE_LE16, MZ_WRITE_LE32, MZ_WRITE_LE64, MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS, MZ_ZIP64_ECDH_CDIR_OFS_OFS, MZ_ZIP64_ECDH_CDIR_SIZE_OFS, MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS, MZ_ZIP64_ECDH_SIG_OFS, MZ_ZIP64_ECDH_SIZE_OF_RECORD_OFS, MZ_ZIP64_ECDH_VERSION_MADE_BY_OFS, MZ_ZIP64_ECDH_VERSION_NEEDED_OFS, MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS, MZ_ZIP64_ECDL_SIG_OFS, MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS, MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG, MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE, MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG, MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE, MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS, MZ_ZIP_ECDH_CDIR_OFS_OFS, MZ_ZIP_ECDH_CDIR_SIZE_OFS, MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS, MZ_ZIP_ECDH_SIG_OFS, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE, MZ_ZIP_FILE_CLOSE_FAILED, MZ_ZIP_FILE_WRITE_FAILED, MZ_ZIP_INVALID_PARAMETER, MZ_ZIP_MODE_WRITING, MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED, mz_zip_set_error(), and MZ_ZIP_TOO_MANY_FILES.

Referenced by mz_zip_add_mem_to_archive_file_in_place_v2(), and mz_zip_writer_finalize_heap_archive().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_zip_writer_finalize_heap_archive()

MINIZ_EXPORT mz_bool mz_zip_writer_finalize_heap_archive ( mz_zip_archive * pZip,
void ** ppBuf,
size_t * pSize )

Definition at line 7452 of file miniz.c.

7453{
7454 if ((!ppBuf) || (!pSize))
7456
7457 *ppBuf = NULL;
7458 *pSize = 0;
7459
7460 if ((!pZip) || (!pZip->m_pState))
7462
7463 if (pZip->m_pWrite != mz_zip_heap_write_func)
7465
7467 return MZ_FALSE;
7468
7469 *ppBuf = pZip->m_pState->m_pMem;
7470 *pSize = pZip->m_pState->m_mem_size;
7471 pZip->m_pState->m_pMem = NULL;
7472 pZip->m_pState->m_mem_size = pZip->m_pState->m_mem_capacity = 0;
7473
7474 return MZ_TRUE;
7475}
static size_t mz_zip_heap_write_func(void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n)
Definition miniz.c:5685

References mz_zip_internal_state_tag::m_mem_capacity, mz_zip_internal_state_tag::m_mem_size, mz_zip_internal_state_tag::m_pMem, mz_zip_archive::m_pState, mz_zip_archive::m_pWrite, MZ_FALSE, MZ_TRUE, mz_zip_heap_write_func(), MZ_ZIP_INVALID_PARAMETER, mz_zip_set_error(), and mz_zip_writer_finalize_archive().

+ Here is the call graph for this function:

◆ mz_zip_writer_init()

MINIZ_EXPORT mz_bool mz_zip_writer_init ( mz_zip_archive * pZip,
mz_uint64 existing_size )

Definition at line 5818 of file miniz.c.

5819{
5820 return mz_zip_writer_init_v2(pZip, existing_size, 0);
5821}
mz_bool mz_zip_writer_init_v2(mz_zip_archive *pZip, mz_uint64 existing_size, mz_uint flags)
Definition miniz.c:5769

References mz_zip_writer_init_v2().

+ Here is the call graph for this function:

◆ mz_zip_writer_init_cfile()

MINIZ_EXPORT mz_bool mz_zip_writer_init_cfile ( mz_zip_archive * pZip,
MZ_FILE * pFile,
mz_uint flags )

Definition at line 5925 of file miniz.c.

5926{
5928 pZip->m_pNeeds_keepalive = NULL;
5929
5932
5933 pZip->m_pIO_opaque = pZip;
5934
5935 if (!mz_zip_writer_init_v2(pZip, 0, flags))
5936 return MZ_FALSE;
5937
5938 pZip->m_pState->m_pFile = pFile;
5941
5942 return MZ_TRUE;
5943}
static size_t mz_zip_file_write_func(void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n)
Definition miniz.c:5857

References mz_zip_internal_state_tag::m_file_archive_start_ofs, mz_zip_internal_state_tag::m_pFile, mz_zip_archive::m_pIO_opaque, mz_zip_archive::m_pNeeds_keepalive, mz_zip_archive::m_pRead, mz_zip_archive::m_pState, mz_zip_archive::m_pWrite, mz_zip_archive::m_zip_type, MZ_FALSE, MZ_FTELL64, MZ_TRUE, mz_zip_file_read_func(), mz_zip_file_write_func(), MZ_ZIP_FLAG_WRITE_ALLOW_READING, MZ_ZIP_TYPE_CFILE, and mz_zip_writer_init_v2().

+ Here is the call graph for this function:

◆ mz_zip_writer_init_file()

MINIZ_EXPORT mz_bool mz_zip_writer_init_file ( mz_zip_archive * pZip,
const char * pFilename,
mz_uint64 size_to_reserve_at_beginning )

Definition at line 5873 of file miniz.c.

5874{
5875 return mz_zip_writer_init_file_v2(pZip, pFilename, size_to_reserve_at_beginning, 0);
5876}

References mz_zip_writer_init_file_v2().

+ Here is the call graph for this function:

◆ mz_zip_writer_init_file_v2()

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 )

Definition at line 5878 of file miniz.c.

5879{
5880 MZ_FILE *pFile;
5881
5883 pZip->m_pNeeds_keepalive = NULL;
5884
5887
5888 pZip->m_pIO_opaque = pZip;
5889
5890 if (!mz_zip_writer_init_v2(pZip, size_to_reserve_at_beginning, flags))
5891 return MZ_FALSE;
5892
5893 if (NULL == (pFile = MZ_FOPEN(pFilename, (flags & MZ_ZIP_FLAG_WRITE_ALLOW_READING) ? "w+b" : "wb")))
5894 {
5895 mz_zip_writer_end(pZip);
5897 }
5898
5899 pZip->m_pState->m_pFile = pFile;
5901
5902 if (size_to_reserve_at_beginning)
5903 {
5904 mz_uint64 cur_ofs = 0;
5905 char buf[4096];
5906
5908
5909 do
5910 {
5911 size_t n = (size_t)MZ_MIN(sizeof(buf), size_to_reserve_at_beginning);
5912 if (pZip->m_pWrite(pZip->m_pIO_opaque, cur_ofs, buf, n) != n)
5913 {
5914 mz_zip_writer_end(pZip);
5916 }
5917 cur_ofs += n;
5918 size_to_reserve_at_beginning -= n;
5919 } while (size_to_reserve_at_beginning);
5920 }
5921
5922 return MZ_TRUE;
5923}
voidpf void * buf
Definition ioapi.h:134

References mz_zip_internal_state_tag::m_pFile, mz_zip_archive::m_pIO_opaque, mz_zip_archive::m_pNeeds_keepalive, mz_zip_archive::m_pRead, mz_zip_archive::m_pState, mz_zip_archive::m_pWrite, mz_zip_archive::m_zip_type, MZ_CLEAR_ARR, MZ_FALSE, MZ_FILE, MZ_FOPEN, MZ_MIN, MZ_TRUE, MZ_ZIP_FILE_OPEN_FAILED, mz_zip_file_read_func(), MZ_ZIP_FILE_WRITE_FAILED, mz_zip_file_write_func(), MZ_ZIP_FLAG_WRITE_ALLOW_READING, mz_zip_set_error(), MZ_ZIP_TYPE_FILE, mz_zip_writer_end(), and mz_zip_writer_init_v2().

Referenced by mz_zip_add_mem_to_archive_file_in_place_v2(), and mz_zip_writer_init_file().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_zip_writer_init_from_reader()

MINIZ_EXPORT mz_bool mz_zip_writer_init_from_reader ( mz_zip_archive * pZip,
const char * pFilename )

Definition at line 6033 of file miniz.c.

6034{
6035 return mz_zip_writer_init_from_reader_v2(pZip, pFilename, 0);
6036}

References mz_zip_writer_init_from_reader_v2().

+ Here is the call graph for this function:

◆ mz_zip_writer_init_from_reader_v2()

MINIZ_EXPORT mz_bool mz_zip_writer_init_from_reader_v2 ( mz_zip_archive * pZip,
const char * pFilename,
mz_uint flags )

Definition at line 5946 of file miniz.c.

5947{
5948 mz_zip_internal_state *pState;
5949
5950 if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_READING))
5952
5953 if (flags & MZ_ZIP_FLAG_WRITE_ZIP64)
5954 {
5955 /* 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?) */
5956 if (!pZip->m_pState->m_zip64)
5958 }
5959
5960 /* No sense in trying to write to an archive that's already at the support max size */
5961 if (pZip->m_pState->m_zip64)
5962 {
5963 if (pZip->m_total_files == MZ_UINT32_MAX)
5965 }
5966 else
5967 {
5968 if (pZip->m_total_files == MZ_UINT16_MAX)
5970
5973 }
5974
5975 pState = pZip->m_pState;
5976
5977 if (pState->m_pFile)
5978 {
5979#ifdef MINIZ_NO_STDIO
5980 (void)pFilename;
5982#else
5983 if (pZip->m_pIO_opaque != pZip)
5985
5986 if (pZip->m_zip_type == MZ_ZIP_TYPE_FILE)
5987 {
5988 if (!pFilename)
5990
5991 /* Archive is being read from stdio and was originally opened only for reading. Try to reopen as writable. */
5992 if (NULL == (pState->m_pFile = MZ_FREOPEN(pFilename, "r+b", pState->m_pFile)))
5993 {
5994 /* The mz_zip_archive is now in a bogus state because pState->m_pFile is NULL, so just close it. */
5997 }
5998 }
5999
6001 pZip->m_pNeeds_keepalive = NULL;
6002#endif /* #ifdef MINIZ_NO_STDIO */
6003 }
6004 else if (pState->m_pMem)
6005 {
6006 /* Archive lives in a memory block. Assume it's from the heap that we can resize using the realloc callback. */
6007 if (pZip->m_pIO_opaque != pZip)
6009
6010 pState->m_mem_capacity = pState->m_mem_size;
6012 pZip->m_pNeeds_keepalive = NULL;
6013 }
6014 /* Archive is being read via a user provided read function - make sure the user has specified a write function too. */
6015 else if (!pZip->m_pWrite)
6017
6018 /* Start writing new files at the archive's current central directory location. */
6019 /* TODO: We could add a flag that lets the user start writing immediately AFTER the existing central dir - this would be safer. */
6022
6023 /* Clear the sorted central dir offsets, they aren't useful or maintained now. */
6024 /* Even though we're now in write mode, files can still be extracted and verified, but file locates will be slow. */
6025 /* TODO: We could easily maintain the sorted central directory offsets. */
6027
6029
6030 return MZ_TRUE;
6031}
#define MZ_FREOPEN(f, m, s)
Definition miniz.c:3223

References mz_zip_archive::m_archive_size, mz_zip_archive::m_central_directory_file_ofs, mz_zip_internal_state_tag::m_mem_capacity, mz_zip_internal_state_tag::m_mem_size, mz_zip_internal_state_tag::m_pFile, mz_zip_archive::m_pIO_opaque, mz_zip_internal_state_tag::m_pMem, mz_zip_archive::m_pNeeds_keepalive, mz_zip_archive::m_pState, mz_zip_archive::m_pWrite, mz_zip_internal_state_tag::m_sorted_central_dir_offsets, mz_zip_archive::m_total_files, mz_zip_internal_state_tag::m_zip64, mz_zip_archive::m_zip_mode, mz_zip_archive::m_zip_type, MZ_FALSE, MZ_FREOPEN, MZ_TRUE, MZ_UINT16_MAX, MZ_UINT32_MAX, mz_zip_array_clear(), MZ_ZIP_CENTRAL_DIR_HEADER_SIZE, MZ_ZIP_FILE_OPEN_FAILED, MZ_ZIP_FILE_TOO_LARGE, mz_zip_file_write_func(), MZ_ZIP_FLAG_WRITE_ZIP64, mz_zip_heap_write_func(), MZ_ZIP_INVALID_PARAMETER, MZ_ZIP_LOCAL_DIR_HEADER_SIZE, MZ_ZIP_MODE_READING, MZ_ZIP_MODE_WRITING, mz_zip_reader_end_internal(), mz_zip_set_error(), MZ_ZIP_TOO_MANY_FILES, and MZ_ZIP_TYPE_FILE.

Referenced by mz_zip_add_mem_to_archive_file_in_place_v2(), and mz_zip_writer_init_from_reader().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_zip_writer_init_heap()

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 )

Definition at line 5851 of file miniz.c.

5852{
5853 return mz_zip_writer_init_heap_v2(pZip, size_to_reserve_at_beginning, initial_allocation_size, 0);
5854}
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)
Definition miniz.c:5823

References mz_zip_writer_init_heap_v2().

+ Here is the call graph for this function:

◆ mz_zip_writer_init_heap_v2()

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 )

Definition at line 5823 of file miniz.c.

5824{
5826 pZip->m_pNeeds_keepalive = NULL;
5827
5830
5831 pZip->m_pIO_opaque = pZip;
5832
5833 if (!mz_zip_writer_init_v2(pZip, size_to_reserve_at_beginning, flags))
5834 return MZ_FALSE;
5835
5837
5838 if (0 != (initial_allocation_size = MZ_MAX(initial_allocation_size, size_to_reserve_at_beginning)))
5839 {
5840 if (NULL == (pZip->m_pState->m_pMem = pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, initial_allocation_size)))
5841 {
5844 }
5845 pZip->m_pState->m_mem_capacity = initial_allocation_size;
5846 }
5847
5848 return MZ_TRUE;
5849}

References mz_zip_internal_state_tag::m_mem_capacity, mz_zip_archive::m_pAlloc, mz_zip_archive::m_pAlloc_opaque, mz_zip_archive::m_pIO_opaque, mz_zip_internal_state_tag::m_pMem, mz_zip_archive::m_pNeeds_keepalive, mz_zip_archive::m_pRead, mz_zip_archive::m_pState, mz_zip_archive::m_pWrite, mz_zip_archive::m_zip_type, MZ_FALSE, MZ_MAX, MZ_TRUE, MZ_ZIP_ALLOC_FAILED, MZ_ZIP_FLAG_WRITE_ALLOW_READING, mz_zip_heap_write_func(), mz_zip_mem_read_func(), mz_zip_set_error(), MZ_ZIP_TYPE_HEAP, mz_zip_writer_end_internal(), and mz_zip_writer_init_v2().

Referenced by mz_zip_writer_init_heap().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_zip_writer_init_v2()

MINIZ_EXPORT mz_bool mz_zip_writer_init_v2 ( mz_zip_archive * pZip,
mz_uint64 existing_size,
mz_uint flags )

Definition at line 5769 of file miniz.c.

5770{
5771 mz_bool zip64 = (flags & MZ_ZIP_FLAG_WRITE_ZIP64) != 0;
5772
5773 if ((!pZip) || (pZip->m_pState) || (!pZip->m_pWrite) || (pZip->m_zip_mode != MZ_ZIP_MODE_INVALID))
5775
5777 {
5778 if (!pZip->m_pRead)
5780 }
5781
5782 if (pZip->m_file_offset_alignment)
5783 {
5784 /* Ensure user specified file offset alignment is a power of 2. */
5785 if (pZip->m_file_offset_alignment & (pZip->m_file_offset_alignment - 1))
5787 }
5788
5789 if (!pZip->m_pAlloc)
5791 if (!pZip->m_pFree)
5793 if (!pZip->m_pRealloc)
5795
5796 pZip->m_archive_size = existing_size;
5798 pZip->m_total_files = 0;
5799
5800 if (NULL == (pZip->m_pState = (mz_zip_internal_state *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(mz_zip_internal_state))))
5802
5803 memset(pZip->m_pState, 0, sizeof(mz_zip_internal_state));
5804
5808
5809 pZip->m_pState->m_zip64 = zip64;
5811
5814
5815 return MZ_TRUE;
5816}
#define MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(array_ptr, element_size)
Definition miniz.c:3351
MINIZ_EXPORT void * miniz_def_realloc_func(void *opaque, void *address, size_t items, size_t size)
Definition miniz.c:178
mz_realloc_func m_pRealloc
Definition miniz.h:1142
mz_bool m_zip64_has_extended_info_fields
Definition miniz.c:3340

References mz_zip_archive::m_archive_size, mz_zip_internal_state_tag::m_central_dir, mz_zip_internal_state_tag::m_central_dir_offsets, mz_zip_archive::m_central_directory_file_ofs, mz_zip_archive::m_file_offset_alignment, mz_zip_archive::m_pAlloc, mz_zip_archive::m_pAlloc_opaque, mz_zip_archive::m_pFree, mz_zip_archive::m_pRead, mz_zip_archive::m_pRealloc, mz_zip_archive::m_pState, mz_zip_archive::m_pWrite, mz_zip_internal_state_tag::m_sorted_central_dir_offsets, mz_zip_archive::m_total_files, mz_zip_internal_state_tag::m_zip64, mz_zip_internal_state_tag::m_zip64_has_extended_info_fields, mz_zip_archive::m_zip_mode, mz_zip_archive::m_zip_type, miniz_def_alloc_func(), miniz_def_free_func(), miniz_def_realloc_func(), MZ_TRUE, MZ_ZIP_ALLOC_FAILED, MZ_ZIP_ARRAY_SET_ELEMENT_SIZE, MZ_ZIP_FLAG_WRITE_ALLOW_READING, MZ_ZIP_FLAG_WRITE_ZIP64, MZ_ZIP_INVALID_PARAMETER, MZ_ZIP_MODE_INVALID, MZ_ZIP_MODE_WRITING, mz_zip_set_error(), and MZ_ZIP_TYPE_USER.

Referenced by mz_zip_writer_init(), mz_zip_writer_init_cfile(), mz_zip_writer_init_file_v2(), and mz_zip_writer_init_heap_v2().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ mz_zip_zero_struct()

MINIZ_EXPORT void mz_zip_zero_struct ( mz_zip_archive * pZip)

Definition at line 3918 of file miniz.c.

3919{
3920 if (pZip)
3921 MZ_CLEAR_PTR(pZip);
3922}
#define MZ_CLEAR_PTR(obj)
Definition miniz.h:598

References MZ_CLEAR_PTR.

Referenced by mz_zip_add_mem_to_archive_file_in_place_v2(), mz_zip_extract_archive_file_to_heap_v2(), mz_zip_validate_file_archive(), and mz_zip_validate_mem_archive().

+ Here is the caller graph for this function:

◆ tdefl_compress()

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 )

Definition at line 1919 of file miniz.c.

1920{
1921 if (!d)
1922 {
1923 if (pIn_buf_size)
1924 *pIn_buf_size = 0;
1925 if (pOut_buf_size)
1926 *pOut_buf_size = 0;
1928 }
1929
1930 d->m_pIn_buf = pIn_buf;
1931 d->m_pIn_buf_size = pIn_buf_size;
1932 d->m_pOut_buf = pOut_buf;
1933 d->m_pOut_buf_size = pOut_buf_size;
1934 d->m_pSrc = (const mz_uint8 *)(pIn_buf);
1935 d->m_src_buf_left = pIn_buf_size ? *pIn_buf_size : 0;
1936 d->m_out_buf_ofs = 0;
1937 d->m_flush = flush;
1938
1939 if (((d->m_pPut_buf_func != NULL) == ((pOut_buf != NULL) || (pOut_buf_size != NULL))) || (d->m_prev_return_status != TDEFL_STATUS_OKAY) ||
1940 (d->m_wants_to_finish && (flush != TDEFL_FINISH)) || (pIn_buf_size && *pIn_buf_size && !pIn_buf) || (pOut_buf_size && *pOut_buf_size && !pOut_buf))
1941 {
1942 if (pIn_buf_size)
1943 *pIn_buf_size = 0;
1944 if (pOut_buf_size)
1945 *pOut_buf_size = 0;
1947 }
1948 d->m_wants_to_finish |= (flush == TDEFL_FINISH);
1949
1950 if ((d->m_output_flush_remaining) || (d->m_finished))
1952
1953#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN
1954 if (((d->m_flags & TDEFL_MAX_PROBES_MASK) == 1) &&
1955 ((d->m_flags & TDEFL_GREEDY_PARSING_FLAG) != 0) &&
1957 {
1958 if (!tdefl_compress_fast(d))
1959 return d->m_prev_return_status;
1960 }
1961 else
1962#endif /* #if MINIZ_USE_UNALIGNED_LOADS_AND_STORES && MINIZ_LITTLE_ENDIAN */
1963 {
1964 if (!tdefl_compress_normal(d))
1965 return d->m_prev_return_status;
1966 }
1967
1968 if ((d->m_flags & (TDEFL_WRITE_ZLIB_HEADER | TDEFL_COMPUTE_ADLER32)) && (pIn_buf))
1969 d->m_adler32 = (mz_uint32)mz_adler32(d->m_adler32, (const mz_uint8 *)pIn_buf, d->m_pSrc - (const mz_uint8 *)pIn_buf);
1970
1971 if ((flush) && (!d->m_lookahead_size) && (!d->m_src_buf_left) && (!d->m_output_flush_remaining))
1972 {
1973 if (tdefl_flush_block(d, flush) < 0)
1974 return d->m_prev_return_status;
1975 d->m_finished = (flush == TDEFL_FINISH);
1976 if (flush == TDEFL_FULL_FLUSH)
1977 {
1978 MZ_CLEAR_ARR(d->m_hash);
1979 MZ_CLEAR_ARR(d->m_next);
1980 d->m_dict_size = 0;
1981 }
1982 }
1983
1985}
mz_ulong mz_adler32(mz_ulong adler, const unsigned char *ptr, size_t buf_len)
Definition miniz.c:41
static int tdefl_flush_block(tdefl_compressor *d, int flush)
Definition miniz.c:1257
static mz_bool tdefl_compress_normal(tdefl_compressor *d)
Definition miniz.c:1753
static tdefl_status tdefl_flush_output_buffer(tdefl_compressor *d)
Definition miniz.c:1898
size_t * m_pOut_buf_size
Definition miniz.h:776
mz_uint16 m_hash[TDEFL_LZ_HASH_SIZE]
Definition miniz.h:786
const mz_uint8 * m_pSrc
Definition miniz.h:778
mz_uint m_output_flush_remaining
Definition miniz.h:772
mz_uint m_wants_to_finish
Definition miniz.h:772
mz_uint m_finished
Definition miniz.h:772
size_t m_src_buf_left
Definition miniz.h:779
tdefl_status m_prev_return_status
Definition miniz.h:773
tdefl_put_buf_func_ptr m_pPut_buf_func
Definition miniz.h:765
tdefl_flush m_flush
Definition miniz.h:777
size_t m_out_buf_ofs
Definition miniz.h:779
mz_uint16 m_next[TDEFL_LZ_DICT_SIZE]
Definition miniz.h:785
mz_uint m_lookahead_size
Definition miniz.h:769
void * m_pOut_buf
Definition miniz.h:775
const void * m_pIn_buf
Definition miniz.h:774
mz_uint m_flags
Definition miniz.h:767
mz_uint m_dict_size
Definition miniz.h:769
size_t * m_pIn_buf_size
Definition miniz.h:776
mz_uint m_adler32
Definition miniz.h:769

References tdefl_compressor::m_adler32, tdefl_compressor::m_dict_size, tdefl_compressor::m_finished, tdefl_compressor::m_flags, tdefl_compressor::m_flush, tdefl_compressor::m_hash, tdefl_compressor::m_lookahead_size, tdefl_compressor::m_next, tdefl_compressor::m_out_buf_ofs, tdefl_compressor::m_output_flush_remaining, tdefl_compressor::m_pIn_buf, tdefl_compressor::m_pIn_buf_size, tdefl_compressor::m_pOut_buf, tdefl_compressor::m_pOut_buf_size, tdefl_compressor::m_pPut_buf_func, tdefl_compressor::m_prev_return_status, tdefl_compressor::m_pSrc, tdefl_compressor::m_src_buf_left, tdefl_compressor::m_wants_to_finish, mz_adler32(), MZ_CLEAR_ARR, tdefl_compress_normal(), TDEFL_COMPUTE_ADLER32, TDEFL_FILTER_MATCHES, TDEFL_FINISH, tdefl_flush_block(), tdefl_flush_output_buffer(), TDEFL_FORCE_ALL_RAW_BLOCKS, TDEFL_FULL_FLUSH, TDEFL_GREEDY_PARSING_FLAG, TDEFL_MAX_PROBES_MASK, TDEFL_RLE_MATCHES, TDEFL_STATUS_BAD_PARAM, TDEFL_STATUS_OKAY, and TDEFL_WRITE_ZLIB_HEADER.

Referenced by mz_deflate(), and tdefl_compress_buffer().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ tdefl_compress_buffer()

MINIZ_EXPORT tdefl_status tdefl_compress_buffer ( tdefl_compressor * d,
const void * pIn_buf,
size_t in_buf_size,
tdefl_flush flush )

Definition at line 1987 of file miniz.c.

1988{
1990 return tdefl_compress(d, pIn_buf, &in_buf_size, NULL, NULL, flush);
1991}

References tdefl_compressor::m_pPut_buf_func, MZ_ASSERT, and tdefl_compress().

Referenced by mz_zip_writer_add_mem_ex_v2(), mz_zip_writer_add_read_buf_callback(), tdefl_compress_mem_to_output(), and tdefl_write_image_to_png_file_in_memory_ex().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ tdefl_compress_mem_to_heap()

MINIZ_EXPORT void * tdefl_compress_mem_to_heap ( const void * pSrc_buf,
size_t src_buf_len,
size_t * pOut_len,
int flags )

Definition at line 2086 of file miniz.c.

2087{
2088 tdefl_output_buffer out_buf;
2089 MZ_CLEAR_OBJ(out_buf);
2090 if (!pOut_len)
2091 return MZ_FALSE;
2092 else
2093 *pOut_len = 0;
2094 out_buf.m_expandable = MZ_TRUE;
2095 if (!tdefl_compress_mem_to_output(pSrc_buf, src_buf_len, tdefl_output_buffer_putter, &out_buf, flags))
2096 return NULL;
2097 *pOut_len = out_buf.m_size;
2098 return out_buf.m_pBuf;
2099}
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)
Definition miniz.c:2039
static mz_bool tdefl_output_buffer_putter(const void *pBuf, int len, void *pUser)
Definition miniz.c:2061
#define MZ_CLEAR_OBJ(obj)
Definition miniz.h:596
mz_bool m_expandable
Definition miniz.c:2058
mz_uint8 * m_pBuf
Definition miniz.c:2057

References tdefl_output_buffer::m_expandable, tdefl_output_buffer::m_pBuf, tdefl_output_buffer::m_size, MZ_CLEAR_OBJ, MZ_FALSE, MZ_TRUE, tdefl_compress_mem_to_output(), and tdefl_output_buffer_putter().

+ Here is the call graph for this function:

◆ tdefl_compress_mem_to_mem()

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 )

Definition at line 2101 of file miniz.c.

2102{
2103 tdefl_output_buffer out_buf;
2104 MZ_CLEAR_OBJ(out_buf);
2105 if (!pOut_buf)
2106 return 0;
2107 out_buf.m_pBuf = (mz_uint8 *)pOut_buf;
2108 out_buf.m_capacity = out_buf_len;
2109 if (!tdefl_compress_mem_to_output(pSrc_buf, src_buf_len, tdefl_output_buffer_putter, &out_buf, flags))
2110 return 0;
2111 return out_buf.m_size;
2112}

References tdefl_output_buffer::m_capacity, tdefl_output_buffer::m_pBuf, tdefl_output_buffer::m_size, MZ_CLEAR_OBJ, tdefl_compress_mem_to_output(), and tdefl_output_buffer_putter().

+ Here is the call graph for this function:

◆ tdefl_compress_mem_to_output()

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 )

Definition at line 2039 of file miniz.c.

2040{
2041 tdefl_compressor *pComp;
2042 mz_bool succeeded;
2043 if (((buf_len) && (!pBuf)) || (!pPut_buf_func))
2044 return MZ_FALSE;
2045 pComp = (tdefl_compressor *)MZ_MALLOC(sizeof(tdefl_compressor));
2046 if (!pComp)
2047 return MZ_FALSE;
2048 succeeded = (tdefl_init(pComp, pPut_buf_func, pPut_buf_user, flags) == TDEFL_STATUS_OKAY);
2049 succeeded = succeeded && (tdefl_compress_buffer(pComp, pBuf, buf_len, TDEFL_FINISH) == TDEFL_STATUS_DONE);
2050 MZ_FREE(pComp);
2051 return succeeded;
2052}

References MZ_FALSE, MZ_FREE, MZ_MALLOC, tdefl_compress_buffer(), TDEFL_FINISH, tdefl_init(), TDEFL_STATUS_DONE, and TDEFL_STATUS_OKAY.

Referenced by tdefl_compress_mem_to_heap(), and tdefl_compress_mem_to_mem().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ tdefl_compressor_alloc()

MINIZ_EXPORT tdefl_compressor * tdefl_compressor_alloc ( void )

Definition at line 2233 of file miniz.c.

2234{
2235 return (tdefl_compressor *)MZ_MALLOC(sizeof(tdefl_compressor));
2236}

References MZ_MALLOC.

◆ tdefl_compressor_free()

MINIZ_EXPORT void tdefl_compressor_free ( tdefl_compressor * pComp)

Definition at line 2238 of file miniz.c.

2239{
2240 MZ_FREE(pComp);
2241}

References MZ_FREE.

◆ tdefl_create_comp_flags_from_zip_params()

MINIZ_EXPORT mz_uint tdefl_create_comp_flags_from_zip_params ( int level,
int window_bits,
int strategy )

Definition at line 2117 of file miniz.c.

2118{
2119 mz_uint comp_flags = s_tdefl_num_probes[(level >= 0) ? MZ_MIN(10, level) : MZ_DEFAULT_LEVEL] | ((level <= 3) ? TDEFL_GREEDY_PARSING_FLAG : 0);
2120 if (window_bits > 0)
2121 comp_flags |= TDEFL_WRITE_ZLIB_HEADER;
2122
2123 if (!level)
2124 comp_flags |= TDEFL_FORCE_ALL_RAW_BLOCKS;
2125 else if (strategy == MZ_FILTERED)
2126 comp_flags |= TDEFL_FILTER_MATCHES;
2127 else if (strategy == MZ_HUFFMAN_ONLY)
2128 comp_flags &= ~TDEFL_MAX_PROBES_MASK;
2129 else if (strategy == MZ_FIXED)
2130 comp_flags |= TDEFL_FORCE_ALL_STATIC_BLOCKS;
2131 else if (strategy == MZ_RLE)
2132 comp_flags |= TDEFL_RLE_MATCHES;
2133
2134 return comp_flags;
2135}
static const mz_uint s_tdefl_num_probes[11]
Definition miniz.c:1255

References MZ_DEFAULT_LEVEL, MZ_FILTERED, MZ_FIXED, MZ_HUFFMAN_ONLY, MZ_MIN, MZ_RLE, s_tdefl_num_probes, TDEFL_FILTER_MATCHES, TDEFL_FORCE_ALL_RAW_BLOCKS, TDEFL_FORCE_ALL_STATIC_BLOCKS, TDEFL_GREEDY_PARSING_FLAG, TDEFL_RLE_MATCHES, and TDEFL_WRITE_ZLIB_HEADER.

Referenced by mz_deflateInit2(), mz_zip_writer_add_mem_ex_v2(), and mz_zip_writer_add_read_buf_callback().

+ Here is the caller graph for this function:

◆ tdefl_get_adler32()

MINIZ_EXPORT mz_uint32 tdefl_get_adler32 ( tdefl_compressor * d)

Definition at line 2034 of file miniz.c.

2035{
2036 return d->m_adler32;
2037}

References tdefl_compressor::m_adler32.

Referenced by mz_deflate().

+ Here is the caller graph for this function:

◆ tdefl_get_prev_return_status()

MINIZ_EXPORT tdefl_status tdefl_get_prev_return_status ( tdefl_compressor * d)

Definition at line 2029 of file miniz.c.

2030{
2031 return d->m_prev_return_status;
2032}

References tdefl_compressor::m_prev_return_status.

◆ tdefl_init()

MINIZ_EXPORT tdefl_status tdefl_init ( tdefl_compressor * d,
tdefl_put_buf_func_ptr pPut_buf_func,
void * pPut_buf_user,
int flags )

Definition at line 1993 of file miniz.c.

1994{
1995 d->m_pPut_buf_func = pPut_buf_func;
1996 d->m_pPut_buf_user = pPut_buf_user;
1997 d->m_flags = (mz_uint)(flags);
1998 d->m_max_probes[0] = 1 + ((flags & 0xFFF) + 2) / 3;
1999 d->m_greedy_parsing = (flags & TDEFL_GREEDY_PARSING_FLAG) != 0;
2000 d->m_max_probes[1] = 1 + (((flags & 0xFFF) >> 2) + 2) / 3;
2002 MZ_CLEAR_ARR(d->m_hash);
2005 d->m_pLZ_code_buf = d->m_lz_code_buf + 1;
2006 d->m_pLZ_flags = d->m_lz_code_buf;
2007 *d->m_pLZ_flags = 0;
2008 d->m_num_flags_left = 8;
2013 d->m_adler32 = 1;
2014 d->m_pIn_buf = NULL;
2015 d->m_pOut_buf = NULL;
2016 d->m_pIn_buf_size = NULL;
2017 d->m_pOut_buf_size = NULL;
2019 d->m_pSrc = NULL;
2020 d->m_src_buf_left = 0;
2021 d->m_out_buf_ofs = 0;
2023 MZ_CLEAR_ARR(d->m_dict);
2024 memset(&d->m_huff_count[0][0], 0, sizeof(d->m_huff_count[0][0]) * TDEFL_MAX_HUFF_SYMBOLS_0);
2025 memset(&d->m_huff_count[1][0], 0, sizeof(d->m_huff_count[1][0]) * TDEFL_MAX_HUFF_SYMBOLS_1);
2026 return TDEFL_STATUS_OKAY;
2027}
mz_uint m_max_probes[2]
Definition miniz.h:767
mz_uint m_block_index
Definition miniz.h:772
mz_uint m_saved_lit
Definition miniz.h:772
mz_uint m_saved_match_dist
Definition miniz.h:772
mz_uint m_num_flags_left
Definition miniz.h:771
mz_uint m_lookahead_pos
Definition miniz.h:769
mz_uint m_total_lz_bytes
Definition miniz.h:771
mz_uint8 m_dict[TDEFL_LZ_DICT_SIZE+TDEFL_MAX_MATCH_LEN - 1]
Definition miniz.h:780
mz_uint m_output_flush_ofs
Definition miniz.h:772
mz_uint m_bit_buffer
Definition miniz.h:771
mz_uint m_bits_in
Definition miniz.h:771
mz_uint8 * m_pOutput_buf_end
Definition miniz.h:770
mz_uint8 * m_pLZ_flags
Definition miniz.h:770
mz_uint m_saved_match_len
Definition miniz.h:772
mz_uint16 m_huff_count[TDEFL_MAX_HUFF_TABLES][TDEFL_MAX_HUFF_SYMBOLS]
Definition miniz.h:781
mz_uint m_lz_code_buf_dict_pos
Definition miniz.h:771
mz_uint8 m_lz_code_buf[TDEFL_LZ_CODE_BUF_SIZE]
Definition miniz.h:784
int m_greedy_parsing
Definition miniz.h:768
void * m_pPut_buf_user
Definition miniz.h:766
mz_uint8 * m_pLZ_code_buf
Definition miniz.h:770
mz_uint8 m_output_buf[TDEFL_OUT_BUF_SIZE]
Definition miniz.h:787
mz_uint8 * m_pOutput_buf
Definition miniz.h:770

References tdefl_compressor::m_adler32, tdefl_compressor::m_bit_buffer, tdefl_compressor::m_bits_in, tdefl_compressor::m_block_index, tdefl_compressor::m_dict, tdefl_compressor::m_dict_size, tdefl_compressor::m_finished, tdefl_compressor::m_flags, tdefl_compressor::m_flush, tdefl_compressor::m_greedy_parsing, tdefl_compressor::m_hash, tdefl_compressor::m_huff_count, tdefl_compressor::m_lookahead_pos, tdefl_compressor::m_lookahead_size, tdefl_compressor::m_lz_code_buf, tdefl_compressor::m_lz_code_buf_dict_pos, tdefl_compressor::m_max_probes, tdefl_compressor::m_num_flags_left, tdefl_compressor::m_out_buf_ofs, tdefl_compressor::m_output_buf, tdefl_compressor::m_output_flush_ofs, tdefl_compressor::m_output_flush_remaining, tdefl_compressor::m_pIn_buf, tdefl_compressor::m_pIn_buf_size, tdefl_compressor::m_pLZ_code_buf, tdefl_compressor::m_pLZ_flags, tdefl_compressor::m_pOut_buf, tdefl_compressor::m_pOut_buf_size, tdefl_compressor::m_pOutput_buf, tdefl_compressor::m_pOutput_buf_end, tdefl_compressor::m_pPut_buf_func, tdefl_compressor::m_pPut_buf_user, tdefl_compressor::m_prev_return_status, tdefl_compressor::m_pSrc, tdefl_compressor::m_saved_lit, tdefl_compressor::m_saved_match_dist, tdefl_compressor::m_saved_match_len, tdefl_compressor::m_src_buf_left, tdefl_compressor::m_total_lz_bytes, tdefl_compressor::m_wants_to_finish, MZ_CLEAR_ARR, TDEFL_GREEDY_PARSING_FLAG, TDEFL_MAX_HUFF_SYMBOLS_0, TDEFL_MAX_HUFF_SYMBOLS_1, TDEFL_NO_FLUSH, TDEFL_NONDETERMINISTIC_PARSING_FLAG, and TDEFL_STATUS_OKAY.

Referenced by mz_deflateInit2(), mz_deflateReset(), mz_zip_writer_add_mem_ex_v2(), mz_zip_writer_add_read_buf_callback(), tdefl_compress_mem_to_output(), and tdefl_write_image_to_png_file_in_memory_ex().

+ Here is the caller graph for this function:

◆ tdefl_write_image_to_png_file_in_memory()

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 )

Definition at line 2223 of file miniz.c.

2224{
2225 /* 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) */
2226 return tdefl_write_image_to_png_file_in_memory_ex(pImage, w, h, num_chans, pLen_out, 6, MZ_FALSE);
2227}
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)
Definition miniz.c:2145

References MZ_FALSE, and tdefl_write_image_to_png_file_in_memory_ex().

+ Here is the call graph for this function:

◆ tdefl_write_image_to_png_file_in_memory_ex()

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 )

Definition at line 2145 of file miniz.c.

2146{
2147 /* Using a local copy of this array here in case MINIZ_NO_ZLIB_APIS was defined. */
2148 static const mz_uint s_tdefl_png_num_probes[11] = { 0, 1, 6, 32, 16, 32, 128, 256, 512, 768, 1500 };
2150 tdefl_output_buffer out_buf;
2151 int i, bpl = w * num_chans, y, z;
2152 mz_uint32 c;
2153 *pLen_out = 0;
2154 if (!pComp)
2155 return NULL;
2156 MZ_CLEAR_OBJ(out_buf);
2157 out_buf.m_expandable = MZ_TRUE;
2158 out_buf.m_capacity = 57 + MZ_MAX(64, (1 + bpl) * h);
2159 if (NULL == (out_buf.m_pBuf = (mz_uint8 *)MZ_MALLOC(out_buf.m_capacity)))
2160 {
2161 MZ_FREE(pComp);
2162 return NULL;
2163 }
2164 /* write dummy header */
2165 for (z = 41; z; --z)
2166 tdefl_output_buffer_putter(&z, 1, &out_buf);
2167 /* compress image data */
2168 tdefl_init(pComp, tdefl_output_buffer_putter, &out_buf, s_tdefl_png_num_probes[MZ_MIN(10, level)] | TDEFL_WRITE_ZLIB_HEADER);
2169 for (y = 0; y < h; ++y)
2170 {
2172 tdefl_compress_buffer(pComp, (mz_uint8 *)pImage + (flip ? (h - 1 - y) : y) * bpl, bpl, TDEFL_NO_FLUSH);
2173 }
2175 {
2176 MZ_FREE(pComp);
2177 MZ_FREE(out_buf.m_pBuf);
2178 return NULL;
2179 }
2180 /* write real header */
2181 *pLen_out = out_buf.m_size - 41;
2182 {
2183 static const mz_uint8 chans[] = { 0x00, 0x00, 0x04, 0x02, 0x06 };
2184 mz_uint8 pnghdr[41] = { 0x89, 0x50, 0x4e, 0x47, 0x0d,
2185 0x0a, 0x1a, 0x0a, 0x00, 0x00,
2186 0x00, 0x0d, 0x49, 0x48, 0x44,
2187 0x52, 0x00, 0x00, 0x00, 0x00,
2188 0x00, 0x00, 0x00, 0x00, 0x08,
2189 0x00, 0x00, 0x00, 0x00, 0x00,
2190 0x00, 0x00, 0x00, 0x00, 0x00,
2191 0x00, 0x00, 0x49, 0x44, 0x41,
2192 0x54 };
2193 pnghdr[18] = (mz_uint8)(w >> 8);
2194 pnghdr[19] = (mz_uint8)w;
2195 pnghdr[22] = (mz_uint8)(h >> 8);
2196 pnghdr[23] = (mz_uint8)h;
2197 pnghdr[25] = chans[num_chans];
2198 pnghdr[33] = (mz_uint8)(*pLen_out >> 24);
2199 pnghdr[34] = (mz_uint8)(*pLen_out >> 16);
2200 pnghdr[35] = (mz_uint8)(*pLen_out >> 8);
2201 pnghdr[36] = (mz_uint8)*pLen_out;
2202 c = (mz_uint32)mz_crc32(MZ_CRC32_INIT, pnghdr + 12, 17);
2203 for (i = 0; i < 4; ++i, c <<= 8)
2204 ((mz_uint8 *)(pnghdr + 29))[i] = (mz_uint8)(c >> 24);
2205 memcpy(out_buf.m_pBuf, pnghdr, 41);
2206 }
2207 /* write footer (IDAT CRC-32, followed by IEND chunk) */
2208 if (!tdefl_output_buffer_putter("\0\0\0\0\0\0\0\0\x49\x45\x4e\x44\xae\x42\x60\x82", 16, &out_buf))
2209 {
2210 *pLen_out = 0;
2211 MZ_FREE(pComp);
2212 MZ_FREE(out_buf.m_pBuf);
2213 return NULL;
2214 }
2215 c = (mz_uint32)mz_crc32(MZ_CRC32_INIT, out_buf.m_pBuf + 41 - 4, *pLen_out + 4);
2216 for (i = 0; i < 4; ++i, c <<= 8)
2217 (out_buf.m_pBuf + out_buf.m_size - 16)[i] = (mz_uint8)(c >> 24);
2218 /* compute final size of file, grab compressed data buffer and return */
2219 *pLen_out += 57;
2220 MZ_FREE(pComp);
2221 return out_buf.m_pBuf;
2222}
float y

References tdefl_output_buffer::m_capacity, tdefl_output_buffer::m_expandable, tdefl_output_buffer::m_pBuf, tdefl_output_buffer::m_size, MZ_CLEAR_OBJ, mz_crc32(), MZ_CRC32_INIT, MZ_FREE, MZ_MALLOC, MZ_MAX, MZ_MIN, MZ_TRUE, tdefl_compress_buffer(), TDEFL_FINISH, tdefl_init(), TDEFL_NO_FLUSH, tdefl_output_buffer_putter(), TDEFL_STATUS_DONE, TDEFL_WRITE_ZLIB_HEADER, and y.

Referenced by tdefl_write_image_to_png_file_in_memory().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ tinfl_decompress()

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 )

Definition at line 2438 of file miniz.c.

2439{
2440 static const mz_uint16 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 };
2441 static const mz_uint8 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 };
2442 static const mz_uint16 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 };
2443 static const mz_uint8 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 };
2444 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 };
2445 static const mz_uint16 s_min_table_sizes[3] = { 257, 1, 4 };
2446
2447 mz_int16 *pTrees[3];
2448 mz_uint8 *pCode_sizes[3];
2449
2451 mz_uint32 num_bits, dist, counter, num_extra;
2452 tinfl_bit_buf_t bit_buf;
2453 const mz_uint8 *pIn_buf_cur = pIn_buf_next, *const pIn_buf_end = pIn_buf_next + *pIn_buf_size;
2454 mz_uint8 *pOut_buf_cur = pOut_buf_next, *const pOut_buf_end = pOut_buf_next ? pOut_buf_next + *pOut_buf_size : NULL;
2455 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;
2456
2457 /* 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). */
2458 if ((!pOut_buf_start) || (!pOut_buf_next) || (!pIn_buf_size) || (!pOut_buf_size))
2459 {
2461 }
2462 if (((out_buf_size_mask + 1) & out_buf_size_mask) || (pOut_buf_next < pOut_buf_start))
2463 {
2464 *pIn_buf_size = *pOut_buf_size = 0;
2466 }
2467
2468 pTrees[0] = r->m_tree_0;
2469 pTrees[1] = r->m_tree_1;
2470 pTrees[2] = r->m_tree_2;
2471 pCode_sizes[0] = r->m_code_size_0;
2472 pCode_sizes[1] = r->m_code_size_1;
2473 pCode_sizes[2] = r->m_code_size_2;
2474
2475 num_bits = r->m_num_bits;
2476 bit_buf = r->m_bit_buf;
2477 dist = r->m_dist;
2478 counter = r->m_counter;
2479 num_extra = r->m_num_extra;
2480 dist_from_out_buf_start = r->m_dist_from_out_buf_start;
2482
2483 bit_buf = num_bits = dist = counter = num_extra = r->m_zhdr0 = r->m_zhdr1 = 0;
2484 r->m_z_adler32 = r->m_check_adler32 = 1;
2485 if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER)
2486 {
2487 TINFL_GET_BYTE(1, r->m_zhdr0);
2488 TINFL_GET_BYTE(2, r->m_zhdr1);
2489 counter = (((r->m_zhdr0 * 256 + r->m_zhdr1) % 31 != 0) || (r->m_zhdr1 & 32) || ((r->m_zhdr0 & 15) != 8));
2490 if (!(decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF))
2491 counter |= (((1U << (8U + (r->m_zhdr0 >> 4))) > 32768U) || ((out_buf_size_mask + 1) < (size_t)((size_t)1 << (8U + (r->m_zhdr0 >> 4)))));
2492 if (counter)
2493 {
2495 }
2496 }
2497
2498 do
2499 {
2500 TINFL_GET_BITS(3, r->m_final, 3);
2501 r->m_type = r->m_final >> 1;
2502 if (r->m_type == 0)
2503 {
2504 TINFL_SKIP_BITS(5, num_bits & 7);
2505 for (counter = 0; counter < 4; ++counter)
2506 {
2507 if (num_bits)
2508 TINFL_GET_BITS(6, r->m_raw_header[counter], 8);
2509 else
2510 TINFL_GET_BYTE(7, r->m_raw_header[counter]);
2511 }
2512 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))))
2513 {
2515 }
2516 while ((counter) && (num_bits))
2517 {
2518 TINFL_GET_BITS(51, dist, 8);
2519 while (pOut_buf_cur >= pOut_buf_end)
2520 {
2522 }
2523 *pOut_buf_cur++ = (mz_uint8)dist;
2524 counter--;
2525 }
2526 while (counter)
2527 {
2528 size_t n;
2529 while (pOut_buf_cur >= pOut_buf_end)
2530 {
2532 }
2533 while (pIn_buf_cur >= pIn_buf_end)
2534 {
2536 }
2537 n = MZ_MIN(MZ_MIN((size_t)(pOut_buf_end - pOut_buf_cur), (size_t)(pIn_buf_end - pIn_buf_cur)), counter);
2538 TINFL_MEMCPY(pOut_buf_cur, pIn_buf_cur, n);
2539 pIn_buf_cur += n;
2540 pOut_buf_cur += n;
2541 counter -= (mz_uint)n;
2542 }
2543 }
2544 else if (r->m_type == 3)
2545 {
2547 }
2548 else
2549 {
2550 if (r->m_type == 1)
2551 {
2552 mz_uint8 *p = r->m_code_size_0;
2553 mz_uint i;
2554 r->m_table_sizes[0] = 288;
2555 r->m_table_sizes[1] = 32;
2556 TINFL_MEMSET(r->m_code_size_1, 5, 32);
2557 for (i = 0; i <= 143; ++i)
2558 *p++ = 8;
2559 for (; i <= 255; ++i)
2560 *p++ = 9;
2561 for (; i <= 279; ++i)
2562 *p++ = 7;
2563 for (; i <= 287; ++i)
2564 *p++ = 8;
2565 }
2566 else
2567 {
2568 for (counter = 0; counter < 3; counter++)
2569 {
2570 TINFL_GET_BITS(11, r->m_table_sizes[counter], "\05\05\04"[counter]);
2571 r->m_table_sizes[counter] += s_min_table_sizes[counter];
2572 }
2574 for (counter = 0; counter < r->m_table_sizes[2]; counter++)
2575 {
2576 mz_uint s;
2577 TINFL_GET_BITS(14, s, 3);
2578 r->m_code_size_2[s_length_dezigzag[counter]] = (mz_uint8)s;
2579 }
2580 r->m_table_sizes[2] = 19;
2581 }
2582 for (; (int)r->m_type >= 0; r->m_type--)
2583 {
2584 int tree_next, tree_cur;
2585 mz_int16 *pLookUp;
2586 mz_int16 *pTree;
2587 mz_uint8 *pCode_size;
2588 mz_uint i, j, used_syms, total, sym_index, next_code[17], total_syms[16];
2589 pLookUp = r->m_look_up[r->m_type];
2590 pTree = pTrees[r->m_type];
2591 pCode_size = pCode_sizes[r->m_type];
2592 MZ_CLEAR_ARR(total_syms);
2593 TINFL_MEMSET(pLookUp, 0, sizeof(r->m_look_up[0]));
2595 for (i = 0; i < r->m_table_sizes[r->m_type]; ++i)
2596 total_syms[pCode_size[i]]++;
2597 used_syms = 0, total = 0;
2598 next_code[0] = next_code[1] = 0;
2599 for (i = 1; i <= 15; ++i)
2600 {
2601 used_syms += total_syms[i];
2602 next_code[i + 1] = (total = ((total + total_syms[i]) << 1));
2603 }
2604 if ((65536 != total) && (used_syms > 1))
2605 {
2607 }
2608 for (tree_next = -1, sym_index = 0; sym_index < r->m_table_sizes[r->m_type]; ++sym_index)
2609 {
2610 mz_uint rev_code = 0, l, cur_code, code_size = pCode_size[sym_index];
2611 if (!code_size)
2612 continue;
2613 cur_code = next_code[code_size]++;
2614 for (l = code_size; l > 0; l--, cur_code >>= 1)
2615 rev_code = (rev_code << 1) | (cur_code & 1);
2616 if (code_size <= TINFL_FAST_LOOKUP_BITS)
2617 {
2618 mz_int16 k = (mz_int16)((code_size << 9) | sym_index);
2619 while (rev_code < TINFL_FAST_LOOKUP_SIZE)
2620 {
2621 pLookUp[rev_code] = k;
2622 rev_code += (1 << code_size);
2623 }
2624 continue;
2625 }
2626 if (0 == (tree_cur = pLookUp[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)]))
2627 {
2628 pLookUp[rev_code & (TINFL_FAST_LOOKUP_SIZE - 1)] = (mz_int16)tree_next;
2629 tree_cur = tree_next;
2630 tree_next -= 2;
2631 }
2632 rev_code >>= (TINFL_FAST_LOOKUP_BITS - 1);
2633 for (j = code_size; j > (TINFL_FAST_LOOKUP_BITS + 1); j--)
2634 {
2635 tree_cur -= ((rev_code >>= 1) & 1);
2636 if (!pTree[-tree_cur - 1])
2637 {
2638 pTree[-tree_cur - 1] = (mz_int16)tree_next;
2639 tree_cur = tree_next;
2640 tree_next -= 2;
2641 }
2642 else
2643 tree_cur = pTree[-tree_cur - 1];
2644 }
2645 tree_cur -= ((rev_code >>= 1) & 1);
2646 pTree[-tree_cur - 1] = (mz_int16)sym_index;
2647 }
2648 if (r->m_type == 2)
2649 {
2650 for (counter = 0; counter < (r->m_table_sizes[0] + r->m_table_sizes[1]);)
2651 {
2652 mz_uint s;
2653 TINFL_HUFF_DECODE(16, dist, r->m_look_up[2], r->m_tree_2);
2654 if (dist < 16)
2655 {
2656 r->m_len_codes[counter++] = (mz_uint8)dist;
2657 continue;
2658 }
2659 if ((dist == 16) && (!counter))
2660 {
2662 }
2663 num_extra = "\02\03\07"[dist - 16];
2664 TINFL_GET_BITS(18, s, num_extra);
2665 s += "\03\03\013"[dist - 16];
2666 TINFL_MEMSET(r->m_len_codes + counter, (dist == 16) ? r->m_len_codes[counter - 1] : 0, s);
2667 counter += s;
2668 }
2669 if ((r->m_table_sizes[0] + r->m_table_sizes[1]) != counter)
2670 {
2672 }
2675 }
2676 }
2677 for (;;)
2678 {
2679 mz_uint8 *pSrc;
2680 for (;;)
2681 {
2682 if (((pIn_buf_end - pIn_buf_cur) < 4) || ((pOut_buf_end - pOut_buf_cur) < 2))
2683 {
2684 TINFL_HUFF_DECODE(23, counter, r->m_look_up[0], r->m_tree_0);
2685 if (counter >= 256)
2686 break;
2687 while (pOut_buf_cur >= pOut_buf_end)
2688 {
2690 }
2691 *pOut_buf_cur++ = (mz_uint8)counter;
2692 }
2693 else
2694 {
2695 int sym2;
2696 mz_uint code_len;
2697#if TINFL_USE_64BIT_BITBUF
2698 if (num_bits < 30)
2699 {
2700 bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE32(pIn_buf_cur)) << num_bits);
2701 pIn_buf_cur += 4;
2702 num_bits += 32;
2703 }
2704#else
2705 if (num_bits < 15)
2706 {
2707 bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits);
2708 pIn_buf_cur += 2;
2709 num_bits += 16;
2710 }
2711#endif
2712 if ((sym2 = r->m_look_up[0][bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0)
2713 code_len = sym2 >> 9;
2714 else
2715 {
2716 code_len = TINFL_FAST_LOOKUP_BITS;
2717 do
2718 {
2719 sym2 = r->m_tree_0[~sym2 + ((bit_buf >> code_len++) & 1)];
2720 } while (sym2 < 0);
2721 }
2722 counter = sym2;
2723 bit_buf >>= code_len;
2724 num_bits -= code_len;
2725 if (counter & 256)
2726 break;
2727
2728#if !TINFL_USE_64BIT_BITBUF
2729 if (num_bits < 15)
2730 {
2731 bit_buf |= (((tinfl_bit_buf_t)MZ_READ_LE16(pIn_buf_cur)) << num_bits);
2732 pIn_buf_cur += 2;
2733 num_bits += 16;
2734 }
2735#endif
2736 if ((sym2 = r->m_look_up[0][bit_buf & (TINFL_FAST_LOOKUP_SIZE - 1)]) >= 0)
2737 code_len = sym2 >> 9;
2738 else
2739 {
2740 code_len = TINFL_FAST_LOOKUP_BITS;
2741 do
2742 {
2743 sym2 = r->m_tree_0[~sym2 + ((bit_buf >> code_len++) & 1)];
2744 } while (sym2 < 0);
2745 }
2746 bit_buf >>= code_len;
2747 num_bits -= code_len;
2748
2749 pOut_buf_cur[0] = (mz_uint8)counter;
2750 if (sym2 & 256)
2751 {
2752 pOut_buf_cur++;
2753 counter = sym2;
2754 break;
2755 }
2756 pOut_buf_cur[1] = (mz_uint8)sym2;
2757 pOut_buf_cur += 2;
2758 }
2759 }
2760 if ((counter &= 511) == 256)
2761 break;
2762
2763 num_extra = s_length_extra[counter - 257];
2764 counter = s_length_base[counter - 257];
2765 if (num_extra)
2766 {
2767 mz_uint extra_bits;
2768 TINFL_GET_BITS(25, extra_bits, num_extra);
2769 counter += extra_bits;
2770 }
2771
2772 TINFL_HUFF_DECODE(26, dist, r->m_look_up[1], r->m_tree_1);
2773 num_extra = s_dist_extra[dist];
2774 dist = s_dist_base[dist];
2775 if (num_extra)
2776 {
2777 mz_uint extra_bits;
2778 TINFL_GET_BITS(27, extra_bits, num_extra);
2779 dist += extra_bits;
2780 }
2781
2782 dist_from_out_buf_start = pOut_buf_cur - pOut_buf_start;
2783 if ((dist == 0 || dist > dist_from_out_buf_start || dist_from_out_buf_start == 0) && (decomp_flags & TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF))
2784 {
2786 }
2787
2788 pSrc = pOut_buf_start + ((dist_from_out_buf_start - dist) & out_buf_size_mask);
2789
2790 if ((MZ_MAX(pOut_buf_cur, pSrc) + counter) > pOut_buf_end)
2791 {
2792 while (counter--)
2793 {
2794 while (pOut_buf_cur >= pOut_buf_end)
2795 {
2797 }
2798 *pOut_buf_cur++ = pOut_buf_start[(dist_from_out_buf_start++ - dist) & out_buf_size_mask];
2799 }
2800 continue;
2801 }
2802#if MINIZ_USE_UNALIGNED_LOADS_AND_STORES
2803 else if ((counter >= 9) && (counter <= dist))
2804 {
2805 const mz_uint8 *pSrc_end = pSrc + (counter & ~7);
2806 do
2807 {
2808#ifdef MINIZ_UNALIGNED_USE_MEMCPY
2809 memcpy(pOut_buf_cur, pSrc, sizeof(mz_uint32)*2);
2810#else
2811 ((mz_uint32 *)pOut_buf_cur)[0] = ((const mz_uint32 *)pSrc)[0];
2812 ((mz_uint32 *)pOut_buf_cur)[1] = ((const mz_uint32 *)pSrc)[1];
2813#endif
2814 pOut_buf_cur += 8;
2815 } while ((pSrc += 8) < pSrc_end);
2816 if ((counter &= 7) < 3)
2817 {
2818 if (counter)
2819 {
2820 pOut_buf_cur[0] = pSrc[0];
2821 if (counter > 1)
2822 pOut_buf_cur[1] = pSrc[1];
2823 pOut_buf_cur += counter;
2824 }
2825 continue;
2826 }
2827 }
2828#endif
2829 while(counter>2)
2830 {
2831 pOut_buf_cur[0] = pSrc[0];
2832 pOut_buf_cur[1] = pSrc[1];
2833 pOut_buf_cur[2] = pSrc[2];
2834 pOut_buf_cur += 3;
2835 pSrc += 3;
2836 counter -= 3;
2837 }
2838 if (counter > 0)
2839 {
2840 pOut_buf_cur[0] = pSrc[0];
2841 if (counter > 1)
2842 pOut_buf_cur[1] = pSrc[1];
2843 pOut_buf_cur += counter;
2844 }
2845 }
2846 }
2847 } while (!(r->m_final & 1));
2848
2849 /* 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. */
2850 /* 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. */
2851 TINFL_SKIP_BITS(32, num_bits & 7);
2852 while ((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8))
2853 {
2854 --pIn_buf_cur;
2855 num_bits -= 8;
2856 }
2857 bit_buf &= ~(~(tinfl_bit_buf_t)0 << num_bits);
2858 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). */
2859
2860 if (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER)
2861 {
2862 for (counter = 0; counter < 4; ++counter)
2863 {
2864 mz_uint s;
2865 if (num_bits)
2866 TINFL_GET_BITS(41, s, 8);
2867 else
2868 TINFL_GET_BYTE(42, s);
2869 r->m_z_adler32 = (r->m_z_adler32 << 8) | s;
2870 }
2871 }
2873
2875
2876common_exit:
2877 /* As long as we aren't telling the caller that we NEED more input to make forward progress: */
2878 /* 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. */
2879 /* 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. */
2881 {
2882 while ((pIn_buf_cur > pIn_buf_next) && (num_bits >= 8))
2883 {
2884 --pIn_buf_cur;
2885 num_bits -= 8;
2886 }
2887 }
2888 r->m_num_bits = num_bits;
2889 r->m_bit_buf = bit_buf & ~(~(tinfl_bit_buf_t)0 << num_bits);
2890 r->m_dist = dist;
2891 r->m_counter = counter;
2892 r->m_num_extra = num_extra;
2893 r->m_dist_from_out_buf_start = dist_from_out_buf_start;
2894 *pIn_buf_size = pIn_buf_cur - pIn_buf_next;
2895 *pOut_buf_size = pOut_buf_cur - pOut_buf_next;
2896 if ((decomp_flags & (TINFL_FLAG_PARSE_ZLIB_HEADER | TINFL_FLAG_COMPUTE_ADLER32)) && (status >= 0))
2897 {
2898 const mz_uint8 *ptr = pOut_buf_next;
2899 size_t buf_len = *pOut_buf_size;
2900 mz_uint32 i, s1 = r->m_check_adler32 & 0xffff, s2 = r->m_check_adler32 >> 16;
2901 size_t block_len = buf_len % 5552;
2902 while (buf_len)
2903 {
2904 for (i = 0; i + 7 < block_len; i += 8, ptr += 8)
2905 {
2906 s1 += ptr[0], s2 += s1;
2907 s1 += ptr[1], s2 += s1;
2908 s1 += ptr[2], s2 += s1;
2909 s1 += ptr[3], s2 += s1;
2910 s1 += ptr[4], s2 += s1;
2911 s1 += ptr[5], s2 += s1;
2912 s1 += ptr[6], s2 += s1;
2913 s1 += ptr[7], s2 += s1;
2914 }
2915 for (; i < block_len; ++i)
2916 s1 += *ptr++, s2 += s1;
2917 s1 %= 65521U, s2 %= 65521U;
2918 buf_len -= block_len;
2919 block_len = 5552;
2920 }
2921 r->m_check_adler32 = (s2 << 16) + s1;
2922 if ((status == TINFL_STATUS_DONE) && (decomp_flags & TINFL_FLAG_PARSE_ZLIB_HEADER) && (r->m_check_adler32 != r->m_z_adler32))
2924 }
2925 return status;
2926}
typedef int(ZCALLBACK *close_file_func) OF((voidpf opaque
#define TINFL_HUFF_DECODE(state_index, sym, pLookUp, pTree)
Definition miniz.c:2394
#define TINFL_CR_BEGIN
Definition miniz.c:2292
#define TINFL_GET_BYTE(state_index, c)
Definition miniz.c:2316
#define TINFL_MEMCPY(d, s, l)
Definition miniz.c:2289
#define TINFL_GET_BITS(state_index, b, n)
Definition miniz.c:2346
static void tinfl_clear_tree(tinfl_decompressor *r)
Definition miniz.c:2428
#define TINFL_MEMSET(p, c, l)
Definition miniz.c:2290
#define TINFL_CR_FINISH
Definition miniz.c:2314
#define TINFL_CR_RETURN(state_index, result)
Definition miniz.c:2296
#define TINFL_CR_RETURN_FOREVER(state_index, result)
Definition miniz.c:2305
#define TINFL_SKIP_BITS(state_index, n)
Definition miniz.c:2335
signed short mz_int16
Definition miniz.h:546
mz_uint32 tinfl_bit_buf_t
Definition miniz.h:950
mz_uint8 m_code_size_0[TINFL_MAX_HUFF_SYMBOLS_0]
Definition miniz.h:963
mz_uint32 m_final
Definition miniz.h:956
mz_uint32 m_zhdr0
Definition miniz.h:956
tinfl_bit_buf_t m_bit_buf
Definition miniz.h:957
mz_uint32 m_counter
Definition miniz.h:956
size_t m_dist_from_out_buf_start
Definition miniz.h:958
mz_uint32 m_check_adler32
Definition miniz.h:956
mz_int16 m_tree_0[TINFL_MAX_HUFF_SYMBOLS_0 *2]
Definition miniz.h:960
mz_int16 m_tree_1[TINFL_MAX_HUFF_SYMBOLS_1 *2]
Definition miniz.h:961
mz_uint8 m_raw_header[4]
Definition miniz.h:966
mz_uint32 m_zhdr1
Definition miniz.h:956
mz_uint32 m_num_bits
Definition miniz.h:956
mz_int16 m_look_up[TINFL_MAX_HUFF_TABLES][TINFL_FAST_LOOKUP_SIZE]
Definition miniz.h:959
mz_int16 m_tree_2[TINFL_MAX_HUFF_SYMBOLS_2 *2]
Definition miniz.h:962
mz_uint32 m_z_adler32
Definition miniz.h:956
mz_uint32 m_table_sizes[TINFL_MAX_HUFF_TABLES]
Definition miniz.h:956
mz_uint8 m_code_size_2[TINFL_MAX_HUFF_SYMBOLS_2]
Definition miniz.h:965
mz_uint8 m_len_codes[TINFL_MAX_HUFF_SYMBOLS_0+TINFL_MAX_HUFF_SYMBOLS_1+137]
Definition miniz.h:966
mz_uint32 m_num_extra
Definition miniz.h:956
mz_uint8 m_code_size_1[TINFL_MAX_HUFF_SYMBOLS_1]
Definition miniz.h:964

References int(), tinfl_decompressor_tag::m_bit_buf, tinfl_decompressor_tag::m_check_adler32, tinfl_decompressor_tag::m_code_size_0, tinfl_decompressor_tag::m_code_size_1, tinfl_decompressor_tag::m_code_size_2, tinfl_decompressor_tag::m_counter, tinfl_decompressor_tag::m_dist, tinfl_decompressor_tag::m_dist_from_out_buf_start, tinfl_decompressor_tag::m_final, tinfl_decompressor_tag::m_len_codes, tinfl_decompressor_tag::m_look_up, tinfl_decompressor_tag::m_num_bits, tinfl_decompressor_tag::m_num_extra, tinfl_decompressor_tag::m_raw_header, tinfl_decompressor_tag::m_table_sizes, tinfl_decompressor_tag::m_tree_0, tinfl_decompressor_tag::m_tree_1, tinfl_decompressor_tag::m_tree_2, tinfl_decompressor_tag::m_type, tinfl_decompressor_tag::m_z_adler32, tinfl_decompressor_tag::m_zhdr0, tinfl_decompressor_tag::m_zhdr1, MZ_ASSERT, MZ_CLEAR_ARR, MZ_MAX, MZ_MIN, MZ_READ_LE16, MZ_READ_LE32, tinfl_clear_tree(), TINFL_CR_BEGIN, TINFL_CR_FINISH, TINFL_CR_RETURN, TINFL_CR_RETURN_FOREVER, TINFL_FAST_LOOKUP_BITS, TINFL_FAST_LOOKUP_SIZE, TINFL_FLAG_COMPUTE_ADLER32, TINFL_FLAG_HAS_MORE_INPUT, TINFL_FLAG_PARSE_ZLIB_HEADER, TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF, TINFL_GET_BITS, TINFL_GET_BYTE, TINFL_HUFF_DECODE, TINFL_MEMCPY, TINFL_MEMSET, TINFL_SKIP_BITS, TINFL_STATUS_ADLER32_MISMATCH, TINFL_STATUS_BAD_PARAM, TINFL_STATUS_DONE, TINFL_STATUS_FAILED, TINFL_STATUS_FAILED_CANNOT_MAKE_PROGRESS, TINFL_STATUS_HAS_MORE_OUTPUT, and TINFL_STATUS_NEEDS_MORE_INPUT.

Referenced by mz_inflate(), mz_zip_reader_extract_iter_read(), mz_zip_reader_extract_to_callback(), mz_zip_reader_extract_to_mem_no_alloc1(), tinfl_decompress_mem_to_callback(), tinfl_decompress_mem_to_heap(), and tinfl_decompress_mem_to_mem().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ tinfl_decompress_mem_to_callback()

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 )

Definition at line 2976 of file miniz.c.

2977{
2978 int result = 0;
2979 tinfl_decompressor decomp;
2981 size_t in_buf_ofs = 0, dict_ofs = 0;
2982 if (!pDict)
2983 return TINFL_STATUS_FAILED;
2984 memset(pDict,0,TINFL_LZ_DICT_SIZE);
2985 tinfl_init(&decomp);
2986 for (;;)
2987 {
2988 size_t in_buf_size = *pIn_buf_size - in_buf_ofs, dst_buf_size = TINFL_LZ_DICT_SIZE - dict_ofs;
2989 tinfl_status status = tinfl_decompress(&decomp, (const mz_uint8 *)pIn_buf + in_buf_ofs, &in_buf_size, pDict, pDict + dict_ofs, &dst_buf_size,
2991 in_buf_ofs += in_buf_size;
2992 if ((dst_buf_size) && (!(*pPut_buf_func)(pDict + dict_ofs, (int)dst_buf_size, pPut_buf_user)))
2993 break;
2994 if (status != TINFL_STATUS_HAS_MORE_OUTPUT)
2995 {
2996 result = (status == TINFL_STATUS_DONE);
2997 break;
2998 }
2999 dict_ofs = (dict_ofs + dst_buf_size) & (TINFL_LZ_DICT_SIZE - 1);
3000 }
3001 MZ_FREE(pDict);
3002 *pIn_buf_size = in_buf_ofs;
3003 return result;
3004}

References MZ_FREE, MZ_MALLOC, tinfl_decompress(), TINFL_FLAG_HAS_MORE_INPUT, TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF, tinfl_init, TINFL_LZ_DICT_SIZE, TINFL_STATUS_DONE, TINFL_STATUS_FAILED, and TINFL_STATUS_HAS_MORE_OUTPUT.

+ Here is the call graph for this function:

◆ tinfl_decompress_mem_to_heap()

MINIZ_EXPORT void * tinfl_decompress_mem_to_heap ( const void * pSrc_buf,
size_t src_buf_len,
size_t * pOut_len,
int flags )

Definition at line 2929 of file miniz.c.

2930{
2931 tinfl_decompressor decomp;
2932 void *pBuf = NULL, *pNew_buf;
2933 size_t src_buf_ofs = 0, out_buf_capacity = 0;
2934 *pOut_len = 0;
2935 tinfl_init(&decomp);
2936 for (;;)
2937 {
2938 size_t src_buf_size = src_buf_len - src_buf_ofs, dst_buf_size = out_buf_capacity - *pOut_len, new_out_buf_capacity;
2939 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,
2941 if ((status < 0) || (status == TINFL_STATUS_NEEDS_MORE_INPUT))
2942 {
2943 MZ_FREE(pBuf);
2944 *pOut_len = 0;
2945 return NULL;
2946 }
2947 src_buf_ofs += src_buf_size;
2948 *pOut_len += dst_buf_size;
2949 if (status == TINFL_STATUS_DONE)
2950 break;
2951 new_out_buf_capacity = out_buf_capacity * 2;
2952 if (new_out_buf_capacity < 128)
2953 new_out_buf_capacity = 128;
2954 pNew_buf = MZ_REALLOC(pBuf, new_out_buf_capacity);
2955 if (!pNew_buf)
2956 {
2957 MZ_FREE(pBuf);
2958 *pOut_len = 0;
2959 return NULL;
2960 }
2961 pBuf = pNew_buf;
2962 out_buf_capacity = new_out_buf_capacity;
2963 }
2964 return pBuf;
2965}

References MZ_FREE, MZ_REALLOC, tinfl_decompress(), TINFL_FLAG_HAS_MORE_INPUT, TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF, tinfl_init, TINFL_STATUS_DONE, and TINFL_STATUS_NEEDS_MORE_INPUT.

+ Here is the call graph for this function:

◆ tinfl_decompress_mem_to_mem()

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 )

Definition at line 2967 of file miniz.c.

2968{
2969 tinfl_decompressor decomp;
2970 tinfl_status status;
2971 tinfl_init(&decomp);
2972 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);
2973 return (status != TINFL_STATUS_DONE) ? TINFL_DECOMPRESS_MEM_TO_MEM_FAILED : out_buf_len;
2974}
#define TINFL_DECOMPRESS_MEM_TO_MEM_FAILED
Definition miniz.h:860

References tinfl_decompress(), TINFL_DECOMPRESS_MEM_TO_MEM_FAILED, TINFL_FLAG_HAS_MORE_INPUT, TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF, tinfl_init, and TINFL_STATUS_DONE.

+ Here is the call graph for this function:

◆ tinfl_decompressor_alloc()

MINIZ_EXPORT tinfl_decompressor * tinfl_decompressor_alloc ( void )

Definition at line 3007 of file miniz.c.

3008{
3010 if (pDecomp)
3011 tinfl_init(pDecomp);
3012 return pDecomp;
3013}

References MZ_MALLOC, and tinfl_init.

◆ tinfl_decompressor_free()

MINIZ_EXPORT void tinfl_decompressor_free ( tinfl_decompressor * pDecomp)

Definition at line 3015 of file miniz.c.

3016{
3017 MZ_FREE(pDecomp);
3018}

References MZ_FREE.