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

+1.7.3 [2020-07-15]

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

+

+* Support cmake < 3.17 again.

+* Fix pkgconfig file (regression in 1.7.2).

+

+1.7.2 [2020-07-11]

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

+

+* Fixes for the CMake `find_project()` files.

+* libzip moved to the CMake `libzip::` `NAMESPACE`.

+* CMake usage best practice cleanups.

+

+1.7.1 [2020-06-13]

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

+

+* Restore `LIBZIP_VERSION_{MAJOR,MINOR,MICRO}` symbols.

+* Fixes warnings reported by PVS-Studio.

+* Add `LIBZIP_DO_INSTALL` build setting to make it easier to use

+ libzip as subproject.

+

+1.7.0 [2020-06-05]

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

+

+* Add support for encrypting using traditional PKWare encryption.

+* Add `zip_compression_method_supported()`.

+* Add `zip_encryption_method_supported()`.

+* Add the `ZIP_SOURCE_GET_FILE_ATTRIBUTES` source command.

+* Refactor stdio file backend.

+* Add CMake find_project() support.

+

+1.6.1 [2020-02-03]

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

+

+* Bugfix for double-free in `zipcmp(1)` during cleanup.

+

+1.6.0 [2020-01-24]

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

+

+* Avoid using `umask()` since it's not thread-safe.

+* Set close-on-exec flag when opening files.

+* Do not accept empty files as valid zip archives any longer.

+* Add support for XZ compressed files (using liblzma).

+* Add support for cancelling while closing zip archives.

+* Add support for setting the time in the on-disk format.

+

+

+

+* on Windows, explicitly set dllimport/dllexport

+#define VERSION "1.7.3"

+#define _Nullable

+#define _Nonnull

+

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

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

+ 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_RESERVED_1, /* previously used internally */

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

+ ZIP_SOURCE_ACCEPT_EMPTY, /* whether empty files are valid archives */

+ ZIP_SOURCE_GET_FILE_ATTRIBUTES /* get additional file attributes */

+/* 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 *_Nullable str; /* string representation or NULL */

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

+ zip_uint8_t *_Nonnull data;

+struct zip_file_attributes {

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

+ zip_uint8_t version; /* version of this struct, currently 1 */

+ zip_uint8_t host_system; /* host system on which file was created */

+ zip_uint8_t ascii; /* flag whether file is ASCII text */

+ zip_uint8_t version_needed; /* minimum version needed to extract file */

+ zip_uint32_t external_file_attributes; /* external file attributes (host-system specific) */

+ zip_uint16_t general_purpose_bit_flags; /* general purpose big flags, only some bits are honored */

+ zip_uint16_t general_purpose_bit_mask; /* which bits in general_purpose_bit_flags are valid */

+};

+

+#define ZIP_FILE_ATTRIBUTES_HOST_SYSTEM 0x0001u

+#define ZIP_FILE_ATTRIBUTES_ASCII 0x0002u

+#define ZIP_FILE_ATTRIBUTES_VERSION_NEEDED 0x0004u

+#define ZIP_FILE_ATTRIBUTES_EXTERNAL_FILE_ATTRIBUTES 0x0008u

+#define ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS 0x0010u

+

+typedef struct zip_file_attributes zip_file_attributes_t;

+typedef zip_int64_t (*zip_source_callback)(void *_Nullable, void *_Nullable, zip_uint64_t, zip_source_cmd_t);

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

+typedef int (*zip_cancel_callback)(zip_t *_Nonnull, void *_Nullable);

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

+

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

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

+ZIP_EXTERN const char *_Nullable zip_get_file_comment(zip_t *_Nonnull, zip_uint64_t, int *_Nullable, int); /* use zip_file_get_comment */

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

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

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

+ZIP_EXTERN int zip_set_file_comment(zip_t *_Nonnull, zip_uint64_t, const char *_Nullable, 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 *_Nonnull, int *_Nullable, int *_Nullable); /* use zip_get_error, zip_error_code_zip / zip_error_code_system */

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

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

+ZIP_EXTERN int zip_close(zip_t *_Nonnull);

+ZIP_EXTERN int zip_delete(zip_t *_Nonnull, zip_uint64_t);

+ZIP_EXTERN zip_int64_t zip_dir_add(zip_t *_Nonnull, const char *_Nonnull, zip_flags_t);

+ZIP_EXTERN void zip_discard(zip_t *_Nonnull);

+

+ZIP_EXTERN zip_error_t *_Nonnull zip_get_error(zip_t *_Nonnull);

+ZIP_EXTERN void zip_error_clear(zip_t *_Nonnull);

+ZIP_EXTERN int zip_error_code_zip(const zip_error_t *_Nonnull);

+ZIP_EXTERN int zip_error_code_system(const zip_error_t *_Nonnull);

+ZIP_EXTERN void zip_error_fini(zip_error_t *_Nonnull);

+ZIP_EXTERN void zip_error_init(zip_error_t *_Nonnull);

+ZIP_EXTERN void zip_error_init_with_code(zip_error_t *_Nonnull, int);

+ZIP_EXTERN void zip_error_set(zip_error_t *_Nullable, int, int);

+ZIP_EXTERN const char *_Nonnull zip_error_strerror(zip_error_t *_Nonnull);

+ZIP_EXTERN int zip_error_system_type(const zip_error_t *_Nonnull);

+ZIP_EXTERN zip_int64_t zip_error_to_data(const zip_error_t *_Nonnull, void *_Nonnull, zip_uint64_t);

+

+ZIP_EXTERN int zip_fclose(zip_file_t *_Nonnull);

+ZIP_EXTERN zip_t *_Nullable zip_fdopen(int, int, int *_Nullable);

+ZIP_EXTERN zip_int64_t zip_file_add(zip_t *_Nonnull, const char *_Nonnull, zip_source_t *_Nonnull, zip_flags_t);

+ZIP_EXTERN void zip_file_attributes_init(zip_file_attributes_t *_Nonnull);

+ZIP_EXTERN void zip_file_error_clear(zip_file_t *_Nonnull);

+ZIP_EXTERN int zip_file_extra_field_delete(zip_t *_Nonnull, zip_uint64_t, zip_uint16_t, zip_flags_t);

+ZIP_EXTERN int zip_file_extra_field_delete_by_id(zip_t *_Nonnull, zip_uint64_t, zip_uint16_t, zip_uint16_t, zip_flags_t);

+ZIP_EXTERN int zip_file_extra_field_set(zip_t *_Nonnull, zip_uint64_t, zip_uint16_t, zip_uint16_t, const zip_uint8_t *_Nullable, zip_uint16_t, zip_flags_t);

+ZIP_EXTERN zip_int16_t zip_file_extra_fields_count(zip_t *_Nonnull, zip_uint64_t, zip_flags_t);

+ZIP_EXTERN zip_int16_t zip_file_extra_fields_count_by_id(zip_t *_Nonnull, zip_uint64_t, zip_uint16_t, zip_flags_t);

+ZIP_EXTERN const zip_uint8_t *_Nullable zip_file_extra_field_get(zip_t *_Nonnull, zip_uint64_t, zip_uint16_t, zip_uint16_t *_Nullable, zip_uint16_t *_Nullable, zip_flags_t);

+ZIP_EXTERN const zip_uint8_t *_Nullable zip_file_extra_field_get_by_id(zip_t *_Nonnull, zip_uint64_t, zip_uint16_t, zip_uint16_t, zip_uint16_t *_Nullable, zip_flags_t);

+ZIP_EXTERN const char *_Nullable zip_file_get_comment(zip_t *_Nonnull, zip_uint64_t, zip_uint32_t *_Nullable, zip_flags_t);

+ZIP_EXTERN zip_error_t *_Nonnull zip_file_get_error(zip_file_t *_Nonnull);

+ZIP_EXTERN int zip_file_get_external_attributes(zip_t *_Nonnull, zip_uint64_t, zip_flags_t, zip_uint8_t *_Nullable, zip_uint32_t *_Nullable);

+ZIP_EXTERN int zip_file_rename(zip_t *_Nonnull, zip_uint64_t, const char *_Nonnull, zip_flags_t);

+ZIP_EXTERN int zip_file_replace(zip_t *_Nonnull, zip_uint64_t, zip_source_t *_Nonnull, zip_flags_t);

+ZIP_EXTERN int zip_file_set_comment(zip_t *_Nonnull, zip_uint64_t, const char *_Nullable, zip_uint16_t, zip_flags_t);

+ZIP_EXTERN int zip_file_set_dostime(zip_t *_Nonnull, zip_uint64_t, zip_uint16_t, zip_uint16_t, zip_flags_t);

+ZIP_EXTERN int zip_file_set_encryption(zip_t *_Nonnull, zip_uint64_t, zip_uint16_t, const char *_Nullable);

+ZIP_EXTERN int zip_file_set_external_attributes(zip_t *_Nonnull, zip_uint64_t, zip_flags_t, zip_uint8_t, zip_uint32_t);

+ZIP_EXTERN int zip_file_set_mtime(zip_t *_Nonnull, zip_uint64_t, time_t, zip_flags_t);

+ZIP_EXTERN const char *_Nonnull zip_file_strerror(zip_file_t *_Nonnull);

+ZIP_EXTERN zip_file_t *_Nullable zip_fopen(zip_t *_Nonnull, const char *_Nonnull, zip_flags_t);

+ZIP_EXTERN zip_file_t *_Nullable zip_fopen_encrypted(zip_t *_Nonnull, const char *_Nonnull, zip_flags_t, const char *_Nullable);

+ZIP_EXTERN zip_file_t *_Nullable zip_fopen_index(zip_t *_Nonnull, zip_uint64_t, zip_flags_t);

+ZIP_EXTERN zip_file_t *_Nullable zip_fopen_index_encrypted(zip_t *_Nonnull, zip_uint64_t, zip_flags_t, const char *_Nullable);

+ZIP_EXTERN zip_int64_t zip_fread(zip_file_t *_Nonnull, void *_Nonnull, zip_uint64_t);

+ZIP_EXTERN zip_int8_t zip_fseek(zip_file_t *_Nonnull, zip_int64_t, int);

+ZIP_EXTERN zip_int64_t zip_ftell(zip_file_t *_Nonnull);

+ZIP_EXTERN const char *_Nullable zip_get_archive_comment(zip_t *_Nonnull, int *_Nullable, zip_flags_t);

+ZIP_EXTERN int zip_get_archive_flag(zip_t *_Nonnull, zip_flags_t, zip_flags_t);

+ZIP_EXTERN const char *_Nullable zip_get_name(zip_t *_Nonnull, zip_uint64_t, zip_flags_t);

+ZIP_EXTERN zip_int64_t zip_get_num_entries(zip_t *_Nonnull, zip_flags_t);

+ZIP_EXTERN const char *_Nonnull zip_libzip_version(void);

+ZIP_EXTERN zip_int64_t zip_name_locate(zip_t *_Nonnull, const char *_Nonnull, zip_flags_t);

+ZIP_EXTERN zip_t *_Nullable zip_open(const char *_Nonnull, int, int *_Nullable);

+ZIP_EXTERN zip_t *_Nullable zip_open_from_source(zip_source_t *_Nonnull, int, zip_error_t *_Nullable);

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

+ZIP_EXTERN int zip_register_cancel_callback_with_state(zip_t *_Nonnull, zip_cancel_callback _Nullable, void (*_Nullable)(void *_Nullable), void *_Nullable);

+ZIP_EXTERN int zip_set_archive_comment(zip_t *_Nonnull, const char *_Nullable, zip_uint16_t);

+ZIP_EXTERN int zip_set_archive_flag(zip_t *_Nonnull, zip_flags_t, int);

+ZIP_EXTERN int zip_set_default_password(zip_t *_Nonnull, const char *_Nullable);

+ZIP_EXTERN int zip_set_file_compression(zip_t *_Nonnull, zip_uint64_t, zip_int32_t, zip_uint32_t);

+ZIP_EXTERN int zip_source_begin_write(zip_source_t *_Nonnull);

+ZIP_EXTERN int zip_source_begin_write_cloning(zip_source_t *_Nonnull, zip_uint64_t);

+ZIP_EXTERN zip_source_t *_Nullable zip_source_buffer(zip_t *_Nonnull, const void *_Nullable, zip_uint64_t, int);

+ZIP_EXTERN zip_source_t *_Nullable zip_source_buffer_create(const void *_Nullable, zip_uint64_t, int, zip_error_t *_Nullable);

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

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

+ZIP_EXTERN int zip_source_close(zip_source_t *_Nonnull);

+ZIP_EXTERN int zip_source_commit_write(zip_source_t *_Nonnull);

+ZIP_EXTERN zip_error_t *_Nonnull zip_source_error(zip_source_t *_Nonnull);

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

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

+ZIP_EXTERN zip_source_t *_Nullable zip_source_filep(zip_t *_Nonnull, FILE *_Nonnull, zip_uint64_t, zip_int64_t);

+ZIP_EXTERN zip_source_t *_Nullable zip_source_filep_create(FILE *_Nonnull, zip_uint64_t, zip_int64_t, zip_error_t *_Nullable);

+ZIP_EXTERN void zip_source_free(zip_source_t *_Nullable);

+ZIP_EXTERN zip_source_t *_Nullable zip_source_function(zip_t *_Nonnull, zip_source_callback _Nonnull, void *_Nullable);

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

+ZIP_EXTERN int zip_source_get_file_attributes(zip_source_t *_Nonnull, zip_file_attributes_t *_Nonnull);

+ZIP_EXTERN int zip_source_is_deleted(zip_source_t *_Nonnull);

+ZIP_EXTERN void zip_source_keep(zip_source_t *_Nonnull);

+ZIP_EXTERN int zip_source_open(zip_source_t *_Nonnull);

+ZIP_EXTERN zip_int64_t zip_source_read(zip_source_t *_Nonnull, void *_Nonnull, zip_uint64_t);

+ZIP_EXTERN void zip_source_rollback_write(zip_source_t *_Nonnull);

+ZIP_EXTERN int zip_source_seek(zip_source_t *_Nonnull, zip_int64_t, int);

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

+ZIP_EXTERN int zip_source_seek_write(zip_source_t *_Nonnull, zip_int64_t, int);

+ZIP_EXTERN int zip_source_stat(zip_source_t *_Nonnull, zip_stat_t *_Nonnull);

+ZIP_EXTERN zip_int64_t zip_source_tell(zip_source_t *_Nonnull);

+ZIP_EXTERN zip_int64_t zip_source_tell_write(zip_source_t *_Nonnull);

+ZIP_EXTERN zip_int64_t zip_source_write(zip_source_t *_Nonnull, const void *_Nullable, zip_uint64_t);

+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_EXTERN int zip_stat(zip_t *_Nonnull, const char *_Nonnull, zip_flags_t, zip_stat_t *_Nonnull);

+ZIP_EXTERN int zip_stat_index(zip_t *_Nonnull, zip_uint64_t, zip_flags_t, zip_stat_t *_Nonnull);

+ZIP_EXTERN void zip_stat_init(zip_stat_t *_Nonnull);

+ZIP_EXTERN const char *_Nonnull zip_strerror(zip_t *_Nonnull);

+ZIP_EXTERN int zip_unchange(zip_t *_Nonnull, zip_uint64_t);

+ZIP_EXTERN int zip_unchange_all(zip_t *_Nonnull);

+ZIP_EXTERN int zip_unchange_archive(zip_t *_Nonnull);

+ZIP_EXTERN int zip_compression_method_supported(zip_int32_t method, int compress);

+ZIP_EXTERN int zip_encryption_method_supported(zip_uint16_t method, int encode);

+static zip_uint16_t

+general_purpose_bit_flags(void *ud) {

+ return 2 << 1;

+ return 1 << 1;

+/* clang-format off */

+ general_purpose_bit_flags,

+ 20,

+ general_purpose_bit_flags,

+ 20,

+/* clang-format on */

+static int add_data(zip_t *, zip_source_t *, zip_dirent_t *, zip_uint32_t);

+static int write_data_descriptor(zip_t *za, const zip_dirent_t *dirent, int is_zip64);

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

+ if (add_data(za, zs ? zs : entry->source, de, entry->changes ? entry->changes->changed : 0) < 0) {

+ if (de->encryption_method != ZIP_EM_TRAD_PKWARE) {

+ /* when copying data, all sizes are known -> no data descriptor needed */

+ /* except for PKWare encryption, where removing the data descriptor breaks password validation */

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

+ }

+ error = 1;

+ error = 1;

+

+ if (de->bitflags & ZIP_GPBF_DATA_DESCRIPTOR) {

+ if (write_data_descriptor(za, de, _zip_dirent_needs_zip64(de, 0)) < 0) {

+ error = 1;

+ break;

+ }

+ }

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

+ zip_stat_t st;

+ zip_file_attributes_t attributes;

+ if (de->encryption_method == ZIP_EM_TRAD_PKWARE) {

+ de->bitflags |= ZIP_GPBF_DATA_DESCRIPTOR;

+ }

+ if (zip_source_get_file_attributes(src_final, &attributes) != 0) {

+ _zip_dirent_apply_attributes(de, &attributes, (flags & ZIP_FL_FORCE_ZIP64) != 0, changed);

+ if (de->bitflags & ZIP_GPBF_DATA_DESCRIPTOR) {

+ if (write_data_descriptor(za, de, is_zip64) < 0) {

+ return -1;

+ }

+ }

+

+

+static int

+write_data_descriptor(zip_t *za, const zip_dirent_t *de, int is_zip64) {

+ zip_buffer_t *buffer = _zip_buffer_new(NULL, MAX_DATA_DESCRIPTOR_LENGTH);

+ int ret = 0;

+

+ if (buffer == NULL) {

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

+ return -1;

+ }

+

+ _zip_buffer_put(buffer, DATADES_MAGIC, 4);

+ _zip_buffer_put_32(buffer, de->crc);

+ if (is_zip64) {

+ _zip_buffer_put_64(buffer, de->comp_size);

+ _zip_buffer_put_64(buffer, de->uncomp_size);

+ }

+ else {

+ _zip_buffer_put_32(buffer, (zip_uint32_t)de->comp_size);

+ _zip_buffer_put_32(buffer, (zip_uint32_t)de->uncomp_size);

+ }

+

+ if (!_zip_buffer_ok(buffer)) {

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

+ ret = -1;

+ }

+ else {

+ ret = _zip_write(za, _zip_buffer_data(buffer), _zip_buffer_offset(buffer));

+ }

+

+ _zip_buffer_free(buffer);

+

+ return ret;

+}

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

+ }

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

+ }

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

+ }

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

+ }

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

+ _zip_buffer_free(ef_buffer);

+ if (!from_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ return -1;

+ return (zip_int64_t)size + (zip_int64_t)variable_size;

+ _zip_buffer_put_16(buffer, de->version_madeby);

+ _zip_buffer_put_16(buffer, ZIP_MAX(is_really_zip64 ? 45 : 0, de->version_needed));

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

+_zip_dirent_apply_attributes(zip_dirent_t *de, zip_file_attributes_t *attributes, bool force_zip64, zip_uint32_t changed) {

+ if (attributes->valid & ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS) {

+ zip_uint16_t mask = attributes->general_purpose_bit_mask & ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS_ALLOWED_MASK;

+ de->bitflags = (de->bitflags & ~mask) | (attributes->general_purpose_bit_flags & mask);

+ }

+ if (attributes->valid & ZIP_FILE_ATTRIBUTES_ASCII) {

+ de->int_attrib = (de->int_attrib & ~0x1) | (attributes->ascii ? 1 : 0);

+ }

+ /* manually set attributes are preferred over attributes provided by source */

+ if ((changed & ZIP_DIRENT_ATTRIBUTES) == 0 && (attributes->valid & ZIP_FILE_ATTRIBUTES_EXTERNAL_FILE_ATTRIBUTES)) {

+ de->ext_attrib = attributes->external_file_attributes;

+ }

+

+ else if (de->encryption_method == ZIP_EM_AES_128 || de->encryption_method == ZIP_EM_AES_192 || de->encryption_method == ZIP_EM_AES_256) {

+ de->version_needed = 51;

+ }

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

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

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

+ de->version_needed = 20;

+ }

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

+ }

+ else {

+ de->version_needed = 10;

+ if (attributes->valid & ZIP_FILE_ATTRIBUTES_VERSION_NEEDED) {

+ de->version_needed = ZIP_MAX(de->version_needed, attributes->version_needed);

+ de->version_madeby = 63 | (de->version_madeby & 0xff00);

+ if ((changed & ZIP_DIRENT_ATTRIBUTES) == 0 && (attributes->valid & ZIP_FILE_ATTRIBUTES_HOST_SYSTEM)) {

+ de->version_madeby = (de->version_madeby & 0xff) | (zip_uint16_t)(attributes->host_system << 8);

+ }

+#include <zlib.h>

+#include <zlib.h>

+ return operation == ZIP_CODEC_DECODE ? zip_source_pkware_decode : zip_source_pkware_encode;

+

+ZIP_EXTERN int

+zip_encryption_method_supported(zip_uint16_t method, int encode) {

+ if (method == ZIP_EM_NONE) {

+ return 1;

+ }

+ return _zip_get_encryption_implementation(method, encode ? ZIP_CODEC_ENCODE : ZIP_CODEC_DECODE) != NULL;

+}

+typedef enum { EXISTS_ERROR = -1, EXISTS_NOT = 0, EXISTS_OK } exists_t;

+/*

+ zip_pkware.c -- Traditional PKWARE de/encryption backend routines

+ Copyright (C) 2009-2020 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>

+#include <zlib.h>

+

+#include "zipint.h"

+

+#define PKWARE_KEY0 305419896

+#define PKWARE_KEY1 591751049

+#define PKWARE_KEY2 878082192

+

+

+static void

+update_keys(zip_pkware_keys_t *keys, zip_uint8_t b) {

+ keys->key[0] = (zip_uint32_t)crc32(keys->key[0] ^ 0xffffffffUL, &b, 1) ^ 0xffffffffUL;

+ keys->key[1] = (keys->key[1] + (keys->key[0] & 0xff)) * 134775813 + 1;

+ b = (zip_uint8_t)(keys->key[1] >> 24);

+ keys->key[2] = (zip_uint32_t)crc32(keys->key[2] ^ 0xffffffffUL, &b, 1) ^ 0xffffffffUL;

+}

+

+

+static zip_uint8_t

+crypt_byte(zip_pkware_keys_t *keys) {

+ zip_uint16_t tmp;

+ tmp = (zip_uint16_t)(keys->key[2] | 2);

+ tmp = (zip_uint16_t)(((zip_uint32_t)tmp * (tmp ^ 1)) >> 8);

+ return (zip_uint8_t)tmp;

+}

+

+

+void

+_zip_pkware_keys_reset(zip_pkware_keys_t *keys) {

+ keys->key[0] = PKWARE_KEY0;

+ keys->key[1] = PKWARE_KEY1;

+ keys->key[2] = PKWARE_KEY2;

+}

+

+

+void

+_zip_pkware_encrypt(zip_pkware_keys_t *keys, zip_uint8_t *out, const zip_uint8_t *in, zip_uint64_t len) {

+ zip_uint64_t i;

+ zip_uint8_t b;

+ zip_uint8_t tmp;

+

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

+ b = in[i];

+

+ if (out != NULL) {

+ tmp = crypt_byte(keys);

+ update_keys(keys, b);

+ b ^= tmp;

+ out[i] = b;

+ }

+ else {

+ /* during initialization, we're only interested in key updates */

+ update_keys(keys, b);

+ }

+ }

+}

+

+

+void

+_zip_pkware_decrypt(zip_pkware_keys_t *keys, zip_uint8_t *out, const zip_uint8_t *in, zip_uint64_t len) {

+ zip_uint64_t i;

+ zip_uint8_t b;

+ zip_uint8_t tmp;

+

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

+ b = in[i];

+

+ /* during initialization, we're only interested in key updates */

+ if (out != NULL) {

+ tmp = crypt_byte(keys);

+ b ^= tmp;

+ out[i] = b;

+ }

+

+ update_keys(keys, b);

+ }

+}

+ if (za->progress == NULL) {

+ if (za->progress == NULL) {

+ zip_file_attributes_t attributes;

+zip_source_t *zip_source_buffer_with_attributes_create(const void *data, zip_uint64_t len, int freep, zip_file_attributes_t *attributes, zip_error_t *error);

+zip_source_t *zip_source_buffer_fragment_with_attributes_create(const zip_buffer_fragment_t *fragments, zip_uint64_t nfragments, int freep, zip_file_attributes_t *attributes, zip_error_t *error);

+

+ return zip_source_buffer_with_attributes_create(data, len, freep, NULL, &za->error);

+ return zip_source_buffer_with_attributes_create(data, len, freep, NULL, error);

+}

+

+

+zip_source_t *

+zip_source_buffer_with_attributes_create(const void *data, zip_uint64_t len, int freep, zip_file_attributes_t *attributes, zip_error_t *error) {

+ if (len > 0) {

+ zip_error_set(error, ZIP_ER_INVAL, 0);

+ return NULL;

+ }

+ return zip_source_buffer_fragment_with_attributes_create(NULL, 0, freep, attributes, error);

+ return zip_source_buffer_fragment_with_attributes_create(&fragment, 1, freep, attributes, error);

+ return zip_source_buffer_fragment_with_attributes_create(fragments, nfragments, freep, NULL, &za->error);

+ return zip_source_buffer_fragment_with_attributes_create(fragments, nfragments, freep, NULL, error);

+}

+

+zip_source_t *

+zip_source_buffer_fragment_with_attributes_create(const zip_buffer_fragment_t *fragments, zip_uint64_t nfragments, int freep, zip_file_attributes_t *attributes, zip_error_t *error) {

+ if (attributes) {

+ memcpy(&ctx->attributes, attributes, sizeof(ctx->attributes));

+ }

+ else {

+ zip_file_attributes_init(&ctx->attributes);

+ }

+zip_source_t *

+zip_source_buffer_with_attributes(zip_t *za, const void *data, zip_uint64_t len, int freep, zip_file_attributes_t *attributes) {

+ return zip_source_buffer_with_attributes_create(data, len, freep, attributes, &za->error);

+}

+

+ case ZIP_SOURCE_GET_FILE_ATTRIBUTES: {

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

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

+ return -1;

+ }

+

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

+

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

+ /* Disabled - because 7z isn't able to unpack ZIP+LZMA ZIP+LZMA2

+ archives made this way - and vice versa.

+ {ZIP_CM_LZMA, &zip_algorithm_xz_compress, &zip_algorithm_xz_decompress},

+ {ZIP_CM_LZMA2, &zip_algorithm_xz_compress, &zip_algorithm_xz_decompress},

+ */

+ZIP_EXTERN int

+zip_compression_method_supported(zip_int32_t method, int compress) {

+ return 1;

+ case ZIP_SOURCE_GET_FILE_ATTRIBUTES: {

+ zip_file_attributes_t *attributes = (zip_file_attributes_t *)data;

+

+ if (len < sizeof(*attributes)) {

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

+ return -1;

+ }

+

+ attributes->valid |= ZIP_FILE_ATTRIBUTES_VERSION_NEEDED | ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS;

+ attributes->version_needed = ctx->algorithm->version_needed;

+ attributes->general_purpose_bit_mask = ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS_ALLOWED_MASK;

+ attributes->general_purpose_bit_flags = (ctx->is_stored ? 0 : ctx->algorithm->general_purpose_bit_flags(ctx->ud));

+

+ return sizeof(*attributes);

+ }

+

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

+#include <zlib.h>

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

+/*

+ zip_source_file.h -- header for common file operations

+ Copyright (C) 2020 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.

+*/

+

+struct zip_source_file_stat {

+ zip_uint64_t size; /* must be valid for regular files */

+ time_t mtime; /* must always be valid, is initialized to current time */

+ bool exists; /* must always be vaild */

+ bool regular_file; /* must always be valid */

+};

+

+typedef struct zip_source_file_context zip_source_file_context_t;

+typedef struct zip_source_file_operations zip_source_file_operations_t;

+typedef struct zip_source_file_stat zip_source_file_stat_t;

+

+struct zip_source_file_context {

+ zip_error_t error; /* last error information */

+ zip_int64_t supports;

+

+ /* reading */

+ char *fname; /* name of file to read from */

+ void *f; /* file to read from */

+ zip_stat_t st; /* stat information passed in */

+ zip_file_attributes_t attributes; /* additional file attributes */

+ zip_error_t stat_error; /* error returned for stat */

+ zip_uint64_t start; /* start offset of data to read */

+ zip_uint64_t len; /* length of the file, 0 for up to EOF */

+ zip_uint64_t offset; /* current offset relative to start (0 is beginning of part we read) */

+

+ /* writing */

+ char *tmpname;

+ void *fout;

+

+ zip_source_file_operations_t *ops;

+ void *ops_userdata;

+};

+

+

+/* The following methods must be implemented to support each feature:

+ - close, read, seek, and stat must always be implemented.

+ - To support specifying the file by name, open, and strdup must be implemented.

+ - For write support, the file must be specified by name and close, commit_write, create_temp_output, remove, rollback_write, and tell must be implemented.

+ - create_temp_output_cloning is always optional. */

+

+struct zip_source_file_operations {

+ void (*close)(zip_source_file_context_t *ctx);

+ zip_int64_t (*commit_write)(zip_source_file_context_t *ctx);

+ zip_int64_t (*create_temp_output)(zip_source_file_context_t *ctx);

+ zip_int64_t (*create_temp_output_cloning)(zip_source_file_context_t *ctx, zip_uint64_t len);

+ bool (*open)(zip_source_file_context_t *ctx);

+ zip_int64_t (*read)(zip_source_file_context_t *ctx, void *buf, zip_uint64_t len);

+ zip_int64_t (*remove)(zip_source_file_context_t *ctx);

+ void (*rollback_write)(zip_source_file_context_t *ctx);

+ bool (*seek)(zip_source_file_context_t *ctx, void *f, zip_int64_t offset, int whence);

+ bool (*stat)(zip_source_file_context_t *ctx, zip_source_file_stat_t *st);

+ char *(*string_duplicate)(zip_source_file_context_t *ctx, const char *);

+ zip_int64_t (*tell)(zip_source_file_context_t *ctx, void *f);

+ zip_int64_t (*write)(zip_source_file_context_t *ctx, const void *data, zip_uint64_t len);

+};

+

+zip_source_t *zip_source_file_common_new(const char *fname, void *file, zip_uint64_t start, zip_int64_t len, const zip_stat_t *st, zip_source_file_operations_t *ops, void *ops_userdata, zip_error_t *error);

+/*

+ zip_source_file_common.c -- create data source from file

+ Copyright (C) 1999-2019 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 <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+

+#include "zipint.h"

+

+#include "zip_source_file.h"

+

+static zip_int64_t read_file(void *state, void *data, zip_uint64_t len, zip_source_cmd_t cmd);

+

+static void

+zip_source_file_stat_init(zip_source_file_stat_t *st) {

+ st->size = 0;

+ st->mtime = time(NULL);

+ st->exists = false;

+ st->regular_file = false;

+}

+

+zip_source_t *

+zip_source_file_common_new(const char *fname, void *file, zip_uint64_t start, zip_int64_t len, const zip_stat_t *st, zip_source_file_operations_t *ops, void *ops_userdata, zip_error_t *error) {

+ zip_source_file_context_t *ctx;

+ zip_source_t *zs;

+ zip_source_file_stat_t sb;

+

+ if (ops == NULL) {

+ zip_error_set(error, ZIP_ER_INVAL, 0);

+ return NULL;

+ }

+

+ if (ops->close == NULL || ops->read == NULL || ops->seek == NULL || ops->stat == NULL) {

+ zip_error_set(error, ZIP_ER_INTERNAL, 0);

+ return NULL;

+ }

+

+ if (ops->write != NULL && (ops->commit_write == NULL || ops->create_temp_output == NULL || ops->remove == NULL || ops->rollback_write == NULL || ops->tell == NULL)) {

+ zip_error_set(error, ZIP_ER_INTERNAL, 0);

+ return NULL;

+ }

+

+ if (fname != NULL) {

+ if (ops->open == NULL || ops->string_duplicate == NULL) {

+ zip_error_set(error, ZIP_ER_INTERNAL, 0);

+ return NULL;

+ }

+ }

+ else if (file == NULL) {

+ zip_error_set(error, ZIP_ER_INVAL, 0);

+ return NULL;

+ }

+

+ if (len < 0) {

+ len = 0;

+ }

+

+ if (start > ZIP_INT64_MAX || start + (zip_uint64_t)len < start) {

+ zip_error_set(error, ZIP_ER_INVAL, 0);

+ return NULL;

+ }

+

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

+ zip_error_set(error, ZIP_ER_MEMORY, 0);

+ return NULL;

+ }

+

+ ctx->ops = ops;

+ ctx->ops_userdata = ops_userdata;

+ ctx->fname = NULL;

+ if (fname) {

+ if ((ctx->fname = ops->string_duplicate(ctx, fname)) == NULL) {

+ zip_error_set(error, ZIP_ER_MEMORY, 0);

+ free(ctx);

+ return NULL;

+ }

+ }

+ ctx->f = file;

+ ctx->start = start;

+ ctx->len = (zip_uint64_t)len;

+ if (st) {

+ memcpy(&ctx->st, st, sizeof(ctx->st));

+ ctx->st.name = NULL;

+ ctx->st.valid &= ~ZIP_STAT_NAME;

+ }

+ else {

+ zip_stat_init(&ctx->st);

+ }

+

+ if (ctx->len > 0) {

+ ctx->st.size = ctx->len;

+ ctx->st.valid |= ZIP_STAT_SIZE;

+ }

+

+ zip_error_init(&ctx->stat_error);

+

+ ctx->tmpname = NULL;

+ ctx->fout = NULL;

+

+ zip_error_init(&ctx->error);

+ zip_file_attributes_init(&ctx->attributes);

+

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

+

+ zip_source_file_stat_init(&sb);

+ if (!ops->stat(ctx, &sb)) {

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

+ free(ctx->fname);

+ free(ctx);

+ return NULL;

+ }

+

+ if (!sb.exists) {

+ if (ctx->fname && ctx->start == 0 && ctx->len == 0 && ops->write != NULL) {

+ ctx->supports = ZIP_SOURCE_SUPPORTS_WRITABLE;

+ /* zip_open_from_source checks for this to detect non-existing files */

+ zip_error_set(&ctx->stat_error, ZIP_ER_READ, ENOENT);

+ }

+ else {

+ zip_error_set(&ctx->stat_error, ZIP_ER_READ, ENOENT);

+ free(ctx->fname);

+ free(ctx);

+ return NULL;

+ }

+ }

+ else {

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

+ ctx->st.mtime = sb.mtime;

+ ctx->st.valid |= ZIP_STAT_MTIME;

+ }

+ if (sb.regular_file) {

+ ctx->supports = ZIP_SOURCE_SUPPORTS_SEEKABLE;

+

+ if (ctx->start + ctx->len > sb.size) {

+ zip_error_set(error, ZIP_ER_INVAL, 0);

+ free(ctx->fname);

+ free(ctx);

+ return NULL;

+ }

+

+ if (ctx->len == 0) {

+ ctx->len = sb.size - ctx->start;

+ ctx->st.size = ctx->len;

+ ctx->st.valid |= ZIP_STAT_SIZE;

+

+ /* when using a partial file, don't allow writing */

+ if (ctx->fname && start == 0 && ops->write != NULL) {

+ ctx->supports = ZIP_SOURCE_SUPPORTS_WRITABLE;

+ }

+ }

+ }

+

+ ctx->supports |= ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_GET_FILE_ATTRIBUTES);

+ }

+

+ ctx->supports |= ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_ACCEPT_EMPTY);

+ if (ops->create_temp_output_cloning != NULL) {

+ if (ctx->supports & ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_BEGIN_WRITE)) {

+ ctx->supports |= ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_BEGIN_WRITE_CLONING);

+ }

+ }

+

+ if ((zs = zip_source_function_create(read_file, ctx, error)) == NULL) {

+ free(ctx->fname);

+ free(ctx);

+ return NULL;

+ }

+

+ return zs;

+}

+

+

+static zip_int64_t

+read_file(void *state, void *data, zip_uint64_t len, zip_source_cmd_t cmd) {

+ zip_source_file_context_t *ctx;

+ char *buf;

+

+ ctx = (zip_source_file_context_t *)state;

+ buf = (char *)data;

+

+ switch (cmd) {

+ case ZIP_SOURCE_ACCEPT_EMPTY:

+ return 0;

+

+ case ZIP_SOURCE_BEGIN_WRITE:

+ /* write support should not be set if fname is NULL */

+ if (ctx->fname == NULL) {

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

+ return -1;

+ }

+ return ctx->ops->create_temp_output(ctx);

+

+ case ZIP_SOURCE_BEGIN_WRITE_CLONING:

+ /* write support should not be set if fname is NULL */

+ if (ctx->fname == NULL) {

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

+ return -1;

+ }

+ return ctx->ops->create_temp_output_cloning(ctx, len);

+

+ case ZIP_SOURCE_CLOSE:

+ if (ctx->fname) {

+ ctx->ops->close(ctx);

+ ctx->f = NULL;

+ }

+ return 0;

+

+ case ZIP_SOURCE_COMMIT_WRITE: {

+ zip_int64_t ret = ctx->ops->commit_write(ctx);

+ ctx->fout = NULL;

+ if (ret == 0) {

+ free(ctx->tmpname);

+ ctx->tmpname = NULL;

+ }

+ return ret;

+ }

+

+ case ZIP_SOURCE_ERROR:

+ return zip_error_to_data(&ctx->error, data, len);

+

+ case ZIP_SOURCE_FREE:

+ free(ctx->fname);

+ free(ctx->tmpname);

+ if (ctx->f) {

+ ctx->ops->close(ctx);

+ }

+ free(ctx);

+ return 0;

+

+ case ZIP_SOURCE_GET_FILE_ATTRIBUTES:

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

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

+ return -1;

+ }

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

+ return sizeof(ctx->attributes);

+

+ case ZIP_SOURCE_OPEN:

+ if (ctx->fname) {

+ if (ctx->ops->open(ctx) == false) {

+ return -1;

+ }

+ }

+

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

+ if (ctx->ops->seek(ctx, ctx->f, (zip_int64_t)ctx->start, SEEK_SET) == false) {

+ /* TODO: skip by reading */

+ return -1;

+ }

+ }

+ ctx->offset = 0;

+ return 0;

+

+ case ZIP_SOURCE_READ: {

+ zip_int64_t i;

+ zip_uint64_t n;

+

+ if (ctx->len > 0) {

+ n = ZIP_MIN(ctx->len - ctx->offset, len);

+ }

+ else {

+ n = len;

+ }

+

+ if ((i = ctx->ops->read(ctx, buf, n)) < 0) {

+ zip_error_set(&ctx->error, ZIP_ER_READ, errno);

+ return -1;

+ }

+ ctx->offset += (zip_uint64_t)i;

+

+ return i;

+ }

+

+ case ZIP_SOURCE_REMOVE:

+ return ctx->ops->remove(ctx);

+

+ case ZIP_SOURCE_ROLLBACK_WRITE:

+ ctx->ops->rollback_write(ctx);

+ ctx->fout = NULL;

+ free(ctx->tmpname);

+ ctx->tmpname = NULL;

+ return 0;

+

+ case ZIP_SOURCE_SEEK: {

+ zip_int64_t new_offset = zip_source_seek_compute_offset(ctx->offset, ctx->len, data, len, &ctx->error);

+

+ if (new_offset < 0) {

+ return -1;

+ }

+

+ /* The actual offset inside the file must be representable as zip_int64_t. */

+ if (new_offset > ZIP_INT64_MAX - (zip_int64_t)ctx->start) {

+ zip_error_set(&ctx->error, ZIP_ER_SEEK, EOVERFLOW);

+ return -1;

+ }

+

+ ctx->offset = (zip_uint64_t)new_offset;

+

+ if (ctx->ops->seek(ctx, ctx->f, (zip_int64_t)(ctx->offset + ctx->start), SEEK_SET) == false) {

+ return -1;

+ }

+ return 0;

+ }

+

+ case ZIP_SOURCE_SEEK_WRITE: {

+ zip_source_args_seek_t *args;

+

+ args = ZIP_SOURCE_GET_ARGS(zip_source_args_seek_t, data, len, &ctx->error);

+ if (args == NULL) {

+ return -1;

+ }

+

+ if (ctx->ops->seek(ctx, ctx->fout, args->offset, args->whence) == false) {

+ return -1;

+ }

+ return 0;

+ }

+

+ case ZIP_SOURCE_STAT: {

+ if (len < sizeof(ctx->st))

+ return -1;

+

+ if (zip_error_code_zip(&ctx->stat_error) != 0) {

+ zip_error_set(&ctx->error, zip_error_code_zip(&ctx->stat_error), zip_error_code_system(&ctx->stat_error));

+ return -1;

+ }

+

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

+ return sizeof(ctx->st);

+ }

+

+ case ZIP_SOURCE_SUPPORTS:

+ return ctx->supports;

+

+ case ZIP_SOURCE_TELL:

+ return (zip_int64_t)ctx->offset;

+

+ case ZIP_SOURCE_TELL_WRITE:

+ return ctx->ops->tell(ctx, ctx->fout);

+

+ case ZIP_SOURCE_WRITE:

+ return ctx->ops->write(ctx, data, len);

+

+ default:

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

+ return -1;

+ }

+}

+/*

+ zip_source_file_stdio.c -- read-only stdio file source implementation

+ Copyright (C) 2020 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 "zip_source_file.h"

+#include "zip_source_file_stdio.h"

+

+#include <fcntl.h>

+#include <stdio.h>

+#include <stdlib.h>

+#include <sys/stat.h>

+

+#ifdef _WIN32

+#ifndef S_IWUSR

+#define S_IWUSR _S_IWRITE

+#endif

+#endif

+

+/* clang-format off */

+static zip_source_file_operations_t ops_stdio_read = {

+ _zip_stdio_op_close,

+ NULL,

+ NULL,

+ NULL,

+ NULL,

+ _zip_stdio_op_read,

+ NULL,

+ NULL,

+ _zip_stdio_op_seek,

+ _zip_stdio_op_stat,

+ NULL,

+ _zip_stdio_op_tell,

+ NULL

+};

+/* clang-format on */

+

+

+ZIP_EXTERN zip_source_t *

+zip_source_filep(zip_t *za, FILE *file, zip_uint64_t start, zip_int64_t len) {

+ if (za == NULL) {

+ return NULL;

+ }

+

+ return zip_source_filep_create(file, start, len, &za->error);

+}

+

+

+ZIP_EXTERN zip_source_t *

+zip_source_filep_create(FILE *file, zip_uint64_t start, zip_int64_t length, zip_error_t *error) {

+ if (file == NULL || length < -1) {

+ zip_error_set(error, ZIP_ER_INVAL, 0);

+ return NULL;

+ }

+

+ return zip_source_file_common_new(NULL, file, start, length, NULL, &ops_stdio_read, NULL, error);

+}

+

+

+void

+_zip_stdio_op_close(zip_source_file_context_t *ctx) {

+ fclose((FILE *)ctx->f);

+}

+

+

+zip_int64_t

+_zip_stdio_op_read(zip_source_file_context_t *ctx, void *buf, zip_uint64_t len) {

+ size_t i;

+ if (len > SIZE_MAX) {

+ len = SIZE_MAX;

+ }

+

+ if ((i = fread(buf, 1, (size_t)len, ctx->f)) == 0) {

+ if (ferror((FILE *)ctx->f)) {

+ zip_error_set(&ctx->error, ZIP_ER_READ, errno);

+ return -1;

+ }

+ }

+

+ return (zip_int64_t)i;

+}

+

+

+bool

+_zip_stdio_op_seek(zip_source_file_context_t *ctx, void *f, zip_int64_t offset, int whence) {

+#if ZIP_FSEEK_MAX > ZIP_INT64_MAX

+ if (offset > ZIP_FSEEK_MAX || offset < ZIP_FSEEK_MIN) {

+ zip_error_set(&ctx->error, ZIP_ER_SEEK, EOVERFLOW);

+ return false;

+ }

+#endif

+

+ if (fseeko((FILE *)f, (off_t)offset, whence) < 0) {

+ zip_error_set(&ctx->error, ZIP_ER_SEEK, errno);

+ return false;

+ }

+ return true;

+}

+

+

+bool

+_zip_stdio_op_stat(zip_source_file_context_t *ctx, zip_source_file_stat_t *st) {

+ struct stat sb;

+

+ int ret;

+

+ if (ctx->fname) {

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

+ }

+ else {

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

+ }

+

+ if (ret < 0) {

+ if (errno == ENOENT) {

+ st->exists = false;

+ return true;

+ }

+ zip_error_set(&ctx->error, ZIP_ER_READ, errno);

+ return false;

+ }

+

+ st->size = (zip_uint64_t)sb.st_size;

+ st->mtime = sb.st_mtime;

+

+ st->regular_file = S_ISREG(sb.st_mode);

+ st->exists = true;

+

+ /* We're using UNIX file API, even on Windows; thus, we supply external file attributes with Unix values. */

+ /* TODO: This could be improved on Windows by providing Windows-specific file attributes */

+ ctx->attributes.valid = ZIP_FILE_ATTRIBUTES_HOST_SYSTEM | ZIP_FILE_ATTRIBUTES_EXTERNAL_FILE_ATTRIBUTES;

+ ctx->attributes.host_system = ZIP_OPSYS_UNIX;

+ ctx->attributes.external_file_attributes = (((zip_uint32_t)sb.st_mode) << 16) | ((sb.st_mode & S_IWUSR) ? 0 : 1);

+

+ return true;

+}

+

+

+zip_int64_t

+_zip_stdio_op_tell(zip_source_file_context_t *ctx, void *f) {

+ off_t offset = ftello((FILE *)f);

+

+ if (offset < 0) {

+ zip_error_set(&ctx->error, ZIP_ER_SEEK, errno);

+ }

+

+ return offset;

+}

+

+

+/*

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

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

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

+ */

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

+}

+#ifndef _HAD_ZIP_SOURCE_FILE_STDIO_H

+#define _HAD_ZIP_SOURCE_FILE_STDIO_H

+

+ zip_source_file_stdio.h -- common header for stdio file implementation

+ Copyright (C) 2020 Dieter Baron and Thomas Klausner

+#include <stdio.h>

+

+void _zip_stdio_op_close(zip_source_file_context_t *ctx);

+zip_int64_t _zip_stdio_op_read(zip_source_file_context_t *ctx, void *buf, zip_uint64_t len);

+bool _zip_stdio_op_seek(zip_source_file_context_t *ctx, void *f, zip_int64_t offset, int whence);

+bool _zip_stdio_op_stat(zip_source_file_context_t *ctx, zip_source_file_stat_t *st);

+zip_int64_t _zip_stdio_op_tell(zip_source_file_context_t *ctx, void *f);

+

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

+#endif /* _HAD_ZIP_SOURCE_FILE_STDIO_H */

+/*

+ zip_source_file_win32.c -- read-only Windows file source implementation

+ Copyright (C) 1999-2020 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 "zip_source_file_win32.h"

+

+static bool _zip_win32_op_stat(zip_source_file_context_t *ctx, zip_source_file_stat_t *st);

+

+static bool _zip_stat_win32(zip_source_file_context_t *ctx, zip_source_file_stat_t *st, HANDLE h);

+

+static zip_source_file_operations_t ops_win32_read = {

+ _zip_win32_op_close,

+ NULL,

+ NULL,

+ NULL,

+ NULL,

+ _zip_win32_op_read,

+ NULL,

+ NULL,

+ _zip_win32_op_seek,

+ _zip_win32_op_stat,

+ NULL,

+ _zip_win32_op_tell,

+ NULL

+};

+

+

+ZIP_EXTERN zip_source_t *

+zip_source_win32handle(zip_t *za, HANDLE h, zip_uint64_t start, zip_int64_t len) {

+ if (za == NULL) {

+ return NULL;

+ }

+

+ return zip_source_win32handle_create(h, start, len, &za->error);

+}

+

+

+ZIP_EXTERN zip_source_t *

+zip_source_win32handle_create(HANDLE h, zip_uint64_t start, zip_int64_t length, zip_error_t *error) {

+ if (h == INVALID_HANDLE_VALUE || length < -1) {

+ zip_error_set(error, ZIP_ER_INVAL, 0);

+ return NULL;

+ }

+

+ return zip_source_file_common_new(NULL, h, start, length, NULL, &ops_win32_read, NULL, error);

+}

+

+

+void

+_zip_win32_op_close(zip_source_file_context_t *ctx) {

+ CloseHandle((HANDLE)ctx->f);

+}

+

+

+zip_int64_t

+_zip_win32_op_read(zip_source_file_context_t *ctx, void *buf, zip_uint64_t len) {

+ DWORD i;

+

+ /* TODO: cap len to "DWORD_MAX" */

+ if (!ReadFile((HANDLE)ctx->f, buf, (DWORD)len, &i, NULL)) {

+ zip_error_set(&ctx->error, ZIP_ER_READ, _zip_win32_error_to_errno(GetLastError()));

+ return -1;

+ }

+

+ return (zip_int64_t)i;

+}

+

+

+bool

+_zip_win32_op_seek(zip_source_file_context_t *ctx, void *f, zip_int64_t offset, int whence) {

+ LARGE_INTEGER li;

+ DWORD method;

+

+ switch (whence) {

+ case SEEK_SET:

+ method = FILE_BEGIN;

+ break;

+ case SEEK_END:

+ method = FILE_END;

+ break;

+ case SEEK_CUR:

+ method = FILE_CURRENT;

+ break;

+ default:

+ zip_error_set(&ctx->error, ZIP_ER_SEEK, EINVAL);

+ return -1;

+ }

+

+ li.QuadPart = (LONGLONG)offset;

+ if (!SetFilePointerEx((HANDLE)f, li, NULL, method)) {

+ zip_error_set(&ctx->error, ZIP_ER_SEEK, _zip_win32_error_to_errno(GetLastError()));

+ return false;

+ }

+

+ return true;

+}

+

+

+static bool

+_zip_win32_op_stat(zip_source_file_context_t *ctx, zip_source_file_stat_t *st) {

+ return _zip_stat_win32(ctx, st, (HANDLE)ctx->f);

+}

+

+

+zip_int64_t

+_zip_win32_op_tell(zip_source_file_context_t *ctx, void *f) {

+ LARGE_INTEGER zero;

+ LARGE_INTEGER new_offset;

+

+ zero.QuadPart = 0;

+ if (!SetFilePointerEx((HANDLE)f, zero, &new_offset, FILE_CURRENT)) {

+ zip_error_set(&ctx->error, ZIP_ER_SEEK, _zip_win32_error_to_errno(GetLastError()));

+ return -1;

+ }

+

+ return (zip_int64_t)new_offset.QuadPart;

+}

+

+

+int

+_zip_win32_error_to_errno(DWORD win32err) {

+ /* Note: This list isn't exhaustive, but should cover common cases. */

+ switch (win32err) {

+ case ERROR_INVALID_PARAMETER:

+ return EINVAL;

+ case ERROR_FILE_NOT_FOUND:

+ return ENOENT;

+ case ERROR_INVALID_HANDLE:

+ return EBADF;

+ case ERROR_ACCESS_DENIED:

+ return EACCES;

+ case ERROR_FILE_EXISTS:

+ return EEXIST;

+ case ERROR_TOO_MANY_OPEN_FILES:

+ return EMFILE;

+ case ERROR_DISK_FULL:

+ return ENOSPC;

+ default:

+ return 10000 + win32err;

+ }

+}

+

+

+static bool

+_zip_stat_win32(zip_source_file_context_t *ctx, zip_source_file_stat_t *st, HANDLE h) {

+ FILETIME mtimeft;

+ time_t mtime;

+ LARGE_INTEGER size;

+

+ if (!GetFileTime(h, NULL, NULL, &mtimeft)) {

+ zip_error_set(&ctx->error, ZIP_ER_READ, _zip_win32_error_to_errno(GetLastError()));

+ return false;

+ }

+ if (_zip_filetime_to_time_t(mtimeft, &mtime) < 0) {

+ zip_error_set(&ctx->error, ZIP_ER_READ, ERANGE);

+ return false;

+ }

+

+ st->exists = true;

+ st->mtime = mtime;

+

+ if (GetFileType(h) == FILE_TYPE_DISK) {

+ st->regular_file = 1;

+

+ if (!GetFileSizeEx(h, &size)) {

+ zip_error_set(&ctx->error, ZIP_ER_READ, _zip_win32_error_to_errno(GetLastError()));

+ return false;

+ }

+

+ st->size = (zip_uint64_t)size.QuadPart;

+ }

+

+ /* TODO: fill in ctx->attributes */

+

+ return true;

+}

+

+

+bool

+_zip_filetime_to_time_t(FILETIME ft, time_t *t) {

+ /*

+ Inspired by http://stackoverflow.com/questions/6161776/convert-windows-filetime-to-second-in-unix-linux

+ */

+ const zip_int64_t WINDOWS_TICK = 10000000LL;

+ const zip_int64_t SEC_TO_UNIX_EPOCH = 11644473600LL;

+ ULARGE_INTEGER li;

+ zip_int64_t secs;

+ time_t temp;

+

+ li.LowPart = ft.dwLowDateTime;

+ li.HighPart = ft.dwHighDateTime;

+ secs = (li.QuadPart / WINDOWS_TICK - SEC_TO_UNIX_EPOCH);

+

+ temp = (time_t)secs;

+ if (secs != (zip_int64_t)temp) {

+ return false;

+ }

+

+ *t = temp;

+ return true;

+}

+#ifndef _HAD_ZIP_SOURCE_FILE_WIN32_H

+#define _HAD_ZIP_SOURCE_FILE_WIN32_H

+

+/*

+ zip_source_file_win32.h -- common header for Windows file implementation

+ Copyright (C) 2020 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.

+*/

+

+/* 0x0501 => Windows XP; needs to be at least this value because of GetFileSizeEx */

+#if !defined(MS_UWP) && !defined(_WIN32_WINNT)

+#define _WIN32_WINNT 0x0501

+#endif

+

+#include <windows.h>

+

+#include <aclapi.h>

+

+#include "zipint.h"

+

+#include "zip_source_file.h"

+

+struct zip_win32_file_operations {

+ char *(*allocate_tempname)(const char *name, size_t extra_chars, size_t *lengthp);

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

+ BOOL (__stdcall *delete_file)(const void *name);

+ DWORD (__stdcall *get_file_attributes)(const void *name);

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

+ void (*make_tempname)(char *buf, size_t len, const char *name, zip_uint32_t i);

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

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

+ char *(*string_duplicate)(const char *string);

+};

+

+typedef struct zip_win32_file_operations zip_win32_file_operations_t;

+

+extern zip_source_file_operations_t _zip_source_file_win32_named_ops;

+

+void _zip_win32_op_close(zip_source_file_context_t *ctx);

+zip_int64_t _zip_win32_op_read(zip_source_file_context_t *ctx, void *buf, zip_uint64_t len);

+bool _zip_win32_op_seek(zip_source_file_context_t *ctx, void *f, zip_int64_t offset, int whence);

+zip_int64_t _zip_win32_op_tell(zip_source_file_context_t *ctx, void *f);

+

+bool _zip_filetime_to_time_t(FILETIME ft, time_t *t);

+int _zip_win32_error_to_errno(DWORD win32err);

+

+#endif /* _HAD_ZIP_SOURCE_FILE_WIN32_H */

+/*

+ zip_source_file_win32_named.c -- source for Windows file opened by name

+ Copyright (C) 1999-2020 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 "zip_source_file_win32.h"

+

+static zip_int64_t _zip_win32_named_op_commit_write(zip_source_file_context_t *ctx);

+static zip_int64_t _zip_win32_named_op_create_temp_output(zip_source_file_context_t *ctx);

+static bool _zip_win32_named_op_open(zip_source_file_context_t *ctx);

+static zip_int64_t _zip_win32_named_op_remove(zip_source_file_context_t *ctx);

+static void _zip_win32_named_op_rollback_write(zip_source_file_context_t *ctx);

+static bool _zip_win32_named_op_stat(zip_source_file_context_t *ctx, zip_source_file_stat_t *st);

+static char *_zip_win32_named_op_string_duplicate(zip_source_file_context_t *ctx, const char *string);

+static zip_int64_t _zip_win32_named_op_write(zip_source_file_context_t *ctx, const void *data, zip_uint64_t len);

+

+static HANDLE win32_named_open(zip_source_file_context_t *ctx, const char *name, bool temporary, PSECURITY_ATTRIBUTES security_attributes);

+

+/* clang-format off */

+zip_source_file_operations_t _zip_source_file_win32_named_ops = {

+ _zip_win32_op_close,

+ _zip_win32_named_op_commit_write,

+ _zip_win32_named_op_create_temp_output,

+ NULL,

+ _zip_win32_named_op_open,

+ _zip_win32_op_read,

+ _zip_win32_named_op_remove,

+ _zip_win32_named_op_rollback_write,

+ _zip_win32_op_seek,

+ _zip_win32_named_op_stat,

+ _zip_win32_named_op_string_duplicate,

+ _zip_win32_op_tell,

+ _zip_win32_named_op_write

+};

+/* clang-format on */

+

+static zip_int64_t

+_zip_win32_named_op_commit_write(zip_source_file_context_t *ctx) {

+ zip_win32_file_operations_t *file_ops = (zip_win32_file_operations_t *)ctx->ops_userdata;

+ DWORD attributes;

+

+ if (!CloseHandle((HANDLE)ctx->fout)) {

+ zip_error_set(&ctx->error, ZIP_ER_WRITE, _zip_win32_error_to_errno(GetLastError()));

+ return -1;

+ }

+

+ attributes = file_ops->get_file_attributes(ctx->tmpname);

+ if (attributes == INVALID_FILE_ATTRIBUTES) {

+ zip_error_set(&ctx->error, ZIP_ER_RENAME, _zip_win32_error_to_errno(GetLastError()));

+ return -1;

+ }

+

+ if (attributes & FILE_ATTRIBUTE_TEMPORARY) {

+ if (!file_ops->set_file_attributes(ctx->tmpname, attributes & ~FILE_ATTRIBUTE_TEMPORARY)) {

+ zip_error_set(&ctx->error, ZIP_ER_RENAME, _zip_win32_error_to_errno(GetLastError()));

+ return -1;

+ }

+ }

+

+ if (!file_ops->move_file(ctx->tmpname, ctx->fname, MOVEFILE_REPLACE_EXISTING)) {

+ zip_error_set(&ctx->error, ZIP_ER_RENAME, _zip_win32_error_to_errno(GetLastError()));

+ return -1;

+ }

+

+ return 0;

+}

+

+static zip_int64_t

+_zip_win32_named_op_create_temp_output(zip_source_file_context_t *ctx) {

+ zip_win32_file_operations_t *file_ops = (zip_win32_file_operations_t *)ctx->ops_userdata;

+

+ zip_uint32_t value, i;

+ HANDLE th = INVALID_HANDLE_VALUE;

+ void *temp = NULL;

+ PSECURITY_DESCRIPTOR psd = NULL;

+ PSECURITY_ATTRIBUTES psa = NULL;

+ SECURITY_ATTRIBUTES sa;

+ SECURITY_INFORMATION si;

+ DWORD success;

+ PACL dacl = NULL;

+ char *tempname = NULL;

+ size_t tempname_size = 0;

+

+ if ((HANDLE)ctx->f != INVALID_HANDLE_VALUE && GetFileType((HANDLE)ctx->f) == FILE_TYPE_DISK) {

+ si = DACL_SECURITY_INFORMATION | UNPROTECTED_DACL_SECURITY_INFORMATION;

+ success = GetSecurityInfo((HANDLE)ctx->f, SE_FILE_OBJECT, si, NULL, NULL, &dacl, NULL, &psd);

+ if (success == ERROR_SUCCESS) {

+ sa.nLength = sizeof(SECURITY_ATTRIBUTES);

+ sa.bInheritHandle = FALSE;

+ sa.lpSecurityDescriptor = psd;

+ psa = &sa;

+ }

+ }

+

+ #ifndef MS_UWP

+ value = GetTickCount();

+#else

+ value = (zip_uint32_t)(GetTickCount64() & 0xffffffff);

+#endif

+

+ if ((tempname = file_ops->allocate_tempname(ctx->fname, 10, &tempname_size)) == NULL) {

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

+ return -1;

+ }

+

+ for (i = 0; i < 1024 && th == INVALID_HANDLE_VALUE; i++) {

+ file_ops->make_tempname(tempname, tempname_size, ctx->fname, value + i);

+

+ th = win32_named_open(ctx, tempname, true, psa);

+ if (th == INVALID_HANDLE_VALUE && GetLastError() != ERROR_FILE_EXISTS)

+ break;

+ }

+

+ if (th == INVALID_HANDLE_VALUE) {

+ free(tempname);

+ LocalFree(psd);

+ zip_error_set(&ctx->error, ZIP_ER_TMPOPEN, _zip_win32_error_to_errno(GetLastError()));

+ return -1;

+ }

+

+ LocalFree(psd);

+ ctx->fout = th;

+ ctx->tmpname = tempname;

+

+ return 0;

+}

+

+

+static bool

+_zip_win32_named_op_open(zip_source_file_context_t *ctx) {

+ HANDLE h = win32_named_open(ctx, ctx->fname, false, NULL);

+

+ if (h == INVALID_HANDLE_VALUE) {

+ return false;

+ }

+

+ ctx->f = h;

+ return true;

+}

+

+

+static zip_int64_t

+_zip_win32_named_op_remove(zip_source_file_context_t *ctx) {

+ zip_win32_file_operations_t *file_ops = (zip_win32_file_operations_t *)ctx->ops_userdata;

+

+ if (!file_ops->delete_file(ctx->fname)) {

+ zip_error_set(&ctx->error, ZIP_ER_REMOVE, _zip_win32_error_to_errno(GetLastError()));

+ return -1;

+ }

+

+ return 0;

+}

+

+

+static void

+_zip_win32_named_op_rollback_write(zip_source_file_context_t *ctx) {

+ zip_win32_file_operations_t *file_ops = (zip_win32_file_operations_t *)ctx->ops_userdata;

+

+ if (ctx->fout) {

+ CloseHandle((HANDLE)ctx->fout);

+ }

+ file_ops->delete_file(ctx->tmpname);

+}

+

+

+static bool

+_zip_win32_named_op_stat(zip_source_file_context_t *ctx, zip_source_file_stat_t *st) {

+ zip_win32_file_operations_t *file_ops = (zip_win32_file_operations_t *)ctx->ops_userdata;

+

+ WIN32_FILE_ATTRIBUTE_DATA file_attributes;

+

+ if (!file_ops->get_file_attributes_ex(ctx->fname, GetFileExInfoStandard, &file_attributes)) {

+ DWORD error = GetLastError();

+ if (error == ERROR_FILE_NOT_FOUND) {

+ st->exists = false;

+ return true;

+ }

+ zip_error_set(&ctx->error, ZIP_ER_READ, _zip_win32_error_to_errno(error));

+ return false;

+ }

+

+ st->exists = true;

+ st->regular_file = true; /* TODO: Is this always right? How to determine without a HANDLE? */

+ if (!_zip_filetime_to_time_t(file_attributes.ftLastWriteTime, &st->mtime)) {

+ zip_error_set(&ctx->error, ZIP_ER_READ, ERANGE);

+ return false;

+ }

+ st->size = ((zip_uint64_t)file_attributes.nFileSizeHigh << 32) | file_attributes.nFileSizeLow;

+

+ /* TODO: fill in ctx->attributes */

+

+ return true;

+}

+

+

+static char *

+_zip_win32_named_op_string_duplicate(zip_source_file_context_t *ctx, const char *string) {

+ zip_win32_file_operations_t *file_ops = (zip_win32_file_operations_t *)ctx->ops_userdata;

+

+ return file_ops->string_duplicate(string);

+}

+

+

+static zip_int64_t

+_zip_win32_named_op_write(zip_source_file_context_t *ctx, const void *data, zip_uint64_t len) {

+ DWORD ret;

+ if (!WriteFile((HANDLE)ctx->fout, data, (DWORD)len, &ret, NULL) || ret != len) {

+ zip_error_set(&ctx->error, ZIP_ER_WRITE, _zip_win32_error_to_errno(GetLastError()));

+ return -1;

+ }

+

+ return (zip_int64_t)ret;

+}

+

+

+static HANDLE

+win32_named_open(zip_source_file_context_t *ctx, const char *name, bool temporary, PSECURITY_ATTRIBUTES security_attributes) {

+ zip_win32_file_operations_t *file_ops = (zip_win32_file_operations_t *)ctx->ops_userdata;

+

+ DWORD access = GENERIC_READ;

+ DWORD share_mode = FILE_SHARE_READ | FILE_SHARE_WRITE;

+ DWORD creation_disposition = OPEN_EXISTING;

+ DWORD file_attributes = FILE_ATTRIBUTE_NORMAL;

+ HANDLE h;

+

+ if (temporary) {

+ access = GENERIC_READ | GENERIC_WRITE;

+ share_mode = FILE_SHARE_READ;

+ creation_disposition = CREATE_NEW;

+ file_attributes = FILE_ATTRIBUTE_NORMAL | FILE_ATTRIBUTE_TEMPORARY;

+ }

+

+ h = file_ops->create_file(name, access, share_mode, security_attributes, creation_disposition, file_attributes, NULL);

+

+ if (h == INVALID_HANDLE_VALUE) {

+ zip_error_set(&ctx->error, ZIP_ER_OPEN, _zip_win32_error_to_errno(GetLastError()));

+ }

+

+ return h;

+}

+/*

+ zip_source_file_win32_utf16.c -- source for Windows file opened by UTF-16 name

+ Copyright (C) 1999-2020 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 "zip_source_file_win32.h"

+

+#define RtlGenRandom SystemFunction036

+BOOLEAN NTAPI RtlGenRandom(PVOID RandomBuffer, ULONG RandomBufferLength);

+

+bool zip_secure_random(zip_uint8_t *buffer, zip_uint16_t length)

+{

+ return RtlGenRandom (buffer, (ULONG) length);

+}

+

+

+static char *utf16_allocate_tempname(const char *name, size_t extra_chars, size_t *lengthp);

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

+static void utf16_make_tempname(char *buf, size_t len, const char *name, zip_uint32_t i);

+static char *utf16_strdup(const char *string);

+

+zip_win32_file_operations_t ops_utf16 = {

+ utf16_allocate_tempname,

+ utf16_create_file,

+ DeleteFileW,

+ GetFileAttributesW,

+ GetFileAttributesExW,

+ utf16_make_tempname,

+ MoveFileExW,

+ SetFileAttributesW,

+ utf16_strdup

+};

+

+ZIP_EXTERN zip_source_t *

+zip_source_win32w(zip_t *za, const wchar_t *fname, zip_uint64_t start, zip_int64_t len) {

+ if (za == NULL)

+ return NULL;

+

+ return zip_source_win32w_create(fname, start, len, &za->error);

+}

+

+

+ZIP_EXTERN zip_source_t *

+zip_source_win32w_create(const wchar_t *fname, zip_uint64_t start, zip_int64_t length, zip_error_t *error) {

+ if (fname == NULL || length < -1) {

+ zip_error_set(error, ZIP_ER_INVAL, 0);

+ return NULL;

+ }

+

+

+ return zip_source_file_common_new((const char *)fname, NULL, start, length, NULL, &_zip_source_file_win32_named_ops, &ops_utf16, error);

+}

+

+

+static char *

+utf16_allocate_tempname(const char *name, size_t extra_chars, size_t *lengthp) {

+ *lengthp = wcslen((const wchar_t *)name) + extra_chars;

+ return (char *)malloc(*lengthp * sizeof(wchar_t));

+}

+

+

+static HANDLE __stdcall

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

+#ifdef MS_UWP

+ CREATEFILE2_EXTENDED_PARAMETERS extParams = {0};

+ extParams.dwFileAttributes = file_attributes;

+ extParams.dwFileFlags = FILE_FLAG_RANDOM_ACCESS;

+ extParams.dwSecurityQosFlags = SECURITY_ANONYMOUS;

+ extParams.dwSize = sizeof(extParams);

+ extParams.hTemplateFile = template_file;

+ extParams.lpSecurityAttributes = security_attributes;

+

+ return CreateFile2((const wchar_t *)name, access, share_mode, creation_disposition, &extParams);

+#else

+ return CreateFileW((const wchar_t *)name, access, share_mode, security_attributes, creation_disposition, file_attributes, template_file);

+#endif

+}

+

+

+static void

+utf16_make_tempname(char *buf, size_t len, const char *name, zip_uint32_t i) {

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

+}

+

+

+static char *

+utf16_strdup(const char *string) {

+ return (char *)_wcsdup((const wchar_t *)string);

+}

+ zip_source_file_win32_ansi.c -- source for Windows file opened by UTF-8 name

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

+#include "zip_source_file_win32.h"

+ if (za == NULL) {

+ return NULL;

+ }

+

+ zip_error_set(error, ZIP_ER_INVAL, 0);

+ return NULL;

+ zip_error_set(error, ZIP_ER_INVAL, 0);

+ return NULL;

+ zip_error_set(error, ZIP_ER_MEMORY, 0);

+ return NULL;

+

+/*

+ zip_source_get_file_attributes.c -- get attributes for file from source

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

+

+ZIP_EXTERN void

+zip_file_attributes_init(zip_file_attributes_t *attributes) {

+ attributes->valid = 0;

+ attributes->version = 1;

+}

+

+int

+zip_source_get_file_attributes(zip_source_t *src, zip_file_attributes_t *attributes) {

+ if (src->source_closed) {

+ return -1;

+ }

+ if (attributes == NULL) {

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

+ return -1;

+ }

+

+ zip_file_attributes_init(attributes);

+

+ if (src->supports & ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_GET_FILE_ATTRIBUTES)) {

+ if (_zip_source_call(src, attributes, sizeof(*attributes), ZIP_SOURCE_GET_FILE_ATTRIBUTES) < 0) {

+ return -1;

+ }

+ }

+

+ if (ZIP_SOURCE_IS_LAYERED(src)) {

+ zip_file_attributes_t lower_attributes;

+

+ if (zip_source_get_file_attributes(src->src, &lower_attributes) < 0) {

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

+ return -1;

+ }

+

+ if ((lower_attributes.valid & ZIP_FILE_ATTRIBUTES_HOST_SYSTEM) && (attributes->valid & ZIP_FILE_ATTRIBUTES_HOST_SYSTEM) == 0) {

+ attributes->host_system = lower_attributes.host_system;

+ attributes->valid |= ZIP_FILE_ATTRIBUTES_HOST_SYSTEM;

+ }

+ if ((lower_attributes.valid & ZIP_FILE_ATTRIBUTES_ASCII) && (attributes->valid & ZIP_FILE_ATTRIBUTES_ASCII) == 0) {

+ attributes->ascii = lower_attributes.ascii;

+ attributes->valid |= ZIP_FILE_ATTRIBUTES_ASCII;

+ }

+ if ((lower_attributes.valid & ZIP_FILE_ATTRIBUTES_VERSION_NEEDED)) {

+ if (attributes->valid & ZIP_FILE_ATTRIBUTES_VERSION_NEEDED) {

+ attributes->version_needed = ZIP_MAX(lower_attributes.version_needed, attributes->version_needed);

+ }

+ else {

+ attributes->version_needed = lower_attributes.version_needed;

+ attributes->valid |= ZIP_FILE_ATTRIBUTES_VERSION_NEEDED;

+ }

+ }

+ if ((lower_attributes.valid & ZIP_FILE_ATTRIBUTES_EXTERNAL_FILE_ATTRIBUTES) && (attributes->valid & ZIP_FILE_ATTRIBUTES_EXTERNAL_FILE_ATTRIBUTES) == 0) {

+ attributes->external_file_attributes = lower_attributes.external_file_attributes;

+ attributes->valid |= ZIP_FILE_ATTRIBUTES_EXTERNAL_FILE_ATTRIBUTES;

+ }

+ if ((lower_attributes.valid & ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS)) {

+ if (attributes->valid & ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS) {

+ attributes->general_purpose_bit_flags &= ~lower_attributes.general_purpose_bit_mask;

+ attributes->general_purpose_bit_flags |= lower_attributes.general_purpose_bit_flags & lower_attributes.general_purpose_bit_mask;

+ attributes->general_purpose_bit_mask |= lower_attributes.general_purpose_bit_mask;

+ }

+ else {

+ attributes->valid |= ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS;

+ attributes->general_purpose_bit_flags = lower_attributes.general_purpose_bit_flags;

+ attributes->general_purpose_bit_mask = lower_attributes.general_purpose_bit_mask;

+ }

+ }

+ }

+

+ return 0;

+}

+ zip_source_pkware_decode.c -- Traditional PKWARE decryption routines

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

+ char *password;

+ zip_pkware_keys_t keys;

+static struct trad_pkware *trad_pkware_new(const char *password, zip_error_t *error);

+static void trad_pkware_free(struct trad_pkware *);

+zip_source_pkware_decode(zip_t *za, zip_source_t *src, zip_uint16_t em, int flags, const char *password) {

+ if ((ctx = trad_pkware_new(password, &za->error)) == NULL) {

+ trad_pkware_free(ctx);

+ zip_uint8_t header[ZIP_CRYPTO_PKWARE_HEADERLEN];

+ bool ok;

+ if ((n = zip_source_read(src, header, ZIP_CRYPTO_PKWARE_HEADERLEN)) < 0) {

+ if (n != ZIP_CRYPTO_PKWARE_HEADERLEN) {

+ _zip_pkware_decrypt(&ctx->keys, header, header, ZIP_CRYPTO_PKWARE_HEADERLEN);

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

+ /* password verification - two ways:

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

+ * CRC - old PKWare way

+ */

+

+ ok = false;

+

+ if (st.valid & ZIP_STAT_MTIME) {

+ unsigned short dostime, dosdate;

+ _zip_u2d_time(st.mtime, &dostime, &dosdate);

+ if (header[ZIP_CRYPTO_PKWARE_HEADERLEN - 1] == dostime >> 8) {

+ ok = true;

+ }

+ }

+

+ if (st.valid & ZIP_STAT_CRC) {

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

+ ok = true;

+ }

+ }

+ if (!ok && ((st.valid & (ZIP_STAT_MTIME | ZIP_STAT_CRC)) != 0)) {

+ _zip_pkware_keys_reset(&ctx->keys);

+ _zip_pkware_decrypt(&ctx->keys, NULL, (const zip_uint8_t *)ctx->password, strlen(ctx->password));

+ if (decrypt_header(src, ctx) < 0) {

+ }

+ _zip_pkware_decrypt(&ctx->keys, (zip_uint8_t *)data, (zip_uint8_t *)data, (zip_uint64_t)n);

+ if (st->valid & ZIP_STAT_COMP_SIZE) {

+ st->comp_size -= ZIP_CRYPTO_PKWARE_HEADERLEN;

+ }

+ trad_pkware_free(ctx);

+static struct trad_pkware *

+trad_pkware_new(const char *password, zip_error_t *error) {

+ struct trad_pkware *ctx;

+

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

+ zip_error_set(error, ZIP_ER_MEMORY, 0);

+ return NULL;

+ }

+

+ if ((ctx->password = strdup(password)) == NULL) {

+ zip_error_set(error, ZIP_ER_MEMORY, 0);

+ free(ctx);

+ return NULL;

+ }

+

+ zip_error_init(&ctx->error);

+

+ return ctx;

+}

+

+

+trad_pkware_free(struct trad_pkware *ctx) {

+ if (ctx == NULL) {

+ return;

+ }

+

+ free(ctx->password);

+/*

+ zip_source_pkware_encode.c -- Traditional PKWARE encryption routines

+ Copyright (C) 2009-2020 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>

+#include <string.h>

+

+#include "zipint.h"

+

+struct trad_pkware {

+ char *password;

+ zip_pkware_keys_t keys;

+ zip_buffer_t *buffer;

+ bool eof;

+ zip_error_t error;

+};

+

+

+static int encrypt_header(zip_source_t *, struct trad_pkware *);

+static zip_int64_t pkware_encrypt(zip_source_t *, void *, void *, zip_uint64_t, zip_source_cmd_t);

+static void trad_pkware_free(struct trad_pkware *);

+static struct trad_pkware *trad_pkware_new(const char *password, zip_error_t *error);

+

+

+zip_source_t *

+zip_source_pkware_encode(zip_t *za, zip_source_t *src, zip_uint16_t em, int flags, const char *password) {

+ struct trad_pkware *ctx;

+ zip_source_t *s2;

+

+ if (password == NULL || src == NULL || em != ZIP_EM_TRAD_PKWARE) {

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

+ return NULL;

+ }

+ if (!(flags & ZIP_CODEC_ENCODE)) {

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

+ return NULL;

+ }

+

+ if ((ctx = trad_pkware_new(password, &za->error)) == NULL) {

+ return NULL;

+ }

+

+ if ((s2 = zip_source_layered(za, src, pkware_encrypt, ctx)) == NULL) {

+ trad_pkware_free(ctx);

+ return NULL;

+ }

+

+ return s2;

+}

+

+

+static int

+encrypt_header(zip_source_t *src, struct trad_pkware *ctx) {

+ struct zip_stat st;

+ unsigned short dostime, dosdate;

+ zip_uint8_t *header;

+

+ if (zip_source_stat(src, &st) != 0) {

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

+ return -1;

+ }

+

+ _zip_u2d_time(st.mtime, &dostime, &dosdate);

+

+ if ((ctx->buffer = _zip_buffer_new(NULL, ZIP_CRYPTO_PKWARE_HEADERLEN)) == NULL) {

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

+ return -1;

+ }

+

+ header = _zip_buffer_data(ctx->buffer);

+

+ /* generate header from random bytes and mtime

+ see appnote.iz, XIII. Decryption, Step 2, last paragraph */

+ if (!zip_secure_random(header, ZIP_CRYPTO_PKWARE_HEADERLEN - 1)) {

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

+ _zip_buffer_free(ctx->buffer);

+ ctx->buffer = NULL;

+ return -1;

+ }

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

+

+ _zip_pkware_encrypt(&ctx->keys, header, header, ZIP_CRYPTO_PKWARE_HEADERLEN);

+

+ return 0;

+}

+

+

+static zip_int64_t

+pkware_encrypt(zip_source_t *src, void *ud, void *data, zip_uint64_t length, zip_source_cmd_t cmd) {

+ struct trad_pkware *ctx;

+ zip_int64_t n;

+ zip_uint64_t buffer_n;

+

+ ctx = (struct trad_pkware *)ud;

+

+ switch (cmd) {

+ case ZIP_SOURCE_OPEN:

+ ctx->eof = false;

+

+ /* initialize keys */

+ _zip_pkware_keys_reset(&ctx->keys);

+ _zip_pkware_encrypt(&ctx->keys, NULL, (const zip_uint8_t *)ctx->password, strlen(ctx->password));

+

+ if (encrypt_header(src, ctx) < 0) {

+ return -1;

+ }

+ return 0;

+

+ case ZIP_SOURCE_READ:

+ buffer_n = 0;

+

+ if (ctx->buffer) {

+ /* write header values to data */

+ buffer_n = _zip_buffer_read(ctx->buffer, data, length);

+ data = (zip_uint8_t *)data + buffer_n;

+ length -= buffer_n;

+

+ if (_zip_buffer_eof(ctx->buffer)) {

+ _zip_buffer_free(ctx->buffer);

+ ctx->buffer = NULL;

+ }

+ }

+

+ if (ctx->eof) {

+ return (zip_int64_t)buffer_n;

+ }

+

+ if ((n = zip_source_read(src, data, length)) < 0) {

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

+ return -1;

+ }

+

+ _zip_pkware_encrypt(&ctx->keys, (zip_uint8_t *)data, (zip_uint8_t *)data, (zip_uint64_t)n);

+

+ if ((zip_uint64_t)n < length) {

+ ctx->eof = true;

+ }

+

+ return (zip_int64_t)buffer_n + n;

+

+ case ZIP_SOURCE_CLOSE:

+ _zip_buffer_free(ctx->buffer);

+ ctx->buffer = NULL;

+ return 0;

+

+ case ZIP_SOURCE_STAT: {

+ zip_stat_t *st;

+

+ st = (zip_stat_t *)data;

+ st->encryption_method = ZIP_EM_TRAD_PKWARE;

+ st->valid |= ZIP_STAT_ENCRYPTION_METHOD;

+ if (st->valid & ZIP_STAT_COMP_SIZE) {

+ st->comp_size += ZIP_CRYPTO_PKWARE_HEADERLEN;

+ }

+

+ return 0;

+ }

+

+ case ZIP_SOURCE_GET_FILE_ATTRIBUTES: {

+ zip_file_attributes_t *attributes = (zip_file_attributes_t *)data;

+ if (length < sizeof(*attributes)) {

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

+ return -1;

+ }

+ attributes->valid |= ZIP_FILE_ATTRIBUTES_VERSION_NEEDED;

+ attributes->version_needed = 20;

+

+ return 0;

+ }

+

+ case ZIP_SOURCE_SUPPORTS:

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

+

+ case ZIP_SOURCE_ERROR:

+ return zip_error_to_data(&ctx->error, data, length);

+

+ case ZIP_SOURCE_FREE:

+ trad_pkware_free(ctx);

+ return 0;

+

+ default:

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

+ return -1;

+ }

+}

+

+

+static struct trad_pkware *

+trad_pkware_new(const char *password, zip_error_t *error) {

+ struct trad_pkware *ctx;

+

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

+ zip_error_set(error, ZIP_ER_MEMORY, 0);

+ return NULL;

+ }

+

+ if ((ctx->password = strdup(password)) == NULL) {

+ zip_error_set(error, ZIP_ER_MEMORY, 0);

+ free(ctx);

+ return NULL;

+ }

+ ctx->buffer = NULL;

+ zip_error_init(&ctx->error);

+

+ return ctx;

+}

+

+

+static void

+trad_pkware_free(struct trad_pkware *ctx) {

+ if (ctx == NULL) {

+ return;

+ }

+

+ free(ctx->password);

+ _zip_buffer_free(ctx->buffer);

+ zip_error_fini(&ctx->error);

+ free(ctx);

+}

+ zip_file_attributes_t attributes;

+_zip_source_window_new(zip_source_t *src, zip_uint64_t start, zip_uint64_t length, zip_stat_t *st, zip_file_attributes_t *attributes, zip_t *source_archive, zip_uint64_t source_index, zip_error_t *error) {

+ if (attributes != NULL) {

+ memcpy(&ctx->attributes, attributes, sizeof(ctx->attributes));

+ }

+ else {

+ zip_file_attributes_init(&ctx->attributes);

+ }

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

+

+ case ZIP_SOURCE_GET_FILE_ATTRIBUTES:

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

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

+ return -1;

+ }

+

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

+ return sizeof(ctx->attributes);

+static void _zip_file_attributes_from_dirent(zip_file_attributes_t *attributes, zip_dirent_t *de);

+ zip_stat_t st;

+ zip_file_attributes_t attributes;

+ zip_dirent_t *de;

+ if (za == NULL) {

+ }

+ if (flags & ZIP_FL_ENCRYPTED) {

+ }

+ if ((de = _zip_get_dirent(srcza, srcidx, flags, &za->error)) == NULL) {

+ return NULL;

+ }

+ _zip_file_attributes_from_dirent(&attributes, de);

+

+ return zip_source_buffer_with_attributes(za, NULL, 0, 0, &attributes);

+ if ((src = _zip_source_window_new(srcza->src, start, len, &st2, &attributes, srcza, srcidx, &za->error)) == NULL) {

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

+

+static void

+_zip_file_attributes_from_dirent(zip_file_attributes_t *attributes, zip_dirent_t *de) {

+ zip_file_attributes_init(attributes);

+ attributes->valid = ZIP_FILE_ATTRIBUTES_ASCII | ZIP_FILE_ATTRIBUTES_HOST_SYSTEM | ZIP_FILE_ATTRIBUTES_EXTERNAL_FILE_ATTRIBUTES | ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS;

+ attributes->ascii = de->int_attrib & 1;

+ attributes->host_system = de->version_madeby >> 8;

+ attributes->external_file_attributes = de->ext_attrib;

+ attributes->general_purpose_bit_flags = de->bitflags;

+ attributes->general_purpose_bit_mask = ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS_ALLOWED_MASK;

+}

+#include <zlib.h>

+ if ((s->raw = (zip_uint8_t *)malloc((size_t)length + 1)) == NULL) {

+#define MAX_DATA_DESCRIPTOR_LENGTH 24

+

+#define ZIP_CRYPTO_PKWARE_HEADERLEN 12

+#define ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS_ALLOWED_MASK 0x0836

+/* clang-format off */

+/* clang-format on */

+ zip_uint16_t (*general_purpose_bit_flags)(void *ctx);

+ /* minimum version needed when using this algorithm */

+ zip_uint8_t version_needed;

+zip_source_t *zip_source_pkware_decode(zip_t *, zip_source_t *, zip_uint16_t, int, const char *);

+zip_source_t *zip_source_pkware_encode(zip_t *, zip_source_t *, zip_uint16_t, int, const char *);

+zip_source_t *zip_source_buffer_with_attributes(zip_t *za, const void *data, zip_uint64_t len, int freep, zip_file_attributes_t *attributes);

+#define DEFINE_BYTE_ARRAY(buf, size) zip_uint8_t *buf

+#define byte_array_init(buf, size) (((buf) = (zip_uint8_t *)malloc(size)) != NULL)

+#define byte_array_fini(buf) (free(buf))

+#define DEFINE_BYTE_ARRAY(buf, size) zip_uint8_t buf[size]

+#define byte_array_init(buf, size) (1)

+#define byte_array_fini(buf) ((void)0)

+struct _zip_pkware_keys {

+ zip_uint32_t key[3];

+};

+typedef struct _zip_pkware_keys zip_pkware_keys_t;

+

+void _zip_dirent_apply_attributes(zip_dirent_t *, zip_file_attributes_t *, bool, zip_uint32_t);

+zip_string_t *_zip_read_string(zip_buffer_t *buffer, zip_source_t *src, zip_uint16_t length, bool nulp, zip_error_t *error);

+zip_source_t *_zip_source_window_new(zip_source_t *src, zip_uint64_t start, zip_uint64_t length, zip_stat_t *st, zip_file_attributes_t *attributes, zip_t *source_archive, zip_uint64_t source_index, zip_error_t *error);

+void _zip_pkware_encrypt(zip_pkware_keys_t *keys, zip_uint8_t *out, const zip_uint8_t *in, zip_uint64_t len);

+void _zip_pkware_decrypt(zip_pkware_keys_t *keys, zip_uint8_t *out, const zip_uint8_t *in, zip_uint64_t len);

+zip_pkware_keys_t *_zip_pkware_keys_new(zip_error_t *error);

+void _zip_pkware_keys_free(zip_pkware_keys_t *keys);

+void _zip_pkware_keys_reset(zip_pkware_keys_t *keys);

+