From 4fc2f55f761d71aae1f145d5aa94ba929cc39676 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 28 Apr 2024 11:34:30 +0200 Subject: Adding upstream version 1.7.3. Signed-off-by: Daniel Baumann --- dnsdist-lua-bindings-packetcache.cc | 220 ++++++++++++++++++++++++++++++++++++ 1 file changed, 220 insertions(+) create mode 100644 dnsdist-lua-bindings-packetcache.cc (limited to 'dnsdist-lua-bindings-packetcache.cc') diff --git a/dnsdist-lua-bindings-packetcache.cc b/dnsdist-lua-bindings-packetcache.cc new file mode 100644 index 0000000..086fb5d --- /dev/null +++ b/dnsdist-lua-bindings-packetcache.cc @@ -0,0 +1,220 @@ +/* + * This file is part of PowerDNS or dnsdist. + * Copyright -- PowerDNS.COM B.V. and its contributors + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of version 2 of the GNU General Public License as + * published by the Free Software Foundation. + * + * In addition, for the avoidance of any doubt, permission is granted to + * link this program with OpenSSL and to (re)distribute the binaries + * produced as the result of such linking. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ +#include +#include +#include + +#include "config.h" +#include "dolog.hh" +#include "dnsdist.hh" +#include "dnsdist-lua.hh" + +#include + +void setupLuaBindingsPacketCache(LuaContext& luaCtx, bool client) +{ + /* PacketCache */ + luaCtx.writeFunction("newPacketCache", [client](size_t maxEntries, boost::optional>>>> vars) { + + bool keepStaleData = false; + size_t maxTTL = 86400; + size_t minTTL = 0; + size_t tempFailTTL = 60; + size_t maxNegativeTTL = 3600; + size_t staleTTL = 60; + size_t numberOfShards = 20; + bool dontAge = false; + bool deferrableInsertLock = true; + bool ecsParsing = false; + std::unordered_set optionsToSkip{EDNSOptionCode::COOKIE}; + + if (vars) { + + if (vars->count("deferrableInsertLock")) { + deferrableInsertLock = boost::get((*vars)["deferrableInsertLock"]); + } + + if (vars->count("dontAge")) { + dontAge = boost::get((*vars)["dontAge"]); + } + + if (vars->count("keepStaleData")) { + keepStaleData = boost::get((*vars)["keepStaleData"]); + } + + if (vars->count("maxNegativeTTL")) { + maxNegativeTTL = boost::get((*vars)["maxNegativeTTL"]); + } + + if (vars->count("maxTTL")) { + maxTTL = boost::get((*vars)["maxTTL"]); + } + + if (vars->count("minTTL")) { + minTTL = boost::get((*vars)["minTTL"]); + } + + if (vars->count("numberOfShards")) { + numberOfShards = boost::get((*vars)["numberOfShards"]); + } + + if (vars->count("parseECS")) { + ecsParsing = boost::get((*vars)["parseECS"]); + } + + if (vars->count("staleTTL")) { + staleTTL = boost::get((*vars)["staleTTL"]); + } + + if (vars->count("temporaryFailureTTL")) { + tempFailTTL = boost::get((*vars)["temporaryFailureTTL"]); + } + + if (vars->count("cookieHashing")) { + if (boost::get((*vars)["cookieHashing"])) { + optionsToSkip.erase(EDNSOptionCode::COOKIE); + } + } + if (vars->count("skipOptions")) { + for (auto option: boost::get>>(vars->at("skipOptions"))) { + optionsToSkip.insert(option.second); + } + } + } + + if (maxEntries == 0) { + warnlog("The number of entries in the packet cache is set to 0, raising to 1"); + g_outputBuffer += "The number of entries in the packet cache is set to 0, raising to 1"; + maxEntries = 1; + } + + if (maxEntries < numberOfShards) { + warnlog("The number of entries (%d) in the packet cache is smaller than the number of shards (%d), decreasing the number of shards to %d", maxEntries, numberOfShards, maxEntries); + g_outputBuffer += "The number of entries (" + std::to_string(maxEntries) + " in the packet cache is smaller than the number of shards (" + std::to_string(numberOfShards) + "), decreasing the number of shards to " + std::to_string(maxEntries); + numberOfShards = maxEntries; + } + + if (client) { + maxEntries = 1; + numberOfShards = 1; + } + + auto res = std::make_shared(maxEntries, maxTTL, minTTL, tempFailTTL, maxNegativeTTL, staleTTL, dontAge, numberOfShards, deferrableInsertLock, ecsParsing); + + res->setKeepStaleData(keepStaleData); + res->setSkippedOptions(optionsToSkip); + + return res; + }); + luaCtx.registerFunction::*)()const>("toString", [](const std::shared_ptr& cache) { + if (cache) { + return cache->toString(); + } + return std::string(); + }); + luaCtx.registerFunction::*)()const>("isFull", [](const std::shared_ptr& cache) { + if (cache) { + return cache->isFull(); + } + return false; + }); + luaCtx.registerFunction::*)(size_t)>("purgeExpired", [](std::shared_ptr& cache, size_t upTo) { + if (cache) { + const time_t now = time(nullptr); + + return cache->purgeExpired(upTo, now); + } + return static_cast(0); + }); + luaCtx.registerFunction::*)(size_t)>("expunge", [](std::shared_ptr& cache, size_t upTo) { + if (cache) { + return cache->expunge(upTo); + } + return static_cast(0); + }); + luaCtx.registerFunction::*)(const boost::variant& dname, boost::optional qtype, boost::optional suffixMatch)>("expungeByName", []( + std::shared_ptr& cache, + const boost::variant& dname, + boost::optional qtype, + boost::optional suffixMatch) { + DNSName qname; + if (dname.type() == typeid(DNSName)) { + qname = boost::get(dname); + } + if (dname.type() == typeid(string)) { + qname = DNSName(boost::get(dname)); + } + if (cache) { + g_outputBuffer="Expunged " + std::to_string(cache->expungeByName(qname, qtype ? *qtype : QType(QType::ANY).getCode(), suffixMatch ? *suffixMatch : false)) + " records\n"; + } + }); + luaCtx.registerFunction::*)()const>("printStats", [](const std::shared_ptr& cache) { + if (cache) { + g_outputBuffer="Entries: " + std::to_string(cache->getEntriesCount()) + "/" + std::to_string(cache->getMaxEntries()) + "\n"; + g_outputBuffer+="Hits: " + std::to_string(cache->getHits()) + "\n"; + g_outputBuffer+="Misses: " + std::to_string(cache->getMisses()) + "\n"; + g_outputBuffer+="Deferred inserts: " + std::to_string(cache->getDeferredInserts()) + "\n"; + g_outputBuffer+="Deferred lookups: " + std::to_string(cache->getDeferredLookups()) + "\n"; + g_outputBuffer+="Lookup Collisions: " + std::to_string(cache->getLookupCollisions()) + "\n"; + g_outputBuffer+="Insert Collisions: " + std::to_string(cache->getInsertCollisions()) + "\n"; + g_outputBuffer+="TTL Too Shorts: " + std::to_string(cache->getTTLTooShorts()) + "\n"; + } + }); + luaCtx.registerFunction(std::shared_ptr::*)()const>("getStats", [](const std::shared_ptr& cache) { + std::unordered_map stats; + if (cache) { + stats["entries"] = cache->getEntriesCount(); + stats["maxEntries"] = cache->getMaxEntries(); + stats["hits"] = cache->getHits(); + stats["misses"] = cache->getMisses(); + stats["deferredInserts"] = cache->getDeferredInserts(); + stats["deferredLookups"] = cache->getDeferredLookups(); + stats["lookupCollisions"] = cache->getLookupCollisions(); + stats["insertCollisions"] = cache->getInsertCollisions(); + stats["ttlTooShorts"] = cache->getTTLTooShorts(); + } + return stats; + }); + luaCtx.registerFunction::*)(const std::string& fname)const>("dump", [](const std::shared_ptr& cache, const std::string& fname) { + if (cache) { + + int fd = open(fname.c_str(), O_CREAT | O_EXCL | O_WRONLY, 0660); + if (fd < 0) { + g_outputBuffer = "Error opening dump file for writing: " + stringerror() + "\n"; + return; + } + + uint64_t records = 0; + try { + records = cache->dump(fd); + } + catch (const std::exception& e) { + close(fd); + throw; + } + + close(fd); + + g_outputBuffer += "Dumped " + std::to_string(records) + " records\n"; + } + }); +} -- cgit v1.2.3