folkslinux
/
rpm
mirror of https://github.com/rpm-software-management/rpm.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
rpm/rpmio/rpmglob.c

971 lines
26 KiB
C
Raw Blame History

#include "system.h"
/* Copyright (C) 1991,92,93,94,95,96,97,98,99 Free Software Foundation, Inc.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; see the file COPYING.LIB. If not,
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
/* AIX requires this to be the first thing in the file. */
#if defined _AIX && !defined __GNUC__
#pragma alloca
#endif
#include "system.h"
#include <stdlib.h>
#include <string.h>
#include <pwd.h>
#include <assert.h>
#include <sys/stat.h> /* S_ISDIR */
/* Bits set in the FLAGS argument to `glob'. */
#define GLOB_ERR (1 << 0) /* Return on read errors. */
#define GLOB_MARK (1 << 1) /* Append a slash to each name. */
#define GLOB_NOSORT (1 << 2) /* Don't sort the names. */
#define GLOB_DOOFFS (1 << 3) /* Insert PGLOB->gl_offs NULLs. */
#define GLOB_NOCHECK (1 << 4) /* If nothing matches, return the pattern. */
#define GLOB_APPEND (1 << 5) /* Append to results of a previous call. */
#define GLOB_NOESCAPE (1 << 6) /* Backslashes don't quote metacharacters. */
#define GLOB_PERIOD (1 << 7) /* Leading `.' can be matched by metachars. */
#define GLOB_MAGCHAR (1 << 8) /* Set in gl_flags if any metachars seen. */
#define GLOB_ALTDIRFUNC (1 << 9) /* Use gl_opendir et al functions. */
#define GLOB_BRACE (1 << 10) /* Expand "{a,b}" to "a" "b". */
#define GLOB_NOMAGIC (1 << 11) /* If no magic chars, return the pattern. */
#define GLOB_TILDE (1 << 12) /* Expand ~user and ~ to home directories. */
#define GLOB_ONLYDIR (1 << 13) /* Match only directories. */
#define GLOB_TILDE_CHECK (1 << 14) /* Like GLOB_TILDE but return an error
if the user name is not available. */
#define __GLOB_FLAGS (GLOB_ERR|GLOB_MARK|GLOB_NOSORT|GLOB_DOOFFS| \
GLOB_NOESCAPE|GLOB_NOCHECK|GLOB_APPEND| \
GLOB_PERIOD|GLOB_ALTDIRFUNC|GLOB_BRACE| \
GLOB_NOMAGIC|GLOB_TILDE|GLOB_ONLYDIR|GLOB_TILDE_CHECK)
/* Error returns from `glob'. */
#define GLOB_NOSPACE 1 /* Ran out of memory. */
#define GLOB_ABORTED 2 /* Read error. */
#define GLOB_NOMATCH 3 /* No matches found. */
#define GLOB_NOSYS 4 /* Not implemented. */
/* Structure describing a globbing run. */
typedef struct {
size_t gl_pathc; /* Count of paths matched by the pattern. */
char **gl_pathv; /* List of matched pathnames. */
size_t gl_offs; /* Slots to reserve in `gl_pathv'. */
int gl_flags; /* Set to FLAGS, maybe | GLOB_MAGCHAR. */
/* If the GLOB_ALTDIRFUNC flag is set, the following functions
are used instead of the normal file access functions. */
void (*gl_closedir)(void *);
struct dirent *(*gl_readdir)(void *);
void *(*gl_opendir)(const char *);
int (*gl_lstat)(const char *, struct stat *);
int (*gl_stat)(const char *, struct stat *);
} glob_t;
#define NAMLEN(_d) NLENGTH(_d)
#if (defined POSIX || defined WINDOWS32) && !defined __GNU_LIBRARY__
/* Posix does not require that the d_ino field be present, and some
systems do not provide it. */
#define REAL_DIR_ENTRY(dp) 1
#else
#define REAL_DIR_ENTRY(dp) (dp->d_ino != 0)
#endif /* POSIX */
#include <errno.h>
#ifndef __set_errno
#define __set_errno(val) errno = (val)
#endif
#include <popt.h>
#include <rpm/rpmfileutil.h>
#include <rpm/rpmurl.h>
#include "debug.h"
/* Outcomment the following line for production quality code. */
/* #define NDEBUG 1 */
#define GLOB_INTERFACE_VERSION 1
static void globfree(glob_t * pglob);
static inline const char *next_brace_sub(const char *begin);
static int glob_in_dir(const char *pattern, const char *directory,
int flags,
int (*errfunc) (const char *, int),
glob_t * pglob);
static int prefix_array(const char *prefix, char **array, size_t n);
static int collated_compare(const void *, const void *);
#ifndef HAVE_MEMPCPY
static void * mempcpy(void *dest, const void *src, size_t n)
{
return (char *) memcpy(dest, src, n) + n;
}
#endif
/* Find the end of the sub-pattern in a brace expression. We define
this as an inline function if the compiler permits. */
static inline const char *next_brace_sub(const char *begin)
{
unsigned int depth = 0;
const char *cp = begin;
while (1) {
if (depth == 0) {
if (*cp != ',' && *cp != '}' && *cp != '\0') {
if (*cp == '{')
++depth;
++cp;
continue;
}
} else {
while (*cp != '\0' && (*cp != '}' || depth > 0)) {
if (*cp == '}')
--depth;
++cp;
}
if (*cp == '\0')
/* An incorrectly terminated brace expression. */
return NULL;
continue;
}
break;
}
return cp;
}
static int __glob_pattern_p(const char *pattern, int quote);
/* Do glob searching for PATTERN, placing results in PGLOB.
The bits defined above may be set in FLAGS.
If a directory cannot be opened or read and ERRFUNC is not nil,
it is called with the pathname that caused the error, and the
`errno' value from the failing call; if it returns non-zero
`glob' returns GLOB_ABORTED; if it returns zero, the error is ignored.
If memory cannot be allocated for PGLOB, GLOB_NOSPACE is returned.
Otherwise, `glob' returns zero. */
static int
glob(const char *pattern, int flags,
int (*errfunc)(const char *, int), glob_t * pglob)
{
const char *filename;
const char *dirname;
size_t dirlen;
int status;
int oldcount;
if (pattern == NULL || pglob == NULL || (flags & ~__GLOB_FLAGS) != 0) {
__set_errno(EINVAL);
return -1;
}
if (flags & GLOB_BRACE) {
const char *begin = strchr(pattern, '{');
if (begin != NULL) {
/* Allocate working buffer large enough for our work. Note that
we have at least an opening and closing brace. */
int firstc;
char *alt_start;
const char *p;
const char *next;
const char *rest;
size_t rest_len;
char onealt[strlen(pattern) - 1];
/* We know the prefix for all sub-patterns. */
alt_start = mempcpy(onealt, pattern, begin - pattern);
/* Find the first sub-pattern and at the same time find the
rest after the closing brace. */
next = next_brace_sub(begin + 1);
if (next == NULL) {
/* It is an illegal expression. */
return glob(pattern, flags & ~GLOB_BRACE, errfunc, pglob);
}
/* Now find the end of the whole brace expression. */
rest = next;
while (*rest != '}') {
rest = next_brace_sub(rest + 1);
if (rest == NULL) {
/* It is an illegal expression. */
return glob(pattern, flags & ~GLOB_BRACE, errfunc,
pglob);
}
}
/* Please note that we now can be sure the brace expression
is well-formed. */
rest_len = strlen(++rest) + 1;
/* We have a brace expression. BEGIN points to the opening {,
NEXT points past the terminator of the first element, and END
points past the final }. We will accumulate result names from
recursive runs for each brace alternative in the buffer using
GLOB_APPEND. */
if (!(flags & GLOB_APPEND)) {
/* This call is to set a new vector, so clear out the
vector so we can append to it. */
pglob->gl_pathc = 0;
pglob->gl_pathv = NULL;
}
firstc = pglob->gl_pathc;
p = begin + 1;
while (1) {
int result;
/* Construct the new glob expression. */
mempcpy(mempcpy(alt_start, p, next - p), rest, rest_len);
result = glob(onealt,
((flags & ~(GLOB_NOCHECK | GLOB_NOMAGIC))
| GLOB_APPEND), errfunc, pglob);
/* If we got an error, return it. */
if (result && result != GLOB_NOMATCH) {
if (!(flags & GLOB_APPEND))
globfree(pglob);
return result;
}
if (*next == '}')
/* We saw the last entry. */
break;
p = next + 1;
next = next_brace_sub(p);
assert(next != NULL);
}
if (pglob->gl_pathc != firstc)
/* We found some entries. */
return 0;
else if (!(flags & (GLOB_NOCHECK | GLOB_NOMAGIC)))
return GLOB_NOMATCH;
}
}
/* Find the filename. */
filename = strrchr(pattern, '/');
if (filename == NULL) {
/* This can mean two things: a simple name or "~name". The latter
case is nothing but a notation for a directory. */
if ((flags & (GLOB_TILDE | GLOB_TILDE_CHECK)) && pattern[0] == '~') {
dirname = pattern;
dirlen = strlen(pattern);
/* Set FILENAME to NULL as a special flag. This is ugly but
other solutions would require much more code. We test for
this special case below. */
filename = NULL;
} else {
filename = pattern;
dirname = ".";
dirlen = 0;
}
} else if (filename == pattern) {
/* "/pattern". */
dirname = "/";
dirlen = 1;
++filename;
} else {
char *newp;
dirlen = filename - pattern;
newp = (char *) alloca(dirlen + 1);
*((char *) mempcpy(newp, pattern, dirlen)) = '\0';
dirname = newp;
++filename;
if (filename[0] == '\0' && dirlen > 1) {
/* "pattern/". Expand "pattern", appending slashes. */
int val = glob(dirname, flags | GLOB_MARK, errfunc, pglob);
if (val == 0)
pglob->gl_flags = ((pglob->gl_flags & ~GLOB_MARK)
| (flags & GLOB_MARK));
return val;
}
}
if (!(flags & GLOB_APPEND)) {
pglob->gl_pathc = 0;
pglob->gl_pathv = NULL;
}
oldcount = pglob->gl_pathc;
if ((flags & (GLOB_TILDE | GLOB_TILDE_CHECK)) && dirname[0] == '~') {
if (dirname[1] == '\0' || dirname[1] == '/') {
/* Look up home directory. */
const char *home_dir = getenv("HOME");
if (home_dir == NULL || home_dir[0] == '\0') {
int success;
char *name;
success = (name = getlogin()) != NULL;
if (success) {
struct passwd *p;
p = getpwnam(name);
if (p != NULL)
home_dir = p->pw_dir;
}
}
if (home_dir == NULL || home_dir[0] == '\0') {
if (flags & GLOB_TILDE_CHECK)
return GLOB_NOMATCH;
else
home_dir = "~"; /* No luck. */
}
/* Now construct the full directory. */
if (dirname[1] == '\0')
dirname = home_dir;
else {
char *newp;
size_t home_len = strlen(home_dir);
newp = (char *) alloca(home_len + dirlen);
mempcpy(mempcpy(newp, home_dir, home_len),
&dirname[1], dirlen);
dirname = newp;
}
}
else {
char *end_name = strchr(dirname, '/');
const char *user_name;
const char *home_dir;
if (end_name == NULL)
user_name = dirname + 1;
else {
char *newp;
newp = (char *) alloca(end_name - dirname);
*((char *) mempcpy(newp, dirname + 1, end_name - dirname))
= '\0';
user_name = newp;
}
/* Look up specific user's home directory. */
{
struct passwd *p;
p = getpwnam(user_name);
if (p != NULL)
home_dir = p->pw_dir;
else
home_dir = NULL;
}
/* If we found a home directory use this. */
if (home_dir != NULL) {
char *newp;
size_t home_len = strlen(home_dir);
size_t rest_len = end_name == NULL ? 0 : strlen(end_name);
newp = (char *) alloca(home_len + rest_len + 1);
*((char *) mempcpy(mempcpy(newp, home_dir, home_len),
end_name, rest_len)) = '\0';
dirname = newp;
} else if (flags & GLOB_TILDE_CHECK)
/* We have to regard it as an error if we cannot find the
home directory. */
return GLOB_NOMATCH;
}
}
/* Now test whether we looked for "~" or "~NAME". In this case we
can give the answer now. */
if (filename == NULL) {
struct stat st;
/* Return the directory if we don't check for error or if it exists. */
if ((flags & GLOB_NOCHECK)
|| (((flags & GLOB_ALTDIRFUNC)
? (*pglob->gl_stat) (dirname, &st)
: stat(dirname, &st)) == 0 && S_ISDIR(st.st_mode))) {
pglob->gl_pathv
= (char **) xrealloc(pglob->gl_pathv,
(pglob->gl_pathc +
((flags & GLOB_DOOFFS) ?
pglob->gl_offs : 0) +
1 + 1) * sizeof(char *));
if (flags & GLOB_DOOFFS)
while (pglob->gl_pathc < pglob->gl_offs)
pglob->gl_pathv[pglob->gl_pathc++] = NULL;
pglob->gl_pathv[pglob->gl_pathc] = xstrdup(dirname);
if (pglob->gl_pathv[pglob->gl_pathc] == NULL) {
free(pglob->gl_pathv);
return GLOB_NOSPACE;
}
pglob->gl_pathv[++pglob->gl_pathc] = NULL;
pglob->gl_flags = flags;
return 0;
}
/* Not found. */
return GLOB_NOMATCH;
}
if (__glob_pattern_p(dirname, !(flags & GLOB_NOESCAPE))) {
/* The directory name contains metacharacters, so we
have to glob for the directory, and then glob for
the pattern in each directory found. */
glob_t dirs;
register int i;
if ((flags & GLOB_ALTDIRFUNC) != 0) {
/* Use the alternative access functions also in the recursive
call. */
dirs.gl_opendir = pglob->gl_opendir;
dirs.gl_readdir = pglob->gl_readdir;
dirs.gl_closedir = pglob->gl_closedir;
dirs.gl_stat = pglob->gl_stat;
dirs.gl_lstat = pglob->gl_lstat;
}
status = glob(dirname,
((flags & (GLOB_ERR | GLOB_NOCHECK | GLOB_NOESCAPE
| GLOB_ALTDIRFUNC))
| GLOB_NOSORT | GLOB_ONLYDIR), errfunc, &dirs);
if (status != 0)
return status;
/* We have successfully globbed the preceding directory name.
For each name we found, call glob_in_dir on it and FILENAME,
appending the results to PGLOB. */
for (i = 0; i < dirs.gl_pathc; ++i) {
int old_pathc = pglob->gl_pathc;
status = glob_in_dir(filename, dirs.gl_pathv[i],
((flags | GLOB_APPEND)
& ~(GLOB_NOCHECK | GLOB_ERR)),
errfunc, pglob);
if (status == GLOB_NOMATCH)
/* No matches in this directory. Try the next. */
continue;
if (status != 0) {
globfree(&dirs);
globfree(pglob);
return status;
}
/* Stick the directory on the front of each name. */
if (prefix_array(dirs.gl_pathv[i],
&pglob->gl_pathv[old_pathc],
pglob->gl_pathc - old_pathc)) {
globfree(&dirs);
globfree(pglob);
return GLOB_NOSPACE;
}
}
flags |= GLOB_MAGCHAR;
/* We have ignored the GLOB_NOCHECK flag in the `glob_in_dir' calls.
But if we have not found any matching entry and thie GLOB_NOCHECK
flag was set we must return the list consisting of the disrectory
names followed by the filename. */
if (pglob->gl_pathc == oldcount) {
/* No matches. */
if (flags & GLOB_NOCHECK) {
size_t filename_len = strlen(filename) + 1;
char **new_pathv;
struct stat st;
/* This is an pessimistic guess about the size. */
pglob->gl_pathv
= (char **) xrealloc(pglob->gl_pathv,
(pglob->gl_pathc +
((flags & GLOB_DOOFFS) ?
pglob->gl_offs : 0) +
dirs.gl_pathc + 1) *
sizeof(char *));
if (flags & GLOB_DOOFFS)
while (pglob->gl_pathc < pglob->gl_offs)
pglob->gl_pathv[pglob->gl_pathc++] = NULL;
for (i = 0; i < dirs.gl_pathc; ++i) {
const char *dir = dirs.gl_pathv[i];
size_t dir_len = strlen(dir);
/* First check whether this really is a directory. */
if (((flags & GLOB_ALTDIRFUNC)
? (*pglob->gl_stat) (dir, &st) : stat(dir,
&st)) != 0
|| !S_ISDIR(st.st_mode))
/* No directory, ignore this entry. */
continue;
pglob->gl_pathv[pglob->gl_pathc] = xmalloc(dir_len + 1
+
filename_len);
mempcpy(mempcpy
(mempcpy
(pglob->gl_pathv[pglob->gl_pathc], dir,
dir_len), "/", 1), filename, filename_len);
++pglob->gl_pathc;
}
pglob->gl_pathv[pglob->gl_pathc] = NULL;
pglob->gl_flags = flags;
/* Now we know how large the gl_pathv vector must be. */
new_pathv = (char **) xrealloc(pglob->gl_pathv,
((pglob->gl_pathc + 1)
* sizeof(char *)));
pglob->gl_pathv = new_pathv;
} else
return GLOB_NOMATCH;
}
globfree(&dirs);
} else {
status = glob_in_dir(filename, dirname, flags, errfunc, pglob);
if (status != 0)
return status;
if (dirlen > 0) {
/* Stick the directory on the front of each name. */
int ignore = oldcount;
if ((flags & GLOB_DOOFFS) && ignore < pglob->gl_offs)
ignore = pglob->gl_offs;
if (prefix_array(dirname,
&pglob->gl_pathv[ignore],
pglob->gl_pathc - ignore)) {
globfree(pglob);
return GLOB_NOSPACE;
}
}
}
if (flags & GLOB_MARK) {
/* Append slashes to directory names. */
int i;
struct stat st;
for (i = oldcount; i < pglob->gl_pathc; ++i)
if (((flags & GLOB_ALTDIRFUNC)
? (*pglob->gl_stat) (pglob->gl_pathv[i], &st)
: stat(pglob->gl_pathv[i], &st)) == 0
&& S_ISDIR(st.st_mode)) {
size_t len = strlen(pglob->gl_pathv[i]) + 2;
char *new = xrealloc(pglob->gl_pathv[i], len);
strcpy(&new[len - 2], "/");
pglob->gl_pathv[i] = new;
}
}
if (!(flags & GLOB_NOSORT)) {
/* Sort the vector. */
int non_sort = oldcount;
if ((flags & GLOB_DOOFFS) && pglob->gl_offs > oldcount)
non_sort = pglob->gl_offs;
qsort(& pglob->gl_pathv[non_sort],
pglob->gl_pathc - non_sort,
sizeof(char *), collated_compare);
}
return 0;
}
/* Free storage allocated in PGLOB by a previous `glob' call. */
static void globfree(glob_t * pglob)
{
if (pglob->gl_pathv != NULL) {
register int i;
for (i = 0; i < pglob->gl_pathc; ++i)
if (pglob->gl_pathv[i] != NULL)
free(pglob->gl_pathv[i]);
free(pglob->gl_pathv);
}
}
/* Do a collated comparison of A and B. */
static int collated_compare(const void * a, const void * b)
{
const char *const s1 = *(const char *const *const) a;
const char *const s2 = *(const char *const *const) b;
if (s1 == s2)
return 0;
if (s1 == NULL)
return 1;
if (s2 == NULL)
return -1;
return strcoll(s1, s2);
}
/* Prepend DIRNAME to each of N members of ARRAY, replacing ARRAY's
elements in place. Return nonzero if out of memory, zero if successful.
A slash is inserted between DIRNAME and each elt of ARRAY,
unless DIRNAME is just "/". Each old element of ARRAY is freed. */
static int prefix_array(const char *dirname, char **array, size_t n)
{
register size_t i;
size_t dirlen = strlen(dirname);
if (dirlen == 1 && dirname[0] == '/')
/* DIRNAME is just "/", so normal prepending would get us "//foo".
We want "/foo" instead, so don't prepend any chars from DIRNAME. */
dirlen = 0;
for (i = 0; i < n; ++i) {
size_t eltlen = strlen(array[i]) + 1;
char *new = (char *) xmalloc(dirlen + 1 + eltlen);
{
char *endp = (char *) mempcpy(new, dirname, dirlen);
*endp++ = '/';
mempcpy(endp, array[i], eltlen);
}
free(array[i]);
array[i] = new;
}
return 0;
}
/* Return nonzero if PATTERN contains any metacharacters.
Metacharacters can be quoted with backslashes if QUOTE is nonzero. */
static int __glob_pattern_p(const char *pattern, int quote)
{
register const char *p;
int open = 0;
for (p = pattern; *p != '\0'; ++p)
switch (*p) {
case '?':
case '*':
return 1;
case '\\':
if (quote && p[1] != '\0')
++p;
break;
case '[':
open = 1;
break;
case ']':
if (open)
return 1;
break;
}
return 0;
}
/* Like `glob', but PATTERN is a final pathname component,
and matches are searched for in DIRECTORY.
The GLOB_NOSORT bit in FLAGS is ignored. No sorting is ever done.
The GLOB_APPEND flag is assumed to be set (always appends). */
static int
glob_in_dir(const char *pattern, const char *directory, int flags,
int (*errfunc)(const char *, int), glob_t * pglob)
{
void * stream = NULL;
struct globlink {
struct globlink *next;
char *name;
};
struct globlink *names = NULL;
size_t nfound;
int meta;
int save;
meta = __glob_pattern_p(pattern, !(flags & GLOB_NOESCAPE));
if (meta == 0) {
if (flags & (GLOB_NOCHECK | GLOB_NOMAGIC))
/* We need not do any tests. The PATTERN contains no meta
characters and we must not return an error therefore the
result will always contain exactly one name. */
flags |= GLOB_NOCHECK;
else {
/* Since we use the normal file functions we can also use stat()
to verify the file is there. */
struct stat st;
size_t patlen = strlen(pattern);
size_t dirlen = strlen(directory);
char *fullname = (char *) alloca(dirlen + 1 + patlen + 1);
mempcpy(mempcpy(mempcpy(fullname, directory, dirlen),
"/", 1), pattern, patlen + 1);
if (((flags & GLOB_ALTDIRFUNC)
? (*pglob->gl_stat) (fullname, &st)
: stat(fullname, &st)) == 0)
/* We found this file to be existing. Now tell the rest
of the function to copy this name into the result. */
flags |= GLOB_NOCHECK;
}
nfound = 0;
} else {
if (pattern[0] == '\0') {
/* This is a special case for matching directories like in
"*a/". */
names = (struct globlink *) alloca(sizeof(struct globlink));
names->name = (char *) xmalloc(1);
names->name[0] = '\0';
names->next = NULL;
nfound = 1;
meta = 0;
} else {
stream = ((flags & GLOB_ALTDIRFUNC)
? (*pglob->gl_opendir) (directory)
: opendir(directory));
if (stream == NULL) {
if (errno != ENOTDIR
&& ((errfunc != NULL && (*errfunc) (directory, errno))
|| (flags & GLOB_ERR)))
return GLOB_ABORTED;
nfound = 0;
meta = 0;
} else {
int fnm_flags = ((!(flags & GLOB_PERIOD) ? FNM_PERIOD : 0) |
((flags & GLOB_NOESCAPE) ? FNM_NOESCAPE : 0));
nfound = 0;
flags |= GLOB_MAGCHAR;
while (1) {
const char *name;
size_t len;
struct dirent *d = ((flags & GLOB_ALTDIRFUNC)
? (*pglob->gl_readdir) (stream)
: readdir((DIR *) stream));
if (d == NULL)
break;
if (!REAL_DIR_ENTRY(d))
continue;
#ifdef HAVE_STRUCT_DIRENT_D_TYPE
/* If we shall match only directories use the information
provided by the dirent call if possible. */
if ((flags & GLOB_ONLYDIR)
&& d->d_type != DT_UNKNOWN && d->d_type != DT_DIR)
continue;
#endif
name = d->d_name;
if (fnmatch(pattern, name, fnm_flags) == 0) {
struct globlink *new = (struct globlink *)
alloca(sizeof(struct globlink));
len = NAMLEN(d);
new->name = (char *) xmalloc(len + 1);
*((char *) mempcpy(new->name, name, len))
= '\0';
new->next = names;
names = new;
++nfound;
}
}
}
}
}
if (nfound == 0 && (flags & GLOB_NOCHECK)) {
size_t len = strlen(pattern);
nfound = 1;
names = (struct globlink *) alloca(sizeof(struct globlink));
names->next = NULL;
names->name = (char *) xmalloc(len + 1);
*((char *) mempcpy(names->name, pattern, len)) = '\0';
}
if (nfound != 0) {
pglob->gl_pathv
= (char **) xrealloc(pglob->gl_pathv,
(pglob->gl_pathc +
((flags & GLOB_DOOFFS) ? pglob->
gl_offs : 0) + nfound +
1) * sizeof(char *));
if (flags & GLOB_DOOFFS)
while (pglob->gl_pathc < pglob->gl_offs)
pglob->gl_pathv[pglob->gl_pathc++] = NULL;
for (; names != NULL; names = names->next)
pglob->gl_pathv[pglob->gl_pathc++] = names->name;
pglob->gl_pathv[pglob->gl_pathc] = NULL;
pglob->gl_flags = flags;
}
save = errno;
if (stream != NULL) {
if (flags & GLOB_ALTDIRFUNC)
(*pglob->gl_closedir) (stream);
else
closedir((DIR *) stream);
}
__set_errno(save);
return nfound == 0 ? GLOB_NOMATCH : 0;
}
/* librpmio exported interfaces */
int rpmGlob(const char * patterns, int * argcPtr, ARGV_t * argvPtr)
{
int ac = 0;
const char ** av = NULL;
int argc = 0;
ARGV_t argv = NULL;
char * globRoot = NULL;
const char *home = getenv("HOME");
int gflags = 0;
#ifdef ENABLE_NLS
char * old_collate = NULL;
char * old_ctype = NULL;
const char * t;
#endif
size_t maxb, nb;
int i, j;
int rc;
if (home != NULL && strlen(home) > 0)
gflags |= GLOB_TILDE;
/* Can't use argvSplit() here, it doesn't handle whitespace etc escapes */
rc = poptParseArgvString(patterns, &ac, &av);
if (rc)
return rc;
#ifdef ENABLE_NLS
t = setlocale(LC_COLLATE, NULL);
if (t)
old_collate = xstrdup(t);
t = setlocale(LC_CTYPE, NULL);
if (t)
old_ctype = xstrdup(t);
(void) setlocale(LC_COLLATE, "C");
(void) setlocale(LC_CTYPE, "C");
#endif
if (av != NULL)
for (j = 0; j < ac; j++) {
char * globURL;
const char * path;
int ut = urlPath(av[j], &path);
int local = (ut == URL_IS_PATH) || (ut == URL_IS_UNKNOWN);
size_t plen = strlen(path);
int flags = gflags;
int dir_only = (plen > 0 && path[plen-1] == '/');
glob_t gl;
if (!local || (!rpmIsGlob(av[j], 0) && strchr(path, '~') == NULL)) {
argvAdd(&argv, av[j]);
continue;
}
if (dir_only)
flags |= GLOB_ONLYDIR;
gl.gl_pathc = 0;
gl.gl_pathv = NULL;
rc = glob(av[j], flags, NULL, &gl);
if (rc)
goto exit;
/* XXX Prepend the URL leader for globs that have stripped it off */
maxb = 0;
for (i = 0; i < gl.gl_pathc; i++) {
if ((nb = strlen(&(gl.gl_pathv[i][0]))) > maxb)
maxb = nb;
}
nb = ((ut == URL_IS_PATH) ? (path - av[j]) : 0);
maxb += nb;
maxb += 1;
globURL = globRoot = xmalloc(maxb);
switch (ut) {
case URL_IS_PATH:
case URL_IS_DASH:
strncpy(globRoot, av[j], nb);
break;
case URL_IS_HTTPS:
case URL_IS_HTTP:
case URL_IS_FTP:
case URL_IS_HKP:
case URL_IS_UNKNOWN:
default:
break;
}
globRoot += nb;
*globRoot = '\0';
for (i = 0; i < gl.gl_pathc; i++) {
const char * globFile = &(gl.gl_pathv[i][0]);
if (dir_only) {
struct stat sb;
if (lstat(gl.gl_pathv[i], &sb) || !S_ISDIR(sb.st_mode))
continue;
}
if (globRoot > globURL && globRoot[-1] == '/')
while (*globFile == '/') globFile++;
strcpy(globRoot, globFile);
argvAdd(&argv, globURL);
}
globfree(&gl);
free(globURL);
}
argc = argvCount(argv);
if (argc > 0) {
if (argvPtr)
*argvPtr = argv;
if (argcPtr)
*argcPtr = argc;
rc = 0;
} else
rc = 1;
exit:
#ifdef ENABLE_NLS
if (old_collate) {
(void) setlocale(LC_COLLATE, old_collate);
free(old_collate);
}
if (old_ctype) {
(void) setlocale(LC_CTYPE, old_ctype);
free(old_ctype);
}
#endif
av = _free(av);
if (rc || argvPtr == NULL) {
argvFree(argv);
}
return rc;
}
int rpmIsGlob(const char * pattern, int quote)
{
return __glob_pattern_p(pattern, quote);
}
Reference in New Issue View Git Blame Copy Permalink