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

+#include <sys/types.h>

+_zip_cdir_free(zip_cdir_t *cd) {

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

+ _zip_entry_finalize(cd->entry + i);

+_zip_cdir_new(zip_uint64_t nentry, zip_error_t *error) {

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

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

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

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

+ _zip_entry_init(cd->entry + i);

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

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

+ return -1;

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

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

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

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

+ return -1;

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

+ return -1;

+ _zip_buffer_put_64(buffer, EOCD64LEN - 12);

+ _zip_buffer_put_64(buffer, offset + size);

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

+ _zip_buffer_free(buffer);

+ return -1;

+ _zip_buffer_free(buffer);

+_zip_dirent_clone(const zip_dirent_t *sde) {

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

+_zip_dirent_finalize(zip_dirent_t *zde) {

+_zip_dirent_free(zip_dirent_t *zde) {

+_zip_dirent_init(zip_dirent_t *de) {

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

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

+ de->compression_level = 0;

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

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

+_zip_dirent_new(void) {

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

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

+ if (_zip_buffer_left(buffer) < size) {

+ zip_error_set(error, ZIP_ER_NOZIP, 0);

+ return -1;

+ }

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

+ return -1;

+ }

+ if (!from_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ }

+ else {

+ zip_error_set(error, ZIP_ER_INTERNAL, 0);

+ if (!from_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ return -1;

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

+ if (_zip_buffer_left(buffer) < variable_size) {

+ zip_error_set(error, ZIP_ER_INCONS, 0);

+ return -1;

+ }

+ _zip_buffer_free(buffer);

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

+ return -1;

+ }

+ if (!zde->filename) {

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

+ zip_error_set(error, ZIP_ER_INCONS, 0);

+ }

+ if (!from_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ }

+ if (!from_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ if (ef == NULL) {

+ if (!from_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ }

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

+ if (!from_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ if (!zde->comment) {

+ if (!from_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ }

+ if (!from_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ zip_buffer_t *ef_buffer;

+ if (ef == NULL) {

+ if (!from_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ }

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

+ zip_error_set(error, ZIP_ER_MEMORY, 0);

+ if (!from_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ return -1;

+ }

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

+ if (!_zip_buffer_eof(ef_buffer)) {

+ zip_error_set(error, ZIP_ER_INCONS, 0);

+ _zip_buffer_free(ef_buffer);

+ if (!from_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ return -1;

+ }

+ _zip_buffer_free(ef_buffer);

+ zip_error_set(error, ZIP_ER_INTERNAL, 0);

+ if (!from_buffer) {

+ _zip_buffer_free(buffer);

+ }

+ return -1;

+ _zip_buffer_free(buffer);

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

+ return str;

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

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

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

+ return false;

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

+ _zip_error_set_from_source(error, src);

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

+ zip_error_set(error, ZIP_ER_INTERNAL, 0);

+ return -1;

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

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

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

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

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

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

+ zip_uint8_t ef_zip64[EFZIP64SIZE];

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

+ if (ef_buffer == NULL) {

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

+ return -1;

+ }

+

+ if (flags & ZIP_FL_LOCAL) {

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

+ _zip_buffer_put_64(ef_buffer, de->uncomp_size);

+ _zip_buffer_put_64(ef_buffer, de->comp_size);

+ }

+ }

+ else {

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

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

+ _zip_buffer_put_64(ef_buffer, de->uncomp_size);

+ }

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

+ _zip_buffer_put_64(ef_buffer, de->comp_size);

+ }

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

+ _zip_buffer_put_64(ef_buffer, de->offset);

+ }

+ }

+ }

+

+ if (!_zip_buffer_ok(ef_buffer)) {

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

+ _zip_buffer_free(ef_buffer);

+ return -1;

+ }

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

+ _zip_buffer_free(ef_buffer);

+ ef64->next = ef;

+ ef = ef64;

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

+

+ if (ef_buffer == NULL) {

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

+ return -1;

+ }

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

+ if (!_zip_buffer_ok(ef_buffer)) {

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

+ _zip_buffer_free(ef_buffer);

+ return -1;

+ }

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

+ _zip_buffer_free(ef_buffer);

+ ef_winzip->next = ef;

+ ef = ef_winzip;

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

+ _zip_ef_free(ef);

+ return -1;

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

+ _zip_buffer_put_16(buffer, de->bitflags);

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

+ if (de->comp_size < ZIP_UINT32_MAX) {

+ }

+ else {

+ }

+ if (de->uncomp_size < ZIP_UINT32_MAX) {

+ }

+ else {

+ }

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

+ _zip_buffer_free(buffer);

+ _zip_ef_free(ef);

+ return -1;

+ _zip_buffer_free(buffer);

+ _zip_ef_free(ef);

+ return -1;

+ _zip_ef_free(ef);

+ _zip_ef_free(ef);

+_zip_d2u_time(zip_uint16_t dtime, zip_uint16_t ddate) {

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

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

+ tm.tm_mday = ddate & 31;

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

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

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

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

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

+ if (len + 5 > ZIP_UINT16_MAX) {

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

+ return NULL;

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

+ zip_error_set(error, ZIP_ER_INTERNAL, 0);

+ _zip_buffer_free(buffer);

+ return NULL;

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

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

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

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

+

+

+void

+_zip_dirent_set_version_needed(zip_dirent_t *de, bool force_zip64) {

+ zip_uint16_t length;

+

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

+ de->version_needed = 63;

+ return;

+ }

+

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

+ de->version_needed = 46;

+ return;

+ }

+

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

+ de->version_needed = 45;

+ return;

+ }

+

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

+ de->version_needed = 20;

+ return;

+ }

+

+ /* directory */

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

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

+ de->version_needed = 20;

+ return;

+ }

+ }

+

+ de->version_needed = 10;

+}