find/ftsfind.c

   1 /* find -- search for files in a directory hierarchy (fts version)
   2    Copyright (C) 1990, 91, 92, 93, 94, 2000,
   3                  2003, 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 /* This file was written by James Youngman, based on find.c.
  21
  22    GNU find was written by Eric Decker <cire@cisco.com>,
  23    with enhancements by David MacKenzie <djm@gnu.org>,
  24    Jay Plett <jay@silence.princeton.nj.us>,
  25    and Tim Wood <axolotl!tim@toad.com>.
  26    The idea for -print0 and xargs -0 came from
  27    Dan Bernstein <brnstnd@kramden.acf.nyu.edu>.
  28 */
  29
  30
  31 #include <config.h>
  32 #include "defs.h"
  33
  34
  35 #define USE_SAFE_CHDIR 1
  36 #undef  STAT_MOUNTPOINTS
  37
  38
  39 #include <errno.h>
  40 #include <assert.h>
  41
  42 #ifdef HAVE_FCNTL_H
  43 #include <fcntl.h>
  44 #else
  45 #include <sys/file.h>
  46 #endif
  47 #include <sys/stat.h>
  48
  49 #include <unistd.h>
  50
  51 #include "xalloc.h"
  52 #include "closeout.h"
  53 #include <modetype.h>
  54 #include "quotearg.h"
  55 #include "quote.h"
  56 #include "fts_.h"
  57 #include "openat.h"
  58 #include "save-cwd.h"
  59 #include "xgetcwd.h"
  60 #include "error.h"
  61 #include "dircallback.h"
  62
  63 #ifdef HAVE_LOCALE_H
  64 #include <locale.h>
  65 #endif
  66
  67 #if ENABLE_NLS
  68 # include <libintl.h>
  69 # define _(Text) gettext (Text)
  70 #else
  71 # define _(Text) Text
  72 #define textdomain(Domain)
  73 #define bindtextdomain(Package, Directory)
  74 #endif
  75 #ifdef gettext_noop
  76 # define N_(String) gettext_noop (String)
  77 #else
  78 /* See locate.c for explanation as to why not use (String) */
  79 # define N_(String) String
  80 #endif
  81
  82
  83 static void set_close_on_exec(int fd)
  84 {
  85 #if defined F_GETFD && defined FD_CLOEXEC
  86   int flags;
  87   flags = fcntl(fd, F_GETFD);
  88   if (flags >= 0)
  89     {
  90       flags |= FD_CLOEXEC;
  91       fcntl(fd, F_SETFD, flags);
  92     }
  93 #endif
  94 }
  95
  96
  97
  98 /* FTS_TIGHT_CYCLE_CHECK tries to work around Savannah bug #17877
  99  * (but actually using it doesn't fix the bug).
 100  */
 101 static int ftsoptions = FTS_NOSTAT|FTS_TIGHT_CYCLE_CHECK;
 102
 103 static int prev_depth = INT_MIN; /* fts_level can be < 0 */
 104 static int curr_fd = -1;
 105
 106 int get_current_dirfd(void)
 107 {
 108   if (ftsoptions & FTS_CWDFD)
 109     {
 110       assert (curr_fd != -1);
 111       assert ( (AT_FDCWD == curr_fd) || (curr_fd >= 0) );
 112
 113       if (AT_FDCWD == curr_fd)
 114         return starting_desc;
 115       else
 116         return curr_fd;
 117     }
 118   else
 119     {
 120       return AT_FDCWD;
 121     }
 122 }
 123
 124 static void left_dir(void)
 125 {
 126   if (ftsoptions & FTS_CWDFD)
 127     {
 128       if (curr_fd >= 0)
 129         {
 130           close(curr_fd);
 131           curr_fd = -1;
 132         }
 133     }
 134   else
 135     {
 136       /* do nothing. */
 137     }
 138 }
 139
 140 /*
 141  * Signal that we are now inside a directory pointed to by dirfd.
 142  * The caller can't tell if this is the first time this happens, so
 143  * we have to be careful not to call dup() more than once
 144  */
 145 static void inside_dir(int dirfd)
 146 {
 147   if (ftsoptions & FTS_CWDFD)
 148     {
 149       assert (dirfd == AT_FDCWD || dirfd >= 0);
 150
 151       state.cwd_dir_fd = dirfd;
 152       if (curr_fd < 0)
 153         {
 154           if (AT_FDCWD == dirfd)
 155             {
 156               curr_fd = AT_FDCWD;
 157             }
 158           else if (dirfd >= 0)
 159             {
 160               curr_fd = dup(dirfd);
 161               set_close_on_exec(curr_fd);
 162             }
 163           else
 164             {
 165               /* curr_fd is invalid, but dirfd is also invalid.
 166                * This should not have happened.
 167                */
 168               assert (curr_fd >= 0 || dirfd >= 0);
 169             }
 170         }
 171     }
 172   else
 173     {
 174       /* FTS_CWDFD is not in use.  We can always assume that
 175        * AT_FDCWD refers to the directory we are currentl searching.
 176        *
 177        * Therefore there is nothing to do.
 178        */
 179     }
 180 }
 181
 182
 183
 184 #ifdef STAT_MOUNTPOINTS
 185 static void init_mounted_dev_list(void);
 186 #endif
 187 \f
 188 /* We have encountered an error which should affect the exit status.
 189  * This is normally used to change the exit status from 0 to 1.
 190  * However, if the exit status is already 2 for example, we don't want to
 191  * reduce it to 1.
 192  */
 193 static void
 194 error_severity(int level)
 195 {
 196   if (state.exit_status < level)
 197     state.exit_status = level;
 198 }
 199 \f
 200
 201 #define STRINGIFY(X) #X
 202 #define HANDLECASE(N) case N: return #N;
 203
 204 static char *
 205 get_fts_info_name(int info)
 206 {
 207   static char buf[10];
 208   switch (info)
 209     {
 210       HANDLECASE(FTS_D);
 211       HANDLECASE(FTS_DC);
 212       HANDLECASE(FTS_DEFAULT);
 213       HANDLECASE(FTS_DNR);
 214       HANDLECASE(FTS_DOT);
 215       HANDLECASE(FTS_DP);
 216       HANDLECASE(FTS_ERR);
 217       HANDLECASE(FTS_F);
 218       HANDLECASE(FTS_INIT);
 219       HANDLECASE(FTS_NS);
 220       HANDLECASE(FTS_NSOK);
 221       HANDLECASE(FTS_SL);
 222       HANDLECASE(FTS_SLNONE);
 223       HANDLECASE(FTS_W);
 224     default:
 225       sprintf(buf, "[%d]", info);
 226       return buf;
 227     }
 228 }
 229 \f
 230 static void
 231 visit(FTS *p, FTSENT *ent, struct stat *pstat)
 232 {
 233   struct predicate *eval_tree;
 234
 235   state.curdepth = ent->fts_level;
 236   state.have_stat = (ent->fts_info != FTS_NS) && (ent->fts_info != FTS_NSOK);
 237   state.rel_pathname = ent->fts_accpath;
 238   state.cwd_dir_fd   = p->fts_cwd_fd;
 239
 240   /* Apply the predicates to this path. */
 241   eval_tree = get_eval_tree();
 242   apply_predicate(ent->fts_path, pstat, eval_tree);
 243
 244   /* Deal with any side effects of applying the predicates. */
 245   if (state.stop_at_current_level)
 246     {
 247       fts_set(p, ent, FTS_SKIP);
 248     }
 249 }
 250 \f
 251 static const char*
 252 partial_quotearg_n(int n, char *s, size_t len, enum quoting_style style)
 253 {
 254   if (0 == len)
 255     {
 256       return quotearg_n_style(n, style, "");
 257     }
 258   else
 259     {
 260       char saved;
 261       const char *result;
 262
 263       saved = s[len];
 264       s[len] = 0;
 265       result = quotearg_n_style(n, style, s);
 266       s[len] = saved;
 267       return result;
 268     }
 269 }
 270
 271 \f
 272 /* We've detected a file system loop.   This is caused by one of
 273  * two things:
 274  *
 275  * 1. Option -L is in effect and we've hit a symbolic link that
 276  *    points to an ancestor.  This is harmless.  We won't traverse the
 277  *    symbolic link.
 278  *
 279  * 2. We have hit a real cycle in the directory hierarchy.  In this
 280  *    case, we issue a diagnostic message (POSIX requires this) and we
 281  *    skip that directory entry.
 282  */
 283 static void
 284 issue_loop_warning(FTSENT * ent)
 285 {
 286   if (S_ISLNK(ent->fts_statp->st_mode))
 287     {
 288       error(0, 0,
 289             _("Symbolic link %s is part of a loop in the directory hierarchy; we have already visited the directory to which it points."),
 290             safely_quote_err_filename(0, ent->fts_path));
 291     }
 292   else
 293     {
 294       /* We have found an infinite loop.  POSIX requires us to
 295        * issue a diagnostic.  Usually we won't get to here
 296        * because when the leaf optimisation is on, it will cause
 297        * the subdirectory to be skipped.  If /a/b/c/d is a hard
 298        * link to /a/b, then the link count of /a/b/c is 2,
 299        * because the ".." entry of /a/b/c/d points to /a, not
 300        * to /a/b/c.
 301        */
 302       error(0, 0,
 303             _("File system loop detected; "
 304               "%s is part of the same file system loop as %s."),
 305             safely_quote_err_filename(0, ent->fts_path),
 306             partial_quotearg_n(1,
 307                                ent->fts_cycle->fts_path,
 308                                ent->fts_cycle->fts_pathlen,
 309                                options.err_quoting_style));
 310     }
 311 }
 312 \f
 313 /*
 314  * Return true if NAME corresponds to a file which forms part of a
 315  * symbolic link loop.  The command
 316  *      rm -f a b; ln -s a b; ln -s b a
 317  * produces such a loop.
 318  */
 319 static boolean
 320 symlink_loop(const char *name)
 321 {
 322   struct stat stbuf;
 323   int rv;
 324   if (following_links())
 325     rv = stat(name, &stbuf);
 326   else
 327     rv = lstat(name, &stbuf);
 328   return (0 != rv) && (ELOOP == errno);
 329 }
 330 \f
 331
 332 static int
 333 complete_execdirs_cb(void *context)
 334 {
 335   (void) context;
 336   /* By the tme this callback is called, the current directory is correct. */
 337   complete_pending_execdirs(AT_FDCWD);
 338   return 0;
 339 }
 340
 341 static void
 342 show_outstanding_execdirs(FILE *fp)
 343 {
 344   if (options.debug_options & DebugExec)
 345     {
 346       int seen=0;
 347       struct predicate *p;
 348       p = get_eval_tree();
 349       fprintf(fp, "Outstanding execdirs:");
 350
 351       while (p)
 352         {
 353           const char *pfx;
 354
 355           if (pred_is(p, pred_execdir))
 356             pfx = "-execdir";
 357           else if (pred_is(p, pred_okdir))
 358             pfx = "-okdir";
 359           else
 360             pfx = NULL;
 361           if (pfx)
 362             {
 363               int i;
 364               const struct exec_val *execp = &p->args.exec_vec;
 365               ++seen;
 366
 367               fprintf(fp, "%s ", pfx);
 368               if (execp->multiple)
 369                 fprintf(fp, "multiple ");
 370               fprintf(fp, "%d args: ", execp->state.cmd_argc);
 371               for (i=0; i<execp->state.cmd_argc; ++i)
 372                 {
 373                   fprintf(fp, "%s ", execp->state.cmd_argv[i]);
 374                 }
 375               fprintf(fp, "\n");
 376             }
 377           p = p->pred_next;
 378         }
 379       if (!seen)
 380         fprintf(fp, " none\n");
 381     }
 382   else
 383     {
 384       /* No debug output is wanted. */
 385     }
 386 }
 387
 388
 389
 390 \f
 391 static void
 392 consider_visiting(FTS *p, FTSENT *ent)
 393 {
 394   struct stat statbuf;
 395   mode_t mode;
 396   int ignore, isdir;
 397
 398   if (options.debug_options & DebugSearch)
 399     fprintf(stderr,
 400             "consider_visiting: fts_info=%-6s, fts_level=%2d, prev_depth=%d "
 401             "fts_path=%s, fts_accpath=%s\n",
 402             get_fts_info_name(ent->fts_info),
 403             (int)ent->fts_level, prev_depth,
 404             quotearg_n_style(0, options.err_quoting_style, ent->fts_path),
 405             quotearg_n_style(1, options.err_quoting_style, ent->fts_accpath));
 406
 407   if (ent->fts_info == FTS_DP)
 408     {
 409       left_dir();
 410     }
 411   else if (ent->fts_level > prev_depth || ent->fts_level==0)
 412     {
 413       left_dir();
 414     }
 415   inside_dir(p->fts_cwd_fd);
 416   prev_depth = ent->fts_level;
 417
 418
 419   /* Cope with various error conditions. */
 420   if (ent->fts_info == FTS_ERR
 421       || ent->fts_info == FTS_DNR)
 422     {
 423       error(0, ent->fts_errno, "%s",
 424             safely_quote_err_filename(0, ent->fts_path));
 425       error_severity(1);
 426       return;
 427     }
 428   else if (ent->fts_info == FTS_DC)
 429     {
 430       issue_loop_warning(ent);
 431       error_severity(1);
 432       return;
 433     }
 434   else if (ent->fts_info == FTS_SLNONE)
 435     {
 436       /* fts_read() claims that ent->fts_accpath is a broken symbolic
 437        * link.  That would be fine, but if this is part of a symbolic
 438        * link loop, we diagnose the problem and also ensure that the
 439        * eventual return value is nonzero.   Note that while the path
 440        * we stat is local (fts_accpath), we print the fill path name
 441        * of the file (fts_path) in the error message.
 442        */
 443       if (symlink_loop(ent->fts_accpath))
 444         {
 445           error(0, ELOOP, "%s", safely_quote_err_filename(0, ent->fts_path));
 446           error_severity(1);
 447           return;
 448         }
 449     }
 450   else if (ent->fts_info == FTS_NS)
 451     {
 452       if (ent->fts_level == 0)
 453         {
 454           /* e.g., nonexistent starting point */
 455           error(0, ent->fts_errno, "%s",
 456                 safely_quote_err_filename(0, ent->fts_path));
 457           error_severity(1);    /* remember problem */
 458           return;
 459         }
 460       else
 461         {
 462           /* The following if statement fixes Savannah bug #19605
 463            * (failure to diagnose a symbolic link loop)
 464            */
 465           if (symlink_loop(ent->fts_accpath))
 466             {
 467               error(0, ELOOP, "%s",
 468                     safely_quote_err_filename(0, ent->fts_path));
 469               error_severity(1);
 470               return;
 471             }
 472         }
 473     }
 474
 475   /* Cope with the usual cases. */
 476   if (ent->fts_info == FTS_NSOK
 477       || ent->fts_info == FTS_NS /* e.g. symlink loop */)
 478     {
 479       assert (!state.have_stat);
 480       assert (!state.have_type);
 481       state.type = mode = 0;
 482     }
 483   else
 484     {
 485       state.have_stat = true;
 486       state.have_type = true;
 487       statbuf = *(ent->fts_statp);
 488       state.type = mode = statbuf.st_mode;
 489
 490       if (00000 == mode)
 491         {
 492           /* Savannah bug #16378. */
 493           error(0, 0, _("Warning: file %s appears to have mode 0000"),
 494                 quotearg_n_style(0, options.err_quoting_style, ent->fts_path));
 495         }
 496     }
 497
 498   if (mode)
 499     {
 500       if (!digest_mode(mode, ent->fts_path, ent->fts_name, &statbuf, 0))
 501         return;
 502     }
 503
 504   /* examine this item. */
 505   ignore = 0;
 506   isdir = S_ISDIR(statbuf.st_mode)
 507     || (FTS_D  == ent->fts_info)
 508     || (FTS_DP == ent->fts_info)
 509     || (FTS_DC == ent->fts_info);
 510
 511   if (isdir && (ent->fts_info == FTS_NSOK))
 512     {
 513       /* This is a directory, but fts did not stat it, so
 514        * presumably would not be planning to search its
 515        * children.  Force a stat of the file so that the
 516        * children can be checked.
 517        */
 518       fts_set(p, ent, FTS_AGAIN);
 519       return;
 520     }
 521
 522   if (options.maxdepth >= 0)
 523     {
 524       if (ent->fts_level >= options.maxdepth)
 525         {
 526           fts_set(p, ent, FTS_SKIP); /* descend no further */
 527
 528           if (ent->fts_level > options.maxdepth)
 529             ignore = 1;         /* don't even look at this one */
 530         }
 531     }
 532
 533   if ( (ent->fts_info == FTS_D) && !options.do_dir_first )
 534     {
 535       /* this is the preorder visit, but user said -depth */
 536       ignore = 1;
 537     }
 538   else if ( (ent->fts_info == FTS_DP) && options.do_dir_first )
 539     {
 540       /* this is the postorder visit, but user didn't say -depth */
 541       ignore = 1;
 542     }
 543   else if (ent->fts_level < options.mindepth)
 544     {
 545       ignore = 1;
 546     }
 547
 548   if (!ignore)
 549     {
 550       visit(p, ent, &statbuf);
 551     }
 552
 553   /* XXX: if we allow a build-up of pending arguments for "-execdir foo {} +"
 554    * we need to execute them in the same directory as we found the item.
 555    * If we are trying to do "find a -execdir echo {} +", we will need to
 556    * echo
 557    *      a while in the original working directory
 558    *      b while in a
 559    *      c while in b (just before leaving b)
 560    *
 561    * These restrictions are hard to satisfy while using fts().   The reason is
 562    * that it doesn't tell us just before we leave a directory.  For the moment,
 563    * we punt and don't allow the arguments to build up.
 564    */
 565   if (state.execdirs_outstanding)
 566     {
 567       show_outstanding_execdirs(stderr);
 568       run_in_dir(p->fts_cwd_fd, complete_execdirs_cb, NULL);
 569     }
 570
 571   if (ent->fts_info == FTS_DP)
 572     {
 573       /* we're leaving a directory. */
 574       state.stop_at_current_level = false;
 575     }
 576 }
 577
 578
 579 \f
 580 static void
 581 find(char *arg)
 582 {
 583   char * arglist[2];
 584   FTS *p;
 585   FTSENT *ent;
 586
 587
 588   state.starting_path_length = strlen(arg);
 589   inside_dir(AT_FDCWD);
 590
 591   arglist[0] = arg;
 592   arglist[1] = NULL;
 593
 594   switch (options.symlink_handling)
 595     {
 596     case SYMLINK_ALWAYS_DEREF:
 597       ftsoptions |= FTS_COMFOLLOW|FTS_LOGICAL;
 598       break;
 599
 600     case SYMLINK_DEREF_ARGSONLY:
 601       ftsoptions |= FTS_COMFOLLOW|FTS_PHYSICAL;
 602       break;
 603
 604     case SYMLINK_NEVER_DEREF:
 605       ftsoptions |= FTS_PHYSICAL;
 606       break;
 607     }
 608
 609   if (options.stay_on_filesystem)
 610     ftsoptions |= FTS_XDEV;
 611
 612   p = fts_open(arglist, ftsoptions, NULL);
 613   if (NULL == p)
 614     {
 615       error (0, errno, _("cannot search %s"),
 616              safely_quote_err_filename(0, arg));
 617     }
 618   else
 619     {
 620       while ( (ent=fts_read(p)) != NULL )
 621         {
 622           state.have_stat = false;
 623           state.have_type = false;
 624           state.type = 0;
 625           consider_visiting(p, ent);
 626         }
 627       fts_close(p);
 628       p = NULL;
 629     }
 630 }
 631
 632
 633 static void
 634 process_all_startpoints(int argc, char *argv[])
 635 {
 636   int i;
 637
 638   /* figure out how many start points there are */
 639   for (i = 0; i < argc && !looks_like_expression(argv[i], true); i++)
 640     {
 641       state.starting_path_length = strlen(argv[i]); /* TODO: is this redundant? */
 642       find(argv[i]);
 643     }
 644
 645   if (i == 0)
 646     {
 647       /*
 648        * We use a temporary variable here because some actions modify
 649        * the path temporarily.  Hence if we use a string constant,
 650        * we get a coredump.  The best example of this is if we say
 651        * "find -printf %H" (note, not "find . -printf %H").
 652        */
 653       char defaultpath[2] = ".";
 654       find(defaultpath);
 655     }
 656 }
 657
 658
 659
 660 \f
 661 int
 662 main (int argc, char **argv)
 663 {
 664   int end_of_leading_options = 0; /* First arg after any -H/-L etc. */
 665   struct predicate *eval_tree;
 666
 667   program_name = argv[0];
 668   state.exit_status = 0;
 669   state.execdirs_outstanding = false;
 670   state.cwd_dir_fd = AT_FDCWD;
 671
 672   /* Set the option defaults before we do the locale initialisation as
 673    * check_nofollow() needs to be executed in the POSIX locale.
 674    */
 675   set_option_defaults(&options);
 676
 677 #ifdef HAVE_SETLOCALE
 678   setlocale (LC_ALL, "");
 679 #endif
 680
 681   bindtextdomain (PACKAGE, LOCALEDIR);
 682   textdomain (PACKAGE);
 683   atexit (close_stdout);
 684
 685   /* Check for -P, -H or -L options.  Also -D and -O, which are
 686    * both GNU extensions.
 687    */
 688   end_of_leading_options = process_leading_options(argc, argv);
 689
 690   if (options.debug_options & DebugStat)
 691     options.xstat = debug_stat;
 692
 693 #ifdef DEBUG
 694   fprintf (stderr, "cur_day_start = %s", ctime (&options.cur_day_start));
 695 #endif /* DEBUG */
 696
 697
 698   /* We are now processing the part of the "find" command line
 699    * after the -H/-L options (if any).
 700    */
 701   eval_tree = build_expression_tree(argc, argv, end_of_leading_options);
 702
 703   /* safely_chdir() needs to check that it has ended up in the right place.
 704    * To avoid bailing out when something gets automounted, it checks if
 705    * the target directory appears to have had a directory mounted on it as
 706    * we chdir()ed.  The problem with this is that in order to notice that
 707    * a file system was mounted, we would need to lstat() all the mount points.
 708    * That strategy loses if our machine is a client of a dead NFS server.
 709    *
 710    * Hence if safely_chdir() and wd_sanity_check() can manage without needing
 711    * to know the mounted device list, we do that.
 712    */
 713   if (!options.open_nofollow_available)
 714     {
 715 #ifdef STAT_MOUNTPOINTS
 716       init_mounted_dev_list();
 717 #endif
 718     }
 719
 720
 721   starting_desc = open (".", O_RDONLY
 722 #if defined O_LARGEFILE
 723                         |O_LARGEFILE
 724 #endif
 725                         );
 726   if (0 <= starting_desc && fchdir (starting_desc) != 0)
 727     {
 728       close (starting_desc);
 729       starting_desc = -1;
 730     }
 731   if (starting_desc < 0)
 732     {
 733       starting_dir = xgetcwd ();
 734       if (! starting_dir)
 735         error (1, errno, _("cannot get current directory"));
 736     }
 737
 738
 739   process_all_startpoints(argc-end_of_leading_options, argv+end_of_leading_options);
 740
 741   /* If "-exec ... {} +" has been used, there may be some
 742    * partially-full command lines which have been built,
 743    * but which are not yet complete.   Execute those now.
 744    */
 745   show_success_rates(eval_tree);
 746   cleanup();
 747   return state.exit_status;
 748 }
 749
 750 boolean
 751 is_fts_enabled(int *fts_options)
 752 {
 753   /* this version of find (i.e. this main()) uses fts. */
 754   *fts_options = ftsoptions;
 755   return true;
 756 }