posix/glob.c

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