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, 2007 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 #include <config.h>
  22
  23 #include "defs.h"
  24 #include <ctype.h>
  25 #include <math.h>
  26 #include <assert.h>
  27 #include <pwd.h>
  28 #include <errno.h>
  29 #include <grp.h>
  30 #include <fnmatch.h>
  31 #include "modechange.h"
  32 #include "modetype.h"
  33 #include "xstrtol.h"
  34 #include "xalloc.h"
  35 #include "quote.h"
  36 #include "quotearg.h"
  37 #include "buildcmd.h"
  38 #include "nextelem.h"
  39 #include "stdio-safer.h"
  40 #include "regextype.h"
  41 #include "stat-time.h"
  42 #include "xstrtod.h"
  43 #include "fts_.h"
  44 #include "getdate.h"
  45 #include "error.h"
  46 #include "gnulib-version.h"
  47
  48 #ifdef HAVE_FCNTL_H
  49 #include <fcntl.h>
  50 #else
  51 #include <sys/file.h>
  52 #endif
  53
  54 /* The presence of unistd.h is assumed by gnulib these days, so we
  55  * might as well assume it too.
  56  */
  57 /* We need <unistd.h> for isatty(). */
  58 #include <unistd.h>
  59 #include <sys/stat.h>
  60
  61 #if ENABLE_NLS
  62 # include <libintl.h>
  63 # define _(Text) gettext (Text)
  64 #else
  65 # define _(Text) Text
  66 #endif
  67 #ifdef gettext_noop
  68 # define N_(String) gettext_noop (String)
  69 #else
  70 /* See locate.c for explanation as to why not use (String) */
  71 # define N_(String) String
  72 #endif
  73
  74 #if !defined (isascii) || defined (STDC_HEADERS)
  75 #ifdef isascii
  76 #undef isascii
  77 #endif
  78 #define isascii(c) 1
  79 #endif
  80
  81 #define ISDIGIT(c) (isascii ((unsigned char)c) && isdigit ((unsigned char)c))
  82 #define ISUPPER(c) (isascii ((unsigned char)c) && isupper ((unsigned char)c))
  83
  84 #ifndef HAVE_ENDGRENT
  85 #define endgrent()
  86 #endif
  87 #ifndef HAVE_ENDPWENT
  88 #define endpwent()
  89 #endif
  90 \f
  91 static boolean parse_accesscheck   PARAMS((const struct parser_table* entry, char **argv, int *arg_ptr));
  92 static boolean parse_amin          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
  93 static boolean parse_and           PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
  94 static boolean parse_anewer        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
  95 static boolean parse_cmin          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
  96 static boolean parse_cnewer        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
  97 static boolean parse_comma         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
  98 static boolean parse_daystart      PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
  99 static boolean parse_delete        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 100 static boolean parse_d             PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 101 static boolean parse_depth         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 102 static boolean parse_empty         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 103 static boolean parse_exec          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 104 static boolean parse_execdir       PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 105 static boolean parse_false         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 106 static boolean parse_fls           PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 107 static boolean parse_fprintf       PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 108 static boolean parse_follow        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 109 static boolean parse_fprint        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 110 static boolean parse_fprint0       PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 111 static boolean parse_fstype        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 112 static boolean parse_gid           PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 113 static boolean parse_group         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 114 static boolean parse_help          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 115 static boolean parse_ilname        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 116 static boolean parse_iname         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 117 static boolean parse_inum          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 118 static boolean parse_ipath         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 119 static boolean parse_iregex        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 120 static boolean parse_iwholename    PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 121 static boolean parse_links         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 122 static boolean parse_lname         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 123 static boolean parse_ls            PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 124 static boolean parse_maxdepth      PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 125 static boolean parse_mindepth      PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 126 static boolean parse_mmin          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 127 static boolean parse_name          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 128 static boolean parse_negate        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 129 static boolean parse_newer         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 130 static boolean parse_newerXY       PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 131 static boolean parse_noleaf        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 132 static boolean parse_nogroup       PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 133 static boolean parse_nouser        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 134 static boolean parse_nowarn        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 135 static boolean parse_ok            PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 136 static boolean parse_okdir         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 137 static boolean parse_or            PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 138 static boolean parse_path          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 139 static boolean parse_perm          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 140 static boolean parse_print0        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 141 static boolean parse_printf        PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 142 static boolean parse_prune         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 143 static boolean parse_regex         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 144 static boolean parse_regextype     PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 145 static boolean parse_samefile      PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 146 #if 0
 147 static boolean parse_show_control_chars PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 148 #endif
 149 static boolean parse_size          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 150 static boolean parse_time          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 151 static boolean parse_true          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 152 static boolean parse_type          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 153 static boolean parse_uid           PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 154 static boolean parse_used          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 155 static boolean parse_user          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 156 static boolean parse_version       PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 157 static boolean parse_wholename     PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 158 static boolean parse_xdev          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 159 static boolean parse_ignore_race   PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 160 static boolean parse_noignore_race PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 161 static boolean parse_warn          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 162 static boolean parse_xtype         PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 163 static boolean parse_quit          PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 164
 165 boolean parse_print             PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 166
 167
 168 static boolean insert_type PARAMS((char **argv, int *arg_ptr, const struct parser_table *entry, PRED_FUNC which_pred));
 169 static boolean insert_regex PARAMS((char *argv[], int *arg_ptr, const struct parser_table *entry, int regex_options));
 170 static boolean insert_fprintf (struct format_val *vec,
 171                                const struct parser_table *entry,
 172                                PRED_FUNC func,
 173                                const char *format);
 174
 175 static struct segment **make_segment PARAMS((struct segment **segment, char *format, int len,
 176                                              int kind, char format_char, char aux_format_char,
 177                                              struct predicate *pred));
 178 static boolean insert_exec_ok PARAMS((const char *action, const struct parser_table *entry, int dirfd, char *argv[], int *arg_ptr));
 179 static boolean get_comp_type PARAMS((const char **str, enum comparison_type *comp_type));
 180 static boolean get_relative_timestamp PARAMS((const char *str, struct time_val *tval, time_t origin, double sec_per_unit, const char *overflowmessage));
 181 static boolean get_num PARAMS((const char *str, uintmax_t *num, enum comparison_type *comp_type));
 182 static struct predicate* insert_num PARAMS((char *argv[], int *arg_ptr, const struct parser_table *entry));
 183 static void open_output_file (const char *path, struct format_val *p);
 184 static void open_stdout (struct format_val *p);
 185 static boolean stream_is_tty(FILE *fp);
 186 static boolean parse_noop PARAMS((const struct parser_table* entry, char **argv, int *arg_ptr));
 187
 188 #define PASTE(x,y) x##y
 189 #define STRINGIFY(s) #s
 190
 191 #define PARSE_OPTION(what,suffix) \
 192   { (ARG_OPTION), (what), PASTE(parse_,suffix), NULL }
 193
 194 #define PARSE_POSOPT(what,suffix) \
 195   { (ARG_POSITIONAL_OPTION), (what), PASTE(parse_,suffix), NULL }
 196
 197 #define PARSE_TEST(what,suffix) \
 198   { (ARG_TEST), (what), PASTE(parse_,suffix), PASTE(pred_,suffix) }
 199
 200 #define PARSE_TEST_NP(what,suffix) \
 201   { (ARG_TEST), (what), PASTE(parse_,suffix), NULL }
 202
 203 #define PARSE_ACTION(what,suffix) \
 204   { (ARG_ACTION), (what), PASTE(parse_,suffix), PASTE(pred_,suffix) }
 205
 206 #define PARSE_ACTION_NP(what,suffix) \
 207   { (ARG_ACTION), (what), PASTE(parse_,suffix), NULL }
 208
 209 #define PARSE_PUNCTUATION(what,suffix) \
 210   { (ARG_PUNCTUATION), (what), PASTE(parse_,suffix), PASTE(pred_,suffix) }
 211
 212
 213 /* Predicates we cannot handle in the usual way.  If you add an entry
 214  * to this table, double-check the switch statement in
 215  * pred_sanity_check() to make sure that the new case is being
 216  * correctly handled.
 217  */
 218 static struct parser_table const parse_entry_newerXY =
 219   {
 220     ARG_SPECIAL_PARSE, "newerXY",            parse_newerXY, pred_newerXY /* BSD  */
 221   };
 222
 223 /* GNU find predicates that are not mentioned in POSIX.2 are marked `GNU'.
 224    If they are in some Unix versions of find, they are marked `Unix'. */
 225
 226 static struct parser_table const parse_table[] =
 227 {
 228   PARSE_PUNCTUATION("!",                     negate),
 229   PARSE_PUNCTUATION("not",                   negate),        /* GNU */
 230   PARSE_PUNCTUATION("(",                     openparen),
 231   PARSE_PUNCTUATION(")",                     closeparen),
 232   PARSE_PUNCTUATION(",",                     comma),         /* GNU */
 233   PARSE_PUNCTUATION("a",                     and),
 234   PARSE_TEST       ("amin",                  amin),          /* GNU */
 235   PARSE_PUNCTUATION("and",                   and),              /* GNU */
 236   PARSE_TEST       ("anewer",                anewer),        /* GNU */
 237   {ARG_TEST,       "atime",                  parse_time, pred_atime},
 238   PARSE_TEST       ("cmin",                  cmin),          /* GNU */
 239   PARSE_TEST       ("cnewer",                cnewer),        /* GNU */
 240   {ARG_TEST,       "ctime",                  parse_time, pred_ctime},
 241   PARSE_POSOPT     ("daystart",              daystart),      /* GNU */
 242   PARSE_ACTION     ("delete",                delete), /* GNU, Mac OS, FreeBSD */
 243   PARSE_OPTION     ("d",                     d), /* Mac OS X, FreeBSD, NetBSD, OpenBSD, but deprecated  in favour of -depth */
 244   PARSE_OPTION     ("depth",                 depth),
 245   PARSE_TEST       ("empty",                 empty),         /* GNU */
 246   {ARG_ACTION,      "exec",    parse_exec, pred_exec}, /* POSIX */
 247   {ARG_TEST,        "executable",            parse_accesscheck, pred_executable}, /* GNU, 4.3.0+ */
 248   PARSE_ACTION     ("execdir",               execdir), /* *BSD, GNU */
 249   PARSE_ACTION     ("fls",                   fls),           /* GNU */
 250   PARSE_POSOPT     ("follow",                follow),  /* GNU, Unix */
 251   PARSE_ACTION     ("fprint",                fprint),        /* GNU */
 252   PARSE_ACTION     ("fprint0",               fprint0),       /* GNU */
 253   {ARG_ACTION,      "fprintf", parse_fprintf, pred_fprintf}, /* GNU */
 254   PARSE_TEST       ("fstype",                fstype),  /* GNU, Unix */
 255   PARSE_TEST       ("gid",                   gid),           /* GNU */
 256   PARSE_TEST       ("group",                 group),
 257   PARSE_OPTION     ("ignore_readdir_race",   ignore_race),   /* GNU */
 258   PARSE_TEST       ("ilname",                ilname),        /* GNU */
 259   PARSE_TEST       ("iname",                 iname),         /* GNU */
 260   PARSE_TEST       ("inum",                  inum),    /* GNU, Unix */
 261   PARSE_TEST       ("ipath",                 ipath), /* GNU, deprecated in favour of iwholename */
 262   PARSE_TEST_NP    ("iregex",                iregex),        /* GNU */
 263   PARSE_TEST_NP    ("iwholename",            iwholename),    /* GNU */
 264   PARSE_TEST       ("links",                 links),
 265   PARSE_TEST       ("lname",                 lname),         /* GNU */
 266   PARSE_ACTION     ("ls",                    ls),      /* GNU, Unix */
 267   PARSE_OPTION     ("maxdepth",              maxdepth),      /* GNU */
 268   PARSE_OPTION     ("mindepth",              mindepth),      /* GNU */
 269   PARSE_TEST       ("mmin",                  mmin),          /* GNU */
 270   PARSE_OPTION     ("mount",                 xdev),         /* Unix */
 271   {ARG_TEST,       "mtime",                  parse_time, pred_mtime},
 272   PARSE_TEST       ("name",                  name),
 273 #ifdef UNIMPLEMENTED_UNIX
 274   PARSE(ARG_UNIMPLEMENTED, "ncpio",          ncpio),        /* Unix */
 275 #endif
 276   PARSE_TEST       ("newer",                 newer),
 277   {ARG_TEST,       "atime",                  parse_time, pred_atime},
 278   PARSE_OPTION     ("noleaf",                noleaf),        /* GNU */
 279   PARSE_TEST       ("nogroup",               nogroup),
 280   PARSE_TEST       ("nouser",                nouser),
 281   PARSE_OPTION     ("noignore_readdir_race", noignore_race), /* GNU */
 282   PARSE_POSOPT     ("nowarn",                nowarn),        /* GNU */
 283   PARSE_PUNCTUATION("o",                     or),
 284   PARSE_PUNCTUATION("or",                    or),            /* GNU */
 285   PARSE_ACTION     ("ok",                    ok),
 286   PARSE_ACTION     ("okdir",                 okdir), /* GNU (-execdir is BSD) */
 287   PARSE_TEST       ("path",                  path), /* GNU, HP-UX, GNU prefers wholename */
 288   PARSE_TEST       ("perm",                  perm),
 289   PARSE_ACTION     ("print",                 print),
 290   PARSE_ACTION     ("print0",                print0),        /* GNU */
 291   {ARG_ACTION,      "printf",   parse_printf, NULL},         /* GNU */
 292   PARSE_ACTION     ("prune",                 prune),
 293   PARSE_ACTION     ("quit",                  quit),          /* GNU */
 294   {ARG_TEST,       "readable",            parse_accesscheck, pred_readable}, /* GNU, 4.3.0+ */
 295   PARSE_TEST       ("regex",                 regex),         /* GNU */
 296   PARSE_OPTION     ("regextype",             regextype),     /* GNU */
 297   PARSE_TEST       ("samefile",              samefile),      /* GNU */
 298 #if 0
 299   PARSE_OPTION     ("show-control-chars",    show_control_chars), /* GNU, 4.3.0+ */
 300 #endif
 301   PARSE_TEST       ("size",                  size),
 302   PARSE_TEST       ("type",                  type),
 303   PARSE_TEST       ("uid",                   uid),           /* GNU */
 304   PARSE_TEST       ("used",                  used),          /* GNU */
 305   PARSE_TEST       ("user",                  user),
 306   PARSE_OPTION     ("warn",                  warn),          /* GNU */
 307   PARSE_TEST_NP    ("wholename",             wholename), /* GNU, replaces -path */
 308   {ARG_TEST,       "writable",               parse_accesscheck, pred_writable}, /* GNU, 4.3.0+ */
 309   PARSE_OPTION     ("xdev",                  xdev),
 310   PARSE_TEST       ("xtype",                 xtype),         /* GNU */
 311 #ifdef UNIMPLEMENTED_UNIX
 312   /* It's pretty ugly for find to know about archive formats.
 313      Plus what it could do with cpio archives is very limited.
 314      Better to leave it out.  */
 315   PARSE(ARG_UNIMPLEMENTED,      "cpio",                  cpio), /* Unix */
 316 #endif
 317   /* gnulib's stdbool.h might have made true and false into macros,
 318    * so we can't leave named 'true' and 'false' tokens, so we have
 319    * to expeant the relevant entries longhand.
 320    */
 321   {ARG_TEST, "false",                 parse_false,   pred_false}, /* GNU */
 322   {ARG_TEST, "true",                  parse_true,    pred_true }, /* GNU */
 323   {ARG_NOOP, "noop",                  NULL,          pred_true }, /* GNU, internal use only */
 324
 325   /* Various other cases that don't fit neatly into our macro scheme. */
 326   {ARG_TEST, "help",                  parse_help,    NULL},       /* GNU */
 327   {ARG_TEST, "-help",                 parse_help,    NULL},       /* GNU */
 328   {ARG_TEST, "version",               parse_version, NULL},       /* GNU */
 329   {ARG_TEST, "-version",              parse_version, NULL},       /* GNU */
 330   {0, 0, 0, 0}
 331 };
 332 \f
 333
 334 static const char *first_nonoption_arg = NULL;
 335 static const struct parser_table *noop = NULL;
 336
 337
 338 static const struct parser_table*
 339 get_noop(void)
 340 {
 341   int i;
 342   if (NULL == noop)
 343     {
 344       for (i = 0; parse_table[i].parser_name != 0; i++)
 345         {
 346           if (ARG_NOOP ==parse_table[i].type)
 347             {
 348               noop = &(parse_table[i]);
 349               break;
 350             }
 351         }
 352     }
 353   return noop;
 354 }
 355 \f
 356 static int
 357 get_stat_Ytime(const struct stat *p,
 358                char what,
 359                struct timespec *ret)
 360 {
 361   switch (what)
 362     {
 363     case 'a':
 364       *ret = get_stat_atime(p);
 365       return 1;
 366     case 'B':
 367       *ret = get_stat_birthtime(p);
 368       return (ret->tv_nsec >= 0);
 369     case 'c':
 370       *ret = get_stat_ctime(p);
 371       return 1;
 372     case 'm':
 373       *ret = get_stat_mtime(p);
 374       return 1;
 375     default:
 376       assert (0);
 377       abort();
 378     }
 379 }
 380 \f
 381 void
 382 set_follow_state(enum SymlinkOption opt)
 383 {
 384   if (options.debug_options & DebugStat)
 385     {
 386       /* For DebugStat, the choice is made at runtime within debug_stat()
 387        * by checking the contents of the symlink_handling variable.
 388        */
 389       options.xstat = debug_stat;
 390     }
 391   else
 392     {
 393       switch (opt)
 394         {
 395         case SYMLINK_ALWAYS_DEREF:  /* -L */
 396           options.xstat = optionl_stat;
 397           options.no_leaf_check = true;
 398           break;
 399
 400         case SYMLINK_NEVER_DEREF:       /* -P (default) */
 401           options.xstat = optionp_stat;
 402           /* Can't turn no_leaf_check off because the user might have specified
 403            * -noleaf anyway
 404            */
 405           break;
 406
 407         case SYMLINK_DEREF_ARGSONLY: /* -H */
 408           options.xstat = optionh_stat;
 409           options.no_leaf_check = true;
 410         }
 411     }
 412   options.symlink_handling = opt;
 413 }
 414
 415
 416 void
 417 parse_begin_user_args (char **args, int argno, const struct predicate *last, const struct predicate *predicates)
 418 {
 419   (void) args;
 420   (void) argno;
 421   (void) last;
 422   (void) predicates;
 423   first_nonoption_arg = NULL;
 424 }
 425
 426 void
 427 parse_end_user_args (char **args, int argno, const struct predicate *last, const struct predicate *predicates)
 428 {
 429   /* does nothing */
 430   (void) args;
 431   (void) argno;
 432   (void) last;
 433   (void) predicates;
 434 }
 435
 436
 437 /* Check that it is legal to fid the given primary in its
 438  * position and return it.
 439  */
 440 const struct parser_table*
 441 found_parser(const char *original_arg, const struct parser_table *entry)
 442 {
 443   /* If this is an option, but we have already had a
 444    * non-option argument, the user may be under the
 445    * impression that the behaviour of the option
 446    * argument is conditional on some preceding
 447    * tests.  This might typically be the case with,
 448    * for example, -maxdepth.
 449    *
 450    * The options -daystart and -follow are exempt
 451    * from this treatment, since their positioning
 452    * in the command line does have an effect on
 453    * subsequent tests but not previous ones.  That
 454    * might be intentional on the part of the user.
 455    */
 456   if (entry->type != ARG_POSITIONAL_OPTION)
 457     {
 458       /* Something other than -follow/-daystart.
 459        * If this is an option, check if it followed
 460        * a non-option and if so, issue a warning.
 461        */
 462       if (entry->type == ARG_OPTION)
 463         {
 464           if ((first_nonoption_arg != NULL)
 465               && options.warnings )
 466             {
 467               /* option which follows a non-option */
 468               error (0, 0,
 469                      _("warning: you have specified the %s "
 470                        "option after a non-option argument %s, "
 471                        "but options are not positional (%s affects "
 472                        "tests specified before it as well as those "
 473                        "specified after it).  Please specify options "
 474                        "before other arguments.\n"),
 475                      original_arg,
 476                      first_nonoption_arg,
 477                      original_arg);
 478             }
 479         }
 480       else
 481         {
 482           /* Not an option or a positional option,
 483            * so remember we've seen it in order to
 484            * use it in a possible future warning message.
 485            */
 486           if (first_nonoption_arg == NULL)
 487             {
 488               first_nonoption_arg = original_arg;
 489             }
 490         }
 491     }
 492
 493   return entry;
 494 }
 495
 496
 497 /* Return a pointer to the parser function to invoke for predicate
 498    SEARCH_NAME.
 499    Return NULL if SEARCH_NAME is not a valid predicate name. */
 500
 501 const struct parser_table*
 502 find_parser (char *search_name)
 503 {
 504   int i;
 505   const char *original_arg = search_name;
 506
 507   /* Ugh.  Special case -newerXY. */
 508   if (0 == strncmp("-newer", search_name, 6)
 509       && (8 == strlen(search_name)))
 510     {
 511       return found_parser(original_arg, &parse_entry_newerXY);
 512     }
 513
 514   if (*search_name == '-')
 515     search_name++;
 516
 517   for (i = 0; parse_table[i].parser_name != 0; i++)
 518     {
 519       if (strcmp (parse_table[i].parser_name, search_name) == 0)
 520         {
 521           return found_parser(original_arg, &parse_table[i]);
 522         }
 523     }
 524   return NULL;
 525 }
 526 \f
 527 static float
 528 estimate_file_age_success_rate(float num_days)
 529 {
 530   if (num_days < 0.1)
 531     {
 532       /* Assume 1% of files have timestamps in the future */
 533       return 0.01f;
 534     }
 535   else if (num_days < 1)
 536     {
 537       /* Assume 30% of files have timestamps today */
 538       return 0.3f;
 539     }
 540   else if (num_days > 100)
 541     {
 542       /* Assume 30% of files are very old */
 543       return 0.3f;
 544     }
 545   else
 546     {
 547       /* Assume 39% of files are between 1 and 100 days old. */
 548       return 0.39f;
 549     }
 550 }
 551 \f
 552 static float
 553 estimate_timestamp_success_rate(time_t when)
 554 {
 555   int num_days = (options.cur_day_start - when) / 86400;
 556   return estimate_file_age_success_rate(num_days);
 557 }
 558
 559 /* Collect an argument from the argument list, or
 560  * return false.
 561  */
 562 static boolean
 563 collect_arg(char **argv, int *arg_ptr, const char **collected_arg)
 564 {
 565   if ((argv == NULL) || (argv[*arg_ptr] == NULL))
 566     {
 567       *collected_arg = NULL;
 568       return false;
 569     }
 570   else
 571     {
 572       *collected_arg = argv[*arg_ptr];
 573       (*arg_ptr)++;
 574       return true;
 575     }
 576 }
 577
 578 static boolean
 579 collect_arg_stat_info(char **argv, int *arg_ptr, struct stat *p)
 580 {
 581   const char *filename;
 582   if (collect_arg(argv, arg_ptr, &filename))
 583     {
 584       if (0 == (options.xstat)(filename, p))
 585         {
 586           return true;
 587         }
 588       else
 589         {
 590           fatal_file_error(filename);
 591         }
 592     }
 593   else
 594     {
 595       return false;
 596     }
 597 }
 598
 599 /* The parsers are responsible to continue scanning ARGV for
 600    their arguments.  Each parser knows what is and isn't
 601    allowed for itself.
 602
 603    ARGV is the argument array.
 604    *ARG_PTR is the index to start at in ARGV,
 605    updated to point beyond the last element consumed.
 606
 607    The predicate structure is updated with the new information. */
 608
 609 \f
 610 static boolean
 611 parse_and (const struct parser_table* entry, char **argv, int *arg_ptr)
 612 {
 613   struct predicate *our_pred;
 614
 615   (void) argv;
 616   (void) arg_ptr;
 617
 618   our_pred = get_new_pred (entry);
 619   our_pred->pred_func = pred_and;
 620   our_pred->p_type = BI_OP;
 621   our_pred->p_prec = AND_PREC;
 622   our_pred->need_stat = our_pred->need_type = false;
 623   return true;
 624 }
 625
 626 static boolean
 627 parse_anewer (const struct parser_table* entry, char **argv, int *arg_ptr)
 628 {
 629   struct stat stat_newer;
 630
 631   set_stat_placeholders(&stat_newer);
 632   if (collect_arg_stat_info(argv, arg_ptr, &stat_newer))
 633     {
 634       struct predicate *our_pred = insert_primary (entry);
 635       our_pred->args.reftime.xval = XVAL_ATIME;
 636       our_pred->args.reftime.ts = get_stat_mtime(&stat_newer);
 637       our_pred->args.reftime.kind = COMP_GT;
 638       our_pred->est_success_rate = estimate_timestamp_success_rate(stat_newer.st_mtime);
 639       return true;
 640     }
 641   return false;
 642 }
 643
 644 boolean
 645 parse_closeparen (const struct parser_table* entry, char **argv, int *arg_ptr)
 646 {
 647   struct predicate *our_pred;
 648
 649   (void) argv;
 650   (void) arg_ptr;
 651
 652   our_pred = get_new_pred (entry);
 653   our_pred->pred_func = pred_closeparen;
 654   our_pred->p_type = CLOSE_PAREN;
 655   our_pred->p_prec = NO_PREC;
 656   our_pred->need_stat = our_pred->need_type = false;
 657   return true;
 658 }
 659
 660 static boolean
 661 parse_cnewer (const struct parser_table* entry, char **argv, int *arg_ptr)
 662 {
 663   struct stat stat_newer;
 664
 665   set_stat_placeholders(&stat_newer);
 666   if (collect_arg_stat_info(argv, arg_ptr, &stat_newer))
 667     {
 668       struct predicate *our_pred = insert_primary (entry);
 669       our_pred->args.reftime.xval = XVAL_CTIME; /* like -newercm */
 670       our_pred->args.reftime.ts = get_stat_mtime(&stat_newer);
 671       our_pred->args.reftime.kind = COMP_GT;
 672       our_pred->est_success_rate = estimate_timestamp_success_rate(stat_newer.st_mtime);
 673       return true;
 674     }
 675   return false;
 676 }
 677
 678 static boolean
 679 parse_comma (const struct parser_table* entry, char **argv, int *arg_ptr)
 680 {
 681   struct predicate *our_pred;
 682
 683   (void) argv;
 684   (void) arg_ptr;
 685
 686   our_pred = get_new_pred (entry);
 687   our_pred->pred_func = pred_comma;
 688   our_pred->p_type = BI_OP;
 689   our_pred->p_prec = COMMA_PREC;
 690   our_pred->need_stat = our_pred->need_type = false;
 691   our_pred->est_success_rate = 1.0f;
 692   return true;
 693 }
 694
 695 static boolean
 696 parse_daystart (const struct parser_table* entry, char **argv, int *arg_ptr)
 697 {
 698   struct tm *local;
 699
 700   (void) entry;
 701   (void) argv;
 702   (void) arg_ptr;
 703
 704   if (options.full_days == false)
 705     {
 706       options.cur_day_start += DAYSECS;
 707       local = localtime (&options.cur_day_start);
 708       options.cur_day_start -= (local
 709                         ? (local->tm_sec + local->tm_min * 60
 710                            + local->tm_hour * 3600)
 711                         : options.cur_day_start % DAYSECS);
 712       options.full_days = true;
 713     }
 714   return true;
 715 }
 716
 717 static boolean
 718 parse_delete (const struct parser_table* entry, char *argv[], int *arg_ptr)
 719 {
 720   struct predicate *our_pred;
 721   (void) argv;
 722   (void) arg_ptr;
 723
 724   our_pred = insert_primary (entry);
 725   our_pred->side_effects = our_pred->no_default_print = true;
 726   /* -delete implies -depth */
 727   options.do_dir_first = false;
 728
 729   /* We do not need stat information because we check for the case
 730    * (errno==EISDIR) in pred_delete.
 731    */
 732   our_pred->need_stat = our_pred->need_type = false;
 733
 734   our_pred->est_success_rate = 1.0f;
 735   return true;
 736 }
 737
 738 static boolean
 739 parse_depth (const struct parser_table* entry, char **argv, int *arg_ptr)
 740 {
 741   (void) entry;
 742   (void) argv;
 743
 744   options.do_dir_first = false;
 745   return parse_noop(entry, argv, arg_ptr);
 746 }
 747
 748 static boolean
 749 parse_d (const struct parser_table* entry, char **argv, int *arg_ptr)
 750 {
 751   if (options.warnings)
 752     {
 753       error (0, 0,
 754              _("warning: the -d option is deprecated; please use -depth instead, because the latter is a POSIX-compliant feature."));
 755     }
 756   return parse_depth(entry, argv, arg_ptr);
 757 }
 758
 759 static boolean
 760 parse_empty (const struct parser_table* entry, char **argv, int *arg_ptr)
 761 {
 762   struct predicate *our_pred;
 763   (void) argv;
 764   (void) arg_ptr;
 765
 766   our_pred = insert_primary (entry);
 767   our_pred->est_success_rate = 0.01f; /* assume 1% of files are empty. */
 768   return true;
 769 }
 770
 771 static boolean
 772 parse_exec (const struct parser_table* entry, char **argv, int *arg_ptr)
 773 {
 774   return insert_exec_ok ("-exec", entry, get_start_dirfd(), argv, arg_ptr);
 775 }
 776
 777 static boolean
 778 parse_execdir (const struct parser_table* entry, char **argv, int *arg_ptr)
 779 {
 780   return insert_exec_ok ("-execdir", entry, -1, argv, arg_ptr);
 781 }
 782
 783 static boolean
 784 parse_false (const struct parser_table* entry, char **argv, int *arg_ptr)
 785 {
 786   struct predicate *our_pred;
 787
 788   (void) argv;
 789   (void) arg_ptr;
 790
 791   our_pred = insert_primary (entry);
 792   our_pred->need_stat = our_pred->need_type = false;
 793   our_pred->side_effects = our_pred->no_default_print = false;
 794   our_pred->est_success_rate = 0.0f;
 795   return true;
 796 }
 797
 798 static boolean
 799 insert_fls (const struct parser_table* entry, const char *filename)
 800 {
 801   struct predicate *our_pred = insert_primary (entry);
 802   if (filename)
 803     open_output_file (filename, &our_pred->args.printf_vec);
 804   else
 805     open_stdout (&our_pred->args.printf_vec);
 806   our_pred->side_effects = our_pred->no_default_print = true;
 807   our_pred->est_success_rate = 1.0f;
 808   return true;
 809 }
 810
 811
 812 static boolean
 813 parse_fls (const struct parser_table* entry, char **argv, int *arg_ptr)
 814 {
 815   const char *filename;
 816   return collect_arg(argv, arg_ptr, &filename)
 817     &&  insert_fls(entry, filename);
 818 }
 819
 820 static boolean
 821 parse_follow (const struct parser_table* entry, char **argv, int *arg_ptr)
 822 {
 823   set_follow_state(SYMLINK_ALWAYS_DEREF);
 824   return parse_noop(entry, argv, arg_ptr);
 825 }
 826
 827 static boolean
 828 parse_fprint (const struct parser_table* entry, char **argv, int *arg_ptr)
 829 {
 830   struct predicate *our_pred;
 831   const char *filename;
 832   if (collect_arg(argv, arg_ptr, &filename))
 833     {
 834       our_pred = insert_primary (entry);
 835       open_output_file (filename, &our_pred->args.printf_vec);
 836       our_pred->side_effects = our_pred->no_default_print = true;
 837       our_pred->need_stat = our_pred->need_type = false;
 838       our_pred->est_success_rate = 1.0f;
 839       return true;
 840     }
 841   else
 842     {
 843       return false;
 844     }
 845 }
 846
 847 static boolean
 848 insert_fprint(const struct parser_table* entry, const char *filename)
 849 {
 850   struct predicate *our_pred = insert_primary (entry);
 851   if (filename)
 852     open_output_file (filename, &our_pred->args.printf_vec);
 853   else
 854     open_stdout (&our_pred->args.printf_vec);
 855   our_pred->side_effects = our_pred->no_default_print = true;
 856   our_pred->need_stat = our_pred->need_type = false;
 857   our_pred->est_success_rate = 1.0f;
 858   return true;
 859 }
 860
 861
 862 static boolean
 863 parse_fprint0 (const struct parser_table* entry, char **argv, int *arg_ptr)
 864 {
 865   const char *filename;
 866   if (collect_arg(argv, arg_ptr, &filename))
 867     return insert_fprint(entry, filename);
 868   else
 869     return false;
 870 }
 871
 872 static float estimate_fstype_success_rate(const char *fsname)
 873 {
 874   struct stat dir_stat;
 875   const char *dir = "/";
 876   if (0 == stat(dir, &dir_stat))
 877     {
 878       const char *fstype = filesystem_type(&dir_stat, dir);
 879       /* Assume most files are on the same file system type as the root fs. */
 880       if (0 == strcmp(fsname, fstype))
 881           return 0.7f;
 882       else
 883         return 0.3f;
 884     }
 885   return 1.0f;
 886 }
 887
 888
 889 static boolean
 890 parse_fstype (const struct parser_table* entry, char **argv, int *arg_ptr)
 891 {
 892   const char *typename;
 893   if (collect_arg(argv, arg_ptr, &typename))
 894     {
 895       struct predicate *our_pred = insert_primary (entry);
 896       our_pred->args.str = typename;
 897
 898       /* This is an expensive operation, so although there are
 899        * circumstances where it is selective, we ignore this fact
 900        * because we probably don't want to promote this test to the
 901        * front anyway.
 902        */
 903       our_pred->est_success_rate = estimate_fstype_success_rate(typename);
 904       return true;
 905     }
 906   else
 907     {
 908       return false;
 909     }
 910 }
 911
 912 static boolean
 913 parse_gid (const struct parser_table* entry, char **argv, int *arg_ptr)
 914 {
 915   struct predicate *p = insert_num (argv, arg_ptr, entry);
 916   if (p)
 917     {
 918       p->est_success_rate = (p->args.numinfo.l_val < 100) ? 0.99 : 0.2;
 919       return true;
 920     }
 921   else
 922     {
 923       return false;
 924     }
 925 }
 926
 927
 928 static int
 929 safe_atoi (const char *s)
 930 {
 931   long lval;
 932   char *end;
 933
 934   errno = 0;
 935   lval = strtol(s, &end, 10);
 936   if ( (LONG_MAX == lval) || (LONG_MIN == lval) )
 937     {
 938       /* max/min possible value, or an error. */
 939       if (errno == ERANGE)
 940         {
 941           /* too big, or too small. */
 942           error(1, errno, "%s", s);
 943         }
 944       else
 945         {
 946           /* not a valid number */
 947           error(1, errno, "%s", s);
 948         }
 949       /* Otherwise, we do a range chack against INT_MAX and INT_MIN
 950        * below.
 951        */
 952     }
 953
 954   if (lval > INT_MAX || lval < INT_MIN)
 955     {
 956       /* The number was in range for long, but not int. */
 957       errno = ERANGE;
 958       error(1, errno, "%s", s);
 959     }
 960   else if (*end)
 961     {
 962       error(1, errno, "Unexpected suffix %s on %s",
 963             quotearg_n_style(0, options.err_quoting_style, end),
 964             quotearg_n_style(1, options.err_quoting_style, s));
 965     }
 966   else if (end == s)
 967     {
 968       error(1, errno, "Expected an integer: %s",
 969             quotearg_n_style(0, options.err_quoting_style, s));
 970     }
 971   return (int)lval;
 972 }
 973
 974
 975 static boolean
 976 parse_group (const struct parser_table* entry, char **argv, int *arg_ptr)
 977 {
 978   const char *groupname;
 979
 980   if (collect_arg(argv, arg_ptr, &groupname))
 981     {
 982       gid_t gid;
 983       struct predicate *our_pred;
 984       struct group *cur_gr = getgrnam(groupname);
 985       endgrent();
 986       if (cur_gr)
 987         {
 988           gid = cur_gr->gr_gid;
 989         }
 990       else
 991         {
 992           const int gid_len = strspn (groupname, "0123456789");
 993           if (gid_len)
 994             {
 995               if (groupname[gid_len] == 0)
 996                 {
 997                   gid = safe_atoi (groupname);
 998                 }
 999               else
1000                 {
1001                   /* XXX: no test in test suite for this */
1002                   error(1, 0, _("%s is not the name of an existing group and"
1003                                 " it does not look like a numeric group ID "
1004                                 "because it has the unexpected suffix %s"),
1005                         quotearg_n_style(0, options.err_quoting_style, groupname),
1006                         quotearg_n_style(1, options.err_quoting_style, groupname+gid_len));
1007                   return false;
1008                 }
1009             }
1010           else
1011             {
1012               if (*groupname)
1013                 {
1014                   /* XXX: no test in test suite for this */
1015                   error(1, 0, _("%s is not the name of an existing group"),
1016                         quotearg_n_style(0, options.err_quoting_style, groupname));
1017                 }
1018               else
1019                 {
1020                   error(1, 0, _("argument to -group is empty, but should be a group name"));
1021                 }
1022               return false;
1023             }
1024         }
1025       our_pred = insert_primary (entry);
1026       our_pred->args.gid = gid;
1027       our_pred->est_success_rate = (our_pred->args.numinfo.l_val < 100) ? 0.99 : 0.2;
1028       return true;
1029     }
1030   return false;
1031 }
1032
1033 static boolean
1034 parse_help (const struct parser_table* entry, char **argv, int *arg_ptr)
1035 {
1036   (void) entry;
1037   (void) argv;
1038   (void) arg_ptr;
1039
1040   usage(stdout, 0, NULL);
1041   puts (_("\n\
1042 default path is the current directory; default expression is -print\n\
1043 expression may consist of: operators, options, tests, and actions:\n"));
1044   puts (_("\
1045 operators (decreasing precedence; -and is implicit where no others are given):\n\
1046       ( EXPR )   ! EXPR   -not EXPR   EXPR1 -a EXPR2   EXPR1 -and EXPR2\n\
1047       EXPR1 -o EXPR2   EXPR1 -or EXPR2   EXPR1 , EXPR2\n"));
1048   puts (_("\
1049 positional options (always true): -daystart -follow -regextype\n\n\
1050 normal options (always true, specified before other expressions):\n\
1051       -depth --help -maxdepth LEVELS -mindepth LEVELS -mount -noleaf\n\
1052       --version -xdev -ignore_readdir_race -noignore_readdir_race\n"));
1053   puts (_("\
1054 tests (N can be +N or -N or N): -amin N -anewer FILE -atime N -cmin N\n\
1055       -cnewer FILE -ctime N -empty -false -fstype TYPE -gid N -group NAME\n\
1056       -ilname PATTERN -iname PATTERN -inum N -iwholename PATTERN -iregex PATTERN\n\
1057       -links N -lname PATTERN -mmin N -mtime N -name PATTERN -newer FILE"));
1058   puts (_("\
1059       -nouser -nogroup -path PATTERN -perm [+-]MODE -regex PATTERN\n\
1060       -readable -writable -executable\n\
1061       -wholename PATTERN -size N[bcwkMG] -true -type [bcdpflsD] -uid N\n\
1062       -used N -user NAME -xtype [bcdpfls]\n"));
1063   puts (_("\
1064 actions: -delete -print0 -printf FORMAT -fprintf FILE FORMAT -print \n\
1065       -fprint0 FILE -fprint FILE -ls -fls FILE -prune -quit\n\
1066       -exec COMMAND ; -exec COMMAND {} + -ok COMMAND ;\n\
1067       -execdir COMMAND ; -execdir COMMAND {} + -okdir COMMAND ;\n\
1068 "));
1069   puts (_("Report (and track progress on fixing) bugs via the findutils bug-reporting\n\
1070 page at http://savannah.gnu.org/ or, if you have no web access, by sending\n\
1071 email to <bug-findutils@gnu.org>."));
1072   exit (0);
1073 }
1074
1075 static float
1076 estimate_pattern_match_rate(const char *pattern, int is_regex)
1077 {
1078   if (strpbrk(pattern, "*?[") || (is_regex && strpbrk(pattern, ".")))
1079     {
1080       /* A wildcard; assume the pattern matches most files. */
1081       return 0.8f;
1082     }
1083   else
1084     {
1085       return 0.1f;
1086     }
1087 }
1088
1089 static boolean
1090 parse_ilname (const struct parser_table* entry, char **argv, int *arg_ptr)
1091 {
1092   const char *name;
1093   if (collect_arg(argv, arg_ptr, &name))
1094     {
1095       struct predicate *our_pred = insert_primary (entry);
1096       our_pred->args.str = name;
1097       /* Use the generic glob pattern estimator to figure out how many
1098        * links will match, but bear in mind that most files won't be links.
1099        */
1100       our_pred->est_success_rate = 0.1 * estimate_pattern_match_rate(name, 0);
1101       return true;
1102     }
1103   else
1104     {
1105       return false;
1106     }
1107 }
1108
1109
1110 /* sanity check the fnmatch() function to make sure that case folding
1111  * is supported (as opposed to just having the flag ignored).
1112  */
1113 static boolean
1114 fnmatch_sanitycheck(void)
1115 {
1116   static boolean checked = false;
1117   if (!checked)
1118     {
1119       if (0 != fnmatch("foo", "foo", 0)
1120           || 0 == fnmatch("Foo", "foo", 0)
1121           || 0 != fnmatch("Foo", "foo", FNM_CASEFOLD))
1122         {
1123           error (1, 0, _("sanity check of the fnmatch() library function failed."));
1124           return false;
1125         }
1126       checked = true;
1127     }
1128   return checked;
1129 }
1130
1131
1132 static boolean
1133 check_name_arg(const char *pred, const char *arg)
1134 {
1135   if (strchr(arg, '/'))
1136     {
1137       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'."),
1138             pred,
1139             safely_quote_err_filename(0, arg),
1140             safely_quote_err_filename(1, arg));
1141     }
1142   return true;                  /* allow it anyway */
1143 }
1144
1145
1146
1147 static boolean
1148 parse_iname (const struct parser_table* entry, char **argv, int *arg_ptr)
1149 {
1150   const char *name;
1151   fnmatch_sanitycheck();
1152   if (collect_arg(argv, arg_ptr, &name))
1153     {
1154       if (check_name_arg("-iname", name))
1155         {
1156           struct predicate *our_pred = insert_primary (entry);
1157           our_pred->need_stat = our_pred->need_type = false;
1158           our_pred->args.str = name;
1159           our_pred->est_success_rate = estimate_pattern_match_rate(name, 0);
1160           return true;
1161         }
1162     }
1163   return false;
1164 }
1165
1166 static boolean
1167 parse_inum (const struct parser_table* entry, char **argv, int *arg_ptr)
1168 {
1169   struct predicate *p =  insert_num (argv, arg_ptr, entry);
1170   if (p)
1171     {
1172       /* inode number is exact match only, so very low proportions of
1173        * files match
1174        */
1175       p->est_success_rate = 1e-6;
1176       return true;
1177     }
1178   else
1179     {
1180       return false;
1181     }
1182 }
1183
1184 /* -ipath is deprecated (at RMS's request) in favour of
1185  * -iwholename.   See the node "GNU Manuals" in standards.texi
1186  * for the rationale for this (basically, GNU prefers the use
1187  * of the phrase "file name" to "path name"
1188  */
1189 static boolean
1190 parse_ipath (const struct parser_table* entry, char **argv, int *arg_ptr)
1191 {
1192   error (0, 0,
1193          _("warning: the predicate -ipath is deprecated; please use -iwholename instead."));
1194
1195   return parse_iwholename(entry, argv, arg_ptr);
1196 }
1197
1198 static boolean
1199 parse_iwholename (const struct parser_table* entry, char **argv, int *arg_ptr)
1200 {
1201   const char *name;
1202
1203   fnmatch_sanitycheck();
1204   if (collect_arg(argv, arg_ptr, &name))
1205     {
1206       struct predicate *our_pred = insert_primary_withpred (entry, pred_ipath);
1207       our_pred->need_stat = our_pred->need_type = false;
1208       our_pred->args.str = name;
1209       our_pred->est_success_rate = estimate_pattern_match_rate(name, 0);
1210       return true;
1211     }
1212   return false;
1213 }
1214
1215 static boolean
1216 parse_iregex (const struct parser_table* entry, char **argv, int *arg_ptr)
1217 {
1218   return insert_regex (argv, arg_ptr, entry, RE_ICASE|options.regex_options);
1219 }
1220
1221 static boolean
1222 parse_links (const struct parser_table* entry, char **argv, int *arg_ptr)
1223 {
1224   struct predicate *p = insert_num (argv, arg_ptr, entry);
1225   if (p)
1226     {
1227       if (p->args.numinfo.l_val == 1)
1228         p->est_success_rate = 0.99;
1229       else if (p->args.numinfo.l_val == 2)
1230         p->est_success_rate = 0.01;
1231       else
1232         p->est_success_rate = 1e-3;
1233       return true;
1234     }
1235   else
1236     {
1237       return false;
1238     }
1239 }
1240
1241 static boolean
1242 parse_lname (const struct parser_table* entry, char **argv, int *arg_ptr)
1243 {
1244   const char *name;
1245   fnmatch_sanitycheck();
1246   if (collect_arg(argv, arg_ptr, &name))
1247     {
1248       struct predicate *our_pred = insert_primary (entry);
1249       our_pred->args.str = name;
1250       our_pred->est_success_rate = 0.1 * estimate_pattern_match_rate(name, 0);
1251       return true;
1252     }
1253   return false;
1254 }
1255
1256 static boolean
1257 parse_ls (const struct parser_table* entry, char **argv, int *arg_ptr)
1258 {
1259   (void) &argv;
1260   (void) &arg_ptr;
1261   return insert_fls(entry, NULL);
1262 }
1263
1264 static boolean
1265 insert_depthspec(const struct parser_table* entry, char **argv, int *arg_ptr,
1266                  int *limitptr)
1267 {
1268   const char *depthstr;
1269   int depth_len;
1270   const char *predicate = argv[(*arg_ptr)-1];
1271   if (collect_arg(argv, arg_ptr, &depthstr))
1272     {
1273       depth_len = strspn (depthstr, "0123456789");
1274       if ((depth_len > 0) && (depthstr[depth_len] == 0))
1275         {
1276           (*limitptr) = safe_atoi (depthstr);
1277           if (*limitptr >= 0)
1278             {
1279               return parse_noop(entry, argv, arg_ptr);
1280             }
1281         }
1282       error(1, 0, _("Expected a positive decimal integer argument to %s, but got %s"),
1283             predicate,
1284             quotearg_n_style(0, options.err_quoting_style, depthstr));
1285       return false;
1286     }
1287   /* missing argument */
1288   return false;
1289 }
1290
1291
1292 static boolean
1293 parse_maxdepth (const struct parser_table* entry, char **argv, int *arg_ptr)
1294 {
1295   return insert_depthspec(entry, argv, arg_ptr, &options.maxdepth);
1296 }
1297
1298 static boolean
1299 parse_mindepth (const struct parser_table* entry, char **argv, int *arg_ptr)
1300 {
1301   return insert_depthspec(entry, argv, arg_ptr, &options.mindepth);
1302 }
1303 \f
1304
1305 static boolean
1306 do_parse_xmin (const struct parser_table* entry, char **argv, int *arg_ptr, enum xval xv)
1307 {
1308   const char *minutes;
1309
1310   if (collect_arg(argv, arg_ptr, &minutes))
1311     {
1312       struct time_val tval;
1313       tval.xval = xv;
1314       if (get_relative_timestamp(minutes, &tval,
1315                                  options.cur_day_start + DAYSECS, 60,
1316                                  "arithmetic overflow while converting %s "
1317                                  "minutes to a number of seconds"))
1318         {
1319           struct predicate *our_pred = insert_primary (entry);
1320           our_pred->args.reftime = tval;
1321           our_pred->est_success_rate = estimate_timestamp_success_rate(tval.ts.tv_sec);
1322           return true;
1323         }
1324     }
1325   return false;
1326 }
1327 static boolean
1328 parse_amin (const struct parser_table* entry, char **argv, int *arg_ptr)
1329 {
1330   return do_parse_xmin(entry, argv, arg_ptr, XVAL_ATIME);
1331 }
1332 \f
1333 static boolean
1334 parse_cmin (const struct parser_table* entry, char **argv, int *arg_ptr)
1335 {
1336   return do_parse_xmin(entry, argv, arg_ptr, XVAL_CTIME);
1337 }
1338
1339 \f
1340 static boolean
1341 parse_mmin (const struct parser_table* entry, char **argv, int *arg_ptr)
1342 {
1343   return do_parse_xmin(entry, argv, arg_ptr, XVAL_MTIME);
1344 }
1345
1346 static boolean
1347 parse_name (const struct parser_table* entry, char **argv, int *arg_ptr)
1348 {
1349   const char *name;
1350   if (collect_arg(argv, arg_ptr, &name))
1351     {
1352       fnmatch_sanitycheck();
1353       if (check_name_arg("-name", name))
1354         {
1355           struct predicate *our_pred = insert_primary (entry);
1356           our_pred->need_stat = our_pred->need_type = false;
1357           our_pred->args.str = name;
1358           our_pred->est_success_rate = estimate_pattern_match_rate(name, 0);
1359           return true;
1360         }
1361     }
1362   return false;
1363 }
1364
1365 static boolean
1366 parse_negate (const struct parser_table* entry, char **argv, int *arg_ptr)
1367 {
1368   struct predicate *our_pred;
1369
1370   (void) &argv;
1371   (void) &arg_ptr;
1372
1373   our_pred = get_new_pred_chk_op (entry);
1374   our_pred->pred_func = pred_negate;
1375   our_pred->p_type = UNI_OP;
1376   our_pred->p_prec = NEGATE_PREC;
1377   our_pred->need_stat = our_pred->need_type = false;
1378   return true;
1379 }
1380
1381 static boolean
1382 parse_newer (const struct parser_table* entry, char **argv, int *arg_ptr)
1383 {
1384   struct predicate *our_pred;
1385   struct stat stat_newer;
1386
1387   set_stat_placeholders(&stat_newer);
1388   if (collect_arg_stat_info(argv, arg_ptr, &stat_newer))
1389     {
1390       our_pred = insert_primary (entry);
1391       our_pred->args.reftime.ts = get_stat_mtime(&stat_newer);
1392       our_pred->args.reftime.xval = XVAL_MTIME;
1393       our_pred->args.reftime.kind = COMP_GT;
1394       our_pred->est_success_rate = estimate_timestamp_success_rate(stat_newer.st_mtime);
1395       return true;
1396     }
1397   return false;
1398 }
1399
1400
1401 static boolean
1402 parse_newerXY (const struct parser_table* entry, char **argv, int *arg_ptr)
1403 {
1404   (void) argv;
1405   (void) arg_ptr;
1406
1407   if ((argv == NULL) || (argv[*arg_ptr] == NULL))
1408     {
1409       return false;
1410     }
1411   else if (8u != strlen(argv[*arg_ptr]))
1412     {
1413       return false;
1414     }
1415   else
1416     {
1417       char x, y;
1418       const char validchars[] = "aBcmt";
1419
1420       assert (0 == strncmp("-newer", argv[*arg_ptr], 6));
1421       x = argv[*arg_ptr][6];
1422       y = argv[*arg_ptr][7];
1423
1424
1425 #if !defined(HAVE_STRUCT_STAT_ST_BIRTHTIME) && !defined(HAVE_STRUCT_STAT_ST_BIRTHTIMENSEC) && !defined(HAVE_STRUCT_STAT_ST_BIRTHTIMESPEC_TV_NSEC)
1426       if ('B' == x || 'B' == y)
1427         {
1428           error(0, 0,
1429                 _("This system does not provide a way to find the birth time of a file."));
1430           return 0;
1431         }
1432 #endif
1433
1434       /* -newertY (for any Y) is invalid. */
1435       if (x == 't'
1436           || 0 == strchr(validchars, x)
1437           || 0 == strchr( validchars, y))
1438         {
1439           return false;
1440         }
1441       else
1442         {
1443           struct predicate *our_pred;
1444
1445           /* Because this item is ARG_SPECIAL_PARSE, we have to advance arg_ptr
1446            * past the test name (for most other tests, this is already done)
1447            */
1448           (*arg_ptr)++;
1449
1450           our_pred = insert_primary (entry);
1451
1452
1453           switch (x)
1454             {
1455             case 'a':
1456               our_pred->args.reftime.xval = XVAL_ATIME;
1457               break;
1458             case 'B':
1459               our_pred->args.reftime.xval = XVAL_BIRTHTIME;
1460               break;
1461             case 'c':
1462               our_pred->args.reftime.xval = XVAL_CTIME;
1463               break;
1464             case 'm':
1465               our_pred->args.reftime.xval = XVAL_MTIME;
1466               break;
1467             default:
1468               assert (strchr(validchars, x));
1469               assert (0);
1470             }
1471
1472           if ('t' == y)
1473             {
1474               if (!get_date(&our_pred->args.reftime.ts,
1475                             argv[*arg_ptr],
1476                             &options.start_time))
1477                 {
1478                   error(1, 0,
1479                         _("I cannot figure out how to interpret %s as a date or time"),
1480                         quotearg_n_style(0, options.err_quoting_style, argv[*arg_ptr]));
1481                 }
1482             }
1483           else
1484             {
1485               struct stat stat_newer;
1486
1487               /* Stat the named file. */
1488               set_stat_placeholders(&stat_newer);
1489               if ((*options.xstat) (argv[*arg_ptr], &stat_newer))
1490                 fatal_file_error(argv[*arg_ptr]);
1491
1492               if (!get_stat_Ytime(&stat_newer, y, &our_pred->args.reftime.ts))
1493                 {
1494                   /* We cannot extract a timestamp from the struct stat. */
1495                   error(1, 0, _("Cannot obtain birth time of file %s"),
1496                         safely_quote_err_filename(0, argv[*arg_ptr]));
1497                 }
1498             }
1499           our_pred->args.reftime.kind = COMP_GT;
1500           our_pred->est_success_rate = estimate_timestamp_success_rate(our_pred->args.reftime.ts.tv_sec);
1501           (*arg_ptr)++;
1502
1503           assert (our_pred->pred_func != NULL);
1504           assert (our_pred->pred_func == pred_newerXY);
1505           assert (our_pred->need_stat);
1506           return true;
1507         }
1508     }
1509 }
1510
1511
1512 static boolean
1513 parse_noleaf (const struct parser_table* entry, char **argv, int *arg_ptr)
1514 {
1515   options.no_leaf_check = true;
1516   return parse_noop(entry, argv, arg_ptr);
1517 }
1518
1519 #ifdef CACHE_IDS
1520 /* Arbitrary amount by which to increase size
1521    of `uid_unused' and `gid_unused'. */
1522 #define ALLOC_STEP 2048
1523
1524 /* Boolean: if uid_unused[n] is nonzero, then UID n has no passwd entry. */
1525 char *uid_unused = NULL;
1526
1527 /* Number of elements in `uid_unused'. */
1528 unsigned uid_allocated;
1529
1530 /* Similar for GIDs and group entries. */
1531 char *gid_unused = NULL;
1532 unsigned gid_allocated;
1533 #endif
1534
1535 static boolean
1536 parse_nogroup (const struct parser_table* entry, char **argv, int *arg_ptr)
1537 {
1538   struct predicate *our_pred;
1539
1540   (void) &argv;
1541   (void) &arg_ptr;
1542
1543   our_pred = insert_primary (entry);
1544   our_pred->est_success_rate = 1e-4;
1545 #ifdef CACHE_IDS
1546   if (gid_unused == NULL)
1547     {
1548       struct group *gr;
1549
1550       gid_allocated = ALLOC_STEP;
1551       gid_unused = xmalloc (gid_allocated);
1552       memset (gid_unused, 1, gid_allocated);
1553       setgrent ();
1554       while ((gr = getgrent ()) != NULL)
1555         {
1556           if ((unsigned) gr->gr_gid >= gid_allocated)
1557             {
1558               unsigned new_allocated = (unsigned) gr->gr_gid + ALLOC_STEP;
1559               gid_unused = xrealloc (gid_unused, new_allocated);
1560               memset (gid_unused + gid_allocated, 1,
1561                       new_allocated - gid_allocated);
1562               gid_allocated = new_allocated;
1563             }
1564           gid_unused[(unsigned) gr->gr_gid] = 0;
1565         }
1566       endgrent ();
1567     }
1568 #endif
1569   return true;
1570 }
1571
1572 static boolean
1573 parse_nouser (const struct parser_table* entry, char **argv, int *arg_ptr)
1574 {
1575   struct predicate *our_pred;
1576   (void) argv;
1577   (void) arg_ptr;
1578
1579
1580   our_pred = insert_primary (entry);
1581   our_pred->est_success_rate = 1e-3;
1582 #ifdef CACHE_IDS
1583   if (uid_unused == NULL)
1584     {
1585       struct passwd *pw;
1586
1587       uid_allocated = ALLOC_STEP;
1588       uid_unused = xmalloc (uid_allocated);
1589       memset (uid_unused, 1, uid_allocated);
1590       setpwent ();
1591       while ((pw = getpwent ()) != NULL)
1592         {
1593           if ((unsigned) pw->pw_uid >= uid_allocated)
1594             {
1595               unsigned new_allocated = (unsigned) pw->pw_uid + ALLOC_STEP;
1596               uid_unused = xrealloc (uid_unused, new_allocated);
1597               memset (uid_unused + uid_allocated, 1,
1598                       new_allocated - uid_allocated);
1599               uid_allocated = new_allocated;
1600             }
1601           uid_unused[(unsigned) pw->pw_uid] = 0;
1602         }
1603       endpwent ();
1604     }
1605 #endif
1606   return true;
1607 }
1608
1609 static boolean
1610 parse_nowarn (const struct parser_table* entry, char **argv, int *arg_ptr)
1611 {
1612   options.warnings = false;
1613   return parse_noop(entry, argv, arg_ptr);
1614 }
1615
1616 static boolean
1617 parse_ok (const struct parser_table* entry, char **argv, int *arg_ptr)
1618 {
1619   return insert_exec_ok ("-ok", entry, get_start_dirfd(), argv, arg_ptr);
1620 }
1621
1622 static boolean
1623 parse_okdir (const struct parser_table* entry, char **argv, int *arg_ptr)
1624 {
1625   return insert_exec_ok ("-okdir", entry, -1, argv, arg_ptr);
1626 }
1627
1628 boolean
1629 parse_openparen (const struct parser_table* entry, char **argv, int *arg_ptr)
1630 {
1631   struct predicate *our_pred;
1632
1633   (void) argv;
1634   (void) arg_ptr;
1635
1636   our_pred = get_new_pred_chk_op (entry);
1637   our_pred->pred_func = pred_openparen;
1638   our_pred->p_type = OPEN_PAREN;
1639   our_pred->p_prec = NO_PREC;
1640   our_pred->need_stat = our_pred->need_type = false;
1641   return true;
1642 }
1643
1644 static boolean
1645 parse_or (const struct parser_table* entry, char **argv, int *arg_ptr)
1646 {
1647   struct predicate *our_pred;
1648
1649   (void) argv;
1650   (void) arg_ptr;
1651
1652   our_pred = get_new_pred (entry);
1653   our_pred->pred_func = pred_or;
1654   our_pred->p_type = BI_OP;
1655   our_pred->p_prec = OR_PREC;
1656   our_pred->need_stat = our_pred->need_type = false;
1657   return true;
1658 }
1659
1660 /* -path is deprecated (at RMS's request) in favour of
1661  * -iwholename.   See the node "GNU Manuals" in standards.texi
1662  * for the rationale for this (basically, GNU prefers the use
1663  * of the phrase "file name" to "path name".
1664  *
1665  * We do not issue a warning that this usage is deprecated
1666  * since HPUX find supports this predicate also.
1667  */
1668 static boolean
1669 parse_path (const struct parser_table* entry, char **argv, int *arg_ptr)
1670 {
1671   return parse_wholename(entry, argv, arg_ptr);
1672 }
1673
1674 static boolean
1675 parse_wholename (const struct parser_table* entry, char **argv, int *arg_ptr)
1676 {
1677   const char *name;
1678   if (collect_arg(argv, arg_ptr, &name))
1679     {
1680       struct predicate *our_pred = insert_primary_withpred (entry, pred_path);
1681       our_pred->need_stat = our_pred->need_type = false;
1682       our_pred->args.str = name;
1683       our_pred->est_success_rate = estimate_pattern_match_rate(name, 0);
1684       return true;
1685     }
1686   return false;
1687 }
1688
1689 static boolean
1690 parse_perm (const struct parser_table* entry, char **argv, int *arg_ptr)
1691 {
1692   mode_t perm_val[2];
1693   float rate;
1694   int mode_start = 0;
1695   boolean havekind = false;
1696   enum permissions_type kind = PERM_EXACT;
1697   struct mode_change *change = NULL;
1698   struct predicate *our_pred;
1699   const char *perm_expr;
1700
1701   if (!collect_arg(argv, arg_ptr, &perm_expr))
1702     return false;
1703
1704   switch (perm_expr[0])
1705     {
1706     case '-':
1707       mode_start = 1;
1708       kind = PERM_AT_LEAST;
1709       havekind = true;
1710       rate = 0.2;
1711       break;
1712
1713      case '+':
1714        change = mode_compile (perm_expr);
1715        if (NULL == change)
1716          {
1717            /* Most likely the caller is an old script that is still
1718             * using the obsolete GNU syntax '-perm +MODE'.  This old
1719             * syntax was withdrawn in favor of '-perm /MODE' because
1720             * it is incompatible with POSIX in some cases, but we
1721             * still support uses of it that are not incompatible with
1722             * POSIX.
1723             */
1724            mode_start = 1;
1725            kind = PERM_ANY;
1726            rate = 0.3;
1727          }
1728        else
1729          {
1730            /* This is a POSIX-compatible usage */
1731            mode_start = 0;
1732            kind = PERM_EXACT;
1733            rate = 0.1;
1734          }
1735        havekind = true;
1736        break;
1737
1738     case '/':                   /* GNU extension */
1739        mode_start = 1;
1740        kind = PERM_ANY;
1741        havekind = true;
1742        rate = 0.3;
1743        break;
1744
1745     default:
1746       /* For example, '-perm 0644', which is valid and matches
1747        * only files whose mode is exactly 0644.
1748        */
1749       mode_start = 0;
1750       kind = PERM_EXACT;
1751       havekind = true;
1752       rate = 0.01;
1753       break;
1754     }
1755
1756   if (NULL == change)
1757     {
1758       change = mode_compile (perm_expr + mode_start);
1759       if (NULL == change)
1760         error (1, 0, _("invalid mode %s"),
1761                quotearg_n_style(0, options.err_quoting_style, perm_expr));
1762     }
1763   perm_val[0] = mode_adjust (0, false, 0, change, NULL);
1764   perm_val[1] = mode_adjust (0, true, 0, change, NULL);
1765   free (change);
1766
1767   if (('/' == perm_expr[0]) && (0 == perm_val[0]) && (0 == perm_val[1]))
1768     {
1769       /* The meaning of -perm /000 will change in the future.  It
1770        * currently matches no files, but like -perm -000 it should
1771        * match all files.
1772        *
1773        * Starting in 2005, we used to issue a warning message
1774        * informing the user that the behaviour would change in the
1775        * future.  We have now changed the behaviour and issue a
1776        * warning message that the behaviour recently changed.
1777        */
1778       error (0, 0,
1779              _("warning: you have specified a mode pattern %s (which is "
1780                "equivalent to /000). The meaning of -perm /000 has now been "
1781                "changed to be consistent with -perm -000; that is, while it "
1782                "used to match no files, it now matches all files."),
1783              perm_expr);
1784
1785       kind = PERM_AT_LEAST;
1786       havekind = true;
1787
1788       /* The "magic" number below is just the fraction of files on my
1789        * own system that "-type l -xtype l" fails for (i.e. unbroken symlinks).
1790        * Actual totals are 1472 and 1073833.
1791        */
1792       rate = 0.9986; /* probably matches anything but a broken symlink */
1793     }
1794
1795   our_pred = insert_primary (entry);
1796   our_pred->est_success_rate = rate;
1797   if (havekind)
1798     {
1799       our_pred->args.perm.kind = kind;
1800     }
1801   else
1802     {
1803
1804       switch (perm_expr[0])
1805         {
1806         case '-':
1807           our_pred->args.perm.kind = PERM_AT_LEAST;
1808           break;
1809         case '+':
1810           our_pred->args.perm.kind = PERM_ANY;
1811           break;
1812         default:
1813           our_pred->args.perm.kind = PERM_EXACT;
1814           break;
1815         }
1816     }
1817   memcpy (our_pred->args.perm.val, perm_val, sizeof perm_val);
1818   return true;
1819 }
1820
1821 boolean
1822 parse_print (const struct parser_table* entry, char **argv, int *arg_ptr)
1823 {
1824   struct predicate *our_pred;
1825
1826   (void) argv;
1827   (void) arg_ptr;
1828
1829   our_pred = insert_primary (entry);
1830   /* -print has the side effect of printing.  This prevents us
1831      from doing undesired multiple printing when the user has
1832      already specified -print. */
1833   our_pred->side_effects = our_pred->no_default_print = true;
1834   our_pred->need_stat = our_pred->need_type = false;
1835   open_stdout(&our_pred->args.printf_vec);
1836   return true;
1837 }
1838
1839 static boolean
1840 parse_print0 (const struct parser_table* entry, char **argv, int *arg_ptr)
1841 {
1842   return insert_fprint(entry, NULL);
1843 }
1844
1845 static boolean
1846 parse_printf (const struct parser_table* entry, char **argv, int *arg_ptr)
1847 {
1848   const char *format;
1849   if (collect_arg(argv, arg_ptr, &format))
1850     {
1851       struct format_val fmt;
1852       open_stdout(&fmt);
1853       return insert_fprintf (&fmt, entry, pred_fprintf, format);
1854     }
1855   return false;
1856 }
1857
1858 static boolean
1859 parse_fprintf (const struct parser_table* entry, char **argv, int *arg_ptr)
1860 {
1861   const char *format, *filename;
1862   if (collect_arg(argv, arg_ptr, &filename))
1863     {
1864       if (collect_arg(argv, arg_ptr, &format))
1865         {
1866           struct format_val fmt;
1867           open_output_file (filename, &fmt);
1868           return insert_fprintf (&fmt, entry, pred_fprintf, format);
1869         }
1870     }
1871   return false;
1872 }
1873
1874 static boolean
1875 parse_prune (const struct parser_table* entry, char **argv, int *arg_ptr)
1876 {
1877   struct predicate *our_pred;
1878
1879   (void) argv;
1880   (void) arg_ptr;
1881
1882   our_pred = insert_primary (entry);
1883   our_pred->need_stat = our_pred->need_type = false;
1884   /* -prune has a side effect that it does not descend into
1885      the current directory. */
1886   our_pred->side_effects = true;
1887   our_pred->no_default_print = false;
1888   return true;
1889 }
1890
1891 static boolean
1892 parse_quit  (const struct parser_table* entry, char **argv, int *arg_ptr)
1893 {
1894   struct predicate *our_pred = insert_primary (entry);
1895   (void) argv;
1896   (void) arg_ptr;
1897   our_pred->need_stat = our_pred->need_type = false;
1898   our_pred->side_effects = true; /* Exiting is a side effect... */
1899   our_pred->no_default_print = false; /* Don't inhibit the default print, though. */
1900   our_pred->est_success_rate = 1.0f;
1901   return true;
1902 }
1903
1904
1905 static boolean
1906 parse_regextype (const struct parser_table* entry, char **argv, int *arg_ptr)
1907 {
1908   const char *type_name;
1909   if (collect_arg(argv, arg_ptr, &type_name))
1910     {
1911       /* collect the regex type name */
1912       options.regex_options = get_regex_type(type_name);
1913       return parse_noop(entry, argv, arg_ptr);
1914     }
1915   return false;
1916 }
1917
1918
1919 static boolean
1920 parse_regex (const struct parser_table* entry, char **argv, int *arg_ptr)
1921 {
1922   return insert_regex (argv, arg_ptr, entry, options.regex_options);
1923 }
1924
1925 static boolean
1926 insert_regex (char **argv, int *arg_ptr, const struct parser_table *entry, int regex_options)
1927 {
1928   const char *rx;
1929   if (collect_arg(argv, arg_ptr, &rx))
1930     {
1931       struct re_pattern_buffer *re;
1932       const char *error_message;
1933       struct predicate *our_pred = insert_primary_withpred (entry, pred_regex);
1934       our_pred->need_stat = our_pred->need_type = false;
1935       re = xmalloc (sizeof (struct re_pattern_buffer));
1936       our_pred->args.regex = re;
1937       re->allocated = 100;
1938       re->buffer = 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 = 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':                   /* file system 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 file system.  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, *orig_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   orig_timearg = timearg;
3185
3186   /* Decide the origin by previewing the comparison type. */
3187   origin = options.cur_day_start;
3188
3189   if (get_comp_type(&timearg, &comp))
3190     {
3191       /* Remember, we invert the sense of the comparison, so this tests
3192        * against COMP_LT instead of COMP_GT...
3193        */
3194       if (COMP_LT == comp)
3195         {
3196           uintmax_t expected = origin + (DAYSECS-1);
3197           origin += (DAYSECS-1);
3198           if (origin != expected)
3199             {
3200               error(1, 0,
3201                     _("arithmetic overflow when trying to calculate the end of today"));
3202             }
3203         }
3204     }
3205   /* We discard the value of comp here, as get_relative_timestamp
3206    * will set tval.kind.  For that to work, we have to restore
3207    * timearg so that it points to the +/- prefix, if any.  get_comp_type()
3208    * will have advanced timearg, so we restore it.
3209    */
3210   timearg = orig_timearg;
3211
3212   if (!get_relative_timestamp(timearg, &tval, origin, DAYSECS, errmsg))
3213     return false;
3214
3215   our_pred = insert_primary (entry);
3216   our_pred->args.reftime = tval;
3217   our_pred->est_success_rate = estimate_timestamp_success_rate(tval.ts.tv_sec);
3218
3219   if (options.debug_options & DebugExpressionTree)
3220     {
3221       time_t t;
3222
3223       fprintf (stderr, "inserting %s\n", our_pred->p_name);
3224       fprintf (stderr, "    type: %s    %s  ",
3225                (tval.kind == COMP_GT) ? "gt" :
3226                ((tval.kind == COMP_LT) ? "lt" : ((tval.kind == COMP_EQ) ? "eq" : "?")),
3227                (tval.kind == COMP_GT) ? " >" :
3228                ((tval.kind == COMP_LT) ? " <" : ((tval.kind == COMP_EQ) ? ">=" : " ?")));
3229       t = our_pred->args.reftime.ts.tv_sec;
3230       fprintf (stderr, "%ju %s", (uintmax_t) our_pred->args.reftime.ts.tv_sec, ctime (&t));
3231       if (tval.kind == COMP_EQ)
3232         {
3233           t = our_pred->args.reftime.ts.tv_sec + DAYSECS;
3234           fprintf (stderr, "                 <  %ju %s",
3235                    (uintmax_t) t, ctime (&t));
3236         }
3237     }
3238
3239   return true;
3240 }
3241 \f
3242 /* Get the comparison type prefix (if any) from a number argument.
3243    The prefix is at *STR.
3244    Set *COMP_TYPE to the kind of comparison that is requested.
3245    Advance *STR beyond any initial comparison prefix.
3246
3247    Return true if all okay, false if input error.  */
3248 static boolean
3249 get_comp_type(const char **str, enum comparison_type *comp_type)
3250 {
3251   switch (**str)
3252     {
3253     case '+':
3254       *comp_type = COMP_GT;
3255       (*str)++;
3256       break;
3257     case '-':
3258       *comp_type = COMP_LT;
3259       (*str)++;
3260       break;
3261     default:
3262       *comp_type = COMP_EQ;
3263       break;
3264     }
3265   return true;
3266 }
3267
3268
3269
3270
3271 \f
3272 /* Get a number with comparison information.
3273    The sense of the comparison information is 'normal'; that is,
3274    '+' looks for a count > than the number and '-' less than.
3275
3276    STR is the ASCII representation of the number.
3277    Set *NUM to the number.
3278    Set *COMP_TYPE to the kind of comparison that is requested.
3279
3280    Return true if all okay, false if input error.  */
3281
3282 static boolean
3283 get_num (const char *str,
3284          uintmax_t *num,
3285          enum comparison_type *comp_type)
3286 {
3287   char *pend;
3288
3289   if (str == NULL)
3290     return false;
3291
3292   /* Figure out the comparison type if the caller accepts one. */
3293   if (comp_type)
3294     {
3295       if (!get_comp_type(&str, comp_type))
3296         return false;
3297     }
3298
3299   return xstrtoumax (str, &pend, 10, num, "") == LONGINT_OK;
3300 }
3301 \f
3302 /* Insert a number predicate.
3303    ARGV is a pointer to the argument array.
3304    *ARG_PTR is an index into ARGV, incremented if all went well.
3305    *PRED is the predicate processor to insert.
3306
3307    Return true if input is valid, false if error.
3308
3309    A new predicate node is assigned, along with an argument node
3310    obtained with malloc.
3311
3312    Used by -inum and -links parsers. */
3313
3314 static struct predicate *
3315 insert_num (char **argv, int *arg_ptr, const struct parser_table *entry)
3316 {
3317   const char *numstr;
3318
3319   if (collect_arg(argv, arg_ptr, &numstr))
3320   {
3321     uintmax_t num;
3322     enum comparison_type c_type;
3323
3324     if (get_num (numstr, &num, &c_type))
3325       {
3326         struct predicate *our_pred = insert_primary (entry);
3327         our_pred->args.numinfo.kind = c_type;
3328         our_pred->args.numinfo.l_val = num;
3329
3330         if (options.debug_options & DebugExpressionTree)
3331           {
3332             fprintf (stderr, "inserting %s\n", our_pred->p_name);
3333             fprintf (stderr, "    type: %s    %s  ",
3334                      (c_type == COMP_GT) ? "gt" :
3335                      ((c_type == COMP_LT) ? "lt" : ((c_type == COMP_EQ) ? "eq" : "?")),
3336                      (c_type == COMP_GT) ? " >" :
3337                      ((c_type == COMP_LT) ? " <" : ((c_type == COMP_EQ) ? " =" : " ?")));
3338             fprintf (stderr, "%ju\n", our_pred->args.numinfo.l_val);
3339           }
3340         return our_pred;
3341       }
3342   }
3343   return NULL;
3344 }
3345
3346 static void
3347 open_output_file (const char *path, struct format_val *p)
3348 {
3349   p->segment = NULL;
3350   p->quote_opts = clone_quoting_options (NULL);
3351
3352   if (!strcmp (path, "/dev/stderr"))
3353     {
3354       p->stream = stderr;
3355       p->filename = _("standard error");
3356     }
3357   else if (!strcmp (path, "/dev/stdout"))
3358     {
3359       p->stream = stdout;
3360       p->filename = _("standard output");
3361     }
3362   else
3363     {
3364       p->stream = fopen_safer (path, "w");
3365       p->filename = path;
3366
3367       if (p->stream == NULL)
3368         {
3369           fatal_file_error(path);
3370         }
3371     }
3372
3373   p->dest_is_tty = stream_is_tty(p->stream);
3374 }
3375
3376 static void
3377 open_stdout (struct format_val *p)
3378 {
3379   open_output_file("/dev/stdout", p);
3380 }
3381