+ if (IsWin10BuildAtLeast(WIN_10_1607_BUILD))

+ 0x17, 0x8C, 0x1B, 0x37, 0x70, 0xBF, 0x8B, 0xDF, 0x84, 0x55, 0xC5, 0x18,

+ 0x13, 0x64, 0xE9, 0x65, 0x6D, 0x67, 0xCA, 0x0C, 0xD6, 0x3B, 0x9E, 0x7B,

+ 0x9B, 0x6A, 0x63, 0xD6, 0x19, 0xAE, 0xD7, 0xBA, 0xBE, 0x5C, 0xCB, 0xD1,

+ 0x07, 0x89, 0x07, 0xFB, 0x12, 0xC0, 0x2C, 0x94, 0x86, 0xEB, 0x67, 0x0B,

+ 0x9C, 0x97, 0xEB, 0x20, 0x38, 0x13, 0x9C, 0x0F, 0x56, 0x93, 0x1B, 0x19,

+ 0x6F, 0x8F, 0x6A, 0x39

+BOOL IsWin10BuildAtLeast(DWORD minBuild)

+{

+ // Must first be recognized as Windows 10 or higher

+ if (nCurrentOS < WIN_10)

+ return FALSE;

+

+ // If we’re on Windows 10, check build number

+ if (nCurrentOS == WIN_10 && CurrentOSBuildNumber < minBuild)

+ return FALSE;

+

+ // If we are on a higher version of Windows, we are good to go

+ return TRUE;

+}

+

+ if (!IsWin10BuildAtLeast(WIN_10_1809_BUILD))

+ // abort using a message that says that VeraCrypt can run only on Windows 10 version 1809 or later

+ AbortProcessDirect(L"VeraCrypt requires at least Windows 10 version 1809 (October 2018 Update) to run.");

+#define WIN_10_1607_BUILD 14393 // Windows 10 version 1607 corresponds to build 14393

+#define WIN_10_1809_BUILD 17763 // Windows 10 version 1809 corresponds to build 17763

+

+BOOL IsWin10BuildAtLeast(DWORD minBuild);

+#include <pdh.h>

+#include <pdhmsg.h>

+static HMODULE hPdhLib = NULL;

+

+typedef PDH_STATUS (WINAPI *PfnPdhOpenQueryW)(LPCWSTR, DWORD_PTR, PDH_HQUERY *);

+typedef PDH_STATUS (WINAPI *PfnPdhAddCounterW)(PDH_HQUERY, LPCWSTR, DWORD_PTR, PDH_HCOUNTER *);

+typedef PDH_STATUS (WINAPI *PfnPdhCollectQueryData)(PDH_HQUERY);

+typedef PDH_STATUS (WINAPI *PfnPdhGetFormattedCounterValue)(PDH_HCOUNTER, DWORD, LPDWORD, PPDH_FMT_COUNTERVALUE);

+typedef PDH_STATUS (WINAPI *PfnPdhCloseQuery)(PDH_HQUERY);

+

+static PfnPdhOpenQueryW pfnPdhOpenQuery = NULL;

+static PfnPdhAddCounterW pfnPdhAddCounter = NULL;

+static PfnPdhCollectQueryData pfnPdhCollectQueryData = NULL;

+static PfnPdhGetFormattedCounterValue pfnPdhGetFormattedCounterValue = NULL;

+static PfnPdhCloseQuery pfnPdhCloseQuery = NULL;

+

+static BOOL LoadPdhDll()

+{

+ if (!hPdhLib)

+ {

+ hPdhLib = LoadLibraryExW(L"pdh.dll", NULL, LOAD_LIBRARY_SEARCH_SYSTEM32);

+ if (!hPdhLib)

+ return FALSE;

+

+ pfnPdhOpenQuery = (PfnPdhOpenQueryW) GetProcAddress(hPdhLib, "PdhOpenQueryW");

+ pfnPdhAddCounter = (PfnPdhAddCounterW) GetProcAddress(hPdhLib, "PdhAddCounterW");

+ pfnPdhCollectQueryData = (PfnPdhCollectQueryData) GetProcAddress(hPdhLib, "PdhCollectQueryData");

+ pfnPdhGetFormattedCounterValue = (PfnPdhGetFormattedCounterValue) GetProcAddress(hPdhLib, "PdhGetFormattedCounterValue");

+ pfnPdhCloseQuery = (PfnPdhCloseQuery) GetProcAddress(hPdhLib, "PdhCloseQuery");

+ }

+

+ return (pfnPdhOpenQuery && pfnPdhAddCounter && pfnPdhCollectQueryData &&

+ pfnPdhGetFormattedCounterValue && pfnPdhCloseQuery);

+}

+

+ #ifndef WOLFCRYPT_BACKEND

+ #ifndef WOLFCRYPT_BACKEND

+

+/* -------------------------------------------------------------------------------------

+ GetDiskStatistics: This function uses the Windows Performance Data Helper (PDH) API

+ to collect disk statistics. The function collects the number of disk reads and writes

+ per second for all physical disks. The function also collects high-resolution

+ timestamps before and after the PDH query. The function then adds the collected data

+ to the random pool.

+ The code waits a short random interval between the two PDH samples to ensures that

+ the performance counters have time to accumulate measurable changes and produce more

+ varied data.

+ -------------------------------------------------------------------------------------

+*/

+void GetDiskStatistics()

+{

+ if (!LoadPdhDll())

+ return;

+ PDH_STATUS status;

+ PDH_HQUERY query = NULL;

+ PDH_HCOUNTER counterReads = NULL, counterWrites = NULL;

+ PDH_FMT_COUNTERVALUE counterValue;

+ DWORD dwType;

+ LONGLONG llReads = 0, llWrites = 0;

+ DWORDLONG tstampBefore = 0, tstampAfter = 0;

+ LARGE_INTEGER perfCounterBefore, perfCounterAfter;

+

+ // High-resolution timestamps

+ if (!QueryPerformanceCounter(&perfCounterBefore))

+ return;

+ tstampBefore = GetTickCount64();

+

+ // Open PDH query

+ status = pfnPdhOpenQuery(NULL, 0, &query);

+ if (status != ERROR_SUCCESS)

+ goto error;

+

+ // Add counters for disk reads and writes (all physical disks).

+ status = pfnPdhAddCounter(query, L"\\PhysicalDisk(*)\\Disk Reads/sec", 0, &counterReads);

+ if (status != ERROR_SUCCESS)

+ goto error;

+

+ status = pfnPdhAddCounter(query, L"\\PhysicalDisk(*)\\Disk Writes/sec", 0, &counterWrites);

+ if (status != ERROR_SUCCESS)

+ goto error;

+

+ // First sample

+ status = pfnPdhCollectQueryData(query);

+ if (status != ERROR_SUCCESS)

+ goto error;

+

+ // Wait a short random interval

+ Sleep(10 + (GetCurrentProcessId() % 40));

+

+ // Second sample

+ status = pfnPdhCollectQueryData(query);

+ if (status != ERROR_SUCCESS)

+ goto error;

+

+ // Format counters in PDH_FMT_LARGE

+ status = pfnPdhGetFormattedCounterValue(counterReads, PDH_FMT_LARGE, &dwType, &counterValue);

+ if (status == ERROR_SUCCESS)

+ llReads = counterValue.largeValue;

+

+ status = pfnPdhGetFormattedCounterValue(counterWrites, PDH_FMT_LARGE, &dwType, &counterValue);

+ if (status == ERROR_SUCCESS)

+ llWrites = counterValue.largeValue;

+

+ // Another high-resolution timestamp

+ if (!QueryPerformanceCounter(&perfCounterAfter))

+ goto error;

+ tstampAfter = GetTickCount64();

+ // Close PDH query

+ pfnPdhCloseQuery(query);

+ query = NULL;

+ // Collect results into the random pool

+ RandaddBuf(&llReads, sizeof(llReads));

+ RandaddBuf(&llWrites, sizeof(llWrites));

+ RandaddBuf(&tstampBefore, sizeof(tstampBefore));

+ RandaddBuf(&tstampAfter, sizeof(tstampAfter));

+ RandaddBuf(&perfCounterBefore.QuadPart, sizeof(perfCounterBefore.QuadPart));

+ RandaddBuf(&perfCounterAfter.QuadPart, sizeof(perfCounterAfter.QuadPart));

+

+error:

+ if (query)

+ pfnPdhCloseQuery(query);

+}

+

+

+/* -------------------------------------------------------------------------------------

+ GetNetworkStatistics: This function uses the Windows Performance Data Helper (PDH) API

+ to collect network statistics. The function collects the number of bytes sent and

+ received per second for all network interfaces. The function also collects

+ high-resolution timestamps before and after the PDH query. The function then adds the

+ collected data to the random pool.

+ The code waits a short random interval between the two PDH samples to ensures that

+ the performance counters have time to accumulate measurable changes and produce more

+ varied data.

+*/

+void GetNetworkStatistics()

+ if (!LoadPdhDll())

+ return;

+ PDH_STATUS status;

+ PDH_HQUERY query = NULL;

+ PDH_HCOUNTER counterBytesSent = NULL, counterBytesReceived = NULL;

+ PDH_FMT_COUNTERVALUE counterValue;

+ DWORD dwType;

+ LONGLONG llBytesSent = 0, llBytesReceived = 0;

+ DWORDLONG tstampBefore = 0, tstampAfter = 0;

+ LARGE_INTEGER perfCounterBefore, perfCounterAfter;

+

+ // High-resolution timestamps

+ if (!QueryPerformanceCounter(&perfCounterBefore))

+ return;

+ tstampBefore = GetTickCount64();

+ // Open PDH query

+ status = pfnPdhOpenQuery(NULL, 0, &query);

+ if (status != ERROR_SUCCESS)

+ goto error;

+ // Add counters for network bytes sent and received

+ status = pfnPdhAddCounter(query, L"\\Network Interface(*)\\Bytes Sent/sec", 0, &counterBytesSent);

+ if (status != ERROR_SUCCESS)

+ goto error;

+ status = pfnPdhAddCounter(query, L"\\Network Interface(*)\\Bytes Received/sec", 0, &counterBytesReceived);

+ if (status != ERROR_SUCCESS)

+ goto error;

+ // First sample

+ status = pfnPdhCollectQueryData(query);

+ if (status != ERROR_SUCCESS)

+ goto error;

+ // Wait short, dynamic interval

+ Sleep(10 + (GetCurrentProcessId() % 40));

+ // Second sample

+ status = pfnPdhCollectQueryData(query);

+ if (status != ERROR_SUCCESS)

+ goto error;

+ // Format counters

+ status = pfnPdhGetFormattedCounterValue(counterBytesSent, PDH_FMT_LARGE, &dwType, &counterValue);

+ if (status == ERROR_SUCCESS)

+ llBytesSent = counterValue.largeValue;

+ status = pfnPdhGetFormattedCounterValue(counterBytesReceived, PDH_FMT_LARGE, &dwType, &counterValue);

+ if (status == ERROR_SUCCESS)

+ llBytesReceived = counterValue.largeValue;

+ if (!QueryPerformanceCounter(&perfCounterAfter))

+ goto error;

+ tstampAfter = GetTickCount64();

+ // Close PDH query

+ pfnPdhCloseQuery(query);

+ query = NULL;

+ // Collect results into our random pool

+ RandaddBuf(&llBytesSent, sizeof(llBytesSent));

+ RandaddBuf(&llBytesReceived, sizeof(llBytesReceived));

+ RandaddBuf(&tstampBefore, sizeof(tstampBefore));

+ RandaddBuf(&tstampAfter, sizeof(tstampAfter));

+ RandaddBuf(&perfCounterBefore.QuadPart, sizeof(perfCounterBefore.QuadPart));

+ RandaddBuf(&perfCounterAfter.QuadPart, sizeof(perfCounterAfter.QuadPart));

+

+error:

+ if (query)

+ pfnPdhCloseQuery(query);

+}

+

+/* This is the slowpoll function which gathers up network/hard drive

+ performance data for the random pool */

+BOOL SlowPoll (void)

+{

+ NTSTATUS bStatus = 0;

+

+ // Gather disk stats via PDH

+ GetDiskStatistics();

+

+ // Gather network stats via PDH

+ GetNetworkStatistics();

+ if ( IsCpuRngEnabled() &&

+

+ /* Mix the pool */

+ if ( IsCpuRngEnabled() &&

+#define TCalloc(size) ((void *) ExAllocatePoolUninitialized( NonPagedPoolNx , size, AllocTag ))

+ <ClCompile Include="libzip\zip_source_get_dostime.c" />

+ <ClCompile Include="libzip\zip_source_get_dostime.c">

+ <Filter>libzip</Filter>

+ </ClCompile>

+# 1.11.2 [2024-10-31]

+

+* Fix performance regression in `zip_stat` introduced in 1.11.

+

+# 1.11.1 [2024-09-19]

+

+* Fix zipconf.h for version number with missing third component.

+

+# 1.11 [2024-09-19]

+

+* Stop searching after finding acceptable central directory, even if it contains inconsistencies.

+* Only write Zip64 EOCD if fields don't fit in normal EOCD. Previously libzip also wrote it when any directory entry required Zip64.

+* Allow bytes from 0x00-0x1F as UTF-8.

+* Add new error code `ZIP_ER_TRUNCATED_ZIP` for files that start with a valid local header signature.

+* `zipcmp`: add `-T` option for comparing timestamps.

+* `zip_file_replace` now removes the target's extra field information.

+

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+

+#if defined(HAVE__FSEEKI64) && defined(HAVE__FSTAT64) && defined(HAVE__FTELLI64)

+/* Windows API using int64 */

+typedef zip_int64_t zip_off_t;

+typedef struct _stat64 zip_os_stat_t;

+#define zip_os_stat _stat64

+#define zip_os_fstat _fstat64

+#define zip_os_fseek _fseeki64

+#define zip_os_ftell _ftelli64

+#define ZIP_FSEEK_MAX ZIP_INT64_MAX

+#define ZIP_FSEEK_MIN ZIP_INT64_MIN

+#else

+

+/* Normal API */

+#include <sys/stat.h>

+typedef struct stat zip_os_stat_t;

+#define zip_os_fstat fstat

+#define zip_os_stat stat

+

+#if defined(HAVE_FTELLO) && defined(HAVE_FSEEKO)

+/* Using off_t */

+typedef off_t zip_off_t;

+#if SIZEOF_OFF_T == 8

+#define ZIP_OFF_MAX ZIP_INT64_MAX

+#define ZIP_OFF_MIN ZIP_INT64_MIN

+#elif SIZEOF_OFF_T == 4

+#define ZIP_OFF_MAX ZIP_INT32_MAX

+#define ZIP_OFF_MIN ZIP_INT32_MIN

+#elif SIZEOF_OFF_T == 2

+#define ZIP_OFF_MAX ZIP_INT16_MAX

+#define ZIP_OFF_MIN ZIP_INT16_MIN

+#else

+#error unsupported size of off_t

+#endif

+

+#define ZIP_FSEEK_MAX ZIP_OFF_MAX

+#define ZIP_FSEEK_MIN ZIP_OFF_MIN

+

+#define zip_os_fseek fseeko

+#define zip_os_ftell ftello

+#else

+

+/* Using long */

+typedef long zip_off_t;

+#include <limits.h>

+#define ZIP_FSEEK_MAX LONG_MAX

+#define ZIP_FSEEK_MIN LONG_MIN

+

+#define zip_os_fseek fseek

+#define zip_os_ftell ftell

+#endif

+

+

+#define HAVE__FSEEKI64

+#define HAVE__FSTAT64

+#define HAVE__FTELLI64

+#define HAVE__STAT64

+#define VERSION "1.11.2"

+ Copyright (C) 1999-2024 Dieter Baron and Thomas Klausner

+#define ZIP_ER_TRUNCATED_ZIP 35 /* N Possibly truncated or corrupted zip archive */

+ ZIP_SOURCE_SUPPORTS_REOPEN, /* allow reading from changed entry */

+ ZIP_SOURCE_GET_DOS_TIME /* get last modification time in DOS format */

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2024 Dieter Baron and Thomas Klausner

+ if (rentries == NULL) {

+ Copyright (C) 2017-2023 Dieter Baron and Thomas Klausner

+ Copyright (C) 2017-2023 Dieter Baron and Thomas Klausner

+ Copyright (C) 2017-2023 Dieter Baron and Thomas Klausner

+ Copyright (C) 2020-2023 Dieter Baron and Thomas Klausner

+ Copyright (C) 2014-2024 Dieter Baron and Thomas Klausner

+int _zip_buffer_set_offset(zip_buffer_t *buffer, zip_uint64_t offset) {

+ Copyright (C) 1999-2024 Dieter Baron and Thomas Klausner

+static int copy_source(zip_t *, zip_source_t *, zip_source_t *, zip_int64_t);

+ if ((src_tmp = _zip_source_window_new(src_final, 0, -1, NULL, 0, NULL, &de->last_mod, NULL, 0, true, &za->error)) == NULL) {

+ ret = copy_source(za, src_final, src, data_length);

+ int ret2 = zip_source_get_dos_time(src, &de->last_mod);

+ if (ret2 < 0) {

+ zip_error_set_from_source(&za->error, src);

+ return -1;

+ }

+ if (ret2 == 0) {

+ time_t mtime;

+ if (st.valid & ZIP_STAT_MTIME) {

+ mtime = st.mtime;

+ }

+ else {

+ time(&mtime);

+ }

+ if (_zip_u2d_time(mtime, &de->last_mod, &za->error) < 0) {

+ return -1;

+ }

+ }

+copy_source(zip_t *za, zip_source_t *src, zip_source_t *src_for_length, zip_int64_t data_length) {

+ zip_int64_t t;

+ t = zip_source_tell(src_for_length);

+ if (t >= 0) {

+ current = t;

+ } else {

+ current += n;

+ }

+}

+ Copyright (C) 2017-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2018-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2018-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2018-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2018-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2018-2023 Dieter Baron and Thomas Klausner

+ Copyright (C) 2018-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2018-2023 Dieter Baron and Thomas Klausner

+ int len = 0;

+ if (EVP_EncryptUpdate(aes, out, &len, in, ZIP_CRYPTO_AES_BLOCK_LENGTH) != 1

+ || len != ZIP_CRYPTO_AES_BLOCK_LENGTH) {

+ size_t length = 0;

+ unsigned int length = 0;

+ return HMAC_Final(hmac, data, &length) == 1 && length == ZIP_CRYPTO_SHA1_LENGTH;

+ Copyright (C) 2018-2023 Dieter Baron and Thomas Klausner

+ Copyright (C) 2018-2023 Dieter Baron and Thomas Klausner

+ Copyright (C) 2018-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2024 Dieter Baron and Thomas Klausner

+static zip_string_t *_zip_dirent_process_ef_utf_8(const zip_dirent_t *de, zip_uint16_t id, zip_string_t *str, bool check_consistency);

+ if (cd == NULL) {

+ }

+_zip_cdir_new(zip_error_t *error) {

+ if (_zip_dirent_write(za, entry->changes ? entry->changes : entry->orig, ZIP_FL_CENTRAL) < 0) {

+ za->write_crc = NULL;

+ }

+ if (survivors > ZIP_UINT16_MAX || offset > ZIP_UINT32_MAX || size > ZIP_UINT32_MAX) {

+ de->last_mod_mtime_valid = false;

+ de->last_mod.date = 0;

+ de->last_mod.time = 0;

+/*

+_zip_dirent_read(zip_dirent_t *zde, zip_source_t *src, zip_buffer_t *buffer, bool local, zip_uint64_t central_compressed_size, bool check_consistency, zip_error_t *error) {

+ zip_string_t *utf8_string;

+ bool is_zip64 = false;

+ zde->last_mod.time = _zip_buffer_get_16(buffer);

+ zde->last_mod.date = _zip_buffer_get_16(buffer);

+ if (zde->filename == NULL) {

+ if (zde->comment == NULL) {

+ if ((utf8_string = _zip_dirent_process_ef_utf_8(zde, ZIP_EF_UTF_8_NAME, zde->filename, check_consistency)) == NULL && zde->filename != NULL) {

+ zip_error_set(error, ZIP_ER_INCONS, ZIP_ER_DETAIL_UTF8_FILENAME_MISMATCH);

+ if (!from_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ return -1;

+ }

+ zde->filename = utf8_string;

+ if (!local) {

+ if ((utf8_string = _zip_dirent_process_ef_utf_8(zde, ZIP_EF_UTF_8_COMMENT, zde->comment, check_consistency)) == NULL && zde->comment != NULL) {

+ zip_error_set(error, ZIP_ER_INCONS, ZIP_ER_DETAIL_UTF8_COMMENT_MISMATCH);

+ if (!from_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ return -1;

+ }

+ zde->comment = utf8_string;

+ }

+ is_zip64 = true;

+

+ if (local && zde->bitflags & ZIP_GPBF_DATA_DESCRIPTOR) {

+ zip_uint32_t df_crc;

+ zip_uint64_t df_comp_size, df_uncomp_size;

+ if (zip_source_seek(src, central_compressed_size, SEEK_CUR) != 0 || (buffer = _zip_buffer_new_from_source(src, MAX_DATA_DESCRIPTOR_LENGTH, buf, error)) == NULL) {

+ return -1;

+ }

+ if (memcmp(_zip_buffer_peek(buffer, MAGIC_LEN), DATADES_MAGIC, MAGIC_LEN) == 0) {

+ _zip_buffer_skip(buffer, MAGIC_LEN);

+ }

+ df_crc = _zip_buffer_get_32(buffer);

+ df_comp_size = is_zip64 ? _zip_buffer_get_64(buffer) : _zip_buffer_get_32(buffer);

+ df_uncomp_size = is_zip64 ? _zip_buffer_get_64(buffer) : _zip_buffer_get_32(buffer);

+

+ if (!_zip_buffer_ok(buffer)) {

+ zip_error_set(error, ZIP_ER_INTERNAL, 0);

+ _zip_buffer_free(buffer);

+ return -1;

+ }

+ _zip_buffer_free(buffer);

+

+ if ((zde->crc != 0 && zde->crc != df_crc) || (zde->comp_size != 0 && zde->comp_size != df_comp_size) || (zde->uncomp_size != 0 && zde->uncomp_size != df_uncomp_size)) {

+ zip_error_set(error, ZIP_ER_INCONS, ZIP_ER_DETAIL_DATA_DESCRIPTOR_MISMATCH);

+ return -1;

+ }

+ zde->crc = df_crc;

+ zde->comp_size = df_comp_size;

+ zde->uncomp_size = df_uncomp_size;

+ }

+

+bool

+zip_dirent_process_ef_zip64(zip_dirent_t *zde, const zip_uint8_t *ef, zip_uint64_t got_len, bool local, zip_error_t *error) {

+_zip_dirent_process_ef_utf_8(const zip_dirent_t *de, zip_uint16_t id, zip_string_t *str, bool check_consistency) {

+ if (check_consistency) {

+ if (!_zip_string_equal(str, ef_str) && _zip_string_is_ascii(ef_str)) {

+ _zip_string_free(ef_str);

+ _zip_buffer_free(buffer);

+ return NULL;

+ }

+ }

+

+ case 1:

+ break;

+ case 2:

+ crc_valid = false;

+ /* TODO: When checking consistency, check that crc is 0. */

+ break;

+

+ default:

+ zip_error_set(error, ZIP_ER_ENCRNOTSUPP, 0);

+ _zip_buffer_free(buffer);

+ return false;

+ zip_dostime_t dostime;

+ dostime.time = 0xbc00;

+ dostime.date = 0x2198;

+ dostime = de->last_mod;

+ _zip_buffer_put_16(buffer, dostime.time);

+ _zip_buffer_put_16(buffer, dostime.date);

+_zip_d2u_time(const zip_dostime_t *dtime) {

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

+ tm.tm_mon = ((dtime->date >> 5) & 15) - 1;

+ tm.tm_mday = dtime->date & 31;

+ tm.tm_hour = (dtime->time >> 11) & 31;

+ tm.tm_min = (dtime->time >> 5) & 63;

+ tm.tm_sec = (dtime->time << 1) & 62;

+int

+_zip_u2d_time(time_t intime, zip_dostime_t *dtime, zip_error_t *ze) {

+ dtime->date = (1 << 5) + 1;

+ dtime->time = 0;

+ if (ze) {

+ zip_error_set(ze, ZIP_ER_INVAL, errno);

+ }

+ return -1;

+ dtime->date = (zip_uint16_t)(((tpm->tm_year + 1900 - 1980) << 9) + ((tpm->tm_mon + 1) << 5) + tpm->tm_mday);

+ dtime->time = (zip_uint16_t)(((tpm->tm_hour) << 11) + ((tpm->tm_min) << 5) + ((tpm->tm_sec) >> 1));

+

+ return 0;

+void

+zip_dirent_torrentzip_normalize(zip_dirent_t *de) {

+ de->bitflags = 2; /* maximum compression */

+}

+int

+zip_dirent_check_consistency(zip_dirent_t *dirent) {

+ if (dirent->comp_method == ZIP_CM_STORE && dirent->comp_size != dirent->uncomp_size) {

+ return ZIP_ER_DETAIL_STORED_SIZE_MISMATCH;

+ }

+ return 0;

+

+time_t zip_dirent_get_last_mod_mtime(zip_dirent_t *de) {

+ if (!de->last_mod_mtime_valid) {

+ de->last_mod_mtime = _zip_d2u_time(&de->last_mod);

+ de->last_mod_mtime_valid = true;

+ }

+

+ return de->last_mod_mtime;

+} \ No newline at end of file

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+ { N, "Possibly truncated or corrupted zip archive" },

+ { E, "compressed and uncompressed sizes don't match for stored file" },

+ { E, "local header and data descriptor do not match" },

+ { G, "EOCD64 and EOCD64 locator do not match" },

+ { E, "UTF-8 filename is ASCII and doesn't match filename" },

+ { E, "UTF-8 comment is ASCII and doesn't match comment" },

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2023 Dieter Baron and Thomas Klausner

+ if (system_error_buffer == NULL) {

+ return _zip_err_str[ZIP_ER_MEMORY].description;

+ }

+ if (system_error_buffer == NULL) {

+ return _zip_err_str[ZIP_ER_MEMORY].description;

+ }

+ if (system_error_buffer == NULL) {

+ return _zip_err_str[ZIP_ER_MEMORY].description;

+ }

+ if (system_error_buffer == NULL) {

+ return _zip_err_str[ZIP_ER_MEMORY].description;

+ }

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2012-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2012-2024 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2009-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2006-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2013-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2024 Dieter Baron and Thomas Klausner

+ /* delete all extra fields - these are usually data that are

+ * strongly coupled with the original data */

+ if (zip_file_extra_field_delete(za, idx, ZIP_EXTRA_FIELD_ALL, ZIP_FL_CENTRAL | ZIP_FL_LOCAL) < 0) {

+ return -1;

+ }

+

+ Copyright (C) 2006-2023 Dieter Baron and Thomas Klausner

+ Copyright (C) 2016-2023 Dieter Baron and Thomas Klausner

+ Copyright (C) 2013-2023 Dieter Baron and Thomas Klausner

+ Copyright (C) 2014-2024 Dieter Baron and Thomas Klausner

+static int zip_file_set_time(zip_t *za, zip_uint64_t idx, zip_uint16_t dtime, zip_uint16_t ddate, zip_flags_t flags, time_t *mtime) {

+ if (_zip_get_dirent(za, idx, 0, NULL) == NULL) {

+ }

+ e->changes->last_mod.time = dtime;

+ e->changes->last_mod.date = ddate;

+ if (mtime != NULL) {

+ e->changes->last_mod_mtime = *mtime;

+ e->changes->last_mod_mtime_valid = true;

+ }

+ else {

+ e->changes->last_mod_mtime_valid = false;

+ }

+

+ZIP_EXTERN int zip_file_set_dostime(zip_t *za, zip_uint64_t idx, zip_uint16_t dtime, zip_uint16_t ddate, zip_flags_t flags) {

+ return zip_file_set_time(za, idx, dtime, ddate, flags, NULL);

+}

+

+

+ZIP_EXTERN int zip_file_set_mtime(zip_t *za, zip_uint64_t idx, time_t mtime, zip_flags_t flags) {

+ zip_dostime_t dostime;

+

+ if (_zip_u2d_time(mtime, &dostime, &za->error) < 0) {

+ return -1;

+ }

+

+ return zip_file_set_time(za, idx, dostime.time, dostime.date, flags, &mtime);

+}

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2023 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2024 Dieter Baron and Thomas Klausner

+ if (zf == NULL) {

+ }

+ if (zf->error.zip_err != 0) {

+ }

+ Copyright (C) 2016-2024 Dieter Baron and Thomas Klausner

+ if (zf == NULL) {

+ }

+ if (zf->error.zip_err != 0) {

+ }

+ if (zfile == NULL) {

+ Copyright (C) 2016-2024 Dieter Baron and Thomas Klausner

+ if (zf == NULL) {

+ }

+ if (zf->error.zip_err != 0) {

+ }

+ Copyright (C) 2006-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2008-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2009-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2006-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2015-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2024 Dieter Baron and Thomas Klausner

+// VS2022: Workaround an Internal compiler error for Release ARM (32-bit) build.

+#if _MSC_VER >= 1940 && _MSC_VER < 1950 && defined(_M_ARM) && defined(NDEBUG)

+ size_t l = length + (nulp ? 1 : 0);

+ r = (zip_uint8_t *)malloc(l);

+#else

+#endif

+ if (r == NULL) {

+ Copyright (C) 2017-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2024 Dieter Baron and Thomas Klausner

+ if (ret == NULL) {

+ Copyright (C) 1999-2024 Dieter Baron and Thomas Klausner

+ if (za == NULL) {

+ za->torrent_mtime = 0;

+ Copyright (C) 1999-2024 Dieter Baron and Thomas Klausner

+typedef enum {

+ EXISTS_ERROR = -1,

+ EXISTS_NOT = 0,

+ EXISTS_OK

+} exists_t;

+typedef enum {

+ CDIR_OK,

+ CDIR_INVALID,

+ CDIR_NOT_FOUND

+

+} cdir_status_t;

+

+static bool check_eocd(zip_cdir_t *cd, unsigned int flags, zip_error_t *error);

+static bool check_magic(zip_uint64_t offset, zip_buffer_t *buffer, zip_uint64_t buffer_offset, zip_source_t *src, const char* magic);

+static bool _zip_read_cdir(zip_t *za, zip_buffer_t *buffer, zip_uint64_t buf_offset, zip_cdir_t **cdirp, zip_error_t *error);

+static zip_cdir_t *_zip_read_eocd(zip_buffer_t *buffer, zip_uint64_t buf_offset, zip_error_t *error);

+static cdir_status_t _zip_read_eocd64(zip_cdir_t *cdir, zip_source_t *src, zip_buffer_t *buffer, zip_uint64_t buf_offset, unsigned int flags, zip_error_t *error);

+static const unsigned char *find_eocd(zip_buffer_t *buffer, const unsigned char *last);

+static bool

+_is_truncated_zip(zip_source_t *src) {

+ unsigned char data[4];

+ /* check if the source is a truncated zip archive: true if yes, no

+ if not or can't be determined */

+ if (zip_source_seek(src, 0, SEEK_SET) < 0) {

+ return false;

+ }

+

+ if (zip_source_read(src, data, 4) != 4) {

+ return false;

+ }

+

+ if (memcmp(data, LOCAL_MAGIC, 4) == 0) {

+ /* file starts with a ZIP local header signature */

+ return true;

+ }

+ return false;

+}

+

+

+ if (zip_error_code_zip(error) == ZIP_ER_NOZIP) {

+ /* not a zip - find out if it's truncated */

+ if (_is_truncated_zip(src)) {

+ zip_error_set(error, ZIP_ER_TRUNCATED_ZIP, 0);

+ }

+ }

+ switch (zip_error_system_type(err)) {

+ case ZIP_ET_SYS:

+ case ZIP_ET_LIBZIP:

+ errno = zip_error_code_system(err);

+ break;

+

+ default:

+ break;

+static bool _zip_read_cdir(zip_t *za, zip_buffer_t *buffer, zip_uint64_t buf_offset, zip_cdir_t **cdirp, zip_error_t *error) {

+ bool eocd64_found = false;

+ *cdirp = NULL;

+ if ((cd = _zip_read_eocd(buffer, buf_offset, error)) == NULL) {

+ return false;

+ eocd64_found = true;

+ switch (_zip_read_eocd64(cd, za->src, buffer, buf_offset, za->flags, error)) {

+ case CDIR_OK:

+ break;

+

+ case CDIR_INVALID:

+ _zip_cdir_free(cd);

+ return true;

+

+ case CDIR_NOT_FOUND:

+ _zip_cdir_free(cd);

+ return false;

+ }

+

+ if ((cd->eocd_disk != 0 || cd->this_disk != 0) && !eocd64_found && cd->eocd_disk != cd->this_disk) {

+ /* If the central directory doesn't start on this disk, we can't check that offset is valid. Check as much as we can instead. */

+ if (cd->this_disk < cd->eocd_disk) {

+ /* Disks before the start of the central directory don't contain an EOCD. */

+ _zip_cdir_free(cd);

+ return false;

+ }

+ if (cd->size <= cd->eocd_offset) {

+ /* The complete central directory would fit on this disk. */

+ _zip_cdir_free(cd);

+ return false;

+ }

+ if (!eocd64_found) {

+ if (cd->this_disk == 0 && cd->eocd_disk == 0 && cd->eocd_offset == 0 && cd->offset == 0 && cd->num_entries == 0) {

+ /* An empty archive doesn't contain central directory entries. */

+ }

+ else if (!check_magic(cd->offset, buffer, buf_offset, za->src, CENTRAL_MAGIC)) {

+ _zip_cdir_free(cd);

+ return false;

+ }

+ }

+

+ /* We accept this EOCD as valid and won't search for an earlier one if it is unusable. */

+

+ if (!check_eocd(cd, za->flags, error)) {

+ _zip_cdir_free(cd);

+ return true;

+ }

+ return true;

+ if (tail_len != comment_len) {

+ if (za->open_flags & ZIP_CHECKCONS) {

+ zip_error_set(error, ZIP_ER_INCONS, ZIP_ER_DETAIL_COMMENT_LENGTH_INVALID);

+ _zip_cdir_free(cd);

+ return true;

+ }

+ if (tail_len < comment_len) {

+ comment_len = tail_len;

+ }

+ return true;

+ return true;

+ return true;

+ return true;

+ return true;

+ if (!_zip_cdir_grow(cd, cd->num_entries, error)) {

+ _zip_cdir_free(cd);

+ _zip_buffer_free(cd_buffer);

+ return true;

+ }

+ return true;

+ if ((cd->entry[i].orig = _zip_dirent_new()) == NULL || (entry_size = _zip_dirent_read(cd->entry[i].orig, za->src, cd_buffer, false, 0, za->open_flags & ZIP_CHECKCONS, error)) < 0) {

+ if (zip_error_code_zip(error) == ZIP_ER_INCONS) {

+ zip_error_set(error, ZIP_ER_INCONS, ADD_INDEX_TO_DETAIL(zip_error_code_system(error), i));

+ }

+ else if (grown && zip_error_code_zip(error) == ZIP_ER_NOZIP) {

+ return true;

+ /* If we didn't fill all we grew, cd->num_entries was wrong. */

+ return true;

+ return true;

+ return true;

+ *cdirp = cd;

+ return true;

+}

+

+

+static bool check_magic(zip_uint64_t offset, zip_buffer_t *buffer, zip_uint64_t buffer_offset, zip_source_t *src, const char* magic) {

+ if (buffer_offset <= offset) {

+ zip_uint8_t* data;

+ if (_zip_buffer_set_offset(buffer, offset - buffer_offset) < 0 || (data = _zip_buffer_get(buffer, MAGIC_LEN)) == NULL) {

+ return false;

+ }

+ return memcmp(data, magic, MAGIC_LEN) == 0;

+ }

+ else {

+ zip_uint8_t data[MAGIC_LEN];

+

+ if (zip_source_seek(src, offset, SEEK_SET) < 0 || zip_source_read(src, data, MAGIC_LEN) != MAGIC_LEN) {

+ return false;

+ }

+ return memcmp(data, magic, MAGIC_LEN) == 0;

+ }

+ int detail;

+ if (_zip_dirent_read(&temp, za->src, NULL, true, cd->entry[i].orig->comp_size, true, error) == -1) {

+ if (zip_error_code_zip(error) == ZIP_ER_INCONS) {

+ zip_error_set(error, ZIP_ER_INCONS, ADD_INDEX_TO_DETAIL(zip_error_code_system(error), i));

+ }

+

+ if ((detail = zip_dirent_check_consistency(cd->entry[i].orig)) != 0) {

+ zip_error_set(error, ZIP_ER_INCONS, MAKE_DETAIL_WITH_INDEX(detail, i));

+ return -1;

+ }

+ || (central->comp_method != local->comp_method) || (central->last_mod.time != local->last_mod.time) || (central->last_mod.date != local->last_mod.date) || !_zip_string_equal(central->filename, local->filename))

+ macOS Archive sets the compressed size even when data descriptor is used ( but not the others),

+ also in violation of the appnote.

+ */

+ /* if data descriptor is not used, the values must match */

+ }

+ /* when using a data descriptor, the local header value must be zero or match */

+ if ((local->crc != 0 && central->crc != local->crc) || (local->comp_size != 0 && central->comp_size != local->comp_size) || (local->uncomp_size != 0 && central->uncomp_size != local->uncomp_size)) {

+ return -1;

+ }

+ zip_cdir_t *cdir;

+ match = NULL;

+ while ((match = find_eocd(buffer, match)) != NULL) {

+ if (_zip_read_cdir(za, buffer, (zip_uint64_t)buf_offset, &cdir, &error)) {

+ if (cdir != NULL && (za->open_flags & ZIP_CHECKCONS) && _zip_checkcons(za, cdir, &error) < 0) {

+ _zip_cdir_free(cdir);

+ cdir = NULL;

+ break;

+ if (cdir == NULL) {

+static const unsigned char *

+find_eocd(zip_buffer_t *buffer, const unsigned char *last) {

+ const unsigned char *data = _zip_buffer_data(buffer);

+ if (last == NULL) {

+ last = data + _zip_buffer_size(buffer) - MAGIC_LEN;

+ else if (last == _zip_buffer_data(buffer)) {

+ else {

+ last -= 1;

+ }

+ for (p = last; p >= data; p -= 1) {

+ if (*p == EOCD_MAGIC[0]) {

+ if (memcmp(p, EOCD_MAGIC, MAGIC_LEN) == 0) {

+ return p;

+ }

+

+ return NULL;

+_zip_read_eocd(zip_buffer_t *buffer, zip_uint64_t buf_offset, zip_error_t *error) {

+ if ((cd = _zip_cdir_new(error)) == NULL) {

+ cd->eocd_offset = buf_offset + _zip_buffer_offset(buffer);

+ /* This function is only called where EOCD magic was found, so no need to check that here. */

+ _zip_buffer_skip(buffer, MAGIC_LEN);

+ cd->is_zip64 = false;

+ cd->this_disk = _zip_buffer_get_16(buffer);

+ cd->eocd_disk = _zip_buffer_get_16(buffer);

+

+ cd->disk_entries = _zip_buffer_get_16(buffer);

+ cd->num_entries = _zip_buffer_get_16(buffer);

+ cd->size = _zip_buffer_get_32(buffer);

+ cd->offset = _zip_buffer_get_32(buffer);

+ return cd;

+}

+static bool

+check_eocd(zip_cdir_t *cd, unsigned int flags, zip_error_t *error) {

+ if (cd->disk_entries != cd->num_entries || cd->this_disk != 0 || cd->eocd_disk != 0) {

+ zip_error_set(error, ZIP_ER_MULTIDISK, 0);

+ return false;

+ if (cd->offset + cd->size < cd->offset) {

+ zip_error_set(error, ZIP_ER_SEEK, EFBIG);

+ return false;

+ if ((flags & ZIP_CHECKCONS) && cd->offset + cd->size != cd->eocd_offset) {

+ return false;

+ return true;

+cdir_status_t _zip_read_eocd64(zip_cdir_t *cdir, zip_source_t *src, zip_buffer_t *buffer, zip_uint64_t buf_offset, unsigned int flags, zip_error_t *error) {

+ zip_uint32_t num_disks, eocd_disk, this_disk;

+ eocd_disk = _zip_buffer_get_32(buffer);

+ num_disks = _zip_buffer_get_32(buffer);

+

+ if (!check_magic(eocd_offset, buffer, buf_offset, src, EOCD64_MAGIC)) {

+ return CDIR_NOT_FOUND;

+ }

+

+ if (num_disks != 1) {

+ zip_error_set(error, ZIP_ER_MULTIDISK, 0);

+ return CDIR_INVALID;

+ }

+ return CDIR_INVALID;

+ return CDIR_INVALID;

+ return CDIR_INVALID;

+ return CDIR_INVALID;

+ return CDIR_INVALID;

+ return CDIR_INVALID;

+ this_disk = _zip_buffer_get_32(buffer);

+ if (_zip_buffer_get_32(buffer) != eocd_disk) {

+ zip_error_set(error, ZIP_ER_INCONS, ZIP_ER_DETAIL_EOCD64_LOCATOR_MISMATCH);

+ return CDIR_INVALID;

+ nentry = _zip_buffer_get_64(buffer);

+ return CDIR_INVALID;

+ return CDIR_INVALID;

+ return CDIR_INVALID;

+ return CDIR_INVALID;

+ if ((cdir->size != 0xffffffff && cdir->size != size) || (cdir->offset != 0xffffffff && cdir->offset != offset) || (cdir->num_entries != 0xffff && cdir->num_entries != nentry) || (cdir->disk_entries != 0xffff && cdir->disk_entries != i) || (cdir->this_disk != 0xffff && cdir->this_disk != this_disk) || (cdir->eocd_disk != 0xffff && cdir->eocd_disk != eocd_disk)) {

+ zip_error_set(error, ZIP_ER_INCONS, ZIP_ER_DETAIL_EOCD64_MISMATCH);

+ return CDIR_INVALID;

+ }

+ cdir->is_zip64 = true;

+ cdir->size = size;

+ cdir->offset = offset;

+ cdir->disk_entries = i;

+ cdir->num_entries = nentry;

+ cdir->this_disk = this_disk;

+ cdir->eocd_disk = eocd_disk;

+ return CDIR_OK;

+static int

+decode_hex(char c) {

+static void

+zip_check_torrentzip(zip_t *za, const zip_cdir_t *cdir) {

+ char buf[8 + 1];

+ if (_zip_string_length(cdir->comment) != TORRENTZIP_SIGNATURE_LENGTH + TORRENTZIP_CRC_LENGTH || strncmp((const char *)cdir->comment->raw, TORRENTZIP_SIGNATURE, TORRENTZIP_SIGNATURE_LENGTH) != 0)

+ zip_source_t *src_window;

+ zip_source_t *src_crc;

+ if ((src_window = _zip_source_window_new(za->src, cdir->offset, cdir->size, &st, 0, NULL, NULL, NULL, 0, false, NULL)) == NULL) {

+ Copyright (C) 2009-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2017-2024 Dieter Baron and Thomas Klausner

+ if (current - progress->last_update > progress->precision || (progress->last_update < 1 && current == 1)) {

+ Copyright (C) 2016-2023 Dieter Baron and Thomas Klausner

+ Copyright (C) 2017-2023 Dieter Baron and Thomas Klausner

+ Copyright (C) 2016-2023 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2006-2023 Dieter Baron and Thomas Klausner

+ Copyright (C) 2008-2023 Dieter Baron and Thomas Klausner

+ Copyright (C) 2009-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2006-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2012-2023 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2019-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2014-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2017-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2023 Dieter Baron and Thomas Klausner

+ Copyright (C) 2009-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2009-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2014-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2017-2023 Dieter Baron and Thomas Klausner

+ Copyright (C) 2009-2023 Dieter Baron and Thomas Klausner

+ Copyright (C) 2009-2022 Dieter Baron and Thomas Klausner

+#ifndef _HAD_ZIP_SOURCE_FILE_H

+#define _HAD_ZIP_SOURCE_FILE_H

+

+ Copyright (C) 2020-2024 Dieter Baron and Thomas Klausner

+

+#endif /* _HAD_ZIP_SOURCE_FILE_H */

+ Copyright (C) 1999-2023 Dieter Baron and Thomas Klausner

+ Copyright (C) 2020-2023 Dieter Baron and Thomas Klausner

+ if (zip_os_fseek((FILE *)f, (zip_off_t)offset, whence) < 0) {

+ zip_os_stat_t sb;

+ ret = zip_os_stat(ctx->fname, &sb);

+ ret = zip_os_fstat(fileno((FILE *)ctx->f), &sb);

+ zip_off_t offset = zip_os_ftell((FILE *)f);

+ Copyright (C) 2020-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2023 Dieter Baron and Thomas Klausner

+ zip_os_stat_t st;

+ if (zip_os_fstat(fileno(ctx->f), &st) < 0) {

+ if (zip_os_fseek(tfp, (zip_off_t)offset, SEEK_SET) < 0) {

+ zip_os_stat_t st;

+ if (zip_os_stat(ctx->fname, &st) == 0) {

+ if (zip_os_stat(temp, &st) < 0) {

+ Copyright (C) 1999-2023 Dieter Baron and Thomas Klausner

+ Copyright (C) 2020-2024 Dieter Baron and Thomas Klausner

+ HANDLE(__stdcall *find_first_file)(const void *name, void *data);

+ Copyright (C) 1999-2024 Dieter Baron and Thomas Klausner

+static HANDLE __stdcall ansi_create_file(const void *name, DWORD access, DWORD share_mode, PSECURITY_ATTRIBUTES security_attributes, DWORD creation_disposition, DWORD file_attributes, HANDLE template_file);

+static BOOL __stdcall ansi_delete_file(const void *name);

+static DWORD __stdcall ansi_get_file_attributes(const void *name);

+static BOOL __stdcall ansi_get_file_attributes_ex(const void *name, GET_FILEEX_INFO_LEVELS info_level, void *information);

+static BOOL __stdcall ansi_move_file(const void *from, const void *to, DWORD flags);

+static BOOL __stdcall ansi_set_file_attributes(const void *name, DWORD attributes);

+static HANDLE __stdcall ansi_find_first_file(const void *name, void* data);

+ ansi_create_file,

+ ansi_delete_file,

+ ansi_get_file_attributes,

+ ansi_get_file_attributes_ex,

+ ansi_move_file,

+ ansi_set_file_attributes,

+ strdup,

+ ansi_find_first_file,

+static HANDLE __stdcall

+ansi_create_file(const void *name, DWORD access, DWORD share_mode, PSECURITY_ATTRIBUTES security_attributes, DWORD creation_disposition, DWORD file_attributes, HANDLE template_file)

+{

+ return CreateFileA((const char *)name, access, share_mode, security_attributes, creation_disposition, file_attributes, template_file);

+}

+

+static BOOL __stdcall

+ansi_delete_file(const void *name)

+{

+ return DeleteFileA((const char *)name);

+}

+

+static DWORD __stdcall

+ansi_get_file_attributes(const void *name)

+{

+ return GetFileAttributesA((const char *)name);

+}

+

+static BOOL __stdcall

+ansi_get_file_attributes_ex(const void *name, GET_FILEEX_INFO_LEVELS info_level, void *information)

+{

+ return GetFileAttributesExA((const char *)name, info_level, information);

+}

+

+static BOOL __stdcall

+ansi_move_file(const void *from, const void *to, DWORD flags)

+{

+ return MoveFileExA((const char *)from, (const char *)to, flags);

+}

+

+static BOOL __stdcall

+ansi_set_file_attributes(const void *name, DWORD attributes)

+{

+ return SetFileAttributesA((const char *)name, attributes);

+}

+

+static HANDLE __stdcall

+ansi_find_first_file(const void *name, void *data)

+{

+ return FindFirstFileA((const char *)name, data);

+}

+ Copyright (C) 1999-2024 Dieter Baron and Thomas Klausner

+/* ACL is not available when targeting the games API partition */

+#if defined(WINAPI_FAMILY_PARTITION) && defined(WINAPI_PARTITION_GAMES)

+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_GAMES)

+#define ACL_UNSUPPORTED

+#endif

+#endif

+

+ #ifdef ACL_UNSUPPORTED

+ success = ERROR_NOT_SUPPORTED;

+ #else

+ #endif

+ if ((file_attributes.dwFileAttributes & (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_DEVICE)) == 0) {

+ if (file_attributes.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) {

+#ifdef IO_REPARSE_TAG_DEDUP // Not defined in WinSDK 7.1 or before (VS2010).

+ WIN32_FIND_DATA find_data;

+ /* Deduplication on Windows replaces files with reparse points;

+ * accept them as regular files. */

+ if (file_ops->find_first_file(ctx->fname, &find_data) != INVALID_HANDLE_VALUE) {

+ st->regular_file = (find_data.dwReserved0 == IO_REPARSE_TAG_DEDUP);

+ }

+#endif

+ }

+ else {

+ st->regular_file = true;

+ }

+ Copyright (C) 1999-2024 Dieter Baron and Thomas Klausner

+static HANDLE __stdcall utf16_create_file(const void *name, DWORD access, DWORD share_mode, PSECURITY_ATTRIBUTES security_attributes, DWORD creation_disposition, DWORD file_attributes, HANDLE template_file);

+static BOOL __stdcall utf16_delete_file(const void *name);

+static DWORD __stdcall utf16_get_file_attributes(const void *name);

+static BOOL __stdcall utf16_get_file_attributes_ex(const void *name, GET_FILEEX_INFO_LEVELS info_level, void *information);

+static BOOL __stdcall utf16_move_file(const void *from, const void *to, DWORD flags);

+static BOOL __stdcall utf16_set_file_attributes(const void *name, DWORD attributes);

+static HANDLE __stdcall utf16_find_first_file(const void *name, void* data);

+/* clang-format off */

+ utf16_delete_file,

+ utf16_get_file_attributes,

+ utf16_get_file_attributes_ex,

+ utf16_move_file,

+ utf16_set_file_attributes,

+ utf16_strdup,

+ utf16_find_first_file

+static HANDLE __stdcall utf16_create_file(const void *name, DWORD access, DWORD share_mode, PSECURITY_ATTRIBUTES security_attributes, DWORD creation_disposition, DWORD file_attributes, HANDLE template_file) {

+static BOOL __stdcall

+utf16_delete_file(const void *name)

+{

+ return DeleteFileW((const wchar_t *)name);

+}

+

+static DWORD __stdcall

+utf16_get_file_attributes(const void *name)

+{

+ return GetFileAttributesW((const wchar_t *)name);

+}

+

+static BOOL __stdcall

+utf16_get_file_attributes_ex(const void *name, GET_FILEEX_INFO_LEVELS info_level, void *information)

+{

+ return GetFileAttributesExW((const wchar_t *)name, info_level, information);

+}

+static BOOL __stdcall

+utf16_move_file(const void *from, const void *to, DWORD flags)

+{

+ return MoveFileExW((const wchar_t *)from, (const wchar_t *)to, flags);

+}

+

+static BOOL __stdcall

+utf16_set_file_attributes(const void *name, DWORD attributes)

+{

+ return SetFileAttributesW((const wchar_t *)name, attributes);

+}

+

+

+static HANDLE __stdcall

+utf16_find_first_file(const void *name, void* data)

+{

+ return FindFirstFileW((const wchar_t *)name, data);

+}

+ Copyright (C) 1999-2023 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+/*

+ zip_source_get_dostime.c -- get modification time in DOS format from source

+ Copyright (C) 2024 Dieter Baron and Thomas Klausner

+

+ This file is part of libzip, a library to manipulate ZIP archives.

+ The authors can be contacted at <info@libzip.org>

+

+ Redistribution and use in source and binary forms, with or without

+ modification, are permitted provided that the following conditions

+ are met:

+ 1. Redistributions of source code must retain the above copyright

+ notice, this list of conditions and the following disclaimer.

+ 2. Redistributions in binary form must reproduce the above copyright

+ notice, this list of conditions and the following disclaimer in

+ the documentation and/or other materials provided with the

+ distribution.

+ 3. The names of the authors may not be used to endorse or promote

+ products derived from this software without specific prior

+ written permission.

+

+ THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS

+ OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

+ ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY

+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

+ DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE

+ GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

+ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER

+ IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR

+ OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN

+ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+*/

+

+

+#include "zipint.h"

+

+/* Returns -1 on error, 0 on no dostime available, 1 for dostime returned */

+int

+zip_source_get_dos_time(zip_source_t *src, zip_dostime_t *dos_time) {

+ if (src->source_closed) {

+ return -1;

+ }

+ if (dos_time == NULL) {

+ zip_error_set(&src->error, ZIP_ER_INVAL, 0);

+ return -1;

+ }

+

+ if (src->write_state == ZIP_SOURCE_WRITE_REMOVED) {

+ zip_error_set(&src->error, ZIP_ER_READ, ENOENT);

+ }

+

+ if (zip_source_supports(src) & ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_GET_DOS_TIME)) {

+ zip_int64_t n = _zip_source_call(src, dos_time, sizeof(*dos_time), ZIP_SOURCE_GET_DOS_TIME);

+

+ if (n < 0) {

+ return -1;

+ }

+ else if (n == 0) {

+ return 0;

+ }

+ else if (n == sizeof(*dos_time)) {

+ return 1;

+ }

+ else {

+ zip_error_set(&src->error, ZIP_ER_INTERNAL, 0);

+ return -1;

+ }

+ }

+ else {

+ return 0;

+ }

+}

+ Copyright (C) 2020-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2014-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2009-2023 Dieter Baron and Thomas Klausner

+ Copyright (C) 2009-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2022-2024 Dieter Baron and Thomas Klausner

+ case ZIP_SOURCE_GET_DOS_TIME:

+ Copyright (C) 2009-2024 Dieter Baron and Thomas Klausner

+ zip_stat_t st;

+ zip_dostime_t dostime;

+ if (zip_source_stat(src, &st) < 0 || (st.valid & ZIP_STAT_CRC) == 0) {

+ /* skip password validation */

+ if (zip_source_get_dos_time(src, &dostime) <= 0) {

+ if ((st.valid & ZIP_STAT_MTIME) == 0) {

+ /* no date available, skip password validation */

+ return 0;

+ if (_zip_u2d_time(st.mtime, &dostime, &ctx->error) < 0) {

+ return -1;

+ /*

+ password verification - two ways:

+ - mtime - InfoZIP way, to avoid computing complete CRC before encrypting data

+ - CRC - old PKWare way

+ */

+ if (header[ZIP_CRYPTO_PKWARE_HEADERLEN - 1] == dostime.time >> 8

+ || header[ZIP_CRYPTO_PKWARE_HEADERLEN - 1] == st.crc >> 24) {

+ return 0;

+ }

+ else {

+ Copyright (C) 2009-2024 Dieter Baron and Thomas Klausner

+ zip_dostime_t dostime;

+ zip_error_set(&za->error, ZIP_ER_MEMORY, 0);

+ if (zip_source_get_dos_time(src, &ctx->dostime) <= 0) {

+ zip_stat_t st;

+

+ if (zip_source_stat(src, &st) < 0) {

+ zip_error_set_from_source(&za->error, src);

+ trad_pkware_free(ctx);

+ return NULL;

+ }

+ if (_zip_u2d_time((st.valid & ZIP_STAT_MTIME) ? st.mtime : time(NULL), &ctx->dostime, &za->error) < 0) {

+ trad_pkware_free(ctx);

+ return NULL;

+ }

+ }

+

+ header[ZIP_CRYPTO_PKWARE_HEADERLEN - 1] = (zip_uint8_t)((ctx->dostime.time >> 8) & 0xff);

+ case ZIP_SOURCE_GET_DOS_TIME:

+ if (length < sizeof(ctx->dostime)) {

+ zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);

+ return -1;

+ }

+ (void)memcpy_s(data, sizeof(ctx->dostime), &ctx->dostime, sizeof(ctx->dostime));

+ return sizeof(ctx->dostime);

+

+ return zip_source_make_command_bitmap(ZIP_SOURCE_OPEN, ZIP_SOURCE_READ, ZIP_SOURCE_CLOSE, ZIP_SOURCE_STAT, ZIP_SOURCE_ERROR, ZIP_SOURCE_FREE, ZIP_SOURCE_GET_FILE_ATTRIBUTES, ZIP_SOURCE_GET_DOS_TIME, -1);

+ Copyright (C) 2009-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2014-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2014-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2014-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2014-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2009-2023 Dieter Baron and Thomas Klausner

+ Copyright (C) 2014-2023 Dieter Baron and Thomas Klausner

+ Copyright (C) 2014-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2014-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2012-2024 Dieter Baron and Thomas Klausner

+ zip_dostime_t dostime;

+ bool dostime_valid;

+ return _zip_source_window_new(src, start, len, NULL, 0, NULL, NULL, NULL, 0, false, error);

+_zip_source_window_new(zip_source_t *src, zip_uint64_t start, zip_int64_t length, zip_stat_t *st, zip_uint64_t st_invalid, zip_file_attributes_t *attributes, zip_dostime_t *dostime, zip_t *source_archive, zip_uint64_t source_index, bool take_ownership, zip_error_t *error) {

+ if (dostime != NULL) {

+ ctx->dostime = *dostime;

+ ctx->dostime_valid = true;

+ }

+ else {

+ ctx->dostime_valid = false;

+ }

+ ctx->supports = (zip_source_supports(src) & (ZIP_SOURCE_SUPPORTS_SEEKABLE | ZIP_SOURCE_SUPPORTS_REOPEN)) | (zip_source_make_command_bitmap(ZIP_SOURCE_GET_FILE_ATTRIBUTES, ZIP_SOURCE_GET_DOS_TIME, ZIP_SOURCE_SUPPORTS, ZIP_SOURCE_TELL, ZIP_SOURCE_FREE, -1));

+ case ZIP_SOURCE_GET_DOS_TIME:

+ if (len < sizeof(ctx->dostime)) {

+ zip_error_set(&ctx->error, ZIP_ER_INVAL, 0);

+ return -1;

+ }

+ if (ctx->dostime_valid) {

+ (void)memcpy_s(data, sizeof(ctx->dostime), &ctx->dostime, sizeof(ctx->dostime));

+ return sizeof(ctx->dostime);

+ }

+ else {

+ return 0;

+ }

+

+ Copyright (C) 2009-2023 Dieter Baron and Thomas Klausner

+ Copyright (C) 2009-2023 Dieter Baron and Thomas Klausner

+ Copyright (C) 2014-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2023 Dieter Baron and Thomas Klausner

+ Copyright (C) 2012-2024 Dieter Baron and Thomas Klausner

+ if ((src = _zip_source_window_new(src, start, data_len, &st2, ZIP_STAT_NAME, &attributes, &de->last_mod, source_archive, source_index, take_ownership, error)) == NULL) {

+ if ((src = _zip_source_window_new(srcza->src, 0, (zip_int64_t)st.comp_size, &st, ZIP_STAT_NAME, &attributes, &de->last_mod, srcza, srcidx, take_ownership, error)) == NULL) {

+ if ((src = _zip_source_window_new(src, 0, data_len, &st, ZIP_STAT_NAME, &attributes, &de->last_mod, NULL, 0, take_ownership, error)) == NULL) {

+ zip_source_free(src);

+ s2 = _zip_source_window_new(src, start, data_len, &st2, ZIP_STAT_NAME, NULL, NULL, NULL, 0, true, error);

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2024 Dieter Baron and Thomas Klausner

+ st->mtime = zip_dirent_get_last_mod_mtime(de);

+ st->mtime = zip_dirent_get_last_mod_mtime(de);

+ if (za->torrent_mtime == 0) {

+ zip_dostime_t dostime = {0xbc00, 0x2198};

+ za->torrent_mtime = _zip_d2u_time(&dostime);

+ }

+ st->mtime = za->torrent_mtime;

+ Copyright (C) 2006-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2012-2024 Dieter Baron and Thomas Klausner

+ if (string->encoding == ZIP_ENCODING_UNKNOWN) {

+ /* guess encoding, sets string->encoding */

+ (void)_zip_guess_encoding(string, ZIP_ENCODING_UNKNOWN);

+ }

+bool _zip_string_is_ascii(const zip_string_t *string) {

+ if (string->encoding != ZIP_ENCODING_ASCII) {

+ zip_uint16_t i;

+

+ for (i = 0; i < string->length; i++) {

+ if (string->raw[i] & 0x80) {

+ return false;

+ }

+ }

+ }

+

+ return true;

+}

+

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2006-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 1999-2022 Dieter Baron and Thomas Klausner

+ Copyright (C) 2011-2024 Dieter Baron and Thomas Klausner

+ bool can_be_ascii = true;

+ bool can_be_utf8 = true;

+ bool has_control_characters = false;

+ if (str == NULL) {

+ }

+ if (str->encoding != ZIP_ENCODING_UNKNOWN) {

+ return str->encoding;

+ }

+ for (i = 0; i < str->length; i++) {

+ if (name[i] < 128) {

+ if (name[i] < 32 && name[i] != '\r' && name[i] != '\n' && name[i] != '\t') {

+ has_control_characters = true;

+ continue;

+ }

+

+ can_be_ascii = false;

+ if ((name[i] & UTF_8_LEN_2_MASK) == UTF_8_LEN_2_MATCH) {

+ ulen = 1;

+ }

+ else if ((name[i] & UTF_8_LEN_3_MASK) == UTF_8_LEN_3_MATCH) {

+ ulen = 2;

+ }

+ else if ((name[i] & UTF_8_LEN_4_MASK) == UTF_8_LEN_4_MATCH) {

+ ulen = 3;

+ }

+ else {

+ can_be_utf8 = false;

+ break;

+ }

+ if (i + ulen >= str->length) {

+ can_be_utf8 = false;

+ break;

+ }

+

+ for (j = 1; j <= ulen; j++) {

+ if ((name[i + j] & UTF_8_CONTINUE_MASK) != UTF_8_CONTINUE_MATCH) {

+ can_be_utf8 = false;

+ goto done;

+ i += ulen;

+ done:

+ enc = ZIP_ENCODING_CP437;

+

+ switch (expected_encoding) {

+ case ZIP_ENCODING_UTF8_KNOWN:

+ case ZIP_ENCODING_UTF8_GUESSED:

+ if (can_be_utf8) {

+ enc = ZIP_ENCODING_UTF8_KNOWN;

+ }

+ else {

+ enc = ZIP_ENCODING_ERROR;

+ }

+ break;

+ case ZIP_ENCODING_ASCII:

+ if (can_be_ascii && !has_control_characters) {

+ enc = ZIP_ENCODING_ASCII;

+ }

+ else {

+ enc = ZIP_ENCODING_ERROR;

+ }

+ break;

+ case ZIP_ENCODING_CP437:

+ enc = ZIP_ENCODING_CP437;

+ break;

+

+ case ZIP_ENCODING_UNKNOWN:

+ if (can_be_ascii && !has_control_characters) {

+ /* only bytes from 0x20-0x7F */

+ enc = ZIP_ENCODING_ASCII;

+ }

+ else if (can_be_ascii && has_control_characters) {

+ /* only bytes from 0x00-0x7F */

+ enc = ZIP_ENCODING_CP437;

+ }

+ else if (can_be_utf8) {

+ /* contains bytes from 0x80-0xFF and is valid UTF-8 */

+ enc = ZIP_ENCODING_UTF8_GUESSED;

+ }

+ else {

+ /* fallback */

+ enc = ZIP_ENCODING_CP437;

+ }

+ break;

+ case ZIP_ENCODING_ERROR:

+ /* invalid, shouldn't happen */

+ enc = ZIP_ENCODING_ERROR;

+ break;

+ str->encoding = enc;

+ if (codepoint < 0x0080) {

+ }

+ if (codepoint < 0x0800) {

+ }

+ if (codepoint < 0x10000) {

+ }

+ if (utf8_lenp) {

+ }

+ for (i = 0; i < len; i++) {

+ }

+ for (i = 0; i < len; i++) {

+ }

+ if (utf8_lenp) {

+ }

+ Copyright (C) 2017-2022 Dieter Baron and Thomas Klausner

+#define LIBZIP_VERSION "1.11.2"

+#define LIBZIP_VERSION_MINOR 11

+#define LIBZIP_VERSION_MICRO 2

+ Copyright (C) 1999-2024 Dieter Baron and Thomas Klausner

+#define MAGIC_LEN 4

+#define ZIP_ER_DETAIL_INVALID_UTF8_IN_COMMENT 14 /* E invalid UTF-8 in comment */

+#define ZIP_ER_DETAIL_INVALID_ZIP64_EF 15 /* E invalid Zip64 extra field */

+#define ZIP_ER_DETAIL_INVALID_WINZIPAES_EF 16 /* E invalid WinZip AES extra field */

+#define ZIP_ER_DETAIL_EF_TRAILING_GARBAGE 17 /* E garbage at end of extra fields */

+#define ZIP_ER_DETAIL_INVALID_EF_LENGTH 18 /* E extra field length is invalid */

+#define ZIP_ER_DETAIL_INVALID_FILE_LENGTH 19 /* E file length in header doesn't match actual file length */

+#define ZIP_ER_DETAIL_STORED_SIZE_MISMATCH 20 /* E compressed and uncompressed sizes don't match for stored file */

+#define ZIP_ER_DETAIL_DATA_DESCRIPTOR_MISMATCH 21 /* E local header and data descriptor do not match */

+#define ZIP_ER_DETAIL_EOCD64_LOCATOR_MISMATCH 22 /* G EOCD64 and EOCD64 locator do not match */

+#define ZIP_ER_DETAIL_UTF8_FILENAME_MISMATCH 23 /* E UTF-8 filename is ASCII and doesn't match filename */

+#define ZIP_ER_DETAIL_UTF8_COMMENT_MISMATCH 24 /* E UTF-8 comment is ASCII and doesn't match comment */

+typedef struct zip_dostime zip_dostime_t;

+ time_t torrent_mtime;

+struct zip_dostime {

+ zip_uint16_t time;

+ zip_uint16_t date;

+};

+

+ bool last_mod_mtime_valid;

+ zip_dostime_t last_mod; /* (cl) time of last modification */

+

+ time_t last_mod_mtime; /* cached last_mod in Unix time format */

+ zip_uint32_t this_disk;

+ zip_uint32_t eocd_disk;

+ zip_uint64_t disk_entries; /* number of entries on this disk */

+ zip_uint64_t num_entries; /* number of entries on all disks */

+ zip_uint64_t eocd_offset; /* offset of EOCD in file */

+zip_cdir_t *_zip_cdir_new(zip_error_t *);

+time_t _zip_d2u_time(const zip_dostime_t*);

+int zip_dirent_check_consistency(zip_dirent_t *dirent);

+time_t zip_dirent_get_last_mod_mtime(zip_dirent_t *de);

+zip_int64_t _zip_dirent_read(zip_dirent_t *zde, zip_source_t *src, zip_buffer_t *buffer, bool local, zip_uint64_t central_compressed_size, bool check_consistency, zip_error_t *error);

+int zip_source_get_dos_time(zip_source_t *src, zip_dostime_t *dos_time);

+

+zip_source_t *_zip_source_window_new(zip_source_t *src, zip_uint64_t start, zip_int64_t length, zip_stat_t *st, zip_uint64_t st_invalid, zip_file_attributes_t *attributes, zip_dostime_t *dostime, zip_t *source_archive, zip_uint64_t source_index, bool take_ownership, zip_error_t *error);

+bool _zip_string_is_ascii(const zip_string_t *string);

+int _zip_u2d_time(time_t, zip_dostime_t *, zip_error_t *);

+#endif /* _HAD_ZIPINT_H */

+2024-01-24 : Igor Pavlov : Public domain */

+#define Z7_DIAGNOSTIC_IGNORE_BEGIN_CAST_QUAL \

+#define Z7_DIAGNOSTIC_IGNORE_END_CAST_QUAL \

+#define Z7_DIAGNOSTIC_IGNORE_BEGIN_CAST_QUAL

+#define Z7_DIAGNOSTIC_IGNORE_END_CAST_QUAL

+ Z7_DIAGNOSTIC_IGNORE_BEGIN_CAST_QUAL \

+ Z7_DIAGNOSTIC_IGNORE_END_CAST_QUAL

+2024-02-18 : Igor Pavlov : Public domain */

+#if defined(Z7_LARGE_PAGES) && defined(_WIN32) && \

+ (!defined(Z7_WIN32_WINNT_MIN) || Z7_WIN32_WINNT_MIN < 0x0502) // < Win2003 (xp-64)

+ #define Z7_USE_DYN_GetLargePageMinimum

+#endif

+

+// for debug:

+#if 0

+#if defined(__CHERI__) && defined(__SIZEOF_POINTER__) && (__SIZEOF_POINTER__ == 16)

+// #pragma message("=== Z7_ALLOC_NO_OFFSET_ALLOCATOR === ")

+#define Z7_ALLOC_NO_OFFSET_ALLOCATOR

+#endif

+#ifndef Z7_ALLOC_NO_OFFSET_ALLOCATOR

+#endif

+ #define MY_MEM_LARGE_PAGES MEM_LARGE_PAGES

+ #define MY_MEM_LARGE_PAGES 0x20000000

+#ifdef Z7_USE_DYN_GetLargePageMinimum

+Z7_DIAGNOSTIC_IGNORE_CAST_FUNCTION

+

+ (Func_GetLargePageMinimum) Z7_CAST_FUNC_C GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")),

+#else

+ size = GetLargePageMinimum();

+#endif

+ void *p = VirtualAlloc(NULL, size2, MEM_COMMIT | MY_MEM_LARGE_PAGES, PAGE_READWRITE);

+#ifndef Z7_ALLOC_NO_OFFSET_ALLOCATOR

+ uintptr_t : <stdint.h> C99 (optional)

+ : unsupported in VS6

+typedef

+ #ifdef _WIN32

+ UINT_PTR

+ #elif 1

+ uintptr_t

+ #else

+ ptrdiff_t

+ #endif

+ MY_uintptr_t;

+

+#if 0 \

+ || (defined(__CHERI__) \

+ || defined(__SIZEOF_POINTER__) && (__SIZEOF_POINTER__ > 8))

+// for 128-bit pointers (cheri):

+#define MY_ALIGN_PTR_DOWN(p, align) \

+ ((void *)((char *)(p) - ((size_t)(MY_uintptr_t)(p) & ((align) - 1))))

+#else

+#define MY_ALIGN_PTR_DOWN(p, align) \

+ ((void *)((((MY_uintptr_t)(p)) & ~((MY_uintptr_t)(align) - 1))))

+#endif

+#endif

+#if !defined(_WIN32) \

+ && (defined(Z7_ALLOC_NO_OFFSET_ALLOCATOR) \

+ || defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE >= 200112L))

+void *z7_AlignedAlloc(size_t size)

+#ifndef USE_posix_memalign

+#else

+#endif

+}

+

+

+void z7_AlignedFree(void *address)

+{

+#ifndef USE_posix_memalign

+ if (address)

+ MyFree(((void **)address)[-1]);

+#else

+ free(address);

+#endif

+}

+

+

+static void *SzAlignedAlloc(ISzAllocPtr pp, size_t size)

+{

+ UNUSED_VAR(pp)

+ return z7_AlignedAlloc(size);

+#ifndef USE_posix_memalign

+#else

+#endif

+#ifndef Z7_ALLOC_NO_OFFSET_ALLOCATOR

+#if 1

+ #define MY_ALIGN_PTR_DOWN_1(p) MY_ALIGN_PTR_DOWN(p, sizeof(void *))

+ #define REAL_BLOCK_PTR_VAR(p) ((void **)MY_ALIGN_PTR_DOWN_1(p))[-1]

+#else

+ // we can use this simplified code,

+ // if (CAlignOffsetAlloc::offset == (k * sizeof(void *))

+ #define REAL_BLOCK_PTR_VAR(p) (((void **)(p))[-1])

+#endif

+#endif

+

+

+#if 0

+#ifndef Z7_ALLOC_NO_OFFSET_ALLOCATOR

+#include <stdio.h>

+static void PrintPtr(const char *s, const void *p)

+{

+ const Byte *p2 = (const Byte *)&p;

+ unsigned i;

+ printf("%s %p ", s, p);

+ for (i = sizeof(p); i != 0;)

+ {

+ i--;

+ printf("%02x", p2[i]);

+ }

+ printf("\n");

+}

+#endif

+#endif

+

+#if defined(Z7_ALLOC_NO_OFFSET_ALLOCATOR)

+ UNUSED_VAR(pp)

+ return z7_AlignedAlloc(size);

+#else

+#if 0

+ printf("\nalignSize = %6x, offset=%6x, size=%8x \n", (unsigned)alignSize, (unsigned)p->offset, (unsigned)size);

+ PrintPtr("base", adr);

+ PrintPtr("alig", pAligned);

+#endif

+