/* Various processing of names.
Copyright (C) 1988, 1992, 1994, 1996, 1997, 1998, 1999, 2000, 2001,
- 2003 Free Software Foundation, Inc.
+ 2003, 2004 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
#include "system.h"
#include <fnmatch.h>
-#include <grp.h>
#include <hash.h>
-#include <pwd.h>
#include <quotearg.h>
#include "common.h"
/* Given UNAME, set the corresponding UID and return 1, or else, return 0. */
int
-uname_to_uid (char *uname, uid_t *uidp)
+uname_to_uid (char const *uname, uid_t *uidp)
{
struct passwd *passwd;
/* Given GNAME, set the corresponding GID and return 1, or else, return 0. */
int
-gname_to_gid (char *gname, gid_t *gidp)
+gname_to_gid (char const *gname, gid_t *gidp)
{
struct group *group;
/* Set up to gather file names for tar. They can either come from a
file or were saved from decoding arguments. */
void
-name_init (int argc, char *const *argv)
+name_init (void)
{
name_buffer = xmalloc (NAME_FIELD_SIZE + 2);
name_buffer_length = NAME_FIELD_SIZE;
buffer->change_dir = change_dir;
strcpy (buffer->name, name);
buffer->next = 0;
- buffer->found = 0;
+ buffer->found_count = 0;
namelist = buffer;
nametail = &namelist->next;
}
+ else if (change_dir)
+ addname (0, change_dir);
}
else
{
name->next = 0;
name->length = length;
- name->found = 0;
+ name->found_count = 0;
name->regexp = 0; /* assume not a regular expression */
name->firstch = 1; /* assume first char is literal */
name->change_dir = change_dir;
return name;
}
-/* Find a match for PATH (whose string length is LENGTH) in the name
+/* Find a match for FILE_NAME (whose string length is LENGTH) in the name
list. */
static struct name *
-namelist_match (char const *path, size_t length)
+namelist_match (char const *file_name, size_t length)
{
struct name *p;
{
/* If first chars don't match, quick skip. */
- if (p->firstch && p->name[0] != path[0])
+ if (p->firstch && p->name[0] != file_name[0])
continue;
if (p->regexp
- ? fnmatch (p->name, path, recursion_option) == 0
+ ? fnmatch (p->name, file_name, recursion_option) == 0
: (p->length <= length
- && (path[p->length] == '\0'
- || (ISSLASH (path[p->length]) && recursion_option))
- && memcmp (path, p->name, p->length) == 0))
+ && (file_name[p->length] == '\0'
+ || (ISSLASH (file_name[p->length]) && recursion_option))
+ && memcmp (file_name, p->name, p->length) == 0))
return p;
}
return 0;
}
-/* Return true if and only if name PATH (from an archive) matches any
+/* Return true if and only if name FILE_NAME (from an archive) matches any
name from the namelist. */
int
-name_match (const char *path)
+name_match (const char *file_name)
{
- size_t length = strlen (path);
+ size_t length = strlen (file_name);
while (1)
{
return ! files_from_option;
}
- cursor = namelist_match (path, length);
+ cursor = namelist_match (file_name, length);
if (cursor)
{
- cursor->found = 1; /* remember it matched */
+ if (!(ISSLASH (file_name[cursor->length]) && recursion_option)
+ || cursor->found_count == 0)
+ cursor->found_count++; /* remember it matched */
if (starting_file_option)
{
free (namelist);
chdir_do (cursor->change_dir);
/* We got a match. */
- return 1;
+ return ISFOUND (cursor);
}
/* Filename from archive not found in namelist. If we have the whole
namelist here, just return 0. Otherwise, read the next name in and
- compare it. If this was the last name, namelist->found will remain
- on. If not, we loop to compare the newly read name. */
+ compare it. If this was the last name, namelist->found_count will
+ remain on. If not, we loop to compare the newly read name. */
- if (same_order_option && namelist->found)
+ if (same_order_option && namelist->found_count)
{
name_gather (); /* read one more */
- if (namelist->found)
+ if (namelist->found_count)
return 0;
}
else
}
}
-/* Returns true if all names from the namelist were processed */
+/* Returns true if all names from the namelist were processed.
+ P is the stat_info of the most recently processed entry.
+ The decision is postponed until the next entry is read if:
+
+ 1) P ended with a slash (i.e. it was a directory)
+ 2) P matches any entry from the namelist *and* represents a subdirectory
+ or a file lying under this entry (in the terms of directory structure).
+
+ This is necessary to handle contents of directories. */
bool
-names_done ()
+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 || (!cursor->found && !cursor->fake))
- return false;
+ {
+ if (cursor->regexp
+ || (!WASFOUND(cursor) && !cursor->fake)
+ || (len >= cursor->length && ISSLASH (p->file_name[cursor->length])))
+ return false;
+ }
return true;
}
struct name const *cursor;
for (cursor = namelist; cursor; cursor = cursor->next)
- if (!cursor->found && !cursor->fake)
- ERROR ((0, 0, _("%s: Not found in archive"),
- quotearg_colon (cursor->name)));
+ 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)));
+ }
/* Don't bother freeing the name list; we're about to exit. */
namelist = 0;
{
char *name;
- while (name = name_next (1), name)
+ while ((name = name_next (1)) != NULL)
ERROR ((0, 0, _("%s: Not found in archive"),
quotearg_colon (name)));
}
static int
compare_names (struct name const *n1, struct name const *n2)
{
- int found_diff = n2->found - n1->found;
+ int found_diff = WASFOUND(n2) - WASFOUND(n1);
return found_diff ? found_diff : strcmp (n1->name, n2->name);
}
\f
static void
add_hierarchy_to_namelist (struct name *name, dev_t device)
{
- char *path = name->name;
- char *buffer = get_directory_contents (path, device);
+ char *file_name = name->name;
+ char *buffer = get_directory_contents (file_name, device);
if (! buffer)
name->dir_contents = "\0\0\0\0";
size_t allocated_length = (name_length >= NAME_FIELD_SIZE
? name_length + NAME_FIELD_SIZE
: NAME_FIELD_SIZE);
- char *name_buffer = xmalloc (allocated_length + 1);
+ char *namebuf = xmalloc (allocated_length + 1);
/* FIXME: + 2 above? */
char *string;
size_t string_length;
int change_dir = name->change_dir;
name->dir_contents = buffer;
- strcpy (name_buffer, path);
- if (! ISSLASH (name_buffer[name_length - 1]))
+ strcpy (namebuf, file_name);
+ if (! ISSLASH (namebuf[name_length - 1]))
{
- name_buffer[name_length++] = '/';
- name_buffer[name_length] = '\0';
+ namebuf[name_length++] = '/';
+ namebuf[name_length] = '\0';
}
for (string = buffer; *string; string += string_length + 1)
}
while (allocated_length <= name_length + string_length);
- name_buffer = xrealloc (name_buffer, allocated_length + 1);
+ namebuf = xrealloc (namebuf, allocated_length + 1);
}
- strcpy (name_buffer + name_length, string + 1);
- add_hierarchy_to_namelist (addname (name_buffer, change_dir),
+ strcpy (namebuf + name_length, string + 1);
+ add_hierarchy_to_namelist (addname (namebuf, change_dir),
device);
}
}
- free (name_buffer);
+ free (namebuf);
}
}
\f
for (name = namelist; name; name = next_name)
{
next_name = name->next;
- if (name->found || name->dir_contents)
+ if (name->found_count || name->dir_contents)
continue;
if (name->regexp) /* FIXME: just skip regexps for now */
continue;
if (deref_stat (dereference_option, name->name, &statbuf) != 0)
{
- if (ignore_failed_read_option)
- stat_warn (name->name);
- else
- stat_error (name->name);
+ stat_diag (name->name);
continue;
}
if (S_ISDIR (statbuf.st_mode))
{
- name->found = 1;
+ name->found_count++;
add_hierarchy_to_namelist (name, statbuf.st_dev);
}
}
namelist = merge_sort (namelist, num_names, compare_names);
for (name = namelist; name; name = name->next)
- name->found = 0;
+ name->found_count = 0;
}
/* This is like name_match, except that it returns a pointer to the
will have to do that if it wants to. Oh, and if the namelist is
empty, it returns null, unlike name_match, which returns TRUE. */
struct name *
-name_scan (const char *path)
+name_scan (const char *file_name)
{
- size_t length = strlen (path);
+ size_t length = strlen (file_name);
while (1)
{
- struct name *cursor = namelist_match (path, length);
+ struct name *cursor = namelist_match (file_name, length);
if (cursor)
return cursor;
/* Filename from archive not found in namelist. If we have the whole
namelist here, just return 0. Otherwise, read the next name in and
- compare it. If this was the last name, namelist->found will remain
- on. If not, we loop to compare the newly read name. */
+ compare it. If this was the last name, namelist->found_count will
+ remain on. If not, we loop to compare the newly read name. */
- if (same_order_option && namelist && namelist->found)
+ if (same_order_option && namelist && namelist->found_count)
{
name_gather (); /* read one more */
- if (namelist->found)
+ if (namelist->found_count)
return 0;
}
else
{
if (!gnu_list_name)
gnu_list_name = namelist;
- while (gnu_list_name && (gnu_list_name->found | gnu_list_name->fake))
+ 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 = 1;
+ gnu_list_name->found_count++;
chdir_do (gnu_list_name->change_dir);
return gnu_list_name->name;
}
gnu_list_name = 0;
for (name = namelist; name; name = name->next)
- name->found = 0;
+ name->found_count = 0;
}
-/* Yield a newly allocated file name consisting of PATH concatenated to
- NAME, with an intervening slash if PATH does not already end in one. */
+/* Yield a newly allocated file name consisting of FILE_NAME concatenated to
+ NAME, with an intervening slash if FILE_NAME does not already end in one. */
char *
-new_name (const char *path, const char *name)
+new_name (const char *file_name, const char *name)
{
- size_t pathlen = strlen (path);
+ size_t file_name_len = strlen (file_name);
size_t namesize = strlen (name) + 1;
- int slash = pathlen && ! ISSLASH (path[pathlen - 1]);
- char *buffer = xmalloc (pathlen + slash + namesize);
- memcpy (buffer, path, pathlen);
- buffer[pathlen] = '/';
- memcpy (buffer + pathlen + slash, name, namesize);
+ 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 + FILESYSTEM_PREFIX_LEN (name));
+ return excluded_filename (excluded, name + FILE_SYSTEM_PREFIX_LEN (name));
}
\f
/* Hash tables of strings. */
p = file_name;
else
{
- /* Skip file system prefixes, leading pathnames that contain
+ /* Skip file system prefixes, leading file name components that contain
"..", and leading slashes. */
- size_t prefix_len = FILESYSTEM_PREFIX_LEN (file_name);
+ 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]))
+ if (p[0] == '.' && p[1] == '.' && (ISSLASH (p[2]) || !p[2]))
prefix_len = p + 2 - file_name;
do
N_("Substituting `.' for empty member name"),
N_("Substituting `.' for empty hard link target")
};
- WARN ((0, 0, _(diagnostic[link_target])));
+ WARN ((0, 0, "%s", _(diagnostic[link_target])));
}
p = ".";
}
\f
/* Return the size of the prefix of FILE_NAME that is removed after
- stripping NUM leading path name components. NUM must be
+ stripping NUM leading file name components. NUM must be
positive. */
size_t
stripped_prefix_len (char const *file_name, size_t num)
{
- char const *p = file_name + FILESYSTEM_PREFIX_LEN (file_name);
+ char const *p = file_name + FILE_SYSTEM_PREFIX_LEN (file_name);
while (ISSLASH (*p))
p++;
while (*p)
return -1;
}
\f
-/* Return nonzero if NAME contains ".." as a path name component. */
+/* Return nonzero if NAME contains ".." as a file name component. */
bool
contains_dot_dot (char const *name)
{
- char const *p = name + FILESYSTEM_PREFIX_LEN (name);
+ char const *p = name + FILE_SYSTEM_PREFIX_LEN (name);
for (;; p++)
{