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
;
294 ep
->v
.file
.fp
= NULL
;
297 /* Names from external name file. */
299 static char *name_buffer
; /* buffer to hold the current file name */
300 static size_t name_buffer_length
; /* allocated length of name_buffer */
302 /* Set up to gather file names for tar. They can either come from a
303 file or were saved from decoding arguments. */
307 name_buffer
= xmalloc (NAME_FIELD_SIZE
+ 2);
308 name_buffer_length
= NAME_FIELD_SIZE
;
318 /* Prevent recursive inclusion of the same file */
321 struct file_id_list
*next
;
326 static struct file_id_list
*file_id_list
;
329 add_file_id (const char *filename
)
331 struct file_id_list
*p
;
334 if (stat (filename
, &st
))
335 stat_fatal (filename
);
336 for (p
= file_id_list
; p
; p
= p
->next
)
337 if (p
->ino
== st
.st_ino
&& p
->dev
== st
.st_dev
)
339 ERROR ((0, 0, _("%s: file list already read"),
340 quotearg_colon (filename
)));
343 p
= xmalloc (sizeof *p
);
344 p
->next
= file_id_list
;
351 enum read_file_list_state
/* Result of reading file name from the list file */
353 file_list_success
, /* OK, name read successfully */
354 file_list_end
, /* End of list file */
355 file_list_zero
, /* Zero separator encountered where it should not */
356 file_list_skip
/* Empty (zero-length) entry encountered, skip it */
359 /* Read from FP a sequence of characters up to TERM and put them
362 static enum read_file_list_state
363 read_name_from_file (struct name_elt
*ent
)
367 FILE *fp
= ent
->v
.file
.fp
;
368 int term
= ent
->v
.file
.term
;
370 for (c
= getc (fp
); c
!= EOF
&& c
!= term
; c
= getc (fp
))
372 if (counter
== name_buffer_length
)
373 name_buffer
= x2realloc (name_buffer
, &name_buffer_length
);
374 name_buffer
[counter
++] = c
;
377 /* We have read a zero separator. The file possibly is
379 return file_list_zero
;
383 if (counter
== 0 && c
!= EOF
)
384 return file_list_skip
;
386 if (counter
== name_buffer_length
)
387 name_buffer
= x2realloc (name_buffer
, &name_buffer_length
);
388 name_buffer
[counter
] = 0;
390 return (counter
== 0 && c
== EOF
) ? file_list_end
: file_list_success
;
394 handle_option (const char *str
)
399 while (*str
&& isspace (*str
))
405 if (wordsplit (str
, &ws
, WRDSF_DEFFLAGS
|WRDSF_DOOFFS
))
406 FATAL_ERROR ((0, 0, _("cannot split string '%s': %s"),
407 str
, wordsplit_strerror (&ws
)));
408 ws
.ws_wordv
[0] = program_invocation_short_name
;
409 more_options (ws
.ws_wordc
+ws
.ws_offs
, ws
.ws_wordv
);
410 for (i
= 0; i
< ws
.ws_wordc
+ws
.ws_offs
; i
++)
411 ws
.ws_wordv
[i
] = NULL
;
413 wordsplit_free (&ws
);
418 read_next_name (struct name_elt
*ent
, struct name_elt
*ret
)
422 if (!strcmp (ent
->v
.file
.name
, "-"))
424 request_stdin ("-T");
425 ent
->v
.file
.fp
= stdin
;
429 if (add_file_id (ent
->v
.file
.name
))
431 if ((ent
->v
.file
.fp
= fopen (ent
->v
.file
.name
, "r")) == NULL
)
432 open_fatal (ent
->v
.file
.name
);
438 switch (read_name_from_file (ent
))
444 WARNOPT (WARN_FILENAME_WITH_NULS
,
445 (0, 0, N_("%s: file name read contains nul character"),
446 quotearg_colon (ent
->v
.file
.name
)));
447 ent
->v
.file
.term
= 0;
449 case file_list_success
:
450 if (handle_option (name_buffer
) == 0)
452 ret
->type
= NELT_NAME
;
453 ret
->v
.name
= name_buffer
;
457 if (strcmp (ent
->v
.file
.name
, "-"))
458 fclose (ent
->v
.file
.fp
);
459 ent
->v
.file
.fp
= NULL
;
466 copy_name (struct name_elt
*ep
)
473 source_len
= strlen (source
);
474 if (name_buffer_length
< source_len
)
478 name_buffer_length
*= 2;
479 if (! name_buffer_length
)
482 while (name_buffer_length
< source_len
);
485 name_buffer
= xmalloc(name_buffer_length
+ 2);
487 strcpy (name_buffer
, source
);
489 /* Zap trailing slashes. */
490 cursor
= name_buffer
+ strlen (name_buffer
) - 1;
491 while (cursor
> name_buffer
&& ISSLASH (*cursor
))
496 static int matching_flags
; /* exclude_fnmatch options */
498 /* Get the next NELT_NAME element from name_array. Result is in
499 static storage and can't be relied upon across two calls.
501 If CHANGE_DIRS is true, treat any entries of type NELT_CHDIR as
502 the request to change to the given directory.
504 Entries of type NELT_FMASK cause updates of the matching_flags
506 static struct name_elt
*
507 name_next_elt (int change_dirs
)
509 static struct name_elt entry
;
511 while (scanned
!= entries
)
515 ep
= &name_array
[scanned
];
520 matching_flags
= ep
->v
.matching_flags
;
525 if (read_next_name (ep
, &entry
) == 0)
535 if (chdir (name_buffer
) < 0)
536 chdir_fatal (name_buffer
);
544 unquote_string (name_buffer
);
545 entry
.type
= ep
->type
;
546 entry
.v
.name
= name_buffer
;
555 name_next (int change_dirs
)
557 struct name_elt
*nelt
= name_next_elt (change_dirs
);
558 return nelt
? nelt
->v
.name
: NULL
;
561 /* Gather names in a list for scanning. Could hash them later if we
564 If the names are already sorted to match the archive, we just read
565 them one by one. name_gather reads the first one, and it is called
566 by name_match as appropriate to read the next ones. At EOF, the
567 last name read is just left in the buffer. This option lets users
568 of small machines extract an arbitrary number of files by doing
569 "tar t" and editing down the list of files. */
574 /* Buffer able to hold a single name. */
575 static struct name
*buffer
= NULL
;
579 if (same_order_option
)
581 static int change_dir
;
583 while ((ep
= name_next_elt (0)) && ep
->type
== NELT_CHDIR
)
584 change_dir
= chdir_arg (xstrdup (ep
->v
.name
));
589 buffer
= make_name (ep
->v
.name
);
590 buffer
->change_dir
= change_dir
;
592 buffer
->found_count
= 0;
593 buffer
->matching_flags
= matching_flags
;
594 buffer
->directory
= NULL
;
595 buffer
->parent
= NULL
;
596 buffer
->cmdline
= true;
598 namelist
= nametail
= buffer
;
601 addname (0, change_dir
, false, NULL
);
605 /* Non sorted names -- read them all in. */
610 int change_dir0
= change_dir
;
611 while ((ep
= name_next_elt (0)) && ep
->type
== NELT_CHDIR
)
612 change_dir
= chdir_arg (xstrdup (ep
->v
.name
));
615 addname (ep
->v
.name
, change_dir
, true, NULL
);
618 if (change_dir
!= change_dir0
)
619 addname (NULL
, change_dir
, false, NULL
);
626 /* Add a name to the namelist. */
628 addname (char const *string
, int change_dir
, bool cmdline
, struct name
*parent
)
630 struct name
*name
= make_name (string
);
632 name
->prev
= nametail
;
634 name
->found_count
= 0;
635 name
->matching_flags
= matching_flags
;
636 name
->change_dir
= change_dir
;
637 name
->directory
= NULL
;
638 name
->parent
= parent
;
639 name
->cmdline
= cmdline
;
642 nametail
->next
= name
;
649 /* Find a match for FILE_NAME (whose string length is LENGTH) in the name
652 namelist_match (char const *file_name
, size_t length
)
656 for (p
= namelist
; p
; p
= p
->next
)
659 && exclude_fnmatch (p
->name
, file_name
, p
->matching_flags
))
667 remname (struct name
*name
)
671 if ((p
= name
->prev
) != NULL
)
672 p
->next
= name
->next
;
674 namelist
= name
->next
;
676 if ((p
= name
->next
) != NULL
)
677 p
->prev
= name
->prev
;
679 nametail
= name
->prev
;
682 /* Return true if and only if name FILE_NAME (from an archive) matches any
683 name from the namelist. */
685 name_match (const char *file_name
)
687 size_t length
= strlen (file_name
);
691 struct name
*cursor
= namelist
;
696 if (cursor
->name
[0] == 0)
698 chdir_do (cursor
->change_dir
);
704 cursor
= namelist_match (file_name
, length
);
707 if (!(ISSLASH (file_name
[cursor
->length
]) && recursion_option
)
708 || cursor
->found_count
== 0)
709 cursor
->found_count
++; /* remember it matched */
710 if (starting_file_option
)
716 chdir_do (cursor
->change_dir
);
718 /* We got a match. */
719 return ISFOUND (cursor
);
722 /* Filename from archive not found in namelist. If we have the whole
723 namelist here, just return 0. Otherwise, read the next name in and
724 compare it. If this was the last name, namelist->found_count will
725 remain on. If not, we loop to compare the newly read name. */
727 if (same_order_option
&& namelist
->found_count
)
729 name_gather (); /* read one more */
730 if (namelist
->found_count
)
738 /* Returns true if all names from the namelist were processed.
739 P is the stat_info of the most recently processed entry.
740 The decision is postponed until the next entry is read if:
742 1) P ended with a slash (i.e. it was a directory)
743 2) P matches any entry from the namelist *and* represents a subdirectory
744 or a file lying under this entry (in the terms of directory structure).
746 This is necessary to handle contents of directories. */
748 all_names_found (struct tar_stat_info
*p
)
750 struct name
const *cursor
;
753 if (!p
->file_name
|| occurrence_option
== 0 || p
->had_trailing_slash
)
755 len
= strlen (p
->file_name
);
756 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
758 if ((cursor
->name
[0] && !WASFOUND (cursor
))
759 || (len
>= cursor
->length
&& ISSLASH (p
->file_name
[cursor
->length
])))
766 regex_usage_warning (const char *name
)
768 static int warned_once
= 0;
770 if (warn_regex_usage
&& fnmatch_pattern_has_wildcards (name
, 0))
774 _("Pattern matching characters used in file names")));
776 _("Use --wildcards to enable pattern matching,"
777 " or --no-wildcards to suppress this warning")));
782 /* Print the names of things in the namelist that were not matched. */
784 names_notfound (void)
786 struct name
const *cursor
;
788 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
789 if (!WASFOUND (cursor
) && cursor
->name
[0])
791 regex_usage_warning (cursor
->name
);
793 (cursor
->found_count
== 0) ?
794 _("%s: Not found in archive") :
795 _("%s: Required occurrence not found in archive"),
796 quotearg_colon (cursor
->name
)));
799 /* Don't bother freeing the name list; we're about to exit. */
803 if (same_order_option
)
807 while ((name
= name_next (1)) != NULL
)
809 regex_usage_warning (name
);
810 ERROR ((0, 0, _("%s: Not found in archive"),
811 quotearg_colon (name
)));
817 label_notfound (void)
819 struct name
const *cursor
;
824 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
825 if (WASFOUND (cursor
))
829 error (0, 0, _("Archive label mismatch"));
830 set_exit_status (TAREXIT_DIFFERS
);
832 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
834 if (regex_usage_warning (cursor
->name
))
838 /* Don't bother freeing the name list; we're about to exit. */
842 if (same_order_option
)
846 while ((name
= name_next (1)) != NULL
847 && regex_usage_warning (name
) == 0)
852 /* Sorting name lists. */
854 /* Sort *singly* linked LIST of names, of given LENGTH, using COMPARE
855 to order names. Return the sorted list. Note that after calling
856 this function, the 'prev' links in list elements are messed up.
858 Apart from the type 'struct name' and the definition of SUCCESSOR,
859 this is a generic list-sorting function, but it's too painful to
860 make it both generic and portable
864 merge_sort_sll (struct name
*list
, int length
,
865 int (*compare
) (struct name
const*, struct name
const*))
867 struct name
*first_list
;
868 struct name
*second_list
;
872 struct name
**merge_point
;
876 # define SUCCESSOR(name) ((name)->next)
883 if ((*compare
) (list
, SUCCESSOR (list
)) > 0)
885 result
= SUCCESSOR (list
);
886 SUCCESSOR (result
) = list
;
887 SUCCESSOR (list
) = 0;
894 first_length
= (length
+ 1) / 2;
895 second_length
= length
/ 2;
896 for (cursor
= list
, counter
= first_length
- 1;
898 cursor
= SUCCESSOR (cursor
), counter
--)
900 second_list
= SUCCESSOR (cursor
);
901 SUCCESSOR (cursor
) = 0;
903 first_list
= merge_sort_sll (first_list
, first_length
, compare
);
904 second_list
= merge_sort_sll (second_list
, second_length
, compare
);
906 merge_point
= &result
;
907 while (first_list
&& second_list
)
908 if ((*compare
) (first_list
, second_list
) < 0)
910 cursor
= SUCCESSOR (first_list
);
911 *merge_point
= first_list
;
912 merge_point
= &SUCCESSOR (first_list
);
917 cursor
= SUCCESSOR (second_list
);
918 *merge_point
= second_list
;
919 merge_point
= &SUCCESSOR (second_list
);
920 second_list
= cursor
;
923 *merge_point
= first_list
;
925 *merge_point
= second_list
;
932 /* Sort doubly linked LIST of names, of given LENGTH, using COMPARE
933 to order names. Return the sorted list. */
935 merge_sort (struct name
*list
, int length
,
936 int (*compare
) (struct name
const*, struct name
const*))
938 struct name
*head
, *p
, *prev
;
939 head
= merge_sort_sll (list
, length
, compare
);
940 /* Fixup prev pointers */
941 for (prev
= NULL
, p
= head
; p
; prev
= p
, p
= p
->next
)
946 /* A comparison function for sorting names. Put found names last;
947 break ties by string comparison. */
950 compare_names_found (struct name
const *n1
, struct name
const *n2
)
952 int found_diff
= WASFOUND (n2
) - WASFOUND (n1
);
953 return found_diff
? found_diff
: strcmp (n1
->name
, n2
->name
);
956 /* Simple comparison by names. */
958 compare_names (struct name
const *n1
, struct name
const *n2
)
960 return strcmp (n1
->name
, n2
->name
);
964 /* Add all the dirs under ST to the namelist NAME, descending the
965 directory hierarchy recursively. */
968 add_hierarchy_to_namelist (struct tar_stat_info
*st
, struct name
*name
)
972 name
->directory
= scan_directory (st
);
973 buffer
= directory_contents (name
->directory
);
976 struct name
*child_head
= NULL
, *child_tail
= NULL
;
977 size_t name_length
= name
->length
;
978 size_t allocated_length
= (name_length
>= NAME_FIELD_SIZE
979 ? name_length
+ NAME_FIELD_SIZE
981 char *namebuf
= xmalloc (allocated_length
+ 1);
982 /* FIXME: + 2 above? */
984 size_t string_length
;
985 int change_dir
= name
->change_dir
;
987 strcpy (namebuf
, name
->name
);
988 if (! ISSLASH (namebuf
[name_length
- 1]))
990 namebuf
[name_length
++] = '/';
991 namebuf
[name_length
] = '\0';
994 for (string
= buffer
; *string
; string
+= string_length
+ 1)
996 string_length
= strlen (string
);
1000 struct tar_stat_info subdir
;
1003 if (allocated_length
<= name_length
+ string_length
)
1007 allocated_length
*= 2;
1008 if (! allocated_length
)
1011 while (allocated_length
<= name_length
+ string_length
);
1013 namebuf
= xrealloc (namebuf
, allocated_length
+ 1);
1015 strcpy (namebuf
+ name_length
, string
+ 1);
1016 np
= addname (namebuf
, change_dir
, false, name
);
1020 child_tail
->sibling
= np
;
1023 tar_stat_init (&subdir
);
1031 subfd
= subfile_open (st
, string
+ 1,
1032 open_read_flags
| O_DIRECTORY
);
1034 open_diag (namebuf
);
1038 if (fstat (subfd
, &subdir
.stat
) != 0)
1039 stat_diag (namebuf
);
1040 else if (! (O_DIRECTORY
|| S_ISDIR (subdir
.stat
.st_mode
)))
1043 open_diag (namebuf
);
1047 subdir
.orig_file_name
= xstrdup (namebuf
);
1048 add_hierarchy_to_namelist (&subdir
, np
);
1049 restore_parent_fd (&subdir
);
1053 tar_stat_destroy (&subdir
);
1058 name
->child
= child_head
;
1062 /* Auxiliary functions for hashed table of struct name's. */
1065 name_hash (void const *entry
, size_t n_buckets
)
1067 struct name
const *name
= entry
;
1068 return hash_string (name
->caname
, n_buckets
);
1071 /* Compare two directories for equality of their names. */
1073 name_compare (void const *entry1
, void const *entry2
)
1075 struct name
const *name1
= entry1
;
1076 struct name
const *name2
= entry2
;
1077 return strcmp (name1
->caname
, name2
->caname
) == 0;
1081 /* Rebase 'name' member of CHILD and all its siblings to
1084 rebase_child_list (struct name
*child
, struct name
*parent
)
1086 size_t old_prefix_len
= child
->parent
->length
;
1087 size_t new_prefix_len
= parent
->length
;
1088 char *new_prefix
= parent
->name
;
1090 for (; child
; child
= child
->sibling
)
1092 size_t size
= child
->length
- old_prefix_len
+ new_prefix_len
;
1093 char *newp
= xmalloc (size
+ 1);
1094 strcpy (newp
, new_prefix
);
1095 strcat (newp
, child
->name
+ old_prefix_len
);
1098 child
->length
= size
;
1100 rebase_directory (child
->directory
,
1101 child
->parent
->name
, old_prefix_len
,
1102 new_prefix
, new_prefix_len
);
1106 /* Collect all the names from argv[] (or whatever), expand them into a
1107 directory tree, and sort them. This gets only subdirectories, not
1111 collect_and_sort_names (void)
1114 struct name
*next_name
, *prev_name
= NULL
;
1116 Hash_table
*nametab
;
1121 addname (".", 0, false, NULL
);
1123 if (listed_incremental_option
)
1125 switch (chdir_count ())
1131 if (namelist
->change_dir
== 0)
1133 _("Using -C option inside file list is not "
1134 "allowed with --listed-incremental")));
1139 _("Only one -C option is allowed with "
1140 "--listed-incremental")));
1143 read_directory_file ();
1147 for (name
= namelist
; name
; name
= name
->next
, num_names
++)
1149 struct tar_stat_info st
;
1151 if (name
->found_count
|| name
->directory
)
1153 if (name
->matching_flags
& EXCLUDE_WILDCARDS
)
1154 /* NOTE: EXCLUDE_ANCHORED is not relevant here */
1155 /* FIXME: just skip regexps for now */
1157 chdir_do (name
->change_dir
);
1159 if (name
->name
[0] == 0)
1162 tar_stat_init (&st
);
1164 if (deref_stat (name
->name
, &st
.stat
) != 0)
1166 stat_diag (name
->name
);
1169 if (S_ISDIR (st
.stat
.st_mode
))
1171 int dir_fd
= openat (chdir_fd
, name
->name
,
1172 open_read_flags
| O_DIRECTORY
);
1174 open_diag (name
->name
);
1178 if (fstat (dir_fd
, &st
.stat
) != 0)
1179 stat_diag (name
->name
);
1180 else if (O_DIRECTORY
|| S_ISDIR (st
.stat
.st_mode
))
1182 st
.orig_file_name
= xstrdup (name
->name
);
1183 name
->found_count
++;
1184 add_hierarchy_to_namelist (&st
, name
);
1189 tar_stat_destroy (&st
);
1192 namelist
= merge_sort (namelist
, num_names
, compare_names
);
1195 nametab
= hash_initialize (0, 0,
1197 name_compare
, NULL
);
1198 for (name
= namelist
; name
; name
= next_name
)
1200 next_name
= name
->next
;
1201 name
->caname
= normalize_filename (name
->name
);
1204 struct name
*p
= hash_lookup (nametab
, name
);
1207 /* Keep the one listed in the command line */
1211 rebase_child_list (p
->child
, name
);
1212 hash_delete (nametab
, name
);
1213 /* FIXME: remove_directory (p->caname); ? */
1221 rebase_child_list (name
->child
, p
);
1222 /* FIXME: remove_directory (name->caname); ? */
1229 name
->found_count
= 0;
1230 if (!hash_insert (nametab
, name
))
1235 nametail
= prev_name
;
1236 hash_free (nametab
);
1238 namelist
= merge_sort (namelist
, num_names
, compare_names_found
);
1240 if (listed_incremental_option
)
1242 for (name
= namelist
; name
&& name
->name
[0] == 0; name
++)
1245 append_incremental_renames (name
->directory
);
1249 /* This is like name_match, except that
1250 1. It returns a pointer to the name it matched, and doesn't set FOUND
1251 in structure. The caller will have to do that if it wants to.
1252 2. If the namelist is empty, it returns null, unlike name_match, which
1255 name_scan (const char *file_name
)
1257 size_t length
= strlen (file_name
);
1261 struct name
*cursor
= namelist_match (file_name
, length
);
1265 /* Filename from archive not found in namelist. If we have the whole
1266 namelist here, just return 0. Otherwise, read the next name in and
1267 compare it. If this was the last name, namelist->found_count will
1268 remain on. If not, we loop to compare the newly read name. */
1270 if (same_order_option
&& namelist
&& namelist
->found_count
)
1272 name_gather (); /* read one more */
1273 if (namelist
->found_count
)
1281 /* This returns a name from the namelist which doesn't have ->found
1282 set. It sets ->found before returning, so successive calls will
1283 find and return all the non-found names in the namelist. */
1284 struct name
*gnu_list_name
;
1287 name_from_list (void)
1290 gnu_list_name
= namelist
;
1291 while (gnu_list_name
1292 && (gnu_list_name
->found_count
|| gnu_list_name
->name
[0] == 0))
1293 gnu_list_name
= gnu_list_name
->next
;
1296 gnu_list_name
->found_count
++;
1297 chdir_do (gnu_list_name
->change_dir
);
1298 return gnu_list_name
;
1304 blank_name_list (void)
1309 for (name
= namelist
; name
; name
= name
->next
)
1310 name
->found_count
= 0;
1313 /* Yield a newly allocated file name consisting of FILE_NAME concatenated to
1314 NAME, with an intervening slash if FILE_NAME does not already end in one. */
1316 new_name (const char *file_name
, const char *name
)
1318 size_t file_name_len
= strlen (file_name
);
1319 size_t namesize
= strlen (name
) + 1;
1320 int slash
= file_name_len
&& ! ISSLASH (file_name
[file_name_len
- 1]);
1321 char *buffer
= xmalloc (file_name_len
+ slash
+ namesize
);
1322 memcpy (buffer
, file_name
, file_name_len
);
1323 buffer
[file_name_len
] = '/';
1324 memcpy (buffer
+ file_name_len
+ slash
, name
, namesize
);
1328 /* Return nonzero if file NAME is excluded. */
1330 excluded_name (char const *name
)
1332 return excluded_file_name (excluded
, name
+ FILE_SYSTEM_PREFIX_LEN (name
));
1336 /* Return the size of the prefix of FILE_NAME that is removed after
1337 stripping NUM leading file name components. NUM must be
1341 stripped_prefix_len (char const *file_name
, size_t num
)
1343 char const *p
= file_name
+ FILE_SYSTEM_PREFIX_LEN (file_name
);
1344 while (ISSLASH (*p
))
1348 bool slash
= ISSLASH (*p
);
1353 return p
- file_name
;
1354 while (ISSLASH (*p
))
1361 /* Return nonzero if NAME contains ".." as a file name component. */
1363 contains_dot_dot (char const *name
)
1365 char const *p
= name
+ FILE_SYSTEM_PREFIX_LEN (name
);
1369 if (p
[0] == '.' && p
[1] == '.' && (ISSLASH (p
[2]) || !p
[2]))
1372 while (! ISSLASH (*p
))