Merge pull request #83 from majestrate/master

better config settings for defaults

include/llarp/service/context.hpp

@@ -72,9 +72,8 @@ namespace llarp
                     llarp::Addr &localPrivateIpAddr);
 
       bool
-      AddDefaultEndpoint(const std::string &ifaddr, const std::string &ifname,
-                         const std::string &remoteResovler,
-                         const std::string &localResolver);
+      AddDefaultEndpoint(
+          const std::unordered_multimap< std::string, std::string > &opts);
 
       bool
       AddEndpoint(const Config::section_t &conf, bool autostart = false);

llarp/router.cpp

@@ -837,24 +837,17 @@ 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;
-  }
-
+  uint64_t delay = ((llarp_randint() % 10) * 500) + 500;
   if(IBLinksStarted > 0)
   {
     // initialize as service node
     if(!InitServiceNode())
     {
       llarp::LogError("Failed to initialize service node");
+      Close();
       return;
     }
-    // immediate connect all for service node
-    uint64_t delay = llarp_randint() % 100;
-    llarp_logic_call_later(logic, {delay, this, &ConnectAll});
+    delay = llarp_randint() % 50;
   }
   else
   {
@@ -867,75 +860,32 @@ llarp_router::Run()
     if(!_rc.Sign(&crypto, identity))
     {
       llarp::LogError("failed to regenerate keys and sign RC");
+      Close();
       return;
     }
-
-    // don't create default if we already have some defined
-    if(this->ShouldCreateDefaultHiddenService())
+    // generate default hidden service
+    llarp::LogInfo("setting up default network endpoint");
+    if(!CreateDefaultHiddenService())
     {
-      // generate default hidden service
-      if(!CreateDefaultHiddenService())
-        return;
+      llarp::LogError("failed to set up default network endpoint");
+      Close();
+      return;
     }
-    // delayed connect all for clients
-    uint64_t delay = ((llarp_randint() % 10) * 500) + 500;
-    llarp_logic_call_later(logic, {delay, this, &ConnectAll});
   }
 
+  llarp::LogInfo("starting hidden service context...");
+  if(!hiddenServiceContext.StartAll())
+  {
+    llarp::LogError("Failed to start hidden service context");
+    Close();
+    return;
+  }
   llarp::PubKey ourPubkey = pubkey();
   llarp::LogInfo("starting dht context as ", ourPubkey);
   llarp_dht_context_start(dht, ourPubkey);
-
   ScheduleTicker(1000);
-}
-
-bool
-llarp_router::ShouldCreateDefaultHiddenService()
-{
-  // llarp::LogInfo("IfName: ", this->defaultIfName, " defaultIfName: ",
-  // this->defaultIfName);
-  if(this->defaultIfName == "auto" || this->defaultIfName == "auto")
-  {
-    // auto detect if we have any pre-defined endpoints
-    // no if we have a endpoints
-    if(hiddenServiceContext.hasEndpoints())
-    {
-      llarp::LogInfo("Auto mode detected and we have endpoints");
-      return false;
-    }
-    // we don't have any endpoints, auto configure settings
-
-    // set a default IP range
-    this->defaultIfAddr = llarp::findFreePrivateRange();
-    if(this->defaultIfAddr == "")
-    {
-      llarp::LogError(
-          "Could not find any free lokitun interface names, can't auto set up "
-          "default HS context for client");
-      this->defaultIfAddr = "no";
-      return false;
-    }
-
-    // pick an ifName
-    this->defaultIfName = llarp::findFreeLokiTunIfName();
-    if(this->defaultIfName == "")
-    {
-      llarp::LogError(
-          "Could not find any free private ip ranges, can't auto set up "
-          "default HS context for client");
-      this->defaultIfName = "no";
-      return false;
-    }
-    // auto config'd, go ahead and create it
-    return true;
-  }
-  // not auto mode then just check to make sure it's explicitly disabled
-  if(this->defaultIfAddr != "" && this->defaultIfAddr != "no"
-     && this->defaultIfName != "" && this->defaultIfName != "no")
-  {
-    return true;
-  }
-  return false;
+  // delayed connect all
+  llarp_logic_call_later(logic, {delay, this, &ConnectAll});
 }
 
 bool
@@ -944,8 +894,7 @@ llarp_router::InitServiceNode()
   llarp::LogInfo("accepting transit traffic");
   paths.AllowTransit();
   llarp_dht_allow_transit(dht);
-  exitContext.AddExitEndpoint("default-connectivity", exitConf);
-  return true;
+  return exitContext.AddExitEndpoint("default-connectivity", netConfig);
 }
 
 void
@@ -1027,14 +976,26 @@ llarp_router::InitOutboundLink()
 bool
 llarp_router::CreateDefaultHiddenService()
 {
-  if(upstreamResolvers.size())
-    return hiddenServiceContext.AddDefaultEndpoint(defaultIfAddr, defaultIfName,
-                                                   upstreamResolvers.front(),
-                                                   resolverBindAddr);
-  else
-    return hiddenServiceContext.AddDefaultEndpoint(defaultIfAddr, defaultIfName,
-                                                   defaultUpstreamResolver,
-                                                   resolverBindAddr);
+  // fallback defaults
+  static const std::unordered_map< std::string,
+                                   std::function< std::string(void) > >
+      netConfigDefaults = {
+          {"ifname", llarp::findFreeLokiTunIfName},
+          {"ifaddr", llarp::findFreePrivateRange},
+          {"local-dns", []() -> std::string { return "127.0.0.1:53"; }},
+          {"upstream-dns", []() -> std::string { return "1.1.1.1:53"; }}};
+  // populate with fallback defaults if values not present
+  auto itr = netConfigDefaults.begin();
+  while(itr != netConfigDefaults.end())
+  {
+    if(netConfig.count(itr->first) == 0)
+    {
+      netConfig.emplace(std::make_pair(itr->first, itr->second()));
+    }
+    ++itr;
+  }
+  // add endpoint
+  return hiddenServiceContext.AddDefaultEndpoint(netConfig);
 }
 
 bool
@@ -1241,14 +1202,6 @@ namespace llarp
     }
     else if(StrEq(section, "network"))
     {
-      if(StrEq(key, "ifaddr"))
-      {
-        self->defaultIfAddr = val;
-      }
-      if(StrEq(key, "ifname"))
-      {
-        self->defaultIfName = val;
-      }
       if(StrEq(key, "profiles"))
       {
         self->routerProfilesFile = val;
@@ -1257,7 +1210,7 @@ namespace llarp
       }
       else
       {
-        self->exitConf.insert(std::make_pair(key, val));
+        self->netConfig.insert(std::make_pair(key, val));
       }
     }
     else if(StrEq(section, "api"))
@@ -1302,12 +1255,12 @@ namespace llarp
       if(StrEq(key, "upstream"))
       {
         llarp::LogInfo("add upstream resolver ", val);
-        self->upstreamResolvers.push_back(val);
+        self->netConfig.emplace(std::make_pair("upstream-dns", val));
       }
       if(StrEq(key, "bind"))
       {
         llarp::LogInfo("set local dns to ", val);
-        self->resolverBindAddr = val;
+        self->netConfig.emplace(std::make_pair("local-dns", val));
       }
     }
     else if(StrEq(section, "connect"))

llarp/router.hpp

@@ -100,17 +100,17 @@ struct llarp_router
 
   llarp::service::Context hiddenServiceContext;
 
-  std::string defaultIfAddr = "auto";
-  std::string defaultIfName = "auto";
+  using NetConfig_t = std::unordered_multimap< std::string, std::string >;
 
-  /// default exit config
-  llarp::exit::Context::Config_t exitConf;
+  /// default network config for default network interface
+  NetConfig_t netConfig;
 
   bool
   ExitEnabled() const
   {
-    auto itr = exitConf.find("exit");
-    if(itr == exitConf.end())
+    // TODO: use equal_range ?
+    auto itr = netConfig.find("exit");
+    if(itr == netConfig.end())
       return false;
     return llarp::IsTrueValue(itr->second.c_str());
   }
@@ -118,9 +118,6 @@ struct llarp_router
   bool
   CreateDefaultHiddenService();
 
-  bool
-  ShouldCreateDefaultHiddenService();
-
   const std::string DefaultRPCBindAddr = "127.0.0.1:1190";
   bool enableRPCServer                 = true;
   std::unique_ptr< llarp::rpc::Server > rpcServer;
@@ -167,11 +164,6 @@ struct llarp_router
   std::unordered_map< llarp::PubKey, llarp_time_t, llarp::PubKey::Hash >
       lokinetRouters;
 
-  // TODO: change me if needed
-  const std::string defaultUpstreamResolver = "1.1.1.1:53";
-  std::list< std::string > upstreamResolvers;
-  std::string resolverBindAddr = "127.0.0.1:53";
-
   llarp_router();
   ~llarp_router();
 
@@ -340,10 +332,8 @@ struct llarp_router
   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 : netConfig)
+      out.push_back({item.first, item.second});
     for(const auto &item : in)
       out.push_back({item.first, item.second});
   }

llarp/service/context.cpp

@@ -207,18 +207,20 @@ namespace llarp
     }
 
     bool
-    Context::AddDefaultEndpoint(const std::string &ifaddr,
-                                const std::string &ifname,
-                                const std::string &remoteResolver,
-                                const std::string &localResolver)
+    Context::AddDefaultEndpoint(
+        const std::unordered_multimap< std::string, std::string > &opts)
     {
-      return AddEndpoint({"default",
-                          {{"type", "tun"},
-                           {"ifaddr", ifaddr},
-                           {"ifname", ifname},
-                           {"local-dns", localResolver},
-                           {"upstream-dns", remoteResolver}}},
-                         true);
+      Config::section_values_t configOpts;
+      configOpts.push_back({"type", "tun"});
+      {
+        auto itr = opts.begin();
+        while(itr != opts.end())
+        {
+          configOpts.push_back({itr->first, itr->second});
+          ++itr;
+        }
+      }
+      return AddEndpoint({"default", configOpts});
     }
 
     bool