ext/zip/lib/zip

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
zip_open
zip_open_from_source
zip_archive_set_tempdir
_zip_open
_zip_set_open_error
_zip_read_cdir
_zip_checkcons
_zip_headercomp
_zip_allocate_new
_zip_file_exists
_zip_find_central_dir
_zip_memmem
_zip_read_eocd
_zip_read_eocd64
   1 /*
   2   zip_open.c -- open zip archive by name
   3   Copyright (C) 1999-2015 Dieter Baron and Thomas Klausner
   4 
   5   This file is part of libzip, a library to manipulate ZIP archives.
   6   The authors can be contacted at <libzip@nih.at>
   7 
   8   Redistribution and use in source and binary forms, with or without
   9   modification, are permitted provided that the following conditions
  10   are met:
  11   1. Redistributions of source code must retain the above copyright
  12      notice, this list of conditions and the following disclaimer.
  13   2. Redistributions in binary form must reproduce the above copyright
  14      notice, this list of conditions and the following disclaimer in
  15      the documentation and/or other materials provided with the
  16      distribution.
  17   3. The names of the authors may not be used to endorse or promote
  18      products derived from this software without specific prior
  19      written permission.
  20  
  21   THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS
  22   OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  23   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24   ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
  25   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  27   GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  28   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  29   IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  30   OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  31   IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32 */
  33 
  34 
  35 #include <sys/stat.h>
  36 #include <limits.h>
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40 
  41 #include "zipint.h"
  42 
  43 typedef enum {
  44     EXISTS_ERROR = -1,
  45     EXISTS_NOT = 0,
  46     EXISTS_EMPTY,
  47     EXISTS_NONEMPTY,
  48 } exists_t;
  49 static zip_t *_zip_allocate_new(zip_source_t *src, unsigned int flags, zip_error_t *error);
  50 static zip_int64_t _zip_checkcons(zip_t *za, zip_cdir_t *cdir, zip_error_t *error);
  51 static zip_cdir_t *_zip_find_central_dir(zip_t *za, zip_uint64_t len);
  52 static exists_t _zip_file_exists(zip_source_t *src, zip_error_t *error);
  53 static int _zip_headercomp(const zip_dirent_t *, const zip_dirent_t *);
  54 static unsigned char *_zip_memmem(const unsigned char *, size_t, const unsigned char *, size_t);
  55 static zip_cdir_t *_zip_read_cdir(zip_t *za, zip_buffer_t *buffer, zip_uint64_t buf_offset, zip_error_t *error);
  56 static zip_cdir_t *_zip_read_eocd(zip_buffer_t *buffer, zip_uint64_t buf_offset, unsigned int flags, zip_error_t *error);
  57 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);
  58 
  59 
  60 ZIP_EXTERN zip_t *
  61 zip_open(const char *fn, int _flags, int *zep)
  62 {
  63     zip_t *za;
  64     zip_source_t *src;
  65     struct zip_error error;
  66 
  67     zip_error_init(&error);
  68     if ((src = zip_source_file_create(fn, 0, -1, &error)) == NULL) {
  69         _zip_set_open_error(zep, &error, 0);
  70         zip_error_fini(&error);
  71         return NULL;
  72     }
  73 
  74     if ((za = zip_open_from_source(src, _flags, &error)) == NULL) {
  75         zip_source_free(src);
  76         _zip_set_open_error(zep, &error, 0);
  77         zip_error_fini(&error);
  78         return NULL;
  79     }
  80 
  81     zip_error_fini(&error);
  82     return za;
  83 }
  84 
  85 
  86 ZIP_EXTERN zip_t *
  87 zip_open_from_source(zip_source_t *src, int _flags, zip_error_t *error)
  88 {
  89     static zip_int64_t needed_support_read = -1;
  90     static zip_int64_t needed_support_write = -1;
  91     
  92     unsigned int flags;
  93     zip_int64_t supported;
  94     exists_t exists;
  95     
  96     if (_flags < 0 || src == NULL) {
  97         zip_error_set(error, ZIP_ER_INVAL, 0);
  98         return NULL;
  99     }
 100     flags = (unsigned int)_flags;
 101     
 102     supported = zip_source_supports(src);
 103     if (needed_support_read == -1) {
 104         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);
 105         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);
 106     }
 107     if ((supported & needed_support_read) != needed_support_read) {
 108         zip_error_set(error, ZIP_ER_OPNOTSUPP, 0);
 109         return NULL;
 110     }
 111     if ((supported & needed_support_write) != needed_support_write) {
 112         flags |= ZIP_RDONLY;
 113     }
 114 
 115     if ((flags & (ZIP_RDONLY|ZIP_TRUNCATE)) == (ZIP_RDONLY|ZIP_TRUNCATE)) {
 116         zip_error_set(error, ZIP_ER_RDONLY, 0);
 117         return NULL;
 118     }
 119 
 120     exists = _zip_file_exists(src, error);
 121     switch (exists) { 
 122     case EXISTS_ERROR:
 123         return NULL;
 124 
 125     case EXISTS_NOT:
 126         if ((flags & ZIP_CREATE) == 0) {
 127             zip_error_set(error, ZIP_ER_NOENT, 0);
 128             return NULL;
 129         }
 130         return _zip_allocate_new(src, flags, error);
 131 
 132     default: {
 133         zip_t *za;
 134         if (flags & ZIP_EXCL) {
 135             zip_error_set(error, ZIP_ER_EXISTS, 0);
 136             return NULL;
 137         }
 138         if (zip_source_open(src) < 0) {
 139             _zip_error_set_from_source(error, src);
 140             return NULL;
 141         }
 142 
 143         if (flags & ZIP_TRUNCATE) {
 144             za = _zip_allocate_new(src, flags, error);
 145         }
 146         else {
 147             /* ZIP_CREATE gets ignored if file exists and not ZIP_EXCL, just like open() */
 148             za = _zip_open(src, flags, error);
 149         }
 150 
 151         if (za == NULL) {
 152             zip_source_close(src);
 153             return NULL;
 154         }
 155         return za;
 156     }
 157     }
 158 }
 159 
 160 ZIP_EXTERN int
 161 zip_archive_set_tempdir(zip_t *za, const char *tempdir)
 162 {
 163     char *new_tempdir;
 164     
 165     if (tempdir) {
 166         if ((new_tempdir = strdup(tempdir)) == NULL) {
 167             zip_error_set(&za->error, ZIP_ER_MEMORY, errno);
 168             return -1;
 169         }
 170     }
 171     else
 172         new_tempdir = NULL;
 173     
 174     free(za->tempdir);
 175     za->tempdir = new_tempdir;
 176     
 177     return 0;
 178 }
 179 
 180 zip_t *
 181 _zip_open(zip_source_t *src, unsigned int flags, zip_error_t *error)
 182 {
 183     zip_t *za;
 184     zip_cdir_t *cdir;
 185     struct zip_stat st;
 186     zip_uint64_t len, idx;
 187 
 188     zip_stat_init(&st);
 189     if (zip_source_stat(src, &st) < 0) {
 190         _zip_error_set_from_source(error, src);
 191         return NULL;
 192     }
 193     if ((st.valid & ZIP_STAT_SIZE) == 0) {
 194         zip_error_set(error, ZIP_ER_SEEK, EOPNOTSUPP);
 195         return NULL;
 196     }
 197     len = st.size;
 198 
 199     /* treat empty files as empty archives */
 200     if (len == 0) {
 201         if ((za=_zip_allocate_new(src, flags, error)) == NULL) {
 202             zip_source_free(src);
 203             return NULL;
 204         }
 205 
 206         return za;
 207     }
 208 
 209     if ((za=_zip_allocate_new(src, flags, error)) == NULL) {
 210         return NULL;
 211     }
 212     
 213     if ((cdir = _zip_find_central_dir(za, len)) == NULL) {
 214         _zip_error_copy(error, &za->error);
 215         /* keep src so discard does not get rid of it */
 216         zip_source_keep(src);
 217         zip_discard(za);
 218         return NULL;
 219     }
 220 
 221     za->entry = cdir->entry;
 222     za->nentry = cdir->nentry;
 223     za->nentry_alloc = cdir->nentry_alloc;
 224     za->comment_orig = cdir->comment;
 225 
 226     free(cdir);
 227 
 228     for (idx = 0; idx < za->nentry; idx++) {
 229         const zip_uint8_t *name = _zip_string_get(za->entry[idx].orig->filename, NULL, 0, error);
 230         if (name == NULL) {
 231                 /* keep src so discard does not get rid of it */
 232                 zip_source_keep(src);
 233                 zip_discard(za);
 234                 return NULL;
 235         }
 236         
 237         if (_zip_hash_add(za->names, name, idx, ZIP_FL_UNCHANGED, &za->error) == false) {
 238             if (za->error.zip_err != ZIP_ER_EXISTS || (flags & ZIP_CHECKCONS)) {
 239                 _zip_error_copy(error, &za->error);
 240                 /* keep src so discard does not get rid of it */
 241                 zip_source_keep(src);
 242                 zip_discard(za);
 243                 return NULL;
 244             }
 245         }
 246     }
 247     
 248     za->ch_flags = za->flags;
 249 
 250     return za;
 251 }
 252 
 253 
 254 void
 255 _zip_set_open_error(int *zep, const zip_error_t *err, int ze)
 256 {
 257     if (err) {
 258         ze = zip_error_code_zip(err);
 259         if (zip_error_system_type(err) == ZIP_ET_SYS) {
 260             errno = zip_error_code_system(err);
 261         }
 262     }
 263 
 264     if (zep)
 265         *zep = ze;
 266 }
 267 
 268 
 269 /* _zip_readcdir:
 270    tries to find a valid end-of-central-directory at the beginning of
 271    buf, and then the corresponding central directory entries.
 272    Returns a struct zip_cdir which contains the central directory 
 273    entries, or NULL if unsuccessful. */
 274 
 275 static zip_cdir_t *
 276 _zip_read_cdir(zip_t *za, zip_buffer_t *buffer, zip_uint64_t buf_offset, zip_error_t *error)
 277 {
 278     zip_cdir_t *cd;
 279     zip_uint16_t comment_len;
 280     zip_uint64_t i, left;
 281     zip_uint64_t eocd_offset = _zip_buffer_offset(buffer);
 282     zip_buffer_t *cd_buffer;
 283 
 284     if (_zip_buffer_left(buffer) < EOCDLEN) {
 285         /* not enough bytes left for comment */
 286         zip_error_set(error, ZIP_ER_NOZIP, 0);
 287         return NULL;
 288     }
 289     
 290     /* check for end-of-central-dir magic */
 291     if (memcmp(_zip_buffer_get(buffer, 4), EOCD_MAGIC, 4) != 0) {
 292         zip_error_set(error, ZIP_ER_NOZIP, 0);
 293         return NULL;
 294     }
 295 
 296     if (eocd_offset >= EOCD64LOCLEN && memcmp(_zip_buffer_data(buffer) + eocd_offset - EOCD64LOCLEN, EOCD64LOC_MAGIC, 4) == 0) {
 297         _zip_buffer_set_offset(buffer, eocd_offset - EOCD64LOCLEN);
 298         cd = _zip_read_eocd64(za->src, buffer, buf_offset, za->flags, error);
 299     }
 300     else {
 301         _zip_buffer_set_offset(buffer, eocd_offset);
 302         cd = _zip_read_eocd(buffer, buf_offset, za->flags, error);
 303     }
 304 
 305     if (cd == NULL)
 306         return NULL;
 307 
 308     _zip_buffer_set_offset(buffer, eocd_offset + 20);
 309     comment_len = _zip_buffer_get_16(buffer);
 310 
 311     if (cd->offset + cd->size > buf_offset + eocd_offset) {
 312         /* cdir spans past EOCD record */
 313         zip_error_set(error, ZIP_ER_INCONS, 0);
 314         _zip_cdir_free(cd);
 315         return NULL;
 316     }
 317 
 318     if (comment_len || (za->open_flags & ZIP_CHECKCONS)) {
 319         zip_uint64_t tail_len;
 320         
 321         _zip_buffer_set_offset(buffer, eocd_offset + EOCDLEN);
 322         tail_len = _zip_buffer_left(buffer);
 323         
 324         if (tail_len < comment_len || ((za->open_flags & ZIP_CHECKCONS) && tail_len != comment_len)) {
 325             zip_error_set(error, ZIP_ER_INCONS, 0);
 326             _zip_cdir_free(cd);
 327             return NULL;
 328         }
 329 
 330         if (comment_len) {
 331             if ((cd->comment=_zip_string_new(_zip_buffer_get(buffer, comment_len), comment_len, ZIP_FL_ENC_GUESS, error)) == NULL) {
 332                 _zip_cdir_free(cd);
 333                 return NULL;
 334             }
 335         }
 336     }
 337 
 338     if (cd->offset >= buf_offset) {
 339         zip_uint8_t *data;
 340         /* if buffer already read in, use it */
 341         _zip_buffer_set_offset(buffer, cd->offset - buf_offset);
 342         
 343         if ((data = _zip_buffer_get(buffer, cd->size)) == NULL) {
 344             zip_error_set(error, ZIP_ER_INCONS, 0);
 345             _zip_cdir_free(cd);
 346             return NULL;
 347         }
 348         if ((cd_buffer = _zip_buffer_new(data, cd->size)) == NULL) {
 349             zip_error_set(error, ZIP_ER_MEMORY, 0);
 350             _zip_cdir_free(cd);
 351             return NULL;
 352         }
 353     }
 354     else {
 355         cd_buffer = NULL;
 356         
 357         if (zip_source_seek(za->src, (zip_int64_t)cd->offset, SEEK_SET) < 0) {
 358             _zip_error_set_from_source(error, za->src);
 359             _zip_cdir_free(cd);
 360             return NULL;
 361         }
 362 
 363         /* possible consistency check: cd->offset = len-(cd->size+cd->comment_len+EOCDLEN) ? */
 364         if (zip_source_tell(za->src) != (zip_int64_t)cd->offset) {
 365             zip_error_set(error, ZIP_ER_NOZIP, 0);
 366             _zip_cdir_free(cd);
 367             return NULL;
 368         }
 369     }
 370 
 371     left = (zip_uint64_t)cd->size;
 372     i=0;
 373     while (i<cd->nentry && left > 0) {
 374         zip_int64_t entry_size;
 375         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) {
 376             _zip_cdir_free(cd);
 377             _zip_buffer_free(cd_buffer);
 378             return NULL;
 379         }
 380         i++;
 381         left -= (zip_uint64_t)entry_size;
 382     }
 383     
 384     if (i != cd->nentry) {
 385         zip_error_set(error, ZIP_ER_INCONS, 0);
 386         _zip_buffer_free(cd_buffer);
 387         _zip_cdir_free(cd);
 388         return NULL;
 389     }
 390     
 391     if (za->open_flags & ZIP_CHECKCONS) {
 392         bool ok;
 393         
 394         if (cd_buffer) {
 395             ok = _zip_buffer_eof(cd_buffer);
 396         }
 397         else {
 398             zip_int64_t offset = zip_source_tell(za->src);
 399             
 400             if (offset < 0) {
 401                 _zip_error_set_from_source(error, za->src);
 402                 _zip_buffer_free(cd_buffer);
 403                 _zip_cdir_free(cd);
 404                 return NULL;
 405             }
 406             ok = ((zip_uint64_t)offset == cd->offset + cd->size);
 407         }
 408         
 409         if (!ok) {
 410             zip_error_set(error, ZIP_ER_INCONS, 0);
 411             _zip_buffer_free(cd_buffer);
 412             _zip_cdir_free(cd);
 413             return NULL;
 414         }
 415     }
 416 
 417     _zip_buffer_free(cd_buffer);
 418     return cd;
 419 }
 420 
 421 
 422 /* _zip_checkcons:
 423    Checks the consistency of the central directory by comparing central
 424    directory entries with local headers and checking for plausible
 425    file and header offsets. Returns -1 if not plausible, else the
 426    difference between the lowest and the highest fileposition reached */
 427 
 428 static zip_int64_t
 429 _zip_checkcons(zip_t *za, zip_cdir_t *cd, zip_error_t *error)
 430 {
 431     zip_uint64_t i;
 432     zip_uint64_t min, max, j;
 433     struct zip_dirent temp;
 434 
 435     _zip_dirent_init(&temp);
 436     if (cd->nentry) {
 437         max = cd->entry[0].orig->offset;
 438         min = cd->entry[0].orig->offset;
 439     }
 440     else
 441         min = max = 0;
 442 
 443     for (i=0; i<cd->nentry; i++) {
 444         if (cd->entry[i].orig->offset < min)
 445             min = cd->entry[i].orig->offset;
 446         if (min > (zip_uint64_t)cd->offset) {
 447             zip_error_set(error, ZIP_ER_NOZIP, 0);
 448             return -1;
 449         }
 450         
 451         j = cd->entry[i].orig->offset + cd->entry[i].orig->comp_size
 452             + _zip_string_length(cd->entry[i].orig->filename) + LENTRYSIZE;
 453         if (j > max)
 454             max = j;
 455         if (max > (zip_uint64_t)cd->offset) {
 456             zip_error_set(error, ZIP_ER_NOZIP, 0);
 457             return -1;
 458         }
 459         
 460         if (zip_source_seek(za->src, (zip_int64_t)cd->entry[i].orig->offset, SEEK_SET) < 0) {
 461             _zip_error_set_from_source(error, za->src);
 462             return -1;
 463         }
 464         
 465         if (_zip_dirent_read(&temp, za->src, NULL, true, error) == -1) {
 466             _zip_dirent_finalize(&temp);
 467             return -1;
 468         }
 469         
 470         if (_zip_headercomp(cd->entry[i].orig, &temp) != 0) {
 471             zip_error_set(error, ZIP_ER_INCONS, 0);
 472             _zip_dirent_finalize(&temp);
 473             return -1;
 474         }
 475         
 476         cd->entry[i].orig->extra_fields = _zip_ef_merge(cd->entry[i].orig->extra_fields, temp.extra_fields);
 477         cd->entry[i].orig->local_extra_fields_read = 1;
 478         temp.extra_fields = NULL;
 479         
 480         _zip_dirent_finalize(&temp);
 481     }
 482 
 483     return (max-min) < ZIP_INT64_MAX ? (zip_int64_t)(max-min) : ZIP_INT64_MAX;
 484 }
 485 
 486 
 487 /* _zip_headercomp:
 488    compares a central directory entry and a local file header
 489    Return 0 if they are consistent, -1 if not. */
 490 
 491 static int
 492 _zip_headercomp(const zip_dirent_t *central, const zip_dirent_t *local)
 493 {
 494     if ((central->version_needed != local->version_needed)
 495 #if 0
 496         /* some zip-files have different values in local
 497            and global headers for the bitflags */
 498         || (central->bitflags != local->bitflags)
 499 #endif
 500         || (central->comp_method != local->comp_method)
 501         || (central->last_mod != local->last_mod)
 502         || !_zip_string_equal(central->filename, local->filename))
 503         return -1;
 504 
 505     if ((central->crc != local->crc) || (central->comp_size != local->comp_size)
 506         || (central->uncomp_size != local->uncomp_size)) {
 507         /* InfoZip stores valid values in local header even when data descriptor is used.
 508            This is in violation of the appnote. */
 509         if (((local->bitflags & ZIP_GPBF_DATA_DESCRIPTOR) == 0
 510              || local->crc != 0 || local->comp_size != 0 || local->uncomp_size != 0))
 511             return -1;
 512     }
 513 
 514     return 0;
 515 }
 516 
 517 
 518 static zip_t *
 519 _zip_allocate_new(zip_source_t *src, unsigned int flags, zip_error_t *error)
 520 {
 521     zip_t *za;
 522 
 523     if ((za = _zip_new(error)) == NULL) {
 524         return NULL;
 525     }
 526 
 527     za->src = src;
 528     za->open_flags = flags;
 529     if (flags & ZIP_RDONLY) {
 530         za->flags |= ZIP_AFL_RDONLY;
 531         za->ch_flags |= ZIP_AFL_RDONLY;
 532     }
 533     return za;
 534 }
 535 
 536 
 537 /*
 538  * tests for file existence
 539  */
 540 static exists_t
 541 _zip_file_exists(zip_source_t *src, zip_error_t *error)
 542 {
 543     struct zip_stat st;
 544 
 545     zip_stat_init(&st);
 546     if (zip_source_stat(src, &st) != 0) {
 547         zip_error_t *src_error = zip_source_error(src);
 548         if (zip_error_code_zip(src_error) == ZIP_ER_READ && zip_error_code_system(src_error) == ENOENT) {
 549             return EXISTS_NOT;
 550         }
 551         _zip_error_copy(error, src_error);
 552         return EXISTS_ERROR;
 553     }
 554 
 555     return (st.valid & ZIP_STAT_SIZE) && st.size == 0 ? EXISTS_EMPTY : EXISTS_NONEMPTY;
 556 }
 557 
 558 
 559 static zip_cdir_t *
 560 _zip_find_central_dir(zip_t *za, zip_uint64_t len)
 561 {
 562     zip_cdir_t *cdir, *cdirnew;
 563     zip_uint8_t *match;
 564     zip_int64_t buf_offset;
 565     zip_uint64_t buflen;
 566     zip_int64_t a;
 567     zip_int64_t best;
 568     zip_error_t error;
 569     zip_buffer_t *buffer;
 570 
 571     if (len < EOCDLEN) {
 572         zip_error_set(&za->error, ZIP_ER_NOZIP, 0);
 573         return NULL;
 574     }
 575 
 576     buflen = (len < CDBUFSIZE ? len : CDBUFSIZE);
 577     if (zip_source_seek(za->src, -(zip_int64_t)buflen, SEEK_END) < 0) {
 578         zip_error_t *src_error = zip_source_error(za->src);
 579         if (zip_error_code_zip(src_error) != ZIP_ER_SEEK || zip_error_code_system(src_error) != EFBIG) {
 580             /* seek before start of file on my machine */
 581             _zip_error_copy(&za->error, src_error);
 582             return NULL;
 583         }
 584     }
 585     if ((buf_offset = zip_source_tell(za->src)) < 0) {
 586         _zip_error_set_from_source(&za->error, za->src);
 587         return NULL;
 588     }
 589     
 590     if ((buffer = _zip_buffer_new_from_source(za->src, buflen, NULL, &za->error)) == NULL) {
 591         return NULL;
 592     }
 593 
 594     best = -1;
 595     cdir = NULL;
 596     if (buflen >= CDBUFSIZE) {
 597         /* EOCD64 locator is before EOCD, so leave place for it */
 598         _zip_buffer_set_offset(buffer, EOCD64LOCLEN);
 599     }
 600     zip_error_set(&error, ZIP_ER_NOZIP, 0);
 601 
 602     match = _zip_buffer_get(buffer, 0);
 603     while ((match=_zip_memmem(match, _zip_buffer_left(buffer)-(EOCDLEN-4), (const unsigned char *)EOCD_MAGIC, 4)) != NULL) {
 604         _zip_buffer_set_offset(buffer, (zip_uint64_t)(match - _zip_buffer_data(buffer)));
 605         if ((cdirnew = _zip_read_cdir(za, buffer, (zip_uint64_t)buf_offset, &error)) != NULL) {
 606             if (cdir) {
 607                 if (best <= 0) {
 608                     best = _zip_checkcons(za, cdir, &error);
 609                 }
 610                 
 611                 a = _zip_checkcons(za, cdirnew, &error);
 612                 if (best < a) {
 613                     _zip_cdir_free(cdir);
 614                     cdir = cdirnew;
 615                     best = a;
 616                 }
 617                 else {
 618                     _zip_cdir_free(cdirnew);
 619                 }
 620             }
 621             else {
 622                 cdir = cdirnew;
 623                 if (za->open_flags & ZIP_CHECKCONS)
 624                     best = _zip_checkcons(za, cdir, &error);
 625                 else {
 626                     best = 0;
 627                 }
 628             }
 629             cdirnew = NULL;
 630         }
 631         
 632         match++;
 633         _zip_buffer_set_offset(buffer, (zip_uint64_t)(match - _zip_buffer_data(buffer)));
 634     }
 635 
 636     _zip_buffer_free(buffer);
 637     
 638     if (best < 0) {
 639         _zip_error_copy(&za->error, &error);
 640         _zip_cdir_free(cdir);
 641         return NULL;
 642     }
 643 
 644     return cdir;
 645 }
 646 
 647 
 648 static unsigned char *
 649 _zip_memmem(const unsigned char *big, size_t biglen, const unsigned char *little, size_t littlelen)
 650 {
 651     const unsigned char *p;
 652     
 653     if ((biglen < littlelen) || (littlelen == 0))
 654         return NULL;
 655     p = big-1;
 656     while ((p=(const unsigned char *)
 657                 memchr(p+1, little[0], (size_t)(big-(p+1))+(size_t)(biglen-littlelen)+1)) != NULL) {
 658         if (memcmp(p+1, little+1, littlelen-1)==0)
 659             return (unsigned char *)p;
 660     }
 661 
 662     return NULL;
 663 }
 664 
 665 
 666 static zip_cdir_t *
 667 _zip_read_eocd(zip_buffer_t *buffer, zip_uint64_t buf_offset, unsigned int flags, zip_error_t *error)
 668 {
 669     zip_cdir_t *cd;
 670     zip_uint64_t i, nentry, size, offset, eocd_offset;
 671 
 672     if (_zip_buffer_left(buffer) < EOCDLEN) {
 673         zip_error_set(error, ZIP_ER_INCONS, 0);
 674         return NULL;
 675     }
 676     
 677     eocd_offset = _zip_buffer_offset(buffer);
 678 
 679     _zip_buffer_get(buffer, 4); /* magic already verified */
 680 
 681     if (_zip_buffer_get_32(buffer) != 0) {
 682         zip_error_set(error, ZIP_ER_MULTIDISK, 0);
 683         return NULL;
 684     }
 685 
 686     /* number of cdir-entries on this disk */
 687     i = _zip_buffer_get_16(buffer);
 688     /* number of cdir-entries */
 689     nentry = _zip_buffer_get_16(buffer);
 690 
 691     if (nentry != i) {
 692         zip_error_set(error, ZIP_ER_NOZIP, 0);
 693         return NULL;
 694     }
 695 
 696     size = _zip_buffer_get_32(buffer);
 697     offset = _zip_buffer_get_32(buffer);
 698 
 699     if (offset+size < offset) {
 700         zip_error_set(error, ZIP_ER_SEEK, EFBIG);
 701         return NULL;
 702     }
 703     
 704     if (offset+size > buf_offset + eocd_offset) {
 705         /* cdir spans past EOCD record */
 706         zip_error_set(error, ZIP_ER_INCONS, 0);
 707         return NULL;
 708     }
 709 
 710     if ((flags & ZIP_CHECKCONS) && offset+size != buf_offset + eocd_offset) {
 711         zip_error_set(error, ZIP_ER_INCONS, 0);
 712         return NULL;
 713     }
 714 
 715     if ((cd=_zip_cdir_new(nentry, error)) == NULL)
 716         return NULL;
 717 
 718     cd->size = size;
 719     cd->offset = offset;
 720     
 721     return cd;
 722 }
 723 
 724 
 725 static zip_cdir_t *
 726 _zip_read_eocd64(zip_source_t *src, zip_buffer_t *buffer, zip_uint64_t buf_offset, unsigned int flags, zip_error_t *error)
 727 {
 728     zip_cdir_t *cd;
 729     zip_uint64_t offset;
 730     zip_uint8_t eocd[EOCD64LEN];
 731     zip_uint64_t eocd_offset;
 732     zip_uint64_t size, nentry, i, eocdloc_offset;
 733     bool free_buffer;
 734     zip_uint32_t num_disks, num_disks64, eocd_disk, eocd_disk64;
 735 
 736     eocdloc_offset = _zip_buffer_offset(buffer);
 737     
 738     _zip_buffer_get(buffer, 4); /* magic already verified */
 739 
 740     num_disks = _zip_buffer_get_16(buffer);
 741     eocd_disk = _zip_buffer_get_16(buffer);
 742     eocd_offset = _zip_buffer_get_64(buffer);
 743     
 744     if (eocd_offset > ZIP_INT64_MAX || eocd_offset + EOCD64LEN < eocd_offset) {
 745         zip_error_set(error, ZIP_ER_SEEK, EFBIG);
 746         return NULL;
 747     }
 748 
 749     if (eocd_offset + EOCD64LEN > eocdloc_offset + buf_offset) {
 750         zip_error_set(error, ZIP_ER_INCONS, 0);
 751         return NULL;
 752     }
 753 
 754     if (eocd_offset >= buf_offset && eocd_offset + EOCD64LEN <= buf_offset + _zip_buffer_size(buffer)) {
 755         _zip_buffer_set_offset(buffer, eocd_offset - buf_offset);
 756         free_buffer = false;
 757     }
 758     else {
 759         if (zip_source_seek(src, (zip_int64_t)eocd_offset, SEEK_SET) < 0) {
 760             _zip_error_set_from_source(error, src);
 761             return NULL;
 762         }
 763         if ((buffer = _zip_buffer_new_from_source(src, EOCD64LEN, eocd, error)) == NULL) {
 764             return NULL;
 765         }
 766         free_buffer = true;
 767     }
 768 
 769     if (memcmp(_zip_buffer_get(buffer, 4), EOCD64_MAGIC, 4) != 0) {
 770         zip_error_set(error, ZIP_ER_INCONS, 0);
 771         if (free_buffer) {
 772             _zip_buffer_free(buffer);
 773         }
 774         return NULL;
 775     }
 776     
 777     size = _zip_buffer_get_64(buffer);
 778 
 779     if ((flags & ZIP_CHECKCONS) && size + eocd_offset + 12 != buf_offset + eocdloc_offset) {
 780         zip_error_set(error, ZIP_ER_INCONS, 0);
 781         if (free_buffer) {
 782             _zip_buffer_free(buffer);
 783         }
 784         return NULL;
 785     }
 786 
 787     _zip_buffer_get(buffer, 4); /* skip version made by/needed */
 788 
 789     num_disks64 = _zip_buffer_get_32(buffer);
 790     eocd_disk64 = _zip_buffer_get_32(buffer);
 791 
 792     /* if eocd values are 0xffff, we have to use eocd64 values.
 793        otherwise, if the values are not the same, it's inconsistent;
 794        in any case, if the value is not 0, we don't support it */
 795     if (num_disks == 0xffff) {
 796         num_disks = num_disks64;
 797     }
 798     if (eocd_disk == 0xffff) {
 799         eocd_disk = eocd_disk64;
 800     }
 801     if ((flags & ZIP_CHECKCONS) && (eocd_disk != eocd_disk64 || num_disks != num_disks64)) {
 802         zip_error_set(error, ZIP_ER_INCONS, 0);
 803         return NULL;
 804     }
 805     if (num_disks != 0 || eocd_disk != 0) {
 806         zip_error_set(error, ZIP_ER_MULTIDISK, 0);
 807         return NULL;
 808     }
 809 
 810     nentry = _zip_buffer_get_64(buffer);
 811     i = _zip_buffer_get_64(buffer);
 812 
 813     if (nentry != i) {
 814         zip_error_set(error, ZIP_ER_MULTIDISK, 0);
 815         if (free_buffer) {
 816             _zip_buffer_free(buffer);
 817         }
 818         return NULL;
 819     }
 820 
 821     size = _zip_buffer_get_64(buffer);
 822     offset = _zip_buffer_get_64(buffer);
 823     
 824     if (!_zip_buffer_ok(buffer)) {
 825         zip_error_set(error, ZIP_ER_INTERNAL, 0);
 826         if (free_buffer) {
 827             _zip_buffer_free(buffer);
 828         }
 829         return NULL;
 830     }
 831 
 832     if (free_buffer) {
 833         _zip_buffer_free(buffer);
 834     }
 835 
 836     if (offset > ZIP_INT64_MAX || offset+size < offset) {
 837         zip_error_set(error, ZIP_ER_SEEK, EFBIG);
 838         return NULL;
 839     }
 840     if ((flags & ZIP_CHECKCONS) && offset+size != eocd_offset) {
 841         zip_error_set(error, ZIP_ER_INCONS, 0);
 842         return NULL;
 843     }
 844 
 845     if ((cd=_zip_cdir_new(nentry, error)) == NULL)
 846         return NULL;
 847 
 848     
 849     cd->size = size;
 850     cd->offset = offset;
 851 
 852     return cd;
 853 }
/* [<][>][^][v][top][bottom][index][help] */
root/ext/zip/lib/zip_open.c

DEFINITIONS
