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

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

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

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

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

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

+ <Filter>libzip</Filter>

+ </ClCompile>

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

+ <Filter>libzip</Filter>

+ </ClCompile>

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

+ <Filter>libzip</Filter>

+ </ClCompile>

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

+ <Filter>libzip</Filter>

+ </ClCompile>

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

+ <Filter>libzip</Filter>

+ </ClCompile>

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

+1.5.0 [2018-03-11]

+==================

+

+* Use standard cryptographic library instead of custom AES implementation.

+ This also simplifies the license.

+* Use `clang-format` to format the source code.

+* More Windows improvements.

+

+1.4.0 [2017-12-29]

+==================

+

+* Improve build with cmake

+* Retire autoconf/automake build system

+* Add `zip_source_buffer_fragment()`.

+* Add support to clone unchanged beginning of archive (instead of rewriting it).

+ Supported for buffer sources and on Apple File System.

+* Add support for Microsoft Universal Windows Platform.

+

+1.3.2 [2017-11-20]

+==================

+* Fix bug introduced in last: zip_t was erroneously freed if zip_close() failed.

+

+1.3.1 [2017-11-19]

+==================

+

+* Install zipconf.h into ${PREFIX}/include

+* Add zip_libzip_version()

+* Fix AES tests on Linux

+

+1.3.0 [2017-09-02]

+==================

+

+* Support bzip2 compressed zip archives

+* Improve file progress callback code

+* Fix zip_fdopen()

+* CVE-2017-12858: Fix double free()

+* CVE-2017-14107: Improve EOCD64 parsing

+

+ and decryption

+* Support legacy zip files with >64k entries

+* Fix seeking in zip_source_file if start > 0

+* Add zip_fseek() for seeking in uncompressed data

+* Add zip_ftell() for telling position in uncompressed data

+* Fix build on Windows when using autoconf

+* Build fixes for Windows

+* Implemented an I/O abstraction layer

+* Added support for native Windows API for files

+* Added support for setting the last modification time for a file

+* Added a new type zip_error_t for errors

+* Added more typedefs for structs

+* Torrentzip support was removed

+* CVE-2015-2331 was fixed

+* Addressed all Coverity CIDs

+* Support querying/setting operating system and external attributes

+ to 0666 (0777 for directories)

+* Fix bug when writing zip archives containing files bigger than 4GB

+* Fix bugs in zip_set_file_compression()

+* Include Xcode build infrastructure

+* Added zip_get_num_entries(), deprecated zip_get_num_files()

+* Better windows support

+* Support for traditional PKWARE encryption added

+* Fix opening archives with more than 65535 entries

+* Fix some memory leaks

+* More documentation

+* Include m4/ directory in distribution; some packagers need it

+* Avoid passing uninitialized data to deflate()

+* Fix memory leak when closing zip archives

+* Fix infinite loop on reading some broken files

+* Optimization in time conversion (don't call localtime())

+* Clear data descriptor flag in central directory, fixing Open Office files

+* Allow more than 64k entries

+* added functions for reading and writing file and archive comments

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

+

+#include "zipconf.h"

+

+#ifndef ZIP_EXTERN

+#ifndef ZIP_STATIC

+#else

+#define ZIP_EXTERN

+#endif

+#ifndef __cplusplus

+#define true 1

+#define false 0

+#endif

+#if defined(HAVE__CHMOD)

+#define chmod _chmod

+#endif

+#define close _close

+#define dup _dup

+#define fdopen _fdopen

+#define fileno _fileno

+#define open(a, b, c) _open((a), (b))

+#define snprintf _snprintf

+#define strdup _strdup

+#define _setmode setmode

+#define strtoll _strtoi64

+#define strtoull _strtoui64

+#endif

+#if defined(HAVE__UMASK)

+#define umask _umask

+#endif

+#if defined(HAVE__UNLINK)

+#define unlink _unlink

+#define fseeko(s, o, w) (fseek((s), (long int)(o), (w)))

+#define ftello(s) ((long)ftell((s)))

+#define strcasecmp _stricmp

+#define strcasecmp stricmp

+#define S_ISDIR(mode) (((mode)&S_IFMT) == S_IFDIR)

+#define HAVE__CHMOD

+#define HAVE__UMASK

+#define HAVE__UNLINK

+/* #undef HAVE_CLONEFILE */

+/* #undef HAVE_COMMONCRYPTO */

+/* #undef HAVE_CRYPTO */

+/* #undef HAVE_FICLONERANGE */

+/* #undef HAVE_GNUTLS */

+/* #undef HAVE_LIBBZ2 */

+/* #undef HAVE_OPENSSL */

+#define SHORT_LIBZIP 2

+#define INT_LIBZIP 4

+#define LONG_LIBZIP 4

+#define LONG_LONG_LIBZIP 8

+/* #undef HAVE_FTS_H */

+#define HAVE_SHARED

+#define VERSION "1.5.0a"

+#include <sys/types.h>

+#include <process.h>

+#else

+#include <unistd.h>

+_zip_mkstemp(char *path) {

+ int ret;

+ ret = _creat(_mktemp(path), _S_IREAD | _S_IWRITE);

+ if (ret == -1) {

+ return 0;

+ }

+ else {

+ return ret;

+ }

+ int fd;

+ char *start, *trv;

+ struct stat sbuf;

+ pid_t pid;

+

+ /* To guarantee multiple calls generate unique names even if

+ the file is not created. 676 different possibilities with 7

+ or more X's, 26 with 6 or less. */

+ static char xtra[2] = "aa";

+ int xcnt = 0;

+

+ pid = getpid();

+

+ /* Move to end of path and count trailing X's. */

+ for (trv = path; *trv; ++trv)

+ if (*trv == 'X')

+ xcnt++;

+ else

+ xcnt = 0;

+

+ /* Use at least one from xtra. Use 2 if more than 6 X's. */

+ if (*(trv - 1) == 'X')

+ *--trv = xtra[0];

+ if (xcnt > 6 && *(trv - 1) == 'X')

+ *--trv = xtra[1];

+

+ /* Set remaining X's to pid digits with 0's to the left. */

+ while (*--trv == 'X') {

+ *trv = (pid % 10) + '0';

+ pid /= 10;

+ }

+

+ /* update xtra for next call. */

+ if (xtra[0] != 'z')

+ xtra[0]++;

+ else {

+ xtra[0] = 'a';

+ if (xtra[1] != 'z')

+ xtra[1]++;

+ else

+ xtra[1] = 'a';

+ }

+

+ /*

+ * check the target directory; if you have six X's and it

+ * doesn't exist this runs for a *very* long time.

+ */

+ for (start = trv + 1;; --trv) {

+ if (trv <= path)

+ break;

+ if (*trv == '/') {

+ *trv = '\0';

+ if (stat(path, &sbuf))

+ return (0);

+ if (!S_ISDIR(sbuf.st_mode)) {

+ errno = ENOTDIR;

+ return (0);

+ }

+ *trv = '/';

+ break;

+ }

+

+ for (;;) {

+ if ((fd = open(path, O_CREAT | O_EXCL | O_RDWR | O_BINARY, 0600)) >= 0)

+ return (fd);

+ if (errno != EEXIST)

+ return (0);

+

+ /* tricky little algorithm for backward compatibility */

+ for (trv = start;;) {

+ if (!*trv)

+ return (0);

+ if (*trv == 'z')

+ *trv++ = 'a';

+ else {

+ if (isdigit((unsigned char)*trv))

+ *trv = 'a';

+ ++*trv;

+ break;

+ }

+ }

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

+#ifndef ZIP_EXTERN

+#ifndef ZIP_STATIC

+#ifdef _WIN32

+#define ZIP_EXTERN __declspec(dllimport)

+#elif defined(__GNUC__) && __GNUC__ >= 4

+#define ZIP_EXTERN __attribute__((visibility("default")))

+#else

+#define ZIP_EXTERN

+#endif

+#else

+#define ZIP_EXTERN

+#endif

+#endif

+

+#include <sys/types.h>

+#define ZIP_CREATE 1

+#define ZIP_EXCL 2

+#define ZIP_CHECKCONS 4

+#define ZIP_TRUNCATE 8

+#define ZIP_RDONLY 16

+#define ZIP_FL_NOCASE 1u /* ignore case on name lookup */

+#define ZIP_FL_NODIR 2u /* ignore directory component */

+#define ZIP_FL_COMPRESSED 4u /* read compressed data */

+#define ZIP_FL_UNCHANGED 8u /* use original data, ignoring changes */

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

+#define ZIP_FL_ENCRYPTED 32u /* read encrypted data (implies ZIP_FL_COMPRESSED) */

+#define ZIP_FL_ENC_GUESS 0u /* guess string encoding (is default) */

+#define ZIP_FL_ENC_RAW 64u /* get unmodified string */

+#define ZIP_FL_ENC_STRICT 128u /* follow specification strictly */

+#define ZIP_FL_LOCAL 256u /* in local header */

+#define ZIP_FL_CENTRAL 512u /* in central directory */

+#define ZIP_FL_ENC_UTF_8 2048u /* string is UTF-8 encoded */

+#define ZIP_FL_ENC_CP437 4096u /* string is CP437 encoded */

+#define ZIP_FL_OVERWRITE 8192u /* zip_file_add: if file with name exists, overwrite (replace) it */

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

+#define ZIP_EXTRA_FIELD_ALL ZIP_UINT16_MAX

+#define ZIP_EXTRA_FIELD_NEW ZIP_UINT16_MAX

+#define ZIP_ER_OK 0 /* N No error */

+#define ZIP_ER_MULTIDISK 1 /* N Multi-disk zip archives not supported */

+#define ZIP_ER_RENAME 2 /* S Renaming temporary file failed */

+#define ZIP_ER_CLOSE 3 /* S Closing zip archive failed */

+#define ZIP_ER_SEEK 4 /* S Seek error */

+#define ZIP_ER_READ 5 /* S Read error */

+#define ZIP_ER_WRITE 6 /* S Write error */

+#define ZIP_ER_CRC 7 /* N CRC error */

+#define ZIP_ER_ZIPCLOSED 8 /* N Containing zip archive was closed */

+#define ZIP_ER_NOENT 9 /* N No such file */

+#define ZIP_ER_EXISTS 10 /* N File already exists */

+#define ZIP_ER_OPEN 11 /* S Can't open file */

+#define ZIP_ER_TMPOPEN 12 /* S Failure to create temporary file */

+#define ZIP_ER_ZLIB 13 /* Z Zlib error */

+#define ZIP_ER_MEMORY 14 /* N Malloc failure */

+#define ZIP_ER_CHANGED 15 /* N Entry has been changed */

+#define ZIP_ER_COMPNOTSUPP 16 /* N Compression method not supported */

+#define ZIP_ER_EOF 17 /* N Premature end of file */

+#define ZIP_ER_INVAL 18 /* N Invalid argument */

+#define ZIP_ER_NOZIP 19 /* N Not a zip archive */

+#define ZIP_ER_INTERNAL 20 /* N Internal error */

+#define ZIP_ER_INCONS 21 /* N Zip archive inconsistent */

+#define ZIP_ER_REMOVE 22 /* S Can't remove file */

+#define ZIP_ER_DELETED 23 /* N Entry has been deleted */

+#define ZIP_ER_ENCRNOTSUPP 24 /* N Encryption method not supported */

+#define ZIP_ER_RDONLY 25 /* N Read-only archive */

+#define ZIP_ER_NOPASSWD 26 /* N No password provided */

+#define ZIP_ER_WRONGPASSWD 27 /* N Wrong password provided */

+#define ZIP_ER_OPNOTSUPP 28 /* N Operation not supported */

+#define ZIP_ER_INUSE 29 /* N Resource still in use */

+#define ZIP_ER_TELL 30 /* S Tell error */

+#define ZIP_ER_COMPRESSED_DATA 31 /* N Compressed data invalid */

+#define ZIP_ET_NONE 0 /* sys_err unused */

+#define ZIP_ET_SYS 1 /* sys_err is errno */

+#define ZIP_ET_ZLIB 2 /* sys_err is zlib error code */

+#define ZIP_CM_DEFAULT -1 /* better of deflate or store */

+#define ZIP_CM_STORE 0 /* stored (uncompressed) */

+#define ZIP_CM_SHRINK 1 /* shrunk */

+#define ZIP_CM_REDUCE_1 2 /* reduced with factor 1 */

+#define ZIP_CM_REDUCE_2 3 /* reduced with factor 2 */

+#define ZIP_CM_REDUCE_3 4 /* reduced with factor 3 */

+#define ZIP_CM_REDUCE_4 5 /* reduced with factor 4 */

+#define ZIP_CM_IMPLODE 6 /* imploded */

+#define ZIP_CM_DEFLATE 8 /* deflated */

+#define ZIP_CM_DEFLATE64 9 /* deflate64 */

+#define ZIP_CM_PKWARE_IMPLODE 10 /* PKWARE imploding */

+#define ZIP_CM_BZIP2 12 /* compressed using BZIP2 algorithm */

+#define ZIP_CM_LZMA 14 /* LZMA (EFS) */

+#define ZIP_CM_TERSE 18 /* compressed using IBM TERSE (new) */

+#define ZIP_CM_LZ77 19 /* IBM LZ77 z Architecture (PFS) */

+#define ZIP_CM_XZ 95 /* XZ compressed data */

+#define ZIP_CM_JPEG 96 /* Compressed Jpeg data */

+#define ZIP_CM_WAVPACK 97 /* WavPack compressed data */

+#define ZIP_CM_PPMD 98 /* PPMd version I, Rev 1 */

+#define ZIP_EM_NONE 0 /* not encrypted */

+#define ZIP_EM_TRAD_PKWARE 1 /* traditional PKWARE encryption */

+#if 0 /* Strong Encryption Header not parsed yet */

+#define ZIP_EM_DES 0x6601 /* strong encryption: DES */

+#define ZIP_EM_RC2_OLD 0x6602 /* strong encryption: RC2, version < 5.2 */

+#define ZIP_EM_3DES_168 0x6603

+#define ZIP_EM_3DES_112 0x6609

+#define ZIP_EM_PKZIP_AES_128 0x660e

+#define ZIP_EM_PKZIP_AES_192 0x660f

+#define ZIP_EM_PKZIP_AES_256 0x6610

+#define ZIP_EM_RC2 0x6702 /* strong encryption: RC2, version >= 5.2 */

+#define ZIP_EM_RC4 0x6801

+#define ZIP_EM_AES_128 0x0101 /* Winzip AES encryption */

+#define ZIP_EM_AES_192 0x0102

+#define ZIP_EM_AES_256 0x0103

+#define ZIP_EM_UNKNOWN 0xffff /* unknown algorithm */

+

+#define ZIP_OPSYS_DOS 0x00u

+#define ZIP_OPSYS_AMIGA 0x01u

+#define ZIP_OPSYS_OPENVMS 0x02u

+#define ZIP_OPSYS_UNIX 0x03u

+#define ZIP_OPSYS_VM_CMS 0x04u

+#define ZIP_OPSYS_ATARI_ST 0x05u

+#define ZIP_OPSYS_OS_2 0x06u

+#define ZIP_OPSYS_MACINTOSH 0x07u

+#define ZIP_OPSYS_Z_SYSTEM 0x08u

+#define ZIP_OPSYS_CPM 0x09u

+#define ZIP_OPSYS_WINDOWS_NTFS 0x0au

+#define ZIP_OPSYS_MVS 0x0bu

+#define ZIP_OPSYS_VSE 0x0cu

+#define ZIP_OPSYS_ACORN_RISC 0x0du

+#define ZIP_OPSYS_VFAT 0x0eu

+#define ZIP_OPSYS_ALTERNATE_MVS 0x0fu

+#define ZIP_OPSYS_BEOS 0x10u

+#define ZIP_OPSYS_TANDEM 0x11u

+#define ZIP_OPSYS_OS_400 0x12u

+#define ZIP_OPSYS_OS_X 0x13u

+

+#define ZIP_OPSYS_DEFAULT ZIP_OPSYS_UNIX

+ ZIP_SOURCE_OPEN, /* prepare for reading */

+ ZIP_SOURCE_READ, /* read data */

+ ZIP_SOURCE_CLOSE, /* reading is done */

+ ZIP_SOURCE_STAT, /* get meta information */

+ ZIP_SOURCE_ERROR, /* get error information */

+ ZIP_SOURCE_FREE, /* cleanup and free resources */

+ ZIP_SOURCE_SEEK, /* set position for reading */

+ ZIP_SOURCE_TELL, /* get read position */

+ ZIP_SOURCE_BEGIN_WRITE, /* prepare for writing */

+ ZIP_SOURCE_COMMIT_WRITE, /* writing is done */

+ ZIP_SOURCE_ROLLBACK_WRITE, /* discard written changes */

+ ZIP_SOURCE_WRITE, /* write data */

+ ZIP_SOURCE_SEEK_WRITE, /* set position for writing */

+ ZIP_SOURCE_TELL_WRITE, /* get write position */

+ ZIP_SOURCE_SUPPORTS, /* check whether source supports command */

+ ZIP_SOURCE_REMOVE, /* remove file */

+ ZIP_SOURCE_GET_COMPRESSION_FLAGS, /* get compression flags, internal only */

+ ZIP_SOURCE_BEGIN_WRITE_CLONING /* like ZIP_SOURCE_BEGIN_WRITE, but keep part of original file */

+#define ZIP_SOURCE_MAKE_COMMAND_BITMASK(cmd) (((zip_int64_t)1) << (cmd))

+

+// clang-format off

+// clang-format on

+

+ int zip_err; /* libzip error code (ZIP_ER_*) */

+ int sys_err; /* copy of errno (E*) or zlib error code */

+ char *str; /* string representation or NULL */

+#define ZIP_STAT_NAME 0x0001u

+#define ZIP_STAT_INDEX 0x0002u

+#define ZIP_STAT_SIZE 0x0004u

+#define ZIP_STAT_COMP_SIZE 0x0008u

+#define ZIP_STAT_MTIME 0x0010u

+#define ZIP_STAT_CRC 0x0020u

+#define ZIP_STAT_COMP_METHOD 0x0040u

+#define ZIP_STAT_ENCRYPTION_METHOD 0x0080u

+#define ZIP_STAT_FLAGS 0x0100u

+ zip_uint64_t valid; /* which fields have valid values */

+ const char *name; /* name of the file */

+ zip_uint64_t index; /* index within archive */

+ zip_uint64_t size; /* size of file (uncompressed) */

+ zip_uint64_t comp_size; /* size of file (compressed) */

+ time_t mtime; /* modification time */

+ zip_uint32_t crc; /* crc of file data */

+ zip_uint16_t comp_method; /* compression method used */

+ zip_uint16_t encryption_method; /* encryption method used */

+ zip_uint32_t flags; /* reserved for future use */

+};

+

+struct zip_buffer_fragment {

+ zip_uint8_t *data;

+ zip_uint64_t length;

+typedef struct zip_buffer_fragment zip_buffer_fragment_t;

+typedef void (*zip_progress_callback)(zip_t *, double, void *);

+typedef void (*zip_progress_callback_t)(double);

+ZIP_EXTERN void zip_register_progress_callback(zip_t *, zip_progress_callback_t); /* use zip_register_progress_callback_with_state */

+

+ZIP_EXTERN zip_int64_t zip_add(zip_t *, const char *, zip_source_t *); /* use zip_file_add */

+ZIP_EXTERN zip_int64_t zip_add_dir(zip_t *, const char *); /* use zip_dir_add */

+ZIP_EXTERN int zip_get_num_files(zip_t *); /* use zip_get_num_entries instead */

+ZIP_EXTERN int zip_rename(zip_t *, zip_uint64_t, const char *); /* use zip_file_rename */

+ZIP_EXTERN int zip_replace(zip_t *, zip_uint64_t, zip_source_t *); /* use zip_file_replace */

+ZIP_EXTERN int zip_set_file_comment(zip_t *, zip_uint64_t, const char *, int); /* use zip_file_set_comment */

+ZIP_EXTERN int zip_error_get_sys_type(int); /* use zip_error_system_type */

+ZIP_EXTERN void zip_error_get(zip_t *, int *, int *); /* use zip_get_error, zip_error_code_zip / zip_error_code_system */

+ZIP_EXTERN int zip_error_to_str(char *, zip_uint64_t, int, int); /* use zip_error_init_with_code / zip_error_strerror */

+ZIP_EXTERN void zip_file_error_get(zip_file_t *, int *, int *); /* use zip_file_get_error, zip_error_code_zip / zip_error_code_system */

+ZIP_EXTERN const char *zip_libzip_version(void);

+ZIP_EXTERN int zip_register_progress_callback_with_state(zip_t *, double, zip_progress_callback, void (*)(void *), void *);

+ZIP_EXTERN int zip_source_begin_write_cloning(zip_source_t *, zip_uint64_t);

+ZIP_EXTERN zip_source_t *zip_source_buffer_fragment(zip_t *, const zip_buffer_fragment_t *, zip_uint64_t, int);

+ZIP_EXTERN zip_source_t *zip_source_buffer_fragment_create(const zip_buffer_fragment_t *, zip_uint64_t, int, zip_error_t *);

+

+ The index can not be larger than ZIP_INT64_MAX since the size

+ of the central directory cannot be larger than

+ ZIP_UINT64_MAX, and each entry is larger than 2 bytes.

+zip_add(zip_t *za, const char *name, zip_source_t *source) {

+

+zip_add_dir(zip_t *za, const char *name) {

+

+_zip_add_entry(zip_t *za) {

+ if (za->nentry + 1 >= za->nentry_alloc) {

+ _zip_entry_init(za->entry + idx);

+/*

+ zip_algorithm_deflate.c -- deflate (de)compression routines

+ Copyright (C) 2017 Dieter Baron and Thomas Klausner

+

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

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

+

+ 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"

+

+#include <limits.h>

+#include <stdlib.h>

+#include <zlib.h>

+

+struct ctx {

+ zip_error_t *error;

+ bool compress;

+ int compression_flags;

+ bool end_of_input;

+ z_stream zstr;

+};

+

+

+static void *

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

+ struct ctx *ctx;

+

+ if ((ctx = (struct ctx *)malloc(sizeof(*ctx))) == NULL) {

+ return NULL;

+ }

+

+ ctx->error = error;

+ ctx->compress = compress;

+ ctx->compression_flags = compression_flags;

+ if (ctx->compression_flags < 1 || ctx->compression_flags > 9) {

+ ctx->compression_flags = Z_BEST_COMPRESSION;

+ }

+ ctx->end_of_input = false;

+

+ ctx->zstr.zalloc = Z_NULL;

+ ctx->zstr.zfree = Z_NULL;

+ ctx->zstr.opaque = NULL;

+

+ return ctx;

+}

+

+

+static void *

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

+ return allocate(true, compression_flags, error);

+}

+

+

+static void *

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

+ return allocate(false, compression_flags, error);

+}

+

+

+static void

+deallocate(void *ud) {

+ struct ctx *ctx = (struct ctx *)ud;

+

+ free(ctx);

+}

+

+

+static int

+compression_flags(void *ud) {

+ struct ctx *ctx = (struct ctx *)ud;

+

+ if (!ctx->compress) {

+ return 0;

+ }

+

+ if (ctx->compression_flags < 3) {

+ return 2;

+ }

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

+ return 1;

+ }

+ return 0;

+}

+

+

+static bool

+start(void *ud) {

+ struct ctx *ctx = (struct ctx *)ud;

+ int ret;

+

+ ctx->zstr.avail_in = 0;

+ ctx->zstr.next_in = NULL;

+ ctx->zstr.avail_out = 0;

+ ctx->zstr.next_out = NULL;

+

+ if (ctx->compress) {

+ /* negative value to tell zlib not to write a header */

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

+ }

+ else {

+ ret = inflateInit2(&ctx->zstr, -MAX_WBITS);

+ }

+

+ if (ret != Z_OK) {

+ zip_error_set(ctx->error, ZIP_ER_ZLIB, ret);

+ return false;

+ }

+

+

+ return true;

+}

+

+

+static bool

+end(void *ud) {

+ struct ctx *ctx = (struct ctx *)ud;

+ int err;

+

+ if (ctx->compress) {

+ err = deflateEnd(&ctx->zstr);

+ }

+ else {

+ err = inflateEnd(&ctx->zstr);

+ }

+

+ if (err != Z_OK) {

+ zip_error_set(ctx->error, ZIP_ER_ZLIB, err);

+ return false;

+ }

+

+ return true;

+}

+

+

+static bool

+input(void *ud, zip_uint8_t *data, zip_uint64_t length) {

+ struct ctx *ctx = (struct ctx *)ud;

+

+ if (length > UINT_MAX || ctx->zstr.avail_in > 0) {

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

+ return false;

+ }

+

+ ctx->zstr.avail_in = (uInt)length;

+ ctx->zstr.next_in = (Bytef *)data;

+

+ return true;

+}

+

+

+static void

+end_of_input(void *ud) {

+ struct ctx *ctx = (struct ctx *)ud;

+

+ ctx->end_of_input = true;

+}

+

+

+static zip_compression_status_t

+process(void *ud, zip_uint8_t *data, zip_uint64_t *length) {

+ struct ctx *ctx = (struct ctx *)ud;

+

+ int ret;

+

+ ctx->zstr.avail_out = (uInt)ZIP_MIN(UINT_MAX, *length);

+ ctx->zstr.next_out = (Bytef *)data;

+

+ if (ctx->compress) {

+ ret = deflate(&ctx->zstr, ctx->end_of_input ? Z_FINISH : 0);

+ }

+ else {

+ ret = inflate(&ctx->zstr, Z_SYNC_FLUSH);

+ }

+

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

+

+ switch (ret) {

+ case Z_OK:

+ return ZIP_COMPRESSION_OK;

+

+ case Z_STREAM_END:

+ return ZIP_COMPRESSION_END;

+

+ case Z_BUF_ERROR:

+ if (ctx->zstr.avail_in == 0) {

+ return ZIP_COMPRESSION_NEED_DATA;

+ }

+

+ /* fallthrough */

+

+ default:

+ zip_error_set(ctx->error, ZIP_ER_ZLIB, ret);

+ return ZIP_COMPRESSION_ERROR;

+ }

+}

+

+// clang-format off

+

+zip_compression_algorithm_t zip_algorithm_deflate_compress = {

+ compress_allocate,

+ deallocate,

+ compression_flags,

+ start,

+ end,

+ input,

+ end_of_input,

+ process

+};

+

+

+zip_compression_algorithm_t zip_algorithm_deflate_decompress = {

+ decompress_allocate,

+ deallocate,

+ compression_flags,

+ start,

+ end,

+ input,

+ end_of_input,

+ process

+};

+

+// clang-format on

+_zip_buffer_data(zip_buffer_t *buffer) {

+_zip_buffer_free(zip_buffer_t *buffer) {

+ return;

+ free(buffer->data);

+_zip_buffer_eof(zip_buffer_t *buffer) {

+_zip_buffer_get(zip_buffer_t *buffer, zip_uint64_t length) {

+_zip_buffer_get_16(zip_buffer_t *buffer) {

+ return 0;

+_zip_buffer_get_32(zip_buffer_t *buffer) {

+ return 0;

+_zip_buffer_get_64(zip_buffer_t *buffer) {

+ return 0;

+_zip_buffer_get_8(zip_buffer_t *buffer) {

+ return 0;

+_zip_buffer_left(zip_buffer_t *buffer) {

+_zip_buffer_read(zip_buffer_t *buffer, zip_uint8_t *data, zip_uint64_t length) {

+_zip_buffer_new(zip_uint8_t *data, zip_uint64_t size) {

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

+ return NULL;

+ }

+ if (free_data) {

+ free(data);

+ }

+ return NULL;

+_zip_buffer_new_from_source(zip_source_t *src, zip_uint64_t size, zip_uint8_t *buf, zip_error_t *error) {

+ zip_error_set(error, ZIP_ER_MEMORY, 0);

+ return NULL;

+ _zip_buffer_free(buffer);

+ return NULL;

+_zip_buffer_offset(zip_buffer_t *buffer) {

+_zip_buffer_ok(zip_buffer_t *buffer) {

+_zip_buffer_peek(zip_buffer_t *buffer, zip_uint64_t length) {

+ buffer->ok = false;

+ return NULL;

+_zip_buffer_put(zip_buffer_t *buffer, const void *src, size_t length) {

+ return -1;

+_zip_buffer_put_16(zip_buffer_t *buffer, zip_uint16_t i) {

+ return -1;

+_zip_buffer_put_32(zip_buffer_t *buffer, zip_uint32_t i) {

+ return -1;

+_zip_buffer_put_64(zip_buffer_t *buffer, zip_uint64_t i) {

+ return -1;

+_zip_buffer_put_8(zip_buffer_t *buffer, zip_uint8_t i) {

+ return -1;

+_zip_buffer_set_offset(zip_buffer_t *buffer, zip_uint64_t offset) {

+ buffer->ok = false;

+ return -1;

+ buffer->ok = false;

+ return -1;

+_zip_buffer_size(zip_buffer_t *buffer) {

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

+

+#include <sys/types.h>

+#include <io.h>

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

+zip_close(zip_t *za) {

+ zip_uint64_t i, j, survivors, unchanged_offset;

+ }

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

+ return -1;

+

+ if ((filelist = (zip_filelist_t *)malloc(sizeof(filelist[0]) * (size_t)survivors)) == NULL)

+ unchanged_offset = ZIP_UINT64_MAX;

+ for (i = j = 0; i < za->nentry; i++) {

+ if (za->entry[i].orig != NULL && ZIP_ENTRY_HAS_CHANGES(&za->entry[i])) {

+ unchanged_offset = ZIP_MIN(unchanged_offset, za->entry[i].orig->offset);

+ }

+ if (za->entry[i].deleted) {

+ }

+

+ if (j >= survivors) {

+ free(filelist);

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

+ return -1;

+ }

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

+

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

+ unchanged_offset = 0;

+ }

+ else {

+ if (unchanged_offset == ZIP_UINT64_MAX) {

+ /* we're keeping all file data, find the end of the last one */

+ zip_uint64_t last_index = ZIP_UINT64_MAX;

+ unchanged_offset = 0;

+

+ for (i = 0; i < za->nentry; i++) {

+ if (za->entry[i].orig != NULL) {

+ if (za->entry[i].orig->offset >= unchanged_offset) {

+ unchanged_offset = za->entry[i].orig->offset;

+ last_index = i;

+ }

+ }

+ }

+ if (last_index != ZIP_UINT64_MAX) {

+ if ((unchanged_offset = _zip_file_get_end(za, last_index, &za->error)) == 0) {

+ free(filelist);

+ return -1;

+ }

+ }

+ }

+ if (unchanged_offset > 0) {

+ if (zip_source_begin_write_cloning(za->src, unchanged_offset) < 0) {

+ /* cloning not supported, need to copy everything */

+ unchanged_offset = 0;

+ }

+ }

+ }

+ if (unchanged_offset == 0) {

+ if (zip_source_begin_write(za->src) < 0) {

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

+ free(filelist);

+ return -1;

+ }

+ }

+

+ _zip_progress_start(za->progress);

+ for (j = 0; j < survivors; j++) {

+ _zip_progress_subrange(za->progress, (double)j / (double)survivors, (double)(j + 1) / (double)survivors);

+ entry = za->entry + i;

+

+ if (entry->orig != NULL && entry->orig->offset < unchanged_offset) {

+ /* already implicitly copied by cloning */

+ continue;

+ }

+ if ((entry->changes = _zip_dirent_clone(entry->orig)) == NULL) {

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

+ error = 1;

+ break;

+ if ((off = zip_source_tell_write(za->src)) < 0) {

+ error = 1;

+ break;

+ }

+ de->offset = (zip_uint64_t)off;

+ if ((zs = _zip_source_zip_new(za, za, i, ZIP_FL_UNCHANGED, 0, 0, NULL)) == NULL) {

+ if ((offset = _zip_file_get_offset(za, i, &za->error)) == 0) {

+ _zip_progress_end(za->progress);

+

+

+add_data(zip_t *za, zip_source_t *src, zip_dirent_t *de) {

+ zip_int64_t offstart, offdata, offend, data_length;

+ zip_int8_t compression_flags;

+

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

+ data_length = -1;

+ }

+ /* this is technically incorrect (copy_source counts compressed data), but it's the best we have */

+ data_length = (zip_int64_t)st.size;

+

+ zip_uint64_t max_size;

+

+ switch (ZIP_CM_ACTUAL(de->comp_method)) {

+ case ZIP_CM_BZIP2:

+ /* computed by looking at increase of 10 random files of size 1MB when

+ * compressed with bzip2, rounded up: 1.006 */

+ max_size = 4269351188u;

+ break;

+

+ case ZIP_CM_DEFLATE:

+ /* max deflate size increase: size + ceil(size/16k)*5+6 */

+ max_size = 4293656963u;

+ break;

+

+ case ZIP_CM_STORE:

+ max_size = 0xffffffffu;

+ break;

+

+ default:

+ max_size = 0;

+ }

+

+ if (st.size > max_size) {

+ }

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

+ return -1;

+ if ((is_zip64 = _zip_dirent_write(za, de, flags)) < 0) {

+ }

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

+

+

+ if ((src_tmp = zip_source_decompress(za, src_final, st.comp_method)) == NULL) {

+ if ((src_tmp = zip_source_compress(za, src_final, de->comp_method, de->compression_level)) == NULL) {

+

+

+ }

+ else if (za->default_password) {

+

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

+ return -1;

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

+

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

+ ret = -1;

+ }

+

+ if ((compression_flags = zip_source_get_compression_flags(src_final)) < 0) {

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

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

+ return -1;

+ if ((st.valid & (ZIP_STAT_COMP_METHOD | ZIP_STAT_CRC | ZIP_STAT_SIZE)) != (ZIP_STAT_COMP_METHOD | ZIP_STAT_CRC | ZIP_STAT_SIZE)) {

+ if (st.valid & ZIP_STAT_MTIME)

+ de->last_mod = st.mtime;

+ else

+ time(&de->last_mod);

+ de->bitflags = (zip_uint16_t)((de->bitflags & (zip_uint16_t)~6) | ((zip_uint8_t)compression_flags << 1));

+ _zip_dirent_set_version_needed(de, (flags & ZIP_FL_FORCE_ZIP64) != 0);

+ if ((ret = _zip_dirent_write(za, de, flags)) < 0)

+

+copy_data(zip_t *za, zip_uint64_t len) {

+ double total = (double)len;

+

+

+ _zip_progress_update(za->progress, (total - (double)len) / total);

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

+ zip_int64_t n, current;

+ current = 0;

+ while ((n = zip_source_read(src, buf, sizeof(buf))) > 0) {

+ if (n == sizeof(buf) && za->progress && data_length > 0) {

+ current += n;

+ _zip_progress_update(za->progress, (double)current / (double)data_length);

+ }

+

+

+write_cdir(zip_t *za, const zip_filelist_t *filelist, zip_uint64_t survivors) {

+

+ return -1;

+ if ((size = _zip_cdir_write(za, filelist, survivors)) < 0) {

+

+ return -1;

+_zip_changed(const zip_t *za, zip_uint64_t *survivorsp) {

+ if (za->comment_changed || za->ch_flags != za->flags) {

+ }

+ for (i = 0; i < za->nentry; i++) {

+ if (ZIP_ENTRY_HAS_CHANGES(&za->entry[i])) {

+ }

+ if (!za->entry[i].deleted) {

+ }

+ if (survivorsp) {

+ }

+

+zip_delete(zip_t *za, zip_uint64_t idx) {

+ if ((name = _zip_get_name(za, idx, 0, &za->error)) == NULL) {

+

+zip_dir_add(zip_t *za, const char *name, zip_flags_t flags) {

+ if (name[len - 1] != '/') {

+ if ((s = (char *)malloc(len + 2)) == NULL) {

+ s[len + 1] = '\0';

+ if ((source = zip_source_buffer(za, NULL, 0, 0)) == NULL) {

+

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

+#include <sys/types.h>

+_zip_cdir_free(zip_cdir_t *cd) {

+ for (i = 0; i < cd->nentry; i++)

+ _zip_entry_finalize(cd->entry + i);

+_zip_cdir_new(zip_uint64_t nentry, zip_error_t *error) {

+ if ((cd = (zip_cdir_t *)malloc(sizeof(*cd))) == NULL) {

+_zip_cdir_grow(zip_cdir_t *cd, zip_uint64_t additional_entries, zip_error_t *error) {

+ if (new_alloc < additional_entries || new_alloc > SIZE_MAX / sizeof(*(cd->entry))) {

+ if ((new_entry = (zip_entry_t *)realloc(cd->entry, sizeof(*(cd->entry)) * (size_t)new_alloc)) == NULL) {

+ _zip_entry_init(cd->entry + i);

+_zip_cdir_write(zip_t *za, const zip_filelist_t *filelist, zip_uint64_t survivors) {

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

+ return -1;

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

+ zip_entry_t *entry = za->entry + filelist[i].idx;

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

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

+ return -1;

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

+ return -1;

+ _zip_buffer_put_64(buffer, EOCD64LEN - 12);

+ _zip_buffer_put_64(buffer, offset + size);

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

+ _zip_buffer_free(buffer);

+ return -1;

+ _zip_buffer_free(buffer);

+_zip_dirent_clone(const zip_dirent_t *sde) {

+ if ((tde = (zip_dirent_t *)malloc(sizeof(*tde))) == NULL)

+_zip_dirent_finalize(zip_dirent_t *zde) {

+_zip_dirent_free(zip_dirent_t *zde) {

+_zip_dirent_init(zip_dirent_t *de) {

+ de->version_madeby = 63 | (ZIP_OPSYS_DEFAULT << 8);

+ de->version_needed = 10; /* 1.0 */

+ de->compression_level = 0;

+_zip_dirent_needs_zip64(const zip_dirent_t *de, zip_flags_t flags) {

+ if (de->uncomp_size >= ZIP_UINT32_MAX || de->comp_size >= ZIP_UINT32_MAX || ((flags & ZIP_FL_CENTRAL) && de->offset >= ZIP_UINT32_MAX))

+_zip_dirent_new(void) {

+ if ((de = (zip_dirent_t *)malloc(sizeof(*de))) == NULL)

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

+ if (_zip_buffer_left(buffer) < size) {

+ zip_error_set(error, ZIP_ER_NOZIP, 0);

+ return -1;

+ }

+ if ((buffer = _zip_buffer_new_from_source(src, size, buf, error)) == NULL) {

+ return -1;

+ }

+ if (!from_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ }

+ else {

+ zip_error_set(error, ZIP_ER_INTERNAL, 0);

+ if (!from_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ return -1;

+ variable_size = (zip_uint32_t)filename_len + (zip_uint32_t)ef_len + (zip_uint32_t)comment_len;

+ if (_zip_buffer_left(buffer) < variable_size) {

+ zip_error_set(error, ZIP_ER_INCONS, 0);

+ return -1;

+ }

+ _zip_buffer_free(buffer);

+ if ((buffer = _zip_buffer_new_from_source(src, variable_size, NULL, error)) == NULL) {

+ return -1;

+ }

+ if (!zde->filename) {

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

+ zip_error_set(error, ZIP_ER_INCONS, 0);

+ }

+ if (!from_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ }

+ if (!from_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ if (ef == NULL) {

+ if (!from_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ }

+ if (!_zip_ef_parse(ef, ef_len, local ? ZIP_EF_LOCAL : ZIP_EF_CENTRAL, &zde->extra_fields, error)) {

+ if (!from_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ if (!zde->comment) {

+ if (!from_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ }

+ if (!from_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ zip_buffer_t *ef_buffer;

+ if (ef == NULL) {

+ if (!from_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ }

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

+ zip_error_set(error, ZIP_ER_MEMORY, 0);

+ if (!from_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ return -1;

+ }

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

+ if (!_zip_buffer_eof(ef_buffer)) {

+ zip_error_set(error, ZIP_ER_INCONS, 0);

+ _zip_buffer_free(ef_buffer);

+ if (!from_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ return -1;

+ }

+ _zip_buffer_free(ef_buffer);

+ zip_error_set(error, ZIP_ER_INTERNAL, 0);

+ if (!from_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ return -1;

+ _zip_buffer_free(buffer);

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

+ return str;

+ zip_uint16_t len = (zip_uint16_t)_zip_buffer_left(buffer);

+ zip_string_t *ef_str = _zip_string_new(_zip_buffer_get(buffer, len), len, ZIP_FL_ENC_UTF_8, NULL);

+_zip_dirent_process_winzip_aes(zip_dirent_t *de, zip_error_t *error) {

+ return false;

+_zip_dirent_size(zip_source_t *src, zip_uint16_t flags, zip_error_t *error) {

+ _zip_error_set_from_source(error, src);

+ for (i = 0; i < (local ? 2 : 3); i++) {

+ zip_error_set(error, ZIP_ER_INTERNAL, 0);

+ return -1;

+_zip_dirent_write(zip_t *za, zip_dirent_t *de, zip_flags_t flags) {

+ if ((name_enc == ZIP_ENCODING_UTF8_KNOWN && com_enc == ZIP_ENCODING_ASCII) || (name_enc == ZIP_ENCODING_ASCII && com_enc == ZIP_ENCODING_UTF8_KNOWN) || (name_enc == ZIP_ENCODING_UTF8_KNOWN && com_enc == ZIP_ENCODING_UTF8_KNOWN))

+ if ((flags & ZIP_FL_LOCAL) == 0 && com_enc == ZIP_ENCODING_UTF8_KNOWN) {

+ de->bitflags &= (zip_uint16_t)~ZIP_GPBF_ENCRYPTED;

+ de->bitflags |= (zip_uint16_t)ZIP_GPBF_ENCRYPTED;

+ is_zip64 = (flags & (ZIP_FL_LOCAL | ZIP_FL_FORCE_ZIP64)) == (ZIP_FL_LOCAL | ZIP_FL_FORCE_ZIP64) || is_really_zip64;

+ zip_uint8_t ef_zip64[EFZIP64SIZE];

+ zip_buffer_t *ef_buffer = _zip_buffer_new(ef_zip64, sizeof(ef_zip64));

+ if (ef_buffer == NULL) {

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

+ return -1;

+ }

+

+ if (flags & ZIP_FL_LOCAL) {

+ if ((flags & ZIP_FL_FORCE_ZIP64) || de->comp_size > ZIP_UINT32_MAX || de->uncomp_size > ZIP_UINT32_MAX) {

+ _zip_buffer_put_64(ef_buffer, de->uncomp_size);

+ _zip_buffer_put_64(ef_buffer, de->comp_size);

+ }

+ }

+ else {

+ if ((flags & ZIP_FL_FORCE_ZIP64) || de->comp_size > ZIP_UINT32_MAX || de->uncomp_size > ZIP_UINT32_MAX || de->offset > ZIP_UINT32_MAX) {

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

+ _zip_buffer_put_64(ef_buffer, de->uncomp_size);

+ }

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

+ _zip_buffer_put_64(ef_buffer, de->comp_size);

+ }

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

+ _zip_buffer_put_64(ef_buffer, de->offset);

+ }

+ }

+ }

+

+ if (!_zip_buffer_ok(ef_buffer)) {

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

+ _zip_buffer_free(ef_buffer);

+ return -1;

+ }

+ ef64 = _zip_ef_new(ZIP_EF_ZIP64, (zip_uint16_t)(_zip_buffer_offset(ef_buffer)), ef_zip64, ZIP_EF_BOTH);

+ _zip_buffer_free(ef_buffer);

+ ef64->next = ef;

+ ef = ef64;

+ zip_buffer_t *ef_buffer = _zip_buffer_new(data, sizeof(data));

+

+ if (ef_buffer == NULL) {

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

+ return -1;

+ }

+ _zip_buffer_put_8(ef_buffer, (zip_uint8_t)(de->encryption_method & 0xff));

+ if (!_zip_buffer_ok(ef_buffer)) {

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

+ _zip_buffer_free(ef_buffer);

+ return -1;

+ }

+ ef_winzip = _zip_ef_new(ZIP_EF_WINZIP_AES, EF_WINZIP_AES_SIZE, data, ZIP_EF_BOTH);

+ _zip_buffer_free(ef_buffer);

+ ef_winzip->next = ef;

+ ef = ef_winzip;

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

+ _zip_ef_free(ef);

+ return -1;

+ _zip_buffer_put_16(buffer, (zip_uint16_t)(is_really_zip64 ? 45 : de->version_madeby));

+ _zip_buffer_put_16(buffer, de->bitflags);

+ if (is_winzip_aes && de->uncomp_size < 20) {

+ if (de->comp_size < ZIP_UINT32_MAX) {

+ }

+ else {

+ }

+ if (de->uncomp_size < ZIP_UINT32_MAX) {

+ }

+ else {

+ }

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

+ _zip_buffer_free(buffer);

+ _zip_ef_free(ef);

+ return -1;

+ _zip_buffer_free(buffer);

+ _zip_ef_free(ef);

+ return -1;

+ _zip_ef_free(ef);

+ _zip_ef_free(ef);

+_zip_d2u_time(zip_uint16_t dtime, zip_uint16_t ddate) {

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

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

+ tm.tm_mday = ddate & 31;

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

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

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

+_zip_ef_utf8(zip_uint16_t id, zip_string_t *str, zip_error_t *error) {

+ if ((raw = _zip_string_get(str, &len, ZIP_FL_ENC_RAW, NULL)) == NULL) {

+ if (len + 5 > ZIP_UINT16_MAX) {

+ zip_error_set(error, ZIP_ER_INVAL, 0); /* TODO: better error code? */

+ return NULL;

+ if ((buffer = _zip_buffer_new(NULL, len + 5)) == NULL) {

+ zip_error_set(error, ZIP_ER_INTERNAL, 0);

+ _zip_buffer_free(buffer);

+ return NULL;

+_zip_get_dirent(zip_t *za, zip_uint64_t idx, zip_flags_t flags, zip_error_t *error) {

+_zip_u2d_time(time_t intime, zip_uint16_t *dtime, zip_uint16_t *ddate) {

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

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

+

+

+void

+_zip_dirent_set_version_needed(zip_dirent_t *de, bool force_zip64) {

+ zip_uint16_t length;

+

+ if (de->comp_method == ZIP_CM_LZMA) {

+ de->version_needed = 63;

+ return;

+ }

+

+ if (de->comp_method == ZIP_CM_BZIP2) {

+ de->version_needed = 46;

+ return;

+ }

+

+ if (force_zip64 || _zip_dirent_needs_zip64(de, 0)) {

+ de->version_needed = 45;

+ return;

+ }

+

+ if (de->comp_method == ZIP_CM_DEFLATE || de->encryption_method == ZIP_EM_TRAD_PKWARE) {

+ de->version_needed = 20;

+ return;

+ }

+

+ /* directory */

+ if ((length = _zip_string_length(de->filename)) > 0) {

+ if (de->filename->raw[length - 1] == '/') {

+ de->version_needed = 20;

+ return;

+ }

+ }

+

+ de->version_needed = 10;

+}

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

+

+zip_discard(zip_t *za) {

+ for (i = 0; i < za->nentry; i++)

+ _zip_entry_finalize(za->entry + i);

+ for (i = 0; i < za->nopen_source; i++) {

+ _zip_progress_free(za->progress);

+

+

+

+_zip_entry_finalize(zip_entry_t *e) {

+_zip_entry_init(zip_entry_t *e) {

+const char *const _zip_err_str[] = {

+ "No error", "Multi-disk zip archives not supported", "Renaming temporary file failed", "Closing zip archive failed", "Seek error", "Read error", "Write error", "CRC error", "Containing zip archive was closed", "No such file", "File already exists", "Can't open file", "Failure to create temporary file", "Zlib error", "Malloc failure", "Entry has been changed", "Compression method not supported", "Premature end of file", "Invalid argument", "Not a zip archive", "Internal error", "Zip archive inconsistent", "Can't remove file", "Entry has been deleted", "Encryption method not supported", "Read-only archive", "No password provided", "Wrong password provided", "Operation not supported", "Resource still in use", "Tell error", "Compressed data invalid",

+const int _zip_nerr_str = sizeof(_zip_err_str) / sizeof(_zip_err_str[0]);

+ N, N, S, S, S, S, S, N, N, N, N, S, S, Z, N, N, N, N, N, N, N, N, S, N, N, N, N, N, N, N, S, N,

+

+zip_error_fini(zip_error_t *err) {

+zip_error_init(zip_error_t *err) {

+zip_error_init_with_code(zip_error_t *error, int ze) {

+ }

+ return ZIP_ET_NONE;

+

+_zip_error_clear(zip_error_t *err) {

+_zip_error_copy(zip_error_t *dst, const zip_error_t *src) {

+ if (dst == NULL) {

+ return;

+ }

+

+_zip_error_get(const zip_error_t *err, int *zep, int *sep) {

+zip_error_set(zip_error_t *err, int ze, int se) {

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

+zip_error_to_data(const zip_error_t *error, void *data, zip_uint64_t length) {

+

+ if (length < sizeof(int) * 2) {

+ return -1;

+

+ return sizeof(int) * 2;

+

+zip_error_clear(zip_t *za) {

+

+zip_error_get(zip_t *za, int *zep, int *sep) {

+zip_get_error(zip_t *za) {

+zip_file_get_error(zip_file_t *f) {

+

+zip_error_get_sys_type(int ze) {

+

+zip_error_strerror(zip_error_t *err) {

+

+ if ((s = (char *)malloc(strlen(ss) + (zs ? strlen(zs) + 2 : 0) + 1)) == NULL)

+

+ sprintf(s, "%s%s%s", (zs ? zs : ""), (zs ? ": " : ""), ss);

+

+zip_error_to_str(char *buf, zip_uint64_t len, int ze, int se) {

+

+

+

+ return snprintf(buf, len, "%s%s%s", zs, (ss ? ": " : ""), (ss ? ss : ""));

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

+

+_zip_ef_clone(const zip_extra_field_t *ef, zip_error_t *error) {

+

+

+ if ((def = _zip_ef_new(ef->id, ef->size, ef->data, ef->flags)) == NULL) {

+ zip_error_set(error, ZIP_ER_MEMORY, 0);

+ _zip_ef_free(head);

+ return NULL;

+ }

+

+ if (head == NULL)

+ head = def;

+ if (prev)

+ prev->next = def;

+ prev = def;

+

+_zip_ef_delete_by_id(zip_extra_field_t *ef, zip_uint16_t id, zip_uint16_t id_idx, zip_flags_t flags) {

+ for (; ef; ef = (prev ? prev->next : head)) {

+

+_zip_ef_free(zip_extra_field_t *ef) {

+_zip_ef_get_by_id(const zip_extra_field_t *ef, zip_uint16_t *lenp, zip_uint16_t id, zip_uint16_t id_idx, zip_flags_t flags, zip_error_t *error) {

+ static const zip_uint8_t empty[1] = {'\0'};

+

+ for (; ef; ef = ef->next) {

+_zip_ef_merge(zip_extra_field_t *to, zip_extra_field_t *from) {

+ for (tail = to; tail->next; tail = tail->next)

+ for (; from; from = ef2) {

+ for (tt = to; tt; tt = tt->next) {

+ if (tt->id == from->id && tt->size == from->size && (tt->size == 0 || memcmp(tt->data, from->data, tt->size) == 0)) {

+_zip_ef_new(zip_uint16_t id, zip_uint16_t size, const zip_uint8_t *data, zip_flags_t flags) {

+ if ((ef = (zip_extra_field_t *)malloc(sizeof(*ef))) == NULL)

+ if ((ef->data = (zip_uint8_t *)_zip_memdup(data, size, NULL)) == NULL) {

+_zip_ef_parse(const zip_uint8_t *data, zip_uint16_t len, zip_flags_t flags, zip_extra_field_t **ef_head_p, zip_error_t *error) {

+ zip_error_set(error, ZIP_ER_MEMORY, 0);

+ return false;

+

+

+ zip_uint16_t fid, flen;

+ zip_uint8_t *ef_data;

+

+ fid = _zip_buffer_get_16(buffer);

+ ef_data = _zip_buffer_get(buffer, flen);

+ if (ef_data == NULL) {

+ _zip_buffer_free(buffer);

+ }

+

+ if ((ef2 = _zip_ef_new(fid, flen, ef_data, flags)) == NULL) {

+ _zip_buffer_free(buffer);

+ _zip_ef_free(ef_head);

+

+_zip_ef_remove_internal(zip_extra_field_t *ef) {

+

+

+ if (ZIP_EF_IS_INTERNAL(ef->id)) {

+ next = ef->next;

+ if (ef_head == ef)

+ ef_head = next;

+ ef->next = NULL;

+ _zip_ef_free(ef);

+ if (prev)

+ prev->next = next;

+ ef = next;

+ }

+ else {

+ prev = ef;

+ ef = ef->next;

+ }

+

+_zip_ef_size(const zip_extra_field_t *ef, zip_flags_t flags) {

+ for (; ef; ef = ef->next) {

+ size = (zip_uint16_t)(size + 4 + ef->size);

+_zip_ef_write(zip_t *za, const zip_extra_field_t *ef, zip_flags_t flags) {

+ for (; ef; ef = ef->next) {

+ _zip_buffer_set_offset(buffer, 0);

+ _zip_buffer_put_16(buffer, ef->id);

+ if (!_zip_buffer_ok(buffer)) {

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

+ _zip_buffer_free(buffer);

+ return -1;

+ }

+ _zip_buffer_free(buffer);

+ return -1;

+ _zip_buffer_free(buffer);

+ return -1;

+

+_zip_read_local_ef(zip_t *za, zip_uint64_t idx) {

+ e = za->entry + idx;

+ }

+

+ return -1;

+

+

+ _zip_buffer_free(buffer);

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

+ return -1;

+

+

+

+

+zip_file_extra_field_delete(zip_t *za, zip_uint64_t idx, zip_uint16_t ef_idx, zip_flags_t flags) {

+

+

+ return -1;

+

+

+zip_file_extra_field_delete_by_id(zip_t *za, zip_uint64_t idx, zip_uint16_t ef_id, zip_uint16_t ef_idx, zip_flags_t flags) {

+

+

+ return -1;

+

+zip_file_extra_field_get(zip_t *za, zip_uint64_t idx, zip_uint16_t ef_idx, zip_uint16_t *idp, zip_uint16_t *lenp, zip_flags_t flags) {

+ static const zip_uint8_t empty[1] = {'\0'};

+ if ((de = _zip_get_dirent(za, idx, flags, &za->error)) == NULL)

+ for (ef = de->extra_fields; ef; ef = ef->next) {

+zip_file_extra_field_get_by_id(zip_t *za, zip_uint64_t idx, zip_uint16_t ef_id, zip_uint16_t ef_idx, zip_uint16_t *lenp, zip_flags_t flags) {

+ if ((de = _zip_get_dirent(za, idx, flags, &za->error)) == NULL)

+zip_file_extra_fields_count(zip_t *za, zip_uint64_t idx, zip_flags_t flags) {

+ if ((de = _zip_get_dirent(za, idx, flags, &za->error)) == NULL)

+ for (ef = de->extra_fields; ef; ef = ef->next)

+zip_file_extra_fields_count_by_id(zip_t *za, zip_uint64_t idx, zip_uint16_t ef_id, zip_flags_t flags) {

+ if ((de = _zip_get_dirent(za, idx, flags, &za->error)) == NULL)

+ for (ef = de->extra_fields; ef; ef = ef->next)

+zip_file_extra_field_set(zip_t *za, zip_uint64_t idx, zip_uint16_t ef_id, zip_uint16_t ef_idx, const zip_uint8_t *data, zip_uint16_t len, zip_flags_t flags) {

+

+

+ return -1;

+

+ for (; ef; ef = ef->next) {

+

+ if ((ef_new = _zip_ef_new(ef_id, len, data, flags)) == NULL) {

+ }

+

+_zip_file_extra_field_prepare_for_change(zip_t *za, zip_uint64_t idx) {

+

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

+ return -1;

+

+ e = za->entry + idx;

+

+ return 0;

+

+ if ((e->changes = _zip_dirent_clone(e->orig)) == NULL) {

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

+ return -1;

+ }

+

+ if ((e->changes->extra_fields = _zip_ef_clone(e->orig->extra_fields, &za->error)) == NULL)

+

+

+zip_fclose(zip_file_t *zf) {

+

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

+

+zip_fdopen(int fd_orig, int _flags, int *zep) {

+ if (_flags < 0 || (_flags & ~(ZIP_CHECKCONS | ZIP_RDONLY))) {

+ return NULL;

+

+ if ((fd = dup(fd_orig)) < 0) {

+ if ((fp = fdopen(fd, "rb")) == NULL) {

+

+ The index can not be larger than ZIP_INT64_MAX since the size

+ of the central directory cannot be larger than

+ ZIP_UINT64_MAX, and each entry is larger than 2 bytes.

+zip_file_add(zip_t *za, const char *name, zip_source_t *source, zip_flags_t flags) {

+

+

+zip_file_error_clear(zip_file_t *zf) {

+

+zip_file_error_get(zip_file_t *zf, int *zep, int *sep) {

+

+zip_file_get_comment(zip_t *za, zip_uint64_t idx, zip_uint32_t *lenp, zip_flags_t flags) {

+ if ((de = _zip_get_dirent(za, idx, flags, NULL)) == NULL)

+ if ((str = _zip_string_get(de->comment, &len, flags, &za->error)) == NULL)

+

+zip_file_get_external_attributes(zip_t *za, zip_uint64_t idx, zip_flags_t flags, zip_uint8_t *opsys, zip_uint32_t *attributes) {

+ if ((de = _zip_get_dirent(za, idx, flags, NULL)) == NULL)

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

+

+#include <sys/types.h>

+_zip_file_get_offset(const zip_t *za, zip_uint64_t idx, zip_error_t *error) {

+ if (za->entry[idx].orig == NULL) {

+ zip_error_set(error, ZIP_ER_INTERNAL, 0);

+ return 0;

+ }

+

+ if ((size = _zip_dirent_size(za->src, ZIP_EF_LOCAL, error)) < 0)

+ if (offset + (zip_uint32_t)size > ZIP_INT64_MAX) {

+ zip_error_set(error, ZIP_ER_SEEK, EFBIG);

+ return 0;

+

+

+zip_uint64_t

+_zip_file_get_end(const zip_t *za, zip_uint64_t index, zip_error_t *error) {

+ zip_uint64_t offset;

+ zip_dirent_t *entry;

+

+ if ((offset = _zip_file_get_offset(za, index, error)) == 0) {

+ return 0;

+ }

+

+ entry = za->entry[index].orig;

+

+ if (offset + entry->comp_size < offset || offset + entry->comp_size > ZIP_INT64_MAX) {

+ zip_error_set(error, ZIP_ER_SEEK, EFBIG);

+ return 0;

+ }

+ offset += entry->comp_size;

+

+ if (entry->bitflags & ZIP_GPBF_DATA_DESCRIPTOR) {

+ zip_uint8_t buf[4];

+ if (zip_source_seek(za->src, (zip_int64_t)offset, SEEK_SET) < 0) {

+ _zip_error_set_from_source(error, za->src);

+ return 0;

+ }

+ if (zip_source_read(za->src, buf, 4) != 4) {

+ _zip_error_set_from_source(error, za->src);

+ return 0;

+ }

+ if (memcmp(buf, DATADES_MAGIC, 4) == 0) {

+ offset += 4;

+ }

+ offset += 12;

+ if (_zip_dirent_needs_zip64(entry, 0)) {

+ offset += 8;

+ }

+ if (offset > ZIP_INT64_MAX) {

+ zip_error_set(error, ZIP_ER_SEEK, EFBIG);

+ return 0;

+ }

+ }

+

+ return offset;

+}

+

+zip_file_rename(zip_t *za, zip_uint64_t idx, const char *name, zip_flags_t flags) {

+

+ if ((old_name = zip_get_name(za, idx, 0)) == NULL)

+

+ new_is_dir = (name != NULL && name[strlen(name) - 1] == '/');

+ old_is_dir = (old_name[strlen(old_name) - 1] == '/');

+

+zip_file_replace(zip_t *za, zip_uint64_t idx, zip_source_t *source, zip_flags_t flags) {

+_zip_file_replace(zip_t *za, zip_uint64_t idx, const char *name, zip_source_t *source, zip_flags_t flags) {

+

+

+ if ((i = _zip_add_entry(za)) < 0)

+

+ _zip_entry_finalize(za->entry + idx);

+ _zip_unchange_data(za->entry + idx);

+ if (za->entry[idx].changes == NULL) {

+ if ((za->entry[idx].changes = _zip_dirent_clone(za->entry[idx].orig)) == NULL) {

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

+ return -1;

+ }

+ }

+

+ za->entry[idx].changes->comp_method = ZIP_CM_REPLACED_DEFAULT;

+ za->entry[idx].changes->changed |= ZIP_DIRENT_COMP_METHOD;

+

+

+zip_file_set_comment(zip_t *za, zip_uint64_t idx, const char *comment, zip_uint16_t len, zip_flags_t flags) {

+ if ((cstr = _zip_string_new((const zip_uint8_t *)comment, len, flags, &za->error)) == NULL)

+ e = za->entry + idx;

+

+ if (e->changes == NULL) {

+ if ((e->changes = _zip_dirent_clone(e->orig)) == NULL) {

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

+ return -1;

+ }

+ }

+ e->changes->comment = cstr;

+ e->changes->changed |= ZIP_DIRENT_COMMENT;

+

+zip_file_set_external_attributes(zip_t *za, zip_uint64_t idx, zip_flags_t flags, zip_uint8_t opsys, zip_uint32_t attributes) {

+ e = za->entry + idx;

+ unchanged_opsys = (e->orig ? (zip_uint8_t)(e->orig->version_madeby >> 8) : (zip_uint8_t)ZIP_OPSYS_DEFAULT);

+ if (e->changes == NULL) {

+ if ((e->changes = _zip_dirent_clone(e->orig)) == NULL) {

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

+ return -1;

+ }

+ }

+ e->changes->version_madeby = (zip_uint16_t)((opsys << 8) | (e->changes->version_madeby & 0xff));

+ e->changes->changed |= ZIP_DIRENT_ATTRIBUTES;

+

+

+

+ZIP_EXTERN int

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

+

+ return -1;

+

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

+ return -1;

+

+ e = za->entry + idx;

+

+ if (e->changes == NULL) {

+ if ((e->changes = _zip_dirent_clone(e->orig)) == NULL) {

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

+ return -1;

+ }

+ }

+ e->changes->last_mod = mtime;

+ e->changes->changed |= ZIP_DIRENT_LAST_MOD;

+ if (e->changes) {

+ e->changes->changed &= ~ZIP_DIRENT_LAST_MOD;

+ if (e->changes->changed == 0) {

+ e->changes = NULL;

+ }

+ }

+

+

+zip_file_strerror(zip_file_t *zf) {

+

+_zip_filerange_crc(zip_source_t *src, zip_uint64_t start, zip_uint64_t len, uLong *crcp, zip_error_t *error) {

+

+

+zip_fopen(zip_t *za, const char *fname, zip_flags_t flags) {

+ if ((idx = zip_name_locate(za, fname, flags)) < 0)

+

+zip_fopen_encrypted(zip_t *za, const char *fname, zip_flags_t flags, const char *password) {

+ if ((idx = zip_name_locate(za, fname, flags)) < 0)

+

+zip_fopen_index(zip_t *za, zip_uint64_t index, zip_flags_t flags) {

+

+zip_fopen_index_encrypted(zip_t *za, zip_uint64_t index, zip_flags_t flags, const char *password) {

+ if ((src = _zip_source_zip_new(za, za, index, flags, 0, 0, password)) == NULL)

+ if ((zf = _zip_file_new(za)) == NULL) {

+_zip_file_new(zip_t *za) {

+ if ((zf = (zip_file_t *)malloc(sizeof(struct zip_file))) == NULL) {

+

+zip_fread(zip_file_t *zf, void *outbuf, zip_uint64_t toread) {

+ if ((n = zip_source_read(zf->src, outbuf, toread)) < 0) {

+

+zip_get_archive_comment(zip_t *za, int *lenp, zip_flags_t flags) {

+ if ((str = _zip_string_get(comment, &len, flags, &za->error)) == NULL)

+

+zip_get_archive_flag(zip_t *za, zip_flags_t flag, zip_flags_t flags) {

+

+_zip_get_encryption_implementation(zip_uint16_t em, int operation) {

+

+#if defined(HAVE_CRYPTO)

+#endif

+

+

+zip_get_file_comment(zip_t *za, zip_uint64_t idx, int *lenp, int flags) {

+ if ((s = zip_file_get_comment(za, idx, &len, (zip_flags_t)flags)) != NULL) {

+

+zip_get_name(zip_t *za, zip_uint64_t idx, zip_flags_t flags) {

+_zip_get_name(zip_t *za, zip_uint64_t idx, zip_flags_t flags, zip_error_t *error) {

+ if ((de = _zip_get_dirent(za, idx, flags, error)) == NULL)

+ if ((str = _zip_string_get(de->filename, NULL, flags, error)) == NULL)

+

+zip_get_num_entries(zip_t *za, zip_flags_t flags) {

+ while (n > 0 && za->entry[n - 1].orig == NULL)

+

+zip_get_num_files(zip_t *za) {

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

+

+#include "zipint.h"

+

+/* parameter for the string hash function */

+#define HASH_MULTIPLIER 33

+#define HASH_START 5381

+

+/* hash table's fill ratio is kept between these by doubling/halfing its size as necessary */

+#define HASH_MAX_FILL .75

+#define HASH_MIN_FILL .01

+

+/* but hash table size is kept between these */

+#define HASH_MIN_SIZE 256

+#define HASH_MAX_SIZE 0x80000000ul

+ zip_uint32_t hash_value;

+ zip_uint32_t table_size;

+ zip_uint64_t nentries;

+/* free list of entries */

+static void

+free_list(zip_hash_entry_t *entry) {

+ while (entry != NULL) {

+ zip_hash_entry_t *next = entry->next;

+ free(entry);

+ entry = next;

+}

+

+

+/* compute hash of string, full 32 bit value */

+static zip_uint32_t

+hash_string(const zip_uint8_t *name) {

+ zip_uint64_t value = HASH_START;

+ if (name == NULL) {

+ return 0;

+ }

+

+ while (*name != 0) {

+ value = (zip_uint64_t)(((value * HASH_MULTIPLIER) + (zip_uint8_t)*name) % 0x100000000ul);

+ name++;

+ }

+

+ return (zip_uint32_t)value;

+}

+

+

+/* resize hash table; new_size must be a power of 2, can be larger or smaller than current size */

+static bool

+hash_resize(zip_hash_t *hash, zip_uint32_t new_size, zip_error_t *error) {

+ zip_hash_entry_t **new_table;

+

+ if (new_size == hash->table_size) {

+ return true;

+ }

+

+ if ((new_table = (zip_hash_entry_t **)calloc(new_size, sizeof(zip_hash_entry_t *))) == NULL) {

+ return false;

+

+ if (hash->nentries > 0) {

+ zip_uint32_t i;

+

+ for (i = 0; i < hash->table_size; i++) {

+ zip_hash_entry_t *entry = hash->table[i];

+ while (entry) {

+ zip_hash_entry_t *next = entry->next;

+

+ zip_uint32_t new_index = entry->hash_value % new_size;

+

+ entry->next = new_table[new_index];

+ new_table[new_index] = entry;

+

+ entry = next;

+ }

+ }

+ }

+

+ free(hash->table);

+ hash->table = new_table;

+ hash->table_size = new_size;

+

+ return true;

+}

+

+

+static zip_uint32_t

+size_for_capacity(zip_uint64_t capacity) {

+ double needed_size = capacity / HASH_MAX_FILL;

+ zip_uint32_t v;

+

+ if (needed_size > ZIP_UINT32_MAX) {

+ v = ZIP_UINT32_MAX;

+ }

+ else {

+ v = (zip_uint32_t)needed_size;

+ }

+

+ if (v > HASH_MAX_SIZE) {

+ return HASH_MAX_SIZE;

+ }

+

+ /* From Bit Twiddling Hacks by Sean Eron Anderson <seander@cs.stanford.edu>

+ (http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2). */

+

+ v--;

+ v |= v >> 1;

+ v |= v >> 2;

+ v |= v >> 4;

+ v |= v >> 8;

+ v |= v >> 16;

+ v++;

+

+ return v;

+}

+

+

+zip_hash_t *

+_zip_hash_new(zip_error_t *error) {

+ zip_hash_t *hash;

+

+ if ((hash = (zip_hash_t *)malloc(sizeof(zip_hash_t))) == NULL) {

+ hash->table_size = 0;

+ hash->nentries = 0;

+ hash->table = NULL;

+

+_zip_hash_free(zip_hash_t *hash) {

+ zip_uint32_t i;

+ if (hash->table != NULL) {

+ for (i = 0; i < hash->table_size; i++) {

+ if (hash->table[i] != NULL) {

+ free_list(hash->table[i]);

+ }

+ free(hash->table);

+_zip_hash_add(zip_hash_t *hash, const zip_uint8_t *name, zip_uint64_t index, zip_flags_t flags, zip_error_t *error) {

+ zip_uint32_t hash_value, table_index;

+ if (hash->table_size == 0) {

+ if (!hash_resize(hash, HASH_MIN_SIZE, error)) {

+ return false;

+ }

+ }

+

+ hash_value = hash_string(name);

+ table_index = hash_value % hash->table_size;

+

+ for (entry = hash->table[table_index]; entry != NULL; entry = entry->next) {

+ if (entry->hash_value == hash_value && strcmp((const char *)name, (const char *)entry->name) == 0) {

+ if ((entry = (zip_hash_entry_t *)malloc(sizeof(zip_hash_entry_t))) == NULL) {

+ entry->next = hash->table[table_index];

+ hash->table[table_index] = entry;

+ entry->hash_value = hash_value;

+ hash->nentries++;

+ if (hash->nentries > hash->table_size * HASH_MAX_FILL && hash->table_size < HASH_MAX_SIZE) {

+ if (!hash_resize(hash, hash->table_size * 2, error)) {

+ return false;

+ }

+ }

+

+_zip_hash_delete(zip_hash_t *hash, const zip_uint8_t *name, zip_error_t *error) {

+ zip_uint32_t hash_value, index;

+ if (hash->nentries > 0) {

+ hash_value = hash_string(name);

+ index = hash_value % hash->table_size;

+ previous = NULL;

+ entry = hash->table[index];

+ while (entry) {

+ if (entry->hash_value == hash_value && strcmp((const char *)name, (const char *)entry->name) == 0) {

+ if (entry->orig_index == -1) {

+ if (previous) {

+ previous->next = entry->next;

+ }

+ else {

+ hash->table[index] = entry->next;

+ }

+ free(entry);

+ hash->nentries--;

+ if (hash->nentries < hash->table_size * HASH_MIN_FILL && hash->table_size > HASH_MIN_SIZE) {

+ if (!hash_resize(hash, hash->table_size / 2, error)) {

+ return false;

+ }

+ }

+ entry->current_index = -1;

+ return true;

+ previous = entry;

+ entry = entry->next;

+ }

+

+_zip_hash_lookup(zip_hash_t *hash, const zip_uint8_t *name, zip_flags_t flags, zip_error_t *error) {

+ zip_uint32_t hash_value, index;

+ if (hash->nentries > 0) {

+ hash_value = hash_string(name);

+ index = hash_value % hash->table_size;

+ for (entry = hash->table[index]; entry != NULL; entry = entry->next) {

+ if (strcmp((const char *)name, (const char *)entry->name) == 0) {

+ if (flags & ZIP_FL_UNCHANGED) {

+ if (entry->orig_index != -1) {

+ return entry->orig_index;

+ }

+ else {

+ if (entry->current_index != -1) {

+ return entry->current_index;

+ }

+ break;

+ return -1;

+

+bool

+_zip_hash_reserve_capacity(zip_hash_t *hash, zip_uint64_t capacity, zip_error_t *error) {

+ zip_uint32_t new_size;

+

+ if (capacity == 0) {

+ return true;

+ }

+

+ new_size = size_for_capacity(capacity);

+

+ if (new_size <= hash->table_size) {

+ return true;

+ }

+

+ if (!hash_resize(hash, new_size, error)) {

+ return false;

+ }

+

+ return true;

+}

+

+

+bool

+_zip_hash_revert(zip_hash_t *hash, zip_error_t *error) {

+ zip_uint32_t i;

+

+ hash->nentries--;

+

+ if (hash->nentries < hash->table_size * HASH_MIN_FILL && hash->table_size > HASH_MIN_SIZE) {

+ zip_uint32_t new_size = hash->table_size / 2;

+ while (hash->nentries < new_size * HASH_MIN_FILL && new_size > HASH_MIN_SIZE) {

+ new_size /= 2;

+ }

+ if (!hash_resize(hash, new_size, error)) {

+ return false;

+ }

+ }

+

+ return true;

+

+

+

+_zip_read(zip_source_t *src, zip_uint8_t *b, zip_uint64_t length, zip_error_t *error) {

+_zip_read_data(zip_buffer_t *buffer, zip_source_t *src, size_t length, bool nulp, zip_error_t *error) {

+

+ zip_uint8_t *data = _zip_buffer_get(buffer, length);

+

+ if (data == NULL) {

+ zip_error_set(error, ZIP_ER_MEMORY, 0);

+ free(r);

+ return NULL;

+ }

+ for (o = r; o < r + length; o++)

+_zip_read_string(zip_buffer_t *buffer, zip_source_t *src, zip_uint16_t len, bool nulp, zip_error_t *error) {

+ if ((raw = _zip_read_data(buffer, src, len, nulp, error)) == NULL)

+_zip_write(zip_t *za, const void *data, zip_uint64_t length) {

+

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

+ return -1;

+ zip_error_set(&za->error, ZIP_ER_WRITE, EINTR);

+ return -1;

+

+

+_zip_memdup(const void *mem, size_t len, zip_error_t *error) {

+

+zip_name_locate(zip_t *za, const char *fname, zip_flags_t flags) {

+_zip_name_locate(zip_t *za, const char *fname, zip_flags_t flags, zip_error_t *error) {

+ if (flags & (ZIP_FL_NOCASE | ZIP_FL_NODIR | ZIP_FL_ENC_CP437)) {

+ for (i = 0; i < za->nentry; i++) {

+

+

+ fn = p + 1;

+

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

+

+_zip_new(zip_error_t *error) {

+ if ((za->names = _zip_hash_new(error)) == NULL) {

+ za->progress = NULL;

+

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

+#include <sys/stat.h>

+zip_open(const char *fn, int _flags, int *zep) {

+zip_open_from_source(zip_source_t *src, int _flags, zip_error_t *error) {

+ return NULL;

+ needed_support_read = zip_source_make_command_bitmap(ZIP_SOURCE_OPEN, ZIP_SOURCE_READ, ZIP_SOURCE_CLOSE, ZIP_SOURCE_SEEK, ZIP_SOURCE_TELL, ZIP_SOURCE_STAT, -1);

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

+ zip_error_set(error, ZIP_ER_OPNOTSUPP, 0);

+ return NULL;

+ flags |= ZIP_RDONLY;

+ if ((flags & (ZIP_RDONLY | ZIP_TRUNCATE)) == (ZIP_RDONLY | ZIP_TRUNCATE)) {

+_zip_open(zip_source_t *src, unsigned int flags, zip_error_t *error) {

+ if ((za = _zip_allocate_new(src, flags, error)) == NULL) {

+ if ((za = _zip_allocate_new(src, flags, error)) == NULL) {

+ return NULL;

+ _zip_error_copy(error, &za->error);

+ _zip_hash_reserve_capacity(za->names, za->nentry, &za->error);

+

+ /* keep src so discard does not get rid of it */

+ zip_source_keep(src);

+ zip_discard(za);

+ return NULL;

+_zip_set_open_error(int *zep, const zip_error_t *err, int ze) {

+_zip_read_cdir(zip_t *za, zip_buffer_t *buffer, zip_uint64_t buf_offset, zip_error_t *error) {

+ _zip_buffer_set_offset(buffer, eocd_offset - EOCD64LOCLEN);

+ cd = _zip_read_eocd64(za->src, buffer, buf_offset, za->flags, error);

+ _zip_buffer_set_offset(buffer, eocd_offset);

+ cd = _zip_read_eocd(buffer, buf_offset, za->flags, error);

+ zip_uint64_t tail_len;

+ _zip_buffer_set_offset(buffer, eocd_offset + EOCDLEN);

+ tail_len = _zip_buffer_left(buffer);

+ if (tail_len < comment_len || ((za->open_flags & ZIP_CHECKCONS) && tail_len != comment_len)) {

+ zip_error_set(error, ZIP_ER_INCONS, 0);

+ _zip_cdir_free(cd);

+ return NULL;

+ }

+ if (comment_len) {

+ if ((cd->comment = _zip_string_new(_zip_buffer_get(buffer, comment_len), comment_len, ZIP_FL_ENC_GUESS, error)) == NULL) {

+ _zip_cdir_free(cd);

+ return NULL;

+ }

+ }

+ zip_uint8_t *data;

+ _zip_buffer_set_offset(buffer, cd->offset - buf_offset);

+

+ if ((data = _zip_buffer_get(buffer, cd->size)) == NULL) {

+ zip_error_set(error, ZIP_ER_INCONS, 0);

+ _zip_cdir_free(cd);

+ return NULL;

+ }

+ if ((cd_buffer = _zip_buffer_new(data, cd->size)) == NULL) {

+ zip_error_set(error, ZIP_ER_MEMORY, 0);

+ _zip_cdir_free(cd);

+ return NULL;

+ }

+ cd_buffer = NULL;

+ if (zip_source_seek(za->src, (zip_int64_t)cd->offset, SEEK_SET) < 0) {

+ _zip_error_set_from_source(error, za->src);

+ _zip_cdir_free(cd);

+ return NULL;

+ }

+ zip_error_set(error, ZIP_ER_NOZIP, 0);

+ i = 0;

+ zip_int64_t entry_size;

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

+ _zip_buffer_free(cd_buffer);

+ left -= (zip_uint64_t)entry_size;

+ zip_error_set(error, ZIP_ER_INCONS, 0);

+ _zip_buffer_free(cd_buffer);

+ _zip_cdir_free(cd);

+ return NULL;

+ bool ok;

+

+ if (cd_buffer) {

+ ok = _zip_buffer_eof(cd_buffer);

+ }

+ else {

+ zip_int64_t offset = zip_source_tell(za->src);

+

+ if (offset < 0) {

+ _zip_error_set_from_source(error, za->src);

+ _zip_cdir_free(cd);

+ return NULL;

+ }

+ ok = ((zip_uint64_t)offset == cd->offset + cd->size);

+ }

+

+ if (!ok) {

+ zip_error_set(error, ZIP_ER_INCONS, 0);

+ _zip_buffer_free(cd_buffer);

+ _zip_cdir_free(cd);

+ return NULL;

+ }

+_zip_checkcons(zip_t *za, zip_cdir_t *cd, zip_error_t *error) {

+ for (i = 0; i < cd->nentry; i++) {

+ j = cd->entry[i].orig->offset + cd->entry[i].orig->comp_size + _zip_string_length(cd->entry[i].orig->filename) + LENTRYSIZE;

+ if (zip_source_seek(za->src, (zip_int64_t)cd->entry[i].orig->offset, SEEK_SET) < 0) {

+ _zip_error_set_from_source(error, za->src);

+ return -1;

+ return (max - min) < ZIP_INT64_MAX ? (zip_int64_t)(max - min) : ZIP_INT64_MAX;

+_zip_headercomp(const zip_dirent_t *central, const zip_dirent_t *local) {

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

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

+ if (((local->bitflags & ZIP_GPBF_DATA_DESCRIPTOR) == 0 || local->crc != 0 || local->comp_size != 0 || local->uncomp_size != 0))

+_zip_allocate_new(zip_source_t *src, unsigned int flags, zip_error_t *error) {

+ za->flags |= ZIP_AFL_RDONLY;

+ za->ch_flags |= ZIP_AFL_RDONLY;

+_zip_file_exists(zip_source_t *src, zip_error_t *error) {

+ zip_error_t *src_error = zip_source_error(src);

+ if (zip_error_code_zip(src_error) == ZIP_ER_READ && zip_error_code_system(src_error) == ENOENT) {

+_zip_find_central_dir(zip_t *za, zip_uint64_t len) {

+ return NULL;

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

+ return NULL;

+ return NULL;

+ /* EOCD64 locator is before EOCD, so leave place for it */

+ _zip_buffer_set_offset(buffer, EOCD64LOCLEN);

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

+ _zip_buffer_set_offset(buffer, (zip_uint64_t)(match - _zip_buffer_data(buffer)));

+ if ((cdirnew = _zip_read_cdir(za, buffer, (zip_uint64_t)buf_offset, &error)) != NULL) {

+ if (cdir) {

+ if (best <= 0) {

+ best = _zip_checkcons(za, cdir, &error);

+ }

+

+ a = _zip_checkcons(za, cdirnew, &error);

+ if (best < a) {

+ _zip_cdir_free(cdir);

+ cdir = cdirnew;

+ best = a;

+ }

+ else {

+ _zip_cdir_free(cdirnew);

+ }

+ }

+ else {

+ cdir = cdirnew;

+ if (za->open_flags & ZIP_CHECKCONS)

+ best = _zip_checkcons(za, cdir, &error);

+ else {

+ best = 0;

+ }

+ }

+ cdirnew = NULL;

+ }

+

+ match++;

+ _zip_buffer_set_offset(buffer, (zip_uint64_t)(match - _zip_buffer_data(buffer)));

+ _zip_error_copy(&za->error, &error);

+ _zip_cdir_free(cdir);

+ return NULL;

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

+ p = big - 1;

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

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

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

+ if (offset + size < offset) {

+ zip_error_set(error, ZIP_ER_SEEK, EFBIG);

+ return NULL;

+ if (offset + size > buf_offset + eocd_offset) {

+ if ((flags & ZIP_CHECKCONS) && offset + size != buf_offset + eocd_offset) {

+ if ((cd = _zip_cdir_new(nentry, error)) == NULL)

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

+ zip_error_set(error, ZIP_ER_SEEK, EFBIG);

+ return NULL;

+ _zip_buffer_set_offset(buffer, eocd_offset - buf_offset);

+ free_buffer = false;

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

+ _zip_error_set_from_source(error, src);

+ return NULL;

+ }

+ if ((buffer = _zip_buffer_new_from_source(src, EOCD64LEN, eocd, error)) == NULL) {

+ return NULL;

+ }

+ free_buffer = true;

+ if (free_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ if (free_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ return NULL;

+ if (free_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ if (free_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ if (free_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ zip_error_set(error, ZIP_ER_INTERNAL, 0);

+ if (free_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ return NULL;

+ _zip_buffer_free(buffer);

+ if (offset > ZIP_INT64_MAX || offset + size < offset) {

+ zip_error_set(error, ZIP_ER_SEEK, EFBIG);

+ return NULL;

+ }

+ if (offset + size > buf_offset + eocd_offset) {

+ /* cdir spans past EOCD record */

+ zip_error_set(error, ZIP_ER_INCONS, 0);

+ return NULL;

+ if ((flags & ZIP_CHECKCONS) && offset + size != buf_offset + eocd_offset) {

+ if ((cd = _zip_cdir_new(nentry, error)) == NULL)

+/*

+ zip_progress.c -- progress reporting

+ Copyright (C) 2017 Dieter Baron and Thomas Klausner

+

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

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

+

+ 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 <stdlib.h>

+

+

+#define _ZIP_COMPILING_DEPRECATED

+#include "zipint.h"

+

+struct zip_progress {

+ zip_t *za;

+ zip_progress_callback callback;

+ void (*ud_free)(void *);

+

+ void *ud;

+

+ double precision;

+

+ /* state */

+ double last_update; /* last value callback function was called with */

+

+ double start; /* start of sub-progress section */

+ double end; /* end of sub-progress section */

+};

+

+

+void

+_zip_progress_end(zip_progress_t *progress) {

+ _zip_progress_update(progress, 1.0);

+}

+

+

+void

+_zip_progress_free(zip_progress_t *progress) {

+ if (progress == NULL) {

+ return;

+ }

+

+ if (progress->ud_free) {

+ progress->ud_free(progress->ud);

+ }

+

+ free(progress);

+}

+

+

+zip_progress_t *

+_zip_progress_new(zip_t *za, double precision, zip_progress_callback callback, void (*ud_free)(void *), void *ud) {

+ zip_progress_t *progress = (zip_progress_t *)malloc(sizeof(*progress));

+

+ if (progress == NULL) {

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

+ return NULL;

+ }

+

+ progress->za = za;

+ progress->callback = callback;

+ progress->ud_free = ud_free;

+ progress->ud = ud;

+ progress->precision = precision;

+

+ return progress;

+}

+

+

+void

+_zip_progress_start(zip_progress_t *progress) {

+ if (progress == NULL) {

+ return;

+ }

+

+ progress->last_update = 0.0;

+ progress->callback(progress->za, 0.0, progress->ud);

+}

+

+

+void

+_zip_progress_subrange(zip_progress_t *progress, double start, double end) {

+ if (progress == NULL) {

+ return;

+ }

+

+ progress->start = start;

+ progress->end = end;

+

+ _zip_progress_update(progress, 0.0);

+}

+

+void

+_zip_progress_update(zip_progress_t *progress, double sub_current) {

+ double current;

+

+ if (progress == NULL) {

+ return;

+ }

+

+ current = ZIP_MIN(ZIP_MAX(sub_current, 0.0), 1.0) * (progress->end - progress->start) + progress->start;

+

+ if (current - progress->last_update > progress->precision) {

+ progress->callback(progress->za, current, progress->ud);

+ progress->last_update = current;

+ }

+}

+

+

+ZIP_EXTERN int

+zip_register_progress_callback_with_state(zip_t *za, double precision, zip_progress_callback callback, void (*ud_free)(void *), void *ud) {

+ zip_progress_t *progress = NULL;

+

+ if (callback != NULL) {

+ if ((progress = _zip_progress_new(za, precision, callback, ud_free, ud)) == NULL) {

+ return -1;

+ }

+ }

+

+ _zip_progress_free(za->progress);

+ za->progress = progress;

+

+ return 0;

+}

+

+

+struct legacy_ud {

+ zip_progress_callback_t callback;

+};

+

+

+static void

+_zip_legacy_progress_callback(zip_t *za, double progress, void *vud) {

+ struct legacy_ud *ud = (struct legacy_ud *)vud;

+

+ ud->callback(progress);

+}

+

+ZIP_EXTERN void

+zip_register_progress_callback(zip_t *za, zip_progress_callback_t progress_callback) {

+ struct legacy_ud *ud;

+

+ if (progress_callback == NULL) {

+ zip_register_progress_callback_with_state(za, 0, NULL, NULL, NULL);

+ }

+

+ if ((ud = (struct legacy_ud *)malloc(sizeof(*ud))) == NULL) {

+ return;

+ }

+

+ ud->callback = progress_callback;

+

+ if (zip_register_progress_callback_with_state(za, 0.001, _zip_legacy_progress_callback, free, ud) < 0) {

+ free(ud);

+ }

+}

+

+zip_rename(zip_t *za, zip_uint64_t idx, const char *name) {

+

+zip_replace(zip_t *za, zip_uint64_t idx, zip_source_t *source) {

+

+zip_set_archive_comment(zip_t *za, const char *comment, zip_uint16_t len) {

+ if ((cstr = _zip_string_new((const zip_uint8_t *)comment, len, ZIP_FL_ENC_GUESS, &za->error)) == NULL)

+ if (((za->comment_orig && _zip_string_equal(za->comment_orig, cstr)) || (za->comment_orig == NULL && cstr == NULL))) {

+

+

+zip_set_archive_flag(zip_t *za, zip_flags_t flag, int value) {

+

+ if ((flag & ZIP_AFL_RDONLY) && value && (za->ch_flags & ZIP_AFL_RDONLY) == 0) {

+

+zip_set_default_password(zip_t *za, const char *passwd) {

+

+ if ((za->default_password = strdup(passwd)) == NULL) {

+

+zip_set_file_comment(zip_t *za, zip_uint64_t idx, const char *comment, int len) {