gzip.c revision 1.71 1 1.71 yamt /* $NetBSD: gzip.c,v 1.71 2005/02/22 21:45:44 yamt 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.71 yamt __RCSID("$NetBSD: gzip.c,v 1.71 2005/02/22 21:45:44 yamt 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.65 dsl * RFC 1950 covers the zlib format
42 1.65 dsl * RFC 1951 covers the deflate format
43 1.65 dsl * RFC 1952 covers the gzip format
44 1.65 dsl *
45 1.6 mrg * TODO:
46 1.10 mrg * - use mmap where possible
47 1.16 wiz * - handle some signals better (remove outfile?)
48 1.41 mrg * - make bzip2/compress -v/-t/-l support work as well as possible
49 1.1 mrg */
50 1.1 mrg
51 1.1 mrg #include <sys/param.h>
52 1.1 mrg #include <sys/stat.h>
53 1.1 mrg #include <sys/time.h>
54 1.1 mrg
55 1.63 dsl #include <inttypes.h>
56 1.1 mrg #include <unistd.h>
57 1.1 mrg #include <stdio.h>
58 1.1 mrg #include <string.h>
59 1.1 mrg #include <stdlib.h>
60 1.1 mrg #include <err.h>
61 1.1 mrg #include <errno.h>
62 1.1 mrg #include <fcntl.h>
63 1.1 mrg #include <zlib.h>
64 1.1 mrg #include <fts.h>
65 1.1 mrg #include <libgen.h>
66 1.1 mrg #include <stdarg.h>
67 1.1 mrg #include <getopt.h>
68 1.69 jmc #include <time.h>
69 1.1 mrg
70 1.63 dsl #ifndef PRIdOFF
71 1.63 dsl #define PRIdOFF PRId64
72 1.63 dsl #endif
73 1.63 dsl
74 1.10 mrg /* what type of file are we dealing with */
75 1.10 mrg enum filetype {
76 1.10 mrg FT_GZIP,
77 1.24 tsutsui #ifndef NO_BZIP2_SUPPORT
78 1.10 mrg FT_BZIP2,
79 1.24 tsutsui #endif
80 1.24 tsutsui #ifndef NO_COMPRESS_SUPPORT
81 1.22 mrg FT_Z,
82 1.24 tsutsui #endif
83 1.10 mrg FT_LAST,
84 1.10 mrg FT_UNKNOWN
85 1.10 mrg };
86 1.10 mrg
87 1.24 tsutsui #ifndef NO_BZIP2_SUPPORT
88 1.10 mrg #include <bzlib.h>
89 1.10 mrg
90 1.24 tsutsui #define BZ2_SUFFIX ".bz2"
91 1.24 tsutsui #define BZIP2_MAGIC "\102\132\150"
92 1.24 tsutsui #endif
93 1.24 tsutsui
94 1.24 tsutsui #ifndef NO_COMPRESS_SUPPORT
95 1.22 mrg #define Z_SUFFIX ".Z"
96 1.22 mrg #define Z_MAGIC "\037\235"
97 1.24 tsutsui #endif
98 1.10 mrg
99 1.10 mrg #define GZ_SUFFIX ".gz"
100 1.1 mrg
101 1.37 mrg #define BUFLEN (64 * 1024)
102 1.1 mrg
103 1.9 mrg #define GZIP_MAGIC0 0x1F
104 1.10 mrg #define GZIP_MAGIC1 0x8B
105 1.10 mrg #define GZIP_OMAGIC1 0x9E
106 1.9 mrg
107 1.48 mrg #define GZIP_TIMESTAMP (off_t)4
108 1.47 mrg #define GZIP_ORIGNAME (off_t)10
109 1.47 mrg
110 1.37 mrg #define HEAD_CRC 0x02
111 1.37 mrg #define EXTRA_FIELD 0x04
112 1.37 mrg #define ORIG_NAME 0x08
113 1.37 mrg #define COMMENT 0x10
114 1.1 mrg
115 1.37 mrg #define OS_CODE 3 /* Unix */
116 1.1 mrg
117 1.63 dsl typedef struct {
118 1.66 dsl const char *zipped;
119 1.63 dsl int ziplen;
120 1.66 dsl const char *normal; /* for unzip - must not be longer than zipped */
121 1.63 dsl } suffixes_t;
122 1.63 dsl static suffixes_t suffixes[] = {
123 1.66 dsl #define SUFFIX(Z, N) {Z, sizeof Z - 1, N}
124 1.63 dsl SUFFIX(GZ_SUFFIX, ""), /* Overwritten by -S .xxx */
125 1.63 dsl #ifndef SMALL
126 1.63 dsl SUFFIX(GZ_SUFFIX, ""),
127 1.63 dsl SUFFIX(".z", ""),
128 1.63 dsl SUFFIX("-gz", ""),
129 1.63 dsl SUFFIX("-z", ""),
130 1.63 dsl SUFFIX("_z", ""),
131 1.63 dsl SUFFIX(".taz", ".tar"),
132 1.63 dsl SUFFIX(".tgz", ".tar"),
133 1.56 mrg #ifndef NO_BZIP2_SUPPORT
134 1.63 dsl SUFFIX(BZ2_SUFFIX, ""),
135 1.56 mrg #endif
136 1.56 mrg #ifndef NO_COMPRESS_SUPPORT
137 1.63 dsl SUFFIX(Z_SUFFIX, ""),
138 1.56 mrg #endif
139 1.63 dsl SUFFIX(GZ_SUFFIX, ""), /* Overwritten by -S "" */
140 1.63 dsl #endif /* SMALL */
141 1.63 dsl #undef SUFFIX
142 1.56 mrg };
143 1.63 dsl #define NUM_SUFFIXES (sizeof suffixes / sizeof suffixes[0])
144 1.56 mrg
145 1.63 dsl static const char gzip_version[] = "NetBSD gzip 20040830";
146 1.1 mrg
147 1.1 mrg static int cflag; /* stdout mode */
148 1.1 mrg static int dflag; /* decompress mode */
149 1.25 mrg static int lflag; /* list mode */
150 1.41 mrg static int numflag = 6; /* gzip -1..-9 value */
151 1.26 mrg
152 1.25 mrg #ifndef SMALL
153 1.1 mrg static int fflag; /* force mode */
154 1.1 mrg static int nflag; /* don't save name/timestamp */
155 1.1 mrg static int Nflag; /* don't restore name/timestamp */
156 1.1 mrg static int qflag; /* quiet mode */
157 1.1 mrg static int rflag; /* recursive mode */
158 1.26 mrg static int tflag; /* test */
159 1.26 mrg static int vflag; /* verbose mode */
160 1.25 mrg #else
161 1.25 mrg #define qflag 0
162 1.66 dsl #define tflag 0
163 1.25 mrg #endif
164 1.26 mrg
165 1.46 mrg static int exit_value = 0; /* exit value */
166 1.46 mrg
167 1.1 mrg static char *infile; /* name of file coming in */
168 1.1 mrg
169 1.63 dsl static void maybe_err(const char *fmt, ...)
170 1.63 dsl __attribute__((__format__(__printf__, 1, 2)));
171 1.66 dsl #ifndef NO_BZIP2_SUPPORT
172 1.63 dsl static void maybe_errx(const char *fmt, ...)
173 1.63 dsl __attribute__((__format__(__printf__, 1, 2)));
174 1.66 dsl #endif
175 1.63 dsl static void maybe_warn(const char *fmt, ...)
176 1.63 dsl __attribute__((__format__(__printf__, 1, 2)));
177 1.63 dsl static void maybe_warnx(const char *fmt, ...)
178 1.63 dsl __attribute__((__format__(__printf__, 1, 2)));
179 1.32 mrg static enum filetype file_gettype(u_char *);
180 1.63 dsl #ifdef SMALL
181 1.63 dsl #define gz_compress(if, of, sz, fn, tm) gz_compress(if, of, sz)
182 1.63 dsl #endif
183 1.63 dsl static off_t gz_compress(int, int, off_t *, const char *, uint32_t);
184 1.46 mrg static off_t gz_uncompress(int, int, char *, size_t, off_t *, const char *);
185 1.45 agc static off_t file_compress(char *, char *, size_t);
186 1.45 agc static off_t file_uncompress(char *, char *, size_t);
187 1.1 mrg static void handle_pathname(char *);
188 1.1 mrg static void handle_file(char *, struct stat *);
189 1.1 mrg static void handle_stdin(void);
190 1.1 mrg static void handle_stdout(void);
191 1.6 mrg static void print_ratio(off_t, off_t, FILE *);
192 1.7 mrg static void print_list(int fd, off_t, const char *, time_t);
193 1.10 mrg static void usage(void);
194 1.10 mrg static void display_version(void);
195 1.63 dsl static const suffixes_t *check_suffix(char *, int);
196 1.71 yamt static ssize_t read_retry(int, void *, size_t);
197 1.26 mrg
198 1.63 dsl #ifdef SMALL
199 1.63 dsl #define unlink_input(f, sb) unlink(f)
200 1.63 dsl #else
201 1.66 dsl static off_t cat_fd(unsigned char *, size_t, off_t *, int fd);
202 1.26 mrg static void prepend_gzip(char *, int *, char ***);
203 1.26 mrg static void handle_dir(char *, struct stat *);
204 1.63 dsl static void print_verbage(const char *, const char *, off_t, off_t);
205 1.45 agc static void print_test(const char *, int);
206 1.29 mrg static void copymodes(const char *, struct stat *);
207 1.56 mrg static int check_outfile(const char *outfile, struct stat *sb);
208 1.26 mrg #endif
209 1.26 mrg
210 1.24 tsutsui #ifndef NO_BZIP2_SUPPORT
211 1.37 mrg static off_t unbzip2(int, int, char *, size_t, off_t *);
212 1.24 tsutsui #endif
213 1.26 mrg
214 1.24 tsutsui #ifndef NO_COMPRESS_SUPPORT
215 1.63 dsl static FILE *zdopen(int);
216 1.37 mrg static off_t zuncompress(FILE *, FILE *, char *, size_t, off_t *);
217 1.24 tsutsui #endif
218 1.1 mrg
219 1.1 mrg int main(int, char *p[]);
220 1.1 mrg
221 1.11 mrg #ifdef SMALL
222 1.11 mrg #define getopt_long(a,b,c,d,e) getopt(a,b,c)
223 1.11 mrg #else
224 1.3 jdolecek static const struct option longopts[] = {
225 1.1 mrg { "stdout", no_argument, 0, 'c' },
226 1.1 mrg { "to-stdout", no_argument, 0, 'c' },
227 1.1 mrg { "decompress", no_argument, 0, 'd' },
228 1.1 mrg { "uncompress", no_argument, 0, 'd' },
229 1.1 mrg { "force", no_argument, 0, 'f' },
230 1.1 mrg { "help", no_argument, 0, 'h' },
231 1.5 mrg { "list", no_argument, 0, 'l' },
232 1.1 mrg { "no-name", no_argument, 0, 'n' },
233 1.1 mrg { "name", no_argument, 0, 'N' },
234 1.1 mrg { "quiet", no_argument, 0, 'q' },
235 1.1 mrg { "recursive", no_argument, 0, 'r' },
236 1.1 mrg { "suffix", required_argument, 0, 'S' },
237 1.1 mrg { "test", no_argument, 0, 't' },
238 1.1 mrg { "verbose", no_argument, 0, 'v' },
239 1.1 mrg { "version", no_argument, 0, 'V' },
240 1.1 mrg { "fast", no_argument, 0, '1' },
241 1.1 mrg { "best", no_argument, 0, '9' },
242 1.1 mrg #if 0
243 1.1 mrg /*
244 1.10 mrg * This is what else GNU gzip implements. --ascii isn't useful
245 1.10 mrg * on NetBSD, and I don't care to have a --license.
246 1.1 mrg */
247 1.1 mrg { "ascii", no_argument, 0, 'a' },
248 1.1 mrg { "license", no_argument, 0, 'L' },
249 1.1 mrg #endif
250 1.12 mrg { NULL, no_argument, 0, 0 },
251 1.1 mrg };
252 1.11 mrg #endif
253 1.1 mrg
254 1.1 mrg int
255 1.1 mrg main(int argc, char **argv)
256 1.1 mrg {
257 1.28 mrg const char *progname = getprogname();
258 1.25 mrg #ifndef SMALL
259 1.15 mrg char *gzip;
260 1.63 dsl int len;
261 1.25 mrg #endif
262 1.1 mrg int ch;
263 1.1 mrg
264 1.15 mrg /* XXX set up signals */
265 1.15 mrg
266 1.25 mrg #ifndef SMALL
267 1.15 mrg if ((gzip = getenv("GZIP")) != NULL)
268 1.15 mrg prepend_gzip(gzip, &argc, &argv);
269 1.28 mrg #endif
270 1.15 mrg
271 1.1 mrg /*
272 1.1 mrg * XXX
273 1.1 mrg * handle being called `gunzip', `zcat' and `gzcat'
274 1.1 mrg */
275 1.1 mrg if (strcmp(progname, "gunzip") == 0)
276 1.1 mrg dflag = 1;
277 1.1 mrg else if (strcmp(progname, "zcat") == 0 ||
278 1.1 mrg strcmp(progname, "gzcat") == 0)
279 1.1 mrg dflag = cflag = 1;
280 1.25 mrg
281 1.25 mrg #ifdef SMALL
282 1.31 mrg #define OPT_LIST "cdhHltV123456789"
283 1.25 mrg #else
284 1.28 mrg #define OPT_LIST "cdfhHlnNqrS:tvV123456789"
285 1.25 mrg #endif
286 1.1 mrg
287 1.63 dsl while ((ch = getopt_long(argc, argv, OPT_LIST, longopts, NULL)) != -1) {
288 1.1 mrg switch (ch) {
289 1.1 mrg case 'c':
290 1.1 mrg cflag = 1;
291 1.1 mrg break;
292 1.1 mrg case 'd':
293 1.1 mrg dflag = 1;
294 1.1 mrg break;
295 1.5 mrg case 'l':
296 1.5 mrg lflag = 1;
297 1.5 mrg dflag = 1;
298 1.5 mrg break;
299 1.26 mrg case 'V':
300 1.26 mrg display_version();
301 1.26 mrg /* NOTREACHED */
302 1.26 mrg case '1': case '2': case '3':
303 1.26 mrg case '4': case '5': case '6':
304 1.26 mrg case '7': case '8': case '9':
305 1.38 mrg numflag = ch - '0';
306 1.26 mrg break;
307 1.25 mrg #ifndef SMALL
308 1.25 mrg case 'f':
309 1.25 mrg fflag = 1;
310 1.25 mrg break;
311 1.1 mrg case 'n':
312 1.1 mrg nflag = 1;
313 1.1 mrg Nflag = 0;
314 1.1 mrg break;
315 1.1 mrg case 'N':
316 1.1 mrg nflag = 0;
317 1.1 mrg Nflag = 1;
318 1.1 mrg break;
319 1.1 mrg case 'q':
320 1.1 mrg qflag = 1;
321 1.1 mrg break;
322 1.1 mrg case 'r':
323 1.1 mrg rflag = 1;
324 1.1 mrg break;
325 1.1 mrg case 'S':
326 1.63 dsl len = strlen(optarg);
327 1.63 dsl if (len != 0) {
328 1.66 dsl suffixes[0].zipped = optarg;
329 1.63 dsl suffixes[0].ziplen = len;
330 1.63 dsl } else {
331 1.66 dsl suffixes[NUM_SUFFIXES - 1].zipped = "";
332 1.63 dsl suffixes[NUM_SUFFIXES - 1].ziplen = 0;
333 1.63 dsl }
334 1.1 mrg break;
335 1.1 mrg case 't':
336 1.1 mrg cflag = 1;
337 1.1 mrg tflag = 1;
338 1.1 mrg dflag = 1;
339 1.1 mrg break;
340 1.1 mrg case 'v':
341 1.1 mrg vflag = 1;
342 1.1 mrg break;
343 1.26 mrg #endif
344 1.12 mrg default:
345 1.12 mrg usage();
346 1.12 mrg /* NOTREACHED */
347 1.1 mrg }
348 1.63 dsl }
349 1.1 mrg argv += optind;
350 1.1 mrg argc -= optind;
351 1.1 mrg
352 1.1 mrg if (argc == 0) {
353 1.1 mrg if (dflag) /* stdin mode */
354 1.1 mrg handle_stdin();
355 1.1 mrg else /* stdout mode */
356 1.1 mrg handle_stdout();
357 1.1 mrg } else {
358 1.1 mrg do {
359 1.1 mrg handle_pathname(argv[0]);
360 1.5 mrg } while (*++argv);
361 1.1 mrg }
362 1.29 mrg #ifndef SMALL
363 1.6 mrg if (qflag == 0 && lflag && argc > 1)
364 1.7 mrg print_list(-1, 0, "(totals)", 0);
365 1.29 mrg #endif
366 1.46 mrg exit(exit_value);
367 1.1 mrg }
368 1.1 mrg
369 1.1 mrg /* maybe print a warning */
370 1.1 mrg void
371 1.1 mrg maybe_warn(const char *fmt, ...)
372 1.1 mrg {
373 1.1 mrg va_list ap;
374 1.1 mrg
375 1.1 mrg if (qflag == 0) {
376 1.1 mrg va_start(ap, fmt);
377 1.1 mrg vwarn(fmt, ap);
378 1.1 mrg va_end(ap);
379 1.1 mrg }
380 1.46 mrg if (exit_value == 0)
381 1.46 mrg exit_value = 1;
382 1.1 mrg }
383 1.1 mrg
384 1.46 mrg /* ... without an errno. */
385 1.1 mrg void
386 1.1 mrg maybe_warnx(const char *fmt, ...)
387 1.1 mrg {
388 1.1 mrg va_list ap;
389 1.1 mrg
390 1.1 mrg if (qflag == 0) {
391 1.1 mrg va_start(ap, fmt);
392 1.1 mrg vwarnx(fmt, ap);
393 1.1 mrg va_end(ap);
394 1.1 mrg }
395 1.46 mrg if (exit_value == 0)
396 1.46 mrg exit_value = 1;
397 1.1 mrg }
398 1.1 mrg
399 1.46 mrg /* maybe print an error */
400 1.1 mrg void
401 1.46 mrg maybe_err(const char *fmt, ...)
402 1.1 mrg {
403 1.1 mrg va_list ap;
404 1.1 mrg
405 1.1 mrg if (qflag == 0) {
406 1.1 mrg va_start(ap, fmt);
407 1.1 mrg vwarn(fmt, ap);
408 1.1 mrg va_end(ap);
409 1.1 mrg }
410 1.46 mrg exit(2);
411 1.1 mrg }
412 1.1 mrg
413 1.66 dsl #ifndef NO_BZIP2_SUPPORT
414 1.46 mrg /* ... without an errno. */
415 1.9 mrg void
416 1.46 mrg maybe_errx(const char *fmt, ...)
417 1.9 mrg {
418 1.9 mrg va_list ap;
419 1.9 mrg
420 1.9 mrg if (qflag == 0) {
421 1.9 mrg va_start(ap, fmt);
422 1.9 mrg vwarnx(fmt, ap);
423 1.9 mrg va_end(ap);
424 1.9 mrg }
425 1.46 mrg exit(2);
426 1.9 mrg }
427 1.66 dsl #endif
428 1.9 mrg
429 1.25 mrg #ifndef SMALL
430 1.15 mrg /* split up $GZIP and prepend it to the argument list */
431 1.15 mrg static void
432 1.15 mrg prepend_gzip(char *gzip, int *argc, char ***argv)
433 1.15 mrg {
434 1.15 mrg char *s, **nargv, **ac;
435 1.15 mrg int nenvarg = 0, i;
436 1.15 mrg
437 1.15 mrg /* scan how many arguments there are */
438 1.70 enami for (s = gzip;;) {
439 1.70 enami while (*s == ' ' || *s == '\t')
440 1.70 enami s++;
441 1.70 enami if (*s == 0)
442 1.70 enami goto count_done;
443 1.15 mrg nenvarg++;
444 1.70 enami while (*s != ' ' && *s != '\t')
445 1.70 enami if (*s++ == 0)
446 1.70 enami goto count_done;
447 1.15 mrg }
448 1.70 enami count_done:
449 1.15 mrg /* punt early */
450 1.15 mrg if (nenvarg == 0)
451 1.15 mrg return;
452 1.15 mrg
453 1.15 mrg *argc += nenvarg;
454 1.15 mrg ac = *argv;
455 1.15 mrg
456 1.17 simonb nargv = (char **)malloc((*argc + 1) * sizeof(char *));
457 1.15 mrg if (nargv == NULL)
458 1.46 mrg maybe_err("malloc");
459 1.15 mrg
460 1.15 mrg /* stash this away */
461 1.15 mrg *argv = nargv;
462 1.15 mrg
463 1.15 mrg /* copy the program name first */
464 1.15 mrg i = 0;
465 1.15 mrg nargv[i++] = *(ac++);
466 1.15 mrg
467 1.15 mrg /* take a copy of $GZIP and add it to the array */
468 1.15 mrg s = strdup(gzip);
469 1.15 mrg if (s == NULL)
470 1.46 mrg maybe_err("strdup");
471 1.70 enami for (;;) {
472 1.70 enami /* Skip whitespaces. */
473 1.70 enami while (*s == ' ' || *s == '\t')
474 1.70 enami s++;
475 1.70 enami if (*s == 0)
476 1.70 enami goto copy_done;
477 1.15 mrg nargv[i++] = s;
478 1.70 enami /* Find the end of this argument. */
479 1.70 enami while (*s != ' ' && *s != '\t')
480 1.70 enami if (*s++ == 0)
481 1.70 enami /* Argument followed by NUL. */
482 1.70 enami goto copy_done;
483 1.70 enami /* Terminate by overwriting ' ' or '\t' with NUL. */
484 1.70 enami *s++ = 0;
485 1.15 mrg }
486 1.70 enami copy_done:
487 1.15 mrg
488 1.15 mrg /* copy the original arguments and a NULL */
489 1.15 mrg while (*ac)
490 1.15 mrg nargv[i++] = *(ac++);
491 1.15 mrg nargv[i] = NULL;
492 1.15 mrg }
493 1.25 mrg #endif
494 1.15 mrg
495 1.63 dsl /* compress input to output. Return bytes read, -1 on error */
496 1.37 mrg static off_t
497 1.63 dsl gz_compress(int in, int out, off_t *gsizep, const char *origname, uint32_t mtime)
498 1.1 mrg {
499 1.37 mrg z_stream z;
500 1.62 he char *outbufp, *inbufp;
501 1.37 mrg off_t in_tot = 0, out_tot = 0;
502 1.37 mrg ssize_t in_size;
503 1.37 mrg int i, error;
504 1.37 mrg uLong crc;
505 1.63 dsl #ifdef SMALL
506 1.63 dsl static char header[] = { GZIP_MAGIC0, GZIP_MAGIC1, Z_DEFLATED, 0,
507 1.63 dsl 0, 0, 0, 0,
508 1.63 dsl 0, OS_CODE };
509 1.63 dsl #endif
510 1.37 mrg
511 1.63 dsl outbufp = malloc(BUFLEN);
512 1.63 dsl inbufp = malloc(BUFLEN);
513 1.63 dsl if (outbufp == NULL || inbufp == NULL) {
514 1.62 he maybe_err("malloc failed");
515 1.46 mrg goto out;
516 1.46 mrg }
517 1.37 mrg
518 1.37 mrg memset(&z, 0, sizeof z);
519 1.38 mrg z.zalloc = Z_NULL;
520 1.38 mrg z.zfree = Z_NULL;
521 1.37 mrg z.opaque = 0;
522 1.37 mrg
523 1.63 dsl #ifdef SMALL
524 1.63 dsl memcpy(outbufp, header, sizeof header);
525 1.63 dsl i = sizeof header;
526 1.63 dsl #else
527 1.63 dsl if (nflag != 0) {
528 1.63 dsl mtime = 0;
529 1.63 dsl origname = "";
530 1.63 dsl }
531 1.63 dsl
532 1.63 dsl i = snprintf(outbufp, BUFLEN, "%c%c%c%c%c%c%c%c%c%c%s",
533 1.63 dsl GZIP_MAGIC0, GZIP_MAGIC1, Z_DEFLATED,
534 1.63 dsl *origname ? ORIG_NAME : 0,
535 1.63 dsl mtime & 0xff,
536 1.63 dsl (mtime >> 8) & 0xff,
537 1.63 dsl (mtime >> 16) & 0xff,
538 1.63 dsl (mtime >> 24) & 0xff,
539 1.65 dsl numflag == 1 ? 4 : numflag == 9 ? 2 : 0,
540 1.65 dsl OS_CODE, origname);
541 1.63 dsl if (i >= BUFLEN)
542 1.63 dsl /* this need PATH_MAX > BUFLEN ... */
543 1.63 dsl maybe_err("snprintf");
544 1.63 dsl if (*origname)
545 1.63 dsl i++;
546 1.63 dsl #endif
547 1.63 dsl
548 1.63 dsl z.next_out = outbufp + i;
549 1.63 dsl z.avail_out = BUFLEN - i;
550 1.63 dsl
551 1.37 mrg error = deflateInit2(&z, numflag, Z_DEFLATED,
552 1.37 mrg -MAX_WBITS, 8, Z_DEFAULT_STRATEGY);
553 1.46 mrg if (error != Z_OK) {
554 1.46 mrg maybe_warnx("deflateInit2 failed");
555 1.46 mrg in_tot = -1;
556 1.46 mrg goto out;
557 1.46 mrg }
558 1.37 mrg
559 1.37 mrg crc = crc32(0L, Z_NULL, 0);
560 1.37 mrg for (;;) {
561 1.37 mrg if (z.avail_out == 0) {
562 1.62 he if (write(out, outbufp, BUFLEN) != BUFLEN) {
563 1.46 mrg maybe_warn("write");
564 1.46 mrg in_tot = -1;
565 1.46 mrg goto out;
566 1.46 mrg }
567 1.37 mrg
568 1.62 he out_tot += BUFLEN;
569 1.62 he z.next_out = outbufp;
570 1.62 he z.avail_out = BUFLEN;
571 1.37 mrg }
572 1.37 mrg
573 1.37 mrg if (z.avail_in == 0) {
574 1.63 dsl in_size = read(in, inbufp, BUFLEN);
575 1.63 dsl if (in_size < 0) {
576 1.63 dsl maybe_warn("read");
577 1.46 mrg in_tot = -1;
578 1.46 mrg goto out;
579 1.46 mrg }
580 1.37 mrg if (in_size == 0)
581 1.37 mrg break;
582 1.37 mrg
583 1.62 he crc = crc32(crc, (const Bytef *)inbufp, (unsigned)in_size);
584 1.37 mrg in_tot += in_size;
585 1.62 he z.next_in = inbufp;
586 1.37 mrg z.avail_in = in_size;
587 1.37 mrg }
588 1.37 mrg
589 1.37 mrg error = deflate(&z, Z_NO_FLUSH);
590 1.46 mrg if (error != Z_OK && error != Z_STREAM_END) {
591 1.46 mrg maybe_warnx("deflate failed");
592 1.46 mrg in_tot = -1;
593 1.46 mrg goto out;
594 1.46 mrg }
595 1.37 mrg }
596 1.1 mrg
597 1.37 mrg /* clean up */
598 1.1 mrg for (;;) {
599 1.37 mrg size_t len;
600 1.37 mrg
601 1.37 mrg error = deflate(&z, Z_FINISH);
602 1.46 mrg if (error != Z_OK && error != Z_STREAM_END) {
603 1.46 mrg maybe_warnx("deflate failed");
604 1.46 mrg in_tot = -1;
605 1.46 mrg goto out;
606 1.46 mrg }
607 1.37 mrg
608 1.63 dsl len = (char *)z.next_out - outbufp;
609 1.37 mrg
610 1.62 he if (write(out, outbufp, len) != len) {
611 1.46 mrg maybe_warn("write");
612 1.46 mrg out_tot = -1;
613 1.46 mrg goto out;
614 1.46 mrg }
615 1.37 mrg out_tot += len;
616 1.62 he z.next_out = outbufp;
617 1.62 he z.avail_out = BUFLEN;
618 1.37 mrg
619 1.37 mrg if (error == Z_STREAM_END)
620 1.1 mrg break;
621 1.37 mrg }
622 1.37 mrg
623 1.46 mrg if (deflateEnd(&z) != Z_OK) {
624 1.46 mrg maybe_warnx("deflateEnd failed");
625 1.46 mrg in_tot = -1;
626 1.46 mrg goto out;
627 1.46 mrg }
628 1.37 mrg
629 1.63 dsl i = snprintf(outbufp, BUFLEN, "%c%c%c%c%c%c%c%c",
630 1.37 mrg (int)crc & 0xff,
631 1.37 mrg (int)(crc >> 8) & 0xff,
632 1.37 mrg (int)(crc >> 16) & 0xff,
633 1.37 mrg (int)(crc >> 24) & 0xff,
634 1.37 mrg (int)in_tot & 0xff,
635 1.37 mrg (int)(in_tot >> 8) & 0xff,
636 1.37 mrg (int)(in_tot >> 16) & 0xff,
637 1.37 mrg (int)(in_tot >> 24) & 0xff);
638 1.37 mrg if (i != 8)
639 1.63 dsl maybe_err("snprintf");
640 1.63 dsl if (write(out, outbufp, i) != i) {
641 1.46 mrg maybe_warn("write");
642 1.46 mrg in_tot = -1;
643 1.63 dsl } else
644 1.63 dsl out_tot += i;
645 1.1 mrg
646 1.46 mrg out:
647 1.63 dsl if (inbufp != NULL)
648 1.63 dsl free(inbufp);
649 1.63 dsl if (outbufp != NULL)
650 1.63 dsl free(outbufp);
651 1.37 mrg if (gsizep)
652 1.37 mrg *gsizep = out_tot;
653 1.37 mrg return in_tot;
654 1.1 mrg }
655 1.1 mrg
656 1.37 mrg /*
657 1.37 mrg * uncompress input to output then close the input. return the
658 1.37 mrg * uncompressed size written, and put the compressed sized read
659 1.37 mrg * into `*gsizep'.
660 1.37 mrg */
661 1.1 mrg static off_t
662 1.46 mrg gz_uncompress(int in, int out, char *pre, size_t prelen, off_t *gsizep,
663 1.46 mrg const char *filename)
664 1.1 mrg {
665 1.37 mrg z_stream z;
666 1.62 he char *outbufp, *inbufp;
667 1.67 dsl off_t out_tot, in_tot;
668 1.67 dsl uint32_t out_sub_tot;
669 1.37 mrg enum {
670 1.37 mrg GZSTATE_MAGIC0,
671 1.37 mrg GZSTATE_MAGIC1,
672 1.37 mrg GZSTATE_METHOD,
673 1.37 mrg GZSTATE_FLAGS,
674 1.37 mrg GZSTATE_SKIPPING,
675 1.37 mrg GZSTATE_EXTRA,
676 1.37 mrg GZSTATE_EXTRA2,
677 1.37 mrg GZSTATE_EXTRA3,
678 1.37 mrg GZSTATE_ORIGNAME,
679 1.37 mrg GZSTATE_COMMENT,
680 1.37 mrg GZSTATE_HEAD_CRC1,
681 1.37 mrg GZSTATE_HEAD_CRC2,
682 1.37 mrg GZSTATE_INIT,
683 1.55 mrg GZSTATE_READ,
684 1.55 mrg GZSTATE_CRC,
685 1.55 mrg GZSTATE_LEN,
686 1.37 mrg } state = GZSTATE_MAGIC0;
687 1.37 mrg int flags = 0, skip_count = 0;
688 1.37 mrg int error, done_reading = 0;
689 1.54 mrg uLong crc;
690 1.68 dsl ssize_t wr;
691 1.71 yamt int needmore = 0;
692 1.37 mrg
693 1.37 mrg #define ADVANCE() { z.next_in++; z.avail_in--; }
694 1.37 mrg
695 1.62 he if ((outbufp = malloc(BUFLEN)) == NULL) {
696 1.62 he maybe_err("malloc failed");
697 1.62 he goto out2;
698 1.62 he }
699 1.62 he if ((inbufp = malloc(BUFLEN)) == NULL) {
700 1.62 he maybe_err("malloc failed");
701 1.62 he goto out1;
702 1.62 he }
703 1.62 he
704 1.37 mrg memset(&z, 0, sizeof z);
705 1.37 mrg z.avail_in = prelen;
706 1.37 mrg z.next_in = pre;
707 1.62 he z.avail_out = BUFLEN;
708 1.62 he z.next_out = outbufp;
709 1.37 mrg z.zalloc = NULL;
710 1.37 mrg z.zfree = NULL;
711 1.37 mrg z.opaque = 0;
712 1.37 mrg
713 1.37 mrg in_tot = prelen;
714 1.37 mrg out_tot = 0;
715 1.1 mrg
716 1.37 mrg for (;;) {
717 1.71 yamt if ((z.avail_in == 0 || needmore) && done_reading == 0) {
718 1.71 yamt size_t in_size;
719 1.71 yamt
720 1.71 yamt if (z.avail_in > 0) {
721 1.71 yamt memmove(inbufp, z.next_in, z.avail_in);
722 1.71 yamt }
723 1.71 yamt z.next_in = inbufp;
724 1.71 yamt in_size = read(in, z.next_in + z.avail_in,
725 1.71 yamt BUFLEN - z.avail_in);
726 1.1 mrg
727 1.37 mrg if (in_size == -1) {
728 1.26 mrg #ifndef SMALL
729 1.46 mrg if (tflag && vflag)
730 1.46 mrg print_test(filename, 0);
731 1.37 mrg #endif
732 1.51 mrg maybe_warn("failed to read stdin");
733 1.46 mrg out_tot = -1;
734 1.46 mrg goto stop;
735 1.71 yamt } else if (in_size == 0) {
736 1.37 mrg done_reading = 1;
737 1.71 yamt }
738 1.37 mrg
739 1.71 yamt z.avail_in += in_size;
740 1.71 yamt needmore = 0;
741 1.37 mrg
742 1.37 mrg in_tot += in_size;
743 1.37 mrg }
744 1.54 mrg if (z.avail_in == 0) {
745 1.55 mrg if (done_reading && state != GZSTATE_MAGIC0)
746 1.55 mrg maybe_warnx("%s: unexpected end of file",
747 1.55 mrg filename);
748 1.54 mrg goto stop;
749 1.54 mrg }
750 1.37 mrg switch (state) {
751 1.37 mrg case GZSTATE_MAGIC0:
752 1.46 mrg if (*z.next_in != GZIP_MAGIC0) {
753 1.55 mrg maybe_warnx("input not gziped (MAGIC0)");
754 1.46 mrg out_tot = -1;
755 1.46 mrg goto stop;
756 1.46 mrg }
757 1.37 mrg ADVANCE();
758 1.37 mrg state++;
759 1.54 mrg out_sub_tot = 0;
760 1.54 mrg crc = crc32(0L, Z_NULL, 0);
761 1.37 mrg break;
762 1.37 mrg
763 1.37 mrg case GZSTATE_MAGIC1:
764 1.37 mrg if (*z.next_in != GZIP_MAGIC1 &&
765 1.46 mrg *z.next_in != GZIP_OMAGIC1) {
766 1.55 mrg maybe_warnx("input not gziped (MAGIC1)");
767 1.46 mrg out_tot = -1;
768 1.46 mrg goto stop;
769 1.46 mrg }
770 1.37 mrg ADVANCE();
771 1.37 mrg state++;
772 1.37 mrg break;
773 1.37 mrg
774 1.37 mrg case GZSTATE_METHOD:
775 1.46 mrg if (*z.next_in != Z_DEFLATED) {
776 1.51 mrg maybe_warnx("unknown compression method");
777 1.46 mrg out_tot = -1;
778 1.46 mrg goto stop;
779 1.46 mrg }
780 1.37 mrg ADVANCE();
781 1.37 mrg state++;
782 1.37 mrg break;
783 1.37 mrg
784 1.37 mrg case GZSTATE_FLAGS:
785 1.37 mrg flags = *z.next_in;
786 1.37 mrg ADVANCE();
787 1.37 mrg skip_count = 6;
788 1.37 mrg state++;
789 1.37 mrg break;
790 1.37 mrg
791 1.37 mrg case GZSTATE_SKIPPING:
792 1.37 mrg if (skip_count > 0) {
793 1.37 mrg skip_count--;
794 1.37 mrg ADVANCE();
795 1.37 mrg } else
796 1.37 mrg state++;
797 1.37 mrg break;
798 1.37 mrg
799 1.37 mrg case GZSTATE_EXTRA:
800 1.37 mrg if ((flags & EXTRA_FIELD) == 0) {
801 1.37 mrg state = GZSTATE_ORIGNAME;
802 1.37 mrg break;
803 1.37 mrg }
804 1.37 mrg skip_count = *z.next_in;
805 1.37 mrg ADVANCE();
806 1.37 mrg state++;
807 1.37 mrg break;
808 1.37 mrg
809 1.37 mrg case GZSTATE_EXTRA2:
810 1.37 mrg skip_count |= ((*z.next_in) << 8);
811 1.37 mrg ADVANCE();
812 1.37 mrg state++;
813 1.37 mrg break;
814 1.37 mrg
815 1.37 mrg case GZSTATE_EXTRA3:
816 1.37 mrg if (skip_count > 0) {
817 1.37 mrg skip_count--;
818 1.37 mrg ADVANCE();
819 1.1 mrg } else
820 1.37 mrg state++;
821 1.37 mrg break;
822 1.37 mrg
823 1.37 mrg case GZSTATE_ORIGNAME:
824 1.37 mrg if ((flags & ORIG_NAME) == 0) {
825 1.37 mrg state++;
826 1.37 mrg break;
827 1.37 mrg }
828 1.37 mrg if (*z.next_in == 0)
829 1.37 mrg state++;
830 1.37 mrg ADVANCE();
831 1.37 mrg break;
832 1.37 mrg
833 1.37 mrg case GZSTATE_COMMENT:
834 1.37 mrg if ((flags & COMMENT) == 0) {
835 1.37 mrg state++;
836 1.37 mrg break;
837 1.37 mrg }
838 1.37 mrg if (*z.next_in == 0)
839 1.37 mrg state++;
840 1.37 mrg ADVANCE();
841 1.37 mrg break;
842 1.37 mrg
843 1.37 mrg case GZSTATE_HEAD_CRC1:
844 1.37 mrg if (flags & HEAD_CRC)
845 1.37 mrg skip_count = 2;
846 1.37 mrg else
847 1.37 mrg skip_count = 0;
848 1.37 mrg state++;
849 1.37 mrg break;
850 1.37 mrg
851 1.37 mrg case GZSTATE_HEAD_CRC2:
852 1.37 mrg if (skip_count > 0) {
853 1.37 mrg skip_count--;
854 1.37 mrg ADVANCE();
855 1.37 mrg } else
856 1.37 mrg state++;
857 1.37 mrg break;
858 1.37 mrg
859 1.37 mrg case GZSTATE_INIT:
860 1.37 mrg if (inflateInit2(&z, -MAX_WBITS) != Z_OK) {
861 1.51 mrg maybe_warnx("failed to inflateInit");
862 1.46 mrg out_tot = -1;
863 1.37 mrg goto stop;
864 1.37 mrg }
865 1.37 mrg state++;
866 1.37 mrg break;
867 1.37 mrg
868 1.37 mrg case GZSTATE_READ:
869 1.37 mrg error = inflate(&z, Z_FINISH);
870 1.50 mrg /* Z_BUF_ERROR goes with Z_FINISH... */
871 1.68 dsl if (error != Z_STREAM_END && error != Z_BUF_ERROR)
872 1.68 dsl /* Just need more input */
873 1.68 dsl break;
874 1.68 dsl wr = BUFLEN - z.avail_out;
875 1.50 mrg
876 1.68 dsl if (wr != 0) {
877 1.62 he crc = crc32(crc, (const Bytef *)outbufp, (unsigned)wr);
878 1.37 mrg if (
879 1.37 mrg #ifndef SMALL
880 1.37 mrg /* don't write anything with -t */
881 1.37 mrg tflag == 0 &&
882 1.37 mrg #endif
883 1.62 he write(out, outbufp, wr) != wr) {
884 1.52 yamt maybe_warn("error writing to output");
885 1.46 mrg out_tot = -1;
886 1.46 mrg goto stop;
887 1.46 mrg }
888 1.39 mrg
889 1.39 mrg out_tot += wr;
890 1.54 mrg out_sub_tot += wr;
891 1.68 dsl }
892 1.37 mrg
893 1.68 dsl if (error == Z_STREAM_END) {
894 1.68 dsl inflateEnd(&z);
895 1.68 dsl state++;
896 1.68 dsl }
897 1.39 mrg
898 1.68 dsl z.next_out = outbufp;
899 1.68 dsl z.avail_out = BUFLEN;
900 1.37 mrg
901 1.68 dsl break;
902 1.55 mrg case GZSTATE_CRC:
903 1.55 mrg {
904 1.55 mrg uLong origcrc;
905 1.55 mrg
906 1.55 mrg if (z.avail_in < 4) {
907 1.71 yamt if (!done_reading) {
908 1.71 yamt needmore = 1;
909 1.55 mrg continue;
910 1.71 yamt }
911 1.55 mrg maybe_warnx("truncated input");
912 1.57 mrg out_tot = -1;
913 1.55 mrg goto stop;
914 1.55 mrg }
915 1.57 mrg origcrc = ((unsigned)z.next_in[0] & 0xff) |
916 1.57 mrg ((unsigned)z.next_in[1] & 0xff) << 8 |
917 1.57 mrg ((unsigned)z.next_in[2] & 0xff) << 16 |
918 1.57 mrg ((unsigned)z.next_in[3] & 0xff) << 24;
919 1.57 mrg if (origcrc != crc) {
920 1.55 mrg maybe_warnx("invalid compressed"
921 1.55 mrg " data--crc error");
922 1.57 mrg out_tot = -1;
923 1.57 mrg goto stop;
924 1.57 mrg }
925 1.55 mrg }
926 1.55 mrg
927 1.55 mrg z.avail_in -= 4;
928 1.55 mrg z.next_in += 4;
929 1.55 mrg
930 1.71 yamt if (!z.avail_in && done_reading) {
931 1.55 mrg goto stop;
932 1.71 yamt }
933 1.55 mrg state++;
934 1.55 mrg break;
935 1.55 mrg case GZSTATE_LEN:
936 1.55 mrg {
937 1.55 mrg uLong origlen;
938 1.55 mrg
939 1.55 mrg if (z.avail_in < 4) {
940 1.71 yamt if (!done_reading) {
941 1.71 yamt needmore = 1;
942 1.55 mrg continue;
943 1.71 yamt }
944 1.55 mrg maybe_warnx("truncated input");
945 1.57 mrg out_tot = -1;
946 1.55 mrg goto stop;
947 1.55 mrg }
948 1.57 mrg origlen = ((unsigned)z.next_in[0] & 0xff) |
949 1.57 mrg ((unsigned)z.next_in[1] & 0xff) << 8 |
950 1.57 mrg ((unsigned)z.next_in[2] & 0xff) << 16 |
951 1.57 mrg ((unsigned)z.next_in[3] & 0xff) << 24;
952 1.55 mrg
953 1.57 mrg if (origlen != out_sub_tot) {
954 1.55 mrg maybe_warnx("invalid compressed"
955 1.55 mrg " data--length error");
956 1.57 mrg out_tot = -1;
957 1.57 mrg goto stop;
958 1.57 mrg }
959 1.55 mrg }
960 1.55 mrg
961 1.55 mrg z.avail_in -= 4;
962 1.55 mrg z.next_in += 4;
963 1.55 mrg
964 1.37 mrg if (error < 0) {
965 1.51 mrg maybe_warnx("decompression error");
966 1.37 mrg out_tot = -1;
967 1.37 mrg goto stop;
968 1.37 mrg }
969 1.55 mrg state = GZSTATE_MAGIC0;
970 1.1 mrg break;
971 1.1 mrg }
972 1.37 mrg continue;
973 1.37 mrg stop:
974 1.37 mrg break;
975 1.37 mrg }
976 1.37 mrg if (state > GZSTATE_INIT)
977 1.37 mrg inflateEnd(&z);
978 1.1 mrg
979 1.26 mrg #ifndef SMALL
980 1.46 mrg if (tflag && vflag)
981 1.46 mrg print_test(filename, out_tot != -1);
982 1.26 mrg #endif
983 1.1 mrg
984 1.62 he free(inbufp);
985 1.62 he out1:
986 1.62 he free(outbufp);
987 1.62 he out2:
988 1.37 mrg if (gsizep)
989 1.37 mrg *gsizep = in_tot;
990 1.37 mrg return (out_tot);
991 1.1 mrg }
992 1.1 mrg
993 1.29 mrg #ifndef SMALL
994 1.1 mrg /*
995 1.1 mrg * set the owner, mode, flags & utimes for a file
996 1.1 mrg */
997 1.1 mrg static void
998 1.1 mrg copymodes(const char *file, struct stat *sbp)
999 1.1 mrg {
1000 1.1 mrg struct timeval times[2];
1001 1.1 mrg
1002 1.1 mrg /*
1003 1.1 mrg * If we have no info on the input, give this file some
1004 1.1 mrg * default values and return..
1005 1.1 mrg */
1006 1.1 mrg if (sbp == NULL) {
1007 1.1 mrg mode_t mask = umask(022);
1008 1.1 mrg
1009 1.1 mrg (void)chmod(file, DEFFILEMODE & ~mask);
1010 1.1 mrg (void)umask(mask);
1011 1.1 mrg return;
1012 1.1 mrg }
1013 1.1 mrg
1014 1.1 mrg /* if the chown fails, remove set-id bits as-per compress(1) */
1015 1.1 mrg if (chown(file, sbp->st_uid, sbp->st_gid) < 0) {
1016 1.1 mrg if (errno != EPERM)
1017 1.1 mrg maybe_warn("couldn't chown: %s", file);
1018 1.1 mrg sbp->st_mode &= ~(S_ISUID|S_ISGID);
1019 1.1 mrg }
1020 1.1 mrg
1021 1.1 mrg /* we only allow set-id and the 9 normal permission bits */
1022 1.63 dsl sbp->st_mode &= S_ISUID | S_ISGID | S_IRWXU | S_IRWXG | S_IRWXO;
1023 1.1 mrg if (chmod(file, sbp->st_mode) < 0)
1024 1.1 mrg maybe_warn("couldn't chmod: %s", file);
1025 1.1 mrg
1026 1.1 mrg /* only try flags if they exist already */
1027 1.1 mrg if (sbp->st_flags != 0 && chflags(file, sbp->st_flags) < 0)
1028 1.1 mrg maybe_warn("couldn't chflags: %s", file);
1029 1.1 mrg
1030 1.1 mrg TIMESPEC_TO_TIMEVAL(×[0], &sbp->st_atimespec);
1031 1.1 mrg TIMESPEC_TO_TIMEVAL(×[1], &sbp->st_mtimespec);
1032 1.1 mrg if (utimes(file, times) < 0)
1033 1.1 mrg maybe_warn("couldn't utimes: %s", file);
1034 1.1 mrg }
1035 1.29 mrg #endif
1036 1.1 mrg
1037 1.32 mrg /* what sort of file is this? */
1038 1.32 mrg static enum filetype
1039 1.32 mrg file_gettype(u_char *buf)
1040 1.32 mrg {
1041 1.32 mrg
1042 1.32 mrg if (buf[0] == GZIP_MAGIC0 &&
1043 1.32 mrg (buf[1] == GZIP_MAGIC1 || buf[1] == GZIP_OMAGIC1))
1044 1.32 mrg return FT_GZIP;
1045 1.32 mrg else
1046 1.32 mrg #ifndef NO_BZIP2_SUPPORT
1047 1.32 mrg if (memcmp(buf, BZIP2_MAGIC, 3) == 0 &&
1048 1.32 mrg buf[3] >= '0' && buf[3] <= '9')
1049 1.32 mrg return FT_BZIP2;
1050 1.32 mrg else
1051 1.32 mrg #endif
1052 1.32 mrg #ifndef NO_COMPRESS_SUPPORT
1053 1.32 mrg if (memcmp(buf, Z_MAGIC, 2) == 0)
1054 1.32 mrg return FT_Z;
1055 1.32 mrg else
1056 1.32 mrg #endif
1057 1.32 mrg return FT_UNKNOWN;
1058 1.32 mrg }
1059 1.32 mrg
1060 1.46 mrg #ifndef SMALL
1061 1.46 mrg /* check the outfile is OK. */
1062 1.46 mrg static int
1063 1.46 mrg check_outfile(const char *outfile, struct stat *sb)
1064 1.46 mrg {
1065 1.46 mrg int ok = 1;
1066 1.46 mrg
1067 1.59 mrg if (lflag == 0 && stat(outfile, sb) == 0) {
1068 1.59 mrg if (fflag)
1069 1.59 mrg unlink(outfile);
1070 1.59 mrg else if (isatty(STDIN_FILENO)) {
1071 1.46 mrg char ans[10] = { 'n', '\0' }; /* default */
1072 1.46 mrg
1073 1.46 mrg fprintf(stderr, "%s already exists -- do you wish to "
1074 1.46 mrg "overwrite (y or n)? " , outfile);
1075 1.46 mrg (void)fgets(ans, sizeof(ans) - 1, stdin);
1076 1.46 mrg if (ans[0] != 'y' && ans[0] != 'Y') {
1077 1.46 mrg fprintf(stderr, "\tnot overwritting\n");
1078 1.46 mrg ok = 0;
1079 1.46 mrg } else
1080 1.46 mrg unlink(outfile);
1081 1.46 mrg } else {
1082 1.46 mrg maybe_warnx("%s already exists -- skipping", outfile);
1083 1.46 mrg ok = 0;
1084 1.46 mrg }
1085 1.46 mrg }
1086 1.46 mrg return ok;
1087 1.46 mrg }
1088 1.56 mrg
1089 1.63 dsl static void
1090 1.63 dsl unlink_input(const char *file, struct stat *sb)
1091 1.56 mrg {
1092 1.63 dsl struct stat nsb;
1093 1.63 dsl
1094 1.63 dsl if (stat(file, &nsb) != 0)
1095 1.63 dsl /* Must be gone alrady */
1096 1.63 dsl return;
1097 1.63 dsl if (nsb.st_dev != sb->st_dev || nsb.st_ino != sb->st_ino)
1098 1.63 dsl /* Definitely a different file */
1099 1.63 dsl return;
1100 1.63 dsl unlink(file);
1101 1.63 dsl }
1102 1.63 dsl #endif
1103 1.56 mrg
1104 1.63 dsl static const suffixes_t *
1105 1.63 dsl check_suffix(char *file, int xlate)
1106 1.63 dsl {
1107 1.63 dsl const suffixes_t *s;
1108 1.63 dsl int len = strlen(file);
1109 1.63 dsl char *sp;
1110 1.63 dsl
1111 1.63 dsl for (s = suffixes; s != suffixes + NUM_SUFFIXES; s++) {
1112 1.57 mrg /* if it doesn't fit in "a.suf", don't bother */
1113 1.63 dsl if (s->ziplen >= len)
1114 1.63 dsl continue;
1115 1.63 dsl sp = file + len - s->ziplen;
1116 1.63 dsl if (strcmp(s->zipped, sp) != 0)
1117 1.57 mrg continue;
1118 1.63 dsl if (xlate)
1119 1.63 dsl strcpy(sp, s->normal);
1120 1.63 dsl return s;
1121 1.56 mrg }
1122 1.56 mrg return NULL;
1123 1.56 mrg }
1124 1.46 mrg
1125 1.1 mrg /*
1126 1.1 mrg * compress the given file: create a corresponding .gz file and remove the
1127 1.1 mrg * original.
1128 1.1 mrg */
1129 1.31 mrg static off_t
1130 1.45 agc file_compress(char *file, char *outfile, size_t outsize)
1131 1.1 mrg {
1132 1.63 dsl int in;
1133 1.37 mrg int out;
1134 1.63 dsl off_t size, insize;
1135 1.63 dsl #ifndef SMALL
1136 1.1 mrg struct stat isb, osb;
1137 1.63 dsl const suffixes_t *suff;
1138 1.25 mrg #endif
1139 1.1 mrg
1140 1.63 dsl in = open(file, O_RDONLY);
1141 1.63 dsl if (in == -1) {
1142 1.63 dsl maybe_warn("can't open %s", file);
1143 1.63 dsl return -1;
1144 1.63 dsl }
1145 1.63 dsl
1146 1.1 mrg if (cflag == 0) {
1147 1.56 mrg #ifndef SMALL
1148 1.63 dsl if (stat(file, &isb) == 0) {
1149 1.63 dsl if (isb.st_nlink > 1 && fflag == 0) {
1150 1.63 dsl maybe_warnx("%s has %d other link%s -- "
1151 1.63 dsl "skipping", file, isb.st_nlink - 1,
1152 1.63 dsl isb.st_nlink == 1 ? "" : "s");
1153 1.63 dsl close(in);
1154 1.63 dsl return -1;
1155 1.63 dsl }
1156 1.63 dsl }
1157 1.56 mrg
1158 1.63 dsl if (fflag == 0 && (suff = check_suffix(file, 0))
1159 1.63 dsl && suff->zipped[0] != 0) {
1160 1.56 mrg maybe_warnx("%s already has %s suffix -- unchanged",
1161 1.63 dsl file, suff->zipped);
1162 1.63 dsl close(in);
1163 1.63 dsl return -1;
1164 1.56 mrg }
1165 1.56 mrg #endif
1166 1.56 mrg
1167 1.63 dsl /* Add (usually) .gz to filename */
1168 1.63 dsl if (snprintf(outfile, outsize, "%s%s",
1169 1.63 dsl file, suffixes[0].zipped) >= outsize)
1170 1.63 dsl memcpy(outfile - suffixes[0].ziplen - 1,
1171 1.63 dsl suffixes[0].zipped, suffixes[0].ziplen + 1);
1172 1.1 mrg
1173 1.25 mrg #ifndef SMALL
1174 1.63 dsl if (check_outfile(outfile, &osb) == 0) {
1175 1.63 dsl close(in);
1176 1.63 dsl return -1;
1177 1.34 mrg }
1178 1.25 mrg #endif
1179 1.1 mrg }
1180 1.1 mrg
1181 1.43 bouyer if (cflag == 0) {
1182 1.63 dsl out = open(outfile, O_WRONLY | O_CREAT | O_EXCL, 0600);
1183 1.39 mrg if (out == -1) {
1184 1.39 mrg maybe_warn("could not create output: %s", outfile);
1185 1.63 dsl fclose(stdin);
1186 1.63 dsl return -1;
1187 1.39 mrg }
1188 1.1 mrg } else
1189 1.37 mrg out = STDOUT_FILENO;
1190 1.1 mrg
1191 1.63 dsl insize = gz_compress(in, out, &size, basename(file), (uint32_t)isb.st_mtime);
1192 1.1 mrg
1193 1.63 dsl (void)close(in);
1194 1.42 mrg
1195 1.1 mrg /*
1196 1.63 dsl * If there was an error, insize will be -1.
1197 1.63 dsl * If we compressed to stdout, just return the size.
1198 1.63 dsl * Otherwise stat the file and check it is the correct size.
1199 1.63 dsl * We only blow away the file if we can stat the output and it
1200 1.63 dsl * has the expected size.
1201 1.1 mrg */
1202 1.63 dsl if (cflag != 0)
1203 1.63 dsl return insize == -1 ? -1 : size;
1204 1.63 dsl
1205 1.63 dsl if (close(out) == -1)
1206 1.63 dsl maybe_warn("couldn't close ouput");
1207 1.39 mrg
1208 1.29 mrg #ifndef SMALL
1209 1.63 dsl if (stat(outfile, &osb) < 0) {
1210 1.63 dsl maybe_warn("couldn't stat: %s", outfile);
1211 1.63 dsl goto bad_outfile;
1212 1.63 dsl }
1213 1.63 dsl
1214 1.63 dsl if (osb.st_size != size) {
1215 1.63 dsl maybe_warnx("output file: %s wrong size (%" PRIdOFF
1216 1.63 dsl " != %" PRIdOFF "), deleting",
1217 1.63 dsl outfile, osb.st_size, size);
1218 1.63 dsl goto bad_outfile;
1219 1.63 dsl }
1220 1.63 dsl
1221 1.63 dsl copymodes(outfile, &isb);
1222 1.29 mrg #endif
1223 1.1 mrg
1224 1.63 dsl /* output is good, ok to delete input */
1225 1.63 dsl unlink_input(file, &isb);
1226 1.63 dsl return size;
1227 1.63 dsl
1228 1.63 dsl #ifndef SMALL
1229 1.63 dsl bad_outfile:
1230 1.63 dsl maybe_warnx("leaving original %s", file);
1231 1.63 dsl unlink(outfile);
1232 1.63 dsl return size;
1233 1.63 dsl #endif
1234 1.1 mrg }
1235 1.1 mrg
1236 1.1 mrg /* uncompress the given file and remove the original */
1237 1.31 mrg static off_t
1238 1.45 agc file_uncompress(char *file, char *outfile, size_t outsize)
1239 1.1 mrg {
1240 1.1 mrg struct stat isb, osb;
1241 1.1 mrg off_t size;
1242 1.63 dsl ssize_t rbytes;
1243 1.66 dsl unsigned char header1[4];
1244 1.10 mrg enum filetype method;
1245 1.63 dsl int fd, zfd = -1;
1246 1.48 mrg #ifndef SMALL
1247 1.48 mrg time_t timestamp = 0;
1248 1.66 dsl unsigned char name[PATH_MAX + 1];
1249 1.48 mrg #endif
1250 1.9 mrg
1251 1.9 mrg /* gather the old name info */
1252 1.1 mrg
1253 1.9 mrg fd = open(file, O_RDONLY);
1254 1.46 mrg if (fd < 0) {
1255 1.46 mrg maybe_warn("can't open %s", file);
1256 1.46 mrg goto lose;
1257 1.46 mrg }
1258 1.63 dsl
1259 1.63 dsl strlcpy(outfile, file, outsize);
1260 1.63 dsl if (check_suffix(outfile, 1) == NULL && !(cflag || lflag)) {
1261 1.63 dsl maybe_warnx("%s: unknown suffix -- ignored", file);
1262 1.63 dsl goto lose;
1263 1.63 dsl }
1264 1.63 dsl
1265 1.57 mrg rbytes = read(fd, header1, sizeof header1);
1266 1.57 mrg if (rbytes != sizeof header1) {
1267 1.10 mrg /* we don't want to fail here. */
1268 1.25 mrg #ifndef SMALL
1269 1.10 mrg if (fflag)
1270 1.63 dsl goto lose;
1271 1.25 mrg #endif
1272 1.57 mrg if (rbytes == -1)
1273 1.57 mrg maybe_warn("can't read %s", file);
1274 1.57 mrg else
1275 1.57 mrg maybe_warnx("%s: unexpected end of file", file);
1276 1.63 dsl goto lose;
1277 1.10 mrg }
1278 1.10 mrg
1279 1.32 mrg method = file_gettype(header1);
1280 1.29 mrg
1281 1.32 mrg #ifndef SMALL
1282 1.42 mrg if (fflag == 0 && method == FT_UNKNOWN) {
1283 1.42 mrg maybe_warnx("%s: not in gzip format", file);
1284 1.63 dsl goto lose;
1285 1.42 mrg }
1286 1.63 dsl
1287 1.25 mrg #endif
1288 1.9 mrg
1289 1.48 mrg #ifndef SMALL
1290 1.63 dsl if (method == FT_GZIP && Nflag) {
1291 1.63 dsl unsigned char ts[4]; /* timestamp */
1292 1.48 mrg
1293 1.63 dsl if (pread(fd, ts, sizeof ts, GZIP_TIMESTAMP) != sizeof ts) {
1294 1.63 dsl if (!fflag)
1295 1.63 dsl maybe_warn("can't read %s", file);
1296 1.63 dsl goto lose;
1297 1.63 dsl }
1298 1.63 dsl timestamp = ts[3] << 24 | ts[2] << 16 | ts[1] << 8 | ts[0];
1299 1.48 mrg
1300 1.9 mrg if (header1[3] & ORIG_NAME) {
1301 1.63 dsl rbytes = pread(fd, name, sizeof name, GZIP_ORIGNAME);
1302 1.42 mrg if (rbytes < 0) {
1303 1.42 mrg maybe_warn("can't read %s", file);
1304 1.63 dsl goto lose;
1305 1.42 mrg }
1306 1.63 dsl if (name[0] != 0) {
1307 1.63 dsl /* preserve original directory name */
1308 1.63 dsl char *dp = strrchr(file, '/');
1309 1.63 dsl if (dp == NULL)
1310 1.63 dsl dp = file;
1311 1.63 dsl else
1312 1.63 dsl dp++;
1313 1.63 dsl snprintf(outfile, outsize, "%.*s%.*s",
1314 1.64 he (int) (dp - file),
1315 1.64 he file, (int) rbytes, name);
1316 1.1 mrg }
1317 1.1 mrg }
1318 1.9 mrg }
1319 1.63 dsl #endif
1320 1.63 dsl lseek(fd, 0, SEEK_SET);
1321 1.1 mrg
1322 1.31 mrg if (cflag == 0 || lflag) {
1323 1.63 dsl if (fstat(fd, &isb) != 0)
1324 1.63 dsl goto lose;
1325 1.25 mrg #ifndef SMALL
1326 1.63 dsl if (isb.st_nlink > 1 && lflag == 0 && fflag == 0) {
1327 1.63 dsl maybe_warnx("%s has %d other links -- skipping",
1328 1.63 dsl file, isb.st_nlink - 1);
1329 1.9 mrg goto lose;
1330 1.63 dsl }
1331 1.63 dsl if (nflag == 0 && timestamp)
1332 1.63 dsl isb.st_mtime = timestamp;
1333 1.63 dsl if (check_outfile(outfile, &osb) == 0)
1334 1.63 dsl goto lose;
1335 1.31 mrg #endif
1336 1.1 mrg }
1337 1.5 mrg
1338 1.48 mrg if (cflag == 0 && lflag == 0) {
1339 1.46 mrg zfd = open(outfile, O_WRONLY|O_CREAT|O_EXCL, 0600);
1340 1.63 dsl if (zfd == STDOUT_FILENO) {
1341 1.63 dsl /* We won't close STDOUT_FILENO later... */
1342 1.63 dsl zfd = dup(zfd);
1343 1.63 dsl close(STDOUT_FILENO);
1344 1.63 dsl }
1345 1.46 mrg if (zfd == -1) {
1346 1.46 mrg maybe_warn("can't open %s", outfile);
1347 1.46 mrg goto lose;
1348 1.46 mrg }
1349 1.46 mrg } else
1350 1.46 mrg zfd = STDOUT_FILENO;
1351 1.46 mrg
1352 1.24 tsutsui #ifndef NO_BZIP2_SUPPORT
1353 1.10 mrg if (method == FT_BZIP2) {
1354 1.5 mrg
1355 1.30 mrg /* XXX */
1356 1.46 mrg if (lflag) {
1357 1.46 mrg maybe_warnx("no -l with bzip2 files");
1358 1.46 mrg goto lose;
1359 1.46 mrg }
1360 1.26 mrg
1361 1.63 dsl size = unbzip2(fd, zfd, NULL, 0, NULL);
1362 1.24 tsutsui } else
1363 1.24 tsutsui #endif
1364 1.29 mrg
1365 1.24 tsutsui #ifndef NO_COMPRESS_SUPPORT
1366 1.24 tsutsui if (method == FT_Z) {
1367 1.22 mrg FILE *in, *out;
1368 1.22 mrg
1369 1.30 mrg /* XXX */
1370 1.46 mrg if (lflag) {
1371 1.46 mrg maybe_warnx("no -l with Lempel-Ziv files");
1372 1.46 mrg goto lose;
1373 1.46 mrg }
1374 1.26 mrg
1375 1.63 dsl if ((in = zdopen(fd)) == NULL) {
1376 1.63 dsl maybe_warn("zdopen for read: %s", file);
1377 1.46 mrg goto lose;
1378 1.46 mrg }
1379 1.22 mrg
1380 1.63 dsl out = fdopen(dup(zfd), "w");
1381 1.46 mrg if (out == NULL) {
1382 1.63 dsl maybe_warn("fdopen for write: %s", outfile);
1383 1.63 dsl fclose(in);
1384 1.46 mrg goto lose;
1385 1.22 mrg }
1386 1.22 mrg
1387 1.37 mrg size = zuncompress(in, out, NULL, 0, NULL);
1388 1.66 dsl /* need to fclose() if ferror() is true... */
1389 1.66 dsl if (ferror(in) | fclose(in)) {
1390 1.66 dsl maybe_warn("failed infile fclose");
1391 1.42 mrg unlink(outfile);
1392 1.46 mrg (void)fclose(out);
1393 1.42 mrg }
1394 1.63 dsl if (fclose(out) != 0) {
1395 1.66 dsl maybe_warn("failed outfile fclose");
1396 1.63 dsl unlink(outfile);
1397 1.63 dsl goto lose;
1398 1.22 mrg }
1399 1.24 tsutsui } else
1400 1.24 tsutsui #endif
1401 1.51 mrg
1402 1.51 mrg #ifndef SMALL
1403 1.51 mrg if (method == FT_UNKNOWN) {
1404 1.63 dsl if (lflag) {
1405 1.63 dsl maybe_warnx("no -l for unknown filetypes");
1406 1.51 mrg goto lose;
1407 1.51 mrg }
1408 1.63 dsl size = cat_fd(NULL, 0, NULL, fd);
1409 1.51 mrg } else
1410 1.51 mrg #endif
1411 1.24 tsutsui {
1412 1.10 mrg if (lflag) {
1413 1.63 dsl print_list(fd, isb.st_size, outfile, isb.st_mtime);
1414 1.63 dsl close(fd);
1415 1.61 yamt return -1; /* XXX */
1416 1.10 mrg }
1417 1.10 mrg
1418 1.63 dsl size = gz_uncompress(fd, zfd, NULL, 0, NULL, file);
1419 1.63 dsl }
1420 1.63 dsl
1421 1.63 dsl if (close(fd) != 0)
1422 1.63 dsl maybe_warn("couldn't close input");
1423 1.63 dsl if (zfd != STDOUT_FILENO && close(zfd) != 0)
1424 1.63 dsl maybe_warn("couldn't close output");
1425 1.1 mrg
1426 1.63 dsl if (size == -1) {
1427 1.63 dsl if (cflag == 0)
1428 1.63 dsl unlink(outfile);
1429 1.63 dsl maybe_warnx("%s: uncompress failed", file);
1430 1.63 dsl return -1;
1431 1.10 mrg }
1432 1.1 mrg
1433 1.1 mrg /* if testing, or we uncompressed to stdout, this is all we need */
1434 1.26 mrg #ifndef SMALL
1435 1.26 mrg if (tflag)
1436 1.63 dsl return size;
1437 1.26 mrg #endif
1438 1.67 dsl /* if we are uncompressing to stdin, don't remove the file. */
1439 1.26 mrg if (cflag)
1440 1.63 dsl return size;
1441 1.1 mrg
1442 1.1 mrg /*
1443 1.1 mrg * if we create a file...
1444 1.1 mrg */
1445 1.63 dsl /*
1446 1.67 dsl * if we can't stat the file don't remove the file.
1447 1.63 dsl */
1448 1.63 dsl if (stat(outfile, &osb) < 0) {
1449 1.63 dsl maybe_warn("couldn't stat (leaving original): %s",
1450 1.63 dsl outfile);
1451 1.63 dsl return -1;
1452 1.63 dsl }
1453 1.63 dsl if (osb.st_size != size) {
1454 1.63 dsl maybe_warn("stat gave different size: %" PRIdOFF
1455 1.63 dsl " != %" PRIdOFF " (leaving original)",
1456 1.63 dsl size, osb.st_size);
1457 1.63 dsl unlink(outfile);
1458 1.63 dsl return -1;
1459 1.63 dsl }
1460 1.63 dsl unlink_input(file, &isb);
1461 1.29 mrg #ifndef SMALL
1462 1.63 dsl copymodes(outfile, &isb);
1463 1.29 mrg #endif
1464 1.63 dsl return size;
1465 1.1 mrg
1466 1.63 dsl lose:
1467 1.63 dsl if (fd != -1)
1468 1.63 dsl close(fd);
1469 1.63 dsl if (zfd != -1 && zfd != STDOUT_FILENO)
1470 1.63 dsl close(fd);
1471 1.46 mrg return -1;
1472 1.1 mrg }
1473 1.1 mrg
1474 1.37 mrg #ifndef SMALL
1475 1.37 mrg static off_t
1476 1.51 mrg cat_fd(unsigned char * prepend, size_t count, off_t *gsizep, int fd)
1477 1.37 mrg {
1478 1.37 mrg char buf[BUFLEN];
1479 1.37 mrg size_t rv;
1480 1.37 mrg off_t in_tot;
1481 1.37 mrg
1482 1.37 mrg in_tot = count;
1483 1.46 mrg if (write(STDOUT_FILENO, prepend, count) != count) {
1484 1.46 mrg maybe_warn("write to stdout");
1485 1.46 mrg return -1;
1486 1.46 mrg }
1487 1.37 mrg for (;;) {
1488 1.51 mrg rv = read(fd, buf, sizeof buf);
1489 1.51 mrg if (rv == 0)
1490 1.51 mrg break;
1491 1.51 mrg if (rv < 0) {
1492 1.51 mrg maybe_warn("read from fd %d", fd);
1493 1.51 mrg break;
1494 1.51 mrg }
1495 1.37 mrg
1496 1.46 mrg if (write(STDOUT_FILENO, buf, rv) != rv) {
1497 1.46 mrg maybe_warn("write to stdout");
1498 1.51 mrg break;
1499 1.46 mrg }
1500 1.37 mrg in_tot += rv;
1501 1.37 mrg }
1502 1.37 mrg
1503 1.37 mrg if (gsizep)
1504 1.37 mrg *gsizep = in_tot;
1505 1.37 mrg return (in_tot);
1506 1.37 mrg }
1507 1.37 mrg #endif
1508 1.37 mrg
1509 1.1 mrg static void
1510 1.1 mrg handle_stdin(void)
1511 1.1 mrg {
1512 1.37 mrg unsigned char header1[4];
1513 1.37 mrg off_t usize, gsize;
1514 1.37 mrg enum filetype method;
1515 1.71 yamt ssize_t bytes_read;
1516 1.37 mrg #ifndef NO_COMPRESS_SUPPORT
1517 1.37 mrg FILE *in;
1518 1.37 mrg #endif
1519 1.1 mrg
1520 1.25 mrg #ifndef SMALL
1521 1.5 mrg if (fflag == 0 && lflag == 0 && isatty(STDIN_FILENO)) {
1522 1.1 mrg maybe_warnx("standard input is a terminal -- ignoring");
1523 1.1 mrg return;
1524 1.1 mrg }
1525 1.25 mrg #endif
1526 1.5 mrg
1527 1.5 mrg if (lflag) {
1528 1.5 mrg struct stat isb;
1529 1.5 mrg
1530 1.37 mrg /* XXX could read the whole file, etc. */
1531 1.46 mrg if (fstat(STDIN_FILENO, &isb) < 0) {
1532 1.46 mrg maybe_warn("fstat");
1533 1.46 mrg return;
1534 1.46 mrg }
1535 1.7 mrg print_list(STDIN_FILENO, isb.st_size, "stdout", isb.st_mtime);
1536 1.5 mrg return;
1537 1.5 mrg }
1538 1.5 mrg
1539 1.71 yamt bytes_read = read_retry(STDIN_FILENO, header1, sizeof header1);
1540 1.71 yamt if (bytes_read == -1) {
1541 1.46 mrg maybe_warn("can't read stdin");
1542 1.46 mrg return;
1543 1.71 yamt } else if (bytes_read != sizeof(header1)) {
1544 1.71 yamt maybe_warnx("unexpected EOF");
1545 1.71 yamt return;
1546 1.46 mrg }
1547 1.37 mrg
1548 1.37 mrg method = file_gettype(header1);
1549 1.37 mrg switch (method) {
1550 1.37 mrg default:
1551 1.37 mrg #ifndef SMALL
1552 1.46 mrg if (fflag == 0) {
1553 1.46 mrg maybe_warnx("unknown compression format");
1554 1.46 mrg return;
1555 1.46 mrg }
1556 1.51 mrg usize = cat_fd(header1, sizeof header1, &gsize, STDIN_FILENO);
1557 1.37 mrg break;
1558 1.37 mrg #endif
1559 1.37 mrg case FT_GZIP:
1560 1.37 mrg usize = gz_uncompress(STDIN_FILENO, STDOUT_FILENO,
1561 1.46 mrg header1, sizeof header1, &gsize, "(stdin)");
1562 1.37 mrg break;
1563 1.37 mrg #ifndef NO_BZIP2_SUPPORT
1564 1.37 mrg case FT_BZIP2:
1565 1.37 mrg usize = unbzip2(STDIN_FILENO, STDOUT_FILENO,
1566 1.37 mrg header1, sizeof header1, &gsize);
1567 1.37 mrg break;
1568 1.37 mrg #endif
1569 1.37 mrg #ifndef NO_COMPRESS_SUPPORT
1570 1.37 mrg case FT_Z:
1571 1.63 dsl if ((in = zdopen(STDIN_FILENO)) == NULL) {
1572 1.46 mrg maybe_warnx("zopen of stdin");
1573 1.46 mrg return;
1574 1.46 mrg }
1575 1.37 mrg
1576 1.37 mrg usize = zuncompress(in, stdout, header1, sizeof header1, &gsize);
1577 1.63 dsl fclose(in);
1578 1.37 mrg break;
1579 1.37 mrg #endif
1580 1.37 mrg }
1581 1.37 mrg
1582 1.37 mrg #ifndef SMALL
1583 1.37 mrg if (vflag && !tflag && usize != -1 && gsize != -1)
1584 1.63 dsl print_verbage(NULL, NULL, usize, gsize);
1585 1.37 mrg #endif
1586 1.37 mrg
1587 1.1 mrg }
1588 1.1 mrg
1589 1.1 mrg static void
1590 1.1 mrg handle_stdout(void)
1591 1.1 mrg {
1592 1.37 mrg off_t gsize, usize;
1593 1.69 jmc struct stat sb;
1594 1.69 jmc time_t systime;
1595 1.69 jmc uint32_t mtime;
1596 1.69 jmc int ret;
1597 1.1 mrg
1598 1.25 mrg #ifndef SMALL
1599 1.1 mrg if (fflag == 0 && isatty(STDOUT_FILENO)) {
1600 1.1 mrg maybe_warnx("standard output is a terminal -- ignoring");
1601 1.1 mrg return;
1602 1.1 mrg }
1603 1.25 mrg #endif
1604 1.69 jmc /* If stdin is a file use it's mtime, otherwise use current time */
1605 1.69 jmc ret = fstat(STDIN_FILENO, &sb);
1606 1.69 jmc
1607 1.69 jmc #ifndef SMALL
1608 1.69 jmc if (ret < 0) {
1609 1.69 jmc maybe_warn("Can't stat stdin");
1610 1.69 jmc return;
1611 1.69 jmc }
1612 1.69 jmc #endif
1613 1.37 mrg
1614 1.69 jmc if (S_ISREG(sb.st_mode))
1615 1.69 jmc mtime = (uint32_t)sb.st_mtime;
1616 1.69 jmc else {
1617 1.69 jmc systime = time(NULL);
1618 1.69 jmc #ifndef SMALL
1619 1.69 jmc if (systime == -1) {
1620 1.69 jmc maybe_warn("time");
1621 1.69 jmc return;
1622 1.69 jmc }
1623 1.69 jmc #endif
1624 1.69 jmc mtime = (uint32_t)systime;
1625 1.69 jmc }
1626 1.69 jmc
1627 1.69 jmc usize = gz_compress(STDIN_FILENO, STDOUT_FILENO, &gsize, "", mtime);
1628 1.37 mrg #ifndef SMALL
1629 1.37 mrg if (vflag && !tflag && usize != -1 && gsize != -1)
1630 1.63 dsl print_verbage(NULL, NULL, usize, gsize);
1631 1.37 mrg #endif
1632 1.1 mrg }
1633 1.1 mrg
1634 1.1 mrg /* do what is asked for, for the path name */
1635 1.1 mrg static void
1636 1.1 mrg handle_pathname(char *path)
1637 1.1 mrg {
1638 1.44 agc char *opath = path, *s = NULL;
1639 1.1 mrg ssize_t len;
1640 1.63 dsl int slen;
1641 1.1 mrg struct stat sb;
1642 1.1 mrg
1643 1.1 mrg /* check for stdout/stdin */
1644 1.1 mrg if (path[0] == '-' && path[1] == '\0') {
1645 1.1 mrg if (dflag)
1646 1.1 mrg handle_stdin();
1647 1.1 mrg else
1648 1.1 mrg handle_stdout();
1649 1.49 mrg return;
1650 1.1 mrg }
1651 1.1 mrg
1652 1.1 mrg retry:
1653 1.1 mrg if (stat(path, &sb) < 0) {
1654 1.1 mrg /* lets try <path>.gz if we're decompressing */
1655 1.44 agc if (dflag && s == NULL && errno == ENOENT) {
1656 1.1 mrg len = strlen(path);
1657 1.63 dsl slen = suffixes[0].ziplen;
1658 1.63 dsl s = malloc(len + slen + 1);
1659 1.44 agc if (s == NULL)
1660 1.46 mrg maybe_err("malloc");
1661 1.63 dsl memcpy(s, path, len);
1662 1.63 dsl memcpy(s + len, suffixes[0].zipped, slen + 1);
1663 1.1 mrg path = s;
1664 1.1 mrg goto retry;
1665 1.1 mrg }
1666 1.1 mrg maybe_warn("can't stat: %s", opath);
1667 1.1 mrg goto out;
1668 1.1 mrg }
1669 1.1 mrg
1670 1.1 mrg if (S_ISDIR(sb.st_mode)) {
1671 1.25 mrg #ifndef SMALL
1672 1.1 mrg if (rflag)
1673 1.1 mrg handle_dir(path, &sb);
1674 1.1 mrg else
1675 1.25 mrg #endif
1676 1.60 yamt maybe_warnx("%s is a directory", path);
1677 1.1 mrg goto out;
1678 1.1 mrg }
1679 1.1 mrg
1680 1.1 mrg if (S_ISREG(sb.st_mode))
1681 1.1 mrg handle_file(path, &sb);
1682 1.63 dsl else
1683 1.63 dsl maybe_warnx("%s is not a regular file", path);
1684 1.1 mrg
1685 1.1 mrg out:
1686 1.1 mrg if (s)
1687 1.1 mrg free(s);
1688 1.1 mrg }
1689 1.1 mrg
1690 1.1 mrg /* compress/decompress a file */
1691 1.1 mrg static void
1692 1.1 mrg handle_file(char *file, struct stat *sbp)
1693 1.1 mrg {
1694 1.31 mrg off_t usize, gsize;
1695 1.45 agc char outfile[PATH_MAX];
1696 1.1 mrg
1697 1.1 mrg infile = file;
1698 1.1 mrg if (dflag) {
1699 1.45 agc usize = file_uncompress(file, outfile, sizeof(outfile));
1700 1.46 mrg if (usize == -1)
1701 1.1 mrg return;
1702 1.1 mrg gsize = sbp->st_size;
1703 1.1 mrg } else {
1704 1.45 agc gsize = file_compress(file, outfile, sizeof(outfile));
1705 1.46 mrg if (gsize == -1)
1706 1.1 mrg return;
1707 1.1 mrg usize = sbp->st_size;
1708 1.1 mrg }
1709 1.1 mrg
1710 1.26 mrg
1711 1.26 mrg #ifndef SMALL
1712 1.1 mrg if (vflag && !tflag)
1713 1.45 agc print_verbage(file, (cflag) ? NULL : outfile, usize, gsize);
1714 1.26 mrg #endif
1715 1.1 mrg }
1716 1.1 mrg
1717 1.25 mrg #ifndef SMALL
1718 1.63 dsl /* this is used with -r to recursively descend directories */
1719 1.1 mrg static void
1720 1.1 mrg handle_dir(char *dir, struct stat *sbp)
1721 1.1 mrg {
1722 1.1 mrg char *path_argv[2];
1723 1.1 mrg FTS *fts;
1724 1.1 mrg FTSENT *entry;
1725 1.1 mrg
1726 1.1 mrg path_argv[0] = dir;
1727 1.1 mrg path_argv[1] = 0;
1728 1.1 mrg fts = fts_open(path_argv, FTS_PHYSICAL, NULL);
1729 1.1 mrg if (fts == NULL) {
1730 1.1 mrg warn("couldn't fts_open %s", dir);
1731 1.1 mrg return;
1732 1.1 mrg }
1733 1.1 mrg
1734 1.1 mrg while ((entry = fts_read(fts))) {
1735 1.1 mrg switch(entry->fts_info) {
1736 1.1 mrg case FTS_D:
1737 1.1 mrg case FTS_DP:
1738 1.1 mrg continue;
1739 1.1 mrg
1740 1.1 mrg case FTS_DNR:
1741 1.1 mrg case FTS_ERR:
1742 1.1 mrg case FTS_NS:
1743 1.1 mrg maybe_warn("%s", entry->fts_path);
1744 1.1 mrg continue;
1745 1.1 mrg case FTS_F:
1746 1.1 mrg handle_file(entry->fts_name, entry->fts_statp);
1747 1.1 mrg }
1748 1.1 mrg }
1749 1.1 mrg (void)fts_close(fts);
1750 1.1 mrg }
1751 1.25 mrg #endif
1752 1.1 mrg
1753 1.66 dsl /* print a ratio - size reduction as a fraction of uncompressed size */
1754 1.6 mrg static void
1755 1.6 mrg print_ratio(off_t in, off_t out, FILE *where)
1756 1.6 mrg {
1757 1.66 dsl int percent10; /* 10 * percent */
1758 1.66 dsl off_t diff;
1759 1.66 dsl char buff[8];
1760 1.66 dsl int len;
1761 1.35 mrg
1762 1.66 dsl diff = in - out/2;
1763 1.66 dsl if (diff <= 0)
1764 1.66 dsl /*
1765 1.66 dsl * Output is more than double size of input! print -99.9%
1766 1.66 dsl * Quite possibly we've failed to get the original size.
1767 1.66 dsl */
1768 1.66 dsl percent10 = -999;
1769 1.66 dsl else {
1770 1.66 dsl /*
1771 1.66 dsl * We only need 12 bits of result from the final division,
1772 1.66 dsl * so reduce the values until a 32bit division will suffice.
1773 1.66 dsl */
1774 1.66 dsl while (in > 0x100000) {
1775 1.66 dsl diff >>= 1;
1776 1.66 dsl in >>= 1;
1777 1.66 dsl }
1778 1.66 dsl if (in != 0)
1779 1.66 dsl percent10 = ((u_int)diff * 2000) / (u_int)in - 1000;
1780 1.66 dsl else
1781 1.66 dsl percent10 = 0;
1782 1.66 dsl }
1783 1.35 mrg
1784 1.66 dsl len = snprintf(buff, sizeof buff, "%2.2d.", percent10);
1785 1.66 dsl /* Move the '.' to before the last digit */
1786 1.66 dsl buff[len - 1] = buff[len - 2];
1787 1.66 dsl buff[len - 2] = '.';
1788 1.66 dsl fprintf(where, "%5s%%", buff);
1789 1.6 mrg }
1790 1.6 mrg
1791 1.26 mrg #ifndef SMALL
1792 1.1 mrg /* print compression statistics, and the new name (if there is one!) */
1793 1.1 mrg static void
1794 1.63 dsl print_verbage(const char *file, const char *nfile, off_t usize, off_t gsize)
1795 1.1 mrg {
1796 1.37 mrg if (file)
1797 1.37 mrg fprintf(stderr, "%s:%s ", file,
1798 1.37 mrg strlen(file) < 7 ? "\t\t" : "\t");
1799 1.63 dsl print_ratio(usize, gsize, stderr);
1800 1.4 mrg if (nfile)
1801 1.4 mrg fprintf(stderr, " -- replaced with %s", nfile);
1802 1.1 mrg fprintf(stderr, "\n");
1803 1.1 mrg fflush(stderr);
1804 1.1 mrg }
1805 1.1 mrg
1806 1.1 mrg /* print test results */
1807 1.1 mrg static void
1808 1.45 agc print_test(const char *file, int ok)
1809 1.1 mrg {
1810 1.1 mrg
1811 1.46 mrg if (exit_value == 0 && ok == 0)
1812 1.46 mrg exit_value = 1;
1813 1.1 mrg fprintf(stderr, "%s:%s %s\n", file,
1814 1.1 mrg strlen(file) < 7 ? "\t\t" : "\t", ok ? "OK" : "NOT OK");
1815 1.1 mrg fflush(stderr);
1816 1.1 mrg }
1817 1.26 mrg #endif
1818 1.1 mrg
1819 1.5 mrg /* print a file's info ala --list */
1820 1.5 mrg /* eg:
1821 1.5 mrg compressed uncompressed ratio uncompressed_name
1822 1.5 mrg 354841 1679360 78.8% /usr/pkgsrc/distfiles/libglade-2.0.1.tar
1823 1.5 mrg */
1824 1.5 mrg static void
1825 1.35 mrg print_list(int fd, off_t out, const char *outfile, time_t ts)
1826 1.5 mrg {
1827 1.5 mrg static int first = 1;
1828 1.29 mrg #ifndef SMALL
1829 1.6 mrg static off_t in_tot, out_tot;
1830 1.63 dsl uint32_t crc;
1831 1.29 mrg #endif
1832 1.35 mrg off_t in;
1833 1.5 mrg int rv;
1834 1.5 mrg
1835 1.7 mrg if (first) {
1836 1.26 mrg #ifndef SMALL
1837 1.7 mrg if (vflag)
1838 1.7 mrg printf("method crc date time ");
1839 1.26 mrg #endif
1840 1.7 mrg if (qflag == 0)
1841 1.7 mrg printf(" compressed uncompressed "
1842 1.7 mrg "ratio uncompressed_name\n");
1843 1.7 mrg }
1844 1.5 mrg first = 0;
1845 1.5 mrg
1846 1.6 mrg /* print totals? */
1847 1.29 mrg #ifndef SMALL
1848 1.6 mrg if (fd == -1) {
1849 1.6 mrg in = in_tot;
1850 1.6 mrg out = out_tot;
1851 1.29 mrg } else
1852 1.29 mrg #endif
1853 1.29 mrg {
1854 1.6 mrg /* read the last 4 bytes - this is the uncompressed size */
1855 1.7 mrg rv = lseek(fd, (off_t)(-8), SEEK_END);
1856 1.6 mrg if (rv != -1) {
1857 1.7 mrg unsigned char buf[8];
1858 1.63 dsl uint32_t usize;
1859 1.6 mrg
1860 1.6 mrg if (read(fd, (char *)buf, sizeof(buf)) != sizeof(buf))
1861 1.37 mrg maybe_warn("read of uncompressed size");
1862 1.7 mrg usize = buf[4] | buf[5] << 8 | buf[6] << 16 | buf[7] << 24;
1863 1.35 mrg in = (off_t)usize;
1864 1.29 mrg #ifndef SMALL
1865 1.29 mrg crc = buf[0] | buf[1] << 8 | buf[2] << 16 | buf[3] << 24;
1866 1.29 mrg #endif
1867 1.6 mrg }
1868 1.6 mrg }
1869 1.5 mrg
1870 1.26 mrg #ifndef SMALL
1871 1.7 mrg if (vflag && fd == -1)
1872 1.7 mrg printf(" ");
1873 1.7 mrg else if (vflag) {
1874 1.7 mrg char *date = ctime(&ts);
1875 1.7 mrg
1876 1.7 mrg /* skip the day, 1/100th second, and year */
1877 1.7 mrg date += 4;
1878 1.7 mrg date[12] = 0;
1879 1.7 mrg printf("%5s %08x %11s ", "defla"/*XXX*/, crc, date);
1880 1.7 mrg }
1881 1.29 mrg in_tot += in;
1882 1.29 mrg out_tot += out;
1883 1.26 mrg #endif
1884 1.35 mrg printf("%12llu %12llu ", (unsigned long long)out, (unsigned long long)in);
1885 1.6 mrg print_ratio(in, out, stdout);
1886 1.6 mrg printf(" %s\n", outfile);
1887 1.5 mrg }
1888 1.5 mrg
1889 1.1 mrg /* display the usage of NetBSD gzip */
1890 1.1 mrg static void
1891 1.1 mrg usage(void)
1892 1.1 mrg {
1893 1.1 mrg
1894 1.1 mrg fprintf(stderr, "%s\n", gzip_version);
1895 1.1 mrg fprintf(stderr,
1896 1.29 mrg "usage: %s [-" OPT_LIST "] [<file> [<file> ...]]\n"
1897 1.11 mrg #ifndef SMALL
1898 1.1 mrg " -c --stdout write to stdout, keep original files\n"
1899 1.1 mrg " --to-stdout\n"
1900 1.1 mrg " -d --decompress uncompress files\n"
1901 1.1 mrg " --uncompress\n"
1902 1.1 mrg " -f --force force overwriting & compress links\n"
1903 1.1 mrg " -h --help display this help\n"
1904 1.1 mrg " -n --no-name don't save original file name or time stamp\n"
1905 1.1 mrg " -N --name save or restore original file name and time stamp\n"
1906 1.1 mrg " -q --quiet output no warnings\n"
1907 1.1 mrg " -r --recursive recursively compress files in directories\n"
1908 1.1 mrg " -S .suf use suffix .suf instead of .gz\n"
1909 1.1 mrg " --suffix .suf\n"
1910 1.1 mrg " -t --test test compressed file\n"
1911 1.1 mrg " -v --verbose print extra statistics\n"
1912 1.1 mrg " -V --version display program version\n"
1913 1.1 mrg " -1 --fast fastest (worst) compression\n"
1914 1.1 mrg " -2 .. -8 set compression level\n"
1915 1.1 mrg " -9 --best best (slowest) compression\n",
1916 1.11 mrg #else
1917 1.11 mrg ,
1918 1.11 mrg #endif
1919 1.1 mrg getprogname());
1920 1.1 mrg exit(0);
1921 1.1 mrg }
1922 1.1 mrg
1923 1.1 mrg /* display the version of NetBSD gzip */
1924 1.1 mrg static void
1925 1.1 mrg display_version(void)
1926 1.1 mrg {
1927 1.1 mrg
1928 1.1 mrg fprintf(stderr, "%s\n", gzip_version);
1929 1.1 mrg exit(0);
1930 1.1 mrg }
1931 1.10 mrg
1932 1.24 tsutsui #ifndef NO_BZIP2_SUPPORT
1933 1.10 mrg #include "unbzip2.c"
1934 1.24 tsutsui #endif
1935 1.24 tsutsui #ifndef NO_COMPRESS_SUPPORT
1936 1.22 mrg #include "zuncompress.c"
1937 1.24 tsutsui #endif
1938 1.71 yamt
1939 1.71 yamt static ssize_t
1940 1.71 yamt read_retry(int fd, void *buf, size_t sz)
1941 1.71 yamt {
1942 1.71 yamt char *cp = buf;
1943 1.71 yamt ssize_t left = sz;
1944 1.71 yamt
1945 1.71 yamt while (left > 0) {
1946 1.71 yamt ssize_t ret;
1947 1.71 yamt
1948 1.71 yamt ret = read(fd, cp, sz);
1949 1.71 yamt if (ret == -1) {
1950 1.71 yamt return ret;
1951 1.71 yamt } else if (ret == 0) {
1952 1.71 yamt break; /* EOF */
1953 1.71 yamt }
1954 1.71 yamt cp += ret;
1955 1.71 yamt left -= ret;
1956 1.71 yamt }
1957 1.71 yamt
1958 1.71 yamt return sz - left;
1959 1.71 yamt }
1960