![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to zipfile.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / bin / zip|
Return to zipfile.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin / zip |
1.1 ! root 1: /* ! 2: ! 3: Copyright (C) 1990-1992 Mark Adler, Richard B. Wales, Jean-loup Gailly, ! 4: Kai Uwe Rommel and Igor Mandrichenko. ! 5: Permission is granted to any individual or institution to use, copy, or ! 6: redistribute this software so long as all of the original files are included ! 7: unmodified, that it is not sold for profit, and that this copyright notice ! 8: is retained. ! 9: ! 10: */ ! 11: ! 12: /* ! 13: * zipfile.c by Mark Adler. ! 14: */ ! 15: ! 16: #include "zip.h" ! 17: ! 18: #ifdef VMS ! 19: # include "VMSmunch.h" ! 20: # include <rms.h> ! 21: #endif ! 22: ! 23: ! 24: /* Macros for converting integers in little-endian to machine format */ ! 25: #define SH(a) (((ush)(uch)(a)[0]) | (((ush)(uch)(a)[1]) << 8)) ! 26: #define LG(a) ((ulg)SH(a) | ((ulg)SH((a)+2) << 16)) ! 27: ! 28: /* Macros for writing machine integers to little-endian format */ ! 29: #define PUTSH(a,f) {putc((char)(a),(f)); putc((char)((a) >> 8),(f));} ! 30: #define PUTLG(a,f) {PUTSH(a,f) PUTSH((a) >> 16,f)} ! 31: ! 32: ! 33: /* -- Structure of a ZIP file -- */ ! 34: ! 35: /* Signatures for zip file information headers */ ! 36: #define LOCSIG 0x04034b50L ! 37: #define CENSIG 0x02014b50L ! 38: #define ENDSIG 0x06054b50L ! 39: #define EXTLOCSIG 0x08074b50L ! 40: ! 41: /* Offsets of values in headers */ ! 42: #define LOCVER 0 /* version needed to extract */ ! 43: #define LOCFLG 2 /* encrypt, deflate flags */ ! 44: #define LOCHOW 4 /* compression method */ ! 45: #define LOCTIM 6 /* last modified file time, DOS format */ ! 46: #define LOCDAT 8 /* last modified file date, DOS format */ ! 47: #define LOCCRC 10 /* uncompressed crc-32 for file */ ! 48: #define LOCSIZ 14 /* compressed size in zip file */ ! 49: #define LOCLEN 18 /* uncompressed size */ ! 50: #define LOCNAM 22 /* length of filename */ ! 51: #define LOCEXT 24 /* length of extra field */ ! 52: ! 53: #define CENVEM 0 /* version made by */ ! 54: #define CENVER 2 /* version needed to extract */ ! 55: #define CENFLG 4 /* encrypt, deflate flags */ ! 56: #define CENHOW 6 /* compression method */ ! 57: #define CENTIM 8 /* last modified file time, DOS format */ ! 58: #define CENDAT 10 /* last modified file date, DOS format */ ! 59: #define CENCRC 12 /* uncompressed crc-32 for file */ ! 60: #define CENSIZ 16 /* compressed size in zip file */ ! 61: #define CENLEN 20 /* uncompressed size */ ! 62: #define CENNAM 24 /* length of filename */ ! 63: #define CENEXT 26 /* length of extra field */ ! 64: #define CENCOM 28 /* file comment length */ ! 65: #define CENDSK 30 /* disk number start */ ! 66: #define CENATT 32 /* internal file attributes */ ! 67: #define CENATX 34 /* external file attributes */ ! 68: #define CENOFF 38 /* relative offset of local header */ ! 69: ! 70: #define ENDDSK 0 /* number of this disk */ ! 71: #define ENDBEG 2 /* number of the starting disk */ ! 72: #define ENDSUB 4 /* entries on this disk */ ! 73: #define ENDTOT 6 /* total number of entries */ ! 74: #define ENDSIZ 8 /* size of entire central directory */ ! 75: #define ENDOFF 12 /* offset of central on starting disk */ ! 76: #define ENDCOM 16 /* length of zip file comment */ ! 77: ! 78: ! 79: /* Local functions */ ! 80: #ifdef PROTO ! 81: local int zqcmp(voidp *, voidp *); ! 82: # ifndef UTIL ! 83: local int zbcmp(voidp *, voidp far *); ! 84: local char *cutpath(char *); ! 85: # endif /* !UTIL */ ! 86: #endif /* PROTO */ ! 87: ! 88: ! 89: local int zqcmp(a, b) ! 90: voidp *a, *b; /* pointers to pointers to zip entries */ ! 91: /* Used by qsort() to compare entries in the zfile list. */ ! 92: { ! 93: return namecmp((*(struct zlist far **)a)->zname, ! 94: (*(struct zlist far **)b)->zname); ! 95: } ! 96: ! 97: ! 98: #ifndef UTIL ! 99: ! 100: local int zbcmp(n, z) ! 101: voidp *n; /* string to search for */ ! 102: voidp far *z; /* pointer to a pointer to a zip entry */ ! 103: /* Used by search() to compare a target to an entry in the zfile list. */ ! 104: { ! 105: return namecmp((char *)n, ((struct zlist far *)z)->zname); ! 106: } ! 107: ! 108: ! 109: struct zlist far *zsearch(n) ! 110: char *n; /* name to find */ ! 111: /* Return a pointer to the entry in zfile with the name n, or NULL if ! 112: not found. */ ! 113: { ! 114: voidp far **p; /* result of search() */ ! 115: ! 116: if (zcount && (p = search(n, (voidp far **)zsort, zcount, zbcmp)) != NULL) ! 117: return *(struct zlist far **)p; ! 118: else ! 119: return NULL; ! 120: } ! 121: ! 122: #endif /* !UTIL */ ! 123: ! 124: #ifndef VMS ! 125: # define PATHCUT '/' ! 126: ! 127: char *ziptyp(s) ! 128: char *s; /* file name to force to zip */ ! 129: /* If the file name *s has a dot (other than the first char), then return ! 130: the name, otherwise append .zip to the name. Allocate the space for ! 131: the name in either case. Return a pointer to the new name, or NULL ! 132: if malloc() fails. */ ! 133: { ! 134: char *q; /* temporary pointer */ ! 135: char *t; /* pointer to malloc'ed string */ ! 136: ! 137: if ((t = malloc(strlen(s) + 5)) == NULL) ! 138: return NULL; ! 139: strcpy(t, s); ! 140: #ifdef MSDOS ! 141: for (q = t; *q; q++) ! 142: if (*q == '\\') ! 143: *q = '/'; ! 144: #endif /* MSDOS */ ! 145: if (strrchr((q = strrchr(t, PATHCUT)) == NULL ? t : q + 1, '.') == NULL) ! 146: strcat(t, ".zip"); ! 147: #if defined(FORCE_UPPER) && defined(MSDOS) && !defined(OS2) ! 148: strupr(t); ! 149: #endif ! 150: return t; ! 151: } ! 152: ! 153: #else /* VMS */ ! 154: ! 155: # define PATHCUT ']' ! 156: ! 157: char *ziptyp(s) ! 158: char *s; ! 159: { int status; ! 160: struct FAB fab; ! 161: struct NAM nam; ! 162: static char zero=0; ! 163: char result[NAM$C_MAXRSS+1],exp[NAM$C_MAXRSS+1]; ! 164: char *p; ! 165: ! 166: fab = cc$rms_fab; ! 167: nam = cc$rms_nam; ! 168: ! 169: fab.fab$l_fna = s; ! 170: fab.fab$b_fns = strlen(fab.fab$l_fna); ! 171: ! 172: fab.fab$l_dna = "sys$disk:[].zip"; /* Default fspec */ ! 173: fab.fab$b_dns = strlen(fab.fab$l_dna); ! 174: ! 175: fab.fab$l_nam = &nam; ! 176: ! 177: nam.nam$l_rsa = result; /* Put resultant name of */ ! 178: nam.nam$b_rss = sizeof(result)-1; /* existing zipfile here */ ! 179: ! 180: nam.nam$l_esa = exp; /* For full spec of */ ! 181: nam.nam$b_ess = sizeof(exp)-1; /* file to create */ ! 182: ! 183: status = sys$parse(&fab); ! 184: if( (status & 1) == 0 ) ! 185: return &zero; ! 186: ! 187: status = sys$search(&fab); ! 188: if( status & 1 ) ! 189: { /* Existing ZIP file */ ! 190: int l; ! 191: if( (p=malloc( (l=nam.nam$b_rsl) + 1 )) != NULL ) ! 192: { result[l] = 0; ! 193: strcpy(p,result); ! 194: } ! 195: } ! 196: else ! 197: { /* New ZIP file */ ! 198: int l; ! 199: if( (p=malloc( (l=nam.nam$b_esl) + 1 )) != NULL ) ! 200: { exp[l] = 0; ! 201: strcpy(p,exp); ! 202: } ! 203: } ! 204: return p; ! 205: } ! 206: ! 207: #endif /* VMS */ ! 208: ! 209: ! 210: int readzipfile() ! 211: /* ! 212: Make first pass through zip file, reading information from local file ! 213: headers and then verifying that information with the central file ! 214: headers. Any deviation from the expected zip file format returns an ! 215: error. At the end, a sorted list of file names in the zip file is made ! 216: to facilitate searching by name. ! 217: ! 218: The name of the zip file is pointed to by the global "zipfile". The ! 219: globals zfiles, zcount, zcomlen, zcomment, and zsort are filled in. ! 220: Return an error code in the ZE_ class. ! 221: */ ! 222: { ! 223: char b[CENHEAD]; /* buffer for central headers */ ! 224: FILE *f; /* zip file */ ! 225: ush flg; /* general purpose bit flag */ ! 226: int m; /* mismatch flag */ ! 227: extent n; /* length of name */ ! 228: ulg p; /* current file offset */ ! 229: char r; /* holds reserved bits during memcmp() */ ! 230: ulg s; /* size of data, start of central */ ! 231: char *t; /* temporary variable */ ! 232: char far *u; /* temporary variable */ ! 233: struct zlist far * far *x; /* pointer last entry's link */ ! 234: struct zlist far *z; /* current zip entry structure */ ! 235: ! 236: /* Initialize zip file info */ ! 237: zipbeg = 0; ! 238: zfiles = NULL; /* Points to first header */ ! 239: zcomlen = 0; /* zip file comment length */ ! 240: ! 241: /* If zip file exists, read headers and check structure */ ! 242: #ifdef VMS ! 243: if (zipfile == NULL || !(*zipfile) || !strcmp(zipfile, "-")) ! 244: return ZE_OK; ! 245: { ! 246: int rtype; ! 247: VMSmunch(zipfile, GET_RTYPE, (char *)&rtype); ! 248: if (rtype == FAT$C_VARIABLE) { ! 249: fprintf(stderr, ! 250: "\n Error: zipfile is in variable-length record format. Please\n\ ! 251: run \"bilf b %s\" to convert the zipfile to fixed-length\n\ ! 252: record format. (Bilf.exe, bilf.c and make_bilf.com are included\n\ ! 253: in the VMS UnZip distribution.)\n\n", zipfile); ! 254: return ZE_FORM; ! 255: } ! 256: } ! 257: if ((f = fopen(zipfile, FOPR)) != NULL) ! 258: #else /* !VMS */ ! 259: if (zipfile != NULL && *zipfile && strcmp(zipfile, "-") && ! 260: (f = fopen(zipfile, FOPR)) != NULL) ! 261: #endif /* ?VMS */ ! 262: { ! 263: x = &zfiles; /* first link */ ! 264: p = 0; /* starting file offset */ ! 265: zcount = 0; /* number of files */ ! 266: ! 267: /* Find start of zip structures */ ! 268: for (;;) { ! 269: while ((m = getc(f)) != EOF && m != 'P') p++; ! 270: b[0] = (char) m; ! 271: if (fread(b+1, 3, 1, f) != 1 || (s = LG(b)) == LOCSIG || s == ENDSIG) ! 272: break; ! 273: if (fseek(f, -3L, SEEK_CUR)) ! 274: return ferror(f) ? ZE_READ : ZE_EOF; ! 275: p++; ! 276: } ! 277: zipbeg = p; ! 278: ! 279: /* Read local headers */ ! 280: while (LG(b) == LOCSIG) ! 281: { ! 282: /* Read local header raw to compare later with central header ! 283: (this requires that the offest of ext in the zlist structure ! 284: be greater than or equal to LOCHEAD) */ ! 285: if ((z = (struct zlist far *)farmalloc(sizeof(struct zlist))) == NULL) ! 286: return ZE_MEM; ! 287: if (fread(b, LOCHEAD, 1, f) != 1) ! 288: return ferror(f) ? ZE_READ : ZE_EOF; ! 289: t = b; u = (char far *)z; n = LOCHEAD; ! 290: do { ! 291: *u++ = *t++; ! 292: } while (--n); ! 293: ! 294: /* Link into list */ ! 295: *x = z; ! 296: z->nxt = NULL; ! 297: x = &z->nxt; ! 298: ! 299: /* Read file name and extra field and skip data */ ! 300: n = SH(LOCNAM + (uch far *)z); ! 301: z->ext = SH(LOCEXT + (uch far *)z); ! 302: s = LG(LOCSIZ + (uch far *)z); ! 303: if (n == 0) ! 304: { ! 305: sprintf(errbuf, "%d", zcount + 1); ! 306: warn("zero-length name for entry #", errbuf); ! 307: return ZE_FORM; ! 308: } ! 309: if ((z->zname = malloc(n+1)) == NULL || ! 310: (z->ext && (z->extra = malloc(z->ext)) == NULL)) ! 311: return ZE_MEM; ! 312: if (fread(z->zname, n, 1, f) != 1 || ! 313: (z->ext && fread(z->extra, z->ext, 1, f) != 1) || ! 314: fseek(f, (long)s, SEEK_CUR)) ! 315: return ferror(f) ? ZE_READ : ZE_EOF; ! 316: /* If there is an extended local header, s is either 0 or ! 317: * the correct compressed size. ! 318: */ ! 319: z->zname[n] = 0; /* terminate name */ ! 320: #ifdef UTIL ! 321: z->name = z->zname; ! 322: #else /* !UTIL */ ! 323: z->name = in2ex(z->zname); /* convert to external name */ ! 324: if (z->name == NULL) ! 325: return ZE_MEM; ! 326: #endif /* ?UTIL */ ! 327: ! 328: /* Save offset, update for next header */ ! 329: z->off = p; ! 330: p += 4 + LOCHEAD + n + z->ext + s; ! 331: zcount++; ! 332: ! 333: /* Skip extended local header if there is one */ ! 334: flg = SH(b+LOCFLG); ! 335: if ((flg & 8) != 0) { ! 336: /* Skip the compressed data if compressed size is unknown. ! 337: * For safety, we should use the central directory. ! 338: */ ! 339: if (s == 0) { ! 340: for (;;) { ! 341: while ((m = getc(f)) != EOF && m != 'P') ; ! 342: b[0] = (char) m; ! 343: if (fread(b+1, 15, 1, f) != 1 || LG(b) == EXTLOCSIG) ! 344: break; ! 345: if (fseek(f, -15L, SEEK_CUR)) ! 346: return ferror(f) ? ZE_READ : ZE_EOF; ! 347: } ! 348: s = LG(b+8); ! 349: p += s; ! 350: if ((ulg) ftell(f) != p+16L) { ! 351: warn("bad extended local header for ", z->zname); ! 352: return ZE_FORM; ! 353: } ! 354: } else { ! 355: /* compressed size non zero, assume that it is valid: */ ! 356: if (fseek(f, p, SEEK_SET) || fread(b, 16, 1, f) != 1) ! 357: return ferror(f) ? ZE_READ : ZE_EOF; ! 358: if (LG(b) != EXTLOCSIG) { ! 359: warn("extended local header not found for ", z->zname); ! 360: return ZE_FORM; ! 361: } ! 362: } ! 363: /* overwrite the unknown values of the local header: */ ! 364: t = b+4; u = (char far *)z+LOCCRC; n = 12; ! 365: do { ! 366: *u++ = *t++; ! 367: } while (--n); ! 368: p += 16L; ! 369: } ! 370: /* Read next signature */ ! 371: if (fread(b, 4, 1, f) != 1) ! 372: return ferror(f) ? ZE_READ : ZE_EOF; ! 373: } ! 374: ! 375: /* Point to start of header list and read central headers */ ! 376: z = zfiles; ! 377: s = p; /* save start of central */ ! 378: while (LG(b) == CENSIG) ! 379: { ! 380: if (z == NULL) ! 381: { ! 382: warn("extraneous central header signature", ""); ! 383: return ZE_FORM; ! 384: } ! 385: ! 386: /* Read central header */ ! 387: if (fread(b, CENHEAD, 1, f) != 1) ! 388: return ferror(f) ? ZE_READ : ZE_EOF; ! 389: ! 390: /* Compare local header with that part of central header (except ! 391: for the reserved bits in the general purpose flags and except ! 392: for length of extra fields--authentication can make these ! 393: different in central and local headers) */ ! 394: z->lflg = SH(LOCFLG + (uch far *)z); /* Save reserved bits */ ! 395: r = b[CENFLG+1]; ! 396: ((uch far *)z)[LOCFLG+1] &= 0x1f; /* Zero out reserved bits */ ! 397: b[CENFLG+1] &= 0x1f; ! 398: for (m = 0, u = (char far *)z, n = 0; n < LOCHEAD - 2; n++) ! 399: if (u[n] != b[n+2]) ! 400: { ! 401: if (!m) ! 402: warn("local and central headers differ for ", z->zname); ! 403: m = 1; ! 404: sprintf(errbuf, " offset %d--local = %02x, central = %02x", ! 405: n, (uch)u[n], (uch)b[n+2]); ! 406: warn(errbuf, ""); ! 407: } ! 408: if (m) ! 409: return ZE_FORM; ! 410: b[CENFLG+1] = r; /* Restore reserved bits */ ! 411: ! 412: /* Overwrite local header with translated central header */ ! 413: z->vem = SH(CENVEM + b); ! 414: z->ver = SH(CENVER + b); ! 415: z->flg = SH(CENFLG + b); /* may be different from z->lflg */ ! 416: z->how = SH(CENHOW + b); ! 417: z->tim = LG(CENTIM + b); /* time and date into one long */ ! 418: z->crc = LG(CENCRC + b); ! 419: z->siz = LG(CENSIZ + b); ! 420: z->len = LG(CENLEN + b); ! 421: z->nam = SH(CENNAM + b); ! 422: z->cext = SH(CENEXT + b); /* may be different from z->ext */ ! 423: z->com = SH(CENCOM + b); ! 424: z->dsk = SH(CENDSK + b); ! 425: z->att = SH(CENATT + b); ! 426: z->atx = LG(CENATX + b); ! 427: if (z->off != LG(CENOFF + b)) ! 428: { ! 429: warn("local offset in central header incorrect for ", z->zname); ! 430: return ZE_FORM; ! 431: } ! 432: ! 433: /* Compare name and extra fields and read comment field */ ! 434: if ((t = malloc(z->nam)) == NULL) ! 435: return ZE_MEM; ! 436: if (fread(t, z->nam, 1, f) != 1) ! 437: { ! 438: free((voidp *)t); ! 439: return ferror(f) ? ZE_READ : ZE_EOF; ! 440: } ! 441: if (memcmp(t, z->zname, z->nam)) ! 442: { ! 443: free((voidp *)t); ! 444: warn("names in local and central differ for ", z->zname); ! 445: return ZE_FORM; ! 446: } ! 447: free((voidp *)t); ! 448: if (z->cext) ! 449: { ! 450: if ((z->cextra = malloc(z->cext)) == NULL) ! 451: return ZE_MEM; ! 452: if (fread(z->cextra, z->cext, 1, f) != 1) ! 453: { ! 454: free((voidp *)(z->cextra)); ! 455: return ferror(f) ? ZE_READ : ZE_EOF; ! 456: } ! 457: if (z->ext == z->cext && memcmp(z->extra, z->cextra, z->ext) == 0) ! 458: { ! 459: free((voidp *)(z->cextra)); ! 460: z->cextra = z->extra; ! 461: } ! 462: } ! 463: if (z->com) ! 464: { ! 465: if ((z->comment = malloc(z->com)) == NULL) ! 466: return ZE_MEM; ! 467: if (fread(z->comment, z->com, 1, f) != 1) ! 468: { ! 469: free((voidp *)(z->comment)); ! 470: return ferror(f) ? ZE_READ : ZE_EOF; ! 471: } ! 472: } ! 473: ! 474: /* Note oddities */ ! 475: if (verbose) ! 476: { ! 477: if (z->vem != 10 && z->vem != 11 && z->vem != 20 && ! 478: (n = z->vem >> 8) != 3 && n != 2 && n != 6 && n != 0) ! 479: { ! 480: sprintf(errbuf, "made by version %d.%d on system type %d: ", ! 481: (ush)(z->vem & 0xff) / (ush)10, ! 482: (ush)(z->vem & 0xff) % (ush)10, z->vem >> 8); ! 483: warn(errbuf, z->zname); ! 484: } ! 485: if (z->ver != 10 && z->ver != 11 && z->ver != 20) ! 486: { ! 487: sprintf(errbuf, "needs unzip %d.%d on system type %d: ", ! 488: (ush)(z->ver & 0xff) / (ush)10, ! 489: (ush)(z->ver & 0xff) % (ush)10, z->ver >> 8); ! 490: warn(errbuf, z->zname); ! 491: } ! 492: if (z->flg != z->lflg) ! 493: { ! 494: sprintf(errbuf, "local flags = 0x%04x, central = 0x%04x: ", ! 495: z->lflg, z->flg); ! 496: warn(errbuf, z->zname); ! 497: } ! 498: else if (z->flg & ~0xf) ! 499: { ! 500: sprintf(errbuf, "undefined bits used in flags = 0x%04x: ", z->flg); ! 501: warn(errbuf, z->zname); ! 502: } ! 503: if (z->how > DEFLATE) ! 504: { ! 505: sprintf(errbuf, "unknown compression method %u: ", z->how); ! 506: warn(errbuf, z->zname); ! 507: } ! 508: if (z->dsk) ! 509: { ! 510: sprintf(errbuf, "starts on disk %u: ", z->dsk); ! 511: warn(errbuf, z->zname); ! 512: } ! 513: if (z->att & ~1) ! 514: { ! 515: sprintf(errbuf, "unknown internal attributes = 0x%04x: ", z->att); ! 516: warn(errbuf, z->zname); ! 517: } ! 518: if (((n = z->vem >> 8) != 3) && n != 2 && z->atx & ~0xffL) ! 519: { ! 520: sprintf(errbuf, "unknown external attributes = 0x%08lx: ", z->atx); ! 521: warn(errbuf, z->zname); ! 522: } ! 523: if (z->ext || z->cext) ! 524: if (z->ext == z->cext && z->extra == z->cextra) ! 525: { ! 526: sprintf(errbuf, "has %d bytes of extra data: ", z->ext); ! 527: warn(errbuf, z->zname); ! 528: } ! 529: else ! 530: { ! 531: sprintf(errbuf, ! 532: "local extra (%d bytes) != central extra (%d bytes): ", ! 533: z->ext, z->cext); ! 534: warn(errbuf, z->zname); ! 535: } ! 536: } ! 537: ! 538: /* Clear actions */ ! 539: z->mark = 0; ! 540: z->trash = 0; ! 541: ! 542: /* Update file offset */ ! 543: p += 4 + CENHEAD + z->nam + z->cext + z->com; ! 544: ! 545: /* Advance to next header structure */ ! 546: z = z->nxt; ! 547: ! 548: /* Read next signature */ ! 549: if (fread(b, 4, 1, f) != 1) ! 550: return ferror(f) ? ZE_READ : ZE_EOF; ! 551: } ! 552: ! 553: /* Read end header */ ! 554: if (z != NULL || LG(b) != ENDSIG) ! 555: { ! 556: warn("missing end signature--probably not a zip file (did you", ""); ! 557: warn("remember to use binary mode when you transferred it?)", ""); ! 558: return ZE_FORM; ! 559: } ! 560: if (fread(b, ENDHEAD, 1, f) != 1) ! 561: return ferror(f) ? ZE_READ : ZE_EOF; ! 562: if (SH(ENDDSK + b) || SH(ENDBEG + b) || ! 563: SH(ENDSUB + b) != SH(ENDTOT + b)) ! 564: warn("multiple disk information ignored", ""); ! 565: if (zcount != SH(ENDSUB + b)) ! 566: { ! 567: warn("count in end of central directory incorrect", ""); ! 568: return ZE_FORM; ! 569: } ! 570: if (LG(ENDSIZ + b) != p - s) ! 571: { ! 572: warn("central directory size is incorrect (made by stzip?)", ""); ! 573: /* stzip 0.9 gets this wrong, so be tolerant */ ! 574: /* return ZE_FORM; */ ! 575: } ! 576: if (LG(ENDOFF + b) != s) ! 577: { ! 578: warn("central directory start is incorrect", ""); ! 579: return ZE_FORM; ! 580: } ! 581: cenbeg = s; ! 582: zcomlen = SH(ENDCOM + b); ! 583: if (zcomlen) ! 584: { ! 585: if ((zcomment = malloc(zcomlen)) == NULL) ! 586: return ZE_MEM; ! 587: if (fread(zcomment, zcomlen, 1, f) != 1) ! 588: { ! 589: free((voidp *)zcomment); ! 590: return ferror(f) ? ZE_READ : ZE_EOF; ! 591: } ! 592: } ! 593: if (zipbeg) ! 594: { ! 595: sprintf(errbuf, " has a preamble of %ld bytes", zipbeg); ! 596: warn(zipfile, errbuf); ! 597: } ! 598: if (getc(f) != EOF) ! 599: warn("garbage at end of zip file ignored", ""); ! 600: ! 601: /* Done with zip file for now */ ! 602: fclose(f); ! 603: ! 604: /* If one or more files, sort by name */ ! 605: if (zcount) ! 606: { ! 607: if ((x = zsort = ! 608: (struct zlist far **)malloc(zcount * sizeof(struct zlist far *))) == ! 609: NULL) ! 610: return ZE_MEM; ! 611: for (z = zfiles; z != NULL; z = z->nxt) ! 612: *x++ = z; ! 613: qsort((char *)zsort, zcount, sizeof(struct zlist far *), zqcmp); ! 614: } ! 615: } ! 616: return ZE_OK; ! 617: } ! 618: ! 619: ! 620: int putlocal(z, f) ! 621: struct zlist far *z; /* zip entry to write local header for */ ! 622: FILE *f; /* file to write to */ ! 623: /* Write a local header described by *z to file *f. Return an error code ! 624: in the ZE_ class. */ ! 625: { ! 626: PUTLG(LOCSIG, f); ! 627: PUTSH(z->ver, f); ! 628: PUTSH(z->lflg, f); ! 629: PUTSH(z->how, f); ! 630: PUTLG(z->tim, f); ! 631: PUTLG(z->crc, f); ! 632: PUTLG(z->siz, f); ! 633: PUTLG(z->len, f); ! 634: PUTSH(z->nam, f); ! 635: PUTSH(z->ext, f); ! 636: if (fwrite(z->zname, 1, z->nam, f) != z->nam || ! 637: (z->ext && fwrite(z->extra, 1, z->ext, f) != z->ext)) ! 638: return ZE_TEMP; ! 639: return ZE_OK; ! 640: } ! 641: ! 642: int putextended(z, f) ! 643: struct zlist far *z; /* zip entry to write local header for */ ! 644: FILE *f; /* file to write to */ ! 645: /* Write an extended local header described by *z to file *f. ! 646: * Return an error code in the ZE_ class. */ ! 647: { ! 648: PUTLG(EXTLOCSIG, f); ! 649: PUTLG(z->crc, f); ! 650: PUTLG(z->siz, f); ! 651: PUTLG(z->len, f); ! 652: return ZE_OK; ! 653: } ! 654: ! 655: int putcentral(z, f) ! 656: struct zlist far *z; /* zip entry to write central header for */ ! 657: FILE *f; /* file to write to */ ! 658: /* Write a central header described by *z to file *f. Return an error code ! 659: in the ZE_ class. */ ! 660: { ! 661: PUTLG(CENSIG, f); ! 662: PUTSH(z->vem, f); ! 663: PUTSH(z->ver, f); ! 664: PUTSH(z->flg, f); ! 665: PUTSH(z->how, f); ! 666: PUTLG(z->tim, f); ! 667: PUTLG(z->crc, f); ! 668: PUTLG(z->siz, f); ! 669: PUTLG(z->len, f); ! 670: PUTSH(z->nam, f); ! 671: PUTSH(z->cext, f); ! 672: PUTSH(z->com, f); ! 673: PUTSH(z->dsk, f); ! 674: PUTSH(z->att, f); ! 675: PUTLG(z->atx, f); ! 676: PUTLG(z->off, f); ! 677: if (fwrite(z->zname, 1, z->nam, f) != z->nam || ! 678: (z->cext && fwrite(z->cextra, 1, z->cext, f) != z->cext) || ! 679: (z->com && fwrite(z->comment, 1, z->com, f) != z->com)) ! 680: return ZE_TEMP; ! 681: return ZE_OK; ! 682: } ! 683: ! 684: ! 685: int putend(n, s, c, m, z, f) ! 686: int n; /* number of entries in central directory */ ! 687: ulg s, c; /* size and offset of central directory */ ! 688: extent m; /* length of zip file comment (0 if none) */ ! 689: char *z; /* zip file comment if m != 0 */ ! 690: FILE *f; /* file to write to */ ! 691: /* Write the end of central directory data to file *f. Return an error code ! 692: in the ZE_ class. */ ! 693: { ! 694: PUTLG(ENDSIG, f); ! 695: PUTSH(0, f); ! 696: PUTSH(0, f); ! 697: PUTSH(n, f); ! 698: PUTSH(n, f); ! 699: PUTLG(s, f); ! 700: PUTLG(c, f); ! 701: PUTSH(m, f); ! 702: if (m && fwrite(z, 1, m, f) != m) ! 703: return ZE_TEMP; ! 704: return ZE_OK; ! 705: } ! 706: ! 707: ! 708: #ifndef UTIL ! 709: ! 710: local char *cutpath(p) ! 711: char *p; /* path string */ ! 712: /* Cut the last path component off the name *p in place. Return p. */ ! 713: { ! 714: char *r; /* pointer to last path delimiter */ ! 715: ! 716: #ifdef VMS /* change [w.x.y]z to [w.x]y.DIR */ ! 717: if ((r = strrchr(p, ']')) != NULL) ! 718: { ! 719: *r = 0; ! 720: if ((r = strrchr(p, '.')) != NULL) ! 721: { ! 722: *r = ']'; ! 723: strcat(r, ".DIR"); /* this assumes a little padding--see PAD */ ! 724: } ! 725: else ! 726: *p = 0; ! 727: } ! 728: else ! 729: *p = 0; ! 730: #else /* !VMS */ /* change w/x/y/z to w/x/y */ ! 731: if ((r = strrchr(p, '/')) != NULL) ! 732: *r = 0; ! 733: else ! 734: *p = 0; ! 735: #endif /* ?VMS */ ! 736: return p; ! 737: } ! 738: ! 739: ! 740: int trash() ! 741: /* Delete the compressed files and the directories that contained the deleted ! 742: files, if empty. Return an error code in the ZE_ class. Failure of ! 743: destroy() or deletedir() is ignored. */ ! 744: { ! 745: extent i; /* counter on deleted names */ ! 746: extent k; /* number of deleted directories this pass */ ! 747: extent n; /* number of deleted names left to handle */ ! 748: struct zlist far **s; /* table of zip entries to handle, sorted */ ! 749: struct zlist far *z; /* current zip entry */ ! 750: ! 751: /* Count and delete marked names */ ! 752: n = 0; ! 753: for (z = zfiles; z != NULL; z = z->nxt) ! 754: if (z->mark || z->trash) ! 755: { ! 756: if (z->zname[z->nam - 1] == '/') /* directory */ ! 757: z->mark = z->trash = 0; ! 758: else { ! 759: z->mark = 1; ! 760: n++; ! 761: if (verbose) ! 762: printf("zip diagnostic: trashing file %s\n", z->name); ! 763: destroy(z->name); ! 764: } ! 765: } ! 766: ! 767: /* Try to delete all paths that lead up to marked names */ ! 768: if (n) ! 769: { ! 770: if ((s = (struct zlist far **)malloc((n+1)*sizeof(struct zlist far *))) == ! 771: NULL || ! 772: (s[0] = (struct zlist far *)farmalloc(sizeof(struct zlist))) == NULL) ! 773: return ZE_MEM; ! 774: s[0]->name = ""; ! 775: s++; ! 776: do { ! 777: n = k = 0; ! 778: for (z = zfiles; z != NULL; z = z->nxt) ! 779: if (z->mark) ! 780: s[n++] = z; ! 781: qsort((char *)s, n, sizeof(struct zlist far *), zqcmp); ! 782: for (i = 0; i < n; i++) ! 783: if (*cutpath(s[i]->name) && strcmp(s[i]->name, s[i-1]->name)) ! 784: { ! 785: if (verbose) ! 786: printf("zip diagnostic: trashing directory %s (if empty)\n", ! 787: s[i]->name); ! 788: deletedir(s[i]->name); ! 789: k++; ! 790: } ! 791: else ! 792: s[i]->mark = 0; ! 793: } while (k); ! 794: farfree((voidp far *)((--s)[0])); ! 795: free((voidp *)s); ! 796: } ! 797: return ZE_OK; ! 798: } ! 799: ! 800: #endif /* !UTIL */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.