dnsdist: Implement SNIRule for DoT

[thirdparty/pdns.git] / pdns / dnsdist-lua-rules.cc

diff --git a/pdns/dnsdist-lua-rules.cc b/pdns/dnsdist-lua-rules.cc
index c209d10a500822b1af30299a89b5b9df4ebc67ea..b781e8c79ac5ecef92b8e0b98dc95ea2e9015cb6 100644 (file)
--- a/pdns/dnsdist-lua-rules.cc
+++ b/pdns/dnsdist-lua-rules.cc
@@ -61,11 +61,10 @@ std::shared_ptr<DNSRule> makeRule(const luadnsrule_t& var)
 static boost::uuids::uuid makeRuleID(std::string& id)
 {
   if (id.empty()) {
-    return t_uuidGenerator();
+    return getUniqueID();
   }
 
-  boost::uuids::string_generator gen;
-  return gen(id);
+  return getUniqueID(id);
 }
 
 void parseRuleParams(boost::optional<luaruleparams_t> params, boost::uuids::uuid& uuid, uint64_t& creationOrder)
@@ -128,8 +127,7 @@ static void rmRule(GlobalStateHolder<vector<T> > *someRulActions, boost::variant
   setLuaSideEffect();
   auto rules = someRulActions->getCopy();
   if (auto str = boost::get<std::string>(&id)) {
-    boost::uuids::string_generator gen;
-    const auto uuid = gen(*str);
+    const auto uuid = getUniqueID(*str);
     if (rules.erase(std::remove_if(rules.begin(),
                                     rules.end(),
                                     [uuid](const T& a) { return a.d_id == uuid; }),
@@ -170,7 +168,7 @@ static void mvRule(GlobalStateHolder<vector<T> > *someRespRulActions, unsigned i
   }
   auto subject = rules[from];
   rules.erase(rules.begin()+from);
-  if(to == rules.size())
+  if(to > rules.size())
     rules.push_back(subject);
   else {
     if(from < to)
@@ -253,14 +251,15 @@ void setupLuaRules()
         });
     });
 
-  g_lua.writeFunction("setRules", [](std::vector<DNSDistRuleAction>& newruleactions) {
+  g_lua.writeFunction("setRules", [](const std::vector<std::pair<int, std::shared_ptr<DNSDistRuleAction>>>& newruleactions) {
       setLuaSideEffect();
       g_rulactions.modify([newruleactions](decltype(g_rulactions)::value_type& gruleactions) {
           gruleactions.clear();
-          for (const auto& newruleaction : newruleactions) {
-            if (newruleaction.d_action) {
-              auto rule=makeRule(newruleaction.d_rule);
-              gruleactions.push_back({rule, newruleaction.d_action, newruleaction.d_id});
+          for (const auto& pair : newruleactions) {
+            const auto& newruleaction = pair.second;
+            if (newruleaction->d_action) {
+              auto rule=makeRule(newruleaction->d_rule);
+              gruleactions.push_back({rule, newruleaction->d_action, newruleaction->d_id});
             }
           }
         });
@@ -281,12 +280,25 @@ void setupLuaRules()
       return std::shared_ptr<DNSRule>(new RegexRule(str));
     });
 
+#ifdef HAVE_DNS_OVER_HTTPS
+  g_lua.writeFunction("HTTPHeaderRule", [](const std::string& header, const std::string& regex) {
+      return std::shared_ptr<DNSRule>(new HTTPHeaderRule(header, regex));
+    });
+  g_lua.writeFunction("HTTPPathRule", [](const std::string& path) {
+      return std::shared_ptr<DNSRule>(new HTTPPathRule(path));
+    });
+#endif
+
 #ifdef HAVE_RE2
   g_lua.writeFunction("RE2Rule", [](const std::string& str) {
       return std::shared_ptr<DNSRule>(new RE2Rule(str));
     });
 #endif
 
+  g_lua.writeFunction("SNIRule", [](const std::string& name) {
+      return std::shared_ptr<DNSRule>(new SNIRule(name));
+  });
+
   g_lua.writeFunction("SuffixMatchNodeRule", [](const SuffixMatchNode& smn, boost::optional<bool> quiet) {
       return std::shared_ptr<DNSRule>(new SuffixMatchNodeRule(smn, quiet ? *quiet : false));
     });
@@ -420,6 +432,10 @@ void setupLuaRules()
       return std::shared_ptr<DNSRule>(new ERCodeRule(rcode));
     });
 
+  g_lua.writeFunction("EDNSVersionRule", [](uint8_t version) {
+      return std::shared_ptr<DNSRule>(new EDNSVersionRule(version));
+    });
+
   g_lua.writeFunction("EDNSOptionRule", [](uint16_t optcode) {
       return std::shared_ptr<DNSRule>(new EDNSOptionRule(optcode));
     });
@@ -459,4 +475,8 @@ void setupLuaRules()
   g_lua.registerFunction<std::shared_ptr<DNSRule>(std::shared_ptr<TimedIPSetRule>::*)()>("slice", [](std::shared_ptr<TimedIPSetRule> tisr) {
       return std::dynamic_pointer_cast<DNSRule>(tisr);
     });
+
+  g_lua.writeFunction("QNameSetRule", [](const DNSNameSet& names) {
+      return std::shared_ptr<DNSRule>(new QNameSetRule(names));
+    });
 }