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)
67 #define ngettext(singular,plural,n) ((1==n) ? singular : plural)
70 # define N_(String) gettext_noop (String)
72 /* See locate.c for explanation as to why not use (String) */
73 # define N_(String) String
76 #ifdef STAT_MOUNTPOINTS
77 static void init_mounted_dev_list(int mandatory
);
80 static void process_top_path
PARAMS((char *pathname
, mode_t mode
));
81 static int process_path
PARAMS((char *pathname
, char *name
, boolean leaf
, char *parent
, mode_t type
));
82 static void process_dir
PARAMS((char *pathname
, char *name
, int pathlen
, const struct stat
*statp
, char *parent
));
86 /* Name this program was run with. */
89 /* A file descriptor open to the initial working directory.
90 Doing it this way allows us to work when the i.w.d. has
91 unreadable parents. */
94 /* The stat buffer of the initial working directory. */
95 static struct stat starting_stat_buf
;
97 enum ChdirSymlinkHandling
99 SymlinkHandleDefault
, /* Normally the right choice */
100 SymlinkFollowOk
/* see comment in process_top_path() */
104 enum TraversalDirection
110 enum WdSanityCheckFatality
112 FATAL_IF_SANITY_CHECK_FAILS
,
113 RETRY_IF_SANITY_CHECK_FAILS
,
114 NON_FATAL_IF_SANITY_CHECK_FAILS
118 int get_current_dirfd(void)
125 main (int argc
, char **argv
)
128 int end_of_leading_options
= 0; /* First arg after any -H/-L etc. */
129 struct predicate
*eval_tree
;
131 program_name
= argv
[0];
132 state
.exit_status
= 0;
134 /* Set the option defaults before we do the locale
135 * initialisation as check_nofollow() needs to be executed in the
138 set_option_defaults(&options
);
140 #ifdef HAVE_SETLOCALE
141 setlocale (LC_ALL
, "");
143 bindtextdomain (PACKAGE
, LOCALEDIR
);
144 textdomain (PACKAGE
);
145 atexit (close_stdin
);
147 /* Check for -P, -H or -L options. */
148 end_of_leading_options
= process_leading_options(argc
, argv
);
150 if (options
.debug_options
& DebugStat
)
151 options
.xstat
= debug_stat
;
154 fprintf (stderr
, "cur_day_start = %s", ctime (&options
.cur_day_start
));
157 /* state.cwd_dir_fd has to be initialised before we call build_expression_tree()
158 * because command-line parsing may lead us to stat some files.
160 state
.cwd_dir_fd
= AT_FDCWD
;
162 /* We are now processing the part of the "find" command line
163 * after the -H/-L options (if any).
165 eval_tree
= build_expression_tree(argc
, argv
, end_of_leading_options
);
168 /* safely_chdir() needs to check that it has ended up in the right place.
169 * To avoid bailing out when something gets automounted, it checks if
170 * the target directory appears to have had a directory mounted on it as
171 * we chdir()ed. The problem with this is that in order to notice that
172 * a file system was mounted, we would need to lstat() all the mount points.
173 * That strategy loses if our machine is a client of a dead NFS server.
175 * Hence if safely_chdir() and wd_sanity_check() can manage without needing
176 * to know the mounted device list, we do that.
178 if (!options
.open_nofollow_available
)
180 #ifdef STAT_MOUNTPOINTS
181 init_mounted_dev_list(0);
186 starting_desc
= open (".", O_RDONLY
187 #if defined O_LARGEFILE
191 if (0 <= starting_desc
&& fchdir (starting_desc
) != 0)
193 close (starting_desc
);
197 if (starting_desc
< 0)
199 starting_dir
= xgetcwd ();
201 error (1, errno
, _("cannot get current directory"));
203 set_stat_placeholders(&starting_stat_buf
);
204 if ((*options
.xstat
) (".", &starting_stat_buf
) != 0)
205 error (1, errno
, _("cannot stat current directory"));
207 /* If no paths are given, default to ".". */
208 for (i
= end_of_leading_options
; i
< argc
&& !looks_like_expression(argv
[i
], true); i
++)
210 process_top_path (argv
[i
], 0);
213 /* If there were no path arguments, default to ".". */
214 if (i
== end_of_leading_options
)
217 * We use a temporary variable here because some actions modify
218 * the path temporarily. Hence if we use a string constant,
219 * we get a coredump. The best example of this is if we say
220 * "find -printf %H" (note, not "find . -printf %H").
222 char defaultpath
[2] = ".";
223 process_top_path (defaultpath
, 0);
226 /* If "-exec ... {} +" has been used, there may be some
227 * partially-full command lines which have been built,
228 * but which are not yet complete. Execute those now.
230 show_success_rates(eval_tree
);
232 return state
.exit_status
;
235 boolean
is_fts_enabled(int *ftsoptions
)
237 /* this version of find (i.e. this main()) does not use fts. */
244 specific_dirname(const char *dir
)
248 if (0 == strcmp(".", dir
))
250 /* OK, what's '.'? */
251 if (NULL
!= getcwd(dirbuf
, sizeof(dirbuf
)))
253 return strdup(dirbuf
);
262 char *result
= canonicalize_filename_mode(dir
, CAN_EXISTING
);
272 /* Return non-zero if FS is the name of a file system that is likely to
276 fs_likely_to_be_automounted(const char *fs
)
278 return ( (0==strcmp(fs
, "nfs")) || (0==strcmp(fs
, "autofs")) || (0==strcmp(fs
, "subfs")));
283 #ifdef STAT_MOUNTPOINTS
284 static dev_t
*mounted_devices
= NULL
;
285 static size_t num_mounted_devices
= 0u;
289 init_mounted_dev_list(int mandatory
)
291 assert (NULL
== mounted_devices
);
292 assert (0 == num_mounted_devices
);
293 mounted_devices
= get_mounted_devices(&num_mounted_devices
);
294 if (mandatory
&& (NULL
== mounted_devices
))
296 error(1, 0, "Cannot read list of mounted devices.");
301 refresh_mounted_dev_list(void)
305 free(mounted_devices
);
308 num_mounted_devices
= 0u;
309 init_mounted_dev_list(1);
313 /* Search for device DEV in the array LIST, which is of size N. */
315 dev_present(dev_t dev
, const dev_t
*list
, size_t n
)
321 if ( (*list
++) == dev
)
328 enum MountPointStateChange
330 MountPointRecentlyMounted
,
331 MountPointRecentlyUnmounted
,
332 MountPointStateUnchanged
337 static enum MountPointStateChange
338 get_mount_state(dev_t newdev
)
340 int new_is_present
, new_was_present
;
342 new_was_present
= dev_present(newdev
, mounted_devices
, num_mounted_devices
);
343 refresh_mounted_dev_list();
344 new_is_present
= dev_present(newdev
, mounted_devices
, num_mounted_devices
);
346 if (new_was_present
== new_is_present
)
347 return MountPointStateUnchanged
;
348 else if (new_is_present
)
349 return MountPointRecentlyMounted
;
351 return MountPointRecentlyUnmounted
;
356 /* We stat()ed a directory, chdir()ed into it (we know this
357 * since direction is TraversingDown), stat()ed it again,
358 * and noticed that the device numbers are different. Check
359 * if the file system was recently mounted.
361 * If it was, it looks like chdir()ing into the directory
362 * caused a file system to be mounted. Maybe automount is
363 * running. Anyway, that's probably OK - but it happens
364 * only when we are moving downward.
366 * We also allow for the possibility that a similar thing
367 * has happened with the unmounting of a file system. This
368 * is much rarer, as it relies on an automounter timeout
369 * occurring at exactly the wrong moment.
371 static enum WdSanityCheckFatality
372 dirchange_is_fatal(const char *specific_what
,
373 enum WdSanityCheckFatality isfatal
,
375 struct stat
*newinfo
)
377 enum MountPointStateChange transition
= get_mount_state(newinfo
->st_dev
);
380 case MountPointRecentlyUnmounted
:
381 isfatal
= NON_FATAL_IF_SANITY_CHECK_FAILS
;
385 _("Warning: file system %s has recently been unmounted."),
386 safely_quote_err_filename(0, specific_what
));
390 case MountPointRecentlyMounted
:
391 isfatal
= NON_FATAL_IF_SANITY_CHECK_FAILS
;
395 _("Warning: file system %s has recently been mounted."),
396 safely_quote_err_filename(0, specific_what
));
400 case MountPointStateUnchanged
:
401 /* leave isfatal as it is */
413 /* Examine the results of the stat() of a directory from before we
414 * entered or left it, with the results of stat()ing it afterward. If
415 * these are different, the file system tree has been modified while we
416 * were traversing it. That might be an attempt to use a race
417 * condition to persuade find to do something it didn't intend
418 * (e.g. an attempt by an ordinary user to exploit the fact that root
419 * sometimes runs find on the whole file system). However, this can
420 * also happen if automount is running (certainly on Solaris). With
421 * automount, moving into a directory can cause a file system to be
424 * To cope sensibly with this, we will raise an error if we see the
425 * device number change unless we are chdir()ing into a subdirectory,
426 * and the directory we moved into has been mounted or unmounted "recently".
427 * Here "recently" means since we started "find" or we last re-read
428 * the /etc/mnttab file.
430 * If the device number does not change but the inode does, that is a
433 * If the device number and inode are both the same, we are happy.
435 * If a file system is (un)mounted as we chdir() into the directory, that
436 * may mean that we're now examining a section of the file system that might
437 * have been excluded from consideration (via -prune or -quit for example).
438 * Hence we print a warning message to indicate that the output of find
439 * might be inconsistent due to the change in the file system.
442 wd_sanity_check(const char *thing_to_stat
,
443 const char *progname
,
447 struct stat
*newinfo
,
450 enum TraversalDirection direction
,
451 enum WdSanityCheckFatality isfatal
,
452 boolean
*changed
) /* output parameter */
455 char *specific_what
= NULL
;
457 const char *current_dir
= ".";
461 set_stat_placeholders(newinfo
);
462 if ((*options
.xstat
) (current_dir
, newinfo
) != 0)
463 fatal_file_error(thing_to_stat
);
465 if (old_dev
!= newinfo
->st_dev
)
468 specific_what
= specific_dirname(what
);
469 fstype
= filesystem_type(newinfo
, current_dir
);
470 silent
= fs_likely_to_be_automounted(fstype
);
472 /* This condition is rare, so once we are here it is
473 * reasonable to perform an expensive computation to
474 * determine if we should continue or fail.
476 if (TraversingDown
== direction
)
478 #ifdef STAT_MOUNTPOINTS
479 isfatal
= dirchange_is_fatal(specific_what
,isfatal
,silent
,newinfo
);
481 isfatal
= RETRY_IF_SANITY_CHECK_FAILS
;
487 case FATAL_IF_SANITY_CHECK_FAILS
:
489 fstype
= filesystem_type(newinfo
, current_dir
);
491 _("%s%s changed during execution of %s (old device number %ld, new device number %ld, file system type is %s) [ref %ld]"),
492 safely_quote_err_filename(0, specific_what
),
494 safely_quote_err_filename(1, progname
),
496 (long) newinfo
->st_dev
,
503 case NON_FATAL_IF_SANITY_CHECK_FAILS
:
505 /* Since the device has changed under us, the inode number
506 * will almost certainly also be different. However, we have
507 * already decided that this is not a problem. Hence we return
508 * without checking the inode number.
514 case RETRY_IF_SANITY_CHECK_FAILS
:
519 /* Device number was the same, check if the inode has changed. */
520 if (old_ino
!= newinfo
->st_ino
)
523 specific_what
= specific_dirname(what
);
524 fstype
= filesystem_type(newinfo
, current_dir
);
526 error ((isfatal
== FATAL_IF_SANITY_CHECK_FAILS
) ? 1 : 0,
527 0, /* no relevant errno value */
528 _("%s%s changed during execution of %s "
529 "(old inode number %ld, new inode number %ld, file system type is %s) [ref %ld]"),
530 safely_quote_err_filename(0, specific_what
),
532 safely_quote_err_filename(1, progname
),
534 (long) newinfo
->st_ino
,
547 SafeChdirFailSymlink
,
550 SafeChdirFailWouldBeUnableToReturn
,
551 SafeChdirFailChdirFailed
,
552 SafeChdirFailNonexistent
,
553 SafeChdirFailDestUnreadable
556 /* Safely perform a change in directory. We do this by calling
557 * lstat() on the subdirectory, using chdir() to move into it, and
558 * then lstat()ing ".". We compare the results of the two stat calls
559 * to see if they are consistent. If not, we sound the alarm.
561 * If following_links() is true, we do follow symbolic links.
563 static enum SafeChdirStatus
564 safely_chdir_lstat(const char *dest
,
565 enum TraversalDirection direction
,
566 struct stat
*statbuf_dest
,
567 enum ChdirSymlinkHandling symlink_follow_option
,
570 struct stat statbuf_arrived
;
572 int saved_errno
; /* specific_dirname() changes errno. */
573 boolean rv_set
= false;
574 boolean statflag
= false;
576 enum WdSanityCheckFatality isfatal
= RETRY_IF_SANITY_CHECK_FAILS
;
578 saved_errno
= errno
= 0;
580 dotfd
= open(".", O_RDONLY
581 #if defined O_LARGEFILE
586 /* We jump back to here if wd_sanity_check()
587 * recoverably triggers an alert.
594 /* Stat the directory we're going to. */
595 set_stat_placeholders(statbuf_dest
);
596 if (0 == options
.xstat(dest
, statbuf_dest
))
601 /* symlink_follow_option might be set to SymlinkFollowOk, which
602 * would allow us to chdir() into a symbolic link. This is
603 * only useful for the case where the directory we're
604 * chdir()ing into is the basename of a command line
605 * argument, for example where "foo/bar/baz" is specified on
606 * the command line. When -P is in effect (the default),
607 * baz will not be followed if it is a symlink, but if bar
608 * is a symlink, it _should_ be followed. Hence we need the
609 * ability to override the policy set by following_links().
611 if (!following_links() && S_ISLNK(statbuf_dest
->st_mode
))
613 /* We're not supposed to be following links, but this is
614 * a link. Check symlink_follow_option to see if we should
615 * make a special exception.
617 if (symlink_follow_option
== SymlinkFollowOk
)
619 /* We need to re-stat() the file so that the
620 * sanity check can pass.
622 if (0 != stat(dest
, statbuf_dest
))
624 rv
= SafeChdirFailNonexistent
;
633 /* Not following symlinks, so the attempt to
634 * chdir() into a symlink should be prevented.
636 rv
= SafeChdirFailSymlink
;
638 saved_errno
= 0; /* silence the error message */
644 /* Although the immediately following chdir() would detect
645 * the fact that this is not a directory for us, this would
646 * result in an extra system call that fails. Anybody
647 * examining the system-call trace should ideally not be
648 * concerned that something is actually failing.
650 if (!S_ISDIR(statbuf_dest
->st_mode
))
652 rv
= SafeChdirFailNotDir
;
654 saved_errno
= 0; /* silence the error message */
659 if (options
.debug_options
& DebugSearch
)
660 fprintf(stderr
, "safely_chdir(): chdir(\"%s\")\n", dest
);
662 if (0 == chdir(dest
))
664 /* check we ended up where we wanted to go */
665 boolean changed
= false;
666 if (!wd_sanity_check(".", program_name
, ".",
667 statbuf_dest
->st_dev
,
668 statbuf_dest
->st_ino
,
670 0, __LINE__
, direction
,
674 /* Only allow one failure. */
675 if (RETRY_IF_SANITY_CHECK_FAILS
== isfatal
)
677 if (0 == fchdir(dotfd
))
679 isfatal
= FATAL_IF_SANITY_CHECK_FAILS
;
684 /* Failed to return to original directory,
685 * but we know that the current working
686 * directory is not the one that we intend
687 * to be in. Since fchdir() failed, we
688 * can't recover from this and so this error
692 "failed to return to parent directory");
697 /* XXX: not sure what to use as an excuse here. */
698 rv
= SafeChdirFailNonexistent
;
711 if (ENOENT
== saved_errno
)
713 rv
= SafeChdirFailNonexistent
;
715 if (options
.ignore_readdir_race
)
716 errno
= 0; /* don't issue err msg */
718 else if (ENOTDIR
== saved_errno
)
720 /* This can happen if the we stat a directory,
721 * and then file system activity changes it into
724 saved_errno
= 0; /* don't issue err msg */
725 rv
= SafeChdirFailNotDir
;
730 rv
= SafeChdirFailChdirFailed
;
739 rv
= SafeChdirFailStat
;
742 if ( (ENOENT
== saved_errno
) || (0 == state
.curdepth
))
743 saved_errno
= 0; /* don't issue err msg */
749 /* We do not have read permissions on "." */
750 rv
= SafeChdirFailWouldBeUnableToReturn
;
755 /* This is the success path, so we clear errno. The caller probably
756 * won't be calling error() anyway.
760 /* We use the same exit path for success or failure.
761 * which has occurred is recorded in RV.
764 /* We do not call error() as this would result in a duplicate error
765 * message when the caller does the same thing.
776 *did_stat
= statflag
;
781 #if defined O_NOFOLLOW
782 /* Safely change working directory to the specified subdirectory. If
783 * we are not allowed to follow symbolic links, we use open() with
784 * O_NOFOLLOW, followed by fchdir(). This ensures that we don't
785 * follow symbolic links (of course, we do follow them if the -L
786 * option is in effect).
788 static enum SafeChdirStatus
789 safely_chdir_nofollow(const char *dest
,
790 enum TraversalDirection direction
,
791 struct stat
*statbuf_dest
,
792 enum ChdirSymlinkHandling symlink_follow_option
,
803 switch (symlink_follow_option
)
805 case SymlinkFollowOk
:
809 case SymlinkHandleDefault
:
810 if (following_links())
813 extraflags
= O_NOFOLLOW
;
818 fd
= open(dest
, O_RDONLY
819 #if defined O_LARGEFILE
828 return SafeChdirFailSymlink
; /* This is why we use O_NOFOLLOW */
830 return SafeChdirFailNonexistent
;
832 return SafeChdirFailDestUnreadable
;
844 int saved_errno
= errno
;
851 return SafeChdirFailNotDir
;
854 case EBADF
: /* Shouldn't happen */
858 return SafeChdirFailChdirFailed
;
864 static enum SafeChdirStatus
865 safely_chdir(const char *dest
,
866 enum TraversalDirection direction
,
867 struct stat
*statbuf_dest
,
868 enum ChdirSymlinkHandling symlink_follow_option
,
871 enum SafeChdirStatus result
;
873 /* We're about to leave a directory. If there are any -execdir
874 * argument lists which have been built but have not yet been
875 * processed, do them now because they must be done in the same
878 complete_pending_execdirs(get_current_dirfd());
880 #if !defined(O_NOFOLLOW)
881 options
.open_nofollow_available
= false;
883 if (options
.open_nofollow_available
)
885 result
= safely_chdir_nofollow(dest
, direction
, statbuf_dest
,
886 symlink_follow_option
, did_stat
);
887 if (SafeChdirFailDestUnreadable
!= result
)
893 /* Savannah bug #15384: fall through to use safely_chdir_lstat
894 * if the directory is not readable.
899 /* Even if O_NOFOLLOW is available, we may need to use the alternative
900 * method, since parent of the start point may be executable but not
903 return safely_chdir_lstat(dest
, direction
, statbuf_dest
,
904 symlink_follow_option
, did_stat
);
909 /* Safely go back to the starting directory. */
913 struct stat stat_buf
;
916 if (starting_desc
< 0)
918 if (options
.debug_options
& DebugSearch
)
919 fprintf(stderr
, "chdir_back(): chdir(\"%s\")\n", starting_dir
);
921 #ifdef STAT_MOUNTPOINTS
922 /* We will need the mounted device list. Get it now if we don't
925 if (NULL
== mounted_devices
)
926 init_mounted_dev_list(1);
929 if (chdir (starting_dir
) != 0)
930 fatal_file_error(starting_dir
);
932 wd_sanity_check(starting_dir
,
935 starting_stat_buf
.st_dev
,
936 starting_stat_buf
.st_ino
,
937 &stat_buf
, 0, __LINE__
,
939 FATAL_IF_SANITY_CHECK_FAILS
,
944 if (options
.debug_options
& DebugSearch
)
945 fprintf(stderr
, "chdir_back(): chdir(<starting-point>)\n");
947 if (fchdir (starting_desc
) != 0)
949 fatal_file_error(starting_dir
);
954 /* Move to the parent of a given directory and then call a function,
955 * restoring the cwd. Don't bother changing directory if the
956 * specified directory is a child of "." or is the root directory.
959 at_top (char *pathname
,
962 void (*action
)(char *pathname
,
968 char *parent_dir
= dir_name (pathname
);
969 char *base
= last_component (pathname
);
972 state
.starting_path_length
= strlen (pathname
);
975 || 0 == strcmp(parent_dir
, "."))
982 enum TraversalDirection direction
;
983 enum SafeChdirStatus chdir_status
;
985 boolean did_stat
= false;
988 if (0 == strcmp(base
, ".."))
989 direction
= TraversingUp
;
991 direction
= TraversingDown
;
993 /* We pass SymlinkFollowOk to safely_chdir(), which allows it to
994 * chdir() into a symbolic link. This is only useful for the
995 * case where the directory we're chdir()ing into is the
996 * basename of a command line argument, for example where
997 * "foo/bar/baz" is specified on the command line. When -P is
998 * in effect (the default), baz will not be followed if it is a
999 * symlink, but if bar is a symlink, it _should_ be followed.
1000 * Hence we need the ability to override the policy set by
1001 * following_links().
1003 chdir_status
= safely_chdir(parent_dir
, direction
, &st
, SymlinkFollowOk
, &did_stat
);
1004 if (SafeChdirOK
!= chdir_status
)
1006 const char *what
= (SafeChdirFailWouldBeUnableToReturn
== chdir_status
) ? "." : parent_dir
;
1008 error (0, errno
, "%s",
1009 safely_quote_err_filename(0, what
));
1011 error (0, 0, _("Failed to safely change directory into %s"),
1012 safely_quote_err_filename(0, parent_dir
));
1014 /* We can't process this command-line argument. */
1015 state
.exit_status
= 1;
1023 action(pathname
, base
, mode
, pstat
);
1032 static void do_process_top_dir(char *pathname
,
1039 process_path (pathname
, base
, false, ".", mode
);
1040 complete_pending_execdirs(get_current_dirfd());
1043 static void do_process_predicate(char *pathname
,
1050 state
.rel_pathname
= base
; /* cwd_dir_fd was already set by safely_chdir */
1051 apply_predicate (pathname
, pstat
, get_eval_tree());
1057 /* Descend PATHNAME, which is a command-line argument.
1059 Actions like -execdir assume that we are in the
1060 parent directory of the file we're examining,
1061 and on entry to this function our working directory
1062 is whatever it was when find was invoked. Therefore
1063 If PATHNAME is "." we just leave things as they are.
1064 Otherwise, we figure out what the parent directory is,
1068 process_top_path (char *pathname
, mode_t mode
)
1070 at_top(pathname
, mode
, NULL
, do_process_top_dir
);
1074 /* Info on each directory in the current tree branch, to avoid
1075 getting stuck in symbolic link loops. */
1076 static struct dir_id
*dir_ids
= NULL
;
1077 /* Entries allocated in `dir_ids'. */
1078 static int dir_alloc
= 0;
1079 /* Index in `dir_ids' of directory currently being searched.
1080 This is always the last valid entry. */
1081 static int dir_curr
= -1;
1082 /* (Arbitrary) number of entries to grow `dir_ids' by. */
1083 #define DIR_ALLOC_STEP 32
1087 /* We've detected a file system loop. This is caused by one of
1090 * 1. Option -L is in effect and we've hit a symbolic link that
1091 * points to an ancestor. This is harmless. We won't traverse the
1094 * 2. We have hit a real cycle in the directory hierarchy. In this
1095 * case, we issue a diagnostic message (POSIX requires this) and we
1096 * skip that directory entry.
1099 issue_loop_warning(const char *name
, const char *pathname
, int level
)
1101 struct stat stbuf_link
;
1102 if (lstat(name
, &stbuf_link
) != 0)
1103 stbuf_link
.st_mode
= S_IFREG
;
1105 if (S_ISLNK(stbuf_link
.st_mode
))
1108 _("Symbolic link %s is part of a loop in the directory hierarchy; we have already visited the directory to which it points."),
1109 safely_quote_err_filename(0, pathname
));
1110 /* XXX: POSIX appears to require that the exit status be non-zero if a
1111 * diagnostic is issued.
1116 int distance
= 1 + (dir_curr
-level
);
1117 /* We have found an infinite loop. POSIX requires us to
1118 * issue a diagnostic. Usually we won't get to here
1119 * because when the leaf optimisation is on, it will cause
1120 * the subdirectory to be skipped. If /a/b/c/d is a hard
1121 * link to /a/b, then the link count of /a/b/c is 2,
1122 * because the ".." entry of /b/b/c/d points to /a, not
1127 "Filesystem loop detected; %s has the same device number and inode as "
1128 "a directory which is %d level higher in the file system hierarchy",
1129 "Filesystem loop detected; %s has the same device number and inode as "
1130 "a directory which is %d levels higher in the file system hierarchy",
1132 safely_quote_err_filename(0, pathname
),
1139 /* Recursively descend path PATHNAME, applying the predicates.
1140 LEAF is true if PATHNAME is known to be in a directory that has no
1141 more unexamined subdirectories, and therefore it is not a directory.
1142 Knowing this allows us to avoid calling stat as long as possible for
1145 NAME is PATHNAME relative to the current directory. We access NAME
1148 PARENT is the path of the parent of NAME, relative to find's
1151 Return nonzero iff PATHNAME is a directory. */
1154 process_path (char *pathname
, char *name
, boolean leaf
, char *parent
,
1157 struct stat stat_buf
;
1158 static dev_t root_dev
; /* Device ID of current argument pathname. */
1160 struct predicate
*eval_tree
;
1162 eval_tree
= get_eval_tree();
1163 /* Assume it is a non-directory initially. */
1164 stat_buf
.st_mode
= 0;
1165 state
.rel_pathname
= name
;
1167 state
.have_stat
= false;
1168 state
.have_type
= false;
1170 if (!digest_mode(mode
, pathname
, name
, &stat_buf
, leaf
))
1173 if (!S_ISDIR (state
.type
))
1175 if (state
.curdepth
>= options
.mindepth
)
1176 apply_predicate (pathname
, &stat_buf
, eval_tree
);
1180 /* From here on, we're working on a directory. */
1183 /* Now we really need to stat the directory, even if we know the
1184 * type, because we need information like struct stat.st_rdev.
1186 if (get_statinfo(pathname
, name
, &stat_buf
) != 0)
1189 state
.have_stat
= true;
1190 mode
= state
.type
= stat_buf
.st_mode
; /* use full info now that we have it. */
1191 state
.stop_at_current_level
=
1192 options
.maxdepth
>= 0
1193 && state
.curdepth
>= options
.maxdepth
;
1195 /* If we've already seen this directory on this branch,
1196 don't descend it again. */
1197 for (i
= 0; i
<= dir_curr
; i
++)
1198 if (stat_buf
.st_ino
== dir_ids
[i
].ino
&&
1199 stat_buf
.st_dev
== dir_ids
[i
].dev
)
1201 state
.stop_at_current_level
= true;
1202 issue_loop_warning(name
, pathname
, i
);
1205 if (dir_alloc
<= ++dir_curr
)
1207 dir_alloc
+= DIR_ALLOC_STEP
;
1208 dir_ids
= (struct dir_id
*)
1209 xrealloc ((char *) dir_ids
, dir_alloc
* sizeof (struct dir_id
));
1211 dir_ids
[dir_curr
].ino
= stat_buf
.st_ino
;
1212 dir_ids
[dir_curr
].dev
= stat_buf
.st_dev
;
1214 if (options
.stay_on_filesystem
)
1216 if (state
.curdepth
== 0)
1217 root_dev
= stat_buf
.st_dev
;
1218 else if (stat_buf
.st_dev
!= root_dev
)
1219 state
.stop_at_current_level
= true;
1222 if (options
.do_dir_first
&& state
.curdepth
>= options
.mindepth
)
1223 apply_predicate (pathname
, &stat_buf
, eval_tree
);
1225 if (options
.debug_options
& DebugSearch
)
1226 fprintf(stderr
, "pathname = %s, stop_at_current_level = %d\n",
1227 pathname
, state
.stop_at_current_level
);
1229 if (state
.stop_at_current_level
== false)
1231 /* Scan directory on disk. */
1232 process_dir (pathname
, name
, strlen (pathname
), &stat_buf
, parent
);
1235 if (options
.do_dir_first
== false && state
.curdepth
>= options
.mindepth
)
1237 /* The fields in 'state' are now out of date. Correct them.
1239 if (!digest_mode(mode
, pathname
, name
, &stat_buf
, leaf
))
1244 at_top(pathname
, mode
, &stat_buf
, do_process_predicate
);
1248 do_process_predicate(pathname
, name
, mode
, &stat_buf
);
1258 /* Scan directory PATHNAME and recurse through process_path for each entry.
1260 PATHLEN is the length of PATHNAME.
1262 NAME is PATHNAME relative to the current directory.
1264 STATP is the results of *options.xstat on it.
1266 PARENT is the path of the parent of NAME, relative to find's
1267 starting directory. */
1270 process_dir (char *pathname
, char *name
, int pathlen
, const struct stat
*statp
, char *parent
)
1272 int subdirs_left
; /* Number of unexamined subdirs in PATHNAME. */
1273 boolean subdirs_unreliable
; /* if true, cannot use dir link count as subdir limif (if false, it may STILL be unreliable) */
1274 unsigned int idx
; /* Which entry are we on? */
1275 struct stat stat_buf
;
1276 size_t dircount
= 0u;
1277 struct savedir_dirinfo
*dirinfo
;
1279 printf("process_dir: pathname=%s name=%s statp->st_nlink=%d st_ino=%d\n",
1282 (int)statp
->st_nlink
,
1283 (int)statp
->st_ino
);
1285 if (statp
->st_nlink
< 2)
1287 subdirs_unreliable
= true;
1292 subdirs_unreliable
= false; /* not necessarily right */
1293 subdirs_left
= statp
->st_nlink
- 2; /* Account for name and ".". */
1297 dirinfo
= xsavedir(name
, 0);
1300 if (dirinfo
== NULL
)
1302 assert (errno
!= 0);
1303 error (0, errno
, "%s", safely_quote_err_filename(0, pathname
));
1304 state
.exit_status
= 1;
1308 register char *namep
; /* Current point in `name_space'. */
1309 char *cur_path
; /* Full path of each file to process. */
1310 char *cur_name
; /* Base name of each file to process. */
1311 unsigned cur_path_size
; /* Bytes allocated for `cur_path'. */
1312 register unsigned file_len
; /* Length of each path to process. */
1313 register unsigned pathname_len
; /* PATHLEN plus trailing '/'. */
1314 boolean did_stat
= false;
1316 if (pathname
[pathlen
- 1] == '/')
1317 pathname_len
= pathlen
+ 1; /* For '\0'; already have '/'. */
1319 pathname_len
= pathlen
+ 2; /* For '/' and '\0'. */
1323 /* We're about to leave the directory. If there are any
1324 * -execdir argument lists which have been built but have not
1325 * yet been processed, do them now because they must be done in
1326 * the same directory.
1328 complete_pending_execdirs(get_current_dirfd());
1330 if (strcmp (name
, "."))
1332 enum SafeChdirStatus status
= safely_chdir (name
, TraversingDown
, &stat_buf
, SymlinkHandleDefault
, &did_stat
);
1336 /* If there had been a change but wd_sanity_check()
1337 * accepted it, we need to accept that on the
1338 * way back up as well, so modify our record
1339 * of what we think we should see later.
1340 * If there was no change, the assignments are a no-op.
1342 * However, before performing the assignment, we need to
1343 * check that we have the stat information. If O_NOFOLLOW
1344 * is available, safely_chdir() will not have needed to use
1345 * stat(), and so stat_buf will just contain random data.
1349 /* If there is a link we need to follow it. Hence
1350 * the direct call to stat() not through (options.xstat)
1352 set_stat_placeholders(&stat_buf
);
1353 if (0 != stat(".", &stat_buf
))
1354 break; /* skip the assignment. */
1356 dir_ids
[dir_curr
].dev
= stat_buf
.st_dev
;
1357 dir_ids
[dir_curr
].ino
= stat_buf
.st_ino
;
1361 case SafeChdirFailWouldBeUnableToReturn
:
1362 error (0, errno
, ".");
1363 state
.exit_status
= 1;
1366 case SafeChdirFailNonexistent
:
1367 case SafeChdirFailDestUnreadable
:
1368 case SafeChdirFailStat
:
1369 case SafeChdirFailNotDir
:
1370 case SafeChdirFailChdirFailed
:
1371 error (0, errno
, "%s",
1372 safely_quote_err_filename(0, pathname
));
1373 state
.exit_status
= 1;
1376 case SafeChdirFailSymlink
:
1378 _("warning: not following the symbolic link %s"),
1379 safely_quote_err_filename(0, pathname
));
1380 state
.exit_status
= 1;
1385 for (idx
=0; idx
< dirinfo
->size
; ++idx
)
1387 /* savedirinfo() may return dirinfo=NULL if extended information
1390 mode_t mode
= (dirinfo
->entries
[idx
].flags
& SavedirHaveFileType
) ?
1391 dirinfo
->entries
[idx
].type_info
: 0;
1392 namep
= dirinfo
->entries
[idx
].name
;
1394 /* Append this directory entry's name to the path being searched. */
1395 file_len
= pathname_len
+ strlen (namep
);
1396 if (file_len
> cur_path_size
)
1398 while (file_len
> cur_path_size
)
1399 cur_path_size
+= 1024;
1402 cur_path
= xmalloc (cur_path_size
);
1403 strcpy (cur_path
, pathname
);
1404 cur_path
[pathname_len
- 2] = '/';
1406 cur_name
= cur_path
+ pathname_len
- 1;
1407 strcpy (cur_name
, namep
);
1410 if (!options
.no_leaf_check
&& !subdirs_unreliable
)
1412 if (mode
&& S_ISDIR(mode
) && (subdirs_left
== 0))
1414 /* This is a subdirectory, but the number of directories we
1415 * have found now exceeds the number we would expect given
1416 * the hard link count on the parent. This is likely to be
1417 * a bug in the file system driver (e.g. Linux's
1418 * /proc file system) or may just be a fact that the OS
1419 * doesn't really handle hard links with Unix semantics.
1420 * In the latter case, -noleaf should be used routinely.
1422 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."),
1423 safely_quote_err_filename(0, pathname
),
1426 state
.exit_status
= 1; /* We know the result is wrong, now */
1427 options
.no_leaf_check
= true; /* Don't make same
1429 subdirs_unreliable
= 1;
1430 subdirs_left
= 1; /* band-aid for this iteration. */
1433 /* Normal case optimization. On normal Unix
1434 file systems, a directory that has no subdirectories
1435 has two links: its name, and ".". Any additional
1436 links are to the ".." entries of its subdirectories.
1437 Once we have processed as many subdirectories as
1438 there are additional links, we know that the rest of
1439 the entries are non-directories -- in other words,
1443 count
= process_path (cur_path
, cur_name
,
1444 subdirs_left
== 0, pathname
,
1446 subdirs_left
-= count
;
1452 /* There might be weird (e.g., CD-ROM or MS-DOS) file systems
1453 mounted, which don't have Unix-like directory link counts. */
1454 process_path (cur_path
, cur_name
, false, pathname
, mode
);
1461 /* We're about to leave the directory. If there are any
1462 * -execdir argument lists which have been built but have not
1463 * yet been processed, do them now because they must be done in
1464 * the same directory.
1466 complete_pending_execdirs(get_current_dirfd());
1468 if (strcmp (name
, "."))
1470 enum SafeChdirStatus status
;
1473 /* We could go back and do the next command-line arg
1474 instead, maybe using longjmp. */
1476 boolean deref
= following_links() ? true : false;
1478 if ( (state
.curdepth
>0) && !deref
)
1487 status
= safely_chdir (dir
, TraversingUp
, &stat_buf
, SymlinkHandleDefault
, &did_stat
);
1493 case SafeChdirFailWouldBeUnableToReturn
:
1494 error (1, errno
, ".");
1497 case SafeChdirFailNonexistent
:
1498 case SafeChdirFailDestUnreadable
:
1499 case SafeChdirFailStat
:
1500 case SafeChdirFailSymlink
:
1501 case SafeChdirFailNotDir
:
1502 case SafeChdirFailChdirFailed
:
1503 error (1, errno
, "%s", safely_quote_err_filename(0, pathname
));
1509 did
.dev
= dir_ids
[dir_curr
-1].dev
;
1510 did
.ino
= dir_ids
[dir_curr
-1].ino
;
1514 did
.dev
= starting_stat_buf
.st_dev
;
1515 did
.ino
= starting_stat_buf
.st_ino
;
1521 free_dirinfo(dirinfo
);
1524 if (subdirs_unreliable
)
1526 /* Make sure we hasn't used the variable subdirs_left if we knew
1527 * we shouldn't do so.
1529 assert (0 == subdirs_left
|| options
.no_leaf_check
);