posix/glob.c

   1 /* Copyright (C) 1991, 92, 93, 94, 95, 96, 97 Free Software Foundation, Inc.
   2
   3    This library is free software; you can redistribute it and/or
   4    modify it under the terms of the GNU Library General Public License as
   5    published by the Free Software Foundation; either version 2 of the
   6    License, or (at your option) any later version.
   7
   8    This library is distributed in the hope that it will be useful,
   9    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11    Library General Public License for more details.
  12
  13    You should have received a copy of the GNU Library General Public
  14    License along with this library; see the file COPYING.LIB.  If not,
  15    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  16    Boston, MA 02111-1307, USA.  */
  17
  18 /* AIX requires this to be the first thing in the file.  */
  19 #if defined _AIX && !defined __GNUC__
  20  #pragma alloca
  21 #endif
  22
  23 #ifdef  HAVE_CONFIG_H
  24 # include <config.h>
  25 #endif
  26
  27 /* Enable GNU extensions in glob.h.  */
  28 #ifndef _GNU_SOURCE
  29 # define _GNU_SOURCE    1
  30 #endif
  31
  32 #include <errno.h>
  33 #include <sys/types.h>
  34 #include <sys/stat.h>
  35
  36 /* Outcomment the following line for production quality code.  */
  37 /* #define NDEBUG 1 */
  38 #include <assert.h>
  39
  40 #include <stdio.h>              /* Needed on stupid SunOS for assert.  */
  41
  42
  43 /* Comment out all this code if we are using the GNU C Library, and are not
  44    actually compiling the library itself.  This code is part of the GNU C
  45    Library, but also included in many other GNU distributions.  Compiling
  46    and linking in this code is a waste when using the GNU C library
  47    (especially if it is a shared library).  Rather than having every GNU
  48    program understand `configure --with-gnu-libc' and omit the object files,
  49    it is simpler to just do this in the source for each such file.  */
  50
  51 #define GLOB_INTERFACE_VERSION 1
  52 #if !defined _LIBC && defined __GNU_LIBRARY__ && __GNU_LIBRARY__ > 1
  53 # include <gnu-versions.h>
  54 # if _GNU_GLOB_INTERFACE_VERSION == GLOB_INTERFACE_VERSION
  55 #  define ELIDE_CODE
  56 # endif
  57 #endif
  58
  59 #ifndef ELIDE_CODE
  60
  61 #if defined STDC_HEADERS || defined __GNU_LIBRARY__
  62 # include <stddef.h>
  63 #endif
  64
  65 #if defined HAVE_UNISTD_H || defined _LIBC
  66 # include <unistd.h>
  67 # ifndef POSIX
  68 #  ifdef _POSIX_VERSION
  69 #   define POSIX
  70 #  endif
  71 # endif
  72 #endif
  73
  74 #if !defined _AMIGA && !defined VMS && !defined WINDOWS32
  75 # include <pwd.h>
  76 #endif
  77
  78 #if !defined __GNU_LIBRARY__ && !defined STDC_HEADERS
  79 extern int errno;
  80 #endif
  81 #ifndef __set_errno
  82 # define __set_errno(val) errno = (val)
  83 #endif
  84
  85 #ifndef NULL
  86 # define NULL   0
  87 #endif
  88
  89
  90 #if defined HAVE_DIRENT_H || defined __GNU_LIBRARY__
  91 # include <dirent.h>
  92 # define NAMLEN(dirent) strlen((dirent)->d_name)
  93 #else
  94 # define dirent direct
  95 # define NAMLEN(dirent) (dirent)->d_namlen
  96 # ifdef HAVE_SYS_NDIR_H
  97 #  include <sys/ndir.h>
  98 # endif
  99 # ifdef HAVE_SYS_DIR_H
 100 #  include <sys/dir.h>
 101 # endif
 102 # ifdef HAVE_NDIR_H
 103 #  include <ndir.h>
 104 # endif
 105 # ifdef HAVE_VMSDIR_H
 106 #  include "vmsdir.h"
 107 # endif /* HAVE_VMSDIR_H */
 108 #endif
 109
 110
 111 /* In GNU systems, <dirent.h> defines this macro for us.  */
 112 #ifdef _D_NAMLEN
 113 # undef NAMLEN
 114 # define NAMLEN(d) _D_NAMLEN(d)
 115 #endif
 116
 117 /* When used in the GNU libc the symbol _DIRENT_HAVE_D_TYPE is available
 118    if the `d_type' member for `struct dirent' is available.  */
 119 #ifdef _DIRENT_HAVE_D_TYPE
 120 # define HAVE_D_TYPE    1
 121 #endif
 122
 123
 124 #if (defined POSIX || defined WINDOWS32) && !defined __GNU_LIBRARY__
 125 /* Posix does not require that the d_ino field be present, and some
 126    systems do not provide it. */
 127 # define REAL_DIR_ENTRY(dp) 1
 128 #else
 129 # define REAL_DIR_ENTRY(dp) (dp->d_ino != 0)
 130 #endif /* POSIX */
 131
 132 #if defined STDC_HEADERS || defined __GNU_LIBRARY__
 133 # include <stdlib.h>
 134 # include <string.h>
 135 # define        ANSI_STRING
 136 #else   /* No standard headers.  */
 137
 138 extern char *getenv ();
 139
 140 # ifdef HAVE_STRING_H
 141 #  include <string.h>
 142 #  define ANSI_STRING
 143 # else
 144 #  include <strings.h>
 145 # endif
 146 # ifdef HAVE_MEMORY_H
 147 #  include <memory.h>
 148 # endif
 149
 150 extern char *malloc (), *realloc ();
 151 extern void free ();
 152
 153 extern void qsort ();
 154 extern void abort (), exit ();
 155
 156 #endif  /* Standard headers.  */
 157
 158 #ifndef ANSI_STRING
 159
 160 # ifndef bzero
 161 extern void bzero ();
 162 # endif
 163 # ifndef bcopy
 164 extern void bcopy ();
 165 # endif
 166
 167 # define memcpy(d, s, n)        bcopy ((s), (d), (n))
 168 # define strrchr        rindex
 169 /* memset is only used for zero here, but let's be paranoid.  */
 170 # define memset(s, better_be_zero, n) \
 171   ((void) ((better_be_zero) == 0 ? (bzero((s), (n)), 0) : (abort(), 0)))
 172 #endif  /* Not ANSI_STRING.  */
 173
 174 #if !defined HAVE_STRCOLL && !defined _LIBC
 175 # define strcoll        strcmp
 176 #endif
 177
 178 #if !defined HAVE_MEMPCPY && __GLIBC__ - 0 == 2 && __GLIBC_MINOR__ >= 1
 179 # define HAVE_MEMPCPY   1
 180 # define mempcpy(Dest, Src, Len) __mempcpy (Dest, Src, Len)
 181 #endif
 182
 183
 184 #ifndef __GNU_LIBRARY__
 185 # ifdef __GNUC__
 186 __inline
 187 # endif
 188 # ifndef __SASC
 189 #  ifdef WINDOWS32
 190 static void *
 191 #  else
 192 static char *
 193 # endif
 194 my_realloc (p, n)
 195      char *p;
 196      unsigned int n;
 197 {
 198   /* These casts are the for sake of the broken Ultrix compiler,
 199      which warns of illegal pointer combinations otherwise.  */
 200   if (p == NULL)
 201     return (char *) malloc (n);
 202   return (char *) realloc (p, n);
 203 }
 204 # define        realloc my_realloc
 205 # endif /* __SASC */
 206 #endif /* __GNU_LIBRARY__ */
 207
 208
 209 #if !defined __alloca && !defined __GNU_LIBRARY__
 210
 211 # ifdef __GNUC__
 212 #  undef alloca
 213 #  define alloca(n)     __builtin_alloca (n)
 214 # else  /* Not GCC.  */
 215 #  ifdef HAVE_ALLOCA_H
 216 #   include <alloca.h>
 217 #  else /* Not HAVE_ALLOCA_H.  */
 218 #   ifndef _AIX
 219 #    ifdef WINDOWS32
 220 #     include <malloc.h>
 221 #    else
 222 extern char *alloca ();
 223 #    endif /* WINDOWS32 */
 224 #   endif /* Not _AIX.  */
 225 #  endif /* sparc or HAVE_ALLOCA_H.  */
 226 # endif /* GCC.  */
 227
 228 # define __alloca       alloca
 229
 230 #endif
 231
 232 #ifndef __GNU_LIBRARY__
 233 # define __stat stat
 234 # ifdef STAT_MACROS_BROKEN
 235 #  undef S_ISDIR
 236 # endif
 237 # ifndef S_ISDIR
 238 #  define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR)
 239 # endif
 240 #endif
 241
 242 #if !(defined STDC_HEADERS || defined __GNU_LIBRARY__)
 243 # undef size_t
 244 # define size_t unsigned int
 245 #endif
 246
 247 /* Some system header files erroneously define these.
 248    We want our own definitions from <fnmatch.h> to take precedence.  */
 249 #undef  FNM_PATHNAME
 250 #undef  FNM_NOESCAPE
 251 #undef  FNM_PERIOD
 252 #include <fnmatch.h>
 253
 254 /* Some system header files erroneously define these.
 255    We want our own definitions from <glob.h> to take precedence.  */
 256 #undef  GLOB_ERR
 257 #undef  GLOB_MARK
 258 #undef  GLOB_NOSORT
 259 #undef  GLOB_DOOFFS
 260 #undef  GLOB_NOCHECK
 261 #undef  GLOB_APPEND
 262 #undef  GLOB_NOESCAPE
 263 #undef  GLOB_PERIOD
 264 #include <glob.h>
 265 \f
 266 static
 267 #if __GNUC__ - 0 >= 2
 268 inline
 269 #endif
 270 const char *next_brace_sub __P ((const char *begin));
 271 static int glob_in_dir __P ((const char *pattern, const char *directory,
 272                              int flags,
 273                              int (*errfunc) __P ((const char *, int)),
 274                              glob_t *pglob));
 275 static int prefix_array __P ((const char *prefix, char **array, size_t n));
 276 static int collated_compare __P ((const __ptr_t, const __ptr_t));
 277
 278
 279 /* Find the end of the sub-pattern in a brace expression.  We define
 280    this as an inline function if the compiler permits.  */
 281 static
 282 #if __GNUC__ - 0 >= 2
 283 inline
 284 #endif
 285 const char *
 286 next_brace_sub (begin)
 287      const char *begin;
 288 {
 289   unsigned int depth = 0;
 290   const char *cp = begin;
 291
 292   while (1)
 293     {
 294       if (depth == 0)
 295         {
 296           if (*cp != ',' && *cp != '}' && *cp != '\0')
 297             {
 298               if (*cp == '{')
 299                 ++depth;
 300               ++cp;
 301               continue;
 302             }
 303         }
 304       else
 305         {
 306           while (*cp != '\0' && (*cp != '}' || depth > 0))
 307             {
 308               if (*cp == '}')
 309                 --depth;
 310               ++cp;
 311             }
 312           if (*cp == '\0')
 313             /* An incorrectly terminated brace expression.  */
 314             return NULL;
 315
 316           continue;
 317         }
 318       break;
 319     }
 320
 321   return cp;
 322 }
 323
 324 /* Do glob searching for PATTERN, placing results in PGLOB.
 325    The bits defined above may be set in FLAGS.
 326    If a directory cannot be opened or read and ERRFUNC is not nil,
 327    it is called with the pathname that caused the error, and the
 328    `errno' value from the failing call; if it returns non-zero
 329    `glob' returns GLOB_ABORTED; if it returns zero, the error is ignored.
 330    If memory cannot be allocated for PGLOB, GLOB_NOSPACE is returned.
 331    Otherwise, `glob' returns zero.  */
 332 int
 333 glob (pattern, flags, errfunc, pglob)
 334      const char *pattern;
 335      int flags;
 336      int (*errfunc) __P ((const char *, int));
 337      glob_t *pglob;
 338 {
 339   const char *filename;
 340   char *dirname;
 341   size_t dirlen;
 342   int status;
 343   int oldcount;
 344
 345   if (pattern == NULL || pglob == NULL || (flags & ~__GLOB_FLAGS) != 0)
 346     {
 347       __set_errno (EINVAL);
 348       return -1;
 349     }
 350
 351   if (flags & GLOB_BRACE)
 352     {
 353       const char *begin = strchr (pattern, '{');
 354       if (begin != NULL)
 355         {
 356           /* Allocate working buffer large enough for our work.  Note that
 357             we have at least an opening and closing brace.  */
 358           int firstc;
 359           char *alt_start;
 360           const char *p;
 361           const char *next;
 362           const char *rest;
 363           size_t rest_len;
 364 #ifdef __GNUC__
 365           char onealt[strlen (pattern) - 1];
 366 #else
 367           char *onealt = (char *) malloc (strlen (pattern) - 1);
 368           if (onealt == NULL)
 369             {
 370               if (!(flags & GLOB_APPEND))
 371                 globfree (pglob);
 372               return GLOB_NOSPACE;
 373             }
 374 #endif
 375
 376           /* We know the prefix for all sub-patterns.  */
 377 #ifdef HAVE_MEMPCPY
 378           alt_start = mempcpy (onealt, pattern, begin - pattern);
 379 #else
 380           memcpy (onealt, pattern, begin - pattern);
 381           alt_start = &onealt[begin - pattern];
 382 #endif
 383
 384           /* Find the first sub-pattern and at the same time find the
 385              rest after the closing brace.  */
 386           next = next_brace_sub (begin + 1);
 387           if (next == NULL)
 388             {
 389               /* It is an illegal expression.  */
 390 #ifndef __GNUC__
 391               free (onealt);
 392 #endif
 393               return glob (pattern, flags & ~GLOB_BRACE, errfunc, pglob);
 394             }
 395
 396           /* Now find the end of the whole brace expression.  */
 397           rest = next;
 398           while (*rest != '}')
 399             {
 400               rest = next_brace_sub (rest + 1);
 401               if (rest == NULL)
 402                 {
 403                   /* It is an illegal expression.  */
 404 #ifndef __GNUC__
 405                   free (onealt);
 406 #endif
 407                   return glob (pattern, flags & ~GLOB_BRACE, errfunc, pglob);
 408                 }
 409             }
 410           /* Please note that we now can be sure the brace expression
 411              is well-formed.  */
 412           rest_len = strlen (++rest) + 1;
 413
 414           /* We have a brace expression.  BEGIN points to the opening {,
 415              NEXT points past the terminator of the first element, and END
 416              points past the final }.  We will accumulate result names from
 417              recursive runs for each brace alternative in the buffer using
 418              GLOB_APPEND.  */
 419
 420           if (!(flags & GLOB_APPEND))
 421             {
 422               /* This call is to set a new vector, so clear out the
 423                  vector so we can append to it.  */
 424               pglob->gl_pathc = 0;
 425               pglob->gl_pathv = NULL;
 426             }
 427           firstc = pglob->gl_pathc;
 428
 429           p = begin + 1;
 430           while (1)
 431             {
 432               int result;
 433
 434               /* Construct the new glob expression.  */
 435 #ifdef HAVE_MEMPCPY
 436               mempcpy (mempcpy (alt_start, p, next - p), rest, rest_len);
 437 #else
 438               memcpy (alt_start, p, next - p);
 439               memcpy (&alt_start[next - p], rest, rest_len);
 440 #endif
 441
 442               result = glob (onealt,
 443                              ((flags & ~(GLOB_NOCHECK|GLOB_NOMAGIC))
 444                               | GLOB_APPEND), errfunc, pglob);
 445
 446               /* If we got an error, return it.  */
 447               if (result && result != GLOB_NOMATCH)
 448                 {
 449 #ifndef __GNUC__
 450                   free (onealt);
 451 #endif
 452                   if (!(flags & GLOB_APPEND))
 453                     globfree (pglob);
 454                   return result;
 455                 }
 456
 457               if (*next == '}')
 458                 /* We saw the last entry.  */
 459                 break;
 460
 461               p = next + 1;
 462               next = next_brace_sub (p);
 463               assert (next != NULL);
 464             }
 465
 466 #ifndef __GNUC__
 467           free (onealt);
 468 #endif
 469
 470           if (pglob->gl_pathc != firstc)
 471             /* We found some entries.  */
 472             return 0;
 473           else if (!(flags & (GLOB_NOCHECK|GLOB_NOMAGIC)))
 474             return GLOB_NOMATCH;
 475         }
 476     }
 477
 478   /* Find the filename.  */
 479   filename = strrchr (pattern, '/');
 480   if (filename == NULL)
 481     {
 482       filename = pattern;
 483 #ifdef _AMIGA
 484       dirname = (char *) "";
 485 #else
 486       dirname = (char *) ".";
 487 #endif
 488       dirlen = 0;
 489     }
 490   else if (filename == pattern)
 491     {
 492       /* "/pattern".  */
 493       dirname = (char *) "/";
 494       dirlen = 1;
 495       ++filename;
 496     }
 497   else
 498     {
 499       dirlen = filename - pattern;
 500       dirname = (char *) __alloca (dirlen + 1);
 501 #ifdef HAVE_MEMPCPY
 502       *((char *) mempcpy (dirname, pattern, dirlen)) = '\0';
 503 #else
 504       memcpy (dirname, pattern, dirlen);
 505       dirname[dirlen] = '\0';
 506 #endif
 507       ++filename;
 508     }
 509
 510   if (filename[0] == '\0' && dirlen > 1)
 511     /* "pattern/".  Expand "pattern", appending slashes.  */
 512     {
 513       int val = glob (dirname, flags | GLOB_MARK, errfunc, pglob);
 514       if (val == 0)
 515         pglob->gl_flags = (pglob->gl_flags & ~GLOB_MARK) | (flags & GLOB_MARK);
 516       return val;
 517     }
 518
 519   if (!(flags & GLOB_APPEND))
 520     {
 521       pglob->gl_pathc = 0;
 522       pglob->gl_pathv = NULL;
 523     }
 524
 525   oldcount = pglob->gl_pathc;
 526
 527 #ifndef VMS
 528   if ((flags & GLOB_TILDE) && dirname[0] == '~')
 529     {
 530       if (dirname[1] == '\0' || dirname[1] == '/')
 531         {
 532           /* Look up home directory.  */
 533           char *home_dir = getenv ("HOME");
 534 # ifdef _AMIGA
 535           if (home_dir == NULL || home_dir[0] == '\0')
 536             home_dir = "SYS:";
 537 # else
 538 #  ifdef WINDOWS32
 539           if (home_dir == NULL || home_dir[0] == '\0')
 540             home_dir = "c:/users/default"; /* poor default */
 541 #  else
 542           if (home_dir == NULL || home_dir[0] == '\0')
 543             {
 544               int success;
 545 #   if defined HAVE_GETLOGIN_R || defined _LIBC
 546               extern int getlogin_r __P ((char *, size_t));
 547               size_t buflen = sysconf (_SC_LOGIN_NAME_MAX) + 1;
 548               char *name;
 549
 550               if (buflen == 0)
 551                 /* `sysconf' does not support _SC_LOGIN_NAME_MAX.  Try
 552                    a moderate value.  */
 553                 buflen = 16;
 554               name = (char *) __alloca (buflen);
 555
 556               success = getlogin_r (name, buflen) >= 0;
 557 #   else
 558               extern char *getlogin __P ((void));
 559               char *name;
 560
 561               success = (name = getlogin ()) != NULL;
 562 #   endif
 563               if (success)
 564                 {
 565 #   if defined HAVE_GETPWNAM_R || defined _LIBC
 566                   size_t pwbuflen = sysconf (_SC_GETPW_R_SIZE_MAX);
 567                   char *pwtmpbuf;
 568                   struct passwd pwbuf, *p;
 569
 570                   pwtmpbuf = (char *) __alloca (pwbuflen);
 571
 572                   success = (__getpwnam_r (name, &pwbuf, pwtmpbuf,
 573                                            pwbuflen, &p) >= 0);
 574 #   else
 575                   struct passwd *p = getpwnam (name);
 576                   success = p != NULL;
 577 #   endif
 578                   if (success)
 579                     home_dir = p->pw_dir;
 580                 }
 581             }
 582           if (home_dir == NULL || home_dir[0] == '\0')
 583             home_dir = (char *) "~"; /* No luck.  */
 584 #  endif /* WINDOWS32 */
 585 # endif
 586           /* Now construct the full directory.  */
 587           if (dirname[1] == '\0')
 588             dirname = home_dir;
 589           else
 590             {
 591               char *newp;
 592               size_t home_len = strlen (home_dir);
 593               newp = (char *) __alloca (home_len + dirlen);
 594 # ifdef HAVE_MEMPCPY
 595               mempcpy (mempcpy (newp, home_dir, home_len),
 596                        &dirname[1], dirlen);
 597 # else
 598               memcpy (newp, home_dir, home_len);
 599               memcpy (&newp[home_len], &dirname[1], dirlen);
 600 # endif
 601               dirname = newp;
 602             }
 603         }
 604 # if !defined _AMIGA && !defined WINDOWS32
 605       else
 606         {
 607           char *end_name = strchr (dirname, '/');
 608           char *user_name;
 609           char *home_dir;
 610
 611           if (end_name == NULL)
 612             user_name = dirname + 1;
 613           else
 614             {
 615               user_name = (char *) __alloca (end_name - dirname);
 616 # ifdef HAVE_MEMPCPY
 617               *((char *) mempcpy (user_name, dirname + 1, end_name - dirname))
 618                 = '\0';
 619 # else
 620               memcpy (user_name, dirname + 1, end_name - dirname);
 621               user_name[end_name - dirname - 1] = '\0';
 622 # endif
 623             }
 624
 625           /* Look up specific user's home directory.  */
 626           {
 627 #  if defined HAVE_GETPWNAM_R || defined _LIBC
 628             size_t buflen = sysconf (_SC_GETPW_R_SIZE_MAX);
 629             char *pwtmpbuf = (char *) __alloca (buflen);
 630             struct passwd pwbuf, *p;
 631             if (__getpwnam_r (user_name, &pwbuf, pwtmpbuf, buflen, &p) >= 0)
 632               home_dir = p->pw_dir;
 633             else
 634               home_dir = NULL;
 635 #  else
 636             struct passwd *p = getpwnam (user_name);
 637             if (p != NULL)
 638               home_dir = p->pw_dir;
 639             else
 640               home_dir = NULL;
 641 #  endif
 642           }
 643           /* If we found a home directory use this.  */
 644           if (home_dir != NULL)
 645             {
 646               char *newp;
 647               size_t home_len = strlen (home_dir);
 648               size_t rest_len = end_name == NULL ? 0 : strlen (end_name);
 649               newp = (char *) __alloca (home_len + rest_len + 1);
 650 #  ifdef HAVE_MEMPCPY
 651               *((char *) mempcpy (mempcpy (newp, home_dir, home_len),
 652                                   end_name, rest_len)) = '\0';
 653 #  else
 654               memcpy (newp, home_dir, home_len);
 655               memcpy (&newp[home_len], end_name, rest_len);
 656               newp[home_len + rest_len] = '\0';
 657 #  endif
 658               dirname = newp;
 659             }
 660         }
 661 # endif /* Not Amiga && not WINDOWS32.  */
 662     }
 663 #endif  /* Not VMS.  */
 664
 665   if (__glob_pattern_p (dirname, !(flags & GLOB_NOESCAPE)))
 666     {
 667       /* The directory name contains metacharacters, so we
 668          have to glob for the directory, and then glob for
 669          the pattern in each directory found.  */
 670       glob_t dirs;
 671       register int i;
 672
 673       status = glob (dirname,
 674                      ((flags & (GLOB_ERR | GLOB_NOCHECK | GLOB_NOESCAPE))
 675                       | GLOB_NOSORT | GLOB_ONLYDIR),
 676                      errfunc, &dirs);
 677       if (status != 0)
 678         return status;
 679
 680       /* We have successfully globbed the preceding directory name.
 681          For each name we found, call glob_in_dir on it and FILENAME,
 682          appending the results to PGLOB.  */
 683       for (i = 0; i < dirs.gl_pathc; ++i)
 684         {
 685           int oldcount;
 686
 687 #ifdef  SHELL
 688           {
 689             /* Make globbing interruptible in the bash shell. */
 690             extern int interrupt_state;
 691
 692             if (interrupt_state)
 693               {
 694                 globfree (&dirs);
 695                 globfree (&files);
 696                 return GLOB_ABORTED;
 697               }
 698           }
 699 #endif /* SHELL.  */
 700
 701           oldcount = pglob->gl_pathc;
 702           status = glob_in_dir (filename, dirs.gl_pathv[i],
 703                                 ((flags | GLOB_APPEND)
 704                                  & ~(GLOB_NOCHECK | GLOB_ERR)),
 705                                 errfunc, pglob);
 706           if (status == GLOB_NOMATCH)
 707             /* No matches in this directory.  Try the next.  */
 708             continue;
 709
 710           if (status != 0)
 711             {
 712               globfree (&dirs);
 713               globfree (pglob);
 714               return status;
 715             }
 716
 717           /* Stick the directory on the front of each name.  */
 718           if (prefix_array (dirs.gl_pathv[i],
 719                             &pglob->gl_pathv[oldcount],
 720                             pglob->gl_pathc - oldcount))
 721             {
 722               globfree (&dirs);
 723               globfree (pglob);
 724               return GLOB_NOSPACE;
 725             }
 726         }
 727
 728       flags |= GLOB_MAGCHAR;
 729
 730       if (pglob->gl_pathc == oldcount)
 731         /* No matches.  */
 732         if (flags & GLOB_NOCHECK)
 733           {
 734             size_t len = strlen (pattern) + 1;
 735             char *patcopy = (char *) malloc (len);
 736             if (patcopy == NULL)
 737               return GLOB_NOSPACE;
 738             memcpy (patcopy, pattern, len);
 739
 740             pglob->gl_pathv
 741               = (char **) realloc (pglob->gl_pathv,
 742                                    (pglob->gl_pathc +
 743                                     ((flags & GLOB_DOOFFS) ?
 744                                      pglob->gl_offs : 0) +
 745                                     1 + 1) *
 746                                    sizeof (char *));
 747             if (pglob->gl_pathv == NULL)
 748               {
 749                 free (patcopy);
 750                 return GLOB_NOSPACE;
 751               }
 752
 753             if (flags & GLOB_DOOFFS)
 754               while (pglob->gl_pathc < pglob->gl_offs)
 755                 pglob->gl_pathv[pglob->gl_pathc++] = NULL;
 756
 757             pglob->gl_pathv[pglob->gl_pathc++] = patcopy;
 758             pglob->gl_pathv[pglob->gl_pathc] = NULL;
 759             pglob->gl_flags = flags;
 760           }
 761         else
 762           return GLOB_NOMATCH;
 763     }
 764   else
 765     {
 766       status = glob_in_dir (filename, dirname, flags, errfunc, pglob);
 767       if (status != 0)
 768         return status;
 769
 770       if (dirlen > 0)
 771         {
 772           /* Stick the directory on the front of each name.  */
 773           if (prefix_array (dirname,
 774                             &pglob->gl_pathv[oldcount],
 775                             pglob->gl_pathc - oldcount))
 776             {
 777               globfree (pglob);
 778               return GLOB_NOSPACE;
 779             }
 780         }
 781     }
 782
 783   if (flags & GLOB_MARK)
 784     {
 785       /* Append slashes to directory names.  */
 786       int i;
 787       struct stat st;
 788       for (i = oldcount; i < pglob->gl_pathc; ++i)
 789         if (((flags & GLOB_ALTDIRFUNC) ?
 790              (*pglob->gl_stat) (pglob->gl_pathv[i], &st) :
 791              __stat (pglob->gl_pathv[i], &st)) == 0 &&
 792             S_ISDIR (st.st_mode))
 793           {
 794             size_t len = strlen (pglob->gl_pathv[i]) + 2;
 795             char *new = realloc (pglob->gl_pathv[i], len);
 796             if (new == NULL)
 797               {
 798                 globfree (pglob);
 799                 return GLOB_NOSPACE;
 800               }
 801             strcpy (&new[len - 2], "/");
 802             pglob->gl_pathv[i] = new;
 803           }
 804     }
 805
 806   if (!(flags & GLOB_NOSORT))
 807     /* Sort the vector.  */
 808     qsort ((__ptr_t) &pglob->gl_pathv[oldcount],
 809            pglob->gl_pathc - oldcount,
 810            sizeof (char *), collated_compare);
 811
 812   return 0;
 813 }
 814
 815
 816 /* Free storage allocated in PGLOB by a previous `glob' call.  */
 817 void
 818 globfree (pglob)
 819      register glob_t *pglob;
 820 {
 821   if (pglob->gl_pathv != NULL)
 822     {
 823       register int i;
 824       for (i = 0; i < pglob->gl_pathc; ++i)
 825         if (pglob->gl_pathv[i] != NULL)
 826           free ((__ptr_t) pglob->gl_pathv[i]);
 827       free ((__ptr_t) pglob->gl_pathv);
 828     }
 829 }
 830
 831
 832 /* Do a collated comparison of A and B.  */
 833 static int
 834 collated_compare (a, b)
 835      const __ptr_t a;
 836      const __ptr_t b;
 837 {
 838   const char *const s1 = *(const char *const * const) a;
 839   const char *const s2 = *(const char *const * const) b;
 840
 841   if (s1 == s2)
 842     return 0;
 843   if (s1 == NULL)
 844     return 1;
 845   if (s2 == NULL)
 846     return -1;
 847   return strcoll (s1, s2);
 848 }
 849
 850
 851 /* Prepend DIRNAME to each of N members of ARRAY, replacing ARRAY's
 852    elements in place.  Return nonzero if out of memory, zero if successful.
 853    A slash is inserted between DIRNAME and each elt of ARRAY,
 854    unless DIRNAME is just "/".  Each old element of ARRAY is freed.  */
 855 static int
 856 prefix_array (dirname, array, n)
 857      const char *dirname;
 858      char **array;
 859      size_t n;
 860 {
 861   register size_t i;
 862   size_t dirlen = strlen (dirname);
 863
 864   if (dirlen == 1 && dirname[0] == '/')
 865     /* DIRNAME is just "/", so normal prepending would get us "//foo".
 866        We want "/foo" instead, so don't prepend any chars from DIRNAME.  */
 867     dirlen = 0;
 868
 869   for (i = 0; i < n; ++i)
 870     {
 871       size_t eltlen = strlen (array[i]) + 1;
 872       char *new = (char *) malloc (dirlen + 1 + eltlen);
 873       if (new == NULL)
 874         {
 875           while (i > 0)
 876             free ((__ptr_t) array[--i]);
 877           return 1;
 878         }
 879
 880 #ifdef HAVE_MEMPCPY
 881       {
 882         char *endp = (char *) mempcpy (new, dirname, dirlen);
 883         *endp++ = '/';
 884         mempcpy (endp, array[i], eltlen);
 885       }
 886 #else
 887       memcpy (new, dirname, dirlen);
 888       new[dirlen] = '/';
 889       memcpy (&new[dirlen + 1], array[i], eltlen);
 890 #endif
 891       free ((__ptr_t) array[i]);
 892       array[i] = new;
 893     }
 894
 895   return 0;
 896 }
 897
 898
 899 /* Return nonzero if PATTERN contains any metacharacters.
 900    Metacharacters can be quoted with backslashes if QUOTE is nonzero.  */
 901 int
 902 __glob_pattern_p (pattern, quote)
 903      const char *pattern;
 904      int quote;
 905 {
 906   register const char *p;
 907   int open = 0;
 908
 909   for (p = pattern; *p != '\0'; ++p)
 910     switch (*p)
 911       {
 912       case '?':
 913       case '*':
 914         return 1;
 915
 916       case '\\':
 917         if (quote && p[1] != '\0')
 918           ++p;
 919         break;
 920
 921       case '[':
 922         open = 1;
 923         break;
 924
 925       case ']':
 926         if (open)
 927           return 1;
 928         break;
 929       }
 930
 931   return 0;
 932 }
 933 #ifdef _LIBC
 934 weak_alias (__glob_pattern_p, glob_pattern_p)
 935 #endif
 936
 937
 938 /* Like `glob', but PATTERN is a final pathname component,
 939    and matches are searched for in DIRECTORY.
 940    The GLOB_NOSORT bit in FLAGS is ignored.  No sorting is ever done.
 941    The GLOB_APPEND flag is assumed to be set (always appends).  */
 942 static int
 943 glob_in_dir (pattern, directory, flags, errfunc, pglob)
 944      const char *pattern;
 945      const char *directory;
 946      int flags;
 947      int (*errfunc) __P ((const char *, int));
 948      glob_t *pglob;
 949 {
 950   __ptr_t stream;
 951
 952   struct globlink
 953     {
 954       struct globlink *next;
 955       char *name;
 956     };
 957   struct globlink *names = NULL;
 958   size_t nfound;
 959   int meta;
 960   int save;
 961
 962   stream = ((flags & GLOB_ALTDIRFUNC) ?
 963             (*pglob->gl_opendir) (directory) :
 964             (__ptr_t) opendir (directory));
 965   if (stream == NULL)
 966     {
 967       if ((errfunc != NULL && (*errfunc) (directory, errno)) ||
 968           (flags & GLOB_ERR))
 969         return GLOB_ABORTED;
 970       nfound = 0;
 971       meta = 0;
 972     }
 973   else if (pattern[0] == '\0')
 974     {
 975       /* This is a special case for matching directories like in
 976          "*a/".  */
 977       names = (struct globlink *) __alloca (sizeof (struct globlink));
 978       names->name = (char *) malloc (1);
 979       if (names->name == NULL)
 980         goto memory_error;
 981       names->name[0] = '\0';
 982       names->next = NULL;
 983       nfound = 1;
 984       meta = 0;
 985     }
 986   else
 987     {
 988       nfound = 0;
 989       meta = __glob_pattern_p (pattern, !(flags & GLOB_NOESCAPE));
 990       if(meta)
 991         flags |= GLOB_MAGCHAR;
 992
 993       while (1)
 994         {
 995           const char *name;
 996           size_t len;
 997           struct dirent *d = ((flags & GLOB_ALTDIRFUNC) ?
 998                               (*pglob->gl_readdir) (stream) :
 999                               readdir ((DIR *) stream));
1000           if (d == NULL)
1001             break;
1002           if (! REAL_DIR_ENTRY (d))
1003             continue;
1004
1005 #ifdef HAVE_D_TYPE
1006           /* If we shall match only directories use the information
1007              provided by the dirent call if possible.  */
1008           if ((flags & GLOB_ONLYDIR)
1009               && d->d_type != DT_UNKNOWN && d->d_type != DT_DIR)
1010             continue;
1011 #endif
1012
1013           name = d->d_name;
1014
1015           if ((!meta && strcmp (pattern, name) == 0)
1016               || fnmatch (pattern, name,
1017                           (!(flags & GLOB_PERIOD) ? FNM_PERIOD : 0) |
1018                           ((flags & GLOB_NOESCAPE) ? FNM_NOESCAPE : 0)
1019 #ifdef _AMIGA
1020                           | FNM_CASEFOLD
1021 #endif
1022                          ) == 0)
1023             {
1024               struct globlink *new
1025                 = (struct globlink *) __alloca (sizeof (struct globlink));
1026               len = NAMLEN (d);
1027               new->name = (char *) malloc (len + 1);
1028               if (new->name == NULL)
1029                 goto memory_error;
1030 #ifdef HAVE_MEMPCPY
1031               *((char *) mempcpy ((__ptr_t) new->name, name, len)) = '\0';
1032 #else
1033               memcpy ((__ptr_t) new->name, name, len);
1034               new->name[len] = '\0';
1035 #endif
1036               new->next = names;
1037               names = new;
1038               ++nfound;
1039               if (!meta)
1040                 break;
1041             }
1042         }
1043     }
1044
1045   if (nfound == 0 && (flags & GLOB_NOMAGIC) && !meta)
1046     flags |= GLOB_NOCHECK;
1047
1048   if (nfound == 0 && (flags & GLOB_NOCHECK))
1049     {
1050       size_t len = strlen (pattern);
1051       nfound = 1;
1052       names = (struct globlink *) __alloca (sizeof (struct globlink));
1053       names->next = NULL;
1054       names->name = (char *) malloc (len + 1);
1055       if (names->name == NULL)
1056         goto memory_error;
1057 #ifdef HAVE_MEMPCPY
1058       *((char *) mempcpy (names->name, pattern, len)) = '\0';
1059 #else
1060       memcpy (names->name, pattern, len);
1061       names->name[len] = '\0';
1062 #endif
1063     }
1064
1065   if (nfound != 0)
1066     {
1067       pglob->gl_pathv
1068         = (char **) realloc (pglob->gl_pathv,
1069                              (pglob->gl_pathc +
1070                               ((flags & GLOB_DOOFFS) ? pglob->gl_offs : 0) +
1071                               nfound + 1) *
1072                              sizeof (char *));
1073       if (pglob->gl_pathv == NULL)
1074         goto memory_error;
1075
1076       if (flags & GLOB_DOOFFS)
1077         while (pglob->gl_pathc < pglob->gl_offs)
1078           pglob->gl_pathv[pglob->gl_pathc++] = NULL;
1079
1080       for (; names != NULL; names = names->next)
1081         pglob->gl_pathv[pglob->gl_pathc++] = names->name;
1082       pglob->gl_pathv[pglob->gl_pathc] = NULL;
1083
1084       pglob->gl_flags = flags;
1085     }
1086
1087   save = errno;
1088   if (flags & GLOB_ALTDIRFUNC)
1089     (*pglob->gl_closedir) (stream);
1090   else
1091     closedir ((DIR *) stream);
1092   __set_errno (save);
1093
1094   return nfound == 0 ? GLOB_NOMATCH : 0;
1095
1096  memory_error:
1097   {
1098     int save = errno;
1099     if (flags & GLOB_ALTDIRFUNC)
1100       (*pglob->gl_closedir) (stream);
1101     else
1102       closedir ((DIR *) stream);
1103     __set_errno (save);
1104   }
1105   while (names != NULL)
1106     {
1107       if (names->name != NULL)
1108         free ((__ptr_t) names->name);
1109       names = names->next;
1110     }
1111   return GLOB_NOSPACE;
1112 }
1113
1114 #endif  /* Not ELIDE_CODE.  */