make lookup name async return optional variant

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

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

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);

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