/* Various processing of names.
- Copyright 1988, 1992, 1994, 1996-2001, 2003-2007, 2009, 2013-2014
+ Copyright 1988, 1992, 1994, 1996-2001, 2003-2007, 2009, 2013-2016
Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify it
#include "common.h"
\f
+static void name_add_option (int option, const char *arg);
+static void name_add_dir (const char *name);
+static void name_add_file (const char *name);
+\f
+enum
+ {
+ EXCLUDE_BACKUPS_OPTION = 256,
+ EXCLUDE_CACHES_OPTION,
+ EXCLUDE_CACHES_UNDER_OPTION,
+ EXCLUDE_CACHES_ALL_OPTION,
+ EXCLUDE_OPTION,
+ EXCLUDE_IGNORE_OPTION,
+ EXCLUDE_IGNORE_RECURSIVE_OPTION,
+ EXCLUDE_TAG_OPTION,
+ EXCLUDE_TAG_UNDER_OPTION,
+ EXCLUDE_TAG_ALL_OPTION,
+ EXCLUDE_VCS_OPTION,
+ EXCLUDE_VCS_IGNORES_OPTION,
+ IGNORE_CASE_OPTION,
+ NO_IGNORE_CASE_OPTION,
+ ANCHORED_OPTION,
+ NO_ANCHORED_OPTION,
+ RECURSION_OPTION,
+ NO_RECURSION_OPTION,
+ UNQUOTE_OPTION,
+ NO_UNQUOTE_OPTION,
+ NO_VERBATIM_FILES_FROM_OPTION,
+ NO_WILDCARDS_MATCH_SLASH_OPTION,
+ NO_WILDCARDS_OPTION,
+ NULL_OPTION,
+ NO_NULL_OPTION,
+ VERBATIM_FILES_FROM_OPTION,
+ WILDCARDS_MATCH_SLASH_OPTION,
+ WILDCARDS_OPTION
+ };
+
+static struct argp_option names_options[] = {
+#define GRID 100
+ {NULL, 0, NULL, 0,
+ N_("Local file name selection:"), GRID },
+
+ {"add-file", ARGP_KEY_ARG, N_("FILE"), 0,
+ N_("add given FILE to the archive (useful if its name starts with a dash)"), GRID+1 },
+ {"directory", 'C', N_("DIR"), 0,
+ N_("change to directory DIR"), GRID+1 },
+ {"files-from", 'T', N_("FILE"), 0,
+ N_("get names to extract or create from FILE"), GRID+1 },
+ {"null", NULL_OPTION, 0, 0,
+ N_("-T reads null-terminated names; implies --verbatim-files-from"),
+ GRID+1 },
+ {"no-null", NO_NULL_OPTION, 0, 0,
+ N_("disable the effect of the previous --null option"), GRID+1 },
+ {"unquote", UNQUOTE_OPTION, 0, 0,
+ N_("unquote input file or member names (default)"), GRID+1 },
+ {"no-unquote", NO_UNQUOTE_OPTION, 0, 0,
+ N_("do not unquote input file or member names"), GRID+1 },
+ {"verbatim-files-from", VERBATIM_FILES_FROM_OPTION, 0, 0,
+ N_("-T reads file names verbatim (no option handling)"), GRID+1 },
+ {"no-verbatim-files-from", NO_VERBATIM_FILES_FROM_OPTION, 0, 0,
+ N_("-T treats file names starting with dash as options (default)"),
+ GRID+1 },
+ {"exclude", EXCLUDE_OPTION, N_("PATTERN"), 0,
+ N_("exclude files, given as a PATTERN"), GRID+1 },
+ {"exclude-from", 'X', N_("FILE"), 0,
+ N_("exclude patterns listed in FILE"), GRID+1 },
+ {"exclude-caches", EXCLUDE_CACHES_OPTION, 0, 0,
+ N_("exclude contents of directories containing CACHEDIR.TAG, "
+ "except for the tag file itself"), GRID+1 },
+ {"exclude-caches-under", EXCLUDE_CACHES_UNDER_OPTION, 0, 0,
+ N_("exclude everything under directories containing CACHEDIR.TAG"),
+ GRID+1 },
+ {"exclude-caches-all", EXCLUDE_CACHES_ALL_OPTION, 0, 0,
+ N_("exclude directories containing CACHEDIR.TAG"), GRID+1 },
+ {"exclude-tag", EXCLUDE_TAG_OPTION, N_("FILE"), 0,
+ N_("exclude contents of directories containing FILE, except"
+ " for FILE itself"), GRID+1 },
+ {"exclude-ignore", EXCLUDE_IGNORE_OPTION, N_("FILE"), 0,
+ N_("read exclude patterns for each directory from FILE, if it exists"),
+ GRID+1 },
+ {"exclude-ignore-recursive", EXCLUDE_IGNORE_RECURSIVE_OPTION, N_("FILE"), 0,
+ N_("read exclude patterns for each directory and its subdirectories "
+ "from FILE, if it exists"), GRID+1 },
+ {"exclude-tag-under", EXCLUDE_TAG_UNDER_OPTION, N_("FILE"), 0,
+ N_("exclude everything under directories containing FILE"), GRID+1 },
+ {"exclude-tag-all", EXCLUDE_TAG_ALL_OPTION, N_("FILE"), 0,
+ N_("exclude directories containing FILE"), GRID+1 },
+ {"exclude-vcs", EXCLUDE_VCS_OPTION, NULL, 0,
+ N_("exclude version control system directories"), GRID+1 },
+ {"exclude-vcs-ignores", EXCLUDE_VCS_IGNORES_OPTION, NULL, 0,
+ N_("read exclude patterns from the VCS ignore files"), GRID+1 },
+ {"exclude-backups", EXCLUDE_BACKUPS_OPTION, NULL, 0,
+ N_("exclude backup and lock files"), GRID+1 },
+ {"recursion", RECURSION_OPTION, 0, 0,
+ N_("recurse into directories (default)"), GRID+1 },
+ {"no-recursion", NO_RECURSION_OPTION, 0, 0,
+ N_("avoid descending automatically in directories"), GRID+1 },
+#undef GRID
+
+#define GRID 120
+ {NULL, 0, NULL, 0,
+ N_("File name matching options (affect both exclude and include patterns):"),
+ GRID },
+ {"anchored", ANCHORED_OPTION, 0, 0,
+ N_("patterns match file name start"), GRID+1 },
+ {"no-anchored", NO_ANCHORED_OPTION, 0, 0,
+ N_("patterns match after any '/' (default for exclusion)"), GRID+1 },
+ {"ignore-case", IGNORE_CASE_OPTION, 0, 0,
+ N_("ignore case"), GRID+1 },
+ {"no-ignore-case", NO_IGNORE_CASE_OPTION, 0, 0,
+ N_("case sensitive matching (default)"), GRID+1 },
+ {"wildcards", WILDCARDS_OPTION, 0, 0,
+ N_("use wildcards (default for exclusion)"), GRID+1 },
+ {"no-wildcards", NO_WILDCARDS_OPTION, 0, 0,
+ N_("verbatim string matching"), GRID+1 },
+ {"wildcards-match-slash", WILDCARDS_MATCH_SLASH_OPTION, 0, 0,
+ N_("wildcards match '/' (default for exclusion)"), GRID+1 },
+ {"no-wildcards-match-slash", NO_WILDCARDS_MATCH_SLASH_OPTION, 0, 0,
+ N_("wildcards do not match '/'"), GRID+1 },
+#undef GRID
+
+ {NULL}
+};
+
+static bool
+is_file_selection_option (int key)
+{
+ struct argp_option *p;
+
+ for (p = names_options;
+ !(p->name == NULL && p->key == 0 && p->doc == NULL); p++)
+ if (p->key == key)
+ return true;
+ return false;
+}
+\f
+/* Either NL or NUL, as decided by the --null option. */
+static char filename_terminator = '\n';
+/* Treat file names read from -T input verbatim */
+static bool verbatim_files_from_option;
+
+static error_t
+names_parse_opt (int key, char *arg, struct argp_state *state)
+{
+ switch (key)
+ {
+ case 'C':
+ name_add_dir (arg);
+ break;
+
+ case 'T':
+ name_add_file (arg);
+ /* Indicate we've been given -T option. This is for backward
+ compatibility only, so that `tar cfT archive /dev/null will
+ succeed */
+ files_from_option = true;
+ break;
+
+ default:
+ if (is_file_selection_option (key))
+ name_add_option (key, arg);
+ else
+ return ARGP_ERR_UNKNOWN;
+ }
+ return 0;
+}
+\f
+/* Wildcard matching settings */
+enum wildcards
+ {
+ default_wildcards, /* For exclusion == enable_wildcards,
+ for inclusion == disable_wildcards */
+ disable_wildcards,
+ enable_wildcards
+ };
+
+static enum wildcards wildcards = default_wildcards;
+ /* Wildcard settings (--wildcards/--no-wildcards) */
+static int matching_flags = 0;
+ /* exclude_fnmatch options */
+static int include_anchored = EXCLUDE_ANCHORED;
+ /* Pattern anchoring options used for file inclusion */
+
+#define EXCLUDE_OPTIONS \
+ (((wildcards != disable_wildcards) ? EXCLUDE_WILDCARDS : 0) \
+ | matching_flags \
+ | recursion_option)
+
+#define INCLUDE_OPTIONS \
+ (((wildcards == enable_wildcards) ? EXCLUDE_WILDCARDS : 0) \
+ | include_anchored \
+ | matching_flags \
+ | recursion_option)
+\f
+static char const * const vcs_file_table[] = {
+ /* CVS: */
+ "CVS",
+ ".cvsignore",
+ /* RCS: */
+ "RCS",
+ /* SCCS: */
+ "SCCS",
+ /* SVN: */
+ ".svn",
+ /* git: */
+ ".git",
+ ".gitignore",
+ ".gitattributes",
+ ".gitmodules",
+ /* Arch: */
+ ".arch-ids",
+ "{arch}",
+ "=RELEASE-ID",
+ "=meta-update",
+ "=update",
+ /* Bazaar */
+ ".bzr",
+ ".bzrignore",
+ ".bzrtags",
+ /* Mercurial */
+ ".hg",
+ ".hgignore",
+ ".hgtags",
+ /* darcs */
+ "_darcs",
+ NULL
+};
+
+static char const * const backup_file_table[] = {
+ ".#*",
+ "*~",
+ "#*#",
+ NULL
+};
+
+static void
+add_exclude_array (char const * const * fv, int opts)
+{
+ int i;
+
+ for (i = 0; fv[i]; i++)
+ add_exclude (excluded, fv[i], opts);
+}
+\f
+static void
+handle_file_selection_option (int key, const char *arg)
+{
+ switch (key)
+ {
+ case EXCLUDE_BACKUPS_OPTION:
+ add_exclude_array (backup_file_table, EXCLUDE_WILDCARDS);
+ break;
+
+ case EXCLUDE_OPTION:
+ add_exclude (excluded, arg, EXCLUDE_OPTIONS);
+ break;
+
+ case EXCLUDE_CACHES_OPTION:
+ add_exclusion_tag ("CACHEDIR.TAG", exclusion_tag_contents,
+ cachedir_file_p);
+ break;
+
+ case EXCLUDE_CACHES_UNDER_OPTION:
+ add_exclusion_tag ("CACHEDIR.TAG", exclusion_tag_under,
+ cachedir_file_p);
+ break;
+
+ case EXCLUDE_CACHES_ALL_OPTION:
+ add_exclusion_tag ("CACHEDIR.TAG", exclusion_tag_all,
+ cachedir_file_p);
+ break;
+
+ case EXCLUDE_IGNORE_OPTION:
+ excfile_add (arg, EXCL_NON_RECURSIVE);
+ break;
+
+ case EXCLUDE_IGNORE_RECURSIVE_OPTION:
+ excfile_add (arg, EXCL_RECURSIVE);
+ break;
+
+ case EXCLUDE_TAG_OPTION:
+ add_exclusion_tag (arg, exclusion_tag_contents, NULL);
+ break;
+
+ case EXCLUDE_TAG_UNDER_OPTION:
+ add_exclusion_tag (arg, exclusion_tag_under, NULL);
+ break;
+
+ case EXCLUDE_TAG_ALL_OPTION:
+ add_exclusion_tag (arg, exclusion_tag_all, NULL);
+ break;
+
+ case EXCLUDE_VCS_OPTION:
+ add_exclude_array (vcs_file_table, 0);
+ break;
+
+ case EXCLUDE_VCS_IGNORES_OPTION:
+ exclude_vcs_ignores ();
+ break;
+
+ case RECURSION_OPTION:
+ recursion_option = FNM_LEADING_DIR;
+ break;
+
+ case NO_RECURSION_OPTION:
+ recursion_option = 0;
+ break;
+
+ case UNQUOTE_OPTION:
+ unquote_option = true;
+ break;
+
+ case NO_UNQUOTE_OPTION:
+ unquote_option = false;
+ break;
+
+ case NULL_OPTION:
+ filename_terminator = '\0';
+ verbatim_files_from_option = true;
+ break;
+
+ case NO_NULL_OPTION:
+ filename_terminator = '\n';
+ verbatim_files_from_option = false;
+ break;
+
+ case 'X':
+ if (add_exclude_file (add_exclude, excluded, arg, EXCLUDE_OPTIONS, '\n')
+ != 0)
+ {
+ int e = errno;
+ FATAL_ERROR ((0, e, "%s", quotearg_colon (arg)));
+ }
+ break;
+
+ case ANCHORED_OPTION:
+ matching_flags |= EXCLUDE_ANCHORED;
+ break;
+
+ case NO_ANCHORED_OPTION:
+ include_anchored = 0; /* Clear the default for comman line args */
+ matching_flags &= ~ EXCLUDE_ANCHORED;
+ break;
+
+ case IGNORE_CASE_OPTION:
+ matching_flags |= FNM_CASEFOLD;
+ break;
+
+ case NO_IGNORE_CASE_OPTION:
+ matching_flags &= ~ FNM_CASEFOLD;
+ break;
+
+ case WILDCARDS_OPTION:
+ wildcards = enable_wildcards;
+ break;
+
+ case NO_WILDCARDS_OPTION:
+ wildcards = disable_wildcards;
+ break;
+
+ case WILDCARDS_MATCH_SLASH_OPTION:
+ matching_flags &= ~ FNM_FILE_NAME;
+ break;
+
+ case NO_WILDCARDS_MATCH_SLASH_OPTION:
+ matching_flags |= FNM_FILE_NAME;
+ break;
+
+ case VERBATIM_FILES_FROM_OPTION:
+ verbatim_files_from_option = true;
+ break;
+
+ case NO_VERBATIM_FILES_FROM_OPTION:
+ verbatim_files_from_option = false;
+ break;
+
+ default:
+ FATAL_ERROR ((0, 0, "unhandled positional option %d", key));
+ }
+}
+
+static struct argp names_argp = {
+ names_options,
+ names_parse_opt,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL
+};
+
+struct argp_child names_argp_children[] = {
+ { &names_argp, 0, "", 0 },
+ { NULL }
+};
+\f
/* User and group names. */
/* Make sure you link with the proper libraries if you are running the
/* A name_list element contains entries of three types: */
-#define NELT_NAME 0 /* File name */
-#define NELT_CHDIR 1 /* Change directory request */
-#define NELT_FMASK 2 /* Change fnmatch options request */
-#define NELT_FILE 3 /* Read file names from that file */
-#define NELT_NOOP 4 /* No operation */
+enum nelt_type
+ {
+ NELT_NAME, /* File name */
+ NELT_CHDIR, /* Change directory request */
+ NELT_FILE, /* Read file names from that file */
+ NELT_NOOP, /* No operation */
+ NELT_OPTION /* Filename-selection option */
+ };
struct name_elt /* A name_array element. */
{
struct name_elt *next, *prev;
- char type; /* Element type, see NELT_* constants above */
+ enum nelt_type type; /* Element type, see NELT_* constants above */
union
{
const char *name; /* File or directory name */
- int matching_flags;/* fnmatch options if type == NELT_FMASK */
struct /* File, if type == NELT_FILE */
{
const char *name;/* File name */
+ size_t line; /* Input line number */
int term; /* File name terminator in the list */
+ bool verbatim; /* Verbatim handling of file names: no white-space
+ trimming, no option processing */
FILE *fp;
} file;
+ struct
+ {
+ int option;
+ char const *arg;
+ } opt; /* NELT_OPTION */
} v;
};
free (elt);
}
-/* Add to name_array the file NAME with fnmatch options MATCHING_FLAGS */
+
+/* Add to name_array the file NAME with fnmatch options MATFLAGS */
void
-name_add_name (const char *name, int matching_flags)
+name_add_name (const char *name)
{
- static int prev_flags = 0; /* FIXME: Or EXCLUDE_ANCHORED? */
struct name_elt *ep = name_elt_alloc ();
- if (prev_flags != matching_flags)
- {
- ep->type = NELT_FMASK;
- ep->v.matching_flags = matching_flags;
- prev_flags = matching_flags;
- ep = name_elt_alloc ();
- }
ep->type = NELT_NAME;
ep->v.name = name;
name_count++;
}
+static void
+name_add_option (int option, const char *arg)
+{
+ struct name_elt *elt = name_elt_alloc ();
+ elt->type = NELT_OPTION;
+ elt->v.opt.option = option;
+ elt->v.opt.arg = arg;
+}
+
/* Add to name_array a chdir request for the directory NAME */
-void
+static void
name_add_dir (const char *name)
{
struct name_elt *ep = name_elt_alloc ();
ep->v.name = name;
}
-void
-name_add_file (const char *name, int term)
+static void
+name_add_file (const char *name)
{
struct name_elt *ep = name_elt_alloc ();
+
ep->type = NELT_FILE;
ep->v.file.name = name;
- ep->v.file.term = term;
+ ep->v.file.line = 0;
ep->v.file.fp = NULL;
}
\f
file_id_list = p;
return 0;
}
+
+/* Chop trailing slashes. */
+static void
+chopslash (char *str)
+{
+ char *p = str + strlen (str) - 1;
+ while (p > str && ISSLASH (*p))
+ *p-- = '\0';
+}
\f
enum read_file_list_state /* Result of reading file name from the list file */
{
FILE *fp = ent->v.file.fp;
int term = ent->v.file.term;
+ ++ent->v.file.line;
for (c = getc (fp); c != EOF && c != term; c = getc (fp))
{
if (counter == name_buffer_length)
if (counter == name_buffer_length)
name_buffer = x2realloc (name_buffer, &name_buffer_length);
name_buffer[counter] = 0;
-
+ chopslash (name_buffer);
return (counter == 0 && c == EOF) ? file_list_end : file_list_success;
}
static int
-handle_option (const char *str)
+handle_option (const char *str, struct name_elt const *ent)
{
struct wordsplit ws;
int i;
-
+ struct option_locus loc;
+
while (*str && isspace (*str))
++str;
if (*str != '-')
if (wordsplit (str, &ws, WRDSF_DEFFLAGS|WRDSF_DOOFFS))
FATAL_ERROR ((0, 0, _("cannot split string '%s': %s"),
str, wordsplit_strerror (&ws)));
- ws.ws_wordv[0] = program_invocation_short_name;
- more_options (ws.ws_wordc+ws.ws_offs, ws.ws_wordv);
+ ws.ws_wordv[0] = (char *) program_name;
+ loc.source = OPTS_FILE;
+ loc.name = ent->v.file.name;
+ loc.line = ent->v.file.line;
+ more_options (ws.ws_wordc+ws.ws_offs, ws.ws_wordv, &loc);
for (i = 0; i < ws.ws_wordc+ws.ws_offs; i++)
ws.ws_wordv[i] = NULL;
if ((ent->v.file.fp = fopen (ent->v.file.name, "r")) == NULL)
open_fatal (ent->v.file.name);
}
+ ent->v.file.term = filename_terminator;
+ ent->v.file.verbatim = verbatim_files_from_option;
}
while (1)
case file_list_success:
if (unquote_option)
unquote_string (name_buffer);
- if (handle_option (name_buffer) == 0)
+ if (!ent->v.file.verbatim && handle_option (name_buffer, ent) == 0)
{
name_list_adjust ();
return 1;
{
const char *source;
size_t source_len;
- char *cursor;
source = ep->v.name;
source_len = strlen (source);
name_buffer = xmalloc(name_buffer_length + 2);
}
strcpy (name_buffer, source);
-
- /* Zap trailing slashes. */
- cursor = name_buffer + strlen (name_buffer) - 1;
- while (cursor > name_buffer && ISSLASH (*cursor))
- *cursor-- = '\0';
+ chopslash (name_buffer);
}
\f
-static int matching_flags; /* exclude_fnmatch options */
-
/* Get the next NELT_NAME element from name_array. Result is in
static storage and can't be relied upon across two calls.
If CHANGE_DIRS is true, treat any entries of type NELT_CHDIR as
the request to change to the given directory.
- Entries of type NELT_FMASK cause updates of the matching_flags
- value. */
+*/
static struct name_elt *
name_next_elt (int change_dirs)
{
name_list_advance ();
break;
- case NELT_FMASK:
- matching_flags = ep->v.matching_flags;
- recursion_option = matching_flags & FNM_LEADING_DIR;
- name_list_advance ();
- continue;
-
case NELT_FILE:
if (read_next_name (ep, &entry) == 0)
return &entry;
entry.v.name = name_buffer;
name_list_advance ();
return &entry;
+
+ case NELT_OPTION:
+ handle_file_selection_option (ep->v.opt.option, ep->v.opt.arg);
+ name_list_advance ();
+ continue;
}
}
buffer->change_dir = change_dir;
buffer->next = 0;
buffer->found_count = 0;
- buffer->matching_flags = matching_flags;
+ buffer->matching_flags = INCLUDE_OPTIONS;
buffer->directory = NULL;
buffer->parent = NULL;
buffer->cmdline = true;
name->prev = nametail;
name->next = NULL;
name->found_count = 0;
- name->matching_flags = matching_flags;
+ name->matching_flags = INCLUDE_OPTIONS;
name->change_dir = change_dir;
name->directory = NULL;
name->parent = parent;
{
static int warned_once = 0;
- if (warn_regex_usage && fnmatch_pattern_has_wildcards (name, 0))
+ /* Warn about implicit use of the wildcards in command line arguments.
+ (Default for tar prior to 1.15.91, but changed afterwards) */
+ if (wildcards == default_wildcards
+ && fnmatch_pattern_has_wildcards (name, 0))
{
warned_once = 1;
WARN ((0, 0,
name->found_count = 0;
}
-/* Yield a newly allocated file name consisting of FILE_NAME concatenated to
- NAME, with an intervening slash if FILE_NAME does not already end in one. */
+/* Yield a newly allocated file name consisting of DIR_NAME concatenated to
+ NAME, with an intervening slash if DIR_NAME does not already end in one. */
char *
-new_name (const char *file_name, const char *name)
+make_file_name (const char *directory_name, const char *name)
{
- size_t file_name_len = strlen (file_name);
- size_t namesize = strlen (name) + 1;
- int slash = file_name_len && ! ISSLASH (file_name[file_name_len - 1]);
- char *buffer = xmalloc (file_name_len + slash + namesize);
- memcpy (buffer, file_name, file_name_len);
- buffer[file_name_len] = '/';
- memcpy (buffer + file_name_len + slash, name, namesize);
+ size_t dirlen = strlen (directory_name);
+ size_t namelen = strlen (name) + 1;
+ int slash = dirlen && ! ISSLASH (directory_name[dirlen - 1]);
+ char *buffer = xmalloc (dirlen + slash + namelen);
+ memcpy (buffer, directory_name, dirlen);
+ buffer[dirlen] = '/';
+ memcpy (buffer + dirlen + slash, name, namelen);
return buffer;
}
projects / debian / tar / blobdiff