#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 #include #include #include #include /* 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 #ifndef __set_errno #define __set_errno(val) errno = (val) #endif #include #include #include #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); }