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