From cca6d6a8baecd3ce5d546740e00a413c18022010 Mon Sep 17 00:00:00 2001 From: Remi Gacogne Date: Mon, 16 Nov 2020 18:30:02 +0100 Subject: [PATCH] rec: Use a struct to pass gettag_ffi parameters --- pdns/lua-recursor4.cc | 112 +++++++++++++++++------------------------- pdns/lua-recursor4.hh | 36 +++++++++++++- pdns/pdns_recursor.cc | 17 ++++--- 3 files changed, 90 insertions(+), 75 deletions(-) diff --git a/pdns/lua-recursor4.cc b/pdns/lua-recursor4.cc index b86e30f185..a69ba0aa16 100644 --- a/pdns/lua-recursor4.cc +++ b/pdns/lua-recursor4.cc @@ -602,54 +602,30 @@ unsigned int RecursorLua4::gettag(const ComboAddress& remote, const Netmask& edn struct pdns_ffi_param { public: - pdns_ffi_param(const DNSName& qname_, uint16_t qtype_, const ComboAddress& local_, const ComboAddress& remote_, const Netmask& ednssubnet_, std::unordered_set& policyTags_, std::vector& records_, const EDNSOptionViewMap& ednsOptions_, const std::vector& proxyProtocolValues_, std::string& requestorId_, std::string& deviceId_, std::string& deviceName_, std::string& routingTag_, boost::optional& rcode_, uint32_t& ttlCap_, bool& variable_, bool tcp_, bool& logQuery_, bool& logResponse_, bool& followCNAMERecords_, boost::optional& extendedErrorCode_, std::string& extendedErrorExtra_): qname(qname_), local(local_), remote(remote_), ednssubnet(ednssubnet_), policyTags(policyTags_), records(records_), ednsOptions(ednsOptions_), proxyProtocolValues(proxyProtocolValues_), requestorId(requestorId_), deviceId(deviceId_), deviceName(deviceName_), routingTag(routingTag_), extendedErrorExtra(extendedErrorExtra_), rcode(rcode_), extendedErrorCode(extendedErrorCode_), ttlCap(ttlCap_), variable(variable_), logQuery(logQuery_), logResponse(logResponse_), followCNAMERecords(followCNAMERecords_), qtype(qtype_), tcp(tcp_) + pdns_ffi_param(RecursorLua4::FFIParams& params_): params(params_) { } + RecursorLua4::FFIParams& params; std::unique_ptr qnameStr{nullptr}; std::unique_ptr localStr{nullptr}; std::unique_ptr remoteStr{nullptr}; std::unique_ptr ednssubnetStr{nullptr}; std::vector ednsOptionsVect; std::vector proxyProtocolValuesVect; - - const DNSName& qname; - const ComboAddress& local; - const ComboAddress& remote; - const Netmask& ednssubnet; - std::unordered_set& policyTags; - std::vector& records; - const EDNSOptionViewMap& ednsOptions; - const std::vector& proxyProtocolValues; - std::string& requestorId; - std::string& deviceId; - std::string& deviceName; - std::string& routingTag; - std::string& extendedErrorExtra; - boost::optional& rcode; - boost::optional& extendedErrorCode; - uint32_t& ttlCap; - bool& variable; - bool& logQuery; - bool& logResponse; - bool& followCNAMERecords; - - unsigned int tag{0}; - uint16_t qtype; - bool tcp; }; -unsigned int RecursorLua4::gettag_ffi(const ComboAddress& remote, const Netmask& ednssubnet, const ComboAddress& local, const DNSName& qname, uint16_t qtype, std::unordered_set* policyTags, std::vector& records, LuaContext::LuaObject& data, const EDNSOptionViewMap& ednsOptions, bool tcp, const std::vector& proxyProtocolValues, std::string& requestorId, std::string& deviceId, std::string& deviceName, std::string& routingTag, boost::optional& rcode, uint32_t& ttlCap, bool& variable, bool& logQuery, bool& logResponse, bool& followCNAMERecords, boost::optional& extendedErrorCode, std::string& extendedErrorExtra) const +unsigned int RecursorLua4::gettag_ffi(RecursorLua4::FFIParams& params) const { if (d_gettag_ffi) { - pdns_ffi_param_t param(qname, qtype, local, remote, ednssubnet, *policyTags, records, ednsOptions, proxyProtocolValues, requestorId, deviceId, deviceName, routingTag, rcode, ttlCap, variable, tcp, logQuery, logResponse, followCNAMERecords, extendedErrorCode, extendedErrorExtra); + pdns_ffi_param_t param(params); auto ret = d_gettag_ffi(¶m); if (ret) { - data = *ret; + params.data = *ret; } - return param.tag; + return param.params.tag; } return 0; } @@ -717,7 +693,7 @@ RecursorLua4::~RecursorLua4(){} const char* pdns_ffi_param_get_qname(pdns_ffi_param_t* ref) { if (!ref->qnameStr) { - ref->qnameStr = std::unique_ptr(new std::string(ref->qname.toStringNoDot())); + ref->qnameStr = std::unique_ptr(new std::string(ref->params.qname.toStringNoDot())); } return ref->qnameStr->c_str(); @@ -725,20 +701,20 @@ const char* pdns_ffi_param_get_qname(pdns_ffi_param_t* ref) void pdns_ffi_param_get_qname_raw(pdns_ffi_param_t* ref, const char** qname, size_t* qnameSize) { - const auto& storage = ref->qname.getStorage(); + const auto& storage = ref->params.qname.getStorage(); *qname = storage.data(); *qnameSize = storage.size(); } uint16_t pdns_ffi_param_get_qtype(const pdns_ffi_param_t* ref) { - return ref->qtype; + return ref->params.qtype; } const char* pdns_ffi_param_get_remote(pdns_ffi_param_t* ref) { if (!ref->remoteStr) { - ref->remoteStr = std::unique_ptr(new std::string(ref->remote.toString())); + ref->remoteStr = std::unique_ptr(new std::string(ref->params.remote.toString())); } return ref->remoteStr->c_str(); @@ -758,18 +734,18 @@ static void pdns_ffi_comboaddress_to_raw(const ComboAddress& ca, const void** ad void pdns_ffi_param_get_remote_raw(pdns_ffi_param_t* ref, const void** addr, size_t* addrSize) { - pdns_ffi_comboaddress_to_raw(ref->remote, addr, addrSize); + pdns_ffi_comboaddress_to_raw(ref->params.remote, addr, addrSize); } uint16_t pdns_ffi_param_get_remote_port(const pdns_ffi_param_t* ref) { - return ref->remote.getPort(); + return ref->params.remote.getPort(); } const char* pdns_ffi_param_get_local(pdns_ffi_param_t* ref) { if (!ref->localStr) { - ref->localStr = std::unique_ptr(new std::string(ref->local.toString())); + ref->localStr = std::unique_ptr(new std::string(ref->params.local.toString())); } return ref->localStr->c_str(); @@ -777,22 +753,22 @@ const char* pdns_ffi_param_get_local(pdns_ffi_param_t* ref) void pdns_ffi_param_get_local_raw(pdns_ffi_param_t* ref, const void** addr, size_t* addrSize) { - pdns_ffi_comboaddress_to_raw(ref->local, addr, addrSize); + pdns_ffi_comboaddress_to_raw(ref->params.local, addr, addrSize); } uint16_t pdns_ffi_param_get_local_port(const pdns_ffi_param_t* ref) { - return ref->local.getPort(); + return ref->params.local.getPort(); } const char* pdns_ffi_param_get_edns_cs(pdns_ffi_param_t* ref) { - if (ref->ednssubnet.empty()) { + if (ref->params.ednssubnet.empty()) { return nullptr; } if (!ref->ednssubnetStr) { - ref->ednssubnetStr = std::unique_ptr(new std::string(ref->ednssubnet.toStringNoMask())); + ref->ednssubnetStr = std::unique_ptr(new std::string(ref->params.ednssubnet.toStringNoMask())); } return ref->ednssubnetStr->c_str(); @@ -800,18 +776,18 @@ const char* pdns_ffi_param_get_edns_cs(pdns_ffi_param_t* ref) void pdns_ffi_param_get_edns_cs_raw(pdns_ffi_param_t* ref, const void** net, size_t* netSize) { - if (ref->ednssubnet.empty()) { + if (ref->params.ednssubnet.empty()) { *net = nullptr; *netSize = 0; return; } - pdns_ffi_comboaddress_to_raw(ref->ednssubnet.getNetwork(), net, netSize); + pdns_ffi_comboaddress_to_raw(ref->params.ednssubnet.getNetwork(), net, netSize); } uint8_t pdns_ffi_param_get_edns_cs_source_mask(const pdns_ffi_param_t* ref) { - return ref->ednssubnet.getBits(); + return ref->params.ednssubnet.getBits(); } static void fill_edns_option(const EDNSOptionViewValue& value, pdns_ednsoption_t& option) @@ -826,19 +802,19 @@ static void fill_edns_option(const EDNSOptionViewValue& value, pdns_ednsoption_t size_t pdns_ffi_param_get_edns_options(pdns_ffi_param_t* ref, const pdns_ednsoption_t** out) { - if (ref->ednsOptions.empty()) { + if (ref->params.ednsOptions.empty()) { return 0; } size_t totalCount = 0; - for (const auto& option : ref->ednsOptions) { + for (const auto& option : ref->params.ednsOptions) { totalCount += option.second.values.size(); } ref->ednsOptionsVect.resize(totalCount); size_t pos = 0; - for (const auto& option : ref->ednsOptions) { + for (const auto& option : ref->params.ednsOptions) { for (const auto& entry : option.second.values) { fill_edns_option(entry, ref->ednsOptionsVect.at(pos)); ref->ednsOptionsVect.at(pos).optionCode = option.first; @@ -853,8 +829,8 @@ size_t pdns_ffi_param_get_edns_options(pdns_ffi_param_t* ref, const pdns_ednsopt size_t pdns_ffi_param_get_edns_options_by_code(pdns_ffi_param_t* ref, uint16_t optionCode, const pdns_ednsoption_t** out) { - const auto& it = ref->ednsOptions.find(optionCode); - if (it == ref->ednsOptions.cend() || it->second.values.empty()) { + const auto& it = ref->params.ednsOptions.find(optionCode); + if (it == ref->params.ednsOptions.cend() || it->second.values.empty()) { return 0; } @@ -874,14 +850,14 @@ size_t pdns_ffi_param_get_edns_options_by_code(pdns_ffi_param_t* ref, uint16_t o size_t pdns_ffi_param_get_proxy_protocol_values(pdns_ffi_param_t* ref, const pdns_proxyprotocol_value_t** out) { - if (ref->proxyProtocolValues.empty()) { + if (ref->params.proxyProtocolValues.empty()) { return 0; } - ref->proxyProtocolValuesVect.resize(ref->proxyProtocolValues.size()); + ref->proxyProtocolValuesVect.resize(ref->params.proxyProtocolValues.size()); size_t pos = 0; - for (const auto& value : ref->proxyProtocolValues) { + for (const auto& value : ref->params.proxyProtocolValues) { auto& dest = ref->proxyProtocolValuesVect.at(pos); dest.type = value.type; dest.len = value.content.size(); @@ -898,85 +874,85 @@ size_t pdns_ffi_param_get_proxy_protocol_values(pdns_ffi_param_t* ref, const pdn void pdns_ffi_param_set_tag(pdns_ffi_param_t* ref, unsigned int tag) { - ref->tag = tag; + ref->params.tag = tag; } void pdns_ffi_param_add_policytag(pdns_ffi_param_t *ref, const char* name) { - ref->policyTags.insert(std::string(name)); + ref->params.policyTags.insert(std::string(name)); } void pdns_ffi_param_set_requestorid(pdns_ffi_param_t* ref, const char* name) { - ref->requestorId = std::string(name); + ref->params.requestorId = std::string(name); } void pdns_ffi_param_set_devicename(pdns_ffi_param_t* ref, const char* name) { - ref->deviceName = std::string(name); + ref->params.deviceName = std::string(name); } void pdns_ffi_param_set_deviceid(pdns_ffi_param_t* ref, size_t len, const void* name) { - ref->deviceId = std::string(reinterpret_cast(name), len); + ref->params.deviceId = std::string(reinterpret_cast(name), len); } void pdns_ffi_param_set_routingtag(pdns_ffi_param_t* ref, const char* rtag) { - ref->routingTag = std::string(rtag); + ref->params.routingTag = std::string(rtag); } void pdns_ffi_param_set_variable(pdns_ffi_param_t* ref, bool variable) { - ref->variable = variable; + ref->params.variable = variable; } void pdns_ffi_param_set_ttl_cap(pdns_ffi_param_t* ref, uint32_t ttl) { - ref->ttlCap = ttl; + ref->params.ttlCap = ttl; } void pdns_ffi_param_set_log_query(pdns_ffi_param_t* ref, bool logQuery) { - ref->logQuery = logQuery; + ref->params.logQuery = logQuery; } void pdns_ffi_param_set_log_response(pdns_ffi_param_t* ref, bool logResponse) { - ref->logResponse = logResponse; + ref->params.logResponse = logResponse; } void pdns_ffi_param_set_rcode(pdns_ffi_param_t* ref, int rcode) { - ref->rcode = rcode; + ref->params.rcode = rcode; } void pdns_ffi_param_set_follow_cname_records(pdns_ffi_param_t* ref, bool follow) { - ref->followCNAMERecords = follow; + ref->params.followCNAMERecords = follow; } void pdns_ffi_param_set_extended_error_code(pdns_ffi_param_t* ref, uint16_t code) { - ref->extendedErrorCode = code; + ref->params.extendedErrorCode = code; } void pdns_ffi_param_set_extended_error_extra(pdns_ffi_param_t* ref, size_t len, const char* extra) { - ref->extendedErrorExtra = std::string(extra, len); + ref->params.extendedErrorExtra = std::string(extra, len); } bool pdns_ffi_param_add_record(pdns_ffi_param_t *ref, const char* name, uint16_t type, uint32_t ttl, const char* content, size_t contentSize, pdns_record_place_t place) { try { DNSRecord dr; - dr.d_name = name != nullptr ? DNSName(name) : ref->qname; + dr.d_name = name != nullptr ? DNSName(name) : ref->params.qname; dr.d_ttl = ttl; dr.d_type = type; dr.d_class = QClass::IN; dr.d_place = DNSResourceRecord::Place(place); dr.d_content = DNSRecordContent::mastermake(type, QClass::IN, std::string(content, contentSize)); - ref->records.push_back(std::move(dr)); + ref->params.records.push_back(std::move(dr)); return true; } diff --git a/pdns/lua-recursor4.hh b/pdns/lua-recursor4.hh index 1bdd02b10f..58887de0d6 100644 --- a/pdns/lua-recursor4.hh +++ b/pdns/lua-recursor4.hh @@ -131,8 +131,42 @@ public: std::unordered_map* discardedPolicies{nullptr}; }; + struct FFIParams + { + public: + FFIParams(const DNSName& qname_, uint16_t qtype_, const ComboAddress& local_, const ComboAddress& remote_, const Netmask& ednssubnet_, LuaContext::LuaObject& data_, std::unordered_set& policyTags_, std::vector& records_, const EDNSOptionViewMap& ednsOptions_, const std::vector& proxyProtocolValues_, std::string& requestorId_, std::string& deviceId_, std::string& deviceName_, std::string& routingTag_, boost::optional& rcode_, uint32_t& ttlCap_, bool& variable_, bool tcp_, bool& logQuery_, bool& logResponse_, bool& followCNAMERecords_, boost::optional& extendedErrorCode_, std::string& extendedErrorExtra_): data(data_), qname(qname_), local(local_), remote(remote_), ednssubnet(ednssubnet_), policyTags(policyTags_), records(records_), ednsOptions(ednsOptions_), proxyProtocolValues(proxyProtocolValues_), requestorId(requestorId_), deviceId(deviceId_), deviceName(deviceName_), routingTag(routingTag_), extendedErrorExtra(extendedErrorExtra_), rcode(rcode_), extendedErrorCode(extendedErrorCode_), ttlCap(ttlCap_), variable(variable_), logQuery(logQuery_), logResponse(logResponse_), followCNAMERecords(followCNAMERecords_), qtype(qtype_), tcp(tcp_) + { + } + + LuaContext::LuaObject& data; + const DNSName& qname; + const ComboAddress& local; + const ComboAddress& remote; + const Netmask& ednssubnet; + std::unordered_set& policyTags; + std::vector& records; + const EDNSOptionViewMap& ednsOptions; + const std::vector& proxyProtocolValues; + std::string& requestorId; + std::string& deviceId; + std::string& deviceName; + std::string& routingTag; + std::string& extendedErrorExtra; + boost::optional& rcode; + boost::optional& extendedErrorCode; + uint32_t& ttlCap; + bool& variable; + bool& logQuery; + bool& logResponse; + bool& followCNAMERecords; + + unsigned int tag{0}; + uint16_t qtype; + bool tcp; + }; + unsigned int gettag(const ComboAddress& remote, const Netmask& ednssubnet, const ComboAddress& local, const DNSName& qname, uint16_t qtype, std::unordered_set* policyTags, LuaContext::LuaObject& data, const EDNSOptionViewMap&, bool tcp, std::string& requestorId, std::string& deviceId, std::string& deviceName, std::string& routingTag, const std::vector& proxyProtocolValues) const; - unsigned int gettag_ffi(const ComboAddress& remote, const Netmask& ednssubnet, const ComboAddress& local, const DNSName& qname, uint16_t qtype, std::unordered_set* policyTags, std::vector& records, LuaContext::LuaObject& data, const EDNSOptionViewMap& ednsOptions, bool tcp, const std::vector& proxyProtocolValues, std::string& requestorId, std::string& deviceId, std::string& deviceName, std::string& routingTag, boost::optional& rcode, uint32_t& ttlCap, bool& variable, bool& logQuery, bool& logResponse, bool& followCNAMERecords, boost::optional& extendedErrorCode, std::string& extendedErrorExtra) const; + unsigned int gettag_ffi(FFIParams&) const; void maintenance() const; bool prerpz(DNSQuestion& dq, int& ret) const; diff --git a/pdns/pdns_recursor.cc b/pdns/pdns_recursor.cc index 21ad4e74f4..d81529d1e7 100644 --- a/pdns/pdns_recursor.cc +++ b/pdns/pdns_recursor.cc @@ -2501,7 +2501,8 @@ static void handleRunningTCPQuestion(int fd, FDMultiplexer::funcparam_t& var) if(t_pdl) { try { if (t_pdl->d_gettag_ffi) { - dc->d_tag = t_pdl->gettag_ffi(dc->d_source, dc->d_ednssubnet.source, dc->d_destination, qname, qtype, &dc->d_policyTags, dc->d_records, dc->d_data, ednsOptions, true, dc->d_proxyProtocolValues, requestorId, deviceId, deviceName, dc->d_routingTag, dc->d_rcode, dc->d_ttlCap, dc->d_variable, logQuery, dc->d_logResponse, dc->d_followCNAMERecords, dc->d_extendedErrorCode, dc->d_extendedErrorExtra); + RecursorLua4::FFIParams params(qname, qtype, dc->d_destination, dc->d_source, dc->d_ednssubnet.source, dc->d_data, dc->d_policyTags, dc->d_records, ednsOptions, dc->d_proxyProtocolValues, requestorId, deviceId, deviceName, dc->d_routingTag, dc->d_rcode, dc->d_ttlCap, dc->d_variable, true, logQuery, dc->d_logResponse, dc->d_followCNAMERecords, dc->d_extendedErrorCode, dc->d_extendedErrorExtra); + dc->d_tag = t_pdl->gettag_ffi(params); } else if (t_pdl->d_gettag) { dc->d_tag = t_pdl->gettag(dc->d_source, dc->d_ednssubnet.source, dc->d_destination, qname, qtype, &dc->d_policyTags, dc->d_data, ednsOptions, true, requestorId, deviceId, deviceName, dc->d_routingTag, dc->d_proxyProtocolValues); @@ -2768,22 +2769,26 @@ static string* doProcessUDPQuestion(const std::string& question, const ComboAddr if(t_pdl) { try { if (t_pdl->d_gettag_ffi) { - ctag = t_pdl->gettag_ffi(source, ednssubnet.source, destination, qname, qtype, &policyTags, records, data, ednsOptions, false, proxyProtocolValues, requestorId, deviceId, deviceName, routingTag, rcode, ttlCap, variable, logQuery, logResponse, followCNAMEs, extendedErrorCode, extendedErrorExtra); + RecursorLua4::FFIParams params(qname, qtype, destination, source, ednssubnet.source, data, policyTags, records, ednsOptions, proxyProtocolValues, requestorId, deviceId, deviceName, routingTag, rcode, ttlCap, variable, false, logQuery, logResponse, followCNAMEs, extendedErrorCode, extendedErrorExtra); + + ctag = t_pdl->gettag_ffi(params); } else if (t_pdl->d_gettag) { ctag = t_pdl->gettag(source, ednssubnet.source, destination, qname, qtype, &policyTags, data, ednsOptions, false, requestorId, deviceId, deviceName, routingTag, proxyProtocolValues); } } - catch(const std::exception& e) { - if(g_logCommonErrors) + catch (const std::exception& e) { + if (g_logCommonErrors) { g_log<