find/defs.h

   1 /* defs.h -- data types and declarations.
   2    Copyright (C) 1990, 91, 92, 93, 94, 2000, 2004, 2005, 2006 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 2, or (at your option)
   7    any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software
  16    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  17    USA.
  18 */
  19 #ifndef INC_DEFS_H
  20 #define INC_DEFS_H 1
  21
  22 #include <config.h>
  23 #include <sys/types.h>
  24
  25 /* XXX: some of these includes probably don't belong in a common header file */
  26 #include <sys/stat.h>
  27 #include <stdio.h>              /* for FILE* */
  28 #include <string.h>
  29 #include <stdlib.h>
  30 #include <unistd.h>
  31 #include <time.h>
  32 #include <limits.h>             /* for CHAR_BIT */
  33 #include <stdbool.h>            /* for bool/boolean */
  34 #include <stdint.h>             /* for uintmax_t */
  35 #include <sys/stat.h> /* S_ISUID etc. */
  36
  37
  38
  39 #ifndef CHAR_BIT
  40 # define CHAR_BIT 8
  41 #endif
  42
  43 #if HAVE_INTTYPES_H
  44 # include <inttypes.h>
  45 #endif
  46 typedef bool boolean;
  47
  48 #include "regex.h"
  49 #include "timespec.h"
  50 #include "buildcmd.h"
  51 #include "quotearg.h"
  52
  53 /* These days we will assume ANSI/ISO C protootypes work on our compiler. */
  54 #define PARAMS(Args) Args
  55
  56 #ifndef ATTRIBUTE_NORETURN
  57 # if HAVE_ATTRIBUTE_NORETURN
  58 #  define ATTRIBUTE_NORETURN __attribute__ ((__noreturn__))
  59 # else
  60 #  define ATTRIBUTE_NORETURN /* nothing */
  61 # endif
  62 #endif
  63
  64 int optionl_stat PARAMS((const char *name, struct stat *p));
  65 int optionp_stat PARAMS((const char *name, struct stat *p));
  66 int optionh_stat PARAMS((const char *name, struct stat *p));
  67 int debug_stat   PARAMS((const char *file, struct stat *bufp));
  68
  69 void set_stat_placeholders PARAMS((struct stat *p));
  70 int get_statinfo PARAMS((const char *pathname, const char *name, struct stat *p));
  71
  72
  73 #define MODE_WXUSR      (S_IWUSR | S_IXUSR)
  74 #define MODE_R          (S_IRUSR | S_IRGRP | S_IROTH)
  75 #define MODE_RW         (S_IWUSR | S_IWGRP | S_IWOTH | MODE_R)
  76 #define MODE_RWX        (S_IXUSR | S_IXGRP | S_IXOTH | MODE_RW)
  77 #define MODE_ALL        (S_ISUID | S_ISGID | S_ISVTX | MODE_RWX)
  78
  79
  80 struct predicate;
  81 struct options;
  82
  83 /* Pointer to a predicate function. */
  84 typedef boolean (*PRED_FUNC)(const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr);
  85
  86 /* The number of seconds in a day. */
  87 #define         DAYSECS     86400
  88
  89 /* Argument structures for predicates. */
  90
  91 enum comparison_type
  92 {
  93   COMP_GT,
  94   COMP_LT,
  95   COMP_EQ
  96 };
  97
  98 enum permissions_type
  99 {
 100   PERM_AT_LEAST,
 101   PERM_ANY,
 102   PERM_EXACT
 103 };
 104
 105 enum predicate_type
 106 {
 107   NO_TYPE,
 108   PRIMARY_TYPE,
 109   UNI_OP,
 110   BI_OP,
 111   OPEN_PAREN,
 112   CLOSE_PAREN
 113 };
 114
 115 enum predicate_precedence
 116 {
 117   NO_PREC,
 118   COMMA_PREC,
 119   OR_PREC,
 120   AND_PREC,
 121   NEGATE_PREC,
 122   MAX_PREC
 123 };
 124
 125 struct long_val
 126 {
 127   enum comparison_type kind;
 128   boolean negative;             /* Defined only when representing time_t.  */
 129   uintmax_t l_val;
 130 };
 131
 132 struct perm_val
 133 {
 134   enum permissions_type kind;
 135   mode_t val[2];
 136 };
 137
 138 /* dir_id is used to support loop detection in find.c
 139  */
 140 struct dir_id
 141 {
 142   ino_t ino;
 143   dev_t dev;
 144 };
 145
 146 /* samefile_file_id is used to support the -samefile test.
 147  */
 148 struct samefile_file_id
 149 {
 150   ino_t ino;
 151   dev_t dev;
 152   int   fd;
 153 };
 154
 155 struct size_val
 156 {
 157   enum comparison_type kind;
 158   int blocksize;
 159   uintmax_t size;
 160 };
 161
 162
 163 enum xval
 164   {
 165     XVAL_ATIME, XVAL_BIRTHTIME, XVAL_CTIME, XVAL_MTIME, XVAL_TIME
 166   };
 167
 168 struct time_val
 169 {
 170   enum xval            xval;
 171   enum comparison_type kind;
 172   struct timespec      ts;
 173 };
 174
 175
 176 struct exec_val
 177 {
 178   boolean multiple;             /* -exec {} \+ denotes multiple argument. */
 179   struct buildcmd_control ctl;
 180   struct buildcmd_state   state;
 181   char **replace_vec;           /* Command arguments (for ";" style) */
 182   int num_args;
 183   boolean use_current_dir;      /* If nonzero, don't chdir to start dir */
 184   boolean close_stdin;          /* If true, close stdin in the child. */
 185   int dirfd;                    /* The directory to do the exec in. */
 186 };
 187
 188 /* The format string for a -printf or -fprintf is chopped into one or
 189    more `struct segment', linked together into a list.
 190    Each stretch of plain text is a segment, and
 191    each \c and `%' conversion is a segment. */
 192
 193 /* Special values for the `kind' field of `struct segment'. */
 194 enum SegmentKind
 195   {
 196     KIND_PLAIN=0,               /* Segment containing just plain text. */
 197     KIND_STOP=1,                /* \c -- stop printing and flush output. */
 198     KIND_FORMAT,                /* Regular format */
 199   };
 200
 201 struct segment
 202 {
 203   enum SegmentKind segkind;     /* KIND_FORMAT, KIND_PLAIN, KIND_STOP */
 204   char format_char[2];          /* Format chars if kind is KIND_FORMAT */
 205   char *text;                   /* Plain text or `%' format string. */
 206   int text_len;                 /* Length of `text'. */
 207   struct segment *next;         /* Next segment for this predicate. */
 208 };
 209
 210 struct format_val
 211 {
 212   struct segment *segment;      /* Linked list of segments. */
 213   FILE *stream;                 /* Output stream to print on. */
 214   const char *filename;         /* We need the filename for error messages. */
 215   boolean dest_is_tty;          /* True if the destination is a terminal. */
 216   struct quoting_options *quote_opts;
 217 };
 218
 219 /* Profiling information for a predicate */
 220 struct predicate_performance_info
 221 {
 222   unsigned long visits;
 223   unsigned long successes;
 224 };
 225
 226 /* evaluation cost of a predicate */
 227 enum EvaluationCost
 228 {
 229   NeedsNothing,
 230   NeedsType,
 231   NeedsStatInfo,
 232   NeedsLinkName,
 233   NeedsAccessInfo,
 234   NeedsSyncDiskHit,
 235   NeedsEventualExec,
 236   NeedsImmediateExec,
 237   NeedsUserInteraction,
 238   NeedsUnknown,
 239   NumEvaluationCosts
 240 };
 241
 242 struct predicate
 243 {
 244   /* Pointer to the function that implements this predicate.  */
 245   PRED_FUNC pred_func;
 246
 247   /* Only used for debugging, but defined unconditionally so individual
 248      modules can be compiled with -DDEBUG.  */
 249   char *p_name;
 250
 251   /* The type of this node.  There are two kinds.  The first is real
 252      predicates ("primaries") such as -perm, -print, or -exec.  The
 253      other kind is operators for combining predicates. */
 254   enum predicate_type p_type;
 255
 256   /* The precedence of this node.  Only has meaning for operators. */
 257   enum predicate_precedence p_prec;
 258
 259   /* True if this predicate node produces side effects.
 260      If side_effects are produced
 261      then optimization will not be performed */
 262   boolean side_effects;
 263
 264   /* True if this predicate node requires default print be turned off. */
 265   boolean no_default_print;
 266
 267   /* True if this predicate node requires a stat system call to execute. */
 268   boolean need_stat;
 269
 270   /* True if this predicate node requires knowledge of the file type. */
 271   boolean need_type;
 272
 273   enum EvaluationCost p_cost;
 274
 275   /* est_success_rate is a number between 0.0 and 1.0 */
 276   float est_success_rate;
 277
 278   /* True if this predicate should display control characters literally */
 279   boolean literal_control_chars;
 280
 281   /* True if this predicate didn't originate from the user. */
 282   boolean artificial;
 283
 284   /* The raw text of the argument of this predicate. */
 285   char *arg_text;
 286
 287   /* Information needed by the predicate processor.
 288      Next to each member are listed the predicates that use it. */
 289   union
 290   {
 291     const char *str;            /* fstype [i]lname [i]name [i]path */
 292     struct re_pattern_buffer *regex; /* regex */
 293     struct exec_val exec_vec;   /* exec ok */
 294     struct long_val numinfo;    /* gid inum links  uid */
 295     struct size_val size;       /* size */
 296     uid_t uid;                  /* user */
 297     gid_t gid;                  /* group */
 298     struct time_val reftime;    /* newer newerXY anewer cnewer mtime atime ctime mmin amin cmin */
 299     struct perm_val perm;       /* perm */
 300     struct samefile_file_id samefileid; /* samefile */
 301     mode_t type;                /* type */
 302     struct format_val printf_vec; /* printf fprintf fprint ls fls print0 fprint0 print */
 303   } args;
 304
 305   /* The next predicate in the user input sequence,
 306      which represents the order in which the user supplied the
 307      predicates on the command line. */
 308   struct predicate *pred_next;
 309
 310   /* The right and left branches from this node in the expression
 311      tree, which represents the order in which the nodes should be
 312      processed. */
 313   struct predicate *pred_left;
 314   struct predicate *pred_right;
 315
 316   struct predicate_performance_info perf;
 317
 318   const struct parser_table* parser_entry;
 319 };
 320
 321 /* find.c, ftsfind.c */
 322 boolean is_fts_enabled(int *ftsoptions);
 323 int get_start_dirfd(void);
 324 int get_current_dirfd(void);
 325
 326 /* find library function declarations.  */
 327
 328 /* find global function declarations.  */
 329
 330 /* find.c */
 331 /* SymlinkOption represents the choice of
 332  * -P, -L or -P (default) on the command line.
 333  */
 334 enum SymlinkOption
 335   {
 336     SYMLINK_NEVER_DEREF,        /* Option -P */
 337     SYMLINK_ALWAYS_DEREF,       /* Option -L */
 338     SYMLINK_DEREF_ARGSONLY      /* Option -H */
 339   };
 340 extern enum SymlinkOption symlink_handling; /* defined in find.c. */
 341
 342 void set_follow_state PARAMS((enum SymlinkOption opt));
 343 void cleanup(void);
 344
 345 /* fstype.c */
 346 char *filesystem_type PARAMS((const struct stat *statp, const char *path));
 347 char * get_mounted_filesystems (void);
 348 dev_t * get_mounted_devices PARAMS((size_t *));
 349
 350
 351
 352 enum arg_type
 353   {
 354     ARG_OPTION,                 /* regular options like -maxdepth */
 355     ARG_NOOP,                   /* does nothing, returns true, internal use only */
 356     ARG_POSITIONAL_OPTION,      /* options whose position is important (-follow) */
 357     ARG_TEST,                   /* a like -name */
 358     ARG_SPECIAL_PARSE,          /* complex to parse, don't eat the test name before calling parse_xx(). */
 359     ARG_PUNCTUATION,            /* like -o or ( */
 360     ARG_ACTION                  /* like -print */
 361   };
 362
 363
 364 struct parser_table;
 365 /* Pointer to a parser function. */
 366 typedef boolean (*PARSE_FUNC)(const struct parser_table *p,
 367                               char *argv[], int *arg_ptr);
 368 struct parser_table
 369 {
 370   enum arg_type type;
 371   char *parser_name;
 372   PARSE_FUNC parser_func;
 373   PRED_FUNC    pred_func;
 374 };
 375
 376 /* parser.c */
 377 const struct parser_table* find_parser PARAMS((char *search_name));
 378 boolean parse_print PARAMS((const struct parser_table*, char *argv[], int *arg_ptr));
 379 void pred_sanity_check PARAMS((const struct predicate *predicates));
 380 void parse_begin_user_args PARAMS((char **args, int argno, const struct predicate *last, const struct predicate *predicates));
 381 void parse_end_user_args PARAMS((char **args, int argno, const struct predicate *last, const struct predicate *predicates));
 382 boolean parse_openparen              PARAMS((const struct parser_table* entry, char *argv[], int *arg_ptr));
 383 boolean parse_closeparen             PARAMS((const struct parser_table* entry, char *argv[], int *arg_ptr));
 384
 385 /* pred.c */
 386
 387 typedef boolean PREDICATEFUNCTION(const char *pathname, struct stat *stat_buf, struct predicate *pred_ptr);
 388 PREDICATEFUNCTION pred_amin;
 389 PREDICATEFUNCTION pred_and;
 390 PREDICATEFUNCTION pred_anewer;
 391 PREDICATEFUNCTION pred_atime;
 392 PREDICATEFUNCTION pred_closeparen;
 393 PREDICATEFUNCTION pred_cmin;
 394 PREDICATEFUNCTION pred_cnewer;
 395 PREDICATEFUNCTION pred_comma;
 396 PREDICATEFUNCTION pred_ctime;
 397 PREDICATEFUNCTION pred_delete;
 398 PREDICATEFUNCTION pred_empty;
 399 PREDICATEFUNCTION pred_exec;
 400 PREDICATEFUNCTION pred_execdir;
 401 PREDICATEFUNCTION pred_executable;
 402 PREDICATEFUNCTION pred_false;
 403 PREDICATEFUNCTION pred_fls;
 404 PREDICATEFUNCTION pred_fprint;
 405 PREDICATEFUNCTION pred_fprint0;
 406 PREDICATEFUNCTION pred_fprintf;
 407 PREDICATEFUNCTION pred_fstype;
 408 PREDICATEFUNCTION pred_gid;
 409 PREDICATEFUNCTION pred_group;
 410 PREDICATEFUNCTION pred_ilname;
 411 PREDICATEFUNCTION pred_iname;
 412 PREDICATEFUNCTION pred_inum;
 413 PREDICATEFUNCTION pred_ipath;
 414 PREDICATEFUNCTION pred_links;
 415 PREDICATEFUNCTION pred_lname;
 416 PREDICATEFUNCTION pred_ls;
 417 PREDICATEFUNCTION pred_mmin;
 418 PREDICATEFUNCTION pred_mtime;
 419 PREDICATEFUNCTION pred_name;
 420 PREDICATEFUNCTION pred_negate;
 421 PREDICATEFUNCTION pred_newer;
 422 PREDICATEFUNCTION pred_newerXY;
 423 PREDICATEFUNCTION pred_nogroup;
 424 PREDICATEFUNCTION pred_nouser;
 425 PREDICATEFUNCTION pred_ok;
 426 PREDICATEFUNCTION pred_okdir;
 427 PREDICATEFUNCTION pred_openparen;
 428 PREDICATEFUNCTION pred_or;
 429 PREDICATEFUNCTION pred_path;
 430 PREDICATEFUNCTION pred_perm;
 431 PREDICATEFUNCTION pred_print;
 432 PREDICATEFUNCTION pred_print0;
 433 PREDICATEFUNCTION pred_prune;
 434 PREDICATEFUNCTION pred_quit;
 435 PREDICATEFUNCTION pred_readable;
 436 PREDICATEFUNCTION pred_regex;
 437 PREDICATEFUNCTION pred_samefile;
 438 PREDICATEFUNCTION pred_size;
 439 PREDICATEFUNCTION pred_true;
 440 PREDICATEFUNCTION pred_type;
 441 PREDICATEFUNCTION pred_uid;
 442 PREDICATEFUNCTION pred_used;
 443 PREDICATEFUNCTION pred_user;
 444 PREDICATEFUNCTION pred_writable;
 445 PREDICATEFUNCTION pred_xtype;
 446
 447
 448
 449 int launch PARAMS((const struct buildcmd_control *ctl,
 450                    struct buildcmd_state *buildstate));
 451
 452
 453 char *find_pred_name PARAMS((PRED_FUNC pred_func));
 454
 455
 456
 457 void print_predicate PARAMS((FILE *fp, const struct predicate *p));
 458 void print_tree PARAMS((FILE*, struct predicate *node, int indent));
 459 void print_list PARAMS((FILE*, struct predicate *node));
 460 void print_optlist PARAMS((FILE *fp, const struct predicate *node));
 461 void show_success_rates(const struct predicate *node);
 462
 463
 464 /* tree.c */
 465 struct predicate * build_expression_tree PARAMS((int argc, char *argv[], int end_of_leading_options));
 466 struct predicate * get_eval_tree PARAMS((void));
 467 struct predicate *get_new_pred PARAMS((const struct parser_table *entry));
 468 struct predicate *get_new_pred_chk_op PARAMS((const struct parser_table *entry));
 469 float  calculate_derived_rates PARAMS((struct predicate *p));
 470
 471 /* util.c */
 472 struct predicate *insert_primary PARAMS((const struct parser_table *entry));
 473 struct predicate *insert_primary_withpred PARAMS((const struct parser_table *entry, PRED_FUNC fptr));
 474 void usage PARAMS((FILE *fp, int status, char *msg));
 475 extern boolean check_nofollow(void);
 476 void complete_pending_execs(struct predicate *p);
 477 void complete_pending_execdirs(int dirfd); /* Passing dirfd is an unpleasant CodeSmell. */
 478 const char *safely_quote_err_filename (int n, char const *arg);
 479 void fatal_file_error(const char *name) ATTRIBUTE_NORETURN;
 480 void nonfatal_file_error(const char *name);
 481
 482 int process_leading_options PARAMS((int argc, char *argv[]));
 483 void set_option_defaults PARAMS((struct options *p));
 484
 485 #if 0
 486 #define apply_predicate(pathname, stat_buf_ptr, node)   \
 487   (*(node)->pred_func)((pathname), (stat_buf_ptr), (node))
 488 #else
 489 boolean apply_predicate(const char *pathname, struct stat *stat_buf, struct predicate *p);
 490 #endif
 491
 492 #define pred_is(node, fn) ( ((node)->pred_func) == (fn) )
 493
 494
 495 /* find.c. */
 496 int get_info PARAMS((const char *pathname, struct stat *p, struct predicate *pred_ptr));
 497 int following_links PARAMS((void));
 498 int digest_mode PARAMS((mode_t mode, const char *pathname, const char *name, struct stat *pstat, boolean leaf));
 499 boolean default_prints PARAMS((struct predicate *pred));
 500 boolean looks_like_expression PARAMS((const char *arg, boolean leading));
 501
 502
 503 enum DebugOption
 504   {
 505     DebugNone             = 0,
 506     DebugExpressionTree   = 1,
 507     DebugStat             = 2,
 508     DebugSearch           = 4,
 509     DebugTreeOpt          = 8,
 510     DebugHelp             = 16,
 511     DebugExec             = 32,
 512     DebugSuccessRates     = 64
 513   };
 514
 515 struct options
 516 {
 517   /* If true, process directory before contents.  True unless -depth given. */
 518   boolean do_dir_first;
 519
 520   /* If >=0, don't descend more than this many levels of subdirectories. */
 521   int maxdepth;
 522
 523   /* If >=0, don't process files above this level. */
 524   int mindepth;
 525
 526   /* If true, do not assume that files in directories with nlink == 2
 527      are non-directories. */
 528   boolean no_leaf_check;
 529
 530   /* If true, don't cross filesystem boundaries. */
 531   boolean stay_on_filesystem;
 532
 533   /* If true, we ignore the problem where we find that a directory entry
 534    * no longer exists by the time we get around to processing it.
 535    */
 536   boolean ignore_readdir_race;
 537
 538   /* If true, pass control characters through.  If false, escape them
 539    * or turn them into harmless things.
 540    */
 541   boolean literal_control_chars;
 542
 543   /* If true, we issue warning messages
 544    */
 545   boolean warnings;
 546
 547   struct timespec      start_time;              /* Time at start of execution.  */
 548
 549   /* Seconds between 00:00 1/1/70 and either one day before now
 550      (the default), or the start of today (if -daystart is given). */
 551   time_t cur_day_start;
 552
 553   /* If true, cur_day_start has been adjusted to the start of the day. */
 554   boolean full_days;
 555
 556   int output_block_size;        /* Output block size.  */
 557
 558   /* bitmask for debug options */
 559   unsigned long debug_options;
 560
 561   enum SymlinkOption symlink_handling;
 562
 563
 564   /* Pointer to the function used to stat files. */
 565   int (*xstat) (const char *name, struct stat *statbuf);
 566
 567
 568   /* Indicate if we can implement safely_chdir() using the O_NOFOLLOW
 569    * flag to open(2).
 570    */
 571   boolean open_nofollow_available;
 572
 573   /* The variety of regular expression that we support.
 574    * The default is POSIX Basic Regular Expressions, but this
 575    * can be changed with the positional option, -regextype.
 576    */
 577   int regex_options;
 578
 579   /* Optimisation level.  One is the default.
 580    */
 581   unsigned short optimisation_level;
 582
 583
 584   /* How should we quote filenames in error messages and so forth?
 585    */
 586   enum quoting_style err_quoting_style;
 587 };
 588 extern struct options options;
 589
 590
 591 struct state
 592 {
 593   /* Current depth; 0 means current path is a command line arg. */
 594   int curdepth;
 595
 596   /* If true, we have called stat on the current path. */
 597   boolean have_stat;
 598
 599   /* If true, we know the type of the current path. */
 600   boolean have_type;
 601   mode_t type;                  /* this is the actual type */
 602
 603   /* The file being operated on, relative to the current directory.
 604      Used for stat, readlink, remove, and opendir.  */
 605   char *rel_pathname;
 606   /* The directory fd to which rel_pathname is relative.  Thsi is relevant
 607    * when we're navigating the hierarchy with fts() and using FTS_CWDFD.
 608    */
 609   int cwd_dir_fd;
 610
 611   /* Length of starting path. */
 612   int starting_path_length;
 613
 614   /* If true, don't descend past current directory.
 615      Can be set by -prune, -maxdepth, and -xdev/-mount. */
 616   boolean stop_at_current_level;
 617
 618   /* Status value to return to system. */
 619   int exit_status;
 620
 621   /* True if there are any execdirs.  This saves us a pair of fchdir()
 622    * calls for every directory we leave if it is false.  This is just
 623    * an optimisation.  Set to true if you want to be conservative.
 624    */
 625   boolean execdirs_outstanding;
 626 };
 627
 628 /* finddata.c */
 629 extern struct state state;
 630 extern char const *starting_dir;
 631 extern int starting_desc;
 632 extern char *program_name;
 633
 634
 635 #endif