posix/glob.c

   1 /* Copyright (C) 1991-2002, 2003, 2004, 2005, 2006, 2007, 2008, 2010, 2011
   2    Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 #ifdef  HAVE_CONFIG_H
  21 # include <config.h>
  22 #endif
  23
  24 #include <glob.h>
  25
  26 #include <errno.h>
  27 #include <sys/types.h>
  28 #include <sys/stat.h>
  29 #include <stddef.h>
  30
  31 /* Outcomment the following line for production quality code.  */
  32 /* #define NDEBUG 1 */
  33 #include <assert.h>
  34
  35 #include <stdio.h>              /* Needed on stupid SunOS for assert.  */
  36
  37 #if !defined _LIBC || !defined GLOB_ONLY_P
  38 #if defined HAVE_UNISTD_H || defined _LIBC
  39 # include <unistd.h>
  40 # ifndef POSIX
  41 #  ifdef _POSIX_VERSION
  42 #   define POSIX
  43 #  endif
  44 # endif
  45 #endif
  46
  47 #include <pwd.h>
  48
  49 #if defined HAVE_STDINT_H || defined _LIBC
  50 # include <stdint.h>
  51 #elif !defined UINTPTR_MAX
  52 # define UINTPTR_MAX (~((size_t) 0))
  53 #endif
  54
  55 #include <errno.h>
  56 #ifndef __set_errno
  57 # define __set_errno(val) errno = (val)
  58 #endif
  59
  60 #if defined HAVE_DIRENT_H || defined __GNU_LIBRARY__
  61 # include <dirent.h>
  62 # define NAMLEN(dirent) strlen((dirent)->d_name)
  63 #else
  64 # define dirent direct
  65 # define NAMLEN(dirent) (dirent)->d_namlen
  66 # ifdef HAVE_SYS_NDIR_H
  67 #  include <sys/ndir.h>
  68 # endif
  69 # ifdef HAVE_SYS_DIR_H
  70 #  include <sys/dir.h>
  71 # endif
  72 # ifdef HAVE_NDIR_H
  73 #  include <ndir.h>
  74 # endif
  75 # ifdef HAVE_VMSDIR_H
  76 #  include "vmsdir.h"
  77 # endif /* HAVE_VMSDIR_H */
  78 #endif
  79
  80
  81 /* In GNU systems, <dirent.h> defines this macro for us.  */
  82 #ifdef _D_NAMLEN
  83 # undef NAMLEN
  84 # define NAMLEN(d) _D_NAMLEN(d)
  85 #endif
  86
  87 /* When used in the GNU libc the symbol _DIRENT_HAVE_D_TYPE is available
  88    if the `d_type' member for `struct dirent' is available.
  89    HAVE_STRUCT_DIRENT_D_TYPE plays the same role in GNULIB.  */
  90 #if defined _DIRENT_HAVE_D_TYPE || defined HAVE_STRUCT_DIRENT_D_TYPE
  91 /* True if the directory entry D must be of type T.  */
  92 # define DIRENT_MUST_BE(d, t)   ((d)->d_type == (t))
  93
  94 /* True if the directory entry D might be a symbolic link.  */
  95 # define DIRENT_MIGHT_BE_SYMLINK(d) \
  96     ((d)->d_type == DT_UNKNOWN || (d)->d_type == DT_LNK)
  97
  98 /* True if the directory entry D might be a directory.  */
  99 # define DIRENT_MIGHT_BE_DIR(d)  \
 100     ((d)->d_type == DT_DIR || DIRENT_MIGHT_BE_SYMLINK (d))
 101
 102 #else /* !HAVE_D_TYPE */
 103 # define DIRENT_MUST_BE(d, t)           false
 104 # define DIRENT_MIGHT_BE_SYMLINK(d)     true
 105 # define DIRENT_MIGHT_BE_DIR(d)         true
 106 #endif /* HAVE_D_TYPE */
 107
 108 /* If the system has the `struct dirent64' type we use it internally.  */
 109 #if defined _LIBC && !defined COMPILE_GLOB64
 110 # if defined HAVE_DIRENT_H || defined __GNU_LIBRARY__
 111 #  define CONVERT_D_NAMLEN(d64, d32)
 112 # else
 113 #  define CONVERT_D_NAMLEN(d64, d32) \
 114   (d64)->d_namlen = (d32)->d_namlen;
 115 # endif
 116
 117 # if (defined POSIX || defined WINDOWS32) && !defined __GNU_LIBRARY__
 118 #  define CONVERT_D_INO(d64, d32)
 119 # else
 120 #  define CONVERT_D_INO(d64, d32) \
 121   (d64)->d_ino = (d32)->d_ino;
 122 # endif
 123
 124 # ifdef _DIRENT_HAVE_D_TYPE
 125 #  define CONVERT_D_TYPE(d64, d32) \
 126   (d64)->d_type = (d32)->d_type;
 127 # else
 128 #  define CONVERT_D_TYPE(d64, d32)
 129 # endif
 130
 131 # define CONVERT_DIRENT_DIRENT64(d64, d32) \
 132   memcpy ((d64)->d_name, (d32)->d_name, NAMLEN (d32) + 1);                    \
 133   CONVERT_D_NAMLEN (d64, d32)                                                 \
 134   CONVERT_D_INO (d64, d32)                                                    \
 135   CONVERT_D_TYPE (d64, d32)
 136 #endif
 137
 138
 139 #if (defined POSIX || defined WINDOWS32) && !defined __GNU_LIBRARY__
 140 /* Posix does not require that the d_ino field be present, and some
 141    systems do not provide it. */
 142 # define REAL_DIR_ENTRY(dp) 1
 143 #else
 144 # define REAL_DIR_ENTRY(dp) (dp->d_ino != 0)
 145 #endif /* POSIX */
 146
 147 #include <stdlib.h>
 148 #include <string.h>
 149
 150 /* NAME_MAX is usually defined in <dirent.h> or <limits.h>.  */
 151 #include <limits.h>
 152 #ifndef NAME_MAX
 153 # define NAME_MAX (sizeof (((struct dirent *) 0)->d_name))
 154 #endif
 155
 156 #include <alloca.h>
 157
 158 #ifdef _LIBC
 159 # undef strdup
 160 # define strdup(str) __strdup (str)
 161 # define sysconf(id) __sysconf (id)
 162 # define closedir(dir) __closedir (dir)
 163 # define opendir(name) __opendir (name)
 164 # define readdir(str) __readdir64 (str)
 165 # define getpwnam_r(name, bufp, buf, len, res) \
 166    __getpwnam_r (name, bufp, buf, len, res)
 167 # ifndef __stat64
 168 #  define __stat64(fname, buf) __xstat64 (_STAT_VER, fname, buf)
 169 # endif
 170 # define struct_stat64          struct stat64
 171 #else /* !_LIBC */
 172 # include "getlogin_r.h"
 173 # include "mempcpy.h"
 174 # include "stat-macros.h"
 175 # include "strdup.h"
 176 # define __stat64(fname, buf)   stat (fname, buf)
 177 # define struct_stat64          struct stat
 178 # define __stat(fname, buf)     stat (fname, buf)
 179 # define __alloca               alloca
 180 # define __readdir              readdir
 181 # define __readdir64            readdir64
 182 # define __glob_pattern_p       glob_pattern_p
 183 #endif /* _LIBC */
 184
 185 #include <fnmatch.h>
 186
 187 #ifdef _SC_GETPW_R_SIZE_MAX
 188 # define GETPW_R_SIZE_MAX()     sysconf (_SC_GETPW_R_SIZE_MAX)
 189 #else
 190 # define GETPW_R_SIZE_MAX()     (-1)
 191 #endif
 192 #ifdef _SC_LOGIN_NAME_MAX
 193 # define GET_LOGIN_NAME_MAX()   sysconf (_SC_LOGIN_NAME_MAX)
 194 #else
 195 # define GET_LOGIN_NAME_MAX()   (-1)
 196 #endif
 197 \f
 198 static const char *next_brace_sub (const char *begin, int flags) __THROW;
 199
 200 #endif /* !defined _LIBC || !defined GLOB_ONLY_P */
 201
 202 #ifndef attribute_hidden
 203 # define attribute_hidden
 204 #endif
 205
 206 static int glob_in_dir (const char *pattern, const char *directory,
 207                         int flags, int (*errfunc) (const char *, int),
 208                         glob_t *pglob, size_t alloca_used);
 209 extern int __glob_pattern_type (const char *pattern, int quote)
 210     attribute_hidden;
 211
 212 #if !defined _LIBC || !defined GLOB_ONLY_P
 213 static int prefix_array (const char *prefix, char **array, size_t n) __THROW;
 214 static int collated_compare (const void *, const void *) __THROW;
 215
 216
 217 /* Find the end of the sub-pattern in a brace expression.  */
 218 static const char *
 219 next_brace_sub (const char *cp, int flags)
 220 {
 221   unsigned int depth = 0;
 222   while (*cp != '\0')
 223     if ((flags & GLOB_NOESCAPE) == 0 && *cp == '\\')
 224       {
 225         if (*++cp == '\0')
 226           break;
 227         ++cp;
 228       }
 229     else
 230       {
 231         if ((*cp == '}' && depth-- == 0) || (*cp == ',' && depth == 0))
 232           break;
 233
 234         if (*cp++ == '{')
 235           depth++;
 236       }
 237
 238   return *cp != '\0' ? cp : NULL;
 239 }
 240
 241 #endif /* !defined _LIBC || !defined GLOB_ONLY_P */
 242
 243 /* Do glob searching for PATTERN, placing results in PGLOB.
 244    The bits defined above may be set in FLAGS.
 245    If a directory cannot be opened or read and ERRFUNC is not nil,
 246    it is called with the pathname that caused the error, and the
 247    `errno' value from the failing call; if it returns non-zero
 248    `glob' returns GLOB_ABORTED; if it returns zero, the error is ignored.
 249    If memory cannot be allocated for PGLOB, GLOB_NOSPACE is returned.
 250    Otherwise, `glob' returns zero.  */
 251 int
 252 #ifdef GLOB_ATTRIBUTE
 253 GLOB_ATTRIBUTE
 254 #endif
 255 glob (pattern, flags, errfunc, pglob)
 256      const char *pattern;
 257      int flags;
 258      int (*errfunc) (const char *, int);
 259      glob_t *pglob;
 260 {
 261   const char *filename;
 262   char *dirname = NULL;
 263   size_t dirlen;
 264   int status;
 265   size_t oldcount;
 266   int meta;
 267   int dirname_modified;
 268   int malloc_dirname = 0;
 269   glob_t dirs;
 270   int retval = 0;
 271 #ifdef _LIBC
 272   size_t alloca_used = 0;
 273 #endif
 274
 275   if (pattern == NULL || pglob == NULL || (flags & ~__GLOB_FLAGS) != 0)
 276     {
 277       __set_errno (EINVAL);
 278       return -1;
 279     }
 280
 281   if (!(flags & GLOB_DOOFFS))
 282     /* Have to do this so `globfree' knows where to start freeing.  It
 283        also makes all the code that uses gl_offs simpler. */
 284     pglob->gl_offs = 0;
 285
 286   if (flags & GLOB_BRACE)
 287     {
 288       const char *begin;
 289
 290       if (flags & GLOB_NOESCAPE)
 291         begin = strchr (pattern, '{');
 292       else
 293         {
 294           begin = pattern;
 295           while (1)
 296             {
 297               if (*begin == '\0')
 298                 {
 299                   begin = NULL;
 300                   break;
 301                 }
 302
 303               if (*begin == '\\' && begin[1] != '\0')
 304                 ++begin;
 305               else if (*begin == '{')
 306                 break;
 307
 308               ++begin;
 309             }
 310         }
 311
 312       if (begin != NULL)
 313         {
 314           /* Allocate working buffer large enough for our work.  Note that
 315             we have at least an opening and closing brace.  */
 316           size_t firstc;
 317           char *alt_start;
 318           const char *p;
 319           const char *next;
 320           const char *rest;
 321           size_t rest_len;
 322           char *onealt;
 323           size_t pattern_len = strlen (pattern) - 1;
 324 #ifdef _LIBC
 325           int alloca_onealt = __libc_use_alloca (alloca_used + pattern_len);
 326           if (alloca_onealt)
 327             onealt = alloca_account (pattern_len, alloca_used);
 328           else
 329 #endif
 330             {
 331               onealt = (char *) malloc (pattern_len);
 332               if (onealt == NULL)
 333                 {
 334                   if (!(flags & GLOB_APPEND))
 335                     {
 336                       pglob->gl_pathc = 0;
 337                       pglob->gl_pathv = NULL;
 338                     }
 339                   return GLOB_NOSPACE;
 340                 }
 341             }
 342
 343           /* We know the prefix for all sub-patterns.  */
 344           alt_start = mempcpy (onealt, pattern, begin - pattern);
 345
 346           /* Find the first sub-pattern and at the same time find the
 347              rest after the closing brace.  */
 348           next = next_brace_sub (begin + 1, flags);
 349           if (next == NULL)
 350             {
 351               /* It is an illegal expression.  */
 352             illegal_brace:
 353 #ifdef _LIBC
 354               if (__builtin_expect (!alloca_onealt, 0))
 355 #endif
 356                 free (onealt);
 357               return glob (pattern, flags & ~GLOB_BRACE, errfunc, pglob);
 358             }
 359
 360           /* Now find the end of the whole brace expression.  */
 361           rest = next;
 362           while (*rest != '}')
 363             {
 364               rest = next_brace_sub (rest + 1, flags);
 365               if (rest == NULL)
 366                 /* It is an illegal expression.  */
 367                 goto illegal_brace;
 368             }
 369           /* Please note that we now can be sure the brace expression
 370              is well-formed.  */
 371           rest_len = strlen (++rest) + 1;
 372
 373           /* We have a brace expression.  BEGIN points to the opening {,
 374              NEXT points past the terminator of the first element, and END
 375              points past the final }.  We will accumulate result names from
 376              recursive runs for each brace alternative in the buffer using
 377              GLOB_APPEND.  */
 378
 379           if (!(flags & GLOB_APPEND))
 380             {
 381               /* This call is to set a new vector, so clear out the
 382                  vector so we can append to it.  */
 383               pglob->gl_pathc = 0;
 384               pglob->gl_pathv = NULL;
 385             }
 386           firstc = pglob->gl_pathc;
 387
 388           p = begin + 1;
 389           while (1)
 390             {
 391               int result;
 392
 393               /* Construct the new glob expression.  */
 394               mempcpy (mempcpy (alt_start, p, next - p), rest, rest_len);
 395
 396               result = glob (onealt,
 397                              ((flags & ~(GLOB_NOCHECK | GLOB_NOMAGIC))
 398                               | GLOB_APPEND), errfunc, pglob);
 399
 400               /* If we got an error, return it.  */
 401               if (result && result != GLOB_NOMATCH)
 402                 {
 403 #ifdef _LIBC
 404                   if (__builtin_expect (!alloca_onealt, 0))
 405 #endif
 406                     free (onealt);
 407                   if (!(flags & GLOB_APPEND))
 408                     {
 409                       globfree (pglob);
 410                       pglob->gl_pathc = 0;
 411                     }
 412                   return result;
 413                 }
 414
 415               if (*next == '}')
 416                 /* We saw the last entry.  */
 417                 break;
 418
 419               p = next + 1;
 420               next = next_brace_sub (p, flags);
 421               assert (next != NULL);
 422             }
 423
 424 #ifdef _LIBC
 425           if (__builtin_expect (!alloca_onealt, 0))
 426 #endif
 427             free (onealt);
 428
 429           if (pglob->gl_pathc != firstc)
 430             /* We found some entries.  */
 431             return 0;
 432           else if (!(flags & (GLOB_NOCHECK|GLOB_NOMAGIC)))
 433             return GLOB_NOMATCH;
 434         }
 435     }
 436
 437   if (!(flags & GLOB_APPEND))
 438     {
 439       pglob->gl_pathc = 0;
 440       if (!(flags & GLOB_DOOFFS))
 441         pglob->gl_pathv = NULL;
 442       else
 443         {
 444           size_t i;
 445
 446           if (pglob->gl_offs >= ~((size_t) 0) / sizeof (char *))
 447             return GLOB_NOSPACE;
 448
 449           pglob->gl_pathv = (char **) malloc ((pglob->gl_offs + 1)
 450                                               * sizeof (char *));
 451           if (pglob->gl_pathv == NULL)
 452             return GLOB_NOSPACE;
 453
 454           for (i = 0; i <= pglob->gl_offs; ++i)
 455             pglob->gl_pathv[i] = NULL;
 456         }
 457     }
 458
 459   oldcount = pglob->gl_pathc + pglob->gl_offs;
 460
 461   /* Find the filename.  */
 462   filename = strrchr (pattern, '/');
 463 #if defined __MSDOS__ || defined WINDOWS32
 464   /* The case of "d:pattern".  Since `:' is not allowed in
 465      file names, we can safely assume that wherever it
 466      happens in pattern, it signals the filename part.  This
 467      is so we could some day support patterns like "[a-z]:foo".  */
 468   if (filename == NULL)
 469     filename = strchr (pattern, ':');
 470 #endif /* __MSDOS__ || WINDOWS32 */
 471   dirname_modified = 0;
 472   if (filename == NULL)
 473     {
 474       /* This can mean two things: a simple name or "~name".  The latter
 475          case is nothing but a notation for a directory.  */
 476       if ((flags & (GLOB_TILDE|GLOB_TILDE_CHECK)) && pattern[0] == '~')
 477         {
 478           dirname = (char *) pattern;
 479           dirlen = strlen (pattern);
 480
 481           /* Set FILENAME to NULL as a special flag.  This is ugly but
 482              other solutions would require much more code.  We test for
 483              this special case below.  */
 484           filename = NULL;
 485         }
 486       else
 487         {
 488           if (__builtin_expect (pattern[0] == '\0', 0))
 489             {
 490               dirs.gl_pathv = NULL;
 491               goto no_matches;
 492             }
 493
 494           filename = pattern;
 495 #ifdef _AMIGA
 496           dirname = (char *) "";
 497 #else
 498           dirname = (char *) ".";
 499 #endif
 500           dirlen = 0;
 501         }
 502     }
 503   else if (filename == pattern
 504            || (filename == pattern + 1 && pattern[0] == '\\'
 505                && (flags & GLOB_NOESCAPE) == 0))
 506     {
 507       /* "/pattern" or "\\/pattern".  */
 508       dirname = (char *) "/";
 509       dirlen = 1;
 510       ++filename;
 511     }
 512   else
 513     {
 514       char *newp;
 515       dirlen = filename - pattern;
 516 #if defined __MSDOS__ || defined WINDOWS32
 517       if (*filename == ':'
 518           || (filename > pattern + 1 && filename[-1] == ':'))
 519         {
 520           char *drive_spec;
 521
 522           ++dirlen;
 523           drive_spec = (char *) __alloca (dirlen + 1);
 524           *((char *) mempcpy (drive_spec, pattern, dirlen)) = '\0';
 525           /* For now, disallow wildcards in the drive spec, to
 526              prevent infinite recursion in glob.  */
 527           if (__glob_pattern_p (drive_spec, !(flags & GLOB_NOESCAPE)))
 528             return GLOB_NOMATCH;
 529           /* If this is "d:pattern", we need to copy `:' to DIRNAME
 530              as well.  If it's "d:/pattern", don't remove the slash
 531              from "d:/", since "d:" and "d:/" are not the same.*/
 532         }
 533 #endif
 534 #ifdef _LIBC
 535       if (__libc_use_alloca (alloca_used + dirlen + 1))
 536         newp = alloca_account (dirlen + 1, alloca_used);
 537       else
 538 #endif
 539         {
 540           newp = malloc (dirlen + 1);
 541           if (newp == NULL)
 542             return GLOB_NOSPACE;
 543           malloc_dirname = 1;
 544         }
 545       *((char *) mempcpy (newp, pattern, dirlen)) = '\0';
 546       dirname = newp;
 547       ++filename;
 548
 549       if (filename[0] == '\0'
 550 #if defined __MSDOS__ || defined WINDOWS32
 551           && dirname[dirlen - 1] != ':'
 552           && (dirlen < 3 || dirname[dirlen - 2] != ':'
 553               || dirname[dirlen - 1] != '/')
 554 #endif
 555           && dirlen > 1)
 556         /* "pattern/".  Expand "pattern", appending slashes.  */
 557         {
 558           int orig_flags = flags;
 559           if (!(flags & GLOB_NOESCAPE) && dirname[dirlen - 1] == '\\')
 560             {
 561               /* "pattern\\/".  Remove the final backslash if it hasn't
 562                  been quoted.  */
 563               char *p = (char *) &dirname[dirlen - 1];
 564
 565               while (p > dirname && p[-1] == '\\') --p;
 566               if ((&dirname[dirlen] - p) & 1)
 567                 {
 568                   *(char *) &dirname[--dirlen] = '\0';
 569                   flags &= ~(GLOB_NOCHECK | GLOB_NOMAGIC);
 570                 }
 571             }
 572           int val = glob (dirname, flags | GLOB_MARK, errfunc, pglob);
 573           if (val == 0)
 574             pglob->gl_flags = ((pglob->gl_flags & ~GLOB_MARK)
 575                                | (flags & GLOB_MARK));
 576           else if (val == GLOB_NOMATCH && flags != orig_flags)
 577             {
 578               /* Make sure globfree (&dirs); is a nop.  */
 579               dirs.gl_pathv = NULL;
 580               flags = orig_flags;
 581               oldcount = pglob->gl_pathc + pglob->gl_offs;
 582               goto no_matches;
 583             }
 584           retval = val;
 585           goto out;
 586         }
 587     }
 588
 589 #ifndef VMS
 590   if ((flags & (GLOB_TILDE|GLOB_TILDE_CHECK)) && dirname[0] == '~')
 591     {
 592       if (dirname[1] == '\0' || dirname[1] == '/'
 593           || (!(flags & GLOB_NOESCAPE) && dirname[1] == '\\'
 594               && (dirname[2] == '\0' || dirname[2] == '/')))
 595         {
 596           /* Look up home directory.  */
 597           char *home_dir = getenv ("HOME");
 598           int malloc_home_dir = 0;
 599 # ifdef _AMIGA
 600           if (home_dir == NULL || home_dir[0] == '\0')
 601             home_dir = "SYS:";
 602 # else
 603 #  ifdef WINDOWS32
 604           if (home_dir == NULL || home_dir[0] == '\0')
 605             home_dir = "c:/users/default"; /* poor default */
 606 #  else
 607           if (home_dir == NULL || home_dir[0] == '\0')
 608             {
 609               int success;
 610               char *name;
 611               size_t buflen = GET_LOGIN_NAME_MAX () + 1;
 612
 613               if (buflen == 0)
 614                 /* `sysconf' does not support _SC_LOGIN_NAME_MAX.  Try
 615                    a moderate value.  */
 616                 buflen = 20;
 617               name = alloca_account (buflen, alloca_used);
 618
 619               success = getlogin_r (name, buflen) == 0;
 620               if (success)
 621                 {
 622                   struct passwd *p;
 623 #   if defined HAVE_GETPWNAM_R || defined _LIBC
 624                   long int pwbuflen = GETPW_R_SIZE_MAX ();
 625                   char *pwtmpbuf;
 626                   struct passwd pwbuf;
 627                   int malloc_pwtmpbuf = 0;
 628                   int save = errno;
 629
 630 #    ifndef _LIBC
 631                   if (pwbuflen == -1)
 632                     /* `sysconf' does not support _SC_GETPW_R_SIZE_MAX.
 633                        Try a moderate value.  */
 634                     pwbuflen = 1024;
 635 #    endif
 636                   if (__libc_use_alloca (alloca_used + pwbuflen))
 637                     pwtmpbuf = alloca_account (pwbuflen, alloca_used);
 638                   else
 639                     {
 640                       pwtmpbuf = malloc (pwbuflen);
 641                       if (pwtmpbuf == NULL)
 642                         {
 643                           retval = GLOB_NOSPACE;
 644                           goto out;
 645                         }
 646                       malloc_pwtmpbuf = 1;
 647                     }
 648
 649                   while (getpwnam_r (name, &pwbuf, pwtmpbuf, pwbuflen, &p)
 650                          != 0)
 651                     {
 652                       if (errno != ERANGE)
 653                         {
 654                           p = NULL;
 655                           break;
 656                         }
 657
 658                       if (!malloc_pwtmpbuf
 659                           && __libc_use_alloca (alloca_used
 660                                                 + 2 * pwbuflen))
 661                         pwtmpbuf = extend_alloca_account (pwtmpbuf, pwbuflen,
 662                                                           2 * pwbuflen,
 663                                                           alloca_used);
 664                       else
 665                         {
 666                           char *newp = realloc (malloc_pwtmpbuf
 667                                                 ? pwtmpbuf : NULL,
 668                                                 2 * pwbuflen);
 669                           if (newp == NULL)
 670                             {
 671                               if (__builtin_expect (malloc_pwtmpbuf, 0))
 672                                 free (pwtmpbuf);
 673                               retval = GLOB_NOSPACE;
 674                               goto out;
 675                             }
 676                           pwtmpbuf = newp;
 677                           pwbuflen = 2 * pwbuflen;
 678                           malloc_pwtmpbuf = 1;
 679                         }
 680                       __set_errno (save);
 681                     }
 682 #   else
 683                   p = getpwnam (name);
 684 #   endif
 685                   if (p != NULL)
 686                     {
 687                       if (!malloc_pwtmpbuf)
 688                         home_dir = p->pw_dir;
 689                       else
 690                         {
 691                           size_t home_dir_len = strlen (p->pw_dir) + 1;
 692                           if (__libc_use_alloca (alloca_used + home_dir_len))
 693                             home_dir = alloca_account (home_dir_len,
 694                                                        alloca_used);
 695                           else
 696                             {
 697                               home_dir = malloc (home_dir_len);
 698                               if (home_dir == NULL)
 699                                 {
 700                                   free (pwtmpbuf);
 701                                   retval = GLOB_NOSPACE;
 702                                   goto out;
 703                                 }
 704                               malloc_home_dir = 1;
 705                             }
 706                           memcpy (home_dir, p->pw_dir, home_dir_len);
 707
 708                           free (pwtmpbuf);
 709                         }
 710                     }
 711                 }
 712             }
 713           if (home_dir == NULL || home_dir[0] == '\0')
 714             {
 715               if (flags & GLOB_TILDE_CHECK)
 716                 {
 717                   if (__builtin_expect (malloc_home_dir, 0))
 718                     free (home_dir);
 719                   retval = GLOB_NOMATCH;
 720                   goto out;
 721                 }
 722               else
 723                 home_dir = (char *) "~"; /* No luck.  */
 724             }
 725 #  endif /* WINDOWS32 */
 726 # endif
 727           /* Now construct the full directory.  */
 728           if (dirname[1] == '\0')
 729             {
 730               if (__builtin_expect (malloc_dirname, 0))
 731                 free (dirname);
 732
 733               dirname = home_dir;
 734               dirlen = strlen (dirname);
 735               malloc_dirname = malloc_home_dir;
 736             }
 737           else
 738             {
 739               char *newp;
 740               size_t home_len = strlen (home_dir);
 741               int use_alloca = __libc_use_alloca (alloca_used
 742                                                   + home_len + dirlen);
 743               if (use_alloca)
 744                 newp = alloca_account (home_len + dirlen, alloca_used);
 745               else
 746                 {
 747                   newp = malloc (home_len + dirlen);
 748                   if (newp == NULL)
 749                     {
 750                       if (__builtin_expect (malloc_home_dir, 0))
 751                         free (home_dir);
 752                       retval = GLOB_NOSPACE;
 753                       goto out;
 754                     }
 755                 }
 756
 757               mempcpy (mempcpy (newp, home_dir, home_len),
 758                        &dirname[1], dirlen);
 759
 760               if (__builtin_expect (malloc_dirname, 0))
 761                 free (dirname);
 762
 763               dirname = newp;
 764               dirlen += home_len - 1;
 765               malloc_dirname = !use_alloca;
 766             }
 767           dirname_modified = 1;
 768         }
 769 # if !defined _AMIGA && !defined WINDOWS32
 770       else
 771         {
 772           char *end_name = strchr (dirname, '/');
 773           char *user_name;
 774           int malloc_user_name = 0;
 775           char *unescape = NULL;
 776
 777           if (!(flags & GLOB_NOESCAPE))
 778             {
 779               if (end_name == NULL)
 780                 {
 781                   unescape = strchr (dirname, '\\');
 782                   if (unescape)
 783                     end_name = strchr (unescape, '\0');
 784                 }
 785               else
 786                 unescape = memchr (dirname, '\\', end_name - dirname);
 787             }
 788           if (end_name == NULL)
 789             user_name = dirname + 1;
 790           else
 791             {
 792               char *newp;
 793               if (__libc_use_alloca (alloca_used + (end_name - dirname)))
 794                 newp = alloca_account (end_name - dirname, alloca_used);
 795               else
 796                 {
 797                   newp = malloc (end_name - dirname);
 798                   if (newp == NULL)
 799                     {
 800                       retval = GLOB_NOSPACE;
 801                       goto out;
 802                     }
 803                   malloc_user_name = 1;
 804                 }
 805               if (unescape != NULL)
 806                 {
 807                   char *p = mempcpy (newp, dirname + 1,
 808                                      unescape - dirname - 1);
 809                   char *q = unescape;
 810                   while (*q != '\0')
 811                     {
 812                       if (*q == '\\')
 813                         {
 814                           if (q[1] == '\0')
 815                             {
 816                               /* "~fo\\o\\" unescape to user_name "foo\\",
 817                                  but "~fo\\o\\/" unescape to user_name
 818                                  "foo".  */
 819                               if (filename == NULL)
 820                                 *p++ = '\\';
 821                               break;
 822                             }
 823                           ++q;
 824                         }
 825                       *p++ = *q++;
 826                     }
 827                   *p = '\0';
 828                 }
 829               else
 830                 *((char *) mempcpy (newp, dirname + 1, end_name - dirname))
 831                   = '\0';
 832               user_name = newp;
 833             }
 834
 835           /* Look up specific user's home directory.  */
 836           {
 837             struct passwd *p;
 838 #  if defined HAVE_GETPWNAM_R || defined _LIBC
 839             long int buflen = GETPW_R_SIZE_MAX ();
 840             char *pwtmpbuf;
 841             int malloc_pwtmpbuf = 0;
 842             struct passwd pwbuf;
 843             int save = errno;
 844
 845 #   ifndef _LIBC
 846             if (buflen == -1)
 847               /* `sysconf' does not support _SC_GETPW_R_SIZE_MAX.  Try a
 848                  moderate value.  */
 849               buflen = 1024;
 850 #   endif
 851             if (__libc_use_alloca (alloca_used + buflen))
 852               pwtmpbuf = alloca_account (buflen, alloca_used);
 853             else
 854               {
 855                 pwtmpbuf = malloc (buflen);
 856                 if (pwtmpbuf == NULL)
 857                   {
 858                   nomem_getpw:
 859                     if (__builtin_expect (malloc_user_name, 0))
 860                       free (user_name);
 861                     retval = GLOB_NOSPACE;
 862                     goto out;
 863                   }
 864                 malloc_pwtmpbuf = 1;
 865               }
 866
 867             while (getpwnam_r (user_name, &pwbuf, pwtmpbuf, buflen, &p) != 0)
 868               {
 869                 if (errno != ERANGE)
 870                   {
 871                     p = NULL;
 872                     break;
 873                   }
 874                 if (!malloc_pwtmpbuf
 875                     && __libc_use_alloca (alloca_used + 2 * buflen))
 876                   pwtmpbuf = extend_alloca_account (pwtmpbuf, buflen,
 877                                                     2 * buflen, alloca_used);
 878                 else
 879                   {
 880                     char *newp = realloc (malloc_pwtmpbuf ? pwtmpbuf : NULL,
 881                                           2 * buflen);
 882                     if (newp == NULL)
 883                       {
 884                         if (__builtin_expect (malloc_pwtmpbuf, 0))
 885                           free (pwtmpbuf);
 886                         goto nomem_getpw;
 887                       }
 888                     pwtmpbuf = newp;
 889                     malloc_pwtmpbuf = 1;
 890                   }
 891                 __set_errno (save);
 892               }
 893 #  else
 894             p = getpwnam (user_name);
 895 #  endif
 896
 897             if (__builtin_expect (malloc_user_name, 0))
 898               free (user_name);
 899
 900             /* If we found a home directory use this.  */
 901             if (p != NULL)
 902               {
 903                 size_t home_len = strlen (p->pw_dir);
 904                 size_t rest_len = end_name == NULL ? 0 : strlen (end_name);
 905
 906                 if (__builtin_expect (malloc_dirname, 0))
 907                   free (dirname);
 908                 malloc_dirname = 0;
 909
 910                 if (__libc_use_alloca (alloca_used + home_len + rest_len + 1))
 911                   dirname = alloca_account (home_len + rest_len + 1,
 912                                             alloca_used);
 913                 else
 914                   {
 915                     dirname = malloc (home_len + rest_len + 1);
 916                     if (dirname == NULL)
 917                       {
 918                         if (__builtin_expect (malloc_pwtmpbuf, 0))
 919                           free (pwtmpbuf);
 920                         retval = GLOB_NOSPACE;
 921                         goto out;
 922                       }
 923                     malloc_dirname = 1;
 924                   }
 925                 *((char *) mempcpy (mempcpy (dirname, p->pw_dir, home_len),
 926                                     end_name, rest_len)) = '\0';
 927
 928                 dirlen = home_len + rest_len;
 929                 dirname_modified = 1;
 930
 931                 if (__builtin_expect (malloc_pwtmpbuf, 0))
 932                   free (pwtmpbuf);
 933               }
 934             else
 935               {
 936                 if (__builtin_expect (malloc_pwtmpbuf, 0))
 937                   free (pwtmpbuf);
 938
 939                 if (flags & GLOB_TILDE_CHECK)
 940                   /* We have to regard it as an error if we cannot find the
 941                      home directory.  */
 942                   return GLOB_NOMATCH;
 943               }
 944           }
 945         }
 946 # endif /* Not Amiga && not WINDOWS32.  */
 947     }
 948 #endif  /* Not VMS.  */
 949
 950   /* Now test whether we looked for "~" or "~NAME".  In this case we
 951      can give the answer now.  */
 952   if (filename == NULL)
 953     {
 954       struct stat st;
 955       struct_stat64 st64;
 956
 957       /* Return the directory if we don't check for error or if it exists.  */
 958       if ((flags & GLOB_NOCHECK)
 959           || (((__builtin_expect (flags & GLOB_ALTDIRFUNC, 0))
 960                ? ((*pglob->gl_stat) (dirname, &st) == 0
 961                   && S_ISDIR (st.st_mode))
 962                : (__stat64 (dirname, &st64) == 0 && S_ISDIR (st64.st_mode)))))
 963         {
 964           int newcount = pglob->gl_pathc + pglob->gl_offs;
 965           char **new_gl_pathv;
 966
 967           if (newcount > UINTPTR_MAX - (1 + 1)
 968               || newcount + 1 + 1 > ~((size_t) 0) / sizeof (char *))
 969             {
 970             nospace:
 971               free (pglob->gl_pathv);
 972               pglob->gl_pathv = NULL;
 973               pglob->gl_pathc = 0;
 974               return GLOB_NOSPACE;
 975             }
 976
 977           new_gl_pathv
 978             = (char **) realloc (pglob->gl_pathv,
 979                                  (newcount + 1 + 1) * sizeof (char *));
 980           if (new_gl_pathv == NULL)
 981             goto nospace;
 982           pglob->gl_pathv = new_gl_pathv;
 983
 984           if (flags & GLOB_MARK)
 985             {
 986               char *p;
 987               pglob->gl_pathv[newcount] = malloc (dirlen + 2);
 988               if (pglob->gl_pathv[newcount] == NULL)
 989                 goto nospace;
 990               p = mempcpy (pglob->gl_pathv[newcount], dirname, dirlen);
 991               p[0] = '/';
 992               p[1] = '\0';
 993             }
 994           else
 995             {
 996               pglob->gl_pathv[newcount] = strdup (dirname);
 997               if (pglob->gl_pathv[newcount] == NULL)
 998                 goto nospace;
 999             }
1000           pglob->gl_pathv[++newcount] = NULL;
1001           ++pglob->gl_pathc;
1002           pglob->gl_flags = flags;
1003
1004           return 0;
1005         }
1006
1007       /* Not found.  */
1008       return GLOB_NOMATCH;
1009     }
1010
1011   meta = __glob_pattern_type (dirname, !(flags & GLOB_NOESCAPE));
1012   /* meta is 1 if correct glob pattern containing metacharacters.
1013      If meta has bit (1 << 2) set, it means there was an unterminated
1014      [ which we handle the same, using fnmatch.  Broken unterminated
1015      pattern bracket expressions ought to be rare enough that it is
1016      not worth special casing them, fnmatch will do the right thing.  */
1017   if (meta & 5)
1018     {
1019       /* The directory name contains metacharacters, so we
1020          have to glob for the directory, and then glob for
1021          the pattern in each directory found.  */
1022       size_t i;
1023
1024       if (!(flags & GLOB_NOESCAPE) && dirlen > 0 && dirname[dirlen - 1] == '\\')
1025         {
1026           /* "foo\\/bar".  Remove the final backslash from dirname
1027              if it has not been quoted.  */
1028           char *p = (char *) &dirname[dirlen - 1];
1029
1030           while (p > dirname && p[-1] == '\\') --p;
1031           if ((&dirname[dirlen] - p) & 1)
1032             *(char *) &dirname[--dirlen] = '\0';
1033         }
1034
1035       if (__builtin_expect ((flags & GLOB_ALTDIRFUNC) != 0, 0))
1036         {
1037           /* Use the alternative access functions also in the recursive
1038              call.  */
1039           dirs.gl_opendir = pglob->gl_opendir;
1040           dirs.gl_readdir = pglob->gl_readdir;
1041           dirs.gl_closedir = pglob->gl_closedir;
1042           dirs.gl_stat = pglob->gl_stat;
1043           dirs.gl_lstat = pglob->gl_lstat;
1044         }
1045
1046       status = glob (dirname,
1047                      ((flags & (GLOB_ERR | GLOB_NOESCAPE
1048                                 | GLOB_ALTDIRFUNC))
1049                       | GLOB_NOSORT | GLOB_ONLYDIR),
1050                      errfunc, &dirs);
1051       if (status != 0)
1052         {
1053           if ((flags & GLOB_NOCHECK) == 0 || status != GLOB_NOMATCH)
1054             return status;
1055           goto no_matches;
1056         }
1057
1058       /* We have successfully globbed the preceding directory name.
1059          For each name we found, call glob_in_dir on it and FILENAME,
1060          appending the results to PGLOB.  */
1061       for (i = 0; i < dirs.gl_pathc; ++i)
1062         {
1063           int old_pathc;
1064
1065 #ifdef  SHELL
1066           {
1067             /* Make globbing interruptible in the bash shell. */
1068             extern int interrupt_state;
1069
1070             if (interrupt_state)
1071               {
1072                 globfree (&dirs);
1073                 return GLOB_ABORTED;
1074               }
1075           }
1076 #endif /* SHELL.  */
1077
1078           old_pathc = pglob->gl_pathc;
1079           status = glob_in_dir (filename, dirs.gl_pathv[i],
1080                                 ((flags | GLOB_APPEND)
1081                                  & ~(GLOB_NOCHECK | GLOB_NOMAGIC)),
1082                                 errfunc, pglob, alloca_used);
1083           if (status == GLOB_NOMATCH)
1084             /* No matches in this directory.  Try the next.  */
1085             continue;
1086
1087           if (status != 0)
1088             {
1089               globfree (&dirs);
1090               globfree (pglob);
1091               pglob->gl_pathc = 0;
1092               return status;
1093             }
1094
1095           /* Stick the directory on the front of each name.  */
1096           if (prefix_array (dirs.gl_pathv[i],
1097                             &pglob->gl_pathv[old_pathc + pglob->gl_offs],
1098                             pglob->gl_pathc - old_pathc))
1099             {
1100               globfree (&dirs);
1101               globfree (pglob);
1102               pglob->gl_pathc = 0;
1103               return GLOB_NOSPACE;
1104             }
1105         }
1106
1107       flags |= GLOB_MAGCHAR;
1108
1109       /* We have ignored the GLOB_NOCHECK flag in the `glob_in_dir' calls.
1110          But if we have not found any matching entry and the GLOB_NOCHECK
1111          flag was set we must return the input pattern itself.  */
1112       if (pglob->gl_pathc + pglob->gl_offs == oldcount)
1113         {
1114         no_matches:
1115           /* No matches.  */
1116           if (flags & GLOB_NOCHECK)
1117             {
1118               int newcount = pglob->gl_pathc + pglob->gl_offs;
1119               char **new_gl_pathv;
1120
1121               if (newcount > UINTPTR_MAX - 2
1122                   || newcount + 2 > ~((size_t) 0) / sizeof (char *))
1123                 {
1124                 nospace2:
1125                   globfree (&dirs);
1126                   return GLOB_NOSPACE;
1127                 }
1128
1129               new_gl_pathv = (char **) realloc (pglob->gl_pathv,
1130                                                 (newcount + 2)
1131                                                 * sizeof (char *));
1132               if (new_gl_pathv == NULL)
1133                 goto nospace2;
1134               pglob->gl_pathv = new_gl_pathv;
1135
1136               pglob->gl_pathv[newcount] = __strdup (pattern);
1137               if (pglob->gl_pathv[newcount] == NULL)
1138                 {
1139                   globfree (&dirs);
1140                   globfree (pglob);
1141                   pglob->gl_pathc = 0;
1142                   return GLOB_NOSPACE;
1143                 }
1144
1145               ++pglob->gl_pathc;
1146               ++newcount;
1147
1148               pglob->gl_pathv[newcount] = NULL;
1149               pglob->gl_flags = flags;
1150             }
1151           else
1152             {
1153               globfree (&dirs);
1154               return GLOB_NOMATCH;
1155             }
1156         }
1157
1158       globfree (&dirs);
1159     }
1160   else
1161     {
1162       int old_pathc = pglob->gl_pathc;
1163       int orig_flags = flags;
1164
1165       if (meta & 2)
1166         {
1167           char *p = strchr (dirname, '\\'), *q;
1168           /* We need to unescape the dirname string.  It is certainly
1169              allocated by alloca, as otherwise filename would be NULL
1170              or dirname wouldn't contain backslashes.  */
1171           q = p;
1172           do
1173             {
1174               if (*p == '\\')
1175                 {
1176                   *q = *++p;
1177                   --dirlen;
1178                 }
1179               else
1180                 *q = *p;
1181               ++q;
1182             }
1183           while (*p++ != '\0');
1184           dirname_modified = 1;
1185         }
1186       if (dirname_modified)
1187         flags &= ~(GLOB_NOCHECK | GLOB_NOMAGIC);
1188       status = glob_in_dir (filename, dirname, flags, errfunc, pglob,
1189                             alloca_used);
1190       if (status != 0)
1191         {
1192           if (status == GLOB_NOMATCH && flags != orig_flags
1193               && pglob->gl_pathc + pglob->gl_offs == oldcount)
1194             {
1195               /* Make sure globfree (&dirs); is a nop.  */
1196               dirs.gl_pathv = NULL;
1197               flags = orig_flags;
1198               goto no_matches;
1199             }
1200           return status;
1201         }
1202
1203       if (dirlen > 0)
1204         {
1205           /* Stick the directory on the front of each name.  */
1206           if (prefix_array (dirname,
1207                             &pglob->gl_pathv[old_pathc + pglob->gl_offs],
1208                             pglob->gl_pathc - old_pathc))
1209             {
1210               globfree (pglob);
1211               pglob->gl_pathc = 0;
1212               return GLOB_NOSPACE;
1213             }
1214         }
1215     }
1216
1217   if (flags & GLOB_MARK)
1218     {
1219       /* Append slashes to directory names.  */
1220       size_t i;
1221       struct stat st;
1222       struct_stat64 st64;
1223
1224       for (i = oldcount; i < pglob->gl_pathc + pglob->gl_offs; ++i)
1225         if ((__builtin_expect (flags & GLOB_ALTDIRFUNC, 0)
1226              ? ((*pglob->gl_stat) (pglob->gl_pathv[i], &st) == 0
1227                 && S_ISDIR (st.st_mode))
1228              : (__stat64 (pglob->gl_pathv[i], &st64) == 0
1229                 && S_ISDIR (st64.st_mode))))
1230           {
1231             size_t len = strlen (pglob->gl_pathv[i]) + 2;
1232             char *new = realloc (pglob->gl_pathv[i], len);
1233             if (new == NULL)
1234               {
1235                 globfree (pglob);
1236                 pglob->gl_pathc = 0;
1237                 return GLOB_NOSPACE;
1238               }
1239             strcpy (&new[len - 2], "/");
1240             pglob->gl_pathv[i] = new;
1241           }
1242     }
1243
1244   if (!(flags & GLOB_NOSORT))
1245     {
1246       /* Sort the vector.  */
1247       qsort (&pglob->gl_pathv[oldcount],
1248              pglob->gl_pathc + pglob->gl_offs - oldcount,
1249              sizeof (char *), collated_compare);
1250     }
1251
1252  out:
1253   if (__builtin_expect (malloc_dirname, 0))
1254     free (dirname);
1255
1256   return retval;
1257 }
1258 #if defined _LIBC && !defined glob
1259 libc_hidden_def (glob)
1260 #endif
1261
1262
1263 #if !defined _LIBC || !defined GLOB_ONLY_P
1264
1265 /* Free storage allocated in PGLOB by a previous `glob' call.  */
1266 void
1267 globfree (pglob)
1268      register glob_t *pglob;
1269 {
1270   if (pglob->gl_pathv != NULL)
1271     {
1272       size_t i;
1273       for (i = 0; i < pglob->gl_pathc; ++i)
1274         free (pglob->gl_pathv[pglob->gl_offs + i]);
1275       free (pglob->gl_pathv);
1276       pglob->gl_pathv = NULL;
1277     }
1278 }
1279 #if defined _LIBC && !defined globfree
1280 libc_hidden_def (globfree)
1281 #endif
1282
1283
1284 /* Do a collated comparison of A and B.  */
1285 static int
1286 collated_compare (const void *a, const void *b)
1287 {
1288   const char *const s1 = *(const char *const * const) a;
1289   const char *const s2 = *(const char *const * const) b;
1290
1291   if (s1 == s2)
1292     return 0;
1293   if (s1 == NULL)
1294     return 1;
1295   if (s2 == NULL)
1296     return -1;
1297   return strcoll (s1, s2);
1298 }
1299
1300
1301 /* Prepend DIRNAME to each of N members of ARRAY, replacing ARRAY's
1302    elements in place.  Return nonzero if out of memory, zero if successful.
1303    A slash is inserted between DIRNAME and each elt of ARRAY,
1304    unless DIRNAME is just "/".  Each old element of ARRAY is freed.  */
1305 static int
1306 prefix_array (const char *dirname, char **array, size_t n)
1307 {
1308   register size_t i;
1309   size_t dirlen = strlen (dirname);
1310 #if defined __MSDOS__ || defined WINDOWS32
1311   int sep_char = '/';
1312 # define DIRSEP_CHAR sep_char
1313 #else
1314 # define DIRSEP_CHAR '/'
1315 #endif
1316
1317   if (dirlen == 1 && dirname[0] == '/')
1318     /* DIRNAME is just "/", so normal prepending would get us "//foo".
1319        We want "/foo" instead, so don't prepend any chars from DIRNAME.  */
1320     dirlen = 0;
1321 #if defined __MSDOS__ || defined WINDOWS32
1322   else if (dirlen > 1)
1323     {
1324       if (dirname[dirlen - 1] == '/' && dirname[dirlen - 2] == ':')
1325         /* DIRNAME is "d:/".  Don't prepend the slash from DIRNAME.  */
1326         --dirlen;
1327       else if (dirname[dirlen - 1] == ':')
1328         {
1329           /* DIRNAME is "d:".  Use `:' instead of `/'.  */
1330           --dirlen;
1331           sep_char = ':';
1332         }
1333     }
1334 #endif
1335
1336   for (i = 0; i < n; ++i)
1337     {
1338       size_t eltlen = strlen (array[i]) + 1;
1339       char *new = (char *) malloc (dirlen + 1 + eltlen);
1340       if (new == NULL)
1341         {
1342           while (i > 0)
1343             free (array[--i]);
1344           return 1;
1345         }
1346
1347       {
1348         char *endp = mempcpy (new, dirname, dirlen);
1349         *endp++ = DIRSEP_CHAR;
1350         mempcpy (endp, array[i], eltlen);
1351       }
1352       free (array[i]);
1353       array[i] = new;
1354     }
1355
1356   return 0;
1357 }
1358
1359
1360 /* We must not compile this function twice.  */
1361 #if !defined _LIBC || !defined NO_GLOB_PATTERN_P
1362 int
1363 __glob_pattern_type (pattern, quote)
1364      const char *pattern;
1365      int quote;
1366 {
1367   register const char *p;
1368   int ret = 0;
1369
1370   for (p = pattern; *p != '\0'; ++p)
1371     switch (*p)
1372       {
1373       case '?':
1374       case '*':
1375         return 1;
1376
1377       case '\\':
1378         if (quote)
1379           {
1380             if (p[1] != '\0')
1381               ++p;
1382             ret |= 2;
1383           }
1384         break;
1385
1386       case '[':
1387         ret |= 4;
1388         break;
1389
1390       case ']':
1391         if (ret & 4)
1392           return 1;
1393         break;
1394       }
1395
1396   return ret;
1397 }
1398
1399 /* Return nonzero if PATTERN contains any metacharacters.
1400    Metacharacters can be quoted with backslashes if QUOTE is nonzero.  */
1401 int
1402 __glob_pattern_p (pattern, quote)
1403      const char *pattern;
1404      int quote;
1405 {
1406   return __glob_pattern_type (pattern, quote) == 1;
1407 }
1408 # ifdef _LIBC
1409 weak_alias (__glob_pattern_p, glob_pattern_p)
1410 # endif
1411 #endif
1412
1413 #endif /* !GLOB_ONLY_P */
1414
1415
1416 /* We put this in a separate function mainly to allow the memory
1417    allocated with alloca to be recycled.  */
1418 #if !defined _LIBC || !defined GLOB_ONLY_P
1419 static int
1420 __attribute_noinline__
1421 link_exists2_p (const char *dir, size_t dirlen, const char *fname,
1422                glob_t *pglob
1423 # ifndef _LIBC
1424                 , int flags
1425 # endif
1426                 )
1427 {
1428   size_t fnamelen = strlen (fname);
1429   char *fullname = (char *) __alloca (dirlen + 1 + fnamelen + 1);
1430   struct stat st;
1431 # ifndef _LIBC
1432   struct_stat64 st64;
1433 # endif
1434
1435   mempcpy (mempcpy (mempcpy (fullname, dir, dirlen), "/", 1),
1436            fname, fnamelen + 1);
1437
1438 # ifdef _LIBC
1439   return (*pglob->gl_stat) (fullname, &st) == 0;
1440 # else
1441   return ((__builtin_expect (flags & GLOB_ALTDIRFUNC, 0)
1442            ? (*pglob->gl_stat) (fullname, &st)
1443            : __stat64 (fullname, &st64)) == 0);
1444 # endif
1445 }
1446 # ifdef _LIBC
1447 #  define link_exists_p(dfd, dirname, dirnamelen, fname, pglob, flags) \
1448   (__builtin_expect (flags & GLOB_ALTDIRFUNC, 0)                              \
1449    ? link_exists2_p (dirname, dirnamelen, fname, pglob)                       \
1450    : ({ struct stat64 st64;                                                   \
1451        __fxstatat64 (_STAT_VER, dfd, fname, &st64, 0) == 0; }))
1452 # else
1453 #  define link_exists_p(dfd, dirname, dirnamelen, fname, pglob, flags) \
1454   link_exists2_p (dirname, dirnamelen, fname, pglob, flags)
1455 # endif
1456 #endif
1457
1458
1459 /* Like `glob', but PATTERN is a final pathname component,
1460    and matches are searched for in DIRECTORY.
1461    The GLOB_NOSORT bit in FLAGS is ignored.  No sorting is ever done.
1462    The GLOB_APPEND flag is assumed to be set (always appends).  */
1463 static int
1464 glob_in_dir (const char *pattern, const char *directory, int flags,
1465              int (*errfunc) (const char *, int),
1466              glob_t *pglob, size_t alloca_used)
1467 {
1468   size_t dirlen = strlen (directory);
1469   void *stream = NULL;
1470   struct globnames
1471     {
1472       struct globnames *next;
1473       size_t count;
1474       char *name[64];
1475     };
1476 #define INITIAL_COUNT sizeof (init_names.name) / sizeof (init_names.name[0])
1477   struct globnames init_names;
1478   struct globnames *names = &init_names;
1479   struct globnames *names_alloca = &init_names;
1480   size_t nfound = 0;
1481   size_t cur = 0;
1482   int meta;
1483   int save;
1484
1485   alloca_used += sizeof (init_names);
1486
1487   init_names.next = NULL;
1488   init_names.count = INITIAL_COUNT;
1489
1490   meta = __glob_pattern_type (pattern, !(flags & GLOB_NOESCAPE));
1491   if (meta == 0 && (flags & (GLOB_NOCHECK|GLOB_NOMAGIC)))
1492     {
1493       /* We need not do any tests.  The PATTERN contains no meta
1494          characters and we must not return an error therefore the
1495          result will always contain exactly one name.  */
1496       flags |= GLOB_NOCHECK;
1497     }
1498   else if (meta == 0)
1499     {
1500       /* Since we use the normal file functions we can also use stat()
1501          to verify the file is there.  */
1502       union
1503       {
1504         struct stat st;
1505         struct_stat64 st64;
1506       } ust;
1507       size_t patlen = strlen (pattern);
1508       int alloca_fullname = __libc_use_alloca (alloca_used
1509                                                + dirlen + 1 + patlen + 1);
1510       char *fullname;
1511       if (alloca_fullname)
1512         fullname = alloca_account (dirlen + 1 + patlen + 1, alloca_used);
1513       else
1514         {
1515           fullname = malloc (dirlen + 1 + patlen + 1);
1516           if (fullname == NULL)
1517             return GLOB_NOSPACE;
1518         }
1519
1520       mempcpy (mempcpy (mempcpy (fullname, directory, dirlen),
1521                         "/", 1),
1522                pattern, patlen + 1);
1523       if ((__builtin_expect (flags & GLOB_ALTDIRFUNC, 0)
1524            ? (*pglob->gl_stat) (fullname, &ust.st)
1525            : __stat64 (fullname, &ust.st64)) == 0)
1526         /* We found this file to be existing.  Now tell the rest
1527            of the function to copy this name into the result.  */
1528         flags |= GLOB_NOCHECK;
1529
1530       if (__builtin_expect (!alloca_fullname, 0))
1531         free (fullname);
1532     }
1533   else
1534     {
1535       stream = (__builtin_expect (flags & GLOB_ALTDIRFUNC, 0)
1536                 ? (*pglob->gl_opendir) (directory)
1537                 : opendir (directory));
1538       if (stream == NULL)
1539         {
1540           if (errno != ENOTDIR
1541               && ((errfunc != NULL && (*errfunc) (directory, errno))
1542                   || (flags & GLOB_ERR)))
1543             return GLOB_ABORTED;
1544         }
1545       else
1546         {
1547 #ifdef _LIBC
1548           int dfd = (__builtin_expect (flags & GLOB_ALTDIRFUNC, 0)
1549                      ? -1 : dirfd ((DIR *) stream));
1550 #endif
1551           int fnm_flags = ((!(flags & GLOB_PERIOD) ? FNM_PERIOD : 0)
1552                            | ((flags & GLOB_NOESCAPE) ? FNM_NOESCAPE : 0)
1553 #if defined _AMIGA || defined VMS
1554                            | FNM_CASEFOLD
1555 #endif
1556                            );
1557           flags |= GLOB_MAGCHAR;
1558
1559           while (1)
1560             {
1561               const char *name;
1562               size_t len;
1563 #if defined _LIBC && !defined COMPILE_GLOB64
1564               struct dirent64 *d;
1565               union
1566                 {
1567                   struct dirent64 d64;
1568                   char room [offsetof (struct dirent64, d_name[0])
1569                              + NAME_MAX + 1];
1570                 }
1571               d64buf;
1572
1573               if (__builtin_expect (flags & GLOB_ALTDIRFUNC, 0))
1574                 {
1575                   struct dirent *d32 = (*pglob->gl_readdir) (stream);
1576                   if (d32 != NULL)
1577                     {
1578                       CONVERT_DIRENT_DIRENT64 (&d64buf.d64, d32);
1579                       d = &d64buf.d64;
1580                     }
1581                   else
1582                     d = NULL;
1583                 }
1584               else
1585                 d = __readdir64 (stream);
1586 #else
1587               struct dirent *d = (__builtin_expect (flags & GLOB_ALTDIRFUNC, 0)
1588                                   ? ((struct dirent *)
1589                                      (*pglob->gl_readdir) (stream))
1590                                   : __readdir (stream));
1591 #endif
1592               if (d == NULL)
1593                 break;
1594               if (! REAL_DIR_ENTRY (d))
1595                 continue;
1596
1597               /* If we shall match only directories use the information
1598                  provided by the dirent call if possible.  */
1599               if ((flags & GLOB_ONLYDIR) && !DIRENT_MIGHT_BE_DIR (d))
1600                 continue;
1601
1602               name = d->d_name;
1603
1604               if (fnmatch (pattern, name, fnm_flags) == 0)
1605                 {
1606                   /* If the file we found is a symlink we have to
1607                      make sure the target file exists.  */
1608                   if (!DIRENT_MIGHT_BE_SYMLINK (d)
1609                       || link_exists_p (dfd, directory, dirlen, name, pglob,
1610                                         flags))
1611                     {
1612                       if (cur == names->count)
1613                         {
1614                           struct globnames *newnames;
1615                           size_t count = names->count * 2;
1616                           size_t size = (sizeof (struct globnames)
1617                                          + ((count - INITIAL_COUNT)
1618                                             * sizeof (char *)));
1619                           if (__libc_use_alloca (alloca_used + size))
1620                             newnames = names_alloca
1621                               = alloca_account (size, alloca_used);
1622                           else if ((newnames = malloc (size))
1623                                    == NULL)
1624                             goto memory_error;
1625                           newnames->count = count;
1626                           newnames->next = names;
1627                           names = newnames;
1628                           cur = 0;
1629                         }
1630                       len = NAMLEN (d);
1631                       names->name[cur] = (char *) malloc (len + 1);
1632                       if (names->name[cur] == NULL)
1633                         goto memory_error;
1634                       *((char *) mempcpy (names->name[cur++], name, len))
1635                         = '\0';
1636                       ++nfound;
1637                     }
1638                 }
1639             }
1640         }
1641     }
1642
1643   if (nfound == 0 && (flags & GLOB_NOCHECK))
1644     {
1645       size_t len = strlen (pattern);
1646       nfound = 1;
1647       names->name[cur] = (char *) malloc (len + 1);
1648       if (names->name[cur] == NULL)
1649         goto memory_error;
1650       *((char *) mempcpy (names->name[cur++], pattern, len)) = '\0';
1651     }
1652
1653   int result = GLOB_NOMATCH;
1654   if (nfound != 0)
1655     {
1656       result = 0;
1657
1658       if (pglob->gl_pathc > UINTPTR_MAX - pglob->gl_offs
1659           || pglob->gl_pathc + pglob->gl_offs > UINTPTR_MAX - nfound
1660           || pglob->gl_pathc + pglob->gl_offs + nfound > UINTPTR_MAX - 1
1661           || (pglob->gl_pathc + pglob->gl_offs + nfound + 1
1662               > UINTPTR_MAX / sizeof (char *)))
1663         goto memory_error;
1664
1665       char **new_gl_pathv;
1666       new_gl_pathv
1667         = (char **) realloc (pglob->gl_pathv,
1668                              (pglob->gl_pathc + pglob->gl_offs + nfound + 1)
1669                              * sizeof (char *));
1670       if (new_gl_pathv == NULL)
1671         {
1672         memory_error:
1673           while (1)
1674             {
1675               struct globnames *old = names;
1676               for (size_t i = 0; i < cur; ++i)
1677                 free (names->name[i]);
1678               names = names->next;
1679               /* NB: we will not leak memory here if we exit without
1680                  freeing the current block assigned to OLD.  At least
1681                  the very first block is always allocated on the stack
1682                  and this is the block assigned to OLD here.  */
1683               if (names == NULL)
1684                 {
1685                   assert (old == &init_names);
1686                   break;
1687                 }
1688               cur = names->count;
1689               if (old == names_alloca)
1690                 names_alloca = names;
1691               else
1692                 free (old);
1693             }
1694           result = GLOB_NOSPACE;
1695         }
1696       else
1697         {
1698           while (1)
1699             {
1700               struct globnames *old = names;
1701               for (size_t i = 0; i < cur; ++i)
1702                 new_gl_pathv[pglob->gl_offs + pglob->gl_pathc++]
1703                   = names->name[i];
1704               names = names->next;
1705               /* NB: we will not leak memory here if we exit without
1706                  freeing the current block assigned to OLD.  At least
1707                  the very first block is always allocated on the stack
1708                  and this is the block assigned to OLD here.  */
1709               if (names == NULL)
1710                 {
1711                   assert (old == &init_names);
1712                   break;
1713                 }
1714               cur = names->count;
1715               if (old == names_alloca)
1716                 names_alloca = names;
1717               else
1718                 free (old);
1719             }
1720
1721           pglob->gl_pathv = new_gl_pathv;
1722
1723           pglob->gl_pathv[pglob->gl_offs + pglob->gl_pathc] = NULL;
1724
1725           pglob->gl_flags = flags;
1726         }
1727     }
1728
1729   if (stream != NULL)
1730     {
1731       save = errno;
1732       if (__builtin_expect (flags & GLOB_ALTDIRFUNC, 0))
1733         (*pglob->gl_closedir) (stream);
1734       else
1735         closedir (stream);
1736       __set_errno (save);
1737     }
1738
1739   return result;
1740 }