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>
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 /* Given UID, find the corresponding UNAME. */
52 uid_to_uname (uid_t uid
, char **uname
)
54 struct passwd
*passwd
;
56 if (uid
!= 0 && uid
== cached_no_such_uid
)
58 *uname
= xstrdup ("");
62 if (!cached_uname
|| uid
!= cached_uid
)
64 passwd
= getpwuid (uid
);
68 assign_string (&cached_uname
, passwd
->pw_name
);
72 cached_no_such_uid
= uid
;
73 *uname
= xstrdup ("");
77 *uname
= xstrdup (cached_uname
);
80 /* Given GID, find the corresponding GNAME. */
82 gid_to_gname (gid_t gid
, char **gname
)
86 if (gid
!= 0 && gid
== cached_no_such_gid
)
88 *gname
= xstrdup ("");
92 if (!cached_gname
|| gid
!= cached_gid
)
94 group
= getgrgid (gid
);
98 assign_string (&cached_gname
, group
->gr_name
);
102 cached_no_such_gid
= gid
;
103 *gname
= xstrdup ("");
107 *gname
= xstrdup (cached_gname
);
110 /* Given UNAME, set the corresponding UID and return 1, or else, return 0. */
112 uname_to_uid (char const *uname
, uid_t
*uidp
)
114 struct passwd
*passwd
;
116 if (cached_no_such_uname
117 && strcmp (uname
, cached_no_such_uname
) == 0)
121 || uname
[0] != cached_uname
[0]
122 || strcmp (uname
, cached_uname
) != 0)
124 passwd
= getpwnam (uname
);
127 cached_uid
= passwd
->pw_uid
;
128 assign_string (&cached_uname
, passwd
->pw_name
);
132 assign_string (&cached_no_such_uname
, uname
);
140 /* Given GNAME, set the corresponding GID and return 1, or else, return 0. */
142 gname_to_gid (char const *gname
, gid_t
*gidp
)
146 if (cached_no_such_gname
147 && strcmp (gname
, cached_no_such_gname
) == 0)
151 || gname
[0] != cached_gname
[0]
152 || strcmp (gname
, cached_gname
) != 0)
154 group
= getgrnam (gname
);
157 cached_gid
= group
->gr_gid
;
158 assign_string (&cached_gname
, gname
);
162 assign_string (&cached_no_such_gname
, gname
);
172 make_name (const char *file_name
)
174 struct name
*p
= xzalloc (sizeof (*p
));
177 p
->name
= xstrdup (file_name
);
178 p
->length
= strlen (p
->name
);
183 free_name (struct name
*p
)
194 /* Names from the command call. */
196 static struct name
*namelist
; /* first name in list, if any */
197 static struct name
*nametail
; /* end of name list */
199 /* File name arguments are processed in two stages: first a
200 name_array (see below) is filled, then the names from it
201 are moved into the namelist.
203 This awkward process is needed only to implement --same-order option,
204 which is meant to help process large archives on machines with
205 limited memory. With this option on, namelist contains at most one
206 entry, which diminishes the memory consumption.
208 However, I very much doubt if we still need this -- Sergey */
210 /* A name_array element contains entries of three types: */
212 #define NELT_NAME 0 /* File name */
213 #define NELT_CHDIR 1 /* Change directory request */
214 #define NELT_FMASK 2 /* Change fnmatch options request */
215 #define NELT_FILE 3 /* Read file names from that file */
217 struct name_elt
/* A name_array element. */
219 char type
; /* Element type, see NELT_* constants above */
222 const char *name
; /* File or directory name */
223 int matching_flags
;/* fnmatch options if type == NELT_FMASK */
226 const char *name
;/* File name */
227 int term
; /* File name terminator in the list */
233 static struct name_elt
*name_array
; /* store an array of names */
234 static size_t allocated_entries
; /* how big is the array? */
235 static size_t entries
; /* how many entries does it have? */
236 static size_t scanned
; /* how many of the entries have we scanned? */
237 size_t name_count
; /* how many of the entries are names? */
239 /* Check the size of name_array, reallocating it as necessary. */
241 check_name_alloc (void)
243 if (entries
== allocated_entries
)
245 if (allocated_entries
== 0)
246 allocated_entries
= 10; /* Set initial allocation */
247 name_array
= x2nrealloc (name_array
, &allocated_entries
,
248 sizeof (name_array
[0]));
252 /* Add to name_array the file NAME with fnmatch options MATCHING_FLAGS */
254 name_add_name (const char *name
, int matching_flags
)
256 static int prev_flags
= 0; /* FIXME: Or EXCLUDE_ANCHORED? */
260 ep
= &name_array
[entries
++];
261 if (prev_flags
!= matching_flags
)
263 ep
->type
= NELT_FMASK
;
264 ep
->v
.matching_flags
= matching_flags
;
265 prev_flags
= matching_flags
;
267 ep
= &name_array
[entries
++];
269 ep
->type
= NELT_NAME
;
274 /* Add to name_array a chdir request for the directory NAME */
276 name_add_dir (const char *name
)
280 ep
= &name_array
[entries
++];
281 ep
->type
= NELT_CHDIR
;
286 name_add_file (const char *name
, int term
)
290 ep
= &name_array
[entries
++];
291 ep
->type
= NELT_FILE
;
292 ep
->v
.file
.name
= name
;
293 ep
->v
.file
.term
= term
;
296 /* Names from external name file. */
298 static char *name_buffer
; /* buffer to hold the current file name */
299 static size_t name_buffer_length
; /* allocated length of name_buffer */
301 /* Set up to gather file names for tar. They can either come from a
302 file or were saved from decoding arguments. */
306 name_buffer
= xmalloc (NAME_FIELD_SIZE
+ 2);
307 name_buffer_length
= NAME_FIELD_SIZE
;
317 /* Prevent recursive inclusion of the same file */
320 struct file_id_list
*next
;
325 static struct file_id_list
*file_id_list
;
328 add_file_id (const char *filename
)
330 struct file_id_list
*p
;
333 if (stat (filename
, &st
))
334 stat_fatal (filename
);
335 for (p
= file_id_list
; p
; p
= p
->next
)
336 if (p
->ino
== st
.st_ino
&& p
->dev
== st
.st_dev
)
338 FATAL_ERROR ((0, 0, _("%s: file list already read"),
339 quotearg_colon (filename
)));
341 p
= xmalloc (sizeof *p
);
342 p
->next
= file_id_list
;
348 enum read_file_list_state
/* Result of reading file name from the list file */
350 file_list_success
, /* OK, name read successfully */
351 file_list_end
, /* End of list file */
352 file_list_zero
, /* Zero separator encountered where it should not */
353 file_list_skip
/* Empty (zero-length) entry encountered, skip it */
356 /* Read from FP a sequence of characters up to TERM and put them
359 static enum read_file_list_state
360 read_name_from_file (struct name_elt
*ent
)
364 FILE *fp
= ent
->v
.file
.fp
;
365 int term
= ent
->v
.file
.term
;
367 for (c
= getc (fp
); c
!= EOF
&& c
!= term
; c
= getc (fp
))
369 if (counter
== name_buffer_length
)
370 name_buffer
= x2realloc (name_buffer
, &name_buffer_length
);
371 name_buffer
[counter
++] = c
;
374 /* We have read a zero separator. The file possibly is
376 return file_list_zero
;
380 if (counter
== 0 && c
!= EOF
)
381 return file_list_skip
;
383 if (counter
== name_buffer_length
)
384 name_buffer
= x2realloc (name_buffer
, &name_buffer_length
);
385 name_buffer
[counter
] = 0;
387 return (counter
== 0 && c
== EOF
) ? file_list_end
: file_list_success
;
391 handle_option (const char *str
)
396 while (*str
&& isspace (*str
))
402 if (wordsplit (str
, &ws
, WRDSF_DEFFLAGS
|WRDSF_DOOFFS
))
403 FATAL_ERROR ((0, 0, _("cannot split string '%s': %s"),
404 str
, wordsplit_strerror (&ws
)));
405 ws
.ws_wordv
[0] = "tar";
406 more_options (ws
.ws_wordc
+ws
.ws_offs
, ws
.ws_wordv
);
407 for (i
= 0; i
< ws
.ws_wordc
+ws
.ws_offs
; i
++)
408 ws
.ws_wordv
[i
] = NULL
;
410 wordsplit_free (&ws
);
415 read_next_name (struct name_elt
*ent
, struct name_elt
*ret
)
417 enum read_file_list_state read_state
;
421 if (!strcmp (ent
->v
.file
.name
, "-"))
423 request_stdin ("-T");
424 ent
->v
.file
.fp
= stdin
;
428 add_file_id (ent
->v
.file
.name
);
429 if ((ent
->v
.file
.fp
= fopen (ent
->v
.file
.name
, "r")) == NULL
)
430 open_fatal (ent
->v
.file
.name
);
436 switch (read_name_from_file (ent
))
442 WARNOPT (WARN_FILENAME_WITH_NULS
,
443 (0, 0, N_("%s: file name read contains nul character"),
444 quotearg_colon (ent
->v
.file
.name
)));
445 ent
->v
.file
.term
= 0;
447 case file_list_success
:
448 if (handle_option (name_buffer
) == 0)
450 ret
->type
= NELT_NAME
;
451 ret
->v
.name
= name_buffer
;
455 if (strcmp (ent
->v
.file
.name
, "-"))
456 fclose (ent
->v
.file
.fp
);
457 ent
->v
.file
.fp
= NULL
;
464 copy_name (struct name_elt
*ep
)
471 source_len
= strlen (source
);
472 if (name_buffer_length
< source_len
)
476 name_buffer_length
*= 2;
477 if (! name_buffer_length
)
480 while (name_buffer_length
< source_len
);
483 name_buffer
= xmalloc(name_buffer_length
+ 2);
485 strcpy (name_buffer
, source
);
487 /* Zap trailing slashes. */
488 cursor
= name_buffer
+ strlen (name_buffer
) - 1;
489 while (cursor
> name_buffer
&& ISSLASH (*cursor
))
494 static int matching_flags
; /* exclude_fnmatch options */
496 /* Get the next NELT_NAME element from name_array. Result is in
497 static storage and can't be relied upon across two calls.
499 If CHANGE_DIRS is true, treat any entries of type NELT_CHDIR as
500 the request to change to the given directory.
502 Entries of type NELT_FMASK cause updates of the matching_flags
504 static struct name_elt
*
505 name_next_elt (int change_dirs
)
507 static struct name_elt entry
;
509 while (scanned
!= entries
)
513 ep
= &name_array
[scanned
];
514 if (ep
->type
== NELT_FMASK
)
516 matching_flags
= ep
->v
.matching_flags
;
524 if (read_next_name (ep
, &entry
) == 0)
534 if (chdir (name_buffer
) < 0)
535 chdir_fatal (name_buffer
);
543 unquote_string (name_buffer
);
544 entry
.type
= ep
->type
;
545 entry
.v
.name
= name_buffer
;
554 name_next (int change_dirs
)
556 struct name_elt
*nelt
= name_next_elt (change_dirs
);
557 return nelt
? nelt
->v
.name
: NULL
;
560 /* Gather names in a list for scanning. Could hash them later if we
563 If the names are already sorted to match the archive, we just read
564 them one by one. name_gather reads the first one, and it is called
565 by name_match as appropriate to read the next ones. At EOF, the
566 last name read is just left in the buffer. This option lets users
567 of small machines extract an arbitrary number of files by doing
568 "tar t" and editing down the list of files. */
573 /* Buffer able to hold a single name. */
574 static struct name
*buffer
= NULL
;
578 if (same_order_option
)
580 static int change_dir
;
582 while ((ep
= name_next_elt (0)) && ep
->type
== NELT_CHDIR
)
583 change_dir
= chdir_arg (xstrdup (ep
->v
.name
));
588 buffer
= make_name (ep
->v
.name
);
589 buffer
->change_dir
= change_dir
;
591 buffer
->found_count
= 0;
592 buffer
->matching_flags
= matching_flags
;
593 buffer
->directory
= NULL
;
594 buffer
->parent
= NULL
;
595 buffer
->cmdline
= true;
597 namelist
= nametail
= buffer
;
600 addname (0, change_dir
, false, NULL
);
604 /* Non sorted names -- read them all in. */
609 int change_dir0
= change_dir
;
610 while ((ep
= name_next_elt (0)) && ep
->type
== NELT_CHDIR
)
611 change_dir
= chdir_arg (xstrdup (ep
->v
.name
));
614 addname (ep
->v
.name
, change_dir
, true, NULL
);
617 if (change_dir
!= change_dir0
)
618 addname (NULL
, change_dir
, false, NULL
);
625 /* Add a name to the namelist. */
627 addname (char const *string
, int change_dir
, bool cmdline
, struct name
*parent
)
629 struct name
*name
= make_name (string
);
631 name
->prev
= nametail
;
633 name
->found_count
= 0;
634 name
->matching_flags
= matching_flags
;
635 name
->change_dir
= change_dir
;
636 name
->directory
= NULL
;
637 name
->parent
= parent
;
638 name
->cmdline
= cmdline
;
641 nametail
->next
= name
;
648 /* Find a match for FILE_NAME (whose string length is LENGTH) in the name
651 namelist_match (char const *file_name
, size_t length
)
655 for (p
= namelist
; p
; p
= p
->next
)
658 && exclude_fnmatch (p
->name
, file_name
, p
->matching_flags
))
666 remname (struct name
*name
)
670 if ((p
= name
->prev
) != NULL
)
671 p
->next
= name
->next
;
673 namelist
= name
->next
;
675 if ((p
= name
->next
) != NULL
)
676 p
->prev
= name
->prev
;
678 nametail
= name
->prev
;
681 /* Return true if and only if name FILE_NAME (from an archive) matches any
682 name from the namelist. */
684 name_match (const char *file_name
)
686 size_t length
= strlen (file_name
);
690 struct name
*cursor
= namelist
;
695 if (cursor
->name
[0] == 0)
697 chdir_do (cursor
->change_dir
);
703 cursor
= namelist_match (file_name
, length
);
706 if (!(ISSLASH (file_name
[cursor
->length
]) && recursion_option
)
707 || cursor
->found_count
== 0)
708 cursor
->found_count
++; /* remember it matched */
709 if (starting_file_option
)
715 chdir_do (cursor
->change_dir
);
717 /* We got a match. */
718 return ISFOUND (cursor
);
721 /* Filename from archive not found in namelist. If we have the whole
722 namelist here, just return 0. Otherwise, read the next name in and
723 compare it. If this was the last name, namelist->found_count will
724 remain on. If not, we loop to compare the newly read name. */
726 if (same_order_option
&& namelist
->found_count
)
728 name_gather (); /* read one more */
729 if (namelist
->found_count
)
737 /* Returns true if all names from the namelist were processed.
738 P is the stat_info of the most recently processed entry.
739 The decision is postponed until the next entry is read if:
741 1) P ended with a slash (i.e. it was a directory)
742 2) P matches any entry from the namelist *and* represents a subdirectory
743 or a file lying under this entry (in the terms of directory structure).
745 This is necessary to handle contents of directories. */
747 all_names_found (struct tar_stat_info
*p
)
749 struct name
const *cursor
;
752 if (!p
->file_name
|| occurrence_option
== 0 || p
->had_trailing_slash
)
754 len
= strlen (p
->file_name
);
755 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
757 if ((cursor
->name
[0] && !WASFOUND (cursor
))
758 || (len
>= cursor
->length
&& ISSLASH (p
->file_name
[cursor
->length
])))
765 regex_usage_warning (const char *name
)
767 static int warned_once
= 0;
769 if (warn_regex_usage
&& fnmatch_pattern_has_wildcards (name
, 0))
773 _("Pattern matching characters used in file names")));
775 _("Use --wildcards to enable pattern matching,"
776 " or --no-wildcards to suppress this warning")));
781 /* Print the names of things in the namelist that were not matched. */
783 names_notfound (void)
785 struct name
const *cursor
;
787 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
788 if (!WASFOUND (cursor
) && cursor
->name
[0])
790 regex_usage_warning (cursor
->name
);
792 (cursor
->found_count
== 0) ?
793 _("%s: Not found in archive") :
794 _("%s: Required occurrence not found in archive"),
795 quotearg_colon (cursor
->name
)));
798 /* Don't bother freeing the name list; we're about to exit. */
802 if (same_order_option
)
806 while ((name
= name_next (1)) != NULL
)
808 regex_usage_warning (name
);
809 ERROR ((0, 0, _("%s: Not found in archive"),
810 quotearg_colon (name
)));
816 label_notfound (void)
818 struct name
const *cursor
;
823 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
824 if (WASFOUND (cursor
))
828 error (0, 0, _("Archive label mismatch"));
829 set_exit_status (TAREXIT_DIFFERS
);
831 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
833 if (regex_usage_warning (cursor
->name
))
837 /* Don't bother freeing the name list; we're about to exit. */
841 if (same_order_option
)
845 while ((name
= name_next (1)) != NULL
846 && regex_usage_warning (name
) == 0)
851 /* Sorting name lists. */
853 /* Sort *singly* linked LIST of names, of given LENGTH, using COMPARE
854 to order names. Return the sorted list. Note that after calling
855 this function, the 'prev' links in list elements are messed up.
857 Apart from the type 'struct name' and the definition of SUCCESSOR,
858 this is a generic list-sorting function, but it's too painful to
859 make it both generic and portable
863 merge_sort_sll (struct name
*list
, int length
,
864 int (*compare
) (struct name
const*, struct name
const*))
866 struct name
*first_list
;
867 struct name
*second_list
;
871 struct name
**merge_point
;
875 # define SUCCESSOR(name) ((name)->next)
882 if ((*compare
) (list
, SUCCESSOR (list
)) > 0)
884 result
= SUCCESSOR (list
);
885 SUCCESSOR (result
) = list
;
886 SUCCESSOR (list
) = 0;
893 first_length
= (length
+ 1) / 2;
894 second_length
= length
/ 2;
895 for (cursor
= list
, counter
= first_length
- 1;
897 cursor
= SUCCESSOR (cursor
), counter
--)
899 second_list
= SUCCESSOR (cursor
);
900 SUCCESSOR (cursor
) = 0;
902 first_list
= merge_sort_sll (first_list
, first_length
, compare
);
903 second_list
= merge_sort_sll (second_list
, second_length
, compare
);
905 merge_point
= &result
;
906 while (first_list
&& second_list
)
907 if ((*compare
) (first_list
, second_list
) < 0)
909 cursor
= SUCCESSOR (first_list
);
910 *merge_point
= first_list
;
911 merge_point
= &SUCCESSOR (first_list
);
916 cursor
= SUCCESSOR (second_list
);
917 *merge_point
= second_list
;
918 merge_point
= &SUCCESSOR (second_list
);
919 second_list
= cursor
;
922 *merge_point
= first_list
;
924 *merge_point
= second_list
;
931 /* Sort doubly linked LIST of names, of given LENGTH, using COMPARE
932 to order names. Return the sorted list. */
934 merge_sort (struct name
*list
, int length
,
935 int (*compare
) (struct name
const*, struct name
const*))
937 struct name
*head
, *p
, *prev
;
938 head
= merge_sort_sll (list
, length
, compare
);
939 /* Fixup prev pointers */
940 for (prev
= NULL
, p
= head
; p
; prev
= p
, p
= p
->next
)
945 /* A comparison function for sorting names. Put found names last;
946 break ties by string comparison. */
949 compare_names_found (struct name
const *n1
, struct name
const *n2
)
951 int found_diff
= WASFOUND (n2
) - WASFOUND (n1
);
952 return found_diff
? found_diff
: strcmp (n1
->name
, n2
->name
);
955 /* Simple comparison by names. */
957 compare_names (struct name
const *n1
, struct name
const *n2
)
959 return strcmp (n1
->name
, n2
->name
);
963 /* Add all the dirs under ST to the namelist NAME, descending the
964 directory hierarchy recursively. */
967 add_hierarchy_to_namelist (struct tar_stat_info
*st
, struct name
*name
)
971 name
->directory
= scan_directory (st
);
972 buffer
= directory_contents (name
->directory
);
975 struct name
*child_head
= NULL
, *child_tail
= NULL
;
976 size_t name_length
= name
->length
;
977 size_t allocated_length
= (name_length
>= NAME_FIELD_SIZE
978 ? name_length
+ NAME_FIELD_SIZE
980 char *namebuf
= xmalloc (allocated_length
+ 1);
981 /* FIXME: + 2 above? */
983 size_t string_length
;
984 int change_dir
= name
->change_dir
;
986 strcpy (namebuf
, name
->name
);
987 if (! ISSLASH (namebuf
[name_length
- 1]))
989 namebuf
[name_length
++] = '/';
990 namebuf
[name_length
] = '\0';
993 for (string
= buffer
; *string
; string
+= string_length
+ 1)
995 string_length
= strlen (string
);
999 struct tar_stat_info subdir
;
1002 if (allocated_length
<= name_length
+ string_length
)
1006 allocated_length
*= 2;
1007 if (! allocated_length
)
1010 while (allocated_length
<= name_length
+ string_length
);
1012 namebuf
= xrealloc (namebuf
, allocated_length
+ 1);
1014 strcpy (namebuf
+ name_length
, string
+ 1);
1015 np
= addname (namebuf
, change_dir
, false, name
);
1019 child_tail
->sibling
= np
;
1022 tar_stat_init (&subdir
);
1030 subfd
= subfile_open (st
, string
+ 1,
1031 open_read_flags
| O_DIRECTORY
);
1033 open_diag (namebuf
);
1037 if (fstat (subfd
, &subdir
.stat
) != 0)
1038 stat_diag (namebuf
);
1039 else if (! (O_DIRECTORY
|| S_ISDIR (subdir
.stat
.st_mode
)))
1042 open_diag (namebuf
);
1046 subdir
.orig_file_name
= xstrdup (namebuf
);
1047 add_hierarchy_to_namelist (&subdir
, np
);
1048 restore_parent_fd (&subdir
);
1052 tar_stat_destroy (&subdir
);
1057 name
->child
= child_head
;
1061 /* Auxiliary functions for hashed table of struct name's. */
1064 name_hash (void const *entry
, size_t n_buckets
)
1066 struct name
const *name
= entry
;
1067 return hash_string (name
->caname
, n_buckets
);
1070 /* Compare two directories for equality of their names. */
1072 name_compare (void const *entry1
, void const *entry2
)
1074 struct name
const *name1
= entry1
;
1075 struct name
const *name2
= entry2
;
1076 return strcmp (name1
->caname
, name2
->caname
) == 0;
1080 /* Rebase 'name' member of CHILD and all its siblings to
1083 rebase_child_list (struct name
*child
, struct name
*parent
)
1085 size_t old_prefix_len
= child
->parent
->length
;
1086 size_t new_prefix_len
= parent
->length
;
1087 char *new_prefix
= parent
->name
;
1089 for (; child
; child
= child
->sibling
)
1091 size_t size
= child
->length
- old_prefix_len
+ new_prefix_len
;
1092 char *newp
= xmalloc (size
+ 1);
1093 strcpy (newp
, new_prefix
);
1094 strcat (newp
, child
->name
+ old_prefix_len
);
1097 child
->length
= size
;
1099 rebase_directory (child
->directory
,
1100 child
->parent
->name
, old_prefix_len
,
1101 new_prefix
, new_prefix_len
);
1105 /* Collect all the names from argv[] (or whatever), expand them into a
1106 directory tree, and sort them. This gets only subdirectories, not
1110 collect_and_sort_names (void)
1113 struct name
*next_name
, *prev_name
= NULL
;
1115 Hash_table
*nametab
;
1120 addname (".", 0, false, NULL
);
1122 if (listed_incremental_option
)
1124 switch (chdir_count ())
1130 if (namelist
->change_dir
== 0)
1132 _("Using -C option inside file list is not "
1133 "allowed with --listed-incremental")));
1138 _("Only one -C option is allowed with "
1139 "--listed-incremental")));
1142 read_directory_file ();
1146 for (name
= namelist
; name
; name
= name
->next
, num_names
++)
1148 struct tar_stat_info st
;
1150 if (name
->found_count
|| name
->directory
)
1152 if (name
->matching_flags
& EXCLUDE_WILDCARDS
)
1153 /* NOTE: EXCLUDE_ANCHORED is not relevant here */
1154 /* FIXME: just skip regexps for now */
1156 chdir_do (name
->change_dir
);
1158 if (name
->name
[0] == 0)
1161 tar_stat_init (&st
);
1163 if (deref_stat (name
->name
, &st
.stat
) != 0)
1165 stat_diag (name
->name
);
1168 if (S_ISDIR (st
.stat
.st_mode
))
1170 int dir_fd
= openat (chdir_fd
, name
->name
,
1171 open_read_flags
| O_DIRECTORY
);
1173 open_diag (name
->name
);
1177 if (fstat (dir_fd
, &st
.stat
) != 0)
1178 stat_diag (name
->name
);
1179 else if (O_DIRECTORY
|| S_ISDIR (st
.stat
.st_mode
))
1181 st
.orig_file_name
= xstrdup (name
->name
);
1182 name
->found_count
++;
1183 add_hierarchy_to_namelist (&st
, name
);
1188 tar_stat_destroy (&st
);
1191 namelist
= merge_sort (namelist
, num_names
, compare_names
);
1194 nametab
= hash_initialize (0, 0,
1196 name_compare
, NULL
);
1197 for (name
= namelist
; name
; name
= next_name
)
1199 next_name
= name
->next
;
1200 name
->caname
= normalize_filename (name
->name
);
1203 struct name
*p
= hash_lookup (nametab
, name
);
1206 /* Keep the one listed in the command line */
1210 rebase_child_list (p
->child
, name
);
1211 hash_delete (nametab
, name
);
1212 /* FIXME: remove_directory (p->caname); ? */
1220 rebase_child_list (name
->child
, p
);
1221 /* FIXME: remove_directory (name->caname); ? */
1228 name
->found_count
= 0;
1229 if (!hash_insert (nametab
, name
))
1234 nametail
= prev_name
;
1235 hash_free (nametab
);
1237 namelist
= merge_sort (namelist
, num_names
, compare_names_found
);
1239 if (listed_incremental_option
)
1241 for (name
= namelist
; name
&& name
->name
[0] == 0; name
++)
1244 append_incremental_renames (name
->directory
);
1248 /* This is like name_match, except that
1249 1. It returns a pointer to the name it matched, and doesn't set FOUND
1250 in structure. The caller will have to do that if it wants to.
1251 2. If the namelist is empty, it returns null, unlike name_match, which
1254 name_scan (const char *file_name
)
1256 size_t length
= strlen (file_name
);
1260 struct name
*cursor
= namelist_match (file_name
, length
);
1264 /* Filename from archive not found in namelist. If we have the whole
1265 namelist here, just return 0. Otherwise, read the next name in and
1266 compare it. If this was the last name, namelist->found_count will
1267 remain on. If not, we loop to compare the newly read name. */
1269 if (same_order_option
&& namelist
&& namelist
->found_count
)
1271 name_gather (); /* read one more */
1272 if (namelist
->found_count
)
1280 /* This returns a name from the namelist which doesn't have ->found
1281 set. It sets ->found before returning, so successive calls will
1282 find and return all the non-found names in the namelist. */
1283 struct name
*gnu_list_name
;
1286 name_from_list (void)
1289 gnu_list_name
= namelist
;
1290 while (gnu_list_name
1291 && (gnu_list_name
->found_count
|| gnu_list_name
->name
[0] == 0))
1292 gnu_list_name
= gnu_list_name
->next
;
1295 gnu_list_name
->found_count
++;
1296 chdir_do (gnu_list_name
->change_dir
);
1297 return gnu_list_name
;
1303 blank_name_list (void)
1308 for (name
= namelist
; name
; name
= name
->next
)
1309 name
->found_count
= 0;
1312 /* Yield a newly allocated file name consisting of FILE_NAME concatenated to
1313 NAME, with an intervening slash if FILE_NAME does not already end in one. */
1315 new_name (const char *file_name
, const char *name
)
1317 size_t file_name_len
= strlen (file_name
);
1318 size_t namesize
= strlen (name
) + 1;
1319 int slash
= file_name_len
&& ! ISSLASH (file_name
[file_name_len
- 1]);
1320 char *buffer
= xmalloc (file_name_len
+ slash
+ namesize
);
1321 memcpy (buffer
, file_name
, file_name_len
);
1322 buffer
[file_name_len
] = '/';
1323 memcpy (buffer
+ file_name_len
+ slash
, name
, namesize
);
1327 /* Return nonzero if file NAME is excluded. */
1329 excluded_name (char const *name
)
1331 return excluded_file_name (excluded
, name
+ FILE_SYSTEM_PREFIX_LEN (name
));
1335 /* Return the size of the prefix of FILE_NAME that is removed after
1336 stripping NUM leading file name components. NUM must be
1340 stripped_prefix_len (char const *file_name
, size_t num
)
1342 char const *p
= file_name
+ FILE_SYSTEM_PREFIX_LEN (file_name
);
1343 while (ISSLASH (*p
))
1347 bool slash
= ISSLASH (*p
);
1352 return p
- file_name
;
1353 while (ISSLASH (*p
))
1360 /* Return nonzero if NAME contains ".." as a file name component. */
1362 contains_dot_dot (char const *name
)
1364 char const *p
= name
+ FILE_SYSTEM_PREFIX_LEN (name
);
1368 if (p
[0] == '.' && p
[1] == '.' && (ISSLASH (p
[2]) || !p
[2]))
1371 while (! ISSLASH (*p
))