gzip.c revision 1.39 1 1.39 mrg /* $NetBSD: gzip.c,v 1.39 2004/04/27 01:23:35 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.39 mrg __RCSID("$NetBSD: gzip.c,v 1.39 2004/04/27 01:23:35 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.39 mrg write(out, outbuf, wr) != wr)
717 1.37 mrg maybe_err(1, "error writing "
718 1.39 mrg "to output\n");
719 1.39 mrg
720 1.39 mrg out_tot += wr;
721 1.37 mrg
722 1.37 mrg if (error == Z_STREAM_END)
723 1.37 mrg goto stop;
724 1.39 mrg
725 1.37 mrg z.next_out = outbuf;
726 1.37 mrg z.avail_out = BUFLEN;
727 1.37 mrg
728 1.37 mrg break;
729 1.37 mrg }
730 1.37 mrg if (error < 0) {
731 1.38 mrg maybe_warnx("decompression error\n");
732 1.37 mrg out_tot = -1;
733 1.37 mrg goto stop;
734 1.37 mrg }
735 1.1 mrg break;
736 1.1 mrg }
737 1.37 mrg continue;
738 1.37 mrg stop:
739 1.37 mrg break;
740 1.37 mrg }
741 1.37 mrg if (state > GZSTATE_INIT)
742 1.37 mrg inflateEnd(&z);
743 1.1 mrg
744 1.26 mrg #ifndef SMALL
745 1.37 mrg if (tflag) {
746 1.37 mrg print_test("(stdin)", 1);
747 1.37 mrg return 0;
748 1.37 mrg }
749 1.26 mrg #endif
750 1.1 mrg
751 1.37 mrg if (gsizep)
752 1.37 mrg *gsizep = in_tot;
753 1.37 mrg return (out_tot);
754 1.1 mrg }
755 1.1 mrg
756 1.29 mrg #ifndef SMALL
757 1.1 mrg /*
758 1.1 mrg * set the owner, mode, flags & utimes for a file
759 1.1 mrg */
760 1.1 mrg static void
761 1.1 mrg copymodes(const char *file, struct stat *sbp)
762 1.1 mrg {
763 1.1 mrg struct timeval times[2];
764 1.1 mrg
765 1.1 mrg /*
766 1.1 mrg * If we have no info on the input, give this file some
767 1.1 mrg * default values and return..
768 1.1 mrg */
769 1.1 mrg if (sbp == NULL) {
770 1.1 mrg mode_t mask = umask(022);
771 1.1 mrg
772 1.1 mrg (void)chmod(file, DEFFILEMODE & ~mask);
773 1.1 mrg (void)umask(mask);
774 1.1 mrg return;
775 1.1 mrg }
776 1.1 mrg
777 1.1 mrg /* if the chown fails, remove set-id bits as-per compress(1) */
778 1.1 mrg if (chown(file, sbp->st_uid, sbp->st_gid) < 0) {
779 1.1 mrg if (errno != EPERM)
780 1.1 mrg maybe_warn("couldn't chown: %s", file);
781 1.1 mrg sbp->st_mode &= ~(S_ISUID|S_ISGID);
782 1.1 mrg }
783 1.1 mrg
784 1.1 mrg /* we only allow set-id and the 9 normal permission bits */
785 1.1 mrg sbp->st_mode &= S_ISUID|S_ISGID|S_IRWXU|S_IRWXG|S_IRWXO;
786 1.1 mrg if (chmod(file, sbp->st_mode) < 0)
787 1.1 mrg maybe_warn("couldn't chmod: %s", file);
788 1.1 mrg
789 1.1 mrg /* only try flags if they exist already */
790 1.1 mrg if (sbp->st_flags != 0 && chflags(file, sbp->st_flags) < 0)
791 1.1 mrg maybe_warn("couldn't chflags: %s", file);
792 1.1 mrg
793 1.1 mrg TIMESPEC_TO_TIMEVAL(×[0], &sbp->st_atimespec);
794 1.1 mrg TIMESPEC_TO_TIMEVAL(×[1], &sbp->st_mtimespec);
795 1.1 mrg if (utimes(file, times) < 0)
796 1.1 mrg maybe_warn("couldn't utimes: %s", file);
797 1.1 mrg }
798 1.29 mrg #endif
799 1.1 mrg
800 1.32 mrg /* what sort of file is this? */
801 1.32 mrg static enum filetype
802 1.32 mrg file_gettype(u_char *buf)
803 1.32 mrg {
804 1.32 mrg
805 1.32 mrg if (buf[0] == GZIP_MAGIC0 &&
806 1.32 mrg (buf[1] == GZIP_MAGIC1 || buf[1] == GZIP_OMAGIC1))
807 1.32 mrg return FT_GZIP;
808 1.32 mrg else
809 1.32 mrg #ifndef NO_BZIP2_SUPPORT
810 1.32 mrg if (memcmp(buf, BZIP2_MAGIC, 3) == 0 &&
811 1.32 mrg buf[3] >= '0' && buf[3] <= '9')
812 1.32 mrg return FT_BZIP2;
813 1.32 mrg else
814 1.32 mrg #endif
815 1.32 mrg #ifndef NO_COMPRESS_SUPPORT
816 1.32 mrg if (memcmp(buf, Z_MAGIC, 2) == 0)
817 1.32 mrg return FT_Z;
818 1.32 mrg else
819 1.32 mrg #endif
820 1.32 mrg return FT_UNKNOWN;
821 1.32 mrg }
822 1.32 mrg
823 1.1 mrg /*
824 1.1 mrg * compress the given file: create a corresponding .gz file and remove the
825 1.1 mrg * original.
826 1.1 mrg */
827 1.31 mrg static off_t
828 1.1 mrg file_compress(char *file)
829 1.1 mrg {
830 1.1 mrg FILE *in;
831 1.37 mrg int out;
832 1.1 mrg struct stat isb, osb;
833 1.5 mrg char outfile[MAXPATHLEN];
834 1.31 mrg off_t size;
835 1.25 mrg #ifndef SMALL
836 1.1 mrg u_int32_t mtime = 0;
837 1.37 mrg char *savename;
838 1.25 mrg #endif
839 1.1 mrg
840 1.1 mrg if (cflag == 0) {
841 1.1 mrg (void)strncpy(outfile, file, MAXPATHLEN - suffix_len);
842 1.1 mrg outfile[MAXPATHLEN - suffix_len] = '\0';
843 1.10 mrg (void)strlcat(outfile, suffix, sizeof(outfile));
844 1.1 mrg
845 1.25 mrg #ifndef SMALL
846 1.1 mrg if (fflag == 0) {
847 1.1 mrg if (stat(outfile, &osb) == 0) {
848 1.1 mrg maybe_warnx("%s already exists -- skipping",
849 1.1 mrg outfile);
850 1.1 mrg goto lose;
851 1.1 mrg }
852 1.1 mrg }
853 1.1 mrg if (stat(file, &isb) == 0) {
854 1.33 tron if (isb.st_nlink > 1 && fflag == 0) {
855 1.1 mrg maybe_warnx("%s has %d other link%s -- "
856 1.33 tron "skipping", file, isb.st_nlink - 1,
857 1.1 mrg isb.st_nlink == 1 ? "" : "s");
858 1.1 mrg goto lose;
859 1.1 mrg }
860 1.1 mrg if (nflag == 0)
861 1.1 mrg mtime = (u_int32_t)isb.st_mtime;
862 1.34 mrg }
863 1.25 mrg #endif
864 1.1 mrg }
865 1.1 mrg in = fopen(file, "r");
866 1.1 mrg if (in == 0)
867 1.1 mrg maybe_err(1, "can't fopen %s", file);
868 1.1 mrg
869 1.1 mrg if (cflag == 0) {
870 1.37 mrg #ifndef SMALL
871 1.1 mrg if (nflag == 0)
872 1.1 mrg savename = basename(file);
873 1.1 mrg else
874 1.1 mrg savename = NULL;
875 1.1 mrg #endif
876 1.37 mrg out = open(outfile, O_WRONLY|O_CREAT|O_EXCL, 0600);
877 1.39 mrg if (out == -1) {
878 1.39 mrg maybe_warn("could not create output: %s", outfile);
879 1.39 mrg goto lose;
880 1.39 mrg }
881 1.1 mrg } else
882 1.37 mrg out = STDOUT_FILENO;
883 1.1 mrg
884 1.37 mrg #ifdef SMALL
885 1.37 mrg gz_compress(in, out, NULL, NULL, 0);
886 1.37 mrg #else
887 1.37 mrg gz_compress(in, out, NULL, savename, mtime);
888 1.37 mrg #endif
889 1.1 mrg
890 1.1 mrg /*
891 1.1 mrg * if we compressed to stdout, we don't know the size and
892 1.1 mrg * we don't know the new file name, punt. if we can't stat
893 1.1 mrg * the file, whine, otherwise set the size from the stat
894 1.1 mrg * buffer. we only blow away the file if we can stat the
895 1.1 mrg * output, just in case.
896 1.1 mrg */
897 1.1 mrg if (cflag == 0) {
898 1.39 mrg if (close(out) == -1)
899 1.39 mrg maybe_warn("couldn't close ouput");
900 1.39 mrg
901 1.1 mrg if (stat(outfile, &osb) < 0) {
902 1.1 mrg maybe_warn("couldn't stat: %s", outfile);
903 1.1 mrg maybe_warnx("leaving original %s", file);
904 1.1 mrg size = 0;
905 1.1 mrg } else {
906 1.1 mrg unlink(file);
907 1.1 mrg size = osb.st_size;
908 1.1 mrg }
909 1.1 mrg newfile = outfile;
910 1.29 mrg #ifndef SMALL
911 1.1 mrg copymodes(outfile, &isb);
912 1.29 mrg #endif
913 1.1 mrg } else {
914 1.1 mrg lose:
915 1.1 mrg size = 0;
916 1.1 mrg newfile = 0;
917 1.1 mrg }
918 1.1 mrg
919 1.1 mrg return (size);
920 1.1 mrg }
921 1.1 mrg
922 1.1 mrg /* uncompress the given file and remove the original */
923 1.31 mrg static off_t
924 1.1 mrg file_uncompress(char *file)
925 1.1 mrg {
926 1.1 mrg struct stat isb, osb;
927 1.5 mrg char buf[PATH_MAX];
928 1.1 mrg char *outfile = buf, *s;
929 1.1 mrg off_t size;
930 1.1 mrg ssize_t len = strlen(file);
931 1.9 mrg int fd;
932 1.37 mrg unsigned char header1[4], name[PATH_MAX + 1];
933 1.10 mrg enum filetype method;
934 1.9 mrg
935 1.9 mrg /* gather the old name info */
936 1.1 mrg
937 1.9 mrg fd = open(file, O_RDONLY);
938 1.9 mrg if (fd < 0)
939 1.9 mrg maybe_err(1, "can't open %s", file);
940 1.37 mrg if (read(fd, header1, sizeof header1) != sizeof header1) {
941 1.10 mrg /* we don't want to fail here. */
942 1.25 mrg #ifndef SMALL
943 1.10 mrg if (fflag)
944 1.10 mrg goto close_it;
945 1.25 mrg #endif
946 1.9 mrg maybe_err(1, "can't read %s", file);
947 1.10 mrg }
948 1.10 mrg
949 1.32 mrg method = file_gettype(header1);
950 1.29 mrg
951 1.32 mrg #ifndef SMALL
952 1.32 mrg if (Sflag == NULL) {
953 1.32 mrg # ifndef NO_BZIP2_SUPPORT
954 1.32 mrg if (method == FT_BZIP2)
955 1.10 mrg suffix = BZ2_SUFFIX;
956 1.32 mrg else
957 1.26 mrg # endif
958 1.32 mrg # ifndef NO_COMPRESS_SUPPORT
959 1.32 mrg if (method == FT_Z)
960 1.22 mrg suffix = Z_SUFFIX;
961 1.26 mrg # endif
962 1.32 mrg }
963 1.9 mrg
964 1.10 mrg if (fflag == 0 && method == FT_UNKNOWN)
965 1.9 mrg maybe_errx(1, "%s: not in gzip format", file);
966 1.25 mrg #endif
967 1.9 mrg
968 1.10 mrg if (cflag == 0 || lflag) {
969 1.10 mrg s = &file[len - suffix_len + 1];
970 1.10 mrg if (strncmp(s, suffix, suffix_len) == 0) {
971 1.10 mrg (void)strncpy(outfile, file, len - suffix_len + 1);
972 1.10 mrg outfile[len - suffix_len + 1] = '\0';
973 1.10 mrg } else if (lflag == 0)
974 1.10 mrg maybe_errx(1, "unknown suffix %s", s);
975 1.10 mrg }
976 1.10 mrg
977 1.25 mrg #ifdef SMALL
978 1.25 mrg if (method == FT_GZIP && lflag)
979 1.25 mrg #else
980 1.25 mrg if (method == FT_GZIP && (Nflag || lflag))
981 1.25 mrg #endif
982 1.25 mrg {
983 1.9 mrg if (header1[3] & ORIG_NAME) {
984 1.9 mrg size_t rbytes;
985 1.9 mrg int i;
986 1.9 mrg
987 1.9 mrg rbytes = read(fd, name, PATH_MAX + 1);
988 1.9 mrg if (rbytes < 0)
989 1.1 mrg maybe_err(1, "can't read %s", file);
990 1.9 mrg for (i = 0; i < rbytes && name[i]; i++)
991 1.9 mrg ;
992 1.9 mrg if (i < rbytes) {
993 1.9 mrg name[i] = 0;
994 1.9 mrg /* now maybe merge old dirname */
995 1.9 mrg if (strchr(outfile, '/') == 0)
996 1.9 mrg outfile = name;
997 1.9 mrg else {
998 1.9 mrg char *dir = dirname(outfile);
999 1.9 mrg if (asprintf(&outfile, "%s/%s", dir,
1000 1.9 mrg name) == -1)
1001 1.9 mrg maybe_err(1, "malloc");
1002 1.1 mrg }
1003 1.1 mrg }
1004 1.1 mrg }
1005 1.9 mrg }
1006 1.25 mrg #ifndef SMALL
1007 1.10 mrg close_it:
1008 1.25 mrg #endif
1009 1.9 mrg close(fd);
1010 1.1 mrg
1011 1.31 mrg if (cflag == 0 || lflag) {
1012 1.25 mrg #ifndef SMALL
1013 1.31 mrg if (fflag == 0 && lflag == 0 && stat(outfile, &osb) == 0) {
1014 1.9 mrg maybe_warnx("%s already exists -- skipping", outfile);
1015 1.9 mrg goto lose;
1016 1.9 mrg }
1017 1.31 mrg #endif
1018 1.9 mrg if (stat(file, &isb) == 0) {
1019 1.31 mrg #ifndef SMALL
1020 1.33 tron if (isb.st_nlink > 1 && lflag == 0 && fflag == 0) {
1021 1.9 mrg maybe_warnx("%s has %d other links -- skipping",
1022 1.9 mrg file, isb.st_nlink - 1);
1023 1.1 mrg goto lose;
1024 1.1 mrg }
1025 1.31 mrg #endif
1026 1.9 mrg } else
1027 1.9 mrg goto lose;
1028 1.1 mrg }
1029 1.5 mrg
1030 1.24 tsutsui #ifndef NO_BZIP2_SUPPORT
1031 1.10 mrg if (method == FT_BZIP2) {
1032 1.10 mrg int in, out;
1033 1.5 mrg
1034 1.30 mrg /* XXX */
1035 1.26 mrg if (lflag)
1036 1.26 mrg maybe_errx(1, "no -l with bzip2 files");
1037 1.26 mrg
1038 1.10 mrg if ((in = open(file, O_RDONLY)) == -1)
1039 1.10 mrg maybe_err(1, "open for read: %s", file);
1040 1.10 mrg if (cflag == 1)
1041 1.10 mrg out = STDOUT_FILENO;
1042 1.10 mrg else
1043 1.10 mrg out = open(outfile, O_WRONLY|O_CREAT|O_EXCL, 0600);
1044 1.10 mrg if (out == -1)
1045 1.10 mrg maybe_err(1, "open for write: %s", outfile);
1046 1.5 mrg
1047 1.37 mrg if ((size = unbzip2(in, out, NULL, 0, NULL)) == 0) {
1048 1.36 mrg if (cflag == 0)
1049 1.36 mrg unlink(outfile);
1050 1.10 mrg goto lose;
1051 1.10 mrg }
1052 1.24 tsutsui } else
1053 1.24 tsutsui #endif
1054 1.29 mrg
1055 1.24 tsutsui #ifndef NO_COMPRESS_SUPPORT
1056 1.24 tsutsui if (method == FT_Z) {
1057 1.22 mrg FILE *in, *out;
1058 1.22 mrg int fd;
1059 1.22 mrg
1060 1.30 mrg /* XXX */
1061 1.26 mrg if (lflag)
1062 1.26 mrg maybe_errx(1, "no -l with Lempel-Ziv files");
1063 1.26 mrg
1064 1.37 mrg if ((in = zopen(file, NULL)) == NULL)
1065 1.22 mrg maybe_err(1, "open for read: %s", file);
1066 1.22 mrg
1067 1.22 mrg if (cflag == 1)
1068 1.22 mrg fd = STDOUT_FILENO;
1069 1.22 mrg else {
1070 1.22 mrg fd = open(outfile, O_WRONLY|O_CREAT|O_EXCL, 0600);
1071 1.22 mrg if (fd == -1)
1072 1.22 mrg maybe_err(1, "open for write: %s", outfile);
1073 1.22 mrg }
1074 1.22 mrg out = fdopen(fd, "w");
1075 1.22 mrg if (out == NULL)
1076 1.22 mrg maybe_err(1, "open for write: %s", outfile);
1077 1.22 mrg
1078 1.37 mrg size = zuncompress(in, out, NULL, 0, NULL);
1079 1.36 mrg if (cflag == 0) {
1080 1.36 mrg if (size == 0) {
1081 1.36 mrg unlink(outfile);
1082 1.36 mrg goto lose;
1083 1.36 mrg }
1084 1.36 mrg if (ferror(in) || fclose(in)) {
1085 1.36 mrg unlink(outfile);
1086 1.36 mrg maybe_err(1, "failed infile fclose");
1087 1.36 mrg }
1088 1.36 mrg if (fclose(out)) {
1089 1.36 mrg unlink(outfile);
1090 1.36 mrg maybe_err(1, "failed outfile close");
1091 1.36 mrg }
1092 1.22 mrg }
1093 1.24 tsutsui } else
1094 1.24 tsutsui #endif
1095 1.24 tsutsui {
1096 1.37 mrg int fd, in;
1097 1.37 mrg
1098 1.10 mrg if (lflag) {
1099 1.10 mrg if ((fd = open(file, O_RDONLY)) == -1)
1100 1.10 mrg maybe_err(1, "open");
1101 1.10 mrg print_list(fd, isb.st_size, outfile, isb.st_mtime);
1102 1.10 mrg return 0; /* XXX */
1103 1.10 mrg }
1104 1.10 mrg
1105 1.37 mrg in = open(file, O_RDONLY);
1106 1.37 mrg if (in == -1)
1107 1.37 mrg maybe_err(1, "can't open %s", file);
1108 1.10 mrg
1109 1.10 mrg if (cflag == 0) {
1110 1.10 mrg /* Use open(2) directly to get a safe file. */
1111 1.10 mrg fd = open(outfile, O_WRONLY|O_CREAT|O_EXCL, 0600);
1112 1.10 mrg if (fd < 0)
1113 1.10 mrg maybe_err(1, "can't open %s", outfile);
1114 1.10 mrg } else
1115 1.37 mrg fd = STDOUT_FILENO;
1116 1.1 mrg
1117 1.37 mrg size = gz_uncompress(in, fd, NULL, 0, NULL);
1118 1.36 mrg if (cflag == 0) {
1119 1.37 mrg if (size == -1) {
1120 1.36 mrg unlink(outfile);
1121 1.36 mrg goto lose;
1122 1.36 mrg }
1123 1.37 mrg if (close(fd))
1124 1.37 mrg maybe_err(1, "failed close");
1125 1.10 mrg }
1126 1.10 mrg }
1127 1.1 mrg
1128 1.1 mrg /* if testing, or we uncompressed to stdout, this is all we need */
1129 1.26 mrg #ifndef SMALL
1130 1.26 mrg if (tflag)
1131 1.26 mrg return (size);
1132 1.26 mrg #endif
1133 1.26 mrg if (cflag)
1134 1.1 mrg return (size);
1135 1.1 mrg
1136 1.1 mrg /*
1137 1.1 mrg * if we create a file...
1138 1.1 mrg */
1139 1.1 mrg if (cflag == 0) {
1140 1.1 mrg /*
1141 1.1 mrg * if we can't stat the file, or we are uncompressing to
1142 1.1 mrg * stdin, don't remove the file.
1143 1.1 mrg */
1144 1.1 mrg if (stat(outfile, &osb) < 0) {
1145 1.1 mrg maybe_warn("couldn't stat (leaving original): %s",
1146 1.1 mrg outfile);
1147 1.1 mrg goto lose;
1148 1.1 mrg }
1149 1.1 mrg if (osb.st_size != size) {
1150 1.1 mrg maybe_warn("stat gave different size: %llu != %llu "
1151 1.1 mrg "(leaving original)",
1152 1.1 mrg (unsigned long long)size,
1153 1.1 mrg (unsigned long long)osb.st_size);
1154 1.1 mrg goto lose;
1155 1.1 mrg }
1156 1.1 mrg newfile = outfile;
1157 1.36 mrg if (cflag == 0)
1158 1.36 mrg unlink(file);
1159 1.1 mrg size = osb.st_size;
1160 1.29 mrg #ifndef SMALL
1161 1.1 mrg copymodes(outfile, &isb);
1162 1.29 mrg #endif
1163 1.1 mrg }
1164 1.1 mrg return (size);
1165 1.1 mrg
1166 1.1 mrg lose:
1167 1.1 mrg newfile = 0;
1168 1.22 mrg return 0;
1169 1.1 mrg }
1170 1.1 mrg
1171 1.37 mrg #ifndef SMALL
1172 1.37 mrg static off_t
1173 1.37 mrg cat_stdin(unsigned char * prepend, size_t count, off_t *gsizep)
1174 1.37 mrg {
1175 1.37 mrg char buf[BUFLEN];
1176 1.37 mrg size_t rv;
1177 1.37 mrg off_t in_tot;
1178 1.37 mrg
1179 1.37 mrg in_tot = count;
1180 1.37 mrg if (write(STDOUT_FILENO, prepend, count) != count)
1181 1.37 mrg maybe_err(1, "write to stdout");
1182 1.37 mrg for (;;) {
1183 1.37 mrg rv = read(STDIN_FILENO, buf, sizeof buf);
1184 1.37 mrg
1185 1.37 mrg if (write(STDOUT_FILENO, buf, rv) != rv)
1186 1.37 mrg maybe_err(1, "write to stdout");
1187 1.37 mrg in_tot += rv;
1188 1.37 mrg }
1189 1.37 mrg
1190 1.37 mrg if (gsizep)
1191 1.37 mrg *gsizep = in_tot;
1192 1.37 mrg return (in_tot);
1193 1.37 mrg }
1194 1.37 mrg #endif
1195 1.37 mrg
1196 1.1 mrg static void
1197 1.1 mrg handle_stdin(void)
1198 1.1 mrg {
1199 1.37 mrg unsigned char header1[4];
1200 1.37 mrg off_t usize, gsize;
1201 1.37 mrg enum filetype method;
1202 1.37 mrg #ifndef NO_COMPRESS_SUPPORT
1203 1.37 mrg FILE *in;
1204 1.37 mrg #endif
1205 1.1 mrg
1206 1.25 mrg #ifndef SMALL
1207 1.5 mrg if (fflag == 0 && lflag == 0 && isatty(STDIN_FILENO)) {
1208 1.1 mrg maybe_warnx("standard input is a terminal -- ignoring");
1209 1.1 mrg return;
1210 1.1 mrg }
1211 1.25 mrg #endif
1212 1.5 mrg
1213 1.5 mrg if (lflag) {
1214 1.5 mrg struct stat isb;
1215 1.5 mrg
1216 1.37 mrg /* XXX could read the whole file, etc. */
1217 1.5 mrg if (fstat(STDIN_FILENO, &isb) < 0)
1218 1.5 mrg maybe_err(1, "fstat");
1219 1.7 mrg print_list(STDIN_FILENO, isb.st_size, "stdout", isb.st_mtime);
1220 1.5 mrg return;
1221 1.5 mrg }
1222 1.5 mrg
1223 1.37 mrg if (read(STDIN_FILENO, header1, sizeof header1) != sizeof header1)
1224 1.37 mrg maybe_err(1, "can't read stdin");
1225 1.37 mrg
1226 1.37 mrg method = file_gettype(header1);
1227 1.37 mrg switch (method) {
1228 1.37 mrg default:
1229 1.37 mrg #ifndef SMALL
1230 1.37 mrg if (fflag == 0)
1231 1.37 mrg maybe_errx(1, "unknown compression format");
1232 1.37 mrg usize = cat_stdin(header1, sizeof header1, &gsize);
1233 1.37 mrg break;
1234 1.37 mrg #endif
1235 1.37 mrg case FT_GZIP:
1236 1.37 mrg usize = gz_uncompress(STDIN_FILENO, STDOUT_FILENO,
1237 1.37 mrg header1, sizeof header1, &gsize);
1238 1.37 mrg break;
1239 1.37 mrg #ifndef NO_BZIP2_SUPPORT
1240 1.37 mrg case FT_BZIP2:
1241 1.37 mrg usize = unbzip2(STDIN_FILENO, STDOUT_FILENO,
1242 1.37 mrg header1, sizeof header1, &gsize);
1243 1.37 mrg break;
1244 1.37 mrg #endif
1245 1.37 mrg #ifndef NO_COMPRESS_SUPPORT
1246 1.37 mrg case FT_Z:
1247 1.37 mrg if ((in = zopen(NULL, stdin)) == NULL)
1248 1.37 mrg maybe_err(1, "zopen of stdin");
1249 1.37 mrg
1250 1.37 mrg usize = zuncompress(in, stdout, header1, sizeof header1, &gsize);
1251 1.37 mrg break;
1252 1.37 mrg #endif
1253 1.37 mrg }
1254 1.37 mrg
1255 1.37 mrg #ifndef SMALL
1256 1.37 mrg if (vflag && !tflag && usize != -1 && gsize != -1)
1257 1.37 mrg print_verbage(NULL, 0, usize, gsize);
1258 1.37 mrg #endif
1259 1.37 mrg
1260 1.1 mrg }
1261 1.1 mrg
1262 1.1 mrg static void
1263 1.1 mrg handle_stdout(void)
1264 1.1 mrg {
1265 1.37 mrg off_t gsize, usize;
1266 1.1 mrg
1267 1.25 mrg #ifndef SMALL
1268 1.1 mrg if (fflag == 0 && isatty(STDOUT_FILENO)) {
1269 1.1 mrg maybe_warnx("standard output is a terminal -- ignoring");
1270 1.1 mrg return;
1271 1.1 mrg }
1272 1.25 mrg #endif
1273 1.37 mrg usize = gz_compress(stdin, STDOUT_FILENO, &gsize, NULL, 0);
1274 1.37 mrg
1275 1.37 mrg #ifndef SMALL
1276 1.37 mrg if (vflag && !tflag && usize != -1 && gsize != -1)
1277 1.37 mrg print_verbage(NULL, 0, usize, gsize);
1278 1.37 mrg #endif
1279 1.1 mrg }
1280 1.1 mrg
1281 1.1 mrg /* do what is asked for, for the path name */
1282 1.1 mrg static void
1283 1.1 mrg handle_pathname(char *path)
1284 1.1 mrg {
1285 1.1 mrg char *opath = path, *s = 0;
1286 1.1 mrg ssize_t len;
1287 1.1 mrg struct stat sb;
1288 1.1 mrg
1289 1.1 mrg /* check for stdout/stdin */
1290 1.1 mrg if (path[0] == '-' && path[1] == '\0') {
1291 1.1 mrg if (dflag)
1292 1.1 mrg handle_stdin();
1293 1.1 mrg else
1294 1.1 mrg handle_stdout();
1295 1.1 mrg }
1296 1.1 mrg
1297 1.1 mrg retry:
1298 1.1 mrg if (stat(path, &sb) < 0) {
1299 1.1 mrg /* lets try <path>.gz if we're decompressing */
1300 1.1 mrg if (dflag && s == 0 && errno == ENOENT) {
1301 1.1 mrg len = strlen(path);
1302 1.1 mrg s = malloc(len + suffix_len);
1303 1.1 mrg if (s == 0)
1304 1.1 mrg maybe_err(1, "malloc");
1305 1.1 mrg memmove(s, path, len);
1306 1.10 mrg memmove(&s[len], suffix, suffix_len);
1307 1.1 mrg path = s;
1308 1.1 mrg goto retry;
1309 1.1 mrg }
1310 1.1 mrg maybe_warn("can't stat: %s", opath);
1311 1.1 mrg goto out;
1312 1.1 mrg }
1313 1.1 mrg
1314 1.1 mrg if (S_ISDIR(sb.st_mode)) {
1315 1.25 mrg #ifndef SMALL
1316 1.1 mrg if (rflag)
1317 1.1 mrg handle_dir(path, &sb);
1318 1.1 mrg else
1319 1.25 mrg #endif
1320 1.1 mrg maybe_warn("%s is a directory", path);
1321 1.1 mrg goto out;
1322 1.1 mrg }
1323 1.1 mrg
1324 1.1 mrg if (S_ISREG(sb.st_mode))
1325 1.1 mrg handle_file(path, &sb);
1326 1.1 mrg
1327 1.1 mrg out:
1328 1.1 mrg if (s)
1329 1.1 mrg free(s);
1330 1.1 mrg }
1331 1.1 mrg
1332 1.1 mrg /* compress/decompress a file */
1333 1.1 mrg static void
1334 1.1 mrg handle_file(char *file, struct stat *sbp)
1335 1.1 mrg {
1336 1.31 mrg off_t usize, gsize;
1337 1.1 mrg
1338 1.1 mrg infile = file;
1339 1.1 mrg if (dflag) {
1340 1.1 mrg usize = file_uncompress(file);
1341 1.1 mrg if (usize == 0)
1342 1.1 mrg return;
1343 1.1 mrg gsize = sbp->st_size;
1344 1.1 mrg } else {
1345 1.1 mrg gsize = file_compress(file);
1346 1.1 mrg if (gsize == 0)
1347 1.1 mrg return;
1348 1.1 mrg usize = sbp->st_size;
1349 1.1 mrg }
1350 1.1 mrg
1351 1.26 mrg
1352 1.26 mrg #ifndef SMALL
1353 1.1 mrg if (vflag && !tflag)
1354 1.1 mrg print_verbage(file, cflag == 0 ? newfile : 0, usize, gsize);
1355 1.26 mrg #endif
1356 1.1 mrg }
1357 1.1 mrg
1358 1.25 mrg #ifndef SMALL
1359 1.1 mrg /* this is used with -r to recursively decend directories */
1360 1.1 mrg static void
1361 1.1 mrg handle_dir(char *dir, struct stat *sbp)
1362 1.1 mrg {
1363 1.1 mrg char *path_argv[2];
1364 1.1 mrg FTS *fts;
1365 1.1 mrg FTSENT *entry;
1366 1.1 mrg
1367 1.1 mrg path_argv[0] = dir;
1368 1.1 mrg path_argv[1] = 0;
1369 1.1 mrg fts = fts_open(path_argv, FTS_PHYSICAL, NULL);
1370 1.1 mrg if (fts == NULL) {
1371 1.1 mrg warn("couldn't fts_open %s", dir);
1372 1.1 mrg return;
1373 1.1 mrg }
1374 1.1 mrg
1375 1.1 mrg while ((entry = fts_read(fts))) {
1376 1.1 mrg switch(entry->fts_info) {
1377 1.1 mrg case FTS_D:
1378 1.1 mrg case FTS_DP:
1379 1.1 mrg continue;
1380 1.1 mrg
1381 1.1 mrg case FTS_DNR:
1382 1.1 mrg case FTS_ERR:
1383 1.1 mrg case FTS_NS:
1384 1.1 mrg maybe_warn("%s", entry->fts_path);
1385 1.1 mrg continue;
1386 1.1 mrg case FTS_F:
1387 1.1 mrg handle_file(entry->fts_name, entry->fts_statp);
1388 1.1 mrg }
1389 1.1 mrg }
1390 1.1 mrg (void)fts_close(fts);
1391 1.1 mrg }
1392 1.25 mrg #endif
1393 1.1 mrg
1394 1.6 mrg /* print a ratio */
1395 1.6 mrg static void
1396 1.6 mrg print_ratio(off_t in, off_t out, FILE *where)
1397 1.6 mrg {
1398 1.35 mrg int64_t percent10; /* 10 * percent */
1399 1.35 mrg off_t diff = in - out;
1400 1.35 mrg char ch;
1401 1.6 mrg
1402 1.35 mrg if (in == 0)
1403 1.35 mrg percent10 = 0;
1404 1.35 mrg else if (diff > 0x400000) /* anything with 22 or more bits */
1405 1.35 mrg percent10 = diff / (in / 1000);
1406 1.35 mrg else
1407 1.35 mrg percent10 = (1000 * diff) / in;
1408 1.35 mrg
1409 1.35 mrg if (percent10 < 0) {
1410 1.35 mrg percent10 = -percent10;
1411 1.35 mrg ch = '-';
1412 1.35 mrg } else
1413 1.35 mrg ch = ' ';
1414 1.35 mrg
1415 1.35 mrg /*
1416 1.35 mrg * ugh. for negative percentages < 10, we need to avoid printing a
1417 1.35 mrg * a space between the "-" and the single number.
1418 1.35 mrg */
1419 1.35 mrg if (ch == '-' && percent10 / 10LL < 10)
1420 1.35 mrg fprintf(where, " -%1d.%1u%%", (unsigned)(percent10 / 10LL),
1421 1.35 mrg (unsigned)(percent10 % 10LL));
1422 1.6 mrg else
1423 1.35 mrg fprintf(where, "%c%2d.%1u%%", ch, (unsigned)(percent10 / 10LL),
1424 1.35 mrg (unsigned)(percent10 % 10LL));
1425 1.6 mrg }
1426 1.6 mrg
1427 1.26 mrg #ifndef SMALL
1428 1.1 mrg /* print compression statistics, and the new name (if there is one!) */
1429 1.1 mrg static void
1430 1.31 mrg print_verbage(char *file, char *nfile, off_t usize, off_t gsize)
1431 1.1 mrg {
1432 1.37 mrg if (file)
1433 1.37 mrg fprintf(stderr, "%s:%s ", file,
1434 1.37 mrg strlen(file) < 7 ? "\t\t" : "\t");
1435 1.31 mrg print_ratio((off_t)usize, (off_t)gsize, stderr);
1436 1.4 mrg if (nfile)
1437 1.4 mrg fprintf(stderr, " -- replaced with %s", nfile);
1438 1.1 mrg fprintf(stderr, "\n");
1439 1.1 mrg fflush(stderr);
1440 1.1 mrg }
1441 1.1 mrg
1442 1.1 mrg /* print test results */
1443 1.1 mrg static void
1444 1.1 mrg print_test(char *file, int ok)
1445 1.1 mrg {
1446 1.1 mrg
1447 1.1 mrg fprintf(stderr, "%s:%s %s\n", file,
1448 1.1 mrg strlen(file) < 7 ? "\t\t" : "\t", ok ? "OK" : "NOT OK");
1449 1.1 mrg fflush(stderr);
1450 1.1 mrg }
1451 1.26 mrg #endif
1452 1.1 mrg
1453 1.5 mrg /* print a file's info ala --list */
1454 1.5 mrg /* eg:
1455 1.5 mrg compressed uncompressed ratio uncompressed_name
1456 1.5 mrg 354841 1679360 78.8% /usr/pkgsrc/distfiles/libglade-2.0.1.tar
1457 1.5 mrg */
1458 1.5 mrg static void
1459 1.35 mrg print_list(int fd, off_t out, const char *outfile, time_t ts)
1460 1.5 mrg {
1461 1.5 mrg static int first = 1;
1462 1.29 mrg #ifndef SMALL
1463 1.6 mrg static off_t in_tot, out_tot;
1464 1.29 mrg u_int32_t crc;
1465 1.29 mrg #endif
1466 1.35 mrg off_t in;
1467 1.5 mrg int rv;
1468 1.5 mrg
1469 1.7 mrg if (first) {
1470 1.26 mrg #ifndef SMALL
1471 1.7 mrg if (vflag)
1472 1.7 mrg printf("method crc date time ");
1473 1.26 mrg #endif
1474 1.7 mrg if (qflag == 0)
1475 1.7 mrg printf(" compressed uncompressed "
1476 1.7 mrg "ratio uncompressed_name\n");
1477 1.7 mrg }
1478 1.5 mrg first = 0;
1479 1.5 mrg
1480 1.6 mrg /* print totals? */
1481 1.29 mrg #ifndef SMALL
1482 1.6 mrg if (fd == -1) {
1483 1.6 mrg in = in_tot;
1484 1.6 mrg out = out_tot;
1485 1.29 mrg } else
1486 1.29 mrg #endif
1487 1.29 mrg {
1488 1.6 mrg /* read the last 4 bytes - this is the uncompressed size */
1489 1.7 mrg rv = lseek(fd, (off_t)(-8), SEEK_END);
1490 1.6 mrg if (rv != -1) {
1491 1.7 mrg unsigned char buf[8];
1492 1.6 mrg u_int32_t usize;
1493 1.6 mrg
1494 1.6 mrg if (read(fd, (char *)buf, sizeof(buf)) != sizeof(buf))
1495 1.37 mrg maybe_warn("read of uncompressed size");
1496 1.7 mrg usize = buf[4] | buf[5] << 8 | buf[6] << 16 | buf[7] << 24;
1497 1.35 mrg in = (off_t)usize;
1498 1.29 mrg #ifndef SMALL
1499 1.29 mrg crc = buf[0] | buf[1] << 8 | buf[2] << 16 | buf[3] << 24;
1500 1.29 mrg #endif
1501 1.6 mrg }
1502 1.6 mrg }
1503 1.5 mrg
1504 1.26 mrg #ifndef SMALL
1505 1.7 mrg if (vflag && fd == -1)
1506 1.7 mrg printf(" ");
1507 1.7 mrg else if (vflag) {
1508 1.7 mrg char *date = ctime(&ts);
1509 1.7 mrg
1510 1.7 mrg /* skip the day, 1/100th second, and year */
1511 1.7 mrg date += 4;
1512 1.7 mrg date[12] = 0;
1513 1.7 mrg printf("%5s %08x %11s ", "defla"/*XXX*/, crc, date);
1514 1.7 mrg }
1515 1.29 mrg in_tot += in;
1516 1.29 mrg out_tot += out;
1517 1.26 mrg #endif
1518 1.35 mrg printf("%12llu %12llu ", (unsigned long long)out, (unsigned long long)in);
1519 1.6 mrg print_ratio(in, out, stdout);
1520 1.6 mrg printf(" %s\n", outfile);
1521 1.5 mrg }
1522 1.5 mrg
1523 1.1 mrg /* display the usage of NetBSD gzip */
1524 1.1 mrg static void
1525 1.1 mrg usage(void)
1526 1.1 mrg {
1527 1.1 mrg
1528 1.1 mrg fprintf(stderr, "%s\n", gzip_version);
1529 1.1 mrg fprintf(stderr,
1530 1.29 mrg "usage: %s [-" OPT_LIST "] [<file> [<file> ...]]\n"
1531 1.11 mrg #ifndef SMALL
1532 1.1 mrg " -c --stdout write to stdout, keep original files\n"
1533 1.1 mrg " --to-stdout\n"
1534 1.1 mrg " -d --decompress uncompress files\n"
1535 1.1 mrg " --uncompress\n"
1536 1.1 mrg " -f --force force overwriting & compress links\n"
1537 1.1 mrg " -h --help display this help\n"
1538 1.1 mrg " -n --no-name don't save original file name or time stamp\n"
1539 1.1 mrg " -N --name save or restore original file name and time stamp\n"
1540 1.1 mrg " -q --quiet output no warnings\n"
1541 1.1 mrg " -r --recursive recursively compress files in directories\n"
1542 1.1 mrg " -S .suf use suffix .suf instead of .gz\n"
1543 1.1 mrg " --suffix .suf\n"
1544 1.1 mrg " -t --test test compressed file\n"
1545 1.1 mrg " -v --verbose print extra statistics\n"
1546 1.1 mrg " -V --version display program version\n"
1547 1.1 mrg " -1 --fast fastest (worst) compression\n"
1548 1.1 mrg " -2 .. -8 set compression level\n"
1549 1.1 mrg " -9 --best best (slowest) compression\n",
1550 1.11 mrg #else
1551 1.11 mrg ,
1552 1.11 mrg #endif
1553 1.1 mrg getprogname());
1554 1.1 mrg exit(0);
1555 1.1 mrg }
1556 1.1 mrg
1557 1.1 mrg /* display the version of NetBSD gzip */
1558 1.1 mrg static void
1559 1.1 mrg display_version(void)
1560 1.1 mrg {
1561 1.1 mrg
1562 1.1 mrg fprintf(stderr, "%s\n", gzip_version);
1563 1.1 mrg exit(0);
1564 1.1 mrg }
1565 1.10 mrg
1566 1.24 tsutsui #ifndef NO_BZIP2_SUPPORT
1567 1.10 mrg #include "unbzip2.c"
1568 1.24 tsutsui #endif
1569 1.24 tsutsui #ifndef NO_COMPRESS_SUPPORT
1570 1.22 mrg #include "zuncompress.c"
1571 1.24 tsutsui #endif
1572