find/parser.c

   1 /* parser.c -- convert the command line args into an expression tree.
   2    Copyright (C) 1990, 1991, 1992, 1993, 1994, 2000, 2001, 2003,
   3                  2004, 2005, 2006 Free Software Foundation, Inc.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 2, or (at your option)
   8    any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software
  17    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  18    USA.
  19 */
  20
  21
  22 #include "defs.h"
  23 #include <ctype.h>
  24 #include <math.h>
  25 #include <assert.h>
  26 #include <pwd.h>
  27 #include <errno.h>
  28 #include <grp.h>
  29 #include <fnmatch.h>
  30 #include "modechange.h"
  31 #include "modetype.h"
  32 #include "xstrtol.h"
  33 #include "xalloc.h"
  34 #include "quote.h"
  35 #include "quotearg.h"
  36 #include "buildcmd.h"
  37 #include "nextelem.h"
  38 #include "stdio-safer.h"
  39 #include "regextype.h"
  40 #include "stat-time.h"
  41 #include "xstrtod.h"
  42 #include "fts_.h"
  43 #include "getdate.h"
  44 #include "error.h"
  45 #include "gnulib-version.h"
  46
  47 #ifdef HAVE_FCNTL_H
  48 #include <fcntl.h>
  49 #else
  50 #include <sys/file.h>
  51 #endif
  52
  53 /* The presence of unistd.h is assumed by gnulib these days, so we
  54  * might as well assume it too.
  55  */
  56 /* We need <unistd.h> for isatty(). */
  57 #include <unistd.h>
  58
  59 #if ENABLE_NLS
  60 # include <libintl.h>
  61 # define _(Text) gettext (Text)
  62 #else
  63 # define _(Text) Text
  64 #endif
  65 #ifdef gettext_noop
  66 # define N_(String) gettext_noop (String)
  67 #else
  68 /* See locate.c for explanation as to why not use (String) */
  69 # define N_(String) String
  70 #endif
  71
  72 #if !defined (isascii) || defined (STDC_HEADERS)
  73 #ifdef isascii
  74 #undef isascii
  75 #endif
  76 #define isascii(c) 1
  77 #endif
  78
  79 #define ISDIGIT(c) (isascii ((unsigned char)c) && isdigit ((unsigned char)c))
  80 #define ISUPPER(c) (isascii ((unsigned char)c) && isupper ((unsigned char)c))
  81
  82 #ifndef HAVE_ENDGRENT
  83 #define endgrent()
  84 #endif
  85 #ifndef HAVE_ENDPWENT
  86 #define endpwent()
  87 #endif
  88 \f
  89 static boolean parse_accesscheck   PARAMS((const struct parser_table* entry, char **argv, int *arg_ptr));
  90 static boolean parse_amin          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
  91 static boolean parse_and           PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
  92 static boolean parse_anewer        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
  93 static boolean parse_cmin          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
  94 static boolean parse_cnewer        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
  95 static boolean parse_comma         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
  96 static boolean parse_daystart      PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
  97 static boolean parse_delete        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
  98 static boolean parse_d             PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
  99 static boolean parse_depth         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 100 static boolean parse_empty         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 101 static boolean parse_exec          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 102 static boolean parse_execdir       PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 103 static boolean parse_false         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 104 static boolean parse_fls           PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 105 static boolean parse_fprintf       PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 106 static boolean parse_follow        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 107 static boolean parse_fprint        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 108 static boolean parse_fprint0       PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 109 static boolean parse_fstype        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 110 static boolean parse_gid           PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 111 static boolean parse_group         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 112 static boolean parse_help          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 113 static boolean parse_ilname        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 114 static boolean parse_iname         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 115 static boolean parse_inum          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 116 static boolean parse_ipath         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 117 static boolean parse_iregex        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 118 static boolean parse_iwholename    PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 119 static boolean parse_links         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 120 static boolean parse_lname         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 121 static boolean parse_ls            PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 122 static boolean parse_maxdepth      PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 123 static boolean parse_mindepth      PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 124 static boolean parse_mmin          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 125 static boolean parse_name          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 126 static boolean parse_negate        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 127 static boolean parse_newer         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 128 static boolean parse_newerXY       PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 129 static boolean parse_noleaf        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 130 static boolean parse_nogroup       PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 131 static boolean parse_nouser        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 132 static boolean parse_nowarn        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 133 static boolean parse_ok            PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 134 static boolean parse_okdir         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 135 static boolean parse_or            PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 136 static boolean parse_path          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 137 static boolean parse_perm          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 138 static boolean parse_print0        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 139 static boolean parse_printf        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 140 static boolean parse_prune         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 141 static boolean parse_regex         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 142 static boolean parse_regextype     PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 143 static boolean parse_samefile      PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 144 #if 0
 145 static boolean parse_show_control_chars PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 146 #endif
 147 static boolean parse_size          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 148 static boolean parse_time          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 149 static boolean parse_true          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 150 static boolean parse_type          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 151 static boolean parse_uid           PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 152 static boolean parse_used          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 153 static boolean parse_user          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 154 static boolean parse_version       PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 155 static boolean parse_wholename     PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 156 static boolean parse_xdev          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 157 static boolean parse_ignore_race   PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 158 static boolean parse_noignore_race PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 159 static boolean parse_warn          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 160 static boolean parse_xtype         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 161 static boolean parse_quit          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 162
 163 boolean parse_print             PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 164
 165
 166 static boolean insert_type PARAMS((char **argv, int *arg_ptr, const struct parser_table *entry, PRED_FUNC which_pred));
 167 static boolean insert_regex PARAMS((char *argv[], int *arg_ptr, const struct parser_table *entry, int regex_options));
 168 static boolean insert_fprintf (struct format_val *vec,
 169                                const struct parser_table *entry,
 170                                PRED_FUNC func,
 171                                const char *format);
 172
 173 static struct segment **make_segment PARAMS((struct segment **segment, char *format, int len,
 174                                              int kind, char format_char, char aux_format_char,
 175                                              struct predicate *pred));
 176 static boolean insert_exec_ok PARAMS((const char *action, const struct parser_table *entry, int dirfd, char *argv[], int *arg_ptr));
 177 static boolean get_comp_type PARAMS((const char **str, enum comparison_type *comp_type));
 178 static boolean get_relative_timestamp PARAMS((const char *str, struct time_val *tval, time_t origin, double sec_per_unit, const char *overflowmessage));
 179 static boolean get_num PARAMS((const char *str, uintmax_t *num, enum comparison_type *comp_type));
 180 static struct predicate* insert_num PARAMS((char *argv[], int *arg_ptr, const struct parser_table *entry));
 181 static void open_output_file (const char *path, struct format_val *p);
 182 static void open_stdout (struct format_val *p);
 183 static boolean stream_is_tty(FILE *fp);
 184 static boolean parse_noop PARAMS((const struct parser_table* entry, char **argv, int *arg_ptr));
 185
 186 #define PASTE(x,y) x##y
 187 #define STRINGIFY(s) #s
 188
 189 #define PARSE_OPTION(what,suffix) \
 190   { (ARG_OPTION), (what), PASTE(parse_,suffix), NULL }
 191
 192 #define PARSE_POSOPT(what,suffix) \
 193   { (ARG_POSITIONAL_OPTION), (what), PASTE(parse_,suffix), NULL }
 194
 195 #define PARSE_TEST(what,suffix) \
 196   { (ARG_TEST), (what), PASTE(parse_,suffix), PASTE(pred_,suffix) }
 197
 198 #define PARSE_TEST_NP(what,suffix) \
 199   { (ARG_TEST), (what), PASTE(parse_,suffix), NULL }
 200
 201 #define PARSE_ACTION(what,suffix) \
 202   { (ARG_ACTION), (what), PASTE(parse_,suffix), PASTE(pred_,suffix) }
 203
 204 #define PARSE_ACTION_NP(what,suffix) \
 205   { (ARG_ACTION), (what), PASTE(parse_,suffix), NULL }
 206
 207 #define PARSE_PUNCTUATION(what,suffix) \
 208   { (ARG_PUNCTUATION), (what), PASTE(parse_,suffix), PASTE(pred_,suffix) }
 209
 210
 211 /* Predicates we cannot handle in the usual way.  If you add an entry
 212  * to this table, double-check the switch statement in
 213  * pred_sanity_check() to make sure that the new case is being
 214  * correctly handled.
 215  */
 216 static struct parser_table const parse_entry_newerXY =
 217   {
 218     ARG_SPECIAL_PARSE, "newerXY",            parse_newerXY, pred_newerXY /* BSD  */
 219   };
 220
 221 /* GNU find predicates that are not mentioned in POSIX.2 are marked `GNU'.
 222    If they are in some Unix versions of find, they are marked `Unix'. */
 223
 224 static struct parser_table const parse_table[] =
 225 {
 226   PARSE_PUNCTUATION("!",                     negate),
 227   PARSE_PUNCTUATION("not",                   negate),        /* GNU */
 228   PARSE_PUNCTUATION("(",                     openparen),
 229   PARSE_PUNCTUATION(")",                     closeparen),
 230   PARSE_PUNCTUATION(",",                     comma),         /* GNU */
 231   PARSE_PUNCTUATION("a",                     and),
 232   PARSE_TEST       ("amin",                  amin),          /* GNU */
 233   PARSE_PUNCTUATION("and",                   and),              /* GNU */
 234   PARSE_TEST       ("anewer",                anewer),        /* GNU */
 235   {ARG_TEST,       "atime",                  parse_time, pred_atime},
 236   PARSE_TEST       ("cmin",                  cmin),          /* GNU */
 237   PARSE_TEST       ("cnewer",                cnewer),        /* GNU */
 238   {ARG_TEST,       "ctime",                  parse_time, pred_ctime},
 239   PARSE_POSOPT     ("daystart",              daystart),      /* GNU */
 240   PARSE_ACTION     ("delete",                delete), /* GNU, Mac OS, FreeBSD */
 241   PARSE_OPTION     ("d",                     d), /* Mac OS X, FreeBSD, NetBSD, OpenBSD, but deprecated  in favour of -depth */
 242   PARSE_OPTION     ("depth",                 depth),
 243   PARSE_TEST       ("empty",                 empty),         /* GNU */
 244   {ARG_ACTION,      "exec",    parse_exec, pred_exec}, /* POSIX */
 245   {ARG_TEST,        "executable",            parse_accesscheck, pred_executable}, /* GNU, 4.3.0+ */
 246   PARSE_ACTION     ("execdir",               execdir), /* *BSD, GNU */
 247   PARSE_ACTION     ("fls",                   fls),           /* GNU */
 248   PARSE_POSOPT     ("follow",                follow),  /* GNU, Unix */
 249   PARSE_ACTION     ("fprint",                fprint),        /* GNU */
 250   PARSE_ACTION     ("fprint0",               fprint0),       /* GNU */
 251   {ARG_ACTION,      "fprintf", parse_fprintf, pred_fprintf}, /* GNU */
 252   PARSE_TEST       ("fstype",                fstype),  /* GNU, Unix */
 253   PARSE_TEST       ("gid",                   gid),           /* GNU */
 254   PARSE_TEST       ("group",                 group),
 255   PARSE_OPTION     ("ignore_readdir_race",   ignore_race),   /* GNU */
 256   PARSE_TEST       ("ilname",                ilname),        /* GNU */
 257   PARSE_TEST       ("iname",                 iname),         /* GNU */
 258   PARSE_TEST       ("inum",                  inum),    /* GNU, Unix */
 259   PARSE_TEST       ("ipath",                 ipath), /* GNU, deprecated in favour of iwholename */
 260   PARSE_TEST_NP    ("iregex",                iregex),        /* GNU */
 261   PARSE_TEST_NP    ("iwholename",            iwholename),    /* GNU */
 262   PARSE_TEST       ("links",                 links),
 263   PARSE_TEST       ("lname",                 lname),         /* GNU */
 264   PARSE_ACTION     ("ls",                    ls),      /* GNU, Unix */
 265   PARSE_OPTION     ("maxdepth",              maxdepth),      /* GNU */
 266   PARSE_OPTION     ("mindepth",              mindepth),      /* GNU */
 267   PARSE_TEST       ("mmin",                  mmin),          /* GNU */
 268   PARSE_OPTION     ("mount",                 xdev),         /* Unix */
 269   {ARG_TEST,       "mtime",                  parse_time, pred_mtime},
 270   PARSE_TEST       ("name",                  name),
 271 #ifdef UNIMPLEMENTED_UNIX
 272   PARSE(ARG_UNIMPLEMENTED, "ncpio",          ncpio),        /* Unix */
 273 #endif
 274   PARSE_TEST       ("newer",                 newer),
 275   {ARG_TEST,       "atime",                  parse_time, pred_atime},
 276   PARSE_OPTION     ("noleaf",                noleaf),        /* GNU */
 277   PARSE_TEST       ("nogroup",               nogroup),
 278   PARSE_TEST       ("nouser",                nouser),
 279   PARSE_OPTION     ("noignore_readdir_race", noignore_race), /* GNU */
 280   PARSE_POSOPT     ("nowarn",                nowarn),        /* GNU */
 281   PARSE_PUNCTUATION("o",                     or),
 282   PARSE_PUNCTUATION("or",                    or),            /* GNU */
 283   PARSE_ACTION     ("ok",                    ok),
 284   PARSE_ACTION     ("okdir",                 okdir), /* GNU (-execdir is BSD) */
 285   PARSE_TEST       ("path",                  path), /* GNU, HP-UX, GNU prefers wholename */
 286   PARSE_TEST       ("perm",                  perm),
 287   PARSE_ACTION     ("print",                 print),
 288   PARSE_ACTION     ("print0",                print0),        /* GNU */
 289   {ARG_ACTION,      "printf",   parse_printf, NULL},         /* GNU */
 290   PARSE_ACTION     ("prune",                 prune),
 291   PARSE_ACTION     ("quit",                  quit),          /* GNU */
 292   {ARG_TEST,       "readable",            parse_accesscheck, pred_readable}, /* GNU, 4.3.0+ */
 293   PARSE_TEST       ("regex",                 regex),         /* GNU */
 294   PARSE_OPTION     ("regextype",             regextype),     /* GNU */
 295   PARSE_TEST       ("samefile",              samefile),      /* GNU */
 296 #if 0
 297   PARSE_OPTION     ("show-control-chars",    show_control_chars), /* GNU, 4.3.0+ */
 298 #endif
 299   PARSE_TEST       ("size",                  size),
 300   PARSE_TEST       ("type",                  type),
 301   PARSE_TEST       ("uid",                   uid),           /* GNU */
 302   PARSE_TEST       ("used",                  used),          /* GNU */
 303   PARSE_TEST       ("user",                  user),
 304   PARSE_OPTION     ("warn",                  warn),          /* GNU */
 305   PARSE_TEST_NP    ("wholename",             wholename), /* GNU, replaces -path */
 306   {ARG_TEST,       "writable",               parse_accesscheck, pred_writable}, /* GNU, 4.3.0+ */
 307   PARSE_OPTION     ("xdev",                  xdev),
 308   PARSE_TEST       ("xtype",                 xtype),         /* GNU */
 309 #ifdef UNIMPLEMENTED_UNIX
 310   /* It's pretty ugly for find to know about archive formats.
 311      Plus what it could do with cpio archives is very limited.
 312      Better to leave it out.  */
 313   PARSE(ARG_UNIMPLEMENTED,      "cpio",                  cpio), /* Unix */
 314 #endif
 315   /* gnulib's stdbool.h might have made true and false into macros,
 316    * so we can't leave named 'true' and 'false' tokens, so we have
 317    * to expeant the relevant entries longhand.
 318    */
 319   {ARG_TEST, "false",                 parse_false,   pred_false}, /* GNU */
 320   {ARG_TEST, "true",                  parse_true,    pred_true }, /* GNU */
 321   {ARG_NOOP, "noop",                  NULL,          pred_true }, /* GNU, internal use only */
 322
 323   /* Various other cases that don't fit neatly into our macro scheme. */
 324   {ARG_TEST, "help",                  parse_help,    NULL},       /* GNU */
 325   {ARG_TEST, "-help",                 parse_help,    NULL},       /* GNU */
 326   {ARG_TEST, "version",               parse_version, NULL},       /* GNU */
 327   {ARG_TEST, "-version",              parse_version, NULL},       /* GNU */
 328   {0, 0, 0, 0}
 329 };
 330 \f
 331
 332 static const char *first_nonoption_arg = NULL;
 333 static const struct parser_table *noop = NULL;
 334
 335
 336 static const struct parser_table*
 337 get_noop(void)
 338 {
 339   int i;
 340   if (NULL == noop)
 341     {
 342       for (i = 0; parse_table[i].parser_name != 0; i++)
 343         {
 344           if (ARG_NOOP ==parse_table[i].type)
 345             {
 346               noop = &(parse_table[i]);
 347               break;
 348             }
 349         }
 350     }
 351   return noop;
 352 }
 353 \f
 354 static int
 355 get_stat_Ytime(const struct stat *p,
 356                char what,
 357                struct timespec *ret)
 358 {
 359   switch (what)
 360     {
 361     case 'a':
 362       *ret = get_stat_atime(p);
 363       return 1;
 364     case 'B':
 365       *ret = get_stat_birthtime(p);
 366       return (ret->tv_nsec >= 0);
 367     case 'c':
 368       *ret = get_stat_ctime(p);
 369       return 1;
 370     case 'm':
 371       *ret = get_stat_mtime(p);
 372       return 1;
 373     default:
 374       assert(0);
 375       abort();
 376       abort();
 377     }
 378 }
 379 \f
 380 void
 381 set_follow_state(enum SymlinkOption opt)
 382 {
 383   if (options.debug_options & DebugStat)
 384     {
 385       /* For DebugStat, the choice is made at runtime within debug_stat()
 386        * by checking the contents of the symlink_handling variable.
 387        */
 388       options.xstat = debug_stat;
 389     }
 390   else
 391     {
 392       switch (opt)
 393         {
 394         case SYMLINK_ALWAYS_DEREF:  /* -L */
 395           options.xstat = optionl_stat;
 396           options.no_leaf_check = true;
 397           break;
 398
 399         case SYMLINK_NEVER_DEREF:       /* -P (default) */
 400           options.xstat = optionp_stat;
 401           /* Can't turn no_leaf_check off because the user might have specified
 402            * -noleaf anyway
 403            */
 404           break;
 405
 406         case SYMLINK_DEREF_ARGSONLY: /* -H */
 407           options.xstat = optionh_stat;
 408           options.no_leaf_check = true;
 409         }
 410     }
 411   options.symlink_handling = opt;
 412 }
 413
 414
 415 void
 416 parse_begin_user_args (char **args, int argno, const struct predicate *last, const struct predicate *predicates)
 417 {
 418   (void) args;
 419   (void) argno;
 420   (void) last;
 421   (void) predicates;
 422   first_nonoption_arg = NULL;
 423 }
 424
 425 void
 426 parse_end_user_args (char **args, int argno, const struct predicate *last, const struct predicate *predicates)
 427 {
 428   /* does nothing */
 429   (void) args;
 430   (void) argno;
 431   (void) last;
 432   (void) predicates;
 433 }
 434
 435
 436 /* Check that it is legal to fid the given primary in its
 437  * position and return it.
 438  */
 439 const struct parser_table*
 440 found_parser(const char *original_arg, const struct parser_table *entry)
 441 {
 442   /* If this is an option, but we have already had a
 443    * non-option argument, the user may be under the
 444    * impression that the behaviour of the option
 445    * argument is conditional on some preceding
 446    * tests.  This might typically be the case with,
 447    * for example, -maxdepth.
 448    *
 449    * The options -daystart and -follow are exempt
 450    * from this treatment, since their positioning
 451    * in the command line does have an effect on
 452    * subsequent tests but not previous ones.  That
 453    * might be intentional on the part of the user.
 454    */
 455   if (entry->type != ARG_POSITIONAL_OPTION)
 456     {
 457       /* Something other than -follow/-daystart.
 458        * If this is an option, check if it followed
 459        * a non-option and if so, issue a warning.
 460        */
 461       if (entry->type == ARG_OPTION)
 462         {
 463           if ((first_nonoption_arg != NULL)
 464               && options.warnings )
 465             {
 466               /* option which follows a non-option */
 467               error (0, 0,
 468                      _("warning: you have specified the %s "
 469                        "option after a non-option argument %s, "
 470                        "but options are not positional (%s affects "
 471                        "tests specified before it as well as those "
 472                        "specified after it).  Please specify options "
 473                        "before other arguments.\n"),
 474                      original_arg,
 475                      first_nonoption_arg,
 476                      original_arg);
 477             }
 478         }
 479       else
 480         {
 481           /* Not an option or a positional option,
 482            * so remember we've seen it in order to
 483            * use it in a possible future warning message.
 484            */
 485           if (first_nonoption_arg == NULL)
 486             {
 487               first_nonoption_arg = original_arg;
 488             }
 489         }
 490     }
 491
 492   return entry;
 493 }
 494
 495
 496 /* Return a pointer to the parser function to invoke for predicate
 497    SEARCH_NAME.
 498    Return NULL if SEARCH_NAME is not a valid predicate name. */
 499
 500 const struct parser_table*
 501 find_parser (char *search_name)
 502 {
 503   int i;
 504   const char *original_arg = search_name;
 505
 506   /* Ugh.  Special case -newerXY. */
 507   if (0 == strncmp("-newer", search_name, 6)
 508       && (8 == strlen(search_name)))
 509     {
 510       return found_parser(original_arg, &parse_entry_newerXY);
 511     }
 512
 513   if (*search_name == '-')
 514     search_name++;
 515
 516   for (i = 0; parse_table[i].parser_name != 0; i++)
 517     {
 518       if (strcmp (parse_table[i].parser_name, search_name) == 0)
 519         {
 520           return found_parser(original_arg, &parse_table[i]);
 521         }
 522     }
 523   return NULL;
 524 }
 525 \f
 526 static float
 527 estimate_file_age_success_rate(float num_days)
 528 {
 529   if (num_days < 0.1)
 530     {
 531       /* Assume 1% of files have timestamps in the future */
 532       return 0.01f;
 533     }
 534   else if (num_days < 1)
 535     {
 536       /* Assume 30% of files have timestamps today */
 537       return 0.3f;
 538     }
 539   else if (num_days > 100)
 540     {
 541       /* Assume 30% of files are very old */
 542       return 0.3f;
 543     }
 544   else
 545     {
 546       /* Assume 39% of files are between 1 and 100 days old. */
 547       return 0.39f;
 548     }
 549 }
 550 \f
 551 static float
 552 estimate_timestamp_success_rate(time_t when)
 553 {
 554   int num_days = (options.cur_day_start - when) / 86400;
 555   return estimate_file_age_success_rate(num_days);
 556 }
 557
 558 /* Collect an argument from the argument list, or
 559  * return false.
 560  */
 561 static boolean
 562 collect_arg(char **argv, int *arg_ptr, const char **collected_arg)
 563 {
 564   if ((argv == NULL) || (argv[*arg_ptr] == NULL))
 565     {
 566       *collected_arg = NULL;
 567       return false;
 568     }
 569   else
 570     {
 571       *collected_arg = argv[*arg_ptr];
 572       (*arg_ptr)++;
 573       return true;
 574     }
 575 }
 576
 577 static boolean
 578 collect_arg_stat_info(char **argv, int *arg_ptr, struct stat *p)
 579 {
 580   const char *filename;
 581   if (collect_arg(argv, arg_ptr, &filename))
 582     {
 583       if (0 == (options.xstat)(filename, p))
 584         {
 585           return true;
 586         }
 587       else
 588         {
 589           fatal_file_error(filename);
 590         }
 591     }
 592   else
 593     {
 594       return false;
 595     }
 596 }
 597
 598 /* The parsers are responsible to continue scanning ARGV for
 599    their arguments.  Each parser knows what is and isn't
 600    allowed for itself.
 601
 602    ARGV is the argument array.
 603    *ARG_PTR is the index to start at in ARGV,
 604    updated to point beyond the last element consumed.
 605
 606    The predicate structure is updated with the new information. */
 607
 608 \f
 609 static boolean
 610 parse_and (const struct parser_table* entry, char **argv, int *arg_ptr)
 611 {
 612   struct predicate *our_pred;
 613
 614   (void) argv;
 615   (void) arg_ptr;
 616
 617   our_pred = get_new_pred (entry);
 618   our_pred->pred_func = pred_and;
 619   our_pred->p_type = BI_OP;
 620   our_pred->p_prec = AND_PREC;
 621   our_pred->need_stat = our_pred->need_type = false;
 622   return true;
 623 }
 624
 625 static boolean
 626 parse_anewer (const struct parser_table* entry, char **argv, int *arg_ptr)
 627 {
 628   struct stat stat_newer;
 629
 630   set_stat_placeholders(&stat_newer);
 631   if (collect_arg_stat_info(argv, arg_ptr, &stat_newer))
 632     {
 633       struct predicate *our_pred = insert_primary (entry);
 634       our_pred->args.reftime.xval = XVAL_ATIME;
 635       our_pred->args.reftime.ts = get_stat_mtime(&stat_newer);
 636       our_pred->args.reftime.kind = COMP_GT;
 637       our_pred->est_success_rate = estimate_timestamp_success_rate(stat_newer.st_mtime);
 638       return true;
 639     }
 640   return false;
 641 }
 642
 643 boolean
 644 parse_closeparen (const struct parser_table* entry, char **argv, int *arg_ptr)
 645 {
 646   struct predicate *our_pred;
 647
 648   (void) argv;
 649   (void) arg_ptr;
 650
 651   our_pred = get_new_pred (entry);
 652   our_pred->pred_func = pred_closeparen;
 653   our_pred->p_type = CLOSE_PAREN;
 654   our_pred->p_prec = NO_PREC;
 655   our_pred->need_stat = our_pred->need_type = false;
 656   return true;
 657 }
 658
 659 static boolean
 660 parse_cnewer (const struct parser_table* entry, char **argv, int *arg_ptr)
 661 {
 662   struct stat stat_newer;
 663
 664   set_stat_placeholders(&stat_newer);
 665   if (collect_arg_stat_info(argv, arg_ptr, &stat_newer))
 666     {
 667       struct predicate *our_pred = insert_primary (entry);
 668       our_pred->args.reftime.xval = XVAL_CTIME; /* like -newercm */
 669       our_pred->args.reftime.ts = get_stat_mtime(&stat_newer);
 670       our_pred->args.reftime.kind = COMP_GT;
 671       our_pred->est_success_rate = estimate_timestamp_success_rate(stat_newer.st_mtime);
 672       return true;
 673     }
 674   return false;
 675 }
 676
 677 static boolean
 678 parse_comma (const struct parser_table* entry, char **argv, int *arg_ptr)
 679 {
 680   struct predicate *our_pred;
 681
 682   (void) argv;
 683   (void) arg_ptr;
 684
 685   our_pred = get_new_pred (entry);
 686   our_pred->pred_func = pred_comma;
 687   our_pred->p_type = BI_OP;
 688   our_pred->p_prec = COMMA_PREC;
 689   our_pred->need_stat = our_pred->need_type = false;
 690   our_pred->est_success_rate = 1.0f;
 691   return true;
 692 }
 693
 694 static boolean
 695 parse_daystart (const struct parser_table* entry, char **argv, int *arg_ptr)
 696 {
 697   struct tm *local;
 698
 699   (void) entry;
 700   (void) argv;
 701   (void) arg_ptr;
 702
 703   if (options.full_days == false)
 704     {
 705       options.cur_day_start += DAYSECS;
 706       local = localtime (&options.cur_day_start);
 707       options.cur_day_start -= (local
 708                         ? (local->tm_sec + local->tm_min * 60
 709                            + local->tm_hour * 3600)
 710                         : options.cur_day_start % DAYSECS);
 711       options.full_days = true;
 712     }
 713   return true;
 714 }
 715
 716 static boolean
 717 parse_delete (const struct parser_table* entry, char *argv[], int *arg_ptr)
 718 {
 719   struct predicate *our_pred;
 720   (void) argv;
 721   (void) arg_ptr;
 722
 723   our_pred = insert_primary (entry);
 724   our_pred->side_effects = our_pred->no_default_print = true;
 725   /* -delete implies -depth */
 726   options.do_dir_first = false;
 727
 728   /* We do not need stat information because we check for the case
 729    * (errno==EISDIR) in pred_delete.
 730    */
 731   our_pred->need_stat = our_pred->need_type = false;
 732
 733   our_pred->est_success_rate = 1.0f;
 734   return true;
 735 }
 736
 737 static boolean
 738 parse_depth (const struct parser_table* entry, char **argv, int *arg_ptr)
 739 {
 740   (void) entry;
 741   (void) argv;
 742
 743   options.do_dir_first = false;
 744   return parse_noop(entry, argv, arg_ptr);
 745 }
 746
 747 static boolean
 748 parse_d (const struct parser_table* entry, char **argv, int *arg_ptr)
 749 {
 750   if (options.warnings)
 751     {
 752       error (0, 0,
 753              _("warning: the -d option is deprecated; please use -depth instead, because the latter is a POSIX-compliant feature."));
 754     }
 755   return parse_depth(entry, argv, arg_ptr);
 756 }
 757
 758 static boolean
 759 parse_empty (const struct parser_table* entry, char **argv, int *arg_ptr)
 760 {
 761   struct predicate *our_pred;
 762   (void) argv;
 763   (void) arg_ptr;
 764
 765   our_pred = insert_primary (entry);
 766   our_pred->est_success_rate = 0.01f; /* assume 1% of files are empty. */
 767   return true;
 768 }
 769
 770 static boolean
 771 parse_exec (const struct parser_table* entry, char **argv, int *arg_ptr)
 772 {
 773   return insert_exec_ok ("-exec", entry, get_start_dirfd(), argv, arg_ptr);
 774 }
 775
 776 static boolean
 777 parse_execdir (const struct parser_table* entry, char **argv, int *arg_ptr)
 778 {
 779   return insert_exec_ok ("-execdir", entry, -1, argv, arg_ptr);
 780 }
 781
 782 static boolean
 783 parse_false (const struct parser_table* entry, char **argv, int *arg_ptr)
 784 {
 785   struct predicate *our_pred;
 786
 787   (void) argv;
 788   (void) arg_ptr;
 789
 790   our_pred = insert_primary (entry);
 791   our_pred->need_stat = our_pred->need_type = false;
 792   our_pred->side_effects = our_pred->no_default_print = false;
 793   our_pred->est_success_rate = 0.0f;
 794   return true;
 795 }
 796
 797 static boolean
 798 insert_fls (const struct parser_table* entry, const char *filename)
 799 {
 800   struct predicate *our_pred = insert_primary (entry);
 801   if (filename)
 802     open_output_file (filename, &our_pred->args.printf_vec);
 803   else
 804     open_stdout (&our_pred->args.printf_vec);
 805   our_pred->side_effects = our_pred->no_default_print = true;
 806   our_pred->est_success_rate = 1.0f;
 807   return true;
 808 }
 809
 810
 811 static boolean
 812 parse_fls (const struct parser_table* entry, char **argv, int *arg_ptr)
 813 {
 814   const char *filename;
 815   return collect_arg(argv, arg_ptr, &filename)
 816     &&  insert_fls(entry, filename);
 817 }
 818
 819 static boolean
 820 parse_follow (const struct parser_table* entry, char **argv, int *arg_ptr)
 821 {
 822   set_follow_state(SYMLINK_ALWAYS_DEREF);
 823   return parse_noop(entry, argv, arg_ptr);
 824 }
 825
 826 static boolean
 827 parse_fprint (const struct parser_table* entry, char **argv, int *arg_ptr)
 828 {
 829   struct predicate *our_pred;
 830   const char *filename;
 831   if (collect_arg(argv, arg_ptr, &filename))
 832     {
 833       our_pred = insert_primary (entry);
 834       open_output_file (filename, &our_pred->args.printf_vec);
 835       our_pred->side_effects = our_pred->no_default_print = true;
 836       our_pred->need_stat = our_pred->need_type = false;
 837       our_pred->est_success_rate = 1.0f;
 838       return true;
 839     }
 840   else
 841     {
 842       return false;
 843     }
 844 }
 845
 846 static boolean
 847 insert_fprint(const struct parser_table* entry, const char *filename)
 848 {
 849   struct predicate *our_pred = insert_primary (entry);
 850   if (filename)
 851     open_output_file (filename, &our_pred->args.printf_vec);
 852   else
 853     open_stdout (&our_pred->args.printf_vec);
 854   our_pred->side_effects = our_pred->no_default_print = true;
 855   our_pred->need_stat = our_pred->need_type = false;
 856   our_pred->est_success_rate = 1.0f;
 857   return true;
 858 }
 859
 860
 861 static boolean
 862 parse_fprint0 (const struct parser_table* entry, char **argv, int *arg_ptr)
 863 {
 864   const char *filename;
 865   if (collect_arg(argv, arg_ptr, &filename))
 866     return insert_fprint(entry, filename);
 867   else
 868     return false;
 869 }
 870
 871 static float estimate_fstype_success_rate(const char *fsname)
 872 {
 873   struct stat dir_stat;
 874   const char *dir = "/";
 875   if (0 == stat(dir, &dir_stat))
 876     {
 877       const char *fstype = filesystem_type(&dir_stat, dir);
 878       /* Assume most files are on the same filesystem type as the root fs. */
 879       if (0 == strcmp(fsname, fstype))
 880           return 0.7f;
 881       else
 882         return 0.3f;
 883     }
 884   return 1.0f;
 885 }
 886
 887
 888 static boolean
 889 parse_fstype (const struct parser_table* entry, char **argv, int *arg_ptr)
 890 {
 891   const char *typename;
 892   if (collect_arg(argv, arg_ptr, &typename))
 893     {
 894       struct predicate *our_pred = insert_primary (entry);
 895       our_pred->args.str = typename;
 896
 897       /* This is an expensive operation, so although there are
 898        * circumstances where it is selective, we ignore this fact
 899        * because we probably don't want to promote this test to the
 900        * front anyway.
 901        */
 902       our_pred->est_success_rate = estimate_fstype_success_rate(typename);
 903       return true;
 904     }
 905   else
 906     {
 907       return false;
 908     }
 909 }
 910
 911 static boolean
 912 parse_gid (const struct parser_table* entry, char **argv, int *arg_ptr)
 913 {
 914   struct predicate *p = insert_num (argv, arg_ptr, entry);
 915   if (p)
 916     {
 917       p->est_success_rate = (p->args.numinfo.l_val < 100) ? 0.99 : 0.2;
 918       return true;
 919     }
 920   else
 921     {
 922       return false;
 923     }
 924 }
 925
 926
 927 static int
 928 safe_atoi (const char *s)
 929 {
 930   long lval;
 931   const char *end;
 932
 933   errno = 0;
 934   lval = strtol(s, &end, 10);
 935   if ( (LONG_MAX == lval) || (LONG_MIN == lval) )
 936     {
 937       /* max/min possible value, or an error. */
 938       if (errno == ERANGE)
 939         {
 940           /* too big, or too small. */
 941           error(1, errno, "%s", s);
 942         }
 943       else
 944         {
 945           /* not a valid number */
 946           error(1, errno, "%s", s);
 947         }
 948       /* Otherwise, we do a range chack against INT_MAX and INT_MIN
 949        * below.
 950        */
 951     }
 952
 953   if (lval > INT_MAX || lval < INT_MIN)
 954     {
 955       /* The number was in range for long, but not int. */
 956       errno = ERANGE;
 957       error(1, errno, "%s", s);
 958     }
 959   else if (*end)
 960     {
 961       error(1, errno, "Unexpected suffix %s on %s",
 962             quotearg_n_style(0, options.err_quoting_style, end),
 963             quotearg_n_style(1, options.err_quoting_style, s));
 964     }
 965   else if (end == s)
 966     {
 967       error(1, errno, "Expected an integer: %s",
 968             quotearg_n_style(0, options.err_quoting_style, s));
 969     }
 970   return (int)lval;
 971 }
 972
 973
 974 static boolean
 975 parse_group (const struct parser_table* entry, char **argv, int *arg_ptr)
 976 {
 977   const char *groupname;
 978
 979   if (collect_arg(argv, arg_ptr, &groupname))
 980     {
 981       gid_t gid;
 982       struct predicate *our_pred;
 983       struct group *cur_gr = getgrnam(groupname);
 984       endgrent();
 985       if (cur_gr)
 986         {
 987           gid = cur_gr->gr_gid;
 988         }
 989       else
 990         {
 991           const int gid_len = strspn (groupname, "0123456789");
 992           if (gid_len)
 993             {
 994               if (groupname[gid_len] == 0)
 995                 {
 996                   gid = safe_atoi (groupname);
 997                 }
 998               else
 999                 {
1000                   /* XXX: no test in test suite for this */
1001                   error(1, 0, _("%s is not the name of an existing group and"
1002                                 " it does not look like a numeric group ID "
1003                                 "because it has the unexpected suffix %s"),
1004                         quotearg_n_style(0, options.err_quoting_style, groupname),
1005                         quotearg_n_style(1, options.err_quoting_style, groupname+gid_len));
1006                   return false;
1007                 }
1008             }
1009           else
1010             {
1011               if (*groupname)
1012                 {
1013                   /* XXX: no test in test suite for this */
1014                   error(1, 0, _("%s is not the name of an existing group"),
1015                         quotearg_n_style(0, options.err_quoting_style, groupname));
1016                 }
1017               else
1018                 {
1019                   error(1, 0, _("argument to -group is empty, but should be a group name"));
1020                 }
1021               return false;
1022             }
1023         }
1024       our_pred = insert_primary (entry);
1025       our_pred->args.gid = gid;
1026       our_pred->est_success_rate = (our_pred->args.numinfo.l_val < 100) ? 0.99 : 0.2;
1027       return true;
1028     }
1029   return false;
1030 }
1031
1032 static boolean
1033 parse_help (const struct parser_table* entry, char **argv, int *arg_ptr)
1034 {
1035   (void) entry;
1036   (void) argv;
1037   (void) arg_ptr;
1038
1039   usage(stdout, 0, NULL);
1040   puts (_("\n\
1041 default path is the current directory; default expression is -print\n\
1042 expression may consist of: operators, options, tests, and actions:\n"));
1043   puts (_("\
1044 operators (decreasing precedence; -and is implicit where no others are given):\n\
1045       ( EXPR )   ! EXPR   -not EXPR   EXPR1 -a EXPR2   EXPR1 -and EXPR2\n\
1046       EXPR1 -o EXPR2   EXPR1 -or EXPR2   EXPR1 , EXPR2\n"));
1047   puts (_("\
1048 positional options (always true): -daystart -follow -regextype\n\n\
1049 normal options (always true, specified before other expressions):\n\
1050       -depth --help -maxdepth LEVELS -mindepth LEVELS -mount -noleaf\n\
1051       --version -xdev -ignore_readdir_race -noignore_readdir_race\n"));
1052   puts (_("\
1053 tests (N can be +N or -N or N): -amin N -anewer FILE -atime N -cmin N\n\
1054       -cnewer FILE -ctime N -empty -false -fstype TYPE -gid N -group NAME\n\
1055       -ilname PATTERN -iname PATTERN -inum N -iwholename PATTERN -iregex PATTERN\n\
1056       -links N -lname PATTERN -mmin N -mtime N -name PATTERN -newer FILE"));
1057   puts (_("\
1058       -nouser -nogroup -path PATTERN -perm [+-]MODE -regex PATTERN\n\
1059       -readable -writable -executable\n\
1060       -wholename PATTERN -size N[bcwkMG] -true -type [bcdpflsD] -uid N\n\
1061       -used N -user NAME -xtype [bcdpfls]\n"));
1062   puts (_("\
1063 actions: -delete -print0 -printf FORMAT -fprintf FILE FORMAT -print \n\
1064       -fprint0 FILE -fprint FILE -ls -fls FILE -prune -quit\n\
1065       -exec COMMAND ; -exec COMMAND {} + -ok COMMAND ;\n\
1066       -execdir COMMAND ; -execdir COMMAND {} + -okdir COMMAND ;\n\
1067 "));
1068   puts (_("Report (and track progress on fixing) bugs via the findutils bug-reporting\n\
1069 page at http://savannah.gnu.org/ or, if you have no web access, by sending\n\
1070 email to <bug-findutils@gnu.org>."));
1071   exit (0);
1072 }
1073
1074 static float
1075 estimate_pattern_match_rate(const char *pattern, int is_regex)
1076 {
1077   if (strpbrk(pattern, "*?[") || (is_regex && strpbrk(pattern, ".")))
1078     {
1079       /* A wildcard; assume the pattern matches most files. */
1080       return 0.8f;
1081     }
1082   else
1083     {
1084       return 0.1f;
1085     }
1086 }
1087
1088 static boolean
1089 parse_ilname (const struct parser_table* entry, char **argv, int *arg_ptr)
1090 {
1091   const char *name;
1092   if (collect_arg(argv, arg_ptr, &name))
1093     {
1094       struct predicate *our_pred = insert_primary (entry);
1095       our_pred->args.str = name;
1096       /* Use the generic glob pattern estimator to figure out how many
1097        * links will match, but bear in mind that most files won't be links.
1098        */
1099       our_pred->est_success_rate = 0.1 * estimate_pattern_match_rate(name, 0);
1100       return true;
1101     }
1102   else
1103     {
1104       return false;
1105     }
1106 }
1107
1108
1109 /* sanity check the fnmatch() function to make sure that case folding
1110  * is supported (as opposed to just having the flag ignored).
1111  */
1112 static boolean
1113 fnmatch_sanitycheck(void)
1114 {
1115   static boolean checked = false;
1116   if (!checked)
1117     {
1118       if (0 != fnmatch("foo", "foo", 0)
1119           || 0 == fnmatch("Foo", "foo", 0)
1120           || 0 != fnmatch("Foo", "foo", FNM_CASEFOLD))
1121         {
1122           error (1, 0, _("sanity check of the fnmatch() library function failed."));
1123           return false;
1124         }
1125       checked = true;
1126     }
1127   return checked;
1128 }
1129
1130
1131 static boolean
1132 check_name_arg(const char *pred, const char *arg)
1133 {
1134   if (strchr(arg, '/'))
1135     {
1136       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'."),
1137             pred,
1138             safely_quote_err_filename(0, arg),
1139             safely_quote_err_filename(1, arg));
1140     }
1141   return true;                  /* allow it anyway */
1142 }
1143
1144
1145
1146 static boolean
1147 parse_iname (const struct parser_table* entry, char **argv, int *arg_ptr)
1148 {
1149   const char *name;
1150   fnmatch_sanitycheck();
1151   if (collect_arg(argv, arg_ptr, &name))
1152     {
1153       if (check_name_arg("-iname", name))
1154         {
1155           struct predicate *our_pred = insert_primary (entry);
1156           our_pred->need_stat = our_pred->need_type = false;
1157           our_pred->args.str = name;
1158           our_pred->est_success_rate = estimate_pattern_match_rate(name, 0);
1159           return true;
1160         }
1161     }
1162   return false;
1163 }
1164
1165 static boolean
1166 parse_inum (const struct parser_table* entry, char **argv, int *arg_ptr)
1167 {
1168   struct predicate *p =  insert_num (argv, arg_ptr, entry);
1169   if (p)
1170     {
1171       /* inode number is exact match only, so very low proportions of
1172        * files match
1173        */
1174       p->est_success_rate = 1e-6;
1175       return true;
1176     }
1177   else
1178     {
1179       return false;
1180     }
1181 }
1182
1183 /* -ipath is deprecated (at RMS's request) in favour of
1184  * -iwholename.   See the node "GNU Manuals" in standards.texi
1185  * for the rationale for this (basically, GNU prefers the use
1186  * of the phrase "file name" to "path name"
1187  */
1188 static boolean
1189 parse_ipath (const struct parser_table* entry, char **argv, int *arg_ptr)
1190 {
1191   error (0, 0,
1192          _("warning: the predicate -ipath is deprecated; please use -iwholename instead."));
1193
1194   return parse_iwholename(entry, argv, arg_ptr);
1195 }
1196
1197 static boolean
1198 parse_iwholename (const struct parser_table* entry, char **argv, int *arg_ptr)
1199 {
1200   const char *name;
1201
1202   fnmatch_sanitycheck();
1203   if (collect_arg(argv, arg_ptr, &name))
1204     {
1205       struct predicate *our_pred = insert_primary_withpred (entry, pred_ipath);
1206       our_pred->need_stat = our_pred->need_type = false;
1207       our_pred->args.str = name;
1208       our_pred->est_success_rate = estimate_pattern_match_rate(name, 0);
1209       return true;
1210     }
1211   return false;
1212 }
1213
1214 static boolean
1215 parse_iregex (const struct parser_table* entry, char **argv, int *arg_ptr)
1216 {
1217   return insert_regex (argv, arg_ptr, entry, RE_ICASE|options.regex_options);
1218 }
1219
1220 static boolean
1221 parse_links (const struct parser_table* entry, char **argv, int *arg_ptr)
1222 {
1223   struct predicate *p = insert_num (argv, arg_ptr, entry);
1224   if (p)
1225     {
1226       if (p->args.numinfo.l_val == 1)
1227         p->est_success_rate = 0.99;
1228       else if (p->args.numinfo.l_val == 2)
1229         p->est_success_rate = 0.01;
1230       else
1231         p->est_success_rate = 1e-3;
1232       return true;
1233     }
1234   else
1235     {
1236       return false;
1237     }
1238 }
1239
1240 static boolean
1241 parse_lname (const struct parser_table* entry, char **argv, int *arg_ptr)
1242 {
1243   const char *name;
1244   fnmatch_sanitycheck();
1245   if (collect_arg(argv, arg_ptr, &name))
1246     {
1247       struct predicate *our_pred = insert_primary (entry);
1248       our_pred->args.str = name;
1249       our_pred->est_success_rate = 0.1 * estimate_pattern_match_rate(name, 0);
1250       return true;
1251     }
1252   return false;
1253 }
1254
1255 static boolean
1256 parse_ls (const struct parser_table* entry, char **argv, int *arg_ptr)
1257 {
1258   (void) &argv;
1259   (void) &arg_ptr;
1260   return insert_fls(entry, NULL);
1261 }
1262
1263 static boolean
1264 insert_depthspec(const struct parser_table* entry, char **argv, int *arg_ptr,
1265                  int *limitptr)
1266 {
1267   const char *depthstr;
1268   int depth_len;
1269   const char *predicate = argv[(*arg_ptr)-1];
1270   if (collect_arg(argv, arg_ptr, &depthstr))
1271     {
1272       depth_len = strspn (depthstr, "0123456789");
1273       if ((depth_len > 0) && (depthstr[depth_len] == 0))
1274         {
1275           (*limitptr) = safe_atoi (depthstr);
1276           if (*limitptr >= 0)
1277             {
1278               return parse_noop(entry, argv, arg_ptr);
1279             }
1280         }
1281       error(1, 0, _("Expected a positive decimal integer argument to %s, but got %s"),
1282             predicate,
1283             quotearg_n_style(0, options.err_quoting_style, depthstr));
1284       return false;
1285     }
1286   /* missing argument */
1287   return false;
1288 }
1289
1290
1291 static boolean
1292 parse_maxdepth (const struct parser_table* entry, char **argv, int *arg_ptr)
1293 {
1294   return insert_depthspec(entry, argv, arg_ptr, &options.maxdepth);
1295 }
1296
1297 static boolean
1298 parse_mindepth (const struct parser_table* entry, char **argv, int *arg_ptr)
1299 {
1300   return insert_depthspec(entry, argv, arg_ptr, &options.mindepth);
1301 }
1302 \f
1303
1304 static boolean
1305 do_parse_xmin (const struct parser_table* entry, char **argv, int *arg_ptr, enum xval xv)
1306 {
1307   const char *minutes;
1308
1309   if (collect_arg(argv, arg_ptr, &minutes))
1310     {
1311       struct time_val tval;
1312       tval.xval = xv;
1313       if (get_relative_timestamp(minutes, &tval,
1314                                  options.cur_day_start + DAYSECS, 60,
1315                                  "arithmetic overflow while converting %s "
1316                                  "minutes to a number of seconds"))
1317         {
1318           struct predicate *our_pred = insert_primary (entry);
1319           our_pred->args.reftime = tval;
1320           our_pred->est_success_rate = estimate_timestamp_success_rate(tval.ts.tv_sec);
1321           return true;
1322         }
1323     }
1324   return false;
1325 }
1326 static boolean
1327 parse_amin (const struct parser_table* entry, char **argv, int *arg_ptr)
1328 {
1329   return do_parse_xmin(entry, argv, arg_ptr, XVAL_ATIME);
1330 }
1331 \f
1332 static boolean
1333 parse_cmin (const struct parser_table* entry, char **argv, int *arg_ptr)
1334 {
1335   return do_parse_xmin(entry, argv, arg_ptr, XVAL_CTIME);
1336 }
1337
1338 \f
1339 static boolean
1340 parse_mmin (const struct parser_table* entry, char **argv, int *arg_ptr)
1341 {
1342   return do_parse_xmin(entry, argv, arg_ptr, XVAL_MTIME);
1343 }
1344
1345 static boolean
1346 parse_name (const struct parser_table* entry, char **argv, int *arg_ptr)
1347 {
1348   const char *name;
1349   if (collect_arg(argv, arg_ptr, &name))
1350     {
1351       fnmatch_sanitycheck();
1352       if (check_name_arg("-name", name))
1353         {
1354           struct predicate *our_pred = insert_primary (entry);
1355           our_pred->need_stat = our_pred->need_type = false;
1356           our_pred->args.str = name;
1357           our_pred->est_success_rate = estimate_pattern_match_rate(name, 0);
1358           return true;
1359         }
1360     }
1361   return false;
1362 }
1363
1364 static boolean
1365 parse_negate (const struct parser_table* entry, char **argv, int *arg_ptr)
1366 {
1367   struct predicate *our_pred;
1368
1369   (void) &argv;
1370   (void) &arg_ptr;
1371
1372   our_pred = get_new_pred_chk_op (entry);
1373   our_pred->pred_func = pred_negate;
1374   our_pred->p_type = UNI_OP;
1375   our_pred->p_prec = NEGATE_PREC;
1376   our_pred->need_stat = our_pred->need_type = false;
1377   return true;
1378 }
1379
1380 static boolean
1381 parse_newer (const struct parser_table* entry, char **argv, int *arg_ptr)
1382 {
1383   struct predicate *our_pred;
1384   struct stat stat_newer;
1385
1386   set_stat_placeholders(&stat_newer);
1387   if (collect_arg_stat_info(argv, arg_ptr, &stat_newer))
1388     {
1389       our_pred = insert_primary (entry);
1390       our_pred->args.reftime.ts = get_stat_mtime(&stat_newer);
1391       our_pred->args.reftime.xval = XVAL_MTIME;
1392       our_pred->args.reftime.kind = COMP_GT;
1393       our_pred->est_success_rate = estimate_timestamp_success_rate(stat_newer.st_mtime);
1394       return true;
1395     }
1396   return false;
1397 }
1398
1399
1400 static boolean
1401 parse_newerXY (const struct parser_table* entry, char **argv, int *arg_ptr)
1402 {
1403   (void) argv;
1404   (void) arg_ptr;
1405
1406   if ((argv == NULL) || (argv[*arg_ptr] == NULL))
1407     {
1408       return false;
1409     }
1410   else if (8u != strlen(argv[*arg_ptr]))
1411     {
1412       return false;
1413     }
1414   else
1415     {
1416       char x, y;
1417       const char validchars[] = "aBcmt";
1418
1419       assert(0 == strncmp("-newer", argv[*arg_ptr], 6));
1420       x = argv[*arg_ptr][6];
1421       y = argv[*arg_ptr][7];
1422
1423
1424 #if !defined(HAVE_STRUCT_STAT_ST_BIRTHTIME) && !defined(HAVE_STRUCT_STAT_ST_BIRTHTIMENSEC) && !defined(HAVE_STRUCT_STAT_ST_BIRTHTIMESPEC_TV_NSEC)
1425       if ('B' == x || 'B' == y)
1426         {
1427           error(0, 0,
1428                 _("This system does not provide a way to find the birth time of a file."));
1429           return 0;
1430         }
1431 #endif
1432
1433       /* -newertY (for any Y) is invalid. */
1434       if (x == 't'
1435           || 0 == strchr(validchars, x)
1436           || 0 == strchr( validchars, y))
1437         {
1438           return false;
1439         }
1440       else
1441         {
1442           struct predicate *our_pred;
1443
1444           /* Because this item is ARG_SPECIAL_PARSE, we have to advance arg_ptr
1445            * past the test name (for most other tests, this is already done)
1446            */
1447           (*arg_ptr)++;
1448
1449           our_pred = insert_primary (entry);
1450
1451
1452           switch (x)
1453             {
1454             case 'a':
1455               our_pred->args.reftime.xval = XVAL_ATIME;
1456               break;
1457             case 'B':
1458               our_pred->args.reftime.xval = XVAL_BIRTHTIME;
1459               break;
1460             case 'c':
1461               our_pred->args.reftime.xval = XVAL_CTIME;
1462               break;
1463             case 'm':
1464               our_pred->args.reftime.xval = XVAL_MTIME;
1465               break;
1466             default:
1467               assert(strchr(validchars, x));
1468               assert(0);
1469             }
1470
1471           if ('t' == y)
1472             {
1473               if (!get_date(&our_pred->args.reftime.ts,
1474                             argv[*arg_ptr],
1475                             &options.start_time))
1476                 {
1477                   error(1, 0,
1478                         _("I cannot figure out how to interpret %s as a date or time"),
1479                         quotearg_n_style(0, options.err_quoting_style, argv[*arg_ptr]));
1480                 }
1481             }
1482           else
1483             {
1484               struct stat stat_newer;
1485
1486               /* Stat the named file. */
1487               set_stat_placeholders(&stat_newer);
1488               if ((*options.xstat) (argv[*arg_ptr], &stat_newer))
1489                 fatal_file_error(argv[*arg_ptr]);
1490
1491               if (!get_stat_Ytime(&stat_newer, y, &our_pred->args.reftime.ts))
1492                 {
1493                   /* We cannot extract a timestamp from the struct stat. */
1494                   error(1, 0, _("Cannot obtain birth time of file %s"),
1495                         safely_quote_err_filename(0, argv[*arg_ptr]));
1496                 }
1497             }
1498           our_pred->args.reftime.kind = COMP_GT;
1499           our_pred->est_success_rate = estimate_timestamp_success_rate(our_pred->args.reftime.ts.tv_sec);
1500           (*arg_ptr)++;
1501
1502           assert(our_pred->pred_func != NULL);
1503           assert(our_pred->pred_func == pred_newerXY);
1504           assert(our_pred->need_stat);
1505           return true;
1506         }
1507     }
1508 }
1509
1510
1511 static boolean
1512 parse_noleaf (const struct parser_table* entry, char **argv, int *arg_ptr)
1513 {
1514   options.no_leaf_check = true;
1515   return parse_noop(entry, argv, arg_ptr);
1516 }
1517
1518 #ifdef CACHE_IDS
1519 /* Arbitrary amount by which to increase size
1520    of `uid_unused' and `gid_unused'. */
1521 #define ALLOC_STEP 2048
1522
1523 /* Boolean: if uid_unused[n] is nonzero, then UID n has no passwd entry. */
1524 char *uid_unused = NULL;
1525
1526 /* Number of elements in `uid_unused'. */
1527 unsigned uid_allocated;
1528
1529 /* Similar for GIDs and group entries. */
1530 char *gid_unused = NULL;
1531 unsigned gid_allocated;
1532 #endif
1533
1534 static boolean
1535 parse_nogroup (const struct parser_table* entry, char **argv, int *arg_ptr)
1536 {
1537   struct predicate *our_pred;
1538
1539   (void) &argv;
1540   (void) &arg_ptr;
1541
1542   our_pred = insert_primary (entry);
1543   our_pred->est_success_rate = 1e-4;
1544 #ifdef CACHE_IDS
1545   if (gid_unused == NULL)
1546     {
1547       struct group *gr;
1548
1549       gid_allocated = ALLOC_STEP;
1550       gid_unused = xmalloc (gid_allocated);
1551       memset (gid_unused, 1, gid_allocated);
1552       setgrent ();
1553       while ((gr = getgrent ()) != NULL)
1554         {
1555           if ((unsigned) gr->gr_gid >= gid_allocated)
1556             {
1557               unsigned new_allocated = (unsigned) gr->gr_gid + ALLOC_STEP;
1558               gid_unused = xrealloc (gid_unused, new_allocated);
1559               memset (gid_unused + gid_allocated, 1,
1560                       new_allocated - gid_allocated);
1561               gid_allocated = new_allocated;
1562             }
1563           gid_unused[(unsigned) gr->gr_gid] = 0;
1564         }
1565       endgrent ();
1566     }
1567 #endif
1568   return true;
1569 }
1570
1571 static boolean
1572 parse_nouser (const struct parser_table* entry, char **argv, int *arg_ptr)
1573 {
1574   struct predicate *our_pred;
1575   (void) argv;
1576   (void) arg_ptr;
1577
1578
1579   our_pred = insert_primary (entry);
1580   our_pred->est_success_rate = 1e-3;
1581 #ifdef CACHE_IDS
1582   if (uid_unused == NULL)
1583     {
1584       struct passwd *pw;
1585
1586       uid_allocated = ALLOC_STEP;
1587       uid_unused = xmalloc (uid_allocated);
1588       memset (uid_unused, 1, uid_allocated);
1589       setpwent ();
1590       while ((pw = getpwent ()) != NULL)
1591         {
1592           if ((unsigned) pw->pw_uid >= uid_allocated)
1593             {
1594               unsigned new_allocated = (unsigned) pw->pw_uid + ALLOC_STEP;
1595               uid_unused = xrealloc (uid_unused, new_allocated);
1596               memset (uid_unused + uid_allocated, 1,
1597                       new_allocated - uid_allocated);
1598               uid_allocated = new_allocated;
1599             }
1600           uid_unused[(unsigned) pw->pw_uid] = 0;
1601         }
1602       endpwent ();
1603     }
1604 #endif
1605   return true;
1606 }
1607
1608 static boolean
1609 parse_nowarn (const struct parser_table* entry, char **argv, int *arg_ptr)
1610 {
1611   options.warnings = false;
1612   return parse_noop(entry, argv, arg_ptr);
1613 }
1614
1615 static boolean
1616 parse_ok (const struct parser_table* entry, char **argv, int *arg_ptr)
1617 {
1618   return insert_exec_ok ("-ok", entry, get_start_dirfd(), argv, arg_ptr);
1619 }
1620
1621 static boolean
1622 parse_okdir (const struct parser_table* entry, char **argv, int *arg_ptr)
1623 {
1624   return insert_exec_ok ("-okdir", entry, -1, argv, arg_ptr);
1625 }
1626
1627 boolean
1628 parse_openparen (const struct parser_table* entry, char **argv, int *arg_ptr)
1629 {
1630   struct predicate *our_pred;
1631
1632   (void) argv;
1633   (void) arg_ptr;
1634
1635   our_pred = get_new_pred_chk_op (entry);
1636   our_pred->pred_func = pred_openparen;
1637   our_pred->p_type = OPEN_PAREN;
1638   our_pred->p_prec = NO_PREC;
1639   our_pred->need_stat = our_pred->need_type = false;
1640   return true;
1641 }
1642
1643 static boolean
1644 parse_or (const struct parser_table* entry, char **argv, int *arg_ptr)
1645 {
1646   struct predicate *our_pred;
1647
1648   (void) argv;
1649   (void) arg_ptr;
1650
1651   our_pred = get_new_pred (entry);
1652   our_pred->pred_func = pred_or;
1653   our_pred->p_type = BI_OP;
1654   our_pred->p_prec = OR_PREC;
1655   our_pred->need_stat = our_pred->need_type = false;
1656   return true;
1657 }
1658
1659 /* -path is deprecated (at RMS's request) in favour of
1660  * -iwholename.   See the node "GNU Manuals" in standards.texi
1661  * for the rationale for this (basically, GNU prefers the use
1662  * of the phrase "file name" to "path name".
1663  *
1664  * We do not issue a warning that this usage is deprecated
1665  * since HPUX find supports this predicate also.
1666  */
1667 static boolean
1668 parse_path (const struct parser_table* entry, char **argv, int *arg_ptr)
1669 {
1670   return parse_wholename(entry, argv, arg_ptr);
1671 }
1672
1673 static boolean
1674 parse_wholename (const struct parser_table* entry, char **argv, int *arg_ptr)
1675 {
1676   const char *name;
1677   if (collect_arg(argv, arg_ptr, &name))
1678     {
1679       struct predicate *our_pred = insert_primary_withpred (entry, pred_path);
1680       our_pred->need_stat = our_pred->need_type = false;
1681       our_pred->args.str = name;
1682       our_pred->est_success_rate = estimate_pattern_match_rate(name, 0);
1683       return true;
1684     }
1685   return false;
1686 }
1687
1688 static boolean
1689 parse_perm (const struct parser_table* entry, char **argv, int *arg_ptr)
1690 {
1691   mode_t perm_val[2];
1692   float rate;
1693   int mode_start = 0;
1694   boolean havekind = false;
1695   enum permissions_type kind = PERM_EXACT;
1696   struct mode_change *change = NULL;
1697   struct predicate *our_pred;
1698   const char *perm_expr;
1699
1700   if (!collect_arg(argv, arg_ptr, &perm_expr))
1701     return false;
1702
1703   switch (perm_expr[0])
1704     {
1705     case '-':
1706       mode_start = 1;
1707       kind = PERM_AT_LEAST;
1708       havekind = true;
1709       rate = 0.2;
1710       break;
1711
1712      case '+':
1713        change = mode_compile (perm_expr);
1714        if (NULL == change)
1715          {
1716            /* Most likely the caller is an old script that is still
1717             * using the obsolete GNU syntax '-perm +MODE'.  This old
1718             * syntax was withdrawn in favor of '-perm /MODE' because
1719             * it is incompatible with POSIX in some cases, but we
1720             * still support uses of it that are not incompatible with
1721             * POSIX.
1722             */
1723            mode_start = 1;
1724            kind = PERM_ANY;
1725            rate = 0.3;
1726          }
1727        else
1728          {
1729            /* This is a POSIX-compatible usage */
1730            mode_start = 0;
1731            kind = PERM_EXACT;
1732            rate = 0.1;
1733          }
1734        havekind = true;
1735        break;
1736
1737     case '/':                   /* GNU extension */
1738        mode_start = 1;
1739        kind = PERM_ANY;
1740        havekind = true;
1741        rate = 0.3;
1742        break;
1743
1744     default:
1745       /* For example, '-perm 0644', which is valid and matches
1746        * only files whose mode is exactly 0644.
1747        */
1748       mode_start = 0;
1749       kind = PERM_EXACT;
1750       havekind = true;
1751       rate = 0.01;
1752       break;
1753     }
1754
1755   if (NULL == change)
1756     {
1757       change = mode_compile (perm_expr + mode_start);
1758       if (NULL == change)
1759         error (1, 0, _("invalid mode %s"),
1760                quotearg_n_style(0, options.err_quoting_style, perm_expr));
1761     }
1762   perm_val[0] = mode_adjust (0, false, 0, change, NULL);
1763   perm_val[1] = mode_adjust (0, true, 0, change, NULL);
1764   free (change);
1765
1766   if (('/' == perm_expr[0]) && (0 == perm_val[0]) && (0 == perm_val[1]))
1767     {
1768       /* The meaning of -perm /000 will change in the future.  It
1769        * currently matches no files, but like -perm -000 it should
1770        * match all files.
1771        *
1772        * Starting in 2005, we used to issue a warning message
1773        * informing the user that the behaviour would change in the
1774        * future.  We have now changed the behaviour and issue a
1775        * warning message that the behaviour recently changed.
1776        */
1777       error (0, 0,
1778              _("warning: you have specified a mode pattern %s (which is "
1779                "equivalent to /000). The meaning of -perm /000 has now been "
1780                "changed to be consistent with -perm -000; that is, while it "
1781                "used to match no files, it now matches all files."),
1782              perm_expr);
1783
1784       kind = PERM_AT_LEAST;
1785       havekind = true;
1786
1787       /* The "magic" number below is just the fraction of files on my
1788        * own system that "-type l -xtype l" fails for (i.e. unbroken symlinks).
1789        * Actual totals are 1472 and 1073833.
1790        */
1791       rate = 0.9986; /* probably matches anything but a broken symlink */
1792     }
1793
1794   our_pred = insert_primary (entry);
1795   our_pred->est_success_rate = rate;
1796   if (havekind)
1797     {
1798       our_pred->args.perm.kind = kind;
1799     }
1800   else
1801     {
1802
1803       switch (perm_expr[0])
1804         {
1805         case '-':
1806           our_pred->args.perm.kind = PERM_AT_LEAST;
1807           break;
1808         case '+':
1809           our_pred->args.perm.kind = PERM_ANY;
1810           break;
1811         default:
1812           our_pred->args.perm.kind = PERM_EXACT;
1813           break;
1814         }
1815     }
1816   memcpy (our_pred->args.perm.val, perm_val, sizeof perm_val);
1817   return true;
1818 }
1819
1820 boolean
1821 parse_print (const struct parser_table* entry, char **argv, int *arg_ptr)
1822 {
1823   struct predicate *our_pred;
1824
1825   (void) argv;
1826   (void) arg_ptr;
1827
1828   our_pred = insert_primary (entry);
1829   /* -print has the side effect of printing.  This prevents us
1830      from doing undesired multiple printing when the user has
1831      already specified -print. */
1832   our_pred->side_effects = our_pred->no_default_print = true;
1833   our_pred->need_stat = our_pred->need_type = false;
1834   open_stdout(&our_pred->args.printf_vec);
1835   return true;
1836 }
1837
1838 static boolean
1839 parse_print0 (const struct parser_table* entry, char **argv, int *arg_ptr)
1840 {
1841   return insert_fprint(entry, NULL);
1842 }
1843
1844 static boolean
1845 parse_printf (const struct parser_table* entry, char **argv, int *arg_ptr)
1846 {
1847   const char *format;
1848   if (collect_arg(argv, arg_ptr, &format))
1849     {
1850       struct format_val fmt;
1851       open_stdout(&fmt);
1852       return insert_fprintf (&fmt, entry, pred_fprintf, format);
1853     }
1854   return false;
1855 }
1856
1857 static boolean
1858 parse_fprintf (const struct parser_table* entry, char **argv, int *arg_ptr)
1859 {
1860   const char *format, *filename;
1861   if (collect_arg(argv, arg_ptr, &filename))
1862     {
1863       if (collect_arg(argv, arg_ptr, &format))
1864         {
1865           struct format_val fmt;
1866           open_output_file (filename, &fmt);
1867           return insert_fprintf (&fmt, entry, pred_fprintf, format);
1868         }
1869     }
1870   return false;
1871 }
1872
1873 static boolean
1874 parse_prune (const struct parser_table* entry, char **argv, int *arg_ptr)
1875 {
1876   struct predicate *our_pred;
1877
1878   (void) argv;
1879   (void) arg_ptr;
1880
1881   our_pred = insert_primary (entry);
1882   our_pred->need_stat = our_pred->need_type = false;
1883   /* -prune has a side effect that it does not descend into
1884      the current directory. */
1885   our_pred->side_effects = true;
1886   our_pred->no_default_print = false;
1887   return true;
1888 }
1889
1890 static boolean
1891 parse_quit  (const struct parser_table* entry, char **argv, int *arg_ptr)
1892 {
1893   struct predicate *our_pred = insert_primary (entry);
1894   (void) argv;
1895   (void) arg_ptr;
1896   our_pred->need_stat = our_pred->need_type = false;
1897   our_pred->side_effects = true; /* Exiting is a side effect... */
1898   our_pred->no_default_print = false; /* Don't inhibit the default print, though. */
1899   our_pred->est_success_rate = 1.0f;
1900   return true;
1901 }
1902
1903
1904 static boolean
1905 parse_regextype (const struct parser_table* entry, char **argv, int *arg_ptr)
1906 {
1907   const char *type_name;
1908   if (collect_arg(argv, arg_ptr, &type_name))
1909     {
1910       /* collect the regex type name */
1911       options.regex_options = get_regex_type(type_name);
1912       return parse_noop(entry, argv, arg_ptr);
1913     }
1914   return false;
1915 }
1916
1917
1918 static boolean
1919 parse_regex (const struct parser_table* entry, char **argv, int *arg_ptr)
1920 {
1921   return insert_regex (argv, arg_ptr, entry, options.regex_options);
1922 }
1923
1924 static boolean
1925 insert_regex (char **argv, int *arg_ptr, const struct parser_table *entry, int regex_options)
1926 {
1927   const char *rx;
1928   if (collect_arg(argv, arg_ptr, &rx))
1929     {
1930       struct re_pattern_buffer *re;
1931       const char *error_message;
1932       struct predicate *our_pred = insert_primary_withpred (entry, pred_regex);
1933       our_pred->need_stat = our_pred->need_type = false;
1934       re = (struct re_pattern_buffer *)
1935         xmalloc (sizeof (struct re_pattern_buffer));
1936       our_pred->args.regex = re;
1937       re->allocated = 100;
1938       re->buffer = (unsigned char *) xmalloc (re->allocated);
1939       re->fastmap = NULL;
1940
1941       re_set_syntax(regex_options);
1942       re->syntax = regex_options;
1943       re->translate = NULL;
1944
1945       error_message = re_compile_pattern (rx, strlen(rx), re);
1946       if (error_message)
1947         error (1, 0, "%s", error_message);
1948       our_pred->est_success_rate = estimate_pattern_match_rate(rx, 1);
1949       return true;
1950     }
1951   return false;
1952 }
1953
1954 static boolean
1955 parse_size (const struct parser_table* entry, char **argv, int *arg_ptr)
1956 {
1957   struct predicate *our_pred;
1958   uintmax_t num;
1959   char suffix;
1960   enum comparison_type c_type;
1961
1962   int blksize = 512;
1963   int len;
1964
1965   /* XXX: cannot (yet) convert to ue collect_arg() as this
1966    * function modifies the args in-place.
1967    */
1968   if ((argv == NULL) || (argv[*arg_ptr] == NULL))
1969     return false;
1970
1971   len = strlen (argv[*arg_ptr]);
1972   if (len == 0)
1973     error (1, 0, _("invalid null argument to -size"));
1974
1975   suffix = argv[*arg_ptr][len - 1];
1976   switch (suffix)
1977     {
1978     case 'b':
1979       blksize = 512;
1980       argv[*arg_ptr][len - 1] = '\0';
1981       break;
1982
1983     case 'c':
1984       blksize = 1;
1985       argv[*arg_ptr][len - 1] = '\0';
1986       break;
1987
1988     case 'k':
1989       blksize = 1024;
1990       argv[*arg_ptr][len - 1] = '\0';
1991       break;
1992
1993     case 'M':                   /* Megabytes */
1994       blksize = 1024*1024;
1995       argv[*arg_ptr][len - 1] = '\0';
1996       break;
1997
1998     case 'G':                   /* Gigabytes */
1999       blksize = 1024*1024*1024;
2000       argv[*arg_ptr][len - 1] = '\0';
2001       break;
2002
2003     case 'w':
2004       blksize = 2;
2005       argv[*arg_ptr][len - 1] = '\0';
2006       break;
2007
2008     case '0':
2009     case '1':
2010     case '2':
2011     case '3':
2012     case '4':
2013     case '5':
2014     case '6':
2015     case '7':
2016     case '8':
2017     case '9':
2018       break;
2019
2020     default:
2021       error (1, 0, _("invalid -size type `%c'"), argv[*arg_ptr][len - 1]);
2022     }
2023   /* TODO: accept fractional megabytes etc. ? */
2024   if (!get_num (argv[*arg_ptr], &num, &c_type))
2025     {
2026       error(1, 0, _("Invalid argument `%s%c' to -size"), argv[*arg_ptr], (int)suffix);
2027       return false;
2028     }
2029   our_pred = insert_primary (entry);
2030   our_pred->args.size.kind = c_type;
2031   our_pred->args.size.blocksize = blksize;
2032   our_pred->args.size.size = num;
2033   our_pred->need_stat = true;
2034   our_pred->need_type = false;
2035
2036   if (COMP_GT == c_type)
2037     our_pred->est_success_rate = (num*blksize > 20480) ? 0.1 : 0.9;
2038   else if (COMP_LT == c_type)
2039     our_pred->est_success_rate = (num*blksize > 20480) ? 0.9 : 0.1;
2040   else
2041     our_pred->est_success_rate = 0.01;
2042
2043   (*arg_ptr)++;
2044   return true;
2045 }
2046
2047
2048 static boolean
2049 parse_samefile (const struct parser_table* entry, char **argv, int *arg_ptr)
2050 {
2051   /* General idea: stat the file, remember device and inode numbers.
2052    * If a candidate file matches those, it's the same file.
2053    */
2054   struct predicate *our_pred;
2055   struct stat st, fst;
2056   int fd, openflags;
2057
2058   set_stat_placeholders(&st);
2059   if (!collect_arg_stat_info(argv, arg_ptr, &st))
2060     return false;
2061
2062   set_stat_placeholders(&fst);
2063   /* POSIX systems are free to re-use the inode number of a deleted
2064    * file.  To ensure that we are not fooled by inode reuse, we hold
2065    * the file open if we can.  This would prevent the system reusing
2066    * the file.
2067    */
2068   fd = -3;                      /* means, uninitialised */
2069   openflags = O_RDONLY;
2070
2071   if (options.symlink_handling == SYMLINK_NEVER_DEREF)
2072     {
2073       if (options.open_nofollow_available)
2074         {
2075           assert(O_NOFOLLOW != 0);
2076           openflags |= O_NOFOLLOW;
2077           fd = -1;              /* safe to open it. */
2078         }
2079       else
2080         {
2081           if (S_ISLNK(st.st_mode))
2082             {
2083               /* no way to ensure that a symlink will not be followed
2084                * by open(2), so fall back on using lstat().  Accept
2085                * the risk that the named file will be deleted and
2086                * replaced with another having the same inode.
2087                *
2088                * Avoid opening the file.
2089                */
2090               fd = -2;          /* Do not open it */
2091             }
2092           else
2093             {
2094               fd = -1;
2095               /* Race condition here: the file might become a symlink here. */
2096             }
2097         }
2098     }
2099   else
2100     {
2101       /* We want to dereference the symlink anyway */
2102       fd = -1;                  /* safe to open it without O_NOFOLLOW */
2103     }
2104
2105   assert(fd != -3);             /* check we made a decision */
2106   if (fd == -1)
2107     {
2108       /* Race condition here.  The file might become a
2109        * symbolic link in between out call to stat and
2110        * the call to open.
2111        */
2112       fd = open(argv[*arg_ptr], openflags);
2113
2114       if (fd >= 0)
2115         {
2116           /* We stat the file again here to prevent a race condition
2117            * between the first stat and the call to open(2).
2118            */
2119           if (0 != fstat(fd, &fst))
2120             {
2121               fatal_file_error(argv[*arg_ptr]);
2122             }
2123           else
2124             {
2125               /* Worry about the race condition.  If the file became a
2126                * symlink after our first stat and before our call to
2127                * open, fst may contain the stat information for the
2128                * destination of the link, not the link itself.
2129                */
2130               if ((*options.xstat) (argv[*arg_ptr], &st))
2131                 fatal_file_error(argv[*arg_ptr]);
2132
2133               if ((options.symlink_handling == SYMLINK_NEVER_DEREF)
2134                   && (!options.open_nofollow_available))
2135                 {
2136                   if (S_ISLNK(st.st_mode))
2137                     {
2138                       /* We lost the race.  Leave the data in st.  The
2139                        * file descriptor points to the wrong thing.
2140                        */
2141                       close(fd);
2142                       fd = -1;
2143                     }
2144                   else
2145                     {
2146                       /* Several possibilities here:
2147                        * 1. There was no race
2148                        * 2. The file changed into a symlink after the stat and
2149                        *    before the open, and then back into a non-symlink
2150                        *    before the second stat.
2151                        *
2152                        * In case (1) there is no problem.  In case (2),
2153                        * the stat() and fstat() calls will have returned
2154                        * different data.  O_NOFOLLOW was not available,
2155                        * so the open() call may have followed a symlink
2156                        * even if the -P option is in effect.
2157                        */
2158                       if ((st.st_dev == fst.st_dev)
2159                           && (st.st_ino == fst.st_ino))
2160                         {
2161                           /* No race.  No need to copy fst to st,
2162                            * since they should be identical (modulo
2163                            * differences in padding bytes).
2164                            */
2165                         }
2166                       else
2167                         {
2168                           /* We lost the race.  Leave the data in st.  The
2169                            * file descriptor points to the wrong thing.
2170                            */
2171                           close(fd);
2172                           fd = -1;
2173                         }
2174                     }
2175                 }
2176               else
2177                 {
2178                   st = fst;
2179                 }
2180             }
2181         }
2182     }
2183
2184   our_pred = insert_primary (entry);
2185   our_pred->args.samefileid.ino = st.st_ino;
2186   our_pred->args.samefileid.dev = st.st_dev;
2187   our_pred->args.samefileid.fd  = fd;
2188   our_pred->need_type = false;
2189   our_pred->need_stat = true;
2190   our_pred->est_success_rate = 0.01f;
2191   return true;
2192 }
2193
2194 #if 0
2195 /* This function is commented out partly because support for it is
2196  * uneven.
2197  */
2198 static boolean
2199 parse_show_control_chars (const struct parser_table* entry, char **argv, int *arg_ptr)
2200 {
2201   const char *arg;
2202   const char *errmsg = _("The -show-control-chars option takes a single argument which "
2203                          "must be 'literal' or 'safe'");
2204
2205   if ((argv == NULL) || (argv[*arg_ptr] == NULL))
2206     {
2207       error (1, errno, "%s", errmsg);
2208       return false;
2209     }
2210   else
2211     {
2212       arg = argv[*arg_ptr];
2213
2214       if (0 == strcmp("literal", arg))
2215         {
2216           options.literal_control_chars = true;
2217         }
2218       else if (0 == strcmp("safe", arg))
2219         {
2220           options.literal_control_chars = false;
2221         }
2222       else
2223         {
2224           error (1, errno, "%s", errmsg);
2225           return false;
2226         }
2227       (*arg_ptr)++;             /* consume the argument. */
2228       return true;
2229     }
2230 }
2231 #endif
2232
2233
2234 static boolean
2235 parse_true (const struct parser_table* entry, char **argv, int *arg_ptr)
2236 {
2237   struct predicate *our_pred;
2238
2239   (void) argv;
2240   (void) arg_ptr;
2241
2242   our_pred = insert_primary (entry);
2243   our_pred->need_stat = our_pred->need_type = false;
2244   our_pred->est_success_rate = 1.0f;
2245   return true;
2246 }
2247
2248 static boolean
2249 parse_noop (const struct parser_table* entry, char **argv, int *arg_ptr)
2250 {
2251   (void) entry;
2252   return parse_true(get_noop(), argv, arg_ptr);
2253 }
2254
2255 static boolean
2256 parse_accesscheck (const struct parser_table* entry, char **argv, int *arg_ptr)
2257 {
2258   struct predicate *our_pred;
2259   (void) argv;
2260   (void) arg_ptr;
2261   our_pred = insert_primary (entry);
2262   our_pred->need_stat = our_pred->need_type = false;
2263   our_pred->side_effects = our_pred->no_default_print = false;
2264   if (pred_is(our_pred, pred_executable))
2265     our_pred->est_success_rate = 0.2;
2266   else
2267     our_pred->est_success_rate = 0.9;
2268   return true;
2269 }
2270
2271 static boolean
2272 parse_type (const struct parser_table* entry, char **argv, int *arg_ptr)
2273 {
2274   return insert_type (argv, arg_ptr, entry, pred_type);
2275 }
2276
2277 static boolean
2278 parse_uid (const struct parser_table* entry, char **argv, int *arg_ptr)
2279 {
2280   struct predicate *p = insert_num (argv, arg_ptr, entry);
2281   if (p)
2282     {
2283       p->est_success_rate = (p->args.numinfo.l_val < 100) ? 0.99 : 0.2;
2284       return true;
2285     }
2286   else
2287     {
2288       return false;
2289     }
2290 }
2291
2292 static boolean
2293 parse_used (const struct parser_table* entry, char **argv, int *arg_ptr)
2294 {
2295   struct predicate *our_pred;
2296   struct time_val tval;
2297   const char *offset_str;
2298   const char *errmsg = "arithmetic overflow while converting %s days to a number of seconds";
2299
2300   if (collect_arg(argv, arg_ptr, &offset_str))
2301     {
2302       /* The timespec is actually a delta value, so we use an origin of 0. */
2303       if (get_relative_timestamp(offset_str, &tval, 0, DAYSECS, errmsg))
2304         {
2305           our_pred = insert_primary (entry);
2306           our_pred->args.reftime = tval;
2307           our_pred->est_success_rate = estimate_file_age_success_rate(tval.ts.tv_sec / DAYSECS);
2308           return true;
2309         }
2310       else
2311         {
2312           error(1, 0, _("Invalid argument %s to -used"), offset_str);
2313           return false;
2314         }
2315     }
2316   else
2317     {
2318       return false;             /* missing argument */
2319     }
2320 }
2321
2322 static boolean
2323 parse_user (const struct parser_table* entry, char **argv, int *arg_ptr)
2324 {
2325   const char *username;
2326
2327   if (collect_arg(argv, arg_ptr, &username))
2328     {
2329       struct predicate *our_pred;
2330       uid_t uid;
2331       struct passwd *cur_pwd = getpwnam(username);
2332       endpwent();
2333       if (cur_pwd != NULL)
2334         {
2335           uid = cur_pwd->pw_uid;
2336         }
2337       else
2338         {
2339           int uid_len = strspn (username, "0123456789");
2340           if (uid_len && (username[uid_len]==0))
2341             uid = safe_atoi (username);
2342           else
2343             return false;
2344         }
2345       our_pred = insert_primary (entry);
2346       our_pred->args.uid = uid;
2347       our_pred->est_success_rate = (our_pred->args.uid < 100) ? 0.99 : 0.2;
2348       return true;
2349     }
2350   return false;
2351 }
2352
2353 static boolean
2354 parse_version (const struct parser_table* entry, char **argv, int *arg_ptr)
2355 {
2356   extern char *version_string;
2357   int features = 0;
2358   int flags;
2359
2360   (void) argv;
2361   (void) arg_ptr;
2362   (void) entry;
2363
2364   fflush (stderr);
2365   printf (_("GNU find version %s\n"), version_string);
2366   printf (_("Built using GNU gnulib version %s\n"), gnulib_version);
2367   printf (_("Features enabled: "));
2368
2369 #if CACHE_IDS
2370   printf("CACHE_IDS ");
2371   ++features;
2372 #endif
2373 #if DEBUG
2374   printf("DEBUG ");
2375   ++features;
2376 #endif
2377 #if DEBUG_STAT
2378   printf("DEBUG_STAT ");
2379   ++features;
2380 #endif
2381 #if defined(USE_STRUCT_DIRENT_D_TYPE) && defined(HAVE_STRUCT_DIRENT_D_TYPE)
2382   printf("D_TYPE ");
2383   ++features;
2384 #endif
2385 #if defined(O_NOFOLLOW)
2386   printf("O_NOFOLLOW(%s) ",
2387          (options.open_nofollow_available ? "enabled" : "disabled"));
2388   ++features;
2389 #endif
2390 #if defined(LEAF_OPTIMISATION)
2391   printf("LEAF_OPTIMISATION ");
2392   ++features;
2393 #endif
2394
2395   flags = 0;
2396   if (is_fts_enabled(&flags))
2397     {
2398       int nflags = 0;
2399       printf("FTS(");
2400       ++features;
2401
2402       if (flags & FTS_CWDFD)
2403         {
2404           if (nflags)
2405             {
2406               printf(",");
2407             }
2408           printf("FTS_CWDFD");
2409           ++nflags;
2410         }
2411       printf(") ");
2412     }
2413
2414   printf("CBO(level=%d) ", (int)(options.optimisation_level));
2415   ++features;
2416
2417   if (0 == features)
2418     {
2419       /* For the moment, leave this as English in case someone wants
2420          to parse these strings. */
2421       printf("none");
2422     }
2423   printf("\n");
2424
2425   exit (0);
2426 }
2427
2428 static boolean
2429 parse_xdev (const struct parser_table* entry, char **argv, int *arg_ptr)
2430 {
2431   options.stay_on_filesystem = true;
2432   return parse_noop(entry, argv, arg_ptr);
2433 }
2434
2435 static boolean
2436 parse_ignore_race (const struct parser_table* entry, char **argv, int *arg_ptr)
2437 {
2438   options.ignore_readdir_race = true;
2439   return parse_noop(entry, argv, arg_ptr);
2440 }
2441
2442 static boolean
2443 parse_noignore_race (const struct parser_table* entry, char **argv, int *arg_ptr)
2444 {
2445   options.ignore_readdir_race = false;
2446   return parse_noop(entry, argv, arg_ptr);
2447 }
2448
2449 static boolean
2450 parse_warn (const struct parser_table* entry, char **argv, int *arg_ptr)
2451 {
2452   options.warnings = true;
2453   return parse_noop(entry, argv, arg_ptr);
2454 }
2455
2456 static boolean
2457 parse_xtype (const struct parser_table* entry, char **argv, int *arg_ptr)
2458 {
2459   return insert_type (argv, arg_ptr, entry, pred_xtype);
2460 }
2461 \f
2462 static boolean
2463 insert_type (char **argv, int *arg_ptr, const struct parser_table *entry, PRED_FUNC which_pred)
2464 {
2465   mode_t type_cell;
2466   struct predicate *our_pred;
2467   float rate = 0.5;
2468   const char *typeletter;
2469
2470   if (collect_arg(argv, arg_ptr, &typeletter))
2471     {
2472       if (strlen(typeletter) != 1u)
2473         {
2474           error(1, 0, _("Arguments to -type should contain only one letter"));
2475           return false;
2476         }
2477
2478       switch (typeletter[0])
2479         {
2480         case 'b':                       /* block special */
2481           type_cell = S_IFBLK;
2482           rate = 0.01f;
2483           break;
2484         case 'c':                       /* character special */
2485           type_cell = S_IFCHR;
2486           rate = 0.01f;
2487           break;
2488         case 'd':                       /* directory */
2489           type_cell = S_IFDIR;
2490           rate = 0.4f;
2491           break;
2492         case 'f':                       /* regular file */
2493           type_cell = S_IFREG;
2494           rate = 0.95f;
2495           break;
2496 #ifdef S_IFLNK
2497         case 'l':                       /* symbolic link */
2498           type_cell = S_IFLNK;
2499           rate = 0.1f;
2500           break;
2501 #endif
2502 #ifdef S_IFIFO
2503         case 'p':                       /* pipe */
2504           type_cell = S_IFIFO;
2505           rate = 0.01f;
2506           break;
2507 #endif
2508 #ifdef S_IFSOCK
2509         case 's':                       /* socket */
2510           type_cell = S_IFSOCK;
2511           rate = 0.01f;
2512           break;
2513 #endif
2514 #ifdef S_IFDOOR
2515         case 'D':                       /* Solaris door */
2516           type_cell = S_IFDOOR;
2517           rate = 0.01f;
2518           break;
2519 #endif
2520         default:                        /* None of the above ... nuke 'em. */
2521           error(1, 0, _("Unknown argument to -type: %c"), (*typeletter));
2522           return false;
2523         }
2524       our_pred = insert_primary_withpred (entry, which_pred);
2525       our_pred->est_success_rate = rate;
2526
2527       /* Figure out if we will need to stat the file, because if we don't
2528        * need to follow symlinks, we can avoid a stat call by using
2529        * struct dirent.d_type.
2530        */
2531       if (which_pred == pred_xtype)
2532         {
2533           our_pred->need_stat = true;
2534           our_pred->need_type = false;
2535         }
2536       else
2537         {
2538           our_pred->need_stat = false; /* struct dirent is enough */
2539           our_pred->need_type = true;
2540         }
2541       our_pred->args.type = type_cell;
2542       return true;
2543     }
2544   return false;
2545 }
2546
2547
2548 /* Return true if the file accessed via FP is a terminal.
2549  */
2550 static boolean
2551 stream_is_tty(FILE *fp)
2552 {
2553   int fd = fileno(fp);
2554   if (-1 == fd)
2555     {
2556       return false; /* not a valid stream */
2557     }
2558   else
2559     {
2560       return isatty(fd) ? true : false;
2561     }
2562
2563 }
2564
2565
2566
2567
2568 /* XXX: do we need to pass FUNC to this function? */
2569 static boolean
2570 insert_fprintf (struct format_val *vec,
2571                 const struct parser_table *entry, PRED_FUNC func,
2572                 const char *format_const)
2573 {
2574   char *format = (char*)format_const; /* XXX: casting away constness */
2575   register char *scan;          /* Current address in scanning `format'. */
2576   register char *scan2;         /* Address inside of element being scanned. */
2577   struct segment **segmentp;    /* Address of current segment. */
2578   struct predicate *our_pred;
2579
2580   our_pred = insert_primary_withpred (entry, func);
2581   our_pred->side_effects = our_pred->no_default_print = true;
2582   our_pred->args.printf_vec = *vec;
2583   our_pred->need_type = false;
2584   our_pred->need_stat = false;
2585   our_pred->p_cost    = NeedsNothing;
2586
2587   segmentp = &our_pred->args.printf_vec.segment;
2588   *segmentp = NULL;
2589
2590   for (scan = format; *scan; scan++)
2591     {
2592       if (*scan == '\\')
2593         {
2594           scan2 = scan + 1;
2595           if (*scan2 >= '0' && *scan2 <= '7')
2596             {
2597               register int n, i;
2598
2599               for (i = n = 0; i < 3 && (*scan2 >= '0' && *scan2 <= '7');
2600                    i++, scan2++)
2601                 n = 8 * n + *scan2 - '0';
2602               scan2--;
2603               *scan = n;
2604             }
2605           else
2606             {
2607               switch (*scan2)
2608                 {
2609                 case 'a':
2610                   *scan = 7;
2611                   break;
2612                 case 'b':
2613                   *scan = '\b';
2614                   break;
2615                 case 'c':
2616                   make_segment (segmentp, format, scan - format,
2617                                 KIND_STOP, 0, 0,
2618                                 our_pred);
2619                   if (our_pred->need_stat && (our_pred->p_cost < NeedsStatInfo))
2620                     our_pred->p_cost = NeedsStatInfo;
2621                   return true;
2622                 case 'f':
2623                   *scan = '\f';
2624                   break;
2625                 case 'n':
2626                   *scan = '\n';
2627                   break;
2628                 case 'r':
2629                   *scan = '\r';
2630                   break;
2631                 case 't':
2632                   *scan = '\t';
2633                   break;
2634                 case 'v':
2635                   *scan = '\v';
2636                   break;
2637                 case '\\':
2638                   /* *scan = '\\'; * it already is */
2639                   break;
2640                 default:
2641                   error (0, 0,
2642                          _("warning: unrecognized escape `\\%c'"), *scan2);
2643                   scan++;
2644                   continue;
2645                 }
2646             }
2647           segmentp = make_segment (segmentp, format, scan - format + 1,
2648                                    KIND_PLAIN, 0, 0,
2649                                    our_pred);
2650           format = scan2 + 1;   /* Move past the escape. */
2651           scan = scan2;         /* Incremented immediately by `for'. */
2652         }
2653       else if (*scan == '%')
2654         {
2655           if (scan[1] == 0)
2656             {
2657               /* Trailing %.  We don't like those. */
2658               error (1, 0, _("error: %s at end of format string"), scan);
2659             }
2660           else if (scan[1] == '%')
2661             {
2662               segmentp = make_segment (segmentp, format, scan - format + 1,
2663                                        KIND_PLAIN, 0, 0,
2664                                        our_pred);
2665               scan++;
2666               format = scan + 1;
2667               continue;
2668             }
2669           /* Scan past flags, width and precision, to verify kind. */
2670           for (scan2 = scan; *++scan2 && strchr ("-+ #", *scan2);)
2671             /* Do nothing. */ ;
2672           while (ISDIGIT (*scan2))
2673             scan2++;
2674           if (*scan2 == '.')
2675             for (scan2++; ISDIGIT (*scan2); scan2++)
2676               /* Do nothing. */ ;
2677           if (strchr ("abcdDfFgGhHiklmMnpPsStuUyY", *scan2))
2678             {
2679               segmentp = make_segment (segmentp, format, scan2 - format,
2680                                        KIND_FORMAT, *scan2, 0,
2681                                        our_pred);
2682               scan = scan2;
2683               format = scan + 1;
2684             }
2685           else if (strchr ("ABCT", *scan2) && scan2[1])
2686             {
2687               segmentp = make_segment (segmentp, format, scan2 - format,
2688                                        KIND_FORMAT, scan2[0], scan2[1],
2689                                        our_pred);
2690               scan = scan2 + 1;
2691               format = scan + 1;
2692               continue;
2693             }
2694           else
2695             {
2696               /* An unrecognized % escape.  Print the char after the %. */
2697               error (0, 0, _("warning: unrecognized format directive `%%%c'"),
2698                      *scan2);
2699               segmentp = make_segment (segmentp, format, scan - format,
2700                                        KIND_PLAIN, 0, 0,
2701                                        our_pred);
2702               format = scan + 1;
2703               continue;
2704             }
2705         }
2706     }
2707
2708   if (scan > format)
2709     make_segment (segmentp, format, scan - format, KIND_PLAIN, 0, 0,
2710                   our_pred);
2711   return true;
2712 }
2713
2714 /* Create a new fprintf segment in *SEGMENT, with type KIND,
2715    from the text in FORMAT, which has length LEN.
2716    Return the address of the `next' pointer of the new segment. */
2717
2718 static struct segment **
2719 make_segment (struct segment **segment,
2720               char *format,
2721               int len,
2722               int kind,
2723               char format_char,
2724               char aux_format_char,
2725               struct predicate *pred)
2726 {
2727   enum EvaluationCost mycost = NeedsNothing;
2728   char *fmt;
2729
2730   *segment = (struct segment *) xmalloc (sizeof (struct segment));
2731
2732   (*segment)->segkind = kind;
2733   (*segment)->format_char[0] = format_char;
2734   (*segment)->format_char[1] = aux_format_char;
2735   (*segment)->next = NULL;
2736   (*segment)->text_len = len;
2737
2738   fmt = (*segment)->text = xmalloc (len + sizeof "d");
2739   strncpy (fmt, format, len);
2740   fmt += len;
2741
2742   switch (kind)
2743     {
2744     case KIND_PLAIN:            /* Plain text string, no % conversion. */
2745     case KIND_STOP:             /* Terminate argument, no newline. */
2746       assert(0 == format_char);
2747       assert(0 == aux_format_char);
2748       *fmt = '\0';
2749       if (mycost > pred->p_cost)
2750         pred->p_cost = NeedsNothing;
2751       return &(*segment)->next;
2752       break;
2753     }
2754
2755   assert(kind == KIND_FORMAT);
2756   switch (format_char)
2757     {
2758     case 'l':                   /* object of symlink */
2759       pred->need_stat = true;
2760       mycost = NeedsLinkName;
2761       *fmt++ = 's';
2762       break;
2763
2764     case 'y':                   /* file type */
2765       pred->need_type = true;
2766       mycost = NeedsType;
2767       *fmt++ = 's';
2768       break;
2769
2770     case 'a':                   /* atime in `ctime' format */
2771     case 'A':                   /* atime in user-specified strftime format */
2772     case 'B':                   /* birth time in user-specified strftime format */
2773     case 'c':                   /* ctime in `ctime' format */
2774     case 'C':                   /* ctime in user-specified strftime format */
2775     case 'F':                   /* filesystem type */
2776     case 'g':                   /* group name */
2777     case 'i':                   /* inode number */
2778     case 'M':                   /* mode in `ls -l' format (eg., "drwxr-xr-x") */
2779     case 's':                   /* size in bytes */
2780     case 't':                   /* mtime in `ctime' format */
2781     case 'T':                   /* mtime in user-specified strftime format */
2782     case 'u':                   /* user name */
2783       pred->need_stat = true;
2784       mycost = NeedsStatInfo;
2785       *fmt++ = 's';
2786       break;
2787
2788     case 'S':                   /* sparseness */
2789       pred->need_stat = true;
2790       mycost = NeedsStatInfo;
2791       *fmt++ = 'g';
2792       break;
2793
2794     case 'Y':                   /* symlink pointed file type */
2795       pred->need_stat = true;
2796       mycost = NeedsType;       /* true for amortised effect */
2797       *fmt++ = 's';
2798       break;
2799
2800     case 'f':                   /* basename of path */
2801     case 'h':                   /* leading directories part of path */
2802     case 'p':                   /* pathname */
2803     case 'P':                   /* pathname with ARGV element stripped */
2804       *fmt++ = 's';
2805       break;
2806
2807     case 'H':                   /* ARGV element file was found under */
2808       *fmt++ = 's';
2809       break;
2810
2811       /* Numeric items that one might expect to honour
2812        * #, 0, + flags but which do not.
2813        */
2814     case 'G':                   /* GID number */
2815     case 'U':                   /* UID number */
2816     case 'b':                   /* size in 512-byte blocks (NOT birthtime in ctime fmt)*/
2817     case 'D':                   /* Filesystem device on which the file exits */
2818     case 'k':                   /* size in 1K blocks */
2819     case 'n':                   /* number of links */
2820       pred->need_stat = true;
2821       mycost = NeedsStatInfo;
2822       *fmt++ = 's';
2823       break;
2824
2825       /* Numeric items that DO honour #, 0, + flags.
2826        */
2827     case 'd':                   /* depth in search tree (0 = ARGV element) */
2828       *fmt++ = 'd';
2829       break;
2830
2831     case 'm':                   /* mode as octal number (perms only) */
2832       *fmt++ = 'o';
2833       pred->need_stat = true;
2834       mycost = NeedsStatInfo;
2835       break;
2836
2837     case '{':
2838     case '[':
2839     case '(':
2840       error (1, 0,
2841              _("error: the format directive `%%%c' is reserved for future use"),
2842              (int)kind);
2843       /*NOTREACHED*/
2844       break;
2845     }
2846   *fmt = '\0';
2847
2848   if (mycost > pred->p_cost)
2849     pred->p_cost = mycost;
2850   return &(*segment)->next;
2851 }
2852 \f
2853 static void
2854 check_path_safety(const char *action, char **argv)
2855 {
2856   const char *path = getenv("PATH");
2857   char *s;
2858
2859   (void)argv;
2860
2861   s = next_element(path, 1);
2862   while ((s = next_element ((char *) NULL, 1)) != NULL)
2863     {
2864       if (0 == strcmp(s, "."))
2865         {
2866           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)"),
2867                 action);
2868         }
2869       else if ('/' != s[0])
2870         {
2871           /* Relative paths are also dangerous in $PATH. */
2872           error(1, 0, _("The relative path %s is included in the PATH "
2873                         "environment variable, which is insecure in "
2874                         "combination with the %s action of find.  "
2875                         "Please remove that entry from $PATH"),
2876                 safely_quote_err_filename(0, s),
2877                 action);
2878         }
2879     }
2880 }
2881
2882 \f
2883 /* handles both exec and ok predicate */
2884 static boolean
2885 new_insert_exec_ok (const char *action,
2886                     const struct parser_table *entry,
2887                     int dirfd,
2888                     char **argv,
2889                     int *arg_ptr)
2890 {
2891   int start, end;               /* Indexes in ARGV of start & end of cmd. */
2892   int i;                        /* Index into cmd args */
2893   int saw_braces;               /* True if previous arg was '{}'. */
2894   boolean allow_plus;           /* True if + is a valid terminator */
2895   int brace_count;              /* Number of instances of {}. */
2896   PRED_FUNC func = entry->pred_func;
2897   enum BC_INIT_STATUS bcstatus;
2898
2899   struct predicate *our_pred;
2900   struct exec_val *execp;       /* Pointer for efficiency. */
2901
2902   if ((argv == NULL) || (argv[*arg_ptr] == NULL))
2903     return false;
2904
2905   our_pred = insert_primary_withpred (entry, func);
2906   our_pred->side_effects = our_pred->no_default_print = true;
2907   our_pred->need_type = our_pred->need_stat = false;
2908
2909   execp = &our_pred->args.exec_vec;
2910
2911   if ((func != pred_okdir) && (func != pred_ok))
2912     {
2913       allow_plus = true;
2914       execp->close_stdin = false;
2915     }
2916   else
2917     {
2918       allow_plus = false;
2919       /* If find reads stdin (i.e. for -ok and similar), close stdin
2920        * in the child to prevent some script from consiming the output
2921        * intended for find.
2922        */
2923       execp->close_stdin = true;
2924     }
2925
2926
2927   if ((func == pred_execdir) || (func == pred_okdir))
2928     {
2929       options.ignore_readdir_race = false;
2930       check_path_safety(action, argv);
2931       execp->use_current_dir = true;
2932     }
2933   else
2934     {
2935       execp->use_current_dir = false;
2936     }
2937
2938   our_pred->args.exec_vec.multiple = 0;
2939
2940   /* Count the number of args with path replacements, up until the ';'.
2941    * Also figure out if the command is terminated by ";" or by "+".
2942    */
2943   start = *arg_ptr;
2944   for (end = start, saw_braces=0, brace_count=0;
2945        (argv[end] != NULL)
2946        && ((argv[end][0] != ';') || (argv[end][1] != '\0'));
2947        end++)
2948     {
2949       /* For -exec and -execdir, "{} +" can terminate the command. */
2950       if ( allow_plus
2951            && argv[end][0] == '+' && argv[end][1] == 0
2952            && saw_braces)
2953         {
2954           our_pred->args.exec_vec.multiple = 1;
2955           break;
2956         }
2957
2958       saw_braces = 0;
2959       if (mbsstr (argv[end], "{}"))
2960         {
2961           saw_braces = 1;
2962           ++brace_count;
2963
2964           if (0 == end && (func == pred_execdir || func == pred_okdir))
2965             {
2966               /* The POSIX standard says that {} replacement should
2967                * occur even in the utility name.  This is insecure
2968                * since it means we will be executing a command whose
2969                * name is chosen according to whatever find finds in
2970                * the filesystem.  That can be influenced by an
2971                * attacker.  Hence for -execdir and -okdir this is not
2972                * allowed.  We can specify this as those options are
2973                * not defined by POSIX.
2974                */
2975               error(1, 0, _("You may not use {} within the utility name for -execdir and -okdir, because this is a potential security problem."));
2976             }
2977         }
2978     }
2979
2980   /* Fail if no command given or no semicolon found. */
2981   if ((end == start) || (argv[end] == NULL))
2982     {
2983       *arg_ptr = end;
2984       free(our_pred);
2985       return false;
2986     }
2987
2988   if (our_pred->args.exec_vec.multiple && brace_count > 1)
2989     {
2990
2991       const char *suffix;
2992       if (func == pred_execdir)
2993         suffix = "dir";
2994       else
2995         suffix = "";
2996
2997       error(1, 0,
2998             _("Only one instance of {} is supported with -exec%s ... +"),
2999             suffix);
3000     }
3001
3002   /* We use a switch statement here so that the compiler warns us when
3003    * we forget to handle a newly invented enum value.
3004    *
3005    * Like xargs, we allow 2KiB of headroom for the launched utility to
3006    * export its own environment variables before calling something
3007    * else.
3008    */
3009   bcstatus = bc_init_controlinfo(&execp->ctl, 2048u);
3010   switch (bcstatus)
3011     {
3012     case BC_INIT_ENV_TOO_BIG:
3013     case BC_INIT_CANNOT_ACCOMODATE_HEADROOM:
3014       error(1, 0,
3015             _("The environment is too large for exec()."));
3016       break;
3017     case BC_INIT_OK:
3018       /* Good news.  Carry on. */
3019       break;
3020     }
3021   bc_use_sensible_arg_max(&execp->ctl);
3022
3023
3024   execp->ctl.exec_callback = launch;
3025
3026   if (our_pred->args.exec_vec.multiple)
3027     {
3028       /* "+" terminator, so we can just append our arguments after the
3029        * command and initial arguments.
3030        */
3031       execp->replace_vec = NULL;
3032       execp->ctl.replace_pat = NULL;
3033       execp->ctl.rplen = 0;
3034       execp->ctl.lines_per_exec = 0; /* no limit */
3035       execp->ctl.args_per_exec = 0; /* no limit */
3036
3037       /* remember how many arguments there are */
3038       execp->ctl.initial_argc = (end-start) - 1;
3039
3040       /* execp->state = xmalloc(sizeof struct buildcmd_state); */
3041       bc_init_state(&execp->ctl, &execp->state, execp);
3042
3043       /* Gather the initial arguments.  Skip the {}. */
3044       for (i=start; i<end-1; ++i)
3045         {
3046           bc_push_arg(&execp->ctl, &execp->state,
3047                       argv[i], strlen(argv[i])+1,
3048                       NULL, 0,
3049                       1);
3050         }
3051     }
3052   else
3053     {
3054       /* Semicolon terminator - more than one {} is supported, so we
3055        * have to do brace-replacement.
3056        */
3057       execp->num_args = end - start;
3058
3059       execp->ctl.replace_pat = "{}";
3060       execp->ctl.rplen = strlen(execp->ctl.replace_pat);
3061       execp->ctl.lines_per_exec = 0; /* no limit */
3062       execp->ctl.args_per_exec = 0; /* no limit */
3063       execp->replace_vec = xmalloc(sizeof(char*)*execp->num_args);
3064
3065
3066       /* execp->state = xmalloc(sizeof(*(execp->state))); */
3067       bc_init_state(&execp->ctl, &execp->state, execp);
3068
3069       /* Remember the (pre-replacement) arguments for later. */
3070       for (i=0; i<execp->num_args; ++i)
3071         {
3072           execp->replace_vec[i] = argv[i+start];
3073         }
3074     }
3075
3076   if (argv[end] == NULL)
3077     *arg_ptr = end;
3078   else
3079     *arg_ptr = end + 1;
3080
3081   return true;
3082 }
3083
3084
3085
3086 static boolean
3087 insert_exec_ok (const char *action, const struct parser_table *entry, int dirfd, char **argv, int *arg_ptr)
3088 {
3089   return new_insert_exec_ok(action, entry, dirfd, argv, arg_ptr);
3090 }
3091
3092
3093 \f
3094 /* Get a timestamp and comparison type.
3095
3096    STR is the ASCII representation.
3097    Set *NUM_DAYS to the number of days/minutes/whatever, taken as being
3098    relative to ORIGIN (usually the current moment or midnight).
3099    Thus the sense of the comparison type appears to be reversed.
3100    Set *COMP_TYPE to the kind of comparison that is requested.
3101    Issue OVERFLOWMESSAGE if overflow occurs.
3102    Return true if all okay, false if input error.
3103
3104    Used by -atime, -ctime and -mtime (parsers) to
3105    get the appropriate information for a time predicate processor. */
3106
3107 static boolean
3108 get_relative_timestamp (const char *str,
3109                         struct time_val *result,
3110                         time_t origin,
3111                         double sec_per_unit,
3112                         const char *overflowmessage)
3113 {
3114   uintmax_t checkval;
3115   double offset, seconds, f;
3116
3117   if (get_comp_type(&str, &result->kind))
3118     {
3119       /* Invert the sense of the comparison */
3120       switch (result->kind)
3121         {
3122         case COMP_LT: result->kind = COMP_GT; break;
3123         case COMP_GT: result->kind = COMP_LT; break;
3124         default: break;
3125         }
3126
3127       /* Convert the ASCII number into floating-point. */
3128       if (xstrtod(str, NULL, &offset, strtod))
3129         {
3130           /* Separate the floating point number the user specified
3131            * (which is a number of days, or minutes, etc) into an
3132            * integral number of seconds (SECONDS) and a fraction (F).
3133            */
3134           f = modf(offset * sec_per_unit, &seconds);
3135
3136           result->ts.tv_sec  = origin - seconds;
3137           result->ts.tv_nsec = fabs(f * 1e9);
3138
3139           /* Check for overflow. */
3140           checkval = (uintmax_t)origin - seconds;
3141           if (checkval != result->ts.tv_sec)
3142             {
3143               /* an overflow has occurred. */
3144               error (1, 0, overflowmessage, str);
3145             }
3146           return true;
3147         }
3148       else
3149         {
3150           /* Conversion from ASCII to double failed. */
3151           return false;
3152         }
3153     }
3154   else
3155     {
3156       return false;
3157     }
3158 }
3159 \f
3160 /* Insert a time predicate based on the information in ENTRY.
3161    ARGV is a pointer to the argument array.
3162    ARG_PTR is a pointer to an index into the array, incremented if
3163    all went well.
3164
3165    Return true if input is valid, false if not.
3166
3167    A new predicate node is assigned, along with an argument node
3168    obtained with malloc.
3169
3170    Used by -atime, -ctime, and -mtime parsers. */
3171
3172 static boolean
3173 parse_time (const struct parser_table* entry, char *argv[], int *arg_ptr)
3174 {
3175   struct predicate *our_pred;
3176   struct time_val tval;
3177   enum comparison_type comp;
3178   const char *timearg;
3179   const char *errmsg = "arithmetic overflow while converting %s days to a number of seconds";
3180   time_t origin;
3181
3182   if (!collect_arg(argv, arg_ptr, &timearg))
3183     return false;
3184
3185   /* Decide the origin by previewing the comparison type. */
3186   origin = options.cur_day_start;
3187
3188   if (get_comp_type(&timearg, &comp))
3189     {
3190       /* Remember, we invert the sense of the comparison, so this tests against COMP_LT instead of COMP_GT... */
3191       if (COMP_LT == tval.kind)
3192         {
3193           uintmax_t expected = origin + (DAYSECS-1);
3194           origin += (DAYSECS-1);
3195           if (origin != expected)
3196             {
3197               error(1, 0,
3198                     _("arithmetic overflow when trying to calculate the end of today"));
3199             }
3200         }
3201       /* We discard the value of comp here, as get_relative_timestamp
3202        * will set tval.kind.
3203        */
3204     }
3205
3206   if (!get_relative_timestamp(timearg, &tval, origin, DAYSECS, errmsg))
3207     return false;
3208
3209   our_pred = insert_primary (entry);
3210   our_pred->args.reftime = tval;
3211   our_pred->est_success_rate = estimate_timestamp_success_rate(tval.ts.tv_sec);
3212
3213   if (options.debug_options & DebugExpressionTree)
3214     {
3215       time_t t;
3216
3217       fprintf (stderr, "inserting %s\n", our_pred->p_name);
3218       fprintf (stderr, "    type: %s    %s  ",
3219                (tval.kind == COMP_GT) ? "gt" :
3220                ((tval.kind == COMP_LT) ? "lt" : ((tval.kind == COMP_EQ) ? "eq" : "?")),
3221                (tval.kind == COMP_GT) ? " >" :
3222                ((tval.kind == COMP_LT) ? " <" : ((tval.kind == COMP_EQ) ? ">=" : " ?")));
3223       t = our_pred->args.reftime.ts.tv_sec;
3224       fprintf (stderr, "%ju %s", (uintmax_t) our_pred->args.reftime.ts.tv_sec, ctime (&t));
3225       if (tval.kind == COMP_EQ)
3226         {
3227           t = our_pred->args.reftime.ts.tv_sec += DAYSECS;
3228           fprintf (stderr, "                 <  %ju %s",
3229                    (uintmax_t) our_pred->args.reftime.ts.tv_sec, ctime (&t));
3230           our_pred->args.reftime.ts.tv_sec -= DAYSECS;
3231         }
3232     }
3233
3234   return true;
3235 }
3236 \f
3237 /* Get the comparison type prefix (if any) from a number argument.
3238    The prefix is at *STR.
3239    Set *COMP_TYPE to the kind of comparison that is requested.
3240    Advance *STR beyond any initial comparison prefix.
3241
3242    Return true if all okay, false if input error.  */
3243 static boolean
3244 get_comp_type(const char **str, enum comparison_type *comp_type)
3245 {
3246   switch (**str)
3247     {
3248     case '+':
3249       *comp_type = COMP_GT;
3250       (*str)++;
3251       break;
3252     case '-':
3253       *comp_type = COMP_LT;
3254       (*str)++;
3255       break;
3256     default:
3257       *comp_type = COMP_EQ;
3258       break;
3259     }
3260   return true;
3261 }
3262
3263
3264
3265
3266 \f
3267 /* Get a number with comparison information.
3268    The sense of the comparison information is 'normal'; that is,
3269    '+' looks for a count > than the number and '-' less than.
3270
3271    STR is the ASCII representation of the number.
3272    Set *NUM to the number.
3273    Set *COMP_TYPE to the kind of comparison that is requested.
3274
3275    Return true if all okay, false if input error.  */
3276
3277 static boolean
3278 get_num (const char *str,
3279          uintmax_t *num,
3280          enum comparison_type *comp_type)
3281 {
3282   char *pend;
3283
3284   if (str == NULL)
3285     return false;
3286
3287   /* Figure out the comparison type if the caller accepts one. */
3288   if (comp_type)
3289     {
3290       if (!get_comp_type(&str, comp_type))
3291         return false;
3292     }
3293
3294   return xstrtoumax (str, &pend, 10, num, "") == LONGINT_OK;
3295 }
3296 \f
3297 /* Insert a number predicate.
3298    ARGV is a pointer to the argument array.
3299    *ARG_PTR is an index into ARGV, incremented if all went well.
3300    *PRED is the predicate processor to insert.
3301
3302    Return true if input is valid, false if error.
3303
3304    A new predicate node is assigned, along with an argument node
3305    obtained with malloc.
3306
3307    Used by -inum and -links parsers. */
3308
3309 static struct predicate *
3310 insert_num (char **argv, int *arg_ptr, const struct parser_table *entry)
3311 {
3312   const char *numstr;
3313
3314   if (collect_arg(argv, arg_ptr, &numstr))
3315   {
3316     uintmax_t num;
3317     enum comparison_type c_type;
3318
3319     if (get_num (numstr, &num, &c_type))
3320       {
3321         struct predicate *our_pred = insert_primary (entry);
3322         our_pred->args.numinfo.kind = c_type;
3323         our_pred->args.numinfo.l_val = num;
3324
3325         if (options.debug_options & DebugExpressionTree)
3326           {
3327             fprintf (stderr, "inserting %s\n", our_pred->p_name);
3328             fprintf (stderr, "    type: %s    %s  ",
3329                      (c_type == COMP_GT) ? "gt" :
3330                      ((c_type == COMP_LT) ? "lt" : ((c_type == COMP_EQ) ? "eq" : "?")),
3331                      (c_type == COMP_GT) ? " >" :
3332                      ((c_type == COMP_LT) ? " <" : ((c_type == COMP_EQ) ? " =" : " ?")));
3333             fprintf (stderr, "%ju\n", our_pred->args.numinfo.l_val);
3334           }
3335         return our_pred;
3336       }
3337   }
3338   return NULL;
3339 }
3340
3341 static void
3342 open_output_file (const char *path, struct format_val *p)
3343 {
3344   p->segment = NULL;
3345   p->quote_opts = clone_quoting_options (NULL);
3346
3347   if (!strcmp (path, "/dev/stderr"))
3348     {
3349       p->stream = stderr;
3350       p->filename = _("standard error");
3351     }
3352   else if (!strcmp (path, "/dev/stdout"))
3353     {
3354       p->stream = stdout;
3355       p->filename = _("standard output");
3356     }
3357   else
3358     {
3359       p->stream = fopen_safer (path, "w");
3360       p->filename = path;
3361
3362       if (p->stream == NULL)
3363         {
3364           fatal_file_error(path);
3365         }
3366     }
3367
3368   p->dest_is_tty = stream_is_tty(p->stream);
3369 }
3370
3371 static void
3372 open_stdout (struct format_val *p)
3373 {
3374   open_output_file("/dev/stdout", p);
3375 }
3376