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