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 element list (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_list 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 */
216 #define NELT_NOOP 4 /* No operation */
218 struct name_elt
/* A name_array element. */
220 struct name_elt
*next
, *prev
;
221 char type
; /* Element type, see NELT_* constants above */
224 const char *name
; /* File or directory name */
225 int matching_flags
;/* fnmatch options if type == NELT_FMASK */
226 struct /* File, if type == NELT_FILE */
228 const char *name
;/* File name */
229 int term
; /* File name terminator in the list */
235 static struct name_elt
*name_head
; /* store a list of names */
236 size_t name_count
; /* how many of the entries are names? */
238 static struct name_elt
*
239 name_elt_alloc (void)
241 struct name_elt
*elt
;
243 elt
= xmalloc (sizeof (*elt
));
247 name_head
->prev
= name_head
->next
= NULL
;
248 name_head
->type
= NELT_NOOP
;
249 elt
= xmalloc (sizeof (*elt
));
252 elt
->prev
= name_head
->prev
;
254 name_head
->prev
->next
= elt
;
255 elt
->next
= name_head
;
256 name_head
->prev
= elt
;
261 name_list_adjust (void)
264 while (name_head
->prev
)
265 name_head
= name_head
->prev
;
269 name_list_advance (void)
271 struct name_elt
*elt
= name_head
;
272 name_head
= elt
->next
;
274 name_head
->prev
= NULL
;
278 /* Add to name_array the file NAME with fnmatch options MATCHING_FLAGS */
280 name_add_name (const char *name
, int matching_flags
)
282 static int prev_flags
= 0; /* FIXME: Or EXCLUDE_ANCHORED? */
283 struct name_elt
*ep
= name_elt_alloc ();
285 if (prev_flags
!= matching_flags
)
287 ep
->type
= NELT_FMASK
;
288 ep
->v
.matching_flags
= matching_flags
;
289 prev_flags
= matching_flags
;
290 ep
= name_elt_alloc ();
292 ep
->type
= NELT_NAME
;
297 /* Add to name_array a chdir request for the directory NAME */
299 name_add_dir (const char *name
)
301 struct name_elt
*ep
= name_elt_alloc ();
302 ep
->type
= NELT_CHDIR
;
307 name_add_file (const char *name
, int term
)
309 struct name_elt
*ep
= name_elt_alloc ();
310 ep
->type
= NELT_FILE
;
311 ep
->v
.file
.name
= name
;
312 ep
->v
.file
.term
= term
;
313 ep
->v
.file
.fp
= NULL
;
316 /* Names from external name file. */
318 static char *name_buffer
; /* buffer to hold the current file name */
319 static size_t name_buffer_length
; /* allocated length of name_buffer */
321 /* Set up to gather file names for tar. They can either come from a
322 file or were saved from decoding arguments. */
326 name_buffer
= xmalloc (NAME_FIELD_SIZE
+ 2);
327 name_buffer_length
= NAME_FIELD_SIZE
;
337 /* Prevent recursive inclusion of the same file */
340 struct file_id_list
*next
;
343 const char *from_file
;
346 static struct file_id_list
*file_id_list
;
348 /* Return the name of the file from which the file names and options
352 file_list_name (void)
354 struct name_elt
*elt
;
356 for (elt
= name_head
; elt
; elt
= elt
->next
)
357 if (elt
->type
== NELT_FILE
&& elt
->v
.file
.fp
)
358 return elt
->v
.file
.name
;
359 return _("command line");
363 add_file_id (const char *filename
)
365 struct file_id_list
*p
;
367 const char *reading_from
;
369 if (stat (filename
, &st
))
370 stat_fatal (filename
);
371 reading_from
= file_list_name ();
372 for (p
= file_id_list
; p
; p
= p
->next
)
373 if (p
->ino
== st
.st_ino
&& p
->dev
== st
.st_dev
)
375 int oldc
= set_char_quoting (NULL
, ':', 1);
377 _("%s: file list requested from %s already read from %s"),
378 quotearg_n (0, filename
),
379 reading_from
, p
->from_file
));
380 set_char_quoting (NULL
, ':', oldc
);
383 p
= xmalloc (sizeof *p
);
384 p
->next
= file_id_list
;
387 p
->from_file
= reading_from
;
392 enum read_file_list_state
/* Result of reading file name from the list file */
394 file_list_success
, /* OK, name read successfully */
395 file_list_end
, /* End of list file */
396 file_list_zero
, /* Zero separator encountered where it should not */
397 file_list_skip
/* Empty (zero-length) entry encountered, skip it */
400 /* Read from FP a sequence of characters up to TERM and put them
403 static enum read_file_list_state
404 read_name_from_file (struct name_elt
*ent
)
408 FILE *fp
= ent
->v
.file
.fp
;
409 int term
= ent
->v
.file
.term
;
411 for (c
= getc (fp
); c
!= EOF
&& c
!= term
; c
= getc (fp
))
413 if (counter
== name_buffer_length
)
414 name_buffer
= x2realloc (name_buffer
, &name_buffer_length
);
415 name_buffer
[counter
++] = c
;
418 /* We have read a zero separator. The file possibly is
420 return file_list_zero
;
424 if (counter
== 0 && c
!= EOF
)
425 return file_list_skip
;
427 if (counter
== name_buffer_length
)
428 name_buffer
= x2realloc (name_buffer
, &name_buffer_length
);
429 name_buffer
[counter
] = 0;
431 return (counter
== 0 && c
== EOF
) ? file_list_end
: file_list_success
;
435 handle_option (const char *str
)
440 while (*str
&& isspace (*str
))
446 if (wordsplit (str
, &ws
, WRDSF_DEFFLAGS
|WRDSF_DOOFFS
))
447 FATAL_ERROR ((0, 0, _("cannot split string '%s': %s"),
448 str
, wordsplit_strerror (&ws
)));
449 ws
.ws_wordv
[0] = program_invocation_short_name
;
450 more_options (ws
.ws_wordc
+ws
.ws_offs
, ws
.ws_wordv
);
451 for (i
= 0; i
< ws
.ws_wordc
+ws
.ws_offs
; i
++)
452 ws
.ws_wordv
[i
] = NULL
;
454 wordsplit_free (&ws
);
459 read_next_name (struct name_elt
*ent
, struct name_elt
*ret
)
463 if (!strcmp (ent
->v
.file
.name
, "-"))
465 request_stdin ("-T");
466 ent
->v
.file
.fp
= stdin
;
470 if (add_file_id (ent
->v
.file
.name
))
472 name_list_advance ();
475 if ((ent
->v
.file
.fp
= fopen (ent
->v
.file
.name
, "r")) == NULL
)
476 open_fatal (ent
->v
.file
.name
);
482 switch (read_name_from_file (ent
))
488 WARNOPT (WARN_FILENAME_WITH_NULS
,
489 (0, 0, N_("%s: file name read contains nul character"),
490 quotearg_colon (ent
->v
.file
.name
)));
491 ent
->v
.file
.term
= 0;
493 case file_list_success
:
494 if (handle_option (name_buffer
) == 0)
499 ret
->type
= NELT_NAME
;
500 ret
->v
.name
= name_buffer
;
504 if (strcmp (ent
->v
.file
.name
, "-"))
505 fclose (ent
->v
.file
.fp
);
506 ent
->v
.file
.fp
= NULL
;
507 name_list_advance ();
514 copy_name (struct name_elt
*ep
)
521 source_len
= strlen (source
);
522 if (name_buffer_length
< source_len
)
526 name_buffer_length
*= 2;
527 if (! name_buffer_length
)
530 while (name_buffer_length
< source_len
);
533 name_buffer
= xmalloc(name_buffer_length
+ 2);
535 strcpy (name_buffer
, source
);
537 /* Zap trailing slashes. */
538 cursor
= name_buffer
+ strlen (name_buffer
) - 1;
539 while (cursor
> name_buffer
&& ISSLASH (*cursor
))
544 static int matching_flags
; /* exclude_fnmatch options */
546 /* Get the next NELT_NAME element from name_array. Result is in
547 static storage and can't be relied upon across two calls.
549 If CHANGE_DIRS is true, treat any entries of type NELT_CHDIR as
550 the request to change to the given directory.
552 Entries of type NELT_FMASK cause updates of the matching_flags
554 static struct name_elt
*
555 name_next_elt (int change_dirs
)
557 static struct name_elt entry
;
560 while ((ep
= name_head
) != NULL
)
565 name_list_advance ();
569 matching_flags
= ep
->v
.matching_flags
;
570 name_list_advance ();
574 if (read_next_name (ep
, &entry
) == 0)
582 if (chdir (name_buffer
) < 0)
583 chdir_fatal (name_buffer
);
584 name_list_advance ();
591 unquote_string (name_buffer
);
592 entry
.type
= ep
->type
;
593 entry
.v
.name
= name_buffer
;
594 name_list_advance ();
603 name_next (int change_dirs
)
605 struct name_elt
*nelt
= name_next_elt (change_dirs
);
606 return nelt
? nelt
->v
.name
: NULL
;
609 /* Gather names in a list for scanning. Could hash them later if we
612 If the names are already sorted to match the archive, we just read
613 them one by one. name_gather reads the first one, and it is called
614 by name_match as appropriate to read the next ones. At EOF, the
615 last name read is just left in the buffer. This option lets users
616 of small machines extract an arbitrary number of files by doing
617 "tar t" and editing down the list of files. */
622 /* Buffer able to hold a single name. */
623 static struct name
*buffer
= NULL
;
627 if (same_order_option
)
629 static int change_dir
;
631 while ((ep
= name_next_elt (0)) && ep
->type
== NELT_CHDIR
)
632 change_dir
= chdir_arg (xstrdup (ep
->v
.name
));
637 buffer
= make_name (ep
->v
.name
);
638 buffer
->change_dir
= change_dir
;
640 buffer
->found_count
= 0;
641 buffer
->matching_flags
= matching_flags
;
642 buffer
->directory
= NULL
;
643 buffer
->parent
= NULL
;
644 buffer
->cmdline
= true;
646 namelist
= nametail
= buffer
;
649 addname (0, change_dir
, false, NULL
);
653 /* Non sorted names -- read them all in. */
658 int change_dir0
= change_dir
;
659 while ((ep
= name_next_elt (0)) && ep
->type
== NELT_CHDIR
)
660 change_dir
= chdir_arg (xstrdup (ep
->v
.name
));
663 addname (ep
->v
.name
, change_dir
, true, NULL
);
666 if (change_dir
!= change_dir0
)
667 addname (NULL
, change_dir
, false, NULL
);
674 /* Add a name to the namelist. */
676 addname (char const *string
, int change_dir
, bool cmdline
, struct name
*parent
)
678 struct name
*name
= make_name (string
);
680 name
->prev
= nametail
;
682 name
->found_count
= 0;
683 name
->matching_flags
= matching_flags
;
684 name
->change_dir
= change_dir
;
685 name
->directory
= NULL
;
686 name
->parent
= parent
;
687 name
->cmdline
= cmdline
;
690 nametail
->next
= name
;
697 /* Find a match for FILE_NAME (whose string length is LENGTH) in the name
700 namelist_match (char const *file_name
, size_t length
)
704 for (p
= namelist
; p
; p
= p
->next
)
707 && exclude_fnmatch (p
->name
, file_name
, p
->matching_flags
))
715 remname (struct name
*name
)
719 if ((p
= name
->prev
) != NULL
)
720 p
->next
= name
->next
;
722 namelist
= name
->next
;
724 if ((p
= name
->next
) != NULL
)
725 p
->prev
= name
->prev
;
727 nametail
= name
->prev
;
730 /* Return true if and only if name FILE_NAME (from an archive) matches any
731 name from the namelist. */
733 name_match (const char *file_name
)
735 size_t length
= strlen (file_name
);
739 struct name
*cursor
= namelist
;
744 if (cursor
->name
[0] == 0)
746 chdir_do (cursor
->change_dir
);
752 cursor
= namelist_match (file_name
, length
);
755 if (!(ISSLASH (file_name
[cursor
->length
]) && recursion_option
)
756 || cursor
->found_count
== 0)
757 cursor
->found_count
++; /* remember it matched */
758 if (starting_file_option
)
764 chdir_do (cursor
->change_dir
);
766 /* We got a match. */
767 return ISFOUND (cursor
);
770 /* Filename from archive not found in namelist. If we have the whole
771 namelist here, just return 0. Otherwise, read the next name in and
772 compare it. If this was the last name, namelist->found_count will
773 remain on. If not, we loop to compare the newly read name. */
775 if (same_order_option
&& namelist
->found_count
)
777 name_gather (); /* read one more */
778 if (namelist
->found_count
)
786 /* Returns true if all names from the namelist were processed.
787 P is the stat_info of the most recently processed entry.
788 The decision is postponed until the next entry is read if:
790 1) P ended with a slash (i.e. it was a directory)
791 2) P matches any entry from the namelist *and* represents a subdirectory
792 or a file lying under this entry (in the terms of directory structure).
794 This is necessary to handle contents of directories. */
796 all_names_found (struct tar_stat_info
*p
)
798 struct name
const *cursor
;
801 if (!p
->file_name
|| occurrence_option
== 0 || p
->had_trailing_slash
)
803 len
= strlen (p
->file_name
);
804 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
806 if ((cursor
->name
[0] && !WASFOUND (cursor
))
807 || (len
>= cursor
->length
&& ISSLASH (p
->file_name
[cursor
->length
])))
814 regex_usage_warning (const char *name
)
816 static int warned_once
= 0;
818 if (warn_regex_usage
&& fnmatch_pattern_has_wildcards (name
, 0))
822 _("Pattern matching characters used in file names")));
824 _("Use --wildcards to enable pattern matching,"
825 " or --no-wildcards to suppress this warning")));
830 /* Print the names of things in the namelist that were not matched. */
832 names_notfound (void)
834 struct name
const *cursor
;
836 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
837 if (!WASFOUND (cursor
) && cursor
->name
[0])
839 regex_usage_warning (cursor
->name
);
841 (cursor
->found_count
== 0) ?
842 _("%s: Not found in archive") :
843 _("%s: Required occurrence not found in archive"),
844 quotearg_colon (cursor
->name
)));
847 /* Don't bother freeing the name list; we're about to exit. */
851 if (same_order_option
)
855 while ((name
= name_next (1)) != NULL
)
857 regex_usage_warning (name
);
858 ERROR ((0, 0, _("%s: Not found in archive"),
859 quotearg_colon (name
)));
865 label_notfound (void)
867 struct name
const *cursor
;
872 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
873 if (WASFOUND (cursor
))
877 error (0, 0, _("Archive label mismatch"));
878 set_exit_status (TAREXIT_DIFFERS
);
880 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
882 if (regex_usage_warning (cursor
->name
))
886 /* Don't bother freeing the name list; we're about to exit. */
890 if (same_order_option
)
894 while ((name
= name_next (1)) != NULL
895 && regex_usage_warning (name
) == 0)
900 /* Sorting name lists. */
902 /* Sort *singly* linked LIST of names, of given LENGTH, using COMPARE
903 to order names. Return the sorted list. Note that after calling
904 this function, the 'prev' links in list elements are messed up.
906 Apart from the type 'struct name' and the definition of SUCCESSOR,
907 this is a generic list-sorting function, but it's too painful to
908 make it both generic and portable
912 merge_sort_sll (struct name
*list
, int length
,
913 int (*compare
) (struct name
const*, struct name
const*))
915 struct name
*first_list
;
916 struct name
*second_list
;
920 struct name
**merge_point
;
924 # define SUCCESSOR(name) ((name)->next)
931 if ((*compare
) (list
, SUCCESSOR (list
)) > 0)
933 result
= SUCCESSOR (list
);
934 SUCCESSOR (result
) = list
;
935 SUCCESSOR (list
) = 0;
942 first_length
= (length
+ 1) / 2;
943 second_length
= length
/ 2;
944 for (cursor
= list
, counter
= first_length
- 1;
946 cursor
= SUCCESSOR (cursor
), counter
--)
948 second_list
= SUCCESSOR (cursor
);
949 SUCCESSOR (cursor
) = 0;
951 first_list
= merge_sort_sll (first_list
, first_length
, compare
);
952 second_list
= merge_sort_sll (second_list
, second_length
, compare
);
954 merge_point
= &result
;
955 while (first_list
&& second_list
)
956 if ((*compare
) (first_list
, second_list
) < 0)
958 cursor
= SUCCESSOR (first_list
);
959 *merge_point
= first_list
;
960 merge_point
= &SUCCESSOR (first_list
);
965 cursor
= SUCCESSOR (second_list
);
966 *merge_point
= second_list
;
967 merge_point
= &SUCCESSOR (second_list
);
968 second_list
= cursor
;
971 *merge_point
= first_list
;
973 *merge_point
= second_list
;
980 /* Sort doubly linked LIST of names, of given LENGTH, using COMPARE
981 to order names. Return the sorted list. */
983 merge_sort (struct name
*list
, int length
,
984 int (*compare
) (struct name
const*, struct name
const*))
986 struct name
*head
, *p
, *prev
;
987 head
= merge_sort_sll (list
, length
, compare
);
988 /* Fixup prev pointers */
989 for (prev
= NULL
, p
= head
; p
; prev
= p
, p
= p
->next
)
994 /* A comparison function for sorting names. Put found names last;
995 break ties by string comparison. */
998 compare_names_found (struct name
const *n1
, struct name
const *n2
)
1000 int found_diff
= WASFOUND (n2
) - WASFOUND (n1
);
1001 return found_diff
? found_diff
: strcmp (n1
->name
, n2
->name
);
1004 /* Simple comparison by names. */
1006 compare_names (struct name
const *n1
, struct name
const *n2
)
1008 return strcmp (n1
->name
, n2
->name
);
1012 /* Add all the dirs under ST to the namelist NAME, descending the
1013 directory hierarchy recursively. */
1016 add_hierarchy_to_namelist (struct tar_stat_info
*st
, struct name
*name
)
1020 name
->directory
= scan_directory (st
);
1021 buffer
= directory_contents (name
->directory
);
1024 struct name
*child_head
= NULL
, *child_tail
= NULL
;
1025 size_t name_length
= name
->length
;
1026 size_t allocated_length
= (name_length
>= NAME_FIELD_SIZE
1027 ? name_length
+ NAME_FIELD_SIZE
1029 char *namebuf
= xmalloc (allocated_length
+ 1);
1030 /* FIXME: + 2 above? */
1032 size_t string_length
;
1033 int change_dir
= name
->change_dir
;
1035 strcpy (namebuf
, name
->name
);
1036 if (! ISSLASH (namebuf
[name_length
- 1]))
1038 namebuf
[name_length
++] = '/';
1039 namebuf
[name_length
] = '\0';
1042 for (string
= buffer
; *string
; string
+= string_length
+ 1)
1044 string_length
= strlen (string
);
1048 struct tar_stat_info subdir
;
1051 if (allocated_length
<= name_length
+ string_length
)
1055 allocated_length
*= 2;
1056 if (! allocated_length
)
1059 while (allocated_length
<= name_length
+ string_length
);
1061 namebuf
= xrealloc (namebuf
, allocated_length
+ 1);
1063 strcpy (namebuf
+ name_length
, string
+ 1);
1064 np
= addname (namebuf
, change_dir
, false, name
);
1068 child_tail
->sibling
= np
;
1071 tar_stat_init (&subdir
);
1079 subfd
= subfile_open (st
, string
+ 1,
1080 open_read_flags
| O_DIRECTORY
);
1082 open_diag (namebuf
);
1086 if (fstat (subfd
, &subdir
.stat
) != 0)
1087 stat_diag (namebuf
);
1088 else if (! (O_DIRECTORY
|| S_ISDIR (subdir
.stat
.st_mode
)))
1091 open_diag (namebuf
);
1095 subdir
.orig_file_name
= xstrdup (namebuf
);
1096 add_hierarchy_to_namelist (&subdir
, np
);
1097 restore_parent_fd (&subdir
);
1101 tar_stat_destroy (&subdir
);
1106 name
->child
= child_head
;
1110 /* Auxiliary functions for hashed table of struct name's. */
1113 name_hash (void const *entry
, size_t n_buckets
)
1115 struct name
const *name
= entry
;
1116 return hash_string (name
->caname
, n_buckets
);
1119 /* Compare two directories for equality of their names. */
1121 name_compare (void const *entry1
, void const *entry2
)
1123 struct name
const *name1
= entry1
;
1124 struct name
const *name2
= entry2
;
1125 return strcmp (name1
->caname
, name2
->caname
) == 0;
1129 /* Rebase 'name' member of CHILD and all its siblings to
1132 rebase_child_list (struct name
*child
, struct name
*parent
)
1134 size_t old_prefix_len
= child
->parent
->length
;
1135 size_t new_prefix_len
= parent
->length
;
1136 char *new_prefix
= parent
->name
;
1138 for (; child
; child
= child
->sibling
)
1140 size_t size
= child
->length
- old_prefix_len
+ new_prefix_len
;
1141 char *newp
= xmalloc (size
+ 1);
1142 strcpy (newp
, new_prefix
);
1143 strcat (newp
, child
->name
+ old_prefix_len
);
1146 child
->length
= size
;
1148 rebase_directory (child
->directory
,
1149 child
->parent
->name
, old_prefix_len
,
1150 new_prefix
, new_prefix_len
);
1154 /* Collect all the names from argv[] (or whatever), expand them into a
1155 directory tree, and sort them. This gets only subdirectories, not
1159 collect_and_sort_names (void)
1162 struct name
*next_name
, *prev_name
= NULL
;
1164 Hash_table
*nametab
;
1169 addname (".", 0, false, NULL
);
1171 if (listed_incremental_option
)
1173 switch (chdir_count ())
1179 if (namelist
->change_dir
== 0)
1181 _("Using -C option inside file list is not "
1182 "allowed with --listed-incremental")));
1187 _("Only one -C option is allowed with "
1188 "--listed-incremental")));
1191 read_directory_file ();
1195 for (name
= namelist
; name
; name
= name
->next
, num_names
++)
1197 struct tar_stat_info st
;
1199 if (name
->found_count
|| name
->directory
)
1201 if (name
->matching_flags
& EXCLUDE_WILDCARDS
)
1202 /* NOTE: EXCLUDE_ANCHORED is not relevant here */
1203 /* FIXME: just skip regexps for now */
1205 chdir_do (name
->change_dir
);
1207 if (name
->name
[0] == 0)
1210 tar_stat_init (&st
);
1212 if (deref_stat (name
->name
, &st
.stat
) != 0)
1214 stat_diag (name
->name
);
1217 if (S_ISDIR (st
.stat
.st_mode
))
1219 int dir_fd
= openat (chdir_fd
, name
->name
,
1220 open_read_flags
| O_DIRECTORY
);
1222 open_diag (name
->name
);
1226 if (fstat (dir_fd
, &st
.stat
) != 0)
1227 stat_diag (name
->name
);
1228 else if (O_DIRECTORY
|| S_ISDIR (st
.stat
.st_mode
))
1230 st
.orig_file_name
= xstrdup (name
->name
);
1231 name
->found_count
++;
1232 add_hierarchy_to_namelist (&st
, name
);
1237 tar_stat_destroy (&st
);
1240 namelist
= merge_sort (namelist
, num_names
, compare_names
);
1243 nametab
= hash_initialize (0, 0,
1245 name_compare
, NULL
);
1246 for (name
= namelist
; name
; name
= next_name
)
1248 next_name
= name
->next
;
1249 name
->caname
= normalize_filename (name
->name
);
1252 struct name
*p
= hash_lookup (nametab
, name
);
1255 /* Keep the one listed in the command line */
1259 rebase_child_list (p
->child
, name
);
1260 hash_delete (nametab
, name
);
1261 /* FIXME: remove_directory (p->caname); ? */
1269 rebase_child_list (name
->child
, p
);
1270 /* FIXME: remove_directory (name->caname); ? */
1277 name
->found_count
= 0;
1278 if (!hash_insert (nametab
, name
))
1283 nametail
= prev_name
;
1284 hash_free (nametab
);
1286 namelist
= merge_sort (namelist
, num_names
, compare_names_found
);
1288 if (listed_incremental_option
)
1290 for (name
= namelist
; name
&& name
->name
[0] == 0; name
++)
1293 append_incremental_renames (name
->directory
);
1297 /* This is like name_match, except that
1298 1. It returns a pointer to the name it matched, and doesn't set FOUND
1299 in structure. The caller will have to do that if it wants to.
1300 2. If the namelist is empty, it returns null, unlike name_match, which
1303 name_scan (const char *file_name
)
1305 size_t length
= strlen (file_name
);
1309 struct name
*cursor
= namelist_match (file_name
, length
);
1313 /* Filename from archive not found in namelist. If we have the whole
1314 namelist here, just return 0. Otherwise, read the next name in and
1315 compare it. If this was the last name, namelist->found_count will
1316 remain on. If not, we loop to compare the newly read name. */
1318 if (same_order_option
&& namelist
&& namelist
->found_count
)
1320 name_gather (); /* read one more */
1321 if (namelist
->found_count
)
1329 /* This returns a name from the namelist which doesn't have ->found
1330 set. It sets ->found before returning, so successive calls will
1331 find and return all the non-found names in the namelist. */
1332 struct name
*gnu_list_name
;
1335 name_from_list (void)
1338 gnu_list_name
= namelist
;
1339 while (gnu_list_name
1340 && (gnu_list_name
->found_count
|| gnu_list_name
->name
[0] == 0))
1341 gnu_list_name
= gnu_list_name
->next
;
1344 gnu_list_name
->found_count
++;
1345 chdir_do (gnu_list_name
->change_dir
);
1346 return gnu_list_name
;
1352 blank_name_list (void)
1357 for (name
= namelist
; name
; name
= name
->next
)
1358 name
->found_count
= 0;
1361 /* Yield a newly allocated file name consisting of FILE_NAME concatenated to
1362 NAME, with an intervening slash if FILE_NAME does not already end in one. */
1364 new_name (const char *file_name
, const char *name
)
1366 size_t file_name_len
= strlen (file_name
);
1367 size_t namesize
= strlen (name
) + 1;
1368 int slash
= file_name_len
&& ! ISSLASH (file_name
[file_name_len
- 1]);
1369 char *buffer
= xmalloc (file_name_len
+ slash
+ namesize
);
1370 memcpy (buffer
, file_name
, file_name_len
);
1371 buffer
[file_name_len
] = '/';
1372 memcpy (buffer
+ file_name_len
+ slash
, name
, namesize
);
1376 /* Return nonzero if file NAME is excluded. */
1378 excluded_name (char const *name
)
1380 return excluded_file_name (excluded
, name
+ FILE_SYSTEM_PREFIX_LEN (name
));
1384 /* Return the size of the prefix of FILE_NAME that is removed after
1385 stripping NUM leading file name components. NUM must be
1389 stripped_prefix_len (char const *file_name
, size_t num
)
1391 char const *p
= file_name
+ FILE_SYSTEM_PREFIX_LEN (file_name
);
1392 while (ISSLASH (*p
))
1396 bool slash
= ISSLASH (*p
);
1401 return p
- file_name
;
1402 while (ISSLASH (*p
))
1409 /* Return nonzero if NAME contains ".." as a file name component. */
1411 contains_dot_dot (char const *name
)
1413 char const *p
= name
+ FILE_SYSTEM_PREFIX_LEN (name
);
1417 if (p
[0] == '.' && p
[1] == '.' && (ISSLASH (p
[2]) || !p
[2]))
1420 while (! ISSLASH (*p
))