#ifndef _HAD_ZIPINT_H #define _HAD_ZIPINT_H /* zipint.h -- internal declarations. 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 <[email protected]> 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 "compat.h" #include "config.h" #ifdef ZIP_ALLOCATE_BUFFER #include <stdlib.h> #endif #ifndef _ZIP_COMPILING_DEPRECATED #define ZIP_DISABLE_DEPRECATED #endif #include "zip.h" #define CENTRAL_MAGIC … #define LOCAL_MAGIC … #define EOCD_MAGIC … #define DATADES_MAGIC … #define EOCD64LOC_MAGIC … #define EOCD64_MAGIC … #define CDENTRYSIZE … #define LENTRYSIZE … #define MAXCOMLEN … #define MAXEXTLEN … #define EOCDLEN … #define EOCD64LOCLEN … #define EOCD64LEN … #define CDBUFSIZE … #define BUFSIZE … #define EFZIP64SIZE … #define EF_WINZIP_AES_SIZE … #define MAX_DATA_DESCRIPTOR_LENGTH … #define ZIP_CRYPTO_PKWARE_HEADERLEN … #define ZIP_CM_REPLACED_DEFAULT … #define ZIP_CM_WINZIP_AES … #define WINZIP_AES_PASSWORD_VERIFY_LENGTH … #define WINZIP_AES_MAX_HEADER_LENGTH … #define AES_BLOCK_SIZE … #define HMAC_LENGTH … #define SHA1_LENGTH … #define SALT_LENGTH(method) … #define ZIP_CM_IS_DEFAULT(x) … #define ZIP_CM_ACTUAL(x) … #define ZIP_EF_UTF_8_COMMENT … #define ZIP_EF_UTF_8_NAME … #define ZIP_EF_WINZIP_AES … #define ZIP_EF_ZIP64 … #define ZIP_EF_IS_INTERNAL(id) … /* according to unzip-6.0's zipinfo.c, this corresponds to a regular file with * rw permissions for everyone */ #define ZIP_EXT_ATTRIB_DEFAULT … /* according to unzip-6.0's zipinfo.c, this corresponds to a directory with rwx * permissions for everyone */ #define ZIP_EXT_ATTRIB_DEFAULT_DIR … #define ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS_ALLOWED_MASK … #define ZIP_MAX(a, b) … #define ZIP_MIN(a, b) … /* This section contains API that won't materialize like this. It's placed in the internal section, pending cleanup. */ /* flags for compression and encryption sources */ #define ZIP_CODEC_DECODE … #define ZIP_CODEC_ENCODE … zip_encryption_implementation; zip_encryption_implementation _zip_get_encryption_implementation( zip_uint16_t method, int operation); /* clang-format off */ enum zip_compression_status { … }; /* clang-format on */ zip_compression_status_t; struct zip_compression_algorithm { … }; zip_compression_algorithm_t; extern zip_compression_algorithm_t zip_algorithm_bzip2_compress; extern zip_compression_algorithm_t zip_algorithm_bzip2_decompress; extern zip_compression_algorithm_t zip_algorithm_deflate_compress; extern zip_compression_algorithm_t zip_algorithm_deflate_decompress; extern zip_compression_algorithm_t zip_algorithm_xz_compress; extern zip_compression_algorithm_t zip_algorithm_xz_decompress; /* This API is not final yet, but we need it internally, so it's private for * now. */ const zip_uint8_t* zip_get_extra_field_by_id(zip_t*, int, int, zip_uint16_t, int, zip_uint16_t*); /* This section contains API that is of limited use until support for user-supplied compression/encryption implementation is finished. Thus we will keep it private for now. */ zip_source_layered_callback; zip_source_t* zip_source_compress(zip_t* za, zip_source_t* src, zip_int32_t cm, int compression_flags); zip_source_t* zip_source_crc(zip_t*, zip_source_t*, int); zip_source_t* zip_source_decompress(zip_t* za, zip_source_t* src, zip_int32_t cm); zip_source_t* zip_source_layered(zip_t*, zip_source_t*, zip_source_layered_callback, void*); zip_source_t* zip_source_layered_create(zip_source_t* src, zip_source_layered_callback cb, void* ud, zip_error_t* error); 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*); int zip_source_remove(zip_source_t*); zip_int64_t zip_source_supports(zip_source_t* src); zip_source_t* zip_source_window(zip_t*, zip_source_t*, zip_uint64_t, zip_uint64_t); zip_source_t* zip_source_winzip_aes_decode(zip_t*, zip_source_t*, zip_uint16_t, int, const char*); zip_source_t* zip_source_winzip_aes_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); /* error source for layered sources */ enum zip_les { … }; /* directory entry: general purpose bit flags */ #define ZIP_GPBF_ENCRYPTED … #define ZIP_GPBF_DATA_DESCRIPTOR … #define ZIP_GPBF_STRONG_ENCRYPTION … #define ZIP_GPBF_ENCODING_UTF_8 … /* extra fields */ #define ZIP_EF_LOCAL … #define ZIP_EF_CENTRAL … #define ZIP_EF_BOTH … #define ZIP_FL_FORCE_ZIP64 … #define ZIP_FL_ENCODING_ALL … /* encoding type */ enum zip_encoding_type { … }; zip_encoding_type_t; struct zip_hash; struct zip_progress; zip_cdir_t; zip_dirent_t; zip_entry_t; zip_extra_field_t; zip_string_t; zip_buffer_t; zip_hash_t; zip_progress_t; /* zip archive, part of API */ struct zip { … }; /* file in zip archive, part of API */ struct zip_file { … }; /* zip archive directory entry (central or local) */ #define ZIP_DIRENT_COMP_METHOD … #define ZIP_DIRENT_FILENAME … #define ZIP_DIRENT_COMMENT … #define ZIP_DIRENT_EXTRA_FIELD … #define ZIP_DIRENT_ATTRIBUTES … #define ZIP_DIRENT_LAST_MOD … #define ZIP_DIRENT_ENCRYPTION_METHOD … #define ZIP_DIRENT_PASSWORD … #define ZIP_DIRENT_ALL … struct zip_dirent { … }; /* zip archive central directory */ struct zip_cdir { … }; struct zip_extra_field { … }; enum zip_source_write_state { … }; zip_source_write_state_t; struct zip_source { … }; #define ZIP_SOURCE_IS_OPEN_READING(src) … #define ZIP_SOURCE_IS_OPEN_WRITING(src) … #define ZIP_SOURCE_IS_LAYERED(src) … /* entry in zip archive directory */ struct zip_entry { … }; /* file or archive comment, or filename */ struct zip_string { … }; /* byte array */ /* For performance, we usually keep 8k byte arrays on the stack. However, there are (embedded) systems with a stack size of 12k; for those, use malloc()/free() */ #ifdef ZIP_ALLOCATE_BUFFER #define DEFINE_BYTE_ARRAY … #define byte_array_init … #define byte_array_fini … #else #define DEFINE_BYTE_ARRAY(buf, size) … #define byte_array_init(buf, size) … #define byte_array_fini(buf) … #endif /* bounds checked access to memory buffer */ struct zip_buffer { … }; /* which files to write in which order */ struct zip_filelist { … }; zip_filelist_t; struct _zip_winzip_aes; zip_winzip_aes_t; struct _zip_pkware_keys { … }; zip_pkware_keys_t; extern const char* const _zip_err_str[]; extern const int _zip_nerr_str; extern const int _zip_err_type[]; #define ZIP_MAX(a, b) … #define ZIP_MIN(a, b) … #define ZIP_ENTRY_CHANGED(e, f) … #define ZIP_ENTRY_DATA_CHANGED(x) … #define ZIP_ENTRY_HAS_CHANGES(e) … #define ZIP_IS_RDONLY(za) … #ifdef HAVE_EXPLICIT_MEMSET #define _zip_crypto_clear … #else #ifdef HAVE_EXPLICIT_BZERO #define _zip_crypto_clear … #else #include <string.h> #define _zip_crypto_clear(b, l) … #endif #endif zip_int64_t _zip_add_entry(zip_t*); zip_uint8_t* _zip_buffer_data(zip_buffer_t* buffer); bool _zip_buffer_eof(zip_buffer_t* buffer); void _zip_buffer_free(zip_buffer_t* buffer); zip_uint8_t* _zip_buffer_get(zip_buffer_t* buffer, zip_uint64_t length); zip_uint16_t _zip_buffer_get_16(zip_buffer_t* buffer); zip_uint32_t _zip_buffer_get_32(zip_buffer_t* buffer); zip_uint64_t _zip_buffer_get_64(zip_buffer_t* buffer); zip_uint8_t _zip_buffer_get_8(zip_buffer_t* buffer); zip_uint64_t _zip_buffer_left(zip_buffer_t* buffer); zip_buffer_t* _zip_buffer_new(zip_uint8_t* data, zip_uint64_t size); zip_buffer_t* _zip_buffer_new_from_source(zip_source_t* src, zip_uint64_t size, zip_uint8_t* buf, zip_error_t* error); zip_uint64_t _zip_buffer_offset(zip_buffer_t* buffer); bool _zip_buffer_ok(zip_buffer_t* buffer); zip_uint8_t* _zip_buffer_peek(zip_buffer_t* buffer, zip_uint64_t length); int _zip_buffer_put(zip_buffer_t* buffer, const void* src, size_t length); int _zip_buffer_put_16(zip_buffer_t* buffer, zip_uint16_t i); int _zip_buffer_put_32(zip_buffer_t* buffer, zip_uint32_t i); int _zip_buffer_put_64(zip_buffer_t* buffer, zip_uint64_t i); int _zip_buffer_put_8(zip_buffer_t* buffer, zip_uint8_t i); zip_uint64_t _zip_buffer_read(zip_buffer_t* buffer, zip_uint8_t* data, zip_uint64_t length); int _zip_buffer_skip(zip_buffer_t* buffer, zip_uint64_t length); int _zip_buffer_set_offset(zip_buffer_t* buffer, zip_uint64_t offset); zip_uint64_t _zip_buffer_size(zip_buffer_t* buffer); void _zip_cdir_free(zip_cdir_t*); bool _zip_cdir_grow(zip_cdir_t* cd, zip_uint64_t additional_entries, zip_error_t* error); zip_cdir_t* _zip_cdir_new(zip_uint64_t, zip_error_t*); zip_int64_t _zip_cdir_write(zip_t* za, const zip_filelist_t* filelist, zip_uint64_t survivors); time_t _zip_d2u_time(zip_uint16_t, zip_uint16_t); void _zip_deregister_source(zip_t* za, zip_source_t* src); void _zip_dirent_apply_attributes(zip_dirent_t*, zip_file_attributes_t*, bool, zip_uint32_t); zip_dirent_t* _zip_dirent_clone(const zip_dirent_t*); void _zip_dirent_free(zip_dirent_t*); void _zip_dirent_finalize(zip_dirent_t*); void _zip_dirent_init(zip_dirent_t*); bool _zip_dirent_needs_zip64(const zip_dirent_t*, zip_flags_t); zip_dirent_t* _zip_dirent_new(void); zip_int64_t _zip_dirent_read(zip_dirent_t* zde, zip_source_t* src, zip_buffer_t* buffer, bool local, zip_error_t* error); void _zip_dirent_set_version_needed(zip_dirent_t* de, bool force_zip64); zip_int32_t _zip_dirent_size(zip_source_t* src, zip_uint16_t, zip_error_t*); int _zip_dirent_write(zip_t* za, zip_dirent_t* dirent, zip_flags_t flags); zip_extra_field_t* _zip_ef_clone(const zip_extra_field_t*, zip_error_t*); zip_extra_field_t* _zip_ef_delete_by_id(zip_extra_field_t*, zip_uint16_t, zip_uint16_t, zip_flags_t); void _zip_ef_free(zip_extra_field_t*); const zip_uint8_t* _zip_ef_get_by_id(const zip_extra_field_t*, zip_uint16_t*, zip_uint16_t, zip_uint16_t, zip_flags_t, zip_error_t*); zip_extra_field_t* _zip_ef_merge(zip_extra_field_t*, zip_extra_field_t*); zip_extra_field_t* _zip_ef_new(zip_uint16_t, zip_uint16_t, const zip_uint8_t*, zip_flags_t); bool _zip_ef_parse(const zip_uint8_t*, zip_uint16_t, zip_flags_t, zip_extra_field_t**, zip_error_t*); zip_extra_field_t* _zip_ef_remove_internal(zip_extra_field_t*); zip_uint16_t _zip_ef_size(const zip_extra_field_t*, zip_flags_t); int _zip_ef_write(zip_t* za, const zip_extra_field_t* ef, zip_flags_t flags); void _zip_entry_finalize(zip_entry_t*); void _zip_entry_init(zip_entry_t*); void _zip_error_clear(zip_error_t*); void _zip_error_get(const zip_error_t*, int*, int*); void _zip_error_copy(zip_error_t* dst, const zip_error_t* src); void _zip_error_set_from_source(zip_error_t*, zip_source_t*); const zip_uint8_t* _zip_extract_extra_field_by_id(zip_error_t*, zip_uint16_t, int, const zip_uint8_t*, zip_uint16_t, zip_uint16_t*); int _zip_file_extra_field_prepare_for_change(zip_t*, zip_uint64_t); int _zip_file_fillbuf(void*, size_t, zip_file_t*); zip_uint64_t _zip_file_get_end(const zip_t* za, zip_uint64_t index, zip_error_t* error); zip_uint64_t _zip_file_get_offset(const zip_t*, zip_uint64_t, zip_error_t*); zip_dirent_t* _zip_get_dirent(zip_t*, zip_uint64_t, zip_flags_t, zip_error_t*); enum zip_encoding_type _zip_guess_encoding(zip_string_t*, enum zip_encoding_type); zip_uint8_t* _zip_cp437_to_utf8(const zip_uint8_t* const, zip_uint32_t, zip_uint32_t*, zip_error_t*); bool _zip_hash_add(zip_hash_t* hash, const zip_uint8_t* name, zip_uint64_t index, zip_flags_t flags, zip_error_t* error); bool _zip_hash_delete(zip_hash_t* hash, const zip_uint8_t* key, zip_error_t* error); void _zip_hash_free(zip_hash_t* hash); zip_int64_t _zip_hash_lookup(zip_hash_t* hash, const zip_uint8_t* name, zip_flags_t flags, zip_error_t* error); zip_hash_t* _zip_hash_new(zip_error_t* error); bool _zip_hash_reserve_capacity(zip_hash_t* hash, zip_uint64_t capacity, zip_error_t* error); bool _zip_hash_revert(zip_hash_t* hash, zip_error_t* error); int _zip_mkstempm(char* path, int mode); zip_t* _zip_open(zip_source_t*, unsigned int, zip_error_t*); void _zip_progress_end(zip_progress_t* progress); void _zip_progress_free(zip_progress_t* progress); int _zip_progress_start(zip_progress_t* progress); int _zip_progress_subrange(zip_progress_t* progress, double start, double end); int _zip_progress_update(zip_progress_t* progress, double value); /* this symbol is extern so it can be overridden for regression testing */ ZIP_EXTERN bool zip_secure_random(zip_uint8_t* buffer, zip_uint16_t length); zip_uint32_t zip_random_uint32(void); int _zip_read(zip_source_t* src, zip_uint8_t* data, zip_uint64_t length, zip_error_t* error); int _zip_read_at_offset(zip_source_t* src, zip_uint64_t offset, unsigned char* b, size_t length, zip_error_t* error); zip_uint8_t* _zip_read_data(zip_buffer_t* buffer, zip_source_t* src, size_t length, bool nulp, zip_error_t* error); int _zip_read_local_ef(zip_t*, zip_uint64_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); int _zip_register_source(zip_t* za, zip_source_t* src); void _zip_set_open_error(int* zep, const zip_error_t* err, int ze); bool zip_source_accept_empty(zip_source_t* src); zip_int64_t _zip_source_call(zip_source_t* src, void* data, zip_uint64_t length, zip_source_cmd_t command); bool _zip_source_eof(zip_source_t*); zip_source_t* _zip_source_file_or_p(const char*, FILE*, zip_uint64_t, zip_int64_t, const zip_stat_t*, zip_error_t* error); bool _zip_source_had_error(zip_source_t*); void _zip_source_invalidate(zip_source_t* src); zip_source_t* _zip_source_new(zip_error_t* error); int _zip_source_set_source_archive(zip_source_t*, zip_t*); 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); zip_source_t* _zip_source_zip_new(zip_t*, zip_t*, zip_uint64_t, zip_flags_t, zip_uint64_t, zip_uint64_t, const char*); int _zip_stat_merge(zip_stat_t* dst, const zip_stat_t* src, zip_error_t* error); int _zip_string_equal(const zip_string_t*, const zip_string_t*); void _zip_string_free(zip_string_t*); zip_uint32_t _zip_string_crc32(const zip_string_t*); const zip_uint8_t* _zip_string_get(zip_string_t*, zip_uint32_t*, zip_flags_t, zip_error_t*); zip_uint16_t _zip_string_length(const zip_string_t*); zip_string_t* _zip_string_new(const zip_uint8_t*, zip_uint16_t, zip_flags_t, zip_error_t*); int _zip_string_write(zip_t* za, const zip_string_t* string); bool _zip_winzip_aes_decrypt(zip_winzip_aes_t* ctx, zip_uint8_t* data, zip_uint64_t length); bool _zip_winzip_aes_encrypt(zip_winzip_aes_t* ctx, zip_uint8_t* data, zip_uint64_t length); bool _zip_winzip_aes_finish(zip_winzip_aes_t* ctx, zip_uint8_t* hmac); void _zip_winzip_aes_free(zip_winzip_aes_t* ctx); zip_winzip_aes_t* _zip_winzip_aes_new(const zip_uint8_t* password, zip_uint64_t password_length, const zip_uint8_t* salt, zip_uint16_t key_size, zip_uint8_t* password_verify, 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); int _zip_changed(const zip_t*, zip_uint64_t*); const char* _zip_get_name(zip_t*, zip_uint64_t, zip_flags_t, zip_error_t*); int _zip_local_header_read(zip_t*, int); void* _zip_memdup(const void*, size_t, zip_error_t*); zip_int64_t _zip_name_locate(zip_t*, const char*, zip_flags_t, zip_error_t*); zip_t* _zip_new(zip_error_t*); zip_int64_t _zip_file_replace(zip_t*, zip_uint64_t, const char*, zip_source_t*, zip_flags_t); int _zip_set_name(zip_t*, zip_uint64_t, const char*, zip_flags_t); void _zip_u2d_time(time_t, zip_uint16_t*, zip_uint16_t*); int _zip_unchange(zip_t*, zip_uint64_t, int); void _zip_unchange_data(zip_entry_t*); int _zip_write(zip_t* za, const void* data, zip_uint64_t length); #endif /* zipint.h */
Codebase Browser
chromium