sysdeps/generic/glob.c

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