ref: 33636932054f74c7a922a9713a9229d6d5fc7f38
dir: /sys/src/ape/cmd/pax/namelist.c/
/* $Source: /u/mark/src/pax/RCS/namelist.c,v $
*
* $Revision: 1.6 $
*
* namelist.c - track filenames given as arguments to tar/cpio/pax
*
* DESCRIPTION
*
* Arguments may be regular expressions, therefore all agurments will
* be treated as if they were regular expressions, even if they are
* not.
*
* AUTHOR
*
* Mark H. Colburn, NAPS International ([email protected])
*
* Sponsored by The USENIX Association for public distribution.
*
* Copyright (c) 1989 Mark H. Colburn.
* All rights reserved.
*
* Redistribution and use in source and binary forms are permitted
* provided that the above copyright notice is duplicated in all such
* forms and that any documentation, advertising materials, and other
* materials related to such distribution and use acknowledge that the
* software was developed by Mark H. Colburn and sponsored by The
* USENIX Association.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* $Log: namelist.c,v $
* Revision 1.6 89/02/13 09:14:48 mark
* Fixed problem with directory errors
*
* Revision 1.5 89/02/12 12:14:00 mark
* Fixed misspellings
*
* Revision 1.4 89/02/12 11:25:19 mark
* Modifications to compile and link cleanly under USG
*
* Revision 1.3 89/02/12 10:40:23 mark
* Fixed casting problems
*
* Revision 1.2 89/02/12 10:04:57 mark
* 1.2 release fixes
*
* Revision 1.1 88/12/23 18:02:17 mark
* Initial revision
*
*/
#ifndef lint
static char *ident = "$Id: namelist.c,v 1.6 89/02/13 09:14:48 mark Exp $";
static char *copyright = "Copyright (c) 1989 Mark H. Colburn.\nAll rights reserved.\n";
#endif /* ! lint */
/* Headers */
#include "pax.h"
/* Type Definitions */
/*
* Structure for keeping track of filenames and lists thereof.
*/
struct nm_list {
struct nm_list *next;
short length; /* cached strlen(name) */
char found; /* A matching file has been found */
char firstch; /* First char is literally matched */
char re; /* regexp pattern for item */
char name[1]; /* name of file or rexexp */
};
struct dirinfo {
char dirname[PATH_MAX + 1]; /* name of directory */
OFFSET where; /* current location in directory */
struct dirinfo *next;
};
/* Static Variables */
static struct dirinfo *stack_head = (struct dirinfo *)NULL;
/* Function Prototypes */
#ifndef __STDC__
static void pushdir();
static struct dirinfo *popdir();
#else
static void pushdir(struct dirinfo *info);
static struct dirinfo *popdir(void);
#endif
/* Internal Identifiers */
static struct nm_list *namelast; /* Points to last name in list */
static struct nm_list *namelist; /* Points to first name in list */
/* addname - add a name to the namelist.
*
* DESCRIPTION
*
* Addname adds the name given to the name list. Memory for the
* namelist structure is dynamically allocated. If the space for
* the structure cannot be allocated, then the program will exit
* the an out of memory error message and a non-zero return code
* will be returned to the caller.
*
* PARAMETERS
*
* char *name - A pointer to the name to add to the list
*/
#ifdef __STDC__
void add_name(char *name)
#else
void add_name(name)
char *name; /* pointer to name */
#endif
{
int i; /* Length of string */
struct nm_list *p; /* Current struct pointer */
i = strlen(name);
p = (struct nm_list *) malloc((unsigned) (i + sizeof(struct nm_list)));
if (!p) {
fatal("cannot allocate memory for namelist entry\n");
}
p->next = (struct nm_list *)NULL;
p->length = i;
strncpy(p->name, name, i);
p->name[i] = '\0'; /* Null term */
p->found = 0;
p->firstch = isalpha(name[0]);
if (strchr(name, '*') || strchr(name, '[') || strchr(name, '?')) {
p->re = 1;
}
if (namelast) {
namelast->next = p;
}
namelast = p;
if (!namelist) {
namelist = p;
}
}
/* name_match - match a name from an archive with a name from the namelist
*
* DESCRIPTION
*
* Name_match attempts to find a name pointed at by p in the namelist.
* If no namelist is available, then all filenames passed in are
* assumed to match the filename criteria. Name_match knows how to
* match names with regular expressions, etc.
*
* PARAMETERS
*
* char *p - the name to match
*
* RETURNS
*
* Returns 1 if the name is in the namelist, or no name list is
* available, otherwise returns 0
*
*/
#ifdef __STDC__
int name_match(char *p)
#else
int name_match(p)
char *p;
#endif
{
struct nm_list *nlp;
int len;
if ((nlp = namelist) == 0) {/* Empty namelist is easy */
return (1);
}
len = strlen(p);
for (; nlp != 0; nlp = nlp->next) {
/* If first chars don't match, quick skip */
if (nlp->firstch && nlp->name[0] != p[0]) {
continue;
}
/* Regular expressions */
if (nlp->re) {
if (wildmat(nlp->name, p)) {
nlp->found = 1; /* Remember it matched */
return (1); /* We got a match */
}
continue;
}
/* Plain Old Strings */
if (nlp->length <= len /* Archive len >= specified */
&& (p[nlp->length] == '\0' || p[nlp->length] == '/')
&& strncmp(p, nlp->name, nlp->length) == 0) {
/* Name compare */
nlp->found = 1; /* Remember it matched */
return (1); /* We got a match */
}
}
return (0);
}
/* names_notfound - print names of files in namelist that were not found
*
* DESCRIPTION
*
* Names_notfound scans through the namelist for any files which were
* named, but for which a matching file was not processed by the
* archive. Each of the files is listed on the standard error.
*
*/
#ifdef __STDC__
void names_notfound(void)
#else
void names_notfound()
#endif
{
struct nm_list *nlp;
for (nlp = namelist; nlp != 0; nlp = nlp->next) {
if (!nlp->found) {
fprintf(stderr, "%s: %s not found in archive\n",
myname, nlp->name);
}
free(nlp);
}
namelist = (struct nm_list *)NULL;
namelast = (struct nm_list *)NULL;
}
/* name_init - set up to gather file names
*
* DESCRIPTION
*
* Name_init sets up the namelist pointers so that we may access the
* command line arguments. At least the first item of the command
* line (argv[0]) is assumed to be stripped off, prior to the
* name_init call.
*
* PARAMETERS
*
* int argc - number of items in argc
* char **argv - pointer to the command line arguments
*/
#ifdef __STDC__
void name_init(int argc, char **argv)
#else
void name_init(argc, argv)
int argc;
char **argv;
#endif
{
/* Get file names from argv, after options. */
n_argc = argc;
n_argv = argv;
}
/* name_next - get the next name from argv or the name file.
*
* DESCRIPTION
*
* Name next finds the next name which is to be processed in the
* archive. If the named file is a directory, then the directory
* is recursively traversed for additional file names. Directory
* names and locations within the directory are kept track of by
* using a directory stack. See the pushdir/popdir function for
* more details.
*
* The names come from argv, after options or from the standard input.
*
* PARAMETERS
*
* name - a pointer to a buffer of at least MAX_PATH + 1 bytes long;
* statbuf - a pointer to a stat structure
*
* RETURNS
*
* Returns -1 if there are no names left, (e.g. EOF), otherwise returns
* 0
*/
#ifdef __STDC__
int name_next(char *name, Stat *statbuf)
#else
int name_next(name, statbuf)
char *name;
Stat *statbuf;
#endif
{
int err = -1;
static int in_subdir = 0;
static DIR *dirp;
struct dirent *d;
static struct dirinfo *curr_dir;
int len;
do {
if (names_from_stdin) {
if (lineget(stdin, name) < 0) {
return (-1);
}
if (nameopt(name) < 0) {
continue;
}
} else {
if (in_subdir) {
if ((d = readdir(dirp)) != (struct dirent *)NULL) {
/* Skip . and .. */
if (strcmp(d->d_name, ".") == 0 ||
strcmp(d->d_name, "..") == 0) {
continue;
}
if (strlen(d->d_name) +
strlen(curr_dir->dirname) >= PATH_MAX) {
warn("name too long", d->d_name);
continue;
}
strcpy(name, curr_dir->dirname);
strcat(name, d->d_name);
} else {
closedir(dirp);
in_subdir--;
curr_dir = popdir();
if (in_subdir) {
errno = 0;
if ((dirp=opendir(curr_dir->dirname)) == (DIR *)NULL) {
warn(curr_dir->dirname, "error opening directory (1)");
in_subdir--;
}
seekdir(dirp, curr_dir->where);
}
continue;
}
} else if (optind >= n_argc) {
return (-1);
} else {
strcpy(name, n_argv[optind++]);
}
}
if ((err = LSTAT(name, statbuf)) < 0) {
warn(name, strerror());
continue;
}
if (!names_from_stdin && (statbuf->sb_mode & S_IFMT) == S_IFDIR) {
if (in_subdir) {
curr_dir->where = telldir(dirp);
pushdir(curr_dir);
closedir(dirp);
}
in_subdir++;
/* Build new prototype name */
if ((curr_dir = (struct dirinfo *) mem_get(sizeof(struct dirinfo)))
== (struct dirinfo *)NULL) {
exit(2);
}
strcpy(curr_dir->dirname, name);
len = strlen(curr_dir->dirname);
while (len >= 1 && curr_dir->dirname[len - 1] == '/') {
len--; /* Delete trailing slashes */
}
curr_dir->dirname[len++] = '/'; /* Now add exactly one back */
curr_dir->dirname[len] = '\0';/* Make sure null-terminated */
curr_dir->where = 0;
errno = 0;
do {
if ((dirp = opendir(curr_dir->dirname)) == (DIR *)NULL) {
warn(curr_dir->dirname, "error opening directory (2)");
if (in_subdir > 1) {
curr_dir = popdir();
}
in_subdir--;
err = -1;
continue;
} else {
seekdir(dirp, curr_dir->where);
}
} while (in_subdir && (! dirp));
}
} while (err < 0);
return (0);
}
/* name_gather - gather names in a list for scanning.
*
* DESCRIPTION
*
* Name_gather takes names from the command line and adds them to
* the name list.
*
* FIXME
*
* We could hash the names if we really care about speed here.
*/
#ifdef __STDC__
void name_gather(void)
#else
void name_gather()
#endif
{
while (optind < n_argc) {
add_name(n_argv[optind++]);
}
}
/* pushdir - pushes a directory name on the directory stack
*
* DESCRIPTION
*
* The pushdir function puses the directory structure which is pointed
* to by "info" onto a stack for later processing. The information
* may be retrieved later with a call to popdir().
*
* PARAMETERS
*
* dirinfo *info - pointer to directory structure to save
*/
#ifdef __STDC__
static void pushdir(struct dirinfo *info)
#else
static void pushdir(info)
struct dirinfo *info;
#endif
{
if (stack_head == (struct dirinfo *)NULL) {
stack_head = info;
stack_head->next = (struct dirinfo *)NULL;
} else {
info->next = stack_head;
stack_head = info;
}
}
/* popdir - pop a directory structure off the directory stack.
*
* DESCRIPTION
*
* The popdir function pops the most recently pushed directory
* structure off of the directory stack and returns it to the calling
* function.
*
* RETURNS
*
* Returns a pointer to the most recently pushed directory structure
* or NULL if the stack is empty.
*/
#ifdef __STDC__
static struct dirinfo *popdir(void)
#else
static struct dirinfo *popdir()
#endif
{
struct dirinfo *tmp;
if (stack_head == (struct dirinfo *)NULL) {
return((struct dirinfo *)NULL);
} else {
tmp = stack_head;
stack_head = stack_head->next;
}
return(tmp);
}