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