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>
75 # include "unistd--.h"
76 # include "same-inode.h"
80 #ifndef _D_EXACT_NAMLEN
81 # define _D_EXACT_NAMLEN(dirent) strlen ((dirent)->d_name)
84 #if HAVE_STRUCT_DIRENT_D_TYPE
85 /* True if the type of the directory entry D is known. */
86 # define DT_IS_KNOWN(d) ((d)->d_type != DT_UNKNOWN)
87 /* True if the type of the directory entry D must be T. */
88 # define DT_MUST_BE(d, t) ((d)->d_type == (t))
90 # define DT_IS_KNOWN(d) false
91 # define DT_MUST_BE(d, t) false
96 NOT_AN_INODE_NUMBER = 0
99 #ifdef D_INO_IN_DIRENT
100 # define D_INO(dp) (dp)->d_ino
102 /* Some systems don't have inodes, so fake them to avoid lots of ifdefs. */
103 # define D_INO(dp) NOT_AN_INODE_NUMBER
106 /* If there are more than this many entries in a directory,
107 and the conditions mentioned below are satisfied, then sort
108 the entries on inode number before any further processing. */
109 #ifndef FTS_INODE_SORT_DIR_ENTRIES_THRESHOLD
110 # define FTS_INODE_SORT_DIR_ENTRIES_THRESHOLD 10000
114 _FTS_INODE_SORT_DIR_ENTRIES_THRESHOLD = FTS_INODE_SORT_DIR_ENTRIES_THRESHOLD
119 FTS_NO_STAT_REQUIRED = 1,
120 FTS_STAT_REQUIRED = 2
125 # define close __close
127 # define closedir __closedir
129 # define fchdir __fchdir
133 # define opendir __opendir
135 # define readdir __readdir
137 # undef internal_function
138 # define internal_function /* empty */
142 # define __set_errno(Val) errno = (Val)
145 #ifndef __attribute__
146 # if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 8)
147 # define __attribute__(x) /* empty */
151 #ifndef ATTRIBUTE_UNUSED
152 # define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
155 /* If this host provides the openat function, then we can avoid
156 attempting to open "." in some initialization code below. */
158 # define HAVE_OPENAT_SUPPORT 1
160 # define HAVE_OPENAT_SUPPORT 0
164 # define fts_assert(expr) ((void) 0)
166 # define fts_assert(expr) \
175 static FTSENT *fts_alloc (FTS *, const char *, size_t) internal_function;
176 static FTSENT *fts_build (FTS *, int) internal_function;
177 static void fts_lfree (FTSENT *) internal_function;
178 static void fts_load (FTS *, FTSENT *) internal_function;
179 static size_t fts_maxarglen (char * const *) internal_function;
180 static void fts_padjust (FTS *, FTSENT *) internal_function;
181 static bool fts_palloc (FTS *, size_t) internal_function;
182 static FTSENT *fts_sort (FTS *, FTSENT *, size_t) internal_function;
183 static unsigned short int fts_stat (FTS *, FTSENT *, bool) internal_function;
184 static int fts_safe_changedir (FTS *, FTSENT *, int, const char *)
188 # include "fts-cycle.c"
190 static bool enter_dir (FTS *fts, FTSENT *ent) { return true; }
191 static void leave_dir (FTS *fts, FTSENT *ent) {}
192 static bool setup_dir (FTS *fts) { return true; }
193 static void free_dir (FTS *fts) {}
197 # define MAX(a,b) ((a) > (b) ? (a) : (b))
201 # define SIZE_MAX ((size_t) -1)
205 # define O_DIRECTORY 0
208 #define ISDOT(a) (a[0] == '.' && (!a[1] || (a[1] == '.' && !a[2])))
209 #define STREQ(a, b) (strcmp ((a), (b)) == 0)
211 #define CLR(opt) (sp->fts_options &= ~(opt))
212 #define ISSET(opt) (sp->fts_options & (opt))
213 #define SET(opt) (sp->fts_options |= (opt))
215 /* FIXME: make this a function */
216 #define RESTORE_INITIAL_CWD(sp) \
217 (fd_ring_clear (&((sp)->fts_fd_ring)), \
218 FCHDIR ((sp), (ISSET (FTS_CWDFD) ? AT_FDCWD : (sp)->fts_rfd)))
220 /* FIXME: FTS_NOCHDIR is now misnamed.
221 Call it FTS_USE_FULL_RELATIVE_FILE_NAMES instead. */
222 #define FCHDIR(sp, fd) \
223 (!ISSET(FTS_NOCHDIR) && (ISSET(FTS_CWDFD) \
224 ? (cwd_advance_fd ((sp), (fd), true), 0) \
228 /* fts_build flags */
229 /* FIXME: make this an enum */
230 #define BCHILD 1 /* fts_children */
231 #define BNAMES 2 /* fts_children, names only */
232 #define BREAD 3 /* fts_read */
235 # include <inttypes.h>
238 # include "getcwdat.h"
239 bool fts_debug = false;
240 # define Dprintf(x) do { if (fts_debug) printf x; } while (false)
243 # define fd_ring_check(x)
244 # define fd_ring_print(a, b, c)
247 #define LEAVE_DIR(Fts, Ent, Tag) \
250 Dprintf ((" %s-leaving: %s\n", Tag, (Ent)->fts_path)); \
251 leave_dir (Fts, Ent); \
252 fd_ring_check (Fts); \
257 fd_ring_clear (I_ring *fd_ring)
259 while ( ! i_ring_empty (fd_ring))
261 int fd = i_ring_pop (fd_ring);
267 /* Overload the fts_statp->st_size member (otherwise unused, when
268 fts_info is FTS_NSOK) to indicate whether fts_read should stat
269 this entry or not. */
271 fts_set_stat_required (FTSENT *p, bool required)
273 fts_assert (p->fts_info == FTS_NSOK);
274 p->fts_statp->st_size = (required
276 : FTS_NO_STAT_REQUIRED);
279 /* file-descriptor-relative opendir. */
280 /* FIXME: if others need this function, move it into lib/openat.c */
283 opendirat (int fd, char const *dir)
285 int new_fd = openat (fd, dir, O_RDONLY);
290 dirp = fdopendir (new_fd);
293 int saved_errno = errno;
300 /* Virtual fchdir. Advance SP's working directory file descriptor,
301 SP->fts_cwd_fd, to FD, and push the previous value onto the fd_ring.
302 CHDIR_DOWN_ONE is true if FD corresponds to an entry in the directory
303 open on sp->fts_cwd_fd; i.e., to move the working directory one level
307 cwd_advance_fd (FTS *sp, int fd, bool chdir_down_one)
309 int old = sp->fts_cwd_fd;
310 fts_assert (old != fd || old == AT_FDCWD);
314 /* Push "old" onto the ring.
315 If the displaced file descriptor is non-negative, close it. */
316 int prev_fd_in_slot = i_ring_push (&sp->fts_fd_ring, old);
317 fd_ring_print (sp, stderr, "post-push");
318 if (0 <= prev_fd_in_slot)
319 close (prev_fd_in_slot); /* ignore any close failure */
321 else if ( ! ISSET (FTS_NOCHDIR))
324 close (old); /* ignore any close failure */
330 /* Open the directory DIR if possible, and return a file
331 descriptor. Return -1 and set errno on failure. It doesn't matter
332 whether the file descriptor has read or write access. */
336 diropen (FTS const *sp, char const *dir)
338 int open_flags = (O_RDONLY | O_DIRECTORY | O_NOCTTY | O_NONBLOCK
339 | (ISSET (FTS_PHYSICAL) ? O_NOFOLLOW : 0));
341 return (ISSET (FTS_CWDFD)
342 ? openat (sp->fts_cwd_fd, dir, open_flags)
343 : open (dir, open_flags));
347 fts_open (char * const *argv,
348 register int options,
349 int (*compar) (FTSENT const **, FTSENT const **))
352 register FTSENT *p, *root;
353 register size_t nitems;
354 FTSENT *parent = NULL;
355 FTSENT *tmp = NULL; /* pacify gcc */
360 if (options & ~FTS_OPTIONMASK) {
361 __set_errno (EINVAL);
364 if ((options & FTS_NOCHDIR) && (options & FTS_CWDFD)) {
365 __set_errno (EINVAL);
368 if ( ! (options & (FTS_LOGICAL | FTS_PHYSICAL))) {
369 __set_errno (EINVAL);
373 /* Allocate/initialize the stream */
374 if ((sp = malloc(sizeof(FTS))) == NULL)
376 memset(sp, 0, sizeof(FTS));
377 sp->fts_compar = compar;
378 sp->fts_options = options;
380 /* Logical walks turn on NOCHDIR; symbolic links are too hard. */
381 if (ISSET(FTS_LOGICAL)) {
386 /* Initialize fts_cwd_fd. */
387 sp->fts_cwd_fd = AT_FDCWD;
388 if ( ISSET(FTS_CWDFD) && ! HAVE_OPENAT_SUPPORT)
390 /* While it isn't technically necessary to open "." this
391 early, doing it here saves us the trouble of ensuring
392 later (where it'd be messier) that "." can in fact
393 be opened. If not, revert to FTS_NOCHDIR mode. */
394 int fd = open (".", O_RDONLY);
397 /* Even if `.' is unreadable, don't revert to FTS_NOCHDIR mode
398 on systems like Linux+PROC_FS, where our openat emulation
399 is good enough. Note: on a system that emulates
400 openat via /proc, this technique can still fail, but
401 only in extreme conditions, e.g., when the working
402 directory cannot be saved (i.e. save_cwd fails) --
403 and that happens on Linux only when "." is unreadable
404 and the CWD would be longer than PATH_MAX.
405 FIXME: once Linux kernel openat support is well established,
406 replace the above open call and this entire if/else block
407 with the body of the if-block below. */
408 if ( openat_needs_fchdir ())
421 * Start out with 1K of file name space, and enough, in any case,
422 * to hold the user's file names.
425 # define MAXPATHLEN 1024
428 size_t maxarglen = fts_maxarglen(argv);
429 if (! fts_palloc(sp, MAX(maxarglen, MAXPATHLEN)))
433 /* Allocate/initialize root's parent. */
435 if ((parent = fts_alloc(sp, "", 0)) == NULL)
437 parent->fts_level = FTS_ROOTPARENTLEVEL;
440 /* The classic fts implementation would call fts_stat with
441 a new entry for each iteration of the loop below.
442 If the comparison function is not specified or if the
443 FTS_DEFER_STAT option is in effect, don't stat any entry
444 in this loop. This is an attempt to minimize the interval
445 between the initial stat/lstat/fstatat and the point at which
446 a directory argument is first opened. This matters for any
447 directory command line argument that resides on a file system
448 without genuine i-nodes. If you specify FTS_DEFER_STAT along
449 with a comparison function, that function must not access any
450 data via the fts_statp pointer. */
451 defer_stat = (compar == NULL || ISSET(FTS_DEFER_STAT));
453 /* Allocate/initialize root(s). */
454 for (root = NULL, nitems = 0; *argv != NULL; ++argv, ++nitems) {
455 /* Don't allow zero-length file names. */
456 if ((len = strlen(*argv)) == 0) {
457 __set_errno (ENOENT);
461 if ((p = fts_alloc(sp, *argv, len)) == NULL)
463 p->fts_level = FTS_ROOTLEVEL;
464 p->fts_parent = parent;
465 p->fts_accpath = p->fts_name;
466 /* Even when defer_stat is true, be sure to stat the first
467 command line argument, since fts_read (at least with
468 FTS_XDEV) requires that. */
469 if (defer_stat && root != NULL) {
470 p->fts_info = FTS_NSOK;
471 fts_set_stat_required(p, true);
473 p->fts_info = fts_stat(sp, p, false);
477 * If comparison routine supplied, traverse in sorted
478 * order; otherwise traverse in the order specified.
493 if (compar && nitems > 1)
494 root = fts_sort(sp, root, nitems);
497 * Allocate a dummy pointer and make fts_read think that we've just
498 * finished the node before the root(s); set p->fts_info to FTS_INIT
499 * so that everything about the "current" node is ignored.
501 if ((sp->fts_cur = fts_alloc(sp, "", 0)) == NULL)
503 sp->fts_cur->fts_link = root;
504 sp->fts_cur->fts_info = FTS_INIT;
505 if (! setup_dir (sp))
509 * If using chdir(2), grab a file descriptor pointing to dot to ensure
510 * that we can get back here; this could be avoided for some file names,
511 * but almost certainly not worth the effort. Slashes, symbolic links,
512 * and ".." are all fairly nasty problems. Note, if we can't get the
513 * descriptor we run anyway, just more slowly.
515 if (!ISSET(FTS_NOCHDIR) && !ISSET(FTS_CWDFD)
516 && (sp->fts_rfd = diropen (sp, ".")) < 0)
519 i_ring_init (&sp->fts_fd_ring, -1);
522 mem3: fts_lfree(root);
524 mem2: free(sp->fts_path);
531 fts_load (FTS *sp, register FTSENT *p)
537 * Load the stream structure for the next traversal. Since we don't
538 * actually enter the directory until after the preorder visit, set
539 * the fts_accpath field specially so the chdir gets done to the right
540 * place and the user can access the first node. From fts_open it's
541 * known that the file name will fit.
543 len = p->fts_pathlen = p->fts_namelen;
544 memmove(sp->fts_path, p->fts_name, len + 1);
545 if ((cp = strrchr(p->fts_name, '/')) && (cp != p->fts_name || cp[1])) {
547 memmove(p->fts_name, cp, len + 1);
548 p->fts_namelen = len;
550 p->fts_accpath = p->fts_path = sp->fts_path;
556 register FTSENT *freep, *p;
560 * This still works if we haven't read anything -- the dummy structure
561 * points to the root list, so we step through to the end of the root
562 * list which has a valid parent pointer.
565 for (p = sp->fts_cur; p->fts_level >= FTS_ROOTLEVEL;) {
567 p = p->fts_link != NULL ? p->fts_link : p->fts_parent;
573 /* Free up child linked list, sort array, file name buffer. */
575 fts_lfree(sp->fts_child);
579 if (ISSET(FTS_CWDFD))
581 if (0 <= sp->fts_cwd_fd)
582 close (sp->fts_cwd_fd);
584 else if (!ISSET(FTS_NOCHDIR))
586 /* Return to original directory, save errno if necessary. */
587 if (fchdir(sp->fts_rfd))
592 fd_ring_clear (&sp->fts_fd_ring);
595 /* Free up the stream pointer. */
598 /* Set errno and return. */
600 __set_errno (saved_errno);
608 * Special case of "/" at the end of the file name so that slashes aren't
609 * appended which would cause file names to be written as "....//foo".
612 (p->fts_path[p->fts_pathlen - 1] == '/' \
613 ? p->fts_pathlen - 1 : p->fts_pathlen)
616 fts_read (register FTS *sp)
618 register FTSENT *p, *tmp;
619 register unsigned short int instr;
622 /* If finished or unrecoverable error, return NULL. */
623 if (sp->fts_cur == NULL || ISSET(FTS_STOP))
626 /* Set current node pointer. */
629 /* Save and zero out user instructions. */
630 instr = p->fts_instr;
631 p->fts_instr = FTS_NOINSTR;
633 /* Any type of file may be re-visited; re-stat and re-turn. */
634 if (instr == FTS_AGAIN) {
635 p->fts_info = fts_stat(sp, p, false);
638 Dprintf (("fts_read: p=%s\n",
639 p->fts_info == FTS_INIT ? "" : p->fts_path));
642 * Following a symlink -- SLNONE test allows application to see
643 * SLNONE and recover. If indirecting through a symlink, have
644 * keep a pointer to current location. If unable to get that
645 * pointer, follow fails.
647 if (instr == FTS_FOLLOW &&
648 (p->fts_info == FTS_SL || p->fts_info == FTS_SLNONE)) {
649 p->fts_info = fts_stat(sp, p, true);
650 if (p->fts_info == FTS_D && !ISSET(FTS_NOCHDIR)) {
651 if ((p->fts_symfd = diropen (sp, ".")) < 0) {
652 p->fts_errno = errno;
653 p->fts_info = FTS_ERR;
655 p->fts_flags |= FTS_SYMFOLLOW;
660 /* Directory in pre-order. */
661 if (p->fts_info == FTS_D) {
662 /* If skipped or crossed mount point, do post-order visit. */
663 if (instr == FTS_SKIP ||
664 (ISSET(FTS_XDEV) && p->fts_statp->st_dev != sp->fts_dev)) {
665 if (p->fts_flags & FTS_SYMFOLLOW)
666 (void)close(p->fts_symfd);
668 fts_lfree(sp->fts_child);
669 sp->fts_child = NULL;
671 p->fts_info = FTS_DP;
672 LEAVE_DIR (sp, p, "1");
676 /* Rebuild if only read the names and now traversing. */
677 if (sp->fts_child != NULL && ISSET(FTS_NAMEONLY)) {
679 fts_lfree(sp->fts_child);
680 sp->fts_child = NULL;
684 * Cd to the subdirectory.
686 * If have already read and now fail to chdir, whack the list
687 * to make the names come out right, and set the parent errno
688 * so the application will eventually get an error condition.
689 * Set the FTS_DONTCHDIR flag so that when we logically change
690 * directories back to the parent we don't do a chdir.
692 * If haven't read do so. If the read fails, fts_build sets
693 * FTS_STOP or the fts_info field of the node.
695 if (sp->fts_child != NULL) {
696 if (fts_safe_changedir(sp, p, -1, p->fts_accpath)) {
697 p->fts_errno = errno;
698 p->fts_flags |= FTS_DONTCHDIR;
699 for (p = sp->fts_child; p != NULL;
702 p->fts_parent->fts_accpath;
704 } else if ((sp->fts_child = fts_build(sp, BREAD)) == NULL) {
707 /* If fts_build's call to fts_safe_changedir failed
708 because it was not able to fchdir into a
709 subdirectory, tell the caller. */
710 if (p->fts_errno && p->fts_info != FTS_DNR)
711 p->fts_info = FTS_ERR;
712 LEAVE_DIR (sp, p, "2");
716 sp->fts_child = NULL;
720 /* Move to the next node on this level. */
722 if ((p = p->fts_link) != NULL) {
727 * If reached the top, return to the original directory (or
728 * the root of the tree), and load the file names for the next
731 if (p->fts_level == FTS_ROOTLEVEL) {
732 if (RESTORE_INITIAL_CWD(sp)) {
741 * User may have called fts_set on the node. If skipped,
742 * ignore. If followed, get a file descriptor so we can
743 * get back if necessary.
745 if (p->fts_instr == FTS_SKIP)
747 if (p->fts_instr == FTS_FOLLOW) {
748 p->fts_info = fts_stat(sp, p, true);
749 if (p->fts_info == FTS_D && !ISSET(FTS_NOCHDIR)) {
750 if ((p->fts_symfd = diropen (sp, ".")) < 0) {
751 p->fts_errno = errno;
752 p->fts_info = FTS_ERR;
754 p->fts_flags |= FTS_SYMFOLLOW;
756 p->fts_instr = FTS_NOINSTR;
759 name: t = sp->fts_path + NAPPEND(p->fts_parent);
761 memmove(t, p->fts_name, p->fts_namelen + 1);
764 if (p->fts_info == FTS_NSOK)
766 if (p->fts_statp->st_size == FTS_STAT_REQUIRED)
767 p->fts_info = fts_stat(sp, p, false);
769 fts_assert (p->fts_statp->st_size == FTS_NO_STAT_REQUIRED);
772 if (p->fts_info == FTS_D)
774 /* Now that P->fts_statp is guaranteed to be valid,
775 if this is a command-line directory, record its
776 device number, to be used for FTS_XDEV. */
777 if (p->fts_level == FTS_ROOTLEVEL)
778 sp->fts_dev = p->fts_statp->st_dev;
779 Dprintf ((" entering: %s\n", p->fts_path));
780 if (! enter_dir (sp, p))
782 __set_errno (ENOMEM);
789 /* Move up to the parent node. */
794 if (p->fts_level == FTS_ROOTPARENTLEVEL) {
796 * Done; free everything up and set errno to 0 so the user
797 * can distinguish between error and EOF.
801 return (sp->fts_cur = NULL);
804 fts_assert (p->fts_info != FTS_NSOK);
806 /* NUL terminate the file name. */
807 sp->fts_path[p->fts_pathlen] = '\0';
810 * Return to the parent directory. If at a root node, restore
811 * the initial working directory. If we came through a symlink,
812 * go back through the file descriptor. Otherwise, move up
813 * one level, via "..".
815 if (p->fts_level == FTS_ROOTLEVEL) {
816 if (RESTORE_INITIAL_CWD(sp)) {
817 p->fts_errno = errno;
820 } else if (p->fts_flags & FTS_SYMFOLLOW) {
821 if (FCHDIR(sp, p->fts_symfd)) {
822 int saved_errno = errno;
823 (void)close(p->fts_symfd);
824 __set_errno (saved_errno);
825 p->fts_errno = errno;
828 (void)close(p->fts_symfd);
829 } else if (!(p->fts_flags & FTS_DONTCHDIR) &&
830 fts_safe_changedir(sp, p->fts_parent, -1, "..")) {
831 p->fts_errno = errno;
834 p->fts_info = p->fts_errno ? FTS_ERR : FTS_DP;
835 if (p->fts_errno == 0)
836 LEAVE_DIR (sp, p, "3");
837 return ISSET(FTS_STOP) ? NULL : p;
841 * Fts_set takes the stream as an argument although it's not used in this
842 * implementation; it would be necessary if anyone wanted to add global
843 * semantics to fts using fts_set. An error return is allowed for similar
848 fts_set(FTS *sp ATTRIBUTE_UNUSED, FTSENT *p, int instr)
850 if (instr != 0 && instr != FTS_AGAIN && instr != FTS_FOLLOW &&
851 instr != FTS_NOINSTR && instr != FTS_SKIP) {
852 __set_errno (EINVAL);
855 p->fts_instr = instr;
860 fts_children (register FTS *sp, int instr)
865 if (instr != 0 && instr != FTS_NAMEONLY) {
866 __set_errno (EINVAL);
870 /* Set current node pointer. */
874 * Errno set to 0 so user can distinguish empty directory from
879 /* Fatal errors stop here. */
883 /* Return logical hierarchy of user's arguments. */
884 if (p->fts_info == FTS_INIT)
885 return (p->fts_link);
888 * If not a directory being visited in pre-order, stop here. Could
889 * allow FTS_DNR, assuming the user has fixed the problem, but the
890 * same effect is available with FTS_AGAIN.
892 if (p->fts_info != FTS_D /* && p->fts_info != FTS_DNR */)
895 /* Free up any previous child list. */
896 if (sp->fts_child != NULL)
897 fts_lfree(sp->fts_child);
899 if (instr == FTS_NAMEONLY) {
906 * If using chdir on a relative file name and called BEFORE fts_read
907 * does its chdir to the root of a traversal, we can lose -- we need to
908 * chdir into the subdirectory, and we don't know where the current
909 * directory is, so we can't get back so that the upcoming chdir by
910 * fts_read will work.
912 if (p->fts_level != FTS_ROOTLEVEL || p->fts_accpath[0] == '/' ||
914 return (sp->fts_child = fts_build(sp, instr));
916 if ((fd = diropen (sp, ".")) < 0)
917 return (sp->fts_child = NULL);
918 sp->fts_child = fts_build(sp, instr);
919 if (ISSET(FTS_CWDFD))
921 cwd_advance_fd (sp, fd, true);
927 int saved_errno = errno;
929 __set_errno (saved_errno);
934 return (sp->fts_child);
937 #if defined __linux__ \
938 && HAVE_SYS_VFS_H && HAVE_FSTATFS && HAVE_STRUCT_STATFS_F_TYPE
942 /* Linux-specific constants from coreutils' src/fs.h */
943 # define S_MAGIC_TMPFS 0x1021994
944 # define S_MAGIC_NFS 0x6969
946 /* Return false if it is easy to determine the file system type of
947 the directory on which DIR_FD is open, and sorting dirents on
948 inode numbers is known not to improve traversal performance with
949 that type of file system. Otherwise, return true. */
951 dirent_inode_sort_may_be_useful (int dir_fd)
953 /* Skip the sort only if we can determine efficiently
954 that skipping it is the right thing to do.
955 The cost of performing an unnecessary sort is negligible,
956 while the cost of *not* performing it can be O(N^2) with
957 a very large constant. */
958 struct statfs fs_buf;
960 /* If fstatfs fails, assume sorting would be useful. */
961 if (fstatfs (dir_fd, &fs_buf) != 0)
964 /* FIXME: what about when f_type is not an integral type?
965 deal with that if/when it's encountered. */
966 switch (fs_buf.f_type)
970 /* On a file system of any of these types, sorting
971 is unnecessary, and hence wasteful. */
979 static bool dirent_inode_sort_may_be_useful (int dir_fd) { return true; }
982 /* A comparison function to sort on increasing inode number.
983 For some file system types, sorting either way makes a huge
984 performance difference for a directory with very many entries,
985 but sorting on increasing values is slightly better than sorting
986 on decreasing values. The difference is in the 5% range. */
988 fts_compare_ino (struct _ftsent const **a, struct _ftsent const **b)
990 return (a[0]->fts_statp->st_ino < b[0]->fts_statp->st_ino ? -1
991 : b[0]->fts_statp->st_ino < a[0]->fts_statp->st_ino ? 1 : 0);
995 * This is the tricky part -- do not casually change *anything* in here. The
996 * idea is to build the linked list of entries that are used by fts_children
997 * and fts_read. There are lots of special cases.
999 * The real slowdown in walking the tree is the stat calls. If FTS_NOSTAT is
1000 * set and it's a physical walk (so that symbolic links can't be directories),
1001 * we can do things quickly. First, if it's a 4.4BSD file system, the type
1002 * of the file is in the directory entry. Otherwise, we assume that the number
1003 * of subdirectories in a node is equal to the number of links to the parent.
1004 * The former skips all stat calls. The latter skips stat calls in any leaf
1005 * directories and for any files after the subdirectories in the directory have
1006 * been found, cutting the stat calls by about 2/3.
1010 fts_build (register FTS *sp, int type)
1012 register struct dirent *dp;
1013 register FTSENT *p, *head;
1014 register size_t nitems;
1024 size_t len, maxlen, new_len;
1027 /* Set current node pointer. */
1031 * Open the directory for reading. If this fails, we're done.
1032 * If being called from fts_read, set the fts_info field.
1034 #if defined FTS_WHITEOUT && 0
1035 if (ISSET(FTS_WHITEOUT))
1036 oflag = DTF_NODUP|DTF_REWIND;
1038 oflag = DTF_HIDEW|DTF_NODUP|DTF_REWIND;
1040 # define __opendir2(file, flag) \
1041 ( ! ISSET(FTS_NOCHDIR) && ISSET(FTS_CWDFD) \
1042 ? opendirat(sp->fts_cwd_fd, file) \
1045 if ((dirp = __opendir2(cur->fts_accpath, oflag)) == NULL) {
1046 if (type == BREAD) {
1047 cur->fts_info = FTS_DNR;
1048 cur->fts_errno = errno;
1052 /* Rather than calling fts_stat for each and every entry encountered
1053 in the readdir loop (below), stat each directory only right after
1055 if (cur->fts_info == FTS_NSOK)
1056 cur->fts_info = fts_stat(sp, cur, false);
1059 * Nlinks is the number of possible entries of type directory in the
1060 * directory if we're cheating on stat calls, 0 if we're not doing
1061 * any stat calls at all, (nlink_t) -1 if we're statting everything.
1063 if (type == BNAMES) {
1065 /* Be quiet about nostat, GCC. */
1067 } else if (ISSET(FTS_NOSTAT) && ISSET(FTS_PHYSICAL)) {
1068 nlinks = (cur->fts_statp->st_nlink
1069 - (ISSET(FTS_SEEDOT) ? 0 : 2));
1077 * If we're going to need to stat anything or we want to descend
1078 * and stay in the directory, chdir. If this fails we keep going,
1079 * but set a flag so we don't chdir after the post-order visit.
1080 * We won't be able to stat anything, but we can still return the
1081 * names themselves. Note, that since fts_read won't be able to
1082 * chdir into the directory, it will have to return different file
1083 * names than before, i.e. "a/b" instead of "b". Since the node
1084 * has already been visited in pre-order, have to wait until the
1085 * post-order visit to return the error. There is a special case
1086 * here, if there was nothing to stat then it's not an error to
1087 * not be able to stat. This is all fairly nasty. If a program
1088 * needed sorted entries or stat information, they had better be
1089 * checking FTS_NS on the returned nodes.
1091 if (nlinks || type == BREAD) {
1092 int dir_fd = dirfd(dirp);
1093 if (ISSET(FTS_CWDFD) && 0 <= dir_fd)
1094 dir_fd = dup (dir_fd);
1095 if (dir_fd < 0 || fts_safe_changedir(sp, cur, dir_fd, NULL)) {
1096 if (nlinks && type == BREAD)
1097 cur->fts_errno = errno;
1098 cur->fts_flags |= FTS_DONTCHDIR;
1101 if (ISSET(FTS_CWDFD) && 0 <= dir_fd)
1110 * Figure out the max file name length that can be stored in the
1111 * current buffer -- the inner loop allocates more space as necessary.
1112 * We really wouldn't have to do the maxlen calculations here, we
1113 * could do them in fts_read before returning the name, but it's a
1114 * lot easier here since the length is part of the dirent structure.
1116 * If not changing directories set a pointer so that can just append
1117 * each new component into the file name.
1120 if (ISSET(FTS_NOCHDIR)) {
1121 cp = sp->fts_path + len;
1124 /* GCC, you're too verbose. */
1128 maxlen = sp->fts_pathlen - len;
1130 level = cur->fts_level + 1;
1132 /* Read the directory, attaching each entry to the `link' pointer. */
1134 for (head = tail = NULL, nitems = 0; dirp && (dp = readdir(dirp));) {
1137 if (!ISSET(FTS_SEEDOT) && ISDOT(dp->d_name))
1140 if ((p = fts_alloc (sp, dp->d_name,
1141 _D_EXACT_NAMLEN (dp))) == NULL)
1143 if (_D_EXACT_NAMLEN (dp) >= maxlen) {
1144 /* include space for NUL */
1145 oldaddr = sp->fts_path;
1146 if (! fts_palloc(sp, _D_EXACT_NAMLEN (dp) + len + 1)) {
1148 * No more memory. Save
1149 * errno, free up the current structure and the
1150 * structures already allocated.
1152 mem1: saved_errno = errno;
1156 cur->fts_info = FTS_ERR;
1158 __set_errno (saved_errno);
1161 /* Did realloc() change the pointer? */
1162 if (oldaddr != sp->fts_path) {
1164 if (ISSET(FTS_NOCHDIR))
1165 cp = sp->fts_path + len;
1167 maxlen = sp->fts_pathlen - len;
1170 new_len = len + _D_EXACT_NAMLEN (dp);
1171 if (new_len < len) {
1173 * In the unlikely event that we would end up
1174 * with a file name longer than SIZE_MAX, free up
1175 * the current structure and the structures already
1176 * allocated, then error out with ENAMETOOLONG.
1181 cur->fts_info = FTS_ERR;
1183 __set_errno (ENAMETOOLONG);
1186 p->fts_level = level;
1187 p->fts_parent = sp->fts_cur;
1188 p->fts_pathlen = new_len;
1190 #if defined FTS_WHITEOUT && 0
1191 if (dp->d_type == DT_WHT)
1192 p->fts_flags |= FTS_ISW;
1194 /* Store dirent.d_ino, in case we need to sort
1195 entries before processing them. */
1196 p->fts_statp->st_ino = D_INO (dp);
1198 /* Build a file name for fts_stat to stat. */
1199 if (ISSET(FTS_NOCHDIR)) {
1200 p->fts_accpath = p->fts_path;
1201 memmove(cp, p->fts_name, p->fts_namelen + 1);
1203 p->fts_accpath = p->fts_name;
1205 if (sp->fts_compar == NULL || ISSET(FTS_DEFER_STAT)) {
1206 /* Record what fts_read will have to do with this
1207 entry. In many cases, it will simply fts_stat it,
1208 but we can take advantage of any d_type information
1209 to optimize away the unnecessary stat calls. I.e.,
1210 if FTS_NOSTAT is in effect and we're not following
1211 symlinks (FTS_PHYSICAL) and d_type indicates this
1212 is *not* a directory, then we won't have to stat it
1213 at all. If it *is* a directory, then (currently)
1214 we stat it regardless, in order to get device and
1215 inode numbers. Some day we might optimize that
1216 away, too, for directories where d_ino is known to
1218 bool skip_stat = (ISSET(FTS_PHYSICAL)
1219 && ISSET(FTS_NOSTAT)
1221 && ! DT_MUST_BE(dp, DT_DIR));
1222 p->fts_info = FTS_NSOK;
1223 fts_set_stat_required(p, !skip_stat);
1224 is_dir = (ISSET(FTS_PHYSICAL) && ISSET(FTS_NOSTAT)
1225 && DT_MUST_BE(dp, DT_DIR));
1227 p->fts_info = fts_stat(sp, p, false);
1228 is_dir = (p->fts_info == FTS_D
1229 || p->fts_info == FTS_DC
1230 || p->fts_info == FTS_DOT);
1233 /* Decrement link count if applicable. */
1234 if (nlinks > 0 && is_dir)
1237 /* We walk in directory order so "ls -f" doesn't get upset. */
1251 * If realloc() changed the address of the file name, adjust the
1252 * addresses for the rest of the tree and the dir list.
1255 fts_padjust(sp, head);
1258 * If not changing directories, reset the file name back to original
1261 if (ISSET(FTS_NOCHDIR)) {
1262 if (len == sp->fts_pathlen || nitems == 0)
1268 * If descended after called from fts_children or after called from
1269 * fts_read and nothing found, get back. At the root level we use
1270 * the saved fd; if one of fts_open()'s arguments is a relative name
1271 * to an empty directory, we wind up here with no other way back. If
1272 * can't get back, we're done.
1274 if (descend && (type == BCHILD || !nitems) &&
1275 (cur->fts_level == FTS_ROOTLEVEL
1276 ? RESTORE_INITIAL_CWD(sp)
1277 : fts_safe_changedir(sp, cur->fts_parent, -1, ".."))) {
1278 cur->fts_info = FTS_ERR;
1284 /* If didn't find anything, return NULL. */
1287 cur->fts_info = FTS_DP;
1292 /* If there are many entries, no sorting function has been specified,
1293 and this file system is of a type that may be slow with a large
1294 number of entries, then sort the directory entries on increasing
1296 if (nitems > _FTS_INODE_SORT_DIR_ENTRIES_THRESHOLD
1298 && ISSET (FTS_CWDFD)
1299 && dirent_inode_sort_may_be_useful (sp->fts_cwd_fd)) {
1300 sp->fts_compar = fts_compare_ino;
1301 head = fts_sort (sp, head, nitems);
1302 sp->fts_compar = NULL;
1305 /* Sort the entries. */
1306 if (sp->fts_compar && nitems > 1)
1307 head = fts_sort(sp, head, nitems);
1313 /* Walk ->fts_parent links starting at E_CURR, until the root of the
1314 current hierarchy. There should be a directory with dev/inode
1315 matching those of AD. If not, print a lot of diagnostics. */
1317 find_matching_ancestor (FTSENT const *e_curr, struct Active_dir const *ad)
1320 for (ent = e_curr; ent->fts_level >= FTS_ROOTLEVEL; ent = ent->fts_parent)
1322 if (ad->ino == ent->fts_statp->st_ino
1323 && ad->dev == ent->fts_statp->st_dev)
1326 printf ("ERROR: tree dir, %s, not active\n", ad->fts_ent->fts_accpath);
1327 printf ("active dirs:\n");
1329 ent->fts_level >= FTS_ROOTLEVEL; ent = ent->fts_parent)
1330 printf (" %s(%"PRIuMAX"/%"PRIuMAX") to %s(%"PRIuMAX"/%"PRIuMAX")...\n",
1331 ad->fts_ent->fts_accpath,
1332 (uintmax_t) ad->dev,
1333 (uintmax_t) ad->ino,
1335 (uintmax_t) ent->fts_statp->st_dev,
1336 (uintmax_t) ent->fts_statp->st_ino);
1340 fts_cross_check (FTS const *sp)
1342 FTSENT const *ent = sp->fts_cur;
1344 if ( ! ISSET (FTS_TIGHT_CYCLE_CHECK))
1347 Dprintf (("fts-cross-check cur=%s\n", ent->fts_path));
1348 /* Make sure every parent dir is in the tree. */
1349 for (t = ent->fts_parent; t->fts_level >= FTS_ROOTLEVEL; t = t->fts_parent)
1351 struct Active_dir ad;
1352 ad.ino = t->fts_statp->st_ino;
1353 ad.dev = t->fts_statp->st_dev;
1354 if ( ! hash_lookup (sp->fts_cycle.ht, &ad))
1355 printf ("ERROR: active dir, %s, not in tree\n", t->fts_path);
1358 /* Make sure every dir in the tree is an active dir.
1359 But ENT is not necessarily a directory. If so, just skip this part. */
1360 if (ent->fts_parent->fts_level >= FTS_ROOTLEVEL
1361 && (ent->fts_info == FTS_DP
1362 || ent->fts_info == FTS_D))
1364 struct Active_dir *ad;
1365 for (ad = hash_get_first (sp->fts_cycle.ht); ad != NULL;
1366 ad = hash_get_next (sp->fts_cycle.ht, ad))
1368 find_matching_ancestor (ent, ad);
1374 same_fd (int fd1, int fd2)
1376 struct stat sb1, sb2;
1377 return (fstat (fd1, &sb1) == 0
1378 && fstat (fd2, &sb2) == 0
1379 && SAME_INODE (sb1, sb2));
1383 fd_ring_print (FTS const *sp, FILE *stream, char const *msg)
1385 I_ring const *fd_ring = &sp->fts_fd_ring;
1386 unsigned int i = fd_ring->fts_front;
1387 char *cwd = getcwdat (sp->fts_cwd_fd, NULL, 0);
1388 fprintf (stream, "=== %s ========== %s\n", msg, cwd);
1390 if (i_ring_empty (fd_ring))
1395 int fd = fd_ring->fts_fd_ring[i];
1397 fprintf (stream, "%d: %d:\n", i, fd);
1400 char *wd = getcwdat (fd, NULL, 0);
1401 fprintf (stream, "%d: %d: %s\n", i, fd, wd);
1404 if (i == fd_ring->fts_back)
1406 i = (i + I_RING_SIZE - 1) % I_RING_SIZE;
1410 /* Ensure that each file descriptor on the fd_ring matches a
1411 parent, grandparent, etc. of the current working directory. */
1413 fd_ring_check (FTS const *sp)
1418 /* Make a writable copy. */
1419 I_ring fd_w = sp->fts_fd_ring;
1421 int cwd_fd = sp->fts_cwd_fd;
1422 cwd_fd = dup (cwd_fd);
1423 char *dot = getcwdat (cwd_fd, NULL, 0);
1424 error (0, 0, "===== check ===== cwd: %s", dot);
1426 while ( ! i_ring_empty (&fd_w))
1428 int fd = i_ring_pop (&fd_w);
1431 int parent_fd = openat (cwd_fd, "..", O_RDONLY);
1437 if (!same_fd (fd, parent_fd))
1439 char *cwd = getcwdat (fd, NULL, 0);
1440 error (0, errno, "ring : %s", cwd);
1441 char *c2 = getcwdat (parent_fd, NULL, 0);
1442 error (0, errno, "parent: %s", c2);
1455 static unsigned short int
1457 fts_stat(FTS *sp, register FTSENT *p, bool follow)
1459 struct stat *sbp = p->fts_statp;
1462 if (p->fts_level == FTS_ROOTLEVEL && ISSET(FTS_COMFOLLOW))
1465 #if defined FTS_WHITEOUT && 0
1466 /* check for whiteout */
1467 if (p->fts_flags & FTS_ISW) {
1468 memset(sbp, '\0', sizeof (*sbp));
1469 sbp->st_mode = S_IFWHT;
1475 * If doing a logical walk, or application requested FTS_FOLLOW, do
1476 * a stat(2). If that fails, check for a non-existent symlink. If
1477 * fail, set the errno from the stat call.
1479 if (ISSET(FTS_LOGICAL) || follow) {
1480 if (stat(p->fts_accpath, sbp)) {
1481 saved_errno = errno;
1483 && lstat(p->fts_accpath, sbp) == 0) {
1485 return (FTS_SLNONE);
1487 p->fts_errno = saved_errno;
1490 } else if (fstatat(sp->fts_cwd_fd, p->fts_accpath, sbp,
1491 AT_SYMLINK_NOFOLLOW)) {
1492 p->fts_errno = errno;
1493 err: memset(sbp, 0, sizeof(struct stat));
1497 if (S_ISDIR(sbp->st_mode)) {
1498 if (ISDOT(p->fts_name)) {
1499 /* Command-line "." and ".." are real directories. */
1500 return (p->fts_level == FTS_ROOTLEVEL ? FTS_D : FTS_DOT);
1506 * Cycle detection is done by brute force when the directory
1507 * is first encountered. If the tree gets deep enough or the
1508 * number of symbolic links to directories is high enough,
1509 * something faster might be worthwhile.
1513 for (t = p->fts_parent;
1514 t->fts_level >= FTS_ROOTLEVEL; t = t->fts_parent)
1515 if (sbp->st_ino == t->fts_statp->st_ino
1516 && sbp->st_dev == t->fts_statp->st_dev)
1526 if (S_ISLNK(sbp->st_mode))
1528 if (S_ISREG(sbp->st_mode))
1530 return (FTS_DEFAULT);
1534 fts_compar (void const *a, void const *b)
1536 /* Convert A and B to the correct types, to pacify the compiler, and
1537 for portability to bizarre hosts where "void const *" and "FTSENT
1538 const **" differ in runtime representation. The comparison
1539 function cannot modify *a and *b, but there is no compile-time
1541 FTSENT const **pa = (FTSENT const **) a;
1542 FTSENT const **pb = (FTSENT const **) b;
1543 return pa[0]->fts_fts->fts_compar (pa, pb);
1548 fts_sort (FTS *sp, FTSENT *head, register size_t nitems)
1550 register FTSENT **ap, *p;
1552 /* On most modern hosts, void * and FTSENT ** have the same
1553 run-time representation, and one can convert sp->fts_compar to
1554 the type qsort expects without problem. Use the heuristic that
1555 this is OK if the two pointer types are the same size, and if
1556 converting FTSENT ** to long int is the same as converting
1557 FTSENT ** to void * and then to long int. This heuristic isn't
1558 valid in general but we don't know of any counterexamples. */
1560 int (*compare) (void const *, void const *) =
1561 ((sizeof &dummy == sizeof (void *)
1562 && (long int) &dummy == (long int) (void *) &dummy)
1563 ? (int (*) (void const *, void const *)) sp->fts_compar
1567 * Construct an array of pointers to the structures and call qsort(3).
1568 * Reassemble the array in the order returned by qsort. If unable to
1569 * sort for memory reasons, return the directory entries in their
1570 * current order. Allocate enough space for the current needs plus
1571 * 40 so don't realloc one entry at a time.
1573 if (nitems > sp->fts_nitems) {
1576 sp->fts_nitems = nitems + 40;
1577 if (SIZE_MAX / sizeof *a < sp->fts_nitems
1578 || ! (a = realloc (sp->fts_array,
1579 sp->fts_nitems * sizeof *a))) {
1580 free(sp->fts_array);
1581 sp->fts_array = NULL;
1587 for (ap = sp->fts_array, p = head; p; p = p->fts_link)
1589 qsort((void *)sp->fts_array, nitems, sizeof(FTSENT *), compare);
1590 for (head = *(ap = sp->fts_array); --nitems; ++ap)
1591 ap[0]->fts_link = ap[1];
1592 ap[0]->fts_link = NULL;
1598 fts_alloc (FTS *sp, const char *name, register size_t namelen)
1604 * The file name is a variable length array. Allocate the FTSENT
1605 * structure and the file name in one chunk.
1607 len = sizeof(FTSENT) + namelen;
1608 if ((p = malloc(len)) == NULL)
1611 /* Copy the name and guarantee NUL termination. */
1612 memmove(p->fts_name, name, namelen);
1613 p->fts_name[namelen] = '\0';
1615 p->fts_namelen = namelen;
1617 p->fts_path = sp->fts_path;
1620 p->fts_instr = FTS_NOINSTR;
1622 p->fts_pointer = NULL;
1628 fts_lfree (register FTSENT *head)
1632 /* Free a linked list of structures. */
1633 while ((p = head)) {
1634 head = head->fts_link;
1640 * Allow essentially unlimited file name lengths; find, rm, ls should
1641 * all work on any tree. Most systems will allow creation of file
1642 * names much longer than MAXPATHLEN, even though the kernel won't
1643 * resolve them. Add the size (not just what's needed) plus 256 bytes
1644 * so don't realloc the file name 2 bytes at a time.
1648 fts_palloc (FTS *sp, size_t more)
1651 size_t new_len = sp->fts_pathlen + more + 256;
1654 * See if fts_pathlen would overflow.
1656 if (new_len < sp->fts_pathlen) {
1658 sp->fts_path = NULL;
1659 __set_errno (ENAMETOOLONG);
1662 sp->fts_pathlen = new_len;
1663 p = realloc(sp->fts_path, sp->fts_pathlen);
1666 sp->fts_path = NULL;
1674 * When the file name is realloc'd, have to fix all of the pointers in
1675 * structures already returned.
1679 fts_padjust (FTS *sp, FTSENT *head)
1682 char *addr = sp->fts_path;
1684 #define ADJUST(p) do { \
1685 if ((p)->fts_accpath != (p)->fts_name) { \
1686 (p)->fts_accpath = \
1687 (char *)addr + ((p)->fts_accpath - (p)->fts_path); \
1689 (p)->fts_path = addr; \
1691 /* Adjust the current set of children. */
1692 for (p = sp->fts_child; p; p = p->fts_link)
1695 /* Adjust the rest of the tree, including the current level. */
1696 for (p = head; p->fts_level >= FTS_ROOTLEVEL;) {
1698 p = p->fts_link ? p->fts_link : p->fts_parent;
1704 fts_maxarglen (char * const *argv)
1708 for (max = 0; *argv; ++argv)
1709 if ((len = strlen(*argv)) > max)
1715 * Change to dir specified by fd or file name without getting
1716 * tricked by someone changing the world out from underneath us.
1717 * Assumes p->fts_statp->st_dev and p->fts_statp->st_ino are filled in.
1718 * If FD is non-negative, expect it to be used after this function returns,
1719 * and to be closed eventually. So don't pass e.g., `dirfd(dirp)' and then
1720 * do closedir(dirp), because that would invalidate the saved FD.
1721 * Upon failure, close FD immediately and return nonzero.
1725 fts_safe_changedir (FTS *sp, FTSENT *p, int fd, char const *dir)
1728 bool is_dotdot = dir && STREQ (dir, "..");
1731 /* This clause handles the unusual case in which FTS_NOCHDIR
1732 is specified, along with FTS_CWDFD. In that case, there is
1733 no need to change even the virtual cwd file descriptor.
1734 However, if FD is non-negative, we do close it here. */
1735 if (ISSET (FTS_NOCHDIR))
1737 if (ISSET (FTS_CWDFD) && 0 <= fd)
1742 if (fd < 0 && is_dotdot && ISSET (FTS_CWDFD))
1744 /* When possible, skip the diropen and subsequent fstat+dev/ino
1745 comparison. I.e., when changing to parent directory
1746 (chdir ("..")), use a file descriptor from the ring and
1747 save the overhead of diropen+fstat, as well as avoiding
1748 failure when we lack "x" access to the virtual cwd. */
1749 if ( ! i_ring_empty (&sp->fts_fd_ring))
1752 fd_ring_print (sp, stderr, "pre-pop");
1753 parent_fd = i_ring_pop (&sp->fts_fd_ring);
1764 if (fd < 0 && (newfd = diropen (sp, dir)) < 0)
1767 /* The following dev/inode check is necessary if we're doing a
1768 `logical' traversal (through symlinks, a la chown -L), if the
1769 system lacks O_NOFOLLOW support, or if we're changing to ".."
1770 (but not via a popped file descriptor). When changing to the
1771 name "..", O_NOFOLLOW can't help. In general, when the target is
1772 not "..", diropen's use of O_NOFOLLOW ensures we don't mistakenly
1773 follow a symlink, so we can avoid the expense of this fstat. */
1774 if (ISSET(FTS_LOGICAL) || ! HAVE_WORKING_O_NOFOLLOW
1775 || (dir && STREQ (dir, "..")))
1778 if (fstat(newfd, &sb))
1783 if (p->fts_statp->st_dev != sb.st_dev
1784 || p->fts_statp->st_ino != sb.st_ino)
1786 __set_errno (ENOENT); /* disinformation */
1792 if (ISSET(FTS_CWDFD))
1794 cwd_advance_fd (sp, newfd, ! is_dotdot);
1798 ret = fchdir(newfd);
1804 __set_errno (oerrno);