1 /* Various processing of names.
3 Copyright (C) 1988, 1992, 1994, 1996, 1997, 1998, 1999, 2000, 2001,
4 2003, 2004, 2005, 2006 Free 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 2, 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, write to the Free Software Foundation, Inc.,
18 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
28 /* User and group names. */
30 struct group
*getgrnam ();
31 struct passwd
*getpwnam ();
32 #if ! HAVE_DECL_GETPWUID
33 struct passwd
*getpwuid ();
35 #if ! HAVE_DECL_GETGRGID
36 struct group
*getgrgid ();
39 /* Make sure you link with the proper libraries if you are running the
40 Yellow Peril (thanks for the good laugh, Ian J.!), or, euh... NIS.
41 This code should also be modified for non-UNIX systems to do something
44 static char *cached_uname
;
45 static char *cached_gname
;
47 static uid_t cached_uid
; /* valid only if cached_uname is not empty */
48 static gid_t cached_gid
; /* valid only if cached_gname is not empty */
50 /* These variables are valid only if nonempty. */
51 static char *cached_no_such_uname
;
52 static char *cached_no_such_gname
;
54 /* These variables are valid only if nonzero. It's not worth optimizing
55 the case for weird systems where 0 is not a valid uid or gid. */
56 static uid_t cached_no_such_uid
;
57 static gid_t cached_no_such_gid
;
59 static void register_individual_file (char const *name
);
61 /* Given UID, find the corresponding UNAME. */
63 uid_to_uname (uid_t uid
, char **uname
)
65 struct passwd
*passwd
;
67 if (uid
!= 0 && uid
== cached_no_such_uid
)
69 *uname
= xstrdup ("");
73 if (!cached_uname
|| uid
!= cached_uid
)
75 passwd
= getpwuid (uid
);
79 assign_string (&cached_uname
, passwd
->pw_name
);
83 cached_no_such_uid
= uid
;
84 *uname
= xstrdup ("");
88 *uname
= xstrdup (cached_uname
);
91 /* Given GID, find the corresponding GNAME. */
93 gid_to_gname (gid_t gid
, char **gname
)
97 if (gid
!= 0 && gid
== cached_no_such_gid
)
99 *gname
= xstrdup ("");
103 if (!cached_gname
|| gid
!= cached_gid
)
105 group
= getgrgid (gid
);
109 assign_string (&cached_gname
, group
->gr_name
);
113 cached_no_such_gid
= gid
;
114 *gname
= xstrdup ("");
118 *gname
= xstrdup (cached_gname
);
121 /* Given UNAME, set the corresponding UID and return 1, or else, return 0. */
123 uname_to_uid (char const *uname
, uid_t
*uidp
)
125 struct passwd
*passwd
;
127 if (cached_no_such_uname
128 && strcmp (uname
, cached_no_such_uname
) == 0)
132 || uname
[0] != cached_uname
[0]
133 || strcmp (uname
, cached_uname
) != 0)
135 passwd
= getpwnam (uname
);
138 cached_uid
= passwd
->pw_uid
;
139 assign_string (&cached_uname
, passwd
->pw_name
);
143 assign_string (&cached_no_such_uname
, uname
);
151 /* Given GNAME, set the corresponding GID and return 1, or else, return 0. */
153 gname_to_gid (char const *gname
, gid_t
*gidp
)
157 if (cached_no_such_gname
158 && strcmp (gname
, cached_no_such_gname
) == 0)
162 || gname
[0] != cached_gname
[0]
163 || strcmp (gname
, cached_gname
) != 0)
165 group
= getgrnam (gname
);
168 cached_gid
= group
->gr_gid
;
169 assign_string (&cached_gname
, gname
);
173 assign_string (&cached_no_such_gname
, gname
);
182 /* Names from the command call. */
184 static struct name
*namelist
; /* first name in list, if any */
185 static struct name
**nametail
= &namelist
; /* end of name list */
186 static const char **name_array
; /* store an array of names */
187 static int allocated_names
; /* how big is the array? */
188 static int names
; /* how many entries does it have? */
189 static int name_index
; /* how many of the entries have we scanned? */
191 /* Initialize structures. */
195 allocated_names
= 10;
196 name_array
= xmalloc (sizeof (const char *) * allocated_names
);
200 /* Add NAME at end of name_array, reallocating it as necessary. */
202 name_add (const char *name
)
204 if (names
== allocated_names
)
206 allocated_names
*= 2;
208 xrealloc (name_array
, sizeof (const char *) * allocated_names
);
210 name_array
[names
++] = name
;
214 /* Names from external name file. */
216 static char *name_buffer
; /* buffer to hold the current file name */
217 static size_t name_buffer_length
; /* allocated length of name_buffer */
219 /* FIXME: I should better check more closely. It seems at first glance that
220 is_pattern is only used when reading a file, and ignored for all
221 command line arguments. */
224 is_pattern (const char *string
)
226 return strchr (string
, '*') || strchr (string
, '[') || strchr (string
, '?');
229 /* Set up to gather file names for tar. They can either come from a
230 file or were saved from decoding arguments. */
234 name_buffer
= xmalloc (NAME_FIELD_SIZE
+ 2);
235 name_buffer_length
= NAME_FIELD_SIZE
;
245 /* Get the next name from ARGV or the file of names. Result is in
246 static storage and can't be relied upon across two calls.
248 If CHANGE_DIRS is true, treat a filename of the form "-C" as
249 meaning that the next filename is the name of a directory to change
250 to. If filename_terminator is NUL, CHANGE_DIRS is effectively
253 name_next (int change_dirs
)
259 if (filename_terminator
== '\0')
262 while (name_index
!= names
)
265 source
= name_array
[name_index
++];
266 source_len
= strlen (source
);
267 if (name_buffer_length
< source_len
)
271 name_buffer_length
*= 2;
272 if (! name_buffer_length
)
275 while (name_buffer_length
< source_len
);
278 name_buffer
= xmalloc (name_buffer_length
+ 2);
280 strcpy (name_buffer
, source
);
282 /* Zap trailing slashes. */
284 cursor
= name_buffer
+ strlen (name_buffer
) - 1;
285 while (cursor
> name_buffer
&& ISSLASH (*cursor
))
290 if (chdir (name_buffer
) < 0)
291 chdir_fatal (name_buffer
);
294 else if (change_dirs
&& strcmp (name_buffer
, "-C") == 0)
299 unquote_string (name_buffer
);
300 if (incremental_option
)
301 register_individual_file (name_buffer
);
309 /* Gather names in a list for scanning. Could hash them later if we
312 If the names are already sorted to match the archive, we just read
313 them one by one. name_gather reads the first one, and it is called
314 by name_match as appropriate to read the next ones. At EOF, the
315 last name read is just left in the buffer. This option lets users
316 of small machines extract an arbitrary number of files by doing
317 "tar t" and editing down the list of files. */
322 /* Buffer able to hold a single name. */
323 static struct name
*buffer
;
324 static size_t allocated_size
;
328 if (same_order_option
)
330 static int change_dir
;
332 if (allocated_size
== 0)
334 allocated_size
= offsetof (struct name
, name
) + NAME_FIELD_SIZE
+ 1;
335 buffer
= xmalloc (allocated_size
);
336 /* FIXME: This memset is overkill, and ugly... */
337 memset (buffer
, 0, allocated_size
);
340 while ((name
= name_next (0)) && strcmp (name
, "-C") == 0)
342 char const *dir
= name_next (0);
344 FATAL_ERROR ((0, 0, _("Missing file name after -C")));
345 change_dir
= chdir_arg (xstrdup (dir
));
351 buffer
->length
= strlen (name
);
352 needed_size
= offsetof (struct name
, name
) + buffer
->length
+ 1;
353 if (allocated_size
< needed_size
)
358 if (! allocated_size
)
361 while (allocated_size
< needed_size
);
363 buffer
= xrealloc (buffer
, allocated_size
);
365 buffer
->change_dir
= change_dir
;
366 strcpy (buffer
->name
, name
);
368 buffer
->found_count
= 0;
371 nametail
= &namelist
->next
;
374 addname (0, change_dir
);
378 /* Non sorted names -- read them all in. */
383 int change_dir0
= change_dir
;
384 while ((name
= name_next (0)) && strcmp (name
, "-C") == 0)
386 char const *dir
= name_next (0);
388 FATAL_ERROR ((0, 0, _("Missing file name after -C")));
389 change_dir
= chdir_arg (xstrdup (dir
));
392 addname (name
, change_dir
);
395 if (change_dir
!= change_dir0
)
396 addname (0, change_dir
);
403 /* Add a name to the namelist. */
405 addname (char const *string
, int change_dir
)
407 size_t length
= string
? strlen (string
) : 0;
408 struct name
*name
= xmalloc (offsetof (struct name
, name
) + length
+ 1);
413 strcpy (name
->name
, string
);
419 /* FIXME: This initialization (and the byte of memory that it
420 initializes) is probably not needed, but we are currently in
421 bug-fix mode so we'll leave it in for now. */
426 name
->length
= length
;
427 name
->found_count
= 0;
428 name
->regexp
= 0; /* assume not a regular expression */
429 name
->firstch
= 1; /* assume first char is literal */
430 name
->change_dir
= change_dir
;
431 name
->dir_contents
= 0;
434 if (string
&& is_pattern (string
))
437 if (string
[0] == '*' || string
[0] == '[' || string
[0] == '?')
442 nametail
= &name
->next
;
446 /* Find a match for FILE_NAME (whose string length is LENGTH) in the name
449 namelist_match (char const *file_name
, size_t length
, bool exact
)
453 for (p
= namelist
; p
; p
= p
->next
)
455 /* If first chars don't match, quick skip. */
457 if (p
->firstch
&& p
->name
[0] != file_name
[0])
461 ? fnmatch (p
->name
, file_name
, recursion_option
) == 0
462 : exact
? (p
->length
== length
463 && memcmp (file_name
, p
->name
, length
) == 0)
464 : (p
->length
<= length
465 && (file_name
[p
->length
] == '\0'
466 || (ISSLASH (file_name
[p
->length
]) && recursion_option
))
467 && memcmp (file_name
, p
->name
, p
->length
) == 0))
474 /* Return true if and only if name FILE_NAME (from an archive) matches any
475 name from the namelist. */
477 name_match (const char *file_name
)
479 size_t length
= strlen (file_name
);
483 struct name
*cursor
= namelist
;
490 chdir_do (cursor
->change_dir
);
492 nametail
= &namelist
;
496 cursor
= namelist_match (file_name
, length
, false);
499 if (!(ISSLASH (file_name
[cursor
->length
]) && recursion_option
)
500 || cursor
->found_count
== 0)
501 cursor
->found_count
++; /* remember it matched */
502 if (starting_file_option
)
506 nametail
= &namelist
;
508 chdir_do (cursor
->change_dir
);
510 /* We got a match. */
511 return ISFOUND (cursor
);
514 /* Filename from archive not found in namelist. If we have the whole
515 namelist here, just return 0. Otherwise, read the next name in and
516 compare it. If this was the last name, namelist->found_count will
517 remain on. If not, we loop to compare the newly read name. */
519 if (same_order_option
&& namelist
->found_count
)
521 name_gather (); /* read one more */
522 if (namelist
->found_count
)
530 /* Returns true if all names from the namelist were processed.
531 P is the stat_info of the most recently processed entry.
532 The decision is postponed until the next entry is read if:
534 1) P ended with a slash (i.e. it was a directory)
535 2) P matches any entry from the namelist *and* represents a subdirectory
536 or a file lying under this entry (in the terms of directory structure).
538 This is necessary to handle contents of directories. */
540 all_names_found (struct tar_stat_info
*p
)
542 struct name
const *cursor
;
545 if (test_label_option
)
547 if (!p
->file_name
|| occurrence_option
== 0 || p
->had_trailing_slash
)
549 len
= strlen (p
->file_name
);
550 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
553 || (!WASFOUND(cursor
) && !cursor
->fake
)
554 || (len
>= cursor
->length
&& ISSLASH (p
->file_name
[cursor
->length
])))
560 /* Print the names of things in the namelist that were not matched. */
562 names_notfound (void)
564 struct name
const *cursor
;
566 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
567 if (!WASFOUND(cursor
) && !cursor
->fake
)
569 if (cursor
->found_count
== 0)
570 ERROR ((0, 0, _("%s: Not found in archive"),
571 quotearg_colon (cursor
->name
)));
573 ERROR ((0, 0, _("%s: Required occurrence not found in archive"),
574 quotearg_colon (cursor
->name
)));
577 /* Don't bother freeing the name list; we're about to exit. */
579 nametail
= &namelist
;
581 if (same_order_option
)
585 while ((name
= name_next (1)) != NULL
)
586 ERROR ((0, 0, _("%s: Not found in archive"),
587 quotearg_colon (name
)));
591 /* Sorting name lists. */
593 /* Sort linked LIST of names, of given LENGTH, using COMPARE to order
594 names. Return the sorted list. Apart from the type `struct name'
595 and the definition of SUCCESSOR, this is a generic list-sorting
596 function, but it's too painful to make it both generic and portable
600 merge_sort (struct name
*list
, int length
,
601 int (*compare
) (struct name
const*, struct name
const*))
603 struct name
*first_list
;
604 struct name
*second_list
;
608 struct name
**merge_point
;
612 # define SUCCESSOR(name) ((name)->next)
619 if ((*compare
) (list
, SUCCESSOR (list
)) > 0)
621 result
= SUCCESSOR (list
);
622 SUCCESSOR (result
) = list
;
623 SUCCESSOR (list
) = 0;
630 first_length
= (length
+ 1) / 2;
631 second_length
= length
/ 2;
632 for (cursor
= list
, counter
= first_length
- 1;
634 cursor
= SUCCESSOR (cursor
), counter
--)
636 second_list
= SUCCESSOR (cursor
);
637 SUCCESSOR (cursor
) = 0;
639 first_list
= merge_sort (first_list
, first_length
, compare
);
640 second_list
= merge_sort (second_list
, second_length
, compare
);
642 merge_point
= &result
;
643 while (first_list
&& second_list
)
644 if ((*compare
) (first_list
, second_list
) < 0)
646 cursor
= SUCCESSOR (first_list
);
647 *merge_point
= first_list
;
648 merge_point
= &SUCCESSOR (first_list
);
653 cursor
= SUCCESSOR (second_list
);
654 *merge_point
= second_list
;
655 merge_point
= &SUCCESSOR (second_list
);
656 second_list
= cursor
;
659 *merge_point
= first_list
;
661 *merge_point
= second_list
;
668 /* A comparison function for sorting names. Put found names last;
669 break ties by string comparison. */
672 compare_names (struct name
const *n1
, struct name
const *n2
)
674 int found_diff
= WASFOUND(n2
) - WASFOUND(n1
);
675 return found_diff
? found_diff
: strcmp (n1
->name
, n2
->name
);
678 /* Add all the dirs under NAME, which names a directory, to the namelist.
679 If any of the files is a directory, recurse on the subdirectory.
680 DEVICE is the device not to leave, if the -l option is specified. */
683 add_hierarchy_to_namelist (struct name
*name
, dev_t device
)
685 char *file_name
= name
->name
;
686 char *buffer
= get_directory_contents (file_name
, device
);
689 name
->dir_contents
= "\0\0\0\0";
692 size_t name_length
= name
->length
;
693 size_t allocated_length
= (name_length
>= NAME_FIELD_SIZE
694 ? name_length
+ NAME_FIELD_SIZE
696 char *namebuf
= xmalloc (allocated_length
+ 1);
697 /* FIXME: + 2 above? */
699 size_t string_length
;
700 int change_dir
= name
->change_dir
;
702 name
->dir_contents
= buffer
;
703 strcpy (namebuf
, file_name
);
704 if (! ISSLASH (namebuf
[name_length
- 1]))
706 namebuf
[name_length
++] = '/';
707 namebuf
[name_length
] = '\0';
710 for (string
= buffer
; *string
; string
+= string_length
+ 1)
712 string_length
= strlen (string
);
717 if (allocated_length
<= name_length
+ string_length
)
721 allocated_length
*= 2;
722 if (! allocated_length
)
725 while (allocated_length
<= name_length
+ string_length
);
727 namebuf
= xrealloc (namebuf
, allocated_length
+ 1);
729 strcpy (namebuf
+ name_length
, string
+ 1);
730 np
= addname (namebuf
, change_dir
);
732 add_hierarchy_to_namelist (np
, device
);
740 /* Collect all the names from argv[] (or whatever), expand them into a
741 directory tree, and sort them. This gets only subdirectories, not
745 collect_and_sort_names (void)
748 struct name
*next_name
;
754 if (listed_incremental_option
)
755 read_directory_file ();
760 for (name
= namelist
; name
; name
= next_name
)
762 next_name
= name
->next
;
763 if (name
->found_count
|| name
->dir_contents
)
765 if (name
->regexp
) /* FIXME: just skip regexps for now */
767 chdir_do (name
->change_dir
);
771 if (deref_stat (dereference_option
, name
->name
, &statbuf
) != 0)
773 stat_diag (name
->name
);
776 if (S_ISDIR (statbuf
.st_mode
))
779 add_hierarchy_to_namelist (name
, statbuf
.st_dev
);
784 for (name
= namelist
; name
; name
= name
->next
)
786 namelist
= merge_sort (namelist
, num_names
, compare_names
);
788 for (name
= namelist
; name
; name
= name
->next
)
789 name
->found_count
= 0;
792 /* This is like name_match, except that
793 1. It returns a pointer to the name it matched, and doesn't set FOUND
794 in structure. The caller will have to do that if it wants to.
795 2. If the namelist is empty, it returns null, unlike name_match, which
797 3. The second argument (EXACT) controls matching algorithm. If it
798 is TRUE, the exact matching is used. However, regular expressions are
799 always matched as such, no matter what the value of EXACT is. */
801 name_scan (const char *file_name
, bool exact
)
803 size_t length
= strlen (file_name
);
807 struct name
*cursor
= namelist_match (file_name
, length
, exact
);
811 /* Filename from archive not found in namelist. If we have the whole
812 namelist here, just return 0. Otherwise, read the next name in and
813 compare it. If this was the last name, namelist->found_count will
814 remain on. If not, we loop to compare the newly read name. */
816 if (same_order_option
&& namelist
&& namelist
->found_count
)
818 name_gather (); /* read one more */
819 if (namelist
->found_count
)
827 /* This returns a name from the namelist which doesn't have ->found
828 set. It sets ->found before returning, so successive calls will
829 find and return all the non-found names in the namelist. */
830 struct name
*gnu_list_name
;
833 name_from_list (void)
836 gnu_list_name
= namelist
;
837 while (gnu_list_name
&& (gnu_list_name
->found_count
|| gnu_list_name
->fake
))
838 gnu_list_name
= gnu_list_name
->next
;
841 gnu_list_name
->found_count
++;
842 chdir_do (gnu_list_name
->change_dir
);
843 return gnu_list_name
->name
;
849 blank_name_list (void)
854 for (name
= namelist
; name
; name
= name
->next
)
855 name
->found_count
= 0;
858 /* Yield a newly allocated file name consisting of FILE_NAME concatenated to
859 NAME, with an intervening slash if FILE_NAME does not already end in one. */
861 new_name (const char *file_name
, const char *name
)
863 size_t file_name_len
= strlen (file_name
);
864 size_t namesize
= strlen (name
) + 1;
865 int slash
= file_name_len
&& ! ISSLASH (file_name
[file_name_len
- 1]);
866 char *buffer
= xmalloc (file_name_len
+ slash
+ namesize
);
867 memcpy (buffer
, file_name
, file_name_len
);
868 buffer
[file_name_len
] = '/';
869 memcpy (buffer
+ file_name_len
+ slash
, name
, namesize
);
873 /* Return nonzero if file NAME is excluded. */
875 excluded_name (char const *name
)
877 return excluded_file_name (excluded
, name
+ FILE_SYSTEM_PREFIX_LEN (name
));
880 /* Names to avoid dumping. */
881 static Hash_table
*avoided_name_table
;
883 /* Remember to not archive NAME. */
885 add_avoided_name (char const *name
)
887 hash_string_insert (&avoided_name_table
, name
);
890 /* Should NAME be avoided when archiving? */
892 is_avoided_name (char const *name
)
894 return hash_string_lookup (avoided_name_table
, name
);
898 static Hash_table
*individual_file_table
;
901 register_individual_file (char const *name
)
905 if (deref_stat (dereference_option
, name
, &st
) != 0)
906 return; /* Will be complained about later */
907 if (S_ISDIR (st
.st_mode
))
910 hash_string_insert (&individual_file_table
, name
);
914 is_individual_file (char const *name
)
916 return hash_string_lookup (individual_file_table
, name
);
921 /* Return the size of the prefix of FILE_NAME that is removed after
922 stripping NUM leading file name components. NUM must be
926 stripped_prefix_len (char const *file_name
, size_t num
)
928 char const *p
= file_name
+ FILE_SYSTEM_PREFIX_LEN (file_name
);
933 bool slash
= ISSLASH (*p
);
938 return p
- file_name
;
946 /* Return nonzero if NAME contains ".." as a file name component. */
948 contains_dot_dot (char const *name
)
950 char const *p
= name
+ FILE_SYSTEM_PREFIX_LEN (name
);
954 if (p
[0] == '.' && p
[1] == '.' && (ISSLASH (p
[2]) || !p
[2]))
962 while (! ISSLASH (*p
));