Merge pull request #483 from loki-project/staging

Staging

llarp/ev/ev_kqueue.cpp

@@ -24,14 +24,11 @@ namespace llarp
     else
     {
       if(errno == EAGAIN || errno == EWOULDBLOCK)
-      {
-        errno = 0;
-        return 0;
-      }
+        return amount;
       _shouldClose = true;
       return -1;
     }
-    return 0;
+    return amount;
   }
 
   inline void
@@ -376,12 +373,17 @@ llarp_kqueue_loop::tick(int ms)
       {
         if(events[idx].filter & EVFILT_WRITE)
         {
-          ev->flush_write_buffers(events[idx].data);
+          IO([&]() -> ssize_t {
+            ev->flush_write_buffers(events[idx].data);
+            return 0;
+          });
         }
         if(events[idx].filter & EVFILT_READ)
         {
-          ev->read(readbuf,
-                   std::min(sizeof(readbuf), size_t(events[idx].data)));
+          IO([&]() -> ssize_t {
+            return ev->read(readbuf,
+              std::min(sizeof(readbuf), size_t(events[idx].data)));
+          });
         }
       }
       ++idx;

llarp/link/server.cpp

@@ -34,15 +34,33 @@ namespace llarp
 
   void
   ILinkLayer::ForEachSession(
-      std::function< void(const ILinkSession*) > visit) const
+    std::function< void(const ILinkSession*) > visit, bool randomize) const
   {
     Lock l(&m_AuthedLinksMutex);
+    if(m_AuthedLinks.size() == 0)
+      return;
+    const size_t sz = randint() % m_AuthedLinks.size();
     auto itr = m_AuthedLinks.begin();
+    auto begin = itr;
+    if(randomize)
+    {
+      std::advance(itr, sz);
+      begin = itr;
+    }
     while(itr != m_AuthedLinks.end())
     {
       visit(itr->second.get());
       ++itr;
     }
+    if(randomize)
+    {
+      itr = m_AuthedLinks.begin();
+      while(itr != begin)
+      {
+        visit(itr->second.get());
+        ++itr;
+      }
+    }
   }
 
   bool

llarp/link/server.hpp

@@ -71,7 +71,7 @@ namespace llarp
     HasSessionVia(const Addr& addr);
 
     void
-    ForEachSession(std::function< void(const ILinkSession*) > visit) const
+    ForEachSession(std::function< void(const ILinkSession*) > visit, bool randomize=false) const
         LOCKS_EXCLUDED(m_AuthedLinksMutex);
 
     void

llarp/path/pathbuilder.cpp

@@ -207,11 +207,20 @@ namespace llarp
                        RouterContact& cur, size_t hop, PathRole roles)
     {
       (void)roles;
-      if(hop == 0)
-        return router->NumberOfConnectedRouters()
-            && router->GetRandomConnectedRouter(cur);
-
       size_t tries                 = 10;
+      if(hop == 0)
+      {
+        if(router->NumberOfConnectedRouters() == 0)
+          return false;
+        bool got = false;
+        router->ForEachPeer([&](const ILinkSession * s, bool ) {
+                              if(got || router->IsBootstrapNode(s->GetPubKey()))
+                                return;
+                              cur = s->GetRemoteRC();
+                              got = true;
+                            }, true);
+        return got;
+      }
       std::set< RouterID > exclude = {prev.pubkey};
       do
       {

llarp/router/abstractrouter.hpp

@@ -115,6 +115,9 @@ namespace llarp
     virtual void
     Stop() = 0;
 
+    virtual bool
+    IsBootstrapNode(RouterID r) const = 0;
+    
     virtual const byte_t *
     pubkey() const = 0;
 
@@ -185,7 +188,7 @@ namespace llarp
     /// visit each connected link session
     virtual void
     ForEachPeer(
-        std::function< void(const ILinkSession *, bool) > visit) const = 0;
+      std::function< void(const ILinkSession *, bool) > visit, bool randomize) const = 0;
   };
 }  // namespace llarp
 

llarp/router/router.cpp

@@ -375,17 +375,17 @@ namespace llarp
 
   void
   Router::ForEachPeer(
-      std::function< void(const ILinkSession *, bool) > visit) const
+    std::function< void(const ILinkSession *, bool) > visit, bool randomize) const
   {
     for(const auto &link : outboundLinks)
     {
       link->ForEachSession(
-          [visit](const ILinkSession *peer) { visit(peer, true); });
+        [visit](const ILinkSession *peer) { visit(peer, true); }, randomize);
     }
     for(const auto &link : inboundLinks)
     {
       link->ForEachSession(
-          [visit](const ILinkSession *peer) { visit(peer, false); });
+        [visit](const ILinkSession *peer) { visit(peer, false); }, randomize);
     }
   }
 
@@ -1044,6 +1044,17 @@ namespace llarp
     ep->LookupRouterAnon(remote);
   }
 
+  bool
+  Router::IsBootstrapNode(RouterID r) const
+  {
+    for(const auto & rc : bootstrapRCList)
+    {
+      if(rc.pubkey == r)
+        return true;
+    }
+    return false;
+  }
+  
   void
   Router::Tick()
   {
@@ -1132,11 +1143,14 @@ namespace llarp
       else
         LogError("we have no bootstrap nodes specified");
     }
-    if(connected < minConnectedRouters)
+    else
     {
-      size_t dlt = minConnectedRouters - connected;
-      LogInfo("connecting to ", dlt, " random routers to keep alive");
-      ConnectToRandomRouters(dlt);
+      if(connected < minConnectedRouters)
+      {
+        size_t dlt = minConnectedRouters - connected;
+        LogInfo("connecting to ", dlt, " random routers to keep alive");
+        ConnectToRandomRouters(dlt);
+      }
     }
 
     if(!IsServiceNode())
@@ -1478,9 +1492,11 @@ namespace llarp
       LogInfo("initalized service node: ", us);
       if(minConnectedRouters < 6)
         minConnectedRouters = 6;
+      
     }
     else
     {
+      maxConnectedRouters = minConnectedRouters + 1;
       // we are a client
       // regenerate keys and resign rc before everything else
       crypto()->identity_keygen(_identity);
@@ -1660,6 +1676,11 @@ namespace llarp
          && !(self->HasSessionTo(other.pubkey)
               || self->HasPendingConnectJob(other.pubkey)))
       {
+        for(const auto & rc : self->bootstrapRCList)
+        {
+          if(rc.pubkey == other.pubkey)
+            return want > 0;
+        }
         self->TryConnectAsync(other, 5);
         --want;
       }

llarp/router/router.hpp

@@ -452,11 +452,14 @@ namespace llarp
 
     void
     ForEachPeer(
-        std::function< void(const ILinkSession *, bool) > visit) const override;
+      std::function< void(const ILinkSession *, bool) > visit, bool randomize=false) const override;
 
     void
     ForEachPeer(std::function< void(ILinkSession *) > visit);
 
+    bool
+    IsBootstrapNode(RouterID) const override;
+    
     /// check if newRc matches oldRC and update local rc for this remote contact
     /// if valid
     /// returns true on valid and updated

llarp/rpc/rpc.cpp

@@ -237,7 +237,7 @@ namespace llarp
               Response{{"ident", RouterID(session->GetPubKey()).ToString()},
                        {"addr", session->GetRemoteEndpoint().ToString()},
                        {"outbound", outbound}});
-        });
+        }, false);
         return resp;
       }
 

llarp/service/endpoint.cpp

@@ -726,7 +726,20 @@ namespace llarp
     {
       if(NumInStatus(llarp::path::ePathEstablished) < 3)
         return false;
-      if(m_IntroSet.HasExpiredIntros(now))
+      // make sure we have all paths that are established
+      // in our introset
+      bool should = false;
+      ForEachPath([&](const path::Path *p) {
+                    if(!p->IsReady())
+                      return;
+                    for(const auto & i : m_IntroSet.I)
+                    {
+                      if(i == p->intro)
+                        return;
+                    }
+                    should = true;
+                  });
+      if(m_IntroSet.HasExpiredIntros(now) || should)
         return now - m_LastPublishAttempt >= INTROSET_PUBLISH_RETRY_INTERVAL;
       return now - m_LastPublishAttempt >= INTROSET_PUBLISH_INTERVAL;
     }