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