Dogcows Code - chaz/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, 2006, 2007, 2009 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 3, 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 #include <argp-namefrob.h>
  27 #include <argp-fmtstream.h>
  28 #include <argp-version-etc.h>
  29
  30 #include <signal.h>
  31 #if ! defined SIGCHLD && defined SIGCLD
  32 # define SIGCHLD SIGCLD
  33 #endif
  34
  35 /* The following causes "common.h" to produce definitions of all the global
  36    variables, rather than just "extern" declarations of them.  GNU tar does
  37    depend on the system loader to preset all GLOBAL variables to neutral (or
  38    zero) values; explicit initialization is usually not done.  */
  39 #define GLOBAL
  40 #include "common.h"
  41
  42 #include <argmatch.h>
  43 #include <closeout.h>
  44 #include <configmake.h>
  45 #include <exitfail.h>
  46 #include <getdate.h>
  47 #include <rmt.h>
  48 #include <rmt-command.h>
  49 #include <prepargs.h>
  50 #include <quotearg.h>
  51 #include <version-etc.h>
  52 #include <xstrtol.h>
  53 #include <stdopen.h>
  54 #include <priv-set.h>
  55
  56 /* Local declarations.  */
  57
  58 #ifndef DEFAULT_ARCHIVE_FORMAT
  59 # define DEFAULT_ARCHIVE_FORMAT GNU_FORMAT
  60 #endif
  61
  62 #ifndef DEFAULT_ARCHIVE
  63 # define DEFAULT_ARCHIVE "tar.out"
  64 #endif
  65
  66 #ifndef DEFAULT_BLOCKING
  67 # define DEFAULT_BLOCKING 20
  68 #endif
  69
  70 \f
  71 /* Miscellaneous.  */
  72
  73 /* Name of option using stdin.  */
  74 static const char *stdin_used_by;
  75
  76 /* Doesn't return if stdin already requested.  */
  77 static void
  78 request_stdin (const char *option)
  79 {
  80   if (stdin_used_by)
  81     USAGE_ERROR ((0, 0, _("Options `-%s' and `-%s' both want standard input"),
  82                   stdin_used_by, option));
  83
  84   stdin_used_by = option;
  85 }
  86
  87 extern int rpmatch (char const *response);
  88
  89 /* Returns true if and only if the user typed an affirmative response.  */
  90 int
  91 confirm (const char *message_action, const char *message_name)
  92 {
  93   static FILE *confirm_file;
  94   static int confirm_file_EOF;
  95   bool status = false;
  96
  97   if (!confirm_file)
  98     {
  99       if (archive == 0 || stdin_used_by)
 100         {
 101           confirm_file = fopen (TTY_NAME, "r");
 102           if (! confirm_file)
 103             open_fatal (TTY_NAME);
 104         }
 105       else
 106         {
 107           request_stdin ("-w");
 108           confirm_file = stdin;
 109         }
 110     }
 111
 112   fprintf (stdlis, "%s %s?", message_action, quote (message_name));
 113   fflush (stdlis);
 114
 115   if (!confirm_file_EOF)
 116     {
 117       char *response = NULL;
 118       size_t response_size = 0;
 119       if (getline (&response, &response_size, confirm_file) < 0)
 120         confirm_file_EOF = 1;
 121       else
 122         status = rpmatch (response) > 0;
 123       free (response);
 124     }
 125
 126   if (confirm_file_EOF)
 127     {
 128       fputc ('\n', stdlis);
 129       fflush (stdlis);
 130     }
 131
 132   return status;
 133 }
 134
 135 static struct fmttab {
 136   char const *name;
 137   enum archive_format fmt;
 138 } const fmttab[] = {
 139   { "v7",      V7_FORMAT },
 140   { "oldgnu",  OLDGNU_FORMAT },
 141   { "ustar",   USTAR_FORMAT },
 142   { "posix",   POSIX_FORMAT },
 143 #if 0 /* not fully supported yet */
 144   { "star",    STAR_FORMAT },
 145 #endif
 146   { "gnu",     GNU_FORMAT },
 147   { "pax",     POSIX_FORMAT }, /* An alias for posix */
 148   { NULL,      0 }
 149 };
 150
 151 static void
 152 set_archive_format (char const *name)
 153 {
 154   struct fmttab const *p;
 155
 156   for (p = fmttab; strcmp (p->name, name) != 0; )
 157     if (! (++p)->name)
 158       USAGE_ERROR ((0, 0, _("%s: Invalid archive format"),
 159                     quotearg_colon (name)));
 160
 161   archive_format = p->fmt;
 162 }
 163
 164 const char *
 165 archive_format_string (enum archive_format fmt)
 166 {
 167   struct fmttab const *p;
 168
 169   for (p = fmttab; p->name; p++)
 170     if (p->fmt == fmt)
 171       return p->name;
 172   return "unknown?";
 173 }
 174
 175 #define FORMAT_MASK(n) (1<<(n))
 176
 177 static void
 178 assert_format(unsigned fmt_mask)
 179 {
 180   if ((FORMAT_MASK (archive_format) & fmt_mask) == 0)
 181     USAGE_ERROR ((0, 0,
 182                   _("GNU features wanted on incompatible archive format")));
 183 }
 184
 185 const char *
 186 subcommand_string (enum subcommand c)
 187 {
 188   switch (c)
 189     {
 190     case UNKNOWN_SUBCOMMAND:
 191       return "unknown?";
 192
 193     case APPEND_SUBCOMMAND:
 194       return "-r";
 195
 196     case CAT_SUBCOMMAND:
 197       return "-A";
 198
 199     case CREATE_SUBCOMMAND:
 200       return "-c";
 201
 202     case DELETE_SUBCOMMAND:
 203       return "-D";
 204
 205     case DIFF_SUBCOMMAND:
 206       return "-d";
 207
 208     case EXTRACT_SUBCOMMAND:
 209       return "-x";
 210
 211     case LIST_SUBCOMMAND:
 212       return "-t";
 213
 214     case UPDATE_SUBCOMMAND:
 215       return "-u";
 216
 217     case TEST_LABEL_SUBCOMMAND:
 218       return "--test-label";
 219     }
 220   abort ();
 221 }
 222
 223 static void
 224 tar_list_quoting_styles (struct obstack *stk, char const *prefix)
 225 {
 226   int i;
 227   size_t prefixlen = strlen (prefix);
 228
 229   for (i = 0; quoting_style_args[i]; i++)
 230     {
 231       obstack_grow (stk, prefix, prefixlen);
 232       obstack_grow (stk, quoting_style_args[i],
 233                     strlen (quoting_style_args[i]));
 234       obstack_1grow (stk, '\n');
 235     }
 236 }
 237
 238 static void
 239 tar_set_quoting_style (char *arg)
 240 {
 241   int i;
 242
 243   for (i = 0; quoting_style_args[i]; i++)
 244     if (strcmp (arg, quoting_style_args[i]) == 0)
 245       {
 246         set_quoting_style (NULL, i);
 247         return;
 248       }
 249   FATAL_ERROR ((0, 0,
 250                 _("Unknown quoting style `%s'. Try `%s --quoting-style=help' to get a list."), arg, program_invocation_short_name));
 251 }
 252
 253 \f
 254 /* Options.  */
 255
 256 enum
 257 {
 258   ANCHORED_OPTION = CHAR_MAX + 1,
 259   ATIME_PRESERVE_OPTION,
 260   BACKUP_OPTION,
 261   CHECK_DEVICE_OPTION,
 262   CHECKPOINT_OPTION,
 263   CHECKPOINT_ACTION_OPTION,
 264   DELAY_DIRECTORY_RESTORE_OPTION,
 265   HARD_DEREFERENCE_OPTION,
 266   DELETE_OPTION,
 267   EXCLUDE_BACKUPS_OPTION,
 268   EXCLUDE_CACHES_OPTION,
 269   EXCLUDE_CACHES_UNDER_OPTION,
 270   EXCLUDE_CACHES_ALL_OPTION,
 271   EXCLUDE_OPTION,
 272   EXCLUDE_TAG_OPTION,
 273   EXCLUDE_TAG_UNDER_OPTION,
 274   EXCLUDE_TAG_ALL_OPTION,
 275   EXCLUDE_VCS_OPTION,
 276   FORCE_LOCAL_OPTION,
 277   FULL_TIME_OPTION,
 278   GROUP_OPTION,
 279   IGNORE_CASE_OPTION,
 280   IGNORE_COMMAND_ERROR_OPTION,
 281   IGNORE_FAILED_READ_OPTION,
 282   INDEX_FILE_OPTION,
 283   KEEP_NEWER_FILES_OPTION,
 284   LEVEL_OPTION,
 285   LZIP_OPTION,
 286   LZMA_OPTION,
 287   LZOP_OPTION,
 288   MODE_OPTION,
 289   MTIME_OPTION,
 290   NEWER_MTIME_OPTION,
 291   NO_ANCHORED_OPTION,
 292   NO_AUTO_COMPRESS_OPTION,
 293   NO_CHECK_DEVICE_OPTION,
 294   NO_DELAY_DIRECTORY_RESTORE_OPTION,
 295   NO_IGNORE_CASE_OPTION,
 296   NO_IGNORE_COMMAND_ERROR_OPTION,
 297   NO_NULL_OPTION,
 298   NO_OVERWRITE_DIR_OPTION,
 299   NO_QUOTE_CHARS_OPTION,
 300   NO_RECURSION_OPTION,
 301   NO_SAME_OWNER_OPTION,
 302   NO_SAME_PERMISSIONS_OPTION,
 303   NO_SEEK_OPTION,
 304   NO_UNQUOTE_OPTION,
 305   NO_WILDCARDS_MATCH_SLASH_OPTION,
 306   NO_WILDCARDS_OPTION,
 307   NULL_OPTION,
 308   NUMERIC_OWNER_OPTION,
 309   OCCURRENCE_OPTION,
 310   OLD_ARCHIVE_OPTION,
 311   ONE_FILE_SYSTEM_OPTION,
 312   OVERWRITE_DIR_OPTION,
 313   OVERWRITE_OPTION,
 314   OWNER_OPTION,
 315   PAX_OPTION,
 316   POSIX_OPTION,
 317   PRESERVE_OPTION,
 318   QUOTE_CHARS_OPTION,
 319   QUOTING_STYLE_OPTION,
 320   RECORD_SIZE_OPTION,
 321   RECURSION_OPTION,
 322   RECURSIVE_UNLINK_OPTION,
 323   REMOVE_FILES_OPTION,
 324   RESTRICT_OPTION,
 325   RMT_COMMAND_OPTION,
 326   RSH_COMMAND_OPTION,
 327   SAME_OWNER_OPTION,
 328   SHOW_DEFAULTS_OPTION,
 329   SHOW_OMITTED_DIRS_OPTION,
 330   SHOW_TRANSFORMED_NAMES_OPTION,
 331   SPARSE_VERSION_OPTION,
 332   STRIP_COMPONENTS_OPTION,
 333   SUFFIX_OPTION,
 334   TEST_LABEL_OPTION,
 335   TOTALS_OPTION,
 336   TO_COMMAND_OPTION,
 337   TRANSFORM_OPTION,
 338   UNQUOTE_OPTION,
 339   UTC_OPTION,
 340   VOLNO_FILE_OPTION,
 341   WARNING_OPTION,
 342   WILDCARDS_MATCH_SLASH_OPTION,
 343   WILDCARDS_OPTION
 344 };
 345
 346 const char *argp_program_version = "tar (" PACKAGE_NAME ") " VERSION;
 347 const char *argp_program_bug_address = "<" PACKAGE_BUGREPORT ">";
 348 static char const doc[] = N_("\
 349 GNU `tar' saves many files together into a single tape or disk archive, \
 350 and can restore individual files from the archive.\n\
 351 \n\
 352 Examples:\n\
 353   tar -cf archive.tar foo bar  # Create archive.tar from files foo and bar.\n\
 354   tar -tvf archive.tar         # List all files in archive.tar verbosely.\n\
 355   tar -xf archive.tar          # Extract all files from archive.tar.\n")
 356 "\v"
 357 N_("The backup suffix is `~', unless set with --suffix or SIMPLE_BACKUP_SUFFIX.\n\
 358 The version control may be set with --backup or VERSION_CONTROL, values are:\n\n\
 359   none, off       never make backups\n\
 360   t, numbered     make numbered backups\n\
 361   nil, existing   numbered if numbered backups exist, simple otherwise\n\
 362   never, simple   always make simple backups\n");
 363
 364
 365 /* NOTE:
 366
 367    Available option letters are DEQY and eqy. Consider the following
 368    assignments:
 369
 370    [For Solaris tar compatibility =/= Is it important at all?]
 371    e  exit immediately with a nonzero exit status if unexpected errors occur
 372    E  use extended headers (--format=posix)
 373
 374    [q  alias for --occurrence=1 =/= this would better be used for quiet?]
 375
 376    y  per-file gzip compression
 377    Y  per-block gzip compression.
 378
 379    Additionally, the 'n' letter is assigned for option --seek, which
 380    is probably not needed and should be marked as deprecated, so that
 381    -n may become available in the future.
 382 */
 383
 384 static struct argp_option options[] = {
 385 #define GRID 10
 386   {NULL, 0, NULL, 0,
 387    N_("Main operation mode:"), GRID },
 388
 389   {"list", 't', 0, 0,
 390    N_("list the contents of an archive"), GRID+1 },
 391   {"extract", 'x', 0, 0,
 392    N_("extract files from an archive"), GRID+1 },
 393   {"get", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 394   {"create", 'c', 0, 0,
 395    N_("create a new archive"), GRID+1 },
 396   {"diff", 'd', 0, 0,
 397    N_("find differences between archive and file system"), GRID+1 },
 398   {"compare", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 399   {"append", 'r', 0, 0,
 400    N_("append files to the end of an archive"), GRID+1 },
 401   {"update", 'u', 0, 0,
 402    N_("only append files newer than copy in archive"), GRID+1 },
 403   {"catenate", 'A', 0, 0,
 404    N_("append tar files to an archive"), GRID+1 },
 405   {"concatenate", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 406   {"delete", DELETE_OPTION, 0, 0,
 407    N_("delete from the archive (not on mag tapes!)"), GRID+1 },
 408   {"test-label", TEST_LABEL_OPTION, NULL, 0,
 409    N_("test the archive volume label and exit"), GRID+1 },
 410 #undef GRID
 411
 412 #define GRID 20
 413   {NULL, 0, NULL, 0,
 414    N_("Operation modifiers:"), GRID },
 415
 416   {"sparse", 'S', 0, 0,
 417    N_("handle sparse files efficiently"), GRID+1 },
 418   {"sparse-version", SPARSE_VERSION_OPTION, N_("MAJOR[.MINOR]"), 0,
 419    N_("set version of the sparse format to use (implies --sparse)"), GRID+1},
 420   {"incremental", 'G', 0, 0,
 421    N_("handle old GNU-format incremental backup"), GRID+1 },
 422   {"listed-incremental", 'g', N_("FILE"), 0,
 423    N_("handle new GNU-format incremental backup"), GRID+1 },
 424   {"level", LEVEL_OPTION, N_("NUMBER"), 0,
 425    N_("dump level for created listed-incremental archive"), GRID+1 },
 426   {"ignore-failed-read", IGNORE_FAILED_READ_OPTION, 0, 0,
 427    N_("do not exit with nonzero on unreadable files"), GRID+1 },
 428   {"occurrence", OCCURRENCE_OPTION, N_("NUMBER"), OPTION_ARG_OPTIONAL,
 429    N_("process only the NUMBERth occurrence of each file in the archive;"
 430       " this option is valid only in conjunction with one of the subcommands"
 431       " --delete, --diff, --extract or --list and when a list of files"
 432       " is given either on the command line or via the -T option;"
 433       " NUMBER defaults to 1"), GRID+1 },
 434   {"seek", 'n', NULL, 0,
 435    N_("archive is seekable"), GRID+1 },
 436   {"no-seek", NO_SEEK_OPTION, NULL, 0,
 437    N_("archive is not seekable"), GRID+1 },
 438   {"no-check-device", NO_CHECK_DEVICE_OPTION, NULL, 0,
 439    N_("do not check device numbers when creating incremental archives"),
 440    GRID+1 },
 441   {"check-device", CHECK_DEVICE_OPTION, NULL, 0,
 442    N_("check device numbers when creating incremental archives (default)"),
 443    GRID+1 },
 444 #undef GRID
 445
 446 #define GRID 30
 447   {NULL, 0, NULL, 0,
 448    N_("Overwrite control:"), GRID },
 449
 450   {"verify", 'W', 0, 0,
 451    N_("attempt to verify the archive after writing it"), GRID+1 },
 452   {"remove-files", REMOVE_FILES_OPTION, 0, 0,
 453    N_("remove files after adding them to the archive"), GRID+1 },
 454   {"keep-old-files", 'k', 0, 0,
 455    N_("don't replace existing files when extracting"), GRID+1 },
 456   {"keep-newer-files", KEEP_NEWER_FILES_OPTION, 0, 0,
 457    N_("don't replace existing files that are newer than their archive copies"), GRID+1 },
 458   {"overwrite", OVERWRITE_OPTION, 0, 0,
 459    N_("overwrite existing files when extracting"), GRID+1 },
 460   {"unlink-first", 'U', 0, 0,
 461    N_("remove each file prior to extracting over it"), GRID+1 },
 462   {"recursive-unlink", RECURSIVE_UNLINK_OPTION, 0, 0,
 463    N_("empty hierarchies prior to extracting directory"), GRID+1 },
 464   {"no-overwrite-dir", NO_OVERWRITE_DIR_OPTION, 0, 0,
 465    N_("preserve metadata of existing directories"), GRID+1 },
 466   {"overwrite-dir", OVERWRITE_DIR_OPTION, 0, 0,
 467    N_("overwrite metadata of existing directories when extracting (default)"),
 468    GRID+1 },
 469 #undef GRID
 470
 471 #define GRID 40
 472   {NULL, 0, NULL, 0,
 473    N_("Select output stream:"), GRID },
 474
 475   {"to-stdout", 'O', 0, 0,
 476    N_("extract files to standard output"), GRID+1 },
 477   {"to-command", TO_COMMAND_OPTION, N_("COMMAND"), 0,
 478    N_("pipe extracted files to another program"), GRID+1 },
 479   {"ignore-command-error", IGNORE_COMMAND_ERROR_OPTION, 0, 0,
 480    N_("ignore exit codes of children"), GRID+1 },
 481   {"no-ignore-command-error", NO_IGNORE_COMMAND_ERROR_OPTION, 0, 0,
 482    N_("treat non-zero exit codes of children as error"), GRID+1 },
 483 #undef GRID
 484
 485 #define GRID 50
 486   {NULL, 0, NULL, 0,
 487    N_("Handling of file attributes:"), GRID },
 488
 489   {"owner", OWNER_OPTION, N_("NAME"), 0,
 490    N_("force NAME as owner for added files"), GRID+1 },
 491   {"group", GROUP_OPTION, N_("NAME"), 0,
 492    N_("force NAME as group for added files"), GRID+1 },
 493   {"mtime", MTIME_OPTION, N_("DATE-OR-FILE"), 0,
 494    N_("set mtime for added files from DATE-OR-FILE"), GRID+1 },
 495   {"mode", MODE_OPTION, N_("CHANGES"), 0,
 496    N_("force (symbolic) mode CHANGES for added files"), GRID+1 },
 497   {"atime-preserve", ATIME_PRESERVE_OPTION,
 498    N_("METHOD"), OPTION_ARG_OPTIONAL,
 499    N_("preserve access times on dumped files, either by restoring the times"
 500       " after reading (METHOD='replace'; default) or by not setting the times"
 501       " in the first place (METHOD='system')"), GRID+1 },
 502   {"touch", 'm', 0, 0,
 503    N_("don't extract file modified time"), GRID+1 },
 504   {"same-owner", SAME_OWNER_OPTION, 0, 0,
 505    N_("try extracting files with the same ownership as exists in the archive (default for superuser)"), GRID+1 },
 506   {"no-same-owner", NO_SAME_OWNER_OPTION, 0, 0,
 507    N_("extract files as yourself (default for ordinary users)"), GRID+1 },
 508   {"numeric-owner", NUMERIC_OWNER_OPTION, 0, 0,
 509    N_("always use numbers for user/group names"), GRID+1 },
 510   {"preserve-permissions", 'p', 0, 0,
 511    N_("extract information about file permissions (default for superuser)"),
 512    GRID+1 },
 513   {"same-permissions", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 514   {"no-same-permissions", NO_SAME_PERMISSIONS_OPTION, 0, 0,
 515    N_("apply the user's umask when extracting permissions from the archive (default for ordinary users)"), GRID+1 },
 516   {"preserve-order", 's', 0, 0,
 517    N_("sort names to extract to match archive"), GRID+1 },
 518   {"same-order", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 519   {"preserve", PRESERVE_OPTION, 0, 0,
 520    N_("same as both -p and -s"), GRID+1 },
 521   {"delay-directory-restore", DELAY_DIRECTORY_RESTORE_OPTION, 0, 0,
 522    N_("delay setting modification times and permissions of extracted"
 523       " directories until the end of extraction"), GRID+1 },
 524   {"no-delay-directory-restore", NO_DELAY_DIRECTORY_RESTORE_OPTION, 0, 0,
 525    N_("cancel the effect of --delay-directory-restore option"), GRID+1 },
 526 #undef GRID
 527
 528 #define GRID 60
 529   {NULL, 0, NULL, 0,
 530    N_("Device selection and switching:"), GRID },
 531
 532   {"file", 'f', N_("ARCHIVE"), 0,
 533    N_("use archive file or device ARCHIVE"), GRID+1 },
 534   {"force-local", FORCE_LOCAL_OPTION, 0, 0,
 535    N_("archive file is local even if it has a colon"), GRID+1 },
 536   {"rmt-command", RMT_COMMAND_OPTION, N_("COMMAND"), 0,
 537    N_("use given rmt COMMAND instead of rmt"), GRID+1 },
 538   {"rsh-command", RSH_COMMAND_OPTION, N_("COMMAND"), 0,
 539    N_("use remote COMMAND instead of rsh"), GRID+1 },
 540 #ifdef DEVICE_PREFIX
 541   {"-[0-7][lmh]", 0, NULL, OPTION_DOC, /* It is OK, since `name' will never be
 542                                           translated */
 543    N_("specify drive and density"), GRID+1 },
 544 #endif
 545   {NULL, '0', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 546   {NULL, '1', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 547   {NULL, '2', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 548   {NULL, '3', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 549   {NULL, '4', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 550   {NULL, '5', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 551   {NULL, '6', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 552   {NULL, '7', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 553   {NULL, '8', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 554   {NULL, '9', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 555
 556   {"multi-volume", 'M', 0, 0,
 557    N_("create/list/extract multi-volume archive"), GRID+1 },
 558   {"tape-length", 'L', N_("NUMBER"), 0,
 559    N_("change tape after writing NUMBER x 1024 bytes"), GRID+1 },
 560   {"info-script", 'F', N_("NAME"), 0,
 561    N_("run script at end of each tape (implies -M)"), GRID+1 },
 562   {"new-volume-script", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 563   {"volno-file", VOLNO_FILE_OPTION, N_("FILE"), 0,
 564    N_("use/update the volume number in FILE"), GRID+1 },
 565 #undef GRID
 566
 567 #define GRID 70
 568   {NULL, 0, NULL, 0,
 569    N_("Device blocking:"), GRID },
 570
 571   {"blocking-factor", 'b', N_("BLOCKS"), 0,
 572    N_("BLOCKS x 512 bytes per record"), GRID+1 },
 573   {"record-size", RECORD_SIZE_OPTION, N_("NUMBER"), 0,
 574    N_("NUMBER of bytes per record, multiple of 512"), GRID+1 },
 575   {"ignore-zeros", 'i', 0, 0,
 576    N_("ignore zeroed blocks in archive (means EOF)"), GRID+1 },
 577   {"read-full-records", 'B', 0, 0,
 578    N_("reblock as we read (for 4.2BSD pipes)"), GRID+1 },
 579 #undef GRID
 580
 581 #define GRID 80
 582   {NULL, 0, NULL, 0,
 583    N_("Archive format selection:"), GRID },
 584
 585   {"format", 'H', N_("FORMAT"), 0,
 586    N_("create archive of the given format"), GRID+1 },
 587
 588   {NULL, 0, NULL, 0, N_("FORMAT is one of the following:"), GRID+2 },
 589   {"  v7", 0, NULL, OPTION_DOC|OPTION_NO_TRANS, N_("old V7 tar format"),
 590    GRID+3 },
 591   {"  oldgnu", 0, NULL, OPTION_DOC|OPTION_NO_TRANS,
 592    N_("GNU format as per tar <= 1.12"), GRID+3 },
 593   {"  gnu", 0, NULL, OPTION_DOC|OPTION_NO_TRANS,
 594    N_("GNU tar 1.13.x format"), GRID+3 },
 595   {"  ustar", 0, NULL, OPTION_DOC|OPTION_NO_TRANS,
 596    N_("POSIX 1003.1-1988 (ustar) format"), GRID+3 },
 597   {"  pax", 0, NULL, OPTION_DOC|OPTION_NO_TRANS,
 598    N_("POSIX 1003.1-2001 (pax) format"), GRID+3 },
 599   {"  posix", 0, NULL, OPTION_DOC|OPTION_NO_TRANS, N_("same as pax"), GRID+3 },
 600
 601   {"old-archive", OLD_ARCHIVE_OPTION, 0, 0, /* FIXME */
 602    N_("same as --format=v7"), GRID+8 },
 603   {"portability", 0, 0, OPTION_ALIAS, NULL, GRID+8 },
 604   {"posix", POSIX_OPTION, 0, 0,
 605    N_("same as --format=posix"), GRID+8 },
 606   {"pax-option", PAX_OPTION, N_("keyword[[:]=value][,keyword[[:]=value]]..."), 0,
 607    N_("control pax keywords"), GRID+8 },
 608   {"label", 'V', N_("TEXT"), 0,
 609    N_("create archive with volume name TEXT; at list/extract time, use TEXT as a globbing pattern for volume name"), GRID+8 },
 610 #undef GRID
 611
 612 #define GRID 90
 613   {NULL, 0, NULL, 0,
 614    N_("Compression options:"), GRID },
 615   {"auto-compress", 'a', 0, 0,
 616    N_("use archive suffix to determine the compression program"), GRID+1 },
 617   {"no-auto-compress", NO_AUTO_COMPRESS_OPTION, 0, 0,
 618    N_("do not use archive suffix to determine the compression program"),
 619    GRID+1 },
 620   {"use-compress-program", 'I', N_("PROG"), 0,
 621    N_("filter through PROG (must accept -d)"), GRID+1 },
 622   /* Note: docstrings for the options below are generated by tar_help_filter */
 623   {"bzip2", 'j', 0, 0, NULL, GRID+1 },
 624   {"gzip", 'z', 0, 0, NULL, GRID+1 },
 625   {"gunzip", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 626   {"ungzip", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 627   {"compress", 'Z', 0, 0, NULL, GRID+1 },
 628   {"uncompress", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 629   {"lzip", LZIP_OPTION, 0, 0, NULL, GRID+1 },
 630   {"lzma", LZMA_OPTION, 0, 0, NULL, GRID+1 },
 631   {"lzop", LZOP_OPTION, 0, 0, NULL, GRID+1 },
 632   {"xz", 'J', 0, 0, NULL, GRID+1 },
 633 #undef GRID
 634
 635 #define GRID 100
 636   {NULL, 0, NULL, 0,
 637    N_("Local file selection:"), GRID },
 638
 639   {"add-file", ARGP_KEY_ARG, N_("FILE"), 0,
 640    N_("add given FILE to the archive (useful if its name starts with a dash)"), GRID+1 },
 641   {"directory", 'C', N_("DIR"), 0,
 642    N_("change to directory DIR"), GRID+1 },
 643   {"files-from", 'T', N_("FILE"), 0,
 644    N_("get names to extract or create from FILE"), GRID+1 },
 645   {"null", NULL_OPTION, 0, 0,
 646    N_("-T reads null-terminated names, disable -C"), GRID+1 },
 647   {"no-null", NO_NULL_OPTION, 0, 0,
 648    N_("disable the effect of the previous --null option"), GRID+1 },
 649   {"unquote", UNQUOTE_OPTION, 0, 0,
 650    N_("unquote filenames read with -T (default)"), GRID+1 },
 651   {"no-unquote", NO_UNQUOTE_OPTION, 0, 0,
 652    N_("do not unquote filenames read with -T"), GRID+1 },
 653   {"exclude", EXCLUDE_OPTION, N_("PATTERN"), 0,
 654    N_("exclude files, given as a PATTERN"), GRID+1 },
 655   {"exclude-from", 'X', N_("FILE"), 0,
 656    N_("exclude patterns listed in FILE"), GRID+1 },
 657   {"exclude-caches", EXCLUDE_CACHES_OPTION, 0, 0,
 658    N_("exclude contents of directories containing CACHEDIR.TAG, "
 659       "except for the tag file itself"), GRID+1 },
 660   {"exclude-caches-under", EXCLUDE_CACHES_UNDER_OPTION, 0, 0,
 661    N_("exclude everything under directories containing CACHEDIR.TAG"),
 662    GRID+1 },
 663   {"exclude-caches-all", EXCLUDE_CACHES_ALL_OPTION, 0, 0,
 664    N_("exclude directories containing CACHEDIR.TAG"), GRID+1 },
 665   {"exclude-tag", EXCLUDE_TAG_OPTION, N_("FILE"), 0,
 666    N_("exclude contents of directories containing FILE, except"
 667       " for FILE itself"), GRID+1 },
 668   {"exclude-tag-under", EXCLUDE_TAG_UNDER_OPTION, N_("FILE"), 0,
 669    N_("exclude everything under directories containing FILE"), GRID+1 },
 670   {"exclude-tag-all", EXCLUDE_TAG_ALL_OPTION, N_("FILE"), 0,
 671    N_("exclude directories containing FILE"), GRID+1 },
 672   {"exclude-vcs", EXCLUDE_VCS_OPTION, NULL, 0,
 673    N_("exclude version control system directories"), GRID+1 },
 674   {"exclude-backups", EXCLUDE_BACKUPS_OPTION, NULL, 0,
 675    N_("exclude backup and lock files"), GRID+1 },
 676   {"no-recursion", NO_RECURSION_OPTION, 0, 0,
 677    N_("avoid descending automatically in directories"), GRID+1 },
 678   {"one-file-system", ONE_FILE_SYSTEM_OPTION, 0, 0,
 679    N_("stay in local file system when creating archive"), GRID+1 },
 680   {"recursion", RECURSION_OPTION, 0, 0,
 681    N_("recurse into directories (default)"), GRID+1 },
 682   {"absolute-names", 'P', 0, 0,
 683    N_("don't strip leading `/'s from file names"), GRID+1 },
 684   {"dereference", 'h', 0, 0,
 685    N_("follow symlinks; archive and dump the files they point to"), GRID+1 },
 686   {"hard-dereference", HARD_DEREFERENCE_OPTION, 0, 0,
 687    N_("follow hard links; archive and dump the files they refer to"), GRID+1 },
 688   {"starting-file", 'K', N_("MEMBER-NAME"), 0,
 689    N_("begin at member MEMBER-NAME in the archive"), GRID+1 },
 690   {"newer", 'N', N_("DATE-OR-FILE"), 0,
 691    N_("only store files newer than DATE-OR-FILE"), GRID+1 },
 692   {"after-date", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 693   {"newer-mtime", NEWER_MTIME_OPTION, N_("DATE"), 0,
 694    N_("compare date and time when data changed only"), GRID+1 },
 695   {"backup", BACKUP_OPTION, N_("CONTROL"), OPTION_ARG_OPTIONAL,
 696    N_("backup before removal, choose version CONTROL"), GRID+1 },
 697   {"suffix", SUFFIX_OPTION, N_("STRING"), 0,
 698    N_("backup before removal, override usual suffix ('~' unless overridden by environment variable SIMPLE_BACKUP_SUFFIX)"), GRID+1 },
 699 #undef GRID
 700
 701 #define GRID 110
 702   {NULL, 0, NULL, 0,
 703    N_("File name transformations:"), GRID },
 704   {"strip-components", STRIP_COMPONENTS_OPTION, N_("NUMBER"), 0,
 705    N_("strip NUMBER leading components from file names on extraction"),
 706    GRID+1 },
 707   {"transform", TRANSFORM_OPTION, N_("EXPRESSION"), 0,
 708    N_("use sed replace EXPRESSION to transform file names"), GRID+1 },
 709   {"xform", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 710 #undef GRID
 711
 712 #define GRID 120
 713   {NULL, 0, NULL, 0,
 714    N_("File name matching options (affect both exclude and include patterns):"),
 715    GRID },
 716   {"ignore-case", IGNORE_CASE_OPTION, 0, 0,
 717    N_("ignore case"), GRID+1 },
 718   {"anchored", ANCHORED_OPTION, 0, 0,
 719    N_("patterns match file name start"), GRID+1 },
 720   {"no-anchored", NO_ANCHORED_OPTION, 0, 0,
 721    N_("patterns match after any `/' (default for exclusion)"), GRID+1 },
 722   {"no-ignore-case", NO_IGNORE_CASE_OPTION, 0, 0,
 723    N_("case sensitive matching (default)"), GRID+1 },
 724   {"wildcards", WILDCARDS_OPTION, 0, 0,
 725    N_("use wildcards (default for exclusion)"), GRID+1 },
 726   {"no-wildcards", NO_WILDCARDS_OPTION, 0, 0,
 727    N_("verbatim string matching"), GRID+1 },
 728   {"no-wildcards-match-slash", NO_WILDCARDS_MATCH_SLASH_OPTION, 0, 0,
 729    N_("wildcards do not match `/'"), GRID+1 },
 730   {"wildcards-match-slash", WILDCARDS_MATCH_SLASH_OPTION, 0, 0,
 731    N_("wildcards match `/' (default for exclusion)"), GRID+1 },
 732 #undef GRID
 733
 734 #define GRID 130
 735   {NULL, 0, NULL, 0,
 736    N_("Informative output:"), GRID },
 737
 738   {"verbose", 'v', 0, 0,
 739    N_("verbosely list files processed"), GRID+1 },
 740   {"warning", WARNING_OPTION, N_("KEYWORD"), 0,
 741    N_("warning control"), GRID+1 },
 742   {"checkpoint", CHECKPOINT_OPTION, N_("NUMBER"), OPTION_ARG_OPTIONAL,
 743    N_("display progress messages every NUMBERth record (default 10)"),
 744    GRID+1 },
 745   {"checkpoint-action", CHECKPOINT_ACTION_OPTION, N_("ACTION"), 0,
 746    N_("execute ACTION on each checkpoint"),
 747    GRID+1 },
 748   {"check-links", 'l', 0, 0,
 749    N_("print a message if not all links are dumped"), GRID+1 },
 750   {"totals", TOTALS_OPTION, N_("SIGNAL"), OPTION_ARG_OPTIONAL,
 751    N_("print total bytes after processing the archive; "
 752       "with an argument - print total bytes when this SIGNAL is delivered; "
 753       "Allowed signals are: SIGHUP, SIGQUIT, SIGINT, SIGUSR1 and SIGUSR2; "
 754       "the names without SIG prefix are also accepted"), GRID+1 },
 755   {"utc", UTC_OPTION, 0, 0,
 756    N_("print file modification times in UTC"), GRID+1 },
 757   {"full-time", FULL_TIME_OPTION, 0, 0,
 758    N_("print file time to its full resolution"), GRID+1 },
 759   {"index-file", INDEX_FILE_OPTION, N_("FILE"), 0,
 760    N_("send verbose output to FILE"), GRID+1 },
 761   {"block-number", 'R', 0, 0,
 762    N_("show block number within archive with each message"), GRID+1 },
 763   {"interactive", 'w', 0, 0,
 764    N_("ask for confirmation for every action"), GRID+1 },
 765   {"confirmation", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 766   {"show-defaults", SHOW_DEFAULTS_OPTION, 0, 0,
 767    N_("show tar defaults"), GRID+1 },
 768   {"show-omitted-dirs", SHOW_OMITTED_DIRS_OPTION, 0, 0,
 769    N_("when listing or extracting, list each directory that does not match search criteria"), GRID+1 },
 770   {"show-transformed-names", SHOW_TRANSFORMED_NAMES_OPTION, 0, 0,
 771    N_("show file or archive names after transformation"),
 772    GRID+1 },
 773   {"show-stored-names", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 774   {"quoting-style", QUOTING_STYLE_OPTION, N_("STYLE"), 0,
 775    N_("set name quoting style; see below for valid STYLE values"), GRID+1 },
 776   {"quote-chars", QUOTE_CHARS_OPTION, N_("STRING"), 0,
 777    N_("additionally quote characters from STRING"), GRID+1 },
 778   {"no-quote-chars", NO_QUOTE_CHARS_OPTION, N_("STRING"), 0,
 779    N_("disable quoting for characters from STRING"), GRID+1 },
 780 #undef GRID
 781
 782 #define GRID 140
 783   {NULL, 0, NULL, 0,
 784    N_("Compatibility options:"), GRID },
 785
 786   {NULL, 'o', 0, 0,
 787    N_("when creating, same as --old-archive; when extracting, same as --no-same-owner"), GRID+1 },
 788 #undef GRID
 789
 790 #define GRID 150
 791   {NULL, 0, NULL, 0,
 792    N_("Other options:"), GRID },
 793
 794   {"restrict", RESTRICT_OPTION, 0, 0,
 795    N_("disable use of some potentially harmful options"), -1 },
 796 #undef GRID
 797
 798   {0, 0, 0, 0, 0, 0}
 799 };
 800
 801 static char const *const atime_preserve_args[] =
 802 {
 803   "replace", "system", NULL
 804 };
 805
 806 static enum atime_preserve const atime_preserve_types[] =
 807 {
 808   replace_atime_preserve, system_atime_preserve
 809 };
 810
 811 /* Make sure atime_preserve_types has as much entries as atime_preserve_args
 812    (minus 1 for NULL guard) */
 813 ARGMATCH_VERIFY (atime_preserve_args, atime_preserve_types);
 814
 815 /* Wildcard matching settings */
 816 enum wildcards
 817   {
 818     default_wildcards, /* For exclusion == enable_wildcards,
 819                           for inclusion == disable_wildcards */
 820     disable_wildcards,
 821     enable_wildcards
 822   };
 823
 824 struct tar_args        /* Variables used during option parsing */
 825 {
 826   struct textual_date *textual_date; /* Keeps the arguments to --newer-mtime
 827                                         and/or --date option if they are
 828                                         textual dates */
 829   enum wildcards wildcards;        /* Wildcard settings (--wildcards/
 830                                       --no-wildcards) */
 831   int matching_flags;              /* exclude_fnmatch options */
 832   int include_anchored;            /* Pattern anchoring options used for
 833                                       file inclusion */
 834   bool o_option;                   /* True if -o option was given */
 835   bool pax_option;                 /* True if --pax-option was given */
 836   char const *backup_suffix_string;   /* --suffix option argument */
 837   char const *version_control_string; /* --backup option argument */
 838   bool input_files;                /* True if some input files where given */
 839   int compress_autodetect;         /* True if compression autodetection should
 840                                       be attempted when creating archives */
 841 };
 842
 843 \f
 844 #define MAKE_EXCL_OPTIONS(args) \
 845  ((((args)->wildcards != disable_wildcards) ? EXCLUDE_WILDCARDS : 0) \
 846   | (args)->matching_flags \
 847   | recursion_option)
 848
 849 #define MAKE_INCL_OPTIONS(args) \
 850  ((((args)->wildcards == enable_wildcards) ? EXCLUDE_WILDCARDS : 0) \
 851   | (args)->include_anchored \
 852   | (args)->matching_flags \
 853   | recursion_option)
 854
 855 static char const * const vcs_file_table[] = {
 856   /* CVS: */
 857   "CVS",
 858   ".cvsignore",
 859   /* RCS: */
 860   "RCS",
 861   /* SCCS: */
 862   "SCCS",
 863   /* SVN: */
 864   ".svn",
 865   /* git: */
 866   ".git",
 867   ".gitignore",
 868   /* Arch: */
 869   ".arch-ids",
 870   "{arch}",
 871   "=RELEASE-ID",
 872   "=meta-update",
 873   "=update",
 874   /* Bazaar */
 875   ".bzr",
 876   ".bzrignore",
 877   ".bzrtags",
 878   /* Mercurial */
 879   ".hg",
 880   ".hgignore",
 881   ".hgtags",
 882   /* darcs */
 883   "_darcs",
 884   NULL
 885 };
 886
 887 static char const * const backup_file_table[] = {
 888   ".#*",
 889   "*~",
 890   "#*#",
 891   NULL
 892 };
 893
 894 static void
 895 add_exclude_array (char const * const * fv)
 896 {
 897   int i;
 898
 899   for (i = 0; fv[i]; i++)
 900     add_exclude (excluded, fv[i], 0);
 901 }
 902
 903 \f
 904 static char *
 905 format_default_settings (void)
 906 {
 907   return xasprintf (
 908             "--format=%s -f%s -b%d --quoting-style=%s --rmt-command=%s"
 909 #ifdef REMOTE_SHELL
 910             " --rsh-command=%s"
 911 #endif
 912             ,
 913             archive_format_string (DEFAULT_ARCHIVE_FORMAT),
 914             DEFAULT_ARCHIVE, DEFAULT_BLOCKING,
 915             quoting_style_args[DEFAULT_QUOTING_STYLE],
 916             DEFAULT_RMT_COMMAND
 917 #ifdef REMOTE_SHELL
 918             , REMOTE_SHELL
 919 #endif
 920             );
 921 }
 922
 923 \f
 924 static void
 925 set_subcommand_option (enum subcommand subcommand)
 926 {
 927   if (subcommand_option != UNKNOWN_SUBCOMMAND
 928       && subcommand_option != subcommand)
 929     USAGE_ERROR ((0, 0,
 930                   _("You may not specify more than one `-Acdtrux' or `--test-label' option")));
 931
 932   subcommand_option = subcommand;
 933 }
 934
 935 static void
 936 set_use_compress_program_option (const char *string)
 937 {
 938   if (use_compress_program_option
 939       && strcmp (use_compress_program_option, string) != 0)
 940     USAGE_ERROR ((0, 0, _("Conflicting compression options")));
 941
 942   use_compress_program_option = string;
 943 }
 944 \f
 945 static RETSIGTYPE
 946 sigstat (int signo)
 947 {
 948   compute_duration ();
 949   print_total_stats ();
 950 #ifndef HAVE_SIGACTION
 951   signal (signo, sigstat);
 952 #endif
 953 }
 954
 955 static void
 956 stat_on_signal (int signo)
 957 {
 958 #ifdef HAVE_SIGACTION
 959   struct sigaction act;
 960   act.sa_handler = sigstat;
 961   sigemptyset (&act.sa_mask);
 962   act.sa_flags = 0;
 963   sigaction (signo, &act, NULL);
 964 #else
 965   signal (signo, sigstat);
 966 #endif
 967 }
 968
 969 static void
 970 set_stat_signal (const char *name)
 971 {
 972   static struct sigtab
 973   {
 974     char const *name;
 975     int signo;
 976   } const sigtab[] = {
 977     { "SIGUSR1", SIGUSR1 },
 978     { "USR1", SIGUSR1 },
 979     { "SIGUSR2", SIGUSR2 },
 980     { "USR2", SIGUSR2 },
 981     { "SIGHUP", SIGHUP },
 982     { "HUP", SIGHUP },
 983     { "SIGINT", SIGINT },
 984     { "INT", SIGINT },
 985     { "SIGQUIT", SIGQUIT },
 986     { "QUIT", SIGQUIT }
 987   };
 988   struct sigtab const *p;
 989
 990   for (p = sigtab; p < sigtab + sizeof (sigtab) / sizeof (sigtab[0]); p++)
 991     if (strcmp (p->name, name) == 0)
 992       {
 993         stat_on_signal (p->signo);
 994         return;
 995       }
 996   FATAL_ERROR ((0, 0, _("Unknown signal name: %s"), name));
 997 }
 998
 999 \f
1000 struct textual_date
1001 {
1002   struct textual_date *next;
1003   struct timespec ts;
1004   const char *option;
1005   char *date;
1006 };
1007
1008 static int
1009 get_date_or_file (struct tar_args *args, const char *option,
1010                   const char *str, struct timespec *ts)
1011 {
1012   if (FILE_SYSTEM_PREFIX_LEN (str) != 0
1013       || ISSLASH (*str)
1014       || *str == '.')
1015     {
1016       struct stat st;
1017       if (deref_stat (dereference_option, str, &st) != 0)
1018         {
1019           stat_error (str);
1020           USAGE_ERROR ((0, 0, _("Date sample file not found")));
1021         }
1022       *ts = get_stat_mtime (&st);
1023     }
1024   else
1025     {
1026       if (! get_date (ts, str, NULL))
1027         {
1028           WARN ((0, 0, _("Substituting %s for unknown date format %s"),
1029                  tartime (*ts, false), quote (str)));
1030           ts->tv_nsec = 0;
1031           return 1;
1032         }
1033       else
1034         {
1035           struct textual_date *p = xmalloc (sizeof (*p));
1036           p->ts = *ts;
1037           p->option = option;
1038           p->date = xstrdup (str);
1039           p->next = args->textual_date;
1040           args->textual_date = p;
1041         }
1042     }
1043   return 0;
1044 }
1045
1046 static void
1047 report_textual_dates (struct tar_args *args)
1048 {
1049   struct textual_date *p;
1050   for (p = args->textual_date; p; )
1051     {
1052       struct textual_date *next = p->next;
1053       if (verbose_option)
1054         {
1055           char const *treated_as = tartime (p->ts, true);
1056           if (strcmp (p->date, treated_as) != 0)
1057             WARN ((0, 0, _("Option %s: Treating date `%s' as %s"),
1058                    p->option, p->date, treated_as));
1059         }
1060       free (p->date);
1061       free (p);
1062       p = next;
1063     }
1064 }
1065
1066 \f
1067
1068 /* Either NL or NUL, as decided by the --null option.  */
1069 static char filename_terminator;
1070
1071 enum read_file_list_state  /* Result of reading file name from the list file */
1072   {
1073     file_list_success,     /* OK, name read successfully */
1074     file_list_end,         /* End of list file */
1075     file_list_zero,        /* Zero separator encountered where it should not */
1076     file_list_skip         /* Empty (zero-length) entry encountered, skip it */
1077   };
1078
1079 /* Read from FP a sequence of characters up to TERM and put them
1080    into STK.
1081  */
1082 static enum read_file_list_state
1083 read_name_from_file (FILE *fp, struct obstack *stk, int term)
1084 {
1085   int c;
1086   size_t counter = 0;
1087
1088   for (c = getc (fp); c != EOF && c != term; c = getc (fp))
1089     {
1090       if (c == 0)
1091         {
1092           /* We have read a zero separator. The file possibly is
1093              zero-separated */
1094           return file_list_zero;
1095         }
1096       obstack_1grow (stk, c);
1097       counter++;
1098     }
1099
1100   if (counter == 0 && c != EOF)
1101     return file_list_skip;
1102
1103   obstack_1grow (stk, 0);
1104
1105   return (counter == 0 && c == EOF) ? file_list_end : file_list_success;
1106 }
1107
1108 \f
1109 static bool files_from_option;  /* When set, tar will not refuse to create
1110                                    empty archives */
1111 static struct obstack argv_stk; /* Storage for additional command line options
1112                                    read using -T option */
1113
1114 /* Prevent recursive inclusion of the same file */
1115 struct file_id_list
1116 {
1117   struct file_id_list *next;
1118   ino_t ino;
1119   dev_t dev;
1120 };
1121
1122 static struct file_id_list *file_id_list;
1123
1124 static void
1125 add_file_id (const char *filename)
1126 {
1127   struct file_id_list *p;
1128   struct stat st;
1129
1130   if (stat (filename, &st))
1131     stat_fatal (filename);
1132   for (p = file_id_list; p; p = p->next)
1133     if (p->ino == st.st_ino && p->dev == st.st_dev)
1134       {
1135         FATAL_ERROR ((0, 0, _("%s: file list already read"),
1136                       quotearg_colon (filename)));
1137       }
1138   p = xmalloc (sizeof *p);
1139   p->next = file_id_list;
1140   p->ino = st.st_ino;
1141   p->dev = st.st_dev;
1142   file_id_list = p;
1143 }
1144
1145 static void
1146 update_argv (const char *filename, struct argp_state *state)
1147 {
1148   FILE *fp;
1149   size_t count = 0, i;
1150   char *start, *p;
1151   char **new_argv;
1152   size_t new_argc;
1153   bool is_stdin = false;
1154   enum read_file_list_state read_state;
1155   int term = filename_terminator;
1156
1157   if (!strcmp (filename, "-"))
1158     {
1159       is_stdin = true;
1160       request_stdin ("-T");
1161       fp = stdin;
1162     }
1163   else
1164     {
1165       add_file_id (filename);
1166       if ((fp = fopen (filename, "r")) == NULL)
1167         open_fatal (filename);
1168     }
1169
1170   while ((read_state = read_name_from_file (fp, &argv_stk, term))
1171          != file_list_end)
1172     {
1173       switch (read_state)
1174         {
1175         case file_list_success:
1176           count++;
1177           break;
1178
1179         case file_list_end: /* won't happen, just to pacify gcc */
1180           break;
1181
1182         case file_list_zero:
1183           {
1184             size_t size;
1185
1186             WARNOPT (WARN_FILENAME_WITH_NULS,
1187                      (0, 0, N_("%s: file name read contains nul character"),
1188                       quotearg_colon (filename)));
1189
1190             /* Prepare new stack contents */
1191             size = obstack_object_size (&argv_stk);
1192             p = obstack_finish (&argv_stk);
1193             for (; size > 0; size--, p++)
1194               if (*p)
1195                 obstack_1grow (&argv_stk, *p);
1196               else
1197                 obstack_1grow (&argv_stk, '\n');
1198             obstack_1grow (&argv_stk, 0);
1199             count = 1;
1200             /* Read rest of files using new filename terminator */
1201             term = 0;
1202             break;
1203           }
1204
1205         case file_list_skip:
1206           break;
1207         }
1208     }
1209
1210   if (!is_stdin)
1211     fclose (fp);
1212
1213   if (count == 0)
1214     return;
1215
1216   start = obstack_finish (&argv_stk);
1217
1218   if (term == 0)
1219     for (p = start; *p; p += strlen (p) + 1)
1220       if (p[0] == '-')
1221         count++;
1222
1223   new_argc = state->argc + count;
1224   new_argv = xmalloc (sizeof (state->argv[0]) * (new_argc + 1));
1225   memcpy (new_argv, state->argv, sizeof (state->argv[0]) * (state->argc + 1));
1226   state->argv = new_argv;
1227   memmove (&state->argv[state->next + count], &state->argv[state->next],
1228            (state->argc - state->next + 1) * sizeof (state->argv[0]));
1229
1230   state->argc = new_argc;
1231
1232   for (i = state->next, p = start; *p; p += strlen (p) + 1, i++)
1233     {
1234       if (term == 0 && p[0] == '-')
1235         state->argv[i++] = "--add-file";
1236       state->argv[i] = p;
1237     }
1238 }
1239
1240 \f
1241 static char *
1242 tar_help_filter (int key, const char *text, void *input)
1243 {
1244   struct obstack stk;
1245   char *s;
1246
1247   switch (key)
1248     {
1249     default:
1250       s = (char*) text;
1251       break;
1252
1253     case 'j':
1254       s = xasprintf (_("filter the archive through %s"), BZIP2_PROGRAM);
1255       break;
1256
1257     case 'z':
1258       s = xasprintf (_("filter the archive through %s"), GZIP_PROGRAM);
1259       break;
1260
1261     case 'Z':
1262       s = xasprintf (_("filter the archive through %s"), COMPRESS_PROGRAM);
1263       break;
1264
1265     case LZIP_OPTION:
1266       s = xasprintf (_("filter the archive through %s"), LZIP_PROGRAM);
1267       break;
1268
1269     case LZMA_OPTION:
1270       s = xasprintf (_("filter the archive through %s"), LZMA_PROGRAM);
1271       break;
1272
1273     case 'J':
1274       s = xasprintf (_("filter the archive through %s"), XZ_PROGRAM);
1275       break;
1276
1277     case ARGP_KEY_HELP_EXTRA:
1278       {
1279         const char *tstr;
1280
1281         obstack_init (&stk);
1282         tstr = _("Valid arguments for the --quoting-style option are:");
1283         obstack_grow (&stk, tstr, strlen (tstr));
1284         obstack_grow (&stk, "\n\n", 2);
1285         tar_list_quoting_styles (&stk, "  ");
1286         tstr = _("\n*This* tar defaults to:\n");
1287         obstack_grow (&stk, tstr, strlen (tstr));
1288         s = format_default_settings ();
1289         obstack_grow (&stk, s, strlen (s));
1290         obstack_1grow (&stk, '\n');
1291         obstack_1grow (&stk, 0);
1292         s = xstrdup (obstack_finish (&stk));
1293         obstack_free (&stk, NULL);
1294       }
1295     }
1296   return s;
1297 }
1298 \f
1299 static char *
1300 expand_pax_option (struct tar_args *targs, const char *arg)
1301 {
1302   struct obstack stk;
1303   char *res;
1304
1305   obstack_init (&stk);
1306   while (*arg)
1307     {
1308       size_t seglen = strcspn (arg, ",");
1309       char *p = memchr (arg, '=', seglen);
1310       if (p)
1311         {
1312           size_t len = p - arg + 1;
1313           obstack_grow (&stk, arg, len);
1314           len = seglen - len;
1315           for (++p; *p && isspace ((unsigned char) *p); p++)
1316             len--;
1317           if (*p == '{' && p[len-1] == '}')
1318             {
1319               struct timespec ts;
1320               char *tmp = xmalloc (len);
1321               memcpy (tmp, p + 1, len-2);
1322               tmp[len-2] = 0;
1323               if (get_date_or_file (targs, "--pax-option", tmp, &ts) == 0)
1324                 {
1325                   char buf[UINTMAX_STRSIZE_BOUND], *s;
1326                   s = umaxtostr (ts.tv_sec, buf);
1327                   obstack_grow (&stk, s, strlen (s));
1328                 }
1329               else
1330                 obstack_grow (&stk, p, len);
1331               free (tmp);
1332             }
1333           else
1334             obstack_grow (&stk, p, len);
1335         }
1336       else
1337         obstack_grow (&stk, arg, seglen);
1338
1339       arg += seglen;
1340       if (*arg)
1341         {
1342           obstack_1grow (&stk, *arg);
1343           arg++;
1344         }
1345     }
1346   obstack_1grow (&stk, 0);
1347   res = xstrdup (obstack_finish (&stk));
1348   obstack_free (&stk, NULL);
1349   return res;
1350 }
1351
1352 \f
1353 #define TAR_SIZE_SUFFIXES "bBcGgkKMmPTtw"
1354
1355 static error_t
1356 parse_opt (int key, char *arg, struct argp_state *state)
1357 {
1358   struct tar_args *args = state->input;
1359
1360   switch (key)
1361     {
1362     case ARGP_KEY_ARG:
1363       /* File name or non-parsed option, because of ARGP_IN_ORDER */
1364       name_add_name (arg, MAKE_INCL_OPTIONS (args));
1365       args->input_files = true;
1366       break;
1367
1368     case 'A':
1369       set_subcommand_option (CAT_SUBCOMMAND);
1370       break;
1371
1372     case 'a':
1373       args->compress_autodetect = true;
1374       break;
1375
1376     case NO_AUTO_COMPRESS_OPTION:
1377       args->compress_autodetect = false;
1378       break;
1379
1380     case 'b':
1381       {
1382         uintmax_t u;
1383         if (! (xstrtoumax (arg, 0, 10, &u, "") == LONGINT_OK
1384                && u == (blocking_factor = u)
1385                && 0 < blocking_factor
1386                && u == (record_size = u * BLOCKSIZE) / BLOCKSIZE))
1387           USAGE_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
1388                         _("Invalid blocking factor")));
1389       }
1390       break;
1391
1392     case 'B':
1393       /* Try to reblock input records.  For reading 4.2BSD pipes.  */
1394
1395       /* It would surely make sense to exchange -B and -R, but it seems
1396          that -B has been used for a long while in Sun tar and most
1397          BSD-derived systems.  This is a consequence of the block/record
1398          terminology confusion.  */
1399
1400       read_full_records_option = true;
1401       break;
1402
1403     case 'c':
1404       set_subcommand_option (CREATE_SUBCOMMAND);
1405       break;
1406
1407     case 'C':
1408       name_add_dir (arg);
1409       break;
1410
1411     case 'd':
1412       set_subcommand_option (DIFF_SUBCOMMAND);
1413       break;
1414
1415     case 'f':
1416       if (archive_names == allocated_archive_names)
1417         archive_name_array = x2nrealloc (archive_name_array,
1418                                          &allocated_archive_names,
1419                                          sizeof (archive_name_array[0]));
1420
1421       archive_name_array[archive_names++] = arg;
1422       break;
1423
1424     case 'F':
1425       /* Since -F is only useful with -M, make it implied.  Run this
1426          script at the end of each tape.  */
1427
1428       info_script_option = arg;
1429       multi_volume_option = true;
1430       break;
1431
1432     case FULL_TIME_OPTION:
1433       full_time_option = true;
1434       break;
1435
1436     case 'g':
1437       listed_incremental_option = arg;
1438       after_date_option = true;
1439       /* Fall through.  */
1440
1441     case 'G':
1442       /* We are making an incremental dump (FIXME: are we?); save
1443          directories at the beginning of the archive, and include in each
1444          directory its contents.  */
1445
1446       incremental_option = true;
1447       break;
1448
1449     case 'h':
1450       /* Follow symbolic links.  */
1451       dereference_option = true;
1452       break;
1453
1454     case HARD_DEREFERENCE_OPTION:
1455       hard_dereference_option = true;
1456       break;
1457
1458     case 'i':
1459       /* Ignore zero blocks (eofs).  This can't be the default,
1460          because Unix tar writes two blocks of zeros, then pads out
1461          the record with garbage.  */
1462
1463       ignore_zeros_option = true;
1464       break;
1465
1466     case 'j':
1467       set_use_compress_program_option (BZIP2_PROGRAM);
1468       break;
1469
1470     case 'J':
1471       set_use_compress_program_option (XZ_PROGRAM);
1472       break;
1473
1474     case 'k':
1475       /* Don't replace existing files.  */
1476       old_files_option = KEEP_OLD_FILES;
1477       break;
1478
1479     case 'K':
1480       starting_file_option = true;
1481       addname (arg, 0, true, NULL);
1482       break;
1483
1484     case ONE_FILE_SYSTEM_OPTION:
1485       /* When dumping directories, don't dump files/subdirectories
1486          that are on other filesystems. */
1487       one_file_system_option = true;
1488       break;
1489
1490     case 'l':
1491       check_links_option = 1;
1492       break;
1493
1494     case 'L':
1495       {
1496         uintmax_t u;
1497         char *p;
1498
1499         if (xstrtoumax (arg, &p, 10, &u, TAR_SIZE_SUFFIXES) != LONGINT_OK)
1500           USAGE_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
1501                         _("Invalid tape length")));
1502         if (p > arg && !strchr (TAR_SIZE_SUFFIXES, p[-1]))
1503           tape_length_option = 1024 * (tarlong) u;
1504         else
1505           tape_length_option = (tarlong) u;
1506         multi_volume_option = true;
1507       }
1508       break;
1509
1510     case LEVEL_OPTION:
1511       {
1512         char *p;
1513         incremental_level = strtoul (arg, &p, 10);
1514         if (*p)
1515           USAGE_ERROR ((0, 0, _("Invalid incremental level value")));
1516       }
1517       break;
1518
1519     case LZIP_OPTION:
1520       set_use_compress_program_option (LZIP_PROGRAM);
1521       break;
1522
1523     case LZMA_OPTION:
1524       set_use_compress_program_option (LZMA_PROGRAM);
1525       break;
1526
1527     case LZOP_OPTION:
1528       set_use_compress_program_option (LZOP_PROGRAM);
1529       break;
1530
1531     case 'm':
1532       touch_option = true;
1533       break;
1534
1535     case 'M':
1536       /* Make multivolume archive: when we can't write any more into
1537          the archive, re-open it, and continue writing.  */
1538
1539       multi_volume_option = true;
1540       break;
1541
1542     case MTIME_OPTION:
1543       get_date_or_file (args, "--mtime", arg, &mtime_option);
1544       set_mtime_option = true;
1545       break;
1546
1547     case 'n':
1548       seek_option = 1;
1549       break;
1550
1551     case NO_SEEK_OPTION:
1552       seek_option = 0;
1553       break;
1554
1555     case 'N':
1556       after_date_option = true;
1557       /* Fall through.  */
1558
1559     case NEWER_MTIME_OPTION:
1560       if (NEWER_OPTION_INITIALIZED (newer_mtime_option))
1561         USAGE_ERROR ((0, 0, _("More than one threshold date")));
1562       get_date_or_file (args,
1563                         key == NEWER_MTIME_OPTION ? "--newer-mtime"
1564                         : "--after-date", arg, &newer_mtime_option);
1565       break;
1566
1567     case 'o':
1568       args->o_option = true;
1569       break;
1570
1571     case 'O':
1572       to_stdout_option = true;
1573       break;
1574
1575     case 'p':
1576       same_permissions_option = true;
1577       break;
1578
1579     case 'P':
1580       absolute_names_option = true;
1581       break;
1582
1583     case 'r':
1584       set_subcommand_option (APPEND_SUBCOMMAND);
1585       break;
1586
1587     case 'R':
1588       /* Print block numbers for debugging bad tar archives.  */
1589
1590       /* It would surely make sense to exchange -B and -R, but it seems
1591          that -B has been used for a long while in Sun tar and most
1592          BSD-derived systems.  This is a consequence of the block/record
1593          terminology confusion.  */
1594
1595       block_number_option = true;
1596       break;
1597
1598     case 's':
1599       /* Names to extract are sorted.  */
1600
1601       same_order_option = true;
1602       break;
1603
1604     case 'S':
1605       sparse_option = true;
1606       break;
1607
1608     case SPARSE_VERSION_OPTION:
1609       sparse_option = true;
1610       {
1611         char *p;
1612         tar_sparse_major = strtoul (arg, &p, 10);
1613         if (*p)
1614           {
1615             if (*p != '.')
1616               USAGE_ERROR ((0, 0, _("Invalid sparse version value")));
1617             tar_sparse_minor = strtoul (p + 1, &p, 10);
1618             if (*p)
1619               USAGE_ERROR ((0, 0, _("Invalid sparse version value")));
1620           }
1621       }
1622       break;
1623
1624     case 't':
1625       set_subcommand_option (LIST_SUBCOMMAND);
1626       verbose_option++;
1627       break;
1628
1629     case TEST_LABEL_OPTION:
1630       set_subcommand_option (TEST_LABEL_SUBCOMMAND);
1631       break;
1632
1633     case 'T':
1634       update_argv (arg, state);
1635       /* Indicate we've been given -T option. This is for backward
1636          compatibility only, so that `tar cfT archive /dev/null will
1637          succeed */
1638       files_from_option = true;
1639       break;
1640
1641     case 'u':
1642       set_subcommand_option (UPDATE_SUBCOMMAND);
1643       break;
1644
1645     case 'U':
1646       old_files_option = UNLINK_FIRST_OLD_FILES;
1647       break;
1648
1649     case UTC_OPTION:
1650       utc_option = true;
1651       break;
1652
1653     case 'v':
1654       verbose_option++;
1655       warning_option |= WARN_VERBOSE_WARNINGS;
1656       break;
1657
1658     case 'V':
1659       volume_label_option = arg;
1660       break;
1661
1662     case 'w':
1663       interactive_option = true;
1664       break;
1665
1666     case 'W':
1667       verify_option = true;
1668       break;
1669
1670     case 'x':
1671       set_subcommand_option (EXTRACT_SUBCOMMAND);
1672       break;
1673
1674     case 'X':
1675       if (add_exclude_file (add_exclude, excluded, arg,
1676                             MAKE_EXCL_OPTIONS (args), '\n')
1677           != 0)
1678         {
1679           int e = errno;
1680           FATAL_ERROR ((0, e, "%s", quotearg_colon (arg)));
1681         }
1682       break;
1683
1684     case 'z':
1685       set_use_compress_program_option (GZIP_PROGRAM);
1686       break;
1687
1688     case 'Z':
1689       set_use_compress_program_option (COMPRESS_PROGRAM);
1690       break;
1691
1692     case ANCHORED_OPTION:
1693       args->matching_flags |= EXCLUDE_ANCHORED;
1694       break;
1695
1696     case ATIME_PRESERVE_OPTION:
1697       atime_preserve_option =
1698         (arg
1699          ? XARGMATCH ("--atime-preserve", arg,
1700                       atime_preserve_args, atime_preserve_types)
1701          : replace_atime_preserve);
1702       if (! O_NOATIME && atime_preserve_option == system_atime_preserve)
1703         FATAL_ERROR ((0, 0,
1704                       _("--atime-preserve='system' is not supported"
1705                         " on this platform")));
1706       break;
1707
1708     case CHECK_DEVICE_OPTION:
1709       check_device_option = true;
1710       break;
1711
1712     case NO_CHECK_DEVICE_OPTION:
1713       check_device_option = false;
1714       break;
1715
1716     case CHECKPOINT_OPTION:
1717       if (arg)
1718         {
1719           char *p;
1720
1721           if (*arg == '.')
1722             {
1723               checkpoint_compile_action (".");
1724               arg++;
1725             }
1726           checkpoint_option = strtoul (arg, &p, 0);
1727           if (*p)
1728             FATAL_ERROR ((0, 0,
1729                           _("--checkpoint value is not an integer")));
1730         }
1731       else
1732         checkpoint_option = DEFAULT_CHECKPOINT;
1733       break;
1734
1735     case CHECKPOINT_ACTION_OPTION:
1736       checkpoint_compile_action (arg);
1737       break;
1738
1739     case BACKUP_OPTION:
1740       backup_option = true;
1741       if (arg)
1742         args->version_control_string = arg;
1743       break;
1744
1745     case DELAY_DIRECTORY_RESTORE_OPTION:
1746       delay_directory_restore_option = true;
1747       break;
1748
1749     case NO_DELAY_DIRECTORY_RESTORE_OPTION:
1750       delay_directory_restore_option = false;
1751       break;
1752
1753     case DELETE_OPTION:
1754       set_subcommand_option (DELETE_SUBCOMMAND);
1755       break;
1756
1757     case EXCLUDE_BACKUPS_OPTION:
1758       add_exclude_array (backup_file_table);
1759       break;
1760
1761     case EXCLUDE_OPTION:
1762       add_exclude (excluded, arg, MAKE_EXCL_OPTIONS (args));
1763       break;
1764
1765     case EXCLUDE_CACHES_OPTION:
1766       add_exclusion_tag ("CACHEDIR.TAG", exclusion_tag_contents,
1767                          cachedir_file_p);
1768       break;
1769
1770     case EXCLUDE_CACHES_UNDER_OPTION:
1771       add_exclusion_tag ("CACHEDIR.TAG", exclusion_tag_under,
1772                          cachedir_file_p);
1773       break;
1774
1775     case EXCLUDE_CACHES_ALL_OPTION:
1776       add_exclusion_tag ("CACHEDIR.TAG", exclusion_tag_all,
1777                          cachedir_file_p);
1778       break;
1779
1780     case EXCLUDE_TAG_OPTION:
1781       add_exclusion_tag (arg, exclusion_tag_contents, NULL);
1782       break;
1783
1784     case EXCLUDE_TAG_UNDER_OPTION:
1785       add_exclusion_tag (arg, exclusion_tag_under, NULL);
1786       break;
1787
1788     case EXCLUDE_TAG_ALL_OPTION:
1789       add_exclusion_tag (arg, exclusion_tag_all, NULL);
1790       break;
1791
1792     case EXCLUDE_VCS_OPTION:
1793       add_exclude_array (vcs_file_table);
1794       break;
1795
1796     case FORCE_LOCAL_OPTION:
1797       force_local_option = true;
1798       break;
1799
1800     case 'H':
1801       set_archive_format (arg);
1802       break;
1803
1804     case INDEX_FILE_OPTION:
1805       index_file_name = arg;
1806       break;
1807
1808     case IGNORE_CASE_OPTION:
1809       args->matching_flags |= FNM_CASEFOLD;
1810       break;
1811
1812     case IGNORE_COMMAND_ERROR_OPTION:
1813       ignore_command_error_option = true;
1814       break;
1815
1816     case IGNORE_FAILED_READ_OPTION:
1817       ignore_failed_read_option = true;
1818       break;
1819
1820     case KEEP_NEWER_FILES_OPTION:
1821       old_files_option = KEEP_NEWER_FILES;
1822       break;
1823
1824     case GROUP_OPTION:
1825       if (! (strlen (arg) < GNAME_FIELD_SIZE
1826              && gname_to_gid (arg, &group_option)))
1827         {
1828           uintmax_t g;
1829           if (xstrtoumax (arg, 0, 10, &g, "") == LONGINT_OK
1830               && g == (gid_t) g)
1831             group_option = g;
1832           else
1833             FATAL_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
1834                           _("Invalid group")));
1835         }
1836       break;
1837
1838     case MODE_OPTION:
1839       mode_option = mode_compile (arg);
1840       if (!mode_option)
1841         FATAL_ERROR ((0, 0, _("Invalid mode given on option")));
1842       initial_umask = umask (0);
1843       umask (initial_umask);
1844       break;
1845
1846     case NO_ANCHORED_OPTION:
1847       args->include_anchored = 0; /* Clear the default for comman line args */
1848       args->matching_flags &= ~ EXCLUDE_ANCHORED;
1849       break;
1850
1851     case NO_IGNORE_CASE_OPTION:
1852       args->matching_flags &= ~ FNM_CASEFOLD;
1853       break;
1854
1855     case NO_IGNORE_COMMAND_ERROR_OPTION:
1856       ignore_command_error_option = false;
1857       break;
1858
1859     case NO_OVERWRITE_DIR_OPTION:
1860       old_files_option = NO_OVERWRITE_DIR_OLD_FILES;
1861       break;
1862
1863     case NO_QUOTE_CHARS_OPTION:
1864       for (;*arg; arg++)
1865         set_char_quoting (NULL, *arg, 0);
1866       break;
1867
1868     case NO_WILDCARDS_OPTION:
1869       args->wildcards = disable_wildcards;
1870       break;
1871
1872     case NO_WILDCARDS_MATCH_SLASH_OPTION:
1873       args->matching_flags |= FNM_FILE_NAME;
1874       break;
1875
1876     case NULL_OPTION:
1877       filename_terminator = '\0';
1878       break;
1879
1880     case NO_NULL_OPTION:
1881       filename_terminator = '\n';
1882       break;
1883
1884     case NUMERIC_OWNER_OPTION:
1885       numeric_owner_option = true;
1886       break;
1887
1888     case OCCURRENCE_OPTION:
1889       if (!arg)
1890         occurrence_option = 1;
1891       else
1892         {
1893           uintmax_t u;
1894           if (xstrtoumax (arg, 0, 10, &u, "") == LONGINT_OK)
1895             occurrence_option = u;
1896           else
1897             FATAL_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
1898                           _("Invalid number")));
1899         }
1900       break;
1901
1902     case OVERWRITE_DIR_OPTION:
1903       old_files_option = DEFAULT_OLD_FILES;
1904       break;
1905
1906     case OVERWRITE_OPTION:
1907       old_files_option = OVERWRITE_OLD_FILES;
1908       break;
1909
1910     case OWNER_OPTION:
1911       if (! (strlen (arg) < UNAME_FIELD_SIZE
1912              && uname_to_uid (arg, &owner_option)))
1913         {
1914           uintmax_t u;
1915           if (xstrtoumax (arg, 0, 10, &u, "") == LONGINT_OK
1916               && u == (uid_t) u)
1917             owner_option = u;
1918           else
1919             FATAL_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
1920                           _("Invalid owner")));
1921         }
1922       break;
1923
1924     case QUOTE_CHARS_OPTION:
1925       for (;*arg; arg++)
1926         set_char_quoting (NULL, *arg, 1);
1927       break;
1928
1929     case QUOTING_STYLE_OPTION:
1930       tar_set_quoting_style (arg);
1931       break;
1932
1933     case PAX_OPTION:
1934       {
1935         char *tmp = expand_pax_option (args, arg);
1936         args->pax_option = true;
1937         xheader_set_option (tmp);
1938         free (tmp);
1939       }
1940       break;
1941
1942     case POSIX_OPTION:
1943       set_archive_format ("posix");
1944       break;
1945
1946     case PRESERVE_OPTION:
1947       /* FIXME: What it is good for? */
1948       same_permissions_option = true;
1949       same_order_option = true;
1950       WARN ((0, 0, _("The --preserve option is deprecated, "
1951                      "use --preserve-permissions --preserve-order instead")));
1952       break;
1953
1954     case RECORD_SIZE_OPTION:
1955       {
1956         uintmax_t u;
1957
1958         if (! (xstrtoumax (arg, NULL, 10, &u, TAR_SIZE_SUFFIXES) == LONGINT_OK
1959                && u == (size_t) u))
1960           USAGE_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
1961                         _("Invalid record size")));
1962         record_size = u;
1963         if (record_size % BLOCKSIZE != 0)
1964           USAGE_ERROR ((0, 0, _("Record size must be a multiple of %d."),
1965                         BLOCKSIZE));
1966         blocking_factor = record_size / BLOCKSIZE;
1967       }
1968       break;
1969
1970     case RECURSIVE_UNLINK_OPTION:
1971       recursive_unlink_option = true;
1972       break;
1973
1974     case REMOVE_FILES_OPTION:
1975       remove_files_option = true;
1976       break;
1977
1978     case RESTRICT_OPTION:
1979       restrict_option = true;
1980       break;
1981
1982     case RMT_COMMAND_OPTION:
1983       rmt_command = arg;
1984       break;
1985
1986     case RSH_COMMAND_OPTION:
1987       rsh_command_option = arg;
1988       break;
1989
1990     case SHOW_DEFAULTS_OPTION:
1991       {
1992         char *s = format_default_settings ();
1993         printf ("%s\n", s);
1994         close_stdout ();
1995         free (s);
1996         exit (0);
1997       }
1998
1999     case STRIP_COMPONENTS_OPTION:
2000       {
2001         uintmax_t u;
2002         if (! (xstrtoumax (arg, 0, 10, &u, "") == LONGINT_OK
2003                && u == (size_t) u))
2004           USAGE_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
2005                         _("Invalid number of elements")));
2006         strip_name_components = u;
2007       }
2008       break;
2009
2010     case SHOW_OMITTED_DIRS_OPTION:
2011       show_omitted_dirs_option = true;
2012       break;
2013
2014     case SHOW_TRANSFORMED_NAMES_OPTION:
2015       show_transformed_names_option = true;
2016       break;
2017
2018     case SUFFIX_OPTION:
2019       backup_option = true;
2020       args->backup_suffix_string = arg;
2021       break;
2022
2023     case TO_COMMAND_OPTION:
2024       if (to_command_option)
2025         USAGE_ERROR ((0, 0, _("Only one --to-command option allowed")));
2026       to_command_option = arg;
2027       break;
2028
2029     case TOTALS_OPTION:
2030       if (arg)
2031         set_stat_signal (arg);
2032       else
2033         totals_option = true;
2034       break;
2035
2036     case TRANSFORM_OPTION:
2037       set_transform_expr (arg);
2038       break;
2039
2040     case 'I':
2041       set_use_compress_program_option (arg);
2042       break;
2043
2044     case VOLNO_FILE_OPTION:
2045       volno_file_option = arg;
2046       break;
2047
2048     case WILDCARDS_OPTION:
2049       args->wildcards = enable_wildcards;
2050       break;
2051
2052     case WILDCARDS_MATCH_SLASH_OPTION:
2053       args->matching_flags &= ~ FNM_FILE_NAME;
2054       break;
2055
2056     case NO_RECURSION_OPTION:
2057       recursion_option = 0;
2058       break;
2059
2060     case NO_SAME_OWNER_OPTION:
2061       same_owner_option = -1;
2062       break;
2063
2064     case NO_SAME_PERMISSIONS_OPTION:
2065       same_permissions_option = -1;
2066       break;
2067
2068     case RECURSION_OPTION:
2069       recursion_option = FNM_LEADING_DIR;
2070       break;
2071
2072     case SAME_OWNER_OPTION:
2073       same_owner_option = 1;
2074       break;
2075
2076     case UNQUOTE_OPTION:
2077       unquote_option = true;
2078       break;
2079
2080     case NO_UNQUOTE_OPTION:
2081       unquote_option = false;
2082       break;
2083
2084     case WARNING_OPTION:
2085       set_warning_option (arg);
2086       break;
2087
2088     case '0':
2089     case '1':
2090     case '2':
2091     case '3':
2092     case '4':
2093     case '5':
2094     case '6':
2095     case '7':
2096
2097 #ifdef DEVICE_PREFIX
2098       {
2099         int device = key - '0';
2100         int density;
2101         static char buf[sizeof DEVICE_PREFIX + 10];
2102         char *cursor;
2103
2104         if (arg[1])
2105           argp_error (state, _("Malformed density argument: %s"), quote (arg));
2106
2107         strcpy (buf, DEVICE_PREFIX);
2108         cursor = buf + strlen (buf);
2109
2110 #ifdef DENSITY_LETTER
2111
2112         sprintf (cursor, "%d%c", device, arg[0]);
2113
2114 #else /* not DENSITY_LETTER */
2115
2116         switch (arg[0])
2117           {
2118           case 'l':
2119             device += LOW_DENSITY_NUM;
2120             break;
2121
2122           case 'm':
2123             device += MID_DENSITY_NUM;
2124             break;
2125
2126           case 'h':
2127             device += HIGH_DENSITY_NUM;
2128             break;
2129
2130           default:
2131             argp_error (state, _("Unknown density: `%c'"), arg[0]);
2132           }
2133         sprintf (cursor, "%d", device);
2134
2135 #endif /* not DENSITY_LETTER */
2136
2137         if (archive_names == allocated_archive_names)
2138           archive_name_array = x2nrealloc (archive_name_array,
2139                                            &allocated_archive_names,
2140                                            sizeof (archive_name_array[0]));
2141         archive_name_array[archive_names++] = xstrdup (buf);
2142       }
2143       break;
2144
2145 #else /* not DEVICE_PREFIX */
2146
2147       argp_error (state,
2148                   _("Options `-[0-7][lmh]' not supported by *this* tar"));
2149
2150 #endif /* not DEVICE_PREFIX */
2151
2152     default:
2153       return ARGP_ERR_UNKNOWN;
2154     }
2155   return 0;
2156 }
2157
2158 static struct argp argp = {
2159   options,
2160   parse_opt,
2161   N_("[FILE]..."),
2162   doc,
2163   NULL,
2164   tar_help_filter,
2165   NULL
2166 };
2167
2168 void
2169 usage (int status)
2170 {
2171   argp_help (&argp, stderr, ARGP_HELP_SEE, (char*) program_name);
2172   close_stdout ();
2173   exit (status);
2174 }
2175
2176 /* Parse the options for tar.  */
2177
2178 static struct argp_option *
2179 find_argp_option (struct argp_option *o, int letter)
2180 {
2181   for (;
2182        !(o->name == NULL
2183          && o->key == 0
2184          && o->arg == 0
2185          && o->flags == 0
2186          && o->doc == NULL); o++)
2187     if (o->key == letter)
2188       return o;
2189   return NULL;
2190 }
2191
2192 static const char *tar_authors[] = {
2193   "John Gilmore",
2194   "Jay Fenlason",
2195   NULL
2196 };
2197
2198 static void
2199 decode_options (int argc, char **argv)
2200 {
2201   int idx;
2202   struct tar_args args;
2203
2204   argp_version_setup ("tar", tar_authors);
2205
2206   /* Set some default option values.  */
2207   args.textual_date = NULL;
2208   args.wildcards = default_wildcards;
2209   args.matching_flags = 0;
2210   args.include_anchored = EXCLUDE_ANCHORED;
2211   args.o_option = false;
2212   args.pax_option = false;
2213   args.backup_suffix_string = getenv ("SIMPLE_BACKUP_SUFFIX");
2214   args.version_control_string = 0;
2215   args.input_files = false;
2216   args.compress_autodetect = false;
2217
2218   subcommand_option = UNKNOWN_SUBCOMMAND;
2219   archive_format = DEFAULT_FORMAT;
2220   blocking_factor = DEFAULT_BLOCKING;
2221   record_size = DEFAULT_BLOCKING * BLOCKSIZE;
2222   excluded = new_exclude ();
2223   newer_mtime_option.tv_sec = TYPE_MINIMUM (time_t);
2224   newer_mtime_option.tv_nsec = -1;
2225   recursion_option = FNM_LEADING_DIR;
2226   unquote_option = true;
2227   tar_sparse_major = 1;
2228   tar_sparse_minor = 0;
2229
2230   owner_option = -1;
2231   group_option = -1;
2232
2233   check_device_option = true;
2234
2235   incremental_level = -1;
2236
2237   seek_option = -1;
2238
2239   /* Convert old-style tar call by exploding option element and rearranging
2240      options accordingly.  */
2241
2242   if (argc > 1 && argv[1][0] != '-')
2243     {
2244       int new_argc;             /* argc value for rearranged arguments */
2245       char **new_argv;          /* argv value for rearranged arguments */
2246       char *const *in;          /* cursor into original argv */
2247       char **out;               /* cursor into rearranged argv */
2248       const char *letter;       /* cursor into old option letters */
2249       char buffer[3];           /* constructed option buffer */
2250
2251       /* Initialize a constructed option.  */
2252
2253       buffer[0] = '-';
2254       buffer[2] = '\0';
2255
2256       /* Allocate a new argument array, and copy program name in it.  */
2257
2258       new_argc = argc - 1 + strlen (argv[1]);
2259       new_argv = xmalloc ((new_argc + 1) * sizeof (char *));
2260       in = argv;
2261       out = new_argv;
2262       *out++ = *in++;
2263
2264       /* Copy each old letter option as a separate option, and have the
2265          corresponding argument moved next to it.  */
2266
2267       for (letter = *in++; *letter; letter++)
2268         {
2269           struct argp_option *opt;
2270
2271           buffer[1] = *letter;
2272           *out++ = xstrdup (buffer);
2273           opt = find_argp_option (options, *letter);
2274           if (opt && opt->arg)
2275             {
2276               if (in < argv + argc)
2277                 *out++ = *in++;
2278               else
2279                 USAGE_ERROR ((0, 0, _("Old option `%c' requires an argument."),
2280                               *letter));
2281             }
2282         }
2283
2284       /* Copy all remaining options.  */
2285
2286       while (in < argv + argc)
2287         *out++ = *in++;
2288       *out = 0;
2289
2290       /* Replace the old option list by the new one.  */
2291
2292       argc = new_argc;
2293       argv = new_argv;
2294     }
2295
2296   /* Parse all options and non-options as they appear.  */
2297
2298   prepend_default_options (getenv ("TAR_OPTIONS"), &argc, &argv);
2299
2300   if (argp_parse (&argp, argc, argv, ARGP_IN_ORDER, &idx, &args))
2301     exit (TAREXIT_FAILURE);
2302
2303
2304   /* Special handling for 'o' option:
2305
2306      GNU tar used to say "output old format".
2307      UNIX98 tar says don't chown files after extracting (we use
2308      "--no-same-owner" for this).
2309
2310      The old GNU tar semantics is retained when used with --create
2311      option, otherwise UNIX98 semantics is assumed */
2312
2313   if (args.o_option)
2314     {
2315       if (subcommand_option == CREATE_SUBCOMMAND)
2316         {
2317           /* GNU Tar <= 1.13 compatibility */
2318           set_archive_format ("v7");
2319         }
2320       else
2321         {
2322           /* UNIX98 compatibility */
2323           same_owner_option = -1;
2324         }
2325     }
2326
2327   /* Handle operands after any "--" argument.  */
2328   for (; idx < argc; idx++)
2329     {
2330       name_add_name (argv[idx], MAKE_INCL_OPTIONS (&args));
2331       args.input_files = true;
2332     }
2333
2334   /* Warn about implicit use of the wildcards in command line arguments.
2335      See TODO */
2336   warn_regex_usage = args.wildcards == default_wildcards;
2337
2338   /* Derive option values and check option consistency.  */
2339
2340   if (archive_format == DEFAULT_FORMAT)
2341     {
2342       if (args.pax_option)
2343         archive_format = POSIX_FORMAT;
2344       else
2345         archive_format = DEFAULT_ARCHIVE_FORMAT;
2346     }
2347
2348   if ((volume_label_option && subcommand_option == CREATE_SUBCOMMAND)
2349       || incremental_option
2350       || multi_volume_option
2351       || sparse_option)
2352     assert_format (FORMAT_MASK (OLDGNU_FORMAT)
2353                    | FORMAT_MASK (GNU_FORMAT)
2354                    | FORMAT_MASK (POSIX_FORMAT));
2355
2356   if (occurrence_option)
2357     {
2358       if (!args.input_files)
2359         USAGE_ERROR ((0, 0,
2360                       _("--occurrence is meaningless without a file list")));
2361       if (subcommand_option != DELETE_SUBCOMMAND
2362           && subcommand_option != DIFF_SUBCOMMAND
2363           && subcommand_option != EXTRACT_SUBCOMMAND
2364           && subcommand_option != LIST_SUBCOMMAND)
2365             USAGE_ERROR ((0, 0,
2366                           _("--occurrence cannot be used in the requested operation mode")));
2367     }
2368
2369   if (archive_names == 0)
2370     {
2371       /* If no archive file name given, try TAPE from the environment, or
2372          else, DEFAULT_ARCHIVE from the configuration process.  */
2373
2374       archive_names = 1;
2375       archive_name_array[0] = getenv ("TAPE");
2376       if (! archive_name_array[0])
2377         archive_name_array[0] = DEFAULT_ARCHIVE;
2378     }
2379
2380   /* Allow multiple archives only with `-M'.  */
2381
2382   if (archive_names > 1 && !multi_volume_option)
2383     USAGE_ERROR ((0, 0,
2384                   _("Multiple archive files require `-M' option")));
2385
2386   if (listed_incremental_option
2387       && NEWER_OPTION_INITIALIZED (newer_mtime_option))
2388     USAGE_ERROR ((0, 0,
2389                   _("Cannot combine --listed-incremental with --newer")));
2390   if (incremental_level != -1 && !listed_incremental_option)
2391     WARN ((0, 0,
2392            _("--level is meaningless without --listed-incremental")));
2393
2394   if (volume_label_option)
2395     {
2396       if (archive_format == GNU_FORMAT || archive_format == OLDGNU_FORMAT)
2397         {
2398           size_t volume_label_max_len =
2399             (sizeof current_header->header.name
2400              - 1 /* for trailing '\0' */
2401              - (multi_volume_option
2402                 ? (sizeof " Volume "
2403                    - 1 /* for null at end of " Volume " */
2404                    + INT_STRLEN_BOUND (int) /* for volume number */
2405                    - 1 /* for sign, as 0 <= volno */)
2406                 : 0));
2407           if (volume_label_max_len < strlen (volume_label_option))
2408             USAGE_ERROR ((0, 0,
2409                           ngettext ("%s: Volume label is too long (limit is %lu byte)",
2410                                     "%s: Volume label is too long (limit is %lu bytes)",
2411                                     volume_label_max_len),
2412                           quotearg_colon (volume_label_option),
2413                           (unsigned long) volume_label_max_len));
2414         }
2415       /* else FIXME
2416          Label length in PAX format is limited by the volume size. */
2417     }
2418
2419   if (verify_option)
2420     {
2421       if (multi_volume_option)
2422         USAGE_ERROR ((0, 0, _("Cannot verify multi-volume archives")));
2423       if (use_compress_program_option)
2424         USAGE_ERROR ((0, 0, _("Cannot verify compressed archives")));
2425     }
2426
2427   if (use_compress_program_option)
2428     {
2429       if (multi_volume_option)
2430         USAGE_ERROR ((0, 0, _("Cannot use multi-volume compressed archives")));
2431       if (subcommand_option == UPDATE_SUBCOMMAND
2432           || subcommand_option == APPEND_SUBCOMMAND
2433           || subcommand_option == DELETE_SUBCOMMAND)
2434         USAGE_ERROR ((0, 0, _("Cannot update compressed archives")));
2435       if (subcommand_option == CAT_SUBCOMMAND)
2436         USAGE_ERROR ((0, 0, _("Cannot concatenate compressed archives")));
2437     }
2438
2439   /* It is no harm to use --pax-option on non-pax archives in archive
2440      reading mode. It may even be useful, since it allows to override
2441      file attributes from tar headers. Therefore I allow such usage.
2442      --gray */
2443   if (args.pax_option
2444       && archive_format != POSIX_FORMAT
2445       && (subcommand_option != EXTRACT_SUBCOMMAND
2446           || subcommand_option != DIFF_SUBCOMMAND
2447           || subcommand_option != LIST_SUBCOMMAND))
2448     USAGE_ERROR ((0, 0, _("--pax-option can be used only on POSIX archives")));
2449
2450   /* If ready to unlink hierarchies, so we are for simpler files.  */
2451   if (recursive_unlink_option)
2452     old_files_option = UNLINK_FIRST_OLD_FILES;
2453
2454
2455   if (subcommand_option == TEST_LABEL_SUBCOMMAND)
2456     {
2457       /* --test-label is silent if the user has specified the label name to
2458          compare against. */
2459       if (!args.input_files)
2460         verbose_option++;
2461     }
2462   else if (utc_option)
2463     verbose_option = 2;
2464
2465   if (tape_length_option && tape_length_option < record_size)
2466     USAGE_ERROR ((0, 0, _("Volume length cannot be less than record size")));
2467
2468   if (same_order_option && listed_incremental_option)
2469     USAGE_ERROR ((0, 0, _("--preserve-order is not compatible with "
2470                           "--listed-incremental")));
2471
2472   /* Forbid using -c with no input files whatsoever.  Check that `-f -',
2473      explicit or implied, is used correctly.  */
2474
2475   switch (subcommand_option)
2476     {
2477     case CREATE_SUBCOMMAND:
2478       if (!args.input_files && !files_from_option)
2479         USAGE_ERROR ((0, 0,
2480                       _("Cowardly refusing to create an empty archive")));
2481       if (args.compress_autodetect && archive_names
2482           && strcmp (archive_name_array[0], "-"))
2483         set_compression_program_by_suffix (archive_name_array[0],
2484                                            use_compress_program_option);
2485       break;
2486
2487     case EXTRACT_SUBCOMMAND:
2488     case LIST_SUBCOMMAND:
2489     case DIFF_SUBCOMMAND:
2490     case TEST_LABEL_SUBCOMMAND:
2491       for (archive_name_cursor = archive_name_array;
2492            archive_name_cursor < archive_name_array + archive_names;
2493            archive_name_cursor++)
2494         if (!strcmp (*archive_name_cursor, "-"))
2495           request_stdin ("-f");
2496       break;
2497
2498     case CAT_SUBCOMMAND:
2499     case UPDATE_SUBCOMMAND:
2500     case APPEND_SUBCOMMAND:
2501       for (archive_name_cursor = archive_name_array;
2502            archive_name_cursor < archive_name_array + archive_names;
2503            archive_name_cursor++)
2504         if (!strcmp (*archive_name_cursor, "-"))
2505           USAGE_ERROR ((0, 0,
2506                         _("Options `-Aru' are incompatible with `-f -'")));
2507
2508     default:
2509       break;
2510     }
2511
2512   /* Initialize stdlis */
2513   if (index_file_name)
2514     {
2515       stdlis = fopen (index_file_name, "w");
2516       if (! stdlis)
2517         open_error (index_file_name);
2518     }
2519   else
2520     stdlis = to_stdout_option ? stderr : stdout;
2521
2522   archive_name_cursor = archive_name_array;
2523
2524   /* Prepare for generating backup names.  */
2525
2526   if (args.backup_suffix_string)
2527     simple_backup_suffix = xstrdup (args.backup_suffix_string);
2528
2529   if (backup_option)
2530     {
2531       backup_type = xget_version ("--backup", args.version_control_string);
2532       /* No backup is needed either if explicitely disabled or if
2533          the extracted files are not being written to disk. */
2534       if (backup_type == no_backups || EXTRACT_OVER_PIPE)
2535         backup_option = false;
2536     }
2537
2538   checkpoint_finish_compile ();
2539
2540   report_textual_dates (&args);
2541 }
2542
2543 \f
2544 /* Tar proper.  */
2545
2546 /* Main routine for tar.  */
2547 int
2548 main (int argc, char **argv)
2549 {
2550   set_start_time ();
2551   set_program_name (argv[0]);
2552
2553   setlocale (LC_ALL, "");
2554   bindtextdomain (PACKAGE, LOCALEDIR);
2555   textdomain (PACKAGE);
2556
2557   exit_failure = TAREXIT_FAILURE;
2558   exit_status = TAREXIT_SUCCESS;
2559   filename_terminator = '\n';
2560   set_quoting_style (0, DEFAULT_QUOTING_STYLE);
2561
2562   /* Make sure we have first three descriptors available */
2563   stdopen ();
2564
2565   /* Pre-allocate a few structures.  */
2566
2567   allocated_archive_names = 10;
2568   archive_name_array =
2569     xmalloc (sizeof (const char *) * allocated_archive_names);
2570   archive_names = 0;
2571
2572   obstack_init (&argv_stk);
2573
2574   /* System V fork+wait does not work if SIGCHLD is ignored.  */
2575   signal (SIGCHLD, SIG_DFL);
2576
2577   /* Try to disable the ability to unlink a directory.  */
2578   priv_set_remove_linkdir ();
2579
2580   /* Decode options.  */
2581
2582   decode_options (argc, argv);
2583
2584   name_init ();
2585
2586   /* Main command execution.  */
2587
2588   if (volno_file_option)
2589     init_volume_number ();
2590
2591   switch (subcommand_option)
2592     {
2593     case UNKNOWN_SUBCOMMAND:
2594       USAGE_ERROR ((0, 0,
2595                     _("You must specify one of the `-Acdtrux' or `--test-label'  options")));
2596
2597     case CAT_SUBCOMMAND:
2598     case UPDATE_SUBCOMMAND:
2599     case APPEND_SUBCOMMAND:
2600       update_archive ();
2601       break;
2602
2603     case DELETE_SUBCOMMAND:
2604       delete_archive_members ();
2605       break;
2606
2607     case CREATE_SUBCOMMAND:
2608       create_archive ();
2609       break;
2610
2611     case EXTRACT_SUBCOMMAND:
2612       extr_init ();
2613       read_and (extract_archive);
2614
2615       /* FIXME: should extract_finish () even if an ordinary signal is
2616          received.  */
2617       extract_finish ();
2618
2619       break;
2620
2621     case LIST_SUBCOMMAND:
2622       read_and (list_archive);
2623       break;
2624
2625     case DIFF_SUBCOMMAND:
2626       diff_init ();
2627       read_and (diff_archive);
2628       break;
2629
2630     case TEST_LABEL_SUBCOMMAND:
2631       test_archive_label ();
2632     }
2633
2634   if (totals_option)
2635     print_total_stats ();
2636
2637   if (check_links_option)
2638     check_links ();
2639
2640   if (volno_file_option)
2641     closeout_volume_number ();
2642
2643   /* Dispose of allocated memory, and return.  */
2644
2645   free (archive_name_array);
2646   name_term ();
2647
2648   if (exit_status == TAREXIT_FAILURE)
2649     error (0, 0, _("Exiting with failure status due to previous errors"));
2650
2651   if (stdlis == stdout)
2652     close_stdout ();
2653   else if (ferror (stderr) || fclose (stderr) != 0)
2654     set_exit_status (TAREXIT_FAILURE);
2655
2656   return exit_status;
2657 }
2658
2659 void
2660 tar_stat_init (struct tar_stat_info *st)
2661 {
2662   memset (st, 0, sizeof (*st));
2663 }
2664
2665 void
2666 tar_stat_destroy (struct tar_stat_info *st)
2667 {
2668   free (st->orig_file_name);
2669   free (st->file_name);
2670   free (st->link_name);
2671   free (st->uname);
2672   free (st->gname);
2673   free (st->sparse_map);
2674   free (st->dumpdir);
2675   xheader_destroy (&st->xhdr);
2676   memset (st, 0, sizeof (*st));
2677 }
2678
2679 /* Format mask for all available formats that support nanosecond
2680    timestamp resolution. */
2681 #define NS_PRECISION_FORMAT_MASK FORMAT_MASK (POSIX_FORMAT)
2682
2683 /* Same as timespec_cmp, but ignore nanoseconds if current archive
2684    format does not provide sufficient resolution.  */
2685 int
2686 tar_timespec_cmp (struct timespec a, struct timespec b)
2687 {
2688   if (!(FORMAT_MASK (current_format) & NS_PRECISION_FORMAT_MASK))
2689     a.tv_nsec = b.tv_nsec = 0;
2690   return timespec_cmp (a, b);
2691 }
2692
2693 /* Set tar exit status to VAL, unless it is already indicating
2694    a more serious condition. This relies on the fact that the
2695    values of TAREXIT_ constants are ranged by severity. */
2696 void
2697 set_exit_status (int val)
2698 {
2699   if (val > exit_status)
2700     exit_status = val;
2701 }