"Fossies" - the Fresh Open Source Software Archive

Member "src/Common/libzip/zipint.h" (10 Oct 2018, 24843 Bytes) of package /windows/misc/VeraCrypt_1.23-Hotfix-2_Source.zip:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "zipint.h" see the Fossies "Dox" file reference documentation and the last Fossies "Diffs" side-by-side code changes report: 1.21_Source_vs_1.22_Source.

    1 #ifndef _HAD_ZIPINT_H
    2 #define _HAD_ZIPINT_H
    3 
    4 /*
    5   zipint.h -- internal declarations.
    6   Copyright (C) 1999-2017 Dieter Baron and Thomas Klausner
    7 
    8   This file is part of libzip, a library to manipulate ZIP archives.
    9   The authors can be contacted at <libzip@nih.at>
   10 
   11   Redistribution and use in source and binary forms, with or without
   12   modification, are permitted provided that the following conditions
   13   are met:
   14   1. Redistributions of source code must retain the above copyright
   15      notice, this list of conditions and the following disclaimer.
   16   2. Redistributions in binary form must reproduce the above copyright
   17      notice, this list of conditions and the following disclaimer in
   18      the documentation and/or other materials provided with the
   19      distribution.
   20   3. The names of the authors may not be used to endorse or promote
   21      products derived from this software without specific prior
   22      written permission.
   23 
   24   THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS
   25   OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   26   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   27   ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
   28   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   29   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
   30   GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   31   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
   32   IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
   33   OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
   34   IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   35 */
   36 
   37 #ifdef HAVE_CONFIG_H
   38 #include "config.h"
   39 #endif
   40 
   41 #include "compat.h"
   42 
   43 #include <zlib.h>
   44 
   45 #ifndef _ZIP_COMPILING_DEPRECATED
   46 #define ZIP_DISABLE_DEPRECATED
   47 #endif
   48 
   49 #include "zip.h"
   50 
   51 #define CENTRAL_MAGIC "PK\1\2"
   52 #define LOCAL_MAGIC "PK\3\4"
   53 #define EOCD_MAGIC "PK\5\6"
   54 #define DATADES_MAGIC "PK\7\10"
   55 #define EOCD64LOC_MAGIC "PK\6\7"
   56 #define EOCD64_MAGIC "PK\6\6"
   57 #define CDENTRYSIZE 46u
   58 #define LENTRYSIZE 30
   59 #define MAXCOMLEN 65536
   60 #define MAXEXTLEN 65536
   61 #define EOCDLEN 22
   62 #define EOCD64LOCLEN 20
   63 #define EOCD64LEN 56
   64 #define CDBUFSIZE (MAXCOMLEN + EOCDLEN + EOCD64LOCLEN)
   65 #define BUFSIZE 8192
   66 #define EFZIP64SIZE 28
   67 #define EF_WINZIP_AES_SIZE 7
   68 
   69 #define ZIP_CM_REPLACED_DEFAULT (-2)
   70 #define ZIP_CM_WINZIP_AES 99 /* Winzip AES encrypted */
   71 
   72 #define WINZIP_AES_PASSWORD_VERIFY_LENGTH 2
   73 #define WINZIP_AES_MAX_HEADER_LENGTH (16 + WINZIP_AES_PASSWORD_VERIFY_LENGTH)
   74 #define AES_BLOCK_SIZE 16
   75 #define HMAC_LENGTH 10
   76 #define SHA1_LENGTH 20
   77 #define SALT_LENGTH(method) ((method) == ZIP_EM_AES_128 ? 8 : ((method) == ZIP_EM_AES_192 ? 12 : 16))
   78 
   79 #define ZIP_CM_IS_DEFAULT(x) ((x) == ZIP_CM_DEFAULT || (x) == ZIP_CM_REPLACED_DEFAULT)
   80 #define ZIP_CM_ACTUAL(x) ((zip_uint16_t)(ZIP_CM_IS_DEFAULT(x) ? ZIP_CM_DEFLATE : (x)))
   81 
   82 #define ZIP_EF_UTF_8_COMMENT 0x6375
   83 #define ZIP_EF_UTF_8_NAME 0x7075
   84 #define ZIP_EF_WINZIP_AES 0x9901
   85 #define ZIP_EF_ZIP64 0x0001
   86 
   87 #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)
   88 
   89 /* according to unzip-6.0's zipinfo.c, this corresponds to a regular file with rw permissions for everyone */
   90 #define ZIP_EXT_ATTRIB_DEFAULT (0100666u << 16)
   91 /* according to unzip-6.0's zipinfo.c, this corresponds to a directory with rwx permissions for everyone */
   92 #define ZIP_EXT_ATTRIB_DEFAULT_DIR (0040777u << 16)
   93 
   94 
   95 #define ZIP_MAX(a, b) ((a) > (b) ? (a) : (b))
   96 #define ZIP_MIN(a, b) ((a) < (b) ? (a) : (b))
   97 
   98 /* This section contains API that won't materialize like this.  It's
   99    placed in the internal section, pending cleanup. */
  100 
  101 /* flags for compression and encryption sources */
  102 
  103 #define ZIP_CODEC_DECODE 0 /* decompress/decrypt (encode flag not set) */
  104 #define ZIP_CODEC_ENCODE 1 /* compress/encrypt */
  105 
  106 typedef zip_source_t *(*zip_encryption_implementation)(zip_t *, zip_source_t *, zip_uint16_t, int, const char *);
  107 
  108 zip_encryption_implementation _zip_get_encryption_implementation(zip_uint16_t method, int operation);
  109 
  110 // clang-format off
  111 enum zip_compression_status {
  112     ZIP_COMPRESSION_OK,
  113     ZIP_COMPRESSION_END,
  114     ZIP_COMPRESSION_ERROR,
  115     ZIP_COMPRESSION_NEED_DATA
  116 };
  117 // clang-format on
  118 typedef enum zip_compression_status zip_compression_status_t;
  119 
  120 struct zip_compression_algorithm {
  121     /* called once to create new context */
  122     void *(*allocate)(zip_uint16_t method, int compression_flags, zip_error_t *error);
  123     /* called once to free context */
  124     void (*deallocate)(void *ctx);
  125 
  126     /* get compression specific general purpose bitflags */
  127     int (*compression_flags)(void *ctx);
  128 
  129     /* start processing */
  130     bool (*start)(void *ctx);
  131     /* stop processing */
  132     bool (*end)(void *ctx);
  133 
  134     /* provide new input data, remains valid until next call to input or end */
  135     bool (*input)(void *ctx, zip_uint8_t *data, zip_uint64_t length);
  136 
  137     /* all input data has been provided */
  138     void (*end_of_input)(void *ctx);
  139 
  140     /* process input data, writing to data, which has room for length bytes, update length to number of bytes written */
  141     zip_compression_status_t (*process)(void *ctx, zip_uint8_t *data, zip_uint64_t *length);
  142 };
  143 typedef struct zip_compression_algorithm zip_compression_algorithm_t;
  144 
  145 extern zip_compression_algorithm_t zip_algorithm_bzip2_compress;
  146 extern zip_compression_algorithm_t zip_algorithm_bzip2_decompress;
  147 extern zip_compression_algorithm_t zip_algorithm_deflate_compress;
  148 extern zip_compression_algorithm_t zip_algorithm_deflate_decompress;
  149 
  150 bool zip_compression_method_supported(zip_int32_t method, bool compress);
  151 
  152 /* This API is not final yet, but we need it internally, so it's private for now. */
  153 
  154 const zip_uint8_t *zip_get_extra_field_by_id(zip_t *, int, int, zip_uint16_t, int, zip_uint16_t *);
  155 
  156 /* This section contains API that is of limited use until support for
  157    user-supplied compression/encryption implementation is finished.
  158    Thus we will keep it private for now. */
  159 
  160 typedef zip_int64_t (*zip_source_layered_callback)(zip_source_t *, void *, void *, zip_uint64_t, enum zip_source_cmd);
  161 zip_source_t *zip_source_compress(zip_t *za, zip_source_t *src, zip_int32_t cm, int compression_flags);
  162 zip_source_t *zip_source_crc(zip_t *, zip_source_t *, int);
  163 zip_source_t *zip_source_decompress(zip_t *za, zip_source_t *src, zip_int32_t cm);
  164 zip_source_t *zip_source_layered(zip_t *, zip_source_t *, zip_source_layered_callback, void *);
  165 zip_source_t *zip_source_layered_create(zip_source_t *src, zip_source_layered_callback cb, void *ud, zip_error_t *error);
  166 zip_source_t *zip_source_pkware(zip_t *, zip_source_t *, zip_uint16_t, int, const char *);
  167 int zip_source_remove(zip_source_t *);
  168 zip_int64_t zip_source_supports(zip_source_t *src);
  169 zip_source_t *zip_source_window(zip_t *, zip_source_t *, zip_uint64_t, zip_uint64_t);
  170 zip_source_t *zip_source_winzip_aes_decode(zip_t *, zip_source_t *, zip_uint16_t, int, const char *);
  171 zip_source_t *zip_source_winzip_aes_encode(zip_t *, zip_source_t *, zip_uint16_t, int, const char *);
  172 
  173 
  174 /* error source for layered sources */
  175 
  176 enum zip_les { ZIP_LES_NONE, ZIP_LES_UPPER, ZIP_LES_LOWER, ZIP_LES_INVAL };
  177 
  178 /* directory entry: general purpose bit flags */
  179 
  180 #define ZIP_GPBF_ENCRYPTED 0x0001u         /* is encrypted */
  181 #define ZIP_GPBF_DATA_DESCRIPTOR 0x0008u   /* crc/size after file data */
  182 #define ZIP_GPBF_STRONG_ENCRYPTION 0x0040u /* uses strong encryption */
  183 #define ZIP_GPBF_ENCODING_UTF_8 0x0800u    /* file name encoding is UTF-8 */
  184 
  185 
  186 /* extra fields */
  187 #define ZIP_EF_LOCAL ZIP_FL_LOCAL                   /* include in local header */
  188 #define ZIP_EF_CENTRAL ZIP_FL_CENTRAL               /* include in central directory */
  189 #define ZIP_EF_BOTH (ZIP_EF_LOCAL | ZIP_EF_CENTRAL) /* include in both */
  190 
  191 #define ZIP_FL_FORCE_ZIP64 1024 /* force zip64 extra field (_zip_dirent_write) */
  192 
  193 #define ZIP_FL_ENCODING_ALL (ZIP_FL_ENC_GUESS | ZIP_FL_ENC_CP437 | ZIP_FL_ENC_UTF_8)
  194 
  195 
  196 /* encoding type */
  197 enum zip_encoding_type {
  198     ZIP_ENCODING_UNKNOWN,      /* not yet analyzed */
  199     ZIP_ENCODING_ASCII,        /* plain ASCII */
  200     ZIP_ENCODING_UTF8_KNOWN,   /* is UTF-8 */
  201     ZIP_ENCODING_UTF8_GUESSED, /* possibly UTF-8 */
  202     ZIP_ENCODING_CP437,        /* Code Page 437 */
  203     ZIP_ENCODING_ERROR         /* should be UTF-8 but isn't */
  204 };
  205 
  206 typedef enum zip_encoding_type zip_encoding_type_t;
  207 
  208 struct zip_hash;
  209 struct zip_progress;
  210 
  211 typedef struct zip_cdir zip_cdir_t;
  212 typedef struct zip_dirent zip_dirent_t;
  213 typedef struct zip_entry zip_entry_t;
  214 typedef struct zip_extra_field zip_extra_field_t;
  215 typedef struct zip_string zip_string_t;
  216 typedef struct zip_buffer zip_buffer_t;
  217 typedef struct zip_hash zip_hash_t;
  218 typedef struct zip_progress zip_progress_t;
  219 
  220 /* zip archive, part of API */
  221 
  222 struct zip {
  223     zip_source_t *src;       /* data source for archive */
  224     unsigned int open_flags; /* flags passed to zip_open */
  225     zip_error_t error;       /* error information */
  226 
  227     unsigned int flags;    /* archive global flags */
  228     unsigned int ch_flags; /* changed archive global flags */
  229 
  230     char *default_password; /* password used when no other supplied */
  231 
  232     zip_string_t *comment_orig;    /* archive comment */
  233     zip_string_t *comment_changes; /* changed archive comment */
  234     bool comment_changed;          /* whether archive comment was changed */
  235 
  236     zip_uint64_t nentry;       /* number of entries */
  237     zip_uint64_t nentry_alloc; /* number of entries allocated */
  238     zip_entry_t *entry;        /* entries */
  239 
  240     unsigned int nopen_source;       /* number of open sources using archive */
  241     unsigned int nopen_source_alloc; /* number of sources allocated */
  242     zip_source_t **open_source;      /* open sources using archive */
  243 
  244     zip_hash_t *names; /* hash table for name lookup */
  245 
  246     zip_progress_t *progress; /* progress callback for zip_close() */
  247 };
  248 
  249 /* file in zip archive, part of API */
  250 
  251 struct zip_file {
  252     zip_t *za;         /* zip archive containing this file */
  253     zip_error_t error; /* error information */
  254     bool eof;
  255     zip_source_t *src; /* data source */
  256 };
  257 
  258 /* zip archive directory entry (central or local) */
  259 
  260 #define ZIP_DIRENT_COMP_METHOD 0x0001u
  261 #define ZIP_DIRENT_FILENAME 0x0002u
  262 #define ZIP_DIRENT_COMMENT 0x0004u
  263 #define ZIP_DIRENT_EXTRA_FIELD 0x0008u
  264 #define ZIP_DIRENT_ATTRIBUTES 0x0010u
  265 #define ZIP_DIRENT_LAST_MOD 0x0020u
  266 #define ZIP_DIRENT_ENCRYPTION_METHOD 0x0040u
  267 #define ZIP_DIRENT_PASSWORD 0x0080u
  268 #define ZIP_DIRENT_ALL ZIP_UINT32_MAX
  269 
  270 struct zip_dirent {
  271     zip_uint32_t changed;
  272     bool local_extra_fields_read; /*      whether we already read in local header extra fields */
  273     bool cloned;                  /*      whether this instance is cloned, and thus shares non-changed strings */
  274 
  275     bool crc_valid; /*      if CRC is valid (sometimes not for encrypted archives) */
  276 
  277     zip_uint16_t version_madeby;     /* (c)  version of creator */
  278     zip_uint16_t version_needed;     /* (cl) version needed to extract */
  279     zip_uint16_t bitflags;           /* (cl) general purpose bit flag */
  280     zip_int32_t comp_method;         /* (cl) compression method used (uint16 and ZIP_CM_DEFAULT (-1)) */
  281     time_t last_mod;                 /* (cl) time of last modification */
  282     zip_uint32_t crc;                /* (cl) CRC-32 of uncompressed data */
  283     zip_uint64_t comp_size;          /* (cl) size of compressed data */
  284     zip_uint64_t uncomp_size;        /* (cl) size of uncompressed data */
  285     zip_string_t *filename;          /* (cl) file name (NUL-terminated) */
  286     zip_extra_field_t *extra_fields; /* (cl) extra fields, parsed */
  287     zip_string_t *comment;           /* (c)  file comment */
  288     zip_uint32_t disk_number;        /* (c)  disk number start */
  289     zip_uint16_t int_attrib;         /* (c)  internal file attributes */
  290     zip_uint32_t ext_attrib;         /* (c)  external file attributes */
  291     zip_uint64_t offset;             /* (c)  offset of local header */
  292 
  293     zip_uint16_t compression_level; /*      level of compression to use (never valid in orig) */
  294     zip_uint16_t encryption_method; /*      encryption method, computed from other fields */
  295     char *password;                 /*      file specific encryption password */
  296 };
  297 
  298 /* zip archive central directory */
  299 
  300 struct zip_cdir {
  301     zip_entry_t *entry;        /* directory entries */
  302     zip_uint64_t nentry;       /* number of entries */
  303     zip_uint64_t nentry_alloc; /* number of entries allocated */
  304 
  305     zip_uint64_t size;     /* size of central directory */
  306     zip_uint64_t offset;   /* offset of central directory in file */
  307     zip_string_t *comment; /* zip archive comment */
  308     bool is_zip64;         /* central directory in zip64 format */
  309 };
  310 
  311 struct zip_extra_field {
  312     zip_extra_field_t *next;
  313     zip_flags_t flags; /* in local/central header */
  314     zip_uint16_t id;   /* header id */
  315     zip_uint16_t size; /* data size */
  316     zip_uint8_t *data;
  317 };
  318 
  319 enum zip_source_write_state {
  320     ZIP_SOURCE_WRITE_CLOSED, /* write is not in progress */
  321     ZIP_SOURCE_WRITE_OPEN,   /* write is in progress */
  322     ZIP_SOURCE_WRITE_FAILED, /* commit failed, only rollback allowed */
  323     ZIP_SOURCE_WRITE_REMOVED /* file was removed */
  324 };
  325 typedef enum zip_source_write_state zip_source_write_state_t;
  326 
  327 struct zip_source {
  328     zip_source_t *src;
  329     union {
  330     zip_source_callback f;
  331     zip_source_layered_callback l;
  332     } cb;
  333     void *ud;
  334     zip_error_t error;
  335     zip_int64_t supports;                 /* supported commands */
  336     unsigned int open_count;              /* number of times source was opened (directly or as lower layer) */
  337     zip_source_write_state_t write_state; /* whether source is open for writing */
  338     bool source_closed;                   /* set if source archive is closed */
  339     zip_t *source_archive;                /* zip archive we're reading from, NULL if not from archive */
  340     unsigned int refcount;
  341     bool eof;            /* EOF reached */
  342     bool had_read_error; /* a previous ZIP_SOURCE_READ reported an error */
  343 };
  344 
  345 #define ZIP_SOURCE_IS_OPEN_READING(src) ((src)->open_count > 0)
  346 #define ZIP_SOURCE_IS_OPEN_WRITING(src) ((src)->write_state == ZIP_SOURCE_WRITE_OPEN)
  347 #define ZIP_SOURCE_IS_LAYERED(src) ((src)->src != NULL)
  348 
  349 /* entry in zip archive directory */
  350 
  351 struct zip_entry {
  352     zip_dirent_t *orig;
  353     zip_dirent_t *changes;
  354     zip_source_t *source;
  355     bool deleted;
  356 };
  357 
  358 
  359 /* file or archive comment, or filename */
  360 
  361 struct zip_string {
  362     zip_uint8_t *raw;                /* raw string */
  363     zip_uint16_t length;             /* length of raw string */
  364     enum zip_encoding_type encoding; /* autorecognized encoding */
  365     zip_uint8_t *converted;          /* autoconverted string */
  366     zip_uint32_t converted_length;   /* length of converted */
  367 };
  368 
  369 
  370 /* bounds checked access to memory buffer */
  371 
  372 struct zip_buffer {
  373     bool ok;
  374     bool free_data;
  375 
  376     zip_uint8_t *data;
  377     zip_uint64_t size;
  378     zip_uint64_t offset;
  379 };
  380 
  381 /* which files to write in which order */
  382 
  383 struct zip_filelist {
  384     zip_uint64_t idx;
  385     /* TODO    const char *name; */
  386 };
  387 
  388 typedef struct zip_filelist zip_filelist_t;
  389 
  390 struct _zip_winzip_aes;
  391 typedef struct _zip_winzip_aes zip_winzip_aes_t;
  392 
  393 extern const char *const _zip_err_str[];
  394 extern const int _zip_nerr_str;
  395 extern const int _zip_err_type[];
  396 
  397 #define ZIP_MAX(a, b) ((a) > (b) ? (a) : (b))
  398 #define ZIP_MIN(a, b) ((a) < (b) ? (a) : (b))
  399 
  400 #define ZIP_ENTRY_CHANGED(e, f) ((e)->changes && ((e)->changes->changed & (f)))
  401 #define ZIP_ENTRY_DATA_CHANGED(x) ((x)->source != NULL)
  402 #define ZIP_ENTRY_HAS_CHANGES(e) (ZIP_ENTRY_DATA_CHANGED(e) || (e)->deleted || ZIP_ENTRY_CHANGED((e), ZIP_DIRENT_ALL))
  403 
  404 #define ZIP_IS_RDONLY(za) ((za)->ch_flags & ZIP_AFL_RDONLY)
  405 
  406 
  407 #ifdef HAVE_EXPLICIT_MEMSET
  408 #define _zip_crypto_clear(b, l) explicit_memset((b), 0, (l))
  409 #else
  410 #ifdef HAVE_EXPLICIT_BZERO
  411 #define _zip_crypto_clear(b, l) explicit_bzero((b), (l))
  412 #else
  413 #include <string.h>
  414 #define _zip_crypto_clear(b, l) memset((b), 0, (l))
  415 #endif
  416 #endif
  417 
  418 
  419 zip_int64_t _zip_add_entry(zip_t *);
  420 
  421 zip_uint8_t *_zip_buffer_data(zip_buffer_t *buffer);
  422 bool _zip_buffer_eof(zip_buffer_t *buffer);
  423 void _zip_buffer_free(zip_buffer_t *buffer);
  424 zip_uint8_t *_zip_buffer_get(zip_buffer_t *buffer, zip_uint64_t length);
  425 zip_uint16_t _zip_buffer_get_16(zip_buffer_t *buffer);
  426 zip_uint32_t _zip_buffer_get_32(zip_buffer_t *buffer);
  427 zip_uint64_t _zip_buffer_get_64(zip_buffer_t *buffer);
  428 zip_uint8_t _zip_buffer_get_8(zip_buffer_t *buffer);
  429 zip_uint64_t _zip_buffer_left(zip_buffer_t *buffer);
  430 zip_buffer_t *_zip_buffer_new(zip_uint8_t *data, zip_uint64_t size);
  431 zip_buffer_t *_zip_buffer_new_from_source(zip_source_t *src, zip_uint64_t size, zip_uint8_t *buf, zip_error_t *error);
  432 zip_uint64_t _zip_buffer_offset(zip_buffer_t *buffer);
  433 bool _zip_buffer_ok(zip_buffer_t *buffer);
  434 zip_uint8_t *_zip_buffer_peek(zip_buffer_t *buffer, zip_uint64_t length);
  435 int _zip_buffer_put(zip_buffer_t *buffer, const void *src, size_t length);
  436 int _zip_buffer_put_16(zip_buffer_t *buffer, zip_uint16_t i);
  437 int _zip_buffer_put_32(zip_buffer_t *buffer, zip_uint32_t i);
  438 int _zip_buffer_put_64(zip_buffer_t *buffer, zip_uint64_t i);
  439 int _zip_buffer_put_8(zip_buffer_t *buffer, zip_uint8_t i);
  440 zip_uint64_t _zip_buffer_read(zip_buffer_t *buffer, zip_uint8_t *data, zip_uint64_t length);
  441 int _zip_buffer_skip(zip_buffer_t *buffer, zip_uint64_t length);
  442 int _zip_buffer_set_offset(zip_buffer_t *buffer, zip_uint64_t offset);
  443 zip_uint64_t _zip_buffer_size(zip_buffer_t *buffer);
  444 
  445 int _zip_cdir_compute_crc(zip_t *, uLong *);
  446 void _zip_cdir_free(zip_cdir_t *);
  447 bool _zip_cdir_grow(zip_cdir_t *cd, zip_uint64_t additional_entries, zip_error_t *error);
  448 zip_cdir_t *_zip_cdir_new(zip_uint64_t, zip_error_t *);
  449 zip_int64_t _zip_cdir_write(zip_t *za, const zip_filelist_t *filelist, zip_uint64_t survivors);
  450 void _zip_deregister_source(zip_t *za, zip_source_t *src);
  451 
  452 zip_dirent_t *_zip_dirent_clone(const zip_dirent_t *);
  453 void _zip_dirent_free(zip_dirent_t *);
  454 void _zip_dirent_finalize(zip_dirent_t *);
  455 void _zip_dirent_init(zip_dirent_t *);
  456 bool _zip_dirent_needs_zip64(const zip_dirent_t *, zip_flags_t);
  457 zip_dirent_t *_zip_dirent_new(void);
  458 zip_int64_t _zip_dirent_read(zip_dirent_t *zde, zip_source_t *src, zip_buffer_t *buffer, bool local, zip_error_t *error);
  459 void _zip_dirent_set_version_needed(zip_dirent_t *de, bool force_zip64);
  460 zip_int32_t _zip_dirent_size(zip_source_t *src, zip_uint16_t, zip_error_t *);
  461 int _zip_dirent_write(zip_t *za, zip_dirent_t *dirent, zip_flags_t flags);
  462 
  463 zip_extra_field_t *_zip_ef_clone(const zip_extra_field_t *, zip_error_t *);
  464 zip_extra_field_t *_zip_ef_delete_by_id(zip_extra_field_t *, zip_uint16_t, zip_uint16_t, zip_flags_t);
  465 void _zip_ef_free(zip_extra_field_t *);
  466 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 *);
  467 zip_extra_field_t *_zip_ef_merge(zip_extra_field_t *, zip_extra_field_t *);
  468 zip_extra_field_t *_zip_ef_new(zip_uint16_t, zip_uint16_t, const zip_uint8_t *, zip_flags_t);
  469 bool _zip_ef_parse(const zip_uint8_t *, zip_uint16_t, zip_flags_t, zip_extra_field_t **, zip_error_t *);
  470 zip_extra_field_t *_zip_ef_remove_internal(zip_extra_field_t *);
  471 zip_uint16_t _zip_ef_size(const zip_extra_field_t *, zip_flags_t);
  472 int _zip_ef_write(zip_t *za, const zip_extra_field_t *ef, zip_flags_t flags);
  473 
  474 void _zip_entry_finalize(zip_entry_t *);
  475 void _zip_entry_init(zip_entry_t *);
  476 
  477 void _zip_error_clear(zip_error_t *);
  478 void _zip_error_get(const zip_error_t *, int *, int *);
  479 
  480 void _zip_error_copy(zip_error_t *dst, const zip_error_t *src);
  481 void _zip_error_set_from_source(zip_error_t *, zip_source_t *);
  482 
  483 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 *);
  484 
  485 int _zip_file_extra_field_prepare_for_change(zip_t *, zip_uint64_t);
  486 int _zip_file_fillbuf(void *, size_t, zip_file_t *);
  487 zip_uint64_t _zip_file_get_end(const zip_t *za, zip_uint64_t index, zip_error_t *error);
  488 zip_uint64_t _zip_file_get_offset(const zip_t *, zip_uint64_t, zip_error_t *);
  489 
  490 int _zip_filerange_crc(zip_source_t *src, zip_uint64_t offset, zip_uint64_t length, uLong *crcp, zip_error_t *error);
  491 
  492 zip_dirent_t *_zip_get_dirent(zip_t *, zip_uint64_t, zip_flags_t, zip_error_t *);
  493 
  494 enum zip_encoding_type _zip_guess_encoding(zip_string_t *, enum zip_encoding_type);
  495 zip_uint8_t *_zip_cp437_to_utf8(const zip_uint8_t *const, zip_uint32_t, zip_uint32_t *, zip_error_t *);
  496 
  497 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);
  498 bool _zip_hash_delete(zip_hash_t *hash, const zip_uint8_t *key, zip_error_t *error);
  499 void _zip_hash_free(zip_hash_t *hash);
  500 zip_int64_t _zip_hash_lookup(zip_hash_t *hash, const zip_uint8_t *name, zip_flags_t flags, zip_error_t *error);
  501 zip_hash_t *_zip_hash_new(zip_error_t *error);
  502 bool _zip_hash_reserve_capacity(zip_hash_t *hash, zip_uint64_t capacity, zip_error_t *error);
  503 bool _zip_hash_revert(zip_hash_t *hash, zip_error_t *error);
  504 
  505 zip_t *_zip_open(zip_source_t *, unsigned int, zip_error_t *);
  506 
  507 void _zip_progress_end(zip_progress_t *progress);
  508 void _zip_progress_free(zip_progress_t *progress);
  509 zip_progress_t *_zip_progress_new(zip_t *za, double precision, zip_progress_callback callback, void (*ud_free)(void *), void *ud);
  510 void _zip_progress_start(zip_progress_t *progress);
  511 void _zip_progress_subrange(zip_progress_t *progress, double start, double end);
  512 void _zip_progress_update(zip_progress_t *progress, double value);
  513 
  514 ZIP_EXTERN bool zip_random(zip_uint8_t *buffer, zip_uint16_t length);
  515 
  516 int _zip_read(zip_source_t *src, zip_uint8_t *data, zip_uint64_t length, zip_error_t *error);
  517 int _zip_read_at_offset(zip_source_t *src, zip_uint64_t offset, unsigned char *b, size_t length, zip_error_t *error);
  518 zip_uint8_t *_zip_read_data(zip_buffer_t *buffer, zip_source_t *src, size_t length, bool nulp, zip_error_t *error);
  519 int _zip_read_local_ef(zip_t *, zip_uint64_t);
  520 zip_string_t *_zip_read_string(zip_buffer_t *buffer, zip_source_t *src, zip_uint16_t lenght, bool nulp, zip_error_t *error);
  521 int _zip_register_source(zip_t *za, zip_source_t *src);
  522 
  523 void _zip_set_open_error(int *zep, const zip_error_t *err, int ze);
  524 
  525 zip_int64_t _zip_source_call(zip_source_t *src, void *data, zip_uint64_t length, zip_source_cmd_t command);
  526 bool _zip_source_eof(zip_source_t *);
  527 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);
  528 zip_int8_t zip_source_get_compression_flags(zip_source_t *);
  529 bool _zip_source_had_error(zip_source_t *);
  530 void _zip_source_invalidate(zip_source_t *src);
  531 zip_source_t *_zip_source_new(zip_error_t *error);
  532 int _zip_source_set_source_archive(zip_source_t *, zip_t *);
  533 zip_source_t *_zip_source_window_new(zip_source_t *src, zip_uint64_t start, zip_uint64_t length, zip_stat_t *st, zip_int8_t compression_flags, zip_t *source_archive, zip_uint64_t source_index, zip_error_t *error);
  534 zip_source_t *_zip_source_zip_new(zip_t *, zip_t *, zip_uint64_t, zip_flags_t, zip_uint64_t, zip_uint64_t, const char *);
  535 
  536 int _zip_stat_merge(zip_stat_t *dst, const zip_stat_t *src, zip_error_t *error);
  537 int _zip_string_equal(const zip_string_t *, const zip_string_t *);
  538 void _zip_string_free(zip_string_t *);
  539 zip_uint32_t _zip_string_crc32(const zip_string_t *);
  540 const zip_uint8_t *_zip_string_get(zip_string_t *, zip_uint32_t *, zip_flags_t, zip_error_t *);
  541 zip_uint16_t _zip_string_length(const zip_string_t *);
  542 zip_string_t *_zip_string_new(const zip_uint8_t *, zip_uint16_t, zip_flags_t, zip_error_t *);
  543 int _zip_string_write(zip_t *za, const zip_string_t *string);
  544 bool _zip_winzip_aes_decrypt(zip_winzip_aes_t *ctx, zip_uint8_t *data, zip_uint64_t length);
  545 bool _zip_winzip_aes_encrypt(zip_winzip_aes_t *ctx, zip_uint8_t *data, zip_uint64_t length);
  546 bool _zip_winzip_aes_finish(zip_winzip_aes_t *ctx, zip_uint8_t *hmac);
  547 void _zip_winzip_aes_free(zip_winzip_aes_t *ctx);
  548 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);
  549 
  550 int _zip_changed(const zip_t *, zip_uint64_t *);
  551 const char *_zip_get_name(zip_t *, zip_uint64_t, zip_flags_t, zip_error_t *);
  552 int _zip_local_header_read(zip_t *, int);
  553 void *_zip_memdup(const void *, size_t, zip_error_t *);
  554 zip_int64_t _zip_name_locate(zip_t *, const char *, zip_flags_t, zip_error_t *);
  555 zip_t *_zip_new(zip_error_t *);
  556 
  557 zip_int64_t _zip_file_replace(zip_t *, zip_uint64_t, const char *, zip_source_t *, zip_flags_t);
  558 int _zip_set_name(zip_t *, zip_uint64_t, const char *, zip_flags_t);
  559 void _zip_u2d_time(time_t, zip_uint16_t *, zip_uint16_t *);
  560 int _zip_unchange(zip_t *, zip_uint64_t, int);
  561 void _zip_unchange_data(zip_entry_t *);
  562 int _zip_write(zip_t *za, const void *data, zip_uint64_t length);
  563 
  564 #endif /* zipint.h */