glibc/posix/glob.c
Ulrich Drepper 714a562f0b Update.
<1997-06-12 21:22  Ulrich Drepper  <drepper@cygnus.com>

	* Makefile (libc-map): Define before including Makerules.
	* Makerules (lib%.so): Depend on $(lib%-map).
	(build-shlib): Adapt rule for above change.
	(libc.so): Depend on $(libc-map).
	* db/Makefile (libcdb-map): New definition.
	* elf/Makefile (libdl-map): New definition.
	* elf/dl-lookup.c: Don't use relative include path.
	(undefined_msg): New variable.  Use single string in all functions.
	(do_lookup): Correctly recognize default version.
	Return -2 if no version information is available.
	Stop processing hash entries when string was found.
	Don't bark about missing versioned symbol in file with original
	reference if it is a weak symbol.
	(_dl_lookup_symbol): Use undefined_msg.
	(_dl_lookup_versioned_symbol): Likewise.
	Give extra information if no verdef info is available.
	* elf/dl-version.c (file_needed): Remove first argument.  We must
	seek in the whole search list.
	(match_symbol): Correct check for available verdef info.
	(_dl_check_map_versions): Correct call of find_needed.
	* locale/Makefile (libBrokenLocale-map): New definition.
	* login/Makefile (libutil-map): New definition.
	* math/Makefile (libm-map): New definition.
	* md5-crypt/Makefile (libcrypt-map): New definition.
	* nis/Makefile (libnsl-map, libnss_compat-map, libnss_nis-map,
	libnss_nisplus-map): New definition.
	* nss/Makefile (libnss_files-map, libnss_db-map): New definitions.
	* resolv/Makefile (libresolv-map, libnss_dns-map): New definitions.
	* libc.map: New file.
	* db/libdb.map: New file.
	* elf/libdl.map: New file.
	* locale/libBrokenLocale.map: New file.
	* login/libutil.map: New file.
	* math/libm.map: New file.
	* md5-crypt/libcrypt.map: New file.
	* nis/libnss_compat.map: New file.
	* nis/libnsl.map: New file.
	* nis/libnss_nis.map: New file.
	* nis/libnss_nisplus.map: New file.
	* nss/libnss_files.map: New file.
	* nss/libnss_db.map: New file.
	* resolv/libnss_dns.map: New file.
	* resolv/libresolv.map: New file.

	* sysdeps/i386/dl-machine.h (elf_machine_rel): Don't do anything
	for R_386_NONE entries.

	* Makefile (manual/dir-add.info): New rule.

	* Makerules: Add vpath definition for .x files.

	* Makerules (distinfo): Make sure target directory exists.

	* argp/argp-help.c (argp_args_usage): Don't modify `fdoc' value
	since it is used to distinguish filtered strings from unmodifed
	strings.

	* elf/dl-lookup.c (do_lookup): Optimize STT_* recognition.
	* elf/dl-reloc.c: Fix typo.

	* inet/arpa/tftp.h (struct tftphdr): Change type of tu_block to
	`unsigned short'.

	* manual/Makefile (dir-add.texi): Also emit wrapper text for
	info/install-info.
	(distribute): Add dir-add.texi and dir-add.info.
	(mostlyclean): Add dir-add.info.
	(realclean): Add dir-add.texi.
	(install): Add entries in `dir' file using install-info.

	* manual/libc.texinfo: Add @dircategory and @direntry text.
	Reported by Miles Bader <miles@gnu.ai.mit.edu>.

	* manual/pattern.texi: Correct description of GLOB_MAGCHAR and
	GLOB_NOMAGIC.  Changes by Roland McGrath <roland@gnu.ai.mit.edu>.

	* nis/nis_addmember.c: Little optimizations.
	* nis/nis_call.c: Likewise.
	* nis/nis_creategroup.c: Likewise.
	* nis/nis_defaults.c: Likewise.
	* nis/nis_destroygroup.c: Likewise.
	* nis/nis_ismember.c: Likewise.
	* nis/nis_local_names.c: Likewise.
	* nis/nis_print_group_entry.c: Likewise.
	* nis/nis_verifygroup.c: Likewise.

	* posix/unistd.h: Fix comment for getcwd.

	* stdlib/Makefile (headers): Remove inttypes.h.  It's a system
	dependent header.
	* sysdeps/wordsize-32/Dist: New file.
	* sysdeps/wordsize-32/Makefile: New file.
	* sysdeps/wordsize-64/Dist: New file.
	* sysdeps/wordsize-64/Makefile: New file.

	* sunrpc/Makefile: Adopt comment for real situation.

	* sysdeps/i386/add_n.S: Add ASM_TYPE_DIRECTIVE and AS_SIZE_DIRECTIVE.
	* sysdeps/i386/addmul_1.s: Likewise.
	* sysdeps/i386/lshist.s: Likewise.
	* sysdeps/i386/rshift.s: Likewise.
	* sysdeps/i386/sub_n.s: Likewise.
	* sysdeps/i386/submul_1.s: Likewise.

	* sysdeps/unix/sysv/linux/i386/sysdep.h (SYSCALL_ERROR_HANDLER):
	Add .type and .size.

1997-06-12 13:32  Philip Blundell  <Philip.Blundell@pobox.com>

	* libc/sysdeps/unix/arm/brk.S: New file.
	* libc/sysdeps/unix/arm/sysdep.S: Likewise.
	* libc/sysdeps/unix/sysv/linux/arm/sysdep.S: Likewise.

1997-06-11 11:51  Thorsten Kukuk  <kukuk@vt.uni-paderborn.de>

	* nis/nss_nisplus/nisplus-spwd.c (_nss_nisplus_parse_spent):
	Check if we have shadow information.

1997-06-08 19:33  Thorsten Kukuk  <kukuk@vt.uni-paderborn.de>

	* nis/nis_getservlist.c (nis_getservlist): Use calloc instead of
	malloc, alloc memory for nis_server struct.
	* nis/nis_getservlist.c (nis_freeservlist): Give the memory for
	the nis_server struct free, too.

	* nis/nis_removemember (nis_removemember): Fix for loop.

1997-06-12 12:45  Ulrich Drepper  <drepper@cygnus.com>

	* sysdeps/i386/fpu/__math.h (__M_SQRT2): Define here since we
	cannot rely on M_SQRT2 being defined.  (log1p): Use __M_SQRT2 not
	M_SQRT2.
	* math/math.h (_Mldbl): Define even if M_* constants are not
	defined.
	Reported by corsepiu@faw.uni-ulm.de.

1997-06-12 03:08  Philip Blundell  <Philip.Blundell@pobox.com>

	* nss/getXXbyYY_r.c (do_weak_alias): Remove extra parentheses.

1997-06-11 13:22  Ulrich Drepper  <drepper@cygnus.com>

	* misc/regexp.h (compile): Allow use of macro INIT for variable
	declaration.  Add documentation for INIT.
	Reported by Robert Bihlmeyer <robbe@orcus.priv.at>.

1997-06-11 10:47  Philip Blundell  <Philip.Blundell@pobox.com>

	* sysdeps/unix/sysv/linux/net/if_arp.h: Add two new hardware types.

1997-06-10 11:31  H.J. Lu  <hjl@gnu.ai.mit.edu>

	* sysdeps/powerpc/strlen.s: Use -0x101 instead of 0xfffffeff
	for a signed 16-bit value.

1997-06-07 07:54  H.J. Lu  <hjl@gnu.ai.mit.edu>

	* sysdeps/unix/sysv/linux/powerpc/dl-sysdep.c
	(_dl_sysdep_read_whole_file): Deleted.

	* sysdeps/powerpc/fenvbits.h (__FE_ALL_INVALID): Changed
	to FE_ALL_INVALID.

	* sysdeps/powerpc/fraiseexcpt.c (__FE_INVALID_SOFTWARE):
	Changed to FE_INVALID_SOFTWARE.
	(__FPSCR_STICKY_BITS): Changed to FPSCR_STICKY_BITS.

	* sysdeps/libm-ieee754/s_fmin.c: Fix a typo.

1997-06-07 18:48  H.J. Lu  <hjl@gnu.ai.mit.edu>

	* shlib-versions (.*-.*-linux.*): Set libc to 6.

1997-06-08 15:35  Thorsten Kukuk  <kukuk@vt.uni-paderborn.de>

	* nis/nis_add.c (nis_add): Use nis_leaf_of_r instead of nis_name_of_r.

	* nis/nis_addmember.c (nis_addmember): Fix a lot of pointer errors.
	* nis/nis_clone.c: Likewise.
	* nis/nis_removemember.c (nis_removemember): Likewise.
	* nis/nis_table.c: Likewise.

	* nis/nss_nis/nis-hosts.c: Use addr, not p for inet_pton call.
	* nis/nss_nisplus/nisplus-hosts.c: Likewise.

	* nis/nss_nis/nis-netgrp.c (_nss_nis_setnetgrent): Check for
	group == NULL.

1997-06-08 21:21  Mark Kettenis  <kettenis@phys.uva.nl>

	* login/login.c, login/utmp_daemon.c, login/utmp_file.c,
	login/getutent_r.c, login/utmpname.c: Cleanup `#if _LIBC' and
	`#ifndef _LIBC' fragments.

	* login/programs/utmpd.c: Define DEFAULT_USER.
	(drop_priviliges): Use it.
	(main): Set locale and text domain.

	* login/programs/utmpd-private.h: Declare proc_utmp_eq.
	* login/programs/database.c (proc_utmp_eq): Removed.
	* login/programs/request.c (proc_utmp_eq): Made global.  Only use
	ut_id field if valid.

	* login/utmp_file.c (proc_utmp_eq): Restore patch made by Miles
	Bader that was lost when adding the daemon backend; Only use ut_id
	field if valid.

1997-06-05 23:10  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* sysdeps/unix/sysv/linux/Dist: Remove netatalk/atalk.h and
	netinet/icmp.h, add netatalk/at.h.
	* sysdeps/unix/sysv/linux/powerpc/Dist: Remove termios.h.
	* sysdeps/unix/sysv/linux/sparc/Dist: Remove start.c.

1997-06-04 19:22  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* stdlib/testsort.c (compare): Fix parameter types.

1997-06-04 19:05  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* md5-crypt/Makefile (distribute): Fix name of file.

1997-06-04 19:02  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* login/Makefile (utmpd-routines): Remove utmpd again, which is
	already added implicitly through $(others).

1997-06-05 13:43  Fila Kolodny  <fila@filapc.ibi.com>

	* sysdeps/unix/sysv/linux/Makefile (sysdep_headers): Add netipx/ipx.h.

1997-06-05 13:25  Andreas Jaeger  <aj@arthur.rhein-neckar.de>

	* md5-crypt/md5-crypt.c: Add prototype for __md5_crypt.

1997-06-05 17:08  Ulrich Drepper  <drepper@cygnus.com>

	* string/argz-addsep.c: Correct weak alias.
	Reported by Ben Pfaff <pfaffben@pilot.msu.edu>.

	* locale/setlocale.c (setlocale): Free variable with locale path
	before returning.
	(setname): Don't test for _nl_current[category] being NULL before
	freeing.
	Reported by Ben Pfaff <pfaffben@pilot.msu.edu>.

1997-06-04 12:41  Andreas Jaeger  <aj@arthur.rhein-neckar.de>

	* manual/intro.texi (XPG): Correct some typos.

	* manual/libc.texinfo (Program Arguments): Menu updated.
	* nis/nis_local_names.c (nis_local_host): Fix pointer errors.
1997-06-12 21:38:55 +00:00

1028 lines
24 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* Copyright (C) 1991, 92, 93, 94, 95, 96, 97 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>
/* 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(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(WIN32)
#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
#if (defined (POSIX) || defined (WIN32)) && !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
#ifndef __GNU_LIBRARY__
#ifdef __GNUC__
__inline
#endif
#ifndef __SASC
#ifdef WIN32
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 WIN32
#include <malloc.h>
#else
extern char *alloca ();
#endif /* WIN32 */
#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
#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. */
#undef FNM_PATHNAME
#undef FNM_NOESCAPE
#undef FNM_PERIOD
#include <fnmatch.h>
/* Some system header files erroneously define these.
We want our own definitions from <glob.h> to take precedence. */
#undef GLOB_ERR
#undef GLOB_MARK
#undef GLOB_NOSORT
#undef GLOB_DOOFFS
#undef GLOB_NOCHECK
#undef GLOB_APPEND
#undef GLOB_NOESCAPE
#undef GLOB_PERIOD
#include <glob.h>
static int glob_in_dir __P ((const char *pattern, const char *directory,
int flags,
int (*errfunc) __P ((const char *, int)),
glob_t *pglob));
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 (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;
}
/* 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;
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;
#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. */
memcpy (onealt, pattern, begin - pattern);
alt_start = &onealt[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. */
#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. */
memcpy (alt_start, p, next - p);
memcpy (&alt_start[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)
{
#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 (filename == NULL)
{
filename = pattern;
#ifdef _AMIGA
dirname = (char *) "";
#else
dirname = (char *) ".";
#endif
dirlen = 0;
}
else if (filename == pattern)
{
/* "/pattern". */
dirname = (char *) "/";
dirlen = 1;
++filename;
}
else
{
dirlen = filename - pattern;
dirname = (char *) __alloca (dirlen + 1);
memcpy (dirname, pattern, dirlen);
dirname[dirlen] = '\0';
++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;
#ifndef VMS
if ((flags & GLOB_TILDE) && dirname[0] == '~')
{
if (dirname[1] == '\0' || dirname[1] == '/')
{
/* Look up home directory. */
char *home_dir = getenv ("HOME");
#ifdef _AMIGA
if (home_dir == NULL || home_dir[0] == '\0')
home_dir = "SYS:";
#else
#ifdef WIN32
if (home_dir == NULL || home_dir[0] == '\0')
home_dir = "c:/users/default"; /* poor default */
#else
if (home_dir == NULL || home_dir[0] == '\0')
{
extern char *getlogin __P ((void));
extern int getlogin_r __P ((char *, size_t));
int success;
#if defined HAVE_GETLOGIN_R || defined _LIBC
size_t buflen = sysconf (_SC_LOGIN_NAME_MAX) + 1;
char *name;
if (buflen == 0)
/* `sysconf' does not support _SC_LOGIN_NAME_MAX. Try
a moderate value. */
buflen = 16;
name = __alloca (buflen);
success = getlogin_r (name, buflen) >= 0;
#else
char *name;
success = (name = getlogin ()) != NULL;
#endif
if (success)
{
#if defined HAVE_GETPWNAM_R || defined _LIBC
size_t pwbuflen = sysconf (_SC_GETPW_R_SIZE_MAX);
char *pwtmpbuf;
struct passwd pwbuf, *p;
pwtmpbuf = __alloca (pwbuflen);
success = (__getpwnam_r (name, &pwbuf, pwtmpbuf,
pwbuflen, &p) >= 0);
#else
struct passwd *p = getpwnam (name);
success = p != NULL;
#endif
if (success)
home_dir = p->pw_dir;
}
}
if (home_dir == NULL || home_dir[0] == '\0')
home_dir = (char *) "~"; /* No luck. */
#endif /* WIN32 */
#endif
/* Now construct the full directory. */
if (dirname[1] == '\0')
dirname = home_dir;
else
{
char *newp;
size_t home_len = strlen (home_dir);
newp = __alloca (home_len + dirlen);
memcpy (newp, home_dir, home_len);
memcpy (&newp[home_len], &dirname[1], dirlen);
dirname = newp;
}
}
#if !defined _AMIGA && !defined WIN32
else
{
char *end_name = strchr (dirname, '/');
char *user_name;
char *home_dir;
if (end_name == NULL)
user_name = dirname + 1;
else
{
user_name = __alloca (end_name - dirname);
memcpy (user_name, dirname + 1, end_name - dirname);
user_name[end_name - dirname - 1] = '\0';
}
/* Look up specific user's home directory. */
{
#if defined HAVE_GETPWNAM_R || defined _LIBC
size_t buflen = sysconf (_SC_GETPW_R_SIZE_MAX);
char *pwtmpbuf = __alloca (buflen);
struct passwd pwbuf, *p;
if (__getpwnam_r (user_name, &pwbuf, pwtmpbuf, buflen, &p) >= 0)
home_dir = p->pw_dir;
else
home_dir = NULL;
#else
struct passwd *p = getpwnam (user_name);
if (p != NULL)
home_dir = p->pw_dir;
else
home_dir = NULL;
#endif
}
/* 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 = __alloca (home_len + rest_len + 1);
memcpy (newp, home_dir, home_len);
memcpy (&newp[home_len], end_name, rest_len);
newp[home_len + rest_len] = '\0';
dirname = newp;
}
}
#endif /* Not Amiga && not Win32. */
}
#endif /* Not VMS. */
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;
status = glob (dirname,
((flags & (GLOB_ERR | GLOB_NOCHECK | GLOB_NOESCAPE)) |
GLOB_NOSORT),
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 oldcount;
#ifdef SHELL
{
/* Make globbing interruptible in the bash shell. */
extern int interrupt_state;
if (interrupt_state)
{
globfree (&dirs);
globfree (&files);
return GLOB_ABORTED;
}
}
#endif /* SHELL. */
oldcount = 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[oldcount],
pglob->gl_pathc - oldcount))
{
globfree (&dirs);
globfree (pglob);
return GLOB_NOSPACE;
}
}
flags |= GLOB_MAGCHAR;
if (pglob->gl_pathc == oldcount)
/* No matches. */
if (flags & GLOB_NOCHECK)
{
size_t len = strlen (pattern) + 1;
char *patcopy = (char *) malloc (len);
if (patcopy == NULL)
return GLOB_NOSPACE;
memcpy (patcopy, pattern, len);
pglob->gl_pathv
= (char **) realloc (pglob->gl_pathv,
(pglob->gl_pathc +
((flags & GLOB_DOOFFS) ?
pglob->gl_offs : 0) +
1 + 1) *
sizeof (char *));
if (pglob->gl_pathv == NULL)
{
free (patcopy);
return GLOB_NOSPACE;
}
if (flags & GLOB_DOOFFS)
while (pglob->gl_pathc < pglob->gl_offs)
pglob->gl_pathv[pglob->gl_pathc++] = NULL;
pglob->gl_pathv[pglob->gl_pathc++] = patcopy;
pglob->gl_pathv[pglob->gl_pathc] = NULL;
pglob->gl_flags = flags;
}
else
return GLOB_NOMATCH;
}
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. */
if (prefix_array (dirname,
&pglob->gl_pathv[oldcount],
pglob->gl_pathc - oldcount))
{
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 = 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 - oldcount,
sizeof (char *), collated_compare);
return 0;
}
/* Free storage allocated in PGLOB by a previous `glob' call. */
void
globfree (pglob)
register 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 ((__ptr_t) pglob->gl_pathv[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 (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 *) malloc (dirlen + 1 + eltlen);
if (new == NULL)
{
while (i > 0)
free ((__ptr_t) array[--i]);
return 1;
}
memcpy (new, dirname, dirlen);
new[dirlen] = '/';
memcpy (&new[dirlen + 1], array[i], eltlen);
free ((__ptr_t) array[i]);
array[i] = new;
}
return 0;
}
/* 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
/* 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;
struct globlink
{
struct globlink *next;
char *name;
};
struct globlink *names = NULL;
size_t nfound = 0;
if (!__glob_pattern_p (pattern, !(flags & GLOB_NOESCAPE)))
{
stream = NULL;
flags |= GLOB_NOCHECK;
}
else
{
flags |= GLOB_MAGCHAR;
stream = ((flags & GLOB_ALTDIRFUNC) ?
(*pglob->gl_opendir) (directory) :
(__ptr_t) opendir (directory));
if (stream == NULL)
{
if ((errfunc != NULL && (*errfunc) (directory, errno)) ||
(flags & GLOB_ERR))
return GLOB_ABORTED;
}
else
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;
name = d->d_name;
if (fnmatch (pattern, name,
(!(flags & GLOB_PERIOD) ? FNM_PERIOD : 0) |
((flags & GLOB_NOESCAPE) ? FNM_NOESCAPE : 0)
#ifdef _AMIGA
| FNM_CASEFOLD
#endif
) == 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;
memcpy ((__ptr_t) new->name, name, len);
new->name[len] = '\0';
new->next = names;
names = new;
++nfound;
}
}
}
if (nfound == 0 && (flags & GLOB_NOMAGIC) &&
! __glob_pattern_p (pattern, !(flags & GLOB_NOESCAPE)))
flags |= GLOB_NOCHECK;
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;
memcpy (names->name, pattern, len);
names->name[len] = '\0';
}
pglob->gl_pathv
= (char **) realloc (pglob->gl_pathv,
(pglob->gl_pathc +
((flags & GLOB_DOOFFS) ? pglob->gl_offs : 0) +
nfound + 1) *
sizeof (char *));
if (pglob->gl_pathv == NULL)
goto memory_error;
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;
if (stream != NULL)
{
int save = errno;
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. */