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