#include <system.h>
#include <fnmatch.h>
#include <hash.h>
#include <quotearg.h>
#include "common.h"
struct group *getgrnam ();
struct passwd *getpwnam ();
#if ! HAVE_DECL_GETPWUID
struct passwd *getpwuid ();
#endif
#if ! HAVE_DECL_GETGRGID
struct group *getgrgid ();
#endif
static char *cached_uname;
static char *cached_gname;
static uid_t cached_uid;
static gid_t cached_gid;
static char *cached_no_such_uname;
static char *cached_no_such_gname;
static uid_t cached_no_such_uid;
static gid_t cached_no_such_gid;
static void register_individual_file (char const *name);
void
uid_to_uname (uid_t uid, char **uname)
{
struct passwd *passwd;
if (uid != 0 && uid == cached_no_such_uid)
{
*uname = strdup ("");
return;
}
if (!cached_uname || uid != cached_uid)
{
passwd = getpwuid (uid);
if (passwd)
{
cached_uid = uid;
assign_string (&cached_uname, passwd->pw_name);
}
else
{
cached_no_such_uid = uid;
*uname = strdup ("");
return;
}
}
*uname = strdup (cached_uname);
}
void
gid_to_gname (gid_t gid, char **gname)
{
struct group *group;
if (gid != 0 && gid == cached_no_such_gid)
{
*gname = strdup ("");
return;
}
if (!cached_gname || gid != cached_gid)
{
group = getgrgid (gid);
if (group)
{
cached_gid = gid;
assign_string (&cached_gname, group->gr_name);
}
else
{
cached_no_such_gid = gid;
*gname = strdup ("");
return;
}
}
*gname = strdup (cached_gname);
}
int
uname_to_uid (char const *uname, uid_t *uidp)
{
struct passwd *passwd;
if (cached_no_such_uname
&& strcmp (uname, cached_no_such_uname) == 0)
return 0;
if (!cached_uname
|| uname[0] != cached_uname[0]
|| strcmp (uname, cached_uname) != 0)
{
passwd = getpwnam (uname);
if (passwd)
{
cached_uid = passwd->pw_uid;
assign_string (&cached_uname, passwd->pw_name);
}
else
{
assign_string (&cached_no_such_uname, uname);
return 0;
}
}
*uidp = cached_uid;
return 1;
}
int
gname_to_gid (char const *gname, gid_t *gidp)
{
struct group *group;
if (cached_no_such_gname
&& strcmp (gname, cached_no_such_gname) == 0)
return 0;
if (!cached_gname
|| gname[0] != cached_gname[0]
|| strcmp (gname, cached_gname) != 0)
{
group = getgrnam (gname);
if (group)
{
cached_gid = group->gr_gid;
assign_string (&cached_gname, gname);
}
else
{
assign_string (&cached_no_such_gname, gname);
return 0;
}
}
*gidp = cached_gid;
return 1;
}
static struct name *namelist;
static struct name **nametail = &namelist;
static const char **name_array;
static int allocated_names;
static int names;
static int name_index;
void
init_names (void)
{
allocated_names = 10;
name_array = xmalloc (sizeof (const char *) * allocated_names);
names = 0;
}
void
name_add (const char *name)
{
if (names == allocated_names)
{
allocated_names *= 2;
name_array =
xrealloc (name_array, sizeof (const char *) * allocated_names);
}
name_array[names++] = name;
}
static FILE *name_file;
static char *name_buffer;
static size_t name_buffer_length;
static inline int
is_pattern (const char *string)
{
return strchr (string, '*') || strchr (string, '[') || strchr (string, '?');
}
void
name_init (void)
{
name_buffer = xmalloc (NAME_FIELD_SIZE + 2);
name_buffer_length = NAME_FIELD_SIZE;
if (files_from_option)
{
if (!strcmp (files_from_option, "-"))
{
request_stdin ("-T");
name_file = stdin;
}
else if (name_file = fopen (files_from_option, "r"), !name_file)
open_fatal (files_from_option);
}
}
void
name_term (void)
{
free (name_buffer);
free (name_array);
}
static int
read_name_from_file (void)
{
int character;
size_t counter = 0;
while (character = getc (name_file),
character != EOF && character != filename_terminator)
{
if (counter == name_buffer_length)
{
if (name_buffer_length * 2 < name_buffer_length)
xalloc_die ();
name_buffer_length *= 2;
name_buffer = xrealloc (name_buffer, name_buffer_length + 2);
}
name_buffer[counter++] = character;
}
if (counter == 0 && character == EOF)
return 0;
if (counter == name_buffer_length)
{
if (name_buffer_length * 2 < name_buffer_length)
xalloc_die ();
name_buffer_length *= 2;
name_buffer = xrealloc (name_buffer, name_buffer_length + 2);
}
name_buffer[counter] = '\0';
return 1;
}
char *
name_next (int change_dirs)
{
const char *source;
char *cursor;
int chdir_flag = 0;
if (filename_terminator == '\0')
change_dirs = 0;
while (1)
{
if (name_index == names)
{
if (! name_file)
break;
if (! read_name_from_file ())
break;
}
else
{
size_t source_len;
source = name_array[name_index++];
source_len = strlen (source);
if (name_buffer_length < source_len)
{
do
{
name_buffer_length *= 2;
if (! name_buffer_length)
xalloc_die ();
}
while (name_buffer_length < source_len);
free (name_buffer);
name_buffer = xmalloc (name_buffer_length + 2);
}
strcpy (name_buffer, source);
}
cursor = name_buffer + strlen (name_buffer) - 1;
while (cursor > name_buffer && ISSLASH (*cursor))
*cursor-- = '\0';
if (chdir_flag)
{
if (chdir (name_buffer) < 0)
chdir_fatal (name_buffer);
chdir_flag = 0;
}
else if (change_dirs && strcmp (name_buffer, "-C") == 0)
chdir_flag = 1;
else
{
unquote_string (name_buffer);
if (incremental_option)
register_individual_file (name_buffer);
return name_buffer;
}
}
if (name_file && chdir_flag)
FATAL_ERROR ((0, 0, _("Missing file name after -C")));
return 0;
}
void
name_close (void)
{
if (name_file && name_file != stdin)
if (fclose (name_file) != 0)
close_error (name_buffer);
}
void
name_gather (void)
{
static struct name *buffer;
static size_t allocated_size;
char const *name;
if (same_order_option)
{
static int change_dir;
if (allocated_size == 0)
{
allocated_size = offsetof (struct name, name) + NAME_FIELD_SIZE + 1;
buffer = xmalloc (allocated_size);
memset (buffer, 0, allocated_size);
}
while ((name = name_next (0)) && strcmp (name, "-C") == 0)
{
char const *dir = name_next (0);
if (! dir)
FATAL_ERROR ((0, 0, _("Missing file name after -C")));
change_dir = chdir_arg (xstrdup (dir));
}
if (name)
{
size_t needed_size;
buffer->length = strlen (name);
needed_size = offsetof (struct name, name) + buffer->length + 1;
if (allocated_size < needed_size)
{
do
{
allocated_size *= 2;
if (! allocated_size)
xalloc_die ();
}
while (allocated_size < needed_size);
buffer = xrealloc (buffer, allocated_size);
}
buffer->change_dir = change_dir;
strcpy (buffer->name, name);
buffer->next = 0;
buffer->found_count = 0;
namelist = buffer;
nametail = &namelist->next;
}
else if (change_dir)
addname (0, change_dir);
}
else
{
int change_dir = 0;
for (;;)
{
int change_dir0 = change_dir;
while ((name = name_next (0)) && strcmp (name, "-C") == 0)
{
char const *dir = name_next (0);
if (! dir)
FATAL_ERROR ((0, 0, _("Missing file name after -C")));
change_dir = chdir_arg (xstrdup (dir));
}
if (name)
addname (name, change_dir);
else
{
if (change_dir != change_dir0)
addname (0, change_dir);
break;
}
}
}
}
struct name *
addname (char const *string, int change_dir)
{
size_t length = string ? strlen (string) : 0;
struct name *name = xmalloc (offsetof (struct name, name) + length + 1);
if (string)
{
name->fake = 0;
strcpy (name->name, string);
}
else
{
name->fake = 1;
name->name[0] = 0;
}
name->next = 0;
name->length = length;
name->found_count = 0;
name->regexp = 0;
name->firstch = 1;
name->change_dir = change_dir;
name->dir_contents = 0;
if (string && is_pattern (string))
{
name->regexp = 1;
if (string[0] == '*' || string[0] == '[' || string[0] == '?')
name->firstch = 0;
}
*nametail = name;
nametail = &name->next;
return name;
}
static struct name *
namelist_match (char const *file_name, size_t length)
{
struct name *p;
for (p = namelist; p; p = p->next)
{
if (p->firstch && p->name[0] != file_name[0])
continue;
if (p->regexp
? fnmatch (p->name, file_name, recursion_option) == 0
: (p->length <= length
&& (file_name[p->length] == '\0'
|| (ISSLASH (file_name[p->length]) && recursion_option))
&& memcmp (file_name, p->name, p->length) == 0))
return p;
}
return 0;
}
int
name_match (const char *file_name)
{
size_t length = strlen (file_name);
while (1)
{
struct name *cursor = namelist;
if (!cursor)
return ! files_from_option;
if (cursor->fake)
{
chdir_do (cursor->change_dir);
namelist = 0;
nametail = &namelist;
return ! files_from_option;
}
cursor = namelist_match (file_name, length);
if (cursor)
{
if (!(ISSLASH (file_name[cursor->length]) && recursion_option)
|| cursor->found_count == 0)
cursor->found_count++;
if (starting_file_option)
{
free (namelist);
namelist = 0;
nametail = &namelist;
}
chdir_do (cursor->change_dir);
return ISFOUND (cursor);
}
if (same_order_option && namelist->found_count)
{
name_gather ();
if (namelist->found_count)
return 0;
}
else
return 0;
}
}
bool
all_names_found (struct tar_stat_info *p)
{
struct name const *cursor;
size_t len;
if (!p->file_name || occurrence_option == 0 || p->had_trailing_slash)
return false;
len = strlen (p->file_name);
for (cursor = namelist; cursor; cursor = cursor->next)
{
if (cursor->regexp
|| (!WASFOUND(cursor) && !cursor->fake)
|| (len >= cursor->length && ISSLASH (p->file_name[cursor->length])))
return false;
}
return true;
}
void
names_notfound (void)
{
struct name const *cursor;
for (cursor = namelist; cursor; cursor = cursor->next)
if (!WASFOUND(cursor) && !cursor->fake)
{
if (cursor->found_count == 0)
ERROR ((0, 0, _("%s: Not found in archive"),
quotearg_colon (cursor->name)));
else
ERROR ((0, 0, _("%s: Required occurrence not found in archive"),
quotearg_colon (cursor->name)));
}
namelist = 0;
nametail = &namelist;
if (same_order_option)
{
char *name;
while ((name = name_next (1)) != NULL)
ERROR ((0, 0, _("%s: Not found in archive"),
quotearg_colon (name)));
}
}
static struct name *
merge_sort (struct name *list, int length,
int (*compare) (struct name const*, struct name const*))
{
struct name *first_list;
struct name *second_list;
int first_length;
int second_length;
struct name *result;
struct name **merge_point;
struct name *cursor;
int counter;
# define SUCCESSOR(name) ((name)->next)
if (length == 1)
return list;
if (length == 2)
{
if ((*compare) (list, SUCCESSOR (list)) > 0)
{
result = SUCCESSOR (list);
SUCCESSOR (result) = list;
SUCCESSOR (list) = 0;
return result;
}
return list;
}
first_list = list;
first_length = (length + 1) / 2;
second_length = length / 2;
for (cursor = list, counter = first_length - 1;
counter;
cursor = SUCCESSOR (cursor), counter--)
continue;
second_list = SUCCESSOR (cursor);
SUCCESSOR (cursor) = 0;
first_list = merge_sort (first_list, first_length, compare);
second_list = merge_sort (second_list, second_length, compare);
merge_point = &result;
while (first_list && second_list)
if ((*compare) (first_list, second_list) < 0)
{
cursor = SUCCESSOR (first_list);
*merge_point = first_list;
merge_point = &SUCCESSOR (first_list);
first_list = cursor;
}
else
{
cursor = SUCCESSOR (second_list);
*merge_point = second_list;
merge_point = &SUCCESSOR (second_list);
second_list = cursor;
}
if (first_list)
*merge_point = first_list;
else
*merge_point = second_list;
return result;
#undef SUCCESSOR
}
static int
compare_names (struct name const *n1, struct name const *n2)
{
int found_diff = WASFOUND(n2) - WASFOUND(n1);
return found_diff ? found_diff : strcmp (n1->name, n2->name);
}
static void
add_hierarchy_to_namelist (struct name *name, dev_t device)
{
char *file_name = name->name;
char *buffer = get_directory_contents (file_name, device);
if (! buffer)
name->dir_contents = "\0\0\0\0";
else
{
size_t name_length = name->length;
size_t allocated_length = (name_length >= NAME_FIELD_SIZE
? name_length + NAME_FIELD_SIZE
: NAME_FIELD_SIZE);
char *namebuf = xmalloc (allocated_length + 1);
char *string;
size_t string_length;
int change_dir = name->change_dir;
name->dir_contents = buffer;
strcpy (namebuf, file_name);
if (! ISSLASH (namebuf[name_length - 1]))
{
namebuf[name_length++] = '/';
namebuf[name_length] = '\0';
}
for (string = buffer; *string; string += string_length + 1)
{
string_length = strlen (string);
if (*string == 'D')
{
if (allocated_length <= name_length + string_length)
{
do
{
allocated_length *= 2;
if (! allocated_length)
xalloc_die ();
}
while (allocated_length <= name_length + string_length);
namebuf = xrealloc (namebuf, allocated_length + 1);
}
strcpy (namebuf + name_length, string + 1);
add_hierarchy_to_namelist (addname (namebuf, change_dir),
device);
}
}
free (namebuf);
}
}
void
collect_and_sort_names (void)
{
struct name *name;
struct name *next_name;
int num_names;
struct stat statbuf;
name_gather ();
if (listed_incremental_option)
read_directory_file ();
if (!namelist)
addname (".", 0);
for (name = namelist; name; name = next_name)
{
next_name = name->next;
if (name->found_count || name->dir_contents)
continue;
if (name->regexp)
continue;
chdir_do (name->change_dir);
if (name->fake)
continue;
if (deref_stat (dereference_option, name->name, &statbuf) != 0)
{
stat_diag (name->name);
continue;
}
if (S_ISDIR (statbuf.st_mode))
{
name->found_count++;
add_hierarchy_to_namelist (name, statbuf.st_dev);
}
}
num_names = 0;
for (name = namelist; name; name = name->next)
num_names++;
namelist = merge_sort (namelist, num_names, compare_names);
for (name = namelist; name; name = name->next)
name->found_count = 0;
}
struct name *
name_scan (const char *file_name)
{
size_t length = strlen (file_name);
while (1)
{
struct name *cursor = namelist_match (file_name, length);
if (cursor)
return cursor;
if (same_order_option && namelist && namelist->found_count)
{
name_gather ();
if (namelist->found_count)
return 0;
}
else
return 0;
}
}
struct name *gnu_list_name;
char *
name_from_list (void)
{
if (!gnu_list_name)
gnu_list_name = namelist;
while (gnu_list_name && (gnu_list_name->found_count || gnu_list_name->fake))
gnu_list_name = gnu_list_name->next;
if (gnu_list_name)
{
gnu_list_name->found_count++;
chdir_do (gnu_list_name->change_dir);
return gnu_list_name->name;
}
return 0;
}
void
blank_name_list (void)
{
struct name *name;
gnu_list_name = 0;
for (name = namelist; name; name = name->next)
name->found_count = 0;
}
char *
new_name (const char *file_name, const char *name)
{
size_t file_name_len = strlen (file_name);
size_t namesize = strlen (name) + 1;
int slash = file_name_len && ! ISSLASH (file_name[file_name_len - 1]);
char *buffer = xmalloc (file_name_len + slash + namesize);
memcpy (buffer, file_name, file_name_len);
buffer[file_name_len] = '/';
memcpy (buffer + file_name_len + slash, name, namesize);
return buffer;
}
bool
excluded_name (char const *name)
{
return excluded_filename (excluded, name + FILE_SYSTEM_PREFIX_LEN (name));
}
static unsigned
hash_string_hasher (void const *name, unsigned n_buckets)
{
return hash_string (name, n_buckets);
}
static bool
hash_string_compare (void const *name1, void const *name2)
{
return strcmp (name1, name2) == 0;
}
static bool
hash_string_insert_prefix (Hash_table **table, char const *string, size_t len,
const char **return_prefix)
{
Hash_table *t = *table;
char *s;
char *e;
if (len)
{
s = xmalloc (len + 1);
memcpy (s, string, len);
s[len] = 0;
}
else
s = xstrdup (string);
if (! ((t
|| (*table = t = hash_initialize (0, 0, hash_string_hasher,
hash_string_compare, 0)))
&& (e = hash_insert (t, s))))
xalloc_die ();
if (e == s)
{
if (return_prefix)
*return_prefix = s;
return 1;
}
else
{
free (s);
return 0;
}
}
bool
hash_string_insert (Hash_table **table, char const *string)
{
return hash_string_insert_prefix (table, string, 0, NULL);
}
static bool
hash_string_lookup (Hash_table const *table, char const *string)
{
return table && hash_lookup (table, string);
}
static Hash_table *avoided_name_table;
void
add_avoided_name (char const *name)
{
hash_string_insert (&avoided_name_table, name);
}
bool
is_avoided_name (char const *name)
{
return hash_string_lookup (avoided_name_table, name);
}
static Hash_table *individual_file_table;
static void
register_individual_file (char const *name)
{
struct stat st;
if (deref_stat (dereference_option, name, &st) != 0)
return;
if (S_ISDIR (st.st_mode))
return;
hash_string_insert (&individual_file_table, name);
}
bool
is_individual_file (char const *name)
{
return hash_string_lookup (individual_file_table, name);
}
static Hash_table *prefix_table[2];
bool
removed_prefixes_p (void)
{
return (prefix_table[0] && hash_get_n_entries (prefix_table[0]) != 0)
|| (prefix_table[1] && hash_get_n_entries (prefix_table[1]) != 0);
}
char *
safer_name_suffix (char const *file_name, bool link_target)
{
char const *p;
if (absolute_names_option)
p = file_name;
else
{
size_t prefix_len = FILE_SYSTEM_PREFIX_LEN (file_name);
for (p = file_name + prefix_len; *p; )
{
if (p[0] == '.' && p[1] == '.' && (ISSLASH (p[2]) || !p[2]))
prefix_len = p + 2 - file_name;
do
{
char c = *p++;
if (ISSLASH (c))
break;
}
while (*p);
}
for (p = file_name + prefix_len; ISSLASH (*p); p++)
continue;
prefix_len = p - file_name;
if (prefix_len)
{
const char *prefix;
if (hash_string_insert_prefix (&prefix_table[link_target], file_name,
prefix_len, &prefix))
{
static char const *const diagnostic[] =
{
N_("Removing leading `%s' from member names"),
N_("Removing leading `%s' from hard link targets")
};
WARN ((0, 0, _(diagnostic[link_target]), prefix));
}
}
}
if (! *p)
{
if (p == file_name)
{
static char const *const diagnostic[] =
{
N_("Substituting `.' for empty member name"),
N_("Substituting `.' for empty hard link target")
};
WARN ((0, 0, "%s", _(diagnostic[link_target])));
}
p = ".";
}
return (char *) p;
}
size_t
stripped_prefix_len (char const *file_name, size_t num)
{
char const *p = file_name + FILE_SYSTEM_PREFIX_LEN (file_name);
while (ISSLASH (*p))
p++;
while (*p)
{
bool slash = ISSLASH (*p);
p++;
if (slash)
{
if (--num == 0)
return p - file_name;
while (ISSLASH (*p))
p++;
}
}
return -1;
}
bool
contains_dot_dot (char const *name)
{
char const *p = name + FILE_SYSTEM_PREFIX_LEN (name);
for (;; p++)
{
if (p[0] == '.' && p[1] == '.' && (ISSLASH (p[2]) || !p[2]))
return 1;
while (! ISSLASH (*p))
{
if (! *p++)
return 0;
}
}
}