1 /* Copyright (C) 1991-2020 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
70 # include <shlib-compat.h>
73 # define __getlogin_r(buf, len) getlogin_r (buf, len)
74 # define __lstat64(fname, buf) lstat (fname, buf)
76 /* Avoid GCC warning. mingw has an unused __stat64 macro. */
79 # define __stat64(fname, buf) stat (fname, buf)
80 # define __fxstatat64(_, d, f, st, flag) fstatat (d, f, st, flag)
81 # define struct_stat64 struct stat
83 # define __alloca alloca
85 # define __readdir readdir
86 # define COMPILE_GLOB64
91 #include <flexmember.h>
92 #include <glob_internal.h>
93 #include <scratch_buffer.h>
95 static const char *next_brace_sub (const char *begin
, int flags
) __THROWNL
;
97 /* The type of ((struct dirent *) 0)->d_type is 'unsigned char' on most
98 platforms, but 'unsigned int' in the mingw from mingw.org. */
99 typedef uint_fast32_t dirent_type
;
101 #if !defined _LIBC && !defined HAVE_STRUCT_DIRENT_D_TYPE
102 /* Any distinct values will do here.
103 Undef any existing macros out of the way. */
107 # define DT_UNKNOWN 0
112 /* A representation of a directory entry which does not depend on the
113 layout of struct dirent, or the size of ino_t. */
114 struct readdir_result
117 #if defined _DIRENT_HAVE_D_TYPE || defined HAVE_STRUCT_DIRENT_D_TYPE
122 /* Initialize and return type member of struct readdir_result. */
124 readdir_result_type (struct readdir_result d
)
126 #if defined _DIRENT_HAVE_D_TYPE || defined HAVE_STRUCT_DIRENT_D_TYPE
127 # define D_TYPE_TO_RESULT(source) (source)->d_type,
130 # define D_TYPE_TO_RESULT(source)
135 /* Construct an initializer for a struct readdir_result object from a
136 struct dirent *. No copy of the name is made. */
137 #define READDIR_RESULT_INITIALIZER(source) \
140 D_TYPE_TO_RESULT (source) \
143 /* Call gl_readdir on STREAM. This macro can be overridden to reduce
144 type safety if an old interface version needs to be supported. */
146 # define GL_READDIR(pglob, stream) ((pglob)->gl_readdir (stream))
149 /* Extract name and type from directory entry. No copy of the name is
150 made. If SOURCE is NULL, result name is NULL. Keep in sync with
151 convert_dirent64 below. */
152 static struct readdir_result
153 convert_dirent (const struct dirent
*source
)
157 struct readdir_result result
= { NULL
, };
160 struct readdir_result result
= READDIR_RESULT_INITIALIZER (source
);
164 #ifndef COMPILE_GLOB64
165 /* Like convert_dirent, but works on struct dirent64 instead. Keep in
166 sync with convert_dirent above. */
167 static struct readdir_result
168 convert_dirent64 (const struct dirent64
*source
)
172 struct readdir_result result
= { NULL
, };
175 struct readdir_result result
= READDIR_RESULT_INITIALIZER (source
);
181 /* The results of opendir() in this file are not used with dirfd and fchdir,
182 and we do not leak fds to any single-threaded code that could use stdio,
183 therefore save some unnecessary recursion in fchdir.c and opendir_safer.c.
184 FIXME - if the kernel ever adds support for multi-thread safety for
185 avoiding standard fds, then we should use opendir_safer. */
186 # ifdef GNULIB_defined_opendir
189 # ifdef GNULIB_defined_closedir
193 /* Just use malloc. */
194 # define __libc_use_alloca(n) false
195 # define alloca_account(len, avar) ((void) (len), (void) (avar), (void *) 0)
196 # define extend_alloca_account(buf, len, newlen, avar) \
197 ((void) (buf), (void) (len), (void) (newlen), (void) (avar), (void *) 0)
201 glob_lstat (glob_t
*pglob
, int flags
, const char *fullname
)
203 /* Use on glob-lstat-compat.c to provide a compat symbol which does not
204 use lstat / gl_lstat. */
206 # define GL_LSTAT gl_stat
207 # define LSTAT64 __stat64
209 # define GL_LSTAT gl_lstat
210 # define LSTAT64 __lstat64
218 return (__glibc_unlikely (flags
& GLOB_ALTDIRFUNC
)
219 ? pglob
->GL_LSTAT (fullname
, &ust
.st
)
220 : LSTAT64 (fullname
, &ust
.st64
));
223 /* Set *R = A + B. Return true if the answer is mathematically
224 incorrect due to overflow; in this case, *R is the low order
225 bits of the correct answer. */
228 size_add_wrapv (size_t a
, size_t b
, size_t *r
)
230 #if 5 <= __GNUC__ && !defined __ICC
231 return __builtin_add_overflow (a
, b
, r
);
239 glob_use_alloca (size_t alloca_used
, size_t len
)
242 return (!size_add_wrapv (alloca_used
, len
, &size
)
243 && __libc_use_alloca (size
));
246 static int glob_in_dir (const char *pattern
, const char *directory
,
247 int flags
, int (*errfunc
) (const char *, int),
248 glob_t
*pglob
, size_t alloca_used
);
249 static int prefix_array (const char *prefix
, char **array
, size_t n
) __THROWNL
;
250 static int collated_compare (const void *, const void *) __THROWNL
;
253 /* Return true if FILENAME is a directory or a symbolic link to a directory.
254 Use FLAGS and PGLOB to resolve the filename. */
256 is_dir (char const *filename
, int flags
, glob_t
const *pglob
)
260 return (__glibc_unlikely (flags
& GLOB_ALTDIRFUNC
)
261 ? pglob
->gl_stat (filename
, &st
) == 0 && S_ISDIR (st
.st_mode
)
262 : __stat64 (filename
, &st64
) == 0 && S_ISDIR (st64
.st_mode
));
265 /* Find the end of the sub-pattern in a brace expression. */
267 next_brace_sub (const char *cp
, int flags
)
271 if ((flags
& GLOB_NOESCAPE
) == 0 && *cp
== '\\')
279 if ((*cp
== '}' && depth
-- == 0) || (*cp
== ',' && depth
== 0))
286 return *cp
!= '\0' ? cp
: NULL
;
289 #ifndef GLOB_ATTRIBUTE
290 # define GLOB_ATTRIBUTE
293 /* Do glob searching for PATTERN, placing results in PGLOB.
294 The bits defined above may be set in FLAGS.
295 If a directory cannot be opened or read and ERRFUNC is not nil,
296 it is called with the pathname that caused the error, and the
297 'errno' value from the failing call; if it returns non-zero
298 'glob' returns GLOB_ABORTED; if it returns zero, the error is ignored.
299 If memory cannot be allocated for PGLOB, GLOB_NOSPACE is returned.
300 Otherwise, 'glob' returns zero. */
303 __glob (const char *pattern
, int flags
, int (*errfunc
) (const char *, int),
306 const char *filename
;
307 char *dirname
= NULL
;
312 int dirname_modified
;
313 int malloc_dirname
= 0;
316 size_t alloca_used
= 0;
318 if (pattern
== NULL
|| pglob
== NULL
|| (flags
& ~__GLOB_FLAGS
) != 0)
320 __set_errno (EINVAL
);
324 /* POSIX requires all slashes to be matched. This means that with
325 a trailing slash we must match only directories. */
326 if (pattern
[0] && pattern
[strlen (pattern
) - 1] == '/')
327 flags
|= GLOB_ONLYDIR
;
329 if (!(flags
& GLOB_DOOFFS
))
330 /* Have to do this so 'globfree' knows where to start freeing. It
331 also makes all the code that uses gl_offs simpler. */
334 if (!(flags
& GLOB_APPEND
))
337 if (!(flags
& GLOB_DOOFFS
))
338 pglob
->gl_pathv
= NULL
;
343 if (pglob
->gl_offs
>= ~((size_t) 0) / sizeof (char *))
346 pglob
->gl_pathv
= (char **) malloc ((pglob
->gl_offs
+ 1)
348 if (pglob
->gl_pathv
== NULL
)
351 for (i
= 0; i
<= pglob
->gl_offs
; ++i
)
352 pglob
->gl_pathv
[i
] = NULL
;
356 if (flags
& GLOB_BRACE
)
360 if (flags
& GLOB_NOESCAPE
)
361 begin
= strchr (pattern
, '{');
373 if (*begin
== '\\' && begin
[1] != '\0')
375 else if (*begin
== '{')
384 /* Allocate working buffer large enough for our work. Note that
385 we have at least an opening and closing brace. */
393 size_t pattern_len
= strlen (pattern
) - 1;
394 int alloca_onealt
= glob_use_alloca (alloca_used
, pattern_len
);
396 onealt
= alloca_account (pattern_len
, alloca_used
);
399 onealt
= malloc (pattern_len
);
404 /* We know the prefix for all sub-patterns. */
405 alt_start
= mempcpy (onealt
, pattern
, begin
- pattern
);
407 /* Find the first sub-pattern and at the same time find the
408 rest after the closing brace. */
409 next
= next_brace_sub (begin
+ 1, flags
);
412 /* It is an invalid expression. */
414 if (__glibc_unlikely (!alloca_onealt
))
416 flags
&= ~GLOB_BRACE
;
420 /* Now find the end of the whole brace expression. */
424 rest
= next_brace_sub (rest
+ 1, flags
);
426 /* It is an illegal expression. */
429 /* Please note that we now can be sure the brace expression
431 rest_len
= strlen (++rest
) + 1;
433 /* We have a brace expression. BEGIN points to the opening {,
434 NEXT points past the terminator of the first element, and END
435 points past the final }. We will accumulate result names from
436 recursive runs for each brace alternative in the buffer using
438 firstc
= pglob
->gl_pathc
;
445 /* Construct the new glob expression. */
446 mempcpy (mempcpy (alt_start
, p
, next
- p
), rest
, rest_len
);
448 result
= __glob (onealt
,
449 ((flags
& ~(GLOB_NOCHECK
| GLOB_NOMAGIC
))
453 /* If we got an error, return it. */
454 if (result
&& result
!= GLOB_NOMATCH
)
456 if (__glibc_unlikely (!alloca_onealt
))
458 if (!(flags
& GLOB_APPEND
))
467 /* We saw the last entry. */
471 next
= next_brace_sub (p
, flags
);
472 assert (next
!= NULL
);
475 if (__glibc_unlikely (!alloca_onealt
))
478 if (pglob
->gl_pathc
!= firstc
)
479 /* We found some entries. */
481 else if (!(flags
& (GLOB_NOCHECK
|GLOB_NOMAGIC
)))
487 oldcount
= pglob
->gl_pathc
+ pglob
->gl_offs
;
489 /* Find the filename. */
490 filename
= strrchr (pattern
, '/');
492 #if defined __MSDOS__ || defined WINDOWS32
493 /* The case of "d:pattern". Since ':' is not allowed in
494 file names, we can safely assume that wherever it
495 happens in pattern, it signals the filename part. This
496 is so we could some day support patterns like "[a-z]:foo". */
497 if (filename
== NULL
)
498 filename
= strchr (pattern
, ':');
499 #endif /* __MSDOS__ || WINDOWS32 */
501 dirname_modified
= 0;
502 if (filename
== NULL
)
504 /* This can mean two things: a simple name or "~name". The latter
505 case is nothing but a notation for a directory. */
506 if ((flags
& (GLOB_TILDE
|GLOB_TILDE_CHECK
)) && pattern
[0] == '~')
508 dirname
= (char *) pattern
;
509 dirlen
= strlen (pattern
);
511 /* Set FILENAME to NULL as a special flag. This is ugly but
512 other solutions would require much more code. We test for
513 this special case below. */
518 if (__glibc_unlikely (pattern
[0] == '\0'))
520 dirs
.gl_pathv
= NULL
;
525 dirname
= (char *) ".";
529 else if (filename
== pattern
530 || (filename
== pattern
+ 1 && pattern
[0] == '\\'
531 && (flags
& GLOB_NOESCAPE
) == 0))
533 /* "/pattern" or "\\/pattern". */
534 dirname
= (char *) "/";
541 dirlen
= filename
- pattern
;
542 #if defined __MSDOS__ || defined WINDOWS32
544 || (filename
> pattern
+ 1 && filename
[-1] == ':'))
549 drive_spec
= __alloca (dirlen
+ 1);
550 *((char *) mempcpy (drive_spec
, pattern
, dirlen
)) = '\0';
551 /* For now, disallow wildcards in the drive spec, to
552 prevent infinite recursion in glob. */
553 if (__glob_pattern_p (drive_spec
, !(flags
& GLOB_NOESCAPE
)))
555 /* If this is "d:pattern", we need to copy ':' to DIRNAME
556 as well. If it's "d:/pattern", don't remove the slash
557 from "d:/", since "d:" and "d:/" are not the same.*/
561 if (glob_use_alloca (alloca_used
, dirlen
+ 1))
562 newp
= alloca_account (dirlen
+ 1, alloca_used
);
565 newp
= malloc (dirlen
+ 1);
570 *((char *) mempcpy (newp
, pattern
, dirlen
)) = '\0';
574 #if defined __MSDOS__ || defined WINDOWS32
575 bool drive_root
= (dirlen
> 1
576 && (dirname
[dirlen
- 1] == ':'
577 || (dirlen
> 2 && dirname
[dirlen
- 2] == ':'
578 && dirname
[dirlen
- 1] == '/')));
580 bool drive_root
= false;
583 if (filename
[0] == '\0' && dirlen
> 1 && !drive_root
)
584 /* "pattern/". Expand "pattern", appending slashes. */
586 int orig_flags
= flags
;
587 if (!(flags
& GLOB_NOESCAPE
) && dirname
[dirlen
- 1] == '\\')
589 /* "pattern\\/". Remove the final backslash if it hasn't
591 char *p
= (char *) &dirname
[dirlen
- 1];
593 while (p
> dirname
&& p
[-1] == '\\') --p
;
594 if ((&dirname
[dirlen
] - p
) & 1)
596 *(char *) &dirname
[--dirlen
] = '\0';
597 flags
&= ~(GLOB_NOCHECK
| GLOB_NOMAGIC
);
600 int val
= __glob (dirname
, flags
| GLOB_MARK
, errfunc
, pglob
);
602 pglob
->gl_flags
= ((pglob
->gl_flags
& ~GLOB_MARK
)
603 | (flags
& GLOB_MARK
));
604 else if (val
== GLOB_NOMATCH
&& flags
!= orig_flags
)
606 /* Make sure globfree (&dirs); is a nop. */
607 dirs
.gl_pathv
= NULL
;
609 oldcount
= pglob
->gl_pathc
+ pglob
->gl_offs
;
617 if ((flags
& (GLOB_TILDE
|GLOB_TILDE_CHECK
)) && dirname
[0] == '~')
619 if (dirname
[1] == '\0' || dirname
[1] == '/'
620 || (!(flags
& GLOB_NOESCAPE
) && dirname
[1] == '\\'
621 && (dirname
[2] == '\0' || dirname
[2] == '/')))
623 /* Look up home directory. */
624 char *home_dir
= getenv ("HOME");
625 int malloc_home_dir
= 0;
626 if (home_dir
== NULL
|| home_dir
[0] == '\0')
629 /* Windows NT defines HOMEDRIVE and HOMEPATH. But give
630 preference to HOME, because the user can change HOME. */
631 const char *home_drive
= getenv ("HOMEDRIVE");
632 const char *home_path
= getenv ("HOMEPATH");
634 if (home_drive
!= NULL
&& home_path
!= NULL
)
636 size_t home_drive_len
= strlen (home_drive
);
637 size_t home_path_len
= strlen (home_path
);
638 char *mem
= alloca (home_drive_len
+ home_path_len
+ 1);
640 memcpy (mem
, home_drive
, home_drive_len
);
641 memcpy (mem
+ home_drive_len
, home_path
, home_path_len
+ 1);
645 home_dir
= "c:/users/default"; /* poor default */
650 struct scratch_buffer s
;
651 scratch_buffer_init (&s
);
655 err
= __getlogin_r (s
.data
, s
.length
);
658 # if defined HAVE_GETPWNAM_R || defined _LIBC
659 size_t ssize
= strlen (s
.data
) + 1;
660 char *sdata
= s
.data
;
661 err
= getpwnam_r (sdata
, &pwbuf
, sdata
+ ssize
,
662 s
.length
- ssize
, &p
);
664 p
= getpwnam (s
.data
);
671 if (!scratch_buffer_grow (&s
))
673 retval
= GLOB_NOSPACE
;
679 home_dir
= strdup (p
->pw_dir
);
682 scratch_buffer_free (&s
);
683 if (err
== 0 && home_dir
== NULL
)
685 retval
= GLOB_NOSPACE
;
688 #endif /* WINDOWS32 */
690 if (home_dir
== NULL
|| home_dir
[0] == '\0')
692 if (__glibc_unlikely (malloc_home_dir
))
694 if (flags
& GLOB_TILDE_CHECK
)
696 retval
= GLOB_NOMATCH
;
701 home_dir
= (char *) "~"; /* No luck. */
705 /* Now construct the full directory. */
706 if (dirname
[1] == '\0')
708 if (__glibc_unlikely (malloc_dirname
))
712 dirlen
= strlen (dirname
);
713 malloc_dirname
= malloc_home_dir
;
718 size_t home_len
= strlen (home_dir
);
719 int use_alloca
= glob_use_alloca (alloca_used
, home_len
+ dirlen
);
721 newp
= alloca_account (home_len
+ dirlen
, alloca_used
);
724 newp
= malloc (home_len
+ dirlen
);
727 if (__glibc_unlikely (malloc_home_dir
))
729 retval
= GLOB_NOSPACE
;
734 mempcpy (mempcpy (newp
, home_dir
, home_len
),
735 &dirname
[1], dirlen
);
737 if (__glibc_unlikely (malloc_dirname
))
741 dirlen
+= home_len
- 1;
742 malloc_dirname
= !use_alloca
;
744 if (__glibc_unlikely (malloc_home_dir
))
747 dirname_modified
= 1;
752 char *end_name
= strchr (dirname
, '/');
754 int malloc_user_name
= 0;
755 char *unescape
= NULL
;
757 if (!(flags
& GLOB_NOESCAPE
))
759 if (end_name
== NULL
)
761 unescape
= strchr (dirname
, '\\');
763 end_name
= strchr (unescape
, '\0');
766 unescape
= memchr (dirname
, '\\', end_name
- dirname
);
768 if (end_name
== NULL
)
769 user_name
= dirname
+ 1;
773 if (glob_use_alloca (alloca_used
, end_name
- dirname
))
774 newp
= alloca_account (end_name
- dirname
, alloca_used
);
777 newp
= malloc (end_name
- dirname
);
780 retval
= GLOB_NOSPACE
;
783 malloc_user_name
= 1;
785 if (unescape
!= NULL
)
787 char *p
= mempcpy (newp
, dirname
+ 1,
788 unescape
- dirname
- 1);
790 while (q
!= end_name
)
794 if (q
+ 1 == end_name
)
796 /* "~fo\\o\\" unescape to user_name "foo\\",
797 but "~fo\\o\\/" unescape to user_name
799 if (filename
== NULL
)
810 *((char *) mempcpy (newp
, dirname
+ 1, end_name
- dirname
- 1))
815 /* Look up specific user's home directory. */
818 struct scratch_buffer pwtmpbuf
;
819 scratch_buffer_init (&pwtmpbuf
);
821 # if defined HAVE_GETPWNAM_R || defined _LIBC
824 while (getpwnam_r (user_name
, &pwbuf
,
825 pwtmpbuf
.data
, pwtmpbuf
.length
, &p
)
828 if (!scratch_buffer_grow (&pwtmpbuf
))
830 retval
= GLOB_NOSPACE
;
835 p
= getpwnam (user_name
);
838 if (__glibc_unlikely (malloc_user_name
))
841 /* If we found a home directory use this. */
844 size_t home_len
= strlen (p
->pw_dir
);
845 size_t rest_len
= end_name
== NULL
? 0 : strlen (end_name
);
848 if (__glibc_unlikely (malloc_dirname
))
852 if (glob_use_alloca (alloca_used
, home_len
+ rest_len
+ 1))
853 dirname
= alloca_account (home_len
+ rest_len
+ 1,
857 dirname
= malloc (home_len
+ rest_len
+ 1);
860 scratch_buffer_free (&pwtmpbuf
);
861 retval
= GLOB_NOSPACE
;
866 d
= mempcpy (dirname
, p
->pw_dir
, home_len
);
867 if (end_name
!= NULL
)
868 d
= mempcpy (d
, end_name
, rest_len
);
871 dirlen
= home_len
+ rest_len
;
872 dirname_modified
= 1;
876 if (flags
& GLOB_TILDE_CHECK
)
878 /* We have to regard it as an error if we cannot find the
880 retval
= GLOB_NOMATCH
;
884 scratch_buffer_free (&pwtmpbuf
);
886 #endif /* !WINDOWS32 */
890 /* Now test whether we looked for "~" or "~NAME". In this case we
891 can give the answer now. */
892 if (filename
== NULL
)
894 size_t newcount
= pglob
->gl_pathc
+ pglob
->gl_offs
;
897 if (newcount
> SIZE_MAX
/ sizeof (char *) - 2)
900 free (pglob
->gl_pathv
);
901 pglob
->gl_pathv
= NULL
;
903 retval
= GLOB_NOSPACE
;
907 new_gl_pathv
= realloc (pglob
->gl_pathv
,
908 (newcount
+ 2) * sizeof (char *));
909 if (new_gl_pathv
== NULL
)
911 pglob
->gl_pathv
= new_gl_pathv
;
913 if (flags
& GLOB_MARK
&& is_dir (dirname
, flags
, pglob
))
916 pglob
->gl_pathv
[newcount
] = malloc (dirlen
+ 2);
917 if (pglob
->gl_pathv
[newcount
] == NULL
)
919 p
= mempcpy (pglob
->gl_pathv
[newcount
], dirname
, dirlen
);
922 if (__glibc_unlikely (malloc_dirname
))
927 if (__glibc_unlikely (malloc_dirname
))
928 pglob
->gl_pathv
[newcount
] = dirname
;
931 pglob
->gl_pathv
[newcount
] = strdup (dirname
);
932 if (pglob
->gl_pathv
[newcount
] == NULL
)
936 pglob
->gl_pathv
[++newcount
] = NULL
;
938 pglob
->gl_flags
= flags
;
943 meta
= __glob_pattern_type (dirname
, !(flags
& GLOB_NOESCAPE
));
944 /* meta is 1 if correct glob pattern containing metacharacters.
945 If meta has bit (1 << 2) set, it means there was an unterminated
946 [ which we handle the same, using fnmatch. Broken unterminated
947 pattern bracket expressions ought to be rare enough that it is
948 not worth special casing them, fnmatch will do the right thing. */
949 if (meta
& (GLOBPAT_SPECIAL
| GLOBPAT_BRACKET
))
951 /* The directory name contains metacharacters, so we
952 have to glob for the directory, and then glob for
953 the pattern in each directory found. */
956 if (!(flags
& GLOB_NOESCAPE
) && dirlen
> 0 && dirname
[dirlen
- 1] == '\\')
958 /* "foo\\/bar". Remove the final backslash from dirname
959 if it has not been quoted. */
960 char *p
= (char *) &dirname
[dirlen
- 1];
962 while (p
> dirname
&& p
[-1] == '\\') --p
;
963 if ((&dirname
[dirlen
] - p
) & 1)
964 *(char *) &dirname
[--dirlen
] = '\0';
967 if (__glibc_unlikely ((flags
& GLOB_ALTDIRFUNC
) != 0))
969 /* Use the alternative access functions also in the recursive
971 dirs
.gl_opendir
= pglob
->gl_opendir
;
972 dirs
.gl_readdir
= pglob
->gl_readdir
;
973 dirs
.gl_closedir
= pglob
->gl_closedir
;
974 dirs
.gl_stat
= pglob
->gl_stat
;
975 dirs
.gl_lstat
= pglob
->gl_lstat
;
978 status
= __glob (dirname
,
979 ((flags
& (GLOB_ERR
| GLOB_NOESCAPE
| GLOB_ALTDIRFUNC
))
980 | GLOB_NOSORT
| GLOB_ONLYDIR
),
984 if ((flags
& GLOB_NOCHECK
) == 0 || status
!= GLOB_NOMATCH
)
992 /* We have successfully globbed the preceding directory name.
993 For each name we found, call glob_in_dir on it and FILENAME,
994 appending the results to PGLOB. */
995 for (i
= 0; i
< dirs
.gl_pathc
; ++i
)
999 old_pathc
= pglob
->gl_pathc
;
1000 status
= glob_in_dir (filename
, dirs
.gl_pathv
[i
],
1001 ((flags
| GLOB_APPEND
)
1002 & ~(GLOB_NOCHECK
| GLOB_NOMAGIC
)),
1003 errfunc
, pglob
, alloca_used
);
1004 if (status
== GLOB_NOMATCH
)
1005 /* No matches in this directory. Try the next. */
1012 pglob
->gl_pathc
= 0;
1017 /* Stick the directory on the front of each name. */
1018 if (prefix_array (dirs
.gl_pathv
[i
],
1019 &pglob
->gl_pathv
[old_pathc
+ pglob
->gl_offs
],
1020 pglob
->gl_pathc
- old_pathc
))
1024 pglob
->gl_pathc
= 0;
1025 retval
= GLOB_NOSPACE
;
1030 flags
|= GLOB_MAGCHAR
;
1032 /* We have ignored the GLOB_NOCHECK flag in the 'glob_in_dir' calls.
1033 But if we have not found any matching entry and the GLOB_NOCHECK
1034 flag was set we must return the input pattern itself. */
1035 if (pglob
->gl_pathc
+ pglob
->gl_offs
== oldcount
)
1039 if (flags
& GLOB_NOCHECK
)
1041 size_t newcount
= pglob
->gl_pathc
+ pglob
->gl_offs
;
1042 char **new_gl_pathv
;
1044 if (newcount
> SIZE_MAX
/ sizeof (char *) - 2)
1048 retval
= GLOB_NOSPACE
;
1052 new_gl_pathv
= realloc (pglob
->gl_pathv
,
1053 (newcount
+ 2) * sizeof (char *));
1054 if (new_gl_pathv
== NULL
)
1056 pglob
->gl_pathv
= new_gl_pathv
;
1058 pglob
->gl_pathv
[newcount
] = strdup (pattern
);
1059 if (pglob
->gl_pathv
[newcount
] == NULL
)
1063 pglob
->gl_pathc
= 0;
1064 retval
= GLOB_NOSPACE
;
1071 pglob
->gl_pathv
[newcount
] = NULL
;
1072 pglob
->gl_flags
= flags
;
1077 retval
= GLOB_NOMATCH
;
1086 size_t old_pathc
= pglob
->gl_pathc
;
1087 int orig_flags
= flags
;
1089 if (meta
& GLOBPAT_BACKSLASH
)
1091 char *p
= strchr (dirname
, '\\'), *q
;
1092 /* We need to unescape the dirname string. It is certainly
1093 allocated by alloca, as otherwise filename would be NULL
1094 or dirname wouldn't contain backslashes. */
1107 while (*p
++ != '\0');
1108 dirname_modified
= 1;
1110 if (dirname_modified
)
1111 flags
&= ~(GLOB_NOCHECK
| GLOB_NOMAGIC
);
1112 status
= glob_in_dir (filename
, dirname
, flags
, errfunc
, pglob
,
1116 if (status
== GLOB_NOMATCH
&& flags
!= orig_flags
1117 && pglob
->gl_pathc
+ pglob
->gl_offs
== oldcount
)
1119 /* Make sure globfree (&dirs); is a nop. */
1120 dirs
.gl_pathv
= NULL
;
1130 /* Stick the directory on the front of each name. */
1131 if (prefix_array (dirname
,
1132 &pglob
->gl_pathv
[old_pathc
+ pglob
->gl_offs
],
1133 pglob
->gl_pathc
- old_pathc
))
1136 pglob
->gl_pathc
= 0;
1137 retval
= GLOB_NOSPACE
;
1143 if (flags
& GLOB_MARK
)
1145 /* Append slashes to directory names. */
1148 for (i
= oldcount
; i
< pglob
->gl_pathc
+ pglob
->gl_offs
; ++i
)
1149 if (is_dir (pglob
->gl_pathv
[i
], flags
, pglob
))
1151 size_t len
= strlen (pglob
->gl_pathv
[i
]) + 2;
1152 char *new = realloc (pglob
->gl_pathv
[i
], len
);
1156 pglob
->gl_pathc
= 0;
1157 retval
= GLOB_NOSPACE
;
1160 strcpy (&new[len
- 2], "/");
1161 pglob
->gl_pathv
[i
] = new;
1165 if (!(flags
& GLOB_NOSORT
))
1167 /* Sort the vector. */
1168 qsort (&pglob
->gl_pathv
[oldcount
],
1169 pglob
->gl_pathc
+ pglob
->gl_offs
- oldcount
,
1170 sizeof (char *), collated_compare
);
1174 if (__glibc_unlikely (malloc_dirname
))
1179 #if defined _LIBC && !defined __glob
1180 versioned_symbol (libc
, __glob
, glob
, GLIBC_2_27
);
1181 libc_hidden_ver (__glob
, glob
)
1185 /* Do a collated comparison of A and B. */
1187 collated_compare (const void *a
, const void *b
)
1189 char *const *ps1
= a
; char *s1
= *ps1
;
1190 char *const *ps2
= b
; char *s2
= *ps2
;
1198 return strcoll (s1
, s2
);
1202 /* Prepend DIRNAME to each of N members of ARRAY, replacing ARRAY's
1203 elements in place. Return nonzero if out of memory, zero if successful.
1204 A slash is inserted between DIRNAME and each elt of ARRAY,
1205 unless DIRNAME is just "/". Each old element of ARRAY is freed. */
1207 prefix_array (const char *dirname
, char **array
, size_t n
)
1210 size_t dirlen
= strlen (dirname
);
1211 char dirsep_char
= '/';
1213 if (dirlen
== 1 && dirname
[0] == '/')
1214 /* DIRNAME is just "/", so normal prepending would get us "//foo".
1215 We want "/foo" instead, so don't prepend any chars from DIRNAME. */
1218 #if defined __MSDOS__ || defined WINDOWS32
1221 if (dirname
[dirlen
- 1] == '/' && dirname
[dirlen
- 2] == ':')
1222 /* DIRNAME is "d:/". Don't prepend the slash from DIRNAME. */
1224 else if (dirname
[dirlen
- 1] == ':')
1226 /* DIRNAME is "d:". Use ':' instead of '/'. */
1233 for (i
= 0; i
< n
; ++i
)
1235 size_t eltlen
= strlen (array
[i
]) + 1;
1236 char *new = malloc (dirlen
+ 1 + eltlen
);
1245 char *endp
= mempcpy (new, dirname
, dirlen
);
1246 *endp
++ = dirsep_char
;
1247 mempcpy (endp
, array
[i
], eltlen
);
1256 /* Like 'glob', but PATTERN is a final pathname component,
1257 and matches are searched for in DIRECTORY.
1258 The GLOB_NOSORT bit in FLAGS is ignored. No sorting is ever done.
1259 The GLOB_APPEND flag is assumed to be set (always appends). */
1261 glob_in_dir (const char *pattern
, const char *directory
, int flags
,
1262 int (*errfunc
) (const char *, int),
1263 glob_t
*pglob
, size_t alloca_used
)
1265 size_t dirlen
= strlen (directory
);
1266 void *stream
= NULL
;
1267 # define GLOBNAMES_MEMBERS(nnames) \
1268 struct globnames *next; size_t count; char *name[nnames];
1269 struct globnames
{ GLOBNAMES_MEMBERS (FLEXIBLE_ARRAY_MEMBER
) };
1270 struct { GLOBNAMES_MEMBERS (64) } init_names_buf
;
1271 struct globnames
*init_names
= (struct globnames
*) &init_names_buf
;
1272 struct globnames
*names
= init_names
;
1273 struct globnames
*names_alloca
= init_names
;
1280 alloca_used
+= sizeof init_names_buf
;
1282 init_names
->next
= NULL
;
1283 init_names
->count
= ((sizeof init_names_buf
1284 - offsetof (struct globnames
, name
))
1285 / sizeof init_names
->name
[0]);
1287 meta
= __glob_pattern_type (pattern
, !(flags
& GLOB_NOESCAPE
));
1288 if (meta
== GLOBPAT_NONE
&& (flags
& (GLOB_NOCHECK
|GLOB_NOMAGIC
)))
1290 /* We need not do any tests. The PATTERN contains no meta
1291 characters and we must not return an error therefore the
1292 result will always contain exactly one name. */
1293 flags
|= GLOB_NOCHECK
;
1295 else if (meta
== GLOBPAT_NONE
)
1297 size_t patlen
= strlen (pattern
);
1299 bool alloca_fullname
1300 = (! size_add_wrapv (dirlen
+ 1, patlen
+ 1, &fullsize
)
1301 && glob_use_alloca (alloca_used
, fullsize
));
1303 if (alloca_fullname
)
1304 fullname
= alloca_account (fullsize
, alloca_used
);
1307 fullname
= malloc (fullsize
);
1308 if (fullname
== NULL
)
1309 return GLOB_NOSPACE
;
1312 mempcpy (mempcpy (mempcpy (fullname
, directory
, dirlen
),
1314 pattern
, patlen
+ 1);
1315 if (glob_lstat (pglob
, flags
, fullname
) == 0
1316 || errno
== EOVERFLOW
)
1317 /* We found this file to be existing. Now tell the rest
1318 of the function to copy this name into the result. */
1319 flags
|= GLOB_NOCHECK
;
1321 if (__glibc_unlikely (!alloca_fullname
))
1326 stream
= (__builtin_expect (flags
& GLOB_ALTDIRFUNC
, 0)
1327 ? (*pglob
->gl_opendir
) (directory
)
1328 : opendir (directory
));
1331 if (errno
!= ENOTDIR
1332 && ((errfunc
!= NULL
&& (*errfunc
) (directory
, errno
))
1333 || (flags
& GLOB_ERR
)))
1334 return GLOB_ABORTED
;
1338 int fnm_flags
= ((!(flags
& GLOB_PERIOD
) ? FNM_PERIOD
: 0)
1339 | ((flags
& GLOB_NOESCAPE
) ? FNM_NOESCAPE
: 0));
1340 flags
|= GLOB_MAGCHAR
;
1344 struct readdir_result d
;
1346 if (__builtin_expect (flags
& GLOB_ALTDIRFUNC
, 0))
1347 d
= convert_dirent (GL_READDIR (pglob
, stream
));
1350 #ifdef COMPILE_GLOB64
1351 d
= convert_dirent (__readdir (stream
));
1353 d
= convert_dirent64 (__readdir64 (stream
));
1360 /* If we shall match only directories use the information
1361 provided by the dirent call if possible. */
1362 if (flags
& GLOB_ONLYDIR
)
1363 switch (readdir_result_type (d
))
1365 case DT_DIR
: case DT_LNK
: case DT_UNKNOWN
: break;
1369 if (fnmatch (pattern
, d
.name
, fnm_flags
) == 0)
1371 if (cur
== names
->count
)
1373 struct globnames
*newnames
;
1374 size_t count
= names
->count
* 2;
1375 size_t nameoff
= offsetof (struct globnames
, name
);
1376 size_t size
= FLEXSIZEOF (struct globnames
, name
,
1377 count
* sizeof (char *));
1378 if ((SIZE_MAX
- nameoff
) / 2 / sizeof (char *)
1381 if (glob_use_alloca (alloca_used
, size
))
1382 newnames
= names_alloca
1383 = alloca_account (size
, alloca_used
);
1384 else if ((newnames
= malloc (size
))
1387 newnames
->count
= count
;
1388 newnames
->next
= names
;
1392 names
->name
[cur
] = strdup (d
.name
);
1393 if (names
->name
[cur
] == NULL
)
1397 if (SIZE_MAX
- pglob
->gl_offs
<= nfound
)
1404 if (nfound
== 0 && (flags
& GLOB_NOCHECK
))
1406 size_t len
= strlen (pattern
);
1408 names
->name
[cur
] = malloc (len
+ 1);
1409 if (names
->name
[cur
] == NULL
)
1411 *((char *) mempcpy (names
->name
[cur
++], pattern
, len
)) = '\0';
1414 result
= GLOB_NOMATCH
;
1417 char **new_gl_pathv
;
1420 if (SIZE_MAX
/ sizeof (char *) - pglob
->gl_pathc
1421 < pglob
->gl_offs
+ nfound
+ 1)
1425 = realloc (pglob
->gl_pathv
,
1426 (pglob
->gl_pathc
+ pglob
->gl_offs
+ nfound
+ 1)
1429 if (new_gl_pathv
== NULL
)
1434 struct globnames
*old
= names
;
1435 for (size_t i
= 0; i
< cur
; ++i
)
1436 free (names
->name
[i
]);
1437 names
= names
->next
;
1438 /* NB: we will not leak memory here if we exit without
1439 freeing the current block assigned to OLD. At least
1440 the very first block is always allocated on the stack
1441 and this is the block assigned to OLD here. */
1444 assert (old
== init_names
);
1448 if (old
== names_alloca
)
1449 names_alloca
= names
;
1453 result
= GLOB_NOSPACE
;
1459 struct globnames
*old
= names
;
1460 for (size_t i
= 0; i
< cur
; ++i
)
1461 new_gl_pathv
[pglob
->gl_offs
+ pglob
->gl_pathc
++]
1463 names
= names
->next
;
1464 /* NB: we will not leak memory here if we exit without
1465 freeing the current block assigned to OLD. At least
1466 the very first block is always allocated on the stack
1467 and this is the block assigned to OLD here. */
1470 assert (old
== init_names
);
1474 if (old
== names_alloca
)
1475 names_alloca
= names
;
1480 pglob
->gl_pathv
= new_gl_pathv
;
1482 pglob
->gl_pathv
[pglob
->gl_offs
+ pglob
->gl_pathc
] = NULL
;
1484 pglob
->gl_flags
= flags
;
1491 if (__glibc_unlikely (flags
& GLOB_ALTDIRFUNC
))
1492 (*pglob
->gl_closedir
) (stream
);