sys-apps/findutils: update selinux patch.

(Portage version: 2.1.4)

1 files changed, 9951 insertions, 0 deletions

diff --git a/sys-apps/findutils/files/findutils-4.3.12-selinux.diff b/sys-apps/findutils/files/findutils-4.3.12-selinux.diff
new file mode 100644
index 000000000000..fb772671e444
--- /dev/null
+++ b/sys-apps/findutils/files/findutils-4.3.12-selinux.diff
@@ -0,0 +1,9951 @@
+diff -purN findutils-4.3.12.orig/find/Makefile.am findutils-4.3.12/find/Makefile.am
+--- findutils-4.3.12.orig/find/Makefile.am	2007-07-22 08:29:31.000000000 -0400
++++ findutils-4.3.12/find/Makefile.am	2008-01-30 08:46:05.750843391 -0500
+@@ -2,6 +2,7 @@ AUTOMAKE_OPTIONS = std-options
+ localedir = $(datadir)/locale
+ # noinst_PROGRAMS = regexprops
+ # regexprops_SOURCES = regexprops.c
++DEFS = @DEFS@ -I. -I$(srcdir) -I.. -DWITH_SELINUX
+ 
+ noinst_LIBRARIES = libfindtools.a
+ libfindtools_a_SOURCES = finddata.c fstype.c parser.c pred.c tree.c util.c
+@@ -26,7 +27,7 @@ endif
+ 
+ EXTRA_DIST = defs.h $(man_MANS)
+ INCLUDES = -I../gnulib/lib -I$(top_srcdir)/lib -I$(top_srcdir)/gnulib/lib -I../intl -DLOCALEDIR=\"$(localedir)\"
+-LDADD = ./libfindtools.a ../lib/libfind.a ../gnulib/lib/libgnulib.a @INTLLIBS@ @LIB_CLOCK_GETTIME@ @FINDLIBS@
++LDADD = ./libfindtools.a ../lib/libfind.a ../gnulib/lib/libgnulib.a @INTLLIBS@ @LIB_CLOCK_GETTIME@ @FINDLIBS@ -lselinux
+ man_MANS = find.1
+ SUBDIRS = . testsuite
+ 
+diff -purN findutils-4.3.12.orig/find/Makefile.in findutils-4.3.12/find/Makefile.in
+--- findutils-4.3.12.orig/find/Makefile.in	2007-12-19 16:27:24.000000000 -0500
++++ findutils-4.3.12/find/Makefile.in	2008-01-30 08:46:05.750843391 -0500
+@@ -275,7 +275,7 @@ CPP = @CPP@
+ CPPFLAGS = @CPPFLAGS@
+ CYGPATH_W = @CYGPATH_W@
+ DEFAULT_ARG_SIZE = @DEFAULT_ARG_SIZE@
+-DEFS = @DEFS@
++DEFS = @DEFS@ -I. -I$(srcdir) -I.. -DWITH_SELINUX
+ DEPDIR = @DEPDIR@
+ DIRENT_H = @DIRENT_H@
+ ECHO_C = @ECHO_C@
+@@ -601,7 +601,7 @@ libfindtools_a_SOURCES = finddata.c fsty
+ @WITH_FTS_TRUE@oldfind_SOURCES = find.c
+ @WITH_FTS_FALSE@ftsfind_SOURCES = ftsfind.c
+ EXTRA_DIST = defs.h $(man_MANS)
+-LDADD = ./libfindtools.a ../lib/libfind.a ../gnulib/lib/libgnulib.a @INTLLIBS@ @LIB_CLOCK_GETTIME@ @FINDLIBS@
++LDADD = ./libfindtools.a ../lib/libfind.a ../gnulib/lib/libgnulib.a @INTLLIBS@ @LIB_CLOCK_GETTIME@ @FINDLIBS@ -lselinux
+ man_MANS = find.1
+ SUBDIRS = . testsuite
+ all: all-recursive
+diff -purN findutils-4.3.12.orig/find/defs.h findutils-4.3.12/find/defs.h
+--- findutils-4.3.12.orig/find/defs.h	2007-11-30 05:19:58.000000000 -0500
++++ findutils-4.3.12/find/defs.h	2008-01-30 08:46:05.754843619 -0500
+@@ -90,6 +90,9 @@ int get_statinfo PARAMS((const char *pat
+ #define MODE_RWX	(S_IXUSR | S_IXGRP | S_IXOTH | MODE_RW)
+ #define MODE_ALL	(S_ISUID | S_ISGID | S_ISVTX | MODE_RWX)
+ 
++#ifdef WITH_SELINUX
++#include <selinux/selinux.h>
++#endif /*WITH_SELINUX*/
+ 
+ struct predicate;
+ struct options;
+@@ -314,6 +317,9 @@ struct predicate
+     struct samefile_file_id samefileid; /* samefile */
+     mode_t type;		/* type */
+     struct format_val printf_vec; /* printf fprintf fprint ls fls print0 fprint0 print */
++#ifdef WITH_SELINUX
++    security_context_t scontext; /* scontext */
++#endif /*WITH_SELINUX*/
+   } args;
+ 
+   /* The next predicate in the user input sequence,
+@@ -458,7 +464,9 @@ PREDICATEFUNCTION pred_used;
+ PREDICATEFUNCTION pred_user;
+ PREDICATEFUNCTION pred_writable;
+ PREDICATEFUNCTION pred_xtype;
+-
++#ifdef WITH_SELINUX
++PREDICATEFUNCTION pred_scontext;
++#endif /* WITH_SELINUX */
+ 
+ 
+ int launch PARAMS((const struct buildcmd_control *ctl,
+@@ -605,10 +613,13 @@ struct options
+    */
+   unsigned short optimisation_level;
+ 
+-
+   /* How should we quote filenames in error messages and so forth?
+    */
+   enum quoting_style err_quoting_style;
++
++#ifdef WITH_SELINUX
++  int (*x_getfilecon)();
++#endif /* WITH_SELINUX */
+ };
+ extern struct options options;
+ 
+diff -purN findutils-4.3.12.orig/find/find.1 findutils-4.3.12/find/find.1
+--- findutils-4.3.12.orig/find/find.1	2007-12-19 14:53:14.000000000 -0500
++++ findutils-4.3.12/find/find.1	2008-01-30 08:49:54.983906639 -0500
+@@ -935,6 +935,10 @@ checks the type of the file that 
+ .B \-type
+ does not check.
+ 
++.IP "\-context \fIscontext\fR"
++.IP "\--context \fIscontext\fR"
++(SELinux only) File has the security context \fIscontext\fR.
++
+ .SS ACTIONS
+ .IP "\-delete\fR"
+ Delete files; true if removal succeeded.  If the removal failed, an
+@@ -1340,6 +1344,8 @@ File's type (like in 
+ U=unknown type (shouldn't happen)
+ .IP %Y
+ File's type (like %y), plus follow symlinks: L=loop, N=nonexistent
++.IP %Z
++(SELinux only) file's security context.
+ .PP
+ A `%' character followed by any other character is discarded, but the
+ other character is printed (don't rely on this, as further format
+diff -purN findutils-4.3.12.orig/find/find.1.orig findutils-4.3.12/find/find.1.orig
+--- findutils-4.3.12.orig/find/find.1.orig	1969-12-31 19:00:00.000000000 -0500
++++ findutils-4.3.12/find/find.1.orig	2007-12-19 14:53:14.000000000 -0500
+@@ -0,0 +1,2027 @@
++.TH FIND 1 \" -*- nroff -*-
++.SH NAME
++find \- search for files in a directory hierarchy
++.SH SYNOPSIS
++.B find 
++[\-H] [\-L] [\-P] [\-D debugopts] [\-Olevel] [path...] [expression]
++.SH DESCRIPTION
++This manual page
++documents the GNU version of
++.BR find .
++GNU
++.B find
++searches the directory tree rooted at each given file name by
++evaluating the given expression from left to right, according to the
++rules of precedence (see section OPERATORS), until the outcome is
++known (the left hand side is false for \fIand\fR operations, true for
++\fIor\fR), at which point
++.B find
++moves on to the next file name.
++.PP
++If you are using 
++.B find 
++in an environment where security is important (for example if you are
++using it to seach directories that are writable by other users), you
++should read the "Security Considerations" chapter of the findutils
++documentation, which is called \fBFinding Files\fP and comes with
++findutils.   That document also includes a lot more detail 
++and discussion than this manual page, so you may find it a more useful 
++source of information.
++.SH OPTIONS
++The 
++.BR \-H , 
++.B \-L 
++and 
++.B \-P
++options control the treatment of symbolic
++links.  Command-line arguments following these are taken to be names
++of files or directories to be examined, up to the first argument that
++begins with `\-', or the argument `(' or `!'.  That argument and any
++following arguments are taken to be the expression describing what is
++to be searched for.  If no paths are given, the current directory is
++used.  If no expression is given, the expression 
++.B \-print
++is used
++(but you should probably consider using 
++.B \-print0
++instead, anyway).
++.PP
++This manual page talks about `options' within the expression list.
++These options control the behaviour of 
++.B find
++but are specified immediately after the last path name.  The five
++`real' options
++.BR \-H , 
++.BR \-L , 
++.BR \-P , 
++.B  \-D 
++and 
++.B  \-O
++must appear before
++the first path name, if at all.  A double dash 
++.B \-\-
++can also be used
++to signal that any remaining arguments are not options (though
++ensuring that all start points begin with either `./' or `/' is
++generally safer if you use wildcards in the list of start points).
++.IP \-P
++Never follow symbolic links.  This is the default behaviour.  When 
++.B find
++examines or prints information a file, and the file is a symbolic
++link, the information used shall be taken from the properties of the
++symbolic link itself.  
++
++.IP \-L
++Follow symbolic links.  When 
++.B find
++examines or prints information about files, the information used shall
++be taken from the properties of the file to which the link points, not
++from the link itself (unless it is a broken symbolic link or 
++.B find
++is unable to examine the file to which the link points).  Use of this
++option implies 
++.BR \-noleaf .  
++If you later use the 
++.B \-P 
++option, 
++.B \-noleaf
++will still be in effect.  If 
++.B \-L 
++is in effect and 
++.B find 
++discovers a symbolic link to a subdirectory during its search, 
++the subdirectory pointed to by the symbolic link will be searched.
++.IP
++When the 
++.B \-L 
++option is in effect, the 
++.B \-type 
++predicate will always
++match against the type of the file that a symbolic link points to
++rather than the link itself (unless the symbolic link is broken).
++Using 
++.B \-L 
++causes the 
++.B \-lname 
++and 
++.B \-ilname 
++predicates always to return
++false.
++
++.IP \-H
++Do not follow symbolic links, except while processing the command
++line arguments.  When
++.B find
++examines or prints information about files, the information used 
++shall be taken from the properties of the symbolic link itself.   The
++only exception to this behaviour is when a file specified on the
++command line is a symbolic link, and the link can be resolved.  For
++that situation, the information used is taken from whatever the link
++points to (that is, the link is followed).  The information about the
++link itself is used as a fallback if the file pointed to by the
++symbolic link cannot be examined.  If 
++.B \-H 
++is in effect and one of the
++paths specified on the command line is a symbolic link to a directory,
++the contents of that directory will be examined (though of course
++\-maxdepth 0 would prevent this).
++.P
++If more than one of 
++.BR \-H , 
++.B \-L 
++and 
++.B \-P 
++is specified, each overrides the
++others; the last one appearing on the command line takes effect.
++Since it is the default, the 
++.B \-P 
++option should be considered to be in
++effect unless either 
++.B \-H 
++or 
++.B \-L 
++is specified.
++
++GNU 
++.B find
++frequently stats files during the processing of the command line
++itself, before any searching has begun.  These options also affect how
++those arguments are processed.  Specifically, there are a number of
++tests that compare files listed on the command line against a file we
++are currently considering.  In each case, the file specified on the
++command line will have been examined and some of its properties will
++have been saved.  If the named file is in fact a symbolic link, and
++the 
++.B \-P 
++option is in effect (or if neither 
++.B \-H 
++nor 
++.B \-L 
++were specified), the information used for the comparison will be taken from
++the properties of the symbolic link.  Otherwise, it will be taken from
++the properties of the file the link points to.  If
++.B find 
++cannot follow the link (for example because it has insufficient
++privileges or the link points to a nonexistent file) the properties of
++the link itself will be used.
++.P
++When the 
++.B \-H 
++or 
++.B \-L options are in effect, any symbolic links listed
++as the argument of 
++.B \-newer 
++will be dereferenced, and the timestamp
++will be taken from the file to which the symbolic link points.  The
++same consideration applies to 
++.BR \-newerXY , 
++.B \-anewer 
++and 
++.BR \-cnewer .
++
++The 
++.B \-follow 
++option has a similar effect to 
++.BR \-L , 
++though it takes
++effect at the point where it appears (that is, if 
++.B \-L
++is not used but
++.B \-follow
++is, any symbolic links appearing after 
++.B \-follow
++on the
++command line will be dereferenced, and those before it will not).
++
++.IP "\-D debugoptions"
++Print diagnostic information; this can be helpful to diagnose problems
++with why
++.B find 
++is not doing what you want.  The list of debug options should be comma
++separated.  Compatibility of the debug options is not guaranteed
++between releases of findutils.  For a complete list of valid debug
++options, see the output of
++.B find \-D
++.BR help .
++Valid debug options include
++.RS
++.IP help
++Explain the debugging options
++.IP tree
++Show the expression tree in its original and optimised form.
++.IP stat
++Print messages as files are examined with the 
++.B stat 
++and 
++.B lstat 
++system calls.  The 
++.B find
++program tries to minimise such calls.
++.IP opt
++Prints diagnostic information relating to the optimisation of the
++expression tree; see the \-O option.
++.IP rates
++Prints a summary indicating how often each predicate succeeded or
++failed.
++.RE
++.IP \-Olevel
++Enables query optimisation.   The 
++.B find 
++program reorders tests to speed up execution while preserving the
++overall effect; that is, predicates with side effects are not
++reordered relative to each other.  The optimisations performed at each
++optimisation level are as follows.
++.RS
++.IP 0
++Equivalent to optimisation level 1.
++.IP 1
++This is the default optimisation level and corresponds to the
++traditional behaviour.  Expressions are reordered so that tests based
++only on the names of files (for example 
++.B \-name 
++and 
++.BR \-regex ) 
++are performed first.
++.IP 2
++Any 
++.B \-type 
++or 
++.B \-xtype 
++tests are performed after any tests based only on the names of files,
++but before any tests that require information from the inode.  On many
++modern versions of Unix, file types are returned by
++.B readdir() 
++and so these predicates are faster to evaluate than predicates which
++need to stat the file first.
++.IP 3
++At this optimisation level, the full cost-based query optimiser is
++enabled.  The order of tests is modified so that cheap (i.e. fast)
++tests are performed first and more expensive ones are performed later,
++if necessary.  Within each cost band, predicates are evaluated earlier
++or later according to whether they are likely to succeed or not.  For 
++.BR \-o ,
++predicates which are likely to succeed are evaluated earlier, and for 
++.BR \-a ,
++predicates which are likely to fail are evaluated earlier.
++.RE
++.IP
++The cost-based optimiser has a fixed idea of how likely any given test
++is to succeed.  In some cases the probability takes account of the
++specific nature of the test (for example, 
++.B \-type f
++is assumed to be more likely to succeed than 
++.BR "\-type c" ).
++The cost-based optimiser is currently being evaluated.   If it does
++not actually improve the performance of 
++.BR find ,
++it will be removed again.  Conversely, optimisations that prove to be
++reliable, robust and effective may be enabled at lower optimisation
++levels over time.  However, the default behaviour (i.e. optimisation
++level 1) will not be changed in the 4.3.x release series.  The
++findutils test suite runs all the tests on 
++.B find
++at each optimisation level and ensures that the result is the same.
++.P
++.SH EXPRESSIONS
++The expression is made up of options (which affect overall operation
++rather than the processing of a specific file, and always return
++true), tests (which return a true or false value), and actions (which
++have side effects and return a true or false value), all separated by
++operators.  
++.B \-and
++is assumed where the operator is omitted.  
++
++If the expression contains no actions other than 
++.BR \-prune , 
++.B \-print
++is
++performed on all files for which the expression is true.
++
++.SS OPTIONS
++.P
++All options always return true.  Except for 
++.BR \-daystart , 
++.B \-follow
++and
++.BR \-regextype , 
++the options affect all tests, including tests specified
++before the option.  This is because the options are processed when the
++command line is parsed, while the tests don't do anything until files
++are examined.  The 
++.BR \-daystart , 
++.B \-follow 
++and 
++.B \-regextype
++options are different in this respect, and have an effect only on tests which
++appear later in the command line.  Therefore, for clarity, it is best
++to place them at the beginning of the expression.  A warning is issued
++if you don't do this.
++
++.IP \-d
++A synonym for \-depth, for compatibility with FreeBSD, NetBSD, MacOS X and OpenBSD.
++
++.IP \-daystart
++Measure times (for 
++.BR \-amin , 
++.BR \-atime , 
++.BR \-cmin , 
++.BR \-ctime , 
++.BR \-mmin , 
++and 
++.BR \-mtime )
++from the beginning of today rather than from 24 hours ago.  This
++option only affects tests which appear later on the command line.
++
++.IP \-depth
++Process each directory's contents before the directory itself.  The
++\-delete action also implies 
++.BR \-depth .
++
++.IP \-follow
++Deprecated; use the 
++.B \-L 
++option instead.  Dereference symbolic links.
++Implies 
++.BR \-noleaf .  
++The 
++.B \-follow 
++option affects only those tests which
++appear after it on the command line.  Unless the 
++.B \-H
++or 
++.B \-L 
++option has
++been specified, the position of the 
++.B \-follow 
++option changes the behaviour of the 
++.B \-newer 
++predicate; any files listed as the argument
++of 
++.B \-newer
++will be dereferenced if they are symbolic links.  The same
++consideration applies to 
++.BR \-newerXY , 
++.B \-anewer 
++and 
++.BR \-cnewer .  
++Similarly, the 
++.B \-type 
++predicate will always match against the type of the file
++that a symbolic link points to rather than the link itself.  Using
++.B \-follow 
++causes the 
++.B \-lname and
++.B \-ilname 
++predicates always to return false.
++
++.IP "\-help, \-\-help"
++Print a summary of the command-line usage of
++.B find
++and exit.
++
++.IP \-ignore_readdir_race
++Normally, \fBfind\fR will emit an error message when it fails to stat a file.
++If you give this option and a file is deleted between the time \fBfind\fR 
++reads the name of the file from the directory and the time it tries to stat 
++the file, no error message will be issued.    This also applies to files
++or directories whose names are given on the command line.  This option takes
++effect at the time the command line is read, which means that you cannot search
++one part of the filesystem with this option on and part of it with this option
++off (if you need to do that, you will need to issue two \fBfind\fR commands
++instead, one with the option and one without it).
++
++.IP "\-maxdepth \fIlevels\fR"
++Descend at most \fIlevels\fR (a non-negative integer) levels of
++directories below the command line arguments.  
++.B \-maxdepth 0
++ means only apply the tests and actions to the command line arguments.
++
++.IP "\-mindepth \fIlevels\fR"
++Do not apply any tests or actions at levels less than \fIlevels\fR (a
++non-negative integer).  
++.B \-mindepth 1
++means process all files except the command line arguments.
++
++.IP \-mount
++Don't descend directories on other filesystems.  An alternate name for
++.BR \-xdev , 
++for compatibility with some other versions of
++.BR find .
++
++.IP \-noignore_readdir_race
++Turns off the effect of 
++.BR \-ignore_readdir_race . 
++
++.IP "\-noleaf"
++Do not optimize by assuming that directories contain 2 fewer
++subdirectories than their hard link count.  This option is needed when
++searching filesystems that do not follow the Unix directory-link
++convention, such as CD-ROM or MS-DOS filesystems or AFS volume mount
++points.  Each directory on a normal Unix filesystem has at least 2
++hard links: its name and its `.'  entry.  Additionally, its
++subdirectories (if any) each have a `..'  entry linked to that
++directory.  When
++.B find
++is examining a directory, after it has statted 2 fewer subdirectories
++than the directory's link count, it knows that the rest of the entries
++in the directory are non-directories (`leaf' files in the directory
++tree).  If only the files' names need to be examined, there is no need
++to stat them; this gives a significant increase in search speed.
++
++.IP "\-regextype \fItype\fR"
++Changes the regular expression syntax understood by 
++.B \-regex
++and 
++.B \-iregex
++tests which occur later on the command line.  Currently-implemented
++types are emacs (this is the default), posix-awk, posix-basic,
++posix-egrep and posix-extended.
++
++.IP "\-version, \-\-version"
++Print the \fBfind\fR version number and exit.
++
++.IP "\-warn, \-nowarn"
++Turn warning messages on or off.  These warnings apply only to the
++command line usage, not to any conditions that 
++.B find 
++might encounter when it searches directories.  The default behaviour
++corresponds to 
++.B \-warn 
++if standard input is a tty, and to 
++.B \-nowarn
++otherwise.
++
++.IP \-xdev
++Don't descend directories on other filesystems.
++
++.SS TESTS
++Some tests, for example
++.B \-newerXY
++and 
++.BR -samefile ,
++allow comparison between the file currently being examined and some
++reference file specified on the command line.  When these tests are
++used, the interpretation of the reference file is determined by the 
++options 
++.BR \-H , 
++.B \-L 
++and 
++.B \-P
++and any previous 
++.BR \-follow ,
++but the reference file is only examined once, at the time the command
++line is parsed.  If the reference file cannot be examined (for
++example, the 
++.BR stat (2) 
++system call fails for it), an error message is issued, and 
++.B find
++exits with a nonzero status.
++.P
++Numeric arguments can be specified as
++.IP \fI+n\fP
++for greater than
++.IR n ,
++.IP \fI\-n\fP
++for less than
++.IR n ,
++.IP \fIn\fP
++for exactly
++.IR n .
++.P
++
++.IP "\-amin \fIn\fR"
++File was last accessed \fIn\fR minutes ago.
++
++.IP "\-anewer \fIfile\fR"
++File was last accessed more recently than \fIfile\fR was modified.  If
++\fIfile\fR is a symbolic link and the 
++.B \-H 
++option or the 
++.B \-L 
++option is in effect, the access time of the file it points to is
++always used.
++
++.IP "\-atime \fIn\fR"
++File was last accessed \fIn\fR*24 hours ago.  
++When find figures out how many 24-hour periods ago the file 
++was last accessed, any fractional part is ignored, so to match 
++.B \-atime 
++.BR +1 ,
++a file has to have been accessed at least 
++.I two
++days ago.
++
++.IP "\-cmin \fIn\fR"
++File's status was last changed \fIn\fR minutes ago.
++
++.IP "\-cnewer \fIfile\fR"
++File's status was last changed more recently than \fIfile\fR was
++modified.  If \fIfile\fR is a symbolic link and the 
++.B \-H 
++option or the
++.B \-L 
++option is in effect, the status-change time of the file it points
++to is always used.
++
++.IP "\-ctime \fIn\fR"
++File's status was last changed \fIn\fR*24 hours ago.
++See the comments for 
++.B \-atime 
++to understand how rounding affects the interpretation of file status
++change times.
++
++.IP \-empty
++File is empty and is either a regular file or a directory.
++
++.IP \-executable
++Matches files which are executable and directories which are
++searchable (in a file name resolution sense).  This takes into account
++access control lists and other permissions artefacts which the
++.B \-perm 
++test ignores.  This test makes use of the
++.BR access (2)
++system call, and so can be fooled by NFS servers which do UID
++mapping (or root-squashing), since many systems implement 
++.BR access (2) 
++in the client's kernel and so cannot make use of the UID mapping
++information held on the server.  Because this test is based only on
++the result of the 
++.BR access (2)
++system call, there is no guarantee that a file for which this test
++succeeds can actually be executed.
++
++.IP \-false
++Always false.
++
++.IP "\-fstype \fItype\fR"
++File is on a filesystem of type \fItype\fR.  The valid filesystem
++types vary among different versions of Unix; an incomplete list of
++filesystem types that are accepted on some version of Unix or another
++is: ufs, 4.2, 4.3, nfs, tmp, mfs, S51K, S52K.  You can use 
++.B \-printf
++with the %F directive to see the types of your filesystems.
++
++.IP "\-gid \fIn\fR"
++File's numeric group ID is \fIn\fR.
++
++.IP "\-group \fIgname\fR"
++File belongs to group \fIgname\fR (numeric group ID allowed).
++
++.IP "\-ilname \fIpattern\fR"
++Like 
++.BR \-lname , 
++but the match is case insensitive.
++If the 
++.B \-L 
++option or the 
++.B \-follow 
++option is in effect, this test returns false unless the symbolic link
++is broken. 
++
++.IP "\-iname \fIpattern\fR"
++Like 
++.BR \-name , 
++but the match is case insensitive.  For example, the
++patterns `fo*' and `F??' match the file names `Foo', `FOO', `foo',
++`fOo', etc.   In these patterns, unlike filename expansion by the
++shell, an initial '.' can be matched by `*'.  That is, 
++.B find \-name *bar 
++will match the file `.foobar'.   Please note that you should quote
++patterns as a matter of course, otherwise the shell will expand any
++wildcard characters in them.
++
++.IP "\-inum \fIn\fR"
++File has inode number \fIn\fR.  It is normally easier to use the 
++.B \-samefile
++test instead.
++
++.IP "\-ipath \fIpattern\fR"
++Behaves in the same way as 
++.BR \-iwholename .  
++This option is deprecated, so please do not use it.
++
++.IP "\-iregex \fIpattern\fR"
++Like 
++.BR \-regex , 
++but the match is case insensitive.
++
++.IP "\-iwholename \fIpattern\fR"
++Like 
++.BR \-wholename , 
++but the match is case insensitive.
++
++.IP "\-links \fIn\fR"
++File has \fIn\fR links.
++
++.IP "\-lname \fIpattern\fR"
++File is a symbolic link whose contents match shell pattern
++\fIpattern\fR.  The metacharacters do not treat `/' or `.' specially.
++If the 
++.B \-L 
++option or the 
++.B \-follow 
++option is in effect, this test returns false unless the symbolic link
++is broken. 
++
++.IP "\-mmin \fIn\fR"
++File's data was last modified \fIn\fR minutes ago.
++
++.IP "\-mtime \fIn\fR"
++File's data was last modified \fIn\fR*24 hours ago.
++See the comments for 
++.B \-atime 
++to understand how rounding affects the interpretation of file
++modification times.
++
++.IP "\-name \fIpattern\fR"
++Base of file name (the path with the leading directories removed)
++matches shell pattern \fIpattern\fR.  The metacharacters (`*', `?',
++and `[]') match a `.' at the start of the base name (this is a change
++in findutils-4.2.2; see section STANDARDS CONFORMANCE below).  To ignore a
++directory and the files under it, use 
++.BR \-prune ; 
++see an example in the
++description of 
++.BR \-path .  
++Braces are not recognised as being
++special, despite the fact that some shells including Bash imbue braces
++with a special meaning in shell patterns.  The filename matching is
++performed with the use of the
++.BR fnmatch (3) 
++library function.   Don't forget to enclose the pattern in quotes 
++in order to protect it from expansion by the shell.
++
++.IP "\-newer \fIfile\fR"
++File was modified more recently than \fIfile\fR.  If \fIfile\fR is a
++symbolic link and the 
++.B \-H 
++option or the 
++.B \-L 
++option is in effect, the
++modification time of the file it points to is always used.
++
++.IP "\-newerXY \fIreference\fR"
++Compares the timestamp of the current file with \fIreference\fR.  
++The 
++.I reference 
++argument is normally the name of a file (and one of its timestamps is
++used for the comparison) but it may also be a string describing an
++absolute time.  
++.I X 
++and 
++.I Y 
++are placeholders for other letters, and these letters select which
++time belonging to 
++how 
++.I reference 
++is used for the comparison.
++.TS
++ll
++ll
++ll
++ll
++llw(2i).
++a	The access time of the file \fIreference\fR 
++B	The birth time of the file \fIreference\fR
++c	The inode status change time of \fIreference\fR
++m	The modification time of the file \fIreference\fR
++t	\fIreference\fR is interpreted directly as a time
++.TE
++
++Some combinations are invalid; for example, it is invalid for
++.I X 
++to be 
++.IR t .
++Some combinations are not implemented on all systems; for example 
++.I B
++is not supported on all systems.  If an invalid or unsupported
++combination of 
++.I XY 
++is specified, a fatal error results.  Time specifications are
++interpreted as for the argument to the 
++.B \-d 
++option of GNU 
++.BR date .
++If you try to use the birth time of a reference file, and the birth
++time cannot be determined, a fatal error message results.  If you
++specify a test which refers to the birth time of files being examined,
++this test will fail for any files where the birth time is unknown.
++
++.IP \-nogroup
++No group corresponds to file's numeric group ID.
++
++.IP \-nouser
++No user corresponds to file's numeric user ID.
++
++.IP "\-path \fIpattern\fR"
++File name matches shell pattern \fIpattern\fR.  The metacharacters do
++not treat `/' or `.' specially; so, for example,
++.br
++.in +1i
++find . \-path "./sr*sc"
++.br
++.in -1i
++will print an entry for a directory called `./src/misc' (if one
++exists).  To ignore a whole directory tree, use 
++.B \-prune
++rather than
++checking every file in the tree.  For example, to skip the
++directory `src/emacs' and all files and directories under it, and
++print the names of the other files found, do something like this:
++.br
++.in +1i
++find . \-path ./src/emacs \-prune \-o \-print
++.br
++.in -1i
++Note that the pattern match test applies to the whole file name,
++starting from one of the start points named on the command line.  It
++would only make sense to use an absolute path name here if the
++relevant start point is also an absolute path.  This means that this
++command will never match anything:
++.br
++.in +1i
++find bar \-path /foo/bar/myfile \-print
++.br
++.in -1i
++The predicate 
++.B \-path
++is also supported by HP-UX
++.B find 
++and will be in a forthcoming version of the POSIX standard.
++
++.IP "\-perm \fImode\fR"
++File's permission bits are exactly \fImode\fR (octal or symbolic).
++Since an exact match is required, if you want to use this form for
++symbolic modes, you may have to specify a rather complex mode string.
++For example 
++.B \-perm g=w
++will only match files which have mode 0020
++(that is, ones for which group write permission is the only permission
++set).  It is more likely that you will want to use the `/' or `-'
++forms, for example 
++.BR "\-perm \-g=w" ,
++which matches any file with group write permission.  See the
++.B EXAMPLES 
++section for some illustrative examples.
++
++.IP "\-perm \-\fImode\fR"
++All of the permission bits \fImode\fR are set for the file.
++Symbolic modes are accepted in this form, and this is usually the way
++in which would want to use them.  You must specify `u', `g' or `o' if
++you use a symbolic mode.   See the 
++.B EXAMPLES 
++section for some illustrative examples.
++
++.IP "\-perm /\fImode\fR"
++Any of the permission bits \fImode\fR are set for the file.  Symbolic
++modes are accepted in this form.  You must specify `u', `g' or `o' if
++you use a symbolic mode.  See the
++.B EXAMPLES 
++section for some illustrative examples.  If no permission bits in 
++.I mode
++are set, this test currently matches no files.  However, it will soon
++be changed to match any file (the idea is to be more consistent with
++the behaviour of 
++.B \-perm 
++.BR \-000 ).
++
++.IP "\-perm +\fImode\fR"
++Deprecated, old way of searching for files with any of the permission
++bits in \fImode\fR set.  You should use
++.B \-perm \fI/mode\fR
++instead. Trying to use the `+' syntax with symbolic modes will yield
++surprising results.  For example, `+u+x' is a valid symbolic mode
++(equivalent to +u,+x, i.e. 0111) and will therefore not be evaluated
++as
++.B \-perm +\fImode\fR
++but instead as the exact mode specifier
++.B \-perm \fImode\fR
++and so it matches files with exact permissions 0111 instead of files with any
++execute bit set.  If you found this paragraph confusing, you're not
++alone - just use 
++.B \-perm /\fImode\fR.
++This form of the 
++.B \-perm
++test is deprecated because the POSIX specification requires the
++interpretation of a leading `+' as being part of a symbolic mode, and
++so we switched to using `/' instead.
++
++.IP \-readable
++Matches files which are readable.  This takes into account access
++control lists and other permissions artefacts which the
++.B \-perm 
++test ignores.  This test makes use of the
++.BR access (2)
++system call, and so can be fooled by NFS servers which do UID
++mapping (or root-squashing), since many systems implement 
++.BR access (2) 
++in the client's kernel and so cannot make use of the UID mapping
++information held on the server.
++
++.IP "\-regex \fIpattern\fR"
++File name matches regular expression \fIpattern\fR.  This is a match
++on the whole path, not a search.  For example, to match a file named
++`./fubar3', you can use the regular expression `.*bar.' or `.*b.*3',
++but not `f.*r3'.  The regular expressions understood by 
++.B find 
++are by default Emacs Regular Expressions, but this can be
++changed with the 
++.B \-regextype 
++option.
++
++.IP "\-samefile \fIname\fR"
++File refers to the same inode as \fIname\fR.   When 
++.B \-L 
++is in effect, this can include symbolic links.
++
++.IP "\-size \fIn\fR[cwbkMG]"
++File uses \fIn\fP units of space.  The following suffixes 
++can be used:
++.RS
++.IP `b' 
++for 512-byte blocks (this is the default if no suffix is used)
++.IP `c' 
++for bytes
++.IP `w' 
++for two-byte words
++.IP `k' 
++for Kilobytes (units of 1024 bytes)
++.IP `M' 
++for Megabytes (units of 1048576 bytes)
++.IP `G' 
++for Gigabytes (units of 1073741824 bytes)
++.RE
++.IP
++The size does not count indirect blocks, but it does count blocks in
++sparse files that are not actually allocated.  Bear in mind that the
++`%k' and `%b' format specifiers of 
++.B \-printf 
++handle sparse files
++differently.  The `b' suffix always denotes 512-byte blocks and never
++1 Kilobyte blocks, which is different to the behaviour of 
++.BR \-ls .
++
++.IP \-true
++Always true.
++
++.IP "\-type \fIc\fR"
++File is of type \fIc\fR:
++.RS
++.IP b
++block (buffered) special
++.IP c
++character (unbuffered) special
++.IP d
++directory
++.IP p
++named pipe (FIFO)
++.IP f
++regular file
++.IP l
++symbolic link; this is never true if the 
++.B \-L 
++option or the 
++.B \-follow
++option is in effect, unless the symbolic link is broken.  If you want
++to search for symbolic links when 
++.B \-L 
++is in effect, use
++.BR \-xtype .
++.IP s
++socket
++.IP D
++door (Solaris)
++.RE
++.IP "\-uid \fIn\fR"
++File's numeric user ID is \fIn\fR.
++
++.IP "\-used \fIn\fR"
++File was last accessed \fIn\fR days after its status was last changed.
++
++.IP "\-user \fIuname\fR"
++File is owned by user \fIuname\fR (numeric user ID allowed).
++
++.IP "\-wholename \fIpattern\fR"
++See \-path.    This alternative is less portable than 
++.BR \-path .
++
++.IP "\-writable"
++Matches files which are writable.  This takes into account access
++control lists and other permissions artefacts which the
++.B \-perm 
++test ignores.  This test makes use of the
++.BR access (2)
++system call, and so can be fooled by NFS servers which do UID
++mapping (or root-squashing), since many systems implement 
++.BR access (2) 
++in the client's kernel and so cannot make use of the UID mapping
++information held on the server.
++
++.IP "\-xtype \fIc\fR"
++The same as 
++.B \-type
++unless the file is a symbolic link.  For symbolic
++links: if the 
++.B \-H 
++or 
++.B \-P 
++option was specified, true if the file is a
++link to a file of type \fIc\fR; if the 
++.B \-L
++option has been given, true
++if \fIc\fR is `l'.  In other words, for symbolic links, 
++.B \-xtype 
++checks the type of the file that 
++.B \-type
++does not check.
++
++.SS ACTIONS
++.IP "\-delete\fR"
++Delete files; true if removal succeeded.  If the removal failed, an
++error message is issued.  
++If 
++.B \-delete
++fails, 
++.BR find 's 
++exit status will be nonzero
++(when it eventually exits).  
++Use of 
++.B \-delete 
++automatically turns on the 
++.B \-depth 
++option.   
++
++.BR Warnings :
++Don't forget that the find command line is 
++evaluated as an expression, so putting 
++.B \-delete 
++first will make 
++.B find
++try to delete everything below the starting points you specified.
++When testing a 
++.B find
++command line that you later intend to use with 
++.BR \-delete , 
++you should explicitly specify 
++.B \-depth 
++in order to avoid later surprises.  Because
++.B \-delete 
++implies 
++.BR \-depth , 
++you cannot usefully use 
++.B \-prune 
++and 
++.B \-delete
++together. 
++
++.IP "\-exec \fIcommand\fR ;"
++Execute \fIcommand\fR; true if 0 status is returned.  All following
++arguments to
++.B find
++are taken to be arguments to the command until an argument consisting
++of `;' is encountered.  The string `{}' is replaced by the current
++file name being processed everywhere it occurs in the arguments to the
++command, not just in arguments where it is alone, as in some versions
++of
++.BR find .
++Both of these constructions might need to be escaped (with a `\e') or
++quoted to protect them from expansion by the shell.  See the
++.B EXAMPLES
++section for examples of the use of the 
++.B \-exec
++option.  The specified
++command is run once for each matched file.
++The command is executed in the starting directory.   There are
++unavoidable security problems surrounding use of the 
++.B \-exec
++action;
++you should use the
++.B \-execdir
++option instead.  
++
++.IP "\-exec \fIcommand\fR {} +"
++This variant of the 
++.B \-exec
++action runs the specified command on the
++selected files, but the command line is built by appending each
++selected file name at the end; the total number of invocations of the
++command will be much less than the number of matched files.  The
++command line is built in much the same way that
++.B xargs
++builds its command lines.  Only one instance of `{}' is allowed within
++the command.  The command is executed in the starting directory.
++
++.IP "\-execdir \fIcommand\fR ;"
++.IP "\-execdir \fIcommand\fR {} +"
++Like 
++.BR \-exec ,
++but the specified command is run from the subdirectory
++containing the matched file, which is not normally the directory in
++which you started 
++.BR find .
++This a much more secure method for invoking commands, as it avoids
++race conditions during resolution of the paths to the matched files.
++As with the 
++.B \-exec
++action, the `+' form of 
++.B \-execdir
++will build a
++command line to process more than one matched file, but any given
++invocation of
++.I command 
++will only list files that exist in the same subdirectory.  If you use
++this option, you must ensure that your 
++.B $PATH
++environment variable does not reference `.';
++otherwise, an attacker can run any commands they like by leaving an
++appropriately-named file in a directory in which you will run
++.BR \-execdir .  
++The same applies to having entries in 
++.B $PATH
++which are empty or which are not absolute directory names.
++
++.IP "\-fls \fIfile\fR"
++True; like 
++.B \-ls
++but write to \fIfile\fR like 
++.BR \-fprint .
++The output file is always created, even if the predicate is never
++matched.  
++See the
++.B UNUSUAL FILENAMES
++section for information about how unusual characters in filenames are handled.
++
++.IP "\-fprint \fIfile\fR"
++True; print the full file name into file \fIfile\fR.  If \fIfile\fR
++does not exist when \fBfind\fR is run, it is created; if it does
++exist, it is truncated.  The file names ``/dev/stdout'' and
++``/dev/stderr'' are handled specially; they refer to the standard
++output and standard error output, respectively.
++The output file is always created, even if the predicate is never matched.
++See the
++.B UNUSUAL FILENAMES
++section for information about how unusual characters in filenames are handled.
++
++.IP "\-fprint0 \fIfile\fR"
++True; like 
++.B \-print0 
++but write to \fIfile\fR like 
++.BR \-fprint .
++The output file is always created, even if the predicate is never matched.
++See the
++.B UNUSUAL FILENAMES
++section for information about how unusual characters in filenames are handled.
++
++.IP "\-fprintf \fIfile\fR \fIformat\fR"
++True; like 
++.B \-printf 
++but write to \fIfile\fR like 
++.BR \-fprint .
++The output file is always created, even if the predicate is never matched.
++See the
++.B UNUSUAL FILENAMES
++section for information about how unusual characters in filenames are handled.
++
++.IP \-ls
++True; list current file in 
++.B ls \-dils
++format on standard output.
++The block counts are of 1K blocks, unless the environment variable
++POSIXLY_CORRECT is set, in which case 512-byte blocks are used.
++See the
++.B UNUSUAL FILENAMES
++section for information about how unusual characters in filenames are handled.
++
++.IP "\-ok \fIcommand\fR ;"
++Like 
++.B \-exec
++but ask the user first (on the standard input); if the
++response does not start with `y' or `Y', do not run the command, and
++return false.  If the command is run, its standard input is redirected
++from
++.BR /dev/null .
++
++.IP "\-okdir \fIcommand\fR ;"
++Like 
++.B \-execdir
++but ask the user first (on the standard input); if the
++response does not start with `y' or `Y', do not run the command, and
++return false.  If the command is run, its standard input is redirected
++from
++.BR /dev/null .
++
++.IP \-print
++True; print the full file name on the standard output, followed by a
++newline.   If you are piping the output of 
++.B find 
++into another program and there is the faintest possibility that the files 
++which you are searching for might contain a newline, then you should 
++seriously consider using the 
++.B \-print0
++option instead of 
++.BR \-print .
++See the
++.B UNUSUAL FILENAMES
++section for information about how unusual characters in filenames are handled.
++
++.IP \-print0
++True; print the full file name on the standard output, followed by a
++null character (instead of the newline character that 
++.B \-print
++uses).
++This allows file names that contain newlines or other types of white
++space to be correctly interpreted by programs that process the
++\fBfind\fR output.  This option corresponds to the 
++.B \-0
++option of
++.BR xargs .
++
++.IP "\-printf \fIformat\fR"
++True; print \fIformat\fR on the standard output, interpreting `\e'
++escapes and `%' directives.  Field widths and precisions can be
++specified as with the `printf' C function.  Please note that many of
++the fields are printed as %s rather than %d, and this may mean that
++flags don't work as you might expect.  This also means that the `\-'
++flag does work (it forces fields to be left-aligned).  Unlike 
++.BR \-print ,
++.B \-printf
++does not add a newline at the end of the string.  The escapes
++and directives are:
++.RS
++.IP \ea
++Alarm bell.
++.IP \eb
++Backspace.
++.IP \ec
++Stop printing from this format immediately and flush the output.
++.IP \ef
++Form feed.
++.IP \en
++Newline.
++.IP \er
++Carriage return.
++.IP \et
++Horizontal tab.
++.IP \ev
++Vertical tab.
++.IP \e\0
++ASCII NUL.
++.IP \e\e
++A literal backslash (`\e').
++.IP \eNNN
++The character whose ASCII code is NNN (octal).
++.PP
++A `\e' character followed by any other character is treated as an
++ordinary character, so they both are printed.
++.IP %%
++A literal percent sign.
++.IP %a
++File's last access time in the format returned by the C `ctime' function.
++.IP %A\fIk\fP
++File's last access time in the format specified by \fIk\fR, which is
++either `@' or a directive for the C `strftime' function.  The possible
++values for \fIk\fR are listed below; some of them might not be
++available on all systems, due to differences in `strftime' between
++systems.  
++.RS
++.IP @
++seconds since Jan. 1, 1970, 00:00 GMT, with fractional part.
++.PP
++Time fields:
++.IP H
++hour (00..23)
++.IP I
++hour (01..12)
++.IP k
++hour ( 0..23)
++.IP l
++hour ( 1..12)
++.IP M
++minute (00..59)
++.IP p
++locale's AM or PM
++.IP r
++time, 12-hour (hh:mm:ss [AP]M)
++.IP S
++Second (00.00 .. 61.00).  There is a fractional part.
++.IP T
++time, 24-hour (hh:mm:ss)
++.IP +
++Date and time, separated by `+', for example
++`2004\-04\-28+22:22:05.0'.  This is a GNU extension.  The time is
++given in the current timezone (which may be affected by setting the TZ
++environment variable).  The seconds field includes a fractional part.
++.IP X
++locale's time representation (H:M:S)
++.IP Z
++time zone (e.g., EDT), or nothing if no time zone is determinable
++.PP
++Date fields:
++.IP a
++locale's abbreviated weekday name (Sun..Sat)
++.IP A
++locale's full weekday name, variable length (Sunday..Saturday)
++.IP b
++locale's abbreviated month name (Jan..Dec)
++.IP B
++locale's full month name, variable length (January..December)
++.IP c
++locale's date and time (Sat Nov 04 12:02:33 EST 1989).  The format is
++the same as for 
++.BR ctime (3)
++and so to preserve compatibility with that format, there is no fractional part
++in the seconds field.
++.IP d
++day of month (01..31)
++.IP D
++date (mm/dd/yy)
++.IP h
++same as b
++.IP j
++day of year (001..366)
++.IP m
++month (01..12)
++.IP U
++week number of year with Sunday as first day of week (00..53)
++.IP w
++day of week (0..6)
++.IP W
++week number of year with Monday as first day of week (00..53)
++.IP x
++locale's date representation (mm/dd/yy)
++.IP y
++last two digits of year (00..99)
++.IP Y
++year (1970...)
++.RE
++.IP %b
++The amount of disk space used for this file in 512-byte blocks. Since disk
++space is allocated in multiples of the filesystem block size this is usually
++greater than %s/512, but it can also be smaller if the file is a sparse file.
++.IP %c
++File's last status change time in the format returned by the C `ctime'
++function.
++.IP %C\fIk\fP
++File's last status change time in the format specified by \fIk\fR,
++which is the same as for %A.
++.IP %d
++File's depth in the directory tree; 0 means the file is a command line
++argument.
++.IP %D
++The device number on which the file exists (the st_dev field of struct
++stat), in decimal.
++.IP %f
++File's name with any leading directories removed (only the last element).
++.IP %F
++Type of the filesystem the file is on; this value can be used for
++\-fstype.
++.IP %g
++File's group name, or numeric group ID if the group has no name.
++.IP %G
++File's numeric group ID.
++.IP %h
++Leading directories of file's name (all but the last element).
++If the file name contains no slashes (since it is in the current 
++directory) the %h specifier expands to ".".
++.IP %H
++Command line argument under which file was found.
++.IP %i
++File's inode number (in decimal).
++.IP %k
++The amount of disk space used for this file in 1K blocks. Since disk space is
++allocated in multiples of the filesystem block size this is usually greater
++than %s/1024, but it can also be smaller if the file is a sparse file.
++.IP %l
++Object of symbolic link (empty string if file is not a symbolic link).
++.IP %m
++File's permission bits (in octal).  This option uses the `traditional'
++numbers which most Unix implementations use, but if your particular 
++implementation uses an unusual ordering of octal permissions bits, you
++will see a difference between the actual value of the file's mode and
++the output of %m.   Normally you will want to have a leading
++zero on this number, and to do this, you should use the 
++.B #
++flag (as in, for example, `%#m').
++.IP %M 
++File's permissions (in symbolic form, as for 
++.BR ls ).  
++This directive is supported in findutils 4.2.5 and later.
++.IP %n
++Number of hard links to file.
++.IP %p
++File's name.
++.IP %P
++File's name with the name of the command line argument under which
++it was found removed.
++.IP %s
++File's size in bytes.
++.IP %S 
++File's sparseness.  This is calculated as (BLOCKSIZE*st_blocks /
++st_size).  The exact value you will get for an ordinary file of a
++certain length is system-dependent.  However, normally sparse files
++will have values less than 1.0, and files which use indirect blocks
++may have a value which is greater than 1.0.   The value used for
++BLOCKSIZE is system-dependent, but is usually 512 bytes.   If the file
++size is zero, the value printed is undefined.  On systems which lack
++support for st_blocks, a file's sparseness is assumed to be 1.0.
++.IP %t
++File's last modification time in the format returned by the C `ctime'
++function.
++.IP %T\fIk\fP
++File's last modification time in the format specified by \fIk\fR, 
++which is the same as for %A.
++.IP %u
++File's user name, or numeric user ID if the user has no name.
++.IP %U
++File's numeric user ID.
++.IP %y
++File's type (like in 
++.BR "ls \-l" ), 
++U=unknown type (shouldn't happen)
++.IP %Y
++File's type (like %y), plus follow symlinks: L=loop, N=nonexistent
++.PP
++A `%' character followed by any other character is discarded, but the
++other character is printed (don't rely on this, as further format
++characters may be introduced).  A `%' at the end of the format
++argument causes undefined behaviour since there is no following
++character.  In some locales, it may hide your door keys, while in
++others it may remove the final page from the novel you are reading.
++
++The %m and %d directives support the 
++.B #
++, 
++.B 0 
++and 
++.B + 
++flags, but the other directives do not, even if they
++print numbers.  Numeric directives that do not support these flags
++include 
++.BR G , 
++.BR U , 
++.BR b , 
++.BR D , 
++.B  k 
++and 
++.BR n .
++The `\-' format flag is supported and changes the alignment of a field
++from right-justified (which is the default) to left-justified.
++.PP
++See the
++.B UNUSUAL FILENAMES
++section for information about how unusual characters in filenames are handled.
++
++
++.RE
++.IP \-prune
++True; if the file is a directory, do not descend into it. If 
++.B \-depth
++is given, false; no effect.  Because 
++.B \-delete
++implies 
++.BR \-depth , 
++you cannot usefully use 
++.B \-prune 
++and 
++.B \-delete together. 
++
++.IP "\-quit"
++Exit immediately.  No child processes will be left running, but no more
++paths specified on the command line will be processed.  For example,
++.B find /tmp/foo /tmp/bar \-print \-quit
++will print only
++.BR /tmp/foo .
++Any command lines which have been built up with
++.B \-execdir ... {} +
++will be invoked before 
++.B find
++exits.   The exit status may or may not be zero, depending on whether
++an error has already occurred.  
++
++.SS UNUSUAL FILENAMES
++Many of the actions of 
++.B find
++result in the printing of data which is under the control of other
++users.  This includes file names, sizes, modification times and so
++forth.  File names are a potential problem since they can contain any
++character except `\e0' and `/'.  Unusual characters in file names can
++do unexpected and often undesirable things to your terminal (for
++example, changing the settings of your function keys on some
++terminals).  Unusual characters are handled differently by various
++actions, as described below.
++
++.IP "\-print0, \-fprint0\"
++Always print the exact filename, unchanged, even if the output is
++going to a terminal.
++
++.IP "\-ls, \-fls"
++Unusual characters are always escaped.  White space, backslash, and
++double quote characters are printed using C-style escaping (for
++example `\ef', `\e"').  Other unusual characters are printed using an
++octal escape.  Other printable characters (for 
++.B \-ls 
++and 
++.B \-fls 
++these are the characters between octal 041 and 0176) are printed as-is.
++
++.IP "\-printf, \-fprintf"
++If the output is not going to a terminal, it is printed as-is.
++Otherwise, the result depends on which directive is in use.  The
++directives %D, %F, %g, %G, %H, %Y, and %y expand to values which are
++not under control of files' owners, and so are printed as-is.  The
++directives %a, %b, %c, %d, %i, %k, %m, %M, %n, %s, %t, %u and %U have
++values which are under the control of files' owners but which cannot
++be used to send arbitrary data to the terminal, and so these are
++printed as-is.  The directives %f, %h, %l, %p and %P are quoted.  This
++quoting is performed in the same way as for GNU
++.BR ls .   
++This is not the same quoting mechanism as the one used for
++.B \-ls 
++and
++.BR \-fls .   
++If you are able to decide what format to use for the output of 
++.B find
++then it is normally better to use `\e0' as a terminator
++than to use newline, as file names can contain white space and newline
++characters.
++
++.IP "\-print, \-fprint"
++Quoting is handled in the same way as for 
++.B \-printf
++and 
++.BR \-fprintf .
++If you are using 
++.B find
++in a script or in a situation where the matched files might have
++arbitrary names, you should consider using 
++.B \-print0 
++instead of
++.BR \-print .
++.P
++The 
++.B \-ok 
++and 
++.B \-okdir
++actions print the current filename as-is.  This may change in a future release.
++.SS OPERATORS
++.P
++Listed in order of decreasing precedence:
++
++.IP "( \fIexpr\fR )"
++Force precedence.  Since parentheses are special to the shell, you
++will normally need to quote them.  Many of the examples in this manual
++page use backslashes for this purpose: `\e(...\e)' instead of `(...)'.
++
++.IP "! \fIexpr\fR"
++True if \fIexpr\fR is false.  This character will also usually need
++protection from interpretation by the shell.
++
++.IP "\-not \fIexpr\fR"
++Same as ! \fIexpr\fR, but not POSIX compliant.
++
++.IP "\fIexpr1 expr2\fR"
++Two expressions in a row are taken to be joined with an 
++implied "and"; \fIexpr2\fR is not evaluated if \fIexpr1\fR is false.
++
++.IP "\fIexpr1\fR \-a \fIexpr2\fR"
++Same as \fIexpr1 expr2\fR.
++
++.IP "\fIexpr1\fR \-and \fIexpr2\fR"
++Same as \fIexpr1 expr2\fR, but not POSIX compliant.
++
++.IP "\fIexpr1\fR \-o \fIexpr2\fR"
++Or; \fIexpr2\fR is not evaluated if \fIexpr1\fR is true.
++
++.IP "\fIexpr1\fR \-or \fIexpr2\fR"
++Same as \fIexpr1\fR 
++.B \-o 
++\fIexpr2\fR, but not POSIX compliant.
++
++.IP "\fIexpr1\fR , \fIexpr2\fR"
++List; both \fIexpr1\fR and \fIexpr2\fR are always evaluated.  The
++value of \fIexpr1\fR is discarded; the value of the list is the value
++of \fIexpr2\fR. The comma operator can be useful for searching for
++several different types of thing, but traversing the filesystem
++hierarchy only once.  The
++.B \-fprintf  
++action can be used to list the various matched items into several
++different output files.
++
++
++.SH "STANDARDS CONFORMANCE"
++For closest compliance to the POSIX standard, you should set the
++POSIXLY_CORRECT environment variable.  The following options are
++specified in the POSIX standard (IEEE Std 1003.1, 2003 Edition):
++
++.IP \fB\-H\fR
++This option is supported.
++
++.IP \fB\-L\fR
++This option is supported.
++
++.IP \fB\-name\fR
++This option is supported, but POSIX conformance depends on the 
++POSIX conformance of the system's 
++.BR fnmatch (3) 
++library function.  As of findutils-4.2.2, shell metacharacters
++(`*', `?' or `[]' for example) will match a leading `.', because 
++IEEE PASC interpretation 126 requires this.   This is a change from
++previous versions of findutils.
++
++.IP \fB\-type\fR
++Supported.   POSIX specifies `b', `c', `d', `l', `p', `f' and `s'.
++GNU find also supports `D', representing a Door, where the OS provides these.
++
++.IP \fB\-ok\fR
++Supported.   Interpretation of the response is not locale-dependent
++(see ENVIRONMENT VARIABLES).
++
++.IP \fB\-newer\fR
++Supported.  If the file specified is a symbolic link, it is always
++dereferenced.  This is a change from previous behaviour, which used to 
++take the relevant time from the symbolic link; see the HISTORY section
++below.
++
++.IP \fB\-perm\fR
++Supported.  If the POSIXLY_CORRECT environment variable is not set,
++some mode arguments (for example +a+x) which are not valid in POSIX
++are supported for backward-compatibility.
++
++.IP "Other predicates"
++The predicates
++.BR \-atime ,
++.BR \-ctime ,
++.BR \-depth ,
++.BR \-group ,
++.BR \-links ,
++.BR \-mtime ,
++.BR \-nogroup ,
++.BR \-nouser ,
++.BR \-print ,
++.BR \-prune ,
++.BR \-size ,
++.BR \-user  
++and 
++.B \-xdev
++are all supported.
++
++.P
++The POSIX standard specifies parentheses `(', `)', negation `!' and the
++`and' and `or' operators (
++.BR \-a , 
++.BR \-o ).   
++.P
++All other options, predicates, expressions and so forth are extensions 
++beyond the POSIX standard.  Many of these extensions are not unique to 
++GNU find, however.
++.P
++The POSIX standard requires that 
++.B find 
++detects loops:
++.IP
++The 
++.B find
++utility shall detect infinite loops; that is, entering a
++previously visited directory that is an ancestor of the last file
++encountered. When it detects an infinite loop, find shall write a
++diagnostic message to standard error and shall either recover its
++position in the hierarchy or terminate.
++.P
++GNU 
++.B find 
++complies with these requirements.  The link count of
++directories which contain entries which are hard links to an ancestor
++will often be lower than they otherwise should be.  This can mean that
++GNU find will sometimes optimise away the visiting of a subdirectory
++which is actually a link to an ancestor.  Since
++.B find
++does not actually enter such a subdirectory, it is allowed to avoid
++emitting a diagnostic message.  Although this behaviour may be
++somewhat confusing, it is unlikely that anybody actually depends on
++this behaviour.  If the leaf optimisation has been turned off with
++.BR \-noleaf ,
++the directory entry will always be examined and the diagnostic message
++will be issued where it is appropriate.  Symbolic links cannot be used
++to create filesystem cycles as such, but if the 
++.B \-L
++option or the
++.B \-follow
++option is in use, a diagnostic message is issued when 
++.B find 
++encounters a loop of symbolic links.  As with loops containing hard
++links, the leaf optimisation will often mean that 
++.B find
++knows that it doesn't need to call 
++.I stat()
++or
++.I chdir() 
++on the symbolic link, so this diagnostic is frequently not necessary.
++.P
++The 
++.B \-d
++option is supported for compatibility with various BSD systems,
++but you should use the POSIX-compliant option 
++.B \-depth
++instead.
++.P
++The POSIXLY_CORRECT environment variable does not affect the behaviour
++of the 
++.B \-regex 
++or 
++.B \-iregex 
++tests because those tests aren't specified in the POSIX standard.
++.SH "ENVIRONMENT VARIABLES"
++
++.IP LANG
++Provides a default value for the internationalization variables that
++are unset or null.
++
++.IP LC_ALL
++If set to a non-empty string value, override the values of all the
++other internationalization variables.
++
++.IP LC_COLLATE
++The POSIX standard specifies that this variable affects the pattern
++matching to be used for the 
++.B \-name
++option.   GNU find uses the 
++.BR fnmatch (3) 
++library function, and so support for `LC_COLLATE' depends on the
++system library.    
++
++.IP
++POSIX also specifies that the `LC_COLLATE' environment 
++variable affects the interpretation of the user's response to the 
++query issued by 
++.BR \-ok' , 
++but this is not the case for GNU find.
++
++.IP LC_CTYPE 
++This variable affects the treatment of character classes used with 
++the 
++.B \-name
++test, if the system's 
++.BR fnmatch (3) 
++library function supports this.   It has no effect on the behaviour 
++of the 
++.B \-ok
++expression.
++
++.IP LC_MESSAGES
++Determines the locale to be used for internationalised messages.
++
++.IP NLSPATH
++Determines the location of the internationalisation message catalogues.
++
++.IP PATH
++Affects the directories which are searched to find the executables 
++invoked by 
++.BR \-exec , 
++.BR \-execdir , 
++.B \-ok
++and 
++.BR \-okdir .
++
++.IP POSIXLY_CORRECT
++Determines the block size used by 
++.B \-ls
++and 
++.BR \-fls . 
++If 
++.B POSIXLY_CORRECT
++is set, blocks are units of 512 bytes.  Otherwise
++they are units of 1024 bytes.   
++.IP
++Setting this variable also turns off
++warning messages (that is, implies
++.BR \-nowarn )
++by default, because POSIX requires that apart from
++the output for 
++.BR \-ok ,
++all messages printed on stderr are diagnositcs and must result in a
++non-zero exit status.
++.IP
++When POSIXLY_CORRECT is not set, 
++.B \-perm
+++zzz
++is treated just like 
++.B \-perm 
++/zzz
++if 
+++zzz is not a valid symbolic mode.  When POSIXLY_CORRECT is set, such
++constructs are treated as an error.
++
++.IP TZ
++Affects the time zone used for some of the time-related format
++directives of 
++.B \-printf 
++and 
++.BR \-fprintf .
++.SH "EXAMPLES"
++.nf
++.B find /tmp \-name core \-type f \-print | xargs /bin/rm \-f
++
++.fi
++Find files named 
++.B core
++in or below the directory 
++.B /tmp 
++and delete them.  Note that this will work incorrectly if there are 
++any filenames containing newlines, single or double quotes, or spaces.
++.P
++.B find /tmp \-name core \-type f \-print0 | xargs \-0 /bin/rm \-f
++
++.fi
++Find files named 
++.B core
++in or below the directory 
++.B /tmp 
++and delete them, processing filenames in such a way that file or
++directory names containing single or double quotes, spaces or newlines
++are correctly handled.  The
++.B \-name 
++test comes before the 
++.B \-type
++test in order to avoid having to call 
++.B stat(2) 
++on every file.
++
++.P
++.nf
++.B find . \-type f \-exec file \(aq{}\(aq \e\;
++
++.fi
++Runs `file' on every file in or below the current directory.  Notice
++that the braces are enclosed in single quote marks to protect them
++from interpretation as shell script punctuation.  The semicolon is
++similarly protected by the use of a backslash, though single quotes
++could have been used in that case also.
++
++.P
++.nf
++.B find /  \e
++.B \e( \-perm \-4000 \-fprintf /root/suid.txt "%#m %u %p\en" \e) , \e
++.B \e( \-size +100M \-fprintf /root/big.txt  "%\-10s %p\en" \e)
++
++.fi
++Traverse the filesystem just once, listing setuid files and
++directories into
++.B /root/suid.txt
++and large files into 
++.BR /root/big.txt .
++
++.P
++.nf
++.B find $HOME  \-mtime 0
++
++.fi
++Search for files in your home directory which have been modified in
++the last twenty-four hours.  This command works this way because the
++time since each file was last modified is divided by 24 hours and any 
++remainder is discarded.  That means that to match 
++.B \-mtime 
++.BR 0 ,
++a file will have to have a modification in the past which is less than
++24 hours ago.
++
++.P
++.nf
++.B find /sbin /usr/sbin -executable \e! -readable \-print
++
++.fi
++Search for files which are executable but not readable.
++
++.P
++.nf
++.B find . \-perm 664
++
++.fi
++Search for files which have read and write permission for their owner,
++and group, but which other users can read but not write to.  Files
++which meet these criteria but have other permissions bits set (for
++example if someone can execute the file) will not be matched.
++
++.P
++.nf
++.B find . \-perm \-664
++
++.fi
++Search for files which have read and write permission for their owner
++and group, and which other users can read, without regard to the
++presence of any extra permission bits (for example the executable
++bit).  This will match a file which has mode 0777, for example.
++
++.P
++.nf
++.B find . \-perm /222
++
++.fi
++Search for files which are writable by somebody (their owner, or
++their group, or anybody else).
++
++.P
++.nf
++.B find . \-perm /220
++.B find . \-perm /u+w,g+w
++.B find . \-perm /u=w,g=w
++
++.fi
++All three of these commands do the same thing, but the first one uses
++the octal representation of the file mode, and the other two use the
++symbolic form.  These commands all search for files which are
++writable by either their owner or their group.  The files don't have
++to be writable by both the owner and group to be matched; either will
++do.
++
++.P
++.nf
++.B find . \-perm \-220
++.B find . \-perm \-g+w,u+w
++
++.fi
++Both these commands do the same thing; search for files which are
++writable by both their owner and their group.
++
++.P
++.nf
++.B find . \-perm \-444 \-perm /222 ! \-perm /111
++.B find . \-perm \-a+r \-perm /a+w ! \-perm /a+x
++
++.fi
++These two commands both search for files that are readable for
++everybody (
++.B \-perm \-444 
++or 
++.BR "\-perm \-a+r" ), 
++have at least one write bit
++set (
++.B \-perm /222 
++or 
++.BR "\-perm /a+w" ) 
++but are not executable for anybody (
++.B ! \-perm /111 
++and 
++.B ! \-perm /a+x 
++respectively).
++
++.P
++.nf
++.B cd /source-dir
++.B find . \-name .snapshot \-prune \-o \e( \e! \-name "*~" \-print0 \e)|
++.B cpio \-pmd0   /dest-dir
++
++.fi 
++This command copies the contents of 
++.B /source-dir
++to 
++.BR /dest-dir ,
++but omits files and directories named 
++.B .snapshot 
++(and anything in them).  It also omits files or directories whose name
++ends in
++.BR ~ ,
++but not their contents.  The construct 
++.B \-prune \-o \e( ... \-print0 \e)
++is quite common.  The idea here is that the expression before 
++.B \-prune 
++matches things which are to be pruned.  However, the 
++.B \-prune 
++action itself returns true, so the following 
++.B \-o 
++ensures that the right hand side is evaluated only for those
++directories which didn't get pruned (the contents of the pruned
++directories are not even visited, so their contents are irrelevant).
++The expression on the right hand side of the 
++.B \-o
++is in parentheses only for clarity.  It emphasises that the
++.B \-print0 
++action takes place only for things that didn't have 
++.B \-prune 
++applied to them.  Because the default `and' condition between tests
++binds more tightly than 
++.BR \-o ,
++this is the default anyway, but the parentheses help to show
++what is going on.
++
++.SH EXIT STATUS
++.PP
++.B find
++exits with status 0 if all files are processed successfully, greater
++than 0 if errors occur.   This is deliberately a very broad
++description, but if the return value is non-zero, you should not rely
++on the correctness of the results of 
++.BR find .
++
++.SH "SEE ALSO"
++\fBlocate\fP(1), \fBlocatedb\fP(5), \fBupdatedb\fP(1), \fBxargs\fP(1),
++\fBchmod\fP(1), \fBfnmatch\fP(3), \fBregex\fP(7), \fBstat\fP(2),
++\fBlstat\fP(2), \fBls\fP(1), \fBprintf\fP(3), \fBstrftime\fP(3),
++\fBctime\fP(3), \fBFinding Files\fP (on-line in Info, or printed).
++.SH "HISTORY"
++As of findutils-4.2.2, shell metacharacters (`*', `?' or `[]' for
++example) used in filename patterns will match a leading `.', because
++IEEE POSIX interpretation 126 requires this.
++.P
++The syntax 
++\.B \-perm +MODE 
++was deprecated in findutils-4.2.21, in favour of
++\.B \-perm 
++.BR /MODE .
++As of findutils-4.3.3, 
++.B \-perm /000
++now matches all files instead of none.  
++.P
++Nanosecond-resolution
++timestamps were implemented in findutils-4.3.3.
++.P
++As of findutils-4.3.11, the 
++.B \-delete 
++action sets 
++.BR find 's 
++exit status to a nonzero value when it fails.
++However, 
++.B find
++will not exit immediately.  Previously, 
++.BR find 's 
++exit status was unaffected by the failure of 
++.BR \-delete .
++.TS
++l l l .
++Feature	Added in	Also occurs in 
++\-newerXY	4.3.3	BSD
++\-D	4.3.1
++\-O	4.3.1
++\-readable	4.3.0
++\-writable	4.3.0
++\-executable	4.3.0
++\-regextype	4.2.24
++\-exec ... +	4.2.12	POSIX
++\-execdir	4.2.12	BSD
++\-okdir	4.2.12
++\-samefile	4.2.11
++\-H	4.2.5	POSIX
++\-L	4.2.5	POSIX
++\-P	4.2.5	BSD
++\-delete	4.2.3	
++\-quit	4.2.3
++\-d	4.2.3	BSD
++\-wholename	4.2.0
++\-iwholename	4.2.0
++\-ignore_readdir_race	4.2.0
++\-fls	4.0
++\-ilname	3.8
++\-iname	3.8
++\-ipath	3.8
++\-iregex	3.8
++.TE
++.SH "NON-BUGS"
++.nf
++.B $ find . \-name *.c \-print
++find: paths must precede expression
++Usage: find [\-H] [\-L] [\-P] [\-Olevel] [\-D help|tree|search|stat|rates|opt|exec] [path...] [expression]
++.fi
++.P
++This happens because 
++.I *.c 
++has been expanded by the shell
++resulting in 
++.B find
++actually receiving a command line like this:
++.nf
++
++.B find . \-name bigram.c code.c frcode.c locate.c \-print
++
++.fi
++That command is of course not going to work.  Instead of doing things
++this way, you should enclose the pattern in quotes or escape the wildcard:
++.nf
++.B $ find . \-name \e*.c \-print
++.fi
++
++.SH "BUGS"
++.P
++There are security problems inherent in the behaviour that the POSIX
++standard specifies for
++.BR find ,
++which therefore cannot be fixed.  For example, the 
++.B \-exec
++action is
++inherently insecure, and 
++.B \-execdir
++should be used instead.  
++Please see \fBFinding Files\fP for more information. 
++.P
++The environment variable 
++.B  LC_COLLATE
++has no effect on the 
++.B \-ok 
++action.
++.P 
++The best way to report a bug is to use the form at
++http://savannah.gnu.org/bugs/?group=findutils.  
++The reason for this is that you will then be able to track progress in
++fixing the problem.   Other comments about \fBfind\fP(1) and about
++the findutils package in general can be sent to the 
++.I bug\-findutils
++mailing list.  To join the list, send email to 
++.IR bug\-findutils\-request@gnu.org .
+diff -purN findutils-4.3.12.orig/find/find.c findutils-4.3.12/find/find.c
+--- findutils-4.3.12.orig/find/find.c	2007-12-19 16:12:34.000000000 -0500
++++ findutils-4.3.12/find/find.c	2008-01-30 08:46:05.754843619 -0500
+@@ -1270,7 +1270,7 @@ process_path (char *pathname, char *name
+ static void
+ process_dir (char *pathname, char *name, int pathlen, const struct stat *statp, char *parent)
+ {
+-  int subdirs_left;		/* Number of unexamined subdirs in PATHNAME. */
++  int subdirs_left=0;		/* Number of unexamined subdirs in PATHNAME. */
+   boolean subdirs_unreliable;	/* if true, cannot use dir link count as subdir limif (if false, it may STILL be unreliable) */
+   unsigned int idx;		/* Which entry are we on? */
+   struct stat stat_buf;
+diff -purN findutils-4.3.12.orig/find/find.c.orig findutils-4.3.12/find/find.c.orig
+--- findutils-4.3.12.orig/find/find.c.orig	1969-12-31 19:00:00.000000000 -0500
++++ findutils-4.3.12/find/find.c.orig	2007-12-19 16:12:34.000000000 -0500
+@@ -0,0 +1,1537 @@
++/* find -- search for files in a directory hierarchy
++   Copyright (C) 1990, 91, 92, 93, 94, 2000, 
++                 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
++
++   This program is free software: you can redistribute it and/or modify
++   it under the terms of the GNU General Public License as published by
++   the Free Software Foundation, either version 3 of the License, or
++   (at your option) any later version.
++   
++   This program is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++   GNU General Public License for more details.
++   
++   You should have received a copy of the GNU General Public License
++   along with this program.  If not, see <http://www.gnu.org/licenses/>.
++*/
++/* GNU find was written by Eric Decker <cire@cisco.com>,
++   with enhancements by David MacKenzie <djm@gnu.org>,
++   Jay Plett <jay@silence.princeton.nj.us>,
++   and Tim Wood <axolotl!tim@toad.com>.
++   The idea for -print0 and xargs -0 came from
++   Dan Bernstein <brnstnd@kramden.acf.nyu.edu>.  
++   Improvements have been made by James Youngman <jay@gnu.org>.
++*/
++
++
++#include <config.h>
++#include "defs.h"
++
++#define USE_SAFE_CHDIR 1
++#undef  STAT_MOUNTPOINTS
++
++
++#include <errno.h>
++#include <assert.h>
++
++#include <sys/stat.h>
++#include <fcntl.h>
++#include <openat.h>
++
++#include "xalloc.h"
++#include "human.h"
++#include "canonicalize.h"
++#include <modetype.h>
++
++#include "closein.h"
++#include "savedirinfo.h"
++#include "buildcmd.h"
++#include "dirname.h"
++#include "quote.h"
++#include "quotearg.h"
++#include "xgetcwd.h"
++#include "error.h"
++
++#ifdef HAVE_LOCALE_H
++#include <locale.h>
++#endif
++
++#if ENABLE_NLS
++# include <libintl.h>
++# define _(Text) gettext (Text)
++#else
++# define _(Text) Text
++#define textdomain(Domain)
++#define bindtextdomain(Package, Directory)
++#define ngettext(singular,plural,n) ((1==n) ? singular : plural)
++#endif
++#ifdef gettext_noop
++# define N_(String) gettext_noop (String)
++#else
++/* See locate.c for explanation as to why not use (String) */
++# define N_(String) String
++#endif
++
++#ifdef STAT_MOUNTPOINTS
++static void init_mounted_dev_list(int mandatory);
++#endif
++
++static void process_top_path PARAMS((char *pathname, mode_t mode));
++static int process_path PARAMS((char *pathname, char *name, boolean leaf, char *parent, mode_t type));
++static void process_dir PARAMS((char *pathname, char *name, int pathlen, const struct stat *statp, char *parent));
++
++
++
++/* Name this program was run with. */
++char *program_name;
++
++/* A file descriptor open to the initial working directory.
++   Doing it this way allows us to work when the i.w.d. has
++   unreadable parents.  */
++int starting_desc;
++
++/* The stat buffer of the initial working directory. */
++static struct stat starting_stat_buf;
++
++enum ChdirSymlinkHandling
++  {
++    SymlinkHandleDefault,	/* Normally the right choice */
++    SymlinkFollowOk		/* see comment in process_top_path() */
++  };
++
++
++enum TraversalDirection
++  {
++    TraversingUp,
++    TraversingDown
++  };
++
++enum WdSanityCheckFatality
++  {
++    FATAL_IF_SANITY_CHECK_FAILS,
++    RETRY_IF_SANITY_CHECK_FAILS,
++    NON_FATAL_IF_SANITY_CHECK_FAILS
++  };
++
++
++int get_current_dirfd(void)
++{
++  return AT_FDCWD;
++}
++
++
++int
++main (int argc, char **argv)
++{
++  int i;
++  int end_of_leading_options = 0; /* First arg after any -H/-L etc. */
++  struct predicate *eval_tree;
++
++  program_name = argv[0];
++  state.exit_status = 0;
++
++  /* Set the option defaults before we do the locale
++   * initialisation as check_nofollow() needs to be executed in the
++   * POSIX locale.
++   */
++  set_option_defaults(&options);
++
++#ifdef HAVE_SETLOCALE
++  setlocale (LC_ALL, "");
++#endif
++  bindtextdomain (PACKAGE, LOCALEDIR);
++  textdomain (PACKAGE);
++  atexit (close_stdin);
++
++  /* Check for -P, -H or -L options. */
++  end_of_leading_options = process_leading_options(argc, argv);
++
++  if (options.debug_options & DebugStat)
++    options.xstat = debug_stat;
++
++#ifdef DEBUG
++  fprintf (stderr, "cur_day_start = %s", ctime (&options.cur_day_start));
++#endif /* DEBUG */
++
++  /* state.cwd_dir_fd has to be initialised before we call build_expression_tree()
++   * because command-line parsing may lead us to stat some files.
++   */
++  state.cwd_dir_fd = AT_FDCWD;
++  
++  /* We are now processing the part of the "find" command line 
++   * after the -H/-L options (if any).
++   */
++  eval_tree = build_expression_tree(argc, argv, end_of_leading_options);
++
++  
++  /* safely_chdir() needs to check that it has ended up in the right place. 
++   * To avoid bailing out when something gets automounted, it checks if 
++   * the target directory appears to have had a directory mounted on it as
++   * we chdir()ed.  The problem with this is that in order to notice that 
++   * a file system was mounted, we would need to lstat() all the mount points.
++   * That strategy loses if our machine is a client of a dead NFS server.
++   *
++   * Hence if safely_chdir() and wd_sanity_check() can manage without needing 
++   * to know the mounted device list, we do that.  
++   */
++  if (!options.open_nofollow_available)
++    {
++#ifdef STAT_MOUNTPOINTS
++      init_mounted_dev_list(0);
++#endif
++    }
++  
++
++  starting_desc = open (".", O_RDONLY
++#if defined O_LARGEFILE
++			|O_LARGEFILE
++#endif
++			);
++  if (0 <= starting_desc && fchdir (starting_desc) != 0)
++    {
++      close (starting_desc);
++      starting_desc = -1;
++    }
++
++  if (starting_desc < 0)
++    {
++      starting_dir = xgetcwd ();
++      if (! starting_dir)
++	error (1, errno, _("cannot get current directory"));
++    }
++  set_stat_placeholders(&starting_stat_buf);
++  if ((*options.xstat) (".", &starting_stat_buf) != 0)
++    error (1, errno, _("cannot stat current directory"));
++
++  /* If no paths are given, default to ".".  */
++  for (i = end_of_leading_options; i < argc && !looks_like_expression(argv[i], true); i++)
++    {
++      process_top_path (argv[i], 0);
++    }
++
++  /* If there were no path arguments, default to ".". */
++  if (i == end_of_leading_options)
++    {
++      /* 
++       * We use a temporary variable here because some actions modify 
++       * the path temporarily.  Hence if we use a string constant, 
++       * we get a coredump.  The best example of this is if we say 
++       * "find -printf %H" (note, not "find . -printf %H").
++       */
++      char defaultpath[2] = ".";
++      process_top_path (defaultpath, 0);
++    }
++
++  /* If "-exec ... {} +" has been used, there may be some 
++   * partially-full command lines which have been built, 
++   * but which are not yet complete.   Execute those now.
++   */
++  show_success_rates(eval_tree);
++  cleanup();
++  return state.exit_status;
++}
++
++boolean is_fts_enabled(int *ftsoptions)
++{
++  /* this version of find (i.e. this main()) does not use fts. */
++  *ftsoptions = 0;
++  return false;
++}
++
++
++static char *
++specific_dirname(const char *dir)
++{
++  char dirbuf[1024];
++
++  if (0 == strcmp(".", dir))
++    {
++      /* OK, what's '.'? */
++      if (NULL != getcwd(dirbuf, sizeof(dirbuf)))
++	{
++	  return strdup(dirbuf);
++	}
++      else
++	{
++	  return strdup(dir);
++	}
++    }
++  else
++    {
++      char *result = canonicalize_filename_mode(dir, CAN_EXISTING);
++      if (NULL == result)
++	return strdup(dir);
++      else
++	return result;
++    }
++}
++
++
++
++/* Return non-zero if FS is the name of a file system that is likely to
++ * be automounted
++ */
++static int
++fs_likely_to_be_automounted(const char *fs)
++{
++  return ( (0==strcmp(fs, "nfs")) || (0==strcmp(fs, "autofs")) || (0==strcmp(fs, "subfs")));
++}
++
++
++
++#ifdef STAT_MOUNTPOINTS
++static dev_t *mounted_devices = NULL;
++static size_t num_mounted_devices = 0u;
++
++
++static void
++init_mounted_dev_list(int mandatory)
++{
++  assert (NULL == mounted_devices);
++  assert (0 == num_mounted_devices);
++  mounted_devices = get_mounted_devices(&num_mounted_devices);
++  if (mandatory && (NULL == mounted_devices))
++    {
++      error(1, 0, "Cannot read list of mounted devices.");
++    }
++}
++
++static void
++refresh_mounted_dev_list(void)
++{
++  if (mounted_devices)
++    {
++      free(mounted_devices);
++      mounted_devices = 0;
++    }
++  num_mounted_devices = 0u;
++  init_mounted_dev_list(1);
++}
++
++
++/* Search for device DEV in the array LIST, which is of size N. */
++static int
++dev_present(dev_t dev, const dev_t *list, size_t n)
++{
++  if (list)
++    {
++      while (n-- > 0u)
++	{
++	  if ( (*list++) == dev )
++	    return 1;
++	}
++    }
++  return 0;
++}
++
++enum MountPointStateChange
++  {
++    MountPointRecentlyMounted,
++    MountPointRecentlyUnmounted,
++    MountPointStateUnchanged
++  };
++
++
++
++static enum MountPointStateChange
++get_mount_state(dev_t newdev)
++{
++  int new_is_present, new_was_present;
++  
++  new_was_present = dev_present(newdev, mounted_devices, num_mounted_devices);
++  refresh_mounted_dev_list();
++  new_is_present  = dev_present(newdev, mounted_devices, num_mounted_devices);
++  
++  if (new_was_present == new_is_present)
++    return MountPointStateUnchanged;
++  else if (new_is_present)
++    return MountPointRecentlyMounted;
++  else
++    return MountPointRecentlyUnmounted;
++}
++
++
++
++/* We stat()ed a directory, chdir()ed into it (we know this 
++ * since direction is TraversingDown), stat()ed it again,
++ * and noticed that the device numbers are different.  Check
++ * if the file system was recently mounted. 
++ * 
++ * If it was, it looks like chdir()ing into the directory
++ * caused a file system to be mounted.  Maybe automount is
++ * running.  Anyway, that's probably OK - but it happens
++ * only when we are moving downward.
++ *
++ * We also allow for the possibility that a similar thing
++ * has happened with the unmounting of a file system.  This
++ * is much rarer, as it relies on an automounter timeout
++ * occurring at exactly the wrong moment.
++ */
++static enum WdSanityCheckFatality
++dirchange_is_fatal(const char *specific_what,
++		   enum WdSanityCheckFatality isfatal,
++		   int silent,
++		   struct stat *newinfo)
++{
++  enum MountPointStateChange transition = get_mount_state(newinfo->st_dev);
++  switch (transition)
++    {
++    case MountPointRecentlyUnmounted:
++      isfatal = NON_FATAL_IF_SANITY_CHECK_FAILS;
++      if (!silent)
++	{
++	  error (0, 0,
++		 _("Warning: file system %s has recently been unmounted."),
++		 safely_quote_err_filename(0, specific_what));
++	}
++      break;
++	      
++    case MountPointRecentlyMounted:
++      isfatal = NON_FATAL_IF_SANITY_CHECK_FAILS;
++      if (!silent)
++	{
++	  error (0, 0,
++		 _("Warning: file system %s has recently been mounted."),
++		 safely_quote_err_filename(0, specific_what));
++	}
++      break;
++
++    case MountPointStateUnchanged:
++      /* leave isfatal as it is */
++      break;
++    }
++  
++  return isfatal;
++}
++
++
++#endif
++
++
++
++/* Examine the results of the stat() of a directory from before we
++ * entered or left it, with the results of stat()ing it afterward.  If
++ * these are different, the file system tree has been modified while we
++ * were traversing it.  That might be an attempt to use a race
++ * condition to persuade find to do something it didn't intend
++ * (e.g. an attempt by an ordinary user to exploit the fact that root
++ * sometimes runs find on the whole file system).  However, this can
++ * also happen if automount is running (certainly on Solaris).  With 
++ * automount, moving into a directory can cause a file system to be 
++ * mounted there.
++ *
++ * To cope sensibly with this, we will raise an error if we see the
++ * device number change unless we are chdir()ing into a subdirectory,
++ * and the directory we moved into has been mounted or unmounted "recently".  
++ * Here "recently" means since we started "find" or we last re-read 
++ * the /etc/mnttab file. 
++ *
++ * If the device number does not change but the inode does, that is a
++ * problem.
++ *
++ * If the device number and inode are both the same, we are happy.
++ *
++ * If a file system is (un)mounted as we chdir() into the directory, that 
++ * may mean that we're now examining a section of the file system that might 
++ * have been excluded from consideration (via -prune or -quit for example).
++ * Hence we print a warning message to indicate that the output of find 
++ * might be inconsistent due to the change in the file system.
++ */
++static boolean
++wd_sanity_check(const char *thing_to_stat,
++		const char *progname,
++		const char *what,
++		dev_t old_dev,
++		ino_t old_ino,
++		struct stat *newinfo,
++		int parent,
++		int line_no,
++		enum TraversalDirection direction,
++		enum WdSanityCheckFatality isfatal,
++		boolean *changed) /* output parameter */
++{
++  const char *fstype;
++  char *specific_what = NULL;
++  int silent = 0;
++  const char *current_dir = ".";
++  
++  *changed = false;
++  
++  set_stat_placeholders(newinfo);
++  if ((*options.xstat) (current_dir, newinfo) != 0)
++    fatal_file_error(thing_to_stat);
++  
++  if (old_dev != newinfo->st_dev)
++    {
++      *changed = true;
++      specific_what = specific_dirname(what);
++      fstype = filesystem_type(newinfo, current_dir);
++      silent = fs_likely_to_be_automounted(fstype);
++
++      /* This condition is rare, so once we are here it is 
++       * reasonable to perform an expensive computation to 
++       * determine if we should continue or fail. 
++       */
++      if (TraversingDown == direction)
++	{
++#ifdef STAT_MOUNTPOINTS
++	  isfatal = dirchange_is_fatal(specific_what,isfatal,silent,newinfo);
++#else
++	  isfatal = RETRY_IF_SANITY_CHECK_FAILS;
++#endif
++	}
++
++      switch (isfatal)
++	{
++	case FATAL_IF_SANITY_CHECK_FAILS:
++	  {
++	    fstype = filesystem_type(newinfo, current_dir);
++	    error (1, 0,
++		   _("%1$s%2$s changed during execution of %3$s "
++		     "(old device number %4$ld, new device number %5$ld, file system type is %6$s) [ref %7$ld]"),
++		   safely_quote_err_filename(0, specific_what),
++		   parent ? "/.." : "",
++		   safely_quote_err_filename(1, progname),
++		   (long) old_dev,
++		   (long) newinfo->st_dev,
++		   fstype,
++		   (long)line_no);
++	    /*NOTREACHED*/
++	    return false;
++	  }
++	  
++	case NON_FATAL_IF_SANITY_CHECK_FAILS:
++	  {
++	    /* Since the device has changed under us, the inode number 
++	     * will almost certainly also be different. However, we have 
++	     * already decided that this is not a problem.  Hence we return
++	     * without checking the inode number.
++	     */
++	    free(specific_what);
++	    return true;
++	  }
++
++	case RETRY_IF_SANITY_CHECK_FAILS:
++	  return false;
++	}
++    }
++
++  /* Device number was the same, check if the inode has changed. */
++  if (old_ino != newinfo->st_ino)
++    {
++      *changed = true;
++      specific_what = specific_dirname(what);
++      fstype = filesystem_type(newinfo, current_dir);
++      
++      error ((isfatal == FATAL_IF_SANITY_CHECK_FAILS) ? 1 : 0,
++	     0,			/* no relevant errno value */
++	     _("%1$s%2$s changed during execution of %3$s "
++	       "(old inode number %4$ld, new inode number %5$ld, file system type is %5$s) [ref %7$ld]"),
++	     safely_quote_err_filename(0, specific_what), 
++	     parent ? "/.." : "",
++	     safely_quote_err_filename(1, progname),
++	     (long) old_ino,
++	     (long) newinfo->st_ino,
++	     fstype,
++	     (long)line_no);
++      free(specific_what);
++      return false;
++    }
++  
++  return true;
++}
++
++enum SafeChdirStatus
++  {
++    SafeChdirOK,
++    SafeChdirFailSymlink,
++    SafeChdirFailNotDir,
++    SafeChdirFailStat,
++    SafeChdirFailWouldBeUnableToReturn,
++    SafeChdirFailChdirFailed,
++    SafeChdirFailNonexistent,
++    SafeChdirFailDestUnreadable
++  };
++
++/* Safely perform a change in directory.  We do this by calling
++ * lstat() on the subdirectory, using chdir() to move into it, and
++ * then lstat()ing ".".  We compare the results of the two stat calls
++ * to see if they are consistent.  If not, we sound the alarm.
++ *
++ * If following_links() is true, we do follow symbolic links.
++ */
++static enum SafeChdirStatus
++safely_chdir_lstat(const char *dest,
++		   enum TraversalDirection direction,
++		   struct stat *statbuf_dest,
++		   enum ChdirSymlinkHandling symlink_follow_option,
++		   boolean *did_stat)
++{
++  struct stat statbuf_arrived;
++  int rv, dotfd=-1;
++  int saved_errno;		/* specific_dirname() changes errno. */
++  boolean rv_set = false;
++  boolean statflag = false;
++  int tries = 0;
++  enum WdSanityCheckFatality isfatal = RETRY_IF_SANITY_CHECK_FAILS;
++  
++  saved_errno = errno = 0;
++
++  dotfd = open(".", O_RDONLY
++#if defined O_LARGEFILE
++	       |O_LARGEFILE
++#endif
++	       );
++
++  /* We jump back to here if wd_sanity_check()
++   * recoverably triggers an alert.
++   */
++ retry:
++  ++tries;
++  
++  if (dotfd >= 0)
++    {
++      /* Stat the directory we're going to. */
++      set_stat_placeholders(statbuf_dest);
++      if (0 == options.xstat(dest, statbuf_dest))
++	{
++	  statflag = true;
++	  
++#ifdef S_ISLNK
++	  /* symlink_follow_option might be set to SymlinkFollowOk, which
++	   * would allow us to chdir() into a symbolic link.  This is
++	   * only useful for the case where the directory we're
++	   * chdir()ing into is the basename of a command line
++	   * argument, for example where "foo/bar/baz" is specified on
++	   * the command line.  When -P is in effect (the default),
++	   * baz will not be followed if it is a symlink, but if bar
++	   * is a symlink, it _should_ be followed.  Hence we need the
++	   * ability to override the policy set by following_links().
++	   */
++	  if (!following_links() && S_ISLNK(statbuf_dest->st_mode))
++	    {
++	      /* We're not supposed to be following links, but this is 
++	       * a link.  Check symlink_follow_option to see if we should 
++	       * make a special exception.
++	       */
++	      if (symlink_follow_option == SymlinkFollowOk)
++		{
++		  /* We need to re-stat() the file so that the 
++		   * sanity check can pass. 
++		   */
++		  if (0 != stat(dest, statbuf_dest))
++		    {
++		      rv = SafeChdirFailNonexistent;
++		      rv_set = true;
++		      saved_errno = errno;
++		      goto fail;
++		    }
++		  statflag = true;
++		}
++	      else
++		{
++		  /* Not following symlinks, so the attempt to
++		   * chdir() into a symlink should be prevented.
++		   */
++		  rv = SafeChdirFailSymlink;
++		  rv_set = true;
++		  saved_errno = 0;	/* silence the error message */
++		  goto fail;
++		}
++	    }
++#endif	  
++#ifdef S_ISDIR
++	  /* Although the immediately following chdir() would detect
++	   * the fact that this is not a directory for us, this would
++	   * result in an extra system call that fails.  Anybody
++	   * examining the system-call trace should ideally not be
++	   * concerned that something is actually failing.
++	   */
++	  if (!S_ISDIR(statbuf_dest->st_mode))
++	    {
++	      rv = SafeChdirFailNotDir;
++	      rv_set = true;
++	      saved_errno = 0;	/* silence the error message */
++	      goto fail;
++	    }
++#endif
++	  
++	  if (options.debug_options & DebugSearch)
++	    fprintf(stderr, "safely_chdir(): chdir(\"%s\")\n", dest);
++
++	  if (0 == chdir(dest))
++	    {
++	      /* check we ended up where we wanted to go */
++	      boolean changed = false;
++	      if (!wd_sanity_check(".", program_name, ".",
++				   statbuf_dest->st_dev,
++				   statbuf_dest->st_ino,
++				   &statbuf_arrived, 
++				   0, __LINE__, direction,
++				   isfatal,
++				   &changed))
++		{
++		  /* Only allow one failure. */
++		  if (RETRY_IF_SANITY_CHECK_FAILS == isfatal)
++		    {
++		      if (0 == fchdir(dotfd))
++			{
++			  isfatal = FATAL_IF_SANITY_CHECK_FAILS;
++			  goto retry;
++			}
++		      else
++			{
++			  /* Failed to return to original directory,
++			   * but we know that the current working
++			   * directory is not the one that we intend
++			   * to be in.  Since fchdir() failed, we
++			   * can't recover from this and so this error
++			   * is fatal.
++			   */
++			  error(1, errno,
++				"failed to return to parent directory");
++			}
++		    }
++		  else
++		    {
++		      /* XXX: not sure what to use as an excuse here. */
++		      rv = SafeChdirFailNonexistent;
++		      rv_set = true;
++		      saved_errno = 0;
++		      goto fail;
++		    }
++		}
++
++	      close(dotfd);
++	      return SafeChdirOK;
++	    }
++	  else
++	    {
++	      saved_errno = errno;
++	      if (ENOENT == saved_errno)
++		{
++		  rv = SafeChdirFailNonexistent;
++		  rv_set = true;
++		  if (options.ignore_readdir_race)
++		    errno = 0;	/* don't issue err msg */
++		}
++	      else if (ENOTDIR == saved_errno)
++		{
++		  /* This can happen if the we stat a directory,
++		   * and then file system activity changes it into 
++		   * a non-directory.
++		   */
++		  saved_errno = 0;	/* don't issue err msg */
++		  rv = SafeChdirFailNotDir;
++		  rv_set = true;
++		}
++	      else
++		{
++		  rv = SafeChdirFailChdirFailed;
++		  rv_set = true;
++		}
++	      goto fail;
++	    }
++	}
++      else
++	{
++	  saved_errno = errno;
++	  rv = SafeChdirFailStat;
++	  rv_set = true;
++
++	  if ( (ENOENT == saved_errno) || (0 == state.curdepth))
++	    saved_errno = 0;	/* don't issue err msg */
++	  goto fail;
++	}
++    }
++  else
++    {
++      /* We do not have read permissions on "." */
++      rv = SafeChdirFailWouldBeUnableToReturn;
++      rv_set = true;
++      goto fail;
++    }
++
++  /* This is the success path, so we clear errno.  The caller probably
++   * won't be calling error() anyway.
++   */
++  saved_errno = 0;
++  
++  /* We use the same exit path for success or failure. 
++   * which has occurred is recorded in RV. 
++   */
++ fail:
++  /* We do not call error() as this would result in a duplicate error
++   * message when the caller does the same thing.
++   */
++  if (saved_errno)
++    errno = saved_errno;
++  
++  if (dotfd >= 0)
++    {
++      close(dotfd);
++      dotfd = -1;
++    }
++  
++  *did_stat = statflag;
++  assert (rv_set);
++  return rv;
++}
++
++#if defined O_NOFOLLOW
++/* Safely change working directory to the specified subdirectory.  If
++ * we are not allowed to follow symbolic links, we use open() with
++ * O_NOFOLLOW, followed by fchdir().  This ensures that we don't
++ * follow symbolic links (of course, we do follow them if the -L
++ * option is in effect).
++ */
++static enum SafeChdirStatus
++safely_chdir_nofollow(const char *dest,
++		      enum TraversalDirection direction,
++		      struct stat *statbuf_dest,
++		      enum ChdirSymlinkHandling symlink_follow_option,
++		      boolean *did_stat)
++{
++  int extraflags, fd;
++
++  (void) direction;
++  (void) statbuf_dest;
++  
++  extraflags = 0;
++  *did_stat = false;
++  
++  switch (symlink_follow_option)
++    {
++    case SymlinkFollowOk:
++      extraflags = 0;
++      break;
++      
++    case SymlinkHandleDefault:
++      if (following_links())
++	extraflags = 0;
++      else
++	extraflags = O_NOFOLLOW;
++      break;
++    }
++  
++  errno = 0;
++  fd = open(dest, O_RDONLY
++#if defined O_LARGEFILE
++	    |O_LARGEFILE
++#endif
++	    |extraflags);
++  if (fd < 0)
++    {
++      switch (errno)
++	{
++	case ELOOP:
++	  return SafeChdirFailSymlink; /* This is why we use O_NOFOLLOW */
++	case ENOENT:
++	  return SafeChdirFailNonexistent;
++	default:
++	  return SafeChdirFailDestUnreadable;
++	}
++    }
++  
++  errno = 0;
++  if (0 == fchdir(fd))
++    {
++      close(fd);
++      return SafeChdirOK;
++    }
++  else
++    {
++      int saved_errno = errno;
++      close(fd);
++      errno = saved_errno;
++      
++      switch (errno)
++	{
++	case ENOTDIR:
++	  return SafeChdirFailNotDir;
++	  
++	case EACCES:
++	case EBADF:		/* Shouldn't happen */
++	case EINTR:
++	case EIO:
++	default:
++	  return SafeChdirFailChdirFailed;
++	}
++    }
++}
++#endif
++
++static enum SafeChdirStatus
++safely_chdir(const char *dest,
++	     enum TraversalDirection direction,
++	     struct stat *statbuf_dest,
++	     enum ChdirSymlinkHandling symlink_follow_option,
++	     boolean *did_stat)
++{
++  enum SafeChdirStatus result;
++  
++  /* We're about to leave a directory.  If there are any -execdir
++   * argument lists which have been built but have not yet been
++   * processed, do them now because they must be done in the same
++   * directory.
++   */
++  complete_pending_execdirs(get_current_dirfd());
++
++#if !defined(O_NOFOLLOW)
++  options.open_nofollow_available = false;
++#endif
++  if (options.open_nofollow_available)
++    {
++      result = safely_chdir_nofollow(dest, direction, statbuf_dest,
++				     symlink_follow_option, did_stat);
++      if (SafeChdirFailDestUnreadable != result)
++	{
++	  return result;
++	}
++      else
++	{
++	  /* Savannah bug #15384: fall through to use safely_chdir_lstat
++	   * if the directory is not readable. 
++	   */
++	  /* Do nothing. */
++	}
++    }
++  /* Even if O_NOFOLLOW is available, we may need to use the alternative 
++   * method, since parent of the start point may be executable but not 
++   * readable. 
++   */
++  return safely_chdir_lstat(dest, direction, statbuf_dest,
++				  symlink_follow_option, did_stat);
++}
++
++
++
++/* Safely go back to the starting directory. */
++static void
++chdir_back (void)
++{
++  struct stat stat_buf;
++  boolean dummy;
++  
++  if (starting_desc < 0)
++    {
++      if (options.debug_options & DebugSearch)
++	fprintf(stderr, "chdir_back(): chdir(\"%s\")\n", starting_dir);
++      
++#ifdef STAT_MOUNTPOINTS
++      /* We will need the mounted device list.  Get it now if we don't
++       * already have it.
++       */
++      if (NULL == mounted_devices)
++	init_mounted_dev_list(1);
++#endif
++      
++      if (chdir (starting_dir) != 0)
++	fatal_file_error(starting_dir);
++
++      wd_sanity_check(starting_dir,
++		      program_name,
++		      starting_dir,
++		      starting_stat_buf.st_dev,
++		      starting_stat_buf.st_ino,
++		      &stat_buf, 0, __LINE__,
++		      TraversingUp,
++		      FATAL_IF_SANITY_CHECK_FAILS,
++		      &dummy);
++    }
++  else
++    {
++      if (options.debug_options & DebugSearch)
++	fprintf(stderr, "chdir_back(): chdir(<starting-point>)\n");
++
++      if (fchdir (starting_desc) != 0)
++	{
++	  fatal_file_error(starting_dir);
++	}
++    }
++}
++
++/* Move to the parent of a given directory and then call a function,
++ * restoring the cwd.  Don't bother changing directory if the
++ * specified directory is a child of "." or is the root directory.
++ */
++static void
++at_top (char *pathname,
++	mode_t mode,
++	struct stat *pstat,
++	void (*action)(char *pathname,
++		       char *basename,
++		       int mode,
++		       struct stat *pstat))
++{
++  int dirchange;
++  char *parent_dir = dir_name (pathname);
++  char *base = last_component (pathname);
++
++  state.curdepth = 0;
++  state.starting_path_length = strlen (pathname);
++
++  if (0 == *base
++      || 0 == strcmp(parent_dir, "."))
++    {
++      dirchange = 0;
++      base = pathname;
++    }
++  else
++    {
++      enum TraversalDirection direction;
++      enum SafeChdirStatus chdir_status;
++      struct stat st;
++      boolean did_stat = false;
++      
++      dirchange = 1;
++      if (0 == strcmp(base, ".."))
++	direction = TraversingUp;
++      else
++	direction = TraversingDown;
++
++      /* We pass SymlinkFollowOk to safely_chdir(), which allows it to
++       * chdir() into a symbolic link.  This is only useful for the
++       * case where the directory we're chdir()ing into is the
++       * basename of a command line argument, for example where
++       * "foo/bar/baz" is specified on the command line.  When -P is
++       * in effect (the default), baz will not be followed if it is a
++       * symlink, but if bar is a symlink, it _should_ be followed.
++       * Hence we need the ability to override the policy set by
++       * following_links().
++       */
++      chdir_status = safely_chdir(parent_dir, direction, &st, SymlinkFollowOk, &did_stat);
++      if (SafeChdirOK != chdir_status)
++	{
++	  const char *what = (SafeChdirFailWouldBeUnableToReturn == chdir_status) ? "." : parent_dir;
++	  if (errno)
++	    error (0, errno, "%s",
++		   safely_quote_err_filename(0, what));
++	  else
++	    error (0, 0, _("Failed to safely change directory into %s"),
++		   safely_quote_err_filename(0, parent_dir));
++	    
++	  /* We can't process this command-line argument. */
++	  state.exit_status = 1;
++	  return;
++	}
++    }
++
++  free (parent_dir);
++  parent_dir = NULL;
++  
++  action(pathname, base, mode, pstat);
++  
++  if (dirchange)
++    {
++      chdir_back();
++    }
++}
++
++
++static void do_process_top_dir(char *pathname,
++			       char *base,
++			       int mode,
++			       struct stat *pstat)
++{
++  (void) pstat;
++  
++  process_path (pathname, base, false, ".", mode);
++  complete_pending_execdirs(get_current_dirfd());
++}
++
++static void do_process_predicate(char *pathname,
++				 char *base,
++				 int mode,
++				 struct stat *pstat)
++{
++  (void) mode;
++  
++  state.rel_pathname = base;	/* cwd_dir_fd was already set by safely_chdir */
++  apply_predicate (pathname, pstat, get_eval_tree());
++}
++
++
++
++
++/* Descend PATHNAME, which is a command-line argument.  
++
++   Actions like -execdir assume that we are in the 
++   parent directory of the file we're examining, 
++   and on entry to this function our working directory
++   is whatever it was when find was invoked.  Therefore
++   If PATHNAME is "." we just leave things as they are. 
++   Otherwise, we figure out what the parent directory is, 
++   and move to that.
++*/
++static void
++process_top_path (char *pathname, mode_t mode)
++{
++  at_top(pathname, mode, NULL, do_process_top_dir);
++}
++
++
++/* Info on each directory in the current tree branch, to avoid
++   getting stuck in symbolic link loops.  */
++static struct dir_id *dir_ids = NULL;
++/* Entries allocated in `dir_ids'.  */
++static int dir_alloc = 0;
++/* Index in `dir_ids' of directory currently being searched.
++   This is always the last valid entry.  */
++static int dir_curr = -1;
++/* (Arbitrary) number of entries to grow `dir_ids' by.  */
++#define DIR_ALLOC_STEP 32
++
++
++
++/* We've detected a file system loop.   This is caused by one of 
++ * two things:
++ *
++ * 1. Option -L is in effect and we've hit a symbolic link that 
++ *    points to an ancestor.  This is harmless.  We won't traverse the 
++ *    symbolic link.
++ *
++ * 2. We have hit a real cycle in the directory hierarchy.  In this 
++ *    case, we issue a diagnostic message (POSIX requires this) and we
++ *    skip that directory entry.
++ */
++static void
++issue_loop_warning(const char *name, const char *pathname, int level)
++{
++  struct stat stbuf_link;
++  if (lstat(name, &stbuf_link) != 0)
++    stbuf_link.st_mode = S_IFREG;
++  
++  if (S_ISLNK(stbuf_link.st_mode))
++    {
++      error(0, 0,
++	    _("Symbolic link %s is part of a loop in the directory hierarchy; we have already visited the directory to which it points."),
++	    safely_quote_err_filename(0, pathname));
++      /* XXX: POSIX appears to require that the exit status be non-zero if a 
++       * diagnostic is issued.  
++       */
++    }
++  else
++    {
++      int distance = 1 + (dir_curr-level);
++      /* We have found an infinite loop.  POSIX requires us to
++       * issue a diagnostic.  Usually we won't get to here
++       * because when the leaf optimisation is on, it will cause
++       * the subdirectory to be skipped.  If /a/b/c/d is a hard
++       * link to /a/b, then the link count of /a/b/c is 2,
++       * because the ".." entry of /b/b/c/d points to /a, not
++       * to /a/b/c.
++       */
++      error(0, 0,
++	    ngettext(
++		     "Filesystem loop detected; %1$s has the same device number and inode as "
++		     "a directory which is %2$d level higher in the file system hierarchy",
++		     "Filesystem loop detected; %1$s has the same device number and inode as "
++		     "a directory which is %2$d levels higher in the file system hierarchy",
++		     (long)distance),
++	    safely_quote_err_filename(0, pathname),
++	    distance);
++    }
++}
++
++
++
++/* Recursively descend path PATHNAME, applying the predicates.
++   LEAF is true if PATHNAME is known to be in a directory that has no
++   more unexamined subdirectories, and therefore it is not a directory.
++   Knowing this allows us to avoid calling stat as long as possible for
++   leaf files.
++
++   NAME is PATHNAME relative to the current directory.  We access NAME
++   but print PATHNAME.
++
++   PARENT is the path of the parent of NAME, relative to find's
++   starting directory.
++
++   Return nonzero iff PATHNAME is a directory. */
++
++static int
++process_path (char *pathname, char *name, boolean leaf, char *parent,
++	      mode_t mode)
++{
++  struct stat stat_buf;
++  static dev_t root_dev;	/* Device ID of current argument pathname. */
++  int i;
++  struct predicate *eval_tree;
++
++  eval_tree = get_eval_tree();
++  /* Assume it is a non-directory initially. */
++  stat_buf.st_mode = 0;
++  state.rel_pathname = name;
++  state.type = 0;
++  state.have_stat = false;
++  state.have_type = false;
++
++  if (!digest_mode(mode, pathname, name, &stat_buf, leaf))
++    return 0;
++  
++  if (!S_ISDIR (state.type))
++    {
++      if (state.curdepth >= options.mindepth)
++	apply_predicate (pathname, &stat_buf, eval_tree);
++      return 0;
++    }
++
++  /* From here on, we're working on a directory.  */
++
++  
++  /* Now we really need to stat the directory, even if we know the
++   * type, because we need information like struct stat.st_rdev.
++   */
++  if (get_statinfo(pathname, name, &stat_buf) != 0)
++    return 0;
++
++  state.have_stat = true;
++  mode = state.type = stat_buf.st_mode;	/* use full info now that we have it. */
++  state.stop_at_current_level =
++    options.maxdepth >= 0
++    && state.curdepth >= options.maxdepth;
++
++  /* If we've already seen this directory on this branch,
++     don't descend it again.  */
++  for (i = 0; i <= dir_curr; i++)
++    if (stat_buf.st_ino == dir_ids[i].ino &&
++	stat_buf.st_dev == dir_ids[i].dev)
++      {
++	state.stop_at_current_level = true;
++	issue_loop_warning(name, pathname, i);
++      }
++  
++  if (dir_alloc <= ++dir_curr)
++    {
++      dir_alloc += DIR_ALLOC_STEP;
++      dir_ids = (struct dir_id *)
++	xrealloc ((char *) dir_ids, dir_alloc * sizeof (struct dir_id));
++    }
++  dir_ids[dir_curr].ino = stat_buf.st_ino;
++  dir_ids[dir_curr].dev = stat_buf.st_dev;
++
++  if (options.stay_on_filesystem)
++    {
++      if (state.curdepth == 0)
++	root_dev = stat_buf.st_dev;
++      else if (stat_buf.st_dev != root_dev)
++	state.stop_at_current_level = true;
++    }
++
++  if (options.do_dir_first && state.curdepth >= options.mindepth)
++    apply_predicate (pathname, &stat_buf, eval_tree);
++
++  if (options.debug_options & DebugSearch)
++    fprintf(stderr, "pathname = %s, stop_at_current_level = %d\n",
++	    pathname, state.stop_at_current_level);
++  
++  if (state.stop_at_current_level == false)
++    {
++      /* Scan directory on disk. */
++      process_dir (pathname, name, strlen (pathname), &stat_buf, parent);
++    }
++
++  if (options.do_dir_first == false && state.curdepth >= options.mindepth)
++    {
++      /* The fields in 'state' are now out of date.  Correct them.
++       */
++      if (!digest_mode(mode, pathname, name, &stat_buf, leaf))
++	return 0;
++
++      if (0 == dir_curr)
++	{
++	  at_top(pathname, mode, &stat_buf, do_process_predicate);
++	}
++      else
++	{
++	  do_process_predicate(pathname, name, mode, &stat_buf);
++	}
++    }
++
++  dir_curr--;
++
++  return 1;
++}
++
++
++/* Scan directory PATHNAME and recurse through process_path for each entry.
++
++   PATHLEN is the length of PATHNAME.
++
++   NAME is PATHNAME relative to the current directory.
++
++   STATP is the results of *options.xstat on it.
++
++   PARENT is the path of the parent of NAME, relative to find's
++   starting directory.  */
++
++static void
++process_dir (char *pathname, char *name, int pathlen, const struct stat *statp, char *parent)
++{
++  int subdirs_left;		/* Number of unexamined subdirs in PATHNAME. */
++  boolean subdirs_unreliable;	/* if true, cannot use dir link count as subdir limif (if false, it may STILL be unreliable) */
++  unsigned int idx;		/* Which entry are we on? */
++  struct stat stat_buf;
++  size_t dircount = 0u;
++  struct savedir_dirinfo *dirinfo;
++#if 0
++  printf("process_dir: pathname=%s name=%s statp->st_nlink=%d st_ino=%d\n",
++	 pathname,
++	 name,
++	 (int)statp->st_nlink,
++	 (int)statp->st_ino);
++#endif  
++  if (statp->st_nlink < 2)
++    {
++      subdirs_unreliable = true;
++      subdirs_left = 0;
++    }
++  else
++    {
++      subdirs_unreliable = false; /* not necessarily right */
++      subdirs_left = statp->st_nlink - 2; /* Account for name and ".". */
++    }
++  
++  errno = 0;
++  dirinfo = xsavedir(name, 0);
++
++  
++  if (dirinfo == NULL)
++    {
++      assert (errno != 0);
++      error (0, errno, "%s", safely_quote_err_filename(0, pathname));
++      state.exit_status = 1;
++    }
++  else
++    {
++      register char *namep;	/* Current point in `name_space'. */
++      char *cur_path;		/* Full path of each file to process. */
++      char *cur_name;		/* Base name of each file to process. */
++      unsigned cur_path_size;	/* Bytes allocated for `cur_path'. */
++      register unsigned file_len; /* Length of each path to process. */
++      register unsigned pathname_len; /* PATHLEN plus trailing '/'. */
++      boolean did_stat = false;
++      
++      if (pathname[pathlen - 1] == '/')
++	pathname_len = pathlen + 1; /* For '\0'; already have '/'. */
++      else
++	pathname_len = pathlen + 2; /* For '/' and '\0'. */
++      cur_path_size = 0;
++      cur_path = NULL;
++
++      /* We're about to leave the directory.  If there are any
++       * -execdir argument lists which have been built but have not
++       * yet been processed, do them now because they must be done in
++       * the same directory.
++       */
++      complete_pending_execdirs(get_current_dirfd());
++      
++      if (strcmp (name, "."))
++	{
++	  enum SafeChdirStatus status = safely_chdir (name, TraversingDown, &stat_buf, SymlinkHandleDefault, &did_stat);
++	  switch (status)
++	    {
++	    case SafeChdirOK:
++	      /* If there had been a change but wd_sanity_check()
++	       * accepted it, we need to accept that on the 
++	       * way back up as well, so modify our record 
++	       * of what we think we should see later.
++	       * If there was no change, the assignments are a no-op.
++	       *
++	       * However, before performing the assignment, we need to
++	       * check that we have the stat information.   If O_NOFOLLOW
++	       * is available, safely_chdir() will not have needed to use 
++	       * stat(), and so stat_buf will just contain random data.
++	       */
++	      if (!did_stat)
++		{
++		  /* If there is a link we need to follow it.  Hence 
++		   * the direct call to stat() not through (options.xstat)
++		   */
++		  set_stat_placeholders(&stat_buf);
++		  if (0 != stat(".", &stat_buf))
++		    break;	/* skip the assignment. */
++		}
++	      dir_ids[dir_curr].dev = stat_buf.st_dev;
++	      dir_ids[dir_curr].ino = stat_buf.st_ino;
++	      
++	      break;
++      
++	    case SafeChdirFailWouldBeUnableToReturn:
++	      error (0, errno, ".");
++	      state.exit_status = 1;
++	      break;
++	      
++	    case SafeChdirFailNonexistent:
++	    case SafeChdirFailDestUnreadable:
++	    case SafeChdirFailStat:
++	    case SafeChdirFailNotDir:
++	    case SafeChdirFailChdirFailed:
++	      error (0, errno, "%s",
++		     safely_quote_err_filename(0, pathname));
++	      state.exit_status = 1;
++	      return;
++	      
++	    case SafeChdirFailSymlink:
++	      error (0, 0,
++		     _("warning: not following the symbolic link %s"),
++		     safely_quote_err_filename(0, pathname));
++	      state.exit_status = 1;
++	      return;
++	    }
++	}
++
++      for (idx=0; idx < dirinfo->size; ++idx)
++	{
++	  /* savedirinfo() may return dirinfo=NULL if extended information 
++	   * is not available. 
++	   */
++	  mode_t mode = (dirinfo->entries[idx].flags & SavedirHaveFileType) ? 
++	    dirinfo->entries[idx].type_info : 0;
++	  namep = dirinfo->entries[idx].name;
++
++	  /* Append this directory entry's name to the path being searched. */
++	  file_len = pathname_len + strlen (namep);
++	  if (file_len > cur_path_size)
++	    {
++	      while (file_len > cur_path_size)
++		cur_path_size += 1024;
++	      if (cur_path)
++		free (cur_path);
++	      cur_path = xmalloc (cur_path_size);
++	      strcpy (cur_path, pathname);
++	      cur_path[pathname_len - 2] = '/';
++	    }
++	  cur_name = cur_path + pathname_len - 1;
++	  strcpy (cur_name, namep);
++
++	  state.curdepth++;
++	  if (!options.no_leaf_check && !subdirs_unreliable)
++	    {
++	      if (mode && S_ISDIR(mode) && (subdirs_left == 0))
++		{
++		  /* This is a subdirectory, but the number of directories we 
++		   * have found now exceeds the number we would expect given 
++		   * the hard link count on the parent.   This is likely to be 
++		   * a bug in the file system driver (e.g. Linux's 
++		   * /proc file system) or may just be a fact that the OS 
++		   * doesn't really handle hard links with Unix semantics.
++		   * In the latter case, -noleaf should be used routinely.
++		   */
++		  error(0, 0, _("WARNING: Hard link count is wrong for %1$s "
++				"(saw only st_nlink=%2$d but we already saw %3$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."),
++			safely_quote_err_filename(0, pathname),
++			statp->st_nlink,
++			dircount);
++		  state.exit_status = 1; /* We know the result is wrong, now */
++		  options.no_leaf_check = true;	/* Don't make same
++						   mistake again */
++		  subdirs_unreliable = 1;
++		  subdirs_left = 1; /* band-aid for this iteration. */
++		}
++	      
++	      /* Normal case optimization.  On normal Unix
++		 file systems, a directory that has no subdirectories
++		 has two links: its name, and ".".  Any additional
++		 links are to the ".." entries of its subdirectories.
++		 Once we have processed as many subdirectories as
++		 there are additional links, we know that the rest of
++		 the entries are non-directories -- in other words,
++		 leaf files. */
++	      {
++		int count;
++		count = process_path (cur_path, cur_name,
++					    subdirs_left == 0, pathname,
++					    mode);
++		subdirs_left -= count;
++		dircount += count;
++	      }
++	    }
++	  else
++	    {
++	      /* There might be weird (e.g., CD-ROM or MS-DOS) file systems
++		 mounted, which don't have Unix-like directory link counts. */
++	      process_path (cur_path, cur_name, false, pathname, mode);
++	    }
++	  
++	  state.curdepth--;
++	}
++
++
++      /* We're about to leave the directory.  If there are any
++       * -execdir argument lists which have been built but have not
++       * yet been processed, do them now because they must be done in
++       * the same directory.
++       */
++      complete_pending_execdirs(get_current_dirfd()); 
++
++      if (strcmp (name, "."))
++	{
++	  enum SafeChdirStatus status;
++	  struct dir_id did;
++	  
++	  /* We could go back and do the next command-line arg
++	     instead, maybe using longjmp.  */
++	  char const *dir;
++	  boolean deref = following_links() ? true : false;
++	  
++	  if ( (state.curdepth>0) && !deref)
++	    dir = "..";
++	  else
++	    {
++	      chdir_back ();
++	      dir = parent;
++	    }
++	  
++	  did_stat = false;
++	  status = safely_chdir (dir, TraversingUp, &stat_buf, SymlinkHandleDefault, &did_stat);
++	  switch (status)
++	    {
++	    case SafeChdirOK:
++	      break;
++      
++	    case SafeChdirFailWouldBeUnableToReturn:
++	      error (1, errno, ".");
++	      return;
++	      
++	    case SafeChdirFailNonexistent:
++	    case SafeChdirFailDestUnreadable:
++	    case SafeChdirFailStat:
++	    case SafeChdirFailSymlink:
++	    case SafeChdirFailNotDir:
++	    case SafeChdirFailChdirFailed:
++	      error (1, errno, "%s", safely_quote_err_filename(0, pathname));
++	      return;
++	    }
++
++	  if (dir_curr > 0)
++	    {
++	      did.dev = dir_ids[dir_curr-1].dev;
++	      did.ino = dir_ids[dir_curr-1].ino;
++	    }
++	  else
++	    {
++	      did.dev = starting_stat_buf.st_dev;
++	      did.ino = starting_stat_buf.st_ino;
++	    }
++	}
++
++      if (cur_path)
++	free (cur_path);
++      free_dirinfo(dirinfo);
++    }
++
++  if (subdirs_unreliable)
++    {
++      /* Make sure we hasn't used the variable subdirs_left if we knew
++       * we shouldn't do so.
++       */
++      assert (0 == subdirs_left || options.no_leaf_check);
++    }
++}
+diff -purN findutils-4.3.12.orig/find/parser.c findutils-4.3.12/find/parser.c
+--- findutils-4.3.12.orig/find/parser.c	2007-12-19 16:12:34.000000000 -0500
++++ findutils-4.3.12/find/parser.c	2008-01-30 08:46:05.754843619 -0500
+@@ -53,6 +53,13 @@
+ #include <unistd.h> 
+ #include <sys/stat.h>
+ 
++#ifdef WITH_SELINUX
++#include <selinux/selinux.h>
++int optionh_getfilecon(const char *name, security_context_t *p);
++int optionl_getfilecon(const char *name, security_context_t *p);
++int optionp_getfilecon(const char *name, security_context_t *p);
++#endif /*WITH_SELINUX*/
++
+ #if ENABLE_NLS
+ # include <libintl.h>
+ # define _(Text) gettext (Text)
+@@ -156,6 +163,9 @@ static boolean parse_noignore_race PARAM
+ static boolean parse_warn          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
+ static boolean parse_xtype         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
+ static boolean parse_quit          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++#ifdef WITH_SELINUX
++static boolean parse_scontext      PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++#endif /*WITH_SELINUX*/
+ 
+ boolean parse_print             PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
+ 
+@@ -341,6 +351,8 @@ static struct parser_table const parse_t
+   {ARG_TEST, "-help",                 parse_help,    NULL},       /* GNU */
+   {ARG_TEST, "version",               parse_version, NULL},	  /* GNU */
+   {ARG_TEST, "-version",              parse_version, NULL},	  /* GNU */
++  {ARG_TEST, "context",               parse_scontext, pred_scontext},	/* SELinux */
++  {ARG_TEST, "-context",              parse_scontext, pred_scontext},	/* SELinux */
+   {0, 0, 0, 0}
+ };
+ 
+@@ -452,10 +464,16 @@ set_follow_state(enum SymlinkOption opt)
+ 	case SYMLINK_ALWAYS_DEREF:  /* -L */
+ 	  options.xstat = optionl_stat;
+ 	  options.no_leaf_check = true;
++#ifdef WITH_SELINUX
++	  options.x_getfilecon = optionl_getfilecon;
++#endif /* WITH_SELINUX */
+ 	  break;
+ 	  
+ 	case SYMLINK_NEVER_DEREF:	/* -P (default) */
+ 	  options.xstat = optionp_stat;
++#ifdef WITH_SELINUX
++	  options.x_getfilecon = optionp_getfilecon;
++#endif /* WITH_SELINUX */
+ 	  /* Can't turn no_leaf_check off because the user might have specified 
+ 	   * -noleaf anyway
+ 	   */
+@@ -464,6 +482,9 @@ set_follow_state(enum SymlinkOption opt)
+ 	case SYMLINK_DEREF_ARGSONLY: /* -H */
+ 	  options.xstat = optionh_stat;
+ 	  options.no_leaf_check = true;
++#ifdef WITH_SELINUX
++	  options.x_getfilecon = optionh_getfilecon;
++#endif /* WITH_SELINUX */
+ 	}
+     }
+   options.symlink_handling = opt;
+@@ -667,6 +688,94 @@ collect_arg_stat_info(char **argv, int *
+  
+    The predicate structure is updated with the new information. */
+ 
++#ifdef WITH_SELINUX
++
++static int
++fallback_getfilecon(const char *name, security_context_t *p, int prev_rv)
++{
++  /* Our original getfilecon() call failed.  Perhaps we can't follow a
++   * symbolic link.  If that might be the problem, lgetfilecon() the link. 
++   * Otherwise, admit defeat. 
++   */
++  switch (errno)
++    {
++    case ENOENT:
++    case ENOTDIR:
++#ifdef DEBUG_STAT
++      fprintf(stderr, "fallback_getfilecon(): getfilecon(%s) failed; falling back on lgetfilecon()\n", name);
++#endif
++      return lgetfilecon(name, p);
++
++    case EACCES:
++    case EIO:
++    case ELOOP:
++    case ENAMETOOLONG:
++#ifdef EOVERFLOW
++    case EOVERFLOW:	    /* EOVERFLOW is not #defined on UNICOS. */
++#endif
++    default:
++      return prev_rv;	       
++    }
++}
++
++
++/* optionh_getfilecon() implements the getfilecon operation when the
++ * -H option is in effect.
++ * 
++ * If the item to be examined is a command-line argument, we follow
++ * symbolic links.  If the getfilecon() call fails on the command-line
++ * item, we fall back on the properties of the symbolic link.
++ *
++ * If the item to be examined is not a command-line argument, we
++ * examine the link itself.
++ */
++int 
++optionh_getfilecon(const char *name, security_context_t *p)
++{
++  if (0 == state.curdepth) 
++    {
++      /* This file is from the command line; deference the link (if it
++       * is a link).  
++       */
++      int rv = getfilecon(name, p);
++      if (0 == rv)
++	return 0;		/* success */
++      else
++	return fallback_getfilecon(name, p, rv);
++    }
++  else
++    {
++      /* Not a file on the command line; do not derefernce the link.
++       */
++      return lgetfilecon(name, p);
++    }
++}
++
++/* optionl_getfilecon() implements the getfilecon operation when the
++ * -L option is in effect.  That option makes us examine the thing the
++ * symbolic link points to, not the symbolic link itself.
++ */
++int 
++optionl_getfilecon(const char *name, security_context_t *p)
++{
++  int rv = getfilecon(name, p);
++  if (0 == rv)
++    return 0;			/* normal case. */
++  else
++    return fallback_getfilecon(name, p, rv);
++}
++
++/* optionp_getfilecon() implements the stat operation when the -P
++ * option is in effect (this is also the default).  That option makes
++ * us examine the symbolic link itself, not the thing it points to.
++ */
++int 
++optionp_getfilecon(const char *name, security_context_t *p)
++{
++  return lgetfilecon(name, p);
++}
++#endif /* WITH_SELINUX */
++
+ 
+ static boolean
+ parse_and (const struct parser_table* entry, char **argv, int *arg_ptr)
+@@ -1124,6 +1233,10 @@ tests (N can be +N or -N or N): -amin N 
+       -readable -writable -executable\n\
+       -wholename PATTERN -size N[bcwkMG] -true -type [bcdpflsD] -uid N\n\
+       -used N -user NAME -xtype [bcdpfls]\n"));
++#ifdef WITH_SELINUX
++  puts (_("\
++      -context CONTEXT\n"));
++#endif /*WITH_SELINUX*/
+   puts (_("\
+ actions: -delete -print0 -printf FORMAT -fprintf FILE FORMAT -print \n\
+       -fprint0 FILE -fprint FILE -ls -fls FILE -prune -quit\n\
+@@ -2522,6 +2635,29 @@ parse_version (const struct parser_table
+   exit (0);
+ }
+ 
++#ifdef WITH_SELINUX
++
++static boolean
++parse_scontext ( const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  struct predicate *our_pred;
++
++  if ( (argv == NULL) || (argv[*arg_ptr] == NULL) )
++    return( false );
++
++  our_pred = insert_primary(entry);
++  our_pred->need_stat = false;
++#ifdef DEBUG
++  our_pred->p_name = find_pred_name (pred_scontext);
++#endif /*DEBUG*/
++  our_pred->args.scontext = argv[*arg_ptr];;
++
++  (*arg_ptr)++;
++  return( true );
++}
++
++#endif /*WITH_SELINUX*/
++
+ static boolean
+ parse_xdev (const struct parser_table* entry, char **argv, int *arg_ptr)
+ {
+@@ -2773,7 +2909,11 @@ insert_fprintf (struct format_val *vec,
+ 	  if (*scan2 == '.')
+ 	    for (scan2++; ISDIGIT (*scan2); scan2++)
+ 	      /* Do nothing. */ ;
++#ifdef WITH_SELINUX
++	  if (strchr ("abcdDfFgGhHiklmMnpPsStuUyYZ", *scan2))
++#else
+ 	  if (strchr ("abcdDfFgGhHiklmMnpPsStuUyY", *scan2))
++#endif
+ 	    {
+ 	      segmentp = make_segment (segmentp, format, scan2 - format,
+ 				       KIND_FORMAT, *scan2, 0,
+diff -purN findutils-4.3.12.orig/find/parser.c.orig findutils-4.3.12/find/parser.c.orig
+--- findutils-4.3.12.orig/find/parser.c.orig	1969-12-31 19:00:00.000000000 -0500
++++ findutils-4.3.12/find/parser.c.orig	2007-12-19 16:12:34.000000000 -0500
+@@ -0,0 +1,3502 @@
++/* parser.c -- convert the command line args into an expression tree.
++   Copyright (C) 1990, 1991, 1992, 1993, 1994, 2000, 2001, 2003, 
++                 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
++
++   This program is free software: you can redistribute it and/or modify
++   it under the terms of the GNU General Public License as published by
++   the Free Software Foundation, either version 3 of the License, or
++   (at your option) any later version.
++
++   This program is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++   GNU General Public License for more details.
++
++   You should have received a copy of the GNU General Public License
++   along with this program.  If not, see <http://www.gnu.org/licenses/>.
++*/
++
++#include <config.h>
++
++#include "defs.h"
++#include <ctype.h>
++#include <math.h>
++#include <assert.h>
++#include <pwd.h>
++#include <errno.h>
++#include <grp.h>
++#include <fnmatch.h>
++#include "modechange.h"
++#include "modetype.h"
++#include "xstrtol.h"
++#include "xalloc.h"
++#include "quote.h"
++#include "quotearg.h"
++#include "buildcmd.h"
++#include "nextelem.h"
++#include "stdio-safer.h"
++#include "regextype.h"
++#include "stat-time.h"
++#include "xstrtod.h"
++#include "fts_.h"
++#include "getdate.h"
++#include "error.h"
++#include "findutils-version.h"
++
++#include <fcntl.h>
++
++
++/* The presence of unistd.h is assumed by gnulib these days, so we 
++ * might as well assume it too. 
++ */
++/* We need <unistd.h> for isatty(). */
++#include <unistd.h> 
++#include <sys/stat.h>
++
++#if ENABLE_NLS
++# include <libintl.h>
++# define _(Text) gettext (Text)
++#else
++# define _(Text) Text
++#endif
++#ifdef gettext_noop
++# define N_(String) gettext_noop (String)
++#else
++/* See locate.c for explanation as to why not use (String) */
++# define N_(String) String
++#endif
++
++#if !defined (isascii) || defined (STDC_HEADERS)
++#ifdef isascii
++#undef isascii
++#endif
++#define isascii(c) 1
++#endif
++
++#define ISDIGIT(c) (isascii ((unsigned char)c) && isdigit ((unsigned char)c))
++#define ISUPPER(c) (isascii ((unsigned char)c) && isupper ((unsigned char)c))
++
++#ifndef HAVE_ENDGRENT
++#define endgrent()
++#endif
++#ifndef HAVE_ENDPWENT
++#define endpwent()
++#endif
++
++static boolean parse_accesscheck   PARAMS((const struct parser_table* entry, char **argv, int *arg_ptr));
++static boolean parse_amin          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_and           PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_anewer        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_cmin          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_cnewer        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_comma         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_daystart      PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_delete        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_d             PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_depth         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_empty         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_exec          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_execdir       PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_false         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_fls           PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_fprintf       PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_follow        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_fprint        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_fprint0       PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_fstype        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_gid           PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_group         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_help          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_ilname        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_iname         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_inum          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_ipath         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_iregex        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_iwholename    PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_links         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_lname         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_ls            PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_maxdepth      PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_mindepth      PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_mmin          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_name          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_negate        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_newer         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_newerXY       PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_noleaf        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_nogroup       PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_nouser        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_nowarn        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_ok            PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_okdir         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_or            PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_path          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_perm          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_print0        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_printf        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_prune         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_regex         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_regextype     PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_samefile      PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++#if 0
++static boolean parse_show_control_chars PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++#endif
++static boolean parse_size          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_time          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_true          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_type          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_uid           PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_used          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_user          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_version       PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_wholename     PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_xdev          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_ignore_race   PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_noignore_race PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_warn          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_xtype         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++static boolean parse_quit          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++
++boolean parse_print             PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
++
++
++static boolean insert_type PARAMS((char **argv, int *arg_ptr,
++				   const struct parser_table *entry,
++				   PRED_FUNC which_pred));
++static boolean insert_regex PARAMS((char *argv[], int *arg_ptr,
++				    const struct parser_table *entry,
++				    int regex_options));
++static boolean insert_fprintf (struct format_val *vec,
++			       const struct parser_table *entry,
++			       PRED_FUNC func,
++			       const char *format);
++
++static struct segment **make_segment PARAMS((struct segment **segment,
++					     char *format, int len,
++					     int kind, char format_char,
++					     char aux_format_char,
++					     struct predicate *pred));
++static boolean insert_exec_ok PARAMS((const char *action,
++				      const struct parser_table *entry,
++				      int dirfd,
++				      char *argv[],
++				      int *arg_ptr));
++static boolean get_comp_type PARAMS((const char **str,
++				     enum comparison_type *comp_type));
++static boolean get_relative_timestamp PARAMS((const char *str,
++					      struct time_val *tval,
++					      time_t origin,
++					      double sec_per_unit,
++					      const char *overflowmessage));
++static boolean get_num PARAMS((const char *str,
++			       uintmax_t *num,
++			       enum comparison_type *comp_type));
++static struct predicate* insert_num PARAMS((char *argv[], int *arg_ptr,
++					    const struct parser_table *entry));
++static void open_output_file (const char *path, struct format_val *p);
++static void open_stdout (struct format_val *p);
++static boolean stream_is_tty(FILE *fp);
++static boolean parse_noop PARAMS((const struct parser_table* entry,
++				  char **argv, int *arg_ptr));
++
++#define PASTE(x,y) x##y
++#define STRINGIFY(s) #s
++
++#define PARSE_OPTION(what,suffix) \
++  { (ARG_OPTION), (what), PASTE(parse_,suffix), NULL }
++
++#define PARSE_POSOPT(what,suffix) \
++  { (ARG_POSITIONAL_OPTION), (what), PASTE(parse_,suffix), NULL }
++
++#define PARSE_TEST(what,suffix) \
++  { (ARG_TEST), (what), PASTE(parse_,suffix), PASTE(pred_,suffix) }
++
++#define PARSE_TEST_NP(what,suffix) \
++  { (ARG_TEST), (what), PASTE(parse_,suffix), NULL }
++
++#define PARSE_ACTION(what,suffix) \
++  { (ARG_ACTION), (what), PASTE(parse_,suffix), PASTE(pred_,suffix) }
++
++#define PARSE_ACTION_NP(what,suffix) \
++  { (ARG_ACTION), (what), PASTE(parse_,suffix), NULL }
++
++#define PARSE_PUNCTUATION(what,suffix) \
++  { (ARG_PUNCTUATION), (what), PASTE(parse_,suffix), PASTE(pred_,suffix) }
++
++
++/* Predicates we cannot handle in the usual way.  If you add an entry
++ * to this table, double-check the switch statement in
++ * pred_sanity_check() to make sure that the new case is being
++ * correctly handled.
++ */
++static struct parser_table const parse_entry_newerXY = 
++  {
++    ARG_SPECIAL_PARSE, "newerXY",            parse_newerXY, pred_newerXY /* BSD  */
++  };
++
++/* GNU find predicates that are not mentioned in POSIX.2 are marked `GNU'.
++   If they are in some Unix versions of find, they are marked `Unix'. */
++
++static struct parser_table const parse_table[] =
++{
++  PARSE_PUNCTUATION("!",                     negate), /* POSIX */
++  PARSE_PUNCTUATION("not",                   negate),	     /* GNU */
++  PARSE_PUNCTUATION("(",                     openparen), /* POSIX */
++  PARSE_PUNCTUATION(")",                     closeparen), /* POSIX */
++  PARSE_PUNCTUATION(",",                     comma),	     /* GNU */
++  PARSE_PUNCTUATION("a",                     and), /* POSIX */
++  PARSE_TEST       ("amin",                  amin),	     /* GNU */
++  PARSE_PUNCTUATION("and",                   and),		/* GNU */
++  PARSE_TEST       ("anewer",                anewer),	     /* GNU */
++  {ARG_TEST,       "atime",                  parse_time, pred_atime}, /* POSIX */
++  PARSE_TEST       ("cmin",                  cmin),	     /* GNU */
++  PARSE_TEST       ("cnewer",                cnewer),	     /* GNU */
++  {ARG_TEST,       "ctime",                  parse_time, pred_ctime}, /* POSIX */
++  PARSE_POSOPT     ("daystart",              daystart),	     /* GNU */
++  PARSE_ACTION     ("delete",                delete), /* GNU, Mac OS, FreeBSD */
++  PARSE_OPTION     ("d",                     d), /* Mac OS X, FreeBSD, NetBSD, OpenBSD, but deprecated  in favour of -depth */
++  PARSE_OPTION     ("depth",                 depth), /* POSIX */
++  PARSE_TEST       ("empty",                 empty),	     /* GNU */
++  {ARG_ACTION,      "exec",    parse_exec, pred_exec}, /* POSIX */
++  {ARG_TEST,        "executable",            parse_accesscheck, pred_executable}, /* GNU, 4.3.0+ */
++  PARSE_ACTION     ("execdir",               execdir), /* *BSD, GNU */
++  PARSE_ACTION     ("fls",                   fls),	     /* GNU */
++  PARSE_POSOPT     ("follow",                follow),  /* GNU, Unix */
++  PARSE_ACTION     ("fprint",                fprint),	     /* GNU */
++  PARSE_ACTION     ("fprint0",               fprint0),	     /* GNU */
++  {ARG_ACTION,      "fprintf", parse_fprintf, pred_fprintf}, /* GNU */
++  PARSE_TEST       ("fstype",                fstype),  /* GNU, Unix */
++  PARSE_TEST       ("gid",                   gid),	     /* GNU */
++  PARSE_TEST       ("group",                 group), /* POSIX */
++  PARSE_OPTION     ("ignore_readdir_race",   ignore_race),   /* GNU */
++  PARSE_TEST       ("ilname",                ilname),	     /* GNU */
++  PARSE_TEST       ("iname",                 iname),	     /* GNU */
++  PARSE_TEST       ("inum",                  inum),    /* GNU, Unix */
++  PARSE_TEST       ("ipath",                 ipath), /* GNU, deprecated in favour of iwholename */
++  PARSE_TEST_NP    ("iregex",                iregex),	     /* GNU */
++  PARSE_TEST_NP    ("iwholename",            iwholename),    /* GNU */
++  PARSE_TEST       ("links",                 links), /* POSIX */
++  PARSE_TEST       ("lname",                 lname),	     /* GNU */
++  PARSE_ACTION     ("ls",                    ls),      /* GNU, Unix */
++  PARSE_OPTION     ("maxdepth",              maxdepth),	     /* GNU */
++  PARSE_OPTION     ("mindepth",              mindepth),	     /* GNU */
++  PARSE_TEST       ("mmin",                  mmin),	     /* GNU */
++  PARSE_OPTION     ("mount",                 xdev),	    /* Unix */
++  {ARG_TEST,       "mtime",                  parse_time, pred_mtime}, /* POSIX */
++  PARSE_TEST       ("name",                  name),
++#ifdef UNIMPLEMENTED_UNIX	                    
++  PARSE(ARG_UNIMPLEMENTED, "ncpio",          ncpio),	    /* Unix */
++#endif				                    
++  PARSE_TEST       ("newer",                 newer), /* POSIX */
++  {ARG_TEST,       "atime",                  parse_time, pred_atime}, /* POSIX */
++  PARSE_OPTION     ("noleaf",                noleaf),	     /* GNU */
++  PARSE_TEST       ("nogroup",               nogroup), /* POSIX */
++  PARSE_TEST       ("nouser",                nouser), /* POSIX */
++  PARSE_OPTION     ("noignore_readdir_race", noignore_race), /* GNU */
++  PARSE_POSOPT     ("nowarn",                nowarn),	     /* GNU */
++  PARSE_PUNCTUATION("o",                     or), /* POSIX */
++  PARSE_PUNCTUATION("or",                    or),	     /* GNU */
++  PARSE_ACTION     ("ok",                    ok), /* POSIX */
++  PARSE_ACTION     ("okdir",                 okdir), /* GNU (-execdir is BSD) */
++  PARSE_TEST       ("path",                  path), /* GNU, HP-UX, RMS prefers wholename, but anyway soon POSIX */
++  PARSE_TEST       ("perm",                  perm), /* POSIX */
++  PARSE_ACTION     ("print",                 print), /* POSIX */
++  PARSE_ACTION     ("print0",                print0),	     /* GNU */
++  {ARG_ACTION,      "printf",   parse_printf, NULL},	     /* GNU */
++  PARSE_ACTION     ("prune",                 prune), /* POSIX */
++  PARSE_ACTION     ("quit",                  quit),	     /* GNU */
++  {ARG_TEST,       "readable",            parse_accesscheck, pred_readable}, /* GNU, 4.3.0+ */
++  PARSE_TEST       ("regex",                 regex),	     /* GNU */
++  PARSE_OPTION     ("regextype",             regextype),     /* GNU */
++  PARSE_TEST       ("samefile",              samefile),	     /* GNU */
++#if 0
++  PARSE_OPTION     ("show-control-chars",    show_control_chars), /* GNU, 4.3.0+ */
++#endif
++  PARSE_TEST       ("size",                  size), /* POSIX */
++  PARSE_TEST       ("type",                  type), /* POSIX */
++  PARSE_TEST       ("uid",                   uid),	     /* GNU */
++  PARSE_TEST       ("used",                  used),	     /* GNU */
++  PARSE_TEST       ("user",                  user), /* POSIX */
++  PARSE_OPTION     ("warn",                  warn),	     /* GNU */
++  PARSE_TEST_NP    ("wholename",             wholename), /* GNU, replaced -path, but anyway -path will soon be in POSIX */
++  {ARG_TEST,       "writable",               parse_accesscheck, pred_writable}, /* GNU, 4.3.0+ */
++  PARSE_OPTION     ("xdev",                  xdev), /* POSIX */
++  PARSE_TEST       ("xtype",                 xtype),	     /* GNU */
++#ifdef UNIMPLEMENTED_UNIX
++  /* It's pretty ugly for find to know about archive formats.
++     Plus what it could do with cpio archives is very limited.
++     Better to leave it out.  */
++  PARSE(ARG_UNIMPLEMENTED,      "cpio",                  cpio),	/* Unix */
++#endif
++  /* gnulib's stdbool.h might have made true and false into macros, 
++   * so we can't leave named 'true' and 'false' tokens, so we have 
++   * to expeant the relevant entries longhand. 
++   */
++  {ARG_TEST, "false",                 parse_false,   pred_false}, /* GNU */
++  {ARG_TEST, "true",                  parse_true,    pred_true }, /* GNU */
++  {ARG_NOOP, "noop",                  NULL,          pred_true }, /* GNU, internal use only */
++
++  /* Various other cases that don't fit neatly into our macro scheme. */
++  {ARG_TEST, "help",                  parse_help,    NULL},       /* GNU */
++  {ARG_TEST, "-help",                 parse_help,    NULL},       /* GNU */
++  {ARG_TEST, "version",               parse_version, NULL},	  /* GNU */
++  {ARG_TEST, "-version",              parse_version, NULL},	  /* GNU */
++  {0, 0, 0, 0}
++};
++
++
++static const char *first_nonoption_arg = NULL;
++static const struct parser_table *noop = NULL;
++
++
++void 
++check_option_combinations(const struct predicate *p)
++{
++  enum { seen_delete=1u, seen_prune=2u };
++  unsigned int predicates = 0u;
++
++  while (p)
++    {
++      if (p->pred_func == pred_delete)
++	predicates |= seen_delete;
++      else if (p->pred_func == pred_prune)
++	predicates |= seen_prune;
++      p = p->pred_next;
++    }
++
++  if ((predicates & seen_prune) && (predicates & seen_delete))
++    {
++      /* The user specified both -delete and -prune.  One might test
++       * this by first doing
++       *    find dirs   .... -prune ..... -print
++       * to fnd out what's going to get deleted, and then switch to
++       *    find dirs   .... -prune ..... -delete
++       * once we are happy.  Unfortunately, the -delete action also
++       * implicitly turns on -depth, which will affect the behaviour
++       * of -prune (in fact, it makes it a no-op).  In this case we 
++       * would like to prevent unfortunate accidents, so we require 
++       * the user to have explicitly used -depth.
++       *
++       * We only get away with this because the -delete predicate is not 
++       * in POSIX.   If it was, we couldn't issue a fatal error here.
++       */
++      if (!options.explicit_depth) 
++	{
++	  /* This fixes Savannah bug #20865. */
++	  error (1, 0, _("The -delete action atomatically turns on -depth, "
++			 "but -prune does nothing when -depth is in effect.  "
++			 "If you want to carry on anyway, just explicitly use "
++			 "the -depth option."));
++	}
++    }
++}
++
++
++static const struct parser_table*
++get_noop(void)
++{
++  int i;
++  if (NULL == noop)
++    {
++      for (i = 0; parse_table[i].parser_name != 0; i++)
++	{
++	  if (ARG_NOOP ==parse_table[i].type)
++	    {
++	      noop = &(parse_table[i]);
++	      break;
++	    }
++	}
++    }
++  return noop;
++}
++
++static int
++get_stat_Ytime(const struct stat *p,
++	       char what,
++	       struct timespec *ret)
++{
++  switch (what)
++    {
++    case 'a':
++      *ret = get_stat_atime(p);
++      return 1;
++    case 'B':
++      *ret = get_stat_birthtime(p);
++      return (ret->tv_nsec >= 0);
++    case 'c':
++      *ret = get_stat_ctime(p);
++      return 1;
++    case 'm':
++      *ret = get_stat_mtime(p);
++      return 1;
++    default:
++      assert (0);
++      abort();
++    }
++}
++
++void 
++set_follow_state(enum SymlinkOption opt)
++{
++  if (options.debug_options & DebugStat)
++    {
++      /* For DebugStat, the choice is made at runtime within debug_stat()
++       * by checking the contents of the symlink_handling variable.
++       */
++      options.xstat = debug_stat;
++    }
++  else
++    {
++      switch (opt)
++	{
++	case SYMLINK_ALWAYS_DEREF:  /* -L */
++	  options.xstat = optionl_stat;
++	  options.no_leaf_check = true;
++	  break;
++	  
++	case SYMLINK_NEVER_DEREF:	/* -P (default) */
++	  options.xstat = optionp_stat;
++	  /* Can't turn no_leaf_check off because the user might have specified 
++	   * -noleaf anyway
++	   */
++	  break;
++	  
++	case SYMLINK_DEREF_ARGSONLY: /* -H */
++	  options.xstat = optionh_stat;
++	  options.no_leaf_check = true;
++	}
++    }
++  options.symlink_handling = opt;
++}
++
++
++void
++parse_begin_user_args (char **args, int argno,
++		       const struct predicate *last,
++		       const struct predicate *predicates)
++{
++  (void) args;
++  (void) argno;
++  (void) last;
++  (void) predicates;
++  first_nonoption_arg = NULL;
++}
++
++void 
++parse_end_user_args (char **args, int argno,
++		     const struct predicate *last,
++		     const struct predicate *predicates)
++{
++  /* does nothing */
++  (void) args;
++  (void) argno;
++  (void) last;
++  (void) predicates;
++}
++
++
++/* Check that it is legal to fid the given primary in its
++ * position and return it.
++ */
++const struct parser_table*
++found_parser(const char *original_arg, const struct parser_table *entry)
++{
++  /* If this is an option, but we have already had a 
++   * non-option argument, the user may be under the 
++   * impression that the behaviour of the option 
++   * argument is conditional on some preceding 
++   * tests.  This might typically be the case with,
++   * for example, -maxdepth.
++   *
++   * The options -daystart and -follow are exempt 
++   * from this treatment, since their positioning
++   * in the command line does have an effect on 
++   * subsequent tests but not previous ones.  That
++   * might be intentional on the part of the user.
++   */
++  if (entry->type != ARG_POSITIONAL_OPTION)
++    {
++      /* Something other than -follow/-daystart.
++       * If this is an option, check if it followed
++       * a non-option and if so, issue a warning.
++       */
++      if (entry->type == ARG_OPTION)
++	{
++	  if ((first_nonoption_arg != NULL)
++	      && options.warnings )
++	    {
++	      /* option which follows a non-option */
++	      error (0, 0,
++		     _("warning: you have specified the %1$s "
++		       "option after a non-option argument %2$s, "
++		       "but options are not positional (%3$s affects "
++		       "tests specified before it as well as those "
++		       "specified after it).  Please specify options "
++		       "before other arguments.\n"),
++		     original_arg,
++		     first_nonoption_arg,
++		     original_arg);
++	    }
++	}
++      else
++	{
++	  /* Not an option or a positional option,
++	   * so remember we've seen it in order to 
++	   * use it in a possible future warning message.
++	   */
++	  if (first_nonoption_arg == NULL)
++	    {
++	      first_nonoption_arg = original_arg;
++	    }
++	}
++    }
++	  
++  return entry;
++}
++
++
++/* Return a pointer to the parser function to invoke for predicate
++   SEARCH_NAME.
++   Return NULL if SEARCH_NAME is not a valid predicate name. */
++
++const struct parser_table*
++find_parser (char *search_name)
++{
++  int i;
++  const char *original_arg = search_name;
++  
++  /* Ugh.  Special case -newerXY. */
++  if (0 == strncmp("-newer", search_name, 6)
++      && (8 == strlen(search_name)))
++    {
++      return found_parser(original_arg, &parse_entry_newerXY);
++    }
++  
++  if (*search_name == '-')
++    search_name++;
++
++  for (i = 0; parse_table[i].parser_name != 0; i++)
++    {
++      if (strcmp (parse_table[i].parser_name, search_name) == 0)
++	{
++	  return found_parser(original_arg, &parse_table[i]);
++	}
++    }
++  return NULL;
++}
++
++static float 
++estimate_file_age_success_rate(float num_days)
++{
++  if (num_days < 0.1)
++    {
++      /* Assume 1% of files have timestamps in the future */
++      return 0.01f;		
++    }
++  else if (num_days < 1)
++    {
++      /* Assume 30% of files have timestamps today */
++      return 0.3f;
++    }
++  else if (num_days > 100)
++    {
++      /* Assume 30% of files are very old */
++      return 0.3f;
++    }
++  else 
++    {
++      /* Assume 39% of files are between 1 and 100 days old. */
++      return 0.39f;
++    }
++}
++
++static float 
++estimate_timestamp_success_rate(time_t when)
++{
++  int num_days = (options.cur_day_start - when) / 86400;
++  return estimate_file_age_success_rate(num_days);
++}
++
++/* Collect an argument from the argument list, or 
++ * return false.
++ */
++static boolean
++collect_arg(char **argv, int *arg_ptr, const char **collected_arg)
++{
++  if ((argv == NULL) || (argv[*arg_ptr] == NULL))
++    {
++      *collected_arg = NULL;
++      return false;
++    }
++  else
++    {
++      *collected_arg = argv[*arg_ptr];
++      (*arg_ptr)++;
++      return true;
++    }
++}
++
++static boolean 
++collect_arg_stat_info(char **argv, int *arg_ptr, struct stat *p)
++{
++  const char *filename;
++  if (collect_arg(argv, arg_ptr, &filename))
++    {
++      if (0 == (options.xstat)(filename, p))
++	{
++	  return true;
++	}
++      else
++	{
++	  fatal_file_error(filename);
++	}
++    }
++  else
++    {
++      return false;
++    }
++}
++
++/* The parsers are responsible to continue scanning ARGV for
++   their arguments.  Each parser knows what is and isn't
++   allowed for itself.
++   
++   ARGV is the argument array.
++   *ARG_PTR is the index to start at in ARGV,
++   updated to point beyond the last element consumed.
++ 
++   The predicate structure is updated with the new information. */
++
++
++static boolean
++parse_and (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  struct predicate *our_pred;
++
++  (void) argv;
++  (void) arg_ptr;
++  
++  our_pred = get_new_pred (entry);
++  our_pred->pred_func = pred_and;
++  our_pred->p_type = BI_OP;
++  our_pred->p_prec = AND_PREC;
++  our_pred->need_stat = our_pred->need_type = false;
++  return true;
++}
++
++static boolean
++parse_anewer (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  struct stat stat_newer;
++
++  set_stat_placeholders(&stat_newer);
++  if (collect_arg_stat_info(argv, arg_ptr, &stat_newer))
++    {
++      struct predicate *our_pred = insert_primary (entry);
++      our_pred->args.reftime.xval = XVAL_ATIME;
++      our_pred->args.reftime.ts = get_stat_mtime(&stat_newer);
++      our_pred->args.reftime.kind = COMP_GT;
++      our_pred->est_success_rate = estimate_timestamp_success_rate(stat_newer.st_mtime);
++      return true;
++    }
++  return false;
++}
++
++boolean
++parse_closeparen (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  struct predicate *our_pred;
++
++  (void) argv;
++  (void) arg_ptr;
++  
++  our_pred = get_new_pred (entry);
++  our_pred->pred_func = pred_closeparen;
++  our_pred->p_type = CLOSE_PAREN;
++  our_pred->p_prec = NO_PREC;
++  our_pred->need_stat = our_pred->need_type = false;
++  return true;
++}
++
++static boolean
++parse_cnewer (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  struct stat stat_newer;
++
++  set_stat_placeholders(&stat_newer);
++  if (collect_arg_stat_info(argv, arg_ptr, &stat_newer))
++    {
++      struct predicate *our_pred = insert_primary (entry);
++      our_pred->args.reftime.xval = XVAL_CTIME; /* like -newercm */
++      our_pred->args.reftime.ts = get_stat_mtime(&stat_newer);
++      our_pred->args.reftime.kind = COMP_GT;
++      our_pred->est_success_rate = estimate_timestamp_success_rate(stat_newer.st_mtime);
++      return true;
++    }
++  return false;
++}
++
++static boolean
++parse_comma (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  struct predicate *our_pred;
++
++  (void) argv;
++  (void) arg_ptr;
++
++  our_pred = get_new_pred (entry);
++  our_pred->pred_func = pred_comma;
++  our_pred->p_type = BI_OP;
++  our_pred->p_prec = COMMA_PREC;
++  our_pred->need_stat = our_pred->need_type = false;
++  our_pred->est_success_rate = 1.0f;
++  return true;
++}
++
++static boolean
++parse_daystart (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  struct tm *local;
++
++  (void) entry;
++  (void) argv;
++  (void) arg_ptr;
++
++  if (options.full_days == false)
++    {
++      options.cur_day_start += DAYSECS;
++      local = localtime (&options.cur_day_start);
++      options.cur_day_start -= (local
++			? (local->tm_sec + local->tm_min * 60
++			   + local->tm_hour * 3600)
++			: options.cur_day_start % DAYSECS);
++      options.full_days = true;
++    }
++  return true;
++}
++
++static boolean
++parse_delete (const struct parser_table* entry, char *argv[], int *arg_ptr)
++{
++  struct predicate *our_pred;
++  (void) argv;
++  (void) arg_ptr;
++
++  our_pred = insert_primary (entry);
++  our_pred->side_effects = our_pred->no_default_print = true;
++  /* -delete implies -depth */
++  options.do_dir_first = false;
++  
++  /* We do not need stat information because we check for the case
++   * (errno==EISDIR) in pred_delete.
++   */
++  our_pred->need_stat = our_pred->need_type = false;
++  
++  our_pred->est_success_rate = 1.0f;
++  return true;
++}
++
++static boolean
++parse_depth (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  (void) entry;
++  (void) argv;
++
++  options.do_dir_first = false;
++  options.explicit_depth = true;
++  return parse_noop(entry, argv, arg_ptr);
++}
++ 
++static boolean
++parse_d (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  if (options.warnings)
++    {
++      error (0, 0,
++	     _("warning: the -d option is deprecated; please use "
++	       "-depth instead, because the latter is a "
++	       "POSIX-compliant feature."));
++    }
++  return parse_depth(entry, argv, arg_ptr);
++}
++ 
++static boolean
++parse_empty (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  struct predicate *our_pred;
++  (void) argv;
++  (void) arg_ptr;
++
++  our_pred = insert_primary (entry);
++  our_pred->est_success_rate = 0.01f; /* assume 1% of files are empty. */
++  return true;
++}
++
++static boolean
++parse_exec (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  return insert_exec_ok ("-exec", entry, get_start_dirfd(), argv, arg_ptr);
++}
++
++static boolean
++parse_execdir (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  return insert_exec_ok ("-execdir", entry, -1, argv, arg_ptr);
++}
++
++static boolean
++parse_false (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  struct predicate *our_pred;
++  
++  (void) argv;
++  (void) arg_ptr;
++
++  our_pred = insert_primary (entry);
++  our_pred->need_stat = our_pred->need_type = false;
++  our_pred->side_effects = our_pred->no_default_print = false;
++  our_pred->est_success_rate = 0.0f;
++  return true;
++}
++
++static boolean
++insert_fls (const struct parser_table* entry, const char *filename)
++{
++  struct predicate *our_pred = insert_primary (entry);
++  if (filename)
++    open_output_file (filename, &our_pred->args.printf_vec);
++  else
++    open_stdout (&our_pred->args.printf_vec);
++  our_pred->side_effects = our_pred->no_default_print = true;
++  our_pred->est_success_rate = 1.0f;
++  return true;
++}
++
++
++static boolean
++parse_fls (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  const char *filename;
++  return collect_arg(argv, arg_ptr, &filename)
++    &&  insert_fls(entry, filename);
++}
++
++static boolean
++parse_follow (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  set_follow_state(SYMLINK_ALWAYS_DEREF);
++  return parse_noop(entry, argv, arg_ptr);
++}
++
++static boolean
++parse_fprint (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  struct predicate *our_pred;
++  const char *filename;
++  if (collect_arg(argv, arg_ptr, &filename))
++    {
++      our_pred = insert_primary (entry);
++      open_output_file (filename, &our_pred->args.printf_vec);
++      our_pred->side_effects = our_pred->no_default_print = true;
++      our_pred->need_stat = our_pred->need_type = false;
++      our_pred->est_success_rate = 1.0f;
++      return true;
++    }
++  else
++    {
++      return false;
++    }
++}
++
++static boolean 
++insert_fprint(const struct parser_table* entry, const char *filename)
++{
++  struct predicate *our_pred = insert_primary (entry);
++  if (filename)
++    open_output_file (filename, &our_pred->args.printf_vec);
++  else
++    open_stdout (&our_pred->args.printf_vec);
++  our_pred->side_effects = our_pred->no_default_print = true;
++  our_pred->need_stat = our_pred->need_type = false;
++  our_pred->est_success_rate = 1.0f;
++  return true;
++}
++
++
++static boolean
++parse_fprint0 (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  const char *filename;
++  if (collect_arg(argv, arg_ptr, &filename))
++    return insert_fprint(entry, filename);
++  else
++    return false;
++}
++
++static float estimate_fstype_success_rate(const char *fsname)
++{
++  struct stat dir_stat;
++  const char *dir = "/";
++  if (0 == stat(dir, &dir_stat))
++    {
++      const char *fstype = filesystem_type(&dir_stat, dir);
++      /* Assume most files are on the same file system type as the root fs. */
++      if (0 == strcmp(fsname, fstype))
++	  return 0.7f;
++      else
++	return 0.3f;
++    }
++  return 1.0f;
++}
++
++
++static boolean
++parse_fstype (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  const char *typename;
++  if (collect_arg(argv, arg_ptr, &typename))
++    {
++      struct predicate *our_pred = insert_primary (entry);
++      our_pred->args.str = typename;
++
++      /* This is an expensive operation, so although there are
++       * circumstances where it is selective, we ignore this fact
++       * because we probably don't want to promote this test to the
++       * front anyway.
++       */
++      our_pred->est_success_rate = estimate_fstype_success_rate(typename);
++      return true;
++    }
++  else
++    {
++      return false;
++    }
++}
++
++static boolean
++parse_gid (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  struct predicate *p = insert_num (argv, arg_ptr, entry);
++  if (p)
++    {
++      p->est_success_rate = (p->args.numinfo.l_val < 100) ? 0.99 : 0.2;
++      return true;
++    }
++  else
++    {
++      return false;
++    }
++}
++
++
++static int
++safe_atoi (const char *s)
++{
++  long lval;
++  char *end;
++  
++  errno = 0;
++  lval = strtol(s, &end, 10);
++  if ( (LONG_MAX == lval) || (LONG_MIN == lval) )
++    {
++      /* max/min possible value, or an error. */
++      if (errno == ERANGE)
++	{
++	  /* too big, or too small. */
++	  error(1, errno, "%s", s);
++	}
++      else
++	{
++	  /* not a valid number */
++	  error(1, errno, "%s", s);
++	}
++      /* Otherwise, we do a range chack against INT_MAX and INT_MIN
++       * below.
++       */
++    }
++  
++  if (lval > INT_MAX || lval < INT_MIN)
++    {
++      /* The number was in range for long, but not int. */
++      errno = ERANGE;
++      error(1, errno, "%s", s);
++    }
++  else if (*end)
++    {
++      error(1, errno, "Unexpected suffix %s on %s",
++	    quotearg_n_style(0, options.err_quoting_style, end),
++	    quotearg_n_style(1, options.err_quoting_style, s));
++    }
++  else if (end == s)
++    {
++      error(1, errno, "Expected an integer: %s", 
++	    quotearg_n_style(0, options.err_quoting_style, s));
++    }
++  return (int)lval;
++}
++
++
++static boolean
++parse_group (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  const char *groupname;
++
++  if (collect_arg(argv, arg_ptr, &groupname))
++    {
++      gid_t gid;
++      struct predicate *our_pred;
++      struct group *cur_gr = getgrnam(groupname);
++      endgrent();
++      if (cur_gr)
++	{
++	  gid = cur_gr->gr_gid;
++	}
++      else
++	{
++	  const int gid_len = strspn (groupname, "0123456789");
++	  if (gid_len)
++	    {
++	      if (groupname[gid_len] == 0)
++		{
++		  gid = safe_atoi (groupname);
++		}
++	      else
++		{
++		  /* XXX: no test in test suite for this */
++		  error(1, 0, _("%1$s is not the name of an existing group and"
++				" it does not look like a numeric group ID "
++				"because it has the unexpected suffix %2$s"),
++			quotearg_n_style(0, options.err_quoting_style, groupname),
++			quotearg_n_style(1, options.err_quoting_style, groupname+gid_len));
++		  return false;
++		}
++	    }
++	  else
++	    {
++	      if (*groupname)
++		{
++		  /* XXX: no test in test suite for this */
++		  error(1, 0, _("%s is not the name of an existing group"),
++			quotearg_n_style(0, options.err_quoting_style, groupname));
++		}
++	      else
++		{
++		  error(1, 0, _("argument to -group is empty, but should be a group name"));
++		}
++	      return false;
++	    }
++	}
++      our_pred = insert_primary (entry);
++      our_pred->args.gid = gid;
++      our_pred->est_success_rate = (our_pred->args.numinfo.l_val < 100) ? 0.99 : 0.2;
++      return true;
++    }
++  return false;
++}
++
++static boolean
++parse_help (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  (void) entry;
++  (void) argv;
++  (void) arg_ptr;
++
++  usage(stdout, 0, NULL);
++  puts (_("\n\
++default path is the current directory; default expression is -print\n\
++expression may consist of: operators, options, tests, and actions:\n"));
++  puts (_("\
++operators (decreasing precedence; -and is implicit where no others are given):\n\
++      ( EXPR )   ! EXPR   -not EXPR   EXPR1 -a EXPR2   EXPR1 -and EXPR2\n\
++      EXPR1 -o EXPR2   EXPR1 -or EXPR2   EXPR1 , EXPR2\n"));
++  puts (_("\
++positional options (always true): -daystart -follow -regextype\n\n\
++normal options (always true, specified before other expressions):\n\
++      -depth --help -maxdepth LEVELS -mindepth LEVELS -mount -noleaf\n\
++      --version -xdev -ignore_readdir_race -noignore_readdir_race\n"));
++  puts (_("\
++tests (N can be +N or -N or N): -amin N -anewer FILE -atime N -cmin N\n\
++      -cnewer FILE -ctime N -empty -false -fstype TYPE -gid N -group NAME\n\
++      -ilname PATTERN -iname PATTERN -inum N -iwholename PATTERN -iregex PATTERN\n\
++      -links N -lname PATTERN -mmin N -mtime N -name PATTERN -newer FILE"));
++  puts (_("\
++      -nouser -nogroup -path PATTERN -perm [+-]MODE -regex PATTERN\n\
++      -readable -writable -executable\n\
++      -wholename PATTERN -size N[bcwkMG] -true -type [bcdpflsD] -uid N\n\
++      -used N -user NAME -xtype [bcdpfls]\n"));
++  puts (_("\
++actions: -delete -print0 -printf FORMAT -fprintf FILE FORMAT -print \n\
++      -fprint0 FILE -fprint FILE -ls -fls FILE -prune -quit\n\
++      -exec COMMAND ; -exec COMMAND {} + -ok COMMAND ;\n\
++      -execdir COMMAND ; -execdir COMMAND {} + -okdir COMMAND ;\n\
++"));
++  puts (_("Report (and track progress on fixing) bugs via the findutils bug-reporting\n\
++page at http://savannah.gnu.org/ or, if you have no web access, by sending\n\
++email to <bug-findutils@gnu.org>."));
++  exit (0);
++}
++
++static float
++estimate_pattern_match_rate(const char *pattern, int is_regex)
++{
++  if (strpbrk(pattern, "*?[") || (is_regex && strpbrk(pattern, ".")))
++    {
++      /* A wildcard; assume the pattern matches most files. */
++      return 0.8f;
++    }
++  else
++    {
++      return 0.1f;
++    }
++}
++
++static boolean
++parse_ilname (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  const char *name;
++  if (collect_arg(argv, arg_ptr, &name))
++    {
++      struct predicate *our_pred = insert_primary (entry);
++      our_pred->args.str = name;
++      /* Use the generic glob pattern estimator to figure out how many 
++       * links will match, but bear in mind that most files won't be links.
++       */
++      our_pred->est_success_rate = 0.1 * estimate_pattern_match_rate(name, 0);
++      return true;
++    }
++  else
++    {
++      return false;
++    }
++}
++
++
++/* sanity check the fnmatch() function to make sure that case folding
++ * is supported (as opposed to just having the flag ignored).
++ */
++static boolean 
++fnmatch_sanitycheck(void)
++{
++  static boolean checked = false;
++  if (!checked)
++    {
++      if (0 != fnmatch("foo", "foo", 0)
++	  || 0 == fnmatch("Foo", "foo", 0)
++	  || 0 != fnmatch("Foo", "foo", FNM_CASEFOLD))
++	{
++	  error (1, 0, _("sanity check of the fnmatch() library function failed."));
++	  return false;
++	}
++      checked = true;
++    }
++  return checked;
++}
++
++
++static boolean
++check_name_arg(const char *pred, const char *arg)
++{
++  if (options.warnings && strchr(arg, '/'))
++    {
++      error(0, 0,_("warning: Unix filenames usually don't contain slashes "
++		   "(though pathnames do).  That means that '%s %s' will "
++		   "probably evaluate to false all the time on this system.  "
++		   "You might find the '-wholename' test more useful, or "
++		   "perhaps '-samefile'.  Alternatively, if you are using "
++		   "GNU grep, you could "
++		   "use 'find ... -print0 | grep -FzZ %s'."),
++	    pred,
++	    safely_quote_err_filename(0, arg),
++	    safely_quote_err_filename(1, arg));
++    }
++  return true;			/* allow it anyway */
++}
++
++
++
++static boolean
++parse_iname (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  const char *name;
++  fnmatch_sanitycheck();
++  if (collect_arg(argv, arg_ptr, &name))
++    {
++      if (check_name_arg("-iname", name))
++	{
++	  struct predicate *our_pred = insert_primary (entry);
++	  our_pred->need_stat = our_pred->need_type = false;
++	  our_pred->args.str = name;
++	  our_pred->est_success_rate = estimate_pattern_match_rate(name, 0);
++	  return true;
++	}
++    }
++  return false;
++}
++
++static boolean
++parse_inum (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  struct predicate *p =  insert_num (argv, arg_ptr, entry);
++  if (p)
++    {
++      /* inode number is exact match only, so very low proportions of
++       * files match
++       */
++      p->est_success_rate = 1e-6;
++      return true;
++    }
++  else
++    {
++      return false;
++    }
++}
++
++/* -ipath is deprecated (at RMS's request) in favour of 
++ * -iwholename.   See the node "GNU Manuals" in standards.texi
++ * for the rationale for this (basically, GNU prefers the use 
++ * of the phrase "file name" to "path name"
++ */
++static boolean
++parse_ipath (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  const char *name;
++
++  fnmatch_sanitycheck ();
++  if (collect_arg (argv, arg_ptr, &name))
++    {
++      struct predicate *our_pred = insert_primary_withpred (entry, pred_ipath);
++      our_pred->need_stat = our_pred->need_type = false;
++      our_pred->args.str = name;
++      our_pred->est_success_rate = estimate_pattern_match_rate (name, 0);
++      return true;
++    }
++  return false;
++}
++
++static boolean
++parse_iwholename (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  return parse_ipath (entry, argv, arg_ptr);
++}
++
++static boolean
++parse_iregex (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  return insert_regex (argv, arg_ptr, entry, RE_ICASE|options.regex_options);
++}
++
++static boolean
++parse_links (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  struct predicate *p = insert_num (argv, arg_ptr, entry);
++  if (p)
++    {
++      if (p->args.numinfo.l_val == 1)
++	p->est_success_rate = 0.99;
++      else if (p->args.numinfo.l_val == 2)
++	p->est_success_rate = 0.01;
++      else
++	p->est_success_rate = 1e-3;
++      return true;
++    }
++  else
++    {
++      return false;
++    }
++}
++
++static boolean
++parse_lname (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  const char *name;
++  fnmatch_sanitycheck();
++  if (collect_arg(argv, arg_ptr, &name))
++    {
++      struct predicate *our_pred = insert_primary (entry);
++      our_pred->args.str = name;
++      our_pred->est_success_rate = 0.1 * estimate_pattern_match_rate(name, 0);
++      return true;
++    }
++  return false;
++}
++
++static boolean
++parse_ls (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  (void) &argv;
++  (void) &arg_ptr;
++  return insert_fls(entry, NULL);
++}
++
++static boolean
++insert_depthspec(const struct parser_table* entry, char **argv, int *arg_ptr,
++		 int *limitptr)
++{
++  const char *depthstr;
++  int depth_len;
++  const char *predicate = argv[(*arg_ptr)-1];
++  if (collect_arg(argv, arg_ptr, &depthstr))
++    {
++      depth_len = strspn (depthstr, "0123456789");
++      if ((depth_len > 0) && (depthstr[depth_len] == 0))
++	{
++	  (*limitptr) = safe_atoi (depthstr);
++	  if (*limitptr >= 0)
++	    {
++	      return parse_noop(entry, argv, arg_ptr);
++	    }
++	}
++      error(1, 0, _("Expected a positive decimal integer argument to %1$s, but got %2$s"),
++	    predicate,
++	    quotearg_n_style(0, options.err_quoting_style, depthstr));
++      return false;
++    }
++  /* missing argument */
++  return false;
++}
++
++
++static boolean
++parse_maxdepth (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  return insert_depthspec(entry, argv, arg_ptr, &options.maxdepth);
++}
++
++static boolean
++parse_mindepth (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  return insert_depthspec(entry, argv, arg_ptr, &options.mindepth);
++}
++
++
++static boolean
++do_parse_xmin (const struct parser_table* entry,
++	       char **argv,
++	       int *arg_ptr,
++	       enum xval xv)
++{
++  const char *minutes;
++
++  if (collect_arg(argv, arg_ptr, &minutes))
++    {
++      struct time_val tval;
++      tval.xval = xv;
++      if (get_relative_timestamp(minutes, &tval,
++				 options.cur_day_start + DAYSECS, 60,
++				 "arithmetic overflow while converting %s "
++				 "minutes to a number of seconds"))
++	{
++	  struct predicate *our_pred = insert_primary (entry);
++	  our_pred->args.reftime = tval;
++	  our_pred->est_success_rate = estimate_timestamp_success_rate(tval.ts.tv_sec);
++	  return true;
++	}
++    }
++  return false;
++}
++static boolean
++parse_amin (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  return do_parse_xmin(entry, argv, arg_ptr, XVAL_ATIME);
++}
++
++static boolean
++parse_cmin (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  return do_parse_xmin(entry, argv, arg_ptr, XVAL_CTIME);
++}
++
++
++static boolean
++parse_mmin (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  return do_parse_xmin(entry, argv, arg_ptr, XVAL_MTIME);
++}
++
++static boolean
++parse_name (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  const char *name;
++  if (collect_arg(argv, arg_ptr, &name))
++    {
++      fnmatch_sanitycheck();
++      if (check_name_arg("-name", name))
++	{
++	  struct predicate *our_pred = insert_primary (entry);
++	  our_pred->need_stat = our_pred->need_type = false;
++	  our_pred->args.str = name;
++	  our_pred->est_success_rate = estimate_pattern_match_rate(name, 0);
++	  return true;
++	}
++    }
++  return false;
++}
++
++static boolean
++parse_negate (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  struct predicate *our_pred;
++
++  (void) &argv;
++  (void) &arg_ptr;
++
++  our_pred = get_new_pred_chk_op (entry);
++  our_pred->pred_func = pred_negate;
++  our_pred->p_type = UNI_OP;
++  our_pred->p_prec = NEGATE_PREC;
++  our_pred->need_stat = our_pred->need_type = false;
++  return true;
++}
++
++static boolean
++parse_newer (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  struct predicate *our_pred;
++  struct stat stat_newer;
++
++  set_stat_placeholders(&stat_newer);
++  if (collect_arg_stat_info(argv, arg_ptr, &stat_newer))
++    {
++      our_pred = insert_primary (entry);
++      our_pred->args.reftime.ts = get_stat_mtime(&stat_newer);
++      our_pred->args.reftime.xval = XVAL_MTIME;
++      our_pred->args.reftime.kind = COMP_GT;
++      our_pred->est_success_rate = estimate_timestamp_success_rate(stat_newer.st_mtime);
++      return true;
++    }
++  return false;
++}
++
++
++static boolean
++parse_newerXY (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  (void) argv;
++  (void) arg_ptr;
++
++  if ((argv == NULL) || (argv[*arg_ptr] == NULL))
++    {
++      return false;
++    }
++  else if (8u != strlen(argv[*arg_ptr]))
++    {
++      return false;
++    }
++  else 
++    {
++      char x, y;
++      const char validchars[] = "aBcmt";
++      
++      assert (0 == strncmp("-newer", argv[*arg_ptr], 6));
++      x = argv[*arg_ptr][6];
++      y = argv[*arg_ptr][7];
++
++
++#if !defined(HAVE_STRUCT_STAT_ST_BIRTHTIME) && !defined(HAVE_STRUCT_STAT_ST_BIRTHTIMENSEC) && !defined(HAVE_STRUCT_STAT_ST_BIRTHTIMESPEC_TV_NSEC)
++      if ('B' == x || 'B' == y)
++	{
++	  error(0, 0,
++		_("This system does not provide a way to find the birth time of a file."));
++	  return 0;
++	}
++#endif
++      
++      /* -newertY (for any Y) is invalid. */
++      if (x == 't'
++	  || 0 == strchr(validchars, x)
++	  || 0 == strchr( validchars, y))
++	{
++	  return false;
++	}
++      else
++	{
++	  struct predicate *our_pred;
++	  
++	  /* Because this item is ARG_SPECIAL_PARSE, we have to advance arg_ptr
++	   * past the test name (for most other tests, this is already done)
++	   */
++	  (*arg_ptr)++;
++	  
++	  our_pred = insert_primary (entry);
++
++
++	  switch (x)
++	    {
++	    case 'a':
++	      our_pred->args.reftime.xval = XVAL_ATIME;
++	      break;
++	    case 'B':
++	      our_pred->args.reftime.xval = XVAL_BIRTHTIME;
++	      break;
++	    case 'c':
++	      our_pred->args.reftime.xval = XVAL_CTIME;
++	      break;
++	    case 'm':
++	      our_pred->args.reftime.xval = XVAL_MTIME;
++	      break;
++	    default:
++	      assert (strchr(validchars, x));
++	      assert (0);
++	    }
++	  
++	  if ('t' == y)
++	    {
++	      if (!get_date(&our_pred->args.reftime.ts,
++			    argv[*arg_ptr],
++			    &options.start_time))
++		{
++		  error(1, 0,
++			_("I cannot figure out how to interpret %s as a date or time"),
++			quotearg_n_style(0, options.err_quoting_style, argv[*arg_ptr]));
++		}
++	    }
++	  else
++	    {
++	      struct stat stat_newer;
++	      
++	      /* Stat the named file. */
++	      set_stat_placeholders(&stat_newer);
++	      if ((*options.xstat) (argv[*arg_ptr], &stat_newer))
++		fatal_file_error(argv[*arg_ptr]);
++	      
++	      if (!get_stat_Ytime(&stat_newer, y, &our_pred->args.reftime.ts))
++		{
++		  /* We cannot extract a timestamp from the struct stat. */
++		  error(1, 0, _("Cannot obtain birth time of file %s"),
++			safely_quote_err_filename(0, argv[*arg_ptr]));
++		}
++	    }
++	  our_pred->args.reftime.kind = COMP_GT;
++	  our_pred->est_success_rate = estimate_timestamp_success_rate(our_pred->args.reftime.ts.tv_sec);
++	  (*arg_ptr)++;
++	  
++	  assert (our_pred->pred_func != NULL);
++	  assert (our_pred->pred_func == pred_newerXY);
++	  assert (our_pred->need_stat);
++	  return true;
++	}
++    }
++}
++
++
++static boolean
++parse_noleaf (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  options.no_leaf_check = true;
++  return parse_noop(entry, argv, arg_ptr);
++}
++
++#ifdef CACHE_IDS
++/* Arbitrary amount by which to increase size
++   of `uid_unused' and `gid_unused'. */
++#define ALLOC_STEP 2048
++
++/* Boolean: if uid_unused[n] is nonzero, then UID n has no passwd entry. */
++char *uid_unused = NULL;
++
++/* Number of elements in `uid_unused'. */
++unsigned uid_allocated;
++
++/* Similar for GIDs and group entries. */
++char *gid_unused = NULL;
++unsigned gid_allocated;
++#endif
++
++static boolean
++parse_nogroup (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  struct predicate *our_pred;
++
++  (void) &argv;
++  (void) &arg_ptr;
++  
++  our_pred = insert_primary (entry);
++  our_pred->est_success_rate = 1e-4;
++#ifdef CACHE_IDS
++  if (gid_unused == NULL)
++    {
++      struct group *gr;
++
++      gid_allocated = ALLOC_STEP;
++      gid_unused = xmalloc (gid_allocated);
++      memset (gid_unused, 1, gid_allocated);
++      setgrent ();
++      while ((gr = getgrent ()) != NULL)
++	{
++	  if ((unsigned) gr->gr_gid >= gid_allocated)
++	    {
++	      unsigned new_allocated = (unsigned) gr->gr_gid + ALLOC_STEP;
++	      gid_unused = xrealloc (gid_unused, new_allocated);
++	      memset (gid_unused + gid_allocated, 1,
++		      new_allocated - gid_allocated);
++	      gid_allocated = new_allocated;
++	    }
++	  gid_unused[(unsigned) gr->gr_gid] = 0;
++	}
++      endgrent ();
++    }
++#endif
++  return true;
++}
++
++static boolean
++parse_nouser (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  struct predicate *our_pred;
++  (void) argv;
++  (void) arg_ptr;
++  
++
++  our_pred = insert_primary (entry);
++  our_pred->est_success_rate = 1e-3;
++#ifdef CACHE_IDS
++  if (uid_unused == NULL)
++    {
++      struct passwd *pw;
++
++      uid_allocated = ALLOC_STEP;
++      uid_unused = xmalloc (uid_allocated);
++      memset (uid_unused, 1, uid_allocated);
++      setpwent ();
++      while ((pw = getpwent ()) != NULL)
++	{
++	  if ((unsigned) pw->pw_uid >= uid_allocated)
++	    {
++	      unsigned new_allocated = (unsigned) pw->pw_uid + ALLOC_STEP;
++	      uid_unused = xrealloc (uid_unused, new_allocated);
++	      memset (uid_unused + uid_allocated, 1,
++		      new_allocated - uid_allocated);
++	      uid_allocated = new_allocated;
++	    }
++	  uid_unused[(unsigned) pw->pw_uid] = 0;
++	}
++      endpwent ();
++    }
++#endif
++  return true;
++}
++
++static boolean
++parse_nowarn (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  options.warnings = false;
++  return parse_noop(entry, argv, arg_ptr);
++}
++
++static boolean
++parse_ok (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  return insert_exec_ok ("-ok", entry, get_start_dirfd(), argv, arg_ptr);
++}
++
++static boolean
++parse_okdir (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  return insert_exec_ok ("-okdir", entry, -1, argv, arg_ptr);
++}
++
++boolean
++parse_openparen (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  struct predicate *our_pred;
++
++  (void) argv;
++  (void) arg_ptr;
++  
++  our_pred = get_new_pred_chk_op (entry);
++  our_pred->pred_func = pred_openparen;
++  our_pred->p_type = OPEN_PAREN;
++  our_pred->p_prec = NO_PREC;
++  our_pred->need_stat = our_pred->need_type = false;
++  return true;
++}
++
++static boolean
++parse_or (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  struct predicate *our_pred;
++
++  (void) argv;
++  (void) arg_ptr;
++  
++  our_pred = get_new_pred (entry);
++  our_pred->pred_func = pred_or;
++  our_pred->p_type = BI_OP;
++  our_pred->p_prec = OR_PREC;
++  our_pred->need_stat = our_pred->need_type = false;
++  return true;
++}
++
++/* For some time, -path was deprecated (at RMS's request) in favour of
++ * -iwholename.  See the node "GNU Manuals" in standards.texi for the
++ * rationale for this (basically, GNU prefers the use of the phrase
++ * "file name" to "path name".
++ *
++ * We do not issue a warning that this usage is deprecated
++ * since
++ * (a) HPUX find supports this predicate also and 
++ * (b) it will soon be in POSIX anyway.
++ */
++static boolean
++parse_path (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  const char *name;
++  if (collect_arg(argv, arg_ptr, &name))
++    {
++      struct predicate *our_pred = insert_primary_withpred (entry, pred_path);
++      our_pred->need_stat = our_pred->need_type = false;
++      our_pred->args.str = name;
++      our_pred->est_success_rate = estimate_pattern_match_rate (name, 0);
++      return true;
++    }
++  return false;
++}
++
++static boolean
++parse_wholename (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  return parse_path (entry, argv, arg_ptr);
++}
++
++static void
++non_posix_mode(const char *mode)
++{
++  if (options.posixly_correct)
++    {
++      error (1, 0, _("Mode %s is not valid when POSIXLY_CORRECT is on."),
++	     quotearg_n_style(0, options.err_quoting_style, mode));
++    }
++}
++
++
++static boolean
++parse_perm (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  mode_t perm_val[2];
++  float rate;
++  int mode_start = 0;
++  boolean havekind = false;
++  enum permissions_type kind = PERM_EXACT;
++  struct mode_change *change = NULL;
++  struct predicate *our_pred;
++  const char *perm_expr;
++
++  if (!collect_arg(argv, arg_ptr, &perm_expr))
++    return false;
++
++  switch (perm_expr[0])
++    {
++    case '-':
++      mode_start = 1;
++      kind = PERM_AT_LEAST;
++      havekind = true;
++      rate = 0.2;
++      break;
++      
++     case '+':
++       change = mode_compile (perm_expr);
++       if (NULL == change)
++	 {
++	   /* Most likely the caller is an old script that is still
++	    * using the obsolete GNU syntax '-perm +MODE'.  This old
++	    * syntax was withdrawn in favor of '-perm /MODE' because
++	    * it is incompatible with POSIX in some cases, but we
++	    * still support uses of it that are not incompatible with
++	    * POSIX.
++	    *
++	    * Example: POSIXLY_CORRECT=y find -perm +a+x
++	    */
++	   non_posix_mode(perm_expr);
++
++	   /* support the previous behaviour. */
++	   mode_start = 1;
++	   kind = PERM_ANY;
++	   rate = 0.3;
++	 }
++       else
++	 {
++	   /* This is a POSIX-compatible usage */
++	   mode_start = 0;
++	   kind = PERM_EXACT;
++	   rate = 0.1;
++	 }
++       havekind = true;
++       break;
++      
++    case '/':			/* GNU extension */
++      non_posix_mode(perm_expr);
++      mode_start = 1;
++      kind = PERM_ANY;
++      havekind = true;
++      rate = 0.3;
++      break;
++       
++    default:
++      /* For example, '-perm 0644', which is valid and matches 
++       * only files whose mode is exactly 0644.
++       */
++      mode_start = 0;
++      kind = PERM_EXACT;
++      havekind = true;
++      rate = 0.01;
++      break;
++    }
++
++  if (NULL == change)
++    {
++      change = mode_compile (perm_expr + mode_start);
++      if (NULL == change)
++	error (1, 0, _("invalid mode %s"
++		       /* TRANSLATORS: the argument is a 
++			* file permission string like 'u=rw,go='
++			*/),
++	       quotearg_n_style(0, options.err_quoting_style, perm_expr));
++    }
++  perm_val[0] = mode_adjust (0, false, 0, change, NULL);
++  perm_val[1] = mode_adjust (0, true, 0, change, NULL);
++  free (change);
++  
++  if (('/' == perm_expr[0]) && (0 == perm_val[0]) && (0 == perm_val[1]))
++    {
++      /* The meaning of -perm /000 will change in the future.  It
++       * currently matches no files, but like -perm -000 it should
++       * match all files.
++       *
++       * Starting in 2005, we used to issue a warning message
++       * informing the user that the behaviour would change in the
++       * future.  We have now changed the behaviour and issue a
++       * warning message that the behaviour recently changed.
++       */
++      error (0, 0,
++	     _("warning: you have specified a mode pattern %s (which is "
++	       "equivalent to /000). The meaning of -perm /000 has now been "
++	       "changed to be consistent with -perm -000; that is, while it "
++	       "used to match no files, it now matches all files."),
++	     perm_expr);
++      
++      kind = PERM_AT_LEAST;
++      havekind = true;
++
++      /* The "magic" number below is just the fraction of files on my 
++       * own system that "-type l -xtype l" fails for (i.e. unbroken symlinks).
++       * Actual totals are 1472 and 1073833.
++       */
++      rate = 0.9986; /* probably matches anything but a broken symlink */
++    }
++  
++  our_pred = insert_primary (entry);
++  our_pred->est_success_rate = rate;
++  if (havekind)
++    {
++      our_pred->args.perm.kind = kind;
++    }
++  else
++    {
++  
++      switch (perm_expr[0])
++	{
++	case '-':
++	  our_pred->args.perm.kind = PERM_AT_LEAST;
++	  break;
++	case '+':
++	  our_pred->args.perm.kind = PERM_ANY;
++	  break;
++	default:
++	  our_pred->args.perm.kind = PERM_EXACT;
++	  break;
++	}
++    }
++  memcpy (our_pred->args.perm.val, perm_val, sizeof perm_val);
++  return true;
++}
++
++boolean
++parse_print (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  struct predicate *our_pred;
++
++  (void) argv;
++  (void) arg_ptr;
++  
++  our_pred = insert_primary (entry);
++  /* -print has the side effect of printing.  This prevents us
++     from doing undesired multiple printing when the user has
++     already specified -print. */
++  our_pred->side_effects = our_pred->no_default_print = true;
++  our_pred->need_stat = our_pred->need_type = false;
++  open_stdout(&our_pred->args.printf_vec);
++  return true;
++}
++
++static boolean
++parse_print0 (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  return insert_fprint(entry, NULL);
++}
++
++static boolean
++parse_printf (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  const char *format;
++  if (collect_arg(argv, arg_ptr, &format))
++    {
++      struct format_val fmt;
++      open_stdout(&fmt);
++      return insert_fprintf (&fmt, entry, pred_fprintf, format);
++    }
++  return false;
++}
++
++static boolean 
++parse_fprintf (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  const char *format, *filename;
++  if (collect_arg(argv, arg_ptr, &filename))
++    {
++      if (collect_arg(argv, arg_ptr, &format))
++	{
++	  struct format_val fmt;
++	  open_output_file (filename, &fmt);
++	  return insert_fprintf (&fmt, entry, pred_fprintf, format);
++	}
++    }
++  return false;
++}
++
++static boolean
++parse_prune (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  struct predicate *our_pred;
++
++  (void) argv;
++  (void) arg_ptr;
++  
++  our_pred = insert_primary (entry);
++  our_pred->need_stat = our_pred->need_type = false;
++  /* -prune has a side effect that it does not descend into
++     the current directory. */
++  our_pred->side_effects = true;
++  our_pred->no_default_print = false;
++  return true;
++}
++
++static boolean 
++parse_quit  (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  struct predicate *our_pred = insert_primary (entry);
++  (void) argv;
++  (void) arg_ptr;
++  our_pred->need_stat = our_pred->need_type = false;
++  our_pred->side_effects = true; /* Exiting is a side effect... */
++  our_pred->no_default_print = false; /* Don't inhibit the default print, though. */
++  our_pred->est_success_rate = 1.0f;
++  return true;
++}
++
++
++static boolean 
++parse_regextype (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  const char *type_name;
++  if (collect_arg(argv, arg_ptr, &type_name))
++    {
++      /* collect the regex type name */
++      options.regex_options = get_regex_type(type_name);
++      return parse_noop(entry, argv, arg_ptr);
++    }
++  return false;
++}
++
++
++static boolean
++parse_regex (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  return insert_regex (argv, arg_ptr, entry, options.regex_options);
++}
++
++static boolean
++insert_regex (char **argv,
++	      int *arg_ptr,
++	      const struct parser_table *entry,
++	      int regex_options)
++{
++  const char *rx;
++  if (collect_arg(argv, arg_ptr, &rx))
++    {
++      struct re_pattern_buffer *re;
++      const char *error_message;
++      struct predicate *our_pred = insert_primary_withpred (entry, pred_regex);
++      our_pred->need_stat = our_pred->need_type = false;
++      re = xmalloc (sizeof (struct re_pattern_buffer));
++      our_pred->args.regex = re;
++      re->allocated = 100;
++      re->buffer = xmalloc (re->allocated);
++      re->fastmap = NULL;
++      
++      re_set_syntax(regex_options);
++      re->syntax = regex_options;
++      re->translate = NULL;
++      
++      error_message = re_compile_pattern (rx, strlen(rx), re);
++      if (error_message)
++	error (1, 0, "%s", error_message);
++      our_pred->est_success_rate = estimate_pattern_match_rate(rx, 1);
++      return true;
++    }
++  return false;
++}
++
++static boolean
++parse_size (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  struct predicate *our_pred;
++  uintmax_t num;
++  char suffix;
++  enum comparison_type c_type;
++
++  int blksize = 512;
++  int len;
++
++  /* XXX: cannot (yet) convert to ue collect_arg() as this 
++   * function modifies the args in-place. 
++   */
++  if ((argv == NULL) || (argv[*arg_ptr] == NULL))
++    return false;
++  
++  len = strlen (argv[*arg_ptr]);
++  if (len == 0)
++    error (1, 0, _("invalid null argument to -size"));
++
++  suffix = argv[*arg_ptr][len - 1];
++  switch (suffix)
++    {
++    case 'b':
++      blksize = 512;
++      argv[*arg_ptr][len - 1] = '\0';
++      break;
++
++    case 'c':
++      blksize = 1;
++      argv[*arg_ptr][len - 1] = '\0';
++      break;
++
++    case 'k':
++      blksize = 1024;
++      argv[*arg_ptr][len - 1] = '\0';
++      break;
++
++    case 'M':			/* Megabytes */
++      blksize = 1024*1024;
++      argv[*arg_ptr][len - 1] = '\0';
++      break;
++
++    case 'G':			/* Gigabytes */
++      blksize = 1024*1024*1024;
++      argv[*arg_ptr][len - 1] = '\0';
++      break;
++
++    case 'w':
++      blksize = 2;
++      argv[*arg_ptr][len - 1] = '\0';
++      break;
++
++    case '0':
++    case '1':
++    case '2':
++    case '3':
++    case '4':
++    case '5':
++    case '6':
++    case '7':
++    case '8':
++    case '9':
++      break;
++
++    default:
++      error (1, 0, _("invalid -size type `%c'"), argv[*arg_ptr][len - 1]);
++    }
++  /* TODO: accept fractional megabytes etc. ? */
++  if (!get_num (argv[*arg_ptr], &num, &c_type))
++    {
++      error(1, 0,
++	    _("Invalid argument `%s%c' to -size"),
++	    argv[*arg_ptr], (int)suffix);
++      return false;
++    }
++  our_pred = insert_primary (entry);
++  our_pred->args.size.kind = c_type;
++  our_pred->args.size.blocksize = blksize;
++  our_pred->args.size.size = num;
++  our_pred->need_stat = true;
++  our_pred->need_type = false;
++  
++  if (COMP_GT == c_type)
++    our_pred->est_success_rate = (num*blksize > 20480) ? 0.1 : 0.9;
++  else if (COMP_LT == c_type)
++    our_pred->est_success_rate = (num*blksize > 20480) ? 0.9 : 0.1;
++  else
++    our_pred->est_success_rate = 0.01;
++  
++  (*arg_ptr)++;
++  return true;
++}
++
++
++static boolean
++parse_samefile (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  /* General idea: stat the file, remember device and inode numbers.
++   * If a candidate file matches those, it's the same file.  
++   */
++  struct predicate *our_pred;
++  struct stat st, fst;
++  int fd, openflags;
++  
++  set_stat_placeholders(&st);
++  if (!collect_arg_stat_info(argv, arg_ptr, &st))
++    return false;
++  
++  set_stat_placeholders(&fst);
++  /* POSIX systems are free to re-use the inode number of a deleted
++   * file.  To ensure that we are not fooled by inode reuse, we hold
++   * the file open if we can.  This would prevent the system reusing
++   * the file.
++   */
++  fd = -3;			/* means, uninitialised */
++  openflags = O_RDONLY;
++  
++  if (options.symlink_handling == SYMLINK_NEVER_DEREF)
++    {
++      if (options.open_nofollow_available)
++	{
++	  assert (O_NOFOLLOW != 0);
++	  openflags |= O_NOFOLLOW;
++	  fd = -1;		/* safe to open it. */
++	}
++      else
++	{
++	  if (S_ISLNK(st.st_mode))
++	    {
++	      /* no way to ensure that a symlink will not be followed
++	       * by open(2), so fall back on using lstat().  Accept 
++	       * the risk that the named file will be deleted and 
++	       * replaced with another having the same inode.
++	       *
++	       * Avoid opening the file.
++	       */
++	      fd = -2;		/* Do not open it */
++	    }
++	  else
++	    {
++	      fd = -1;
++	      /* Race condition here: the file might become a symlink here. */
++	    }
++	}
++    }
++  else
++    {
++      /* We want to dereference the symlink anyway */
++      fd = -1;			/* safe to open it without O_NOFOLLOW */
++    }
++
++  assert (fd != -3);		/* check we made a decision */
++  if (fd == -1)
++    {
++      /* Race condition here.  The file might become a
++       * symbolic link in between out call to stat and
++       * the call to open.
++       */
++      fd = open(argv[*arg_ptr], openflags);
++
++      if (fd >= 0)
++	{
++	  /* We stat the file again here to prevent a race condition 
++	   * between the first stat and the call to open(2).
++	   */
++	  if (0 != fstat(fd, &fst))
++	    {
++	      fatal_file_error(argv[*arg_ptr]);
++	    }
++	  else
++	    {
++	      /* Worry about the race condition.  If the file became a
++	       * symlink after our first stat and before our call to
++	       * open, fst may contain the stat information for the
++	       * destination of the link, not the link itself.
++	       */
++	      if ((*options.xstat) (argv[*arg_ptr], &st))
++		fatal_file_error(argv[*arg_ptr]);
++
++	      if ((options.symlink_handling == SYMLINK_NEVER_DEREF)
++		  && (!options.open_nofollow_available))
++		{
++		  if (S_ISLNK(st.st_mode))
++		    {
++		      /* We lost the race.  Leave the data in st.  The
++		       * file descriptor points to the wrong thing.
++		       */
++		      close(fd);
++		      fd = -1;
++		    }
++		  else
++		    {
++		      /* Several possibilities here:
++		       * 1. There was no race
++		       * 2. The file changed into a symlink after the stat and
++		       *    before the open, and then back into a non-symlink
++		       *    before the second stat.
++		       *
++		       * In case (1) there is no problem.  In case (2), 
++		       * the stat() and fstat() calls will have returned 
++		       * different data.  O_NOFOLLOW was not available,
++		       * so the open() call may have followed a symlink
++		       * even if the -P option is in effect.
++		       */
++		      if ((st.st_dev == fst.st_dev)
++			  && (st.st_ino == fst.st_ino))
++			{
++			  /* No race.  No need to copy fst to st,
++			   * since they should be identical (modulo
++			   * differences in padding bytes).
++			   */
++			}
++		      else
++			{
++			  /* We lost the race.  Leave the data in st.  The
++			   * file descriptor points to the wrong thing.
++			   */
++			  close(fd);
++			  fd = -1;
++			}
++		    }
++		}
++	      else
++		{
++		  st = fst;
++		}
++	    }
++	}
++    }
++  
++  our_pred = insert_primary (entry);
++  our_pred->args.samefileid.ino = st.st_ino;
++  our_pred->args.samefileid.dev = st.st_dev;
++  our_pred->args.samefileid.fd  = fd;
++  our_pred->need_type = false;
++  our_pred->need_stat = true;
++  our_pred->est_success_rate = 0.01f;
++  return true;
++}
++
++#if 0
++/* This function is commented out partly because support for it is
++ * uneven. 
++ */
++static boolean
++parse_show_control_chars (const struct parser_table* entry,
++			  char **argv,
++			  int *arg_ptr)
++{
++  const char *arg;
++  const char *errmsg = _("The -show-control-chars option takes "
++			 "a single argument which "
++			 "must be 'literal' or 'safe'");
++  
++  if ((argv == NULL) || (argv[*arg_ptr] == NULL))
++    {
++      error (1, errno, "%s", errmsg);
++      return false;
++    }
++  else 
++    {
++      arg = argv[*arg_ptr];
++      
++      if (0 == strcmp("literal", arg))
++	{
++	  options.literal_control_chars = true;
++	}
++      else if (0 == strcmp("safe", arg))
++	{
++	  options.literal_control_chars = false;
++	}
++      else
++	{
++	  error (1, errno, "%s", errmsg);
++	  return false;
++	}
++      (*arg_ptr)++;		/* consume the argument. */
++      return true;
++    }
++}
++#endif
++
++
++static boolean
++parse_true (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  struct predicate *our_pred;
++
++  (void) argv;
++  (void) arg_ptr;
++  
++  our_pred = insert_primary (entry);
++  our_pred->need_stat = our_pred->need_type = false;
++  our_pred->est_success_rate = 1.0f;
++  return true;
++}
++
++static boolean
++parse_noop (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  (void) entry;
++  return parse_true(get_noop(), argv, arg_ptr);
++}
++
++static boolean
++parse_accesscheck (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  struct predicate *our_pred;
++  (void) argv;
++  (void) arg_ptr;
++  our_pred = insert_primary (entry);
++  our_pred->need_stat = our_pred->need_type = false;
++  our_pred->side_effects = our_pred->no_default_print = false;
++  if (pred_is(our_pred, pred_executable))
++    our_pred->est_success_rate = 0.2;
++  else
++    our_pred->est_success_rate = 0.9;
++  return true;
++}
++
++static boolean
++parse_type (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  return insert_type (argv, arg_ptr, entry, pred_type);
++}
++
++static boolean
++parse_uid (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  struct predicate *p = insert_num (argv, arg_ptr, entry);
++  if (p)
++    {
++      p->est_success_rate = (p->args.numinfo.l_val < 100) ? 0.99 : 0.2;
++      return true;
++    }
++  else
++    {
++      return false;
++    }
++}
++
++static boolean
++parse_used (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  struct predicate *our_pred;
++  struct time_val tval;
++  const char *offset_str;
++  const char *errmsg = "arithmetic overflow while converting %s days to a number of seconds";
++
++  if (collect_arg(argv, arg_ptr, &offset_str))
++    {
++      /* The timespec is actually a delta value, so we use an origin of 0. */
++      if (get_relative_timestamp(offset_str, &tval, 0, DAYSECS, errmsg))
++	{
++	  our_pred = insert_primary (entry);
++	  our_pred->args.reftime = tval;
++	  our_pred->est_success_rate = estimate_file_age_success_rate(tval.ts.tv_sec / DAYSECS);
++	  return true;
++	}
++      else
++	{
++	  error(1, 0, _("Invalid argument %s to -used"), offset_str);
++	  return false;
++	}
++    }
++  else
++    {
++      return false;		/* missing argument */
++    }
++}
++
++static boolean
++parse_user (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  const char *username;
++
++  if (collect_arg(argv, arg_ptr, &username))
++    {
++      struct predicate *our_pred;
++      uid_t uid;
++      struct passwd *cur_pwd = getpwnam(username);
++      endpwent();
++      if (cur_pwd != NULL)
++	{
++	  uid = cur_pwd->pw_uid;
++	}
++      else
++	{
++	  int uid_len = strspn (username, "0123456789");
++	  if (uid_len && (username[uid_len]==0))
++	    uid = safe_atoi (username);
++	  else
++	    return false;
++	}
++      our_pred = insert_primary (entry);
++      our_pred->args.uid = uid;
++      our_pred->est_success_rate = (our_pred->args.uid < 100) ? 0.99 : 0.2;
++      return true;
++    }
++  return false;
++}
++
++static boolean
++parse_version (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  int features = 0;
++  int flags;
++  
++  (void) argv;
++  (void) arg_ptr;
++  (void) entry;
++  
++  display_findutils_version("find");
++  printf (_("Features enabled: "));
++  
++#if CACHE_IDS
++  printf("CACHE_IDS ");
++  ++features;
++#endif
++#if DEBUG
++  printf("DEBUG ");
++  ++features;
++#endif
++#if DEBUG_STAT
++  printf("DEBUG_STAT ");
++  ++features;
++#endif
++#if defined USE_STRUCT_DIRENT_D_TYPE && defined HAVE_STRUCT_DIRENT_D_TYPE
++  printf("D_TYPE ");
++  ++features;
++#endif
++#if defined O_NOFOLLOW
++  printf("O_NOFOLLOW(%s) ",
++	 (options.open_nofollow_available ? "enabled" : "disabled"));
++  ++features;
++#endif
++#if defined LEAF_OPTIMISATION
++  printf("LEAF_OPTIMISATION ");
++  ++features;
++#endif
++
++  flags = 0;
++  if (is_fts_enabled(&flags))
++    {
++      int nflags = 0;
++      printf("FTS(");
++      ++features;
++
++      if (flags & FTS_CWDFD)
++	{
++	  if (nflags)
++	    {
++	      printf(",");
++	    }
++	  printf("FTS_CWDFD");
++	  ++nflags;
++	}
++      printf(") ");
++    }
++
++  printf("CBO(level=%d) ", (int)(options.optimisation_level));
++  ++features;
++  
++  if (0 == features)
++    {
++      /* For the moment, leave this as English in case someone wants
++	 to parse these strings. */
++      printf("none");
++    }
++  printf("\n");
++  
++  exit (0);
++}
++
++static boolean
++parse_xdev (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  options.stay_on_filesystem = true;
++  return parse_noop(entry, argv, arg_ptr);
++}
++
++static boolean
++parse_ignore_race (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  options.ignore_readdir_race = true;
++  return parse_noop(entry, argv, arg_ptr);
++}
++
++static boolean
++parse_noignore_race (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  options.ignore_readdir_race = false;
++  return parse_noop(entry, argv, arg_ptr);
++}
++
++static boolean
++parse_warn (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  options.warnings = true;
++  return parse_noop(entry, argv, arg_ptr);
++}
++
++static boolean
++parse_xtype (const struct parser_table* entry, char **argv, int *arg_ptr)
++{
++  return insert_type (argv, arg_ptr, entry, pred_xtype);
++}
++
++static boolean
++insert_type (char **argv, int *arg_ptr,
++	     const struct parser_table *entry,
++	     PRED_FUNC which_pred)
++{
++  mode_t type_cell;
++  struct predicate *our_pred;
++  float rate = 0.5;
++  const char *typeletter;
++
++  if (collect_arg(argv, arg_ptr, &typeletter))
++    {
++      if (strlen(typeletter) != 1u)
++	{
++	  error(1, 0, _("Arguments to -type should contain only one letter"));
++	  return false;
++	}
++      
++      switch (typeletter[0])
++	{
++	case 'b':			/* block special */
++	  type_cell = S_IFBLK;
++	  rate = 0.01f;
++	  break;
++	case 'c':			/* character special */
++	  type_cell = S_IFCHR;
++	  rate = 0.01f;
++	  break;
++	case 'd':			/* directory */
++	  type_cell = S_IFDIR;
++	  rate = 0.4f;
++	  break;
++	case 'f':			/* regular file */
++	  type_cell = S_IFREG;
++	  rate = 0.95f;
++	  break;
++#ifdef S_IFLNK
++	case 'l':			/* symbolic link */
++	  type_cell = S_IFLNK;
++	  rate = 0.1f;
++	  break;
++#endif
++#ifdef S_IFIFO
++	case 'p':			/* pipe */
++	  type_cell = S_IFIFO;
++	  rate = 0.01f;
++	  break;
++#endif
++#ifdef S_IFSOCK
++	case 's':			/* socket */
++	  type_cell = S_IFSOCK;
++	  rate = 0.01f;
++	  break;
++#endif
++#ifdef S_IFDOOR
++	case 'D':			/* Solaris door */
++	  type_cell = S_IFDOOR;
++	  rate = 0.01f;
++	  break;
++#endif
++	default:			/* None of the above ... nuke 'em. */
++	  error(1, 0, _("Unknown argument to -type: %c"), (*typeletter));
++	  return false;
++	}
++      our_pred = insert_primary_withpred (entry, which_pred);
++      our_pred->est_success_rate = rate;
++      
++      /* Figure out if we will need to stat the file, because if we don't
++       * need to follow symlinks, we can avoid a stat call by using 
++       * struct dirent.d_type.
++       */
++      if (which_pred == pred_xtype)
++	{
++	  our_pred->need_stat = true;
++	  our_pred->need_type = false;
++	}
++      else
++	{
++	  our_pred->need_stat = false; /* struct dirent is enough */
++	  our_pred->need_type = true;
++	}
++      our_pred->args.type = type_cell;
++      return true;
++    }
++  return false;
++}
++
++
++/* Return true if the file accessed via FP is a terminal.
++ */
++static boolean 
++stream_is_tty(FILE *fp)
++{
++  int fd = fileno(fp);
++  if (-1 == fd)
++    {
++      return false; /* not a valid stream */
++    }
++  else
++    {
++      return isatty(fd) ? true : false;
++    }
++  
++}
++
++
++
++
++/* XXX: do we need to pass FUNC to this function? */
++static boolean
++insert_fprintf (struct format_val *vec,
++		const struct parser_table *entry, PRED_FUNC func,
++		const char *format_const)
++{
++  char *format = (char*)format_const; /* XXX: casting away constness */
++  register char *scan;		/* Current address in scanning `format'. */
++  register char *scan2;		/* Address inside of element being scanned. */
++  struct segment **segmentp;	/* Address of current segment. */
++  struct predicate *our_pred;
++
++  our_pred = insert_primary_withpred (entry, func);
++  our_pred->side_effects = our_pred->no_default_print = true;
++  our_pred->args.printf_vec = *vec;
++  our_pred->need_type = false;
++  our_pred->need_stat = false;
++  our_pred->p_cost    = NeedsNothing;
++
++  segmentp = &our_pred->args.printf_vec.segment;
++  *segmentp = NULL;
++
++  for (scan = format; *scan; scan++)
++    {
++      if (*scan == '\\')
++	{
++	  scan2 = scan + 1;
++	  if (*scan2 >= '0' && *scan2 <= '7')
++	    {
++	      register int n, i;
++
++	      for (i = n = 0; i < 3 && (*scan2 >= '0' && *scan2 <= '7');
++		   i++, scan2++)
++		n = 8 * n + *scan2 - '0';
++	      scan2--;
++	      *scan = n;
++	    }
++	  else
++	    {
++	      switch (*scan2)
++		{
++		case 'a':
++		  *scan = 7;
++		  break;
++		case 'b':
++		  *scan = '\b';
++		  break;
++		case 'c':
++		  make_segment (segmentp, format, scan - format,
++				KIND_STOP, 0, 0,
++				our_pred);
++		  if (our_pred->need_stat && (our_pred->p_cost < NeedsStatInfo))
++		    our_pred->p_cost = NeedsStatInfo;
++		  return true;
++		case 'f':
++		  *scan = '\f';
++		  break;
++		case 'n':
++		  *scan = '\n';
++		  break;
++		case 'r':
++		  *scan = '\r';
++		  break;
++		case 't':
++		  *scan = '\t';
++		  break;
++		case 'v':
++		  *scan = '\v';
++		  break;
++		case '\\':
++		  /* *scan = '\\'; * it already is */
++		  break;
++		default:
++		  error (0, 0,
++			 _("warning: unrecognized escape `\\%c'"), *scan2);
++		  scan++;
++		  continue;
++		}
++	    }
++	  segmentp = make_segment (segmentp, format, scan - format + 1,
++				   KIND_PLAIN, 0, 0,
++				   our_pred);
++	  format = scan2 + 1;	/* Move past the escape. */
++	  scan = scan2;		/* Incremented immediately by `for'. */
++	}
++      else if (*scan == '%')
++	{
++	  if (scan[1] == 0)
++	    {
++	      /* Trailing %.  We don't like those. */
++	      error (1, 0, _("error: %s at end of format string"), scan);
++	    }
++	  else if (scan[1] == '%')
++	    {
++	      segmentp = make_segment (segmentp, format, scan - format + 1,
++				       KIND_PLAIN, 0, 0,
++				       our_pred);
++	      scan++;
++	      format = scan + 1;
++	      continue;
++	    }
++	  /* Scan past flags, width and precision, to verify kind. */
++	  for (scan2 = scan; *++scan2 && strchr ("-+ #", *scan2);)
++	    /* Do nothing. */ ;
++	  while (ISDIGIT (*scan2))
++	    scan2++;
++	  if (*scan2 == '.')
++	    for (scan2++; ISDIGIT (*scan2); scan2++)
++	      /* Do nothing. */ ;
++	  if (strchr ("abcdDfFgGhHiklmMnpPsStuUyY", *scan2))
++	    {
++	      segmentp = make_segment (segmentp, format, scan2 - format,
++				       KIND_FORMAT, *scan2, 0,
++				       our_pred);
++	      scan = scan2;
++	      format = scan + 1;
++	    }
++	  else if (strchr ("ABCT", *scan2) && scan2[1])
++	    {
++	      segmentp = make_segment (segmentp, format, scan2 - format,
++				       KIND_FORMAT, scan2[0], scan2[1],
++				       our_pred);
++	      scan = scan2 + 1;
++	      format = scan + 1;
++	      continue;
++	    }
++	  else
++	    {
++	      /* An unrecognized % escape.  Print the char after the %. */
++	      error (0, 0, _("warning: unrecognized format directive `%%%c'"),
++		     *scan2);
++	      segmentp = make_segment (segmentp, format, scan - format,
++				       KIND_PLAIN, 0, 0,
++				       our_pred);
++	      format = scan + 1;
++	      continue;
++	    }
++	}
++    }
++
++  if (scan > format)
++    make_segment (segmentp, format, scan - format, KIND_PLAIN, 0, 0,
++		  our_pred);
++  return true;
++}
++
++/* Create a new fprintf segment in *SEGMENT, with type KIND,
++   from the text in FORMAT, which has length LEN.
++   Return the address of the `next' pointer of the new segment. */
++
++static struct segment **
++make_segment (struct segment **segment,
++	      char *format,
++	      int len,
++	      int kind,
++	      char format_char,
++	      char aux_format_char,
++	      struct predicate *pred)
++{
++  enum EvaluationCost mycost = NeedsNothing;
++  char *fmt;
++
++  *segment = xmalloc (sizeof (struct segment));
++
++  (*segment)->segkind = kind;
++  (*segment)->format_char[0] = format_char;
++  (*segment)->format_char[1] = aux_format_char;
++  (*segment)->next = NULL;
++  (*segment)->text_len = len;
++
++  fmt = (*segment)->text = xmalloc (len + sizeof "d");
++  strncpy (fmt, format, len);
++  fmt += len;
++
++  switch (kind)
++    {
++    case KIND_PLAIN:		/* Plain text string, no % conversion. */
++    case KIND_STOP:		/* Terminate argument, no newline. */
++      assert (0 == format_char);
++      assert (0 == aux_format_char);
++      *fmt = '\0';
++      if (mycost > pred->p_cost)
++	pred->p_cost = NeedsNothing;
++      return &(*segment)->next;
++      break;
++    }
++
++  assert (kind == KIND_FORMAT);
++  switch (format_char)
++    {
++    case 'l':			/* object of symlink */
++      pred->need_stat = true;	
++      mycost = NeedsLinkName;
++      *fmt++ = 's';
++      break;
++      
++    case 'y':			/* file type */
++      pred->need_type = true;	
++      mycost = NeedsType;
++      *fmt++ = 's';
++      break;
++      
++    case 'a':			/* atime in `ctime' format */
++    case 'A':			/* atime in user-specified strftime format */
++    case 'B':			/* birth time in user-specified strftime format */
++    case 'c':			/* ctime in `ctime' format */
++    case 'C':			/* ctime in user-specified strftime format */
++    case 'F':			/* file system type */
++    case 'g':			/* group name */
++    case 'i':			/* inode number */
++    case 'M':			/* mode in `ls -l' format (eg., "drwxr-xr-x") */
++    case 's':			/* size in bytes */
++    case 't':			/* mtime in `ctime' format */
++    case 'T':			/* mtime in user-specified strftime format */
++    case 'u':			/* user name */
++      pred->need_stat = true;
++      mycost = NeedsStatInfo;
++      *fmt++ = 's';
++      break;
++      
++    case 'S':			/* sparseness */
++      pred->need_stat = true;
++      mycost = NeedsStatInfo;
++      *fmt++ = 'g';
++      break;
++      
++    case 'Y':			/* symlink pointed file type */
++      pred->need_stat = true;
++      mycost = NeedsType;	/* true for amortised effect */
++      *fmt++ = 's';
++      break;
++      
++    case 'f':			/* basename of path */
++    case 'h':			/* leading directories part of path */
++    case 'p':			/* pathname */
++    case 'P':			/* pathname with ARGV element stripped */
++      *fmt++ = 's';
++      break;
++
++    case 'H':			/* ARGV element file was found under */
++      *fmt++ = 's';
++      break;
++      
++      /* Numeric items that one might expect to honour 
++       * #, 0, + flags but which do not.
++       */
++    case 'G':			/* GID number */
++    case 'U':			/* UID number */
++    case 'b':			/* size in 512-byte blocks (NOT birthtime in ctime fmt)*/
++    case 'D':                   /* Filesystem device on which the file exits */
++    case 'k':			/* size in 1K blocks */
++    case 'n':			/* number of links */
++      pred->need_stat = true;
++      mycost = NeedsStatInfo;
++      *fmt++ = 's';
++      break;
++      
++      /* Numeric items that DO honour #, 0, + flags.
++       */
++    case 'd':			/* depth in search tree (0 = ARGV element) */
++      *fmt++ = 'd';
++      break;
++
++    case 'm':			/* mode as octal number (perms only) */
++      *fmt++ = 'o';
++      pred->need_stat = true;
++      mycost = NeedsStatInfo;
++      break;
++
++    case '{':
++    case '[':
++    case '(':
++      error (1, 0,
++	     _("error: the format directive `%%%c' is reserved for future use"),
++	     (int)kind);
++      /*NOTREACHED*/
++      break;
++    }
++  *fmt = '\0';
++
++  if (mycost > pred->p_cost)
++    pred->p_cost = mycost;
++  return &(*segment)->next;
++}
++
++static void 
++check_path_safety(const char *action, char **argv)
++{
++  char *s;
++  const char *path = getenv("PATH");
++  if (NULL == path)
++    {
++      /* $PATH is not set.  Assume the OS default is safe.
++       * That may not be true on Windows, but I'm not aware 
++       * of a way to get Windows to avoid searching the 
++       * current directory anyway.
++       */
++      return;
++    }
++
++  (void)argv;
++  
++  s = next_element(path, 1);
++  while ((s = next_element ((char *) NULL, 1)) != NULL)
++    {
++      if (0 == strcmp(s, "."))
++	{
++	  error(1, 0, _("The current directory is included in the PATH "
++			"environment variable, which is insecure in "
++			"combination with the %s action of find.  "
++			"Please remove the current directory from your "
++			"$PATH (that is, remove \".\" or leading or trailing "
++			"colons)"),
++		action);
++	}
++      else if ('/' != s[0])
++	{
++	  /* Relative paths are also dangerous in $PATH. */
++	  error(1, 0, _("The relative path %1$s is included in the PATH "
++			"environment variable, which is insecure in "
++			"combination with the %2$s action of find.  "
++			"Please remove that entry from $PATH"),
++		safely_quote_err_filename(0, s),
++		action);
++	}
++    }
++}
++
++
++/* handles both exec and ok predicate */
++static boolean
++new_insert_exec_ok (const char *action,
++		    const struct parser_table *entry,
++		    int dirfd,
++		    char **argv,
++		    int *arg_ptr)
++{
++  int start, end;		/* Indexes in ARGV of start & end of cmd. */
++  int i;			/* Index into cmd args */
++  int saw_braces;		/* True if previous arg was '{}'. */
++  boolean allow_plus;		/* True if + is a valid terminator */
++  int brace_count;		/* Number of instances of {}. */
++  PRED_FUNC func = entry->pred_func;
++  enum BC_INIT_STATUS bcstatus;
++  
++  struct predicate *our_pred;
++  struct exec_val *execp;	/* Pointer for efficiency. */
++
++  if ((argv == NULL) || (argv[*arg_ptr] == NULL))
++    return false;
++
++  our_pred = insert_primary_withpred (entry, func);
++  our_pred->side_effects = our_pred->no_default_print = true;
++  our_pred->need_type = our_pred->need_stat = false;
++  
++  execp = &our_pred->args.exec_vec;
++
++  if ((func != pred_okdir) && (func != pred_ok))
++    {
++      allow_plus = true;
++      execp->close_stdin = false;
++    }
++  else
++    {
++      allow_plus = false;
++      /* If find reads stdin (i.e. for -ok and similar), close stdin
++       * in the child to prevent some script from consiming the output
++       * intended for find.
++       */
++      execp->close_stdin = true;
++    }
++  
++  
++  if ((func == pred_execdir) || (func == pred_okdir))
++    {
++      options.ignore_readdir_race = false;
++      check_path_safety(action, argv);
++      execp->use_current_dir = true;
++    }
++  else
++    {
++      execp->use_current_dir = false;
++    }
++  
++  our_pred->args.exec_vec.multiple = 0;
++
++  /* Count the number of args with path replacements, up until the ';'. 
++   * Also figure out if the command is terminated by ";" or by "+".
++   */
++  start = *arg_ptr;
++  for (end = start, saw_braces=0, brace_count=0;
++       (argv[end] != NULL)
++       && ((argv[end][0] != ';') || (argv[end][1] != '\0'));
++       end++)
++    {
++      /* For -exec and -execdir, "{} +" can terminate the command. */
++      if ( allow_plus
++	   && argv[end][0] == '+' && argv[end][1] == 0
++	   && saw_braces)
++	{
++	  our_pred->args.exec_vec.multiple = 1;
++	  break;
++	}
++      
++      saw_braces = 0;
++      if (mbsstr (argv[end], "{}"))
++	{
++	  saw_braces = 1;
++	  ++brace_count;
++	  
++	  if (0 == end && (func == pred_execdir || func == pred_okdir))
++	    {
++	      /* The POSIX standard says that {} replacement should
++	       * occur even in the utility name.  This is insecure
++	       * since it means we will be executing a command whose
++	       * name is chosen according to whatever find finds in
++	       * the file system.  That can be influenced by an
++	       * attacker.  Hence for -execdir and -okdir this is not
++	       * allowed.  We can specify this as those options are 
++	       * not defined by POSIX.
++	       */
++	      error(1, 0, _("You may not use {} within the utility name for "
++			    "-execdir and -okdir, because this is a potential "
++			    "security problem."));
++	    }
++	}
++    }
++  
++  /* Fail if no command given or no semicolon found. */
++  if ((end == start) || (argv[end] == NULL))
++    {
++      *arg_ptr = end;
++      free(our_pred);
++      return false;
++    }
++
++  if (our_pred->args.exec_vec.multiple && brace_count > 1)
++    {
++	
++      const char *suffix;
++      if (func == pred_execdir)
++	suffix = "dir";
++      else
++	suffix = "";
++
++      error(1, 0,
++	    _("Only one instance of {} is supported with -exec%s ... +"),
++	    suffix);
++    }
++
++  /* We use a switch statement here so that the compiler warns us when
++   * we forget to handle a newly invented enum value.
++   *
++   * Like xargs, we allow 2KiB of headroom for the launched utility to
++   * export its own environment variables before calling something
++   * else.
++   */
++  bcstatus = bc_init_controlinfo(&execp->ctl, 2048u);
++  switch (bcstatus) 
++    {
++    case BC_INIT_ENV_TOO_BIG:
++    case BC_INIT_CANNOT_ACCOMODATE_HEADROOM:
++      error(1, 0, 
++	    _("The environment is too large for exec()."));
++      break;
++    case BC_INIT_OK:
++      /* Good news.  Carry on. */
++      break;
++    }
++  bc_use_sensible_arg_max(&execp->ctl);
++
++
++  execp->ctl.exec_callback = launch;
++
++  if (our_pred->args.exec_vec.multiple)
++    {
++      /* "+" terminator, so we can just append our arguments after the
++       * command and initial arguments.
++       */
++      execp->replace_vec = NULL;
++      execp->ctl.replace_pat = NULL;
++      execp->ctl.rplen = 0;
++      execp->ctl.lines_per_exec = 0; /* no limit */
++      execp->ctl.args_per_exec = 0; /* no limit */
++      
++      /* remember how many arguments there are */
++      execp->ctl.initial_argc = (end-start) - 1;
++
++      /* execp->state = xmalloc(sizeof struct buildcmd_state); */
++      bc_init_state(&execp->ctl, &execp->state, execp);
++  
++      /* Gather the initial arguments.  Skip the {}. */
++      for (i=start; i<end-1; ++i)
++	{
++	  bc_push_arg(&execp->ctl, &execp->state,
++		      argv[i], strlen(argv[i])+1,
++		      NULL, 0,
++		      1);
++	}
++    }
++  else
++    {
++      /* Semicolon terminator - more than one {} is supported, so we
++       * have to do brace-replacement.
++       */
++      execp->num_args = end - start;
++      
++      execp->ctl.replace_pat = "{}";
++      execp->ctl.rplen = strlen(execp->ctl.replace_pat);
++      execp->ctl.lines_per_exec = 0; /* no limit */
++      execp->ctl.args_per_exec = 0; /* no limit */
++      execp->replace_vec = xmalloc(sizeof(char*)*execp->num_args);
++
++
++      /* execp->state = xmalloc(sizeof(*(execp->state))); */
++      bc_init_state(&execp->ctl, &execp->state, execp);
++
++      /* Remember the (pre-replacement) arguments for later. */
++      for (i=0; i<execp->num_args; ++i)
++	{
++	  execp->replace_vec[i] = argv[i+start];
++	}
++    }
++  
++  if (argv[end] == NULL)
++    *arg_ptr = end;
++  else
++    *arg_ptr = end + 1;
++  
++  return true;
++}
++
++
++
++static boolean
++insert_exec_ok (const char *action,
++		const struct parser_table *entry,
++		int dirfd,
++		char **argv,
++		int *arg_ptr)
++{
++  return new_insert_exec_ok(action, entry, dirfd, argv, arg_ptr);
++}
++
++
++
++/* Get a timestamp and comparison type.
++
++   STR is the ASCII representation.
++   Set *NUM_DAYS to the number of days/minutes/whatever, taken as being 
++   relative to ORIGIN (usually the current moment or midnight).  
++   Thus the sense of the comparison type appears to be reversed.
++   Set *COMP_TYPE to the kind of comparison that is requested.
++   Issue OVERFLOWMESSAGE if overflow occurs.
++   Return true if all okay, false if input error.
++
++   Used by -atime, -ctime and -mtime (parsers) to
++   get the appropriate information for a time predicate processor. */
++
++static boolean
++get_relative_timestamp (const char *str,
++			struct time_val *result,
++			time_t origin,
++			double sec_per_unit,
++			const char *overflowmessage)
++{
++  uintmax_t checkval;
++  double offset, seconds, f;
++  
++  if (get_comp_type(&str, &result->kind))
++    {
++      /* Invert the sense of the comparison */
++      switch (result->kind)
++	{
++	case COMP_LT: result->kind = COMP_GT; break;
++	case COMP_GT: result->kind = COMP_LT; break;
++	default: break;
++	}
++
++      /* Convert the ASCII number into floating-point. */
++      if (xstrtod(str, NULL, &offset, strtod))
++	{
++	  /* Separate the floating point number the user specified
++	   * (which is a number of days, or minutes, etc) into an
++	   * integral number of seconds (SECONDS) and a fraction (F).
++	   */
++	  f = modf(offset * sec_per_unit, &seconds);
++	  
++	  result->ts.tv_sec  = origin - seconds;
++	  result->ts.tv_nsec = fabs(f * 1e9);
++
++	  /* Check for overflow. */
++	  checkval = (uintmax_t)origin - seconds;
++	  if (checkval != result->ts.tv_sec)
++	    {
++	      /* an overflow has occurred. */
++	      error (1, 0, overflowmessage, str);
++	    }
++	  return true;
++	}
++      else
++	{
++	  /* Conversion from ASCII to double failed. */
++	  return false;
++	}
++    }
++  else
++    {
++      return false;
++    }
++}
++
++/* Insert a time predicate based on the information in ENTRY.
++   ARGV is a pointer to the argument array.
++   ARG_PTR is a pointer to an index into the array, incremented if
++   all went well.
++
++   Return true if input is valid, false if not.
++
++   A new predicate node is assigned, along with an argument node
++   obtained with malloc.
++
++   Used by -atime, -ctime, and -mtime parsers. */
++
++static boolean 
++parse_time (const struct parser_table* entry, char *argv[], int *arg_ptr)
++{
++  struct predicate *our_pred;
++  struct time_val tval;
++  enum comparison_type comp;
++  const char *timearg, *orig_timearg;
++  const char *errmsg = "arithmetic overflow while converting %s "
++    "days to a number of seconds";
++  time_t origin;
++
++  if (!collect_arg(argv, arg_ptr, &timearg))
++    return false;
++  orig_timearg = timearg;
++
++  /* Decide the origin by previewing the comparison type. */
++  origin = options.cur_day_start;
++
++  if (get_comp_type(&timearg, &comp))
++    {
++      /* Remember, we invert the sense of the comparison, so this tests 
++       * against COMP_LT instead of COMP_GT... 
++       */
++      if (COMP_LT == comp)      
++	{
++	  uintmax_t expected = origin + (DAYSECS-1);
++	  origin += (DAYSECS-1);
++	  if (origin != expected)
++	    {
++	      error(1, 0,
++		    _("arithmetic overflow when trying to calculate the end of today"));
++	    }
++	}
++    }
++  /* We discard the value of comp here, as get_relative_timestamp
++   * will set tval.kind.  For that to work, we have to restore
++   * timearg so that it points to the +/- prefix, if any.  get_comp_type()
++   * will have advanced timearg, so we restore it.
++   */
++  timearg = orig_timearg;
++
++  if (!get_relative_timestamp(timearg, &tval, origin, DAYSECS, errmsg))
++    return false;
++
++  our_pred = insert_primary (entry);
++  our_pred->args.reftime = tval;
++  our_pred->est_success_rate = estimate_timestamp_success_rate(tval.ts.tv_sec);
++
++  if (options.debug_options & DebugExpressionTree)
++    {
++      time_t t;
++
++      fprintf (stderr, "inserting %s\n", our_pred->p_name);
++      fprintf (stderr, "    type: %s    %s  ",
++	       (tval.kind == COMP_GT) ? "gt" :
++	       ((tval.kind == COMP_LT) ? "lt" : ((tval.kind == COMP_EQ) ? "eq" : "?")),
++	       (tval.kind == COMP_GT) ? " >" :
++	       ((tval.kind == COMP_LT) ? " <" : ((tval.kind == COMP_EQ) ? ">=" : " ?")));
++      t = our_pred->args.reftime.ts.tv_sec;
++      fprintf (stderr, "%ju %s",
++	       (uintmax_t) our_pred->args.reftime.ts.tv_sec,
++	       ctime (&t));
++      if (tval.kind == COMP_EQ)
++	{
++	  t = our_pred->args.reftime.ts.tv_sec + DAYSECS;
++	  fprintf (stderr, "                 <  %ju %s",
++		   (uintmax_t) t, ctime (&t));
++	}
++    }
++  
++  return true;
++}
++
++/* Get the comparison type prefix (if any) from a number argument.
++   The prefix is at *STR.
++   Set *COMP_TYPE to the kind of comparison that is requested.
++   Advance *STR beyond any initial comparison prefix.  
++
++   Return true if all okay, false if input error.  */
++static boolean
++get_comp_type(const char **str, enum comparison_type *comp_type)
++{
++  switch (**str)
++    {
++    case '+':
++      *comp_type = COMP_GT;
++      (*str)++;
++      break;
++    case '-':
++      *comp_type = COMP_LT;
++      (*str)++;
++      break;
++    default:
++      *comp_type = COMP_EQ;
++      break;
++    }
++  return true;
++}
++
++
++   
++				 
++
++/* Get a number with comparison information.
++   The sense of the comparison information is 'normal'; that is,
++   '+' looks for a count > than the number and '-' less than.
++   
++   STR is the ASCII representation of the number.
++   Set *NUM to the number.
++   Set *COMP_TYPE to the kind of comparison that is requested.
++ 
++   Return true if all okay, false if input error.  */
++
++static boolean
++get_num (const char *str,
++	 uintmax_t *num,
++	 enum comparison_type *comp_type)
++{
++  char *pend;
++
++  if (str == NULL)
++    return false;
++
++  /* Figure out the comparison type if the caller accepts one. */
++  if (comp_type)
++    {
++      if (!get_comp_type(&str, comp_type))
++	return false;
++    }
++  
++  return xstrtoumax (str, &pend, 10, num, "") == LONGINT_OK;
++}
++
++/* Insert a number predicate.
++   ARGV is a pointer to the argument array.
++   *ARG_PTR is an index into ARGV, incremented if all went well.
++   *PRED is the predicate processor to insert.
++
++   Return true if input is valid, false if error.
++   
++   A new predicate node is assigned, along with an argument node
++   obtained with malloc.
++
++   Used by -inum and -links parsers. */
++
++static struct predicate *
++insert_num (char **argv, int *arg_ptr, const struct parser_table *entry)
++{
++  const char *numstr;
++
++  if (collect_arg(argv, arg_ptr, &numstr))
++  {
++    uintmax_t num;
++    enum comparison_type c_type;
++
++    if (get_num (numstr, &num, &c_type))
++      {
++	struct predicate *our_pred = insert_primary (entry);
++	our_pred->args.numinfo.kind = c_type;
++	our_pred->args.numinfo.l_val = num;
++	
++	if (options.debug_options & DebugExpressionTree)
++	  {
++	    fprintf (stderr, "inserting %s\n", our_pred->p_name);
++	    fprintf (stderr, "    type: %s    %s  ",
++		     (c_type == COMP_GT) ? "gt" :
++		     ((c_type == COMP_LT) ? "lt" : ((c_type == COMP_EQ) ? "eq" : "?")),
++		     (c_type == COMP_GT) ? " >" :
++		     ((c_type == COMP_LT) ? " <" : ((c_type == COMP_EQ) ? " =" : " ?")));
++	    fprintf (stderr, "%ju\n", our_pred->args.numinfo.l_val);
++	  }
++	return our_pred;
++      }
++  }
++  return NULL;
++}
++
++static void
++open_output_file (const char *path, struct format_val *p)
++{
++  p->segment = NULL;
++  p->quote_opts = clone_quoting_options (NULL);
++  
++  if (!strcmp (path, "/dev/stderr"))
++    {
++      p->stream = stderr;
++      p->filename = _("standard error");
++    }
++  else if (!strcmp (path, "/dev/stdout"))
++    {
++      p->stream = stdout;
++      p->filename = _("standard output");
++    }
++  else
++    {
++      p->stream = fopen_safer (path, "w");
++      p->filename = path;
++      
++      if (p->stream == NULL)
++	{
++	  fatal_file_error(path);
++	}
++    }
++
++  p->dest_is_tty = stream_is_tty(p->stream);
++}
++
++static void
++open_stdout (struct format_val *p)
++{
++  open_output_file("/dev/stdout", p);
++}
+diff -purN findutils-4.3.12.orig/find/pred.c findutils-4.3.12/find/pred.c
+--- findutils-4.3.12.orig/find/pred.c	2007-12-19 16:12:34.000000000 -0500
++++ findutils-4.3.12/find/pred.c	2008-01-30 08:46:05.758843847 -0500
+@@ -47,6 +47,14 @@
+ #include "error.h"
+ #include "verify.h"
+ 
++#ifdef WITH_SELINUX
++#include <selinux/selinux.h>
++#endif /*WITH_SELINUX*/
++
++#ifndef FNM_CASEFOLD
++#define FNM_CASEFOLD (1<<4)
++#endif  /*FNM_CASEFOLD*/
++
+ #if ENABLE_NLS
+ # include <libintl.h>
+ # define _(Text) gettext (Text)
+@@ -229,6 +237,9 @@ struct pred_assoc pred_table[] =
+   {pred_user, "user    "},
+   {pred_writable, "writable "},
+   {pred_xtype, "xtype   "},
++#ifdef WITH_SELINUX
++  {pred_scontext, "context"},
++#endif /*WITH_SELINUX*/
+   {0, "none    "}
+ };
+ #endif
+@@ -1045,6 +1056,26 @@ do_fprintf(struct format_val *dest,
+ 			     mode_to_filetype(stat_buf->st_mode & S_IFMT));
+ 	  }
+ 	  break;
++#ifdef WITH_SELINUX
++      case 'Z':               /* SELinux security context */
++        {
++          security_context_t scontext;
++          int rv;
++          rv = (*options.x_getfilecon)(state.rel_pathname, &scontext);
++
++          if ( rv < 0 ) {
++            fprintf(stderr, "getfileconf(%s): %s",
++                           pathname, strerror(errno));
++            fflush(stderr);
++          }
++          else {
++	      segment->text[segment->text_len] = 's';
++	      checked_fprintf (dest, segment->text, scontext);
++	      freecon(scontext);
++          }
++        }
++        break ;
++#endif /* WITH_SELINUX */
+ 	}
+       /* end of KIND_FORMAT case */
+       break;
+@@ -1838,6 +1869,31 @@ pred_xtype (const char *pathname, struct
+    */
+   return (pred_type (pathname, &sbuf, pred_ptr));
+ }
++  
++
++#ifdef WITH_SELINUX
++
++boolean
++pred_scontext (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  int rv;
++  security_context_t scontext;
++
++  rv = (* options.x_getfilecon)(state.rel_pathname, &scontext);
++
++  if ( rv < 0 ) {
++    (void) fprintf(stderr, "getfilecon(%s): %s\n", pathname, strerror(errno));
++    (void) fflush(stderr);
++    return ( false );
++  }
++
++  rv = (fnmatch(pred_ptr->args.scontext, scontext,0)==0);
++  freecon(scontext);
++  return rv;
++}
++
++#endif /*WITH_SELINUX*/
++
+ 
+ /*  1) fork to get a child; parent remembers the child pid
+     2) child execs the command requested
+diff -purN findutils-4.3.12.orig/find/pred.c.orig findutils-4.3.12/find/pred.c.orig
+--- findutils-4.3.12.orig/find/pred.c.orig	1969-12-31 19:00:00.000000000 -0500
++++ findutils-4.3.12/find/pred.c.orig	2007-12-19 16:12:34.000000000 -0500
+@@ -0,0 +1,2405 @@
++/* pred.c -- execute the expression tree.
++   Copyright (C) 1990, 1991, 1992, 1993, 1994, 2000, 2003, 
++                 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
++
++   This program is free software: you can redistribute it and/or modify
++   it under the terms of the GNU General Public License as published by
++   the Free Software Foundation, either version 3 of the License, or
++   (at your option) any later version.
++   
++   This program is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++   GNU General Public License for more details.
++   
++   You should have received a copy of the GNU General Public License
++   along with this program.  If not, see <http://www.gnu.org/licenses/>.
++*/
++
++#include <config.h>
++#include "defs.h"
++
++#include <fnmatch.h>
++#include <signal.h>
++#include <math.h>
++#include <pwd.h>
++#include <grp.h>
++#include <sys/types.h>
++#include <sys/stat.h>
++#include <errno.h>
++#include <assert.h>
++#include <stdarg.h>
++#include <fcntl.h>
++#include <locale.h>
++#include <openat.h>
++#include "xalloc.h"
++#include "dirname.h"
++#include "human.h"
++#include "modetype.h"
++#include "filemode.h"
++#include "wait.h"
++#include "printquoted.h"
++#include "buildcmd.h"
++#include "yesno.h"
++#include "listfile.h"
++#include "stat-time.h"
++#include "dircallback.h"
++#include "error.h"
++#include "verify.h"
++
++#if ENABLE_NLS
++# include <libintl.h>
++# define _(Text) gettext (Text)
++#else
++# define _(Text) Text
++#endif
++#ifdef gettext_noop
++# define N_(String) gettext_noop (String)
++#else
++/* See locate.c for explanation as to why not use (String) */
++# define N_(String) String
++#endif
++
++#if !defined(SIGCHLD) && defined(SIGCLD)
++#define SIGCHLD SIGCLD
++#endif
++
++
++
++#if HAVE_DIRENT_H
++# include <dirent.h>
++# define NAMLEN(dirent) strlen((dirent)->d_name)
++#else
++# define dirent direct
++# define NAMLEN(dirent) (dirent)->d_namlen
++# if HAVE_SYS_NDIR_H
++#  include <sys/ndir.h>
++# endif
++# if HAVE_SYS_DIR_H
++#  include <sys/dir.h>
++# endif
++# if HAVE_NDIR_H
++#  include <ndir.h>
++# endif
++#endif
++
++#ifdef CLOSEDIR_VOID
++/* Fake a return value. */
++#define CLOSEDIR(d) (closedir (d), 0)
++#else
++#define CLOSEDIR(d) closedir (d)
++#endif
++
++
++
++
++/* Get or fake the disk device blocksize.
++   Usually defined by sys/param.h (if at all).  */
++#ifndef DEV_BSIZE
++# ifdef BSIZE
++#  define DEV_BSIZE BSIZE
++# else /* !BSIZE */
++#  define DEV_BSIZE 4096
++# endif /* !BSIZE */
++#endif /* !DEV_BSIZE */
++
++/* Extract or fake data from a `struct stat'.
++   ST_BLKSIZE: Preferred I/O blocksize for the file, in bytes.
++   ST_NBLOCKS: Number of blocks in the file, including indirect blocks.
++   ST_NBLOCKSIZE: Size of blocks used when calculating ST_NBLOCKS.  */
++#ifndef HAVE_STRUCT_STAT_ST_BLOCKS
++# define ST_BLKSIZE(statbuf) DEV_BSIZE
++# if defined _POSIX_SOURCE || !defined BSIZE /* fileblocks.c uses BSIZE.  */
++#  define ST_NBLOCKS(statbuf) \
++  (S_ISREG ((statbuf).st_mode) \
++   || S_ISDIR ((statbuf).st_mode) \
++   ? (statbuf).st_size / ST_NBLOCKSIZE + ((statbuf).st_size % ST_NBLOCKSIZE != 0) : 0)
++# else /* !_POSIX_SOURCE && BSIZE */
++#  define ST_NBLOCKS(statbuf) \
++  (S_ISREG ((statbuf).st_mode) \
++   || S_ISDIR ((statbuf).st_mode) \
++   ? st_blocks ((statbuf).st_size) : 0)
++# endif /* !_POSIX_SOURCE && BSIZE */
++#else /* HAVE_STRUCT_STAT_ST_BLOCKS */
++/* Some systems, like Sequents, return st_blksize of 0 on pipes. */
++# define ST_BLKSIZE(statbuf) ((statbuf).st_blksize > 0 \
++			       ? (statbuf).st_blksize : DEV_BSIZE)
++# if defined hpux || defined __hpux__ || defined __hpux
++/* HP-UX counts st_blocks in 1024-byte units.
++   This loses when mixing HP-UX and BSD file systems with NFS.  */
++#  define ST_NBLOCKSIZE 1024
++# else /* !hpux */
++#  if defined _AIX && defined _I386
++/* AIX PS/2 counts st_blocks in 4K units.  */
++#   define ST_NBLOCKSIZE (4 * 1024)
++#  else /* not AIX PS/2 */
++#   if defined _CRAY
++#    define ST_NBLOCKS(statbuf) \
++  (S_ISREG ((statbuf).st_mode) \
++   || S_ISDIR ((statbuf).st_mode) \
++   ? (statbuf).st_blocks * ST_BLKSIZE(statbuf)/ST_NBLOCKSIZE : 0)
++#   endif /* _CRAY */
++#  endif /* not AIX PS/2 */
++# endif /* !hpux */
++#endif /* HAVE_STRUCT_STAT_ST_BLOCKS */
++
++#ifndef ST_NBLOCKS
++# define ST_NBLOCKS(statbuf) \
++  (S_ISREG ((statbuf).st_mode) \
++   || S_ISDIR ((statbuf).st_mode) \
++   ? (statbuf).st_blocks : 0)
++#endif
++
++#ifndef ST_NBLOCKSIZE
++# define ST_NBLOCKSIZE 512
++#endif
++
++
++#undef MAX
++#define MAX(a, b) ((a) > (b) ? (a) : (b))
++
++static boolean match_lname PARAMS((const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr, boolean ignore_case));
++
++static char *format_date PARAMS((struct timespec ts, int kind));
++static char *ctime_format PARAMS((struct timespec ts));
++
++#ifdef	DEBUG
++struct pred_assoc
++{
++  PRED_FUNC pred_func;
++  char *pred_name;
++};
++
++struct pred_assoc pred_table[] =
++{
++  {pred_amin, "amin    "},
++  {pred_and, "and     "},
++  {pred_anewer, "anewer  "},
++  {pred_atime, "atime   "},
++  {pred_closeparen, ")       "},
++  {pred_cmin, "cmin    "},
++  {pred_cnewer, "cnewer  "},
++  {pred_comma, ",       "},
++  {pred_ctime, "ctime   "},
++  {pred_delete, "delete  "},
++  {pred_empty, "empty   "},
++  {pred_exec, "exec    "},
++  {pred_execdir, "execdir "},
++  {pred_executable, "executable "},
++  {pred_false, "false   "},
++  {pred_fprint, "fprint  "},
++  {pred_fprint0, "fprint0 "},
++  {pred_fprintf, "fprintf "},
++  {pred_fstype, "fstype  "},
++  {pred_gid, "gid     "},
++  {pred_group, "group   "},
++  {pred_ilname, "ilname  "},
++  {pred_iname, "iname   "},
++  {pred_inum, "inum    "},
++  {pred_ipath, "ipath   "},
++  {pred_links, "links   "},
++  {pred_lname, "lname   "},
++  {pred_ls, "ls      "},
++  {pred_mmin, "mmin    "},
++  {pred_mtime, "mtime   "},
++  {pred_name, "name    "},
++  {pred_negate, "not     "},
++  {pred_newer, "newer   "},
++  {pred_newerXY, "newerXY   "},
++  {pred_nogroup, "nogroup "},
++  {pred_nouser, "nouser  "},
++  {pred_ok, "ok      "},
++  {pred_okdir, "okdir   "},
++  {pred_openparen, "(       "},
++  {pred_or, "or      "},
++  {pred_path, "path    "},
++  {pred_perm, "perm    "},
++  {pred_print, "print   "},
++  {pred_print0, "print0  "},
++  {pred_prune, "prune   "},
++  {pred_quit, "quit    "},
++  {pred_readable, "readable    "},
++  {pred_regex, "regex   "},
++  {pred_samefile,"samefile "},
++  {pred_size, "size    "},
++  {pred_true, "true    "},
++  {pred_type, "type    "},
++  {pred_uid, "uid     "},
++  {pred_used, "used    "},
++  {pred_user, "user    "},
++  {pred_writable, "writable "},
++  {pred_xtype, "xtype   "},
++  {0, "none    "}
++};
++#endif
++
++/* Returns ts1 - ts2 */
++static double ts_difference(struct timespec ts1,
++			    struct timespec ts2)
++{
++  double d =  difftime(ts1.tv_sec, ts2.tv_sec) 
++    + (1.0e-9 * (ts1.tv_nsec - ts2.tv_nsec));
++  return d;
++}
++
++
++static int 
++compare_ts(struct timespec ts1,
++	   struct timespec ts2)
++{
++  if ((ts1.tv_sec == ts2.tv_sec) &&
++      (ts1.tv_nsec == ts2.tv_nsec))
++    {
++      return 0;
++    }
++  else
++    {
++      double diff = ts_difference(ts1, ts2);
++      return diff < 0.0 ? -1 : +1;
++    }
++}
++
++/* Predicate processing routines.
++ 
++   PATHNAME is the full pathname of the file being checked.
++   *STAT_BUF contains information about PATHNAME.
++   *PRED_PTR contains information for applying the predicate.
++ 
++   Return true if the file passes this predicate, false if not. */
++
++
++/* pred_timewindow
++ *
++ * Returns true if THE_TIME is 
++ * COMP_GT: after the specified time
++ * COMP_LT: before the specified time
++ * COMP_EQ: less than WINDOW seconds after the specified time.
++ */
++static boolean
++pred_timewindow(struct timespec ts, struct predicate const *pred_ptr, int window)
++{
++  switch (pred_ptr->args.reftime.kind)
++    {
++    case COMP_GT:
++      return compare_ts(ts, pred_ptr->args.reftime.ts) > 0;
++      
++    case COMP_LT:
++      return compare_ts(ts, pred_ptr->args.reftime.ts) < 0;
++      
++    case COMP_EQ:
++      {
++	double delta = ts_difference(ts, pred_ptr->args.reftime.ts);
++	return (delta >= 0.0 && delta < window);
++      }
++    }
++  assert (0);
++  abort ();
++}
++
++
++boolean
++pred_amin (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) &pathname;
++  return pred_timewindow(get_stat_atime(stat_buf), pred_ptr, 60);
++}
++
++boolean
++pred_and (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  if (pred_ptr->pred_left == NULL
++      || apply_predicate(pathname, stat_buf, pred_ptr->pred_left))
++    {
++      return apply_predicate(pathname, stat_buf, pred_ptr->pred_right);
++    }
++  else
++    return false;
++}
++
++boolean
++pred_anewer (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) &pathname;
++  assert (COMP_GT == pred_ptr->args.reftime.kind);
++  return compare_ts(get_stat_atime(stat_buf), pred_ptr->args.reftime.ts) > 0;
++}
++
++boolean
++pred_atime (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) &pathname;
++  return pred_timewindow(get_stat_atime(stat_buf), pred_ptr, DAYSECS);
++}
++
++boolean
++pred_closeparen (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) &pathname;
++  (void) &stat_buf;
++  (void) &pred_ptr;
++  
++  return true;
++}
++
++boolean
++pred_cmin (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) pathname;
++  return pred_timewindow(get_stat_ctime(stat_buf), pred_ptr, 60);
++}
++
++boolean
++pred_cnewer (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) pathname;
++  
++  assert (COMP_GT == pred_ptr->args.reftime.kind);
++  return compare_ts(get_stat_ctime(stat_buf), pred_ptr->args.reftime.ts) > 0;
++}
++
++boolean
++pred_comma (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  if (pred_ptr->pred_left != NULL)
++    {
++      apply_predicate(pathname, stat_buf,pred_ptr->pred_left);
++    }
++  return apply_predicate(pathname, stat_buf, pred_ptr->pred_right);
++}
++
++boolean
++pred_ctime (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) &pathname;
++  return pred_timewindow(get_stat_ctime(stat_buf), pred_ptr, DAYSECS);
++}
++
++static boolean
++perform_delete(int flags)
++{
++  return 0 == unlinkat(state.cwd_dir_fd, state.rel_pathname, flags);
++}
++
++
++boolean
++pred_delete (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) pred_ptr;
++  (void) stat_buf;
++  if (strcmp (state.rel_pathname, "."))
++    {
++      int flags=0;
++      if (state.have_stat && S_ISDIR(stat_buf->st_mode))
++	flags |= AT_REMOVEDIR;
++      if (perform_delete(flags))
++	{
++	  return true;
++	}
++      else
++	{
++	  if (EISDIR == errno)
++	    {
++	      if ((flags & AT_REMOVEDIR) == 0)
++		{
++		  /* unlink() operation failed because we should have done rmdir(). */
++		  flags |= AT_REMOVEDIR;
++		  if (perform_delete(flags))
++		    return true;
++		}
++	    }
++	}
++      error (0, errno, _("cannot delete %s"
++			 /* TRANSLATORS: the argument is either a
++			  * file or a directory, but we do not know which.
++			  * Mail bug-findutils@gnu.org if you cannot correctly 
++			  * translate the string without knowing.
++			  */),
++	     safely_quote_err_filename(0, pathname));
++      /* Previously I had believed that having the -delete action
++       * return false provided the user with control over whether an
++       * error message is issued.  While this is true, the policy of
++       * not affecting the exit status is contrary to the POSIX
++       * requirement that diagnostic messages are accompanied by a
++       * nonzero exit status.  While -delete is not a POSIX option and
++       * we can therefore opt not to follow POSIX in this case, that
++       * seems somewhat arbitrary and confusing.  So, as of
++       * findutils-4.3.11, we also set the exit status in this case.
++       */
++      state.exit_status = 1;
++      return false;
++    }
++  else
++    {
++      /* nothing to do. */
++      return true;
++    }
++}
++
++boolean
++pred_empty (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) pathname;
++  (void) pred_ptr;
++  
++  if (S_ISDIR (stat_buf->st_mode))
++    {
++      int fd;
++      DIR *d;
++      struct dirent *dp;
++      boolean empty = true;
++
++      errno = 0;
++      if ((fd = openat(state.cwd_dir_fd, state.rel_pathname, O_RDONLY
++#if defined O_LARGEFILE
++			|O_LARGEFILE
++#endif
++		       )) < 0)
++	{
++	  error (0, errno, "%s", safely_quote_err_filename(0, pathname));
++	  state.exit_status = 1;
++	  return false;
++	}
++      d = fdopendir (fd);
++      if (d == NULL)
++	{
++	  error (0, errno, "%s", safely_quote_err_filename(0, pathname));
++	  state.exit_status = 1;
++	  return false;
++	}
++      for (dp = readdir (d); dp; dp = readdir (d))
++	{
++	  if (dp->d_name[0] != '.'
++	      || (dp->d_name[1] != '\0'
++		  && (dp->d_name[1] != '.' || dp->d_name[2] != '\0')))
++	    {
++	      empty = false;
++	      break;
++	    }
++	}
++      if (CLOSEDIR (d))
++	{
++	  error (0, errno, "%s", safely_quote_err_filename(0, pathname));
++	  state.exit_status = 1;
++	  return false;
++	}
++      return (empty);
++    }
++  else if (S_ISREG (stat_buf->st_mode))
++    return (stat_buf->st_size == 0);
++  else
++    return (false);
++}
++
++static boolean
++new_impl_pred_exec (int dirfd, const char *pathname,
++		    struct stat *stat_buf,
++		    struct predicate *pred_ptr,
++		    const char *prefix, size_t pfxlen)
++{
++  struct exec_val *execp = &pred_ptr->args.exec_vec;
++  size_t len = strlen(pathname);
++
++  (void) stat_buf;
++  execp->dirfd = dirfd;
++  if (execp->multiple)
++    {
++      /* Push the argument onto the current list. 
++       * The command may or may not be run at this point, 
++       * depending on the command line length limits.
++       */
++      bc_push_arg(&execp->ctl,
++		  &execp->state,
++		  pathname, len+1,
++		  prefix, pfxlen,
++		  0);
++
++      /* remember that there are pending execdirs. */
++      state.execdirs_outstanding = true;
++      
++      /* POSIX: If the primary expression is punctuated by a plus
++       * sign, the primary shall always evaluate as true
++       */
++      return true;
++    }
++  else
++    {
++      int i;
++
++      for (i=0; i<execp->num_args; ++i)
++	{
++	  bc_do_insert(&execp->ctl,
++		       &execp->state,
++		       execp->replace_vec[i],
++		       strlen(execp->replace_vec[i]),
++		       prefix, pfxlen,
++		       pathname, len,
++		       0);
++	}
++
++      /* Actually invoke the command. */
++      return  execp->ctl.exec_callback(&execp->ctl,
++					&execp->state);
++    }
++}
++
++
++boolean
++pred_exec (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  return new_impl_pred_exec(get_start_dirfd(),
++			    pathname, stat_buf, pred_ptr, NULL, 0);
++}
++
++boolean
++pred_execdir (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++   const char *prefix = (state.rel_pathname[0] == '/') ? NULL : "./";
++   (void) &pathname;
++   return new_impl_pred_exec (get_current_dirfd(),
++			      state.rel_pathname, stat_buf, pred_ptr,
++			      prefix, (prefix ? 2 : 0));
++}
++
++boolean
++pred_false (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) &pathname;
++  (void) &stat_buf;
++  (void) &pred_ptr;
++
++  
++  return (false);
++}
++
++boolean
++pred_fls (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  FILE * stream = pred_ptr->args.printf_vec.stream;
++  list_file (pathname, state.cwd_dir_fd, state.rel_pathname, stat_buf,
++	     options.start_time.tv_sec,
++	     options.output_block_size,
++	     pred_ptr->literal_control_chars, stream);
++  return true;
++}
++
++boolean
++pred_fprint (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) &pathname;
++  (void) &stat_buf;
++  
++  print_quoted(pred_ptr->args.printf_vec.stream,
++	       pred_ptr->args.printf_vec.quote_opts,
++	       pred_ptr->args.printf_vec.dest_is_tty,
++	       "%s\n",
++	       pathname);
++  return true;
++}
++
++boolean
++pred_fprint0 (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  FILE * fp = pred_ptr->args.printf_vec.stream;
++
++  (void) &stat_buf;
++  
++  fputs (pathname, fp);
++  putc (0, fp);
++  return true;
++}
++
++
++
++static char*
++mode_to_filetype(mode_t m)
++{
++#define HANDLE_TYPE(t,letter) if (m==t) { return letter; }
++#ifdef S_IFREG
++  HANDLE_TYPE(S_IFREG,  "f");	/* regular file */
++#endif
++#ifdef S_IFDIR
++  HANDLE_TYPE(S_IFDIR,  "d");	/* directory */
++#endif
++#ifdef S_IFLNK
++  HANDLE_TYPE(S_IFLNK,  "l");	/* symbolic link */
++#endif
++#ifdef S_IFSOCK
++  HANDLE_TYPE(S_IFSOCK, "s");	/* Unix domain socket */
++#endif
++#ifdef S_IFBLK
++  HANDLE_TYPE(S_IFBLK,  "b");	/* block device */
++#endif
++#ifdef S_IFCHR
++  HANDLE_TYPE(S_IFCHR,  "c");	/* character device */
++#endif
++#ifdef S_IFIFO
++  HANDLE_TYPE(S_IFIFO,  "p");	/* FIFO */
++#endif
++#ifdef S_IFDOOR
++  HANDLE_TYPE(S_IFDOOR, "D");	/* Door (e.g. on Solaris) */
++#endif
++  return "U";			/* Unknown */
++}
++
++static double 
++file_sparseness(const struct stat *p)
++{
++#if defined HAVE_STRUCT_STAT_ST_BLOCKS
++  if (0 == p->st_size)
++    {
++      if (0 == p->st_blocks)
++	return 1.0;
++      else
++	return p->st_blocks < 0 ? -HUGE_VAL : HUGE_VAL;
++    }
++  else
++    {
++      double blklen = file_blocksize(p) * (double)p->st_blocks;
++      return blklen / p->st_size;
++    }
++#else  
++  return 1.0;
++#endif
++}
++
++
++
++static void
++checked_fprintf(struct format_val *dest, const char *fmt, ...)
++{
++  int rv;
++  va_list ap;
++
++  va_start(ap, fmt);
++  rv = vfprintf(dest->stream, fmt, ap);
++  if (rv < 0)
++    nonfatal_file_error(dest->filename);
++}
++
++
++static void
++checked_print_quoted (struct format_val *dest,
++			   const char *format, const char *s)
++{
++  int rv = print_quoted(dest->stream, dest->quote_opts, dest->dest_is_tty,
++			format, s);
++  if (rv < 0)
++    nonfatal_file_error(dest->filename);
++}
++
++
++static void
++checked_fwrite(void *p, size_t siz, size_t nmemb, struct format_val *dest)
++{
++  int items_written = fwrite(p, siz, nmemb, dest->stream);
++  if (items_written < nmemb)
++    nonfatal_file_error(dest->filename);
++}
++
++static void
++checked_fflush(struct format_val *dest)
++{
++  if (0 != fflush(dest->stream))
++    {
++      nonfatal_file_error(dest->filename);
++    }
++}
++
++static void
++do_fprintf(struct format_val *dest,
++	   struct segment *segment,
++	   const char *pathname,
++	   const struct stat *stat_buf)
++{
++  char hbuf[LONGEST_HUMAN_READABLE + 1];
++  const char *cp;
++
++  switch (segment->segkind)
++    {
++    case KIND_PLAIN:	/* Plain text string (no % conversion). */
++      /* trusted */
++      checked_fwrite(segment->text, 1, segment->text_len, dest);
++      break;
++	  
++    case KIND_STOP:		/* Terminate argument and flush output. */
++      /* trusted */
++      checked_fwrite(segment->text, 1, segment->text_len, dest);
++      checked_fflush(dest);
++      break;
++	  
++    case KIND_FORMAT:
++      switch (segment->format_char[0])
++	{
++	case 'a':		/* atime in `ctime' format. */
++	  /* UNTRUSTED, probably unexploitable */
++	  checked_fprintf (dest, segment->text, ctime_format (get_stat_atime(stat_buf)));
++	  break;
++	case 'b':		/* size in 512-byte blocks */
++	  /* UNTRUSTED, probably unexploitable */
++	  checked_fprintf (dest, segment->text,
++			   human_readable ((uintmax_t) ST_NBLOCKS (*stat_buf),
++					   hbuf, human_ceiling,
++					   ST_NBLOCKSIZE, 512));
++	  break;
++	case 'c':		/* ctime in `ctime' format */
++	  /* UNTRUSTED, probably unexploitable */
++	  checked_fprintf (dest, segment->text, ctime_format (get_stat_ctime(stat_buf)));
++	  break;
++	case 'd':		/* depth in search tree */
++	  /* UNTRUSTED, probably unexploitable */
++	  checked_fprintf (dest, segment->text, state.curdepth);
++	  break;
++	case 'D':		/* Device on which file exists (stat.st_dev) */
++	  /* trusted */
++	  checked_fprintf (dest, segment->text, 
++			   human_readable ((uintmax_t) stat_buf->st_dev, hbuf,
++					   human_ceiling, 1, 1));
++	  break;
++	case 'f':		/* base name of path */
++	  /* sanitised */
++	  {
++	    char *base = base_name (pathname);
++	    checked_print_quoted (dest, segment->text, base);
++	    free (base);
++	  }
++	  break;
++	case 'F':		/* file system type */
++	  /* trusted */
++	  checked_print_quoted (dest, segment->text, filesystem_type (stat_buf, pathname));
++	  break;
++	case 'g':		/* group name */
++	  /* trusted */
++	  /* (well, the actual group is selected by the user but
++	   * its name was selected by the system administrator)
++	   */
++	  {
++	    struct group *g;
++
++	    g = getgrgid (stat_buf->st_gid);
++	    if (g)
++	      {
++		segment->text[segment->text_len] = 's';
++		checked_fprintf (dest, segment->text, g->gr_name);
++		break;
++	      }
++	    else
++	      {
++		/* Do nothing. */
++		/*FALLTHROUGH*/
++	      }
++	  }
++	  /*FALLTHROUGH*/ /*...sometimes, so 'G' case.*/
++
++	case 'G':		/* GID number */
++	  /* UNTRUSTED, probably unexploitable */
++	  checked_fprintf (dest, segment->text,
++			   human_readable ((uintmax_t) stat_buf->st_gid, hbuf,
++					   human_ceiling, 1, 1));
++	  break;
++	case 'h':		/* leading directories part of path */
++	  /* sanitised */
++	  {
++	    cp = strrchr (pathname, '/');
++	    if (cp == NULL)	/* No leading directories. */
++	      {
++		/* If there is no slash in the pathname, we still
++		 * print the string because it contains characters
++		 * other than just '%s'.  The %h expands to ".".
++		 */
++		checked_print_quoted (dest, segment->text, ".");
++	      }
++	    else
++	      {
++		char *s = strdup(pathname);
++		s[cp - pathname] = 0;
++		checked_print_quoted (dest, segment->text, s);
++		free(s);
++	      }
++	  }
++	  break;
++
++	case 'H':		/* ARGV element file was found under */
++	  /* trusted */
++	  {
++	    char *s = xmalloc(state.starting_path_length+1);
++	    memcpy(s, pathname, state.starting_path_length);
++	    s[state.starting_path_length] = 0;
++	    checked_fprintf (dest, segment->text, s);
++	    free(s);
++	  }
++	  break;
++
++	case 'i':		/* inode number */
++	  /* UNTRUSTED, but not exploitable I think */
++	  checked_fprintf (dest, segment->text,
++			   human_readable ((uintmax_t) stat_buf->st_ino, hbuf,
++					   human_ceiling,
++					   1, 1));
++	  break;
++	case 'k':		/* size in 1K blocks */
++	  /* UNTRUSTED, but not exploitable I think */
++	  checked_fprintf (dest, segment->text,
++			   human_readable ((uintmax_t) ST_NBLOCKS (*stat_buf),
++					   hbuf, human_ceiling,
++					   ST_NBLOCKSIZE, 1024)); 
++	  break;
++	case 'l':		/* object of symlink */
++	  /* sanitised */
++#ifdef S_ISLNK
++	  {
++	    char *linkname = 0;
++
++	    if (S_ISLNK (stat_buf->st_mode))
++	      {
++		linkname = get_link_name_at (pathname, state.cwd_dir_fd, state.rel_pathname);
++		if (linkname == 0)
++		  state.exit_status = 1;
++	      }
++	    if (linkname)
++	      {
++		checked_print_quoted (dest, segment->text, linkname);
++		free (linkname);
++	      }
++	    else
++	      {
++		/* We still need to honour the field width etc., so this is
++		 * not a no-op.
++		 */
++		checked_print_quoted (dest, segment->text, "");
++	      }
++	  }
++#endif				/* S_ISLNK */
++	  break;
++
++	case 'M':		/* mode as 10 chars (eg., "-rwxr-x--x" */
++	  /* UNTRUSTED, probably unexploitable */
++	  {
++	    char modestring[16] ;
++	    filemodestring (stat_buf, modestring);
++	    modestring[10] = '\0';
++	    checked_fprintf (dest, segment->text, modestring);
++	  }
++	  break;
++
++	case 'm':		/* mode as octal number (perms only) */
++	  /* UNTRUSTED, probably unexploitable */
++	  {
++	    /* Output the mode portably using the traditional numbers,
++	       even if the host unwisely uses some other numbering
++	       scheme.  But help the compiler in the common case where
++	       the host uses the traditional numbering scheme.  */
++	    mode_t m = stat_buf->st_mode;
++	    boolean traditional_numbering_scheme =
++	      (S_ISUID == 04000 && S_ISGID == 02000 && S_ISVTX == 01000
++	       && S_IRUSR == 00400 && S_IWUSR == 00200 && S_IXUSR == 00100
++	       && S_IRGRP == 00040 && S_IWGRP == 00020 && S_IXGRP == 00010
++	       && S_IROTH == 00004 && S_IWOTH == 00002 && S_IXOTH == 00001);
++	    checked_fprintf (dest, segment->text,
++		     (traditional_numbering_scheme
++		      ? m & MODE_ALL
++		      : ((m & S_ISUID ? 04000 : 0)
++			 | (m & S_ISGID ? 02000 : 0)
++			 | (m & S_ISVTX ? 01000 : 0)
++			 | (m & S_IRUSR ? 00400 : 0)
++			 | (m & S_IWUSR ? 00200 : 0)
++			 | (m & S_IXUSR ? 00100 : 0)
++			 | (m & S_IRGRP ? 00040 : 0)
++			 | (m & S_IWGRP ? 00020 : 0)
++			 | (m & S_IXGRP ? 00010 : 0)
++			 | (m & S_IROTH ? 00004 : 0)
++			 | (m & S_IWOTH ? 00002 : 0)
++			 | (m & S_IXOTH ? 00001 : 0))));
++	  }
++	  break;
++	  
++	case 'n':		/* number of links */
++	  /* UNTRUSTED, probably unexploitable */
++	  checked_fprintf (dest, segment->text,
++		   human_readable ((uintmax_t) stat_buf->st_nlink,
++				   hbuf,
++				   human_ceiling,
++				   1, 1));
++	  break;
++
++	case 'p':		/* pathname */
++	  /* sanitised */
++	  checked_print_quoted (dest, segment->text, pathname);
++	  break;
++
++	case 'P':		/* pathname with ARGV element stripped */
++	  /* sanitised */
++	  if (state.curdepth > 0)
++	    {
++	      cp = pathname + state.starting_path_length;
++	      if (*cp == '/')
++		/* Move past the slash between the ARGV element
++		   and the rest of the pathname.  But if the ARGV element
++		   ends in a slash, we didn't add another, so we've
++		   already skipped past it.  */
++		cp++;
++	    }
++	  else
++	    {
++	      cp = "";
++	    }
++	  checked_print_quoted (dest, segment->text, cp);
++	  break;
++	  
++	case 's':		/* size in bytes */
++	  /* UNTRUSTED, probably unexploitable */
++	  checked_fprintf (dest, segment->text,
++		   human_readable ((uintmax_t) stat_buf->st_size,
++				   hbuf, human_ceiling, 1, 1));
++	  break;
++	  
++	case 'S':		/* sparseness */
++	  /* UNTRUSTED, probably unexploitable */
++	  checked_fprintf (dest, segment->text, file_sparseness(stat_buf));;
++	  break;
++	  
++	case 't':		/* mtime in `ctime' format */
++	  /* UNTRUSTED, probably unexploitable */
++	  checked_fprintf (dest, segment->text,
++			   ctime_format (get_stat_mtime(stat_buf)));
++	  break;
++	  
++	case 'u':		/* user name */
++	  /* trusted */
++	  /* (well, the actual user is selected by the user on systems
++	   * where chown is not restricted, but the user name was
++	   * selected by the system administrator)
++	   */
++	  {
++	    struct passwd *p;
++
++	    p = getpwuid (stat_buf->st_uid);
++	    if (p)
++	      {
++		segment->text[segment->text_len] = 's';
++		checked_fprintf (dest, segment->text, p->pw_name);
++		break;
++	      }
++	    /* else fallthru */
++	  }
++	  /* FALLTHROUGH*/ /* .. to case U */
++	  
++	case 'U':		/* UID number */
++	  /* UNTRUSTED, probably unexploitable */
++	  checked_fprintf (dest, segment->text,
++			   human_readable ((uintmax_t) stat_buf->st_uid, hbuf,
++					   human_ceiling, 1, 1));
++	  break;
++
++	  /* %Y: type of file system entry like `ls -l`: 
++	   *     (d,-,l,s,p,b,c,n) n=nonexistent(symlink) 
++	   */
++	case 'Y':		/* in case of symlink */
++	  /* trusted */
++	  {
++#ifdef S_ISLNK
++	    if (S_ISLNK (stat_buf->st_mode))
++	      {
++		struct stat sbuf;
++		/* If we would normally follow links, do not do so.
++		 * If we would normally not follow links, do so.
++		 */
++		if ((following_links() ? lstat : stat)
++		    (state.rel_pathname, &sbuf) != 0)
++		  {
++		    if ( errno == ENOENT )
++		      {
++			checked_fprintf (dest, segment->text, "N");
++			break;
++		      }
++		    else if ( errno == ELOOP )
++		      {
++			checked_fprintf (dest, segment->text, "L");
++			break;
++		      }
++		    else 
++		      {
++			checked_fprintf (dest, segment->text, "?");
++			error (0, errno, "%s",
++			       safely_quote_err_filename(0, pathname));
++			/* exit_status = 1;
++			   return ; */
++			break;
++		      }
++		  }
++		checked_fprintf (dest, segment->text,
++				 mode_to_filetype(sbuf.st_mode & S_IFMT));
++	      }
++#endif /* S_ISLNK */
++	    else
++	      {
++		checked_fprintf (dest, segment->text,
++				 mode_to_filetype(stat_buf->st_mode & S_IFMT));
++	      }
++	  }
++	  break;
++
++	case 'y':
++	  /* trusted */
++	  {
++	    checked_fprintf (dest, segment->text,
++			     mode_to_filetype(stat_buf->st_mode & S_IFMT));
++	  }
++	  break;
++	}
++      /* end of KIND_FORMAT case */
++      break;
++    }
++}
++
++boolean
++pred_fprintf (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  struct format_val *dest = &pred_ptr->args.printf_vec;
++  struct segment *segment;
++
++  for (segment = dest->segment; segment; segment = segment->next)
++    {
++      if ( (KIND_FORMAT == segment->segkind) && segment->format_char[1]) /* Component of date. */
++	{
++	  struct timespec ts;
++	  int valid = 0;
++	  
++	  switch (segment->format_char[0])
++	    {
++	    case 'A':
++	      ts = get_stat_atime(stat_buf);
++	      valid = 1;
++	      break;
++	    case 'B':
++	      ts = get_stat_birthtime(stat_buf);
++	      if ('@' == segment->format_char[1])
++		valid = 1;
++	      else
++		valid = (ts.tv_nsec >= 0);
++	      break;
++	    case 'C':
++	      ts = get_stat_ctime(stat_buf);
++	      valid = 1;
++	      break;
++	    case 'T':
++	      ts = get_stat_mtime(stat_buf);
++	      valid = 1;
++	      break;
++	    default:
++	      assert (0);
++	      abort ();
++	    }
++	  /* We trust the output of format_date not to contain 
++	   * nasty characters, though the value of the date
++	   * is itself untrusted data.
++	   */
++	  if (valid)
++	    {
++	      /* trusted */
++	      checked_fprintf (dest, segment->text,
++			       format_date (ts, segment->format_char[1]));
++	    }
++	  else
++	    {
++	      /* The specified timestamp is not available, output
++	       * nothing for the timestamp, but use the rest (so that
++	       * for example find foo -printf '[%Bs] %p\n' can print
++	       * "[] foo").
++	       */
++	      /* trusted */
++	      checked_fprintf (dest, segment->text, "");
++	    }
++	}
++      else
++	{
++	  /* Print a segment which is not a date. */
++	  do_fprintf(dest, segment, pathname, stat_buf);
++	}
++    }
++  return true;
++}
++
++boolean
++pred_fstype (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) pathname;
++  
++  if (strcmp (filesystem_type (stat_buf, pathname), pred_ptr->args.str) == 0)
++    return true;
++  else
++    return false;
++}
++
++boolean
++pred_gid (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) pathname;
++  
++  switch (pred_ptr->args.numinfo.kind)
++    {
++    case COMP_GT:
++      if (stat_buf->st_gid > pred_ptr->args.numinfo.l_val)
++	return (true);
++      break;
++    case COMP_LT:
++      if (stat_buf->st_gid < pred_ptr->args.numinfo.l_val)
++	return (true);
++      break;
++    case COMP_EQ:
++      if (stat_buf->st_gid == pred_ptr->args.numinfo.l_val)
++	return (true);
++      break;
++    }
++  return (false);
++}
++
++boolean
++pred_group (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) pathname;
++  
++  if (pred_ptr->args.gid == stat_buf->st_gid)
++    return (true);
++  else
++    return (false);
++}
++
++boolean
++pred_ilname (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  return match_lname (pathname, stat_buf, pred_ptr, true);
++}
++
++/* Common code between -name, -iname.  PATHNAME is being visited, STR
++   is name to compare basename against, and FLAGS are passed to
++   fnmatch.  Recall that 'find / -name /' is one of the few times where a '/' 
++   in the -name must actually find something. */ 
++static boolean
++pred_name_common (const char *pathname, const char *str, int flags)
++{
++  char *p;
++  boolean b;
++  /* We used to use last_component() here, but that would not allow us to modify the 
++   * input string, which is const.   We could optimise by duplicating the string only
++   * if we need to modify it, and I'll do that if there is a measurable 
++   * performance difference on a machine built after 1990...
++   */
++  char *base = base_name (pathname);
++  /* remove trailing slashes, but leave  "/" or "//foo" unchanged. */
++  strip_trailing_slashes(base);
++
++  /* FNM_PERIOD is not used here because POSIX requires that it not be.
++   * See http://standards.ieee.org/reading/ieee/interp/1003-2-92_int/pasc-1003.2-126.html
++   */
++  b = fnmatch (str, base, flags) == 0;
++  free (base);
++  return b;
++}
++
++boolean
++pred_iname (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) stat_buf;
++  return pred_name_common (pathname, pred_ptr->args.str, FNM_CASEFOLD);
++}
++
++boolean
++pred_inum (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) pathname;
++  
++  switch (pred_ptr->args.numinfo.kind)
++    {
++    case COMP_GT:
++      if (stat_buf->st_ino > pred_ptr->args.numinfo.l_val)
++	return (true);
++      break;
++    case COMP_LT:
++      if (stat_buf->st_ino < pred_ptr->args.numinfo.l_val)
++	return (true);
++      break;
++    case COMP_EQ:
++      if (stat_buf->st_ino == pred_ptr->args.numinfo.l_val)
++	return (true);
++      break;
++    }
++  return (false);
++}
++
++boolean
++pred_ipath (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) stat_buf;
++  
++  if (fnmatch (pred_ptr->args.str, pathname, FNM_CASEFOLD) == 0)
++    return (true);
++  return (false);
++}
++
++boolean
++pred_links (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) pathname;
++  
++  switch (pred_ptr->args.numinfo.kind)
++    {
++    case COMP_GT:
++      if (stat_buf->st_nlink > pred_ptr->args.numinfo.l_val)
++	return (true);
++      break;
++    case COMP_LT:
++      if (stat_buf->st_nlink < pred_ptr->args.numinfo.l_val)
++	return (true);
++      break;
++    case COMP_EQ:
++      if (stat_buf->st_nlink == pred_ptr->args.numinfo.l_val)
++	return (true);
++      break;
++    }
++  return (false);
++}
++
++boolean
++pred_lname (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  return match_lname (pathname, stat_buf, pred_ptr, false);
++}
++
++static boolean
++match_lname (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr, boolean ignore_case)
++{
++  boolean ret = false;
++#ifdef S_ISLNK
++  if (S_ISLNK (stat_buf->st_mode))
++    {
++      char *linkname = get_link_name_at (pathname, state.cwd_dir_fd, state.rel_pathname);
++      if (linkname)
++	{
++	  if (fnmatch (pred_ptr->args.str, linkname,
++		       ignore_case ? FNM_CASEFOLD : 0) == 0)
++	    ret = true;
++	  free (linkname);
++	}
++    }
++#endif /* S_ISLNK */
++  return ret;
++}
++
++boolean
++pred_ls (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  return pred_fls(pathname, stat_buf, pred_ptr);
++}
++
++boolean
++pred_mmin (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) &pathname;
++  return pred_timewindow(get_stat_mtime(stat_buf), pred_ptr, 60);
++}
++
++boolean
++pred_mtime (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) pathname;
++  return pred_timewindow(get_stat_mtime(stat_buf), pred_ptr, DAYSECS);
++}
++
++boolean
++pred_name (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) stat_buf;
++  return pred_name_common (pathname, pred_ptr->args.str, 0);
++}
++
++boolean
++pred_negate (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  return !apply_predicate(pathname, stat_buf, pred_ptr->pred_right);
++}
++
++boolean
++pred_newer (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) pathname;
++  
++  assert (COMP_GT == pred_ptr->args.reftime.kind);
++  return compare_ts(get_stat_mtime(stat_buf), pred_ptr->args.reftime.ts) > 0;
++}
++
++boolean
++pred_newerXY (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  struct timespec ts;
++  boolean collected = false;
++  
++  assert (COMP_GT == pred_ptr->args.reftime.kind);
++  
++  switch (pred_ptr->args.reftime.xval)
++    {
++    case XVAL_TIME:
++      assert (pred_ptr->args.reftime.xval != XVAL_TIME);
++      return false;
++
++    case XVAL_ATIME:
++      ts = get_stat_atime(stat_buf);
++      collected = true;
++      break;
++      
++    case XVAL_BIRTHTIME:
++      ts = get_stat_birthtime(stat_buf);
++      collected = true;
++      if (ts.tv_nsec < 0);
++	{
++	  /* XXX: Cannot determine birth time.  Warn once. */
++	  error(0, 0, _("Warning: cannot determine birth time of file %s"),
++		safely_quote_err_filename(0, pathname));
++	  return false;
++	}
++      break;
++      
++    case XVAL_CTIME:
++      ts = get_stat_ctime(stat_buf);
++      collected = true;
++      break;
++      
++    case XVAL_MTIME:
++      ts = get_stat_mtime(stat_buf);
++      collected = true;
++      break;
++    }
++  
++  assert (collected);
++  return compare_ts(ts, pred_ptr->args.reftime.ts) > 0;
++}
++
++boolean
++pred_nogroup (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) pathname;
++  (void) pred_ptr;
++  
++#ifdef CACHE_IDS
++  extern char *gid_unused;
++
++  return gid_unused[(unsigned) stat_buf->st_gid];
++#else
++  return getgrgid (stat_buf->st_gid) == NULL;
++#endif
++}
++
++boolean
++pred_nouser (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++#ifdef CACHE_IDS
++  extern char *uid_unused;
++#endif
++  
++  (void) pathname;
++  (void) pred_ptr;
++  
++#ifdef CACHE_IDS
++  return uid_unused[(unsigned) stat_buf->st_uid];
++#else
++  return getpwuid (stat_buf->st_uid) == NULL;
++#endif
++}
++
++
++static boolean
++is_ok(const char *program, const char *arg)
++{
++  fflush (stdout);
++  /* The draft open standard requires that, in the POSIX locale,
++     the last non-blank character of this prompt be '?'.
++     The exact format is not specified.
++     This standard does not have requirements for locales other than POSIX
++  */
++  /* XXX: printing UNTRUSTED data here. */
++  fprintf (stderr, _("< %s ... %s > ? "
++		     /* TRANSLATORS: we would like, if possible, the final non-blank 
++		      * character of this string to be '?', but it is not 
++		      * wholly essential. */
++		     ), program, arg);
++  fflush (stderr);
++  return yesno();
++}
++
++boolean
++pred_ok (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  if (is_ok(pred_ptr->args.exec_vec.replace_vec[0], pathname))
++    return new_impl_pred_exec (get_start_dirfd(),
++			       pathname, stat_buf, pred_ptr, NULL, 0);
++  else
++    return false;
++}
++
++boolean
++pred_okdir (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  const char *prefix = (state.rel_pathname[0] == '/') ? NULL : "./";
++  if (is_ok(pred_ptr->args.exec_vec.replace_vec[0], pathname))
++    return new_impl_pred_exec (get_current_dirfd(),
++			       state.rel_pathname, stat_buf, pred_ptr, 
++			       prefix, (prefix ? 2 : 0));
++  else
++    return false;
++}
++
++boolean
++pred_openparen (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) pathname;
++  (void) stat_buf;
++  (void) pred_ptr;
++  return true;
++}
++
++boolean
++pred_or (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  if (pred_ptr->pred_left == NULL
++      || !apply_predicate(pathname, stat_buf, pred_ptr->pred_left))
++    {
++      return apply_predicate(pathname, stat_buf, pred_ptr->pred_right);
++    }
++  else
++    return true;
++}
++
++boolean
++pred_path (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) stat_buf;
++  if (fnmatch (pred_ptr->args.str, pathname, 0) == 0)
++    return (true);
++  return (false);
++}
++
++boolean
++pred_perm (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  mode_t mode = stat_buf->st_mode;
++  mode_t perm_val = pred_ptr->args.perm.val[S_ISDIR (mode) != 0];
++  (void) pathname;
++  switch (pred_ptr->args.perm.kind)
++    {
++    case PERM_AT_LEAST:
++      return (mode & perm_val) == perm_val;
++      break;
++
++    case PERM_ANY:
++      /* True if any of the bits set in the mask are also set in the file's mode.
++       *
++       *
++       * Otherwise, if onum is prefixed by a hyphen, the primary shall
++       * evaluate as true if at least all of the bits specified in
++       * onum that are also set in the octal mask 07777 are set.
++       *
++       * Eric Blake's interpretation is that the mode argument is zero, 
++       
++       */
++      if (0 == perm_val)
++	return true;		/* Savannah bug 14748; we used to return false */
++      else
++	return (mode & perm_val) != 0;
++      break;
++
++    case PERM_EXACT:
++      return (mode & MODE_ALL) == perm_val;
++      break;
++
++    default:
++      abort ();
++      break;
++    }
++}
++
++
++struct access_check_args
++{
++  const char *filename;
++  int access_type;
++  int cb_errno;
++};
++
++
++static int
++access_callback(void *context)
++{
++  int rv;
++  struct access_check_args *args = context;
++  if ((rv = access(args->filename, args->access_type)) < 0)
++    args->cb_errno = errno;
++  return rv;
++}
++
++static int
++can_access(int access_type)
++{
++  struct access_check_args args;
++  args.filename = state.rel_pathname;
++  args.access_type = access_type;
++  args.cb_errno = 0;
++  return 0 == run_in_dir(state.cwd_dir_fd, access_callback, &args);
++}
++
++
++boolean
++pred_executable (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) pathname;
++  (void) stat_buf;
++  (void) pred_ptr;
++  
++  return can_access(X_OK);
++}
++
++boolean
++pred_readable (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) pathname;
++  (void) stat_buf;
++  (void) pred_ptr;
++  
++  return can_access(R_OK);
++}
++
++boolean
++pred_writable (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) pathname;
++  (void) stat_buf;
++  (void) pred_ptr;
++  
++  return can_access(W_OK);
++}
++
++boolean
++pred_print (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) stat_buf;
++  (void) pred_ptr;
++
++  print_quoted(pred_ptr->args.printf_vec.stream,
++	       pred_ptr->args.printf_vec.quote_opts,
++	       pred_ptr->args.printf_vec.dest_is_tty,
++	       "%s\n", pathname);
++  return true;
++}
++
++boolean
++pred_print0 (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  return pred_fprint0(pathname, stat_buf, pred_ptr);
++}
++
++boolean
++pred_prune (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) pathname;
++  (void) pred_ptr;
++
++  if (options.do_dir_first == true && /* no effect with -depth */
++      stat_buf != NULL &&
++      S_ISDIR(stat_buf->st_mode))
++    state.stop_at_current_level = true;
++
++  /* findutils used to return options.do_dir_first here, so that -prune
++   * returns true only if -depth is not in effect.   But POSIX requires 
++   * that -prune always evaluate as true.
++   */
++  return true;
++}
++
++boolean
++pred_quit (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) pathname;
++  (void) stat_buf;
++  (void) pred_ptr;
++
++  /* Run any cleanups.  This includes executing any command lines 
++   * we have partly built but not executed.
++   */
++  cleanup();
++  
++  /* Since -exec and friends don't leave child processes running in the 
++   * background, there is no need to wait for them here.
++   */
++  exit(state.exit_status);	/* 0 for success, etc. */
++}
++
++boolean
++pred_regex (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  int len = strlen (pathname);
++(void) stat_buf;
++  if (re_match (pred_ptr->args.regex, pathname, len, 0,
++		(struct re_registers *) NULL) == len)
++    return (true);
++  return (false);
++}
++
++boolean
++pred_size (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  uintmax_t f_val;
++
++  (void) pathname;
++  f_val = ((stat_buf->st_size / pred_ptr->args.size.blocksize)
++	   + (stat_buf->st_size % pred_ptr->args.size.blocksize != 0));
++  switch (pred_ptr->args.size.kind)
++    {
++    case COMP_GT:
++      if (f_val > pred_ptr->args.size.size)
++	return (true);
++      break;
++    case COMP_LT:
++      if (f_val < pred_ptr->args.size.size)
++	return (true);
++      break;
++    case COMP_EQ:
++      if (f_val == pred_ptr->args.size.size)
++	return (true);
++      break;
++    }
++  return (false);
++}
++
++boolean
++pred_samefile (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  /* Potential optimisation: because of the loop protection, we always
++   * know the device of the current directory, hence the device number
++   * of the file we're currently considering.  If -L is not in effect,
++   * and the device number of the file we're looking for is not the
++   * same as the device number of the current directory, this
++   * predicate cannot return true.  Hence there would be no need to
++   * stat the file we're looking at.
++   */
++  (void) pathname;
++
++  /* We will often still have an fd open on the file under consideration,
++   * but that's just to ensure inode number stability by maintaining 
++   * a reference to it; we don't need the file for anything else.
++   */
++  return stat_buf->st_ino == pred_ptr->args.samefileid.ino
++    &&   stat_buf->st_dev == pred_ptr->args.samefileid.dev;
++}
++
++boolean
++pred_true (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) pathname;
++  (void) stat_buf;
++  (void) pred_ptr;
++  return true;
++}
++
++boolean
++pred_type (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  mode_t mode;
++  mode_t type = pred_ptr->args.type;
++
++  assert (state.have_type);
++
++  if (0 == state.type)
++    {
++      /* This can sometimes happen with broken NFS servers. 
++       * See Savannah bug #16378.
++       */
++      return false;
++    }
++  
++  (void) pathname;
++
++  if (state.have_stat)
++     mode = stat_buf->st_mode;
++  else
++     mode = state.type;
++
++#ifndef S_IFMT
++  /* POSIX system; check `mode' the slow way. */
++  if ((S_ISBLK (mode) && type == S_IFBLK)
++      || (S_ISCHR (mode) && type == S_IFCHR)
++      || (S_ISDIR (mode) && type == S_IFDIR)
++      || (S_ISREG (mode) && type == S_IFREG)
++#ifdef S_IFLNK
++      || (S_ISLNK (mode) && type == S_IFLNK)
++#endif
++#ifdef S_IFIFO
++      || (S_ISFIFO (mode) && type == S_IFIFO)
++#endif
++#ifdef S_IFSOCK
++      || (S_ISSOCK (mode) && type == S_IFSOCK)
++#endif
++#ifdef S_IFDOOR
++      || (S_ISDOOR (mode) && type == S_IFDOOR)
++#endif
++      )
++#else /* S_IFMT */
++  /* Unix system; check `mode' the fast way. */
++  if ((mode & S_IFMT) == type)
++#endif /* S_IFMT */
++    return (true);
++  else
++    return (false);
++}
++
++boolean
++pred_uid (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) pathname;
++  switch (pred_ptr->args.numinfo.kind)
++    {
++    case COMP_GT:
++      if (stat_buf->st_uid > pred_ptr->args.numinfo.l_val)
++	return (true);
++      break;
++    case COMP_LT:
++      if (stat_buf->st_uid < pred_ptr->args.numinfo.l_val)
++	return (true);
++      break;
++    case COMP_EQ:
++      if (stat_buf->st_uid == pred_ptr->args.numinfo.l_val)
++	return (true);
++      break;
++    }
++  return (false);
++}
++
++boolean
++pred_used (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  struct timespec delta, at, ct;
++
++  (void) pathname;
++
++  /* TODO: this needs to be retested carefully (manually, if necessary) */
++  at = get_stat_atime(stat_buf);
++  ct = get_stat_ctime(stat_buf);
++  delta.tv_sec  = at.tv_sec  - ct.tv_sec;
++  delta.tv_nsec = at.tv_nsec - ct.tv_nsec;
++  if (delta.tv_nsec < 0)
++    {
++      delta.tv_nsec += 1000000000;
++      delta.tv_sec  -=          1;
++    }
++  return pred_timewindow(delta, pred_ptr, DAYSECS);
++}
++
++boolean
++pred_user (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  (void) pathname;
++  if (pred_ptr->args.uid == stat_buf->st_uid)
++    return (true);
++  else
++    return (false);
++}
++
++boolean
++pred_xtype (const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr)
++{
++  struct stat sbuf;		/* local copy, not stat_buf because we're using a different stat method */
++  int (*ystat) (const char*, struct stat *p);
++
++  /* If we would normally stat the link itself, stat the target instead.
++   * If we would normally follow the link, stat the link itself instead. 
++   */
++  if (following_links())
++    ystat = optionp_stat;
++  else
++    ystat = optionl_stat;
++  
++  set_stat_placeholders(&sbuf);
++  if ((*ystat) (state.rel_pathname, &sbuf) != 0)
++    {
++      if (following_links() && errno == ENOENT)
++	{
++	  /* If we failed to follow the symlink,
++	   * fall back on looking at the symlink itself. 
++	   */
++	  /* Mimic behavior of ls -lL. */
++	  return (pred_type (pathname, stat_buf, pred_ptr));
++	}
++      else
++	{
++	  error (0, errno, "%s", safely_quote_err_filename(0, pathname));
++	  state.exit_status = 1;
++	}
++      return false;
++    }
++  /* Now that we have our stat() information, query it in the same 
++   * way that -type does.
++   */
++  return (pred_type (pathname, &sbuf, pred_ptr));
++}
++
++/*  1) fork to get a child; parent remembers the child pid
++    2) child execs the command requested
++    3) parent waits for child; checks for proper pid of child
++
++    Possible returns:
++
++    ret		errno	status(h)   status(l)
++
++    pid		x	signal#	    0177	stopped
++    pid		x	exit arg    0		term by _exit
++    pid		x	0	    signal #	term by signal
++    -1		EINTR				parent got signal
++    -1		other				some other kind of error
++
++    Return true only if the pid matches, status(l) is
++    zero, and the exit arg (status high) is 0.
++    Otherwise return false, possibly printing an error message. */
++
++
++static boolean
++prep_child_for_exec (boolean close_stdin, int dirfd)
++{
++  boolean ok = true;
++  if (close_stdin)
++    {
++      const char inputfile[] = "/dev/null";
++      
++      if (close(0) < 0)
++	{
++	  error(0, errno, _("Cannot close standard input"));
++	  ok = false;
++	}
++      else 
++	{
++	  if (open(inputfile, O_RDONLY
++#if defined O_LARGEFILE
++		   |O_LARGEFILE
++#endif
++		   ) < 0)
++	    {
++	      /* This is not entirely fatal, since 
++	       * executing the child with a closed
++	       * stdin is almost as good as executing it
++	       * with its stdin attached to /dev/null.
++	       */
++	      error (0, errno, "%s", safely_quote_err_filename(0, inputfile));
++	      /* do not set ok=false, it is OK to continue anyway. */
++	    }
++	}
++    }
++
++  /* Even if DebugSearch is set, don't announce our change of
++   * directory, since we're not going to emit a subsequent
++   * announcement of a call to stat() anyway, as we're about to exec
++   * something.
++   */
++  if (dirfd != AT_FDCWD)
++    {
++      assert (dirfd >= 0);
++      if (0 != fchdir(dirfd))
++	{
++	  /* If we cannot execute our command in the correct directory,
++	   * we should not execute it at all.
++	   */
++	  error(0, errno, _("Failed to change directory"));
++	  ok = false;
++	}
++    }
++  return ok;
++}
++
++
++
++int
++launch (const struct buildcmd_control *ctl,
++	struct buildcmd_state *buildstate)
++{
++  int wait_status;
++  pid_t child_pid;
++  static int first_time = 1;
++  const struct exec_val *execp = buildstate->usercontext;
++
++  if (!execp->use_current_dir)
++    {
++      assert (starting_desc >= 0);
++      assert (execp->dirfd == starting_desc);
++    }
++  
++	
++  /* Null terminate the arg list.  */
++  bc_push_arg (ctl, buildstate, (char *) NULL, 0, NULL, 0, false); 
++  
++  /* Make sure output of command doesn't get mixed with find output. */
++  fflush (stdout);
++  fflush (stderr);
++  
++  /* Make sure to listen for the kids.  */
++  if (first_time)
++    {
++      first_time = 0;
++      signal (SIGCHLD, SIG_DFL);
++    }
++
++  child_pid = fork ();
++  if (child_pid == -1)
++    error (1, errno, _("cannot fork"));
++  if (child_pid == 0)
++    {
++      /* We are the child. */
++      assert (starting_desc >= 0);
++      if (!prep_child_for_exec(execp->close_stdin, execp->dirfd))
++	{
++	  _exit(1);
++	}
++      
++      execvp (buildstate->cmd_argv[0], buildstate->cmd_argv);
++      error (0, errno, "%s",
++	     safely_quote_err_filename(0, buildstate->cmd_argv[0]));
++      _exit (1);
++    }
++
++
++  /* In parent; set up for next time. */
++  bc_clear_args(ctl, buildstate);
++
++  
++  while (waitpid (child_pid, &wait_status, 0) == (pid_t) -1)
++    {
++      if (errno != EINTR)
++	{
++	  error (0, errno, _("error waiting for %s"),
++		 safely_quote_err_filename(0, buildstate->cmd_argv[0]));
++	  state.exit_status = 1;
++	  return 0;		/* FAIL */
++	}
++    }
++  
++  if (WIFSIGNALED (wait_status))
++    {
++      error (0, 0, _("%1$s terminated by signal %2$d"),
++	     quotearg_n_style(0, options.err_quoting_style,
++			      buildstate->cmd_argv[0]),
++	     WTERMSIG (wait_status));
++      
++      if (execp->multiple)
++	{
++	  /* -exec   \; just returns false if the invoked command fails. 
++	   * -exec {} + returns true if the invoked command fails, but
++	   *            sets the program exit status.
++	   */
++	  state.exit_status = 1;
++	}
++      
++      return 1;			/* OK */
++    }
++
++  if (0 == WEXITSTATUS (wait_status))
++    {
++      return 1;			/* OK */
++    }
++  else
++    {
++      if (execp->multiple)
++	{
++	  /* -exec   \; just returns false if the invoked command fails. 
++	   * -exec {} + returns true if the invoked command fails, but
++	   *            sets the program exit status.
++	   */
++	  state.exit_status = 1;
++	}
++      return 0;			/* FAIL */
++    }
++  
++}
++
++
++/* Return a static string formatting the time WHEN according to the
++ * strftime format character KIND.
++ *
++ * This function contains a number of assertions.  These look like
++ * runtime checks of the results of computations, which would be a
++ * problem since external events should not be tested for with
++ * "assert" (instead you should use "if").  However, they are not
++ * really runtime checks.  The assertions actually exist to verify
++ * that the various buffers are correctly sized.
++ */
++static char *
++format_date (struct timespec ts, int kind)
++{
++  /* In theory, we use an extra 10 characters for 9 digits of
++   * nanoseconds and 1 for the decimal point.  However, the real
++   * world is more complex than that.
++   *
++   * For example, some systems return junk in the tv_nsec part of
++   * st_birthtime.  An example of this is the NetBSD-4.0-RELENG kernel
++   * (at Sat Mar 24 18:46:46 2007) running a NetBSD-3.1-RELEASE
++   * runtime and examining files on an msdos filesytem.  So for that 
++   * reason we set NS_BUF_LEN to 32, which is simply "long enough" as 
++   * opposed to "exactly the right size".  Note that the behaviour of 
++   * NetBSD appears to be a result of the use of uninitialised data, 
++   * as it's not 100% reproducible (more like 25%).
++   */
++  enum {
++    NS_BUF_LEN = 32,
++    DATE_LEN_PERCENT_APLUS=21	/* length of result of %A+ (it's longer than %c)*/
++  };	  
++  static char buf[128u+10u + MAX(DATE_LEN_PERCENT_APLUS,
++			    MAX (LONGEST_HUMAN_READABLE + 2, NS_BUF_LEN+64+200))];
++  char ns_buf[NS_BUF_LEN]; /* -.9999999990 (- sign can happen!)*/
++  int  charsprinted, need_ns_suffix;
++  struct tm *tm;
++  char fmt[6];
++
++  /* human_readable() assumes we pass a buffer which is at least as
++   * long as LONGEST_HUMAN_READABLE.  We use an assertion here to
++   * ensure that no nasty unsigned overflow happend in our calculation
++   * of the size of buf.  Do the assertion here rather than in the
++   * code for %@ so that we find the problem quickly if it exists.  If
++   * you want to submit a patch to move this into the if statement, go
++   * ahead, I'll apply it.  But include performance timings
++   * demonstrating that the performance difference is actually
++   * measurable.
++   */
++  verify (sizeof(buf) >= LONGEST_HUMAN_READABLE);
++
++  charsprinted = 0;
++  need_ns_suffix = 0;
++  
++  /* Format the main part of the time. */
++  if (kind == '+')
++    {
++      strcpy (fmt, "%F+%T");
++      need_ns_suffix = 1;
++    }
++  else
++    {
++      fmt[0] = '%';
++      fmt[1] = kind;
++      fmt[2] = '\0';
++
++      /* %a, %c, and %t are handled in ctime_format() */
++      switch (kind)
++	{
++	case 'S':
++	case 'T':
++	case 'X':
++	case '@':
++	  need_ns_suffix = 1;
++	  break;
++	default:
++	  need_ns_suffix = 0;
++	  break;
++	}
++    }
++
++  if (need_ns_suffix)
++    {
++      /* Format the nanoseconds part.  Leave a trailing zero to
++       * discourage people from writing scripts which extract the
++       * fractional part of the timestamp by using column offsets.
++       * The reason for discouraging this is that in the future, the
++       * granularity may not be nanoseconds.
++       */
++      ns_buf[0] = 0;
++      charsprinted = snprintf(ns_buf, NS_BUF_LEN, ".%09ld0", (long int)ts.tv_nsec);
++      assert (charsprinted < NS_BUF_LEN);
++    }
++
++  if (kind != '@'
++      && (tm = localtime (&ts.tv_sec))
++      && strftime (buf, sizeof buf, fmt, tm))
++    {
++      /* For %AS, %CS, %TS, add the fractional part of the seconds
++       * information.
++       */
++      if (need_ns_suffix)
++	{
++	  assert ((sizeof buf - strlen(buf)) > strlen(ns_buf));
++	  strcat(buf, ns_buf);
++	}
++      return buf;
++    }
++  else
++    {
++      uintmax_t w = ts.tv_sec;
++      size_t used, len, remaining;
++
++      /* XXX: note that we are negating an unsigned type which is the
++       * widest possible unsigned type.
++       */
++      char *p = human_readable (ts.tv_sec < 0 ? -w : w, buf + 1,
++				human_ceiling, 1, 1);
++      assert (p > buf);
++      assert (p < (buf + (sizeof buf)));
++      if (ts.tv_sec < 0)
++	*--p = '-'; /* XXX: Ugh, relying on internal details of human_readable(). */
++
++      /* Add the nanoseconds part.  Because we cannot enforce a
++       * particlar implementation of human_readable, we cannot assume
++       * any particular value for (p-buf).  So we need to be careful
++       * that there is enough space remaining in the buffer.
++       */
++      if (need_ns_suffix)
++	{
++	  len = strlen(p);
++	  used = (p-buf) + len;	/* Offset into buf of current end */
++	  assert (sizeof buf > used); /* Ensure we can perform subtraction safely. */
++	  remaining = sizeof buf - used - 1u; /* allow space for NUL */
++	  
++	  if (strlen(ns_buf) >= remaining)
++	    {
++	      error(0, 0,
++		    "charsprinted=%ld but remaining=%lu: ns_buf=%s",
++		    (long)charsprinted, (unsigned long)remaining, ns_buf);
++	    }
++	  assert (strlen(ns_buf) < remaining);
++	  strcat(p, ns_buf);
++	}
++      return p;
++    }
++}
++
++static const char *weekdays[] = 
++  {
++    "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
++  };
++static char * months[] = 
++  {
++    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
++    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
++  };
++
++
++static char *
++ctime_format (struct timespec ts)
++{
++  const struct tm * ptm;
++#define TIME_BUF_LEN 1024u
++  static char resultbuf[TIME_BUF_LEN];
++  int nout;
++  
++  ptm = localtime(&ts.tv_sec);
++  if (ptm)
++    {
++      assert (ptm->tm_wday >=  0);
++      assert (ptm->tm_wday <   7);
++      assert (ptm->tm_mon  >=  0);
++      assert (ptm->tm_mon  <  12);
++      assert (ptm->tm_hour >=  0);
++      assert (ptm->tm_hour <  24);
++      assert (ptm->tm_min  <  60);
++      assert (ptm->tm_sec  <= 61); /* allows 2 leap seconds. */
++      
++      /* wkday mon mday hh:mm:ss.nnnnnnnnn yyyy */
++      nout = snprintf(resultbuf, TIME_BUF_LEN,
++		      "%3s %3s %2d %02d:%02d:%02d.%010ld %04d",
++		      weekdays[ptm->tm_wday],
++		      months[ptm->tm_mon],
++		      ptm->tm_mday,
++		      ptm->tm_hour,
++		      ptm->tm_min,
++		      ptm->tm_sec,
++		      (long int)ts.tv_nsec,
++		      1900 + ptm->tm_year);
++      
++      assert (nout < TIME_BUF_LEN);
++      return resultbuf;
++    }
++  else
++    {
++      /* The time cannot be represented as a struct tm.
++	 Output it as an integer.  */
++      return format_date (ts, '@');
++    }
++}
++
++/* Copy STR into BUF and trim blanks from the end of BUF.
++   Return BUF. */
++
++static char *
++blank_rtrim (str, buf)
++     char *str;
++     char *buf;
++{
++  int i;
++
++  if (str == NULL)
++    return (NULL);
++  strcpy (buf, str);
++  i = strlen (buf) - 1;
++  while ((i >= 0) && ((buf[i] == ' ') || buf[i] == '\t'))
++    i--;
++  buf[++i] = '\0';
++  return (buf);
++}
++
++/* Print out the predicate list starting at NODE. */
++void
++print_list (FILE *fp, struct predicate *node)
++{
++  struct predicate *cur;
++  char name[256];
++
++  cur = node;
++  while (cur != NULL)
++    {
++      fprintf (fp, "[%s] ", blank_rtrim (cur->p_name, name));
++      cur = cur->pred_next;
++    }
++  fprintf (fp, "\n");
++}
++
++/* Print out the predicate list starting at NODE. */
++static void
++print_parenthesised(FILE *fp, struct predicate *node)
++{
++  int parens = 0;
++
++  if (node)
++    {
++      if ((pred_is(node, pred_or) || pred_is(node, pred_and))
++	  && node->pred_left == NULL)
++	{
++	  /* We print "<nothing> or  X" as just "X"
++	   * We print "<nothing> and X" as just "X"
++	   */
++	  print_parenthesised(fp, node->pred_right);
++	}
++      else
++	{
++	  if (node->pred_left || node->pred_right)
++	    parens = 1;
++
++	  if (parens)
++	    fprintf(fp, "%s", " ( ");
++	  print_optlist(fp, node);
++	  if (parens)
++	    fprintf(fp, "%s", " ) ");
++	}
++    }
++}
++
++void
++print_optlist (FILE *fp, const struct predicate *p)
++{
++  if (p)
++    {
++      print_parenthesised(fp, p->pred_left);
++      fprintf (fp,
++	       "%s%s",
++	       p->need_stat ? "[call stat] " : "",
++	       p->need_type ? "[need type] " : "");
++      print_predicate(fp, p);
++      fprintf(fp, " [%g] ", p->est_success_rate);
++      if (options.debug_options & DebugSuccessRates)
++	{
++	  fprintf(fp, "[%ld/%ld", p->perf.successes, p->perf.visits);
++	  if (p->perf.visits)
++	    {
++	      double real_rate = (double)p->perf.successes / (double)p->perf.visits;
++	      fprintf(fp, "=%g] ", real_rate);
++	    }
++	  else
++	    {
++	      fprintf(fp, "=_] ");
++	    }
++	}
++      print_parenthesised(fp, p->pred_right);
++    }
++}
++
++void show_success_rates(const struct predicate *p)
++{
++  if (options.debug_options & DebugSuccessRates)
++    {
++      fprintf(stderr, "Predicate success rates after completion:\n");
++      print_optlist(stderr, p);
++      fprintf(stderr, "\n");
++    }
++}
++
++
++
++
++#ifdef _NDEBUG
++/* If _NDEBUG is defined, the assertions will do nothing.   Hence 
++ * there is no point in having a function body for pred_sanity_check()
++ * if that preprocessor macro is defined. 
++ */
++void
++pred_sanity_check(const struct predicate *predicates)
++{
++  /* Do nothing, since assert is a no-op with _NDEBUG set */
++  return;
++}
++#else
++void
++pred_sanity_check(const struct predicate *predicates)
++{
++  const struct predicate *p;
++  
++  for (p=predicates; p != NULL; p=p->pred_next)
++    {
++      /* All predicates must do something. */
++      assert (p->pred_func != NULL);
++
++      /* All predicates must have a parser table entry. */
++      assert (p->parser_entry != NULL);
++      
++      /* If the parser table tells us that just one predicate function is 
++       * possible, verify that that is still the one that is in effect.
++       * If the parser has NULL for the predicate function, that means that 
++       * the parse_xxx function fills it in, so we can't check it.
++       */
++      if (p->parser_entry->pred_func)
++	{
++	  assert (p->parser_entry->pred_func == p->pred_func);
++	}
++      
++      switch (p->parser_entry->type)
++	{
++	  /* Options all take effect during parsing, so there should
++	   * be no predicate entries corresponding to them.  Hence we
++	   * should not see any ARG_OPTION or ARG_POSITIONAL_OPTION
++	   * items.
++	   *
++	   * This is a silly way of coding this test, but it prevents
++	   * a compiler warning (i.e. otherwise it would think that
++	   * there would be case statements missing).
++	   */
++	case ARG_OPTION:
++	case ARG_POSITIONAL_OPTION:
++	  assert (p->parser_entry->type != ARG_OPTION);
++	  assert (p->parser_entry->type != ARG_POSITIONAL_OPTION);
++	  break;
++	  
++	case ARG_ACTION:
++	  assert(p->side_effects); /* actions have side effects. */
++	  if (!pred_is(p, pred_prune) && !pred_is(p, pred_quit))
++	    {
++	      /* actions other than -prune and -quit should
++	       * inhibit the default -print
++	       */
++	      assert (p->no_default_print);
++	    }
++	  break;
++
++	/* We happen to know that the only user of ARG_SPECIAL_PARSE
++	 * is a test, so handle it like ARG_TEST.
++	 */
++	case ARG_SPECIAL_PARSE:
++	case ARG_TEST:
++	case ARG_PUNCTUATION:
++	case ARG_NOOP:
++	  /* Punctuation and tests should have no side
++	   * effects and not inhibit default print.
++	   */
++	  assert (!p->no_default_print);
++	  assert (!p->side_effects);
++	  break;
++	}
++    }
++}
++#endif
+diff -purN findutils-4.3.12.orig/find/tree.c findutils-4.3.12/find/tree.c
+--- findutils-4.3.12.orig/find/tree.c	2007-12-19 16:12:34.000000000 -0500
++++ findutils-4.3.12/find/tree.c	2008-01-30 08:46:05.758843847 -0500
+@@ -1195,6 +1195,10 @@ build_expression_tree(int argc, char *ar
+   const struct parser_table *entry_close, *entry_print, *entry_open;
+   int i, oldi;
+ 
++#ifdef WITH_SELINUX
++  int is_selinux_enabled_flag = is_selinux_enabled()>0;
++#endif /* WITH_SELINUX */
++
+   predicates = NULL;
+   
+   /* Find where in ARGV the predicates begin by skipping the list of
+@@ -1230,6 +1234,16 @@ build_expression_tree(int argc, char *ar
+ 	}
+ 
+       predicate_name = argv[i];
++
++#ifdef WITH_SELINUX
++      if (! is_selinux_enabled_flag) {
++	if ((strncmp(predicate_name,"-context",strlen("-context"))==0) ||
++	    (strncmp(predicate_name,"--context",strlen("--context"))==0)) {
++	  error (1, 0,_("Error: invalid predicate %s: the kernel is not selinux-enabled.\n"),predicate_name);
++	}
++      }
++#endif
++
+       parse_entry = find_parser (predicate_name);
+       if (parse_entry == NULL)
+ 	{
+@@ -1434,6 +1448,9 @@ get_new_pred (const struct parser_table 
+   last_pred->need_stat = true;
+   last_pred->need_type = true;
+   last_pred->args.str = NULL;
++#ifdef WITH_SELINUX
++  last_pred->args.scontext = NULL;
++#endif
+   last_pred->pred_next = NULL;
+   last_pred->pred_left = NULL;
+   last_pred->pred_right = NULL;