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