#include "config.h"
#include "compat.h"
#include "zip.h"
#include <string.h>

Classes
struct	zip_compression_algorithm

struct	_zip_err_info

struct	zip

struct	zip_file

struct	zip_dirent

struct	zip_cdir

struct	zip_extra_field

struct	zip_source

struct	zip_entry

struct	zip_string

struct	zip_buffer

struct	zip_filelist

struct	_zip_pkware_keys

Macros
#define	CENTRAL_MAGIC "PK\1\2"

#define	LOCAL_MAGIC "PK\3\4"

#define	EOCD_MAGIC "PK\5\6"

#define	DATADES_MAGIC "PK\7\10"

#define	EOCD64LOC_MAGIC "PK\6\7"

#define	EOCD64_MAGIC "PK\6\6"

#define	CDENTRYSIZE 46u

#define	LENTRYSIZE 30

#define	MAXCOMLEN 65536

#define	MAXEXTLEN 65536

#define	EOCDLEN 22

#define	EOCD64LOCLEN 20

#define	EOCD64LEN 56

#define	CDBUFSIZE (MAXCOMLEN + EOCDLEN + EOCD64LOCLEN)

#define	BUFSIZE 8192

#define	EFZIP64SIZE 28

#define	EF_WINZIP_AES_SIZE 7

#define	MAX_DATA_DESCRIPTOR_LENGTH 24

#define	ZIP_CRYPTO_PKWARE_HEADERLEN 12

#define	ZIP_CM_REPLACED_DEFAULT (-2)

#define	ZIP_CM_WINZIP_AES 99 /* Winzip AES encrypted */

#define	WINZIP_AES_PASSWORD_VERIFY_LENGTH 2

#define	WINZIP_AES_MAX_HEADER_LENGTH (16 + WINZIP_AES_PASSWORD_VERIFY_LENGTH)

#define	AES_BLOCK_SIZE 16

#define	HMAC_LENGTH 10

#define	SHA1_LENGTH 20

#define	SALT_LENGTH(method) ((method) == ZIP_EM_AES_128 ? 8 : ((method) == ZIP_EM_AES_192 ? 12 : 16))

#define	ZIP_CM_IS_DEFAULT(x) ((x) == ZIP_CM_DEFAULT \|\| (x) == ZIP_CM_REPLACED_DEFAULT)

#define	ZIP_CM_ACTUAL(x) ((zip_uint16_t)(ZIP_CM_IS_DEFAULT(x) ? ZIP_CM_DEFLATE : (x)))

#define	ZIP_EF_UTF_8_COMMENT 0x6375

#define	ZIP_EF_UTF_8_NAME 0x7075

#define	ZIP_EF_WINZIP_AES 0x9901

#define	ZIP_EF_ZIP64 0x0001

#define	ZIP_EF_IS_INTERNAL(id) ((id) == ZIP_EF_UTF_8_COMMENT \|\| (id) == ZIP_EF_UTF_8_NAME \|\| (id) == ZIP_EF_WINZIP_AES \|\| (id) == ZIP_EF_ZIP64)

#define	ZIP_EXT_ATTRIB_DEFAULT (0100666u << 16)

#define	ZIP_EXT_ATTRIB_DEFAULT_DIR (0040777u << 16)

#define	ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS_ALLOWED_MASK 0x0836

#define	ZIP_MAX(a, b) ((a) > (b) ? (a) : (b))

#define	ZIP_MIN(a, b) ((a) < (b) ? (a) : (b))

#define	ZIP_CODEC_DECODE 0 /* decompress/decrypt (encode flag not set) */

#define	ZIP_CODEC_ENCODE 1 /* compress/encrypt */

#define	ZIP_DETAIL_ET_GLOBAL 0

#define	ZIP_DETAIL_ET_ENTRY 1

#define	MAX_DETAIL_INDEX 0x7fffff

#define	MAKE_DETAIL_WITH_INDEX(error, index) ((((index) > MAX_DETAIL_INDEX) ? MAX_DETAIL_INDEX : (int)(index)) << 8 \| (error))

#define	GET_INDEX_FROM_DETAIL(error) (((error) >> 8) & MAX_DETAIL_INDEX)

#define	GET_ERROR_FROM_DETAIL(error) ((error) & 0xff)

#define	ADD_INDEX_TO_DETAIL(error, index) MAKE_DETAIL_WITH_INDEX(GET_ERROR_FROM_DETAIL(error), (index))

#define	ZIP_ER_DETAIL_NO_DETAIL 0 /* G no detail */

#define	ZIP_ER_DETAIL_CDIR_OVERLAPS_EOCD 1 /* G central directory overlaps EOCD, or there is space between them */

#define	ZIP_ER_DETAIL_COMMENT_LENGTH_INVALID 2 /* G archive comment length incorrect */

#define	ZIP_ER_DETAIL_CDIR_LENGTH_INVALID 3 /* G central directory length invalid */

#define	ZIP_ER_DETAIL_CDIR_ENTRY_INVALID 4 /* E central header invalid */

#define	ZIP_ER_DETAIL_CDIR_WRONG_ENTRIES_COUNT 5 /* G central directory count of entries is incorrect */

#define	ZIP_ER_DETAIL_ENTRY_HEADER_MISMATCH 6 /* E local and central headers do not match */

#define	ZIP_ER_DETAIL_EOCD_LENGTH_INVALID 7 /* G wrong EOCD length */

#define	ZIP_ER_DETAIL_EOCD64_OVERLAPS_EOCD 8 /* G EOCD64 overlaps EOCD, or there is space between them */

#define	ZIP_ER_DETAIL_EOCD64_WRONG_MAGIC 9 /* G EOCD64 magic incorrect */

#define	ZIP_ER_DETAIL_EOCD64_MISMATCH 10 /* G EOCD64 and EOCD do not match */

#define	ZIP_ER_DETAIL_CDIR_INVALID 11 /* G invalid value in central directory */

#define	ZIP_ER_DETAIL_VARIABLE_SIZE_OVERFLOW 12 /* E variable size fields overflow header */

#define	ZIP_ER_DETAIL_INVALID_UTF8_IN_FILENAME 13 /* E invalid UTF-8 in filename */

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

#define	ZIP_ER_DETAIL_INVALID_ZIP64_EF 14 /* E invalid Zip64 extra field */

#define	ZIP_ER_DETAIL_INVALID_WINZIPAES_EF 14 /* E invalid WinZip AES extra field */

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

#define	ZIP_ER_DETAIL_INVALID_EF_LENGTH 16 /* E extra field length is invalid */

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

#define	ZIP_GPBF_ENCRYPTED 0x0001u /* is encrypted */

#define	ZIP_GPBF_DATA_DESCRIPTOR 0x0008u /* crc/size after file data */

#define	ZIP_GPBF_STRONG_ENCRYPTION 0x0040u /* uses strong encryption */

#define	ZIP_GPBF_ENCODING_UTF_8 0x0800u /* file name encoding is UTF-8 */

#define	ZIP_EF_LOCAL ZIP_FL_LOCAL /* include in local header */

#define	ZIP_EF_CENTRAL ZIP_FL_CENTRAL /* include in central directory */

#define	ZIP_EF_BOTH (ZIP_EF_LOCAL \| ZIP_EF_CENTRAL) /* include in both */

#define	ZIP_FL_FORCE_ZIP64 1024 /* force zip64 extra field (_zip_dirent_write) */

#define	ZIP_FL_ENCODING_ALL (ZIP_FL_ENC_GUESS \| ZIP_FL_ENC_CP437 \| ZIP_FL_ENC_UTF_8)

#define	ZIP_DIRENT_COMP_METHOD 0x0001u

#define	ZIP_DIRENT_FILENAME 0x0002u

#define	ZIP_DIRENT_COMMENT 0x0004u

#define	ZIP_DIRENT_EXTRA_FIELD 0x0008u

#define	ZIP_DIRENT_ATTRIBUTES 0x0010u

#define	ZIP_DIRENT_LAST_MOD 0x0020u

#define	ZIP_DIRENT_ENCRYPTION_METHOD 0x0040u

#define	ZIP_DIRENT_PASSWORD 0x0080u

#define	ZIP_DIRENT_ALL ZIP_UINT32_MAX

#define	ZIP_SOURCE_IS_OPEN_READING(src) ((src)->open_count > 0)

#define	ZIP_SOURCE_IS_OPEN_WRITING(src) ((src)->write_state == ZIP_SOURCE_WRITE_OPEN)

#define	ZIP_SOURCE_IS_LAYERED(src) ((src)->src != NULL)

#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)

#define	ZIP_MAX(a, b) ((a) > (b) ? (a) : (b))

#define	ZIP_MIN(a, b) ((a) < (b) ? (a) : (b))

#define	ZIP_ENTRY_CHANGED(e, f) ((e)->changes && ((e)->changes->changed & (f)))

#define	ZIP_ENTRY_DATA_CHANGED(x) ((x)->source != NULL)

#define	ZIP_ENTRY_HAS_CHANGES(e) (ZIP_ENTRY_DATA_CHANGED(e) \|\| (e)->deleted \|\| ZIP_ENTRY_CHANGED((e), ZIP_DIRENT_ALL))

#define	ZIP_IS_RDONLY(za) ((za)->ch_flags & ZIP_AFL_RDONLY)

#define	_zip_crypto_clear(b, l) memset((b), 0, (l))

Typedefs
typedef zip_source_t (	zip_encryption_implementation) (zip_t , zip_source_t , zip_uint16_t, int, const char *)

typedef enum zip_compression_status	zip_compression_status_t

typedef struct zip_compression_algorithm	zip_compression_algorithm_t

typedef zip_int64_t(*	zip_source_layered_callback) (zip_source_t , void , void *, zip_uint64_t, enum zip_source_cmd)

typedef enum zip_encoding_type	zip_encoding_type_t

typedef struct zip_cdir	zip_cdir_t

typedef struct zip_dirent	zip_dirent_t

typedef struct zip_entry	zip_entry_t

typedef struct zip_extra_field	zip_extra_field_t

typedef struct zip_string	zip_string_t

typedef struct zip_buffer	zip_buffer_t

typedef struct zip_hash	zip_hash_t

typedef struct zip_progress	zip_progress_t

typedef enum zip_source_write_state	zip_source_write_state_t

typedef struct zip_filelist	zip_filelist_t

typedef struct _zip_winzip_aes	zip_winzip_aes_t

typedef struct _zip_pkware_keys	zip_pkware_keys_t

Functions
zip_encryption_implementation	_zip_get_encryption_implementation (zip_uint16_t method, int operation)

zip_compression_algorithm_t *	_zip_get_compression_algorithm (zip_int32_t method, bool compress)

const zip_uint8_t *	zip_get_extra_field_by_id (zip_t , int, int, zip_uint16_t, int, zip_uint16_t )

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_create (zip_source_t , int, zip_error_t error)

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_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)

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_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, bool create_file)

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)

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_int64_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_uint64_t, zip_flags_t, zip_uint64_t, zip_uint64_t, const char , zip_error_t *error)

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 a, const zip_string_t b)

void	_zip_string_free (zip_string_t *string)

zip_uint32_t	_zip_string_crc32 (const zip_string_t *string)

const zip_uint8_t *	_zip_string_get (zip_string_t string, zip_uint32_t lenp, zip_flags_t flags, zip_error_t *error)

zip_uint16_t	_zip_string_length (const zip_string_t *string)

zip_string_t *	_zip_string_new (const zip_uint8_t raw, zip_uint16_t length, zip_flags_t flags, zip_error_t error)

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)

Macro Definition Documentation

◆ _zip_crypto_clear

#define _zip_crypto_clear	(	b,
		l
	)	memset((b), 0, (l))

Definition at line 489 of file zipint.h.

◆ ADD_INDEX_TO_DETAIL

#define ADD_INDEX_TO_DETAIL	(	error,
		index
	)	MAKE_DETAIL_WITH_INDEX(GET_ERROR_FROM_DETAIL(error), (index))

Definition at line 210 of file zipint.h.

◆ AES_BLOCK_SIZE

#define AES_BLOCK_SIZE 16

Definition at line 77 of file zipint.h.

◆ BUFSIZE

#define BUFSIZE 8192

Definition at line 65 of file zipint.h.

◆ byte_array_fini

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

Definition at line 440 of file zipint.h.

◆ byte_array_init

#define byte_array_init	(	buf,
		size
	)	(1)

Definition at line 439 of file zipint.h.

◆ CDBUFSIZE

#define CDBUFSIZE (MAXCOMLEN + EOCDLEN + EOCD64LOCLEN)

Definition at line 64 of file zipint.h.

◆ CDENTRYSIZE

#define CDENTRYSIZE 46u

Definition at line 57 of file zipint.h.

◆ CENTRAL_MAGIC

#define CENTRAL_MAGIC "PK\1\2"

Definition at line 51 of file zipint.h.

◆ DATADES_MAGIC

#define DATADES_MAGIC "PK\7\10"

Definition at line 54 of file zipint.h.

◆ DEFINE_BYTE_ARRAY

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

Definition at line 438 of file zipint.h.

◆ EF_WINZIP_AES_SIZE

#define EF_WINZIP_AES_SIZE 7

Definition at line 67 of file zipint.h.

◆ EFZIP64SIZE

#define EFZIP64SIZE 28

Definition at line 66 of file zipint.h.

◆ EOCD64_MAGIC

#define EOCD64_MAGIC "PK\6\6"

Definition at line 56 of file zipint.h.

◆ EOCD64LEN

#define EOCD64LEN 56

Definition at line 63 of file zipint.h.

◆ EOCD64LOC_MAGIC

#define EOCD64LOC_MAGIC "PK\6\7"

Definition at line 55 of file zipint.h.

◆ EOCD64LOCLEN

#define EOCD64LOCLEN 20

Definition at line 62 of file zipint.h.

◆ EOCD_MAGIC

#define EOCD_MAGIC "PK\5\6"

Definition at line 53 of file zipint.h.

◆ EOCDLEN

#define EOCDLEN 22

Definition at line 61 of file zipint.h.

◆ GET_ERROR_FROM_DETAIL

#define GET_ERROR_FROM_DETAIL ( error ) ((error) & 0xff)

Definition at line 209 of file zipint.h.

◆ GET_INDEX_FROM_DETAIL

#define GET_INDEX_FROM_DETAIL ( error ) (((error) >> 8) & MAX_DETAIL_INDEX)

Definition at line 208 of file zipint.h.

◆ HMAC_LENGTH

#define HMAC_LENGTH 10

Definition at line 78 of file zipint.h.

◆ LENTRYSIZE

#define LENTRYSIZE 30

Definition at line 58 of file zipint.h.

◆ LOCAL_MAGIC

#define LOCAL_MAGIC "PK\3\4"

Definition at line 52 of file zipint.h.

◆ MAKE_DETAIL_WITH_INDEX

#define MAKE_DETAIL_WITH_INDEX	(	error,
		index
	)	((((index) > MAX_DETAIL_INDEX) ? MAX_DETAIL_INDEX : (int)(index)) << 8 \| (error))

Definition at line 207 of file zipint.h.

◆ MAX_DATA_DESCRIPTOR_LENGTH

#define MAX_DATA_DESCRIPTOR_LENGTH 24

Definition at line 68 of file zipint.h.

◆ MAX_DETAIL_INDEX

#define MAX_DETAIL_INDEX 0x7fffff

Definition at line 206 of file zipint.h.

◆ MAXCOMLEN

#define MAXCOMLEN 65536

Definition at line 59 of file zipint.h.

◆ MAXEXTLEN

#define MAXEXTLEN 65536

Definition at line 60 of file zipint.h.

◆ SALT_LENGTH

#define SALT_LENGTH ( method ) ((method) == ZIP_EM_AES_128 ? 8 : ((method) == ZIP_EM_AES_192 ? 12 : 16))

Definition at line 80 of file zipint.h.

◆ SHA1_LENGTH

#define SHA1_LENGTH 20

Definition at line 79 of file zipint.h.

◆ WINZIP_AES_MAX_HEADER_LENGTH

#define WINZIP_AES_MAX_HEADER_LENGTH (16 + WINZIP_AES_PASSWORD_VERIFY_LENGTH)

Definition at line 76 of file zipint.h.

◆ WINZIP_AES_PASSWORD_VERIFY_LENGTH

#define WINZIP_AES_PASSWORD_VERIFY_LENGTH 2

Definition at line 75 of file zipint.h.

◆ ZIP_CM_ACTUAL

#define ZIP_CM_ACTUAL ( x ) ((zip_uint16_t)(ZIP_CM_IS_DEFAULT(x) ? ZIP_CM_DEFLATE : (x)))

Definition at line 83 of file zipint.h.

◆ ZIP_CM_IS_DEFAULT

#define ZIP_CM_IS_DEFAULT ( x ) ((x) == ZIP_CM_DEFAULT || (x) == ZIP_CM_REPLACED_DEFAULT)

Definition at line 82 of file zipint.h.

◆ ZIP_CM_REPLACED_DEFAULT

#define ZIP_CM_REPLACED_DEFAULT (-2)

Definition at line 72 of file zipint.h.

◆ ZIP_CM_WINZIP_AES

#define ZIP_CM_WINZIP_AES 99 /* Winzip AES encrypted */

Definition at line 73 of file zipint.h.

◆ ZIP_CODEC_DECODE

#define ZIP_CODEC_DECODE 0 /* decompress/decrypt (encode flag not set) */

Definition at line 107 of file zipint.h.

◆ ZIP_CODEC_ENCODE

#define ZIP_CODEC_ENCODE 1 /* compress/encrypt */

Definition at line 108 of file zipint.h.

◆ ZIP_CRYPTO_PKWARE_HEADERLEN

#define ZIP_CRYPTO_PKWARE_HEADERLEN 12

Definition at line 70 of file zipint.h.

◆ ZIP_DETAIL_ET_ENTRY

#define ZIP_DETAIL_ET_ENTRY 1

Definition at line 193 of file zipint.h.

◆ ZIP_DETAIL_ET_GLOBAL

#define ZIP_DETAIL_ET_GLOBAL 0

Definition at line 192 of file zipint.h.

◆ ZIP_DIRENT_ALL

#define ZIP_DIRENT_ALL ZIP_UINT32_MAX

Definition at line 324 of file zipint.h.

◆ ZIP_DIRENT_ATTRIBUTES

#define ZIP_DIRENT_ATTRIBUTES 0x0010u

Definition at line 320 of file zipint.h.

◆ ZIP_DIRENT_COMMENT

#define ZIP_DIRENT_COMMENT 0x0004u

Definition at line 318 of file zipint.h.

◆ ZIP_DIRENT_COMP_METHOD

#define ZIP_DIRENT_COMP_METHOD 0x0001u

Definition at line 316 of file zipint.h.

◆ ZIP_DIRENT_ENCRYPTION_METHOD

#define ZIP_DIRENT_ENCRYPTION_METHOD 0x0040u

Definition at line 322 of file zipint.h.

◆ ZIP_DIRENT_EXTRA_FIELD

#define ZIP_DIRENT_EXTRA_FIELD 0x0008u

Definition at line 319 of file zipint.h.

◆ ZIP_DIRENT_FILENAME

#define ZIP_DIRENT_FILENAME 0x0002u

Definition at line 317 of file zipint.h.

◆ ZIP_DIRENT_LAST_MOD

#define ZIP_DIRENT_LAST_MOD 0x0020u

Definition at line 321 of file zipint.h.

◆ ZIP_DIRENT_PASSWORD

#define ZIP_DIRENT_PASSWORD 0x0080u

Definition at line 323 of file zipint.h.

◆ ZIP_EF_BOTH

#define ZIP_EF_BOTH (ZIP_EF_LOCAL | ZIP_EF_CENTRAL) /* include in both */

Definition at line 245 of file zipint.h.

◆ ZIP_EF_CENTRAL

#define ZIP_EF_CENTRAL ZIP_FL_CENTRAL /* include in central directory */

Definition at line 244 of file zipint.h.

◆ ZIP_EF_IS_INTERNAL

#define ZIP_EF_IS_INTERNAL ( id ) ((id) == ZIP_EF_UTF_8_COMMENT || (id) == ZIP_EF_UTF_8_NAME || (id) == ZIP_EF_WINZIP_AES || (id) == ZIP_EF_ZIP64)

Definition at line 90 of file zipint.h.

◆ ZIP_EF_LOCAL

#define ZIP_EF_LOCAL ZIP_FL_LOCAL /* include in local header */

Definition at line 243 of file zipint.h.

◆ ZIP_EF_UTF_8_COMMENT

#define ZIP_EF_UTF_8_COMMENT 0x6375

Definition at line 85 of file zipint.h.

◆ ZIP_EF_UTF_8_NAME

#define ZIP_EF_UTF_8_NAME 0x7075

Definition at line 86 of file zipint.h.

◆ ZIP_EF_WINZIP_AES

#define ZIP_EF_WINZIP_AES 0x9901

Definition at line 87 of file zipint.h.

◆ ZIP_EF_ZIP64

#define ZIP_EF_ZIP64 0x0001

Definition at line 88 of file zipint.h.

◆ ZIP_ENTRY_CHANGED

#define ZIP_ENTRY_CHANGED	(	e,
		f
	)	((e)->changes && ((e)->changes->changed & (f)))

Definition at line 475 of file zipint.h.

◆ ZIP_ENTRY_DATA_CHANGED

#define ZIP_ENTRY_DATA_CHANGED ( x ) ((x)->source != NULL)

Definition at line 476 of file zipint.h.

◆ ZIP_ENTRY_HAS_CHANGES

#define ZIP_ENTRY_HAS_CHANGES ( e ) (ZIP_ENTRY_DATA_CHANGED(e) || (e)->deleted || ZIP_ENTRY_CHANGED((e), ZIP_DIRENT_ALL))

Definition at line 477 of file zipint.h.

◆ ZIP_ER_DETAIL_CDIR_ENTRY_INVALID

#define ZIP_ER_DETAIL_CDIR_ENTRY_INVALID 4 /* E central header invalid */

Definition at line 217 of file zipint.h.

◆ ZIP_ER_DETAIL_CDIR_INVALID

#define ZIP_ER_DETAIL_CDIR_INVALID 11 /* G invalid value in central directory */

Definition at line 224 of file zipint.h.

◆ ZIP_ER_DETAIL_CDIR_LENGTH_INVALID

#define ZIP_ER_DETAIL_CDIR_LENGTH_INVALID 3 /* G central directory length invalid */

Definition at line 216 of file zipint.h.

◆ ZIP_ER_DETAIL_CDIR_OVERLAPS_EOCD

#define ZIP_ER_DETAIL_CDIR_OVERLAPS_EOCD 1 /* G central directory overlaps EOCD, or there is space between them */

Definition at line 214 of file zipint.h.

◆ ZIP_ER_DETAIL_CDIR_WRONG_ENTRIES_COUNT

#define ZIP_ER_DETAIL_CDIR_WRONG_ENTRIES_COUNT 5 /* G central directory count of entries is incorrect */

Definition at line 218 of file zipint.h.

◆ ZIP_ER_DETAIL_COMMENT_LENGTH_INVALID

#define ZIP_ER_DETAIL_COMMENT_LENGTH_INVALID 2 /* G archive comment length incorrect */

Definition at line 215 of file zipint.h.

◆ ZIP_ER_DETAIL_EF_TRAILING_GARBAGE

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

Definition at line 230 of file zipint.h.

◆ ZIP_ER_DETAIL_ENTRY_HEADER_MISMATCH

#define ZIP_ER_DETAIL_ENTRY_HEADER_MISMATCH 6 /* E local and central headers do not match */

Definition at line 219 of file zipint.h.

◆ ZIP_ER_DETAIL_EOCD64_MISMATCH

#define ZIP_ER_DETAIL_EOCD64_MISMATCH 10 /* G EOCD64 and EOCD do not match */

Definition at line 223 of file zipint.h.

◆ ZIP_ER_DETAIL_EOCD64_OVERLAPS_EOCD

#define ZIP_ER_DETAIL_EOCD64_OVERLAPS_EOCD 8 /* G EOCD64 overlaps EOCD, or there is space between them */

Definition at line 221 of file zipint.h.

◆ ZIP_ER_DETAIL_EOCD64_WRONG_MAGIC

#define ZIP_ER_DETAIL_EOCD64_WRONG_MAGIC 9 /* G EOCD64 magic incorrect */

Definition at line 222 of file zipint.h.

◆ ZIP_ER_DETAIL_EOCD_LENGTH_INVALID

#define ZIP_ER_DETAIL_EOCD_LENGTH_INVALID 7 /* G wrong EOCD length */

Definition at line 220 of file zipint.h.

◆ ZIP_ER_DETAIL_INVALID_EF_LENGTH

#define ZIP_ER_DETAIL_INVALID_EF_LENGTH 16 /* E extra field length is invalid */

Definition at line 231 of file zipint.h.

◆ ZIP_ER_DETAIL_INVALID_FILE_LENGTH

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

Definition at line 232 of file zipint.h.

◆ ZIP_ER_DETAIL_INVALID_UTF8_IN_COMMENT

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

Definition at line 227 of file zipint.h.

◆ ZIP_ER_DETAIL_INVALID_UTF8_IN_FILENAME

#define ZIP_ER_DETAIL_INVALID_UTF8_IN_FILENAME 13 /* E invalid UTF-8 in filename */

Definition at line 226 of file zipint.h.

◆ ZIP_ER_DETAIL_INVALID_WINZIPAES_EF

#define ZIP_ER_DETAIL_INVALID_WINZIPAES_EF 14 /* E invalid WinZip AES extra field */

Definition at line 229 of file zipint.h.

◆ ZIP_ER_DETAIL_INVALID_ZIP64_EF

#define ZIP_ER_DETAIL_INVALID_ZIP64_EF 14 /* E invalid Zip64 extra field */

Definition at line 228 of file zipint.h.

◆ ZIP_ER_DETAIL_NO_DETAIL

#define ZIP_ER_DETAIL_NO_DETAIL 0 /* G no detail */

Definition at line 213 of file zipint.h.

◆ ZIP_ER_DETAIL_VARIABLE_SIZE_OVERFLOW

#define ZIP_ER_DETAIL_VARIABLE_SIZE_OVERFLOW 12 /* E variable size fields overflow header */

Definition at line 225 of file zipint.h.

◆ ZIP_EXT_ATTRIB_DEFAULT

#define ZIP_EXT_ATTRIB_DEFAULT (0100666u << 16)

Definition at line 93 of file zipint.h.

◆ ZIP_EXT_ATTRIB_DEFAULT_DIR

#define ZIP_EXT_ATTRIB_DEFAULT_DIR (0040777u << 16)

Definition at line 95 of file zipint.h.

◆ ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS_ALLOWED_MASK

#define ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS_ALLOWED_MASK 0x0836

Definition at line 97 of file zipint.h.

◆ ZIP_FL_ENCODING_ALL

#define ZIP_FL_ENCODING_ALL (ZIP_FL_ENC_GUESS | ZIP_FL_ENC_CP437 | ZIP_FL_ENC_UTF_8)

Definition at line 249 of file zipint.h.

◆ ZIP_FL_FORCE_ZIP64

#define ZIP_FL_FORCE_ZIP64 1024 /* force zip64 extra field (_zip_dirent_write) */

Definition at line 247 of file zipint.h.

◆ ZIP_GPBF_DATA_DESCRIPTOR

#define ZIP_GPBF_DATA_DESCRIPTOR 0x0008u /* crc/size after file data */

Definition at line 237 of file zipint.h.

◆ ZIP_GPBF_ENCODING_UTF_8

#define ZIP_GPBF_ENCODING_UTF_8 0x0800u /* file name encoding is UTF-8 */

Definition at line 239 of file zipint.h.

◆ ZIP_GPBF_ENCRYPTED

#define ZIP_GPBF_ENCRYPTED 0x0001u /* is encrypted */

Definition at line 236 of file zipint.h.

◆ ZIP_GPBF_STRONG_ENCRYPTION

#define ZIP_GPBF_STRONG_ENCRYPTION 0x0040u /* uses strong encryption */

Definition at line 238 of file zipint.h.

◆ ZIP_IS_RDONLY

#define ZIP_IS_RDONLY ( za ) ((za)->ch_flags & ZIP_AFL_RDONLY)

Definition at line 479 of file zipint.h.

◆ ZIP_MAX [1/2]

#define ZIP_MAX	(	a,
		b
	)	((a) > (b) ? (a) : (b))

Definition at line 472 of file zipint.h.

◆ ZIP_MAX [2/2]

#define ZIP_MAX	(	a,
		b
	)	((a) > (b) ? (a) : (b))

Definition at line 472 of file zipint.h.

◆ ZIP_MIN [1/2]

#define ZIP_MIN	(	a,
		b
	)	((a) < (b) ? (a) : (b))

Definition at line 473 of file zipint.h.

◆ ZIP_MIN [2/2]

#define ZIP_MIN	(	a,
		b
	)	((a) < (b) ? (a) : (b))

Definition at line 473 of file zipint.h.

◆ ZIP_SOURCE_IS_LAYERED

#define ZIP_SOURCE_IS_LAYERED ( src ) ((src)->src != NULL)

Definition at line 404 of file zipint.h.

◆ ZIP_SOURCE_IS_OPEN_READING

#define ZIP_SOURCE_IS_OPEN_READING ( src ) ((src)->open_count > 0)

Definition at line 402 of file zipint.h.

◆ ZIP_SOURCE_IS_OPEN_WRITING

#define ZIP_SOURCE_IS_OPEN_WRITING ( src ) ((src)->write_state == ZIP_SOURCE_WRITE_OPEN)

Definition at line 403 of file zipint.h.

Typedef Documentation

◆ zip_buffer_t

typedef struct zip_buffer zip_buffer_t

Definition at line 203 of file zipint.h.

◆ zip_cdir_t

typedef struct zip_cdir zip_cdir_t

Definition at line 203 of file zipint.h.

◆ zip_compression_algorithm_t

typedef struct zip_compression_algorithm zip_compression_algorithm_t

Definition at line 112 of file zipint.h.

◆ zip_compression_status_t

typedef enum zip_compression_status zip_compression_status_t

Definition at line 112 of file zipint.h.

◆ zip_dirent_t

typedef struct zip_dirent zip_dirent_t

Definition at line 203 of file zipint.h.

◆ zip_encoding_type_t

typedef enum zip_encoding_type zip_encoding_type_t

Definition at line 203 of file zipint.h.

◆ zip_encryption_implementation

typedef zip_source_t*(* zip_encryption_implementation) (zip_t *, zip_source_t *, zip_uint16_t, int, const char *)

Definition at line 110 of file zipint.h.

◆ zip_entry_t

typedef struct zip_entry zip_entry_t

Definition at line 203 of file zipint.h.

◆ zip_extra_field_t

typedef struct zip_extra_field zip_extra_field_t

Definition at line 203 of file zipint.h.

◆ zip_filelist_t

typedef struct zip_filelist zip_filelist_t

Definition at line 203 of file zipint.h.

◆ zip_hash_t

typedef struct zip_hash zip_hash_t

Definition at line 203 of file zipint.h.

◆ zip_pkware_keys_t

typedef struct _zip_pkware_keys zip_pkware_keys_t

Definition at line 203 of file zipint.h.

◆ zip_progress_t

typedef struct zip_progress zip_progress_t

Definition at line 203 of file zipint.h.

◆ zip_source_layered_callback

typedef zip_int64_t(* zip_source_layered_callback) (zip_source_t *, void *, void *, zip_uint64_t, enum zip_source_cmd)

Definition at line 173 of file zipint.h.

◆ zip_source_write_state_t

typedef enum zip_source_write_state zip_source_write_state_t

Definition at line 203 of file zipint.h.

◆ zip_string_t

typedef struct zip_string zip_string_t

Definition at line 203 of file zipint.h.

◆ zip_winzip_aes_t

typedef struct _zip_winzip_aes zip_winzip_aes_t

Definition at line 203 of file zipint.h.

Enumeration Type Documentation

◆ zip_compression_status

enum zip_compression_status

Enumerator
ZIP_COMPRESSION_OK
ZIP_COMPRESSION_END
ZIP_COMPRESSION_ERROR
ZIP_COMPRESSION_NEED_DATA

Definition at line 115 of file zipint.h.

                             {
     ZIP_COMPRESSION_OK,
     ZIP_COMPRESSION_END,
     ZIP_COMPRESSION_ERROR,
     ZIP_COMPRESSION_NEED_DATA
 };

◆ zip_encoding_type

enum zip_encoding_type

Enumerator
ZIP_ENCODING_UNKNOWN
ZIP_ENCODING_ASCII
ZIP_ENCODING_UTF8_KNOWN
ZIP_ENCODING_UTF8_GUESSED
ZIP_ENCODING_CP437
ZIP_ENCODING_ERROR

Definition at line 253 of file zipint.h.

                        {
     ZIP_ENCODING_UNKNOWN,      /* not yet analyzed */
     ZIP_ENCODING_ASCII,        /* plain ASCII */
     ZIP_ENCODING_UTF8_KNOWN,   /* is UTF-8 */
     ZIP_ENCODING_UTF8_GUESSED, /* possibly UTF-8 */
     ZIP_ENCODING_CP437,        /* Code Page 437 */
     ZIP_ENCODING_ERROR         /* should be UTF-8 but isn't */
 };

◆ zip_les

enum zip_les

Enumerator
ZIP_LES_NONE
ZIP_LES_UPPER
ZIP_LES_LOWER
ZIP_LES_INVAL

Definition at line 190 of file zipint.h.

190 { ZIP_LES_NONE, ZIP_LES_UPPER, ZIP_LES_LOWER, ZIP_LES_INVAL };

ZIP_LES_NONE

@ ZIP_LES_NONE

Definition: zipint.h:190

ZIP_LES_INVAL

@ ZIP_LES_INVAL

Definition: zipint.h:190

ZIP_LES_UPPER

@ ZIP_LES_UPPER

Definition: zipint.h:190

ZIP_LES_LOWER

@ ZIP_LES_LOWER

Definition: zipint.h:190

◆ zip_source_write_state

enum zip_source_write_state

Enumerator
ZIP_SOURCE_WRITE_CLOSED
ZIP_SOURCE_WRITE_OPEN
ZIP_SOURCE_WRITE_FAILED
ZIP_SOURCE_WRITE_REMOVED

Definition at line 375 of file zipint.h.

                             {
     ZIP_SOURCE_WRITE_CLOSED, /* write is not in progress */
     ZIP_SOURCE_WRITE_OPEN,   /* write is in progress */
     ZIP_SOURCE_WRITE_FAILED, /* commit failed, only rollback allowed */
     ZIP_SOURCE_WRITE_REMOVED /* file was removed */
 };

Function Documentation

◆ _zip_add_entry()

zip_int64_t _zip_add_entry ( zip_t * za )

Definition at line 43 of file zip_add_entry.c.

                           {
     zip_uint64_t idx;
  
     if (za->nentry + 1 >= za->nentry_alloc) {
         zip_entry_t *rentries;
         zip_uint64_t nalloc = za->nentry_alloc;
         zip_uint64_t additional_entries = 2 * nalloc;
         zip_uint64_t realloc_size;
  
         if (additional_entries < 16) {
             additional_entries = 16;
         }
         else if (additional_entries > 1024) {
             additional_entries = 1024;
         }
         /* neither + nor * overflows can happen: nentry_alloc * sizeof(struct zip_entry) < UINT64_MAX */
         nalloc += additional_entries;
         realloc_size = sizeof(struct zip_entry) * (size_t)nalloc;
  
         if (sizeof(struct zip_entry) * (size_t)za->nentry_alloc > realloc_size) {
             zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
             return -1;
         }
         rentries = (zip_entry_t *)realloc(za->entry, sizeof(struct zip_entry) * (size_t)nalloc);
         if (!rentries) {
             zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
             return -1;
         }
         za->entry = rentries;
         za->nentry_alloc = nalloc;
     }
  
     idx = za->nentry++;
  
     _zip_entry_init(za->entry + idx);
  
     return (zip_int64_t)idx;
 }

References _zip_entry_init(), zip::entry, zip::error, setup::idx, zip::nentry, zip::nentry_alloc, realloc(), za, ZIP_ER_MEMORY, and zip_error_set().

Referenced by _zip_file_replace().

◆ _zip_buffer_data()

zip_uint8_t* _zip_buffer_data ( zip_buffer_t * buffer )

Definition at line 40 of file zip_buffer.c.

                                        {
     return buffer->data;
 }

Referenced by _zip_cdir_write(), _zip_ef_utf8(), _zip_find_central_dir(), _zip_read_cdir(), encrypt_header(), and write_data_descriptor().

◆ _zip_buffer_eof()

bool _zip_buffer_eof ( zip_buffer_t * buffer )

Definition at line 60 of file zip_buffer.c.

                                       {
     return buffer->ok && buffer->offset == buffer->size;
 }

References buffer::offset, and buffer::size.

Referenced by _zip_dirent_read(), _zip_dirent_size(), _zip_ef_parse(), _zip_read_cdir(), _zip_read_local_ef(), pkware_encrypt(), and winzip_aes_encrypt().

◆ _zip_buffer_free()

void _zip_buffer_free ( zip_buffer_t * buffer )

Definition at line 46 of file zip_buffer.c.

                                        {
     if (buffer == NULL) {
         return;
     }
  
     if (buffer->free_data) {
         free(buffer->data);
     }
  
     free(buffer);
 }

References free(), and NULL.

Referenced by _zip_buffer_new_from_source(), _zip_cdir_write(), _zip_dirent_process_ef_utf_8(), _zip_dirent_process_winzip_aes(), _zip_dirent_read(), _zip_dirent_size(), _zip_dirent_write(), _zip_ef_parse(), _zip_ef_utf8(), _zip_ef_write(), _zip_find_central_dir(), _zip_read_cdir(), _zip_read_eocd64(), _zip_read_local_ef(), encrypt_header(), input(), pkware_encrypt(), trad_pkware_free(), winzip_aes_encrypt(), winzip_aes_free(), and write_data_descriptor().

◆ _zip_buffer_get()

zip_uint8_t* _zip_buffer_get	(	zip_buffer_t *	buffer,
		zip_uint64_t	length
	)

Definition at line 66 of file zip_buffer.c.

                                                            {
     zip_uint8_t *data;
  
     data = _zip_buffer_peek(buffer, length);
  
     if (data != NULL) {
         buffer->offset += length;
     }
  
     return data;
 }

References _zip_buffer_peek(), length, NULL, and buffer::offset.

Referenced by _zip_buffer_get_16(), _zip_buffer_get_32(), _zip_buffer_get_64(), _zip_buffer_get_8(), _zip_buffer_put(), _zip_buffer_put_16(), _zip_buffer_put_32(), _zip_buffer_put_64(), _zip_buffer_put_8(), _zip_buffer_read(), _zip_dirent_process_ef_utf_8(), _zip_dirent_process_winzip_aes(), _zip_dirent_read(), _zip_ef_parse(), _zip_find_central_dir(), _zip_read_cdir(), _zip_read_data(), _zip_read_eocd(), and _zip_read_eocd64().

◆ _zip_buffer_get_16()

zip_uint16_t _zip_buffer_get_16 ( zip_buffer_t * buffer )

Definition at line 80 of file zip_buffer.c.

                                          {
     zip_uint8_t *data = _zip_buffer_get(buffer, 2);
  
     if (data == NULL) {
         return 0;
     }
  
     return (zip_uint16_t)(data[0] + (data[1] << 8));
 }

References _zip_buffer_get(), and NULL.

Referenced by _zip_dirent_process_winzip_aes(), _zip_dirent_read(), _zip_dirent_size(), _zip_ef_parse(), _zip_read_cdir(), _zip_read_eocd(), _zip_read_eocd64(), and _zip_read_local_ef().

◆ _zip_buffer_get_32()

zip_uint32_t _zip_buffer_get_32 ( zip_buffer_t * buffer )

Definition at line 92 of file zip_buffer.c.

                                          {
     zip_uint8_t *data = _zip_buffer_get(buffer, 4);
  
     if (data == NULL) {
         return 0;
     }
  
     return ((((((zip_uint32_t)data[3] << 8) + data[2]) << 8) + data[1]) << 8) + data[0];
 }

References _zip_buffer_get(), and NULL.

Referenced by _zip_dirent_process_ef_utf_8(), _zip_dirent_read(), _zip_read_eocd(), and _zip_read_eocd64().

◆ _zip_buffer_get_64()

zip_uint64_t _zip_buffer_get_64 ( zip_buffer_t * buffer )

Definition at line 104 of file zip_buffer.c.

                                          {
     zip_uint8_t *data = _zip_buffer_get(buffer, 8);
  
     if (data == NULL) {
         return 0;
     }
  
     return ((zip_uint64_t)data[7] << 56) + ((zip_uint64_t)data[6] << 48) + ((zip_uint64_t)data[5] << 40) + ((zip_uint64_t)data[4] << 32) + ((zip_uint64_t)data[3] << 24) + ((zip_uint64_t)data[2] << 16) + ((zip_uint64_t)data[1] << 8) + (zip_uint64_t)data[0];
 }

References _zip_buffer_get(), and NULL.

Referenced by _zip_dirent_read(), and _zip_read_eocd64().

◆ _zip_buffer_get_8()

zip_uint8_t _zip_buffer_get_8 ( zip_buffer_t * buffer )

Definition at line 116 of file zip_buffer.c.

                                         {
     zip_uint8_t *data = _zip_buffer_get(buffer, 1);
  
     if (data == NULL) {
         return 0;
     }
  
     return data[0];
 }

References _zip_buffer_get(), and NULL.

Referenced by _zip_dirent_process_ef_utf_8(), and _zip_dirent_process_winzip_aes().

◆ _zip_buffer_left()

zip_uint64_t _zip_buffer_left ( zip_buffer_t * buffer )

Definition at line 128 of file zip_buffer.c.

                                        {
     return buffer->ok ? buffer->size - buffer->offset : 0;
 }

References buffer::offset, and buffer::size.

Referenced by _zip_buffer_read(), _zip_dirent_process_ef_utf_8(), _zip_dirent_read(), _zip_ef_parse(), _zip_find_central_dir(), _zip_read_cdir(), and _zip_read_eocd().

◆ _zip_buffer_new()

zip_buffer_t* _zip_buffer_new	(	zip_uint8_t *	data,
		zip_uint64_t	size
	)

Definition at line 146 of file zip_buffer.c.

                                                       {
     bool free_data = (data == NULL);
     zip_buffer_t *buffer;
  
     if (data == NULL) {
         if ((data = (zip_uint8_t *)malloc(size)) == NULL) {
             return NULL;
         }
     }
  
     if ((buffer = (zip_buffer_t *)malloc(sizeof(*buffer))) == NULL) {
         if (free_data) {
             free(data);
         }
         return NULL;
     }
  
     buffer->ok = true;
     buffer->data = data;
     buffer->size = size;
     buffer->offset = 0;
     buffer->free_data = free_data;
  
     return buffer;
 }

References free(), malloc(), NULL, buffer::offset, and buffer::size.

Referenced by _zip_buffer_new_from_source(), _zip_cdir_write(), _zip_dirent_process_ef_utf_8(), _zip_dirent_process_winzip_aes(), _zip_dirent_read(), _zip_dirent_write(), _zip_ef_parse(), _zip_ef_utf8(), _zip_ef_write(), _zip_read_cdir(), encrypt_header(), input(), winzip_aes_encrypt(), and write_data_descriptor().

◆ _zip_buffer_new_from_source()

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

Definition at line 174 of file zip_buffer.c.

                                                                                                         {
     zip_buffer_t *buffer;
  
     if ((buffer = _zip_buffer_new(buf, size)) == NULL) {
         zip_error_set(error, ZIP_ER_MEMORY, 0);
         return NULL;
     }
  
     if (_zip_read(src, buffer->data, size, error) < 0) {
         _zip_buffer_free(buffer);
         return NULL;
     }
  
     return buffer;
 }

References _zip_buffer_free(), _zip_buffer_new(), _zip_read(), error(), NULL, src, ZIP_ER_MEMORY, and zip_error_set().

Referenced by _zip_dirent_read(), _zip_dirent_size(), _zip_find_central_dir(), _zip_read_eocd64(), and _zip_read_local_ef().

◆ _zip_buffer_offset()

zip_uint64_t _zip_buffer_offset ( zip_buffer_t * buffer )

Definition at line 192 of file zip_buffer.c.

                                          {
     return buffer->ok ? buffer->offset : 0;
 }

References buffer::offset.

Referenced by _zip_cdir_write(), _zip_dirent_write(), _zip_ef_utf8(), _zip_read_cdir(), _zip_read_eocd(), _zip_read_eocd64(), and write_data_descriptor().

◆ _zip_buffer_ok()

bool _zip_buffer_ok ( zip_buffer_t * buffer )

Definition at line 198 of file zip_buffer.c.

                                      {
     return buffer->ok;
 }

Referenced by _zip_cdir_write(), _zip_dirent_read(), _zip_dirent_write(), _zip_ef_parse(), _zip_ef_utf8(), _zip_ef_write(), _zip_read_eocd64(), and write_data_descriptor().

◆ _zip_buffer_peek()

zip_uint8_t* _zip_buffer_peek	(	zip_buffer_t *	buffer,
		zip_uint64_t	length
	)

Definition at line 204 of file zip_buffer.c.

                                                             {
     zip_uint8_t *data;
  
     if (!buffer->ok || buffer->offset + length < length || buffer->offset + length > buffer->size) {
         buffer->ok = false;
         return NULL;
     }
  
     data = buffer->data + buffer->offset;
     return data;
 }

References length, NULL, buffer::offset, and buffer::size.

Referenced by _zip_buffer_get().

◆ _zip_buffer_put()

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

Definition at line 217 of file zip_buffer.c.

                                                                       {
     zip_uint8_t *dst = _zip_buffer_get(buffer, length);
  
     if (dst == NULL) {
         return -1;
     }
  
     memcpy(dst, src, length);
     return 0;
 }

References _zip_buffer_get(), dst, length, memcpy(), NULL, and src.

Referenced by _zip_cdir_write(), _zip_dirent_write(), _zip_ef_utf8(), and write_data_descriptor().

◆ _zip_buffer_put_16()

int _zip_buffer_put_16	(	zip_buffer_t *	buffer,
		zip_uint16_t	i
	)

Definition at line 230 of file zip_buffer.c.

                                                          {
     zip_uint8_t *data = _zip_buffer_get(buffer, 2);
  
     if (data == NULL) {
         return -1;
     }
  
     data[0] = (zip_uint8_t)(i & 0xff);
     data[1] = (zip_uint8_t)((i >> 8) & 0xff);
  
     return 0;
 }

References _zip_buffer_get(), i, and NULL.

Referenced by _zip_cdir_write(), _zip_dirent_write(), and _zip_ef_write().

◆ _zip_buffer_put_32()

int _zip_buffer_put_32	(	zip_buffer_t *	buffer,
		zip_uint32_t	i
	)

Definition at line 245 of file zip_buffer.c.

                                                          {
     zip_uint8_t *data = _zip_buffer_get(buffer, 4);
  
     if (data == NULL) {
         return -1;
     }
  
     data[0] = (zip_uint8_t)(i & 0xff);
     data[1] = (zip_uint8_t)((i >> 8) & 0xff);
     data[2] = (zip_uint8_t)((i >> 16) & 0xff);
     data[3] = (zip_uint8_t)((i >> 24) & 0xff);
  
     return 0;
 }

References _zip_buffer_get(), i, and NULL.

Referenced by _zip_cdir_write(), _zip_dirent_write(), _zip_ef_utf8(), and write_data_descriptor().

◆ _zip_buffer_put_64()

int _zip_buffer_put_64	(	zip_buffer_t *	buffer,
		zip_uint64_t	i
	)

Definition at line 262 of file zip_buffer.c.

                                                          {
     zip_uint8_t *data = _zip_buffer_get(buffer, 8);
  
     if (data == NULL) {
         return -1;
     }
  
     data[0] = (zip_uint8_t)(i & 0xff);
     data[1] = (zip_uint8_t)((i >> 8) & 0xff);
     data[2] = (zip_uint8_t)((i >> 16) & 0xff);
     data[3] = (zip_uint8_t)((i >> 24) & 0xff);
     data[4] = (zip_uint8_t)((i >> 32) & 0xff);
     data[5] = (zip_uint8_t)((i >> 40) & 0xff);
     data[6] = (zip_uint8_t)((i >> 48) & 0xff);
     data[7] = (zip_uint8_t)((i >> 56) & 0xff);
  
     return 0;
 }

References _zip_buffer_get(), i, and NULL.

Referenced by _zip_cdir_write(), _zip_dirent_write(), input(), and write_data_descriptor().

◆ _zip_buffer_put_8()

int _zip_buffer_put_8	(	zip_buffer_t *	buffer,
		zip_uint8_t	i
	)

Definition at line 283 of file zip_buffer.c.

                                                        {
     zip_uint8_t *data = _zip_buffer_get(buffer, 1);
  
     if (data == NULL) {
         return -1;
     }
  
     data[0] = i;
  
     return 0;
 }

References _zip_buffer_get(), i, and NULL.

Referenced by _zip_dirent_write(), and _zip_ef_utf8().

◆ _zip_buffer_read()

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

Definition at line 134 of file zip_buffer.c.

                                                                                {
     if (_zip_buffer_left(buffer) < length) {
         length = _zip_buffer_left(buffer);
     }
  
     memcpy(data, _zip_buffer_get(buffer, length), length);
  
     return length;
 }

References _zip_buffer_get(), _zip_buffer_left(), length, and memcpy().

Referenced by pkware_encrypt(), and winzip_aes_encrypt().

◆ _zip_buffer_set_offset()

int _zip_buffer_set_offset	(	zip_buffer_t *	buffer,
		zip_uint64_t	offset
	)

Definition at line 297 of file zip_buffer.c.

                                                                   {
     if (offset > buffer->size) {
         buffer->ok = false;
         return -1;
     }
  
     buffer->ok = true;
     buffer->offset = offset;
  
     return 0;
 }

References buffer::offset, and buffer::size.

Referenced by _zip_buffer_skip(), _zip_dirent_read(), _zip_ef_write(), _zip_find_central_dir(), _zip_read_cdir(), and _zip_read_eocd64().

◆ _zip_buffer_size()

zip_uint64_t _zip_buffer_size ( zip_buffer_t * buffer )

Definition at line 322 of file zip_buffer.c.

                                        {
     return buffer->size;
 }

References buffer::size.

Referenced by _zip_read_eocd64().

◆ _zip_buffer_skip()

int _zip_buffer_skip	(	zip_buffer_t *	buffer,
		zip_uint64_t	length
	)

Definition at line 311 of file zip_buffer.c.

                                                             {
     zip_uint64_t offset = buffer->offset + length;
  
     if (offset < buffer->offset) {
         buffer->ok = false;
         return -1;
     }
     return _zip_buffer_set_offset(buffer, offset);
 }

References _zip_buffer_set_offset(), length, and buffer::offset.

Referenced by _zip_dirent_read().

◆ _zip_cdir_free()

void _zip_cdir_free ( zip_cdir_t * cd )

Definition at line 49 of file zip_dirent.c.

                                {
     zip_uint64_t i;
  
     if (!cd)
         return;
  
     for (i = 0; i < cd->nentry; i++)
         _zip_entry_finalize(cd->entry + i);
     free(cd->entry);
     _zip_string_free(cd->comment);
     free(cd);
 }

References _zip_entry_finalize(), _zip_string_free(), cd, free(), and i.

Referenced by _zip_cdir_new(), _zip_find_central_dir(), and _zip_read_cdir().

◆ _zip_cdir_grow()

bool _zip_cdir_grow	(	zip_cdir_t *	cd,
		zip_uint64_t	additional_entries,
		zip_error_t *	error
	)

Definition at line 88 of file zip_dirent.c.

                                                                                     {
     zip_uint64_t i, new_alloc;
     zip_entry_t *new_entry;
  
     if (additional_entries == 0) {
         return true;
     }
  
     new_alloc = cd->nentry_alloc + additional_entries;
  
     if (new_alloc < additional_entries || new_alloc > SIZE_MAX / sizeof(*(cd->entry))) {
         zip_error_set(error, ZIP_ER_MEMORY, 0);
         return false;
     }
  
     if ((new_entry = (zip_entry_t *)realloc(cd->entry, sizeof(*(cd->entry)) * (size_t)new_alloc)) == NULL) {
         zip_error_set(error, ZIP_ER_MEMORY, 0);
         return false;
     }
  
     cd->entry = new_entry;
  
     for (i = cd->nentry; i < new_alloc; i++) {
         _zip_entry_init(cd->entry + i);
     }
  
     cd->nentry = cd->nentry_alloc = new_alloc;
  
     return true;
 }

References _zip_entry_init(), cd, error(), i, NULL, realloc(), SIZE_MAX, ZIP_ER_MEMORY, and zip_error_set().

Referenced by _zip_cdir_new(), and _zip_read_cdir().

◆ _zip_cdir_new()

zip_cdir_t* _zip_cdir_new	(	zip_uint64_t	nentry,
		zip_error_t *	error
	)

Definition at line 64 of file zip_dirent.c.

                                                        {
     zip_cdir_t *cd;
  
     if ((cd = (zip_cdir_t *)malloc(sizeof(*cd))) == NULL) {
         zip_error_set(error, ZIP_ER_MEMORY, 0);
         return NULL;
     }
  
     cd->entry = NULL;
     cd->nentry = cd->nentry_alloc = 0;
     cd->size = cd->offset = 0;
     cd->comment = NULL;
     cd->is_zip64 = false;
  
     if (!_zip_cdir_grow(cd, nentry, error)) {
         _zip_cdir_free(cd);
         return NULL;
     }
  
     return cd;
 }

References _zip_cdir_free(), _zip_cdir_grow(), cd, error(), malloc(), NULL, ZIP_ER_MEMORY, and zip_error_set().

Referenced by _zip_read_eocd(), and _zip_read_eocd64().

◆ _zip_cdir_write()

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

Definition at line 121 of file zip_dirent.c.

                                                                                    {
     zip_uint64_t offset, size;
     zip_string_t *comment;
     zip_uint8_t buf[EOCDLEN + EOCD64LEN + EOCD64LOCLEN];
     zip_buffer_t *buffer;
     zip_int64_t off;
     zip_uint64_t i;
     bool is_zip64;
     int ret;
  
     if ((off = zip_source_tell_write(za->src)) < 0) {
         _zip_error_set_from_source(&za->error, za->src);
         return -1;
     }
     offset = (zip_uint64_t)off;
  
     is_zip64 = false;
  
     for (i = 0; i < survivors; i++) {
         zip_entry_t *entry = za->entry + filelist[i].idx;
  
         if ((ret = _zip_dirent_write(za, entry->changes ? entry->changes : entry->orig, ZIP_FL_CENTRAL)) < 0)
             return -1;
         if (ret)
             is_zip64 = true;
     }
  
     if ((off = zip_source_tell_write(za->src)) < 0) {
         _zip_error_set_from_source(&za->error, za->src);
         return -1;
     }
     size = (zip_uint64_t)off - offset;
  
     if (offset > ZIP_UINT32_MAX || survivors > ZIP_UINT16_MAX)
         is_zip64 = true;
  
  
     if ((buffer = _zip_buffer_new(buf, sizeof(buf))) == NULL) {
         zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
         return -1;
     }
  
     if (is_zip64) {
         _zip_buffer_put(buffer, EOCD64_MAGIC, 4);
         _zip_buffer_put_64(buffer, EOCD64LEN - 12);
         _zip_buffer_put_16(buffer, 45);
         _zip_buffer_put_16(buffer, 45);
         _zip_buffer_put_32(buffer, 0);
         _zip_buffer_put_32(buffer, 0);
         _zip_buffer_put_64(buffer, survivors);
         _zip_buffer_put_64(buffer, survivors);
         _zip_buffer_put_64(buffer, size);
         _zip_buffer_put_64(buffer, offset);
         _zip_buffer_put(buffer, EOCD64LOC_MAGIC, 4);
         _zip_buffer_put_32(buffer, 0);
         _zip_buffer_put_64(buffer, offset + size);
         _zip_buffer_put_32(buffer, 1);
     }
  
     _zip_buffer_put(buffer, EOCD_MAGIC, 4);
     _zip_buffer_put_32(buffer, 0);
     _zip_buffer_put_16(buffer, (zip_uint16_t)(survivors >= ZIP_UINT16_MAX ? ZIP_UINT16_MAX : survivors));
     _zip_buffer_put_16(buffer, (zip_uint16_t)(survivors >= ZIP_UINT16_MAX ? ZIP_UINT16_MAX : survivors));
     _zip_buffer_put_32(buffer, size >= ZIP_UINT32_MAX ? ZIP_UINT32_MAX : (zip_uint32_t)size);
     _zip_buffer_put_32(buffer, offset >= ZIP_UINT32_MAX ? ZIP_UINT32_MAX : (zip_uint32_t)offset);
  
     comment = za->comment_changed ? za->comment_changes : za->comment_orig;
  
     _zip_buffer_put_16(buffer, (zip_uint16_t)(comment ? comment->length : 0));
  
     if (!_zip_buffer_ok(buffer)) {
         zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
         _zip_buffer_free(buffer);
         return -1;
     }
  
     if (_zip_write(za, _zip_buffer_data(buffer), _zip_buffer_offset(buffer)) < 0) {
         _zip_buffer_free(buffer);
         return -1;
     }
  
     _zip_buffer_free(buffer);
  
     if (comment) {
         if (_zip_write(za, comment->raw, comment->length) < 0) {
             return -1;
         }
     }
  
     return (zip_int64_t)size;
 }

References _zip_buffer_data(), _zip_buffer_free(), _zip_buffer_new(), _zip_buffer_offset(), _zip_buffer_ok(), _zip_buffer_put(), _zip_buffer_put_16(), _zip_buffer_put_32(), _zip_buffer_put_64(), _zip_dirent_write(), _zip_error_set_from_source(), _zip_write(), zip::comment_changed, zip::comment_changes, zip::comment_orig, zip::entry, EOCD64_MAGIC, EOCD64LEN, EOCD64LOC_MAGIC, EOCD64LOCLEN, EOCD_MAGIC, EOCDLEN, zip::error, i, zip_filelist::idx, zip_string::length, NULL, off, zip_string::raw, zip::src, za, ZIP_ER_INTERNAL, ZIP_ER_MEMORY, zip_error_set(), ZIP_FL_CENTRAL, zip_source_tell_write(), ZIP_UINT16_MAX, and ZIP_UINT32_MAX.

Referenced by write_cdir().

◆ _zip_changed()

int _zip_changed	(	const zip_t *	za,
		zip_uint64_t *	survivorsp
	)

Definition at line 655 of file zip_close.c.

                                                         {
     int changed;
     zip_uint64_t i, survivors;
  
     changed = 0;
     survivors = 0;
  
     if (za->comment_changed || za->ch_flags != za->flags) {
         changed = 1;
     }
  
     for (i = 0; i < za->nentry; i++) {
         if (ZIP_ENTRY_HAS_CHANGES(&za->entry[i])) {
             changed = 1;
         }
         if (!za->entry[i].deleted) {
             survivors++;
         }
     }
  
     if (survivorsp) {
         *survivorsp = survivors;
     }
  
     return changed;
 }

References zip::ch_flags, zip::comment_changed, zip_entry::deleted, zip::entry, zip::flags, i, zip::nentry, za, and ZIP_ENTRY_HAS_CHANGES.

Referenced by zip_close(), and zip_set_archive_flag().

◆ _zip_cp437_to_utf8()

zip_uint8_t* _zip_cp437_to_utf8	(	const zip_uint8_t * const	_cp437buf,
		zip_uint32_t	len,
		zip_uint32_t *	utf8_lenp,
		zip_error_t *	error
	)

Definition at line 198 of file zip_utf-8.c.

                                                                                                                       {
     zip_uint8_t *cp437buf = (zip_uint8_t *)_cp437buf;
     zip_uint8_t *utf8buf;
     zip_uint32_t buflen, i, offset;
  
     if (len == 0) {
         if (utf8_lenp)
             *utf8_lenp = 0;
         return NULL;
     }
  
     buflen = 1;
     for (i = 0; i < len; i++)
         buflen += _zip_unicode_to_utf8_len(_cp437_to_unicode[cp437buf[i]]);
  
     if ((utf8buf = (zip_uint8_t *)malloc(buflen)) == NULL) {
         zip_error_set(error, ZIP_ER_MEMORY, 0);
         return NULL;
     }
  
     offset = 0;
     for (i = 0; i < len; i++)
         offset += _zip_unicode_to_utf8(_cp437_to_unicode[cp437buf[i]], utf8buf + offset);
  
     utf8buf[buflen - 1] = 0;
     if (utf8_lenp)
         *utf8_lenp = buflen - 1;
     return utf8buf;
 }

References _cp437_to_unicode, _zip_unicode_to_utf8(), _zip_unicode_to_utf8_len(), buflen, error(), i, len, malloc(), NULL, ZIP_ER_MEMORY, and zip_error_set().

Referenced by _zip_string_get().

◆ _zip_d2u_time()

time_t _zip_d2u_time	(	zip_uint16_t	dtime,
		zip_uint16_t	ddate
	)

Definition at line 1004 of file zip_dirent.c.

                                                       {
     struct tm tm;
  
     memset(&tm, 0, sizeof(tm));
  
     /* let mktime decide if DST is in effect */
     tm.tm_isdst = -1;
  
     tm.tm_year = ((ddate >> 9) & 127) + 1980 - 1900;
     tm.tm_mon = ((ddate >> 5) & 15) - 1;
     tm.tm_mday = ddate & 31;
  
     tm.tm_hour = (dtime >> 11) & 31;
     tm.tm_min = (dtime >> 5) & 63;
     tm.tm_sec = (dtime << 1) & 62;
  
     return mktime(&tm);
 }

References memset().

Referenced by _zip_dirent_read(), and zip_file_set_dostime().

◆ _zip_deregister_source()

void _zip_deregister_source	(	zip_t *	za,
		zip_source_t *	src
	)

Definition at line 306 of file zip_source_window.c.

                                                      {
     unsigned int i;
  
     for (i = 0; i < za->nopen_source; i++) {
         if (za->open_source[i] == src) {
             za->open_source[i] = za->open_source[za->nopen_source - 1];
             za->nopen_source--;
             break;
         }
     }
 }

References i, zip::nopen_source, zip::open_source, src, and za.

Referenced by zip_source_free().

◆ _zip_dirent_apply_attributes()

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

Definition at line 1117 of file zip_dirent.c.

                                                                                                                           {
     zip_uint16_t length;
  
     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;
     }
  
     if (de->comp_method == ZIP_CM_LZMA) {
         de->version_needed = 63;
     }
     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) {
         de->version_needed = 46;
     }
     else if (force_zip64 || _zip_dirent_needs_zip64(de, 0)) {
         de->version_needed = 45;
     }
     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] == '/') {
         de->version_needed = 20;
     }
     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);
     }
 }

References _zip_dirent_needs_zip64(), _zip_string_length(), zip_file_attributes::ascii, zip_dirent::bitflags, zip_dirent::comp_method, zip_dirent::encryption_method, zip_dirent::ext_attrib, zip_file_attributes::external_file_attributes, zip_dirent::filename, zip_file_attributes::general_purpose_bit_flags, zip_file_attributes::general_purpose_bit_mask, zip_file_attributes::host_system, zip_dirent::int_attrib, length, mask, zip_string::raw, zip_file_attributes::valid, zip_dirent::version_madeby, zip_file_attributes::version_needed, zip_dirent::version_needed, ZIP_CM_BZIP2, ZIP_CM_DEFLATE, ZIP_CM_LZMA, ZIP_DIRENT_ATTRIBUTES, ZIP_EM_AES_128, ZIP_EM_AES_192, ZIP_EM_AES_256, ZIP_EM_TRAD_PKWARE, ZIP_FILE_ATTRIBUTES_ASCII, ZIP_FILE_ATTRIBUTES_EXTERNAL_FILE_ATTRIBUTES, ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS, ZIP_FILE_ATTRIBUTES_GENERAL_PURPOSE_BIT_FLAGS_ALLOWED_MASK, ZIP_FILE_ATTRIBUTES_HOST_SYSTEM, ZIP_FILE_ATTRIBUTES_VERSION_NEEDED, and ZIP_MAX.

Referenced by add_data().

◆ _zip_dirent_clone()

zip_dirent_t* _zip_dirent_clone ( const zip_dirent_t * sde )

Definition at line 215 of file zip_dirent.c.

                                            {
     zip_dirent_t *tde;
  
     if ((tde = (zip_dirent_t *)malloc(sizeof(*tde))) == NULL)
         return NULL;
  
     if (sde)
         memcpy(tde, sde, sizeof(*sde));
     else
         _zip_dirent_init(tde);
  
     tde->changed = 0;
     tde->cloned = 1;
  
     return tde;
 }

References _zip_dirent_init(), zip_dirent::changed, zip_dirent::cloned, malloc(), memcpy(), and NULL.

Referenced by _zip_file_extra_field_prepare_for_change(), _zip_file_replace(), _zip_set_name(), zip_close(), zip_file_set_comment(), zip_file_set_encryption(), zip_file_set_external_attributes(), zip_file_set_mtime(), and zip_set_file_compression().

◆ _zip_dirent_finalize()

void _zip_dirent_finalize ( zip_dirent_t * zde )

Definition at line 234 of file zip_dirent.c.

                                         {
     if (!zde->cloned || zde->changed & ZIP_DIRENT_FILENAME) {
         _zip_string_free(zde->filename);
         zde->filename = NULL;
     }
     if (!zde->cloned || zde->changed & ZIP_DIRENT_EXTRA_FIELD) {
         _zip_ef_free(zde->extra_fields);
         zde->extra_fields = NULL;
     }
     if (!zde->cloned || zde->changed & ZIP_DIRENT_COMMENT) {
         _zip_string_free(zde->comment);
         zde->comment = NULL;
     }
     if (!zde->cloned || zde->changed & ZIP_DIRENT_PASSWORD) {
         if (zde->password) {
             _zip_crypto_clear(zde->password, strlen(zde->password));
         }
         free(zde->password);
         zde->password = NULL;
     }
 }

References _zip_crypto_clear, _zip_ef_free(), _zip_string_free(), zip_dirent::changed, zip_dirent::cloned, zip_dirent::comment, zip_dirent::extra_fields, zip_dirent::filename, free(), NULL, zip_dirent::password, ZIP_DIRENT_COMMENT, ZIP_DIRENT_EXTRA_FIELD, ZIP_DIRENT_FILENAME, and ZIP_DIRENT_PASSWORD.

Referenced by _zip_checkcons(), and _zip_dirent_free().

◆ _zip_dirent_free()

void _zip_dirent_free ( zip_dirent_t * zde )

Definition at line 258 of file zip_dirent.c.

                                     {
     if (zde == NULL)
         return;
  
     _zip_dirent_finalize(zde);
     free(zde);
 }

References _zip_dirent_finalize(), free(), and NULL.

Referenced by _zip_entry_finalize(), _zip_set_name(), _zip_unchange(), _zip_unchange_data(), zip_file_set_comment(), zip_file_set_encryption(), zip_file_set_external_attributes(), and zip_set_file_compression().

◆ _zip_dirent_init()

void _zip_dirent_init ( zip_dirent_t * de )

Definition at line 268 of file zip_dirent.c.

                                    {
     de->changed = 0;
     de->local_extra_fields_read = 0;
     de->cloned = 0;
  
     de->crc_valid = true;
     de->version_madeby = 63 | (ZIP_OPSYS_DEFAULT << 8);
     de->version_needed = 10; /* 1.0 */
     de->bitflags = 0;
     de->comp_method = ZIP_CM_DEFAULT;
     de->last_mod = 0;
     de->crc = 0;
     de->comp_size = 0;
     de->uncomp_size = 0;
     de->filename = NULL;
     de->extra_fields = NULL;
     de->comment = NULL;
     de->disk_number = 0;
     de->int_attrib = 0;
     de->ext_attrib = ZIP_EXT_ATTRIB_DEFAULT;
     de->offset = 0;
     de->compression_level = 0;
     de->encryption_method = ZIP_EM_NONE;
     de->password = NULL;
 }

References zip_dirent::bitflags, zip_dirent::changed, zip_dirent::cloned, zip_dirent::comment, zip_dirent::comp_method, zip_dirent::comp_size, zip_dirent::compression_level, zip_dirent::crc, zip_dirent::crc_valid, zip_dirent::disk_number, zip_dirent::encryption_method, zip_dirent::ext_attrib, zip_dirent::extra_fields, zip_dirent::filename, zip_dirent::int_attrib, zip_dirent::last_mod, zip_dirent::local_extra_fields_read, NULL, zip_dirent::offset, zip_dirent::password, zip_dirent::uncomp_size, zip_dirent::version_madeby, zip_dirent::version_needed, ZIP_CM_DEFAULT, ZIP_EM_NONE, ZIP_EXT_ATTRIB_DEFAULT, and ZIP_OPSYS_DEFAULT.

Referenced by _zip_checkcons(), _zip_dirent_clone(), _zip_dirent_new(), and _zip_dirent_read().

◆ _zip_dirent_needs_zip64()

bool _zip_dirent_needs_zip64	(	const zip_dirent_t *	de,
		zip_flags_t	flags
	)

Definition at line 296 of file zip_dirent.c.

                                                                    {
     if (de->uncomp_size >= ZIP_UINT32_MAX || de->comp_size >= ZIP_UINT32_MAX || ((flags & ZIP_FL_CENTRAL) && de->offset >= ZIP_UINT32_MAX))
         return true;
  
     return false;
 }

References zip_dirent::comp_size, flags, zip_dirent::offset, zip_dirent::uncomp_size, ZIP_FL_CENTRAL, and ZIP_UINT32_MAX.

Referenced by _zip_dirent_apply_attributes(), _zip_dirent_write(), _zip_file_get_end(), and zip_close().

◆ _zip_dirent_new()

zip_dirent_t* _zip_dirent_new ( void )

Definition at line 305 of file zip_dirent.c.

                       {
     zip_dirent_t *de;
  
     if ((de = (zip_dirent_t *)malloc(sizeof(*de))) == NULL)
         return NULL;
  
     _zip_dirent_init(de);
     return de;
 }

References _zip_dirent_init(), malloc(), and NULL.

Referenced by _zip_read_cdir().

◆ _zip_dirent_read()

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

Definition at line 327 of file zip_dirent.c.

                                                                                                              {
     zip_uint8_t buf[CDENTRYSIZE];
     zip_uint16_t dostime, dosdate;
     zip_uint32_t size, variable_size;
     zip_uint16_t filename_len, comment_len, ef_len;
  
     bool from_buffer = (buffer != NULL);
  
     size = local ? LENTRYSIZE : CDENTRYSIZE;
  
     if (buffer) {
         if (_zip_buffer_left(buffer) < size) {
             zip_error_set(error, ZIP_ER_NOZIP, 0);
             return -1;
         }
     }
     else {
         if ((buffer = _zip_buffer_new_from_source(src, size, buf, error)) == NULL) {
             return -1;
         }
     }
  
     if (memcmp(_zip_buffer_get(buffer, 4), (local ? LOCAL_MAGIC : CENTRAL_MAGIC), 4) != 0) {
         zip_error_set(error, ZIP_ER_NOZIP, 0);
         if (!from_buffer) {
             _zip_buffer_free(buffer);
         }
         return -1;
     }
  
     /* convert buffercontents to zip_dirent */
  
     _zip_dirent_init(zde);
     if (!local)
         zde->version_madeby = _zip_buffer_get_16(buffer);
     else
         zde->version_madeby = 0;
     zde->version_needed = _zip_buffer_get_16(buffer);
     zde->bitflags = _zip_buffer_get_16(buffer);
     zde->comp_method = _zip_buffer_get_16(buffer);
  
     /* convert to time_t */
     dostime = _zip_buffer_get_16(buffer);
     dosdate = _zip_buffer_get_16(buffer);
     zde->last_mod = _zip_d2u_time(dostime, dosdate);
  
     zde->crc = _zip_buffer_get_32(buffer);
     zde->comp_size = _zip_buffer_get_32(buffer);
     zde->uncomp_size = _zip_buffer_get_32(buffer);
  
     filename_len = _zip_buffer_get_16(buffer);
     ef_len = _zip_buffer_get_16(buffer);
  
     if (local) {
         comment_len = 0;
         zde->disk_number = 0;
         zde->int_attrib = 0;
         zde->ext_attrib = 0;
         zde->offset = 0;
     }
     else {
         comment_len = _zip_buffer_get_16(buffer);
         zde->disk_number = _zip_buffer_get_16(buffer);
         zde->int_attrib = _zip_buffer_get_16(buffer);
         zde->ext_attrib = _zip_buffer_get_32(buffer);
         zde->offset = _zip_buffer_get_32(buffer);
     }
  
     if (!_zip_buffer_ok(buffer)) {
         zip_error_set(error, ZIP_ER_INTERNAL, 0);
         if (!from_buffer) {
             _zip_buffer_free(buffer);
         }
         return -1;
     }
  
     if (zde->bitflags & ZIP_GPBF_ENCRYPTED) {
         if (zde->bitflags & ZIP_GPBF_STRONG_ENCRYPTION) {
             /* TODO */
             zde->encryption_method = ZIP_EM_UNKNOWN;
         }
         else {
             zde->encryption_method = ZIP_EM_TRAD_PKWARE;
         }
     }
     else {
         zde->encryption_method = ZIP_EM_NONE;
     }
  
     zde->filename = NULL;
     zde->extra_fields = NULL;
     zde->comment = NULL;
  
     variable_size = (zip_uint32_t)filename_len + (zip_uint32_t)ef_len + (zip_uint32_t)comment_len;
  
     if (from_buffer) {
         if (_zip_buffer_left(buffer) < variable_size) {
             zip_error_set(error, ZIP_ER_INCONS, ZIP_ER_DETAIL_VARIABLE_SIZE_OVERFLOW);
             return -1;
         }
     }
     else {
         _zip_buffer_free(buffer);
  
         if ((buffer = _zip_buffer_new_from_source(src, variable_size, NULL, error)) == NULL) {
             return -1;
         }
     }
  
     if (filename_len) {
         zde->filename = _zip_read_string(buffer, src, filename_len, 1, error);
         if (!zde->filename) {
             if (zip_error_code_zip(error) == ZIP_ER_EOF) {
                 zip_error_set(error, ZIP_ER_INCONS, ZIP_ER_DETAIL_VARIABLE_SIZE_OVERFLOW);
             }
             if (!from_buffer) {
                 _zip_buffer_free(buffer);
             }
             return -1;
         }
  
         if (zde->bitflags & ZIP_GPBF_ENCODING_UTF_8) {
             if (_zip_guess_encoding(zde->filename, ZIP_ENCODING_UTF8_KNOWN) == ZIP_ENCODING_ERROR) {
                 zip_error_set(error, ZIP_ER_INCONS, ZIP_ER_DETAIL_INVALID_UTF8_IN_FILENAME);
                 if (!from_buffer) {
                     _zip_buffer_free(buffer);
                 }
                 return -1;
             }
         }
     }
  
     if (ef_len) {
         zip_uint8_t *ef = _zip_read_data(buffer, src, ef_len, 0, error);
  
         if (ef == NULL) {
             if (!from_buffer) {
                 _zip_buffer_free(buffer);
             }
             return -1;
         }
         if (!_zip_ef_parse(ef, ef_len, local ? ZIP_EF_LOCAL : ZIP_EF_CENTRAL, &zde->extra_fields, error)) {
             free(ef);
             if (!from_buffer) {
                 _zip_buffer_free(buffer);
             }
             return -1;
         }
         free(ef);
         if (local)
             zde->local_extra_fields_read = 1;
     }
  
     if (comment_len) {
         zde->comment = _zip_read_string(buffer, src, comment_len, 0, error);
         if (!zde->comment) {
             if (!from_buffer) {
                 _zip_buffer_free(buffer);
             }
             return -1;
         }
         if (zde->bitflags & ZIP_GPBF_ENCODING_UTF_8) {
             if (_zip_guess_encoding(zde->comment, ZIP_ENCODING_UTF8_KNOWN) == ZIP_ENCODING_ERROR) {
                 zip_error_set(error, ZIP_ER_INCONS, ZIP_ER_DETAIL_INVALID_UTF8_IN_COMMENT);
                 if (!from_buffer) {
                     _zip_buffer_free(buffer);
                 }
                 return -1;
             }
         }
     }
  
     zde->filename = _zip_dirent_process_ef_utf_8(zde, ZIP_EF_UTF_8_NAME, zde->filename);
     zde->comment = _zip_dirent_process_ef_utf_8(zde, ZIP_EF_UTF_8_COMMENT, zde->comment);
  
     /* Zip64 */
  
     if (zde->uncomp_size == ZIP_UINT32_MAX || zde->comp_size == ZIP_UINT32_MAX || zde->offset == ZIP_UINT32_MAX) {
         zip_uint16_t got_len;
         zip_buffer_t *ef_buffer;
         const zip_uint8_t *ef = _zip_ef_get_by_id(zde->extra_fields, &got_len, ZIP_EF_ZIP64, 0, local ? ZIP_EF_LOCAL : ZIP_EF_CENTRAL, error);
         /* TODO: if got_len == 0 && !ZIP64_EOCD: no error, 0xffffffff is valid value */
         if (ef == NULL) {
             if (!from_buffer) {
                 _zip_buffer_free(buffer);
             }
             return -1;
         }
  
         if ((ef_buffer = _zip_buffer_new((zip_uint8_t *)ef, got_len)) == NULL) {
             zip_error_set(error, ZIP_ER_MEMORY, 0);
             if (!from_buffer) {
                 _zip_buffer_free(buffer);
             }
             return -1;
         }
  
         if (zde->uncomp_size == ZIP_UINT32_MAX) {
             zde->uncomp_size = _zip_buffer_get_64(ef_buffer);
         }
         else if (local) {
             /* From appnote.txt: This entry in the Local header MUST
                include BOTH original and compressed file size fields. */
             (void)_zip_buffer_skip(ef_buffer, 8); /* error is caught by _zip_buffer_eof() call */
         }
         if (zde->comp_size == ZIP_UINT32_MAX) {
             zde->comp_size = _zip_buffer_get_64(ef_buffer);
         }
         if (!local) {
             if (zde->offset == ZIP_UINT32_MAX) {
                 zde->offset = _zip_buffer_get_64(ef_buffer);
             }
             if (zde->disk_number == ZIP_UINT16_MAX) {
                 zde->disk_number = _zip_buffer_get_32(ef_buffer);
             }
         }
  
         if (!_zip_buffer_eof(ef_buffer)) {
             /* accept additional fields if values match */
             bool ok = true;
             switch (got_len) {
             case 28:
                 _zip_buffer_set_offset(ef_buffer, 24);
                 if (zde->disk_number != _zip_buffer_get_32(ef_buffer)) {
                     ok = false;
                 }
                 /* fallthrough */
             case 24:
                 _zip_buffer_set_offset(ef_buffer, 0);
                 if ((zde->uncomp_size != _zip_buffer_get_64(ef_buffer)) || (zde->comp_size != _zip_buffer_get_64(ef_buffer)) || (zde->offset != _zip_buffer_get_64(ef_buffer))) {
                     ok = false;
                 }
                 break;
  
             default:
                 ok = false;
             }
             if (!ok) {
                 zip_error_set(error, ZIP_ER_INCONS, ZIP_ER_DETAIL_INVALID_ZIP64_EF);
                 _zip_buffer_free(ef_buffer);
                 if (!from_buffer) {
                     _zip_buffer_free(buffer);
                 }
                 return -1;
             }
         }
         _zip_buffer_free(ef_buffer);
     }
  
     if (!_zip_buffer_ok(buffer)) {
         zip_error_set(error, ZIP_ER_INTERNAL, 0);
         if (!from_buffer) {
             _zip_buffer_free(buffer);
         }
         return -1;
     }
     if (!from_buffer) {
         _zip_buffer_free(buffer);
     }
  
     /* zip_source_seek / zip_source_tell don't support values > ZIP_INT64_MAX */
     if (zde->offset > ZIP_INT64_MAX) {
         zip_error_set(error, ZIP_ER_SEEK, EFBIG);
         return -1;
     }
  
     if (!_zip_dirent_process_winzip_aes(zde, error)) {
         return -1;
     }
  
     zde->extra_fields = _zip_ef_remove_internal(zde->extra_fields);
  
     return (zip_int64_t)size + (zip_int64_t)variable_size;
 }

References _zip_buffer_eof(), _zip_buffer_free(), _zip_buffer_get(), _zip_buffer_get_16(), _zip_buffer_get_32(), _zip_buffer_get_64(), _zip_buffer_left(), _zip_buffer_new(), _zip_buffer_new_from_source(), _zip_buffer_ok(), _zip_buffer_set_offset(), _zip_buffer_skip(), _zip_d2u_time(), _zip_dirent_init(), _zip_dirent_process_ef_utf_8(), _zip_dirent_process_winzip_aes(), _zip_ef_get_by_id(), _zip_ef_parse(), _zip_ef_remove_internal(), _zip_guess_encoding(), _zip_read_data(), _zip_read_string(), zip_dirent::bitflags, CDENTRYSIZE, CENTRAL_MAGIC, zip_dirent::comment, zip_dirent::comp_method, zip_dirent::comp_size, zip_dirent::crc, zip_dirent::disk_number, EFBIG, zip_dirent::encryption_method, error(), zip_dirent::ext_attrib, zip_dirent::extra_fields, zip_dirent::filename, free(), zip_dirent::int_attrib, zip_dirent::last_mod, LENTRYSIZE, local, zip_dirent::local_extra_fields_read, LOCAL_MAGIC, NULL, zip_dirent::offset, ok, src, zip_dirent::uncomp_size, zip_dirent::version_madeby, zip_dirent::version_needed, ZIP_EF_CENTRAL, ZIP_EF_LOCAL, ZIP_EF_UTF_8_COMMENT, ZIP_EF_UTF_8_NAME, ZIP_EF_ZIP64, ZIP_EM_NONE, ZIP_EM_TRAD_PKWARE, ZIP_EM_UNKNOWN, ZIP_ENCODING_ERROR, ZIP_ENCODING_UTF8_KNOWN, ZIP_ER_DETAIL_INVALID_UTF8_IN_COMMENT, ZIP_ER_DETAIL_INVALID_UTF8_IN_FILENAME, ZIP_ER_DETAIL_INVALID_ZIP64_EF, ZIP_ER_DETAIL_VARIABLE_SIZE_OVERFLOW, ZIP_ER_EOF, ZIP_ER_INCONS, ZIP_ER_INTERNAL, ZIP_ER_MEMORY, ZIP_ER_NOZIP, ZIP_ER_SEEK, zip_error_code_zip(), zip_error_set(), ZIP_GPBF_ENCODING_UTF_8, ZIP_GPBF_ENCRYPTED, ZIP_GPBF_STRONG_ENCRYPTION, ZIP_INT64_MAX, ZIP_UINT16_MAX, and ZIP_UINT32_MAX.

Referenced by _zip_checkcons(), and _zip_read_cdir().

◆ _zip_dirent_set_version_needed()

void _zip_dirent_set_version_needed	(	zip_dirent_t *	de,
		bool	force_zip64
	)

◆ _zip_dirent_size()

zip_int32_t _zip_dirent_size	(	zip_source_t *	src,
		zip_uint16_t	flags,
		zip_error_t *	error
	)

Definition at line 721 of file zip_dirent.c.

                                                                             {
     zip_int32_t size;
     bool local = (flags & ZIP_EF_LOCAL) != 0;
     int i;
     zip_uint8_t b[6];
     zip_buffer_t *buffer;
  
     size = local ? LENTRYSIZE : CDENTRYSIZE;
  
     if (zip_source_seek(src, local ? 26 : 28, SEEK_CUR) < 0) {
         _zip_error_set_from_source(error, src);
         return -1;
     }
  
     if ((buffer = _zip_buffer_new_from_source(src, local ? 4 : 6, b, error)) == NULL) {
         return -1;
     }
  
     for (i = 0; i < (local ? 2 : 3); i++) {
         size += _zip_buffer_get_16(buffer);
     }
  
     if (!_zip_buffer_eof(buffer)) {
         zip_error_set(error, ZIP_ER_INTERNAL, 0);
         _zip_buffer_free(buffer);
         return -1;
     }
  
     _zip_buffer_free(buffer);
     return size;
 }

References _zip_buffer_eof(), _zip_buffer_free(), _zip_buffer_get_16(), _zip_buffer_new_from_source(), _zip_error_set_from_source(), b, CDENTRYSIZE, error(), flags, i, LENTRYSIZE, local, NULL, SEEK_CUR, src, ZIP_EF_LOCAL, ZIP_ER_INTERNAL, zip_error_set(), and zip_source_seek().

Referenced by _zip_file_get_offset().

◆ _zip_dirent_write()

int _zip_dirent_write	(	zip_t *	za,
		zip_dirent_t *	dirent,
		zip_flags_t	flags
	)

Definition at line 765 of file zip_dirent.c.

                                                                   {
     zip_uint16_t dostime, dosdate;
     zip_encoding_type_t com_enc, name_enc;
     zip_extra_field_t *ef;
     zip_extra_field_t *ef64;
     zip_uint32_t ef_total_size;
     bool is_zip64;
     bool is_really_zip64;
     bool is_winzip_aes;
     zip_uint8_t buf[CDENTRYSIZE];
     zip_buffer_t *buffer;
  
     ef = NULL;
  
     name_enc = _zip_guess_encoding(de->filename, ZIP_ENCODING_UNKNOWN);
     com_enc = _zip_guess_encoding(de->comment, ZIP_ENCODING_UNKNOWN);
  
     if ((name_enc == ZIP_ENCODING_UTF8_KNOWN && com_enc == ZIP_ENCODING_ASCII) || (name_enc == ZIP_ENCODING_ASCII && com_enc == ZIP_ENCODING_UTF8_KNOWN) || (name_enc == ZIP_ENCODING_UTF8_KNOWN && com_enc == ZIP_ENCODING_UTF8_KNOWN))
         de->bitflags |= ZIP_GPBF_ENCODING_UTF_8;
     else {
         de->bitflags &= (zip_uint16_t)~ZIP_GPBF_ENCODING_UTF_8;
         if (name_enc == ZIP_ENCODING_UTF8_KNOWN) {
             ef = _zip_ef_utf8(ZIP_EF_UTF_8_NAME, de->filename, &za->error);
             if (ef == NULL)
                 return -1;
         }
         if ((flags & ZIP_FL_LOCAL) == 0 && com_enc == ZIP_ENCODING_UTF8_KNOWN) {
             zip_extra_field_t *ef2 = _zip_ef_utf8(ZIP_EF_UTF_8_COMMENT, de->comment, &za->error);
             if (ef2 == NULL) {
                 _zip_ef_free(ef);
                 return -1;
             }
             ef2->next = ef;
             ef = ef2;
         }
     }
  
     if (de->encryption_method == ZIP_EM_NONE) {
         de->bitflags &= (zip_uint16_t)~ZIP_GPBF_ENCRYPTED;
     }
     else {
         de->bitflags |= (zip_uint16_t)ZIP_GPBF_ENCRYPTED;
     }
  
     is_really_zip64 = _zip_dirent_needs_zip64(de, flags);
     is_zip64 = (flags & (ZIP_FL_LOCAL | ZIP_FL_FORCE_ZIP64)) == (ZIP_FL_LOCAL | ZIP_FL_FORCE_ZIP64) || is_really_zip64;
     is_winzip_aes = de->encryption_method == ZIP_EM_AES_128 || de->encryption_method == ZIP_EM_AES_192 || de->encryption_method == ZIP_EM_AES_256;
  
     if (is_zip64) {
         zip_uint8_t ef_zip64[EFZIP64SIZE];
         zip_buffer_t *ef_buffer = _zip_buffer_new(ef_zip64, sizeof(ef_zip64));
         if (ef_buffer == NULL) {
             zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
             _zip_ef_free(ef);
             return -1;
         }
  
         if (flags & ZIP_FL_LOCAL) {
             if ((flags & ZIP_FL_FORCE_ZIP64) || de->comp_size > ZIP_UINT32_MAX || de->uncomp_size > ZIP_UINT32_MAX) {
                 _zip_buffer_put_64(ef_buffer, de->uncomp_size);
                 _zip_buffer_put_64(ef_buffer, de->comp_size);
             }
         }
         else {
             if ((flags & ZIP_FL_FORCE_ZIP64) || de->comp_size > ZIP_UINT32_MAX || de->uncomp_size > ZIP_UINT32_MAX || de->offset > ZIP_UINT32_MAX) {
                 if (de->uncomp_size >= ZIP_UINT32_MAX) {
                     _zip_buffer_put_64(ef_buffer, de->uncomp_size);
                 }
                 if (de->comp_size >= ZIP_UINT32_MAX) {
                     _zip_buffer_put_64(ef_buffer, de->comp_size);
                 }
                 if (de->offset >= ZIP_UINT32_MAX) {
                     _zip_buffer_put_64(ef_buffer, de->offset);
                 }
             }
         }
  
         if (!_zip_buffer_ok(ef_buffer)) {
             zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
             _zip_buffer_free(ef_buffer);
             _zip_ef_free(ef);
             return -1;
         }
  
         ef64 = _zip_ef_new(ZIP_EF_ZIP64, (zip_uint16_t)(_zip_buffer_offset(ef_buffer)), ef_zip64, ZIP_EF_BOTH);
         _zip_buffer_free(ef_buffer);
         ef64->next = ef;
         ef = ef64;
     }
  
     if (is_winzip_aes) {
         zip_uint8_t data[EF_WINZIP_AES_SIZE];
         zip_buffer_t *ef_buffer = _zip_buffer_new(data, sizeof(data));
         zip_extra_field_t *ef_winzip;
  
         if (ef_buffer == NULL) {
             zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
             _zip_ef_free(ef);
             return -1;
         }
  
         _zip_buffer_put_16(ef_buffer, 2);
         _zip_buffer_put(ef_buffer, "AE", 2);
         _zip_buffer_put_8(ef_buffer, (zip_uint8_t)(de->encryption_method & 0xff));
         _zip_buffer_put_16(ef_buffer, (zip_uint16_t)de->comp_method);
  
         if (!_zip_buffer_ok(ef_buffer)) {
             zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
             _zip_buffer_free(ef_buffer);
             _zip_ef_free(ef);
             return -1;
         }
  
         ef_winzip = _zip_ef_new(ZIP_EF_WINZIP_AES, EF_WINZIP_AES_SIZE, data, ZIP_EF_BOTH);
         _zip_buffer_free(ef_buffer);
         ef_winzip->next = ef;
         ef = ef_winzip;
     }
  
     if ((buffer = _zip_buffer_new(buf, sizeof(buf))) == NULL) {
         zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
         _zip_ef_free(ef);
         return -1;
     }
  
     _zip_buffer_put(buffer, (flags & ZIP_FL_LOCAL) ? LOCAL_MAGIC : CENTRAL_MAGIC, 4);
  
     if ((flags & ZIP_FL_LOCAL) == 0) {
         _zip_buffer_put_16(buffer, de->version_madeby);
     }
     _zip_buffer_put_16(buffer, ZIP_MAX(is_really_zip64 ? 45 : 0, de->version_needed));
     _zip_buffer_put_16(buffer, de->bitflags);
     if (is_winzip_aes) {
         _zip_buffer_put_16(buffer, ZIP_CM_WINZIP_AES);
     }
     else {
         _zip_buffer_put_16(buffer, (zip_uint16_t)de->comp_method);
     }
  
     _zip_u2d_time(de->last_mod, &dostime, &dosdate);
     _zip_buffer_put_16(buffer, dostime);
     _zip_buffer_put_16(buffer, dosdate);
  
     if (is_winzip_aes && de->uncomp_size < 20) {
         _zip_buffer_put_32(buffer, 0);
     }
     else {
         _zip_buffer_put_32(buffer, de->crc);
     }
  
     if (((flags & ZIP_FL_LOCAL) == ZIP_FL_LOCAL) && ((de->comp_size >= ZIP_UINT32_MAX) || (de->uncomp_size >= ZIP_UINT32_MAX))) {
         /* In local headers, if a ZIP64 EF is written, it MUST contain
          * both compressed and uncompressed sizes (even if one of the
          * two is smaller than 0xFFFFFFFF); on the other hand, those
          * may only appear when the corresponding standard entry is
          * 0xFFFFFFFF.  (appnote.txt 4.5.3) */
         _zip_buffer_put_32(buffer, ZIP_UINT32_MAX);
         _zip_buffer_put_32(buffer, ZIP_UINT32_MAX);
     }
     else {
         if (de->comp_size < ZIP_UINT32_MAX) {
             _zip_buffer_put_32(buffer, (zip_uint32_t)de->comp_size);
         }
         else {
             _zip_buffer_put_32(buffer, ZIP_UINT32_MAX);
         }
         if (de->uncomp_size < ZIP_UINT32_MAX) {
             _zip_buffer_put_32(buffer, (zip_uint32_t)de->uncomp_size);
         }
         else {
             _zip_buffer_put_32(buffer, ZIP_UINT32_MAX);
         }
     }
  
     _zip_buffer_put_16(buffer, _zip_string_length(de->filename));
     /* TODO: check for overflow */
     ef_total_size = (zip_uint32_t)_zip_ef_size(de->extra_fields, flags) + (zip_uint32_t)_zip_ef_size(ef, ZIP_EF_BOTH);
     _zip_buffer_put_16(buffer, (zip_uint16_t)ef_total_size);
  
     if ((flags & ZIP_FL_LOCAL) == 0) {
         _zip_buffer_put_16(buffer, _zip_string_length(de->comment));
         _zip_buffer_put_16(buffer, (zip_uint16_t)de->disk_number);
         _zip_buffer_put_16(buffer, de->int_attrib);
         _zip_buffer_put_32(buffer, de->ext_attrib);
         if (de->offset < ZIP_UINT32_MAX)
             _zip_buffer_put_32(buffer, (zip_uint32_t)de->offset);
         else
             _zip_buffer_put_32(buffer, ZIP_UINT32_MAX);
     }
  
     if (!_zip_buffer_ok(buffer)) {
         zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
         _zip_buffer_free(buffer);
         _zip_ef_free(ef);
         return -1;
     }
  
     if (_zip_write(za, buf, _zip_buffer_offset(buffer)) < 0) {
         _zip_buffer_free(buffer);
         _zip_ef_free(ef);
         return -1;
     }
  
     _zip_buffer_free(buffer);
  
     if (de->filename) {
         if (_zip_string_write(za, de->filename) < 0) {
             _zip_ef_free(ef);
             return -1;
         }
     }
  
     if (ef) {
         if (_zip_ef_write(za, ef, ZIP_EF_BOTH) < 0) {
             _zip_ef_free(ef);
             return -1;
         }
     }
     _zip_ef_free(ef);
     if (de->extra_fields) {
         if (_zip_ef_write(za, de->extra_fields, flags) < 0) {
             return -1;
         }
     }
  
     if ((flags & ZIP_FL_LOCAL) == 0) {
         if (de->comment) {
             if (_zip_string_write(za, de->comment) < 0) {
                 return -1;
             }
         }
     }
  
  
     return is_zip64;
 }

References _zip_buffer_free(), _zip_buffer_new(), _zip_buffer_offset(), _zip_buffer_ok(), _zip_buffer_put(), _zip_buffer_put_16(), _zip_buffer_put_32(), _zip_buffer_put_64(), _zip_buffer_put_8(), _zip_dirent_needs_zip64(), _zip_ef_free(), _zip_ef_new(), _zip_ef_size(), _zip_ef_utf8(), _zip_ef_write(), _zip_guess_encoding(), _zip_string_length(), _zip_string_write(), _zip_u2d_time(), _zip_write(), zip_dirent::bitflags, CDENTRYSIZE, CENTRAL_MAGIC, zip_dirent::comment, zip_dirent::comp_method, zip_dirent::comp_size, zip_dirent::crc, zip_dirent::disk_number, ef, EF_WINZIP_AES_SIZE, EFZIP64SIZE, zip_dirent::encryption_method, zip::error, zip_dirent::ext_attrib, zip_dirent::extra_fields, zip_dirent::filename, flags, zip_dirent::int_attrib, zip_dirent::last_mod, LOCAL_MAGIC, zip_extra_field::next, NULL, zip_dirent::offset, zip_dirent::uncomp_size, zip_dirent::version_madeby, zip_dirent::version_needed, za, ZIP_CM_WINZIP_AES, ZIP_EF_BOTH, ZIP_EF_UTF_8_COMMENT, ZIP_EF_UTF_8_NAME, ZIP_EF_WINZIP_AES, ZIP_EF_ZIP64, ZIP_EM_AES_128, ZIP_EM_AES_192, ZIP_EM_AES_256, ZIP_EM_NONE, ZIP_ENCODING_ASCII, ZIP_ENCODING_UNKNOWN, ZIP_ENCODING_UTF8_KNOWN, ZIP_ER_INTERNAL, ZIP_ER_MEMORY, zip_error_set(), ZIP_FL_FORCE_ZIP64, ZIP_FL_LOCAL, ZIP_GPBF_ENCODING_UTF_8, ZIP_GPBF_ENCRYPTED, ZIP_MAX, and ZIP_UINT32_MAX.

Referenced by _zip_cdir_write(), add_data(), and zip_close().

◆ _zip_ef_clone()

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

Definition at line 41 of file zip_extra_field.c.

                                                                {
     zip_extra_field_t *head, *prev, *def;
  
     head = prev = NULL;
  
     while (ef) {
         if ((def = _zip_ef_new(ef->id, ef->size, ef->data, ef->flags)) == NULL) {
             zip_error_set(error, ZIP_ER_MEMORY, 0);
             _zip_ef_free(head);
             return NULL;
         }
  
         if (head == NULL)
             head = def;
         if (prev)
             prev->next = def;
         prev = def;
  
         ef = ef->next;
     }
  
     return head;
 }

References _zip_ef_free(), _zip_ef_new(), ef::data, def(), error(), ef::flags, test-lz4-versions::head, ef::id, zip_extra_field::next, NULL, ef::size, ZIP_ER_MEMORY, and zip_error_set().

Referenced by _zip_file_extra_field_prepare_for_change().

◆ _zip_ef_delete_by_id()

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

Definition at line 67 of file zip_extra_field.c.

                                                                                                      {
     zip_extra_field_t *head, *prev;
     int i;
  
     i = 0;
     head = ef;
     prev = NULL;
     for (; ef; ef = (prev ? prev->next : head)) {
         if ((ef->flags & flags & ZIP_EF_BOTH) && ((ef->id == id) || (id == ZIP_EXTRA_FIELD_ALL))) {
             if (id_idx == ZIP_EXTRA_FIELD_ALL || i == id_idx) {
                 ef->flags &= ~(flags & ZIP_EF_BOTH);
                 if ((ef->flags & ZIP_EF_BOTH) == 0) {
                     if (prev)
                         prev->next = ef->next;
                     else
                         head = ef->next;
                     ef->next = NULL;
                     _zip_ef_free(ef);
  
                     if (id_idx == ZIP_EXTRA_FIELD_ALL)
                         continue;
                 }
             }
  
             i++;
             if (i > id_idx)
                 break;
         }
         prev = ef;
     }
  
     return head;
 }

References _zip_ef_free(), ef, flags, ef::flags, test-lz4-versions::head, i, id, ef::id, zip_extra_field::next, NULL, ZIP_EF_BOTH, and ZIP_EXTRA_FIELD_ALL.

Referenced by zip_file_extra_field_delete(), and zip_file_extra_field_delete_by_id().

◆ _zip_ef_free()

void _zip_ef_free ( zip_extra_field_t * ef )

Definition at line 103 of file zip_extra_field.c.

                                     {
     zip_extra_field_t *ef2;
  
     while (ef) {
         ef2 = ef->next;
         free(ef->data);
         free(ef);
         ef = ef2;
     }
 }

References ef::data, and free().

Referenced by _zip_dirent_finalize(), _zip_dirent_write(), _zip_ef_clone(), _zip_ef_delete_by_id(), _zip_ef_merge(), _zip_ef_parse(), _zip_ef_remove_internal(), and zip_file_extra_field_set().

◆ _zip_ef_get_by_id()

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

Definition at line 116 of file zip_extra_field.c.

                                                                                                                                                 {
     static const zip_uint8_t empty[1] = {'\0'};
  
     int i;
  
     i = 0;
     for (; ef; ef = ef->next) {
         if (ef->id == id && (ef->flags & flags & ZIP_EF_BOTH)) {
             if (i < id_idx) {
                 i++;
                 continue;
             }
  
             if (lenp)
                 *lenp = ef->size;
             if (ef->size > 0)
                 return ef->data;
             else
                 return empty;
         }
     }
  
     zip_error_set(error, ZIP_ER_NOENT, 0);
     return NULL;
 }

References ef::data, ef, error(), flags, ef::flags, i, ef::id, NULL, ef::size, ZIP_EF_BOTH, ZIP_ER_NOENT, and zip_error_set().

Referenced by _zip_dirent_process_ef_utf_8(), _zip_dirent_process_winzip_aes(), _zip_dirent_read(), and zip_file_extra_field_get_by_id().

◆ _zip_ef_merge()

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

Definition at line 144 of file zip_extra_field.c.

                                                               {
     zip_extra_field_t *ef2, *tt, *tail;
     int duplicate;
  
     if (to == NULL)
         return from;
  
     for (tail = to; tail->next; tail = tail->next)
         ;
  
     for (; from; from = ef2) {
         ef2 = from->next;
  
         duplicate = 0;
         for (tt = to; tt; tt = tt->next) {
             if (tt->id == from->id && tt->size == from->size && (tt->size == 0 || memcmp(tt->data, from->data, tt->size) == 0)) {
                 tt->flags |= (from->flags & ZIP_EF_BOTH);
                 duplicate = 1;
                 break;
             }
         }
  
         from->next = NULL;
         if (duplicate)
             _zip_ef_free(from);
         else
             tail = tail->next = from;
     }
  
     return to;
 }

References _zip_ef_free(), zip_extra_field::data, zip_extra_field::flags, from, zip_extra_field::id, zip_extra_field::next, NULL, zip_extra_field::size, to, and ZIP_EF_BOTH.

Referenced by _zip_checkcons(), and _zip_read_local_ef().

◆ _zip_ef_new()

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

Definition at line 178 of file zip_extra_field.c.

                                                                                             {
     zip_extra_field_t *ef;
  
     if ((ef = (zip_extra_field_t *)malloc(sizeof(*ef))) == NULL)
         return NULL;
  
     ef->next = NULL;
     ef->flags = flags;
     ef->id = id;
     ef->size = size;
     if (size > 0) {
         if ((ef->data = (zip_uint8_t *)_zip_memdup(data, size, NULL)) == NULL) {
             free(ef);
             return NULL;
         }
     }
     else
         ef->data = NULL;
  
     return ef;
 }

References _zip_memdup(), ef::data, ef, flags, ef::flags, free(), id, ef::id, malloc(), NULL, and ef::size.

Referenced by _zip_dirent_write(), _zip_ef_clone(), _zip_ef_parse(), _zip_ef_utf8(), and zip_file_extra_field_set().

◆ _zip_ef_parse()

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

Definition at line 202 of file zip_extra_field.c.

                                                                                                                                {
     zip_buffer_t *buffer;
     zip_extra_field_t *ef, *ef2, *ef_head;
  
     if ((buffer = _zip_buffer_new((zip_uint8_t *)data, len)) == NULL) {
         zip_error_set(error, ZIP_ER_MEMORY, 0);
         return false;
     }
  
     ef_head = ef = NULL;
  
     while (_zip_buffer_ok(buffer) && _zip_buffer_left(buffer) >= 4) {
         zip_uint16_t fid, flen;
         zip_uint8_t *ef_data;
  
         fid = _zip_buffer_get_16(buffer);
         flen = _zip_buffer_get_16(buffer);
         ef_data = _zip_buffer_get(buffer, flen);
  
         if (ef_data == NULL) {
             zip_error_set(error, ZIP_ER_INCONS, ZIP_ER_DETAIL_INVALID_EF_LENGTH);
             _zip_buffer_free(buffer);
             _zip_ef_free(ef_head);
             return false;
         }
  
         if ((ef2 = _zip_ef_new(fid, flen, ef_data, flags)) == NULL) {
             zip_error_set(error, ZIP_ER_MEMORY, 0);
             _zip_buffer_free(buffer);
             _zip_ef_free(ef_head);
             return false;
         }
  
         if (ef_head) {
             ef->next = ef2;
             ef = ef2;
         }
         else
             ef_head = ef = ef2;
     }
  
     if (!_zip_buffer_eof(buffer)) {
         /* Android APK files align stored file data with padding in extra fields; ignore. */
         /* see https://android.googlesource.com/platform/build/+/master/tools/zipalign/ZipAlign.cpp */
         size_t glen = _zip_buffer_left(buffer);
         zip_uint8_t *garbage;
         garbage = _zip_buffer_get(buffer, glen);
         if (glen >= 4 || garbage == NULL || memcmp(garbage, "\0\0\0", glen) != 0) {
             zip_error_set(error, ZIP_ER_INCONS, ZIP_ER_DETAIL_EF_TRAILING_GARBAGE);
             _zip_buffer_free(buffer);
             _zip_ef_free(ef_head);
             return false;
         }
     }
  
     _zip_buffer_free(buffer);
  
     if (ef_head_p) {
         *ef_head_p = ef_head;
     }
     else {
         _zip_ef_free(ef_head);
     }
  
     return true;
 }

References _zip_buffer_eof(), _zip_buffer_free(), _zip_buffer_get(), _zip_buffer_get_16(), _zip_buffer_left(), _zip_buffer_new(), _zip_buffer_ok(), _zip_ef_free(), _zip_ef_new(), ef, error(), flags, len, NULL, ZIP_ER_DETAIL_EF_TRAILING_GARBAGE, ZIP_ER_DETAIL_INVALID_EF_LENGTH, ZIP_ER_INCONS, ZIP_ER_MEMORY, and zip_error_set().

Referenced by _zip_dirent_read(), and _zip_read_local_ef().

◆ _zip_ef_remove_internal()

zip_extra_field_t* _zip_ef_remove_internal ( zip_extra_field_t * ef )

Definition at line 271 of file zip_extra_field.c.

                                                {
     zip_extra_field_t *ef_head;
     zip_extra_field_t *prev, *next;
  
     ef_head = ef;
     prev = NULL;
  
     while (ef) {
         if (ZIP_EF_IS_INTERNAL(ef->id)) {
             next = ef->next;
             if (ef_head == ef)
                 ef_head = next;
             ef->next = NULL;
             _zip_ef_free(ef);
             if (prev)
                 prev->next = next;
             ef = next;
         }
         else {
             prev = ef;
             ef = ef->next;
         }
     }
  
     return ef_head;
 }

References _zip_ef_free(), ef, ef::id, zip_extra_field::next, NULL, and ZIP_EF_IS_INTERNAL.

Referenced by _zip_dirent_read(), and _zip_read_local_ef().

◆ _zip_ef_size()

zip_uint16_t _zip_ef_size	(	const zip_extra_field_t *	ef,
		zip_flags_t	flags
	)

Definition at line 300 of file zip_extra_field.c.

                                                              {
     zip_uint16_t size;
  
     size = 0;
     for (; ef; ef = ef->next) {
         if (ef->flags & flags & ZIP_EF_BOTH)
             size = (zip_uint16_t)(size + 4 + ef->size);
     }
  
     return size;
 }

References ef, flags, ef::flags, ef::size, and ZIP_EF_BOTH.

Referenced by _zip_dirent_write(), and zip_file_extra_field_set().

◆ _zip_ef_write()

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

Definition at line 314 of file zip_extra_field.c.

                                                                          {
     zip_uint8_t b[4];
     zip_buffer_t *buffer = _zip_buffer_new(b, sizeof(b));
  
     if (buffer == NULL) {
         return -1;
     }
  
     for (; ef; ef = ef->next) {
         if (ef->flags & flags & ZIP_EF_BOTH) {
             _zip_buffer_set_offset(buffer, 0);
             _zip_buffer_put_16(buffer, ef->id);
             _zip_buffer_put_16(buffer, ef->size);
             if (!_zip_buffer_ok(buffer)) {
                 zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
                 _zip_buffer_free(buffer);
                 return -1;
             }
             if (_zip_write(za, b, 4) < 0) {
                 _zip_buffer_free(buffer);
                 return -1;
             }
             if (ef->size > 0) {
                 if (_zip_write(za, ef->data, ef->size) < 0) {
                     _zip_buffer_free(buffer);
                     return -1;
                 }
             }
         }
     }
  
     _zip_buffer_free(buffer);
     return 0;
 }

References _zip_buffer_free(), _zip_buffer_new(), _zip_buffer_ok(), _zip_buffer_put_16(), _zip_buffer_set_offset(), _zip_write(), b, ef::data, ef, zip::error, flags, ef::flags, ef::id, NULL, ef::size, za, ZIP_EF_BOTH, ZIP_ER_INTERNAL, and zip_error_set().

Referenced by _zip_dirent_write().

◆ _zip_entry_finalize()

void _zip_entry_finalize ( zip_entry_t * e )

Definition at line 38 of file zip_entry.c.

                                     {
     _zip_unchange_data(e);
     _zip_dirent_free(e->orig);
     _zip_dirent_free(e->changes);
 }

References _zip_dirent_free(), _zip_unchange_data(), and e.

Referenced by _zip_cdir_free(), _zip_file_replace(), and zip_discard().

◆ _zip_entry_init()

void _zip_entry_init ( zip_entry_t * e )

Definition at line 46 of file zip_entry.c.

                                 {
     e->orig = NULL;
     e->changes = NULL;
     e->source = NULL;
     e->deleted = 0;
 }

References e, and NULL.

Referenced by _zip_add_entry(), and _zip_cdir_grow().

◆ _zip_error_clear()

void _zip_error_clear ( zip_error_t * err )

Definition at line 92 of file zip_error.c.

                                    {
     if (err == NULL)
         return;
  
     err->zip_err = ZIP_ER_OK;
     err->sys_err = 0;
 }

References err, NULL, and ZIP_ER_OK.

Referenced by _zip_name_locate(), zip_error_clear(), zip_file_error_clear(), and zip_source_open().

◆ _zip_error_copy()

void _zip_error_copy	(	zip_error_t *	dst,
		const zip_error_t *	src
	)

Definition at line 102 of file zip_error.c.

                                                           {
     if (dst == NULL) {
         return;
     }
  
     dst->zip_err = src->zip_err;
     dst->sys_err = src->sys_err;
 }

References dst, NULL, and src.

Referenced by _zip_error_set_from_source(), _zip_file_exists(), _zip_find_central_dir(), _zip_open(), and zip_source_file_common_new().

◆ _zip_error_get()

void _zip_error_get	(	const zip_error_t *	err,
		int *	zep,
		int *	sep
	)

Definition at line 113 of file zip_error.c.

                                                            {
     if (zep)
         *zep = err->zip_err;
     if (sep) {
         if (zip_error_system_type(err) != ZIP_ET_NONE)
             *sep = err->sys_err;
         else
             *sep = 0;
     }
 }

References err, zip_error_system_type(), and ZIP_ET_NONE.

Referenced by zip_error_get(), and zip_file_error_get().

◆ _zip_error_set_from_source()

void _zip_error_set_from_source	(	zip_error_t *	err,
		zip_source_t *	src
	)

Definition at line 135 of file zip_error.c.

                                                                 {
     _zip_error_copy(err, zip_source_error(src));
 }

References _zip_error_copy(), err, src, and zip_source_error().

Referenced by _zip_cdir_write(), _zip_checkcons(), _zip_dirent_size(), _zip_file_get_end(), _zip_file_get_offset(), _zip_find_central_dir(), _zip_open(), _zip_read(), _zip_read_cdir(), _zip_read_eocd64(), _zip_read_local_ef(), _zip_write(), add_data(), compress_callback(), compress_read(), copy_source(), crc_read(), decrypt_header(), encrypt_header(), pkware_decrypt(), pkware_encrypt(), verify_hmac(), window_read(), winzip_aes_decrypt(), winzip_aes_encrypt(), zip_close(), zip_fopen_index_encrypted(), zip_fread(), zip_fseek(), zip_ftell(), zip_open_from_source(), zip_source_get_file_attributes(), zip_source_open(), zip_source_stat(), and zip_source_winzip_aes_decode().

◆ _zip_extract_extra_field_by_id()

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 *
	)

◆ _zip_file_extra_field_prepare_for_change()

int _zip_file_extra_field_prepare_for_change	(	zip_t *	za,
		zip_uint64_t	idx
	)

Definition at line 323 of file zip_extra_field_api.c.

                                                                       {
     zip_entry_t *e;
  
     if (idx >= za->nentry) {
         zip_error_set(&za->error, ZIP_ER_INVAL, 0);
         return -1;
     }
  
     e = za->entry + idx;
  
     if (e->changes && (e->changes->changed & ZIP_DIRENT_EXTRA_FIELD))
         return 0;
  
     if (e->orig) {
         if (_zip_read_local_ef(za, idx) < 0)
             return -1;
     }
  
     if (e->changes == NULL) {
         if ((e->changes = _zip_dirent_clone(e->orig)) == NULL) {
             zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
             return -1;
         }
     }
  
     if (e->orig && e->orig->extra_fields) {
         if ((e->changes->extra_fields = _zip_ef_clone(e->orig->extra_fields, &za->error)) == NULL)
             return -1;
     }
     e->changes->changed |= ZIP_DIRENT_EXTRA_FIELD;
  
     return 0;
 }

References _zip_dirent_clone(), _zip_ef_clone(), _zip_read_local_ef(), e, zip::entry, zip::error, setup::idx, zip::nentry, NULL, za, ZIP_DIRENT_EXTRA_FIELD, ZIP_ER_INVAL, ZIP_ER_MEMORY, and zip_error_set().

Referenced by zip_file_extra_field_delete(), zip_file_extra_field_delete_by_id(), and zip_file_extra_field_set().

◆ _zip_file_fillbuf()

int _zip_file_fillbuf	(	void *	,
		size_t	,
		zip_file_t *
	)

◆ _zip_file_get_end()

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

Definition at line 77 of file zip_file_get_offset.c.

                                                                            {
     zip_uint64_t offset;
     zip_dirent_t *entry;
  
     if ((offset = _zip_file_get_offset(za, index, error)) == 0) {
         return 0;
     }
  
     entry = za->entry[index].orig;
  
     if (offset + entry->comp_size < offset || offset + entry->comp_size > ZIP_INT64_MAX) {
         zip_error_set(error, ZIP_ER_SEEK, EFBIG);
         return 0;
     }
     offset += entry->comp_size;
  
     if (entry->bitflags & ZIP_GPBF_DATA_DESCRIPTOR) {
         zip_uint8_t buf[4];
         if (zip_source_seek(za->src, (zip_int64_t)offset, SEEK_SET) < 0) {
             _zip_error_set_from_source(error, za->src);
             return 0;
         }
         if (zip_source_read(za->src, buf, 4) != 4) {
             _zip_error_set_from_source(error, za->src);
             return 0;
         }
         if (memcmp(buf, DATADES_MAGIC, 4) == 0) {
             offset += 4;
         }
         offset += 12;
         if (_zip_dirent_needs_zip64(entry, 0)) {
             offset += 8;
         }
         if (offset > ZIP_INT64_MAX) {
             zip_error_set(error, ZIP_ER_SEEK, EFBIG);
             return 0;
         }
     }
  
     return offset;
 }

References _zip_dirent_needs_zip64(), _zip_error_set_from_source(), _zip_file_get_offset(), DATADES_MAGIC, EFBIG, zip::entry, error(), zip_entry::orig, SEEK_SET, zip::src, za, ZIP_ER_SEEK, zip_error_set(), ZIP_GPBF_DATA_DESCRIPTOR, ZIP_INT64_MAX, zip_source_read(), and zip_source_seek().

Referenced by zip_close().

◆ _zip_file_get_offset()

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

Definition at line 48 of file zip_file_get_offset.c.

                                                                             {
     zip_uint64_t offset;
     zip_int32_t size;
  
     if (za->entry[idx].orig == NULL) {
         zip_error_set(error, ZIP_ER_INTERNAL, 0);
         return 0;
     }
  
     offset = za->entry[idx].orig->offset;
  
     if (zip_source_seek(za->src, (zip_int64_t)offset, SEEK_SET) < 0) {
         _zip_error_set_from_source(error, za->src);
         return 0;
     }
  
     /* TODO: cache? */
     if ((size = _zip_dirent_size(za->src, ZIP_EF_LOCAL, error)) < 0)
         return 0;
  
     if (offset + (zip_uint32_t)size > ZIP_INT64_MAX) {
         zip_error_set(error, ZIP_ER_SEEK, EFBIG);
         return 0;
     }
  
     return offset + (zip_uint32_t)size;
 }

References _zip_dirent_size(), _zip_error_set_from_source(), EFBIG, zip::entry, error(), setup::idx, NULL, zip_dirent::offset, zip_entry::orig, SEEK_SET, zip::src, za, ZIP_EF_LOCAL, ZIP_ER_INTERNAL, ZIP_ER_SEEK, zip_error_set(), ZIP_INT64_MAX, and zip_source_seek().

Referenced by _zip_file_get_end(), window_read(), and zip_close().

◆ _zip_file_replace()

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

Definition at line 55 of file zip_file_replace.c.

                                                                                                           {
     zip_uint64_t za_nentry_prev;
  
     if (ZIP_IS_RDONLY(za)) {
         zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
         return -1;
     }
  
     za_nentry_prev = za->nentry;
     if (idx == ZIP_UINT64_MAX) {
         zip_int64_t i = -1;
  
         if (flags & ZIP_FL_OVERWRITE)
             i = _zip_name_locate(za, name, flags, NULL);
  
         if (i == -1) {
             /* create and use new entry, used by zip_add */
             if ((i = _zip_add_entry(za)) < 0)
                 return -1;
         }
         idx = (zip_uint64_t)i;
     }
  
     if (name && _zip_set_name(za, idx, name, flags) != 0) {
         if (za->nentry != za_nentry_prev) {
             _zip_entry_finalize(za->entry + idx);
             za->nentry = za_nentry_prev;
         }
         return -1;
     }
  
     /* does not change any name related data, so we can do it here;
      * needed for a double add of the same file name */
     _zip_unchange_data(za->entry + idx);
  
     if (za->entry[idx].orig != NULL && (za->entry[idx].changes == NULL || (za->entry[idx].changes->changed & ZIP_DIRENT_COMP_METHOD) == 0)) {
         if (za->entry[idx].changes == NULL) {
             if ((za->entry[idx].changes = _zip_dirent_clone(za->entry[idx].orig)) == NULL) {
                 zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
                 return -1;
             }
         }
  
         za->entry[idx].changes->comp_method = ZIP_CM_REPLACED_DEFAULT;
         za->entry[idx].changes->changed |= ZIP_DIRENT_COMP_METHOD;
     }
  
     za->entry[idx].source = source;
  
     return (zip_int64_t)idx;
 }

References _zip_add_entry(), _zip_dirent_clone(), _zip_entry_finalize(), _zip_name_locate(), _zip_set_name(), _zip_unchange_data(), zip_dirent::changed, zip_entry::changes, zip_dirent::comp_method, zip::entry, zip::error, flags, i, setup::idx, zip::nentry, NULL, zip_entry::orig, zip_entry::source, source, za, ZIP_CM_REPLACED_DEFAULT, ZIP_DIRENT_COMP_METHOD, ZIP_ER_MEMORY, ZIP_ER_RDONLY, zip_error_set(), ZIP_FL_OVERWRITE, ZIP_IS_RDONLY, and ZIP_UINT64_MAX.

Referenced by zip_dir_add(), zip_file_add(), and zip_file_replace().

◆ _zip_get_compression_algorithm()

zip_compression_algorithm_t* _zip_get_compression_algorithm	(	zip_int32_t	method,
		bool	compress
	)

Definition at line 93 of file zip_source_compress.c.

                                                                   {
     size_t i;
     zip_uint16_t real_method = ZIP_CM_ACTUAL(method);
  
     for (i = 0; i < implementations_size; i++) {
         if (implementations[i].method == real_method) {
             if (compress) {
                 return implementations[i].compress;
             }
             else {
                 return implementations[i].decompress;
             }
         }
     }
  
     return NULL;
 }

References implementation::compress, compress(), implementation::decompress, i, implementations, implementations_size, context::method, NULL, and ZIP_CM_ACTUAL.

Referenced by add_data(), compression_source_new(), and zip_compression_method_supported().

◆ _zip_get_dirent()

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

Definition at line 1064 of file zip_dirent.c.

                                                                                     {
     if (error == NULL)
         error = &za->error;
  
     if (idx >= za->nentry) {
         zip_error_set(error, ZIP_ER_INVAL, 0);
         return NULL;
     }
  
     if ((flags & ZIP_FL_UNCHANGED) || za->entry[idx].changes == NULL) {
         if (za->entry[idx].orig == NULL) {
             zip_error_set(error, ZIP_ER_INVAL, 0);
             return NULL;
         }
         if (za->entry[idx].deleted && (flags & ZIP_FL_UNCHANGED) == 0) {
             zip_error_set(error, ZIP_ER_DELETED, 0);
             return NULL;
         }
         return za->entry[idx].orig;
     }
     else
         return za->entry[idx].changes;
 }

References zip_entry::changes, zip_entry::deleted, zip::entry, zip::error, error(), flags, setup::idx, zip::nentry, NULL, zip_entry::orig, za, ZIP_ER_DELETED, ZIP_ER_INVAL, zip_error_set(), and ZIP_FL_UNCHANGED.

Referenced by _zip_get_name(), _zip_source_zip_new(), zip_file_extra_field_delete(), zip_file_extra_field_delete_by_id(), zip_file_extra_field_get(), zip_file_extra_field_get_by_id(), zip_file_extra_field_set(), zip_file_extra_fields_count(), zip_file_extra_fields_count_by_id(), zip_file_get_comment(), zip_file_get_external_attributes(), zip_file_set_comment(), zip_file_set_external_attributes(), zip_file_set_mtime(), and zip_stat_index().

◆ _zip_get_encryption_implementation()

zip_encryption_implementation _zip_get_encryption_implementation	(	zip_uint16_t	method,
		int	operation
	)

Definition at line 39 of file zip_get_encryption_implementation.c.

                                                                    {
     switch (em) {
     case ZIP_EM_TRAD_PKWARE:
         return operation == ZIP_CODEC_DECODE ? zip_source_pkware_decode : zip_source_pkware_encode;
  
 #if defined(HAVE_CRYPTO)
     case ZIP_EM_AES_128:
     case ZIP_EM_AES_192:
     case ZIP_EM_AES_256:
         return operation == ZIP_CODEC_DECODE ? zip_source_winzip_aes_decode : zip_source_winzip_aes_encode;
 #endif
  
     default:
         return NULL;
     }
 }

References NULL, ZIP_CODEC_DECODE, ZIP_EM_AES_128, ZIP_EM_AES_192, ZIP_EM_AES_256, ZIP_EM_TRAD_PKWARE, zip_source_pkware_decode(), zip_source_pkware_encode(), zip_source_winzip_aes_decode(), and zip_source_winzip_aes_encode().

Referenced by _zip_source_zip_new(), add_data(), zip_encryption_method_supported(), and zip_file_set_encryption().

◆ _zip_get_name()

const char* _zip_get_name	(	zip_t *	za,
		zip_uint64_t	idx,
		zip_flags_t	flags,
		zip_error_t *	error
	)

Definition at line 47 of file zip_get_name.c.

                                                                                   {
     zip_dirent_t *de;
     const zip_uint8_t *str;
  
     if ((de = _zip_get_dirent(za, idx, flags, error)) == NULL)
         return NULL;
  
     if ((str = _zip_string_get(de->filename, NULL, flags, error)) == NULL)
         return NULL;
  
     return (const char *)str;
 }

References _zip_get_dirent(), _zip_string_get(), error(), zip_dirent::filename, flags, setup::idx, NULL, cmd_descs_generate::str, and za.

Referenced by _zip_name_locate(), _zip_unchange(), zip_delete(), and zip_get_name().

◆ _zip_guess_encoding()

enum zip_encoding_type _zip_guess_encoding	(	zip_string_t *	,
		enum	zip_encoding_type
	)

◆ _zip_hash_add()

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
	)

Definition at line 205 of file zip_hash.c.

                                                                                                                     {
     zip_uint32_t hash_value, table_index;
     zip_hash_entry_t *entry;
  
     if (hash == NULL || name == NULL || index > ZIP_INT64_MAX) {
         zip_error_set(error, ZIP_ER_INVAL, 0);
         return false;
     }
  
     if (hash->table_size == 0) {
         if (!hash_resize(hash, HASH_MIN_SIZE, error)) {
             return false;
         }
     }
  
     hash_value = hash_string(name);
     table_index = hash_value % hash->table_size;
  
     for (entry = hash->table[table_index]; entry != NULL; entry = entry->next) {
         if (entry->hash_value == hash_value && strcmp((const char *)name, (const char *)entry->name) == 0) {
             if (((flags & ZIP_FL_UNCHANGED) && entry->orig_index != -1) || entry->current_index != -1) {
                 zip_error_set(error, ZIP_ER_EXISTS, 0);
                 return false;
             }
             else {
                 break;
             }
         }
     }
  
     if (entry == NULL) {
         if ((entry = (zip_hash_entry_t *)malloc(sizeof(zip_hash_entry_t))) == NULL) {
             zip_error_set(error, ZIP_ER_MEMORY, 0);
             return false;
         }
         entry->name = name;
         entry->next = hash->table[table_index];
         hash->table[table_index] = entry;
         entry->hash_value = hash_value;
         entry->orig_index = -1;
         hash->nentries++;
         if (hash->nentries > hash->table_size * HASH_MAX_FILL && hash->table_size < HASH_MAX_SIZE) {
             if (!hash_resize(hash, hash->table_size * 2, error)) {
                 return false;
             }
         }
     }
  
     if (flags & ZIP_FL_UNCHANGED) {
         entry->orig_index = (zip_int64_t)index;
     }
     entry->current_index = (zip_int64_t)index;
  
     return true;
 }

References error(), flags, HASH_MAX_FILL, HASH_MAX_SIZE, HASH_MIN_SIZE, hash_resize(), hash_string(), malloc(), name, entry::name, zip_hash::nentries, NULL, zip_hash::table, zip_hash::table_size, ZIP_ER_EXISTS, ZIP_ER_INVAL, ZIP_ER_MEMORY, zip_error_set(), ZIP_FL_UNCHANGED, and ZIP_INT64_MAX.

Referenced by _zip_open(), _zip_set_name(), and _zip_unchange().

◆ _zip_hash_delete()

bool _zip_hash_delete	(	zip_hash_t *	hash,
		const zip_uint8_t *	key,
		zip_error_t *	error
	)

Definition at line 264 of file zip_hash.c.

                                                                                 {
     zip_uint32_t hash_value, index;
     zip_hash_entry_t *entry, *previous;
  
     if (hash == NULL || name == NULL) {
         zip_error_set(error, ZIP_ER_INVAL, 0);
         return false;
     }
  
     if (hash->nentries > 0) {
         hash_value = hash_string(name);
         index = hash_value % hash->table_size;
         previous = NULL;
         entry = hash->table[index];
         while (entry) {
             if (entry->hash_value == hash_value && strcmp((const char *)name, (const char *)entry->name) == 0) {
                 if (entry->orig_index == -1) {
                     if (previous) {
                         previous->next = entry->next;
                     }
                     else {
                         hash->table[index] = entry->next;
                     }
                     free(entry);
                     hash->nentries--;
                     if (hash->nentries < hash->table_size * HASH_MIN_FILL && hash->table_size > HASH_MIN_SIZE) {
                         if (!hash_resize(hash, hash->table_size / 2, error)) {
                             return false;
                         }
                     }
                 }
                 else {
                     entry->current_index = -1;
                 }
                 return true;
             }
             previous = entry;
             entry = entry->next;
         }
     }
  
     zip_error_set(error, ZIP_ER_NOENT, 0);
     return false;
 }

References error(), free(), HASH_MIN_FILL, HASH_MIN_SIZE, hash_resize(), hash_string(), entry::name, zip_hash::nentries, zip_hash_entry::next, NULL, zip_hash::table, zip_hash::table_size, ZIP_ER_INVAL, ZIP_ER_NOENT, and zip_error_set().

Referenced by _zip_set_name(), _zip_unchange(), and zip_delete().

◆ _zip_hash_free()

void _zip_hash_free ( zip_hash_t * hash )

Definition at line 184 of file zip_hash.c.

                                  {
     zip_uint32_t i;
  
     if (hash == NULL) {
         return;
     }
  
     if (hash->table != NULL) {
         for (i = 0; i < hash->table_size; i++) {
             if (hash->table[i] != NULL) {
                 free_list(hash->table[i]);
             }
         }
         free(hash->table);
     }
     free(hash);
 }

References free(), free_list(), i, NULL, zip_hash::table, and zip_hash::table_size.

Referenced by zip_discard().

◆ _zip_hash_lookup()

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

Definition at line 312 of file zip_hash.c.

                                                                                                    {
     zip_uint32_t hash_value, index;
     zip_hash_entry_t *entry;
  
     if (hash == NULL || name == NULL) {
         zip_error_set(error, ZIP_ER_INVAL, 0);
         return -1;
     }
  
     if (hash->nentries > 0) {
         hash_value = hash_string(name);
         index = hash_value % hash->table_size;
         for (entry = hash->table[index]; entry != NULL; entry = entry->next) {
             if (strcmp((const char *)name, (const char *)entry->name) == 0) {
                 if (flags & ZIP_FL_UNCHANGED) {
                     if (entry->orig_index != -1) {
                         return entry->orig_index;
                     }
                 }
                 else {
                     if (entry->current_index != -1) {
                         return entry->current_index;
                     }
                 }
                 break;
             }
         }
     }
  
     zip_error_set(error, ZIP_ER_NOENT, 0);
     return -1;
 }

References error(), flags, hash_string(), entry::name, zip_hash::nentries, NULL, zip_hash::table, zip_hash::table_size, ZIP_ER_INVAL, ZIP_ER_NOENT, zip_error_set(), and ZIP_FL_UNCHANGED.

Referenced by _zip_name_locate().

◆ _zip_hash_new()

zip_hash_t* _zip_hash_new ( zip_error_t * error )

Definition at line 167 of file zip_hash.c.

                                   {
     zip_hash_t *hash;
  
     if ((hash = (zip_hash_t *)malloc(sizeof(zip_hash_t))) == NULL) {
         zip_error_set(error, ZIP_ER_MEMORY, 0);
         return NULL;
     }
  
     hash->table_size = 0;
     hash->nentries = 0;
     hash->table = NULL;
  
     return hash;
 }

References error(), malloc(), zip_hash::nentries, NULL, zip_hash::table, zip_hash::table_size, ZIP_ER_MEMORY, and zip_error_set().

Referenced by _zip_new().

◆ _zip_hash_reserve_capacity()

bool _zip_hash_reserve_capacity	(	zip_hash_t *	hash,
		zip_uint64_t	capacity,
		zip_error_t *	error
	)

Definition at line 347 of file zip_hash.c.

                                                                                         {
     zip_uint32_t new_size;
  
     if (capacity == 0) {
         return true;
     }
  
     new_size = size_for_capacity(capacity);
  
     if (new_size <= hash->table_size) {
         return true;
     }
  
     if (!hash_resize(hash, new_size, error)) {
         return false;
     }
  
     return true;
 }

References error(), hash_resize(), and size_for_capacity().

Referenced by _zip_open().

◆ _zip_hash_revert()

bool _zip_hash_revert	(	zip_hash_t *	hash,
		zip_error_t *	error
	)

Definition at line 369 of file zip_hash.c.

                                                        {
     zip_uint32_t i;
     zip_hash_entry_t *entry, *previous;
  
     for (i = 0; i < hash->table_size; i++) {
         previous = NULL;
         entry = hash->table[i];
         while (entry) {
             if (entry->orig_index == -1) {
                 zip_hash_entry_t *p;
                 if (previous) {
                     previous->next = entry->next;
                 }
                 else {
                     hash->table[i] = entry->next;
                 }
                 p = entry;
                 entry = entry->next;
                 /* previous does not change */
                 free(p);
                 hash->nentries--;
             }
             else {
                 entry->current_index = entry->orig_index;
                 previous = entry;
                 entry = entry->next;
             }
         }
     }
  
     if (hash->nentries < hash->table_size * HASH_MIN_FILL && hash->table_size > HASH_MIN_SIZE) {
         zip_uint32_t new_size = hash->table_size / 2;
         while (hash->nentries < new_size * HASH_MIN_FILL && new_size > HASH_MIN_SIZE) {
             new_size /= 2;
         }
         if (!hash_resize(hash, new_size, error)) {
             return false;
         }
     }
  
     return true;
 }

References error(), free(), HASH_MIN_FILL, HASH_MIN_SIZE, hash_resize(), i, zip_hash::nentries, zip_hash_entry::next, NULL, p, zip_hash::table, and zip_hash::table_size.

Referenced by zip_unchange_all().

◆ _zip_local_header_read()

int _zip_local_header_read	(	zip_t *	,
		int
	)

◆ _zip_memdup()

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

Definition at line 41 of file zip_memdup.c.

                                                              {
     void *ret;
  
     if (len == 0)
         return NULL;
  
     ret = malloc(len);
     if (!ret) {
         zip_error_set(error, ZIP_ER_MEMORY, 0);
         return NULL;
     }
  
     memcpy(ret, mem, len);
  
     return ret;
 }

References error(), len, malloc(), mem, memcpy(), NULL, ZIP_ER_MEMORY, and zip_error_set().

Referenced by _zip_ef_new().

◆ _zip_mkstempm()

int _zip_mkstempm	(	char *	path,
		int	mode,
		bool	create_file
	)

◆ _zip_name_locate()

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

Definition at line 50 of file zip_name_locate.c.

                                                                                       {
     int (*cmp)(const char *, const char *);
     zip_string_t *str = NULL;
     const char *fn, *p;
     zip_uint64_t i;
  
     if (za == NULL)
         return -1;
  
     if (fname == NULL) {
         zip_error_set(error, ZIP_ER_INVAL, 0);
         return -1;
     }
  
     if ((flags & (ZIP_FL_ENC_UTF_8 | ZIP_FL_ENC_RAW)) == 0 && fname[0] != '\0') {
         if ((str = _zip_string_new((const zip_uint8_t *)fname, strlen(fname), flags, error)) == NULL) {
             return -1;
         }
         if ((fname = (const char *)_zip_string_get(str, NULL, 0, error)) == NULL) {
             _zip_string_free(str);
             return -1;
         }
     }
  
     if (flags & (ZIP_FL_NOCASE | ZIP_FL_NODIR | ZIP_FL_ENC_RAW | ZIP_FL_ENC_STRICT)) {
         /* can't use hash table */
         cmp = (flags & ZIP_FL_NOCASE) ? strcasecmp : strcmp;
  
         for (i = 0; i < za->nentry; i++) {
             fn = _zip_get_name(za, i, flags, error);
  
             /* newly added (partially filled) entry or error */
             if (fn == NULL)
                 continue;
  
             if (flags & ZIP_FL_NODIR) {
                 p = strrchr(fn, '/');
                 if (p)
                     fn = p + 1;
             }
  
             if (cmp(fname, fn) == 0) {
                 _zip_error_clear(error);
                 _zip_string_free(str);
                 return (zip_int64_t)i;
             }
         }
  
         zip_error_set(error, ZIP_ER_NOENT, 0);
         _zip_string_free(str);
         return -1;
     }
     else {
         zip_int64_t ret = _zip_hash_lookup(za->names, (const zip_uint8_t *)fname, flags, error);
         _zip_string_free(str);
         return ret;
     }
 }

References _zip_error_clear(), _zip_get_name(), _zip_hash_lookup(), _zip_string_free(), _zip_string_get(), _zip_string_new(), cmp(), error(), flags, fn, create_tags_rz::fname, i, int, zip::names, zip::nentry, NULL, p, cmd_descs_generate::str, za, ZIP_ER_INVAL, ZIP_ER_NOENT, zip_error_set(), ZIP_FL_ENC_RAW, ZIP_FL_ENC_STRICT, ZIP_FL_ENC_UTF_8, ZIP_FL_NOCASE, and ZIP_FL_NODIR.

Referenced by _zip_file_replace(), _zip_set_name(), _zip_unchange(), and zip_name_locate().

◆ _zip_new()

zip_t* _zip_new ( zip_error_t * error )

Definition at line 45 of file zip_new.c.

                              {
     zip_t *za;
  
     za = (zip_t *)malloc(sizeof(struct zip));
     if (!za) {
         zip_error_set(error, ZIP_ER_MEMORY, 0);
         return NULL;
     }
  
     if ((za->names = _zip_hash_new(error)) == NULL) {
         free(za);
         return NULL;
     }
  
     za->src = NULL;
     za->open_flags = 0;
     zip_error_init(&za->error);
     za->flags = za->ch_flags = 0;
     za->default_password = NULL;
     za->comment_orig = za->comment_changes = NULL;
     za->comment_changed = 0;
     za->nentry = za->nentry_alloc = 0;
     za->entry = NULL;
     za->nopen_source = za->nopen_source_alloc = 0;
     za->open_source = NULL;
     za->progress = NULL;
  
     return za;
 }

References _zip_hash_new(), zip::ch_flags, zip::comment_changed, zip::comment_changes, zip::comment_orig, zip::default_password, zip::entry, zip::error, error(), zip::flags, free(), malloc(), zip::names, zip::nentry, zip::nentry_alloc, zip::nopen_source, zip::nopen_source_alloc, NULL, zip::open_flags, zip::open_source, zip::progress, zip::src, za, ZIP_ER_MEMORY, zip_error_init(), and zip_error_set().

Referenced by _zip_allocate_new().

◆ _zip_open()

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

Definition at line 146 of file zip_open.c.

                                                                      {
     zip_t *za;
     zip_cdir_t *cdir;
     struct zip_stat st;
     zip_uint64_t len, idx;
  
     zip_stat_init(&st);
     if (zip_source_stat(src, &st) < 0) {
         _zip_error_set_from_source(error, src);
         return NULL;
     }
     if ((st.valid & ZIP_STAT_SIZE) == 0) {
         zip_error_set(error, ZIP_ER_SEEK, EOPNOTSUPP);
         return NULL;
     }
     len = st.size;
  
  
     if ((za = _zip_allocate_new(src, flags, error)) == NULL) {
         return NULL;
     }
  
     /* treat empty files as empty archives */
     if (len == 0 && zip_source_accept_empty(src)) {
         return za;
     }
  
     if ((cdir = _zip_find_central_dir(za, len)) == NULL) {
         _zip_error_copy(error, &za->error);
         /* keep src so discard does not get rid of it */
         zip_source_keep(src);
         zip_discard(za);
         return NULL;
     }
  
     za->entry = cdir->entry;
     za->nentry = cdir->nentry;
     za->nentry_alloc = cdir->nentry_alloc;
     za->comment_orig = cdir->comment;
  
     free(cdir);
  
     _zip_hash_reserve_capacity(za->names, za->nentry, &za->error);
  
     for (idx = 0; idx < za->nentry; idx++) {
         const zip_uint8_t *name = _zip_string_get(za->entry[idx].orig->filename, NULL, 0, error);
         if (name == NULL) {
             /* keep src so discard does not get rid of it */
             zip_source_keep(src);
             zip_discard(za);
             return NULL;
         }
  
         if (_zip_hash_add(za->names, name, idx, ZIP_FL_UNCHANGED, &za->error) == false) {
             if (za->error.zip_err != ZIP_ER_EXISTS || (flags & ZIP_CHECKCONS)) {
                 _zip_error_copy(error, &za->error);
                 /* keep src so discard does not get rid of it */
                 zip_source_keep(src);
                 zip_discard(za);
                 return NULL;
             }
         }
     }
  
     za->ch_flags = za->flags;
  
     return za;
 }

References _zip_allocate_new(), _zip_error_copy(), _zip_error_set_from_source(), _zip_find_central_dir(), _zip_hash_add(), _zip_hash_reserve_capacity(), _zip_string_get(), zip::ch_flags, zip_cdir::comment, zip::comment_orig, zip::entry, zip_cdir::entry, EOPNOTSUPP, zip::error, error(), zip_dirent::filename, flags, zip::flags, free(), setup::idx, len, zip::names, zip::nentry, zip_cdir::nentry, zip::nentry_alloc, zip_cdir::nentry_alloc, NULL, zip_entry::orig, zip_stat::size, src, zip_stat::valid, za, ZIP_CHECKCONS, zip_discard(), ZIP_ER_EXISTS, ZIP_ER_SEEK, zip_error::zip_err, zip_error_set(), ZIP_FL_UNCHANGED, zip_source_accept_empty(), zip_source_keep(), zip_source_stat(), zip_stat_init(), and ZIP_STAT_SIZE.

Referenced by zip_open_from_source().

◆ _zip_pkware_decrypt()

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

Definition at line 95 of file zip_pkware.c.

                                                                                                         {
     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);
     }
 }

References b, crypt_byte(), i, in, keys, len, NULL, out, autogen_x86imm::tmp, and update_keys().

Referenced by decrypt_header(), and pkware_decrypt().

◆ _zip_pkware_encrypt()

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

Definition at line 72 of file zip_pkware.c.

                                                                                                         {
     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);
         }
     }
 }

References b, crypt_byte(), i, in, keys, len, NULL, out, autogen_x86imm::tmp, and update_keys().

Referenced by encrypt_header(), and pkware_encrypt().

◆ _zip_pkware_keys_free()

void _zip_pkware_keys_free ( zip_pkware_keys_t * keys )

◆ _zip_pkware_keys_new()

zip_pkware_keys_t* _zip_pkware_keys_new ( zip_error_t * error )

◆ _zip_pkware_keys_reset()

void _zip_pkware_keys_reset ( zip_pkware_keys_t * keys )

Definition at line 64 of file zip_pkware.c.

                                                 {
     keys->key[0] = PKWARE_KEY0;
     keys->key[1] = PKWARE_KEY1;
     keys->key[2] = PKWARE_KEY2;
 }

References keys, PKWARE_KEY0, PKWARE_KEY1, and PKWARE_KEY2.

Referenced by pkware_decrypt(), and pkware_encrypt().

◆ _zip_progress_end()

void _zip_progress_end ( zip_progress_t * progress )

Definition at line 68 of file zip_progress.c.

                                             {
     _zip_progress_update(progress, 1.0);
 }

References _zip_progress_update().

Referenced by zip_close().

◆ _zip_progress_free()

void _zip_progress_free ( zip_progress_t * progress )

Definition at line 74 of file zip_progress.c.

                                              {
     if (progress == NULL) {
         return;
     }
  
     _zip_progress_free_progress_callback(progress);
     _zip_progress_free_cancel_callback(progress);
  
     free(progress);
 }

References _zip_progress_free_cancel_callback(), _zip_progress_free_progress_callback(), free(), and NULL.

Referenced by zip_discard(), zip_register_cancel_callback_with_state(), and zip_register_progress_callback_with_state().

◆ _zip_progress_start()

int _zip_progress_start ( zip_progress_t * progress )

Definition at line 151 of file zip_progress.c.

                                               {
     if (progress == NULL) {
         return 0;
     }
  
     if (progress->callback_progress != NULL) {
         progress->last_update = 0.0;
         progress->callback_progress(progress->za, 0.0, progress->ud_progress);
     }
  
     if (progress->callback_cancel != NULL) {
         if (progress->callback_cancel(progress->za, progress->ud_cancel)) {
             return -1;
         }
     }
  
     return 0;
 }

References zip_progress::callback_cancel, zip_progress::callback_progress, zip_progress::last_update, NULL, zip_progress::ud_cancel, zip_progress::ud_progress, and zip_progress::za.

Referenced by zip_close().

◆ _zip_progress_subrange()

int _zip_progress_subrange	(	zip_progress_t *	progress,
		double	start,
		double	end
	)

Definition at line 172 of file zip_progress.c.

                                                                            {
     if (progress == NULL) {
         return 0;
     }
  
     progress->start = start;
     progress->end = end;
  
     return _zip_progress_update(progress, 0.0);
 }

References _zip_progress_update(), test_evm::end, zip_progress::end, NULL, start, and zip_progress::start.

Referenced by zip_close().

◆ _zip_progress_update()

int _zip_progress_update	(	zip_progress_t *	progress,
		double	value
	)

Definition at line 184 of file zip_progress.c.

                                                                    {
     double current;
  
     if (progress == NULL) {
         return 0;
     }
  
     if (progress->callback_progress != NULL) {
         current = ZIP_MIN(ZIP_MAX(sub_current, 0.0), 1.0) * (progress->end - progress->start) + progress->start;
  
         if (current - progress->last_update > progress->precision) {
             progress->callback_progress(progress->za, current, progress->ud_progress);
             progress->last_update = current;
         }
     }
  
     if (progress->callback_cancel != NULL) {
         if (progress->callback_cancel(progress->za, progress->ud_cancel)) {
             return -1;
         }
     }
  
     return 0;
 }

References zip_progress::callback_cancel, zip_progress::callback_progress, zip_progress::end, if(), zip_progress::last_update, NULL, zip_progress::precision, zip_progress::start, zip_progress::ud_cancel, zip_progress::ud_progress, zip_progress::za, ZIP_MAX, and ZIP_MIN.

Referenced by _zip_progress_end(), _zip_progress_subrange(), copy_data(), and copy_source().

◆ _zip_read()

int _zip_read	(	zip_source_t *	src,
		zip_uint8_t *	data,
		zip_uint64_t	length,
		zip_error_t *	error
	)

Definition at line 40 of file zip_io_util.c.

                                                                                       {
     zip_int64_t n;
  
     if (length > ZIP_INT64_MAX) {
         zip_error_set(error, ZIP_ER_INTERNAL, 0);
         return -1;
     }
  
     if ((n = zip_source_read(src, b, length)) < 0) {
         _zip_error_set_from_source(error, src);
         return -1;
     }
  
     if (n < (zip_int64_t)length) {
         zip_error_set(error, ZIP_ER_EOF, 0);
         return -1;
     }
  
     return 0;
 }

References _zip_error_set_from_source(), b, error(), length, n, src, ZIP_ER_EOF, ZIP_ER_INTERNAL, zip_error_set(), ZIP_INT64_MAX, and zip_source_read().

Referenced by _zip_buffer_new_from_source(), _zip_read_data(), and copy_data().

◆ _zip_read_at_offset()

int _zip_read_at_offset	(	zip_source_t *	src,
		zip_uint64_t	offset,
		unsigned char *	b,
		size_t	length,
		zip_error_t *	error
	)

◆ _zip_read_data()

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

Definition at line 63 of file zip_io_util.c.

                                                                                                       {
     zip_uint8_t *r;
  
     if (length == 0 && !nulp) {
         return NULL;
     }
  
     r = (zip_uint8_t *)malloc(length + (nulp ? 1 : 0));
     if (!r) {
         zip_error_set(error, ZIP_ER_MEMORY, 0);
         return NULL;
     }
  
     if (buffer) {
         zip_uint8_t *data = _zip_buffer_get(buffer, length);
  
         if (data == NULL) {
             zip_error_set(error, ZIP_ER_MEMORY, 0);
             free(r);
             return NULL;
         }
         memcpy(r, data, length);
     }
     else {
         if (_zip_read(src, r, length, error) < 0) {
             free(r);
             return NULL;
         }
     }
  
     if (nulp) {
         zip_uint8_t *o;
         /* replace any in-string NUL characters with spaces */
         r[length] = 0;
         for (o = r; o < r + length; o++)
             if (*o == '\0')
                 *o = ' ';
     }
  
     return r;
 }

References _zip_buffer_get(), _zip_read(), error(), free(), length, malloc(), memcpy(), NULL, r, src, ZIP_ER_MEMORY, and zip_error_set().

Referenced by _zip_dirent_read(), _zip_read_local_ef(), and _zip_read_string().

◆ _zip_read_local_ef()

int _zip_read_local_ef	(	zip_t *	za,
		zip_uint64_t	idx
	)

Definition at line 351 of file zip_extra_field.c.

                                                 {
     zip_entry_t *e;
     unsigned char b[4];
     zip_buffer_t *buffer;
     zip_uint16_t fname_len, ef_len;
  
     if (idx >= za->nentry) {
         zip_error_set(&za->error, ZIP_ER_INVAL, 0);
         return -1;
     }
  
     e = za->entry + idx;
  
     if (e->orig == NULL || e->orig->local_extra_fields_read)
         return 0;
  
     if (e->orig->offset + 26 > ZIP_INT64_MAX) {
         zip_error_set(&za->error, ZIP_ER_SEEK, EFBIG);
         return -1;
     }
  
     if (zip_source_seek(za->src, (zip_int64_t)(e->orig->offset + 26), SEEK_SET) < 0) {
         _zip_error_set_from_source(&za->error, za->src);
         return -1;
     }
  
     if ((buffer = _zip_buffer_new_from_source(za->src, sizeof(b), b, &za->error)) == NULL) {
         return -1;
     }
  
     fname_len = _zip_buffer_get_16(buffer);
     ef_len = _zip_buffer_get_16(buffer);
  
     if (!_zip_buffer_eof(buffer)) {
         _zip_buffer_free(buffer);
         zip_error_set(&za->error, ZIP_ER_INTERNAL, 0);
         return -1;
     }
  
     _zip_buffer_free(buffer);
  
     if (ef_len > 0) {
         zip_extra_field_t *ef;
         zip_uint8_t *ef_raw;
  
         if (zip_source_seek(za->src, fname_len, SEEK_CUR) < 0) {
             zip_error_set(&za->error, ZIP_ER_SEEK, errno);
             return -1;
         }
  
         ef_raw = _zip_read_data(NULL, za->src, ef_len, 0, &za->error);
  
         if (ef_raw == NULL)
             return -1;
  
         if (!_zip_ef_parse(ef_raw, ef_len, ZIP_EF_LOCAL, &ef, &za->error)) {
             free(ef_raw);
             return -1;
         }
         free(ef_raw);
  
         if (ef) {
             ef = _zip_ef_remove_internal(ef);
             e->orig->extra_fields = _zip_ef_merge(e->orig->extra_fields, ef);
         }
     }
  
     e->orig->local_extra_fields_read = 1;
  
     if (e->changes && e->changes->local_extra_fields_read == 0) {
         e->changes->extra_fields = e->orig->extra_fields;
         e->changes->local_extra_fields_read = 1;
     }
  
     return 0;
 }

References _zip_buffer_eof(), _zip_buffer_free(), _zip_buffer_get_16(), _zip_buffer_new_from_source(), _zip_ef_merge(), _zip_ef_parse(), _zip_ef_remove_internal(), _zip_error_set_from_source(), _zip_read_data(), b, e, ef, EFBIG, zip::entry, zip::error, free(), setup::idx, zip::nentry, NULL, SEEK_CUR, SEEK_SET, zip::src, za, ZIP_EF_LOCAL, ZIP_ER_INTERNAL, ZIP_ER_INVAL, ZIP_ER_SEEK, zip_error_set(), ZIP_INT64_MAX, and zip_source_seek().

Referenced by _zip_file_extra_field_prepare_for_change(), zip_close(), zip_file_extra_field_get(), zip_file_extra_field_get_by_id(), zip_file_extra_fields_count(), and zip_file_extra_fields_count_by_id().

◆ _zip_read_string()

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

Definition at line 107 of file zip_io_util.c.

                                                                                                            {
     zip_uint8_t *raw;
     zip_string_t *s;
  
     if ((raw = _zip_read_data(buffer, src, len, nulp, error)) == NULL)
         return NULL;
  
     s = _zip_string_new(raw, len, ZIP_FL_ENC_GUESS, error);
     free(raw);
     return s;
 }

References _zip_read_data(), _zip_string_new(), error(), free(), len, NULL, s, src, and ZIP_FL_ENC_GUESS.

Referenced by _zip_dirent_read().

◆ _zip_register_source()

int _zip_register_source	(	zip_t *	za,
		zip_source_t *	src
	)

Definition at line 320 of file zip_source_window.c.

                                                    {
     zip_source_t **open_source;
  
     if (za->nopen_source + 1 >= za->nopen_source_alloc) {
         unsigned int n;
         n = za->nopen_source_alloc + 10;
         open_source = (zip_source_t **)realloc(za->open_source, n * sizeof(zip_source_t *));
         if (open_source == NULL) {
             zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
             return -1;
         }
         za->nopen_source_alloc = n;
         za->open_source = open_source;
     }
  
     za->open_source[za->nopen_source++] = src;
  
     return 0;
 }

References zip::error, n, zip::nopen_source, zip::nopen_source_alloc, NULL, zip::open_source, realloc(), src, za, ZIP_ER_MEMORY, and zip_error_set().

Referenced by _zip_source_set_source_archive().

◆ _zip_set_name()

int _zip_set_name	(	zip_t *	za,
		zip_uint64_t	idx,
		const char *	name,
		zip_flags_t	flags
	)

Definition at line 42 of file zip_set_name.c.

                                                                                 {
     zip_entry_t *e;
     zip_string_t *str;
     bool same_as_orig;
     zip_int64_t i;
     const zip_uint8_t *old_name, *new_name;
     zip_string_t *old_str;
  
     if (idx >= za->nentry) {
         zip_error_set(&za->error, ZIP_ER_INVAL, 0);
         return -1;
     }
  
     if (ZIP_IS_RDONLY(za)) {
         zip_error_set(&za->error, ZIP_ER_RDONLY, 0);
         return -1;
     }
  
     if (name && name[0] != '\0') {
         /* TODO: check for string too long */
         if ((str = _zip_string_new((const zip_uint8_t *)name, (zip_uint16_t)strlen(name), flags, &za->error)) == NULL)
             return -1;
         if ((flags & ZIP_FL_ENCODING_ALL) == ZIP_FL_ENC_GUESS && _zip_guess_encoding(str, ZIP_ENCODING_UNKNOWN) == ZIP_ENCODING_UTF8_GUESSED)
             str->encoding = ZIP_ENCODING_UTF8_KNOWN;
     }
     else
         str = NULL;
  
     /* TODO: encoding flags needed for CP437? */
     if ((i = _zip_name_locate(za, name, 0, NULL)) >= 0 && (zip_uint64_t)i != idx) {
         _zip_string_free(str);
         zip_error_set(&za->error, ZIP_ER_EXISTS, 0);
         return -1;
     }
  
     /* no effective name change */
     if (i >= 0 && (zip_uint64_t)i == idx) {
         _zip_string_free(str);
         return 0;
     }
  
     e = za->entry + idx;
  
     if (e->orig)
         same_as_orig = _zip_string_equal(e->orig->filename, str);
     else
         same_as_orig = false;
  
     if (!same_as_orig && e->changes == NULL) {
         if ((e->changes = _zip_dirent_clone(e->orig)) == NULL) {
             zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
             _zip_string_free(str);
             return -1;
         }
     }
  
     if ((new_name = _zip_string_get(same_as_orig ? e->orig->filename : str, NULL, 0, &za->error)) == NULL) {
         _zip_string_free(str);
         return -1;
     }
  
     if (e->changes) {
         old_str = e->changes->filename;
     }
     else if (e->orig) {
         old_str = e->orig->filename;
     }
     else {
         old_str = NULL;
     }
  
     if (old_str) {
         if ((old_name = _zip_string_get(old_str, NULL, 0, &za->error)) == NULL) {
             _zip_string_free(str);
             return -1;
         }
     }
     else {
         old_name = NULL;
     }
  
     if (_zip_hash_add(za->names, new_name, idx, 0, &za->error) == false) {
         _zip_string_free(str);
         return -1;
     }
     if (old_name) {
         _zip_hash_delete(za->names, old_name, NULL);
     }
  
     if (same_as_orig) {
         if (e->changes) {
             if (e->changes->changed & ZIP_DIRENT_FILENAME) {
                 _zip_string_free(e->changes->filename);
                 e->changes->changed &= ~ZIP_DIRENT_FILENAME;
                 if (e->changes->changed == 0) {
                     _zip_dirent_free(e->changes);
                     e->changes = NULL;
                 }
                 else {
                     /* TODO: what if not cloned? can that happen? */
                     e->changes->filename = e->orig->filename;
                 }
             }
         }
         _zip_string_free(str);
     }
     else {
         if (e->changes->changed & ZIP_DIRENT_FILENAME) {
             _zip_string_free(e->changes->filename);
         }
         e->changes->changed |= ZIP_DIRENT_FILENAME;
         e->changes->filename = str;
     }
  
     return 0;
 }

References _zip_dirent_clone(), _zip_dirent_free(), _zip_guess_encoding(), _zip_hash_add(), _zip_hash_delete(), _zip_name_locate(), _zip_string_equal(), _zip_string_free(), _zip_string_get(), _zip_string_new(), e, zip::entry, zip::error, flags, i, setup::idx, zip::names, zip::nentry, NULL, cmd_descs_generate::str, za, ZIP_DIRENT_FILENAME, ZIP_ENCODING_UNKNOWN, ZIP_ENCODING_UTF8_GUESSED, ZIP_ENCODING_UTF8_KNOWN, ZIP_ER_EXISTS, ZIP_ER_INVAL, ZIP_ER_MEMORY, ZIP_ER_RDONLY, zip_error_set(), ZIP_FL_ENC_GUESS, ZIP_FL_ENCODING_ALL, and ZIP_IS_RDONLY.

Referenced by _zip_file_replace(), and zip_file_rename().

◆ _zip_set_open_error()

void _zip_set_open_error	(	int *	zep,
		const zip_error_t *	err,
		int	ze
	)

Definition at line 217 of file zip_open.c.

                                                               {
     if (err) {
         ze = zip_error_code_zip(err);
     switch (zip_error_system_type(err)) {
         case ZIP_ET_SYS:
         case ZIP_ET_LIBZIP:
         errno = zip_error_code_system(err);
         break;
         
         default:
         break;
         }
     }
  
     if (zep)
         *zep = ze;
 }

References err, zip_error_code_system(), zip_error_code_zip(), zip_error_system_type(), ZIP_ET_LIBZIP, and ZIP_ET_SYS.

Referenced by zip_fdopen(), and zip_open().

◆ _zip_source_call()

zip_int64_t _zip_source_call	(	zip_source_t *	src,
		void *	data,
		zip_uint64_t	length,
		zip_source_cmd_t	command
	)

Definition at line 39 of file zip_source_call.c.

                                                                                                {
     zip_int64_t ret;
  
     if ((src->supports & ZIP_SOURCE_MAKE_COMMAND_BITMASK(command)) == 0) {
         zip_error_set(&src->error, ZIP_ER_OPNOTSUPP, 0);
         return -1;
     }
  
     if (src->src == NULL) {
         ret = src->cb.f(src->ud, data, length, command);
     }
     else {
         ret = src->cb.l(src->src, src->ud, data, length, command);
     }
  
     if (ret < 0) {
         if (command != ZIP_SOURCE_ERROR && command != ZIP_SOURCE_SUPPORTS) {
             int e[2];
  
             if (_zip_source_call(src, e, sizeof(e), ZIP_SOURCE_ERROR) < 0) {
                 zip_error_set(&src->error, ZIP_ER_INTERNAL, 0);
             }
             else {
                 zip_error_set(&src->error, e[0], e[1]);
             }
         }
     }
  
     return ret;
 }

References command, e, length, NULL, src, ZIP_ER_INTERNAL, ZIP_ER_OPNOTSUPP, zip_error_set(), ZIP_SOURCE_ERROR, ZIP_SOURCE_MAKE_COMMAND_BITMASK, and ZIP_SOURCE_SUPPORTS.

Referenced by zip_source_accept_empty(), zip_source_begin_write(), zip_source_begin_write_cloning(), zip_source_close(), zip_source_commit_write(), zip_source_free(), zip_source_get_file_attributes(), zip_source_open(), zip_source_read(), zip_source_remove(), zip_source_rollback_write(), zip_source_seek(), zip_source_seek_write(), zip_source_stat(), zip_source_tell(), zip_source_tell_write(), and zip_source_write().

◆ _zip_source_eof()

bool _zip_source_eof ( zip_source_t * src )

Definition at line 94 of file zip_source_read.c.

                                    {
     return src->eof;
 }

References src.

Referenced by zip_source_read().

◆ _zip_source_file_or_p()

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
	)

◆ _zip_source_had_error()

bool _zip_source_had_error ( zip_source_t * src )

Definition at line 44 of file zip_source_error.c.

                                          {
     return zip_source_error(src)->zip_err != ZIP_ER_OK;
 }

References src, ZIP_ER_OK, zip_error::zip_err, and zip_source_error().

◆ _zip_source_invalidate()

void _zip_source_invalidate ( zip_source_t * src )

Definition at line 129 of file zip_source_window.c.

                                           {
     src->source_closed = 1;
  
     if (zip_error_code_zip(&src->error) == ZIP_ER_OK) {
         zip_error_set(&src->error, ZIP_ER_ZIPCLOSED, 0);
     }
 }

References src, ZIP_ER_OK, ZIP_ER_ZIPCLOSED, zip_error_code_zip(), and zip_error_set().

Referenced by zip_discard().

◆ _zip_source_new()

zip_source_t* _zip_source_new ( zip_error_t * error )

Definition at line 76 of file zip_source_function.c.

                                     {
     zip_source_t *src;
  
     if ((src = (zip_source_t *)malloc(sizeof(*src))) == NULL) {
         zip_error_set(error, ZIP_ER_MEMORY, 0);
         return NULL;
     }
  
     src->src = NULL;
     src->cb.f = NULL;
     src->ud = NULL;
     src->open_count = 0;
     src->write_state = ZIP_SOURCE_WRITE_CLOSED;
     src->source_closed = false;
     src->source_archive = NULL;
     src->refcount = 1;
     zip_error_init(&src->error);
     src->eof = false;
     src->had_read_error = false;
     src->bytes_read = 0;
  
     return src;
 }

References error(), malloc(), NULL, src, ZIP_ER_MEMORY, zip_error_init(), zip_error_set(), and ZIP_SOURCE_WRITE_CLOSED.

Referenced by zip_source_function_create(), and zip_source_layered_create().

◆ _zip_source_set_source_archive()

int _zip_source_set_source_archive	(	zip_source_t *	src,
		zip_t *	za
	)

Definition at line 121 of file zip_source_window.c.

                                                              {
     src->source_archive = za;
     return _zip_register_source(za, src);
 }

References _zip_register_source(), src, and za.

Referenced by _zip_source_zip_new().

◆ _zip_source_window_new()

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

Definition at line 68 of file zip_source_window.c.

                                                                                                                                                                                                            {
     struct window *ctx;
  
     if (src == NULL || length < -1 || (source_archive == NULL && source_index != 0)) {
         zip_error_set(error, ZIP_ER_INVAL, 0);
         return NULL;
     }
     
     if (length >= 0) {
         if (start + (zip_uint64_t)length < start) {
             zip_error_set(error, ZIP_ER_INVAL, 0);
             return NULL;
         }
     }
  
     if ((ctx = (struct window *)malloc(sizeof(*ctx))) == NULL) {
         zip_error_set(error, ZIP_ER_MEMORY, 0);
         return NULL;
     }
  
     ctx->start = start;
     if (length == -1) {
         ctx->end_valid = false;
     }
     else {
         ctx->end = start + (zip_uint64_t)length;
         ctx->end_valid = true;
     }
     zip_stat_init(&ctx->stat);
     if (attributes != NULL) {
         memcpy(&ctx->attributes, attributes, sizeof(ctx->attributes));
     }
     else {
         zip_file_attributes_init(&ctx->attributes);
     }
     ctx->source_archive = source_archive;
     ctx->source_index = source_index;
     zip_error_init(&ctx->error);
     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));
     ctx->needs_seek = (ctx->supports & ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_SEEK)) ? true : false;
  
     if (st) {
         if (_zip_stat_merge(&ctx->stat, st, error) < 0) {
             free(ctx);
             return NULL;
         }
     }
     
     return zip_source_layered_create(src, window_read, ctx, error);
 }

References _zip_stat_merge(), window::attributes, ctx::error, error(), free(), length, malloc(), memcpy(), NULL, window::source_archive, window::source_index, src, start, window_read(), ZIP_ER_INVAL, ZIP_ER_MEMORY, zip_error_init(), zip_error_set(), zip_file_attributes_init(), ZIP_SOURCE_GET_FILE_ATTRIBUTES, zip_source_layered_create(), zip_source_make_command_bitmap(), ZIP_SOURCE_MAKE_COMMAND_BITMASK, ZIP_SOURCE_SEEK, ZIP_SOURCE_SUPPORTS, zip_source_supports(), ZIP_SOURCE_SUPPORTS_SEEKABLE, ZIP_SOURCE_TELL, and zip_stat_init().

Referenced by _zip_source_zip_new(), add_data(), and zip_source_window_create().

◆ _zip_source_zip_new()

zip_source_t* _zip_source_zip_new	(	zip_t *	srcza,
		zip_uint64_t	srcidx,
		zip_flags_t	flags,
		zip_uint64_t	start,
		zip_uint64_t	len,
		const char *	password,
		zip_error_t *	error
	)

Definition at line 41 of file zip_source_zip_new.c.

                                                                                                                                                                         {
     zip_source_t *src, *s2;
     zip_stat_t st;
     zip_file_attributes_t attributes;
     zip_dirent_t *de;
     bool partial_data, needs_crc, needs_decrypt, needs_decompress;
  
     if (srcza == NULL || srcidx >= srcza->nentry || len > ZIP_INT64_MAX) {
         zip_error_set(error, ZIP_ER_INVAL, 0);
         return NULL;
     }
  
     if ((flags & ZIP_FL_UNCHANGED) == 0 && (ZIP_ENTRY_DATA_CHANGED(srcza->entry + srcidx) || srcza->entry[srcidx].deleted)) {
         zip_error_set(error, ZIP_ER_CHANGED, 0);
         return NULL;
     }
  
     if (zip_stat_index(srcza, srcidx, flags | ZIP_FL_UNCHANGED, &st) < 0) {
         zip_error_set(error, ZIP_ER_INTERNAL, 0);
         return NULL;
     }
  
     if (flags & ZIP_FL_ENCRYPTED) {
         flags |= ZIP_FL_COMPRESSED;
     }
  
     if ((start > 0 || len > 0) && (flags & ZIP_FL_COMPRESSED)) {
         zip_error_set(error, ZIP_ER_INVAL, 0);
         return NULL;
     }
  
     /* overflow or past end of file */
     if ((start > 0 || len > 0) && (start + len < start || start + len > st.size)) {
         zip_error_set(error, ZIP_ER_INVAL, 0);
         return NULL;
     }
  
     if (len == 0) {
         len = st.size - start;
     }
  
     partial_data = len < st.size;
     needs_decrypt = ((flags & ZIP_FL_ENCRYPTED) == 0) && (st.encryption_method != ZIP_EM_NONE);
     needs_decompress = ((flags & ZIP_FL_COMPRESSED) == 0) && (st.comp_method != ZIP_CM_STORE);
     /* when reading the whole file, check for CRC errors */
     needs_crc = ((flags & ZIP_FL_COMPRESSED) == 0 || st.comp_method == ZIP_CM_STORE) && !partial_data;
  
     if (needs_decrypt) {
         if (password == NULL) {
             password = srcza->default_password;
         }
         if (password == NULL) {
             zip_error_set(error, ZIP_ER_NOPASSWD, 0);
             return NULL;
         }
     }
  
     if ((de = _zip_get_dirent(srcza, srcidx, flags, error)) == NULL) {
         return NULL;
     }
     _zip_file_attributes_from_dirent(&attributes, de);
  
     if (st.comp_size == 0) {
         return zip_source_buffer_with_attributes_create(NULL, 0, 0, &attributes, error);
     }
  
     if (partial_data && !needs_decrypt && !needs_decompress) {
         struct zip_stat st2;
  
         st2.size = len;
         st2.comp_size = len;
         st2.comp_method = ZIP_CM_STORE;
         st2.mtime = st.mtime;
         st2.valid = ZIP_STAT_SIZE | ZIP_STAT_COMP_SIZE | ZIP_STAT_COMP_METHOD | ZIP_STAT_MTIME;
  
         if ((src = _zip_source_window_new(srcza->src, start, (zip_int64_t)len, &st2, &attributes, srcza, srcidx, error)) == NULL) {
             return NULL;
         }
     }
     else {
         if (st.comp_size > ZIP_INT64_MAX) {
             zip_error_set(error, ZIP_ER_INVAL, 0);
             return NULL;
         }
         if ((src =  _zip_source_window_new(srcza->src, 0, (zip_int64_t)st.comp_size, &st, &attributes, srcza, srcidx, error)) == NULL) {
             return NULL;
         }
     }
  
     if (_zip_source_set_source_archive(src, srcza) < 0) {
         zip_source_free(src);
         return NULL;
     }
  
     /* creating a layered source calls zip_keep() on the lower layer, so we free it */
  
     if (needs_decrypt) {
         zip_encryption_implementation enc_impl;
  
         if ((enc_impl = _zip_get_encryption_implementation(st.encryption_method, ZIP_CODEC_DECODE)) == NULL) {
             zip_error_set(error, ZIP_ER_ENCRNOTSUPP, 0);
             return NULL;
         }
  
         s2 = enc_impl(srcza, src, st.encryption_method, 0, password);
         zip_source_free(src);
         if (s2 == NULL) {
             return NULL;
         }
         src = s2;
     }
     if (needs_decompress) {
         s2 = zip_source_decompress(srcza, src, st.comp_method);
         zip_source_free(src);
         if (s2 == NULL) {
             return NULL;
         }
         src = s2;
     }
     if (needs_crc) {
         s2 = zip_source_crc_create(src, 1, error);
         zip_source_free(src);
         if (s2 == NULL) {
             return NULL;
         }
         src = s2;
     }
  
     if (partial_data && (needs_decrypt || needs_decompress)) {
         s2 = zip_source_window_create(src, start, (zip_int64_t)len, error);
         zip_source_free(src);
         if (s2 == NULL) {
             return NULL;
         }
         src = s2;
     }
  
     return src;
 }

References _zip_file_attributes_from_dirent(), _zip_get_dirent(), _zip_get_encryption_implementation(), _zip_source_set_source_archive(), _zip_source_window_new(), zip_stat::comp_method, zip_stat::comp_size, zip::default_password, zip_entry::deleted, zip_stat::encryption_method, zip::entry, error(), flags, len, zip_stat::mtime, zip::nentry, NULL, s2, zip_stat::size, zip::src, src, start, zip_stat::valid, ZIP_CM_STORE, ZIP_CODEC_DECODE, ZIP_EM_NONE, ZIP_ENTRY_DATA_CHANGED, ZIP_ER_CHANGED, ZIP_ER_ENCRNOTSUPP, ZIP_ER_INTERNAL, ZIP_ER_INVAL, ZIP_ER_NOPASSWD, zip_error_set(), ZIP_FL_COMPRESSED, ZIP_FL_ENCRYPTED, ZIP_FL_UNCHANGED, ZIP_INT64_MAX, zip_source_buffer_with_attributes_create(), zip_source_crc_create(), zip_source_decompress(), zip_source_free(), zip_source_window_create(), ZIP_STAT_COMP_METHOD, ZIP_STAT_COMP_SIZE, zip_stat_index(), ZIP_STAT_MTIME, and ZIP_STAT_SIZE.

Referenced by zip_close(), zip_fopen_index_encrypted(), and zip_source_zip_create().

◆ _zip_stat_merge()

int _zip_stat_merge	(	zip_stat_t *	dst,
		const zip_stat_t *	src,
		zip_error_t *	error
	)

Definition at line 54 of file zip_stat_init.c.

                                                                             {
     /* name is not merged, since zip_stat_t doesn't own it, and src may not be valid as long as dst */
     if (src->valid & ZIP_STAT_INDEX) {
         dst->index = src->index;
     }
     if (src->valid & ZIP_STAT_SIZE) {
         dst->size = src->size;
     }
     if (src->valid & ZIP_STAT_COMP_SIZE) {
         dst->comp_size = src->comp_size;
     }
     if (src->valid & ZIP_STAT_MTIME) {
         dst->mtime = src->mtime;
     }
     if (src->valid & ZIP_STAT_CRC) {
         dst->crc = src->crc;
     }
     if (src->valid & ZIP_STAT_COMP_METHOD) {
         dst->comp_method = src->comp_method;
     }
     if (src->valid & ZIP_STAT_ENCRYPTION_METHOD) {
         dst->encryption_method = src->encryption_method;
     }
     if (src->valid & ZIP_STAT_FLAGS) {
         dst->flags = src->flags;
     }
     dst->valid |= src->valid;
  
     return 0;
 }

References dst, src, ZIP_STAT_COMP_METHOD, ZIP_STAT_COMP_SIZE, ZIP_STAT_CRC, ZIP_STAT_ENCRYPTION_METHOD, ZIP_STAT_FLAGS, ZIP_STAT_INDEX, ZIP_STAT_MTIME, and ZIP_STAT_SIZE.

Referenced by _zip_source_window_new(), and window_read().

◆ _zip_string_crc32()

zip_uint32_t _zip_string_crc32 ( const zip_string_t * string )

Definition at line 42 of file zip_string.c.

                                          {
     zip_uint32_t crc;
  
     crc = (zip_uint32_t)crc32(0L, Z_NULL, 0);
  
     if (s != NULL)
         crc = (zip_uint32_t)crc32(crc, s->raw, s->length);
  
     return crc;
 }

References crc32(), L, NULL, s, and Z_NULL.

Referenced by _zip_dirent_process_ef_utf_8(), and _zip_ef_utf8().

◆ _zip_string_equal()

int _zip_string_equal	(	const zip_string_t *	a,
		const zip_string_t *	b
	)

Definition at line 55 of file zip_string.c.

                                                                 {
     if (a == NULL || b == NULL)
         return a == b;
  
     if (a->length != b->length)
         return 0;
  
     /* TODO: encoding */
  
     return (memcmp(a->raw, b->raw, a->length) == 0);
 }

References a, b, and NULL.

Referenced by _zip_headercomp(), _zip_set_name(), zip_file_set_comment(), and zip_set_archive_comment().

◆ _zip_string_free()

void _zip_string_free ( zip_string_t * string )

Definition at line 69 of file zip_string.c.

                                   {
     if (s == NULL)
         return;
  
     free(s->raw);
     free(s->converted);
     free(s);
 }

References free(), NULL, and s.

Referenced by _zip_cdir_free(), _zip_dirent_finalize(), _zip_dirent_process_ef_utf_8(), _zip_name_locate(), _zip_set_name(), _zip_string_new(), zip_discard(), zip_file_set_comment(), zip_set_archive_comment(), and zip_unchange_archive().

◆ _zip_string_get()

const zip_uint8_t* _zip_string_get	(	zip_string_t *	string,
		zip_uint32_t *	lenp,
		zip_flags_t	flags,
		zip_error_t *	error
	)

Definition at line 80 of file zip_string.c.

                                                                                                  {
     static const zip_uint8_t empty[1] = "";
  
     if (string == NULL) {
         if (lenp)
             *lenp = 0;
         return empty;
     }
  
     if ((flags & ZIP_FL_ENC_RAW) == 0) {
         /* start guessing */
         if (string->encoding == ZIP_ENCODING_UNKNOWN)
             _zip_guess_encoding(string, ZIP_ENCODING_UNKNOWN);
  
         if (((flags & ZIP_FL_ENC_STRICT) && string->encoding != ZIP_ENCODING_ASCII && string->encoding != ZIP_ENCODING_UTF8_KNOWN) || (string->encoding == ZIP_ENCODING_CP437)) {
             if (string->converted == NULL) {
                 if ((string->converted = _zip_cp437_to_utf8(string->raw, string->length, &string->converted_length, error)) == NULL)
                     return NULL;
             }
             if (lenp)
                 *lenp = string->converted_length;
             return string->converted;
         }
     }
  
     if (lenp)
         *lenp = string->length;
     return string->raw;
 }

References _zip_cp437_to_utf8(), _zip_guess_encoding(), zip_string::converted, zip_string::converted_length, zip_string::encoding, error(), flags, zip_string::length, NULL, zip_string::raw, ZIP_ENCODING_ASCII, ZIP_ENCODING_CP437, ZIP_ENCODING_UNKNOWN, ZIP_ENCODING_UTF8_KNOWN, ZIP_FL_ENC_RAW, and ZIP_FL_ENC_STRICT.

Referenced by _zip_ef_utf8(), _zip_get_name(), _zip_name_locate(), _zip_open(), _zip_set_name(), zip_file_get_comment(), and zip_get_archive_comment().

◆ _zip_string_length()

zip_uint16_t _zip_string_length ( const zip_string_t * string )

Definition at line 112 of file zip_string.c.

                                           {
     if (s == NULL)
         return 0;
  
     return s->length;
 }

References NULL, and s.

Referenced by _zip_checkcons(), _zip_dirent_apply_attributes(), and _zip_dirent_write().

◆ _zip_string_new()

zip_string_t* _zip_string_new	(	const zip_uint8_t *	raw,
		zip_uint16_t	length,
		zip_flags_t	flags,
		zip_error_t *	error
	)

Definition at line 121 of file zip_string.c.

                                                                                                     {
     zip_string_t *s;
     zip_encoding_type_t expected_encoding;
  
     if (length == 0)
         return NULL;
  
     switch (flags & ZIP_FL_ENCODING_ALL) {
     case ZIP_FL_ENC_GUESS:
         expected_encoding = ZIP_ENCODING_UNKNOWN;
         break;
     case ZIP_FL_ENC_UTF_8:
         expected_encoding = ZIP_ENCODING_UTF8_KNOWN;
         break;
     case ZIP_FL_ENC_CP437:
         expected_encoding = ZIP_ENCODING_CP437;
         break;
     default:
         zip_error_set(error, ZIP_ER_INVAL, 0);
         return NULL;
     }
  
     if ((s = (zip_string_t *)malloc(sizeof(*s))) == NULL) {
         zip_error_set(error, ZIP_ER_MEMORY, 0);
         return NULL;
     }
  
     if ((s->raw = (zip_uint8_t *)malloc((size_t)length + 1)) == NULL) {
         free(s);
         return NULL;
     }
  
     memcpy(s->raw, raw, length);
     s->raw[length] = '\0';
     s->length = length;
     s->encoding = ZIP_ENCODING_UNKNOWN;
     s->converted = NULL;
     s->converted_length = 0;
  
     if (expected_encoding != ZIP_ENCODING_UNKNOWN) {
         if (_zip_guess_encoding(s, expected_encoding) == ZIP_ENCODING_ERROR) {
             _zip_string_free(s);
             zip_error_set(error, ZIP_ER_INVAL, 0);
             return NULL;
         }
     }
  
     return s;
 }

References _zip_guess_encoding(), _zip_string_free(), error(), flags, free(), length, malloc(), memcpy(), NULL, s, ZIP_ENCODING_CP437, ZIP_ENCODING_ERROR, ZIP_ENCODING_UNKNOWN, ZIP_ENCODING_UTF8_KNOWN, ZIP_ER_INVAL, ZIP_ER_MEMORY, zip_error_set(), ZIP_FL_ENC_CP437, ZIP_FL_ENC_GUESS, ZIP_FL_ENC_UTF_8, and ZIP_FL_ENCODING_ALL.

Referenced by _zip_dirent_process_ef_utf_8(), _zip_name_locate(), _zip_read_cdir(), _zip_read_string(), _zip_set_name(), zip_file_set_comment(), and zip_set_archive_comment().

◆ _zip_string_write()

int _zip_string_write	(	zip_t *	za,
		const zip_string_t *	string
	)

Definition at line 173 of file zip_string.c.

                                                     {
     if (s == NULL)
         return 0;
  
     return _zip_write(za, s->raw, s->length);
 }

References _zip_write(), NULL, s, and za.

Referenced by _zip_dirent_write().

◆ _zip_u2d_time()

void _zip_u2d_time	(	time_t	intime,
		zip_uint16_t *	dtime,
		zip_uint16_t *	ddate
	)

Definition at line 1090 of file zip_dirent.c.

                                                                        {
     struct tm *tpm;
  
 #ifdef HAVE_LOCALTIME_R
     struct tm tm;
     tpm = localtime_r(&intime, &tm);
 #else
     tpm = localtime(&intime);
 #endif
     if (tpm == NULL) {
         /* if localtime() fails, return an arbitrary date (1980-01-01 00:00:00) */
         *ddate = (1 << 5) + 1;
         *dtime = 0;
         return;
     }
     if (tpm->tm_year < 80) {
         tpm->tm_year = 80;
     }
  
     *ddate = (zip_uint16_t)(((tpm->tm_year + 1900 - 1980) << 9) + ((tpm->tm_mon + 1) << 5) + tpm->tm_mday);
     *dtime = (zip_uint16_t)(((tpm->tm_hour) << 11) + ((tpm->tm_min) << 5) + ((tpm->tm_sec) >> 1));
  
     return;
 }

References NULL.

Referenced by _zip_dirent_write(), decrypt_header(), and encrypt_header().

◆ _zip_unchange()

int _zip_unchange	(	zip_t *	za,
		zip_uint64_t	idx,
		int	allow_duplicates
	)

Definition at line 47 of file zip_unchange.c.

                                                                  {
     zip_int64_t i;
     bool renamed;
  
     if (idx >= za->nentry) {
         zip_error_set(&za->error, ZIP_ER_INVAL, 0);
         return -1;
     }
  
     renamed = za->entry[idx].changes && (za->entry[idx].changes->changed & ZIP_DIRENT_FILENAME);
     if (!allow_duplicates && (renamed || za->entry[idx].deleted)) {
         const char *orig_name = NULL;
         const char *changed_name = NULL;
  
         if (za->entry[idx].orig != NULL) {
             if ((orig_name = _zip_get_name(za, idx, ZIP_FL_UNCHANGED, &za->error)) == NULL) {
                 return -1;
             }
  
             i = _zip_name_locate(za, orig_name, 0, NULL);
             if (i >= 0 && (zip_uint64_t)i != idx) {
                 zip_error_set(&za->error, ZIP_ER_EXISTS, 0);
                 return -1;
             }
         }
  
         if (renamed) {
             if ((changed_name = _zip_get_name(za, idx, 0, &za->error)) == NULL) {
                 return -1;
             }
         }
  
         if (orig_name) {
             if (_zip_hash_add(za->names, (const zip_uint8_t *)orig_name, idx, 0, &za->error) == false) {
                 return -1;
             }
         }
         if (changed_name) {
             if (_zip_hash_delete(za->names, (const zip_uint8_t *)changed_name, &za->error) == false) {
                 _zip_hash_delete(za->names, (const zip_uint8_t *)orig_name, NULL);
                 return -1;
             }
         }
     }
  
     _zip_dirent_free(za->entry[idx].changes);
     za->entry[idx].changes = NULL;
  
     _zip_unchange_data(za->entry + idx);
  
     return 0;
 }

References _zip_dirent_free(), _zip_get_name(), _zip_hash_add(), _zip_hash_delete(), _zip_name_locate(), _zip_unchange_data(), zip_dirent::changed, zip_entry::changes, zip_entry::deleted, zip::entry, zip::error, i, setup::idx, zip::names, zip::nentry, NULL, zip_entry::orig, za, ZIP_DIRENT_FILENAME, ZIP_ER_EXISTS, ZIP_ER_INVAL, zip_error_set(), and ZIP_FL_UNCHANGED.

Referenced by zip_delete(), zip_unchange(), and zip_unchange_all().

◆ _zip_unchange_data()

void _zip_unchange_data ( zip_entry_t * ze )

Definition at line 38 of file zip_unchange_data.c.

                                     {
     if (ze->source) {
         zip_source_free(ze->source);
         ze->source = NULL;
     }
  
     if (ze->changes != NULL && (ze->changes->changed & ZIP_DIRENT_COMP_METHOD) && ze->changes->comp_method == ZIP_CM_REPLACED_DEFAULT) {
         ze->changes->changed &= ~ZIP_DIRENT_COMP_METHOD;
         if (ze->changes->changed == 0) {
             _zip_dirent_free(ze->changes);
             ze->changes = NULL;
         }
     }
  
     ze->deleted = 0;
 }

References _zip_dirent_free(), zip_dirent::changed, zip_entry::changes, zip_dirent::comp_method, zip_entry::deleted, NULL, zip_entry::source, ZIP_CM_REPLACED_DEFAULT, ZIP_DIRENT_COMP_METHOD, and zip_source_free().

Referenced by _zip_entry_finalize(), _zip_file_replace(), and _zip_unchange().

◆ _zip_winzip_aes_decrypt()

bool _zip_winzip_aes_decrypt	(	zip_winzip_aes_t *	ctx,
		zip_uint8_t *	data,
		zip_uint64_t	length
	)

Definition at line 142 of file zip_winzip_aes.c.

                                                                                        {
     return _zip_crypto_hmac(ctx->hmac, data, length) && aes_crypt(ctx, data, length);
 }

References _zip_crypto_hmac, aes_crypt(), and length.

Referenced by winzip_aes_decrypt().

◆ _zip_winzip_aes_encrypt()

bool _zip_winzip_aes_encrypt	(	zip_winzip_aes_t *	ctx,
		zip_uint8_t *	data,
		zip_uint64_t	length
	)

Definition at line 136 of file zip_winzip_aes.c.

                                                                                        {
     return aes_crypt(ctx, data, length) && _zip_crypto_hmac(ctx->hmac, data, length);
 }

References _zip_crypto_hmac, aes_crypt(), and length.

Referenced by winzip_aes_encrypt().

◆ _zip_winzip_aes_finish()

bool _zip_winzip_aes_finish	(	zip_winzip_aes_t *	ctx,
		zip_uint8_t *	hmac
	)

Definition at line 148 of file zip_winzip_aes.c.

                                                                  {
     return _zip_crypto_hmac_output(ctx->hmac, hmac);
 }

References _zip_crypto_hmac_output.

Referenced by verify_hmac(), and winzip_aes_encrypt().

◆ _zip_winzip_aes_free()

void _zip_winzip_aes_free ( zip_winzip_aes_t * ctx )

Definition at line 154 of file zip_winzip_aes.c.

                                             {
     if (ctx == NULL) {
         return;
     }
  
     _zip_crypto_aes_free(ctx->aes);
     _zip_crypto_hmac_free(ctx->hmac);
     free(ctx);
 }

References _zip_crypto_aes_free(), _zip_crypto_hmac_free(), free(), and NULL.

Referenced by decrypt_header(), encrypt_header(), verify_hmac(), winzip_aes_encrypt(), and winzip_aes_free().

◆ _zip_winzip_aes_new()

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
	)

Definition at line 78 of file zip_winzip_aes.c.

                                                                                                                                                                                           {
     zip_winzip_aes_t *ctx;
     zip_uint8_t buffer[2 * (MAX_KEY_LENGTH / 8) + WINZIP_AES_PASSWORD_VERIFY_LENGTH];
     zip_uint16_t key_size = 0; /* in bits */
     zip_uint16_t key_length;   /* in bytes */
  
     switch (encryption_method) {
     case ZIP_EM_AES_128:
         key_size = 128;
         break;
     case ZIP_EM_AES_192:
         key_size = 192;
         break;
     case ZIP_EM_AES_256:
         key_size = 256;
         break;
     }
  
     if (key_size == 0 || salt == NULL || password == NULL || password_length == 0) {
         zip_error_set(error, ZIP_ER_INVAL, 0);
         return NULL;
     }
  
     key_length = key_size / 8;
  
     if ((ctx = (zip_winzip_aes_t *)malloc(sizeof(*ctx))) == NULL) {
         zip_error_set(error, ZIP_ER_MEMORY, 0);
         return NULL;
     }
  
     memset(ctx->counter, 0, sizeof(ctx->counter));
     ctx->pad_offset = ZIP_CRYPTO_AES_BLOCK_LENGTH;
  
     if (!_zip_crypto_pbkdf2(password, password_length, salt, key_length / 2, PBKDF2_ITERATIONS, buffer, 2 * key_length + WINZIP_AES_PASSWORD_VERIFY_LENGTH)) {
         free(ctx);
         return NULL;
     }
  
     if ((ctx->aes = _zip_crypto_aes_new(buffer, key_size, error)) == NULL) {
         _zip_crypto_clear(ctx, sizeof(*ctx));
         free(ctx);
         return NULL;
     }
     if ((ctx->hmac = _zip_crypto_hmac_new(buffer + key_length, key_length, error)) == NULL) {
         _zip_crypto_aes_free(ctx->aes);
         free(ctx);
         return NULL;
     }
  
     if (password_verify) {
         memcpy(password_verify, buffer + (2 * key_size / 8), WINZIP_AES_PASSWORD_VERIFY_LENGTH);
     }
  
     return ctx;
 }

References _zip_crypto_aes_free(), _zip_crypto_aes_new(), _zip_crypto_clear, _zip_crypto_hmac_new(), _zip_crypto_pbkdf2, error(), free(), malloc(), MAX_KEY_LENGTH, memcpy(), memset(), NULL, PBKDF2_ITERATIONS, WINZIP_AES_PASSWORD_VERIFY_LENGTH, ZIP_CRYPTO_AES_BLOCK_LENGTH, ZIP_EM_AES_128, ZIP_EM_AES_192, ZIP_EM_AES_256, ZIP_ER_INVAL, ZIP_ER_MEMORY, and zip_error_set().

Referenced by decrypt_header(), and encrypt_header().

◆ _zip_write()

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

Definition at line 121 of file zip_io_util.c.

                                                              {
     zip_int64_t n;
  
     if ((n = zip_source_write(za->src, data, length)) < 0) {
         _zip_error_set_from_source(&za->error, za->src);
         return -1;
     }
     if ((zip_uint64_t)n != length) {
         zip_error_set(&za->error, ZIP_ER_WRITE, EINTR);
         return -1;
     }
  
     return 0;
 }

References _zip_error_set_from_source(), EINTR, zip::error, length, n, zip::src, za, ZIP_ER_WRITE, zip_error_set(), and zip_source_write().

Referenced by _zip_cdir_write(), _zip_dirent_write(), _zip_ef_write(), _zip_string_write(), copy_data(), copy_source(), and write_data_descriptor().

◆ zip_get_extra_field_by_id()

const zip_uint8_t* zip_get_extra_field_by_id	(	zip_t *	,
		int	,
		int	,
		zip_uint16_t	,
		int	,
		zip_uint16_t *
	)

◆ zip_random_uint32()

zip_uint32_t zip_random_uint32 ( void )

Definition at line 87 of file zip_random_unix.c.

                         {
     static bool seeded = false;
  
     zip_uint32_t value;
  
     if (zip_secure_random((zip_uint8_t *)&value, sizeof(value))) {
         return value;
     }
  
     if (!seeded) {
         srandom((unsigned int)time(NULL));
     }
  
     return (zip_uint32_t)random();
 }

References NULL, time, value, and zip_secure_random().

Referenced by create_temp_file().

◆ zip_secure_random()

ZIP_EXTERN bool zip_secure_random	(	zip_uint8_t *	buffer,
		zip_uint16_t	length
	)

Definition at line 132 of file zip_crypto_gnutls.c.

                                                             {
     return gnutls_rnd(GNUTLS_RND_KEY, buffer, length) == 0;
 }

References close, fd, free(), length, malloc(), memset(), NULL, O_RDONLY, and read().

Referenced by encrypt_header(), main(), and zip_random_uint32().

◆ zip_source_accept_empty()

bool zip_source_accept_empty ( zip_source_t * src )

Definition at line 39 of file zip_source_accept_empty.c.

                                            {
     int ret;
  
     if ((zip_source_supports(src) & ZIP_SOURCE_MAKE_COMMAND_BITMASK(ZIP_SOURCE_ACCEPT_EMPTY)) == 0) {
         if (ZIP_SOURCE_IS_LAYERED(src)) {
             return zip_source_accept_empty(src->src);
         }
         return true;
     }
  
     ret = (int)_zip_source_call(src, NULL, 0, ZIP_SOURCE_ACCEPT_EMPTY);
  
     return ret != 0;
 }

References _zip_source_call(), int, NULL, src, ZIP_SOURCE_ACCEPT_EMPTY, ZIP_SOURCE_IS_LAYERED, ZIP_SOURCE_MAKE_COMMAND_BITMASK, and zip_source_supports().

Referenced by _zip_open().

◆ zip_source_buffer_with_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
	)

Definition at line 180 of file zip_source_buffer.c.

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

References read_data::attributes, zip::error, len, za, and zip_source_buffer_with_attributes_create().

◆ zip_source_buffer_with_attributes_create()

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
	)

Definition at line 103 of file zip_source_buffer.c.

                                                                                                                                                {
     zip_buffer_fragment_t fragment;
  
     if (data == NULL) {
         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);
     }
  
     fragment.data = (zip_uint8_t *)data;
     fragment.length = len;
  
     return zip_source_buffer_fragment_with_attributes_create(&fragment, 1, freep, attributes, error);
 }

References zip_buffer_fragment::data, error(), len, zip_buffer_fragment::length, NULL, ZIP_ER_INVAL, zip_error_set(), and zip_source_buffer_fragment_with_attributes_create().

Referenced by _zip_source_zip_new(), zip_source_buffer(), zip_source_buffer_create(), and zip_source_buffer_with_attributes().

◆ zip_source_compress()

zip_source_t* zip_source_compress	(	zip_t *	za,
		zip_source_t *	src,
		zip_int32_t	cm,
		int	compression_flags
	)

Definition at line 120 of file zip_source_compress.c.

                                                                                              {
     return compression_source_new(za, src, method, true, compression_flags);
 }

References compression_source_new(), context::method, src, and za.

Referenced by add_data().

◆ zip_source_crc_create()

zip_source_t* zip_source_crc_create	(	zip_source_t *	src,
		int	validate,
		zip_error_t *	error
	)

Definition at line 55 of file zip_source_crc.c.

                                                                            {
     struct crc_context *ctx;
  
     if (src == NULL) {
         zip_error_set(error, ZIP_ER_INVAL, 0);
         return NULL;
     }
  
     if ((ctx = (struct crc_context *)malloc(sizeof(*ctx))) == NULL) {
         zip_error_set(error, ZIP_ER_MEMORY, 0);
         return NULL;
     }
  
     zip_error_init(&ctx->error);
     ctx->validate = validate;
     ctx->crc_complete = 0;
     ctx->crc_position = 0;
     ctx->crc = (zip_uint32_t)crc32(0, NULL, 0);
     ctx->size = 0;
  
     return zip_source_layered_create(src, crc_read, ctx, error);
 }

References crc32(), crc_read(), ctx::error, error(), malloc(), NULL, src, validate(), ZIP_ER_INVAL, ZIP_ER_MEMORY, zip_error_init(), zip_error_set(), and zip_source_layered_create().

Referenced by _zip_source_zip_new(), and add_data().

◆ zip_source_decompress()

zip_source_t* zip_source_decompress	(	zip_t *	za,
		zip_source_t *	src,
		zip_int32_t	cm
	)

Definition at line 125 of file zip_source_compress.c.

                                                                         {
     return compression_source_new(za, src, method, false, 0);
 }

References compression_source_new(), context::method, src, and za.

Referenced by _zip_source_zip_new(), and add_data().

◆ zip_source_layered()

zip_source_t* zip_source_layered	(	zip_t *	za,
		zip_source_t *	src,
		zip_source_layered_callback	cb,
		void *	ud
	)

Definition at line 41 of file zip_source_layered.c.

                                                                                            {
     if (za == NULL)
         return NULL;
  
     return zip_source_layered_create(src, cb, ud, &za->error);
 }

References cb, zip::error, NULL, src, za, and zip_source_layered_create().

Referenced by compression_source_new(), zip_source_pkware_decode(), zip_source_pkware_encode(), zip_source_winzip_aes_decode(), and zip_source_winzip_aes_encode().

◆ zip_source_layered_create()

zip_source_t* zip_source_layered_create	(	zip_source_t *	src,
		zip_source_layered_callback	cb,
		void *	ud,
		zip_error_t *	error
	)

Definition at line 50 of file zip_source_layered.c.

                                                                                                            {
     zip_source_t *zs;
  
     if ((zs = _zip_source_new(error)) == NULL)
         return NULL;
  
     zip_source_keep(src);
     zs->src = src;
     zs->cb.l = cb;
     zs->ud = ud;
  
     zs->supports = cb(src, ud, NULL, 0, ZIP_SOURCE_SUPPORTS);
     if (zs->supports < 0) {
         zs->supports = ZIP_SOURCE_SUPPORTS_READABLE;
     }
  
     return zs;
 }

References _zip_source_new(), cb, zip_source::cb, error(), zip_source::l, NULL, zip_source::src, src, zip_source::supports, zip_source::ud, zip_source_keep(), ZIP_SOURCE_SUPPORTS, and ZIP_SOURCE_SUPPORTS_READABLE.

Referenced by _zip_source_window_new(), zip_source_crc_create(), and zip_source_layered().

◆ zip_source_pkware_decode()

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

Definition at line 54 of file zip_source_pkware_decode.c.

                                                                                                          {
     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_decrypt, ctx)) == NULL) {
         trad_pkware_free(ctx);
         return NULL;
     }
  
     return s2;
 }

References zip::error, flags, NULL, trad_pkware::password, pkware_decrypt(), s2, src, trad_pkware_free(), trad_pkware_new(), za, ZIP_CODEC_ENCODE, ZIP_EM_TRAD_PKWARE, ZIP_ER_ENCRNOTSUPP, ZIP_ER_INVAL, zip_error_set(), and zip_source_layered().

Referenced by _zip_get_encryption_implementation().

◆ zip_source_pkware_encode()

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

Definition at line 56 of file zip_source_pkware_encode.c.

                                                                                                          {
     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;
 }

References zip::error, flags, NULL, trad_pkware::password, pkware_encrypt(), s2, src, trad_pkware_free(), trad_pkware_new(), za, ZIP_CODEC_ENCODE, ZIP_EM_TRAD_PKWARE, ZIP_ER_ENCRNOTSUPP, ZIP_ER_INVAL, zip_error_set(), and zip_source_layered().

Referenced by _zip_get_encryption_implementation().

◆ zip_source_remove()

int zip_source_remove ( zip_source_t * src )

Definition at line 39 of file zip_source_remove.c.

                                      {
     if (src->write_state == ZIP_SOURCE_WRITE_REMOVED) {
         return 0;
     }
  
     if (ZIP_SOURCE_IS_OPEN_READING(src)) {
         if (zip_source_close(src) < 0) {
             return -1;
         }
     }
     if (src->write_state != ZIP_SOURCE_WRITE_CLOSED) {
         zip_source_rollback_write(src);
     }
  
     if (_zip_source_call(src, NULL, 0, ZIP_SOURCE_REMOVE) < 0) {
         return -1;
     }
  
     src->write_state = ZIP_SOURCE_WRITE_REMOVED;
  
     return 0;
 }

References _zip_source_call(), NULL, src, zip_source_close(), ZIP_SOURCE_IS_OPEN_READING, ZIP_SOURCE_REMOVE, zip_source_rollback_write(), ZIP_SOURCE_WRITE_CLOSED, and ZIP_SOURCE_WRITE_REMOVED.

Referenced by zip_close().

◆ zip_source_supports()

zip_int64_t zip_source_supports ( zip_source_t * src )

Definition at line 41 of file zip_source_supports.c.

                                        {
     return src->supports;
 }

References src.

Referenced by _zip_source_window_new(), crc_read(), zip_close(), zip_file_is_seekable(), zip_open_from_source(), zip_source_accept_empty(), and zip_source_open().

◆ zip_source_winzip_aes_decode()

zip_source_t* zip_source_winzip_aes_decode	(	zip_t *	za,
		zip_source_t *	src,
		zip_uint16_t	encryption_method,
		int	flags,
		const char *	password
	)

Definition at line 59 of file zip_source_winzip_aes_decode.c.

                                                                                                                             {
     zip_source_t *s2;
     zip_stat_t st;
     zip_uint64_t aux_length;
     struct winzip_aes *ctx;
  
     if ((encryption_method != ZIP_EM_AES_128 && encryption_method != ZIP_EM_AES_192 && encryption_method != ZIP_EM_AES_256) || password == NULL || src == NULL) {
         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 (zip_source_stat(src, &st) != 0) {
         _zip_error_set_from_source(&za->error, src);
         return NULL;
     }
  
     aux_length = WINZIP_AES_PASSWORD_VERIFY_LENGTH + SALT_LENGTH(encryption_method) + HMAC_LENGTH;
  
     if ((st.valid & ZIP_STAT_COMP_SIZE) == 0 || st.comp_size < aux_length) {
         zip_error_set(&za->error, ZIP_ER_OPNOTSUPP, 0);
         return NULL;
     }
  
     if ((ctx = winzip_aes_new(encryption_method, password, &za->error)) == NULL) {
         return NULL;
     }
  
     ctx->data_length = st.comp_size - aux_length;
  
     if ((s2 = zip_source_layered(za, src, winzip_aes_decrypt, ctx)) == NULL) {
         winzip_aes_free(ctx);
         return NULL;
     }
  
     return s2;
 }

References _zip_error_set_from_source(), zip_stat::comp_size, winzip_aes::encryption_method, zip::error, flags, HMAC_LENGTH, NULL, winzip_aes::password, s2, SALT_LENGTH, src, zip_stat::valid, winzip_aes_decrypt(), winzip_aes_free(), winzip_aes_new(), WINZIP_AES_PASSWORD_VERIFY_LENGTH, za, ZIP_CODEC_ENCODE, ZIP_EM_AES_128, ZIP_EM_AES_192, ZIP_EM_AES_256, ZIP_ER_ENCRNOTSUPP, ZIP_ER_INVAL, ZIP_ER_OPNOTSUPP, zip_error_set(), zip_source_layered(), zip_source_stat(), and ZIP_STAT_COMP_SIZE.

Referenced by _zip_get_encryption_implementation().

◆ zip_source_winzip_aes_encode()

zip_source_t* zip_source_winzip_aes_encode	(	zip_t *	za,
		zip_source_t *	src,
		zip_uint16_t	encryption_method,
		int	flags,
		const char *	password
	)

Definition at line 61 of file zip_source_winzip_aes_encode.c.

                                                                                                                             {
     zip_source_t *s2;
     struct winzip_aes *ctx;
  
     if ((encryption_method != ZIP_EM_AES_128 && encryption_method != ZIP_EM_AES_192 && encryption_method != ZIP_EM_AES_256) || password == NULL || src == NULL) {
         zip_error_set(&za->error, ZIP_ER_INVAL, 0);
         return NULL;
     }
  
     if ((ctx = winzip_aes_new(encryption_method, password, &za->error)) == NULL) {
         return NULL;
     }
  
     if ((s2 = zip_source_layered(za, src, winzip_aes_encrypt, ctx)) == NULL) {
         winzip_aes_free(ctx);
         return NULL;
     }
  
     return s2;
 }

References winzip_aes::encryption_method, zip::error, NULL, winzip_aes::password, s2, src, winzip_aes_encrypt(), winzip_aes_free(), winzip_aes_new(), za, ZIP_EM_AES_128, ZIP_EM_AES_192, ZIP_EM_AES_256, ZIP_ER_INVAL, zip_error_set(), and zip_source_layered().

Referenced by _zip_get_encryption_implementation().

Variable Documentation

◆ _zip_err_details

const struct _zip_err_info _zip_err_details[]

extern

Definition at line 51 of file zip_err_str.c.

Referenced by zip_error_strerror().

◆ _zip_err_details_count

const int _zip_err_details_count

extern

Definition at line 76 of file zip_err_str.c.

Referenced by zip_error_strerror().

◆ _zip_err_str

const struct _zip_err_info _zip_err_str[]

extern

Definition at line 1 of file zip_err_str.c.

Referenced by zip_error_get_sys_type(), zip_error_strerror(), zip_error_system_type(), and zip_error_to_str().

◆ _zip_err_str_count

const int _zip_err_str_count

extern

Definition at line 51 of file zip_err_str.c.

Referenced by zip_error_get_sys_type(), zip_error_strerror(), zip_error_system_type(), and zip_error_to_str().

◆ zip_algorithm_bzip2_compress

zip_compression_algorithm_t zip_algorithm_bzip2_compress

extern

Definition at line 258 of file zip_algorithm_bzip2.c.

◆ zip_algorithm_bzip2_decompress

zip_compression_algorithm_t zip_algorithm_bzip2_decompress

extern

Definition at line 272 of file zip_algorithm_bzip2.c.

◆ zip_algorithm_deflate_compress

zip_compression_algorithm_t zip_algorithm_deflate_compress

extern

Definition at line 238 of file zip_algorithm_deflate.c.

◆ zip_algorithm_deflate_decompress

zip_compression_algorithm_t zip_algorithm_deflate_decompress

extern

Definition at line 252 of file zip_algorithm_deflate.c.

◆ zip_algorithm_xz_compress

zip_compression_algorithm_t zip_algorithm_xz_compress

extern

Definition at line 379 of file zip_algorithm_xz.c.

◆ zip_algorithm_xz_decompress

zip_compression_algorithm_t zip_algorithm_xz_decompress

extern

Definition at line 393 of file zip_algorithm_xz.c.

◆ zip_algorithm_zstd_compress

zip_compression_algorithm_t zip_algorithm_zstd_compress

extern

Definition at line 267 of file zip_algorithm_zstd.c.

◆ zip_algorithm_zstd_decompress

zip_compression_algorithm_t zip_algorithm_zstd_decompress

extern

Definition at line 281 of file zip_algorithm_zstd.c.

Enumerations
enum	zip_compression_status { ZIP_COMPRESSION_OK , ZIP_COMPRESSION_END , ZIP_COMPRESSION_ERROR , ZIP_COMPRESSION_NEED_DATA }

enum	zip_les { ZIP_LES_NONE , ZIP_LES_UPPER , ZIP_LES_LOWER , ZIP_LES_INVAL }

enum	zip_encoding_type { ZIP_ENCODING_UNKNOWN , ZIP_ENCODING_ASCII , ZIP_ENCODING_UTF8_KNOWN , ZIP_ENCODING_UTF8_GUESSED , ZIP_ENCODING_CP437 , ZIP_ENCODING_ERROR }

enum	zip_source_write_state { ZIP_SOURCE_WRITE_CLOSED , ZIP_SOURCE_WRITE_OPEN , ZIP_SOURCE_WRITE_FAILED , ZIP_SOURCE_WRITE_REMOVED }

Variables
zip_compression_algorithm_t	zip_algorithm_bzip2_compress

zip_compression_algorithm_t	zip_algorithm_bzip2_decompress

zip_compression_algorithm_t	zip_algorithm_deflate_compress

zip_compression_algorithm_t	zip_algorithm_deflate_decompress

zip_compression_algorithm_t	zip_algorithm_xz_compress

zip_compression_algorithm_t	zip_algorithm_xz_decompress

zip_compression_algorithm_t	zip_algorithm_zstd_compress

zip_compression_algorithm_t	zip_algorithm_zstd_decompress

const struct _zip_err_info	_zip_err_str []

const int	_zip_err_str_count

const struct _zip_err_info	_zip_err_details []

const int	_zip_err_details_count

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ _zip_crypto_clear

◆ ADD_INDEX_TO_DETAIL

◆ AES_BLOCK_SIZE

◆ BUFSIZE

◆ byte_array_fini

◆ byte_array_init

◆ CDBUFSIZE

◆ CDENTRYSIZE

◆ CENTRAL_MAGIC

◆ DATADES_MAGIC

◆ DEFINE_BYTE_ARRAY

◆ EF_WINZIP_AES_SIZE

◆ EFZIP64SIZE

◆ EOCD64_MAGIC

◆ EOCD64LEN

◆ EOCD64LOC_MAGIC

◆ EOCD64LOCLEN

◆ EOCD_MAGIC

◆ EOCDLEN

◆ GET_ERROR_FROM_DETAIL

◆ GET_INDEX_FROM_DETAIL

◆ HMAC_LENGTH

◆ LENTRYSIZE

◆ LOCAL_MAGIC

◆ MAKE_DETAIL_WITH_INDEX

◆ MAX_DATA_DESCRIPTOR_LENGTH

◆ MAX_DETAIL_INDEX

◆ MAXCOMLEN

◆ MAXEXTLEN

◆ SALT_LENGTH

◆ SHA1_LENGTH

◆ WINZIP_AES_MAX_HEADER_LENGTH

◆ WINZIP_AES_PASSWORD_VERIFY_LENGTH

◆ ZIP_CM_ACTUAL

◆ ZIP_CM_IS_DEFAULT

◆ ZIP_CM_REPLACED_DEFAULT

◆ ZIP_CM_WINZIP_AES

◆ ZIP_CODEC_DECODE

◆ ZIP_CODEC_ENCODE

◆ ZIP_CRYPTO_PKWARE_HEADERLEN

◆ ZIP_DETAIL_ET_ENTRY

◆ ZIP_DETAIL_ET_GLOBAL

◆ ZIP_DIRENT_ALL

◆ ZIP_DIRENT_ATTRIBUTES

◆ ZIP_DIRENT_COMMENT

◆ ZIP_DIRENT_COMP_METHOD

◆ ZIP_DIRENT_ENCRYPTION_METHOD

◆ ZIP_DIRENT_EXTRA_FIELD

◆ ZIP_DIRENT_FILENAME

◆ ZIP_DIRENT_LAST_MOD

◆ ZIP_DIRENT_PASSWORD

◆ ZIP_EF_BOTH

◆ ZIP_EF_CENTRAL

◆ ZIP_EF_IS_INTERNAL

◆ ZIP_EF_LOCAL

◆ ZIP_EF_UTF_8_COMMENT

◆ ZIP_EF_UTF_8_NAME

◆ ZIP_EF_WINZIP_AES

◆ ZIP_EF_ZIP64

◆ ZIP_ENTRY_CHANGED

◆ ZIP_ENTRY_DATA_CHANGED

◆ ZIP_ENTRY_HAS_CHANGES

◆ ZIP_ER_DETAIL_CDIR_ENTRY_INVALID

◆ ZIP_ER_DETAIL_CDIR_INVALID

◆ ZIP_ER_DETAIL_CDIR_LENGTH_INVALID

◆ ZIP_ER_DETAIL_CDIR_OVERLAPS_EOCD

◆ ZIP_ER_DETAIL_CDIR_WRONG_ENTRIES_COUNT

◆ ZIP_ER_DETAIL_COMMENT_LENGTH_INVALID

◆ ZIP_ER_DETAIL_EF_TRAILING_GARBAGE

◆ ZIP_ER_DETAIL_ENTRY_HEADER_MISMATCH

◆ ZIP_ER_DETAIL_EOCD64_MISMATCH

◆ ZIP_ER_DETAIL_EOCD64_OVERLAPS_EOCD

◆ ZIP_ER_DETAIL_EOCD64_WRONG_MAGIC