gzip.c revision 1.38 1 1.38 mrg /* $NetBSD: gzip.c,v 1.38 2004/04/26 03:01:55 mrg Exp $ */
2 1.1 mrg
3 1.1 mrg /*
4 1.37 mrg * Copyright (c) 1997, 1998, 2003, 2004 Matthew R. Green
5 1.1 mrg * All rights reserved.
6 1.1 mrg *
7 1.1 mrg * Redistribution and use in source and binary forms, with or without
8 1.1 mrg * modification, are permitted provided that the following conditions
9 1.1 mrg * are met:
10 1.1 mrg * 1. Redistributions of source code must retain the above copyright
11 1.1 mrg * notice, this list of conditions and the following disclaimer.
12 1.1 mrg * 2. Redistributions in binary form must reproduce the above copyright
13 1.1 mrg * notice, this list of conditions and the following disclaimer in the
14 1.1 mrg * documentation and/or other materials provided with the distribution.
15 1.1 mrg * 3. The name of the author may not be used to endorse or promote products
16 1.1 mrg * derived from this software without specific prior written permission.
17 1.1 mrg *
18 1.1 mrg * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 1.1 mrg * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 1.1 mrg * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 1.1 mrg * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 1.1 mrg * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
23 1.1 mrg * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24 1.1 mrg * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
25 1.1 mrg * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
26 1.1 mrg * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 1.1 mrg * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 1.1 mrg * SUCH DAMAGE.
29 1.1 mrg */
30 1.1 mrg
31 1.4 mrg #include <sys/cdefs.h>
32 1.4 mrg #ifndef lint
33 1.37 mrg __COPYRIGHT("@(#) Copyright (c) 1997, 1998, 2003, 2004 Matthew R. Green\n\
34 1.4 mrg All rights reserved.\n");
35 1.38 mrg __RCSID("$NetBSD: gzip.c,v 1.38 2004/04/26 03:01:55 mrg Exp $");
36 1.4 mrg #endif /* not lint */
37 1.4 mrg
38 1.1 mrg /*
39 1.1 mrg * gzip.c -- GPL free gzip using zlib.
40 1.1 mrg *
41 1.6 mrg * TODO:
42 1.6 mrg * - handle .taz/.tgz files?
43 1.10 mrg * - use mmap where possible
44 1.16 wiz * - handle some signals better (remove outfile?)
45 1.37 mrg * - audit maybe_err()/maybe_warn() usage
46 1.1 mrg */
47 1.1 mrg
48 1.1 mrg #include <sys/param.h>
49 1.1 mrg #include <sys/stat.h>
50 1.1 mrg #include <sys/time.h>
51 1.1 mrg
52 1.1 mrg #include <unistd.h>
53 1.1 mrg #include <stdio.h>
54 1.1 mrg #include <string.h>
55 1.1 mrg #include <stdlib.h>
56 1.1 mrg #include <err.h>
57 1.1 mrg #include <errno.h>
58 1.1 mrg #include <fcntl.h>
59 1.1 mrg #include <zlib.h>
60 1.1 mrg #include <fts.h>
61 1.1 mrg #include <libgen.h>
62 1.1 mrg #include <stdarg.h>
63 1.1 mrg #include <getopt.h>
64 1.1 mrg
65 1.10 mrg /* what type of file are we dealing with */
66 1.10 mrg enum filetype {
67 1.10 mrg FT_GZIP,
68 1.24 tsutsui #ifndef NO_BZIP2_SUPPORT
69 1.10 mrg FT_BZIP2,
70 1.24 tsutsui #endif
71 1.24 tsutsui #ifndef NO_COMPRESS_SUPPORT
72 1.22 mrg FT_Z,
73 1.24 tsutsui #endif
74 1.10 mrg FT_LAST,
75 1.10 mrg FT_UNKNOWN
76 1.10 mrg };
77 1.10 mrg
78 1.24 tsutsui #ifndef NO_BZIP2_SUPPORT
79 1.10 mrg #include <bzlib.h>
80 1.10 mrg
81 1.24 tsutsui #define BZ2_SUFFIX ".bz2"
82 1.24 tsutsui #define BZIP2_MAGIC "\102\132\150"
83 1.24 tsutsui #endif
84 1.24 tsutsui
85 1.24 tsutsui #ifndef NO_COMPRESS_SUPPORT
86 1.22 mrg #define Z_SUFFIX ".Z"
87 1.22 mrg #define Z_MAGIC "\037\235"
88 1.24 tsutsui #endif
89 1.10 mrg
90 1.10 mrg #define GZ_SUFFIX ".gz"
91 1.1 mrg
92 1.37 mrg #define BUFLEN (64 * 1024)
93 1.1 mrg
94 1.9 mrg #define GZIP_MAGIC0 0x1F
95 1.10 mrg #define GZIP_MAGIC1 0x8B
96 1.10 mrg #define GZIP_OMAGIC1 0x9E
97 1.9 mrg
98 1.37 mrg #define HEAD_CRC 0x02
99 1.37 mrg #define EXTRA_FIELD 0x04
100 1.37 mrg #define ORIG_NAME 0x08
101 1.37 mrg #define COMMENT 0x10
102 1.1 mrg
103 1.37 mrg #define OS_CODE 3 /* Unix */
104 1.1 mrg
105 1.37 mrg static const char gzip_version[] = "NetBSD gzip 20040425";
106 1.1 mrg
107 1.1 mrg static int cflag; /* stdout mode */
108 1.1 mrg static int dflag; /* decompress mode */
109 1.25 mrg static int lflag; /* list mode */
110 1.37 mrg static int numflag = 5; /* gzip -1..-9 value */
111 1.26 mrg
112 1.25 mrg #ifndef SMALL
113 1.1 mrg static int fflag; /* force mode */
114 1.1 mrg static int nflag; /* don't save name/timestamp */
115 1.1 mrg static int Nflag; /* don't restore name/timestamp */
116 1.1 mrg static int qflag; /* quiet mode */
117 1.1 mrg static int rflag; /* recursive mode */
118 1.26 mrg static int tflag; /* test */
119 1.26 mrg static char *Sflag;
120 1.26 mrg static int vflag; /* verbose mode */
121 1.25 mrg #else
122 1.25 mrg #define qflag 0
123 1.25 mrg #endif
124 1.26 mrg
125 1.10 mrg static char *suffix;
126 1.10 mrg #define suffix_len (strlen(suffix) + 1) /* len + nul */
127 1.1 mrg static char *newfile; /* name of newly created file */
128 1.1 mrg static char *infile; /* name of file coming in */
129 1.1 mrg
130 1.1 mrg static void maybe_err(int rv, const char *fmt, ...);
131 1.9 mrg static void maybe_errx(int rv, const char *fmt, ...);
132 1.1 mrg static void maybe_warn(const char *fmt, ...);
133 1.1 mrg static void maybe_warnx(const char *fmt, ...);
134 1.32 mrg static enum filetype file_gettype(u_char *);
135 1.37 mrg static off_t gz_compress(FILE *, int, off_t *, const char *, time_t);
136 1.37 mrg static off_t gz_uncompress(int, int, char *, size_t, off_t *);
137 1.31 mrg static off_t file_compress(char *);
138 1.31 mrg static off_t file_uncompress(char *);
139 1.1 mrg static void handle_pathname(char *);
140 1.1 mrg static void handle_file(char *, struct stat *);
141 1.1 mrg static void handle_stdin(void);
142 1.1 mrg static void handle_stdout(void);
143 1.6 mrg static void print_ratio(off_t, off_t, FILE *);
144 1.7 mrg static void print_list(int fd, off_t, const char *, time_t);
145 1.10 mrg static void usage(void);
146 1.10 mrg static void display_version(void);
147 1.26 mrg
148 1.26 mrg #ifndef SMALL
149 1.26 mrg static void prepend_gzip(char *, int *, char ***);
150 1.26 mrg static void handle_dir(char *, struct stat *);
151 1.31 mrg static void print_verbage(char *, char *, off_t, off_t);
152 1.26 mrg static void print_test(char *, int);
153 1.29 mrg static void copymodes(const char *, struct stat *);
154 1.26 mrg #endif
155 1.26 mrg
156 1.24 tsutsui #ifndef NO_BZIP2_SUPPORT
157 1.37 mrg static off_t unbzip2(int, int, char *, size_t, off_t *);
158 1.24 tsutsui #endif
159 1.26 mrg
160 1.24 tsutsui #ifndef NO_COMPRESS_SUPPORT
161 1.37 mrg static FILE *zopen(const char *, FILE *);
162 1.37 mrg static off_t zuncompress(FILE *, FILE *, char *, size_t, off_t *);
163 1.24 tsutsui #endif
164 1.1 mrg
165 1.1 mrg int main(int, char *p[]);
166 1.1 mrg
167 1.11 mrg #ifdef SMALL
168 1.11 mrg #define getopt_long(a,b,c,d,e) getopt(a,b,c)
169 1.11 mrg #else
170 1.3 jdolecek static const struct option longopts[] = {
171 1.1 mrg { "stdout", no_argument, 0, 'c' },
172 1.1 mrg { "to-stdout", no_argument, 0, 'c' },
173 1.1 mrg { "decompress", no_argument, 0, 'd' },
174 1.1 mrg { "uncompress", no_argument, 0, 'd' },
175 1.1 mrg { "force", no_argument, 0, 'f' },
176 1.1 mrg { "help", no_argument, 0, 'h' },
177 1.5 mrg { "list", no_argument, 0, 'l' },
178 1.1 mrg { "no-name", no_argument, 0, 'n' },
179 1.1 mrg { "name", no_argument, 0, 'N' },
180 1.1 mrg { "quiet", no_argument, 0, 'q' },
181 1.1 mrg { "recursive", no_argument, 0, 'r' },
182 1.1 mrg { "suffix", required_argument, 0, 'S' },
183 1.1 mrg { "test", no_argument, 0, 't' },
184 1.1 mrg { "verbose", no_argument, 0, 'v' },
185 1.1 mrg { "version", no_argument, 0, 'V' },
186 1.1 mrg { "fast", no_argument, 0, '1' },
187 1.1 mrg { "best", no_argument, 0, '9' },
188 1.1 mrg #if 0
189 1.1 mrg /*
190 1.10 mrg * This is what else GNU gzip implements. --ascii isn't useful
191 1.10 mrg * on NetBSD, and I don't care to have a --license.
192 1.1 mrg */
193 1.1 mrg { "ascii", no_argument, 0, 'a' },
194 1.1 mrg { "license", no_argument, 0, 'L' },
195 1.1 mrg #endif
196 1.12 mrg { NULL, no_argument, 0, 0 },
197 1.1 mrg };
198 1.11 mrg #endif
199 1.1 mrg
200 1.1 mrg int
201 1.1 mrg main(int argc, char **argv)
202 1.1 mrg {
203 1.28 mrg const char *progname = getprogname();
204 1.25 mrg #ifndef SMALL
205 1.15 mrg char *gzip;
206 1.25 mrg #endif
207 1.1 mrg int ch;
208 1.1 mrg
209 1.15 mrg /* XXX set up signals */
210 1.15 mrg
211 1.10 mrg suffix = GZ_SUFFIX;;
212 1.10 mrg
213 1.25 mrg #ifndef SMALL
214 1.15 mrg if ((gzip = getenv("GZIP")) != NULL)
215 1.15 mrg prepend_gzip(gzip, &argc, &argv);
216 1.28 mrg #endif
217 1.15 mrg
218 1.1 mrg /*
219 1.1 mrg * XXX
220 1.1 mrg * handle being called `gunzip', `zcat' and `gzcat'
221 1.1 mrg */
222 1.1 mrg if (strcmp(progname, "gunzip") == 0)
223 1.1 mrg dflag = 1;
224 1.1 mrg else if (strcmp(progname, "zcat") == 0 ||
225 1.1 mrg strcmp(progname, "gzcat") == 0)
226 1.1 mrg dflag = cflag = 1;
227 1.25 mrg
228 1.25 mrg #ifdef SMALL
229 1.31 mrg #define OPT_LIST "cdhHltV123456789"
230 1.25 mrg #else
231 1.28 mrg #define OPT_LIST "cdfhHlnNqrS:tvV123456789"
232 1.25 mrg #endif
233 1.1 mrg
234 1.28 mrg while ((ch = getopt_long(argc, argv, OPT_LIST, longopts, NULL)) != -1)
235 1.1 mrg switch (ch) {
236 1.1 mrg case 'c':
237 1.1 mrg cflag = 1;
238 1.1 mrg break;
239 1.1 mrg case 'd':
240 1.1 mrg dflag = 1;
241 1.1 mrg break;
242 1.5 mrg case 'l':
243 1.5 mrg lflag = 1;
244 1.5 mrg dflag = 1;
245 1.5 mrg break;
246 1.26 mrg case 'V':
247 1.26 mrg display_version();
248 1.26 mrg /* NOTREACHED */
249 1.26 mrg case '1': case '2': case '3':
250 1.26 mrg case '4': case '5': case '6':
251 1.26 mrg case '7': case '8': case '9':
252 1.38 mrg numflag = ch - '0';
253 1.26 mrg break;
254 1.25 mrg #ifndef SMALL
255 1.25 mrg case 'f':
256 1.25 mrg fflag = 1;
257 1.25 mrg break;
258 1.1 mrg case 'n':
259 1.1 mrg nflag = 1;
260 1.1 mrg Nflag = 0;
261 1.1 mrg break;
262 1.1 mrg case 'N':
263 1.1 mrg nflag = 0;
264 1.1 mrg Nflag = 1;
265 1.1 mrg break;
266 1.1 mrg case 'q':
267 1.1 mrg qflag = 1;
268 1.1 mrg break;
269 1.1 mrg case 'r':
270 1.1 mrg rflag = 1;
271 1.1 mrg break;
272 1.1 mrg case 'S':
273 1.1 mrg Sflag = optarg;
274 1.1 mrg break;
275 1.1 mrg case 't':
276 1.1 mrg cflag = 1;
277 1.1 mrg tflag = 1;
278 1.1 mrg dflag = 1;
279 1.1 mrg break;
280 1.1 mrg case 'v':
281 1.1 mrg vflag = 1;
282 1.1 mrg break;
283 1.26 mrg #endif
284 1.12 mrg default:
285 1.12 mrg usage();
286 1.12 mrg /* NOTREACHED */
287 1.1 mrg }
288 1.1 mrg argv += optind;
289 1.1 mrg argc -= optind;
290 1.1 mrg
291 1.1 mrg if (argc == 0) {
292 1.1 mrg if (dflag) /* stdin mode */
293 1.1 mrg handle_stdin();
294 1.1 mrg else /* stdout mode */
295 1.1 mrg handle_stdout();
296 1.1 mrg } else {
297 1.1 mrg do {
298 1.1 mrg handle_pathname(argv[0]);
299 1.5 mrg } while (*++argv);
300 1.1 mrg }
301 1.29 mrg #ifndef SMALL
302 1.6 mrg if (qflag == 0 && lflag && argc > 1)
303 1.7 mrg print_list(-1, 0, "(totals)", 0);
304 1.29 mrg #endif
305 1.1 mrg exit(0);
306 1.1 mrg }
307 1.1 mrg
308 1.1 mrg /* maybe print a warning */
309 1.1 mrg void
310 1.1 mrg maybe_warn(const char *fmt, ...)
311 1.1 mrg {
312 1.1 mrg va_list ap;
313 1.1 mrg
314 1.1 mrg if (qflag == 0) {
315 1.1 mrg va_start(ap, fmt);
316 1.1 mrg vwarn(fmt, ap);
317 1.1 mrg va_end(ap);
318 1.1 mrg }
319 1.1 mrg }
320 1.1 mrg
321 1.1 mrg void
322 1.1 mrg maybe_warnx(const char *fmt, ...)
323 1.1 mrg {
324 1.1 mrg va_list ap;
325 1.1 mrg
326 1.1 mrg if (qflag == 0) {
327 1.1 mrg va_start(ap, fmt);
328 1.1 mrg vwarnx(fmt, ap);
329 1.1 mrg va_end(ap);
330 1.1 mrg }
331 1.1 mrg }
332 1.1 mrg
333 1.1 mrg /* maybe print a warning */
334 1.1 mrg void
335 1.1 mrg maybe_err(int rv, const char *fmt, ...)
336 1.1 mrg {
337 1.1 mrg va_list ap;
338 1.1 mrg
339 1.1 mrg if (qflag == 0) {
340 1.1 mrg va_start(ap, fmt);
341 1.1 mrg vwarn(fmt, ap);
342 1.1 mrg va_end(ap);
343 1.1 mrg }
344 1.1 mrg exit(rv);
345 1.1 mrg }
346 1.1 mrg
347 1.9 mrg /* maybe print a warning */
348 1.9 mrg void
349 1.9 mrg maybe_errx(int rv, const char *fmt, ...)
350 1.9 mrg {
351 1.9 mrg va_list ap;
352 1.9 mrg
353 1.9 mrg if (qflag == 0) {
354 1.9 mrg va_start(ap, fmt);
355 1.9 mrg vwarnx(fmt, ap);
356 1.9 mrg va_end(ap);
357 1.9 mrg }
358 1.9 mrg exit(rv);
359 1.9 mrg }
360 1.9 mrg
361 1.25 mrg #ifndef SMALL
362 1.15 mrg /* split up $GZIP and prepend it to the argument list */
363 1.15 mrg static void
364 1.15 mrg prepend_gzip(char *gzip, int *argc, char ***argv)
365 1.15 mrg {
366 1.15 mrg char *s, **nargv, **ac;
367 1.15 mrg int nenvarg = 0, i;
368 1.15 mrg
369 1.15 mrg /* scan how many arguments there are */
370 1.15 mrg for (s = gzip; *s; s++) {
371 1.15 mrg if (*s == ' ' || *s == '\t')
372 1.15 mrg continue;
373 1.15 mrg nenvarg++;
374 1.15 mrg for (; *s; s++)
375 1.15 mrg if (*s == ' ' || *s == '\t')
376 1.15 mrg break;
377 1.18 mrg if (*s == 0)
378 1.18 mrg break;
379 1.15 mrg }
380 1.15 mrg /* punt early */
381 1.15 mrg if (nenvarg == 0)
382 1.15 mrg return;
383 1.15 mrg
384 1.15 mrg *argc += nenvarg;
385 1.15 mrg ac = *argv;
386 1.15 mrg
387 1.17 simonb nargv = (char **)malloc((*argc + 1) * sizeof(char *));
388 1.15 mrg if (nargv == NULL)
389 1.15 mrg maybe_err(1, "malloc");
390 1.15 mrg
391 1.15 mrg /* stash this away */
392 1.15 mrg *argv = nargv;
393 1.15 mrg
394 1.15 mrg /* copy the program name first */
395 1.15 mrg i = 0;
396 1.15 mrg nargv[i++] = *(ac++);
397 1.15 mrg
398 1.15 mrg /* take a copy of $GZIP and add it to the array */
399 1.15 mrg s = strdup(gzip);
400 1.15 mrg if (s == NULL)
401 1.15 mrg maybe_err(1, "strdup");
402 1.15 mrg for (; *s; s++) {
403 1.15 mrg if (*s == ' ' || *s == '\t')
404 1.15 mrg continue;
405 1.15 mrg nargv[i++] = s;
406 1.15 mrg for (; *s; s++)
407 1.15 mrg if (*s == ' ' || *s == '\t') {
408 1.15 mrg *s = 0;
409 1.15 mrg break;
410 1.15 mrg }
411 1.15 mrg }
412 1.15 mrg
413 1.15 mrg /* copy the original arguments and a NULL */
414 1.15 mrg while (*ac)
415 1.15 mrg nargv[i++] = *(ac++);
416 1.15 mrg nargv[i] = NULL;
417 1.15 mrg }
418 1.25 mrg #endif
419 1.15 mrg
420 1.1 mrg /* compress input to output then close both files */
421 1.37 mrg static off_t
422 1.37 mrg gz_compress(FILE *in, int out, off_t *gsizep, const char *origname, time_t mtime)
423 1.1 mrg {
424 1.37 mrg z_stream z;
425 1.37 mrg char inbuf[BUFLEN], outbuf[BUFLEN];
426 1.37 mrg off_t in_tot = 0, out_tot = 0;
427 1.37 mrg ssize_t in_size;
428 1.37 mrg char *str;
429 1.37 mrg int i, error;
430 1.37 mrg uLong crc;
431 1.37 mrg
432 1.37 mrg i = asprintf(&str, "%c%c%c%c%c%c%c%c%c%c%s",
433 1.37 mrg GZIP_MAGIC0, GZIP_MAGIC1,
434 1.37 mrg Z_DEFLATED, origname ? ORIG_NAME : 0,
435 1.37 mrg (int)mtime & 0xff,
436 1.37 mrg (int)(mtime >> 8) & 0xff,
437 1.37 mrg (int)(mtime >> 16) & 0xff,
438 1.37 mrg (int)(mtime >> 24) & 0xff,
439 1.37 mrg 0, OS_CODE, origname ? origname : "");
440 1.37 mrg if (i == -1)
441 1.37 mrg maybe_err(1, "asprintf");
442 1.37 mrg if (origname)
443 1.37 mrg i++;
444 1.37 mrg if (write(out, str, i) != i)
445 1.37 mrg maybe_err(1, "write");
446 1.37 mrg free(str);
447 1.37 mrg
448 1.37 mrg memset(&z, 0, sizeof z);
449 1.37 mrg z.next_out = outbuf;
450 1.37 mrg z.avail_out = sizeof outbuf;
451 1.38 mrg z.zalloc = Z_NULL;
452 1.38 mrg z.zfree = Z_NULL;
453 1.37 mrg z.opaque = 0;
454 1.37 mrg
455 1.37 mrg error = deflateInit2(&z, numflag, Z_DEFLATED,
456 1.37 mrg -MAX_WBITS, 8, Z_DEFAULT_STRATEGY);
457 1.37 mrg if (error != Z_OK)
458 1.37 mrg maybe_errx(1, "deflateInit2 failed");
459 1.37 mrg
460 1.37 mrg crc = crc32(0L, Z_NULL, 0);
461 1.37 mrg for (;;) {
462 1.37 mrg if (z.avail_out == 0) {
463 1.37 mrg if (write(out, outbuf, sizeof outbuf) != sizeof outbuf)
464 1.37 mrg maybe_err(1, "write");
465 1.37 mrg
466 1.37 mrg out_tot += sizeof outbuf;
467 1.37 mrg z.next_out = outbuf;
468 1.37 mrg z.avail_out = sizeof outbuf;
469 1.37 mrg }
470 1.37 mrg
471 1.37 mrg if (z.avail_in == 0) {
472 1.37 mrg in_size = fread(inbuf, 1, sizeof inbuf, in);
473 1.37 mrg if (ferror(in))
474 1.37 mrg maybe_err(1, "fread");
475 1.37 mrg if (in_size == 0)
476 1.37 mrg break;
477 1.37 mrg
478 1.37 mrg crc = crc32(crc, (const Bytef *)inbuf, (unsigned)in_size);
479 1.37 mrg in_tot += in_size;
480 1.37 mrg z.next_in = inbuf;
481 1.37 mrg z.avail_in = in_size;
482 1.37 mrg }
483 1.37 mrg
484 1.37 mrg error = deflate(&z, Z_NO_FLUSH);
485 1.37 mrg if (error != Z_OK && error != Z_STREAM_END)
486 1.38 mrg maybe_errx(1, "deflate failed");
487 1.37 mrg }
488 1.1 mrg
489 1.37 mrg /* clean up */
490 1.1 mrg for (;;) {
491 1.37 mrg size_t len;
492 1.37 mrg
493 1.37 mrg error = deflate(&z, Z_FINISH);
494 1.37 mrg if (error != Z_OK && error != Z_STREAM_END)
495 1.38 mrg maybe_errx(1, "deflate failed");
496 1.37 mrg
497 1.37 mrg len = sizeof outbuf - z.avail_out;
498 1.37 mrg
499 1.37 mrg if (write(out, outbuf, len) != len)
500 1.37 mrg maybe_err(1, "write");
501 1.37 mrg out_tot += len;
502 1.37 mrg z.next_out = outbuf;
503 1.37 mrg z.avail_out = sizeof outbuf;
504 1.37 mrg
505 1.37 mrg if (error == Z_STREAM_END)
506 1.1 mrg break;
507 1.37 mrg }
508 1.37 mrg
509 1.37 mrg if (deflateEnd(&z) != Z_OK)
510 1.37 mrg maybe_errx(1, "deflateEnd failed");
511 1.37 mrg
512 1.37 mrg i = asprintf(&str, "%c%c%c%c%c%c%c%c",
513 1.37 mrg (int)crc & 0xff,
514 1.37 mrg (int)(crc >> 8) & 0xff,
515 1.37 mrg (int)(crc >> 16) & 0xff,
516 1.37 mrg (int)(crc >> 24) & 0xff,
517 1.37 mrg (int)in_tot & 0xff,
518 1.37 mrg (int)(in_tot >> 8) & 0xff,
519 1.37 mrg (int)(in_tot >> 16) & 0xff,
520 1.37 mrg (int)(in_tot >> 24) & 0xff);
521 1.37 mrg if (i != 8)
522 1.37 mrg maybe_err(1, "asprintf");
523 1.37 mrg if (write(out, str, i) != i)
524 1.37 mrg maybe_err(1, "write");
525 1.37 mrg free(str);
526 1.1 mrg
527 1.1 mrg if (fclose(in) < 0)
528 1.1 mrg maybe_err(1, "failed fclose");
529 1.37 mrg
530 1.37 mrg if (gsizep)
531 1.37 mrg *gsizep = out_tot;
532 1.37 mrg return in_tot;
533 1.1 mrg }
534 1.1 mrg
535 1.37 mrg /*
536 1.37 mrg * uncompress input to output then close the input. return the
537 1.37 mrg * uncompressed size written, and put the compressed sized read
538 1.37 mrg * into `*gsizep'.
539 1.37 mrg */
540 1.1 mrg static off_t
541 1.37 mrg gz_uncompress(int in, int out, char *pre, size_t prelen, off_t *gsizep)
542 1.1 mrg {
543 1.37 mrg z_stream z;
544 1.37 mrg char outbuf[BUFLEN], inbuf[BUFLEN];
545 1.37 mrg off_t out_tot, in_tot;
546 1.37 mrg enum {
547 1.37 mrg GZSTATE_MAGIC0,
548 1.37 mrg GZSTATE_MAGIC1,
549 1.37 mrg GZSTATE_METHOD,
550 1.37 mrg GZSTATE_FLAGS,
551 1.37 mrg GZSTATE_SKIPPING,
552 1.37 mrg GZSTATE_EXTRA,
553 1.37 mrg GZSTATE_EXTRA2,
554 1.37 mrg GZSTATE_EXTRA3,
555 1.37 mrg GZSTATE_ORIGNAME,
556 1.37 mrg GZSTATE_COMMENT,
557 1.37 mrg GZSTATE_HEAD_CRC1,
558 1.37 mrg GZSTATE_HEAD_CRC2,
559 1.37 mrg GZSTATE_INIT,
560 1.37 mrg GZSTATE_READ
561 1.37 mrg } state = GZSTATE_MAGIC0;
562 1.37 mrg int flags = 0, skip_count = 0;
563 1.37 mrg int error, done_reading = 0;
564 1.37 mrg
565 1.37 mrg #define ADVANCE() { z.next_in++; z.avail_in--; }
566 1.37 mrg
567 1.37 mrg memset(&z, 0, sizeof z);
568 1.37 mrg z.avail_in = prelen;
569 1.37 mrg z.next_in = pre;
570 1.37 mrg z.avail_out = sizeof outbuf;
571 1.37 mrg z.next_out = outbuf;
572 1.37 mrg z.zalloc = NULL;
573 1.37 mrg z.zfree = NULL;
574 1.37 mrg z.opaque = 0;
575 1.37 mrg
576 1.37 mrg in_tot = prelen;
577 1.37 mrg out_tot = 0;
578 1.1 mrg
579 1.37 mrg for (;;) {
580 1.37 mrg if (z.avail_in == 0 && done_reading == 0) {
581 1.37 mrg size_t in_size = read(in, inbuf, BUFLEN);
582 1.1 mrg
583 1.37 mrg if (in_size == -1) {
584 1.26 mrg #ifndef SMALL
585 1.37 mrg if (tflag) {
586 1.37 mrg print_test("(stdin)", 0);
587 1.37 mrg return 0;
588 1.37 mrg }
589 1.37 mrg #endif
590 1.37 mrg maybe_warn("failed to read stdin\n");
591 1.37 mrg return -1;
592 1.37 mrg } else if (in_size == 0)
593 1.37 mrg done_reading = 1;
594 1.37 mrg
595 1.37 mrg z.avail_in = in_size;
596 1.37 mrg z.next_in = inbuf;
597 1.37 mrg
598 1.37 mrg in_tot += in_size;
599 1.37 mrg }
600 1.37 mrg switch (state) {
601 1.37 mrg case GZSTATE_MAGIC0:
602 1.37 mrg if (*z.next_in != GZIP_MAGIC0)
603 1.37 mrg maybe_err(1, "input not gziped\n");
604 1.37 mrg ADVANCE();
605 1.37 mrg state++;
606 1.37 mrg break;
607 1.37 mrg
608 1.37 mrg case GZSTATE_MAGIC1:
609 1.37 mrg if (*z.next_in != GZIP_MAGIC1 &&
610 1.37 mrg *z.next_in != GZIP_OMAGIC1)
611 1.37 mrg maybe_err(1, "input not gziped\n");
612 1.37 mrg ADVANCE();
613 1.37 mrg state++;
614 1.37 mrg break;
615 1.37 mrg
616 1.37 mrg case GZSTATE_METHOD:
617 1.37 mrg if (*z.next_in != Z_DEFLATED)
618 1.37 mrg maybe_err(1, "unknown compression method\n");
619 1.37 mrg ADVANCE();
620 1.37 mrg state++;
621 1.37 mrg break;
622 1.37 mrg
623 1.37 mrg case GZSTATE_FLAGS:
624 1.37 mrg flags = *z.next_in;
625 1.37 mrg ADVANCE();
626 1.37 mrg skip_count = 6;
627 1.37 mrg state++;
628 1.37 mrg break;
629 1.37 mrg
630 1.37 mrg case GZSTATE_SKIPPING:
631 1.37 mrg if (skip_count > 0) {
632 1.37 mrg skip_count--;
633 1.37 mrg ADVANCE();
634 1.37 mrg } else
635 1.37 mrg state++;
636 1.37 mrg break;
637 1.37 mrg
638 1.37 mrg case GZSTATE_EXTRA:
639 1.37 mrg if ((flags & EXTRA_FIELD) == 0) {
640 1.37 mrg state = GZSTATE_ORIGNAME;
641 1.37 mrg break;
642 1.37 mrg }
643 1.37 mrg skip_count = *z.next_in;
644 1.37 mrg ADVANCE();
645 1.37 mrg state++;
646 1.37 mrg break;
647 1.37 mrg
648 1.37 mrg case GZSTATE_EXTRA2:
649 1.37 mrg skip_count |= ((*z.next_in) << 8);
650 1.37 mrg ADVANCE();
651 1.37 mrg state++;
652 1.37 mrg break;
653 1.37 mrg
654 1.37 mrg case GZSTATE_EXTRA3:
655 1.37 mrg if (skip_count > 0) {
656 1.37 mrg skip_count--;
657 1.37 mrg ADVANCE();
658 1.1 mrg } else
659 1.37 mrg state++;
660 1.37 mrg break;
661 1.37 mrg
662 1.37 mrg case GZSTATE_ORIGNAME:
663 1.37 mrg if ((flags & ORIG_NAME) == 0) {
664 1.37 mrg state++;
665 1.37 mrg break;
666 1.37 mrg }
667 1.37 mrg if (*z.next_in == 0)
668 1.37 mrg state++;
669 1.37 mrg ADVANCE();
670 1.37 mrg break;
671 1.37 mrg
672 1.37 mrg case GZSTATE_COMMENT:
673 1.37 mrg if ((flags & COMMENT) == 0) {
674 1.37 mrg state++;
675 1.37 mrg break;
676 1.37 mrg }
677 1.37 mrg if (*z.next_in == 0)
678 1.37 mrg state++;
679 1.37 mrg ADVANCE();
680 1.37 mrg break;
681 1.37 mrg
682 1.37 mrg case GZSTATE_HEAD_CRC1:
683 1.37 mrg if (flags & HEAD_CRC)
684 1.37 mrg skip_count = 2;
685 1.37 mrg else
686 1.37 mrg skip_count = 0;
687 1.37 mrg state++;
688 1.37 mrg break;
689 1.37 mrg
690 1.37 mrg case GZSTATE_HEAD_CRC2:
691 1.37 mrg if (skip_count > 0) {
692 1.37 mrg skip_count--;
693 1.37 mrg ADVANCE();
694 1.37 mrg } else
695 1.37 mrg state++;
696 1.37 mrg break;
697 1.37 mrg
698 1.37 mrg case GZSTATE_INIT:
699 1.37 mrg if (inflateInit2(&z, -MAX_WBITS) != Z_OK) {
700 1.37 mrg maybe_err(1, "failed to inflateInit\n");
701 1.37 mrg goto stop;
702 1.37 mrg }
703 1.37 mrg state++;
704 1.37 mrg break;
705 1.37 mrg
706 1.37 mrg case GZSTATE_READ:
707 1.37 mrg error = inflate(&z, Z_FINISH);
708 1.37 mrg if (error == Z_STREAM_END || error == Z_BUF_ERROR) {
709 1.37 mrg size_t wr = BUFLEN - z.avail_out;
710 1.37 mrg
711 1.37 mrg if (
712 1.37 mrg #ifndef SMALL
713 1.37 mrg /* don't write anything with -t */
714 1.37 mrg tflag == 0 &&
715 1.37 mrg #endif
716 1.37 mrg write(STDOUT_FILENO, outbuf, wr) != wr)
717 1.37 mrg maybe_err(1, "error writing "
718 1.37 mrg "to stdout\n");
719 1.37 mrg
720 1.37 mrg if (error == Z_STREAM_END)
721 1.37 mrg goto stop;
722 1.37 mrg z.next_out = outbuf;
723 1.37 mrg z.avail_out = BUFLEN;
724 1.37 mrg
725 1.37 mrg out_tot += wr;
726 1.37 mrg break;
727 1.37 mrg }
728 1.37 mrg if (error < 0) {
729 1.38 mrg maybe_warnx("decompression error\n");
730 1.37 mrg out_tot = -1;
731 1.37 mrg goto stop;
732 1.37 mrg }
733 1.1 mrg break;
734 1.1 mrg }
735 1.37 mrg continue;
736 1.37 mrg stop:
737 1.37 mrg break;
738 1.37 mrg }
739 1.37 mrg if (state > GZSTATE_INIT)
740 1.37 mrg inflateEnd(&z);
741 1.1 mrg
742 1.26 mrg #ifndef SMALL
743 1.37 mrg if (tflag) {
744 1.37 mrg print_test("(stdin)", 1);
745 1.37 mrg return 0;
746 1.37 mrg }
747 1.26 mrg #endif
748 1.1 mrg
749 1.37 mrg if (gsizep)
750 1.37 mrg *gsizep = in_tot;
751 1.37 mrg return (out_tot);
752 1.1 mrg }
753 1.1 mrg
754 1.29 mrg #ifndef SMALL
755 1.1 mrg /*
756 1.1 mrg * set the owner, mode, flags & utimes for a file
757 1.1 mrg */
758 1.1 mrg static void
759 1.1 mrg copymodes(const char *file, struct stat *sbp)
760 1.1 mrg {
761 1.1 mrg struct timeval times[2];
762 1.1 mrg
763 1.1 mrg /*
764 1.1 mrg * If we have no info on the input, give this file some
765 1.1 mrg * default values and return..
766 1.1 mrg */
767 1.1 mrg if (sbp == NULL) {
768 1.1 mrg mode_t mask = umask(022);
769 1.1 mrg
770 1.1 mrg (void)chmod(file, DEFFILEMODE & ~mask);
771 1.1 mrg (void)umask(mask);
772 1.1 mrg return;
773 1.1 mrg }
774 1.1 mrg
775 1.1 mrg /* if the chown fails, remove set-id bits as-per compress(1) */
776 1.1 mrg if (chown(file, sbp->st_uid, sbp->st_gid) < 0) {
777 1.1 mrg if (errno != EPERM)
778 1.1 mrg maybe_warn("couldn't chown: %s", file);
779 1.1 mrg sbp->st_mode &= ~(S_ISUID|S_ISGID);
780 1.1 mrg }
781 1.1 mrg
782 1.1 mrg /* we only allow set-id and the 9 normal permission bits */
783 1.1 mrg sbp->st_mode &= S_ISUID|S_ISGID|S_IRWXU|S_IRWXG|S_IRWXO;
784 1.1 mrg if (chmod(file, sbp->st_mode) < 0)
785 1.1 mrg maybe_warn("couldn't chmod: %s", file);
786 1.1 mrg
787 1.1 mrg /* only try flags if they exist already */
788 1.1 mrg if (sbp->st_flags != 0 && chflags(file, sbp->st_flags) < 0)
789 1.1 mrg maybe_warn("couldn't chflags: %s", file);
790 1.1 mrg
791 1.1 mrg TIMESPEC_TO_TIMEVAL(×[0], &sbp->st_atimespec);
792 1.1 mrg TIMESPEC_TO_TIMEVAL(×[1], &sbp->st_mtimespec);
793 1.1 mrg if (utimes(file, times) < 0)
794 1.1 mrg maybe_warn("couldn't utimes: %s", file);
795 1.1 mrg }
796 1.29 mrg #endif
797 1.1 mrg
798 1.32 mrg /* what sort of file is this? */
799 1.32 mrg static enum filetype
800 1.32 mrg file_gettype(u_char *buf)
801 1.32 mrg {
802 1.32 mrg
803 1.32 mrg if (buf[0] == GZIP_MAGIC0 &&
804 1.32 mrg (buf[1] == GZIP_MAGIC1 || buf[1] == GZIP_OMAGIC1))
805 1.32 mrg return FT_GZIP;
806 1.32 mrg else
807 1.32 mrg #ifndef NO_BZIP2_SUPPORT
808 1.32 mrg if (memcmp(buf, BZIP2_MAGIC, 3) == 0 &&
809 1.32 mrg buf[3] >= '0' && buf[3] <= '9')
810 1.32 mrg return FT_BZIP2;
811 1.32 mrg else
812 1.32 mrg #endif
813 1.32 mrg #ifndef NO_COMPRESS_SUPPORT
814 1.32 mrg if (memcmp(buf, Z_MAGIC, 2) == 0)
815 1.32 mrg return FT_Z;
816 1.32 mrg else
817 1.32 mrg #endif
818 1.32 mrg return FT_UNKNOWN;
819 1.32 mrg }
820 1.32 mrg
821 1.1 mrg /*
822 1.1 mrg * compress the given file: create a corresponding .gz file and remove the
823 1.1 mrg * original.
824 1.1 mrg */
825 1.31 mrg static off_t
826 1.1 mrg file_compress(char *file)
827 1.1 mrg {
828 1.1 mrg FILE *in;
829 1.37 mrg int out;
830 1.1 mrg struct stat isb, osb;
831 1.5 mrg char outfile[MAXPATHLEN];
832 1.31 mrg off_t size;
833 1.25 mrg #ifndef SMALL
834 1.1 mrg u_int32_t mtime = 0;
835 1.37 mrg char *savename;
836 1.25 mrg #endif
837 1.1 mrg
838 1.1 mrg if (cflag == 0) {
839 1.1 mrg (void)strncpy(outfile, file, MAXPATHLEN - suffix_len);
840 1.1 mrg outfile[MAXPATHLEN - suffix_len] = '\0';
841 1.10 mrg (void)strlcat(outfile, suffix, sizeof(outfile));
842 1.1 mrg
843 1.25 mrg #ifndef SMALL
844 1.1 mrg if (fflag == 0) {
845 1.1 mrg if (stat(outfile, &osb) == 0) {
846 1.1 mrg maybe_warnx("%s already exists -- skipping",
847 1.1 mrg outfile);
848 1.1 mrg goto lose;
849 1.1 mrg }
850 1.1 mrg }
851 1.1 mrg if (stat(file, &isb) == 0) {
852 1.33 tron if (isb.st_nlink > 1 && fflag == 0) {
853 1.1 mrg maybe_warnx("%s has %d other link%s -- "
854 1.33 tron "skipping", file, isb.st_nlink - 1,
855 1.1 mrg isb.st_nlink == 1 ? "" : "s");
856 1.1 mrg goto lose;
857 1.1 mrg }
858 1.1 mrg if (nflag == 0)
859 1.1 mrg mtime = (u_int32_t)isb.st_mtime;
860 1.34 mrg }
861 1.25 mrg #endif
862 1.1 mrg }
863 1.1 mrg in = fopen(file, "r");
864 1.1 mrg if (in == 0)
865 1.1 mrg maybe_err(1, "can't fopen %s", file);
866 1.1 mrg
867 1.1 mrg if (cflag == 0) {
868 1.37 mrg #ifndef SMALL
869 1.1 mrg if (nflag == 0)
870 1.1 mrg savename = basename(file);
871 1.1 mrg else
872 1.1 mrg savename = NULL;
873 1.1 mrg #endif
874 1.37 mrg out = open(outfile, O_WRONLY|O_CREAT|O_EXCL, 0600);
875 1.1 mrg } else
876 1.37 mrg out = STDOUT_FILENO;
877 1.1 mrg
878 1.37 mrg #ifdef SMALL
879 1.37 mrg gz_compress(in, out, NULL, NULL, 0);
880 1.37 mrg #else
881 1.37 mrg gz_compress(in, out, NULL, savename, mtime);
882 1.37 mrg #endif
883 1.1 mrg
884 1.1 mrg /*
885 1.1 mrg * if we compressed to stdout, we don't know the size and
886 1.1 mrg * we don't know the new file name, punt. if we can't stat
887 1.1 mrg * the file, whine, otherwise set the size from the stat
888 1.1 mrg * buffer. we only blow away the file if we can stat the
889 1.1 mrg * output, just in case.
890 1.1 mrg */
891 1.1 mrg if (cflag == 0) {
892 1.1 mrg if (stat(outfile, &osb) < 0) {
893 1.1 mrg maybe_warn("couldn't stat: %s", outfile);
894 1.1 mrg maybe_warnx("leaving original %s", file);
895 1.1 mrg size = 0;
896 1.1 mrg } else {
897 1.1 mrg unlink(file);
898 1.1 mrg size = osb.st_size;
899 1.1 mrg }
900 1.1 mrg newfile = outfile;
901 1.29 mrg #ifndef SMALL
902 1.1 mrg copymodes(outfile, &isb);
903 1.29 mrg #endif
904 1.1 mrg } else {
905 1.1 mrg lose:
906 1.1 mrg size = 0;
907 1.1 mrg newfile = 0;
908 1.1 mrg }
909 1.1 mrg
910 1.1 mrg return (size);
911 1.1 mrg }
912 1.1 mrg
913 1.1 mrg /* uncompress the given file and remove the original */
914 1.31 mrg static off_t
915 1.1 mrg file_uncompress(char *file)
916 1.1 mrg {
917 1.1 mrg struct stat isb, osb;
918 1.5 mrg char buf[PATH_MAX];
919 1.1 mrg char *outfile = buf, *s;
920 1.1 mrg off_t size;
921 1.1 mrg ssize_t len = strlen(file);
922 1.9 mrg int fd;
923 1.37 mrg unsigned char header1[4], name[PATH_MAX + 1];
924 1.10 mrg enum filetype method;
925 1.9 mrg
926 1.9 mrg /* gather the old name info */
927 1.1 mrg
928 1.9 mrg fd = open(file, O_RDONLY);
929 1.9 mrg if (fd < 0)
930 1.9 mrg maybe_err(1, "can't open %s", file);
931 1.37 mrg if (read(fd, header1, sizeof header1) != sizeof header1) {
932 1.10 mrg /* we don't want to fail here. */
933 1.25 mrg #ifndef SMALL
934 1.10 mrg if (fflag)
935 1.10 mrg goto close_it;
936 1.25 mrg #endif
937 1.9 mrg maybe_err(1, "can't read %s", file);
938 1.10 mrg }
939 1.10 mrg
940 1.32 mrg method = file_gettype(header1);
941 1.29 mrg
942 1.32 mrg #ifndef SMALL
943 1.32 mrg if (Sflag == NULL) {
944 1.32 mrg # ifndef NO_BZIP2_SUPPORT
945 1.32 mrg if (method == FT_BZIP2)
946 1.10 mrg suffix = BZ2_SUFFIX;
947 1.32 mrg else
948 1.26 mrg # endif
949 1.32 mrg # ifndef NO_COMPRESS_SUPPORT
950 1.32 mrg if (method == FT_Z)
951 1.22 mrg suffix = Z_SUFFIX;
952 1.26 mrg # endif
953 1.32 mrg }
954 1.9 mrg
955 1.10 mrg if (fflag == 0 && method == FT_UNKNOWN)
956 1.9 mrg maybe_errx(1, "%s: not in gzip format", file);
957 1.25 mrg #endif
958 1.9 mrg
959 1.10 mrg if (cflag == 0 || lflag) {
960 1.10 mrg s = &file[len - suffix_len + 1];
961 1.10 mrg if (strncmp(s, suffix, suffix_len) == 0) {
962 1.10 mrg (void)strncpy(outfile, file, len - suffix_len + 1);
963 1.10 mrg outfile[len - suffix_len + 1] = '\0';
964 1.10 mrg } else if (lflag == 0)
965 1.10 mrg maybe_errx(1, "unknown suffix %s", s);
966 1.10 mrg }
967 1.10 mrg
968 1.25 mrg #ifdef SMALL
969 1.25 mrg if (method == FT_GZIP && lflag)
970 1.25 mrg #else
971 1.25 mrg if (method == FT_GZIP && (Nflag || lflag))
972 1.25 mrg #endif
973 1.25 mrg {
974 1.9 mrg if (header1[3] & ORIG_NAME) {
975 1.9 mrg size_t rbytes;
976 1.9 mrg int i;
977 1.9 mrg
978 1.9 mrg rbytes = read(fd, name, PATH_MAX + 1);
979 1.9 mrg if (rbytes < 0)
980 1.1 mrg maybe_err(1, "can't read %s", file);
981 1.9 mrg for (i = 0; i < rbytes && name[i]; i++)
982 1.9 mrg ;
983 1.9 mrg if (i < rbytes) {
984 1.9 mrg name[i] = 0;
985 1.9 mrg /* now maybe merge old dirname */
986 1.9 mrg if (strchr(outfile, '/') == 0)
987 1.9 mrg outfile = name;
988 1.9 mrg else {
989 1.9 mrg char *dir = dirname(outfile);
990 1.9 mrg if (asprintf(&outfile, "%s/%s", dir,
991 1.9 mrg name) == -1)
992 1.9 mrg maybe_err(1, "malloc");
993 1.1 mrg }
994 1.1 mrg }
995 1.1 mrg }
996 1.9 mrg }
997 1.25 mrg #ifndef SMALL
998 1.10 mrg close_it:
999 1.25 mrg #endif
1000 1.9 mrg close(fd);
1001 1.1 mrg
1002 1.31 mrg if (cflag == 0 || lflag) {
1003 1.25 mrg #ifndef SMALL
1004 1.31 mrg if (fflag == 0 && lflag == 0 && stat(outfile, &osb) == 0) {
1005 1.9 mrg maybe_warnx("%s already exists -- skipping", outfile);
1006 1.9 mrg goto lose;
1007 1.9 mrg }
1008 1.31 mrg #endif
1009 1.9 mrg if (stat(file, &isb) == 0) {
1010 1.31 mrg #ifndef SMALL
1011 1.33 tron if (isb.st_nlink > 1 && lflag == 0 && fflag == 0) {
1012 1.9 mrg maybe_warnx("%s has %d other links -- skipping",
1013 1.9 mrg file, isb.st_nlink - 1);
1014 1.1 mrg goto lose;
1015 1.1 mrg }
1016 1.31 mrg #endif
1017 1.9 mrg } else
1018 1.9 mrg goto lose;
1019 1.1 mrg }
1020 1.5 mrg
1021 1.24 tsutsui #ifndef NO_BZIP2_SUPPORT
1022 1.10 mrg if (method == FT_BZIP2) {
1023 1.10 mrg int in, out;
1024 1.5 mrg
1025 1.30 mrg /* XXX */
1026 1.26 mrg if (lflag)
1027 1.26 mrg maybe_errx(1, "no -l with bzip2 files");
1028 1.26 mrg
1029 1.10 mrg if ((in = open(file, O_RDONLY)) == -1)
1030 1.10 mrg maybe_err(1, "open for read: %s", file);
1031 1.10 mrg if (cflag == 1)
1032 1.10 mrg out = STDOUT_FILENO;
1033 1.10 mrg else
1034 1.10 mrg out = open(outfile, O_WRONLY|O_CREAT|O_EXCL, 0600);
1035 1.10 mrg if (out == -1)
1036 1.10 mrg maybe_err(1, "open for write: %s", outfile);
1037 1.5 mrg
1038 1.37 mrg if ((size = unbzip2(in, out, NULL, 0, NULL)) == 0) {
1039 1.36 mrg if (cflag == 0)
1040 1.36 mrg unlink(outfile);
1041 1.10 mrg goto lose;
1042 1.10 mrg }
1043 1.24 tsutsui } else
1044 1.24 tsutsui #endif
1045 1.29 mrg
1046 1.24 tsutsui #ifndef NO_COMPRESS_SUPPORT
1047 1.24 tsutsui if (method == FT_Z) {
1048 1.22 mrg FILE *in, *out;
1049 1.22 mrg int fd;
1050 1.22 mrg
1051 1.30 mrg /* XXX */
1052 1.26 mrg if (lflag)
1053 1.26 mrg maybe_errx(1, "no -l with Lempel-Ziv files");
1054 1.26 mrg
1055 1.37 mrg if ((in = zopen(file, NULL)) == NULL)
1056 1.22 mrg maybe_err(1, "open for read: %s", file);
1057 1.22 mrg
1058 1.22 mrg if (cflag == 1)
1059 1.22 mrg fd = STDOUT_FILENO;
1060 1.22 mrg else {
1061 1.22 mrg fd = open(outfile, O_WRONLY|O_CREAT|O_EXCL, 0600);
1062 1.22 mrg if (fd == -1)
1063 1.22 mrg maybe_err(1, "open for write: %s", outfile);
1064 1.22 mrg }
1065 1.22 mrg out = fdopen(fd, "w");
1066 1.22 mrg if (out == NULL)
1067 1.22 mrg maybe_err(1, "open for write: %s", outfile);
1068 1.22 mrg
1069 1.37 mrg size = zuncompress(in, out, NULL, 0, NULL);
1070 1.36 mrg if (cflag == 0) {
1071 1.36 mrg if (size == 0) {
1072 1.36 mrg unlink(outfile);
1073 1.36 mrg goto lose;
1074 1.36 mrg }
1075 1.36 mrg if (ferror(in) || fclose(in)) {
1076 1.36 mrg unlink(outfile);
1077 1.36 mrg maybe_err(1, "failed infile fclose");
1078 1.36 mrg }
1079 1.36 mrg if (fclose(out)) {
1080 1.36 mrg unlink(outfile);
1081 1.36 mrg maybe_err(1, "failed outfile close");
1082 1.36 mrg }
1083 1.22 mrg }
1084 1.24 tsutsui } else
1085 1.24 tsutsui #endif
1086 1.24 tsutsui {
1087 1.37 mrg int fd, in;
1088 1.37 mrg
1089 1.10 mrg if (lflag) {
1090 1.10 mrg if ((fd = open(file, O_RDONLY)) == -1)
1091 1.10 mrg maybe_err(1, "open");
1092 1.10 mrg print_list(fd, isb.st_size, outfile, isb.st_mtime);
1093 1.10 mrg return 0; /* XXX */
1094 1.10 mrg }
1095 1.10 mrg
1096 1.37 mrg in = open(file, O_RDONLY);
1097 1.37 mrg if (in == -1)
1098 1.37 mrg maybe_err(1, "can't open %s", file);
1099 1.10 mrg
1100 1.10 mrg if (cflag == 0) {
1101 1.10 mrg /* Use open(2) directly to get a safe file. */
1102 1.10 mrg fd = open(outfile, O_WRONLY|O_CREAT|O_EXCL, 0600);
1103 1.10 mrg if (fd < 0)
1104 1.10 mrg maybe_err(1, "can't open %s", outfile);
1105 1.10 mrg } else
1106 1.37 mrg fd = STDOUT_FILENO;
1107 1.1 mrg
1108 1.37 mrg size = gz_uncompress(in, fd, NULL, 0, NULL);
1109 1.36 mrg if (cflag == 0) {
1110 1.37 mrg if (size == -1) {
1111 1.36 mrg unlink(outfile);
1112 1.36 mrg goto lose;
1113 1.36 mrg }
1114 1.37 mrg if (close(fd))
1115 1.37 mrg maybe_err(1, "failed close");
1116 1.10 mrg }
1117 1.10 mrg }
1118 1.1 mrg
1119 1.1 mrg /* if testing, or we uncompressed to stdout, this is all we need */
1120 1.26 mrg #ifndef SMALL
1121 1.26 mrg if (tflag)
1122 1.26 mrg return (size);
1123 1.26 mrg #endif
1124 1.26 mrg if (cflag)
1125 1.1 mrg return (size);
1126 1.1 mrg
1127 1.1 mrg /*
1128 1.1 mrg * if we create a file...
1129 1.1 mrg */
1130 1.1 mrg if (cflag == 0) {
1131 1.1 mrg /*
1132 1.1 mrg * if we can't stat the file, or we are uncompressing to
1133 1.1 mrg * stdin, don't remove the file.
1134 1.1 mrg */
1135 1.1 mrg if (stat(outfile, &osb) < 0) {
1136 1.1 mrg maybe_warn("couldn't stat (leaving original): %s",
1137 1.1 mrg outfile);
1138 1.1 mrg goto lose;
1139 1.1 mrg }
1140 1.1 mrg if (osb.st_size != size) {
1141 1.1 mrg maybe_warn("stat gave different size: %llu != %llu "
1142 1.1 mrg "(leaving original)",
1143 1.1 mrg (unsigned long long)size,
1144 1.1 mrg (unsigned long long)osb.st_size);
1145 1.1 mrg goto lose;
1146 1.1 mrg }
1147 1.1 mrg newfile = outfile;
1148 1.36 mrg if (cflag == 0)
1149 1.36 mrg unlink(file);
1150 1.1 mrg size = osb.st_size;
1151 1.29 mrg #ifndef SMALL
1152 1.1 mrg copymodes(outfile, &isb);
1153 1.29 mrg #endif
1154 1.1 mrg }
1155 1.1 mrg return (size);
1156 1.1 mrg
1157 1.1 mrg lose:
1158 1.1 mrg newfile = 0;
1159 1.22 mrg return 0;
1160 1.1 mrg }
1161 1.1 mrg
1162 1.37 mrg #ifndef SMALL
1163 1.37 mrg static off_t
1164 1.37 mrg cat_stdin(unsigned char * prepend, size_t count, off_t *gsizep)
1165 1.37 mrg {
1166 1.37 mrg char buf[BUFLEN];
1167 1.37 mrg size_t rv;
1168 1.37 mrg off_t in_tot;
1169 1.37 mrg
1170 1.37 mrg in_tot = count;
1171 1.37 mrg if (write(STDOUT_FILENO, prepend, count) != count)
1172 1.37 mrg maybe_err(1, "write to stdout");
1173 1.37 mrg for (;;) {
1174 1.37 mrg rv = read(STDIN_FILENO, buf, sizeof buf);
1175 1.37 mrg
1176 1.37 mrg if (write(STDOUT_FILENO, buf, rv) != rv)
1177 1.37 mrg maybe_err(1, "write to stdout");
1178 1.37 mrg in_tot += rv;
1179 1.37 mrg }
1180 1.37 mrg
1181 1.37 mrg if (gsizep)
1182 1.37 mrg *gsizep = in_tot;
1183 1.37 mrg return (in_tot);
1184 1.37 mrg }
1185 1.37 mrg #endif
1186 1.37 mrg
1187 1.1 mrg static void
1188 1.1 mrg handle_stdin(void)
1189 1.1 mrg {
1190 1.37 mrg unsigned char header1[4];
1191 1.37 mrg off_t usize, gsize;
1192 1.37 mrg enum filetype method;
1193 1.37 mrg #ifndef NO_COMPRESS_SUPPORT
1194 1.37 mrg FILE *in;
1195 1.37 mrg #endif
1196 1.1 mrg
1197 1.25 mrg #ifndef SMALL
1198 1.5 mrg if (fflag == 0 && lflag == 0 && isatty(STDIN_FILENO)) {
1199 1.1 mrg maybe_warnx("standard input is a terminal -- ignoring");
1200 1.1 mrg return;
1201 1.1 mrg }
1202 1.25 mrg #endif
1203 1.5 mrg
1204 1.5 mrg if (lflag) {
1205 1.5 mrg struct stat isb;
1206 1.5 mrg
1207 1.37 mrg /* XXX could read the whole file, etc. */
1208 1.5 mrg if (fstat(STDIN_FILENO, &isb) < 0)
1209 1.5 mrg maybe_err(1, "fstat");
1210 1.7 mrg print_list(STDIN_FILENO, isb.st_size, "stdout", isb.st_mtime);
1211 1.5 mrg return;
1212 1.5 mrg }
1213 1.5 mrg
1214 1.37 mrg if (read(STDIN_FILENO, header1, sizeof header1) != sizeof header1)
1215 1.37 mrg maybe_err(1, "can't read stdin");
1216 1.37 mrg
1217 1.37 mrg method = file_gettype(header1);
1218 1.37 mrg switch (method) {
1219 1.37 mrg default:
1220 1.37 mrg #ifndef SMALL
1221 1.37 mrg if (fflag == 0)
1222 1.37 mrg maybe_errx(1, "unknown compression format");
1223 1.37 mrg usize = cat_stdin(header1, sizeof header1, &gsize);
1224 1.37 mrg break;
1225 1.37 mrg #endif
1226 1.37 mrg case FT_GZIP:
1227 1.37 mrg usize = gz_uncompress(STDIN_FILENO, STDOUT_FILENO,
1228 1.37 mrg header1, sizeof header1, &gsize);
1229 1.37 mrg break;
1230 1.37 mrg #ifndef NO_BZIP2_SUPPORT
1231 1.37 mrg case FT_BZIP2:
1232 1.37 mrg usize = unbzip2(STDIN_FILENO, STDOUT_FILENO,
1233 1.37 mrg header1, sizeof header1, &gsize);
1234 1.37 mrg break;
1235 1.37 mrg #endif
1236 1.37 mrg #ifndef NO_COMPRESS_SUPPORT
1237 1.37 mrg case FT_Z:
1238 1.37 mrg if ((in = zopen(NULL, stdin)) == NULL)
1239 1.37 mrg maybe_err(1, "zopen of stdin");
1240 1.37 mrg
1241 1.37 mrg usize = zuncompress(in, stdout, header1, sizeof header1, &gsize);
1242 1.37 mrg break;
1243 1.37 mrg #endif
1244 1.37 mrg }
1245 1.37 mrg
1246 1.37 mrg #ifndef SMALL
1247 1.37 mrg if (vflag && !tflag && usize != -1 && gsize != -1)
1248 1.37 mrg print_verbage(NULL, 0, usize, gsize);
1249 1.37 mrg #endif
1250 1.37 mrg
1251 1.1 mrg }
1252 1.1 mrg
1253 1.1 mrg static void
1254 1.1 mrg handle_stdout(void)
1255 1.1 mrg {
1256 1.37 mrg off_t gsize, usize;
1257 1.1 mrg
1258 1.25 mrg #ifndef SMALL
1259 1.1 mrg if (fflag == 0 && isatty(STDOUT_FILENO)) {
1260 1.1 mrg maybe_warnx("standard output is a terminal -- ignoring");
1261 1.1 mrg return;
1262 1.1 mrg }
1263 1.25 mrg #endif
1264 1.37 mrg usize = gz_compress(stdin, STDOUT_FILENO, &gsize, NULL, 0);
1265 1.37 mrg
1266 1.37 mrg #ifndef SMALL
1267 1.37 mrg if (vflag && !tflag && usize != -1 && gsize != -1)
1268 1.37 mrg print_verbage(NULL, 0, usize, gsize);
1269 1.37 mrg #endif
1270 1.1 mrg }
1271 1.1 mrg
1272 1.1 mrg /* do what is asked for, for the path name */
1273 1.1 mrg static void
1274 1.1 mrg handle_pathname(char *path)
1275 1.1 mrg {
1276 1.1 mrg char *opath = path, *s = 0;
1277 1.1 mrg ssize_t len;
1278 1.1 mrg struct stat sb;
1279 1.1 mrg
1280 1.1 mrg /* check for stdout/stdin */
1281 1.1 mrg if (path[0] == '-' && path[1] == '\0') {
1282 1.1 mrg if (dflag)
1283 1.1 mrg handle_stdin();
1284 1.1 mrg else
1285 1.1 mrg handle_stdout();
1286 1.1 mrg }
1287 1.1 mrg
1288 1.1 mrg retry:
1289 1.1 mrg if (stat(path, &sb) < 0) {
1290 1.1 mrg /* lets try <path>.gz if we're decompressing */
1291 1.1 mrg if (dflag && s == 0 && errno == ENOENT) {
1292 1.1 mrg len = strlen(path);
1293 1.1 mrg s = malloc(len + suffix_len);
1294 1.1 mrg if (s == 0)
1295 1.1 mrg maybe_err(1, "malloc");
1296 1.1 mrg memmove(s, path, len);
1297 1.10 mrg memmove(&s[len], suffix, suffix_len);
1298 1.1 mrg path = s;
1299 1.1 mrg goto retry;
1300 1.1 mrg }
1301 1.1 mrg maybe_warn("can't stat: %s", opath);
1302 1.1 mrg goto out;
1303 1.1 mrg }
1304 1.1 mrg
1305 1.1 mrg if (S_ISDIR(sb.st_mode)) {
1306 1.25 mrg #ifndef SMALL
1307 1.1 mrg if (rflag)
1308 1.1 mrg handle_dir(path, &sb);
1309 1.1 mrg else
1310 1.25 mrg #endif
1311 1.1 mrg maybe_warn("%s is a directory", path);
1312 1.1 mrg goto out;
1313 1.1 mrg }
1314 1.1 mrg
1315 1.1 mrg if (S_ISREG(sb.st_mode))
1316 1.1 mrg handle_file(path, &sb);
1317 1.1 mrg
1318 1.1 mrg out:
1319 1.1 mrg if (s)
1320 1.1 mrg free(s);
1321 1.1 mrg }
1322 1.1 mrg
1323 1.1 mrg /* compress/decompress a file */
1324 1.1 mrg static void
1325 1.1 mrg handle_file(char *file, struct stat *sbp)
1326 1.1 mrg {
1327 1.31 mrg off_t usize, gsize;
1328 1.1 mrg
1329 1.1 mrg infile = file;
1330 1.1 mrg if (dflag) {
1331 1.1 mrg usize = file_uncompress(file);
1332 1.1 mrg if (usize == 0)
1333 1.1 mrg return;
1334 1.1 mrg gsize = sbp->st_size;
1335 1.1 mrg } else {
1336 1.1 mrg gsize = file_compress(file);
1337 1.1 mrg if (gsize == 0)
1338 1.1 mrg return;
1339 1.1 mrg usize = sbp->st_size;
1340 1.1 mrg }
1341 1.1 mrg
1342 1.26 mrg
1343 1.26 mrg #ifndef SMALL
1344 1.1 mrg if (vflag && !tflag)
1345 1.1 mrg print_verbage(file, cflag == 0 ? newfile : 0, usize, gsize);
1346 1.26 mrg #endif
1347 1.1 mrg }
1348 1.1 mrg
1349 1.25 mrg #ifndef SMALL
1350 1.1 mrg /* this is used with -r to recursively decend directories */
1351 1.1 mrg static void
1352 1.1 mrg handle_dir(char *dir, struct stat *sbp)
1353 1.1 mrg {
1354 1.1 mrg char *path_argv[2];
1355 1.1 mrg FTS *fts;
1356 1.1 mrg FTSENT *entry;
1357 1.1 mrg
1358 1.1 mrg path_argv[0] = dir;
1359 1.1 mrg path_argv[1] = 0;
1360 1.1 mrg fts = fts_open(path_argv, FTS_PHYSICAL, NULL);
1361 1.1 mrg if (fts == NULL) {
1362 1.1 mrg warn("couldn't fts_open %s", dir);
1363 1.1 mrg return;
1364 1.1 mrg }
1365 1.1 mrg
1366 1.1 mrg while ((entry = fts_read(fts))) {
1367 1.1 mrg switch(entry->fts_info) {
1368 1.1 mrg case FTS_D:
1369 1.1 mrg case FTS_DP:
1370 1.1 mrg continue;
1371 1.1 mrg
1372 1.1 mrg case FTS_DNR:
1373 1.1 mrg case FTS_ERR:
1374 1.1 mrg case FTS_NS:
1375 1.1 mrg maybe_warn("%s", entry->fts_path);
1376 1.1 mrg continue;
1377 1.1 mrg case FTS_F:
1378 1.1 mrg handle_file(entry->fts_name, entry->fts_statp);
1379 1.1 mrg }
1380 1.1 mrg }
1381 1.1 mrg (void)fts_close(fts);
1382 1.1 mrg }
1383 1.25 mrg #endif
1384 1.1 mrg
1385 1.6 mrg /* print a ratio */
1386 1.6 mrg static void
1387 1.6 mrg print_ratio(off_t in, off_t out, FILE *where)
1388 1.6 mrg {
1389 1.35 mrg int64_t percent10; /* 10 * percent */
1390 1.35 mrg off_t diff = in - out;
1391 1.35 mrg char ch;
1392 1.6 mrg
1393 1.35 mrg if (in == 0)
1394 1.35 mrg percent10 = 0;
1395 1.35 mrg else if (diff > 0x400000) /* anything with 22 or more bits */
1396 1.35 mrg percent10 = diff / (in / 1000);
1397 1.35 mrg else
1398 1.35 mrg percent10 = (1000 * diff) / in;
1399 1.35 mrg
1400 1.35 mrg if (percent10 < 0) {
1401 1.35 mrg percent10 = -percent10;
1402 1.35 mrg ch = '-';
1403 1.35 mrg } else
1404 1.35 mrg ch = ' ';
1405 1.35 mrg
1406 1.35 mrg /*
1407 1.35 mrg * ugh. for negative percentages < 10, we need to avoid printing a
1408 1.35 mrg * a space between the "-" and the single number.
1409 1.35 mrg */
1410 1.35 mrg if (ch == '-' && percent10 / 10LL < 10)
1411 1.35 mrg fprintf(where, " -%1d.%1u%%", (unsigned)(percent10 / 10LL),
1412 1.35 mrg (unsigned)(percent10 % 10LL));
1413 1.6 mrg else
1414 1.35 mrg fprintf(where, "%c%2d.%1u%%", ch, (unsigned)(percent10 / 10LL),
1415 1.35 mrg (unsigned)(percent10 % 10LL));
1416 1.6 mrg }
1417 1.6 mrg
1418 1.26 mrg #ifndef SMALL
1419 1.1 mrg /* print compression statistics, and the new name (if there is one!) */
1420 1.1 mrg static void
1421 1.31 mrg print_verbage(char *file, char *nfile, off_t usize, off_t gsize)
1422 1.1 mrg {
1423 1.37 mrg if (file)
1424 1.37 mrg fprintf(stderr, "%s:%s ", file,
1425 1.37 mrg strlen(file) < 7 ? "\t\t" : "\t");
1426 1.31 mrg print_ratio((off_t)usize, (off_t)gsize, stderr);
1427 1.4 mrg if (nfile)
1428 1.4 mrg fprintf(stderr, " -- replaced with %s", nfile);
1429 1.1 mrg fprintf(stderr, "\n");
1430 1.1 mrg fflush(stderr);
1431 1.1 mrg }
1432 1.1 mrg
1433 1.1 mrg /* print test results */
1434 1.1 mrg static void
1435 1.1 mrg print_test(char *file, int ok)
1436 1.1 mrg {
1437 1.1 mrg
1438 1.1 mrg fprintf(stderr, "%s:%s %s\n", file,
1439 1.1 mrg strlen(file) < 7 ? "\t\t" : "\t", ok ? "OK" : "NOT OK");
1440 1.1 mrg fflush(stderr);
1441 1.1 mrg }
1442 1.26 mrg #endif
1443 1.1 mrg
1444 1.5 mrg /* print a file's info ala --list */
1445 1.5 mrg /* eg:
1446 1.5 mrg compressed uncompressed ratio uncompressed_name
1447 1.5 mrg 354841 1679360 78.8% /usr/pkgsrc/distfiles/libglade-2.0.1.tar
1448 1.5 mrg */
1449 1.5 mrg static void
1450 1.35 mrg print_list(int fd, off_t out, const char *outfile, time_t ts)
1451 1.5 mrg {
1452 1.5 mrg static int first = 1;
1453 1.29 mrg #ifndef SMALL
1454 1.6 mrg static off_t in_tot, out_tot;
1455 1.29 mrg u_int32_t crc;
1456 1.29 mrg #endif
1457 1.35 mrg off_t in;
1458 1.5 mrg int rv;
1459 1.5 mrg
1460 1.7 mrg if (first) {
1461 1.26 mrg #ifndef SMALL
1462 1.7 mrg if (vflag)
1463 1.7 mrg printf("method crc date time ");
1464 1.26 mrg #endif
1465 1.7 mrg if (qflag == 0)
1466 1.7 mrg printf(" compressed uncompressed "
1467 1.7 mrg "ratio uncompressed_name\n");
1468 1.7 mrg }
1469 1.5 mrg first = 0;
1470 1.5 mrg
1471 1.6 mrg /* print totals? */
1472 1.29 mrg #ifndef SMALL
1473 1.6 mrg if (fd == -1) {
1474 1.6 mrg in = in_tot;
1475 1.6 mrg out = out_tot;
1476 1.29 mrg } else
1477 1.29 mrg #endif
1478 1.29 mrg {
1479 1.6 mrg /* read the last 4 bytes - this is the uncompressed size */
1480 1.7 mrg rv = lseek(fd, (off_t)(-8), SEEK_END);
1481 1.6 mrg if (rv != -1) {
1482 1.7 mrg unsigned char buf[8];
1483 1.6 mrg u_int32_t usize;
1484 1.6 mrg
1485 1.6 mrg if (read(fd, (char *)buf, sizeof(buf)) != sizeof(buf))
1486 1.37 mrg maybe_warn("read of uncompressed size");
1487 1.7 mrg usize = buf[4] | buf[5] << 8 | buf[6] << 16 | buf[7] << 24;
1488 1.35 mrg in = (off_t)usize;
1489 1.29 mrg #ifndef SMALL
1490 1.29 mrg crc = buf[0] | buf[1] << 8 | buf[2] << 16 | buf[3] << 24;
1491 1.29 mrg #endif
1492 1.6 mrg }
1493 1.6 mrg }
1494 1.5 mrg
1495 1.26 mrg #ifndef SMALL
1496 1.7 mrg if (vflag && fd == -1)
1497 1.7 mrg printf(" ");
1498 1.7 mrg else if (vflag) {
1499 1.7 mrg char *date = ctime(&ts);
1500 1.7 mrg
1501 1.7 mrg /* skip the day, 1/100th second, and year */
1502 1.7 mrg date += 4;
1503 1.7 mrg date[12] = 0;
1504 1.7 mrg printf("%5s %08x %11s ", "defla"/*XXX*/, crc, date);
1505 1.7 mrg }
1506 1.29 mrg in_tot += in;
1507 1.29 mrg out_tot += out;
1508 1.26 mrg #endif
1509 1.35 mrg printf("%12llu %12llu ", (unsigned long long)out, (unsigned long long)in);
1510 1.6 mrg print_ratio(in, out, stdout);
1511 1.6 mrg printf(" %s\n", outfile);
1512 1.5 mrg }
1513 1.5 mrg
1514 1.1 mrg /* display the usage of NetBSD gzip */
1515 1.1 mrg static void
1516 1.1 mrg usage(void)
1517 1.1 mrg {
1518 1.1 mrg
1519 1.1 mrg fprintf(stderr, "%s\n", gzip_version);
1520 1.1 mrg fprintf(stderr,
1521 1.29 mrg "usage: %s [-" OPT_LIST "] [<file> [<file> ...]]\n"
1522 1.11 mrg #ifndef SMALL
1523 1.1 mrg " -c --stdout write to stdout, keep original files\n"
1524 1.1 mrg " --to-stdout\n"
1525 1.1 mrg " -d --decompress uncompress files\n"
1526 1.1 mrg " --uncompress\n"
1527 1.1 mrg " -f --force force overwriting & compress links\n"
1528 1.1 mrg " -h --help display this help\n"
1529 1.1 mrg " -n --no-name don't save original file name or time stamp\n"
1530 1.1 mrg " -N --name save or restore original file name and time stamp\n"
1531 1.1 mrg " -q --quiet output no warnings\n"
1532 1.1 mrg " -r --recursive recursively compress files in directories\n"
1533 1.1 mrg " -S .suf use suffix .suf instead of .gz\n"
1534 1.1 mrg " --suffix .suf\n"
1535 1.1 mrg " -t --test test compressed file\n"
1536 1.1 mrg " -v --verbose print extra statistics\n"
1537 1.1 mrg " -V --version display program version\n"
1538 1.1 mrg " -1 --fast fastest (worst) compression\n"
1539 1.1 mrg " -2 .. -8 set compression level\n"
1540 1.1 mrg " -9 --best best (slowest) compression\n",
1541 1.11 mrg #else
1542 1.11 mrg ,
1543 1.11 mrg #endif
1544 1.1 mrg getprogname());
1545 1.1 mrg exit(0);
1546 1.1 mrg }
1547 1.1 mrg
1548 1.1 mrg /* display the version of NetBSD gzip */
1549 1.1 mrg static void
1550 1.1 mrg display_version(void)
1551 1.1 mrg {
1552 1.1 mrg
1553 1.1 mrg fprintf(stderr, "%s\n", gzip_version);
1554 1.1 mrg exit(0);
1555 1.1 mrg }
1556 1.10 mrg
1557 1.24 tsutsui #ifndef NO_BZIP2_SUPPORT
1558 1.10 mrg #include "unbzip2.c"
1559 1.24 tsutsui #endif
1560 1.24 tsutsui #ifndef NO_COMPRESS_SUPPORT
1561 1.22 mrg #include "zuncompress.c"
1562 1.24 tsutsui #endif
1563