-
Notifications
You must be signed in to change notification settings - Fork 0
/
gzip.c
2168 lines (1955 loc) · 65.7 KB
/
gzip.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/* gzip (GNU zip) -- compress files with zip algorithm and 'compress' interface
Copyright (C) 1999, 2001-2002, 2006-2007, 2009-2021 Free Software
Foundation, Inc.
Copyright (C) 1992-1993 Jean-loup Gailly
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software Foundation,
Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
/*
* The unzip code was written and put in the public domain by Mark Adler.
* Portions of the lzw code are derived from the public domain 'compress'
* written by Spencer Thomas, Joe Orost, James Woods, Jim McKie, Steve Davies,
* Ken Turkowski, Dave Mack and Peter Jannesen.
*
* See the license_msg below and the file COPYING for the software license.
* See the file algorithm.doc for the compression algorithms and file formats.
*/
static char const *const license_msg[] = {
"Copyright (C) 2018 Free Software Foundation, Inc.",
"Copyright (C) 1993 Jean-loup Gailly.",
"This is free software. You may redistribute copies of it under the terms of",
"the GNU General Public License <https://www.gnu.org/licenses/gpl.html>.",
"There is NO WARRANTY, to the extent permitted by law.",
0};
/* Compress files with zip algorithm and 'compress' interface.
* See help() function below for all options.
* Outputs:
* file.gz: compressed file with same mode, owner, and utimes
* or stdout with -c option or if stdin used as input.
* If the output file name had to be truncated, the original name is kept
* in the compressed file.
* On MSDOS, file.tmp -> file.tmz.
*
* Using gz on MSDOS would create too many file name conflicts. For
* example, foo.txt -> foo.tgz (.tgz must be reserved as shorthand for
* tar.gz). Similarly, foo.dir and foo.doc would both be mapped to foo.dgz.
* I also considered 12345678.txt -> 12345txt.gz but this truncates the name
* too heavily. There is no ideal solution given the MSDOS 8+3 limitation.
*
* For the meaning of all compilation flags, see comments in Makefile.in.
*/
#include <config.h>
#include <ctype.h>
#include <sys/types.h>
#include <signal.h>
#include <stdalign.h>
#include <stdbool.h>
#include <stddef.h>
#include <sys/stat.h>
#include <errno.h>
#include "tailor.h"
#include "gzip.h"
#include "intprops.h"
#include "lzw.h"
#include "revision.h"
#include "timespec.h"
#include "dirname.h"
#include "dosname.h"
#include "fcntl--.h"
#include "getopt.h"
#include "ignore-value.h"
#include "stat-time.h"
#include "version.h"
#include "xalloc.h"
#include "yesno.h"
/* configuration */
#include <limits.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#ifndef NO_DIR
# define NO_DIR 0
#endif
#if !NO_DIR
# include <dirent.h>
# include <savedir.h>
#endif
#ifndef NO_UTIME
# include <utimens.h>
#endif
#ifndef MAX_PATH_LEN
# define MAX_PATH_LEN 1024 /* max pathname length */
#endif
#ifndef SEEK_END
# define SEEK_END 2
#endif
#ifndef CHAR_BIT
# define CHAR_BIT 8
#endif
#ifdef off_t
off_t lseek (int fd, off_t offset, int whence);
#endif
#ifndef HAVE_WORKING_O_NOFOLLOW
# define HAVE_WORKING_O_NOFOLLOW 0
#endif
/* Separator for file name parts (see shorten_name()) */
#ifdef NO_MULTIPLE_DOTS
# define PART_SEP "-"
#else
# define PART_SEP "."
#endif
/* global buffers */
/* With IBM_Z_DFLTCC, DEFLATE COMPRESSION works faster with
page-aligned input and output buffers, and requires page-aligned
windows; the alignment requirement is 4096. On other platforms
alignment doesn't hurt, and alignment up to 4096 is portable so
let's do that. */
#ifdef __alignas_is_defined
# define BUFFER_ALIGNED alignas (4096)
#else
# define BUFFER_ALIGNED /**/
#endif
DECLARE(uch BUFFER_ALIGNED, inbuf, INBUFSIZ +INBUF_EXTRA);
DECLARE(uch BUFFER_ALIGNED, outbuf, OUTBUFSIZ+OUTBUF_EXTRA);
DECLARE(ush, d_buf, DIST_BUFSIZE);
DECLARE(uch BUFFER_ALIGNED, window, 2L*WSIZE);
#ifndef MAXSEG_64K
DECLARE(ush, tab_prefix, 1L<<BITS);
#else
DECLARE(ush, tab_prefix0, 1L<<(BITS-1));
DECLARE(ush, tab_prefix1, 1L<<(BITS-1));
#endif
/* local variables */
/* If true, pretend that standard input is a tty. This option
is deliberately not documented, and only for testing. */
static bool presume_input_tty;
/* If true, transfer output data to the output file's storage device
when supported. Otherwise, if the system crashes around the time
gzip is run, the user might lose both input and output data. See:
Pillai TS et al. All file systems are not created equal: on the
complexity of crafting crash-consistent applications. OSDI'14. 2014:433-48.
https://www.usenix.org/conference/osdi14/technical-sessions/presentation/pillai */
static bool synchronous;
static int ascii = 0; /* convert end-of-lines to local OS conventions */
int to_stdout = 0; /* output to stdout (-c) */
static int decompress = 0; /* decompress (-d) */
static int force = 0; /* don't ask questions, compress links (-f) */
static int keep = 0; /* keep (don't delete) input files */
static int no_name = -1; /* don't save or restore the original file name */
static int no_time = -1; /* don't save or restore the original file time */
static int recursive = 0; /* recurse through directories (-r) */
static int list = 0; /* list the file contents (-l) */
int verbose = 0; /* be verbose (-v) */
int quiet = 0; /* be very quiet (-q) */
static int do_lzw = 0; /* generate output compatible with old compress (-Z) */
int test = 0; /* test .gz file integrity */
static int foreground = 0; /* set if program run in foreground */
char *program_name; /* program name */
int maxbits = BITS; /* max bits per code for LZW */
int method = DEFLATED;/* compression method */
int level = 6; /* compression level */
int exit_code = OK; /* program exit code */
int save_orig_name; /* set if original name must be saved */
static int last_member; /* set for .zip and .Z files */
static int part_nb; /* number of parts in .gz file */
off_t ifile_size; /* input file size, -1 for devices (debug only) */
static char *env; /* contents of GZIP env variable */
static char const *z_suffix; /* default suffix (can be set with --suffix) */
static size_t z_len; /* strlen(z_suffix) */
/* The original timestamp (modification time). If the original is
unknown, TIME_STAMP.tv_nsec is negative. If the original is
greater than struct timespec range, TIME_STAMP is the maximal
struct timespec value; this can happen on hosts with 32-bit signed
time_t because the gzip format's MTIME is 32-bit unsigned.
The original cannot be less than struct timespec range. */
struct timespec time_stamp;
/* The set of signals that are caught. */
static sigset_t caught_signals;
/* If nonzero then exit with status WARNING, rather than with the usual
signal status, on receipt of a signal with this value. This
suppresses a "Broken Pipe" message with some shells. */
static int volatile exiting_signal;
/* If nonnegative, close this file descriptor and unlink remove_ofname
on error. */
static int volatile remove_ofname_fd = -1;
static char volatile remove_ofname[MAX_PATH_LEN];
static bool stdin_was_read;
off_t bytes_in; /* number of input bytes */
off_t bytes_out; /* number of output bytes */
static off_t total_in; /* input bytes for all files */
static off_t total_out; /* output bytes for all files */
char ifname[MAX_PATH_LEN]; /* input file name */
char ofname[MAX_PATH_LEN]; /* output file name */
static char dfname[MAX_PATH_LEN]; /* name of dir containing output file */
static struct stat istat; /* status for input file */
int ifd; /* input file descriptor */
int ofd; /* output file descriptor */
static int dfd = -1; /* output directory file descriptor */
unsigned insize; /* valid bytes in inbuf */
unsigned inptr; /* index of next byte to be processed in inbuf */
unsigned outcnt; /* bytes in output buffer */
int rsync = 0; /* make ryncable chunks */
static int handled_sig[] =
{
/* SIGINT must be first, as 'foreground' depends on it. */
SIGINT
#ifdef SIGHUP
, SIGHUP
#endif
#if SIGPIPE
, SIGPIPE
#endif
#ifdef SIGTERM
, SIGTERM
#endif
#ifdef SIGXCPU
, SIGXCPU
#endif
#ifdef SIGXFSZ
, SIGXFSZ
#endif
};
/* For long options that have no equivalent short option, use a
non-character as a pseudo short option, starting with CHAR_MAX + 1. */
enum
{
PRESUME_INPUT_TTY_OPTION = CHAR_MAX + 1,
RSYNCABLE_OPTION,
SYNCHRONOUS_OPTION,
/* A value greater than all valid long options, used as a flag to
distinguish options derived from the GZIP environment variable. */
ENV_OPTION
};
static char const shortopts[] = "ab:cdfhH?klLmMnNqrS:tvVZ123456789";
static const struct option longopts[] =
{
/* { name has_arg *flag val } */
{"ascii", 0, 0, 'a'}, /* ascii text mode */
{"to-stdout", 0, 0, 'c'}, /* write output on standard output */
{"stdout", 0, 0, 'c'}, /* write output on standard output */
{"decompress", 0, 0, 'd'}, /* decompress */
{"uncompress", 0, 0, 'd'}, /* decompress */
/* {"encrypt", 0, 0, 'e'}, encrypt */
{"force", 0, 0, 'f'}, /* force overwrite of output file */
{"help", 0, 0, 'h'}, /* give help */
/* {"pkzip", 0, 0, 'k'}, force output in pkzip format */
{"keep", 0, 0, 'k'}, /* keep (don't delete) input files */
{"list", 0, 0, 'l'}, /* list .gz file contents */
{"license", 0, 0, 'L'}, /* display software license */
{"no-name", 0, 0, 'n'}, /* don't save or restore original name & time */
{"name", 0, 0, 'N'}, /* save or restore original name & time */
{"-presume-input-tty", no_argument, NULL, PRESUME_INPUT_TTY_OPTION},
{"quiet", 0, 0, 'q'}, /* quiet mode */
{"silent", 0, 0, 'q'}, /* quiet mode */
{"synchronous",0, 0, SYNCHRONOUS_OPTION},
{"recursive", 0, 0, 'r'}, /* recurse through directories */
{"suffix", 1, 0, 'S'}, /* use given suffix instead of .gz */
{"test", 0, 0, 't'}, /* test compressed file integrity */
{"verbose", 0, 0, 'v'}, /* verbose mode */
{"version", 0, 0, 'V'}, /* display version number */
{"fast", 0, 0, '1'}, /* compress faster */
{"best", 0, 0, '9'}, /* compress better */
{"lzw", 0, 0, 'Z'}, /* make output compatible with old compress */
{"bits", 1, 0, 'b'}, /* max number of bits per code (implies -Z) */
{"rsyncable", 0, 0, RSYNCABLE_OPTION}, /* make rsync-friendly archive */
{ 0, 0, 0, 0 }
};
/* local functions */
local noreturn void try_help (void);
local void help (void);
local void license (void);
local void version (void);
local int input_eof (void);
local void treat_stdin (void);
local void treat_file (char *iname);
local int create_outfile (void);
local char *get_suffix (char *name);
local int open_input_file (char *iname, struct stat *sbuf);
local void discard_input_bytes (size_t nbytes, unsigned int flags);
local int make_ofname (void);
local void shorten_name (char *name);
local int get_method (int in);
local void do_list (int ifd, int method);
local int check_ofname (void);
local void copy_stat (struct stat *ifstat);
local void install_signal_handlers (void);
static void remove_output_file (bool);
static void abort_gzip_signal (int);
local noreturn void do_exit (int exitcode);
static void finish_out (void);
int main (int argc, char **argv);
static int (*work) (int infile, int outfile) = zip; /* function to call */
#if ! NO_DIR
local void treat_dir (int fd, char *dir);
#endif
#define strequ(s1, s2) (strcmp((s1),(s2)) == 0)
static void
try_help ()
{
fprintf (stderr, "Try `%s --help' for more information.\n",
program_name);
do_exit (ERROR);
}
/* ======================================================================== */
local void help()
{
static char const* const help_msg[] = {
"Compress or uncompress FILEs (by default, compress FILES in-place).",
"",
"Mandatory arguments to long options are mandatory for short options too.",
"",
#if O_BINARY
" -a, --ascii ascii text; convert end-of-line using local conventions",
#endif
" -c, --stdout write on standard output, keep original files unchanged",
" -d, --decompress decompress",
/* -e, --encrypt encrypt */
" -f, --force force overwrite of output file and compress links",
" -h, --help give this help",
/* -k, --pkzip force output in pkzip format */
" -k, --keep keep (don't delete) input files",
" -l, --list list compressed file contents",
" -L, --license display software license",
#ifdef UNDOCUMENTED
" -m do not save or restore the original modification time",
" -M, --time save or restore the original modification time",
#endif
" -n, --no-name do not save or restore the original name and timestamp",
" -N, --name save or restore the original name and timestamp",
" -q, --quiet suppress all warnings",
#if ! NO_DIR
" -r, --recursive operate recursively on directories",
#endif
" --rsyncable make rsync-friendly archive",
" -S, --suffix=SUF use suffix SUF on compressed files",
" --synchronous synchronous output (safer if system crashes, but slower)",
" -t, --test test compressed file integrity",
" -v, --verbose verbose mode",
" -V, --version display version number",
" -1, --fast compress faster",
" -9, --best compress better",
#ifdef LZW
" -Z, --lzw produce output compatible with old compress",
" -b, --bits=BITS max number of bits per code (implies -Z)",
#endif
"",
"With no FILE, or when FILE is -, read standard input.",
"",
"Report bugs to <bug-gzip@gnu.org>.",
0};
char const *const *p = help_msg;
printf ("Usage: %s [OPTION]... [FILE]...\n", program_name);
while (*p) printf ("%s\n", *p++);
}
/* ======================================================================== */
local void license()
{
char const *const *p = license_msg;
printf ("%s %s\n", program_name, Version);
while (*p) printf ("%s\n", *p++);
}
/* ======================================================================== */
local void version()
{
license ();
printf ("\n");
printf ("Written by Jean-loup Gailly.\n");
}
local void progerror (char const *string)
{
int e = errno;
fprintf (stderr, "%s: ", program_name);
errno = e;
perror(string);
exit_code = ERROR;
}
/* ======================================================================== */
int main (int argc, char **argv)
{
int file_count; /* number of files to process */
size_t proglen; /* length of program_name */
char **argv_copy;
int env_argc;
char **env_argv;
EXPAND(argc, argv); /* wild card expansion if necessary */
program_name = gzip_base_name (argv[0]);
proglen = strlen (program_name);
/* Suppress .exe for MSDOS and OS/2: */
if (4 < proglen && strequ (program_name + proglen - 4, ".exe"))
program_name[proglen - 4] = '\0';
/* Add options in GZIP environment variable if there is one */
argv_copy = argv;
env = add_envopt (&env_argc, &argv_copy, OPTIONS_VAR);
env_argv = env ? argv_copy : NULL;
#ifndef GNU_STANDARD
# define GNU_STANDARD 1
#endif
#if !GNU_STANDARD
/* For compatibility with old compress, use program name as an option.
* Unless you compile with -DGNU_STANDARD=0, this program will behave as
* gzip even if it is invoked under the name gunzip or zcat.
*
* Systems which do not support links can still use -d or -dc.
* Ignore an .exe extension for MSDOS and OS/2.
*/
if (strncmp (program_name, "un", 2) == 0 /* ungzip, uncompress */
|| strncmp (program_name, "gun", 3) == 0) /* gunzip */
decompress = 1;
else if (strequ (program_name + 1, "cat") /* zcat, pcat, gcat */
|| strequ (program_name, "gzcat")) /* gzcat */
decompress = to_stdout = 1;
#endif
z_suffix = Z_SUFFIX;
z_len = strlen(z_suffix);
while (true) {
int optc;
int longind = -1;
if (env_argv)
{
if (env_argv[optind] && strequ (env_argv[optind], "--"))
optc = ENV_OPTION + '-';
else
{
optc = getopt_long (env_argc, env_argv, shortopts, longopts,
&longind);
if (0 <= optc)
optc += ENV_OPTION;
else
{
if (optind != env_argc)
{
fprintf (stderr,
("%s: %s: non-option in "OPTIONS_VAR
" environment variable\n"),
program_name, env_argv[optind]);
try_help ();
}
/* Wait until here before warning, so that GZIP='-q'
doesn't warn. */
if (env_argc != 1 && !quiet)
fprintf (stderr,
("%s: warning: "OPTIONS_VAR" environment variable"
" is deprecated; use an alias or script\n"),
program_name);
/* Start processing ARGC and ARGV instead. */
free (env_argv);
env_argv = NULL;
optind = 1;
longind = -1;
}
}
}
if (!env_argv)
optc = getopt_long (argc, argv, shortopts, longopts, &longind);
if (optc < 0)
break;
switch (optc) {
case 'a':
ascii = 1; break;
case 'b':
maxbits = atoi(optarg);
for (; *optarg; optarg++)
if (! ('0' <= *optarg && *optarg <= '9'))
{
fprintf (stderr, "%s: -b operand is not an integer\n",
program_name);
try_help ();
}
break;
case 'c':
to_stdout = 1; break;
case 'd':
decompress = 1; break;
case 'f':
force++; break;
case 'h': case 'H':
help (); finish_out (); break;
case 'k':
keep = 1; break;
case 'l':
list = decompress = to_stdout = 1; break;
case 'L':
license (); finish_out (); break;
case 'm': /* undocumented, may change later */
no_time = 1; break;
case 'M': /* undocumented, may change later */
no_time = 0; break;
case 'n':
case 'n' + ENV_OPTION:
no_name = no_time = 1; break;
case 'N':
case 'N' + ENV_OPTION:
no_name = no_time = 0; break;
case PRESUME_INPUT_TTY_OPTION:
presume_input_tty = true; break;
case 'q':
case 'q' + ENV_OPTION:
quiet = 1; verbose = 0; break;
case 'r':
#if NO_DIR
fprintf (stderr, "%s: -r not supported on this system\n",
program_name);
try_help ();
#else
recursive = 1;
#endif
break;
case RSYNCABLE_OPTION:
case RSYNCABLE_OPTION + ENV_OPTION:
rsync = 1;
break;
case 'S':
#ifdef NO_MULTIPLE_DOTS
if (*optarg == '.') optarg++;
#endif
z_len = strlen(optarg);
z_suffix = optarg;
break;
case SYNCHRONOUS_OPTION:
synchronous = true;
break;
case 't':
test = decompress = to_stdout = 1;
break;
case 'v':
case 'v' + ENV_OPTION:
verbose++; quiet = 0; break;
case 'V':
version (); finish_out (); break;
case 'Z':
#ifdef LZW
do_lzw = 1; break;
#else
fprintf(stderr, "%s: -Z not supported in this version\n",
program_name);
try_help ();
break;
#endif
case '1' + ENV_OPTION: case '2' + ENV_OPTION: case '3' + ENV_OPTION:
case '4' + ENV_OPTION: case '5' + ENV_OPTION: case '6' + ENV_OPTION:
case '7' + ENV_OPTION: case '8' + ENV_OPTION: case '9' + ENV_OPTION:
optc -= ENV_OPTION;
FALLTHROUGH;
case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
level = optc - '0';
break;
default:
if (ENV_OPTION <= optc && optc != ENV_OPTION + '?')
{
/* Output a diagnostic, since getopt_long didn't. */
fprintf (stderr, "%s: ", program_name);
if (longind < 0)
fprintf (stderr, "-%c: ", optc - ENV_OPTION);
else
fprintf (stderr, "--%s: ", longopts[longind].name);
fprintf (stderr, ("option not valid in "OPTIONS_VAR
" environment variable\n"));
}
try_help ();
}
} /* loop on all arguments */
/* By default, save name and timestamp on compression but do not
* restore them on decompression.
*/
if (no_time < 0) no_time = decompress;
if (no_name < 0) no_name = decompress;
file_count = argc - optind;
#if O_BINARY
#else
if (ascii && !quiet) {
fprintf(stderr, "%s: option --ascii ignored on this system\n",
program_name);
}
#endif
if (z_len == 0 || z_len > MAX_SUFFIX) {
fprintf(stderr, "%s: invalid suffix '%s'\n", program_name, z_suffix);
do_exit(ERROR);
}
if (do_lzw && !decompress) work = lzw;
/* Allocate all global buffers (for DYN_ALLOC option) */
ALLOC(uch, inbuf, INBUFSIZ +INBUF_EXTRA);
ALLOC(uch, outbuf, OUTBUFSIZ+OUTBUF_EXTRA);
ALLOC(ush, d_buf, DIST_BUFSIZE);
ALLOC(uch, window, 2L*WSIZE);
#ifndef MAXSEG_64K
ALLOC(ush, tab_prefix, 1L<<BITS);
#else
ALLOC(ush, tab_prefix0, 1L<<(BITS-1));
ALLOC(ush, tab_prefix1, 1L<<(BITS-1));
#endif
#if SIGPIPE
exiting_signal = quiet ? SIGPIPE : 0;
#endif
install_signal_handlers ();
/* And get to work */
if (file_count != 0) {
if (to_stdout && !test && !list && (!decompress || !ascii)) {
SET_BINARY_MODE (STDOUT_FILENO);
}
while (optind < argc) {
treat_file(argv[optind++]);
}
} else { /* Standard input */
treat_stdin();
}
if (stdin_was_read && close (STDIN_FILENO) != 0)
{
strcpy (ifname, "stdin");
read_error ();
}
if (list)
{
/* Output any totals, and check for output errors. */
if (!quiet && 1 < file_count)
do_list (-1, -1);
if (fflush (stdout) != 0)
write_error ();
}
if (to_stdout
&& ((synchronous
&& fdatasync (STDOUT_FILENO) != 0 && errno != EINVAL)
|| close (STDOUT_FILENO) != 0)
&& errno != EBADF)
write_error ();
do_exit(exit_code);
}
/* Return nonzero when at end of file on input. */
local int
input_eof ()
{
if (!decompress || last_member)
return 1;
if (inptr == insize)
{
if (insize != INBUFSIZ || fill_inbuf (1) == EOF)
return 1;
/* Unget the char that fill_inbuf got. */
inptr = 0;
}
return 0;
}
static void
get_input_size_and_time (void)
{
ifile_size = -1;
time_stamp.tv_nsec = -1;
/* Record the input file's size and timestamp only if it is a
regular file. Doing this for the timestamp helps to keep gzip's
output more reproducible when it is used as part of a
pipeline. */
if (S_ISREG (istat.st_mode))
{
ifile_size = istat.st_size;
if (!no_time || list)
time_stamp = get_stat_mtime (&istat);
}
}
/* ========================================================================
* Compress or decompress stdin
*/
local void treat_stdin()
{
if (!force && !list
&& (presume_input_tty
|| isatty (decompress ? STDIN_FILENO : STDOUT_FILENO))) {
/* Do not send compressed data to the terminal or read it from
* the terminal. We get here when user invoked the program
* without parameters, so be helpful. According to the GNU standards:
*
* If there is one behavior you think is most useful when the output
* is to a terminal, and another that you think is most useful when
* the output is a file or a pipe, then it is usually best to make
* the default behavior the one that is useful with output to a
* terminal, and have an option for the other behavior.
*
* Here we use the --force option to get the other behavior.
*/
if (! quiet)
fprintf (stderr,
("%s: compressed data not %s a terminal."
" Use -f to force %scompression.\n"
"For help, type: %s -h\n"),
program_name,
decompress ? "read from" : "written to",
decompress ? "de" : "",
program_name);
do_exit(ERROR);
}
if (decompress || !ascii) {
SET_BINARY_MODE (STDIN_FILENO);
}
if (!test && !list && (!decompress || !ascii)) {
SET_BINARY_MODE (STDOUT_FILENO);
}
strcpy(ifname, "stdin");
strcpy(ofname, "stdout");
/* Get the file's timestamp and size. */
if (fstat (STDIN_FILENO, &istat) != 0)
{
progerror ("standard input");
do_exit (ERROR);
}
get_input_size_and_time ();
clear_bufs(); /* clear input and output buffers */
to_stdout = 1;
part_nb = 0;
ifd = STDIN_FILENO;
stdin_was_read = true;
if (decompress) {
method = get_method(ifd);
if (method < 0) {
do_exit(exit_code); /* error message already emitted */
}
}
if (list) {
do_list(ifd, method);
return;
}
/* Actually do the compression/decompression. Loop over zipped members.
*/
for (;;) {
if (work (STDIN_FILENO, STDOUT_FILENO) != OK)
return;
if (input_eof ())
break;
method = get_method(ifd);
if (method < 0) return; /* error message already emitted */
bytes_out = 0; /* required for length check */
}
if (verbose) {
if (test) {
fprintf(stderr, " OK\n");
} else if (!decompress) {
display_ratio(bytes_in-(bytes_out-header_bytes), bytes_in, stderr);
fprintf(stderr, "\n");
#ifdef DISPLAY_STDIN_RATIO
} else {
display_ratio(bytes_out-(bytes_in-header_bytes), bytes_out,stderr);
fprintf(stderr, "\n");
#endif
}
}
}
static char const dot = '.';
/* True if the cached directory for calls to openat etc. is DIR, with
length DIRLEN. DIR need not be null-terminated. DIRLEN must be
less than MAX_PATH_LEN. */
static bool
atdir_eq (char const *dir, ptrdiff_t dirlen)
{
if (dirlen == 0)
dir = &dot, dirlen = 1;
return memcmp (dfname, dir, dirlen) == 0 && !dfname[dirlen];
}
/* Set the directory used for calls to openat etc. to be the directory
DIR, with length DIRLEN. DIR need not be null-terminated.
DIRLEN must be less than MAX_PATH_LEN. Return a file descriptor for
the directory, or -1 if one could not be obtained. */
static int
atdir_set (char const *dir, ptrdiff_t dirlen)
{
/* Don't bother opening directories on older systems that
lack openat and unlinkat. It's not worth the porting hassle. */
#if HAVE_OPENAT && HAVE_UNLINKAT
enum { try_opening_directories = true };
#else
enum { try_opening_directories = false };
#endif
if (try_opening_directories && ! atdir_eq (dir, dirlen))
{
if (0 <= dfd)
close (dfd);
if (dirlen == 0)
dir = &dot, dirlen = 1;
memcpy (dfname, dir, dirlen);
dfname[dirlen] = '\0';
dfd = open (dfname, O_SEARCH | O_DIRECTORY);
}
return dfd;
}
/* ========================================================================
* Compress or decompress the given file
*/
local void treat_file(iname)
char *iname;
{
/* Accept "-" as synonym for stdin */
if (strequ(iname, "-")) {
int cflag = to_stdout;
treat_stdin();
to_stdout = cflag;
return;
}
/* Check if the input file is present, set ifname and istat: */
ifd = open_input_file (iname, &istat);
if (ifd < 0)
return;
/* If the input name is that of a directory, recurse or ignore: */
if (S_ISDIR(istat.st_mode)) {
#if ! NO_DIR
if (recursive) {
treat_dir (ifd, iname);
/* Warning: ifname is now garbage */
return;
}
#endif
close (ifd);
WARN ((stderr, "%s: %s is a directory -- ignored\n",
program_name, ifname));
return;
}
if (! to_stdout)
{
if (! S_ISREG (istat.st_mode))
{
WARN ((stderr,
"%s: %s is not a directory or a regular file - ignored\n",
program_name, ifname));
close (ifd);
return;
}
if (istat.st_mode & S_ISUID)
{
WARN ((stderr, "%s: %s is set-user-ID on execution - ignored\n",
program_name, ifname));
close (ifd);
return;
}
if (istat.st_mode & S_ISGID)
{
WARN ((stderr, "%s: %s is set-group-ID on execution - ignored\n",
program_name, ifname));
close (ifd);
return;
}
if (! force)
{
if (istat.st_mode & S_ISVTX)
{
WARN ((stderr,
"%s: %s has the sticky bit set - file ignored\n",
program_name, ifname));
close (ifd);
return;
}
if (2 <= istat.st_nlink)
{
WARN ((stderr, "%s: %s has %lu other link%c -- unchanged\n",
program_name, ifname,
(unsigned long int) istat.st_nlink - 1,
istat.st_nlink == 2 ? ' ' : 's'));
close (ifd);
return;
}
}
}
get_input_size_and_time ();
/* Generate output file name. For -r and (-t or -l), skip files
* without a valid gzip suffix (check done in make_ofname).
*/
if (to_stdout && !list && !test) {
strcpy(ofname, "stdout");
} else if (make_ofname() != OK) {
close (ifd);
return;
}
clear_bufs(); /* clear input and output buffers */
part_nb = 0;
if (decompress) {
method = get_method(ifd); /* updates ofname if original given */
if (method < 0) {
close(ifd);
return; /* error message already emitted */
}
}
if (list) {
do_list(ifd, method);
if (close (ifd) != 0)
read_error ();
return;
}
/* If compressing to a file, check if ofname is not ambiguous
* because the operating system truncates names. Otherwise, generate
* a new ofname and save the original name in the compressed file.
*/
if (to_stdout) {
ofd = STDOUT_FILENO;
/* Keep remove_ofname_fd negative. */
} else {
if (create_outfile() != OK) return;
if (!decompress && save_orig_name && !verbose && !quiet) {
fprintf(stderr, "%s: %s compressed to %s\n",
program_name, ifname, ofname);
}
}
/* Keep the name even if not truncated except with --no-name: */