make dns configurable on runtime

include/llarp/handlers/tun.hpp

@@ -145,6 +145,10 @@ namespace llarp
       huint32_t m_NextIP;
       /// highest ip address to allocate (host byte order)
       huint32_t m_MaxIP;
+      /// upstream dns
+      llarp::Addr m_UpstreamDNSAddr;
+      /// local dns
+      llarp::Addr m_LocalResolverAddr;
     };
   }  // namespace handlers
 }  // namespace llarp

include/llarp/service/context.hpp

@@ -75,7 +75,10 @@ namespace llarp
       AddDefaultEndpoint(const std::string &ifaddr, const std::string &ifname);
 
       bool
-      AddEndpoint(const Config::section_t &conf);
+      AddEndpoint(const Config::section_t &conf, bool autostart = false);
+
+      bool
+      StartAll();
 
      private:
       llarp_router *m_Router;

llarp/config.cpp

@@ -329,14 +329,17 @@ extern "C"
   {
     iter->conf                                                   = conf;
     std::map< std::string, llarp::Config::section_t & > sections = {
-        {"network", conf->impl.network}, {"connect", conf->impl.connect},
-        {"system", conf->impl.system},   {"bind", conf->impl.iwp_links},
-        {"netdb", conf->impl.netdb},     {"dns", conf->impl.dns},
-        {"api", conf->impl.api},         {"services", conf->impl.services}};
+        {"network", conf->impl.network},  {"connect", conf->impl.connect},
+        {"system", conf->impl.system},    {"bind", conf->impl.iwp_links},
+        {"netdb", conf->impl.netdb},      {"api", conf->impl.api},
+        {"services", conf->impl.services}};
 
     for(const auto item : conf->impl.router)
       iter->visit(iter, "router", item.first.c_str(), item.second.c_str());
 
+    for(const auto item : conf->impl.dns)
+      iter->visit(iter, "dns", item.first.c_str(), item.second.c_str());
+
     for(const auto &section : sections)
       for(const auto &item : section.second)
         iter->visit(iter, section.first.c_str(), item.first.c_str(),

llarp/handlers/tun.cpp

@@ -45,6 +45,30 @@ namespace llarp
         llarp::LogInfo(Name() + " would be setting DNS resolver to ", v);
         return true;
       }
+      if(k == "local-dns")
+      {
+        std::string resolverAddr = v;
+        uint16_t dnsport         = DNS_PORT;
+        auto pos                 = v.find(":");
+        if(pos != std::string::npos)
+        {
+          resolverAddr = v.substr(0, pos);
+        }
+        m_LocalResolverAddr = llarp::Addr(resolverAddr, dnsport);
+        llarp::LogInfo(Name(), " local dns set to ", m_LocalResolverAddr);
+      }
+      if(k == "upstream-dns")
+      {
+        std::string resolverAddr = v;
+        uint16_t dnsport         = DNS_PORT;
+        auto pos                 = v.find(":");
+        if(pos != std::string::npos)
+        {
+          resolverAddr = v.substr(0, pos);
+        }
+        m_UpstreamDNSAddr = llarp::Addr(resolverAddr, dnsport);
+        llarp::LogInfo(Name(), " upstream dns set to ", m_UpstreamDNSAddr);
+      }
       if(k == "mapaddr")
       {
         auto pos = v.find(":");
@@ -274,11 +298,11 @@ namespace llarp
         // public interface, don't want it exploitable maybe we could detect if
         // you have a private interface
       }
-      llarp::Addr dnsd_sockaddr(127, 0, 0, 1, DNS_PORT);
-      llarp::Addr dnsc_sockaddr(8, 8, 8, 8, 53);
-      llarp::LogInfo("TunDNS set up ", dnsd_sockaddr, " to ", dnsc_sockaddr);
+
+      llarp::LogInfo("TunDNS set up ", m_LocalResolverAddr, " to ",
+                     m_UpstreamDNSAddr);
       if(!llarp_dnsd_init(&this->dnsd, EndpointLogic(), EndpointNetLoop(),
-                          dnsd_sockaddr, dnsc_sockaddr))
+                          m_LocalResolverAddr, m_UpstreamDNSAddr))
       {
         llarp::LogError("Couldnt init dns daemon");
       }

llarp/router.cpp

@@ -784,6 +784,13 @@ llarp_router::Run()
       llarp::LogWarn("Link ", link->Name(), " failed to start");
   }
 
+  llarp::LogInfo("starting hidden service context...");
+  if(!hiddenServiceContext.StartAll())
+  {
+    llarp::LogError("Failed to start hidden service context");
+    return;
+  }
+
   if(IBLinksStarted > 0)
   {
     // initialize as service node
@@ -1099,7 +1106,10 @@ llarp_router::LoadHiddenServiceConfig(const char *fname)
     return false;
   for(const auto &config : conf.services)
   {
-    if(!hiddenServiceContext.AddEndpoint(config))
+    llarp::service::Config::section_t filteredConfig;
+    mergeHiddenServiceConfig(config.second, filteredConfig.second);
+    filteredConfig.first = config.first;
+    if(!hiddenServiceContext.AddEndpoint(filteredConfig))
       return false;
   }
   return true;
@@ -1200,6 +1210,17 @@ namespace llarp
         llarp::LogWarn("failed to load hidden service config for ", key);
       }
     }
+    else if(StrEq(section, "dns"))
+    {
+      if(StrEq(key, "upstream"))
+      {
+        self->upstreamResolvers.push_back(val);
+      }
+      if(StrEq(key, "bind"))
+      {
+        self->resolverBindAddr = val;
+      }
+    }
     else if(StrEq(section, "connect"))
     {
       self->connect[key] = val;

llarp/router.hpp

@@ -139,6 +139,9 @@ struct llarp_router
   std::unordered_map< llarp::RouterID, llarp_time_t, llarp::RouterID::Hash >
       m_PersistingSessions;
 
+  std::list< std::string > upstreamResolvers;
+  std::string resolverBindAddr = "127.0.0.1:53";
+
   llarp_router();
   ~llarp_router();
 
@@ -296,6 +299,19 @@ struct llarp_router
 
   static void
   HandleAsyncLoadRCForSendTo(llarp_async_load_rc *async);
+
+ private:
+  template < typename Config >
+  void
+  mergeHiddenServiceConfig(const Config &in, Config &out)
+  {
+    for(const auto &resolver : upstreamResolvers)
+      out.push_back({"upstream-dns", resolver});
+    out.push_back({"local-dns", resolverBindAddr});
+
+    for(const auto &item : in)
+      out.push_back({item.first, item.second});
+  }
 };
 
 #endif

llarp/service/context.cpp

@@ -213,11 +213,29 @@ namespace llarp
     {
       return AddEndpoint(
           {"default",
-           {{"type", "tun"}, {"ifaddr", ifaddr}, {"ifname", ifname}}});
+           {{"type", "tun"}, {"ifaddr", ifaddr}, {"ifname", ifname}}},
+          true);
     }
 
     bool
-    Context::AddEndpoint(const Config::section_t &conf)
+    Context::StartAll()
+    {
+      auto itr = m_Endpoints.begin();
+      while(itr != m_Endpoints.end())
+      {
+        if(!itr->second->Start())
+        {
+          llarp::LogError(itr->first, " failed to start");
+          return false;
+        }
+        llarp::LogInfo(itr->first, " started");
+        ++itr;
+      }
+      return true;
+    }
+
+    bool
+    Context::AddEndpoint(const Config::section_t &conf, bool autostart)
     {
       {
         auto itr = m_Endpoints.find(conf.first);
@@ -278,15 +296,25 @@ namespace llarp
           return false;
         }
       }
-      // start
-      if(service->Start())
+      if(autostart)
+      {
+        // start
+        if(service->Start())
+        {
+          llarp::LogInfo("autostarting hidden service endpoint ",
+                         service->Name());
+          m_Endpoints.insert(std::make_pair(conf.first, std::move(service)));
+          return true;
+        }
+        llarp::LogError("failed to start hidden service endpoint ", conf.first);
+        return false;
+      }
+      else
       {
         llarp::LogInfo("added hidden service endpoint ", service->Name());
         m_Endpoints.insert(std::make_pair(conf.first, std::move(service)));
         return true;
       }
-      llarp::LogError("failed to start hidden service endpoint ", conf.first);
-      return false;
     }
   }  // namespace service
 }  // namespace llarp