#include "system.h"
#include <fnmatch.h>
#include <getopt.h>
#include <signal.h>
#if ! defined SIGCHLD && defined SIGCLD
# define SIGCHLD SIGCLD
#endif
#define GLOBAL
#include "common.h"
#include <getdate.h>
#include <localedir.h>
#include <prepargs.h>
#include <quotearg.h>
#include <xstrtol.h>
#ifndef DEFAULT_ARCHIVE_FORMAT
# define DEFAULT_ARCHIVE_FORMAT GNU_FORMAT
#endif
#ifndef DEFAULT_ARCHIVE
# define DEFAULT_ARCHIVE "tar.out"
#endif
#ifndef DEFAULT_BLOCKING
# define DEFAULT_BLOCKING 20
#endif
static const char *stdin_used_by;
void
request_stdin (const char *option)
{
if (stdin_used_by)
USAGE_ERROR ((0, 0, _("Options `-%s' and `-%s' both want standard input"),
stdin_used_by, option));
stdin_used_by = option;
}
int
confirm (const char *message_action, const char *message_name)
{
static FILE *confirm_file;
static int confirm_file_EOF;
if (!confirm_file)
{
if (archive == 0 || stdin_used_by)
{
confirm_file = fopen (TTY_NAME, "r");
if (! confirm_file)
open_fatal (TTY_NAME);
}
else
{
request_stdin ("-w");
confirm_file = stdin;
}
}
fprintf (stdlis, "%s %s?", message_action, quote (message_name));
fflush (stdlis);
{
int reply = confirm_file_EOF ? EOF : getc (confirm_file);
int character;
for (character = reply;
character != '\n';
character = getc (confirm_file))
if (character == EOF)
{
confirm_file_EOF = 1;
fputc ('\n', stdlis);
fflush (stdlis);
break;
}
return reply == 'y' || reply == 'Y';
}
}
static struct fmttab {
char const *name;
enum archive_format fmt;
} const fmttab[] = {
{ "v7", V7_FORMAT },
{ "oldgnu", OLDGNU_FORMAT },
{ "ustar", USTAR_FORMAT },
{ "posix", POSIX_FORMAT },
#if 0
{ "star", STAR_FORMAT },
#endif
{ "gnu", GNU_FORMAT },
{ NULL, 0 }
};
static void
set_archive_format (char const *name)
{
struct fmttab const *p;
for (p = fmttab; strcmp (p->name, name) != 0; )
if (! (++p)->name)
USAGE_ERROR ((0, 0, _("%s: Invalid archive format"),
quotearg_colon (name)));
archive_format = p->fmt;
}
static const char *
archive_format_string (enum archive_format fmt)
{
struct fmttab const *p;
for (p = fmttab; p->name; p++)
if (p->fmt == fmt)
return p->name;
return "unknown?";
}
#define FORMAT_MASK(n) (1<<(n))
static void
assert_format(unsigned fmt_mask)
{
if ((FORMAT_MASK(archive_format) & fmt_mask) == 0)
USAGE_ERROR ((0, 0,
_("GNU features wanted on incompatible archive format")));
}
enum
{
ANCHORED_OPTION = CHAR_MAX + 1,
ATIME_PRESERVE_OPTION,
BACKUP_OPTION,
CHECKPOINT_OPTION,
DELETE_OPTION,
EXCLUDE_OPTION,
FORCE_LOCAL_OPTION,
FORMAT_OPTION,
GROUP_OPTION,
IGNORE_CASE_OPTION,
IGNORE_FAILED_READ_OPTION,
INDEX_FILE_OPTION,
KEEP_NEWER_FILES_OPTION,
MODE_OPTION,
NEWER_MTIME_OPTION,
NO_ANCHORED_OPTION,
NO_IGNORE_CASE_OPTION,
NO_OVERWRITE_DIR_OPTION,
NO_WILDCARDS_OPTION,
NO_WILDCARDS_MATCH_SLASH_OPTION,
NULL_OPTION,
NUMERIC_OWNER_OPTION,
OCCURRENCE_OPTION,
OVERWRITE_OPTION,
OWNER_OPTION,
PAX_OPTION,
POSIX_OPTION,
PRESERVE_OPTION,
RECORD_SIZE_OPTION,
RECURSIVE_UNLINK_OPTION,
REMOVE_FILES_OPTION,
RMT_COMMAND_OPTION,
RSH_COMMAND_OPTION,
SHOW_DEFAULTS_OPTION,
SHOW_OMITTED_DIRS_OPTION,
STRIP_PATH_OPTION,
SUFFIX_OPTION,
TOTALS_OPTION,
USE_COMPRESS_PROGRAM_OPTION,
UTC_OPTION,
VOLNO_FILE_OPTION,
WILDCARDS_OPTION,
WILDCARDS_MATCH_SLASH_OPTION
};
static int show_help;
static int show_version;
static struct option long_options[] =
{
{"absolute-names", no_argument, 0, 'P'},
{"after-date", required_argument, 0, 'N'},
{"anchored", no_argument, 0, ANCHORED_OPTION},
{"append", no_argument, 0, 'r'},
{"atime-preserve", no_argument, 0, ATIME_PRESERVE_OPTION},
{"backup", optional_argument, 0, BACKUP_OPTION},
{"block-number", no_argument, 0, 'R'},
{"blocking-factor", required_argument, 0, 'b'},
{"bzip2", no_argument, 0, 'j'},
{"catenate", no_argument, 0, 'A'},
{"checkpoint", no_argument, 0, CHECKPOINT_OPTION},
{"check-links", no_argument, &check_links_option, 1},
{"compare", no_argument, 0, 'd'},
{"compress", no_argument, 0, 'Z'},
{"concatenate", no_argument, 0, 'A'},
{"confirmation", no_argument, 0, 'w'},
{"create", no_argument, 0, 'c'},
{"delete", no_argument, 0, DELETE_OPTION},
{"dereference", no_argument, 0, 'h'},
{"diff", no_argument, 0, 'd'},
{"directory", required_argument, 0, 'C'},
{"exclude", required_argument, 0, EXCLUDE_OPTION},
{"exclude-from", required_argument, 0, 'X'},
{"extract", no_argument, 0, 'x'},
{"file", required_argument, 0, 'f'},
{"files-from", required_argument, 0, 'T'},
{"force-local", no_argument, 0, FORCE_LOCAL_OPTION},
{"format", required_argument, 0, FORMAT_OPTION},
{"get", no_argument, 0, 'x'},
{"group", required_argument, 0, GROUP_OPTION},
{"gunzip", no_argument, 0, 'z'},
{"gzip", no_argument, 0, 'z'},
{"help", no_argument, &show_help, 1},
{"ignore-case", no_argument, 0, IGNORE_CASE_OPTION},
{"ignore-failed-read", no_argument, 0, IGNORE_FAILED_READ_OPTION},
{"ignore-zeros", no_argument, 0, 'i'},
{"incremental", no_argument, 0, 'G'},
{"index-file", required_argument, 0, INDEX_FILE_OPTION},
{"info-script", required_argument, 0, 'F'},
{"interactive", no_argument, 0, 'w'},
{"keep-newer-files", no_argument, 0, KEEP_NEWER_FILES_OPTION},
{"keep-old-files", no_argument, 0, 'k'},
{"label", required_argument, 0, 'V'},
{"list", no_argument, 0, 't'},
{"listed-incremental", required_argument, 0, 'g'},
{"mode", required_argument, 0, MODE_OPTION},
{"multi-volume", no_argument, 0, 'M'},
{"new-volume-script", required_argument, 0, 'F'},
{"newer", required_argument, 0, 'N'},
{"newer-mtime", required_argument, 0, NEWER_MTIME_OPTION},
{"null", no_argument, 0, NULL_OPTION},
{"no-anchored", no_argument, 0, NO_ANCHORED_OPTION},
{"no-ignore-case", no_argument, 0, NO_IGNORE_CASE_OPTION},
{"no-overwrite-dir", no_argument, 0, NO_OVERWRITE_DIR_OPTION},
{"no-wildcards", no_argument, 0, NO_WILDCARDS_OPTION},
{"no-wildcards-match-slash", no_argument, 0, NO_WILDCARDS_MATCH_SLASH_OPTION},
{"no-recursion", no_argument, &recursion_option, 0},
{"no-same-owner", no_argument, &same_owner_option, -1},
{"no-same-permissions", no_argument, &same_permissions_option, -1},
{"numeric-owner", no_argument, 0, NUMERIC_OWNER_OPTION},
{"occurrence", optional_argument, 0, OCCURRENCE_OPTION},
{"old-archive", no_argument, 0, 'o'},
{"one-file-system", no_argument, 0, 'l'},
{"overwrite", no_argument, 0, OVERWRITE_OPTION},
{"owner", required_argument, 0, OWNER_OPTION},
{"pax-option", required_argument, 0, PAX_OPTION},
{"portability", no_argument, 0, 'o'},
{"posix", no_argument, 0, POSIX_OPTION},
{"preserve", no_argument, 0, PRESERVE_OPTION},
{"preserve-order", no_argument, 0, 's'},
{"preserve-permissions", no_argument, 0, 'p'},
{"recursion", no_argument, &recursion_option, FNM_LEADING_DIR},
{"recursive-unlink", no_argument, 0, RECURSIVE_UNLINK_OPTION},
{"read-full-records", no_argument, 0, 'B'},
{"record-size", required_argument, 0, RECORD_SIZE_OPTION},
{"remove-files", no_argument, 0, REMOVE_FILES_OPTION},
{"rmt-command", required_argument, 0, RMT_COMMAND_OPTION},
{"rsh-command", required_argument, 0, RSH_COMMAND_OPTION},
{"same-order", no_argument, 0, 's'},
{"same-owner", no_argument, &same_owner_option, 1},
{"same-permissions", no_argument, 0, 'p'},
{"show-defaults", no_argument, 0, SHOW_DEFAULTS_OPTION},
{"show-omitted-dirs", no_argument, 0, SHOW_OMITTED_DIRS_OPTION},
{"sparse", no_argument, 0, 'S'},
{"starting-file", required_argument, 0, 'K'},
{"strip-path", required_argument, 0, STRIP_PATH_OPTION },
{"suffix", required_argument, 0, SUFFIX_OPTION},
{"tape-length", required_argument, 0, 'L'},
{"to-stdout", no_argument, 0, 'O'},
{"totals", no_argument, 0, TOTALS_OPTION},
{"touch", no_argument, 0, 'm'},
{"uncompress", no_argument, 0, 'Z'},
{"ungzip", no_argument, 0, 'z'},
{"unlink-first", no_argument, 0, 'U'},
{"update", no_argument, 0, 'u'},
{"utc", no_argument, 0, UTC_OPTION },
{"use-compress-program", required_argument, 0, USE_COMPRESS_PROGRAM_OPTION},
{"verbose", no_argument, 0, 'v'},
{"verify", no_argument, 0, 'W'},
{"version", no_argument, &show_version, 1},
{"volno-file", required_argument, 0, VOLNO_FILE_OPTION},
{"wildcards", no_argument, 0, WILDCARDS_OPTION},
{"wildcards-match-slash", no_argument, 0, WILDCARDS_MATCH_SLASH_OPTION},
{0, 0, 0, 0}
};
void
usage (int status)
{
if (status != TAREXIT_SUCCESS)
fprintf (stderr, _("Try `%s --help' for more information.\n"),
program_name);
else
{
fputs (_("\
GNU `tar' saves many files together into a single tape or disk archive, and\n\
can restore individual files from the archive.\n"),
stdout);
printf (_("\nUsage: %s [OPTION]... [FILE]...\n\
\n\
Examples:\n\
%s -cf archive.tar foo bar # Create archive.tar from files foo and bar.\n\
%s -tvf archive.tar # List all files in archive.tar verbosely.\n\
%s -xf archive.tar # Extract all files from archive.tar.\n"),
program_name, program_name, program_name, program_name);
fputs (_("\
\n\
If a long option shows an argument as mandatory, then it is mandatory\n\
for the equivalent short option also. Similarly for optional arguments.\n"),
stdout);
fputs(_("\
\n\
Main operation mode:\n\
-t, --list list the contents of an archive\n\
-x, --extract, --get extract files from an archive\n\
-c, --create create a new archive\n\
-d, --diff, --compare find differences between archive and file system\n\
-r, --append append files to the end of an archive\n\
-u, --update only append files newer than copy in archive\n\
-A, --catenate append tar files to an archive\n\
--concatenate same as -A\n\
--delete delete from the archive (not on mag tapes!)\n"),
stdout);
fputs (_("\
\n\
Operation modifiers:\n\
-W, --verify attempt to verify the archive after writing it\n\
--remove-files remove files after adding them to the archive\n\
-k, --keep-old-files don't replace existing files when extracting\n\
--keep-newer-files don't replace existing files that are newer\n\
than their archive copies\n\
--overwrite overwrite existing files when extracting\n\
--no-overwrite-dir preserve metadata of existing directories\n\
-U, --unlink-first remove each file prior to extracting over it\n\
--recursive-unlink empty hierarchies prior to extracting directory\n\
-S, --sparse handle sparse files efficiently\n\
-O, --to-stdout extract files to standard output\n\
-G, --incremental handle old GNU-format incremental backup\n\
-g, --listed-incremental=FILE\n\
handle new GNU-format incremental backup\n\
--ignore-failed-read do not exit with nonzero on unreadable files\n\
--occurrence[=NUM] process only the NUMth occurrence of each file in\n\
the archive. This option is valid only in\n\
conjunction with one of the subcommands --delete,\n\
--diff, --extract or --list and when a list of\n\
files is given either on the command line or\n\
via -T option.\n\
NUM defaults to 1.\n"),
stdout);
fputs (_("\
\n\
Handling of file attributes:\n\
--owner=NAME force NAME as owner for added files\n\
--group=NAME force NAME as group for added files\n\
--mode=CHANGES force (symbolic) mode CHANGES for added files\n\
--atime-preserve don't change access times on dumped files\n\
-m, --modification-time don't extract file modified time\n\
--same-owner try extracting files with the same ownership\n\
--no-same-owner extract files as yourself\n\
--numeric-owner always use numbers for user/group names\n\
-p, --same-permissions extract permissions information\n\
--no-same-permissions do not extract permissions information\n\
--preserve-permissions same as -p\n\
-s, --same-order sort names to extract to match archive\n\
--preserve-order same as -s\n\
--preserve same as both -p and -s\n"),
stdout);
fputs (_("\
\n\
Device selection and switching:\n\
-f, --file=ARCHIVE use archive file or device ARCHIVE\n\
--force-local archive file is local even if has a colon\n\
--rmt-command=COMMAND use given rmt COMMAND instead of /etc/rmt\n\
--rsh-command=COMMAND use remote COMMAND instead of rsh\n\
-[0-7][lmh] specify drive and density\n\
-M, --multi-volume create/list/extract multi-volume archive\n\
-L, --tape-length=NUM change tape after writing NUM x 1024 bytes\n\
-F, --info-script=FILE run script at end of each tape (implies -M)\n\
--new-volume-script=FILE same as -F FILE\n\
--volno-file=FILE use/update the volume number in FILE\n"),
stdout);
fputs (_("\
\n\
Device blocking:\n\
-b, --blocking-factor=BLOCKS BLOCKS x 512 bytes per record\n\
--record-size=SIZE SIZE bytes per record, multiple of 512\n\
-i, --ignore-zeros ignore zeroed blocks in archive (means EOF)\n\
-B, --read-full-records reblock as we read (for 4.2BSD pipes)\n"),
stdout);
fputs (_("\
\n\
Archive format selection:\n\
--format=FMTNAME create archive of the given format.\n\
FMTNAME is one of the following:\n\
v7 old V7 tar format\n\
oldgnu GNU format as per tar <= 1.12\n\
gnu GNU tar 1.13 format\n\
ustar POSIX 1003.1-1988 (ustar) format\n\
posix POSIX 1003.1-2001 (pax) format\n\
--old-archive, --portability same as --format=v7\n\
--posix same as --format=posix\n\
--pax-option keyword[[:]=value][,keyword[[:]=value], ...]\n\
control pax keywords\n\
-V, --label=NAME create archive with volume name NAME\n\
PATTERN at list/extract time, a globbing PATTERN\n\
-j, --bzip2 filter the archive through bzip2\n\
-z, --gzip, --ungzip filter the archive through gzip\n\
-Z, --compress, --uncompress filter the archive through compress\n\
--use-compress-program=PROG filter through PROG (must accept -d)\n"),
stdout);
fputs (_("\
\n\
Local file selection:\n\
-C, --directory=DIR change to directory DIR\n\
-T, --files-from=NAME get names to extract or create from file NAME\n\
--null -T reads null-terminated names, disable -C\n\
--exclude=PATTERN exclude files, given as a PATTERN\n\
-X, --exclude-from=FILE exclude patterns listed in FILE\n\
--anchored exclude patterns match file name start (default)\n\
--no-anchored exclude patterns match after any /\n\
--ignore-case exclusion ignores case\n\
--no-ignore-case exclusion is case sensitive (default)\n\
--wildcards exclude patterns use wildcards (default)\n\
--no-wildcards exclude patterns are plain strings\n\
--wildcards-match-slash exclude pattern wildcards match '/' (default)\n\
--no-wildcards-match-slash exclude pattern wildcards do not match '/'\n\
-P, --absolute-names don't strip leading `/'s from file names\n\
-h, --dereference dump instead the files symlinks point to\n\
--no-recursion avoid descending automatically in directories\n\
-l, --one-file-system stay in local file system when creating archive\n\
-K, --starting-file=NAME begin at file NAME in the archive\n\
--strip-path=NUM strip NUM leading components from file names\n\
before extraction\n"),
stdout);
#if !MSDOS
fputs (_("\
-N, --newer=DATE-OR-FILE only store files newer than DATE-OR-FILE\n\
--newer-mtime=DATE compare date and time when data changed only\n\
--after-date=DATE same as -N\n"),
stdout);
#endif
fputs (_("\
--backup[=CONTROL] backup before removal, choose version control\n\
--suffix=SUFFIX backup before removal, override usual suffix\n"),
stdout);
fputs (_("\
\n\
Informative output:\n\
--help print this help, then exit\n\
--version print tar program version number, then exit\n\
-v, --verbose verbosely list files processed\n\
--checkpoint print directory names while reading the archive\n\
--check-links print a message if not all links are dumped\n\
--totals print total bytes written while creating archive\n\
--index-file=FILE send verbose output to FILE\n\
--utc print file modification dates in UTC\n\
-R, --block-number show block number within archive with each message\n\
-w, --interactive ask for confirmation for every action\n\
--confirmation same as -w\n"),
stdout);
fputs (_("\
\n\
Compatibility options:\n\
-o when creating, same as --old-archive\n\
when extracting, same as --no-same-owner\n"),
stdout);
fputs (_("\
\n\
The backup suffix is `~', unless set with --suffix or SIMPLE_BACKUP_SUFFIX.\n\
The version control may be set with --backup or VERSION_CONTROL, values are:\n\
\n\
t, numbered make numbered backups\n\
nil, existing numbered if numbered backups exist, simple otherwise\n\
never, simple always make simple backups\n"),
stdout);
printf (_("\
\n\
ARCHIVE may be FILE, HOST:FILE or USER@HOST:FILE; DATE may be a textual date\n\
or a file name starting with `/' or `.', in which case the file's date is used.\n\
*This* `tar' defaults to `--format=%s -f%s -b%d'.\n"),
archive_format_string (DEFAULT_ARCHIVE_FORMAT),
DEFAULT_ARCHIVE, DEFAULT_BLOCKING);
printf (_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
}
exit (status);
}
#define OPTION_STRING \
"-01234567ABC:F:GIK:L:MN:OPRST:UV:WX:Zb:cdf:g:hijklmoprstuvwxyz"
static void
set_subcommand_option (enum subcommand subcommand)
{
if (subcommand_option != UNKNOWN_SUBCOMMAND
&& subcommand_option != subcommand)
USAGE_ERROR ((0, 0,
_("You may not specify more than one `-Acdtrux' option")));
subcommand_option = subcommand;
}
static void
set_use_compress_program_option (const char *string)
{
if (use_compress_program_option && strcmp (use_compress_program_option, string) != 0)
USAGE_ERROR ((0, 0, _("Conflicting compression options")));
use_compress_program_option = string;
}
static void
decode_options (int argc, char **argv)
{
int optchar;
int input_files;
char const *textual_date_option = 0;
char const *backup_suffix_string;
char const *version_control_string = 0;
int exclude_options = EXCLUDE_WILDCARDS;
bool o_option = 0;
int pax_option = 0;
subcommand_option = UNKNOWN_SUBCOMMAND;
archive_format = DEFAULT_FORMAT;
blocking_factor = DEFAULT_BLOCKING;
record_size = DEFAULT_BLOCKING * BLOCKSIZE;
excluded = new_exclude ();
newer_mtime_option.tv_sec = TYPE_MINIMUM (time_t);
newer_mtime_option.tv_nsec = -1;
recursion_option = FNM_LEADING_DIR;
owner_option = -1;
group_option = -1;
backup_suffix_string = getenv ("SIMPLE_BACKUP_SUFFIX");
if (argc > 1 && argv[1][0] != '-')
{
int new_argc;
char **new_argv;
char *const *in;
char **out;
const char *letter;
char buffer[3];
const char *cursor;
buffer[0] = '-';
buffer[2] = '\0';
new_argc = argc - 1 + strlen (argv[1]);
new_argv = xmalloc ((new_argc + 1) * sizeof (char *));
in = argv;
out = new_argv;
*out++ = *in++;
for (letter = *in++; *letter; letter++)
{
buffer[1] = *letter;
*out++ = xstrdup (buffer);
cursor = strchr (OPTION_STRING, *letter);
if (cursor && cursor[1] == ':')
{
if (in < argv + argc)
*out++ = *in++;
else
USAGE_ERROR ((0, 0, _("Old option `%c' requires an argument."),
*letter));
}
}
while (in < argv + argc)
*out++ = *in++;
*out = 0;
argc = new_argc;
argv = new_argv;
}
input_files = 0;
prepend_default_options (getenv ("TAR_OPTIONS"), &argc, &argv);
while (optchar = getopt_long (argc, argv, OPTION_STRING, long_options, 0),
optchar != -1)
switch (optchar)
{
case '?':
usage (TAREXIT_FAILURE);
case 0:
break;
case 1:
name_add (optarg);
input_files++;
break;
case 'A':
set_subcommand_option (CAT_SUBCOMMAND);
break;
case 'b':
{
uintmax_t u;
if (! (xstrtoumax (optarg, 0, 10, &u, "") == LONGINT_OK
&& u == (blocking_factor = u)
&& 0 < blocking_factor
&& u == (record_size = u * BLOCKSIZE) / BLOCKSIZE))
USAGE_ERROR ((0, 0, "%s: %s", quotearg_colon (optarg),
_("Invalid blocking factor")));
}
break;
case 'B':
read_full_records_option = true;
break;
case 'c':
set_subcommand_option (CREATE_SUBCOMMAND);
break;
case 'C':
name_add ("-C");
name_add (optarg);
break;
case 'd':
set_subcommand_option (DIFF_SUBCOMMAND);
break;
case 'f':
if (archive_names == allocated_archive_names)
{
allocated_archive_names *= 2;
archive_name_array =
xrealloc (archive_name_array,
sizeof (const char *) * allocated_archive_names);
}
archive_name_array[archive_names++] = optarg;
break;
case 'F':
info_script_option = optarg;
multi_volume_option = true;
break;
case 'g':
listed_incremental_option = optarg;
after_date_option = true;
case 'G':
incremental_option = true;
break;
case 'h':
dereference_option = true;
break;
case 'i':
ignore_zeros_option = true;
break;
case 'I':
USAGE_ERROR ((0, 0,
_("Warning: the -I option is not supported;"
" perhaps you meant -j or -T?")));
break;
case 'j':
set_use_compress_program_option ("bzip2");
break;
case 'k':
old_files_option = KEEP_OLD_FILES;
break;
case 'K':
starting_file_option = true;
addname (optarg, 0);
break;
case 'l':
one_file_system_option = true;
break;
case 'L':
{
uintmax_t u;
if (xstrtoumax (optarg, 0, 10, &u, "") != LONGINT_OK)
USAGE_ERROR ((0, 0, "%s: %s", quotearg_colon (optarg),
_("Invalid tape length")));
tape_length_option = 1024 * (tarlong) u;
multi_volume_option = true;
}
break;
case 'm':
touch_option = true;
break;
case 'M':
multi_volume_option = true;
break;
#if !MSDOS
case 'N':
after_date_option = true;
case NEWER_MTIME_OPTION:
if (NEWER_OPTION_INITIALIZED (newer_mtime_option))
USAGE_ERROR ((0, 0, _("More than one threshold date")));
if (FILESYSTEM_PREFIX_LEN (optarg) != 0
|| ISSLASH (*optarg)
|| *optarg == '.')
{
struct stat st;
if (deref_stat (dereference_option, optarg, &st) != 0)
{
stat_error (optarg);
USAGE_ERROR ((0, 0, _("Date file not found")));
}
newer_mtime_option.tv_sec = st.st_mtime;
newer_mtime_option.tv_nsec = TIMESPEC_NS (st.st_mtim);
}
else
{
if (! get_date (&newer_mtime_option, optarg, NULL))
{
WARN ((0, 0, _("Substituting %s for unknown date format %s"),
tartime (newer_mtime_option.tv_sec), quote (optarg)));
newer_mtime_option.tv_nsec = 0;
}
else
textual_date_option = optarg;
}
break;
#endif
case 'o':
o_option = true;
break;
case 'O':
to_stdout_option = true;
break;
case 'p':
same_permissions_option = true;
break;
case 'P':
absolute_names_option = true;
break;
case 'r':
set_subcommand_option (APPEND_SUBCOMMAND);
break;
case 'R':
block_number_option = true;
break;
case 's':
same_order_option = true;
break;
case 'S':
sparse_option = true;
break;
case 't':
set_subcommand_option (LIST_SUBCOMMAND);
verbose_option++;
break;
case 'T':
files_from_option = optarg;
break;
case 'u':
set_subcommand_option (UPDATE_SUBCOMMAND);
break;
case 'U':
old_files_option = UNLINK_FIRST_OLD_FILES;
break;
case UTC_OPTION:
utc_option = true;
break;
case 'v':
verbose_option++;
break;
case 'V':
volume_label_option = optarg;
break;
case 'w':
interactive_option = true;
break;
case 'W':
verify_option = true;
break;
case 'x':
set_subcommand_option (EXTRACT_SUBCOMMAND);
break;
case 'X':
if (add_exclude_file (add_exclude, excluded, optarg,
exclude_options | recursion_option, '\n')
!= 0)
{
int e = errno;
FATAL_ERROR ((0, e, "%s", quotearg_colon (optarg)));
}
break;
case 'y':
USAGE_ERROR ((0, 0,
_("Warning: the -y option is not supported;"
" perhaps you meant -j?")));
break;
case 'z':
set_use_compress_program_option ("gzip");
break;
case 'Z':
set_use_compress_program_option ("compress");
break;
case ANCHORED_OPTION:
exclude_options |= EXCLUDE_ANCHORED;
break;
case ATIME_PRESERVE_OPTION:
atime_preserve_option = true;
break;
case CHECKPOINT_OPTION:
checkpoint_option = true;
break;
case BACKUP_OPTION:
backup_option = true;
if (optarg)
version_control_string = optarg;
break;
case DELETE_OPTION:
set_subcommand_option (DELETE_SUBCOMMAND);
break;
case EXCLUDE_OPTION:
add_exclude (excluded, optarg, exclude_options | recursion_option);
break;
case FORCE_LOCAL_OPTION:
force_local_option = true;
break;
case FORMAT_OPTION:
set_archive_format (optarg);
break;
case INDEX_FILE_OPTION:
index_file_name = optarg;
break;
case IGNORE_CASE_OPTION:
exclude_options |= FNM_CASEFOLD;
break;
case IGNORE_FAILED_READ_OPTION:
ignore_failed_read_option = true;
break;
case KEEP_NEWER_FILES_OPTION:
old_files_option = KEEP_NEWER_FILES;
break;
case GROUP_OPTION:
if (! (strlen (optarg) < GNAME_FIELD_SIZE
&& gname_to_gid (optarg, &group_option)))
{
uintmax_t g;
if (xstrtoumax (optarg, 0, 10, &g, "") == LONGINT_OK
&& g == (gid_t) g)
group_option = g;
else
FATAL_ERROR ((0, 0, "%s: %s", quotearg_colon (optarg),
_("%s: Invalid group")));
}
break;
case MODE_OPTION:
mode_option
= mode_compile (optarg,
MODE_MASK_EQUALS | MODE_MASK_PLUS | MODE_MASK_MINUS);
if (mode_option == MODE_INVALID)
FATAL_ERROR ((0, 0, _("Invalid mode given on option")));
if (mode_option == MODE_MEMORY_EXHAUSTED)
xalloc_die ();
break;
case NO_ANCHORED_OPTION:
exclude_options &= ~ EXCLUDE_ANCHORED;
break;
case NO_IGNORE_CASE_OPTION:
exclude_options &= ~ FNM_CASEFOLD;
break;
case NO_OVERWRITE_DIR_OPTION:
old_files_option = NO_OVERWRITE_DIR_OLD_FILES;
break;
case NO_WILDCARDS_OPTION:
exclude_options &= ~ EXCLUDE_WILDCARDS;
break;
case NO_WILDCARDS_MATCH_SLASH_OPTION:
exclude_options |= FNM_FILE_NAME;
break;
case NULL_OPTION:
filename_terminator = '\0';
break;
case NUMERIC_OWNER_OPTION:
numeric_owner_option = true;
break;
case OCCURRENCE_OPTION:
if (!optarg)
occurrence_option = 1;
else
{
uintmax_t u;
if (xstrtoumax (optarg, 0, 10, &u, "") == LONGINT_OK)
occurrence_option = u;
else
FATAL_ERROR ((0, 0, "%s: %s", quotearg_colon (optarg),
_("Invalid number")));
}
break;
case OVERWRITE_OPTION:
old_files_option = OVERWRITE_OLD_FILES;
break;
case OWNER_OPTION:
if (! (strlen (optarg) < UNAME_FIELD_SIZE
&& uname_to_uid (optarg, &owner_option)))
{
uintmax_t u;
if (xstrtoumax (optarg, 0, 10, &u, "") == LONGINT_OK
&& u == (uid_t) u)
owner_option = u;
else
FATAL_ERROR ((0, 0, "%s: %s", quotearg_colon (optarg),
_("Invalid owner")));
}
break;
case PAX_OPTION:
pax_option++;
xheader_set_option (optarg);
break;
case POSIX_OPTION:
set_archive_format ("posix");
break;
case PRESERVE_OPTION:
same_permissions_option = true;
same_order_option = true;
break;
case RECORD_SIZE_OPTION:
{
uintmax_t u;
if (! (xstrtoumax (optarg, 0, 10, &u, "") == LONGINT_OK
&& u == (size_t) u))
USAGE_ERROR ((0, 0, "%s: %s", quotearg_colon (optarg),
_("Invalid record size")));
record_size = u;
if (record_size % BLOCKSIZE != 0)
USAGE_ERROR ((0, 0, _("Record size must be a multiple of %d."),
BLOCKSIZE));
blocking_factor = record_size / BLOCKSIZE;
}
break;
case RECURSIVE_UNLINK_OPTION:
recursive_unlink_option = true;
break;
case REMOVE_FILES_OPTION:
remove_files_option = true;
break;
case RMT_COMMAND_OPTION:
rmt_command_option = optarg;
break;
case RSH_COMMAND_OPTION:
rsh_command_option = optarg;
break;
case SHOW_DEFAULTS_OPTION:
printf ("--format=%s -f%s -b%d\n",
archive_format_string (DEFAULT_ARCHIVE_FORMAT),
DEFAULT_ARCHIVE, DEFAULT_BLOCKING);
exit(0);
case STRIP_PATH_OPTION:
{
uintmax_t u;
if (! (xstrtoumax (optarg, 0, 10, &u, "") == LONGINT_OK
&& u == (size_t) u))
USAGE_ERROR ((0, 0, "%s: %s", quotearg_colon (optarg),
_("Invalid number of elements")));
strip_path_elements = u;
}
break;
case SUFFIX_OPTION:
backup_option = true;
backup_suffix_string = optarg;
break;
case TOTALS_OPTION:
totals_option = true;
break;
case USE_COMPRESS_PROGRAM_OPTION:
set_use_compress_program_option (optarg);
break;
case VOLNO_FILE_OPTION:
volno_file_option = optarg;
break;
case WILDCARDS_OPTION:
exclude_options |= EXCLUDE_WILDCARDS;
break;
case WILDCARDS_MATCH_SLASH_OPTION:
exclude_options &= ~ FNM_FILE_NAME;
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
#ifdef DEVICE_PREFIX
{
int device = optchar - '0';
int density;
static char buf[sizeof DEVICE_PREFIX + 10];
char *cursor;
density = getopt_long (argc, argv, "lmh", 0, 0);
strcpy (buf, DEVICE_PREFIX);
cursor = buf + strlen (buf);
#ifdef DENSITY_LETTER
sprintf (cursor, "%d%c", device, density);
#else
switch (density)
{
case 'l':
#ifdef LOW_NUM
device += LOW_NUM;
#endif
break;
case 'm':
#ifdef MID_NUM
device += MID_NUM;
#else
device += 8;
#endif
break;
case 'h':
#ifdef HGH_NUM
device += HGH_NUM;
#else
device += 16;
#endif
break;
default:
usage (TAREXIT_FAILURE);
}
sprintf (cursor, "%d", device);
#endif
if (archive_names == allocated_archive_names)
{
allocated_archive_names *= 2;
archive_name_array =
xrealloc (archive_name_array,
sizeof (const char *) * allocated_archive_names);
}
archive_name_array[archive_names++] = strdup (buf);
}
break;
#else
USAGE_ERROR ((0, 0,
_("Options `-[0-7][lmh]' not supported by *this* tar")));
#endif
}
if (o_option)
{
if (subcommand_option == CREATE_SUBCOMMAND)
{
set_archive_format ("v7");
}
else
{
same_owner_option = 1;
}
}
for (; optind < argc; optind++)
{
name_add (argv[optind]);
input_files++;
}
if (show_version)
{
printf ("tar (%s) %s +CVE-2006-6097\n%s\n", PACKAGE_NAME, PACKAGE_VERSION,
"Copyright (C) 2004 Free Software Foundation, Inc.");
puts (_("\
This program comes with NO WARRANTY, to the extent permitted by law.\n\
You may redistribute it under the terms of the GNU General Public License;\n\
see the file named COPYING for details."));
puts (_("Written by John Gilmore and Jay Fenlason."));
puts (_("Modified to support extended attributes."));
exit (TAREXIT_SUCCESS);
}
if (show_help)
usage (TAREXIT_SUCCESS);
if (archive_format == DEFAULT_FORMAT)
{
if (pax_option)
archive_format = POSIX_FORMAT;
else
archive_format = DEFAULT_ARCHIVE_FORMAT;
}
if (volume_label_option && subcommand_option == CREATE_SUBCOMMAND)
assert_format (FORMAT_MASK (OLDGNU_FORMAT)
| FORMAT_MASK (GNU_FORMAT));
if (incremental_option || multi_volume_option)
assert_format (FORMAT_MASK (OLDGNU_FORMAT) | FORMAT_MASK (GNU_FORMAT));
if (sparse_option)
assert_format (FORMAT_MASK (OLDGNU_FORMAT)
| FORMAT_MASK (GNU_FORMAT)
| FORMAT_MASK (POSIX_FORMAT));
if (occurrence_option)
{
if (!input_files && !files_from_option)
USAGE_ERROR ((0, 0,
_("--occurrence is meaningless without a file list")));
if (subcommand_option != DELETE_SUBCOMMAND
&& subcommand_option != DIFF_SUBCOMMAND
&& subcommand_option != EXTRACT_SUBCOMMAND
&& subcommand_option != LIST_SUBCOMMAND)
USAGE_ERROR ((0, 0,
_("--occurrence cannot be used in the requested operation mode")));
}
if (archive_names == 0)
{
archive_names = 1;
archive_name_array[0] = getenv ("TAPE");
if (! archive_name_array[0])
archive_name_array[0] = DEFAULT_ARCHIVE;
}
if (archive_names > 1 && !multi_volume_option)
USAGE_ERROR ((0, 0,
_("Multiple archive files require `-M' option")));
if (listed_incremental_option
&& NEWER_OPTION_INITIALIZED (newer_mtime_option))
USAGE_ERROR ((0, 0,
_("Cannot combine --listed-incremental with --newer")));
if (volume_label_option)
{
size_t volume_label_max_len =
(sizeof current_header->header.name
- 1
- (multi_volume_option
? (sizeof " Volume "
- 1
+ INT_STRLEN_BOUND (int)
- 1 )
: 0));
if (volume_label_max_len < strlen (volume_label_option))
USAGE_ERROR ((0, 0,
ngettext ("%s: Volume label is too long (limit is %lu byte)",
"%s: Volume label is too long (limit is %lu bytes)",
volume_label_max_len),
quotearg_colon (volume_label_option),
(unsigned long) volume_label_max_len));
}
if (verify_option)
{
if (multi_volume_option)
USAGE_ERROR ((0, 0, _("Cannot verify multi-volume archives")));
if (use_compress_program_option)
USAGE_ERROR ((0, 0, _("Cannot verify compressed archives")));
}
if (use_compress_program_option)
{
if (multi_volume_option)
USAGE_ERROR ((0, 0, _("Cannot use multi-volume compressed archives")));
if (subcommand_option == UPDATE_SUBCOMMAND)
USAGE_ERROR ((0, 0, _("Cannot update compressed archives")));
}
if (pax_option
&& archive_format != POSIX_FORMAT
&& (subcommand_option != EXTRACT_SUBCOMMAND
|| subcommand_option != DIFF_SUBCOMMAND
|| subcommand_option != LIST_SUBCOMMAND))
USAGE_ERROR ((0, 0, _("--pax-option can be used only on POSIX archives")));
if (recursive_unlink_option)
old_files_option = UNLINK_FIRST_OLD_FILES;
if (utc_option)
verbose_option = 2;
if (!rmt_command_option)
rmt_command_option = DEFAULT_RMT_COMMAND;
switch (subcommand_option)
{
case CREATE_SUBCOMMAND:
if (input_files == 0 && !files_from_option)
USAGE_ERROR ((0, 0,
_("Cowardly refusing to create an empty archive")));
break;
case EXTRACT_SUBCOMMAND:
case LIST_SUBCOMMAND:
case DIFF_SUBCOMMAND:
for (archive_name_cursor = archive_name_array;
archive_name_cursor < archive_name_array + archive_names;
archive_name_cursor++)
if (!strcmp (*archive_name_cursor, "-"))
request_stdin ("-f");
break;
case CAT_SUBCOMMAND:
case UPDATE_SUBCOMMAND:
case APPEND_SUBCOMMAND:
for (archive_name_cursor = archive_name_array;
archive_name_cursor < archive_name_array + archive_names;
archive_name_cursor++)
if (!strcmp (*archive_name_cursor, "-"))
USAGE_ERROR ((0, 0,
_("Options `-Aru' are incompatible with `-f -'")));
default:
break;
}
archive_name_cursor = archive_name_array;
if (backup_suffix_string)
simple_backup_suffix = xstrdup (backup_suffix_string);
if (backup_option)
backup_type = xget_version ("--backup", version_control_string);
if (verbose_option && textual_date_option)
{
char const *treated_as = tartime (newer_mtime_option.tv_sec);
if (strcmp (textual_date_option, treated_as) != 0)
WARN ((0, 0, _("Treating date `%s' as %s + %ld nanoseconds"),
textual_date_option, treated_as, newer_mtime_option.tv_nsec));
}
}
int
main (int argc, char **argv)
{
#if HAVE_CLOCK_GETTIME
if (clock_gettime (CLOCK_REALTIME, &start_timespec) != 0)
#endif
start_time = time (0);
program_name = argv[0];
setlocale (LC_ALL, "");
bindtextdomain (PACKAGE, LOCALEDIR);
textdomain (PACKAGE);
exit_status = TAREXIT_SUCCESS;
filename_terminator = '\n';
set_quoting_style (0, escape_quoting_style);
allocated_archive_names = 10;
archive_name_array =
xmalloc (sizeof (const char *) * allocated_archive_names);
archive_names = 0;
#ifdef SIGCHLD
signal (SIGCHLD, SIG_DFL);
#endif
init_names ();
decode_options (argc, argv);
name_init ();
if (volno_file_option)
init_volume_number ();
switch (subcommand_option)
{
case UNKNOWN_SUBCOMMAND:
USAGE_ERROR ((0, 0,
_("You must specify one of the `-Acdtrux' options")));
case CAT_SUBCOMMAND:
case UPDATE_SUBCOMMAND:
case APPEND_SUBCOMMAND:
update_archive ();
break;
case DELETE_SUBCOMMAND:
delete_archive_members ();
break;
case CREATE_SUBCOMMAND:
create_archive ();
name_close ();
if (totals_option)
print_total_written ();
break;
case EXTRACT_SUBCOMMAND:
extr_init ();
read_and (extract_archive);
extract_finish ();
break;
case LIST_SUBCOMMAND:
read_and (list_archive);
break;
case DIFF_SUBCOMMAND:
diff_init ();
read_and (diff_archive);
break;
}
if (check_links_option)
check_links ();
if (volno_file_option)
closeout_volume_number ();
free (archive_name_array);
name_term ();
if (stdlis != stderr && (ferror (stdlis) || fclose (stdlis) != 0))
FATAL_ERROR ((0, 0, _("Error in writing to standard output")));
if (exit_status == TAREXIT_FAILURE)
error (0, 0, _("Error exit delayed from previous errors"));
if (ferror (stderr) || fclose (stderr) != 0)
exit_status = TAREXIT_FAILURE;
return exit_status;
}
void
tar_stat_init (struct tar_stat_info *st)
{
memset (st, 0, sizeof (*st));
}
void
tar_stat_destroy (struct tar_stat_info *st)
{
free (st->orig_file_name);
free (st->file_name);
free (st->link_name);
free (st->uname);
free (st->gname);
free (st->sparse_map);
memset (st, 0, sizeof (*st));
}