]> Dogcows Code - chaz/tar/blob - src/tar.c
projects / chaz / tar / blob
? search:


a79b956e76e8485827304c1520f336e9c1603534
[chaz/tar] / src / tar.c
1 /* A tar (tape archiver) program.
2
3 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1999, 2000,
4 2001, 2003, 2004, 2005 Free Software Foundation, Inc.
5
6 Written by John Gilmore, starting 1985-08-25.
7
8 This program is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any later
11 version.
12
13 This program is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
16 Public License for more details.
17
18 You should have received a copy of the GNU General Public License along
19 with this program; if not, write to the Free Software Foundation, Inc.,
20 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
21
22 #include <system.h>
23
24 #include <fnmatch.h>
25 #include <argp.h>
26
27 #include <signal.h>
28 #if ! defined SIGCHLD && defined SIGCLD
29 # define SIGCHLD SIGCLD
30 #endif
31
32 /* The following causes "common.h" to produce definitions of all the global
33 variables, rather than just "extern" declarations of them. GNU tar does
34 depend on the system loader to preset all GLOBAL variables to neutral (or
35 zero) values; explicit initialization is usually not done. */
36 #define GLOBAL
37 #include "common.h"
38
39 #include <argmatch.h>
40 #include <getdate.h>
41 #include <localedir.h>
42 #include <rmt.h>
43 #include <prepargs.h>
44 #include <quotearg.h>
45 #include <xstrtol.h>
46 #include <stdopen.h>
47
48 /* Local declarations. */
49
50 #ifndef DEFAULT_ARCHIVE_FORMAT
51 # define DEFAULT_ARCHIVE_FORMAT GNU_FORMAT
52 #endif
53
54 #ifndef DEFAULT_ARCHIVE
55 # define DEFAULT_ARCHIVE "tar.out"
56 #endif
57
58 #ifndef DEFAULT_BLOCKING
59 # define DEFAULT_BLOCKING 20
60 #endif
61
62 \f
63 /* Miscellaneous. */
64
65 /* Name of option using stdin. */
66 static const char *stdin_used_by;
67
68 /* Doesn't return if stdin already requested. */
69 void
70 request_stdin (const char *option)
71 {
72 if (stdin_used_by)
73 USAGE_ERROR ((0, 0, _("Options `-%s' and `-%s' both want standard input"),
74 stdin_used_by, option));
75
76 stdin_used_by = option;
77 }
78
79 extern int rpmatch (char const *response);
80
81 /* Returns true if and only if the user typed an affirmative response. */
82 int
83 confirm (const char *message_action, const char *message_name)
84 {
85 static FILE *confirm_file;
86 static int confirm_file_EOF;
87 bool status = false;
88
89 if (!confirm_file)
90 {
91 if (archive == 0 || stdin_used_by)
92 {
93 confirm_file = fopen (TTY_NAME, "r");
94 if (! confirm_file)
95 open_fatal (TTY_NAME);
96 }
97 else
98 {
99 request_stdin ("-w");
100 confirm_file = stdin;
101 }
102 }
103
104 fprintf (stdlis, "%s %s?", message_action, quote (message_name));
105 fflush (stdlis);
106
107 if (!confirm_file_EOF)
108 {
109 char *response = NULL;
110 size_t response_size = 0;
111 if (getline (&response, &response_size, confirm_file) < 0)
112 confirm_file_EOF = 1;
113 else
114 status = rpmatch (response) > 0;
115 free (response);
116 }
117
118 if (confirm_file_EOF)
119 {
120 fputc ('\n', stdlis);
121 fflush (stdlis);
122 }
123
124 return status;
125 }
126
127 static struct fmttab {
128 char const *name;
129 enum archive_format fmt;
130 } const fmttab[] = {
131 { "v7", V7_FORMAT },
132 { "oldgnu", OLDGNU_FORMAT },
133 { "ustar", USTAR_FORMAT },
134 { "posix", POSIX_FORMAT },
135 #if 0 /* not fully supported yet */
136 { "star", STAR_FORMAT },
137 #endif
138 { "gnu", GNU_FORMAT },
139 { "pax", POSIX_FORMAT }, /* An alias for posix */
140 { NULL, 0 }
141 };
142
143 static void
144 set_archive_format (char const *name)
145 {
146 struct fmttab const *p;
147
148 for (p = fmttab; strcmp (p->name, name) != 0; )
149 if (! (++p)->name)
150 USAGE_ERROR ((0, 0, _("%s: Invalid archive format"),
151 quotearg_colon (name)));
152
153 archive_format = p->fmt;
154 }
155
156 const char *
157 archive_format_string (enum archive_format fmt)
158 {
159 struct fmttab const *p;
160
161 for (p = fmttab; p->name; p++)
162 if (p->fmt == fmt)
163 return p->name;
164 return "unknown?";
165 }
166
167 #define FORMAT_MASK(n) (1<<(n))
168
169 static void
170 assert_format(unsigned fmt_mask)
171 {
172 if ((FORMAT_MASK (archive_format) & fmt_mask) == 0)
173 USAGE_ERROR ((0, 0,
174 _("GNU features wanted on incompatible archive format")));
175 }
176
177 const char *
178 subcommand_string (enum subcommand c)
179 {
180 switch (c)
181 {
182 case UNKNOWN_SUBCOMMAND:
183 return "unknown?";
184
185 case APPEND_SUBCOMMAND:
186 return "-r";
187
188 case CAT_SUBCOMMAND:
189 return "-A";
190
191 case CREATE_SUBCOMMAND:
192 return "-c";
193
194 case DELETE_SUBCOMMAND:
195 return "-D";
196
197 case DIFF_SUBCOMMAND:
198 return "-d";
199
200 case EXTRACT_SUBCOMMAND:
201 return "-x";
202
203 case LIST_SUBCOMMAND:
204 return "-t";
205
206 case UPDATE_SUBCOMMAND:
207 return "-u";
208
209 default:
210 abort ();
211 }
212 }
213
214 \f
215 /* Options. */
216
217 enum
218 {
219 ANCHORED_OPTION = CHAR_MAX + 1,
220 ATIME_PRESERVE_OPTION,
221 BACKUP_OPTION,
222 CHECKPOINT_OPTION,
223 CHECK_LINKS_OPTION,
224 DELETE_OPTION,
225 EXCLUDE_OPTION,
226 EXCLUDE_CACHES_OPTION,
227 FORCE_LOCAL_OPTION,
228 GROUP_OPTION,
229 HANG_OPTION,
230 IGNORE_CASE_OPTION,
231 IGNORE_COMMAND_ERROR_OPTION,
232 IGNORE_FAILED_READ_OPTION,
233 INDEX_FILE_OPTION,
234 KEEP_NEWER_FILES_OPTION,
235 LICENSE_OPTION,
236 MODE_OPTION,
237 NEWER_MTIME_OPTION,
238 NO_ANCHORED_OPTION,
239 NO_IGNORE_CASE_OPTION,
240 NO_IGNORE_COMMAND_ERROR_OPTION,
241 NO_OVERWRITE_DIR_OPTION,
242 NO_RECURSION_OPTION,
243 NO_SAME_OWNER_OPTION,
244 NO_SAME_PERMISSIONS_OPTION,
245 NO_UNQUOTE_OPTION,
246 NO_WILDCARDS_OPTION,
247 NO_WILDCARDS_MATCH_SLASH_OPTION,
248 NULL_OPTION,
249 NUMERIC_OWNER_OPTION,
250 OCCURRENCE_OPTION,
251 OLD_ARCHIVE_OPTION,
252 ONE_FILE_SYSTEM_OPTION,
253 OVERWRITE_OPTION,
254 OWNER_OPTION,
255 PAX_OPTION,
256 POSIX_OPTION,
257 PRESERVE_OPTION,
258 RECORD_SIZE_OPTION,
259 RECURSION_OPTION,
260 RECURSIVE_UNLINK_OPTION,
261 REMOVE_FILES_OPTION,
262 RESTRICT_OPTION,
263 RMT_COMMAND_OPTION,
264 RSH_COMMAND_OPTION,
265 SAME_OWNER_OPTION,
266 SHOW_DEFAULTS_OPTION,
267 SHOW_OMITTED_DIRS_OPTION,
268 SHOW_STORED_NAMES_OPTION,
269 STRIP_COMPONENTS_OPTION,
270 SUFFIX_OPTION,
271 TEST_LABEL_OPTION,
272 TO_COMMAND_OPTION,
273 TOTALS_OPTION,
274 UNQUOTE_OPTION,
275 USAGE_OPTION,
276 USE_COMPRESS_PROGRAM_OPTION,
277 UTC_OPTION,
278 VERSION_OPTION,
279 VOLNO_FILE_OPTION,
280 WILDCARDS_OPTION,
281 WILDCARDS_MATCH_SLASH_OPTION
282 };
283
284 const char *argp_program_version = "tar (" PACKAGE_NAME ") " VERSION;
285 const char *argp_program_bug_address = "<" PACKAGE_BUGREPORT ">";
286 static char doc[] = N_("GNU `tar' saves many files together into a single tape or disk archive, and can restore individual files from the archive.\n\
287 \n\
288 Examples:\n\
289 tar -cf archive.tar foo bar # Create archive.tar from files foo and bar.\n\
290 tar -tvf archive.tar # List all files in archive.tar verbosely.\n\
291 tar -xf archive.tar # Extract all files from archive.tar.\n\
292 \vThe backup suffix is `~', unless set with --suffix or SIMPLE_BACKUP_SUFFIX.\n\
293 The version control may be set with --backup or VERSION_CONTROL, values are:\n\n\
294 none, off never make backups\n\
295 t, numbered make numbered backups\n\
296 nil, existing numbered if numbered backups exist, simple otherwise\n\
297 never, simple always make simple backups\n");
298
299
300 /* NOTE:
301
302 Available option letters are DEIJQY and aeqy. Consider the following
303 assignments:
304
305 [For Solaris tar compatibility =/= Is it important at all?]
306 e exit immediately with a nonzero exit status if unexpected errors occur
307 E use extended headers (--format=posix)
308
309 [q alias for --occurrence=1 =/= this would better be used for quiet?]
310 [I same as T =/= will harm star compatibility]
311
312 y per-file gzip compression
313 Y per-block gzip compression */
314
315 static struct argp_option options[] = {
316 #define GRID 10
317 {NULL, 0, NULL, 0,
318 N_("Main operation mode:"), GRID },
319
320 {"list", 't', 0, 0,
321 N_("list the contents of an archive"), GRID+1 },
322 {"extract", 'x', 0, 0,
323 N_("extract files from an archive"), GRID+1 },
324 {"get", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
325 {"create", 'c', 0, 0,
326 N_("create a new archive"), GRID+1 },
327 {"diff", 'd', 0, 0,
328 N_("find differences between archive and file system"), GRID+1 },
329 {"compare", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
330 {"append", 'r', 0, 0,
331 N_("append files to the end of an archive"), GRID+1 },
332 {"update", 'u', 0, 0,
333 N_("only append files newer than copy in archive"), GRID+1 },
334 {"catenate", 'A', 0, 0,
335 N_("append tar files to an archive"), GRID+1 },
336 {"concatenate", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
337 {"delete", DELETE_OPTION, 0, 0,
338 N_("delete from the archive (not on mag tapes!)"), GRID+1 },
339 {"test-label", TEST_LABEL_OPTION, NULL, 0,
340 N_("Test archive volume label and exit"), GRID+1 },
341 #undef GRID
342
343 #define GRID 20
344 {NULL, 0, NULL, 0,
345 N_("Operation modifiers:"), GRID },
346
347 {"sparse", 'S', 0, 0,
348 N_("handle sparse files efficiently"), GRID+1 },
349 {"incremental", 'G', 0, 0,
350 N_("handle old GNU-format incremental backup"), GRID+1 },
351 {"listed-incremental", 'g', N_("FILE"), 0,
352 N_("handle new GNU-format incremental backup"), GRID+1 },
353 {"ignore-failed-read", IGNORE_FAILED_READ_OPTION, 0, 0,
354 N_("do not exit with nonzero on unreadable files"), GRID+1 },
355 {"occurrence", OCCURRENCE_OPTION, N_("NUMBER"), OPTION_ARG_OPTIONAL,
356 N_("process only the NUMBERth occurrence of each file in the archive. This option is valid only in conjunction with one of the subcommands --delete, --diff, --extract or --list and when a list of files is given either on the command line or via -T option. NUMBER defaults to 1."), GRID+1 },
357 {"seek", 'n', NULL, 0,
358 N_("archive is seekable"), GRID+1 },
359 #undef GRID
360
361 #define GRID 30
362 {NULL, 0, NULL, 0,
363 N_("Overwrite control:\n"), GRID+1 },
364
365 {"verify", 'W', 0, 0,
366 N_("attempt to verify the archive after writing it"), GRID+1 },
367 {"remove-files", REMOVE_FILES_OPTION, 0, 0,
368 N_("remove files after adding them to the archive"), GRID+1 },
369 {"keep-old-files", 'k', 0, 0,
370 N_("don't replace existing files when extracting"), GRID+1 },
371 {"keep-newer-files", KEEP_NEWER_FILES_OPTION, 0, 0,
372 N_("don't replace existing files that are newer than their archive copies"), GRID+1 },
373 {"overwrite", OVERWRITE_OPTION, 0, 0,
374 N_("overwrite existing files when extracting"), GRID+1 },
375 {"unlink-first", 'U', 0, 0,
376 N_("remove each file prior to extracting over it"), GRID+1 },
377 {"recursive-unlink", RECURSIVE_UNLINK_OPTION, 0, 0,
378 N_("empty hierarchies prior to extracting directory"), GRID+1 },
379 {"no-overwrite-dir", NO_OVERWRITE_DIR_OPTION, 0, 0,
380 N_("preserve metadata of existing directories"), GRID+1 },
381 #undef GRID
382
383 #define GRID 40
384 {NULL, 0, NULL, 0,
385 N_("Select output stream:"), GRID },
386
387 {"to-stdout", 'O', 0, 0,
388 N_("extract files to standard output"), GRID+1 },
389 {"to-command", TO_COMMAND_OPTION, N_("COMMAND"), 0,
390 N_("pipe extracted files to another program"), GRID+1 },
391 {"ignore-command-error", IGNORE_COMMAND_ERROR_OPTION, 0, 0,
392 N_("ignore exit codes of children"), GRID+1 },
393 {"no-ignore-command-error", NO_IGNORE_COMMAND_ERROR_OPTION, 0, 0,
394 N_("treat non-zero exit codes of children as error"), GRID+1 },
395 #undef GRID
396
397 #define GRID 50
398 {NULL, 0, NULL, 0,
399 N_("Handling of file attributes:"), GRID },
400
401 {"owner", OWNER_OPTION, N_("NAME"), 0,
402 N_("force NAME as owner for added files"), GRID+1 },
403 {"group", GROUP_OPTION, N_("NAME"), 0,
404 N_("force NAME as group for added files"), GRID+1 },
405 {"mode", MODE_OPTION, N_("CHANGES"), 0,
406 N_("force (symbolic) mode CHANGES for added files"), GRID+1 },
407 {"atime-preserve", ATIME_PRESERVE_OPTION,
408 N_("METHOD"), OPTION_ARG_OPTIONAL,
409 N_("preserve access times on dumped files, either by restoring the times"
410 " after reading (METHOD='replace'; default) or by not setting the times"
411 " in the first place (METHOD='system')"), GRID+1 },
412 {"touch", 'm', 0, 0,
413 N_("don't extract file modified time"), GRID+1 },
414 {"same-owner", SAME_OWNER_OPTION, 0, 0,
415 N_("try extracting files with the same ownership"), GRID+1 },
416 {"no-same-owner", NO_SAME_OWNER_OPTION, 0, 0,
417 N_("extract files as yourself"), GRID+1 },
418 {"numeric-owner", NUMERIC_OWNER_OPTION, 0, 0,
419 N_("always use numbers for user/group names"), GRID+1 },
420 {"preserve-permissions", 'p', 0, 0,
421 N_("extract information about file permissions (default for superuser)"),
422 GRID+1 },
423 {"same-permissions", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
424 {"no-same-permissions", NO_SAME_PERMISSIONS_OPTION, 0, 0,
425 N_("apply the user's umask when extracting permissions from the archive (default for ordinary users)"), GRID+1 },
426 {"preserve-order", 's', 0, 0,
427 N_("sort names to extract to match archive"), GRID+1 },
428 {"same-order", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
429 {"preserve", PRESERVE_OPTION, 0, 0,
430 N_("same as both -p and -s"), GRID+1 },
431 #undef GRID
432
433 #define GRID 60
434 {NULL, 0, NULL, 0,
435 N_("Device selection and switching:\n"), GRID+1 },
436
437 {"file", 'f', N_("ARCHIVE"), 0,
438 N_("use archive file or device ARCHIVE"), GRID+1 },
439 {"force-local", FORCE_LOCAL_OPTION, 0, 0,
440 N_("archive file is local even if it has a colon"), GRID+1 },
441 {"rmt-command", RMT_COMMAND_OPTION, N_("COMMAND"), 0,
442 N_("use given rmt COMMAND instead of rmt"), GRID+1 },
443 {"rsh-command", RSH_COMMAND_OPTION, N_("COMMAND"), 0,
444 N_("use remote COMMAND instead of rsh"), GRID+1 },
445 #ifdef DEVICE_PREFIX
446 {"-[0-7][lmh]", 0, NULL, OPTION_DOC, /* It is OK, since `name' will never be
447 translated */
448 N_("specify drive and density"), GRID+1 },
449 #endif
450 {NULL, '0', NULL, OPTION_HIDDEN, NULL, GRID+1 },
451 {NULL, '1', NULL, OPTION_HIDDEN, NULL, GRID+1 },
452 {NULL, '2', NULL, OPTION_HIDDEN, NULL, GRID+1 },
453 {NULL, '3', NULL, OPTION_HIDDEN, NULL, GRID+1 },
454 {NULL, '4', NULL, OPTION_HIDDEN, NULL, GRID+1 },
455 {NULL, '5', NULL, OPTION_HIDDEN, NULL, GRID+1 },
456 {NULL, '6', NULL, OPTION_HIDDEN, NULL, GRID+1 },
457 {NULL, '7', NULL, OPTION_HIDDEN, NULL, GRID+1 },
458 {NULL, '8', NULL, OPTION_HIDDEN, NULL, GRID+1 },
459 {NULL, '9', NULL, OPTION_HIDDEN, NULL, GRID+1 },
460
461 {"multi-volume", 'M', 0, 0,
462 N_("create/list/extract multi-volume archive"), GRID+1 },
463 {"tape-length", 'L', N_("NUMBER"), 0,
464 N_("change tape after writing NUMBER x 1024 bytes"), GRID+1 },
465 {"info-script", 'F', N_("NAME"), 0,
466 N_("run script at end of each tape (implies -M)"), GRID+1 },
467 {"new-volume-script", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
468 {"volno-file", VOLNO_FILE_OPTION, N_("FILE"), 0,
469 N_("use/update the volume number in FILE"), GRID+1 },
470 #undef GRID
471
472 #define GRID 70
473 {NULL, 0, NULL, 0,
474 N_("Device blocking:"), GRID+1 },
475
476 {"blocking-factor", 'b', N_("BLOCKS"), 0,
477 N_("BLOCKS x 512 bytes per record"), GRID+1 },
478 {"record-size", RECORD_SIZE_OPTION, N_("NUMBER"), 0,
479 N_("NUMBER of bytes per record, multiple of 512"), GRID+1 },
480 {"ignore-zeros", 'i', 0, 0,
481 N_("ignore zeroed blocks in archive (means EOF)"), GRID+1 },
482 {"read-full-records", 'B', 0, 0,
483 N_("reblock as we read (for 4.2BSD pipes)"), GRID+1 },
484 #undef GRID
485
486 #define GRID 80
487 {NULL, 0, NULL, 0,
488 N_("Archive format selection:"), GRID },
489
490 {"format", 'H', N_("FORMAT"), 0,
491 N_("create archive of the given format."), GRID+1 },
492
493 {NULL, 0, NULL, 0, N_("FORMAT is one of the following:"), GRID+2 },
494 {" v7", 0, NULL, OPTION_DOC|OPTION_NO_TRANS, N_("old V7 tar format"),
495 GRID+3 },
496 {" oldgnu", 0, NULL, OPTION_DOC|OPTION_NO_TRANS,
497 N_("GNU format as per tar <= 1.12"), GRID+3 },
498 {" gnu", 0, NULL, OPTION_DOC|OPTION_NO_TRANS,
499 N_("GNU tar 1.13.x format"), GRID+3 },
500 {" ustar", 0, NULL, OPTION_DOC|OPTION_NO_TRANS,
501 N_("POSIX 1003.1-1988 (ustar) format"), GRID+3 },
502 {" pax", 0, NULL, OPTION_DOC|OPTION_NO_TRANS,
503 N_("POSIX 1003.1-2001 (pax) format"), GRID+3 },
504 {" posix", 0, NULL, OPTION_DOC|OPTION_NO_TRANS, N_("same as pax"), GRID+3 },
505
506 {"old-archive", OLD_ARCHIVE_OPTION, 0, 0, /* FIXME */
507 N_("same as --format=v7"), GRID+8 },
508 {"portability", 0, 0, OPTION_ALIAS, NULL, GRID+8 },
509 {"posix", POSIX_OPTION, 0, 0,
510 N_("same as --format=posix"), GRID+8 },
511 {"pax-option", PAX_OPTION, N_("keyword[[:]=value][,keyword[[:]=value], ...]"), 0,
512 N_("control pax keywords"), GRID+8 },
513 {"label", 'V', N_("TEXT"), 0,
514 N_("create archive with volume name TEXT. At list/extract time, use TEXT as a globbing pattern for volume name"), GRID+8 },
515 {"bzip2", 'j', 0, 0,
516 N_("filter the archive through bzip2"), GRID+8 },
517 {"gzip", 'z', 0, 0,
518 N_("filter the archive through gzip"), GRID+8 },
519 {"gunzip", 0, 0, OPTION_ALIAS, NULL, GRID+8 },
520 {"ungzip", 0, 0, OPTION_ALIAS, NULL, GRID+8 },
521 {"compress", 'Z', 0, 0,
522 N_("filter the archive through compress"), GRID+8 },
523 {"uncompress", 0, 0, OPTION_ALIAS, NULL, GRID+8 },
524 {"use-compress-program", USE_COMPRESS_PROGRAM_OPTION, N_("PROG"), 0,
525 N_("filter through PROG (must accept -d)"), GRID+8 },
526 #undef GRID
527
528 #define GRID 90
529 {NULL, 0, NULL, 0,
530 N_("Local file selection:"), GRID },
531
532 {"add-file", ARGP_KEY_ARG, N_("FILE"), 0,
533 N_("add given FILE to the archive (useful if its name starts with a dash)"), GRID+1 },
534 {"directory", 'C', N_("DIR"), 0,
535 N_("change to directory DIR"), GRID+1 },
536 {"files-from", 'T', N_("FILE"), 0,
537 N_("get names to extract or create from FILE"), GRID+1 },
538 {"null", NULL_OPTION, 0, 0,
539 N_("-T reads null-terminated names, disable -C"), GRID+1 },
540 {"unquote", UNQUOTE_OPTION, 0, 0,
541 N_("unquote filenames read with -T (default)"), GRID+1 },
542 {"no-unquote", NO_UNQUOTE_OPTION, 0, 0,
543 N_("do not unquote filenames read with -T"), GRID+1 },
544 {"exclude", EXCLUDE_OPTION, N_("PATTERN"), 0,
545 N_("exclude files, given as a PATTERN"), GRID+1 },
546 {"exclude-from", 'X', N_("FILE"), 0,
547 N_("exclude patterns listed in FILE"), GRID+1 },
548 {"exclude-caches", EXCLUDE_CACHES_OPTION, 0, 0,
549 N_("exclude directories containing a cache tag"), GRID+1 },
550 {"ignore-case", IGNORE_CASE_OPTION, 0, 0,
551 N_("exclusion ignores case"), GRID+1 },
552 {"anchored", ANCHORED_OPTION, 0, 0,
553 N_("exclude patterns match file name start"), GRID+1 },
554 {"no-anchored", NO_ANCHORED_OPTION, 0, 0,
555 N_("exclude patterns match after any `/' (default)"), GRID+1 },
556 {"no-ignore-case", NO_IGNORE_CASE_OPTION, 0, 0,
557 N_("exclusion is case sensitive (default)"), GRID+1 },
558 {"no-wildcards", NO_WILDCARDS_OPTION, 0, 0,
559 N_("exclude patterns are plain strings"), GRID+1 },
560 {"no-wildcards-match-slash", NO_WILDCARDS_MATCH_SLASH_OPTION, 0, 0,
561 N_("exclude pattern wildcards do not match `/'"), GRID+1 },
562 {"no-recursion", NO_RECURSION_OPTION, 0, 0,
563 N_("avoid descending automatically in directories"), GRID+1 },
564 {"one-file-system", ONE_FILE_SYSTEM_OPTION, 0, 0,
565 N_("stay in local file system when creating archive"), GRID+1 },
566 {NULL, 'l', 0, OPTION_HIDDEN, "", GRID+1 },
567 {"recursion", RECURSION_OPTION, 0, 0,
568 N_("recurse into directories (default)"), GRID+1 },
569 {"absolute-names", 'P', 0, 0,
570 N_("don't strip leading `/'s from file names"), GRID+1 },
571 {"dereference", 'h', 0, 0,
572 N_("follow symlinks; archive and dump the files they point to"), GRID+1 },
573 {"starting-file", 'K', N_("MEMBER-NAME"), 0,
574 N_("begin at member MEMBER-NAME in the archive"), GRID+1 },
575 {"strip-components", STRIP_COMPONENTS_OPTION, N_("NUMBER"), 0,
576 N_("strip NUMBER leading components from file names"), GRID+1 },
577 {"newer", 'N', N_("DATE-OR-FILE"), 0,
578 N_("only store files newer than DATE-OR-FILE"), GRID+1 },
579 {"newer-mtime", NEWER_MTIME_OPTION, N_("DATE"), 0,
580 N_("compare date and time when data changed only"), GRID+1 },
581 {"after-date", 'N', N_("DATE"), 0,
582 N_("same as -N"), GRID+1 },
583 {"backup", BACKUP_OPTION, N_("CONTROL"), OPTION_ARG_OPTIONAL,
584 N_("backup before removal, choose version CONTROL"), GRID+1 },
585 {"suffix", SUFFIX_OPTION, N_("STRING"), 0,
586 N_("backup before removal, override usual suffix ('~' unless overridden by environment variable SIMPLE_BACKUP_SUFFIX)"), GRID+1 },
587 {"wildcards", WILDCARDS_OPTION, 0, 0,
588 N_("exclude patterns use wildcards (default)"), GRID+1 },
589 {"wildcards-match-slash", WILDCARDS_MATCH_SLASH_OPTION, 0, 0,
590 N_("exclude pattern wildcards match `/' (default)"), GRID+1 },
591 #undef GRID
592
593 #define GRID 100
594 {NULL, 0, NULL, 0,
595 N_("Informative output:"), GRID },
596
597 {"verbose", 'v', 0, 0,
598 N_("verbosely list files processed"), GRID+1 },
599 {"checkpoint", CHECKPOINT_OPTION, 0, 0,
600 N_("display progress messages every 10th record"), GRID+1 },
601 {"check-links", CHECK_LINKS_OPTION, 0, 0,
602 N_("print a message if not all links are dumped"), GRID+1 },
603 {"totals", TOTALS_OPTION, 0, 0,
604 N_("print total bytes written while creating archive"), GRID+1 },
605 {"utc", UTC_OPTION, 0, 0,
606 N_("print file modification dates in UTC"), GRID+1 },
607 {"index-file", INDEX_FILE_OPTION, N_("FILE"), 0,
608 N_("send verbose output to FILE"), GRID+1 },
609 {"block-number", 'R', 0, 0,
610 N_("show block number within archive with each message"), GRID+1 },
611 {"interactive", 'w', 0, 0,
612 N_("ask for confirmation for every action"), GRID+1 },
613 {"confirmation", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
614 {"show-defaults", SHOW_DEFAULTS_OPTION, 0, 0,
615 N_("Show tar defaults"), GRID+1 },
616 {"show-omitted-dirs", SHOW_OMITTED_DIRS_OPTION, 0, 0,
617 N_("When listing or extracting, list each directory that does not match search criteria"), GRID+1 },
618 {"show-stored-names", SHOW_STORED_NAMES_OPTION, 0, 0,
619 N_("When creating archive in verbose mode, list member names as stored in the archive"),
620 GRID+1 },
621 #undef GRID
622
623 #define GRID 110
624 {NULL, 0, NULL, 0,
625 N_("Compatibility options:"), GRID },
626
627 {NULL, 'o', 0, 0,
628 N_("when creating, same as --old-archive. When extracting, same as --no-same-owner"), GRID+1 },
629 #undef GRID
630
631 #define GRID 120
632 {NULL, 0, NULL, 0,
633 N_("Other options:"), GRID },
634
635 {"restrict", RESTRICT_OPTION, 0, 0,
636 N_("Restrict use of some potentially harmful options"), -1 },
637
638 {"help", '?', 0, 0, N_("Give this help list"), -1},
639 {"usage", USAGE_OPTION, 0, 0, N_("Give a short usage message"), -1},
640 {"license", LICENSE_OPTION, 0, 0, N_("Print license and exit"), -1},
641 {"version", VERSION_OPTION, 0, 0, N_("Print program version"), -1},
642 /* FIXME -V (--label) conflicts with the default short option for
643 --version */
644 {"HANG", HANG_OPTION, "SECS", OPTION_ARG_OPTIONAL | OPTION_HIDDEN,
645 N_("Hang for SECS seconds (default 3600)"), 0},
646 #undef GRID
647
648 {0, 0, 0, 0, 0, 0}
649 };
650
651 static char const *const atime_preserve_args[] =
652 {
653 "replace", "system", NULL
654 };
655 static enum atime_preserve const atime_preserve_types[] =
656 {
657 replace_atime_preserve, system_atime_preserve
658 };
659 ARGMATCH_VERIFY (atime_preserve_args, atime_preserve_types);
660
661
662 struct tar_args {
663 char const *textual_date_option;
664 int exclude_options;
665 bool o_option;
666 int pax_option;
667 char const *backup_suffix_string;
668 char const *version_control_string;
669 int input_files;
670 };
671
672 static void
673 show_default_settings (FILE *stream)
674 {
675 fprintf (stream,
676 "--format=%s -f%s -b%d --rmt-command=%s",
677 archive_format_string (DEFAULT_ARCHIVE_FORMAT),
678 DEFAULT_ARCHIVE, DEFAULT_BLOCKING,
679 DEFAULT_RMT_COMMAND);
680 #ifdef REMOTE_SHELL
681 fprintf (stream, " --rsh-command=%s", REMOTE_SHELL);
682 #endif
683 fprintf (stream, "\n");
684 }
685
686 static void
687 set_subcommand_option (enum subcommand subcommand)
688 {
689 if (subcommand_option != UNKNOWN_SUBCOMMAND
690 && subcommand_option != subcommand)
691 USAGE_ERROR ((0, 0,
692 _("You may not specify more than one `-Acdtrux' option")));
693
694 subcommand_option = subcommand;
695 }
696
697 static void
698 set_use_compress_program_option (const char *string)
699 {
700 if (use_compress_program_option
701 && strcmp (use_compress_program_option, string) != 0)
702 USAGE_ERROR ((0, 0, _("Conflicting compression options")));
703
704 use_compress_program_option = string;
705 }
706
707 void
708 license ()
709 {
710 printf ("tar (%s) %s\n%s\n", PACKAGE_NAME, PACKAGE_VERSION,
711 "Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1999, \n\
712 2000, 2001, 2003, 2004, 2005 Free Software Foundation, Inc.\n");
713 puts (_("Based on the work of John Gilmore and Jay Fenlason. See AUTHORS\n\
714 for complete list of authors.\n"));
715 printf (_(" GNU tar is free software; you can redistribute it and/or modify\n"
716 " it under the terms of the GNU General Public License as published by\n"
717 " the Free Software Foundation; either version 2 of the License, or\n"
718 " (at your option) any later version.\n"
719 "\n"
720 " GNU tar is distributed in the hope that it will be useful,\n"
721 " but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
722 " MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
723 " GNU General Public License for more details.\n"
724 "\n"
725 " You should have received a copy of the GNU General Public License\n"
726 " along with GNU tar; if not, write to the Free Software Foundation,\n"
727 " Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA\n\n"));
728 exit (0);
729 }
730
731 static volatile int _argp_hang;
732
733 enum read_file_list_state /* Result of reading file name from the list file */
734 {
735 file_list_success, /* OK, name read successfully */
736 file_list_end, /* End of list file */
737 file_list_zero /* Zero separator encountered where it should not */
738 };
739
740 /* Read from FP a sequence of characters up to FILENAME_TERMINATOR and put them
741 into STK.
742 */
743 static enum read_file_list_state
744 read_name_from_file (FILE *fp, struct obstack *stk)
745 {
746 int c;
747 size_t counter = 0;
748
749 for (c = getc (fp); c != EOF && c != filename_terminator; c = getc (fp))
750 {
751 if (c == 0)
752 {
753 /* We have read a zero separator. The file possibly is zero-separated */
754 /* FATAL_ERROR((0, 0, N_("file name contains null character"))); */
755 return file_list_zero;
756 }
757 obstack_1grow (stk, c);
758 counter++;
759 }
760
761 obstack_1grow (stk, 0);
762
763 return (counter == 0 && c == EOF) ? file_list_end : file_list_success;
764 }
765
766 \f
767 static bool files_from_option; /* When set, tar will not refuse to create
768 empty archives */
769 static struct obstack argv_stk; /* Storage for additional command line options
770 read using -T option */
771
772 /* Prevent recursive inclusion of the same file */
773 struct file_id_list
774 {
775 struct file_id_list *next;
776 ino_t ino;
777 dev_t dev;
778 };
779
780 static struct file_id_list *file_id_list;
781
782 static void
783 add_file_id (const char *filename)
784 {
785 struct file_id_list *p;
786 struct stat st;
787
788 if (stat (filename, &st))
789 stat_fatal (filename);
790 for (p = file_id_list; p; p = p->next)
791 if (p->ino == st.st_ino && p->dev == st.st_dev)
792 {
793 FATAL_ERROR ((0, 0, _("%s: file list already read"),
794 quotearg_colon (filename)));
795 }
796 p = xmalloc (sizeof *p);
797 p->next = file_id_list;
798 p->ino = st.st_ino;
799 p->dev = st.st_dev;
800 file_id_list = p;
801 }
802
803 /* Default density numbers for [0-9][lmh] device specifications */
804
805 #ifndef LOW_DENSITY_NUM
806 # define LOW_DENSITY_NUM 0
807 #endif
808
809 #ifndef MID_DENSITY_NUM
810 # define MID_DENSITY_NUM 8
811 #endif
812
813 #ifndef HIGH_DENSITY_NUM
814 # define HIGH_DENSITY_NUM 16
815 #endif
816
817 static void
818 update_argv (const char *filename, struct argp_state *state)
819 {
820 FILE *fp;
821 size_t count = 0, i;
822 char *start, *p;
823 char **new_argv;
824 size_t new_argc;
825 bool is_stdin = false;
826 enum read_file_list_state read_state;
827
828 if (!strcmp (filename, "-"))
829 {
830 is_stdin = true;
831 request_stdin ("-T");
832 fp = stdin;
833 }
834 else
835 {
836 add_file_id (filename);
837 if ((fp = fopen (filename, "r")) == NULL)
838 open_fatal (filename);
839 }
840
841 while ((read_state = read_name_from_file (fp, &argv_stk)) == file_list_success)
842 count++;
843
844 if (read_state == file_list_zero)
845 {
846 size_t size;
847
848 WARN ((0, 0, N_("%s: file name read contains nul character"),
849 quotearg_colon (filename)));
850
851 /* Prepare new stack contents */
852 size = obstack_object_size (&argv_stk);
853 p = obstack_finish (&argv_stk);
854 for (; size > 0; size--, p++)
855 if (*p)
856 obstack_1grow (&argv_stk, *p);
857 else
858 obstack_1grow (&argv_stk, '\n');
859 obstack_1grow (&argv_stk, 0);
860 count = 1;
861
862 /* Read rest of files using new filename terminator */
863 filename_terminator = 0;
864 while (read_name_from_file (fp, &argv_stk) == file_list_success)
865 count++;
866 }
867
868 if (!is_stdin)
869 fclose (fp);
870
871 if (count == 0)
872 return;
873
874 start = obstack_finish (&argv_stk);
875
876 if (filename_terminator == 0)
877 for (p = start; *p; p += strlen (p) + 1)
878 if (p[0] == '-')
879 count++;
880
881 new_argc = state->argc + count;
882 new_argv = xmalloc (sizeof (state->argv[0]) * (new_argc + 1));
883 memcpy (new_argv, state->argv, sizeof (state->argv[0]) * (state->argc + 1));
884 state->argv = new_argv;
885 memmove (&state->argv[state->next + count], &state->argv[state->next],
886 (state->argc - state->next + 1) * sizeof (state->argv[0]));
887
888 state->argc = new_argc;
889
890 for (i = state->next, p = start; *p; p += strlen (p) + 1, i++)
891 {
892 if (filename_terminator == 0 && p[0] == '-')
893 state->argv[i++] = "--add-file";
894 state->argv[i] = p;
895 }
896 }
897
898 \f
899 static error_t
900 parse_opt (int key, char *arg, struct argp_state *state)
901 {
902 struct tar_args *args = state->input;
903
904 switch (key)
905 {
906 case ARGP_KEY_ARG:
907 /* File name or non-parsed option, because of ARGP_IN_ORDER */
908 name_add (arg);
909 args->input_files++;
910 break;
911
912 case 'A':
913 set_subcommand_option (CAT_SUBCOMMAND);
914 break;
915
916 case 'b':
917 {
918 uintmax_t u;
919 if (! (xstrtoumax (arg, 0, 10, &u, "") == LONGINT_OK
920 && u == (blocking_factor = u)
921 && 0 < blocking_factor
922 && u == (record_size = u * BLOCKSIZE) / BLOCKSIZE))
923 USAGE_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
924 _("Invalid blocking factor")));
925 }
926 break;
927
928 case 'B':
929 /* Try to reblock input records. For reading 4.2BSD pipes. */
930
931 /* It would surely make sense to exchange -B and -R, but it seems
932 that -B has been used for a long while in Sun tar and most
933 BSD-derived systems. This is a consequence of the block/record
934 terminology confusion. */
935
936 read_full_records_option = true;
937 break;
938
939 case 'c':
940 set_subcommand_option (CREATE_SUBCOMMAND);
941 break;
942
943 case 'C':
944 name_add ("-C");
945 name_add (arg);
946 break;
947
948 case 'd':
949 set_subcommand_option (DIFF_SUBCOMMAND);
950 break;
951
952 case 'f':
953 if (archive_names == allocated_archive_names)
954 {
955 allocated_archive_names *= 2;
956 archive_name_array =
957 xrealloc (archive_name_array,
958 sizeof (const char *) * allocated_archive_names);
959 }
960 archive_name_array[archive_names++] = arg;
961 break;
962
963 case 'F':
964 /* Since -F is only useful with -M, make it implied. Run this
965 script at the end of each tape. */
966
967 info_script_option = arg;
968 multi_volume_option = true;
969 break;
970
971 case 'g':
972 listed_incremental_option = arg;
973 after_date_option = true;
974 /* Fall through. */
975
976 case 'G':
977 /* We are making an incremental dump (FIXME: are we?); save
978 directories at the beginning of the archive, and include in each
979 directory its contents. */
980
981 incremental_option = true;
982 break;
983
984 case 'h':
985 /* Follow symbolic links. */
986 dereference_option = true;
987 break;
988
989 case 'i':
990 /* Ignore zero blocks (eofs). This can't be the default,
991 because Unix tar writes two blocks of zeros, then pads out
992 the record with garbage. */
993
994 ignore_zeros_option = true;
995 break;
996
997 case 'I':
998 USAGE_ERROR ((0, 0,
999 _("Warning: the -I option is not supported;"
1000 " perhaps you meant -j or -T?")));
1001 break;
1002
1003 case 'j':
1004 set_use_compress_program_option ("bzip2");
1005 break;
1006
1007 case 'k':
1008 /* Don't replace existing files. */
1009 old_files_option = KEEP_OLD_FILES;
1010 break;
1011
1012 case 'K':
1013 starting_file_option = true;
1014 addname (arg, 0);
1015 break;
1016
1017 case 'l':
1018 /* Historically equivalent to --one-file-system. This usage is
1019 incompatible with UNIX98 and POSIX specs and therefore is
1020 deprecated. The semantics of -l option will be changed in
1021 future versions. See TODO.
1022 */
1023 WARN ((0, 0,
1024 _("Semantics of -l option will change in the future releases.")));
1025 WARN ((0, 0,
1026 _("Please use --one-file-system option instead.")));
1027 /* FALL THROUGH */
1028 case ONE_FILE_SYSTEM_OPTION:
1029 /* When dumping directories, don't dump files/subdirectories
1030 that are on other filesystems. */
1031 one_file_system_option = true;
1032 break;
1033
1034 case 'L':
1035 {
1036 uintmax_t u;
1037 if (xstrtoumax (arg, 0, 10, &u, "") != LONGINT_OK)
1038 USAGE_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
1039 _("Invalid tape length")));
1040 tape_length_option = 1024 * (tarlong) u;
1041 multi_volume_option = true;
1042 }
1043 break;
1044
1045 case 'm':
1046 touch_option = true;
1047 break;
1048
1049 case 'M':
1050 /* Make multivolume archive: when we can't write any more into
1051 the archive, re-open it, and continue writing. */
1052
1053 multi_volume_option = true;
1054 break;
1055
1056 case 'n':
1057 seekable_archive = true;
1058 break;
1059
1060 case 'N':
1061 after_date_option = true;
1062 /* Fall through. */
1063
1064 case NEWER_MTIME_OPTION:
1065 if (NEWER_OPTION_INITIALIZED (newer_mtime_option))
1066 USAGE_ERROR ((0, 0, _("More than one threshold date")));
1067
1068 if (FILE_SYSTEM_PREFIX_LEN (arg) != 0
1069 || ISSLASH (*arg)
1070 || *arg == '.')
1071 {
1072 struct stat st;
1073 if (deref_stat (dereference_option, arg, &st) != 0)
1074 {
1075 stat_error (arg);
1076 USAGE_ERROR ((0, 0, _("Date sample file not found")));
1077 }
1078 newer_mtime_option = get_stat_mtime (&st);
1079 }
1080 else
1081 {
1082 if (! get_date (&newer_mtime_option, arg, NULL))
1083 {
1084 WARN ((0, 0, _("Substituting %s for unknown date format %s"),
1085 tartime (newer_mtime_option, false), quote (arg)));
1086 newer_mtime_option.tv_nsec = 0;
1087 }
1088 else
1089 args->textual_date_option = arg;
1090 }
1091
1092 break;
1093
1094 case 'o':
1095 args->o_option = true;
1096 break;
1097
1098 case 'O':
1099 to_stdout_option = true;
1100 break;
1101
1102 case 'p':
1103 same_permissions_option = true;
1104 break;
1105
1106 case 'P':
1107 absolute_names_option = true;
1108 break;
1109
1110 case 'r':
1111 set_subcommand_option (APPEND_SUBCOMMAND);
1112 break;
1113
1114 case 'R':
1115 /* Print block numbers for debugging bad tar archives. */
1116
1117 /* It would surely make sense to exchange -B and -R, but it seems
1118 that -B has been used for a long while in Sun tar ans most
1119 BSD-derived systems. This is a consequence of the block/record
1120 terminology confusion. */
1121
1122 block_number_option = true;
1123 break;
1124
1125 case 's':
1126 /* Names to extr are sorted. */
1127
1128 same_order_option = true;
1129 break;
1130
1131 case 'S':
1132 sparse_option = true;
1133 break;
1134
1135 case 't':
1136 set_subcommand_option (LIST_SUBCOMMAND);
1137 verbose_option++;
1138 break;
1139
1140 case TEST_LABEL_OPTION:
1141 set_subcommand_option (LIST_SUBCOMMAND);
1142 test_label_option = true;
1143 break;
1144
1145 case 'T':
1146 update_argv (arg, state);
1147 /* Indicate we've been given -T option. This is for backward
1148 compatibility only, so that `tar cfT archive /dev/null will
1149 succeed */
1150 files_from_option = true;
1151 break;
1152
1153 case 'u':
1154 set_subcommand_option (UPDATE_SUBCOMMAND);
1155 break;
1156
1157 case 'U':
1158 old_files_option = UNLINK_FIRST_OLD_FILES;
1159 break;
1160
1161 case UTC_OPTION:
1162 utc_option = true;
1163 break;
1164
1165 case 'v':
1166 verbose_option++;
1167 break;
1168
1169 case 'V':
1170 volume_label_option = arg;
1171 break;
1172
1173 case 'w':
1174 interactive_option = true;
1175 break;
1176
1177 case 'W':
1178 verify_option = true;
1179 break;
1180
1181 case 'x':
1182 set_subcommand_option (EXTRACT_SUBCOMMAND);
1183 break;
1184
1185 case 'X':
1186 if (add_exclude_file (add_exclude, excluded, arg,
1187 args->exclude_options | recursion_option, '\n')
1188 != 0)
1189 {
1190 int e = errno;
1191 FATAL_ERROR ((0, e, "%s", quotearg_colon (arg)));
1192 }
1193 break;
1194
1195 case 'z':
1196 set_use_compress_program_option ("gzip");
1197 break;
1198
1199 case 'Z':
1200 set_use_compress_program_option ("compress");
1201 break;
1202
1203 case ANCHORED_OPTION:
1204 args->exclude_options |= EXCLUDE_ANCHORED;
1205 break;
1206
1207 case ATIME_PRESERVE_OPTION:
1208 atime_preserve_option =
1209 (arg
1210 ? XARGMATCH ("--atime-preserve", arg,
1211 atime_preserve_args, atime_preserve_types)
1212 : replace_atime_preserve);
1213 if (! O_NOATIME && atime_preserve_option == system_atime_preserve)
1214 FATAL_ERROR ((0, 0,
1215 _("--atime-preserve='system' is not supported"
1216 " on this platform")));
1217 break;
1218
1219 case CHECKPOINT_OPTION:
1220 checkpoint_option = true;
1221 break;
1222
1223 case BACKUP_OPTION:
1224 backup_option = true;
1225 if (arg)
1226 args->version_control_string = arg;
1227 break;
1228
1229 case DELETE_OPTION:
1230 set_subcommand_option (DELETE_SUBCOMMAND);
1231 break;
1232
1233 case EXCLUDE_OPTION:
1234 add_exclude (excluded, arg, args->exclude_options | recursion_option);
1235 break;
1236
1237 case EXCLUDE_CACHES_OPTION:
1238 exclude_caches_option = true;
1239 break;
1240
1241 case FORCE_LOCAL_OPTION:
1242 force_local_option = true;
1243 break;
1244
1245 case 'H':
1246 set_archive_format (arg);
1247 break;
1248
1249 case INDEX_FILE_OPTION:
1250 index_file_name = arg;
1251 break;
1252
1253 case IGNORE_CASE_OPTION:
1254 args->exclude_options |= FNM_CASEFOLD;
1255 break;
1256
1257 case IGNORE_COMMAND_ERROR_OPTION:
1258 ignore_command_error_option = true;
1259 break;
1260
1261 case IGNORE_FAILED_READ_OPTION:
1262 ignore_failed_read_option = true;
1263 break;
1264
1265 case KEEP_NEWER_FILES_OPTION:
1266 old_files_option = KEEP_NEWER_FILES;
1267 break;
1268
1269 case GROUP_OPTION:
1270 if (! (strlen (arg) < GNAME_FIELD_SIZE
1271 && gname_to_gid (arg, &group_option)))
1272 {
1273 uintmax_t g;
1274 if (xstrtoumax (arg, 0, 10, &g, "") == LONGINT_OK
1275 && g == (gid_t) g)
1276 group_option = g;
1277 else
1278 FATAL_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
1279 _("%s: Invalid group")));
1280 }
1281 break;
1282
1283 case MODE_OPTION:
1284 mode_option = mode_compile (arg);
1285 if (!mode_option)
1286 FATAL_ERROR ((0, 0, _("Invalid mode given on option")));
1287 initial_umask = umask (0);
1288 umask (initial_umask);
1289 break;
1290
1291 case NO_ANCHORED_OPTION:
1292 args->exclude_options &= ~ EXCLUDE_ANCHORED;
1293 break;
1294
1295 case NO_IGNORE_CASE_OPTION:
1296 args->exclude_options &= ~ FNM_CASEFOLD;
1297 break;
1298
1299 case NO_IGNORE_COMMAND_ERROR_OPTION:
1300 ignore_command_error_option = false;
1301 break;
1302
1303 case NO_OVERWRITE_DIR_OPTION:
1304 old_files_option = NO_OVERWRITE_DIR_OLD_FILES;
1305 break;
1306
1307 case NO_WILDCARDS_OPTION:
1308 args->exclude_options &= ~ EXCLUDE_WILDCARDS;
1309 break;
1310
1311 case NO_WILDCARDS_MATCH_SLASH_OPTION:
1312 args->exclude_options |= FNM_FILE_NAME;
1313 break;
1314
1315 case NULL_OPTION:
1316 filename_terminator = '\0';
1317 break;
1318
1319 case NUMERIC_OWNER_OPTION:
1320 numeric_owner_option = true;
1321 break;
1322
1323 case OCCURRENCE_OPTION:
1324 if (!arg)
1325 occurrence_option = 1;
1326 else
1327 {
1328 uintmax_t u;
1329 if (xstrtoumax (arg, 0, 10, &u, "") == LONGINT_OK)
1330 occurrence_option = u;
1331 else
1332 FATAL_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
1333 _("Invalid number")));
1334 }
1335 break;
1336
1337 case OVERWRITE_OPTION:
1338 old_files_option = OVERWRITE_OLD_FILES;
1339 break;
1340
1341 case OWNER_OPTION:
1342 if (! (strlen (arg) < UNAME_FIELD_SIZE
1343 && uname_to_uid (arg, &owner_option)))
1344 {
1345 uintmax_t u;
1346 if (xstrtoumax (arg, 0, 10, &u, "") == LONGINT_OK
1347 && u == (uid_t) u)
1348 owner_option = u;
1349 else
1350 FATAL_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
1351 _("Invalid owner")));
1352 }
1353 break;
1354
1355 case PAX_OPTION:
1356 args->pax_option++;
1357 xheader_set_option (arg);
1358 break;
1359
1360 case POSIX_OPTION:
1361 set_archive_format ("posix");
1362 break;
1363
1364 case PRESERVE_OPTION:
1365 same_permissions_option = true;
1366 same_order_option = true;
1367 break;
1368
1369 case RECORD_SIZE_OPTION:
1370 {
1371 uintmax_t u;
1372 if (! (xstrtoumax (arg, 0, 10, &u, "") == LONGINT_OK
1373 && u == (size_t) u))
1374 USAGE_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
1375 _("Invalid record size")));
1376 record_size = u;
1377 if (record_size % BLOCKSIZE != 0)
1378 USAGE_ERROR ((0, 0, _("Record size must be a multiple of %d."),
1379 BLOCKSIZE));
1380 blocking_factor = record_size / BLOCKSIZE;
1381 }
1382 break;
1383
1384 case RECURSIVE_UNLINK_OPTION:
1385 recursive_unlink_option = true;
1386 break;
1387
1388 case REMOVE_FILES_OPTION:
1389 remove_files_option = true;
1390 break;
1391
1392 case RESTRICT_OPTION:
1393 restrict_option = true;
1394 break;
1395
1396 case RMT_COMMAND_OPTION:
1397 rmt_command = arg;
1398 break;
1399
1400 case RSH_COMMAND_OPTION:
1401 rsh_command_option = arg;
1402 break;
1403
1404 case SHOW_DEFAULTS_OPTION:
1405 show_default_settings (stdout);
1406 exit(0);
1407
1408 case STRIP_COMPONENTS_OPTION:
1409 {
1410 uintmax_t u;
1411 if (! (xstrtoumax (arg, 0, 10, &u, "") == LONGINT_OK
1412 && u == (size_t) u))
1413 USAGE_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
1414 _("Invalid number of elements")));
1415 strip_name_components = u;
1416 }
1417 break;
1418
1419 case SHOW_OMITTED_DIRS_OPTION:
1420 show_omitted_dirs_option = true;
1421 break;
1422
1423 case SHOW_STORED_NAMES_OPTION:
1424 show_stored_names_option = true;
1425 break;
1426
1427 case SUFFIX_OPTION:
1428 backup_option = true;
1429 args->backup_suffix_string = arg;
1430 break;
1431
1432 case TO_COMMAND_OPTION:
1433 if (to_command_option)
1434 USAGE_ERROR ((0, 0, _("Only one --to-command option allowed")));
1435 to_command_option = arg;
1436 break;
1437
1438 case TOTALS_OPTION:
1439 totals_option = true;
1440 break;
1441
1442 case USE_COMPRESS_PROGRAM_OPTION:
1443 set_use_compress_program_option (arg);
1444 break;
1445
1446 case VOLNO_FILE_OPTION:
1447 volno_file_option = arg;
1448 break;
1449
1450 case WILDCARDS_OPTION:
1451 args->exclude_options |= EXCLUDE_WILDCARDS;
1452 break;
1453
1454 case WILDCARDS_MATCH_SLASH_OPTION:
1455 args->exclude_options &= ~ FNM_FILE_NAME;
1456 break;
1457
1458 case CHECK_LINKS_OPTION:
1459 check_links_option = 1;
1460 break;
1461
1462 case NO_RECURSION_OPTION:
1463 recursion_option = 0;
1464 break;
1465
1466 case NO_SAME_OWNER_OPTION:
1467 same_owner_option = -1;
1468 break;
1469
1470 case NO_SAME_PERMISSIONS_OPTION:
1471 same_permissions_option = -1;
1472 break;
1473
1474 case RECURSION_OPTION:
1475 recursion_option = FNM_LEADING_DIR;
1476 break;
1477
1478 case SAME_OWNER_OPTION:
1479 same_owner_option = 1;
1480 break;
1481
1482 case UNQUOTE_OPTION:
1483 unquote_option = true;
1484 break;
1485
1486 case NO_UNQUOTE_OPTION:
1487 unquote_option = false;
1488 break;
1489
1490 case '0':
1491 case '1':
1492 case '2':
1493 case '3':
1494 case '4':
1495 case '5':
1496 case '6':
1497 case '7':
1498
1499 #ifdef DEVICE_PREFIX
1500 {
1501 int device = key - '0';
1502 int density;
1503 static char buf[sizeof DEVICE_PREFIX + 10];
1504 char *cursor;
1505
1506 if (arg[1])
1507 argp_error (state, _("Malformed density argument: %s"), quote (arg));
1508
1509 strcpy (buf, DEVICE_PREFIX);
1510 cursor = buf + strlen (buf);
1511
1512 #ifdef DENSITY_LETTER
1513
1514 sprintf (cursor, "%d%c", device, arg[0]);
1515
1516 #else /* not DENSITY_LETTER */
1517
1518 switch (arg[0])
1519 {
1520 case 'l':
1521 device += LOW_DENSITY_NUM;
1522 break;
1523
1524 case 'm':
1525 device += MID_DENSITY_NUM;
1526 break;
1527
1528 case 'h':
1529 device += HIGH_DENSITY_NUM;
1530 break;
1531
1532 default:
1533 argp_error (state, _("Unknown density: `%c'"), arg[0]);
1534 }
1535 sprintf (cursor, "%d", device);
1536
1537 #endif /* not DENSITY_LETTER */
1538
1539 if (archive_names == allocated_archive_names)
1540 {
1541 allocated_archive_names *= 2;
1542 archive_name_array =
1543 xrealloc (archive_name_array,
1544 sizeof (const char *) * allocated_archive_names);
1545 }
1546 archive_name_array[archive_names++] = xstrdup (buf);
1547 }
1548 break;
1549
1550 #else /* not DEVICE_PREFIX */
1551
1552 argp_error (state,
1553 _("Options `-[0-7][lmh]' not supported by *this* tar"));
1554
1555 #endif /* not DEVICE_PREFIX */
1556
1557 case '?':
1558 state->flags |= ARGP_NO_EXIT;
1559 argp_state_help (state, state->out_stream,
1560 ARGP_HELP_STD_HELP & ~ARGP_HELP_BUG_ADDR);
1561 fprintf (state->out_stream, _("\n*This* tar defaults to:\n"));
1562 show_default_settings (state->out_stream);
1563 fprintf (state->out_stream, "\n");
1564 fprintf (state->out_stream, _("Report bugs to %s.\n"),
1565 argp_program_bug_address);
1566 exit (0);
1567
1568 case USAGE_OPTION:
1569 argp_state_help (state, state->out_stream,
1570 ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
1571 break;
1572
1573 case VERSION_OPTION:
1574 fprintf (state->out_stream, "%s\n", argp_program_version);
1575 exit (0);
1576
1577 case LICENSE_OPTION:
1578 license ();
1579 break;
1580
1581 case HANG_OPTION:
1582 _argp_hang = atoi (arg ? arg : "3600");
1583 while (_argp_hang-- > 0)
1584 sleep (1);
1585 break;
1586
1587 default:
1588 return ARGP_ERR_UNKNOWN;
1589 }
1590 return 0;
1591 }
1592
1593 static struct argp argp = {
1594 options,
1595 parse_opt,
1596 N_("[FILE]..."),
1597 doc,
1598 NULL,
1599 NULL,
1600 NULL
1601 };
1602
1603 void
1604 usage (int status)
1605 {
1606 argp_help (&argp, stderr, ARGP_HELP_SEE, (char*) program_name);
1607 exit (status);
1608 }
1609
1610 /* Parse the options for tar. */
1611
1612 static struct argp_option *
1613 find_argp_option (struct argp_option *options, int letter)
1614 {
1615 for (;
1616 !(options->name == NULL
1617 && options->key == 0
1618 && options->arg == 0
1619 && options->flags == 0
1620 && options->doc == NULL); options++)
1621 if (options->key == letter)
1622 return options;
1623 return NULL;
1624 }
1625
1626 static void
1627 decode_options (int argc, char **argv)
1628 {
1629 int index;
1630 struct tar_args args;
1631
1632 /* Set some default option values. */
1633 args.textual_date_option = NULL;
1634 args.exclude_options = EXCLUDE_WILDCARDS;
1635 args.o_option = 0;
1636 args.pax_option = 0;
1637 args.backup_suffix_string = getenv ("SIMPLE_BACKUP_SUFFIX");
1638 args.version_control_string = 0;
1639 args.input_files = 0;
1640
1641 subcommand_option = UNKNOWN_SUBCOMMAND;
1642 archive_format = DEFAULT_FORMAT;
1643 blocking_factor = DEFAULT_BLOCKING;
1644 record_size = DEFAULT_BLOCKING * BLOCKSIZE;
1645 excluded = new_exclude ();
1646 newer_mtime_option.tv_sec = TYPE_MINIMUM (time_t);
1647 newer_mtime_option.tv_nsec = -1;
1648 recursion_option = FNM_LEADING_DIR;
1649 unquote_option = true;
1650
1651 owner_option = -1;
1652 group_option = -1;
1653
1654 /* Convert old-style tar call by exploding option element and rearranging
1655 options accordingly. */
1656
1657 if (argc > 1 && argv[1][0] != '-')
1658 {
1659 int new_argc; /* argc value for rearranged arguments */
1660 char **new_argv; /* argv value for rearranged arguments */
1661 char *const *in; /* cursor into original argv */
1662 char **out; /* cursor into rearranged argv */
1663 const char *letter; /* cursor into old option letters */
1664 char buffer[3]; /* constructed option buffer */
1665
1666 /* Initialize a constructed option. */
1667
1668 buffer[0] = '-';
1669 buffer[2] = '\0';
1670
1671 /* Allocate a new argument array, and copy program name in it. */
1672
1673 new_argc = argc - 1 + strlen (argv[1]);
1674 new_argv = xmalloc ((new_argc + 1) * sizeof (char *));
1675 in = argv;
1676 out = new_argv;
1677 *out++ = *in++;
1678
1679 /* Copy each old letter option as a separate option, and have the
1680 corresponding argument moved next to it. */
1681
1682 for (letter = *in++; *letter; letter++)
1683 {
1684 struct argp_option *opt;
1685
1686 buffer[1] = *letter;
1687 *out++ = xstrdup (buffer);
1688 opt = find_argp_option (options, *letter);
1689 if (opt && opt->arg)
1690 {
1691 if (in < argv + argc)
1692 *out++ = *in++;
1693 else
1694 USAGE_ERROR ((0, 0, _("Old option `%c' requires an argument."),
1695 *letter));
1696 }
1697 }
1698
1699 /* Copy all remaining options. */
1700
1701 while (in < argv + argc)
1702 *out++ = *in++;
1703 *out = 0;
1704
1705 /* Replace the old option list by the new one. */
1706
1707 argc = new_argc;
1708 argv = new_argv;
1709 }
1710
1711 /* Parse all options and non-options as they appear. */
1712
1713 prepend_default_options (getenv ("TAR_OPTIONS"), &argc, &argv);
1714
1715 if (argp_parse (&argp, argc, argv, ARGP_IN_ORDER|ARGP_NO_HELP,
1716 &index, &args))
1717 exit (1);
1718
1719
1720 /* Special handling for 'o' option:
1721
1722 GNU tar used to say "output old format".
1723 UNIX98 tar says don't chown files after extracting (we use
1724 "--no-same-owner" for this).
1725
1726 The old GNU tar semantics is retained when used with --create
1727 option, otherwise UNIX98 semantics is assumed */
1728
1729 if (args.o_option)
1730 {
1731 if (subcommand_option == CREATE_SUBCOMMAND)
1732 {
1733 /* GNU Tar <= 1.13 compatibility */
1734 set_archive_format ("v7");
1735 }
1736 else
1737 {
1738 /* UNIX98 compatibility */
1739 same_owner_option = -1;
1740 }
1741 }
1742
1743 /* Handle operands after any "--" argument. */
1744 for (; index < argc; index++)
1745 {
1746 name_add (argv[index]);
1747 args.input_files++;
1748 }
1749
1750 /* Derive option values and check option consistency. */
1751
1752 if (archive_format == DEFAULT_FORMAT)
1753 {
1754 if (args.pax_option)
1755 archive_format = POSIX_FORMAT;
1756 else
1757 archive_format = DEFAULT_ARCHIVE_FORMAT;
1758 }
1759
1760 if ((volume_label_option && subcommand_option == CREATE_SUBCOMMAND)
1761 || incremental_option
1762 || multi_volume_option
1763 || sparse_option)
1764 assert_format (FORMAT_MASK (OLDGNU_FORMAT)
1765 | FORMAT_MASK (GNU_FORMAT)
1766 | FORMAT_MASK (POSIX_FORMAT));
1767
1768 if (multi_volume_option
1769 && archive_format == POSIX_FORMAT
1770 && subcommand_option == CREATE_SUBCOMMAND
1771 && !tape_length_option)
1772 USAGE_ERROR ((0, 0,
1773 _("creating multi-volume archives in posix format requires using --tape-length (-L) option")));
1774
1775 if (occurrence_option)
1776 {
1777 if (!args.input_files)
1778 USAGE_ERROR ((0, 0,
1779 _("--occurrence is meaningless without a file list")));
1780 if (subcommand_option != DELETE_SUBCOMMAND
1781 && subcommand_option != DIFF_SUBCOMMAND
1782 && subcommand_option != EXTRACT_SUBCOMMAND
1783 && subcommand_option != LIST_SUBCOMMAND)
1784 USAGE_ERROR ((0, 0,
1785 _("--occurrence cannot be used in the requested operation mode")));
1786 }
1787
1788 if (seekable_archive && subcommand_option == DELETE_SUBCOMMAND)
1789 {
1790 /* The current code in delete.c is based on the assumption that
1791 skip_member() reads all data from the archive. So, we should
1792 make sure it won't use seeks. On the other hand, the same code
1793 depends on the ability to backspace a record in the archive,
1794 so setting seekable_archive to false is technically incorrect.
1795 However, it is tested only in skip_member(), so it's not a
1796 problem. */
1797 seekable_archive = false;
1798 }
1799
1800 if (archive_names == 0)
1801 {
1802 /* If no archive file name given, try TAPE from the environment, or
1803 else, DEFAULT_ARCHIVE from the configuration process. */
1804
1805 archive_names = 1;
1806 archive_name_array[0] = getenv ("TAPE");
1807 if (! archive_name_array[0])
1808 archive_name_array[0] = DEFAULT_ARCHIVE;
1809 }
1810
1811 /* Allow multiple archives only with `-M'. */
1812
1813 if (archive_names > 1 && !multi_volume_option)
1814 USAGE_ERROR ((0, 0,
1815 _("Multiple archive files require `-M' option")));
1816
1817 if (listed_incremental_option
1818 && NEWER_OPTION_INITIALIZED (newer_mtime_option))
1819 USAGE_ERROR ((0, 0,
1820 _("Cannot combine --listed-incremental with --newer")));
1821
1822 if (volume_label_option)
1823 {
1824 if (archive_format == GNU_FORMAT || archive_format == OLDGNU_FORMAT)
1825 {
1826 size_t volume_label_max_len =
1827 (sizeof current_header->header.name
1828 - 1 /* for trailing '\0' */
1829 - (multi_volume_option
1830 ? (sizeof " Volume "
1831 - 1 /* for null at end of " Volume " */
1832 + INT_STRLEN_BOUND (int) /* for volume number */
1833 - 1 /* for sign, as 0 <= volno */)
1834 : 0));
1835 if (volume_label_max_len < strlen (volume_label_option))
1836 USAGE_ERROR ((0, 0,
1837 ngettext ("%s: Volume label is too long (limit is %lu byte)",
1838 "%s: Volume label is too long (limit is %lu bytes)",
1839 volume_label_max_len),
1840 quotearg_colon (volume_label_option),
1841 (unsigned long) volume_label_max_len));
1842 }
1843 /* else FIXME
1844 Label length in PAX format is limited by the volume size. */
1845 }
1846
1847 if (verify_option)
1848 {
1849 if (multi_volume_option)
1850 USAGE_ERROR ((0, 0, _("Cannot verify multi-volume archives")));
1851 if (use_compress_program_option)
1852 USAGE_ERROR ((0, 0, _("Cannot verify compressed archives")));
1853 }
1854
1855 if (use_compress_program_option)
1856 {
1857 if (multi_volume_option)
1858 USAGE_ERROR ((0, 0, _("Cannot use multi-volume compressed archives")));
1859 if (subcommand_option == UPDATE_SUBCOMMAND
1860 || subcommand_option == APPEND_SUBCOMMAND)
1861 USAGE_ERROR ((0, 0, _("Cannot update compressed archives")));
1862 if (subcommand_option == CAT_SUBCOMMAND)
1863 USAGE_ERROR ((0, 0, _("Cannot concatenate compressed archives")));
1864 }
1865
1866 /* It is no harm to use --pax-option on non-pax archives in archive
1867 reading mode. It may even be useful, since it allows to override
1868 file attributes from tar headers. Therefore I allow such usage.
1869 --gray */
1870 if (args.pax_option
1871 && archive_format != POSIX_FORMAT
1872 && (subcommand_option != EXTRACT_SUBCOMMAND
1873 || subcommand_option != DIFF_SUBCOMMAND
1874 || subcommand_option != LIST_SUBCOMMAND))
1875 USAGE_ERROR ((0, 0, _("--pax-option can be used only on POSIX archives")));
1876
1877 /* If ready to unlink hierarchies, so we are for simpler files. */
1878 if (recursive_unlink_option)
1879 old_files_option = UNLINK_FIRST_OLD_FILES;
1880
1881
1882 if (test_label_option)
1883 {
1884 /* --test-label is silent if the user has specified the label name to
1885 compare against. */
1886 if (args.input_files == 0)
1887 verbose_option++;
1888 }
1889 else if (utc_option)
1890 verbose_option = 2;
1891
1892 /* Forbid using -c with no input files whatsoever. Check that `-f -',
1893 explicit or implied, is used correctly. */
1894
1895 switch (subcommand_option)
1896 {
1897 case CREATE_SUBCOMMAND:
1898 if (args.input_files == 0 && !files_from_option)
1899 USAGE_ERROR ((0, 0,
1900 _("Cowardly refusing to create an empty archive")));
1901 break;
1902
1903 case EXTRACT_SUBCOMMAND:
1904 case LIST_SUBCOMMAND:
1905 case DIFF_SUBCOMMAND:
1906 for (archive_name_cursor = archive_name_array;
1907 archive_name_cursor < archive_name_array + archive_names;
1908 archive_name_cursor++)
1909 if (!strcmp (*archive_name_cursor, "-"))
1910 request_stdin ("-f");
1911 break;
1912
1913 case CAT_SUBCOMMAND:
1914 case UPDATE_SUBCOMMAND:
1915 case APPEND_SUBCOMMAND:
1916 for (archive_name_cursor = archive_name_array;
1917 archive_name_cursor < archive_name_array + archive_names;
1918 archive_name_cursor++)
1919 if (!strcmp (*archive_name_cursor, "-"))
1920 USAGE_ERROR ((0, 0,
1921 _("Options `-Aru' are incompatible with `-f -'")));
1922
1923 default:
1924 break;
1925 }
1926
1927 archive_name_cursor = archive_name_array;
1928
1929 /* Prepare for generating backup names. */
1930
1931 if (args.backup_suffix_string)
1932 simple_backup_suffix = xstrdup (args.backup_suffix_string);
1933
1934 if (backup_option)
1935 {
1936 backup_type = xget_version ("--backup", args.version_control_string);
1937 /* No backup is needed either if explicitely disabled or if
1938 the extracted files are not being written to disk. */
1939 if (backup_type == no_backups || EXTRACT_OVER_PIPE)
1940 backup_option = false;
1941 }
1942
1943 if (verbose_option && args.textual_date_option)
1944 {
1945 char const *treated_as = tartime (newer_mtime_option, true);
1946 if (strcmp (args.textual_date_option, treated_as) != 0)
1947 WARN ((0, 0, _("Treating date `%s' as %s"),
1948 args.textual_date_option, treated_as));
1949 }
1950 }
1951
1952 \f
1953 /* Tar proper. */
1954
1955 /* Main routine for tar. */
1956 int
1957 main (int argc, char **argv)
1958 {
1959 set_start_time ();
1960 program_name = argv[0];
1961
1962 setlocale (LC_ALL, "");
1963 bindtextdomain (PACKAGE, LOCALEDIR);
1964 textdomain (PACKAGE);
1965
1966 exit_status = TAREXIT_SUCCESS;
1967 filename_terminator = '\n';
1968 set_quoting_style (0, escape_quoting_style);
1969
1970 /* Make sure we have first three descriptors available */
1971 stdopen ();
1972
1973 /* Pre-allocate a few structures. */
1974
1975 allocated_archive_names = 10;
1976 archive_name_array =
1977 xmalloc (sizeof (const char *) * allocated_archive_names);
1978 archive_names = 0;
1979
1980 obstack_init (&argv_stk);
1981
1982 #ifdef SIGCHLD
1983 /* System V fork+wait does not work if SIGCHLD is ignored. */
1984 signal (SIGCHLD, SIG_DFL);
1985 #endif
1986
1987 init_names ();
1988
1989 /* Decode options. */
1990
1991 decode_options (argc, argv);
1992 name_init ();
1993
1994 /* Main command execution. */
1995
1996 if (volno_file_option)
1997 init_volume_number ();
1998
1999 switch (subcommand_option)
2000 {
2001 case UNKNOWN_SUBCOMMAND:
2002 USAGE_ERROR ((0, 0,
2003 _("You must specify one of the `-Acdtrux' options")));
2004
2005 case CAT_SUBCOMMAND:
2006 case UPDATE_SUBCOMMAND:
2007 case APPEND_SUBCOMMAND:
2008 update_archive ();
2009 break;
2010
2011 case DELETE_SUBCOMMAND:
2012 delete_archive_members ();
2013 break;
2014
2015 case CREATE_SUBCOMMAND:
2016 create_archive ();
2017 if (totals_option)
2018 print_total_written ();
2019 break;
2020
2021 case EXTRACT_SUBCOMMAND:
2022 extr_init ();
2023 read_and (extract_archive);
2024
2025 /* FIXME: should extract_finish () even if an ordinary signal is
2026 received. */
2027 extract_finish ();
2028
2029 break;
2030
2031 case LIST_SUBCOMMAND:
2032 read_and (list_archive);
2033 break;
2034
2035 case DIFF_SUBCOMMAND:
2036 diff_init ();
2037 read_and (diff_archive);
2038 break;
2039 }
2040
2041 if (check_links_option)
2042 check_links ();
2043
2044 if (volno_file_option)
2045 closeout_volume_number ();
2046
2047 /* Dispose of allocated memory, and return. */
2048
2049 free (archive_name_array);
2050 name_term ();
2051
2052 if (stdlis != stderr && (ferror (stdlis) || fclose (stdlis) != 0))
2053 FATAL_ERROR ((0, 0, _("Error in writing to standard output")));
2054 if (exit_status == TAREXIT_FAILURE)
2055 error (0, 0, _("Error exit delayed from previous errors"));
2056 if (ferror (stderr) || fclose (stderr) != 0)
2057 exit_status = TAREXIT_FAILURE;
2058 return exit_status;
2059 }
2060
2061 void
2062 tar_stat_init (struct tar_stat_info *st)
2063 {
2064 memset (st, 0, sizeof (*st));
2065 }
2066
2067 void
2068 tar_stat_destroy (struct tar_stat_info *st)
2069 {
2070 free (st->orig_file_name);
2071 free (st->file_name);
2072 free (st->link_name);
2073 free (st->uname);
2074 free (st->gname);
2075 free (st->sparse_map);
2076 free (st->dumpdir);
2077 memset (st, 0, sizeof (*st));
2078 }
2079
2080 /* Format mask for all available formats that support nanosecond
2081 timestamp resolution. */
2082 #define NS_PRECISION_FORMAT_MASK FORMAT_MASK (POSIX_FORMAT)
2083
2084 /* Same as timespec_cmp, but ignore nanoseconds if current archive
2085 format does not provide sufficient resolution. */
2086 int
2087 tar_timespec_cmp (struct timespec a, struct timespec b)
2088 {
2089 if (!(FORMAT_MASK (current_format) & NS_PRECISION_FORMAT_MASK))
2090 a.tv_nsec = b.tv_nsec = 0;
2091 return timespec_cmp (a, b);
2092 }
Unnamed repository; edit this file 'description' to name the repository.
This page took 0.127639 seconds and 3 git commands to generate.