Merge pull request #1038 from majestrate/dht-disable-iterative-lookup-2020-01-14

disable iterative behavior in DHT

contrib/testnet/genconf.py

@@ -37,7 +37,6 @@ def main():
         exe = 'valgrind {}'.format(args.bin)
     else:
         exe = args.bin
-        
     basedir = os.path.abspath(args.dir)
 
     for nodeid in range(args.svc):
@@ -108,7 +107,7 @@ def main():
         fp = os.path.join(d, 'client.ini')
         with open(fp, 'w') as f:
             config.write(f)
-            for n in range(args.connect):
+            for n in [0]:
                 otherID = (n + nodeid) % args.svc
                 f.write("[bootstrap]\nadd-node={}\n".format(os.path.join(basedir,svcNodeName(otherID), 'rc.signed')))
         with open(hiddenservice, 'w') as f:

llarp/context.cpp

@@ -183,16 +183,6 @@ __        ___    ____  _   _ ___ _   _  ____
       llarp::LogError("nodedb_dir is incorrect");
       return 0;
     }
-    // llarp::LogInfo("nodedb_dir [", nodedb_dir, "] configured!");
-    ssize_t loaded = nodedb->load_dir(nodedb_dir.c_str());
-    llarp::LogInfo("nodedb_dir loaded ", loaded, " RCs from [", nodedb_dir,
-                   "]");
-    if(loaded < 0)
-    {
-      // shouldn't be possible
-      llarp::LogError("nodedb_dir directory doesn't exist");
-      return 0;
-    }
     return 1;
   }
 
@@ -211,7 +201,7 @@ __        ___    ____  _   _ ___ _   _  ____
 
     router = std::make_unique< Router >(worker, mainloop, logic);
 
-    nodedb = std::make_unique< llarp_nodedb >(router->diskworker());
+    nodedb = std::make_unique< llarp_nodedb >(router->diskworker(), nodedb_dir);
 
     if(!router->Configure(config.get(), nodedb.get()))
     {

llarp/dht/context.cpp

@@ -20,7 +20,7 @@
 #include <util/thread/logic.hpp>
 #include <nodedb.hpp>
 #include <profiling.hpp>
-
+#include <router/i_rc_lookup_handler.hpp>
 #include <vector>
 
 namespace llarp
@@ -41,7 +41,7 @@ namespace llarp
       void
       StoreRC(const RouterContact rc) const override
       {
-        GetRouter()->nodedb()->InsertAsync(rc);
+        GetRouter()->rcLookupHandler().CheckRC(rc);
       }
 
       /// on behalf of whoasked request introset for target from dht router with

llarp/dht/localrouterlookup.cpp

@@ -43,7 +43,11 @@ namespace llarp
             found = rc;
         }
         valuesFound.clear();
-        valuesFound.emplace_back(found);
+        if(not found.pubkey.IsZero())
+        {
+          valuesFound.resize(1);
+          valuesFound[0] = found;
+        }
       }
       routing::DHTMessage msg;
       msg.M.emplace_back(new GotRouterMessage(parent->OurKey(), whoasked.txid,

llarp/dht/messages/findrouter.cpp

@@ -167,7 +167,12 @@ namespace llarp
         return false;
       }
       RouterContact found;
-      const Key_t k{K};
+      if(K.IsZero())
+      {
+        llarp::LogError("invalid FRM from ", From, "K is zero");
+        return false;
+      }
+      const Key_t k(K);
       if(exploritory)
         return dht.HandleExploritoryRouterLookup(From, txid, K, replies);
       if(!dht.GetRouter()->ConnectionToRouterAllowed(K))

llarp/dht/messages/gotrouter.cpp

@@ -4,6 +4,7 @@
 #include <memory>
 #include <path/path_context.hpp>
 #include <router/abstractrouter.hpp>
+#include <router/i_rc_lookup_handler.hpp>
 
 namespace llarp
 {
@@ -112,12 +113,19 @@ namespace llarp
         LogDebug("got ", R.size(), " results in GRM for lookup");
         if(R.size() == 0)
           dht.pendingRouterLookups().NotFound(owner, K);
+        else if(R[0].pubkey.IsZero())
+          return false;
         else
           dht.pendingRouterLookups().Found(owner, R[0].pubkey, R);
         return true;
       }
-      llarp::LogWarn("Unwarranted GRM from ", From, " txid=", txid);
+      // store if valid
-      return false;
+      for(const auto &rc : R)
+      {
+        if(not dht.GetRouter()->rcLookupHandler().CheckRC(rc))
+          return false;
+      }
+      return true;
     }
   }  // namespace dht
 }  // namespace llarp

llarp/dht/messages/gotrouter.hpp

@@ -18,8 +18,9 @@ namespace llarp
       {
       }
       GotRouterMessage(const Key_t& from, uint64_t id,
-                       std::vector< RouterContact > results, bool tunneled)
+                       const std::vector< RouterContact >& results,
-          : IMessage(from), R(std::move(results)), txid(id), relayed(tunneled)
+                       bool tunneled)
+          : IMessage(from), R(results), txid(id), relayed(tunneled)
       {
       }
 

llarp/dht/recursiverouterlookup.cpp

@@ -3,6 +3,10 @@
 #include <dht/context.hpp>
 #include <dht/messages/findrouter.hpp>
 #include <dht/messages/gotrouter.hpp>
+
+#include <router/abstractrouter.hpp>
+#include <router/i_rc_lookup_handler.hpp>
+
 #include <utility>
 
 namespace llarp
@@ -42,6 +46,7 @@ namespace llarp
     void
     RecursiveRouterLookup::DoNextRequest(const Key_t &peer)
     {
+      peersAsked.emplace(peer);
       parent->LookupRouterRecursive(target, whoasked.node, whoasked.txid, peer,
                                     resultHandler);
     }
@@ -49,6 +54,7 @@ namespace llarp
     void
     RecursiveRouterLookup::Start(const TXOwner &peer)
     {
+      peersAsked.emplace(peer.node);
       parent->DHTSendTo(peer.node.as_array(),
                         new FindRouterMessage(peer.txid, target));
     }
@@ -61,7 +67,8 @@ namespace llarp
         RouterContact found;
         for(const auto &rc : valuesFound)
         {
-          if(found.OtherIsNewer(rc))
+          if(found.OtherIsNewer(rc)
+             && parent->GetRouter()->rcLookupHandler().CheckRC(rc))
             found = rc;
         }
         valuesFound.clear();
@@ -77,9 +84,6 @@ namespace llarp
             whoasked.node.as_array(),
             new GotRouterMessage({}, whoasked.txid, valuesFound, false), false);
       }
-      // store this in our nodedb for caching
-      if(valuesFound.size() > 0)
-        parent->StoreRC(valuesFound[0]);
     }
   }  // namespace dht
 }  // namespace llarp

llarp/dht/txholder.hpp

@@ -138,10 +138,7 @@ namespace llarp
       {
         return;
       }
-
+      Inform(from, txitr->second->target, {}, true, true);
-      // ask for next peer
-      if(!txitr->second->AskNextPeer(from.node, next))
-        Inform(from, txitr->second->target, {}, true, true);
     }
 
     template < typename K, typename V, typename K_Hash >

llarp/nodedb.cpp

@@ -459,22 +459,10 @@ llarp_nodedb::ensure_dir(const char *dir)
   return true;
 }
 
-void
-llarp_nodedb::set_dir(const char *dir)
-{
-  nodePath = dir;
-}
-
 ssize_t
-llarp_nodedb::load_dir(const char *dir)
+llarp_nodedb::LoadAll()
 {
-  std::error_code ec;
+  return Load(nodePath.c_str());
-  if(!fs::exists(dir, ec))
-  {
-    return -1;
-  }
-  set_dir(dir);
-  return Load(dir);
 }
 
 size_t

llarp/nodedb.hpp

@@ -40,8 +40,10 @@ struct llarp_nodedb_iter
 
 struct llarp_nodedb
 {
-  explicit llarp_nodedb(std::shared_ptr< llarp::thread::ThreadPool > diskworker)
+  explicit llarp_nodedb(std::shared_ptr< llarp::thread::ThreadPool > diskworker,
-      : disk(std::move(diskworker))
+                        const std::string rootdir)
+      : disk(std::move(diskworker)), nodePath(rootdir)
+
   {
   }
 
@@ -136,7 +138,8 @@ struct llarp_nodedb
   set_dir(const char *dir);
 
   ssize_t
-  load_dir(const char *dir);
+  LoadAll();
+
   ssize_t
   store_dir(const char *dir);
 

llarp/path/path_context.cpp

@@ -39,12 +39,16 @@ namespace llarp
     bool
     PathContext::CheckPathLimitHitByIP(const llarp::Addr& ip)
     {
+#ifdef TESTNET
+      return false;
+#else
       llarp::Addr remote = ip;
       // set port to zero
       remote.port(0);
       // try inserting remote address by ip into decaying hash set
       // if it cannot insert it has hit a limit
       return not m_PathLimits.Insert(remote);
+#endif
     }
 
     std::shared_ptr< Logic >

llarp/router/i_rc_lookup_handler.hpp

@@ -37,7 +37,8 @@ namespace llarp
     SetRouterWhitelist(const std::vector< RouterID > &routers) = 0;
 
     virtual void
-    GetRC(const RouterID &router, RCRequestCallback callback) = 0;
+    GetRC(const RouterID &router, RCRequestCallback callback,
+          bool forceLookup = false) = 0;
 
     virtual bool
     RemoteIsAllowed(const RouterID &remote) const = 0;

llarp/router/rc_lookup_handler.cpp

@@ -10,6 +10,7 @@
 #include <util/thread/threading.hpp>
 #include <nodedb.hpp>
 #include <dht/context.hpp>
+#include <router/abstractrouter.hpp>
 
 #include <iterator>
 #include <functional>
@@ -48,20 +49,22 @@ namespace llarp
   }
 
   void
-  RCLookupHandler::GetRC(const RouterID &router, RCRequestCallback callback)
+  RCLookupHandler::GetRC(const RouterID &router, RCRequestCallback callback,
+                         bool forceLookup)
   {
     RouterContact remoteRC;
-
+    if(not forceLookup)
-    if(_nodedb->Get(router, remoteRC))
     {
-      if(callback)
+      if(_nodedb->Get(router, remoteRC))
       {
-        callback(router, &remoteRC, RCRequestResult::Success);
+        if(callback)
+        {
+          callback(router, &remoteRC, RCRequestResult::Success);
+        }
+        FinalizeRequest(router, &remoteRC, RCRequestResult::Success);
+        return;
       }
-      FinalizeRequest(router, &remoteRC, RCRequestResult::Success);
-      return;
     }
-
     bool shouldDoLookup = false;
 
     {
@@ -212,7 +215,7 @@ namespace llarp
 
     for(const auto &router : routersToLookUp)
     {
-      GetRC(router, nullptr);
+      GetRC(router, nullptr, true);
     }
 
     _nodedb->RemoveStaleRCs(_bootstrapRouterIDList,
@@ -235,6 +238,26 @@ namespace llarp
       LogError("we have no bootstrap nodes specified");
     }
 
+    if(useWhitelist)
+    {
+      std::set< RouterID > lookupRouters;
+      {
+        static constexpr size_t LookupPerTick = 25;
+        // if we are using a whitelist look up a few routers we don't have
+        util::Lock l(&_mutex);
+        for(const auto &r : whitelistRouters)
+        {
+          if(_nodedb->Has(r))
+            continue;
+          lookupRouters.emplace(r);
+          if(lookupRouters.size() >= LookupPerTick)
+            break;
+        }
+      }
+      for(const auto &r : lookupRouters)
+        GetRC(r, nullptr, true);
+      return;
+    }
     // TODO: only explore via random subset
     // explore via every connected peer
     _linkManager->ForEachPeer([&](ILinkSession *s) {

llarp/router/rc_lookup_handler.hpp

@@ -41,8 +41,8 @@ namespace llarp
         LOCKS_EXCLUDED(_mutex);
 
     void
-    GetRC(const RouterID &router, RCRequestCallback callback) override
+    GetRC(const RouterID &router, RCRequestCallback callback,
-        LOCKS_EXCLUDED(_mutex);
+          bool forceLookup = false) override LOCKS_EXCLUDED(_mutex);
 
     bool
     RemoteIsAllowed(const RouterID &remote) const override

llarp/router/router.cpp

@@ -696,18 +696,9 @@ namespace llarp
     {
       connected += _linkManager.NumberOfPendingConnections();
     }
-    const size_t N = nodedb()->num_loaded();
-    if(N < llarp::path::default_len)
-    {
-      LogInfo("We need at least ", llarp::path::default_len,
-              " service nodes to build paths but we have ", N, " in nodedb");
 
-      _rcLookupHandler.ExploreNetwork();
+    _rcLookupHandler.ExploreNetwork();
-    }
+
-    else if(isSvcNode)
-    {
-      _rcLookupHandler.ExploreNetwork();
-    }
     size_t connectToNum      = _outboundSessionMaker.minConnectedRouters;
     const auto strictConnect = _rcLookupHandler.NumberOfStrictConnectRouters();
     if(strictConnect > 0 && connectToNum > strictConnect)
@@ -1019,6 +1010,16 @@ namespace llarp
       return false;
     }
 
+    {
+      ssize_t loaded = _nodedb->LoadAll();
+      llarp::LogInfo("loaded ", loaded, " RCs");
+      if(loaded < 0)
+      {
+        // shouldn't be possible
+        return false;
+      }
+    }
+
     llarp_dht_context_start(dht(), pubkey());
 
     for(const auto &rc : bootstrapRCList)

llarp/router_contact.cpp

@@ -334,7 +334,7 @@ namespace llarp
     }
     if(!VerifySignature())
     {
-      llarp::LogError("invalid signature");
+      llarp::LogError("invalid signature: ", *this);
       return false;
     }
     return true;

llarp/service/endpoint.cpp

@@ -733,11 +733,11 @@ namespace llarp
     {
       if(msg->R.size())
       {
-        auto* job         = new llarp_async_verify_rc;
+        llarp_async_verify_rc* job = new llarp_async_verify_rc();
-        job->nodedb       = Router()->nodedb();
+        job->nodedb                = Router()->nodedb();
-        job->cryptoworker = Router()->threadpool();
+        job->cryptoworker          = Router()->threadpool();
-        job->diskworker   = Router()->diskworker();
+        job->diskworker            = Router()->diskworker();
-        job->logic        = Router()->logic();
+        job->logic                 = Router()->logic();
         job->hook = std::bind(&Endpoint::HandleVerifyGotRouter, this, msg,
                               std::placeholders::_1);
         job->rc   = msg->R[0];