1 /* Copyright (C) 1991,92,93,94,95,96,97,98 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 #include <stdio.h>      /* Needed on stupid SunOS for assert.  */
41 
42 
43 /* Comment out all this code if we are using the GNU C Library, and are not
44    actually compiling the library itself.  This code is part of the GNU C
45    Library, but also included in many other GNU distributions.  Compiling
46    and linking in this code is a waste when using the GNU C library
47    (especially if it is a shared library).  Rather than having every GNU
48    program understand `configure --with-gnu-libc' and omit the object files,
49    it is simpler to just do this in the source for each such file.  */
50 
51 #define GLOB_INTERFACE_VERSION 1
52 #if !defined _LIBC && defined __GNU_LIBRARY__ && __GNU_LIBRARY__ > 1
53 # include <gnu-versions.h>
54 # if _GNU_GLOB_INTERFACE_VERSION == GLOB_INTERFACE_VERSION
55 #  define ELIDE_CODE
56 # endif
57 #endif
58 
59 #ifndef ELIDE_CODE
60 
61 #if defined STDC_HEADERS || defined __GNU_LIBRARY__
62 # include <stddef.h>
63 #endif
64 
65 #if defined HAVE_UNISTD_H || defined _LIBC
66 # include <unistd.h>
67 # ifndef POSIX
68 #  ifdef _POSIX_VERSION
69 #   define POSIX
70 #  endif
71 # endif
72 #endif
73 
74 #if !defined _AMIGA && !defined VMS && !defined WINDOWS32
75 # include <pwd.h>
76 #endif
77 
78 #if !defined __GNU_LIBRARY__ && !defined STDC_HEADERS
79 extern int errno;
80 #endif
81 #ifndef __set_errno
82 # define __set_errno(val) errno = (val)
83 #endif
84 
85 #ifndef NULL
86 # define NULL   0
87 #endif
88 
89 
90 #if defined HAVE_DIRENT_H || defined __GNU_LIBRARY__
91 # include <dirent.h>
92 # define NAMLEN(dirent) strlen((dirent)->d_name)
93 #else
94 # define dirent direct
95 # define NAMLEN(dirent) (dirent)->d_namlen
96 # ifdef HAVE_SYS_NDIR_H
97 #  include <sys/ndir.h>
98 # endif
99 # ifdef HAVE_SYS_DIR_H
100 #  include <sys/dir.h>
101 # endif
102 # ifdef HAVE_NDIR_H
103 #  include <ndir.h>
104 # endif
105 # ifdef HAVE_VMSDIR_H
106 #  include "vmsdir.h"
107 # endif /* HAVE_VMSDIR_H */
108 #endif
109 
110 
111 /* In GNU systems, <dirent.h> defines this macro for us.  */
112 #ifdef _D_NAMLEN
113 # undef NAMLEN
114 # define NAMLEN(d) _D_NAMLEN(d)
115 #endif
116 
117 /* When used in the GNU libc the symbol _DIRENT_HAVE_D_TYPE is available
118    if the `d_type' member for `struct dirent' is available.  */
119 #ifdef _DIRENT_HAVE_D_TYPE
120 # define HAVE_D_TYPE    1
121 #endif
122 
123 
124 #if (defined POSIX || defined WINDOWS32) && !defined __GNU_LIBRARY__
125 /* Posix does not require that the d_ino field be present, and some
126    systems do not provide it. */
127 # define REAL_DIR_ENTRY(dp) 1
128 #else
129 # define REAL_DIR_ENTRY(dp) (dp->d_ino != 0)
130 #endif /* POSIX */
131 
132 #if defined STDC_HEADERS || defined __GNU_LIBRARY__
133 # include <stdlib.h>
134 # include <string.h>
135 # define    ANSI_STRING
136 #else   /* No standard headers.  */
137 
138 extern char *getenv ();
139 
140 # ifdef HAVE_STRING_H
141 #  include <string.h>
142 #  define ANSI_STRING
143 # else
144 #  include <strings.h>
145 # endif
146 # ifdef HAVE_MEMORY_H
147 #  include <memory.h>
148 # endif
149 
150 extern char *malloc (), *realloc ();
151 extern void free ();
152 
153 extern void qsort ();
154 extern void abort (), exit ();
155 
156 #endif  /* Standard headers.  */
157 
158 #ifdef HAVE_GETLOGIN_R
159 extern int getlogin_r __P ((char *, size_t));
160 #else
161 extern char *getlogin __P ((void));
162 #endif
163 
164 #ifndef ANSI_STRING
165 
166 # ifndef bzero
167 extern void bzero ();
168 # endif
169 # ifndef bcopy
170 extern void bcopy ();
171 # endif
172 
173 # define memcpy(d, s, n)    bcopy ((s), (d), (n))
174 # define strrchr    rindex
175 /* memset is only used for zero here, but let's be paranoid.  */
176 # define memset(s, better_be_zero, n) \
177   ((void) ((better_be_zero) == 0 ? (bzero((s), (n)), 0) : (abort(), 0)))
178 #endif  /* Not ANSI_STRING.  */
179 
180 #if !defined HAVE_STRCOLL && !defined _LIBC
181 # define strcoll    strcmp
182 #endif
183 
184 #if !defined HAVE_MEMPCPY && __GLIBC__ - 0 == 2 && __GLIBC_MINOR__ >= 1
185 # define HAVE_MEMPCPY   1
186 # undef  mempcpy
187 # define mempcpy(Dest, Src, Len) __mempcpy (Dest, Src, Len)
188 #endif
189 
190 #ifndef __GNU_LIBRARY__
191 # ifdef __GNUC__
192 __inline
193 # endif
194 # ifndef __SASC
195 #  ifdef WINDOWS32
196 static void *
197 #  else
198 static char *
199 # endif
my_realloc(p,n)200 my_realloc (p, n)
201      char *p;
202      unsigned int n;
203 {
204   /* These casts are the for sake of the broken Ultrix compiler,
205      which warns of illegal pointer combinations otherwise.  */
206   if (p == NULL)
207     return (char *) malloc (n);
208   return (char *) realloc (p, n);
209 }
210 # define    realloc my_realloc
211 # endif /* __SASC */
212 #endif /* __GNU_LIBRARY__ */
213 
214 
215 #if !defined __alloca && !defined __GNU_LIBRARY__
216 
217 # ifdef __GNUC__
218 #  undef alloca
219 #  define alloca(n) __builtin_alloca (n)
220 # else  /* Not GCC.  */
221 #  ifdef HAVE_ALLOCA_H
222 #   include <alloca.h>
223 #  else /* Not HAVE_ALLOCA_H.  */
224 #   ifndef _AIX
225 #    ifdef WINDOWS32
226 #     include <malloc.h>
227 #    else
228 extern char *alloca ();
229 #    endif /* WINDOWS32 */
230 #   endif /* Not _AIX.  */
231 #  endif /* sparc or HAVE_ALLOCA_H.  */
232 # endif /* GCC.  */
233 
234 # define __alloca   alloca
235 
236 #endif
237 
238 #ifndef __GNU_LIBRARY__
239 # define __stat stat
240 # ifdef STAT_MACROS_BROKEN
241 #  undef S_ISDIR
242 # endif
243 # ifndef S_ISDIR
244 #  define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR)
245 # endif
246 #endif
247 
248 #ifdef _LIBC
249 # undef strdup
250 # define strdup(str) __strdup (str)
251 # define sysconf(id) __sysconf (id)
252 # define closedir(dir) __closedir (dir)
253 # define opendir(name) __opendir (name)
254 # define readdir(str) __readdir (str)
255 # define getpwnam_r(name, bufp, buf, len, res) \
256    __getpwnam_r (name, bufp, buf, len, res)
257 # ifndef __stat
258 #  define __stat(fname, buf) __xstat (_STAT_VER, fname, buf)
259 # endif
260 #endif
261 
262 #if !(defined STDC_HEADERS || defined __GNU_LIBRARY__)
263 # undef size_t
264 # define size_t unsigned int
265 #endif
266 
267 /* Some system header files erroneously define these.
268    We want our own definitions from <fnmatch.h> to take precedence.  */
269 #ifndef __GNU_LIBRARY__
270 # undef FNM_PATHNAME
271 # undef FNM_NOESCAPE
272 # undef FNM_PERIOD
273 #endif
274 #include <fnmatch.h>
275 
276 /* Some system header files erroneously define these.
277    We want our own definitions from <glob.h> to take precedence.  */
278 #ifndef __GNU_LIBRARY__
279 # undef GLOB_ERR
280 # undef GLOB_MARK
281 # undef GLOB_NOSORT
282 # undef GLOB_DOOFFS
283 # undef GLOB_NOCHECK
284 # undef GLOB_APPEND
285 # undef GLOB_NOESCAPE
286 # undef GLOB_PERIOD
287 #endif
288 #include <glob.h>
289 
290 static
291 #if __GNUC__ - 0 >= 2
292 __inline__
293 #endif
294 const char *next_brace_sub __P ((const char *begin));
295 static int glob_in_dir __P ((const char *pattern, const char *directory,
296                  int flags,
297                  int (*errfunc) (const char *, int),
298                  glob_t *pglob));
299 static int prefix_array __P ((const char *prefix, char **array, size_t n));
300 static int collated_compare __P ((const __ptr_t, const __ptr_t));
301 
302 
303 /* Find the end of the sub-pattern in a brace expression.  We define
304    this as an inline function if the compiler permits.  */
305 static
306 #if __GNUC__ - 0 >= 2
307 __inline__
308 #endif
309 const char *
next_brace_sub(begin)310 next_brace_sub (begin)
311      const char *begin;
312 {
313   unsigned int depth = 0;
314   const char *cp = begin;
315 
316   while (1)
317     {
318       if (depth == 0)
319     {
320       if (*cp != ',' && *cp != '}' && *cp != '\0')
321         {
322           if (*cp == '{')
323         ++depth;
324           ++cp;
325           continue;
326         }
327     }
328       else
329     {
330       while (*cp != '\0' && (*cp != '}' || depth > 0))
331         {
332           if (*cp == '}')
333         --depth;
334           ++cp;
335         }
336       if (*cp == '\0')
337         /* An incorrectly terminated brace expression.  */
338         return NULL;
339 
340       continue;
341     }
342       break;
343     }
344 
345   return cp;
346 }
347 
348 /* Do glob searching for PATTERN, placing results in PGLOB.
349    The bits defined above may be set in FLAGS.
350    If a directory cannot be opened or read and ERRFUNC is not nil,
351    it is called with the pathname that caused the error, and the
352    `errno' value from the failing call; if it returns non-zero
353    `glob' returns GLOB_ABORTED; if it returns zero, the error is ignored.
354    If memory cannot be allocated for PGLOB, GLOB_NOSPACE is returned.
355    Otherwise, `glob' returns zero.  */
356 int
glob(pattern,flags,errfunc,pglob)357 glob (pattern, flags, errfunc, pglob)
358      const char *pattern;
359      int flags;
360      int (*errfunc) __P ((const char *, int));
361      glob_t *pglob;
362 {
363   const char *filename;
364   const char *dirname;
365   size_t dirlen;
366   int status;
367   int oldcount;
368 
369   if (pattern == NULL || pglob == NULL || (flags & ~__GLOB_FLAGS) != 0)
370     {
371       __set_errno (EINVAL);
372       return -1;
373     }
374 
375   if (flags & GLOB_BRACE)
376     {
377       const char *begin = strchr (pattern, '{');
378       if (begin != NULL)
379     {
380       /* Allocate working buffer large enough for our work.  Note that
381         we have at least an opening and closing brace.  */
382       int firstc;
383       char *alt_start;
384       const char *p;
385       const char *next;
386       const char *rest;
387       size_t rest_len;
388 #ifdef __GNUC__
389       __extension__ char onealt[strlen (pattern) - 1];
390 #else
391       char *onealt = (char *) malloc (strlen (pattern) - 1);
392       if (onealt == NULL)
393         {
394           if (!(flags & GLOB_APPEND))
395         globfree (pglob);
396           return GLOB_NOSPACE;
397         }
398 #endif
399 
400       /* We know the prefix for all sub-patterns.  */
401 #ifdef HAVE_MEMPCPY
402       alt_start = mempcpy (onealt, pattern, begin - pattern);
403 #else
404       memcpy (onealt, pattern, begin - pattern);
405       alt_start = &onealt[begin - pattern];
406 #endif
407 
408       /* Find the first sub-pattern and at the same time find the
409          rest after the closing brace.  */
410       next = next_brace_sub (begin + 1);
411       if (next == NULL)
412         {
413           /* It is an illegal expression.  */
414 #ifndef __GNUC__
415           free (onealt);
416 #endif
417           return glob (pattern, flags & ~GLOB_BRACE, errfunc, pglob);
418         }
419 
420       /* Now find the end of the whole brace expression.  */
421       rest = next;
422       while (*rest != '}')
423         {
424           rest = next_brace_sub (rest + 1);
425           if (rest == NULL)
426         {
427           /* It is an illegal expression.  */
428 #ifndef __GNUC__
429           free (onealt);
430 #endif
431           return glob (pattern, flags & ~GLOB_BRACE, errfunc, pglob);
432         }
433         }
434       /* Please note that we now can be sure the brace expression
435          is well-formed.  */
436       rest_len = strlen (++rest) + 1;
437 
438       /* We have a brace expression.  BEGIN points to the opening {,
439          NEXT points past the terminator of the first element, and END
440          points past the final }.  We will accumulate result names from
441          recursive runs for each brace alternative in the buffer using
442          GLOB_APPEND.  */
443 
444       if (!(flags & GLOB_APPEND))
445         {
446           /* This call is to set a new vector, so clear out the
447          vector so we can append to it.  */
448           pglob->gl_pathc = 0;
449           pglob->gl_pathv = NULL;
450         }
451       firstc = pglob->gl_pathc;
452 
453       p = begin + 1;
454       while (1)
455         {
456           int result;
457 
458           /* Construct the new glob expression.  */
459 #ifdef HAVE_MEMPCPY
460           mempcpy (mempcpy (alt_start, p, next - p), rest, rest_len);
461 #else
462           memcpy (alt_start, p, next - p);
463           memcpy (&alt_start[next - p], rest, rest_len);
464 #endif
465 
466           result = glob (onealt,
467                  ((flags & ~(GLOB_NOCHECK|GLOB_NOMAGIC))
468                   | GLOB_APPEND), errfunc, pglob);
469 
470           /* If we got an error, return it.  */
471           if (result && result != GLOB_NOMATCH)
472         {
473 #ifndef __GNUC__
474           free (onealt);
475 #endif
476           if (!(flags & GLOB_APPEND))
477             globfree (pglob);
478           return result;
479         }
480 
481           if (*next == '}')
482         /* We saw the last entry.  */
483         break;
484 
485           p = next + 1;
486           next = next_brace_sub (p);
487           assert (next != NULL);
488         }
489 
490 #ifndef __GNUC__
491       free (onealt);
492 #endif
493 
494       if (pglob->gl_pathc != firstc)
495         /* We found some entries.  */
496         return 0;
497       else if (!(flags & (GLOB_NOCHECK|GLOB_NOMAGIC)))
498         return GLOB_NOMATCH;
499     }
500     }
501 
502   /* Find the filename.  */
503   filename = strrchr (pattern, '/');
504 #if defined __MSDOS__ || defined WINDOWS32
505   /* The case of "d:pattern".  Since `:' is not allowed in
506      file names, we can safely assume that wherever it
507      happens in pattern, it signals the filename part.  This
508      is so we could some day support patterns like "[a-z]:foo".  */
509   if (filename == NULL)
510     filename = strchr (pattern, ':');
511 #endif /* __MSDOS__ || WINDOWS32 */
512   if (filename == NULL)
513     {
514       /* This can mean two things: a simple name or "~name".  The later
515      case is nothing but a notation for a directory.  */
516       if ((flags & (GLOB_TILDE|GLOB_TILDE_CHECK)) && pattern[0] == '~')
517     {
518       dirname = pattern;
519       dirlen = strlen (pattern);
520 
521       /* Set FILENAME to NULL as a special flag.  This is ugly but
522          other solutions would require much more code.  We test for
523          this special case below.  */
524       filename = NULL;
525     }
526       else
527     {
528       filename = pattern;
529 #ifdef _AMIGA
530       dirname = "";
531 #else
532       dirname = ".";
533 #endif
534       dirlen = 0;
535     }
536     }
537   else if (filename == pattern)
538     {
539       /* "/pattern".  */
540       dirname = GOLD_SLASH_CHR;
541       dirlen = 1;
542       ++filename;
543     }
544   else
545     {
546       char *newp;
547       dirlen = filename - pattern;
548 #if defined __MSDOS__ || defined WINDOWS32
549       if (*filename == ':'
550       || (filename > pattern + 1 && filename[-1] == ':'))
551     {
552       char *drive_spec;
553 
554       ++dirlen;
555       drive_spec = (char *) __alloca (dirlen + 1);
556 #ifdef HAVE_MEMPCPY
557       *((char *) mempcpy (drive_spec, pattern, dirlen)) = '\0';
558 #else
559       memcpy (drive_spec, pattern, dirlen);
560       drive_spec[dirlen] = '\0';
561 #endif
562       /* For now, disallow wildcards in the drive spec, to
563          prevent infinite recursion in glob.  */
564       if (__glob_pattern_p (drive_spec, !(flags & GLOB_NOESCAPE)))
565         return GLOB_NOMATCH;
566       /* If this is "d:pattern", we need to copy `:' to DIRNAME
567          as well.  If it's "d:/pattern", don't remove the slash
568          from "d:/", since "d:" and "d:/" are not the same.*/
569     }
570 #endif
571       newp = (char *) __alloca (dirlen + 1);
572 #ifdef HAVE_MEMPCPY
573       *((char *) mempcpy (newp, pattern, dirlen)) = '\0';
574 #else
575       memcpy (newp, pattern, dirlen);
576       newp[dirlen] = '\0';
577 #endif
578       dirname = newp;
579       ++filename;
580 
581       if (filename[0] == '\0'
582 #if defined __MSDOS__ || defined WINDOWS32
583           && dirname[dirlen - 1] != ':'
584       && (dirlen < 3 || dirname[dirlen - 2] != ':'
585           || dirname[dirlen - 1] != '/')
586 #endif
587       && dirlen > 1)
588     /* "pattern/".  Expand "pattern", appending slashes.  */
589     {
590       int val = glob (dirname, flags | GLOB_MARK, errfunc, pglob);
591       if (val == 0)
592         pglob->gl_flags = ((pglob->gl_flags & ~GLOB_MARK)
593                    | (flags & GLOB_MARK));
594       return val;
595     }
596     }
597 
598   if (!(flags & GLOB_APPEND))
599     {
600       pglob->gl_pathc = 0;
601       pglob->gl_pathv = NULL;
602     }
603 
604   oldcount = pglob->gl_pathc;
605 
606 #ifndef VMS
607   if ((flags & (GLOB_TILDE|GLOB_TILDE_CHECK)) && dirname[0] == '~')
608     {
609       if (dirname[1] == '\0' || dirname[1] == '/')
610     {
611       /* Look up home directory.  */
612       const char *home_dir = getenv ("HOME");
613 # ifdef _AMIGA
614       if (home_dir == NULL || home_dir[0] == '\0')
615         home_dir = "SYS:";
616 # else
617 #  ifdef WINDOWS32
618       if (home_dir == NULL || home_dir[0] == '\0')
619             home_dir = "c:/users/default"; /* poor default */
620 #  else
621       if (home_dir == NULL || home_dir[0] == '\0')
622         {
623           int success;
624           char *name;
625 #   if defined HAVE_GETLOGIN_R || defined _LIBC
626           size_t buflen = sysconf (_SC_LOGIN_NAME_MAX) + 1;
627 
628           if (buflen == 0)
629         /* `sysconf' does not support _SC_LOGIN_NAME_MAX.  Try
630            a moderate value.  */
631         buflen = 20;
632           name = (char *) __alloca (buflen);
633 
634           success = getlogin_r (name, buflen) >= 0;
635 #   else
636           success = (name = getlogin ()) != NULL;
637 #   endif
638           if (success)
639         {
640           struct passwd *p;
641 #   if defined HAVE_GETPWNAM_R || defined _LIBC
642           size_t pwbuflen = sysconf (_SC_GETPW_R_SIZE_MAX);
643           char *pwtmpbuf;
644           struct passwd pwbuf;
645 
646           if (pwbuflen == -1)
647             /* `sysconf' does not support _SC_GETPW_R_SIZE_MAX.
648                Try a moderate value.  */
649             pwbuflen = 1024;
650           pwtmpbuf = (char *) __alloca (pwbuflen);
651 
652           success = (getpwnam_r (name, &pwbuf, pwtmpbuf, pwbuflen, &p)
653                  >= 0);
654 #   else
655           p = getpwnam (name);
656           success = p != NULL;
657 #   endif
658           if (success)
659             home_dir = p->pw_dir;
660         }
661         }
662       if (home_dir == NULL || home_dir[0] == '\0')
663         {
664           if (flags & GLOB_TILDE_CHECK)
665         return GLOB_NOMATCH;
666           else
667         home_dir = "~"; /* No luck.  */
668         }
669 #  endif /* WINDOWS32 */
670 # endif
671       /* Now construct the full directory.  */
672       if (dirname[1] == '\0')
673         dirname = home_dir;
674       else
675         {
676           char *newp;
677           size_t home_len = strlen (home_dir);
678           newp = (char *) __alloca (home_len + dirlen);
679 # ifdef HAVE_MEMPCPY
680           mempcpy (mempcpy (newp, home_dir, home_len),
681                &dirname[1], dirlen);
682 # else
683           memcpy (newp, home_dir, home_len);
684           memcpy (&newp[home_len], &dirname[1], dirlen);
685 # endif
686           dirname = newp;
687         }
688     }
689 # if !defined _AMIGA && !defined WINDOWS32
690       else
691     {
692       char *end_name = strchr (dirname, '/');
693       const char *user_name;
694       const char *home_dir;
695 
696       if (end_name == NULL)
697         user_name = dirname + 1;
698       else
699         {
700           char *newp;
701           newp = (char *) __alloca (end_name - dirname);
702 # ifdef HAVE_MEMPCPY
703           *((char *) mempcpy (newp, dirname + 1, end_name - dirname))
704         = '\0';
705 # else
706           memcpy (newp, dirname + 1, end_name - dirname);
707           newp[end_name - dirname - 1] = '\0';
708 # endif
709           user_name = newp;
710         }
711 
712       /* Look up specific user's home directory.  */
713       {
714         struct passwd *p;
715 #  if defined HAVE_GETPWNAM_R || defined _LIBC
716         size_t buflen = sysconf (_SC_GETPW_R_SIZE_MAX);
717         char *pwtmpbuf;
718         struct passwd pwbuf;
719 
720         if (buflen == -1)
721           /* `sysconf' does not support _SC_GETPW_R_SIZE_MAX.  Try a
722          moderate value.  */
723           buflen = 1024;
724         pwtmpbuf = (char *) __alloca (buflen);
725 
726         if (getpwnam_r (user_name, &pwbuf, pwtmpbuf, buflen, &p) >= 0)
727           home_dir = p->pw_dir;
728         else
729           home_dir = NULL;
730 #  else
731         p = getpwnam (user_name);
732         if (p != NULL)
733           home_dir = p->pw_dir;
734         else
735           home_dir = NULL;
736 #  endif
737       }
738       /* If we found a home directory use this.  */
739       if (home_dir != NULL)
740         {
741           char *newp;
742           size_t home_len = strlen (home_dir);
743           size_t rest_len = end_name == NULL ? 0 : strlen (end_name);
744           newp = (char *) __alloca (home_len + rest_len + 1);
745 #  ifdef HAVE_MEMPCPY
746           *((char *) mempcpy (mempcpy (newp, home_dir, home_len),
747                   end_name, rest_len)) = '\0';
748 #  else
749           memcpy (newp, home_dir, home_len);
750           memcpy (&newp[home_len], end_name, rest_len);
751           newp[home_len + rest_len] = '\0';
752 #  endif
753           dirname = newp;
754         }
755       else
756         if (flags & GLOB_TILDE_CHECK)
757           /* We have to regard it as an error if we cannot find the
758          home directory.  */
759           return GLOB_NOMATCH;
760     }
761 # endif /* Not Amiga && not WINDOWS32.  */
762     }
763 #endif  /* Not VMS.  */
764 
765   /* Now test whether we looked for "~" or "~NAME".  In this case we
766      can give the answer now.  */
767   if (filename == NULL)
768     {
769       struct stat st;
770 
771       /* Return the directory if we don't check for error or if it exists.  */
772       if ((flags & GLOB_NOCHECK)
773       || (((flags & GLOB_ALTDIRFUNC)
774            ? (*pglob->gl_stat) (dirname, &st)
775            : __stat (dirname, &st)) == 0
776           && S_ISDIR (st.st_mode)))
777     {
778       pglob->gl_pathv
779         = (char **) realloc (pglob->gl_pathv,
780                  (pglob->gl_pathc +
781                   ((flags & GLOB_DOOFFS) ?
782                    pglob->gl_offs : 0) +
783                   1 + 1) *
784                  sizeof (char *));
785       if (pglob->gl_pathv == NULL)
786         return GLOB_NOSPACE;
787 
788       if (flags & GLOB_DOOFFS)
789         while (pglob->gl_pathc < pglob->gl_offs)
790           pglob->gl_pathv[pglob->gl_pathc++] = NULL;
791 
792 #if defined HAVE_STRDUP || defined _LIBC
793       pglob->gl_pathv[pglob->gl_pathc] = strdup (dirname);
794 #else
795       {
796         size_t len = strlen (dirname) + 1;
797         char *dircopy = malloc (len);
798         if (dircopy != NULL)
799           pglob->gl_pathv[pglob->gl_pathc] = memcpy (dircopy, dirname,
800                              len);
801       }
802 #endif
803       if (pglob->gl_pathv[pglob->gl_pathc] == NULL)
804         {
805           free (pglob->gl_pathv);
806           return GLOB_NOSPACE;
807         }
808       pglob->gl_pathv[++pglob->gl_pathc] = NULL;
809       pglob->gl_flags = flags;
810 
811       return 0;
812     }
813 
814       /* Not found.  */
815       return GLOB_NOMATCH;
816     }
817 
818   if (__glob_pattern_p (dirname, !(flags & GLOB_NOESCAPE)))
819     {
820       /* The directory name contains metacharacters, so we
821      have to glob for the directory, and then glob for
822      the pattern in each directory found.  */
823       glob_t dirs;
824       register int i;
825 
826       status = glob (dirname,
827              ((flags & (GLOB_ERR | GLOB_NOCHECK | GLOB_NOESCAPE))
828               | GLOB_NOSORT | GLOB_ONLYDIR),
829              errfunc, &dirs);
830       if (status != 0)
831     return status;
832 
833       /* We have successfully globbed the preceding directory name.
834      For each name we found, call glob_in_dir on it and FILENAME,
835      appending the results to PGLOB.  */
836       for (i = 0; i < dirs.gl_pathc; ++i)
837     {
838       int old_pathc;
839 
840 #ifdef  SHELL
841       {
842         /* Make globbing interruptible in the bash shell. */
843         extern int interrupt_state;
844 
845         if (interrupt_state)
846           {
847         globfree (&dirs);
848         globfree (&files);
849         return GLOB_ABORTED;
850           }
851       }
852 #endif /* SHELL.  */
853 
854       old_pathc = pglob->gl_pathc;
855       status = glob_in_dir (filename, dirs.gl_pathv[i],
856                 ((flags | GLOB_APPEND)
857                  & ~(GLOB_NOCHECK | GLOB_ERR)),
858                 errfunc, pglob);
859       if (status == GLOB_NOMATCH)
860         /* No matches in this directory.  Try the next.  */
861         continue;
862 
863       if (status != 0)
864         {
865           globfree (&dirs);
866           globfree (pglob);
867           return status;
868         }
869 
870       /* Stick the directory on the front of each name.  */
871       if (prefix_array (dirs.gl_pathv[i],
872                 &pglob->gl_pathv[old_pathc],
873                 pglob->gl_pathc - old_pathc))
874         {
875           globfree (&dirs);
876           globfree (pglob);
877           return GLOB_NOSPACE;
878         }
879     }
880 
881       flags |= GLOB_MAGCHAR;
882 
883       /* We have ignored the GLOB_NOCHECK flag in the `glob_in_dir' calls.
884      But if we have not found any matching entry and thie GLOB_NOCHECK
885      flag was set we must return the list consisting of the disrectory
886      names followed by the filename.  */
887       if (pglob->gl_pathc == oldcount)
888     {
889       /* No matches.  */
890       if (flags & GLOB_NOCHECK)
891         {
892           size_t filename_len = strlen (filename) + 1;
893           char **new_pathv;
894           struct stat st;
895 
896           /* This is an pessimistic guess about the size.  */
897           pglob->gl_pathv
898         = (char **) realloc (pglob->gl_pathv,
899                      (pglob->gl_pathc +
900                       ((flags & GLOB_DOOFFS) ?
901                        pglob->gl_offs : 0) +
902                       dirs.gl_pathc + 1) *
903                      sizeof (char *));
904           if (pglob->gl_pathv == NULL)
905         {
906           globfree (&dirs);
907           return GLOB_NOSPACE;
908         }
909 
910           if (flags & GLOB_DOOFFS)
911         while (pglob->gl_pathc < pglob->gl_offs)
912           pglob->gl_pathv[pglob->gl_pathc++] = NULL;
913 
914           for (i = 0; i < dirs.gl_pathc; ++i)
915         {
916           const char *dir = dirs.gl_pathv[i];
917           size_t dir_len = strlen (dir);
918 
919           /* First check whether this really is a directory.  */
920           if (((flags & GLOB_ALTDIRFUNC)
921                ? (*pglob->gl_stat) (dir, &st) : __stat (dir, &st)) != 0
922               || !S_ISDIR (st.st_mode))
923             /* No directory, ignore this entry.  */
924             continue;
925 
926           pglob->gl_pathv[pglob->gl_pathc] = malloc (dir_len + 1
927                                  + filename_len);
928           if (pglob->gl_pathv[pglob->gl_pathc] == NULL)
929             {
930               globfree (&dirs);
931               globfree (pglob);
932               return GLOB_NOSPACE;
933             }
934 
935 #ifdef HAVE_MEMPCPY
936           mempcpy (mempcpy (mempcpy (pglob->gl_pathv[pglob->gl_pathc],
937                                      dir, dir_len),
938                             GOLD_SLASH_CHR, 1),
939                    filename, filename_len);
940 #else
941           memcpy (pglob->gl_pathv[pglob->gl_pathc], dir, dir_len);
942           pglob->gl_pathv[pglob->gl_pathc][dir_len] = '/';
943           memcpy (&pglob->gl_pathv[pglob->gl_pathc][dir_len + 1],
944               filename, filename_len);
945 #endif
946           ++pglob->gl_pathc;
947         }
948 
949           pglob->gl_pathv[pglob->gl_pathc] = NULL;
950           pglob->gl_flags = flags;
951 
952           /* Now we know how large the gl_pathv vector must be.  */
953           new_pathv = (char **) realloc (pglob->gl_pathv,
954                          ((pglob->gl_pathc + 1)
955                           * sizeof (char *)));
956           if (new_pathv != NULL)
957         pglob->gl_pathv = new_pathv;
958         }
959       else
960         return GLOB_NOMATCH;
961     }
962 
963       globfree (&dirs);
964     }
965   else
966     {
967       status = glob_in_dir (filename, dirname, flags, errfunc, pglob);
968       if (status != 0)
969     return status;
970 
971       if (dirlen > 0)
972     {
973       /* Stick the directory on the front of each name.  */
974       int ignore = oldcount;
975 
976       if ((flags & GLOB_DOOFFS) && ignore < pglob->gl_offs)
977         ignore = pglob->gl_offs;
978 
979       if (prefix_array (dirname,
980                 &pglob->gl_pathv[ignore],
981                 pglob->gl_pathc - ignore))
982         {
983           globfree (pglob);
984           return GLOB_NOSPACE;
985         }
986     }
987     }
988 
989   if (flags & GLOB_MARK)
990     {
991       /* Append slashes to directory names.  */
992       int i;
993       struct stat st;
994       for (i = oldcount; i < pglob->gl_pathc; ++i)
995     if (((flags & GLOB_ALTDIRFUNC)
996          ? (*pglob->gl_stat) (pglob->gl_pathv[i], &st)
997          : __stat (pglob->gl_pathv[i], &st)) == 0
998         && S_ISDIR (st.st_mode))
999       {
1000         size_t len = strlen (pglob->gl_pathv[i]) + 2;
1001         char *new = realloc (pglob->gl_pathv[i], len);
1002         if (new == NULL)
1003           {
1004             globfree (pglob);
1005             return GLOB_NOSPACE;
1006           }
1007         strcpy (&new[len - 2], GOLD_SLASH_CHR);
1008         pglob->gl_pathv[i] = new;
1009       }
1010     }
1011 
1012   if (!(flags & GLOB_NOSORT))
1013     {
1014       /* Sort the vector.  */
1015       int non_sort = oldcount;
1016 
1017       if ((flags & GLOB_DOOFFS) && pglob->gl_offs > oldcount)
1018     non_sort = pglob->gl_offs;
1019 
1020       qsort ((__ptr_t) &pglob->gl_pathv[non_sort],
1021          pglob->gl_pathc - non_sort,
1022          sizeof (char *), collated_compare);
1023     }
1024 
1025   return 0;
1026 }
1027 
1028 
1029 /* Free storage allocated in PGLOB by a previous `glob' call.  */
1030 void
globfree(pglob)1031 globfree (pglob)
1032      register glob_t *pglob;
1033 {
1034   if (pglob->gl_pathv != NULL)
1035     {
1036       register int i;
1037       for (i = 0; i < pglob->gl_pathc; ++i)
1038     if (pglob->gl_pathv[i] != NULL)
1039       free ((__ptr_t) pglob->gl_pathv[i]);
1040       free ((__ptr_t) pglob->gl_pathv);
1041     }
1042 }
1043 
1044 
1045 /* Do a collated comparison of A and B.  */
1046 static int
collated_compare(a,b)1047 collated_compare (a, b)
1048      const __ptr_t a;
1049      const __ptr_t b;
1050 {
1051   const char *const s1 = *(const char *const * const) a;
1052   const char *const s2 = *(const char *const * const) b;
1053 
1054   if (s1 == s2)
1055     return 0;
1056   if (s1 == NULL)
1057     return 1;
1058   if (s2 == NULL)
1059     return -1;
1060   return strcoll (s1, s2);
1061 }
1062 
1063 
1064 /* Prepend DIRNAME to each of N members of ARRAY, replacing ARRAY's
1065    elements in place.  Return nonzero if out of memory, zero if successful.
1066    A slash is inserted between DIRNAME and each elt of ARRAY,
1067    unless DIRNAME is just "/".  Each old element of ARRAY is freed.  */
1068 static int
prefix_array(dirname,array,n)1069 prefix_array (dirname, array, n)
1070      const char *dirname;
1071      char **array;
1072      size_t n;
1073 {
1074   register size_t i;
1075   size_t dirlen = strlen (dirname);
1076 #if defined __MSDOS__ || defined WINDOWS32
1077   int sep_char = '/';
1078 # define DIRSEP_CHAR sep_char
1079 #else
1080 # define DIRSEP_CHAR '/'
1081 #endif
1082 
1083   if (dirlen == 1 && dirname[0] == '/')
1084     /* DIRNAME is just "/", so normal prepending would get us "//foo".
1085        We want "/foo" instead, so don't prepend any chars from DIRNAME.  */
1086     dirlen = 0;
1087 #if defined __MSDOS__ || defined WINDOWS32
1088   else if (dirlen > 1)
1089     {
1090       if (dirname[dirlen - 1] == '/')
1091     /* DIRNAME is "d:/".  Don't prepend the slash from DIRNAME.  */
1092     --dirlen;
1093       else if (dirname[dirlen - 1] == ':')
1094     {
1095       /* DIRNAME is "d:".  Use `:' instead of `/'.  */
1096       --dirlen;
1097       sep_char = ':';
1098     }
1099     }
1100 #endif
1101 
1102   for (i = 0; i < n; ++i)
1103     {
1104       size_t eltlen = strlen (array[i]) + 1;
1105       char *new = (char *) malloc (dirlen + 1 + eltlen);
1106       if (new == NULL)
1107     {
1108       while (i > 0)
1109         free ((__ptr_t) array[--i]);
1110       return 1;
1111     }
1112 
1113 #ifdef HAVE_MEMPCPY
1114       {
1115     char *endp = (char *) mempcpy (new, dirname, dirlen);
1116     *endp++ = DIRSEP_CHAR;
1117     mempcpy (endp, array[i], eltlen);
1118       }
1119 #else
1120       memcpy (new, dirname, dirlen);
1121       new[dirlen] = DIRSEP_CHAR;
1122       memcpy (&new[dirlen + 1], array[i], eltlen);
1123 #endif
1124       free ((__ptr_t) array[i]);
1125       array[i] = new;
1126     }
1127 
1128   return 0;
1129 }
1130 
1131 
1132 /* We must not compile this function twice.  */
1133 #if !defined _LIBC || !defined NO_GLOB_PATTERN_P
1134 /* Return nonzero if PATTERN contains any metacharacters.
1135    Metacharacters can be quoted with backslashes if QUOTE is nonzero.  */
1136 int
__glob_pattern_p(pattern,quote)1137 __glob_pattern_p (pattern, quote)
1138      const char *pattern;
1139      int quote;
1140 {
1141   register const char *p;
1142   int open = 0;
1143 
1144   for (p = pattern; *p != '\0'; ++p)
1145     switch (*p)
1146       {
1147       case '?':
1148       case '*':
1149     return 1;
1150 
1151       case '\\':
1152     if (quote && p[1] != '\0')
1153       ++p;
1154     break;
1155 
1156       case '[':
1157     open = 1;
1158     break;
1159 
1160       case ']':
1161     if (open)
1162       return 1;
1163     break;
1164       }
1165 
1166   return 0;
1167 }
1168 # ifdef _LIBC
1169 weak_alias (__glob_pattern_p, glob_pattern_p)
1170 # endif
1171 #endif
1172 
1173 
1174 /* Like `glob', but PATTERN is a final pathname component,
1175    and matches are searched for in DIRECTORY.
1176    The GLOB_NOSORT bit in FLAGS is ignored.  No sorting is ever done.
1177    The GLOB_APPEND flag is assumed to be set (always appends).  */
1178 static int
1179 glob_in_dir (pattern, directory, flags, errfunc, pglob)
1180      const char *pattern;
1181      const char *directory;
1182      int flags;
1183      int (*errfunc) __P ((const char *, int));
1184      glob_t *pglob;
1185 {
1186   __ptr_t stream = NULL;
1187 
1188   struct globlink
1189     {
1190       struct globlink *next;
1191       char *name;
1192     };
1193   struct globlink *names = NULL;
1194   size_t nfound;
1195   int meta;
1196   int save;
1197 
1198   meta = __glob_pattern_p (pattern, !(flags & GLOB_NOESCAPE));
1199   if (meta == 0)
1200     {
1201       if (flags & (GLOB_NOCHECK|GLOB_NOMAGIC))
1202     /* We need not do any tests.  The PATTERN contains no meta
1203        characters and we must not return an error therefore the
1204        result will always contain exactly one name.  */
1205     flags |= GLOB_NOCHECK;
1206       else
1207     {
1208       /* Since we use the normal file functions we can also use stat()
1209          to verify the file is there.  */
1210       struct stat st;
1211       size_t patlen = strlen (pattern);
1212       size_t dirlen = strlen (directory);
1213       char *fullname = (char *) __alloca (dirlen + 1 + patlen + 1);
1214 
1215 # ifdef HAVE_MEMPCPY
1216       mempcpy (mempcpy (mempcpy (fullname, directory, dirlen),
1217                         GOLD_SLASH_CHR, 1),
1218                pattern, patlen + 1);
1219 # else
1220       memcpy (fullname, directory, dirlen);
1221       fullname[dirlen] = GOLD_SLASH_CHR;
1222       memcpy (&fullname[dirlen + 1], pattern, patlen + 1);
1223 # endif
1224       if (((flags & GLOB_ALTDIRFUNC)
1225            ? (*pglob->gl_stat) (fullname, &st)
1226            : __stat (fullname, &st)) == 0)
1227         /* We found this file to be existing.  Now tell the rest
1228            of the function to copy this name into the result.  */
1229         flags |= GLOB_NOCHECK;
1230     }
1231 
1232       nfound = 0;
1233     }
1234   else
1235     {
1236       if (pattern[0] == '\0')
1237     {
1238       /* This is a special case for matching directories like in
1239          "*a/".  */
1240       names = (struct globlink *) __alloca (sizeof (struct globlink));
1241       names->name = (char *) malloc (1);
1242       if (names->name == NULL)
1243         goto memory_error;
1244       names->name[0] = '\0';
1245       names->next = NULL;
1246       nfound = 1;
1247       meta = 0;
1248     }
1249       else
1250     {
1251       stream = ((flags & GLOB_ALTDIRFUNC)
1252             ? (*pglob->gl_opendir) (directory)
1253             : (__ptr_t) opendir (directory));
1254       if (stream == NULL)
1255         {
1256           if ((errfunc != NULL && (*errfunc) (directory, errno))
1257           || (flags & GLOB_ERR))
1258         return GLOB_ABORTED;
1259           nfound = 0;
1260           meta = 0;
1261         }
1262       else
1263         {
1264           int fnm_flags = ((!(flags & GLOB_PERIOD) ? FNM_PERIOD : 0)
1265                    | ((flags & GLOB_NOESCAPE) ? FNM_NOESCAPE : 0)
1266 #if defined _AMIGA || defined VMS
1267                    | FNM_CASEFOLD
1268 #endif
1269                    );
1270           nfound = 0;
1271           flags |= GLOB_MAGCHAR;
1272 
1273           while (1)
1274         {
1275           const char *name;
1276           size_t len;
1277           struct dirent *d = ((flags & GLOB_ALTDIRFUNC)
1278                       ? (*pglob->gl_readdir) (stream)
1279                       : readdir ((DIR *) stream));
1280           if (d == NULL)
1281             break;
1282           if (! REAL_DIR_ENTRY (d))
1283             continue;
1284 
1285 #ifdef HAVE_D_TYPE
1286           /* If we shall match only directories use the information
1287              provided by the dirent call if possible.  */
1288           if ((flags & GLOB_ONLYDIR)
1289               && d->d_type != DT_UNKNOWN && d->d_type != DT_DIR)
1290             continue;
1291 #endif
1292 
1293           name = d->d_name;
1294 
1295           if (fnmatch (pattern, name, fnm_flags) == 0)
1296             {
1297               struct globlink *new = (struct globlink *)
1298             __alloca (sizeof (struct globlink));
1299               len = NAMLEN (d);
1300               new->name = (char *) malloc (len + 1);
1301               if (new->name == NULL)
1302             goto memory_error;
1303 #ifdef HAVE_MEMPCPY
1304               *((char *) mempcpy ((__ptr_t) new->name, name, len))
1305             = '\0';
1306 #else
1307               memcpy ((__ptr_t) new->name, name, len);
1308               new->name[len] = '\0';
1309 #endif
1310               new->next = names;
1311               names = new;
1312               ++nfound;
1313             }
1314         }
1315         }
1316     }
1317     }
1318 
1319   if (nfound == 0 && (flags & GLOB_NOCHECK))
1320     {
1321       size_t len = strlen (pattern);
1322       nfound = 1;
1323       names = (struct globlink *) __alloca (sizeof (struct globlink));
1324       names->next = NULL;
1325       names->name = (char *) malloc (len + 1);
1326       if (names->name == NULL)
1327     goto memory_error;
1328 #ifdef HAVE_MEMPCPY
1329       *((char *) mempcpy (names->name, pattern, len)) = '\0';
1330 #else
1331       memcpy (names->name, pattern, len);
1332       names->name[len] = '\0';
1333 #endif
1334     }
1335 
1336   if (nfound != 0)
1337     {
1338       pglob->gl_pathv
1339     = (char **) realloc (pglob->gl_pathv,
1340                  (pglob->gl_pathc +
1341                   ((flags & GLOB_DOOFFS) ? pglob->gl_offs : 0) +
1342                   nfound + 1) *
1343                  sizeof (char *));
1344       if (pglob->gl_pathv == NULL)
1345     goto memory_error;
1346 
1347       if (flags & GLOB_DOOFFS)
1348     while (pglob->gl_pathc < pglob->gl_offs)
1349       pglob->gl_pathv[pglob->gl_pathc++] = NULL;
1350 
1351       for (; names != NULL; names = names->next)
1352     pglob->gl_pathv[pglob->gl_pathc++] = names->name;
1353       pglob->gl_pathv[pglob->gl_pathc] = NULL;
1354 
1355       pglob->gl_flags = flags;
1356     }
1357 
1358   save = errno;
1359   if (stream != NULL)
1360     {
1361       if (flags & GLOB_ALTDIRFUNC)
1362     (*pglob->gl_closedir) (stream);
1363       else
1364     closedir ((DIR *) stream);
1365     }
1366   __set_errno (save);
1367 
1368   return nfound == 0 ? GLOB_NOMATCH : 0;
1369 
1370  memory_error:
1371   {
1372     int save = errno;
1373     if (flags & GLOB_ALTDIRFUNC)
1374       (*pglob->gl_closedir) (stream);
1375     else
1376       closedir ((DIR *) stream);
1377     __set_errno (save);
1378   }
1379   while (names != NULL)
1380     {
1381       if (names->name != NULL)
1382     free ((__ptr_t) names->name);
1383       names = names->next;
1384     }
1385   return GLOB_NOSPACE;
1386 }
1387 
1388 #endif  /* Not ELIDE_CODE.  */
1389