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
;
345 static struct file_id_list
*file_id_list
;
348 add_file_id (const char *filename
)
350 struct file_id_list
*p
;
353 if (stat (filename
, &st
))
354 stat_fatal (filename
);
355 for (p
= file_id_list
; p
; p
= p
->next
)
356 if (p
->ino
== st
.st_ino
&& p
->dev
== st
.st_dev
)
358 ERROR ((0, 0, _("%s: file list already read"),
359 quotearg_colon (filename
)));
362 p
= xmalloc (sizeof *p
);
363 p
->next
= file_id_list
;
370 enum read_file_list_state
/* Result of reading file name from the list file */
372 file_list_success
, /* OK, name read successfully */
373 file_list_end
, /* End of list file */
374 file_list_zero
, /* Zero separator encountered where it should not */
375 file_list_skip
/* Empty (zero-length) entry encountered, skip it */
378 /* Read from FP a sequence of characters up to TERM and put them
381 static enum read_file_list_state
382 read_name_from_file (struct name_elt
*ent
)
386 FILE *fp
= ent
->v
.file
.fp
;
387 int term
= ent
->v
.file
.term
;
389 for (c
= getc (fp
); c
!= EOF
&& c
!= term
; c
= getc (fp
))
391 if (counter
== name_buffer_length
)
392 name_buffer
= x2realloc (name_buffer
, &name_buffer_length
);
393 name_buffer
[counter
++] = c
;
396 /* We have read a zero separator. The file possibly is
398 return file_list_zero
;
402 if (counter
== 0 && c
!= EOF
)
403 return file_list_skip
;
405 if (counter
== name_buffer_length
)
406 name_buffer
= x2realloc (name_buffer
, &name_buffer_length
);
407 name_buffer
[counter
] = 0;
409 return (counter
== 0 && c
== EOF
) ? file_list_end
: file_list_success
;
413 handle_option (const char *str
)
418 while (*str
&& isspace (*str
))
424 if (wordsplit (str
, &ws
, WRDSF_DEFFLAGS
|WRDSF_DOOFFS
))
425 FATAL_ERROR ((0, 0, _("cannot split string '%s': %s"),
426 str
, wordsplit_strerror (&ws
)));
427 ws
.ws_wordv
[0] = program_invocation_short_name
;
428 more_options (ws
.ws_wordc
+ws
.ws_offs
, ws
.ws_wordv
);
429 for (i
= 0; i
< ws
.ws_wordc
+ws
.ws_offs
; i
++)
430 ws
.ws_wordv
[i
] = NULL
;
432 wordsplit_free (&ws
);
437 read_next_name (struct name_elt
*ent
, struct name_elt
*ret
)
441 if (!strcmp (ent
->v
.file
.name
, "-"))
443 request_stdin ("-T");
444 ent
->v
.file
.fp
= stdin
;
448 if (add_file_id (ent
->v
.file
.name
))
450 name_list_advance ();
453 if ((ent
->v
.file
.fp
= fopen (ent
->v
.file
.name
, "r")) == NULL
)
454 open_fatal (ent
->v
.file
.name
);
460 switch (read_name_from_file (ent
))
466 WARNOPT (WARN_FILENAME_WITH_NULS
,
467 (0, 0, N_("%s: file name read contains nul character"),
468 quotearg_colon (ent
->v
.file
.name
)));
469 ent
->v
.file
.term
= 0;
471 case file_list_success
:
472 if (handle_option (name_buffer
) == 0)
477 ret
->type
= NELT_NAME
;
478 ret
->v
.name
= name_buffer
;
482 if (strcmp (ent
->v
.file
.name
, "-"))
483 fclose (ent
->v
.file
.fp
);
484 ent
->v
.file
.fp
= NULL
;
485 name_list_advance ();
492 copy_name (struct name_elt
*ep
)
499 source_len
= strlen (source
);
500 if (name_buffer_length
< source_len
)
504 name_buffer_length
*= 2;
505 if (! name_buffer_length
)
508 while (name_buffer_length
< source_len
);
511 name_buffer
= xmalloc(name_buffer_length
+ 2);
513 strcpy (name_buffer
, source
);
515 /* Zap trailing slashes. */
516 cursor
= name_buffer
+ strlen (name_buffer
) - 1;
517 while (cursor
> name_buffer
&& ISSLASH (*cursor
))
522 static int matching_flags
; /* exclude_fnmatch options */
524 /* Get the next NELT_NAME element from name_array. Result is in
525 static storage and can't be relied upon across two calls.
527 If CHANGE_DIRS is true, treat any entries of type NELT_CHDIR as
528 the request to change to the given directory.
530 Entries of type NELT_FMASK cause updates of the matching_flags
532 static struct name_elt
*
533 name_next_elt (int change_dirs
)
535 static struct name_elt entry
;
538 while ((ep
= name_head
) != NULL
)
543 name_list_advance ();
547 matching_flags
= ep
->v
.matching_flags
;
548 name_list_advance ();
552 if (read_next_name (ep
, &entry
) == 0)
560 if (chdir (name_buffer
) < 0)
561 chdir_fatal (name_buffer
);
562 name_list_advance ();
569 unquote_string (name_buffer
);
570 entry
.type
= ep
->type
;
571 entry
.v
.name
= name_buffer
;
572 name_list_advance ();
581 name_next (int change_dirs
)
583 struct name_elt
*nelt
= name_next_elt (change_dirs
);
584 return nelt
? nelt
->v
.name
: NULL
;
587 /* Gather names in a list for scanning. Could hash them later if we
590 If the names are already sorted to match the archive, we just read
591 them one by one. name_gather reads the first one, and it is called
592 by name_match as appropriate to read the next ones. At EOF, the
593 last name read is just left in the buffer. This option lets users
594 of small machines extract an arbitrary number of files by doing
595 "tar t" and editing down the list of files. */
600 /* Buffer able to hold a single name. */
601 static struct name
*buffer
= NULL
;
605 if (same_order_option
)
607 static int change_dir
;
609 while ((ep
= name_next_elt (0)) && ep
->type
== NELT_CHDIR
)
610 change_dir
= chdir_arg (xstrdup (ep
->v
.name
));
615 buffer
= make_name (ep
->v
.name
);
616 buffer
->change_dir
= change_dir
;
618 buffer
->found_count
= 0;
619 buffer
->matching_flags
= matching_flags
;
620 buffer
->directory
= NULL
;
621 buffer
->parent
= NULL
;
622 buffer
->cmdline
= true;
624 namelist
= nametail
= buffer
;
627 addname (0, change_dir
, false, NULL
);
631 /* Non sorted names -- read them all in. */
636 int change_dir0
= change_dir
;
637 while ((ep
= name_next_elt (0)) && ep
->type
== NELT_CHDIR
)
638 change_dir
= chdir_arg (xstrdup (ep
->v
.name
));
641 addname (ep
->v
.name
, change_dir
, true, NULL
);
644 if (change_dir
!= change_dir0
)
645 addname (NULL
, change_dir
, false, NULL
);
652 /* Add a name to the namelist. */
654 addname (char const *string
, int change_dir
, bool cmdline
, struct name
*parent
)
656 struct name
*name
= make_name (string
);
658 name
->prev
= nametail
;
660 name
->found_count
= 0;
661 name
->matching_flags
= matching_flags
;
662 name
->change_dir
= change_dir
;
663 name
->directory
= NULL
;
664 name
->parent
= parent
;
665 name
->cmdline
= cmdline
;
668 nametail
->next
= name
;
675 /* Find a match for FILE_NAME (whose string length is LENGTH) in the name
678 namelist_match (char const *file_name
, size_t length
)
682 for (p
= namelist
; p
; p
= p
->next
)
685 && exclude_fnmatch (p
->name
, file_name
, p
->matching_flags
))
693 remname (struct name
*name
)
697 if ((p
= name
->prev
) != NULL
)
698 p
->next
= name
->next
;
700 namelist
= name
->next
;
702 if ((p
= name
->next
) != NULL
)
703 p
->prev
= name
->prev
;
705 nametail
= name
->prev
;
708 /* Return true if and only if name FILE_NAME (from an archive) matches any
709 name from the namelist. */
711 name_match (const char *file_name
)
713 size_t length
= strlen (file_name
);
717 struct name
*cursor
= namelist
;
722 if (cursor
->name
[0] == 0)
724 chdir_do (cursor
->change_dir
);
730 cursor
= namelist_match (file_name
, length
);
733 if (!(ISSLASH (file_name
[cursor
->length
]) && recursion_option
)
734 || cursor
->found_count
== 0)
735 cursor
->found_count
++; /* remember it matched */
736 if (starting_file_option
)
742 chdir_do (cursor
->change_dir
);
744 /* We got a match. */
745 return ISFOUND (cursor
);
748 /* Filename from archive not found in namelist. If we have the whole
749 namelist here, just return 0. Otherwise, read the next name in and
750 compare it. If this was the last name, namelist->found_count will
751 remain on. If not, we loop to compare the newly read name. */
753 if (same_order_option
&& namelist
->found_count
)
755 name_gather (); /* read one more */
756 if (namelist
->found_count
)
764 /* Returns true if all names from the namelist were processed.
765 P is the stat_info of the most recently processed entry.
766 The decision is postponed until the next entry is read if:
768 1) P ended with a slash (i.e. it was a directory)
769 2) P matches any entry from the namelist *and* represents a subdirectory
770 or a file lying under this entry (in the terms of directory structure).
772 This is necessary to handle contents of directories. */
774 all_names_found (struct tar_stat_info
*p
)
776 struct name
const *cursor
;
779 if (!p
->file_name
|| occurrence_option
== 0 || p
->had_trailing_slash
)
781 len
= strlen (p
->file_name
);
782 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
784 if ((cursor
->name
[0] && !WASFOUND (cursor
))
785 || (len
>= cursor
->length
&& ISSLASH (p
->file_name
[cursor
->length
])))
792 regex_usage_warning (const char *name
)
794 static int warned_once
= 0;
796 if (warn_regex_usage
&& fnmatch_pattern_has_wildcards (name
, 0))
800 _("Pattern matching characters used in file names")));
802 _("Use --wildcards to enable pattern matching,"
803 " or --no-wildcards to suppress this warning")));
808 /* Print the names of things in the namelist that were not matched. */
810 names_notfound (void)
812 struct name
const *cursor
;
814 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
815 if (!WASFOUND (cursor
) && cursor
->name
[0])
817 regex_usage_warning (cursor
->name
);
819 (cursor
->found_count
== 0) ?
820 _("%s: Not found in archive") :
821 _("%s: Required occurrence not found in archive"),
822 quotearg_colon (cursor
->name
)));
825 /* Don't bother freeing the name list; we're about to exit. */
829 if (same_order_option
)
833 while ((name
= name_next (1)) != NULL
)
835 regex_usage_warning (name
);
836 ERROR ((0, 0, _("%s: Not found in archive"),
837 quotearg_colon (name
)));
843 label_notfound (void)
845 struct name
const *cursor
;
850 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
851 if (WASFOUND (cursor
))
855 error (0, 0, _("Archive label mismatch"));
856 set_exit_status (TAREXIT_DIFFERS
);
858 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
860 if (regex_usage_warning (cursor
->name
))
864 /* Don't bother freeing the name list; we're about to exit. */
868 if (same_order_option
)
872 while ((name
= name_next (1)) != NULL
873 && regex_usage_warning (name
) == 0)
878 /* Sorting name lists. */
880 /* Sort *singly* linked LIST of names, of given LENGTH, using COMPARE
881 to order names. Return the sorted list. Note that after calling
882 this function, the 'prev' links in list elements are messed up.
884 Apart from the type 'struct name' and the definition of SUCCESSOR,
885 this is a generic list-sorting function, but it's too painful to
886 make it both generic and portable
890 merge_sort_sll (struct name
*list
, int length
,
891 int (*compare
) (struct name
const*, struct name
const*))
893 struct name
*first_list
;
894 struct name
*second_list
;
898 struct name
**merge_point
;
902 # define SUCCESSOR(name) ((name)->next)
909 if ((*compare
) (list
, SUCCESSOR (list
)) > 0)
911 result
= SUCCESSOR (list
);
912 SUCCESSOR (result
) = list
;
913 SUCCESSOR (list
) = 0;
920 first_length
= (length
+ 1) / 2;
921 second_length
= length
/ 2;
922 for (cursor
= list
, counter
= first_length
- 1;
924 cursor
= SUCCESSOR (cursor
), counter
--)
926 second_list
= SUCCESSOR (cursor
);
927 SUCCESSOR (cursor
) = 0;
929 first_list
= merge_sort_sll (first_list
, first_length
, compare
);
930 second_list
= merge_sort_sll (second_list
, second_length
, compare
);
932 merge_point
= &result
;
933 while (first_list
&& second_list
)
934 if ((*compare
) (first_list
, second_list
) < 0)
936 cursor
= SUCCESSOR (first_list
);
937 *merge_point
= first_list
;
938 merge_point
= &SUCCESSOR (first_list
);
943 cursor
= SUCCESSOR (second_list
);
944 *merge_point
= second_list
;
945 merge_point
= &SUCCESSOR (second_list
);
946 second_list
= cursor
;
949 *merge_point
= first_list
;
951 *merge_point
= second_list
;
958 /* Sort doubly linked LIST of names, of given LENGTH, using COMPARE
959 to order names. Return the sorted list. */
961 merge_sort (struct name
*list
, int length
,
962 int (*compare
) (struct name
const*, struct name
const*))
964 struct name
*head
, *p
, *prev
;
965 head
= merge_sort_sll (list
, length
, compare
);
966 /* Fixup prev pointers */
967 for (prev
= NULL
, p
= head
; p
; prev
= p
, p
= p
->next
)
972 /* A comparison function for sorting names. Put found names last;
973 break ties by string comparison. */
976 compare_names_found (struct name
const *n1
, struct name
const *n2
)
978 int found_diff
= WASFOUND (n2
) - WASFOUND (n1
);
979 return found_diff
? found_diff
: strcmp (n1
->name
, n2
->name
);
982 /* Simple comparison by names. */
984 compare_names (struct name
const *n1
, struct name
const *n2
)
986 return strcmp (n1
->name
, n2
->name
);
990 /* Add all the dirs under ST to the namelist NAME, descending the
991 directory hierarchy recursively. */
994 add_hierarchy_to_namelist (struct tar_stat_info
*st
, struct name
*name
)
998 name
->directory
= scan_directory (st
);
999 buffer
= directory_contents (name
->directory
);
1002 struct name
*child_head
= NULL
, *child_tail
= NULL
;
1003 size_t name_length
= name
->length
;
1004 size_t allocated_length
= (name_length
>= NAME_FIELD_SIZE
1005 ? name_length
+ NAME_FIELD_SIZE
1007 char *namebuf
= xmalloc (allocated_length
+ 1);
1008 /* FIXME: + 2 above? */
1010 size_t string_length
;
1011 int change_dir
= name
->change_dir
;
1013 strcpy (namebuf
, name
->name
);
1014 if (! ISSLASH (namebuf
[name_length
- 1]))
1016 namebuf
[name_length
++] = '/';
1017 namebuf
[name_length
] = '\0';
1020 for (string
= buffer
; *string
; string
+= string_length
+ 1)
1022 string_length
= strlen (string
);
1026 struct tar_stat_info subdir
;
1029 if (allocated_length
<= name_length
+ string_length
)
1033 allocated_length
*= 2;
1034 if (! allocated_length
)
1037 while (allocated_length
<= name_length
+ string_length
);
1039 namebuf
= xrealloc (namebuf
, allocated_length
+ 1);
1041 strcpy (namebuf
+ name_length
, string
+ 1);
1042 np
= addname (namebuf
, change_dir
, false, name
);
1046 child_tail
->sibling
= np
;
1049 tar_stat_init (&subdir
);
1057 subfd
= subfile_open (st
, string
+ 1,
1058 open_read_flags
| O_DIRECTORY
);
1060 open_diag (namebuf
);
1064 if (fstat (subfd
, &subdir
.stat
) != 0)
1065 stat_diag (namebuf
);
1066 else if (! (O_DIRECTORY
|| S_ISDIR (subdir
.stat
.st_mode
)))
1069 open_diag (namebuf
);
1073 subdir
.orig_file_name
= xstrdup (namebuf
);
1074 add_hierarchy_to_namelist (&subdir
, np
);
1075 restore_parent_fd (&subdir
);
1079 tar_stat_destroy (&subdir
);
1084 name
->child
= child_head
;
1088 /* Auxiliary functions for hashed table of struct name's. */
1091 name_hash (void const *entry
, size_t n_buckets
)
1093 struct name
const *name
= entry
;
1094 return hash_string (name
->caname
, n_buckets
);
1097 /* Compare two directories for equality of their names. */
1099 name_compare (void const *entry1
, void const *entry2
)
1101 struct name
const *name1
= entry1
;
1102 struct name
const *name2
= entry2
;
1103 return strcmp (name1
->caname
, name2
->caname
) == 0;
1107 /* Rebase 'name' member of CHILD and all its siblings to
1110 rebase_child_list (struct name
*child
, struct name
*parent
)
1112 size_t old_prefix_len
= child
->parent
->length
;
1113 size_t new_prefix_len
= parent
->length
;
1114 char *new_prefix
= parent
->name
;
1116 for (; child
; child
= child
->sibling
)
1118 size_t size
= child
->length
- old_prefix_len
+ new_prefix_len
;
1119 char *newp
= xmalloc (size
+ 1);
1120 strcpy (newp
, new_prefix
);
1121 strcat (newp
, child
->name
+ old_prefix_len
);
1124 child
->length
= size
;
1126 rebase_directory (child
->directory
,
1127 child
->parent
->name
, old_prefix_len
,
1128 new_prefix
, new_prefix_len
);
1132 /* Collect all the names from argv[] (or whatever), expand them into a
1133 directory tree, and sort them. This gets only subdirectories, not
1137 collect_and_sort_names (void)
1140 struct name
*next_name
, *prev_name
= NULL
;
1142 Hash_table
*nametab
;
1147 addname (".", 0, false, NULL
);
1149 if (listed_incremental_option
)
1151 switch (chdir_count ())
1157 if (namelist
->change_dir
== 0)
1159 _("Using -C option inside file list is not "
1160 "allowed with --listed-incremental")));
1165 _("Only one -C option is allowed with "
1166 "--listed-incremental")));
1169 read_directory_file ();
1173 for (name
= namelist
; name
; name
= name
->next
, num_names
++)
1175 struct tar_stat_info st
;
1177 if (name
->found_count
|| name
->directory
)
1179 if (name
->matching_flags
& EXCLUDE_WILDCARDS
)
1180 /* NOTE: EXCLUDE_ANCHORED is not relevant here */
1181 /* FIXME: just skip regexps for now */
1183 chdir_do (name
->change_dir
);
1185 if (name
->name
[0] == 0)
1188 tar_stat_init (&st
);
1190 if (deref_stat (name
->name
, &st
.stat
) != 0)
1192 stat_diag (name
->name
);
1195 if (S_ISDIR (st
.stat
.st_mode
))
1197 int dir_fd
= openat (chdir_fd
, name
->name
,
1198 open_read_flags
| O_DIRECTORY
);
1200 open_diag (name
->name
);
1204 if (fstat (dir_fd
, &st
.stat
) != 0)
1205 stat_diag (name
->name
);
1206 else if (O_DIRECTORY
|| S_ISDIR (st
.stat
.st_mode
))
1208 st
.orig_file_name
= xstrdup (name
->name
);
1209 name
->found_count
++;
1210 add_hierarchy_to_namelist (&st
, name
);
1215 tar_stat_destroy (&st
);
1218 namelist
= merge_sort (namelist
, num_names
, compare_names
);
1221 nametab
= hash_initialize (0, 0,
1223 name_compare
, NULL
);
1224 for (name
= namelist
; name
; name
= next_name
)
1226 next_name
= name
->next
;
1227 name
->caname
= normalize_filename (name
->name
);
1230 struct name
*p
= hash_lookup (nametab
, name
);
1233 /* Keep the one listed in the command line */
1237 rebase_child_list (p
->child
, name
);
1238 hash_delete (nametab
, name
);
1239 /* FIXME: remove_directory (p->caname); ? */
1247 rebase_child_list (name
->child
, p
);
1248 /* FIXME: remove_directory (name->caname); ? */
1255 name
->found_count
= 0;
1256 if (!hash_insert (nametab
, name
))
1261 nametail
= prev_name
;
1262 hash_free (nametab
);
1264 namelist
= merge_sort (namelist
, num_names
, compare_names_found
);
1266 if (listed_incremental_option
)
1268 for (name
= namelist
; name
&& name
->name
[0] == 0; name
++)
1271 append_incremental_renames (name
->directory
);
1275 /* This is like name_match, except that
1276 1. It returns a pointer to the name it matched, and doesn't set FOUND
1277 in structure. The caller will have to do that if it wants to.
1278 2. If the namelist is empty, it returns null, unlike name_match, which
1281 name_scan (const char *file_name
)
1283 size_t length
= strlen (file_name
);
1287 struct name
*cursor
= namelist_match (file_name
, length
);
1291 /* Filename from archive not found in namelist. If we have the whole
1292 namelist here, just return 0. Otherwise, read the next name in and
1293 compare it. If this was the last name, namelist->found_count will
1294 remain on. If not, we loop to compare the newly read name. */
1296 if (same_order_option
&& namelist
&& namelist
->found_count
)
1298 name_gather (); /* read one more */
1299 if (namelist
->found_count
)
1307 /* This returns a name from the namelist which doesn't have ->found
1308 set. It sets ->found before returning, so successive calls will
1309 find and return all the non-found names in the namelist. */
1310 struct name
*gnu_list_name
;
1313 name_from_list (void)
1316 gnu_list_name
= namelist
;
1317 while (gnu_list_name
1318 && (gnu_list_name
->found_count
|| gnu_list_name
->name
[0] == 0))
1319 gnu_list_name
= gnu_list_name
->next
;
1322 gnu_list_name
->found_count
++;
1323 chdir_do (gnu_list_name
->change_dir
);
1324 return gnu_list_name
;
1330 blank_name_list (void)
1335 for (name
= namelist
; name
; name
= name
->next
)
1336 name
->found_count
= 0;
1339 /* Yield a newly allocated file name consisting of FILE_NAME concatenated to
1340 NAME, with an intervening slash if FILE_NAME does not already end in one. */
1342 new_name (const char *file_name
, const char *name
)
1344 size_t file_name_len
= strlen (file_name
);
1345 size_t namesize
= strlen (name
) + 1;
1346 int slash
= file_name_len
&& ! ISSLASH (file_name
[file_name_len
- 1]);
1347 char *buffer
= xmalloc (file_name_len
+ slash
+ namesize
);
1348 memcpy (buffer
, file_name
, file_name_len
);
1349 buffer
[file_name_len
] = '/';
1350 memcpy (buffer
+ file_name_len
+ slash
, name
, namesize
);
1354 /* Return nonzero if file NAME is excluded. */
1356 excluded_name (char const *name
)
1358 return excluded_file_name (excluded
, name
+ FILE_SYSTEM_PREFIX_LEN (name
));
1362 /* Return the size of the prefix of FILE_NAME that is removed after
1363 stripping NUM leading file name components. NUM must be
1367 stripped_prefix_len (char const *file_name
, size_t num
)
1369 char const *p
= file_name
+ FILE_SYSTEM_PREFIX_LEN (file_name
);
1370 while (ISSLASH (*p
))
1374 bool slash
= ISSLASH (*p
);
1379 return p
- file_name
;
1380 while (ISSLASH (*p
))
1387 /* Return nonzero if NAME contains ".." as a file name component. */
1389 contains_dot_dot (char const *name
)
1391 char const *p
= name
+ FILE_SYSTEM_PREFIX_LEN (name
);
1395 if (p
[0] == '.' && p
[1] == '.' && (ISSLASH (p
[2]) || !p
[2]))
1398 while (! ISSLASH (*p
))