posix/glob.c

   1 /* Copyright (C) 1991, 1992, 1993, 1994, 1995 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
  15 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
  16 Cambridge, MA 02139, 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 #include <errno.h>
  28 #include <sys/types.h>
  29
  30
  31 /* Comment out all this code if we are using the GNU C Library, and are not
  32    actually compiling the library itself.  This code is part of the GNU C
  33    Library, but also included in many other GNU distributions.  Compiling
  34    and linking in this code is a waste when using the GNU C library
  35    (especially if it is a shared library).  Rather than having every GNU
  36    program understand `configure --with-gnu-libc' and omit the object files,
  37    it is simpler to just do this in the source for each such file.  */
  38
  39 #if defined (_LIBC) || !defined (__GNU_LIBRARY__)
  40
  41
  42 #ifdef  STDC_HEADERS
  43 #include <stddef.h>
  44 #endif
  45
  46 #ifdef  HAVE_UNISTD_H
  47 #include <unistd.h>
  48 #ifndef POSIX
  49 #ifdef  _POSIX_VERSION
  50 #define POSIX
  51 #endif
  52 #endif
  53 #endif
  54
  55 #if !defined(__GNU_LIBRARY__) && !defined(STDC_HEADERS)
  56 extern int errno;
  57 #endif
  58
  59 #ifndef NULL
  60 #define NULL    0
  61 #endif
  62
  63
  64 #if     defined (POSIX) || defined (HAVE_DIRENT_H) || defined (__GNU_LIBRARY__)
  65 #include <dirent.h>
  66 #ifndef __GNU_LIBRARY__
  67 #define D_NAMLEN(d) strlen((d)->d_name)
  68 #else   /* GNU C library.  */
  69 #define D_NAMLEN(d) ((d)->d_namlen)
  70 #endif  /* Not GNU C library.  */
  71 #else   /* Not POSIX or HAVE_DIRENT_H.  */
  72 #define direct dirent
  73 #define D_NAMLEN(d) ((d)->d_namlen)
  74 #ifdef  HAVE_SYS_NDIR_H
  75 #include <sys/ndir.h>
  76 #endif  /* HAVE_SYS_NDIR_H */
  77 #ifdef  HAVE_SYS_DIR_H
  78 #include <sys/dir.h>
  79 #endif  /* HAVE_SYS_DIR_H */
  80 #ifdef HAVE_NDIR_H
  81 #include <ndir.h>
  82 #endif  /* HAVE_NDIR_H */
  83 #endif  /* POSIX or HAVE_DIRENT_H or __GNU_LIBRARY__.  */
  84
  85 #if defined (POSIX) && !defined (__GNU_LIBRARY__)
  86 /* Posix does not require that the d_ino field be present, and some
  87    systems do not provide it. */
  88 #define REAL_DIR_ENTRY(dp) 1
  89 #else
  90 #define REAL_DIR_ENTRY(dp) (dp->d_ino != 0)
  91 #endif /* POSIX */
  92
  93 #if     (defined (STDC_HEADERS) || defined (__GNU_LIBRARY__))
  94 #include <stdlib.h>
  95 #include <string.h>
  96 #define ANSI_STRING
  97 #else   /* No standard headers.  */
  98
  99 #ifdef HAVE_STRING_H
 100 #include <string.h>
 101 #define ANSI_STRING
 102 #else
 103 #include <strings.h>
 104 #endif
 105 #ifdef  HAVE_MEMORY_H
 106 #include <memory.h>
 107 #endif
 108
 109 extern char *malloc (), *realloc ();
 110 extern void free ();
 111
 112 extern void qsort ();
 113 extern void abort (), exit ();
 114
 115 #endif  /* Standard headers.  */
 116
 117 #ifndef ANSI_STRING
 118
 119 #ifndef bzero
 120 extern void bzero ();
 121 #endif
 122 #ifndef bcopy
 123 extern void bcopy ();
 124 #endif
 125
 126 #define memcpy(d, s, n) bcopy ((s), (d), (n))
 127 #define strrchr rindex
 128 /* memset is only used for zero here, but let's be paranoid.  */
 129 #define memset(s, better_be_zero, n) \
 130   ((void) ((better_be_zero) == 0 ? (bzero((s), (n)), 0) : (abort(), 0)))
 131 #endif  /* Not ANSI_STRING.  */
 132
 133 #ifndef HAVE_STRCOLL
 134 #define strcoll strcmp
 135 #endif
 136
 137
 138 #ifndef __GNU_LIBRARY__
 139 #ifdef  __GNUC__
 140 __inline
 141 #endif
 142 static char *
 143 my_realloc (p, n)
 144      char *p;
 145      unsigned int n;
 146 {
 147   /* These casts are the for sake of the broken Ultrix compiler,
 148      which warns of illegal pointer combinations otherwise.  */
 149   if (p == NULL)
 150     return (char *) malloc (n);
 151   return (char *) realloc (p, n);
 152 }
 153 #define realloc my_realloc
 154 #endif
 155
 156
 157 #if     !defined(__alloca) && !defined(__GNU_LIBRARY__)
 158
 159 #ifdef  __GNUC__
 160 #undef  alloca
 161 #define alloca(n)       __builtin_alloca (n)
 162 #else   /* Not GCC.  */
 163 #if     defined (sparc) || defined (HAVE_ALLOCA_H)
 164 #include <alloca.h>
 165 #else   /* Not sparc or HAVE_ALLOCA_H.  */
 166 #ifndef _AIX
 167 extern char *alloca ();
 168 #endif  /* Not _AIX.  */
 169 #endif  /* sparc or HAVE_ALLOCA_H.  */
 170 #endif  /* GCC.  */
 171
 172 #define __alloca        alloca
 173
 174 #endif
 175
 176 #ifndef STDC_HEADERS
 177 #undef  size_t
 178 #define size_t  unsigned int
 179 #endif
 180
 181 /* Some system header files erroneously define these.
 182    We want our own definitions from <fnmatch.h> to take precedence.  */
 183 #undef  FNM_PATHNAME
 184 #undef  FNM_NOESCAPE
 185 #undef  FNM_PERIOD
 186 #include <fnmatch.h>
 187
 188 /* Some system header files erroneously define these.
 189    We want our own definitions from <glob.h> to take precedence.  */
 190 #undef  GLOB_ERR
 191 #undef  GLOB_MARK
 192 #undef  GLOB_NOSORT
 193 #undef  GLOB_DOOFFS
 194 #undef  GLOB_NOCHECK
 195 #undef  GLOB_APPEND
 196 #undef  GLOB_NOESCAPE
 197 #undef  GLOB_PERIOD
 198 #include <glob.h>
 199 \f
 200 __ptr_t (*__glob_opendir_hook) __P ((const char *directory));
 201 const char *(*__glob_readdir_hook) __P ((__ptr_t stream));
 202 void (*__glob_closedir_hook) __P ((__ptr_t stream));
 203
 204 static int glob_pattern_p __P ((const char *pattern, int quote));
 205 static int glob_in_dir __P ((const char *pattern, const char *directory,
 206                              int flags,
 207                              int (*errfunc) __P ((const char *, int)),
 208                              glob_t *pglob));
 209 static int prefix_array __P ((const char *prefix, char **array, size_t n));
 210 static int collated_compare __P ((const __ptr_t, const __ptr_t));
 211
 212 /* Do glob searching for PATTERN, placing results in PGLOB.
 213    The bits defined above may be set in FLAGS.
 214    If a directory cannot be opened or read and ERRFUNC is not nil,
 215    it is called with the pathname that caused the error, and the
 216    `errno' value from the failing call; if it returns non-zero
 217    `glob' returns GLOB_ABEND; if it returns zero, the error is ignored.
 218    If memory cannot be allocated for PGLOB, GLOB_NOSPACE is returned.
 219    Otherwise, `glob' returns zero.  */
 220 int
 221 glob (pattern, flags, errfunc, pglob)
 222      const char *pattern;
 223      int flags;
 224      int (*errfunc) __P ((const char *, int));
 225      glob_t *pglob;
 226 {
 227   const char *filename;
 228   char *dirname;
 229   size_t dirlen;
 230   int status;
 231   int oldcount;
 232
 233   if (pattern == NULL || pglob == NULL || (flags & ~__GLOB_FLAGS) != 0)
 234     {
 235       errno = EINVAL;
 236       return -1;
 237     }
 238
 239   /* Find the filename.  */
 240   filename = strrchr (pattern, '/');
 241   if (filename == NULL)
 242     {
 243       filename = pattern;
 244       dirname = (char *) ".";
 245       dirlen = 0;
 246     }
 247   else if (filename == pattern)
 248     {
 249       /* "/pattern".  */
 250       dirname = (char *) "/";
 251       dirlen = 1;
 252       ++filename;
 253     }
 254   else
 255     {
 256       dirlen = filename - pattern;
 257       dirname = (char *) __alloca (dirlen + 1);
 258       memcpy (dirname, pattern, dirlen);
 259       dirname[dirlen] = '\0';
 260       ++filename;
 261     }
 262
 263   if (filename[0] == '\0' && dirlen > 1)
 264     /* "pattern/".  Expand "pattern", appending slashes.  */
 265     {
 266       int val = glob (dirname, flags | GLOB_MARK, errfunc, pglob);
 267       if (val == 0)
 268         pglob->gl_flags = (pglob->gl_flags & ~GLOB_MARK) | (flags & GLOB_MARK);
 269       return val;
 270     }
 271
 272   if (!(flags & GLOB_APPEND))
 273     {
 274       pglob->gl_pathc = 0;
 275       pglob->gl_pathv = NULL;
 276     }
 277
 278   oldcount = pglob->gl_pathc;
 279
 280   if (glob_pattern_p (dirname, !(flags & GLOB_NOESCAPE)))
 281     {
 282       /* The directory name contains metacharacters, so we
 283          have to glob for the directory, and then glob for
 284          the pattern in each directory found.  */
 285       glob_t dirs;
 286       register int i;
 287
 288       status = glob (dirname,
 289                      ((flags & (GLOB_ERR | GLOB_NOCHECK | GLOB_NOESCAPE)) |
 290                       GLOB_NOSORT),
 291                      errfunc, &dirs);
 292       if (status != 0)
 293         return status;
 294
 295       /* We have successfully globbed the preceding directory name.
 296          For each name we found, call glob_in_dir on it and FILENAME,
 297          appending the results to PGLOB.  */
 298       for (i = 0; i < dirs.gl_pathc; ++i)
 299         {
 300           int oldcount;
 301
 302 #ifdef  SHELL
 303           {
 304             /* Make globbing interruptible in the bash shell. */
 305             extern int interrupt_state;
 306
 307             if (interrupt_state)
 308               {
 309                 globfree (&dirs);
 310                 globfree (&files);
 311                 return GLOB_ABEND;
 312               }
 313           }
 314 #endif /* SHELL.  */
 315
 316           oldcount = pglob->gl_pathc;
 317           status = glob_in_dir (filename, dirs.gl_pathv[i],
 318                                 (flags | GLOB_APPEND) & ~GLOB_NOCHECK,
 319                                 errfunc, pglob);
 320           if (status == GLOB_NOMATCH)
 321             /* No matches in this directory.  Try the next.  */
 322             continue;
 323
 324           if (status != 0)
 325             {
 326               globfree (&dirs);
 327               globfree (pglob);
 328               return status;
 329             }
 330
 331           /* Stick the directory on the front of each name.  */
 332           if (prefix_array (dirs.gl_pathv[i],
 333                             &pglob->gl_pathv[oldcount],
 334                             pglob->gl_pathc - oldcount))
 335             {
 336               globfree (&dirs);
 337               globfree (pglob);
 338               return GLOB_NOSPACE;
 339             }
 340         }
 341
 342       flags |= GLOB_MAGCHAR;
 343
 344       if (pglob->gl_pathc == oldcount)
 345         /* No matches.  */
 346         if (flags & GLOB_NOCHECK)
 347           {
 348             size_t len = strlen (pattern) + 1;
 349             char *patcopy = (char *) malloc (len);
 350             if (patcopy == NULL)
 351               return GLOB_NOSPACE;
 352             memcpy (patcopy, pattern, len);
 353
 354             pglob->gl_pathv
 355               = (char **) realloc (pglob->gl_pathv,
 356                                    (pglob->gl_pathc +
 357                                     ((flags & GLOB_DOOFFS) ?
 358                                      pglob->gl_offs : 0) +
 359                                     1 + 1) *
 360                                    sizeof (char *));
 361             if (pglob->gl_pathv == NULL)
 362               {
 363                 free (patcopy);
 364                 return GLOB_NOSPACE;
 365               }
 366
 367             if (flags & GLOB_DOOFFS)
 368               while (pglob->gl_pathc < pglob->gl_offs)
 369                 pglob->gl_pathv[pglob->gl_pathc++] = NULL;
 370
 371             pglob->gl_pathv[pglob->gl_pathc++] = patcopy;
 372             pglob->gl_pathv[pglob->gl_pathc] = NULL;
 373             pglob->gl_flags = flags;
 374           }
 375         else
 376           return GLOB_NOMATCH;
 377     }
 378   else
 379     {
 380       status = glob_in_dir (filename, dirname, flags, errfunc, pglob);
 381       if (status != 0)
 382         return status;
 383
 384       if (dirlen > 0)
 385         {
 386           /* Stick the directory on the front of each name.  */
 387           if (prefix_array (dirname,
 388                             &pglob->gl_pathv[oldcount],
 389                             pglob->gl_pathc - oldcount))
 390             {
 391               globfree (pglob);
 392               return GLOB_NOSPACE;
 393             }
 394         }
 395     }
 396
 397   if (!(flags & GLOB_NOSORT))
 398     /* Sort the vector.  */
 399     qsort ((__ptr_t) & pglob->gl_pathv[oldcount],
 400            pglob->gl_pathc - oldcount,
 401            sizeof (char *), collated_compare);
 402
 403   return 0;
 404 }
 405
 406
 407 /* Free storage allocated in PGLOB by a previous `glob' call.  */
 408 void
 409 globfree (pglob)
 410      register glob_t *pglob;
 411 {
 412   if (pglob->gl_pathv != NULL)
 413     {
 414       register int i;
 415       for (i = 0; i < pglob->gl_pathc; ++i)
 416         if (pglob->gl_pathv[i] != NULL)
 417           free ((__ptr_t) pglob->gl_pathv[i]);
 418       free ((__ptr_t) pglob->gl_pathv);
 419     }
 420 }
 421
 422
 423 /* Do a collated comparison of A and B.  */
 424 static int
 425 collated_compare (a, b)
 426      const __ptr_t a;
 427      const __ptr_t b;
 428 {
 429   const char *const s1 = *(const char *const * const) a;
 430   const char *const s2 = *(const char *const * const) b;
 431
 432   if (s1 == s2)
 433     return 0;
 434   if (s1 == NULL)
 435     return 1;
 436   if (s2 == NULL)
 437     return -1;
 438   return strcoll (s1, s2);
 439 }
 440
 441
 442 /* Prepend DIRNAME to each of N members of ARRAY, replacing ARRAY's
 443    elements in place.  Return nonzero if out of memory, zero if successful.
 444    A slash is inserted between DIRNAME and each elt of ARRAY,
 445    unless DIRNAME is just "/".  Each old element of ARRAY is freed.  */
 446 static int
 447 prefix_array (dirname, array, n)
 448      const char *dirname;
 449      char **array;
 450      size_t n;
 451 {
 452   register size_t i;
 453   size_t dirlen = strlen (dirname);
 454
 455   if (dirlen == 1 && dirname[0] == '/')
 456     /* DIRNAME is just "/", so normal prepending would get us "//foo".
 457        We want "/foo" instead, so don't prepend any chars from DIRNAME.  */
 458     dirlen = 0;
 459
 460   for (i = 0; i < n; ++i)
 461     {
 462       size_t eltlen = strlen (array[i]) + 1;
 463       char *new = (char *) malloc (dirlen + 1 + eltlen);
 464       if (new == NULL)
 465         {
 466           while (i > 0)
 467             free ((__ptr_t) array[--i]);
 468           return 1;
 469         }
 470
 471       memcpy (new, dirname, dirlen);
 472       new[dirlen] = '/';
 473       memcpy (&new[dirlen + 1], array[i], eltlen);
 474       free ((__ptr_t) array[i]);
 475       array[i] = new;
 476     }
 477
 478   return 0;
 479 }
 480
 481
 482 /* Return nonzero if PATTERN contains any metacharacters.
 483    Metacharacters can be quoted with backslashes if QUOTE is nonzero.  */
 484 static int
 485 glob_pattern_p (pattern, quote)
 486      const char *pattern;
 487      int quote;
 488 {
 489   register const char *p;
 490   int open = 0;
 491
 492   for (p = pattern; *p != '\0'; ++p)
 493     switch (*p)
 494       {
 495       case '?':
 496       case '*':
 497         return 1;
 498
 499       case '\\':
 500         if (quote)
 501           ++p;
 502         break;
 503
 504       case '[':
 505         open = 1;
 506         break;
 507
 508       case ']':
 509         if (open)
 510           return 1;
 511         break;
 512       }
 513
 514   return 0;
 515 }
 516
 517
 518 /* Like `glob', but PATTERN is a final pathname component,
 519    and matches are searched for in DIRECTORY.
 520    The GLOB_NOSORT bit in FLAGS is ignored.  No sorting is ever done.
 521    The GLOB_APPEND flag is assumed to be set (always appends).  */
 522 static int
 523 glob_in_dir (pattern, directory, flags, errfunc, pglob)
 524      const char *pattern;
 525      const char *directory;
 526      int flags;
 527      int (*errfunc) __P ((const char *, int));
 528      glob_t *pglob;
 529 {
 530   __ptr_t stream;
 531
 532   struct globlink
 533     {
 534       struct globlink *next;
 535       char *name;
 536     };
 537   struct globlink *names = NULL;
 538   size_t nfound = 0;
 539
 540   if (!glob_pattern_p (pattern, !(flags & GLOB_NOESCAPE)))
 541     {
 542       stream = NULL;
 543       flags |= GLOB_NOCHECK;
 544     }
 545   else
 546     {
 547       flags |= GLOB_MAGCHAR;
 548
 549       stream = (__glob_opendir_hook ? (*__glob_opendir_hook) (directory)
 550                 : (__ptr_t) opendir (directory));
 551       if (stream == NULL)
 552         {
 553           if ((errfunc != NULL && (*errfunc) (directory, errno)) ||
 554               (flags & GLOB_ERR))
 555             return GLOB_ABEND;
 556         }
 557       else
 558         while (1)
 559           {
 560             const char *name;
 561             size_t len;
 562
 563             if (__glob_readdir_hook)
 564               {
 565                 name = (*__glob_readdir_hook) (stream);
 566                 if (name == NULL)
 567                   break;
 568                 len = 0;
 569               }
 570             else
 571               {
 572                 struct dirent *d = readdir ((DIR *) stream);
 573                 if (d == NULL)
 574                   break;
 575                 if (! REAL_DIR_ENTRY (d))
 576                   continue;
 577                 name = d->d_name;
 578 #ifdef  HAVE_D_NAMLEN
 579                 len = d->d_namlen;
 580 #else
 581                 len = 0;
 582 #endif
 583               }
 584
 585             if (fnmatch (pattern, name,
 586                          (!(flags & GLOB_PERIOD) ? FNM_PERIOD : 0) |
 587                          ((flags & GLOB_NOESCAPE) ? FNM_NOESCAPE : 0)) == 0)
 588               {
 589                 struct globlink *new
 590                   = (struct globlink *) __alloca (sizeof (struct globlink));
 591                 if (len == 0)
 592                   len = strlen (name);
 593                 new->name
 594                   = (char *) malloc (len + ((flags & GLOB_MARK) ? 1 : 0) + 1);
 595                 if (new->name == NULL)
 596                   goto memory_error;
 597                 memcpy ((__ptr_t) new->name, name, len);
 598                 if (flags & GLOB_MARK)
 599                   new->name[len++] = '/';
 600                 new->name[len] = '\0';
 601                 new->next = names;
 602                 names = new;
 603                 ++nfound;
 604               }
 605           }
 606     }
 607
 608   if (nfound == 0 && (flags & GLOB_NOCHECK))
 609     {
 610       size_t len = strlen (pattern);
 611       nfound = 1;
 612       names = (struct globlink *) __alloca (sizeof (struct globlink));
 613       names->next = NULL;
 614       names->name = (char *) malloc (len + ((flags & GLOB_MARK) ? 1 : 0) + 1);
 615       if (names->name == NULL)
 616         goto memory_error;
 617       memcpy (names->name, pattern, len);
 618       if (flags & GLOB_MARK)
 619         names->name[len++] = '/';
 620       names->name[len] = '\0';
 621     }
 622
 623   pglob->gl_pathv
 624     = (char **) realloc (pglob->gl_pathv,
 625                          (pglob->gl_pathc +
 626                           ((flags & GLOB_DOOFFS) ? pglob->gl_offs : 0) +
 627                           nfound + 1) *
 628                          sizeof (char *));
 629   if (pglob->gl_pathv == NULL)
 630     goto memory_error;
 631
 632   if (flags & GLOB_DOOFFS)
 633     while (pglob->gl_pathc < pglob->gl_offs)
 634       pglob->gl_pathv[pglob->gl_pathc++] = NULL;
 635
 636   for (; names != NULL; names = names->next)
 637     pglob->gl_pathv[pglob->gl_pathc++] = names->name;
 638   pglob->gl_pathv[pglob->gl_pathc] = NULL;
 639
 640   pglob->gl_flags = flags;
 641
 642   if (stream != NULL)
 643     {
 644       int save = errno;
 645       if (__glob_closedir_hook)
 646         (*__glob_closedir_hook) (stream);
 647       else
 648         (void) closedir ((DIR *) stream);
 649       errno = save;
 650     }
 651   return nfound == 0 ? GLOB_NOMATCH : 0;
 652
 653  memory_error:
 654   {
 655     int save = errno;
 656     if (__glob_closedir_hook)
 657       (*__glob_closedir_hook) (stream);
 658     else
 659       (void) closedir ((DIR *) stream);
 660     errno = save;
 661   }
 662   while (names != NULL)
 663     {
 664       if (names->name != NULL)
 665         free ((__ptr_t) names->name);
 666       names = names->next;
 667     }
 668   return GLOB_NOSPACE;
 669 }
 670
 671 #endif  /* _LIBC or not __GNU_LIBRARY__.  */