Support detecting inaccessible/dangling entries in dir_iterator, path_search()

5 files changed, 93 insertions, 15 deletions

diff --git a/tests/dir-iterator/driver.cxx b/tests/dir-iterator/driver.cxx
index 4a2ff53..92b0b57 100644
--- a/tests/dir-iterator/driver.cxx
+++ b/tests/dir-iterator/driver.cxx
@@ -26,7 +26,7 @@ operator<< (ostream& os, entry_type e)
   return os << entry_type_string[static_cast<size_t> (e)];
 }
 
-// Usage: argv[0] [-v] [-i] <dir>
+// Usage: argv[0] [-v] [-i|-d] <dir>
 //
 // Iterates over a directory filesystem sub-entries, obtains their types and
 // target types for symlinks.
@@ -45,6 +45,7 @@ main (int argc, const char* argv[])
 
   bool verbose (false);
   bool ignore_dangling (false);
+  bool detect_dangling (false);
 
   int i (1);
   for (; i != argc; ++i)
@@ -55,6 +56,8 @@ main (int argc, const char* argv[])
       verbose = true;
     else if (v == "-i")
       ignore_dangling = true;
+    else if (v == "-d")
+      detect_dangling = true;
     else
       break;
   }
@@ -65,11 +68,17 @@ main (int argc, const char* argv[])
     return 1;
   }
 
+  assert (!ignore_dangling || !detect_dangling);
+
   const char* d (argv[i]);
 
   try
   {
-    for (const dir_entry& de: dir_iterator (dir_path (d), ignore_dangling))
+    for (const dir_entry& de:
+           dir_iterator (dir_path (d),
+                         (ignore_dangling ? dir_iterator::ignore_dangling :
+                          detect_dangling ? dir_iterator::detect_dangling :
+                                            dir_iterator::no_follow)))
     {
       entry_type lt (de.ltype ());
       entry_type t (lt == entry_type::symlink ? de.type () : lt);
diff --git a/tests/dir-iterator/testscript b/tests/dir-iterator/testscript
index 30cf6d7..9ecc58b 100644
--- a/tests/dir-iterator/testscript
+++ b/tests/dir-iterator/testscript
@@ -54,6 +54,12 @@ if ($test.target == $build.host)
 
       $*    ../wd >- 2>! != 0 : keep
       $* -i ../wd >'reg     f': skip
+
+      : detect
+      :
+      $* -d ../wd >>~%EOO%
+        %(reg     f|sym unk l)%{2}
+        EOO
     }
 
     : dir
@@ -71,6 +77,12 @@ if ($test.target == $build.host)
 
       $*    ../wd >- 2>! != 0 : keep
       $* -i ../wd >'dir     d': skip
+
+      : detect
+      :
+      $* -d ../wd >>~%EOO%
+        %(dir     d|sym unk l)%{2}
+        EOO
     }
   }
 
@@ -89,5 +101,11 @@ if ($test.target == $build.host)
 
     $*    ../wd >- 2>! != 0 : keep
     $* -i ../wd >'dir     d': skip
+
+      : detect
+      :
+      $* -d ../wd >>~%EOO%
+        %(dir     d|sym unk l)%{2}
+        EOO
   }
 }
diff --git a/tests/link/driver.cxx b/tests/link/driver.cxx
index db9c195..b659838 100644
--- a/tests/link/driver.cxx
+++ b/tests/link/driver.cxx
@@ -107,11 +107,11 @@ link_dir (const dir_path& target,
   dir_path tp (target.absolute () ? target : link.directory () / target);
 
   set<pair<entry_type, path>> te;
-  for (const dir_entry& de: dir_iterator (tp, false /* ignore_dangling */))
+  for (const dir_entry& de: dir_iterator (tp, dir_iterator::no_follow))
     te.emplace (de.ltype (), de.path ());
 
   set<pair<entry_type, path>> le;
-  for (const dir_entry& de: dir_iterator (link, false /* ignore_dangling */))
+  for (const dir_entry& de: dir_iterator (link, dir_iterator::no_follow))
     le.emplace (de.ltype (), de.path ());
 
   return te == le;
@@ -306,7 +306,7 @@ main (int argc, const char* argv[])
     assert (pe.first && pe.second.type == entry_type::directory);
   }
 
-  for (const dir_entry& de: dir_iterator (td, false /* ignore_dangling */))
+  for (const dir_entry& de: dir_iterator (td, dir_iterator::no_follow))
   {
     assert (de.path () != path ("dslink") ||
             (de.type () == entry_type::directory &&
@@ -368,7 +368,9 @@ main (int argc, const char* argv[])
   {
     mksymlink (dp / "non-existing", dp / "lnk");
     assert (!dir_empty (dp));
-    assert (dir_iterator (dp, true /* ignore_dangling */) == dir_iterator ());
+
+    assert (dir_iterator (dp, dir_iterator::ignore_dangling) ==
+            dir_iterator ());
   }
   catch (const system_error& e)
   {
@@ -393,10 +395,10 @@ main (int argc, const char* argv[])
 
   mksymlink  (dp / "non-existing", dp / "lnk1", true /* dir */);
   assert (!dir_empty (dp));
-  assert (dir_iterator (dp, true /* ignore_dangling */) == dir_iterator ());
+  assert (dir_iterator (dp, dir_iterator::ignore_dangling) == dir_iterator ());
 
   mksymlink  (tgd, dp / "lnk2", true /* dir */);
-  assert (dir_iterator (dp, true /* ignore_dangling */) != dir_iterator ());
+  assert (dir_iterator (dp, dir_iterator::ignore_dangling) != dir_iterator ());
 
   rmdir_r (dp);
   assert (dir_exists (tgd));
diff --git a/tests/wildcard/driver.cxx b/tests/wildcard/driver.cxx
index 9419a79..fee2748 100644
--- a/tests/wildcard/driver.cxx
+++ b/tests/wildcard/driver.cxx
@@ -4,11 +4,14 @@
 #include <map>
 #include <string>
 #include <vector>
-#include <algorithm> // sort()
-#include <exception>
 #include <iostream>
+#include <algorithm>    // sort()
+#include <exception>
+#include <functional>
+#include <system_error>
 
 #include <libbutl/path.hxx>
+#include <libbutl/path-io.hxx>
 #include <libbutl/utility.hxx>      // operator<<(ostream, exception)
 #include <libbutl/optional.hxx>
 #include <libbutl/filesystem.hxx>
@@ -59,8 +62,13 @@ int _CRT_glob = 0;
 //    through contains only the specified entry. The start directory is used if
 //    the first pattern component is a self-matching wildcard.
 //
+// -d (print|stop)
+//    If a inaccessible/dangling link is encountered, then print its path to
+//    stderr and, optionally, stop the search. Meaningful in combination with
+//    -sd and must follow it, if specified in the command line.
+//
 // -i
-//    Pass psflags::ignorable_components to the match/search functions.
+//    Pass path_match_flags::match_absent to the match/search functions.
 //    Meaningful in combination with -sd or -sp options and must follow it, if
 //    specified in the command line.
 //
@@ -93,6 +101,9 @@ try
     bool sort (true);
     path_match_flags flags (path_match_flags::follow_symlinks);
 
+    bool dangle_stop (false);
+    function<bool (const dir_entry&)> dangle_func;
+
     int i (2);
     for (; i != argc; ++i)
     {
@@ -101,6 +112,34 @@ try
         sort = false;
       else if (o == "-i")
         flags |= path_match_flags::match_absent;
+      else if (o == "-d")
+      {
+        ++i;
+
+        assert (op == "-sd" && i != argc);
+
+        string v (argv[i]);
+
+        if (v == "print")
+        {
+          dangle_func = [] (const dir_entry& de)
+          {
+            cerr << de.base () / de.path () << endl;
+            return true;
+          };
+        }
+        else if (v == "stop")
+        {
+          dangle_func = [&dangle_stop] (const dir_entry& de)
+          {
+            cerr << de.base () / de.path () << endl;
+            dangle_stop = true;
+            return false;
+          };
+        }
+        else
+          assert (false);
+      }
       else
         break; // End of options.
     }
@@ -166,10 +205,13 @@ try
     };
 
     if (!entry)
-      path_search (pattern, add, start, flags);
+      path_search (pattern, add, start, flags, dangle_func);
     else
       path_search (pattern, *entry, add, start, flags);
 
+    if (dangle_stop)
+      return 1;
+
     // It the search succeeds, then test search in the directory tree
     // represented by each matched path. Otherwise, if the directory tree is
     // specified, then make sure that it doesn't match the pattern.
@@ -230,8 +272,13 @@ catch (const invalid_path& e)
   cerr << e << ": " << e.path << endl;
   return 2;
 }
+catch (const system_error& e)
+{
+  cerr << e << endl;
+  return 3;
+}
 catch (const exception& e)
 {
   cerr << e << endl;
-  return 2;
+  return 4;
 }
diff --git a/tests/wildcard/testscript b/tests/wildcard/testscript
index 5f6a767..baa51aa 100644
--- a/tests/wildcard/testscript
+++ b/tests/wildcard/testscript
@@ -650,12 +650,14 @@
   {
     mkdir a;
     touch --no-cleanup a/b;
-    ^ln -s b a/l &a/l;
+    ln -s b a/l &a/l;
     rm a/b;
 
     touch a/c;
 
-    $* a/* >/'a/c'
+    $* a/* 2>! == 3;
+    $* -d 'print' a/* >/'a/c' 2>/'a/l';
+    $* -d 'stop'  a/* >!      2>/'a/l' == 1
   }
 }