From f3f5d18a8e1ac2ef04b6f5b53bb8af2703bc6f3a Mon Sep 17 00:00:00 2001 From: Charles-Henri Bruyand Date: Thu, 10 Jun 2021 17:54:54 +0200 Subject: [PATCH] rec: code format lua-recursor4-ffi.hh lua-recursor4.cc lua-recursor4.hh and also properly sort .not-formated file --- .not-formatted | 97 ++++----- pdns/lua-recursor4-ffi.hh | 85 ++++---- pdns/lua-recursor4.cc | 441 +++++++++++++++++++------------------- pdns/lua-recursor4.hh | 48 +++-- 4 files changed, 339 insertions(+), 332 deletions(-) diff --git a/.not-formatted b/.not-formatted index 1ff59d93ac..0132d40bfa 100644 --- a/.not-formatted +++ b/.not-formatted @@ -42,47 +42,19 @@ ./pdns/devpollmplexer.cc ./pdns/digests.hh ./pdns/distributor.hh -./pdns/dns.cc -./pdns/dns.hh -./pdns/dns_random.cc -./pdns/dns_random.hh ./pdns/dnsbackend.cc ./pdns/dnsbackend.hh ./pdns/dnsbulktest.cc +./pdns/dns.cc ./pdns/dnscrypt.cc ./pdns/dnscrypt.hh ./pdns/dnsdemog.cc ./pdns/dnsdist-cache.cc ./pdns/dnsdist-cache.hh ./pdns/dnsdist-carbon.cc +./pdns/dnsdist.cc ./pdns/dnsdist-console.cc ./pdns/dnsdist-console.hh -./pdns/dnsdist-dynblocks.hh -./pdns/dnsdist-dynbpf.cc -./pdns/dnsdist-dynbpf.hh -./pdns/dnsdist-ecs.cc -./pdns/dnsdist-ecs.hh -./pdns/dnsdist-lbpolicies.hh -./pdns/dnsdist-lua-actions.cc -./pdns/dnsdist-lua-bindings-dnsquestion.cc -./pdns/dnsdist-lua-bindings.cc -./pdns/dnsdist-lua-inspection.cc -./pdns/dnsdist-lua-rules.cc -./pdns/dnsdist-lua-vars.cc -./pdns/dnsdist-lua.cc -./pdns/dnsdist-lua.hh -./pdns/dnsdist-protobuf.cc -./pdns/dnsdist-protobuf.hh -./pdns/dnsdist-rings.cc -./pdns/dnsdist-rings.hh -./pdns/dnsdist-snmp.cc -./pdns/dnsdist-snmp.hh -./pdns/dnsdist-tcp.cc -./pdns/dnsdist-web.cc -./pdns/dnsdist-xpf.cc -./pdns/dnsdist-xpf.hh -./pdns/dnsdist.cc -./pdns/dnsdist.hh ./pdns/dnsdistdist/connection-management.hh ./pdns/dnsdistdist/dnsdist-backend.cc ./pdns/dnsdistdist/dnsdist-dynblocks.cc @@ -118,19 +90,47 @@ ./pdns/dnsdistdist/test-dnsdistrules_cc.cc ./pdns/dnsdistdist/test-dnsdisttcp_cc.cc ./pdns/dnsdistdist/testrunner.cc +./pdns/dnsdist-dynblocks.hh +./pdns/dnsdist-dynbpf.cc +./pdns/dnsdist-dynbpf.hh +./pdns/dnsdist-ecs.cc +./pdns/dnsdist-ecs.hh +./pdns/dnsdist.hh +./pdns/dnsdist-lbpolicies.hh +./pdns/dnsdist-lua-actions.cc +./pdns/dnsdist-lua-bindings.cc +./pdns/dnsdist-lua-bindings-dnsquestion.cc +./pdns/dnsdist-lua.cc +./pdns/dnsdist-lua.hh +./pdns/dnsdist-lua-inspection.cc +./pdns/dnsdist-lua-rules.cc +./pdns/dnsdist-lua-vars.cc +./pdns/dnsdist-protobuf.cc +./pdns/dnsdist-protobuf.hh +./pdns/dnsdist-rings.cc +./pdns/dnsdist-rings.hh +./pdns/dnsdist-snmp.cc +./pdns/dnsdist-snmp.hh +./pdns/dnsdist-tcp.cc +./pdns/dnsdist-web.cc +./pdns/dnsdist-xpf.cc +./pdns/dnsdist-xpf.hh ./pdns/dnsgram.cc +./pdns/dns.hh ./pdns/dnsname.cc ./pdns/dnsname.hh ./pdns/dnspacket.cc ./pdns/dnspacket.hh ./pdns/dnsparser.cc ./pdns/dnsparser.hh -./pdns/dnspcap.cc -./pdns/dnspcap.hh ./pdns/dnspcap2calidns.cc ./pdns/dnspcap2protobuf.cc +./pdns/dnspcap.cc +./pdns/dnspcap.hh ./pdns/dnsproxy.cc ./pdns/dnsproxy.hh +./pdns/dns_random.cc +./pdns/dns_random.hh ./pdns/dnsrecords.cc ./pdns/dnsrecords.hh ./pdns/dnsreplay.cc @@ -180,12 +180,12 @@ ./pdns/iputils.cc ./pdns/iputils.hh ./pdns/ixfr.cc -./pdns/ixfr.hh +./pdns/ixfrdist.cc ./pdns/ixfrdist-stats.cc ./pdns/ixfrdist-stats.hh ./pdns/ixfrdist-web.cc ./pdns/ixfrdist-web.hh -./pdns/ixfrdist.cc +./pdns/ixfr.hh ./pdns/ixfrutils.cc ./pdns/ixfrutils.hh ./pdns/ixplore.cc @@ -202,9 +202,6 @@ ./pdns/lua-base4.cc ./pdns/lua-base4.hh ./pdns/lua-record.cc -./pdns/lua-recursor4-ffi.hh -./pdns/lua-recursor4.cc -./pdns/lua-recursor4.hh ./pdns/lwres.cc ./pdns/lwres.hh ./pdns/malloctrace.cc @@ -216,9 +213,9 @@ ./pdns/misc.hh ./pdns/mplexer.hh ./pdns/mtasker.cc -./pdns/mtasker.hh ./pdns/mtasker_context.hh ./pdns/mtasker_fcontext.cc +./pdns/mtasker.hh ./pdns/mtasker_ucontext.cc ./pdns/nameserver.cc ./pdns/nameserver.hh @@ -234,9 +231,9 @@ ./pdns/packetcache.hh ./pdns/packethandler.cc ./pdns/packethandler.hh +./pdns/pdnsexception.hh ./pdns/pdns_hw.cc ./pdns/pdns_recursor.cc -./pdns/pdnsexception.hh ./pdns/pdnsutil.cc ./pdns/pkcs11signers.cc ./pdns/pkcs11signers.hh @@ -253,17 +250,17 @@ ./pdns/rcpgenerator.cc ./pdns/rcpgenerator.hh ./pdns/rec-carbon.cc -./pdns/rec-lua-conf.cc -./pdns/rec-lua-conf.hh -./pdns/rec-snmp.cc -./pdns/rec-snmp.hh ./pdns/rec_channel.cc ./pdns/rec_channel.hh ./pdns/rec_channel_rec.cc ./pdns/rec_control.cc ./pdns/receiver.cc +./pdns/rec-lua-conf.cc +./pdns/rec-lua-conf.hh ./pdns/recpacketcache.cc ./pdns/recpacketcache.hh +./pdns/rec-snmp.cc +./pdns/rec-snmp.hh ./pdns/recursor_cache.cc ./pdns/recursor_cache.hh ./pdns/remote_logger.cc @@ -279,10 +276,10 @@ ./pdns/saxfr.cc ./pdns/sdig.cc ./pdns/secpoll-auth.cc -./pdns/secpoll-recursor.cc -./pdns/secpoll-recursor.hh ./pdns/secpoll.cc ./pdns/secpoll.hh +./pdns/secpoll-recursor.cc +./pdns/secpoll-recursor.hh ./pdns/serialtweaker.cc ./pdns/sholder.hh ./pdns/signingpipe.cc @@ -301,11 +298,11 @@ ./pdns/ssqlite3.hh ./pdns/sstuff.hh ./pdns/standalone_fuzz_target_runner.cc -./pdns/stat_t.hh ./pdns/statbag.cc ./pdns/statbag.hh ./pdns/statnode.cc ./pdns/statnode.hh +./pdns/stat_t.hh ./pdns/stubquery.cc ./pdns/stubresolver.cc ./pdns/svc-records.cc @@ -322,13 +319,13 @@ ./pdns/test-common.hh ./pdns/test-digests_hh.cc ./pdns/test-distributor_hh.cc -./pdns/test-dns_random_hh.cc ./pdns/test-dnscrypt_cc.cc ./pdns/test-dnsdist_cc.cc ./pdns/test-dnsdistpacketcache_cc.cc ./pdns/test-dnsname_cc.cc ./pdns/test-dnsparser_cc.cc ./pdns/test-dnsparser_hh.cc +./pdns/test-dns_random_hh.cc ./pdns/test-dnsrecordcontent.cc ./pdns/test-dnsrecords_cc.cc ./pdns/test-dnswriter_cc.cc @@ -345,6 +342,7 @@ ./pdns/test-proxy_protocol_cc.cc ./pdns/test-rcpgenerator_cc.cc ./pdns/test-recpacketcache_cc.cc +./pdns/testrunner.cc ./pdns/test-sha_hh.cc ./pdns/test-sholder_hh.cc ./pdns/test-signers.cc @@ -354,7 +352,6 @@ ./pdns/test-tsig.cc ./pdns/test-ueberbackend_cc.cc ./pdns/test-zoneparser_tng_cc.cc -./pdns/testrunner.cc ./pdns/threadname.cc ./pdns/tkey.cc ./pdns/toysdig.cc @@ -371,10 +368,10 @@ ./pdns/unix_utility.cc ./pdns/utility.hh ./pdns/uuid-utils.cc -./pdns/validate-recursor.cc -./pdns/validate-recursor.hh ./pdns/validate.cc ./pdns/validate.hh +./pdns/validate-recursor.cc +./pdns/validate-recursor.hh ./pdns/version.cc ./pdns/version.hh ./pdns/webserver.cc diff --git a/pdns/lua-recursor4-ffi.hh b/pdns/lua-recursor4-ffi.hh index 30ca676098..bffc9618f7 100644 --- a/pdns/lua-recursor4-ffi.hh +++ b/pdns/lua-recursor4-ffi.hh @@ -20,18 +20,21 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -extern "C" { +extern "C" +{ typedef struct pdns_ffi_param pdns_ffi_param_t; - typedef struct pdns_ednsoption { - uint16_t optionCode; - uint16_t len; + typedef struct pdns_ednsoption + { + uint16_t optionCode; + uint16_t len; const void* data; } pdns_ednsoption_t; - typedef struct pdns_proxyprotocol_value { - uint8_t type; - uint16_t len; + typedef struct pdns_proxyprotocol_value + { + uint8_t type; + uint16_t len; const void* data; } pdns_proxyprotocol_value_t; @@ -42,48 +45,48 @@ extern "C" { additional = 3 } pdns_record_place_t; - const char* pdns_ffi_param_get_qname(pdns_ffi_param_t* ref) __attribute__ ((visibility ("default"))); - void pdns_ffi_param_get_qname_raw(pdns_ffi_param_t* ref, const char** qname, size_t* qnameSize) __attribute__ ((visibility ("default"))); - uint16_t pdns_ffi_param_get_qtype(const pdns_ffi_param_t* ref) __attribute__ ((visibility ("default"))); - const char* pdns_ffi_param_get_remote(pdns_ffi_param_t* ref) __attribute__ ((visibility ("default"))); - void pdns_ffi_param_get_remote_raw(pdns_ffi_param_t* ref, const void** addr, size_t* addrSize) __attribute__ ((visibility ("default"))); - uint16_t pdns_ffi_param_get_remote_port(const pdns_ffi_param_t* ref) __attribute__ ((visibility ("default"))); - const char* pdns_ffi_param_get_local(pdns_ffi_param_t* ref) __attribute__ ((visibility ("default"))); - void pdns_ffi_param_get_local_raw(pdns_ffi_param_t* ref, const void** addr, size_t* addrSize) __attribute__ ((visibility ("default"))); - uint16_t pdns_ffi_param_get_local_port(const pdns_ffi_param_t* ref) __attribute__ ((visibility ("default"))); - const char* pdns_ffi_param_get_edns_cs(pdns_ffi_param_t* ref) __attribute__ ((visibility ("default"))); - void pdns_ffi_param_get_edns_cs_raw(pdns_ffi_param_t* ref, const void** net, size_t* netSize) __attribute__ ((visibility ("default"))); - uint8_t pdns_ffi_param_get_edns_cs_source_mask(const pdns_ffi_param_t* ref) __attribute__ ((visibility ("default"))); + const char* pdns_ffi_param_get_qname(pdns_ffi_param_t* ref) __attribute__((visibility("default"))); + void pdns_ffi_param_get_qname_raw(pdns_ffi_param_t* ref, const char** qname, size_t* qnameSize) __attribute__((visibility("default"))); + uint16_t pdns_ffi_param_get_qtype(const pdns_ffi_param_t* ref) __attribute__((visibility("default"))); + const char* pdns_ffi_param_get_remote(pdns_ffi_param_t* ref) __attribute__((visibility("default"))); + void pdns_ffi_param_get_remote_raw(pdns_ffi_param_t* ref, const void** addr, size_t* addrSize) __attribute__((visibility("default"))); + uint16_t pdns_ffi_param_get_remote_port(const pdns_ffi_param_t* ref) __attribute__((visibility("default"))); + const char* pdns_ffi_param_get_local(pdns_ffi_param_t* ref) __attribute__((visibility("default"))); + void pdns_ffi_param_get_local_raw(pdns_ffi_param_t* ref, const void** addr, size_t* addrSize) __attribute__((visibility("default"))); + uint16_t pdns_ffi_param_get_local_port(const pdns_ffi_param_t* ref) __attribute__((visibility("default"))); + const char* pdns_ffi_param_get_edns_cs(pdns_ffi_param_t* ref) __attribute__((visibility("default"))); + void pdns_ffi_param_get_edns_cs_raw(pdns_ffi_param_t* ref, const void** net, size_t* netSize) __attribute__((visibility("default"))); + uint8_t pdns_ffi_param_get_edns_cs_source_mask(const pdns_ffi_param_t* ref) __attribute__((visibility("default"))); // returns the length of the resulting 'out' array. 'out' is not set if the length is 0 - size_t pdns_ffi_param_get_edns_options(pdns_ffi_param_t* ref, const pdns_ednsoption_t** out) __attribute__ ((visibility ("default"))); - size_t pdns_ffi_param_get_edns_options_by_code(pdns_ffi_param_t* ref, uint16_t optionCode, const pdns_ednsoption_t** out) __attribute__ ((visibility ("default"))); + size_t pdns_ffi_param_get_edns_options(pdns_ffi_param_t* ref, const pdns_ednsoption_t** out) __attribute__((visibility("default"))); + size_t pdns_ffi_param_get_edns_options_by_code(pdns_ffi_param_t* ref, uint16_t optionCode, const pdns_ednsoption_t** out) __attribute__((visibility("default"))); // returns the length of the resulting 'out' array. 'out' is not set if the length is 0 - size_t pdns_ffi_param_get_proxy_protocol_values(pdns_ffi_param_t* ref, const pdns_proxyprotocol_value_t** out) __attribute__ ((visibility ("default"))); + size_t pdns_ffi_param_get_proxy_protocol_values(pdns_ffi_param_t* ref, const pdns_proxyprotocol_value_t** out) __attribute__((visibility("default"))); + + void pdns_ffi_param_set_tag(pdns_ffi_param_t* ref, unsigned int tag) __attribute__((visibility("default"))); + void pdns_ffi_param_add_policytag(pdns_ffi_param_t* ref, const char* name) __attribute__((visibility("default"))); + void pdns_ffi_param_set_requestorid(pdns_ffi_param_t* ref, const char* name) __attribute__((visibility("default"))); + void pdns_ffi_param_set_devicename(pdns_ffi_param_t* ref, const char* name) __attribute__((visibility("default"))); + void pdns_ffi_param_set_deviceid(pdns_ffi_param_t* ref, size_t len, const void* name) __attribute__((visibility("default"))); + void pdns_ffi_param_set_routingtag(pdns_ffi_param_t* ref, const char* name) __attribute__((visibility("default"))); - void pdns_ffi_param_set_tag(pdns_ffi_param_t* ref, unsigned int tag) __attribute__ ((visibility ("default"))); - void pdns_ffi_param_add_policytag(pdns_ffi_param_t *ref, const char* name) __attribute__ ((visibility ("default"))); - void pdns_ffi_param_set_requestorid(pdns_ffi_param_t* ref, const char* name) __attribute__ ((visibility ("default"))); - void pdns_ffi_param_set_devicename(pdns_ffi_param_t* ref, const char* name) __attribute__ ((visibility ("default"))); - void pdns_ffi_param_set_deviceid(pdns_ffi_param_t* ref, size_t len, const void* name) __attribute__ ((visibility ("default"))); - void pdns_ffi_param_set_routingtag(pdns_ffi_param_t* ref, const char* name) __attribute__ ((visibility ("default"))); - - void pdns_ffi_param_set_variable(pdns_ffi_param_t* ref, bool variable) __attribute__ ((visibility ("default"))); - void pdns_ffi_param_set_ttl_cap(pdns_ffi_param_t* ref, uint32_t ttl) __attribute__ ((visibility ("default"))); - void pdns_ffi_param_set_log_query(pdns_ffi_param_t* ref, bool logQuery) __attribute__ ((visibility ("default"))); - void pdns_ffi_param_set_log_response(pdns_ffi_param_t* ref, bool logResponse) __attribute__ ((visibility ("default"))); - void pdns_ffi_param_set_rcode(pdns_ffi_param_t* ref, int rcode) __attribute__ ((visibility ("default"))); - void pdns_ffi_param_set_follow_cname_records(pdns_ffi_param_t* ref, bool follow) __attribute__ ((visibility ("default"))); + void pdns_ffi_param_set_variable(pdns_ffi_param_t* ref, bool variable) __attribute__((visibility("default"))); + void pdns_ffi_param_set_ttl_cap(pdns_ffi_param_t* ref, uint32_t ttl) __attribute__((visibility("default"))); + void pdns_ffi_param_set_log_query(pdns_ffi_param_t* ref, bool logQuery) __attribute__((visibility("default"))); + void pdns_ffi_param_set_log_response(pdns_ffi_param_t* ref, bool logResponse) __attribute__((visibility("default"))); + void pdns_ffi_param_set_rcode(pdns_ffi_param_t* ref, int rcode) __attribute__((visibility("default"))); + void pdns_ffi_param_set_follow_cname_records(pdns_ffi_param_t* ref, bool follow) __attribute__((visibility("default"))); - void pdns_ffi_param_set_extended_error_code(pdns_ffi_param_t* ref, uint16_t code) __attribute__ ((visibility ("default"))); - void pdns_ffi_param_set_extended_error_extra(pdns_ffi_param_t* ref, size_t len, const char* extra) __attribute__ ((visibility ("default"))); + void pdns_ffi_param_set_extended_error_code(pdns_ffi_param_t* ref, uint16_t code) __attribute__((visibility("default"))); + void pdns_ffi_param_set_extended_error_extra(pdns_ffi_param_t* ref, size_t len, const char* extra) __attribute__((visibility("default"))); /* returns true if the record was correctly added, false if something went wrong. Passing a NULL pointer to 'name' will result in the qname being used for the record owner name. */ - 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) __attribute__ ((visibility ("default"))); + 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) __attribute__((visibility("default"))); - void pdns_ffi_param_set_padding_disabled(pdns_ffi_param_t* ref, bool disabled) __attribute__ ((visibility ("default"))); - void pdns_ffi_param_add_meta_single_string_kv(pdns_ffi_param_t *ref, const char* key, const char* val) __attribute__ ((visibility ("default"))); - void pdns_ffi_param_add_meta_single_int64_kv(pdns_ffi_param_t *ref, const char* key, int64_t val) __attribute__ ((visibility ("default"))); + void pdns_ffi_param_set_padding_disabled(pdns_ffi_param_t* ref, bool disabled) __attribute__((visibility("default"))); + void pdns_ffi_param_add_meta_single_string_kv(pdns_ffi_param_t* ref, const char* key, const char* val) __attribute__((visibility("default"))); + void pdns_ffi_param_add_meta_single_int64_kv(pdns_ffi_param_t* ref, const char* key, int64_t val) __attribute__((visibility("default"))); } diff --git a/pdns/lua-recursor4.cc b/pdns/lua-recursor4.cc index c410cc1809..e8719864c4 100644 --- a/pdns/lua-recursor4.cc +++ b/pdns/lua-recursor4.cc @@ -60,33 +60,33 @@ bool RecursorLua4::DNSQuestion::getEDNSFlag(string flag) const return false; } -vector > RecursorLua4::DNSQuestion::getEDNSOptions() const +vector> RecursorLua4::DNSQuestion::getEDNSOptions() const { - if(ednsOptions) + if (ednsOptions) return *ednsOptions; else - return vector>(); + return vector>(); } -boost::optional RecursorLua4::DNSQuestion::getEDNSOption(uint16_t code) const +boost::optional RecursorLua4::DNSQuestion::getEDNSOption(uint16_t code) const { - if(ednsOptions) - for(const auto& o : *ednsOptions) - if(o.first==code) + if (ednsOptions) + for (const auto& o : *ednsOptions) + if (o.first == code) return o.second; - + return boost::optional(); } -boost::optional RecursorLua4::DNSQuestion::getEDNSSubnet() const +boost::optional RecursorLua4::DNSQuestion::getEDNSSubnet() const { - if(ednsOptions) { - for(const auto& o : *ednsOptions) { - if(o.first==EDNSOptionCode::ECS) { + if (ednsOptions) { + for (const auto& o : *ednsOptions) { + if (o.first == EDNSOptionCode::ECS) { EDNSSubnetOpts eso; - if(getEDNSSubnetOptsFromString(o.second, &eso)) + if (getEDNSSubnetOptsFromString(o.second, &eso)) return eso.source; - else + else break; } } @@ -101,27 +101,27 @@ std::vector> RecursorLua4::DNSQuestion::getPr result.reserve(proxyProtocolValues->size()); int idx = 1; - for (const auto& value: *proxyProtocolValues) { - result.push_back({ idx++, value }); + for (const auto& value : *proxyProtocolValues) { + result.push_back({idx++, value}); } } return result; } -vector > RecursorLua4::DNSQuestion::getRecords() const +vector> RecursorLua4::DNSQuestion::getRecords() const { - vector > ret; - int num=1; - for(const auto& r : records) { + vector> ret; + int num = 1; + for (const auto& r : records) { ret.push_back({num++, r}); } return ret; } -void RecursorLua4::DNSQuestion::setRecords(const vector >& recs) +void RecursorLua4::DNSQuestion::setRecords(const vector>& recs) { records.clear(); - for(const auto& p : recs) { + for (const auto& p : recs) { records.push_back(p.second); } } @@ -129,8 +129,8 @@ void RecursorLua4::DNSQuestion::setRecords(const vector >& void RecursorLua4::DNSQuestion::addRecord(uint16_t type, const std::string& content, DNSResourceRecord::Place place, boost::optional ttl, boost::optional name) { DNSRecord dr; - dr.d_name=name ? DNSName(*name) : qname; - dr.d_ttl=ttl.get_value_or(3600); + dr.d_name = name ? DNSName(*name) : qname; + dr.d_ttl = ttl.get_value_or(3600); dr.d_type = type; dr.d_place = place; dr.d_content = DNSRecordContent::mastermake(type, QClass::IN, content); @@ -146,25 +146,36 @@ struct DynMetric { std::atomic* ptr; void inc() { (*ptr)++; } - void incBy(unsigned int by) { (*ptr)+= by; } + void incBy(unsigned int by) { (*ptr) += by; } unsigned long get() { return *ptr; } - void set(unsigned long val) { *ptr =val; } + void set(unsigned long val) { *ptr = val; } }; void RecursorLua4::postPrepareContext() { - d_lw->registerMember("qname", [](const DNSQuestion& dq) -> const DNSName& { return dq.qname; }, [](DNSQuestion& dq, const DNSName& newName) { (void) newName; }); - d_lw->registerMember("qtype", [](const DNSQuestion& dq) -> uint16_t { return dq.qtype; }, [](DNSQuestion& dq, uint16_t newType) { (void) newType; }); - d_lw->registerMember("isTcp", [](const DNSQuestion& dq) -> bool { return dq.isTcp; }, [](DNSQuestion& dq, bool newTcp) { (void) newTcp; }); - d_lw->registerMember("localaddr", [](const DNSQuestion& dq) -> const ComboAddress& { return dq.local; }, [](DNSQuestion& dq, const ComboAddress& newLocal) { (void) newLocal; }); - d_lw->registerMember("remoteaddr", [](const DNSQuestion& dq) -> const ComboAddress& { return dq.remote; }, [](DNSQuestion& dq, const ComboAddress& newRemote) { (void) newRemote; }); - d_lw->registerMember("validationState", [](const DNSQuestion& dq) -> uint8_t { return (vStateIsBogus(dq.validationState) ? /* in order not to break older scripts */ static_cast(255) : static_cast(dq.validationState)); }, [](DNSQuestion& dq, uint8_t newState) { (void) newState; }); - d_lw->registerMember("detailedValidationState", [](const DNSQuestion& dq) -> vState { return dq.validationState; }, [](DNSQuestion& dq, vState newState) { (void) newState; }); - - d_lw->registerMember("variable", [](const DNSQuestion& dq) -> bool { return dq.variable; }, [](DNSQuestion& dq, bool newVariable) { dq.variable = newVariable; }); - d_lw->registerMember("wantsRPZ", [](const DNSQuestion& dq) -> bool { return dq.wantsRPZ; }, [](DNSQuestion& dq, bool newWantsRPZ) { dq.wantsRPZ = newWantsRPZ; }); - d_lw->registerMember("logResponse", [](const DNSQuestion& dq) -> bool { return dq.logResponse; }, [](DNSQuestion& dq, bool newLogResponse) { dq.logResponse = newLogResponse; }); - d_lw->registerMember("addPaddingToResponse", [](const DNSQuestion& dq) -> bool { return dq.addPaddingToResponse; }, [](DNSQuestion& dq, bool add) { dq.addPaddingToResponse = add; }); + d_lw->registerMember( + "qname", [](const DNSQuestion& dq) -> const DNSName& { return dq.qname; }, [](DNSQuestion& dq, const DNSName& newName) { (void)newName; }); + d_lw->registerMember( + "qtype", [](const DNSQuestion& dq) -> uint16_t { return dq.qtype; }, [](DNSQuestion& dq, uint16_t newType) { (void)newType; }); + d_lw->registerMember( + "isTcp", [](const DNSQuestion& dq) -> bool { return dq.isTcp; }, [](DNSQuestion& dq, bool newTcp) { (void)newTcp; }); + d_lw->registerMember( + "localaddr", [](const DNSQuestion& dq) -> const ComboAddress& { return dq.local; }, [](DNSQuestion& dq, const ComboAddress& newLocal) { (void)newLocal; }); + d_lw->registerMember( + "remoteaddr", [](const DNSQuestion& dq) -> const ComboAddress& { return dq.remote; }, [](DNSQuestion& dq, const ComboAddress& newRemote) { (void)newRemote; }); + d_lw->registerMember( + "validationState", [](const DNSQuestion& dq) -> uint8_t { return (vStateIsBogus(dq.validationState) ? /* in order not to break older scripts */ static_cast(255) : static_cast(dq.validationState)); }, [](DNSQuestion& dq, uint8_t newState) { (void)newState; }); + d_lw->registerMember( + "detailedValidationState", [](const DNSQuestion& dq) -> vState { return dq.validationState; }, [](DNSQuestion& dq, vState newState) { (void)newState; }); + + d_lw->registerMember( + "variable", [](const DNSQuestion& dq) -> bool { return dq.variable; }, [](DNSQuestion& dq, bool newVariable) { dq.variable = newVariable; }); + d_lw->registerMember( + "wantsRPZ", [](const DNSQuestion& dq) -> bool { return dq.wantsRPZ; }, [](DNSQuestion& dq, bool newWantsRPZ) { dq.wantsRPZ = newWantsRPZ; }); + d_lw->registerMember( + "logResponse", [](const DNSQuestion& dq) -> bool { return dq.logResponse; }, [](DNSQuestion& dq, bool newLogResponse) { dq.logResponse = newLogResponse; }); + d_lw->registerMember( + "addPaddingToResponse", [](const DNSQuestion& dq) -> bool { return dq.addPaddingToResponse; }, [](DNSQuestion& dq, bool add) { dq.addPaddingToResponse = add; }); d_lw->registerMember("rcode", &DNSQuestion::rcode); d_lw->registerMember("tag", &DNSQuestion::tag); @@ -175,23 +186,23 @@ void RecursorLua4::postPrepareContext() d_lw->registerMember("followupPrefix", &DNSQuestion::followupPrefix); d_lw->registerMember("followupName", &DNSQuestion::followupName); d_lw->registerMember("data", &DNSQuestion::data); - d_lw->registerMember("extendedErrorCode", [](const DNSQuestion& dq) -> uint16_t { + d_lw->registerMember( + "extendedErrorCode", [](const DNSQuestion& dq) -> uint16_t { if (dq.extendedErrorCode && *dq.extendedErrorCode) { return *(*dq.extendedErrorCode); } - return 0; - }, + return 0; }, [](DNSQuestion& dq, uint16_t newCode) { if (dq.extendedErrorCode) { *dq.extendedErrorCode = newCode; } }); - d_lw->registerMember("extendedErrorExtra", [](const DNSQuestion& dq) -> std::string { + d_lw->registerMember( + "extendedErrorExtra", [](const DNSQuestion& dq) -> std::string { if (dq.extendedErrorExtra) { return *dq.extendedErrorExtra; } - return ""; - }, + return ""; }, [](DNSQuestion& dq, const std::string& newExtra) { if (dq.extendedErrorExtra) { *dq.extendedErrorExtra = newExtra; @@ -203,7 +214,8 @@ void RecursorLua4::postPrepareContext() d_lw->registerMember("udpCallback", &DNSQuestion::udpCallback); d_lw->registerMember("appliedPolicy", &DNSQuestion::appliedPolicy); - d_lw->registerMember("policyName", + d_lw->registerMember( + "policyName", [](const DNSFilterEngine::Policy& pol) -> std::string { return pol.getName(); }, @@ -215,7 +227,8 @@ void RecursorLua4::postPrepareContext() d_lw->registerMember("policyTTL", &DNSFilterEngine::Policy::d_ttl); d_lw->registerMember("policyTrigger", &DNSFilterEngine::Policy::d_trigger); d_lw->registerMember("policyHit", &DNSFilterEngine::Policy::d_hit); - d_lw->registerMember("policyCustom", + d_lw->registerMember( + "policyCustom", [](const DNSFilterEngine::Policy& pol) -> std::string { std::string result; if (pol.d_kind != DNSFilterEngine::PolicyKind::Custom) { @@ -235,8 +248,7 @@ void RecursorLua4::postPrepareContext() // Only CNAMES for now, when we ever add a d_custom_type, there will be pain pol.d_custom.clear(); pol.d_custom.push_back(DNSRecordContent::mastermake(QType::CNAME, QClass::IN, content)); - } - ); + }); d_lw->registerFunction("getDH", &DNSQuestion::getDH); d_lw->registerFunction("getEDNSOptions", &DNSQuestion::getEDNSOptions); d_lw->registerFunction("getEDNSOption", &DNSQuestion::getEDNSOption); @@ -251,148 +263,133 @@ void RecursorLua4::postPrepareContext() d_lw->registerMember("place", &DNSRecord::d_place); d_lw->registerMember("size", &EDNSOptionViewValue::size); - d_lw->registerFunction("getContent", [](const EDNSOptionViewValue& value) { return std::string(value.content, value.size); }); - d_lw->registerFunction("count", [](const EDNSOptionView& option) { return option.values.size(); }); - d_lw->registerFunction(EDNSOptionView::*)()>("getValues", [] (const EDNSOptionView& option) { - std::vector values; - for (const auto& value : option.values) { - values.push_back(std::string(value.content, value.size)); - } - return values; - }); + d_lw->registerFunction("getContent", [](const EDNSOptionViewValue& value) { return std::string(value.content, value.size); }); + d_lw->registerFunction("count", [](const EDNSOptionView& option) { return option.values.size(); }); + d_lw->registerFunction (EDNSOptionView::*)()>("getValues", [](const EDNSOptionView& option) { + std::vector values; + for (const auto& value : option.values) { + values.push_back(std::string(value.content, value.size)); + } + return values; + }); /* pre 4.2 API compatibility, when we had only one value for a given EDNS option */ - d_lw->registerMember("size", [](const EDNSOptionView& option) -> uint16_t { + d_lw->registerMember( + "size", [](const EDNSOptionView& option) -> uint16_t { uint16_t result = 0; if (!option.values.empty()) { result = option.values.at(0).size; } - return result; - }, - [](EDNSOptionView& option, uint16_t newSize) { (void) newSize; }); - d_lw->registerFunction("getContent", [](const EDNSOptionView& option) { + return result; }, + [](EDNSOptionView& option, uint16_t newSize) { (void)newSize; }); + d_lw->registerFunction("getContent", [](const EDNSOptionView& option) { if (option.values.empty()) { return std::string(); } return std::string(option.values.at(0).content, option.values.at(0).size); }); - d_lw->registerFunction("getContent", [](const DNSRecord& dr) { return dr.d_content->getZoneRepresentation(); }); - d_lw->registerFunction(DNSRecord::*)()>("getCA", [](const DNSRecord& dr) { - boost::optional ret; + d_lw->registerFunction("getContent", [](const DNSRecord& dr) { return dr.d_content->getZoneRepresentation(); }); + d_lw->registerFunction (DNSRecord::*)()>("getCA", [](const DNSRecord& dr) { + boost::optional ret; - if(auto rec = std::dynamic_pointer_cast(dr.d_content)) - ret=rec->getCA(53); - else if(auto aaaarec = std::dynamic_pointer_cast(dr.d_content)) - ret=aaaarec->getCA(53); - return ret; - }); + if (auto rec = std::dynamic_pointer_cast(dr.d_content)) + ret = rec->getCA(53); + else if (auto aaaarec = std::dynamic_pointer_cast(dr.d_content)) + ret = aaaarec->getCA(53); + return ret; + }); d_lw->registerFunction("getContent", [](const ProxyProtocolValue& value) { return value.content; }); d_lw->registerFunction("getType", [](const ProxyProtocolValue& value) { return value.type; }); - d_lw->registerFunction("changeContent", [](DNSRecord& dr, const std::string& newContent) { dr.d_content = DNSRecordContent::mastermake(dr.d_type, QClass::IN, newContent); }); + d_lw->registerFunction("changeContent", [](DNSRecord& dr, const std::string& newContent) { dr.d_content = DNSRecordContent::mastermake(dr.d_type, QClass::IN, newContent); }); d_lw->registerFunction("addAnswer", &DNSQuestion::addAnswer); d_lw->registerFunction("addRecord", &DNSQuestion::addRecord); d_lw->registerFunction("getRecords", &DNSQuestion::getRecords); d_lw->registerFunction("setRecords", &DNSQuestion::setRecords); - d_lw->registerFunction("addPolicyTag", [](DNSQuestion& dq, const std::string& tag) { if (dq.policyTags) { dq.policyTags->insert(tag); } }); - d_lw->registerFunction >&)>("setPolicyTags", [](DNSQuestion& dq, const std::vector >& tags) { - if (dq.policyTags) { - dq.policyTags->clear(); - dq.policyTags->reserve(tags.size()); - for (const auto& tag : tags) { - dq.policyTags->insert(tag.second); - } + d_lw->registerFunction("addPolicyTag", [](DNSQuestion& dq, const std::string& tag) { if (dq.policyTags) { dq.policyTags->insert(tag); } }); + d_lw->registerFunction>&)>("setPolicyTags", [](DNSQuestion& dq, const std::vector>& tags) { + if (dq.policyTags) { + dq.policyTags->clear(); + dq.policyTags->reserve(tags.size()); + for (const auto& tag : tags) { + dq.policyTags->insert(tag.second); } - }); - d_lw->registerFunction >(DNSQuestion::*)()>("getPolicyTags", [](const DNSQuestion& dq) { - std::vector > ret; - if (dq.policyTags) { - int count = 1; - ret.reserve(dq.policyTags->size()); - for (const auto& tag : *dq.policyTags) { - ret.push_back({count++, tag}); - } + } + }); + d_lw->registerFunction> (DNSQuestion::*)()>("getPolicyTags", [](const DNSQuestion& dq) { + std::vector> ret; + if (dq.policyTags) { + int count = 1; + ret.reserve(dq.policyTags->size()); + for (const auto& tag : *dq.policyTags) { + ret.push_back({count++, tag}); } - return ret; - }); + } + return ret; + }); - d_lw->registerFunction("discardPolicy", [](DNSQuestion& dq, const std::string& policy) { - if (dq.discardedPolicies) { - (*dq.discardedPolicies)[policy] = true; - } - }); + d_lw->registerFunction("discardPolicy", [](DNSQuestion& dq, const std::string& policy) { + if (dq.discardedPolicies) { + (*dq.discardedPolicies)[policy] = true; + } + }); d_lw->writeFunction("newDS", []() { return SuffixMatchNode(); }); - d_lw->registerFunction > >)>( + d_lw->registerFunction>>)>( "add", - [](SuffixMatchNode&smn, const boost::variant > >& in){ + [](SuffixMatchNode& smn, const boost::variant>>& in) { try { - if(auto s = boost::get(&in)) { + if (auto s = boost::get(&in)) { smn.add(DNSName(*s)); } - else if(auto v = boost::get > >(&in)) { - for(const auto& entry : *v) + else if (auto v = boost::get>>(&in)) { + for (const auto& entry : *v) smn.add(DNSName(entry.second)); } else { smn.add(boost::get(in)); } } - catch(std::exception& e) { - g_log <registerFunction("check",(bool (SuffixMatchNode::*)(const DNSName&) const) &SuffixMatchNode::check); - d_lw->registerFunction("toString",(string (SuffixMatchNode::*)() const) &SuffixMatchNode::toString); - - d_pd.push_back({"policykinds", in_t { - {"NoAction", (int)DNSFilterEngine::PolicyKind::NoAction}, - {"Drop", (int)DNSFilterEngine::PolicyKind::Drop }, - {"NXDOMAIN", (int)DNSFilterEngine::PolicyKind::NXDOMAIN}, - {"NODATA", (int)DNSFilterEngine::PolicyKind::NODATA }, - {"Truncate", (int)DNSFilterEngine::PolicyKind::Truncate}, - {"Custom", (int)DNSFilterEngine::PolicyKind::Custom } - }}); - - d_pd.push_back({"policytypes", in_t { - {"None", (int)DNSFilterEngine::PolicyType::None }, - {"QName", (int)DNSFilterEngine::PolicyType::QName }, - {"ClientIP", (int)DNSFilterEngine::PolicyType::ClientIP }, - {"ResponseIP", (int)DNSFilterEngine::PolicyType::ResponseIP }, - {"NSDName", (int)DNSFilterEngine::PolicyType::NSDName }, - {"NSIP", (int)DNSFilterEngine::PolicyType::NSIP } - }}); - - for(const auto& n : QType::names) + }); + + d_lw->registerFunction("check", (bool (SuffixMatchNode::*)(const DNSName&) const) & SuffixMatchNode::check); + d_lw->registerFunction("toString", (string(SuffixMatchNode::*)() const) & SuffixMatchNode::toString); + + d_pd.push_back({"policykinds", in_t{{"NoAction", (int)DNSFilterEngine::PolicyKind::NoAction}, {"Drop", (int)DNSFilterEngine::PolicyKind::Drop}, {"NXDOMAIN", (int)DNSFilterEngine::PolicyKind::NXDOMAIN}, {"NODATA", (int)DNSFilterEngine::PolicyKind::NODATA}, {"Truncate", (int)DNSFilterEngine::PolicyKind::Truncate}, {"Custom", (int)DNSFilterEngine::PolicyKind::Custom}}}); + + d_pd.push_back({"policytypes", in_t{{"None", (int)DNSFilterEngine::PolicyType::None}, {"QName", (int)DNSFilterEngine::PolicyType::QName}, {"ClientIP", (int)DNSFilterEngine::PolicyType::ClientIP}, {"ResponseIP", (int)DNSFilterEngine::PolicyType::ResponseIP}, {"NSDName", (int)DNSFilterEngine::PolicyType::NSDName}, {"NSIP", (int)DNSFilterEngine::PolicyType::NSIP}}}); + + for (const auto& n : QType::names) d_pd.push_back({n.first, n.second}); d_pd.push_back({"validationstates", in_t{ - {"Indeterminate", static_cast(vState::Indeterminate) }, - {"BogusNoValidDNSKEY", static_cast(vState::BogusNoValidDNSKEY) }, - {"BogusInvalidDenial", static_cast(vState::BogusInvalidDenial) }, - {"BogusUnableToGetDSs", static_cast(vState::BogusUnableToGetDSs) }, - {"BogusUnableToGetDNSKEYs", static_cast(vState::BogusUnableToGetDNSKEYs) }, - {"BogusSelfSignedDS", static_cast(vState::BogusSelfSignedDS) }, - {"BogusNoRRSIG", static_cast(vState::BogusNoRRSIG) }, - {"BogusNoValidRRSIG", static_cast(vState::BogusNoValidRRSIG) }, - {"BogusMissingNegativeIndication", static_cast(vState::BogusMissingNegativeIndication) }, - {"BogusSignatureNotYetValid", static_cast(vState::BogusSignatureNotYetValid)}, - {"BogusSignatureExpired", static_cast(vState::BogusSignatureExpired)}, - {"BogusUnsupportedDNSKEYAlgo", static_cast(vState::BogusUnsupportedDNSKEYAlgo)}, - {"BogusUnsupportedDSDigestType", static_cast(vState::BogusUnsupportedDSDigestType)}, - {"BogusNoZoneKeyBitSet", static_cast(vState::BogusNoZoneKeyBitSet)}, - {"BogusRevokedDNSKEY", static_cast(vState::BogusRevokedDNSKEY)}, - {"BogusInvalidDNSKEYProtocol", static_cast(vState::BogusInvalidDNSKEYProtocol)}, - {"Insecure", static_cast(vState::Insecure) }, - {"Secure", static_cast(vState::Secure) }, - /* in order not to break compatibility with older scripts: */ - {"Bogus", static_cast(255) }, - }}); + {"Indeterminate", static_cast(vState::Indeterminate)}, + {"BogusNoValidDNSKEY", static_cast(vState::BogusNoValidDNSKEY)}, + {"BogusInvalidDenial", static_cast(vState::BogusInvalidDenial)}, + {"BogusUnableToGetDSs", static_cast(vState::BogusUnableToGetDSs)}, + {"BogusUnableToGetDNSKEYs", static_cast(vState::BogusUnableToGetDNSKEYs)}, + {"BogusSelfSignedDS", static_cast(vState::BogusSelfSignedDS)}, + {"BogusNoRRSIG", static_cast(vState::BogusNoRRSIG)}, + {"BogusNoValidRRSIG", static_cast(vState::BogusNoValidRRSIG)}, + {"BogusMissingNegativeIndication", static_cast(vState::BogusMissingNegativeIndication)}, + {"BogusSignatureNotYetValid", static_cast(vState::BogusSignatureNotYetValid)}, + {"BogusSignatureExpired", static_cast(vState::BogusSignatureExpired)}, + {"BogusUnsupportedDNSKEYAlgo", static_cast(vState::BogusUnsupportedDNSKEYAlgo)}, + {"BogusUnsupportedDSDigestType", static_cast(vState::BogusUnsupportedDSDigestType)}, + {"BogusNoZoneKeyBitSet", static_cast(vState::BogusNoZoneKeyBitSet)}, + {"BogusRevokedDNSKEY", static_cast(vState::BogusRevokedDNSKEY)}, + {"BogusInvalidDNSKEYProtocol", static_cast(vState::BogusInvalidDNSKEYProtocol)}, + {"Insecure", static_cast(vState::Insecure)}, + {"Secure", static_cast(vState::Secure)}, + /* in order not to break compatibility with older scripts: */ + {"Bogus", static_cast(255)}, + }}); d_lw->writeFunction("isValidationStateBogus", [](vState state) { return vStateIsBogus(state); @@ -402,7 +399,7 @@ void RecursorLua4::postPrepareContext() d_lw->writeFunction("getMetric", [](const std::string& str, boost::optional prometheusName) { return DynMetric{getDynMetric(str, prometheusName ? *prometheusName : "")}; - }); + }); d_lw->registerFunction("inc", &DynMetric::inc); d_lw->registerFunction("incBy", &DynMetric::incBy); @@ -410,62 +407,67 @@ void RecursorLua4::postPrepareContext() d_lw->registerFunction("get", &DynMetric::get); d_lw->writeFunction("getStat", [](const std::string& str) { - uint64_t result = 0; - boost::optional value = getStatByName(str); - if (value) { - result = *value; - } - return result; - }); + uint64_t result = 0; + boost::optional value = getStatByName(str); + if (value) { + result = *value; + } + return result; + }); d_lw->writeFunction("getRecursorThreadId", []() { - return getRecursorThreadId(); - }); + return getRecursorThreadId(); + }); d_lw->writeFunction("sendCustomSNMPTrap", [](const std::string& str) { - if (g_snmpAgent) { - g_snmpAgent->sendCustomTrap(str); - } - }); + if (g_snmpAgent) { + g_snmpAgent->sendCustomTrap(str); + } + }); - d_lw->writeFunction("getregisteredname", [](const DNSName &dname) { - return getRegisteredName(dname); + d_lw->writeFunction("getregisteredname", [](const DNSName& dname) { + return getRegisteredName(dname); }); - d_lw->registerMember("qname", [](const PolicyEvent& event) -> const DNSName& { return event.qname; }, [](PolicyEvent& event, const DNSName& newName) { (void) newName; }); - d_lw->registerMember("qtype", [](const PolicyEvent& event) -> uint16_t { return event.qtype.getCode(); }, [](PolicyEvent& event, uint16_t newType) { (void) newType; }); - d_lw->registerMember("isTcp", [](const PolicyEvent& event) -> bool { return event.isTcp; }, [](PolicyEvent& event, bool newTcp) { (void) newTcp; }); - d_lw->registerMember("remote", [](const PolicyEvent& event) -> const ComboAddress& { return event.remote; }, [](PolicyEvent& event, const ComboAddress& newRemote) { (void) newRemote; }); + d_lw->registerMember( + "qname", [](const PolicyEvent& event) -> const DNSName& { return event.qname; }, [](PolicyEvent& event, const DNSName& newName) { (void)newName; }); + d_lw->registerMember( + "qtype", [](const PolicyEvent& event) -> uint16_t { return event.qtype.getCode(); }, [](PolicyEvent& event, uint16_t newType) { (void)newType; }); + d_lw->registerMember( + "isTcp", [](const PolicyEvent& event) -> bool { return event.isTcp; }, [](PolicyEvent& event, bool newTcp) { (void)newTcp; }); + d_lw->registerMember( + "remote", [](const PolicyEvent& event) -> const ComboAddress& { return event.remote; }, [](PolicyEvent& event, const ComboAddress& newRemote) { (void)newRemote; }); d_lw->registerMember("appliedPolicy", &PolicyEvent::appliedPolicy); - d_lw->registerFunction("addPolicyTag", [](PolicyEvent& event, const std::string& tag) { if (event.policyTags) { event.policyTags->insert(tag); } }); - d_lw->registerFunction >&)>("setPolicyTags", [](PolicyEvent& event, const std::vector >& tags) { - if (event.policyTags) { - event.policyTags->clear(); - event.policyTags->reserve(tags.size()); - for (const auto& tag : tags) { - event.policyTags->insert(tag.second); - } + d_lw->registerFunction("addPolicyTag", [](PolicyEvent& event, const std::string& tag) { if (event.policyTags) { event.policyTags->insert(tag); } }); + d_lw->registerFunction>&)>("setPolicyTags", [](PolicyEvent& event, const std::vector>& tags) { + if (event.policyTags) { + event.policyTags->clear(); + event.policyTags->reserve(tags.size()); + for (const auto& tag : tags) { + event.policyTags->insert(tag.second); } - }); - d_lw->registerFunction >(PolicyEvent::*)()>("getPolicyTags", [](const PolicyEvent& event) { - std::vector > ret; - if (event.policyTags) { - int count = 1; - ret.reserve(event.policyTags->size()); - for (const auto& tag : *event.policyTags) { - ret.push_back({count++, tag}); - } + } + }); + d_lw->registerFunction> (PolicyEvent::*)()>("getPolicyTags", [](const PolicyEvent& event) { + std::vector> ret; + if (event.policyTags) { + int count = 1; + ret.reserve(event.policyTags->size()); + for (const auto& tag : *event.policyTags) { + ret.push_back({count++, tag}); } - return ret; - }); - d_lw->registerFunction("discardPolicy", [](PolicyEvent& event, const std::string& policy) { + } + return ret; + }); + d_lw->registerFunction("discardPolicy", [](PolicyEvent& event, const std::string& policy) { if (event.discardedPolicies) { (*event.discardedPolicies)[policy] = true; } }); } -void RecursorLua4::postLoad() { +void RecursorLua4::postLoad() +{ d_prerpz = d_lw->readVariable>("prerpz").get_value_or(0); d_preresolve = d_lw->readVariable>("preresolve").get_value_or(0); d_nodata = d_lw->readVariable>("nodata").get_value_or(0); @@ -481,12 +483,13 @@ void RecursorLua4::postLoad() { d_policyHitEventFilter = d_lw->readVariable>("policyEventFilter").get_value_or(0); } -void RecursorLua4::getFeatures(Features & features) { +void RecursorLua4::getFeatures(Features& features) +{ // Add key-values pairs below. // Make sure you add string values explicitly converted to string. // e.g. features.push_back(make_pair("somekey", string("stringvalue")); // Both int and double end up as a lua number type. - features.push_back(make_pair("PR8001_devicename", true)); + features.push_back(make_pair("PR8001_devicename", true)); } void RecursorLua4::maintenance() const @@ -535,7 +538,7 @@ bool RecursorLua4::preoutquery(const ComboAddress& ns, const ComboAddress& reque bool RecursorLua4::ipfilter(const ComboAddress& remote, const ComboAddress& local, const struct dnsheader& dh) const { - if(d_ipfilter) + if (d_ipfilter) return d_ipfilter(remote, local, dh); return false; // don't block } @@ -561,7 +564,7 @@ bool RecursorLua4::policyHitEventFilter(const ComboAddress& remote, const DNSNam unsigned int RecursorLua4::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& ednsOptions, bool tcp, std::string& requestorId, std::string& deviceId, std::string& deviceName, std::string& routingTag, const std::vector& proxyProtocolValues) const { - if(d_gettag) { + if (d_gettag) { std::vector> proxyProtocolValuesMap; proxyProtocolValuesMap.reserve(proxyProtocolValues.size()); int num = 1; @@ -611,7 +614,8 @@ unsigned int RecursorLua4::gettag(const ComboAddress& remote, const Netmask& edn struct pdns_ffi_param { public: - pdns_ffi_param(RecursorLua4::FFIParams& params_): params(params_) + pdns_ffi_param(RecursorLua4::FFIParams& params_) : + params(params_) { } @@ -641,12 +645,13 @@ unsigned int RecursorLua4::gettag_ffi(RecursorLua4::FFIParams& params) const bool RecursorLua4::genhook(const luacall_t& func, DNSQuestion& dq, int& ret) const { - if(!func) + if (!func) return false; if (dq.currentRecords) { dq.records = *dq.currentRecords; - } else { + } + else { dq.records.clear(); } @@ -658,32 +663,32 @@ bool RecursorLua4::genhook(const luacall_t& func, DNSQuestion& dq, int& ret) con dq.udpCallback.clear(); dq.rcode = ret; - bool handled=func(&dq); - - if(handled) { -loop:; - ret=dq.rcode; - - if(!dq.followupFunction.empty()) { - if(dq.followupFunction=="followCNAMERecords") { + bool handled = func(&dq); + + if (handled) { + loop:; + ret = dq.rcode; + + if (!dq.followupFunction.empty()) { + if (dq.followupFunction == "followCNAMERecords") { ret = followCNAMERecords(dq.records, QType(dq.qtype), ret); } - else if(dq.followupFunction=="getFakeAAAARecords") { - ret=getFakeAAAARecords(dq.followupName, ComboAddress(dq.followupPrefix), dq.records); + else if (dq.followupFunction == "getFakeAAAARecords") { + ret = getFakeAAAARecords(dq.followupName, ComboAddress(dq.followupPrefix), dq.records); } - else if(dq.followupFunction=="getFakePTRRecords") { - ret=getFakePTRRecords(dq.followupName, dq.records); + else if (dq.followupFunction == "getFakePTRRecords") { + ret = getFakePTRRecords(dq.followupName, dq.records); } - else if(dq.followupFunction=="udpQueryResponse") { + else if (dq.followupFunction == "udpQueryResponse") { PacketBuffer p = GenUDPQueryResponse(dq.udpQueryDest, dq.udpQuery); dq.udpAnswer = std::string(reinterpret_cast(p.data()), p.size()); auto cbFunc = d_lw->readVariable>(dq.udpCallback).get_value_or(0); - if(!cbFunc) { - g_log<params.tag = tag; } -void pdns_ffi_param_add_policytag(pdns_ffi_param_t *ref, const char* name) +void pdns_ffi_param_add_policytag(pdns_ffi_param_t* ref, const char* name) { ref->params.policyTags.insert(std::string(name)); } @@ -952,7 +957,7 @@ void pdns_ffi_param_set_extended_error_extra(pdns_ffi_param_t* ref, size_t 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) +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; @@ -967,7 +972,7 @@ bool pdns_ffi_param_add_record(pdns_ffi_param_t *ref, const char* name, uint16_t return true; } catch (const std::exception& e) { - g_log< -struct LuaContext::Pusher { - static const int minSize = 1; - static const int maxSize = 1; - - static PushedObject push(lua_State* state, pdns_ffi_param* ptr) noexcept { - lua_pushlightuserdata(state, ptr); - return PushedObject{state, 1}; - } +template <> +struct LuaContext::Pusher +{ + static const int minSize = 1; + static const int maxSize = 1; + + static PushedObject push(lua_State* state, pdns_ffi_param* ptr) noexcept + { + lua_pushlightuserdata(state, ptr); + return PushedObject{state, 1}; + } }; class RecursorLua4 : public BaseLua4 @@ -63,7 +65,8 @@ public: struct DNSQuestion { - DNSQuestion(const ComboAddress& rem, const ComboAddress& loc, const DNSName& query, uint16_t type, bool tcp, bool& variable_, bool& wantsRPZ_, bool& logResponse_, bool& addPaddingToResponse_): qname(query), qtype(type), local(loc), remote(rem), isTcp(tcp), variable(variable_), wantsRPZ(wantsRPZ_), logResponse(logResponse_), addPaddingToResponse(addPaddingToResponse_) + DNSQuestion(const ComboAddress& rem, const ComboAddress& loc, const DNSName& query, uint16_t type, bool tcp, bool& variable_, bool& wantsRPZ_, bool& logResponse_, bool& addPaddingToResponse_) : + qname(query), qtype(type), local(loc), remote(rem), isTcp(tcp), variable(variable_), wantsRPZ(wantsRPZ_), logResponse(logResponse_), addPaddingToResponse(addPaddingToResponse_) { } const DNSName& qname; @@ -93,15 +96,15 @@ public: void addAnswer(uint16_t type, const std::string& content, boost::optional ttl, boost::optional name); void addRecord(uint16_t type, const std::string& content, DNSResourceRecord::Place place, boost::optional ttl, boost::optional name); - vector > getRecords() const; + vector> getRecords() const; boost::optional getDH() const; - vector > getEDNSOptions() const; + vector> getEDNSOptions() const; boost::optional getEDNSOption(uint16_t code) const; boost::optional getEDNSSubnet() const; std::vector> getProxyProtocolValues() const; vector getEDNSFlags() const; bool getEDNSFlag(string flag) const; - void setRecords(const vector >& records); + void setRecords(const vector>& records); int rcode{0}; // struct dnsheader, packet length would be great @@ -121,7 +124,8 @@ public: struct PolicyEvent { - PolicyEvent(const ComboAddress& rem, const DNSName& name, const QType& type, bool tcp): qname(name), qtype(type), remote(rem), isTcp(tcp) + PolicyEvent(const ComboAddress& rem, const DNSName& name, const QType& type, bool tcp) : + qname(name), qtype(type), remote(rem), isTcp(tcp) { } const DNSName& qname; @@ -141,7 +145,8 @@ public: 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_, bool& disablePadding_, std::map& meta_): 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_), disablePadding(disablePadding_), qtype(qtype_), tcp(tcp_), meta(meta_) + 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_, bool& disablePadding_, std::map& meta_) : + 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_), disablePadding(disablePadding_), qtype(qtype_), tcp(tcp_), meta(meta_) { } @@ -182,7 +187,7 @@ public: bool prerpz(DNSQuestion& dq, int& ret) const; bool preresolve(DNSQuestion& dq, int& ret) const; bool nxdomain(DNSQuestion& dq, int& ret) const; - bool nodata(DNSQuestion& dq, int& ret) const ; + bool nodata(DNSQuestion& dq, int& ret) const; bool postresolve(DNSQuestion& dq, int& ret) const; bool preoutquery(const ComboAddress& ns, const ComboAddress& requestor, const DNSName& query, const QType& qtype, bool isTcp, vector& res, int& ret) const; @@ -192,14 +197,10 @@ public: bool needDQ() const { - return (d_prerpz || - d_preresolve || - d_nxdomain || - d_nodata || - d_postresolve); + return (d_prerpz || d_preresolve || d_nxdomain || d_nodata || d_postresolve); } - typedef std::function >,boost::optional,boost::optional,boost::optional,boost::optional,boost::optional >(ComboAddress, Netmask, ComboAddress, DNSName, uint16_t, const EDNSOptionViewMap&, bool, const std::vector>&)> gettag_t; + typedef std::function>, boost::optional, boost::optional, boost::optional, boost::optional, boost::optional>(ComboAddress, Netmask, ComboAddress, DNSName, uint16_t, const EDNSOptionViewMap&, bool, const std::vector>&)> gettag_t; gettag_t d_gettag; // public so you can query if we have this hooked typedef std::function(pdns_ffi_param_t*)> gettag_ffi_t; gettag_ffi_t d_gettag_ffi; @@ -208,13 +209,14 @@ protected: virtual void postPrepareContext() override; virtual void postLoad() override; virtual void getFeatures(Features& features) override; + private: typedef std::function luamaintenance_t; luamaintenance_t d_maintenance; typedef std::function luacall_t; luacall_t d_prerpz, d_preresolve, d_nxdomain, d_nodata, d_postresolve, d_preoutquery, d_postoutquery; bool genhook(const luacall_t& func, DNSQuestion& dq, int& ret) const; - typedef std::function ipfilter_t; + typedef std::function ipfilter_t; ipfilter_t d_ipfilter; typedef std::function policyEventFilter_t; policyEventFilter_t d_policyHitEventFilter; -- 2.47.2