/* gzip (GNU zip) -- compress files with zip algorithm and 'compress' interface
* Copyright (C) 1992-1993 Jean-loup Gailly
* The unzip code was written and put in the public domain by Mark Adler.
* Portions of the lzw code are derived from the public domain 'compress'
* written by Spencer Thomas, Joe Orost, James Woods, Jim McKie, Steve Davies,
* Ken Turkowski, Dave Mack and Peter Jannesen.
* See the license_msg below and the file COPYING for the software license.
* See the file algorithm.doc for the compression algorithms and file formats.
static char *license_msg
[] = {
" Copyright (C) 1992-1993 Jean-loup Gailly",
" This program is free software; you can redistribute it and/or modify",
" it under the terms of the GNU General Public License as published by",
" the Free Software Foundation; either version 2, or (at your option)",
" This program is distributed in the hope that it will be useful,",
" but WITHOUT ANY WARRANTY; without even the implied warranty of",
" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the",
" GNU General Public License for more details.",
" You should have received a copy of the GNU General Public License",
" along with this program; if not, write to the Free Software",
" Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.",
/* Compress files with zip algorithm and 'compress' interface.
* See usage() and help() functions below for all options.
* file.gz: compressed file with same mode, owner, and utimes
* or stdout with -c option or if stdin used as input.
* If the output file name had to be truncated, the original name is kept
* in the compressed file.
* On MSDOS, file.tmp -> file.tmz. On VMS, file.tmp -> file.tmp-gz.
* Using gz on MSDOS would create too many file name conflicts. For
* example, foo.txt -> foo.tgz (.tgz must be reserved as shorthand for
* tar.gz). Similarly, foo.dir and foo.doc would both be mapped to foo.dgz.
* I also considered 12345678.txt -> 12345txt.gz but this truncates the name
* too heavily. There is no ideal solution given the MSDOS 8+3 limitation.
* For the meaning of all compilation flags, see comments in Makefile.in.
static char rcsid
[] = "$Id: gzip.c,v 0.24 1993/06/24 10:52:07 jloup Exp $";
#if defined(STDC_HEADERS) || !defined(NO_STDLIB_H)
typedef struct dirent dir_type
;
# define NLENGTH(dirent) ((int)strlen((dirent)->d_name))
# define DIR_OPT "DIRENT"
# define NLENGTH(dirent) ((dirent)->d_namlen)
typedef struct direct dir_type
;
# define DIR_OPT "SYSDIR"
typedef struct direct dir_type
;
# define DIR_OPT "SYSNDIR"
typedef struct direct dir_type
;
# define DIR_OPT "NO_DIR"
# define TIME_OPT "UTIME"
# define TIME_OPT "SYS_UTIME"
# define TIME_OPT "NO_UTIME"
#if !defined(S_ISDIR) && defined(S_IFDIR)
# define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
#if !defined(S_ISREG) && defined(S_IFREG)
# define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
typedef RETSIGTYPE (*sig_type
) OF((int));
# define O_BINARY 0 /* creation mode for open() */
#define RW_USER (S_IRUSR | S_IWUSR) /* creation mode for open() */
# define MAX_PATH_LEN 1024 /* max pathname length */
off_t lseek
OF((int fd
, off_t offset
, int whence
));
/* Separator for file name parts (see shorten_name()) */
DECLARE(uch
, inbuf
, INBUFSIZ
+INBUF_EXTRA
);
DECLARE(uch
, outbuf
, OUTBUFSIZ
+OUTBUF_EXTRA
);
DECLARE(ush
, d_buf
, DIST_BUFSIZE
);
DECLARE(uch
, window
, 2L*WSIZE
);
DECLARE(ush
, tab_prefix
, 1L<<BITS
);
DECLARE(ush
, tab_prefix0
, 1L<<(BITS
-1));
DECLARE(ush
, tab_prefix1
, 1L<<(BITS
-1));
int ascii
= 0; /* convert end-of-lines to local OS conventions */
int to_stdout
= 0; /* output to stdout (-c) */
int decompress
= 0; /* decompress (-d) */
int force
= 0; /* don't ask questions, compress links (-f) */
int no_name
= -1; /* don't save or restore the original file name */
int no_time
= -1; /* don't save or restore the original file time */
int recursive
= 0; /* recurse through directories (-r) */
int list
= 0; /* list the file contents (-l) */
int verbose
= 0; /* be verbose (-v) */
int quiet
= 0; /* be very quiet (-q) */
int do_lzw
= 0; /* generate output compatible with old compress (-Z) */
int test
= 0; /* test .gz file integrity */
int foreground
; /* set if program run in foreground */
char *progname
; /* program name */
int maxbits
= BITS
; /* max bits per code for LZW */
int method
= DEFLATED
;/* compression method */
int level
= 6; /* compression level */
int exit_code
= OK
; /* program exit code */
int save_orig_name
; /* set if original name must be saved */
int last_member
; /* set for .zip and .Z files */
int part_nb
; /* number of parts in .gz file */
long time_stamp
; /* original time stamp (modification time) */
long ifile_size
; /* input file size, -1 for devices (debug only) */
char *env
; /* contents of GZIP env variable */
char **args
= NULL
; /* argv pointer if GZIP env variable defined */
char z_suffix
[MAX_SUFFIX
+1]; /* default suffix (can be set with --suffix) */
int z_len
; /* strlen(z_suffix) */
long bytes_in
; /* number of input bytes */
long bytes_out
; /* number of output bytes */
long total_in
= 0; /* input bytes for all files */
long total_out
= 0; /* output bytes for all files */
char ifname
[MAX_PATH_LEN
]; /* input file name */
char ofname
[MAX_PATH_LEN
]; /* output file name */
int remove_ofname
= 0; /* remove output file on error */
struct stat istat
; /* status for input file */
int ifd
; /* input file descriptor */
int ofd
; /* output file descriptor */
unsigned insize
; /* valid bytes in inbuf */
unsigned inptr
; /* index of next byte to be processed in inbuf */
unsigned outcnt
; /* bytes in output buffer */
struct option longopts
[] =
/* { name has_arg *flag val } */
{"ascii", 0, 0, 'a'}, /* ascii text mode */
{"to-stdout", 0, 0, 'c'}, /* write output on standard output */
{"stdout", 0, 0, 'c'}, /* write output on standard output */
{"decompress", 0, 0, 'd'}, /* decompress */
{"uncompress", 0, 0, 'd'}, /* decompress */
/* {"encrypt", 0, 0, 'e'}, encrypt */
{"force", 0, 0, 'f'}, /* force overwrite of output file */
{"help", 0, 0, 'h'}, /* give help */
/* {"pkzip", 0, 0, 'k'}, force output in pkzip format */
{"list", 0, 0, 'l'}, /* list .gz file contents */
{"license", 0, 0, 'L'}, /* display software license */
{"no-name", 0, 0, 'n'}, /* don't save or restore original name & time */
{"name", 0, 0, 'N'}, /* save or restore original name & time */
{"quiet", 0, 0, 'q'}, /* quiet mode */
{"silent", 0, 0, 'q'}, /* quiet mode */
{"recursive", 0, 0, 'r'}, /* recurse through directories */
{"suffix", 1, 0, 'S'}, /* use given suffix instead of .gz */
{"test", 0, 0, 't'}, /* test compressed file integrity */
{"no-time", 0, 0, 'T'}, /* don't save or restore the time stamp */
{"verbose", 0, 0, 'v'}, /* verbose mode */
{"version", 0, 0, 'V'}, /* display version number */
{"fast", 0, 0, '1'}, /* compress faster */
{"best", 0, 0, '9'}, /* compress better */
{"lzw", 0, 0, 'Z'}, /* make output compatible with old compress */
{"bits", 1, 0, 'b'}, /* max number of bits per code (implies -Z) */
local
void usage
OF((void));
local
void help
OF((void));
local
void license
OF((void));
local
void version
OF((void));
local
void treat_stdin
OF((void));
local
void treat_file
OF((char *iname
));
local
int create_outfile
OF((void));
local
int do_stat
OF((char *name
, struct stat
*sbuf
));
local
char *get_suffix
OF((char *name
));
local
int get_istat
OF((char *iname
, struct stat
*sbuf
));
local
int make_ofname
OF((void));
local
int same_file
OF((struct stat
*stat1
, struct stat
*stat2
));
local
int name_too_long
OF((char *name
, struct stat
*statb
));
local
void shorten_name
OF((char *name
));
local
int get_method
OF((int in
));
local
void do_list
OF((int ifd
, int method
));
local
int check_ofname
OF((void));
local
void copy_stat
OF((struct stat
*ifstat
));
local
void do_exit
OF((int exitcode
));
int main
OF((int argc
, char **argv
));
int (*work
) OF((int infile
, int outfile
)) = zip
; /* function to call */
local
void treat_dir
OF((char *dir
));
local
void reset_times
OF((char *name
, struct stat
*statb
));
#define strequ(s1, s2) (strcmp((s1),(s2)) == 0)
/* ======================================================================== */
fprintf(stderr
, "usage: %s [-%scdfhlLnN%stvV19] [-S suffix] [file ...]\n",
/* ======================================================================== */
static char *help_msg
[] = {
" -a --ascii ascii text; convert end-of-lines using local conventions",
" -c --stdout write on standard output, keep original files unchanged",
" -d --decompress decompress",
/* -e --encrypt encrypt */
" -f --force force overwrite of output file and compress links",
" -h --help give this help",
/* -k --pkzip force output in pkzip format */
" -l --list list compressed file contents",
" -L --license display software license",
" -m --no-time do not save or restore the original modification time",
" -M --time save or restore the original modification time",
" -n --no-name do not save or restore the original name and time stamp",
" -N --name save or restore the original name and time stamp",
" -q --quiet suppress all warnings",
" -r --recursive operate recursively on directories",
" -S .suf --suffix .suf use suffix .suf on compressed files",
" -t --test test compressed file integrity",
" -v --verbose verbose mode",
" -V --version display version number",
" -1 --fast compress faster",
" -9 --best compress better",
" -Z --lzw produce output compatible with old compress",
" -b --bits maxbits max number of bits per code (implies -Z)",
" file... files to (de)compress. If none given, use standard input.",
fprintf(stderr
,"%s %s (%s)\n", progname
, VERSION
, REVDATE
);
while (*p
) fprintf(stderr
, "%s\n", *p
++);
/* ======================================================================== */
fprintf(stderr
,"%s %s (%s)\n", progname
, VERSION
, REVDATE
);
while (*p
) fprintf(stderr
, "%s\n", *p
++);
/* ======================================================================== */
fprintf(stderr
,"%s %s (%s)\n", progname
, VERSION
, REVDATE
);
fprintf(stderr
, "Compilation options:\n%s %s ", DIR_OPT
, TIME_OPT
);
fprintf(stderr
, "STDC_HEADERS ");
fprintf(stderr
, "HAVE_UNISTD_H ");
fprintf(stderr
, "NO_MEMORY_H ");
fprintf(stderr
, "NO_STRING_H ");
fprintf(stderr
, "NO_SYMLINK ");
fprintf(stderr
, "NO_MULTIPLE_DOTS ");
fprintf(stderr
, "NO_CHOWN ");
fprintf(stderr
, "PROTO ");
fprintf(stderr
, "ASMV ");
fprintf(stderr
, "DEBUG ");
fprintf(stderr
, "DYN_ALLOC ");
fprintf(stderr
, "MAXSEG_64K");
/* ======================================================================== */
int file_count
; /* number of files to precess */
int proglen
; /* length of progname */
int optc
; /* current option */
EXPAND(argc
, argv
); /* wild card expansion if necessary */
progname
= basename(argv
[0]);
proglen
= strlen(progname
);
/* Suppress .exe for MSDOS, OS/2 and VMS: */
if (proglen
> 4 && strequ(progname
+proglen
-4, ".exe")) {
progname
[proglen
-4] = '\0';
/* Add options in GZIP environment variable if there is one */
env
= add_envopt(&argc
, &argv
, OPTIONS_VAR
);
if (env
!= NULL
) args
= argv
;
foreground
= signal(SIGINT
, SIG_IGN
) != SIG_IGN
;
(void) signal (SIGINT
, (sig_type
)abort_gzip
);
if (signal(SIGTERM
, SIG_IGN
) != SIG_IGN
) {
(void) signal(SIGTERM
, (sig_type
)abort_gzip
);
if (signal(SIGHUP
, SIG_IGN
) != SIG_IGN
) {
(void) signal(SIGHUP
, (sig_type
)abort_gzip
);
/* For compatibility with old compress, use program name as an option.
* If you compile with -DGNU_STANDARD, this program will behave as
* gzip even if it is invoked under the name gunzip or zcat.
* Systems which do not support links can still use -d or -dc.
* Ignore an .exe extension for MSDOS, OS/2 and VMS.
if ( strncmp(progname
, "un", 2) == 0 /* ungzip, uncompress */
|| strncmp(progname
, "gun", 3) == 0) { /* gunzip */
} else if (strequ(progname
+1, "cat") /* zcat, pcat, gcat */
|| strequ(progname
, "gzcat")) { /* gzcat */
decompress
= to_stdout
= 1;
strncpy(z_suffix
, Z_SUFFIX
, sizeof(z_suffix
)-1);
z_len
= strlen(z_suffix
);
while ((optc
= getopt_long (argc
, argv
, "ab:cdfhH?lLmMnNqrS:tvVZ123456789",
longopts
, (int *)0)) != EOF
) {
case 'h': case 'H': case '?':
help(); do_exit(OK
); break;
list
= decompress
= to_stdout
= 1; break;
license(); do_exit(OK
); break;
case 'm': /* undocumented, may change later */
case 'M': /* undocumented, may change later */
no_name
= no_time
= 1; break;
no_name
= no_time
= 0; break;
quiet
= 1; verbose
= 0; break;
fprintf(stderr
, "%s: -r not supported on this system\n", progname
);
if (*optarg
== '.') optarg
++;
strcpy(z_suffix
, optarg
);
test
= decompress
= to_stdout
= 1;
verbose
++; quiet
= 0; break;
version(); do_exit(OK
); break;
fprintf(stderr
, "%s: -Z not supported in this version\n",
case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
/* Error message already emitted by getopt_long. */
} /* loop on all arguments */
/* By default, save name and timestamp on compression but do not
* restore them on decompression.
if (no_time
< 0) no_time
= decompress
;
if (no_name
< 0) no_name
= decompress
;
file_count
= argc
- optind
;
fprintf(stderr
, "%s: option --ascii ignored on this system\n",
if ((z_len
== 0 && !decompress
) || z_len
> MAX_SUFFIX
) {
fprintf(stderr
, "%s: incorrect suffix '%s'\n",
if (do_lzw
&& !decompress
) work
= lzw
;
/* Allocate all global buffers (for DYN_ALLOC option) */
ALLOC(uch
, inbuf
, INBUFSIZ
+INBUF_EXTRA
);
ALLOC(uch
, outbuf
, OUTBUFSIZ
+OUTBUF_EXTRA
);
ALLOC(ush
, d_buf
, DIST_BUFSIZE
);
ALLOC(uch
, window
, 2L*WSIZE
);
ALLOC(ush
, tab_prefix
, 1L<<BITS
);
ALLOC(ush
, tab_prefix0
, 1L<<(BITS
-1));
ALLOC(ush
, tab_prefix1
, 1L<<(BITS
-1));
if (to_stdout
&& !test
&& !list
&& (!decompress
|| !ascii
)) {
SET_BINARY_MODE(fileno(stdout
));
treat_file(argv
[optind
++]);
} else { /* Standard input */
if (list
&& !quiet
&& file_count
> 1) {
do_list(-1, -1); /* print totals */
return exit_code
; /* just to avoid lint warning */
/* ========================================================================
* Compress or decompress stdin
isatty(fileno((FILE *)(decompress
? stdin
: stdout
)))) {
/* Do not send compressed data to the terminal or read it from
* the terminal. We get here when user invoked the program
* without parameters, so be helpful. According to the GNU standards:
* If there is one behavior you think is most useful when the output
* is to a terminal, and another that you think is most useful when
* the output is a file or a pipe, then it is usually best to make
* the default behavior the one that is useful with output to a
* terminal, and have an option for the other behavior.
* Here we use the --force option to get the other behavior.
"%s: compressed data not %s a terminal. Use -f to force %scompression.\n",
progname
, decompress
? "read from" : "written to",
fprintf(stderr
,"For help, type: %s -h\n", progname
);
if (decompress
|| !ascii
) {
SET_BINARY_MODE(fileno(stdin
));
if (!test
&& !list
&& (!decompress
|| !ascii
)) {
SET_BINARY_MODE(fileno(stdout
));
strcpy(ofname
, "stdout");
/* Get the time stamp on the input file. */
time_stamp
= 0; /* time unknown by default */
if (fstat(fileno(stdin
), &istat
) != 0) {
# ifdef NO_PIPE_TIMESTAMP
if (S_ISREG(istat
.st_mode
))
time_stamp
= istat
.st_mtime
;
#endif /* NO_STDIN_FSTAT */
ifile_size
= -1L; /* convention for unknown size */
clear_bufs(); /* clear input and output buffers */
method
= get_method(ifd
);
do_exit(exit_code
); /* error message already emitted */
/* Actually do the compression/decompression. Loop over zipped members.
if ((*work
)(fileno(stdin
), fileno(stdout
)) != OK
) return;
if (!decompress
|| last_member
|| inptr
== insize
) break;
method
= get_method(ifd
);
if (method
< 0) return; /* error message already emitted */
bytes_out
= 0; /* required for length check */
fprintf(stderr
, " OK\n");
} else if (!decompress
) {
display_ratio(bytes_in
-(bytes_out
-header_bytes
), bytes_in
, stderr
);
#ifdef DISPLAY_STDIN_RATIO
display_ratio(bytes_out
-(bytes_in
-header_bytes
), bytes_out
,stderr
);
/* ========================================================================
* Compress or decompress the given file
local
void treat_file(iname
)
/* Accept "-" as synonym for stdin */
if (strequ(iname
, "-")) {
/* Check if the input file is present, set ifname and istat: */
if (get_istat(iname
, &istat
) != OK
) return;
/* If the input name is that of a directory, recurse or ignore: */
if (S_ISDIR(istat
.st_mode
)) {
/* Warning: ifname is now garbage */
reset_times (iname
, &st
);
WARN((stderr
,"%s: %s is a directory -- ignored\n", progname
, ifname
));
if (!S_ISREG(istat
.st_mode
)) {
"%s: %s is not a directory or a regular file - ignored\n",
if (istat
.st_nlink
> 1 && !to_stdout
&& !force
) {
WARN((stderr
, "%s: %s has %d other link%c -- unchanged\n",
(int)istat
.st_nlink
- 1, istat
.st_nlink
> 2 ? 's' : ' '));
ifile_size
= istat
.st_size
;
time_stamp
= no_time
&& !list
? 0 : istat
.st_mtime
;
/* Generate output file name. For -r and (-t or -l), skip files
* without a valid gzip suffix (check done in make_ofname).
if (to_stdout
&& !list
&& !test
) {
strcpy(ofname
, "stdout");
} else if (make_ofname() != OK
) {
/* Open the input file and determine compression method. The mode
* parameter is ignored but required by some systems (VMS) and forbidden
* on other systems (MacOS).
ifd
= OPEN(ifname
, ascii
&& !decompress
? O_RDONLY
: O_RDONLY
| O_BINARY
,
fprintf(stderr
, "%s: ", progname
);
clear_bufs(); /* clear input and output buffers */
method
= get_method(ifd
); /* updates ofname if original given */
return; /* error message already emitted */
/* If compressing to a file, check if ofname is not ambiguous
* because the operating system truncates names. Otherwise, generate
* a new ofname and save the original name in the compressed file.
/* keep remove_ofname as zero */
if (create_outfile() != OK
) return;
if (!decompress
&& save_orig_name
&& !verbose
&& !quiet
) {
fprintf(stderr
, "%s: %s compressed to %s\n",
progname
, ifname
, ofname
);
/* Keep the name even if not truncated except with --no-name: */
if (!save_orig_name
) save_orig_name
= !no_name
;
fprintf(stderr
, "%s:\t%s", ifname
, (int)strlen(ifname
) >= 15 ?
"" : ((int)strlen(ifname
) >= 7 ? "\t" : "\t\t"));
/* Actually do the compression/decompression. Loop over zipped members.
if ((*work
)(ifd
, ofd
) != OK
) {
method
= -1; /* force cleanup */
if (!decompress
|| last_member
|| inptr
== insize
) break;
method
= get_method(ifd
);
if (method
< 0) break; /* error message already emitted */
bytes_out
= 0; /* required for length check */
if (!to_stdout
&& close(ofd
)) {
if (!to_stdout
) unlink (ofname
);
display_ratio(bytes_out
-(bytes_in
-header_bytes
), bytes_out
,stderr
);
display_ratio(bytes_in
-(bytes_out
-header_bytes
), bytes_in
, stderr
);
if (!test
&& !to_stdout
) {
fprintf(stderr
, " -- replaced with %s", ofname
);
/* Copy modes, times, ownership, and remove the input file */
/* ========================================================================
* Create the output file. Return OK or ERROR.
* Try several times if necessary to avoid truncating the z_suffix. For
* example, do not create a compressed file of name "1234567890123."
* Sets save_orig_name to true if the file name has been truncated.
* IN assertions: the input file has already been open (ifd is set) and
* ofname has already been updated if there was an original name.
* OUT assertions: ifd and ofd are closed in case of error.
local
int create_outfile()
struct stat ostat
; /* stat for ofname */
int flags
= O_WRONLY
| O_CREAT
| O_EXCL
| O_BINARY
;
if (ascii
&& decompress
) {
flags
&= ~O_BINARY
; /* force ascii text mode */
/* Make sure that ofname is not an existing file */
if (check_ofname() != OK
) {
/* Create the output file */
ofd
= OPEN(ofname
, flags
, RW_USER
);
/* Check for name truncation on new file (1234567890123.gz) */
if (stat(ofname
, &ostat
) != 0) {
if (fstat(ofd
, &ostat
) != 0) {
fprintf(stderr
, "%s: ", progname
);
if (!name_too_long(ofname
, &ostat
)) return OK
;
/* name might be too long if an original name was saved */
WARN((stderr
, "%s: %s: warning, name truncated\n",
/* Should never happen, see check_ofname() */
fprintf(stderr
, "%s: %s: name too long\n", progname
, ofname
);
/* ========================================================================
* Use lstat if available, except for -c or -f. Use stat otherwise.
* This allows links when not removing the original file.
local
int do_stat(name
, sbuf
)
#if (defined(S_IFLNK) || defined (S_ISLNK)) && !defined(NO_SYMLINK)
if (!to_stdout
&& !force
) {
return lstat(name
, sbuf
);
/* ========================================================================
* Return a pointer to the 'z' suffix of a file name, or NULL. For all
* systems, ".gz", ".z", ".Z", ".taz", ".tgz", "-gz", "-z" and "_z" are
* accepted suffixes, in addition to the value of the --suffix option.
* ".tgz" is a useful convention for tar.z files on systems limited
* to 3 characters extensions. On such systems, ".?z" and ".??z" are
* also accepted suffixes. For Unix, we do not want to accept any
* .??z suffix as indicating a compressed file; some people use .xyz
* On systems allowing multiple versions of the same file (such as VMS),
* this function removes any version suffix in the given name.
local
char *get_suffix(name
)
char suffix
[MAX_SUFFIX
+3]; /* last chars of name, forced to lower case */
static char *known_suffixes
[] =
{z_suffix
, ".gz", ".z", ".taz", ".tgz", "-gz", "-z", "_z",
char **suf
= known_suffixes
;
if (strequ(z_suffix
, "z")) suf
++; /* check long suffixes first */
/* strip a version number from the file name */
char *v
= strrchr(name
, SUFFIX_SEP
);
if (v
!= NULL
) *v
= '\0';
if (nlen
<= MAX_SUFFIX
+2) {
strcpy(suffix
, name
+nlen
-MAX_SUFFIX
-2);
if (slen
> s
&& suffix
[slen
-s
-1] != PATH_SEP
&& strequ(suffix
+ slen
- s
, *suf
)) {
} while (*++suf
!= NULL
);
/* ========================================================================
* Set ifname to the input file name (with a suffix appended if necessary)
* and istat to its stats. For decompression, if no file exists with the
* original name, try adding successively z_suffix, .gz, .z, -z and .Z.
* For MSDOS, we try only z_suffix and z.
local
int get_istat(iname
, sbuf
)
int ilen
; /* strlen(ifname) */
static char *suffixes
[] = {z_suffix
, ".gz", ".z", "-z", ".Z", NULL
};
char *dot
; /* pointer to ifname extension, or NULL */
/* If input file exists, return OK. */
if (do_stat(ifname
, sbuf
) == 0) return OK
;
if (!decompress
|| errno
!= ENOENT
) {
/* file.ext doesn't exist, try adding a suffix (after removing any
* version number for VMS).
perror(ifname
); /* ifname already has z suffix and does not exist */
dot
= strrchr(ifname
, '.');
dot
= strrchr(ifname
, '.');
if (strequ(z_suffix
, ".gz")) suf
++;
/* Search for all suffixes */
/* Needed if the suffixes are not sorted by increasing length */
if (*dot
== '\0') strcpy(dot
, ".");
dot
[MAX_EXT_CHARS
+1-strlen(s
)] = '\0';
if (do_stat(ifname
, sbuf
) == 0) return OK
;
} while (*++suf
!= NULL
);
/* No suffix found, complain using z_suffix: */
if (*dot
== '\0') strcpy(dot
, ".");
dot
[MAX_EXT_CHARS
+1-z_len
] = '\0';
strcat(ifname
, z_suffix
);
/* ========================================================================
* Generate ofname given ifname. Return OK, or WARNING if file must be skipped.
* Sets save_orig_name to true if the file name has been truncated.
char *suff
; /* ofname z suffix */
/* strip a version number if any and get the gzip suffix if present: */
suff
= get_suffix(ofname
);
/* Whith -t or -l, try all files (even without .gz suffix)
* except with -r (behave as with just -dr).
if (!recursive
&& (list
|| test
)) return OK
;
/* Avoid annoying messages with -r */
if (verbose
|| (!recursive
&& !quiet
)) {
WARN((stderr
,"%s: %s: unknown suffix -- ignored\n",
/* Make a special case for .tgz and .taz: */
if (strequ(suff
, ".tgz") || strequ(suff
, ".taz")) {
*suff
= '\0'; /* strip the z suffix */
/* ofname might be changed later if infile contains an original name */
} else if (suff
!= NULL
) {
/* Avoid annoying messages with -r (see treat_dir()) */
if (verbose
|| (!recursive
&& !quiet
)) {
fprintf(stderr
, "%s: %s already has %s suffix -- unchanged\n",
if (exit_code
== OK
) exit_code
= WARNING
;
suff
= strrchr(ofname
, '.');
if (strequ(z_suffix
, "z")) {
strcat(ofname
, "gz"); /* enough room */
/* On the Atari and some versions of MSDOS, name_too_long()
* does not work correctly because of a bug in stat(). So we
} else if (strlen(suff
)-1 + z_len
> MAX_SUFFIX
) {
suff
[MAX_SUFFIX
+1-z_len
] = '\0';
#endif /* NO_MULTIPLE_DOTS */
strcat(ofname
, z_suffix
);
/* ========================================================================
* Check the magic number of the input file and update ofname if an
* original name was given and to_stdout is not set.
* Return the compression method, -1 for error, -2 for warning.
* Set inptr to the offset of the next byte to be processed.
* Updates time_stamp if there is one and --no-time is not used.
* This function may be called repeatedly for an input file consisting
* of several contiguous gzip'ed members.
* IN assertions: there is at least one remaining compressed member.
* If the member is a zip file, it must be the only one.
int in
; /* input file descriptor */
uch flags
; /* compression flags */
char magic
[2]; /* magic header */
ulg stamp
; /* time stamp */
/* If --force and --stdout, zcat == cat, so do not complain about
* premature end of file: use try_byte instead of get_byte.
if (force
&& to_stdout
) {
magic
[0] = (char)try_byte();
magic
[1] = (char)try_byte();
/* If try_byte returned EOF, magic[1] == 0xff */
magic
[0] = (char)get_byte();
magic
[1] = (char)get_byte();
method
= -1; /* unknown yet */
part_nb
++; /* number of parts in gzip file */
/* assume multiple members in gzip file except for record oriented I/O */
if (memcmp(magic
, GZIP_MAGIC
, 2) == 0
|| memcmp(magic
, OLD_GZIP_MAGIC
, 2) == 0) {
method
= (int)get_byte();
if (method
!= DEFLATED
) {
"%s: %s: unknown method %d -- get newer version of gzip\n",
progname
, ifname
, method
);
if ((flags
& ENCRYPTED
) != 0) {
"%s: %s is encrypted -- get newer version of gzip\n",
if ((flags
& CONTINUATION
) != 0) {
"%s: %s is a a multi-part gzip file -- get newer version of gzip\n",
if (force
<= 1) return -1;
if ((flags
& RESERVED
) != 0) {
"%s: %s has flags 0x%x -- get newer version of gzip\n",
progname
, ifname
, flags
);
if (force
<= 1) return -1;
stamp
|= ((ulg
)get_byte()) << 8;
stamp
|= ((ulg
)get_byte()) << 16;
stamp
|= ((ulg
)get_byte()) << 24;
if (stamp
!= 0 && !no_time
) time_stamp
= stamp
;
(void)get_byte(); /* Ignore extra flags for the moment */
(void)get_byte(); /* Ignore OS type for the moment */
if ((flags
& CONTINUATION
) != 0) {
unsigned part
= (unsigned)get_byte();
part
|= ((unsigned)get_byte())<<8;
fprintf(stderr
,"%s: %s: part number %u\n",
if ((flags
& EXTRA_FIELD
) != 0) {
unsigned len
= (unsigned)get_byte();
len
|= ((unsigned)get_byte())<<8;
fprintf(stderr
,"%s: %s: extra field of %u bytes ignored\n",
while (len
--) (void)get_byte();
/* Get original file name if it was truncated */
if ((flags
& ORIG_NAME
) != 0) {
if (no_name
|| (to_stdout
&& !list
) || part_nb
> 1) {
/* Discard the old name */
char c
; /* dummy used for NeXTstep 3.0 cc optimizer bug */
do {c
=get_byte();} while (c
!= 0);
/* Copy the base name. Keep a directory prefix intact. */
char *p
= basename(ofname
);
if (p
>= ofname
+sizeof(ofname
)) {
error("corrupted input -- file name too large");
/* If necessary, adapt the name to local OS conventions: */
if (base
) list
=0; /* avoid warning about unused variable */
} /* no_name || to_stdout */
/* Discard file comment if any */
if ((flags
& COMMENT
) != 0) {
while (get_char() != 0) /* null */ ;
header_bytes
= inptr
+ 2*sizeof(long); /* include crc and size */
} else if (memcmp(magic
, PKZIP_MAGIC
, 2) == 0 && inptr
== 2
&& memcmp((char*)inbuf
, PKZIP_MAGIC
, 4) == 0) {
/* To simplify the code, we support a zip file when alone only.
* We are thus guaranteed that the entire local header fits in inbuf.
if (check_zipfile(in
) != OK
) return -1;
/* check_zipfile may get ofname from the local header */
} else if (memcmp(magic
, PACK_MAGIC
, 2) == 0) {
} else if (memcmp(magic
, LZW_MAGIC
, 2) == 0) {
} else if (memcmp(magic
, LZH_MAGIC
, 2) == 0) {
} else if (force
&& to_stdout
&& !list
) { /* pass input unchanged */
if (method
>= 0) return method
;
fprintf(stderr
, "\n%s: %s: not in gzip format\n", progname
, ifname
);
WARN((stderr
, "\n%s: %s: decompression OK, trailing garbage ignored\n",
/* ========================================================================
* Display the characteristics of the compressed file.
* If the given method is < 0, display the accumulated totals.
* IN assertions: time_stamp, header_bytes and ifile_size are initialized.
local
void do_list(ifd
, method
)
int ifd
; /* input file descriptor */
int method
; /* compression method */
ulg crc
; /* original crc */
static int first_time
= 1;
static char* methods
[MAX_METHODS
] = {
"", "", "", "", /* 4 to 7 reserved */
if (first_time
&& method
>= 0) {
printf("method crc date time ");
printf("compressed uncompr. ratio uncompressed_name\n");
if (total_in
<= 0 || total_out
<= 0) return;
printf("%9ld %9ld ", total_in
, total_out
);
display_ratio(total_out
-(total_in
-header_bytes
), total_out
, stdout
);
/* header_bytes is not meaningful but used to ensure the same
* ratio if there is a single file.
crc
= (ulg
)~0; /* unknown */
if (method
== DEFLATED
&& !last_member
) {
/* Get the crc and uncompressed size for gzip'ed (not zip'ed) files.
* If the lseek fails, we could use read() to get to the end, but
* --list is used to get quick results.
* Use "gunzip < foo.gz | wc -c" to get the uncompressed size if
* you are not concerned about speed.
bytes_in
= (long)lseek(ifd
, (off_t
)(-8), SEEK_END
);
if (read(ifd
, (char*)buf
, sizeof(buf
)) != sizeof(buf
)) {
date
= ctime((time_t*)&time_stamp
) + 4; /* skip the day of the week */
date
[12] = '\0'; /* suppress the 1/100sec and the year */
printf("%5s %08lx %11s ", methods
[method
], crc
, date
);
printf("%9ld %9ld ", bytes_in
, bytes_out
);
bytes_in
= bytes_out
= header_bytes
= 0;
} else if (total_in
>= 0) {
bytes_in
= bytes_out
= header_bytes
= 0;
} else if (total_out
>= 0) {
display_ratio(bytes_out
-(bytes_in
-header_bytes
), bytes_out
, stdout
);
/* ========================================================================
* Return true if the two stat structures correspond to the same file.
local
int same_file(stat1
, stat2
)
return stat1
->st_ino
== stat2
->st_ino
&& stat1
->st_dev
== stat2
->st_dev
/* Can't rely on st_ino and st_dev, use other fields: */
&& stat1
->st_mode
== stat2
->st_mode
&& stat1
->st_uid
== stat2
->st_uid
&& stat1
->st_gid
== stat2
->st_gid
&& stat1
->st_size
== stat2
->st_size
&& stat1
->st_atime
== stat2
->st_atime
&& stat1
->st_mtime
== stat2
->st_mtime
&& stat1
->st_ctime
== stat2
->st_ctime
/* ========================================================================
* Return true if a file name is ambiguous because the operating system
local
int name_too_long(name
, statb
)
char *name
; /* file name to check */
struct stat
*statb
; /* stat buf for this file name */
struct stat tstat
; /* stat for truncated name */
tstat
= *statb
; /* Just in case OS does not fill all fields */
res
= stat(name
, &tstat
) == 0 && same_file(statb
, &tstat
);
Trace((stderr
, " too_long(%s) => %d\n", name
, res
));
/* ========================================================================
* Shorten the given name by one character, or replace a .tar extension
* with .tgz. Truncate the last part of the name which is longer than
* MIN_PART characters: 1234.678.012.gz -> 123.678.012.gz. If the name
* has only parts shorter than MIN_PART truncate the longest part.
* For decompression, just remove the last character of the name.
* IN assertion: for compression, the suffix of the given name is z_suffix.
local
void shorten_name(name
)
int len
; /* length of name without z_suffix */
char *trunc
= NULL
; /* character to be truncated */
int plen
; /* current part length */
int min_part
= MIN_PART
; /* current minimum part length */
if (len
<= 1) error("name too short");
if (p
== NULL
) error("can't recover suffix\n");
/* compress 1234567890.tar to 1234567890.tgz */
if (len
> 4 && strequ(p
-4, ".tar")) {
/* Try keeping short extensions intact:
* 1234.678.012.gz -> 123.678.012.gz
p
= strrchr(name
, PATH_SEP
);
plen
= strcspn(p
, PART_SEP
);
if (plen
> min_part
) trunc
= p
-1;
} while (trunc
== NULL
&& --min_part
!= 0);
trunc
= strrchr(name
, PART_SEP
[0]);
if (trunc
== NULL
) error("internal error in shorten_name");
if (trunc
[1] == '\0') trunc
--; /* force truncation */
/* ========================================================================
* If compressing to a file, check if ofname is not ambiguous
* because the operating system truncates names. Otherwise, generate
* a new ofname and save the original name in the compressed file.
* If the compressed file already exists, ask for confirmation.
* The check for name truncation is made dynamically, because different
* file systems on the same OS might use different truncation rules (on SVR4
* s5 truncates to 14 chars and ufs does not truncate).
* This function returns -1 if the file must be skipped, and
* updates save_orig_name if necessary.
* IN assertions: save_orig_name is already set if ofname has been
* already truncated because of NO_MULTIPLE_DOTS. The input file has
* already been open and istat is set.
struct stat ostat
; /* stat for ofname */
/* Check for strictly conforming Posix systems (which return ENAMETOOLONG
* instead of silently truncating filenames).
while (stat(ofname
, &ostat
) != 0) {
if (errno
!= ENAMETOOLONG
) return 0; /* ofname does not exist */
if (stat(ofname
, &ostat
) != 0) return 0;
/* Check for name truncation on existing file. Do this even on systems
* defining ENAMETOOLONG, because on most systems the strict Posix
* behavior is disabled by default (silent name truncation allowed).
if (!decompress
&& name_too_long(ofname
, &ostat
)) {
if (stat(ofname
, &ostat
) != 0) return 0;
/* Check that the input and output files are different (could be
* the same by name truncation or links).
if (same_file(&istat
, &ostat
)) {
if (strequ(ifname
, ofname
)) {
fprintf(stderr
, "%s: %s: cannot %scompress onto itself\n",
progname
, ifname
, decompress
? "de" : "");
fprintf(stderr
, "%s: %s and %s are the same file\n",
progname
, ifname
, ofname
);
/* Ask permission to overwrite the existing file */
fprintf(stderr
, "%s: %s already exists;", progname
, ofname
);
if (foreground
&& isatty(fileno(stdin
))) {
fprintf(stderr
, " do you wish to overwrite (y or n)? ");
(void)fgets(response
, sizeof(response
)-1, stdin
);
if (tolow(*response
) != 'y') {
fprintf(stderr
, "\tnot overwritten\n");
if (exit_code
== OK
) exit_code
= WARNING
;
(void) chmod(ofname
, 0777);
fprintf(stderr
, "%s: ", progname
);
/* ========================================================================
* Set the access and modification times from the given stat buffer.
local
void reset_times (name
, statb
)
/* Copy the time stamp */
timep
.actime
= statb
->st_atime
;
timep
.modtime
= statb
->st_mtime
;
/* Some systems (at least OS/2) do not support utime on directories */
if (utime(name
, &timep
) && !S_ISDIR(statb
->st_mode
)) {
WARN((stderr
, "%s: ", progname
));
if (!quiet
) perror(ofname
);
/* ========================================================================
* Copy modes, times, ownership from input file to output file.
* IN assertion: to_stdout is false.
local
void copy_stat(ifstat
)
if (decompress
&& time_stamp
!= 0 && ifstat
->st_mtime
!= time_stamp
) {
ifstat
->st_mtime
= time_stamp
;
fprintf(stderr
, "%s: time stamp restored\n", ofname
);
reset_times(ofname
, ifstat
);
/* Copy the protection modes */
if (chmod(ofname
, ifstat
->st_mode
& 07777)) {
WARN((stderr
, "%s: ", progname
));
if (!quiet
) perror(ofname
);
chown(ofname
, ifstat
->st_uid
, ifstat
->st_gid
); /* Copy ownership */
/* It's now safe to remove the input file: */
(void) chmod(ifname
, 0777);
WARN((stderr
, "%s: ", progname
));
if (!quiet
) perror(ifname
);
/* ========================================================================
* Recurse through the given directory. This code is taken from ncompress.
local
void treat_dir(dir
)
fprintf(stderr
, "%s: %s unreadable\n", progname
, dir
);
** WARNING: the following algorithm could occasionally cause
** compress to produce error warnings of the form "<filename>.gz
** already has .gz suffix - ignored". This occurs when the
** .gz output file is inserted into the directory below
** readdir's current pointer.
** These warnings are harmless but annoying, so they are suppressed
** with option -r (except when -v is on). An alternative
** to allowing this would be to store the entire directory
** list in memory, then compress the entries in the stored
** list. Given the depth-first recursive algorithm used here,
** this could use up a tremendous amount of memory. I don't
** think it's worth it. -- Dave Mack
** (An other alternative might be two passes to avoid depth-first.)
while ((dp
= readdir(dirp
)) != NULL
) {
if (strequ(dp
->d_name
,".") || strequ(dp
->d_name
,"..")) {
if (len
+ NLENGTH(dp
) + 1 < MAX_PATH_LEN
- 1) {
if (len
!= 0 /* dir = "" means current dir on Amiga */
&& dir
[len
-1] != PATH_SEP2
&& dir
[len
-1] != PATH_SEP3
strcpy(nbuf
+len
, dp
->d_name
);
fprintf(stderr
,"%s: %s/%s: pathname too long\n",
progname
, dir
, dp
->d_name
);
/* ========================================================================
* Free all dynamically allocated variables and exit with the given code.
local
void do_exit(exitcode
)
if (in_exit
) exit(exitcode
);
if (env
!= NULL
) free(env
), env
= NULL
;
if (args
!= NULL
) free((char*)args
), args
= NULL
;
/* ========================================================================
* Signal and error handler.