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 FATAL_ERROR ((0, 0, _("%s: file list already read"),
340 quotearg_colon (filename
)));
342 p
= xmalloc (sizeof *p
);
343 p
->next
= file_id_list
;
349 enum read_file_list_state
/* Result of reading file name from the list file */
351 file_list_success
, /* OK, name read successfully */
352 file_list_end
, /* End of list file */
353 file_list_zero
, /* Zero separator encountered where it should not */
354 file_list_skip
/* Empty (zero-length) entry encountered, skip it */
357 /* Read from FP a sequence of characters up to TERM and put them
360 static enum read_file_list_state
361 read_name_from_file (struct name_elt
*ent
)
365 FILE *fp
= ent
->v
.file
.fp
;
366 int term
= ent
->v
.file
.term
;
368 for (c
= getc (fp
); c
!= EOF
&& c
!= term
; c
= getc (fp
))
370 if (counter
== name_buffer_length
)
371 name_buffer
= x2realloc (name_buffer
, &name_buffer_length
);
372 name_buffer
[counter
++] = c
;
375 /* We have read a zero separator. The file possibly is
377 return file_list_zero
;
381 if (counter
== 0 && c
!= EOF
)
382 return file_list_skip
;
384 if (counter
== name_buffer_length
)
385 name_buffer
= x2realloc (name_buffer
, &name_buffer_length
);
386 name_buffer
[counter
] = 0;
388 return (counter
== 0 && c
== EOF
) ? file_list_end
: file_list_success
;
392 handle_option (const char *str
)
397 while (*str
&& isspace (*str
))
403 if (wordsplit (str
, &ws
, WRDSF_DEFFLAGS
|WRDSF_DOOFFS
))
404 FATAL_ERROR ((0, 0, _("cannot split string '%s': %s"),
405 str
, wordsplit_strerror (&ws
)));
406 ws
.ws_wordv
[0] = program_invocation_short_name
;
407 more_options (ws
.ws_wordc
+ws
.ws_offs
, ws
.ws_wordv
);
408 for (i
= 0; i
< ws
.ws_wordc
+ws
.ws_offs
; i
++)
409 ws
.ws_wordv
[i
] = NULL
;
411 wordsplit_free (&ws
);
416 read_next_name (struct name_elt
*ent
, struct name_elt
*ret
)
420 if (!strcmp (ent
->v
.file
.name
, "-"))
422 request_stdin ("-T");
423 ent
->v
.file
.fp
= stdin
;
427 add_file_id (ent
->v
.file
.name
);
428 if ((ent
->v
.file
.fp
= fopen (ent
->v
.file
.name
, "r")) == NULL
)
429 open_fatal (ent
->v
.file
.name
);
435 switch (read_name_from_file (ent
))
441 WARNOPT (WARN_FILENAME_WITH_NULS
,
442 (0, 0, N_("%s: file name read contains nul character"),
443 quotearg_colon (ent
->v
.file
.name
)));
444 ent
->v
.file
.term
= 0;
446 case file_list_success
:
447 if (handle_option (name_buffer
) == 0)
449 ret
->type
= NELT_NAME
;
450 ret
->v
.name
= name_buffer
;
454 if (strcmp (ent
->v
.file
.name
, "-"))
455 fclose (ent
->v
.file
.fp
);
456 ent
->v
.file
.fp
= NULL
;
463 copy_name (struct name_elt
*ep
)
470 source_len
= strlen (source
);
471 if (name_buffer_length
< source_len
)
475 name_buffer_length
*= 2;
476 if (! name_buffer_length
)
479 while (name_buffer_length
< source_len
);
482 name_buffer
= xmalloc(name_buffer_length
+ 2);
484 strcpy (name_buffer
, source
);
486 /* Zap trailing slashes. */
487 cursor
= name_buffer
+ strlen (name_buffer
) - 1;
488 while (cursor
> name_buffer
&& ISSLASH (*cursor
))
493 static int matching_flags
; /* exclude_fnmatch options */
495 /* Get the next NELT_NAME element from name_array. Result is in
496 static storage and can't be relied upon across two calls.
498 If CHANGE_DIRS is true, treat any entries of type NELT_CHDIR as
499 the request to change to the given directory.
501 Entries of type NELT_FMASK cause updates of the matching_flags
503 static struct name_elt
*
504 name_next_elt (int change_dirs
)
506 static struct name_elt entry
;
508 while (scanned
!= entries
)
512 ep
= &name_array
[scanned
];
517 matching_flags
= ep
->v
.matching_flags
;
522 if (read_next_name (ep
, &entry
) == 0)
532 if (chdir (name_buffer
) < 0)
533 chdir_fatal (name_buffer
);
541 unquote_string (name_buffer
);
542 entry
.type
= ep
->type
;
543 entry
.v
.name
= name_buffer
;
552 name_next (int change_dirs
)
554 struct name_elt
*nelt
= name_next_elt (change_dirs
);
555 return nelt
? nelt
->v
.name
: NULL
;
558 /* Gather names in a list for scanning. Could hash them later if we
561 If the names are already sorted to match the archive, we just read
562 them one by one. name_gather reads the first one, and it is called
563 by name_match as appropriate to read the next ones. At EOF, the
564 last name read is just left in the buffer. This option lets users
565 of small machines extract an arbitrary number of files by doing
566 "tar t" and editing down the list of files. */
571 /* Buffer able to hold a single name. */
572 static struct name
*buffer
= NULL
;
576 if (same_order_option
)
578 static int change_dir
;
580 while ((ep
= name_next_elt (0)) && ep
->type
== NELT_CHDIR
)
581 change_dir
= chdir_arg (xstrdup (ep
->v
.name
));
586 buffer
= make_name (ep
->v
.name
);
587 buffer
->change_dir
= change_dir
;
589 buffer
->found_count
= 0;
590 buffer
->matching_flags
= matching_flags
;
591 buffer
->directory
= NULL
;
592 buffer
->parent
= NULL
;
593 buffer
->cmdline
= true;
595 namelist
= nametail
= buffer
;
598 addname (0, change_dir
, false, NULL
);
602 /* Non sorted names -- read them all in. */
607 int change_dir0
= change_dir
;
608 while ((ep
= name_next_elt (0)) && ep
->type
== NELT_CHDIR
)
609 change_dir
= chdir_arg (xstrdup (ep
->v
.name
));
612 addname (ep
->v
.name
, change_dir
, true, NULL
);
615 if (change_dir
!= change_dir0
)
616 addname (NULL
, change_dir
, false, NULL
);
623 /* Add a name to the namelist. */
625 addname (char const *string
, int change_dir
, bool cmdline
, struct name
*parent
)
627 struct name
*name
= make_name (string
);
629 name
->prev
= nametail
;
631 name
->found_count
= 0;
632 name
->matching_flags
= matching_flags
;
633 name
->change_dir
= change_dir
;
634 name
->directory
= NULL
;
635 name
->parent
= parent
;
636 name
->cmdline
= cmdline
;
639 nametail
->next
= name
;
646 /* Find a match for FILE_NAME (whose string length is LENGTH) in the name
649 namelist_match (char const *file_name
, size_t length
)
653 for (p
= namelist
; p
; p
= p
->next
)
656 && exclude_fnmatch (p
->name
, file_name
, p
->matching_flags
))
664 remname (struct name
*name
)
668 if ((p
= name
->prev
) != NULL
)
669 p
->next
= name
->next
;
671 namelist
= name
->next
;
673 if ((p
= name
->next
) != NULL
)
674 p
->prev
= name
->prev
;
676 nametail
= name
->prev
;
679 /* Return true if and only if name FILE_NAME (from an archive) matches any
680 name from the namelist. */
682 name_match (const char *file_name
)
684 size_t length
= strlen (file_name
);
688 struct name
*cursor
= namelist
;
693 if (cursor
->name
[0] == 0)
695 chdir_do (cursor
->change_dir
);
701 cursor
= namelist_match (file_name
, length
);
704 if (!(ISSLASH (file_name
[cursor
->length
]) && recursion_option
)
705 || cursor
->found_count
== 0)
706 cursor
->found_count
++; /* remember it matched */
707 if (starting_file_option
)
713 chdir_do (cursor
->change_dir
);
715 /* We got a match. */
716 return ISFOUND (cursor
);
719 /* Filename from archive not found in namelist. If we have the whole
720 namelist here, just return 0. Otherwise, read the next name in and
721 compare it. If this was the last name, namelist->found_count will
722 remain on. If not, we loop to compare the newly read name. */
724 if (same_order_option
&& namelist
->found_count
)
726 name_gather (); /* read one more */
727 if (namelist
->found_count
)
735 /* Returns true if all names from the namelist were processed.
736 P is the stat_info of the most recently processed entry.
737 The decision is postponed until the next entry is read if:
739 1) P ended with a slash (i.e. it was a directory)
740 2) P matches any entry from the namelist *and* represents a subdirectory
741 or a file lying under this entry (in the terms of directory structure).
743 This is necessary to handle contents of directories. */
745 all_names_found (struct tar_stat_info
*p
)
747 struct name
const *cursor
;
750 if (!p
->file_name
|| occurrence_option
== 0 || p
->had_trailing_slash
)
752 len
= strlen (p
->file_name
);
753 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
755 if ((cursor
->name
[0] && !WASFOUND (cursor
))
756 || (len
>= cursor
->length
&& ISSLASH (p
->file_name
[cursor
->length
])))
763 regex_usage_warning (const char *name
)
765 static int warned_once
= 0;
767 if (warn_regex_usage
&& fnmatch_pattern_has_wildcards (name
, 0))
771 _("Pattern matching characters used in file names")));
773 _("Use --wildcards to enable pattern matching,"
774 " or --no-wildcards to suppress this warning")));
779 /* Print the names of things in the namelist that were not matched. */
781 names_notfound (void)
783 struct name
const *cursor
;
785 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
786 if (!WASFOUND (cursor
) && cursor
->name
[0])
788 regex_usage_warning (cursor
->name
);
790 (cursor
->found_count
== 0) ?
791 _("%s: Not found in archive") :
792 _("%s: Required occurrence not found in archive"),
793 quotearg_colon (cursor
->name
)));
796 /* Don't bother freeing the name list; we're about to exit. */
800 if (same_order_option
)
804 while ((name
= name_next (1)) != NULL
)
806 regex_usage_warning (name
);
807 ERROR ((0, 0, _("%s: Not found in archive"),
808 quotearg_colon (name
)));
814 label_notfound (void)
816 struct name
const *cursor
;
821 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
822 if (WASFOUND (cursor
))
826 error (0, 0, _("Archive label mismatch"));
827 set_exit_status (TAREXIT_DIFFERS
);
829 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
831 if (regex_usage_warning (cursor
->name
))
835 /* Don't bother freeing the name list; we're about to exit. */
839 if (same_order_option
)
843 while ((name
= name_next (1)) != NULL
844 && regex_usage_warning (name
) == 0)
849 /* Sorting name lists. */
851 /* Sort *singly* linked LIST of names, of given LENGTH, using COMPARE
852 to order names. Return the sorted list. Note that after calling
853 this function, the 'prev' links in list elements are messed up.
855 Apart from the type 'struct name' and the definition of SUCCESSOR,
856 this is a generic list-sorting function, but it's too painful to
857 make it both generic and portable
861 merge_sort_sll (struct name
*list
, int length
,
862 int (*compare
) (struct name
const*, struct name
const*))
864 struct name
*first_list
;
865 struct name
*second_list
;
869 struct name
**merge_point
;
873 # define SUCCESSOR(name) ((name)->next)
880 if ((*compare
) (list
, SUCCESSOR (list
)) > 0)
882 result
= SUCCESSOR (list
);
883 SUCCESSOR (result
) = list
;
884 SUCCESSOR (list
) = 0;
891 first_length
= (length
+ 1) / 2;
892 second_length
= length
/ 2;
893 for (cursor
= list
, counter
= first_length
- 1;
895 cursor
= SUCCESSOR (cursor
), counter
--)
897 second_list
= SUCCESSOR (cursor
);
898 SUCCESSOR (cursor
) = 0;
900 first_list
= merge_sort_sll (first_list
, first_length
, compare
);
901 second_list
= merge_sort_sll (second_list
, second_length
, compare
);
903 merge_point
= &result
;
904 while (first_list
&& second_list
)
905 if ((*compare
) (first_list
, second_list
) < 0)
907 cursor
= SUCCESSOR (first_list
);
908 *merge_point
= first_list
;
909 merge_point
= &SUCCESSOR (first_list
);
914 cursor
= SUCCESSOR (second_list
);
915 *merge_point
= second_list
;
916 merge_point
= &SUCCESSOR (second_list
);
917 second_list
= cursor
;
920 *merge_point
= first_list
;
922 *merge_point
= second_list
;
929 /* Sort doubly linked LIST of names, of given LENGTH, using COMPARE
930 to order names. Return the sorted list. */
932 merge_sort (struct name
*list
, int length
,
933 int (*compare
) (struct name
const*, struct name
const*))
935 struct name
*head
, *p
, *prev
;
936 head
= merge_sort_sll (list
, length
, compare
);
937 /* Fixup prev pointers */
938 for (prev
= NULL
, p
= head
; p
; prev
= p
, p
= p
->next
)
943 /* A comparison function for sorting names. Put found names last;
944 break ties by string comparison. */
947 compare_names_found (struct name
const *n1
, struct name
const *n2
)
949 int found_diff
= WASFOUND (n2
) - WASFOUND (n1
);
950 return found_diff
? found_diff
: strcmp (n1
->name
, n2
->name
);
953 /* Simple comparison by names. */
955 compare_names (struct name
const *n1
, struct name
const *n2
)
957 return strcmp (n1
->name
, n2
->name
);
961 /* Add all the dirs under ST to the namelist NAME, descending the
962 directory hierarchy recursively. */
965 add_hierarchy_to_namelist (struct tar_stat_info
*st
, struct name
*name
)
969 name
->directory
= scan_directory (st
);
970 buffer
= directory_contents (name
->directory
);
973 struct name
*child_head
= NULL
, *child_tail
= NULL
;
974 size_t name_length
= name
->length
;
975 size_t allocated_length
= (name_length
>= NAME_FIELD_SIZE
976 ? name_length
+ NAME_FIELD_SIZE
978 char *namebuf
= xmalloc (allocated_length
+ 1);
979 /* FIXME: + 2 above? */
981 size_t string_length
;
982 int change_dir
= name
->change_dir
;
984 strcpy (namebuf
, name
->name
);
985 if (! ISSLASH (namebuf
[name_length
- 1]))
987 namebuf
[name_length
++] = '/';
988 namebuf
[name_length
] = '\0';
991 for (string
= buffer
; *string
; string
+= string_length
+ 1)
993 string_length
= strlen (string
);
997 struct tar_stat_info subdir
;
1000 if (allocated_length
<= name_length
+ string_length
)
1004 allocated_length
*= 2;
1005 if (! allocated_length
)
1008 while (allocated_length
<= name_length
+ string_length
);
1010 namebuf
= xrealloc (namebuf
, allocated_length
+ 1);
1012 strcpy (namebuf
+ name_length
, string
+ 1);
1013 np
= addname (namebuf
, change_dir
, false, name
);
1017 child_tail
->sibling
= np
;
1020 tar_stat_init (&subdir
);
1028 subfd
= subfile_open (st
, string
+ 1,
1029 open_read_flags
| O_DIRECTORY
);
1031 open_diag (namebuf
);
1035 if (fstat (subfd
, &subdir
.stat
) != 0)
1036 stat_diag (namebuf
);
1037 else if (! (O_DIRECTORY
|| S_ISDIR (subdir
.stat
.st_mode
)))
1040 open_diag (namebuf
);
1044 subdir
.orig_file_name
= xstrdup (namebuf
);
1045 add_hierarchy_to_namelist (&subdir
, np
);
1046 restore_parent_fd (&subdir
);
1050 tar_stat_destroy (&subdir
);
1055 name
->child
= child_head
;
1059 /* Auxiliary functions for hashed table of struct name's. */
1062 name_hash (void const *entry
, size_t n_buckets
)
1064 struct name
const *name
= entry
;
1065 return hash_string (name
->caname
, n_buckets
);
1068 /* Compare two directories for equality of their names. */
1070 name_compare (void const *entry1
, void const *entry2
)
1072 struct name
const *name1
= entry1
;
1073 struct name
const *name2
= entry2
;
1074 return strcmp (name1
->caname
, name2
->caname
) == 0;
1078 /* Rebase 'name' member of CHILD and all its siblings to
1081 rebase_child_list (struct name
*child
, struct name
*parent
)
1083 size_t old_prefix_len
= child
->parent
->length
;
1084 size_t new_prefix_len
= parent
->length
;
1085 char *new_prefix
= parent
->name
;
1087 for (; child
; child
= child
->sibling
)
1089 size_t size
= child
->length
- old_prefix_len
+ new_prefix_len
;
1090 char *newp
= xmalloc (size
+ 1);
1091 strcpy (newp
, new_prefix
);
1092 strcat (newp
, child
->name
+ old_prefix_len
);
1095 child
->length
= size
;
1097 rebase_directory (child
->directory
,
1098 child
->parent
->name
, old_prefix_len
,
1099 new_prefix
, new_prefix_len
);
1103 /* Collect all the names from argv[] (or whatever), expand them into a
1104 directory tree, and sort them. This gets only subdirectories, not
1108 collect_and_sort_names (void)
1111 struct name
*next_name
, *prev_name
= NULL
;
1113 Hash_table
*nametab
;
1118 addname (".", 0, false, NULL
);
1120 if (listed_incremental_option
)
1122 switch (chdir_count ())
1128 if (namelist
->change_dir
== 0)
1130 _("Using -C option inside file list is not "
1131 "allowed with --listed-incremental")));
1136 _("Only one -C option is allowed with "
1137 "--listed-incremental")));
1140 read_directory_file ();
1144 for (name
= namelist
; name
; name
= name
->next
, num_names
++)
1146 struct tar_stat_info st
;
1148 if (name
->found_count
|| name
->directory
)
1150 if (name
->matching_flags
& EXCLUDE_WILDCARDS
)
1151 /* NOTE: EXCLUDE_ANCHORED is not relevant here */
1152 /* FIXME: just skip regexps for now */
1154 chdir_do (name
->change_dir
);
1156 if (name
->name
[0] == 0)
1159 tar_stat_init (&st
);
1161 if (deref_stat (name
->name
, &st
.stat
) != 0)
1163 stat_diag (name
->name
);
1166 if (S_ISDIR (st
.stat
.st_mode
))
1168 int dir_fd
= openat (chdir_fd
, name
->name
,
1169 open_read_flags
| O_DIRECTORY
);
1171 open_diag (name
->name
);
1175 if (fstat (dir_fd
, &st
.stat
) != 0)
1176 stat_diag (name
->name
);
1177 else if (O_DIRECTORY
|| S_ISDIR (st
.stat
.st_mode
))
1179 st
.orig_file_name
= xstrdup (name
->name
);
1180 name
->found_count
++;
1181 add_hierarchy_to_namelist (&st
, name
);
1186 tar_stat_destroy (&st
);
1189 namelist
= merge_sort (namelist
, num_names
, compare_names
);
1192 nametab
= hash_initialize (0, 0,
1194 name_compare
, NULL
);
1195 for (name
= namelist
; name
; name
= next_name
)
1197 next_name
= name
->next
;
1198 name
->caname
= normalize_filename (name
->name
);
1201 struct name
*p
= hash_lookup (nametab
, name
);
1204 /* Keep the one listed in the command line */
1208 rebase_child_list (p
->child
, name
);
1209 hash_delete (nametab
, name
);
1210 /* FIXME: remove_directory (p->caname); ? */
1218 rebase_child_list (name
->child
, p
);
1219 /* FIXME: remove_directory (name->caname); ? */
1226 name
->found_count
= 0;
1227 if (!hash_insert (nametab
, name
))
1232 nametail
= prev_name
;
1233 hash_free (nametab
);
1235 namelist
= merge_sort (namelist
, num_names
, compare_names_found
);
1237 if (listed_incremental_option
)
1239 for (name
= namelist
; name
&& name
->name
[0] == 0; name
++)
1242 append_incremental_renames (name
->directory
);
1246 /* This is like name_match, except that
1247 1. It returns a pointer to the name it matched, and doesn't set FOUND
1248 in structure. The caller will have to do that if it wants to.
1249 2. If the namelist is empty, it returns null, unlike name_match, which
1252 name_scan (const char *file_name
)
1254 size_t length
= strlen (file_name
);
1258 struct name
*cursor
= namelist_match (file_name
, length
);
1262 /* Filename from archive not found in namelist. If we have the whole
1263 namelist here, just return 0. Otherwise, read the next name in and
1264 compare it. If this was the last name, namelist->found_count will
1265 remain on. If not, we loop to compare the newly read name. */
1267 if (same_order_option
&& namelist
&& namelist
->found_count
)
1269 name_gather (); /* read one more */
1270 if (namelist
->found_count
)
1278 /* This returns a name from the namelist which doesn't have ->found
1279 set. It sets ->found before returning, so successive calls will
1280 find and return all the non-found names in the namelist. */
1281 struct name
*gnu_list_name
;
1284 name_from_list (void)
1287 gnu_list_name
= namelist
;
1288 while (gnu_list_name
1289 && (gnu_list_name
->found_count
|| gnu_list_name
->name
[0] == 0))
1290 gnu_list_name
= gnu_list_name
->next
;
1293 gnu_list_name
->found_count
++;
1294 chdir_do (gnu_list_name
->change_dir
);
1295 return gnu_list_name
;
1301 blank_name_list (void)
1306 for (name
= namelist
; name
; name
= name
->next
)
1307 name
->found_count
= 0;
1310 /* Yield a newly allocated file name consisting of FILE_NAME concatenated to
1311 NAME, with an intervening slash if FILE_NAME does not already end in one. */
1313 new_name (const char *file_name
, const char *name
)
1315 size_t file_name_len
= strlen (file_name
);
1316 size_t namesize
= strlen (name
) + 1;
1317 int slash
= file_name_len
&& ! ISSLASH (file_name
[file_name_len
- 1]);
1318 char *buffer
= xmalloc (file_name_len
+ slash
+ namesize
);
1319 memcpy (buffer
, file_name
, file_name_len
);
1320 buffer
[file_name_len
] = '/';
1321 memcpy (buffer
+ file_name_len
+ slash
, name
, namesize
);
1325 /* Return nonzero if file NAME is excluded. */
1327 excluded_name (char const *name
)
1329 return excluded_file_name (excluded
, name
+ FILE_SYSTEM_PREFIX_LEN (name
));
1333 /* Return the size of the prefix of FILE_NAME that is removed after
1334 stripping NUM leading file name components. NUM must be
1338 stripped_prefix_len (char const *file_name
, size_t num
)
1340 char const *p
= file_name
+ FILE_SYSTEM_PREFIX_LEN (file_name
);
1341 while (ISSLASH (*p
))
1345 bool slash
= ISSLASH (*p
);
1350 return p
- file_name
;
1351 while (ISSLASH (*p
))
1358 /* Return nonzero if NAME contains ".." as a file name component. */
1360 contains_dot_dot (char const *name
)
1362 char const *p
= name
+ FILE_SYSTEM_PREFIX_LEN (name
);
1366 if (p
[0] == '.' && p
[1] == '.' && (ISSLASH (p
[2]) || !p
[2]))
1369 while (! ISSLASH (*p
))