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