/* 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., 51 Franklin Street, Suite 500,

   Boston, MA 02110-1335, USA.  */

/* AIX requires this to be the first thing in the file.  */

#if defined _AIX && !defined __GNUC__

 #pragma alloca

#endif

#include <config.h>

#include "options.h"

/* Make alloca work the best possible way.  */

#ifdef __GNUC__

#define alloca __builtin_alloca

#else /* not __GNUC__ */

#if HAVE_ALLOCA_H

#include <alloca.h>

#else /* not __GNUC__ or HAVE_ALLOCA_H */

#ifndef _AIX /* Already did AIX, up at the top.  */

char *alloca ();

#endif /* not _AIX */

#endif /* not HAVE_ALLOCA_H */

#endif /* not __GNUC__ */

#define MAX_RECURSION   PR_TUNABLE_GLOBBING_MAX_RECURSION

#define MAX_RESULTS PR_TUNABLE_GLOBBING_MAX_MATCHES

/* 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.

 */

#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

#ifdef _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 && defined __GLIBC__ && __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 (void *p, size_t 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

#ifdef IRIX6

#include <alloca.h>

#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

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.

 */

#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.  */

static 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 (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 (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 = PR_TUNABLE_LOGIN_MAX+1;

        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;

          char **new_buf;

    new_buf

      = (char **) realloc (pglob->gl_pathv,

         (newcount + 1 + 1) * sizeof (char *));

    if (new_buf == NULL)

      return GLOB_NOSPACE;

    pglob->gl_pathv = new_buf;

#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)

      {