#include "system.h"
#include <pwd.h>
#include <grp.h>
#ifndef FNM_LEADING_DIR
# include <fnmatch.h>
#endif
#include "common.h"
extern struct group *getgrnam ();
extern struct passwd *getpwnam ();
#if !HAVE_GETPWUID
extern struct passwd *getpwuid ();
#endif
#if !HAVE_GETGRGID
extern struct group *getgrgid ();
#endif
static char cached_uname[UNAME_FIELD_SIZE] = "";
static char cached_gname[GNAME_FIELD_SIZE] = "";
static uid_t cached_uid;
static gid_t cached_gid;
static char cached_no_such_uname[UNAME_FIELD_SIZE] = "";
static char cached_no_such_gname[GNAME_FIELD_SIZE] = "";
static uid_t cached_no_such_uid = 0;
static gid_t cached_no_such_gid = 0;
void
uid_to_uname (uid_t uid, char uname[UNAME_FIELD_SIZE])
{
struct passwd *passwd;
if (uid != 0 && uid == cached_no_such_uid)
{
*uname = '\0';
return;
}
if (!cached_uname[0] || uid != cached_uid)
{
passwd = getpwuid (uid);
if (passwd)
{
cached_uid = uid;
strncpy (cached_uname, passwd->pw_name, UNAME_FIELD_SIZE);
}
else
{
cached_no_such_uid = uid;
*uname = '\0';
return;
}
}
strncpy (uname, cached_uname, UNAME_FIELD_SIZE);
}
void
gid_to_gname (gid_t gid, char gname[GNAME_FIELD_SIZE])
{
struct group *group;
if (gid != 0 && gid == cached_no_such_gid)
{
*gname = '\0';
return;
}
if (!cached_gname[0] || gid != cached_gid)
{
setgrent ();
group = getgrgid (gid);
if (group)
{
cached_gid = gid;
strncpy (cached_gname, group->gr_name, GNAME_FIELD_SIZE);
}
else
{
cached_no_such_gid = gid;
*gname = '\0';
return;
}
}
strncpy (gname, cached_gname, GNAME_FIELD_SIZE);
}
int
uname_to_uid (char uname[UNAME_FIELD_SIZE], uid_t *uidp)
{
struct passwd *passwd;
if (cached_no_such_uname[0]
&& strncmp (uname, cached_no_such_uname, UNAME_FIELD_SIZE) == 0)
return 0;
if (!cached_uname[0]
|| uname[0] != cached_uname[0]
|| strncmp (uname, cached_uname, UNAME_FIELD_SIZE) != 0)
{
passwd = getpwnam (uname);
if (passwd)
{
cached_uid = passwd->pw_uid;
strncpy (cached_uname, uname, UNAME_FIELD_SIZE);
}
else
{
strncpy (cached_no_such_uname, uname, UNAME_FIELD_SIZE);
return 0;
}
}
*uidp = cached_uid;
return 1;
}
int
gname_to_gid (char gname[GNAME_FIELD_SIZE], gid_t *gidp)
{
struct group *group;
if (cached_no_such_gname[0]
&& strncmp (gname, cached_no_such_gname, GNAME_FIELD_SIZE) == 0)
return 0;
if (!cached_gname[0]
|| gname[0] != cached_gname[0]
|| strncmp (gname, cached_gname, GNAME_FIELD_SIZE) != 0)
{
group = getgrnam (gname);
if (group)
{
cached_gid = group->gr_gid;
strncpy (cached_gname, gname, GNAME_FIELD_SIZE);
}
else
{
strncpy (cached_no_such_gname, gname, GNAME_FIELD_SIZE);
return 0;
}
}
*gidp = cached_gid;
return 1;
}
static const char **name_array;
static int allocated_names;
static int names;
static int name_index = 0;
void
init_names (void)
{
allocated_names = 10;
name_array = (const char **)
xmalloc (sizeof (const char *) * allocated_names);
names = 0;
}
void
name_add (const char *name)
{
if (names == allocated_names)
{
allocated_names *= 2;
name_array = (const char **)
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 (int argc, char *const *argv)
{
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)
FATAL_ERROR ((0, errno, _("Cannot open file %s"), 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)
{
name_buffer_length += NAME_FIELD_SIZE;
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)
{
name_buffer_length += NAME_FIELD_SIZE;
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_file)
{
if (!read_name_from_file ())
break;
}
else
{
if (name_index == names)
break;
source = name_array[name_index++];
if (strlen (source) > name_buffer_length)
{
free (name_buffer);
name_buffer_length = strlen (source);
name_buffer = xmalloc (name_buffer_length + 2);
}
strcpy (name_buffer, source);
}
cursor = name_buffer + strlen (name_buffer) - 1;
while (cursor > name_buffer && *cursor == '/')
*cursor-- = '\0';
if (chdir_flag)
{
if (chdir (name_buffer) < 0)
FATAL_ERROR ((0, errno, _("Cannot change to directory %s"),
name_buffer));
chdir_flag = 0;
}
else if (change_dirs && strcmp (name_buffer, "-C") == 0)
chdir_flag = 1;
else
{
unquote_string (name_buffer);
return name_buffer;
}
}
if (name_file && chdir_flag)
FATAL_ERROR ((0, 0, _("Missing file name after -C")));
return NULL;
}
void
name_close (void)
{
if (name_file != NULL && name_file != stdin)
if (fclose (name_file) == EOF)
ERROR ((0, errno, "%s", name_buffer));
}
void
name_gather (void)
{
static struct name *buffer;
static size_t allocated_length = 0;
char *name;
if (same_order_option)
{
if (allocated_length == 0)
{
allocated_length = sizeof (struct name) + NAME_FIELD_SIZE;
buffer = (struct name *) xmalloc (allocated_length);
memset (buffer, 0, allocated_length);
}
name = name_next (0);
if (name)
{
if (strcmp (name, "-C") == 0)
{
char *copy = xstrdup (name_next (0));
name = name_next (0);
if (!name)
FATAL_ERROR ((0, 0, _("Missing file name after -C")));
buffer->change_dir = copy;
}
buffer->length = strlen (name);
if (sizeof (struct name) + buffer->length >= allocated_length)
{
allocated_length = sizeof (struct name) + buffer->length;
buffer = (struct name *) xrealloc (buffer, allocated_length);
}
strncpy (buffer->name, name, (size_t) buffer->length);
buffer->name[buffer->length] = 0;
buffer->next = NULL;
buffer->found = 0;
namelist = buffer;
namelast = namelist;
}
return;
}
while (name = name_next (0), name)
addname (name);
}
void
addname (const char *string)
{
static char *chdir_name = NULL;
struct name *name;
size_t length;
if (strcmp (string, "-C") == 0)
{
chdir_name = xstrdup (name_next (0));
string = name_next (0);
if (!chdir_name)
FATAL_ERROR ((0, 0, _("Missing file name after -C")));
if (chdir_name[0] != '/')
{
char *path = xmalloc (PATH_MAX);
#if HAVE_GETCWD
if (!getcwd (path, PATH_MAX))
FATAL_ERROR ((0, 0, _("Could not get current directory")));
#else
char *getwd ();
if (!getwd (path))
FATAL_ERROR ((0, 0, _("Could not get current directory: %s"),
path));
#endif
chdir_name = new_name (path, chdir_name);
free (path);
}
}
length = string ? strlen (string) : 0;
name = (struct name *) xmalloc (sizeof (struct name) + length);
memset (name, 0, sizeof (struct name) + length);
name->next = NULL;
if (string)
{
name->fake = 0;
name->length = length;
strncpy (name->name, string, length);
name->name[length] = '\0';
}
else
name->fake = 1;
name->found = 0;
name->regexp = 0;
name->firstch = 1;
name->change_dir = chdir_name;
name->dir_contents = 0;
if (string && is_pattern (string))
{
name->regexp = 1;
if (string[0] == '*' || string[0] == '[' || string[0] == '?')
name->firstch = 0;
}
if (namelast)
namelast->next = name;
namelast = name;
if (!namelist)
namelist = name;
}
int
name_match (const char *path)
{
size_t length = strlen (path);
while (1)
{
struct name *cursor = namelist;
if (!cursor)
return 1;
if (cursor->fake)
{
if (cursor->change_dir && chdir (cursor->change_dir))
FATAL_ERROR ((0, errno, _("Cannot change to directory %s"),
cursor->change_dir));
namelist = 0;
return 1;
}
for (; cursor; cursor = cursor->next)
{
if (cursor->firstch && cursor->name[0] != path[0])
continue;
if (cursor->regexp)
{
if (fnmatch (cursor->name, path, FNM_LEADING_DIR) == 0)
{
cursor->found = 1;
if (starting_file_option)
{
free (namelist);
namelist = NULL;
}
if (cursor->change_dir && chdir (cursor->change_dir))
FATAL_ERROR ((0, errno, _("Cannot change to directory %s"),
cursor->change_dir));
return 1;
}
continue;
}
if (cursor->length <= length
&& (path[cursor->length] == '\0'
|| path[cursor->length] == '/')
&& strncmp (path, cursor->name, cursor->length) == 0)
{
cursor->found = 1;
if (starting_file_option)
{
free ((void *) namelist);
namelist = 0;
}
if (cursor->change_dir && chdir (cursor->change_dir))
FATAL_ERROR ((0, errno, _("Cannot change to directory %s"),
cursor->change_dir));
return 1;
}
}
if (same_order_option && namelist->found)
{
name_gather ();
if (namelist->found)
return 0;
}
else
return 0;
}
}
void
names_notfound (void)
{
struct name *cursor;
struct name *next;
for (cursor = namelist; cursor; cursor = next)
{
next = cursor->next;
if (!cursor->found && !cursor->fake)
ERROR ((0, 0, _("%s: Not found in archive"), cursor->name));
#ifdef amiga
if (!same_order_option)
free (cursor);
#endif
}
namelist = (struct name *) NULL;
namelast = (struct name *) NULL;
if (same_order_option)
{
char *name;
while (name = name_next (1), name)
ERROR ((0, 0, _("%s: Not found in archive"), name));
}
}
void
name_expand (void)
{
}
struct name *
name_scan (const char *path)
{
size_t length = strlen (path);
while (1)
{
struct name *cursor = namelist;
if (!cursor)
return NULL;
for (; cursor; cursor = cursor->next)
{
if (cursor->firstch && cursor->name[0] != path[0])
continue;
if (cursor->regexp)
{
if (fnmatch (cursor->name, path, FNM_LEADING_DIR) == 0)
return cursor;
continue;
}
if (cursor->length <= length
&& (path[cursor->length] == '\0'
|| path[cursor->length] == '/')
&& strncmp (path, cursor->name, cursor->length) == 0)
return cursor;
}
if (same_order_option && namelist->found)
{
name_gather ();
if (namelist->found)
return NULL;
}
else
return NULL;
}
}
struct name *gnu_list_name = NULL;
char *
name_from_list (void)
{
if (!gnu_list_name)
gnu_list_name = namelist;
while (gnu_list_name && gnu_list_name->found)
gnu_list_name = gnu_list_name->next;
if (gnu_list_name)
{
gnu_list_name->found = 1;
if (gnu_list_name->change_dir)
if (chdir (gnu_list_name->change_dir) < 0)
FATAL_ERROR ((0, errno, _("Cannot change to directory %s"),
gnu_list_name->change_dir));
return gnu_list_name->name;
}
return NULL;
}
void
blank_name_list (void)
{
struct name *name;
gnu_list_name = 0;
for (name = namelist; name; name = name->next)
name->found = 0;
}
char *
new_name (const char *path, const char *name)
{
char *buffer = (char *) xmalloc (strlen (path) + strlen (name) + 2);
sprintf (buffer, "%s/%s", path, name);
return buffer;
}