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>
74 # include "unistd--.h"
75 # include "same-inode.h"
79 #ifndef _D_EXACT_NAMLEN
80 # define _D_EXACT_NAMLEN(dirent) strlen ((dirent)->d_name)
83 #if HAVE_STRUCT_DIRENT_D_TYPE
84 /* True if the type of the directory entry D is known. */
85 # define DT_IS_KNOWN(d) ((d)->d_type != DT_UNKNOWN)
86 /* True if the type of the directory entry D must be T. */
87 # define DT_MUST_BE(d, t) ((d)->d_type == (t))
89 # define DT_IS_KNOWN(d) false
90 # define DT_MUST_BE(d, t) false
95 NOT_AN_INODE_NUMBER = 0
98 #ifdef D_INO_IN_DIRENT
99 # define D_INO(dp) (dp)->d_ino
101 /* Some systems don't have inodes, so fake them to avoid lots of ifdefs. */
102 # define D_INO(dp) NOT_AN_INODE_NUMBER
105 /* If there are more than this many entries in a directory,
106 and the conditions mentioned below are satisfied, then sort
107 the entries on inode number before any further processing. */
108 #ifndef FTS_INODE_SORT_DIR_ENTRIES_THRESHOLD
109 # define FTS_INODE_SORT_DIR_ENTRIES_THRESHOLD 10000
113 _FTS_INODE_SORT_DIR_ENTRIES_THRESHOLD = FTS_INODE_SORT_DIR_ENTRIES_THRESHOLD
118 FTS_NO_STAT_REQUIRED = 1,
119 FTS_STAT_REQUIRED = 2
124 # define close __close
126 # define closedir __closedir
128 # define fchdir __fchdir
132 # define opendir __opendir
134 # define readdir __readdir
136 # undef internal_function
137 # define internal_function /* empty */
141 # define __set_errno(Val) errno = (Val)
144 #ifndef __attribute__
145 # if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 8)
146 # define __attribute__(x) /* empty */
150 #ifndef ATTRIBUTE_UNUSED
151 # define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
154 /* If this host provides the openat function, then we can avoid
155 attempting to open "." in some initialization code below. */
157 # define HAVE_OPENAT_SUPPORT 1
159 # define HAVE_OPENAT_SUPPORT 0
163 # define fts_assert(expr) ((void) 0)
165 # define fts_assert(expr) \
174 static FTSENT *fts_alloc (FTS *, const char *, size_t) internal_function;
175 static FTSENT *fts_build (FTS *, int) internal_function;
176 static void fts_lfree (FTSENT *) internal_function;
177 static void fts_load (FTS *, FTSENT *) internal_function;
178 static size_t fts_maxarglen (char * const *) internal_function;
179 static void fts_padjust (FTS *, FTSENT *) internal_function;
180 static bool fts_palloc (FTS *, size_t) internal_function;
181 static FTSENT *fts_sort (FTS *, FTSENT *, size_t) internal_function;
182 static unsigned short int fts_stat (FTS *, FTSENT *, bool) internal_function;
183 static int fts_safe_changedir (FTS *, FTSENT *, int, const char *)
187 # include "fts-cycle.c"
189 static bool enter_dir (FTS *fts, FTSENT *ent) { return true; }
190 static void leave_dir (FTS *fts, FTSENT *ent) {}
191 static bool setup_dir (FTS *fts) { return true; }
192 static void free_dir (FTS *fts) {}
196 # define MAX(a,b) ((a) > (b) ? (a) : (b))
200 # define SIZE_MAX ((size_t) -1)
204 # define O_DIRECTORY 0
207 #define ISDOT(a) (a[0] == '.' && (!a[1] || (a[1] == '.' && !a[2])))
208 #define STREQ(a, b) (strcmp ((a), (b)) == 0)
210 #define CLR(opt) (sp->fts_options &= ~(opt))
211 #define ISSET(opt) (sp->fts_options & (opt))
212 #define SET(opt) (sp->fts_options |= (opt))
214 /* FIXME: make this a function */
215 #define RESTORE_INITIAL_CWD(sp) \
216 (fd_ring_clear (&((sp)->fts_fd_ring)), \
217 FCHDIR ((sp), (ISSET (FTS_CWDFD) ? AT_FDCWD : (sp)->fts_rfd)))
219 /* FIXME: FTS_NOCHDIR is now misnamed.
220 Call it FTS_USE_FULL_RELATIVE_FILE_NAMES instead. */
221 #define FCHDIR(sp, fd) \
222 (!ISSET(FTS_NOCHDIR) && (ISSET(FTS_CWDFD) \
223 ? (cwd_advance_fd ((sp), (fd), true), 0) \
227 /* fts_build flags */
228 /* FIXME: make this an enum */
229 #define BCHILD 1 /* fts_children */
230 #define BNAMES 2 /* fts_children, names only */
231 #define BREAD 3 /* fts_read */
234 # include <inttypes.h>
237 # include "getcwdat.h"
238 bool fts_debug = false;
239 # define Dprintf(x) do { if (fts_debug) printf x; } while (false)
242 # define fd_ring_check(x)
243 # define fd_ring_print(a, b, c)
246 #define LEAVE_DIR(Fts, Ent, Tag) \
249 Dprintf ((" %s-leaving: %s\n", Tag, (Ent)->fts_path)); \
250 leave_dir (Fts, Ent); \
251 fd_ring_check (Fts); \
256 fd_ring_clear (I_ring *fd_ring)
258 while ( ! i_ring_empty (fd_ring))
260 int fd = i_ring_pop (fd_ring);
266 /* Overload the fts_statp->st_size member (otherwise unused, when
267 fts_info is FTS_NSOK) to indicate whether fts_read should stat
268 this entry or not. */
270 fts_set_stat_required (FTSENT *p, bool required)
272 fts_assert (p->fts_info == FTS_NSOK);
273 p->fts_statp->st_size = (required
275 : FTS_NO_STAT_REQUIRED);
278 /* file-descriptor-relative opendir. */
279 /* FIXME: if others need this function, move it into lib/openat.c */
282 opendirat (int fd, char const *dir)
284 int new_fd = openat (fd, dir, O_RDONLY);
289 dirp = fdopendir (new_fd);
292 int saved_errno = errno;
299 /* Virtual fchdir. Advance SP's working directory file descriptor,
300 SP->fts_cwd_fd, to FD, and push the previous value onto the fd_ring.
301 CHDIR_DOWN_ONE is true if FD corresponds to an entry in the directory
302 open on sp->fts_cwd_fd; i.e., to move the working directory one level
306 cwd_advance_fd (FTS *sp, int fd, bool chdir_down_one)
308 int old = sp->fts_cwd_fd;
309 fts_assert (old != fd || old == AT_FDCWD);
313 /* Push "old" onto the ring.
314 If the displaced file descriptor is non-negative, close it. */
315 int prev_fd_in_slot = i_ring_push (&sp->fts_fd_ring, old);
316 fd_ring_print (sp, stderr, "post-push");
317 if (0 <= prev_fd_in_slot)
318 close (prev_fd_in_slot); /* ignore any close failure */
320 else if ( ! ISSET (FTS_NOCHDIR))
323 close (old); /* ignore any close failure */
329 /* Open the directory DIR if possible, and return a file
330 descriptor. Return -1 and set errno on failure. It doesn't matter
331 whether the file descriptor has read or write access. */
335 diropen (FTS const *sp, char const *dir)
337 int open_flags = (O_RDONLY | O_DIRECTORY | O_NOCTTY | O_NONBLOCK
338 | (ISSET (FTS_PHYSICAL) ? O_NOFOLLOW : 0));
340 return (ISSET (FTS_CWDFD)
341 ? openat (sp->fts_cwd_fd, dir, open_flags)
342 : open (dir, open_flags));
346 fts_open (char * const *argv,
347 register int options,
348 int (*compar) (FTSENT const **, FTSENT const **))
351 register FTSENT *p, *root;
352 register size_t nitems;
353 FTSENT *parent = NULL;
354 FTSENT *tmp = NULL; /* pacify gcc */
359 if (options & ~FTS_OPTIONMASK) {
360 __set_errno (EINVAL);
363 if ((options & FTS_NOCHDIR) && (options & FTS_CWDFD)) {
364 __set_errno (EINVAL);
367 if ( ! (options & (FTS_LOGICAL | FTS_PHYSICAL))) {
368 __set_errno (EINVAL);
372 /* Allocate/initialize the stream */
373 if ((sp = malloc(sizeof(FTS))) == NULL)
375 memset(sp, 0, sizeof(FTS));
376 sp->fts_compar = compar;
377 sp->fts_options = options;
379 /* Logical walks turn on NOCHDIR; symbolic links are too hard. */
380 if (ISSET(FTS_LOGICAL)) {
385 /* Initialize fts_cwd_fd. */
386 sp->fts_cwd_fd = AT_FDCWD;
387 if ( ISSET(FTS_CWDFD) && ! HAVE_OPENAT_SUPPORT)
389 /* While it isn't technically necessary to open "." this
390 early, doing it here saves us the trouble of ensuring
391 later (where it'd be messier) that "." can in fact
392 be opened. If not, revert to FTS_NOCHDIR mode. */
393 int fd = open (".", O_RDONLY);
396 /* Even if `.' is unreadable, don't revert to FTS_NOCHDIR mode
397 on systems like Linux+PROC_FS, where our openat emulation
398 is good enough. Note: on a system that emulates
399 openat via /proc, this technique can still fail, but
400 only in extreme conditions, e.g., when the working
401 directory cannot be saved (i.e. save_cwd fails) --
402 and that happens on Linux only when "." is unreadable
403 and the CWD would be longer than PATH_MAX.
404 FIXME: once Linux kernel openat support is well established,
405 replace the above open call and this entire if/else block
406 with the body of the if-block below. */
407 if ( openat_needs_fchdir ())
420 * Start out with 1K of file name space, and enough, in any case,
421 * to hold the user's file names.
424 # define MAXPATHLEN 1024
427 size_t maxarglen = fts_maxarglen(argv);
428 if (! fts_palloc(sp, MAX(maxarglen, MAXPATHLEN)))
432 /* Allocate/initialize root's parent. */
434 if ((parent = fts_alloc(sp, "", 0)) == NULL)
436 parent->fts_level = FTS_ROOTPARENTLEVEL;
439 /* The classic fts implementation would call fts_stat with
440 a new entry for each iteration of the loop below.
441 If the comparison function is not specified or if the
442 FTS_DEFER_STAT option is in effect, don't stat any entry
443 in this loop. This is an attempt to minimize the interval
444 between the initial stat/lstat/fstatat and the point at which
445 a directory argument is first opened. This matters for any
446 directory command line argument that resides on a file system
447 without genuine i-nodes. If you specify FTS_DEFER_STAT along
448 with a comparison function, that function must not access any
449 data via the fts_statp pointer. */
450 defer_stat = (compar == NULL || ISSET(FTS_DEFER_STAT));
452 /* Allocate/initialize root(s). */
453 for (root = NULL, nitems = 0; *argv != NULL; ++argv, ++nitems) {
454 /* Don't allow zero-length file names. */
455 if ((len = strlen(*argv)) == 0) {
456 __set_errno (ENOENT);
460 if ((p = fts_alloc(sp, *argv, len)) == NULL)
462 p->fts_level = FTS_ROOTLEVEL;
463 p->fts_parent = parent;
464 p->fts_accpath = p->fts_name;
465 /* Even when defer_stat is true, be sure to stat the first
466 command line argument, since fts_read (at least with
467 FTS_XDEV) requires that. */
468 if (defer_stat && root != NULL) {
469 p->fts_info = FTS_NSOK;
470 fts_set_stat_required(p, true);
472 p->fts_info = fts_stat(sp, p, false);
476 * If comparison routine supplied, traverse in sorted
477 * order; otherwise traverse in the order specified.
492 if (compar && nitems > 1)
493 root = fts_sort(sp, root, nitems);
496 * Allocate a dummy pointer and make fts_read think that we've just
497 * finished the node before the root(s); set p->fts_info to FTS_INIT
498 * so that everything about the "current" node is ignored.
500 if ((sp->fts_cur = fts_alloc(sp, "", 0)) == NULL)
502 sp->fts_cur->fts_link = root;
503 sp->fts_cur->fts_info = FTS_INIT;
504 if (! setup_dir (sp))
508 * If using chdir(2), grab a file descriptor pointing to dot to ensure
509 * that we can get back here; this could be avoided for some file names,
510 * but almost certainly not worth the effort. Slashes, symbolic links,
511 * and ".." are all fairly nasty problems. Note, if we can't get the
512 * descriptor we run anyway, just more slowly.
514 if (!ISSET(FTS_NOCHDIR) && !ISSET(FTS_CWDFD)
515 && (sp->fts_rfd = diropen (sp, ".")) < 0)
518 i_ring_init (&sp->fts_fd_ring, -1);
521 mem3: fts_lfree(root);
523 mem2: free(sp->fts_path);
530 fts_load (FTS *sp, register FTSENT *p)
536 * Load the stream structure for the next traversal. Since we don't
537 * actually enter the directory until after the preorder visit, set
538 * the fts_accpath field specially so the chdir gets done to the right
539 * place and the user can access the first node. From fts_open it's
540 * known that the file name will fit.
542 len = p->fts_pathlen = p->fts_namelen;
543 memmove(sp->fts_path, p->fts_name, len + 1);
544 if ((cp = strrchr(p->fts_name, '/')) && (cp != p->fts_name || cp[1])) {
546 memmove(p->fts_name, cp, len + 1);
547 p->fts_namelen = len;
549 p->fts_accpath = p->fts_path = sp->fts_path;
555 register FTSENT *freep, *p;
559 * This still works if we haven't read anything -- the dummy structure
560 * points to the root list, so we step through to the end of the root
561 * list which has a valid parent pointer.
564 for (p = sp->fts_cur; p->fts_level >= FTS_ROOTLEVEL;) {
566 p = p->fts_link != NULL ? p->fts_link : p->fts_parent;
572 /* Free up child linked list, sort array, file name buffer. */
574 fts_lfree(sp->fts_child);
578 if (ISSET(FTS_CWDFD))
580 if (0 <= sp->fts_cwd_fd)
581 close (sp->fts_cwd_fd);
583 else if (!ISSET(FTS_NOCHDIR))
585 /* Return to original directory, save errno if necessary. */
586 if (fchdir(sp->fts_rfd))
591 fd_ring_clear (&sp->fts_fd_ring);
594 /* Free up the stream pointer. */
597 /* Set errno and return. */
599 __set_errno (saved_errno);
607 * Special case of "/" at the end of the file name so that slashes aren't
608 * appended which would cause file names to be written as "....//foo".
611 (p->fts_path[p->fts_pathlen - 1] == '/' \
612 ? p->fts_pathlen - 1 : p->fts_pathlen)
615 fts_read (register FTS *sp)
617 register FTSENT *p, *tmp;
618 register unsigned short int instr;
621 /* If finished or unrecoverable error, return NULL. */
622 if (sp->fts_cur == NULL || ISSET(FTS_STOP))
625 /* Set current node pointer. */
628 /* Save and zero out user instructions. */
629 instr = p->fts_instr;
630 p->fts_instr = FTS_NOINSTR;
632 /* Any type of file may be re-visited; re-stat and re-turn. */
633 if (instr == FTS_AGAIN) {
634 p->fts_info = fts_stat(sp, p, false);
637 Dprintf (("fts_read: p=%s\n",
638 p->fts_info == FTS_INIT ? "" : p->fts_path));
641 * Following a symlink -- SLNONE test allows application to see
642 * SLNONE and recover. If indirecting through a symlink, have
643 * keep a pointer to current location. If unable to get that
644 * pointer, follow fails.
646 if (instr == FTS_FOLLOW &&
647 (p->fts_info == FTS_SL || p->fts_info == FTS_SLNONE)) {
648 p->fts_info = fts_stat(sp, p, true);
649 if (p->fts_info == FTS_D && !ISSET(FTS_NOCHDIR)) {
650 if ((p->fts_symfd = diropen (sp, ".")) < 0) {
651 p->fts_errno = errno;
652 p->fts_info = FTS_ERR;
654 p->fts_flags |= FTS_SYMFOLLOW;
659 /* Directory in pre-order. */
660 if (p->fts_info == FTS_D) {
661 /* If skipped or crossed mount point, do post-order visit. */
662 if (instr == FTS_SKIP ||
663 (ISSET(FTS_XDEV) && p->fts_statp->st_dev != sp->fts_dev)) {
664 if (p->fts_flags & FTS_SYMFOLLOW)
665 (void)close(p->fts_symfd);
667 fts_lfree(sp->fts_child);
668 sp->fts_child = NULL;
670 p->fts_info = FTS_DP;
671 LEAVE_DIR (sp, p, "1");
675 /* Rebuild if only read the names and now traversing. */
676 if (sp->fts_child != NULL && ISSET(FTS_NAMEONLY)) {
678 fts_lfree(sp->fts_child);
679 sp->fts_child = NULL;
683 * Cd to the subdirectory.
685 * If have already read and now fail to chdir, whack the list
686 * to make the names come out right, and set the parent errno
687 * so the application will eventually get an error condition.
688 * Set the FTS_DONTCHDIR flag so that when we logically change
689 * directories back to the parent we don't do a chdir.
691 * If haven't read do so. If the read fails, fts_build sets
692 * FTS_STOP or the fts_info field of the node.
694 if (sp->fts_child != NULL) {
695 if (fts_safe_changedir(sp, p, -1, p->fts_accpath)) {
696 p->fts_errno = errno;
697 p->fts_flags |= FTS_DONTCHDIR;
698 for (p = sp->fts_child; p != NULL;
701 p->fts_parent->fts_accpath;
703 } else if ((sp->fts_child = fts_build(sp, BREAD)) == NULL) {
706 /* If fts_build's call to fts_safe_changedir failed
707 because it was not able to fchdir into a
708 subdirectory, tell the caller. */
709 if (p->fts_errno && p->fts_info != FTS_DNR)
710 p->fts_info = FTS_ERR;
711 LEAVE_DIR (sp, p, "2");
715 sp->fts_child = NULL;
719 /* Move to the next node on this level. */
721 if ((p = p->fts_link) != NULL) {
726 * If reached the top, return to the original directory (or
727 * the root of the tree), and load the file names for the next
730 if (p->fts_level == FTS_ROOTLEVEL) {
731 if (RESTORE_INITIAL_CWD(sp)) {
740 * User may have called fts_set on the node. If skipped,
741 * ignore. If followed, get a file descriptor so we can
742 * get back if necessary.
744 if (p->fts_instr == FTS_SKIP)
746 if (p->fts_instr == FTS_FOLLOW) {
747 p->fts_info = fts_stat(sp, p, true);
748 if (p->fts_info == FTS_D && !ISSET(FTS_NOCHDIR)) {
749 if ((p->fts_symfd = diropen (sp, ".")) < 0) {
750 p->fts_errno = errno;
751 p->fts_info = FTS_ERR;
753 p->fts_flags |= FTS_SYMFOLLOW;
755 p->fts_instr = FTS_NOINSTR;
758 name: t = sp->fts_path + NAPPEND(p->fts_parent);
760 memmove(t, p->fts_name, p->fts_namelen + 1);
763 if (p->fts_info == FTS_NSOK)
765 if (p->fts_statp->st_size == FTS_STAT_REQUIRED)
766 p->fts_info = fts_stat(sp, p, false);
768 fts_assert (p->fts_statp->st_size == FTS_NO_STAT_REQUIRED);
771 if (p->fts_info == FTS_D)
773 /* Now that P->fts_statp is guaranteed to be valid,
774 if this is a command-line directory, record its
775 device number, to be used for FTS_XDEV. */
776 if (p->fts_level == FTS_ROOTLEVEL)
777 sp->fts_dev = p->fts_statp->st_dev;
778 Dprintf ((" entering: %s\n", p->fts_path));
779 if (! enter_dir (sp, p))
781 __set_errno (ENOMEM);
788 /* Move up to the parent node. */
793 if (p->fts_level == FTS_ROOTPARENTLEVEL) {
795 * Done; free everything up and set errno to 0 so the user
796 * can distinguish between error and EOF.
800 return (sp->fts_cur = NULL);
803 fts_assert (p->fts_info != FTS_NSOK);
805 /* NUL terminate the file name. */
806 sp->fts_path[p->fts_pathlen] = '\0';
809 * Return to the parent directory. If at a root node, restore
810 * the initial working directory. If we came through a symlink,
811 * go back through the file descriptor. Otherwise, move up
812 * one level, via "..".
814 if (p->fts_level == FTS_ROOTLEVEL) {
815 if (RESTORE_INITIAL_CWD(sp)) {
816 p->fts_errno = errno;
819 } else if (p->fts_flags & FTS_SYMFOLLOW) {
820 if (FCHDIR(sp, p->fts_symfd)) {
821 int saved_errno = errno;
822 (void)close(p->fts_symfd);
823 __set_errno (saved_errno);
824 p->fts_errno = errno;
827 (void)close(p->fts_symfd);
828 } else if (!(p->fts_flags & FTS_DONTCHDIR) &&
829 fts_safe_changedir(sp, p->fts_parent, -1, "..")) {
830 p->fts_errno = errno;
833 p->fts_info = p->fts_errno ? FTS_ERR : FTS_DP;
834 if (p->fts_errno == 0)
835 LEAVE_DIR (sp, p, "3");
836 return ISSET(FTS_STOP) ? NULL : p;
840 * Fts_set takes the stream as an argument although it's not used in this
841 * implementation; it would be necessary if anyone wanted to add global
842 * semantics to fts using fts_set. An error return is allowed for similar
847 fts_set(FTS *sp ATTRIBUTE_UNUSED, FTSENT *p, int instr)
849 if (instr != 0 && instr != FTS_AGAIN && instr != FTS_FOLLOW &&
850 instr != FTS_NOINSTR && instr != FTS_SKIP) {
851 __set_errno (EINVAL);
854 p->fts_instr = instr;
859 fts_children (register FTS *sp, int instr)
864 if (instr != 0 && instr != FTS_NAMEONLY) {
865 __set_errno (EINVAL);
869 /* Set current node pointer. */
873 * Errno set to 0 so user can distinguish empty directory from
878 /* Fatal errors stop here. */
882 /* Return logical hierarchy of user's arguments. */
883 if (p->fts_info == FTS_INIT)
884 return (p->fts_link);
887 * If not a directory being visited in pre-order, stop here. Could
888 * allow FTS_DNR, assuming the user has fixed the problem, but the
889 * same effect is available with FTS_AGAIN.
891 if (p->fts_info != FTS_D /* && p->fts_info != FTS_DNR */)
894 /* Free up any previous child list. */
895 if (sp->fts_child != NULL)
896 fts_lfree(sp->fts_child);
898 if (instr == FTS_NAMEONLY) {
905 * If using chdir on a relative file name and called BEFORE fts_read
906 * does its chdir to the root of a traversal, we can lose -- we need to
907 * chdir into the subdirectory, and we don't know where the current
908 * directory is, so we can't get back so that the upcoming chdir by
909 * fts_read will work.
911 if (p->fts_level != FTS_ROOTLEVEL || p->fts_accpath[0] == '/' ||
913 return (sp->fts_child = fts_build(sp, instr));
915 if ((fd = diropen (sp, ".")) < 0)
916 return (sp->fts_child = NULL);
917 sp->fts_child = fts_build(sp, instr);
918 if (ISSET(FTS_CWDFD))
920 cwd_advance_fd (sp, fd, true);
926 int saved_errno = errno;
928 __set_errno (saved_errno);
933 return (sp->fts_child);
936 #if defined __linux__ \
937 && HAVE_SYS_VFS_H && HAVE_FSTATFS && HAVE_STRUCT_STATFS_F_TYPE
941 /* Linux-specific constants from coreutils' src/fs.h */
942 # define S_MAGIC_TMPFS 0x1021994
943 # define S_MAGIC_NFS 0x6969
945 /* Return false if it is easy to determine the file system type of
946 the directory on which DIR_FD is open, and sorting dirents on
947 inode numbers is known not to improve traversal performance with
948 that type of file system. Otherwise, return true. */
950 dirent_inode_sort_may_be_useful (int dir_fd)
952 /* Skip the sort only if we can determine efficiently
953 that skipping it is the right thing to do.
954 The cost of performing an unnecessary sort is negligible,
955 while the cost of *not* performing it can be O(N^2) with
956 a very large constant. */
957 struct statfs fs_buf;
959 /* If fstatfs fails, assume sorting would be useful. */
960 if (fstatfs (dir_fd, &fs_buf) != 0)
963 /* FIXME: what about when f_type is not an integral type?
964 deal with that if/when it's encountered. */
965 switch (fs_buf.f_type)
969 /* On a file system of any of these types, sorting
970 is unnecessary, and hence wasteful. */
978 static bool dirent_inode_sort_may_be_useful (int dir_fd) { return true; }
981 /* A comparison function to sort on increasing inode number.
982 For some file system types, sorting either way makes a huge
983 performance difference for a directory with very many entries,
984 but sorting on increasing values is slightly better than sorting
985 on decreasing values. The difference is in the 5% range. */
987 fts_compare_ino (struct _ftsent const **a, struct _ftsent const **b)
989 return (a[0]->fts_statp->st_ino < b[0]->fts_statp->st_ino ? -1
990 : b[0]->fts_statp->st_ino < a[0]->fts_statp->st_ino ? 1 : 0);
994 * This is the tricky part -- do not casually change *anything* in here. The
995 * idea is to build the linked list of entries that are used by fts_children
996 * and fts_read. There are lots of special cases.
998 * The real slowdown in walking the tree is the stat calls. If FTS_NOSTAT is
999 * set and it's a physical walk (so that symbolic links can't be directories),
1000 * we can do things quickly. First, if it's a 4.4BSD file system, the type
1001 * of the file is in the directory entry. Otherwise, we assume that the number
1002 * of subdirectories in a node is equal to the number of links to the parent.
1003 * The former skips all stat calls. The latter skips stat calls in any leaf
1004 * directories and for any files after the subdirectories in the directory have
1005 * been found, cutting the stat calls by about 2/3.
1009 fts_build (register FTS *sp, int type)
1011 register struct dirent *dp;
1012 register FTSENT *p, *head;
1013 register size_t nitems;
1023 size_t len, maxlen, new_len;
1026 /* Set current node pointer. */
1030 * Open the directory for reading. If this fails, we're done.
1031 * If being called from fts_read, set the fts_info field.
1033 #if defined FTS_WHITEOUT && 0
1034 if (ISSET(FTS_WHITEOUT))
1035 oflag = DTF_NODUP|DTF_REWIND;
1037 oflag = DTF_HIDEW|DTF_NODUP|DTF_REWIND;
1039 # define __opendir2(file, flag) \
1040 ( ! ISSET(FTS_NOCHDIR) && ISSET(FTS_CWDFD) \
1041 ? opendirat(sp->fts_cwd_fd, file) \
1044 if ((dirp = __opendir2(cur->fts_accpath, oflag)) == NULL) {
1045 if (type == BREAD) {
1046 cur->fts_info = FTS_DNR;
1047 cur->fts_errno = errno;
1051 /* Rather than calling fts_stat for each and every entry encountered
1052 in the readdir loop (below), stat each directory only right after
1054 if (cur->fts_info == FTS_NSOK)
1055 cur->fts_info = fts_stat(sp, cur, false);
1058 * Nlinks is the number of possible entries of type directory in the
1059 * directory if we're cheating on stat calls, 0 if we're not doing
1060 * any stat calls at all, (nlink_t) -1 if we're statting everything.
1062 if (type == BNAMES) {
1064 /* Be quiet about nostat, GCC. */
1066 } else if (ISSET(FTS_NOSTAT) && ISSET(FTS_PHYSICAL)) {
1067 nlinks = (cur->fts_statp->st_nlink
1068 - (ISSET(FTS_SEEDOT) ? 0 : 2));
1076 * If we're going to need to stat anything or we want to descend
1077 * and stay in the directory, chdir. If this fails we keep going,
1078 * but set a flag so we don't chdir after the post-order visit.
1079 * We won't be able to stat anything, but we can still return the
1080 * names themselves. Note, that since fts_read won't be able to
1081 * chdir into the directory, it will have to return different file
1082 * names than before, i.e. "a/b" instead of "b". Since the node
1083 * has already been visited in pre-order, have to wait until the
1084 * post-order visit to return the error. There is a special case
1085 * here, if there was nothing to stat then it's not an error to
1086 * not be able to stat. This is all fairly nasty. If a program
1087 * needed sorted entries or stat information, they had better be
1088 * checking FTS_NS on the returned nodes.
1090 if (nlinks || type == BREAD) {
1091 int dir_fd = dirfd(dirp);
1092 if (ISSET(FTS_CWDFD) && 0 <= dir_fd)
1093 dir_fd = dup (dir_fd);
1094 if (dir_fd < 0 || fts_safe_changedir(sp, cur, dir_fd, NULL)) {
1095 if (nlinks && type == BREAD)
1096 cur->fts_errno = errno;
1097 cur->fts_flags |= FTS_DONTCHDIR;
1100 if (ISSET(FTS_CWDFD) && 0 <= dir_fd)
1109 * Figure out the max file name length that can be stored in the
1110 * current buffer -- the inner loop allocates more space as necessary.
1111 * We really wouldn't have to do the maxlen calculations here, we
1112 * could do them in fts_read before returning the name, but it's a
1113 * lot easier here since the length is part of the dirent structure.
1115 * If not changing directories set a pointer so that can just append
1116 * each new component into the file name.
1119 if (ISSET(FTS_NOCHDIR)) {
1120 cp = sp->fts_path + len;
1123 /* GCC, you're too verbose. */
1127 maxlen = sp->fts_pathlen - len;
1129 level = cur->fts_level + 1;
1131 /* Read the directory, attaching each entry to the `link' pointer. */
1133 for (head = tail = NULL, nitems = 0; dirp && (dp = readdir(dirp));) {
1136 if (!ISSET(FTS_SEEDOT) && ISDOT(dp->d_name))
1139 if ((p = fts_alloc (sp, dp->d_name,
1140 _D_EXACT_NAMLEN (dp))) == NULL)
1142 if (_D_EXACT_NAMLEN (dp) >= maxlen) {
1143 /* include space for NUL */
1144 oldaddr = sp->fts_path;
1145 if (! fts_palloc(sp, _D_EXACT_NAMLEN (dp) + len + 1)) {
1147 * No more memory. Save
1148 * errno, free up the current structure and the
1149 * structures already allocated.
1151 mem1: saved_errno = errno;
1155 cur->fts_info = FTS_ERR;
1157 __set_errno (saved_errno);
1160 /* Did realloc() change the pointer? */
1161 if (oldaddr != sp->fts_path) {
1163 if (ISSET(FTS_NOCHDIR))
1164 cp = sp->fts_path + len;
1166 maxlen = sp->fts_pathlen - len;
1169 new_len = len + _D_EXACT_NAMLEN (dp);
1170 if (new_len < len) {
1172 * In the unlikely event that we would end up
1173 * with a file name longer than SIZE_MAX, free up
1174 * the current structure and the structures already
1175 * allocated, then error out with ENAMETOOLONG.
1180 cur->fts_info = FTS_ERR;
1182 __set_errno (ENAMETOOLONG);
1185 p->fts_level = level;
1186 p->fts_parent = sp->fts_cur;
1187 p->fts_pathlen = new_len;
1189 #if defined FTS_WHITEOUT && 0
1190 if (dp->d_type == DT_WHT)
1191 p->fts_flags |= FTS_ISW;
1193 /* Store dirent.d_ino, in case we need to sort
1194 entries before processing them. */
1195 p->fts_statp->st_ino = D_INO (dp);
1197 /* Build a file name for fts_stat to stat. */
1198 if (ISSET(FTS_NOCHDIR)) {
1199 p->fts_accpath = p->fts_path;
1200 memmove(cp, p->fts_name, p->fts_namelen + 1);
1202 p->fts_accpath = p->fts_name;
1204 if (sp->fts_compar == NULL || ISSET(FTS_DEFER_STAT)) {
1205 /* Record what fts_read will have to do with this
1206 entry. In many cases, it will simply fts_stat it,
1207 but we can take advantage of any d_type information
1208 to optimize away the unnecessary stat calls. I.e.,
1209 if FTS_NOSTAT is in effect and we're not following
1210 symlinks (FTS_PHYSICAL) and d_type indicates this
1211 is *not* a directory, then we won't have to stat it
1212 at all. If it *is* a directory, then (currently)
1213 we stat it regardless, in order to get device and
1214 inode numbers. Some day we might optimize that
1215 away, too, for directories where d_ino is known to
1217 bool skip_stat = (ISSET(FTS_PHYSICAL)
1218 && ISSET(FTS_NOSTAT)
1220 && ! DT_MUST_BE(dp, DT_DIR));
1221 p->fts_info = FTS_NSOK;
1222 fts_set_stat_required(p, !skip_stat);
1223 is_dir = (ISSET(FTS_PHYSICAL) && ISSET(FTS_NOSTAT)
1224 && DT_MUST_BE(dp, DT_DIR));
1226 p->fts_info = fts_stat(sp, p, false);
1227 is_dir = (p->fts_info == FTS_D
1228 || p->fts_info == FTS_DC
1229 || p->fts_info == FTS_DOT);
1232 /* Decrement link count if applicable. */
1233 if (nlinks > 0 && is_dir)
1236 /* We walk in directory order so "ls -f" doesn't get upset. */
1250 * If realloc() changed the address of the file name, adjust the
1251 * addresses for the rest of the tree and the dir list.
1254 fts_padjust(sp, head);
1257 * If not changing directories, reset the file name back to original
1260 if (ISSET(FTS_NOCHDIR)) {
1261 if (len == sp->fts_pathlen || nitems == 0)
1267 * If descended after called from fts_children or after called from
1268 * fts_read and nothing found, get back. At the root level we use
1269 * the saved fd; if one of fts_open()'s arguments is a relative name
1270 * to an empty directory, we wind up here with no other way back. If
1271 * can't get back, we're done.
1273 if (descend && (type == BCHILD || !nitems) &&
1274 (cur->fts_level == FTS_ROOTLEVEL
1275 ? RESTORE_INITIAL_CWD(sp)
1276 : fts_safe_changedir(sp, cur->fts_parent, -1, ".."))) {
1277 cur->fts_info = FTS_ERR;
1283 /* If didn't find anything, return NULL. */
1286 cur->fts_info = FTS_DP;
1291 /* If there are many entries, no sorting function has been specified,
1292 and this file system is of a type that may be slow with a large
1293 number of entries, then sort the directory entries on increasing
1295 if (nitems > _FTS_INODE_SORT_DIR_ENTRIES_THRESHOLD
1297 && ISSET (FTS_CWDFD)
1298 && dirent_inode_sort_may_be_useful (sp->fts_cwd_fd)) {
1299 sp->fts_compar = fts_compare_ino;
1300 head = fts_sort (sp, head, nitems);
1301 sp->fts_compar = NULL;
1304 /* Sort the entries. */
1305 if (sp->fts_compar && nitems > 1)
1306 head = fts_sort(sp, head, nitems);
1312 /* Walk ->fts_parent links starting at E_CURR, until the root of the
1313 current hierarchy. There should be a directory with dev/inode
1314 matching those of AD. If not, print a lot of diagnostics. */
1316 find_matching_ancestor (FTSENT const *e_curr, struct Active_dir const *ad)
1319 for (ent = e_curr; ent->fts_level >= FTS_ROOTLEVEL; ent = ent->fts_parent)
1321 if (ad->ino == ent->fts_statp->st_ino
1322 && ad->dev == ent->fts_statp->st_dev)
1325 printf ("ERROR: tree dir, %s, not active\n", ad->fts_ent->fts_accpath);
1326 printf ("active dirs:\n");
1328 ent->fts_level >= FTS_ROOTLEVEL; ent = ent->fts_parent)
1329 printf (" %s(%"PRIuMAX"/%"PRIuMAX") to %s(%"PRIuMAX"/%"PRIuMAX")...\n",
1330 ad->fts_ent->fts_accpath,
1331 (uintmax_t) ad->dev,
1332 (uintmax_t) ad->ino,
1334 (uintmax_t) ent->fts_statp->st_dev,
1335 (uintmax_t) ent->fts_statp->st_ino);
1339 fts_cross_check (FTS const *sp)
1341 FTSENT const *ent = sp->fts_cur;
1343 if ( ! ISSET (FTS_TIGHT_CYCLE_CHECK))
1346 Dprintf (("fts-cross-check cur=%s\n", ent->fts_path));
1347 /* Make sure every parent dir is in the tree. */
1348 for (t = ent->fts_parent; t->fts_level >= FTS_ROOTLEVEL; t = t->fts_parent)
1350 struct Active_dir ad;
1351 ad.ino = t->fts_statp->st_ino;
1352 ad.dev = t->fts_statp->st_dev;
1353 if ( ! hash_lookup (sp->fts_cycle.ht, &ad))
1354 printf ("ERROR: active dir, %s, not in tree\n", t->fts_path);
1357 /* Make sure every dir in the tree is an active dir.
1358 But ENT is not necessarily a directory. If so, just skip this part. */
1359 if (ent->fts_parent->fts_level >= FTS_ROOTLEVEL
1360 && (ent->fts_info == FTS_DP
1361 || ent->fts_info == FTS_D))
1363 struct Active_dir *ad;
1364 for (ad = hash_get_first (sp->fts_cycle.ht); ad != NULL;
1365 ad = hash_get_next (sp->fts_cycle.ht, ad))
1367 find_matching_ancestor (ent, ad);
1373 same_fd (int fd1, int fd2)
1375 struct stat sb1, sb2;
1376 return (fstat (fd1, &sb1) == 0
1377 && fstat (fd2, &sb2) == 0
1378 && SAME_INODE (sb1, sb2));
1382 fd_ring_print (FTS const *sp, FILE *stream, char const *msg)
1384 I_ring const *fd_ring = &sp->fts_fd_ring;
1385 unsigned int i = fd_ring->fts_front;
1386 char *cwd = getcwdat (sp->fts_cwd_fd, NULL, 0);
1387 fprintf (stream, "=== %s ========== %s\n", msg, cwd);
1389 if (i_ring_empty (fd_ring))
1394 int fd = fd_ring->fts_fd_ring[i];
1396 fprintf (stream, "%d: %d:\n", i, fd);
1399 char *wd = getcwdat (fd, NULL, 0);
1400 fprintf (stream, "%d: %d: %s\n", i, fd, wd);
1403 if (i == fd_ring->fts_back)
1405 i = (i + I_RING_SIZE - 1) % I_RING_SIZE;
1409 /* Ensure that each file descriptor on the fd_ring matches a
1410 parent, grandparent, etc. of the current working directory. */
1412 fd_ring_check (FTS const *sp)
1417 /* Make a writable copy. */
1418 I_ring fd_w = sp->fts_fd_ring;
1420 int cwd_fd = sp->fts_cwd_fd;
1421 cwd_fd = dup (cwd_fd);
1422 char *dot = getcwdat (cwd_fd, NULL, 0);
1423 error (0, 0, "===== check ===== cwd: %s", dot);
1425 while ( ! i_ring_empty (&fd_w))
1427 int fd = i_ring_pop (&fd_w);
1430 int parent_fd = openat (cwd_fd, "..", O_RDONLY);
1436 if (!same_fd (fd, parent_fd))
1438 char *cwd = getcwdat (fd, NULL, 0);
1439 error (0, errno, "ring : %s", cwd);
1440 char *c2 = getcwdat (parent_fd, NULL, 0);
1441 error (0, errno, "parent: %s", c2);
1454 static unsigned short int
1456 fts_stat(FTS *sp, register FTSENT *p, bool follow)
1458 struct stat *sbp = p->fts_statp;
1461 if (p->fts_level == FTS_ROOTLEVEL && ISSET(FTS_COMFOLLOW))
1464 #if defined FTS_WHITEOUT && 0
1465 /* check for whiteout */
1466 if (p->fts_flags & FTS_ISW) {
1467 memset(sbp, '\0', sizeof (*sbp));
1468 sbp->st_mode = S_IFWHT;
1474 * If doing a logical walk, or application requested FTS_FOLLOW, do
1475 * a stat(2). If that fails, check for a non-existent symlink. If
1476 * fail, set the errno from the stat call.
1478 if (ISSET(FTS_LOGICAL) || follow) {
1479 if (stat(p->fts_accpath, sbp)) {
1480 saved_errno = errno;
1482 && lstat(p->fts_accpath, sbp) == 0) {
1484 return (FTS_SLNONE);
1486 p->fts_errno = saved_errno;
1489 } else if (fstatat(sp->fts_cwd_fd, p->fts_accpath, sbp,
1490 AT_SYMLINK_NOFOLLOW)) {
1491 p->fts_errno = errno;
1492 err: memset(sbp, 0, sizeof(struct stat));
1496 if (S_ISDIR(sbp->st_mode)) {
1497 if (ISDOT(p->fts_name)) {
1498 /* Command-line "." and ".." are real directories. */
1499 return (p->fts_level == FTS_ROOTLEVEL ? FTS_D : FTS_DOT);
1505 * Cycle detection is done by brute force when the directory
1506 * is first encountered. If the tree gets deep enough or the
1507 * number of symbolic links to directories is high enough,
1508 * something faster might be worthwhile.
1512 for (t = p->fts_parent;
1513 t->fts_level >= FTS_ROOTLEVEL; t = t->fts_parent)
1514 if (sbp->st_ino == t->fts_statp->st_ino
1515 && sbp->st_dev == t->fts_statp->st_dev)
1525 if (S_ISLNK(sbp->st_mode))
1527 if (S_ISREG(sbp->st_mode))
1529 return (FTS_DEFAULT);
1533 fts_compar (void const *a, void const *b)
1535 /* Convert A and B to the correct types, to pacify the compiler, and
1536 for portability to bizarre hosts where "void const *" and "FTSENT
1537 const **" differ in runtime representation. The comparison
1538 function cannot modify *a and *b, but there is no compile-time
1540 FTSENT const **pa = (FTSENT const **) a;
1541 FTSENT const **pb = (FTSENT const **) b;
1542 return pa[0]->fts_fts->fts_compar (pa, pb);
1547 fts_sort (FTS *sp, FTSENT *head, register size_t nitems)
1549 register FTSENT **ap, *p;
1551 /* On most modern hosts, void * and FTSENT ** have the same
1552 run-time representation, and one can convert sp->fts_compar to
1553 the type qsort expects without problem. Use the heuristic that
1554 this is OK if the two pointer types are the same size, and if
1555 converting FTSENT ** to long int is the same as converting
1556 FTSENT ** to void * and then to long int. This heuristic isn't
1557 valid in general but we don't know of any counterexamples. */
1559 int (*compare) (void const *, void const *) =
1560 ((sizeof &dummy == sizeof (void *)
1561 && (long int) &dummy == (long int) (void *) &dummy)
1562 ? (int (*) (void const *, void const *)) sp->fts_compar
1566 * Construct an array of pointers to the structures and call qsort(3).
1567 * Reassemble the array in the order returned by qsort. If unable to
1568 * sort for memory reasons, return the directory entries in their
1569 * current order. Allocate enough space for the current needs plus
1570 * 40 so don't realloc one entry at a time.
1572 if (nitems > sp->fts_nitems) {
1575 sp->fts_nitems = nitems + 40;
1576 if (SIZE_MAX / sizeof *a < sp->fts_nitems
1577 || ! (a = realloc (sp->fts_array,
1578 sp->fts_nitems * sizeof *a))) {
1579 free(sp->fts_array);
1580 sp->fts_array = NULL;
1586 for (ap = sp->fts_array, p = head; p; p = p->fts_link)
1588 qsort((void *)sp->fts_array, nitems, sizeof(FTSENT *), compare);
1589 for (head = *(ap = sp->fts_array); --nitems; ++ap)
1590 ap[0]->fts_link = ap[1];
1591 ap[0]->fts_link = NULL;
1597 fts_alloc (FTS *sp, const char *name, register size_t namelen)
1603 * The file name is a variable length array. Allocate the FTSENT
1604 * structure and the file name in one chunk.
1606 len = sizeof(FTSENT) + namelen;
1607 if ((p = malloc(len)) == NULL)
1610 /* Copy the name and guarantee NUL termination. */
1611 memmove(p->fts_name, name, namelen);
1612 p->fts_name[namelen] = '\0';
1614 p->fts_namelen = namelen;
1616 p->fts_path = sp->fts_path;
1619 p->fts_instr = FTS_NOINSTR;
1621 p->fts_pointer = NULL;
1627 fts_lfree (register FTSENT *head)
1631 /* Free a linked list of structures. */
1632 while ((p = head)) {
1633 head = head->fts_link;
1639 * Allow essentially unlimited file name lengths; find, rm, ls should
1640 * all work on any tree. Most systems will allow creation of file
1641 * names much longer than MAXPATHLEN, even though the kernel won't
1642 * resolve them. Add the size (not just what's needed) plus 256 bytes
1643 * so don't realloc the file name 2 bytes at a time.
1647 fts_palloc (FTS *sp, size_t more)
1650 size_t new_len = sp->fts_pathlen + more + 256;
1653 * See if fts_pathlen would overflow.
1655 if (new_len < sp->fts_pathlen) {
1657 sp->fts_path = NULL;
1658 __set_errno (ENAMETOOLONG);
1661 sp->fts_pathlen = new_len;
1662 p = realloc(sp->fts_path, sp->fts_pathlen);
1665 sp->fts_path = NULL;
1673 * When the file name is realloc'd, have to fix all of the pointers in
1674 * structures already returned.
1678 fts_padjust (FTS *sp, FTSENT *head)
1681 char *addr = sp->fts_path;
1683 #define ADJUST(p) do { \
1684 if ((p)->fts_accpath != (p)->fts_name) { \
1685 (p)->fts_accpath = \
1686 (char *)addr + ((p)->fts_accpath - (p)->fts_path); \
1688 (p)->fts_path = addr; \
1690 /* Adjust the current set of children. */
1691 for (p = sp->fts_child; p; p = p->fts_link)
1694 /* Adjust the rest of the tree, including the current level. */
1695 for (p = head; p->fts_level >= FTS_ROOTLEVEL;) {
1697 p = p->fts_link ? p->fts_link : p->fts_parent;
1703 fts_maxarglen (char * const *argv)
1707 for (max = 0; *argv; ++argv)
1708 if ((len = strlen(*argv)) > max)
1714 * Change to dir specified by fd or file name without getting
1715 * tricked by someone changing the world out from underneath us.
1716 * Assumes p->fts_statp->st_dev and p->fts_statp->st_ino are filled in.
1717 * If FD is non-negative, expect it to be used after this function returns,
1718 * and to be closed eventually. So don't pass e.g., `dirfd(dirp)' and then
1719 * do closedir(dirp), because that would invalidate the saved FD.
1720 * Upon failure, close FD immediately and return nonzero.
1724 fts_safe_changedir (FTS *sp, FTSENT *p, int fd, char const *dir)
1727 bool is_dotdot = dir && STREQ (dir, "..");
1730 /* This clause handles the unusual case in which FTS_NOCHDIR
1731 is specified, along with FTS_CWDFD. In that case, there is
1732 no need to change even the virtual cwd file descriptor.
1733 However, if FD is non-negative, we do close it here. */
1734 if (ISSET (FTS_NOCHDIR))
1736 if (ISSET (FTS_CWDFD) && 0 <= fd)
1741 if (fd < 0 && is_dotdot && ISSET (FTS_CWDFD))
1743 /* When possible, skip the diropen and subsequent fstat+dev/ino
1744 comparison. I.e., when changing to parent directory
1745 (chdir ("..")), use a file descriptor from the ring and
1746 save the overhead of diropen+fstat, as well as avoiding
1747 failure when we lack "x" access to the virtual cwd. */
1748 if ( ! i_ring_empty (&sp->fts_fd_ring))
1751 fd_ring_print (sp, stderr, "pre-pop");
1752 parent_fd = i_ring_pop (&sp->fts_fd_ring);
1763 if (fd < 0 && (newfd = diropen (sp, dir)) < 0)
1766 /* The following dev/inode check is necessary if we're doing a
1767 `logical' traversal (through symlinks, a la chown -L), if the
1768 system lacks O_NOFOLLOW support, or if we're changing to ".."
1769 (but not via a popped file descriptor). When changing to the
1770 name "..", O_NOFOLLOW can't help. In general, when the target is
1771 not "..", diropen's use of O_NOFOLLOW ensures we don't mistakenly
1772 follow a symlink, so we can avoid the expense of this fstat. */
1773 if (ISSET(FTS_LOGICAL) || ! HAVE_WORKING_O_NOFOLLOW
1774 || (dir && STREQ (dir, "..")))
1777 if (fstat(newfd, &sb))
1782 if (p->fts_statp->st_dev != sb.st_dev
1783 || p->fts_statp->st_ino != sb.st_ino)
1785 __set_errno (ENOENT); /* disinformation */
1791 if (ISSET(FTS_CWDFD))
1793 cwd_advance_fd (sp, newfd, ! is_dotdot);
1797 ret = fchdir(newfd);
1803 __set_errno (oerrno);