IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR

OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN

IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

1.1.3 [2016-05-28]

==================

#if !defined(HAVE__SETMODE) && defined(HAVE_SETMODE)

#define _setmode setmode

#endif

#endif

#ifndef HAVE_FSEEKO

#define HAVE__SNPRINTF

#define HAVE__STRDUP

#define HAVE__STRICMP

#define HAVE_FILENO

/* #undef HAVE_FSEEKO */

/* #undef HAVE_FTELLO */

/* #undef HAVE_STRCASECMP */

#define HAVE_STRDUP

#define HAVE_STRICMP

/* #undef HAVE_STRUCT_TM_TM_ZONE */

/* #undef HAVE_STDBOOL_H */

/* #undef HAVE_STRINGS_H */

/* #undef HAVE_NDIR_H */

/* #undef HAVE_SYS_DIR_H */

/* #undef HAVE_SYS_NDIR_H */

/* END DEFINES */

#define PACKAGE "libzip"

#ifndef HAVE_SSIZE_T_LIBZIP

# if SIZE_T_LIBZIP == INT_LIBZIP

/*

zip.h -- exported declarations.

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

3. The names of the authors may not be used to endorse or promote

products derived from this software without specific prior

written permission.

THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS

OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

#define ZIP_ER_REMOVE 22 /* S Can't remove file */

#define ZIP_ER_DELETED 23 /* N Entry has been deleted */

#define ZIP_ER_ENCRNOTSUPP 24 /* N Encryption method not supported */

#define ZIP_ER_NOPASSWD 26 /* N No password provided */

#define ZIP_ER_WRONGPASSWD 27 /* N Wrong password provided */

#define ZIP_ER_OPNOTSUPP 28 /* N Operation not supported */

/* 15-17 - Reserved by PKWARE */

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

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

#define ZIP_CM_WAVPACK 97 /* WavPack compressed data */

#define ZIP_CM_PPMD 98 /* PPMd version I, Rev 1 */

#define ZIP_EM_RC2_OLD 0x6602 /* strong encryption: RC2, version < 5.2 */

#define ZIP_EM_3DES_168 0x6603

#define ZIP_EM_3DES_112 0x6609

#define ZIP_EM_RC2 0x6702 /* strong encryption: RC2, version >= 5.2 */

#define ZIP_EM_RC4 0x6801

#endif

#define ZIP_EM_UNKNOWN 0xffff /* unknown algorithm */

#define ZIP_OPSYS_DOS 0x00u

typedef struct zip_source zip_source_t;

typedef struct zip_stat zip_stat_t;

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

#ifndef ZIP_DISABLE_DEPRECATED

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

#endif

ZIP_EXTERN int zip_close(zip_t *);

ZIP_EXTERN int zip_delete(zip_t *, zip_uint64_t);

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

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

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

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

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

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

ZIP_EXTERN const char *zip_file_strerror(zip_file_t *);

ZIP_EXTERN zip_file_t *zip_fopen_index(zip_t *, zip_uint64_t, zip_flags_t);

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

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

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

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

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

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

ZIP_EXTERN zip_t *zip_open(const char *, int, int *);

ZIP_EXTERN zip_t *zip_open_from_source(zip_source_t *, int, zip_error_t *);

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

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

ZIP_EXTERN int zip_set_default_password(zip_t *, const char *);

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

ZIP_EXTERN int zip_source_close(zip_source_t *);

ZIP_EXTERN int zip_source_commit_write(zip_source_t *);

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

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

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

/*

zip_add_entry.c -- create and init struct zip_entry

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

/*

zip_buffer.c -- bounds checked access to memory buffer

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions

are met:

3. The names of the authors may not be used to endorse or promote

products derived from this software without specific prior

written permission.

THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS

OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

if (buffer == NULL) {

return;

}

if (buffer->free_data) {

free(buffer->data);

}

free(buffer);

}

_zip_buffer_get(zip_buffer_t *buffer, zip_uint64_t length)

{

zip_uint8_t *data;

}

return data;

}

_zip_buffer_get_16(zip_buffer_t *buffer)

{

zip_uint8_t *data = _zip_buffer_get(buffer, 2);

if (data == NULL) {

return 0;

}

return (zip_uint16_t)(data[0] + (data[1] << 8));

}

_zip_buffer_get_32(zip_buffer_t *buffer)

{

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

}

_zip_buffer_get_64(zip_buffer_t *buffer)

{

zip_uint8_t *data = _zip_buffer_get(buffer, 8);

if (data == NULL) {

return 0;

}

_zip_buffer_get_8(zip_buffer_t *buffer)

{

zip_uint8_t *data = _zip_buffer_get(buffer, 1);

if (data == NULL) {

return 0;

}

return data[0];

}

}

zip_buffer_t *

_zip_buffer_new(zip_uint8_t *data, zip_uint64_t size)

{

bool free_data = (data == NULL);

zip_buffer_t *buffer;

if (data == NULL) {

if ((data = (zip_uint8_t *)malloc(size)) == NULL) {

return NULL;

}

return NULL;

}

buffer->ok = true;

buffer->data = data;

buffer->size = size;

buffer->offset = 0;

buffer->free_data = free_data;

return buffer;

}

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

{

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;

}

}

int

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

{

zip_uint8_t *dst = _zip_buffer_get(buffer, length);

if (dst == NULL) {

return -1;

}

memcpy(dst, src, length);

return 0;

}

_zip_buffer_put_16(zip_buffer_t *buffer, zip_uint16_t i)

{

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;

}

_zip_buffer_put_32(zip_buffer_t *buffer, zip_uint32_t i)

{

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;

}

_zip_buffer_put_64(zip_buffer_t *buffer, zip_uint64_t i)

{

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

}

_zip_buffer_put_8(zip_buffer_t *buffer, zip_uint8_t i)

{

zip_uint8_t *data = _zip_buffer_get(buffer, 1);

if (data == NULL) {

return -1;

}

data[0] = i;

return 0;

}

buffer->ok = false;

return -1;

}

buffer->ok = true;

buffer->offset = offset;

return 0;

}

int

_zip_buffer_skip(zip_buffer_t *buffer, zip_uint64_t length) {

zip_uint64_t offset = buffer->offset + length;

if (offset < buffer->offset) {

buffer->ok = false;

return -1;

/*

zip_close.c -- close zip archive and update changes

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

zip_entry_t *entry;

zip_dirent_t *de;

i = filelist[j].idx;

entry = za->entry+i;

/* create new local directory entry */

if (entry->changes == NULL) {

return -1;

}

zip_discard(za);

return 0;

{

zip_int64_t offstart, offdata, offend;

struct zip_stat st;

int ret;

int is_zip64;

zip_flags_t flags;

if (zip_source_stat(src, &st) < 0) {

_zip_error_set_from_source(&za->error, src);

st.valid &= ~ZIP_STAT_COMP_SIZE;

}

flags = ZIP_EF_LOCAL;

if ((is_zip64=_zip_dirent_write(za, de, flags)) < 0)

return -1;

zip_compression_implementation comp_impl;

}

}

return -1;

}

}

}

}

}

if ((offdata = zip_source_tell_write(za->src)) < 0) {

return -1;

}

ret = -1;

return -1;

if ((offend = zip_source_tell_write(za->src)) < 0) {

return -1;

/*

zip_delete.c -- delete file from zip archive

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

static time_t _zip_d2u_time(zip_uint16_t, zip_uint16_t);

static zip_string_t *_zip_dirent_process_ef_utf_8(const zip_dirent_t *de, zip_uint16_t id, zip_string_t *str);

static zip_extra_field_t *_zip_ef_utf8(zip_uint16_t, zip_string_t *, zip_error_t *);

void

_zip_cdir_new(zip_uint64_t nentry, zip_error_t *error)

{

zip_cdir_t *cd;

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

zip_error_set(error, ZIP_ER_MEMORY, 0);

return NULL;

}

return NULL;

}

_zip_entry_init(cd->entry+i);

}

_zip_string_free(zde->comment);

zde->comment = NULL;

}

}

de->local_extra_fields_read = 0;

de->cloned = 0;

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

de->version_needed = 20; /* 2.0 */

de->bitflags = 0;

de->int_attrib = 0;

de->ext_attrib = ZIP_EXT_ATTRIB_DEFAULT;

de->offset = 0;

}

return -1;

}

zde->filename = NULL;

zde->extra_fields = NULL;

zde->comment = NULL;

return -1;

}

zde->extra_fields = _zip_ef_remove_internal(zde->extra_fields);

return (zip_int64_t)(size + variable_size);

}

zip_int32_t

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

{

zip_uint32_t ef_total_size;

bool is_zip64;

bool is_really_zip64;

zip_uint8_t buf[CDENTRYSIZE];

zip_buffer_t *buffer;

}

}

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;

if (is_zip64) {

zip_uint8_t ef_zip64[EFZIP64SIZE];

ef = ef64;

}

if ((buffer = _zip_buffer_new(buf, sizeof(buf))) == NULL) {

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

_zip_ef_free(ef);

}

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

_zip_buffer_put_16(buffer, de->bitflags&0xfff9); /* clear compression method specific flags */

_zip_u2d_time(de->last_mod, &dostime, &dosdate);

_zip_buffer_put_16(buffer, dostime);

_zip_buffer_put_16(buffer, dosdate);

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

/*

zip_discard.c -- discard and free struct zip

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

"Can't remove file",

"Entry has been deleted",

"Encryption method not supported",

"No password provided",

"Wrong password provided",

"Operation not supported",

S,

N,

N,

N,

N,

N,

/*

zip_error.c -- zip_error_t helper functions

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

/*

zip_error_sterror.c -- get string representation of struct zip_error

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

/*

zip_error_to_str.c -- get string representation of zip error code

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

/*

zip_extra_field.c -- manipulate extra fields

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

/*

zip_fdopen.c -- open read-only archive from file descriptor

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

/*

zip_file_get_offset.c -- get offset of file data in archive.

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

/*

zip_filerange_crc.c -- compute CRC32 for a range of a file

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

/*

zip_fopen_index.c -- open file in zip archive for reading by index

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

/*

zip_fopen_index_encrypted.c -- open file for reading by index w/ password

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

/*

zip_get_compression_implementation.c -- get compression implementation

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

zip_compression_implementation

{

if (cm == ZIP_CM_DEFLATE || ZIP_CM_IS_DEFAULT(cm))

return zip_source_deflate;

/*

zip_get_encryption_implementation.c -- get encryption implementation

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

zip_encryption_implementation

{

return zip_source_pkware;

}

/*

zip_io_util.c -- I/O helper functions

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

/*

zip_name_locate.c -- get index by name

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

/*

zip_new.c -- create and init struct zip

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

za->entry = NULL;

za->nopen_source = za->nopen_source_alloc = 0;

za->open_source = NULL;

return za;

}

/*

zip_open.c -- open zip archive by name

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

3. The names of the authors may not be used to endorse or promote

products derived from this software without specific prior

written permission.

THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS

OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

{

static zip_int64_t needed_support_read = -1;

static zip_int64_t needed_support_write = -1;

unsigned int flags;

zip_int64_t supported;

exists_t exists;

if (_flags < 0 || src == NULL) {

zip_error_set(error, ZIP_ER_INVAL, 0);

return NULL;

}

flags = (unsigned int)_flags;

supported = zip_source_supports(src);

if (needed_support_read == -1) {

needed_support_read = zip_source_make_command_bitmap(ZIP_SOURCE_OPEN, ZIP_SOURCE_READ, ZIP_SOURCE_CLOSE, ZIP_SOURCE_SEEK, ZIP_SOURCE_TELL, ZIP_SOURCE_STAT, -1);

}

exists = _zip_file_exists(src, error);

case EXISTS_ERROR:

return NULL;

}

}

{

}

zip_t *

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

{

if ((za=_zip_allocate_new(src, flags, error)) == NULL) {

return NULL;

}

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

}

}

}

za->ch_flags = za->flags;

return za;

/* _zip_readcdir:

tries to find a valid end-of-central-directory at the beginning of

buf, and then the corresponding central directory entries.

entries, or NULL if unsuccessful. */

static zip_cdir_t *

zip_error_set(error, ZIP_ER_NOZIP, 0);

return NULL;

}

/* check for end-of-central-dir magic */

if (memcmp(_zip_buffer_get(buffer, 4), EOCD_MAGIC, 4) != 0) {

zip_error_set(error, ZIP_ER_NOZIP, 0);

if (comment_len || (za->open_flags & ZIP_CHECKCONS)) {

zip_uint64_t tail_len;

_zip_buffer_set_offset(buffer, eocd_offset + EOCDLEN);

tail_len = _zip_buffer_left(buffer);

if (tail_len < comment_len || ((za->open_flags & ZIP_CHECKCONS) && tail_len != comment_len)) {

zip_error_set(error, ZIP_ER_INCONS, 0);

_zip_cdir_free(cd);

zip_uint8_t *data;

/* if buffer already read in, use it */

_zip_buffer_set_offset(buffer, cd->offset - buf_offset);

if ((data = _zip_buffer_get(buffer, cd->size)) == NULL) {

zip_error_set(error, ZIP_ER_INCONS, 0);

_zip_cdir_free(cd);

}

else {

cd_buffer = NULL;

if (zip_source_seek(za->src, (zip_int64_t)cd->offset, SEEK_SET) < 0) {

_zip_error_set_from_source(error, za->src);

_zip_cdir_free(cd);

left = (zip_uint64_t)cd->size;

i=0;

zip_int64_t entry_size;

if ((cd->entry[i].orig=_zip_dirent_new()) == NULL || (entry_size = _zip_dirent_read(cd->entry[i].orig, za->src, cd_buffer, false, error)) < 0) {

_zip_cdir_free(cd);

_zip_buffer_free(cd_buffer);

return NULL;

i++;

left -= (zip_uint64_t)entry_size;

}

zip_error_set(error, ZIP_ER_INCONS, 0);

_zip_buffer_free(cd_buffer);

_zip_cdir_free(cd);

return NULL;

}

if (za->open_flags & ZIP_CHECKCONS) {

bool ok;

if (cd_buffer) {

ok = _zip_buffer_eof(cd_buffer);

}

else {

zip_int64_t offset = zip_source_tell(za->src);

if (offset < 0) {

_zip_error_set_from_source(error, za->src);

_zip_buffer_free(cd_buffer);

}

ok = ((zip_uint64_t)offset == cd->offset + cd->size);

}

if (!ok) {

zip_error_set(error, ZIP_ER_INCONS, 0);

_zip_buffer_free(cd_buffer);

zip_error_set(error, ZIP_ER_NOZIP, 0);

return -1;

}

j = cd->entry[i].orig->offset + cd->entry[i].orig->comp_size

+ _zip_string_length(cd->entry[i].orig->filename) + LENTRYSIZE;

if (j > max)

zip_error_set(error, ZIP_ER_NOZIP, 0);

return -1;

}

if (zip_source_seek(za->src, (zip_int64_t)cd->entry[i].orig->offset, SEEK_SET) < 0) {

_zip_error_set_from_source(error, za->src);

return -1;

}

if (_zip_dirent_read(&temp, za->src, NULL, true, error) == -1) {

_zip_dirent_finalize(&temp);

return -1;

}

if (_zip_headercomp(cd->entry[i].orig, &temp) != 0) {

zip_error_set(error, ZIP_ER_INCONS, 0);

_zip_dirent_finalize(&temp);

return -1;

}

cd->entry[i].orig->extra_fields = _zip_ef_merge(cd->entry[i].orig->extra_fields, temp.extra_fields);

cd->entry[i].orig->local_extra_fields_read = 1;

temp.extra_fields = NULL;

_zip_dirent_finalize(&temp);

}

static int

_zip_headercomp(const zip_dirent_t *central, const zip_dirent_t *local)

{

#if 0

/* some zip-files have different values in local

and global headers for the bitflags */

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

return NULL;

}

if ((buffer = _zip_buffer_new_from_source(za->src, buflen, NULL, &za->error)) == NULL) {

return NULL;

}

if (best <= 0) {

best = _zip_checkcons(za, cdir, &error);

}

a = _zip_checkcons(za, cdirnew, &error);

if (best < a) {

_zip_cdir_free(cdir);

}

cdirnew = NULL;

}

match++;

_zip_buffer_set_offset(buffer, (zip_uint64_t)(match - _zip_buffer_data(buffer)));

}

_zip_buffer_free(buffer);

if (best < 0) {

_zip_error_copy(&za->error, &error);

_zip_cdir_free(cdir);

_zip_memmem(const unsigned char *big, size_t biglen, const unsigned char *little, size_t littlelen)

{

const unsigned char *p;

if ((biglen < littlelen) || (littlelen == 0))

return NULL;

p = big-1;

zip_error_set(error, ZIP_ER_INCONS, 0);

return NULL;

}

eocd_offset = _zip_buffer_offset(buffer);

_zip_buffer_get(buffer, 4); /* magic already verified */

zip_error_set(error, ZIP_ER_SEEK, EFBIG);

return NULL;

}

if (offset+size > buf_offset + eocd_offset) {

/* cdir spans past EOCD record */

zip_error_set(error, ZIP_ER_INCONS, 0);

if ((cd=_zip_cdir_new(nentry, error)) == NULL)

return NULL;

cd->size = size;

cd->offset = offset;

return cd;

}

zip_uint32_t num_disks, num_disks64, eocd_disk, eocd_disk64;

eocdloc_offset = _zip_buffer_offset(buffer);

_zip_buffer_get(buffer, 4); /* magic already verified */

num_disks = _zip_buffer_get_16(buffer);

eocd_disk = _zip_buffer_get_16(buffer);

eocd_offset = _zip_buffer_get_64(buffer);

if (eocd_offset > ZIP_INT64_MAX || eocd_offset + EOCD64LEN < eocd_offset) {

zip_error_set(error, ZIP_ER_SEEK, EFBIG);

return NULL;

}

return NULL;

}

size = _zip_buffer_get_64(buffer);

if ((flags & ZIP_CHECKCONS) && size + eocd_offset + 12 != buf_offset + eocdloc_offset) {

size = _zip_buffer_get_64(buffer);

offset = _zip_buffer_get_64(buffer);

if (!_zip_buffer_ok(buffer)) {

zip_error_set(error, ZIP_ER_INTERNAL, 0);

if (free_buffer) {

if ((cd=_zip_cdir_new(nentry, error)) == NULL)

return NULL;

cd->size = size;

cd->offset = offset;

/*

zip_set_default_password.c -- set default password for decryption

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

/*

zip_set_name.c -- rename helper function

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

/*

zip_source_error.c -- get last error from zip_source

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

{

return &src->error;

}

/*

zip_source_file.c -- create data source from file

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

3. The names of the authors may not be used to endorse or promote

products derived from this software without specific prior

written permission.

THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS

OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

{

if (za == NULL)

return NULL;

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

}

/*

zip_source_filep.c -- create data source from FILE *

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

3. The names of the authors may not be used to endorse or promote

products derived from this software without specific prior

written permission.

THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS

OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

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

FILE *f; /* file to read from */

struct zip_stat st; /* stat information passed in */

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

/* writing */

char *tmpname;

FILE *fout;

{

if (za == NULL)

return NULL;

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

}

{

struct read_file *ctx;

zip_source_t *zs;

if (file == NULL && fname == NULL) {

zip_error_set(error, ZIP_ER_INVAL, 0);

return NULL;

}

if ((ctx=(struct read_file *)malloc(sizeof(struct read_file))) == NULL) {

zip_error_set(error, ZIP_ER_MEMORY, 0);

return NULL;

}

ctx->f = file;

ctx->start = start;

if (st) {

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

ctx->st.name = NULL;

else {

zip_stat_init(&ctx->st);

}

ctx->tmpname = NULL;

ctx->fout = NULL;

zip_error_init(&ctx->error);

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

if (ctx->fname) {

struct stat sb;

}

}

else if (fseeko(ctx->f, 0, SEEK_CUR) == 0) {

int tfd;

mode_t mask;

FILE *tfp;

if ((temp=(char *)malloc(strlen(ctx->fname)+8)) == NULL) {

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

return -1;

free(temp);

return -1;

}

#ifdef _WIN32

/*

According to Pierre Joye, Windows in some environments per

*/

_setmode(_fileno(tfp), _O_BINARY );

#endif

ctx->fout = tfp;

ctx->tmpname = temp;

return 0;

}

return -1;

}

return create_temp_output(ctx);

case ZIP_SOURCE_COMMIT_WRITE: {

mode_t mask;

ctx->tmpname = NULL;

return 0;

}

case ZIP_SOURCE_CLOSE:

if (ctx->fname) {

fclose(ctx->f);

ctx->f = NULL;

}

return 0;

case ZIP_SOURCE_ERROR:

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

case ZIP_SOURCE_FREE:

free(ctx->fname);

free(ctx->tmpname);

fclose(ctx->f);

free(ctx);

return 0;

case ZIP_SOURCE_OPEN:

if (ctx->fname) {

if ((ctx->f=fopen(ctx->fname, "rb")) == NULL) {

return -1;

}

}

if (ctx->start > 0) {

if (_zip_fseek_u(ctx->f, ctx->start, SEEK_SET, &ctx->error) < 0) {

return -1;

}

}

return 0;

case ZIP_SOURCE_READ:

if (ctx->end > 0) {

if (n > len) {

n = len;

}

else {

n = len;

}

if (n > SIZE_MAX)

n = SIZE_MAX;

ctx->current += i;

return (zip_int64_t)i;

case ZIP_SOURCE_REMOVE:

if (remove(ctx->fname) < 0) {

zip_error_set(&ctx->error, ZIP_ER_REMOVE, errno);

return -1;

}

return 0;

case ZIP_SOURCE_ROLLBACK_WRITE:

if (ctx->fout) {

fclose(ctx->fout);

free(ctx->tmpname);

ctx->tmpname = NULL;

return 0;

case ZIP_SOURCE_SEEK: {

zip_int64_t new_current;

int need_seek;

if (args == NULL)

return -1;

need_seek = 1;

switch (args->whence) {

case SEEK_SET:

new_current = args->offset;

break;

case SEEK_END:

if (ctx->end == 0) {

if (_zip_fseek(ctx->f, args->offset, SEEK_END, &ctx->error) < 0) {

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

return -1;

}

need_seek = 0;

}

else {

new_current = (zip_int64_t)ctx->end + args->offset;

}

break;

case SEEK_CUR:

new_current = (zip_int64_t)ctx->current + args->offset;

break;

return -1;

}

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

return -1;

}

ctx->current = (zip_uint64_t)new_current;

if (need_seek) {

return -1;

}

}

return 0;

}

case ZIP_SOURCE_SEEK_WRITE: {

zip_source_args_seek_t *args;

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

if (args == NULL) {

return -1;

}

if (_zip_fseek(ctx->fout, args->offset, args->whence, &ctx->error) < 0) {

return -1;

}

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

return -1;

}

return sizeof(ctx->st);

}

case ZIP_SOURCE_SUPPORTS:

return ctx->supports;

case ZIP_SOURCE_TELL:

return (zip_int64_t)ctx->current;

case ZIP_SOURCE_TELL_WRITE:

{

off_t ret = ftello(ctx->fout);

if (ret < 0) {

zip_error_set(&ctx->error, ZIP_ER_TELL, errno);

return -1;

}

return ret;

}

case ZIP_SOURCE_WRITE:

{

size_t ret;

clearerr(ctx->fout);

ret = fwrite(data, 1, len, ctx->fout);

if (ret != len || ferror(ctx->fout)) {

zip_error_set(&ctx->error, ZIP_ER_WRITE, errno);

return -1;

}

return (zip_int64_t)ret;

}

/*

zip_source_function.c -- create zip data source from callback function

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

src->source_archive = NULL;

src->refcount = 1;

zip_error_init(&src->error);

return src;

}

/*

zip_source_open.c -- open zip_source (prepare for reading)

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

}

}

src->open_count++;

return 0;

/*

zip_source_pkware.c -- Traditional PKWARE de/encryption routines

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

/*

zip_source_read.c -- read data from zip_source

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

zip_int64_t

zip_source_read(zip_source_t *src, void *data, zip_uint64_t len)

{

if (src->source_closed) {

return -1;

}

return -1;

}

}

/*

zip_source_stat.c -- get meta information from zip_source

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

/*

zip_source_supports.c -- check for supported functions

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

}

else {

h = ctx->ops->op_open(ctx);

}

}

/*

zip_source_zip_new.c -- prepare data structures for zip_fopen/zip_source_zip

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

enc_impl = NULL;

if (((flags & ZIP_FL_ENCRYPTED) == 0) && (st.encryption_method != ZIP_EM_NONE)) {

if (password == NULL) {

zip_error_set(&za->error, ZIP_ER_NOPASSWD, 0);

return NULL;

}

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

return NULL;

}

comp_impl = NULL;

if ((flags & ZIP_FL_COMPRESSED) == 0) {

if (st.comp_method != ZIP_CM_STORE) {

zip_error_set(&za->error, ZIP_ER_COMPNOTSUPP, 0);

return NULL;

}

/*

zip_stat_index.c -- get information about file by index

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

st->mtime = de->last_mod;

st->comp_size = de->comp_size;

st->comp_method = (zip_uint16_t)de->comp_method;

|ZIP_STAT_COMP_SIZE|ZIP_STAT_COMP_METHOD|ZIP_STAT_ENCRYPTION_METHOD;

}

/*

zip_unchange.c -- undo changes to file in zip archive

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

/*

zip_unchange.c -- undo changes to all files in zip archive

This file is part of libzip, a library to manipulate ZIP archives.

The authors can be contacted at <libzip@nih.at>

3. The names of the authors may not be used to endorse or promote

products derived from this software without specific prior

written permission.

THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS

OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

#define CDBUFSIZE (MAXCOMLEN+EOCDLEN+EOCD64LOCLEN)

#define BUFSIZE 8192

#define EFZIP64SIZE 28

#define ZIP_CM_REPLACED_DEFAULT (-2)

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

#define ZIP_EF_UTF_8_COMMENT 0x6375

#define ZIP_EF_UTF_8_NAME 0x7075

#define ZIP_EF_ZIP64 0x0001

/* according to unzip-6.0's zipinfo.c, this corresponds to a regular file with rw permissions for everyone */

#define ZIP_EXT_ATTRIB_DEFAULT (0100666u<<16)

typedef zip_source_t *(*zip_compression_implementation)(zip_t *, zip_source_t *, zip_int32_t, int);

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

int zip_source_remove(zip_source_t *);

zip_int64_t zip_source_supports(zip_source_t *src);

zip_source_t *zip_source_window(zip_t *, zip_source_t *, zip_uint64_t, zip_uint64_t);

/* error source for layered sources */

zip_source_t **open_source; /* open sources using archive */

zip_hash_t *names; /* hash table for name lookup */

};

/* file in zip archive, part of API */

/* zip archive directory entry (central or local) */

struct zip_dirent {

zip_uint32_t changed;

bool local_extra_fields_read; /* whether we already read in local header extra fields */

zip_uint16_t version_madeby; /* (c) version of creator */

zip_uint16_t version_needed; /* (cl) version needed to extract */

zip_uint16_t int_attrib; /* (c) internal file attributes */

zip_uint32_t ext_attrib; /* (c) external file attributes */

zip_uint64_t offset; /* (c) offset of local header */

};

/* zip archive central directory */

zip_uint64_t size; /* size of central directory */

zip_uint64_t offset; /* offset of central directory in file */

zip_string_t *comment; /* zip archive comment */

};

struct zip_extra_field {

bool source_closed; /* set if source archive is closed */

zip_t *source_archive; /* zip archive we're reading from, NULL if not from archive */

unsigned int refcount;

};

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

struct zip_buffer {

bool ok;

bool free_data;

zip_uint8_t *data;

zip_uint64_t size;

zip_uint64_t offset;

extern const int _zip_nerr_str;

extern const int _zip_err_type[];

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

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

zip_int64_t _zip_add_entry(zip_t *);

zip_uint8_t *_zip_buffer_data(zip_buffer_t *buffer);

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

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

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

int _zip_cdir_compute_crc(zip_t *, uLong *);

void _zip_cdir_free(zip_cdir_t *);

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

void _zip_deregister_source(zip_t *za, zip_source_t *src);

zip_t *_zip_open(zip_source_t *, unsigned int, zip_error_t *);

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

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

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

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

void _zip_source_invalidate(zip_source_t *src);

zip_source_t *_zip_source_new(zip_error_t *error);

int _zip_source_set_source_archive(zip_source_t *, zip_t *);

zip_source_t *_zip_source_window_new(zip_source_t *src, zip_uint64_t start, zip_uint64_t length, zip_stat_t *st, zip_error_t *error);