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