![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gzip.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / bin / gzip|
Return to gzip.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / bin / gzip |
1.1 ! root 1: /* gzip (GNU zip) -- compress files with zip algorithm and 'compress' interface ! 2: * Copyright (C) 1992-1993 Jean-loup Gailly ! 3: * The unzip code was written and put in the public domain by Mark Adler. ! 4: * Portions of the lzw code are derived from the public domain 'compress' ! 5: * written by Spencer Thomas, Joe Orost, James Woods, Jim McKie, Steve Davies, ! 6: * Ken Turkowski, Dave Mack and Peter Jannesen. ! 7: * ! 8: * See the license_msg below and the file COPYING for the software license. ! 9: * See the file algorithm.doc for the compression algorithms and file formats. ! 10: */ ! 11: ! 12: static char *license_msg[] = { ! 13: " Copyright (C) 1992-1993 Jean-loup Gailly", ! 14: " This program is free software; you can redistribute it and/or modify", ! 15: " it under the terms of the GNU General Public License as published by", ! 16: " the Free Software Foundation; either version 2, or (at your option)", ! 17: " any later version.", ! 18: "", ! 19: " This program is distributed in the hope that it will be useful,", ! 20: " but WITHOUT ANY WARRANTY; without even the implied warranty of", ! 21: " MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the", ! 22: " GNU General Public License for more details.", ! 23: "", ! 24: " You should have received a copy of the GNU General Public License", ! 25: " along with this program; if not, write to the Free Software", ! 26: " Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.", ! 27: 0}; ! 28: ! 29: /* Compress files with zip algorithm and 'compress' interface. ! 30: * See usage() and help() functions below for all options. ! 31: * Outputs: ! 32: * file.z: compressed file with same mode, owner, and utimes ! 33: * file.Z: same with -Z option (old compress format) ! 34: * or stdout with -c option or if stdin used as input. ! 35: * If the OS does not support file names with multiple dots (MSDOS, VMS) or ! 36: * if the output file name had to be truncated, the original name is kept ! 37: * in the compressed .z file. (Feature not available in old compress format.) ! 38: * On MSDOS, file.tmp -> file.tmz. On VMS, file.tmp -> file.tmp-z. ! 39: * ! 40: * For the meaning of all compilation flags, see comments in Makefile.in. ! 41: */ ! 42: ! 43: #ifndef lint ! 44: static char rcsid[] = "$Id: gzip.c,v 0.14 1993/02/24 18:23:13 jloup Exp $"; ! 45: #endif ! 46: ! 47: #include "tailor.h" ! 48: #include "gzip.h" ! 49: #include "lzw.h" ! 50: #include "revision.h" ! 51: #include "getopt.h" ! 52: ! 53: #include <stdio.h> ! 54: #include <ctype.h> ! 55: #include <sys/types.h> ! 56: #include <signal.h> ! 57: #include <sys/stat.h> ! 58: #include <errno.h> ! 59: ! 60: /* configuration */ ! 61: ! 62: #ifndef NO_FCNTL_H ! 63: # include <fcntl.h> ! 64: #endif ! 65: ! 66: #ifdef HAVE_UNISTD_H ! 67: # include <unistd.h> ! 68: #endif ! 69: ! 70: #if defined(STDC_HEADERS) || !defined(NO_STDLIB_H) ! 71: # include <stdlib.h> ! 72: #else ! 73: extern int errno; ! 74: #endif ! 75: ! 76: #if defined(DIRENT) || defined(_POSIX_VERSION) ! 77: # include <dirent.h> ! 78: typedef struct dirent dir_type; ! 79: # define NLENGTH(dirent) ((int)strlen((dirent)->d_name)) ! 80: # define DIR_OPT "DIRENT" ! 81: #else ! 82: # define NLENGTH(dirent) ((dirent)->d_namlen) ! 83: # ifdef SYSDIR ! 84: # include <sys/dir.h> ! 85: typedef struct direct dir_type; ! 86: # define DIR_OPT "SYSDIR" ! 87: # else ! 88: # ifdef SYSNDIR ! 89: # include <sys/ndir.h> ! 90: typedef struct direct dir_type; ! 91: # define DIR_OPT "SYSNDIR" ! 92: # else ! 93: # ifdef NDIR ! 94: # include <ndir.h> ! 95: typedef struct direct dir_type; ! 96: # define DIR_OPT "NDIR" ! 97: # else ! 98: # define NO_DIR ! 99: # define DIR_OPT "NO_DIR" ! 100: # endif ! 101: # endif ! 102: # endif ! 103: #endif ! 104: ! 105: #ifndef NO_UTIME ! 106: # ifndef NO_UTIME_H ! 107: # include <utime.h> ! 108: # define TIME_OPT "UTIME" ! 109: # else ! 110: # ifdef HAVE_SYS_UTIME_H ! 111: # include <sys/utime.h> ! 112: # define TIME_OPT "SYS_UTIME" ! 113: # else ! 114: struct utimbuf { ! 115: time_t actime; ! 116: time_t modtime; ! 117: }; ! 118: # define TIME_OPT "" ! 119: # endif ! 120: # endif ! 121: #else ! 122: # define TIME_OPT "NO_UTIME" ! 123: #endif ! 124: ! 125: #if !defined(S_ISDIR) && defined(S_IFDIR) ! 126: # define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR) ! 127: #endif ! 128: #if !defined(S_ISREG) && defined(S_IFREG) ! 129: # define S_ISREG(m) (((m) & S_IFMT) == S_IFREG) ! 130: #endif ! 131: ! 132: typedef RETSIGTYPE (*sig_type)(); ! 133: ! 134: #ifndef O_BINARY ! 135: # define O_BINARY 0 /* creation mode for open() */ ! 136: #endif ! 137: ! 138: #define RW_USER 0600 /* creation mode for open() */ ! 139: ! 140: #ifndef MAX_PATH_LEN ! 141: # define MAX_PATH_LEN 1024 /* max pathname length */ ! 142: #endif ! 143: ! 144: #define MAX_HEADER_LEN 16 ! 145: /* max length of a compressed file header, fixed part only */ ! 146: ! 147: /* global buffers */ ! 148: ! 149: DECLARE(uch, inbuf, INBUFSIZ +INBUF_EXTRA); ! 150: DECLARE(uch, outbuf, OUTBUFSIZ+OUTBUF_EXTRA); ! 151: DECLARE(ush, d_buf, DIST_BUFSIZE); ! 152: DECLARE(uch, window, 2L*WSIZE); ! 153: #ifndef MAXSEG_64K ! 154: DECLARE(ush, tab_prefix, 1L<<BITS); ! 155: #else ! 156: DECLARE(ush, tab_prefix0, 1L<<(BITS-1)); ! 157: DECLARE(ush, tab_prefix1, 1L<<(BITS-1)); ! 158: #endif ! 159: ! 160: /* local variables */ ! 161: ! 162: int to_stdout = 0; /* output to stdout (-c) */ ! 163: int decompress = 0; /* decompress (-d) */ ! 164: int force = 0; /* don't ask questions, compress links (-f) */ ! 165: int recursive = 0; /* recurse through directories (-r) */ ! 166: int verbose = 0; /* be verbose (-v) */ ! 167: int quiet = 0; /* be very quiet (-q) */ ! 168: int do_lzw = 0; /* generate output compatible with old compress (-Z) */ ! 169: int test = 0; /* test .z file integrity */ ! 170: int foreground; /* set if program run in foreground */ ! 171: char *progname; /* program name */ ! 172: int maxbits = BITS; /* max bits per code for LZW */ ! 173: int method = DEFLATED;/* compression method */ ! 174: int level = 5; /* compression level */ ! 175: int exit_code = OK; /* program exit code */ ! 176: int save_orig_name; /* set if original name must be saved */ ! 177: int text_mode; /* set if original file is a text file (in variable ! 178: record format for VMS). Must stay 0 if unknown. */ ! 179: ! 180: int last_member; /* set for .zip and .Z files */ ! 181: int part_nb; /* number of parts in .z file */ ! 182: ulg time_stamp; /* original time stamp (modification time) */ ! 183: long ifile_size; /* input file size, -1 for devices (debug only) */ ! 184: char *env; /* contents of GZIP env variable */ ! 185: char **args = NULL; /* argv pointer if GZIP env variable defined */ ! 186: ! 187: long bytes_in; /* number of input bytes */ ! 188: long bytes_out; /* number of output bytes */ ! 189: char ifname[MAX_PATH_LEN]; /* input filename */ ! 190: char ofname[MAX_PATH_LEN]; /* output filename */ ! 191: int remove_ofname = 0; /* remove output file on error */ ! 192: struct stat istat; /* status for input file */ ! 193: int ifd; /* input file descriptor */ ! 194: int ofd; /* output file descriptor */ ! 195: unsigned insize; /* valid bytes in inbuf */ ! 196: unsigned inptr; /* index of next byte to be processed in inbuf */ ! 197: unsigned outcnt; /* bytes in output buffer */ ! 198: ! 199: struct option longopts[] = ! 200: { ! 201: /* { name has_arg *flag val } */ ! 202: /* {"ascii", 0, 0, 'a'}, ascii text mode */ ! 203: {"stdout", 0, 0, 'c'}, /* write output on standard output */ ! 204: {"decompress", 0, 0, 'd'}, /* decompress */ ! 205: /* {"encrypt", 0, 0, 'e'}, encrypt */ ! 206: {"force", 0, 0, 'f'}, /* force overwrite of output file */ ! 207: {"help", 0, 0, 'h'}, /* give help */ ! 208: /* {"pkzip", 0, 0, 'k'}, force output in pkzip format */ ! 209: /* {"list", 0, 0, 'l'}, list .z file contents */ ! 210: {"license", 0, 0, 'L'}, /* display software license */ ! 211: {"quiet", 0, 0, 'q'}, /* quiet mode */ ! 212: {"recurse", 0, 0, 'r'}, /* recurse through directories */ ! 213: {"test", 0, 0, 't'}, /* test compressed file integrity */ ! 214: {"verbose", 0, 0, 'v'}, /* verbose mode */ ! 215: {"version", 0, 0, 'V'}, /* display version number */ ! 216: {"fast", 0, 0, '1'}, /* compress faster */ ! 217: {"best", 0, 0, '9'}, /* compress better */ ! 218: {"lzw", 0, 0, 'Z'}, /* make output compatible with old compress */ ! 219: {"bits", 1, 0, 'b'}, /* max number of bits per code (implies -Z) */ ! 220: { 0, 0, 0, 0 } ! 221: }; ! 222: ! 223: /* local functions */ ! 224: ! 225: local void usage OF((void)); ! 226: local void help OF((void)); ! 227: local void license OF((void)); ! 228: local void version OF((void)); ! 229: local void treat_stdin OF((void)); ! 230: local void treat_file OF((char *iname)); ! 231: local int create_outfile OF((void)); ! 232: local int do_stat OF((char *name, struct stat *sbuf)); ! 233: local char *get_suffix OF((char *name)); ! 234: local int get_istat OF((char *iname, struct stat *sbuf)); ! 235: local int make_ofname OF((void)); ! 236: local int same_file OF((struct stat *stat1, struct stat *stat2)); ! 237: local int name_too_long OF((char *name, struct stat *statb)); ! 238: local int get_method OF((int in)); ! 239: local int check_ofname OF((void)); ! 240: local void copy_stat OF((struct stat *ifstat)); ! 241: local void treat_dir OF((char *dir)); ! 242: local void do_exit OF((int exitcode)); ! 243: int main OF((int argc, char **argv)); ! 244: ! 245: void (*work) OF((int infile, int outfile)) = zip; /* function to call */ ! 246: ! 247: #define strequ(s1, s2) (strcmp((s1),(s2)) == 0) ! 248: ! 249: /* ======================================================================== */ ! 250: local void usage() ! 251: { ! 252: fprintf(stderr, ! 253: #ifdef LZW ! 254: # ifdef NO_DIR ! 255: "usage: %s [-cdfhLtvVZ19] [-b maxbits] [file ...]\n", ! 256: # else ! 257: "usage: %s [-cdfhLrtvVZ19] [-b maxbits] [file ...]\n", ! 258: # endif ! 259: #else /* !LZW */ ! 260: # ifdef NO_DIR ! 261: "usage: %s [-cdfhLtvV19] [file ...]\n", ! 262: # else ! 263: "usage: %s [-cdfhLrtvV19] [file ...]\n", ! 264: # endif ! 265: #endif /* LZW */ ! 266: progname); ! 267: } ! 268: /* ======================================================================== */ ! 269: local void help() ! 270: { ! 271: static char *help_msg[] = { ! 272: /* -a --ascii ascii text; convert end-of-lines to local OS conventions */ ! 273: " -c --stdout write on standard output, keep original files unchanged", ! 274: " -d --decompress decompress", ! 275: /* -e --encrypt encrypt */ ! 276: " -f --force force overwrite of output file and compress links", ! 277: " -h --help give this help", ! 278: /* -k --pkzip force output in pkzip format */ ! 279: /* -l --list list .z file contents */ ! 280: " -L --license display software license", ! 281: " -q --quiet suppress all warnings", ! 282: #ifndef NO_DIR ! 283: " -r --recurse recurse through directories", ! 284: #endif ! 285: " -t --test test compressed file integrity", ! 286: " -v --verbose verbose mode", ! 287: " -V --version display version number", ! 288: " -1 --fast compress faster", ! 289: " -9 --best compress better", ! 290: #ifdef LZW ! 291: " -Z --lzw produce output compatible with old compress", ! 292: " -b --bits maxbits max number of bits per code (implies -Z)", ! 293: #endif ! 294: " file... files to (de)compress. If none given, use standard input.", ! 295: 0}; ! 296: char **p = help_msg; ! 297: ! 298: fprintf(stderr,"%s %s (%s)\n", progname, VERSION, REVDATE); ! 299: usage(); ! 300: while (*p) fprintf(stderr, "%s\n", *p++); ! 301: } ! 302: ! 303: /* ======================================================================== */ ! 304: local void license() ! 305: { ! 306: char **p = license_msg; ! 307: ! 308: fprintf(stderr,"%s %s (%s)\n", progname, VERSION, REVDATE); ! 309: while (*p) fprintf(stderr, "%s\n", *p++); ! 310: } ! 311: ! 312: /* ======================================================================== */ ! 313: local void version() ! 314: { ! 315: fprintf(stderr,"%s %s (%s)\n", progname, VERSION, REVDATE); ! 316: ! 317: fprintf(stderr, "Compilation options:\n%s %s ", DIR_OPT, TIME_OPT); ! 318: #ifdef STDC_HEADERS ! 319: fprintf(stderr, "STDC_HEADERS "); ! 320: #endif ! 321: #ifdef HAVE_UNISTD_H ! 322: fprintf(stderr, "HAVE_UNISTD_H "); ! 323: #endif ! 324: #ifdef NO_MEMORY_H ! 325: fprintf(stderr, "NO_MEMORY_H "); ! 326: #endif ! 327: #ifdef NO_STRING_H ! 328: fprintf(stderr, "NO_STRING_H "); ! 329: #endif ! 330: #ifdef NO_SYMLINK ! 331: fprintf(stderr, "NO_SYMLINK "); ! 332: #endif ! 333: #ifdef NO_MULTIPLE_DOTS ! 334: fprintf(stderr, "NO_MULTIPLE_DOTS "); ! 335: #endif ! 336: #ifdef NO_CHOWN ! 337: fprintf(stderr, "NO_CHOWN "); ! 338: #endif ! 339: #ifdef PROTO ! 340: fprintf(stderr, "PROTO "); ! 341: #endif ! 342: #ifdef ASMV ! 343: fprintf(stderr, "ASMV "); ! 344: #endif ! 345: #ifdef DEBUG ! 346: fprintf(stderr, "DEBUG "); ! 347: #endif ! 348: #ifdef DYN_ALLOC ! 349: fprintf(stderr, "DYN_ALLOC "); ! 350: #endif ! 351: #ifdef MAXSEG_64K ! 352: fprintf(stderr, "MAXSEG_64K"); ! 353: #endif ! 354: fprintf(stderr, "\n"); ! 355: } ! 356: ! 357: /* ======================================================================== */ ! 358: int main (argc, argv) ! 359: int argc; ! 360: char **argv; ! 361: { ! 362: int file_count = 0; /* number of files to precess */ ! 363: int proglen; /* length of progname */ ! 364: int optc; /* current option */ ! 365: ! 366: EXPAND(argc, argv); /* wild card expansion if necessary */ ! 367: ! 368: /* Add options in GZIP environment variable if there is one */ ! 369: env = add_envopt(&argc, &argv, OPTIONS_VAR); ! 370: if (env != NULL) args = argv; ! 371: ! 372: foreground = signal(SIGINT, SIG_IGN) != SIG_IGN; ! 373: if (foreground) { ! 374: signal (SIGINT, (sig_type)abort_gzip); ! 375: } ! 376: #ifdef SIGTERM ! 377: signal(SIGTERM, (sig_type)abort_gzip); ! 378: #endif ! 379: #ifdef SIGHUP ! 380: signal(SIGHUP, (sig_type)abort_gzip); ! 381: #endif ! 382: ! 383: progname = basename(argv[0]); ! 384: proglen = strlen(progname); ! 385: /* Suppress .exe for MSDOS, OS/2 and VMS: */ ! 386: if (proglen > 4 && strequ(progname+proglen-4, ".exe")) { ! 387: progname[proglen-4] = '\0'; ! 388: } ! 389: ! 390: /* For compatibility with old compress, use program name as an option. ! 391: * Systems which do not support links can still use -d or -dc. ! 392: * Ignore an .exe extension for MSDOS, OS/2 and VMS. ! 393: */ ! 394: if ( strncmp(progname, "un", 2) == 0 /* ungzip, uncompress */ ! 395: || strncmp(progname, "gun", 3) == 0) { /* gunzip */ ! 396: decompress = 1; ! 397: } else if (strequ(progname+1, "cat") /* zcat, pcat */ ! 398: || strequ(progname, "gzcat")) { /* gzcat */ ! 399: decompress = to_stdout = 1; ! 400: } ! 401: ! 402: while ((optc = getopt_long (argc, argv, "b:cdfhLqrtvVZ123456789", ! 403: longopts, (int *)0)) != EOF) { ! 404: switch (optc) { ! 405: case 'b': ! 406: maxbits = atoi(optarg); ! 407: break; ! 408: case 'c': ! 409: to_stdout = 1; break; ! 410: case 'd': ! 411: decompress = 1; break; ! 412: case 'f': ! 413: force++; break; ! 414: case 'h': ! 415: help(); do_exit(OK); break; ! 416: case 'L': ! 417: license(); do_exit(OK); break; ! 418: case 'q': ! 419: quiet = 1; verbose = 0; break; ! 420: case 'r': ! 421: #ifdef NO_DIR ! 422: fprintf(stderr, "-r not supported on this system\n"); ! 423: usage(); ! 424: do_exit(ERROR); break; ! 425: #else ! 426: recursive = 1; break; ! 427: #endif ! 428: case 't': ! 429: test = decompress = to_stdout = 1; ! 430: break; ! 431: case 'v': ! 432: verbose++; quiet = 0; break; ! 433: case 'V': ! 434: version(); break; ! 435: case 'Z': ! 436: #ifdef LZW ! 437: do_lzw = 1; break; ! 438: #else ! 439: fprintf(stderr, "-Z not supported in this version\n"); ! 440: usage(); ! 441: do_exit(ERROR); break; ! 442: #endif ! 443: case '1': case '2': case '3': case '4': ! 444: case '5': case '6': case '7': case '8': case '9': ! 445: level = optc - '0'; ! 446: break; ! 447: default: ! 448: /* Error message already emitted by getopt_long. */ ! 449: usage(); ! 450: do_exit(ERROR); ! 451: } ! 452: } /* loop on all arguments */ ! 453: ! 454: file_count = argc - optind; ! 455: ! 456: if (do_lzw && !decompress) work = lzw; ! 457: ! 458: /* Allocate all global buffers (for DYN_ALLOC option) */ ! 459: ALLOC(uch, inbuf, INBUFSIZ +INBUF_EXTRA); ! 460: ALLOC(uch, outbuf, OUTBUFSIZ+OUTBUF_EXTRA); ! 461: ALLOC(ush, d_buf, DIST_BUFSIZE); ! 462: ALLOC(uch, window, 2L*WSIZE); ! 463: #ifndef MAXSEG_64K ! 464: ALLOC(ush, tab_prefix, 1L<<BITS); ! 465: #else ! 466: ALLOC(ush, tab_prefix0, 1L<<(BITS-1)); ! 467: ALLOC(ush, tab_prefix1, 1L<<(BITS-1)); ! 468: #endif ! 469: ! 470: /* And get to work */ ! 471: if (file_count != 0) { ! 472: if (to_stdout && !test) { ! 473: SET_BINARY_MODE(fileno(stdout)); ! 474: } ! 475: while (optind < argc) { ! 476: treat_file(argv[optind++]); ! 477: } ! 478: } else { /* Standard input */ ! 479: treat_stdin(); ! 480: } ! 481: do_exit(exit_code); ! 482: return exit_code; /* just to avoid lint warning */ ! 483: } ! 484: ! 485: /* ======================================================================== ! 486: * Compress or decompress stdin ! 487: */ ! 488: local void treat_stdin() ! 489: { ! 490: if (isatty(fileno((FILE *)(decompress ? stdin : stdout)))) { ! 491: /* Do not send compressed data to the terminal or read it from ! 492: * the terminal. We get here when user invoked the program ! 493: * without parameters, so be helpful. ! 494: */ ! 495: fprintf(stderr, ! 496: "Compressed data not %s a terminal. Redirect %s file or pipe.\n", ! 497: decompress ? "read from" : "written to", ! 498: decompress ? "from" : "to"); ! 499: fprintf(stderr,"For help, type: %s -h\n", progname); ! 500: do_exit(ERROR); ! 501: } ! 502: SET_BINARY_MODE(fileno(stdin)); ! 503: if (!test) SET_BINARY_MODE(fileno(stdout)); ! 504: ! 505: strcpy(ifname, "stdin"); ! 506: strcpy(ofname, "stdout"); ! 507: ! 508: /* Get the time stamp on the input file */ ! 509: #ifdef NO_STDIN_FSTAT ! 510: time_stamp = 0; /* time unknown */ ! 511: text_mode = 0; /* type unknown */ ! 512: #else ! 513: if (fstat(fileno(stdin), &istat) != 0) { ! 514: error("fstat(stdin)"); ! 515: } ! 516: time_stamp = istat.st_mtime; ! 517: text_mode = TEXT_MODE(istat); ! 518: #endif ! 519: ifile_size = -1L; /* convention for unknown size */ ! 520: ! 521: clear_bufs(); /* clear input and output buffers */ ! 522: to_stdout = 1; ! 523: part_nb = 0; ! 524: ! 525: if (decompress) { ! 526: method = get_method(ifd); ! 527: if (method < 0) { ! 528: do_exit(exit_code); /* error message already emitted */ ! 529: } ! 530: } ! 531: ! 532: /* Actually do the compression/decompression. Loop over zipped members. ! 533: */ ! 534: for (;;) { ! 535: (*work)(fileno(stdin), fileno(stdout)); ! 536: ! 537: if (!decompress || last_member || inptr == insize) break; ! 538: /* end of file */ ! 539: ! 540: method = get_method(ifd); ! 541: if (method == -1) return; /* error message already emitted */ ! 542: bytes_out = 0; /* required for length check */ ! 543: } ! 544: ! 545: if (verbose) { ! 546: if (test) { ! 547: fprintf(stderr, " OK"); ! 548: ! 549: } else if (!decompress) { ! 550: fprintf(stderr, "Compression: "); ! 551: display_ratio(bytes_in-bytes_out-overhead, bytes_in); ! 552: } ! 553: fprintf(stderr, "\n"); ! 554: } ! 555: } ! 556: ! 557: /* ======================================================================== ! 558: * Compress or decompress the given file ! 559: */ ! 560: local void treat_file(iname) ! 561: char *iname; ! 562: { ! 563: /* Check if the input file is present, set ifname and istat: */ ! 564: if (get_istat(iname, &istat) != 0) return; ! 565: ! 566: /* If the input name is that of a directory, recurse or ignore: */ ! 567: if (S_ISDIR(istat.st_mode)) { ! 568: #ifndef NO_DIR ! 569: if (recursive) { ! 570: treat_dir(iname); ! 571: /* Warning: ifname is now garbage */ ! 572: } else ! 573: #endif ! 574: WARN((stderr,"%s is a directory -- ignored\n", ifname)); ! 575: return; ! 576: } ! 577: if (!S_ISREG(istat.st_mode)) { ! 578: WARN((stderr, "%s is not a directory or a regular file - ignored\n", ! 579: ifname)); ! 580: return; ! 581: } ! 582: if (istat.st_nlink > 1 && !to_stdout && !force) { ! 583: WARN((stderr, "%s has %d other link%c -- unchanged\n", ifname, ! 584: (int)istat.st_nlink - 1, istat.st_nlink > 2 ? 's' : ' ')); ! 585: return; ! 586: } ! 587: ! 588: ifile_size = istat.st_size; ! 589: time_stamp = istat.st_mtime; ! 590: text_mode = TEXT_MODE(istat); ! 591: ! 592: /* Generate output file name */ ! 593: if (to_stdout) { ! 594: strcpy(ofname, "stdout"); ! 595: ! 596: } else if (make_ofname() != 0) { ! 597: return; ! 598: } ! 599: ! 600: /* Open the input file and determine compression method. The mode ! 601: * parameter is ignored but required by some systems (VMS). ! 602: */ ! 603: ifd = open(ifname, O_RDONLY | O_BINARY, RW_USER); ! 604: if (ifd == -1) { ! 605: perror(ifname); ! 606: exit_code = ERROR; ! 607: return; ! 608: } ! 609: clear_bufs(); /* clear input and output buffers */ ! 610: part_nb = 0; ! 611: ! 612: if (decompress) { ! 613: method = get_method(ifd); /* updates ofname if original given */ ! 614: if (method < 0) { ! 615: close(ifd); ! 616: return; /* error message already emitted */ ! 617: } ! 618: } ! 619: ! 620: /* If compressing to a file, check if ofname is not ambigous ! 621: * because the operating system truncates names. Otherwise, generate ! 622: * a new ofname and save the original name in the compressed file. ! 623: */ ! 624: if (to_stdout) { ! 625: ofd = fileno(stdout); ! 626: /* keep remove_ofname as zero */ ! 627: } else { ! 628: if (create_outfile() == -1) return; ! 629: ! 630: if (save_orig_name && !verbose && !quiet) { ! 631: fprintf(stderr, "%s compressed to %s\n", ifname, ofname); ! 632: } ! 633: } ! 634: if (verbose) { ! 635: fprintf(stderr, "%s:\t%s", ifname, (int)strlen(ifname) >= 15 ? ! 636: "" : ((int)strlen(ifname) >= 7 ? "\t" : "\t\t")); ! 637: } ! 638: ! 639: /* Actually do the compression/decompression. Loop over zipped members. ! 640: */ ! 641: for (;;) { ! 642: (*work)(ifd, ofd); ! 643: ! 644: if (!decompress || last_member || inptr == insize) break; ! 645: /* end of file */ ! 646: ! 647: method = get_method(ifd); ! 648: if (method < 0) break; /* error message already emitted */ ! 649: bytes_out = 0; /* required for length check */ ! 650: } ! 651: ! 652: close(ifd); ! 653: if (!to_stdout && close(ofd)) { ! 654: write_error(); ! 655: } ! 656: if (method == -1) return; /* error, don't display success msg */ ! 657: ! 658: /* Display statistics */ ! 659: if(verbose) { ! 660: if (!decompress) { ! 661: display_ratio(bytes_in-bytes_out-overhead, bytes_in); ! 662: } ! 663: if (test) { ! 664: fprintf(stderr, " OK"); ! 665: } else if (!to_stdout) { ! 666: fprintf(stderr, " -- replaced with %s", ofname); ! 667: } ! 668: fprintf(stderr, "\n"); ! 669: } ! 670: /* Copy modes, times, ownership */ ! 671: if (!to_stdout) { ! 672: copy_stat(&istat); ! 673: } ! 674: } ! 675: ! 676: /* ======================================================================== ! 677: * Create the output file. Return 0 for success, -1 for error. ! 678: * Try twice if ofname is exactly one beyond the name limit, to avoid ! 679: * creating a compressed file of name "1234567890123." ! 680: * We could actually loop more than once if the user gives an extra long ! 681: * name, but I prefer generating an error then. (Posix forbids the system ! 682: * to truncate names.) The error message is generated by check_ofname() ! 683: * in this case. ! 684: * IN assertions: the input file has already been open (ifd is set) and ! 685: * ofname has already been updated if there was an original name. ! 686: * text_mode has been initialized if decompressing. ! 687: * OUT assertions: ifd and ofd are closed in case of error. ! 688: */ ! 689: local int create_outfile() ! 690: { ! 691: struct stat ostat; /* stat for ofname */ ! 692: int n; /* loop counter */ ! 693: ! 694: for (n = 1; n <= 2; n++) { ! 695: if (check_ofname() == -1) { ! 696: close(ifd); ! 697: return -1; ! 698: } ! 699: /* Create the output file */ ! 700: remove_ofname = 1; ! 701: if (decompress) { ! 702: ofd = CREATE(ofname, text_mode); ! 703: } else { ! 704: ofd = open(ofname, O_WRONLY|O_CREAT|O_EXCL|O_BINARY, RW_USER); ! 705: } ! 706: if (ofd == -1) { ! 707: perror(ofname); ! 708: close(ifd); ! 709: exit_code = ERROR; ! 710: return -1; ! 711: } ! 712: ! 713: /* Check for name truncation on new file (1234567890123.z) */ ! 714: if (fstat(ofd, &ostat) != 0) { ! 715: perror(ofname); ! 716: fprintf(stderr, " fstat failed\n"); ! 717: close(ifd); close(ofd); ! 718: unlink(ofname); ! 719: exit_code = ERROR; ! 720: return -1; ! 721: } ! 722: if (!name_too_long(ofname, &ostat)) return 0; ! 723: ! 724: if (decompress) { ! 725: /* name might be too long if an original name was saved */ ! 726: if (!quiet) { ! 727: fprintf(stderr, " warning, name truncated: %s\n", ofname); ! 728: } ! 729: return 0; ! 730: } else { ! 731: #ifdef NO_MULTIPLE_DOTS ! 732: /* Should never happen, see check_ofname() */ ! 733: fprintf(stderr, "ERROR: name too long: %s\n", ofname); ! 734: do_exit(ERROR); ! 735: #else ! 736: close(ofd); ! 737: unlink(ofname); ! 738: save_orig_name = 1; ! 739: strcpy(ofname+strlen(ofname)-Z_LEN-1, Z_SUFFIX); ! 740: /* 1234567890123.z -> 123456789012.z */ ! 741: #endif ! 742: } /* decompress ? */ ! 743: } /* for (n) */ ! 744: ! 745: close(ifd); ! 746: fprintf(stderr, " name too long: %s\n", ofname); ! 747: exit_code = ERROR; ! 748: return -1; ! 749: } ! 750: ! 751: /* ======================================================================== ! 752: * Use lstat if available, except for -c or -f. Use stat otherwise. ! 753: * This allows links when not removing the original file. ! 754: */ ! 755: local int do_stat(name, sbuf) ! 756: char *name; ! 757: struct stat *sbuf; ! 758: { ! 759: #if (defined(S_IFLNK) || defined (S_ISLNK)) && !defined(NO_SYMLINK) ! 760: if (!to_stdout && !force) { ! 761: return lstat(name, sbuf); ! 762: } ! 763: #endif ! 764: return stat(name, sbuf); ! 765: } ! 766: ! 767: /* ======================================================================== ! 768: * Return a pointer to the 'z' suffix of a file name, or NULL. ! 769: * For all systems, ".z", ".Z", ".taz", ".tgz", "-z" are accepted suffixes. ! 770: * ".tgz" is a useful convention for tar.z files on systems limited ! 771: * to 3 characters extensions. On such systems, ".?z" and ".??z" are ! 772: * also accepted suffixes. For Unix, we do not want to accept any ! 773: * .??z suffix as indicating a compressed file; some people use .xyz ! 774: * to denote volume data. ! 775: */ ! 776: local char *get_suffix(name) ! 777: char *name; ! 778: { ! 779: int len; ! 780: char *p = strrchr(name, '.'); ! 781: char *v; ! 782: char suffix[10]; /* last few chars of name, forced to lower case */ ! 783: ! 784: if (p == NULL) return NULL; ! 785: strncpy(suffix, p, sizeof(suffix)); ! 786: ! 787: #ifdef SUFFIX_SEP ! 788: /* strip a version number from the file name */ ! 789: if ((v = strrchr(suffix, SUFFIX_SEP)) != NULL) *v = '\0'; ! 790: #endif ! 791: strlwr(suffix); ! 792: if (strequ(suffix, ".z") || strequ(suffix, ".zip") ! 793: || strequ(suffix, ".tgz") || strequ(suffix, ".taz")) { ! 794: return p; ! 795: } ! 796: len = strlen(suffix); ! 797: if (len <= 2) return NULL; ! 798: ! 799: if (strequ(suffix+len-2, "-z")) return p+len-2; ! 800: #ifdef MAX_EXT_CHARS ! 801: if (suffix[len-1] == 'z') return p+len-1; ! 802: #endif ! 803: return NULL; ! 804: } ! 805: ! 806: ! 807: /* ======================================================================== ! 808: * Set ifname to the input file name (with .z appended if necessary) ! 809: * and istat to its stats. Return 0 if ok, -1 if error. ! 810: */ ! 811: local int get_istat(iname, sbuf) ! 812: char *iname; ! 813: struct stat *sbuf; ! 814: { ! 815: int iexists; /* set if iname exists */ ! 816: int ilen = strlen(iname); ! 817: char *suff; ! 818: ! 819: strcpy(ifname, iname); ! 820: errno = 0; ! 821: ! 822: /* If input file exists, return OK. */ ! 823: if (do_stat(ifname, sbuf) == 0) return 0; ! 824: ! 825: if (!decompress || errno != ENOENT) { ! 826: perror(ifname); ! 827: exit_code = ERROR; ! 828: return -1; ! 829: } ! 830: /* file.ext doesn't exist, try file.ext.z and file.ext.Z. For MSDOS ! 831: * try file.exz, for VMS try file.ext-z. ! 832: */ ! 833: suff = get_suffix(ifname); ! 834: if (suff != NULL) { ! 835: perror(ifname); /* ifname already has z suffix and does not exist */ ! 836: exit_code = ERROR; ! 837: return -1; ! 838: } ! 839: #ifdef SUFFIX_SEP ! 840: /* strip a version number from the input file name */ ! 841: if ((suff = strrchr(ifname, SUFFIX_SEP)) != NULL) *suff = '\0'; ! 842: #endif ! 843: if (strrchr(ifname, '.') != NULL) { ! 844: strcat(ifname, Z_SUFFIX); ! 845: ilen += Z_LEN; ! 846: } else { ! 847: strcat(ifname, ".z"); ! 848: ilen += 2; ! 849: } ! 850: errno = 0; ! 851: iexists = !do_stat(ifname, sbuf); ! 852: if (!iexists) { ! 853: errno = 0; ! 854: ifname[ilen-1] = 'Z'; ! 855: iexists = !do_stat(ifname, sbuf); ! 856: } ! 857: #ifdef NO_MULTIPLE_DOTS ! 858: /* One more try just to be nice to you */ ! 859: if (!iexists) { ! 860: char c = ifname[ilen-2]; ! 861: errno = 0; ! 862: strcpy(ifname+ilen-2, "z"); ! 863: iexists = !do_stat(ifname, sbuf); ! 864: if (!iexists) { ! 865: ifname[ilen-2] = c; ! 866: } ! 867: } ! 868: #endif ! 869: if (!iexists) { ! 870: ifname[ilen-1] = 'z'; ! 871: perror(ifname); ! 872: exit_code = ERROR; ! 873: return -1; ! 874: } ! 875: if (!S_ISREG (sbuf->st_mode)) { ! 876: WARN((stderr, "%s: Not a regular file -- ignored\n", ifname)); ! 877: return -1; ! 878: } ! 879: return 0; /* ok */ ! 880: } ! 881: ! 882: /* ======================================================================== ! 883: * Generate ofname given ifname. Return 0 if ok, -1 if file must be skipped. ! 884: * Initializes save_orig_name. ! 885: * IN assertion: this function is not called if to_stdout is true. ! 886: */ ! 887: local int make_ofname() ! 888: { ! 889: char *suff; /* ofname z suffix */ ! 890: ! 891: strcpy(ofname, ifname); ! 892: suff = get_suffix(ofname); ! 893: ! 894: if (decompress) { ! 895: if (suff == NULL) { ! 896: WARN((stderr,"%s -- no z suffix, ignored\n", ifname)); ! 897: return -1; ! 898: } ! 899: /* Make a special case for .tgz and .taz: */ ! 900: strlwr(suff); ! 901: if (strequ(suff, ".tgz") || strequ(suff, ".taz")) { ! 902: strcpy(suff, ".tar"); ! 903: } else { ! 904: *suff = '\0'; /* strip z suffix and optional version number */ ! 905: } ! 906: /* ofname might be changed later if infile contains an original name */ ! 907: ! 908: } else if (suff != NULL) { ! 909: /* Avoid annoying messages with -r (see treat_dir()) */ ! 910: if (verbose || (!recursive && !quiet)) { ! 911: fprintf(stderr, "%s already has %s suffix -- unchanged\n", ! 912: ifname, suff); ! 913: } ! 914: if (exit_code == OK) exit_code = WARNING; ! 915: return -1; ! 916: } else { ! 917: save_orig_name = 0; ! 918: ! 919: #ifdef SUFFIX_SEP ! 920: /* strip a version number from the file name */ ! 921: if ((suff = strrchr(ofname, SUFFIX_SEP)) != NULL) *suff = '\0'; ! 922: #endif ! 923: ! 924: #ifdef NO_MULTIPLE_DOTS ! 925: suff = strrchr(ofname, '.'); ! 926: if (suff != NULL) { ! 927: # ifdef MAX_EXT_CHARS ! 928: /* On the Atari and some versions of MSDOS, name_too_long() ! 929: * does not work correctly because of a bug in stat(). So we ! 930: * must truncate here. ! 931: */ ! 932: if (strlen(suff) > MAX_EXT_CHARS) { ! 933: strcpy(suff + MAX_EXT_CHARS, do_lzw ? "Z" : "z"); ! 934: save_orig_name = 1; ! 935: return 0; ! 936: } ! 937: # endif ! 938: strcat(ofname, Z_SUFFIX); ! 939: return 0; ! 940: } ! 941: #endif ! 942: strcat(ofname, do_lzw ? ".Z" : ".z"); ! 943: ! 944: } /* decompress ? */ ! 945: return 0; ! 946: } ! 947: ! 948: ! 949: /* ======================================================================== ! 950: * Check the magic number of the input file and update ofname if an ! 951: * original name was given and to_stdout is not set. ! 952: * Return the compression method, -1 for error, -2 for warning. ! 953: * Set inptr to the offset of the next byte to be processed. ! 954: * This function may be called repeatedly for an input file consisting ! 955: * of several contiguous gzip'ed members. ! 956: * IN assertions: there is at least one remaining compressed member. ! 957: * If the member is a zip file, it must be the only one. ! 958: */ ! 959: local int get_method(in) ! 960: int in; /* input file descriptor */ ! 961: { ! 962: uch flags; ! 963: char magic[2]; /* magic header */ ! 964: ! 965: magic[0] = (char)get_byte(); ! 966: magic[1] = (char)get_byte(); ! 967: ! 968: time_stamp = istat.st_mtime; /* may be modified later for some methods */ ! 969: method = -1; /* unknown yet */ ! 970: part_nb++; /* number of parts in gzip file */ ! 971: last_member = RECORD_IO; ! 972: /* assume multiple members in gzip file except for record oriented I/O */ ! 973: ! 974: if (memcmp(magic, GZIP_MAGIC, 2) == 0 ! 975: || memcmp(magic, OLD_GZIP_MAGIC, 2) == 0) { ! 976: ! 977: work = unzip; ! 978: method = (int)get_byte(); ! 979: flags = (uch)get_byte(); ! 980: text_mode = flags & ASCII_FLAG; ! 981: ! 982: if ((flags & ENCRYPTED) != 0) { ! 983: fprintf(stderr, "%s is encrypted -- get newer version of gzip\n", ! 984: ifname); ! 985: exit_code = ERROR; ! 986: return -1; ! 987: } ! 988: if ((flags & CONTINUATION) != 0) { ! 989: fprintf(stderr, ! 990: "%s is a a multi-part gzip file -- get newer version of gzip\n", ! 991: ifname); ! 992: exit_code = ERROR; ! 993: if (force <= 1) return -1; ! 994: } ! 995: if ((flags & RESERVED) != 0) { ! 996: fprintf(stderr, "%s has flags 0x%x -- get newer version of gzip\n", ! 997: ifname, flags); ! 998: exit_code = ERROR; ! 999: if (force <= 1) return -1; ! 1000: } ! 1001: time_stamp = (ulg)get_byte(); ! 1002: time_stamp |= ((ulg)get_byte()) << 8; ! 1003: time_stamp |= ((ulg)get_byte()) << 16; ! 1004: time_stamp |= ((ulg)get_byte()) << 24; ! 1005: ! 1006: (void)get_byte(); /* Ignore extra flags for the moment */ ! 1007: (void)get_byte(); /* Ignore OS type for the moment */ ! 1008: ! 1009: if ((flags & CONTINUATION) != 0) { ! 1010: unsigned part = (unsigned)get_byte(); ! 1011: part |= ((unsigned)get_byte())<<8; ! 1012: if (verbose) { ! 1013: fprintf(stderr,"%s: part number %u\n", ! 1014: ifname, part); ! 1015: } ! 1016: } ! 1017: if ((flags & EXTRA_FIELD) != 0) { ! 1018: unsigned len = (unsigned)get_byte(); ! 1019: len |= ((unsigned)get_byte())<<8; ! 1020: if (verbose) { ! 1021: fprintf(stderr,"%s: extra field of %u bytes ignored\n", ! 1022: ifname, len); ! 1023: } ! 1024: while (len--) (void)get_byte(); ! 1025: } ! 1026: ! 1027: /* Get original file name if it was truncated */ ! 1028: if ((flags & ORIG_NAME) != 0) { ! 1029: if (to_stdout || part_nb > 1) { ! 1030: /* Discard the old name */ ! 1031: while (get_byte() != 0) /* null */ ; ! 1032: } else { ! 1033: /* Copy the base name. Keep a directory prefix intact. */ ! 1034: char *p = basename(ofname); ! 1035: for (;;) { ! 1036: *p = (char)get_byte(); ! 1037: if (*p++ == '\0') break; ! 1038: if (p >= ofname+sizeof(ofname)) { ! 1039: error("corrupted input -- file name too large"); ! 1040: } ! 1041: } ! 1042: } /* to_stdout */ ! 1043: } /* orig_name */ ! 1044: ! 1045: /* Discard file comment if any */ ! 1046: if ((flags & COMMENT) != 0) { ! 1047: while (get_byte() != 0) /* null */ ; ! 1048: } ! 1049: ! 1050: } else if (memcmp(magic, PKZIP_MAGIC, 2) == 0 && inptr == 2 ! 1051: && memcmp(inbuf, PKZIP_MAGIC, 4) == 0) { ! 1052: /* To simplify the code, we support a zip file when alone only. ! 1053: * We are thus guaranteed that the entire local header fits in inbuf. ! 1054: */ ! 1055: inptr = 0; ! 1056: work = unzip; ! 1057: if (check_zipfile(in) == -1) return -1; ! 1058: /* check_zipfile may get ofname from the local header */ ! 1059: last_member = 1; ! 1060: ! 1061: } else if (memcmp(magic, PACK_MAGIC, 2) == 0) { ! 1062: work = unpack; ! 1063: method = PACKED; ! 1064: } else if (memcmp(magic, LZW_MAGIC, 2) == 0) { ! 1065: work = unlzw; ! 1066: method = COMPRESSED; ! 1067: last_member = 1; ! 1068: } ! 1069: if (method >= 0) return method; ! 1070: if (part_nb == 1) { ! 1071: fprintf(stderr, "%s is not in gzip format\n", ifname); ! 1072: exit_code = ERROR; ! 1073: return -1; ! 1074: } else { ! 1075: WARN((stderr, "trailing garbage ignored in %s\n", ifname)); ! 1076: return -2; ! 1077: } ! 1078: } ! 1079: ! 1080: /* ======================================================================== ! 1081: * Return true if the two stat structures correspond to the same file. ! 1082: */ ! 1083: local int same_file(stat1, stat2) ! 1084: struct stat *stat1; ! 1085: struct stat *stat2; ! 1086: { ! 1087: return stat1->st_mode == stat2->st_mode ! 1088: && stat1->st_ino == stat2->st_ino ! 1089: && stat1->st_dev == stat2->st_dev ! 1090: && stat1->st_uid == stat2->st_uid ! 1091: && stat1->st_gid == stat2->st_gid ! 1092: && stat1->st_size == stat2->st_size ! 1093: && stat1->st_atime == stat2->st_atime ! 1094: && stat1->st_mtime == stat2->st_mtime ! 1095: && stat1->st_ctime == stat2->st_ctime; ! 1096: } ! 1097: ! 1098: /* ======================================================================== ! 1099: * Return true if a file name is ambigous because the operating system ! 1100: * truncates file names. ! 1101: */ ! 1102: local int name_too_long(name, statb) ! 1103: char *name; /* file name to check */ ! 1104: struct stat *statb; /* stat buf for this file name */ ! 1105: { ! 1106: int s = strlen(name); ! 1107: char c = name[s-1]; ! 1108: struct stat tstat; /* stat for truncated name */ ! 1109: int res; ! 1110: ! 1111: tstat = *statb; /* Just in case OS does not fill all fields */ ! 1112: name[s-1] = '\0'; ! 1113: res = stat(name, &tstat) == 0 && same_file(statb, &tstat); ! 1114: name[s-1] = c; ! 1115: return res; ! 1116: } ! 1117: ! 1118: /* ======================================================================== ! 1119: * If compressing to a file, check if ofname is not ambigous ! 1120: * because the operating system truncates names. Otherwise, generate ! 1121: * a new ofname and save the original name in the compressed file. ! 1122: * If the compressed file already exists, ask for confirmation. ! 1123: * The check for name truncation is made dynamically, because different ! 1124: * file systems on the same OS might use different truncation rules (on SVR4 ! 1125: * s5 truncates to 14 chars and ufs does not truncate). ! 1126: * This function returns -1 if the file must be skipped, and ! 1127: * updates save_orig_name if necessary. ! 1128: * IN assertions: save_orig_name is already set if ofname has been ! 1129: * already truncated because of NO_MULTIPLE_DOTS. The input file has ! 1130: * already been open and istat is set. ! 1131: */ ! 1132: local int check_ofname() ! 1133: { ! 1134: int s = strlen(ofname); ! 1135: struct stat ostat; /* stat for ofname */ ! 1136: ! 1137: if (stat(ofname, &ostat) != 0) return 0; ! 1138: ! 1139: /* Check for name truncation on existing file: */ ! 1140: #ifdef NO_MULTIPLE_DOTS ! 1141: if (!decompress && name_too_long(ofname, &ostat)) { ! 1142: #else ! 1143: if (!decompress && s > 8 && name_too_long(ofname, &ostat)) { ! 1144: #endif ! 1145: save_orig_name = 1; ! 1146: #ifdef NO_MULTIPLE_DOTS ! 1147: strcpy(ofname+s-Z_LEN-1, Z_SUFFIX); /* f.extz -> f.exz */ ! 1148: #else ! 1149: strcpy(ofname+s-4, ".z"); /* 12345678901234.z -> 123456789012.z */ ! 1150: #endif ! 1151: if (stat(ofname, &ostat) != 0) return 0; ! 1152: } /* !decompress && name_too_long */ ! 1153: ! 1154: /* Check that the input and output files are different (could be ! 1155: * the same by name truncation or links). ! 1156: */ ! 1157: if (same_file(&istat, &ostat)) { ! 1158: fprintf(stderr, "error: %s and %s are the same file\n", ! 1159: ifname, ofname); ! 1160: exit_code = ERROR; ! 1161: return -1; ! 1162: } ! 1163: /* Ask permission to overwrite the existing file */ ! 1164: if (!force) { ! 1165: char response[80]; ! 1166: strcpy(response,"n"); ! 1167: fprintf(stderr, "%s already exists;", ofname); ! 1168: if (foreground && isatty(fileno(stdin))) { ! 1169: fprintf(stderr, " do you wish to overwrite (y or n)? "); ! 1170: fflush(stderr); ! 1171: (void)read(fileno(stdin), response, sizeof(response)); ! 1172: } ! 1173: if (tolow(*response) != 'y') { ! 1174: fprintf(stderr, "\tnot overwritten\n"); ! 1175: if (exit_code == OK) exit_code = WARNING; ! 1176: return -1; ! 1177: } ! 1178: } ! 1179: (void) chmod(ofname, 0777); ! 1180: if (unlink(ofname)) { ! 1181: fprintf(stderr, "Can't remove old output file\n"); ! 1182: perror(ofname); ! 1183: exit_code = ERROR; ! 1184: return -1; ! 1185: } ! 1186: return 0; ! 1187: } ! 1188: ! 1189: ! 1190: /* ======================================================================== ! 1191: * Copy modes, times, ownership. ! 1192: * IN assertion: to_stdout is false. ! 1193: */ ! 1194: local void copy_stat(ifstat) ! 1195: struct stat *ifstat; ! 1196: { ! 1197: #ifndef NO_UTIME ! 1198: struct utimbuf timep; ! 1199: ! 1200: /* Copy the time stamp */ ! 1201: timep.actime = ifstat->st_atime; ! 1202: timep.modtime = ifstat->st_mtime; ! 1203: ! 1204: if (decompress && timep.modtime != time_stamp && time_stamp != 0) { ! 1205: timep.modtime = time_stamp; ! 1206: if (verbose) { ! 1207: fprintf(stderr, " (time stamp restored)\n"); ! 1208: } ! 1209: } ! 1210: if (utime(ofname, &timep)) { ! 1211: if (!quiet) perror(ofname); ! 1212: WARN((stderr, " utime error (ignored)\n")); ! 1213: } ! 1214: #endif ! 1215: /* Copy the protection modes */ ! 1216: if (chmod(ofname, ifstat->st_mode & 07777)) { ! 1217: if (!quiet) perror(ofname); ! 1218: WARN((stderr, " chmod error (ignored)\n")); ! 1219: } ! 1220: #ifndef NO_CHOWN ! 1221: chown(ofname, ifstat->st_uid, ifstat->st_gid); /* Copy ownership */ ! 1222: #endif ! 1223: remove_ofname = 0; ! 1224: /* It's now safe to remove the input file: */ ! 1225: (void) chmod(ifname, 0777); ! 1226: if (unlink(ifname)) { ! 1227: if (!quiet) perror(ifname); ! 1228: WARN((stderr, " unlink error (ignored)\n")); ! 1229: } ! 1230: } ! 1231: ! 1232: #ifndef NO_DIR ! 1233: ! 1234: /* ======================================================================== ! 1235: * Recurse through the given directory. This code is taken from ncompress. ! 1236: */ ! 1237: local void treat_dir(dir) ! 1238: char *dir; ! 1239: { ! 1240: dir_type *dp; ! 1241: DIR *dirp; ! 1242: char nbuf[MAX_PATH_LEN]; ! 1243: ! 1244: dirp = opendir(dir); ! 1245: ! 1246: if (dirp == NULL) { ! 1247: fprintf(stderr, "%s unreadable\n", dir); ! 1248: exit_code = ERROR; ! 1249: return ; ! 1250: } ! 1251: /* ! 1252: ** WARNING: the following algorithm could occasionally cause ! 1253: ** compress to produce error warnings of the form "<filename>.z ! 1254: ** already has .z suffix - ignored". This occurs when the ! 1255: ** .z output file is inserted into the directory below ! 1256: ** readdir's current pointer. ! 1257: ** These warnings are harmless but annoying, so they are suppressed ! 1258: ** with option -r (except when -v is on). An alternative ! 1259: ** to allowing this would be to store the entire directory ! 1260: ** list in memory, then compress the entries in the stored ! 1261: ** list. Given the depth-first recursive algorithm used here, ! 1262: ** this could use up a tremendous amount of memory. I don't ! 1263: ** think it's worth it. -- Dave Mack ! 1264: ** (An other alternative might be two passes to avoid depth-first.) ! 1265: */ ! 1266: ! 1267: while ((dp = readdir(dirp)) != NULL) { ! 1268: ! 1269: if (strequ(dp->d_name,".") || strequ(dp->d_name,"..")) { ! 1270: continue; ! 1271: } ! 1272: if (((int)strlen(dir) + NLENGTH(dp) + 1) < (MAX_PATH_LEN - 1)) { ! 1273: strcpy(nbuf,dir); ! 1274: if (strlen(dir) != 0) { /* dir = "" means current dir on Amiga */ ! 1275: #ifdef OTHER_PATH_SEP ! 1276: if (dir[strlen(dir)-1] != OTHER_PATH_SEP) ! 1277: #endif ! 1278: strcat(nbuf,"/"); ! 1279: } ! 1280: strcat(nbuf,dp->d_name); ! 1281: treat_file(nbuf); ! 1282: } else { ! 1283: fprintf(stderr,"Pathname too long: %s/%s\n", dir, dp->d_name); ! 1284: exit_code = ERROR; ! 1285: } ! 1286: } ! 1287: closedir(dirp); ! 1288: } ! 1289: #endif /* ? NO_DIR */ ! 1290: ! 1291: /* ======================================================================== ! 1292: * Free all dynamically allocated variables and exit with the given code. ! 1293: */ ! 1294: local void do_exit(exitcode) ! 1295: int exitcode; ! 1296: { ! 1297: if (env != NULL) free(env), env = NULL; ! 1298: if (args != NULL) free(args), args = NULL; ! 1299: FREE(inbuf); ! 1300: FREE(outbuf); ! 1301: FREE(d_buf); ! 1302: FREE(window); ! 1303: #ifndef MAXSEG_64K ! 1304: FREE(tab_prefix); ! 1305: #else ! 1306: FREE(tab_prefix0); ! 1307: FREE(tab_prefix1); ! 1308: #endif ! 1309: exit(exitcode); ! 1310: } ! 1311: ! 1312: /* ======================================================================== ! 1313: * Signal and error handler. ! 1314: */ ! 1315: RETSIGTYPE abort_gzip() ! 1316: { ! 1317: if (remove_ofname) { ! 1318: close(ofd); ! 1319: unlink (ofname); ! 1320: } ! 1321: do_exit(ERROR); ! 1322: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.