- Copyright (C) 1999-2016 Dieter Baron and Thomas Klausner

-#include <sys/stat.h>

-zip_open(const char *fn, int _flags, int *zep)

-{

-zip_open_from_source(zip_source_t *src, int _flags, zip_error_t *error)

-{

- return NULL;

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

- needed_support_write = zip_source_make_command_bitmap(ZIP_SOURCE_BEGIN_WRITE, ZIP_SOURCE_COMMIT_WRITE, ZIP_SOURCE_ROLLBACK_WRITE, ZIP_SOURCE_SEEK_WRITE, ZIP_SOURCE_TELL_WRITE, ZIP_SOURCE_REMOVE, -1);

- zip_error_set(error, ZIP_ER_OPNOTSUPP, 0);

- return NULL;

- flags |= ZIP_RDONLY;

- if ((flags & (ZIP_RDONLY|ZIP_TRUNCATE)) == (ZIP_RDONLY|ZIP_TRUNCATE)) {

-ZIP_EXTERN void

-zip_register_progress_callback(zip_t *za, zip_progress_callback_t progress_callback)

-{

- za->progress_callback = progress_callback;

-}

-

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

-{

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

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

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

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

-{

-_zip_read_cdir(zip_t *za, zip_buffer_t *buffer, zip_uint64_t buf_offset, zip_error_t *error)

-{

- _zip_buffer_set_offset(buffer, eocd_offset - EOCD64LOCLEN);

- cd = _zip_read_eocd64(za->src, buffer, buf_offset, za->flags, error);

- _zip_buffer_set_offset(buffer, eocd_offset);

- cd = _zip_read_eocd(buffer, buf_offset, za->flags, error);

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

- return NULL;

- }

- if (comment_len) {

- if ((cd->comment=_zip_string_new(_zip_buffer_get(buffer, comment_len), comment_len, ZIP_FL_ENC_GUESS, error)) == NULL) {

- _zip_cdir_free(cd);

- return NULL;

- }

- }

- zip_uint8_t *data;

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

- return NULL;

- }

- if ((cd_buffer = _zip_buffer_new(data, cd->size)) == NULL) {

- zip_error_set(error, ZIP_ER_MEMORY, 0);

- _zip_cdir_free(cd);

- return NULL;

- }

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

- return NULL;

- }

- zip_error_set(error, ZIP_ER_NOZIP, 0);

- 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_buffer_free(cd_buffer);

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

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

- _zip_cdir_free(cd);

- return NULL;

- }

- 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_cdir_free(cd);

- return NULL;

- }

-_zip_checkcons(zip_t *za, zip_cdir_t *cd, zip_error_t *error)

-{

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

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

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

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

- return (max-min) < ZIP_INT64_MAX ? (zip_int64_t)(max-min) : ZIP_INT64_MAX;

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

-{

- || (central->comp_method != local->comp_method)

- || (central->last_mod != local->last_mod)

- || !_zip_string_equal(central->filename, local->filename))

- if ((central->crc != local->crc) || (central->comp_size != local->comp_size)

- || (central->uncomp_size != local->uncomp_size)) {

- if (((local->bitflags & ZIP_GPBF_DATA_DESCRIPTOR) == 0

- || local->crc != 0 || local->comp_size != 0 || local->uncomp_size != 0))

-_zip_allocate_new(zip_source_t *src, unsigned int flags, zip_error_t *error)

-{

- za->flags |= ZIP_AFL_RDONLY;

- za->ch_flags |= ZIP_AFL_RDONLY;

-_zip_file_exists(zip_source_t *src, zip_error_t *error)

-{

- zip_error_t *src_error = zip_source_error(src);

- if (zip_error_code_zip(src_error) == ZIP_ER_READ && zip_error_code_system(src_error) == ENOENT) {

-_zip_find_central_dir(zip_t *za, zip_uint64_t len)

-{

- return NULL;

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

- return NULL;

- return NULL;

- /* EOCD64 locator is before EOCD, so leave place for it */

- _zip_buffer_set_offset(buffer, EOCD64LOCLEN);

- while ((match=_zip_memmem(match, _zip_buffer_left(buffer)-(EOCDLEN-4), (const unsigned char *)EOCD_MAGIC, 4)) != NULL) {

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

- if ((cdirnew = _zip_read_cdir(za, buffer, (zip_uint64_t)buf_offset, &error)) != NULL) {

- if (cdir) {

- if (best <= 0) {

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

- }

-

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

- if (best < a) {

- _zip_cdir_free(cdir);

- cdir = cdirnew;

- best = a;

- }

- else {

- _zip_cdir_free(cdirnew);

- }

- }

- else {

- cdir = cdirnew;

- if (za->open_flags & ZIP_CHECKCONS)

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

- else {

- best = 0;

- }

- }

- cdirnew = NULL;

- }

-

- match++;

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

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

- _zip_cdir_free(cdir);

- return NULL;

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

-{

- p = big-1;

- while ((p=(const unsigned char *)

- memchr(p+1, little[0], (size_t)(big-(p+1))+(size_t)(biglen-littlelen)+1)) != NULL) {

- if (memcmp(p+1, little+1, littlelen-1)==0)

-_zip_read_eocd(zip_buffer_t *buffer, zip_uint64_t buf_offset, unsigned int flags, zip_error_t *error)

-{

- if (offset+size < offset) {

- zip_error_set(error, ZIP_ER_SEEK, EFBIG);

- return NULL;

- if (offset+size > buf_offset + eocd_offset) {

- if ((flags & ZIP_CHECKCONS) && offset+size != buf_offset + eocd_offset) {

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

-_zip_read_eocd64(zip_source_t *src, zip_buffer_t *buffer, zip_uint64_t buf_offset, unsigned int flags, zip_error_t *error)

-{

- zip_error_set(error, ZIP_ER_SEEK, EFBIG);

- return NULL;

- _zip_buffer_set_offset(buffer, eocd_offset - buf_offset);

- free_buffer = false;

- if (zip_source_seek(src, (zip_int64_t)eocd_offset, SEEK_SET) < 0) {

- _zip_error_set_from_source(error, src);

- return NULL;

- }

- if ((buffer = _zip_buffer_new_from_source(src, EOCD64LEN, eocd, error)) == NULL) {

- return NULL;

- }

- free_buffer = true;

- if (free_buffer) {

- _zip_buffer_free(buffer);

- }

- if (free_buffer) {

- _zip_buffer_free(buffer);

- }

- return NULL;

- if (free_buffer) {

- _zip_buffer_free(buffer);

- }

- zip_error_set(error, ZIP_ER_INTERNAL, 0);

- if (free_buffer) {

- _zip_buffer_free(buffer);

- }

- return NULL;

- _zip_buffer_free(buffer);

- if (offset > ZIP_INT64_MAX || offset+size < offset) {

- zip_error_set(error, ZIP_ER_SEEK, EFBIG);

- return NULL;

- if ((flags & ZIP_CHECKCONS) && offset+size != eocd_offset) {

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