Annotation of embedaddon/php/ext/zip/lib/zip_open.c, revision 1.1
1.1 ! misho 1: /*
! 2: zip_open.c -- open zip archive
! 3: Copyright (C) 1999-2009 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:
! 36: #include <sys/stat.h>
! 37: #include <errno.h>
! 38: #include <limits.h>
! 39: #include <stdio.h>
! 40: #include <stdlib.h>
! 41: #include <string.h>
! 42:
! 43: #include "zipint.h"
! 44:
! 45: static void set_error(int *, struct zip_error *, int);
! 46: static struct zip *_zip_allocate_new(const char *, int *);
! 47: static int _zip_checkcons(FILE *, struct zip_cdir *, struct zip_error *);
! 48: static void _zip_check_torrentzip(struct zip *);
! 49: static struct zip_cdir *_zip_find_central_dir(FILE *, int, int *, off_t);
! 50: static int _zip_file_exists(const char *, int, int *);
! 51: static int _zip_headercomp(struct zip_dirent *, int,
! 52: struct zip_dirent *, int);
! 53: static unsigned char *_zip_memmem(const unsigned char *, int,
! 54: const unsigned char *, int);
! 55: static struct zip_cdir *_zip_readcdir(FILE *, unsigned char *, unsigned char *,
! 56: int, int, struct zip_error *);
! 57:
! 58:
! 59:
! 60: ZIP_EXTERN(struct zip *)
! 61: zip_open(const char *fn, int flags, int *zep)
! 62: {
! 63: FILE *fp;
! 64: struct zip *za;
! 65: struct zip_cdir *cdir;
! 66: int i;
! 67: off_t len;
! 68:
! 69: if (flags & ZIP_OVERWRITE) {
! 70: return _zip_allocate_new(fn, zep);
! 71: }
! 72:
! 73: switch (_zip_file_exists(fn, flags, zep)) {
! 74: case -1:
! 75: if (!(flags & ZIP_OVERWRITE)) {
! 76: return NULL;
! 77: }
! 78:
! 79: case 0:
! 80: return _zip_allocate_new(fn, zep);
! 81:
! 82: default:
! 83: break;
! 84: }
! 85:
! 86: if ((fp=fopen(fn, "rb")) == NULL) {
! 87: set_error(zep, NULL, ZIP_ER_OPEN);
! 88: return NULL;
! 89: }
! 90:
! 91: fseeko(fp, 0, SEEK_END);
! 92: len = ftello(fp);
! 93:
! 94: /* treat empty files as empty archives */
! 95: if (len == 0) {
! 96: if ((za=_zip_allocate_new(fn, zep)) == NULL)
! 97: fclose(fp);
! 98: else
! 99: za->zp = fp;
! 100: return za;
! 101: }
! 102:
! 103: cdir = _zip_find_central_dir(fp, flags, zep, len);
! 104: if (cdir == NULL) {
! 105: fclose(fp);
! 106: return NULL;
! 107: }
! 108:
! 109: if ((za=_zip_allocate_new(fn, zep)) == NULL) {
! 110: _zip_cdir_free(cdir);
! 111: fclose(fp);
! 112: return NULL;
! 113: }
! 114:
! 115: za->cdir = cdir;
! 116: za->zp = fp;
! 117:
! 118: if ((za->entry=(struct zip_entry *)malloc(sizeof(*(za->entry))
! 119: * cdir->nentry)) == NULL) {
! 120: set_error(zep, NULL, ZIP_ER_MEMORY);
! 121: _zip_free(za);
! 122: return NULL;
! 123: }
! 124: for (i=0; i<cdir->nentry; i++)
! 125: _zip_entry_new(za);
! 126:
! 127: _zip_check_torrentzip(za);
! 128: za->ch_flags = za->flags;
! 129:
! 130: return za;
! 131: }
! 132:
! 133:
! 134:
! 135: static void
! 136: set_error(int *zep, struct zip_error *err, int ze)
! 137: {
! 138: int se;
! 139:
! 140: if (err) {
! 141: _zip_error_get(err, &ze, &se);
! 142: if (zip_error_get_sys_type(ze) == ZIP_ET_SYS)
! 143: errno = se;
! 144: }
! 145:
! 146: if (zep)
! 147: *zep = ze;
! 148: }
! 149:
! 150:
! 151:
! 152: /* _zip_readcdir:
! 153: tries to find a valid end-of-central-directory at the beginning of
! 154: buf, and then the corresponding central directory entries.
! 155: Returns a struct zip_cdir which contains the central directory
! 156: entries, or NULL if unsuccessful. */
! 157:
! 158: static struct zip_cdir *
! 159: _zip_readcdir(FILE *fp, unsigned char *buf, unsigned char *eocd, int buflen,
! 160: int flags, struct zip_error *error)
! 161: {
! 162: struct zip_cdir *cd;
! 163: unsigned char *cdp, **bufp;
! 164: int i, comlen, nentry;
! 165: unsigned int left;
! 166:
! 167: comlen = buf + buflen - eocd - EOCDLEN;
! 168: if (comlen < 0) {
! 169: /* not enough bytes left for comment */
! 170: _zip_error_set(error, ZIP_ER_NOZIP, 0);
! 171: return NULL;
! 172: }
! 173:
! 174: /* check for end-of-central-dir magic */
! 175: if (memcmp(eocd, EOCD_MAGIC, 4) != 0) {
! 176: _zip_error_set(error, ZIP_ER_NOZIP, 0);
! 177: return NULL;
! 178: }
! 179:
! 180: if (memcmp(eocd+4, "\0\0\0\0", 4) != 0) {
! 181: _zip_error_set(error, ZIP_ER_MULTIDISK, 0);
! 182: return NULL;
! 183: }
! 184:
! 185: cdp = eocd + 8;
! 186: /* number of cdir-entries on this disk */
! 187: i = _zip_read2(&cdp);
! 188: /* number of cdir-entries */
! 189: nentry = _zip_read2(&cdp);
! 190:
! 191: if ((cd=_zip_cdir_new(nentry, error)) == NULL)
! 192: return NULL;
! 193:
! 194: cd->size = _zip_read4(&cdp);
! 195: cd->offset = _zip_read4(&cdp);
! 196: cd->comment = NULL;
! 197: cd->comment_len = _zip_read2(&cdp);
! 198:
! 199: if ((comlen < cd->comment_len) || (cd->nentry != i)) {
! 200: _zip_error_set(error, ZIP_ER_NOZIP, 0);
! 201: free(cd);
! 202: return NULL;
! 203: }
! 204: if ((flags & ZIP_CHECKCONS) && comlen != cd->comment_len) {
! 205: _zip_error_set(error, ZIP_ER_INCONS, 0);
! 206: free(cd);
! 207: return NULL;
! 208: }
! 209:
! 210: if (cd->comment_len) {
! 211: if ((cd->comment=(char *)_zip_memdup(eocd+EOCDLEN,
! 212: cd->comment_len, error))
! 213: == NULL) {
! 214: free(cd);
! 215: return NULL;
! 216: }
! 217: }
! 218:
! 219: if (cd->size < (unsigned int)(eocd-buf)) {
! 220: /* if buffer already read in, use it */
! 221: cdp = eocd - cd->size;
! 222: bufp = &cdp;
! 223: }
! 224: else {
! 225: /* go to start of cdir and read it entry by entry */
! 226: bufp = NULL;
! 227: clearerr(fp);
! 228: fseeko(fp, cd->offset, SEEK_SET);
! 229: /* possible consistency check: cd->offset =
! 230: len-(cd->size+cd->comment_len+EOCDLEN) ? */
! 231: if (ferror(fp) || ((unsigned long)ftello(fp) != cd->offset)) {
! 232: /* seek error or offset of cdir wrong */
! 233: if (ferror(fp))
! 234: _zip_error_set(error, ZIP_ER_SEEK, errno);
! 235: else
! 236: _zip_error_set(error, ZIP_ER_NOZIP, 0);
! 237: free(cd);
! 238: return NULL;
! 239: }
! 240: }
! 241:
! 242: left = cd->size;
! 243: i=0;
! 244: do {
! 245: if (i == cd->nentry && left > 0) {
! 246: /* Infozip extension for more than 64k entries:
! 247: nentries wraps around, size indicates correct EOCD */
! 248: _zip_cdir_grow(cd, cd->nentry+0x10000, error);
! 249: }
! 250:
! 251: if ((_zip_dirent_read(cd->entry+i, fp, bufp, &left, 0, error)) < 0) {
! 252: cd->nentry = i;
! 253: _zip_cdir_free(cd);
! 254: return NULL;
! 255: }
! 256: i++;
! 257:
! 258: } while (i<cd->nentry);
! 259:
! 260: return cd;
! 261: }
! 262:
! 263:
! 264:
! 265: /* _zip_checkcons:
! 266: Checks the consistency of the central directory by comparing central
! 267: directory entries with local headers and checking for plausible
! 268: file and header offsets. Returns -1 if not plausible, else the
! 269: difference between the lowest and the highest fileposition reached */
! 270:
! 271: static int
! 272: _zip_checkcons(FILE *fp, struct zip_cdir *cd, struct zip_error *error)
! 273: {
! 274: int i;
! 275: unsigned int min, max, j;
! 276: struct zip_dirent temp;
! 277:
! 278: if (cd->nentry) {
! 279: max = cd->entry[0].offset;
! 280: min = cd->entry[0].offset;
! 281: }
! 282: else
! 283: min = max = 0;
! 284:
! 285: for (i=0; i<cd->nentry; i++) {
! 286: if (cd->entry[i].offset < min)
! 287: min = cd->entry[i].offset;
! 288: if (min > cd->offset) {
! 289: _zip_error_set(error, ZIP_ER_NOZIP, 0);
! 290: return -1;
! 291: }
! 292:
! 293: j = cd->entry[i].offset + cd->entry[i].comp_size
! 294: + cd->entry[i].filename_len + LENTRYSIZE;
! 295: if (j > max)
! 296: max = j;
! 297: if (max > cd->offset) {
! 298: _zip_error_set(error, ZIP_ER_NOZIP, 0);
! 299: return -1;
! 300: }
! 301:
! 302: if (fseeko(fp, cd->entry[i].offset, SEEK_SET) != 0) {
! 303: _zip_error_set(error, ZIP_ER_SEEK, 0);
! 304: return -1;
! 305: }
! 306:
! 307: if (_zip_dirent_read(&temp, fp, NULL, NULL, 1, error) == -1)
! 308: return -1;
! 309:
! 310: if (_zip_headercomp(cd->entry+i, 0, &temp, 1) != 0) {
! 311: _zip_error_set(error, ZIP_ER_INCONS, 0);
! 312: _zip_dirent_finalize(&temp);
! 313: return -1;
! 314: }
! 315: _zip_dirent_finalize(&temp);
! 316: }
! 317:
! 318: return max - min;
! 319: }
! 320:
! 321:
! 322:
! 323: /* _zip_check_torrentzip:
! 324: check wether ZA has a valid TORRENTZIP comment, i.e. is torrentzipped */
! 325:
! 326: static void
! 327: _zip_check_torrentzip(struct zip *za)
! 328: {
! 329: uLong crc_got, crc_should;
! 330: char buf[8+1];
! 331: char *end;
! 332:
! 333: if (za->zp == NULL || za->cdir == NULL)
! 334: return;
! 335:
! 336: if (za->cdir->comment_len != TORRENT_SIG_LEN+8
! 337: || strncmp(za->cdir->comment, TORRENT_SIG, TORRENT_SIG_LEN) != 0)
! 338: return;
! 339:
! 340: memcpy(buf, za->cdir->comment+TORRENT_SIG_LEN, 8);
! 341: buf[8] = '\0';
! 342: errno = 0;
! 343: crc_should = strtoul(buf, &end, 16);
! 344: if ((crc_should == UINT_MAX && errno != 0) || (end && *end))
! 345: return;
! 346:
! 347: if (_zip_filerange_crc(za->zp, za->cdir->offset, za->cdir->size,
! 348: &crc_got, NULL) < 0)
! 349: return;
! 350:
! 351: if (crc_got == crc_should)
! 352: za->flags |= ZIP_AFL_TORRENT;
! 353: }
! 354:
! 355:
! 356:
! 357:
! 358: /* _zip_headercomp:
! 359: compares two headers h1 and h2; if they are local headers, set
! 360: local1p or local2p respectively to 1, else 0. Return 0 if they
! 361: are identical, -1 if not. */
! 362:
! 363: static int
! 364: _zip_headercomp(struct zip_dirent *h1, int local1p, struct zip_dirent *h2,
! 365: int local2p)
! 366: {
! 367: if ((h1->version_needed != h2->version_needed)
! 368: #if 0
! 369: /* some zip-files have different values in local
! 370: and global headers for the bitflags */
! 371: || (h1->bitflags != h2->bitflags)
! 372: #endif
! 373: || (h1->comp_method != h2->comp_method)
! 374: || (h1->last_mod != h2->last_mod)
! 375: || (h1->filename_len != h2->filename_len)
! 376: || !h1->filename || !h2->filename
! 377: || strcmp(h1->filename, h2->filename))
! 378: return -1;
! 379:
! 380: /* check that CRC and sizes are zero if data descriptor is used */
! 381: if ((h1->bitflags & ZIP_GPBF_DATA_DESCRIPTOR) && local1p
! 382: && (h1->crc != 0
! 383: || h1->comp_size != 0
! 384: || h1->uncomp_size != 0))
! 385: return -1;
! 386: if ((h2->bitflags & ZIP_GPBF_DATA_DESCRIPTOR) && local2p
! 387: && (h2->crc != 0
! 388: || h2->comp_size != 0
! 389: || h2->uncomp_size != 0))
! 390: return -1;
! 391:
! 392: /* check that CRC and sizes are equal if no data descriptor is used */
! 393: if (((h1->bitflags & ZIP_GPBF_DATA_DESCRIPTOR) == 0 || local1p == 0)
! 394: && ((h2->bitflags & ZIP_GPBF_DATA_DESCRIPTOR) == 0 || local2p == 0)) {
! 395: if ((h1->crc != h2->crc)
! 396: || (h1->comp_size != h2->comp_size)
! 397: || (h1->uncomp_size != h2->uncomp_size))
! 398: return -1;
! 399: }
! 400:
! 401: if ((local1p == local2p)
! 402: && ((h1->extrafield_len != h2->extrafield_len)
! 403: || (h1->extrafield_len && h2->extrafield
! 404: && memcmp(h1->extrafield, h2->extrafield,
! 405: h1->extrafield_len))))
! 406: return -1;
! 407:
! 408: /* if either is local, nothing more to check */
! 409: if (local1p || local2p)
! 410: return 0;
! 411:
! 412: if ((h1->version_madeby != h2->version_madeby)
! 413: || (h1->disk_number != h2->disk_number)
! 414: || (h1->int_attrib != h2->int_attrib)
! 415: || (h1->ext_attrib != h2->ext_attrib)
! 416: || (h1->offset != h2->offset)
! 417: || (h1->comment_len != h2->comment_len)
! 418: || (h1->comment_len && h2->comment
! 419: && memcmp(h1->comment, h2->comment, h1->comment_len)))
! 420: return -1;
! 421:
! 422: return 0;
! 423: }
! 424:
! 425:
! 426:
! 427: static struct zip *
! 428: _zip_allocate_new(const char *fn, int *zep)
! 429: {
! 430: struct zip *za;
! 431: struct zip_error error;
! 432:
! 433: if ((za=_zip_new(&error)) == NULL) {
! 434: set_error(zep, &error, 0);
! 435: return NULL;
! 436: }
! 437:
! 438: za->zn = strdup(fn);
! 439: if (!za->zn) {
! 440: _zip_free(za);
! 441: set_error(zep, NULL, ZIP_ER_MEMORY);
! 442: return NULL;
! 443: }
! 444: return za;
! 445: }
! 446:
! 447:
! 448:
! 449: static int
! 450: _zip_file_exists(const char *fn, int flags, int *zep)
! 451: {
! 452: struct stat st;
! 453:
! 454: if (fn == NULL) {
! 455: set_error(zep, NULL, ZIP_ER_INVAL);
! 456: return -1;
! 457: }
! 458:
! 459: if (stat(fn, &st) != 0) {
! 460: if (flags & ZIP_CREATE || flags & ZIP_OVERWRITE)
! 461: return 0;
! 462: else {
! 463: set_error(zep, NULL, ZIP_ER_OPEN);
! 464: return -1;
! 465: }
! 466: }
! 467: else if ((flags & ZIP_EXCL)) {
! 468: set_error(zep, NULL, ZIP_ER_EXISTS);
! 469: return -1;
! 470: }
! 471: /* ZIP_CREATE gets ignored if file exists and not ZIP_EXCL,
! 472: just like open() */
! 473:
! 474: return 1;
! 475: }
! 476:
! 477:
! 478:
! 479: static struct zip_cdir *
! 480: _zip_find_central_dir(FILE *fp, int flags, int *zep, off_t len)
! 481: {
! 482: struct zip_cdir *cdir, *cdirnew;
! 483: unsigned char *buf, *match;
! 484: int a, best, buflen, i;
! 485: struct zip_error zerr;
! 486:
! 487: i = fseeko(fp, -(len < CDBUFSIZE ? len : CDBUFSIZE), SEEK_END);
! 488: if (i == -1 && errno != EFBIG) {
! 489: /* seek before start of file on my machine */
! 490: set_error(zep, NULL, ZIP_ER_SEEK);
! 491: return NULL;
! 492: }
! 493:
! 494: /* 64k is too much for stack */
! 495: if ((buf=(unsigned char *)malloc(CDBUFSIZE)) == NULL) {
! 496: set_error(zep, NULL, ZIP_ER_MEMORY);
! 497: return NULL;
! 498: }
! 499:
! 500: clearerr(fp);
! 501: buflen = fread(buf, 1, CDBUFSIZE, fp);
! 502:
! 503: if (ferror(fp)) {
! 504: set_error(zep, NULL, ZIP_ER_READ);
! 505: free(buf);
! 506: return NULL;
! 507: }
! 508:
! 509: best = -1;
! 510: cdir = NULL;
! 511: match = buf;
! 512: _zip_error_set(&zerr, ZIP_ER_NOZIP, 0);
! 513:
! 514: while ((match=_zip_memmem(match, buflen-(match-buf)-18,
! 515: (const unsigned char *)EOCD_MAGIC, 4))!=NULL) {
! 516: /* found match -- check, if good */
! 517: /* to avoid finding the same match all over again */
! 518: match++;
! 519: if ((cdirnew=_zip_readcdir(fp, buf, match-1, buflen, flags,
! 520: &zerr)) == NULL)
! 521: continue;
! 522:
! 523: if (cdir) {
! 524: if (best <= 0)
! 525: best = _zip_checkcons(fp, cdir, &zerr);
! 526: a = _zip_checkcons(fp, cdirnew, &zerr);
! 527: if (best < a) {
! 528: _zip_cdir_free(cdir);
! 529: cdir = cdirnew;
! 530: best = a;
! 531: }
! 532: else
! 533: _zip_cdir_free(cdirnew);
! 534: }
! 535: else {
! 536: cdir = cdirnew;
! 537: if (flags & ZIP_CHECKCONS)
! 538: best = _zip_checkcons(fp, cdir, &zerr);
! 539: else
! 540: best = 0;
! 541: }
! 542: cdirnew = NULL;
! 543: }
! 544:
! 545: free(buf);
! 546:
! 547: if (best < 0) {
! 548: set_error(zep, &zerr, 0);
! 549: _zip_cdir_free(cdir);
! 550: return NULL;
! 551: }
! 552:
! 553: return cdir;
! 554: }
! 555:
! 556:
! 557:
! 558: static unsigned char *
! 559: _zip_memmem(const unsigned char *big, int biglen, const unsigned char *little,
! 560: int littlelen)
! 561: {
! 562: const unsigned char *p;
! 563:
! 564: if ((biglen < littlelen) || (littlelen == 0))
! 565: return NULL;
! 566: p = big-1;
! 567: while ((p=(const unsigned char *)
! 568: memchr(p+1, little[0], (size_t)(big-(p+1)+biglen-littlelen+1)))
! 569: != NULL) {
! 570: if (memcmp(p+1, little+1, littlelen-1)==0)
! 571: return (unsigned char *)p;
! 572: }
! 573:
! 574: return NULL;
! 575: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to zip_open.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / zip / lib