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 /* Make sure you link with the proper libraries if you are running the
31 Yellow Peril (thanks for the good laugh, Ian J.!), or, euh... NIS.
32 This code should also be modified for non-UNIX systems to do something
35 static char *cached_uname
;
36 static char *cached_gname
;
38 static uid_t cached_uid
; /* valid only if cached_uname is not empty */
39 static gid_t cached_gid
; /* valid only if cached_gname is not empty */
41 /* These variables are valid only if nonempty. */
42 static char *cached_no_such_uname
;
43 static char *cached_no_such_gname
;
45 /* These variables are valid only if nonzero. It's not worth optimizing
46 the case for weird systems where 0 is not a valid uid or gid. */
47 static uid_t cached_no_such_uid
;
48 static gid_t cached_no_such_gid
;
50 static void register_individual_file (char const *name
);
52 /* Given UID, find the corresponding UNAME. */
54 uid_to_uname (uid_t uid
, char **uname
)
56 struct passwd
*passwd
;
58 if (uid
!= 0 && uid
== cached_no_such_uid
)
60 *uname
= xstrdup ("");
64 if (!cached_uname
|| uid
!= cached_uid
)
66 passwd
= getpwuid (uid
);
70 assign_string (&cached_uname
, passwd
->pw_name
);
74 cached_no_such_uid
= uid
;
75 *uname
= xstrdup ("");
79 *uname
= xstrdup (cached_uname
);
82 /* Given GID, find the corresponding GNAME. */
84 gid_to_gname (gid_t gid
, char **gname
)
88 if (gid
!= 0 && gid
== cached_no_such_gid
)
90 *gname
= xstrdup ("");
94 if (!cached_gname
|| gid
!= cached_gid
)
96 group
= getgrgid (gid
);
100 assign_string (&cached_gname
, group
->gr_name
);
104 cached_no_such_gid
= gid
;
105 *gname
= xstrdup ("");
109 *gname
= xstrdup (cached_gname
);
112 /* Given UNAME, set the corresponding UID and return 1, or else, return 0. */
114 uname_to_uid (char const *uname
, uid_t
*uidp
)
116 struct passwd
*passwd
;
118 if (cached_no_such_uname
119 && strcmp (uname
, cached_no_such_uname
) == 0)
123 || uname
[0] != cached_uname
[0]
124 || strcmp (uname
, cached_uname
) != 0)
126 passwd
= getpwnam (uname
);
129 cached_uid
= passwd
->pw_uid
;
130 assign_string (&cached_uname
, passwd
->pw_name
);
134 assign_string (&cached_no_such_uname
, uname
);
142 /* Given GNAME, set the corresponding GID and return 1, or else, return 0. */
144 gname_to_gid (char const *gname
, gid_t
*gidp
)
148 if (cached_no_such_gname
149 && strcmp (gname
, cached_no_such_gname
) == 0)
153 || gname
[0] != cached_gname
[0]
154 || strcmp (gname
, cached_gname
) != 0)
156 group
= getgrnam (gname
);
159 cached_gid
= group
->gr_gid
;
160 assign_string (&cached_gname
, gname
);
164 assign_string (&cached_no_such_gname
, gname
);
174 make_name (const char *file_name
)
176 struct name
*p
= xzalloc (sizeof (*p
));
179 p
->name
= xstrdup (file_name
);
180 p
->length
= strlen (p
->name
);
185 free_name (struct name
*p
)
196 /* Names from the command call. */
198 static struct name
*namelist
; /* first name in list, if any */
199 static struct name
*nametail
; /* end of name list */
201 /* File name arguments are processed in two stages: first a
202 name_array (see below) is filled, then the names from it
203 are moved into the namelist.
205 This awkward process is needed only to implement --same-order option,
206 which is meant to help process large archives on machines with
207 limited memory. With this option on, namelist contains at most one
208 entry, which diminishes the memory consumption.
210 However, I very much doubt if we still need this -- Sergey */
212 /* A name_array element contains entries of three types: */
214 #define NELT_NAME 0 /* File name */
215 #define NELT_CHDIR 1 /* Change directory request */
216 #define NELT_FMASK 2 /* Change fnmatch options request */
218 struct name_elt
/* A name_array element. */
220 char type
; /* Element type, see NELT_* constants above */
223 const char *name
; /* File or directory name */
224 int matching_flags
;/* fnmatch options if type == NELT_FMASK */
228 static struct name_elt
*name_array
; /* store an array of names */
229 static size_t allocated_entries
; /* how big is the array? */
230 static size_t entries
; /* how many entries does it have? */
231 static size_t scanned
; /* how many of the entries have we scanned? */
232 size_t name_count
; /* how many of the entries are names? */
234 /* Check the size of name_array, reallocating it as necessary. */
236 check_name_alloc (void)
238 if (entries
== allocated_entries
)
240 if (allocated_entries
== 0)
241 allocated_entries
= 10; /* Set initial allocation */
242 name_array
= x2nrealloc (name_array
, &allocated_entries
,
243 sizeof (name_array
[0]));
247 /* Add to name_array the file NAME with fnmatch options MATCHING_FLAGS */
249 name_add_name (const char *name
, int matching_flags
)
251 static int prev_flags
= 0; /* FIXME: Or EXCLUDE_ANCHORED? */
255 ep
= &name_array
[entries
++];
256 if (prev_flags
!= matching_flags
)
258 ep
->type
= NELT_FMASK
;
259 ep
->v
.matching_flags
= matching_flags
;
260 prev_flags
= matching_flags
;
262 ep
= &name_array
[entries
++];
264 ep
->type
= NELT_NAME
;
269 /* Add to name_array a chdir request for the directory NAME */
271 name_add_dir (const char *name
)
275 ep
= &name_array
[entries
++];
276 ep
->type
= NELT_CHDIR
;
281 /* Names from external name file. */
283 static char *name_buffer
; /* buffer to hold the current file name */
284 static size_t name_buffer_length
; /* allocated length of name_buffer */
286 /* Set up to gather file names for tar. They can either come from a
287 file or were saved from decoding arguments. */
291 name_buffer
= xmalloc (NAME_FIELD_SIZE
+ 2);
292 name_buffer_length
= NAME_FIELD_SIZE
;
302 static int matching_flags
; /* exclude_fnmatch options */
304 /* Get the next NELT_NAME element from name_array. Result is in
305 static storage and can't be relied upon across two calls.
307 If CHANGE_DIRS is true, treat any entries of type NELT_CHDIR as
308 the request to change to the given directory.
310 Entries of type NELT_FMASK cause updates of the matching_flags
312 static struct name_elt
*
313 name_next_elt (int change_dirs
)
315 static struct name_elt entry
;
319 while (scanned
!= entries
)
324 ep
= &name_array
[scanned
++];
325 if (ep
->type
== NELT_FMASK
)
327 matching_flags
= ep
->v
.matching_flags
;
332 source_len
= strlen (source
);
333 if (name_buffer_length
< source_len
)
337 name_buffer_length
*= 2;
338 if (! name_buffer_length
)
341 while (name_buffer_length
< source_len
);
344 name_buffer
= xmalloc (name_buffer_length
+ 2);
346 strcpy (name_buffer
, source
);
348 /* Zap trailing slashes. */
350 cursor
= name_buffer
+ strlen (name_buffer
) - 1;
351 while (cursor
> name_buffer
&& ISSLASH (*cursor
))
354 if (change_dirs
&& ep
->type
== NELT_CHDIR
)
356 if (chdir (name_buffer
) < 0)
357 chdir_fatal (name_buffer
);
362 unquote_string (name_buffer
);
363 if (incremental_option
)
364 register_individual_file (name_buffer
);
365 entry
.type
= ep
->type
;
366 entry
.v
.name
= name_buffer
;
375 name_next (int change_dirs
)
377 struct name_elt
*nelt
= name_next_elt (change_dirs
);
378 return nelt
? nelt
->v
.name
: NULL
;
381 /* Gather names in a list for scanning. Could hash them later if we
384 If the names are already sorted to match the archive, we just read
385 them one by one. name_gather reads the first one, and it is called
386 by name_match as appropriate to read the next ones. At EOF, the
387 last name read is just left in the buffer. This option lets users
388 of small machines extract an arbitrary number of files by doing
389 "tar t" and editing down the list of files. */
394 /* Buffer able to hold a single name. */
395 static struct name
*buffer
= NULL
;
399 if (same_order_option
)
401 static int change_dir
;
403 while ((ep
= name_next_elt (0)) && ep
->type
== NELT_CHDIR
)
404 change_dir
= chdir_arg (xstrdup (ep
->v
.name
));
409 buffer
= make_name (ep
->v
.name
);
410 buffer
->change_dir
= change_dir
;
412 buffer
->found_count
= 0;
413 buffer
->matching_flags
= matching_flags
;
414 buffer
->directory
= NULL
;
415 buffer
->parent
= NULL
;
416 buffer
->cmdline
= true;
418 namelist
= nametail
= buffer
;
421 addname (0, change_dir
, false, NULL
);
425 /* Non sorted names -- read them all in. */
430 int change_dir0
= change_dir
;
431 while ((ep
= name_next_elt (0)) && ep
->type
== NELT_CHDIR
)
432 change_dir
= chdir_arg (xstrdup (ep
->v
.name
));
435 addname (ep
->v
.name
, change_dir
, true, NULL
);
438 if (change_dir
!= change_dir0
)
439 addname (NULL
, change_dir
, false, NULL
);
446 /* Add a name to the namelist. */
448 addname (char const *string
, int change_dir
, bool cmdline
, struct name
*parent
)
450 struct name
*name
= make_name (string
);
452 name
->prev
= nametail
;
454 name
->found_count
= 0;
455 name
->matching_flags
= matching_flags
;
456 name
->change_dir
= change_dir
;
457 name
->directory
= NULL
;
458 name
->parent
= parent
;
459 name
->cmdline
= cmdline
;
462 nametail
->next
= name
;
469 /* Find a match for FILE_NAME (whose string length is LENGTH) in the name
472 namelist_match (char const *file_name
, size_t length
)
476 for (p
= namelist
; p
; p
= p
->next
)
479 && exclude_fnmatch (p
->name
, file_name
, p
->matching_flags
))
487 remname (struct name
*name
)
491 if ((p
= name
->prev
) != NULL
)
492 p
->next
= name
->next
;
494 namelist
= name
->next
;
496 if ((p
= name
->next
) != NULL
)
497 p
->prev
= name
->prev
;
499 nametail
= name
->prev
;
502 /* Return true if and only if name FILE_NAME (from an archive) matches any
503 name from the namelist. */
505 name_match (const char *file_name
)
507 size_t length
= strlen (file_name
);
511 struct name
*cursor
= namelist
;
516 if (cursor
->name
[0] == 0)
518 chdir_do (cursor
->change_dir
);
524 cursor
= namelist_match (file_name
, length
);
527 if (!(ISSLASH (file_name
[cursor
->length
]) && recursion_option
)
528 || cursor
->found_count
== 0)
529 cursor
->found_count
++; /* remember it matched */
530 if (starting_file_option
)
536 chdir_do (cursor
->change_dir
);
538 /* We got a match. */
539 return ISFOUND (cursor
);
542 /* Filename from archive not found in namelist. If we have the whole
543 namelist here, just return 0. Otherwise, read the next name in and
544 compare it. If this was the last name, namelist->found_count will
545 remain on. If not, we loop to compare the newly read name. */
547 if (same_order_option
&& namelist
->found_count
)
549 name_gather (); /* read one more */
550 if (namelist
->found_count
)
558 /* Returns true if all names from the namelist were processed.
559 P is the stat_info of the most recently processed entry.
560 The decision is postponed until the next entry is read if:
562 1) P ended with a slash (i.e. it was a directory)
563 2) P matches any entry from the namelist *and* represents a subdirectory
564 or a file lying under this entry (in the terms of directory structure).
566 This is necessary to handle contents of directories. */
568 all_names_found (struct tar_stat_info
*p
)
570 struct name
const *cursor
;
573 if (!p
->file_name
|| occurrence_option
== 0 || p
->had_trailing_slash
)
575 len
= strlen (p
->file_name
);
576 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
578 if ((cursor
->name
[0] && !WASFOUND (cursor
))
579 || (len
>= cursor
->length
&& ISSLASH (p
->file_name
[cursor
->length
])))
586 regex_usage_warning (const char *name
)
588 static int warned_once
= 0;
590 if (warn_regex_usage
&& fnmatch_pattern_has_wildcards (name
, 0))
594 _("Pattern matching characters used in file names")));
596 _("Use --wildcards to enable pattern matching,"
597 " or --no-wildcards to suppress this warning")));
602 /* Print the names of things in the namelist that were not matched. */
604 names_notfound (void)
606 struct name
const *cursor
;
608 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
609 if (!WASFOUND (cursor
) && cursor
->name
[0])
611 regex_usage_warning (cursor
->name
);
613 (cursor
->found_count
== 0) ?
614 _("%s: Not found in archive") :
615 _("%s: Required occurrence not found in archive"),
616 quotearg_colon (cursor
->name
)));
619 /* Don't bother freeing the name list; we're about to exit. */
623 if (same_order_option
)
627 while ((name
= name_next (1)) != NULL
)
629 regex_usage_warning (name
);
630 ERROR ((0, 0, _("%s: Not found in archive"),
631 quotearg_colon (name
)));
637 label_notfound (void)
639 struct name
const *cursor
;
644 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
645 if (WASFOUND (cursor
))
649 error (0, 0, _("Archive label mismatch"));
650 set_exit_status (TAREXIT_DIFFERS
);
652 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
654 if (regex_usage_warning (cursor
->name
))
658 /* Don't bother freeing the name list; we're about to exit. */
662 if (same_order_option
)
666 while ((name
= name_next (1)) != NULL
667 && regex_usage_warning (name
) == 0)
672 /* Sorting name lists. */
674 /* Sort *singly* linked LIST of names, of given LENGTH, using COMPARE
675 to order names. Return the sorted list. Note that after calling
676 this function, the `prev' links in list elements are messed up.
678 Apart from the type `struct name' and the definition of SUCCESSOR,
679 this is a generic list-sorting function, but it's too painful to
680 make it both generic and portable
684 merge_sort_sll (struct name
*list
, int length
,
685 int (*compare
) (struct name
const*, struct name
const*))
687 struct name
*first_list
;
688 struct name
*second_list
;
692 struct name
**merge_point
;
696 # define SUCCESSOR(name) ((name)->next)
703 if ((*compare
) (list
, SUCCESSOR (list
)) > 0)
705 result
= SUCCESSOR (list
);
706 SUCCESSOR (result
) = list
;
707 SUCCESSOR (list
) = 0;
714 first_length
= (length
+ 1) / 2;
715 second_length
= length
/ 2;
716 for (cursor
= list
, counter
= first_length
- 1;
718 cursor
= SUCCESSOR (cursor
), counter
--)
720 second_list
= SUCCESSOR (cursor
);
721 SUCCESSOR (cursor
) = 0;
723 first_list
= merge_sort_sll (first_list
, first_length
, compare
);
724 second_list
= merge_sort_sll (second_list
, second_length
, compare
);
726 merge_point
= &result
;
727 while (first_list
&& second_list
)
728 if ((*compare
) (first_list
, second_list
) < 0)
730 cursor
= SUCCESSOR (first_list
);
731 *merge_point
= first_list
;
732 merge_point
= &SUCCESSOR (first_list
);
737 cursor
= SUCCESSOR (second_list
);
738 *merge_point
= second_list
;
739 merge_point
= &SUCCESSOR (second_list
);
740 second_list
= cursor
;
743 *merge_point
= first_list
;
745 *merge_point
= second_list
;
752 /* Sort doubly linked LIST of names, of given LENGTH, using COMPARE
753 to order names. Return the sorted list. */
755 merge_sort (struct name
*list
, int length
,
756 int (*compare
) (struct name
const*, struct name
const*))
758 struct name
*head
, *p
, *prev
;
759 head
= merge_sort_sll (list
, length
, compare
);
760 /* Fixup prev pointers */
761 for (prev
= NULL
, p
= head
; p
; prev
= p
, p
= p
->next
)
766 /* A comparison function for sorting names. Put found names last;
767 break ties by string comparison. */
770 compare_names_found (struct name
const *n1
, struct name
const *n2
)
772 int found_diff
= WASFOUND (n2
) - WASFOUND (n1
);
773 return found_diff
? found_diff
: strcmp (n1
->name
, n2
->name
);
776 /* Simple comparison by names. */
778 compare_names (struct name
const *n1
, struct name
const *n2
)
780 return strcmp (n1
->name
, n2
->name
);
784 /* Add all the dirs under ST to the namelist NAME, descending the
785 directory hierarchy recursively. */
788 add_hierarchy_to_namelist (struct tar_stat_info
*st
, struct name
*name
)
792 name
->directory
= scan_directory (st
);
793 buffer
= directory_contents (name
->directory
);
796 struct name
*child_head
= NULL
, *child_tail
= NULL
;
797 size_t name_length
= name
->length
;
798 size_t allocated_length
= (name_length
>= NAME_FIELD_SIZE
799 ? name_length
+ NAME_FIELD_SIZE
801 char *namebuf
= xmalloc (allocated_length
+ 1);
802 /* FIXME: + 2 above? */
804 size_t string_length
;
805 int change_dir
= name
->change_dir
;
807 strcpy (namebuf
, name
->name
);
808 if (! ISSLASH (namebuf
[name_length
- 1]))
810 namebuf
[name_length
++] = '/';
811 namebuf
[name_length
] = '\0';
814 for (string
= buffer
; *string
; string
+= string_length
+ 1)
816 string_length
= strlen (string
);
820 struct tar_stat_info subdir
;
822 if (allocated_length
<= name_length
+ string_length
)
826 allocated_length
*= 2;
827 if (! allocated_length
)
830 while (allocated_length
<= name_length
+ string_length
);
832 namebuf
= xrealloc (namebuf
, allocated_length
+ 1);
834 strcpy (namebuf
+ name_length
, string
+ 1);
835 np
= addname (namebuf
, change_dir
, false, name
);
839 child_tail
->sibling
= np
;
842 tar_stat_init (&subdir
);
844 subdir
.fd
= openat (st
->fd
, string
+ 1,
845 open_read_flags
| O_DIRECTORY
);
848 else if (fstat (subdir
.fd
, &subdir
.stat
) != 0)
850 else if (! (O_DIRECTORY
|| S_ISDIR (subdir
.stat
.st_mode
)))
857 subdir
.orig_file_name
= xstrdup (namebuf
);
858 add_hierarchy_to_namelist (&subdir
, np
);
861 tar_stat_destroy (&subdir
);
866 name
->child
= child_head
;
870 /* Auxiliary functions for hashed table of struct name's. */
873 name_hash (void const *entry
, size_t n_buckets
)
875 struct name
const *name
= entry
;
876 return hash_string (name
->caname
, n_buckets
);
879 /* Compare two directories for equality of their names. */
881 name_compare (void const *entry1
, void const *entry2
)
883 struct name
const *name1
= entry1
;
884 struct name
const *name2
= entry2
;
885 return strcmp (name1
->caname
, name2
->caname
) == 0;
889 /* Rebase `name' member of CHILD and all its siblings to
892 rebase_child_list (struct name
*child
, struct name
*parent
)
894 size_t old_prefix_len
= child
->parent
->length
;
895 size_t new_prefix_len
= parent
->length
;
896 char *new_prefix
= parent
->name
;
898 for (; child
; child
= child
->sibling
)
900 size_t size
= child
->length
- old_prefix_len
+ new_prefix_len
;
901 char *newp
= xmalloc (size
+ 1);
902 strcpy (newp
, new_prefix
);
903 strcat (newp
, child
->name
+ old_prefix_len
);
906 child
->length
= size
;
908 rebase_directory (child
->directory
,
909 child
->parent
->name
, old_prefix_len
,
910 new_prefix
, new_prefix_len
);
914 /* Collect all the names from argv[] (or whatever), expand them into a
915 directory tree, and sort them. This gets only subdirectories, not
919 collect_and_sort_names (void)
922 struct name
*next_name
, *prev_name
= NULL
;
929 addname (".", 0, false, NULL
);
931 if (listed_incremental_option
)
933 switch (chdir_count ())
939 if (namelist
->change_dir
== 0)
941 _("Using -C option inside file list is not "
942 "allowed with --listed-incremental")));
947 _("Only one -C option is allowed with "
948 "--listed-incremental")));
951 read_directory_file ();
955 for (name
= namelist
; name
; name
= name
->next
, num_names
++)
957 struct tar_stat_info st
;
959 if (name
->found_count
|| name
->directory
)
961 if (name
->matching_flags
& EXCLUDE_WILDCARDS
)
962 /* NOTE: EXCLUDE_ANCHORED is not relevant here */
963 /* FIXME: just skip regexps for now */
965 chdir_do (name
->change_dir
);
967 if (name
->name
[0] == 0)
972 if (deref_stat (dereference_option
, name
->name
, &st
.stat
) != 0)
974 stat_diag (name
->name
);
977 if (S_ISDIR (st
.stat
.st_mode
))
979 st
.fd
= open (name
->name
, open_read_flags
| O_DIRECTORY
);
981 open_diag (name
->name
);
982 else if (fstat (st
.fd
, &st
.stat
) != 0)
983 stat_diag (name
->name
);
984 else if (O_DIRECTORY
|| S_ISDIR (st
.stat
.st_mode
))
986 st
.orig_file_name
= xstrdup (name
->name
);
988 add_hierarchy_to_namelist (&st
, name
);
992 tar_stat_destroy (&st
);
995 namelist
= merge_sort (namelist
, num_names
, compare_names
);
998 nametab
= hash_initialize (0, 0,
1000 name_compare
, NULL
);
1001 for (name
= namelist
; name
; name
= next_name
)
1003 next_name
= name
->next
;
1004 name
->caname
= normalize_filename (name
->name
);
1007 struct name
*p
= hash_lookup (nametab
, name
);
1010 /* Keep the one listed in the command line */
1014 rebase_child_list (p
->child
, name
);
1015 hash_delete (nametab
, name
);
1016 /* FIXME: remove_directory (p->caname); ? */
1024 rebase_child_list (name
->child
, p
);
1025 /* FIXME: remove_directory (name->caname); ? */
1032 name
->found_count
= 0;
1033 if (!hash_insert (nametab
, name
))
1038 nametail
= prev_name
;
1039 hash_free (nametab
);
1041 namelist
= merge_sort (namelist
, num_names
, compare_names_found
);
1043 if (listed_incremental_option
)
1045 for (name
= namelist
; name
&& name
->name
[0] == 0; name
++)
1048 append_incremental_renames (name
->directory
);
1052 /* This is like name_match, except that
1053 1. It returns a pointer to the name it matched, and doesn't set FOUND
1054 in structure. The caller will have to do that if it wants to.
1055 2. If the namelist is empty, it returns null, unlike name_match, which
1058 name_scan (const char *file_name
)
1060 size_t length
= strlen (file_name
);
1064 struct name
*cursor
= namelist_match (file_name
, length
);
1068 /* Filename from archive not found in namelist. If we have the whole
1069 namelist here, just return 0. Otherwise, read the next name in and
1070 compare it. If this was the last name, namelist->found_count will
1071 remain on. If not, we loop to compare the newly read name. */
1073 if (same_order_option
&& namelist
&& namelist
->found_count
)
1075 name_gather (); /* read one more */
1076 if (namelist
->found_count
)
1084 /* This returns a name from the namelist which doesn't have ->found
1085 set. It sets ->found before returning, so successive calls will
1086 find and return all the non-found names in the namelist. */
1087 struct name
*gnu_list_name
;
1093 gnu_list_name
= namelist
;
1094 while (gnu_list_name
1095 && (gnu_list_name
->found_count
|| gnu_list_name
->name
[0] == 0))
1096 gnu_list_name
= gnu_list_name
->next
;
1099 gnu_list_name
->found_count
++;
1100 chdir_do (gnu_list_name
->change_dir
);
1101 return gnu_list_name
;
1107 blank_name_list (void)
1112 for (name
= namelist
; name
; name
= name
->next
)
1113 name
->found_count
= 0;
1116 /* Yield a newly allocated file name consisting of FILE_NAME concatenated to
1117 NAME, with an intervening slash if FILE_NAME does not already end in one. */
1119 new_name (const char *file_name
, const char *name
)
1121 size_t file_name_len
= strlen (file_name
);
1122 size_t namesize
= strlen (name
) + 1;
1123 int slash
= file_name_len
&& ! ISSLASH (file_name
[file_name_len
- 1]);
1124 char *buffer
= xmalloc (file_name_len
+ slash
+ namesize
);
1125 memcpy (buffer
, file_name
, file_name_len
);
1126 buffer
[file_name_len
] = '/';
1127 memcpy (buffer
+ file_name_len
+ slash
, name
, namesize
);
1131 /* Return nonzero if file NAME is excluded. */
1133 excluded_name (char const *name
)
1135 return excluded_file_name (excluded
, name
+ FILE_SYSTEM_PREFIX_LEN (name
));
1138 static Hash_table
*individual_file_table
;
1141 register_individual_file (char const *name
)
1145 if (deref_stat (dereference_option
, name
, &st
) != 0)
1146 return; /* Will be complained about later */
1147 if (S_ISDIR (st
.st_mode
))
1150 hash_string_insert (&individual_file_table
, name
);
1154 is_individual_file (char const *name
)
1156 return hash_string_lookup (individual_file_table
, name
);
1161 /* Return the size of the prefix of FILE_NAME that is removed after
1162 stripping NUM leading file name components. NUM must be
1166 stripped_prefix_len (char const *file_name
, size_t num
)
1168 char const *p
= file_name
+ FILE_SYSTEM_PREFIX_LEN (file_name
);
1169 while (ISSLASH (*p
))
1173 bool slash
= ISSLASH (*p
);
1178 return p
- file_name
;
1179 while (ISSLASH (*p
))
1186 /* Return nonzero if NAME contains ".." as a file name component. */
1188 contains_dot_dot (char const *name
)
1190 char const *p
= name
+ FILE_SYSTEM_PREFIX_LEN (name
);
1194 if (p
[0] == '.' && p
[1] == '.' && (ISSLASH (p
[2]) || !p
[2]))
1197 while (! ISSLASH (*p
))