From: Remi Gacogne <remi.gacogne@powerdns.com>
Date: Thu, 17 Mar 2022 09:24:25 +0000 (+0100)
Subject: dnsdist: Define types for Lua arrays and associative arrays
X-Git-Tag: rec-4.7.0-beta1~52^2
X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=bfb79abcd975a221c5de24b14585ca5fbb64431c;p=thirdparty%2Fpdns.git

dnsdist: Define types for Lua arrays and associative arrays

That PR defines types for the mapping of Lua arrays and associatives
arrays to C++, improving readability and consistency.
---

diff --git a/pdns/dnsdist-lua-actions.cc b/pdns/dnsdist-lua-actions.cc
index df7189205a..167baf36e3 100644
--- a/pdns/dnsdist-lua-actions.cc
+++ b/pdns/dnsdist-lua-actions.cc
@@ -377,7 +377,7 @@ private:
 class SpoofSVCAction : public DNSAction
 {
 public:
-  SpoofSVCAction(const std::vector<std::pair<int, SVCRecordParameters>>& parameters)
+  SpoofSVCAction(const LuaArray<SVCRecordParameters>& parameters)
   {
     d_payloads.reserve(parameters.size());
 
@@ -2171,12 +2171,12 @@ void setupLuaActions(LuaContext& luaCtx)
       return std::shared_ptr<DNSAction>(new QPSPoolAction(limit, a, stopProcessing.get_value_or(true)));
     });
 
-  luaCtx.writeFunction("SpoofAction", [](boost::variant<std::string,vector<pair<int, std::string>>> inp, boost::optional<responseParams_t> vars) {
+  luaCtx.writeFunction("SpoofAction", [](LuaTypeOrArrayOf<std::string> inp, boost::optional<responseParams_t> vars) {
       vector<ComboAddress> addrs;
       if(auto s = boost::get<std::string>(&inp)) {
         addrs.push_back(ComboAddress(*s));
       } else {
-        const auto& v = boost::get<vector<pair<int,std::string>>>(inp);
+        const auto& v = boost::get<LuaArray<std::string>>(inp);
         for(const auto& a: v) {
           addrs.push_back(ComboAddress(a.second));
         }
@@ -2188,7 +2188,7 @@ void setupLuaActions(LuaContext& luaCtx)
       return ret;
     });
 
-  luaCtx.writeFunction("SpoofSVCAction", [](const std::vector<std::pair<int, SVCRecordParameters>>& parameters, boost::optional<responseParams_t> vars) {
+  luaCtx.writeFunction("SpoofSVCAction", [](const LuaArray<SVCRecordParameters>& parameters, boost::optional<responseParams_t> vars) {
       auto ret = std::shared_ptr<DNSAction>(new SpoofSVCAction(parameters));
       auto sa = std::dynamic_pointer_cast<SpoofSVCAction>(ret);
       parseResponseConfig(vars, sa->d_responseConfig);
@@ -2202,12 +2202,12 @@ void setupLuaActions(LuaContext& luaCtx)
       return ret;
     });
 
-  luaCtx.writeFunction("SpoofRawAction", [](boost::variant<std::string,vector<pair<int, std::string>>> inp, boost::optional<responseParams_t> vars) {
+  luaCtx.writeFunction("SpoofRawAction", [](LuaTypeOrArrayOf<std::string> inp, boost::optional<responseParams_t> vars) {
       vector<string> raws;
       if(auto s = boost::get<std::string>(&inp)) {
         raws.push_back(*s);
       } else {
-        const auto& v = boost::get<vector<pair<int,std::string>>>(inp);
+        const auto& v = boost::get<LuaArray<std::string>>(inp);
         for(const auto& raw: v) {
           raws.push_back(raw.second);
         }
@@ -2271,12 +2271,12 @@ void setupLuaActions(LuaContext& luaCtx)
       return std::shared_ptr<DNSResponseAction>(new LimitTTLResponseAction(0, max));
     });
 
-  luaCtx.writeFunction("ClearRecordTypesResponseAction", [](boost::variant<int, vector<pair<int, int>>> types) {
+  luaCtx.writeFunction("ClearRecordTypesResponseAction", [](LuaTypeOrArrayOf<int> types) {
       std::set<QType> qtypes{};
       if (types.type() == typeid(int)) {
         qtypes.insert(boost::get<int>(types));
-      } else if (types.type() == typeid(vector<pair<int, int>>)) {
-        const auto& v = boost::get<vector<pair<int, int>>>(types);
+      } else if (types.type() == typeid(LuaArray<int>)) {
+        const auto& v = boost::get<LuaArray<int>>(types);
         for (const auto& tpair: v) {
           qtypes.insert(tpair.second);
         }
@@ -2338,7 +2338,7 @@ void setupLuaActions(LuaContext& luaCtx)
     });
 
 #ifndef DISABLE_PROTOBUF
-  luaCtx.writeFunction("RemoteLogAction", [](std::shared_ptr<RemoteLoggerInterface> logger, boost::optional<std::function<void(DNSQuestion*, DNSDistProtoBufMessage*)> > alterFunc, boost::optional<std::unordered_map<std::string, std::string>> vars) {
+  luaCtx.writeFunction("RemoteLogAction", [](std::shared_ptr<RemoteLoggerInterface> logger, boost::optional<std::function<void(DNSQuestion*, DNSDistProtoBufMessage*)> > alterFunc, boost::optional<LuaAssociativeTable<std::string>> vars) {
       if (logger) {
         // avoids potentially-evaluated-expression warning with clang.
         RemoteLoggerInterface& rl = *logger.get();
@@ -2362,7 +2362,7 @@ void setupLuaActions(LuaContext& luaCtx)
       return std::shared_ptr<DNSAction>(new RemoteLogAction(logger, alterFunc, serverID, ipEncryptKey));
     });
 
-  luaCtx.writeFunction("RemoteLogResponseAction", [](std::shared_ptr<RemoteLoggerInterface> logger, boost::optional<std::function<void(DNSResponse*, DNSDistProtoBufMessage*)> > alterFunc, boost::optional<bool> includeCNAME, boost::optional<std::unordered_map<std::string, std::string>> vars) {
+  luaCtx.writeFunction("RemoteLogResponseAction", [](std::shared_ptr<RemoteLoggerInterface> logger, boost::optional<std::function<void(DNSResponse*, DNSDistProtoBufMessage*)> > alterFunc, boost::optional<bool> includeCNAME, boost::optional<LuaAssociativeTable<std::string>> vars) {
       if (logger) {
         // avoids potentially-evaluated-expression warning with clang.
         RemoteLoggerInterface& rl = *logger.get();
diff --git a/pdns/dnsdist-lua-bindings-dnsquestion.cc b/pdns/dnsdist-lua-bindings-dnsquestion.cc
index 40919afdac..04e37de43a 100644
--- a/pdns/dnsdist-lua-bindings-dnsquestion.cc
+++ b/pdns/dnsdist-lua-bindings-dnsquestion.cc
@@ -89,7 +89,7 @@ void setupLuaBindingsDNSQuestion(LuaContext& luaCtx)
   luaCtx.registerFunction<void(DNSQuestion::*)(std::string, std::string)>("setTag", [](DNSQuestion& dq, const std::string& strLabel, const std::string& strValue) {
       dq.setTag(strLabel, strValue);
     });
-  luaCtx.registerFunction<void(DNSQuestion::*)(vector<pair<string, string>>)>("setTagArray", [](DNSQuestion& dq, const vector<pair<string, string>>&tags) {
+  luaCtx.registerFunction<void(DNSQuestion::*)(LuaAssociativeTable<std::string>)>("setTagArray", [](DNSQuestion& dq, const LuaAssociativeTable<std::string>&tags) {
       for (const auto& tag : tags) {
         dq.setTag(tag.first, tag.second);
       }
@@ -115,7 +115,7 @@ void setupLuaBindingsDNSQuestion(LuaContext& luaCtx)
       return *dq.qTag;
     });
 
-  luaCtx.registerFunction<void(DNSQuestion::*)(std::vector<std::pair<int, std::string>>)>("setProxyProtocolValues", [](DNSQuestion& dq, const std::vector<std::pair<int, std::string>>& values) {
+  luaCtx.registerFunction<void(DNSQuestion::*)(LuaArray<std::string>)>("setProxyProtocolValues", [](DNSQuestion& dq, const LuaArray<std::string>& values) {
     if (!dq.proxyProtocolValues) {
       dq.proxyProtocolValues = make_unique<std::vector<ProxyProtocolValue>>();
     }
@@ -137,12 +137,12 @@ void setupLuaBindingsDNSQuestion(LuaContext& luaCtx)
     dq.proxyProtocolValues->push_back({value, static_cast<uint8_t>(type)});
   });
 
-  luaCtx.registerFunction<std::vector<std::pair<int, std::string>>(DNSQuestion::*)()>("getProxyProtocolValues", [](const DNSQuestion& dq) {
+  luaCtx.registerFunction<LuaArray<std::string>(DNSQuestion::*)()>("getProxyProtocolValues", [](const DNSQuestion& dq) {
+    LuaArray<std::string> result;
     if (!dq.proxyProtocolValues) {
-      return std::vector<std::pair<int, std::string>>();
+      return result;
     }
 
-    std::vector<std::pair<int, std::string>> result;
     result.resize(dq.proxyProtocolValues->size());
     for (const auto& value : *dq.proxyProtocolValues) {
       result.push_back({ value.type, value.content });
@@ -151,10 +151,10 @@ void setupLuaBindingsDNSQuestion(LuaContext& luaCtx)
     return result;
   });
 
-  luaCtx.registerFunction<void(DNSQuestion::*)(const boost::variant<std::vector<std::pair<int, ComboAddress>>, std::vector<std::pair<int, std::string>>>& response)>("spoof", [](DNSQuestion& dq, const boost::variant<std::vector<std::pair<int, ComboAddress>>, std::vector<std::pair<int, std::string>>>& response) {
-      if (response.type() == typeid(vector<pair<int, ComboAddress>>)) {
+  luaCtx.registerFunction<void(DNSQuestion::*)(const boost::variant<LuaArray<ComboAddress>, LuaArray<std::string>>& response)>("spoof", [](DNSQuestion& dq, const boost::variant<LuaArray<ComboAddress>, LuaArray<std::string>>& response) {
+      if (response.type() == typeid(LuaArray<ComboAddress>)) {
           std::vector<ComboAddress> data;
-          auto responses = boost::get<vector<pair<int, ComboAddress>>>(response);
+          auto responses = boost::get<LuaArray<ComboAddress>>(response);
           data.reserve(responses.size());
           for (const auto& resp : responses) {
             data.push_back(resp.second);
@@ -164,9 +164,9 @@ void setupLuaBindingsDNSQuestion(LuaContext& luaCtx)
           sa(&dq, &result);
 	  return;
       }
-      if (response.type() == typeid(vector<pair<int, string>>)) {
+      if (response.type() == typeid(LuaArray<std::string>)) {
           std::vector<std::string> data;
-          auto responses = boost::get<vector<pair<int, string>>>(response);
+          auto responses = boost::get<LuaArray<std::string>>(response);
           data.reserve(responses.size());
           for (const auto& resp : responses) {
             data.push_back(resp.second);
@@ -214,7 +214,7 @@ void setupLuaBindingsDNSQuestion(LuaContext& luaCtx)
       dr.setTag(strLabel, strValue);
     });
 
-  luaCtx.registerFunction<void(DNSResponse::*)(vector<pair<string, string>>)>("setTagArray", [](DNSResponse& dr, const vector<pair<string, string>>&tags) {
+  luaCtx.registerFunction<void(DNSResponse::*)(LuaAssociativeTable<std::string>)>("setTagArray", [](DNSResponse& dr, const LuaAssociativeTable<string>&tags) {
       for (const auto& tag : tags) {
         dr.setTag(tag.first, tag.second);
       }
@@ -281,9 +281,9 @@ void setupLuaBindingsDNSQuestion(LuaContext& luaCtx)
       return dq.du->getHTTPScheme();
     });
 
-    luaCtx.registerFunction<std::unordered_map<std::string, std::string>(DNSQuestion::*)(void)const>("getHTTPHeaders", [](const DNSQuestion& dq) {
+    luaCtx.registerFunction<LuaAssociativeTable<std::string>(DNSQuestion::*)(void)const>("getHTTPHeaders", [](const DNSQuestion& dq) {
       if (dq.du == nullptr) {
-        return std::unordered_map<std::string, std::string>();
+        return LuaAssociativeTable<std::string>();
       }
       return dq.du->getHTTPHeaders();
     });
diff --git a/pdns/dnsdist-lua-bindings.cc b/pdns/dnsdist-lua-bindings.cc
index 123e3a73ff..30eff5d39d 100644
--- a/pdns/dnsdist-lua-bindings.cc
+++ b/pdns/dnsdist-lua-bindings.cc
@@ -261,33 +261,33 @@ void setupLuaBindings(LuaContext& luaCtx, bool client)
 
 #ifndef DISABLE_SUFFIX_MATCH_BINDINGS
   /* SuffixMatchNode */
-  luaCtx.registerFunction<void (SuffixMatchNode::*)(const boost::variant<DNSName, string, vector<pair<int, DNSName>>, vector<pair<int, string>>> &name)>("add", [](SuffixMatchNode &smn, const boost::variant<DNSName, string, vector<pair<int, DNSName>>, vector<pair<int, string>>> &name) {
+  luaCtx.registerFunction<void (SuffixMatchNode::*)(const boost::variant<DNSName, std::string, LuaArray<DNSName>, LuaArray<std::string>> &name)>("add", [](SuffixMatchNode &smn, const boost::variant<DNSName, std::string, LuaArray<DNSName>, LuaArray<std::string>> &name) {
       if (name.type() == typeid(DNSName)) {
           auto n = boost::get<DNSName>(name);
           smn.add(n);
           return;
       }
-      if (name.type() == typeid(string)) {
-          auto n = boost::get<string>(name);
+      if (name.type() == typeid(std::string)) {
+          auto n = boost::get<std::string>(name);
           smn.add(n);
           return;
       }
-      if (name.type() == typeid(vector<pair<int, DNSName>>)) {
-          auto names = boost::get<vector<pair<int, DNSName>>>(name);
+      if (name.type() == typeid(LuaArray<DNSName>)) {
+          auto names = boost::get<LuaArray<DNSName>>(name);
           for (const auto& n : names) {
             smn.add(n.second);
           }
           return;
       }
-      if (name.type() == typeid(vector<pair<int, string>>)) {
-          auto names = boost::get<vector<pair<int, string>>>(name);
+      if (name.type() == typeid(LuaArray<std::string>)) {
+          auto names = boost::get<LuaArray<string>>(name);
           for (const auto& n : names) {
             smn.add(n.second);
           }
           return;
       }
   });
-  luaCtx.registerFunction<void (SuffixMatchNode::*)(const boost::variant<DNSName, string, vector<pair<int, DNSName>>, vector<pair<int, string>>> &name)>("remove", [](SuffixMatchNode &smn, const boost::variant<DNSName, string, vector<pair<int, DNSName>>, vector<pair<int, string>>> &name) {
+  luaCtx.registerFunction<void (SuffixMatchNode::*)(const boost::variant<DNSName, string, LuaArray<DNSName>, LuaArray<std::string>> &name)>("remove", [](SuffixMatchNode &smn, const boost::variant<DNSName, string, LuaArray<DNSName>, LuaArray<std::string>> &name) {
       if (name.type() == typeid(DNSName)) {
           auto n = boost::get<DNSName>(name);
           smn.remove(n);
@@ -299,15 +299,15 @@ void setupLuaBindings(LuaContext& luaCtx, bool client)
           smn.remove(d);
           return;
       }
-      if (name.type() == typeid(vector<pair<int, DNSName>>)) {
-          auto names = boost::get<vector<pair<int, DNSName>>>(name);
+      if (name.type() == typeid(LuaArray<DNSName>)) {
+          auto names = boost::get<LuaArray<DNSName>>(name);
           for (const auto& n : names) {
             smn.remove(n.second);
           }
           return;
       }
-      if (name.type() == typeid(vector<pair<int, string>>)) {
-          auto names = boost::get<vector<pair<int, string>>>(name);
+      if (name.type() == typeid(LuaArray<std::string>)) {
+          auto names = boost::get<LuaArray<std::string>>(name);
           for (const auto& n : names) {
             DNSName d(n.second);
             smn.remove(d);
@@ -424,7 +424,7 @@ void setupLuaBindings(LuaContext& luaCtx, bool client)
 
   /* BPF Filter */
 #ifdef HAVE_EBPF
-  using bpfFilterMapParams = boost::variant<uint32_t, std::unordered_map<std::string, boost::variant<uint32_t, std::string>>>;
+  using bpfFilterMapParams = boost::variant<uint32_t, LuaAssociativeTable<boost::variant<uint32_t, std::string>>>;
   luaCtx.writeFunction("newBPFFilter", [client](bpfFilterMapParams v4Params, bpfFilterMapParams v6Params, bpfFilterMapParams qnameParams, boost::optional<bool> external) {
       if (client) {
         return std::shared_ptr<BPFFilter>(nullptr);
@@ -437,8 +437,8 @@ void setupLuaBindings(LuaContext& luaCtx, bool client)
         if (params.type() == typeid(uint32_t)) {
           config.d_maxItems = boost::get<uint32_t>(params);
         }
-        else if (params.type() == typeid(std::unordered_map<std::string, boost::variant<uint32_t, std::string>>)) {
-          auto map = boost::get<std::unordered_map<std::string, boost::variant<uint32_t, std::string>>>(params);
+        else if (params.type() == typeid(LuaAssociativeTable<boost::variant<uint32_t, std::string>>)) {
+          auto map = boost::get<LuaAssociativeTable<boost::variant<uint32_t, std::string>>>(params);
           if (map.count("maxItems")) {
             config.d_maxItems = boost::get<uint32_t>(map.at("maxItems"));
           }
@@ -578,13 +578,13 @@ void setupLuaBindings(LuaContext& luaCtx, bool client)
         }
     });
 
-    luaCtx.registerFunction<void(std::shared_ptr<DynBPFFilter>::*)(boost::variant<std::string, std::vector<std::pair<int, std::string>>>)>("excludeRange", [](std::shared_ptr<DynBPFFilter> dbpf, boost::variant<std::string, std::vector<std::pair<int, std::string>>> ranges) {
+    luaCtx.registerFunction<void(std::shared_ptr<DynBPFFilter>::*)(LuaTypeOrArrayOf<std::string>)>("excludeRange", [](std::shared_ptr<DynBPFFilter> dbpf, LuaTypeOrArrayOf<std::string> ranges) {
       if (!dbpf) {
         return;
       }
 
-      if (ranges.type() == typeid(std::vector<std::pair<int, std::string>>)) {
-        for (const auto& range : *boost::get<std::vector<std::pair<int, std::string>>>(&ranges)) {
+      if (ranges.type() == typeid(LuaArray<std::string>)) {
+        for (const auto& range : *boost::get<LuaArray<std::string>>(&ranges)) {
           dbpf->excludeRange(Netmask(range.second));
         }
       }
@@ -593,13 +593,13 @@ void setupLuaBindings(LuaContext& luaCtx, bool client)
       }
     });
 
-    luaCtx.registerFunction<void(std::shared_ptr<DynBPFFilter>::*)(boost::variant<std::string, std::vector<std::pair<int, std::string>>>)>("includeRange", [](std::shared_ptr<DynBPFFilter> dbpf, boost::variant<std::string, std::vector<std::pair<int, std::string>>> ranges) {
+    luaCtx.registerFunction<void(std::shared_ptr<DynBPFFilter>::*)(LuaTypeOrArrayOf<std::string>)>("includeRange", [](std::shared_ptr<DynBPFFilter> dbpf, LuaTypeOrArrayOf<std::string> ranges) {
       if (!dbpf) {
         return;
       }
 
-      if (ranges.type() == typeid(std::vector<std::pair<int, std::string>>)) {
-        for (const auto& range : *boost::get<std::vector<std::pair<int, std::string>>>(&ranges)) {
+      if (ranges.type() == typeid(LuaArray<std::string>)) {
+        for (const auto& range : *boost::get<LuaArray<std::string>>(&ranges)) {
           dbpf->includeRange(Netmask(range.second));
         }
       }
@@ -621,13 +621,13 @@ void setupLuaBindings(LuaContext& luaCtx, bool client)
     return values;
   });
 
-  luaCtx.writeFunction("newDOHResponseMapEntry", [](const std::string& regex, uint64_t status, const std::string& content, boost::optional<std::map<std::string, std::string>> customHeaders) {
+  luaCtx.writeFunction("newDOHResponseMapEntry", [](const std::string& regex, uint64_t status, const std::string& content, boost::optional<LuaAssociativeTable<std::string>> customHeaders) {
     checkParameterBound("newDOHResponseMapEntry", status, std::numeric_limits<uint16_t>::max());
-    boost::optional<std::vector<std::pair<std::string, std::string>>> headers{boost::none};
+    boost::optional<LuaAssociativeTable<std::string>> headers{boost::none};
     if (customHeaders) {
-      headers = std::vector<std::pair<std::string, std::string>>();
+      headers = LuaAssociativeTable<std::string>();
       for (const auto& header : *customHeaders) {
-        headers->push_back({ boost::to_lower_copy(header.first), header.second });
+        (*headers)[boost::to_lower_copy(header.first)] = header.second;
       }
     }
     return std::make_shared<DOHResponseMapEntry>(regex, status, PacketBuffer(content.begin(), content.end()), headers);
@@ -647,7 +647,7 @@ void setupLuaBindings(LuaContext& luaCtx, bool client)
   });
 
   luaCtx.writeFunction("getListOfNetworkInterfaces", []() {
-    std::vector<std::pair<int, std::string>> result;
+    LuaArray<std::string> result;
     auto itfs = getListOfNetworkInterfaces();
     int counter = 1;
     for (const auto& itf : itfs) {
@@ -657,7 +657,7 @@ void setupLuaBindings(LuaContext& luaCtx, bool client)
   });
 
   luaCtx.writeFunction("getListOfAddressesOfNetworkInterface", [](const std::string& itf) {
-    std::vector<std::pair<int, std::string>> result;
+    LuaArray<std::string> result;
     auto addrs = getListOfAddressesOfNetworkInterface(itf);
     int counter = 1;
     for (const auto& addr : addrs) {
diff --git a/pdns/dnsdist-lua-inspection.cc b/pdns/dnsdist-lua-inspection.cc
index 94d2381f92..112172ce9b 100644
--- a/pdns/dnsdist-lua-inspection.cc
+++ b/pdns/dnsdist-lua-inspection.cc
@@ -29,7 +29,7 @@
 #include "statnode.hh"
 
 #ifndef DISABLE_TOP_N_BINDINGS
-static std::vector<std::pair<int, vector<boost::variant<string,double>>>> getGenResponses(uint64_t top, boost::optional<int> labels, std::function<bool(const Rings::Response&)> pred)
+static LuaArray<std::vector<boost::variant<string,double>>> getGenResponses(uint64_t top, boost::optional<int> labels, std::function<bool(const Rings::Response&)> pred)
 {
   setLuaNoSideEffect();
   map<DNSName, unsigned int> counts;
@@ -62,7 +62,7 @@ static std::vector<std::pair<int, vector<boost::variant<string,double>>>> getGen
   //      cout<<"Looked at "<<total<<" responses, "<<counts.size()<<" different ones"<<endl;
   vector<pair<unsigned int, DNSName>> rcounts;
   rcounts.reserve(counts.size());
-  for(const auto& c : counts)
+  for (const auto& c : counts)
     rcounts.emplace_back(c.second, c.first.makeLowerCase());
 
   sort(rcounts.begin(), rcounts.end(), [](const decltype(rcounts)::value_type& a,
@@ -70,15 +70,17 @@ static std::vector<std::pair<int, vector<boost::variant<string,double>>>> getGen
          return b.first < a.first;
        });
 
-  std::vector<std::pair<int, vector<boost::variant<string,double>>>> ret;
+  LuaArray<vector<boost::variant<string,double>>> ret;
   ret.reserve(std::min(rcounts.size(), static_cast<size_t>(top + 1U)));
   uint64_t count = 1;
   unsigned int rest = 0;
-  for(const auto& rc : rcounts) {
-    if(count==top+1)
+  for (const auto& rc : rcounts) {
+    if (count == top+1) {
       rest+=rc.first;
-    else
+    }
+    else {
       ret.push_back({count++, {rc.second.toString(), rc.first, 100.0*rc.first/total}});
+    }
   }
 
   if (total > 0) {
@@ -140,10 +142,10 @@ static void statNodeRespRing(statvisitor_t visitor, uint64_t seconds)
       visitor(*node_, self, children);},  node);
 }
 
-static vector<pair<int, std::vector<std::pair<string,string> > > > getRespRing(boost::optional<int> rcode)
+static LuaArray<LuaAssociativeTable<std::string>> getRespRing(boost::optional<int> rcode)
 {
-  typedef std::vector<std::pair<string,string>> entry_t;
-  vector<pair<int, entry_t > > ret;
+  typedef LuaAssociativeTable<std::string> entry_t;
+  LuaArray<entry_t> ret;
 
   for (const auto& shard : g_rings.d_shards) {
     auto rl = shard->respRing.lock();
@@ -154,8 +156,8 @@ static vector<pair<int, std::vector<std::pair<string,string> > > > getRespRing(b
         continue;
       }
       entry_t e;
-      e.push_back({ "qname", c.name.toString() });
-      e.push_back({ "rcode", std::to_string(c.dh.rcode) });
+      e["qname"] = c.name.toString();
+      e["rcode"] = std::to_string(c.dh.rcode);
       ret.emplace_back(count, std::move(e));
       count++;
     }
@@ -396,7 +398,7 @@ void setupLuaInspection(LuaContext& luaCtx)
       }
     });
 
-  luaCtx.writeFunction("grepq", [](boost::variant<string, vector<pair<int,string> > > inp, boost::optional<unsigned int> limit) {
+  luaCtx.writeFunction("grepq", [](LuaTypeOrArrayOf<std::string> inp, boost::optional<unsigned int> limit) {
       setLuaNoSideEffect();
       boost::optional<Netmask>  nm;
       boost::optional<DNSName> dn;
@@ -407,7 +409,7 @@ void setupLuaInspection(LuaContext& luaCtx)
       if(str)
         vec.push_back(*str);
       else {
-        auto v = boost::get<vector<pair<int, string> > >(inp);
+        auto v = boost::get<LuaArray<std::string>>(inp);
         for(const auto& a: v)
           vec.push_back(a.second);
       }
@@ -825,9 +827,9 @@ void setupLuaInspection(LuaContext& luaCtx)
         group->setMasks(v4, v6, port);
       }
     });
-  luaCtx.registerFunction<void(std::shared_ptr<DynBlockRulesGroup>::*)(boost::variant<std::string, std::vector<std::pair<int, std::string>>, NetmaskGroup>)>("excludeRange", [](std::shared_ptr<DynBlockRulesGroup>& group, boost::variant<std::string, std::vector<std::pair<int, std::string>>, NetmaskGroup> ranges) {
-      if (ranges.type() == typeid(std::vector<std::pair<int, std::string>>)) {
-        for (const auto& range : *boost::get<std::vector<std::pair<int, std::string>>>(&ranges)) {
+  luaCtx.registerFunction<void(std::shared_ptr<DynBlockRulesGroup>::*)(boost::variant<std::string, LuaArray<std::string>, NetmaskGroup>)>("excludeRange", [](std::shared_ptr<DynBlockRulesGroup>& group, boost::variant<std::string, LuaArray<std::string>, NetmaskGroup> ranges) {
+      if (ranges.type() == typeid(LuaArray<std::string>)) {
+        for (const auto& range : *boost::get<LuaArray<std::string>>(&ranges)) {
           group->excludeRange(Netmask(range.second));
         }
       }
@@ -838,9 +840,9 @@ void setupLuaInspection(LuaContext& luaCtx)
         group->excludeRange(Netmask(*boost::get<std::string>(&ranges)));
       }
     });
-  luaCtx.registerFunction<void(std::shared_ptr<DynBlockRulesGroup>::*)(boost::variant<std::string, std::vector<std::pair<int, std::string>>, NetmaskGroup>)>("includeRange", [](std::shared_ptr<DynBlockRulesGroup>& group, boost::variant<std::string, std::vector<std::pair<int, std::string>>, NetmaskGroup> ranges) {
-      if (ranges.type() == typeid(std::vector<std::pair<int, std::string>>)) {
-        for (const auto& range : *boost::get<std::vector<std::pair<int, std::string>>>(&ranges)) {
+  luaCtx.registerFunction<void(std::shared_ptr<DynBlockRulesGroup>::*)(boost::variant<std::string, LuaArray<std::string>, NetmaskGroup>)>("includeRange", [](std::shared_ptr<DynBlockRulesGroup>& group, boost::variant<std::string, LuaArray<std::string>, NetmaskGroup> ranges) {
+      if (ranges.type() == typeid(LuaArray<std::string>)) {
+        for (const auto& range : *boost::get<LuaArray<std::string>>(&ranges)) {
           group->includeRange(Netmask(range.second));
         }
       }
@@ -851,9 +853,9 @@ void setupLuaInspection(LuaContext& luaCtx)
         group->includeRange(Netmask(*boost::get<std::string>(&ranges)));
       }
     });
-  luaCtx.registerFunction<void(std::shared_ptr<DynBlockRulesGroup>::*)(boost::variant<std::string, std::vector<std::pair<int, std::string>>>)>("excludeDomains", [](std::shared_ptr<DynBlockRulesGroup>& group, boost::variant<std::string, std::vector<std::pair<int, std::string>>> domains) {
-      if (domains.type() == typeid(std::vector<std::pair<int, std::string>>)) {
-        for (const auto& range : *boost::get<std::vector<std::pair<int, std::string>>>(&domains)) {
+  luaCtx.registerFunction<void(std::shared_ptr<DynBlockRulesGroup>::*)(LuaTypeOrArrayOf<std::string>)>("excludeDomains", [](std::shared_ptr<DynBlockRulesGroup>& group, LuaTypeOrArrayOf<std::string> domains) {
+      if (domains.type() == typeid(LuaArray<std::string>)) {
+        for (const auto& range : *boost::get<LuaArray<std::string>>(&domains)) {
           group->excludeDomain(DNSName(range.second));
         }
       }
diff --git a/pdns/dnsdist-lua-rules.cc b/pdns/dnsdist-lua-rules.cc
index f850856307..5fd9c9cd74 100644
--- a/pdns/dnsdist-lua-rules.cc
+++ b/pdns/dnsdist-lua-rules.cc
@@ -41,15 +41,15 @@ std::shared_ptr<DNSRule> makeRule(const luadnsrule_t& var)
   if (var.type() == typeid(string))
     add(*boost::get<string>(&var));
 
-  else if (var.type() == typeid(vector<pair<int, string>>))
-    for(const auto& a : *boost::get<vector<pair<int, string>>>(&var))
+  else if (var.type() == typeid(LuaArray<std::string>))
+    for(const auto& a : *boost::get<LuaArray<std::string>>(&var))
       add(a.second);
 
   else if (var.type() == typeid(DNSName))
     smn.add(*boost::get<DNSName>(&var));
 
-  else if (var.type() == typeid(vector<pair<int, DNSName>>))
-    for(const auto& a : *boost::get<vector<pair<int, DNSName>>>(&var))
+  else if (var.type() == typeid(LuaArray<DNSName>))
+    for(const auto& a : *boost::get<LuaArray<DNSName>>(&var))
       smn.add(a.second);
 
   if(nmg.empty())
@@ -86,7 +86,7 @@ void parseRuleParams(boost::optional<luaruleparams_t> params, boost::uuids::uuid
   creationOrder = s_creationOrder++;
 }
 
-typedef std::unordered_map<std::string, boost::variant<bool, int, std::string, std::vector<std::pair<int,int> > > > ruleparams_t;
+typedef LuaAssociativeTable<boost::variant<bool, int, std::string, LuaArray<int> > > ruleparams_t;
 
 template<typename T>
 static std::string rulesToString(const std::vector<T>& rules, boost::optional<ruleparams_t> vars)
@@ -307,7 +307,7 @@ void setupLuaRules(LuaContext& luaCtx)
         });
     });
 
-  luaCtx.writeFunction("setRules", [](const std::vector<std::pair<int, std::shared_ptr<DNSDistRuleAction>>>& newruleactions) {
+  luaCtx.writeFunction("setRules", [](const LuaArray<std::shared_ptr<DNSDistRuleAction>>& newruleactions) {
       setLuaSideEffect();
       g_ruleactions.modify([newruleactions](decltype(g_ruleactions)::value_type& gruleactions) {
           gruleactions.clear();
@@ -491,11 +491,11 @@ void setupLuaRules(LuaContext& luaCtx)
       return std::shared_ptr<DNSRule>(new OpcodeRule(code));
     });
 
-  luaCtx.writeFunction("AndRule", [](vector<pair<int, std::shared_ptr<DNSRule> > >a) {
+  luaCtx.writeFunction("AndRule", [](LuaArray<std::shared_ptr<DNSRule>> a) {
       return std::shared_ptr<DNSRule>(new AndRule(a));
     });
 
-  luaCtx.writeFunction("OrRule", [](vector<pair<int, std::shared_ptr<DNSRule> > >a) {
+  luaCtx.writeFunction("OrRule", [](LuaArray<std::shared_ptr<DNSRule>>a) {
       return std::shared_ptr<DNSRule>(new OrRule(a));
     });
 
diff --git a/pdns/dnsdist-lua-vars.cc b/pdns/dnsdist-lua-vars.cc
index ed5cf1e5d7..265568f9ff 100644
--- a/pdns/dnsdist-lua-vars.cc
+++ b/pdns/dnsdist-lua-vars.cc
@@ -27,7 +27,7 @@
 
 void setupLuaVars(LuaContext& luaCtx)
 {
-  luaCtx.writeVariable("DNSAction", std::unordered_map<string,int>{
+  luaCtx.writeVariable("DNSAction", LuaAssociativeTable<int>{
       {"Drop", (int)DNSAction::Action::Drop},
       {"Nxdomain", (int)DNSAction::Action::Nxdomain},
       {"Refused", (int)DNSAction::Action::Refused},
@@ -45,7 +45,7 @@ void setupLuaVars(LuaContext& luaCtx)
       {"NoRecurse", (int)DNSAction::Action::NoRecurse}
     });
 
-  luaCtx.writeVariable("DNSResponseAction", std::unordered_map<string,int>{
+  luaCtx.writeVariable("DNSResponseAction", LuaAssociativeTable<int>{
       {"Allow",        (int)DNSResponseAction::Action::Allow        },
       {"Delay",        (int)DNSResponseAction::Action::Delay        },
       {"Drop",         (int)DNSResponseAction::Action::Drop         },
@@ -54,14 +54,14 @@ void setupLuaVars(LuaContext& luaCtx)
       {"None",         (int)DNSResponseAction::Action::None         }
     });
 
-  luaCtx.writeVariable("DNSClass", std::unordered_map<string,int>{
+  luaCtx.writeVariable("DNSClass", LuaAssociativeTable<int>{
       {"IN",    QClass::IN    },
       {"CHAOS", QClass::CHAOS },
       {"NONE",  QClass::NONE  },
       {"ANY",   QClass::ANY   }
     });
 
-  luaCtx.writeVariable("DNSOpcode", std::unordered_map<string,int>{
+  luaCtx.writeVariable("DNSOpcode", LuaAssociativeTable<int>{
       {"Query",  Opcode::Query  },
       {"IQuery", Opcode::IQuery },
       {"Status", Opcode::Status },
@@ -69,14 +69,14 @@ void setupLuaVars(LuaContext& luaCtx)
       {"Update", Opcode::Update }
     });
 
-  luaCtx.writeVariable("DNSSection", std::unordered_map<string,int>{
+  luaCtx.writeVariable("DNSSection", LuaAssociativeTable<int>{
       {"Question",  0 },
       {"Answer",    1 },
       {"Authority", 2 },
       {"Additional",3 }
     });
 
-  luaCtx.writeVariable("EDNSOptionCode", std::unordered_map<string,int>{
+  luaCtx.writeVariable("EDNSOptionCode", LuaAssociativeTable<int>{
       {"NSID",         EDNSOptionCode::NSID },
       {"DAU",          EDNSOptionCode::DAU },
       {"DHU",          EDNSOptionCode::DHU },
@@ -90,7 +90,7 @@ void setupLuaVars(LuaContext& luaCtx)
       {"KEYTAG",       EDNSOptionCode::KEYTAG }
     });
 
-  luaCtx.writeVariable("DNSRCode", std::unordered_map<string, int>{
+  luaCtx.writeVariable("DNSRCode", LuaAssociativeTable<int>{
       {"NOERROR",  RCode::NoError  },
       {"FORMERR",  RCode::FormErr  },
       {"SERVFAIL", RCode::ServFail },
@@ -113,13 +113,14 @@ void setupLuaVars(LuaContext& luaCtx)
       {"BADCOOKIE",ERCode::BADCOOKIE }
   });
 
-  vector<pair<string, int> > dd;
-  for(const auto& n : QType::names)
-    dd.push_back({n.first, n.second});
+  LuaAssociativeTable<int> dd;
+  for (const auto& n : QType::names) {
+    dd[n.first] = n.second;
+  }
   luaCtx.writeVariable("DNSQType", dd);
 
 #ifdef HAVE_DNSCRYPT
-    luaCtx.writeVariable("DNSCryptExchangeVersion", std::unordered_map<string,int>{
+    luaCtx.writeVariable("DNSCryptExchangeVersion", LuaAssociativeTable<int>{
         { "VERSION1", DNSCryptExchangeVersion::VERSION1 },
         { "VERSION2", DNSCryptExchangeVersion::VERSION2 },
     });
diff --git a/pdns/dnsdist-lua.cc b/pdns/dnsdist-lua.cc
index 76801f9b19..d7458a2c5b 100644
--- a/pdns/dnsdist-lua.cc
+++ b/pdns/dnsdist-lua.cc
@@ -100,7 +100,7 @@ void resetLuaSideEffect()
   g_noLuaSideEffect = boost::logic::indeterminate;
 }
 
-typedef std::unordered_map<std::string, boost::variant<bool, int, std::string, std::vector<std::pair<int, int>>, std::vector<std::pair<int, std::string>>, std::vector<std::pair<std::string, std::string>>>> localbind_t;
+using localbind_t = LuaAssociativeTable<boost::variant<bool, int, std::string, LuaArray<int>, LuaArray<std::string>, LuaAssociativeTable<std::string>>>;
 
 static void parseLocalBindVars(boost::optional<localbind_t> vars, bool& reusePort, int& tcpFastOpenQueueSize, std::string& interface, std::set<int>& cpus, int& tcpListenQueueSize, uint64_t& maxInFlightQueriesPerConnection, uint64_t& tcpMaxConcurrentConnections)
 {
@@ -124,7 +124,7 @@ static void parseLocalBindVars(boost::optional<localbind_t> vars, bool& reusePor
       interface = boost::get<std::string>((*vars)["interface"]);
     }
     if (vars->count("cpus")) {
-      for (const auto& cpu : boost::get<std::vector<std::pair<int, int>>>((*vars)["cpus"])) {
+      for (const auto& cpu : boost::get<LuaArray<int>>((*vars)["cpus"])) {
         cpus.insert(cpu.second);
       }
     }
@@ -132,7 +132,7 @@ static void parseLocalBindVars(boost::optional<localbind_t> vars, bool& reusePor
 }
 
 #if defined(HAVE_DNS_OVER_TLS) || defined(HAVE_DNS_OVER_HTTPS)
-static bool loadTLSCertificateAndKeys(const std::string& context, std::vector<TLSCertKeyPair>& pairs, boost::variant<std::string, std::shared_ptr<TLSCertKeyPair>, std::vector<std::pair<int, std::string>>, std::vector<std::pair<int, std::shared_ptr<TLSCertKeyPair>>>> certFiles, boost::variant<std::string, std::vector<std::pair<int, std::string>>> keyFiles)
+static bool loadTLSCertificateAndKeys(const std::string& context, std::vector<TLSCertKeyPair>& pairs, boost::variant<std::string, std::shared_ptr<TLSCertKeyPair>, LuaArray<std::string>, LuaArray<std::shared_ptr<TLSCertKeyPair>>> certFiles, LuaTypeOrArrayOf<std::string> keyFiles)
 {
   if (certFiles.type() == typeid(std::string) && keyFiles.type() == typeid(std::string)) {
     auto certFile = boost::get<std::string>(certFiles);
@@ -145,16 +145,16 @@ static bool loadTLSCertificateAndKeys(const std::string& context, std::vector<TL
     pairs.clear();
     pairs.emplace_back(*cert);
   }
-  else if (certFiles.type() == typeid(std::vector<std::pair<int, std::shared_ptr<TLSCertKeyPair>>>)) {
-    auto certs = boost::get<std::vector<std::pair<int, std::shared_ptr<TLSCertKeyPair>>>>(certFiles);
+  else if (certFiles.type() == typeid(LuaArray<std::shared_ptr<TLSCertKeyPair>>)) {
+    auto certs = boost::get<LuaArray<std::shared_ptr<TLSCertKeyPair>>>(certFiles);
     pairs.clear();
     for (const auto& cert : certs) {
       pairs.emplace_back(*(cert.second));
     }
   }
-  else if (certFiles.type() == typeid(std::vector<std::pair<int, std::string>>) && keyFiles.type() == typeid(std::vector<std::pair<int, std::string>>)) {
-    auto certFilesVect = boost::get<std::vector<std::pair<int, std::string>>>(certFiles);
-    auto keyFilesVect = boost::get<std::vector<std::pair<int, std::string>>>(keyFiles);
+  else if (certFiles.type() == typeid(LuaArray<std::string>) && keyFiles.type() == typeid(LuaArray<std::string>)) {
+    auto certFilesVect = boost::get<LuaArray<std::string>>(certFiles);
+    auto keyFilesVect = boost::get<LuaArray<std::string>>(keyFiles);
     if (certFilesVect.size() == keyFilesVect.size()) {
       pairs.clear();
       for (size_t idx = 0; idx < certFilesVect.size(); idx++) {
@@ -226,7 +226,7 @@ static void parseTLSConfig(TLSConfig& config, const std::string& context, boost:
   }
 
   if (vars->count("ocspResponses")) {
-    auto files = boost::get<std::vector<std::pair<int, std::string>>>((*vars)["ocspResponses"]);
+    auto files = boost::get<LuaArray<std::string>>((*vars)["ocspResponses"]);
     for (const auto& file : files) {
       config.d_ocspFiles.push_back(file.second);
     }
@@ -268,10 +268,10 @@ static void LuaThread(const std::string code)
   LuaContext l;
   // submitToMainThread is camelcased, threadmessage is not.
   // This follows our tradition of hooks we call being lowercased but functions the user can call being camelcased.
-  l.writeFunction("submitToMainThread", [](std::string cmd, std::unordered_map<std::string, std::string> data) {
+  l.writeFunction("submitToMainThread", [](std::string cmd, LuaAssociativeTable<std::string> data) {
     auto lua = g_lua.lock();
     // maybe offer more than `void`
-    auto func = lua->readVariable<boost::optional<std::function<void(std::string cmd, std::unordered_map<std::string, std::string> data)>>>("threadmessage");
+    auto func = lua->readVariable<boost::optional<std::function<void(std::string cmd, LuaAssociativeTable<std::string> data)>>>("threadmessage");
     if (func) {
       func.get()(cmd, data);
     }
@@ -299,7 +299,7 @@ static void LuaThread(const std::string code)
 
 static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
 {
-  typedef std::unordered_map<std::string, boost::variant<bool, std::string, vector<pair<int, std::string>>, DownstreamState::checkfunc_t>> newserver_t;
+  typedef LuaAssociativeTable<boost::variant<bool, std::string, LuaArray<std::string>, DownstreamState::checkfunc_t>> newserver_t;
   luaCtx.writeFunction("inClientStartup", [client]() {
     return client && !g_configurationDone;
   });
@@ -514,7 +514,7 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
                          }
 
                          if (vars.count("cpus")) {
-                           for (const auto& cpu : boost::get<vector<pair<int, string>>>(vars["cpus"])) {
+                           for (const auto& cpu : boost::get<LuaArray<std::string>>(vars["cpus"])) {
                              config.d_cpus.insert(std::stoi(cpu.second));
                            }
                          }
@@ -603,7 +603,7 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
                              config.pools.insert(*pool);
                            }
                            else {
-                             auto pools = boost::get<vector<pair<int, string>>>(vars["pool"]);
+                             auto pools = boost::get<LuaArray<std::string>>(vars["pool"]);
                              for (auto& p : pools) {
                                config.pools.insert(p.second);
                              }
@@ -824,14 +824,14 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
     }
   });
 
-  luaCtx.writeFunction("setACL", [](boost::variant<string, vector<pair<int, string>>> inp) {
+  luaCtx.writeFunction("setACL", [](LuaTypeOrArrayOf<std::string> inp) {
     setLuaSideEffect();
     NetmaskGroup nmg;
     if (auto str = boost::get<string>(&inp)) {
       nmg.addMask(*str);
     }
     else
-      for (const auto& p : boost::get<vector<pair<int, string>>>(inp)) {
+      for (const auto& p : boost::get<LuaArray<std::string>>(inp)) {
         nmg.addMask(p.second);
       }
     g_ACL.setState(nmg);
@@ -888,7 +888,7 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
     _exit(0);
   });
 
-  typedef std::unordered_map<std::string, boost::variant<bool, std::string>> showserversopts_t;
+  typedef LuaAssociativeTable<boost::variant<bool, std::string>> showserversopts_t;
 
   luaCtx.writeFunction("showServers", [](boost::optional<showserversopts_t> vars) {
     setLuaNoSideEffect();
@@ -955,7 +955,7 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
 
   luaCtx.writeFunction("getServers", []() {
     setLuaNoSideEffect();
-    vector<pair<int, std::shared_ptr<DownstreamState>>> ret;
+    LuaArray<std::shared_ptr<DownstreamState>> ret;
     int count = 1;
     for (const auto& s : g_dstates.getCopy()) {
       ret.push_back(make_pair(count++, s));
@@ -1038,7 +1038,7 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
     }
   });
 
-  typedef std::unordered_map<std::string, boost::variant<bool, std::string, std::unordered_map<std::string, std::string>>> webserveropts_t;
+  typedef LuaAssociativeTable<boost::variant<bool, std::string, LuaAssociativeTable<std::string>>> webserveropts_t;
 
   luaCtx.writeFunction("setWebserverConfig", [](boost::optional<webserveropts_t> vars) {
     setLuaSideEffect();
@@ -1152,7 +1152,7 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
     g_consoleACL.modify([netmask](NetmaskGroup& nmg) { nmg.addMask(netmask); });
   });
 
-  luaCtx.writeFunction("setConsoleACL", [](boost::variant<string, vector<pair<int, string>>> inp) {
+  luaCtx.writeFunction("setConsoleACL", [](LuaTypeOrArrayOf<std::string> inp) {
     setLuaSideEffect();
 
 #ifndef HAVE_LIBSODIUM
@@ -1164,7 +1164,7 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
       nmg.addMask(*str);
     }
     else
-      for (const auto& p : boost::get<vector<pair<int, string>>>(inp)) {
+      for (const auto& p : boost::get<LuaArray<std::string>>(inp)) {
         nmg.addMask(p.second);
       }
     g_consoleACL.setState(nmg);
@@ -1495,7 +1495,7 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
                        });
 
   luaCtx.writeFunction("addDynBlockSMT",
-                       [](const vector<pair<int, string>>& names, const std::string& msg, boost::optional<int> seconds, boost::optional<DNSAction::Action> action) {
+                       [](const LuaArray<std::string>& names, const std::string& msg, boost::optional<int> seconds, boost::optional<DNSAction::Action> action) {
                          if (names.empty()) {
                            return;
                          }
@@ -1552,7 +1552,7 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
   });
 
 #ifdef HAVE_DNSCRYPT
-  luaCtx.writeFunction("addDNSCryptBind", [](const std::string& addr, const std::string& providerName, boost::variant<std::string, std::vector<std::pair<int, std::string>>> certFiles, boost::variant<std::string, std::vector<std::pair<int, std::string>>> keyFiles, boost::optional<localbind_t> vars) {
+  luaCtx.writeFunction("addDNSCryptBind", [](const std::string& addr, const std::string& providerName, LuaTypeOrArrayOf<std::string> certFiles, LuaTypeOrArrayOf<std::string> keyFiles, boost::optional<localbind_t> vars) {
     if (g_configurationDone) {
       g_outputBuffer = "addDNSCryptBind cannot be used at runtime!\n";
       return;
@@ -1573,9 +1573,9 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
       auto keyFile = boost::get<std::string>(keyFiles);
       certKeys.push_back({certFile, keyFile});
     }
-    else if (certFiles.type() == typeid(std::vector<std::pair<int, std::string>>) && keyFiles.type() == typeid(std::vector<std::pair<int, std::string>>)) {
-      auto certFilesVect = boost::get<std::vector<std::pair<int, std::string>>>(certFiles);
-      auto keyFilesVect = boost::get<std::vector<std::pair<int, std::string>>>(keyFiles);
+    else if (certFiles.type() == typeid(LuaArray<std::string>) && keyFiles.type() == typeid(LuaArray<std::string>)) {
+      auto certFilesVect = boost::get<LuaArray<std::string>>(certFiles);
+      auto keyFilesVect = boost::get<LuaArray<std::string>>(keyFiles);
       if (certFilesVect.size() == keyFilesVect.size()) {
         for (size_t idx = 0; idx < certFilesVect.size(); idx++) {
           certKeys.push_back({certFilesVect.at(idx).second, keyFilesVect.at(idx).second});
@@ -1822,7 +1822,7 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
 
 #endif /* HAVE_EBPF */
 
-  luaCtx.writeFunction<std::unordered_map<string, uint64_t>()>("getStatisticsCounters", []() {
+  luaCtx.writeFunction<LuaAssociativeTable<uint64_t>()>("getStatisticsCounters", []() {
     setLuaNoSideEffect();
     std::unordered_map<string, uint64_t> res;
     for (const auto& entry : g_stats.entries) {
@@ -1860,7 +1860,7 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
 
     DIR* dirp;
     struct dirent* ent;
-    std::list<std::string> files;
+    std::vector<std::string> files;
     if (!(dirp = opendir(dirname.c_str()))) {
       errlog("Error opening the included directory %s!", dirname.c_str());
       g_outputBuffer = "Error opening the included directory " + dirname + "!";
@@ -1885,17 +1885,17 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
     }
 
     closedir(dirp);
-    files.sort();
+    std::sort(files.begin(), files.end());
 
     g_included = true;
 
-    for (auto file = files.begin(); file != files.end(); ++file) {
-      std::ifstream ifs(*file);
+    for (const auto& file : files) {
+      std::ifstream ifs(file);
       if (!ifs) {
-        warnlog("Unable to read configuration from '%s'", *file);
+        warnlog("Unable to read configuration from '%s'", file);
       }
       else {
-        vinfolog("Read configuration from '%s'", *file);
+        vinfolog("Read configuration from '%s'", file);
       }
 
       try {
@@ -2118,7 +2118,7 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
     g_consoleOutputMsgMaxSize = size;
   });
 
-  luaCtx.writeFunction("setProxyProtocolACL", [](boost::variant<string, vector<pair<int, string>>> inp) {
+  luaCtx.writeFunction("setProxyProtocolACL", [](LuaTypeOrArrayOf<std::string> inp) {
     if (g_configurationDone) {
       errlog("setProxyProtocolACL() cannot be used at runtime!");
       g_outputBuffer = "setProxyProtocolACL() cannot be used at runtime!\n";
@@ -2130,7 +2130,7 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
       nmg.addMask(*str);
     }
     else {
-      for (const auto& p : boost::get<vector<pair<int, string>>>(inp)) {
+      for (const auto& p : boost::get<LuaArray<std::string>>(inp)) {
         nmg.addMask(p.second);
       }
     }
@@ -2302,7 +2302,7 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
     return result;
   });
 
-  luaCtx.writeFunction("addDOHLocal", [client](const std::string& addr, boost::optional<boost::variant<std::string, std::shared_ptr<TLSCertKeyPair>, std::vector<std::pair<int, std::string>>, std::vector<std::pair<int, std::shared_ptr<TLSCertKeyPair>>>>> certFiles, boost::optional<boost::variant<std::string, std::vector<std::pair<int, std::string>>>> keyFiles, boost::optional<boost::variant<std::string, vector<pair<int, std::string>>>> urls, boost::optional<localbind_t> vars) {
+  luaCtx.writeFunction("addDOHLocal", [client](const std::string& addr, boost::optional<boost::variant<std::string, std::shared_ptr<TLSCertKeyPair>, LuaArray<std::string>, LuaArray<std::shared_ptr<TLSCertKeyPair>>>> certFiles, boost::optional<boost::variant<std::string, LuaArray<std::string>>> keyFiles, boost::optional<LuaTypeOrArrayOf<std::string>> urls, boost::optional<localbind_t> vars) {
     if (client) {
       return;
     }
@@ -2330,8 +2330,8 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
       if (urls->type() == typeid(std::string)) {
         frontend->d_urls.push_back(boost::get<std::string>(*urls));
       }
-      else if (urls->type() == typeid(std::vector<std::pair<int, std::string>>)) {
-        auto urlsVect = boost::get<std::vector<std::pair<int, std::string>>>(*urls);
+      else if (urls->type() == typeid(LuaArray<std::string>)) {
+        auto urlsVect = boost::get<LuaArray<std::string>>(*urls);
         for (const auto& p : urlsVect) {
           frontend->d_urls.push_back(p.second);
         }
@@ -2361,8 +2361,8 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
       }
 
       if (vars->count("customResponseHeaders")) {
-        for (auto const& headerMap : boost::get<std::vector<std::pair<std::string, std::string>>>((*vars).at("customResponseHeaders"))) {
-          frontend->d_customResponseHeaders.emplace_back(boost::to_lower_copy(headerMap.first), headerMap.second);
+        for (auto const& headerMap : boost::get<LuaAssociativeTable<std::string>>((*vars).at("customResponseHeaders"))) {
+          frontend->d_customResponseHeaders[boost::to_lower_copy(headerMap.first)] = headerMap.second;
         }
       }
 
@@ -2493,7 +2493,7 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
     }
   });
 
-  luaCtx.registerFunction<void (std::shared_ptr<DOHFrontend>::*)(boost::variant<std::string, std::shared_ptr<TLSCertKeyPair>, std::vector<std::pair<int, std::string>>, std::vector<std::pair<int, std::shared_ptr<TLSCertKeyPair>>>> certFiles, boost::variant<std::string, std::vector<std::pair<int, std::string>>> keyFiles)>("loadNewCertificatesAndKeys", [](std::shared_ptr<DOHFrontend> frontend, boost::variant<std::string, std::shared_ptr<TLSCertKeyPair>, std::vector<std::pair<int, std::string>>, std::vector<std::pair<int, std::shared_ptr<TLSCertKeyPair>>>> certFiles, boost::variant<std::string, std ::vector<std::pair<int, std::string>>> keyFiles) {
+  luaCtx.registerFunction<void (std::shared_ptr<DOHFrontend>::*)(boost::variant<std::string, std::shared_ptr<TLSCertKeyPair>, LuaArray<std::string>, LuaArray<std::shared_ptr<TLSCertKeyPair>>> certFiles, boost::variant<std::string, LuaArray<std::string>> keyFiles)>("loadNewCertificatesAndKeys", [](std::shared_ptr<DOHFrontend> frontend, boost::variant<std::string, std::shared_ptr<TLSCertKeyPair>, LuaArray<std::string>, LuaArray<std::shared_ptr<TLSCertKeyPair>>> certFiles, boost::variant<std::string, LuaArray<std::string>> keyFiles) {
 #ifdef HAVE_DNS_OVER_HTTPS
     if (frontend != nullptr) {
       if (loadTLSCertificateAndKeys("DOHFrontend::loadNewCertificatesAndKeys", frontend->d_tlsConfig.d_certKeyPairs, certFiles, keyFiles)) {
@@ -2515,7 +2515,7 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
     }
   });
 
-  luaCtx.registerFunction<void (std::shared_ptr<DOHFrontend>::*)(const std::vector<std::pair<int, std::shared_ptr<DOHResponseMapEntry>>>&)>("setResponsesMap", [](std::shared_ptr<DOHFrontend> frontend, const std::vector<std::pair<int, std::shared_ptr<DOHResponseMapEntry>>>& map) {
+  luaCtx.registerFunction<void (std::shared_ptr<DOHFrontend>::*)(const LuaArray<std::shared_ptr<DOHResponseMapEntry>>&)>("setResponsesMap", [](std::shared_ptr<DOHFrontend> frontend, const LuaArray<std::shared_ptr<DOHResponseMapEntry>>& map) {
     if (frontend != nullptr) {
       auto newMap = std::make_shared<std::vector<std::shared_ptr<DOHResponseMapEntry>>>();
       newMap->reserve(map.size());
@@ -2528,7 +2528,7 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
     }
   });
 
-  luaCtx.writeFunction("addTLSLocal", [client](const std::string& addr, boost::variant<std::string, std::shared_ptr<TLSCertKeyPair>, std::vector<std::pair<int, std::string>>, std::vector<std::pair<int, std::shared_ptr<TLSCertKeyPair>>>> certFiles, boost::variant<std::string, std::vector<std::pair<int, std::string>>> keyFiles, boost::optional<localbind_t> vars) {
+  luaCtx.writeFunction("addTLSLocal", [client](const std::string& addr, boost::variant<std::string, std::shared_ptr<TLSCertKeyPair>, LuaArray<std::string>, LuaArray<std::shared_ptr<TLSCertKeyPair>>> certFiles, LuaTypeOrArrayOf<std::string> keyFiles, boost::optional<localbind_t> vars) {
     if (client) {
       return;
     }
@@ -2713,7 +2713,7 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
     frontend->setupTLS();
   });
 
-  luaCtx.registerFunction<void (std::shared_ptr<TLSFrontend>::*)(boost::variant<std::string, std::shared_ptr<TLSCertKeyPair>, std::vector<std::pair<int, std::string>>, std::vector<std::pair<int, std::shared_ptr<TLSCertKeyPair>>>> certFiles, boost::variant<std::string, std::vector<std::pair<int, std::string>>> keyFiles)>("loadNewCertificatesAndKeys", [](std::shared_ptr<TLSFrontend>& frontend, boost::variant<std::string, std::shared_ptr<TLSCertKeyPair>, std::vector<std::pair<int, std::string>>, std::vector<std::pair<int, std::shared_ptr<TLSCertKeyPair>>>> certFiles, boost::variant<std::string, std::vector<std::pair<int, std::string>>> keyFiles) {
+  luaCtx.registerFunction<void (std::shared_ptr<TLSFrontend>::*)(boost::variant<std::string, std::shared_ptr<TLSCertKeyPair>, LuaArray<std::string>, LuaArray<std::shared_ptr<TLSCertKeyPair>>> certFiles, LuaTypeOrArrayOf<std::string> keyFiles)>("loadNewCertificatesAndKeys", [](std::shared_ptr<TLSFrontend>& frontend, boost::variant<std::string, std::shared_ptr<TLSCertKeyPair>, LuaArray<std::string>, LuaArray<std::shared_ptr<TLSCertKeyPair>>> certFiles, LuaTypeOrArrayOf<std::string> keyFiles) {
 #ifdef HAVE_DNS_OVER_TLS
     if (loadTLSCertificateAndKeys("TLSFrontend::loadNewCertificatesAndKeys", frontend->d_tlsConfig.d_certKeyPairs, certFiles, keyFiles)) {
       frontend->setupTLS();
@@ -2762,7 +2762,7 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
   });
 #endif /* HAVE_LIBSSL && HAVE_OCSP_BASIC_SIGN*/
 
-  luaCtx.writeFunction("addCapabilitiesToRetain", [](boost::variant<std::string, std::vector<std::pair<int, std::string>>> caps) {
+  luaCtx.writeFunction("addCapabilitiesToRetain", [](LuaTypeOrArrayOf<std::string> caps) {
     setLuaSideEffect();
     if (g_configurationDone) {
       g_outputBuffer = "addCapabilitiesToRetain cannot be used at runtime!\n";
@@ -2771,8 +2771,8 @@ static void setupLuaConfig(LuaContext& luaCtx, bool client, bool configCheck)
     if (caps.type() == typeid(std::string)) {
       g_capabilitiesToRetain.insert(boost::get<std::string>(caps));
     }
-    else if (caps.type() == typeid(std::vector<std::pair<int, std::string>>)) {
-      for (const auto& cap : boost::get<std::vector<std::pair<int, std::string>>>(caps)) {
+    else if (caps.type() == typeid(LuaArray<std::string>)) {
+      for (const auto& cap : boost::get<LuaArray<std::string>>(caps)) {
         g_capabilitiesToRetain.insert(cap.second);
       }
     }
diff --git a/pdns/dnsdist-lua.hh b/pdns/dnsdist-lua.hh
index 32eefa5bcc..cf22e9163a 100644
--- a/pdns/dnsdist-lua.hh
+++ b/pdns/dnsdist-lua.hh
@@ -129,14 +129,18 @@ private:
   uint32_t d_max{std::numeric_limits<uint32_t>::max()};
 };
 
-typedef boost::variant<string, vector<pair<int, string>>, std::shared_ptr<DNSRule>, DNSName, vector<pair<int, DNSName> > > luadnsrule_t;
+template <class T> using LuaArray = std::vector<std::pair<int, T>>;
+template <class T> using LuaAssociativeTable = std::unordered_map<std::string, T>;
+template <class T> using LuaTypeOrArrayOf = boost::variant<T, LuaArray<T>>;
+
+using luadnsrule_t = boost::variant<string, LuaArray<std::string>, std::shared_ptr<DNSRule>, DNSName, LuaArray<DNSName>>;
+using luaruleparams_t = LuaAssociativeTable<std::string>;
+using nmts_t = NetmaskTree<DynBlock, AddressAndPortRange>;
+
 std::shared_ptr<DNSRule> makeRule(const luadnsrule_t& var);
-typedef std::unordered_map<std::string, std::string> luaruleparams_t;
 void parseRuleParams(boost::optional<luaruleparams_t> params, boost::uuids::uuid& uuid, std::string& name, uint64_t& creationOrder);
 void checkParameterBound(const std::string& parameter, uint64_t value, size_t max = std::numeric_limits<uint16_t>::max());
 
-typedef NetmaskTree<DynBlock, AddressAndPortRange> nmts_t;
-
 vector<std::function<void(void)>> setupLua(LuaContext& luaCtx, bool client, bool configCheck, const std::string& config);
 void setupLuaActions(LuaContext& luaCtx);
 void setupLuaBindings(LuaContext& luaCtx, bool client);
diff --git a/pdns/dnsdistdist/dnsdist-lua-bindings-dnscrypt.cc b/pdns/dnsdistdist/dnsdist-lua-bindings-dnscrypt.cc
index cc482777c5..fd3fb39e53 100644
--- a/pdns/dnsdistdist/dnsdist-lua-bindings-dnscrypt.cc
+++ b/pdns/dnsdistdist/dnsdist-lua-bindings-dnscrypt.cc
@@ -51,13 +51,13 @@ void setupLuaBindingsDNSCrypt(LuaContext& luaCtx, bool client)
 
       ctx->addNewCertificate(newCert, newKey, active ? *active : true);
     });
-    luaCtx.registerFunction<std::map<int, std::shared_ptr<DNSCryptCertificatePair>>(std::shared_ptr<DNSCryptContext>::*)()>("getCertificatePairs", [](std::shared_ptr<DNSCryptContext> ctx) {
-      std::map<int, std::shared_ptr<DNSCryptCertificatePair>> result;
+    luaCtx.registerFunction<LuaArray<std::shared_ptr<DNSCryptCertificatePair>>(std::shared_ptr<DNSCryptContext>::*)()>("getCertificatePairs", [](std::shared_ptr<DNSCryptContext> ctx) {
+      LuaArray<std::shared_ptr<DNSCryptCertificatePair>> result;
 
       if (ctx != nullptr) {
         size_t idx = 1;
         for (auto pair : ctx->getCertificates()) {
-          result[idx++] = pair;
+          result.push_back({idx++, pair});
         }
       }
 
diff --git a/pdns/dnsdistdist/dnsdist-lua-bindings-packetcache.cc b/pdns/dnsdistdist/dnsdist-lua-bindings-packetcache.cc
index a5a37924e4..b77cd7f204 100644
--- a/pdns/dnsdistdist/dnsdist-lua-bindings-packetcache.cc
+++ b/pdns/dnsdistdist/dnsdist-lua-bindings-packetcache.cc
@@ -33,7 +33,7 @@
 void setupLuaBindingsPacketCache(LuaContext& luaCtx, bool client)
 {
   /* PacketCache */
-  luaCtx.writeFunction("newPacketCache", [client](size_t maxEntries, boost::optional<std::unordered_map<std::string, boost::variant<bool, size_t, std::vector<std::pair<int, uint16_t>>>>> vars) {
+  luaCtx.writeFunction("newPacketCache", [client](size_t maxEntries, boost::optional<LuaAssociativeTable<boost::variant<bool, size_t, LuaArray<uint16_t>>>> vars) {
 
       bool keepStaleData = false;
       size_t maxTTL = 86400;
@@ -95,7 +95,7 @@ void setupLuaBindingsPacketCache(LuaContext& luaCtx, bool client)
           }
         }
         if (vars->count("skipOptions")) {
-          for (auto option: boost::get<std::vector<std::pair<int, uint16_t>>>(vars->at("skipOptions"))) {
+          for (auto option: boost::get<LuaArray<uint16_t>>(vars->at("skipOptions"))) {
             optionsToSkip.insert(option.second);
           }
         }
@@ -175,8 +175,8 @@ void setupLuaBindingsPacketCache(LuaContext& luaCtx, bool client)
         g_outputBuffer+="TTL Too Shorts: " + std::to_string(cache->getTTLTooShorts()) + "\n";
       }
     });
-  luaCtx.registerFunction<std::unordered_map<std::string, uint64_t>(std::shared_ptr<DNSDistPacketCache>::*)()const>("getStats", [](const std::shared_ptr<DNSDistPacketCache>& cache) {
-      std::unordered_map<std::string, uint64_t> stats;
+  luaCtx.registerFunction<LuaAssociativeTable<uint64_t>(std::shared_ptr<DNSDistPacketCache>::*)()const>("getStats", [](const std::shared_ptr<DNSDistPacketCache>& cache) {
+      LuaAssociativeTable<uint64_t> stats;
       if (cache) {
         stats["entries"] = cache->getEntriesCount();
         stats["maxEntries"] = cache->getMaxEntries();
diff --git a/pdns/dnsdistdist/dnsdist-lua-bindings-protobuf.cc b/pdns/dnsdistdist/dnsdist-lua-bindings-protobuf.cc
index 7bb7a628dd..6e470d34e8 100644
--- a/pdns/dnsdistdist/dnsdist-lua-bindings-protobuf.cc
+++ b/pdns/dnsdistdist/dnsdist-lua-bindings-protobuf.cc
@@ -32,7 +32,7 @@
 #include "remote_logger.hh"
 
 #ifdef HAVE_FSTRM
-static void parseFSTRMOptions(const boost::optional<std::unordered_map<std::string, unsigned int>>& params, std::unordered_map<string, unsigned int>& options)
+static void parseFSTRMOptions(const boost::optional<LuaAssociativeTable<unsigned int>>& params, LuaAssociativeTable<unsigned int>& options)
 {
   if (!params) {
     return;
@@ -67,7 +67,7 @@ void setupLuaBindingsProtoBuf(LuaContext& luaCtx, bool client, bool configCheck)
   luaCtx.registerFunction<void(DNSDistProtoBufMessage::*)(std::string)>("setTag", [](DNSDistProtoBufMessage& message, const std::string& strValue) {
       message.addTag(strValue);
     });
-  luaCtx.registerFunction<void(DNSDistProtoBufMessage::*)(vector<pair<int, string>>)>("setTagArray", [](DNSDistProtoBufMessage& message, const vector<pair<int, string>>&tags) {
+  luaCtx.registerFunction<void(DNSDistProtoBufMessage::*)(LuaArray<std::string>)>("setTagArray", [](DNSDistProtoBufMessage& message, const LuaArray<std::string>& tags) {
       for (const auto& tag : tags) {
         message.addTag(tag.second);
       }
@@ -130,13 +130,13 @@ void setupLuaBindingsProtoBuf(LuaContext& luaCtx, bool client, bool configCheck)
       return std::shared_ptr<RemoteLoggerInterface>(new RemoteLogger(ComboAddress(remote), timeout ? *timeout : 2, maxQueuedEntries ? (*maxQueuedEntries*100) : 10000, reconnectWaitTime ? *reconnectWaitTime : 1, client));
     });
 
-  luaCtx.writeFunction("newFrameStreamUnixLogger", [client,configCheck](const std::string& address, boost::optional<std::unordered_map<std::string, unsigned int>> params) {
+  luaCtx.writeFunction("newFrameStreamUnixLogger", [client,configCheck](const std::string& address, boost::optional<LuaAssociativeTable<unsigned int>> params) {
 #ifdef HAVE_FSTRM
       if (client || configCheck) {
         return std::shared_ptr<RemoteLoggerInterface>(nullptr);
       }
 
-      std::unordered_map<string, unsigned int> options;
+      LuaAssociativeTable<unsigned int> options;
       parseFSTRMOptions(params, options);
       return std::shared_ptr<RemoteLoggerInterface>(new FrameStreamLogger(AF_UNIX, address, !client, options));
 #else
@@ -144,13 +144,13 @@ void setupLuaBindingsProtoBuf(LuaContext& luaCtx, bool client, bool configCheck)
 #endif /* HAVE_FSTRM */
     });
 
-  luaCtx.writeFunction("newFrameStreamTcpLogger", [client,configCheck](const std::string& address, boost::optional<std::unordered_map<std::string, unsigned int>> params) {
+  luaCtx.writeFunction("newFrameStreamTcpLogger", [client,configCheck](const std::string& address, boost::optional<LuaAssociativeTable<unsigned int>> params) {
 #if defined(HAVE_FSTRM) && defined(HAVE_FSTRM_TCP_WRITER_INIT)
       if (client || configCheck) {
         return std::shared_ptr<RemoteLoggerInterface>(nullptr);
       }
 
-      std::unordered_map<string, unsigned int> options;
+      LuaAssociativeTable<unsigned int> options;
       parseFSTRMOptions(params, options);
       return std::shared_ptr<RemoteLoggerInterface>(new FrameStreamLogger(AF_INET, address, !client, options));
 #else
diff --git a/pdns/dnsdistdist/dnsdist-lua-web.cc b/pdns/dnsdistdist/dnsdist-lua-web.cc
index 379402f4a8..0498aed4fc 100644
--- a/pdns/dnsdistdist/dnsdist-lua-web.cc
+++ b/pdns/dnsdistdist/dnsdist-lua-web.cc
@@ -39,38 +39,38 @@ void setupLuaWeb(LuaContext& luaCtx)
   luaCtx.registerMember<int(YaHTTP::Request::*)>("version", [](const YaHTTP::Request& req) -> int { return req.version; }, [](YaHTTP::Request& req, int version) { (void) version; });
   luaCtx.registerMember<std::string(YaHTTP::Request::*)>("method", [](const YaHTTP::Request& req) -> std::string { return req.method; }, [](YaHTTP::Request& req, const std::string& method) { (void) method; });
   luaCtx.registerMember<std::string(YaHTTP::Request::*)>("body", [](const YaHTTP::Request& req) -> const std::string { return req.body; }, [](YaHTTP::Request& req, const std::string& body) { (void) body; });
-  luaCtx.registerMember<std::unordered_map<std::string, std::string>(YaHTTP::Request::*)>("getvars", [](const YaHTTP::Request& req) {
-    std::unordered_map<std::string, std::string> values;
+  luaCtx.registerMember<LuaAssociativeTable<std::string>(YaHTTP::Request::*)>("getvars", [](const YaHTTP::Request& req) {
+    LuaAssociativeTable<std::string> values;
     for (const auto& entry : req.getvars) {
       values.insert({entry.first, entry.second});
     }
     return values;
-  }, [](YaHTTP::Request& req, const std::unordered_map<std::string, std::string>& values) { (void) values; });
-  luaCtx.registerMember<std::unordered_map<std::string, std::string>(YaHTTP::Request::*)>("postvars", [](const YaHTTP::Request& req) {
-    std::unordered_map<std::string, std::string> values;
+  }, [](YaHTTP::Request& req, const LuaAssociativeTable<std::string>& values) { (void) values; });
+  luaCtx.registerMember<LuaAssociativeTable<std::string>(YaHTTP::Request::*)>("postvars", [](const YaHTTP::Request& req) {
+    LuaAssociativeTable<std::string> values;
     for (const auto& entry : req.postvars) {
       values.insert({entry.first, entry.second});
     }
     return values;
-  }, [](YaHTTP::Request& req, const std::unordered_map<std::string, std::string>& values) { (void) values; });
-  luaCtx.registerMember<std::unordered_map<std::string, std::string>(YaHTTP::Request::*)>("headers", [](const YaHTTP::Request& req) {
-    std::unordered_map<std::string, std::string> values;
+  }, [](YaHTTP::Request& req, const LuaAssociativeTable<std::string>& values) { (void) values; });
+  luaCtx.registerMember<LuaAssociativeTable<std::string>(YaHTTP::Request::*)>("headers", [](const YaHTTP::Request& req) {
+    LuaAssociativeTable<std::string> values;
     for (const auto& entry : req.headers) {
       values.insert({entry.first, entry.second});
     }
     return values;
-  }, [](YaHTTP::Request& req, const std::unordered_map<std::string, std::string>& values) { (void) values; });
+  }, [](YaHTTP::Request& req, const LuaAssociativeTable<std::string>& values) { (void) values; });
 
   /* Response */
   luaCtx.registerMember<std::string(YaHTTP::Response::*)>("body", [](const YaHTTP::Response& resp) -> const std::string { return resp.body; }, [](YaHTTP::Response& resp, const std::string& body) { resp.body = body; });
   luaCtx.registerMember<int(YaHTTP::Response::*)>("status", [](const YaHTTP::Response& resp) -> int { return resp.status; }, [](YaHTTP::Response& resp, int status) { resp.status = status; });
-  luaCtx.registerMember<std::unordered_map<std::string, std::string>(YaHTTP::Response::*)>("headers", [](const YaHTTP::Response& resp) {
-    std::unordered_map<std::string, std::string> values;
+  luaCtx.registerMember<LuaAssociativeTable<std::string>(YaHTTP::Response::*)>("headers", [](const YaHTTP::Response& resp) {
+    LuaAssociativeTable<std::string> values;
     for (const auto& entry : resp.headers) {
       values.insert({entry.first, entry.second});
     }
     return values;
-  }, [](YaHTTP::Response& resp, const std::unordered_map<std::string, std::string>& values) {
+  }, [](YaHTTP::Response& resp, const LuaAssociativeTable<std::string>& values) {
     resp.headers.clear();
     for (const auto& entry : values) {
       resp.headers.insert({entry.first, entry.second});
diff --git a/pdns/dnsdistdist/dnsdist-tcp-downstream.hh b/pdns/dnsdistdist/dnsdist-tcp-downstream.hh
index 7c041784d4..7f3cd6a0d8 100644
--- a/pdns/dnsdistdist/dnsdist-tcp-downstream.hh
+++ b/pdns/dnsdistdist/dnsdist-tcp-downstream.hh
@@ -295,7 +295,7 @@ private:
   };
 
   PacketBuffer d_responseBuffer;
-  std::deque<PendingRequest> d_pendingQueries;
+  std::list<PendingRequest> d_pendingQueries;
   std::unordered_map<uint16_t, PendingRequest> d_pendingResponses;
   std::unique_ptr<std::vector<ProxyProtocolValue>> d_proxyProtocolValuesSent{nullptr};
   PendingRequest d_currentQuery;
diff --git a/pdns/dnsdistdist/doh.cc b/pdns/dnsdistdist/doh.cc
index 9f55553777..7021684685 100644
--- a/pdns/dnsdistdist/doh.cc
+++ b/pdns/dnsdistdist/doh.cc
@@ -351,7 +351,7 @@ static const std::string& getReasonFromStatusCode(uint16_t statusCode)
 }
 
 /* Always called from the main DoH thread */
-static void handleResponse(DOHFrontend& df, st_h2o_req_t* req, uint16_t statusCode, const PacketBuffer& response, const std::vector<std::pair<std::string, std::string>>& customResponseHeaders, const std::string& contentType, bool addContentType)
+static void handleResponse(DOHFrontend& df, st_h2o_req_t* req, uint16_t statusCode, const PacketBuffer& response, const std::unordered_map<std::string, std::string>& customResponseHeaders, const std::string& contentType, bool addContentType)
 {
   constexpr int overwrite_if_exists = 1;
   constexpr int maybe_token = 1;
@@ -825,8 +825,7 @@ static void doh_dispatch_query(DOHServerConfig* dsc, h2o_handler_t* self, h2o_re
     du->query_at = req->query_at;
     du->headers.reserve(req->headers.size);
     for (size_t i = 0; i < req->headers.size; ++i) {
-      du->headers.emplace_back(std::string(req->headers.entries[i].name->base, req->headers.entries[i].name->len),
-                               std::string(req->headers.entries[i].value.base, req->headers.entries[i].value.len));
+      du->headers[std::string(req->headers.entries[i].name->base, req->headers.entries[i].name->len)] = std::string(req->headers.entries[i].value.base, req->headers.entries[i].value.len);
     }
 
 #ifdef HAVE_H2O_SOCKET_GET_SSL_SERVER_NAME
diff --git a/pdns/doh.hh b/pdns/doh.hh
index 6004379bf2..56152b6e18 100644
--- a/pdns/doh.hh
+++ b/pdns/doh.hh
@@ -30,7 +30,7 @@ struct DOHServerConfig;
 class DOHResponseMapEntry
 {
 public:
-  DOHResponseMapEntry(const std::string& regex, uint16_t status, const PacketBuffer& content, const boost::optional<std::vector<std::pair<std::string, std::string>>>& headers): d_regex(regex), d_customHeaders(headers), d_content(content), d_status(status)
+  DOHResponseMapEntry(const std::string& regex, uint16_t status, const PacketBuffer& content, const boost::optional<std::unordered_map<std::string, std::string>>& headers): d_regex(regex), d_customHeaders(headers), d_content(content), d_status(status)
   {
     if (status >= 400 && !d_content.empty() && d_content.at(d_content.size() -1) != 0) {
       // we need to make sure it's null-terminated
@@ -53,14 +53,14 @@ public:
     return d_content;
   }
 
-  const boost::optional<std::vector<std::pair<std::string, std::string>>>& getHeaders() const
+  const boost::optional<std::unordered_map<std::string, std::string>>& getHeaders() const
   {
     return d_customHeaders;
   }
 
 private:
   Regex d_regex;
-  boost::optional<std::vector<std::pair<std::string, std::string>>> d_customHeaders;
+  boost::optional<std::unordered_map<std::string, std::string>> d_customHeaders;
   PacketBuffer d_content;
   uint16_t d_status;
 };
@@ -76,7 +76,7 @@ struct DOHFrontend
   TLSConfig d_tlsConfig;
   TLSErrorCounters d_tlsCounters;
   std::string d_serverTokens{"h2o/dnsdist"};
-  std::vector<std::pair<std::string, std::string>> d_customResponseHeaders;
+  std::unordered_map<std::string, std::string> d_customResponseHeaders;
   ComboAddress d_local;
 
   uint32_t d_idleTimeout{30};             // HTTP idle timeout in seconds
@@ -224,7 +224,7 @@ struct DOHUnit
   std::string scheme;
   std::string host;
   std::string contentType;
-  std::vector<std::pair<std::string, std::string>> headers;
+  std::unordered_map<std::string, std::string> headers;
   PacketBuffer query;
   PacketBuffer response;
   std::shared_ptr<DownstreamState> downstream{nullptr};