![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to zip.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 zip.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: * zip.c by Mark Adler. ! 14: */ ! 15: ! 16: #include "revision.h" ! 17: #include "zip.h" ! 18: #ifdef VMS ! 19: # include "VMSmunch.h" ! 20: # define echon() echo(1) ! 21: #endif ! 22: #include <signal.h> ! 23: ! 24: #ifdef MACOS ! 25: # include <console.h> ! 26: #endif ! 27: ! 28: #define PWLEN 80 /* Input buffer size for reading encryption key */ ! 29: #define MAXCOM 256 /* Maximum one-line comment size */ ! 30: ! 31: ! 32: /* Local option flags */ ! 33: #define DELETE 0 ! 34: #define ADD 1 ! 35: #define UPDATE 2 ! 36: #define FRESHEN 3 ! 37: local int action = ADD; /* one of ADD, UPDATE, FRESHEN, or DELETE */ ! 38: local int comadd = 0; /* 1=add comments for new files */ ! 39: local int zipedit = 0; /* 1=edit zip comment and all file comments */ ! 40: local int dispose = 0; /* 1=remove files after put in zip file */ ! 41: local int latest = 0; /* 1=set zip file time to time of latest file */ ! 42: local ulg before = 0; /* 0=ignore, else exclude files before this time */ ! 43: ! 44: ! 45: /* Temporary zip file name and file pointer */ ! 46: local char *tempzip; ! 47: local FILE *tempzf; ! 48: ! 49: ! 50: /* Local functions */ ! 51: #ifdef PROTO ! 52: local void freeup(void); ! 53: local void leave(int); ! 54: local void handler(int); ! 55: local void license(void); ! 56: local void help(void); ! 57: local void zipstdout(void); ! 58: void main(int, char **); ! 59: local int count_args(char *s); ! 60: local void envargs(int *Pargc, char ***Pargv, char *envstr); ! 61: #endif /* PROTO */ ! 62: ! 63: ! 64: ! 65: local void freeup() ! 66: /* Free all allocations in the found list and the zfiles list */ ! 67: { ! 68: struct flist far *f; /* steps through found list */ ! 69: struct zlist far *z; /* pointer to next entry in zfiles list */ ! 70: ! 71: for (f = found; f != NULL; f = fexpel(f)) ! 72: ; ! 73: while (zfiles != NULL) ! 74: { ! 75: z = zfiles->nxt; ! 76: free((voidp *)(zfiles->name)); ! 77: free((voidp *)(zfiles->zname)); ! 78: if (zfiles->ext) ! 79: free((voidp *)(zfiles->extra)); ! 80: if (zfiles->cext && zfiles->cextra != zfiles->extra) ! 81: free((voidp *)(zfiles->cextra)); ! 82: if (zfiles->com) ! 83: free((voidp *)(zfiles->comment)); ! 84: farfree((voidp far *)zfiles); ! 85: zfiles = z; ! 86: zcount--; ! 87: } ! 88: } ! 89: ! 90: ! 91: local void leave(e) ! 92: int e; /* exit code */ ! 93: /* Process -o and -m options (if specified), free up malloc'ed stuff, and ! 94: exit with the code e. */ ! 95: { ! 96: int r; /* return value from trash() */ ! 97: ulg t; /* latest time in zip file */ ! 98: struct zlist far *z; /* pointer into zfile list */ ! 99: ! 100: /* If latest, set time to zip file to latest file in zip file */ ! 101: if (latest && strcmp(zipfile, "-")) ! 102: { ! 103: diag("changing time of zip file to time of latest file in it"); ! 104: /* find latest time in zip file */ ! 105: if (zfiles == NULL) ! 106: warn("zip file is empty, can't make it as old as latest entry", ""); ! 107: else { ! 108: t = zfiles->tim; ! 109: for (z = zfiles->nxt; z != NULL; z = z->nxt) ! 110: if (t < z->tim) ! 111: t = z->tim; ! 112: /* set modified time of zip file to that time */ ! 113: stamp(zipfile, t); ! 114: } ! 115: } ! 116: if (tempath != NULL) ! 117: { ! 118: free((voidp *)tempath); ! 119: tempath = NULL; ! 120: } ! 121: if (zipfile != NULL) ! 122: { ! 123: free((voidp *)zipfile); ! 124: zipfile = NULL; ! 125: } ! 126: ! 127: ! 128: /* If dispose, delete all files in the zfiles list that are marked */ ! 129: if (dispose) ! 130: { ! 131: diag("deleting files that were added to zip file"); ! 132: if ((r = trash()) != ZE_OK) ! 133: err(r, "was deleting moved files and directories"); ! 134: } ! 135: ! 136: ! 137: /* Done! */ ! 138: freeup(); ! 139: #ifdef VMS ! 140: exit(0); ! 141: #else /* !VMS */ ! 142: exit(e); ! 143: #endif /* ?VMS */ ! 144: } ! 145: ! 146: ! 147: void err(c, h) ! 148: int c; /* error code from the ZE_ class */ ! 149: char *h; /* message about how it happened */ ! 150: /* Issue a message for the error, clean up files and memory, and exit. */ ! 151: { ! 152: static int error_level; ! 153: if (error_level++ > 0) exit(0); /* avoid recursive err() */ ! 154: ! 155: if (PERR(c)) ! 156: perror("zip error"); ! 157: fprintf(stderr, "zip error: %s (%s)\n", errors[c-1], h); ! 158: if (tempzip != NULL) ! 159: { ! 160: if (tempzip != zipfile) { ! 161: if (tempzf != NULL) ! 162: fclose(tempzf); ! 163: #ifndef DEBUG ! 164: destroy(tempzip); ! 165: #endif ! 166: free((voidp *)tempzip); ! 167: } else { ! 168: /* -g option, attempt to restore the old file */ ! 169: int k = 0; /* keep count for end header */ ! 170: ulg cb = cenbeg; /* get start of central */ ! 171: struct zlist far *z; /* steps through zfiles linked list */ ! 172: ! 173: fprintf(stderr, "attempting to restore %s to its previous state\n", ! 174: zipfile); ! 175: fseek(tempzf, cenbeg, SEEK_SET); ! 176: tempzn = cenbeg; ! 177: for (z = zfiles; z != NULL; z = z->nxt) ! 178: { ! 179: putcentral(z, tempzf); ! 180: tempzn += 4 + CENHEAD + z->nam + z->cext + z->com; ! 181: k++; ! 182: } ! 183: putend(k, tempzn - cb, cb, zcomlen, zcomment, tempzf); ! 184: tempzf = NULL; ! 185: fclose(tempzf); ! 186: } ! 187: } ! 188: if (key != NULL) ! 189: free((voidp *)key); ! 190: if (tempath != NULL) ! 191: free((voidp *)tempath); ! 192: if (zipfile != NULL) ! 193: free((voidp *)zipfile); ! 194: freeup(); ! 195: #ifdef VMS ! 196: c = 0; ! 197: #endif ! 198: exit(c); ! 199: } ! 200: ! 201: ! 202: void error(h) ! 203: char *h; ! 204: /* Internal error, should never happen */ ! 205: { ! 206: err(ZE_LOGIC, h); ! 207: } ! 208: ! 209: local void handler(s) ! 210: int s; /* signal number (ignored) */ ! 211: /* Upon getting a user interrupt, turn echo back on for tty and abort ! 212: cleanly using err(). */ ! 213: { ! 214: #ifndef MSDOS ! 215: # ifdef CRYPT ! 216: echon(); ! 217: # endif ! 218: putc('\n', stderr); ! 219: #endif /* !MSDOS */ ! 220: err(ZE_ABORT, "aborting"); ! 221: s++; /* keep some compilers happy */ ! 222: } ! 223: ! 224: ! 225: void warn(a, b) ! 226: char *a, *b; /* message strings juxtaposed in output */ ! 227: /* Print a warning message to stderr and return. */ ! 228: { ! 229: fprintf(stderr, "zip warning: %s%s\n", a, b); ! 230: } ! 231: ! 232: ! 233: local void license() ! 234: /* Print license information to stdout. */ ! 235: { ! 236: extent i; /* counter for copyright array */ ! 237: ! 238: for (i = 0; i < sizeof(copyright)/sizeof(char *); i++) { ! 239: printf(copyright[i], "zip"); ! 240: putchar('\n'); ! 241: } ! 242: for (i = 0; i < sizeof(disclaimer)/sizeof(char *); i++) ! 243: puts(disclaimer[i]); ! 244: } ! 245: ! 246: ! 247: local void help() ! 248: /* Print help (along with license info) to stdout. */ ! 249: { ! 250: extent i; /* counter for help array */ ! 251: ! 252: /* help array */ ! 253: static char *text[] = { ! 254: "", ! 255: "Zip %d.%d (%s). Usage:", ! 256: "zip [-options] [-b path] [-t mmddyy] [-n suffixes] [zipfile list] [-x list]", ! 257: " The default action is to add or replace zipfile entries from list, which", ! 258: " can include the special name - to compress standard input.", ! 259: " If zipfile and list are ommitted, zip compresses stdin to stdout.", ! 260: " -f freshen: only changed files -u update: only changed or new files", ! 261: " -d delete entries in zipfile -m move into zipfile (delete files)", ! 262: " -k simulate PKZIP made zipfile -g allow growing existing zipfile", ! 263: " -h show this help -L show software license", ! 264: " -r recurse into directories -j junk (don't record) directory names", ! 265: " -0 store only -l translate end-of-line", ! 266: " -1 compress faster -9 compress better", ! 267: " -q quiet operation -n don't compress these suffixes", ! 268: " -c add one-line comments -z add zipfile comment", ! 269: " -b use \"path\" for temp files -t only do files after \"mmddyy\"", ! 270: " -@ read names from stdin -o make zipfile as old as latest entry", ! 271: #ifdef CRYPT ! 272: " -e encrypt (-ee verify key)", ! 273: #endif ! 274: #ifdef VMS ! 275: " -w append the VMS version number to the name stored in the zip file", ! 276: " -V save VMS file attributes", ! 277: #endif /* VMS */ ! 278: #ifdef OS2 ! 279: " -E use the .LONGNAME Extended attribute (if found) as filename", ! 280: #endif /* OS2 */ ! 281: #ifdef S_IFLNK ! 282: " -y store symbolic links as the link instead of the referenced file", ! 283: #endif /* !S_IFLNK */ ! 284: " -x exclude the names that follow from those operated on" ! 285: }; ! 286: ! 287: for (i = 0; i < sizeof(copyright)/sizeof(char *); i++) ! 288: { ! 289: printf(copyright[i], "zip"); ! 290: putchar('\n'); ! 291: } ! 292: for (i = 0; i < sizeof(text)/sizeof(char *); i++) ! 293: { ! 294: printf(text[i], REVISION / 10, REVISION % 10, REVDATE); ! 295: putchar('\n'); ! 296: } ! 297: } ! 298: ! 299: ! 300: /* Do command line expansion for MSDOS and VMS */ ! 301: #if defined(MSVMS) && !defined(__GO32__) ! 302: # define PROCNAME(n) (action==ADD||action==UPDATE?wild(n):procname(n)) ! 303: #else /* !MSVMS */ ! 304: # define PROCNAME(n) procname(n) ! 305: #endif /* ?MSVMS */ ! 306: ! 307: local void zipstdout() ! 308: /* setup for writing zip file on stdout */ ! 309: { ! 310: int r; ! 311: mesg = stderr; ! 312: if (isatty(1)) ! 313: err(ZE_PARMS, "no zip file provided"); ! 314: if ((zipfile = malloc(4)) == NULL) ! 315: err(ZE_MEM, "was processing arguments"); ! 316: strcpy(zipfile, "-"); ! 317: if ((r = readzipfile()) != ZE_OK) ! 318: err(r, zipfile); ! 319: } ! 320: ! 321: ! 322: void main(argc, argv) ! 323: int argc; /* number of tokens in command line */ ! 324: char **argv; /* command line tokens */ ! 325: /* Add, update, freshen, or delete zip entries in a zip file. See the ! 326: command help in help() above. */ ! 327: { ! 328: int a; /* attributes of zip file */ ! 329: ulg c; /* start of central directory */ ! 330: int d; /* true if just adding to a zip file */ ! 331: char *e; /* malloc'd comment buffer */ ! 332: struct flist far *f; /* steps through found linked list */ ! 333: int i; /* arg counter, root directory flag */ ! 334: int k; /* next argument type, marked counter, ! 335: comment size, entry count */ ! 336: ulg n; /* total of entry len's */ ! 337: int o; /* true if there were any ZE_OPEN errors */ ! 338: char *p; /* steps through option arguments */ ! 339: char *pp; /* temporary pointer */ ! 340: int r; /* temporary variable */ ! 341: ulg t; /* file time, length of central directory */ ! 342: struct zlist far *v; /* temporary variable */ ! 343: struct zlist far * far *w; /* pointer to last link in zfiles list */ ! 344: FILE *x, *y; /* input and output zip files */ ! 345: struct zlist far *z; /* steps through zfiles linked list */ ! 346: char *zipbuf; /* stdio buffer for the zip file */ ! 347: ! 348: mesg = (FILE *) stdout; /* cannot be made at link time for VMS */ ! 349: init_upper(); /* build case map table */ ! 350: ! 351: #ifdef MACOS ! 352: argc = ccommand(&argv); ! 353: #endif ! 354: ! 355: /* Process arguments */ ! 356: diag("processing arguments"); ! 357: if (argc == 1 && isatty(1)) ! 358: { ! 359: help(); ! 360: exit(0); ! 361: } ! 362: envargs(&argc, &argv, "ZIPOPT"); /* get options from environment */ ! 363: ! 364: zipfile = tempzip = NULL; ! 365: tempzf = NULL; ! 366: d = 0; /* disallow adding to a zip file */ ! 367: signal(SIGINT, handler); ! 368: signal(SIGTERM, handler); ! 369: k = 0; /* Next non-option argument type */ ! 370: for (i = 1; i < argc; i++) ! 371: { ! 372: if (argv[i][0] == '-') ! 373: if (argv[i][1]) ! 374: for (p = argv[i]+1; *p; p++) ! 375: switch(*p) ! 376: { ! 377: case '0': ! 378: method = STORE; level = 0; break; ! 379: case '1': case '2': case '3': case '4': ! 380: case '5': case '6': case '7': case '8': case '9': ! 381: /* Set the compression efficacy */ ! 382: level = *p - '0'; break; ! 383: case 'b': /* Specify path for temporary file */ ! 384: if (k != 0) ! 385: err(ZE_PARMS, "use -b before zip file name"); ! 386: else ! 387: k = 1; /* Next non-option is path */ ! 388: break; ! 389: case 'c': /* Add comments for new files in zip file */ ! 390: comadd = 1; break; ! 391: case 'd': /* Delete files from zip file */ ! 392: if (action != ADD) ! 393: err(ZE_PARMS, "specify just one action"); ! 394: action = DELETE; ! 395: break; ! 396: #ifdef CRYPT ! 397: case 'e': /* Encrypt */ ! 398: e = key == NULL ? (char *)NULL : key; ! 399: if ((key = malloc(PWLEN+1)) == NULL) ! 400: err(ZE_MEM, "was getting encryption password"); ! 401: if (getp(e == NULL ? "Enter password: " : "Verify password: ", ! 402: key, PWLEN+1) == NULL) ! 403: err(ZE_PARMS, "stderr is not a tty"); ! 404: if (e != NULL) ! 405: { ! 406: r = strcmp(key, e); ! 407: free((voidp *)e); ! 408: if (r) ! 409: err(ZE_PARMS, "password not verified"); ! 410: } ! 411: latest = 1; /* to make breaking the code harder */ ! 412: break; ! 413: #endif /* CRYPT */ ! 414: case 'f': /* Freshen zip file--overwrite only */ ! 415: if (action != ADD) ! 416: err(ZE_PARMS, "specify just one action"); ! 417: action = FRESHEN; ! 418: break; ! 419: case 'g': /* Allow appending to a zip file */ ! 420: d = 1; break; ! 421: case 'h': case 'H': case '?': /* Help */ ! 422: help(); ! 423: leave(ZE_OK); ! 424: case 'j': /* Junk directory names */ ! 425: pathput = 0; break; ! 426: case 'k': /* Make entries using DOS names (k for Katz) */ ! 427: dosify = 1; break; ! 428: case 'l': /* Translate end-of-line */ ! 429: translate_eol = 1; break; ! 430: case 'L': /* Show license, version */ ! 431: license(); ! 432: leave(ZE_OK); ! 433: case 'm': /* Delete files added or updated in zip file */ ! 434: dispose = 1; break; ! 435: case 'n': /* Don't compress files with a special suffix */ ! 436: special = NULL; ! 437: break; ! 438: case 'o': /* Set zip file time to time of latest file in it */ ! 439: latest = 1; break; ! 440: case 'p': /* Store path with name */ ! 441: break; /* (do nothing as annoyance avoidance) */ ! 442: case 'q': /* Quiet operation */ ! 443: noisy = 0; break; ! 444: case 'r': /* Recurse into subdirectories */ ! 445: recurse = 1; break; ! 446: case 't': /* Exclude files earlier than specified date */ ! 447: if (before) ! 448: err(ZE_PARMS, "can only have one -t"); ! 449: k = 2; break; ! 450: case 'u': /* Update zip file--overwrite only if newer */ ! 451: if (action != ADD) ! 452: err(ZE_PARMS, "specify just one action"); ! 453: action = UPDATE; ! 454: break; ! 455: case 'v': /* Mention oddities in zip file structure */ ! 456: verbose++; ! 457: break; ! 458: #ifdef VMS ! 459: case 'w': /* Append the VMS version number */ ! 460: vmsver = 1; break; ! 461: case 'V': /* Store in VMS format */ ! 462: vms_native = 1; break; ! 463: #endif /* VMS */ ! 464: case 'x': /* Exclude following files */ ! 465: if (k != 4 && ! 466: (k != 3 || (action != UPDATE && action != FRESHEN))) ! 467: err(ZE_PARMS, "nothing to exclude (-x) from"); ! 468: if (k == 3) /* must be -u or -f */ ! 469: for (z = zfiles; z != NULL; z = z->nxt) ! 470: z->mark = 1; /* mark all of them */ ! 471: k = 5; ! 472: if ((r = exclude()) != ZE_OK) ! 473: if (r == ZE_PARMS) ! 474: err(r, "cannot repeat names in zip file"); ! 475: else ! 476: err(r, "was processing list of files"); ! 477: break; ! 478: #ifdef S_IFLNK ! 479: case 'y': /* Store symbolic links as such */ ! 480: linkput = 1; break; ! 481: #endif /* S_IFLNK */ ! 482: case 'z': /* Edit zip file comment */ ! 483: zipedit = 1; break; ! 484: case '@': /* read file names from stdin */ ! 485: while ((pp = getnam(errbuf)) != NULL) ! 486: { ! 487: if ((r = PROCNAME(pp)) != ZE_OK) ! 488: if (r == ZE_MISS) ! 489: warn("name not matched: ", pp); ! 490: else ! 491: err(r, pp); ! 492: } ! 493: break; ! 494: #ifdef OS2 ! 495: case 'E': ! 496: /* use the .LONGNAME EA (if any) as the file's name. */ ! 497: use_longname_ea = 1; ! 498: break; ! 499: #endif ! 500: default: ! 501: { ! 502: sprintf(errbuf, "no such option: %c", *p); ! 503: err(ZE_PARMS, errbuf); ! 504: } ! 505: } ! 506: else /* just a dash */ ! 507: switch (k) ! 508: { ! 509: case 0: ! 510: zipstdout(); ! 511: k = 3; ! 512: break; ! 513: case 1: ! 514: err(ZE_PARMS, "invalid path"); ! 515: break; ! 516: case 2: ! 517: err(ZE_PARMS, "invalid time"); ! 518: break; ! 519: case 3: case 4: case 5: ! 520: if ((r = PROCNAME(argv[i])) != ZE_OK) ! 521: if (r == ZE_MISS) ! 522: warn("name not matched: ", argv[i]); ! 523: else ! 524: err(r, argv[i]); ! 525: if (k == 3) ! 526: k = 4; ! 527: } ! 528: else /* not an option */ ! 529: { ! 530: if (special == NULL) ! 531: special = argv[i]; ! 532: else ! 533: switch (k) ! 534: { ! 535: case 0: ! 536: if ((zipfile = ziptyp(argv[i])) == NULL) ! 537: err(ZE_MEM, "was processing arguments"); ! 538: if ((r = readzipfile()) != ZE_OK) ! 539: err(r, zipfile); ! 540: k = 3; ! 541: break; ! 542: case 1: ! 543: if ((tempath = malloc(strlen(argv[i]) + 1)) == NULL) ! 544: err(ZE_MEM, "was processing arguments"); ! 545: strcpy(tempath, argv[i]); ! 546: k = 0; ! 547: break; ! 548: case 2: ! 549: { ! 550: int yy, mm, dd; /* results of sscanf() */ ! 551: ! 552: if (sscanf(argv[i], "%2d%2d%2d", &mm, &dd, &yy) != 3 || ! 553: mm < 1 || mm > 12 || dd < 1 || dd > 31) ! 554: err(ZE_PARMS, "invalid date entered for -t option"); ! 555: before = dostime(yy + (yy < 80 ? 2000 : 1900), mm, dd, 0, 0, 0); ! 556: k = 0; ! 557: break; ! 558: } ! 559: case 3: case 4: case 5: ! 560: if ((r = PROCNAME(argv[i])) != ZE_OK) ! 561: if (r == ZE_MISS) ! 562: warn("name not matched: ", argv[i]); ! 563: else ! 564: err(r, argv[i]); ! 565: if (k == 3) ! 566: k = 4; ! 567: } ! 568: } ! 569: } ! 570: if (k < 3) { /* zip used as filter */ ! 571: zipstdout(); ! 572: if ((r = procname("-")) != ZE_OK) ! 573: if (r == ZE_MISS) ! 574: warn("name not matched: ", "-"); ! 575: else ! 576: err(r, "-"); ! 577: k = 4; ! 578: } ! 579: ! 580: if (k != 5) /* Clean up selections */ ! 581: { ! 582: if (k == 3 && (action == UPDATE || action == FRESHEN)) ! 583: for (z = zfiles; z != NULL; z = z->nxt) ! 584: z->mark = 1; /* if -u or -f with no args, do all */ ! 585: if ((r = exclude()) != ZE_OK) /* remove duplicates in found list */ ! 586: if (r == ZE_PARMS) ! 587: err(r, "cannot repeat names in zip file"); ! 588: else ! 589: err(r, "was processing list of files"); ! 590: } ! 591: if (zcount) ! 592: free((voidp *)zsort); ! 593: ! 594: /* Check option combinations */ ! 595: if (action == DELETE && (method != BEST || dispose || recurse || ! 596: key != NULL || comadd || zipedit)) ! 597: err(ZE_PARMS, "invalid option(s) used with -d"); ! 598: if (linkput && dosify) ! 599: err(ZE_PARMS, "can't use -y with -k"); ! 600: if ((action != ADD || d) && !strcmp(zipfile, "-")) ! 601: err(ZE_PARMS, "can't use -d,-f,-u or -g on standard output"); ! 602: #ifdef VMS ! 603: if (vms_native && translate_eol) ! 604: err(ZE_PARMS, "can't use -V with -l"); ! 605: #endif ! 606: if (zcount == 0 && (action != ADD || d)) ! 607: warn(zipfile, " not found or empty"); ! 608: ! 609: ! 610: /* If -b not specified, make temporary path the same as the zip file */ ! 611: #ifdef MSDOS ! 612: if (tempath == NULL && ((p = strrchr(zipfile, '/')) != NULL || ! 613: (p = strrchr(zipfile, '\\')) != NULL || ! 614: (p = strrchr(zipfile, ':')) != NULL)) ! 615: { ! 616: if (*p == ':') ! 617: p++; ! 618: #else /* !MSDOS */ ! 619: if (tempath == NULL && (p = strrchr(zipfile, '/')) != NULL) ! 620: { ! 621: #endif /* ?MSDOS */ ! 622: if ((tempath = malloc((int)(p - zipfile) + 1)) == NULL) ! 623: err(ZE_MEM, "was processing arguments"); ! 624: r = *p; *p = 0; ! 625: strcpy(tempath, zipfile); ! 626: *p = (char)r; ! 627: } ! 628: ! 629: /* For each marked entry, if not deleting, check if it exists, and if ! 630: updating or freshening, compare date with entry in old zip file. ! 631: Unmark if it doesn't exist or is too old, else update marked count. */ ! 632: diag("stating marked entries"); ! 633: k = 0; /* Initialize marked count */ ! 634: for (z = zfiles; z != NULL; z = z->nxt) ! 635: if (z->mark) ! 636: if (action != DELETE && ! 637: ((t = filetime(z->name, (ulg *)NULL, (long *)NULL)) == 0 || ! 638: t < before || ! 639: ((action == UPDATE || action == FRESHEN) && t <= z->tim))) ! 640: { ! 641: z->mark = 0; ! 642: z->trash = t && t >= before; /* delete if -um or -fm */ ! 643: if (verbose) ! 644: fprintf(mesg, "zip diagnostic: %s %s\n", z->name, ! 645: z->trash ? "up to date" : "missing or early"); ! 646: } ! 647: else ! 648: k++; ! 649: ! 650: ! 651: /* Remove entries from found list that do not exist or are too old */ ! 652: diag("stating new entries"); ! 653: for (f = found; f != NULL;) ! 654: if (action == DELETE || action == FRESHEN || ! 655: (t = filetime(f->name, (ulg *)NULL, (long *)NULL)) == 0 || ! 656: t < before || (namecmp(f->name, zipfile) == 0 && strcmp(zipfile, "-"))) ! 657: f = fexpel(f); ! 658: else ! 659: f = f->nxt; ! 660: ! 661: /* Make sure there's something left to do */ ! 662: if (k == 0 && found == NULL && !(zfiles != NULL && (latest || zipedit))) ! 663: if (action == UPDATE || action == FRESHEN) ! 664: leave(ZE_OK); ! 665: else if (zfiles == NULL && latest) ! 666: err(ZE_NAME, zipfile); ! 667: else ! 668: err(ZE_NONE, zipfile); ! 669: d = (d && k == 0 && (zipbeg || zfiles != NULL)); /* d true if appending */ ! 670: ! 671: ! 672: /* Before we get carried away, make sure zip file is writeable */ ! 673: if (strcmp(zipfile, "-")) ! 674: { ! 675: x = zfiles == NULL && zipbeg == 0 ? fopen(zipfile, FOPW) : ! 676: fopen(zipfile, FOPM); ! 677: /* Note: FOPW and FOPM expand to several parameters for VMS */ ! 678: if (x == NULL) ! 679: err(ZE_CREAT, zipfile); ! 680: fclose(x); ! 681: a = getfileattr(zipfile); ! 682: if (zfiles == NULL && zipbeg == 0) ! 683: destroy(zipfile); ! 684: } ! 685: else ! 686: a = 0; ! 687: ! 688: ! 689: /* Open zip file and temporary output file */ ! 690: diag("opening zip file and creating temporary zip file"); ! 691: x = NULL; ! 692: tempzn = 0; ! 693: if (strcmp(zipfile, "-") == 0) ! 694: { ! 695: #ifdef MSDOS ! 696: /* Set stdout mode to binary for MSDOS systems */ ! 697: setmode(fileno(stdout), O_BINARY); ! 698: tempzf = y = fdopen(fileno(stdout), FOPW); ! 699: #else ! 700: tempzf = y = stdout; ! 701: #endif ! 702: tempzip = "-"; ! 703: } ! 704: else if (d) /* d true if just appending (-g) */ ! 705: { ! 706: if ((y = fopen(zipfile, FOPM)) == NULL) ! 707: err(ZE_NAME, zipfile); ! 708: tempzip = zipfile; ! 709: tempzf = y; ! 710: if (fseek(y, cenbeg, SEEK_SET)) ! 711: err(ferror(y) ? ZE_READ : ZE_EOF, zipfile); ! 712: tempzn = cenbeg; ! 713: } ! 714: else ! 715: { ! 716: if ((zfiles != NULL || zipbeg) && (x = fopen(zipfile, FOPR_EX)) == NULL) ! 717: err(ZE_NAME, zipfile); ! 718: if ((tempzip = tempname(zipfile)) == NULL) ! 719: err(ZE_MEM, tempzip); ! 720: if ((tempzf = y = fopen(tempzip, FOPW)) == NULL) ! 721: err(ZE_TEMP, tempzip); ! 722: if (zipbeg && (r = fcopy(x, y, zipbeg)) != ZE_OK) ! 723: err(r, r == ZE_TEMP ? tempzip : zipfile); ! 724: tempzn = zipbeg; ! 725: } ! 726: #ifndef VMS ! 727: /* Use large buffer to speed up stdio: */ ! 728: zipbuf = (char *)malloc(ZBSZ); ! 729: if (zipbuf == NULL) ! 730: err(ZE_MEM, tempzip); ! 731: # ifdef _IOFBF ! 732: setvbuf(y, zipbuf, _IOFBF, ZBSZ); ! 733: # else ! 734: setbuf(y, zipbuf); ! 735: # endif /* _IOBUF */ ! 736: #endif /* VMS */ ! 737: o = 0; /* no ZE_OPEN errors yet */ ! 738: ! 739: ! 740: /* Process zip file, updating marked files */ ! 741: if (zfiles != NULL) ! 742: diag("going through old zip file"); ! 743: w = &zfiles; ! 744: while ((z = *w) != NULL) ! 745: if (z->mark) ! 746: { ! 747: /* if not deleting, zip it up */ ! 748: if (action != DELETE) ! 749: { ! 750: if (noisy) ! 751: { ! 752: fprintf(mesg, "updating %s", z->zname); ! 753: fflush(mesg); ! 754: } ! 755: if ((r = zipup(z, y)) != ZE_OK && r != ZE_OPEN) ! 756: { ! 757: if (noisy) ! 758: { ! 759: putc('\n', mesg); ! 760: fflush(mesg); ! 761: } ! 762: sprintf(errbuf, "was zipping %s", z->name); ! 763: err(r, errbuf); ! 764: } ! 765: if (r == ZE_OPEN) ! 766: { ! 767: o = 1; ! 768: if (noisy) ! 769: { ! 770: putc('\n', mesg); ! 771: fflush(mesg); ! 772: } ! 773: perror("zip warning"); ! 774: warn("could not open for reading: ", z->name); ! 775: warn("will just copy entry over: ", z->zname); ! 776: if ((r = zipcopy(z, x, y)) != ZE_OK) ! 777: { ! 778: sprintf(errbuf, "was copying %s", z->zname); ! 779: err(r, errbuf); ! 780: } ! 781: z->mark = 0; ! 782: } ! 783: w = &z->nxt; ! 784: } ! 785: else ! 786: { ! 787: if (noisy) ! 788: { ! 789: fprintf(mesg, "deleting %s\n", z->zname); ! 790: fflush(mesg); ! 791: } ! 792: v = z->nxt; /* delete entry from list */ ! 793: free((voidp *)(z->name)); ! 794: free((voidp *)(z->zname)); ! 795: if (z->ext) ! 796: free((voidp *)(z->extra)); ! 797: if (z->cext && z->cextra != z->extra) ! 798: free((voidp *)(z->cextra)); ! 799: if (z->com) ! 800: free((voidp *)(z->comment)); ! 801: farfree((voidp far *)z); ! 802: *w = v; ! 803: zcount--; ! 804: } ! 805: } ! 806: else ! 807: { ! 808: /* copy the original entry verbatim */ ! 809: if (!d && (r = zipcopy(z, x, y)) != ZE_OK) ! 810: { ! 811: sprintf(errbuf, "was copying %s", z->zname); ! 812: err(r, errbuf); ! 813: } ! 814: w = &z->nxt; ! 815: } ! 816: ! 817: ! 818: /* Process the edited found list, adding them to the zip file */ ! 819: diag("zipping up new entries, if any"); ! 820: for (f = found; f != NULL; f = fexpel(f)) ! 821: { ! 822: /* add a new zfiles entry and set the name */ ! 823: if ((z = (struct zlist far *)farmalloc(sizeof(struct zlist))) == NULL) ! 824: err(ZE_MEM, "was adding files to zip file"); ! 825: z->nxt = NULL; ! 826: z->name = f->name; ! 827: f->name = NULL; ! 828: z->zname = f->zname; ! 829: f->zname = NULL; ! 830: z->ext = z->cext = z->com = 0; ! 831: z->mark = 1; ! 832: z->dosflag = f->dosflag; ! 833: /* zip it up */ ! 834: if (noisy) ! 835: { ! 836: fprintf(mesg, "adding %s", z->zname); ! 837: fflush(mesg); ! 838: } ! 839: if ((r = zipup(z, y)) != ZE_OK && r != ZE_OPEN) ! 840: { ! 841: if (noisy) ! 842: { ! 843: putc('\n', mesg); ! 844: fflush(mesg); ! 845: } ! 846: sprintf(errbuf, "was zipping %s", z->name); ! 847: err(r, errbuf); ! 848: } ! 849: if (r == ZE_OPEN) ! 850: { ! 851: o = 1; ! 852: if (noisy) ! 853: { ! 854: putc('\n', mesg); ! 855: fflush(mesg); ! 856: } ! 857: perror("zip warning"); ! 858: warn("could not open for reading: ", z->name); ! 859: free((voidp *)(z->name)); ! 860: free((voidp *)(z->zname)); ! 861: farfree((voidp far *)z); ! 862: } ! 863: else ! 864: { ! 865: *w = z; ! 866: w = &z->nxt; ! 867: zcount++; ! 868: } ! 869: } ! 870: if (key != NULL) ! 871: { ! 872: free((voidp *)key); ! 873: key = NULL; ! 874: } ! 875: ! 876: ! 877: /* Get one line comment for each new entry */ ! 878: if (comadd) ! 879: { ! 880: if ((e = malloc(MAXCOM + 1)) == NULL) ! 881: err(ZE_MEM, "was reading comment lines"); ! 882: for (z = zfiles; z != NULL; z = z->nxt) ! 883: if (z->mark) ! 884: { ! 885: if (noisy) ! 886: fprintf(mesg, "Enter comment for %s:\n", z->name); ! 887: /* ??? reopen /dev/tty if one file was zipped from stdin ! 888: * or if file names were read from stdin. ! 889: */ ! 890: if (fgets(e, MAXCOM+1, stdin) != NULL) ! 891: { ! 892: if ((p = malloc((k = strlen(e))+1)) == NULL) ! 893: { ! 894: free((voidp *)e); ! 895: err(ZE_MEM, "was reading comment lines"); ! 896: } ! 897: strcpy(p, e); ! 898: if (p[k-1] == '\n') ! 899: p[--k] = 0; ! 900: z->comment = p; ! 901: z->com = k; ! 902: } ! 903: } ! 904: free((voidp *)e); ! 905: } ! 906: ! 907: /* Get multi-line comment for the zip file */ ! 908: if (zipedit) ! 909: { ! 910: if ((e = malloc(MAXCOM + 1)) == NULL) ! 911: err(ZE_MEM, "was reading comment lines"); ! 912: if (noisy && zcomlen) ! 913: { ! 914: fputs("current zip file comment is:\n", mesg); ! 915: fwrite(zcomment, 1, zcomlen, mesg); ! 916: if (zcomment[zcomlen-1] != '\n') ! 917: putc('\n', mesg); ! 918: free((voidp *)zcomment); ! 919: } ! 920: zcomment = malloc(1); ! 921: *zcomment = 0; ! 922: if (noisy) ! 923: fputs("enter new zip file comment (end with .):\n", mesg); ! 924: /* ??? reopen /dev/tty if one file was zipped from stdin ! 925: * or if file names were read from stdin. ! 926: */ ! 927: while (fgets(e, MAXCOM+1, stdin) != NULL && strcmp(e, ".\n")) ! 928: { ! 929: if (e[(r = strlen(e)) - 1] == '\n') ! 930: e[--r] = 0; ! 931: if ((p = malloc((*zcomment ? strlen(zcomment) + 3 : 1) + r)) == NULL) ! 932: { ! 933: free((voidp *)e); ! 934: err(ZE_MEM, "was reading comment lines"); ! 935: } ! 936: if (*zcomment) ! 937: strcat(strcat(strcpy(p, zcomment), "\r\n"), e); ! 938: else ! 939: strcpy(p, *e ? e : "\r\n"); ! 940: free((voidp *)zcomment); ! 941: zcomment = p; ! 942: } ! 943: zcomlen = strlen(zcomment); ! 944: free((voidp *)e); ! 945: } ! 946: ! 947: ! 948: /* Write central directory and end header to temporary zip */ ! 949: diag("writing central directory"); ! 950: k = 0; /* keep count for end header */ ! 951: c = tempzn; /* get start of central */ ! 952: n = t = 0; ! 953: for (z = zfiles; z != NULL; z = z->nxt) ! 954: { ! 955: if ((r = putcentral(z, y)) != ZE_OK) ! 956: err(r, tempzip); ! 957: tempzn += 4 + CENHEAD + z->nam + z->cext + z->com; ! 958: n += z->len; ! 959: t += z->siz; ! 960: k++; ! 961: } ! 962: if (k == 0) ! 963: warn("zip file empty", ""); ! 964: if (verbose) ! 965: fprintf(mesg, "total bytes=%lu, compressed=%lu -> %d%% savings\n", ! 966: n, t, percent(n, t)); ! 967: t = tempzn - c; /* compute length of central */ ! 968: diag("writing end of central directory"); ! 969: if ((r = putend(k, t, c, zcomlen, zcomment, y)) != ZE_OK) ! 970: err(r, tempzip); ! 971: tempzf = NULL; ! 972: if (fclose(y)) ! 973: err(d ? ZE_WRITE : ZE_TEMP, tempzip); ! 974: if (x != NULL) ! 975: fclose(x); ! 976: ! 977: ! 978: /* Replace old zip file with new zip file, leaving only the new one */ ! 979: if (strcmp(zipfile, "-") && !d) ! 980: { ! 981: diag("replacing old zip file with new zip file"); ! 982: if ((r = replace(zipfile, tempzip)) != ZE_OK) ! 983: { ! 984: warn("new zip file left as: ", tempzip); ! 985: free((voidp *)tempzip); ! 986: tempzip = NULL; ! 987: err(r, "was replacing the original zip file"); ! 988: } ! 989: free((voidp *)tempzip); ! 990: } ! 991: tempzip = NULL; ! 992: if (strcmp(zipfile, "-")) { ! 993: setfileattr(zipfile, a); ! 994: #ifdef VMS ! 995: /* If the zip file existed previously, restore its record format: */ ! 996: if (x != NULL) ! 997: VMSmunch(zipfile, RESTORE_RTYPE, NULL); ! 998: #endif ! 999: } ! 1000: ! 1001: /* Finish up (process -o, -m, clean up). Exit code depends on o. */ ! 1002: leave(o ? ZE_OPEN : ZE_OK); ! 1003: } ! 1004: ! 1005: /***************************************************************** ! 1006: | envargs - add default options from environment to command line ! 1007: |---------------------------------------------------------------- ! 1008: | Author: Bill Davidsen, original 10/13/91, revised 23 Oct 1991. ! 1009: | This program is in the public domain. ! 1010: |---------------------------------------------------------------- ! 1011: | Minor program notes: ! 1012: | 1. Yes, the indirection is a tad complex ! 1013: | 2. Parenthesis were added where not needed in some cases ! 1014: | to make the action of the code less obscure. ! 1015: ****************************************************************/ ! 1016: ! 1017: local void ! 1018: envargs(Pargc, Pargv, envstr) ! 1019: int *Pargc; ! 1020: char ***Pargv; ! 1021: char *envstr; ! 1022: { ! 1023: char *getenv(); ! 1024: char *envptr; /* value returned by getenv */ ! 1025: char *bufptr; /* copy of env info */ ! 1026: int argc = 0; /* internal arg count */ ! 1027: int ch; /* spare temp value */ ! 1028: char **argv; /* internal arg vector */ ! 1029: char **argvect; /* copy of vector address */ ! 1030: ! 1031: /* see if anything in the environment */ ! 1032: envptr = getenv(envstr); ! 1033: if (envptr == NULL || *envptr == 0) return; ! 1034: ! 1035: /* count the args so we can allocate room for them */ ! 1036: argc = count_args(envptr); ! 1037: bufptr = malloc(1+strlen(envptr)); ! 1038: if (bufptr == NULL) ! 1039: err(ZE_MEM, "Can't get memory for arguments"); ! 1040: ! 1041: strcpy(bufptr, envptr); ! 1042: ! 1043: /* allocate a vector large enough for all args */ ! 1044: argv = (char **)malloc((argc+*Pargc+1)*sizeof(char *)); ! 1045: if (argv == NULL) ! 1046: err(ZE_MEM, "Can't get memory for arguments"); ! 1047: argvect = argv; ! 1048: ! 1049: /* copy the program name first, that's always true */ ! 1050: *(argv++) = *((*Pargv)++); ! 1051: ! 1052: /* copy the environment args first, may be changed */ ! 1053: do { ! 1054: *(argv++) = bufptr; ! 1055: /* skip the arg and any trailing blanks */ ! 1056: while ((ch = *bufptr) != '\0' && ch != ' ') ++bufptr; ! 1057: if (ch == ' ') *(bufptr++) = '\0'; ! 1058: while ((ch = *bufptr) != '\0' && ch == ' ') ++bufptr; ! 1059: } while (ch); ! 1060: ! 1061: /* now save old argc and copy in the old args */ ! 1062: argc += *Pargc; ! 1063: while (--(*Pargc)) *(argv++) = *((*Pargv)++); ! 1064: ! 1065: /* finally, add a NULL after the last arg, like UNIX */ ! 1066: *argv = NULL; ! 1067: ! 1068: /* save the values and return */ ! 1069: *Pargv = argvect; ! 1070: *Pargc = argc; ! 1071: } ! 1072: ! 1073: static int ! 1074: count_args(s) ! 1075: char *s; ! 1076: { ! 1077: int count = 0; ! 1078: int ch; ! 1079: ! 1080: do { ! 1081: /* count and skip args */ ! 1082: ++count; ! 1083: while ((ch = *s) != '\0' && ch != ' ') ++s; ! 1084: while ((ch = *s) != '\0' && ch == ' ') ++s; ! 1085: } while (ch); ! 1086: ! 1087: return count; ! 1088: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.