1 /* Copyright (C) 1991-2018 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
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.
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.
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 <https://www.gnu.org/licenses/>. */
20 /* Don't use __attribute__ __nonnull__ in this compilation unit. Otherwise gcc
21 optimizes away the pattern == NULL test below. */
22 # define _GL_ARG_NONNULL(params)
31 #include <sys/types.h>
39 #if defined _WIN32 && ! defined __CYGWIN__
55 # define strdup(str) __strdup (str)
56 # define sysconf(id) __sysconf (id)
57 # define closedir(dir) __closedir (dir)
58 # define opendir(name) __opendir (name)
59 # define readdir(str) __readdir64 (str)
60 # define getpwnam_r(name, bufp, buf, len, res) \
61 __getpwnam_r (name, bufp, buf, len, res)
63 # define __lstat64(fname, buf) __lxstat64 (_STAT_VER, fname, buf)
66 # define __stat64(fname, buf) __xstat64 (_STAT_VER, fname, buf)
68 # define struct_stat64 struct stat64
69 # define FLEXIBLE_ARRAY_MEMBER
71 # define __getlogin_r(buf, len) getlogin_r (buf, len)
72 # define __lstat64(fname, buf) lstat (fname, buf)
73 # define __stat64(fname, buf) stat (fname, buf)
74 # define __fxstatat64(_, d, f, st, flag) fstatat (d, f, st, flag)
75 # define struct_stat64 struct stat
77 # define __alloca alloca
79 # define __readdir readdir
80 # define COMPILE_GLOB64
85 #include <flexmember.h>
86 #include <glob_internal.h>
87 #include <scratch_buffer.h>
89 static const char *next_brace_sub (const char *begin
, int flags
) __THROWNL
;
91 /* The type of ((struct dirent *) 0)->d_type is 'unsigned char' on most
92 platforms, but 'unsigned int' in the mingw from mingw.org. */
93 typedef uint_fast32_t dirent_type
;
95 #if !defined _LIBC && !defined HAVE_STRUCT_DIRENT_D_TYPE
96 /* Any distinct values will do here.
97 Undef any existing macros out of the way. */
101 # define DT_UNKNOWN 0
106 /* A representation of a directory entry which does not depend on the
107 layout of struct dirent, or the size of ino_t. */
108 struct readdir_result
111 #if defined _DIRENT_HAVE_D_TYPE || defined HAVE_STRUCT_DIRENT_D_TYPE
116 /* Initialize and return type member of struct readdir_result. */
118 readdir_result_type (struct readdir_result d
)
120 #if defined _DIRENT_HAVE_D_TYPE || defined HAVE_STRUCT_DIRENT_D_TYPE
121 # define D_TYPE_TO_RESULT(source) (source)->d_type,
124 # define D_TYPE_TO_RESULT(source)
129 /* Construct an initializer for a struct readdir_result object from a
130 struct dirent *. No copy of the name is made. */
131 #define READDIR_RESULT_INITIALIZER(source) \
134 D_TYPE_TO_RESULT (source) \
137 /* Call gl_readdir on STREAM. This macro can be overridden to reduce
138 type safety if an old interface version needs to be supported. */
140 # define GL_READDIR(pglob, stream) ((pglob)->gl_readdir (stream))
143 /* Extract name and type from directory entry. No copy of the name is
144 made. If SOURCE is NULL, result name is NULL. Keep in sync with
145 convert_dirent64 below. */
146 static struct readdir_result
147 convert_dirent (const struct dirent
*source
)
151 struct readdir_result result
= { NULL
, };
154 struct readdir_result result
= READDIR_RESULT_INITIALIZER (source
);
158 #ifndef COMPILE_GLOB64
159 /* Like convert_dirent, but works on struct dirent64 instead. Keep in
160 sync with convert_dirent above. */
161 static struct readdir_result
162 convert_dirent64 (const struct dirent64
*source
)
166 struct readdir_result result
= { NULL
, };
169 struct readdir_result result
= READDIR_RESULT_INITIALIZER (source
);
175 /* The results of opendir() in this file are not used with dirfd and fchdir,
176 and we do not leak fds to any single-threaded code that could use stdio,
177 therefore save some unnecessary recursion in fchdir.c and opendir_safer.c.
178 FIXME - if the kernel ever adds support for multi-thread safety for
179 avoiding standard fds, then we should use opendir_safer. */
180 # ifdef GNULIB_defined_opendir
183 # ifdef GNULIB_defined_closedir
187 /* Just use malloc. */
188 # define __libc_use_alloca(n) false
189 # define alloca_account(len, avar) ((void) (len), (void) (avar), (void *) 0)
190 # define extend_alloca_account(buf, len, newlen, avar) \
191 ((void) (buf), (void) (len), (void) (newlen), (void) (avar), (void *) 0)
194 /* Set *R = A + B. Return true if the answer is mathematically
195 incorrect due to overflow; in this case, *R is the low order
196 bits of the correct answer. */
199 size_add_wrapv (size_t a
, size_t b
, size_t *r
)
201 #if 5 <= __GNUC__ && !defined __ICC
202 return __builtin_add_overflow (a
, b
, r
);
210 glob_use_alloca (size_t alloca_used
, size_t len
)
213 return (!size_add_wrapv (alloca_used
, len
, &size
)
214 && __libc_use_alloca (size
));
217 static int glob_in_dir (const char *pattern
, const char *directory
,
218 int flags
, int (*errfunc
) (const char *, int),
219 glob_t
*pglob
, size_t alloca_used
);
220 static int prefix_array (const char *prefix
, char **array
, size_t n
) __THROWNL
;
221 static int collated_compare (const void *, const void *) __THROWNL
;
224 /* Return true if FILENAME is a directory or a symbolic link to a directory.
225 Use FLAGS and PGLOB to resolve the filename. */
227 is_dir (char const *filename
, int flags
, glob_t
const *pglob
)
231 return (__glibc_unlikely (flags
& GLOB_ALTDIRFUNC
)
232 ? pglob
->gl_stat (filename
, &st
) == 0 && S_ISDIR (st
.st_mode
)
233 : __stat64 (filename
, &st64
) == 0 && S_ISDIR (st64
.st_mode
));
236 /* Find the end of the sub-pattern in a brace expression. */
238 next_brace_sub (const char *cp
, int flags
)
242 if ((flags
& GLOB_NOESCAPE
) == 0 && *cp
== '\\')
250 if ((*cp
== '}' && depth
-- == 0) || (*cp
== ',' && depth
== 0))
257 return *cp
!= '\0' ? cp
: NULL
;
261 /* Do glob searching for PATTERN, placing results in PGLOB.
262 The bits defined above may be set in FLAGS.
263 If a directory cannot be opened or read and ERRFUNC is not nil,
264 it is called with the pathname that caused the error, and the
265 'errno' value from the failing call; if it returns non-zero
266 'glob' returns GLOB_ABORTED; if it returns zero, the error is ignored.
267 If memory cannot be allocated for PGLOB, GLOB_NOSPACE is returned.
268 Otherwise, 'glob' returns zero. */
270 #ifdef GLOB_ATTRIBUTE
273 glob (const char *pattern
, int flags
, int (*errfunc
) (const char *, int),
276 const char *filename
;
277 char *dirname
= NULL
;
282 int dirname_modified
;
283 int malloc_dirname
= 0;
286 size_t alloca_used
= 0;
288 if (pattern
== NULL
|| pglob
== NULL
|| (flags
& ~__GLOB_FLAGS
) != 0)
290 __set_errno (EINVAL
);
294 /* POSIX requires all slashes to be matched. This means that with
295 a trailing slash we must match only directories. */
296 if (pattern
[0] && pattern
[strlen (pattern
) - 1] == '/')
297 flags
|= GLOB_ONLYDIR
;
299 if (!(flags
& GLOB_DOOFFS
))
300 /* Have to do this so 'globfree' knows where to start freeing. It
301 also makes all the code that uses gl_offs simpler. */
304 if (!(flags
& GLOB_APPEND
))
307 if (!(flags
& GLOB_DOOFFS
))
308 pglob
->gl_pathv
= NULL
;
313 if (pglob
->gl_offs
>= ~((size_t) 0) / sizeof (char *))
316 pglob
->gl_pathv
= (char **) malloc ((pglob
->gl_offs
+ 1)
318 if (pglob
->gl_pathv
== NULL
)
321 for (i
= 0; i
<= pglob
->gl_offs
; ++i
)
322 pglob
->gl_pathv
[i
] = NULL
;
326 if (flags
& GLOB_BRACE
)
330 if (flags
& GLOB_NOESCAPE
)
331 begin
= strchr (pattern
, '{');
343 if (*begin
== '\\' && begin
[1] != '\0')
345 else if (*begin
== '{')
354 /* Allocate working buffer large enough for our work. Note that
355 we have at least an opening and closing brace. */
363 size_t pattern_len
= strlen (pattern
) - 1;
364 int alloca_onealt
= glob_use_alloca (alloca_used
, pattern_len
);
366 onealt
= alloca_account (pattern_len
, alloca_used
);
369 onealt
= malloc (pattern_len
);
374 /* We know the prefix for all sub-patterns. */
375 alt_start
= mempcpy (onealt
, pattern
, begin
- pattern
);
377 /* Find the first sub-pattern and at the same time find the
378 rest after the closing brace. */
379 next
= next_brace_sub (begin
+ 1, flags
);
382 /* It is an invalid expression. */
384 if (__glibc_unlikely (!alloca_onealt
))
386 flags
&= ~GLOB_BRACE
;
390 /* Now find the end of the whole brace expression. */
394 rest
= next_brace_sub (rest
+ 1, flags
);
396 /* It is an illegal expression. */
399 /* Please note that we now can be sure the brace expression
401 rest_len
= strlen (++rest
) + 1;
403 /* We have a brace expression. BEGIN points to the opening {,
404 NEXT points past the terminator of the first element, and END
405 points past the final }. We will accumulate result names from
406 recursive runs for each brace alternative in the buffer using
408 firstc
= pglob
->gl_pathc
;
415 /* Construct the new glob expression. */
416 mempcpy (mempcpy (alt_start
, p
, next
- p
), rest
, rest_len
);
418 result
= glob (onealt
,
419 ((flags
& ~(GLOB_NOCHECK
| GLOB_NOMAGIC
))
420 | GLOB_APPEND
), errfunc
, pglob
);
422 /* If we got an error, return it. */
423 if (result
&& result
!= GLOB_NOMATCH
)
425 if (__glibc_unlikely (!alloca_onealt
))
427 if (!(flags
& GLOB_APPEND
))
436 /* We saw the last entry. */
440 next
= next_brace_sub (p
, flags
);
441 assert (next
!= NULL
);
444 if (__glibc_unlikely (!alloca_onealt
))
447 if (pglob
->gl_pathc
!= firstc
)
448 /* We found some entries. */
450 else if (!(flags
& (GLOB_NOCHECK
|GLOB_NOMAGIC
)))
456 oldcount
= pglob
->gl_pathc
+ pglob
->gl_offs
;
458 /* Find the filename. */
459 filename
= strrchr (pattern
, '/');
461 #if defined __MSDOS__ || defined WINDOWS32
462 /* The case of "d:pattern". Since ':' is not allowed in
463 file names, we can safely assume that wherever it
464 happens in pattern, it signals the filename part. This
465 is so we could some day support patterns like "[a-z]:foo". */
466 if (filename
== NULL
)
467 filename
= strchr (pattern
, ':');
468 #endif /* __MSDOS__ || WINDOWS32 */
470 dirname_modified
= 0;
471 if (filename
== NULL
)
473 /* This can mean two things: a simple name or "~name". The latter
474 case is nothing but a notation for a directory. */
475 if ((flags
& (GLOB_TILDE
|GLOB_TILDE_CHECK
)) && pattern
[0] == '~')
477 dirname
= (char *) pattern
;
478 dirlen
= strlen (pattern
);
480 /* Set FILENAME to NULL as a special flag. This is ugly but
481 other solutions would require much more code. We test for
482 this special case below. */
487 if (__glibc_unlikely (pattern
[0] == '\0'))
489 dirs
.gl_pathv
= NULL
;
494 dirname
= (char *) ".";
498 else if (filename
== pattern
499 || (filename
== pattern
+ 1 && pattern
[0] == '\\'
500 && (flags
& GLOB_NOESCAPE
) == 0))
502 /* "/pattern" or "\\/pattern". */
503 dirname
= (char *) "/";
510 dirlen
= filename
- pattern
;
512 #if defined __MSDOS__ || defined WINDOWS32
514 || (filename
> pattern
+ 1 && filename
[-1] == ':'))
519 drive_spec
= __alloca (dirlen
+ 1);
520 *((char *) mempcpy (drive_spec
, pattern
, dirlen
)) = '\0';
521 /* For now, disallow wildcards in the drive spec, to
522 prevent infinite recursion in glob. */
523 if (__glob_pattern_p (drive_spec
, !(flags
& GLOB_NOESCAPE
)))
525 /* If this is "d:pattern", we need to copy ':' to DIRNAME
526 as well. If it's "d:/pattern", don't remove the slash
527 from "d:/", since "d:" and "d:/" are not the same.*/
531 if (glob_use_alloca (alloca_used
, dirlen
+ 1))
532 newp
= alloca_account (dirlen
+ 1, alloca_used
);
535 newp
= malloc (dirlen
+ 1);
540 *((char *) mempcpy (newp
, pattern
, dirlen
)) = '\0';
544 #if defined __MSDOS__ || defined WINDOWS32
545 bool drive_root
= (dirlen
> 1
546 && (dirname
[dirlen
- 1] == ':'
547 || (dirlen
> 2 && dirname
[dirlen
- 2] == ':'
548 && dirname
[dirlen
- 1] == '/')));
550 bool drive_root
= false;
553 if (filename
[0] == '\0' && dirlen
> 1 && !drive_root
)
554 /* "pattern/". Expand "pattern", appending slashes. */
556 int orig_flags
= flags
;
557 if (!(flags
& GLOB_NOESCAPE
) && dirname
[dirlen
- 1] == '\\')
559 /* "pattern\\/". Remove the final backslash if it hasn't
561 char *p
= (char *) &dirname
[dirlen
- 1];
563 while (p
> dirname
&& p
[-1] == '\\') --p
;
564 if ((&dirname
[dirlen
] - p
) & 1)
566 *(char *) &dirname
[--dirlen
] = '\0';
567 flags
&= ~(GLOB_NOCHECK
| GLOB_NOMAGIC
);
570 int val
= glob (dirname
, flags
| GLOB_MARK
, errfunc
, pglob
);
572 pglob
->gl_flags
= ((pglob
->gl_flags
& ~GLOB_MARK
)
573 | (flags
& GLOB_MARK
));
574 else if (val
== GLOB_NOMATCH
&& flags
!= orig_flags
)
576 /* Make sure globfree (&dirs); is a nop. */
577 dirs
.gl_pathv
= NULL
;
579 oldcount
= pglob
->gl_pathc
+ pglob
->gl_offs
;
587 if ((flags
& (GLOB_TILDE
|GLOB_TILDE_CHECK
)) && dirname
[0] == '~')
589 if (dirname
[1] == '\0' || dirname
[1] == '/'
590 || (!(flags
& GLOB_NOESCAPE
) && dirname
[1] == '\\'
591 && (dirname
[2] == '\0' || dirname
[2] == '/')))
593 /* Look up home directory. */
594 char *home_dir
= getenv ("HOME");
595 int malloc_home_dir
= 0;
596 if (home_dir
== NULL
|| home_dir
[0] == '\0')
599 /* Windows NT defines HOMEDRIVE and HOMEPATH. But give
600 preference to HOME, because the user can change HOME. */
601 const char *home_drive
= getenv ("HOMEDRIVE");
602 const char *home_path
= getenv ("HOMEPATH");
604 if (home_drive
!= NULL
&& home_path
!= NULL
)
606 size_t home_drive_len
= strlen (home_drive
);
607 size_t home_path_len
= strlen (home_path
);
608 char *mem
= alloca (home_drive_len
+ home_path_len
+ 1);
610 memcpy (mem
, home_drive
, home_drive_len
);
611 memcpy (mem
+ home_drive_len
, home_path
, home_path_len
+ 1);
615 home_dir
= "c:/users/default"; /* poor default */
620 struct scratch_buffer s
;
621 scratch_buffer_init (&s
);
625 err
= __getlogin_r (s
.data
, s
.length
);
628 # if defined HAVE_GETPWNAM_R || defined _LIBC
629 size_t ssize
= strlen (s
.data
) + 1;
630 char *sdata
= s
.data
;
631 err
= getpwnam_r (sdata
, &pwbuf
, sdata
+ ssize
,
632 s
.length
- ssize
, &p
);
634 p
= getpwnam (s
.data
);
641 if (!scratch_buffer_grow (&s
))
643 retval
= GLOB_NOSPACE
;
649 home_dir
= strdup (p
->pw_dir
);
652 scratch_buffer_free (&s
);
653 if (err
== 0 && home_dir
== NULL
)
655 retval
= GLOB_NOSPACE
;
658 #endif /* WINDOWS32 */
660 if (home_dir
== NULL
|| home_dir
[0] == '\0')
662 if (__glibc_unlikely (malloc_home_dir
))
664 if (flags
& GLOB_TILDE_CHECK
)
666 retval
= GLOB_NOMATCH
;
671 home_dir
= (char *) "~"; /* No luck. */
675 /* Now construct the full directory. */
676 if (dirname
[1] == '\0')
678 if (__glibc_unlikely (malloc_dirname
))
682 dirlen
= strlen (dirname
);
683 malloc_dirname
= malloc_home_dir
;
688 size_t home_len
= strlen (home_dir
);
689 int use_alloca
= glob_use_alloca (alloca_used
, home_len
+ dirlen
);
691 newp
= alloca_account (home_len
+ dirlen
, alloca_used
);
694 newp
= malloc (home_len
+ dirlen
);
697 if (__glibc_unlikely (malloc_home_dir
))
699 retval
= GLOB_NOSPACE
;
704 mempcpy (mempcpy (newp
, home_dir
, home_len
),
705 &dirname
[1], dirlen
);
707 if (__glibc_unlikely (malloc_dirname
))
711 dirlen
+= home_len
- 1;
712 malloc_dirname
= !use_alloca
;
714 if (__glibc_unlikely (malloc_home_dir
))
717 dirname_modified
= 1;
722 char *end_name
= strchr (dirname
, '/');
724 int malloc_user_name
= 0;
725 char *unescape
= NULL
;
727 if (!(flags
& GLOB_NOESCAPE
))
729 if (end_name
== NULL
)
731 unescape
= strchr (dirname
, '\\');
733 end_name
= strchr (unescape
, '\0');
736 unescape
= memchr (dirname
, '\\', end_name
- dirname
);
738 if (end_name
== NULL
)
739 user_name
= dirname
+ 1;
743 if (glob_use_alloca (alloca_used
, end_name
- dirname
))
744 newp
= alloca_account (end_name
- dirname
, alloca_used
);
747 newp
= malloc (end_name
- dirname
);
750 retval
= GLOB_NOSPACE
;
753 malloc_user_name
= 1;
755 if (unescape
!= NULL
)
757 char *p
= mempcpy (newp
, dirname
+ 1,
758 unescape
- dirname
- 1);
760 while (q
!= end_name
)
764 if (q
+ 1 == end_name
)
766 /* "~fo\\o\\" unescape to user_name "foo\\",
767 but "~fo\\o\\/" unescape to user_name
769 if (filename
== NULL
)
780 *((char *) mempcpy (newp
, dirname
+ 1, end_name
- dirname
- 1))
785 /* Look up specific user's home directory. */
788 struct scratch_buffer pwtmpbuf
;
789 scratch_buffer_init (&pwtmpbuf
);
791 # if defined HAVE_GETPWNAM_R || defined _LIBC
794 while (getpwnam_r (user_name
, &pwbuf
,
795 pwtmpbuf
.data
, pwtmpbuf
.length
, &p
)
798 if (!scratch_buffer_grow (&pwtmpbuf
))
800 retval
= GLOB_NOSPACE
;
805 p
= getpwnam (user_name
);
808 if (__glibc_unlikely (malloc_user_name
))
811 /* If we found a home directory use this. */
814 size_t home_len
= strlen (p
->pw_dir
);
815 size_t rest_len
= end_name
== NULL
? 0 : strlen (end_name
);
818 if (__glibc_unlikely (malloc_dirname
))
822 if (glob_use_alloca (alloca_used
, home_len
+ rest_len
+ 1))
823 dirname
= alloca_account (home_len
+ rest_len
+ 1,
827 dirname
= malloc (home_len
+ rest_len
+ 1);
830 scratch_buffer_free (&pwtmpbuf
);
831 retval
= GLOB_NOSPACE
;
836 d
= mempcpy (dirname
, p
->pw_dir
, home_len
);
837 if (end_name
!= NULL
)
838 d
= mempcpy (d
, end_name
, rest_len
);
841 dirlen
= home_len
+ rest_len
;
842 dirname_modified
= 1;
846 if (flags
& GLOB_TILDE_CHECK
)
848 /* We have to regard it as an error if we cannot find the
850 retval
= GLOB_NOMATCH
;
854 scratch_buffer_free (&pwtmpbuf
);
856 #endif /* !WINDOWS32 */
860 /* Now test whether we looked for "~" or "~NAME". In this case we
861 can give the answer now. */
862 if (filename
== NULL
)
864 size_t newcount
= pglob
->gl_pathc
+ pglob
->gl_offs
;
867 if (newcount
> SIZE_MAX
/ sizeof (char *) - 2)
870 free (pglob
->gl_pathv
);
871 pglob
->gl_pathv
= NULL
;
873 retval
= GLOB_NOSPACE
;
877 new_gl_pathv
= realloc (pglob
->gl_pathv
,
878 (newcount
+ 2) * sizeof (char *));
879 if (new_gl_pathv
== NULL
)
881 pglob
->gl_pathv
= new_gl_pathv
;
883 if (flags
& GLOB_MARK
&& is_dir (dirname
, flags
, pglob
))
886 pglob
->gl_pathv
[newcount
] = malloc (dirlen
+ 2);
887 if (pglob
->gl_pathv
[newcount
] == NULL
)
889 p
= mempcpy (pglob
->gl_pathv
[newcount
], dirname
, dirlen
);
892 if (__glibc_unlikely (malloc_dirname
))
897 if (__glibc_unlikely (malloc_dirname
))
898 pglob
->gl_pathv
[newcount
] = dirname
;
901 pglob
->gl_pathv
[newcount
] = strdup (dirname
);
902 if (pglob
->gl_pathv
[newcount
] == NULL
)
906 pglob
->gl_pathv
[++newcount
] = NULL
;
908 pglob
->gl_flags
= flags
;
913 meta
= __glob_pattern_type (dirname
, !(flags
& GLOB_NOESCAPE
));
914 /* meta is 1 if correct glob pattern containing metacharacters.
915 If meta has bit (1 << 2) set, it means there was an unterminated
916 [ which we handle the same, using fnmatch. Broken unterminated
917 pattern bracket expressions ought to be rare enough that it is
918 not worth special casing them, fnmatch will do the right thing. */
919 if (meta
& (GLOBPAT_SPECIAL
| GLOBPAT_BRACKET
))
921 /* The directory name contains metacharacters, so we
922 have to glob for the directory, and then glob for
923 the pattern in each directory found. */
926 if (!(flags
& GLOB_NOESCAPE
) && dirlen
> 0 && dirname
[dirlen
- 1] == '\\')
928 /* "foo\\/bar". Remove the final backslash from dirname
929 if it has not been quoted. */
930 char *p
= (char *) &dirname
[dirlen
- 1];
932 while (p
> dirname
&& p
[-1] == '\\') --p
;
933 if ((&dirname
[dirlen
] - p
) & 1)
934 *(char *) &dirname
[--dirlen
] = '\0';
937 if (__glibc_unlikely ((flags
& GLOB_ALTDIRFUNC
) != 0))
939 /* Use the alternative access functions also in the recursive
941 dirs
.gl_opendir
= pglob
->gl_opendir
;
942 dirs
.gl_readdir
= pglob
->gl_readdir
;
943 dirs
.gl_closedir
= pglob
->gl_closedir
;
944 dirs
.gl_stat
= pglob
->gl_stat
;
945 dirs
.gl_lstat
= pglob
->gl_lstat
;
948 status
= glob (dirname
,
949 ((flags
& (GLOB_ERR
| GLOB_NOESCAPE
951 | GLOB_NOSORT
| GLOB_ONLYDIR
),
955 if ((flags
& GLOB_NOCHECK
) == 0 || status
!= GLOB_NOMATCH
)
963 /* We have successfully globbed the preceding directory name.
964 For each name we found, call glob_in_dir on it and FILENAME,
965 appending the results to PGLOB. */
966 for (i
= 0; i
< dirs
.gl_pathc
; ++i
)
970 old_pathc
= pglob
->gl_pathc
;
971 status
= glob_in_dir (filename
, dirs
.gl_pathv
[i
],
972 ((flags
| GLOB_APPEND
)
973 & ~(GLOB_NOCHECK
| GLOB_NOMAGIC
)),
974 errfunc
, pglob
, alloca_used
);
975 if (status
== GLOB_NOMATCH
)
976 /* No matches in this directory. Try the next. */
988 /* Stick the directory on the front of each name. */
989 if (prefix_array (dirs
.gl_pathv
[i
],
990 &pglob
->gl_pathv
[old_pathc
+ pglob
->gl_offs
],
991 pglob
->gl_pathc
- old_pathc
))
996 retval
= GLOB_NOSPACE
;
1001 flags
|= GLOB_MAGCHAR
;
1003 /* We have ignored the GLOB_NOCHECK flag in the 'glob_in_dir' calls.
1004 But if we have not found any matching entry and the GLOB_NOCHECK
1005 flag was set we must return the input pattern itself. */
1006 if (pglob
->gl_pathc
+ pglob
->gl_offs
== oldcount
)
1010 if (flags
& GLOB_NOCHECK
)
1012 size_t newcount
= pglob
->gl_pathc
+ pglob
->gl_offs
;
1013 char **new_gl_pathv
;
1015 if (newcount
> SIZE_MAX
/ sizeof (char *) - 2)
1019 retval
= GLOB_NOSPACE
;
1023 new_gl_pathv
= realloc (pglob
->gl_pathv
,
1024 (newcount
+ 2) * sizeof (char *));
1025 if (new_gl_pathv
== NULL
)
1027 pglob
->gl_pathv
= new_gl_pathv
;
1029 pglob
->gl_pathv
[newcount
] = strdup (pattern
);
1030 if (pglob
->gl_pathv
[newcount
] == NULL
)
1034 pglob
->gl_pathc
= 0;
1035 retval
= GLOB_NOSPACE
;
1042 pglob
->gl_pathv
[newcount
] = NULL
;
1043 pglob
->gl_flags
= flags
;
1048 retval
= GLOB_NOMATCH
;
1057 size_t old_pathc
= pglob
->gl_pathc
;
1058 int orig_flags
= flags
;
1060 if (meta
& GLOBPAT_BACKSLASH
)
1062 char *p
= strchr (dirname
, '\\'), *q
;
1063 /* We need to unescape the dirname string. It is certainly
1064 allocated by alloca, as otherwise filename would be NULL
1065 or dirname wouldn't contain backslashes. */
1078 while (*p
++ != '\0');
1079 dirname_modified
= 1;
1081 if (dirname_modified
)
1082 flags
&= ~(GLOB_NOCHECK
| GLOB_NOMAGIC
);
1083 status
= glob_in_dir (filename
, dirname
, flags
, errfunc
, pglob
,
1087 if (status
== GLOB_NOMATCH
&& flags
!= orig_flags
1088 && pglob
->gl_pathc
+ pglob
->gl_offs
== oldcount
)
1090 /* Make sure globfree (&dirs); is a nop. */
1091 dirs
.gl_pathv
= NULL
;
1101 /* Stick the directory on the front of each name. */
1102 if (prefix_array (dirname
,
1103 &pglob
->gl_pathv
[old_pathc
+ pglob
->gl_offs
],
1104 pglob
->gl_pathc
- old_pathc
))
1107 pglob
->gl_pathc
= 0;
1108 retval
= GLOB_NOSPACE
;
1114 if (flags
& GLOB_MARK
)
1116 /* Append slashes to directory names. */
1119 for (i
= oldcount
; i
< pglob
->gl_pathc
+ pglob
->gl_offs
; ++i
)
1120 if (is_dir (pglob
->gl_pathv
[i
], flags
, pglob
))
1122 size_t len
= strlen (pglob
->gl_pathv
[i
]) + 2;
1123 char *new = realloc (pglob
->gl_pathv
[i
], len
);
1127 pglob
->gl_pathc
= 0;
1128 retval
= GLOB_NOSPACE
;
1131 strcpy (&new[len
- 2], "/");
1132 pglob
->gl_pathv
[i
] = new;
1136 if (!(flags
& GLOB_NOSORT
))
1138 /* Sort the vector. */
1139 qsort (&pglob
->gl_pathv
[oldcount
],
1140 pglob
->gl_pathc
+ pglob
->gl_offs
- oldcount
,
1141 sizeof (char *), collated_compare
);
1145 if (__glibc_unlikely (malloc_dirname
))
1150 #if defined _LIBC && !defined glob
1151 libc_hidden_def (glob
)
1155 /* Do a collated comparison of A and B. */
1157 collated_compare (const void *a
, const void *b
)
1159 char *const *ps1
= a
; char *s1
= *ps1
;
1160 char *const *ps2
= b
; char *s2
= *ps2
;
1168 return strcoll (s1
, s2
);
1172 /* Prepend DIRNAME to each of N members of ARRAY, replacing ARRAY's
1173 elements in place. Return nonzero if out of memory, zero if successful.
1174 A slash is inserted between DIRNAME and each elt of ARRAY,
1175 unless DIRNAME is just "/". Each old element of ARRAY is freed. */
1177 prefix_array (const char *dirname
, char **array
, size_t n
)
1180 size_t dirlen
= strlen (dirname
);
1181 char dirsep_char
= '/';
1183 if (dirlen
== 1 && dirname
[0] == '/')
1184 /* DIRNAME is just "/", so normal prepending would get us "//foo".
1185 We want "/foo" instead, so don't prepend any chars from DIRNAME. */
1188 #if defined __MSDOS__ || defined WINDOWS32
1191 if (dirname
[dirlen
- 1] == '/' && dirname
[dirlen
- 2] == ':')
1192 /* DIRNAME is "d:/". Don't prepend the slash from DIRNAME. */
1194 else if (dirname
[dirlen
- 1] == ':')
1196 /* DIRNAME is "d:". Use ':' instead of '/'. */
1203 for (i
= 0; i
< n
; ++i
)
1205 size_t eltlen
= strlen (array
[i
]) + 1;
1206 char *new = malloc (dirlen
+ 1 + eltlen
);
1215 char *endp
= mempcpy (new, dirname
, dirlen
);
1216 *endp
++ = dirsep_char
;
1217 mempcpy (endp
, array
[i
], eltlen
);
1226 /* Like 'glob', but PATTERN is a final pathname component,
1227 and matches are searched for in DIRECTORY.
1228 The GLOB_NOSORT bit in FLAGS is ignored. No sorting is ever done.
1229 The GLOB_APPEND flag is assumed to be set (always appends). */
1231 glob_in_dir (const char *pattern
, const char *directory
, int flags
,
1232 int (*errfunc
) (const char *, int),
1233 glob_t
*pglob
, size_t alloca_used
)
1235 size_t dirlen
= strlen (directory
);
1236 void *stream
= NULL
;
1237 # define GLOBNAMES_MEMBERS(nnames) \
1238 struct globnames *next; size_t count; char *name[nnames];
1239 struct globnames
{ GLOBNAMES_MEMBERS (FLEXIBLE_ARRAY_MEMBER
) };
1240 struct { GLOBNAMES_MEMBERS (64) } init_names_buf
;
1241 struct globnames
*init_names
= (struct globnames
*) &init_names_buf
;
1242 struct globnames
*names
= init_names
;
1243 struct globnames
*names_alloca
= init_names
;
1250 alloca_used
+= sizeof init_names_buf
;
1252 init_names
->next
= NULL
;
1253 init_names
->count
= ((sizeof init_names_buf
1254 - offsetof (struct globnames
, name
))
1255 / sizeof init_names
->name
[0]);
1257 meta
= __glob_pattern_type (pattern
, !(flags
& GLOB_NOESCAPE
));
1258 if (meta
== GLOBPAT_NONE
&& (flags
& (GLOB_NOCHECK
|GLOB_NOMAGIC
)))
1260 /* We need not do any tests. The PATTERN contains no meta
1261 characters and we must not return an error therefore the
1262 result will always contain exactly one name. */
1263 flags
|= GLOB_NOCHECK
;
1265 else if (meta
== GLOBPAT_NONE
)
1272 size_t patlen
= strlen (pattern
);
1274 bool alloca_fullname
1275 = (! size_add_wrapv (dirlen
+ 1, patlen
+ 1, &fullsize
)
1276 && glob_use_alloca (alloca_used
, fullsize
));
1278 if (alloca_fullname
)
1279 fullname
= alloca_account (fullsize
, alloca_used
);
1282 fullname
= malloc (fullsize
);
1283 if (fullname
== NULL
)
1284 return GLOB_NOSPACE
;
1287 mempcpy (mempcpy (mempcpy (fullname
, directory
, dirlen
),
1289 pattern
, patlen
+ 1);
1290 if (((__builtin_expect (flags
& GLOB_ALTDIRFUNC
, 0)
1291 ? (*pglob
->gl_lstat
) (fullname
, &ust
.st
)
1292 : __lstat64 (fullname
, &ust
.st64
))
1294 || errno
== EOVERFLOW
)
1295 /* We found this file to be existing. Now tell the rest
1296 of the function to copy this name into the result. */
1297 flags
|= GLOB_NOCHECK
;
1299 if (__glibc_unlikely (!alloca_fullname
))
1304 stream
= (__builtin_expect (flags
& GLOB_ALTDIRFUNC
, 0)
1305 ? (*pglob
->gl_opendir
) (directory
)
1306 : opendir (directory
));
1309 if (errno
!= ENOTDIR
1310 && ((errfunc
!= NULL
&& (*errfunc
) (directory
, errno
))
1311 || (flags
& GLOB_ERR
)))
1312 return GLOB_ABORTED
;
1316 int fnm_flags
= ((!(flags
& GLOB_PERIOD
) ? FNM_PERIOD
: 0)
1317 | ((flags
& GLOB_NOESCAPE
) ? FNM_NOESCAPE
: 0));
1318 flags
|= GLOB_MAGCHAR
;
1322 struct readdir_result d
;
1324 if (__builtin_expect (flags
& GLOB_ALTDIRFUNC
, 0))
1325 d
= convert_dirent (GL_READDIR (pglob
, stream
));
1328 #ifdef COMPILE_GLOB64
1329 d
= convert_dirent (__readdir (stream
));
1331 d
= convert_dirent64 (__readdir64 (stream
));
1338 /* If we shall match only directories use the information
1339 provided by the dirent call if possible. */
1340 if (flags
& GLOB_ONLYDIR
)
1341 switch (readdir_result_type (d
))
1343 case DT_DIR
: case DT_LNK
: case DT_UNKNOWN
: break;
1347 if (fnmatch (pattern
, d
.name
, fnm_flags
) == 0)
1349 if (cur
== names
->count
)
1351 struct globnames
*newnames
;
1352 size_t count
= names
->count
* 2;
1353 size_t nameoff
= offsetof (struct globnames
, name
);
1354 size_t size
= FLEXSIZEOF (struct globnames
, name
,
1355 count
* sizeof (char *));
1356 if ((SIZE_MAX
- nameoff
) / 2 / sizeof (char *)
1359 if (glob_use_alloca (alloca_used
, size
))
1360 newnames
= names_alloca
1361 = alloca_account (size
, alloca_used
);
1362 else if ((newnames
= malloc (size
))
1365 newnames
->count
= count
;
1366 newnames
->next
= names
;
1370 names
->name
[cur
] = strdup (d
.name
);
1371 if (names
->name
[cur
] == NULL
)
1375 if (SIZE_MAX
- pglob
->gl_offs
<= nfound
)
1382 if (nfound
== 0 && (flags
& GLOB_NOCHECK
))
1384 size_t len
= strlen (pattern
);
1386 names
->name
[cur
] = malloc (len
+ 1);
1387 if (names
->name
[cur
] == NULL
)
1389 *((char *) mempcpy (names
->name
[cur
++], pattern
, len
)) = '\0';
1392 result
= GLOB_NOMATCH
;
1395 char **new_gl_pathv
;
1398 if (SIZE_MAX
/ sizeof (char *) - pglob
->gl_pathc
1399 < pglob
->gl_offs
+ nfound
+ 1)
1403 = realloc (pglob
->gl_pathv
,
1404 (pglob
->gl_pathc
+ pglob
->gl_offs
+ nfound
+ 1)
1407 if (new_gl_pathv
== NULL
)
1412 struct globnames
*old
= names
;
1413 for (size_t i
= 0; i
< cur
; ++i
)
1414 free (names
->name
[i
]);
1415 names
= names
->next
;
1416 /* NB: we will not leak memory here if we exit without
1417 freeing the current block assigned to OLD. At least
1418 the very first block is always allocated on the stack
1419 and this is the block assigned to OLD here. */
1422 assert (old
== init_names
);
1426 if (old
== names_alloca
)
1427 names_alloca
= names
;
1431 result
= GLOB_NOSPACE
;
1437 struct globnames
*old
= names
;
1438 for (size_t i
= 0; i
< cur
; ++i
)
1439 new_gl_pathv
[pglob
->gl_offs
+ pglob
->gl_pathc
++]
1441 names
= names
->next
;
1442 /* NB: we will not leak memory here if we exit without
1443 freeing the current block assigned to OLD. At least
1444 the very first block is always allocated on the stack
1445 and this is the block assigned to OLD here. */
1448 assert (old
== init_names
);
1452 if (old
== names_alloca
)
1453 names_alloca
= names
;
1458 pglob
->gl_pathv
= new_gl_pathv
;
1460 pglob
->gl_pathv
[pglob
->gl_offs
+ pglob
->gl_pathc
] = NULL
;
1462 pglob
->gl_flags
= flags
;
1469 if (__glibc_unlikely (flags
& GLOB_ALTDIRFUNC
))
1470 (*pglob
->gl_closedir
) (stream
);