fixed searchpath based dns lookups

Author: EmielBruijntjes

include/dnscpp/context.h

@@ -38,6 +38,15 @@ class SearchLookupHandler;
  */
 class Context : private Core
 {
+private:
+    /**
+     *  Should the search path be respected?
+     *  @param  domain      the domain to lookup
+     *  @param  handler     handler that is already in use
+     *  @return bool
+     */
+    bool searchable(const char *domain, DNS::Handler *handler) const;
+
 public:
     /**
      *  Constructor

src/context.cpp

@@ -42,6 +42,33 @@ void Context::capacity(size_t value)
     _capacity = std::min((size_t)IdGenerator::capacity(), std::max(size_t(1), value));
 }
 
+/**
+ *  Should the search path be respected?
+ *  @param  domain      the domain to lookup
+ *  @param  handler     handler that is already in use
+ *  @return bool
+ */
+bool Context::searchable(const char *domain, DNS::Handler *handler) const
+{
+    // length of the lookup
+    size_t length = strlen(domain);
+    
+    // empty domains fail anyway
+    if (length == 0) return false;
+    
+    // canonical domains don't go into recursion
+    if (domain[length-1] == '.') return false;
+    
+    // count the dots
+    size_t ndots = std::count(domain, domain + length + 1, '.');
+    
+    // compare with the 'ndots' setting
+    if (ndots >= _ndots) return false;
+    
+    // do not do recursion (if the current handler already is a SearchLookup)
+    return dynamic_cast<SearchLookup*>(handler) == nullptr;
+}
+
 /**
  *  Do a dns lookup
  *  @param  domain      the record name to look for
@@ -52,13 +79,9 @@ void Context::capacity(size_t value)
  */
 Operation *Context::query(const char *domain, ns_type type, const Bits &bits, DNS::Handler *handler)
 {
-    // count the dots
-    size_t ndots = std::count(domain, domain + strlen(domain) + 1, '.');
-
-    // if the searchpath contains less then ndots dots, and we are not already wrapped
-    // we wrap the call in a searchlookuphandler, to retry the call with the appended searchpaths
-    if (!dynamic_cast<SearchLookup*>(handler) && ndots < _ndots && !_searchpaths.empty()) return new SearchLookup(this, type, bits, domain, handler);
-
+    // check if we should respect the search path
+    if (searchable(domain, handler)) return new SearchLookup(this, type, bits, domain, handler);
+    
     // for A and AAAA lookups we also check the /etc/hosts file
     if (type == ns_t_a    && _hosts.lookup(domain, 4)) return add(new LocalLookup(this, _hosts, domain, type, handler));
     if (type == ns_t_aaaa && _hosts.lookup(domain, 6)) return add(new LocalLookup(this, _hosts, domain, type, handler));
@@ -76,6 +99,8 @@ Operation *Context::query(const char *domain, ns_type type, const Bits &bits, DN
     }
 }
 
+
+
 /**
  *  Do a reverse IP lookup, this is only meaningful for PTR lookups
  *  @param  ip          the ip address to lookup

src/searchlookup.h

@@ -122,38 +122,51 @@ class SearchLookup : public DNS::Operation, public DNS::Handler
      */
     bool proceed()
     {
+        // do nothing if we already have exhausted all calls
+        if (_index == size_t(-1)) return false;
+
         // shortcut to the search-paths
         const auto &searchpaths = _context->searchpaths();
 
         // if there are no more paths left, return false
-        if (_index >= searchpaths.size()) return false;
+        if (_index >= searchpaths.size()) return finalize();
 
         // the next path to check
         const auto &nextdomain = searchpaths[_index++];
 
         // for empty domains we do not need to concatenate
-        if (nextdomain.empty())
-        {
-            // start a lookup for just the requested domain
-            _operation = _context->query(_basedomain.c_str(), _type, _bits, this);
-        }
-        else
-        {
-            // create a string to hold the next domain, and fill it with the user-domain
-            std::string nextdomain(_basedomain);
-
-            // add a . and the searchpath
-            nextdomain.append(".").append(nextdomain);
-
-            // perform dns-query on the constructed path
-            // and save the operation so we can cancell it if requested
-            _operation = _context->query(nextdomain.c_str(), _type, _bits, this);
-        }
+        if (nextdomain.empty()) return finalize();
+
+        // create a string to hold the next domain, and fill it with the user-domain
+        std::string nexthost(_basedomain);
+
+        // add a . and the searchpath
+        nexthost.append(".").append(nextdomain);
+
+        // perform dns-query on the constructed path
+        // and save the operation so we can cancell it if requested
+        _operation = _context->query(nexthost.c_str(), _type, _bits, this);
 
         // return success
         return true;
     }
 
+    /**
+     *  Do the ultimate, final lookup
+     *  @return bool
+     */
+    bool finalize()
+    {
+        // start a lookup for just the requested domain
+        _operation = _context->query(_basedomain.c_str(), _type, _bits, this);
+        
+        // update index to prevent loops
+        _index = size_t(-1);
+        
+        // still busy
+        return true;
+    }
+
     /**
      *  Private destructor because this is a self-destructing object
      */