1 /* Traverse a file hierarchy.
3 Copyright (C) 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
5 This program is free software: you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 3 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 * Copyright (c) 1990, 1993, 1994
20 * The Regents of the University of California. All rights reserved.
22 * Redistribution and use in source and binary forms, with or without
23 * modification, are permitted provided that the following conditions
25 * 1. Redistributions of source code must retain the above copyright
26 * notice, this list of conditions and the following disclaimer.
27 * 2. Redistributions in binary form must reproduce the above copyright
28 * notice, this list of conditions and the following disclaimer in the
29 * documentation and/or other materials provided with the distribution.
30 * 4. Neither the name of the University nor the names of its contributors
31 * may be used to endorse or promote products derived from this software
32 * without specific prior written permission.
34 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
35 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
36 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
37 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
38 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
39 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
40 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
41 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
42 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
43 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
49 #if defined(LIBC_SCCS) && !defined(lint)
50 static char sccsid[] = "@(#)fts.c 8.6 (Berkeley) 8/14/94";
51 #endif /* LIBC_SCCS and not lint */
55 #if HAVE_SYS_PARAM_H || defined _LIBC
56 # include <sys/param.h>
59 # include <include/sys/stat.h>
61 # include <sys/stat.h>
73 # include "unistd--.h"
74 # include "same-inode.h"
78 #ifndef _D_EXACT_NAMLEN
79 # define _D_EXACT_NAMLEN(dirent) strlen ((dirent)->d_name)
82 #if HAVE_STRUCT_DIRENT_D_TYPE
83 /* True if the type of the directory entry D is known. */
84 # define DT_IS_KNOWN(d) ((d)->d_type != DT_UNKNOWN)
85 /* True if the type of the directory entry D must be T. */
86 # define DT_MUST_BE(d, t) ((d)->d_type == (t))
88 # define DT_IS_KNOWN(d) false
89 # define DT_MUST_BE(d, t) false
94 NOT_AN_INODE_NUMBER = 0
97 #ifdef D_INO_IN_DIRENT
98 # define D_INO(dp) (dp)->d_ino
100 /* Some systems don't have inodes, so fake them to avoid lots of ifdefs. */
101 # define D_INO(dp) NOT_AN_INODE_NUMBER
104 /* If there are more than this many entries in a directory,
105 and the conditions mentioned below are satisfied, then sort
106 the entries on inode number before any further processing. */
107 #ifndef FTS_INODE_SORT_DIR_ENTRIES_THRESHOLD
108 # define FTS_INODE_SORT_DIR_ENTRIES_THRESHOLD 10000
112 _FTS_INODE_SORT_DIR_ENTRIES_THRESHOLD = FTS_INODE_SORT_DIR_ENTRIES_THRESHOLD
117 FTS_NO_STAT_REQUIRED = 1,
118 FTS_STAT_REQUIRED = 2
123 # define close __close
125 # define closedir __closedir
127 # define fchdir __fchdir
131 # define opendir __opendir
133 # define readdir __readdir
135 # undef internal_function
136 # define internal_function /* empty */
140 # define __set_errno(Val) errno = (Val)
143 #ifndef __attribute__
144 # if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 8)
145 # define __attribute__(x) /* empty */
149 #ifndef ATTRIBUTE_UNUSED
150 # define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
153 /* If this host provides the openat function, then we can avoid
154 attempting to open "." in some initialization code below. */
156 # define HAVE_OPENAT_SUPPORT 1
158 # define HAVE_OPENAT_SUPPORT 0
162 # define fts_assert(expr) ((void) 0)
164 # define fts_assert(expr) \
173 static FTSENT *fts_alloc (FTS *, const char *, size_t) internal_function;
174 static FTSENT *fts_build (FTS *, int) internal_function;
175 static void fts_lfree (FTSENT *) internal_function;
176 static void fts_load (FTS *, FTSENT *) internal_function;
177 static size_t fts_maxarglen (char * const *) internal_function;
178 static void fts_padjust (FTS *, FTSENT *) internal_function;
179 static bool fts_palloc (FTS *, size_t) internal_function;
180 static FTSENT *fts_sort (FTS *, FTSENT *, size_t) internal_function;
181 static unsigned short int fts_stat (FTS *, FTSENT *, bool) internal_function;
182 static int fts_safe_changedir (FTS *, FTSENT *, int, const char *)
186 # include "fts-cycle.c"
188 static bool enter_dir (FTS *fts, FTSENT *ent) { return true; }
189 static void leave_dir (FTS *fts, FTSENT *ent) {}
190 static bool setup_dir (FTS *fts) { return true; }
191 static void free_dir (FTS *fts) {}
195 # define MAX(a,b) ((a) > (b) ? (a) : (b))
199 # define SIZE_MAX ((size_t) -1)
203 # define O_DIRECTORY 0
206 #define ISDOT(a) (a[0] == '.' && (!a[1] || (a[1] == '.' && !a[2])))
207 #define STREQ(a, b) (strcmp ((a), (b)) == 0)
209 #define CLR(opt) (sp->fts_options &= ~(opt))
210 #define ISSET(opt) (sp->fts_options & (opt))
211 #define SET(opt) (sp->fts_options |= (opt))
213 /* FIXME: make this a function */
214 #define RESTORE_INITIAL_CWD(sp) \
215 (fd_ring_clear (&((sp)->fts_fd_ring)), \
216 FCHDIR ((sp), (ISSET (FTS_CWDFD) ? AT_FDCWD : (sp)->fts_rfd)))
218 /* FIXME: FTS_NOCHDIR is now misnamed.
219 Call it FTS_USE_FULL_RELATIVE_FILE_NAMES instead. */
220 #define FCHDIR(sp, fd) \
221 (!ISSET(FTS_NOCHDIR) && (ISSET(FTS_CWDFD) \
222 ? (cwd_advance_fd ((sp), (fd), true), 0) \
226 /* fts_build flags */
227 /* FIXME: make this an enum */
228 #define BCHILD 1 /* fts_children */
229 #define BNAMES 2 /* fts_children, names only */
230 #define BREAD 3 /* fts_read */
233 # include <inttypes.h>
236 # include "getcwdat.h"
237 bool fts_debug = false;
238 # define Dprintf(x) do { if (fts_debug) printf x; } while (false)
241 # define fd_ring_check(x)
242 # define fd_ring_print(a, b, c)
245 #define LEAVE_DIR(Fts, Ent, Tag) \
248 Dprintf ((" %s-leaving: %s\n", Tag, (Ent)->fts_path)); \
249 leave_dir (Fts, Ent); \
250 fd_ring_check (Fts); \
255 fd_ring_clear (I_ring *fd_ring)
257 while ( ! i_ring_empty (fd_ring))
259 int fd = i_ring_pop (fd_ring);
265 /* Overload the fts_statp->st_size member (otherwise unused, when
266 fts_info is FTS_NSOK) to indicate whether fts_read should stat
267 this entry or not. */
269 fts_set_stat_required (FTSENT *p, bool required)
271 fts_assert (p->fts_info == FTS_NSOK);
272 p->fts_statp->st_size = (required
274 : FTS_NO_STAT_REQUIRED);
277 /* file-descriptor-relative opendir. */
278 /* FIXME: if others need this function, move it into lib/openat.c */
281 opendirat (int fd, char const *dir)
283 int new_fd = openat (fd, dir, O_RDONLY);
288 dirp = fdopendir (new_fd);
291 int saved_errno = errno;
298 /* Virtual fchdir. Advance SP's working directory file descriptor,
299 SP->fts_cwd_fd, to FD, and push the previous value onto the fd_ring.
300 CHDIR_DOWN_ONE is true if FD corresponds to an entry in the directory
301 open on sp->fts_cwd_fd; i.e., to move the working directory one level
305 cwd_advance_fd (FTS *sp, int fd, bool chdir_down_one)
307 int old = sp->fts_cwd_fd;
308 fts_assert (old != fd || old == AT_FDCWD);
312 /* Push "old" onto the ring.
313 If the displaced file descriptor is non-negative, close it. */
314 int prev_fd_in_slot = i_ring_push (&sp->fts_fd_ring, old);
315 fd_ring_print (sp, stderr, "post-push");
316 if (0 <= prev_fd_in_slot)
317 close (prev_fd_in_slot); /* ignore any close failure */
319 else if ( ! ISSET (FTS_NOCHDIR))
322 close (old); /* ignore any close failure */
328 /* Open the directory DIR if possible, and return a file
329 descriptor. Return -1 and set errno on failure. It doesn't matter
330 whether the file descriptor has read or write access. */
334 diropen (FTS const *sp, char const *dir)
336 int open_flags = (O_RDONLY | O_DIRECTORY | O_NOCTTY | O_NONBLOCK
337 | (ISSET (FTS_PHYSICAL) ? O_NOFOLLOW : 0));
339 return (ISSET (FTS_CWDFD)
340 ? openat (sp->fts_cwd_fd, dir, open_flags)
341 : open (dir, open_flags));
345 fts_open (char * const *argv,
346 register int options,
347 int (*compar) (FTSENT const **, FTSENT const **))
350 register FTSENT *p, *root;
351 register size_t nitems;
352 FTSENT *parent = NULL;
353 FTSENT *tmp = NULL; /* pacify gcc */
358 if (options & ~FTS_OPTIONMASK) {
359 __set_errno (EINVAL);
362 if ((options & FTS_NOCHDIR) && (options & FTS_CWDFD)) {
363 __set_errno (EINVAL);
366 if ( ! (options & (FTS_LOGICAL | FTS_PHYSICAL))) {
367 __set_errno (EINVAL);
371 /* Allocate/initialize the stream */
372 if ((sp = malloc(sizeof(FTS))) == NULL)
374 memset(sp, 0, sizeof(FTS));
375 sp->fts_compar = compar;
376 sp->fts_options = options;
378 /* Logical walks turn on NOCHDIR; symbolic links are too hard. */
379 if (ISSET(FTS_LOGICAL)) {
384 /* Initialize fts_cwd_fd. */
385 sp->fts_cwd_fd = AT_FDCWD;
386 if ( ISSET(FTS_CWDFD) && ! HAVE_OPENAT_SUPPORT)
388 /* While it isn't technically necessary to open "." this
389 early, doing it here saves us the trouble of ensuring
390 later (where it'd be messier) that "." can in fact
391 be opened. If not, revert to FTS_NOCHDIR mode. */
392 int fd = open (".", O_RDONLY);
395 /* Even if `.' is unreadable, don't revert to FTS_NOCHDIR mode
396 on systems like Linux+PROC_FS, where our openat emulation
397 is good enough. Note: on a system that emulates
398 openat via /proc, this technique can still fail, but
399 only in extreme conditions, e.g., when the working
400 directory cannot be saved (i.e. save_cwd fails) --
401 and that happens on Linux only when "." is unreadable
402 and the CWD would be longer than PATH_MAX.
403 FIXME: once Linux kernel openat support is well established,
404 replace the above open call and this entire if/else block
405 with the body of the if-block below. */
406 if ( openat_needs_fchdir ())
419 * Start out with 1K of file name space, and enough, in any case,
420 * to hold the user's file names.
423 # define MAXPATHLEN 1024
426 size_t maxarglen = fts_maxarglen(argv);
427 if (! fts_palloc(sp, MAX(maxarglen, MAXPATHLEN)))
431 /* Allocate/initialize root's parent. */
433 if ((parent = fts_alloc(sp, "", 0)) == NULL)
435 parent->fts_level = FTS_ROOTPARENTLEVEL;
438 /* The classic fts implementation would call fts_stat with
439 a new entry for each iteration of the loop below.
440 If the comparison function is not specified or if the
441 FTS_DEFER_STAT option is in effect, don't stat any entry
442 in this loop. This is an attempt to minimize the interval
443 between the initial stat/lstat/fstatat and the point at which
444 a directory argument is first opened. This matters for any
445 directory command line argument that resides on a file system
446 without genuine i-nodes. If you specify FTS_DEFER_STAT along
447 with a comparison function, that function must not access any
448 data via the fts_statp pointer. */
449 defer_stat = (compar == NULL || ISSET(FTS_DEFER_STAT));
451 /* Allocate/initialize root(s). */
452 for (root = NULL, nitems = 0; *argv != NULL; ++argv, ++nitems) {
453 /* Don't allow zero-length file names. */
454 if ((len = strlen(*argv)) == 0) {
455 __set_errno (ENOENT);
459 if ((p = fts_alloc(sp, *argv, len)) == NULL)
461 p->fts_level = FTS_ROOTLEVEL;
462 p->fts_parent = parent;
463 p->fts_accpath = p->fts_name;
464 /* Even when defer_stat is true, be sure to stat the first
465 command line argument, since fts_read (at least with
466 FTS_XDEV) requires that. */
467 if (defer_stat && root != NULL) {
468 p->fts_info = FTS_NSOK;
469 fts_set_stat_required(p, true);
471 p->fts_info = fts_stat(sp, p, false);
475 * If comparison routine supplied, traverse in sorted
476 * order; otherwise traverse in the order specified.
491 if (compar && nitems > 1)
492 root = fts_sort(sp, root, nitems);
495 * Allocate a dummy pointer and make fts_read think that we've just
496 * finished the node before the root(s); set p->fts_info to FTS_INIT
497 * so that everything about the "current" node is ignored.
499 if ((sp->fts_cur = fts_alloc(sp, "", 0)) == NULL)
501 sp->fts_cur->fts_link = root;
502 sp->fts_cur->fts_info = FTS_INIT;
503 if (! setup_dir (sp))
507 * If using chdir(2), grab a file descriptor pointing to dot to ensure
508 * that we can get back here; this could be avoided for some file names,
509 * but almost certainly not worth the effort. Slashes, symbolic links,
510 * and ".." are all fairly nasty problems. Note, if we can't get the
511 * descriptor we run anyway, just more slowly.
513 if (!ISSET(FTS_NOCHDIR) && !ISSET(FTS_CWDFD)
514 && (sp->fts_rfd = diropen (sp, ".")) < 0)
517 i_ring_init (&sp->fts_fd_ring, -1);
520 mem3: fts_lfree(root);
522 mem2: free(sp->fts_path);
529 fts_load (FTS *sp, register FTSENT *p)
535 * Load the stream structure for the next traversal. Since we don't
536 * actually enter the directory until after the preorder visit, set
537 * the fts_accpath field specially so the chdir gets done to the right
538 * place and the user can access the first node. From fts_open it's
539 * known that the file name will fit.
541 len = p->fts_pathlen = p->fts_namelen;
542 memmove(sp->fts_path, p->fts_name, len + 1);
543 if ((cp = strrchr(p->fts_name, '/')) && (cp != p->fts_name || cp[1])) {
545 memmove(p->fts_name, cp, len + 1);
546 p->fts_namelen = len;
548 p->fts_accpath = p->fts_path = sp->fts_path;
554 register FTSENT *freep, *p;
558 * This still works if we haven't read anything -- the dummy structure
559 * points to the root list, so we step through to the end of the root
560 * list which has a valid parent pointer.
563 for (p = sp->fts_cur; p->fts_level >= FTS_ROOTLEVEL;) {
565 p = p->fts_link != NULL ? p->fts_link : p->fts_parent;
571 /* Free up child linked list, sort array, file name buffer. */
573 fts_lfree(sp->fts_child);
577 if (ISSET(FTS_CWDFD))
579 if (0 <= sp->fts_cwd_fd)
580 close (sp->fts_cwd_fd);
582 else if (!ISSET(FTS_NOCHDIR))
584 /* Return to original directory, save errno if necessary. */
585 if (fchdir(sp->fts_rfd))
590 fd_ring_clear (&sp->fts_fd_ring);
593 /* Free up the stream pointer. */
596 /* Set errno and return. */
598 __set_errno (saved_errno);
606 * Special case of "/" at the end of the file name so that slashes aren't
607 * appended which would cause file names to be written as "....//foo".
610 (p->fts_path[p->fts_pathlen - 1] == '/' \
611 ? p->fts_pathlen - 1 : p->fts_pathlen)
614 fts_read (register FTS *sp)
616 register FTSENT *p, *tmp;
617 register unsigned short int instr;
620 /* If finished or unrecoverable error, return NULL. */
621 if (sp->fts_cur == NULL || ISSET(FTS_STOP))
624 /* Set current node pointer. */
627 /* Save and zero out user instructions. */
628 instr = p->fts_instr;
629 p->fts_instr = FTS_NOINSTR;
631 /* Any type of file may be re-visited; re-stat and re-turn. */
632 if (instr == FTS_AGAIN) {
633 p->fts_info = fts_stat(sp, p, false);
636 Dprintf (("fts_read: p=%s\n",
637 p->fts_info == FTS_INIT ? "" : p->fts_path));
640 * Following a symlink -- SLNONE test allows application to see
641 * SLNONE and recover. If indirecting through a symlink, have
642 * keep a pointer to current location. If unable to get that
643 * pointer, follow fails.
645 if (instr == FTS_FOLLOW &&
646 (p->fts_info == FTS_SL || p->fts_info == FTS_SLNONE)) {
647 p->fts_info = fts_stat(sp, p, true);
648 if (p->fts_info == FTS_D && !ISSET(FTS_NOCHDIR)) {
649 if ((p->fts_symfd = diropen (sp, ".")) < 0) {
650 p->fts_errno = errno;
651 p->fts_info = FTS_ERR;
653 p->fts_flags |= FTS_SYMFOLLOW;
658 /* Directory in pre-order. */
659 if (p->fts_info == FTS_D) {
660 /* If skipped or crossed mount point, do post-order visit. */
661 if (instr == FTS_SKIP ||
662 (ISSET(FTS_XDEV) && p->fts_statp->st_dev != sp->fts_dev)) {
663 if (p->fts_flags & FTS_SYMFOLLOW)
664 (void)close(p->fts_symfd);
666 fts_lfree(sp->fts_child);
667 sp->fts_child = NULL;
669 p->fts_info = FTS_DP;
670 LEAVE_DIR (sp, p, "1");
674 /* Rebuild if only read the names and now traversing. */
675 if (sp->fts_child != NULL && ISSET(FTS_NAMEONLY)) {
677 fts_lfree(sp->fts_child);
678 sp->fts_child = NULL;
682 * Cd to the subdirectory.
684 * If have already read and now fail to chdir, whack the list
685 * to make the names come out right, and set the parent errno
686 * so the application will eventually get an error condition.
687 * Set the FTS_DONTCHDIR flag so that when we logically change
688 * directories back to the parent we don't do a chdir.
690 * If haven't read do so. If the read fails, fts_build sets
691 * FTS_STOP or the fts_info field of the node.
693 if (sp->fts_child != NULL) {
694 if (fts_safe_changedir(sp, p, -1, p->fts_accpath)) {
695 p->fts_errno = errno;
696 p->fts_flags |= FTS_DONTCHDIR;
697 for (p = sp->fts_child; p != NULL;
700 p->fts_parent->fts_accpath;
702 } else if ((sp->fts_child = fts_build(sp, BREAD)) == NULL) {
705 /* If fts_build's call to fts_safe_changedir failed
706 because it was not able to fchdir into a
707 subdirectory, tell the caller. */
708 if (p->fts_errno && p->fts_info != FTS_DNR)
709 p->fts_info = FTS_ERR;
710 LEAVE_DIR (sp, p, "2");
714 sp->fts_child = NULL;
718 /* Move to the next node on this level. */
720 if ((p = p->fts_link) != NULL) {
725 * If reached the top, return to the original directory (or
726 * the root of the tree), and load the file names for the next
729 if (p->fts_level == FTS_ROOTLEVEL) {
730 if (RESTORE_INITIAL_CWD(sp)) {
739 * User may have called fts_set on the node. If skipped,
740 * ignore. If followed, get a file descriptor so we can
741 * get back if necessary.
743 if (p->fts_instr == FTS_SKIP)
745 if (p->fts_instr == FTS_FOLLOW) {
746 p->fts_info = fts_stat(sp, p, true);
747 if (p->fts_info == FTS_D && !ISSET(FTS_NOCHDIR)) {
748 if ((p->fts_symfd = diropen (sp, ".")) < 0) {
749 p->fts_errno = errno;
750 p->fts_info = FTS_ERR;
752 p->fts_flags |= FTS_SYMFOLLOW;
754 p->fts_instr = FTS_NOINSTR;
757 name: t = sp->fts_path + NAPPEND(p->fts_parent);
759 memmove(t, p->fts_name, p->fts_namelen + 1);
762 if (p->fts_info == FTS_NSOK)
764 if (p->fts_statp->st_size == FTS_STAT_REQUIRED)
765 p->fts_info = fts_stat(sp, p, false);
767 fts_assert (p->fts_statp->st_size == FTS_NO_STAT_REQUIRED);
770 if (p->fts_info == FTS_D)
772 /* Now that P->fts_statp is guaranteed to be valid,
773 if this is a command-line directory, record its
774 device number, to be used for FTS_XDEV. */
775 if (p->fts_level == FTS_ROOTLEVEL)
776 sp->fts_dev = p->fts_statp->st_dev;
777 Dprintf ((" entering: %s\n", p->fts_path));
778 if (! enter_dir (sp, p))
780 __set_errno (ENOMEM);
787 /* Move up to the parent node. */
792 if (p->fts_level == FTS_ROOTPARENTLEVEL) {
794 * Done; free everything up and set errno to 0 so the user
795 * can distinguish between error and EOF.
799 return (sp->fts_cur = NULL);
802 fts_assert (p->fts_info != FTS_NSOK);
804 /* NUL terminate the file name. */
805 sp->fts_path[p->fts_pathlen] = '\0';
808 * Return to the parent directory. If at a root node, restore
809 * the initial working directory. If we came through a symlink,
810 * go back through the file descriptor. Otherwise, move up
811 * one level, via "..".
813 if (p->fts_level == FTS_ROOTLEVEL) {
814 if (RESTORE_INITIAL_CWD(sp)) {
815 p->fts_errno = errno;
818 } else if (p->fts_flags & FTS_SYMFOLLOW) {
819 if (FCHDIR(sp, p->fts_symfd)) {
820 int saved_errno = errno;
821 (void)close(p->fts_symfd);
822 __set_errno (saved_errno);
823 p->fts_errno = errno;
826 (void)close(p->fts_symfd);
827 } else if (!(p->fts_flags & FTS_DONTCHDIR) &&
828 fts_safe_changedir(sp, p->fts_parent, -1, "..")) {
829 p->fts_errno = errno;
832 p->fts_info = p->fts_errno ? FTS_ERR : FTS_DP;
833 if (p->fts_errno == 0)
834 LEAVE_DIR (sp, p, "3");
835 return ISSET(FTS_STOP) ? NULL : p;
839 * Fts_set takes the stream as an argument although it's not used in this
840 * implementation; it would be necessary if anyone wanted to add global
841 * semantics to fts using fts_set. An error return is allowed for similar
846 fts_set(FTS *sp ATTRIBUTE_UNUSED, FTSENT *p, int instr)
848 if (instr != 0 && instr != FTS_AGAIN && instr != FTS_FOLLOW &&
849 instr != FTS_NOINSTR && instr != FTS_SKIP) {
850 __set_errno (EINVAL);
853 p->fts_instr = instr;
858 fts_children (register FTS *sp, int instr)
863 if (instr != 0 && instr != FTS_NAMEONLY) {
864 __set_errno (EINVAL);
868 /* Set current node pointer. */
872 * Errno set to 0 so user can distinguish empty directory from
877 /* Fatal errors stop here. */
881 /* Return logical hierarchy of user's arguments. */
882 if (p->fts_info == FTS_INIT)
883 return (p->fts_link);
886 * If not a directory being visited in pre-order, stop here. Could
887 * allow FTS_DNR, assuming the user has fixed the problem, but the
888 * same effect is available with FTS_AGAIN.
890 if (p->fts_info != FTS_D /* && p->fts_info != FTS_DNR */)
893 /* Free up any previous child list. */
894 if (sp->fts_child != NULL)
895 fts_lfree(sp->fts_child);
897 if (instr == FTS_NAMEONLY) {
904 * If using chdir on a relative file name and called BEFORE fts_read
905 * does its chdir to the root of a traversal, we can lose -- we need to
906 * chdir into the subdirectory, and we don't know where the current
907 * directory is, so we can't get back so that the upcoming chdir by
908 * fts_read will work.
910 if (p->fts_level != FTS_ROOTLEVEL || p->fts_accpath[0] == '/' ||
912 return (sp->fts_child = fts_build(sp, instr));
914 if ((fd = diropen (sp, ".")) < 0)
915 return (sp->fts_child = NULL);
916 sp->fts_child = fts_build(sp, instr);
917 if (ISSET(FTS_CWDFD))
919 cwd_advance_fd (sp, fd, true);
925 int saved_errno = errno;
927 __set_errno (saved_errno);
932 return (sp->fts_child);
935 #if defined __linux__ \
936 && HAVE_SYS_VFS_H && HAVE_FSTATFS && HAVE_STRUCT_STATFS_F_TYPE
940 /* Linux-specific constants from coreutils' src/fs.h */
941 # define S_MAGIC_TMPFS 0x1021994
942 # define S_MAGIC_NFS 0x6969
944 /* Return false if it is easy to determine the file system type of
945 the directory on which DIR_FD is open, and sorting dirents on
946 inode numbers is known not to improve traversal performance with
947 that type of file system. Otherwise, return true. */
949 dirent_inode_sort_may_be_useful (int dir_fd)
951 /* Skip the sort only if we can determine efficiently
952 that skipping it is the right thing to do.
953 The cost of performing an unnecessary sort is negligible,
954 while the cost of *not* performing it can be O(N^2) with
955 a very large constant. */
956 struct statfs fs_buf;
958 /* If fstatfs fails, assume sorting would be useful. */
959 if (fstatfs (dir_fd, &fs_buf) != 0)
962 /* FIXME: what about when f_type is not an integral type?
963 deal with that if/when it's encountered. */
964 switch (fs_buf.f_type)
968 /* On a file system of any of these types, sorting
969 is unnecessary, and hence wasteful. */
977 static bool dirent_inode_sort_may_be_useful (int dir_fd) { return true; }
980 /* A comparison function to sort on increasing inode number.
981 For some file system types, sorting either way makes a huge
982 performance difference for a directory with very many entries,
983 but sorting on increasing values is slightly better than sorting
984 on decreasing values. The difference is in the 5% range. */
986 fts_compare_ino (struct _ftsent const **a, struct _ftsent const **b)
988 return (a[0]->fts_statp->st_ino < b[0]->fts_statp->st_ino ? -1
989 : b[0]->fts_statp->st_ino < a[0]->fts_statp->st_ino ? 1 : 0);
993 * This is the tricky part -- do not casually change *anything* in here. The
994 * idea is to build the linked list of entries that are used by fts_children
995 * and fts_read. There are lots of special cases.
997 * The real slowdown in walking the tree is the stat calls. If FTS_NOSTAT is
998 * set and it's a physical walk (so that symbolic links can't be directories),
999 * we can do things quickly. First, if it's a 4.4BSD file system, the type
1000 * of the file is in the directory entry. Otherwise, we assume that the number
1001 * of subdirectories in a node is equal to the number of links to the parent.
1002 * The former skips all stat calls. The latter skips stat calls in any leaf
1003 * directories and for any files after the subdirectories in the directory have
1004 * been found, cutting the stat calls by about 2/3.
1008 fts_build (register FTS *sp, int type)
1010 register struct dirent *dp;
1011 register FTSENT *p, *head;
1012 register size_t nitems;
1022 size_t len, maxlen, new_len;
1025 /* Set current node pointer. */
1029 * Open the directory for reading. If this fails, we're done.
1030 * If being called from fts_read, set the fts_info field.
1032 #if defined FTS_WHITEOUT && 0
1033 if (ISSET(FTS_WHITEOUT))
1034 oflag = DTF_NODUP|DTF_REWIND;
1036 oflag = DTF_HIDEW|DTF_NODUP|DTF_REWIND;
1038 # define __opendir2(file, flag) \
1039 ( ! ISSET(FTS_NOCHDIR) && ISSET(FTS_CWDFD) \
1040 ? opendirat(sp->fts_cwd_fd, file) \
1043 if ((dirp = __opendir2(cur->fts_accpath, oflag)) == NULL) {
1044 if (type == BREAD) {
1045 cur->fts_info = FTS_DNR;
1046 cur->fts_errno = errno;
1050 /* Rather than calling fts_stat for each and every entry encountered
1051 in the readdir loop (below), stat each directory only right after
1053 if (cur->fts_info == FTS_NSOK)
1054 cur->fts_info = fts_stat(sp, cur, false);
1057 * Nlinks is the number of possible entries of type directory in the
1058 * directory if we're cheating on stat calls, 0 if we're not doing
1059 * any stat calls at all, (nlink_t) -1 if we're statting everything.
1061 if (type == BNAMES) {
1063 /* Be quiet about nostat, GCC. */
1065 } else if (ISSET(FTS_NOSTAT) && ISSET(FTS_PHYSICAL)) {
1066 nlinks = (cur->fts_statp->st_nlink
1067 - (ISSET(FTS_SEEDOT) ? 0 : 2));
1075 * If we're going to need to stat anything or we want to descend
1076 * and stay in the directory, chdir. If this fails we keep going,
1077 * but set a flag so we don't chdir after the post-order visit.
1078 * We won't be able to stat anything, but we can still return the
1079 * names themselves. Note, that since fts_read won't be able to
1080 * chdir into the directory, it will have to return different file
1081 * names than before, i.e. "a/b" instead of "b". Since the node
1082 * has already been visited in pre-order, have to wait until the
1083 * post-order visit to return the error. There is a special case
1084 * here, if there was nothing to stat then it's not an error to
1085 * not be able to stat. This is all fairly nasty. If a program
1086 * needed sorted entries or stat information, they had better be
1087 * checking FTS_NS on the returned nodes.
1089 if (nlinks || type == BREAD) {
1090 int dir_fd = dirfd(dirp);
1091 if (ISSET(FTS_CWDFD) && 0 <= dir_fd)
1092 dir_fd = dup (dir_fd);
1093 if (dir_fd < 0 || fts_safe_changedir(sp, cur, dir_fd, NULL)) {
1094 if (nlinks && type == BREAD)
1095 cur->fts_errno = errno;
1096 cur->fts_flags |= FTS_DONTCHDIR;
1099 if (ISSET(FTS_CWDFD) && 0 <= dir_fd)
1108 * Figure out the max file name length that can be stored in the
1109 * current buffer -- the inner loop allocates more space as necessary.
1110 * We really wouldn't have to do the maxlen calculations here, we
1111 * could do them in fts_read before returning the name, but it's a
1112 * lot easier here since the length is part of the dirent structure.
1114 * If not changing directories set a pointer so that can just append
1115 * each new component into the file name.
1118 if (ISSET(FTS_NOCHDIR)) {
1119 cp = sp->fts_path + len;
1122 /* GCC, you're too verbose. */
1126 maxlen = sp->fts_pathlen - len;
1128 level = cur->fts_level + 1;
1130 /* Read the directory, attaching each entry to the `link' pointer. */
1132 for (head = tail = NULL, nitems = 0; dirp && (dp = readdir(dirp));) {
1135 if (!ISSET(FTS_SEEDOT) && ISDOT(dp->d_name))
1138 if ((p = fts_alloc (sp, dp->d_name,
1139 _D_EXACT_NAMLEN (dp))) == NULL)
1141 if (_D_EXACT_NAMLEN (dp) >= maxlen) {
1142 /* include space for NUL */
1143 oldaddr = sp->fts_path;
1144 if (! fts_palloc(sp, _D_EXACT_NAMLEN (dp) + len + 1)) {
1146 * No more memory. Save
1147 * errno, free up the current structure and the
1148 * structures already allocated.
1150 mem1: saved_errno = errno;
1154 cur->fts_info = FTS_ERR;
1156 __set_errno (saved_errno);
1159 /* Did realloc() change the pointer? */
1160 if (oldaddr != sp->fts_path) {
1162 if (ISSET(FTS_NOCHDIR))
1163 cp = sp->fts_path + len;
1165 maxlen = sp->fts_pathlen - len;
1168 new_len = len + _D_EXACT_NAMLEN (dp);
1169 if (new_len < len) {
1171 * In the unlikely event that we would end up
1172 * with a file name longer than SIZE_MAX, free up
1173 * the current structure and the structures already
1174 * allocated, then error out with ENAMETOOLONG.
1179 cur->fts_info = FTS_ERR;
1181 __set_errno (ENAMETOOLONG);
1184 p->fts_level = level;
1185 p->fts_parent = sp->fts_cur;
1186 p->fts_pathlen = new_len;
1188 #if defined FTS_WHITEOUT && 0
1189 if (dp->d_type == DT_WHT)
1190 p->fts_flags |= FTS_ISW;
1192 /* Store dirent.d_ino, in case we need to sort
1193 entries before processing them. */
1194 p->fts_statp->st_ino = D_INO (dp);
1196 /* Build a file name for fts_stat to stat. */
1197 if (ISSET(FTS_NOCHDIR)) {
1198 p->fts_accpath = p->fts_path;
1199 memmove(cp, p->fts_name, p->fts_namelen + 1);
1201 p->fts_accpath = p->fts_name;
1203 if (sp->fts_compar == NULL || ISSET(FTS_DEFER_STAT)) {
1204 /* Record what fts_read will have to do with this
1205 entry. In many cases, it will simply fts_stat it,
1206 but we can take advantage of any d_type information
1207 to optimize away the unnecessary stat calls. I.e.,
1208 if FTS_NOSTAT is in effect and we're not following
1209 symlinks (FTS_PHYSICAL) and d_type indicates this
1210 is *not* a directory, then we won't have to stat it
1211 at all. If it *is* a directory, then (currently)
1212 we stat it regardless, in order to get device and
1213 inode numbers. Some day we might optimize that
1214 away, too, for directories where d_ino is known to
1216 bool skip_stat = (ISSET(FTS_PHYSICAL)
1217 && ISSET(FTS_NOSTAT)
1219 && ! DT_MUST_BE(dp, DT_DIR));
1220 p->fts_info = FTS_NSOK;
1221 fts_set_stat_required(p, !skip_stat);
1222 is_dir = (ISSET(FTS_PHYSICAL) && ISSET(FTS_NOSTAT)
1223 && DT_MUST_BE(dp, DT_DIR));
1225 p->fts_info = fts_stat(sp, p, false);
1226 is_dir = (p->fts_info == FTS_D
1227 || p->fts_info == FTS_DC
1228 || p->fts_info == FTS_DOT);
1231 /* Decrement link count if applicable. */
1232 if (nlinks > 0 && is_dir)
1235 /* We walk in directory order so "ls -f" doesn't get upset. */
1249 * If realloc() changed the address of the file name, adjust the
1250 * addresses for the rest of the tree and the dir list.
1253 fts_padjust(sp, head);
1256 * If not changing directories, reset the file name back to original
1259 if (ISSET(FTS_NOCHDIR)) {
1260 if (len == sp->fts_pathlen || nitems == 0)
1266 * If descended after called from fts_children or after called from
1267 * fts_read and nothing found, get back. At the root level we use
1268 * the saved fd; if one of fts_open()'s arguments is a relative name
1269 * to an empty directory, we wind up here with no other way back. If
1270 * can't get back, we're done.
1272 if (descend && (type == BCHILD || !nitems) &&
1273 (cur->fts_level == FTS_ROOTLEVEL
1274 ? RESTORE_INITIAL_CWD(sp)
1275 : fts_safe_changedir(sp, cur->fts_parent, -1, ".."))) {
1276 cur->fts_info = FTS_ERR;
1282 /* If didn't find anything, return NULL. */
1285 cur->fts_info = FTS_DP;
1290 /* If there are many entries, no sorting function has been specified,
1291 and this file system is of a type that may be slow with a large
1292 number of entries, then sort the directory entries on increasing
1294 if (nitems > _FTS_INODE_SORT_DIR_ENTRIES_THRESHOLD
1296 && ISSET (FTS_CWDFD)
1297 && dirent_inode_sort_may_be_useful (sp->fts_cwd_fd)) {
1298 sp->fts_compar = fts_compare_ino;
1299 head = fts_sort (sp, head, nitems);
1300 sp->fts_compar = NULL;
1303 /* Sort the entries. */
1304 if (sp->fts_compar && nitems > 1)
1305 head = fts_sort(sp, head, nitems);
1311 /* Walk ->fts_parent links starting at E_CURR, until the root of the
1312 current hierarchy. There should be a directory with dev/inode
1313 matching those of AD. If not, print a lot of diagnostics. */
1315 find_matching_ancestor (FTSENT const *e_curr, struct Active_dir const *ad)
1318 for (ent = e_curr; ent->fts_level >= FTS_ROOTLEVEL; ent = ent->fts_parent)
1320 if (ad->ino == ent->fts_statp->st_ino
1321 && ad->dev == ent->fts_statp->st_dev)
1324 printf ("ERROR: tree dir, %s, not active\n", ad->fts_ent->fts_accpath);
1325 printf ("active dirs:\n");
1327 ent->fts_level >= FTS_ROOTLEVEL; ent = ent->fts_parent)
1328 printf (" %s(%"PRIuMAX"/%"PRIuMAX") to %s(%"PRIuMAX"/%"PRIuMAX")...\n",
1329 ad->fts_ent->fts_accpath,
1330 (uintmax_t) ad->dev,
1331 (uintmax_t) ad->ino,
1333 (uintmax_t) ent->fts_statp->st_dev,
1334 (uintmax_t) ent->fts_statp->st_ino);
1338 fts_cross_check (FTS const *sp)
1340 FTSENT const *ent = sp->fts_cur;
1342 if ( ! ISSET (FTS_TIGHT_CYCLE_CHECK))
1345 Dprintf (("fts-cross-check cur=%s\n", ent->fts_path));
1346 /* Make sure every parent dir is in the tree. */
1347 for (t = ent->fts_parent; t->fts_level >= FTS_ROOTLEVEL; t = t->fts_parent)
1349 struct Active_dir ad;
1350 ad.ino = t->fts_statp->st_ino;
1351 ad.dev = t->fts_statp->st_dev;
1352 if ( ! hash_lookup (sp->fts_cycle.ht, &ad))
1353 printf ("ERROR: active dir, %s, not in tree\n", t->fts_path);
1356 /* Make sure every dir in the tree is an active dir.
1357 But ENT is not necessarily a directory. If so, just skip this part. */
1358 if (ent->fts_parent->fts_level >= FTS_ROOTLEVEL
1359 && (ent->fts_info == FTS_DP
1360 || ent->fts_info == FTS_D))
1362 struct Active_dir *ad;
1363 for (ad = hash_get_first (sp->fts_cycle.ht); ad != NULL;
1364 ad = hash_get_next (sp->fts_cycle.ht, ad))
1366 find_matching_ancestor (ent, ad);
1372 same_fd (int fd1, int fd2)
1374 struct stat sb1, sb2;
1375 return (fstat (fd1, &sb1) == 0
1376 && fstat (fd2, &sb2) == 0
1377 && SAME_INODE (sb1, sb2));
1381 fd_ring_print (FTS const *sp, FILE *stream, char const *msg)
1383 I_ring const *fd_ring = &sp->fts_fd_ring;
1384 unsigned int i = fd_ring->fts_front;
1385 char *cwd = getcwdat (sp->fts_cwd_fd, NULL, 0);
1386 fprintf (stream, "=== %s ========== %s\n", msg, cwd);
1388 if (i_ring_empty (fd_ring))
1393 int fd = fd_ring->fts_fd_ring[i];
1395 fprintf (stream, "%d: %d:\n", i, fd);
1398 char *wd = getcwdat (fd, NULL, 0);
1399 fprintf (stream, "%d: %d: %s\n", i, fd, wd);
1402 if (i == fd_ring->fts_back)
1404 i = (i + I_RING_SIZE - 1) % I_RING_SIZE;
1408 /* Ensure that each file descriptor on the fd_ring matches a
1409 parent, grandparent, etc. of the current working directory. */
1411 fd_ring_check (FTS const *sp)
1416 /* Make a writable copy. */
1417 I_ring fd_w = sp->fts_fd_ring;
1419 int cwd_fd = sp->fts_cwd_fd;
1420 cwd_fd = dup (cwd_fd);
1421 char *dot = getcwdat (cwd_fd, NULL, 0);
1422 error (0, 0, "===== check ===== cwd: %s", dot);
1424 while ( ! i_ring_empty (&fd_w))
1426 int fd = i_ring_pop (&fd_w);
1429 int parent_fd = openat (cwd_fd, "..", O_RDONLY);
1435 if (!same_fd (fd, parent_fd))
1437 char *cwd = getcwdat (fd, NULL, 0);
1438 error (0, errno, "ring : %s", cwd);
1439 char *c2 = getcwdat (parent_fd, NULL, 0);
1440 error (0, errno, "parent: %s", c2);
1453 static unsigned short int
1455 fts_stat(FTS *sp, register FTSENT *p, bool follow)
1457 struct stat *sbp = p->fts_statp;
1460 if (p->fts_level == FTS_ROOTLEVEL && ISSET(FTS_COMFOLLOW))
1463 #if defined FTS_WHITEOUT && 0
1464 /* check for whiteout */
1465 if (p->fts_flags & FTS_ISW) {
1466 memset(sbp, '\0', sizeof (*sbp));
1467 sbp->st_mode = S_IFWHT;
1473 * If doing a logical walk, or application requested FTS_FOLLOW, do
1474 * a stat(2). If that fails, check for a non-existent symlink. If
1475 * fail, set the errno from the stat call.
1477 if (ISSET(FTS_LOGICAL) || follow) {
1478 if (stat(p->fts_accpath, sbp)) {
1479 saved_errno = errno;
1481 && lstat(p->fts_accpath, sbp) == 0) {
1483 return (FTS_SLNONE);
1485 p->fts_errno = saved_errno;
1488 } else if (fstatat(sp->fts_cwd_fd, p->fts_accpath, sbp,
1489 AT_SYMLINK_NOFOLLOW)) {
1490 p->fts_errno = errno;
1491 err: memset(sbp, 0, sizeof(struct stat));
1495 if (S_ISDIR(sbp->st_mode)) {
1496 if (ISDOT(p->fts_name)) {
1497 /* Command-line "." and ".." are real directories. */
1498 return (p->fts_level == FTS_ROOTLEVEL ? FTS_D : FTS_DOT);
1504 * Cycle detection is done by brute force when the directory
1505 * is first encountered. If the tree gets deep enough or the
1506 * number of symbolic links to directories is high enough,
1507 * something faster might be worthwhile.
1511 for (t = p->fts_parent;
1512 t->fts_level >= FTS_ROOTLEVEL; t = t->fts_parent)
1513 if (sbp->st_ino == t->fts_statp->st_ino
1514 && sbp->st_dev == t->fts_statp->st_dev)
1524 if (S_ISLNK(sbp->st_mode))
1526 if (S_ISREG(sbp->st_mode))
1528 return (FTS_DEFAULT);
1532 fts_compar (void const *a, void const *b)
1534 /* Convert A and B to the correct types, to pacify the compiler, and
1535 for portability to bizarre hosts where "void const *" and "FTSENT
1536 const **" differ in runtime representation. The comparison
1537 function cannot modify *a and *b, but there is no compile-time
1539 FTSENT const **pa = (FTSENT const **) a;
1540 FTSENT const **pb = (FTSENT const **) b;
1541 return pa[0]->fts_fts->fts_compar (pa, pb);
1546 fts_sort (FTS *sp, FTSENT *head, register size_t nitems)
1548 register FTSENT **ap, *p;
1550 /* On most modern hosts, void * and FTSENT ** have the same
1551 run-time representation, and one can convert sp->fts_compar to
1552 the type qsort expects without problem. Use the heuristic that
1553 this is OK if the two pointer types are the same size, and if
1554 converting FTSENT ** to long int is the same as converting
1555 FTSENT ** to void * and then to long int. This heuristic isn't
1556 valid in general but we don't know of any counterexamples. */
1558 int (*compare) (void const *, void const *) =
1559 ((sizeof &dummy == sizeof (void *)
1560 && (long int) &dummy == (long int) (void *) &dummy)
1561 ? (int (*) (void const *, void const *)) sp->fts_compar
1565 * Construct an array of pointers to the structures and call qsort(3).
1566 * Reassemble the array in the order returned by qsort. If unable to
1567 * sort for memory reasons, return the directory entries in their
1568 * current order. Allocate enough space for the current needs plus
1569 * 40 so don't realloc one entry at a time.
1571 if (nitems > sp->fts_nitems) {
1574 sp->fts_nitems = nitems + 40;
1575 if (SIZE_MAX / sizeof *a < sp->fts_nitems
1576 || ! (a = realloc (sp->fts_array,
1577 sp->fts_nitems * sizeof *a))) {
1578 free(sp->fts_array);
1579 sp->fts_array = NULL;
1585 for (ap = sp->fts_array, p = head; p; p = p->fts_link)
1587 qsort((void *)sp->fts_array, nitems, sizeof(FTSENT *), compare);
1588 for (head = *(ap = sp->fts_array); --nitems; ++ap)
1589 ap[0]->fts_link = ap[1];
1590 ap[0]->fts_link = NULL;
1596 fts_alloc (FTS *sp, const char *name, register size_t namelen)
1602 * The file name is a variable length array. Allocate the FTSENT
1603 * structure and the file name in one chunk.
1605 len = sizeof(FTSENT) + namelen;
1606 if ((p = malloc(len)) == NULL)
1609 /* Copy the name and guarantee NUL termination. */
1610 memmove(p->fts_name, name, namelen);
1611 p->fts_name[namelen] = '\0';
1613 p->fts_namelen = namelen;
1615 p->fts_path = sp->fts_path;
1618 p->fts_instr = FTS_NOINSTR;
1620 p->fts_pointer = NULL;
1626 fts_lfree (register FTSENT *head)
1630 /* Free a linked list of structures. */
1631 while ((p = head)) {
1632 head = head->fts_link;
1638 * Allow essentially unlimited file name lengths; find, rm, ls should
1639 * all work on any tree. Most systems will allow creation of file
1640 * names much longer than MAXPATHLEN, even though the kernel won't
1641 * resolve them. Add the size (not just what's needed) plus 256 bytes
1642 * so don't realloc the file name 2 bytes at a time.
1646 fts_palloc (FTS *sp, size_t more)
1649 size_t new_len = sp->fts_pathlen + more + 256;
1652 * See if fts_pathlen would overflow.
1654 if (new_len < sp->fts_pathlen) {
1656 sp->fts_path = NULL;
1657 __set_errno (ENAMETOOLONG);
1660 sp->fts_pathlen = new_len;
1661 p = realloc(sp->fts_path, sp->fts_pathlen);
1664 sp->fts_path = NULL;
1672 * When the file name is realloc'd, have to fix all of the pointers in
1673 * structures already returned.
1677 fts_padjust (FTS *sp, FTSENT *head)
1680 char *addr = sp->fts_path;
1682 #define ADJUST(p) do { \
1683 if ((p)->fts_accpath != (p)->fts_name) { \
1684 (p)->fts_accpath = \
1685 (char *)addr + ((p)->fts_accpath - (p)->fts_path); \
1687 (p)->fts_path = addr; \
1689 /* Adjust the current set of children. */
1690 for (p = sp->fts_child; p; p = p->fts_link)
1693 /* Adjust the rest of the tree, including the current level. */
1694 for (p = head; p->fts_level >= FTS_ROOTLEVEL;) {
1696 p = p->fts_link ? p->fts_link : p->fts_parent;
1702 fts_maxarglen (char * const *argv)
1706 for (max = 0; *argv; ++argv)
1707 if ((len = strlen(*argv)) > max)
1713 * Change to dir specified by fd or file name without getting
1714 * tricked by someone changing the world out from underneath us.
1715 * Assumes p->fts_statp->st_dev and p->fts_statp->st_ino are filled in.
1716 * If FD is non-negative, expect it to be used after this function returns,
1717 * and to be closed eventually. So don't pass e.g., `dirfd(dirp)' and then
1718 * do closedir(dirp), because that would invalidate the saved FD.
1719 * Upon failure, close FD immediately and return nonzero.
1723 fts_safe_changedir (FTS *sp, FTSENT *p, int fd, char const *dir)
1726 bool is_dotdot = dir && STREQ (dir, "..");
1729 /* This clause handles the unusual case in which FTS_NOCHDIR
1730 is specified, along with FTS_CWDFD. In that case, there is
1731 no need to change even the virtual cwd file descriptor.
1732 However, if FD is non-negative, we do close it here. */
1733 if (ISSET (FTS_NOCHDIR))
1735 if (ISSET (FTS_CWDFD) && 0 <= fd)
1740 if (fd < 0 && is_dotdot && ISSET (FTS_CWDFD))
1742 /* When possible, skip the diropen and subsequent fstat+dev/ino
1743 comparison. I.e., when changing to parent directory
1744 (chdir ("..")), use a file descriptor from the ring and
1745 save the overhead of diropen+fstat, as well as avoiding
1746 failure when we lack "x" access to the virtual cwd. */
1747 if ( ! i_ring_empty (&sp->fts_fd_ring))
1750 fd_ring_print (sp, stderr, "pre-pop");
1751 parent_fd = i_ring_pop (&sp->fts_fd_ring);
1762 if (fd < 0 && (newfd = diropen (sp, dir)) < 0)
1765 /* The following dev/inode check is necessary if we're doing a
1766 `logical' traversal (through symlinks, a la chown -L), if the
1767 system lacks O_NOFOLLOW support, or if we're changing to ".."
1768 (but not via a popped file descriptor). When changing to the
1769 name "..", O_NOFOLLOW can't help. In general, when the target is
1770 not "..", diropen's use of O_NOFOLLOW ensures we don't mistakenly
1771 follow a symlink, so we can avoid the expense of this fstat. */
1772 if (ISSET(FTS_LOGICAL) || ! HAVE_WORKING_O_NOFOLLOW
1773 || (dir && STREQ (dir, "..")))
1776 if (fstat(newfd, &sb))
1781 if (p->fts_statp->st_dev != sb.st_dev
1782 || p->fts_statp->st_ino != sb.st_ino)
1784 __set_errno (ENOENT); /* disinformation */
1790 if (ISSET(FTS_CWDFD))
1792 cwd_advance_fd (sp, newfd, ! is_dotdot);
1796 ret = fchdir(newfd);
1802 __set_errno (oerrno);