/*

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;