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