#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "zipint.h"

Enumerations
enum	exists_t { EXISTS_ERROR = -1 , EXISTS_NOT = 0 , EXISTS_OK }

Functions
static zip_t *	_zip_allocate_new (zip_source_t src, unsigned int flags, zip_error_t error)

static zip_int64_t	_zip_checkcons (zip_t za, zip_cdir_t cdir, zip_error_t *error)

static zip_cdir_t *	_zip_find_central_dir (zip_t *za, zip_uint64_t len)

static exists_t	_zip_file_exists (zip_source_t src, zip_error_t error)

static int	_zip_headercomp (const zip_dirent_t , const zip_dirent_t )

static unsigned char *	_zip_memmem (const unsigned char , size_t, const unsigned char , size_t)

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

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

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

ZIP_EXTERN zip_t *	zip_open (const char fn, int _flags, int zep)

ZIP_EXTERN zip_t *	zip_open_from_source (zip_source_t src, int _flags, zip_error_t error)

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

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

Enumeration Type Documentation

◆ exists_t

enum exists_t

Enumerator
EXISTS_ERROR
EXISTS_NOT
EXISTS_OK

Definition at line 41 of file zip_open.c.

41 { EXISTS_ERROR = -1, EXISTS_NOT = 0, EXISTS_OK } exists_t;

exists_t

Definition: zip_open.c:41

EXISTS_NOT

@ EXISTS_NOT

Definition: zip_open.c:41

EXISTS_ERROR

@ EXISTS_ERROR

Definition: zip_open.c:41

EXISTS_OK

@ EXISTS_OK

Definition: zip_open.c:41

Function Documentation

◆ _zip_allocate_new()

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

static

Definition at line 504 of file zip_open.c.

                                                                              {
     zip_t *za;
  
     if ((za = _zip_new(error)) == NULL) {
         return NULL;
     }
  
     za->src = src;
     za->open_flags = flags;
     if (flags & ZIP_RDONLY) {
         za->flags |= ZIP_AFL_RDONLY;
         za->ch_flags |= ZIP_AFL_RDONLY;
     }
     return za;
 }

References _zip_new(), zip::ch_flags, error(), flags, zip::flags, NULL, zip::open_flags, zip::src, src, za, ZIP_AFL_RDONLY, and ZIP_RDONLY.

Referenced by _zip_open(), and zip_open_from_source().

◆ _zip_checkcons()

static zip_int64_t _zip_checkcons	(	zip_t *	za,
		zip_cdir_t *	cdir,
		zip_error_t *	error
	)

static

Definition at line 418 of file zip_open.c.

                                                               {
     zip_uint64_t i;
     zip_uint64_t min, max, j;
     struct zip_dirent temp;
  
     _zip_dirent_init(&temp);
     if (cd->nentry) {
         max = cd->entry[0].orig->offset;
         min = cd->entry[0].orig->offset;
     }
     else
         min = max = 0;
  
     for (i = 0; i < cd->nentry; i++) {
         if (cd->entry[i].orig->offset < min)
             min = cd->entry[i].orig->offset;
         if (min > (zip_uint64_t)cd->offset) {
             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)
             max = j;
         if (max > (zip_uint64_t)cd->offset) {
             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) {
         if (zip_error_code_zip(error) == ZIP_ER_INCONS) {
         zip_error_set(error, ZIP_ER_INCONS, ADD_INDEX_TO_DETAIL(zip_error_code_system(error), i));
         }
             _zip_dirent_finalize(&temp);
             return -1;
         }
  
         if (_zip_headercomp(cd->entry[i].orig, &temp) != 0) {
             zip_error_set(error, ZIP_ER_INCONS, MAKE_DETAIL_WITH_INDEX(ZIP_ER_DETAIL_ENTRY_HEADER_MISMATCH, i));
             _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);
     }
  
     return (max - min) < ZIP_INT64_MAX ? (zip_int64_t)(max - min) : ZIP_INT64_MAX;
 }

References _zip_dirent_finalize(), _zip_dirent_init(), _zip_dirent_read(), _zip_ef_merge(), _zip_error_set_from_source(), _zip_headercomp(), _zip_string_length(), ADD_INDEX_TO_DETAIL, cd, error(), zip_dirent::extra_fields, i, LENTRYSIZE, MAKE_DETAIL_WITH_INDEX, max, min, NULL, SEEK_SET, zip::src, za, ZIP_ER_DETAIL_ENTRY_HEADER_MISMATCH, ZIP_ER_INCONS, ZIP_ER_NOZIP, zip_error_code_system(), zip_error_code_zip(), zip_error_set(), ZIP_INT64_MAX, and zip_source_seek().

Referenced by _zip_find_central_dir().

◆ _zip_file_exists()

static exists_t _zip_file_exists	(	zip_source_t *	src,
		zip_error_t *	error
	)

static

Definition at line 525 of file zip_open.c.

                                                         {
     struct zip_stat st;
  
     zip_stat_init(&st);
     if (zip_source_stat(src, &st) != 0) {
         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) {
             return EXISTS_NOT;
         }
         _zip_error_copy(error, src_error);
         return EXISTS_ERROR;
     }
  
     return EXISTS_OK;
 }

References _zip_error_copy(), ENOENT, error(), EXISTS_ERROR, EXISTS_NOT, EXISTS_OK, src, ZIP_ER_READ, zip_error_code_system(), zip_error_code_zip(), zip_source_error(), zip_source_stat(), and zip_stat_init().

Referenced by zip_open_from_source().

◆ _zip_find_central_dir()

static zip_cdir_t * _zip_find_central_dir	(	zip_t *	za,
		zip_uint64_t	len
	)

static

Definition at line 543 of file zip_open.c.

                                                    {
     zip_cdir_t *cdir, *cdirnew;
     zip_uint8_t *match;
     zip_int64_t buf_offset;
     zip_uint64_t buflen;
     zip_int64_t a;
     zip_int64_t best;
     zip_error_t error;
     zip_buffer_t *buffer;
  
     if (len < EOCDLEN) {
         zip_error_set(&za->error, ZIP_ER_NOZIP, 0);
         return NULL;
     }
  
     buflen = (len < CDBUFSIZE ? len : CDBUFSIZE);
     if (zip_source_seek(za->src, -(zip_int64_t)buflen, SEEK_END) < 0) {
         zip_error_t *src_error = zip_source_error(za->src);
         if (zip_error_code_zip(src_error) != ZIP_ER_SEEK || zip_error_code_system(src_error) != EFBIG) {
             /* seek before start of file on my machine */
             _zip_error_copy(&za->error, src_error);
             return NULL;
         }
     }
     if ((buf_offset = zip_source_tell(za->src)) < 0) {
         _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;
     }
  
     best = -1;
     cdir = NULL;
     if (buflen >= CDBUFSIZE) {
         /* EOCD64 locator is before EOCD, so leave place for it */
         _zip_buffer_set_offset(buffer, EOCD64LOCLEN);
     }
     zip_error_set(&error, ZIP_ER_NOZIP, 0);
  
     match = _zip_buffer_get(buffer, 0);
     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_buffer_free(buffer);
  
     if (best < 0) {
         _zip_error_copy(&za->error, &error);
         _zip_cdir_free(cdir);
         return NULL;
     }
  
     return cdir;
 }

References _zip_buffer_data(), _zip_buffer_free(), _zip_buffer_get(), _zip_buffer_left(), _zip_buffer_new_from_source(), _zip_buffer_set_offset(), _zip_cdir_free(), _zip_checkcons(), _zip_error_copy(), _zip_error_set_from_source(), _zip_memmem(), _zip_read_cdir(), a, buflen, CDBUFSIZE, EFBIG, EOCD64LOCLEN, EOCD_MAGIC, EOCDLEN, zip::error, error(), len, match, NULL, zip::open_flags, SEEK_END, zip::src, za, ZIP_CHECKCONS, ZIP_ER_NOZIP, ZIP_ER_SEEK, zip_error_code_system(), zip_error_code_zip(), zip_error_set(), zip_source_error(), zip_source_seek(), and zip_source_tell().

Referenced by _zip_open().

◆ _zip_headercomp()

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

static

Definition at line 482 of file zip_open.c.

                                                                         {
     if ((central->version_needed < local->version_needed)
 #if 0
     /* some zip-files have different values in local
        and global headers for the bitflags */
     || (central->bitflags != local->bitflags)
 #endif
         || (central->comp_method != local->comp_method) || (central->last_mod != local->last_mod) || !_zip_string_equal(central->filename, local->filename))
         return -1;
  
     if ((central->crc != local->crc) || (central->comp_size != local->comp_size) || (central->uncomp_size != local->uncomp_size)) {
         /* InfoZip stores valid values in local header even when data descriptor is used.
            This is in violation of the appnote. */
         if (((local->bitflags & ZIP_GPBF_DATA_DESCRIPTOR) == 0 || local->crc != 0 || local->comp_size != 0 || local->uncomp_size != 0))
             return -1;
     }
  
     return 0;
 }

References _zip_string_equal(), zip_dirent::bitflags, zip_dirent::comp_method, zip_dirent::comp_size, zip_dirent::crc, zip_dirent::filename, zip_dirent::last_mod, local, zip_dirent::uncomp_size, zip_dirent::version_needed, and ZIP_GPBF_DATA_DESCRIPTOR.

Referenced by _zip_checkcons().

◆ _zip_memmem()

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

static

Definition at line 631 of file zip_open.c.

                                                                                                     {
     const unsigned char *p;
  
     if ((biglen < littlelen) || (littlelen == 0))
         return NULL;
     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)
             return (unsigned char *)p;
     }
  
     return NULL;
 }

References NULL, and p.

Referenced by _zip_find_central_dir().

◆ _zip_open()

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

Definition at line 146 of file zip_open.c.

                                                                      {
     zip_t *za;
     zip_cdir_t *cdir;
     struct zip_stat st;
     zip_uint64_t len, idx;
  
     zip_stat_init(&st);
     if (zip_source_stat(src, &st) < 0) {
         _zip_error_set_from_source(error, src);
         return NULL;
     }
     if ((st.valid & ZIP_STAT_SIZE) == 0) {
         zip_error_set(error, ZIP_ER_SEEK, EOPNOTSUPP);
         return NULL;
     }
     len = st.size;
  
  
     if ((za = _zip_allocate_new(src, flags, error)) == NULL) {
         return NULL;
     }
  
     /* treat empty files as empty archives */
     if (len == 0 && zip_source_accept_empty(src)) {
         return za;
     }
  
     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_source_keep(src);
         zip_discard(za);
         return NULL;
     }
  
     za->entry = cdir->entry;
     za->nentry = cdir->nentry;
     za->nentry_alloc = cdir->nentry_alloc;
     za->comment_orig = cdir->comment;
  
     free(cdir);
  
     _zip_hash_reserve_capacity(za->names, za->nentry, &za->error);
  
     for (idx = 0; idx < za->nentry; idx++) {
         const zip_uint8_t *name = _zip_string_get(za->entry[idx].orig->filename, NULL, 0, error);
         if (name == NULL) {
             /* keep src so discard does not get rid of it */
             zip_source_keep(src);
             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);
                 /* keep src so discard does not get rid of it */
                 zip_source_keep(src);
                 zip_discard(za);
                 return NULL;
             }
         }
     }
  
     za->ch_flags = za->flags;
  
     return za;
 }

References _zip_allocate_new(), _zip_error_copy(), _zip_error_set_from_source(), _zip_find_central_dir(), _zip_hash_add(), _zip_hash_reserve_capacity(), _zip_string_get(), zip::ch_flags, zip_cdir::comment, zip::comment_orig, zip::entry, zip_cdir::entry, EOPNOTSUPP, zip::error, error(), zip_dirent::filename, flags, zip::flags, free(), setup::idx, len, zip::names, zip::nentry, zip_cdir::nentry, zip::nentry_alloc, zip_cdir::nentry_alloc, NULL, zip_entry::orig, zip_stat::size, src, zip_stat::valid, za, ZIP_CHECKCONS, zip_discard(), ZIP_ER_EXISTS, ZIP_ER_SEEK, zip_error::zip_err, zip_error_set(), ZIP_FL_UNCHANGED, zip_source_accept_empty(), zip_source_keep(), zip_source_stat(), zip_stat_init(), and ZIP_STAT_SIZE.

Referenced by zip_open_from_source().

◆ _zip_read_cdir()

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

static

Definition at line 243 of file zip_open.c.

                                                                                              {
     zip_cdir_t *cd;
     zip_uint16_t comment_len;
     zip_uint64_t i, left;
     zip_uint64_t eocd_offset = _zip_buffer_offset(buffer);
     zip_buffer_t *cd_buffer;
  
     if (_zip_buffer_left(buffer) < EOCDLEN) {
         /* not enough bytes left for comment */
         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);
         return NULL;
     }
  
     if (eocd_offset >= EOCD64LOCLEN && memcmp(_zip_buffer_data(buffer) + eocd_offset - EOCD64LOCLEN, EOCD64LOC_MAGIC, 4) == 0) {
         _zip_buffer_set_offset(buffer, eocd_offset - EOCD64LOCLEN);
         cd = _zip_read_eocd64(za->src, buffer, buf_offset, za->flags, error);
     }
     else {
         _zip_buffer_set_offset(buffer, eocd_offset);
         cd = _zip_read_eocd(buffer, buf_offset, za->flags, error);
     }
  
     if (cd == NULL)
         return NULL;
  
     _zip_buffer_set_offset(buffer, eocd_offset + 20);
     comment_len = _zip_buffer_get_16(buffer);
  
     if (cd->offset + cd->size > buf_offset + eocd_offset) {
         /* cdir spans past EOCD record */
         zip_error_set(error, ZIP_ER_INCONS, ZIP_ER_DETAIL_CDIR_OVERLAPS_EOCD);
         _zip_cdir_free(cd);
         return NULL;
     }
  
     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, ZIP_ER_DETAIL_COMMENT_LENGTH_INVALID);
             _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;
             }
         }
     }
  
     if (cd->offset >= buf_offset) {
         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, ZIP_ER_DETAIL_CDIR_LENGTH_INVALID);
             _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;
         }
     }
     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);
             return NULL;
         }
  
         /* possible consistency check: cd->offset = len-(cd->size+cd->comment_len+EOCDLEN) ? */
         if (zip_source_tell(za->src) != (zip_int64_t)cd->offset) {
             zip_error_set(error, ZIP_ER_NOZIP, 0);
             _zip_cdir_free(cd);
             return NULL;
         }
     }
  
     left = (zip_uint64_t)cd->size;
     i = 0;
     while (left > 0) {
         bool grown = false;
         zip_int64_t entry_size;
  
         if (i == cd->nentry) {
             /* InfoZIP has a hack to avoid using Zip64: it stores nentries % 0x10000 */
             /* This hack isn't applicable if we're using Zip64, or if there is no central directory entry following. */
  
             if (cd->is_zip64 || left < CDENTRYSIZE) {
                 break;
             }
  
             if (!_zip_cdir_grow(cd, 0x10000, error)) {
                 _zip_cdir_free(cd);
                 _zip_buffer_free(cd_buffer);
                 return NULL;
             }
             grown = true;
         }
  
         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) {
         if (zip_error_code_zip(error) == ZIP_ER_INCONS) {
         zip_error_set(error, ZIP_ER_INCONS, ADD_INDEX_TO_DETAIL(zip_error_code_system(error), i));
         }
         else if (grown && zip_error_code_zip(error) == ZIP_ER_NOZIP) {
                 zip_error_set(error, ZIP_ER_INCONS, MAKE_DETAIL_WITH_INDEX(ZIP_ER_DETAIL_CDIR_ENTRY_INVALID, i));
             }
             _zip_cdir_free(cd);
             _zip_buffer_free(cd_buffer);
             return NULL;
         }
         i++;
         left -= (zip_uint64_t)entry_size;
     }
  
     if (i != cd->nentry || left > 0) {
         zip_error_set(error, ZIP_ER_INCONS, ZIP_ER_DETAIL_CDIR_WRONG_ENTRIES_COUNT);
         _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_cdir_free(cd);
                 return NULL;
             }
             ok = ((zip_uint64_t)offset == cd->offset + cd->size);
         }
  
         if (!ok) {
             zip_error_set(error, ZIP_ER_INCONS, ZIP_ER_DETAIL_CDIR_LENGTH_INVALID);
             _zip_buffer_free(cd_buffer);
             _zip_cdir_free(cd);
             return NULL;
         }
     }
  
     _zip_buffer_free(cd_buffer);
     return cd;
 }

References _zip_buffer_data(), _zip_buffer_eof(), _zip_buffer_free(), _zip_buffer_get(), _zip_buffer_get_16(), _zip_buffer_left(), _zip_buffer_new(), _zip_buffer_offset(), _zip_buffer_set_offset(), _zip_cdir_free(), _zip_cdir_grow(), _zip_dirent_new(), _zip_dirent_read(), _zip_error_set_from_source(), _zip_read_eocd(), _zip_read_eocd64(), _zip_string_new(), ADD_INDEX_TO_DETAIL, cd, CDENTRYSIZE, EOCD64LOC_MAGIC, EOCD64LOCLEN, EOCD_MAGIC, EOCDLEN, error(), zip::flags, i, MAKE_DETAIL_WITH_INDEX, NULL, ok, zip::open_flags, SEEK_SET, zip::src, while(), za, ZIP_CHECKCONS, ZIP_ER_DETAIL_CDIR_ENTRY_INVALID, ZIP_ER_DETAIL_CDIR_LENGTH_INVALID, ZIP_ER_DETAIL_CDIR_OVERLAPS_EOCD, ZIP_ER_DETAIL_CDIR_WRONG_ENTRIES_COUNT, ZIP_ER_DETAIL_COMMENT_LENGTH_INVALID, ZIP_ER_INCONS, ZIP_ER_MEMORY, ZIP_ER_NOZIP, zip_error_code_system(), zip_error_code_zip(), zip_error_set(), ZIP_FL_ENC_GUESS, zip_source_seek(), and zip_source_tell().

Referenced by _zip_find_central_dir().

◆ _zip_read_eocd()

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

static

Definition at line 647 of file zip_open.c.

                                                                                                       {
     zip_cdir_t *cd;
     zip_uint64_t i, nentry, size, offset, eocd_offset;
  
     if (_zip_buffer_left(buffer) < EOCDLEN) {
         zip_error_set(error, ZIP_ER_INCONS, ZIP_ER_DETAIL_EOCD_LENGTH_INVALID);
         return NULL;
     }
  
     eocd_offset = _zip_buffer_offset(buffer);
  
     _zip_buffer_get(buffer, 4); /* magic already verified */
  
     if (_zip_buffer_get_32(buffer) != 0) {
         zip_error_set(error, ZIP_ER_MULTIDISK, 0);
         return NULL;
     }
  
     /* number of cdir-entries on this disk */
     i = _zip_buffer_get_16(buffer);
     /* number of cdir-entries */
     nentry = _zip_buffer_get_16(buffer);
  
     if (nentry != i) {
         zip_error_set(error, ZIP_ER_NOZIP, 0);
         return NULL;
     }
  
     size = _zip_buffer_get_32(buffer);
     offset = _zip_buffer_get_32(buffer);
  
     if (offset + size < offset) {
         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, ZIP_ER_DETAIL_CDIR_OVERLAPS_EOCD);
         return NULL;
     }
  
     if ((flags & ZIP_CHECKCONS) && offset + size != buf_offset + eocd_offset) {
         zip_error_set(error, ZIP_ER_INCONS, ZIP_ER_DETAIL_CDIR_LENGTH_INVALID);
         return NULL;
     }
  
     if ((cd = _zip_cdir_new(nentry, error)) == NULL)
         return NULL;
  
     cd->is_zip64 = false;
     cd->size = size;
     cd->offset = offset;
  
     return cd;
 }

References _zip_buffer_get(), _zip_buffer_get_16(), _zip_buffer_get_32(), _zip_buffer_left(), _zip_buffer_offset(), _zip_cdir_new(), cd, EFBIG, EOCDLEN, error(), flags, i, NULL, ZIP_CHECKCONS, ZIP_ER_DETAIL_CDIR_LENGTH_INVALID, ZIP_ER_DETAIL_CDIR_OVERLAPS_EOCD, ZIP_ER_DETAIL_EOCD_LENGTH_INVALID, ZIP_ER_INCONS, ZIP_ER_MULTIDISK, ZIP_ER_NOZIP, ZIP_ER_SEEK, and zip_error_set().

Referenced by _zip_read_cdir().

◆ _zip_read_eocd64()

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

static

Definition at line 706 of file zip_open.c.

                                                                                                                            {
     zip_cdir_t *cd;
     zip_uint64_t offset;
     zip_uint8_t eocd[EOCD64LEN];
     zip_uint64_t eocd_offset;
     zip_uint64_t size, nentry, i, eocdloc_offset;
     bool free_buffer;
     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);
  
     /* valid seek value for start of EOCD */
     if (eocd_offset > ZIP_INT64_MAX) {
         zip_error_set(error, ZIP_ER_SEEK, EFBIG);
         return NULL;
     }
  
     /* does EOCD fit before EOCD locator? */
     if (eocd_offset + EOCD64LEN > eocdloc_offset + buf_offset) {
         zip_error_set(error, ZIP_ER_INCONS, ZIP_ER_DETAIL_EOCD64_OVERLAPS_EOCD);
         return NULL;
     }
  
     /* make sure current position of buffer is beginning of EOCD */
     if (eocd_offset >= buf_offset && eocd_offset + EOCD64LEN <= buf_offset + _zip_buffer_size(buffer)) {
         _zip_buffer_set_offset(buffer, eocd_offset - buf_offset);
         free_buffer = false;
     }
     else {
         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 (memcmp(_zip_buffer_get(buffer, 4), EOCD64_MAGIC, 4) != 0) {
         zip_error_set(error, ZIP_ER_INCONS, ZIP_ER_DETAIL_EOCD64_WRONG_MAGIC);
         if (free_buffer) {
             _zip_buffer_free(buffer);
         }
         return NULL;
     }
  
     /* size of EOCD */
     size = _zip_buffer_get_64(buffer);
  
     /* is there a hole between EOCD and EOCD locator, or do they overlap? */
     if ((flags & ZIP_CHECKCONS) && size + eocd_offset + 12 != buf_offset + eocdloc_offset) {
         zip_error_set(error, ZIP_ER_INCONS, ZIP_ER_DETAIL_EOCD64_OVERLAPS_EOCD);
         if (free_buffer) {
             _zip_buffer_free(buffer);
         }
         return NULL;
     }
  
     _zip_buffer_get(buffer, 4); /* skip version made by/needed */
  
     num_disks64 = _zip_buffer_get_32(buffer);
     eocd_disk64 = _zip_buffer_get_32(buffer);
  
     /* if eocd values are 0xffff, we have to use eocd64 values.
        otherwise, if the values are not the same, it's inconsistent;
        in any case, if the value is not 0, we don't support it */
     if (num_disks == 0xffff) {
         num_disks = num_disks64;
     }
     if (eocd_disk == 0xffff) {
         eocd_disk = eocd_disk64;
     }
     if ((flags & ZIP_CHECKCONS) && (eocd_disk != eocd_disk64 || num_disks != num_disks64)) {
         zip_error_set(error, ZIP_ER_INCONS, ZIP_ER_DETAIL_EOCD64_MISMATCH);
         if (free_buffer) {
             _zip_buffer_free(buffer);
         }
         return NULL;
     }
     if (num_disks != 0 || eocd_disk != 0) {
         zip_error_set(error, ZIP_ER_MULTIDISK, 0);
         if (free_buffer) {
             _zip_buffer_free(buffer);
         }
         return NULL;
     }
  
     nentry = _zip_buffer_get_64(buffer);
     i = _zip_buffer_get_64(buffer);
  
     if (nentry != i) {
         zip_error_set(error, ZIP_ER_MULTIDISK, 0);
         if (free_buffer) {
             _zip_buffer_free(buffer);
         }
         return NULL;
     }
  
     size = _zip_buffer_get_64(buffer);
     offset = _zip_buffer_get_64(buffer);
  
     /* did we read past the end of the buffer? */
     if (!_zip_buffer_ok(buffer)) {
         zip_error_set(error, ZIP_ER_INTERNAL, 0);
         if (free_buffer) {
             _zip_buffer_free(buffer);
         }
         return NULL;
     }
  
     if (free_buffer) {
         _zip_buffer_free(buffer);
     }
  
     if (offset > ZIP_INT64_MAX || offset + size < offset) {
         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, ZIP_ER_DETAIL_CDIR_OVERLAPS_EOCD);
         return NULL;
     }
     if ((flags & ZIP_CHECKCONS) && offset + size != buf_offset + eocd_offset) {
         zip_error_set(error, ZIP_ER_INCONS, ZIP_ER_DETAIL_CDIR_OVERLAPS_EOCD);
         return NULL;
     }
  
     if (nentry > size / CDENTRYSIZE) {
         zip_error_set(error, ZIP_ER_INCONS, ZIP_ER_DETAIL_CDIR_INVALID);
         return NULL;
     }
  
     if ((cd = _zip_cdir_new(nentry, error)) == NULL)
         return NULL;
  
     cd->is_zip64 = true;
     cd->size = size;
     cd->offset = offset;
  
     return cd;
 }

References _zip_buffer_free(), _zip_buffer_get(), _zip_buffer_get_16(), _zip_buffer_get_32(), _zip_buffer_get_64(), _zip_buffer_new_from_source(), _zip_buffer_offset(), _zip_buffer_ok(), _zip_buffer_set_offset(), _zip_buffer_size(), _zip_cdir_new(), _zip_error_set_from_source(), cd, CDENTRYSIZE, EFBIG, EOCD64_MAGIC, EOCD64LEN, error(), flags, i, NULL, SEEK_SET, src, ZIP_CHECKCONS, ZIP_ER_DETAIL_CDIR_INVALID, ZIP_ER_DETAIL_CDIR_OVERLAPS_EOCD, ZIP_ER_DETAIL_EOCD64_MISMATCH, ZIP_ER_DETAIL_EOCD64_OVERLAPS_EOCD, ZIP_ER_DETAIL_EOCD64_WRONG_MAGIC, ZIP_ER_INCONS, ZIP_ER_INTERNAL, ZIP_ER_MULTIDISK, ZIP_ER_SEEK, zip_error_set(), ZIP_INT64_MAX, and zip_source_seek().

Referenced by _zip_read_cdir().

◆ _zip_set_open_error()

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

Definition at line 217 of file zip_open.c.

                                                               {
     if (err) {
         ze = zip_error_code_zip(err);
     switch (zip_error_system_type(err)) {
         case ZIP_ET_SYS:
         case ZIP_ET_LIBZIP:
         errno = zip_error_code_system(err);
         break;
         
         default:
         break;
         }
     }
  
     if (zep)
         *zep = ze;
 }

References err, zip_error_code_system(), zip_error_code_zip(), zip_error_system_type(), ZIP_ET_LIBZIP, and ZIP_ET_SYS.

Referenced by zip_fdopen(), and zip_open().

◆ zip_open()

ZIP_EXTERN zip_t* zip_open	(	const char *	fn,
		int	_flags,
		int *	zep
	)

Definition at line 54 of file zip_open.c.

                                                {
     zip_t *za;
     zip_source_t *src;
     struct zip_error error;
  
     zip_error_init(&error);
     if ((src = zip_source_file_create(fn, 0, -1, &error)) == NULL) {
         _zip_set_open_error(zep, &error, 0);
         zip_error_fini(&error);
         return NULL;
     }
  
     if ((za = zip_open_from_source(src, _flags, &error)) == NULL) {
         zip_source_free(src);
         _zip_set_open_error(zep, &error, 0);
         zip_error_fini(&error);
         return NULL;
     }
  
     zip_error_fini(&error);
     return za;
 }

References _zip_set_open_error(), error(), fn, NULL, src, za, zip_error_fini(), zip_error_init(), zip_open_from_source(), zip_source_file_create(), and zip_source_free().

Referenced by add_from_zip(), list_zip(), main(), merge_zip(), read_from_file(), and rz_io_zip_open_archive().

◆ zip_open_from_source()

ZIP_EXTERN zip_t* zip_open_from_source	(	zip_source_t *	src,
		int	_flags,
		zip_error_t *	error
	)

Definition at line 79 of file zip_open.c.

                                                                         {
     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 ((supported & ZIP_SOURCE_SUPPORTS_SEEKABLE) != ZIP_SOURCE_SUPPORTS_SEEKABLE) {
         zip_error_set(error, ZIP_ER_OPNOTSUPP, 0);
         return NULL;
     }
     if ((supported & ZIP_SOURCE_SUPPORTS_WRITABLE) != ZIP_SOURCE_SUPPORTS_WRITABLE) {
         flags |= ZIP_RDONLY;
     }
  
     if ((flags & (ZIP_RDONLY | ZIP_TRUNCATE)) == (ZIP_RDONLY | ZIP_TRUNCATE)) {
         zip_error_set(error, ZIP_ER_RDONLY, 0);
         return NULL;
     }
  
     exists = _zip_file_exists(src, error);
     switch (exists) {
     case EXISTS_ERROR:
         return NULL;
  
     case EXISTS_NOT:
         if ((flags & ZIP_CREATE) == 0) {
             zip_error_set(error, ZIP_ER_NOENT, 0);
             return NULL;
         }
         return _zip_allocate_new(src, flags, error);
  
     default: {
         zip_t *za;
         if (flags & ZIP_EXCL) {
             zip_error_set(error, ZIP_ER_EXISTS, 0);
             return NULL;
         }
         if (zip_source_open(src) < 0) {
             _zip_error_set_from_source(error, src);
             return NULL;
         }
  
         if (flags & ZIP_TRUNCATE) {
             za = _zip_allocate_new(src, flags, error);
         }
         else {
             /* ZIP_CREATE gets ignored if file exists and not ZIP_EXCL, just like open() */
             za = _zip_open(src, flags, error);
         }
  
         if (za == NULL) {
             zip_source_close(src);
             return NULL;
         }
         return za;
     }
     }
 }

References _zip_allocate_new(), _zip_error_set_from_source(), _zip_file_exists(), _zip_open(), error(), EXISTS_ERROR, EXISTS_NOT, flags, int, NULL, src, za, ZIP_CREATE, ZIP_ER_EXISTS, ZIP_ER_INVAL, ZIP_ER_NOENT, ZIP_ER_OPNOTSUPP, ZIP_ER_RDONLY, zip_error_set(), ZIP_EXCL, ZIP_RDONLY, zip_source_close(), zip_source_open(), zip_source_supports(), ZIP_SOURCE_SUPPORTS_SEEKABLE, ZIP_SOURCE_SUPPORTS_WRITABLE, and ZIP_TRUNCATE.

Referenced by LLVMFuzzerTestOneInput(), main(), read_from_file(), read_hole(), read_to_memory(), windows_open(), zip_fdopen(), and zip_open().

Enumerations

Functions

Enumeration Type Documentation

◆ exists_t

Function Documentation

◆ _zip_allocate_new()

◆ _zip_checkcons()

◆ _zip_file_exists()

◆ _zip_find_central_dir()

◆ _zip_headercomp()

◆ _zip_memmem()

◆ _zip_open()

◆ _zip_read_cdir()

◆ _zip_read_eocd()

◆ _zip_read_eocd64()

◆ _zip_set_open_error()

◆ zip_open()

◆ zip_open_from_source()