1 /* Various processing of names.
3 Copyright 1988, 1992, 1994, 1996-2001, 2003-2007, 2009, 2013 Free
4 Software Foundation, Inc.
6 This program is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 3, or (at your option) any later
11 This program is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
14 Public License for more details.
16 You should have received a copy of the GNU General Public License along
17 with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include <wordsplit.h>
29 /* User and group names. */
31 /* Make sure you link with the proper libraries if you are running the
32 Yellow Peril (thanks for the good laugh, Ian J.!), or, euh... NIS.
33 This code should also be modified for non-UNIX systems to do something
36 static char *cached_uname;
37 static char *cached_gname;
39 static uid_t cached_uid; /* valid only if cached_uname is not empty */
40 static gid_t cached_gid; /* valid only if cached_gname is not empty */
42 /* These variables are valid only if nonempty. */
43 static char *cached_no_such_uname;
44 static char *cached_no_such_gname;
46 /* These variables are valid only if nonzero. It's not worth optimizing
47 the case for weird systems where 0 is not a valid uid or gid. */
48 static uid_t cached_no_such_uid;
49 static gid_t cached_no_such_gid;
51 /* Given UID, find the corresponding UNAME. */
53 uid_to_uname (uid_t uid, char **uname)
55 struct passwd *passwd;
57 if (uid != 0 && uid == cached_no_such_uid)
59 *uname = xstrdup ("");
63 if (!cached_uname || uid != cached_uid)
65 passwd = getpwuid (uid);
69 assign_string (&cached_uname, passwd->pw_name);
73 cached_no_such_uid = uid;
74 *uname = xstrdup ("");
78 *uname = xstrdup (cached_uname);
81 /* Given GID, find the corresponding GNAME. */
83 gid_to_gname (gid_t gid, char **gname)
87 if (gid != 0 && gid == cached_no_such_gid)
89 *gname = xstrdup ("");
93 if (!cached_gname || gid != cached_gid)
95 group = getgrgid (gid);
99 assign_string (&cached_gname, group->gr_name);
103 cached_no_such_gid = gid;
104 *gname = xstrdup ("");
108 *gname = xstrdup (cached_gname);
111 /* Given UNAME, set the corresponding UID and return 1, or else, return 0. */
113 uname_to_uid (char const *uname, uid_t *uidp)
115 struct passwd *passwd;
117 if (cached_no_such_uname
118 && strcmp (uname, cached_no_such_uname) == 0)
122 || uname[0] != cached_uname[0]
123 || strcmp (uname, cached_uname) != 0)
125 passwd = getpwnam (uname);
128 cached_uid = passwd->pw_uid;
129 assign_string (&cached_uname, passwd->pw_name);
133 assign_string (&cached_no_such_uname, uname);
141 /* Given GNAME, set the corresponding GID and return 1, or else, return 0. */
143 gname_to_gid (char const *gname, gid_t *gidp)
147 if (cached_no_such_gname
148 && strcmp (gname, cached_no_such_gname) == 0)
152 || gname[0] != cached_gname[0]
153 || strcmp (gname, cached_gname) != 0)
155 group = getgrnam (gname);
158 cached_gid = group->gr_gid;
159 assign_string (&cached_gname, gname);
163 assign_string (&cached_no_such_gname, gname);
173 make_name (const char *file_name)
175 struct name *p = xzalloc (sizeof (*p));
178 p->name = xstrdup (file_name);
179 p->length = strlen (p->name);
184 free_name (struct name *p)
195 /* Names from the command call. */
197 static struct name *namelist; /* first name in list, if any */
198 static struct name *nametail; /* end of name list */
200 /* File name arguments are processed in two stages: first a
201 name element list (see below) is filled, then the names from it
202 are moved into the namelist.
204 This awkward process is needed only to implement --same-order option,
205 which is meant to help process large archives on machines with
206 limited memory. With this option on, namelist contains at most one
207 entry, which diminishes the memory consumption.
209 However, I very much doubt if we still need this -- Sergey */
211 /* A name_list element contains entries of three types: */
213 #define NELT_NAME 0 /* File name */
214 #define NELT_CHDIR 1 /* Change directory request */
215 #define NELT_FMASK 2 /* Change fnmatch options request */
216 #define NELT_FILE 3 /* Read file names from that file */
217 #define NELT_NOOP 4 /* No operation */
219 struct name_elt /* A name_array element. */
221 struct name_elt *next, *prev;
222 char type; /* Element type, see NELT_* constants above */
225 const char *name; /* File or directory name */
226 int matching_flags;/* fnmatch options if type == NELT_FMASK */
227 struct /* File, if type == NELT_FILE */
229 const char *name;/* File name */
230 int term; /* File name terminator in the list */
236 static struct name_elt *name_head; /* store a list of names */
237 size_t name_count; /* how many of the entries are names? */
239 static struct name_elt *
240 name_elt_alloc (void)
242 struct name_elt *elt;
244 elt = xmalloc (sizeof (*elt));
248 name_head->prev = name_head->next = NULL;
249 name_head->type = NELT_NOOP;
250 elt = xmalloc (sizeof (*elt));
253 elt->prev = name_head->prev;
255 name_head->prev->next = elt;
256 elt->next = name_head;
257 name_head->prev = elt;
262 name_list_adjust (void)
265 while (name_head->prev)
266 name_head = name_head->prev;
270 name_list_advance (void)
272 struct name_elt *elt = name_head;
273 name_head = elt->next;
275 name_head->prev = NULL;
279 /* Add to name_array the file NAME with fnmatch options MATCHING_FLAGS */
281 name_add_name (const char *name, int matching_flags)
283 static int prev_flags = 0; /* FIXME: Or EXCLUDE_ANCHORED? */
284 struct name_elt *ep = name_elt_alloc ();
286 if (prev_flags != matching_flags)
288 ep->type = NELT_FMASK;
289 ep->v.matching_flags = matching_flags;
290 prev_flags = matching_flags;
291 ep = name_elt_alloc ();
293 ep->type = NELT_NAME;
298 /* Add to name_array a chdir request for the directory NAME */
300 name_add_dir (const char *name)
302 struct name_elt *ep = name_elt_alloc ();
303 ep->type = NELT_CHDIR;
308 name_add_file (const char *name, int term)
310 struct name_elt *ep = name_elt_alloc ();
311 ep->type = NELT_FILE;
312 ep->v.file.name = name;
313 ep->v.file.term = term;
314 ep->v.file.fp = NULL;
317 /* Names from external name file. */
319 static char *name_buffer; /* buffer to hold the current file name */
320 static size_t name_buffer_length; /* allocated length of name_buffer */
322 /* Set up to gather file names for tar. They can either come from a
323 file or were saved from decoding arguments. */
327 name_buffer = xmalloc (NAME_FIELD_SIZE + 2);
328 name_buffer_length = NAME_FIELD_SIZE;
338 /* Prevent recursive inclusion of the same file */
341 struct file_id_list *next;
344 const char *from_file;
347 static struct file_id_list *file_id_list;
349 /* Return the name of the file from which the file names and options
353 file_list_name (void)
355 struct name_elt *elt;
357 for (elt = name_head; elt; elt = elt->next)
358 if (elt->type == NELT_FILE && elt->v.file.fp)
359 return elt->v.file.name;
360 return _("command line");
364 add_file_id (const char *filename)
366 struct file_id_list *p;
368 const char *reading_from;
370 if (stat (filename, &st))
371 stat_fatal (filename);
372 reading_from = file_list_name ();
373 for (p = file_id_list; p; p = p->next)
374 if (p->ino == st.st_ino && p->dev == st.st_dev)
376 int oldc = set_char_quoting (NULL, ':', 1);
378 _("%s: file list requested from %s already read from %s"),
379 quotearg_n (0, filename),
380 reading_from, p->from_file));
381 set_char_quoting (NULL, ':', oldc);
384 p = xmalloc (sizeof *p);
385 p->next = file_id_list;
388 p->from_file = reading_from;
393 enum read_file_list_state /* Result of reading file name from the list file */
395 file_list_success, /* OK, name read successfully */
396 file_list_end, /* End of list file */
397 file_list_zero, /* Zero separator encountered where it should not */
398 file_list_skip /* Empty (zero-length) entry encountered, skip it */
401 /* Read from FP a sequence of characters up to TERM and put them
404 static enum read_file_list_state
405 read_name_from_file (struct name_elt *ent)
409 FILE *fp = ent->v.file.fp;
410 int term = ent->v.file.term;
412 for (c = getc (fp); c != EOF && c != term; c = getc (fp))
414 if (counter == name_buffer_length)
415 name_buffer = x2realloc (name_buffer, &name_buffer_length);
416 name_buffer[counter++] = c;
419 /* We have read a zero separator. The file possibly is
421 return file_list_zero;
425 if (counter == 0 && c != EOF)
426 return file_list_skip;
428 if (counter == name_buffer_length)
429 name_buffer = x2realloc (name_buffer, &name_buffer_length);
430 name_buffer[counter] = 0;
432 return (counter == 0 && c == EOF) ? file_list_end : file_list_success;
436 handle_option (const char *str)
441 while (*str && isspace (*str))
447 if (wordsplit (str, &ws, WRDSF_DEFFLAGS|WRDSF_DOOFFS))
448 FATAL_ERROR ((0, 0, _("cannot split string '%s': %s"),
449 str, wordsplit_strerror (&ws)));
450 ws.ws_wordv[0] = program_invocation_short_name;
451 more_options (ws.ws_wordc+ws.ws_offs, ws.ws_wordv);
452 for (i = 0; i < ws.ws_wordc+ws.ws_offs; i++)
453 ws.ws_wordv[i] = NULL;
455 wordsplit_free (&ws);
460 read_next_name (struct name_elt *ent, struct name_elt *ret)
464 if (!strcmp (ent->v.file.name, "-"))
466 request_stdin ("-T");
467 ent->v.file.fp = stdin;
471 if (add_file_id (ent->v.file.name))
473 name_list_advance ();
476 if ((ent->v.file.fp = fopen (ent->v.file.name, "r")) == NULL)
477 open_fatal (ent->v.file.name);
483 switch (read_name_from_file (ent))
489 WARNOPT (WARN_FILENAME_WITH_NULS,
490 (0, 0, N_("%s: file name read contains nul character"),
491 quotearg_colon (ent->v.file.name)));
492 ent->v.file.term = 0;
494 case file_list_success:
496 unquote_string (name_buffer);
497 if (handle_option (name_buffer) == 0)
502 ret->type = NELT_NAME;
503 ret->v.name = name_buffer;
507 if (strcmp (ent->v.file.name, "-"))
508 fclose (ent->v.file.fp);
509 ent->v.file.fp = NULL;
510 name_list_advance ();
517 copy_name (struct name_elt *ep)
524 source_len = strlen (source);
525 if (name_buffer_length < source_len)
529 name_buffer_length *= 2;
530 if (! name_buffer_length)
533 while (name_buffer_length < source_len);
536 name_buffer = xmalloc(name_buffer_length + 2);
538 strcpy (name_buffer, source);
540 /* Zap trailing slashes. */
541 cursor = name_buffer + strlen (name_buffer) - 1;
542 while (cursor > name_buffer && ISSLASH (*cursor))
547 static int matching_flags; /* exclude_fnmatch options */
549 /* Get the next NELT_NAME element from name_array. Result is in
550 static storage and can't be relied upon across two calls.
552 If CHANGE_DIRS is true, treat any entries of type NELT_CHDIR as
553 the request to change to the given directory.
555 Entries of type NELT_FMASK cause updates of the matching_flags
557 static struct name_elt *
558 name_next_elt (int change_dirs)
560 static struct name_elt entry;
563 while ((ep = name_head) != NULL)
568 name_list_advance ();
572 matching_flags = ep->v.matching_flags;
573 name_list_advance ();
577 if (read_next_name (ep, &entry) == 0)
584 chdir_do (chdir_arg (xstrdup (ep->v.name)));
585 name_list_advance ();
592 unquote_string (name_buffer);
593 entry.type = ep->type;
594 entry.v.name = name_buffer;
595 name_list_advance ();
604 name_next (int change_dirs)
606 struct name_elt *nelt = name_next_elt (change_dirs);
607 return nelt ? nelt->v.name : NULL;
610 /* Gather names in a list for scanning. Could hash them later if we
613 If the names are already sorted to match the archive, we just read
614 them one by one. name_gather reads the first one, and it is called
615 by name_match as appropriate to read the next ones. At EOF, the
616 last name read is just left in the buffer. This option lets users
617 of small machines extract an arbitrary number of files by doing
618 "tar t" and editing down the list of files. */
623 /* Buffer able to hold a single name. */
624 static struct name *buffer = NULL;
628 if (same_order_option)
630 static int change_dir;
632 while ((ep = name_next_elt (0)) && ep->type == NELT_CHDIR)
633 change_dir = chdir_arg (xstrdup (ep->v.name));
638 buffer = make_name (ep->v.name);
639 buffer->change_dir = change_dir;
641 buffer->found_count = 0;
642 buffer->matching_flags = matching_flags;
643 buffer->directory = NULL;
644 buffer->parent = NULL;
645 buffer->cmdline = true;
647 namelist = nametail = buffer;
650 addname (0, change_dir, false, NULL);
654 /* Non sorted names -- read them all in. */
659 int change_dir0 = change_dir;
660 while ((ep = name_next_elt (0)) && ep->type == NELT_CHDIR)
661 change_dir = chdir_arg (xstrdup (ep->v.name));
664 addname (ep->v.name, change_dir, true, NULL);
667 if (change_dir != change_dir0)
668 addname (NULL, change_dir, false, NULL);
675 /* Add a name to the namelist. */
677 addname (char const *string, int change_dir, bool cmdline, struct name *parent)
679 struct name *name = make_name (string);
681 name->prev = nametail;
683 name->found_count = 0;
684 name->matching_flags = matching_flags;
685 name->change_dir = change_dir;
686 name->directory = NULL;
687 name->parent = parent;
688 name->cmdline = cmdline;
691 nametail->next = name;
698 /* Find a match for FILE_NAME (whose string length is LENGTH) in the name
701 namelist_match (char const *file_name, size_t length)
705 for (p = namelist; p; p = p->next)
708 && exclude_fnmatch (p->name, file_name, p->matching_flags))
716 remname (struct name *name)
720 if ((p = name->prev) != NULL)
721 p->next = name->next;
723 namelist = name->next;
725 if ((p = name->next) != NULL)
726 p->prev = name->prev;
728 nametail = name->prev;
731 /* Return true if and only if name FILE_NAME (from an archive) matches any
732 name from the namelist. */
734 name_match (const char *file_name)
736 size_t length = strlen (file_name);
740 struct name *cursor = namelist;
745 if (cursor->name[0] == 0)
747 chdir_do (cursor->change_dir);
753 cursor = namelist_match (file_name, length);
756 if (!(ISSLASH (file_name[cursor->length]) && recursion_option)
757 || cursor->found_count == 0)
758 cursor->found_count++; /* remember it matched */
759 if (starting_file_option)
765 chdir_do (cursor->change_dir);
767 /* We got a match. */
768 return ISFOUND (cursor);
771 /* Filename from archive not found in namelist. If we have the whole
772 namelist here, just return 0. Otherwise, read the next name in and
773 compare it. If this was the last name, namelist->found_count will
774 remain on. If not, we loop to compare the newly read name. */
776 if (same_order_option && namelist->found_count)
778 name_gather (); /* read one more */
779 if (namelist->found_count)
787 /* Returns true if all names from the namelist were processed.
788 P is the stat_info of the most recently processed entry.
789 The decision is postponed until the next entry is read if:
791 1) P ended with a slash (i.e. it was a directory)
792 2) P matches any entry from the namelist *and* represents a subdirectory
793 or a file lying under this entry (in the terms of directory structure).
795 This is necessary to handle contents of directories. */
797 all_names_found (struct tar_stat_info *p)
799 struct name const *cursor;
802 if (!p->file_name || occurrence_option == 0 || p->had_trailing_slash)
804 len = strlen (p->file_name);
805 for (cursor = namelist; cursor; cursor = cursor->next)
807 if ((cursor->name[0] && !WASFOUND (cursor))
808 || (len >= cursor->length && ISSLASH (p->file_name[cursor->length])))
815 regex_usage_warning (const char *name)
817 static int warned_once = 0;
819 if (warn_regex_usage && fnmatch_pattern_has_wildcards (name, 0))
823 _("Pattern matching characters used in file names")));
825 _("Use --wildcards to enable pattern matching,"
826 " or --no-wildcards to suppress this warning")));
831 /* Print the names of things in the namelist that were not matched. */
833 names_notfound (void)
835 struct name const *cursor;
837 for (cursor = namelist; cursor; cursor = cursor->next)
838 if (!WASFOUND (cursor) && cursor->name[0])
840 regex_usage_warning (cursor->name);
842 (cursor->found_count == 0) ?
843 _("%s: Not found in archive") :
844 _("%s: Required occurrence not found in archive"),
845 quotearg_colon (cursor->name)));
848 /* Don't bother freeing the name list; we're about to exit. */
852 if (same_order_option)
856 while ((name = name_next (1)) != NULL)
858 regex_usage_warning (name);
859 ERROR ((0, 0, _("%s: Not found in archive"),
860 quotearg_colon (name)));
866 label_notfound (void)
868 struct name const *cursor;
873 for (cursor = namelist; cursor; cursor = cursor->next)
874 if (WASFOUND (cursor))
878 error (0, 0, _("Archive label mismatch"));
879 set_exit_status (TAREXIT_DIFFERS);
881 for (cursor = namelist; cursor; cursor = cursor->next)
883 if (regex_usage_warning (cursor->name))
887 /* Don't bother freeing the name list; we're about to exit. */
891 if (same_order_option)
895 while ((name = name_next (1)) != NULL
896 && regex_usage_warning (name) == 0)
901 /* Sorting name lists. */
903 /* Sort *singly* linked LIST of names, of given LENGTH, using COMPARE
904 to order names. Return the sorted list. Note that after calling
905 this function, the 'prev' links in list elements are messed up.
907 Apart from the type 'struct name' and the definition of SUCCESSOR,
908 this is a generic list-sorting function, but it's too painful to
909 make it both generic and portable
913 merge_sort_sll (struct name *list, int length,
914 int (*compare) (struct name const*, struct name const*))
916 struct name *first_list;
917 struct name *second_list;
921 struct name **merge_point;
925 # define SUCCESSOR(name) ((name)->next)
932 if ((*compare) (list, SUCCESSOR (list)) > 0)
934 result = SUCCESSOR (list);
935 SUCCESSOR (result) = list;
936 SUCCESSOR (list) = 0;
943 first_length = (length + 1) / 2;
944 second_length = length / 2;
945 for (cursor = list, counter = first_length - 1;
947 cursor = SUCCESSOR (cursor), counter--)
949 second_list = SUCCESSOR (cursor);
950 SUCCESSOR (cursor) = 0;
952 first_list = merge_sort_sll (first_list, first_length, compare);
953 second_list = merge_sort_sll (second_list, second_length, compare);
955 merge_point = &result;
956 while (first_list && second_list)
957 if ((*compare) (first_list, second_list) < 0)
959 cursor = SUCCESSOR (first_list);
960 *merge_point = first_list;
961 merge_point = &SUCCESSOR (first_list);
966 cursor = SUCCESSOR (second_list);
967 *merge_point = second_list;
968 merge_point = &SUCCESSOR (second_list);
969 second_list = cursor;
972 *merge_point = first_list;
974 *merge_point = second_list;
981 /* Sort doubly linked LIST of names, of given LENGTH, using COMPARE
982 to order names. Return the sorted list. */
984 merge_sort (struct name *list, int length,
985 int (*compare) (struct name const*, struct name const*))
987 struct name *head, *p, *prev;
988 head = merge_sort_sll (list, length, compare);
989 /* Fixup prev pointers */
990 for (prev = NULL, p = head; p; prev = p, p = p->next)
995 /* A comparison function for sorting names. Put found names last;
996 break ties by string comparison. */
999 compare_names_found (struct name const *n1, struct name const *n2)
1001 int found_diff = WASFOUND (n2) - WASFOUND (n1);
1002 return found_diff ? found_diff : strcmp (n1->name, n2->name);
1005 /* Simple comparison by names. */
1007 compare_names (struct name const *n1, struct name const *n2)
1009 return strcmp (n1->name, n2->name);
1013 /* Add all the dirs under ST to the namelist NAME, descending the
1014 directory hierarchy recursively. */
1017 add_hierarchy_to_namelist (struct tar_stat_info *st, struct name *name)
1021 name->directory = scan_directory (st);
1022 buffer = directory_contents (name->directory);
1025 struct name *child_head = NULL, *child_tail = NULL;
1026 size_t name_length = name->length;
1027 size_t allocated_length = (name_length >= NAME_FIELD_SIZE
1028 ? name_length + NAME_FIELD_SIZE
1030 char *namebuf = xmalloc (allocated_length + 1);
1031 /* FIXME: + 2 above? */
1033 size_t string_length;
1034 int change_dir = name->change_dir;
1036 strcpy (namebuf, name->name);
1037 if (! ISSLASH (namebuf[name_length - 1]))
1039 namebuf[name_length++] = '/';
1040 namebuf[name_length] = '\0';
1043 for (string = buffer; *string; string += string_length + 1)
1045 string_length = strlen (string);
1049 struct tar_stat_info subdir;
1052 if (allocated_length <= name_length + string_length)
1056 allocated_length *= 2;
1057 if (! allocated_length)
1060 while (allocated_length <= name_length + string_length);
1062 namebuf = xrealloc (namebuf, allocated_length + 1);
1064 strcpy (namebuf + name_length, string + 1);
1065 np = addname (namebuf, change_dir, false, name);
1069 child_tail->sibling = np;
1072 tar_stat_init (&subdir);
1080 subfd = subfile_open (st, string + 1,
1081 open_read_flags | O_DIRECTORY);
1083 open_diag (namebuf);
1087 if (fstat (subfd, &subdir.stat) != 0)
1088 stat_diag (namebuf);
1089 else if (! (O_DIRECTORY || S_ISDIR (subdir.stat.st_mode)))
1092 open_diag (namebuf);
1096 subdir.orig_file_name = xstrdup (namebuf);
1097 add_hierarchy_to_namelist (&subdir, np);
1098 restore_parent_fd (&subdir);
1102 tar_stat_destroy (&subdir);
1107 name->child = child_head;
1111 /* Auxiliary functions for hashed table of struct name's. */
1114 name_hash (void const *entry, size_t n_buckets)
1116 struct name const *name = entry;
1117 return hash_string (name->caname, n_buckets);
1120 /* Compare two directories for equality of their names. */
1122 name_compare (void const *entry1, void const *entry2)
1124 struct name const *name1 = entry1;
1125 struct name const *name2 = entry2;
1126 return strcmp (name1->caname, name2->caname) == 0;
1130 /* Rebase 'name' member of CHILD and all its siblings to
1133 rebase_child_list (struct name *child, struct name *parent)
1135 size_t old_prefix_len = child->parent->length;
1136 size_t new_prefix_len = parent->length;
1137 char *new_prefix = parent->name;
1139 for (; child; child = child->sibling)
1141 size_t size = child->length - old_prefix_len + new_prefix_len;
1142 char *newp = xmalloc (size + 1);
1143 strcpy (newp, new_prefix);
1144 strcat (newp, child->name + old_prefix_len);
1147 child->length = size;
1149 rebase_directory (child->directory,
1150 child->parent->name, old_prefix_len,
1151 new_prefix, new_prefix_len);
1155 /* Collect all the names from argv[] (or whatever), expand them into a
1156 directory tree, and sort them. This gets only subdirectories, not
1160 collect_and_sort_names (void)
1163 struct name *next_name, *prev_name = NULL;
1165 Hash_table *nametab;
1170 addname (".", 0, false, NULL);
1172 if (listed_incremental_option)
1174 switch (chdir_count ())
1180 if (namelist->change_dir == 0)
1182 _("Using -C option inside file list is not "
1183 "allowed with --listed-incremental")));
1188 _("Only one -C option is allowed with "
1189 "--listed-incremental")));
1192 read_directory_file ();
1196 for (name = namelist; name; name = name->next, num_names++)
1198 struct tar_stat_info st;
1200 if (name->found_count || name->directory)
1202 if (name->matching_flags & EXCLUDE_WILDCARDS)
1203 /* NOTE: EXCLUDE_ANCHORED is not relevant here */
1204 /* FIXME: just skip regexps for now */
1206 chdir_do (name->change_dir);
1208 if (name->name[0] == 0)
1211 tar_stat_init (&st);
1213 if (deref_stat (name->name, &st.stat) != 0)
1215 stat_diag (name->name);
1218 if (S_ISDIR (st.stat.st_mode))
1220 int dir_fd = openat (chdir_fd, name->name,
1221 open_read_flags | O_DIRECTORY);
1223 open_diag (name->name);
1227 if (fstat (dir_fd, &st.stat) != 0)
1228 stat_diag (name->name);
1229 else if (O_DIRECTORY || S_ISDIR (st.stat.st_mode))
1231 st.orig_file_name = xstrdup (name->name);
1232 name->found_count++;
1233 add_hierarchy_to_namelist (&st, name);
1238 tar_stat_destroy (&st);
1241 namelist = merge_sort (namelist, num_names, compare_names);
1244 nametab = hash_initialize (0, 0, name_hash, name_compare, NULL);
1245 for (name = namelist; name; name = next_name)
1247 next_name = name->next;
1248 name->caname = normalize_filename (name->change_dir, name->name);
1251 struct name *p = hash_lookup (nametab, name);
1254 /* Keep the one listed in the command line */
1258 rebase_child_list (p->child, name);
1259 hash_delete (nametab, name);
1260 /* FIXME: remove_directory (p->caname); ? */
1268 rebase_child_list (name->child, p);
1269 /* FIXME: remove_directory (name->caname); ? */
1276 name->found_count = 0;
1277 if (!hash_insert (nametab, name))
1282 nametail = prev_name;
1283 hash_free (nametab);
1285 namelist = merge_sort (namelist, num_names, compare_names_found);
1287 if (listed_incremental_option)
1289 for (name = namelist; name && name->name[0] == 0; name++)
1292 append_incremental_renames (name->directory);
1296 /* This is like name_match, except that
1297 1. It returns a pointer to the name it matched, and doesn't set FOUND
1298 in structure. The caller will have to do that if it wants to.
1299 2. If the namelist is empty, it returns null, unlike name_match, which
1302 name_scan (const char *file_name)
1304 size_t length = strlen (file_name);
1308 struct name *cursor = namelist_match (file_name, length);
1312 /* Filename from archive not found in namelist. If we have the whole
1313 namelist here, just return 0. Otherwise, read the next name in and
1314 compare it. If this was the last name, namelist->found_count will
1315 remain on. If not, we loop to compare the newly read name. */
1317 if (same_order_option && namelist && namelist->found_count)
1319 name_gather (); /* read one more */
1320 if (namelist->found_count)
1328 /* This returns a name from the namelist which doesn't have ->found
1329 set. It sets ->found before returning, so successive calls will
1330 find and return all the non-found names in the namelist. */
1331 struct name *gnu_list_name;
1334 name_from_list (void)
1337 gnu_list_name = namelist;
1338 while (gnu_list_name
1339 && (gnu_list_name->found_count || gnu_list_name->name[0] == 0))
1340 gnu_list_name = gnu_list_name->next;
1343 gnu_list_name->found_count++;
1344 chdir_do (gnu_list_name->change_dir);
1345 return gnu_list_name;
1351 blank_name_list (void)
1356 for (name = namelist; name; name = name->next)
1357 name->found_count = 0;
1360 /* Yield a newly allocated file name consisting of FILE_NAME concatenated to
1361 NAME, with an intervening slash if FILE_NAME does not already end in one. */
1363 new_name (const char *file_name, const char *name)
1365 size_t file_name_len = strlen (file_name);
1366 size_t namesize = strlen (name) + 1;
1367 int slash = file_name_len && ! ISSLASH (file_name[file_name_len - 1]);
1368 char *buffer = xmalloc (file_name_len + slash + namesize);
1369 memcpy (buffer, file_name, file_name_len);
1370 buffer[file_name_len] = '/';
1371 memcpy (buffer + file_name_len + slash, name, namesize);
1375 /* Return nonzero if file NAME is excluded. */
1377 excluded_name (char const *name)
1379 return excluded_file_name (excluded, name + FILE_SYSTEM_PREFIX_LEN (name));
1383 /* Return the size of the prefix of FILE_NAME that is removed after
1384 stripping NUM leading file name components. NUM must be
1388 stripped_prefix_len (char const *file_name, size_t num)
1390 char const *p = file_name + FILE_SYSTEM_PREFIX_LEN (file_name);
1391 while (ISSLASH (*p))
1395 bool slash = ISSLASH (*p);
1400 return p - file_name;
1401 while (ISSLASH (*p))
1408 /* Return nonzero if NAME contains ".." as a file name component. */
1410 contains_dot_dot (char const *name)
1412 char const *p = name + FILE_SYSTEM_PREFIX_LEN (name);
1416 if (p[0] == '.' && p[1] == '.' && (ISSLASH (p[2]) || !p[2]))
1419 while (! ISSLASH (*p))