1/* Copyright (C) 1991-2017 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, see
16 <http://www.gnu.org/licenses/>. */
17
18#ifdef HAVE_CONFIG_H
19# include <config.h>
20#endif
21
22#include <glob.h>
23
24#include <errno.h>
25#include <sys/types.h>
26#include <sys/stat.h>
27#include <stdbool.h>
28#include <stddef.h>
29#include <stdint.h>
30
31/* Outcomment the following line for production quality code. */
32/* #define NDEBUG 1 */
33#include <assert.h>
34
35#include <stdio.h> /* Needed on stupid SunOS for assert. */
36
37#if !defined _LIBC || !defined GLOB_ONLY_P
38#if defined HAVE_UNISTD_H || defined _LIBC
39# include <unistd.h>
40# ifndef POSIX
41# ifdef _POSIX_VERSION
42# define POSIX
43# endif
44# endif
45#endif
46
47#include <pwd.h>
48
49#if defined HAVE_STDINT_H || defined _LIBC
50# include <stdint.h>
51#elif !defined UINTPTR_MAX
52# define UINTPTR_MAX (~((size_t) 0))
53#endif
54
55#include <errno.h>
56#ifndef __set_errno
57# define __set_errno(val) errno = (val)
58#endif
59
60#if defined HAVE_DIRENT_H || defined __GNU_LIBRARY__
61# include <dirent.h>
62#else
63# define dirent direct
64# ifdef HAVE_SYS_NDIR_H
65# include <sys/ndir.h>
66# endif
67# ifdef HAVE_SYS_DIR_H
68# include <sys/dir.h>
69# endif
70# ifdef HAVE_NDIR_H
71# include <ndir.h>
72# endif
73# ifdef HAVE_VMSDIR_H
74# include "vmsdir.h"
75# endif /* HAVE_VMSDIR_H */
76#endif
77
78#include <stdlib.h>
79#include <string.h>
80#include <alloca.h>
81
82#ifdef _LIBC
83# undef strdup
84# define strdup(str) __strdup (str)
85# define sysconf(id) __sysconf (id)
86# define closedir(dir) __closedir (dir)
87# define opendir(name) __opendir (name)
88# define readdir(str) __readdir64 (str)
89# define getpwnam_r(name, bufp, buf, len, res) \
90 __getpwnam_r (name, bufp, buf, len, res)
91# ifndef __stat64
92# define __stat64(fname, buf) __xstat64 (_STAT_VER, fname, buf)
93# endif
94# define struct_stat64 struct stat64
95#else /* !_LIBC */
96# include "getlogin_r.h"
97# include "mempcpy.h"
98# include "stat-macros.h"
99# include "strdup.h"
100# define __stat64(fname, buf) stat (fname, buf)
101# define struct_stat64 struct stat
102# define __stat(fname, buf) stat (fname, buf)
103# define __alloca alloca
104# define __readdir readdir
105# define __readdir64 readdir64
106# define __glob_pattern_p glob_pattern_p
107#endif /* _LIBC */
108
109#include <fnmatch.h>
110
111#ifdef _SC_GETPW_R_SIZE_MAX
112# define GETPW_R_SIZE_MAX() sysconf (_SC_GETPW_R_SIZE_MAX)
113#else
114# define GETPW_R_SIZE_MAX() (-1)
115#endif
116#ifdef _SC_LOGIN_NAME_MAX
117# define GET_LOGIN_NAME_MAX() sysconf (_SC_LOGIN_NAME_MAX)
118#else
119# define GET_LOGIN_NAME_MAX() (-1)
120#endif
121
122static const char *next_brace_sub (const char *begin, int flags) __THROWNL;
123
124/* A representation of a directory entry which does not depend on the
125 layout of struct dirent, or the size of ino_t. */
126struct readdir_result
127{
128 const char *name;
129# if defined _DIRENT_HAVE_D_TYPE || defined HAVE_STRUCT_DIRENT_D_TYPE
130 uint8_t type;
131# endif
132 bool skip_entry;
133};
134
135# if defined _DIRENT_HAVE_D_TYPE || defined HAVE_STRUCT_DIRENT_D_TYPE
136/* Initializer based on the d_type member of struct dirent. */
137# define D_TYPE_TO_RESULT(source) (source)->d_type,
138
139/* True if the directory entry D might be a symbolic link. */
140static bool
141readdir_result_might_be_symlink (struct readdir_result d)
142{
143 return d.type == DT_UNKNOWN || d.type == DT_LNK;
144}
145
146/* True if the directory entry D might be a directory. */
147static bool
148readdir_result_might_be_dir (struct readdir_result d)
149{
150 return d.type == DT_DIR || readdir_result_might_be_symlink (d);
151}
152# else /* defined _DIRENT_HAVE_D_TYPE || defined HAVE_STRUCT_DIRENT_D_TYPE */
153# define D_TYPE_TO_RESULT(source)
154
155/* If we do not have type information, symbolic links and directories
156 are always a possibility. */
157
158static bool
159readdir_result_might_be_symlink (struct readdir_result d)
160{
161 return true;
162}
163
164static bool
165readdir_result_might_be_dir (struct readdir_result d)
166{
167 return true;
168}
169
170# endif /* defined _DIRENT_HAVE_D_TYPE || defined HAVE_STRUCT_DIRENT_D_TYPE */
171
172# if (defined POSIX || defined WINDOWS32) && !defined __GNU_LIBRARY__
173/* Initializer for skip_entry. POSIX does not require that the d_ino
174 field be present, and some systems do not provide it. */
175# define D_INO_TO_RESULT(source) false,
176# else
177# define D_INO_TO_RESULT(source) (source)->d_ino == 0,
178# endif
179
180/* Construct an initializer for a struct readdir_result object from a
181 struct dirent *. No copy of the name is made. */
182#define READDIR_RESULT_INITIALIZER(source) \
183 { \
184 source->d_name, \
185 D_TYPE_TO_RESULT (source) \
186 D_INO_TO_RESULT (source) \
187 }
188
189#endif /* !defined _LIBC || !defined GLOB_ONLY_P */
190
191/* Call gl_readdir on STREAM. This macro can be overridden to reduce
192 type safety if an old interface version needs to be supported. */
193#ifndef GL_READDIR
194# define GL_READDIR(pglob, stream) ((pglob)->gl_readdir (stream))
195#endif
196
197/* Extract name and type from directory entry. No copy of the name is
198 made. If SOURCE is NULL, result name is NULL. Keep in sync with
199 convert_dirent64 below. */
200static struct readdir_result
201convert_dirent (const struct dirent *source)
202{
203 if (source == NULL)
204 {
205 struct readdir_result result = { NULL, };
206 return result;
207 }
208 struct readdir_result result = READDIR_RESULT_INITIALIZER (source);
209 return result;
210}
211
212#ifndef COMPILE_GLOB64
213/* Like convert_dirent, but works on struct dirent64 instead. Keep in
214 sync with convert_dirent above. */
215static struct readdir_result
216convert_dirent64 (const struct dirent64 *source)
217{
218 if (source == NULL)
219 {
220 struct readdir_result result = { NULL, };
221 return result;
222 }
223 struct readdir_result result = READDIR_RESULT_INITIALIZER (source);
224 return result;
225}
226#endif
227
228
229#ifndef attribute_hidden
230# define attribute_hidden
231#endif
232
233static int glob_in_dir (const char *pattern, const char *directory,
234 int flags, int (*errfunc) (const char *, int),
235 glob_t *pglob, size_t alloca_used);
236extern int __glob_pattern_type (const char *pattern, int quote)
237 attribute_hidden;
238
239#if !defined _LIBC || !defined GLOB_ONLY_P
240static int prefix_array (const char *prefix, char **array, size_t n) __THROWNL;
241static int collated_compare (const void *, const void *) __THROWNL;
242
243
244/* Find the end of the sub-pattern in a brace expression. */
245static const char *
246next_brace_sub (const char *cp, int flags)
247{
248 size_t depth = 0;
249 while (*cp != '\0')
250 if ((flags & GLOB_NOESCAPE) == 0 && *cp == '\\')
251 {
252 if (*++cp == '\0')
253 break;
254 ++cp;
255 }
256 else
257 {
258 if ((*cp == '}' && depth-- == 0) || (*cp == ',' && depth == 0))
259 break;
260
261 if (*cp++ == '{')
262 depth++;
263 }
264
265 return *cp != '\0' ? cp : NULL;
266}
267
268#endif /* !defined _LIBC || !defined GLOB_ONLY_P */
269
270/* Do glob searching for PATTERN, placing results in PGLOB.
271 The bits defined above may be set in FLAGS.
272 If a directory cannot be opened or read and ERRFUNC is not nil,
273 it is called with the pathname that caused the error, and the
274 `errno' value from the failing call; if it returns non-zero
275 `glob' returns GLOB_ABORTED; if it returns zero, the error is ignored.
276 If memory cannot be allocated for PGLOB, GLOB_NOSPACE is returned.
277 Otherwise, `glob' returns zero. */
278int
279#ifdef GLOB_ATTRIBUTE
280GLOB_ATTRIBUTE
281#endif
282glob (const char *pattern, int flags, int (*errfunc) (const char *, int),
283 glob_t *pglob)
284{
285 const char *filename;
286 char *dirname = NULL;
287 size_t dirlen;
288 int status;
289 size_t oldcount;
290 int meta;
291 int dirname_modified;
292 int malloc_dirname = 0;
293 glob_t dirs;
294 int retval = 0;
295#ifdef _LIBC
296 size_t alloca_used = 0;
297#endif
298
299 if (pattern == NULL || pglob == NULL || (flags & ~__GLOB_FLAGS) != 0)
300 {
301 __set_errno (EINVAL);
302 return -1;
303 }
304
305 /* POSIX requires all slashes to be matched. This means that with
306 a trailing slash we must match only directories. */
307 if (pattern[0] && pattern[strlen (pattern) - 1] == '/')
308 flags |= GLOB_ONLYDIR;
309
310 if (!(flags & GLOB_DOOFFS))
311 /* Have to do this so `globfree' knows where to start freeing. It
312 also makes all the code that uses gl_offs simpler. */
313 pglob->gl_offs = 0;
314
315 if (!(flags & GLOB_APPEND))
316 {
317 pglob->gl_pathc = 0;
318 if (!(flags & GLOB_DOOFFS))
319 pglob->gl_pathv = NULL;
320 else
321 {
322 size_t i;
323
324 if (pglob->gl_offs >= ~((size_t) 0) / sizeof (char *))
325 return GLOB_NOSPACE;
326
327 pglob->gl_pathv = (char **) malloc ((pglob->gl_offs + 1)
328 * sizeof (char *));
329 if (pglob->gl_pathv == NULL)
330 return GLOB_NOSPACE;
331
332 for (i = 0; i <= pglob->gl_offs; ++i)
333 pglob->gl_pathv[i] = NULL;
334 }
335 }
336
337 if (flags & GLOB_BRACE)
338 {
339 const char *begin;
340
341 if (flags & GLOB_NOESCAPE)
342 begin = strchr (pattern, '{');
343 else
344 {
345 begin = pattern;
346 while (1)
347 {
348 if (*begin == '\0')
349 {
350 begin = NULL;
351 break;
352 }
353
354 if (*begin == '\\' && begin[1] != '\0')
355 ++begin;
356 else if (*begin == '{')
357 break;
358
359 ++begin;
360 }
361 }
362
363 if (begin != NULL)
364 {
365 /* Allocate working buffer large enough for our work. Note that
366 we have at least an opening and closing brace. */
367 size_t firstc;
368 char *alt_start;
369 const char *p;
370 const char *next;
371 const char *rest;
372 size_t rest_len;
373 char *onealt;
374 size_t pattern_len = strlen (pattern) - 1;
375#ifdef _LIBC
376 int alloca_onealt = __libc_use_alloca (alloca_used + pattern_len);
377 if (alloca_onealt)
378 onealt = alloca_account (pattern_len, alloca_used);
379 else
380#endif
381 {
382 onealt = (char *) malloc (pattern_len);
383 if (onealt == NULL)
384 return GLOB_NOSPACE;
385 }
386
387 /* We know the prefix for all sub-patterns. */
388 alt_start = mempcpy (onealt, pattern, begin - pattern);
389
390 /* Find the first sub-pattern and at the same time find the
391 rest after the closing brace. */
392 next = next_brace_sub (begin + 1, flags);
393 if (next == NULL)
394 {
395 /* It is an illegal expression. */
396 illegal_brace:
397#ifdef _LIBC
398 if (__glibc_unlikely (!alloca_onealt))
399#endif
400 free (onealt);
401 flags &= ~GLOB_BRACE;
402 goto no_brace;
403 }
404
405 /* Now find the end of the whole brace expression. */
406 rest = next;
407 while (*rest != '}')
408 {
409 rest = next_brace_sub (rest + 1, flags);
410 if (rest == NULL)
411 /* It is an illegal expression. */
412 goto illegal_brace;
413 }
414 /* Please note that we now can be sure the brace expression
415 is well-formed. */
416 rest_len = strlen (++rest) + 1;
417
418 /* We have a brace expression. BEGIN points to the opening {,
419 NEXT points past the terminator of the first element, and END
420 points past the final }. We will accumulate result names from
421 recursive runs for each brace alternative in the buffer using
422 GLOB_APPEND. */
423 firstc = pglob->gl_pathc;
424
425 p = begin + 1;
426 while (1)
427 {
428 int result;
429
430 /* Construct the new glob expression. */
431 mempcpy (mempcpy (alt_start, p, next - p), rest, rest_len);
432
433 result = glob (onealt,
434 ((flags & ~(GLOB_NOCHECK | GLOB_NOMAGIC))
435 | GLOB_APPEND), errfunc, pglob);
436
437 /* If we got an error, return it. */
438 if (result && result != GLOB_NOMATCH)
439 {
440#ifdef _LIBC
441 if (__glibc_unlikely (!alloca_onealt))
442#endif
443 free (onealt);
444 if (!(flags & GLOB_APPEND))
445 {
446 globfree (pglob);
447 pglob->gl_pathc = 0;
448 }
449 return result;
450 }
451
452 if (*next == '}')
453 /* We saw the last entry. */
454 break;
455
456 p = next + 1;
457 next = next_brace_sub (p, flags);
458 assert (next != NULL);
459 }
460
461#ifdef _LIBC
462 if (__glibc_unlikely (!alloca_onealt))
463#endif
464 free (onealt);
465
466 if (pglob->gl_pathc != firstc)
467 /* We found some entries. */
468 return 0;
469 else if (!(flags & (GLOB_NOCHECK|GLOB_NOMAGIC)))
470 return GLOB_NOMATCH;
471 }
472 }
473
474 no_brace:
475 oldcount = pglob->gl_pathc + pglob->gl_offs;
476
477 /* Find the filename. */
478 filename = strrchr (pattern, '/');
479#if defined __MSDOS__ || defined WINDOWS32
480 /* The case of "d:pattern". Since `:' is not allowed in
481 file names, we can safely assume that wherever it
482 happens in pattern, it signals the filename part. This
483 is so we could some day support patterns like "[a-z]:foo". */
484 if (filename == NULL)
485 filename = strchr (pattern, ':');
486#endif /* __MSDOS__ || WINDOWS32 */
487 dirname_modified = 0;
488 if (filename == NULL)
489 {
490 /* This can mean two things: a simple name or "~name". The latter
491 case is nothing but a notation for a directory. */
492 if ((flags & (GLOB_TILDE|GLOB_TILDE_CHECK)) && pattern[0] == '~')
493 {
494 dirname = (char *) pattern;
495 dirlen = strlen (pattern);
496
497 /* Set FILENAME to NULL as a special flag. This is ugly but
498 other solutions would require much more code. We test for
499 this special case below. */
500 filename = NULL;
501 }
502 else
503 {
504 if (__glibc_unlikely (pattern[0] == '\0'))
505 {
506 dirs.gl_pathv = NULL;
507 goto no_matches;
508 }
509
510 filename = pattern;
511#ifdef _AMIGA
512 dirname = (char *) "";
513#else
514 dirname = (char *) ".";
515#endif
516 dirlen = 0;
517 }
518 }
519 else if (filename == pattern
520 || (filename == pattern + 1 && pattern[0] == '\\'
521 && (flags & GLOB_NOESCAPE) == 0))
522 {
523 /* "/pattern" or "\\/pattern". */
524 dirname = (char *) "/";
525 dirlen = 1;
526 ++filename;
527 }
528 else
529 {
530 char *newp;
531 dirlen = filename - pattern;
532#if defined __MSDOS__ || defined WINDOWS32
533 if (*filename == ':'
534 || (filename > pattern + 1 && filename[-1] == ':'))
535 {
536 char *drive_spec;
537
538 ++dirlen;
539 drive_spec = (char *) __alloca (dirlen + 1);
540 *((char *) mempcpy (drive_spec, pattern, dirlen)) = '\0';
541 /* For now, disallow wildcards in the drive spec, to
542 prevent infinite recursion in glob. */
543 if (__glob_pattern_p (drive_spec, !(flags & GLOB_NOESCAPE)))
544 return GLOB_NOMATCH;
545 /* If this is "d:pattern", we need to copy `:' to DIRNAME
546 as well. If it's "d:/pattern", don't remove the slash
547 from "d:/", since "d:" and "d:/" are not the same.*/
548 }
549#endif
550#ifdef _LIBC
551 if (__libc_use_alloca (alloca_used + dirlen + 1))
552 newp = alloca_account (dirlen + 1, alloca_used);
553 else
554#endif
555 {
556 newp = malloc (dirlen + 1);
557 if (newp == NULL)
558 return GLOB_NOSPACE;
559 malloc_dirname = 1;
560 }
561 *((char *) mempcpy (newp, pattern, dirlen)) = '\0';
562 dirname = newp;
563 ++filename;
564
565 if (filename[0] == '\0'
566#if defined __MSDOS__ || defined WINDOWS32
567 && dirname[dirlen - 1] != ':'
568 && (dirlen < 3 || dirname[dirlen - 2] != ':'
569 || dirname[dirlen - 1] != '/')
570#endif
571 && dirlen > 1)
572 /* "pattern/". Expand "pattern", appending slashes. */
573 {
574 int orig_flags = flags;
575 if (!(flags & GLOB_NOESCAPE) && dirname[dirlen - 1] == '\\')
576 {
577 /* "pattern\\/". Remove the final backslash if it hasn't
578 been quoted. */
579 char *p = (char *) &dirname[dirlen - 1];
580
581 while (p > dirname && p[-1] == '\\') --p;
582 if ((&dirname[dirlen] - p) & 1)
583 {
584 *(char *) &dirname[--dirlen] = '\0';
585 flags &= ~(GLOB_NOCHECK | GLOB_NOMAGIC);
586 }
587 }
588 int val = glob (dirname, flags | GLOB_MARK, errfunc, pglob);
589 if (val == 0)
590 pglob->gl_flags = ((pglob->gl_flags & ~GLOB_MARK)
591 | (flags & GLOB_MARK));
592 else if (val == GLOB_NOMATCH && flags != orig_flags)
593 {
594 /* Make sure globfree (&dirs); is a nop. */
595 dirs.gl_pathv = NULL;
596 flags = orig_flags;
597 oldcount = pglob->gl_pathc + pglob->gl_offs;
598 goto no_matches;
599 }
600 retval = val;
601 goto out;
602 }
603 }
604
605#ifndef VMS
606 if ((flags & (GLOB_TILDE|GLOB_TILDE_CHECK)) && dirname[0] == '~')
607 {
608 if (dirname[1] == '\0' || dirname[1] == '/'
609 || (!(flags & GLOB_NOESCAPE) && dirname[1] == '\\'
610 && (dirname[2] == '\0' || dirname[2] == '/')))
611 {
612 /* Look up home directory. */
613 char *home_dir = getenv ("HOME");
614 int malloc_home_dir = 0;
615# ifdef _AMIGA
616 if (home_dir == NULL || home_dir[0] == '\0')
617 home_dir = "SYS:";
618# else
619# ifdef WINDOWS32
620 if (home_dir == NULL || home_dir[0] == '\0')
621 home_dir = "c:/users/default"; /* poor default */
622# else
623 if (home_dir == NULL || home_dir[0] == '\0')
624 {
625 int success;
626 char *name;
627 size_t buflen = GET_LOGIN_NAME_MAX () + 1;
628
629 if (buflen == 0)
630 /* `sysconf' does not support _SC_LOGIN_NAME_MAX. Try
631 a moderate value. */
632 buflen = 20;
633 name = alloca_account (buflen, alloca_used);
634
635 success = __getlogin_r (name, buflen) == 0;
636 if (success)
637 {
638 struct passwd *p;
639# if defined HAVE_GETPWNAM_R || defined _LIBC
640 long int pwbuflen = GETPW_R_SIZE_MAX ();
641 char *pwtmpbuf;
642 struct passwd pwbuf;
643 int malloc_pwtmpbuf = 0;
644 int save = errno;
645
646# ifndef _LIBC
647 if (pwbuflen == -1)
648 /* `sysconf' does not support _SC_GETPW_R_SIZE_MAX.
649 Try a moderate value. */
650 pwbuflen = 1024;
651# endif
652 if (__libc_use_alloca (alloca_used + pwbuflen))
653 pwtmpbuf = alloca_account (pwbuflen, alloca_used);
654 else
655 {
656 pwtmpbuf = malloc (pwbuflen);
657 if (pwtmpbuf == NULL)
658 {
659 retval = GLOB_NOSPACE;
660 goto out;
661 }
662 malloc_pwtmpbuf = 1;
663 }
664
665 while (getpwnam_r (name, &pwbuf, pwtmpbuf, pwbuflen, &p)
666 != 0)
667 {
668 if (errno != ERANGE)
669 {
670 p = NULL;
671 break;
672 }
673
674 if (!malloc_pwtmpbuf
675 && __libc_use_alloca (alloca_used
676 + 2 * pwbuflen))
677 pwtmpbuf = extend_alloca_account (pwtmpbuf, pwbuflen,
678 2 * pwbuflen,
679 alloca_used);
680 else
681 {
682 char *newp = realloc (malloc_pwtmpbuf
683 ? pwtmpbuf : NULL,
684 2 * pwbuflen);
685 if (newp == NULL)
686 {
687 if (__glibc_unlikely (malloc_pwtmpbuf))
688 free (pwtmpbuf);
689 retval = GLOB_NOSPACE;
690 goto out;
691 }
692 pwtmpbuf = newp;
693 pwbuflen = 2 * pwbuflen;
694 malloc_pwtmpbuf = 1;
695 }
696 __set_errno (save);
697 }
698# else
699 p = getpwnam (name);
700# endif
701 if (p != NULL)
702 {
703 if (!malloc_pwtmpbuf)
704 home_dir = p->pw_dir;
705 else
706 {
707 size_t home_dir_len = strlen (p->pw_dir) + 1;
708 if (__libc_use_alloca (alloca_used + home_dir_len))
709 home_dir = alloca_account (home_dir_len,
710 alloca_used);
711 else
712 {
713 home_dir = malloc (home_dir_len);
714 if (home_dir == NULL)
715 {
716 free (pwtmpbuf);
717 retval = GLOB_NOSPACE;
718 goto out;
719 }
720 malloc_home_dir = 1;
721 }
722 memcpy (home_dir, p->pw_dir, home_dir_len);
723
724 free (pwtmpbuf);
725 }
726 }
727 }
728 }
729 if (home_dir == NULL || home_dir[0] == '\0')
730 {
731 if (flags & GLOB_TILDE_CHECK)
732 {
733 if (__glibc_unlikely (malloc_home_dir))
734 free (home_dir);
735 retval = GLOB_NOMATCH;
736 goto out;
737 }
738 else
739 home_dir = (char *) "~"; /* No luck. */
740 }
741# endif /* WINDOWS32 */
742# endif
743 /* Now construct the full directory. */
744 if (dirname[1] == '\0')
745 {
746 if (__glibc_unlikely (malloc_dirname))
747 free (dirname);
748
749 dirname = home_dir;
750 dirlen = strlen (dirname);
751 malloc_dirname = malloc_home_dir;
752 }
753 else
754 {
755 char *newp;
756 size_t home_len = strlen (home_dir);
757 int use_alloca = __libc_use_alloca (alloca_used
758 + home_len + dirlen);
759 if (use_alloca)
760 newp = alloca_account (home_len + dirlen, alloca_used);
761 else
762 {
763 newp = malloc (home_len + dirlen);
764 if (newp == NULL)
765 {
766 if (__glibc_unlikely (malloc_home_dir))
767 free (home_dir);
768 retval = GLOB_NOSPACE;
769 goto out;
770 }
771 }
772
773 mempcpy (mempcpy (newp, home_dir, home_len),
774 &dirname[1], dirlen);
775
776 if (__glibc_unlikely (malloc_dirname))
777 free (dirname);
778
779 dirname = newp;
780 dirlen += home_len - 1;
781 malloc_dirname = !use_alloca;
782 }
783 dirname_modified = 1;
784 }
785# if !defined _AMIGA && !defined WINDOWS32
786 else
787 {
788 char *end_name = strchr (dirname, '/');
789 char *user_name;
790 int malloc_user_name = 0;
791 char *unescape = NULL;
792
793 if (!(flags & GLOB_NOESCAPE))
794 {
795 if (end_name == NULL)
796 {
797 unescape = strchr (dirname, '\\');
798 if (unescape)
799 end_name = strchr (unescape, '\0');
800 }
801 else
802 unescape = memchr (dirname, '\\', end_name - dirname);
803 }
804 if (end_name == NULL)
805 user_name = dirname + 1;
806 else
807 {
808 char *newp;
809 if (__libc_use_alloca (alloca_used + (end_name - dirname)))
810 newp = alloca_account (end_name - dirname, alloca_used);
811 else
812 {
813 newp = malloc (end_name - dirname);
814 if (newp == NULL)
815 {
816 retval = GLOB_NOSPACE;
817 goto out;
818 }
819 malloc_user_name = 1;
820 }
821 if (unescape != NULL)
822 {
823 char *p = mempcpy (newp, dirname + 1,
824 unescape - dirname - 1);
825 char *q = unescape;
826 while (*q != '\0')
827 {
828 if (*q == '\\')
829 {
830 if (q[1] == '\0')
831 {
832 /* "~fo\\o\\" unescape to user_name "foo\\",
833 but "~fo\\o\\/" unescape to user_name
834 "foo". */
835 if (filename == NULL)
836 *p++ = '\\';
837 break;
838 }
839 ++q;
840 }
841 *p++ = *q++;
842 }
843 *p = '\0';
844 }
845 else
846 *((char *) mempcpy (newp, dirname + 1, end_name - dirname))
847 = '\0';
848 user_name = newp;
849 }
850
851 /* Look up specific user's home directory. */
852 {
853 struct passwd *p;
854# if defined HAVE_GETPWNAM_R || defined _LIBC
855 long int buflen = GETPW_R_SIZE_MAX ();
856 char *pwtmpbuf;
857 int malloc_pwtmpbuf = 0;
858 struct passwd pwbuf;
859 int save = errno;
860
861# ifndef _LIBC
862 if (buflen == -1)
863 /* `sysconf' does not support _SC_GETPW_R_SIZE_MAX. Try a
864 moderate value. */
865 buflen = 1024;
866# endif
867 if (__libc_use_alloca (alloca_used + buflen))
868 pwtmpbuf = alloca_account (buflen, alloca_used);
869 else
870 {
871 pwtmpbuf = malloc (buflen);
872 if (pwtmpbuf == NULL)
873 {
874 nomem_getpw:
875 if (__glibc_unlikely (malloc_user_name))
876 free (user_name);
877 retval = GLOB_NOSPACE;
878 goto out;
879 }
880 malloc_pwtmpbuf = 1;
881 }
882
883 while (getpwnam_r (user_name, &pwbuf, pwtmpbuf, buflen, &p) != 0)
884 {
885 if (errno != ERANGE)
886 {
887 p = NULL;
888 break;
889 }
890 if (!malloc_pwtmpbuf
891 && __libc_use_alloca (alloca_used + 2 * buflen))
892 pwtmpbuf = extend_alloca_account (pwtmpbuf, buflen,
893 2 * buflen, alloca_used);
894 else
895 {
896 char *newp = realloc (malloc_pwtmpbuf ? pwtmpbuf : NULL,
897 2 * buflen);
898 if (newp == NULL)
899 {
900 if (__glibc_unlikely (malloc_pwtmpbuf))
901 free (pwtmpbuf);
902 goto nomem_getpw;
903 }
904 pwtmpbuf = newp;
905 malloc_pwtmpbuf = 1;
906 }
907 __set_errno (save);
908 }
909# else
910 p = getpwnam (user_name);
911# endif
912
913 if (__glibc_unlikely (malloc_user_name))
914 free (user_name);
915
916 /* If we found a home directory use this. */
917 if (p != NULL)
918 {
919 size_t home_len = strlen (p->pw_dir);
920 size_t rest_len = end_name == NULL ? 0 : strlen (end_name);
921
922 if (__glibc_unlikely (malloc_dirname))
923 free (dirname);
924 malloc_dirname = 0;
925
926 if (__libc_use_alloca (alloca_used + home_len + rest_len + 1))
927 dirname = alloca_account (home_len + rest_len + 1,
928 alloca_used);
929 else
930 {
931 dirname = malloc (home_len + rest_len + 1);
932 if (dirname == NULL)
933 {
934 if (__glibc_unlikely (malloc_pwtmpbuf))
935 free (pwtmpbuf);
936 retval = GLOB_NOSPACE;
937 goto out;
938 }
939 malloc_dirname = 1;
940 }
941 *((char *) mempcpy (mempcpy (dirname, p->pw_dir, home_len),
942 end_name, rest_len)) = '\0';
943
944 dirlen = home_len + rest_len;
945 dirname_modified = 1;
946
947 if (__glibc_unlikely (malloc_pwtmpbuf))
948 free (pwtmpbuf);
949 }
950 else
951 {
952 if (__glibc_unlikely (malloc_pwtmpbuf))
953 free (pwtmpbuf);
954
955 if (flags & GLOB_TILDE_CHECK)
956 /* We have to regard it as an error if we cannot find the
957 home directory. */
958 return GLOB_NOMATCH;
959 }
960 }
961 }
962# endif /* Not Amiga && not WINDOWS32. */
963 }
964#endif /* Not VMS. */
965
966 /* Now test whether we looked for "~" or "~NAME". In this case we
967 can give the answer now. */
968 if (filename == NULL)
969 {
970 struct stat st;
971 struct_stat64 st64;
972
973 /* Return the directory if we don't check for error or if it exists. */
974 if ((flags & GLOB_NOCHECK)
975 || (((__builtin_expect (flags & GLOB_ALTDIRFUNC, 0))
976 ? ((*pglob->gl_stat) (dirname, &st) == 0
977 && S_ISDIR (st.st_mode))
978 : (__stat64 (dirname, &st64) == 0 && S_ISDIR (st64.st_mode)))))
979 {
980 size_t newcount = pglob->gl_pathc + pglob->gl_offs;
981 char **new_gl_pathv;
982
983 if (newcount > UINTPTR_MAX - (1 + 1)
984 || newcount + 1 + 1 > ~((size_t) 0) / sizeof (char *))
985 {
986 nospace:
987 free (pglob->gl_pathv);
988 pglob->gl_pathv = NULL;
989 pglob->gl_pathc = 0;
990 return GLOB_NOSPACE;
991 }
992
993 new_gl_pathv
994 = (char **) realloc (pglob->gl_pathv,
995 (newcount + 1 + 1) * sizeof (char *));
996 if (new_gl_pathv == NULL)
997 goto nospace;
998 pglob->gl_pathv = new_gl_pathv;
999
1000 if (flags & GLOB_MARK)
1001 {
1002 char *p;
1003 pglob->gl_pathv[newcount] = malloc (dirlen + 2);
1004 if (pglob->gl_pathv[newcount] == NULL)
1005 goto nospace;
1006 p = mempcpy (pglob->gl_pathv[newcount], dirname, dirlen);
1007 p[0] = '/';
1008 p[1] = '\0';
1009 }
1010 else
1011 {
1012 pglob->gl_pathv[newcount] = strdup (dirname);
1013 if (pglob->gl_pathv[newcount] == NULL)
1014 goto nospace;
1015 }
1016 pglob->gl_pathv[++newcount] = NULL;
1017 ++pglob->gl_pathc;
1018 pglob->gl_flags = flags;
1019
1020 return 0;
1021 }
1022
1023 /* Not found. */
1024 return GLOB_NOMATCH;
1025 }
1026
1027 meta = __glob_pattern_type (dirname, !(flags & GLOB_NOESCAPE));
1028 /* meta is 1 if correct glob pattern containing metacharacters.
1029 If meta has bit (1 << 2) set, it means there was an unterminated
1030 [ which we handle the same, using fnmatch. Broken unterminated
1031 pattern bracket expressions ought to be rare enough that it is
1032 not worth special casing them, fnmatch will do the right thing. */
1033 if (meta & 5)
1034 {
1035 /* The directory name contains metacharacters, so we
1036 have to glob for the directory, and then glob for
1037 the pattern in each directory found. */
1038 size_t i;
1039
1040 if (!(flags & GLOB_NOESCAPE) && dirlen > 0 && dirname[dirlen - 1] == '\\')
1041 {
1042 /* "foo\\/bar". Remove the final backslash from dirname
1043 if it has not been quoted. */
1044 char *p = (char *) &dirname[dirlen - 1];
1045
1046 while (p > dirname && p[-1] == '\\') --p;
1047 if ((&dirname[dirlen] - p) & 1)
1048 *(char *) &dirname[--dirlen] = '\0';
1049 }
1050
1051 if (__glibc_unlikely ((flags & GLOB_ALTDIRFUNC) != 0))
1052 {
1053 /* Use the alternative access functions also in the recursive
1054 call. */
1055 dirs.gl_opendir = pglob->gl_opendir;
1056 dirs.gl_readdir = pglob->gl_readdir;
1057 dirs.gl_closedir = pglob->gl_closedir;
1058 dirs.gl_stat = pglob->gl_stat;
1059 dirs.gl_lstat = pglob->gl_lstat;
1060 }
1061
1062 status = glob (dirname,
1063 ((flags & (GLOB_ERR | GLOB_NOESCAPE
1064 | GLOB_ALTDIRFUNC))
1065 | GLOB_NOSORT | GLOB_ONLYDIR),
1066 errfunc, &dirs);
1067 if (status != 0)
1068 {
1069 if ((flags & GLOB_NOCHECK) == 0 || status != GLOB_NOMATCH)
1070 return status;
1071 goto no_matches;
1072 }
1073
1074 /* We have successfully globbed the preceding directory name.
1075 For each name we found, call glob_in_dir on it and FILENAME,
1076 appending the results to PGLOB. */
1077 for (i = 0; i < dirs.gl_pathc; ++i)
1078 {
1079 size_t old_pathc;
1080
1081#ifdef SHELL
1082 {
1083 /* Make globbing interruptible in the bash shell. */
1084 extern int interrupt_state;
1085
1086 if (interrupt_state)
1087 {
1088 globfree (&dirs);
1089 return GLOB_ABORTED;
1090 }
1091 }
1092#endif /* SHELL. */
1093
1094 old_pathc = pglob->gl_pathc;
1095 status = glob_in_dir (filename, dirs.gl_pathv[i],
1096 ((flags | GLOB_APPEND)
1097 & ~(GLOB_NOCHECK | GLOB_NOMAGIC)),
1098 errfunc, pglob, alloca_used);
1099 if (status == GLOB_NOMATCH)
1100 /* No matches in this directory. Try the next. */
1101 continue;
1102
1103 if (status != 0)
1104 {
1105 globfree (&dirs);
1106 globfree (pglob);
1107 pglob->gl_pathc = 0;
1108 return status;
1109 }
1110
1111 /* Stick the directory on the front of each name. */
1112 if (prefix_array (dirs.gl_pathv[i],
1113 &pglob->gl_pathv[old_pathc + pglob->gl_offs],
1114 pglob->gl_pathc - old_pathc))
1115 {
1116 globfree (&dirs);
1117 globfree (pglob);
1118 pglob->gl_pathc = 0;
1119 return GLOB_NOSPACE;
1120 }
1121 }
1122
1123 flags |= GLOB_MAGCHAR;
1124
1125 /* We have ignored the GLOB_NOCHECK flag in the `glob_in_dir' calls.
1126 But if we have not found any matching entry and the GLOB_NOCHECK
1127 flag was set we must return the input pattern itself. */
1128 if (pglob->gl_pathc + pglob->gl_offs == oldcount)
1129 {
1130 no_matches:
1131 /* No matches. */
1132 if (flags & GLOB_NOCHECK)
1133 {
1134 size_t newcount = pglob->gl_pathc + pglob->gl_offs;
1135 char **new_gl_pathv;
1136
1137 if (newcount > UINTPTR_MAX - 2
1138 || newcount + 2 > ~((size_t) 0) / sizeof (char *))
1139 {
1140 nospace2:
1141 globfree (&dirs);
1142 return GLOB_NOSPACE;
1143 }
1144
1145 new_gl_pathv = (char **) realloc (pglob->gl_pathv,
1146 (newcount + 2)
1147 * sizeof (char *));
1148 if (new_gl_pathv == NULL)
1149 goto nospace2;
1150 pglob->gl_pathv = new_gl_pathv;
1151
1152 pglob->gl_pathv[newcount] = __strdup (pattern);
1153 if (pglob->gl_pathv[newcount] == NULL)
1154 {
1155 globfree (&dirs);
1156 globfree (pglob);
1157 pglob->gl_pathc = 0;
1158 return GLOB_NOSPACE;
1159 }
1160
1161 ++pglob->gl_pathc;
1162 ++newcount;
1163
1164 pglob->gl_pathv[newcount] = NULL;
1165 pglob->gl_flags = flags;
1166 }
1167 else
1168 {
1169 globfree (&dirs);
1170 return GLOB_NOMATCH;
1171 }
1172 }
1173
1174 globfree (&dirs);
1175 }
1176 else
1177 {
1178 size_t old_pathc = pglob->gl_pathc;
1179 int orig_flags = flags;
1180
1181 if (meta & 2)
1182 {
1183 char *p = strchr (dirname, '\\'), *q;
1184 /* We need to unescape the dirname string. It is certainly
1185 allocated by alloca, as otherwise filename would be NULL
1186 or dirname wouldn't contain backslashes. */
1187 q = p;
1188 do
1189 {
1190 if (*p == '\\')
1191 {
1192 *q = *++p;
1193 --dirlen;
1194 }
1195 else
1196 *q = *p;
1197 ++q;
1198 }
1199 while (*p++ != '\0');
1200 dirname_modified = 1;
1201 }
1202 if (dirname_modified)
1203 flags &= ~(GLOB_NOCHECK | GLOB_NOMAGIC);
1204 status = glob_in_dir (filename, dirname, flags, errfunc, pglob,
1205 alloca_used);
1206 if (status != 0)
1207 {
1208 if (status == GLOB_NOMATCH && flags != orig_flags
1209 && pglob->gl_pathc + pglob->gl_offs == oldcount)
1210 {
1211 /* Make sure globfree (&dirs); is a nop. */
1212 dirs.gl_pathv = NULL;
1213 flags = orig_flags;
1214 goto no_matches;
1215 }
1216 return status;
1217 }
1218
1219 if (dirlen > 0)
1220 {
1221 /* Stick the directory on the front of each name. */
1222 if (prefix_array (dirname,
1223 &pglob->gl_pathv[old_pathc + pglob->gl_offs],
1224 pglob->gl_pathc - old_pathc))
1225 {
1226 globfree (pglob);
1227 pglob->gl_pathc = 0;
1228 return GLOB_NOSPACE;
1229 }
1230 }
1231 }
1232
1233 if (flags & GLOB_MARK)
1234 {
1235 /* Append slashes to directory names. */
1236 size_t i;
1237 struct stat st;
1238 struct_stat64 st64;
1239
1240 for (i = oldcount; i < pglob->gl_pathc + pglob->gl_offs; ++i)
1241 if ((__builtin_expect (flags & GLOB_ALTDIRFUNC, 0)
1242 ? ((*pglob->gl_stat) (pglob->gl_pathv[i], &st) == 0
1243 && S_ISDIR (st.st_mode))
1244 : (__stat64 (pglob->gl_pathv[i], &st64) == 0
1245 && S_ISDIR (st64.st_mode))))
1246 {
1247 size_t len = strlen (pglob->gl_pathv[i]) + 2;
1248 char *new = realloc (pglob->gl_pathv[i], len);
1249 if (new == NULL)
1250 {
1251 globfree (pglob);
1252 pglob->gl_pathc = 0;
1253 return GLOB_NOSPACE;
1254 }
1255 strcpy (&new[len - 2], "/");
1256 pglob->gl_pathv[i] = new;
1257 }
1258 }
1259
1260 if (!(flags & GLOB_NOSORT))
1261 {
1262 /* Sort the vector. */
1263 qsort (&pglob->gl_pathv[oldcount],
1264 pglob->gl_pathc + pglob->gl_offs - oldcount,
1265 sizeof (char *), collated_compare);
1266 }
1267
1268 out:
1269 if (__glibc_unlikely (malloc_dirname))
1270 free (dirname);
1271
1272 return retval;
1273}
1274#if defined _LIBC && !defined glob
1275libc_hidden_def (glob)
1276#endif
1277
1278
1279#if !defined _LIBC || !defined GLOB_ONLY_P
1280
1281/* Free storage allocated in PGLOB by a previous `glob' call. */
1282void
1283globfree (glob_t *pglob)
1284{
1285 if (pglob->gl_pathv != NULL)
1286 {
1287 size_t i;
1288 for (i = 0; i < pglob->gl_pathc; ++i)
1289 free (pglob->gl_pathv[pglob->gl_offs + i]);
1290 free (pglob->gl_pathv);
1291 pglob->gl_pathv = NULL;
1292 }
1293}
1294#if defined _LIBC && !defined globfree
1295libc_hidden_def (globfree)
1296#endif
1297
1298
1299/* Do a collated comparison of A and B. */
1300static int
1301collated_compare (const void *a, const void *b)
1302{
1303 const char *const s1 = *(const char *const * const) a;
1304 const char *const s2 = *(const char *const * const) b;
1305
1306 if (s1 == s2)
1307 return 0;
1308 if (s1 == NULL)
1309 return 1;
1310 if (s2 == NULL)
1311 return -1;
1312 return strcoll (s1, s2);
1313}
1314
1315
1316/* Prepend DIRNAME to each of N members of ARRAY, replacing ARRAY's
1317 elements in place. Return nonzero if out of memory, zero if successful.
1318 A slash is inserted between DIRNAME and each elt of ARRAY,
1319 unless DIRNAME is just "/". Each old element of ARRAY is freed. */
1320static int
1321prefix_array (const char *dirname, char **array, size_t n)
1322{
1323 size_t i;
1324 size_t dirlen = strlen (dirname);
1325#if defined __MSDOS__ || defined WINDOWS32
1326 int sep_char = '/';
1327# define DIRSEP_CHAR sep_char
1328#else
1329# define DIRSEP_CHAR '/'
1330#endif
1331
1332 if (dirlen == 1 && dirname[0] == '/')
1333 /* DIRNAME is just "/", so normal prepending would get us "//foo".
1334 We want "/foo" instead, so don't prepend any chars from DIRNAME. */
1335 dirlen = 0;
1336#if defined __MSDOS__ || defined WINDOWS32
1337 else if (dirlen > 1)
1338 {
1339 if (dirname[dirlen - 1] == '/' && dirname[dirlen - 2] == ':')
1340 /* DIRNAME is "d:/". Don't prepend the slash from DIRNAME. */
1341 --dirlen;
1342 else if (dirname[dirlen - 1] == ':')
1343 {
1344 /* DIRNAME is "d:". Use `:' instead of `/'. */
1345 --dirlen;
1346 sep_char = ':';
1347 }
1348 }
1349#endif
1350
1351 for (i = 0; i < n; ++i)
1352 {
1353 size_t eltlen = strlen (array[i]) + 1;
1354 char *new = (char *) malloc (dirlen + 1 + eltlen);
1355 if (new == NULL)
1356 {
1357 while (i > 0)
1358 free (array[--i]);
1359 return 1;
1360 }
1361
1362 {
1363 char *endp = mempcpy (new, dirname, dirlen);
1364 *endp++ = DIRSEP_CHAR;
1365 mempcpy (endp, array[i], eltlen);
1366 }
1367 free (array[i]);
1368 array[i] = new;
1369 }
1370
1371 return 0;
1372}
1373
1374
1375/* We must not compile this function twice. */
1376#if !defined _LIBC || !defined NO_GLOB_PATTERN_P
1377int
1378__glob_pattern_type (const char *pattern, int quote)
1379{
1380 const char *p;
1381 int ret = 0;
1382
1383 for (p = pattern; *p != '\0'; ++p)
1384 switch (*p)
1385 {
1386 case '?':
1387 case '*':
1388 return 1;
1389
1390 case '\\':
1391 if (quote)
1392 {
1393 if (p[1] != '\0')
1394 ++p;
1395 ret |= 2;
1396 }
1397 break;
1398
1399 case '[':
1400 ret |= 4;
1401 break;
1402
1403 case ']':
1404 if (ret & 4)
1405 return 1;
1406 break;
1407 }
1408
1409 return ret;
1410}
1411
1412/* Return nonzero if PATTERN contains any metacharacters.
1413 Metacharacters can be quoted with backslashes if QUOTE is nonzero. */
1414int
1415__glob_pattern_p (const char *pattern, int quote)
1416{
1417 return __glob_pattern_type (pattern, quote) == 1;
1418}
1419# ifdef _LIBC
1420weak_alias (__glob_pattern_p, glob_pattern_p)
1421# endif
1422#endif
1423
1424#endif /* !GLOB_ONLY_P */
1425
1426
1427/* We put this in a separate function mainly to allow the memory
1428 allocated with alloca to be recycled. */
1429#if !defined _LIBC || !defined GLOB_ONLY_P
1430static int
1431__attribute_noinline__
1432link_exists2_p (const char *dir, size_t dirlen, const char *fname,
1433 glob_t *pglob
1434# ifndef _LIBC
1435 , int flags
1436# endif
1437 )
1438{
1439 size_t fnamelen = strlen (fname);
1440 char *fullname = (char *) __alloca (dirlen + 1 + fnamelen + 1);
1441 struct stat st;
1442# ifndef _LIBC
1443 struct_stat64 st64;
1444# endif
1445
1446 mempcpy (mempcpy (mempcpy (fullname, dir, dirlen), "/", 1),
1447 fname, fnamelen + 1);
1448
1449# ifdef _LIBC
1450 return (*pglob->gl_stat) (fullname, &st) == 0;
1451# else
1452 return ((__builtin_expect (flags & GLOB_ALTDIRFUNC, 0)
1453 ? (*pglob->gl_stat) (fullname, &st)
1454 : __stat64 (fullname, &st64)) == 0);
1455# endif
1456}
1457# ifdef _LIBC
1458# define link_exists_p(dfd, dirname, dirnamelen, fname, pglob, flags) \
1459 (__builtin_expect (flags & GLOB_ALTDIRFUNC, 0) \
1460 ? link_exists2_p (dirname, dirnamelen, fname, pglob) \
1461 : ({ struct stat64 st64; \
1462 __fxstatat64 (_STAT_VER, dfd, fname, &st64, 0) == 0; }))
1463# else
1464# define link_exists_p(dfd, dirname, dirnamelen, fname, pglob, flags) \
1465 link_exists2_p (dirname, dirnamelen, fname, pglob, flags)
1466# endif
1467#endif
1468
1469
1470/* Like `glob', but PATTERN is a final pathname component,
1471 and matches are searched for in DIRECTORY.
1472 The GLOB_NOSORT bit in FLAGS is ignored. No sorting is ever done.
1473 The GLOB_APPEND flag is assumed to be set (always appends). */
1474static int
1475glob_in_dir (const char *pattern, const char *directory, int flags,
1476 int (*errfunc) (const char *, int),
1477 glob_t *pglob, size_t alloca_used)
1478{
1479 size_t dirlen = strlen (directory);
1480 void *stream = NULL;
1481 struct globnames
1482 {
1483 struct globnames *next;
1484 size_t count;
1485 char *name[64];
1486 };
1487#define INITIAL_COUNT sizeof (init_names.name) / sizeof (init_names.name[0])
1488 struct globnames init_names;
1489 struct globnames *names = &init_names;
1490 struct globnames *names_alloca = &init_names;
1491 size_t nfound = 0;
1492 size_t cur = 0;
1493 int meta;
1494 int save;
1495
1496 alloca_used += sizeof (init_names);
1497
1498 init_names.next = NULL;
1499 init_names.count = INITIAL_COUNT;
1500
1501 meta = __glob_pattern_type (pattern, !(flags & GLOB_NOESCAPE));
1502 if (meta == 0 && (flags & (GLOB_NOCHECK|GLOB_NOMAGIC)))
1503 {
1504 /* We need not do any tests. The PATTERN contains no meta
1505 characters and we must not return an error therefore the
1506 result will always contain exactly one name. */
1507 flags |= GLOB_NOCHECK;
1508 }
1509 else if (meta == 0)
1510 {
1511 /* Since we use the normal file functions we can also use stat()
1512 to verify the file is there. */
1513 union
1514 {
1515 struct stat st;
1516 struct_stat64 st64;
1517 } ust;
1518 size_t patlen = strlen (pattern);
1519 int alloca_fullname = __libc_use_alloca (alloca_used
1520 + dirlen + 1 + patlen + 1);
1521 char *fullname;
1522 if (alloca_fullname)
1523 fullname = alloca_account (dirlen + 1 + patlen + 1, alloca_used);
1524 else
1525 {
1526 fullname = malloc (dirlen + 1 + patlen + 1);
1527 if (fullname == NULL)
1528 return GLOB_NOSPACE;
1529 }
1530
1531 mempcpy (mempcpy (mempcpy (fullname, directory, dirlen),
1532 "/", 1),
1533 pattern, patlen + 1);
1534 if ((__builtin_expect (flags & GLOB_ALTDIRFUNC, 0)
1535 ? (*pglob->gl_stat) (fullname, &ust.st)
1536 : __stat64 (fullname, &ust.st64)) == 0)
1537 /* We found this file to be existing. Now tell the rest
1538 of the function to copy this name into the result. */
1539 flags |= GLOB_NOCHECK;
1540
1541 if (__glibc_unlikely (!alloca_fullname))
1542 free (fullname);
1543 }
1544 else
1545 {
1546 stream = (__builtin_expect (flags & GLOB_ALTDIRFUNC, 0)
1547 ? (*pglob->gl_opendir) (directory)
1548 : opendir (directory));
1549 if (stream == NULL)
1550 {
1551 if (errno != ENOTDIR
1552 && ((errfunc != NULL && (*errfunc) (directory, errno))
1553 || (flags & GLOB_ERR)))
1554 return GLOB_ABORTED;
1555 }
1556 else
1557 {
1558#ifdef _LIBC
1559 int dfd = (__builtin_expect (flags & GLOB_ALTDIRFUNC, 0)
1560 ? -1 : dirfd ((DIR *) stream));
1561#endif
1562 int fnm_flags = ((!(flags & GLOB_PERIOD) ? FNM_PERIOD : 0)
1563 | ((flags & GLOB_NOESCAPE) ? FNM_NOESCAPE : 0)
1564#if defined _AMIGA || defined VMS
1565 | FNM_CASEFOLD
1566#endif
1567 );
1568 flags |= GLOB_MAGCHAR;
1569
1570 while (1)
1571 {
1572 struct readdir_result d;
1573 {
1574 if (__builtin_expect (flags & GLOB_ALTDIRFUNC, 0))
1575 d = convert_dirent (GL_READDIR (pglob, stream));
1576 else
1577 {
1578#ifdef COMPILE_GLOB64
1579 d = convert_dirent (__readdir (stream));
1580#else
1581 d = convert_dirent64 (__readdir64 (stream));
1582#endif
1583 }
1584 }
1585 if (d.name == NULL)
1586 break;
1587 if (d.skip_entry)
1588 continue;
1589
1590 /* If we shall match only directories use the information
1591 provided by the dirent call if possible. */
1592 if ((flags & GLOB_ONLYDIR) && !readdir_result_might_be_dir (d))
1593 continue;
1594
1595 if (fnmatch (pattern, d.name, fnm_flags) == 0)
1596 {
1597 /* If the file we found is a symlink we have to
1598 make sure the target file exists. */
1599 if (!readdir_result_might_be_symlink (d)
1600 || link_exists_p (dfd, directory, dirlen, d.name,
1601 pglob, flags))
1602 {
1603 if (cur == names->count)
1604 {
1605 struct globnames *newnames;
1606 size_t count = names->count * 2;
1607 size_t size = (sizeof (struct globnames)
1608 + ((count - INITIAL_COUNT)
1609 * sizeof (char *)));
1610 if (__libc_use_alloca (alloca_used + size))
1611 newnames = names_alloca
1612 = alloca_account (size, alloca_used);
1613 else if ((newnames = malloc (size))
1614 == NULL)
1615 goto memory_error;
1616 newnames->count = count;
1617 newnames->next = names;
1618 names = newnames;
1619 cur = 0;
1620 }
1621 names->name[cur] = strdup (d.name);
1622 if (names->name[cur] == NULL)
1623 goto memory_error;
1624 ++cur;
1625 ++nfound;
1626 }
1627 }
1628 }
1629 }
1630 }
1631
1632 if (nfound == 0 && (flags & GLOB_NOCHECK))
1633 {
1634 size_t len = strlen (pattern);
1635 nfound = 1;
1636 names->name[cur] = (char *) malloc (len + 1);
1637 if (names->name[cur] == NULL)
1638 goto memory_error;
1639 *((char *) mempcpy (names->name[cur++], pattern, len)) = '\0';
1640 }
1641
1642 int result = GLOB_NOMATCH;
1643 if (nfound != 0)
1644 {
1645 result = 0;
1646
1647 if (pglob->gl_pathc > UINTPTR_MAX - pglob->gl_offs
1648 || pglob->gl_pathc + pglob->gl_offs > UINTPTR_MAX - nfound
1649 || pglob->gl_pathc + pglob->gl_offs + nfound > UINTPTR_MAX - 1
1650 || (pglob->gl_pathc + pglob->gl_offs + nfound + 1
1651 > UINTPTR_MAX / sizeof (char *)))
1652 goto memory_error;
1653
1654 char **new_gl_pathv;
1655 new_gl_pathv
1656 = (char **) realloc (pglob->gl_pathv,
1657 (pglob->gl_pathc + pglob->gl_offs + nfound + 1)
1658 * sizeof (char *));
1659 if (new_gl_pathv == NULL)
1660 {
1661 memory_error:
1662 while (1)
1663 {
1664 struct globnames *old = names;
1665 for (size_t i = 0; i < cur; ++i)
1666 free (names->name[i]);
1667 names = names->next;
1668 /* NB: we will not leak memory here if we exit without
1669 freeing the current block assigned to OLD. At least
1670 the very first block is always allocated on the stack
1671 and this is the block assigned to OLD here. */
1672 if (names == NULL)
1673 {
1674 assert (old == &init_names);
1675 break;
1676 }
1677 cur = names->count;
1678 if (old == names_alloca)
1679 names_alloca = names;
1680 else
1681 free (old);
1682 }
1683 result = GLOB_NOSPACE;
1684 }
1685 else
1686 {
1687 while (1)
1688 {
1689 struct globnames *old = names;
1690 for (size_t i = 0; i < cur; ++i)
1691 new_gl_pathv[pglob->gl_offs + pglob->gl_pathc++]
1692 = names->name[i];
1693 names = names->next;
1694 /* NB: we will not leak memory here if we exit without
1695 freeing the current block assigned to OLD. At least
1696 the very first block is always allocated on the stack
1697 and this is the block assigned to OLD here. */
1698 if (names == NULL)
1699 {
1700 assert (old == &init_names);
1701 break;
1702 }
1703 cur = names->count;
1704 if (old == names_alloca)
1705 names_alloca = names;
1706 else
1707 free (old);
1708 }
1709
1710 pglob->gl_pathv = new_gl_pathv;
1711
1712 pglob->gl_pathv[pglob->gl_offs + pglob->gl_pathc] = NULL;
1713
1714 pglob->gl_flags = flags;
1715 }
1716 }
1717
1718 if (stream != NULL)
1719 {
1720 save = errno;
1721 if (__glibc_unlikely (flags & GLOB_ALTDIRFUNC))
1722 (*pglob->gl_closedir) (stream);
1723 else
1724 closedir (stream);
1725 __set_errno (save);
1726 }
1727
1728 return result;
1729}
1730