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, 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 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 void
 224 tar_list_quoting_styles (struct obstack *stk, char *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 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   GROUP_OPTION,
 278   IGNORE_CASE_OPTION,
 279   IGNORE_COMMAND_ERROR_OPTION,
 280   IGNORE_FAILED_READ_OPTION,
 281   INDEX_FILE_OPTION,
 282   KEEP_NEWER_FILES_OPTION,
 283   LEVEL_OPTION,
 284   LZIP_OPTION,
 285   LZMA_OPTION,
 286   LZOP_OPTION,
 287   MODE_OPTION,
 288   MTIME_OPTION,
 289   NEWER_MTIME_OPTION,
 290   NO_ANCHORED_OPTION,
 291   NO_AUTO_COMPRESS_OPTION,
 292   NO_CHECK_DEVICE_OPTION,
 293   NO_DELAY_DIRECTORY_RESTORE_OPTION,
 294   NO_IGNORE_CASE_OPTION,
 295   NO_IGNORE_COMMAND_ERROR_OPTION,
 296   NO_NULL_OPTION,
 297   NO_OVERWRITE_DIR_OPTION,
 298   NO_QUOTE_CHARS_OPTION,
 299   NO_RECURSION_OPTION,
 300   NO_SAME_OWNER_OPTION,
 301   NO_SAME_PERMISSIONS_OPTION,
 302   NO_SEEK_OPTION,
 303   NO_UNQUOTE_OPTION,
 304   NO_WILDCARDS_MATCH_SLASH_OPTION,
 305   NO_WILDCARDS_OPTION,
 306   NULL_OPTION,
 307   NUMERIC_OWNER_OPTION,
 308   OCCURRENCE_OPTION,
 309   OLD_ARCHIVE_OPTION,
 310   ONE_FILE_SYSTEM_OPTION,
 311   OVERWRITE_DIR_OPTION,
 312   OVERWRITE_OPTION,
 313   OWNER_OPTION,
 314   PAX_OPTION,
 315   POSIX_OPTION,
 316   PRESERVE_OPTION,
 317   QUOTE_CHARS_OPTION,
 318   QUOTING_STYLE_OPTION,
 319   RECORD_SIZE_OPTION,
 320   RECURSION_OPTION,
 321   RECURSIVE_UNLINK_OPTION,
 322   REMOVE_FILES_OPTION,
 323   RESTRICT_OPTION,
 324   RMT_COMMAND_OPTION,
 325   RSH_COMMAND_OPTION,
 326   SAME_OWNER_OPTION,
 327   SHOW_DEFAULTS_OPTION,
 328   SHOW_OMITTED_DIRS_OPTION,
 329   SHOW_TRANSFORMED_NAMES_OPTION,
 330   SPARSE_VERSION_OPTION,
 331   STRIP_COMPONENTS_OPTION,
 332   SUFFIX_OPTION,
 333   TEST_LABEL_OPTION,
 334   TOTALS_OPTION,
 335   TO_COMMAND_OPTION,
 336   TRANSFORM_OPTION,
 337   UNQUOTE_OPTION,
 338   UTC_OPTION,
 339   VOLNO_FILE_OPTION,
 340   WARNING_OPTION,
 341   WILDCARDS_MATCH_SLASH_OPTION,
 342   WILDCARDS_OPTION
 343 };
 344
 345 const char *argp_program_version = "tar (" PACKAGE_NAME ") " VERSION;
 346 const char *argp_program_bug_address = "<" PACKAGE_BUGREPORT ">";
 347 static char const doc[] = N_("\
 348 GNU `tar' saves many files together into a single tape or disk archive, \
 349 and can restore individual files from the archive.\n\
 350 \n\
 351 Examples:\n\
 352   tar -cf archive.tar foo bar  # Create archive.tar from files foo and bar.\n\
 353   tar -tvf archive.tar         # List all files in archive.tar verbosely.\n\
 354   tar -xf archive.tar          # Extract all files from archive.tar.\n")
 355 "\v"
 356 N_("The backup suffix is `~', unless set with --suffix or SIMPLE_BACKUP_SUFFIX.\n\
 357 The version control may be set with --backup or VERSION_CONTROL, values are:\n\n\
 358   none, off       never make backups\n\
 359   t, numbered     make numbered backups\n\
 360   nil, existing   numbered if numbered backups exist, simple otherwise\n\
 361   never, simple   always make simple backups\n");
 362
 363
 364 /* NOTE:
 365
 366    Available option letters are DEQY and eqy. Consider the following
 367    assignments:
 368
 369    [For Solaris tar compatibility =/= Is it important at all?]
 370    e  exit immediately with a nonzero exit status if unexpected errors occur
 371    E  use extended headers (--format=posix)
 372
 373    [q  alias for --occurrence=1 =/= this would better be used for quiet?]
 374
 375    y  per-file gzip compression
 376    Y  per-block gzip compression.
 377
 378    Additionally, the 'n' letter is assigned for option --seek, which
 379    is probably not needed and should be marked as deprecated, so that
 380    -n may become available in the future.
 381 */
 382
 383 static struct argp_option options[] = {
 384 #define GRID 10
 385   {NULL, 0, NULL, 0,
 386    N_("Main operation mode:"), GRID },
 387
 388   {"list", 't', 0, 0,
 389    N_("list the contents of an archive"), GRID+1 },
 390   {"extract", 'x', 0, 0,
 391    N_("extract files from an archive"), GRID+1 },
 392   {"get", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 393   {"create", 'c', 0, 0,
 394    N_("create a new archive"), GRID+1 },
 395   {"diff", 'd', 0, 0,
 396    N_("find differences between archive and file system"), GRID+1 },
 397   {"compare", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 398   {"append", 'r', 0, 0,
 399    N_("append files to the end of an archive"), GRID+1 },
 400   {"update", 'u', 0, 0,
 401    N_("only append files newer than copy in archive"), GRID+1 },
 402   {"catenate", 'A', 0, 0,
 403    N_("append tar files to an archive"), GRID+1 },
 404   {"concatenate", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 405   {"delete", DELETE_OPTION, 0, 0,
 406    N_("delete from the archive (not on mag tapes!)"), GRID+1 },
 407   {"test-label", TEST_LABEL_OPTION, NULL, 0,
 408    N_("test the archive volume label and exit"), GRID+1 },
 409 #undef GRID
 410
 411 #define GRID 20
 412   {NULL, 0, NULL, 0,
 413    N_("Operation modifiers:"), GRID },
 414
 415   {"sparse", 'S', 0, 0,
 416    N_("handle sparse files efficiently"), GRID+1 },
 417   {"sparse-version", SPARSE_VERSION_OPTION, N_("MAJOR[.MINOR]"), 0,
 418    N_("set version of the sparse format to use (implies --sparse)"), GRID+1},
 419   {"incremental", 'G', 0, 0,
 420    N_("handle old GNU-format incremental backup"), GRID+1 },
 421   {"listed-incremental", 'g', N_("FILE"), 0,
 422    N_("handle new GNU-format incremental backup"), GRID+1 },
 423   {"level", LEVEL_OPTION, N_("NUMBER"), 0,
 424    N_("dump level for created listed-incremental archive"), GRID+1 },
 425   {"ignore-failed-read", IGNORE_FAILED_READ_OPTION, 0, 0,
 426    N_("do not exit with nonzero on unreadable files"), GRID+1 },
 427   {"occurrence", OCCURRENCE_OPTION, N_("NUMBER"), OPTION_ARG_OPTIONAL,
 428    N_("process only the NUMBERth occurrence of each file in the archive;"
 429       " this option is valid only in conjunction with one of the subcommands"
 430       " --delete, --diff, --extract or --list and when a list of files"
 431       " is given either on the command line or via the -T option;"
 432       " NUMBER defaults to 1"), GRID+1 },
 433   {"seek", 'n', NULL, 0,
 434    N_("archive is seekable"), GRID+1 },
 435   {"no-seek", NO_SEEK_OPTION, NULL, 0,
 436    N_("archive is not seekable"), GRID+1 },
 437   {"no-check-device", NO_CHECK_DEVICE_OPTION, NULL, 0,
 438    N_("do not check device numbers when creating incremental archives"),
 439    GRID+1 },
 440   {"check-device", CHECK_DEVICE_OPTION, NULL, 0,
 441    N_("check device numbers when creating incremental archives (default)"),
 442    GRID+1 },
 443 #undef GRID
 444
 445 #define GRID 30
 446   {NULL, 0, NULL, 0,
 447    N_("Overwrite control:"), GRID },
 448
 449   {"verify", 'W', 0, 0,
 450    N_("attempt to verify the archive after writing it"), GRID+1 },
 451   {"remove-files", REMOVE_FILES_OPTION, 0, 0,
 452    N_("remove files after adding them to the archive"), GRID+1 },
 453   {"keep-old-files", 'k', 0, 0,
 454    N_("don't replace existing files when extracting"), GRID+1 },
 455   {"keep-newer-files", KEEP_NEWER_FILES_OPTION, 0, 0,
 456    N_("don't replace existing files that are newer than their archive copies"), GRID+1 },
 457   {"overwrite", OVERWRITE_OPTION, 0, 0,
 458    N_("overwrite existing files when extracting"), GRID+1 },
 459   {"unlink-first", 'U', 0, 0,
 460    N_("remove each file prior to extracting over it"), GRID+1 },
 461   {"recursive-unlink", RECURSIVE_UNLINK_OPTION, 0, 0,
 462    N_("empty hierarchies prior to extracting directory"), GRID+1 },
 463   {"no-overwrite-dir", NO_OVERWRITE_DIR_OPTION, 0, 0,
 464    N_("preserve metadata of existing directories"), GRID+1 },
 465   {"overwrite-dir", OVERWRITE_DIR_OPTION, 0, 0,
 466    N_("overwrite metadata of existing directories when extracting (default)"),
 467    GRID+1 },
 468 #undef GRID
 469
 470 #define GRID 40
 471   {NULL, 0, NULL, 0,
 472    N_("Select output stream:"), GRID },
 473
 474   {"to-stdout", 'O', 0, 0,
 475    N_("extract files to standard output"), GRID+1 },
 476   {"to-command", TO_COMMAND_OPTION, N_("COMMAND"), 0,
 477    N_("pipe extracted files to another program"), GRID+1 },
 478   {"ignore-command-error", IGNORE_COMMAND_ERROR_OPTION, 0, 0,
 479    N_("ignore exit codes of children"), GRID+1 },
 480   {"no-ignore-command-error", NO_IGNORE_COMMAND_ERROR_OPTION, 0, 0,
 481    N_("treat non-zero exit codes of children as error"), GRID+1 },
 482 #undef GRID
 483
 484 #define GRID 50
 485   {NULL, 0, NULL, 0,
 486    N_("Handling of file attributes:"), GRID },
 487
 488   {"owner", OWNER_OPTION, N_("NAME"), 0,
 489    N_("force NAME as owner for added files"), GRID+1 },
 490   {"group", GROUP_OPTION, N_("NAME"), 0,
 491    N_("force NAME as group for added files"), GRID+1 },
 492   {"mtime", MTIME_OPTION, N_("DATE-OR-FILE"), 0,
 493    N_("set mtime for added files from DATE-OR-FILE"), GRID+1 },
 494   {"mode", MODE_OPTION, N_("CHANGES"), 0,
 495    N_("force (symbolic) mode CHANGES for added files"), GRID+1 },
 496   {"atime-preserve", ATIME_PRESERVE_OPTION,
 497    N_("METHOD"), OPTION_ARG_OPTIONAL,
 498    N_("preserve access times on dumped files, either by restoring the times"
 499       " after reading (METHOD='replace'; default) or by not setting the times"
 500       " in the first place (METHOD='system')"), GRID+1 },
 501   {"touch", 'm', 0, 0,
 502    N_("don't extract file modified time"), GRID+1 },
 503   {"same-owner", SAME_OWNER_OPTION, 0, 0,
 504    N_("try extracting files with the same ownership as exists in the archive (default for superuser)"), GRID+1 },
 505   {"no-same-owner", NO_SAME_OWNER_OPTION, 0, 0,
 506    N_("extract files as yourself (default for ordinary users)"), GRID+1 },
 507   {"numeric-owner", NUMERIC_OWNER_OPTION, 0, 0,
 508    N_("always use numbers for user/group names"), GRID+1 },
 509   {"preserve-permissions", 'p', 0, 0,
 510    N_("extract information about file permissions (default for superuser)"),
 511    GRID+1 },
 512   {"same-permissions", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 513   {"no-same-permissions", NO_SAME_PERMISSIONS_OPTION, 0, 0,
 514    N_("apply the user's umask when extracting permissions from the archive (default for ordinary users)"), GRID+1 },
 515   {"preserve-order", 's', 0, 0,
 516    N_("sort names to extract to match archive"), GRID+1 },
 517   {"same-order", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 518   {"preserve", PRESERVE_OPTION, 0, 0,
 519    N_("same as both -p and -s"), GRID+1 },
 520   {"delay-directory-restore", DELAY_DIRECTORY_RESTORE_OPTION, 0, 0,
 521    N_("delay setting modification times and permissions of extracted"
 522       " directories until the end of extraction"), GRID+1 },
 523   {"no-delay-directory-restore", NO_DELAY_DIRECTORY_RESTORE_OPTION, 0, 0,
 524    N_("cancel the effect of --delay-directory-restore option"), GRID+1 },
 525 #undef GRID
 526
 527 #define GRID 60
 528   {NULL, 0, NULL, 0,
 529    N_("Device selection and switching:"), GRID },
 530
 531   {"file", 'f', N_("ARCHIVE"), 0,
 532    N_("use archive file or device ARCHIVE"), GRID+1 },
 533   {"force-local", FORCE_LOCAL_OPTION, 0, 0,
 534    N_("archive file is local even if it has a colon"), GRID+1 },
 535   {"rmt-command", RMT_COMMAND_OPTION, N_("COMMAND"), 0,
 536    N_("use given rmt COMMAND instead of rmt"), GRID+1 },
 537   {"rsh-command", RSH_COMMAND_OPTION, N_("COMMAND"), 0,
 538    N_("use remote COMMAND instead of rsh"), GRID+1 },
 539 #ifdef DEVICE_PREFIX
 540   {"-[0-7][lmh]", 0, NULL, OPTION_DOC, /* It is OK, since `name' will never be
 541                                           translated */
 542    N_("specify drive and density"), GRID+1 },
 543 #endif
 544   {NULL, '0', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 545   {NULL, '1', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 546   {NULL, '2', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 547   {NULL, '3', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 548   {NULL, '4', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 549   {NULL, '5', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 550   {NULL, '6', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 551   {NULL, '7', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 552   {NULL, '8', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 553   {NULL, '9', NULL, OPTION_HIDDEN, NULL, GRID+1 },
 554
 555   {"multi-volume", 'M', 0, 0,
 556    N_("create/list/extract multi-volume archive"), GRID+1 },
 557   {"tape-length", 'L', N_("NUMBER"), 0,
 558    N_("change tape after writing NUMBER x 1024 bytes"), GRID+1 },
 559   {"info-script", 'F', N_("NAME"), 0,
 560    N_("run script at end of each tape (implies -M)"), GRID+1 },
 561   {"new-volume-script", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 562   {"volno-file", VOLNO_FILE_OPTION, N_("FILE"), 0,
 563    N_("use/update the volume number in FILE"), GRID+1 },
 564 #undef GRID
 565
 566 #define GRID 70
 567   {NULL, 0, NULL, 0,
 568    N_("Device blocking:"), GRID },
 569
 570   {"blocking-factor", 'b', N_("BLOCKS"), 0,
 571    N_("BLOCKS x 512 bytes per record"), GRID+1 },
 572   {"record-size", RECORD_SIZE_OPTION, N_("NUMBER"), 0,
 573    N_("NUMBER of bytes per record, multiple of 512"), GRID+1 },
 574   {"ignore-zeros", 'i', 0, 0,
 575    N_("ignore zeroed blocks in archive (means EOF)"), GRID+1 },
 576   {"read-full-records", 'B', 0, 0,
 577    N_("reblock as we read (for 4.2BSD pipes)"), GRID+1 },
 578 #undef GRID
 579
 580 #define GRID 80
 581   {NULL, 0, NULL, 0,
 582    N_("Archive format selection:"), GRID },
 583
 584   {"format", 'H', N_("FORMAT"), 0,
 585    N_("create archive of the given format"), GRID+1 },
 586
 587   {NULL, 0, NULL, 0, N_("FORMAT is one of the following:"), GRID+2 },
 588   {"  v7", 0, NULL, OPTION_DOC|OPTION_NO_TRANS, N_("old V7 tar format"),
 589    GRID+3 },
 590   {"  oldgnu", 0, NULL, OPTION_DOC|OPTION_NO_TRANS,
 591    N_("GNU format as per tar <= 1.12"), GRID+3 },
 592   {"  gnu", 0, NULL, OPTION_DOC|OPTION_NO_TRANS,
 593    N_("GNU tar 1.13.x format"), GRID+3 },
 594   {"  ustar", 0, NULL, OPTION_DOC|OPTION_NO_TRANS,
 595    N_("POSIX 1003.1-1988 (ustar) format"), GRID+3 },
 596   {"  pax", 0, NULL, OPTION_DOC|OPTION_NO_TRANS,
 597    N_("POSIX 1003.1-2001 (pax) format"), GRID+3 },
 598   {"  posix", 0, NULL, OPTION_DOC|OPTION_NO_TRANS, N_("same as pax"), GRID+3 },
 599
 600   {"old-archive", OLD_ARCHIVE_OPTION, 0, 0, /* FIXME */
 601    N_("same as --format=v7"), GRID+8 },
 602   {"portability", 0, 0, OPTION_ALIAS, NULL, GRID+8 },
 603   {"posix", POSIX_OPTION, 0, 0,
 604    N_("same as --format=posix"), GRID+8 },
 605   {"pax-option", PAX_OPTION, N_("keyword[[:]=value][,keyword[[:]=value]]..."), 0,
 606    N_("control pax keywords"), GRID+8 },
 607   {"label", 'V', N_("TEXT"), 0,
 608    N_("create archive with volume name TEXT; at list/extract time, use TEXT as a globbing pattern for volume name"), GRID+8 },
 609 #undef GRID
 610
 611 #define GRID 90
 612   {NULL, 0, NULL, 0,
 613    N_("Compression options:"), GRID },
 614   {"auto-compress", 'a', 0, 0,
 615    N_("use archive suffix to determine the compression program"), GRID+1 },
 616   {"no-auto-compress", NO_AUTO_COMPRESS_OPTION, 0, 0,
 617    N_("do not use archive suffix to determine the compression program"),
 618    GRID+1 },
 619   {"use-compress-program", 'I', N_("PROG"), 0,
 620    N_("filter through PROG (must accept -d)"), GRID+1 },
 621   /* Note: docstrings for the options below are generated by tar_help_filter */
 622   {"bzip2", 'j', 0, 0, NULL, GRID+1 },
 623   {"gzip", 'z', 0, 0, NULL, GRID+1 },
 624   {"gunzip", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 625   {"ungzip", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 626   {"compress", 'Z', 0, 0, NULL, GRID+1 },
 627   {"uncompress", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 628   {"lzip", LZIP_OPTION, 0, 0, NULL, GRID+1 },
 629   {"lzma", LZMA_OPTION, 0, 0, NULL, GRID+1 },
 630   {"lzop", LZOP_OPTION, 0, 0, NULL, GRID+1 },
 631   {"xz", 'J', 0, 0, NULL, GRID+1 },
 632 #undef GRID
 633
 634 #define GRID 100
 635   {NULL, 0, NULL, 0,
 636    N_("Local file selection:"), GRID },
 637
 638   {"add-file", ARGP_KEY_ARG, N_("FILE"), 0,
 639    N_("add given FILE to the archive (useful if its name starts with a dash)"), GRID+1 },
 640   {"directory", 'C', N_("DIR"), 0,
 641    N_("change to directory DIR"), GRID+1 },
 642   {"files-from", 'T', N_("FILE"), 0,
 643    N_("get names to extract or create from FILE"), GRID+1 },
 644   {"null", NULL_OPTION, 0, 0,
 645    N_("-T reads null-terminated names, disable -C"), GRID+1 },
 646   {"no-null", NO_NULL_OPTION, 0, 0,
 647    N_("disable the effect of the previous --null option"), GRID+1 },
 648   {"unquote", UNQUOTE_OPTION, 0, 0,
 649    N_("unquote filenames read with -T (default)"), GRID+1 },
 650   {"no-unquote", NO_UNQUOTE_OPTION, 0, 0,
 651    N_("do not unquote filenames read with -T"), GRID+1 },
 652   {"exclude", EXCLUDE_OPTION, N_("PATTERN"), 0,
 653    N_("exclude files, given as a PATTERN"), GRID+1 },
 654   {"exclude-from", 'X', N_("FILE"), 0,
 655    N_("exclude patterns listed in FILE"), GRID+1 },
 656   {"exclude-caches", EXCLUDE_CACHES_OPTION, 0, 0,
 657    N_("exclude contents of directories containing CACHEDIR.TAG, "
 658       "except for the tag file itself"), GRID+1 },
 659   {"exclude-caches-under", EXCLUDE_CACHES_UNDER_OPTION, 0, 0,
 660    N_("exclude everything under directories containing CACHEDIR.TAG"),
 661    GRID+1 },
 662   {"exclude-caches-all", EXCLUDE_CACHES_ALL_OPTION, 0, 0,
 663    N_("exclude directories containing CACHEDIR.TAG"), GRID+1 },
 664   {"exclude-tag", EXCLUDE_TAG_OPTION, N_("FILE"), 0,
 665    N_("exclude contents of directories containing FILE, except"
 666       " for FILE itself"), GRID+1 },
 667   {"exclude-tag-under", EXCLUDE_TAG_UNDER_OPTION, N_("FILE"), 0,
 668    N_("exclude everything under directories containing FILE"), GRID+1 },
 669   {"exclude-tag-all", EXCLUDE_TAG_ALL_OPTION, N_("FILE"), 0,
 670    N_("exclude directories containing FILE"), GRID+1 },
 671   {"exclude-vcs", EXCLUDE_VCS_OPTION, NULL, 0,
 672    N_("exclude version control system directories"), GRID+1 },
 673   {"exclude-backups", EXCLUDE_BACKUPS_OPTION, NULL, 0,
 674    N_("exclude backup and lock files"), GRID+1 },
 675   {"no-recursion", NO_RECURSION_OPTION, 0, 0,
 676    N_("avoid descending automatically in directories"), GRID+1 },
 677   {"one-file-system", ONE_FILE_SYSTEM_OPTION, 0, 0,
 678    N_("stay in local file system when creating archive"), GRID+1 },
 679   {"recursion", RECURSION_OPTION, 0, 0,
 680    N_("recurse into directories (default)"), GRID+1 },
 681   {"absolute-names", 'P', 0, 0,
 682    N_("don't strip leading `/'s from file names"), GRID+1 },
 683   {"dereference", 'h', 0, 0,
 684    N_("follow symlinks; archive and dump the files they point to"), GRID+1 },
 685   {"hard-dereference", HARD_DEREFERENCE_OPTION, 0, 0,
 686    N_("follow hard links; archive and dump the files they refer to"), GRID+1 },
 687   {"starting-file", 'K', N_("MEMBER-NAME"), 0,
 688    N_("begin at member MEMBER-NAME in the archive"), GRID+1 },
 689   {"newer", 'N', N_("DATE-OR-FILE"), 0,
 690    N_("only store files newer than DATE-OR-FILE"), GRID+1 },
 691   {"after-date", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 692   {"newer-mtime", NEWER_MTIME_OPTION, N_("DATE"), 0,
 693    N_("compare date and time when data changed only"), GRID+1 },
 694   {"backup", BACKUP_OPTION, N_("CONTROL"), OPTION_ARG_OPTIONAL,
 695    N_("backup before removal, choose version CONTROL"), GRID+1 },
 696   {"suffix", SUFFIX_OPTION, N_("STRING"), 0,
 697    N_("backup before removal, override usual suffix ('~' unless overridden by environment variable SIMPLE_BACKUP_SUFFIX)"), GRID+1 },
 698 #undef GRID
 699
 700 #define GRID 110
 701   {NULL, 0, NULL, 0,
 702    N_("File name transformations:"), GRID },
 703   {"strip-components", STRIP_COMPONENTS_OPTION, N_("NUMBER"), 0,
 704    N_("strip NUMBER leading components from file names on extraction"),
 705    GRID+1 },
 706   {"transform", TRANSFORM_OPTION, N_("EXPRESSION"), 0,
 707    N_("use sed replace EXPRESSION to transform file names"), GRID+1 },
 708   {"xform", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 709 #undef GRID
 710
 711 #define GRID 120
 712   {NULL, 0, NULL, 0,
 713    N_("File name matching options (affect both exclude and include patterns):"),
 714    GRID },
 715   {"ignore-case", IGNORE_CASE_OPTION, 0, 0,
 716    N_("ignore case"), GRID+1 },
 717   {"anchored", ANCHORED_OPTION, 0, 0,
 718    N_("patterns match file name start"), GRID+1 },
 719   {"no-anchored", NO_ANCHORED_OPTION, 0, 0,
 720    N_("patterns match after any `/' (default for exclusion)"), GRID+1 },
 721   {"no-ignore-case", NO_IGNORE_CASE_OPTION, 0, 0,
 722    N_("case sensitive matching (default)"), GRID+1 },
 723   {"wildcards", WILDCARDS_OPTION, 0, 0,
 724    N_("use wildcards (default for exclusion)"), GRID+1 },
 725   {"no-wildcards", NO_WILDCARDS_OPTION, 0, 0,
 726    N_("verbatim string matching"), GRID+1 },
 727   {"no-wildcards-match-slash", NO_WILDCARDS_MATCH_SLASH_OPTION, 0, 0,
 728    N_("wildcards do not match `/'"), GRID+1 },
 729   {"wildcards-match-slash", WILDCARDS_MATCH_SLASH_OPTION, 0, 0,
 730    N_("wildcards match `/' (default for exclusion)"), GRID+1 },
 731 #undef GRID
 732
 733 #define GRID 130
 734   {NULL, 0, NULL, 0,
 735    N_("Informative output:"), GRID },
 736
 737   {"verbose", 'v', 0, 0,
 738    N_("verbosely list files processed"), GRID+1 },
 739   {"warning", WARNING_OPTION, N_("KEYWORD"), 0,
 740    N_("warning control"), GRID+1 },
 741   {"checkpoint", CHECKPOINT_OPTION, N_("NUMBER"), OPTION_ARG_OPTIONAL,
 742    N_("display progress messages every NUMBERth record (default 10)"),
 743    GRID+1 },
 744   {"checkpoint-action", CHECKPOINT_ACTION_OPTION, N_("ACTION"), 0,
 745    N_("execute ACTION on each checkpoint"),
 746    GRID+1 },
 747   {"check-links", 'l', 0, 0,
 748    N_("print a message if not all links are dumped"), GRID+1 },
 749   {"totals", TOTALS_OPTION, N_("SIGNAL"), OPTION_ARG_OPTIONAL,
 750    N_("print total bytes after processing the archive; "
 751       "with an argument - print total bytes when this SIGNAL is delivered; "
 752       "Allowed signals are: SIGHUP, SIGQUIT, SIGINT, SIGUSR1 and SIGUSR2; "
 753       "the names without SIG prefix are also accepted"), GRID+1 },
 754   {"utc", UTC_OPTION, 0, 0,
 755    N_("print file modification dates in UTC"), GRID+1 },
 756   {"index-file", INDEX_FILE_OPTION, N_("FILE"), 0,
 757    N_("send verbose output to FILE"), GRID+1 },
 758   {"block-number", 'R', 0, 0,
 759    N_("show block number within archive with each message"), GRID+1 },
 760   {"interactive", 'w', 0, 0,
 761    N_("ask for confirmation for every action"), GRID+1 },
 762   {"confirmation", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 763   {"show-defaults", SHOW_DEFAULTS_OPTION, 0, 0,
 764    N_("show tar defaults"), GRID+1 },
 765   {"show-omitted-dirs", SHOW_OMITTED_DIRS_OPTION, 0, 0,
 766    N_("when listing or extracting, list each directory that does not match search criteria"), GRID+1 },
 767   {"show-transformed-names", SHOW_TRANSFORMED_NAMES_OPTION, 0, 0,
 768    N_("show file or archive names after transformation"),
 769    GRID+1 },
 770   {"show-stored-names", 0, 0, OPTION_ALIAS, NULL, GRID+1 },
 771   {"quoting-style", QUOTING_STYLE_OPTION, N_("STYLE"), 0,
 772    N_("set name quoting style; see below for valid STYLE values"), GRID+1 },
 773   {"quote-chars", QUOTE_CHARS_OPTION, N_("STRING"), 0,
 774    N_("additionally quote characters from STRING"), GRID+1 },
 775   {"no-quote-chars", NO_QUOTE_CHARS_OPTION, N_("STRING"), 0,
 776    N_("disable quoting for characters from STRING"), GRID+1 },
 777 #undef GRID
 778
 779 #define GRID 140
 780   {NULL, 0, NULL, 0,
 781    N_("Compatibility options:"), GRID },
 782
 783   {NULL, 'o', 0, 0,
 784    N_("when creating, same as --old-archive; when extracting, same as --no-same-owner"), GRID+1 },
 785 #undef GRID
 786
 787 #define GRID 150
 788   {NULL, 0, NULL, 0,
 789    N_("Other options:"), GRID },
 790
 791   {"restrict", RESTRICT_OPTION, 0, 0,
 792    N_("disable use of some potentially harmful options"), -1 },
 793 #undef GRID
 794
 795   {0, 0, 0, 0, 0, 0}
 796 };
 797
 798 static char const *const atime_preserve_args[] =
 799 {
 800   "replace", "system", NULL
 801 };
 802
 803 static enum atime_preserve const atime_preserve_types[] =
 804 {
 805   replace_atime_preserve, system_atime_preserve
 806 };
 807
 808 /* Make sure atime_preserve_types has as much entries as atime_preserve_args
 809    (minus 1 for NULL guard) */
 810 ARGMATCH_VERIFY (atime_preserve_args, atime_preserve_types);
 811
 812 /* Wildcard matching settings */
 813 enum wildcards
 814   {
 815     default_wildcards, /* For exclusion == enable_wildcards,
 816                           for inclusion == disable_wildcards */
 817     disable_wildcards,
 818     enable_wildcards
 819   };
 820
 821 struct tar_args        /* Variables used during option parsing */
 822 {
 823   struct textual_date *textual_date; /* Keeps the arguments to --newer-mtime
 824                                         and/or --date option if they are
 825                                         textual dates */
 826   enum wildcards wildcards;        /* Wildcard settings (--wildcards/
 827                                       --no-wildcards) */
 828   int matching_flags;              /* exclude_fnmatch options */
 829   int include_anchored;            /* Pattern anchoring options used for
 830                                       file inclusion */
 831   bool o_option;                   /* True if -o option was given */
 832   bool pax_option;                 /* True if --pax-option was given */
 833   char const *backup_suffix_string;   /* --suffix option argument */
 834   char const *version_control_string; /* --backup option argument */
 835   bool input_files;                /* True if some input files where given */
 836   int compress_autodetect;         /* True if compression autodetection should
 837                                       be attempted when creating archives */
 838 };
 839
 840 \f
 841 #define MAKE_EXCL_OPTIONS(args) \
 842  ((((args)->wildcards != disable_wildcards) ? EXCLUDE_WILDCARDS : 0) \
 843   | (args)->matching_flags \
 844   | recursion_option)
 845
 846 #define MAKE_INCL_OPTIONS(args) \
 847  ((((args)->wildcards == enable_wildcards) ? EXCLUDE_WILDCARDS : 0) \
 848   | (args)->include_anchored \
 849   | (args)->matching_flags \
 850   | recursion_option)
 851
 852 static char const * const vcs_file_table[] = {
 853   /* CVS: */
 854   "CVS",
 855   ".cvsignore",
 856   /* RCS: */
 857   "RCS",
 858   /* SCCS: */
 859   "SCCS",
 860   /* SVN: */
 861   ".svn",
 862   /* git: */
 863   ".git",
 864   ".gitignore",
 865   /* Arch: */
 866   ".arch-ids",
 867   "{arch}",
 868   "=RELEASE-ID",
 869   "=meta-update",
 870   "=update",
 871   /* Bazaar */
 872   ".bzr",
 873   ".bzrignore",
 874   ".bzrtags",
 875   /* Mercurial */
 876   ".hg",
 877   ".hgignore",
 878   ".hgtags",
 879   /* darcs */
 880   "_darcs",
 881   NULL
 882 };
 883
 884 static char const * const backup_file_table[] = {
 885   ".#*",
 886   "*~",
 887   "#*#",
 888   NULL
 889 };
 890
 891 void
 892 add_exclude_array (char const * const * fv)
 893 {
 894   int i;
 895
 896   for (i = 0; fv[i]; i++)
 897     add_exclude (excluded, fv[i], 0);
 898 }
 899
 900 \f
 901 static char *
 902 format_default_settings (void)
 903 {
 904   return xasprintf (
 905             "--format=%s -f%s -b%d --quoting-style=%s --rmt-command=%s"
 906 #ifdef REMOTE_SHELL
 907             " --rsh-command=%s"
 908 #endif
 909             ,
 910             archive_format_string (DEFAULT_ARCHIVE_FORMAT),
 911             DEFAULT_ARCHIVE, DEFAULT_BLOCKING,
 912             quoting_style_args[DEFAULT_QUOTING_STYLE],
 913             DEFAULT_RMT_COMMAND
 914 #ifdef REMOTE_SHELL
 915             , REMOTE_SHELL
 916 #endif
 917             );
 918 }
 919
 920 \f
 921 static void
 922 set_subcommand_option (enum subcommand subcommand)
 923 {
 924   if (subcommand_option != UNKNOWN_SUBCOMMAND
 925       && subcommand_option != subcommand)
 926     USAGE_ERROR ((0, 0,
 927                   _("You may not specify more than one `-Acdtrux' or `--test-label' option")));
 928
 929   subcommand_option = subcommand;
 930 }
 931
 932 static void
 933 set_use_compress_program_option (const char *string)
 934 {
 935   if (use_compress_program_option
 936       && strcmp (use_compress_program_option, string) != 0)
 937     USAGE_ERROR ((0, 0, _("Conflicting compression options")));
 938
 939   use_compress_program_option = string;
 940 }
 941 \f
 942 static RETSIGTYPE
 943 sigstat (int signo)
 944 {
 945   compute_duration ();
 946   print_total_stats ();
 947 #ifndef HAVE_SIGACTION
 948   signal (signo, sigstat);
 949 #endif
 950 }
 951
 952 static void
 953 stat_on_signal (int signo)
 954 {
 955 #ifdef HAVE_SIGACTION
 956   struct sigaction act;
 957   act.sa_handler = sigstat;
 958   sigemptyset (&act.sa_mask);
 959   act.sa_flags = 0;
 960   sigaction (signo, &act, NULL);
 961 #else
 962   signal (signo, sigstat);
 963 #endif
 964 }
 965
 966 void
 967 set_stat_signal (const char *name)
 968 {
 969   static struct sigtab
 970   {
 971     char *name;
 972     int signo;
 973   } sigtab[] = {
 974     { "SIGUSR1", SIGUSR1 },
 975     { "USR1", SIGUSR1 },
 976     { "SIGUSR2", SIGUSR2 },
 977     { "USR2", SIGUSR2 },
 978     { "SIGHUP", SIGHUP },
 979     { "HUP", SIGHUP },
 980     { "SIGINT", SIGINT },
 981     { "INT", SIGINT },
 982     { "SIGQUIT", SIGQUIT },
 983     { "QUIT", SIGQUIT }
 984   };
 985   struct sigtab *p;
 986
 987   for (p = sigtab; p < sigtab + sizeof (sigtab) / sizeof (sigtab[0]); p++)
 988     if (strcmp (p->name, name) == 0)
 989       {
 990         stat_on_signal (p->signo);
 991         return;
 992       }
 993   FATAL_ERROR ((0, 0, _("Unknown signal name: %s"), name));
 994 }
 995
 996 \f
 997 struct textual_date
 998 {
 999   struct textual_date *next;
1000   struct timespec ts;
1001   const char *option;
1002   char *date;
1003 };
1004
1005 static int
1006 get_date_or_file (struct tar_args *args, const char *option,
1007                   const char *str, struct timespec *ts)
1008 {
1009   if (FILE_SYSTEM_PREFIX_LEN (str) != 0
1010       || ISSLASH (*str)
1011       || *str == '.')
1012     {
1013       struct stat st;
1014       if (deref_stat (dereference_option, str, &st) != 0)
1015         {
1016           stat_error (str);
1017           USAGE_ERROR ((0, 0, _("Date sample file not found")));
1018         }
1019       *ts = get_stat_mtime (&st);
1020     }
1021   else
1022     {
1023       if (! get_date (ts, str, NULL))
1024         {
1025           WARN ((0, 0, _("Substituting %s for unknown date format %s"),
1026                  tartime (*ts, false), quote (str)));
1027           ts->tv_nsec = 0;
1028           return 1;
1029         }
1030       else
1031         {
1032           struct textual_date *p = xmalloc (sizeof (*p));
1033           p->ts = *ts;
1034           p->option = option;
1035           p->date = xstrdup (str);
1036           p->next = args->textual_date;
1037           args->textual_date = p;
1038         }
1039     }
1040   return 0;
1041 }
1042
1043 static void
1044 report_textual_dates (struct tar_args *args)
1045 {
1046   struct textual_date *p;
1047   for (p = args->textual_date; p; )
1048     {
1049       struct textual_date *next = p->next;
1050       if (verbose_option)
1051         {
1052           char const *treated_as = tartime (p->ts, true);
1053           if (strcmp (p->date, treated_as) != 0)
1054             WARN ((0, 0, _("Option %s: Treating date `%s' as %s"),
1055                    p->option, p->date, treated_as));
1056         }
1057       free (p->date);
1058       free (p);
1059       p = next;
1060     }
1061 }
1062
1063 \f
1064
1065 /* Either NL or NUL, as decided by the --null option.  */
1066 static char filename_terminator;
1067
1068 enum read_file_list_state  /* Result of reading file name from the list file */
1069   {
1070     file_list_success,     /* OK, name read successfully */
1071     file_list_end,         /* End of list file */
1072     file_list_zero,        /* Zero separator encountered where it should not */
1073     file_list_skip         /* Empty (zero-length) entry encountered, skip it */
1074   };
1075
1076 /* Read from FP a sequence of characters up to TERM and put them
1077    into STK.
1078  */
1079 static enum read_file_list_state
1080 read_name_from_file (FILE *fp, struct obstack *stk, int term)
1081 {
1082   int c;
1083   size_t counter = 0;
1084
1085   for (c = getc (fp); c != EOF && c != term; c = getc (fp))
1086     {
1087       if (c == 0)
1088         {
1089           /* We have read a zero separator. The file possibly is
1090              zero-separated */
1091           return file_list_zero;
1092         }
1093       obstack_1grow (stk, c);
1094       counter++;
1095     }
1096
1097   if (counter == 0 && c != EOF)
1098     return file_list_skip;
1099
1100   obstack_1grow (stk, 0);
1101
1102   return (counter == 0 && c == EOF) ? file_list_end : file_list_success;
1103 }
1104
1105 \f
1106 static bool files_from_option;  /* When set, tar will not refuse to create
1107                                    empty archives */
1108 static struct obstack argv_stk; /* Storage for additional command line options
1109                                    read using -T option */
1110
1111 /* Prevent recursive inclusion of the same file */
1112 struct file_id_list
1113 {
1114   struct file_id_list *next;
1115   ino_t ino;
1116   dev_t dev;
1117 };
1118
1119 static struct file_id_list *file_id_list;
1120
1121 static void
1122 add_file_id (const char *filename)
1123 {
1124   struct file_id_list *p;
1125   struct stat st;
1126
1127   if (stat (filename, &st))
1128     stat_fatal (filename);
1129   for (p = file_id_list; p; p = p->next)
1130     if (p->ino == st.st_ino && p->dev == st.st_dev)
1131       {
1132         FATAL_ERROR ((0, 0, _("%s: file list already read"),
1133                       quotearg_colon (filename)));
1134       }
1135   p = xmalloc (sizeof *p);
1136   p->next = file_id_list;
1137   p->ino = st.st_ino;
1138   p->dev = st.st_dev;
1139   file_id_list = p;
1140 }
1141
1142 /* Default density numbers for [0-9][lmh] device specifications */
1143
1144 #ifndef LOW_DENSITY_NUM
1145 # define LOW_DENSITY_NUM 0
1146 #endif
1147
1148 #ifndef MID_DENSITY_NUM
1149 # define MID_DENSITY_NUM 8
1150 #endif
1151
1152 #ifndef HIGH_DENSITY_NUM
1153 # define HIGH_DENSITY_NUM 16
1154 #endif
1155
1156 static void
1157 update_argv (const char *filename, struct argp_state *state)
1158 {
1159   FILE *fp;
1160   size_t count = 0, i;
1161   char *start, *p;
1162   char **new_argv;
1163   size_t new_argc;
1164   bool is_stdin = false;
1165   enum read_file_list_state read_state;
1166   int term = filename_terminator;
1167
1168   if (!strcmp (filename, "-"))
1169     {
1170       is_stdin = true;
1171       request_stdin ("-T");
1172       fp = stdin;
1173     }
1174   else
1175     {
1176       add_file_id (filename);
1177       if ((fp = fopen (filename, "r")) == NULL)
1178         open_fatal (filename);
1179     }
1180
1181   while ((read_state = read_name_from_file (fp, &argv_stk, term))
1182          != file_list_end)
1183     {
1184       switch (read_state)
1185         {
1186         case file_list_success:
1187           count++;
1188           break;
1189
1190         case file_list_end: /* won't happen, just to pacify gcc */
1191           break;
1192
1193         case file_list_zero:
1194           {
1195             size_t size;
1196
1197             WARNOPT (WARN_FILENAME_WITH_NULS,
1198                      (0, 0, N_("%s: file name read contains nul character"),
1199                       quotearg_colon (filename)));
1200
1201             /* Prepare new stack contents */
1202             size = obstack_object_size (&argv_stk);
1203             p = obstack_finish (&argv_stk);
1204             for (; size > 0; size--, p++)
1205               if (*p)
1206                 obstack_1grow (&argv_stk, *p);
1207               else
1208                 obstack_1grow (&argv_stk, '\n');
1209             obstack_1grow (&argv_stk, 0);
1210             count = 1;
1211             /* Read rest of files using new filename terminator */
1212             term = 0;
1213             break;
1214           }
1215
1216         case file_list_skip:
1217           break;
1218         }
1219     }
1220
1221   if (!is_stdin)
1222     fclose (fp);
1223
1224   if (count == 0)
1225     return;
1226
1227   start = obstack_finish (&argv_stk);
1228
1229   if (term == 0)
1230     for (p = start; *p; p += strlen (p) + 1)
1231       if (p[0] == '-')
1232         count++;
1233
1234   new_argc = state->argc + count;
1235   new_argv = xmalloc (sizeof (state->argv[0]) * (new_argc + 1));
1236   memcpy (new_argv, state->argv, sizeof (state->argv[0]) * (state->argc + 1));
1237   state->argv = new_argv;
1238   memmove (&state->argv[state->next + count], &state->argv[state->next],
1239            (state->argc - state->next + 1) * sizeof (state->argv[0]));
1240
1241   state->argc = new_argc;
1242
1243   for (i = state->next, p = start; *p; p += strlen (p) + 1, i++)
1244     {
1245       if (term == 0 && p[0] == '-')
1246         state->argv[i++] = "--add-file";
1247       state->argv[i] = p;
1248     }
1249 }
1250
1251 \f
1252 static char *
1253 tar_help_filter (int key, const char *text, void *input)
1254 {
1255   struct obstack stk;
1256   char *s;
1257
1258   switch (key)
1259     {
1260     default:
1261       s = (char*) text;
1262       break;
1263
1264     case 'j':
1265       s = xasprintf (_("filter the archive through %s"), BZIP2_PROGRAM);
1266       break;
1267
1268     case 'z':
1269       s = xasprintf (_("filter the archive through %s"), GZIP_PROGRAM);
1270       break;
1271
1272     case 'Z':
1273       s = xasprintf (_("filter the archive through %s"), COMPRESS_PROGRAM);
1274       break;
1275
1276     case LZIP_OPTION:
1277       s = xasprintf (_("filter the archive through %s"), LZIP_PROGRAM);
1278       break;
1279
1280     case LZMA_OPTION:
1281       s = xasprintf (_("filter the archive through %s"), LZMA_PROGRAM);
1282       break;
1283
1284     case 'J':
1285       s = xasprintf (_("filter the archive through %s"), XZ_PROGRAM);
1286       break;
1287
1288     case ARGP_KEY_HELP_EXTRA:
1289       {
1290         const char *tstr;
1291
1292         obstack_init (&stk);
1293         tstr = _("Valid arguments for the --quoting-style option are:");
1294         obstack_grow (&stk, tstr, strlen (tstr));
1295         obstack_grow (&stk, "\n\n", 2);
1296         tar_list_quoting_styles (&stk, "  ");
1297         tstr = _("\n*This* tar defaults to:\n");
1298         obstack_grow (&stk, tstr, strlen (tstr));
1299         s = format_default_settings ();
1300         obstack_grow (&stk, s, strlen (s));
1301         obstack_1grow (&stk, '\n');
1302         obstack_1grow (&stk, 0);
1303         s = xstrdup (obstack_finish (&stk));
1304         obstack_free (&stk, NULL);
1305       }
1306     }
1307   return s;
1308 }
1309 \f
1310 static char *
1311 expand_pax_option (struct tar_args *targs, const char *arg)
1312 {
1313   struct obstack stk;
1314   char *res;
1315
1316   obstack_init (&stk);
1317   while (*arg)
1318     {
1319       size_t seglen = strcspn (arg, ",");
1320       char *p = memchr (arg, '=', seglen);
1321       if (p)
1322         {
1323           size_t len = p - arg + 1;
1324           obstack_grow (&stk, arg, len);
1325           len = seglen - len;
1326           for (++p; *p && isspace ((unsigned char) *p); p++)
1327             len--;
1328           if (*p == '{' && p[len-1] == '}')
1329             {
1330               struct timespec ts;
1331               char *tmp = xmalloc (len);
1332               memcpy (tmp, p + 1, len-2);
1333               tmp[len-2] = 0;
1334               if (get_date_or_file (targs, "--pax-option", tmp, &ts) == 0)
1335                 {
1336                   char buf[UINTMAX_STRSIZE_BOUND], *s;
1337                   s = umaxtostr (ts.tv_sec, buf);
1338                   obstack_grow (&stk, s, strlen (s));
1339                 }
1340               else
1341                 obstack_grow (&stk, p, len);
1342               free (tmp);
1343             }
1344           else
1345             obstack_grow (&stk, p, len);
1346         }
1347       else
1348         obstack_grow (&stk, arg, seglen);
1349
1350       arg += seglen;
1351       if (*arg)
1352         {
1353           obstack_1grow (&stk, *arg);
1354           arg++;
1355         }
1356     }
1357   obstack_1grow (&stk, 0);
1358   res = xstrdup (obstack_finish (&stk));
1359   obstack_free (&stk, NULL);
1360   return res;
1361 }
1362
1363 \f
1364 static error_t
1365 parse_opt (int key, char *arg, struct argp_state *state)
1366 {
1367   struct tar_args *args = state->input;
1368
1369   switch (key)
1370     {
1371     case ARGP_KEY_ARG:
1372       /* File name or non-parsed option, because of ARGP_IN_ORDER */
1373       name_add_name (arg, MAKE_INCL_OPTIONS (args));
1374       args->input_files = true;
1375       break;
1376
1377     case 'A':
1378       set_subcommand_option (CAT_SUBCOMMAND);
1379       break;
1380
1381     case 'a':
1382       args->compress_autodetect = true;
1383       break;
1384
1385     case NO_AUTO_COMPRESS_OPTION:
1386       args->compress_autodetect = false;
1387       break;
1388
1389     case 'b':
1390       {
1391         uintmax_t u;
1392         if (! (xstrtoumax (arg, 0, 10, &u, "") == LONGINT_OK
1393                && u == (blocking_factor = u)
1394                && 0 < blocking_factor
1395                && u == (record_size = u * BLOCKSIZE) / BLOCKSIZE))
1396           USAGE_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
1397                         _("Invalid blocking factor")));
1398       }
1399       break;
1400
1401     case 'B':
1402       /* Try to reblock input records.  For reading 4.2BSD pipes.  */
1403
1404       /* It would surely make sense to exchange -B and -R, but it seems
1405          that -B has been used for a long while in Sun tar and most
1406          BSD-derived systems.  This is a consequence of the block/record
1407          terminology confusion.  */
1408
1409       read_full_records_option = true;
1410       break;
1411
1412     case 'c':
1413       set_subcommand_option (CREATE_SUBCOMMAND);
1414       break;
1415
1416     case 'C':
1417       name_add_dir (arg);
1418       break;
1419
1420     case 'd':
1421       set_subcommand_option (DIFF_SUBCOMMAND);
1422       break;
1423
1424     case 'f':
1425       if (archive_names == allocated_archive_names)
1426         archive_name_array = x2nrealloc (archive_name_array,
1427                                          &allocated_archive_names,
1428                                          sizeof (archive_name_array[0]));
1429
1430       archive_name_array[archive_names++] = arg;
1431       break;
1432
1433     case 'F':
1434       /* Since -F is only useful with -M, make it implied.  Run this
1435          script at the end of each tape.  */
1436
1437       info_script_option = arg;
1438       multi_volume_option = true;
1439       break;
1440
1441     case 'g':
1442       listed_incremental_option = arg;
1443       after_date_option = true;
1444       /* Fall through.  */
1445
1446     case 'G':
1447       /* We are making an incremental dump (FIXME: are we?); save
1448          directories at the beginning of the archive, and include in each
1449          directory its contents.  */
1450
1451       incremental_option = true;
1452       break;
1453
1454     case 'h':
1455       /* Follow symbolic links.  */
1456       dereference_option = true;
1457       break;
1458
1459     case HARD_DEREFERENCE_OPTION:
1460       hard_dereference_option = true;
1461       break;
1462
1463     case 'i':
1464       /* Ignore zero blocks (eofs).  This can't be the default,
1465          because Unix tar writes two blocks of zeros, then pads out
1466          the record with garbage.  */
1467
1468       ignore_zeros_option = true;
1469       break;
1470
1471     case 'j':
1472       set_use_compress_program_option (BZIP2_PROGRAM);
1473       break;
1474
1475     case 'J':
1476       set_use_compress_program_option (XZ_PROGRAM);
1477       break;
1478
1479     case 'k':
1480       /* Don't replace existing files.  */
1481       old_files_option = KEEP_OLD_FILES;
1482       break;
1483
1484     case 'K':
1485       starting_file_option = true;
1486       addname (arg, 0, true, NULL);
1487       break;
1488
1489     case ONE_FILE_SYSTEM_OPTION:
1490       /* When dumping directories, don't dump files/subdirectories
1491          that are on other filesystems. */
1492       one_file_system_option = true;
1493       break;
1494
1495     case 'l':
1496       check_links_option = 1;
1497       break;
1498
1499     case 'L':
1500       {
1501         uintmax_t u;
1502         if (xstrtoumax (arg, 0, 10, &u, "") != LONGINT_OK)
1503           USAGE_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
1504                         _("Invalid tape length")));
1505         tape_length_option = 1024 * (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         if (! (xstrtoumax (arg, 0, 10, &u, "") == LONGINT_OK
1958                && u == (size_t) u))
1959           USAGE_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
1960                         _("Invalid record size")));
1961         record_size = u;
1962         if (record_size % BLOCKSIZE != 0)
1963           USAGE_ERROR ((0, 0, _("Record size must be a multiple of %d."),
1964                         BLOCKSIZE));
1965         blocking_factor = record_size / BLOCKSIZE;
1966       }
1967       break;
1968
1969     case RECURSIVE_UNLINK_OPTION:
1970       recursive_unlink_option = true;
1971       break;
1972
1973     case REMOVE_FILES_OPTION:
1974       remove_files_option = true;
1975       break;
1976
1977     case RESTRICT_OPTION:
1978       restrict_option = true;
1979       break;
1980
1981     case RMT_COMMAND_OPTION:
1982       rmt_command = arg;
1983       break;
1984
1985     case RSH_COMMAND_OPTION:
1986       rsh_command_option = arg;
1987       break;
1988
1989     case SHOW_DEFAULTS_OPTION:
1990       {
1991         char *s = format_default_settings ();
1992         printf ("%s\n", s);
1993         close_stdout ();
1994         free (s);
1995         exit (0);
1996       }
1997
1998     case STRIP_COMPONENTS_OPTION:
1999       {
2000         uintmax_t u;
2001         if (! (xstrtoumax (arg, 0, 10, &u, "") == LONGINT_OK
2002                && u == (size_t) u))
2003           USAGE_ERROR ((0, 0, "%s: %s", quotearg_colon (arg),
2004                         _("Invalid number of elements")));
2005         strip_name_components = u;
2006       }
2007       break;
2008
2009     case SHOW_OMITTED_DIRS_OPTION:
2010       show_omitted_dirs_option = true;
2011       break;
2012
2013     case SHOW_TRANSFORMED_NAMES_OPTION:
2014       show_transformed_names_option = true;
2015       break;
2016
2017     case SUFFIX_OPTION:
2018       backup_option = true;
2019       args->backup_suffix_string = arg;
2020       break;
2021
2022     case TO_COMMAND_OPTION:
2023       if (to_command_option)
2024         USAGE_ERROR ((0, 0, _("Only one --to-command option allowed")));
2025       to_command_option = arg;
2026       break;
2027
2028     case TOTALS_OPTION:
2029       if (arg)
2030         set_stat_signal (arg);
2031       else
2032         totals_option = true;
2033       break;
2034
2035     case TRANSFORM_OPTION:
2036       set_transform_expr (arg);
2037       break;
2038
2039     case 'I':
2040       set_use_compress_program_option (arg);
2041       break;
2042
2043     case VOLNO_FILE_OPTION:
2044       volno_file_option = arg;
2045       break;
2046
2047     case WILDCARDS_OPTION:
2048       args->wildcards = enable_wildcards;
2049       break;
2050
2051     case WILDCARDS_MATCH_SLASH_OPTION:
2052       args->matching_flags &= ~ FNM_FILE_NAME;
2053       break;
2054
2055     case NO_RECURSION_OPTION:
2056       recursion_option = 0;
2057       break;
2058
2059     case NO_SAME_OWNER_OPTION:
2060       same_owner_option = -1;
2061       break;
2062
2063     case NO_SAME_PERMISSIONS_OPTION:
2064       same_permissions_option = -1;
2065       break;
2066
2067     case RECURSION_OPTION:
2068       recursion_option = FNM_LEADING_DIR;
2069       break;
2070
2071     case SAME_OWNER_OPTION:
2072       same_owner_option = 1;
2073       break;
2074
2075     case UNQUOTE_OPTION:
2076       unquote_option = true;
2077       break;
2078
2079     case NO_UNQUOTE_OPTION:
2080       unquote_option = false;
2081       break;
2082
2083     case WARNING_OPTION:
2084       set_warning_option (arg);
2085       break;
2086
2087     case '0':
2088     case '1':
2089     case '2':
2090     case '3':
2091     case '4':
2092     case '5':
2093     case '6':
2094     case '7':
2095
2096 #ifdef DEVICE_PREFIX
2097       {
2098         int device = key - '0';
2099         int density;
2100         static char buf[sizeof DEVICE_PREFIX + 10];
2101         char *cursor;
2102
2103         if (arg[1])
2104           argp_error (state, _("Malformed density argument: %s"), quote (arg));
2105
2106         strcpy (buf, DEVICE_PREFIX);
2107         cursor = buf + strlen (buf);
2108
2109 #ifdef DENSITY_LETTER
2110
2111         sprintf (cursor, "%d%c", device, arg[0]);
2112
2113 #else /* not DENSITY_LETTER */
2114
2115         switch (arg[0])
2116           {
2117           case 'l':
2118             device += LOW_DENSITY_NUM;
2119             break;
2120
2121           case 'm':
2122             device += MID_DENSITY_NUM;
2123             break;
2124
2125           case 'h':
2126             device += HIGH_DENSITY_NUM;
2127             break;
2128
2129           default:
2130             argp_error (state, _("Unknown density: `%c'"), arg[0]);
2131           }
2132         sprintf (cursor, "%d", device);
2133
2134 #endif /* not DENSITY_LETTER */
2135
2136         if (archive_names == allocated_archive_names)
2137           archive_name_array = x2nrealloc (archive_name_array,
2138                                            &allocated_archive_names,
2139                                            sizeof (archive_name_array[0]));
2140         archive_name_array[archive_names++] = xstrdup (buf);
2141       }
2142       break;
2143
2144 #else /* not DEVICE_PREFIX */
2145
2146       argp_error (state,
2147                   _("Options `-[0-7][lmh]' not supported by *this* tar"));
2148
2149 #endif /* not DEVICE_PREFIX */
2150
2151     default:
2152       return ARGP_ERR_UNKNOWN;
2153     }
2154   return 0;
2155 }
2156
2157 static struct argp argp = {
2158   options,
2159   parse_opt,
2160   N_("[FILE]..."),
2161   doc,
2162   NULL,
2163   tar_help_filter,
2164   NULL
2165 };
2166
2167 void
2168 usage (int status)
2169 {
2170   argp_help (&argp, stderr, ARGP_HELP_SEE, (char*) program_name);
2171   close_stdout ();
2172   exit (status);
2173 }
2174
2175 /* Parse the options for tar.  */
2176
2177 static struct argp_option *
2178 find_argp_option (struct argp_option *o, int letter)
2179 {
2180   for (;
2181        !(o->name == NULL
2182          && o->key == 0
2183          && o->arg == 0
2184          && o->flags == 0
2185          && o->doc == NULL); o++)
2186     if (o->key == letter)
2187       return o;
2188   return NULL;
2189 }
2190
2191 static const char *tar_authors[] = {
2192   "John Gilmore",
2193   "Jay Fenlason",
2194   NULL
2195 };
2196
2197 static void
2198 decode_options (int argc, char **argv)
2199 {
2200   int idx;
2201   struct tar_args args;
2202
2203   argp_version_setup ("tar", tar_authors);
2204
2205   /* Set some default option values.  */
2206   args.textual_date = NULL;
2207   args.wildcards = default_wildcards;
2208   args.matching_flags = 0;
2209   args.include_anchored = EXCLUDE_ANCHORED;
2210   args.o_option = false;
2211   args.pax_option = false;
2212   args.backup_suffix_string = getenv ("SIMPLE_BACKUP_SUFFIX");
2213   args.version_control_string = 0;
2214   args.input_files = false;
2215   args.compress_autodetect = false;
2216
2217   subcommand_option = UNKNOWN_SUBCOMMAND;
2218   archive_format = DEFAULT_FORMAT;
2219   blocking_factor = DEFAULT_BLOCKING;
2220   record_size = DEFAULT_BLOCKING * BLOCKSIZE;
2221   excluded = new_exclude ();
2222   newer_mtime_option.tv_sec = TYPE_MINIMUM (time_t);
2223   newer_mtime_option.tv_nsec = -1;
2224   recursion_option = FNM_LEADING_DIR;
2225   unquote_option = true;
2226   tar_sparse_major = 1;
2227   tar_sparse_minor = 0;
2228
2229   owner_option = -1;
2230   group_option = -1;
2231
2232   check_device_option = true;
2233
2234   incremental_level = -1;
2235
2236   seek_option = -1;
2237
2238   /* Convert old-style tar call by exploding option element and rearranging
2239      options accordingly.  */
2240
2241   if (argc > 1 && argv[1][0] != '-')
2242     {
2243       int new_argc;             /* argc value for rearranged arguments */
2244       char **new_argv;          /* argv value for rearranged arguments */
2245       char *const *in;          /* cursor into original argv */
2246       char **out;               /* cursor into rearranged argv */
2247       const char *letter;       /* cursor into old option letters */
2248       char buffer[3];           /* constructed option buffer */
2249
2250       /* Initialize a constructed option.  */
2251
2252       buffer[0] = '-';
2253       buffer[2] = '\0';
2254
2255       /* Allocate a new argument array, and copy program name in it.  */
2256
2257       new_argc = argc - 1 + strlen (argv[1]);
2258       new_argv = xmalloc ((new_argc + 1) * sizeof (char *));
2259       in = argv;
2260       out = new_argv;
2261       *out++ = *in++;
2262
2263       /* Copy each old letter option as a separate option, and have the
2264          corresponding argument moved next to it.  */
2265
2266       for (letter = *in++; *letter; letter++)
2267         {
2268           struct argp_option *opt;
2269
2270           buffer[1] = *letter;
2271           *out++ = xstrdup (buffer);
2272           opt = find_argp_option (options, *letter);
2273           if (opt && opt->arg)
2274             {
2275               if (in < argv + argc)
2276                 *out++ = *in++;
2277               else
2278                 USAGE_ERROR ((0, 0, _("Old option `%c' requires an argument."),
2279                               *letter));
2280             }
2281         }
2282
2283       /* Copy all remaining options.  */
2284
2285       while (in < argv + argc)
2286         *out++ = *in++;
2287       *out = 0;
2288
2289       /* Replace the old option list by the new one.  */
2290
2291       argc = new_argc;
2292       argv = new_argv;
2293     }
2294
2295   /* Parse all options and non-options as they appear.  */
2296
2297   prepend_default_options (getenv ("TAR_OPTIONS"), &argc, &argv);
2298
2299   if (argp_parse (&argp, argc, argv, ARGP_IN_ORDER, &idx, &args))
2300     exit (TAREXIT_FAILURE);
2301
2302
2303   /* Special handling for 'o' option:
2304
2305      GNU tar used to say "output old format".
2306      UNIX98 tar says don't chown files after extracting (we use
2307      "--no-same-owner" for this).
2308
2309      The old GNU tar semantics is retained when used with --create
2310      option, otherwise UNIX98 semantics is assumed */
2311
2312   if (args.o_option)
2313     {
2314       if (subcommand_option == CREATE_SUBCOMMAND)
2315         {
2316           /* GNU Tar <= 1.13 compatibility */
2317           set_archive_format ("v7");
2318         }
2319       else
2320         {
2321           /* UNIX98 compatibility */
2322           same_owner_option = -1;
2323         }
2324     }
2325
2326   /* Handle operands after any "--" argument.  */
2327   for (; idx < argc; idx++)
2328     {
2329       name_add_name (argv[idx], MAKE_INCL_OPTIONS (&args));
2330       args.input_files = true;
2331     }
2332
2333   /* Warn about implicit use of the wildcards in command line arguments.
2334      See TODO */
2335   warn_regex_usage = args.wildcards == default_wildcards;
2336
2337   /* Derive option values and check option consistency.  */
2338
2339   if (archive_format == DEFAULT_FORMAT)
2340     {
2341       if (args.pax_option)
2342         archive_format = POSIX_FORMAT;
2343       else
2344         archive_format = DEFAULT_ARCHIVE_FORMAT;
2345     }
2346
2347   if ((volume_label_option && subcommand_option == CREATE_SUBCOMMAND)
2348       || incremental_option
2349       || multi_volume_option
2350       || sparse_option)
2351     assert_format (FORMAT_MASK (OLDGNU_FORMAT)
2352                    | FORMAT_MASK (GNU_FORMAT)
2353                    | FORMAT_MASK (POSIX_FORMAT));
2354
2355   if (occurrence_option)
2356     {
2357       if (!args.input_files)
2358         USAGE_ERROR ((0, 0,
2359                       _("--occurrence is meaningless without a file list")));
2360       if (subcommand_option != DELETE_SUBCOMMAND
2361           && subcommand_option != DIFF_SUBCOMMAND
2362           && subcommand_option != EXTRACT_SUBCOMMAND
2363           && subcommand_option != LIST_SUBCOMMAND)
2364             USAGE_ERROR ((0, 0,
2365                           _("--occurrence cannot be used in the requested operation mode")));
2366     }
2367
2368   if (archive_names == 0)
2369     {
2370       /* If no archive file name given, try TAPE from the environment, or
2371          else, DEFAULT_ARCHIVE from the configuration process.  */
2372
2373       archive_names = 1;
2374       archive_name_array[0] = getenv ("TAPE");
2375       if (! archive_name_array[0])
2376         archive_name_array[0] = DEFAULT_ARCHIVE;
2377     }
2378
2379   /* Allow multiple archives only with `-M'.  */
2380
2381   if (archive_names > 1 && !multi_volume_option)
2382     USAGE_ERROR ((0, 0,
2383                   _("Multiple archive files require `-M' option")));
2384
2385   if (listed_incremental_option
2386       && NEWER_OPTION_INITIALIZED (newer_mtime_option))
2387     USAGE_ERROR ((0, 0,
2388                   _("Cannot combine --listed-incremental with --newer")));
2389   if (incremental_level != -1 && !listed_incremental_option)
2390     WARN ((0, 0,
2391            _("--level is meaningless without --listed-incremental")));
2392
2393   if (volume_label_option)
2394     {
2395       if (archive_format == GNU_FORMAT || archive_format == OLDGNU_FORMAT)
2396         {
2397           size_t volume_label_max_len =
2398             (sizeof current_header->header.name
2399              - 1 /* for trailing '\0' */
2400              - (multi_volume_option
2401                 ? (sizeof " Volume "
2402                    - 1 /* for null at end of " Volume " */
2403                    + INT_STRLEN_BOUND (int) /* for volume number */
2404                    - 1 /* for sign, as 0 <= volno */)
2405                 : 0));
2406           if (volume_label_max_len < strlen (volume_label_option))
2407             USAGE_ERROR ((0, 0,
2408                           ngettext ("%s: Volume label is too long (limit is %lu byte)",
2409                                     "%s: Volume label is too long (limit is %lu bytes)",
2410                                     volume_label_max_len),
2411                           quotearg_colon (volume_label_option),
2412                           (unsigned long) volume_label_max_len));
2413         }
2414       /* else FIXME
2415          Label length in PAX format is limited by the volume size. */
2416     }
2417
2418   if (verify_option)
2419     {
2420       if (multi_volume_option)
2421         USAGE_ERROR ((0, 0, _("Cannot verify multi-volume archives")));
2422       if (use_compress_program_option)
2423         USAGE_ERROR ((0, 0, _("Cannot verify compressed archives")));
2424     }
2425
2426   if (use_compress_program_option)
2427     {
2428       if (multi_volume_option)
2429         USAGE_ERROR ((0, 0, _("Cannot use multi-volume compressed archives")));
2430       if (subcommand_option == UPDATE_SUBCOMMAND
2431           || subcommand_option == APPEND_SUBCOMMAND
2432           || subcommand_option == DELETE_SUBCOMMAND)
2433         USAGE_ERROR ((0, 0, _("Cannot update compressed archives")));
2434       if (subcommand_option == CAT_SUBCOMMAND)
2435         USAGE_ERROR ((0, 0, _("Cannot concatenate compressed archives")));
2436     }
2437
2438   /* It is no harm to use --pax-option on non-pax archives in archive
2439      reading mode. It may even be useful, since it allows to override
2440      file attributes from tar headers. Therefore I allow such usage.
2441      --gray */
2442   if (args.pax_option
2443       && archive_format != POSIX_FORMAT
2444       && (subcommand_option != EXTRACT_SUBCOMMAND
2445           || subcommand_option != DIFF_SUBCOMMAND
2446           || subcommand_option != LIST_SUBCOMMAND))
2447     USAGE_ERROR ((0, 0, _("--pax-option can be used only on POSIX archives")));
2448
2449   /* If ready to unlink hierarchies, so we are for simpler files.  */
2450   if (recursive_unlink_option)
2451     old_files_option = UNLINK_FIRST_OLD_FILES;
2452
2453
2454   if (subcommand_option == TEST_LABEL_SUBCOMMAND)
2455     {
2456       /* --test-label is silent if the user has specified the label name to
2457          compare against. */
2458       if (!args.input_files)
2459         verbose_option++;
2460     }
2461   else if (utc_option)
2462     verbose_option = 2;
2463
2464   if (tape_length_option && tape_length_option < record_size)
2465     USAGE_ERROR ((0, 0, _("Volume length cannot be less than record size")));
2466
2467   if (same_order_option && listed_incremental_option)
2468     USAGE_ERROR ((0, 0, _("--preserve-order is not compatible with "
2469                           "--listed-incremental")));
2470
2471   /* Forbid using -c with no input files whatsoever.  Check that `-f -',
2472      explicit or implied, is used correctly.  */
2473
2474   switch (subcommand_option)
2475     {
2476     case CREATE_SUBCOMMAND:
2477       if (!args.input_files && !files_from_option)
2478         USAGE_ERROR ((0, 0,
2479                       _("Cowardly refusing to create an empty archive")));
2480       if (args.compress_autodetect && archive_names
2481           && strcmp (archive_name_array[0], "-"))
2482         set_comression_program_by_suffix (archive_name_array[0],
2483                                           use_compress_program_option);
2484       break;
2485
2486     case EXTRACT_SUBCOMMAND:
2487     case LIST_SUBCOMMAND:
2488     case DIFF_SUBCOMMAND:
2489     case TEST_LABEL_SUBCOMMAND:
2490       for (archive_name_cursor = archive_name_array;
2491            archive_name_cursor < archive_name_array + archive_names;
2492            archive_name_cursor++)
2493         if (!strcmp (*archive_name_cursor, "-"))
2494           request_stdin ("-f");
2495       break;
2496
2497     case CAT_SUBCOMMAND:
2498     case UPDATE_SUBCOMMAND:
2499     case APPEND_SUBCOMMAND:
2500       for (archive_name_cursor = archive_name_array;
2501            archive_name_cursor < archive_name_array + archive_names;
2502            archive_name_cursor++)
2503         if (!strcmp (*archive_name_cursor, "-"))
2504           USAGE_ERROR ((0, 0,
2505                         _("Options `-Aru' are incompatible with `-f -'")));
2506
2507     default:
2508       break;
2509     }
2510
2511   /* Initialize stdlis */
2512   if (index_file_name)
2513     {
2514       stdlis = fopen (index_file_name, "w");
2515       if (! stdlis)
2516         open_error (index_file_name);
2517     }
2518   else
2519     stdlis = to_stdout_option ? stderr : stdout;
2520
2521   archive_name_cursor = archive_name_array;
2522
2523   /* Prepare for generating backup names.  */
2524
2525   if (args.backup_suffix_string)
2526     simple_backup_suffix = xstrdup (args.backup_suffix_string);
2527
2528   if (backup_option)
2529     {
2530       backup_type = xget_version ("--backup", args.version_control_string);
2531       /* No backup is needed either if explicitely disabled or if
2532          the extracted files are not being written to disk. */
2533       if (backup_type == no_backups || EXTRACT_OVER_PIPE)
2534         backup_option = false;
2535     }
2536
2537   checkpoint_finish_compile ();
2538
2539   report_textual_dates (&args);
2540 }
2541
2542 \f
2543 /* Tar proper.  */
2544
2545 /* Main routine for tar.  */
2546 int
2547 main (int argc, char **argv)
2548 {
2549   set_start_time ();
2550   set_program_name (argv[0]);
2551
2552   setlocale (LC_ALL, "");
2553   bindtextdomain (PACKAGE, LOCALEDIR);
2554   textdomain (PACKAGE);
2555
2556   exit_failure = TAREXIT_FAILURE;
2557   exit_status = TAREXIT_SUCCESS;
2558   filename_terminator = '\n';
2559   set_quoting_style (0, DEFAULT_QUOTING_STYLE);
2560
2561   /* Make sure we have first three descriptors available */
2562   stdopen ();
2563
2564   /* Pre-allocate a few structures.  */
2565
2566   allocated_archive_names = 10;
2567   archive_name_array =
2568     xmalloc (sizeof (const char *) * allocated_archive_names);
2569   archive_names = 0;
2570
2571   obstack_init (&argv_stk);
2572
2573   /* Ensure default behavior for some signals */
2574   signal (SIGPIPE, SIG_IGN);
2575   /* System V fork+wait does not work if SIGCHLD is ignored.  */
2576   signal (SIGCHLD, SIG_DFL);
2577
2578   /* Try to disable the ability to unlink a directory.  */
2579   priv_set_remove_linkdir ();
2580
2581   /* Decode options.  */
2582
2583   decode_options (argc, argv);
2584
2585   name_init ();
2586
2587   /* Main command execution.  */
2588
2589   if (volno_file_option)
2590     init_volume_number ();
2591
2592   switch (subcommand_option)
2593     {
2594     case UNKNOWN_SUBCOMMAND:
2595       USAGE_ERROR ((0, 0,
2596                     _("You must specify one of the `-Acdtrux' or `--test-label'  options")));
2597
2598     case CAT_SUBCOMMAND:
2599     case UPDATE_SUBCOMMAND:
2600     case APPEND_SUBCOMMAND:
2601       update_archive ();
2602       break;
2603
2604     case DELETE_SUBCOMMAND:
2605       delete_archive_members ();
2606       break;
2607
2608     case CREATE_SUBCOMMAND:
2609       create_archive ();
2610       break;
2611
2612     case EXTRACT_SUBCOMMAND:
2613       extr_init ();
2614       read_and (extract_archive);
2615
2616       /* FIXME: should extract_finish () even if an ordinary signal is
2617          received.  */
2618       extract_finish ();
2619
2620       break;
2621
2622     case LIST_SUBCOMMAND:
2623       read_and (list_archive);
2624       break;
2625
2626     case DIFF_SUBCOMMAND:
2627       diff_init ();
2628       read_and (diff_archive);
2629       break;
2630
2631     case TEST_LABEL_SUBCOMMAND:
2632       test_archive_label ();
2633     }
2634
2635   if (totals_option)
2636     print_total_stats ();
2637
2638   if (check_links_option)
2639     check_links ();
2640
2641   if (volno_file_option)
2642     closeout_volume_number ();
2643
2644   /* Dispose of allocated memory, and return.  */
2645
2646   free (archive_name_array);
2647   name_term ();
2648
2649   if (exit_status == TAREXIT_FAILURE)
2650     error (0, 0, _("Exiting with failure status due to previous errors"));
2651
2652   if (stdlis == stdout)
2653     close_stdout ();
2654   else if (ferror (stderr) || fclose (stderr) != 0)
2655     set_exit_status (TAREXIT_FAILURE);
2656
2657   return exit_status;
2658 }
2659
2660 void
2661 tar_stat_init (struct tar_stat_info *st)
2662 {
2663   memset (st, 0, sizeof (*st));
2664 }
2665
2666 void
2667 tar_stat_destroy (struct tar_stat_info *st)
2668 {
2669   free (st->orig_file_name);
2670   free (st->file_name);
2671   free (st->link_name);
2672   free (st->uname);
2673   free (st->gname);
2674   free (st->sparse_map);
2675   free (st->dumpdir);
2676   xheader_destroy (&st->xhdr);
2677   memset (st, 0, sizeof (*st));
2678 }
2679
2680 /* Format mask for all available formats that support nanosecond
2681    timestamp resolution. */
2682 #define NS_PRECISION_FORMAT_MASK FORMAT_MASK (POSIX_FORMAT)
2683
2684 /* Same as timespec_cmp, but ignore nanoseconds if current archive
2685    format does not provide sufficient resolution.  */
2686 int
2687 tar_timespec_cmp (struct timespec a, struct timespec b)
2688 {
2689   if (!(FORMAT_MASK (current_format) & NS_PRECISION_FORMAT_MASK))
2690     a.tv_nsec = b.tv_nsec = 0;
2691   return timespec_cmp (a, b);
2692 }
2693
2694 /* Set tar exit status to VAL, unless it is already indicating
2695    a more serious condition. This relies on the fact that the
2696    values of TAREXIT_ constants are ranged by severity. */
2697 void
2698 set_exit_status (int val)
2699 {
2700   if (val > exit_status)
2701     exit_status = val;
2702 }