From 7a11f3b1e322e77aa987a02c4c7ffde3ec6f95e8 Mon Sep 17 00:00:00 2001
From: Jeff Becker <jeff@i2p.rocks>
Date: Fri, 19 Mar 2021 10:09:06 -0400
Subject: [PATCH 01/11] redunant lookups for lns.

* request lns from all endpoints we have on our pathset
* make sure all snodes agree on the lns name being looked up
---
 llarp/CMakeLists.txt              |  1 +
 llarp/service/endpoint.cpp        | 43 +++++++++++++++++++++--------
 llarp/service/endpoint_state.hpp  |  3 +++
 llarp/service/lns_tracker.cpp     | 41 ++++++++++++++++++++++++++++
 llarp/service/lns_tracker.hpp     | 45 +++++++++++++++++++++++++++++++
 llarp/util/decaying_hashtable.hpp |  9 +++++++
 6 files changed, 131 insertions(+), 11 deletions(-)
 create mode 100644 llarp/service/lns_tracker.cpp
 create mode 100644 llarp/service/lns_tracker.hpp

diff --git a/llarp/CMakeLists.txt b/llarp/CMakeLists.txt
index ca3e129b7..5962a8a5c 100644
--- a/llarp/CMakeLists.txt
+++ b/llarp/CMakeLists.txt
@@ -201,6 +201,7 @@ add_library(liblokinet
   service/info.cpp
   service/intro_set.cpp
   service/intro.cpp
+  service/lns_tracker.cpp
   service/lookup.cpp
   service/name.cpp
   service/outbound_context.cpp
diff --git a/llarp/service/endpoint.cpp b/llarp/service/endpoint.cpp
index 6d958550e..778163d9c 100644
--- a/llarp/service/endpoint.cpp
+++ b/llarp/service/endpoint.cpp
@@ -808,12 +808,39 @@ namespace llarp
         handler(maybe);
         return true;
       }
-      auto path = PickRandomEstablishedPath();
-      if (path == nullptr)
-        return false;
       LogInfo(Name(), " looking up LNS name: ", name);
-      auto job = new LookupNameJob(this, GenTXID(), name, handler);
-      return job->SendRequestViaPath(path, m_router);
+      path::Path::UniqueEndpointSet_t paths;
+      ForEachPath([&](auto path) {
+        if (path->IsReady())
+        {
+          paths.insert(path);
+        }
+      });
+      // not enough paths
+      if (paths.size() < 3)
+      {
+        handler(std::nullopt);
+        return true;
+      }
+
+      auto maybeInvalidateCache = [handler, &cache, name](auto result) {
+        if (not result)
+        {
+          cache.Remove(name);
+        }
+        handler(result);
+      };
+
+      auto resultHandler =
+          m_state->lnsTracker.MakeResultHandler(name, paths.size(), maybeInvalidateCache);
+
+      for (const auto& path : paths)
+      {
+        LogInfo(Name(), " lookup ", name, " from ", path->Endpoint());
+        auto job = new LookupNameJob(this, GenTXID(), name, resultHandler);
+        job->SendRequestViaPath(path, m_router);
+      }
+      return true;
     }
 
     bool
@@ -826,12 +853,6 @@ namespace llarp
 
       // decrypt entry
       const auto maybe = msg->result.Decrypt(itr->second->name);
-
-      if (maybe.has_value())
-      {
-        // put cache entry for result
-        m_state->nameCache.Put(itr->second->name, *maybe);
-      }
       // inform result
       itr->second->HandleNameResponse(maybe);
       lookups.erase(itr);
diff --git a/llarp/service/endpoint_state.hpp b/llarp/service/endpoint_state.hpp
index 9bae738b9..1b4887993 100644
--- a/llarp/service/endpoint_state.hpp
+++ b/llarp/service/endpoint_state.hpp
@@ -10,6 +10,7 @@
 #include <llarp/util/compare_ptr.hpp>
 #include <llarp/util/decaying_hashtable.hpp>
 #include <llarp/util/status.hpp>
+#include "lns_tracker.hpp"
 
 #include <memory>
 #include <queue>
@@ -66,6 +67,8 @@ namespace llarp
 
       util::DecayingHashTable<std::string, Address, std::hash<std::string>> nameCache;
 
+      LNSLookupTracker lnsTracker;
+
       bool
       Configure(const NetworkConfig& conf);
 
diff --git a/llarp/service/lns_tracker.cpp b/llarp/service/lns_tracker.cpp
new file mode 100644
index 000000000..8171ef435
--- /dev/null
+++ b/llarp/service/lns_tracker.cpp
@@ -0,0 +1,41 @@
+#include "lns_tracker.hpp"
+
+namespace llarp::service
+{
+  std::function<void(std::optional<Address>)>
+  LNSLookupTracker::MakeResultHandler(
+      std::string name,
+      std::size_t numPeers,
+      std::function<void(std::optional<Address>)> resultHandler)
+  {
+    auto itr = m_PendingLookups.emplace(name, LookupInfo{numPeers, resultHandler}).first;
+    auto& request = itr->second;
+    return [&, name](std::optional<Address> found) {
+      if (request.HandleOneResult(found))
+        m_PendingLookups.erase(name);
+    };
+  }
+
+  bool
+  LNSLookupTracker::LookupInfo::HandleOneResult(std::optional<Address> result)
+  {
+    if (result)
+    {
+      m_CurrentValues.insert(*result);
+    }
+    m_ResultsGotten++;
+    if (m_ResultsGotten == m_ResultsNeeded)
+    {
+      if (m_CurrentValues.size() == 1)
+      {
+        m_HandleResult(*m_CurrentValues.begin());
+      }
+      else
+      {
+        m_HandleResult(std::nullopt);
+      }
+      return true;
+    }
+    return false;
+  }
+}  // namespace llarp::service
diff --git a/llarp/service/lns_tracker.hpp b/llarp/service/lns_tracker.hpp
new file mode 100644
index 000000000..1053581f8
--- /dev/null
+++ b/llarp/service/lns_tracker.hpp
@@ -0,0 +1,45 @@
+#pragma once
+
+#include <functional>
+#include <optional>
+#include <unordered_map>
+#include <unordered_set>
+#include <string>
+
+#include "address.hpp"
+
+namespace llarp::service
+{
+  /// tracks and manages consensus of lns names we fetch from the network
+  class LNSLookupTracker
+  {
+    struct LookupInfo
+    {
+      std::unordered_set<Address> m_CurrentValues;
+      std::function<void(std::optional<Address>)> m_HandleResult;
+      std::size_t m_ResultsGotten = 0;
+      std::size_t m_ResultsNeeded;
+
+      LookupInfo(std::size_t wantResults, std::function<void(std::optional<Address>)> resultHandler)
+          : m_HandleResult{std::move(resultHandler)}, m_ResultsNeeded{wantResults}
+      {}
+
+      /// return true to remove self
+      bool
+      HandleOneResult(std::optional<Address> result);
+    };
+
+    std::unordered_map<std::string, LookupInfo> m_PendingLookups;
+
+   public:
+    /// make a function that will handle consensus of an lns request
+    /// name is the name we are requesting
+    /// numPeers is the number of peers we asked
+    /// resultHandler is a function that we are wrapping that will handle the final result
+    std::function<void(std::optional<Address>)>
+    MakeResultHandler(
+        std::string name,
+        std::size_t numPeers,
+        std::function<void(std::optional<Address>)> resultHandler);
+  };
+}  // namespace llarp::service
diff --git a/llarp/util/decaying_hashtable.hpp b/llarp/util/decaying_hashtable.hpp
index 2f7ea7c03..36c48ebd4 100644
--- a/llarp/util/decaying_hashtable.hpp
+++ b/llarp/util/decaying_hashtable.hpp
@@ -17,6 +17,7 @@ namespace llarp::util
       EraseIf([&](const auto& item) { return item.second.second + m_CacheInterval <= now; });
     }
 
+    /// return if we have this value by key
     bool
     Has(const Key_t& k) const
     {
@@ -33,6 +34,7 @@ namespace llarp::util
       return m_Values.try_emplace(std::move(key), std::make_pair(std::move(value), now)).second;
     }
 
+    /// get value by key
     std::optional<Value_t>
     Get(Key_t k) const
     {
@@ -42,6 +44,13 @@ namespace llarp::util
       return itr->second.first;
     }
 
+    /// explicit remove an item from the cache by key
+    void
+    Remove(const Key_t& key)
+    {
+      m_Values.erase(key);
+    }
+
    private:
     template <typename Predicate_t>
     void

From 95eba18e405277d20892f22ec25f01c62238a6b5 Mon Sep 17 00:00:00 2001
From: Jeff Becker <jeff@i2p.rocks>
Date: Fri, 19 Mar 2021 10:13:03 -0400
Subject: [PATCH 02/11] cache result on success

---
 llarp/service/endpoint.cpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/llarp/service/endpoint.cpp b/llarp/service/endpoint.cpp
index 778163d9c..5898679b1 100644
--- a/llarp/service/endpoint.cpp
+++ b/llarp/service/endpoint.cpp
@@ -824,7 +824,11 @@ namespace llarp
       }
 
       auto maybeInvalidateCache = [handler, &cache, name](auto result) {
-        if (not result)
+        if (result)
+        {
+          cache.Put(name, *result);
+        }
+        else
         {
           cache.Remove(name);
         }

From 8e57572b375dee2f8f5b0246bc5b6342541452ed Mon Sep 17 00:00:00 2001
From: Jeff Becker <jeff@i2p.rocks>
Date: Fri, 19 Mar 2021 10:18:36 -0400
Subject: [PATCH 03/11] dont reference iterator in lambda.

---
 llarp/service/lns_tracker.cpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/llarp/service/lns_tracker.cpp b/llarp/service/lns_tracker.cpp
index 8171ef435..862edf8f2 100644
--- a/llarp/service/lns_tracker.cpp
+++ b/llarp/service/lns_tracker.cpp
@@ -8,11 +8,11 @@ namespace llarp::service
       std::size_t numPeers,
       std::function<void(std::optional<Address>)> resultHandler)
   {
-    auto itr = m_PendingLookups.emplace(name, LookupInfo{numPeers, resultHandler}).first;
-    auto& request = itr->second;
-    return [&, name](std::optional<Address> found) {
-      if (request.HandleOneResult(found))
-        m_PendingLookups.erase(name);
+    m_PendingLookups.emplace(name, LookupInfo{numPeers, resultHandler});
+    return [name, this](std::optional<Address> found) {
+      auto itr = m_PendingLookups.find(name);
+      if (itr != m_PendingLookups.end() and itr->second.HandleOneResult(found))
+        m_PendingLookups.erase(itr);
     };
   }
 

From 4e14567d6749d6c996fd9b6b5b410ff8fbf63e85 Mon Sep 17 00:00:00 2001
From: Jeff Becker <jeff@i2p.rocks>
Date: Fri, 19 Mar 2021 15:30:09 -0400
Subject: [PATCH 04/11] make Endpoint::LookupNameAsync return void

---
 llarp/handlers/tun.cpp     | 40 ++++++++++++++++++++------------------
 llarp/service/endpoint.cpp |  7 +++----
 llarp/service/endpoint.hpp |  2 +-
 3 files changed, 25 insertions(+), 24 deletions(-)

diff --git a/llarp/handlers/tun.cpp b/llarp/handlers/tun.cpp
index 2cf56835d..3a533d2f4 100644
--- a/llarp/handlers/tun.cpp
+++ b/llarp/handlers/tun.cpp
@@ -483,7 +483,7 @@ namespace llarp
         }
         else if (service::NameIsValid(lnsName))
         {
-          return LookupNameAsync(lnsName, [msg, lnsName, reply](auto maybe) mutable {
+          LookupNameAsync(lnsName, [msg, lnsName, reply](auto maybe) mutable {
             if (maybe.has_value())
             {
               msg.AddMXReply(maybe->ToString(), 1);
@@ -494,6 +494,7 @@ namespace llarp
             }
             reply(msg);
           });
+          return true;
         }
         else
           msg.AddNXReply();
@@ -617,24 +618,25 @@ namespace llarp
         }
         else if (service::NameIsValid(lnsName))
         {
-          return LookupNameAsync(
-              lnsName,
-              [msg = std::make_shared<dns::Message>(msg),
-               name = Name(),
-               lnsName,
-               isV6,
-               reply,
-               ReplyToLokiDNSWhenReady](auto maybe) {
-                if (not maybe.has_value())
-                {
-                  LogWarn(name, " lns name ", lnsName, " not resolved");
-                  msg->AddNXReply();
-                  reply(*msg);
-                  return;
-                }
-                LogInfo(name, " ", lnsName, " resolved to ", maybe->ToString());
-                ReplyToLokiDNSWhenReady(*maybe, msg, isV6);
-              });
+          LookupNameAsync(
+            lnsName,
+            [msg = std::make_shared<dns::Message>(msg),
+             name = Name(),
+             lnsName,
+             isV6,
+             reply,
+             ReplyToLokiDNSWhenReady](auto maybe) {
+              if (not maybe.has_value())
+              {
+                LogWarn(name, " lns name ", lnsName, " not resolved");
+                msg->AddNXReply();
+                reply(*msg);
+                return;
+              }
+              LogInfo(name, " ", lnsName, " resolved to ", maybe->ToString());
+              ReplyToLokiDNSWhenReady(*maybe, msg, isV6);
+            });
+          return true;
         }
         else
           msg.AddNXReply();
diff --git a/llarp/service/endpoint.cpp b/llarp/service/endpoint.cpp
index 5898679b1..2291d617b 100644
--- a/llarp/service/endpoint.cpp
+++ b/llarp/service/endpoint.cpp
@@ -798,7 +798,7 @@ namespace llarp
       return not m_ExitMap.Empty();
     }
 
-    bool
+    void
     Endpoint::LookupNameAsync(std::string name, std::function<void(std::optional<Address>)> handler)
     {
       auto& cache = m_state->nameCache;
@@ -806,7 +806,7 @@ namespace llarp
       if (maybe.has_value())
       {
         handler(maybe);
-        return true;
+        return;
       }
       LogInfo(Name(), " looking up LNS name: ", name);
       path::Path::UniqueEndpointSet_t paths;
@@ -820,7 +820,7 @@ namespace llarp
       if (paths.size() < 3)
       {
         handler(std::nullopt);
-        return true;
+        return;
       }
 
       auto maybeInvalidateCache = [handler, &cache, name](auto result) {
@@ -844,7 +844,6 @@ namespace llarp
         auto job = new LookupNameJob(this, GenTXID(), name, resultHandler);
         job->SendRequestViaPath(path, m_router);
       }
-      return true;
     }
 
     bool
diff --git a/llarp/service/endpoint.hpp b/llarp/service/endpoint.hpp
index 12e5d3567..efd1c98e9 100644
--- a/llarp/service/endpoint.hpp
+++ b/llarp/service/endpoint.hpp
@@ -218,7 +218,7 @@ namespace llarp
       bool
       LookupRouterAnon(RouterID router, RouterLookupHandler handler);
 
-      bool
+      void
       LookupNameAsync(std::string name, std::function<void(std::optional<Address>)> resultHandler);
 
       /// called on event loop pump

From 88ddcceca4f4976b8deffc74ec87fc2ecf9de211 Mon Sep 17 00:00:00 2001
From: Jeff Becker <jeff@i2p.rocks>
Date: Fri, 19 Mar 2021 16:06:03 -0400
Subject: [PATCH 05/11] make lookup name async return optional variant

---
 llarp/handlers/tun.cpp     | 50 ++++++++++++++++++++++++--------------
 llarp/rpc/rpc_server.cpp   | 18 +++++++++++---
 llarp/service/endpoint.cpp | 17 +++++++------
 llarp/service/endpoint.hpp |  6 ++++-
 4 files changed, 62 insertions(+), 29 deletions(-)

diff --git a/llarp/handlers/tun.cpp b/llarp/handlers/tun.cpp
index 3a533d2f4..ac465ad9f 100644
--- a/llarp/handlers/tun.cpp
+++ b/llarp/handlers/tun.cpp
@@ -354,6 +354,21 @@ namespace llarp
             2s);
       };
 
+      auto ReplyToDNSWhenReady =
+          [ReplyToLokiDNSWhenReady, ReplyToSNodeDNSWhenReady](
+              std::variant<service::Address, RouterID> addr, auto msg, bool isV6) {
+            if (auto ptr = std::get_if<RouterID>(&addr))
+            {
+              ReplyToSNodeDNSWhenReady(*ptr, msg, isV6);
+              return;
+            }
+            if (auto ptr = std::get_if<service::Address>(&addr))
+            {
+              ReplyToLokiDNSWhenReady(*ptr, msg, isV6);
+              return;
+            }
+          };
+
       auto ReplyToLokiSRVWhenReady = [self = this, reply = reply](
                                          service::Address addr, auto msg) -> bool {
         using service::Address;
@@ -486,7 +501,7 @@ namespace llarp
           LookupNameAsync(lnsName, [msg, lnsName, reply](auto maybe) mutable {
             if (maybe.has_value())
             {
-              msg.AddMXReply(maybe->ToString(), 1);
+              std::visit([&](auto&& value) { msg.AddMXReply(value.ToString(), 1); }, *maybe);
             }
             else
             {
@@ -619,23 +634,22 @@ namespace llarp
         else if (service::NameIsValid(lnsName))
         {
           LookupNameAsync(
-            lnsName,
-            [msg = std::make_shared<dns::Message>(msg),
-             name = Name(),
-             lnsName,
-             isV6,
-             reply,
-             ReplyToLokiDNSWhenReady](auto maybe) {
-              if (not maybe.has_value())
-              {
-                LogWarn(name, " lns name ", lnsName, " not resolved");
-                msg->AddNXReply();
-                reply(*msg);
-                return;
-              }
-              LogInfo(name, " ", lnsName, " resolved to ", maybe->ToString());
-              ReplyToLokiDNSWhenReady(*maybe, msg, isV6);
-            });
+              lnsName,
+              [msg = std::make_shared<dns::Message>(msg),
+               name = Name(),
+               lnsName,
+               isV6,
+               reply,
+               ReplyToDNSWhenReady](auto maybe) {
+                if (not maybe.has_value())
+                {
+                  LogWarn(name, " lns name ", lnsName, " not resolved");
+                  msg->AddNXReply();
+                  reply(*msg);
+                  return;
+                }
+                ReplyToDNSWhenReady(*maybe, msg, isV6);
+              });
           return true;
         }
         else
diff --git a/llarp/rpc/rpc_server.cpp b/llarp/rpc/rpc_server.cpp
index 666dad3ef..dca395143 100644
--- a/llarp/rpc/rpc_server.cpp
+++ b/llarp/rpc/rpc_server.cpp
@@ -294,12 +294,24 @@ namespace llarp::rpc
                           reply(CreateJSONError("we could not find an exit with that name"));
                           return;
                         }
-                        if (maybe->IsZero())
+                        std::visit(
+                            [&](auto&& value) {
+                              if (value.IsZero())
+                              {
+                                reply(CreateJSONError("lokinet exit does not exist"));
+                                return;
+                              }
+                            },
+                            *maybe);
+                        if (auto ptr = std::get_if<service::Address>(&*maybe))
+                        {
+                          mapExit(*ptr);
+                        }
+                        else
                         {
-                          reply(CreateJSONError("lokinet exit does not exist"));
+                          reply(CreateJSONError("lns name resolved to a snode"));
                           return;
                         }
-                        mapExit(*maybe);
                       });
                     }
                     else
diff --git a/llarp/service/endpoint.cpp b/llarp/service/endpoint.cpp
index 2291d617b..1d9cf6ca7 100644
--- a/llarp/service/endpoint.cpp
+++ b/llarp/service/endpoint.cpp
@@ -232,12 +232,13 @@ namespace llarp
                   const auto maybe_auth = info.second;
 
                   m_StartupLNSMappings.erase(name);
-
-                  if (maybe_range.has_value())
-                    m_ExitMap.Insert(*maybe_range, *maybe_addr);
-
-                  if (maybe_auth.has_value())
-                    SetAuthInfoForEndpoint(*maybe_addr, *maybe_auth);
+                  if (auto* addr = std::get_if<service::Address>(&*maybe_addr))
+                  {
+                    if (maybe_range.has_value())
+                      m_ExitMap.Insert(*maybe_range, *addr);
+                    if (maybe_auth.has_value())
+                      SetAuthInfoForEndpoint(*addr, *maybe_auth);
+                  }
                 }
               });
         }
@@ -799,7 +800,9 @@ namespace llarp
     }
 
     void
-    Endpoint::LookupNameAsync(std::string name, std::function<void(std::optional<Address>)> handler)
+    Endpoint::LookupNameAsync(
+        std::string name,
+        std::function<void(std::optional<std::variant<Address, RouterID>>)> handler)
     {
       auto& cache = m_state->nameCache;
       const auto maybe = cache.Get(name);
diff --git a/llarp/service/endpoint.hpp b/llarp/service/endpoint.hpp
index efd1c98e9..a4cfd730a 100644
--- a/llarp/service/endpoint.hpp
+++ b/llarp/service/endpoint.hpp
@@ -21,6 +21,8 @@
 
 #include "auth.hpp"
 
+#include <variant>
+
 // minimum time between introset shifts
 #ifndef MIN_SHIFT_INTERVAL
 #define MIN_SHIFT_INTERVAL 5s
@@ -219,7 +221,9 @@ namespace llarp
       LookupRouterAnon(RouterID router, RouterLookupHandler handler);
 
       void
-      LookupNameAsync(std::string name, std::function<void(std::optional<Address>)> resultHandler);
+      LookupNameAsync(
+          std::string name,
+          std::function<void(std::optional<std::variant<Address, RouterID>>)> resultHandler);
 
       /// called on event loop pump
       virtual void

From 6c1d18412c0ad9939a3faa1c3f02bb2ebb2d730a Mon Sep 17 00:00:00 2001
From: Jeff Becker <jeff@i2p.rocks>
Date: Fri, 19 Mar 2021 16:13:09 -0400
Subject: [PATCH 06/11] seperate logic into IsDone()

---
 llarp/service/lns_tracker.cpp | 15 +++++++++++----
 llarp/service/lns_tracker.hpp |  4 +++-
 2 files changed, 14 insertions(+), 5 deletions(-)

diff --git a/llarp/service/lns_tracker.cpp b/llarp/service/lns_tracker.cpp
index 862edf8f2..1373772fc 100644
--- a/llarp/service/lns_tracker.cpp
+++ b/llarp/service/lns_tracker.cpp
@@ -11,12 +11,21 @@ namespace llarp::service
     m_PendingLookups.emplace(name, LookupInfo{numPeers, resultHandler});
     return [name, this](std::optional<Address> found) {
       auto itr = m_PendingLookups.find(name);
-      if (itr != m_PendingLookups.end() and itr->second.HandleOneResult(found))
+      if (itr == m_PendingLookups.end())
+        return;
+      itr->second.HandleOneResult(found);
+      if (itr->second.IsDone())
         m_PendingLookups.erase(itr);
     };
   }
 
   bool
+  LNSLookupTracker::LookupInfo::IsDone() const
+  {
+    return m_ResultsGotten == m_ResultsNeeded;
+  }
+
+  void
   LNSLookupTracker::LookupInfo::HandleOneResult(std::optional<Address> result)
   {
     if (result)
@@ -24,7 +33,7 @@ namespace llarp::service
       m_CurrentValues.insert(*result);
     }
     m_ResultsGotten++;
-    if (m_ResultsGotten == m_ResultsNeeded)
+    if (IsDone())
     {
       if (m_CurrentValues.size() == 1)
       {
@@ -34,8 +43,6 @@ namespace llarp::service
       {
         m_HandleResult(std::nullopt);
       }
-      return true;
     }
-    return false;
   }
 }  // namespace llarp::service
diff --git a/llarp/service/lns_tracker.hpp b/llarp/service/lns_tracker.hpp
index 1053581f8..c6d143e51 100644
--- a/llarp/service/lns_tracker.hpp
+++ b/llarp/service/lns_tracker.hpp
@@ -24,8 +24,10 @@ namespace llarp::service
           : m_HandleResult{std::move(resultHandler)}, m_ResultsNeeded{wantResults}
       {}
 
-      /// return true to remove self
       bool
+      IsDone() const;
+
+      void
       HandleOneResult(std::optional<Address> result);
     };
 

From f10269b03eb2587428c3a9fe8a936f072c52f371 Mon Sep 17 00:00:00 2001
From: Jeff Becker <jeff@i2p.rocks>
Date: Sat, 20 Mar 2021 10:05:36 -0400
Subject: [PATCH 07/11] remove std::visit because apple is functionally
 retarded and does not support it despite claiming to support c++14

---
 llarp/handlers/tun.cpp     | 5 ++++-
 llarp/rpc/rpc_server.cpp   | 9 ---------
 llarp/service/endpoint.cpp | 4 ++++
 3 files changed, 8 insertions(+), 10 deletions(-)

diff --git a/llarp/handlers/tun.cpp b/llarp/handlers/tun.cpp
index ac465ad9f..1db2d8d10 100644
--- a/llarp/handlers/tun.cpp
+++ b/llarp/handlers/tun.cpp
@@ -501,7 +501,10 @@ namespace llarp
           LookupNameAsync(lnsName, [msg, lnsName, reply](auto maybe) mutable {
             if (maybe.has_value())
             {
-              std::visit([&](auto&& value) { msg.AddMXReply(value.ToString(), 1); }, *maybe);
+              if (auto* addr = std::get_if<service::Address>(&*maybe))
+              {
+                msg.AddMXReply(addr->ToString(), 1);
+              }
             }
             else
             {
diff --git a/llarp/rpc/rpc_server.cpp b/llarp/rpc/rpc_server.cpp
index dca395143..14c3fce82 100644
--- a/llarp/rpc/rpc_server.cpp
+++ b/llarp/rpc/rpc_server.cpp
@@ -294,15 +294,6 @@ namespace llarp::rpc
                           reply(CreateJSONError("we could not find an exit with that name"));
                           return;
                         }
-                        std::visit(
-                            [&](auto&& value) {
-                              if (value.IsZero())
-                              {
-                                reply(CreateJSONError("lokinet exit does not exist"));
-                                return;
-                              }
-                            },
-                            *maybe);
                         if (auto ptr = std::get_if<service::Address>(&*maybe))
                         {
                           mapExit(*ptr);
diff --git a/llarp/service/endpoint.cpp b/llarp/service/endpoint.cpp
index 1d9cf6ca7..ea072adc7 100644
--- a/llarp/service/endpoint.cpp
+++ b/llarp/service/endpoint.cpp
@@ -827,6 +827,10 @@ namespace llarp
       }
 
       auto maybeInvalidateCache = [handler, &cache, name](auto result) {
+        if (result and result->IsZero())
+        {
+          result = std::nullopt;
+        }
         if (result)
         {
           cache.Put(name, *result);

From ba9dca6c5d59d29b6fd383d89bc05a8c6fc5de09 Mon Sep 17 00:00:00 2001
From: Jeff Becker <jeff@i2p.rocks>
Date: Sat, 20 Mar 2021 11:47:36 -0400
Subject: [PATCH 08/11] use var::variant and var::visit shims because apple is
 sux

---
 llarp/handlers/tun.cpp           |  5 +----
 llarp/service/endpoint.cpp       | 13 ++++++++++---
 llarp/service/endpoint.hpp       |  4 ++--
 llarp/service/endpoint_state.hpp |  3 ++-
 llarp/service/lns_tracker.cpp    |  8 ++++----
 llarp/service/lns_tracker.hpp    | 18 ++++++++++++------
 6 files changed, 31 insertions(+), 20 deletions(-)

diff --git a/llarp/handlers/tun.cpp b/llarp/handlers/tun.cpp
index 1db2d8d10..0f71f203f 100644
--- a/llarp/handlers/tun.cpp
+++ b/llarp/handlers/tun.cpp
@@ -501,10 +501,7 @@ namespace llarp
           LookupNameAsync(lnsName, [msg, lnsName, reply](auto maybe) mutable {
             if (maybe.has_value())
             {
-              if (auto* addr = std::get_if<service::Address>(&*maybe))
-              {
-                msg.AddMXReply(addr->ToString(), 1);
-              }
+              var::visit([&](auto&& value) { msg.AddMXReply(value.ToString(), 1); }, *maybe);
             }
             else
             {
diff --git a/llarp/service/endpoint.cpp b/llarp/service/endpoint.cpp
index ea072adc7..fa832956c 100644
--- a/llarp/service/endpoint.cpp
+++ b/llarp/service/endpoint.cpp
@@ -802,7 +802,7 @@ namespace llarp
     void
     Endpoint::LookupNameAsync(
         std::string name,
-        std::function<void(std::optional<std::variant<Address, RouterID>>)> handler)
+        std::function<void(std::optional<var::variant<Address, RouterID>>)> handler)
     {
       auto& cache = m_state->nameCache;
       const auto maybe = cache.Get(name);
@@ -827,9 +827,16 @@ namespace llarp
       }
 
       auto maybeInvalidateCache = [handler, &cache, name](auto result) {
-        if (result and result->IsZero())
+        if (result)
         {
-          result = std::nullopt;
+          var::visit(
+              [&](auto&& value) {
+                if (value.IsZero())
+                {
+                  result = std::nullopt;
+                }
+              },
+              *result);
         }
         if (result)
         {
diff --git a/llarp/service/endpoint.hpp b/llarp/service/endpoint.hpp
index a4cfd730a..a1c834caa 100644
--- a/llarp/service/endpoint.hpp
+++ b/llarp/service/endpoint.hpp
@@ -21,7 +21,7 @@
 
 #include "auth.hpp"
 
-#include <variant>
+#include <oxenmq/variant.h>
 
 // minimum time between introset shifts
 #ifndef MIN_SHIFT_INTERVAL
@@ -223,7 +223,7 @@ namespace llarp
       void
       LookupNameAsync(
           std::string name,
-          std::function<void(std::optional<std::variant<Address, RouterID>>)> resultHandler);
+          std::function<void(std::optional<var::variant<Address, RouterID>>)> resultHandler);
 
       /// called on event loop pump
       virtual void
diff --git a/llarp/service/endpoint_state.hpp b/llarp/service/endpoint_state.hpp
index 1b4887993..9f3e4694e 100644
--- a/llarp/service/endpoint_state.hpp
+++ b/llarp/service/endpoint_state.hpp
@@ -65,7 +65,8 @@ namespace llarp
 
       OutboundSessions_t m_OutboundSessions;
 
-      util::DecayingHashTable<std::string, Address, std::hash<std::string>> nameCache;
+      util::DecayingHashTable<std::string, var::variant<Address, RouterID>, std::hash<std::string>>
+          nameCache;
 
       LNSLookupTracker lnsTracker;
 
diff --git a/llarp/service/lns_tracker.cpp b/llarp/service/lns_tracker.cpp
index 1373772fc..153fed1a4 100644
--- a/llarp/service/lns_tracker.cpp
+++ b/llarp/service/lns_tracker.cpp
@@ -2,14 +2,14 @@
 
 namespace llarp::service
 {
-  std::function<void(std::optional<Address>)>
+  std::function<void(std::optional<LNSLookupTracker::Addr_t>)>
   LNSLookupTracker::MakeResultHandler(
       std::string name,
       std::size_t numPeers,
-      std::function<void(std::optional<Address>)> resultHandler)
+      std::function<void(std::optional<Addr_t>)> resultHandler)
   {
     m_PendingLookups.emplace(name, LookupInfo{numPeers, resultHandler});
-    return [name, this](std::optional<Address> found) {
+    return [name, this](std::optional<Addr_t> found) {
       auto itr = m_PendingLookups.find(name);
       if (itr == m_PendingLookups.end())
         return;
@@ -26,7 +26,7 @@ namespace llarp::service
   }
 
   void
-  LNSLookupTracker::LookupInfo::HandleOneResult(std::optional<Address> result)
+  LNSLookupTracker::LookupInfo::HandleOneResult(std::optional<Addr_t> result)
   {
     if (result)
     {
diff --git a/llarp/service/lns_tracker.hpp b/llarp/service/lns_tracker.hpp
index c6d143e51..6da3134fe 100644
--- a/llarp/service/lns_tracker.hpp
+++ b/llarp/service/lns_tracker.hpp
@@ -7,20 +7,26 @@
 #include <string>
 
 #include "address.hpp"
+#include <llarp/router_id.hpp>
+#include <oxenmq/variant.h>
 
 namespace llarp::service
 {
   /// tracks and manages consensus of lns names we fetch from the network
   class LNSLookupTracker
   {
+   public:
+    using Addr_t = var::variant<Address, RouterID>;
+
+   private:
     struct LookupInfo
     {
-      std::unordered_set<Address> m_CurrentValues;
-      std::function<void(std::optional<Address>)> m_HandleResult;
+      std::unordered_set<Addr_t> m_CurrentValues;
+      std::function<void(std::optional<Addr_t>)> m_HandleResult;
       std::size_t m_ResultsGotten = 0;
       std::size_t m_ResultsNeeded;
 
-      LookupInfo(std::size_t wantResults, std::function<void(std::optional<Address>)> resultHandler)
+      LookupInfo(std::size_t wantResults, std::function<void(std::optional<Addr_t>)> resultHandler)
           : m_HandleResult{std::move(resultHandler)}, m_ResultsNeeded{wantResults}
       {}
 
@@ -28,7 +34,7 @@ namespace llarp::service
       IsDone() const;
 
       void
-      HandleOneResult(std::optional<Address> result);
+      HandleOneResult(std::optional<Addr_t> result);
     };
 
     std::unordered_map<std::string, LookupInfo> m_PendingLookups;
@@ -38,10 +44,10 @@ namespace llarp::service
     /// name is the name we are requesting
     /// numPeers is the number of peers we asked
     /// resultHandler is a function that we are wrapping that will handle the final result
-    std::function<void(std::optional<Address>)>
+    std::function<void(std::optional<Addr_t>)>
     MakeResultHandler(
         std::string name,
         std::size_t numPeers,
-        std::function<void(std::optional<Address>)> resultHandler);
+        std::function<void(std::optional<Addr_t>)> resultHandler);
   };
 }  // namespace llarp::service

From b7f72601ce5377b48e632c6593fcd174e525dba2 Mon Sep 17 00:00:00 2001
From: Jeff Becker <jeff@i2p.rocks>
Date: Sat, 20 Mar 2021 14:30:18 -0400
Subject: [PATCH 09/11] move stuff to var::variant

---
 llarp/handlers/tun.cpp           | 27 +++++++++++++--------------
 llarp/service/endpoint_state.hpp |  2 ++
 2 files changed, 15 insertions(+), 14 deletions(-)

diff --git a/llarp/handlers/tun.cpp b/llarp/handlers/tun.cpp
index 0f71f203f..eb2c1df9e 100644
--- a/llarp/handlers/tun.cpp
+++ b/llarp/handlers/tun.cpp
@@ -354,20 +354,19 @@ namespace llarp
             2s);
       };
 
-      auto ReplyToDNSWhenReady =
-          [ReplyToLokiDNSWhenReady, ReplyToSNodeDNSWhenReady](
-              std::variant<service::Address, RouterID> addr, auto msg, bool isV6) {
-            if (auto ptr = std::get_if<RouterID>(&addr))
-            {
-              ReplyToSNodeDNSWhenReady(*ptr, msg, isV6);
-              return;
-            }
-            if (auto ptr = std::get_if<service::Address>(&addr))
-            {
-              ReplyToLokiDNSWhenReady(*ptr, msg, isV6);
-              return;
-            }
-          };
+      auto ReplyToDNSWhenReady = [ReplyToLokiDNSWhenReady, ReplyToSNodeDNSWhenReady](
+                                     auto addr, auto msg, bool isV6) {
+        if (auto ptr = std::get_if<RouterID>(&addr))
+        {
+          ReplyToSNodeDNSWhenReady(*ptr, msg, isV6);
+          return;
+        }
+        if (auto ptr = std::get_if<service::Address>(&addr))
+        {
+          ReplyToLokiDNSWhenReady(*ptr, msg, isV6);
+          return;
+        }
+      };
 
       auto ReplyToLokiSRVWhenReady = [self = this, reply = reply](
                                          service::Address addr, auto msg) -> bool {
diff --git a/llarp/service/endpoint_state.hpp b/llarp/service/endpoint_state.hpp
index 9f3e4694e..b6b8886f2 100644
--- a/llarp/service/endpoint_state.hpp
+++ b/llarp/service/endpoint_state.hpp
@@ -17,6 +17,8 @@
 #include <set>
 #include <unordered_map>
 
+#include <oxenmq/variant.h>
+
 namespace llarp
 {
   namespace service

From 202c9348faa8d4fd00518a6176b759859f6158a6 Mon Sep 17 00:00:00 2001
From: Jeff Becker <jeff@i2p.rocks>
Date: Sat, 20 Mar 2021 15:18:04 -0400
Subject: [PATCH 10/11] use std::variant

---
 llarp/service/endpoint.cpp    | 2 +-
 llarp/service/endpoint.hpp    | 2 +-
 llarp/service/lns_tracker.hpp | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/llarp/service/endpoint.cpp b/llarp/service/endpoint.cpp
index fa832956c..2ebd0a8c7 100644
--- a/llarp/service/endpoint.cpp
+++ b/llarp/service/endpoint.cpp
@@ -802,7 +802,7 @@ namespace llarp
     void
     Endpoint::LookupNameAsync(
         std::string name,
-        std::function<void(std::optional<var::variant<Address, RouterID>>)> handler)
+        std::function<void(std::optional<std::variant<Address, RouterID>>)> handler)
     {
       auto& cache = m_state->nameCache;
       const auto maybe = cache.Get(name);
diff --git a/llarp/service/endpoint.hpp b/llarp/service/endpoint.hpp
index a1c834caa..2e35f4520 100644
--- a/llarp/service/endpoint.hpp
+++ b/llarp/service/endpoint.hpp
@@ -223,7 +223,7 @@ namespace llarp
       void
       LookupNameAsync(
           std::string name,
-          std::function<void(std::optional<var::variant<Address, RouterID>>)> resultHandler);
+          std::function<void(std::optional<std::variant<Address, RouterID>>)> resultHandler);
 
       /// called on event loop pump
       virtual void
diff --git a/llarp/service/lns_tracker.hpp b/llarp/service/lns_tracker.hpp
index 6da3134fe..9aa65904f 100644
--- a/llarp/service/lns_tracker.hpp
+++ b/llarp/service/lns_tracker.hpp
@@ -16,7 +16,7 @@ namespace llarp::service
   class LNSLookupTracker
   {
    public:
-    using Addr_t = var::variant<Address, RouterID>;
+    using Addr_t = std::variant<Address, RouterID>;
 
    private:
     struct LookupInfo

From dfa84081c91a337a2b9bcb32dc4aa8a6a8c78e2b Mon Sep 17 00:00:00 2001
From: Jeff Becker <jeff@i2p.rocks>
Date: Sat, 20 Mar 2021 15:26:08 -0400
Subject: [PATCH 11/11] forgot a type

---
 llarp/service/endpoint_state.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/llarp/service/endpoint_state.hpp b/llarp/service/endpoint_state.hpp
index b6b8886f2..8e9e9f625 100644
--- a/llarp/service/endpoint_state.hpp
+++ b/llarp/service/endpoint_state.hpp
@@ -67,7 +67,7 @@ namespace llarp
 
       OutboundSessions_t m_OutboundSessions;
 
-      util::DecayingHashTable<std::string, var::variant<Address, RouterID>, std::hash<std::string>>
+      util::DecayingHashTable<std::string, std::variant<Address, RouterID>, std::hash<std::string>>
           nameCache;
 
       LNSLookupTracker lnsTracker;