1 /* Various processing of names.
3 Copyright (C) 1988, 1992, 1994, 1996, 1997, 1998, 1999, 2000, 2001,
4 2003 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 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 if (name_buffer_length
* 2 < name_buffer_length
)
275 name_buffer_length
*= 2;
276 name_buffer
= xrealloc (name_buffer
, name_buffer_length
+ 2);
278 name_buffer
[counter
++] = character
;
281 if (counter
== 0 && character
== EOF
)
284 if (counter
== name_buffer_length
)
286 if (name_buffer_length
* 2 < name_buffer_length
)
288 name_buffer_length
*= 2;
289 name_buffer
= xrealloc (name_buffer
, name_buffer_length
+ 2);
291 name_buffer
[counter
] = '\0';
296 /* Get the next name from ARGV or the file of names. Result is in
297 static storage and can't be relied upon across two calls.
299 If CHANGE_DIRS is true, treat a filename of the form "-C" as
300 meaning that the next filename is the name of a directory to change
301 to. If filename_terminator is NUL, CHANGE_DIRS is effectively
304 name_next (int change_dirs
)
310 if (filename_terminator
== '\0')
315 /* Get a name, either from file or from saved arguments. */
317 if (name_index
== names
)
321 if (! read_name_from_file ())
327 source
= name_array
[name_index
++];
328 source_len
= strlen (source
);
329 if (name_buffer_length
< source_len
)
333 name_buffer_length
*= 2;
334 if (! name_buffer_length
)
337 while (name_buffer_length
< source_len
);
340 name_buffer
= xmalloc (name_buffer_length
+ 2);
342 strcpy (name_buffer
, source
);
345 /* Zap trailing slashes. */
347 cursor
= name_buffer
+ strlen (name_buffer
) - 1;
348 while (cursor
> name_buffer
&& ISSLASH (*cursor
))
353 if (chdir (name_buffer
) < 0)
354 chdir_fatal (name_buffer
);
357 else if (change_dirs
&& strcmp (name_buffer
, "-C") == 0)
361 unquote_string (name_buffer
);
366 /* No more names in file. */
368 if (name_file
&& chdir_flag
)
369 FATAL_ERROR ((0, 0, _("Missing file name after -C")));
374 /* Close the name file, if any. */
378 if (name_file
&& name_file
!= stdin
)
379 if (fclose (name_file
) != 0)
380 close_error (name_buffer
);
383 /* Gather names in a list for scanning. Could hash them later if we
386 If the names are already sorted to match the archive, we just read
387 them one by one. name_gather reads the first one, and it is called
388 by name_match as appropriate to read the next ones. At EOF, the
389 last name read is just left in the buffer. This option lets users
390 of small machines extract an arbitrary number of files by doing
391 "tar t" and editing down the list of files. */
396 /* Buffer able to hold a single name. */
397 static struct name
*buffer
;
398 static size_t allocated_size
;
402 if (same_order_option
)
404 static int change_dir
;
406 if (allocated_size
== 0)
408 allocated_size
= offsetof (struct name
, name
) + NAME_FIELD_SIZE
+ 1;
409 buffer
= xmalloc (allocated_size
);
410 /* FIXME: This memset is overkill, and ugly... */
411 memset (buffer
, 0, allocated_size
);
414 while ((name
= name_next (0)) && strcmp (name
, "-C") == 0)
416 char const *dir
= name_next (0);
418 FATAL_ERROR ((0, 0, _("Missing file name after -C")));
419 change_dir
= chdir_arg (xstrdup (dir
));
425 buffer
->length
= strlen (name
);
426 needed_size
= offsetof (struct name
, name
) + buffer
->length
+ 1;
427 if (allocated_size
< needed_size
)
432 if (! allocated_size
)
435 while (allocated_size
< needed_size
);
437 buffer
= xrealloc (buffer
, allocated_size
);
439 buffer
->change_dir
= change_dir
;
440 strcpy (buffer
->name
, name
);
445 nametail
= &namelist
->next
;
450 /* Non sorted names -- read them all in. */
455 int change_dir0
= change_dir
;
456 while ((name
= name_next (0)) && strcmp (name
, "-C") == 0)
458 char const *dir
= name_next (0);
460 FATAL_ERROR ((0, 0, _("Missing file name after -C")));
461 change_dir
= chdir_arg (xstrdup (dir
));
464 addname (name
, change_dir
);
467 if (change_dir
!= change_dir0
)
468 addname (0, change_dir
);
475 /* Add a name to the namelist. */
477 addname (char const *string
, int change_dir
)
479 size_t length
= string
? strlen (string
) : 0;
480 struct name
*name
= xmalloc (offsetof (struct name
, name
) + length
+ 1);
485 strcpy (name
->name
, string
);
491 /* FIXME: This initialization (and the byte of memory that it
492 initializes) is probably not needed, but we are currently in
493 bug-fix mode so we'll leave it in for now. */
498 name
->length
= length
;
500 name
->regexp
= 0; /* assume not a regular expression */
501 name
->firstch
= 1; /* assume first char is literal */
502 name
->change_dir
= change_dir
;
503 name
->dir_contents
= 0;
505 if (string
&& is_pattern (string
))
508 if (string
[0] == '*' || string
[0] == '[' || string
[0] == '?')
513 nametail
= &name
->next
;
517 /* Find a match for PATH (whose string length is LENGTH) in the name
520 namelist_match (char const *path
, size_t length
)
524 for (p
= namelist
; p
; p
= p
->next
)
526 /* If first chars don't match, quick skip. */
528 if (p
->firstch
&& p
->name
[0] != path
[0])
532 ? fnmatch (p
->name
, path
, recursion_option
) == 0
533 : (p
->length
<= length
534 && (path
[p
->length
] == '\0'
535 || (ISSLASH (path
[p
->length
]) && recursion_option
))
536 && memcmp (path
, p
->name
, p
->length
) == 0))
543 /* Return true if and only if name PATH (from an archive) matches any
544 name from the namelist. */
546 name_match (const char *path
)
548 size_t length
= strlen (path
);
552 struct name
*cursor
= namelist
;
555 return ! files_from_option
;
559 chdir_do (cursor
->change_dir
);
561 nametail
= &namelist
;
562 return ! files_from_option
;
565 cursor
= namelist_match (path
, length
);
568 cursor
->found
= 1; /* remember it matched */
569 if (starting_file_option
)
573 nametail
= &namelist
;
575 chdir_do (cursor
->change_dir
);
577 /* We got a match. */
581 /* Filename from archive not found in namelist. If we have the whole
582 namelist here, just return 0. Otherwise, read the next name in and
583 compare it. If this was the last name, namelist->found will remain
584 on. If not, we loop to compare the newly read name. */
586 if (same_order_option
&& namelist
->found
)
588 name_gather (); /* read one more */
597 /* Print the names of things in the namelist that were not matched. */
599 names_notfound (void)
601 struct name
const *cursor
;
603 for (cursor
= namelist
; cursor
; cursor
= cursor
->next
)
604 if (!cursor
->found
&& !cursor
->fake
)
605 ERROR ((0, 0, _("%s: Not found in archive"),
606 quotearg_colon (cursor
->name
)));
608 /* Don't bother freeing the name list; we're about to exit. */
610 nametail
= &namelist
;
612 if (same_order_option
)
616 while (name
= name_next (1), name
)
617 ERROR ((0, 0, _("%s: Not found in archive"),
618 quotearg_colon (name
)));
622 /* Sorting name lists. */
624 /* Sort linked LIST of names, of given LENGTH, using COMPARE to order
625 names. Return the sorted list. Apart from the type `struct name'
626 and the definition of SUCCESSOR, this is a generic list-sorting
627 function, but it's too painful to make it both generic and portable
631 merge_sort (struct name
*list
, int length
,
632 int (*compare
) (struct name
const*, struct name
const*))
634 struct name
*first_list
;
635 struct name
*second_list
;
639 struct name
**merge_point
;
643 # define SUCCESSOR(name) ((name)->next)
650 if ((*compare
) (list
, SUCCESSOR (list
)) > 0)
652 result
= SUCCESSOR (list
);
653 SUCCESSOR (result
) = list
;
654 SUCCESSOR (list
) = 0;
661 first_length
= (length
+ 1) / 2;
662 second_length
= length
/ 2;
663 for (cursor
= list
, counter
= first_length
- 1;
665 cursor
= SUCCESSOR (cursor
), counter
--)
667 second_list
= SUCCESSOR (cursor
);
668 SUCCESSOR (cursor
) = 0;
670 first_list
= merge_sort (first_list
, first_length
, compare
);
671 second_list
= merge_sort (second_list
, second_length
, compare
);
673 merge_point
= &result
;
674 while (first_list
&& second_list
)
675 if ((*compare
) (first_list
, second_list
) < 0)
677 cursor
= SUCCESSOR (first_list
);
678 *merge_point
= first_list
;
679 merge_point
= &SUCCESSOR (first_list
);
684 cursor
= SUCCESSOR (second_list
);
685 *merge_point
= second_list
;
686 merge_point
= &SUCCESSOR (second_list
);
687 second_list
= cursor
;
690 *merge_point
= first_list
;
692 *merge_point
= second_list
;
699 /* A comparison function for sorting names. Put found names last;
700 break ties by string comparison. */
703 compare_names (struct name
const *n1
, struct name
const *n2
)
705 int found_diff
= n2
->found
- n1
->found
;
706 return found_diff
? found_diff
: strcmp (n1
->name
, n2
->name
);
709 /* Add all the dirs under NAME, which names a directory, to the namelist.
710 If any of the files is a directory, recurse on the subdirectory.
711 DEVICE is the device not to leave, if the -l option is specified. */
714 add_hierarchy_to_namelist (struct name
*name
, dev_t device
)
716 char *path
= name
->name
;
717 char *buffer
= get_directory_contents (path
, device
);
720 name
->dir_contents
= "\0\0\0\0";
723 size_t name_length
= name
->length
;
724 size_t allocated_length
= (name_length
>= NAME_FIELD_SIZE
725 ? name_length
+ NAME_FIELD_SIZE
727 char *name_buffer
= xmalloc (allocated_length
+ 1);
728 /* FIXME: + 2 above? */
730 size_t string_length
;
731 int change_dir
= name
->change_dir
;
733 name
->dir_contents
= buffer
;
734 strcpy (name_buffer
, path
);
735 if (! ISSLASH (name_buffer
[name_length
- 1]))
737 name_buffer
[name_length
++] = '/';
738 name_buffer
[name_length
] = '\0';
741 for (string
= buffer
; *string
; string
+= string_length
+ 1)
743 string_length
= strlen (string
);
746 if (allocated_length
<= name_length
+ string_length
)
750 allocated_length
*= 2;
751 if (! allocated_length
)
754 while (allocated_length
<= name_length
+ string_length
);
756 name_buffer
= xrealloc (name_buffer
, allocated_length
+ 1);
758 strcpy (name_buffer
+ name_length
, string
+ 1);
759 add_hierarchy_to_namelist (addname (name_buffer
, change_dir
),
768 /* Collect all the names from argv[] (or whatever), expand them into a
769 directory tree, and sort them. This gets only subdirectories, not
773 collect_and_sort_names (void)
776 struct name
*next_name
;
782 if (listed_incremental_option
)
783 read_directory_file ();
788 for (name
= namelist
; name
; name
= next_name
)
790 next_name
= name
->next
;
791 if (name
->found
|| name
->dir_contents
)
793 if (name
->regexp
) /* FIXME: just skip regexps for now */
795 chdir_do (name
->change_dir
);
799 if (deref_stat (dereference_option
, name
->name
, &statbuf
) != 0)
801 if (ignore_failed_read_option
)
802 stat_warn (name
->name
);
804 stat_error (name
->name
);
807 if (S_ISDIR (statbuf
.st_mode
))
810 add_hierarchy_to_namelist (name
, statbuf
.st_dev
);
815 for (name
= namelist
; name
; name
= name
->next
)
817 namelist
= merge_sort (namelist
, num_names
, compare_names
);
819 for (name
= namelist
; name
; name
= name
->next
)
823 /* This is like name_match, except that it returns a pointer to the
824 name it matched, and doesn't set FOUND in structure. The caller
825 will have to do that if it wants to. Oh, and if the namelist is
826 empty, it returns null, unlike name_match, which returns TRUE. */
828 name_scan (const char *path
)
830 size_t length
= strlen (path
);
834 struct name
*cursor
= namelist_match (path
, length
);
838 /* Filename from archive not found in namelist. If we have the whole
839 namelist here, just return 0. Otherwise, read the next name in and
840 compare it. If this was the last name, namelist->found will remain
841 on. If not, we loop to compare the newly read name. */
843 if (same_order_option
&& namelist
&& namelist
->found
)
845 name_gather (); /* read one more */
854 /* This returns a name from the namelist which doesn't have ->found
855 set. It sets ->found before returning, so successive calls will
856 find and return all the non-found names in the namelist. */
857 struct name
*gnu_list_name
;
860 name_from_list (void)
863 gnu_list_name
= namelist
;
864 while (gnu_list_name
&& (gnu_list_name
->found
| gnu_list_name
->fake
))
865 gnu_list_name
= gnu_list_name
->next
;
868 gnu_list_name
->found
= 1;
869 chdir_do (gnu_list_name
->change_dir
);
870 return gnu_list_name
->name
;
876 blank_name_list (void)
881 for (name
= namelist
; name
; name
= name
->next
)
885 /* Yield a newly allocated file name consisting of PATH concatenated to
886 NAME, with an intervening slash if PATH does not already end in one. */
888 new_name (const char *path
, const char *name
)
890 size_t pathlen
= strlen (path
);
891 size_t namesize
= strlen (name
) + 1;
892 int slash
= pathlen
&& ! ISSLASH (path
[pathlen
- 1]);
893 char *buffer
= xmalloc (pathlen
+ slash
+ namesize
);
894 memcpy (buffer
, path
, pathlen
);
895 buffer
[pathlen
] = '/';
896 memcpy (buffer
+ pathlen
+ slash
, name
, namesize
);
900 /* Return nonzero if file NAME is excluded. */
902 excluded_name (char const *name
)
904 return excluded_filename (excluded
, name
+ FILESYSTEM_PREFIX_LEN (name
));
907 /* Hash tables of strings. */
909 /* Calculate the hash of a string. */
911 hash_string_hasher (void const *name
, unsigned n_buckets
)
913 return hash_string (name
, n_buckets
);
916 /* Compare two strings for equality. */
918 hash_string_compare (void const *name1
, void const *name2
)
920 return strcmp (name1
, name2
) == 0;
923 /* Return zero if TABLE contains a copy of STRING; otherwise, insert a
924 copy of STRING to TABLE and return 1. */
926 hash_string_insert (Hash_table
**table
, char const *string
)
928 Hash_table
*t
= *table
;
929 char *s
= xstrdup (string
);
933 || (*table
= t
= hash_initialize (0, 0, hash_string_hasher
,
934 hash_string_compare
, 0)))
935 && (e
= hash_insert (t
, s
))))
947 /* Return 1 if TABLE contains STRING. */
949 hash_string_lookup (Hash_table
const *table
, char const *string
)
951 return table
&& hash_lookup (table
, string
);
954 /* Names to avoid dumping. */
955 static Hash_table
*avoided_name_table
;
957 /* Remember to not archive NAME. */
959 add_avoided_name (char const *name
)
961 hash_string_insert (&avoided_name_table
, name
);
964 /* Should NAME be avoided when archiving? */
966 is_avoided_name (char const *name
)
968 return hash_string_lookup (avoided_name_table
, name
);
971 /* Return a safer suffix of FILE_NAME, or "." if it has no safer
972 suffix. Check for fully specified file names and other atrocities.
973 Warn the user if we do not return NAME. If LINK_TARGET is 1,
974 FILE_NAME is the target of a hard link, not a member name. */
977 safer_name_suffix (char const *file_name
, bool link_target
)
981 if (absolute_names_option
)
985 /* Skip file system prefixes, leading pathnames that contain
986 "..", and leading slashes. */
988 size_t prefix_len
= FILESYSTEM_PREFIX_LEN (file_name
);
990 for (p
= file_name
+ prefix_len
; *p
; )
992 if (p
[0] == '.' && p
[1] == '.' && (ISSLASH (p
[2]) || !p
[2]))
993 prefix_len
= p
+ 2 - file_name
;
1004 for (p
= file_name
+ prefix_len
; ISSLASH (*p
); p
++)
1006 prefix_len
= p
- file_name
;
1010 static Hash_table
*prefix_table
[2];
1011 char *prefix
= alloca (prefix_len
+ 1);
1012 memcpy (prefix
, file_name
, prefix_len
);
1013 prefix
[prefix_len
] = '\0';
1015 if (hash_string_insert (&prefix_table
[link_target
], prefix
))
1017 static char const *const diagnostic
[] =
1019 N_("Removing leading `%s' from member names"),
1020 N_("Removing leading `%s' from hard link targets")
1022 WARN ((0, 0, _(diagnostic
[link_target
]), prefix
));
1031 static char const *const diagnostic
[] =
1033 N_("Substituting `.' for empty member name"),
1034 N_("Substituting `.' for empty hard link target")
1036 WARN ((0, 0, _(diagnostic
[link_target
])));
1045 /* Return nonzero if NAME contains ".." as a path name component. */
1047 contains_dot_dot (char const *name
)
1049 char const *p
= name
+ FILESYSTEM_PREFIX_LEN (name
);
1053 if (p
[0] == '.' && p
[1] == '.' && (ISSLASH (p
[2]) || !p
[2]))
1061 while (! ISSLASH (*p
));