1 /* Various processing of names.
3 Copyright (C) 1988, 1992, 1994, 1996, 1997, 1998, 1999, 2000, 2001,
4 2003, 2004, 2005, 2006, 2007, 2009 Free 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, write to the Free Software Foundation, Inc.,
18 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
28 /* User and group names. */
30 struct group
*getgrnam ();
31 struct passwd
*getpwnam ();
32 #if ! HAVE_DECL_GETPWUID
33 struct passwd
*getpwuid ();
35 #if ! HAVE_DECL_GETGRGID
36 struct group
*getgrgid ();
39 /* Make sure you link with the proper libraries if you are running the
40 Yellow Peril (thanks for the good laugh, Ian J.!), or, euh... NIS.
41 This code should also be modified for non-UNIX systems to do something
44 static char *cached_uname
;
45 static char *cached_gname
;
47 static uid_t cached_uid
; /* valid only if cached_uname is not empty */
48 static gid_t cached_gid
; /* valid only if cached_gname is not empty */
50 /* These variables are valid only if nonempty. */
51 static char *cached_no_such_uname
;
52 static char *cached_no_such_gname
;
54 /* These variables are valid only if nonzero. It's not worth optimizing
55 the case for weird systems where 0 is not a valid uid or gid. */
56 static uid_t cached_no_such_uid
;
57 static gid_t cached_no_such_gid
;
59 static void register_individual_file (char const *name
);
61 /* Given UID, find the corresponding UNAME. */
63 uid_to_uname (uid_t uid
, char **uname
)
65 struct passwd
*passwd
;
67 if (uid
!= 0 && uid
== cached_no_such_uid
)
69 *uname
= xstrdup ("");
73 if (!cached_uname
|| uid
!= cached_uid
)
75 passwd
= getpwuid (uid
);
79 assign_string (&cached_uname
, passwd
->pw_name
);
83 cached_no_such_uid
= uid
;
84 *uname
= xstrdup ("");
88 *uname
= xstrdup (cached_uname
);
91 /* Given GID, find the corresponding GNAME. */
93 gid_to_gname (gid_t gid
, char **gname
)
97 if (gid
!= 0 && gid
== cached_no_such_gid
)
99 *gname
= xstrdup ("");
103 if (!cached_gname
|| gid
!= cached_gid
)
105 group
= getgrgid (gid
);
109 assign_string (&cached_gname
, group
->gr_name
);
113 cached_no_such_gid
= gid
;
114 *gname
= xstrdup ("");
118 *gname
= xstrdup (cached_gname
);
121 /* Given UNAME, set the corresponding UID and return 1, or else, return 0. */
123 uname_to_uid (char const *uname
, uid_t
*uidp
)
125 struct passwd
*passwd
;
127 if (cached_no_such_uname
128 && strcmp (uname
, cached_no_such_uname
) == 0)
132 || uname
[0] != cached_uname
[0]
133 || strcmp (uname
, cached_uname
) != 0)
135 passwd
= getpwnam (uname
);
138 cached_uid
= passwd
->pw_uid
;
139 assign_string (&cached_uname
, passwd
->pw_name
);
143 assign_string (&cached_no_such_uname
, uname
);
151 /* Given GNAME, set the corresponding GID and return 1, or else, return 0. */
153 gname_to_gid (char const *gname
, gid_t
*gidp
)
157 if (cached_no_such_gname
158 && strcmp (gname
, cached_no_such_gname
) == 0)
162 || gname
[0] != cached_gname
[0]
163 || strcmp (gname
, cached_gname
) != 0)
165 group
= getgrnam (gname
);
168 cached_gid
= group
->gr_gid
;
169 assign_string (&cached_gname
, gname
);
173 assign_string (&cached_no_such_gname
, gname
);
183 make_name (const char *file_name
)
185 struct name
*p
= xzalloc (sizeof (*p
));
188 p
->name
= xstrdup (file_name
);
189 p
->length
= strlen (p
->name
);
194 free_name (struct name
*p
)
205 /* Names from the command call. */
207 static struct name
*namelist
; /* first name in list, if any */
208 static struct name
**nametail
= &namelist
; /* end of name list */
210 /* File name arguments are processed in two stages: first a
211 name_array (see below) is filled, then the names from it
212 are moved into the namelist.
214 This awkward process is needed only to implement --same-order option,
215 which is meant to help process large archives on machines with
216 limited memory. With this option on, namelist contains at most one
217 entry, which diminishes the memory consumption.
219 However, I very much doubt if we still need this -- Sergey */
221 /* A name_array element contains entries of three types: */
223 #define NELT_NAME 0 /* File name */
224 #define NELT_CHDIR 1 /* Change directory request */
225 #define NELT_FMASK 2 /* Change fnmatch options request */
227 struct name_elt
/* A name_array element. */
229 char type
; /* Element type, see NELT_* constants above */
232 const char *name
; /* File or directory name */
233 int matching_flags
;/* fnmatch options if type == NELT_FMASK */
237 static struct name_elt
*name_array
; /* store an array of names */
238 static size_t allocated_names
; /* how big is the array? */
239 static size_t names
; /* how many entries does it have? */
240 static size_t name_index
; /* how many of the entries have we scanned? */
242 /* Check the size of name_array, reallocating it as necessary. */
246 if (names
== allocated_names
)
248 if (allocated_names
== 0)
249 allocated_names
= 10; /* Set initial allocation */
250 name_array
= x2nrealloc (name_array
, &allocated_names
,
251 sizeof (name_array
[0]));
255 /* Add to name_array the file NAME with fnmatch options MATCHING_FLAGS */
257 name_add_name (const char *name
, int matching_flags
)
259 static int prev_flags
= 0; /* FIXME: Or EXCLUDE_ANCHORED? */
263 ep
= &name_array
[names
++];
264 if (prev_flags
!= matching_flags
)
266 ep
->type
= NELT_FMASK
;
267 ep
->v
.matching_flags
= matching_flags
;
268 prev_flags
= matching_flags
;
270 ep
= &name_array
[names
++];
272 ep
->type
= NELT_NAME
;
276 /* Add to name_array a chdir request for the directory NAME */
278 name_add_dir (const char *name
)
282 ep
= &name_array
[names
++];
283 ep
->type
= NELT_CHDIR
;
288 /* Names from external name file. */
290 static char *name_buffer
; /* buffer to hold the current file name */
291 static size_t name_buffer_length
; /* allocated length of name_buffer */
293 /* Set up to gather file names for tar. They can either come from a
294 file or were saved from decoding arguments. */
298 name_buffer
= xmalloc (NAME_FIELD_SIZE
+ 2);
299 name_buffer_length
= NAME_FIELD_SIZE
;
309 static int matching_flags
; /* exclude_fnmatch options */
311 /* Get the next NELT_NAME element from name_array. Result is in
312 static storage and can't be relied upon across two calls.
314 If CHANGE_DIRS is true, treat any entries of type NELT_CHDIR as
315 the request to change to the given directory.
317 Entries of type NELT_FMASK cause updates of the matching_flags
320 name_next_elt (int change_dirs
)
322 static struct name_elt entry
;
326 while (name_index
!= names
)
331 ep
= &name_array
[name_index
++];
332 if (ep
->type
== NELT_FMASK
)
334 matching_flags
= ep
->v
.matching_flags
;
339 source_len
= strlen (source
);
340 if (name_buffer_length
< source_len
)
344 name_buffer_length
*= 2;
345 if (! name_buffer_length
)
348 while (name_buffer_length
< source_len
);
351 name_buffer
= xmalloc (name_buffer_length
+ 2);
353 strcpy (name_buffer
, source
);
355 /* Zap trailing slashes. */
357 cursor
= name_buffer
+ strlen (name_buffer
) - 1;
358 while (cursor
> name_buffer
&& ISSLASH (*cursor
))
361 if (change_dirs
&& ep
->type
== NELT_CHDIR
)
363 if (chdir (name_buffer
) < 0)
364 chdir_fatal (name_buffer
);
369 unquote_string (name_buffer
);
370 if (incremental_option
)
371 register_individual_file (name_buffer
);
372 entry
.type
= ep
->type
;
373 entry
.v
.name
= name_buffer
;
382 name_next (int change_dirs
)
384 struct name_elt
*nelt
= name_next_elt (change_dirs
);
385 return nelt
? nelt
->v
.name
: NULL
;
388 /* Gather names in a list for scanning. Could hash them later if we
391 If the names are already sorted to match the archive, we just read
392 them one by one. name_gather reads the first one, and it is called
393 by name_match as appropriate to read the next ones. At EOF, the
394 last name read is just left in the buffer. This option lets users
395 of small machines extract an arbitrary number of files by doing
396 "tar t" and editing down the list of files. */
401 /* Buffer able to hold a single name. */
402 static struct name
*buffer
= NULL
;
406 if (same_order_option
)
408 static int change_dir
;
410 while ((ep
= name_next_elt (0)) && ep
->type
== NELT_CHDIR
)
411 change_dir
= chdir_arg (xstrdup (ep
->v
.name
));
416 buffer
= make_name (ep
->v
.name
);
417 buffer
->change_dir
= change_dir
;
419 buffer
->found_count
= 0;
420 buffer
->matching_flags
= matching_flags
;
421 buffer
->dir_contents
= NULL
;
422 buffer
->parent
= NULL
;
425 nametail
= &namelist
->next
;
428 addname (0, change_dir
, NULL
);
432 /* Non sorted names -- read them all in. */
437 int change_dir0
= change_dir
;
438 while ((ep
= name_next_elt (0)) && ep
->type
== NELT_CHDIR
)
439 change_dir
= chdir_arg (xstrdup (ep
->v
.name
));
442 addname (ep
->v
.name
, change_dir
, NULL
);
445 if (change_dir
!= change_dir0
)
446 addname (0, change_dir
, NULL
);
453 /* Add a name to the namelist. */
455 addname (char const *string
, int change_dir
, struct name
*parent
)
457 struct name
*name
= make_name (string
);
459 name
->prev
= *nametail
;
461 name
->found_count
= 0;
462 name
->matching_flags
= matching_flags
;
463 name
->change_dir
= change_dir
;
464 name
->dir_contents
= NULL
;
465 name
->parent
= parent
;
468 nametail
= &name
->next
;
472 /* Find a match for FILE_NAME (whose string length is LENGTH) in the name
475 namelist_match (char const *file_name
, size_t length
)
479 for (p
= namelist
; p
; p
= p
->next
)
482 && exclude_fnmatch (p
->name
, file_name
, p
->matching_flags
))
490 remname (struct name
*name
)
494 if ((p
= name
->prev
) != NULL
)
495 p
->next
= name
->next
;
497 namelist
= name
->next
;
499 if ((p
= name
->next
) != NULL
)
500 p
->prev
= name
->prev
;
502 nametail
= &name
->prev
;
505 /* Return true if and only if name FILE_NAME (from an archive) matches any
506 name from the namelist. */
508 name_match (const char *file_name
)
510 size_t length
= strlen (file_name
);
514 struct name
*cursor
= namelist
;
519 if (cursor
->name
[0] == 0)
521 chdir_do (cursor
->change_dir
);
523 nametail
= &namelist
;
527 cursor
= namelist_match (file_name
, length
);
530 if (!(ISSLASH (file_name
[cursor
->length
]) && recursion_option
)
531 || cursor
->found_count
== 0)
532 cursor
->found_count
++; /* remember it matched */
533 if (starting_file_option
)
537 nametail
= &namelist
;
539 chdir_do (cursor
->change_dir
);
541 /* We got a match. */
542 return ISFOUND (cursor
);
545 /* Filename from archive not found in namelist. If we have the whole
546 namelist here, just return 0. Otherwise, read the next name in and
547 compare it. If this was the last name, namelist->found_count will
548 remain on. If not, we loop to compare the newly read name. */
550 if (same_order_option
&& namelist
->found_count
)
552 name_gather (); /* read one more */
553 if (namelist
->found_count
)
561 /* Returns true if all names from the namelist were processed.
562 P is the stat_info of the most recently processed entry.
563 The decision is postponed until the next entry is read if:
565 1) P ended with a slash (i.e. it was a directory)
566 2) P matches any entry from the namelist *and* represents a subdirectory
567 or a file lying under this entry (in the terms of directory structure).
569 This is necessary to handle contents of directories. */
571 all_names_found (struct tar_stat_info
*p
)
573 struct name
const *cursor
;
576 if (test_label_option
)
578 if (!p
->file_name
|| occurrence_option
== 0 || p
->had_trailing_slash
)
580 len
= strlen (p
->file_name
);
581 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
583 if ((cursor
->name
[0] && !WASFOUND (cursor
))
584 || (len
>= cursor
->length
&& ISSLASH (p
->file_name
[cursor
->length
])))
591 is_pattern (const char *string
)
593 return strchr (string
, '*') || strchr (string
, '[') || strchr (string
, '?');
597 regex_usage_warning (const char *name
)
599 static int warned_once
= 0;
601 if (warn_regex_usage
&& is_pattern (name
))
605 /* TRANSLATORS: The following three msgids form a single sentence.
607 _("Pattern matching characters used in file names. Please,")));
609 _("use --wildcards to enable pattern matching, or --no-wildcards to")));
611 _("suppress this warning.")));
615 /* Print the names of things in the namelist that were not matched. */
617 names_notfound (void)
619 struct name
const *cursor
;
621 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
622 if (!WASFOUND (cursor
) && cursor
->name
[0])
624 regex_usage_warning (cursor
->name
);
625 if (cursor
->found_count
== 0)
626 ERROR ((0, 0, _("%s: Not found in archive"),
627 quotearg_colon (cursor
->name
)));
629 ERROR ((0, 0, _("%s: Required occurrence not found in archive"),
630 quotearg_colon (cursor
->name
)));
633 /* Don't bother freeing the name list; we're about to exit. */
635 nametail
= &namelist
;
637 if (same_order_option
)
641 while ((name
= name_next (1)) != NULL
)
643 regex_usage_warning (name
);
644 ERROR ((0, 0, _("%s: Not found in archive"),
645 quotearg_colon (name
)));
650 /* Sorting name lists. */
652 /* Sort *singly* linked LIST of names, of given LENGTH, using COMPARE
653 to order names. Return the sorted list. Note that after calling
654 this function, the `prev' links in list elements are messed up.
656 Apart from the type `struct name' and the definition of SUCCESSOR,
657 this is a generic list-sorting function, but it's too painful to
658 make it both generic and portable
662 merge_sort_sll (struct name
*list
, int length
,
663 int (*compare
) (struct name
const*, struct name
const*))
665 struct name
*first_list
;
666 struct name
*second_list
;
670 struct name
**merge_point
;
674 # define SUCCESSOR(name) ((name)->next)
681 if ((*compare
) (list
, SUCCESSOR (list
)) > 0)
683 result
= SUCCESSOR (list
);
684 SUCCESSOR (result
) = list
;
685 SUCCESSOR (list
) = 0;
692 first_length
= (length
+ 1) / 2;
693 second_length
= length
/ 2;
694 for (cursor
= list
, counter
= first_length
- 1;
696 cursor
= SUCCESSOR (cursor
), counter
--)
698 second_list
= SUCCESSOR (cursor
);
699 SUCCESSOR (cursor
) = 0;
701 first_list
= merge_sort_sll (first_list
, first_length
, compare
);
702 second_list
= merge_sort_sll (second_list
, second_length
, compare
);
704 merge_point
= &result
;
705 while (first_list
&& second_list
)
706 if ((*compare
) (first_list
, second_list
) < 0)
708 cursor
= SUCCESSOR (first_list
);
709 *merge_point
= first_list
;
710 merge_point
= &SUCCESSOR (first_list
);
715 cursor
= SUCCESSOR (second_list
);
716 *merge_point
= second_list
;
717 merge_point
= &SUCCESSOR (second_list
);
718 second_list
= cursor
;
721 *merge_point
= first_list
;
723 *merge_point
= second_list
;
730 /* Sort doubly linked LIST of names, of given LENGTH, using COMPARE
731 to order names. Return the sorted list. */
733 merge_sort (struct name
*list
, int length
,
734 int (*compare
) (struct name
const*, struct name
const*))
736 struct name
*head
, *p
, *prev
;
737 head
= merge_sort_sll (list
, length
, compare
);
738 /* Fixup prev pointers */
739 for (prev
= NULL
, p
= head
; p
; prev
= p
, p
= p
->next
)
744 /* A comparison function for sorting names. Put found names last;
745 break ties by string comparison. */
748 compare_names_found (struct name
const *n1
, struct name
const *n2
)
750 int found_diff
= WASFOUND (n2
) - WASFOUND (n1
);
751 return found_diff
? found_diff
: strcmp (n1
->name
, n2
->name
);
754 /* Simple comparison by names. */
756 compare_names (struct name
const *n1
, struct name
const *n2
)
758 return strcmp (n1
->name
, n2
->name
);
762 /* Add all the dirs under NAME, which names a directory, to the namelist.
763 If any of the files is a directory, recurse on the subdirectory.
764 DEVICE is the device not to leave, if the -l option is specified.
765 CMDLINE is true, if the NAME appeared on the command line. */
768 add_hierarchy_to_namelist (struct name
*name
, dev_t device
, bool cmdline
)
770 char *file_name
= name
->name
;
771 const char *buffer
= scan_directory (file_name
, device
, cmdline
);
774 name
->dir_contents
= "\0\0\0\0";
777 struct name
*child_head
= NULL
, *child_tail
= NULL
;
778 size_t name_length
= name
->length
;
779 size_t allocated_length
= (name_length
>= NAME_FIELD_SIZE
780 ? name_length
+ NAME_FIELD_SIZE
782 char *namebuf
= xmalloc (allocated_length
+ 1);
783 /* FIXME: + 2 above? */
785 size_t string_length
;
786 int change_dir
= name
->change_dir
;
788 name
->dir_contents
= buffer
;
789 strcpy (namebuf
, file_name
);
790 if (! ISSLASH (namebuf
[name_length
- 1]))
792 namebuf
[name_length
++] = '/';
793 namebuf
[name_length
] = '\0';
796 for (string
= buffer
; *string
; string
+= string_length
+ 1)
798 string_length
= strlen (string
);
803 if (allocated_length
<= name_length
+ string_length
)
807 allocated_length
*= 2;
808 if (! allocated_length
)
811 while (allocated_length
<= name_length
+ string_length
);
813 namebuf
= xrealloc (namebuf
, allocated_length
+ 1);
815 strcpy (namebuf
+ name_length
, string
+ 1);
816 np
= addname (namebuf
, change_dir
, name
);
820 child_tail
->sibling
= np
;
822 add_hierarchy_to_namelist (np
, device
, false);
827 name
->child
= child_head
;
831 /* Auxiliary functions for hashed table of struct name's. */
834 name_hash (void const *entry
, size_t n_buckets
)
836 struct name
const *name
= entry
;
837 return hash_string (name
->caname
, n_buckets
);
840 /* Compare two directories for equality of their names. */
842 name_compare (void const *entry1
, void const *entry2
)
844 struct name
const *name1
= entry1
;
845 struct name
const *name2
= entry2
;
846 return strcmp (name1
->caname
, name2
->caname
) == 0;
850 /* Rebase `name' member of CHILD and all its siblings to
853 rebase_child_list (struct name
*child
, struct name
*parent
)
855 size_t old_prefix_len
= child
->parent
->length
;
856 size_t new_prefix_len
= parent
->length
;
857 char *new_prefix
= parent
->name
;
859 for (; child
; child
= child
->sibling
)
861 size_t size
= child
->length
- old_prefix_len
+ new_prefix_len
;
862 char *newp
= xmalloc (size
+ 1);
863 strcpy (newp
, new_prefix
);
864 strcat (newp
, child
->name
+ old_prefix_len
);
867 child
->length
= size
;
869 rebase_directory (child
->name
, old_prefix_len
, child
->parent
->name
,
874 /* Collect all the names from argv[] (or whatever), expand them into a
875 directory tree, and sort them. This gets only subdirectories, not
879 collect_and_sort_names (void)
882 struct name
*next_name
, *prev_name
;
890 addname (".", 0, NULL
);
892 if (listed_incremental_option
)
894 switch (chdir_count ())
900 if (namelist
->change_dir
== 0)
902 _("Using -C option inside file list is not "
903 "allowed with --listed-incremental")));
908 _("Only one -C option is allowed with "
909 "--listed-incremental")));
911 chdir_do (namelist
->change_dir
);
912 read_directory_file ();
916 for (name
= namelist
; name
; name
= name
->next
, num_names
++)
918 if (name
->found_count
|| name
->dir_contents
)
920 if (name
->matching_flags
& EXCLUDE_WILDCARDS
)
921 /* NOTE: EXCLUDE_ANCHORED is not relevant here */
922 /* FIXME: just skip regexps for now */
924 chdir_do (name
->change_dir
);
926 if (name
->name
[0] == 0)
929 if (deref_stat (dereference_option
, name
->name
, &statbuf
) != 0)
931 stat_diag (name
->name
);
934 if (S_ISDIR (statbuf
.st_mode
))
937 add_hierarchy_to_namelist (name
, statbuf
.st_dev
, true);
941 namelist
= merge_sort (namelist
, num_names
, compare_names
);
944 nametab
= hash_initialize (0, 0,
947 for (name
= namelist
; name
; name
= next_name
)
949 next_name
= name
->next
;
950 name
->caname
= normalize_filename (name
->name
);
953 struct name
*p
= hash_lookup (nametab
, name
);
956 /* Keep the one listed in the command line */
960 rebase_child_list (p
->child
, name
);
961 /* FIXME: remove_directory (p->caname); ? */
969 rebase_child_list (name
->child
, p
);
970 /* FIXME: remove_directory (name->caname); ? */
977 name
->found_count
= 0;
978 if (!hash_insert (nametab
, name
))
983 nametail
= &prev_name
;
986 namelist
= merge_sort (namelist
, num_names
, compare_names_found
);
988 if (listed_incremental_option
)
990 for (name
= namelist
; name
&& name
->name
[0] == 0; name
++)
993 name
->dir_contents
= append_incremental_renames (name
->dir_contents
);
997 /* This is like name_match, except that
998 1. It returns a pointer to the name it matched, and doesn't set FOUND
999 in structure. The caller will have to do that if it wants to.
1000 2. If the namelist is empty, it returns null, unlike name_match, which
1003 name_scan (const char *file_name
)
1005 size_t length
= strlen (file_name
);
1009 struct name
*cursor
= namelist_match (file_name
, length
);
1013 /* Filename from archive not found in namelist. If we have the whole
1014 namelist here, just return 0. Otherwise, read the next name in and
1015 compare it. If this was the last name, namelist->found_count will
1016 remain on. If not, we loop to compare the newly read name. */
1018 if (same_order_option
&& namelist
&& namelist
->found_count
)
1020 name_gather (); /* read one more */
1021 if (namelist
->found_count
)
1029 /* This returns a name from the namelist which doesn't have ->found
1030 set. It sets ->found before returning, so successive calls will
1031 find and return all the non-found names in the namelist. */
1032 struct name
*gnu_list_name
;
1035 name_from_list (void)
1038 gnu_list_name
= namelist
;
1039 while (gnu_list_name
1040 && (gnu_list_name
->found_count
|| gnu_list_name
->name
[0] == 0))
1041 gnu_list_name
= gnu_list_name
->next
;
1044 gnu_list_name
->found_count
++;
1045 chdir_do (gnu_list_name
->change_dir
);
1046 return gnu_list_name
->name
;
1052 blank_name_list (void)
1057 for (name
= namelist
; name
; name
= name
->next
)
1058 name
->found_count
= 0;
1061 /* Yield a newly allocated file name consisting of FILE_NAME concatenated to
1062 NAME, with an intervening slash if FILE_NAME does not already end in one. */
1064 new_name (const char *file_name
, const char *name
)
1066 size_t file_name_len
= strlen (file_name
);
1067 size_t namesize
= strlen (name
) + 1;
1068 int slash
= file_name_len
&& ! ISSLASH (file_name
[file_name_len
- 1]);
1069 char *buffer
= xmalloc (file_name_len
+ slash
+ namesize
);
1070 memcpy (buffer
, file_name
, file_name_len
);
1071 buffer
[file_name_len
] = '/';
1072 memcpy (buffer
+ file_name_len
+ slash
, name
, namesize
);
1076 /* Return nonzero if file NAME is excluded. */
1078 excluded_name (char const *name
)
1080 return excluded_file_name (excluded
, name
+ FILE_SYSTEM_PREFIX_LEN (name
));
1083 /* Names to avoid dumping. */
1084 static Hash_table
*avoided_name_table
;
1086 /* Remember to not archive NAME. */
1088 add_avoided_name (char const *name
)
1090 hash_string_insert (&avoided_name_table
, name
);
1093 /* Should NAME be avoided when archiving? */
1095 is_avoided_name (char const *name
)
1097 return hash_string_lookup (avoided_name_table
, name
);
1101 static Hash_table
*individual_file_table
;
1104 register_individual_file (char const *name
)
1108 if (deref_stat (dereference_option
, name
, &st
) != 0)
1109 return; /* Will be complained about later */
1110 if (S_ISDIR (st
.st_mode
))
1113 hash_string_insert (&individual_file_table
, name
);
1117 is_individual_file (char const *name
)
1119 return hash_string_lookup (individual_file_table
, name
);
1124 /* Return the size of the prefix of FILE_NAME that is removed after
1125 stripping NUM leading file name components. NUM must be
1129 stripped_prefix_len (char const *file_name
, size_t num
)
1131 char const *p
= file_name
+ FILE_SYSTEM_PREFIX_LEN (file_name
);
1132 while (ISSLASH (*p
))
1136 bool slash
= ISSLASH (*p
);
1141 return p
- file_name
;
1142 while (ISSLASH (*p
))
1149 /* Return nonzero if NAME contains ".." as a file name component. */
1151 contains_dot_dot (char const *name
)
1153 char const *p
= name
+ FILE_SYSTEM_PREFIX_LEN (name
);
1157 if (p
[0] == '.' && p
[1] == '.' && (ISSLASH (p
[2]) || !p
[2]))
1160 while (! ISSLASH (*p
))