diff --git a/thirdparty/zip/README.md b/thirdparty/zip/README.md
index bb2aaf2de254f7..79a0b239775066 100644
--- a/thirdparty/zip/README.md
+++ b/thirdparty/zip/README.md
@@ -2,31 +2,26 @@
A portable, simple zip library written in C.
-## Unlicense license
+## MIT License (changed from Unlicense in https://github.com/kuba--/zip/commit/d3983cc34c5af8354408c49786df254055fad35a)
```
-This is free and unencumbered software released into the public domain.
+All Rights Reserved.
-Anyone is free to copy, modify, publish, use, compile, sell, or
-distribute this software, either in source code form or as a compiled
-binary, for any purpose, commercial or non-commercial, and by any
-means.
+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:
-In jurisdictions that recognize copyright laws, the author or authors
-of this software dedicate any and all copyright interest in the
-software to the public domain. We make this dedication for the benefit
-of the public at large and to the detriment of our heirs and
-successors. We intend this dedication to be an overt act of
-relinquishment in perpetuity of all present and future rights to this
-software under copyright law.
+The 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 BE LIABLE FOR ANY CLAIM, DAMAGES OR
-OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
-
-For more information, please refer to
+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.
```
diff --git a/thirdparty/zip/miniz.h b/thirdparty/zip/miniz.h
index 5c5dd38281f272..d120ce8726a6b5 100644
--- a/thirdparty/zip/miniz.h
+++ b/thirdparty/zip/miniz.h
@@ -1,7 +1,7 @@
#ifndef MINIZ_EXPORT
#define MINIZ_EXPORT
#endif
-/* miniz.c 3.0.0 - public domain deflate/inflate, zlib-subset, ZIP
+/* miniz.c 3.0.2 - public domain deflate/inflate, zlib-subset, ZIP
reading/writing/appending, PNG writing See "unlicense" statement at the end
of this file. Rich Geldreich , last updated Oct. 13,
2013 Implements RFC 1950: http://www.ietf.org/rfc/rfc1950.txt and RFC 1951:
@@ -740,7 +740,9 @@ extern "C" {
/* Set TDEFL_LESS_MEMORY to 1 to use less memory (compression will be slightly
* slower, and raw/dynamic blocks will be output more frequently). */
+#ifndef TDEFL_LESS_MEMORY
#define TDEFL_LESS_MEMORY 0
+#endif
/* tdefl_init() compression flags logically OR'd together (low 12 bits contain
* the max. number of probes per dictionary search): */
@@ -1424,11 +1426,6 @@ MINIZ_EXPORT mz_bool mz_zip_reader_init_file_v2(mz_zip_archive *pZip,
mz_uint flags,
mz_uint64 file_start_ofs,
mz_uint64 archive_size);
-MINIZ_EXPORT mz_bool mz_zip_reader_init_file_v2_rpb(mz_zip_archive *pZip,
- const char *pFilename,
- mz_uint flags,
- mz_uint64 file_start_ofs,
- mz_uint64 archive_size);
/* Read an archive from an already opened FILE, beginning at the current file
* position. */
@@ -1694,8 +1691,6 @@ MINIZ_EXPORT mz_bool mz_zip_writer_init_from_reader(mz_zip_archive *pZip,
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_init_from_reader_v2_noreopen(
- mz_zip_archive *pZip, const char *pFilename, mz_uint flags);
/* Adds the contents of a memory buffer to an archive. These functions record
* the current local time into the archive. */
@@ -1832,6 +1827,8 @@ MINIZ_EXPORT void *mz_zip_extract_archive_file_to_heap_v2(
#endif
#endif /* MINIZ_NO_ARCHIVE_APIS */
+
+#ifndef MINIZ_HEADER_FILE_ONLY
/**************************************************************************
*
* Copyright 2013-2014 RAD Game Tools and Valve Software
@@ -2144,8 +2141,7 @@ mz_ulong mz_deflateBound(mz_streamp pStream, mz_ulong source_len) {
}
int mz_compress2(unsigned char *pDest, mz_ulong *pDest_len,
- const unsigned char *pSource, mz_ulong pSource_len,
- int level) {
+ const unsigned char *pSource, mz_ulong source_len, int level) {
int status;
mz_stream stream;
memset(&stream, 0, sizeof(stream));
@@ -2153,12 +2149,11 @@ int mz_compress2(unsigned char *pDest, mz_ulong *pDest_len,
#if defined(__MINGW32__) || defined(__MINGW64__) || defined(__WATCOMC__)
/* In case mz_ulong is 64-bits (argh I hate longs). */
#else
- if ((mz_uint64)(pSource_len | *pDest_len) > 0xFFFFFFFFU)
+ if ((mz_uint64)(source_len | *pDest_len) > 0xFFFFFFFFU)
return MZ_PARAM_ERROR;
#endif
-
stream.next_in = pSource;
- stream.avail_in = (mz_uint32)pSource_len;
+ stream.avail_in = (mz_uint32)source_len;
stream.next_out = pDest;
stream.avail_out = (mz_uint32)*pDest_len;
@@ -2408,7 +2403,6 @@ int mz_uncompress2(unsigned char *pDest, mz_ulong *pDest_len,
if ((mz_uint64)(*pSource_len | *pDest_len) > 0xFFFFFFFFU)
return MZ_PARAM_ERROR;
#endif
-
stream.next_in = pSource;
stream.avail_in = (mz_uint32)*pSource_len;
stream.next_out = pDest;
@@ -4952,9 +4946,17 @@ extern "C" {
#else
#include
-#if defined(_MSC_VER) || defined(__MINGW64__)
+#if defined(_MSC_VER) || defined(__MINGW64__) || defined(__MINGW32__)
+#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
+#endif
+#ifndef __cplusplus
+#define MICROSOFT_WINDOWS_WINBASE_H_DEFINE_INTERLOCKED_CPLUSPLUS_OVERLOADS 0
+#endif
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
#include
static WCHAR *mz_utf8z_to_widechar(const char *str) {
@@ -5000,12 +5002,21 @@ static FILE *mz_freopen(const char *pPath, const char *pMode, FILE *pStream) {
#endif
}
+#if defined(__MINGW32__)
+static int mz_stat(const char *path, struct _stat *buffer) {
+ WCHAR *wPath = mz_utf8z_to_widechar(path);
+ int res = _wstat(wPath, buffer);
+ free(wPath);
+ return res;
+}
+#else
static int mz_stat64(const char *path, struct __stat64 *buffer) {
WCHAR *wPath = mz_utf8z_to_widechar(path);
int res = _wstat64(wPath, buffer);
free(wPath);
return res;
}
+#endif
static int mz_mkdir(const char *pDirname) {
WCHAR *wDirname = mz_utf8z_to_widechar(pDirname);
@@ -5027,8 +5038,13 @@ static int mz_mkdir(const char *pDirname) {
#define MZ_FWRITE fwrite
#define MZ_FTELL64 _ftelli64
#define MZ_FSEEK64 _fseeki64
+#if defined(__MINGW32__)
+#define MZ_FILE_STAT_STRUCT _stat
+#define MZ_FILE_STAT mz_stat
+#else
#define MZ_FILE_STAT_STRUCT _stat64
#define MZ_FILE_STAT mz_stat64
+#endif
#define MZ_FFLUSH fflush
#define MZ_FREOPEN mz_freopen
#define MZ_DELETE_FILE remove
@@ -5612,7 +5628,7 @@ static mz_bool mz_zip_reader_locate_header_sig(mz_zip_archive *pZip,
/* 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)))
+ ((mz_uint64)(MZ_UINT16_MAX) + record_size)))
return MZ_FALSE;
cur_file_ofs = MZ_MAX(cur_file_ofs - (sizeof(buf_u32) - 3), 0);
@@ -5622,11 +5638,25 @@ static mz_bool mz_zip_reader_locate_header_sig(mz_zip_archive *pZip,
return MZ_TRUE;
}
+static mz_bool mz_zip_reader_eocd64_valid(mz_zip_archive *pZip, uint64_t offset,
+ uint8_t *buf) {
+ if (pZip->m_pRead(pZip->m_pIO_opaque, offset, buf,
+ MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) ==
+ MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE) {
+ if (MZ_READ_LE32(buf + MZ_ZIP64_ECDH_SIG_OFS) ==
+ MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIG) {
+ return MZ_TRUE;
+ }
+ }
+
+ return MZ_FALSE;
+}
+
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_uint64 cdir_ofs = 0, eocd_ofs = 0, archive_ofs = 0;
mz_int64 cur_file_ofs = 0;
const mz_uint8 *p;
@@ -5657,6 +5687,7 @@ static mz_bool mz_zip_reader_read_central_dir(mz_zip_archive *pZip,
MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE, &cur_file_ofs))
return mz_zip_set_error(pZip, MZ_ZIP_FAILED_FINDING_CENTRAL_DIR);
+ eocd_ofs = cur_file_ofs;
/* 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) !=
@@ -5676,25 +5707,38 @@ static mz_bool mz_zip_reader_read_central_dir(mz_zip_archive *pZip,
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_pState->m_zip64 = MZ_TRUE;
}
}
}
+ if (pZip->m_pState->m_zip64) {
+ /* Try locating the EOCD64 right before the EOCD64 locator. This works even
+ * when the effective start of the zip header is not yet known. */
+ if (cur_file_ofs < MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE +
+ MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE)
+ return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
+
+ zip64_end_of_central_dir_ofs = cur_file_ofs -
+ MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE -
+ MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE;
+
+ if (!mz_zip_reader_eocd64_valid(pZip, zip64_end_of_central_dir_ofs,
+ pZip64_end_of_central_dir)) {
+ /* That failed, try reading where the locator tells us to. */
+ 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 (!mz_zip_reader_eocd64_valid(pZip, zip64_end_of_central_dir_ofs,
+ pZip64_end_of_central_dir))
+ return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
+ }
+ }
+
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);
@@ -5765,6 +5809,29 @@ static mz_bool mz_zip_reader_read_central_dir(mz_zip_archive *pZip,
if ((cdir_ofs + (mz_uint64)cdir_size) > pZip->m_archive_size)
return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
+ if (eocd_ofs < cdir_ofs + cdir_size)
+ return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
+
+ /* The end of central dir follows the central dir, unless the zip file has
+ * some trailing data (e.g. it is appended to an executable file). */
+ archive_ofs = eocd_ofs - (cdir_ofs + cdir_size);
+ if (pZip->m_pState->m_zip64) {
+ if (archive_ofs < MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE +
+ MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE)
+ return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
+
+ archive_ofs -= MZ_ZIP64_END_OF_CENTRAL_DIR_HEADER_SIZE +
+ MZ_ZIP64_END_OF_CENTRAL_DIR_LOCATOR_SIZE;
+ }
+
+ /* Update the archive start position, but only if not specified. */
+ if ((pZip->m_zip_type == MZ_ZIP_TYPE_FILE ||
+ pZip->m_zip_type == MZ_ZIP_TYPE_CFILE) &&
+ pZip->m_pState->m_file_archive_start_ofs == 0) {
+ pZip->m_pState->m_file_archive_start_ofs = archive_ofs;
+ pZip->m_archive_size -= archive_ofs;
+ }
+
pZip->m_central_directory_file_ofs = cdir_ofs;
if (pZip->m_total_files) {
@@ -6113,60 +6180,6 @@ mz_bool mz_zip_reader_init_file_v2(mz_zip_archive *pZip, const char *pFilename,
return MZ_TRUE;
}
-mz_bool mz_zip_reader_init_file_v2_rpb(mz_zip_archive *pZip,
- const char *pFilename, mz_uint flags,
- mz_uint64 file_start_ofs,
- mz_uint64 archive_size) {
- mz_uint64 file_size;
- MZ_FILE *pFile;
-
- if ((!pZip) || (!pFilename) ||
- ((archive_size) &&
- (archive_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE)))
- return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
- pFile = MZ_FOPEN(pFilename, "r+b");
- if (!pFile)
- return mz_zip_set_error(pZip, MZ_ZIP_FILE_OPEN_FAILED);
-
- file_size = archive_size;
- if (!file_size) {
- if (MZ_FSEEK64(pFile, 0, SEEK_END)) {
- MZ_FCLOSE(pFile);
- return mz_zip_set_error(pZip, MZ_ZIP_FILE_SEEK_FAILED);
- }
-
- file_size = MZ_FTELL64(pFile);
- }
-
- /* TODO: Better sanity check archive_size and the # of actual remaining bytes
- */
-
- if (file_size < MZ_ZIP_END_OF_CENTRAL_DIR_HEADER_SIZE) {
- MZ_FCLOSE(pFile);
- return mz_zip_set_error(pZip, MZ_ZIP_NOT_AN_ARCHIVE);
- }
-
- if (!mz_zip_reader_init_internal(pZip, flags)) {
- MZ_FCLOSE(pFile);
- return MZ_FALSE;
- }
-
- pZip->m_zip_type = MZ_ZIP_TYPE_FILE;
- pZip->m_pRead = mz_zip_file_read_func;
- pZip->m_pIO_opaque = pZip;
- pZip->m_pState->m_pFile = pFile;
- pZip->m_archive_size = file_size;
- pZip->m_pState->m_file_archive_start_ofs = file_start_ofs;
-
- if (!mz_zip_reader_read_central_dir(pZip, flags)) {
- mz_zip_reader_end_internal(pZip, MZ_FALSE);
- return MZ_FALSE;
- }
-
- return MZ_TRUE;
-}
-
mz_bool mz_zip_reader_init_cfile(mz_zip_archive *pZip, MZ_FILE *pFile,
mz_uint64 archive_size, mz_uint flags) {
mz_uint64 cur_file_ofs;
@@ -6639,7 +6652,7 @@ static mz_bool mz_zip_reader_extract_to_mem_no_alloc1(
if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG)
return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
- cur_file_ofs += MZ_ZIP_LOCAL_DIR_HEADER_SIZE +
+ cur_file_ofs += (mz_uint64)(MZ_ZIP_LOCAL_DIR_HEADER_SIZE) +
MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS) +
MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS);
if ((cur_file_ofs + file_stat.m_comp_size) > pZip->m_archive_size)
@@ -6880,7 +6893,7 @@ mz_bool mz_zip_reader_extract_to_callback(mz_zip_archive *pZip,
if (MZ_READ_LE32(pLocal_header) != MZ_ZIP_LOCAL_DIR_HEADER_SIG)
return mz_zip_set_error(pZip, MZ_ZIP_INVALID_HEADER_OR_CORRUPTED);
- cur_file_ofs += MZ_ZIP_LOCAL_DIR_HEADER_SIZE +
+ cur_file_ofs += (mz_uint64)(MZ_ZIP_LOCAL_DIR_HEADER_SIZE) +
MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS) +
MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS);
if ((cur_file_ofs + file_stat.m_comp_size) > pZip->m_archive_size)
@@ -7127,7 +7140,7 @@ mz_zip_reader_extract_iter_new(mz_zip_archive *pZip, mz_uint file_index,
}
pState->cur_file_ofs +=
- MZ_ZIP_LOCAL_DIR_HEADER_SIZE +
+ (mz_uint64)(MZ_ZIP_LOCAL_DIR_HEADER_SIZE) +
MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_FILENAME_LEN_OFS) +
MZ_READ_LE16(pLocal_header + MZ_ZIP_LDH_EXTRA_LEN_OFS);
if ((pState->cur_file_ofs + pState->file_stat.m_comp_size) >
@@ -8195,88 +8208,6 @@ mz_bool mz_zip_writer_init_from_reader_v2(mz_zip_archive *pZip,
return MZ_TRUE;
}
-mz_bool mz_zip_writer_init_from_reader_v2_noreopen(mz_zip_archive *pZip,
- const char *pFilename,
- mz_uint flags) {
- mz_zip_internal_state *pState;
-
- if ((!pZip) || (!pZip->m_pState) || (pZip->m_zip_mode != MZ_ZIP_MODE_READING))
- return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
- if (flags & MZ_ZIP_FLAG_WRITE_ZIP64) {
- /* We don't support converting a non-zip64 file to zip64 - this seems like
- * more trouble than it's worth. (What about the existing 32-bit data
- * descriptors that could follow the compressed data?) */
- if (!pZip->m_pState->m_zip64)
- return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
- }
-
- /* No sense in trying to write to an archive that's already at the support max
- * size */
- if (pZip->m_pState->m_zip64) {
- if (pZip->m_total_files == MZ_UINT32_MAX)
- return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
- } else {
- if (pZip->m_total_files == MZ_UINT16_MAX)
- return mz_zip_set_error(pZip, MZ_ZIP_TOO_MANY_FILES);
-
- if ((pZip->m_archive_size + MZ_ZIP_CENTRAL_DIR_HEADER_SIZE +
- MZ_ZIP_LOCAL_DIR_HEADER_SIZE) > MZ_UINT32_MAX)
- return mz_zip_set_error(pZip, MZ_ZIP_FILE_TOO_LARGE);
- }
-
- pState = pZip->m_pState;
-
- if (pState->m_pFile) {
-#ifdef MINIZ_NO_STDIO
- (void)pFilename;
- return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-#else
- if (pZip->m_pIO_opaque != pZip)
- return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
- if (pZip->m_zip_type == MZ_ZIP_TYPE_FILE) {
- if (!pFilename)
- return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
- }
-
- pZip->m_pWrite = mz_zip_file_write_func;
- pZip->m_pNeeds_keepalive = NULL;
-#endif /* #ifdef MINIZ_NO_STDIO */
- } else if (pState->m_pMem) {
- /* Archive lives in a memory block. Assume it's from the heap that we can
- * resize using the realloc callback. */
- if (pZip->m_pIO_opaque != pZip)
- return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
- pState->m_mem_capacity = pState->m_mem_size;
- pZip->m_pWrite = mz_zip_heap_write_func;
- pZip->m_pNeeds_keepalive = NULL;
- }
- /* Archive is being read via a user provided read function - make sure the
- user has specified a write function too. */
- else if (!pZip->m_pWrite)
- return mz_zip_set_error(pZip, MZ_ZIP_INVALID_PARAMETER);
-
- /* Start writing new files at the archive's current central directory
- * location. */
- /* TODO: We could add a flag that lets the user start writing immediately
- * AFTER the existing central dir - this would be safer. */
- pZip->m_archive_size = pZip->m_central_directory_file_ofs;
- pZip->m_central_directory_file_ofs = 0;
-
- /* Clear the sorted central dir offsets, they aren't useful or maintained now.
- */
- /* Even though we're now in write mode, files can still be extracted and
- * verified, but file locates will be slow. */
- /* TODO: We could easily maintain the sorted central directory offsets. */
- mz_zip_array_clear(pZip, &pZip->m_pState->m_sorted_central_dir_offsets);
-
- pZip->m_zip_mode = MZ_ZIP_MODE_WRITING;
-
- return MZ_TRUE;
-}
-
mz_bool mz_zip_writer_init_from_reader(mz_zip_archive *pZip,
const char *pFilename) {
return mz_zip_writer_init_from_reader_v2(pZip, pFilename, 0);
@@ -8379,6 +8310,7 @@ static mz_bool mz_zip_writer_create_central_dir_header(
(void)pZip;
memset(pDst, 0, MZ_ZIP_CENTRAL_DIR_HEADER_SIZE);
MZ_WRITE_LE32(pDst + MZ_ZIP_CDH_SIG_OFS, MZ_ZIP_CENTRAL_DIR_HEADER_SIG);
+ MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_VERSION_MADE_BY_OFS, 0x031E);
MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_VERSION_NEEDED_OFS, method ? 20 : 0);
MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_BIT_FLAG_OFS, bit_flags);
MZ_WRITE_LE16(pDst + MZ_ZIP_CDH_METHOD_OFS, method);
@@ -8571,6 +8503,8 @@ mz_bool mz_zip_writer_add_mem_ex_v2(
time(&cur_time);
mz_zip_time_t_to_dos_time(cur_time, &dos_time, &dos_date);
}
+#else
+ (void)last_modified;
#endif /* #ifndef MINIZ_NO_TIME */
if (!(level_and_flags & MZ_ZIP_FLAG_COMPRESSED_DATA)) {
@@ -8899,6 +8833,8 @@ mz_bool mz_zip_writer_add_read_buf_callback(
if (pFile_time) {
mz_zip_time_t_to_dos_time(*pFile_time, &dos_time, &dos_date);
}
+#else
+ (void)pFile_time;
#endif
if (max_size <= 3)
@@ -9425,9 +9361,9 @@ mz_bool mz_zip_writer_add_from_zip_reader(mz_zip_archive *pZip,
MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_COMPRESSED_SIZE_OFS);
local_header_uncomp_size =
MZ_READ_LE32(pLocal_header + MZ_ZIP_LDH_DECOMPRESSED_SIZE_OFS);
- src_archive_bytes_remaining = local_header_filename_size +
- local_header_extra_len +
- src_file_stat.m_comp_size;
+ src_archive_bytes_remaining = src_file_stat.m_comp_size +
+ local_header_filename_size +
+ local_header_extra_len;
/* Try to find a zip64 extended information field */
if ((local_header_extra_len) &&
@@ -10251,3 +10187,5 @@ mz_bool mz_zip_end(mz_zip_archive *pZip) {
#endif
#endif /*#ifndef MINIZ_NO_ARCHIVE_APIS*/
+
+#endif // MINIZ_HEADER_FILE_ONLY
diff --git a/thirdparty/zip/zip.c b/thirdparty/zip/zip.c
index b14f9e3b1b54e2..f123823169ffd4 100644
--- a/thirdparty/zip/zip.c
+++ b/thirdparty/zip/zip.c
@@ -304,7 +304,7 @@ static int zip_archive_truncate(mz_zip_archive *pzip) {
if (pzip->m_zip_mode == MZ_ZIP_MODE_WRITING_HAS_BEEN_FINALIZED) {
if (pState->m_pFile) {
int fd = fileno(pState->m_pFile);
- return ftruncate(fd, file_size);
+ return ftruncate(fd, pState->m_file_archive_start_ofs + file_size);
}
}
return 0;
@@ -382,8 +382,8 @@ static int zip_archive_extract(mz_zip_archive *zip_archive, const char *dir,
19)) // if zip is produced on Unix or macOS (3 and 19 from
// section 4.4.2.2 of zip standard)
&& info.m_external_attr &
- (0x20 << 24)) { // and has sym link attribute (0x80 is file, 0x40
- // is directory)
+ (0x20 << 24)) { // and has sym link attribute (0x80 is file,
+ // 0x40 is directory)
#if defined(_WIN32) || defined(__WIN32__) || defined(_MSC_VER) || \
defined(__MINGW32__)
#else
@@ -445,9 +445,9 @@ static inline void zip_archive_finalize(mz_zip_archive *pzip) {
static ssize_t zip_entry_mark(struct zip_t *zip,
struct zip_entry_mark_t *entry_mark,
- const ssize_t n, char *const entries[],
+ const size_t n, char *const entries[],
const size_t len) {
- ssize_t i = 0;
+ size_t i = 0;
ssize_t err = 0;
if (!zip || !entry_mark || !entries) {
return ZIP_ENOINIT;
@@ -476,7 +476,7 @@ static ssize_t zip_entry_mark(struct zip_t *zip,
entry_mark[i].type = MZ_KEEP;
}
- if (!mz_zip_reader_file_stat(&zip->archive, i, &file_stat)) {
+ if (!mz_zip_reader_file_stat(&zip->archive, (mz_uint)i, &file_stat)) {
return ZIP_ENOENT;
}
@@ -502,9 +502,9 @@ static ssize_t zip_entry_mark(struct zip_t *zip,
static ssize_t zip_entry_markbyindex(struct zip_t *zip,
struct zip_entry_mark_t *entry_mark,
- const ssize_t n, size_t entries[],
+ const size_t n, size_t entries[],
const size_t len) {
- ssize_t i = 0;
+ size_t i = 0;
ssize_t err = 0;
if (!zip || !entry_mark || !entries) {
return ZIP_ENOINIT;
@@ -521,7 +521,7 @@ static ssize_t zip_entry_markbyindex(struct zip_t *zip,
{
size_t j;
for (j = 0; j < len; ++j) {
- if ((size_t)i == entries[j]) {
+ if (i == entries[j]) {
matches = MZ_TRUE;
break;
}
@@ -533,7 +533,7 @@ static ssize_t zip_entry_markbyindex(struct zip_t *zip,
entry_mark[i].type = MZ_KEEP;
}
- if (!mz_zip_reader_file_stat(&zip->archive, i, &file_stat)) {
+ if (!mz_zip_reader_file_stat(&zip->archive, (mz_uint)i, &file_stat)) {
return ZIP_ENOENT;
}
@@ -596,9 +596,8 @@ static int zip_index_update(struct zip_entry_mark_t *entry_mark,
static int zip_entry_finalize(struct zip_t *zip,
struct zip_entry_mark_t *entry_mark,
- const ssize_t n) {
-
- ssize_t i = 0;
+ const size_t n) {
+ size_t i = 0;
mz_uint64 *local_header_ofs_array = (mz_uint64 *)calloc(n, sizeof(mz_uint64));
if (!local_header_ofs_array) {
return ZIP_EOOMEM;
@@ -608,7 +607,7 @@ static int zip_entry_finalize(struct zip_t *zip,
local_header_ofs_array[i] = entry_mark[i].m_local_header_ofs;
ssize_t index = zip_sort(local_header_ofs_array, i);
- if (index != i) {
+ if ((size_t)index != i) {
zip_index_update(entry_mark, i, index);
}
entry_mark[i].file_index = index;
@@ -636,7 +635,7 @@ static int zip_entry_finalize(struct zip_t *zip,
}
static ssize_t zip_entry_set(struct zip_t *zip,
- struct zip_entry_mark_t *entry_mark, ssize_t n,
+ struct zip_entry_mark_t *entry_mark, size_t n,
char *const entries[], const size_t len) {
ssize_t err = 0;
@@ -651,7 +650,7 @@ static ssize_t zip_entry_set(struct zip_t *zip,
static ssize_t zip_entry_setbyindex(struct zip_t *zip,
struct zip_entry_mark_t *entry_mark,
- ssize_t n, size_t entries[],
+ size_t n, size_t entries[],
const size_t len) {
ssize_t err = 0;
@@ -993,24 +992,30 @@ struct zip_t *zip_openwitherror(const char *zipname, int level, char mode,
break;
case 'a':
- case 'd':
- if (!mz_zip_reader_init_file_v2_rpb(
- &(zip->archive), zipname,
- zip->level | MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY, 0, 0)) {
- // An archive file does not exist or cannot initialize
- // zip_archive reader
+ case 'd': {
+ MZ_FILE *fp = MZ_FOPEN(zipname, "r+b");
+ if (!fp) {
+ *errnum = ZIP_EOPNFILE;
+ goto cleanup;
+ }
+ if (!mz_zip_reader_init_cfile(
+ &(zip->archive), fp, 0,
+ zip->level | MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY)) {
+ // An archive file does not exist or cannot initialize zip_archive
+ // reader
*errnum = ZIP_ERINIT;
+ fclose(fp);
goto cleanup;
}
- if ((mode == 'a' || mode == 'd')) {
- if (!mz_zip_writer_init_from_reader_v2_noreopen(&(zip->archive), zipname,
- 0)) {
- *errnum = ZIP_EWRINIT;
- mz_zip_reader_end(&(zip->archive));
- goto cleanup;
- }
+ if (!mz_zip_writer_init_from_reader_v2(&(zip->archive), zipname, 0)) {
+ *errnum = ZIP_EWRINIT;
+ fclose(fp);
+ mz_zip_reader_end(&(zip->archive));
+ goto cleanup;
}
- break;
+ // The file pointer is now owned by the archive object.
+ zip->archive.m_zip_type = MZ_ZIP_TYPE_FILE;
+ } break;
default:
*errnum = ZIP_EINVMODE;
@@ -1055,6 +1060,16 @@ int zip_is64(struct zip_t *zip) {
return (int)zip->archive.m_pState->m_zip64;
}
+int zip_offset(struct zip_t *zip, uint64_t *offset) {
+ if (!zip || !zip->archive.m_pState) {
+ // zip_t handler or zip state is not initialized
+ return ZIP_ENOINIT;
+ }
+
+ *offset = mz_zip_get_archive_file_start_offset(&zip->archive);
+ return 0;
+}
+
static int _zip_entry_open(struct zip_t *zip, const char *entryname,
int case_sensitive) {
size_t entrylen = 0;
@@ -1736,6 +1751,9 @@ ssize_t zip_entries_delete(struct zip_t *zip, char *const entries[],
}
n = zip_entries_total(zip);
+ if (n < 0) {
+ return n;
+ }
entry_mark = (struct zip_entry_mark_t *)calloc(
(size_t)n, sizeof(struct zip_entry_mark_t));
@@ -1745,7 +1763,7 @@ ssize_t zip_entries_delete(struct zip_t *zip, char *const entries[],
zip->archive.m_zip_mode = MZ_ZIP_MODE_READING;
- err = zip_entry_set(zip, entry_mark, n, entries, len);
+ err = zip_entry_set(zip, entry_mark, (size_t)n, entries, len);
if (err < 0) {
CLEANUP(entry_mark);
return err;
@@ -1771,6 +1789,9 @@ ssize_t zip_entries_deletebyindex(struct zip_t *zip, size_t entries[],
}
n = zip_entries_total(zip);
+ if (n < 0) {
+ return n;
+ }
entry_mark = (struct zip_entry_mark_t *)calloc(
(size_t)n, sizeof(struct zip_entry_mark_t));
@@ -1780,7 +1801,7 @@ ssize_t zip_entries_deletebyindex(struct zip_t *zip, size_t entries[],
zip->archive.m_zip_mode = MZ_ZIP_MODE_READING;
- err = zip_entry_setbyindex(zip, entry_mark, n, entries, len);
+ err = zip_entry_setbyindex(zip, entry_mark, (size_t)n, entries, len);
if (err < 0) {
CLEANUP(entry_mark);
return err;
@@ -1874,7 +1895,7 @@ ssize_t zip_stream_copy(struct zip_t *zip, void **buf, size_t *bufsize) {
*bufsize = n;
}
- *buf = calloc(sizeof(unsigned char), n);
+ *buf = calloc(n, sizeof(unsigned char));
memcpy(*buf, zip->archive.m_pState->m_pMem, n);
return (ssize_t)n;
@@ -1952,8 +1973,7 @@ struct zip_t *zip_cstream_openwitherror(FILE *stream, int level, char mode,
goto cleanup;
}
if ((mode == 'a' || mode == 'd')) {
- if (!mz_zip_writer_init_from_reader_v2_noreopen(&(zip->archive), NULL,
- 0)) {
+ if (!mz_zip_writer_init_from_reader_v2(&(zip->archive), NULL, 0)) {
*errnum = ZIP_EWRINIT;
mz_zip_reader_end(&(zip->archive));
goto cleanup;
diff --git a/thirdparty/zip/zip.h b/thirdparty/zip/zip.h
index 92056d5c5c40b5..dce99ffbc9722b 100644
--- a/thirdparty/zip/zip.h
+++ b/thirdparty/zip/zip.h
@@ -162,6 +162,16 @@ extern ZIP_EXPORT void zip_close(struct zip_t *zip);
*/
extern ZIP_EXPORT int zip_is64(struct zip_t *zip);
+/**
+ * Returns the offset in the stream where the zip header is located.
+ *
+ * @param zip zip archive handler.
+ * @param offset zip header offset.
+ *
+ * @return the return code - 0 if successful, negative number (< 0) on error.
+ */
+extern ZIP_EXPORT int zip_offset(struct zip_t *zip, uint64_t *offset);
+
/**
* Opens an entry by name in the zip archive.
*