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