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 | |
122 | static 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. */ |
126 | struct 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. */ |
140 | static bool |
141 | readdir_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. */ |
147 | static bool |
148 | readdir_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 | |
158 | static bool |
159 | readdir_result_might_be_symlink (struct readdir_result d) |
160 | { |
161 | return true; |
162 | } |
163 | |
164 | static bool |
165 | readdir_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. */ |
200 | static struct readdir_result |
201 | convert_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. */ |
215 | static struct readdir_result |
216 | convert_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 | |
233 | static 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); |
236 | extern int __glob_pattern_type (const char *pattern, int quote) |
237 | attribute_hidden; |
238 | |
239 | #if !defined _LIBC || !defined GLOB_ONLY_P |
240 | static int prefix_array (const char *prefix, char **array, size_t n) __THROWNL; |
241 | static int collated_compare (const void *, const void *) __THROWNL; |
242 | |
243 | |
244 | /* Find the end of the sub-pattern in a brace expression. */ |
245 | static const char * |
246 | next_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. */ |
278 | int |
279 | #ifdef GLOB_ATTRIBUTE |
280 | GLOB_ATTRIBUTE |
281 | #endif |
282 | glob (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 |
1275 | libc_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. */ |
1282 | void |
1283 | globfree (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 |
1295 | libc_hidden_def (globfree) |
1296 | #endif |
1297 | |
1298 | |
1299 | /* Do a collated comparison of A and B. */ |
1300 | static int |
1301 | collated_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. */ |
1320 | static int |
1321 | prefix_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 |
1377 | int |
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. */ |
1414 | int |
1415 | __glob_pattern_p (const char *pattern, int quote) |
1416 | { |
1417 | return __glob_pattern_type (pattern, quote) == 1; |
1418 | } |
1419 | # ifdef _LIBC |
1420 | weak_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 |
1430 | static int |
1431 | __attribute_noinline__ |
1432 | link_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). */ |
1474 | static int |
1475 | glob_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 | |