1449 lines
35 KiB
C
1449 lines
35 KiB
C
/* Copyright (C) 1991-1999, 2000 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
|
||
|
||
#ifdef HAVE_CONFIG_H
|
||
# include <config.h>
|
||
#endif
|
||
|
||
/* Enable GNU extensions in glob.h. */
|
||
#ifndef _GNU_SOURCE
|
||
# define _GNU_SOURCE 1
|
||
#endif
|
||
|
||
#include <errno.h>
|
||
#include <sys/types.h>
|
||
#include <sys/stat.h>
|
||
|
||
/* Outcomment the following line for production quality code. */
|
||
/* #define NDEBUG 1 */
|
||
#include <assert.h>
|
||
|
||
#include <stdio.h> /* Needed on stupid SunOS for assert. */
|
||
|
||
|
||
/* Comment out all this code if we are using the GNU C Library, and are not
|
||
actually compiling the library itself. This code is part of the GNU C
|
||
Library, but also included in many other GNU distributions. Compiling
|
||
and linking in this code is a waste when using the GNU C library
|
||
(especially if it is a shared library). Rather than having every GNU
|
||
program understand `configure --with-gnu-libc' and omit the object files,
|
||
it is simpler to just do this in the source for each such file. */
|
||
|
||
#define GLOB_INTERFACE_VERSION 1
|
||
#if !defined _LIBC && defined __GNU_LIBRARY__ && __GNU_LIBRARY__ > 1
|
||
# include <gnu-versions.h>
|
||
# if _GNU_GLOB_INTERFACE_VERSION == GLOB_INTERFACE_VERSION
|
||
# define ELIDE_CODE
|
||
# endif
|
||
#endif
|
||
|
||
#ifndef ELIDE_CODE
|
||
#if !defined _LIBC || !defined GLOB_ONLY_P
|
||
|
||
#if defined STDC_HEADERS || defined __GNU_LIBRARY__
|
||
# include <stddef.h>
|
||
#endif
|
||
|
||
#if defined HAVE_UNISTD_H || defined _LIBC
|
||
# include <unistd.h>
|
||
# ifndef POSIX
|
||
# ifdef _POSIX_VERSION
|
||
# define POSIX
|
||
# endif
|
||
# endif
|
||
#endif
|
||
|
||
#if !defined _AMIGA && !defined VMS && !defined WINDOWS32
|
||
# include <pwd.h>
|
||
#endif
|
||
|
||
#if !defined __GNU_LIBRARY__ && !defined STDC_HEADERS
|
||
extern int errno;
|
||
#endif
|
||
#ifndef __set_errno
|
||
# define __set_errno(val) errno = (val)
|
||
#endif
|
||
|
||
#ifndef NULL
|
||
# define NULL 0
|
||
#endif
|
||
|
||
|
||
#if defined HAVE_DIRENT_H || defined __GNU_LIBRARY__
|
||
# include <dirent.h>
|
||
# define NAMLEN(dirent) strlen((dirent)->d_name)
|
||
#else
|
||
# define dirent direct
|
||
# define NAMLEN(dirent) (dirent)->d_namlen
|
||
# ifdef HAVE_SYS_NDIR_H
|
||
# include <sys/ndir.h>
|
||
# endif
|
||
# ifdef HAVE_SYS_DIR_H
|
||
# include <sys/dir.h>
|
||
# endif
|
||
# ifdef HAVE_NDIR_H
|
||
# include <ndir.h>
|
||
# endif
|
||
# ifdef HAVE_VMSDIR_H
|
||
# include "vmsdir.h"
|
||
# endif /* HAVE_VMSDIR_H */
|
||
#endif
|
||
|
||
|
||
/* In GNU systems, <dirent.h> defines this macro for us. */
|
||
#ifdef _D_NAMLEN
|
||
# undef NAMLEN
|
||
# define NAMLEN(d) _D_NAMLEN(d)
|
||
#endif
|
||
|
||
/* When used in the GNU libc the symbol _DIRENT_HAVE_D_TYPE is available
|
||
if the `d_type' member for `struct dirent' is available. */
|
||
#ifdef _DIRENT_HAVE_D_TYPE
|
||
# define HAVE_D_TYPE 1
|
||
#endif
|
||
|
||
|
||
#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 */
|
||
|
||
#if defined STDC_HEADERS || defined __GNU_LIBRARY__
|
||
# include <stdlib.h>
|
||
# include <string.h>
|
||
# define ANSI_STRING
|
||
#else /* No standard headers. */
|
||
|
||
extern char *getenv ();
|
||
|
||
# ifdef HAVE_STRING_H
|
||
# include <string.h>
|
||
# define ANSI_STRING
|
||
# else
|
||
# include <strings.h>
|
||
# endif
|
||
# ifdef HAVE_MEMORY_H
|
||
# include <memory.h>
|
||
# endif
|
||
|
||
extern char *malloc (), *realloc ();
|
||
extern void free ();
|
||
|
||
extern void qsort ();
|
||
extern void abort (), exit ();
|
||
|
||
#endif /* Standard headers. */
|
||
|
||
#ifndef ANSI_STRING
|
||
|
||
# ifndef bzero
|
||
extern void bzero ();
|
||
# endif
|
||
# ifndef bcopy
|
||
extern void bcopy ();
|
||
# endif
|
||
|
||
# define memcpy(d, s, n) bcopy ((s), (d), (n))
|
||
# define strrchr rindex
|
||
/* memset is only used for zero here, but let's be paranoid. */
|
||
# define memset(s, better_be_zero, n) \
|
||
((void) ((better_be_zero) == 0 ? (bzero((s), (n)), 0) : (abort(), 0)))
|
||
#endif /* Not ANSI_STRING. */
|
||
|
||
#if !defined HAVE_STRCOLL && !defined _LIBC
|
||
# define strcoll strcmp
|
||
#endif
|
||
|
||
#if !defined HAVE_MEMPCPY && __GLIBC__ - 0 == 2 && __GLIBC_MINOR__ >= 1
|
||
# define HAVE_MEMPCPY 1
|
||
# undef mempcpy
|
||
# define mempcpy(Dest, Src, Len) __mempcpy (Dest, Src, Len)
|
||
#endif
|
||
|
||
#ifndef __GNU_LIBRARY__
|
||
# ifdef __GNUC__
|
||
__inline
|
||
# endif
|
||
# ifndef __SASC
|
||
# ifdef WINDOWS32
|
||
static void *
|
||
# else
|
||
static char *
|
||
# endif
|
||
my_realloc (p, n)
|
||
char *p;
|
||
unsigned int n;
|
||
{
|
||
/* These casts are the for sake of the broken Ultrix compiler,
|
||
which warns of illegal pointer combinations otherwise. */
|
||
if (p == NULL)
|
||
return (char *) malloc (n);
|
||
return (char *) realloc (p, n);
|
||
}
|
||
# define realloc my_realloc
|
||
# endif /* __SASC */
|
||
#endif /* __GNU_LIBRARY__ */
|
||
|
||
|
||
#if !defined __alloca && !defined __GNU_LIBRARY__
|
||
|
||
# ifdef __GNUC__
|
||
# undef alloca
|
||
# define alloca(n) __builtin_alloca (n)
|
||
# else /* Not GCC. */
|
||
# ifdef HAVE_ALLOCA_H
|
||
# include <alloca.h>
|
||
# else /* Not HAVE_ALLOCA_H. */
|
||
# ifndef _AIX
|
||
# ifdef WINDOWS32
|
||
# include <malloc.h>
|
||
# else
|
||
extern char *alloca ();
|
||
# endif /* WINDOWS32 */
|
||
# endif /* Not _AIX. */
|
||
# endif /* sparc or HAVE_ALLOCA_H. */
|
||
# endif /* GCC. */
|
||
|
||
# define __alloca alloca
|
||
|
||
#endif
|
||
|
||
#ifndef __GNU_LIBRARY__
|
||
# define __stat stat
|
||
# ifdef STAT_MACROS_BROKEN
|
||
# undef S_ISDIR
|
||
# endif
|
||
# ifndef S_ISDIR
|
||
# define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR)
|
||
# endif
|
||
#endif
|
||
|
||
#ifdef _LIBC
|
||
# undef strdup
|
||
# define strdup(str) __strdup (str)
|
||
# define sysconf(id) __sysconf (id)
|
||
# define closedir(dir) __closedir (dir)
|
||
# define opendir(name) __opendir (name)
|
||
# define readdir(str) __readdir (str)
|
||
# define getpwnam_r(name, bufp, buf, len, res) \
|
||
__getpwnam_r (name, bufp, buf, len, res)
|
||
# ifndef __stat64
|
||
# define __stat64(fname, buf) __xstat64 (_STAT_VER, fname, buf)
|
||
# endif
|
||
# define HAVE_STAT64 1
|
||
#endif
|
||
|
||
#ifndef HAVE_STAT64
|
||
# define __stat64(fname, buf) __stat (fname, buf)
|
||
/* This is the variable name we are using. */
|
||
# define st64 st
|
||
#endif
|
||
|
||
#if !(defined STDC_HEADERS || defined __GNU_LIBRARY__)
|
||
# undef size_t
|
||
# define size_t unsigned int
|
||
#endif
|
||
|
||
/* Some system header files erroneously define these.
|
||
We want our own definitions from <fnmatch.h> to take precedence. */
|
||
#ifndef __GNU_LIBRARY__
|
||
# undef FNM_PATHNAME
|
||
# undef FNM_NOESCAPE
|
||
# undef FNM_PERIOD
|
||
#endif
|
||
#include <fnmatch.h>
|
||
|
||
/* Some system header files erroneously define these.
|
||
We want our own definitions from <glob.h> to take precedence. */
|
||
#ifndef __GNU_LIBRARY__
|
||
# undef GLOB_ERR
|
||
# undef GLOB_MARK
|
||
# undef GLOB_NOSORT
|
||
# undef GLOB_DOOFFS
|
||
# undef GLOB_NOCHECK
|
||
# undef GLOB_APPEND
|
||
# undef GLOB_NOESCAPE
|
||
# undef GLOB_PERIOD
|
||
#endif
|
||
#include <glob.h>
|
||
|
||
#ifdef HAVE_GETLOGIN_R
|
||
extern int getlogin_r __P ((char *, size_t));
|
||
#else
|
||
extern char *getlogin __P ((void));
|
||
#endif
|
||
|
||
static
|
||
#if __GNUC__ - 0 >= 2
|
||
inline
|
||
#endif
|
||
const char *next_brace_sub __P ((const char *begin));
|
||
|
||
#endif /* GLOB_ONLY_P */
|
||
|
||
static int glob_in_dir __P ((const char *pattern, const char *directory,
|
||
int flags,
|
||
int (*errfunc) (const char *, int),
|
||
glob_t *pglob));
|
||
|
||
#if !defined _LIBC || !defined GLOB_ONLY_P
|
||
static int prefix_array __P ((const char *prefix, char **array, size_t n));
|
||
static int collated_compare __P ((const __ptr_t, const __ptr_t));
|
||
|
||
|
||
/* Find the end of the sub-pattern in a brace expression. We define
|
||
this as an inline function if the compiler permits. */
|
||
static
|
||
#if __GNUC__ - 0 >= 2
|
||
inline
|
||
#endif
|
||
const char *
|
||
next_brace_sub (begin)
|
||
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;
|
||
}
|
||
|
||
#endif /* !GLOB_ONLY_P */
|
||
|
||
/* 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. */
|
||
int
|
||
glob (pattern, flags, errfunc, pglob)
|
||
const char *pattern;
|
||
int flags;
|
||
int (*errfunc) __P ((const char *, int));
|
||
glob_t *pglob;
|
||
{
|
||
const char *filename;
|
||
const char *dirname;
|
||
size_t dirlen;
|
||
int status;
|
||
size_t oldcount;
|
||
|
||
if (pattern == NULL || pglob == NULL || (flags & ~__GLOB_FLAGS) != 0)
|
||
{
|
||
__set_errno (EINVAL);
|
||
return -1;
|
||
}
|
||
|
||
if (!(flags & GLOB_DOOFFS))
|
||
/* Have to do this so `globfree' knows where to start freeing. It
|
||
also makes all the code that uses gl_offs simpler. */
|
||
pglob->gl_offs = 0;
|
||
|
||
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. */
|
||
size_t firstc;
|
||
char *alt_start;
|
||
const char *p;
|
||
const char *next;
|
||
const char *rest;
|
||
size_t rest_len;
|
||
#ifdef __GNUC__
|
||
char onealt[strlen (pattern) - 1];
|
||
#else
|
||
char *onealt = (char *) malloc (strlen (pattern) - 1);
|
||
if (onealt == NULL)
|
||
{
|
||
if (!(flags & GLOB_APPEND))
|
||
globfree (pglob);
|
||
return GLOB_NOSPACE;
|
||
}
|
||
#endif
|
||
|
||
/* We know the prefix for all sub-patterns. */
|
||
#ifdef HAVE_MEMPCPY
|
||
alt_start = mempcpy (onealt, pattern, begin - pattern);
|
||
#else
|
||
memcpy (onealt, pattern, begin - pattern);
|
||
alt_start = &onealt[begin - pattern];
|
||
#endif
|
||
|
||
/* 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. */
|
||
#ifndef __GNUC__
|
||
free (onealt);
|
||
#endif
|
||
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. */
|
||
#ifndef __GNUC__
|
||
free (onealt);
|
||
#endif
|
||
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. */
|
||
#ifdef HAVE_MEMPCPY
|
||
mempcpy (mempcpy (alt_start, p, next - p), rest, rest_len);
|
||
#else
|
||
memcpy (alt_start, p, next - p);
|
||
memcpy (&alt_start[next - p], rest, rest_len);
|
||
#endif
|
||
|
||
result = glob (onealt,
|
||
((flags & ~(GLOB_NOCHECK|GLOB_NOMAGIC))
|
||
| GLOB_APPEND), errfunc, pglob);
|
||
|
||
/* If we got an error, return it. */
|
||
if (result && result != GLOB_NOMATCH)
|
||
{
|
||
#ifndef __GNUC__
|
||
free (onealt);
|
||
#endif
|
||
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);
|
||
}
|
||
|
||
#ifndef __GNUC__
|
||
free (onealt);
|
||
#endif
|
||
|
||
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 defined __MSDOS__ || defined WINDOWS32
|
||
/* The case of "d:pattern". Since `:' is not allowed in
|
||
file names, we can safely assume that wherever it
|
||
happens in pattern, it signals the filename part. This
|
||
is so we could some day support patterns like "[a-z]:foo". */
|
||
if (filename == NULL)
|
||
filename = strchr (pattern, ':');
|
||
#endif /* __MSDOS__ || WINDOWS32 */
|
||
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;
|
||
#ifdef _AMIGA
|
||
dirname = "";
|
||
#else
|
||
dirname = ".";
|
||
#endif
|
||
dirlen = 0;
|
||
}
|
||
}
|
||
else if (filename == pattern)
|
||
{
|
||
/* "/pattern". */
|
||
dirname = "/";
|
||
dirlen = 1;
|
||
++filename;
|
||
}
|
||
else
|
||
{
|
||
char *newp;
|
||
dirlen = filename - pattern;
|
||
#if defined __MSDOS__ || defined WINDOWS32
|
||
if (*filename == ':'
|
||
|| (filename > pattern + 1 && filename[-1] == ':'))
|
||
{
|
||
char *drive_spec;
|
||
|
||
++dirlen;
|
||
drive_spec = (char *) __alloca (dirlen + 1);
|
||
#ifdef HAVE_MEMPCPY
|
||
*((char *) mempcpy (drive_spec, pattern, dirlen)) = '\0';
|
||
#else
|
||
memcpy (drive_spec, pattern, dirlen);
|
||
drive_spec[dirlen] = '\0';
|
||
#endif
|
||
/* For now, disallow wildcards in the drive spec, to
|
||
prevent infinite recursion in glob. */
|
||
if (__glob_pattern_p (drive_spec, !(flags & GLOB_NOESCAPE)))
|
||
return GLOB_NOMATCH;
|
||
/* If this is "d:pattern", we need to copy `:' to DIRNAME
|
||
as well. If it's "d:/pattern", don't remove the slash
|
||
from "d:/", since "d:" and "d:/" are not the same.*/
|
||
}
|
||
#endif
|
||
newp = (char *) __alloca (dirlen + 1);
|
||
#ifdef HAVE_MEMPCPY
|
||
*((char *) mempcpy (newp, pattern, dirlen)) = '\0';
|
||
#else
|
||
memcpy (newp, pattern, dirlen);
|
||
newp[dirlen] = '\0';
|
||
#endif
|
||
dirname = newp;
|
||
++filename;
|
||
|
||
if (filename[0] == '\0'
|
||
#if defined __MSDOS__ || defined WINDOWS32
|
||
&& dirname[dirlen - 1] != ':'
|
||
&& (dirlen < 3 || dirname[dirlen - 2] != ':'
|
||
|| dirname[dirlen - 1] != '/')
|
||
#endif
|
||
&& 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;
|
||
if (!(flags & GLOB_DOOFFS))
|
||
pglob->gl_pathv = NULL;
|
||
else
|
||
{
|
||
size_t i;
|
||
pglob->gl_pathv = (char **) malloc ((pglob->gl_offs + 1)
|
||
* sizeof (char *));
|
||
if (pglob->gl_pathv == NULL)
|
||
return GLOB_NOSPACE;
|
||
|
||
for (i = 0; i <= pglob->gl_offs; ++i)
|
||
pglob->gl_pathv[i] = NULL;
|
||
}
|
||
}
|
||
|
||
oldcount = pglob->gl_pathc + pglob->gl_offs;
|
||
|
||
#ifndef VMS
|
||
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");
|
||
# ifdef _AMIGA
|
||
if (home_dir == NULL || home_dir[0] == '\0')
|
||
home_dir = "SYS:";
|
||
# else
|
||
# ifdef WINDOWS32
|
||
if (home_dir == NULL || home_dir[0] == '\0')
|
||
home_dir = "c:/users/default"; /* poor default */
|
||
# else
|
||
if (home_dir == NULL || home_dir[0] == '\0')
|
||
{
|
||
int success;
|
||
char *name;
|
||
# if defined HAVE_GETLOGIN_R || defined _LIBC
|
||
size_t buflen = sysconf (_SC_LOGIN_NAME_MAX) + 1;
|
||
|
||
if (buflen == 0)
|
||
/* `sysconf' does not support _SC_LOGIN_NAME_MAX. Try
|
||
a moderate value. */
|
||
buflen = 20;
|
||
name = (char *) __alloca (buflen);
|
||
|
||
success = getlogin_r (name, buflen) >= 0;
|
||
# else
|
||
success = (name = getlogin ()) != NULL;
|
||
# endif
|
||
if (success)
|
||
{
|
||
struct passwd *p;
|
||
# if defined HAVE_GETPWNAM_R || defined _LIBC
|
||
long int pwbuflen = sysconf (_SC_GETPW_R_SIZE_MAX);
|
||
char *pwtmpbuf;
|
||
struct passwd pwbuf;
|
||
int save = errno;
|
||
|
||
if (pwbuflen == -1)
|
||
/* `sysconf' does not support _SC_GETPW_R_SIZE_MAX.
|
||
Try a moderate value. */
|
||
pwbuflen = 1024;
|
||
pwtmpbuf = (char *) __alloca (pwbuflen);
|
||
|
||
while (getpwnam_r (name, &pwbuf, pwtmpbuf, pwbuflen, &p)
|
||
!= 0)
|
||
{
|
||
if (errno != ERANGE)
|
||
{
|
||
p = NULL;
|
||
break;
|
||
}
|
||
pwbuflen *= 2;
|
||
pwtmpbuf = (char *) __alloca (pwbuflen);
|
||
__set_errno (save);
|
||
}
|
||
# else
|
||
p = getpwnam (name);
|
||
# endif
|
||
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. */
|
||
}
|
||
# endif /* WINDOWS32 */
|
||
# endif
|
||
/* 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);
|
||
# ifdef HAVE_MEMPCPY
|
||
mempcpy (mempcpy (newp, home_dir, home_len),
|
||
&dirname[1], dirlen);
|
||
# else
|
||
memcpy (newp, home_dir, home_len);
|
||
memcpy (&newp[home_len], &dirname[1], dirlen);
|
||
# endif
|
||
dirname = newp;
|
||
}
|
||
}
|
||
# if !defined _AMIGA && !defined WINDOWS32
|
||
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);
|
||
# ifdef HAVE_MEMPCPY
|
||
*((char *) mempcpy (newp, dirname + 1, end_name - dirname))
|
||
= '\0';
|
||
# else
|
||
memcpy (newp, dirname + 1, end_name - dirname);
|
||
newp[end_name - dirname - 1] = '\0';
|
||
# endif
|
||
user_name = newp;
|
||
}
|
||
|
||
/* Look up specific user's home directory. */
|
||
{
|
||
struct passwd *p;
|
||
# if defined HAVE_GETPWNAM_R || defined _LIBC
|
||
long int buflen = sysconf (_SC_GETPW_R_SIZE_MAX);
|
||
char *pwtmpbuf;
|
||
struct passwd pwbuf;
|
||
int save = errno;
|
||
|
||
if (buflen == -1)
|
||
/* `sysconf' does not support _SC_GETPW_R_SIZE_MAX. Try a
|
||
moderate value. */
|
||
buflen = 1024;
|
||
pwtmpbuf = (char *) __alloca (buflen);
|
||
|
||
while (getpwnam_r (user_name, &pwbuf, pwtmpbuf, buflen, &p) != 0)
|
||
{
|
||
if (errno != ERANGE)
|
||
{
|
||
p = NULL;
|
||
break;
|
||
}
|
||
buflen *= 2;
|
||
pwtmpbuf = __alloca (buflen);
|
||
__set_errno (save);
|
||
}
|
||
# else
|
||
p = getpwnam (user_name);
|
||
# endif
|
||
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);
|
||
# ifdef HAVE_MEMPCPY
|
||
*((char *) mempcpy (mempcpy (newp, home_dir, home_len),
|
||
end_name, rest_len)) = '\0';
|
||
# else
|
||
memcpy (newp, home_dir, home_len);
|
||
memcpy (&newp[home_len], end_name, rest_len);
|
||
newp[home_len + rest_len] = '\0';
|
||
# endif
|
||
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;
|
||
}
|
||
# endif /* Not Amiga && not WINDOWS32. */
|
||
}
|
||
#endif /* Not VMS. */
|
||
|
||
/* Now test whether we looked for "~" or "~NAME". In this case we
|
||
can give the answer now. */
|
||
if (filename == NULL)
|
||
{
|
||
struct stat st;
|
||
#ifdef HAVE_STAT64
|
||
struct stat64 st64;
|
||
#endif
|
||
|
||
/* 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) == 0
|
||
&& S_ISDIR (st.st_mode))
|
||
: (__stat64 (dirname, &st64) == 0 && S_ISDIR (st64.st_mode)))))
|
||
{
|
||
int newcount = pglob->gl_pathc + pglob->gl_offs;
|
||
|
||
pglob->gl_pathv
|
||
= (char **) realloc (pglob->gl_pathv,
|
||
(newcount + 1 + 1) * sizeof (char *));
|
||
if (pglob->gl_pathv == NULL)
|
||
return GLOB_NOSPACE;
|
||
|
||
#if defined HAVE_STRDUP || defined _LIBC
|
||
pglob->gl_pathv[newcount] = strdup (dirname);
|
||
#else
|
||
{
|
||
size_t len = strlen (dirname) + 1;
|
||
char *dircopy = malloc (len);
|
||
if (dircopy != NULL)
|
||
pglob->gl_pathv[newcount] = memcpy (dircopy, dirname, len);
|
||
}
|
||
#endif
|
||
if (pglob->gl_pathv[newcount] == NULL)
|
||
{
|
||
free (pglob->gl_pathv);
|
||
return GLOB_NOSPACE;
|
||
}
|
||
pglob->gl_pathv[++newcount] = NULL;
|
||
++pglob->gl_pathc;
|
||
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;
|
||
size_t 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;
|
||
|
||
#ifdef SHELL
|
||
{
|
||
/* Make globbing interruptible in the bash shell. */
|
||
extern int interrupt_state;
|
||
|
||
if (interrupt_state)
|
||
{
|
||
globfree (&dirs);
|
||
return GLOB_ABORTED;
|
||
}
|
||
}
|
||
#endif /* SHELL. */
|
||
|
||
old_pathc = pglob->gl_pathc;
|
||
status = glob_in_dir (filename, dirs.gl_pathv[i],
|
||
((flags | GLOB_APPEND) & ~GLOB_NOCHECK),
|
||
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_offs],
|
||
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 the GLOB_NOCHECK
|
||
flag was set we must return the list consisting of the disrectory
|
||
names followed by the filename. */
|
||
if (pglob->gl_pathc + pglob->gl_offs == oldcount)
|
||
{
|
||
/* No matches. */
|
||
if (flags & GLOB_NOCHECK)
|
||
{
|
||
size_t filename_len = strlen (filename) + 1;
|
||
char **new_pathv;
|
||
int newcount = pglob->gl_pathc + pglob->gl_offs;
|
||
struct stat st;
|
||
#ifdef HAVE_STAT64
|
||
struct stat64 st64;
|
||
#endif
|
||
|
||
/* This is an pessimistic guess about the size. */
|
||
pglob->gl_pathv
|
||
= (char **) realloc (pglob->gl_pathv,
|
||
(newcount + dirs.gl_pathc + 1)
|
||
* sizeof (char *));
|
||
if (pglob->gl_pathv == NULL)
|
||
{
|
||
globfree (&dirs);
|
||
return GLOB_NOSPACE;
|
||
}
|
||
|
||
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) != 0
|
||
|| !S_ISDIR (st.st_mode))
|
||
: (__stat64 (dir, &st64) != 0
|
||
|| !S_ISDIR (st64.st_mode))))
|
||
/* No directory, ignore this entry. */
|
||
continue;
|
||
|
||
pglob->gl_pathv[newcount] = malloc (dir_len + 1
|
||
+ filename_len);
|
||
if (pglob->gl_pathv[newcount] == NULL)
|
||
{
|
||
globfree (&dirs);
|
||
globfree (pglob);
|
||
return GLOB_NOSPACE;
|
||
}
|
||
|
||
#ifdef HAVE_MEMPCPY
|
||
mempcpy (mempcpy (mempcpy (pglob->gl_pathv[newcount],
|
||
dir, dir_len),
|
||
"/", 1),
|
||
filename, filename_len);
|
||
#else
|
||
memcpy (pglob->gl_pathv[newcount], dir, dir_len);
|
||
pglob->gl_pathv[newcount][dir_len] = '/';
|
||
memcpy (&pglob->gl_pathv[newcount][dir_len + 1],
|
||
filename, filename_len);
|
||
#endif
|
||
++pglob->gl_pathc;
|
||
++newcount;
|
||
}
|
||
|
||
pglob->gl_pathv[newcount] = NULL;
|
||
pglob->gl_flags = flags;
|
||
|
||
/* Now we know how large the gl_pathv vector must be. */
|
||
new_pathv = (char **) realloc (pglob->gl_pathv,
|
||
((newcount + 1)
|
||
* sizeof (char *)));
|
||
if (new_pathv != NULL)
|
||
pglob->gl_pathv = new_pathv;
|
||
}
|
||
else
|
||
{
|
||
globfree (&dirs);
|
||
return GLOB_NOMATCH;
|
||
}
|
||
}
|
||
|
||
globfree (&dirs);
|
||
}
|
||
else
|
||
{
|
||
int old_pathc = pglob->gl_pathc;
|
||
|
||
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. */
|
||
if (prefix_array (dirname,
|
||
&pglob->gl_pathv[old_pathc + pglob->gl_offs],
|
||
pglob->gl_pathc - old_pathc))
|
||
{
|
||
globfree (pglob);
|
||
return GLOB_NOSPACE;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (flags & GLOB_MARK)
|
||
{
|
||
/* Append slashes to directory names. */
|
||
size_t i;
|
||
struct stat st;
|
||
#ifdef HAVE_STAT64
|
||
struct stat64 st64;
|
||
#endif
|
||
|
||
for (i = oldcount; i < pglob->gl_pathc + pglob->gl_offs; ++i)
|
||
if (((flags & GLOB_ALTDIRFUNC)
|
||
? ((*pglob->gl_stat) (pglob->gl_pathv[i], &st) == 0
|
||
&& S_ISDIR (st.st_mode))
|
||
: (__stat64 (pglob->gl_pathv[i], &st64) == 0
|
||
&& S_ISDIR (st64.st_mode))))
|
||
{
|
||
size_t len = strlen (pglob->gl_pathv[i]) + 2;
|
||
char *new = realloc (pglob->gl_pathv[i], len);
|
||
if (new == NULL)
|
||
{
|
||
globfree (pglob);
|
||
return GLOB_NOSPACE;
|
||
}
|
||
strcpy (&new[len - 2], "/");
|
||
pglob->gl_pathv[i] = new;
|
||
}
|
||
}
|
||
|
||
if (!(flags & GLOB_NOSORT))
|
||
{
|
||
/* Sort the vector. */
|
||
qsort ((__ptr_t) &pglob->gl_pathv[oldcount],
|
||
pglob->gl_pathc + pglob->gl_offs - oldcount,
|
||
sizeof (char *), collated_compare);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
#if !defined _LIBC || !defined GLOB_ONLY_P
|
||
|
||
/* Free storage allocated in PGLOB by a previous `glob' call. */
|
||
void
|
||
globfree (pglob)
|
||
register glob_t *pglob;
|
||
{
|
||
if (pglob->gl_pathv != NULL)
|
||
{
|
||
size_t i;
|
||
for (i = 0; i < pglob->gl_pathc; ++i)
|
||
if (pglob->gl_pathv[pglob->gl_offs + i] != NULL)
|
||
free ((__ptr_t) pglob->gl_pathv[pglob->gl_offs + i]);
|
||
free ((__ptr_t) pglob->gl_pathv);
|
||
}
|
||
}
|
||
|
||
|
||
/* Do a collated comparison of A and B. */
|
||
static int
|
||
collated_compare (a, b)
|
||
const __ptr_t a;
|
||
const __ptr_t 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 (dirname, array, n)
|
||
const char *dirname;
|
||
char **array;
|
||
size_t n;
|
||
{
|
||
register size_t i;
|
||
size_t dirlen = strlen (dirname);
|
||
#if defined __MSDOS__ || defined WINDOWS32
|
||
int sep_char = '/';
|
||
# define DIRSEP_CHAR sep_char
|
||
#else
|
||
# define DIRSEP_CHAR '/'
|
||
#endif
|
||
|
||
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;
|
||
#if defined __MSDOS__ || defined WINDOWS32
|
||
else if (dirlen > 1)
|
||
{
|
||
if (dirname[dirlen - 1] == '/' && dirname[dirlen - 2] == ':')
|
||
/* DIRNAME is "d:/". Don't prepend the slash from DIRNAME. */
|
||
--dirlen;
|
||
else if (dirname[dirlen - 1] == ':')
|
||
{
|
||
/* DIRNAME is "d:". Use `:' instead of `/'. */
|
||
--dirlen;
|
||
sep_char = ':';
|
||
}
|
||
}
|
||
#endif
|
||
|
||
for (i = 0; i < n; ++i)
|
||
{
|
||
size_t eltlen = strlen (array[i]) + 1;
|
||
char *new = (char *) malloc (dirlen + 1 + eltlen);
|
||
if (new == NULL)
|
||
{
|
||
while (i > 0)
|
||
free ((__ptr_t) array[--i]);
|
||
return 1;
|
||
}
|
||
|
||
#ifdef HAVE_MEMPCPY
|
||
{
|
||
char *endp = (char *) mempcpy (new, dirname, dirlen);
|
||
*endp++ = DIRSEP_CHAR;
|
||
mempcpy (endp, array[i], eltlen);
|
||
}
|
||
#else
|
||
memcpy (new, dirname, dirlen);
|
||
new[dirlen] = DIRSEP_CHAR;
|
||
memcpy (&new[dirlen + 1], array[i], eltlen);
|
||
#endif
|
||
free ((__ptr_t) array[i]);
|
||
array[i] = new;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
/* We must not compile this function twice. */
|
||
#if !defined _LIBC || !defined NO_GLOB_PATTERN_P
|
||
/* Return nonzero if PATTERN contains any metacharacters.
|
||
Metacharacters can be quoted with backslashes if QUOTE is nonzero. */
|
||
int
|
||
__glob_pattern_p (pattern, quote)
|
||
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;
|
||
}
|
||
# ifdef _LIBC
|
||
weak_alias (__glob_pattern_p, glob_pattern_p)
|
||
# endif
|
||
#endif
|
||
|
||
#endif /* !GLOB_ONLY_P */
|
||
|
||
|
||
/* 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 (pattern, directory, flags, errfunc, pglob)
|
||
const char *pattern;
|
||
const char *directory;
|
||
int flags;
|
||
int (*errfunc) __P ((const char *, int));
|
||
glob_t *pglob;
|
||
{
|
||
__ptr_t 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 && (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;
|
||
nfound = 0;
|
||
}
|
||
else if (meta == 0 &&
|
||
((flags & GLOB_NOESCAPE) || strchr(pattern, '\\') == NULL))
|
||
{
|
||
/* Since we use the normal file functions we can also use stat()
|
||
to verify the file is there. */
|
||
struct stat st;
|
||
# ifdef HAVE_STAT64
|
||
struct stat64 st64;
|
||
# endif
|
||
size_t patlen = strlen (pattern);
|
||
size_t dirlen = strlen (directory);
|
||
char *fullname = (char *) __alloca (dirlen + 1 + patlen + 1);
|
||
|
||
# ifdef HAVE_MEMPCPY
|
||
mempcpy (mempcpy (mempcpy (fullname, directory, dirlen),
|
||
"/", 1),
|
||
pattern, patlen + 1);
|
||
# else
|
||
memcpy (fullname, directory, dirlen);
|
||
fullname[dirlen] = '/';
|
||
memcpy (&fullname[dirlen + 1], pattern, patlen + 1);
|
||
# endif
|
||
if (((flags & GLOB_ALTDIRFUNC)
|
||
? (*pglob->gl_stat) (fullname, &st)
|
||
: __stat64 (fullname, &st64)) == 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 *) malloc (1);
|
||
if (names->name == NULL)
|
||
goto memory_error;
|
||
names->name[0] = '\0';
|
||
names->next = NULL;
|
||
nfound = 1;
|
||
meta = 0;
|
||
}
|
||
else
|
||
{
|
||
stream = ((flags & GLOB_ALTDIRFUNC)
|
||
? (*pglob->gl_opendir) (directory)
|
||
: (__ptr_t) 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)
|
||
#if defined _AMIGA || defined VMS
|
||
| FNM_CASEFOLD
|
||
#endif
|
||
);
|
||
nfound = 0;
|
||
flags |= GLOB_MAGCHAR;
|
||
|
||
while (1)
|
||
{
|
||
const char *name;
|
||
size_t len;
|
||
struct dirent *d =
|
||
((flags & GLOB_ALTDIRFUNC)
|
||
? (struct dirent *)((*pglob->gl_readdir) (stream))
|
||
: readdir ((DIR *) stream));
|
||
if (d == NULL)
|
||
break;
|
||
if (! REAL_DIR_ENTRY (d))
|
||
continue;
|
||
|
||
#ifdef HAVE_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 *) malloc (len + 1);
|
||
if (new->name == NULL)
|
||
goto memory_error;
|
||
#ifdef HAVE_MEMPCPY
|
||
*((char *) mempcpy ((__ptr_t) new->name, name, len))
|
||
= '\0';
|
||
#else
|
||
memcpy ((__ptr_t) new->name, name, len);
|
||
new->name[len] = '\0';
|
||
#endif
|
||
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 *) malloc (len + 1);
|
||
if (names->name == NULL)
|
||
goto memory_error;
|
||
#ifdef HAVE_MEMPCPY
|
||
*((char *) mempcpy (names->name, pattern, len)) = '\0';
|
||
#else
|
||
memcpy (names->name, pattern, len);
|
||
names->name[len] = '\0';
|
||
#endif
|
||
}
|
||
|
||
if (nfound != 0)
|
||
{
|
||
pglob->gl_pathv
|
||
= (char **) realloc (pglob->gl_pathv,
|
||
(pglob->gl_pathc + pglob->gl_offs + nfound + 1)
|
||
* sizeof (char *));
|
||
if (pglob->gl_pathv == NULL)
|
||
goto memory_error;
|
||
|
||
for (; names != NULL; names = names->next)
|
||
pglob->gl_pathv[pglob->gl_offs + pglob->gl_pathc++] = names->name;
|
||
pglob->gl_pathv[pglob->gl_offs + 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;
|
||
|
||
memory_error:
|
||
{
|
||
int save = errno;
|
||
if (flags & GLOB_ALTDIRFUNC)
|
||
(*pglob->gl_closedir) (stream);
|
||
else
|
||
closedir ((DIR *) stream);
|
||
__set_errno (save);
|
||
}
|
||
while (names != NULL)
|
||
{
|
||
if (names->name != NULL)
|
||
free ((__ptr_t) names->name);
|
||
names = names->next;
|
||
}
|
||
return GLOB_NOSPACE;
|
||
}
|
||
|
||
#endif /* Not ELIDE_CODE. */
|