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