auto lock = g_lua.lock();
auto ret = d_func(dnsquestion);
if (ruleresult != nullptr) {
- if (boost::optional<std::string> rule = std::get<1>(ret)) {
+ if (std::optional<std::string> rule = std::get<1>(ret)) {
*ruleresult = *rule;
}
else {
auto lock = g_lua.lock();
auto ret = d_func(response);
if (ruleresult != nullptr) {
- if (boost::optional<std::string> rule = std::get<1>(ret)) {
+ if (std::optional<std::string> rule = std::get<1>(ret)) {
*ruleresult = *rule;
}
else {
};
#ifndef DISABLE_PROTOBUF
-static std::tuple<DnstapMessage::ProtocolType, boost::optional<DnstapMessage::HttpProtocolType>> ProtocolToDNSTap(dnsdist::Protocol protocol)
+static std::tuple<DnstapMessage::ProtocolType, std::optional<DnstapMessage::HttpProtocolType>> ProtocolToDNSTap(dnsdist::Protocol protocol)
{
if (protocol == dnsdist::Protocol::DoUDP) {
- return {DnstapMessage::ProtocolType::DoUDP, boost::none};
+ return {DnstapMessage::ProtocolType::DoUDP, std::nullopt};
}
if (protocol == dnsdist::Protocol::DoTCP) {
- return {DnstapMessage::ProtocolType::DoTCP, boost::none};
+ return {DnstapMessage::ProtocolType::DoTCP, std::nullopt};
}
if (protocol == dnsdist::Protocol::DoT) {
- return {DnstapMessage::ProtocolType::DoT, boost::none};
+ return {DnstapMessage::ProtocolType::DoT, std::nullopt};
}
if (protocol == dnsdist::Protocol::DoH) {
return {DnstapMessage::ProtocolType::DoH, DnstapMessage::HttpProtocolType::HTTP2};
return {DnstapMessage::ProtocolType::DoH, DnstapMessage::HttpProtocolType::HTTP3};
}
if (protocol == dnsdist::Protocol::DNSCryptUDP) {
- return {DnstapMessage::ProtocolType::DNSCryptUDP, boost::none};
+ return {DnstapMessage::ProtocolType::DNSCryptUDP, std::nullopt};
}
if (protocol == dnsdist::Protocol::DNSCryptTCP) {
- return {DnstapMessage::ProtocolType::DNSCryptTCP, boost::none};
+ return {DnstapMessage::ProtocolType::DNSCryptTCP, std::nullopt};
}
if (protocol == dnsdist::Protocol::DoQ) {
- return {DnstapMessage::ProtocolType::DoQ, boost::none};
+ return {DnstapMessage::ProtocolType::DoQ, std::nullopt};
}
throw std::runtime_error("Unhandled protocol for dnstap: " + protocol.toPrettyString());
}
auto [protocol, httpProtocol] = ProtocolToDNSTap(dnsquestion->getProtocol());
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
- DnstapMessage message(std::move(data), !dnsquestion->getHeader()->qr ? DnstapMessage::MessageType::client_query : DnstapMessage::MessageType::client_response, d_identity, &dnsquestion->ids.origRemote, &dnsquestion->ids.origDest, protocol, reinterpret_cast<const char*>(dnsquestion->getData().data()), dnsquestion->getData().size(), &dnsquestion->getQueryRealTime(), nullptr, boost::none, httpProtocol);
+ DnstapMessage message(std::move(data), !dnsquestion->getHeader()->qr ? DnstapMessage::MessageType::client_query : DnstapMessage::MessageType::client_response, d_identity, &dnsquestion->ids.origRemote, &dnsquestion->ids.origDest, protocol, reinterpret_cast<const char*>(dnsquestion->getData().data()), dnsquestion->getData().size(), &dnsquestion->getQueryRealTime(), nullptr, DNSName(), httpProtocol);
{
if (d_alterFunc) {
auto lock = g_lua.lock();
auto [protocol, httpProtocol] = ProtocolToDNSTap(response->getProtocol());
// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
- DnstapMessage message(std::move(data), DnstapMessage::MessageType::client_response, d_identity, &response->ids.origRemote, &response->ids.origDest, protocol, reinterpret_cast<const char*>(response->getData().data()), response->getData().size(), &response->getQueryRealTime(), &now, boost::none, httpProtocol);
+ DnstapMessage message(std::move(data), DnstapMessage::MessageType::client_response, d_identity, &response->ids.origRemote, &response->ids.origDest, protocol, reinterpret_cast<const char*>(response->getData().data()), response->getData().size(), &response->getQueryRealTime(), &now, DNSName(), httpProtocol);
{
if (d_alterFunc) {
auto lock = g_lua.lock();
namespace dnsdist::actions
{
-using LuaActionFunction = std::function<std::tuple<int, boost::optional<string>>(DNSQuestion* dnsquestion)>;
-using LuaResponseActionFunction = std::function<std::tuple<int, boost::optional<string>>(DNSResponse* response)>;
+using LuaActionFunction = std::function<std::tuple<int, std::optional<string>>(DNSQuestion* dnsquestion)>;
+using LuaResponseActionFunction = std::function<std::tuple<int, std::optional<string>>(DNSResponse* response)>;
using LuaActionFFIFunction = std::function<int(dnsdist_ffi_dnsquestion_t* dnsquestion)>;
using LuaResponseActionFFIFunction = std::function<int(dnsdist_ffi_dnsresponse_t* dnsquestion)>;
}
}
-bool DNSDistPacketCache::getClientSubnet(const PacketBuffer& packet, size_t qnameWireLength, boost::optional<Netmask>& subnet)
+bool DNSDistPacketCache::getClientSubnet(const PacketBuffer& packet, size_t qnameWireLength, std::optional<Netmask>& subnet)
{
uint16_t optRDPosition = 0;
size_t remaining = 0;
return false;
}
-bool DNSDistPacketCache::cachedValueMatches(const CacheValue& cachedValue, uint16_t queryFlags, const DNSName& qname, uint16_t qtype, uint16_t qclass, bool receivedOverUDP, bool dnssecOK, const boost::optional<Netmask>& subnet) const
+bool DNSDistPacketCache::cachedValueMatches(const CacheValue& cachedValue, uint16_t queryFlags, const DNSName& qname, uint16_t qtype, uint16_t qclass, bool receivedOverUDP, bool dnssecOK, const std::optional<Netmask>& subnet) const
{
if (cachedValue.queryFlags != queryFlags || cachedValue.dnssecOK != dnssecOK || cachedValue.receivedOverUDP != receivedOverUDP || cachedValue.qtype != qtype || cachedValue.qclass != qclass || cachedValue.qname != qname) {
return false;
return false;
}
-void DNSDistPacketCache::insert(uint32_t key, const boost::optional<Netmask>& subnet, uint16_t queryFlags, bool dnssecOK, const DNSName& qname, uint16_t qtype, uint16_t qclass, const PacketBuffer& response, bool receivedOverUDP, uint8_t rcode, boost::optional<uint32_t> tempFailureTTL)
+void DNSDistPacketCache::insert(uint32_t key, const std::optional<Netmask>& subnet, uint16_t queryFlags, bool dnssecOK, const DNSName& qname, uint16_t qtype, uint16_t qclass, const PacketBuffer& response, bool receivedOverUDP, uint8_t rcode, std::optional<uint32_t> tempFailureTTL)
{
if (response.size() < sizeof(dnsheader) || response.size() > getMaximumEntrySize()) {
return;
uint32_t minTTL{0};
if (rcode == RCode::ServFail || rcode == RCode::Refused) {
- minTTL = tempFailureTTL == boost::none ? d_settings.d_tempFailureTTL : *tempFailureTTL;
+ minTTL = tempFailureTTL == std::nullopt ? d_settings.d_tempFailureTTL : *tempFailureTTL;
if (minTTL == 0) {
return;
}
}
}
-bool DNSDistPacketCache::get(DNSQuestion& dnsQuestion, uint16_t queryId, uint32_t* keyOut, boost::optional<Netmask>& subnet, bool dnssecOK, bool receivedOverUDP, uint32_t allowExpired, bool skipAging, bool truncatedOK, bool recordMiss)
+bool DNSDistPacketCache::get(DNSQuestion& dnsQuestion, uint16_t queryId, uint32_t* keyOut, std::optional<Netmask>& subnet, bool dnssecOK, bool receivedOverUDP, uint32_t allowExpired, bool skipAging, bool truncatedOK, bool recordMiss)
{
if (dnsQuestion.ids.qtype == QType::AXFR || dnsQuestion.ids.qtype == QType::IXFR) {
++d_misses;
rcode = dnsHeader.rcode;
}
- fprintf(filePtr.get(), "%s %" PRId64 " %s %s ; ecs %s, rcode %" PRIu8 ", key %" PRIu32 ", length %" PRIu16 ", received over UDP %d, added %" PRId64 ", dnssecOK %d, raw query flags %" PRIu16, value.qname.toString().c_str(), static_cast<int64_t>(value.validity - now), QClass(value.qclass).toString().c_str(), QType(value.qtype).toString().c_str(), value.subnet ? value.subnet.get().toString().c_str() : "empty", rcode, entry.first, value.len, value.receivedOverUDP ? 1 : 0, static_cast<int64_t>(value.added), value.dnssecOK ? 1 : 0, value.queryFlags);
+ fprintf(filePtr.get(), "%s %" PRId64 " %s %s ; ecs %s, rcode %" PRIu8 ", key %" PRIu32 ", length %" PRIu16 ", received over UDP %d, added %" PRId64 ", dnssecOK %d, raw query flags %" PRIu16, value.qname.toString().c_str(), static_cast<int64_t>(value.validity - now), QClass(value.qclass).toString().c_str(), QType(value.qtype).toString().c_str(), value.subnet ? value.subnet.value().toString().c_str() : "empty", rcode, entry.first, value.len, value.receivedOverUDP ? 1 : 0, static_cast<int64_t>(value.added), value.dnssecOK ? 1 : 0, value.queryFlags);
if (rawResponse) {
std::string rawDataResponse = Base64Encode(value.value);
DNSDistPacketCache(CacheSettings settings);
- void insert(uint32_t key, const boost::optional<Netmask>& subnet, uint16_t queryFlags, bool dnssecOK, const DNSName& qname, uint16_t qtype, uint16_t qclass, const PacketBuffer& response, bool receivedOverUDP, uint8_t rcode, boost::optional<uint32_t> tempFailureTTL);
- bool get(DNSQuestion& dnsQuestion, uint16_t queryId, uint32_t* keyOut, boost::optional<Netmask>& subnet, bool dnssecOK, bool receivedOverUDP, uint32_t allowExpired = 0, bool skipAging = false, bool truncatedOK = true, bool recordMiss = true);
+ void insert(uint32_t key, const std::optional<Netmask>& subnet, uint16_t queryFlags, bool dnssecOK, const DNSName& qname, uint16_t qtype, uint16_t qclass, const PacketBuffer& response, bool receivedOverUDP, uint8_t rcode, std::optional<uint32_t> tempFailureTTL);
+ bool get(DNSQuestion& dnsQuestion, uint16_t queryId, uint32_t* keyOut, std::optional<Netmask>& subnet, bool dnssecOK, bool receivedOverUDP, uint32_t allowExpired = 0, bool skipAging = false, bool truncatedOK = true, bool recordMiss = true);
size_t purgeExpired(size_t upTo, time_t now);
size_t expunge(size_t upTo = 0);
size_t expungeByName(const DNSName& name, uint16_t qtype = QType::ANY, bool suffixMatch = false);
uint32_t getKey(const DNSName::string_t& qname, size_t qnameWireLength, const PacketBuffer& packet, bool receivedOverUDP) const;
static uint32_t getMinTTL(const char* packet, uint16_t length, bool* seenNoDataSOA);
- static bool getClientSubnet(const PacketBuffer& packet, size_t qnameWireLength, boost::optional<Netmask>& subnet);
+ static bool getClientSubnet(const PacketBuffer& packet, size_t qnameWireLength, std::optional<Netmask>& subnet);
private:
struct CacheValue
[[nodiscard]] time_t getTTD() const { return validity; }
std::string value;
DNSName qname;
- boost::optional<Netmask> subnet;
+ std::optional<Netmask> subnet;
uint16_t qtype{0};
uint16_t qclass{0};
uint16_t queryFlags{0};
std::atomic<uint64_t> d_entriesCount{0};
};
- [[nodiscard]] bool cachedValueMatches(const CacheValue& cachedValue, uint16_t queryFlags, const DNSName& qname, uint16_t qtype, uint16_t qclass, bool receivedOverUDP, bool dnssecOK, const boost::optional<Netmask>& subnet) const;
+ [[nodiscard]] bool cachedValueMatches(const CacheValue& cachedValue, uint16_t queryFlags, const DNSName& qname, uint16_t qtype, uint16_t qclass, bool receivedOverUDP, bool dnssecOK, const std::optional<Netmask>& subnet) const;
[[nodiscard]] uint32_t getShardIndex(uint32_t key) const;
bool insertLocked(std::unordered_map<uint32_t, CacheValue>& map, uint32_t key, CacheValue& newValue);
#include "dnsdist-configuration-yaml-internal.hh"
#include <variant>
-#include <boost/optional.hpp>
#include <boost/uuid/string_generator.hpp>
#include <boost/variant.hpp>
static bool getOptionalLuaFunction(T& destination, const ::rust::string& functionName)
{
auto lua = g_lua.lock();
- auto function = lua->readVariable<boost::optional<T>>(std::string(functionName));
+ auto function = lua->readVariable<std::optional<T>>(std::string(functionName));
if (!function) {
return false;
}
if (!bind.doh.responses_map.empty()) {
auto newMap = std::make_shared<std::vector<std::shared_ptr<DOHResponseMapEntry>>>();
for (const auto& responsesMap : bind.doh.responses_map) {
- boost::optional<std::unordered_map<std::string, std::string>> headers;
+ std::optional<std::unordered_map<std::string, std::string>> headers;
if (!responsesMap.headers.empty()) {
headers = std::unordered_map<std::string, std::string>();
for (const auto& header : responsesMap.headers) {
void addLuaBindingsForYAMLObjects([[maybe_unused]] LuaContext& luaCtx)
{
#if defined(HAVE_YAML_CONFIGURATION)
- using ReturnValue = boost::optional<boost::variant<std::shared_ptr<DNSDistPacketCache>, std::shared_ptr<DNSRule>, std::shared_ptr<DNSAction>, std::shared_ptr<DNSResponseAction>, std::shared_ptr<NetmaskGroup>, std::shared_ptr<KeyValueStore>, std::shared_ptr<KeyValueLookupKey>, std::shared_ptr<RemoteLoggerInterface>, std::shared_ptr<ServerPolicy>, std::shared_ptr<TimedIPSetRule>, std::shared_ptr<XSKMap>>>;
+ using ReturnValue = std::optional<boost::variant<std::shared_ptr<DNSDistPacketCache>, std::shared_ptr<DNSRule>, std::shared_ptr<DNSAction>, std::shared_ptr<DNSResponseAction>, std::shared_ptr<NetmaskGroup>, std::shared_ptr<KeyValueStore>, std::shared_ptr<KeyValueLookupKey>, std::shared_ptr<RemoteLoggerInterface>, std::shared_ptr<ServerPolicy>, std::shared_ptr<TimedIPSetRule>, std::shared_ptr<XSKMap>>>;
luaCtx.writeFunction("getObjectFromYAMLConfiguration", [](const std::string& name) -> ReturnValue {
auto map = s_registeredTypesMap.lock();
auto item = map->find(name);
if (item == map->end()) {
- return boost::none;
+ return std::nullopt;
}
if (auto* ptr = std::get_if<std::shared_ptr<DNSDistPacketCache>>(&item->second)) {
return ReturnValue(*ptr);
return ReturnValue(*ptr);
}
- return boost::none;
+ return std::nullopt;
});
#endif /* HAVE_YAML_CONFIGURATION */
}
if (!logger && !(dnsdist::configuration::yaml::s_inClientMode || dnsdist::configuration::yaml::s_inConfigCheckMode)) {
throw std::runtime_error("Unable to find the dnstap logger named '" + std::string(config.logger_name) + "'");
}
- boost::optional<dnsdist::actions::DnstapAlterFunction> alterFuncHolder;
+ std::optional<dnsdist::actions::DnstapAlterFunction> alterFuncHolder;
dnsdist::actions::DnstapAlterFunction alterFunc;
if (dnsdist::configuration::yaml::getLuaFunctionFromConfiguration(alterFunc, config.alter_function_name, config.alter_function_code, config.alter_function_file, "dnstap log action")) {
alterFuncHolder = std::move(alterFunc);
if (!logger && !(dnsdist::configuration::yaml::s_inClientMode || dnsdist::configuration::yaml::s_inConfigCheckMode)) {
throw std::runtime_error("Unable to find the dnstap logger named '" + std::string(config.logger_name) + "'");
}
- boost::optional<dnsdist::actions::DnstapAlterResponseFunction> alterFuncHolder;
+ std::optional<dnsdist::actions::DnstapAlterResponseFunction> alterFuncHolder;
dnsdist::actions::DnstapAlterResponseFunction alterFunc;
if (dnsdist::configuration::yaml::getLuaFunctionFromConfiguration(alterFunc, config.alter_function_name, config.alter_function_code, config.alter_function_file, "dnstap log response action")) {
alterFuncHolder = std::move(alterFunc);
g_outputBuffer.clear();
resetLuaSideEffect();
auto ret = lua->executeCode<
- boost::optional<
+ std::optional<
boost::variant<
string,
shared_ptr<DownstreamState>,
g_outputBuffer.clear();
resetLuaSideEffect();
auto ret = lua->executeCode<
- boost::optional<
+ std::optional<
boost::variant<
string,
shared_ptr<DownstreamState>,
struct ResponseConfig
{
- boost::optional<bool> setAA{boost::none};
- boost::optional<bool> setAD{boost::none};
- boost::optional<bool> setRA{boost::none};
+ std::optional<bool> setAA{std::nullopt};
+ std::optional<bool> setAD{std::nullopt};
+ std::optional<bool> setRA{std::nullopt};
uint32_t ttl{60};
};
void setResponseHeadersFromConfig(dnsheader& dnsheader, const ResponseConfig& config);
class DOHResponseMapEntry
{
public:
- DOHResponseMapEntry(const std::string& regex, uint16_t status, const PacketBuffer& content, const boost::optional<std::unordered_map<std::string, std::string>>& headers) :
+ DOHResponseMapEntry(const std::string& regex, uint16_t status, const PacketBuffer& content, const std::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) {
return d_content;
}
- const boost::optional<std::unordered_map<std::string, std::string>>& getHeaders() const
+ const std::optional<std::unordered_map<std::string, std::string>>& getHeaders() const
{
return d_customHeaders;
}
private:
Regex d_regex;
- boost::optional<std::unordered_map<std::string, std::string>> d_customHeaders;
+ std::optional<std::unordered_map<std::string, std::string>> d_customHeaders;
PacketBuffer d_content;
uint16_t d_status;
};
return;
}
- boost::optional<ClientAddressDynamicRules> blocks;
+ std::optional<ClientAddressDynamicRules> blocks;
bool updated = false;
for (const auto& entry : counts) {
auto ret = d_smtVisitor(*node_, self, children);
block = std::get<0>(ret);
if (block) {
- if (boost::optional<std::string> tmp = std::get<1>(ret)) {
+ if (std::optional<std::string> tmp = std::get<1>(ret)) {
blockParameters.d_reason = std::move(*tmp);
}
- if (boost::optional<int> tmp = std::get<2>(ret)) {
+ if (std::optional<int> tmp = std::get<2>(ret)) {
blockParameters.d_action = static_cast<DNSAction::Action>(*tmp);
}
}
}
}
-void DynBlockRulesGroup::addOrRefreshBlock(boost::optional<ClientAddressDynamicRules>& blocks, const struct timespec& now, const AddressAndPortRange& requestor, const DynBlockRule& rule, bool& updated, bool warning)
+void DynBlockRulesGroup::addOrRefreshBlock(std::optional<ClientAddressDynamicRules>& blocks, const struct timespec& now, const AddressAndPortRange& requestor, const DynBlockRule& rule, bool& updated, bool warning)
{
/* network exclusions are address-based only (no port) */
if (d_excludedSubnets.match(requestor.getNetwork())) {
d_respCacheMissRatioRule = std::move(rule);
}
- using smtVisitor_t = std::function<std::tuple<bool, boost::optional<std::string>, boost::optional<int>>(const StatNode&, const StatNode::Stat&, const StatNode::Stat&)>;
+ using smtVisitor_t = std::function<std::tuple<bool, std::optional<std::string>, std::optional<int>>(const StatNode&, const StatNode::Stat&, const StatNode::Stat&)>;
void setSuffixMatchRule(DynBlockRule&& rule, smtVisitor_t visitor)
{
void applySMT(const struct timespec& now, StatNode& statNodeRoot);
bool checkIfQueryTypeMatches(const Rings::Query& query);
bool checkIfResponseCodeMatches(const Rings::Response& response);
- void addOrRefreshBlock(boost::optional<ClientAddressDynamicRules>& blocks, const struct timespec& now, const AddressAndPortRange& requestor, const DynBlockRule& rule, bool& updated, bool warning);
+ void addOrRefreshBlock(std::optional<ClientAddressDynamicRules>& blocks, const struct timespec& now, const AddressAndPortRange& requestor, const DynBlockRule& rule, bool& updated, bool warning);
void addOrRefreshBlockSMT(SuffixDynamicRules& blocks, const struct timespec& now, const DNSName& name, const DynBlockRule& rule, bool& updated);
- void addBlock(boost::optional<ClientAddressDynamicRules>& blocks, const struct timespec& now, const AddressAndPortRange& requestor, const DynBlockRule& rule, bool& updated)
+ void addBlock(std::optional<ClientAddressDynamicRules>& blocks, const struct timespec& now, const AddressAndPortRange& requestor, const DynBlockRule& rule, bool& updated)
{
addOrRefreshBlock(blocks, now, requestor, rule, updated, false);
}
- void handleWarning(boost::optional<ClientAddressDynamicRules>& blocks, const struct timespec& now, const AddressAndPortRange& requestor, const DynBlockRule& rule, bool& updated)
+ void handleWarning(std::optional<ClientAddressDynamicRules>& blocks, const struct timespec& now, const AddressAndPortRange& requestor, const DynBlockRule& rule, bool& updated)
{
addOrRefreshBlock(blocks, now, requestor, rule, updated, true);
}
InternalQueryState partialCloneForXFR() const;
- boost::optional<Netmask> subnet{boost::none}; // 40
+ std::optional<Netmask> subnet{std::nullopt}; // 40
std::string poolName; // 32
#if !defined(DISABLE_PROTOBUF)
std::string d_rawProtobufContent; // protobuf-encoded content to add to protobuf messages // 32
std::vector<std::pair<std::string, std::shared_ptr<RemoteLoggerInterface>>> delayedResponseMsgs;
#endif
std::unique_ptr<EDNSExtendedError> d_extendedError{nullptr};
- boost::optional<uint32_t> tempFailureTTL{boost::none}; // 8
+ std::optional<uint32_t> tempFailureTTL{std::nullopt}; // 8
ClientState* cs{nullptr}; // 8
std::unique_ptr<DOHUnitInterface> du; // 8
size_t d_proxyProtocolPayloadSize{0}; // 8
using responseParams_t = std::unordered_map<std::string, boost::variant<bool, uint32_t>>;
-static dnsdist::ResponseConfig parseResponseConfig(boost::optional<responseParams_t>& vars)
+static dnsdist::ResponseConfig parseResponseConfig(std::optional<responseParams_t>& vars)
{
dnsdist::ResponseConfig config;
getOptionalValue<uint32_t>(vars, "ttl", config.ttl);
}
template <class T>
-std::optional<T> boostToStandardOptional(const boost::optional<T>& boostOpt)
+std::optional<T> boostToStandardOptional(const std::optional<T>& boostOpt)
{
return boostOpt ? *boostOpt : std::optional<T>();
}
// NOLINTNEXTLINE(readability-function-cognitive-complexity): this function declares Lua bindings, even with a good refactoring it will likely blow up the threshold
void setupLuaActions(LuaContext& luaCtx)
{
- luaCtx.writeFunction("newRuleAction", [](const luadnsrule_t& dnsrule, std::shared_ptr<DNSAction> action, boost::optional<luaruleparams_t> params) {
+ luaCtx.writeFunction("newRuleAction", [](const luadnsrule_t& dnsrule, std::shared_ptr<DNSAction> action, std::optional<luaruleparams_t> params) {
boost::uuids::uuid uuid{};
uint64_t creationOrder = 0;
std::string name;
return dnsdist::actions::getLuaFFIResponseAction(std::move(function));
});
- luaCtx.writeFunction("SpoofAction", [](LuaTypeOrArrayOf<std::string> inp, boost::optional<responseParams_t> vars) {
+ luaCtx.writeFunction("SpoofAction", [](LuaTypeOrArrayOf<std::string> inp, std::optional<responseParams_t> vars) {
vector<ComboAddress> addrs;
if (auto* ipaddr = boost::get<std::string>(&inp)) {
addrs.emplace_back(*ipaddr);
return ret;
});
- luaCtx.writeFunction("SpoofSVCAction", [](const LuaArray<SVCRecordParameters>& parameters, boost::optional<responseParams_t> vars) {
+ luaCtx.writeFunction("SpoofSVCAction", [](const LuaArray<SVCRecordParameters>& parameters, std::optional<responseParams_t> vars) {
auto responseConfig = parseResponseConfig(vars);
checkAllParametersConsumed("SpoofAction", vars);
auto svcParams = convertLuaArrayToRegular(parameters);
return ret;
});
- luaCtx.writeFunction("SpoofCNAMEAction", [](const std::string& cname, boost::optional<responseParams_t> vars) {
+ luaCtx.writeFunction("SpoofCNAMEAction", [](const std::string& cname, std::optional<responseParams_t> vars) {
auto responseConfig = parseResponseConfig(vars);
checkAllParametersConsumed("SpoofCNAMEAction", vars);
auto ret = dnsdist::actions::getSpoofAction(DNSName(cname), responseConfig);
return ret;
});
- luaCtx.writeFunction("SpoofRawAction", [](LuaTypeOrArrayOf<std::string> inp, boost::optional<responseParams_t> vars) {
+ luaCtx.writeFunction("SpoofRawAction", [](LuaTypeOrArrayOf<std::string> inp, std::optional<responseParams_t> vars) {
vector<string> raws;
if (const auto* str = boost::get<std::string>(&inp)) {
raws.push_back(*str);
return ret;
});
- luaCtx.writeFunction("LimitTTLResponseAction", [](uint32_t min, uint32_t max, boost::optional<LuaArray<uint16_t>> types) {
+ luaCtx.writeFunction("LimitTTLResponseAction", [](uint32_t min, uint32_t max, std::optional<LuaArray<uint16_t>> types) {
std::unordered_set<QType> capTypes;
if (types) {
capTypes.reserve(types->size());
return dnsdist::actions::getClearRecordTypesResponseAction(std::move(qtypes));
});
- luaCtx.writeFunction("RCodeAction", [](uint8_t rcode, boost::optional<responseParams_t> vars) {
+ luaCtx.writeFunction("RCodeAction", [](uint8_t rcode, std::optional<responseParams_t> vars) {
auto responseConfig = parseResponseConfig(vars);
checkAllParametersConsumed("RCodeAction", vars);
auto ret = dnsdist::actions::getRCodeAction(rcode, responseConfig);
return ret;
});
- luaCtx.writeFunction("ERCodeAction", [](uint8_t rcode, boost::optional<responseParams_t> vars) {
+ luaCtx.writeFunction("ERCodeAction", [](uint8_t rcode, std::optional<responseParams_t> vars) {
auto responseConfig = parseResponseConfig(vars);
checkAllParametersConsumed("ERCodeAction", vars);
auto ret = dnsdist::actions::getERCodeAction(rcode, responseConfig);
// Used for both RemoteLogAction and RemoteLogResponseAction
static const std::array<std::string, 2> s_validIpEncryptMethods = {"legacy", "ipcrypt-pfx"};
- luaCtx.writeFunction("RemoteLogAction", [](std::shared_ptr<RemoteLoggerInterface> logger, boost::optional<dnsdist::actions::ProtobufAlterFunction> alterFunc, boost::optional<LuaAssociativeTable<std::string>> vars, boost::optional<LuaAssociativeTable<std::string>> metas) {
+ luaCtx.writeFunction("RemoteLogAction", [](std::shared_ptr<RemoteLoggerInterface> logger, std::optional<dnsdist::actions::ProtobufAlterFunction> alterFunc, std::optional<LuaAssociativeTable<std::string>> vars, std::optional<LuaAssociativeTable<std::string>> metas) {
if (logger) {
// avoids potentially-evaluated-expression warning with clang.
RemoteLoggerInterface& remoteLoggerRef = *logger;
return dnsdist::actions::getRemoteLogAction(config);
});
- luaCtx.writeFunction("RemoteLogResponseAction", [](std::shared_ptr<RemoteLoggerInterface> logger, boost::optional<dnsdist::actions::ProtobufAlterResponseFunction> alterFunc, boost::optional<bool> includeCNAME, boost::optional<LuaAssociativeTable<std::string>> vars, boost::optional<LuaAssociativeTable<std::string>> metas, boost::optional<bool> delay) {
+ luaCtx.writeFunction("RemoteLogResponseAction", [](std::shared_ptr<RemoteLoggerInterface> logger, std::optional<dnsdist::actions::ProtobufAlterResponseFunction> alterFunc, std::optional<bool> includeCNAME, std::optional<LuaAssociativeTable<std::string>> vars, std::optional<LuaAssociativeTable<std::string>> metas, std::optional<bool> delay) {
if (logger) {
// avoids potentially-evaluated-expression warning with clang.
RemoteLoggerInterface& remoteLoggerRef = *logger;
return dnsdist::actions::getRemoteLogResponseAction(config);
});
- luaCtx.writeFunction("DnstapLogAction", [](const std::string& identity, std::shared_ptr<RemoteLoggerInterface> logger, boost::optional<dnsdist::actions::DnstapAlterFunction> alterFunc) {
+ luaCtx.writeFunction("DnstapLogAction", [](const std::string& identity, std::shared_ptr<RemoteLoggerInterface> logger, std::optional<dnsdist::actions::DnstapAlterFunction> alterFunc) {
return dnsdist::actions::getDnstapLogAction(identity, std::move(logger), alterFunc ? std::move(*alterFunc) : std::optional<dnsdist::actions::DnstapAlterFunction>());
});
- luaCtx.writeFunction("DnstapLogResponseAction", [](const std::string& identity, std::shared_ptr<RemoteLoggerInterface> logger, boost::optional<dnsdist::actions::DnstapAlterResponseFunction> alterFunc) {
+ luaCtx.writeFunction("DnstapLogResponseAction", [](const std::string& identity, std::shared_ptr<RemoteLoggerInterface> logger, std::optional<dnsdist::actions::DnstapAlterResponseFunction> alterFunc) {
return dnsdist::actions::getDnstapLogResponseAction(identity, std::move(logger), alterFunc ? std::move(*alterFunc) : std::optional<dnsdist::actions::DnstapAlterResponseFunction>());
});
#endif /* DISABLE_PROTOBUF */
- luaCtx.writeFunction("TeeAction", [](const std::string& remote, boost::optional<bool> addECS, boost::optional<std::string> local, boost::optional<bool> addProxyProtocol) {
+ luaCtx.writeFunction("TeeAction", [](const std::string& remote, std::optional<bool> addECS, std::optional<std::string> local, std::optional<bool> addProxyProtocol) {
std::optional<ComboAddress> localAddr;
if (local) {
localAddr = ComboAddress(*local, 0);
return dnsdist::actions::getTeeAction(ComboAddress(remote, 53), localAddr, addECS ? *addECS : false, addProxyProtocol ? *addProxyProtocol : false);
});
- luaCtx.writeFunction("SetECSAction", [](const std::string& v4Netmask, boost::optional<std::string> v6Netmask) {
+ luaCtx.writeFunction("SetECSAction", [](const std::string& v4Netmask, std::optional<std::string> v6Netmask) {
if (v6Netmask) {
return dnsdist::actions::getSetECSAction(v4Netmask, *v6Netmask);
}
});
#ifdef HAVE_DNS_OVER_HTTPS
- luaCtx.writeFunction("HTTPStatusAction", [](uint16_t status, std::string body, boost::optional<std::string> contentType, boost::optional<responseParams_t> vars) {
+ luaCtx.writeFunction("HTTPStatusAction", [](uint16_t status, std::string body, std::optional<std::string> contentType, std::optional<responseParams_t> vars) {
auto responseConfig = parseResponseConfig(vars);
checkAllParametersConsumed("HTTPStatusAction", vars);
auto ret = dnsdist::actions::getHTTPStatusAction(status, PacketBuffer(body.begin(), body.end()), contentType ? *contentType : "", responseConfig);
});
#endif /* defined(HAVE_LMDB) || defined(HAVE_CDB) */
- luaCtx.writeFunction("NegativeAndSOAAction", [](bool nxd, const std::string& zone, uint32_t ttl, const std::string& mname, const std::string& rname, uint32_t serial, uint32_t refresh, uint32_t retry, uint32_t expire, uint32_t minimum, boost::optional<responseParams_t> vars) {
+ luaCtx.writeFunction("NegativeAndSOAAction", [](bool nxd, const std::string& zone, uint32_t ttl, const std::string& mname, const std::string& rname, uint32_t serial, uint32_t refresh, uint32_t retry, uint32_t expire, uint32_t minimum, std::optional<responseParams_t> vars) {
bool soaInAuthoritySection = false;
getOptionalValue<bool>(vars, "soaInAuthoritySection", soaInAuthoritySection);
auto responseConfig = parseResponseConfig(vars);
luaCtx.registerFunction("markInactive", &DNSCryptContext::markInactive);
luaCtx.registerFunction("reloadCertificates", &DNSCryptContext::reloadCertificates);
luaCtx.registerFunction("removeInactiveCertificate", &DNSCryptContext::removeInactiveCertificate);
- luaCtx.registerFunction<void (std::shared_ptr<DNSCryptContext>::*)(const std::string& certFile, const std::string& keyFile, boost::optional<bool> active)>("loadNewCertificate", [](std::shared_ptr<DNSCryptContext>& ctx, const std::string& certFile, const std::string& keyFile, boost::optional<bool> active) {
+ luaCtx.registerFunction<void (std::shared_ptr<DNSCryptContext>::*)(const std::string& certFile, const std::string& keyFile, std::optional<bool> active)>("loadNewCertificate", [](std::shared_ptr<DNSCryptContext>& ctx, const std::string& certFile, const std::string& keyFile, std::optional<bool> active) {
if (ctx == nullptr) {
throw std::runtime_error("DNSCryptContext::loadNewCertificate() called on a nil value");
}
ctx->loadNewCertificate(certFile, keyFile, active ? *active : true);
});
- luaCtx.registerFunction<void (std::shared_ptr<DNSCryptContext>::*)(const DNSCryptCert& newCert, const DNSCryptPrivateKey& newKey, boost::optional<bool> active)>("addNewCertificate", [](std::shared_ptr<DNSCryptContext>& ctx, const DNSCryptCert& newCert, const DNSCryptPrivateKey& newKey, boost::optional<bool> active) {
+ luaCtx.registerFunction<void (std::shared_ptr<DNSCryptContext>::*)(const DNSCryptCert& newCert, const DNSCryptPrivateKey& newKey, std::optional<bool> active)>("addNewCertificate", [](std::shared_ptr<DNSCryptContext>& ctx, const DNSCryptCert& newCert, const DNSCryptPrivateKey& newKey, std::optional<bool> active) {
if (ctx == nullptr) {
throw std::runtime_error("DNSCryptContext::addNewCertificate() called on a nil value");
}
return result;
});
- luaCtx.registerFunction<boost::optional<std::shared_ptr<DNSCryptCertificatePair>> (std::shared_ptr<DNSCryptContext>::*)(size_t idx)>("getCertificatePair", [](std::shared_ptr<DNSCryptContext>& ctx, size_t idx) {
+ luaCtx.registerFunction<std::optional<std::shared_ptr<DNSCryptCertificatePair>> (std::shared_ptr<DNSCryptContext>::*)(size_t idx)>("getCertificatePair", [](std::shared_ptr<DNSCryptContext>& ctx, size_t idx) {
if (ctx == nullptr) {
throw std::runtime_error("DNSCryptContext::getCertificatePair() called on a nil value");
}
- boost::optional<std::shared_ptr<DNSCryptCertificatePair>> result{boost::none};
+ std::optional<std::shared_ptr<DNSCryptCertificatePair>> result{std::nullopt};
auto pairs = ctx->getCertificates();
if (idx < pairs.size()) {
result = pairs.at(idx);
return ret.str();
});
- luaCtx.registerFunction<bool (DNSCryptContext::*)(const std::string& providerPrivateKeyFile, uint32_t serial, time_t begin, time_t end, boost::optional<DNSCryptExchangeVersion> version)>("generateAndLoadInMemoryCertificate", [](DNSCryptContext& ctx, const std::string& providerPrivateKeyFile, uint32_t serial, time_t begin, time_t end, boost::optional<DNSCryptExchangeVersion> version) -> bool {
+ luaCtx.registerFunction<bool (DNSCryptContext::*)(const std::string& providerPrivateKeyFile, uint32_t serial, time_t begin, time_t end, std::optional<DNSCryptExchangeVersion> version)>("generateAndLoadInMemoryCertificate", [](DNSCryptContext& ctx, const std::string& providerPrivateKeyFile, uint32_t serial, time_t begin, time_t end, std::optional<DNSCryptExchangeVersion> version) -> bool {
DNSCryptPrivateKey privateKey;
DNSCryptCert cert;
luaCtx.registerFunction<uint32_t (DNSCryptCert::*)() const>("getTSStart", [](const DNSCryptCert& cert) { return ntohl(cert.getTSStart()); });
luaCtx.registerFunction<uint32_t (DNSCryptCert::*)() const>("getTSEnd", [](const DNSCryptCert& cert) { return ntohl(cert.getTSEnd()); });
- luaCtx.writeFunction("generateDNSCryptCertificate", [client](const std::string& providerPrivateKeyFile, const std::string& certificateFile, const std::string& privateKeyFile, uint32_t serial, time_t begin, time_t end, boost::optional<DNSCryptExchangeVersion> version) {
+ luaCtx.writeFunction("generateDNSCryptCertificate", [client](const std::string& providerPrivateKeyFile, const std::string& certificateFile, const std::string& privateKeyFile, uint32_t serial, time_t begin, time_t end, std::optional<DNSCryptExchangeVersion> version) {
setLuaNoSideEffect();
if (client) {
return;
"ecsOverride", [](const DNSQuestion& dnsQuestion) -> bool { return dnsQuestion.ecsOverride; }, [](DNSQuestion& dnsQuestion, bool ecsOverride) { dnsQuestion.ecsOverride = ecsOverride; });
luaCtx.registerMember<uint16_t(DNSQuestion::*)>(
"ecsPrefixLength", [](const DNSQuestion& dnsQuestion) -> uint16_t { return dnsQuestion.ecsPrefixLength; }, [](DNSQuestion& dnsQuestion, uint16_t newPrefixLength) { dnsQuestion.ecsPrefixLength = newPrefixLength; });
- luaCtx.registerMember<boost::optional<uint32_t>(DNSQuestion::*)>(
+ luaCtx.registerMember<std::optional<uint32_t>(DNSQuestion::*)>(
"tempFailureTTL",
- [](const DNSQuestion& dnsQuestion) -> boost::optional<uint32_t> {
+ [](const DNSQuestion& dnsQuestion) -> std::optional<uint32_t> {
return dnsQuestion.ids.tempFailureTTL;
},
- [](DNSQuestion& dnsQuestion, boost::optional<uint32_t> newValue) {
+ [](DNSQuestion& dnsQuestion, std::optional<uint32_t> newValue) {
dnsQuestion.ids.tempFailureTTL = newValue;
});
luaCtx.registerMember<std::string(DNSQuestion::*)>(
return dnsQuestion.ids.queryRealTime.udiff();
});
- luaCtx.registerFunction<void (DNSQuestion::*)(std::string)>("sendTrap", []([[maybe_unused]] const DNSQuestion& dnsQuestion, [[maybe_unused]] boost::optional<std::string> reason) {
+ luaCtx.registerFunction<void (DNSQuestion::*)(std::string)>("sendTrap", []([[maybe_unused]] const DNSQuestion& dnsQuestion, [[maybe_unused]] std::optional<std::string> reason) {
#ifdef HAVE_NET_SNMP
if (g_snmpAgent != nullptr && dnsdist::configuration::getImmutableConfiguration().d_snmpTrapsEnabled) {
g_snmpAgent->sendDNSTrap(dnsQuestion, reason ? *reason : "");
return true;
});
- luaCtx.registerFunction<void (DNSQuestion::*)(const boost::variant<LuaArray<ComboAddress>, LuaArray<std::string>>&, boost::optional<uint16_t>)>("spoof", [](DNSQuestion& dnsQuestion, const boost::variant<LuaArray<ComboAddress>, LuaArray<std::string>>& response, boost::optional<uint16_t> typeForAny) {
+ luaCtx.registerFunction<void (DNSQuestion::*)(const boost::variant<LuaArray<ComboAddress>, LuaArray<std::string>>&, std::optional<uint16_t>)>("spoof", [](DNSQuestion& dnsQuestion, const boost::variant<LuaArray<ComboAddress>, LuaArray<std::string>>& response, std::optional<uint16_t> typeForAny) {
dnsdist::ResponseConfig responseConfig;
if (response.type() == typeid(LuaArray<ComboAddress>)) {
std::vector<ComboAddress> data;
setEDNSOption(dnsQuestion, code, data);
});
- luaCtx.registerFunction<void (DNSQuestion::*)(uint16_t infoCode, const boost::optional<std::string>& extraText)>("setExtendedDNSError", [](DNSQuestion& dnsQuestion, uint16_t infoCode, const boost::optional<std::string>& extraText) {
+ luaCtx.registerFunction<void (DNSQuestion::*)(uint16_t infoCode, const std::optional<std::string>& extraText)>("setExtendedDNSError", [](DNSQuestion& dnsQuestion, uint16_t infoCode, const std::optional<std::string>& extraText) {
EDNSExtendedError ede;
ede.infoCode = infoCode;
if (extraText) {
return {};
});
- luaCtx.registerFunction<void (DNSResponse::*)(std::string)>("sendTrap", []([[maybe_unused]] const DNSResponse& dnsResponse, [[maybe_unused]] boost::optional<std::string> reason) {
+ luaCtx.registerFunction<void (DNSResponse::*)(std::string)>("sendTrap", []([[maybe_unused]] const DNSResponse& dnsResponse, [[maybe_unused]] std::optional<std::string> reason) {
#ifdef HAVE_NET_SNMP
if (g_snmpAgent != nullptr && dnsdist::configuration::getImmutableConfiguration().d_snmpTrapsEnabled) {
g_snmpAgent->sendDNSTrap(dnsResponse, reason ? *reason : "");
return LuaAssociativeTable<std::string>();
});
- luaCtx.registerFunction<void (DNSQuestion::*)(uint64_t statusCode, const std::string& body, const boost::optional<std::string> contentType)>("setHTTPResponse", [](DNSQuestion& dnsQuestion, uint64_t statusCode, const std::string& body, [[maybe_unused]] const boost::optional<std::string>& contentType) {
+ luaCtx.registerFunction<void (DNSQuestion::*)(uint64_t statusCode, const std::string& body, const std::optional<std::string> contentType)>("setHTTPResponse", [](DNSQuestion& dnsQuestion, uint64_t statusCode, const std::string& body, [[maybe_unused]] const std::optional<std::string>& contentType) {
if (dnsQuestion.ids.du == nullptr && dnsQuestion.ids.doh3u == nullptr) {
return;
}
return setNegativeAndAdditionalSOA(dnsQuestion, nxd, DNSName(zone), ttl, DNSName(mname), DNSName(rname), serial, refresh, retry, expire, minimum, false);
});
- luaCtx.registerFunction<void (DNSResponse::*)(uint16_t infoCode, const boost::optional<std::string>& extraText)>("setExtendedDNSError", [](DNSResponse& dnsResponse, uint16_t infoCode, const boost::optional<std::string>& extraText) {
+ luaCtx.registerFunction<void (DNSResponse::*)(uint16_t infoCode, const std::optional<std::string>& extraText)>("setExtendedDNSError", [](DNSResponse& dnsResponse, uint16_t infoCode, const std::optional<std::string>& extraText) {
EDNSExtendedError ede;
ede.infoCode = infoCode;
if (extraText) {
return dnsdist::queueQueryResumptionEvent(std::move(query));
});
- luaCtx.registerFunction<boost::optional<std::shared_ptr<DownstreamState>> (DNSResponse::*)(void) const>("getSelectedBackend", [](const DNSResponse& dnsResponse) {
- return dnsResponse.d_downstream ? dnsResponse.d_downstream : boost::optional<std::shared_ptr<DownstreamState>>();
+ luaCtx.registerFunction<std::optional<std::shared_ptr<DownstreamState>> (DNSResponse::*)(void) const>("getSelectedBackend", [](const DNSResponse& dnsResponse) {
+ return dnsResponse.d_downstream ? dnsResponse.d_downstream : std::optional<std::shared_ptr<DownstreamState>>();
});
luaCtx.registerFunction<bool (DNSResponse::*)()>("getStaleCacheHit", [](DNSResponse& dnsResponse) {
void setupLuaBindingsKVS([[maybe_unused]] LuaContext& luaCtx, [[maybe_unused]] bool client)
{
#ifdef HAVE_LMDB
- luaCtx.writeFunction("newLMDBKVStore", [client](const std::string& fname, const std::string& dbName, boost::optional<bool> noLock) {
+ luaCtx.writeFunction("newLMDBKVStore", [client](const std::string& fname, const std::string& dbName, std::optional<bool> noLock) {
if (client) {
return std::shared_ptr<KeyValueStore>(nullptr);
}
#if defined(HAVE_LMDB) || defined(HAVE_CDB)
/* Key Value Store objects */
- luaCtx.writeFunction("KeyValueLookupKeySourceIP", [](boost::optional<uint8_t> v4Mask, boost::optional<uint8_t> v6Mask, boost::optional<bool> includePort) {
+ luaCtx.writeFunction("KeyValueLookupKeySourceIP", [](std::optional<uint8_t> v4Mask, std::optional<uint8_t> v6Mask, std::optional<bool> includePort) {
return std::shared_ptr<KeyValueLookupKey>(new KeyValueLookupKeySourceIP(v4Mask ? *v4Mask : 32, v6Mask ? *v6Mask : 128, includePort ? *includePort : false));
});
- luaCtx.writeFunction("KeyValueLookupKeyQName", [](boost::optional<bool> wireFormat) {
+ luaCtx.writeFunction("KeyValueLookupKeyQName", [](std::optional<bool> wireFormat) {
return std::shared_ptr<KeyValueLookupKey>(new KeyValueLookupKeyQName(wireFormat ? *wireFormat : true));
});
- luaCtx.writeFunction("KeyValueLookupKeySuffix", [](boost::optional<size_t> minLabels, boost::optional<bool> wireFormat) {
+ luaCtx.writeFunction("KeyValueLookupKeySuffix", [](std::optional<size_t> minLabels, std::optional<bool> wireFormat) {
return std::shared_ptr<KeyValueLookupKey>(new KeyValueLookupKeySuffix(minLabels ? *minLabels : 0, wireFormat ? *wireFormat : true));
});
luaCtx.writeFunction("KeyValueLookupKeyTag", [](const std::string& tag) {
return std::shared_ptr<KeyValueLookupKey>(new KeyValueLookupKeyTag(tag));
});
- luaCtx.registerFunction<std::string(std::shared_ptr<KeyValueStore>::*)(const boost::variant<ComboAddress, DNSName, std::string>, boost::optional<bool> wireFormat)>("lookup", [](std::shared_ptr<KeyValueStore>& kvs, const boost::variant<ComboAddress, DNSName, std::string> keyVar, boost::optional<bool> wireFormat) {
+ luaCtx.registerFunction<std::string(std::shared_ptr<KeyValueStore>::*)(const boost::variant<ComboAddress, DNSName, std::string>, std::optional<bool> wireFormat)>("lookup", [](std::shared_ptr<KeyValueStore>& kvs, const boost::variant<ComboAddress, DNSName, std::string> keyVar, std::optional<bool> wireFormat) {
std::string result;
if (!kvs) {
return result;
return result;
});
- luaCtx.registerFunction<std::string(std::shared_ptr<KeyValueStore>::*)(const DNSName&, boost::optional<size_t> minLabels, boost::optional<bool> wireFormat)>("lookupSuffix", [](std::shared_ptr<KeyValueStore>& kvs, const DNSName& dn, boost::optional<size_t> minLabels, boost::optional<bool> wireFormat) {
+ luaCtx.registerFunction<std::string(std::shared_ptr<KeyValueStore>::*)(const DNSName&, std::optional<size_t> minLabels, std::optional<bool> wireFormat)>("lookupSuffix", [](std::shared_ptr<KeyValueStore>& kvs, const DNSName& dn, std::optional<size_t> minLabels, std::optional<bool> wireFormat) {
std::string result;
if (!kvs) {
return result;
void setupLuaBindingsPacketCache(LuaContext& luaCtx, bool client)
{
/* PacketCache */
- luaCtx.writeFunction("newPacketCache", [client](size_t maxEntries, boost::optional<LuaAssociativeTable<boost::variant<bool, size_t, LuaArray<uint16_t>>>> vars) {
+ luaCtx.writeFunction("newPacketCache", [client](size_t maxEntries, std::optional<LuaAssociativeTable<boost::variant<bool, size_t, LuaArray<uint16_t>>>> vars) {
DNSDistPacketCache::CacheSettings settings {
.d_maxEntries = maxEntries,
}
return static_cast<size_t>(0);
});
- luaCtx.registerFunction<void(std::shared_ptr<DNSDistPacketCache>::*)(const boost::variant<DNSName, string>& dname, boost::optional<uint16_t> qtype, boost::optional<bool> suffixMatch)>("expungeByName", [](
+ luaCtx.registerFunction<void(std::shared_ptr<DNSDistPacketCache>::*)(const boost::variant<DNSName, string>& dname, std::optional<uint16_t> qtype, std::optional<bool> suffixMatch)>("expungeByName", [](
std::shared_ptr<DNSDistPacketCache>& cache,
const boost::variant<DNSName, string>& dname,
- boost::optional<uint16_t> qtype,
- boost::optional<bool> suffixMatch) {
+ std::optional<uint16_t> qtype,
+ std::optional<bool> suffixMatch) {
DNSName qname;
if (dname.type() == typeid(DNSName)) {
qname = boost::get<DNSName>(dname);
return results;
});
- luaCtx.registerFunction<void(std::shared_ptr<DNSDistPacketCache>::*)(const std::string& fname, boost::optional<bool> rawResponse)const>("dump", [](const std::shared_ptr<DNSDistPacketCache>& cache, const std::string& fname, boost::optional<bool> rawResponse) {
+ luaCtx.registerFunction<void(std::shared_ptr<DNSDistPacketCache>::*)(const std::string& fname, std::optional<bool> rawResponse)const>("dump", [](const std::shared_ptr<DNSDistPacketCache>& cache, const std::string& fname, std::optional<bool> rawResponse) {
if (cache) {
int fd = open(fname.c_str(), O_CREAT | O_EXCL | O_WRONLY, 0660);
#include "remote_logger_pool.hh"
#ifdef HAVE_FSTRM
-static void parseFSTRMOptions(boost::optional<LuaAssociativeTable<unsigned int>>& params, LuaAssociativeTable<unsigned int>& options)
+static void parseFSTRMOptions(std::optional<LuaAssociativeTable<unsigned int>>& params, LuaAssociativeTable<unsigned int>& options)
{
if (!params) {
return;
}
});
- luaCtx.registerFunction<void (DNSDistProtoBufMessage::*)(boost::optional<time_t> sec, boost::optional<uint32_t> uSec)>("setProtobufResponseType",
- [](DNSDistProtoBufMessage& message, boost::optional<time_t> sec, boost::optional<uint32_t> uSec) {
+ luaCtx.registerFunction<void (DNSDistProtoBufMessage::*)(std::optional<time_t> sec, std::optional<uint32_t> uSec)>("setProtobufResponseType",
+ [](DNSDistProtoBufMessage& message, std::optional<time_t> sec, std::optional<uint32_t> uSec) {
message.setType(pdns::ProtoZero::Message::MessageType::DNSResponseType);
message.setQueryTime(sec ? *sec : 0, uSec ? *uSec : 0);
});
luaCtx.registerFunction<void (DNSDistProtoBufMessage::*)(time_t, uint32_t)>("setQueryTime", [](DNSDistProtoBufMessage& message, time_t sec, uint32_t usec) { message.setQueryTime(sec, usec); });
luaCtx.registerFunction<void (DNSDistProtoBufMessage::*)(uint8_t)>("setResponseCode", [](DNSDistProtoBufMessage& message, uint8_t rcode) { message.setResponseCode(rcode); });
- luaCtx.registerFunction<void (DNSDistProtoBufMessage::*)(const ComboAddress&, boost::optional<uint16_t>)>("setRequestor", [](DNSDistProtoBufMessage& message, const ComboAddress& addr, boost::optional<uint16_t> port) {
+ luaCtx.registerFunction<void (DNSDistProtoBufMessage::*)(const ComboAddress&, std::optional<uint16_t>)>("setRequestor", [](DNSDistProtoBufMessage& message, const ComboAddress& addr, std::optional<uint16_t> port) {
message.setRequestor(addr);
if (port) {
message.setRequestorPort(*port);
}
});
- luaCtx.registerFunction<void (DNSDistProtoBufMessage::*)(const std::string&, boost::optional<uint16_t>)>("setRequestorFromString", [](DNSDistProtoBufMessage& message, const std::string& str, boost::optional<uint16_t> port) {
+ luaCtx.registerFunction<void (DNSDistProtoBufMessage::*)(const std::string&, std::optional<uint16_t>)>("setRequestorFromString", [](DNSDistProtoBufMessage& message, const std::string& str, std::optional<uint16_t> port) {
message.setRequestor(ComboAddress(str));
if (port) {
message.setRequestorPort(*port);
}
});
- luaCtx.registerFunction<void (DNSDistProtoBufMessage::*)(const ComboAddress&, boost::optional<uint16_t>)>("setResponder", [](DNSDistProtoBufMessage& message, const ComboAddress& addr, boost::optional<uint16_t> port) {
+ luaCtx.registerFunction<void (DNSDistProtoBufMessage::*)(const ComboAddress&, std::optional<uint16_t>)>("setResponder", [](DNSDistProtoBufMessage& message, const ComboAddress& addr, std::optional<uint16_t> port) {
message.setResponder(addr);
if (port) {
message.setResponderPort(*port);
}
});
- luaCtx.registerFunction<void (DNSDistProtoBufMessage::*)(const std::string&, boost::optional<uint16_t>)>("setResponderFromString", [](DNSDistProtoBufMessage& message, const std::string& str, boost::optional<uint16_t> port) {
+ luaCtx.registerFunction<void (DNSDistProtoBufMessage::*)(const std::string&, std::optional<uint16_t>)>("setResponderFromString", [](DNSDistProtoBufMessage& message, const std::string& str, std::optional<uint16_t> port) {
message.setResponder(ComboAddress(str));
if (port) {
message.setResponderPort(*port);
});
/* RemoteLogger */
- luaCtx.writeFunction("newRemoteLogger", [client, configCheck](const std::string& remote, boost::optional<uint16_t> timeout, boost::optional<uint64_t> maxQueuedEntries, boost::optional<uint8_t> reconnectWaitTime, boost::optional<uint64_t> connectionCount) {
+ luaCtx.writeFunction("newRemoteLogger", [client, configCheck](const std::string& remote, std::optional<uint16_t> timeout, std::optional<uint64_t> maxQueuedEntries, std::optional<uint8_t> reconnectWaitTime, std::optional<uint64_t> connectionCount) {
if (client || configCheck) {
return std::shared_ptr<RemoteLoggerInterface>(nullptr);
}
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]([[maybe_unused]] const std::string& address, [[maybe_unused]] boost::optional<LuaAssociativeTable<unsigned int>> params) {
+ luaCtx.writeFunction("newFrameStreamUnixLogger", [client, configCheck]([[maybe_unused]] const std::string& address, [[maybe_unused]] std::optional<LuaAssociativeTable<unsigned int>> params) {
#ifdef HAVE_FSTRM
if (client || configCheck) {
return std::shared_ptr<RemoteLoggerInterface>(nullptr);
#endif /* HAVE_FSTRM */
});
- luaCtx.writeFunction("newFrameStreamTcpLogger", [client, configCheck]([[maybe_unused]] const std::string& address, [[maybe_unused]] boost::optional<LuaAssociativeTable<unsigned int>> params) {
+ luaCtx.writeFunction("newFrameStreamTcpLogger", [client, configCheck]([[maybe_unused]] const std::string& address, [[maybe_unused]] std::optional<LuaAssociativeTable<unsigned int>> params) {
#if defined(HAVE_FSTRM) && defined(HAVE_FSTRM_TCP_WRITER_INIT)
if (client || configCheck) {
return std::shared_ptr<RemoteLoggerInterface>(nullptr);
}
return "lazy";
});
- luaCtx.registerFunction<void (std::shared_ptr<DownstreamState>::*)(boost::optional<bool> newStatus)>("setAuto", [](std::shared_ptr<DownstreamState>& state, boost::optional<bool> newStatus) {
+ luaCtx.registerFunction<void (std::shared_ptr<DownstreamState>::*)(std::optional<bool> newStatus)>("setAuto", [](std::shared_ptr<DownstreamState>& state, std::optional<bool> newStatus) {
if (!state) {
return;
}
}
state->setAuto();
});
- luaCtx.registerFunction<void (std::shared_ptr<DownstreamState>::*)(boost::optional<bool> newStatus)>("setActiveAuto", [](std::shared_ptr<DownstreamState>& state, boost::optional<bool> newStatus) {
+ luaCtx.registerFunction<void (std::shared_ptr<DownstreamState>::*)(std::optional<bool> newStatus)>("setActiveAuto", [](std::shared_ptr<DownstreamState>& state, std::optional<bool> newStatus) {
if (!state) {
return;
}
}
state->setActiveAuto();
});
- luaCtx.registerFunction<void (std::shared_ptr<DownstreamState>::*)(boost::optional<bool> newStatus)>("setLazyAuto", [](std::shared_ptr<DownstreamState>& state, boost::optional<bool> newStatus) {
+ luaCtx.registerFunction<void (std::shared_ptr<DownstreamState>::*)(std::optional<bool> newStatus)>("setLazyAuto", [](std::shared_ptr<DownstreamState>& state, std::optional<bool> newStatus) {
if (!state) {
return;
}
}
state->setLazyAuto();
});
- luaCtx.registerFunction<void (std::shared_ptr<DownstreamState>::*)(boost::optional<LuaAssociativeTable<boost::variant<size_t>>>)>("setHealthCheckParams", [](std::shared_ptr<DownstreamState>& state, boost::optional<LuaAssociativeTable<boost::variant<size_t>>> vars) {
+ luaCtx.registerFunction<void (std::shared_ptr<DownstreamState>::*)(std::optional<LuaAssociativeTable<boost::variant<size_t>>>)>("setHealthCheckParams", [](std::shared_ptr<DownstreamState>& state, std::optional<LuaAssociativeTable<boost::variant<size_t>>> vars) {
if (!state) {
return;
}
#ifndef DISABLE_COMBO_ADDR_BINDINGS
/* ComboAddress */
luaCtx.writeFunction("newCA", [](const std::string& name) { return ComboAddress(name); });
- luaCtx.writeFunction("newCAFromRaw", [](const std::string& raw, boost::optional<uint16_t> port) {
+ luaCtx.writeFunction("newCAFromRaw", [](const std::string& raw, std::optional<uint16_t> port) {
if (raw.size() == 4) {
sockaddr_in sin4{};
memset(&sin4, 0, sizeof(sin4));
// clang-format off
luaCtx.registerFunction("check", (bool (SuffixMatchNode::*)(const DNSName&) const) &SuffixMatchNode::check);
// clang-format on
- luaCtx.registerFunction<boost::optional<DNSName> (SuffixMatchNode::*)(const DNSName&) const>("getBestMatch", [](const SuffixMatchNode& smn, const DNSName& needle) {
- boost::optional<DNSName> result{boost::none};
+ luaCtx.registerFunction<std::optional<DNSName> (SuffixMatchNode::*)(const DNSName&) const>("getBestMatch", [](const SuffixMatchNode& smn, const DNSName& needle) {
+ std::optional<DNSName> result{std::nullopt};
auto res = smn.getBestMatch(needle);
if (res) {
result = *res;
#ifndef DISABLE_NETMASK_BINDINGS
/* Netmask */
- luaCtx.writeFunction("newNetmask", [](boost::variant<std::string, ComboAddress> addrOrStr, boost::optional<uint8_t> bits) {
+ luaCtx.writeFunction("newNetmask", [](boost::variant<std::string, ComboAddress> addrOrStr, std::optional<uint8_t> bits) {
if (addrOrStr.type() == typeid(ComboAddress)) {
const auto& comboAddr = boost::get<ComboAddress>(addrOrStr);
if (bits) {
return std::make_shared<BPFFilter>(mapsConfig, format, external);
});
- luaCtx.registerFunction<void (std::shared_ptr<BPFFilter>::*)(const ComboAddress& addr, boost::optional<uint32_t> action)>("block", [](const std::shared_ptr<BPFFilter>& bpf, const ComboAddress& addr, boost::optional<uint32_t> action) {
+ luaCtx.registerFunction<void (std::shared_ptr<BPFFilter>::*)(const ComboAddress& addr, std::optional<uint32_t> action)>("block", [](const std::shared_ptr<BPFFilter>& bpf, const ComboAddress& addr, std::optional<uint32_t> action) {
if (bpf) {
if (!action) {
return bpf->block(addr, BPFFilter::MatchAction::Drop);
return bpf->block(addr, match);
}
});
- luaCtx.registerFunction<void (std::shared_ptr<BPFFilter>::*)(const string& range, uint32_t action, boost::optional<bool> force)>("addRangeRule", [](const std::shared_ptr<BPFFilter>& bpf, const string& range, uint32_t action, boost::optional<bool> force) {
+ luaCtx.registerFunction<void (std::shared_ptr<BPFFilter>::*)(const string& range, uint32_t action, std::optional<bool> force)>("addRangeRule", [](const std::shared_ptr<BPFFilter>& bpf, const string& range, uint32_t action, std::optional<bool> force) {
if (!bpf) {
return;
}
}
return bpf->addRangeRule(Netmask(range), force ? *force : false, match);
});
- luaCtx.registerFunction<void (std::shared_ptr<BPFFilter>::*)(const DNSName& qname, boost::optional<uint16_t> qtype, boost::optional<uint32_t> action)>("blockQName", [](const std::shared_ptr<BPFFilter>& bpf, const DNSName& qname, boost::optional<uint16_t> qtype, boost::optional<uint32_t> action) {
+ luaCtx.registerFunction<void (std::shared_ptr<BPFFilter>::*)(const DNSName& qname, std::optional<uint16_t> qtype, std::optional<uint32_t> action)>("blockQName", [](const std::shared_ptr<BPFFilter>& bpf, const DNSName& qname, std::optional<uint16_t> qtype, std::optional<uint32_t> action) {
if (bpf) {
if (!action) {
return bpf->block(qname, BPFFilter::MatchAction::Drop, qtype ? *qtype : 65535);
}
return res;
});
- luaCtx.registerFunction<void (std::shared_ptr<BPFFilter>::*)(const DNSName& qname, boost::optional<uint16_t> qtype)>("unblockQName", [](const std::shared_ptr<BPFFilter>& bpf, const DNSName& qname, boost::optional<uint16_t> qtype) {
+ luaCtx.registerFunction<void (std::shared_ptr<BPFFilter>::*)(const DNSName& qname, std::optional<uint16_t> qtype)>("unblockQName", [](const std::shared_ptr<BPFFilter>& bpf, const DNSName& qname, std::optional<uint16_t> qtype) {
if (bpf) {
return bpf->unblock(qname, qtype ? *qtype : 65535);
}
return std::make_shared<DynBPFFilter>(bpf);
});
- luaCtx.registerFunction<void (std::shared_ptr<DynBPFFilter>::*)(const ComboAddress& addr, boost::optional<int> seconds)>("block", [](const std::shared_ptr<DynBPFFilter>& dbpf, const ComboAddress& addr, boost::optional<int> seconds) {
+ luaCtx.registerFunction<void (std::shared_ptr<DynBPFFilter>::*)(const ComboAddress& addr, std::optional<int> seconds)>("block", [](const std::shared_ptr<DynBPFFilter>& dbpf, const ComboAddress& addr, std::optional<int> seconds) {
if (dbpf) {
timespec until{};
clock_gettime(CLOCK_MONOTONIC, &until);
return values;
});
- luaCtx.writeFunction("newDOHResponseMapEntry", [](const std::string& regex, uint64_t status, const std::string& content, boost::optional<LuaAssociativeTable<std::string>> customHeaders) {
+ luaCtx.writeFunction("newDOHResponseMapEntry", [](const std::string& regex, uint64_t status, const std::string& content, std::optional<LuaAssociativeTable<std::string>> customHeaders) {
checkParameterBound("newDOHResponseMapEntry", status, std::numeric_limits<uint16_t>::max());
- boost::optional<LuaAssociativeTable<std::string>> headers{boost::none};
+ std::optional<LuaAssociativeTable<std::string>> headers{std::nullopt};
if (customHeaders) {
headers = LuaAssociativeTable<std::string>();
for (const auto& header : *customHeaders) {
return std::make_shared<DOHResponseMapEntry>(regex, status, PacketBuffer(content.begin(), content.end()), headers);
});
- luaCtx.writeFunction("newSVCRecordParameters", [](uint64_t priority, const std::string& target, boost::optional<svcParamsLua_t> additionalParameters) {
+ luaCtx.writeFunction("newSVCRecordParameters", [](uint64_t priority, const std::string& target, std::optional<svcParamsLua_t> additionalParameters) {
checkParameterBound("newSVCRecordParameters", priority, std::numeric_limits<uint16_t>::max());
SVCRecordParameters parameters;
if (additionalParameters) {
bool dnsdist_ffi_dnsquestion_is_temp_failure_ttl_set(const dnsdist_ffi_dnsquestion_t* dq)
{
- return dq->dq->ids.tempFailureTTL != boost::none;
+ return dq->dq->ids.tempFailureTTL != std::nullopt;
}
uint32_t dnsdist_ffi_dnsquestion_get_temp_failure_ttl(const dnsdist_ffi_dnsquestion_t* dq)
void dnsdist_ffi_dnsquestion_unset_temp_failure_ttl(dnsdist_ffi_dnsquestion_t* dq)
{
- dq->dq->ids.tempFailureTTL = boost::none;
+ dq->dq->ids.tempFailureTTL = std::nullopt;
}
void dnsdist_ffi_dnsquestion_set_tag(dnsdist_ffi_dnsquestion_t* dq, const char* label, const char* value)
#include "statnode.hh"
#ifndef DISABLE_TOP_N_BINDINGS
-static LuaArray<std::vector<boost::variant<string, double>>> getGenResponses(uint64_t top, boost::optional<int> labels, const std::function<bool(const Rings::Response&)>& pred)
+static LuaArray<std::vector<boost::variant<string, double>>> getGenResponses(uint64_t top, std::optional<int> labels, const std::function<bool(const Rings::Response&)>& pred)
{
setLuaNoSideEffect();
map<DNSName, unsigned int> counts;
root.visit([visitor = std::move(visitor)](const StatNode* node_, const StatNode::Stat& self, const StatNode::Stat& children) { visitor(*node_, self, children); }, node);
}
-static LuaArray<LuaAssociativeTable<std::string>> getRespRing(boost::optional<int> rcode)
+static LuaArray<LuaAssociativeTable<std::string>> getRespRing(std::optional<int> rcode)
{
using entry_t = LuaAssociativeTable<std::string>;
LuaArray<entry_t> ret;
int count = 1;
for (const auto& entry : *respRing) {
- if (rcode && (rcode.get() != entry.dh.rcode)) {
+ if (rcode && (rcode.value() != entry.dh.rcode)) {
continue;
}
entry_t newEntry;
pdns::UniqueFilePtr outputFile{nullptr};
};
-static std::optional<GrepQParams> parseGrepQParams(const LuaTypeOrArrayOf<std::string>& inp, boost::optional<LuaAssociativeTable<std::string>>& options)
+static std::optional<GrepQParams> parseGrepQParams(const LuaTypeOrArrayOf<std::string>& inp, std::optional<LuaAssociativeTable<std::string>>& options)
{
GrepQParams result{};
}
#ifndef DISABLE_DYNBLOCKS
-using DynamicActionOptionalParameters = boost::optional<LuaAssociativeTable<std::string>>;
+using DynamicActionOptionalParameters = std::optional<LuaAssociativeTable<std::string>>;
-static void parseDynamicActionOptionalParameters(const std::string& directive, DynBlockRulesGroup::DynBlockRule& rule, const boost::optional<DNSAction::Action>& action, const DynamicActionOptionalParameters& optionalParameters)
+static void parseDynamicActionOptionalParameters(const std::string& directive, DynBlockRulesGroup::DynBlockRule& rule, const std::optional<DNSAction::Action>& action, const DynamicActionOptionalParameters& optionalParameters)
{
if (action && *action == DNSAction::Action::SetTag) {
if (!optionalParameters) {
void setupLuaInspection(LuaContext& luaCtx)
{
#ifndef DISABLE_TOP_N_BINDINGS
- luaCtx.writeFunction("topClients", [](boost::optional<uint64_t> top_) {
+ luaCtx.writeFunction("topClients", [](std::optional<uint64_t> top_) {
setLuaNoSideEffect();
uint64_t top = top_ ? *top_ : 10U;
map<ComboAddress, unsigned int, ComboAddress::addressOnlyLessThan> counts;
g_outputBuffer += (fmt % (count) % "Rest" % rest % (total > 0 ? 100.0 * rest / total : 100.0)).str();
});
- luaCtx.writeFunction("getTopQueries", [](uint64_t top, boost::optional<int> labels) {
+ luaCtx.writeFunction("getTopQueries", [](uint64_t top, std::optional<int> labels) {
setLuaNoSideEffect();
map<DNSName, unsigned int> counts;
unsigned int total = 0;
return ret;
});
- luaCtx.writeFunction("getTopResponses", [](uint64_t top, uint64_t kind, boost::optional<int> labels) {
+ luaCtx.writeFunction("getTopResponses", [](uint64_t top, uint64_t kind, std::optional<int> labels) {
return getGenResponses(top, labels, [kind](const Rings::Response& resp) { return resp.dh.rcode == kind; });
});
luaCtx.executeCode(R"(function topResponses(top, kind, labels) top = top or 10; kind = kind or 0; for k,v in ipairs(getTopResponses(top, kind, labels)) do show(string.format("%4d %-40s %4d %4.1f%%",k,v[1],v[2],v[3])) end end)");
- luaCtx.writeFunction("getSlowResponses", [](uint64_t top, uint64_t msec, boost::optional<int> labels, boost::optional<bool> timeouts) {
+ luaCtx.writeFunction("getSlowResponses", [](uint64_t top, uint64_t msec, std::optional<int> labels, std::optional<bool> timeouts) {
return getGenResponses(top, labels, [msec, timeouts](const Rings::Response& resp) {
if (timeouts && *timeouts) {
return resp.usec == std::numeric_limits<unsigned int>::max();
}
});
- luaCtx.writeFunction("grepq", [](const LuaTypeOrArrayOf<std::string>& inp, boost::optional<unsigned int> limit, boost::optional<LuaAssociativeTable<std::string>> options) {
+ luaCtx.writeFunction("grepq", [](const LuaTypeOrArrayOf<std::string>& inp, std::optional<unsigned int> limit, std::optional<LuaAssociativeTable<std::string>> options) {
setLuaNoSideEffect();
auto paramsOrError = parseGrepQParams(inp, options);
luaCtx.registerMember("bytes", &StatNode::Stat::bytes);
luaCtx.registerMember("hits", &StatNode::Stat::hits);
- luaCtx.writeFunction("statNodeRespRing", [](statvisitor_t visitor, boost::optional<uint64_t> seconds) {
+ luaCtx.writeFunction("statNodeRespRing", [](statvisitor_t visitor, std::optional<uint64_t> seconds) {
statNodeRespRing(std::move(visitor), seconds ? *seconds : 0U);
});
#endif /* DISABLE_DEPRECATED_DYNBLOCK */
/* DynBlockRulesGroup */
luaCtx.writeFunction("dynBlockRulesGroup", []() { return std::make_shared<DynBlockRulesGroup>(); });
// NOLINTNEXTLINE(performance-unnecessary-value-param): optional parameters cannot be passed by const reference
- luaCtx.registerFunction<void (std::shared_ptr<DynBlockRulesGroup>::*)(unsigned int, unsigned int, const std::string&, unsigned int, boost::optional<DNSAction::Action>, boost::optional<unsigned int>, DynamicActionOptionalParameters)>("setQueryRate", [](std::shared_ptr<DynBlockRulesGroup>& group, unsigned int rate, unsigned int seconds, const std::string& reason, unsigned int blockDuration, boost::optional<DNSAction::Action> action, boost::optional<unsigned int> warningRate, DynamicActionOptionalParameters optionalParameters) {
+ luaCtx.registerFunction<void (std::shared_ptr<DynBlockRulesGroup>::*)(unsigned int, unsigned int, const std::string&, unsigned int, std::optional<DNSAction::Action>, std::optional<unsigned int>, DynamicActionOptionalParameters)>("setQueryRate", [](std::shared_ptr<DynBlockRulesGroup>& group, unsigned int rate, unsigned int seconds, const std::string& reason, unsigned int blockDuration, std::optional<DNSAction::Action> action, std::optional<unsigned int> warningRate, DynamicActionOptionalParameters optionalParameters) {
if (group) {
DynBlockRulesGroup::DynBlockRule rule(reason, blockDuration, rate, warningRate ? *warningRate : 0, seconds, action ? *action : DNSAction::Action::None);
parseDynamicActionOptionalParameters("setQueryRate", rule, action, optionalParameters);
}
});
// NOLINTNEXTLINE(performance-unnecessary-value-param): optional parameters cannot be passed by const reference
- luaCtx.registerFunction<void (std::shared_ptr<DynBlockRulesGroup>::*)(unsigned int, unsigned int, const std::string&, unsigned int, boost::optional<DNSAction::Action>, boost::optional<unsigned int>, DynamicActionOptionalParameters)>("setResponseByteRate", [](std::shared_ptr<DynBlockRulesGroup>& group, unsigned int rate, unsigned int seconds, const std::string& reason, unsigned int blockDuration, boost::optional<DNSAction::Action> action, boost::optional<unsigned int> warningRate, DynamicActionOptionalParameters optionalParameters) {
+ luaCtx.registerFunction<void (std::shared_ptr<DynBlockRulesGroup>::*)(unsigned int, unsigned int, const std::string&, unsigned int, std::optional<DNSAction::Action>, std::optional<unsigned int>, DynamicActionOptionalParameters)>("setResponseByteRate", [](std::shared_ptr<DynBlockRulesGroup>& group, unsigned int rate, unsigned int seconds, const std::string& reason, unsigned int blockDuration, std::optional<DNSAction::Action> action, std::optional<unsigned int> warningRate, DynamicActionOptionalParameters optionalParameters) {
if (group) {
DynBlockRulesGroup::DynBlockRule rule(reason, blockDuration, rate, warningRate ? *warningRate : 0, seconds, action ? *action : DNSAction::Action::None);
parseDynamicActionOptionalParameters("setResponseByteRate", rule, action, optionalParameters);
}
});
// NOLINTNEXTLINE(performance-unnecessary-value-param): optional parameters cannot be passed by const reference
- luaCtx.registerFunction<void (std::shared_ptr<DynBlockRulesGroup>::*)(unsigned int, const std::string&, unsigned int, boost::optional<DNSAction::Action>, DynBlockRulesGroup::smtVisitor_t, DynamicActionOptionalParameters)>("setSuffixMatchRule", [](std::shared_ptr<DynBlockRulesGroup>& group, unsigned int seconds, const std::string& reason, unsigned int blockDuration, boost::optional<DNSAction::Action> action, DynBlockRulesGroup::smtVisitor_t visitor, DynamicActionOptionalParameters optionalParameters) {
+ luaCtx.registerFunction<void (std::shared_ptr<DynBlockRulesGroup>::*)(unsigned int, const std::string&, unsigned int, std::optional<DNSAction::Action>, DynBlockRulesGroup::smtVisitor_t, DynamicActionOptionalParameters)>("setSuffixMatchRule", [](std::shared_ptr<DynBlockRulesGroup>& group, unsigned int seconds, const std::string& reason, unsigned int blockDuration, std::optional<DNSAction::Action> action, DynBlockRulesGroup::smtVisitor_t visitor, DynamicActionOptionalParameters optionalParameters) {
if (group) {
DynBlockRulesGroup::DynBlockRule rule(reason, blockDuration, 0, 0, seconds, action ? *action : DNSAction::Action::None);
parseDynamicActionOptionalParameters("setSuffixMatchRule", rule, action, optionalParameters);
}
});
// NOLINTNEXTLINE(performance-unnecessary-value-param): optional parameters cannot be passed by const reference
- luaCtx.registerFunction<void (std::shared_ptr<DynBlockRulesGroup>::*)(unsigned int, const std::string&, unsigned int, boost::optional<DNSAction::Action>, dnsdist_ffi_stat_node_visitor_t, DynamicActionOptionalParameters)>("setSuffixMatchRuleFFI", [](std::shared_ptr<DynBlockRulesGroup>& group, unsigned int seconds, const std::string& reason, unsigned int blockDuration, boost::optional<DNSAction::Action> action, dnsdist_ffi_stat_node_visitor_t visitor, DynamicActionOptionalParameters optionalParameters) {
+ luaCtx.registerFunction<void (std::shared_ptr<DynBlockRulesGroup>::*)(unsigned int, const std::string&, unsigned int, std::optional<DNSAction::Action>, dnsdist_ffi_stat_node_visitor_t, DynamicActionOptionalParameters)>("setSuffixMatchRuleFFI", [](std::shared_ptr<DynBlockRulesGroup>& group, unsigned int seconds, const std::string& reason, unsigned int blockDuration, std::optional<DNSAction::Action> action, dnsdist_ffi_stat_node_visitor_t visitor, DynamicActionOptionalParameters optionalParameters) {
if (group) {
DynBlockRulesGroup::DynBlockRule rule(reason, blockDuration, 0, 0, seconds, action ? *action : DNSAction::Action::None);
parseDynamicActionOptionalParameters("setSuffixMatchRuleFFI", rule, action, optionalParameters);
}
});
// NOLINTNEXTLINE(performance-unnecessary-value-param): optional parameters cannot be passed by const reference
- luaCtx.registerFunction<void (std::shared_ptr<DynBlockRulesGroup>::*)(uint8_t, unsigned int, unsigned int, const std::string&, unsigned int, boost::optional<DNSAction::Action>, boost::optional<unsigned int>, DynamicActionOptionalParameters)>("setRCodeRate", [](std::shared_ptr<DynBlockRulesGroup>& group, uint8_t rcode, unsigned int rate, unsigned int seconds, const std::string& reason, unsigned int blockDuration, boost::optional<DNSAction::Action> action, boost::optional<unsigned int> warningRate, DynamicActionOptionalParameters optionalParameters) {
+ luaCtx.registerFunction<void (std::shared_ptr<DynBlockRulesGroup>::*)(uint8_t, unsigned int, unsigned int, const std::string&, unsigned int, std::optional<DNSAction::Action>, std::optional<unsigned int>, DynamicActionOptionalParameters)>("setRCodeRate", [](std::shared_ptr<DynBlockRulesGroup>& group, uint8_t rcode, unsigned int rate, unsigned int seconds, const std::string& reason, unsigned int blockDuration, std::optional<DNSAction::Action> action, std::optional<unsigned int> warningRate, DynamicActionOptionalParameters optionalParameters) {
if (group) {
DynBlockRulesGroup::DynBlockRule rule(reason, blockDuration, rate, warningRate ? *warningRate : 0, seconds, action ? *action : DNSAction::Action::None);
parseDynamicActionOptionalParameters("setRCodeRate", rule, action, optionalParameters);
}
});
// NOLINTNEXTLINE(performance-unnecessary-value-param): optional parameters cannot be passed by const reference
- luaCtx.registerFunction<void (std::shared_ptr<DynBlockRulesGroup>::*)(uint8_t, double, unsigned int, const std::string&, unsigned int, size_t, boost::optional<DNSAction::Action>, boost::optional<double>, DynamicActionOptionalParameters)>("setRCodeRatio", [](std::shared_ptr<DynBlockRulesGroup>& group, uint8_t rcode, double ratio, unsigned int seconds, const std::string& reason, unsigned int blockDuration, size_t minimumNumberOfResponses, boost::optional<DNSAction::Action> action, boost::optional<double> warningRatio, DynamicActionOptionalParameters optionalParameters) {
+ luaCtx.registerFunction<void (std::shared_ptr<DynBlockRulesGroup>::*)(uint8_t, double, unsigned int, const std::string&, unsigned int, size_t, std::optional<DNSAction::Action>, std::optional<double>, DynamicActionOptionalParameters)>("setRCodeRatio", [](std::shared_ptr<DynBlockRulesGroup>& group, uint8_t rcode, double ratio, unsigned int seconds, const std::string& reason, unsigned int blockDuration, size_t minimumNumberOfResponses, std::optional<DNSAction::Action> action, std::optional<double> warningRatio, DynamicActionOptionalParameters optionalParameters) {
if (group) {
DynBlockRulesGroup::DynBlockRatioRule rule(reason, blockDuration, ratio, warningRatio ? *warningRatio : 0.0, seconds, action ? *action : DNSAction::Action::None, minimumNumberOfResponses);
parseDynamicActionOptionalParameters("setRCodeRatio", rule, action, optionalParameters);
}
});
// NOLINTNEXTLINE(performance-unnecessary-value-param): optional parameters cannot be passed by const reference
- luaCtx.registerFunction<void (std::shared_ptr<DynBlockRulesGroup>::*)(uint16_t, unsigned int, unsigned int, const std::string&, unsigned int, boost::optional<DNSAction::Action>, boost::optional<unsigned int>, DynamicActionOptionalParameters)>("setQTypeRate", [](std::shared_ptr<DynBlockRulesGroup>& group, uint16_t qtype, unsigned int rate, unsigned int seconds, const std::string& reason, unsigned int blockDuration, boost::optional<DNSAction::Action> action, boost::optional<unsigned int> warningRate, DynamicActionOptionalParameters optionalParameters) {
+ luaCtx.registerFunction<void (std::shared_ptr<DynBlockRulesGroup>::*)(uint16_t, unsigned int, unsigned int, const std::string&, unsigned int, std::optional<DNSAction::Action>, std::optional<unsigned int>, DynamicActionOptionalParameters)>("setQTypeRate", [](std::shared_ptr<DynBlockRulesGroup>& group, uint16_t qtype, unsigned int rate, unsigned int seconds, const std::string& reason, unsigned int blockDuration, std::optional<DNSAction::Action> action, std::optional<unsigned int> warningRate, DynamicActionOptionalParameters optionalParameters) {
if (group) {
DynBlockRulesGroup::DynBlockRule rule(reason, blockDuration, rate, warningRate ? *warningRate : 0, seconds, action ? *action : DNSAction::Action::None);
parseDynamicActionOptionalParameters("setQTypeRate", rule, action, optionalParameters);
}
});
// NOLINTNEXTLINE(performance-unnecessary-value-param): optional parameters cannot be passed by const reference
- luaCtx.registerFunction<void (std::shared_ptr<DynBlockRulesGroup>::*)(double, unsigned int, const std::string&, unsigned int, size_t, double, boost::optional<DNSAction::Action>, boost::optional<double>, DynamicActionOptionalParameters)>("setCacheMissRatio", [](std::shared_ptr<DynBlockRulesGroup>& group, double ratio, unsigned int seconds, const std::string& reason, unsigned int blockDuration, size_t minimumNumberOfResponses, double minimumGlobalCacheHitRatio, boost::optional<DNSAction::Action> action, boost::optional<double> warningRatio, DynamicActionOptionalParameters optionalParameters) {
+ luaCtx.registerFunction<void (std::shared_ptr<DynBlockRulesGroup>::*)(double, unsigned int, const std::string&, unsigned int, size_t, double, std::optional<DNSAction::Action>, std::optional<double>, DynamicActionOptionalParameters)>("setCacheMissRatio", [](std::shared_ptr<DynBlockRulesGroup>& group, double ratio, unsigned int seconds, const std::string& reason, unsigned int blockDuration, size_t minimumNumberOfResponses, double minimumGlobalCacheHitRatio, std::optional<DNSAction::Action> action, std::optional<double> warningRatio, DynamicActionOptionalParameters optionalParameters) {
if (group) {
DynBlockRulesGroup::DynBlockCacheMissRatioRule rule(reason, blockDuration, ratio, warningRatio ? *warningRatio : 0.0, seconds, action ? *action : DNSAction::Action::None, minimumNumberOfResponses, minimumGlobalCacheHitRatio);
parseDynamicActionOptionalParameters("setCacheMissRatio", rule, action, optionalParameters);
luaCtx.writeFunction("addDynBlockSMT",
// NOLINTNEXTLINE(performance-unnecessary-value-param): optional parameters cannot be passed by const reference
- [](const LuaArray<std::string>& names, const std::string& msg, boost::optional<int> seconds, boost::optional<DNSAction::Action> action, DynamicActionOptionalParameters optionalParameters) {
+ [](const LuaArray<std::string>& names, const std::string& msg, std::optional<int> seconds, std::optional<DNSAction::Action> action, DynamicActionOptionalParameters optionalParameters) {
if (names.empty()) {
return;
}
luaCtx.writeFunction("addDynamicBlock",
// NOLINTNEXTLINE(performance-unnecessary-value-param): optional parameters cannot be passed by const reference
- [](const boost::variant<ComboAddress, std::string>& clientIP, const std::string& msg, const boost::optional<DNSAction::Action> action, const boost::optional<int> seconds, boost::optional<uint8_t> clientIPMask, boost::optional<uint8_t> clientIPPortMask, DynamicActionOptionalParameters optionalParameters) {
+ [](const boost::variant<ComboAddress, std::string>& clientIP, const std::string& msg, const std::optional<DNSAction::Action> action, const std::optional<int> seconds, std::optional<uint8_t> clientIPMask, std::optional<uint8_t> clientIPPortMask, DynamicActionOptionalParameters optionalParameters) {
setLuaSideEffect();
ComboAddress clientIPCA;
#include "dnsdist-rules-factory.hh"
#include "dnsdist-rule-chains.hh"
#include "dns_random.hh"
+#include <optional>
std::shared_ptr<DNSRule> makeRule(const luadnsrule_t& var, const std::string& calledFrom)
{
return getUniqueID(identifier);
}
-void parseRuleParams(boost::optional<luaruleparams_t>& params, boost::uuids::uuid& uuid, std::string& name, uint64_t& creationOrder)
+void parseRuleParams(std::optional<luaruleparams_t>& params, boost::uuids::uuid& uuid, std::string& name, uint64_t& creationOrder)
{
static uint64_t s_creationOrder = 0;
using ruleparams_t = LuaAssociativeTable<boost::variant<bool, int, std::string, LuaArray<int>>>;
template <typename T>
-static std::string rulesToString(const std::vector<T>& rules, boost::optional<ruleparams_t>& vars)
+static std::string rulesToString(const std::vector<T>& rules, std::optional<ruleparams_t>& vars)
{
int num = 0;
bool showUUIDs = false;
}
template <typename IdentifierT>
-static void showRules(IdentifierT identifier, boost::optional<ruleparams_t>& vars)
+static void showRules(IdentifierT identifier, std::optional<ruleparams_t>& vars)
{
setLuaNoSideEffect();
}
template <typename ActionT, typename IdentifierT>
-static void addRule(IdentifierT identifier, const std::string& methodName, const luadnsrule_t& var, const std::shared_ptr<ActionT>& action, boost::optional<luaruleparams_t>& params)
+static void addRule(IdentifierT identifier, const std::string& methodName, const luadnsrule_t& var, const std::shared_ptr<ActionT>& action, std::optional<luaruleparams_t>& params)
{
setLuaSideEffect();
}
template <typename T>
-static boost::optional<T> getRuleFromSelector(const std::vector<T>& rules, const boost::variant<unsigned int, std::string>& selector)
+static std::optional<T> getRuleFromSelector(const std::vector<T>& rules, const boost::variant<unsigned int, std::string>& selector)
{
if (const auto* str = boost::get<std::string>(&selector)) {
/* let's see if this a UUID */
supplied position is out of bounds, this is fine */
return rules.at(*pos);
}
- return boost::none;
+ return std::nullopt;
}
namespace
{
-std::shared_ptr<DNSRule> qnameSuffixRule(const boost::variant<const SuffixMatchNode&, std::string, const LuaArray<std::string>> names, boost::optional<bool> quiet)
+std::shared_ptr<DNSRule> qnameSuffixRule(const boost::variant<const SuffixMatchNode&, std::string, const LuaArray<std::string>> names, std::optional<bool> quiet)
{
if (names.type() == typeid(string)) {
SuffixMatchNode smn;
}
template <class T>
-std::optional<T> boostToStandardOptional(const boost::optional<T>& boostOpt)
+std::optional<T> boostToStandardOptional(const std::optional<T>& boostOpt)
{
return boostOpt ? *boostOpt : std::optional<T>();
}
void setupLuaRuleChainsManagement(LuaContext& luaCtx)
{
for (const auto& chain : dnsdist::rules::getResponseRuleChainDescriptions()) {
- luaCtx.writeFunction("show" + chain.prefix + "ResponseRules", [&chain](boost::optional<ruleparams_t> vars) {
+ luaCtx.writeFunction("show" + chain.prefix + "ResponseRules", [&chain](std::optional<ruleparams_t> vars) {
showRules(chain.identifier, vars);
});
luaCtx.writeFunction("rm" + chain.prefix + "ResponseRule", [&chain](const boost::variant<unsigned int, std::string>& identifier) {
luaCtx.writeFunction("mv" + chain.prefix + "ResponseRule", [&chain](unsigned int from, unsigned int dest) {
mvRule(chain.identifier, from, dest);
});
- luaCtx.writeFunction("get" + chain.prefix + "ResponseRule", [&chain](const boost::variant<unsigned int, std::string>& selector) -> boost::optional<dnsdist::rules::ResponseRuleAction> {
+ luaCtx.writeFunction("get" + chain.prefix + "ResponseRule", [&chain](const boost::variant<unsigned int, std::string>& selector) -> std::optional<dnsdist::rules::ResponseRuleAction> {
const auto& chains = dnsdist::configuration::getCurrentRuntimeConfiguration().d_ruleChains;
const auto& rules = dnsdist::rules::getResponseRuleChain(chains, chain.identifier);
return getRuleFromSelector(rules, selector);
});
- luaCtx.writeFunction("getTop" + chain.prefix + "ResponseRules", [&chain](boost::optional<unsigned int> top) {
+ luaCtx.writeFunction("getTop" + chain.prefix + "ResponseRules", [&chain](std::optional<unsigned int> top) {
setLuaNoSideEffect();
const auto& chains = dnsdist::configuration::getCurrentRuntimeConfiguration().d_ruleChains;
const auto& rules = dnsdist::rules::getResponseRuleChain(chains, chain.identifier);
return toLuaArray(getTopRules(rules, (top ? *top : 10)));
});
- luaCtx.writeFunction("top" + chain.prefix + "ResponseRules", [&chain](boost::optional<unsigned int> top, boost::optional<ruleparams_t> vars) {
+ luaCtx.writeFunction("top" + chain.prefix + "ResponseRules", [&chain](std::optional<unsigned int> top, std::optional<ruleparams_t> vars) {
setLuaNoSideEffect();
const auto& chains = dnsdist::configuration::getCurrentRuntimeConfiguration().d_ruleChains;
const auto& rules = dnsdist::rules::getResponseRuleChain(chains, chain.identifier);
}
for (const auto& chain : dnsdist::rules::getRuleChainDescriptions()) {
- luaCtx.writeFunction("show" + chain.prefix + "Rules", [&chain](boost::optional<ruleparams_t> vars) {
+ luaCtx.writeFunction("show" + chain.prefix + "Rules", [&chain](std::optional<ruleparams_t> vars) {
showRules(chain.identifier, vars);
});
luaCtx.writeFunction("rm" + chain.prefix + "Rule", [&chain](const boost::variant<unsigned int, std::string>& identifier) {
luaCtx.writeFunction("mv" + chain.prefix + "Rule", [&chain](unsigned int from, unsigned int dest) {
mvRule(chain.identifier, from, dest);
});
- luaCtx.writeFunction("get" + chain.prefix + "Rule", [&chain](const boost::variant<int, std::string>& selector) -> boost::optional<dnsdist::rules::RuleAction> {
+ luaCtx.writeFunction("get" + chain.prefix + "Rule", [&chain](const boost::variant<int, std::string>& selector) -> std::optional<dnsdist::rules::RuleAction> {
const auto& chains = dnsdist::configuration::getCurrentRuntimeConfiguration().d_ruleChains;
const auto& rules = dnsdist::rules::getRuleChain(chains, chain.identifier);
return getRuleFromSelector(rules, selector);
});
- luaCtx.writeFunction("getTop" + chain.prefix + "Rules", [&chain](boost::optional<unsigned int> top) {
+ luaCtx.writeFunction("getTop" + chain.prefix + "Rules", [&chain](std::optional<unsigned int> top) {
setLuaNoSideEffect();
const auto& chains = dnsdist::configuration::getCurrentRuntimeConfiguration().d_ruleChains;
const auto& rules = dnsdist::rules::getRuleChain(chains, chain.identifier);
return toLuaArray(getTopRules(rules, (top ? *top : 10)));
});
- luaCtx.writeFunction("top" + chain.prefix + "Rules", [&chain](boost::optional<unsigned int> top, boost::optional<ruleparams_t> vars) {
+ luaCtx.writeFunction("top" + chain.prefix + "Rules", [&chain](std::optional<unsigned int> top, std::optional<ruleparams_t> vars) {
setLuaNoSideEffect();
const auto& chains = dnsdist::configuration::getCurrentRuntimeConfiguration().d_ruleChains;
const auto& rules = dnsdist::rules::getRuleChain(chains, chain.identifier);
for (const auto& chain : dnsdist::rules::getRuleChainDescriptions()) {
auto fullName = std::string("add") + chain.prefix + std::string("Action");
- luaCtx.writeFunction(fullName, [&fullName, &chain](const luadnsrule_t& var, boost::variant<std::shared_ptr<DNSAction>, std::shared_ptr<DNSResponseAction>> era, boost::optional<luaruleparams_t> params) {
+ luaCtx.writeFunction(fullName, [&fullName, &chain](const luadnsrule_t& var, boost::variant<std::shared_ptr<DNSAction>, std::shared_ptr<DNSResponseAction>> era, std::optional<luaruleparams_t> params) {
if (era.type() != typeid(std::shared_ptr<DNSAction>)) {
throw std::runtime_error(fullName + "() can only be called with query-related actions, not response-related ones. Are you looking for addResponseAction()?");
}
fullName = std::string("get") + chain.prefix + std::string("Action");
luaCtx.writeFunction(fullName, [&chain](unsigned int num) {
setLuaNoSideEffect();
- boost::optional<std::shared_ptr<DNSAction>> ret;
+ std::optional<std::shared_ptr<DNSAction>> ret;
const auto& chains = dnsdist::configuration::getCurrentRuntimeConfiguration().d_ruleChains;
const auto& ruleactions = dnsdist::rules::getRuleChain(chains, chain.identifier);
if (num < ruleactions.size()) {
for (const auto& chain : dnsdist::rules::getResponseRuleChainDescriptions()) {
const auto fullName = std::string("add") + chain.prefix + std::string("ResponseAction");
- luaCtx.writeFunction(fullName, [&fullName, &chain](const luadnsrule_t& var, boost::variant<std::shared_ptr<DNSAction>, std::shared_ptr<DNSResponseAction>> era, boost::optional<luaruleparams_t> params) {
+ luaCtx.writeFunction(fullName, [&fullName, &chain](const luadnsrule_t& var, boost::variant<std::shared_ptr<DNSAction>, std::shared_ptr<DNSResponseAction>> era, std::optional<luaruleparams_t> params) {
if (era.type() != typeid(std::shared_ptr<DNSResponseAction>)) {
throw std::runtime_error(fullName + "() can only be called with response-related actions, not query-related ones. Are you looking for addAction()?");
}
});
}
- luaCtx.writeFunction("benchRule", [](const std::shared_ptr<DNSRule>& rule, boost::optional<unsigned int> times_, boost::optional<string> suffix_) {
+ luaCtx.writeFunction("benchRule", [](const std::shared_ptr<DNSRule>& rule, std::optional<unsigned int> times_, std::optional<string> suffix_) {
setLuaNoSideEffect();
unsigned int times = times_ ? *times_ : 100000;
DNSName suffix(suffix_ ? *suffix_ : "powerdns.com");
luaCtx.writeFunction("SuffixMatchNodeRule", qnameSuffixRule);
- luaCtx.writeFunction("NetmaskGroupRule", [](const boost::variant<const NetmaskGroup&, std::string, const LuaArray<std::string>> netmasks, boost::optional<bool> src, boost::optional<bool> quiet) {
+ luaCtx.writeFunction("NetmaskGroupRule", [](const boost::variant<const NetmaskGroup&, std::string, const LuaArray<std::string>> netmasks, std::optional<bool> src, std::optional<bool> quiet) {
if (netmasks.type() == typeid(string)) {
NetmaskGroup nmg;
nmg.addMask(*boost::get<std::string>(&netmasks));
return std::shared_ptr<DNSRule>(new QNameSetRule(names));
});
- // NOLINTNEXTLINE(performance-unnecessary-value-param): LuaWrapper does not play well with const boost::optional<T>&
- luaCtx.writeFunction("TagRule", [](const std::string& tag, boost::optional<std::string> value) {
- return std::shared_ptr<DNSRule>(dnsdist::selectors::getTagSelector(tag, boostToStandardOptional(value), !value));
+ // NOLINTNEXTLINE(performance-unnecessary-value-param): LuaWrapper does not play well with const std::optional<T>&
+ luaCtx.writeFunction("TagRule", [](const std::string& tag, std::optional<std::string> value) {
+ return std::shared_ptr<DNSRule>(dnsdist::selectors::getTagSelector(tag, value, !value));
});
#if defined(HAVE_LMDB) || defined(HAVE_CDB)
using localbind_t = LuaAssociativeTable<boost::variant<bool, int, std::string, LuaArray<int>, LuaArray<std::string>, LuaAssociativeTable<std::string>, std::shared_ptr<XskSocket>>>;
-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, bool& enableProxyProtocol)
+static void parseLocalBindVars(std::optional<localbind_t>& vars, bool& reusePort, int& tcpFastOpenQueueSize, std::string& interface, std::set<int>& cpus, int& tcpListenQueueSize, uint64_t& maxInFlightQueriesPerConnection, uint64_t& tcpMaxConcurrentConnections, bool& enableProxyProtocol)
{
if (vars) {
LuaArray<int> setCpus;
}
}
#ifdef HAVE_XSK
-static void parseXskVars(boost::optional<localbind_t>& vars, std::shared_ptr<XskSocket>& socket)
+static void parseXskVars(std::optional<localbind_t>& vars, std::shared_ptr<XskSocket>& socket)
{
if (!vars) {
return;
return true;
}
-static void parseTLSConfig(TLSConfig& config, const std::string& context, boost::optional<localbind_t>& vars)
+static void parseTLSConfig(TLSConfig& config, const std::string& context, std::optional<localbind_t>& vars)
{
getOptionalValue<std::string>(vars, "ciphers", config.d_ciphers);
getOptionalValue<std::string>(vars, "ciphersTLS13", config.d_ciphers13);
context.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, LuaAssociativeTable<std::string> data)>>>("threadmessage");
+ auto func = lua->readVariable<std::optional<std::function<void(std::string cmd, LuaAssociativeTable<std::string> data)>>>("threadmessage");
if (func) {
- func.get()(std::move(cmd), std::move(data));
+ (*func)(std::move(cmd), std::move(data));
}
else {
errlog("Lua thread called submitToMainThread but no threadmessage receiver is defined");
using newserver_t = LuaAssociativeTable<boost::variant<bool, std::string, LuaArray<std::string>, LuaArray<std::shared_ptr<XskSocket>>, DownstreamState::checkfunc_t>>;
-static void handleNewServerHealthCheckParameters(boost::optional<newserver_t>& vars, DownstreamState::Config& config)
+static void handleNewServerHealthCheckParameters(std::optional<newserver_t>& vars, DownstreamState::Config& config)
{
std::string valueStr;
getOptionalIntegerValue("newServer", vars, "rise", config.minRiseSuccesses);
}
-static void handleNewServerSourceParameter(boost::optional<newserver_t>& vars, DownstreamState::Config& config)
+static void handleNewServerSourceParameter(std::optional<newserver_t>& vars, DownstreamState::Config& config)
{
std::string source;
if (getOptionalValue<std::string>(vars, "source", source) <= 0) {
dnsdist::lua::setupConfigurationItems(luaCtx);
luaCtx.writeFunction("newServer",
- [client, configCheck](boost::variant<string, newserver_t> pvars, boost::optional<int> qps) {
+ [client, configCheck](boost::variant<string, newserver_t> pvars, std::optional<int> qps) {
setLuaSideEffect();
- boost::optional<newserver_t> vars = newserver_t();
+ std::optional<newserver_t> vars = newserver_t();
DownstreamState::Config config;
std::string serverAddressStr;
});
});
- luaCtx.writeFunction("setLocal", [client](const std::string& addr, boost::optional<localbind_t> vars) {
+ luaCtx.writeFunction("setLocal", [client](const std::string& addr, std::optional<localbind_t> vars) {
setLuaSideEffect();
if (client) {
return;
}
});
- luaCtx.writeFunction("addLocal", [client](const std::string& addr, boost::optional<localbind_t> vars) {
+ luaCtx.writeFunction("addLocal", [client](const std::string& addr, std::optional<localbind_t> vars) {
setLuaSideEffect();
if (client) {
return;
typedef LuaAssociativeTable<boost::variant<bool, std::string>> showserversopts_t;
- luaCtx.writeFunction("showServers", [](boost::optional<showserversopts_t> vars) {
+ luaCtx.writeFunction("showServers", [](std::optional<showserversopts_t> vars) {
setLuaNoSideEffect();
bool showUUIDs = false;
getOptionalValue<bool>(vars, "showUUIDs", showUUIDs);
return getDownstreamCandidates(pool);
});
- luaCtx.writeFunction("getServer", [client](boost::variant<unsigned int, std::string> identifier) -> boost::optional<std::shared_ptr<DownstreamState>> {
+ luaCtx.writeFunction("getServer", [client](boost::variant<unsigned int, std::string> identifier) -> std::optional<std::shared_ptr<DownstreamState>> {
if (client) {
return std::make_shared<DownstreamState>(ComboAddress());
}
return states.at(*pos);
}
g_outputBuffer = "Error: trying to retrieve server " + std::to_string(*pos) + " while there is only " + std::to_string(states.size()) + "servers\n";
- return boost::none;
+ return std::nullopt;
}
g_outputBuffer = "Error: no server matched\n";
- return boost::none;
+ return std::nullopt;
});
#ifndef DISABLE_CARBON
- luaCtx.writeFunction("carbonServer", [](const std::string& address, boost::optional<string> ourName, boost::optional<uint64_t> interval, boost::optional<string> namespace_name, boost::optional<string> instance_name) {
+ luaCtx.writeFunction("carbonServer", [](const std::string& address, std::optional<string> ourName, std::optional<uint64_t> interval, std::optional<string> namespace_name, std::optional<string> instance_name) {
setLuaSideEffect();
auto newEndpoint = dnsdist::Carbon::newEndpoint(address,
(ourName ? *ourName : ""),
using webserveropts_t = LuaAssociativeTable<boost::variant<bool, std::string, LuaAssociativeTable<std::string>>>;
- luaCtx.writeFunction("setWebserverConfig", [](boost::optional<webserveropts_t> vars) {
+ luaCtx.writeFunction("setWebserverConfig", [](std::optional<webserveropts_t> vars) {
setLuaSideEffect();
if (!vars) {
return dnsdist::webserver::getConfig();
});
- luaCtx.writeFunction("hashPassword", [](const std::string& password, boost::optional<uint64_t> workFactor) {
+ luaCtx.writeFunction("hashPassword", [](const std::string& password, std::optional<uint64_t> workFactor) {
if (workFactor) {
return hashPassword(password, *workFactor, CredentialsHolder::s_defaultParallelFactor, CredentialsHolder::s_defaultBlockSize);
}
g_outputBuffer = (fmt % size).str();
});
- luaCtx.writeFunction("getQueryCounters", [](boost::optional<uint64_t> optMax) {
+ luaCtx.writeFunction("getQueryCounters", [](std::optional<uint64_t> optMax) {
setLuaNoSideEffect();
auto records = dnsdist::QueryCount::g_queryCountRecords.read_lock();
g_outputBuffer = "query counting is currently: ";
dnsdist::console::clearHistory();
});
- luaCtx.writeFunction("testCrypto", []([[maybe_unused]] boost::optional<string> optTestMsg) {
+ luaCtx.writeFunction("testCrypto", []([[maybe_unused]] std::optional<string> optTestMsg) {
setLuaNoSideEffect();
#if defined(HAVE_LIBSODIUM) || defined(HAVE_LIBCRYPTO)
try {
#ifndef DISABLE_DEPRECATED_DYNBLOCK
luaCtx.writeFunction("addDynBlocks",
- [](const std::unordered_map<ComboAddress, unsigned int, ComboAddress::addressOnlyHash, ComboAddress::addressOnlyEqual>& addrs, const std::string& msg, boost::optional<int> seconds, boost::optional<DNSAction::Action> action) {
+ [](const std::unordered_map<ComboAddress, unsigned int, ComboAddress::addressOnlyHash, ComboAddress::addressOnlyEqual>& addrs, const std::string& msg, std::optional<int> seconds, std::optional<DNSAction::Action> action) {
if (addrs.empty()) {
return;
}
#endif /* DISABLE_DYNBLOCKS */
#ifdef HAVE_DNSCRYPT
- luaCtx.writeFunction("addDNSCryptBind", [](const std::string& addr, const std::string& providerName, LuaTypeOrArrayOf<std::string> certFiles, LuaTypeOrArrayOf<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, std::optional<localbind_t> vars) {
if (!checkConfigurationTime("addDNSCryptBind")) {
return;
}
luaCtx.writeFunction("getDNSCryptBind", [](uint64_t idx) {
setLuaNoSideEffect();
- boost::optional<std::shared_ptr<DNSCryptContext>> ret{boost::none};
+ std::optional<std::shared_ptr<DNSCryptContext>> ret{std::nullopt};
/* we are only interested in distinct DNSCrypt binds,
and we have two frontends (UDP and TCP) per bind
sharing the same context so we need to retrieve
errlog("Error while opening the verbose logging destination file %s: %s", dest, e.what());
}
});
- luaCtx.writeFunction("setStructuredLogging", [](bool enable, boost::optional<LuaAssociativeTable<std::string>> options) {
+ luaCtx.writeFunction("setStructuredLogging", [](bool enable, std::optional<LuaAssociativeTable<std::string>> options) {
std::string levelPrefix;
std::string timeFormat;
if (options) {
luaCtx.writeFunction("getBind", [](uint64_t num) {
setLuaNoSideEffect();
- boost::optional<ClientState*> ret{boost::none};
+ std::optional<ClientState*> ret{std::nullopt};
auto frontends = dnsdist::getFrontends();
if (num < frontends.size()) {
ret = frontends[num].get();
return dnsdist::getFrontends().size();
});
- luaCtx.writeFunction("help", [](boost::optional<std::string> command) {
+ luaCtx.writeFunction("help", [](std::optional<std::string> command) {
setLuaNoSideEffect();
g_outputBuffer = "";
#ifndef DISABLE_COMPLETION
#ifndef DISABLE_DYNBLOCKS
#ifndef DISABLE_DEPRECATED_DYNBLOCK
- luaCtx.writeFunction("addBPFFilterDynBlocks", [](const std::unordered_map<ComboAddress, unsigned int, ComboAddress::addressOnlyHash, ComboAddress::addressOnlyEqual>& addrs, const std::shared_ptr<DynBPFFilter>& dynbpf, boost::optional<int> seconds, boost::optional<std::string> msg) {
+ luaCtx.writeFunction("addBPFFilterDynBlocks", [](const std::unordered_map<ComboAddress, unsigned int, ComboAddress::addressOnlyHash, ComboAddress::addressOnlyEqual>& addrs, const std::shared_ptr<DynBPFFilter>& dynbpf, std::optional<int> seconds, std::optional<std::string> msg) {
if (!dynbpf) {
return;
}
s_included = false;
});
- luaCtx.writeFunction("setAPIWritable", [](bool writable, boost::optional<std::string> apiConfigDir) {
+ luaCtx.writeFunction("setAPIWritable", [](bool writable, std::optional<std::string> apiConfigDir) {
if (apiConfigDir && apiConfigDir->empty()) {
errlog("The API configuration directory value cannot be empty!");
g_outputBuffer = "The API configuration directory value cannot be empty!";
setLuaSideEffect();
});
- luaCtx.writeFunction("setRingBuffersSize", [client](uint64_t capacity, boost::optional<uint64_t> numberOfShards) {
+ luaCtx.writeFunction("setRingBuffersSize", [client](uint64_t capacity, std::optional<uint64_t> numberOfShards) {
if (client) {
return;
}
});
#ifdef HAVE_NET_SNMP
- luaCtx.writeFunction("snmpAgent", [client, configCheck](bool enableTraps, boost::optional<std::string> daemonSocket) {
+ luaCtx.writeFunction("snmpAgent", [client, configCheck](bool enableTraps, std::optional<std::string> daemonSocket) {
if (client || configCheck) {
return;
}
});
typedef std::unordered_map<std::string, std::string> tlscertificateopts_t;
- luaCtx.writeFunction("newTLSCertificate", [client]([[maybe_unused]] const std::string& cert, [[maybe_unused]] boost::optional<tlscertificateopts_t> opts) {
+ luaCtx.writeFunction("newTLSCertificate", [client]([[maybe_unused]] const std::string& cert, [[maybe_unused]] std::optional<tlscertificateopts_t> opts) {
std::shared_ptr<TLSCertKeyPair> result = nullptr;
if (client) {
return result;
return result;
});
- luaCtx.writeFunction("addDOHLocal", [client]([[maybe_unused]] const std::string& addr, [[maybe_unused]] boost::optional<boost::variant<std::string, std::shared_ptr<TLSCertKeyPair>, LuaArray<std::string>, LuaArray<std::shared_ptr<TLSCertKeyPair>>>> certFiles, [[maybe_unused]] boost::optional<LuaTypeOrArrayOf<std::string>> keyFiles, [[maybe_unused]] boost::optional<LuaTypeOrArrayOf<std::string>> urls, [[maybe_unused]] boost::optional<localbind_t> vars) {
+ luaCtx.writeFunction("addDOHLocal", [client]([[maybe_unused]] const std::string& addr, [[maybe_unused]] std::optional<boost::variant<std::string, std::shared_ptr<TLSCertKeyPair>, LuaArray<std::string>, LuaArray<std::shared_ptr<TLSCertKeyPair>>>> certFiles, [[maybe_unused]] std::optional<LuaTypeOrArrayOf<std::string>> keyFiles, [[maybe_unused]] std::optional<LuaTypeOrArrayOf<std::string>> urls, [[maybe_unused]] std::optional<localbind_t> vars) {
if (client) {
return;
}
});
// NOLINTNEXTLINE(performance-unnecessary-value-param): somehow clang-tidy gets confused about the fact vars could be const while it cannot
- luaCtx.writeFunction("addDOH3Local", [client]([[maybe_unused]] const std::string& addr, [[maybe_unused]] const boost::variant<std::string, std::shared_ptr<TLSCertKeyPair>, LuaArray<std::string>, LuaArray<std::shared_ptr<TLSCertKeyPair>>>& certFiles, [[maybe_unused]] const LuaTypeOrArrayOf<std::string>& keyFiles, [[maybe_unused]] boost::optional<localbind_t> vars) {
+ luaCtx.writeFunction("addDOH3Local", [client]([[maybe_unused]] const std::string& addr, [[maybe_unused]] const boost::variant<std::string, std::shared_ptr<TLSCertKeyPair>, LuaArray<std::string>, LuaArray<std::shared_ptr<TLSCertKeyPair>>>& certFiles, [[maybe_unused]] const LuaTypeOrArrayOf<std::string>& keyFiles, [[maybe_unused]] std::optional<localbind_t> vars) {
if (client) {
return;
}
});
// NOLINTNEXTLINE(performance-unnecessary-value-param): somehow clang-tidy gets confused about the fact vars could be const while it cannot
- luaCtx.writeFunction("addDOQLocal", [client]([[maybe_unused]] const std::string& addr, [[maybe_unused]] const boost::variant<std::string, std::shared_ptr<TLSCertKeyPair>, LuaArray<std::string>, LuaArray<std::shared_ptr<TLSCertKeyPair>>>& certFiles, [[maybe_unused]] const LuaTypeOrArrayOf<std::string>& keyFiles, [[maybe_unused]] boost::optional<localbind_t> vars) {
+ luaCtx.writeFunction("addDOQLocal", [client]([[maybe_unused]] const std::string& addr, [[maybe_unused]] const boost::variant<std::string, std::shared_ptr<TLSCertKeyPair>, LuaArray<std::string>, LuaArray<std::shared_ptr<TLSCertKeyPair>>>& certFiles, [[maybe_unused]] const LuaTypeOrArrayOf<std::string>& keyFiles, [[maybe_unused]] std::optional<localbind_t> vars) {
if (client) {
return;
}
});
#ifdef HAVE_DNS_OVER_QUIC
- luaCtx.writeFunction("getDOQFrontend", [client](uint64_t index) -> boost::optional<std::shared_ptr<DOQFrontend>> {
- boost::optional<std::shared_ptr<DOQFrontend>> result{boost::none};
+ luaCtx.writeFunction("getDOQFrontend", [client](uint64_t index) -> std::optional<std::shared_ptr<DOQFrontend>> {
+ std::optional<std::shared_ptr<DOQFrontend>> result{std::nullopt};
if (client) {
return std::shared_ptr<DOQFrontend>();
}
});
#ifdef HAVE_DNS_OVER_HTTP3
- luaCtx.writeFunction("getDOH3Frontend", [client](uint64_t index) -> boost::optional<std::shared_ptr<DOH3Frontend>> {
- boost::optional<std::shared_ptr<DOH3Frontend>> result{boost::none};
+ luaCtx.writeFunction("getDOH3Frontend", [client](uint64_t index) -> std::optional<std::shared_ptr<DOH3Frontend>> {
+ std::optional<std::shared_ptr<DOH3Frontend>> result{std::nullopt};
if (client) {
return std::shared_ptr<DOH3Frontend>();
}
#endif
});
- luaCtx.writeFunction("getDOHFrontend", [client]([[maybe_unused]] uint64_t index) -> boost::optional<std::shared_ptr<DOHFrontend>> {
- boost::optional<std::shared_ptr<DOHFrontend>> result{boost::none};
+ luaCtx.writeFunction("getDOHFrontend", [client]([[maybe_unused]] uint64_t index) -> std::optional<std::shared_ptr<DOHFrontend>> {
+ std::optional<std::shared_ptr<DOHFrontend>> result{std::nullopt};
if (client) {
return std::shared_ptr<DOHFrontend>();
}
}
});
- luaCtx.writeFunction("addTLSLocal", [client]([[maybe_unused]] const std::string& addr, [[maybe_unused]] const boost::variant<std::string, std::shared_ptr<TLSCertKeyPair>, LuaArray<std::string>, LuaArray<std::shared_ptr<TLSCertKeyPair>>>& certFiles, [[maybe_unused]] const LuaTypeOrArrayOf<std::string>& keyFiles, [[maybe_unused]] boost::optional<localbind_t> vars) {
+ luaCtx.writeFunction("addTLSLocal", [client]([[maybe_unused]] const std::string& addr, [[maybe_unused]] const boost::variant<std::string, std::shared_ptr<TLSCertKeyPair>, LuaArray<std::string>, LuaArray<std::shared_ptr<TLSCertKeyPair>>>& certFiles, [[maybe_unused]] const LuaTypeOrArrayOf<std::string>& keyFiles, [[maybe_unused]] std::optional<localbind_t> vars) {
if (client) {
return;
}
#endif
});
- luaCtx.writeFunction("getTLSFrontend", [client]([[maybe_unused]] uint64_t index) -> boost::optional<std::shared_ptr<TLSFrontend>> {
- boost::optional<std::shared_ptr<TLSFrontend>> result{boost::none};
+ luaCtx.writeFunction("getTLSFrontend", [client]([[maybe_unused]] uint64_t index) -> std::optional<std::shared_ptr<TLSFrontend>> {
+ std::optional<std::shared_ptr<TLSFrontend>> result{std::nullopt};
if (client) {
return std::shared_ptr<TLSFrontend>();
}
});
#if defined(HAVE_LIBSSL) && !defined(HAVE_TLS_PROVIDERS)
- luaCtx.writeFunction("loadTLSEngine", [client](const std::string& engineName, boost::optional<std::string> defaultString) {
+ luaCtx.writeFunction("loadTLSEngine", [client](const std::string& engineName, std::optional<std::string> defaultString) {
if (client) {
return;
}
newThread.detach();
});
- luaCtx.writeFunction("declareMetric", [](const std::string& name, const std::string& type, const std::string& description, boost::optional<boost::variant<std::string, declare_metric_opts_t>> opts) {
+ luaCtx.writeFunction("declareMetric", [](const std::string& name, const std::string& type, const std::string& description, std::optional<boost::variant<std::string, declare_metric_opts_t>> opts) {
bool withLabels = false;
std::optional<std::string> customName = std::nullopt;
if (opts) {
- auto* optCustomName = boost::get<std::string>(&opts.get());
+ auto* optCustomName = boost::get<std::string>(&opts.value());
if (optCustomName != nullptr) {
customName = std::optional(*optCustomName);
}
if (!customName) {
- boost::optional<declare_metric_opts_t> vars = {boost::get<declare_metric_opts_t>(opts.get())};
+ std::optional<declare_metric_opts_t> vars = {boost::get<declare_metric_opts_t>(opts.value())};
getOptionalValue<std::string>(vars, "customName", customName);
getOptionalValue<bool>(vars, "withLabels", withLabels);
checkAllParametersConsumed("declareMetric", vars);
return true;
});
// NOLINTNEXTLINE(performance-unnecessary-value-param)
- luaCtx.writeFunction("incMetric", [](const std::string& name, boost::optional<boost::variant<uint64_t, update_metric_opts_t>> opts) {
- auto incOpts = opts.get_value_or(1);
+ luaCtx.writeFunction("incMetric", [](const std::string& name, std::optional<boost::variant<uint64_t, update_metric_opts_t>> opts) {
+ auto incOpts = opts.value_or(1);
uint64_t step = 1;
std::unordered_map<std::string, std::string> labels;
if (auto* custom_step = boost::get<uint64_t>(&incOpts)) {
step = *custom_step;
}
else {
- boost::optional<update_metric_opts_t> vars = {boost::get<update_metric_opts_t>(incOpts)};
+ std::optional<update_metric_opts_t> vars = {boost::get<update_metric_opts_t>(incOpts)};
getOptionalValue<uint64_t>(vars, "step", step);
getOptionalValue<LuaAssociativeTable<std::string>>(vars, "labels", labels);
checkAllParametersConsumed("incMetric", vars);
return std::get<uint64_t>(result);
});
// NOLINTNEXTLINE(performance-unnecessary-value-param)
- luaCtx.writeFunction("decMetric", [](const std::string& name, boost::optional<boost::variant<uint64_t, update_metric_opts_t>> opts) {
- auto decOpts = opts.get_value_or(1);
+ luaCtx.writeFunction("decMetric", [](const std::string& name, std::optional<boost::variant<uint64_t, update_metric_opts_t>> opts) {
+ auto decOpts = opts.value_or(1);
uint64_t step = 1;
std::unordered_map<std::string, std::string> labels;
if (auto* custom_step = boost::get<uint64_t>(&decOpts)) {
step = *custom_step;
}
else {
- boost::optional<update_metric_opts_t> vars = {boost::get<update_metric_opts_t>(decOpts)};
+ std::optional<update_metric_opts_t> vars = {boost::get<update_metric_opts_t>(decOpts)};
getOptionalValue<uint64_t>(vars, "step", step);
getOptionalValue<LuaAssociativeTable<std::string>>(vars, "labels", labels);
checkAllParametersConsumed("decMetric", vars);
}
return std::get<uint64_t>(result);
});
- luaCtx.writeFunction("setMetric", [](const std::string& name, const double value, boost::optional<update_metric_opts_t> opts) -> double {
+ luaCtx.writeFunction("setMetric", [](const std::string& name, const double value, std::optional<update_metric_opts_t> opts) -> double {
std::unordered_map<std::string, std::string> labels;
if (opts) {
getOptionalValue<LuaAssociativeTable<std::string>>(opts, "labels", labels);
}
return std::get<double>(result);
});
- luaCtx.writeFunction("getMetric", [](const std::string& name, boost::optional<update_metric_opts_t> opts) {
+ luaCtx.writeFunction("getMetric", [](const std::string& name, std::optional<update_metric_opts_t> opts) {
std::unordered_map<std::string, std::string> labels;
if (opts) {
getOptionalValue<LuaAssociativeTable<std::string>>(opts, "labels", labels);
using luadnsrule_t = boost::variant<string, LuaArray<std::string>, std::shared_ptr<DNSRule>, DNSName, LuaArray<DNSName>>;
std::shared_ptr<DNSRule> makeRule(const luadnsrule_t& var, const std::string& calledFrom);
-void parseRuleParams(boost::optional<luaruleparams_t>& params, boost::uuids::uuid& uuid, std::string& name, uint64_t& creationOrder);
+void parseRuleParams(std::optional<luaruleparams_t>& params, boost::uuids::uuid& uuid, std::string& name, uint64_t& creationOrder);
void checkParameterBound(const std::string& parameter, uint64_t value, uint64_t max = std::numeric_limits<uint16_t>::max());
void setupLua(LuaContext& luaCtx, bool client, bool configCheck, const std::string& config);
* returns: -1 if type wasn't compatible, 0 if not found or number of element(s) found
*/
template <class G, class T, class V>
-static inline int getOptionalValue(boost::optional<V>& vars, const std::string& key, T& value, bool warnOnWrongType = true)
+static inline int getOptionalValue(std::optional<V>& vars, const std::string& key, T& value, bool warnOnWrongType = true)
{
/* nothing found, nothing to return */
if (!vars) {
}
template <class T, class V>
-static inline int getOptionalIntegerValue(const std::string& func, boost::optional<V>& vars, const std::string& key, T& value)
+static inline int getOptionalIntegerValue(const std::string& func, std::optional<V>& vars, const std::string& key, T& value)
{
std::string valueStr;
auto ret = getOptionalValue<std::string>(vars, key, valueStr, true);
}
template <class V>
-static inline void checkAllParametersConsumed(const std::string& func, const boost::optional<V>& vars)
+static inline void checkAllParametersConsumed(const std::string& func, const std::optional<V>& vars)
{
/* no vars */
if (!vars) {
return d_currentStreams.size() + d_killedStreams.size();
}
-boost::optional<struct timeval> IncomingHTTP2Connection::getIdleClientReadTTD(struct timeval now) const
+std::optional<struct timeval> IncomingHTTP2Connection::getIdleClientReadTTD(struct timeval now) const
{
const auto& currentConfig = dnsdist::configuration::getCurrentRuntimeConfiguration();
auto idleTimeout = d_ci.cs->dohFrontend->d_idleTimeout;
if (currentConfig.d_maxTCPConnectionDuration == 0 && idleTimeout == 0) {
- return boost::none;
+ return std::nullopt;
}
if (currentConfig.d_maxTCPConnectionDuration > 0) {
void IncomingHTTP2Connection::updateIO(IOState newState, const FDMultiplexer::callbackfunc_t& callback)
{
- boost::optional<struct timeval> ttd{boost::none};
+ std::optional<struct timeval> ttd{std::nullopt};
if (newState == IOState::Async) {
auto shared = shared_from_this();
IOState handleHandshake(const struct timeval& now) override;
bool hasPendingWrite() const;
void writeToSocket(bool socketReady);
- boost::optional<struct timeval> getIdleClientReadTTD(struct timeval now) const;
+ std::optional<struct timeval> getIdleClientReadTTD(struct timeval now) const;
std::unique_ptr<nghttp2_session, decltype(&nghttp2_session_del)> d_session{nullptr, nghttp2_session_del};
std::unordered_map<StreamID, PendingQuery> d_currentStreams;
.tv_sec = 0, .tv_usec = 0};
gettimeofday(&now, nullptr);
- boost::optional<struct timeval> ttd{boost::none};
+ std::optional<struct timeval> ttd{std::nullopt};
if (!noTTD) {
if (d_healthCheckQuery) {
ttd = getBackendHealthCheckTTD(now);
const DNSResponse* d_dr{nullptr};
const std::string* d_ServerIdentityRef{nullptr};
- boost::optional<PBQuestion> d_question{boost::none};
- boost::optional<std::string> d_serverIdentity{boost::none};
- boost::optional<ComboAddress> d_requestor{boost::none};
- boost::optional<ComboAddress> d_responder{boost::none};
- boost::optional<Netmask> d_ednsSubnet{boost::none};
- boost::optional<std::pair<time_t, uint32_t>> d_time{boost::none};
- boost::optional<std::pair<time_t, uint32_t>> d_queryTime{boost::none};
- boost::optional<size_t> d_bytes{boost::none};
- boost::optional<uint8_t> d_rcode{boost::none};
+ std::optional<PBQuestion> d_question{std::nullopt};
+ std::optional<std::string> d_serverIdentity{std::nullopt};
+ std::optional<ComboAddress> d_requestor{std::nullopt};
+ std::optional<ComboAddress> d_responder{std::nullopt};
+ std::optional<Netmask> d_ednsSubnet{std::nullopt};
+ std::optional<std::pair<time_t, uint32_t>> d_time{std::nullopt};
+ std::optional<std::pair<time_t, uint32_t>> d_queryTime{std::nullopt};
+ std::optional<size_t> d_bytes{std::nullopt};
+ std::optional<uint8_t> d_rcode{std::nullopt};
pdns::ProtoZero::Message::MessageType d_type{pdns::ProtoZero::Message::MessageType::DNSQueryType};
bool d_includeCNAME{false};
class TagRule : public DNSRule
{
public:
- TagRule(const std::string& tag, boost::optional<std::string> value, bool emptyAsWildcard) :
+ TagRule(const std::string& tag, std::optional<std::string> value, bool emptyAsWildcard) :
d_value(std::move(value)), d_tag(tag), d_emptyAsWildcard(emptyAsWildcard)
{
}
}
private:
- boost::optional<std::string> d_value;
+ std::optional<std::string> d_value;
std::string d_tag;
bool d_emptyAsWildcard;
};
class ProxyProtocolValueRule : public DNSRule
{
public:
- ProxyProtocolValueRule(uint8_t type, boost::optional<std::string> value) :
+ ProxyProtocolValueRule(uint8_t type, std::optional<std::string> value) :
d_value(std::move(value)), d_type(type)
{
}
}
private:
- boost::optional<std::string> d_value;
+ std::optional<std::string> d_value;
uint8_t d_type;
};
conn->d_ioState->update(iostate, handleIOCallback, conn);
}
else {
- boost::optional<struct timeval> ttd{boost::none};
+ std::optional<struct timeval> ttd{std::nullopt};
if (iostate == IOState::NeedRead) {
ttd = conn->getBackendReadTTD(now);
}
protected:
bool reconnect();
- boost::optional<struct timeval> getBackendHealthCheckTTD(const struct timeval& now) const
+ std::optional<struct timeval> getBackendHealthCheckTTD(const struct timeval& now) const
{
if (d_ds == nullptr) {
throw std::runtime_error("getBackendReadTTD() without any backend selected");
}
if (d_ds->d_config.checkTimeout == 0) {
- return boost::none;
+ return std::nullopt;
}
struct timeval res = now;
return res;
}
- boost::optional<struct timeval> getBackendReadTTD(const struct timeval& now) const
+ std::optional<struct timeval> getBackendReadTTD(const struct timeval& now) const
{
if (d_ds == nullptr) {
throw std::runtime_error("getBackendReadTTD() without any backend selected");
}
if (d_ds->d_config.tcpRecvTimeout == 0) {
- return boost::none;
+ return std::nullopt;
}
struct timeval res = now;
return res;
}
- boost::optional<struct timeval> getBackendWriteTTD(const struct timeval& now) const
+ std::optional<struct timeval> getBackendWriteTTD(const struct timeval& now) const
{
if (d_ds == nullptr) {
throw std::runtime_error("getBackendWriteTTD() called without any backend selected");
}
if (d_ds->d_config.tcpSendTimeout == 0) {
- return boost::none;
+ return std::nullopt;
}
struct timeval res = now;
return res;
}
- boost::optional<struct timeval> getBackendConnectTTD(const struct timeval& now) const
+ std::optional<struct timeval> getBackendConnectTTD(const struct timeval& now) const
{
if (d_ds == nullptr) {
throw std::runtime_error("getBackendConnectTTD() called without any backend selected");
}
if (d_ds->d_config.tcpConnectTimeout == 0) {
- return boost::none;
+ return std::nullopt;
}
struct timeval res = now;
void resetForNewQuery();
- boost::optional<timeval> getClientReadTTD(timeval now) const;
- boost::optional<timeval> getClientWriteTTD(const timeval& now) const;
+ std::optional<timeval> getClientReadTTD(timeval now) const;
+ std::optional<timeval> getClientWriteTTD(const timeval& now) const;
bool maxConnectionDurationReached(unsigned int maxConnectionDuration, const timeval& now) const;
std::shared_ptr<TCPConnectionToBackend> getDownstreamConnection(std::shared_ptr<DownstreamState>& backend, const std::unique_ptr<std::vector<ProxyProtocolValue>>& tlvs, const struct timeval& now);
d_readIOsCurrentQuery = 0;
}
-boost::optional<timeval> IncomingTCPConnectionState::getClientReadTTD(timeval now) const
+std::optional<timeval> IncomingTCPConnectionState::getClientReadTTD(timeval now) const
{
const auto& runtimeConfiguration = dnsdist::configuration::getCurrentRuntimeConfiguration();
if (!isNearTCPLimits() && runtimeConfiguration.d_maxTCPConnectionDuration == 0 && runtimeConfiguration.d_tcpRecvTimeout == 0) {
- return boost::none;
+ return std::nullopt;
}
size_t maxTCPConnectionDuration = runtimeConfiguration.d_maxTCPConnectionDuration;
return now;
}
-boost::optional<timeval> IncomingTCPConnectionState::getClientWriteTTD(const timeval& now) const
+std::optional<timeval> IncomingTCPConnectionState::getClientWriteTTD(const timeval& now) const
{
const auto& runtimeConfiguration = dnsdist::configuration::getCurrentRuntimeConfiguration();
if (runtimeConfiguration.d_maxTCPConnectionDuration == 0 && runtimeConfiguration.d_tcpSendTimeout == 0) {
- return boost::none;
+ return std::nullopt;
}
timeval res(now);
}
{
auto cacheInsertCloser = dnsResponse.ids.getCloser("packetCacheInsert", __func__); // NOLINT(cppcoreguidelines-pro-bounds-array-to-pointer-decay)
- dnsResponse.ids.packetCache->insert(cacheKey, zeroScope ? boost::none : dnsResponse.ids.subnet, dnsResponse.ids.cacheFlags, dnsResponse.ids.dnssecOK ? *dnsResponse.ids.dnssecOK : false, dnsResponse.ids.qname, dnsResponse.ids.qtype, dnsResponse.ids.qclass, response, dnsResponse.ids.forwardedOverUDP, dnsResponse.getHeader()->rcode, dnsResponse.ids.tempFailureTTL);
+ dnsResponse.ids.packetCache->insert(cacheKey, zeroScope ? std::nullopt : dnsResponse.ids.subnet, dnsResponse.ids.cacheFlags, dnsResponse.ids.dnssecOK ? *dnsResponse.ids.dnssecOK : false, dnsResponse.ids.qname, dnsResponse.ids.qtype, dnsResponse.ids.qclass, response, dnsResponse.ids.forwardedOverUDP, dnsResponse.getHeader()->rcode, dnsResponse.ids.tempFailureTTL);
}
const auto& chains = dnsdist::configuration::getCurrentRuntimeConfiguration().d_ruleChains;
const auto& cacheInsertedRespRuleActions = dnsdist::rules::getResponseRuleChain(chains, dnsdist::rules::ResponseRuleChain::CacheInsertedResponseRules);
{
auto lua = g_lua.lock();
try {
- auto maintenanceCallback = lua->readVariable<boost::optional<std::function<void()>>>("maintenance");
+ auto maintenanceCallback = lua->readVariable<std::optional<std::function<void()>>>("maintenance");
if (maintenanceCallback) {
(*maintenanceCallback)();
}
const DNSName qname(reinterpret_cast<const char*>(data), size, sizeof(dnsheader), false, &qtype, &qclass, &consumed);
pcSkipCookies.getKey(qname.getStorage(), consumed, vect, false);
pcHashCookies.getKey(qname.getStorage(), consumed, vect, false);
- boost::optional<Netmask> subnet;
+ std::optional<Netmask> subnet;
DNSDistPacketCache::getClientSubnet(vect, consumed, subnet);
}
catch (const std::exception& e) {
return result;
}
- void add(IOState iostate, FDMultiplexer::callbackfunc_t callback, FDMultiplexer::funcparam_t callbackData, boost::optional<struct timeval> ttd)
+ void add(IOState iostate, FDMultiplexer::callbackfunc_t callback, FDMultiplexer::funcparam_t callbackData, std::optional<struct timeval> ttd)
{
DEBUGLOG("in "<<__PRETTY_FUNCTION__<<" for fd "<<d_fd<<", last state was "<<getState()<<", adding "<<(int)iostate);
if (iostate == IOState::NeedRead) {
}
}
- void update(IOState iostate, FDMultiplexer::callbackfunc_t callback = FDMultiplexer::callbackfunc_t(), FDMultiplexer::funcparam_t callbackData = boost::any(), boost::optional<struct timeval> ttd = boost::none)
+ void update(IOState iostate, FDMultiplexer::callbackfunc_t callback = FDMultiplexer::callbackfunc_t(), FDMultiplexer::funcparam_t callbackData = boost::any(), std::optional<struct timeval> ttd = std::nullopt)
{
DEBUGLOG("in "<<__PRETTY_FUNCTION__<<" for fd "<<d_fd<<", last state was "<<getState()<<" , new state is "<<(int)iostate);
if (isWaitingForRead() && iostate == IOState::Done) {
bool dnssecOK = true;
bool receivedOverUDP = true;
uint32_t key = 0;
- boost::optional<Netmask> subnet;
+ std::optional<Netmask> subnet;
ids.queryRealTime.start();
DNSQuestion dq(ids, query);
packetCache->get(dq, 0, &key, subnet, dnssecOK, receivedOverUDP);
- packetCache->insert(key, subnet, *(getFlagsFromDNSHeader(dq.getHeader().get())), dnssecOK, ids.qname, QType::A, QClass::IN, response, receivedOverUDP, 0, boost::none);
+ packetCache->insert(key, subnet, *(getFlagsFromDNSHeader(dq.getHeader().get())), dnssecOK, ids.qname, QType::A, QClass::IN, response, receivedOverUDP, 0, std::nullopt);
std::string poolName("test-pool");
auto testPool = ServerPool();
#ifndef DISABLE_PROTOBUF
#ifndef BOOST_TEST_DYN_LINK
#define BOOST_TEST_DYN_LINK
-#include <boost/optional/optional.hpp>
#endif
#include <boost/test/unit_test.hpp>
(void)node;
(void)children;
if (self.queries > 0) {
- return std::tuple<bool, boost::optional<std::string>, boost::optional<int>>(true, boost::none, boost::none);
+ return std::tuple<bool, std::optional<std::string>, std::optional<int>>(true, std::nullopt, std::nullopt);
}
- return std::tuple<bool, boost::optional<std::string>, boost::optional<int>>(false, boost::none, boost::none);
+ return std::tuple<bool, std::optional<std::string>, std::optional<int>>(false, std::nullopt, std::nullopt);
});
}
(void)node;
(void)children;
if (self.queries > 0) {
- return std::tuple<bool, boost::optional<std::string>, boost::optional<int>>(true, "blocked for a different reason", static_cast<int>(DNSAction::Action::Truncate));
+ return std::tuple<bool, std::optional<std::string>, std::optional<int>>(true, "blocked for a different reason", static_cast<int>(DNSAction::Action::Truncate));
}
- return std::tuple<bool, boost::optional<std::string>, boost::optional<int>>(false, boost::none, boost::none);
+ return std::tuple<bool, std::optional<std::string>, std::optional<int>>(false, std::nullopt, std::nullopt);
});
}
DynBlockRulesGroup::DynBlockRule rule(reason, blockDuration, 0, 0, numberOfSeconds, action);
dbrg.setSuffixMatchRule(std::move(rule), [](const StatNode& node, const StatNode::Stat& self, const StatNode::Stat& children) {
if (self.queries > 0) {
- return std::tuple<bool, boost::optional<std::string>, boost::optional<int>>(true, boost::none, boost::none);
+ return std::tuple<bool, std::optional<std::string>, std::optional<int>>(true, std::nullopt, std::nullopt);
}
- return std::tuple<bool, boost::optional<std::string>, boost::optional<int>>(false, boost::none, boost::none);
+ return std::tuple<bool, std::optional<std::string>, std::optional<int>>(false, std::nullopt, std::nullopt);
});
}
#ifndef BOOST_TEST_DYN_LINK
#define BOOST_TEST_DYN_LINK
+#include <optional>
#endif
#define BOOST_TEST_NO_MAIN
pwR.commit();
uint32_t key = 0;
- boost::optional<Netmask> subnet;
+ std::optional<Netmask> subnet;
DNSQuestion dnsQuestion(ids, query);
bool found = localCache.get(dnsQuestion, 0, &key, subnet, dnssecOK, receivedOverUDP);
BOOST_CHECK_EQUAL(found, false);
BOOST_CHECK(!subnet);
- localCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, QType::A, QClass::IN, response, receivedOverUDP, 0, boost::none);
+ localCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, QType::A, QClass::IN, response, receivedOverUDP, 0, std::nullopt);
found = localCache.get(dnsQuestion, pwR.getHeader()->id, &key, subnet, dnssecOK, receivedOverUDP, 0, true);
if (found) {
GenericDNSPacketWriter<PacketBuffer> pwQ(query, ids.qname, QType::A, QClass::IN, 0);
pwQ.getHeader()->rd = 1;
uint32_t key = 0;
- boost::optional<Netmask> subnet;
+ std::optional<Netmask> subnet;
DNSQuestion dnsQuestion(ids, query);
bool found = localCache.get(dnsQuestion, 0, &key, subnet, dnssecOK, receivedOverUDP);
if (found) {
GenericDNSPacketWriter<PacketBuffer> pwQ(query, ids.qname, QType::A, QClass::IN, 0);
pwQ.getHeader()->rd = 1;
uint32_t key = 0;
- boost::optional<Netmask> subnet;
+ std::optional<Netmask> subnet;
DNSQuestion dnsQuestion(ids, query);
if (localCache.get(dnsQuestion, pwQ.getHeader()->id, &key, subnet, dnssecOK, receivedOverUDP)) {
matches++;
pwR.commit();
uint32_t key = 0;
- boost::optional<Netmask> subnet;
+ std::optional<Netmask> subnet;
DNSQuestion dnsQuestion(ids, query);
bool found = localCache.get(dnsQuestion, 0, &key, subnet, dnssecOK, receivedOverUDP);
BOOST_CHECK_EQUAL(found, false);
BOOST_CHECK(!subnet);
- localCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, QType::AAAA, QClass::IN, response, receivedOverUDP, 0, boost::none);
+ localCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, QType::AAAA, QClass::IN, response, receivedOverUDP, 0, std::nullopt);
found = localCache.get(dnsQuestion, pwR.getHeader()->id, &key, subnet, dnssecOK, receivedOverUDP, 0, true);
if (found) {
GenericDNSPacketWriter<PacketBuffer> pwQ(query, ids.qname, QType::AAAA, QClass::IN, 0);
pwQ.getHeader()->rd = 1;
uint32_t key = 0;
- boost::optional<Netmask> subnet;
+ std::optional<Netmask> subnet;
DNSQuestion dnsQuestion(ids, query);
if (localCache.get(dnsQuestion, pwQ.getHeader()->id, &key, subnet, dnssecOK, receivedOverUDP)) {
matches++;
{
/* UDP */
uint32_t key = 0;
- boost::optional<Netmask> subnet;
+ std::optional<Netmask> subnet;
DNSQuestion dnsQuestion(ids, query);
bool found = localCache.get(dnsQuestion, 0, &key, subnet, dnssecOK, receivedOverUDP);
BOOST_CHECK_EQUAL(found, false);
BOOST_CHECK(!subnet);
- localCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, QType::A, QClass::IN, response, receivedOverUDP, RCode::NoError, boost::none);
+ localCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, QType::A, QClass::IN, response, receivedOverUDP, RCode::NoError, std::nullopt);
found = localCache.get(dnsQuestion, pwR.getHeader()->id, &key, subnet, dnssecOK, receivedOverUDP, 0, true);
BOOST_CHECK_EQUAL(found, true);
BOOST_CHECK(!subnet);
{
/* same but over TCP */
uint32_t key = 0;
- boost::optional<Netmask> subnet;
+ std::optional<Netmask> subnet;
ids.protocol = dnsdist::Protocol::DoTCP;
DNSQuestion dnsQuestion(ids, query);
bool found = localCache.get(dnsQuestion, 0, &key, subnet, dnssecOK, !receivedOverUDP);
BOOST_CHECK_EQUAL(found, false);
BOOST_CHECK(!subnet);
- localCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, QType::A, QClass::IN, response, !receivedOverUDP, RCode::NoError, boost::none);
+ localCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, QType::A, QClass::IN, response, !receivedOverUDP, RCode::NoError, std::nullopt);
found = localCache.get(dnsQuestion, pwR.getHeader()->id, &key, subnet, dnssecOK, !receivedOverUDP, 0, true);
BOOST_CHECK_EQUAL(found, true);
BOOST_CHECK(!subnet);
pwR.commit();
uint32_t key = 0;
- boost::optional<Netmask> subnet;
+ std::optional<Netmask> subnet;
DNSQuestion dnsQuestion(ids, query);
bool found = localCache.get(dnsQuestion, 0, &key, subnet, dnssecOK, receivedOverUDP);
BOOST_CHECK_EQUAL(found, false);
BOOST_CHECK(!subnet);
// Insert with failure-TTL of 0 (-> should not enter cache).
- localCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, QType::A, QClass::IN, response, receivedOverUDP, RCode::ServFail, boost::optional<uint32_t>(0));
+ localCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, QType::A, QClass::IN, response, receivedOverUDP, RCode::ServFail, std::optional<uint32_t>(0));
found = localCache.get(dnsQuestion, pwR.getHeader()->id, &key, subnet, dnssecOK, receivedOverUDP, 0, true);
BOOST_CHECK_EQUAL(found, false);
BOOST_CHECK(!subnet);
// Insert with failure-TTL non-zero (-> should enter cache).
- localCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, QType::A, QClass::IN, response, receivedOverUDP, RCode::ServFail, boost::optional<uint32_t>(300));
+ localCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, QType::A, QClass::IN, response, receivedOverUDP, RCode::ServFail, std::optional<uint32_t>(300));
found = localCache.get(dnsQuestion, pwR.getHeader()->id, &key, subnet, dnssecOK, receivedOverUDP, 0, true);
BOOST_CHECK_EQUAL(found, true);
BOOST_CHECK(!subnet);
pwR.commit();
uint32_t key = 0;
- boost::optional<Netmask> subnet;
+ std::optional<Netmask> subnet;
DNSQuestion dnsQuestion(ids, query);
bool found = localCache.get(dnsQuestion, 0, &key, subnet, dnssecOK, receivedOverUDP);
BOOST_CHECK_EQUAL(found, false);
BOOST_CHECK(!subnet);
- localCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, name, QType::A, QClass::IN, response, receivedOverUDP, RCode::NoError, boost::none);
+ localCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, name, QType::A, QClass::IN, response, receivedOverUDP, RCode::NoError, std::nullopt);
found = localCache.get(dnsQuestion, pwR.getHeader()->id, &key, subnet, dnssecOK, receivedOverUDP, 0, true);
BOOST_CHECK_EQUAL(found, true);
BOOST_CHECK(!subnet);
pwR.commit();
uint32_t key = 0;
- boost::optional<Netmask> subnet;
+ std::optional<Netmask> subnet;
DNSQuestion dnsQuestion(ids, query);
bool found = localCache.get(dnsQuestion, 0, &key, subnet, dnssecOK, receivedOverUDP);
BOOST_CHECK_EQUAL(found, false);
BOOST_CHECK(!subnet);
- localCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, name, QType::A, QClass::IN, response, receivedOverUDP, RCode::NXDomain, boost::none);
+ localCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, name, QType::A, QClass::IN, response, receivedOverUDP, RCode::NXDomain, std::nullopt);
found = localCache.get(dnsQuestion, pwR.getHeader()->id, &key, subnet, dnssecOK, receivedOverUDP, 0, true);
BOOST_CHECK_EQUAL(found, true);
BOOST_CHECK(!subnet);
pwR.commit();
uint32_t key = 0;
- boost::optional<Netmask> subnet;
+ std::optional<Netmask> subnet;
DNSQuestion dnsQuestion(ids, query);
bool allowTruncated = true;
BOOST_REQUIRE_EQUAL(found, false);
BOOST_CHECK(!subnet);
- localCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, QType::A, QClass::IN, response, receivedOverUDP, 0, boost::none);
+ localCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, QType::A, QClass::IN, response, receivedOverUDP, 0, std::nullopt);
found = localCache.get(dnsQuestion, pwR.getHeader()->id, &key, subnet, dnssecOK, receivedOverUDP, 0, false, allowTruncated);
BOOST_REQUIRE_EQUAL(found, false);
BOOST_REQUIRE_EQUAL(found, false);
BOOST_CHECK(!subnet);
- localCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, QType::A, QClass::IN, response, receivedOverUDP, 0, boost::none);
+ localCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, QType::A, QClass::IN, response, receivedOverUDP, 0, std::nullopt);
allowTruncated = false;
found = localCache.get(dnsQuestion, pwR.getHeader()->id, &key, subnet, dnssecOK, receivedOverUDP, 0, false, allowTruncated);
{
/* UDP */
uint32_t key = 0;
- boost::optional<Netmask> subnet;
+ std::optional<Netmask> subnet;
DNSQuestion dnsQuestion(ids, query);
bool found = packetCache.get(dnsQuestion, 0, &key, subnet, dnssecOK, receivedOverUDP);
BOOST_CHECK_EQUAL(found, false);
BOOST_CHECK(!subnet);
- packetCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, QType::A, QClass::IN, response, receivedOverUDP, RCode::NoError, boost::none);
+ packetCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, QType::A, QClass::IN, response, receivedOverUDP, RCode::NoError, std::nullopt);
found = packetCache.get(dnsQuestion, queryID, &key, subnet, dnssecOK, receivedOverUDP, 0, true);
BOOST_CHECK_EQUAL(found, true);
BOOST_CHECK(!subnet);
{
/* same but over TCP */
uint32_t key = 0;
- boost::optional<Netmask> subnet;
+ std::optional<Netmask> subnet;
ids.protocol = dnsdist::Protocol::DoTCP;
DNSQuestion dnsQuestion(ids, query);
bool found = packetCache.get(dnsQuestion, 0, &key, subnet, dnssecOK, !receivedOverUDP);
BOOST_CHECK_EQUAL(found, false);
BOOST_CHECK(!subnet);
- packetCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, QType::A, QClass::IN, response, !receivedOverUDP, RCode::NoError, boost::none);
+ packetCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, QType::A, QClass::IN, response, !receivedOverUDP, RCode::NoError, std::nullopt);
found = packetCache.get(dnsQuestion, queryID, &key, subnet, dnssecOK, !receivedOverUDP, 0, true);
BOOST_CHECK_EQUAL(found, true);
BOOST_CHECK(!subnet);
{
/* UDP */
uint32_t key = 0;
- boost::optional<Netmask> subnet;
+ std::optional<Netmask> subnet;
DNSQuestion dnsQuestion(ids, query);
bool found = packetCache.get(dnsQuestion, 0, &key, subnet, dnssecOK, receivedOverUDP);
BOOST_CHECK_EQUAL(found, false);
BOOST_CHECK(!subnet);
- packetCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, QType::A, QClass::IN, response, receivedOverUDP, RCode::NoError, boost::none);
+ packetCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, QType::A, QClass::IN, response, receivedOverUDP, RCode::NoError, std::nullopt);
found = packetCache.get(dnsQuestion, queryID, &key, subnet, dnssecOK, receivedOverUDP, 0, true);
BOOST_CHECK_EQUAL(found, false);
}
{
/* same but over TCP */
uint32_t key = 0;
- boost::optional<Netmask> subnet;
+ std::optional<Netmask> subnet;
ids.protocol = dnsdist::Protocol::DoTCP;
DNSQuestion dnsQuestion(ids, query);
bool found = packetCache.get(dnsQuestion, 0, &key, subnet, dnssecOK, !receivedOverUDP);
BOOST_CHECK_EQUAL(found, false);
BOOST_CHECK(!subnet);
- packetCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, QType::A, QClass::IN, response, !receivedOverUDP, RCode::NoError, boost::none);
+ packetCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, QType::A, QClass::IN, response, !receivedOverUDP, RCode::NoError, std::nullopt);
found = packetCache.get(dnsQuestion, queryID, &key, subnet, dnssecOK, !receivedOverUDP, 0, true);
BOOST_CHECK_EQUAL(found, false);
}
{
/* UDP */
uint32_t key = 0;
- boost::optional<Netmask> subnet;
+ std::optional<Netmask> subnet;
DNSQuestion dnsQuestion(ids, query);
bool found = packetCache.get(dnsQuestion, 0, &key, subnet, dnssecOK, receivedOverUDP);
BOOST_CHECK_EQUAL(found, false);
BOOST_CHECK(!subnet);
- packetCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, QType::A, QClass::IN, response, receivedOverUDP, RCode::NoError, boost::none);
+ packetCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, QType::A, QClass::IN, response, receivedOverUDP, RCode::NoError, std::nullopt);
found = packetCache.get(dnsQuestion, queryID, &key, subnet, dnssecOK, receivedOverUDP, 0, true);
BOOST_CHECK_EQUAL(found, true);
}
{
/* same but over TCP */
uint32_t key = 0;
- boost::optional<Netmask> subnet;
+ std::optional<Netmask> subnet;
ids.protocol = dnsdist::Protocol::DoTCP;
DNSQuestion dnsQuestion(ids, query);
bool found = packetCache.get(dnsQuestion, 0, &key, subnet, dnssecOK, !receivedOverUDP);
BOOST_CHECK_EQUAL(found, false);
BOOST_CHECK(!subnet);
- packetCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, QType::A, QClass::IN, response, !receivedOverUDP, RCode::NoError, boost::none);
+ packetCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, QType::A, QClass::IN, response, !receivedOverUDP, RCode::NoError, std::nullopt);
found = packetCache.get(dnsQuestion, queryID, &key, subnet, dnssecOK, !receivedOverUDP, 0, true);
BOOST_CHECK_EQUAL(found, true);
}
pwR.commit();
uint32_t key = 0;
- boost::optional<Netmask> subnet;
+ std::optional<Netmask> subnet;
DNSQuestion dnsQuestion(ids, query);
s_localCache.get(dnsQuestion, 0, &key, subnet, dnssecOK, receivedOverUDP);
- s_localCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, QType::A, QClass::IN, response, receivedOverUDP, 0, boost::none);
+ s_localCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, QType::A, QClass::IN, response, receivedOverUDP, 0, std::nullopt);
}
}
catch (PDNSException& e) {
pwQ.getHeader()->rd = 1;
uint32_t key = 0;
- boost::optional<Netmask> subnet;
+ std::optional<Netmask> subnet;
DNSQuestion dnsQuestion(ids, query);
bool found = s_localCache.get(dnsQuestion, 0, &key, subnet, dnssecOK, receivedOverUDP);
if (!found) {
uint16_t qid = 0x42;
uint32_t key{};
uint32_t secondKey{};
- boost::optional<Netmask> subnetOut;
+ std::optional<Netmask> subnetOut;
bool dnssecOK = false;
/* lookup for a query with a first ECS value,
pwR.addOpt(512, 0, 0, ednsOptions);
pwR.commit();
- localCache.insert(key, subnetOut, *(getFlagsFromDNSHeader(pwR.getHeader())), dnssecOK, ids.qname, ids.qtype, QClass::IN, response, receivedOverUDP, RCode::NoError, boost::none);
+ localCache.insert(key, subnetOut, *(getFlagsFromDNSHeader(pwR.getHeader())), dnssecOK, ids.qname, ids.qtype, QClass::IN, response, receivedOverUDP, RCode::NoError, std::nullopt);
BOOST_CHECK_EQUAL(localCache.getSize(), 1U);
found = localCache.get(dnsQuestion, 0, &key, subnetOut, dnssecOK, receivedOverUDP);
ids.protocol = dnsdist::Protocol::DoUDP;
uint16_t qid = 0x42;
uint32_t key{};
- boost::optional<Netmask> subnetOut;
+ std::optional<Netmask> subnetOut;
/* lookup for a query with DNSSEC OK,
insert a corresponding response with DO set,
pwR.addOpt(512, 0, EDNS_HEADER_FLAG_DO);
pwR.commit();
- localCache.insert(key, subnetOut, *(getFlagsFromDNSHeader(pwR.getHeader())), /* DNSSEC OK is set */ true, ids.qname, ids.qtype, QClass::IN, response, receivedOverUDP, RCode::NoError, boost::none);
+ localCache.insert(key, subnetOut, *(getFlagsFromDNSHeader(pwR.getHeader())), /* DNSSEC OK is set */ true, ids.qname, ids.qtype, QClass::IN, response, receivedOverUDP, RCode::NoError, std::nullopt);
BOOST_CHECK_EQUAL(localCache.getSize(), 1U);
found = localCache.get(dnsQuestion, 0, &key, subnetOut, false, receivedOverUDP);
pwR.commit();
}
- localCache.insert(key++, boost::none, *getFlagsFromDNSHeader(pwQ.getHeader()), dnssecOK, qname, QType::A, QClass::IN, response, receivedOverUDP, 0, boost::none);
+ localCache.insert(key++, std::nullopt, *getFlagsFromDNSHeader(pwQ.getHeader()), dnssecOK, qname, QType::A, QClass::IN, response, receivedOverUDP, 0, std::nullopt);
BOOST_CHECK_EQUAL(localCache.getSize(), key);
}
pwR.commit();
}
- localCache.insert(key++, boost::none, *getFlagsFromDNSHeader(pwQ.getHeader()), dnssecOK, qname, QType::A, QClass::IN, response, receivedOverUDP, 0, boost::none);
+ localCache.insert(key++, std::nullopt, *getFlagsFromDNSHeader(pwQ.getHeader()), dnssecOK, qname, QType::A, QClass::IN, response, receivedOverUDP, 0, std::nullopt);
BOOST_CHECK_EQUAL(localCache.getSize(), key);
}
pwR.addOpt(4096, 0, 0);
pwR.commit();
- localCache.insert(key++, boost::none, *getFlagsFromDNSHeader(pwQ.getHeader()), dnssecOK, qname, QType::A, QClass::IN, response, receivedOverUDP, 0, boost::none);
+ localCache.insert(key++, std::nullopt, *getFlagsFromDNSHeader(pwQ.getHeader()), dnssecOK, qname, QType::A, QClass::IN, response, receivedOverUDP, 0, std::nullopt);
BOOST_CHECK_EQUAL(localCache.getSize(), key);
}
pwR.commit();
}
- localCache.insert(key++, boost::none, *getFlagsFromDNSHeader(pwQ.getHeader()), dnssecOK, qname, QType::A, QClass::IN, response, receivedOverUDP, 0, boost::none);
+ localCache.insert(key++, std::nullopt, *getFlagsFromDNSHeader(pwQ.getHeader()), dnssecOK, qname, QType::A, QClass::IN, response, receivedOverUDP, 0, std::nullopt);
BOOST_CHECK_EQUAL(localCache.getSize(), key);
}
pwR.commit();
}
- localCache.insert(key++, boost::none, *getFlagsFromDNSHeader(pwQ.getHeader()), dnssecOK, qname, QType::A, QClass::IN, response, receivedOverUDP, 0, boost::none);
+ localCache.insert(key++, std::nullopt, *getFlagsFromDNSHeader(pwQ.getHeader()), dnssecOK, qname, QType::A, QClass::IN, response, receivedOverUDP, 0, std::nullopt);
BOOST_CHECK_EQUAL(localCache.getSize(), key);
}
pwR.commit();
uint32_t key = 0;
- boost::optional<Netmask> subnet;
+ std::optional<Netmask> subnet;
DNSQuestion dnsQuestion(ids, query);
bool found = localCache.get(dnsQuestion, 0, &key, subnet, dnssecOK, receivedOverUDP);
BOOST_CHECK_EQUAL(found, false);
BOOST_CHECK(!subnet);
- localCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, ids.qtype, ids.qclass, response, receivedOverUDP, 0, boost::none);
+ localCache.insert(key, subnet, *(getFlagsFromDNSHeader(dnsQuestion.getHeader().get())), dnssecOK, ids.qname, ids.qtype, ids.qclass, response, receivedOverUDP, 0, std::nullopt);
found = localCache.get(dnsQuestion, pwR.getHeader()->id, &key, subnet, dnssecOK, receivedOverUDP, 0, true);
BOOST_CHECK_EQUAL(found, false);
}
PacketBuffer response;
create_shuffle_response(addresses, ids.qname, response, testqtype, testtype);
- boost::optional<Netmask> subnet;
+ std::optional<Netmask> subnet;
uint32_t key = 0;
DNSQuestion dnsQuestion(ids, query);
bool found = localCache.get(dnsQuestion, 0, &key, subnet, dnssecOK, receivedOverUDP);
BOOST_CHECK_EQUAL(found, false);
- localCache.insert(key, boost::none, *getFlagsFromDNSHeader(pwQ.getHeader()), dnssecOK, ids.qname, testqtype, QClass::IN, response, receivedOverUDP, 0, boost::none);
+ localCache.insert(key, std::nullopt, *getFlagsFromDNSHeader(pwQ.getHeader()), dnssecOK, ids.qname, testqtype, QClass::IN, response, receivedOverUDP, 0, std::nullopt);
}
// now prepare all the possible permutations and save them, to compare later
pwQ.getHeader()->rd = 1;
uint32_t key = 0;
- boost::optional<Netmask> subnet;
+ std::optional<Netmask> subnet;
DNSQuestion dnsQuestion(ids, query);
bool found = localCache.get(dnsQuestion, 0, &key, subnet, dnssecOK, receivedOverUDP);
BOOST_CHECK_EQUAL(found, true);
return std::move(d_buffer);
}
-DnstapMessage::DnstapMessage(std::string&& buffer, DnstapMessage::MessageType type, const std::string& identity, const ComboAddress* requestor, const ComboAddress* responder, DnstapMessage::ProtocolType protocol, const char* packet, const size_t len, const struct timespec* queryTime, const struct timespec* responseTime, const boost::optional<const DNSName&>& auth, const boost::optional<HttpProtocolType> httpProtocol) :
+DnstapMessage::DnstapMessage(std::string&& buffer, DnstapMessage::MessageType type, const std::string& identity, const ComboAddress* requestor, const ComboAddress* responder, DnstapMessage::ProtocolType protocol, const char* packet, const size_t len, const struct timespec* queryTime, const struct timespec* responseTime, const DNSName& auth, const std::optional<HttpProtocolType> httpProtocol) :
d_buffer(std::move(buffer))
{
protozero::pbf_writer pbf{d_buffer};
pbf_message.add_enum(DnstapMessageFields::http_protocol, static_cast<protozero::pbf_tag_type>(*httpProtocol));
}
- if (auth) {
- pbf_message.add_bytes(DnstapMessageFields::query_zone, auth->toDNSString());
+ if (!auth.empty()) {
+ pbf_message.add_bytes(DnstapMessageFields::query_zone, auth.toDNSString());
}
pbf_message.commit();
HTTP3 = 3,
};
- DnstapMessage(std::string&& buffer, MessageType type, const std::string& identity, const ComboAddress* requestor, const ComboAddress* responder, ProtocolType protocol, const char* packet, size_t len, const struct timespec* queryTime, const struct timespec* responseTime, const boost::optional<const DNSName&>& auth = boost::none, const boost::optional<HttpProtocolType> httpProtocol = boost::none);
+ DnstapMessage(std::string&& buffer, MessageType type, const std::string& identity, const ComboAddress* requestor, const ComboAddress* responder, ProtocolType protocol, const char* packet, size_t len, const struct timespec* queryTime, const struct timespec* responseTime, const DNSName& auth, const std::optional<HttpProtocolType> httpProtocol = std::nullopt);
void setExtra(const std::string& extra);
std::string&& getBuffer();
return false;
}
-static void logFstreamQuery(const std::shared_ptr<std::vector<std::unique_ptr<FrameStreamLogger>>>& fstreamLoggers, const struct timeval& queryTime, const ComboAddress& localip, const ComboAddress& address, DnstapMessage::ProtocolType protocol, const boost::optional<const DNSName&>& auth, const vector<uint8_t>& packet)
+static void logFstreamQuery(const std::shared_ptr<std::vector<std::unique_ptr<FrameStreamLogger>>>& fstreamLoggers, const struct timeval& queryTime, const ComboAddress& localip, const ComboAddress& address, DnstapMessage::ProtocolType protocol, const DNSName& auth, const vector<uint8_t>& packet)
{
if (fstreamLoggers == nullptr)
return;
return false;
}
-static void logFstreamResponse(const std::shared_ptr<std::vector<std::unique_ptr<FrameStreamLogger>>>& fstreamLoggers, const ComboAddress& localip, const ComboAddress& address, DnstapMessage::ProtocolType protocol, const boost::optional<const DNSName&>& auth, const PacketBuffer& packet, const struct timeval& queryTime, const struct timeval& replyTime)
+static void logFstreamResponse(const std::shared_ptr<std::vector<std::unique_ptr<FrameStreamLogger>>>& fstreamLoggers, const ComboAddress& localip, const ComboAddress& address, DnstapMessage::ProtocolType protocol, const DNSName& auth, const PacketBuffer& packet, const struct timeval& queryTime, const struct timeval& replyTime)
{
if (fstreamLoggers == nullptr)
return;
}
#ifdef HAVE_FSTRM
if (fstrmQEnabled) {
- logFstreamQuery(fstrmLoggers, queryTime, localip, address, DnstapMessage::ProtocolType::DoUDP, context.d_auth ? context.d_auth : boost::none, vpacket);
+ logFstreamQuery(fstrmLoggers, queryTime, localip, address, DnstapMessage::ProtocolType::DoUDP, context.d_auth, vpacket);
}
#endif
}
struct ResolveContext
{
- ResolveContext(const boost::optional<const boost::uuids::uuid&>& uuid, DNSName name) :
- d_initialRequestId(uuid), d_nsName(std::move(name))
+ ResolveContext(const boost::optional<const boost::uuids::uuid&>& uuid, DNSName name, const DNSName& auth) :
+ d_initialRequestId(uuid), d_nsName(std::move(name)), d_auth(auth)
{}
~ResolveContext() = default;
boost::optional<const boost::uuids::uuid&> d_initialRequestId;
DNSName d_nsName;
- boost::optional<const DNSName&> d_auth;
+ DNSName d_auth;
};
int EDNSLevel = 0;
auto luaconfsLocal = g_luaconfs.getLocal();
- ResolveContext ctx(d_initialRequestId, nsName);
- ctx.d_auth = auth;
+ ResolveContext ctx(d_initialRequestId, nsName, auth);
LWResult::Result ret{};
projects / thirdparty / pdns.git / commitdiff
