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