+# 1.10.0 [2023-06-23]

+

+* Make support for layered sources public.

+* Add `zip_source_zip_file` and `zip_source_zip_file_create`, deprecate `zip_source_zip` and `zip_source_zip_create`.

+* Allow reading changed file data.

+* Fix handling of files of size 4294967295.

+* `zipmerge`: copy extra fields.

+* `zipmerge`: add option to keep files uncompressed.

+* Switch test framework to use nihtest instead of Perl.

+* Fix reading/writing compressed data with buffers > 4GiB.

+* Restore support for torrentzip.

+* Add warnings when using deprecated functions.

+* Allow keeping files for empty archives.

+* Support mbedTLS>=3.3.0.

+* Support OpenSSL 3.

+* Use ISO C secure library functions, if available.

+

+

+# 1.9.2 [2022-06-28]

+

+# 1.9.1 [2022-06-28]

+

+# 1.9.0 [2022-06-13]

+

+# 1.8.0 [2021-06-18]

+

+# 1.7.3 [2020-07-15]

+

+# 1.7.2 [2020-07-11]

+

+# 1.7.1 [2020-06-13]

+

+# 1.7.0 [2020-06-05]

+

+# 1.6.1 [2020-02-03]

+

+# 1.6.0 [2020-01-24]

+

+# 1.5.2 [2019-03-12]

+

+# 1.5.1 [2018-04-11]

+

+# 1.5.0 [2018-03-11]

+

+# 1.4.0 [2017-12-29]

+

+# 1.3.2 [2017-11-20]

+

+# 1.3.1 [2017-11-19]

+

+# 1.3.0 [2017-09-02]

+

+# 1.2.0 [2017-02-19]

+

+# 1.1.3 [2016-05-28]

+

+# 1.1.2 [2016-02-19]

+

+# 1.1.1 [2016-02-07]

+

+# 1.1 [2016-01-26]

+

+# 1.0.1 [2015-05-04]

+

+# 1.0 [2015-05-03]

+

+# 0.11.2 [2013-12-19]

+

+# 0.11.1 [2013-04-27]

+

+# 0.11 [2013-03-23]

+

+# 0.10.1 [2012-03-20]

+

+# 0.10 [2010-03-18]

+

+# 0.9.3 [2010-02-01]

+

+# 0.9.2 [2010-01-31]

+

+# 0.9.1 [2010-01-24]

+

+# 0.9 [2008-07-25]

+

+# 0.8 [2007-06-06]

+

+# 0.7.1 [2006-05-18]

+

+# 0.7 [2006-05-06]

+

+# 0.6.1 [2005-07-14]

+

+# 0.6 [2005-06-09]

+/* to have ISO C secure library functions */

+#define __STDC_WANT_LIB_EXT1__ 1

+

+#if !defined(HAVE__SNWPRINTF_S)

+#define _snwprintf_s(buf, bufsz, len, fmt, ...) (_snwprintf((buf), (len), (fmt), __VA_ARGS__))

+#endif

+#ifdef HAVE_LOCALTIME_S

+#ifdef _WIN32

+/* Windows is incompatible to the C11 standard, hurray! */

+#define zip_localtime(t, tm) (localtime_s((tm), (t)) == 0 ? tm : NULL)

+#else

+#define zip_localtime localtime_s

+#endif

+#else

+#ifdef HAVE_LOCALTIME_R

+#define zip_localtime localtime_r

+#else

+#define zip_localtime(t, tm) (localtime(t))

+#endif

+#endif

+

+#ifndef HAVE_MEMCPY_S

+#define memcpy_s(dest, destsz, src, count) (memcpy((dest), (src), (count)) == NULL)

+#endif

+

+#ifndef HAVE_SNPRINTF_S

+#ifdef HAVE__SNPRINTF_S

+#define snprintf_s(buf, bufsz, fmt, ...) (_snprintf_s((buf), (bufsz), (bufsz), (fmt), __VA_ARGS__))

+#else

+#define snprintf_s snprintf

+#endif

+#endif

+

+#ifndef HAVE_STRNCPY_S

+#define strncpy_s(dest, destsz, src, count) (strncpy((dest), (src), (count)), 0)

+#endif

+

+#ifndef HAVE_STRERROR_S

+#define strerrorlen_s(errnum) (strlen(strerror(errnum)))

+#define strerror_s(buf, bufsz, errnum) ((void)strncpy_s((buf), (bufsz), strerror(errnum), (bufsz)), (buf)[(bufsz)-1] = '\0', strerrorlen_s(errnum) >= (bufsz))

+#else

+#ifndef HAVE_STRERRORLEN_S

+#define strerrorlen_s(errnum) 8192

+#endif

+#endif

+

+#define ENABLE_FDOPEN

+#define HAVE__SNPRINTF_S

+#define HAVE__SNWPRINTF_S

+#define HAVE_LOCALTIME_S

+#define HAVE_MEMCPY_S

+/* #undef HAVE_SNPRINTF_S */

+#define HAVE_STRERROR_S

+/* #undef HAVE_STRERRORLEN_S */

+#define HAVE_STRNCPY_S

+#define VERSION "1.10.0"

+#ifndef ZIP_DEPRECATED

+#if defined(__GNUC__) || defined(__clang__)

+#define ZIP_DEPRECATED(x) __attribute__((deprecated(x)))

+#elif defined(_MSC_VER)

+#define ZIP_DEPRECATED(x) __declspec(deprecated(x))

+#else

+#define ZIP_DEPRECATED(x)

+#endif

+#endif

+

+/* 16u was ZIP_FL_RECOMPRESS, which is deprecated */

+#define ZIP_AFL_RDONLY 2u /* read only -- cannot be cleared */

+#define ZIP_AFL_IS_TORRENTZIP 4u /* current archive is torrentzipped */

+#define ZIP_AFL_WANT_TORRENTZIP 8u /* write archive in torrentzip format */

+#define ZIP_AFL_CREATE_OR_KEEP_FILE_FOR_EMPTY_ARCHIVE 16u /* don't remove file if archive is empty */

+#define ZIP_ER_DATA_LENGTH 33 /* N Unexpected length of data */

+#define ZIP_ER_NOT_ALLOWED 34 /* N Not allowed in torrentzip */

+ ZIP_SOURCE_GET_FILE_ATTRIBUTES, /* get additional file attributes */

+ ZIP_SOURCE_SUPPORTS_REOPEN /* allow reading from changed entry */

+typedef zip_int64_t (*zip_source_layered_callback)(zip_source_t *_Nonnull, void *_Nullable, void *_Nullable, zip_uint64_t, enum zip_source_cmd);

+#define ZIP_FL_RECOMPRESS 16u /* force recompression of data */

+

+ZIP_DEPRECATED("use 'zip_register_progress_callback_with_state' instead") ZIP_EXTERN void zip_register_progress_callback(zip_t *_Nonnull, zip_progress_callback_t _Nullable);

+

+ZIP_DEPRECATED("use 'zip_file_add' instead") ZIP_EXTERN zip_int64_t zip_add(zip_t *_Nonnull, const char *_Nonnull, zip_source_t *_Nonnull);

+ZIP_DEPRECATED("use 'zip_dir_add' instead") ZIP_EXTERN zip_int64_t zip_add_dir(zip_t *_Nonnull, const char *_Nonnull);

+ZIP_DEPRECATED("use 'zip_file_get_comment' instead") ZIP_EXTERN const char *_Nullable zip_get_file_comment(zip_t *_Nonnull, zip_uint64_t, int *_Nullable, int);

+ZIP_DEPRECATED("use 'zip_get_num_entries' instead") ZIP_EXTERN int zip_get_num_files(zip_t *_Nonnull);

+ZIP_DEPRECATED("use 'zip_file_rename' instead") ZIP_EXTERN int zip_rename(zip_t *_Nonnull, zip_uint64_t, const char *_Nonnull);

+ZIP_DEPRECATED("use 'zip_file_replace' instead") ZIP_EXTERN int zip_replace(zip_t *_Nonnull, zip_uint64_t, zip_source_t *_Nonnull);

+ZIP_DEPRECATED("use 'zip_file_set_comment' instead") ZIP_EXTERN int zip_set_file_comment(zip_t *_Nonnull, zip_uint64_t, const char *_Nullable, int);

+ZIP_DEPRECATED("use 'zip_error_init_with_code' and 'zip_error_system_type' instead") ZIP_EXTERN int zip_error_get_sys_type(int);

+ZIP_DEPRECATED("use 'zip_get_error' instead") ZIP_EXTERN void zip_error_get(zip_t *_Nonnull, int *_Nullable, int *_Nullable);

+ZIP_DEPRECATED("use 'zip_error_strerror' instead") ZIP_EXTERN int zip_error_to_str(char *_Nonnull, zip_uint64_t, int, int);

+ZIP_DEPRECATED("use 'zip_file_get_error' instead") ZIP_EXTERN void zip_file_error_get(zip_file_t *_Nonnull, int *_Nullable, int *_Nullable);

+ZIP_DEPRECATED("use 'zip_source_zip_file' instead") ZIP_EXTERN zip_source_t *_Nullable zip_source_zip(zip_t *_Nonnull, zip_t *_Nonnull, zip_uint64_t, zip_flags_t, zip_uint64_t, zip_int64_t);

+ZIP_DEPRECATED("use 'zip_source_zip_file_create' instead") ZIP_EXTERN zip_source_t *_Nullable zip_source_zip_create(zip_t *_Nonnull, zip_uint64_t, zip_flags_t, zip_uint64_t, zip_int64_t, zip_error_t *_Nullable);

+ZIP_EXTERN void zip_error_set_from_source(zip_error_t *_Nonnull, zip_source_t *_Nullable);

+ZIP_EXTERN int zip_source_is_seekable(zip_source_t *_Nonnull);

+ZIP_EXTERN zip_source_t *_Nullable zip_source_layered(zip_t *_Nullable, zip_source_t *_Nonnull, zip_source_layered_callback _Nonnull, void *_Nullable);

+ZIP_EXTERN zip_source_t *_Nullable zip_source_layered_create(zip_source_t *_Nonnull, zip_source_layered_callback _Nonnull, void *_Nullable, zip_error_t *_Nullable);

+ZIP_EXTERN zip_int64_t zip_source_pass_to_lower_layer(zip_source_t *_Nonnull, void *_Nullable, zip_uint64_t, zip_source_cmd_t);

+ZIP_EXTERN zip_source_t *_Nullable zip_source_win32a(zip_t *_Nonnull, const char *_Nonnull, zip_uint64_t, zip_int64_t);

+ZIP_EXTERN zip_source_t *_Nullable zip_source_win32a_create(const char *_Nonnull, zip_uint64_t, zip_int64_t, zip_error_t *_Nullable);

+ZIP_EXTERN zip_source_t *_Nullable zip_source_win32handle(zip_t *_Nonnull, void *_Nonnull, zip_uint64_t, zip_int64_t);

+ZIP_EXTERN zip_source_t *_Nullable zip_source_win32handle_create(void *_Nonnull, zip_uint64_t, zip_int64_t, zip_error_t *_Nullable);

+ZIP_EXTERN zip_source_t *_Nullable zip_source_win32w(zip_t *_Nonnull, const wchar_t *_Nonnull, zip_uint64_t, zip_int64_t);

+ZIP_EXTERN zip_source_t *_Nullable zip_source_win32w_create(const wchar_t *_Nonnull, zip_uint64_t, zip_int64_t, zip_error_t *_Nullable);

+ZIP_EXTERN zip_source_t *_Nullable zip_source_zip_file(zip_t *_Nonnull, zip_t *_Nonnull, zip_uint64_t, zip_flags_t, zip_uint64_t, zip_int64_t, const char *_Nullable);

+ZIP_EXTERN zip_source_t *_Nullable zip_source_zip_file_create(zip_t *_Nonnull, zip_uint64_t, zip_flags_t, zip_uint64_t, zip_int64_t, const char *_Nullable, zip_error_t *_Nullable);

+allocate(bool compress, zip_uint32_t compression_flags, zip_error_t *error) {

+ if (compression_flags >= 1 && compression_flags <= 9) {

+ ctx->compression_flags = (int)compression_flags;

+ }

+ else {

+compress_allocate(zip_uint16_t method, zip_uint32_t compression_flags, zip_error_t *error) {

+ (void)method;

+decompress_allocate(zip_uint16_t method, zip_uint32_t compression_flags, zip_error_t *error) {

+ (void)method;

+ (void)ud;

+ (void)st;

+ (void)attributes;

+

+ unsigned int avail_out;

+ avail_out = (unsigned int)ZIP_MIN(UINT_MAX, *length);

+ ctx->zstr.avail_out = avail_out;

+ *length = avail_out - ctx->zstr.avail_out;

+ int level;

+ int mem_level;

+allocate(bool compress, zip_uint32_t compression_flags, zip_error_t *error) {

+ if (compression_flags >= 1 && compression_flags <= 9) {

+ ctx->level = (int)compression_flags;

+ else {

+ ctx->level = Z_BEST_COMPRESSION;

+ }

+ ctx->mem_level = compression_flags == TORRENTZIP_COMPRESSION_FLAGS ? TORRENTZIP_MEM_LEVEL : MAX_MEM_LEVEL;

+compress_allocate(zip_uint16_t method, zip_uint32_t compression_flags, zip_error_t *error) {

+ (void)method;

+decompress_allocate(zip_uint16_t method, zip_uint32_t compression_flags, zip_error_t *error) {

+ (void)method;

+ if (ctx->level < 3) {

+ else if (ctx->level > 7) {

+ (void)st;

+ (void)attributes;

+

+ ret = deflateInit2(&ctx->zstr, ctx->level, Z_DEFLATED, -MAX_WBITS, ctx->mem_level, Z_DEFAULT_STRATEGY);

+ uInt avail_out;

+ avail_out = (uInt)ZIP_MIN(UINT_MAX, *length);

+ ctx->zstr.avail_out = avail_out;

+ *length = avail_out - ctx->zstr.avail_out;

+allocate(bool compress, zip_uint32_t compression_flags, zip_error_t *error, zip_uint16_t method) {

+ if (compression_flags <= 9) {

+ ctx->compression_flags = compression_flags;

+ ctx->compression_flags = 6; /* default value */

+ if (method == ZIP_CM_LZMA) {

+compress_allocate(zip_uint16_t method, zip_uint32_t compression_flags, zip_error_t *error) {

+decompress_allocate(zip_uint16_t method, zip_uint32_t compression_flags, zip_error_t *error) {

+ (void)memcpy_s(ctx->header + ctx->header_bytes_offset, sizeof(ctx->header) - ctx->header_bytes_offset, data, got);

+ uInt avail_out;

+ (void)memcpy_s(data, *length, ctx->header + ctx->header_bytes_offset, write_len);

+ avail_out = (uInt)ZIP_MIN(UINT_MAX, *length);

+ ctx->zstr.avail_out = avail_out;

+ *length = avail_out - ctx->zstr.avail_out;

+allocate(bool compress, zip_uint32_t compression_flags, zip_error_t *error) {

+ ctx->compression_flags = (zip_int32_t)compression_flags;

+ if (ctx->compression_flags < ZSTD_minCLevel() || ctx->compression_flags > ZSTD_maxCLevel()) {

+ ctx->compression_flags = 0; /* let zstd choose */

+ }

+

+compress_allocate(zip_uint16_t method, zip_uint32_t compression_flags, zip_error_t *error) {

+ (void)method;

+decompress_allocate(zip_uint16_t method, zip_uint32_t compression_flags, zip_error_t *error) {

+ (void)method;

+ (void)ud;

+

+ (void)st;

+ (void)attributes;

+

+ zip_uint64_t copied;

+

+ copied = 0;

+ while (copied < length) {

+ size_t n = ZIP_MIN(length - copied, SIZE_MAX);

+ (void)memcpy_s(data + copied, n, _zip_buffer_get(buffer, n), n);

+ copied += n;

+ }

+ return copied;

+#if ZIP_UINT64_MAX > SIZE_MAX

+ if (size > SIZE_MAX) {

+ return NULL;

+ }

+#endif

+

+ if ((data = (zip_uint8_t *)malloc((size_t)size)) == NULL) {

+ (void)memcpy_s(dst, length, src, length);

+static int torrentzip_compare_names(const void *a, const void *b);

+ if (survivors == 0 && !(za->ch_flags & ZIP_AFL_CREATE_OR_KEEP_FILE_FOR_EMPTY_ARCHIVE)) {

+ /* don't create zip files with no entries */

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

+ /* Always write empty archive if we are told to keep it, otherwise it wouldn't be created if the file doesn't already exist. */

+ if (!changed && survivors > 0) {

+ filelist[j].name = zip_get_name(za, i, 0);

+ if (ZIP_WANT_TORRENTZIP(za)) {

+ qsort(filelist, (size_t)survivors, sizeof(filelist[0]), torrentzip_compare_names);

+ }

+

+ if (ZIP_WANT_TORRENTZIP(za) || (zip_source_supports(za->src) & ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_BEGIN_WRITE_CLONING)) == 0) {

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

+ new_data = (ZIP_ENTRY_DATA_CHANGED(entry) || ZIP_ENTRY_CHANGED(entry, ZIP_DIRENT_COMP_METHOD) || ZIP_ENTRY_CHANGED(entry, ZIP_DIRENT_ENCRYPTION_METHOD)) || (ZIP_WANT_TORRENTZIP(za) && !ZIP_IS_TORRENTZIP(za));

+ if (ZIP_WANT_TORRENTZIP(za)) {

+ zip_dirent_torrentzip_normalize(entry->changes);

+ }

+

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

+ if ((zs = zip_source_zip_file_create(za, i, ZIP_FL_UNCHANGED, 0, -1, NULL, &za->error)) == NULL) {

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

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

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

+ /* TODO: not valid for torrentzip */

+ /* TODO: not valid for torrentzip */

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

+ needs_recompress = ZIP_WANT_TORRENTZIP(za) || st.comp_method != ZIP_CM_ACTUAL(de->comp_method);

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

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

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

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

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

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

+ if (ZIP_WANT_TORRENTZIP(za)) {

+ zip_dirent_torrentzip_normalize(de);

+ }

+

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

+ zip_uint64_t n = ZIP_MIN(len, BUFSIZE);

+

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

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

+ if (za->comment_changed || (ZIP_WANT_TORRENTZIP(za) && !ZIP_IS_TORRENTZIP(za))) {

+

+

+static int torrentzip_compare_names(const void *a, const void *b) {

+ const char *aname = ((const zip_filelist_t *)a)->name;

+ const char *bname = ((const zip_filelist_t *)b)->name;

+

+ if (aname == NULL) {

+ return (bname != NULL) * -1;

+ }

+ else if (bname == NULL) {

+ return 1;

+ }

+

+ return strcasecmp(aname, bname);

+} \ No newline at end of file

+#if MBEDTLS_VERSION_NUMBER < 0x03030000

+

+

+#else

+

+ ok = mbedtls_pkcs5_pbkdf2_hmac_ext(MBEDTLS_MD_SHA1, (const unsigned char *)key, (size_t)key_length, (const unsigned char *)salt, (size_t)salt_length, (unsigned int)iterations, (uint32_t)output_length, (unsigned char *)output) == 0;

+

+#endif // !defined(MBEDTLS_DEPRECATED_REMOVED) || MBEDTLS_VERSION_NUMBER < 0x03030000

+

+#ifdef USE_OPENSSL_3_API

+static _zip_crypto_hmac_t* hmac_new() {

+ _zip_crypto_hmac_t *hmac = (_zip_crypto_hmac_t*)malloc(sizeof(*hmac));

+ if (hmac != NULL) {

+ hmac->mac = NULL;

+ hmac->ctx = NULL;

+ }

+ return hmac;

+}

+static void hmac_free(_zip_crypto_hmac_t* hmac) {

+ if (hmac != NULL) {

+ if (hmac->ctx != NULL) {

+ EVP_MAC_CTX_free(hmac->ctx);

+ }

+ if (hmac->mac != NULL) {

+ EVP_MAC_free(hmac->mac);

+ }

+ free(hmac);

+ }

+}

+#ifdef USE_OPENSSL_3_API

+ if ((hmac = hmac_new()) == NULL

+ || (hmac->mac = EVP_MAC_fetch(NULL, "HMAC", "provider=default")) == NULL

+ || (hmac->ctx = EVP_MAC_CTX_new(hmac->mac)) == NULL) {

+ hmac_free(hmac);

+ zip_error_set(error, ZIP_ER_MEMORY, 0);

+ return NULL;

+ }

+

+ {

+ OSSL_PARAM params[2];

+ params[0] = OSSL_PARAM_construct_utf8_string("digest", "SHA1", 0);

+ params[1] = OSSL_PARAM_construct_end();

+

+ if (!EVP_MAC_init(hmac->ctx, (const unsigned char *)secret, secret_length, params)) {

+ zip_error_set(error, ZIP_ER_INTERNAL, 0);

+ hmac_free(hmac);

+ return NULL;

+ }

+ }

+#else

+ HMAC_CTX_init(hmac);

+#endif

+#if defined(USE_OPENSSL_3_API)

+ hmac_free(hmac);

+#elif defined(USE_OPENSSL_1_0_API)

+#ifdef USE_OPENSSL_3_API

+ size_t length;

+ return EVP_MAC_final(hmac->ctx, data, &length, ZIP_CRYPTO_SHA1_LENGTH) == 1 && length == ZIP_CRYPTO_SHA1_LENGTH;

+#else

+#endif

+#if OPENSSL_VERSION_NUMBER < 0x1010000fL || (defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER < 0x02070000fL)

+#define USE_OPENSSL_1_0_API

+#elif OPENSSL_VERSION_NUMBER < 0x3000000fL

+#define USE_OPENSSL_1_1_API

+#else

+#define USE_OPENSSL_3_API

+#endif

+

+#ifdef USE_OPENSSL_3_API

+struct _zip_crypto_hmac_t {

+ EVP_MAC *mac;

+ EVP_MAC_CTX *ctx;

+};

+typedef struct _zip_crypto_hmac_t _zip_crypto_hmac_t;

+#define _zip_crypto_hmac(hmac, data, length) (EVP_MAC_update((hmac->ctx), (data), (length)) == 1)

+#else

+#define _zip_crypto_hmac(hmac, data, length) (HMAC_Update((hmac), (data), (length)) == 1)

+#endif

+ (void)memcpy_s(U, cbSalt, pbSalt, cbSalt);

+ (void)memcpy_s(U, DIGEST_SIZE, V, DIGEST_SIZE);

+ (void)memcpy_s(&pbDerivedKey[(i - 1) * DIGEST_SIZE], cbDerivedKey - (i - 1) * DIGEST_SIZE, Ti, DIGEST_SIZE);

+ (void)memcpy_s(&pbDerivedKey[(i - 1) * DIGEST_SIZE], cbDerivedKey - (i - 1) * DIGEST_SIZE, Ti, r);

+ if (len > SIZE_MAX - 2 || (s = (char *)malloc(len + 2)) == NULL) {

+ (void)strncpy_s(s, len + 2, name, len);

+#include <zlib.h>

+ zip_uint32_t cdir_crc;

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

+ if (ZIP_WANT_TORRENTZIP(za)) {

+ cdir_crc = (zip_uint32_t)crc32(0, NULL, 0);

+ za->write_crc = &cdir_crc;

+ }

+

+ za->write_crc = NULL;

+

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

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

+ }

+ if (ZIP_WANT_TORRENTZIP(za)) {

+ _zip_buffer_put_16(buffer, TORRENTZIP_SIGNATURE_LENGTH + TORRENTZIP_CRC_LENGTH);

+ }

+ else {

+ _zip_buffer_put_16(buffer, (zip_uint16_t)(comment ? comment->length : 0));

+ }

+

+ if (ZIP_WANT_TORRENTZIP(za)) {

+ char torrentzip_comment[TORRENTZIP_SIGNATURE_LENGTH + TORRENTZIP_CRC_LENGTH + 1];

+ snprintf(torrentzip_comment, sizeof(torrentzip_comment), TORRENTZIP_SIGNATURE "%08X", cdir_crc);

+

+ if (_zip_write(za, torrentzip_comment, strlen(torrentzip_comment)) < 0) {

+ return -1;

+ }

+ }

+ else if (comment != NULL) {

+ (void)memcpy_s(tde, sizeof(*tde), sde, sizeof(*sde));

+ if (ef != NULL) {

+ if (!zip_dirent_process_ef_zip64(zde, ef, got_len, local, error)) {

+

+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_buffer_t *ef_buffer;

+

+ if ((ef_buffer = _zip_buffer_new((zip_uint8_t *)ef, got_len)) == NULL) {

+ zip_error_set(error, ZIP_ER_MEMORY, 0);

+ return false;

+ }

+

+ if (zde->uncomp_size == ZIP_UINT32_MAX) {

+ zde->uncomp_size = _zip_buffer_get_64(ef_buffer);

+ }

+ else if (local) {

+ /* From appnote.txt: This entry in the Local header MUST

+ include BOTH original and compressed file size fields. */

+ (void)_zip_buffer_skip(ef_buffer, 8); /* error is caught by _zip_buffer_eof() call */

+ }

+ if (zde->comp_size == ZIP_UINT32_MAX) {

+ zde->comp_size = _zip_buffer_get_64(ef_buffer);

+ }

+ if (!local) {

+ if (zde->offset == ZIP_UINT32_MAX) {

+ zde->offset = _zip_buffer_get_64(ef_buffer);

+ }

+ if (zde->disk_number == ZIP_UINT16_MAX) {

+ zde->disk_number = _zip_buffer_get_32(ef_buffer);

+ }

+ }

+

+ if (!_zip_buffer_eof(ef_buffer)) {

+ /* accept additional fields if values match */

+ bool ok = true;

+ switch (got_len) {

+ case 28:

+ _zip_buffer_set_offset(ef_buffer, 24);

+ if (zde->disk_number != _zip_buffer_get_32(ef_buffer)) {

+ ok = false;

+ }

+ /* fallthrough */

+ case 24:

+ _zip_buffer_set_offset(ef_buffer, 0);

+ if ((zde->uncomp_size != _zip_buffer_get_64(ef_buffer)) || (zde->comp_size != _zip_buffer_get_64(ef_buffer)) || (zde->offset != _zip_buffer_get_64(ef_buffer))) {

+ ok = false;

+ }

+ break;

+

+ default:

+ ok = false;

+ }

+ if (!ok) {

+ zip_error_set(error, ZIP_ER_INCONS, ZIP_ER_DETAIL_INVALID_ZIP64_EF);

+ _zip_buffer_free(ef_buffer);

+ return false;

+ }

+ }

+ _zip_buffer_free(ef_buffer);

+

+ return true;

+}

+

+ zip_error_set_from_source(error, src);

+ if (ZIP_WANT_TORRENTZIP(za)) {

+ dostime = 0xbc00;

+ dosdate = 0x2198;

+ }

+ else {

+ _zip_u2d_time(de->last_mod, &dostime, &dosdate);

+ }

+ ef_total_size = (zip_uint32_t)_zip_ef_size(ef, ZIP_EF_BOTH);

+ if (!ZIP_WANT_TORRENTZIP(za)) {

+ /* TODO: check for overflow */

+ ef_total_size += (zip_uint32_t)_zip_ef_size(de->extra_fields, flags);

+ }

+ _zip_buffer_put_16(buffer, ZIP_WANT_TORRENTZIP(za) ? 0 : _zip_string_length(de->comment));

+ if (de->extra_fields && !ZIP_WANT_TORRENTZIP(za)) {

+ if ((flags & ZIP_FL_LOCAL) == 0 && !ZIP_WANT_TORRENTZIP(za)) {

+ tpm = zip_localtime(&intime, &tm);

+ /* if localtime fails, return an arbitrary date (1980-01-01 00:00:00) */

+

+

+/* _zip_dirent_torrent_normalize(de);

+ Set values suitable for torrentzip.

+*/

+

+void zip_dirent_torrentzip_normalize(zip_dirent_t *de) {

+ de->version_madeby = 0;

+ de->version_needed = 20; /* 2.0 */

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

+ de->comp_method = ZIP_CM_DEFLATE;

+ de->compression_level = TORRENTZIP_COMPRESSION_FLAGS;

+ de->disk_number = 0;

+ de->int_attrib = 0;

+ de->ext_attrib = 0;

+

+ /* last_mod, extra_fields, and comment are normalized in zip_dirent_write() directly */

+

+}

+ { N, "Unexpected length of data" },

+ { N, "Not allowed in torrentzip" },

+zip_error_set_from_source(zip_error_t *err, zip_source_t *src) {

+ if (src == NULL) {

+ zip_error_set(err, ZIP_ER_INVAL, 0);

+ return;

+ }

+

+ char *s;

+ char *system_error_buffer = NULL;

+ system_error_buffer = (char *)malloc(128);

+ snprintf_s(system_error_buffer, 128, "Unknown error %d", err->zip_err);

+ system_error_buffer[128 - 1] = '\0'; /* make sure string is NUL-terminated */

+ system_error_string = system_error_buffer;

+ case ZIP_ET_SYS: {

+ size_t len = strerrorlen_s(err->sys_err) + 1;

+ system_error_buffer = malloc(len);

+ strerror_s(system_error_buffer, len, err->sys_err);

+ system_error_string = system_error_buffer;

+ }

+ system_error_buffer = (char *)malloc(128);

+ snprintf_s(system_error_buffer, 128, "invalid detail error %u", error);

+ system_error_buffer[128 - 1] = '\0'; /* make sure string is NUL-terminated */

+ system_error_string = system_error_buffer;

+ system_error_buffer = (char *)malloc(128);

+ snprintf_s(system_error_buffer, 128, "entry %d: %s", index, _zip_err_details[error].description);

+ system_error_buffer[128 - 1] = '\0'; /* make sure string is NUL-terminated */

+ system_error_string = system_error_buffer;

+ free(system_error_buffer);

+ size_t length = strlen(system_error_string);

+ if (zip_error_string) {

+ size_t length_error = strlen(zip_error_string);

+ if (length + length_error + 2 < length) {

+ free(system_error_buffer);

+ return _zip_err_str[ZIP_ER_MEMORY].description;

+ }

+ length += length_error + 2;

+ }

+ if (length == SIZE_MAX || (s = (char *)malloc(length + 1)) == NULL) {

+ free(system_error_buffer);

+ snprintf_s(s, length + 1, "%s%s%s", (zip_error_string ? zip_error_string : ""), (zip_error_string ? ": " : ""), system_error_string);

+ free(system_error_buffer);

+ zip_error_t error;

+ const char *error_string;

+ int ret;

+ zip_error_init(&error);

+ zip_error_set(&error, ze, se);

+ error_string = zip_error_strerror(&error);

+ ret = snprintf_s(buf, ZIP_MIN(len, SIZE_MAX), error_string, strlen(error_string));

+ zip_error_fini(&error);

+

+ return ret;

+ /* buffer is at most 64k long, so this can't overflow. */

+ if (glen >= 4 || garbage == NULL || memcmp(garbage, "\0\0\0", (size_t)glen) != 0) {

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

+ if (ZIP_WANT_TORRENTZIP(za)) {

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

+ return -1;

+ }

+ if (ZIP_WANT_TORRENTZIP(za)) {

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

+ return -1;

+ }

+ if (ZIP_WANT_TORRENTZIP(za)) {

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

+ return -1;

+ }

+#ifndef ENABLE_FDOPEN

+ _zip_set_open_error(zep, NULL, ZIP_ER_OPNOTSUPP);

+ return NULL;

+#else

+#endif

+ zip_error_set_from_source(error, za->src);

+ zip_error_set_from_source(error, za->src);

+ zip_error_set_from_source(error, za->src);

+ if (ZIP_WANT_TORRENTZIP(za)) {

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

+ return -1;

+ }

+ if (ZIP_WANT_TORRENTZIP(za)) {

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

+ return -1;

+ }

+ if (ZIP_WANT_TORRENTZIP(za)) {

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

+ return -1;

+ }

+ if (ZIP_WANT_TORRENTZIP(za)) {

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

+ return -1;

+ }

+ if ((src = zip_source_zip_file_create(za, index, flags, 0, -1, password, &za->error)) == NULL)

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

+ if (toread == 0) {

+ }

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

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

+ return zip_source_is_seekable(zfile->src);

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

+#include <limits.h>

+#include <zlib.h>

+ zip_error_set_from_source(error, src);

+ (void)memcpy_s(r, length, data, length);

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

+ if (za->write_crc != NULL) {

+ zip_uint64_t position = 0;

+ while (position < length) {

+ zip_uint64_t nn = ZIP_MIN(UINT_MAX, length - position);

+

+ *za->write_crc = (zip_uint32_t)crc32(*za->write_crc, (const Bytef *)data + position, (uInt)nn);

+ position += nn;

+ }

+ }

+

+ (void)memcpy_s(ret, len, mem, len);

+ size_t fname_length;

+ if (za == NULL) {

+ }

+ fname_length = strlen(fname);

+

+ if (fname_length > ZIP_UINT16_MAX) {

+ zip_error_set(error, ZIP_ER_INVAL, 0);

+ return -1;

+ }

+

+ if ((str = _zip_string_new((const zip_uint8_t *)fname, (zip_uint16_t)strlen(fname), flags, error)) == NULL) {

+#include <limits.h>

+static void zip_check_torrentzip(zip_t *za, const zip_cdir_t *cdir);

+static const unsigned char *_zip_memmem(const unsigned char *, size_t, const unsigned char *, size_t);

+ zip_error_set_from_source(error, src);

+ zip_error_set_from_source(error, src);

+

+ zip_check_torrentzip(za, cdir);

+

+ if (ZIP_IS_TORRENTZIP(za)) {

+ /* Torrentzip uses the archive comment to detect changes by tools that are not torrentzip aware. */

+ _zip_string_free(cdir->comment);

+ }

+ else {

+ za->comment_orig = cdir->comment;

+ }

+ zip_error_set_from_source(error, za->src);

+ zip_error_set_from_source(error, za->src);

+ zip_error_set_from_source(error, za->src);

+ This is in violation of the appnote.

+ 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 */

+ if ((local->bitflags & ZIP_GPBF_DATA_DESCRIPTOR) == 0) {

+ }

+ /* 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;

+ }

+ za->flags = 0;

+ za->ch_flags = 0;

+ za->write_crc = NULL;

+

+

+ const zip_uint8_t *match;

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

+ /* The size of buffer never greater than CDBUFSIZE. */

+ while (_zip_buffer_left(buffer) >= EOCDLEN && (match = _zip_memmem(match, (size_t)_zip_buffer_left(buffer) - (EOCDLEN - 4), (const unsigned char *)EOCD_MAGIC, 4)) != NULL) {

+static const unsigned char *_zip_memmem(const unsigned char *big, size_t biglen, const unsigned char *little, size_t littlelen) {

+ if (littlelen == 0) {

+ return big;

+ }

+

+ if (biglen < littlelen) {

+ p = big;

+ while (true) {

+ p = (const unsigned char *)memchr(p, little[0], biglen - (littlelen - 1) - (size_t)(p - big));

+ if (p == NULL) {

+ return NULL;

+ }

+ if (memcmp(p + 1, little + 1, littlelen - 1) == 0) {

+ return p;

+ }

+ p += 1;

+ }

+ zip_error_set_from_source(error, src);

+

+

+static int decode_hex(char c) {

+ if (c >= '0' && c <= '9') {

+ return c - '0';

+ }

+ else if (c >= 'A' && c <= 'F') {

+ return c - 'A' + 10;

+ }

+ else {

+ return -1;

+ }

+}

+

+/* _zip_check_torrentzip:

+ check whether ZA has a valid TORRENTZIP comment, i.e. is torrentzipped */

+

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

+ zip_uint32_t crc_should;

+ char buf[8+1];

+ size_t i;

+

+ if (cdir == NULL) {

+ return;

+ }

+

+ if (_zip_string_length(cdir->comment) != TORRENTZIP_SIGNATURE_LENGTH + TORRENTZIP_CRC_LENGTH

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

+ return;

+

+ memcpy(buf, cdir->comment->raw + TORRENTZIP_SIGNATURE_LENGTH, TORRENTZIP_CRC_LENGTH);

+ buf[TORRENTZIP_CRC_LENGTH] = '\0';

+ crc_should = 0;

+ for (i = 0; i < TORRENTZIP_CRC_LENGTH; i += 2) {

+ int low, high;

+ high = decode_hex((buf[i]));

+ low = decode_hex(buf[i + 1]);

+ if (high < 0 || low < 0) {

+ return;

+ }

+ crc_should = (crc_should << 8) + (high << 4) + low;

+ }

+

+ {

+ zip_stat_t st;

+ zip_source_t* src_window;

+ zip_source_t* src_crc;

+ zip_uint8_t buffer[512];

+ zip_int64_t ret;

+

+ zip_stat_init(&st);

+ st.valid |= ZIP_STAT_SIZE | ZIP_STAT_CRC;

+ st.size = cdir->size;

+ st.crc = crc_should;

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

+ return;

+ }

+ if ((src_crc = zip_source_crc_create(src_window, 1, NULL)) == NULL) {

+ zip_source_free(src_window);

+ return;

+ }

+ if (zip_source_open(src_crc) != 0) {

+ zip_source_free(src_crc);

+ return;

+ }

+ while ((ret = zip_source_read(src_crc, buffer, sizeof(buffer))) > 0) {

+ }

+ zip_source_free(src_crc);

+ if (ret < 0) {

+ return;

+ }

+ }

+

+ /* TODO: if check consistency, check cdir entries for valid values */

+ za->flags |= ZIP_AFL_IS_TORRENTZIP;

+}

+ if (ZIP_WANT_TORRENTZIP(za)) {

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

+ return -1;

+ }

+ if (flag == ZIP_AFL_IS_TORRENTZIP) {

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

+ return -1;

+ }

+

+ /* TODO: when setting ZIP_AFL_WANT_TORRENTZIP, we should error out if any changes have been made that are not allowed for torrentzip. */

+

+ if (value) {

+ }

+ else {

+ }

+ if (new_flags == za->ch_flags) {

+ }

+ if (ZIP_WANT_TORRENTZIP(za)) {

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

+ return -1;

+ }

+ zip_int64_t ret;

+ ret = _zip_source_call(src, NULL, 0, ZIP_SOURCE_ACCEPT_EMPTY);

+ if (ZIP_SOURCE_IS_LAYERED(src)) {

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

+ return -1;

+ }

+

+ if (ZIP_SOURCE_IS_LAYERED(src)) {

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

+ return -1;

+ }

+

+ zip_uint64_t size; /* size of buffer */

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

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

+ return zip_source_make_command_bitmap(ZIP_SOURCE_GET_FILE_ATTRIBUTES, ZIP_SOURCE_OPEN, ZIP_SOURCE_READ, ZIP_SOURCE_CLOSE, ZIP_SOURCE_STAT, ZIP_SOURCE_ERROR, ZIP_SOURCE_FREE, ZIP_SOURCE_SEEK, ZIP_SOURCE_TELL, ZIP_SOURCE_BEGIN_WRITE, ZIP_SOURCE_BEGIN_WRITE_CLONING, ZIP_SOURCE_COMMIT_WRITE, ZIP_SOURCE_REMOVE, ZIP_SOURCE_ROLLBACK_WRITE, ZIP_SOURCE_SEEK_WRITE, ZIP_SOURCE_TELL_WRITE, ZIP_SOURCE_WRITE, ZIP_SOURCE_SUPPORTS_REOPEN, -1);

+ /* TODO: This should also consider the length of the fully shared fragments */

+ clone->fragments[fragment].length = fragment_offset;

+ buffer->shared_fragments = fragment + 1;

+ zip_uint64_t fragments_size;

+ zip_uint64_t offsets_size;

+ fragments_size = sizeof(buffer->fragments[0]) * capacity;

+ offsets_size = sizeof(buffer->fragment_offsets[0]) * (capacity + 1);

+

+ if (capacity == ZIP_UINT64_MAX || fragments_size < capacity || fragments_size > SIZE_MAX|| offsets_size < capacity || offsets_size > SIZE_MAX) {

+ zip_error_set(error, ZIP_ER_MEMORY, 0);

+ return false;

+ }

+

+ if ((fragments = realloc(buffer->fragments, (size_t)fragments_size)) == NULL) {

+ if ((offsets = realloc(buffer->fragment_offsets, (size_t)offsets_size)) == NULL) {

+ /* TODO: overflow */

+#if ZIP_UINT64_MAX > SIZE_MAX

+ left = ZIP_MIN(left, SIZE_MAX);

+#endif

+ (void)memcpy_s(data + n, (size_t)left, buffer->fragments[i].data + fragment_offset, (size_t)left);

+ zip_uint64_t copied, i, fragment_offset, capacity;

+ copied = 0;

+ while (copied < length) {

+ zip_uint64_t n = ZIP_MIN(ZIP_MIN(length - copied, buffer->fragments[i].length - fragment_offset), SIZE_MAX);

+#if ZIP_UINT64_MAX > SIZE_MAX

+ n = ZIP_MIN(n, SIZE_MAX);

+#endif

+ (void)memcpy_s(buffer->fragments[i].data + fragment_offset, (size_t)n, data + copied, (size_t)n);

+ if (n == buffer->fragments[i].length - fragment_offset) {

+ fragment_offset = 0;

+ else {

+ fragment_offset += n;

+ }

+ copied += n;

+ buffer->offset += copied;

+ return (zip_int64_t)copied;

+ if (ZIP_SOURCE_IS_LAYERED(src)) {

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

+ return -1;

+ }

+

+static zip_source_t *compression_source_new(zip_t *za, zip_source_t *src, zip_int32_t method, bool compress, zip_uint32_t compression_flags);

+static struct context *context_new(zip_int32_t method, bool compress, zip_uint32_t compression_flags, zip_compression_algorithm_t *algorithm);

+zip_source_compress(zip_t *za, zip_source_t *src, zip_int32_t method, zip_uint32_t compression_flags) {

+compression_source_new(zip_t *za, zip_source_t *src, zip_int32_t method, bool compress, zip_uint32_t compression_flags) {

+context_new(zip_int32_t method, bool compress, zip_uint32_t compression_flags, zip_compression_algorithm_t *algorithm) {

+ (void)memcpy_s(data, ctx->size, ctx->buffer, ctx->size);

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

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

+ st->valid &= ~ZIP_STAT_COMP_SIZE;

+ return ZIP_SOURCE_SUPPORTS_READABLE | zip_source_make_command_bitmap(ZIP_SOURCE_GET_FILE_ATTRIBUTES, ZIP_SOURCE_SUPPORTS_REOPEN, -1);

+ return zip_source_pass_to_lower_layer(src, data, len, cmd);

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

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

+ if ((st->valid & ZIP_STAT_SIZE) && st->size != ctx->size) {

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

+ return -1;

+ }

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

+ mask &= ~zip_source_make_command_bitmap(ZIP_SOURCE_BEGIN_WRITE, ZIP_SOURCE_COMMIT_WRITE, ZIP_SOURCE_ROLLBACK_WRITE, ZIP_SOURCE_SEEK_WRITE, ZIP_SOURCE_TELL_WRITE, ZIP_SOURCE_REMOVE, ZIP_SOURCE_GET_FILE_ATTRIBUTES, -1);

+ mask |= zip_source_make_command_bitmap(ZIP_SOURCE_FREE, -1);

+ return mask;

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

+ return zip_source_pass_to_lower_layer(src, data, len, cmd);

+ (void)memcpy_s(&ctx->st, sizeof(ctx->st), st, sizeof(*st));

+ ctx->supports = ZIP_SOURCE_SUPPORTS_READABLE | zip_source_make_command_bitmap(ZIP_SOURCE_SUPPORTS, ZIP_SOURCE_TELL, ZIP_SOURCE_SUPPORTS_REOPEN, -1);

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

+ if (ctx->start > 0) { /* TODO: rewind on re-open */

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

+static FILE *_zip_fopen_close_on_exec(const char *name, bool writeable);

+ size_t temp_size = strlen(ctx->fname) + 13;

+ if ((temp = (char *)malloc(temp_size)) == NULL) {

+ snprintf_s(temp, temp_size, "%s.XXXXXX.part", ctx->fname);

+

+

+/*

+ * fopen replacement that sets the close-on-exec flag

+ * some implementations support an fopen 'e' flag for that,

+ * but e.g. macOS doesn't.

+ */

+static FILE *_zip_fopen_close_on_exec(const char *name, bool writeable) {

+ int fd;

+ int flags;

+ FILE *fp;

+

+ flags = O_CLOEXEC;

+ if (writeable) {

+ flags |= O_RDWR;

+ }

+ else {

+ flags |= O_RDONLY;

+ }

+

+ /* mode argument needed on Windows */

+ if ((fd = open(name, flags, 0666)) < 0) {

+ return NULL;

+ }

+ if ((fp = fdopen(fd, writeable ? "r+b" : "rb")) == NULL) {

+ return NULL;

+ }

+ return fp;

+}

+#ifdef __clang__

+#define DONT_WARN_INCOMPATIBLE_FN_PTR_BEGIN _Pragma("GCC diagnostic push") _Pragma("GCC diagnostic ignored \"-Wincompatible-function-pointer-types\"")

+#define DONT_WARN_INCOMPATIBLE_FN_PTR_END _Pragma("GCC diagnostic pop")

+#else

+#define DONT_WARN_INCOMPATIBLE_FN_PTR_BEGIN

+#define DONT_WARN_INCOMPATIBLE_FN_PTR_END

+#endif

+

+DONT_WARN_INCOMPATIBLE_FN_PTR_BEGIN

+DONT_WARN_INCOMPATIBLE_FN_PTR_END

+ snprintf_s(buf, len, "%s.%08x", name, i);

+DONT_WARN_INCOMPATIBLE_FN_PTR_BEGIN

+DONT_WARN_INCOMPATIBLE_FN_PTR_END

+ _snwprintf_s((wchar_t *)buf, len, len, L"%s.%08x", (const wchar_t *)name, i);

+ zs->supports = zcb(ud, NULL, 0, ZIP_SOURCE_SUPPORTS);

+ zs->supports |= zip_source_make_command_bitmap(ZIP_SOURCE_SUPPORTS, -1);

+ zip_file_attributes_init(&lower_attributes);

+

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

+ zip_int64_t lower_supports, supports;

+ lower_supports = zip_source_supports(src);

+ supports = cb(src, ud, &lower_supports, sizeof(lower_supports), ZIP_SOURCE_SUPPORTS);

+ if (supports < 0) {

+ zip_error_set(error,ZIP_ER_INVAL, 0); /* Initialize in case cb doesn't return valid error. */

+ cb(src, ud, error, sizeof(*error), ZIP_SOURCE_ERROR);

+ }

+

+ if ((zs = _zip_source_new(error)) == NULL) {

+ return NULL;

+ }

+ zs->supports = supports;

+ /* Layered sources can't support writing, since we currently have no use case. If we want to revisit this, we have to define how the two sources interact. */

+ zs->supports &= ~(ZIP_SOURCE_SUPPORTS_WRITABLE & ~ZIP_SOURCE_SUPPORTS_SEEKABLE);

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

+/*

+ zip_source_pass_to_lower_layer.c -- pass command to lower layer

+ Copyright (C) 2022 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"

+

+zip_int64_t zip_source_pass_to_lower_layer(zip_source_t *src, void *data, zip_uint64_t length, zip_source_cmd_t command) {

+ switch (command) {

+ case ZIP_SOURCE_OPEN:

+ case ZIP_SOURCE_CLOSE:

+ case ZIP_SOURCE_FREE:

+ case ZIP_SOURCE_GET_FILE_ATTRIBUTES:

+ case ZIP_SOURCE_SUPPORTS_REOPEN:

+ return 0;

+

+ case ZIP_SOURCE_STAT:

+ return sizeof(zip_stat_t);

+

+ case ZIP_SOURCE_ACCEPT_EMPTY:

+ case ZIP_SOURCE_ERROR:

+ case ZIP_SOURCE_READ:

+ case ZIP_SOURCE_SEEK:

+ case ZIP_SOURCE_TELL:

+ return _zip_source_call(src, data, length, command);

+

+

+ case ZIP_SOURCE_BEGIN_WRITE:

+ case ZIP_SOURCE_BEGIN_WRITE_CLONING:

+ case ZIP_SOURCE_COMMIT_WRITE:

+ case ZIP_SOURCE_REMOVE:

+ case ZIP_SOURCE_ROLLBACK_WRITE:

+ case ZIP_SOURCE_SEEK_WRITE:

+ case ZIP_SOURCE_TELL_WRITE:

+ case ZIP_SOURCE_WRITE:

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

+ return -1;

+

+ case ZIP_SOURCE_SUPPORTS:

+ if (length < sizeof(zip_int64_t)) {

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

+ return -1;

+ }

+ return *(zip_int64_t *)data;

+

+ default:

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

+ return -1;

+ }

+} \ No newline at end of file

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

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

+ 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_SUPPORTS_REOPEN, -1);

+ return zip_source_pass_to_lower_layer(src, data, len, cmd);

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

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

+ return zip_source_pass_to_lower_layer(src, data, length, cmd);

+ if (ZIP_SOURCE_IS_LAYERED(src)) {

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

+ return -1;

+ }

+

+ if (ZIP_SOURCE_IS_LAYERED(src)) {

+ return;

+ }

+

+ if (ZIP_SOURCE_IS_LAYERED(src)) {

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

+ return -1;

+ }

+

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

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

+ }

+

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

+bool

+zip_source_supports_reopen(zip_source_t *src) {

+ return (zip_source_supports(src) & ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_SUPPORTS_REOPEN)) != 0;

+}

+

+

+ZIP_EXTERN int zip_source_is_seekable(zip_source_t *src) {

+ return ZIP_SOURCE_CHECK_SUPPORTED(zip_source_supports(src->src), ZIP_SOURCE_SEEK);

+}

+ if (ZIP_SOURCE_IS_LAYERED(src)) {

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

+ return -1;

+ }

+

+ zip_uint64_t stat_invalid;

+ return _zip_source_window_new(src, start, len, NULL, 0, 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_t *source_archive, zip_uint64_t source_index, bool take_ownership, zip_error_t *error) {

+ zip_source_t* window_source;

+ ctx->stat_invalid = st_invalid;

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

+ 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_SUPPORTS, ZIP_SOURCE_TELL, ZIP_SOURCE_FREE, -1));

+ window_source = zip_source_layered_create(src, window_read, ctx, error);

+ if (window_source != NULL && !take_ownership) {

+ zip_source_keep(src);

+ }

+ return window_source;

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

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

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

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

+

+ if (!(ctx->stat.valid & ZIP_STAT_SIZE)) {

+ if (ctx->end_valid) {

+ st->valid |= ZIP_STAT_SIZE;

+ st->size = ctx->end - ctx->start;

+ }

+ else if (st->valid & ZIP_STAT_SIZE) {

+ st->size -= ctx->start;

+ }

+ }

+

+ st->valid &= ~ctx->stat_invalid;

+

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

+ return zip_source_pass_to_lower_layer(src, data, len, cmd);

+#include "zip_crypto.h"

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

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

+ unsigned char computed[ZIP_CRYPTO_SHA1_LENGTH], from_file[HMAC_LENGTH];

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

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

+ 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_SUPPORTS_REOPEN, -1);

+ return zip_source_pass_to_lower_layer(src, data, len, cmd);

+#include "zip_crypto.h"

+ zip_uint8_t data[ZIP_MAX(WINZIP_AES_MAX_HEADER_LENGTH, ZIP_CRYPTO_SHA1_LENGTH)];

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

+ return zip_source_pass_to_lower_layer(src, data, length, cmd);

+#define _ZIP_COMPILING_DEPRECATED

+ if (len == 0) {

+ len = -1;

+ }

+ if (start == 0 && len == -1) {

+ }

+ else {

+ }

+

+ return zip_source_zip_file_create(srcza, srcidx, flags, start, len, NULL, error);

+ZIP_EXTERN zip_source_t *zip_source_zip_file(zip_t* za, zip_t *srcza, zip_uint64_t srcidx, zip_flags_t flags, zip_uint64_t start, zip_int64_t len, const char *password) {

+ return zip_source_zip_file_create(srcza, srcidx, flags, start, len, password, &za->error);

+}

+

+

+ZIP_EXTERN zip_source_t *zip_source_zip_file_create(zip_t *srcza, zip_uint64_t srcidx, zip_flags_t flags, zip_uint64_t start, zip_int64_t len, const char *password, zip_error_t *error) {

+ /* TODO: We need to make sure that the returned source is invalidated when srcza is closed. */

+ bool partial_data, needs_crc, encrypted, needs_decrypt, compressed, needs_decompress, changed_data, have_size, have_comp_size;

+ zip_flags_t stat_flags;

+ zip_int64_t data_len;

+ bool take_ownership = false;

+ if (srcza == NULL || srcidx >= srcza->nentry || len < -1) {

+ if (flags & ZIP_FL_ENCRYPTED) {

+ flags |= ZIP_FL_COMPRESSED;

+ changed_data = false;

+ if ((flags & ZIP_FL_UNCHANGED) == 0) {

+ zip_entry_t *entry = srcza->entry + srcidx;

+ if (ZIP_ENTRY_DATA_CHANGED(entry)) {

+ if ((flags & ZIP_FL_COMPRESSED) || !zip_source_supports_reopen(entry->source)) {

+ zip_error_set(error, ZIP_ER_CHANGED, 0);

+ return NULL;

+ }

+

+ changed_data = true;

+ }

+ else if (entry->deleted) {

+ zip_error_set(error, ZIP_ER_CHANGED, 0);

+ return NULL;

+ }

+ stat_flags = flags;

+ if (!changed_data) {

+ stat_flags |= ZIP_FL_UNCHANGED;

+ }

+

+ if (zip_stat_index(srcza, srcidx, stat_flags, &st) < 0) {

+ zip_error_set(error, ZIP_ER_INTERNAL, 0);

+ return NULL;

+ if ((start > 0 || len >= 0) && (flags & ZIP_FL_COMPRESSED)) {

+ have_size = (st.valid & ZIP_STAT_SIZE) != 0;

+ if (len >= 0 && ((start > 0 && start + len < start) || (have_size && start + len > st.size))) {

+ if (len == -1) {

+ if (have_size) {

+ if (st.size - start > ZIP_INT64_MAX) {

+ zip_error_set(error, ZIP_ER_INVAL, 0);

+ return NULL;

+ }

+ data_len = (zip_int64_t)(st.size - start);

+ }

+ else {

+ data_len = -1;

+ }

+ }

+ else {

+ data_len = len;

+ if (have_size) {

+ partial_data = (zip_uint64_t)(data_len) < st.size;

+ }

+ else {

+ partial_data = true;

+ }

+ encrypted = (st.valid & ZIP_STAT_ENCRYPTION_METHOD) && (st.encryption_method != ZIP_EM_NONE);

+ needs_decrypt = ((flags & ZIP_FL_ENCRYPTED) == 0) && encrypted;

+ compressed = (st.valid & ZIP_STAT_COMP_METHOD) && (st.comp_method != ZIP_CM_STORE);

+ needs_decompress = ((flags & ZIP_FL_COMPRESSED) == 0) && compressed;

+ needs_crc = ((flags & ZIP_FL_COMPRESSED) == 0 || !compressed) && !partial_data && (st.valid & ZIP_STAT_CRC) != 0;

+ have_comp_size = (st.valid & ZIP_STAT_COMP_SIZE) != 0;

+ if (compressed) {

+ if (have_comp_size && st.comp_size == 0) {

+ src = zip_source_buffer_with_attributes_create(NULL, 0, 0, &attributes, error);

+ }

+ else {

+ src = NULL;

+ }

+ else if (have_size && st.size == 0) {

+ src = zip_source_buffer_with_attributes_create(NULL, 0, 0, &attributes, error);

+ }

+ else {

+ src = NULL;

+ }

+

+

+ /* If we created source buffer above, we want the window source to take ownership of it. */

+ take_ownership = src != NULL;

+ /* if we created a buffer source above, then treat it as if

+ reading the changed data - that way we don't need add another

+ special case to the code below that wraps it in the window

+ source */

+ changed_data = changed_data || (src != NULL);

+ zip_t *source_archive;

+ zip_uint64_t source_index;

+

+ if (changed_data) {

+ if (src == NULL) {

+ src = srcza->entry[srcidx].source;

+ }

+ source_archive = NULL;

+ source_index = 0;

+ }

+ else {

+ src = srcza->src;

+ source_archive = srcza;

+ source_index = srcidx;

+ }

+ st2.valid = ZIP_STAT_COMP_METHOD;

+ if (data_len >= 0) {

+ st2.size = (zip_uint64_t)data_len;

+ st2.comp_size = (zip_uint64_t)data_len;

+ st2.valid |= ZIP_STAT_SIZE | ZIP_STAT_COMP_SIZE;

+ }

+ if (st.valid & ZIP_STAT_MTIME) {

+ st2.mtime = st.mtime;

+ st2.valid |= ZIP_STAT_MTIME;

+ }

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

+ /* here we restrict src to file data, so no point in doing it for

+ source that already represents only the file data */

+ else if (!changed_data) {

+ /* this branch is executed only for archive sources; we know

+ that stat data come from the archive too, so it's safe to

+ assume that st has a comp_size specified */

+ /* despite the fact that we want the whole data file, we still

+ wrap the source into a window source to add st and

+ attributes and to have a source that positions the read

+ offset properly before each read for multiple zip_file_t

+ referring to the same underlying source */

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

+ else {

+ /* this branch gets executed when reading the whole changed

+ data file or when "reading" from a zero-sized source buffer

+ that we created above */

+ if (src == NULL) {

+ src = srcza->entry[srcidx].source;

+ }

+ /* despite the fact that we want the whole data file, we still

+ wrap the source into a window source to add st and

+ attributes and to have a source that positions the read

+ offset properly before each read for multiple zip_file_t

+ referring to the same underlying source */

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

+ return NULL;

+ }

+ }

+

+ /* In all cases, src is a window source and therefore is owned by this function. */

+ zip_source_free(src);

+

+ zip_source_free(src);

+ zip_source_free(src);

+ zip_stat_t st2;

+ zip_stat_init(&st2);

+ if (data_len >= 0) {

+ st2.valid = ZIP_STAT_SIZE;

+ st2.size = (zip_uint64_t)data_len;

+ }

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

+ zip_source_free(src);

+ zip_entry_t *entry;

+ if ((de = _zip_get_dirent(za, index, flags, NULL)) == NULL) {

+ }

+ if ((name = zip_get_name(za, index, flags)) == NULL) {

+ }

+ entry = za->entry + index;

+ if (ZIP_CM_IS_DEFAULT(de->comp_method)) {

+ if (!(st->valid & ZIP_STAT_COMP_METHOD) || st->comp_method == ZIP_CM_STORE) {

+ st->valid &= ~(ZIP_STAT_COMP_SIZE|ZIP_STAT_COMP_METHOD);

+ }

+ }

+ else {

+ if ((st->valid & ZIP_STAT_COMP_METHOD) && st->comp_method != de->comp_method) {

+ st->valid &= ~ZIP_STAT_COMP_SIZE;

+ }

+ st->valid |= ZIP_STAT_COMP_METHOD;

+ st->comp_method = de->comp_method;

+ }

+

+ if (((st->valid & (ZIP_STAT_COMP_METHOD|ZIP_STAT_SIZE)) == (ZIP_STAT_COMP_METHOD|ZIP_STAT_SIZE)) && st->comp_method == ZIP_CM_STORE) {

+ st->valid |= ZIP_STAT_COMP_SIZE;

+ st->comp_size = st->size;

+ }

+

+ if (entry->changes != NULL && entry->changes->changed & ZIP_DIRENT_COMP_METHOD) {

+ st->valid &= ~ZIP_STAT_COMP_SIZE;

+ }

+ }

+

+ if ((za->ch_flags & ZIP_AFL_WANT_TORRENTZIP) && (flags & ZIP_FL_UNCHANGED) == 0) {

+ st->comp_method = ZIP_CM_DEFLATE;

+ st->mtime = _zip_d2u_time(0xbc00, 0x2198);

+ st->valid |= ZIP_STAT_MTIME | ZIP_STAT_COMP_METHOD;

+ st->valid &= ~ZIP_STAT_COMP_SIZE;

+ (void)memcpy_s(s->raw, length + 1, raw, length);

+ (void)memcpy_s(password_verify, WINZIP_AES_PASSWORD_VERIFY_LENGTH, buffer + (2 * key_size / 8), WINZIP_AES_PASSWORD_VERIFY_LENGTH);

+#define LIBZIP_VERSION "1.10.0"

+#define LIBZIP_VERSION_MINOR 10

+#define LIBZIP_VERSION_MICRO 0

+#ifdef _ZIP_COMPILING_DEPRECATED

+#define ZIP_DEPRECATED(x)

+#else

+#define TORRENTZIP_SIGNATURE "TORRENTZIPPED-"

+#define TORRENTZIP_SIGNATURE_LENGTH 14

+#define TORRENTZIP_CRC_LENGTH 8

+#define TORRENTZIP_MEM_LEVEL 8

+#define TORRENTZIP_COMPRESSION_FLAGS ZIP_UINT16_MAX

+

+ void *(*allocate)(zip_uint16_t method, zip_uint32_t compression_flags, zip_error_t *error);

+zip_source_t *zip_source_compress(zip_t *za, zip_source_t *src, zip_int32_t cm, zip_uint32_t compression_flags);

+bool zip_source_supports_reopen(zip_source_t *src);

+

+ zip_uint32_t* write_crc; /* have _zip_write() compute CRC */

+ zip_uint32_t compression_level; /* level of compression to use (never valid in orig) */

+ const char *name;

+#define ZIP_IS_TORRENTZIP(za) ((za)->flags & ZIP_AFL_IS_TORRENTZIP)

+#define ZIP_WANT_TORRENTZIP(za) ((za)->ch_flags & ZIP_AFL_WANT_TORRENTZIP)

+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);

+void zip_dirent_torrentzip_normalize(zip_dirent_t *de);

+

+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_t *source_archive, zip_uint64_t source_index, bool take_ownership, zip_error_t *error);