/**************************************************************************

*

* Copyright 2013-2014 RAD Game Tools and Valve Software

* Copyright 2010-2014 Rich Geldreich and Tenacious Software LLC

* Copyright 2016 Martin Raiber

* All Rights Reserved.

*

* Permission is hereby granted, free of charge, to any person obtaining a copy

* of this software and associated documentation files (the "Software"), to deal

* in the Software without restriction, including without limitation the rights

* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

* copies of the Software, and to permit persons to whom the Software is

* furnished to do so, subject to the following conditions:

*

* The above copyright notice and this permission notice shall be included in

* all copies or substantial portions of the Software.

*

* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

* THE SOFTWARE.

*

**************************************************************************/

#include "miniz_zip.h"

#ifdef __cplusplus

extern "C" {

#endif

/* ------------------- .ZIP archive reading */

#ifdef MINIZ_NO_STDIO

#define MZ_FILE void *

#else

#include <sys/stat.h>

#if defined(_MSC_VER) || defined(__MINGW64__)

static FILE *mz_fopen(const char *pFilename, const char *pMode)

{

FILE *pFile = NULL;

fopen_s(&pFile, pFilename, pMode);

return pFile;

}

static FILE *mz_freopen(const char *pPath, const char *pMode, FILE *pStream)

{

FILE *pFile = NULL;

if (freopen_s(&pFile, pPath, pMode, pStream))

return NULL;

return pFile;

}

#ifndef MINIZ_NO_TIME

#include <sys/utime.h>

#endif

#define MZ_FOPEN mz_fopen

#define MZ_FCLOSE fclose

#define MZ_FREAD fread

#define MZ_FWRITE fwrite

#define MZ_FTELL64 _ftelli64

#define MZ_FSEEK64 _fseeki64

#define MZ_FILE_STAT_STRUCT _stat

#define MZ_FILE_STAT _stat

#define MZ_FFLUSH fflush

#define MZ_FREOPEN mz_freopen

#define MZ_DELETE_FILE remove

#elif defined(__MINGW32__)

#ifndef MINIZ_NO_TIME

#include <sys/utime.h>

#endif

#define MZ_FOPEN(f, m) fopen(f, m)

#define MZ_FCLOSE fclose

#define MZ_FREAD fread

#define MZ_FWRITE fwrite

#define MZ_FTELL64 ftello64

#define MZ_FSEEK64 fseeko64

#define MZ_FILE_STAT_STRUCT _stat

#define MZ_FILE_STAT _stat

#define MZ_FFLUSH fflush

#define MZ_FREOPEN(f, m, s) freopen(f, m, s)

#define MZ_DELETE_FILE remove

#elif defined(__TINYC__)

#ifndef MINIZ_NO_TIME

#include <sys/utime.h>

#endif

#define MZ_FOPEN(f, m) fopen(f, m)

#define MZ_FCLOSE fclose

#define MZ_FREAD fread

#define MZ_FWRITE fwrite

#define MZ_FTELL64 ftell

#define MZ_FSEEK64 fseek

#define MZ_FILE_STAT_STRUCT stat

#define MZ_FILE_STAT stat

#define MZ_FFLUSH fflush

#define MZ_FREOPEN(f, m, s) freopen(f, m, s)

#define MZ_DELETE_FILE remove

#elif defined(__GNUC__) && _LARGEFILE64_SOURCE

#ifndef MINIZ_NO_TIME

#include <utime.h>

#endif

#define MZ_FOPEN(f, m) fopen64(f, m)

#define MZ_FCLOSE fclose

#define MZ_FREAD fread

#define MZ_FWRITE fwrite

#define MZ_FTELL64 ftello64

#define MZ_FSEEK64 fseeko64

#define MZ_FILE_STAT_STRUCT stat64

#define MZ_FILE_STAT stat64

#define MZ_FFLUSH fflush

#define MZ_FREOPEN(p, m, s) freopen64(p, m, s)

#define MZ_DELETE_FILE remove

#elif defined(__APPLE__) && _LARGEFILE64_SOURCE

#ifndef MINIZ_NO_TIME

#include <utime.h>

#endif

#define MZ_FOPEN(f, m) fopen(f, m)

#define MZ_FCLOSE fclose

#define MZ_FREAD fread

#define MZ_FWRITE fwrite

#define MZ_FTELL64 ftello

#define MZ_FSEEK64 fseeko

#define MZ_FILE_STAT_STRUCT stat

#define MZ_FILE_STAT stat

#define MZ_FFLUSH fflush

#define MZ_FREOPEN(p, m, s) freopen(p, m, s)

#define MZ_DELETE_FILE remove

#else

#pragma message("Using fopen, ftello, fseeko, stat() etc. path for file I/O - this path may not support large files.")

#ifndef MINIZ_NO_TIME

#include <utime.h>

#endif

#define MZ_FOPEN(f, m) fopen(f, m)

#define MZ_FCLOSE fclose

#define MZ_FREAD fread

#define MZ_FWRITE fwrite

#define MZ_FTELL64 ftello

#define MZ_FSEEK64 fseeko

#define MZ_FILE_STAT_STRUCT stat

#define MZ_FILE_STAT stat

#define MZ_FFLUSH fflush

#define MZ_FREOPEN(f, m, s) freopen(f, m, s)

#define MZ_DELETE_FILE remove

#endif /* #ifdef _MSC_VER */

#endif /* #ifdef MINIZ_NO_STDIO */

#define MZ_TOLOWER(c) ((((c) >= 'A') && ((c) <= 'Z')) ? ((c) - 'A' + 'a') : (c))

/* Various ZIP archive enums. To completely avoid cross platform compiler alignment and platform endian issues, miniz.c doesn't use structs for any of this stuff. */

enum

{

/* ZIP archive identifiers and record sizes */

MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG = 0x06054b50,

MZ_ZIP_CENTRAL_DIR_HEADER_SIG = 0x02014b50,

MZ_ZIP_LOCAL_DIR_HEADER_SIG = 0x04034b50,

MZ_ZIP_LOCAL_DIR_HEADER_SIZE = 30,

MZ_ZIP_CENTRAL_DIR_HEADER_SIZE = 46,

MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE = 22,

/* ZIP64 archive identifier and record sizes */

MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG = 0x06064b50,

MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG = 0x07064b50,

MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE = 56,

MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE = 20,

MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID = 0x0001,

MZ_ZIP_DATA_DESCRIPTOR_ID = 0x08074b50,

MZ_ZIP_DATA_DESCRIPTER_SIZE64 = 24,

MZ_ZIP_DATA_DESCRIPTER_SIZE32 = 16,

/* Central directory header record offsets */

MZ_ZIP_CDH_SIG_OFS = 0,

MZ_ZIP_CDH_VERSION_MADE_BY_OFS = 4,

MZ_ZIP_CDH_VERSION_NEEDED_OFS = 6,

MZ_ZIP_CDH_BIT_FLAG_OFS = 8,

MZ_ZIP_CDH_METHOD_OFS = 10,

MZ_ZIP_CDH_FILE_TIME_OFS = 12,

MZ_ZIP_CDH_FILE_DATE_OFS = 14,

MZ_ZIP_CDH_CRC32_OFS = 16,

MZ_ZIP_CDH_COMPRESSED_SIZE_OFS = 20,

MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS = 24,

MZ_ZIP_CDH_FILENAME_LEN_OFS = 28,

MZ_ZIP_CDH_EXTRA_LEN_OFS = 30,

MZ_ZIP_CDH_COMMENT_LEN_OFS = 32,

MZ_ZIP_CDH_DISK_START_OFS = 34,

MZ_ZIP_CDH_INTERNAL_ATTR_OFS = 36,

MZ_ZIP_CDH_EXTERNAL_ATTR_OFS = 38,

MZ_ZIP_CDH_LOCAL_HEADER_OFS = 42,

/* Local directory header offsets */

MZ_ZIP_LDH_SIG_OFS = 0,

MZ_ZIP_LDH_VERSION_NEEDED_OFS = 4,

MZ_ZIP_LDH_BIT_FLAG_OFS = 6,

MZ_ZIP_LDH_METHOD_OFS = 8,

MZ_ZIP_LDH_FILE_TIME_OFS = 10,

MZ_ZIP_LDH_FILE_DATE_OFS = 12,

MZ_ZIP_LDH_CRC32_OFS = 14,

MZ_ZIP_LDH_COMPRESSED_SIZE_OFS = 18,

MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS = 22,

MZ_ZIP_LDH_FILENAME_LEN_OFS = 26,

MZ_ZIP_LDH_EXTRA_LEN_OFS = 28,

MZ_ZIP_LDH_BIT_FLAG_HAS_LOCATOR = 1 << 3,

/* End of central directory offsets */

MZ_ZIP_ECDH_SIG_OFS = 0,

MZ_ZIP_ECDH_NUM_THIS_DISK_OFS = 4,

MZ_ZIP_ECDH_NUM_DISK_CDIR_OFS = 6,

MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS = 8,

MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS = 10,

MZ_ZIP_ECDH_CDIR_SIZE_OFS = 12,

MZ_ZIP_ECDH_CDIR_OFS_OFS = 16,

MZ_ZIP_ECDH_COMMENT_SIZE_OFS = 20,

/* ZIP64 End of central directory locator offsets */

MZ_ZIP64_ECDL_SIG_OFS = 0, /* 4 bytes */

MZ_ZIP64_ECDL_NUM_DISK_CDIR_OFS = 4, /* 4 bytes */

MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS = 8, /* 8 bytes */

MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS = 16, /* 4 bytes */

/* ZIP64 End of central directory header offsets */

MZ_ZIP64_ECDH_SIG_OFS = 0, /* 4 bytes */

MZ_ZIP64_ECDH_SIZE_OF_RECORD_OFS = 4, /* 8 bytes */

MZ_ZIP64_ECDH_VERSION_MADE_BY_OFS = 12, /* 2 bytes */

MZ_ZIP64_ECDH_VERSION_NEEDED_OFS = 14, /* 2 bytes */

MZ_ZIP64_ECDH_NUM_THIS_DISK_OFS = 16, /* 4 bytes */

MZ_ZIP64_ECDH_NUM_DISK_CDIR_OFS = 20, /* 4 bytes */

MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS = 24, /* 8 bytes */

MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS = 32, /* 8 bytes */

MZ_ZIP64_ECDH_CDIR_SIZE_OFS = 40, /* 8 bytes */

MZ_ZIP64_ECDH_CDIR_OFS_OFS = 48, /* 8 bytes */

MZ_ZIP_VERSION_MADE_BY_DOS_FILESYSTEM_ID = 0,

MZ_ZIP_DOS_DIR_ATTRIBUTE_BITFLAG = 0x10,

MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_IS_ENCRYPTED = 1,

MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_COMPRESSED_PATCH_FLAG = 32,

MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_USES_STRONG_ENCRYPTION = 64,

MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_LOCAL_DIR_IS_MASKED = 8192,

MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_UTF8 = 1 << 11

};

typedef struct

{

void *m_p;

size_t m_size, m_capacity;

mz_uint m_element_size;

} mz_zip_array;

struct mz_zip_internal_state_tag

{

mz_zip_array m_central_dir;

mz_zip_array m_central_dir_offsets;

mz_zip_array m_sorted_central_dir_offsets;

/* The flags passed in when the archive is initially opened. */

uint32_t m_init_flags;

/* MZ_TRUE if the archive has a zip64 end of central directory headers, etc. */

mz_bool m_zip64;

/* MZ_TRUE if we found zip64 extended info in the central directory (m_zip64 will also be slammed to true too, even if we didn't find a zip64 end of central dir header, etc.) */

mz_bool m_zip64_has_extended_info_fields;

/* These fields are used by the file, FILE, memory, and memory/heap read/write helpers. */

MZ_FILE *m_pFile;

mz_uint64 m_file_archive_start_ofs;

void *m_pMem;

size_t m_mem_size;

size_t m_mem_capacity;

};

#define MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(array_ptr, element_size) (array_ptr)->m_element_size = element_size

#if defined(DEBUG) || defined(_DEBUG) || defined(NDEBUG)

static MZ_FORCEINLINE mz_uint mz_zip_array_range_check(const mz_zip_array *pArray, mz_uint index)

{

MZ_ASSERT(index < pArray->m_size);

return index;

}

#define MZ_ZIP_ARRAY_ELEMENT(array_ptr, element_type, index) ((element_type *)((array_ptr)->m_p))[mz_zip_array_range_check(array_ptr, index)]

#else

#define MZ_ZIP_ARRAY_ELEMENT(array_ptr, element_type, index) ((element_type *)((array_ptr)->m_p))[index]

#endif

static MZ_FORCEINLINE void mz_zip_array_init(mz_zip_array *pArray, mz_uint32 element_size)

{

memset(pArray, 0, sizeof(mz_zip_array));

pArray->m_element_size = element_size;

}

static MZ_FORCEINLINE void mz_zip_array_clear(mz_zip_archive *pZip, mz_zip_array *pArray)

{

pZip->m_pFree(pZip->m_pAlloc_opaque, pArray->m_p);

memset(pArray, 0, sizeof(mz_zip_array));

}

static mz_bool mz_zip_array_ensure_capacity(mz_zip_archive *pZip, mz_zip_array *pArray, size_t min_new_capacity, mz_uint growing)

{

void *pNew_p;

size_t new_capacity = min_new_capacity;

MZ_ASSERT(pArray->m_element_size);

if (pArray->m_capacity >= min_new_capacity)

return MZ_TRUE;

if (growing)

{

new_capacity = MZ_MAX(1, pArray->m_capacity);

while (new_capacity < min_new_capacity)

new_capacity *= 2;

}

if (NULL == (pNew_p = pZip->m_pRealloc(pZip->m_pAlloc_opaque, pArray->m_p, pArray->m_element_size, new_capacity)))

return MZ_FALSE;

pArray->m_p = pNew_p;

pArray->m_capacity = new_capacity;

return MZ_TRUE;

}

static MZ_FORCEINLINE mz_bool mz_zip_array_reserve(mz_zip_archive *pZip, mz_zip_array *pArray, size_t new_capacity, mz_uint growing)

{

if (new_capacity > pArray->m_capacity)

{

if (!mz_zip_array_ensure_capacity(pZip, pArray, new_capacity, growing))

return MZ_FALSE;

}

return MZ_TRUE;

}

static MZ_FORCEINLINE mz_bool mz_zip_array_resize(mz_zip_archive *pZip, mz_zip_array *pArray, size_t new_size, mz_uint growing)

{

if (new_size > pArray->m_capacity)

{

if (!mz_zip_array_ensure_capacity(pZip, pArray, new_size, growing))

return MZ_FALSE;

}

pArray->m_size = new_size;

return MZ_TRUE;

}

static MZ_FORCEINLINE mz_bool mz_zip_array_ensure_room(mz_zip_archive *pZip, mz_zip_array *pArray, size_t n)

{

return mz_zip_array_reserve(pZip, pArray, pArray->m_size + n, MZ_TRUE);

}

static MZ_FORCEINLINE mz_bool mz_zip_array_push_back(mz_zip_archive *pZip, mz_zip_array *pArray, const void *pElements, size_t n)

{

size_t orig_size = pArray->m_size;

if (!mz_zip_array_resize(pZip, pArray, orig_size + n, MZ_TRUE))

return MZ_FALSE;

memcpy((mz_uint8 *)pArray->m_p + orig_size * pArray->m_element_size, pElements, n * pArray->m_element_size);

return MZ_TRUE;

}

#ifndef MINIZ_NO_TIME

static MZ_TIME_T mz_zip_dos_to_time_t(int dos_time, int dos_date)

{

struct tm tm;

memset(&tm, 0, sizeof(tm));

tm.tm_isdst = -1;

tm.tm_year = ((dos_date >> 9) & 127) + 1980 - 1900;

tm.tm_mon = ((dos_date >> 5) & 15) - 1;

tm.tm_mday = dos_date & 31;

tm.tm_hour = (dos_time >> 11) & 31;

tm.tm_min = (dos_time >> 5) & 63;

tm.tm_sec = (dos_time << 1) & 62;

return mktime(&tm);

}

static void mz_zip_time_t_to_dos_time(MZ_TIME_T time, mz_uint16 *pDOS_time, mz_uint16 *pDOS_date)

{

#ifdef _MSC_VER

struct tm tm_struct;

struct tm *tm = &tm_struct;

errno_t err = localtime_s(tm, &time);

if (err)

{

*pDOS_date = 0;

*pDOS_time = 0;

return;

}

#else

struct tm *tm = localtime(&time);

#endif /* #ifdef _MSC_VER */

*pDOS_time = (mz_uint16)(((tm->tm_hour) << 11) + ((tm->tm_min) << 5) + ((tm->tm_sec) >> 1));

*pDOS_date = (mz_uint16)(((tm->tm_year + 1900 - 1980) << 9) + ((tm->tm_mon + 1) << 5) + tm->tm_mday);

}

#ifndef MINIZ_NO_STDIO

static mz_bool mz_zip_get_file_modified_time(const char *pFilename, MZ_TIME_T *pTime)

{

struct MZ_FILE_STAT_STRUCT file_stat;

/* On Linux with x86 glibc, this call will fail on large files (I think >= 0x80000000 bytes) unless you compiled with _LARGEFILE64_SOURCE. Argh. */

if (MZ_FILE_STAT(pFilename, &file_stat) != 0)

return MZ_FALSE;

*pTime = file_stat.st_mtime;

return MZ_TRUE;

}

static mz_bool mz_zip_set_file_times(const char *pFilename, MZ_TIME_T access_time, MZ_TIME_T modified_time)

{

struct utimbuf t;

memset(&t, 0, sizeof(t));

t.actime = access_time;

t.modtime = modified_time;

return !utime(pFilename, &t);

}

#endif /* #ifndef MINIZ_NO_STDIO */

#endif /* #ifndef MINIZ_NO_TIME */

static MZ_FORCEINLINE mz_bool mz_zip_set_error(mz_zip_archive *pZip, mz_zip_error err_num)

{

if (pZip)

pZip->m_last_error = err_num;

return MZ_FALSE;

}

static mz_bool mz_zip_reader_init_internal(mz_zip_archive *pZip, mz_uint flags)

{

(void)flags;

if ((!pZip) || (pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_INVALID))

return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);

if (!pZip->m_pAlloc)

pZip->m_pAlloc = miniz_def_alloc_func;

if (!pZip->m_pFree)

pZip->m_pFree = miniz_def_free_func;

if (!pZip->m_pRealloc)

pZip->m_pRealloc = miniz_def_realloc_func;

pZip->m_archive_size = 0;

pZip->m_central_directory_file_ofs = 0;

pZip->m_total_files = 0;

pZip->m_last_error = MZ_ZIP_NO_ERROR;

if (NULL == (pZip->m_pState = (mz_zip_internal_state *)pZip->m_pAlloc(pZip->m_pAlloc_opaque, 1, sizeof(mz_zip_internal_state))))

return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);

memset(pZip->m_pState, 0, sizeof(mz_zip_internal_state));

MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir, sizeof(mz_uint8));

MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_central_dir_offsets, sizeof(mz_uint32));

MZ_ZIP_ARRAY_SET_ELEMENT_SIZE(&pZip->m_pState->m_sorted_central_dir_offsets, sizeof(mz_uint32));

pZip->m_pState->m_init_flags = flags;

pZip->m_pState->m_zip64 = MZ_FALSE;

pZip->m_pState->m_zip64_has_extended_info_fields = MZ_FALSE;

pZip->m_zip_mode = MZ_ZIP_MODE_READING;

return MZ_TRUE;

}

static MZ_FORCEINLINE mz_bool mz_zip_reader_filename_less(const mz_zip_array *pCentral_dir_array, const mz_zip_array *pCentral_dir_offsets, mz_uint l_index, mz_uint r_index)

{

const mz_uint8 *pL = &MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_array, mz_uint8, MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_offsets, mz_uint32, l_index)), *pE;

const mz_uint8 *pR = &MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_array, mz_uint8, MZ_ZIP_ARRAY_ELEMENT(pCentral_dir_offsets, mz_uint32, r_index));

mz_uint l_len = MZ_READ_LE16(pL + MZ_ZIP_CDH_FILENAME_LEN_OFS), r_len = MZ_READ_LE16(pR + MZ_ZIP_CDH_FILENAME_LEN_OFS);

mz_uint8 l = 0, r = 0;

pL += MZ_ZIP_CENTRAL_DIR_HEADER_SIZE;

pR += MZ_ZIP_CENTRAL_DIR_HEADER_SIZE;

pE = pL + MZ_MIN(l_len, r_len);

while (pL < pE)

{

if ((l = MZ_TOLOWER(*pL)) != (r = MZ_TOLOWER(*pR)))

break;

pL++;

pR++;

}

return (pL == pE) ? (l_len < r_len) : (l < r);

}

#define MZ_SWAP_UINT32(a, b) \

do \

{ \

mz_uint32 t = a; \

a = b; \

b = t; \

} \

MZ_MACRO_END

/* Heap sort of lowercased filenames, used to help accelerate plain central directory searches by mz_zip_reader_locate_file(). (Could also use qsort(), but it could allocate memory.) */

static void mz_zip_reader_sort_central_dir_offsets_by_filename(mz_zip_archive *pZip)

{

mz_zip_internal_state *pState = pZip->m_pState;

const mz_zip_array *pCentral_dir_offsets = &pState->m_central_dir_offsets;

const mz_zip_array *pCentral_dir = &pState->m_central_dir;

mz_uint32 *pIndices;

mz_uint32 start, end;

const mz_uint32 size = pZip->m_total_files;

if (size <= 1U)

return;

pIndices = &MZ_ZIP_ARRAY_ELEMENT(&pState->m_sorted_central_dir_offsets, mz_uint32, 0);

start = (size - 2U) >> 1U;

for (;;)

{

mz_uint64 child, root = start;

for (;;)

{

if ((child = (root << 1U) + 1U) >= size)

break;

child += (((child + 1U) < size) && (mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[child], pIndices[child + 1U])));

if (!mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[root], pIndices[child]))

break;

MZ_SWAP_UINT32(pIndices[root], pIndices[child]);

root = child;

}

if (!start)

break;

start--;

}

end = size - 1;

while (end > 0)

{

mz_uint64 child, root = 0;

MZ_SWAP_UINT32(pIndices[end], pIndices[0]);

for (;;)

{

if ((child = (root << 1U) + 1U) >= end)

break;

child += (((child + 1U) < end) && mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[child], pIndices[child + 1U]));

if (!mz_zip_reader_filename_less(pCentral_dir, pCentral_dir_offsets, pIndices[root], pIndices[child]))

break;

MZ_SWAP_UINT32(pIndices[root], pIndices[child]);

root = child;

}

end--;

}

}

static mz_bool mz_zip_reader_locate_header_sig(mz_zip_archive *pZip, mz_uint32 record_sig, mz_uint32 record_size, mz_int64 *pOfs)

{

mz_int64 cur_file_ofs;

mz_uint32 buf_u32[4096 / sizeof(mz_uint32)];

mz_uint8 *pBuf = (mz_uint8 *)buf_u32;

/* Basic sanity checks - reject files which are too small */

if (pZip->m_archive_size < record_size)

return MZ_FALSE;

/* Find the record by scanning the file from the end towards the beginning. */

cur_file_ofs = MZ_MAX((mz_int64)pZip->m_archive_size - (mz_int64)sizeof(buf_u32), 0);

for (;;)

{

int i, n = (int)MZ_MIN(sizeof(buf_u32), pZip->m_archive_size - cur_file_ofs);

if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf, n) != (mz_uint)n)

return MZ_FALSE;

for (i = n - 4; i >= 0; --i)

{

mz_uint s = MZ_READ_LE32(pBuf + i);

if (s == record_sig)

{

if ((pZip->m_archive_size - (cur_file_ofs + i)) >= record_size)

break;

}

}

if (i >= 0)

{

cur_file_ofs += i;

break;

}

/* Give up if we've searched the entire file, or we've gone back "too far" (~64kb) */

if ((!cur_file_ofs) || ((pZip->m_archive_size - cur_file_ofs) >= (MZ_UINT16_MAX + record_size)))

return MZ_FALSE;

cur_file_ofs = MZ_MAX(cur_file_ofs - (sizeof(buf_u32) - 3), 0);

}

*pOfs = cur_file_ofs;

return MZ_TRUE;

}

static mz_bool mz_zip_reader_read_central_dir(mz_zip_archive *pZip, mz_uint flags)

{

mz_uint cdir_size = 0, cdir_entries_on_this_disk = 0, num_this_disk = 0, cdir_disk_index = 0;

mz_uint64 cdir_ofs = 0;

mz_int64 cur_file_ofs = 0;

const mz_uint8 *p;

mz_uint32 buf_u32[4096 / sizeof(mz_uint32)];

mz_uint8 *pBuf = (mz_uint8 *)buf_u32;

mz_bool sort_central_dir = ((flags & MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY) == 0);

mz_uint32 zip64_end_of_central_dir_locator_u32[(MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];

mz_uint8 *pZip64_locator = (mz_uint8 *)zip64_end_of_central_dir_locator_u32;

mz_uint32 zip64_end_of_central_dir_header_u32[(MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE + sizeof(mz_uint32) - 1) / sizeof(mz_uint32)];

mz_uint8 *pZip64_end_of_central_dir = (mz_uint8 *)zip64_end_of_central_dir_header_u32;

mz_uint64 zip64_end_of_central_dir_ofs = 0;

/* Basic sanity checks - reject files which are too small, and check the first 4 bytes of the file to make sure a local header is there. */

if (pZip->m_archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)

return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);

if (!mz_zip_reader_locate_header_sig(pZip, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE, &cur_file_ofs))

return mz_zip_set_error(pZip, MZ_ZIP_FAILED_FINDING_CENTRAL_DIR);

/* Read and verify the end of central directory record. */

if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs, pBuf, MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) != MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)

return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);

if (MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_SIG_OFS) != MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIG)

return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);

if (cur_file_ofs >= (MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE + MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE))

{

if (pZip->m_pRead(pZip->m_pIO_opaque, cur_file_ofs - MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE, pZip64_locator, MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE) == MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE)

{

if (MZ_READ_LE32(pZip64_locator + MZ_ZIP64_ECDL_SIG_OFS) == MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIG)

{

zip64_end_of_central_dir_ofs = MZ_READ_LE64(pZip64_locator + MZ_ZIP64_ECDL_REL_OFS_TO_ZIP64_ECDR_OFS);

if (zip64_end_of_central_dir_ofs > (pZip->m_archive_size - MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE))

return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);

if (pZip->m_pRead(pZip->m_pIO_opaque, zip64_end_of_central_dir_ofs, pZip64_end_of_central_dir, MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) == MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE)

{

if (MZ_READ_LE32(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_SIG_OFS) == MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG)

{

pZip->m_pState->m_zip64 = MZ_TRUE;

}

}

}

}

}

pZip->m_total_files = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_CDIR_TOTAL_ENTRIES_OFS);

cdir_entries_on_this_disk = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS);

num_this_disk = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_NUM_THIS_DISK_OFS);

cdir_disk_index = MZ_READ_LE16(pBuf + MZ_ZIP_ECDH_NUM_DISK_CDIR_OFS);

cdir_size = MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_CDIR_SIZE_OFS);

cdir_ofs = MZ_READ_LE32(pBuf + MZ_ZIP_ECDH_CDIR_OFS_OFS);

if (pZip->m_pState->m_zip64)

{

mz_uint32 zip64_total_num_of_disks = MZ_READ_LE32(pZip64_locator + MZ_ZIP64_ECDL_TOTAL_NUMBER_OF_DISKS_OFS);

mz_uint64 zip64_cdir_total_entries = MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_TOTAL_ENTRIES_OFS);

mz_uint64 zip64_cdir_total_entries_on_this_disk = MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_NUM_ENTRIES_ON_DISK_OFS);

mz_uint64 zip64_size_of_end_of_central_dir_record = MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_SIZE_OF_RECORD_OFS);

mz_uint64 zip64_size_of_central_directory = MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_SIZE_OFS);

if (zip64_size_of_end_of_central_dir_record < (MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE - 12))

return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);

if (zip64_total_num_of_disks != 1U)

return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK);

/* Check for miniz's practical limits */

if (zip64_cdir_total_entries > MZ_UINT32_MAX)

return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);

pZip->m_total_files = (mz_uint32)zip64_cdir_total_entries;

if (zip64_cdir_total_entries_on_this_disk > MZ_UINT32_MAX)

return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);

cdir_entries_on_this_disk = (mz_uint32)zip64_cdir_total_entries_on_this_disk;

/* Check for miniz's current practical limits (sorry, this should be enough for millions of files) */

if (zip64_size_of_central_directory > MZ_UINT32_MAX)

return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_CDIR_SIZE);

cdir_size = (mz_uint32)zip64_size_of_central_directory;

num_this_disk = MZ_READ_LE32(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_NUM_THIS_DISK_OFS);

cdir_disk_index = MZ_READ_LE32(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_NUM_DISK_CDIR_OFS);

cdir_ofs = MZ_READ_LE64(pZip64_end_of_central_dir + MZ_ZIP64_ECDH_CDIR_OFS_OFS);

}

if (pZip->m_total_files != cdir_entries_on_this_disk)

return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK);

if (((num_this_disk | cdir_disk_index) != 0) && ((num_this_disk != 1) || (cdir_disk_index != 1)))

return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK);

if (cdir_size < pZip->m_total_files * MZ_ZIP_CENTRAL_DIR_HEADER_SIZE)

return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);

if ((cdir_ofs + (mz_uint64)cdir_size) > pZip->m_archive_size)

return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);

pZip->m_central_directory_file_ofs = cdir_ofs;

if (pZip->m_total_files)

{

mz_uint i, n;

/* Read the entire central directory into a heap block, and allocate another heap block to hold the unsorted central dir file record offsets, and possibly another to hold the sorted indices. */

if ((!mz_zip_array_resize(pZip, &pZip->m_pState->m_central_dir, cdir_size, MZ_FALSE)) ||

(!mz_zip_array_resize(pZip, &pZip->m_pState->m_central_dir_offsets, pZip->m_total_files, MZ_FALSE)))

return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);

if (sort_central_dir)

{

if (!mz_zip_array_resize(pZip, &pZip->m_pState->m_sorted_central_dir_offsets, pZip->m_total_files, MZ_FALSE))

return mz_zip_set_error(pZip, MZ_ZIP_ALLOC_FAILED);

}

if (pZip->m_pRead(pZip->m_pIO_opaque, cdir_ofs, pZip->m_pState->m_central_dir.m_p, cdir_size) != cdir_size)

return mz_zip_set_error(pZip, MZ_ZIP_FILE_READ_FAILED);

/* Now create an index into the central directory file records, do some basic sanity checking on each record */

p = (const mz_uint8 *)pZip->m_pState->m_central_dir.m_p;

for (n = cdir_size, i = 0; i < pZip->m_total_files; ++i)

{

mz_uint total_header_size, disk_index, bit_flags, filename_size, ext_data_size;

mz_uint64 comp_size, decomp_size, local_header_ofs;

if ((n < MZ_ZIP_CENTRAL_DIR_HEADER_SIZE) || (MZ_READ_LE32(p) != MZ_ZIP_CENTRAL_DIR_HEADER_SIG))

return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);

MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_central_dir_offsets, mz_uint32, i) = (mz_uint32)(p - (const mz_uint8 *)pZip->m_pState->m_central_dir.m_p);

if (sort_central_dir)

MZ_ZIP_ARRAY_ELEMENT(&pZip->m_pState->m_sorted_central_dir_offsets, mz_uint32, i) = i;

comp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_COMPRESSED_SIZE_OFS);

decomp_size = MZ_READ_LE32(p + MZ_ZIP_CDH_DECOMPRESSED_SIZE_OFS);

local_header_ofs = MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS);

filename_size = MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS);

ext_data_size = MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS);

if ((!pZip->m_pState->m_zip64_has_extended_info_fields) &&

(ext_data_size) &&

(MZ_MAX(MZ_MAX(comp_size, decomp_size), local_header_ofs) == MZ_UINT32_MAX))

{

/* Attempt to find zip64 extended information field in the entry's extra data */

mz_uint32 extra_size_remaining = ext_data_size;

if (extra_size_remaining)

{

const mz_uint8 *pExtra_data = p + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + filename_size;

do

{

if (extra_size_remaining < (sizeof(mz_uint16) * 2))

return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);

mz_uint32 field_id = MZ_READ_LE16(pExtra_data);

mz_uint32 field_data_size = MZ_READ_LE16(pExtra_data + sizeof(mz_uint16));

if ((field_data_size + sizeof(mz_uint16) * 2) > extra_size_remaining)

return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);

if (field_id == MZ_ZIP64_EXTENDED_INFORMATION_FIELD_HEADER_ID)

{

/* Ok, the archive didn't have any zip64 headers but it uses a zip64 extended information field so mark it as zip64 anyway (this can occur with infozip's zip util when it reads compresses files from stdin). */

pZip->m_pState->m_zip64 = MZ_TRUE;

pZip->m_pState->m_zip64_has_extended_info_fields = MZ_TRUE;

break;

}

pExtra_data += sizeof(mz_uint16) * 2 + field_data_size;

extra_size_remaining = extra_size_remaining - sizeof(mz_uint16) * 2 - field_data_size;

} while (extra_size_remaining);

}

}

/* I've seen archives that aren't marked as zip64 that uses zip64 ext data, argh */

if ((comp_size != MZ_UINT32_MAX) && (decomp_size != MZ_UINT32_MAX))

{

if (((!MZ_READ_LE32(p + MZ_ZIP_CDH_METHOD_OFS)) && (decomp_size != comp_size)) || (decomp_size && !comp_size))

return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);

}

disk_index = MZ_READ_LE16(p + MZ_ZIP_CDH_DISK_START_OFS);

if ((disk_index == MZ_UINT16_MAX) || ((disk_index != num_this_disk) && (disk_index != 1)))

return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_MULTIDISK);

if (comp_size != MZ_UINT32_MAX)

{

if (((mz_uint64)MZ_READ_LE32(p + MZ_ZIP_CDH_LOCAL_HEADER_OFS) + MZ_ZIP_LOCAL_DIR_HEADER_SIZE + comp_size) > pZip->m_archive_size)

return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);

}

bit_flags = MZ_READ_LE16(p + MZ_ZIP_CDH_BIT_FLAG_OFS);

if (bit_flags & MZ_ZIP_GENERAL_PURPOSE_BIT_FLAG_LOCAL_DIR_IS_MASKED)

return mz_zip_set_error(pZip, MZ_ZIP_UNSUPPORTED_ENCRYPTION);

if ((total_header_size = MZ_ZIP_CENTRAL_DIR_HEADER_SIZE + MZ_READ_LE16(p + MZ_ZIP_CDH_FILENAME_LEN_OFS) + MZ_READ_LE16(p + MZ_ZIP_CDH_EXTRA_LEN_OFS) + MZ_READ_LE16(p + MZ_ZIP_CDH_COMMENT_LEN_OFS)) > n)

return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);

n -= total_header_size;

p += total_header_size;

}

}

if (sort_central_dir)

mz_zip_reader_sort_central_dir_offsets_by_filename(pZip);

return MZ_TRUE;

}

void mz_zip_zero_struct(mz_zip_archive *pZip)

{

if (pZip)

MZ_CLEAR_OBJ(*pZip);

}

static mz_bool mz_zip_reader_end_internal(mz_zip_archive *pZip, mz_bool set_last_error)

{

mz_bool status = MZ_TRUE;

if (!pZip)

return MZ_FALSE;

if ((!pZip->m_pState) || (!pZip->m_pAlloc) || (!pZip->m_pFree) || (pZip->m_zip_mode != MZ_ZIP_MODE_READING))

{

if (set_last_error)

pZip->m_last_error = MZ_ZIP_INVALID_PARAMETER;

return MZ_FALSE;

}

if (pZip->m_pState)

{

mz_zip_internal_state *pState = pZip->m_pState;

pZip->m_pState = NULL;

mz_zip_array_clear(pZip, &pState->m_central_dir);

mz_zip_array_clear(pZip, &pState->m_central_dir_offsets);

mz_zip_array_clear(pZip, &pState->m_sorted_central_dir_offsets);

#ifndef MINIZ_NO_STDIO

if (pState->m_pFile)

{

if (pZip->m_zip_type == MZ_ZIP_TYPE_FILE)

{

if (MZ_FCLOSE(pState->m_pFile) == EOF)

{

if (set_last_error)

pZip->m_last_error = MZ_ZIP_FILE_CLOSE_FAILED;

status = MZ_FALSE;

}

}

pState->m_pFile = NULL;

}

#endif /* #ifndef MINIZ_NO_STDIO */

pZip->m_pFree(pZip->m_pAlloc_opaque, pState);

}

pZip->m_zip_mode = MZ_ZIP_MODE_INVALID;

return status;

}

mz_bool mz_zip_reader_end(mz_zip_archive *pZip)

{

return mz_zip_reader_end_internal(pZip, MZ_TRUE);

}

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

{

if ((!pZip) || (!pZip->m_pRead))

return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);

if (!mz_zip_reader_init_internal(pZip, flags))

return MZ_FALSE;

pZip->m_zip_type = MZ_ZIP_TYPE_USER;

pZip->m_archive_size = size;

if (!mz_zip_reader_read_central_dir(pZip, flags))

{

mz_zip_reader_end_internal(pZip, MZ_FALSE);

return MZ_FALSE;

}

return MZ_TRUE;

}

static size_t mz_zip_mem_read_func(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n)

{

mz_zip_archive *pZip = (mz_zip_archive *)pOpaque;

size_t s = (file_ofs >= pZip->m_archive_size) ? 0 : (size_t)MZ_MIN(pZip->m_archive_size - file_ofs, n);

memcpy(pBuf, (const mz_uint8 *)pZip->m_pState->m_pMem + file_ofs, s);

return s;

}

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

{

if (!pMem)

return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);

if (size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)

return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);

if (!mz_zip_reader_init_internal(pZip, flags))

return MZ_FALSE;

pZip->m_zip_type = MZ_ZIP_TYPE_MEMORY;

pZip->m_archive_size = size;

pZip->m_pRead = mz_zip_mem_read_func;

pZip->m_pIO_opaque = pZip;

#ifdef __cplusplus

pZip->m_pState->m_pMem = const_cast<void *>(pMem);

#else

pZip->m_pState->m_pMem = (void *)pMem;

#endif

pZip->m_pState->m_mem_size = size;

if (!mz_zip_reader_read_central_dir(pZip, flags))

{

mz_zip_reader_end_internal(pZip, MZ_FALSE);

return MZ_FALSE;

}

return MZ_TRUE;

}

#ifndef MINIZ_NO_STDIO

static size_t mz_zip_file_read_func(void *pOpaque, mz_uint64 file_ofs, void *pBuf, size_t n)

{

mz_zip_archive *pZip = (mz_zip_archive *)pOpaque;

mz_int64 cur_ofs = MZ_FTELL64(pZip->m_pState->m_pFile);

file_ofs += pZip->m_pState->m_file_archive_start_ofs;

if (((mz_int64)file_ofs < 0) || (((cur_ofs != (mz_int64)file_ofs)) && (MZ_FSEEK64(pZip->m_pState->m_pFile, (mz_int64)file_ofs, SEEK_SET))))

return 0;

return MZ_FREAD(pBuf, 1, n, pZip->m_pState->m_pFile);

}

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

{

return mz_zip_reader_init_file_v2(pZip, pFilename, flags, 0, 0);

}

mz_bool mz_zip_reader_init_file_v2(mz_zip_archive *pZip, const char *pFilename, mz_uint flags, mz_uint64 file_start_ofs, mz_uint64 archive_size)

{

if ((!pZip) || (!pFilename) || ((archive_size) && (archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)))

return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);

mz_uint64 file_size;

MZ_FILE *pFile = MZ_FOPEN(pFilename, "rb");

if (!pFile)

return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);

file_size = archive_size;

if (!file_size)

{

if (MZ_FSEEK64(pFile, 0, SEEK_END))

{

MZ_FCLOSE(pFile);

return mz_zip_set_error(pZip, MZ_ZIP_FILE_SEEK_FAILED);

}

file_size = MZ_FTELL64(pFile);

}

/* TODO: Better sanity check archive_size and the # of actual remaining bytes */

if (file_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)

return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);

if (!mz_zip_reader_init_internal(pZip, flags))

{

MZ_FCLOSE(pFile);

return MZ_FALSE;

}

pZip->m_zip_type = MZ_ZIP_TYPE_FILE;

pZip->m_pRead = mz_zip_file_read_func;

pZip->m_pIO_opaque = pZip;

pZip->m_pState->m_pFile = pFile;

pZip->m_archive_size = file_size;

pZip->m_pState->m_file_archive_start_ofs = file_start_ofs;

if (!mz_zip_reader_read_central_dir(pZip, flags))

{

mz_zip_reader_end_internal(pZip, MZ_FALSE);

return MZ_FALSE;

}

return MZ_TRUE;

}

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

{

mz_uint64 cur_file_ofs;

if ((!pZip) || (!pFile))

return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);

cur_file_ofs = MZ_FTELL64(pFile);

if (!archive_size)

{

if (MZ_FSEEK64(pFile, 0, SEEK_END))

return mz_zip_set_error(pZip, MZ_ZIP_FILE_SEEK_FAILED);