1 /* find -- search for files in a directory hierarchy
2 Copyright (C) 1990, 91, 92, 93, 94, 2000,
3 2003, 2004, 2005, 2007 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/>.
18 /* GNU find was written by Eric Decker <cire@cisco.com>,
19 with enhancements by David MacKenzie <djm@gnu.org>,
20 Jay Plett <jay@silence.princeton.nj.us>,
21 and Tim Wood <axolotl!tim@toad.com>.
22 The idea for -print0 and xargs -0 came from
23 Dan Bernstein <brnstnd@kramden.acf.nyu.edu>.
24 Improvements have been made by James Youngman <jay@gnu.org>.
31 #define USE_SAFE_CHDIR 1
32 #undef STAT_MOUNTPOINTS
44 #include "canonicalize.h"
48 #include "savedirinfo.h"
62 # define _(Text) gettext (Text)
65 #define textdomain(Domain)
66 #define bindtextdomain(Package, Directory)
69 # define N_(String) gettext_noop (String)
71 /* See locate.c for explanation as to why not use (String) */
72 # define N_(String) String
75 #ifdef STAT_MOUNTPOINTS
76 static void init_mounted_dev_list(int mandatory
);
79 static void process_top_path
PARAMS((char *pathname
, mode_t mode
));
80 static int process_path
PARAMS((char *pathname
, char *name
, boolean leaf
, char *parent
, mode_t type
));
81 static void process_dir
PARAMS((char *pathname
, char *name
, int pathlen
, const struct stat
*statp
, char *parent
));
85 /* Name this program was run with. */
88 /* A file descriptor open to the initial working directory.
89 Doing it this way allows us to work when the i.w.d. has
90 unreadable parents. */
93 /* The stat buffer of the initial working directory. */
94 static struct stat starting_stat_buf
;
96 enum ChdirSymlinkHandling
98 SymlinkHandleDefault
, /* Normally the right choice */
99 SymlinkFollowOk
/* see comment in process_top_path() */
103 enum TraversalDirection
109 enum WdSanityCheckFatality
111 FATAL_IF_SANITY_CHECK_FAILS
,
112 RETRY_IF_SANITY_CHECK_FAILS
,
113 NON_FATAL_IF_SANITY_CHECK_FAILS
117 int get_current_dirfd(void)
124 main (int argc
, char **argv
)
127 int end_of_leading_options
= 0; /* First arg after any -H/-L etc. */
128 struct predicate
*eval_tree
;
130 program_name
= argv
[0];
131 state
.exit_status
= 0;
133 /* Set the option defaults before we do the locale
134 * initialisation as check_nofollow() needs to be executed in the
137 set_option_defaults(&options
);
139 #ifdef HAVE_SETLOCALE
140 setlocale (LC_ALL
, "");
142 bindtextdomain (PACKAGE
, LOCALEDIR
);
143 textdomain (PACKAGE
);
144 atexit (close_stdin
);
146 /* Check for -P, -H or -L options. */
147 end_of_leading_options
= process_leading_options(argc
, argv
);
149 if (options
.debug_options
& DebugStat
)
150 options
.xstat
= debug_stat
;
153 fprintf (stderr
, "cur_day_start = %s", ctime (&options
.cur_day_start
));
156 /* state.cwd_dir_fd has to be initialised before we call build_expression_tree()
157 * because command-line parsing may lead us to stat some files.
159 state
.cwd_dir_fd
= AT_FDCWD
;
161 /* We are now processing the part of the "find" command line
162 * after the -H/-L options (if any).
164 eval_tree
= build_expression_tree(argc
, argv
, end_of_leading_options
);
167 /* safely_chdir() needs to check that it has ended up in the right place.
168 * To avoid bailing out when something gets automounted, it checks if
169 * the target directory appears to have had a directory mounted on it as
170 * we chdir()ed. The problem with this is that in order to notice that
171 * a file system was mounted, we would need to lstat() all the mount points.
172 * That strategy loses if our machine is a client of a dead NFS server.
174 * Hence if safely_chdir() and wd_sanity_check() can manage without needing
175 * to know the mounted device list, we do that.
177 if (!options
.open_nofollow_available
)
179 #ifdef STAT_MOUNTPOINTS
180 init_mounted_dev_list(0);
185 starting_desc
= open (".", O_RDONLY
186 #if defined O_LARGEFILE
190 if (0 <= starting_desc
&& fchdir (starting_desc
) != 0)
192 close (starting_desc
);
196 if (starting_desc
< 0)
198 starting_dir
= xgetcwd ();
200 error (1, errno
, _("cannot get current directory"));
202 set_stat_placeholders(&starting_stat_buf
);
203 if ((*options
.xstat
) (".", &starting_stat_buf
) != 0)
204 error (1, errno
, _("cannot stat current directory"));
206 /* If no paths are given, default to ".". */
207 for (i
= end_of_leading_options
; i
< argc
&& !looks_like_expression(argv
[i
], true); i
++)
209 process_top_path (argv
[i
], 0);
212 /* If there were no path arguments, default to ".". */
213 if (i
== end_of_leading_options
)
216 * We use a temporary variable here because some actions modify
217 * the path temporarily. Hence if we use a string constant,
218 * we get a coredump. The best example of this is if we say
219 * "find -printf %H" (note, not "find . -printf %H").
221 char defaultpath
[2] = ".";
222 process_top_path (defaultpath
, 0);
225 /* If "-exec ... {} +" has been used, there may be some
226 * partially-full command lines which have been built,
227 * but which are not yet complete. Execute those now.
229 show_success_rates(eval_tree
);
231 return state
.exit_status
;
234 boolean
is_fts_enabled(int *ftsoptions
)
236 /* this version of find (i.e. this main()) does not use fts. */
243 specific_dirname(const char *dir
)
247 if (0 == strcmp(".", dir
))
249 /* OK, what's '.'? */
250 if (NULL
!= getcwd(dirbuf
, sizeof(dirbuf
)))
252 return strdup(dirbuf
);
261 char *result
= canonicalize_filename_mode(dir
, CAN_EXISTING
);
271 /* Return non-zero if FS is the name of a file system that is likely to
275 fs_likely_to_be_automounted(const char *fs
)
277 return ( (0==strcmp(fs
, "nfs")) || (0==strcmp(fs
, "autofs")) || (0==strcmp(fs
, "subfs")));
282 #ifdef STAT_MOUNTPOINTS
283 static dev_t
*mounted_devices
= NULL
;
284 static size_t num_mounted_devices
= 0u;
288 init_mounted_dev_list(int mandatory
)
290 assert (NULL
== mounted_devices
);
291 assert (0 == num_mounted_devices
);
292 mounted_devices
= get_mounted_devices(&num_mounted_devices
);
293 if (mandatory
&& (NULL
== mounted_devices
))
295 error(1, 0, "Cannot read list of mounted devices.");
300 refresh_mounted_dev_list(void)
304 free(mounted_devices
);
307 num_mounted_devices
= 0u;
308 init_mounted_dev_list(1);
312 /* Search for device DEV in the array LIST, which is of size N. */
314 dev_present(dev_t dev
, const dev_t
*list
, size_t n
)
320 if ( (*list
++) == dev
)
327 enum MountPointStateChange
329 MountPointRecentlyMounted
,
330 MountPointRecentlyUnmounted
,
331 MountPointStateUnchanged
336 static enum MountPointStateChange
337 get_mount_state(dev_t newdev
)
339 int new_is_present
, new_was_present
;
341 new_was_present
= dev_present(newdev
, mounted_devices
, num_mounted_devices
);
342 refresh_mounted_dev_list();
343 new_is_present
= dev_present(newdev
, mounted_devices
, num_mounted_devices
);
345 if (new_was_present
== new_is_present
)
346 return MountPointStateUnchanged
;
347 else if (new_is_present
)
348 return MountPointRecentlyMounted
;
350 return MountPointRecentlyUnmounted
;
355 /* We stat()ed a directory, chdir()ed into it (we know this
356 * since direction is TraversingDown), stat()ed it again,
357 * and noticed that the device numbers are different. Check
358 * if the file system was recently mounted.
360 * If it was, it looks like chdir()ing into the directory
361 * caused a file system to be mounted. Maybe automount is
362 * running. Anyway, that's probably OK - but it happens
363 * only when we are moving downward.
365 * We also allow for the possibility that a similar thing
366 * has happened with the unmounting of a file system. This
367 * is much rarer, as it relies on an automounter timeout
368 * occurring at exactly the wrong moment.
370 static enum WdSanityCheckFatality
371 dirchange_is_fatal(const char *specific_what
,
372 enum WdSanityCheckFatality isfatal
,
374 struct stat
*newinfo
)
376 enum MountPointStateChange transition
= get_mount_state(newinfo
->st_dev
);
379 case MountPointRecentlyUnmounted
:
380 isfatal
= NON_FATAL_IF_SANITY_CHECK_FAILS
;
384 _("Warning: file system %s has recently been unmounted."),
385 safely_quote_err_filename(0, specific_what
));
389 case MountPointRecentlyMounted
:
390 isfatal
= NON_FATAL_IF_SANITY_CHECK_FAILS
;
394 _("Warning: file system %s has recently been mounted."),
395 safely_quote_err_filename(0, specific_what
));
399 case MountPointStateUnchanged
:
400 /* leave isfatal as it is */
412 /* Examine the results of the stat() of a directory from before we
413 * entered or left it, with the results of stat()ing it afterward. If
414 * these are different, the file system tree has been modified while we
415 * were traversing it. That might be an attempt to use a race
416 * condition to persuade find to do something it didn't intend
417 * (e.g. an attempt by an ordinary user to exploit the fact that root
418 * sometimes runs find on the whole file system). However, this can
419 * also happen if automount is running (certainly on Solaris). With
420 * automount, moving into a directory can cause a file system to be
423 * To cope sensibly with this, we will raise an error if we see the
424 * device number change unless we are chdir()ing into a subdirectory,
425 * and the directory we moved into has been mounted or unmounted "recently".
426 * Here "recently" means since we started "find" or we last re-read
427 * the /etc/mnttab file.
429 * If the device number does not change but the inode does, that is a
432 * If the device number and inode are both the same, we are happy.
434 * If a file system is (un)mounted as we chdir() into the directory, that
435 * may mean that we're now examining a section of the file system that might
436 * have been excluded from consideration (via -prune or -quit for example).
437 * Hence we print a warning message to indicate that the output of find
438 * might be inconsistent due to the change in the file system.
441 wd_sanity_check(const char *thing_to_stat
,
442 const char *progname
,
446 struct stat
*newinfo
,
449 enum TraversalDirection direction
,
450 enum WdSanityCheckFatality isfatal
,
451 boolean
*changed
) /* output parameter */
454 char *specific_what
= NULL
;
456 const char *current_dir
= ".";
460 set_stat_placeholders(newinfo
);
461 if ((*options
.xstat
) (current_dir
, newinfo
) != 0)
462 fatal_file_error(thing_to_stat
);
464 if (old_dev
!= newinfo
->st_dev
)
467 specific_what
= specific_dirname(what
);
468 fstype
= filesystem_type(newinfo
, current_dir
);
469 silent
= fs_likely_to_be_automounted(fstype
);
471 /* This condition is rare, so once we are here it is
472 * reasonable to perform an expensive computation to
473 * determine if we should continue or fail.
475 if (TraversingDown
== direction
)
477 #ifdef STAT_MOUNTPOINTS
478 isfatal
= dirchange_is_fatal(specific_what
,isfatal
,silent
,newinfo
);
480 isfatal
= RETRY_IF_SANITY_CHECK_FAILS
;
486 case FATAL_IF_SANITY_CHECK_FAILS
:
488 fstype
= filesystem_type(newinfo
, current_dir
);
490 _("%s%s changed during execution of %s (old device number %ld, new device number %ld, file system type is %s) [ref %ld]"),
491 safely_quote_err_filename(0, specific_what
),
493 safely_quote_err_filename(1, progname
),
495 (long) newinfo
->st_dev
,
502 case NON_FATAL_IF_SANITY_CHECK_FAILS
:
504 /* Since the device has changed under us, the inode number
505 * will almost certainly also be different. However, we have
506 * already decided that this is not a problem. Hence we return
507 * without checking the inode number.
513 case RETRY_IF_SANITY_CHECK_FAILS
:
518 /* Device number was the same, check if the inode has changed. */
519 if (old_ino
!= newinfo
->st_ino
)
522 specific_what
= specific_dirname(what
);
523 fstype
= filesystem_type(newinfo
, current_dir
);
525 error ((isfatal
== FATAL_IF_SANITY_CHECK_FAILS
) ? 1 : 0,
526 0, /* no relevant errno value */
527 _("%s%s changed during execution of %s (old inode number %ld, new inode number %ld, file system type is %s) [ref %ld]"),
528 safely_quote_err_filename(0, specific_what
),
530 safely_quote_err_filename(1, progname
),
532 (long) newinfo
->st_ino
,
545 SafeChdirFailSymlink
,
548 SafeChdirFailWouldBeUnableToReturn
,
549 SafeChdirFailChdirFailed
,
550 SafeChdirFailNonexistent
,
551 SafeChdirFailDestUnreadable
554 /* Safely perform a change in directory. We do this by calling
555 * lstat() on the subdirectory, using chdir() to move into it, and
556 * then lstat()ing ".". We compare the results of the two stat calls
557 * to see if they are consistent. If not, we sound the alarm.
559 * If following_links() is true, we do follow symbolic links.
561 static enum SafeChdirStatus
562 safely_chdir_lstat(const char *dest
,
563 enum TraversalDirection direction
,
564 struct stat
*statbuf_dest
,
565 enum ChdirSymlinkHandling symlink_follow_option
,
568 struct stat statbuf_arrived
;
570 int saved_errno
; /* specific_dirname() changes errno. */
571 boolean rv_set
= false;
572 boolean statflag
= false;
574 enum WdSanityCheckFatality isfatal
= RETRY_IF_SANITY_CHECK_FAILS
;
576 saved_errno
= errno
= 0;
578 dotfd
= open(".", O_RDONLY
579 #if defined O_LARGEFILE
584 /* We jump back to here if wd_sanity_check()
585 * recoverably triggers an alert.
592 /* Stat the directory we're going to. */
593 set_stat_placeholders(statbuf_dest
);
594 if (0 == options
.xstat(dest
, statbuf_dest
))
599 /* symlink_follow_option might be set to SymlinkFollowOk, which
600 * would allow us to chdir() into a symbolic link. This is
601 * only useful for the case where the directory we're
602 * chdir()ing into is the basename of a command line
603 * argument, for example where "foo/bar/baz" is specified on
604 * the command line. When -P is in effect (the default),
605 * baz will not be followed if it is a symlink, but if bar
606 * is a symlink, it _should_ be followed. Hence we need the
607 * ability to override the policy set by following_links().
609 if (!following_links() && S_ISLNK(statbuf_dest
->st_mode
))
611 /* We're not supposed to be following links, but this is
612 * a link. Check symlink_follow_option to see if we should
613 * make a special exception.
615 if (symlink_follow_option
== SymlinkFollowOk
)
617 /* We need to re-stat() the file so that the
618 * sanity check can pass.
620 if (0 != stat(dest
, statbuf_dest
))
622 rv
= SafeChdirFailNonexistent
;
631 /* Not following symlinks, so the attempt to
632 * chdir() into a symlink should be prevented.
634 rv
= SafeChdirFailSymlink
;
636 saved_errno
= 0; /* silence the error message */
642 /* Although the immediately following chdir() would detect
643 * the fact that this is not a directory for us, this would
644 * result in an extra system call that fails. Anybody
645 * examining the system-call trace should ideally not be
646 * concerned that something is actually failing.
648 if (!S_ISDIR(statbuf_dest
->st_mode
))
650 rv
= SafeChdirFailNotDir
;
652 saved_errno
= 0; /* silence the error message */
657 if (options
.debug_options
& DebugSearch
)
658 fprintf(stderr
, "safely_chdir(): chdir(\"%s\")\n", dest
);
660 if (0 == chdir(dest
))
662 /* check we ended up where we wanted to go */
663 boolean changed
= false;
664 if (!wd_sanity_check(".", program_name
, ".",
665 statbuf_dest
->st_dev
,
666 statbuf_dest
->st_ino
,
668 0, __LINE__
, direction
,
672 /* Only allow one failure. */
673 if (RETRY_IF_SANITY_CHECK_FAILS
== isfatal
)
675 if (0 == fchdir(dotfd
))
677 isfatal
= FATAL_IF_SANITY_CHECK_FAILS
;
682 /* Failed to return to original directory,
683 * but we know that the current working
684 * directory is not the one that we intend
685 * to be in. Since fchdir() failed, we
686 * can't recover from this and so this error
690 "failed to return to parent directory");
695 /* XXX: not sure what to use as an excuse here. */
696 rv
= SafeChdirFailNonexistent
;
709 if (ENOENT
== saved_errno
)
711 rv
= SafeChdirFailNonexistent
;
713 if (options
.ignore_readdir_race
)
714 errno
= 0; /* don't issue err msg */
716 else if (ENOTDIR
== saved_errno
)
718 /* This can happen if the we stat a directory,
719 * and then file system activity changes it into
722 saved_errno
= 0; /* don't issue err msg */
723 rv
= SafeChdirFailNotDir
;
728 rv
= SafeChdirFailChdirFailed
;
737 rv
= SafeChdirFailStat
;
740 if ( (ENOENT
== saved_errno
) || (0 == state
.curdepth
))
741 saved_errno
= 0; /* don't issue err msg */
747 /* We do not have read permissions on "." */
748 rv
= SafeChdirFailWouldBeUnableToReturn
;
753 /* This is the success path, so we clear errno. The caller probably
754 * won't be calling error() anyway.
758 /* We use the same exit path for success or failure.
759 * which has occurred is recorded in RV.
762 /* We do not call error() as this would result in a duplicate error
763 * message when the caller does the same thing.
774 *did_stat
= statflag
;
779 #if defined O_NOFOLLOW
780 /* Safely change working directory to the specified subdirectory. If
781 * we are not allowed to follow symbolic links, we use open() with
782 * O_NOFOLLOW, followed by fchdir(). This ensures that we don't
783 * follow symbolic links (of course, we do follow them if the -L
784 * option is in effect).
786 static enum SafeChdirStatus
787 safely_chdir_nofollow(const char *dest
,
788 enum TraversalDirection direction
,
789 struct stat
*statbuf_dest
,
790 enum ChdirSymlinkHandling symlink_follow_option
,
801 switch (symlink_follow_option
)
803 case SymlinkFollowOk
:
807 case SymlinkHandleDefault
:
808 if (following_links())
811 extraflags
= O_NOFOLLOW
;
816 fd
= open(dest
, O_RDONLY
817 #if defined O_LARGEFILE
826 return SafeChdirFailSymlink
; /* This is why we use O_NOFOLLOW */
828 return SafeChdirFailNonexistent
;
830 return SafeChdirFailDestUnreadable
;
842 int saved_errno
= errno
;
849 return SafeChdirFailNotDir
;
852 case EBADF
: /* Shouldn't happen */
856 return SafeChdirFailChdirFailed
;
862 static enum SafeChdirStatus
863 safely_chdir(const char *dest
,
864 enum TraversalDirection direction
,
865 struct stat
*statbuf_dest
,
866 enum ChdirSymlinkHandling symlink_follow_option
,
869 enum SafeChdirStatus result
;
871 /* We're about to leave a directory. If there are any -execdir
872 * argument lists which have been built but have not yet been
873 * processed, do them now because they must be done in the same
876 complete_pending_execdirs(get_current_dirfd());
878 #if !defined(O_NOFOLLOW)
879 options
.open_nofollow_available
= false;
881 if (options
.open_nofollow_available
)
882 result
= safely_chdir_nofollow(dest
, direction
, statbuf_dest
, symlink_follow_option
, did_stat
);
884 result
= safely_chdir_lstat(dest
, direction
, statbuf_dest
, symlink_follow_option
, did_stat
);
890 /* Safely go back to the starting directory. */
894 struct stat stat_buf
;
897 if (starting_desc
< 0)
899 if (options
.debug_options
& DebugSearch
)
900 fprintf(stderr
, "chdir_back(): chdir(\"%s\")\n", starting_dir
);
902 #ifdef STAT_MOUNTPOINTS
903 /* We will need the mounted device list. Get it now if we don't
906 if (NULL
== mounted_devices
)
907 init_mounted_dev_list(1);
910 if (chdir (starting_dir
) != 0)
911 fatal_file_error(starting_dir
);
913 wd_sanity_check(starting_dir
,
916 starting_stat_buf
.st_dev
,
917 starting_stat_buf
.st_ino
,
918 &stat_buf
, 0, __LINE__
,
920 FATAL_IF_SANITY_CHECK_FAILS
,
925 if (options
.debug_options
& DebugSearch
)
926 fprintf(stderr
, "chdir_back(): chdir(<starting-point>)\n");
928 if (fchdir (starting_desc
) != 0)
930 fatal_file_error(starting_dir
);
935 /* Move to the parent of a given directory and then call a function,
936 * restoring the cwd. Don't bother changing directory if the
937 * specified directory is a child of "." or is the root directory.
940 at_top (char *pathname
,
943 void (*action
)(char *pathname
,
949 char *parent_dir
= dir_name (pathname
);
950 char *base
= last_component (pathname
);
953 state
.starting_path_length
= strlen (pathname
);
956 || 0 == strcmp(parent_dir
, "."))
963 enum TraversalDirection direction
;
964 enum SafeChdirStatus chdir_status
;
966 boolean did_stat
= false;
969 if (0 == strcmp(base
, ".."))
970 direction
= TraversingUp
;
972 direction
= TraversingDown
;
974 /* We pass SymlinkFollowOk to safely_chdir(), which allows it to
975 * chdir() into a symbolic link. This is only useful for the
976 * case where the directory we're chdir()ing into is the
977 * basename of a command line argument, for example where
978 * "foo/bar/baz" is specified on the command line. When -P is
979 * in effect (the default), baz will not be followed if it is a
980 * symlink, but if bar is a symlink, it _should_ be followed.
981 * Hence we need the ability to override the policy set by
984 chdir_status
= safely_chdir(parent_dir
, direction
, &st
, SymlinkFollowOk
, &did_stat
);
985 if (SafeChdirOK
!= chdir_status
)
987 const char *what
= (SafeChdirFailWouldBeUnableToReturn
== chdir_status
) ? "." : parent_dir
;
989 error (0, errno
, "%s",
990 safely_quote_err_filename(0, what
));
992 error (0, 0, _("Failed to safely change directory into %s"),
993 safely_quote_err_filename(0, parent_dir
));
995 /* We can't process this command-line argument. */
996 state
.exit_status
= 1;
1004 action(pathname
, base
, mode
, pstat
);
1013 static void do_process_top_dir(char *pathname
,
1020 process_path (pathname
, base
, false, ".", mode
);
1021 complete_pending_execdirs(get_current_dirfd());
1024 static void do_process_predicate(char *pathname
,
1031 state
.rel_pathname
= base
; /* cwd_dir_fd was already set by safely_chdir */
1032 apply_predicate (pathname
, pstat
, get_eval_tree());
1038 /* Descend PATHNAME, which is a command-line argument.
1040 Actions like -execdir assume that we are in the
1041 parent directory of the file we're examining,
1042 and on entry to this function our working directory
1043 is whatever it was when find was invoked. Therefore
1044 If PATHNAME is "." we just leave things as they are.
1045 Otherwise, we figure out what the parent directory is,
1049 process_top_path (char *pathname
, mode_t mode
)
1051 at_top(pathname
, mode
, NULL
, do_process_top_dir
);
1055 /* Info on each directory in the current tree branch, to avoid
1056 getting stuck in symbolic link loops. */
1057 static struct dir_id
*dir_ids
= NULL
;
1058 /* Entries allocated in `dir_ids'. */
1059 static int dir_alloc
= 0;
1060 /* Index in `dir_ids' of directory currently being searched.
1061 This is always the last valid entry. */
1062 static int dir_curr
= -1;
1063 /* (Arbitrary) number of entries to grow `dir_ids' by. */
1064 #define DIR_ALLOC_STEP 32
1068 /* We've detected a file system loop. This is caused by one of
1071 * 1. Option -L is in effect and we've hit a symbolic link that
1072 * points to an ancestor. This is harmless. We won't traverse the
1075 * 2. We have hit a real cycle in the directory hierarchy. In this
1076 * case, we issue a diagnostic message (POSIX requires this) and we
1077 * skip that directory entry.
1080 issue_loop_warning(const char *name
, const char *pathname
, int level
)
1082 struct stat stbuf_link
;
1083 if (lstat(name
, &stbuf_link
) != 0)
1084 stbuf_link
.st_mode
= S_IFREG
;
1086 if (S_ISLNK(stbuf_link
.st_mode
))
1089 _("Symbolic link %s is part of a loop in the directory hierarchy; we have already visited the directory to which it points."),
1090 safely_quote_err_filename(0, pathname
));
1091 /* XXX: POSIX appears to require that the exit status be non-zero if a
1092 * diagnostic is issued.
1097 int distance
= 1 + (dir_curr
-level
);
1098 /* We have found an infinite loop. POSIX requires us to
1099 * issue a diagnostic. Usually we won't get to here
1100 * because when the leaf optimisation is on, it will cause
1101 * the subdirectory to be skipped. If /a/b/c/d is a hard
1102 * link to /a/b, then the link count of /a/b/c is 2,
1103 * because the ".." entry of /b/b/c/d points to /a, not
1107 _("Filesystem loop detected; %s has the same device number and inode as a directory which is %d %s."),
1108 safely_quote_err_filename(0, pathname
),
1111 _("level higher in the file system hierarchy") :
1112 _("levels higher in the file system hierarchy")));
1118 /* Recursively descend path PATHNAME, applying the predicates.
1119 LEAF is true if PATHNAME is known to be in a directory that has no
1120 more unexamined subdirectories, and therefore it is not a directory.
1121 Knowing this allows us to avoid calling stat as long as possible for
1124 NAME is PATHNAME relative to the current directory. We access NAME
1127 PARENT is the path of the parent of NAME, relative to find's
1130 Return nonzero iff PATHNAME is a directory. */
1133 process_path (char *pathname
, char *name
, boolean leaf
, char *parent
,
1136 struct stat stat_buf
;
1137 static dev_t root_dev
; /* Device ID of current argument pathname. */
1139 struct predicate
*eval_tree
;
1141 eval_tree
= get_eval_tree();
1142 /* Assume it is a non-directory initially. */
1143 stat_buf
.st_mode
= 0;
1144 state
.rel_pathname
= name
;
1146 state
.have_stat
= false;
1147 state
.have_type
= false;
1149 if (!digest_mode(mode
, pathname
, name
, &stat_buf
, leaf
))
1152 if (!S_ISDIR (state
.type
))
1154 if (state
.curdepth
>= options
.mindepth
)
1155 apply_predicate (pathname
, &stat_buf
, eval_tree
);
1159 /* From here on, we're working on a directory. */
1162 /* Now we really need to stat the directory, even if we know the
1163 * type, because we need information like struct stat.st_rdev.
1165 if (get_statinfo(pathname
, name
, &stat_buf
) != 0)
1168 state
.have_stat
= true;
1169 mode
= state
.type
= stat_buf
.st_mode
; /* use full info now that we have it. */
1170 state
.stop_at_current_level
=
1171 options
.maxdepth
>= 0
1172 && state
.curdepth
>= options
.maxdepth
;
1174 /* If we've already seen this directory on this branch,
1175 don't descend it again. */
1176 for (i
= 0; i
<= dir_curr
; i
++)
1177 if (stat_buf
.st_ino
== dir_ids
[i
].ino
&&
1178 stat_buf
.st_dev
== dir_ids
[i
].dev
)
1180 state
.stop_at_current_level
= true;
1181 issue_loop_warning(name
, pathname
, i
);
1184 if (dir_alloc
<= ++dir_curr
)
1186 dir_alloc
+= DIR_ALLOC_STEP
;
1187 dir_ids
= (struct dir_id
*)
1188 xrealloc ((char *) dir_ids
, dir_alloc
* sizeof (struct dir_id
));
1190 dir_ids
[dir_curr
].ino
= stat_buf
.st_ino
;
1191 dir_ids
[dir_curr
].dev
= stat_buf
.st_dev
;
1193 if (options
.stay_on_filesystem
)
1195 if (state
.curdepth
== 0)
1196 root_dev
= stat_buf
.st_dev
;
1197 else if (stat_buf
.st_dev
!= root_dev
)
1198 state
.stop_at_current_level
= true;
1201 if (options
.do_dir_first
&& state
.curdepth
>= options
.mindepth
)
1202 apply_predicate (pathname
, &stat_buf
, eval_tree
);
1204 if (options
.debug_options
& DebugSearch
)
1205 fprintf(stderr
, "pathname = %s, stop_at_current_level = %d\n",
1206 pathname
, state
.stop_at_current_level
);
1208 if (state
.stop_at_current_level
== false)
1210 /* Scan directory on disk. */
1211 process_dir (pathname
, name
, strlen (pathname
), &stat_buf
, parent
);
1214 if (options
.do_dir_first
== false && state
.curdepth
>= options
.mindepth
)
1216 /* The fields in 'state' are now out of date. Correct them.
1218 if (!digest_mode(mode
, pathname
, name
, &stat_buf
, leaf
))
1223 at_top(pathname
, mode
, &stat_buf
, do_process_predicate
);
1227 do_process_predicate(pathname
, name
, mode
, &stat_buf
);
1237 /* Scan directory PATHNAME and recurse through process_path for each entry.
1239 PATHLEN is the length of PATHNAME.
1241 NAME is PATHNAME relative to the current directory.
1243 STATP is the results of *options.xstat on it.
1245 PARENT is the path of the parent of NAME, relative to find's
1246 starting directory. */
1249 process_dir (char *pathname
, char *name
, int pathlen
, const struct stat
*statp
, char *parent
)
1251 int subdirs_left
; /* Number of unexamined subdirs in PATHNAME. */
1252 boolean subdirs_unreliable
; /* if true, cannot use dir link count as subdir limif (if false, it may STILL be unreliable) */
1253 unsigned int idx
; /* Which entry are we on? */
1254 struct stat stat_buf
;
1255 size_t dircount
= 0u;
1256 struct savedir_dirinfo
*dirinfo
;
1258 printf("process_dir: pathname=%s name=%s statp->st_nlink=%d st_ino=%d\n",
1261 (int)statp
->st_nlink
,
1262 (int)statp
->st_ino
);
1264 if (statp
->st_nlink
< 2)
1266 subdirs_unreliable
= true;
1271 subdirs_unreliable
= false; /* not necessarily right */
1272 subdirs_left
= statp
->st_nlink
- 2; /* Account for name and ".". */
1276 dirinfo
= xsavedir(name
, 0);
1279 if (dirinfo
== NULL
)
1281 assert (errno
!= 0);
1282 error (0, errno
, "%s", safely_quote_err_filename(0, pathname
));
1283 state
.exit_status
= 1;
1287 register char *namep
; /* Current point in `name_space'. */
1288 char *cur_path
; /* Full path of each file to process. */
1289 char *cur_name
; /* Base name of each file to process. */
1290 unsigned cur_path_size
; /* Bytes allocated for `cur_path'. */
1291 register unsigned file_len
; /* Length of each path to process. */
1292 register unsigned pathname_len
; /* PATHLEN plus trailing '/'. */
1293 boolean did_stat
= false;
1295 if (pathname
[pathlen
- 1] == '/')
1296 pathname_len
= pathlen
+ 1; /* For '\0'; already have '/'. */
1298 pathname_len
= pathlen
+ 2; /* For '/' and '\0'. */
1302 /* We're about to leave the directory. If there are any
1303 * -execdir argument lists which have been built but have not
1304 * yet been processed, do them now because they must be done in
1305 * the same directory.
1307 complete_pending_execdirs(get_current_dirfd());
1309 if (strcmp (name
, "."))
1311 enum SafeChdirStatus status
= safely_chdir (name
, TraversingDown
, &stat_buf
, SymlinkHandleDefault
, &did_stat
);
1315 /* If there had been a change but wd_sanity_check()
1316 * accepted it, we need to accept that on the
1317 * way back up as well, so modify our record
1318 * of what we think we should see later.
1319 * If there was no change, the assignments are a no-op.
1321 * However, before performing the assignment, we need to
1322 * check that we have the stat information. If O_NOFOLLOW
1323 * is available, safely_chdir() will not have needed to use
1324 * stat(), and so stat_buf will just contain random data.
1328 /* If there is a link we need to follow it. Hence
1329 * the direct call to stat() not through (options.xstat)
1331 set_stat_placeholders(&stat_buf
);
1332 if (0 != stat(".", &stat_buf
))
1333 break; /* skip the assignment. */
1335 dir_ids
[dir_curr
].dev
= stat_buf
.st_dev
;
1336 dir_ids
[dir_curr
].ino
= stat_buf
.st_ino
;
1340 case SafeChdirFailWouldBeUnableToReturn
:
1341 error (0, errno
, ".");
1342 state
.exit_status
= 1;
1345 case SafeChdirFailNonexistent
:
1346 case SafeChdirFailDestUnreadable
:
1347 case SafeChdirFailStat
:
1348 case SafeChdirFailNotDir
:
1349 case SafeChdirFailChdirFailed
:
1350 error (0, errno
, "%s",
1351 safely_quote_err_filename(0, pathname
));
1352 state
.exit_status
= 1;
1355 case SafeChdirFailSymlink
:
1357 _("warning: not following the symbolic link %s"),
1358 safely_quote_err_filename(0, pathname
));
1359 state
.exit_status
= 1;
1364 for (idx
=0; idx
< dirinfo
->size
; ++idx
)
1366 /* savedirinfo() may return dirinfo=NULL if extended information
1369 mode_t mode
= (dirinfo
->entries
[idx
].flags
& SavedirHaveFileType
) ?
1370 dirinfo
->entries
[idx
].type_info
: 0;
1371 namep
= dirinfo
->entries
[idx
].name
;
1373 /* Append this directory entry's name to the path being searched. */
1374 file_len
= pathname_len
+ strlen (namep
);
1375 if (file_len
> cur_path_size
)
1377 while (file_len
> cur_path_size
)
1378 cur_path_size
+= 1024;
1381 cur_path
= xmalloc (cur_path_size
);
1382 strcpy (cur_path
, pathname
);
1383 cur_path
[pathname_len
- 2] = '/';
1385 cur_name
= cur_path
+ pathname_len
- 1;
1386 strcpy (cur_name
, namep
);
1389 if (!options
.no_leaf_check
&& !subdirs_unreliable
)
1391 if (mode
&& S_ISDIR(mode
) && (subdirs_left
== 0))
1393 /* This is a subdirectory, but the number of directories we
1394 * have found now exceeds the number we would expect given
1395 * the hard link count on the parent. This is likely to be
1396 * a bug in the file system driver (e.g. Linux's
1397 * /proc file system) or may just be a fact that the OS
1398 * doesn't really handle hard links with Unix semantics.
1399 * In the latter case, -noleaf should be used routinely.
1401 error(0, 0, _("WARNING: Hard link count is wrong for %s (saw only st_nlink=%d but we already saw %d subdirectories): this may be a bug in your file system driver. Automatically turning on find's -noleaf option. Earlier results may have failed to include directories that should have been searched."),
1402 safely_quote_err_filename(0, pathname
),
1405 state
.exit_status
= 1; /* We know the result is wrong, now */
1406 options
.no_leaf_check
= true; /* Don't make same
1408 subdirs_unreliable
= 1;
1409 subdirs_left
= 1; /* band-aid for this iteration. */
1412 /* Normal case optimization. On normal Unix
1413 file systems, a directory that has no subdirectories
1414 has two links: its name, and ".". Any additional
1415 links are to the ".." entries of its subdirectories.
1416 Once we have processed as many subdirectories as
1417 there are additional links, we know that the rest of
1418 the entries are non-directories -- in other words,
1422 count
= process_path (cur_path
, cur_name
,
1423 subdirs_left
== 0, pathname
,
1425 subdirs_left
-= count
;
1431 /* There might be weird (e.g., CD-ROM or MS-DOS) file systems
1432 mounted, which don't have Unix-like directory link counts. */
1433 process_path (cur_path
, cur_name
, false, pathname
, mode
);
1440 /* We're about to leave the directory. If there are any
1441 * -execdir argument lists which have been built but have not
1442 * yet been processed, do them now because they must be done in
1443 * the same directory.
1445 complete_pending_execdirs(get_current_dirfd());
1447 if (strcmp (name
, "."))
1449 enum SafeChdirStatus status
;
1452 /* We could go back and do the next command-line arg
1453 instead, maybe using longjmp. */
1455 boolean deref
= following_links() ? true : false;
1457 if ( (state
.curdepth
>0) && !deref
)
1466 status
= safely_chdir (dir
, TraversingUp
, &stat_buf
, SymlinkHandleDefault
, &did_stat
);
1472 case SafeChdirFailWouldBeUnableToReturn
:
1473 error (1, errno
, ".");
1476 case SafeChdirFailNonexistent
:
1477 case SafeChdirFailDestUnreadable
:
1478 case SafeChdirFailStat
:
1479 case SafeChdirFailSymlink
:
1480 case SafeChdirFailNotDir
:
1481 case SafeChdirFailChdirFailed
:
1482 error (1, errno
, "%s", safely_quote_err_filename(0, pathname
));
1488 did
.dev
= dir_ids
[dir_curr
-1].dev
;
1489 did
.ino
= dir_ids
[dir_curr
-1].ino
;
1493 did
.dev
= starting_stat_buf
.st_dev
;
1494 did
.ino
= starting_stat_buf
.st_ino
;
1500 free_dirinfo(dirinfo
);
1503 if (subdirs_unreliable
)
1505 /* Make sure we hasn't used the variable subdirs_left if we knew
1506 * we shouldn't do so.
1508 assert (0 == subdirs_left
|| options
.no_leaf_check
);