+\f
+/* Names from external name file. */
+
+static char *name_buffer; /* buffer to hold the current file name */
+static size_t name_buffer_length; /* allocated length of name_buffer */
+
+/* Set up to gather file names for tar. They can either come from a
+ file or were saved from decoding arguments. */
+void
+name_init (void)
+{
+ name_buffer = xmalloc (NAME_FIELD_SIZE + 2);
+ name_buffer_length = NAME_FIELD_SIZE;
+}
+
+void
+name_term (void)
+{
+ free (name_buffer);
+ free (name_array);
+}
+
+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)
+{
+ static struct name_elt entry;
+ const char *source;
+ char *cursor;
+
+ while (scanned != entries)
+ {
+ struct name_elt *ep;
+ size_t source_len;
+
+ ep = &name_array[scanned++];
+ if (ep->type == NELT_FMASK)
+ {
+ matching_flags = ep->v.matching_flags;
+ continue;
+ }
+
+ source = ep->v.name;
+ source_len = strlen (source);
+ if (name_buffer_length < source_len)
+ {
+ do
+ {
+ name_buffer_length *= 2;
+ if (! name_buffer_length)
+ xalloc_die ();
+ }
+ while (name_buffer_length < source_len);
+
+ free (name_buffer);
+ 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';
+
+ if (change_dirs && ep->type == NELT_CHDIR)
+ {
+ if (chdir (name_buffer) < 0)
+ chdir_fatal (name_buffer);
+ }
+ else
+ {
+ if (unquote_option)
+ unquote_string (name_buffer);
+ entry.type = ep->type;
+ entry.v.name = name_buffer;
+ return &entry;
+ }
+ }
+
+ return NULL;
+}
+
+const char *
+name_next (int change_dirs)
+{
+ struct name_elt *nelt = name_next_elt (change_dirs);
+ return nelt ? nelt->v.name : NULL;
+}
+
+/* Gather names in a list for scanning. Could hash them later if we
+ really care.
+
+ If the names are already sorted to match the archive, we just read
+ them one by one. name_gather reads the first one, and it is called
+ by name_match as appropriate to read the next ones. At EOF, the
+ last name read is just left in the buffer. This option lets users
+ of small machines extract an arbitrary number of files by doing
+ "tar t" and editing down the list of files. */
+
+void
+name_gather (void)
+{
+ /* Buffer able to hold a single name. */
+ static struct name *buffer = NULL;
+
+ struct name_elt *ep;
+
+ if (same_order_option)
+ {
+ static int change_dir;
+
+ while ((ep = name_next_elt (0)) && ep->type == NELT_CHDIR)
+ change_dir = chdir_arg (xstrdup (ep->v.name));
+
+ if (ep)
+ {
+ free_name (buffer);
+ buffer = make_name (ep->v.name);
+ buffer->change_dir = change_dir;
+ buffer->next = 0;
+ buffer->found_count = 0;
+ buffer->matching_flags = matching_flags;
+ buffer->directory = NULL;
+ buffer->parent = NULL;
+ buffer->cmdline = true;
+
+ namelist = nametail = buffer;
+ }
+ else if (change_dir)
+ addname (0, change_dir, false, NULL);
+ }
+ else
+ {
+ /* Non sorted names -- read them all in. */
+ int change_dir = 0;
+
+ for (;;)
+ {
+ int change_dir0 = change_dir;
+ while ((ep = name_next_elt (0)) && ep->type == NELT_CHDIR)
+ change_dir = chdir_arg (xstrdup (ep->v.name));
+
+ if (ep)
+ addname (ep->v.name, change_dir, true, NULL);
+ else
+ {
+ if (change_dir != change_dir0)
+ addname (NULL, change_dir, false, NULL);
+ break;
+ }
+ }
+ }
+}
+
+/* Add a name to the namelist. */
+struct name *
+addname (char const *string, int change_dir, bool cmdline, struct name *parent)
+{
+ struct name *name = make_name (string);
+
+ name->prev = nametail;
+ name->next = NULL;
+ name->found_count = 0;
+ name->matching_flags = matching_flags;
+ name->change_dir = change_dir;
+ name->directory = NULL;
+ name->parent = parent;
+ name->cmdline = cmdline;
+
+ if (nametail)
+ nametail->next = name;
+ else
+ namelist = name;
+ nametail = name;
+ return name;
+}
+
+/* Find a match for FILE_NAME (whose string length is LENGTH) in the name
+ list. */
+static struct name *
+namelist_match (char const *file_name, size_t length)
+{
+ struct name *p;
+
+ for (p = namelist; p; p = p->next)
+ {
+ if (p->name[0]
+ && exclude_fnmatch (p->name, file_name, p->matching_flags))
+ return p;
+ }
+
+ return NULL;
+}
+
+void
+remname (struct name *name)
+{
+ struct name *p;
+
+ if ((p = name->prev) != NULL)
+ p->next = name->next;
+ else
+ namelist = name->next;
+
+ if ((p = name->next) != NULL)
+ p->prev = name->prev;
+ else
+ nametail = name->prev;
+}
+
+/* Return true if and only if name FILE_NAME (from an archive) matches any
+ name from the namelist. */
+bool
+name_match (const char *file_name)
+{
+ size_t length = strlen (file_name);
+
+ while (1)
+ {
+ struct name *cursor = namelist;
+
+ if (!cursor)
+ return true;
+
+ if (cursor->name[0] == 0)
+ {
+ chdir_do (cursor->change_dir);
+ namelist = NULL;
+ nametail = NULL;
+ return true;
+ }
+
+ cursor = namelist_match (file_name, length);
+ if (cursor)
+ {
+ if (!(ISSLASH (file_name[cursor->length]) && recursion_option)
+ || cursor->found_count == 0)
+ cursor->found_count++; /* remember it matched */
+ if (starting_file_option)
+ {
+ free (namelist);
+ namelist = NULL;
+ nametail = NULL;
+ }
+ chdir_do (cursor->change_dir);
+
+ /* We got a match. */
+ return ISFOUND (cursor);
+ }
+
+ /* Filename from archive not found in namelist. If we have the whole
+ namelist here, just return 0. Otherwise, read the next name in and
+ compare it. If this was the last name, namelist->found_count will
+ remain on. If not, we loop to compare the newly read name. */
+
+ if (same_order_option && namelist->found_count)
+ {
+ name_gather (); /* read one more */
+ if (namelist->found_count)
+ return false;
+ }
+ else
+ return false;
+ }
+}
+
+/* Returns true if all names from the namelist were processed.
+ P is the stat_info of the most recently processed entry.
+ The decision is postponed until the next entry is read if:
+
+ 1) P ended with a slash (i.e. it was a directory)
+ 2) P matches any entry from the namelist *and* represents a subdirectory
+ or a file lying under this entry (in the terms of directory structure).
+
+ This is necessary to handle contents of directories. */
+bool
+all_names_found (struct tar_stat_info *p)
+{
+ struct name const *cursor;
+ size_t len;
+
+ if (!p->file_name || occurrence_option == 0 || p->had_trailing_slash)
+ return false;
+ len = strlen (p->file_name);
+ for (cursor = namelist; cursor; cursor = cursor->next)
+ {
+ if ((cursor->name[0] && !WASFOUND (cursor))
+ || (len >= cursor->length && ISSLASH (p->file_name[cursor->length])))
+ return false;
+ }
+ return true;
+}
+
+static int
+regex_usage_warning (const char *name)
+{
+ static int warned_once = 0;
+
+ if (warn_regex_usage && fnmatch_pattern_has_wildcards (name, 0))
+ {
+ warned_once = 1;
+ WARN ((0, 0,
+ _("Pattern matching characters used in file names")));
+ WARN ((0, 0,
+ _("Use --wildcards to enable pattern matching,"
+ " or --no-wildcards to suppress this warning")));
+ }
+ return warned_once;
+}
+
+/* Print the names of things in the namelist that were not matched. */
+void
+names_notfound (void)
+{
+ struct name const *cursor;
+
+ for (cursor = namelist; cursor; cursor = cursor->next)
+ if (!WASFOUND (cursor) && cursor->name[0])
+ {
+ regex_usage_warning (cursor->name);
+ ERROR ((0, 0,
+ (cursor->found_count == 0) ?
+ _("%s: Not found in archive") :
+ _("%s: Required occurrence not found in archive"),
+ quotearg_colon (cursor->name)));
+ }
+
+ /* Don't bother freeing the name list; we're about to exit. */
+ namelist = NULL;
+ nametail = NULL;
+
+ if (same_order_option)
+ {
+ const char *name;
+
+ while ((name = name_next (1)) != NULL)
+ {
+ regex_usage_warning (name);
+ ERROR ((0, 0, _("%s: Not found in archive"),
+ quotearg_colon (name)));
+ }
+ }
+}
+
+void
+label_notfound (void)
+{
+ struct name const *cursor;
+
+ if (!namelist)
+ return;
+
+ for (cursor = namelist; cursor; cursor = cursor->next)
+ if (WASFOUND (cursor))
+ return;
+
+ if (verbose_option)
+ error (0, 0, _("Archive label mismatch"));
+ set_exit_status (TAREXIT_DIFFERS);
+
+ for (cursor = namelist; cursor; cursor = cursor->next)
+ {
+ if (regex_usage_warning (cursor->name))
+ break;
+ }
+
+ /* Don't bother freeing the name list; we're about to exit. */
+ namelist = NULL;
+ nametail = NULL;
+
+ if (same_order_option)
+ {
+ const char *name;
+
+ while ((name = name_next (1)) != NULL
+ && regex_usage_warning (name) == 0)
+ ;
+ }
+}
+\f
+/* Sorting name lists. */
+
+/* Sort *singly* linked LIST of names, of given LENGTH, using COMPARE
+ to order names. Return the sorted list. Note that after calling
+ this function, the `prev' links in list elements are messed up.
+
+ Apart from the type `struct name' and the definition of SUCCESSOR,
+ this is a generic list-sorting function, but it's too painful to
+ make it both generic and portable
+ in C. */
+
+static struct name *
+merge_sort_sll (struct name *list, int length,
+ int (*compare) (struct name const*, struct name const*))
+{
+ struct name *first_list;
+ struct name *second_list;
+ int first_length;
+ int second_length;
+ struct name *result;
+ struct name **merge_point;
+ struct name *cursor;
+ int counter;
+
+# define SUCCESSOR(name) ((name)->next)
+
+ if (length == 1)
+ return list;
+
+ if (length == 2)
+ {
+ if ((*compare) (list, SUCCESSOR (list)) > 0)
+ {
+ result = SUCCESSOR (list);
+ SUCCESSOR (result) = list;
+ SUCCESSOR (list) = 0;
+ return result;
+ }
+ return list;
+ }
+
+ first_list = list;
+ first_length = (length + 1) / 2;
+ second_length = length / 2;
+ for (cursor = list, counter = first_length - 1;
+ counter;
+ cursor = SUCCESSOR (cursor), counter--)
+ continue;
+ second_list = SUCCESSOR (cursor);
+ SUCCESSOR (cursor) = 0;
+
+ first_list = merge_sort_sll (first_list, first_length, compare);
+ second_list = merge_sort_sll (second_list, second_length, compare);
+
+ merge_point = &result;
+ while (first_list && second_list)
+ if ((*compare) (first_list, second_list) < 0)
+ {
+ cursor = SUCCESSOR (first_list);
+ *merge_point = first_list;
+ merge_point = &SUCCESSOR (first_list);
+ first_list = cursor;
+ }
+ else
+ {
+ cursor = SUCCESSOR (second_list);
+ *merge_point = second_list;
+ merge_point = &SUCCESSOR (second_list);
+ second_list = cursor;
+ }
+ if (first_list)
+ *merge_point = first_list;
+ else
+ *merge_point = second_list;
+
+ return result;
+
+#undef SUCCESSOR
+}
+
+/* Sort doubly linked LIST of names, of given LENGTH, using COMPARE
+ to order names. Return the sorted list. */
+static struct name *
+merge_sort (struct name *list, int length,
+ int (*compare) (struct name const*, struct name const*))
+{
+ struct name *head, *p, *prev;
+ head = merge_sort_sll (list, length, compare);
+ /* Fixup prev pointers */
+ for (prev = NULL, p = head; p; prev = p, p = p->next)
+ p->prev = prev;
+ return head;
+}
+
+/* A comparison function for sorting names. Put found names last;
+ break ties by string comparison. */
+
+static int
+compare_names_found (struct name const *n1, struct name const *n2)
+{
+ int found_diff = WASFOUND (n2) - WASFOUND (n1);
+ return found_diff ? found_diff : strcmp (n1->name, n2->name);
+}
+
+/* Simple comparison by names. */
+static int
+compare_names (struct name const *n1, struct name const *n2)
+{
+ return strcmp (n1->name, n2->name);
+}
+
+\f
+/* Add all the dirs under ST to the namelist NAME, descending the
+ directory hierarchy recursively. */
+
+static void
+add_hierarchy_to_namelist (struct tar_stat_info *st, struct name *name)
+{
+ const char *buffer;
+
+ name->directory = scan_directory (st);
+ buffer = directory_contents (name->directory);
+ if (buffer)
+ {
+ struct name *child_head = NULL, *child_tail = NULL;
+ size_t name_length = name->length;
+ size_t allocated_length = (name_length >= NAME_FIELD_SIZE
+ ? name_length + NAME_FIELD_SIZE
+ : NAME_FIELD_SIZE);
+ char *namebuf = xmalloc (allocated_length + 1);
+ /* FIXME: + 2 above? */
+ const char *string;
+ size_t string_length;
+ int change_dir = name->change_dir;
+
+ strcpy (namebuf, name->name);
+ if (! ISSLASH (namebuf[name_length - 1]))
+ {
+ namebuf[name_length++] = '/';
+ namebuf[name_length] = '\0';
+ }
+
+ for (string = buffer; *string; string += string_length + 1)
+ {
+ string_length = strlen (string);
+ if (*string == 'D')
+ {
+ struct name *np;
+ struct tar_stat_info subdir;
+ int subfd;
+
+ if (allocated_length <= name_length + string_length)
+ {
+ do
+ {
+ allocated_length *= 2;
+ if (! allocated_length)
+ xalloc_die ();
+ }
+ while (allocated_length <= name_length + string_length);
+
+ namebuf = xrealloc (namebuf, allocated_length + 1);
+ }
+ strcpy (namebuf + name_length, string + 1);
+ np = addname (namebuf, change_dir, false, name);
+ if (!child_head)
+ child_head = np;
+ else
+ child_tail->sibling = np;
+ child_tail = np;
+
+ tar_stat_init (&subdir);
+ subdir.parent = st;
+ if (st->fd < 0)
+ {
+ subfd = -1;
+ errno = - st->fd;
+ }
+ else
+ subfd = subfile_open (st, string + 1,
+ open_read_flags | O_DIRECTORY);
+ if (subfd < 0)
+ open_diag (namebuf);
+ else
+ {
+ subdir.fd = subfd;
+ if (fstat (subfd, &subdir.stat) != 0)
+ stat_diag (namebuf);
+ else if (! (O_DIRECTORY || S_ISDIR (subdir.stat.st_mode)))
+ {
+ errno = ENOTDIR;
+ open_diag (namebuf);
+ }
+ else
+ {
+ subdir.orig_file_name = xstrdup (namebuf);
+ add_hierarchy_to_namelist (&subdir, np);
+ restore_parent_fd (&subdir);
+ }
+ }
+
+ tar_stat_destroy (&subdir);
+ }
+ }
+
+ free (namebuf);
+ name->child = child_head;
+ }
+}
+\f
+/* Auxiliary functions for hashed table of struct name's. */
+
+static size_t
+name_hash (void const *entry, size_t n_buckets)
+{
+ struct name const *name = entry;
+ return hash_string (name->caname, n_buckets);
+}
+
+/* Compare two directories for equality of their names. */
+static bool
+name_compare (void const *entry1, void const *entry2)
+{
+ struct name const *name1 = entry1;
+ struct name const *name2 = entry2;
+ return strcmp (name1->caname, name2->caname) == 0;
+}
+
+\f
+/* Rebase `name' member of CHILD and all its siblings to
+ the new PARENT. */
+static void
+rebase_child_list (struct name *child, struct name *parent)
+{
+ size_t old_prefix_len = child->parent->length;
+ size_t new_prefix_len = parent->length;
+ char *new_prefix = parent->name;
+
+ for (; child; child = child->sibling)
+ {
+ size_t size = child->length - old_prefix_len + new_prefix_len;
+ char *newp = xmalloc (size + 1);
+ strcpy (newp, new_prefix);
+ strcat (newp, child->name + old_prefix_len);
+ free (child->name);
+ child->name = newp;
+ child->length = size;
+
+ rebase_directory (child->directory,
+ child->parent->name, old_prefix_len,
+ new_prefix, new_prefix_len);
+ }
+}
+
+/* Collect all the names from argv[] (or whatever), expand them into a
+ directory tree, and sort them. This gets only subdirectories, not
+ all files. */
+
+void
+collect_and_sort_names (void)