--- /dev/null
+diff -urN proftpd-1.2.1/Make.rules.in proftpd-1.2/Make.rules.in
+--- proftpd-1.2.1/Make.rules.in Thu Feb 22 05:51:10 2001
++++ proftpd-1.2/Make.rules.in Mon Mar 19 23:11:35 2001
+@@ -63,7 +63,7 @@
+ src/support.o src/inet.o src/log.o src/io.o src/ident.o \
+ src/data.o src/modules.o src/auth.o src/fs.o
+
+-LIB_OBJS=getopt.o getopt1.o pr_fnmatch.o strsep.o vsnprintf.o glob.o pwgrent.o
++LIB_OBJS=getopt.o getopt1.o pr_fnmatch.o strsep.o vsnprintf.o glibc-glob.o pwgrent.o
+
+ FTPCOUNT_OBJS=ftpcount.o pool.o log.o utils.o
+ BUILD_FTPCOUNT_OBJS=src/ftpcount.o src/pool.o src/log.o src/utils.o
+diff -urN proftpd-1.2.1/acconfig.h proftpd-1.2/acconfig.h
+--- proftpd-1.2.1/acconfig.h Wed Feb 14 05:12:48 2001
++++ proftpd-1.2/acconfig.h Mon Mar 19 23:11:35 2001
+@@ -18,12 +18,6 @@
+ /* Define if you have BSD sendfile() semantics */
+ #undef HAVE_BSD_SENDFILE
+
+-/* Define if you have the <glob.h> header file. */
+-#undef HAVE_GLOB_H
+-
+-/* Define if your <glob.h> defines GLOB_PERIOD macro. */
+-#undef HAVE_GLOB_PERIOD
+-
+ /* Define if you have Linux sendfile() semantics */
+ #undef HAVE_LINUX_SENDFILE
+
+diff -urN proftpd-1.2.1/config.h.in proftpd-1.2/config.h.in
+--- proftpd-1.2.1/config.h.in Fri Feb 23 03:47:26 2001
++++ proftpd-1.2/config.h.in Mon Mar 19 23:11:35 2001
+@@ -19,12 +19,6 @@
+ /* Define if you have BSD sendfile() semantics */
+ #undef HAVE_BSD_SENDFILE
+
+-/* Define if you have the <glob.h> header file. */
+-#undef HAVE_GLOB_H
+-
+-/* Define if your <glob.h> defines GLOB_PERIOD macro. */
+-#undef HAVE_GLOB_PERIOD
+-
+ /* Define if you have Linux sendfile() semantics */
+ #undef HAVE_LINUX_SENDFILE
+
+@@ -210,9 +204,6 @@
+ /* Define if you have the gettimeofday function. */
+ #undef HAVE_GETTIMEOFDAY
+
+-/* Define if you have the glob function. */
+-#undef HAVE_GLOB
+-
+ /* Define if you have the inet_aton function. */
+ #undef HAVE_INET_ATON
+
+@@ -320,6 +311,9 @@
+
+ /* Define if you have the <libutil.h> header file. */
+ #undef HAVE_LIBUTIL_H
++
++/* Define if you have the <limits.h> header file. */
++#undef HAVE_LIMITS_H
+
+ /* Define if you have the <memory.h> header file. */
+ #undef HAVE_MEMORY_H
+diff -urN proftpd-1.2.1/configure.in proftpd-1.2/configure.in
+--- proftpd-1.2.1/configure.in Thu Mar 1 04:18:43 2001
++++ proftpd-1.2/configure.in Mon Mar 19 23:11:35 2001
+@@ -300,14 +300,13 @@
+
+ fi
+
+-AC_CHECK_HEADERS(ctype.h getopt.h crypt.h bstring.h strings.h)
++AC_CHECK_HEADERS(ctype.h getopt.h crypt.h bstring.h strings.h limits.h)
+ AC_CHECK_HEADERS(sys/types.h sys/param.h sys/file.h sys/uio.h)
+ AC_CHECK_HEADERS(netdb.h netinet/in.h netinet/tcp.h arpa/inet.h sys/stat.h)
+ AC_CHECK_HEADERS(errno.h sys/socket.h sys/termios.h sys/termio.h)
+ AC_CHECK_HEADERS(sys/statvfs.h sys/vfs.h sys/select.h)
+ AC_CHECK_HEADERS(utmpx.h)
+ AC_CHECK_HEADERS(regex.h)
+-AC_CHECK_HEADER(glob.h,have_glob_h="yes",)
+ AC_CHECK_HEADER(syslog.h,have_syslog_h="yes",)
+
+ dnl Checks for typedefs, structures, and compiler characteristics.
+@@ -362,35 +361,6 @@
+ fi
+ fi
+
+-if test "$have_glob_h" = "yes"; then
+- dnl See if we have GLOB_PERIOD
+- AC_CACHE_CHECK(whether your glob.h defines GLOB_PERIOD,
+- pr_cv_header_glob_period,
+- AC_EGREP_CPP(yes,[
+-#include <glob.h>
+-#ifdef GLOB_PERIOD
+- yes
+-#endif
+- ],pr_cv_header_glob_period="yes",pr_cv_header_glob_period="no"))
+-
+- dnl See if we have GLOB_ALTDIRFUNC
+- if test "$pr_cv_header_glob_period" = "yes"; then
+- AC_CACHE_CHECK(whether your glob.h defines GLOB_ALTDIRFUNC,
+- pr_cv_header_glob_altdirfunc,
+- AC_EGREP_CPP(yes,[
+-#include <glob.h>
+-#ifdef GLOB_ALTDIRFUNC
+- yes
+-#endif
+- ],pr_cv_header_glob_altdirfunc="yes",pr_cv_header_glob_altdirfunc="no"))
+-
+- if test "$pr_cv_header_glob_altdirfunc" = "yes"; then
+- AC_DEFINE(HAVE_GLOB_H)
+- AC_DEFINE(HAVE_GLOB_PERIOD)
+- fi
+- fi
+-fi
+-
+ dnl See if various LOG_ macros are defined
+ if test "$have_syslog_h" = "yes"; then
+ AC_DEFINE(HAVE_SYSLOG_H)
+@@ -538,13 +508,6 @@
+ AC_DEFINE(HAVE_BSD_SENDFILE)
+ ;;
+ esac
+-fi
+-
+-dnl Only check for glob if we have glob.h, GLOB_PERIOD, and GLOB_ALTDIRFUNC
+-if test "$have_glob_h" = "yes" && \
+- test "$pr_cv_header_glob_period" = "yes" && \
+- test "$pr_cv_header_glob_altdirfunc" = "yes"; then
+- AC_CHECK_FUNCS(glob)
+ fi
+
+ dnl Check for various argv[] replacing functions on various OSs
+diff -urN proftpd-1.2.1/include/conf.h proftpd-1.2/include/conf.h
+--- proftpd-1.2.1/include/conf.h Sun Aug 13 17:19:39 2000
++++ proftpd-1.2/include/conf.h Mon Mar 19 23:11:35 2001
+@@ -38,7 +38,7 @@
+ */
+
+ /* Generic configuration and standard header file includes.
+- * $Id$
++ * $Id$
+ */
+
+ #ifndef __CONF_H
+@@ -156,10 +156,6 @@
+
+ #ifdef HAVE_SYSLOG_H
+ # include <syslog.h>
+-#endif
+-
+-#ifdef HAVE_GLOB
+-# include <glob.h>
+ #endif
+
+ #ifdef HAVE_DIRENT_H
+diff -urN proftpd-1.2.1/include/glibc-glob.h proftpd-1.2/include/glibc-glob.h
+--- proftpd-1.2.1/include/glibc-glob.h Thu Jan 1 01:00:00 1970
++++ proftpd-1.2/include/glibc-glob.h Thu Mar 22 14:43:36 2001
+@@ -0,0 +1,221 @@
++/* Copyright (C) 1991,92,95,96,97,98,2000,2001 Free Software Foundation, Inc.
++
++ The GNU C 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.
++
++ The GNU C 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 the GNU C 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. */
++
++#ifndef _GLOB_H
++#define _GLOB_H 1
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++#undef __ptr_t
++#if defined __cplusplus || (defined __STDC__ && __STDC__) || defined WINDOWS32
++# if !defined __GLIBC__ || !defined __P
++# undef __P
++# undef __PMT
++# define __P(protos) protos
++# define __PMT(protos) protos
++# if !defined __GNUC__ || __GNUC__ < 2
++# undef __const
++# define __const const
++# endif
++# endif
++# define __ptr_t void *
++#else /* Not C++ or ANSI C. */
++# undef __P
++# undef __PMT
++# define __P(protos) ()
++# define __PMT(protos) ()
++# undef __const
++# define __const
++# define __ptr_t char *
++#endif /* C++ or ANSI C. */
++
++/* We need `size_t' for the following definitions. */
++#ifndef __size_t
++# if defined __GNUC__ && __GNUC__ >= 2
++typedef __SIZE_TYPE__ __size_t;
++# ifdef _XOPEN_SOURCE
++typedef __SIZE_TYPE__ size_t;
++# endif
++# else
++/* This is a guess. */
++typedef unsigned long int __size_t;
++# endif
++#else
++/* The GNU CC stddef.h version defines __size_t as empty. We need a real
++ definition. */
++# undef __size_t
++# define __size_t size_t
++#endif
++
++/* 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. */
++
++#if (!defined _POSIX_C_SOURCE || _POSIX_C_SOURCE < 2 || defined _BSD_SOURCE \
++ || defined _GNU_SOURCE)
++# 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)
++#else
++# define __GLOB_FLAGS (GLOB_ERR|GLOB_MARK|GLOB_NOSORT|GLOB_DOOFFS| \
++ GLOB_NOESCAPE|GLOB_NOCHECK|GLOB_APPEND| \
++ GLOB_PERIOD)
++#endif
++
++/* 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. */
++#ifdef _GNU_SOURCE
++/* Previous versions of this file defined GLOB_ABEND instead of
++ GLOB_ABORTED. Provide a compatibility definition here. */
++# define GLOB_ABEND GLOB_ABORTED
++#endif
++
++/* Structure describing a globbing run. */
++#if !defined _AMIGA && !defined VMS /* Buggy compiler. */
++# ifdef _GNU_SOURCE
++struct stat;
++# endif
++#endif
++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) __PMT ((void *));
++#ifdef _GNU_SOURCE
++ struct dirent *(*gl_readdir) __PMT ((void *));
++#else
++ void *(*gl_readdir) __PMT ((void *));
++#endif
++ __ptr_t (*gl_opendir) __PMT ((__const char *));
++#ifdef _GNU_SOURCE
++ int (*gl_lstat) __PMT ((__const char *,
++ struct stat *));
++ int (*gl_stat) __PMT ((__const char *, struct stat *));
++#else
++ int (*gl_lstat) __PMT ((__const char *, void *));
++ int (*gl_stat) __PMT ((__const char *, void *));
++#endif
++ } glob_t;
++
++#ifdef _LARGEFILE64_SOURCE
++# ifdef _GNU_SOURCE
++struct stat64;
++# endif
++typedef struct
++ {
++ __size_t gl_pathc;
++ char **gl_pathv;
++ __size_t gl_offs;
++ int gl_flags;
++
++ /* If the GLOB_ALTDIRFUNC flag is set, the following functions
++ are used instead of the normal file access functions. */
++ void (*gl_closedir) __PMT ((void *));
++# ifdef _GNU_SOURCE
++ struct dirent64 *(*gl_readdir) __PMT ((void *));
++# else
++ void *(*gl_readdir) __PMT ((void *));
++# endif
++ __ptr_t (*gl_opendir) __PMT ((__const char *));
++# ifdef _GNU_SOURCE
++ int (*gl_lstat) __PMT ((__const char *,
++ struct stat64 *));
++ int (*gl_stat) __PMT ((__const char *,
++ struct stat64 *));
++# else
++ int (*gl_lstat) __PMT ((__const char *, void *));
++ int (*gl_stat) __PMT ((__const char *, void *));
++# endif
++ } glob64_t;
++#endif
++
++#if _FILE_OFFSET_BITS == 64 && __GNUC__ < 2
++# define glob glob64
++# define globfree globfree64
++#endif
++
++/* 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_ABEND; if it returns zero, the error is ignored.
++ If memory cannot be allocated for PGLOB, GLOB_NOSPACE is returned.
++ Otherwise, `glob' returns zero. */
++#if _FILE_OFFSET_BITS != 64 || __GNUC__ < 2
++extern int glob __P ((__const char *__pattern, int __flags,
++ int (*__errfunc) (__const char *, int),
++ glob_t *__pglob));
++
++/* Free storage allocated in PGLOB by a previous `glob' call. */
++extern void globfree __P ((glob_t *__pglob));
++#else
++extern int glob __P ((__const char *__pattern, int __flags,
++ int (*__errfunc) (__const char *, int),
++ glob_t *__pglob));
++
++extern void globfree __P ((glob_t *__pglob));
++#endif
++
++#ifdef _LARGEFILE64_SOURCE
++extern int glob64 __P ((__const char *__pattern, int __flags,
++ int (*__errfunc) (__const char *, int),
++ glob64_t *__pglob));
++
++extern void globfree64 __P ((glob64_t *__pglob));
++#endif
++
++
++#ifdef _GNU_SOURCE
++/* Return nonzero if PATTERN contains any metacharacters.
++ Metacharacters can be quoted with backslashes if QUOTE is nonzero.
++
++ This function is not part of the interface specified by POSIX.2
++ but several programs want to use it. */
++extern int glob_pattern_p __P ((__const char *__pattern, int __quote));
++#endif
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif /* glob.h */
+diff -urN proftpd-1.2.1/include/libsupp.h proftpd-1.2/include/libsupp.h
+--- proftpd-1.2.1/include/libsupp.h Wed Aug 2 07:25:24 2000
++++ proftpd-1.2/include/libsupp.h Mon Mar 19 23:11:35 2001
+@@ -23,66 +23,10 @@
+
+ /* ProFTPD support library definitions.
+ *
+- * $Id$
++ * $Id$
+ */
+
+-#if !defined HAVE_GLOB && !defined __PROFTPD_SUPPORT_LIBRARY
+-
+-#ifndef __P
+-#define __P(x) x
+-#endif
+-
+-/* 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_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)
+-#define GLOB_NOSPACE 1 /* Ran out of memory. */
+-#define GLOB_ABORTED 2 /* Read error. */
+-#define GLOB_NOMATCH 3 /* No matches found. */
+-
+-/* Structure describing a globbing run. */
+-#if !defined _AMIGA && !defined VMS /* Buggy compiler. */
+-struct stat;
+-#endif
+-typedef struct
+- {
+- int gl_pathc; /* Count of paths matched by the pattern. */
+- char **gl_pathv; /* List of matched pathnames. */
+- int 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) __P ((void *));
+- struct dirent *(*gl_readdir) __P ((void *));
+- void *(*gl_opendir) __P ((const char *));
+- int (*gl_lstat) __P ((const char *, struct stat *));
+- int (*gl_stat) __P ((const char *, struct stat *));
+- } glob_t;
+-
+-extern int glob (const char *__pattern, int __flags,
+- int (*__errfunc)(const char *, int),
+- glob_t *__pglob);
+-extern void globfree (glob_t *__pglob);
+-extern int __glob_pattern_p (const char *__pattern, int __quote);
+-extern int glob_pattern_p (const char *__pattern, int __quote);
+-
+-#endif /* HAVE_GLOB */
++#include <glibc-glob.h>
+
+ /* Bits set in the FLAGS argument to `pr_fnmatch'. */
+ #define PR_FNM_PATHNAME (1 << 0) /* No wildcard can ever match `/'. */
+diff -urN proftpd-1.2.1/lib/Makefile.in proftpd-1.2/lib/Makefile.in
+--- proftpd-1.2.1/lib/Makefile.in Thu Mar 1 17:02:10 2001
++++ proftpd-1.2/lib/Makefile.in Sun Feb 25 00:09:19 2001
+@@ -32,15 +32,15 @@
+ # Dependancies written below
+ # DO NOT DELETE
+
++pr_fnmatch.o: ../include/conf.h ../include/version.h ../config.h
++pr_fnmatch.o: ../include/default_paths.h ../include/options.h
++pr_fnmatch.o: ../include/libsupp.h pr_fnmatch_loop.c
+ getopt.o: ../include/conf.h ../include/version.h ../config.h
+ getopt.o: ../include/default_paths.h ../include/options.h getopt.h
+ getopt1.o: ../include/conf.h ../include/version.h ../config.h
+ getopt1.o: ../include/default_paths.h ../include/options.h getopt.h
+ glob.o: ../include/conf.h ../include/version.h ../config.h
+ glob.o: ../include/default_paths.h ../include/options.h ../include/libsupp.h
+-pr_fnmatch.o: ../include/conf.h ../include/version.h ../config.h
+-pr_fnmatch.o: ../include/default_paths.h ../include/options.h
+-pr_fnmatch.o: ../include/libsupp.h pr_fnmatch_loop.c
+ pwgrent.o: ../include/conf.h ../include/version.h ../config.h
+ pwgrent.o: ../include/default_paths.h ../include/options.h
+ strsep.o: ../include/conf.h ../include/version.h ../config.h
+diff -urN proftpd-1.2.1/lib/glibc-glob.c proftpd-1.2/lib/glibc-glob.c
+--- proftpd-1.2.1/lib/glibc-glob.c Thu Jan 1 01:00:00 1970
++++ proftpd-1.2/lib/glibc-glob.c Sat Mar 17 21:34:31 2001
+@@ -0,0 +1,1544 @@
++/* Copyright (C) 1991-1999, 2000, 2001 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 <config.h>
++
++#define MAX_RECURSION 8
++#define MAX_RESULTS 100000UL
++
++/* 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. */
++
++/* Proftpd modification: always undefine __GNU_LIBRARY__ because we are not
++ * compiling as part of glibc.
++ * jss - 3/17/2001
++ */
++
++#undef __GNU_LIBRARY__
++
++#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
++
++#undef ELIDE_CODE
++#define __alloca alloca
++#define __readdir readdir
++
++#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 _LIBC
++# define HAVE_DIRENT64 1
++#endif
++
++/* If the system has the `struct dirent64' type we use it internally. */
++#if defined HAVE_DIRENT64 && !defined COMPILE_GLOB64
++# if defined HAVE_DIRENT_H || defined __GNU_LIBRARY__
++# define CONVERT_D_NAMLEN(d64, d32)
++# else
++# define CONVERT_D_NAMLEN(d64, d32) \
++ (d64)->d_namlen = (d32)->d_namlen;
++# endif
++
++# if (defined POSIX || defined WINDOWS32) && !defined __GNU_LIBRARY__
++# define CONVERT_D_INO(d64, d32)
++# else
++# define CONVERT_D_INO(d64, d32) \
++ (d64)->d_ino = (d32)->d_ino;
++# endif
++
++# ifdef HAVE_D_TYPE
++# define CONVERT_D_TYPE(d64, d32) \
++ (d64)->d_type = (d32)->d_type;
++# else
++# define CONVERT_D_TYPE(d64, d32)
++# endif
++
++# define CONVERT_DIRENT_DIRENT64(d64, d32) \
++ memcpy ((d64)->d_name, (d32)->d_name, NAMLEN (d32) + 1); \
++ CONVERT_D_NAMLEN (d64, d32) \
++ CONVERT_D_INO (d64, d32) \
++ CONVERT_D_TYPE (d64, d32)
++#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
++
++static unsigned long nbresults;
++
++#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) __readdir64 (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 <glibc-glob.h>
++
++#ifdef HAVE_GETLOGIN_R
++extern int getlogin_r __P ((char *, size_t));
++#else
++extern char *getlogin __P ((void));
++#endif
++\f
++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));
++
++/* Prototype __glob_pattern_p to avoid compiler warning.
++ * jss - 3/17/2001
++ */
++#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 (const char *pattern, int quote);
++#endif /* NO_GLOB_PATTERN_P */
++
++#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. */
++static int
++glob_limited (depth, pattern, flags, errfunc, pglob)
++ unsigned int depth;
++ 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 (depth > MAX_RECURSION) {
++ return GLOB_NOSPACE;
++ }
++ 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_limited (depth + 1U, 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_limited (depth + 1U, 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_limited (depth + 1U, 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_limited (depth + 1U, 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_limited (depth + 1U, 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;
++}
++
++int
++glob (pattern, flags, errfunc, pglob)
++
++ const char *pattern;
++ int flags;
++ int (*errfunc) __P ((const char *, int));
++ glob_t *pglob;
++{
++ nbresults = 0UL;
++ return glob_limited(0U, pattern, flags, errfunc, pglob);
++}
++
++#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;
++#if defined HAVE_DIRENT64 && !defined COMPILE_GLOB64
++ struct dirent64 *d;
++ struct dirent64 d64;
++
++ if (flags & GLOB_ALTDIRFUNC)
++ {
++ struct dirent *d32 = (*pglob->gl_readdir) (stream);
++ if (d32 != NULL)
++ {
++ CONVERT_DIRENT_DIRENT64 (&d64, d32);
++ d = &d64;
++ }
++ else
++ d = NULL;
++ }
++ else
++ d = __readdir64 ((DIR *) stream);
++#else
++ struct dirent *d = ((flags & GLOB_ALTDIRFUNC)
++ ? ((struct dirent *)
++ (*pglob->gl_readdir) (stream))
++ : __readdir ((DIR *) stream));
++#endif
++ if (d == NULL)
++ break;
++ if (nbresults > MAX_RESULTS) {
++ break;
++ }
++ nbresults++;
++ 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. */
+diff -urN proftpd-1.2.1/lib/glob.c proftpd-1.2/lib/glob.c
+--- proftpd-1.2.1/lib/glob.c Wed Jul 26 10:16:33 2000
++++ proftpd-1.2/lib/glob.c Thu Jan 1 01:00:00 1970
+@@ -1,1108 +0,0 @@
+-/* 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
+-
+-/* Enable GNU extensions in glob.h. */
+-#ifndef _GNU_SOURCE
+-# define _GNU_SOURCE 1
+-#endif
+-
+-/* Required to tell conf.h not to include the standard ProFTPD
+- * header files
+- */
+-
+-#define __PROFTPD_SUPPORT_LIBRARY
+-
+-#include <conf.h>
+-
+-#include <errno.h>
+-#include <sys/types.h>
+-#include <sys/stat.h>
+-
+-#include <assert.h>
+-#include <stdio.h> /* Needed on stupid SunOS for assert. */
+-
+-#include <libsupp.h>
+-
+-#undef _LIBC
+-#undef __GNU_LIBRARY__
+-
+-#ifndef HAVE_GLOB
+-
+-/* 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. */
+-
+-#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
+-
+-#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
+-
+-#ifndef __osf__
+-extern char *malloc (), *realloc ();
+-extern void free ();
+-
+-extern void qsort ();
+-extern void abort (), exit ();
+-#endif /* __osf__ */
+-
+-#endif /* Standard headers. */
+-
+-#ifndef ANSI_STRING
+-
+-# ifndef bzero
+-extern void bzero ();
+-# endif
+-# ifndef bcopy
+-extern void bcopy ();
+-# endif
+-
+-# undef memcpy
+-# define memcpy(d, s, n) bcopy ((s), (d), (n))
+-# undef strrchr
+-# define strrchr rindex
+-/* memset is only used for zero here, but let's be paranoid. */
+-# undef memset
+-# 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
+-# 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
+-
+-#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 <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
+-#if __GNUC__ - 0 >= 2
+-inline
+-#endif
+-const char *next_brace_sub __P ((const char *begin));
+-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 (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;
+-}
+-
+-/* 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. */
+-#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 (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);
+-#ifdef HAVE_MEMPCPY
+- *((char *) mempcpy (dirname, pattern, dirlen)) = '\0';
+-#else
+- memcpy (dirname, pattern, dirlen);
+- dirname[dirlen] = '\0';
+-#endif
+- ++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 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;
+-# if defined HAVE_GETLOGIN_R || defined _LIBC
+- extern int getlogin_r __P ((char *, size_t));
+- 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 = (char *) __alloca (buflen);
+-
+- success = getlogin_r (name, buflen) >= 0;
+-# else
+- extern char *getlogin __P ((void));
+- 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 = (char *) __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 /* 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, '/');
+- char *user_name;
+- char *home_dir;
+-
+- if (end_name == NULL)
+- user_name = dirname + 1;
+- else
+- {
+- user_name = (char *) __alloca (end_name - dirname);
+-# ifdef HAVE_MEMPCPY
+- *((char *) mempcpy (user_name, dirname + 1, end_name - dirname))
+- = '\0';
+-# else
+- memcpy (user_name, dirname + 1, end_name - dirname);
+- user_name[end_name - dirname - 1] = '\0';
+-# endif
+- }
+-
+- /* 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 = (char *) __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 = (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;
+- }
+- }
+-# endif /* Not Amiga && not WINDOWS32. */
+- }
+-#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 | 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 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 | 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[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;
+- }
+- strncpy (&new[len - 2], "/", 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;
+- }
+-
+-#ifdef HAVE_MEMPCPY
+- {
+- char *endp = (char *) mempcpy (new, dirname, dirlen);
+- *endp++ = '/';
+- mempcpy (endp, array[i], eltlen);
+- }
+-#else
+- memcpy (new, dirname, dirlen);
+- new[dirlen] = '/';
+- memcpy (&new[dirlen + 1], array[i], eltlen);
+-#endif
+- 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;
+- int meta;
+- int save;
+-
+- 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;
+- nfound = 0;
+- meta = 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
+- {
+- nfound = 0;
+- meta = __glob_pattern_p (pattern, !(flags & GLOB_NOESCAPE));
+- if(meta)
+- 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_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 ((!meta && strcmp (pattern, name) == 0)
+- || pr_fnmatch (pattern, name,
+- (!(flags & GLOB_PERIOD) ? PR_FNM_PERIOD : 0) |
+- ((flags & GLOB_NOESCAPE) ? PR_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;
+-#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 (!meta)
+- break;
+- }
+- }
+- }
+-
+- if (nfound == 0 && (flags & GLOB_NOMAGIC) && !meta)
+- 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;
+-#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 +
+- ((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;
+- }
+-
+- save = errno;
+- if(stream) {
+- 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 /* HAVE_GLOB */
+diff -urN proftpd-1.2.1/lib/glob.h proftpd-1.2/lib/glob.h
+--- proftpd-1.2.1/lib/glob.h Sun Oct 18 04:24:41 1998
++++ proftpd-1.2/lib/glob.h Thu Jan 1 01:00:00 1970
+@@ -1,133 +0,0 @@
+-/* Copyright (C) 1991, 1992, 1995, 1996, 1997 Free Software Foundation, Inc.
+-
+- The GNU C 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.
+-
+- The GNU C 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 the GNU C 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. */
+-
+-#ifndef _GLOB_H
+-#define _GLOB_H 1
+-
+-#ifdef __cplusplus
+-extern "C"
+-{
+-#endif
+-
+-#undef __ptr_t
+-#if (defined __cplusplus || (defined __STDC__ && __STDC__) \
+- || defined WINDOWS32)
+-# undef __P
+-# define __P(protos) protos
+-# define __ptr_t void *
+-# if !defined __GNUC__ || __GNUC__ < 2
+-# undef __const
+-# define __const const
+-# endif
+-#else /* Not C++ or ANSI C. */
+-# undef __P
+-# define __P(protos) ()
+-# undef __const
+-# define __const
+-# define __ptr_t char *
+-#endif /* C++ or ANSI C. */
+-
+-/* 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. */
+-
+-#if (!defined _POSIX_C_SOURCE || _POSIX_C_SOURCE < 2 || defined _BSD_SOURCE \
+- || defined _GNU_SOURCE)
+-# 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_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)
+-#else
+-# define __GLOB_FLAGS (GLOB_ERR|GLOB_MARK|GLOB_NOSORT|GLOB_DOOFFS| \
+- GLOB_NOESCAPE|GLOB_NOCHECK|GLOB_APPEND| \
+- GLOB_PERIOD)
+-#endif
+-
+-/* 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. */
+-
+-#ifdef _GNU_SOURCE
+-/* Previous versions of this file defined GLOB_ABEND instead of
+- GLOB_ABORTED. Provide a compatibility definition here. */
+-# define GLOB_ABEND GLOB_ABORTED
+-#endif
+-
+-/* Structure describing a globbing run. */
+-#if !defined _AMIGA && !defined VMS /* Buggy compiler. */
+-struct stat;
+-#endif
+-typedef struct
+- {
+- int gl_pathc; /* Count of paths matched by the pattern. */
+- char **gl_pathv; /* List of matched pathnames. */
+- int 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) __P ((void *));
+- struct dirent *(*gl_readdir) __P ((void *));
+- __ptr_t (*gl_opendir) __P ((__const char *));
+- int (*gl_lstat) __P ((__const char *, struct stat *));
+- int (*gl_stat) __P ((__const char *, struct stat *));
+- } glob_t;
+-
+-/* 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_ABEND; if it returns zero, the error is ignored.
+- If memory cannot be allocated for PGLOB, GLOB_NOSPACE is returned.
+- Otherwise, `glob' returns zero. */
+-extern int glob __P ((__const char *__pattern, int __flags,
+- int (*__errfunc) __P ((__const char *, int)),
+- glob_t *__pglob));
+-
+-/* Free storage allocated in PGLOB by a previous `glob' call. */
+-extern void globfree __P ((glob_t *__pglob));
+-
+-
+-#ifdef _GNU_SOURCE
+-/* Return nonzero if PATTERN contains any metacharacters.
+- Metacharacters can be quoted with backslashes if QUOTE is nonzero.
+-
+- This function is not part of the interface specified by POSIX.2
+- but several programs want to use it. */
+-extern int __glob_pattern_p __P ((__const char *__pattern, int __quote));
+-extern int glob_pattern_p __P ((__const char *__pattern, int __quote));
+-#endif
+-
+-#ifdef __cplusplus
+-}
+-#endif
+-
+-#endif /* glob.h */
+diff -urN proftpd-1.2.1/src/fs.c proftpd-1.2/src/fs.c
+--- proftpd-1.2.1/src/fs.c Sat Feb 3 00:09:26 2001
++++ proftpd-1.2/src/fs.c Mon Mar 19 23:11:36 2001
+@@ -19,7 +19,7 @@
+ */
+
+ /* ProFTPD virtual/modular file-system support
+- * $Id$
++ * $Id$
+ */
+
+ #include "conf.h"
+@@ -1132,10 +1132,10 @@
+ flags |= GLOB_ALTDIRFUNC;
+
+ pglob->gl_closedir = (void (*)(void*))fs_closedir;
+- pglob->gl_readdir = fs_readdir;
++ pglob->gl_readdir = (void*(*)(void*))fs_readdir;
+ pglob->gl_opendir = fs_opendir;
+- pglob->gl_lstat = fs_lstat;
+- pglob->gl_stat = fs_stat;
++ pglob->gl_lstat = (int (*)(const char *,void*))fs_lstat;
++ pglob->gl_stat = (int (*)(const char *,void*))fs_stat;
+ }
+
+ return glob(pattern,flags,errfunc,pglob);
+
projects / packages / proftpd.git / commitdiff