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