This is a rebase of posix/glob.c from upstream (gnulib->glibc->rhel).

Relevent upstream commits:

7c477b57a31487eda516db02b9e04f22d1a6e6af posix/glob.c: update from gnulib

  (This is the master commit to which we're syncing)

gnulib commit 98f034a0c2ba8917c96f363de1a8d66244e411da

  (This is the gnulib commit to which glibc upstream sync'd)

Additional glibc upstream commits of note:

84f7ce84474c1648ce96884f1c91ca7b97ca3fc2 posix: Add glob64 with 64-bit time_t support

  (just posix/glob.c and sysdeps/gnu/glob64-lstat-compat.c)

9a7ab0769b295cbf5232140401742a8f34bda3de hurd: Fix glob lstat compatibility

4883360415f1ed772ba44decc501d59deb17bdf0 posix: Sync glob code with gnulib

04986243d1af37ac0177ed2f9db0a066ebd2b212 Remove internal usage of extensible stat functions

ddc650e9b3dc916eab417ce9f79e67337b05035c Fix use-after-free in glob when expanding ~user (bug 25414)

diff -rup a/posix/glob-lstat-compat.c b/posix/glob-lstat-compat.c

--- a/posix/glob-lstat-compat.c	2018-08-01 01:10:47.000000000 -0400

+++ b/posix/glob-lstat-compat.c	2022-05-02 22:49:06.504676711 -0400

@@ -28,7 +28,8 @@

 # define GLOB_ATTRIBUTE attribute_compat_text_section

 /* Avoid calling gl_lstat with GLOB_ALTDIRFUNC.  */

-# define GLOB_NO_LSTAT

+# define GLOB_LSTAT   gl_stat

+# define GLOB_LSTAT64 __stat64

 # include <posix/glob.c>

diff -rup a/posix/glob.c b/posix/glob.c

--- a/posix/glob.c	2022-05-03 14:37:52.959042051 -0400

+++ b/posix/glob.c	2022-05-02 22:49:18.655134696 -0400

@@ -1,4 +1,4 @@

-/* Copyright (C) 1991-2018 Free Software Foundation, Inc.

+/* Copyright (C) 1991-2022 Free Software Foundation, Inc.

    This file is part of the GNU C Library.

    The GNU C Library is free software; you can redistribute it and/or

@@ -13,11 +13,22 @@

    You should have received a copy of the GNU Lesser General Public

    License along with the GNU C Library; if not, see

-   <http://www.gnu.org/licenses/>.  */

+   <https://www.gnu.org/licenses/>.  */

+

+#ifndef _LIBC

+

+/* Don't use __attribute__ __nonnull__ in this compilation unit.  Otherwise gcc

+   optimizes away the pattern == NULL test below.  */

+# define _GL_ARG_NONNULL(params)

+

+# include <libc-config.h>

+

+#endif

 #include <glob.h>

 #include <errno.h>

+#include <fcntl.h>

 #include <sys/types.h>

 #include <sys/stat.h>

 #include <stdbool.h>

@@ -26,7 +37,7 @@

 #include <assert.h>

 #include <unistd.h>

-#if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__

+#if defined _WIN32 && ! defined __CYGWIN__

 # define WINDOWS32

 #endif

@@ -46,30 +57,38 @@

 # define sysconf(id) __sysconf (id)

 # define closedir(dir) __closedir (dir)

 # define opendir(name) __opendir (name)

+# undef dirfd

+# define dirfd(str) __dirfd (str)

 # define readdir(str) __readdir64 (str)

 # define getpwnam_r(name, bufp, buf, len, res) \

     __getpwnam_r (name, bufp, buf, len, res)

-# ifndef __lstat64

-#  define __lstat64(fname, buf) __lxstat64 (_STAT_VER, fname, buf)

+# define FLEXIBLE_ARRAY_MEMBER

+# ifndef struct_stat

+#  define struct_stat           struct stat

 # endif

-# ifndef __stat64

-#  define __stat64(fname, buf) __xstat64 (_STAT_VER, fname, buf)

+# ifndef struct_stat64

+#  define struct_stat64         struct stat64

+# endif

+# ifndef GLOB_LSTAT

+#  define GLOB_LSTAT            gl_lstat

+# endif

+# ifndef GLOB_FSTATAT64

+#  define GLOB_FSTATAT64        __fstatat64

 # endif

-# define struct_stat64		struct stat64

-# define FLEXIBLE_ARRAY_MEMBER

 # include <shlib-compat.h>

 #else /* !_LIBC */

 # define __glob                 glob

 # define __getlogin_r(buf, len) getlogin_r (buf, len)

-# define __lstat64(fname, buf)  lstat (fname, buf)

-# define __stat64(fname, buf)   stat (fname, buf)

 # define __fxstatat64(_, d, f, st, flag) fstatat (d, f, st, flag)

-# define struct_stat64          struct stat

 # ifndef __MVS__

 #  define __alloca              alloca

 # endif

 # define __readdir              readdir

 # define COMPILE_GLOB64

+# define struct_stat            struct stat

+# define struct_stat64          struct stat

+# define GLOB_LSTAT             gl_lstat

+# define GLOB_FSTATAT64         fstatat

 #endif /* _LIBC */

 #include <fnmatch.h>

@@ -80,7 +99,9 @@

 static const char *next_brace_sub (const char *begin, int flags) __THROWNL;

-typedef uint_fast8_t dirent_type;

+/* The type of ((struct dirent *) 0)->d_type is 'unsigned char' on most

+   platforms, but 'unsigned int' in the mingw from mingw.org.  */

+typedef uint_fast32_t dirent_type;

 #if !defined _LIBC && !defined HAVE_STRUCT_DIRENT_D_TYPE

 /* Any distinct values will do here.

@@ -119,9 +140,9 @@ readdir_result_type (struct readdir_resu

 /* Construct an initializer for a struct readdir_result object from a

    struct dirent *.  No copy of the name is made.  */

 #define READDIR_RESULT_INITIALIZER(source) \

-  {					   \

-    source->d_name,			   \

-    D_TYPE_TO_RESULT (source)		   \

+  {                                        \

+    source->d_name,                        \

+    D_TYPE_TO_RESULT (source)              \

   }

 /* Call gl_readdir on STREAM.  This macro can be overridden to reduce

@@ -186,22 +207,15 @@ glob_lstat (glob_t *pglob, int flags, co

 {

 /* Use on glob-lstat-compat.c to provide a compat symbol which does not

    use lstat / gl_lstat.  */

-#ifdef GLOB_NO_LSTAT

-# define GL_LSTAT gl_stat

-# define LSTAT64 __stat64

-#else

-# define GL_LSTAT gl_lstat

-# define LSTAT64 __lstat64

-#endif

-

   union

   {

-    struct stat st;

+    struct_stat st;

     struct_stat64 st64;

   } ust;

   return (__glibc_unlikely (flags & GLOB_ALTDIRFUNC)

-          ? pglob->GL_LSTAT (fullname, &ust.st)

-          : LSTAT64 (fullname, &ust.st64));

+          ? pglob->GLOB_LSTAT (fullname, &ust.st)

+          : GLOB_FSTATAT64 (AT_FDCWD, fullname, &ust.st64,

+                            AT_SYMLINK_NOFOLLOW));

 }

 /* Set *R = A + B.  Return true if the answer is mathematically

@@ -211,7 +225,7 @@ glob_lstat (glob_t *pglob, int flags, co

 static bool

 size_add_wrapv (size_t a, size_t b, size_t *r)

 {

-#if 5 <= __GNUC__ && !defined __ICC

+#if 7 <= __GNUC__ && !defined __ICC

   return __builtin_add_overflow (a, b, r);

 #else

   *r = a + b;

@@ -228,8 +242,8 @@ glob_use_alloca (size_t alloca_used, siz

 }

 static int glob_in_dir (const char *pattern, const char *directory,

-			int flags, int (*errfunc) (const char *, int),

-			glob_t *pglob, size_t alloca_used);

+                        int flags, int (*errfunc) (const char *, int),

+                        glob_t *pglob, size_t alloca_used);

 static int prefix_array (const char *prefix, char **array, size_t n) __THROWNL;

 static int collated_compare (const void *, const void *) __THROWNL;

@@ -239,11 +253,12 @@ static int collated_compare (const void

 static bool

 is_dir (char const *filename, int flags, glob_t const *pglob)

 {

-  struct stat st;

+  struct_stat st;

   struct_stat64 st64;

   return (__glibc_unlikely (flags & GLOB_ALTDIRFUNC)

           ? pglob->gl_stat (filename, &st) == 0 && S_ISDIR (st.st_mode)

-          : __stat64 (filename, &st64) == 0 && S_ISDIR (st64.st_mode));

+          : (GLOB_FSTATAT64 (AT_FDCWD, filename, &st64, 0) == 0

+             && S_ISDIR (st64.st_mode)));

 }

 /* Find the end of the sub-pattern in a brace expression.  */

@@ -254,17 +269,17 @@ next_brace_sub (const char *cp, int flag

   while (*cp != '\0')

     if ((flags & GLOB_NOESCAPE) == 0 && *cp == '\\')

       {

-	if (*++cp == '\0')

-	  break;

-	++cp;

+        if (*++cp == '\0')

+          break;

+        ++cp;

       }

     else

       {

-	if ((*cp == '}' && depth-- == 0) || (*cp == ',' && depth == 0))

-	  break;

+        if ((*cp == '}' && depth-- == 0) || (*cp == ',' && depth == 0))

+          break;

-	if (*cp++ == '{')

-	  depth++;

+        if (*cp++ == '{')

+          depth++;

       }

   return *cp != '\0' ? cp : NULL;

@@ -285,7 +300,7 @@ next_brace_sub (const char *cp, int flag

 int

 GLOB_ATTRIBUTE

 __glob (const char *pattern, int flags, int (*errfunc) (const char *, int),

-	glob_t *pglob)

+        glob_t *pglob)

 {

   const char *filename;

   char *dirname = NULL;

@@ -319,22 +334,22 @@ __glob (const char *pattern, int flags,

     {

       pglob->gl_pathc = 0;

       if (!(flags & GLOB_DOOFFS))

-	pglob->gl_pathv = NULL;

+        pglob->gl_pathv = NULL;

       else

-	{

-	  size_t i;

+        {

+          size_t i;

-	  if (pglob->gl_offs >= ~((size_t) 0) / sizeof (char *))

-	    return GLOB_NOSPACE;

+          if (pglob->gl_offs >= ~((size_t) 0) / sizeof (char *))

+            return GLOB_NOSPACE;

-	  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;

-	}

+          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;

+        }

     }

   if (flags & GLOB_BRACE)

@@ -342,129 +357,129 @@ __glob (const char *pattern, int flags,

       const char *begin;

       if (flags & GLOB_NOESCAPE)

-	begin = strchr (pattern, '{');

+        begin = strchr (pattern, '{');

       else

-	{

-	  begin = pattern;

-	  while (1)

-	    {

-	      if (*begin == '\0')

-		{

-		  begin = NULL;

-		  break;

-		}

-

-	      if (*begin == '\\' && begin[1] != '\0')

-		++begin;

-	      else if (*begin == '{')

-		break;

-

-	      ++begin;

-	    }

-	}

+        {

+          begin = pattern;

+          while (1)

+            {

+              if (*begin == '\0')

+                {

+                  begin = NULL;

+                  break;

+                }

+

+              if (*begin == '\\' && begin[1] != '\0')

+                ++begin;

+              else if (*begin == '{')

+                break;

+

+              ++begin;

+            }

+        }

       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;

-	  char *onealt;

-	  size_t pattern_len = strlen (pattern) - 1;

-	  int alloca_onealt = glob_use_alloca (alloca_used, pattern_len);

-	  if (alloca_onealt)

-	    onealt = alloca_account (pattern_len, alloca_used);

-	  else

-	    {

-	      onealt = malloc (pattern_len);

-	      if (onealt == NULL)

-		return GLOB_NOSPACE;

-	    }

-

-	  /* We know the prefix for all sub-patterns.  */

-	  alt_start = mempcpy (onealt, pattern, begin - pattern);

-

-	  /* Find the first sub-pattern and at the same time find the

-	     rest after the closing brace.  */

-	  next = next_brace_sub (begin + 1, flags);

-	  if (next == NULL)

-	    {

-	      /* It is an invalid expression.  */

-	    illegal_brace:

-	      if (__glibc_unlikely (!alloca_onealt))

-		free (onealt);

-	      flags &= ~GLOB_BRACE;

-	      goto no_brace;

-	    }

-

-	  /* Now find the end of the whole brace expression.  */

-	  rest = next;

-	  while (*rest != '}')

-	    {

-	      rest = next_brace_sub (rest + 1, flags);

-	      if (rest == NULL)

-		/* It is an illegal expression.  */

-		goto illegal_brace;

-	    }

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

-	  firstc = pglob->gl_pathc;

-

-	  p = begin + 1;

-	  while (1)

-	    {

-	      int result;

-

-	      /* Construct the new glob expression.  */

-	      mempcpy (mempcpy (alt_start, p, next - p), rest, rest_len);

-

-	      result = __glob (onealt,

-			       ((flags & ~(GLOB_NOCHECK | GLOB_NOMAGIC))

-				| GLOB_APPEND),

-			       errfunc, pglob);

-

-	      /* If we got an error, return it.  */

-	      if (result && result != GLOB_NOMATCH)

-		{

-		  if (__glibc_unlikely (!alloca_onealt))

-		    free (onealt);

-		  if (!(flags & GLOB_APPEND))

-		    {

-		      globfree (pglob);

-		      pglob->gl_pathc = 0;

-		    }

-		  return result;

-		}

-

-	      if (*next == '}')

-		/* We saw the last entry.  */

-		break;

-

-	      p = next + 1;

-	      next = next_brace_sub (p, flags);

-	      assert (next != NULL);

-	    }

-

-	  if (__glibc_unlikely (!alloca_onealt))

-	    free (onealt);

-

-	  if (pglob->gl_pathc != firstc)

-	    /* We found some entries.  */

-	    return 0;

-	  else if (!(flags & (GLOB_NOCHECK|GLOB_NOMAGIC)))

-	    return GLOB_NOMATCH;

-	}

+        {

+          /* 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;

+          char *onealt;

+          size_t pattern_len = strlen (pattern) - 1;

+          int alloca_onealt = glob_use_alloca (alloca_used, pattern_len);

+          if (alloca_onealt)

+            onealt = alloca_account (pattern_len, alloca_used);

+          else

+            {

+              onealt = malloc (pattern_len);

+              if (onealt == NULL)

+                return GLOB_NOSPACE;

+            }

+

+          /* We know the prefix for all sub-patterns.  */

+          alt_start = mempcpy (onealt, pattern, begin - pattern);

+

+          /* Find the first sub-pattern and at the same time find the

+             rest after the closing brace.  */

+          next = next_brace_sub (begin + 1, flags);

+          if (next == NULL)

+            {

+              /* It is an invalid expression.  */

+            illegal_brace:

+              if (__glibc_unlikely (!alloca_onealt))

+                free (onealt);

+              flags &= ~GLOB_BRACE;

+              goto no_brace;

+            }

+

+          /* Now find the end of the whole brace expression.  */

+          rest = next;

+          while (*rest != '}')

+            {

+              rest = next_brace_sub (rest + 1, flags);

+              if (rest == NULL)

+                /* It is an illegal expression.  */

+                goto illegal_brace;

+            }

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

+          firstc = pglob->gl_pathc;

+

+          p = begin + 1;

+          while (1)

+            {

+              int result;

+

+              /* Construct the new glob expression.  */

+              mempcpy (mempcpy (alt_start, p, next - p), rest, rest_len);

+

+              result = __glob (onealt,

+                               ((flags & ~(GLOB_NOCHECK | GLOB_NOMAGIC))

+                                | GLOB_APPEND),

+                               errfunc, pglob);

+

+              /* If we got an error, return it.  */

+              if (result && result != GLOB_NOMATCH)

+                {

+                  if (__glibc_unlikely (!alloca_onealt))

+                    free (onealt);

+                  if (!(flags & GLOB_APPEND))

+                    {

+                      globfree (pglob);

+                      pglob->gl_pathc = 0;

+                    }

+                  return result;

+                }

+

+              if (*next == '}')

+                /* We saw the last entry.  */

+                break;

+

+              p = next + 1;

+              next = next_brace_sub (p, flags);

+              assert (next != NULL);

+            }

+

+          if (__glibc_unlikely (!alloca_onealt))

+            free (onealt);

+

+          if (pglob->gl_pathc != firstc)

+            /* We found some entries.  */

+            return 0;

+          else if (!(flags & (GLOB_NOCHECK|GLOB_NOMAGIC)))

+            return GLOB_NOMATCH;

+        }

     }

  no_brace:

@@ -486,33 +501,33 @@ __glob (const char *pattern, int flags,

   if (filename == NULL)

     {

       /* This can mean two things: a simple name or "~name".  The latter

-	 case is nothing but a notation for a directory.  */

+         case is nothing but a notation for a directory.  */

       if ((flags & (GLOB_TILDE|GLOB_TILDE_CHECK)) && pattern[0] == '~')

-	{

-	  dirname = (char *) 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;

-	}

+        {

+          dirname = (char *) 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

-	{

-	  if (__glibc_unlikely (pattern[0] == '\0'))

-	    {

-	      dirs.gl_pathv = NULL;

-	      goto no_matches;

-	    }

-

-	  filename = pattern;

-	  dirname = (char *) ".";

-	  dirlen = 0;

-	}

+        {

+          if (__glibc_unlikely (pattern[0] == '\0'))

+            {

+              dirs.gl_pathv = NULL;

+              goto no_matches;

+            }

+

+          filename = pattern;

+          dirname = (char *) ".";

+          dirlen = 0;

+        }

     }

   else if (filename == pattern

-	   || (filename == pattern + 1 && pattern[0] == '\\'

-	       && (flags & GLOB_NOESCAPE) == 0))

+           || (filename == pattern + 1 && pattern[0] == '\\'

+               && (flags & GLOB_NOESCAPE) == 0))

     {

       /* "/pattern" or "\\/pattern".  */

       dirname = (char *) "/";

@@ -525,32 +540,32 @@ __glob (const char *pattern, int flags,

       dirlen = filename - pattern;

 #if defined __MSDOS__ || defined WINDOWS32

       if (*filename == ':'

-	  || (filename > pattern + 1 && filename[-1] == ':'))

-	{

-	  char *drive_spec;

-

-	  ++dirlen;

-	  drive_spec = __alloca (dirlen + 1);

-	  *((char *) mempcpy (drive_spec, pattern, dirlen)) = '\0';

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

-	}

+          || (filename > pattern + 1 && filename[-1] == ':'))

+        {

+          char *drive_spec;

+

+          ++dirlen;

+          drive_spec = __alloca (dirlen + 1);

+          *((char *) mempcpy (drive_spec, pattern, dirlen)) = '\0';

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

       if (glob_use_alloca (alloca_used, dirlen + 1))

-	newp = alloca_account (dirlen + 1, alloca_used);

+        newp = alloca_account (dirlen + 1, alloca_used);

       else

-	{

-	  newp = malloc (dirlen + 1);

-	  if (newp == NULL)

-	    return GLOB_NOSPACE;

-	  malloc_dirname = 1;

-	}

+        {

+          newp = malloc (dirlen + 1);

+          if (newp == NULL)

+            return GLOB_NOSPACE;

+          malloc_dirname = 1;

+        }

       *((char *) mempcpy (newp, pattern, dirlen)) = '\0';

       dirname = newp;

       ++filename;

@@ -566,363 +581,383 @@ __glob (const char *pattern, int flags,

       if (filename[0] == '\0' && dirlen > 1 && !drive_root)

         /* "pattern/".  Expand "pattern", appending slashes.  */

-	{

-	  int orig_flags = flags;

-	  if (!(flags & GLOB_NOESCAPE) && dirname[dirlen - 1] == '\\')

-	    {

-	      /* "pattern\\/".  Remove the final backslash if it hasn't

-		 been quoted.  */

-	      char *p = (char *) &dirname[dirlen - 1];

-

-	      while (p > dirname && p[-1] == '\\') --p;

-	      if ((&dirname[dirlen] - p) & 1)

-		{

-		  *(char *) &dirname[--dirlen] = '\0';

-		  flags &= ~(GLOB_NOCHECK | GLOB_NOMAGIC);

-		}

-	    }

-	  int val = __glob (dirname, flags | GLOB_MARK, errfunc, pglob);

-	  if (val == 0)

-	    pglob->gl_flags = ((pglob->gl_flags & ~GLOB_MARK)

-			       | (flags & GLOB_MARK));

-	  else if (val == GLOB_NOMATCH && flags != orig_flags)

-	    {

-	      /* Make sure globfree (&dirs); is a nop.  */

-	      dirs.gl_pathv = NULL;

-	      flags = orig_flags;

-	      oldcount = pglob->gl_pathc + pglob->gl_offs;

-	      goto no_matches;

-	    }

-	  retval = val;

-	  goto out;

-	}

+        {

+          int orig_flags = flags;

+          if (!(flags & GLOB_NOESCAPE) && dirname[dirlen - 1] == '\\')

+            {

+              /* "pattern\\/".  Remove the final backslash if it hasn't

+                 been quoted.  */

+              char *p = (char *) &dirname[dirlen - 1];

+

+              while (p > dirname && p[-1] == '\\') --p;

+              if ((&dirname[dirlen] - p) & 1)

+                {

+                  *(char *) &dirname[--dirlen] = '\0';

+                  flags &= ~(GLOB_NOCHECK | GLOB_NOMAGIC);

+                }

+            }

+          int val = __glob (dirname, flags | GLOB_MARK, errfunc, pglob);

+          if (val == 0)

+            pglob->gl_flags = ((pglob->gl_flags & ~GLOB_MARK)

+                               | (flags & GLOB_MARK));

+          else if (val == GLOB_NOMATCH && flags != orig_flags)

+            {

+              /* Make sure globfree (&dirs); is a nop.  */

+              dirs.gl_pathv = NULL;

+              flags = orig_flags;

+              oldcount = pglob->gl_pathc + pglob->gl_offs;

+              goto no_matches;

+            }

+          retval = val;

+          goto out;

+        }

     }

   if ((flags & (GLOB_TILDE|GLOB_TILDE_CHECK)) && dirname[0] == '~')

     {

       if (dirname[1] == '\0' || dirname[1] == '/'

-	  || (!(flags & GLOB_NOESCAPE) && dirname[1] == '\\'

-	      && (dirname[2] == '\0' || dirname[2] == '/')))

-	{

-	  /* Look up home directory.  */

-	  char *home_dir = getenv ("HOME");

-	  int malloc_home_dir = 0;

-	  if (home_dir == NULL || home_dir[0] == '\0')

-	    {

+          || (!(flags & GLOB_NOESCAPE) && dirname[1] == '\\'

+              && (dirname[2] == '\0' || dirname[2] == '/')))