Formerly ../stdio/vfprintf.c.~8~
[kopensolaris-gnu/glibc.git] / 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 }