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/>. */
27 /* User and group names. */
29 /* Make sure you link with the proper libraries if you are running the
30 Yellow Peril (thanks for the good laugh, Ian J.!), or, euh... NIS.
31 This code should also be modified for non-UNIX systems to do something
34 static char *cached_uname
;
35 static char *cached_gname
;
37 static uid_t cached_uid
; /* valid only if cached_uname is not empty */
38 static gid_t cached_gid
; /* valid only if cached_gname is not empty */
40 /* These variables are valid only if nonempty. */
41 static char *cached_no_such_uname
;
42 static char *cached_no_such_gname
;
44 /* These variables are valid only if nonzero. It's not worth optimizing
45 the case for weird systems where 0 is not a valid uid or gid. */
46 static uid_t cached_no_such_uid
;
47 static gid_t cached_no_such_gid
;
49 /* Given UID, find the corresponding UNAME. */
51 uid_to_uname (uid_t uid
, char **uname
)
53 struct passwd
*passwd
;
55 if (uid
!= 0 && uid
== cached_no_such_uid
)
57 *uname
= xstrdup ("");
61 if (!cached_uname
|| uid
!= cached_uid
)
63 passwd
= getpwuid (uid
);
67 assign_string (&cached_uname
, passwd
->pw_name
);
71 cached_no_such_uid
= uid
;
72 *uname
= xstrdup ("");
76 *uname
= xstrdup (cached_uname
);
79 /* Given GID, find the corresponding GNAME. */
81 gid_to_gname (gid_t gid
, char **gname
)
85 if (gid
!= 0 && gid
== cached_no_such_gid
)
87 *gname
= xstrdup ("");
91 if (!cached_gname
|| gid
!= cached_gid
)
93 group
= getgrgid (gid
);
97 assign_string (&cached_gname
, group
->gr_name
);
101 cached_no_such_gid
= gid
;
102 *gname
= xstrdup ("");
106 *gname
= xstrdup (cached_gname
);
109 /* Given UNAME, set the corresponding UID and return 1, or else, return 0. */
111 uname_to_uid (char const *uname
, uid_t
*uidp
)
113 struct passwd
*passwd
;
115 if (cached_no_such_uname
116 && strcmp (uname
, cached_no_such_uname
) == 0)
120 || uname
[0] != cached_uname
[0]
121 || strcmp (uname
, cached_uname
) != 0)
123 passwd
= getpwnam (uname
);
126 cached_uid
= passwd
->pw_uid
;
127 assign_string (&cached_uname
, passwd
->pw_name
);
131 assign_string (&cached_no_such_uname
, uname
);
139 /* Given GNAME, set the corresponding GID and return 1, or else, return 0. */
141 gname_to_gid (char const *gname
, gid_t
*gidp
)
145 if (cached_no_such_gname
146 && strcmp (gname
, cached_no_such_gname
) == 0)
150 || gname
[0] != cached_gname
[0]
151 || strcmp (gname
, cached_gname
) != 0)
153 group
= getgrnam (gname
);
156 cached_gid
= group
->gr_gid
;
157 assign_string (&cached_gname
, gname
);
161 assign_string (&cached_no_such_gname
, gname
);
171 make_name (const char *file_name
)
173 struct name
*p
= xzalloc (sizeof (*p
));
176 p
->name
= xstrdup (file_name
);
177 p
->length
= strlen (p
->name
);
182 free_name (struct name
*p
)
193 /* Names from the command call. */
195 static struct name
*namelist
; /* first name in list, if any */
196 static struct name
*nametail
; /* end of name list */
198 /* File name arguments are processed in two stages: first a
199 name_array (see below) is filled, then the names from it
200 are moved into the namelist.
202 This awkward process is needed only to implement --same-order option,
203 which is meant to help process large archives on machines with
204 limited memory. With this option on, namelist contains at most one
205 entry, which diminishes the memory consumption.
207 However, I very much doubt if we still need this -- Sergey */
209 /* A name_array element contains entries of three types: */
211 #define NELT_NAME 0 /* File name */
212 #define NELT_CHDIR 1 /* Change directory request */
213 #define NELT_FMASK 2 /* Change fnmatch options request */
215 struct name_elt
/* A name_array element. */
217 char type
; /* Element type, see NELT_* constants above */
220 const char *name
; /* File or directory name */
221 int matching_flags
;/* fnmatch options if type == NELT_FMASK */
225 static struct name_elt
*name_array
; /* store an array of names */
226 static size_t allocated_entries
; /* how big is the array? */
227 static size_t entries
; /* how many entries does it have? */
228 static size_t scanned
; /* how many of the entries have we scanned? */
229 size_t name_count
; /* how many of the entries are names? */
231 /* Check the size of name_array, reallocating it as necessary. */
233 check_name_alloc (void)
235 if (entries
== allocated_entries
)
237 if (allocated_entries
== 0)
238 allocated_entries
= 10; /* Set initial allocation */
239 name_array
= x2nrealloc (name_array
, &allocated_entries
,
240 sizeof (name_array
[0]));
244 /* Add to name_array the file NAME with fnmatch options MATCHING_FLAGS */
246 name_add_name (const char *name
, int matching_flags
)
248 static int prev_flags
= 0; /* FIXME: Or EXCLUDE_ANCHORED? */
252 ep
= &name_array
[entries
++];
253 if (prev_flags
!= matching_flags
)
255 ep
->type
= NELT_FMASK
;
256 ep
->v
.matching_flags
= matching_flags
;
257 prev_flags
= matching_flags
;
259 ep
= &name_array
[entries
++];
261 ep
->type
= NELT_NAME
;
266 /* Add to name_array a chdir request for the directory NAME */
268 name_add_dir (const char *name
)
272 ep
= &name_array
[entries
++];
273 ep
->type
= NELT_CHDIR
;
278 /* Names from external name file. */
280 static char *name_buffer
; /* buffer to hold the current file name */
281 static size_t name_buffer_length
; /* allocated length of name_buffer */
283 /* Set up to gather file names for tar. They can either come from a
284 file or were saved from decoding arguments. */
288 name_buffer
= xmalloc (NAME_FIELD_SIZE
+ 2);
289 name_buffer_length
= NAME_FIELD_SIZE
;
299 static int matching_flags
; /* exclude_fnmatch options */
301 /* Get the next NELT_NAME element from name_array. Result is in
302 static storage and can't be relied upon across two calls.
304 If CHANGE_DIRS is true, treat any entries of type NELT_CHDIR as
305 the request to change to the given directory.
307 Entries of type NELT_FMASK cause updates of the matching_flags
309 static struct name_elt
*
310 name_next_elt (int change_dirs
)
312 static struct name_elt entry
;
316 while (scanned
!= entries
)
321 ep
= &name_array
[scanned
++];
322 if (ep
->type
== NELT_FMASK
)
324 matching_flags
= ep
->v
.matching_flags
;
329 source_len
= strlen (source
);
330 if (name_buffer_length
< source_len
)
334 name_buffer_length
*= 2;
335 if (! name_buffer_length
)
338 while (name_buffer_length
< source_len
);
341 name_buffer
= xmalloc (name_buffer_length
+ 2);
343 strcpy (name_buffer
, source
);
345 /* Zap trailing slashes. */
347 cursor
= name_buffer
+ strlen (name_buffer
) - 1;
348 while (cursor
> name_buffer
&& ISSLASH (*cursor
))
351 if (change_dirs
&& ep
->type
== NELT_CHDIR
)
353 if (chdir (name_buffer
) < 0)
354 chdir_fatal (name_buffer
);
359 unquote_string (name_buffer
);
360 entry
.type
= ep
->type
;
361 entry
.v
.name
= name_buffer
;
370 name_next (int change_dirs
)
372 struct name_elt
*nelt
= name_next_elt (change_dirs
);
373 return nelt
? nelt
->v
.name
: NULL
;
376 /* Gather names in a list for scanning. Could hash them later if we
379 If the names are already sorted to match the archive, we just read
380 them one by one. name_gather reads the first one, and it is called
381 by name_match as appropriate to read the next ones. At EOF, the
382 last name read is just left in the buffer. This option lets users
383 of small machines extract an arbitrary number of files by doing
384 "tar t" and editing down the list of files. */
389 /* Buffer able to hold a single name. */
390 static struct name
*buffer
= NULL
;
394 if (same_order_option
)
396 static int change_dir
;
398 while ((ep
= name_next_elt (0)) && ep
->type
== NELT_CHDIR
)
399 change_dir
= chdir_arg (xstrdup (ep
->v
.name
));
404 buffer
= make_name (ep
->v
.name
);
405 buffer
->change_dir
= change_dir
;
407 buffer
->found_count
= 0;
408 buffer
->matching_flags
= matching_flags
;
409 buffer
->directory
= NULL
;
410 buffer
->parent
= NULL
;
411 buffer
->cmdline
= true;
413 namelist
= nametail
= buffer
;
416 addname (0, change_dir
, false, NULL
);
420 /* Non sorted names -- read them all in. */
425 int change_dir0
= change_dir
;
426 while ((ep
= name_next_elt (0)) && ep
->type
== NELT_CHDIR
)
427 change_dir
= chdir_arg (xstrdup (ep
->v
.name
));
430 addname (ep
->v
.name
, change_dir
, true, NULL
);
433 if (change_dir
!= change_dir0
)
434 addname (NULL
, change_dir
, false, NULL
);
441 /* Add a name to the namelist. */
443 addname (char const *string
, int change_dir
, bool cmdline
, struct name
*parent
)
445 struct name
*name
= make_name (string
);
447 name
->prev
= nametail
;
449 name
->found_count
= 0;
450 name
->matching_flags
= matching_flags
;
451 name
->change_dir
= change_dir
;
452 name
->directory
= NULL
;
453 name
->parent
= parent
;
454 name
->cmdline
= cmdline
;
457 nametail
->next
= name
;
464 /* Find a match for FILE_NAME (whose string length is LENGTH) in the name
467 namelist_match (char const *file_name
, size_t length
)
471 for (p
= namelist
; p
; p
= p
->next
)
474 && exclude_fnmatch (p
->name
, file_name
, p
->matching_flags
))
482 remname (struct name
*name
)
486 if ((p
= name
->prev
) != NULL
)
487 p
->next
= name
->next
;
489 namelist
= name
->next
;
491 if ((p
= name
->next
) != NULL
)
492 p
->prev
= name
->prev
;
494 nametail
= name
->prev
;
497 /* Return true if and only if name FILE_NAME (from an archive) matches any
498 name from the namelist. */
500 name_match (const char *file_name
)
502 size_t length
= strlen (file_name
);
506 struct name
*cursor
= namelist
;
511 if (cursor
->name
[0] == 0)
513 chdir_do (cursor
->change_dir
);
519 cursor
= namelist_match (file_name
, length
);
522 if (!(ISSLASH (file_name
[cursor
->length
]) && recursion_option
)
523 || cursor
->found_count
== 0)
524 cursor
->found_count
++; /* remember it matched */
525 if (starting_file_option
)
531 chdir_do (cursor
->change_dir
);
533 /* We got a match. */
534 return ISFOUND (cursor
);
537 /* Filename from archive not found in namelist. If we have the whole
538 namelist here, just return 0. Otherwise, read the next name in and
539 compare it. If this was the last name, namelist->found_count will
540 remain on. If not, we loop to compare the newly read name. */
542 if (same_order_option
&& namelist
->found_count
)
544 name_gather (); /* read one more */
545 if (namelist
->found_count
)
553 /* Returns true if all names from the namelist were processed.
554 P is the stat_info of the most recently processed entry.
555 The decision is postponed until the next entry is read if:
557 1) P ended with a slash (i.e. it was a directory)
558 2) P matches any entry from the namelist *and* represents a subdirectory
559 or a file lying under this entry (in the terms of directory structure).
561 This is necessary to handle contents of directories. */
563 all_names_found (struct tar_stat_info
*p
)
565 struct name
const *cursor
;
568 if (!p
->file_name
|| occurrence_option
== 0 || p
->had_trailing_slash
)
570 len
= strlen (p
->file_name
);
571 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
573 if ((cursor
->name
[0] && !WASFOUND (cursor
))
574 || (len
>= cursor
->length
&& ISSLASH (p
->file_name
[cursor
->length
])))
581 regex_usage_warning (const char *name
)
583 static int warned_once
= 0;
585 if (warn_regex_usage
&& fnmatch_pattern_has_wildcards (name
, 0))
589 _("Pattern matching characters used in file names")));
591 _("Use --wildcards to enable pattern matching,"
592 " or --no-wildcards to suppress this warning")));
597 /* Print the names of things in the namelist that were not matched. */
599 names_notfound (void)
601 struct name
const *cursor
;
603 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
604 if (!WASFOUND (cursor
) && cursor
->name
[0])
606 regex_usage_warning (cursor
->name
);
608 (cursor
->found_count
== 0) ?
609 _("%s: Not found in archive") :
610 _("%s: Required occurrence not found in archive"),
611 quotearg_colon (cursor
->name
)));
614 /* Don't bother freeing the name list; we're about to exit. */
618 if (same_order_option
)
622 while ((name
= name_next (1)) != NULL
)
624 regex_usage_warning (name
);
625 ERROR ((0, 0, _("%s: Not found in archive"),
626 quotearg_colon (name
)));
632 label_notfound (void)
634 struct name
const *cursor
;
639 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
640 if (WASFOUND (cursor
))
644 error (0, 0, _("Archive label mismatch"));
645 set_exit_status (TAREXIT_DIFFERS
);
647 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
649 if (regex_usage_warning (cursor
->name
))
653 /* Don't bother freeing the name list; we're about to exit. */
657 if (same_order_option
)
661 while ((name
= name_next (1)) != NULL
662 && regex_usage_warning (name
) == 0)
667 /* Sorting name lists. */
669 /* Sort *singly* linked LIST of names, of given LENGTH, using COMPARE
670 to order names. Return the sorted list. Note that after calling
671 this function, the 'prev' links in list elements are messed up.
673 Apart from the type 'struct name' and the definition of SUCCESSOR,
674 this is a generic list-sorting function, but it's too painful to
675 make it both generic and portable
679 merge_sort_sll (struct name
*list
, int length
,
680 int (*compare
) (struct name
const*, struct name
const*))
682 struct name
*first_list
;
683 struct name
*second_list
;
687 struct name
**merge_point
;
691 # define SUCCESSOR(name) ((name)->next)
698 if ((*compare
) (list
, SUCCESSOR (list
)) > 0)
700 result
= SUCCESSOR (list
);
701 SUCCESSOR (result
) = list
;
702 SUCCESSOR (list
) = 0;
709 first_length
= (length
+ 1) / 2;
710 second_length
= length
/ 2;
711 for (cursor
= list
, counter
= first_length
- 1;
713 cursor
= SUCCESSOR (cursor
), counter
--)
715 second_list
= SUCCESSOR (cursor
);
716 SUCCESSOR (cursor
) = 0;
718 first_list
= merge_sort_sll (first_list
, first_length
, compare
);
719 second_list
= merge_sort_sll (second_list
, second_length
, compare
);
721 merge_point
= &result
;
722 while (first_list
&& second_list
)
723 if ((*compare
) (first_list
, second_list
) < 0)
725 cursor
= SUCCESSOR (first_list
);
726 *merge_point
= first_list
;
727 merge_point
= &SUCCESSOR (first_list
);
732 cursor
= SUCCESSOR (second_list
);
733 *merge_point
= second_list
;
734 merge_point
= &SUCCESSOR (second_list
);
735 second_list
= cursor
;
738 *merge_point
= first_list
;
740 *merge_point
= second_list
;
747 /* Sort doubly linked LIST of names, of given LENGTH, using COMPARE
748 to order names. Return the sorted list. */
750 merge_sort (struct name
*list
, int length
,
751 int (*compare
) (struct name
const*, struct name
const*))
753 struct name
*head
, *p
, *prev
;
754 head
= merge_sort_sll (list
, length
, compare
);
755 /* Fixup prev pointers */
756 for (prev
= NULL
, p
= head
; p
; prev
= p
, p
= p
->next
)
761 /* A comparison function for sorting names. Put found names last;
762 break ties by string comparison. */
765 compare_names_found (struct name
const *n1
, struct name
const *n2
)
767 int found_diff
= WASFOUND (n2
) - WASFOUND (n1
);
768 return found_diff
? found_diff
: strcmp (n1
->name
, n2
->name
);
771 /* Simple comparison by names. */
773 compare_names (struct name
const *n1
, struct name
const *n2
)
775 return strcmp (n1
->name
, n2
->name
);
779 /* Add all the dirs under ST to the namelist NAME, descending the
780 directory hierarchy recursively. */
783 add_hierarchy_to_namelist (struct tar_stat_info
*st
, struct name
*name
)
787 name
->directory
= scan_directory (st
);
788 buffer
= directory_contents (name
->directory
);
791 struct name
*child_head
= NULL
, *child_tail
= NULL
;
792 size_t name_length
= name
->length
;
793 size_t allocated_length
= (name_length
>= NAME_FIELD_SIZE
794 ? name_length
+ NAME_FIELD_SIZE
796 char *namebuf
= xmalloc (allocated_length
+ 1);
797 /* FIXME: + 2 above? */
799 size_t string_length
;
800 int change_dir
= name
->change_dir
;
802 strcpy (namebuf
, name
->name
);
803 if (! ISSLASH (namebuf
[name_length
- 1]))
805 namebuf
[name_length
++] = '/';
806 namebuf
[name_length
] = '\0';
809 for (string
= buffer
; *string
; string
+= string_length
+ 1)
811 string_length
= strlen (string
);
815 struct tar_stat_info subdir
;
818 if (allocated_length
<= name_length
+ string_length
)
822 allocated_length
*= 2;
823 if (! allocated_length
)
826 while (allocated_length
<= name_length
+ string_length
);
828 namebuf
= xrealloc (namebuf
, allocated_length
+ 1);
830 strcpy (namebuf
+ name_length
, string
+ 1);
831 np
= addname (namebuf
, change_dir
, false, name
);
835 child_tail
->sibling
= np
;
838 tar_stat_init (&subdir
);
846 subfd
= subfile_open (st
, string
+ 1,
847 open_read_flags
| O_DIRECTORY
);
853 if (fstat (subfd
, &subdir
.stat
) != 0)
855 else if (! (O_DIRECTORY
|| S_ISDIR (subdir
.stat
.st_mode
)))
862 subdir
.orig_file_name
= xstrdup (namebuf
);
863 add_hierarchy_to_namelist (&subdir
, np
);
864 restore_parent_fd (&subdir
);
868 tar_stat_destroy (&subdir
);
873 name
->child
= child_head
;
877 /* Auxiliary functions for hashed table of struct name's. */
880 name_hash (void const *entry
, size_t n_buckets
)
882 struct name
const *name
= entry
;
883 return hash_string (name
->caname
, n_buckets
);
886 /* Compare two directories for equality of their names. */
888 name_compare (void const *entry1
, void const *entry2
)
890 struct name
const *name1
= entry1
;
891 struct name
const *name2
= entry2
;
892 return strcmp (name1
->caname
, name2
->caname
) == 0;
896 /* Rebase 'name' member of CHILD and all its siblings to
899 rebase_child_list (struct name
*child
, struct name
*parent
)
901 size_t old_prefix_len
= child
->parent
->length
;
902 size_t new_prefix_len
= parent
->length
;
903 char *new_prefix
= parent
->name
;
905 for (; child
; child
= child
->sibling
)
907 size_t size
= child
->length
- old_prefix_len
+ new_prefix_len
;
908 char *newp
= xmalloc (size
+ 1);
909 strcpy (newp
, new_prefix
);
910 strcat (newp
, child
->name
+ old_prefix_len
);
913 child
->length
= size
;
915 rebase_directory (child
->directory
,
916 child
->parent
->name
, old_prefix_len
,
917 new_prefix
, new_prefix_len
);
921 /* Collect all the names from argv[] (or whatever), expand them into a
922 directory tree, and sort them. This gets only subdirectories, not
926 collect_and_sort_names (void)
929 struct name
*next_name
, *prev_name
= NULL
;
936 addname (".", 0, false, NULL
);
938 if (listed_incremental_option
)
940 switch (chdir_count ())
946 if (namelist
->change_dir
== 0)
948 _("Using -C option inside file list is not "
949 "allowed with --listed-incremental")));
954 _("Only one -C option is allowed with "
955 "--listed-incremental")));
958 read_directory_file ();
962 for (name
= namelist
; name
; name
= name
->next
, num_names
++)
964 struct tar_stat_info st
;
966 if (name
->found_count
|| name
->directory
)
968 if (name
->matching_flags
& EXCLUDE_WILDCARDS
)
969 /* NOTE: EXCLUDE_ANCHORED is not relevant here */
970 /* FIXME: just skip regexps for now */
972 chdir_do (name
->change_dir
);
974 if (name
->name
[0] == 0)
979 if (deref_stat (name
->name
, &st
.stat
) != 0)
981 stat_diag (name
->name
);
984 if (S_ISDIR (st
.stat
.st_mode
))
986 int dir_fd
= openat (chdir_fd
, name
->name
,
987 open_read_flags
| O_DIRECTORY
);
989 open_diag (name
->name
);
993 if (fstat (dir_fd
, &st
.stat
) != 0)
994 stat_diag (name
->name
);
995 else if (O_DIRECTORY
|| S_ISDIR (st
.stat
.st_mode
))
997 st
.orig_file_name
= xstrdup (name
->name
);
999 add_hierarchy_to_namelist (&st
, name
);
1004 tar_stat_destroy (&st
);
1007 namelist
= merge_sort (namelist
, num_names
, compare_names
);
1010 nametab
= hash_initialize (0, 0,
1012 name_compare
, NULL
);
1013 for (name
= namelist
; name
; name
= next_name
)
1015 next_name
= name
->next
;
1016 name
->caname
= normalize_filename (name
->name
);
1019 struct name
*p
= hash_lookup (nametab
, name
);
1022 /* Keep the one listed in the command line */
1026 rebase_child_list (p
->child
, name
);
1027 hash_delete (nametab
, name
);
1028 /* FIXME: remove_directory (p->caname); ? */
1036 rebase_child_list (name
->child
, p
);
1037 /* FIXME: remove_directory (name->caname); ? */
1044 name
->found_count
= 0;
1045 if (!hash_insert (nametab
, name
))
1050 nametail
= prev_name
;
1051 hash_free (nametab
);
1053 namelist
= merge_sort (namelist
, num_names
, compare_names_found
);
1055 if (listed_incremental_option
)
1057 for (name
= namelist
; name
&& name
->name
[0] == 0; name
++)
1060 append_incremental_renames (name
->directory
);
1064 /* This is like name_match, except that
1065 1. It returns a pointer to the name it matched, and doesn't set FOUND
1066 in structure. The caller will have to do that if it wants to.
1067 2. If the namelist is empty, it returns null, unlike name_match, which
1070 name_scan (const char *file_name
)
1072 size_t length
= strlen (file_name
);
1076 struct name
*cursor
= namelist_match (file_name
, length
);
1080 /* Filename from archive not found in namelist. If we have the whole
1081 namelist here, just return 0. Otherwise, read the next name in and
1082 compare it. If this was the last name, namelist->found_count will
1083 remain on. If not, we loop to compare the newly read name. */
1085 if (same_order_option
&& namelist
&& namelist
->found_count
)
1087 name_gather (); /* read one more */
1088 if (namelist
->found_count
)
1096 /* This returns a name from the namelist which doesn't have ->found
1097 set. It sets ->found before returning, so successive calls will
1098 find and return all the non-found names in the namelist. */
1099 struct name
*gnu_list_name
;
1102 name_from_list (void)
1105 gnu_list_name
= namelist
;
1106 while (gnu_list_name
1107 && (gnu_list_name
->found_count
|| gnu_list_name
->name
[0] == 0))
1108 gnu_list_name
= gnu_list_name
->next
;
1111 gnu_list_name
->found_count
++;
1112 chdir_do (gnu_list_name
->change_dir
);
1113 return gnu_list_name
;
1119 blank_name_list (void)
1124 for (name
= namelist
; name
; name
= name
->next
)
1125 name
->found_count
= 0;
1128 /* Yield a newly allocated file name consisting of FILE_NAME concatenated to
1129 NAME, with an intervening slash if FILE_NAME does not already end in one. */
1131 new_name (const char *file_name
, const char *name
)
1133 size_t file_name_len
= strlen (file_name
);
1134 size_t namesize
= strlen (name
) + 1;
1135 int slash
= file_name_len
&& ! ISSLASH (file_name
[file_name_len
- 1]);
1136 char *buffer
= xmalloc (file_name_len
+ slash
+ namesize
);
1137 memcpy (buffer
, file_name
, file_name_len
);
1138 buffer
[file_name_len
] = '/';
1139 memcpy (buffer
+ file_name_len
+ slash
, name
, namesize
);
1143 /* Return nonzero if file NAME is excluded. */
1145 excluded_name (char const *name
)
1147 return excluded_file_name (excluded
, name
+ FILE_SYSTEM_PREFIX_LEN (name
));
1151 /* Return the size of the prefix of FILE_NAME that is removed after
1152 stripping NUM leading file name components. NUM must be
1156 stripped_prefix_len (char const *file_name
, size_t num
)
1158 char const *p
= file_name
+ FILE_SYSTEM_PREFIX_LEN (file_name
);
1159 while (ISSLASH (*p
))
1163 bool slash
= ISSLASH (*p
);
1168 return p
- file_name
;
1169 while (ISSLASH (*p
))
1176 /* Return nonzero if NAME contains ".." as a file name component. */
1178 contains_dot_dot (char const *name
)
1180 char const *p
= name
+ FILE_SYSTEM_PREFIX_LEN (name
);
1184 if (p
[0] == '.' && p
[1] == '.' && (ISSLASH (p
[2]) || !p
[2]))
1187 while (! ISSLASH (*p
))