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