1 /* Various processing of names.
3 Copyright 1988, 1992, 1994, 1996, 1997, 1998, 1999, 2000, 2001 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 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 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
30 /* User and group names. */
32 struct group
*getgrnam ();
33 struct passwd
*getpwnam ();
34 #if ! HAVE_DECL_GETPWUID
35 struct passwd
*getpwuid ();
37 #if ! HAVE_DECL_GETGRGID
38 struct group
*getgrgid ();
41 /* Make sure you link with the proper libraries if you are running the
42 Yellow Peril (thanks for the good laugh, Ian J.!), or, euh... NIS.
43 This code should also be modified for non-UNIX systems to do something
46 static char cached_uname
[UNAME_FIELD_SIZE
];
47 static char cached_gname
[GNAME_FIELD_SIZE
];
49 static uid_t cached_uid
; /* valid only if cached_uname is not empty */
50 static gid_t cached_gid
; /* valid only if cached_gname is not empty */
52 /* These variables are valid only if nonempty. */
53 static char cached_no_such_uname
[UNAME_FIELD_SIZE
];
54 static char cached_no_such_gname
[GNAME_FIELD_SIZE
];
56 /* These variables are valid only if nonzero. It's not worth optimizing
57 the case for weird systems where 0 is not a valid uid or gid. */
58 static uid_t cached_no_such_uid
;
59 static gid_t cached_no_such_gid
;
61 /* Given UID, find the corresponding UNAME. */
63 uid_to_uname (uid_t uid
, char uname
[UNAME_FIELD_SIZE
])
65 struct passwd
*passwd
;
67 if (uid
!= 0 && uid
== cached_no_such_uid
)
73 if (!cached_uname
[0] || uid
!= cached_uid
)
75 passwd
= getpwuid (uid
);
79 strncpy (cached_uname
, passwd
->pw_name
, UNAME_FIELD_SIZE
);
83 cached_no_such_uid
= uid
;
88 strncpy (uname
, cached_uname
, UNAME_FIELD_SIZE
);
91 /* Given GID, find the corresponding GNAME. */
93 gid_to_gname (gid_t gid
, char gname
[GNAME_FIELD_SIZE
])
97 if (gid
!= 0 && gid
== cached_no_such_gid
)
103 if (!cached_gname
[0] || gid
!= cached_gid
)
105 group
= getgrgid (gid
);
109 strncpy (cached_gname
, group
->gr_name
, GNAME_FIELD_SIZE
);
113 cached_no_such_gid
= gid
;
118 strncpy (gname
, cached_gname
, GNAME_FIELD_SIZE
);
121 /* Given UNAME, set the corresponding UID and return 1, or else, return 0. */
123 uname_to_uid (char uname
[UNAME_FIELD_SIZE
], uid_t
*uidp
)
125 struct passwd
*passwd
;
127 if (cached_no_such_uname
[0]
128 && strncmp (uname
, cached_no_such_uname
, UNAME_FIELD_SIZE
) == 0)
132 || uname
[0] != cached_uname
[0]
133 || strncmp (uname
, cached_uname
, UNAME_FIELD_SIZE
) != 0)
135 passwd
= getpwnam (uname
);
138 cached_uid
= passwd
->pw_uid
;
139 strncpy (cached_uname
, uname
, UNAME_FIELD_SIZE
);
143 strncpy (cached_no_such_uname
, uname
, UNAME_FIELD_SIZE
);
151 /* Given GNAME, set the corresponding GID and return 1, or else, return 0. */
153 gname_to_gid (char gname
[GNAME_FIELD_SIZE
], gid_t
*gidp
)
157 if (cached_no_such_gname
[0]
158 && strncmp (gname
, cached_no_such_gname
, GNAME_FIELD_SIZE
) == 0)
162 || gname
[0] != cached_gname
[0]
163 || strncmp (gname
, cached_gname
, GNAME_FIELD_SIZE
) != 0)
165 group
= getgrnam (gname
);
168 cached_gid
= group
->gr_gid
;
169 strncpy (cached_gname
, gname
, GNAME_FIELD_SIZE
);
173 strncpy (cached_no_such_gname
, gname
, GNAME_FIELD_SIZE
);
181 /* Names from the command call. */
183 static struct name
*namelist
; /* first name in list, if any */
184 static struct name
**nametail
= &namelist
; /* end of name list */
185 static const char **name_array
; /* store an array of names */
186 static int allocated_names
; /* how big is the array? */
187 static int names
; /* how many entries does it have? */
188 static int name_index
; /* how many of the entries have we scanned? */
190 /* Initialize structures. */
194 allocated_names
= 10;
195 name_array
= xmalloc (sizeof (const char *) * allocated_names
);
199 /* Add NAME at end of name_array, reallocating it as necessary. */
201 name_add (const char *name
)
203 if (names
== allocated_names
)
205 allocated_names
*= 2;
207 xrealloc (name_array
, sizeof (const char *) * allocated_names
);
209 name_array
[names
++] = name
;
212 /* Names from external name file. */
214 static FILE *name_file
; /* file to read names from */
215 static char *name_buffer
; /* buffer to hold the current file name */
216 static size_t name_buffer_length
; /* allocated length of name_buffer */
218 /* FIXME: I should better check more closely. It seems at first glance that
219 is_pattern is only used when reading a file, and ignored for all
220 command line arguments. */
223 is_pattern (const char *string
)
225 return strchr (string
, '*') || strchr (string
, '[') || strchr (string
, '?');
228 /* Set up to gather file names for tar. They can either come from a
229 file or were saved from decoding arguments. */
231 name_init (int argc
, char *const *argv
)
233 name_buffer
= xmalloc (NAME_FIELD_SIZE
+ 2);
234 name_buffer_length
= NAME_FIELD_SIZE
;
236 if (files_from_option
)
238 if (!strcmp (files_from_option
, "-"))
240 request_stdin ("-T");
243 else if (name_file
= fopen (files_from_option
, "r"), !name_file
)
244 open_fatal (files_from_option
);
255 /* Read the next filename from name_file and null-terminate it. Put
256 it into name_buffer, reallocating and adjusting name_buffer_length
257 if necessary. Return 0 at end of file, 1 otherwise. */
259 read_name_from_file (void)
264 /* FIXME: getc may be called even if character was EOF the last time here. */
266 /* FIXME: This + 2 allocation might serve no purpose. */
268 while (character
= getc (name_file
),
269 character
!= EOF
&& character
!= filename_terminator
)
271 if (counter
== name_buffer_length
)
273 name_buffer_length
+= NAME_FIELD_SIZE
;
274 name_buffer
= xrealloc (name_buffer
, name_buffer_length
+ 2);
276 name_buffer
[counter
++] = character
;
279 if (counter
== 0 && character
== EOF
)
282 if (counter
== name_buffer_length
)
284 name_buffer_length
+= NAME_FIELD_SIZE
;
285 name_buffer
= xrealloc (name_buffer
, name_buffer_length
+ 2);
287 name_buffer
[counter
] = '\0';
292 /* Get the next name from ARGV or the file of names. Result is in
293 static storage and can't be relied upon across two calls.
295 If CHANGE_DIRS is true, treat a filename of the form "-C" as
296 meaning that the next filename is the name of a directory to change
297 to. If filename_terminator is NUL, CHANGE_DIRS is effectively
300 name_next (int change_dirs
)
306 if (filename_terminator
== '\0')
311 /* Get a name, either from file or from saved arguments. */
313 if (name_index
== names
)
317 if (! read_name_from_file ())
322 source
= name_array
[name_index
++];
323 if (strlen (source
) > name_buffer_length
)
326 name_buffer_length
= strlen (source
);
327 name_buffer
= xmalloc (name_buffer_length
+ 2);
329 strcpy (name_buffer
, source
);
332 /* Zap trailing slashes. */
334 cursor
= name_buffer
+ strlen (name_buffer
) - 1;
335 while (cursor
> name_buffer
&& ISSLASH (*cursor
))
340 if (chdir (name_buffer
) < 0)
341 chdir_fatal (name_buffer
);
344 else if (change_dirs
&& strcmp (name_buffer
, "-C") == 0)
348 unquote_string (name_buffer
);
353 /* No more names in file. */
355 if (name_file
&& chdir_flag
)
356 FATAL_ERROR ((0, 0, _("Missing file name after -C")));
361 /* Close the name file, if any. */
365 if (name_file
&& name_file
!= stdin
)
366 if (fclose (name_file
) != 0)
367 close_error (name_buffer
);
370 /* Gather names in a list for scanning. Could hash them later if we
373 If the names are already sorted to match the archive, we just read
374 them one by one. name_gather reads the first one, and it is called
375 by name_match as appropriate to read the next ones. At EOF, the
376 last name read is just left in the buffer. This option lets users
377 of small machines extract an arbitrary number of files by doing
378 "tar t" and editing down the list of files. */
383 /* Buffer able to hold a single name. */
384 static struct name
*buffer
;
385 static size_t allocated_length
;
389 if (same_order_option
)
391 static int change_dir
;
393 if (allocated_length
== 0)
395 allocated_length
= sizeof (struct name
) + NAME_FIELD_SIZE
;
396 buffer
= xmalloc (allocated_length
);
397 /* FIXME: This memset is overkill, and ugly... */
398 memset (buffer
, 0, allocated_length
);
401 while ((name
= name_next (0)) && strcmp (name
, "-C") == 0)
403 char const *dir
= name_next (0);
405 FATAL_ERROR ((0, 0, _("Missing file name after -C")));
406 change_dir
= chdir_arg (xstrdup (dir
));
411 buffer
->length
= strlen (name
);
412 if (sizeof (struct name
) + buffer
->length
>= allocated_length
)
414 allocated_length
= sizeof (struct name
) + buffer
->length
;
415 buffer
= xrealloc (buffer
, allocated_length
);
417 buffer
->change_dir
= change_dir
;
418 memcpy (buffer
->name
, name
, buffer
->length
+ 1);
423 nametail
= &namelist
->next
;
428 /* Non sorted names -- read them all in. */
433 int change_dir0
= change_dir
;
434 while ((name
= name_next (0)) && strcmp (name
, "-C") == 0)
436 char const *dir
= name_next (0);
438 FATAL_ERROR ((0, 0, _("Missing file name after -C")));
439 change_dir
= chdir_arg (xstrdup (dir
));
442 addname (name
, change_dir
);
445 if (change_dir
!= change_dir0
)
446 addname (0, change_dir
);
453 /* Add a name to the namelist. */
455 addname (char const *string
, int change_dir
)
460 length
= string
? strlen (string
) : 0;
461 name
= xmalloc (sizeof (struct name
) + length
);
462 memset (name
, 0, sizeof (struct name
) + length
);
468 name
->length
= length
;
469 memcpy (name
->name
, string
, length
+ 1);
475 name
->regexp
= 0; /* assume not a regular expression */
476 name
->firstch
= 1; /* assume first char is literal */
477 name
->change_dir
= change_dir
;
478 name
->dir_contents
= 0;
480 if (string
&& is_pattern (string
))
483 if (string
[0] == '*' || string
[0] == '[' || string
[0] == '?')
488 nametail
= &name
->next
;
492 /* Find a match for PATH (whose string length is LENGTH) in the name
495 namelist_match (char const *path
, size_t length
)
499 for (p
= namelist
; p
; p
= p
->next
)
501 /* If first chars don't match, quick skip. */
503 if (p
->firstch
&& p
->name
[0] != path
[0])
507 ? fnmatch (p
->name
, path
, recursion_option
) == 0
508 : (p
->length
<= length
509 && (path
[p
->length
] == '\0' || ISSLASH (path
[p
->length
]))
510 && memcmp (path
, p
->name
, p
->length
) == 0))
517 /* Return true if and only if name PATH (from an archive) matches any
518 name from the namelist. */
520 name_match (const char *path
)
522 size_t length
= strlen (path
);
526 struct name
*cursor
= namelist
;
529 return ! files_from_option
;
533 chdir_do (cursor
->change_dir
);
535 nametail
= &namelist
;
536 return ! files_from_option
;
539 cursor
= namelist_match (path
, length
);
542 cursor
->found
= 1; /* remember it matched */
543 if (starting_file_option
)
547 nametail
= &namelist
;
549 chdir_do (cursor
->change_dir
);
551 /* We got a match. */
555 /* Filename from archive not found in namelist. If we have the whole
556 namelist here, just return 0. Otherwise, read the next name in and
557 compare it. If this was the last name, namelist->found will remain
558 on. If not, we loop to compare the newly read name. */
560 if (same_order_option
&& namelist
->found
)
562 name_gather (); /* read one more */
571 /* Print the names of things in the namelist that were not matched. */
573 names_notfound (void)
575 struct name
const *cursor
;
577 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
578 if (!cursor
->found
&& !cursor
->fake
)
579 ERROR ((0, 0, _("%s: Not found in archive"),
580 quotearg_colon (cursor
->name
)));
582 /* Don't bother freeing the name list; we're about to exit. */
584 nametail
= &namelist
;
586 if (same_order_option
)
590 while (name
= name_next (1), name
)
591 ERROR ((0, 0, _("%s: Not found in archive"),
592 quotearg_colon (name
)));
596 /* Sorting name lists. */
598 /* Sort linked LIST of names, of given LENGTH, using COMPARE to order
599 names. Return the sorted list. Apart from the type `struct name'
600 and the definition of SUCCESSOR, this is a generic list-sorting
601 function, but it's too painful to make it both generic and portable
605 merge_sort (struct name
*list
, int length
,
606 int (*compare
) (struct name
const*, struct name
const*))
608 struct name
*first_list
;
609 struct name
*second_list
;
613 struct name
**merge_point
;
617 # define SUCCESSOR(name) ((name)->next)
624 if ((*compare
) (list
, SUCCESSOR (list
)) > 0)
626 result
= SUCCESSOR (list
);
627 SUCCESSOR (result
) = list
;
628 SUCCESSOR (list
) = 0;
635 first_length
= (length
+ 1) / 2;
636 second_length
= length
/ 2;
637 for (cursor
= list
, counter
= first_length
- 1;
639 cursor
= SUCCESSOR (cursor
), counter
--)
641 second_list
= SUCCESSOR (cursor
);
642 SUCCESSOR (cursor
) = 0;
644 first_list
= merge_sort (first_list
, first_length
, compare
);
645 second_list
= merge_sort (second_list
, second_length
, compare
);
647 merge_point
= &result
;
648 while (first_list
&& second_list
)
649 if ((*compare
) (first_list
, second_list
) < 0)
651 cursor
= SUCCESSOR (first_list
);
652 *merge_point
= first_list
;
653 merge_point
= &SUCCESSOR (first_list
);
658 cursor
= SUCCESSOR (second_list
);
659 *merge_point
= second_list
;
660 merge_point
= &SUCCESSOR (second_list
);
661 second_list
= cursor
;
664 *merge_point
= first_list
;
666 *merge_point
= second_list
;
673 /* A comparison function for sorting names. Put found names last;
674 break ties by string comparison. */
677 compare_names (struct name
const *n1
, struct name
const *n2
)
679 int found_diff
= n2
->found
- n1
->found
;
680 return found_diff
? found_diff
: strcmp (n1
->name
, n2
->name
);
683 /* Add all the dirs under NAME, which names a directory, to the namelist.
684 If any of the files is a directory, recurse on the subdirectory.
685 DEVICE is the device not to leave, if the -l option is specified. */
688 add_hierarchy_to_namelist (struct name
*name
, dev_t device
)
690 char *path
= name
->name
;
691 char *buffer
= get_directory_contents (path
, device
);
694 name
->dir_contents
= "\0\0\0\0";
697 size_t name_length
= name
->length
;
698 size_t allocated_length
= (name_length
>= NAME_FIELD_SIZE
699 ? name_length
+ NAME_FIELD_SIZE
701 char *name_buffer
= xmalloc (allocated_length
+ 1);
702 /* FIXME: + 2 above? */
704 size_t string_length
;
705 int change_dir
= name
->change_dir
;
707 name
->dir_contents
= buffer
;
708 strcpy (name_buffer
, path
);
709 if (! ISSLASH (name_buffer
[name_length
- 1]))
711 name_buffer
[name_length
++] = '/';
712 name_buffer
[name_length
] = '\0';
715 for (string
= buffer
; *string
; string
+= string_length
+ 1)
717 string_length
= strlen (string
);
720 if (name_length
+ string_length
>= allocated_length
)
722 while (name_length
+ string_length
>= allocated_length
)
723 allocated_length
+= NAME_FIELD_SIZE
;
724 name_buffer
= xrealloc (name_buffer
, allocated_length
+ 1);
726 strcpy (name_buffer
+ name_length
, string
+ 1);
727 add_hierarchy_to_namelist (addname (name_buffer
, change_dir
),
736 /* Collect all the names from argv[] (or whatever), expand them into a
737 directory tree, and sort them. This gets only subdirectories, not
741 collect_and_sort_names (void)
744 struct name
*next_name
;
750 if (listed_incremental_option
)
751 read_directory_file ();
756 for (name
= namelist
; name
; name
= next_name
)
758 next_name
= name
->next
;
759 if (name
->found
|| name
->dir_contents
)
761 if (name
->regexp
) /* FIXME: just skip regexps for now */
763 chdir_do (name
->change_dir
);
767 if (deref_stat (dereference_option
, name
->name
, &statbuf
) != 0)
769 if (ignore_failed_read_option
)
770 stat_warn (name
->name
);
772 stat_error (name
->name
);
775 if (S_ISDIR (statbuf
.st_mode
))
778 add_hierarchy_to_namelist (name
, statbuf
.st_dev
);
783 for (name
= namelist
; name
; name
= name
->next
)
785 namelist
= merge_sort (namelist
, num_names
, compare_names
);
787 for (name
= namelist
; name
; name
= name
->next
)
791 /* This is like name_match, except that it returns a pointer to the
792 name it matched, and doesn't set FOUND in structure. The caller
793 will have to do that if it wants to. Oh, and if the namelist is
794 empty, it returns null, unlike name_match, which returns TRUE. */
796 name_scan (const char *path
)
798 size_t length
= strlen (path
);
802 struct name
*cursor
= namelist_match (path
, length
);
806 /* Filename from archive not found in namelist. If we have the whole
807 namelist here, just return 0. Otherwise, read the next name in and
808 compare it. If this was the last name, namelist->found will remain
809 on. If not, we loop to compare the newly read name. */
811 if (same_order_option
&& namelist
&& namelist
->found
)
813 name_gather (); /* read one more */
822 /* This returns a name from the namelist which doesn't have ->found
823 set. It sets ->found before returning, so successive calls will
824 find and return all the non-found names in the namelist. */
825 struct name
*gnu_list_name
;
828 name_from_list (void)
831 gnu_list_name
= namelist
;
832 while (gnu_list_name
&& (gnu_list_name
->found
| gnu_list_name
->fake
))
833 gnu_list_name
= gnu_list_name
->next
;
836 gnu_list_name
->found
= 1;
837 chdir_do (gnu_list_name
->change_dir
);
838 return gnu_list_name
->name
;
844 blank_name_list (void)
849 for (name
= namelist
; name
; name
= name
->next
)
853 /* Yield a newly allocated file name consisting of PATH concatenated to
854 NAME, with an intervening slash if PATH does not already end in one. */
856 new_name (const char *path
, const char *name
)
858 size_t pathlen
= strlen (path
);
859 size_t namesize
= strlen (name
) + 1;
860 int slash
= pathlen
&& ! ISSLASH (path
[pathlen
- 1]);
861 char *buffer
= xmalloc (pathlen
+ slash
+ namesize
);
862 memcpy (buffer
, path
, pathlen
);
863 buffer
[pathlen
] = '/';
864 memcpy (buffer
+ pathlen
+ slash
, name
, namesize
);
868 /* Return nonzero if file NAME is excluded. Exclude a name if its
869 prefix matches a pattern that contains slashes, or if one of its
870 components matches a pattern that contains no slashes. */
872 excluded_name (char const *name
)
874 return excluded_filename (excluded
, name
+ FILESYSTEM_PREFIX_LEN (name
));
877 /* Names to avoid dumping. */
878 static Hash_table
*avoided_name_table
;
880 /* Calculate the hash of an avoided name. */
882 hash_avoided_name (void const *name
, unsigned n_buckets
)
884 return hash_string (name
, n_buckets
);
887 /* Compare two avoided names for equality. */
889 compare_avoided_names (void const *name1
, void const *name2
)
891 return strcmp (name1
, name2
) == 0;
894 /* Remember to not archive NAME. */
896 add_avoided_name (char const *name
)
898 if (! ((avoided_name_table
899 || (avoided_name_table
= hash_initialize (0, 0, hash_avoided_name
,
900 compare_avoided_names
, 0)))
901 && hash_insert (avoided_name_table
, xstrdup (name
))))
905 /* Should NAME be avoided when archiving? */
907 is_avoided_name (char const *name
)
909 return avoided_name_table
&& hash_lookup (avoided_name_table
, name
);