17210411594

Committed 25 Aug 2025 01:33PM UTC coverage: 65.973% (+0.2%) from 65.814%

Build # 17210411594

Build Type

Pull #15874

github

Committed by

web-flow

Commit Message

Merge 6ac7c5514 into 9eeac00a7

Pull Request Pull Request #15874: dnsdist: Only check the freshness of the configuration when needed

Run Details

42140 of 92460 branches covered (45.58%)

Branch coverage included in aggregate %.

59 of 73 new or added lines in 19 files covered. (80.82%)

5421 existing lines in 75 files now uncovered.

128091 of 165573 relevant lines covered (77.36%)

4808876.23 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

59.67

/modules/lua2backend/lua2api2.hh

/*
 * This file is part of PowerDNS or dnsdist.
 * Copyright -- PowerDNS.COM B.V. and its contributors
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * In addition, for the avoidance of any doubt, permission is granted to
 * link this program with OpenSSL and to (re)distribute the binaries
 * produced as the result of such linking.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTAPILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
#pragma once
#include "boost/algorithm/string/join.hpp"
#include "pdns/arguments.hh"

#include "pdns/dnsbackend.hh"
#include "pdns/lua-auth4.hh"

class Lua2BackendAPIv2 : public DNSBackend, AuthLua4
{
private:
  typedef std::function<void()> init_call_t;
  typedef std::function<void()> deinit_call_t;

  typedef std::vector<std::pair<string, string>> lookup_context_t;

  typedef std::vector<std::pair<int, std::vector<std::pair<string, boost::variant<bool, int, DNSName, string, QType>>>>> lookup_result_t;
  typedef std::function<lookup_result_t(const QType& qtype, const DNSName& qname, domainid_t domain_id, const lookup_context_t& ctx)> lookup_call_t;

  typedef boost::variant<bool, lookup_result_t> list_result_t;
  typedef std::function<list_result_t(const DNSName& qname, domainid_t domain_id)> list_call_t;

  typedef vector<pair<string, boost::variant<bool, long, string, vector<string>>>> domaininfo_result_t;
  typedef boost::variant<bool, domaininfo_result_t> get_domaininfo_result_t;
  typedef vector<pair<DNSName, domaininfo_result_t>> get_all_domains_result_t;
  typedef std::function<get_domaininfo_result_t(const DNSName& domain)> get_domaininfo_call_t;
  typedef std::function<get_all_domains_result_t()> get_all_domains_call_t;

  typedef vector<pair<int, string>> domain_metadata_result_t;
  typedef boost::variant<bool, domain_metadata_result_t> get_domain_metadata_result_t;
  typedef boost::variant<bool, vector<pair<string, domain_metadata_result_t>>> get_all_domain_metadata_result_t;
  typedef std::function<get_domain_metadata_result_t(const DNSName& domain, const string& kind)> get_domain_metadata_call_t;
  typedef std::function<get_all_domain_metadata_result_t(const DNSName& domain)> get_all_domain_metadata_call_t;

  typedef vector<pair<string, boost::variant<bool, int, string>>> keydata_result_t;
  typedef boost::variant<bool, vector<pair<int, keydata_result_t>>> get_domain_keys_result_t;
  typedef std::function<get_domain_keys_result_t(const DNSName& domain)> get_domain_keys_call_t;

  typedef std::vector<std::pair<string, boost::variant<string, DNSName>>> before_and_after_names_result_t;
  typedef boost::variant<bool, before_and_after_names_result_t> get_before_and_after_names_absolute_result_t;
  typedef std::function<get_before_and_after_names_absolute_result_t(domainid_t id, const DNSName& qname)> get_before_and_after_names_absolute_call_t;

  typedef std::function<void(domainid_t, long)> set_notified_call_t;

  typedef std::function<string(const string& cmd)> direct_backend_cmd_call_t;

public:
  Lua2BackendAPIv2(const string& suffix)
  {
    d_include_path = ::arg()["lua-global-include-dir"];
    setArgPrefix("lua2" + suffix);
    d_debug_log = mustDo("query-logging");
    prepareContext();
    loadFile(getArg("filename"));
  }

  ~Lua2BackendAPIv2() override;

#define logCall(func, var)                                                                               \
  {                                                                                                      \
    if (d_debug_log) {                                                                                   \
      g_log << Logger::Debug << "[" << getPrefix() << "] Calling " << func << "(" << var << ")" << endl; \
    }                                                                                                    \
  }
#define logResult(var)                                                \
  {                                                                   \
    if (d_debug_log) {                                                \
      g_log << Logger::Debug << "[" << getPrefix() << "] Got result " \
            << "'" << var << "'" << endl;                             \
    }                                                                 \
  }

  void postPrepareContext() override
  {
    AuthLua4::postPrepareContext();
  }

  void postLoad() override
  {
    f_lookup = d_lw->readVariable<boost::optional<lookup_call_t>>("dns_lookup").get_value_or(0);
    f_list = d_lw->readVariable<boost::optional<list_call_t>>("dns_list").get_value_or(0);
    f_get_all_domains = d_lw->readVariable<boost::optional<get_all_domains_call_t>>("dns_get_all_domains").get_value_or(0);
    f_get_domaininfo = d_lw->readVariable<boost::optional<get_domaininfo_call_t>>("dns_get_domaininfo").get_value_or(0);
    f_get_domain_metadata = d_lw->readVariable<boost::optional<get_domain_metadata_call_t>>("dns_get_domain_metadata").get_value_or(0);
    f_get_all_domain_metadata = d_lw->readVariable<boost::optional<get_all_domain_metadata_call_t>>("dns_get_all_domain_metadata").get_value_or(0);
    f_get_domain_keys = d_lw->readVariable<boost::optional<get_domain_keys_call_t>>("dns_get_domain_keys").get_value_or(0);
    f_get_before_and_after_names_absolute = d_lw->readVariable<boost::optional<get_before_and_after_names_absolute_call_t>>("dns_get_before_and_after_names_absolute").get_value_or(0);
    f_set_notified = d_lw->readVariable<boost::optional<set_notified_call_t>>("dns_set_notified").get_value_or(0);

    auto init = d_lw->readVariable<boost::optional<init_call_t>>("dns_init").get_value_or(0);
    if (init)
      init();

    f_deinit = d_lw->readVariable<boost::optional<deinit_call_t>>("dns_deinit").get_value_or(0);

    if (f_lookup == nullptr)
      throw PDNSException("dns_lookup missing");

    /* see if dnssec support is wanted */
    d_dnssec = d_lw->readVariable<boost::optional<bool>>("dns_dnssec").get_value_or(false);
    if (d_dnssec) {
      if (f_get_domain_metadata == nullptr)
        throw PDNSException("dns_dnssec is true but dns_get_domain_metadata is missing");
      if (f_get_before_and_after_names_absolute == nullptr)
        throw PDNSException("dns_dnssec is true but dns_get_before_and_after_names_absolute is missing");
      /* domain keys is not strictly speaking necessary for dnssec backend */
      if (f_get_domain_keys == nullptr)
        g_log << Logger::Warning << "dns_get_domain_keys missing - cannot do live signing" << endl;
    }
  }

  unsigned int getCapabilities() override
  {
    unsigned int caps = CAP_DIRECT | CAP_LIST;
    if (d_dnssec) {
      caps |= CAP_DNSSEC;
    }
    if (f_get_all_domains != nullptr) {
      caps |= CAP_SEARCH;
    }
    return caps;
  }

  void parseLookup(const lookup_result_t& result)
  {
    for (const auto& row : result) {
      DNSResourceRecord rec;
      for (const auto& item : row.second) {
        if (item.first == "type") {
          if (item.second.which() == 1)
            rec.qtype = QType(boost::get<int>(item.second));
          else if (item.second.which() == 3)
            rec.qtype = boost::get<string>(item.second);
          else if (item.second.which() == 4)
            rec.qtype = boost::get<QType>(item.second);
          else
            throw PDNSException("Unsupported value for type");
        }
        else if (item.first == "name") {
          if (item.second.which() == 3)
            rec.qname = DNSName(boost::get<string>(item.second));
          else if (item.second.which() == 2)
            rec.qname = boost::get<DNSName>(item.second);
          else
            throw PDNSException("Unsupported value for name");
        }
        else if (item.first == "domain_id")
          rec.domain_id = boost::get<int>(item.second);
        else if (item.first == "auth")
          rec.auth = boost::get<bool>(item.second);
        else if (item.first == "last_modified")
          rec.last_modified = static_cast<time_t>(boost::get<int>(item.second));
        else if (item.first == "ttl")
          rec.ttl = boost::get<int>(item.second);
        else if (item.first == "content")
          rec.setContent(boost::get<string>(item.second));
        else if (item.first == "scopeMask")
          rec.scopeMask = boost::get<int>(item.second);
        else
          g_log << Logger::Warning << "Unsupported key '" << item.first << "' in lookup or list result" << endl;
      }
      logResult(rec.qname << " IN " << rec.qtype.toString() << " " << rec.ttl << " " << rec.getZoneRepresentation());
      d_result.push_back(rec);
    }
    if (d_result.empty() && d_debug_log)
      g_log << Logger::Debug << "[" << getPrefix() << "] Got empty result" << endl;
  }

  bool list(const ZoneName& target, domainid_t domain_id, bool /* include_disabled */ = false) override
  {
    if (f_list == nullptr) {
      g_log << Logger::Error << "[" << getPrefix() << "] dns_list missing - cannot do AXFR" << endl;
      return false;
    }

    if (d_result.size() != 0)
      throw PDNSException("list attempted while another was running");

    logCall("list", "target=" << target << ",domain_id=" << domain_id);
    list_result_t result = f_list(target.operator const DNSName&(), domain_id);

    if (result.which() == 0)
      return false;

    parseLookup(boost::get<lookup_result_t>(result));

    return true;
  }

  void lookup(const QType& qtype, const DNSName& qname, domainid_t domain_id, DNSPacket* p = nullptr) override
  {
    if (d_result.size() != 0)
      throw PDNSException("lookup attempted while another was running");

    lookup_context_t ctx;
    if (p != NULL) {
      ctx.emplace_back(lookup_context_t::value_type{"source_address", p->getInnerRemote().toString()});
      ctx.emplace_back(lookup_context_t::value_type{"real_source_address", p->getRealRemote().toString()});
    }

    logCall("lookup", "qtype=" << qtype.toString() << ",qname=" << qname << ",domain_id=" << domain_id);
    lookup_result_t result = f_lookup(qtype, qname, domain_id, ctx);
    parseLookup(result);
  }

  bool get(DNSResourceRecord& rr) override
  {
    if (d_result.size() == 0)
      return false;
    rr = std::move(d_result.front());
    d_result.pop_front();
    return true;
  }

  string directBackendCmd(const string& querystr) override
  {
    string::size_type pos = querystr.find_first_of(" \t");
    string cmd = querystr;
    string par = "";
    if (pos != string::npos) {
      cmd = querystr.substr(0, pos);
      par = querystr.substr(pos + 1);
    }
    direct_backend_cmd_call_t f = d_lw->readVariable<boost::optional<direct_backend_cmd_call_t>>(cmd).get_value_or(0);
    if (f == nullptr) {
      return cmd + "not found";
    }
    logCall(cmd, "parameter=" << par);
    return f(par);
  }

  void setNotified(domainid_t id, uint32_t serial) override
  {
    if (f_set_notified == NULL)
      return;
    logCall("dns_set_notified", "id=" << id << ",serial=" << serial);
    f_set_notified(id, serial);
  }

  void parseDomainInfo(const domaininfo_result_t& row, DomainInfo& di)
  {
    di.id = UnknownDomainID;
    for (const auto& item : row) {
      if (item.first == "account")
        di.account = boost::get<string>(item.second);
      else if (item.first == "last_check")
        di.last_check = static_cast<time_t>(boost::get<long>(item.second));
      else if (item.first == "masters")
        for (const auto& primary : boost::get<vector<string>>(item.second))
          di.primaries.push_back(ComboAddress(primary, 53));
      else if (item.first == "id")
        di.id = static_cast<domainid_t>(boost::get<long>(item.second));
      else if (item.first == "notified_serial")
        di.notified_serial = static_cast<unsigned int>(boost::get<long>(item.second));
      else if (item.first == "serial")
        di.serial = static_cast<unsigned int>(boost::get<long>(item.second));
      else if (item.first == "kind")
        di.kind = DomainInfo::stringToKind(boost::get<string>(item.second));
      else
        g_log << Logger::Warning << "Unsupported key '" << item.first << "' in domaininfo result" << endl;
    }
    di.backend = this;
    logResult("zone=" << di.zone << ",serial=" << di.serial << ",kind=" << di.getKindString());
  }

  bool getDomainInfo(const ZoneName& domain, DomainInfo& di, bool /* getSerial */ = true) override
  {
    if (f_get_domaininfo == nullptr) {
      // use getAuth instead... but getAuth wraps getSOA which will call
      // getDomainInfo if this is a domain variant, so protect against this
      // would-be infinite recursion.
      if (domain.hasVariant()) {
        g_log << Logger::Info << "Unable to return domain information for '" << domain.toLogString() << "' due to unimplemented dns_get_domaininfo" << endl;
        return false;
      }
      SOAData sd;
      if (!getAuth(domain, &sd))
        return false;

      di.id = sd.domain_id;
      di.zone = domain;
      di.backend = this;
      di.serial = sd.serial;
      return true;
    }

    logCall("get_domaininfo", "domain=" << domain);
    get_domaininfo_result_t result = f_get_domaininfo(domain.operator const DNSName&());

    if (result.which() == 0)
      return false;

    di.zone = domain;
    parseDomainInfo(boost::get<domaininfo_result_t>(result), di);

    return true;
  }

  void getAllDomains(vector<DomainInfo>* domains, bool /* getSerial */, bool /* include_disabled */) override
  {
    if (f_get_all_domains == nullptr)
      return;

    logCall("get_all_domains", "");
    for (const auto& row : f_get_all_domains()) {
      DomainInfo di;
      di.zone = ZoneName(row.first);
      logResult(di.zone);
      parseDomainInfo(row.second, di);
      domains->push_back(di);
    }
  }

  bool getAllDomainMetadata(const ZoneName& name, std::map<std::string, std::vector<std::string>>& meta) override
  {
    if (f_get_all_domain_metadata == nullptr)
      return false;

    logCall("get_all_domain_metadata", "name=" << name);
    get_all_domain_metadata_result_t result = f_get_all_domain_metadata(name.operator const DNSName&());
    if (result.which() == 0)
      return false;

    for (const auto& row : boost::get<vector<pair<string, domain_metadata_result_t>>>(result)) {
      meta[row.first].clear();
      for (const auto& item : row.second)
        meta[row.first].push_back(item.second);
      logResult("kind=" << row.first << ",value=" << boost::algorithm::join(meta[row.first], ", "));
    }

    return true;
  }

  bool getDomainMetadata(const ZoneName& name, const std::string& kind, std::vector<std::string>& meta) override
  {
    if (f_get_domain_metadata == nullptr)
      return false;

    logCall("get_domain_metadata", "name=" << name << ",kind=" << kind);
    get_domain_metadata_result_t result = f_get_domain_metadata(name.operator const DNSName&(), kind);
    if (result.which() == 0)
      return false;

    meta.clear();
    for (const auto& item : boost::get<domain_metadata_result_t>(result))
      meta.push_back(item.second);

    logResult("value=" << boost::algorithm::join(meta, ", "));
    return true;
  }

  bool getDomainKeys(const ZoneName& name, std::vector<DNSBackend::KeyData>& keys) override
  {
    if (f_get_domain_keys == nullptr)
      return false;

    logCall("get_domain_keys", "name=" << name);
    get_domain_keys_result_t result = f_get_domain_keys(name.operator const DNSName&());

    if (result.which() == 0)
      return false;

    for (const auto& row : boost::get<vector<pair<int, keydata_result_t>>>(result)) {
      DNSBackend::KeyData key;
      key.published = true;
      for (const auto& item : row.second) {
        if (item.first == "content")
          key.content = boost::get<string>(item.second);
        else if (item.first == "id")
          key.id = static_cast<unsigned int>(boost::get<int>(item.second));
        else if (item.first == "flags")
          key.flags = static_cast<unsigned int>(boost::get<int>(item.second));
        else if (item.first == "active")
          key.active = boost::get<bool>(item.second);
        else if (item.first == "published")
          key.published = boost::get<bool>(item.second);
        else
          g_log << Logger::Warning << "[" << getPrefix() << "] Unsupported key '" << item.first << "' in keydata result" << endl;
      }
      logResult("id=" << key.id << ",flags=" << key.flags << ",active=" << (key.active ? "true" : "false") << ",published=" << (key.published ? "true" : "false"));
      keys.emplace_back(std::move(key));
    }

    return true;
  }

  bool getBeforeAndAfterNamesAbsolute(domainid_t id, const DNSName& qname, DNSName& unhashed, DNSName& before, DNSName& after) override
  {
    if (f_get_before_and_after_names_absolute == nullptr)
      return false;

    logCall("get_before_and_after_names_absolute", "id=<<" << id << ",qname=" << qname);
    get_before_and_after_names_absolute_result_t result = f_get_before_and_after_names_absolute(id, qname);

    if (result.which() == 0)
      return false;

    before_and_after_names_result_t row = boost::get<before_and_after_names_result_t>(result);
    if (row.size() != 3) {
      g_log << Logger::Error << "Invalid result from dns_get_before_and_after_names_absolute, expected array with 3 items, got " << row.size() << "item(s)" << endl;
      return false;
    }
    for (const auto& item : row) {
      DNSName value;
      if (item.second.which() == 0)
        value = DNSName(boost::get<string>(item.second));
      else
        value = DNSName(boost::get<DNSName>(item.second));
      if (item.first == "unhashed")
        unhashed = value;
      else if (item.first == "before")
        before = value;
      else if (item.first == "after")
        after = value;
      else {
        g_log << Logger::Error << "Invalid result from dns_get_before_and_after_names_absolute, unexpected key " << item.first << endl;
        return false;
      }
    }

    logResult("unhashed=" << unhashed << ",before=" << before << ",after=" << after);
    return true;
  }

private:
  std::list<DNSResourceRecord> d_result;
  bool d_debug_log{false};
  bool d_dnssec{false};

  lookup_call_t f_lookup;
  list_call_t f_list;

  get_domaininfo_call_t f_get_domaininfo;
  get_all_domains_call_t f_get_all_domains;

  get_domain_metadata_call_t f_get_domain_metadata;
  get_all_domain_metadata_call_t f_get_all_domain_metadata;

  get_domain_keys_call_t f_get_domain_keys;

  get_before_and_after_names_absolute_call_t f_get_before_and_after_names_absolute;

  set_notified_call_t f_set_notified;

  deinit_call_t f_deinit;
};

1	/*
2	* This file is part of PowerDNS or dnsdist.
3	* Copyright -- PowerDNS.COM B.V. and its contributors
4	*
5	* This program is free software; you can redistribute it and/or modify
6	* it under the terms of version 2 of the GNU General Public License as
7	* published by the Free Software Foundation.
8	*
9	* In addition, for the avoidance of any doubt, permission is granted to
10	* link this program with OpenSSL and to (re)distribute the binaries
11	* produced as the result of such linking.
12	*
13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTAPILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.
17	*
18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21	*/
22	#pragma once
23	#include "boost/algorithm/string/join.hpp"
24	#include "pdns/arguments.hh"
25
26	#include "pdns/dnsbackend.hh"
27	#include "pdns/lua-auth4.hh"
28
29	class Lua2BackendAPIv2 : public DNSBackend, AuthLua4
30	{
31	private:
32	typedef std::function<void()> init_call_t;
33	typedef std::function<void()> deinit_call_t;
34
35	typedef std::vector<std::pair<string, string>> lookup_context_t;
36
37	typedef std::vector<std::pair<int, std::vector<std::pair<string, boost::variant<bool, int, DNSName, string, QType>>>>> lookup_result_t;
38	typedef std::function<lookup_result_t(const QType& qtype, const DNSName& qname, domainid_t domain_id, const lookup_context_t& ctx)> lookup_call_t;
39
40	typedef boost::variant<bool, lookup_result_t> list_result_t;
41	typedef std::function<list_result_t(const DNSName& qname, domainid_t domain_id)> list_call_t;
42
43	typedef vector<pair<string, boost::variant<bool, long, string, vector<string>>>> domaininfo_result_t;
44	typedef boost::variant<bool, domaininfo_result_t> get_domaininfo_result_t;
45	typedef vector<pair<DNSName, domaininfo_result_t>> get_all_domains_result_t;
46	typedef std::function<get_domaininfo_result_t(const DNSName& domain)> get_domaininfo_call_t;
47	typedef std::function<get_all_domains_result_t()> get_all_domains_call_t;
48
49	typedef vector<pair<int, string>> domain_metadata_result_t;
50	typedef boost::variant<bool, domain_metadata_result_t> get_domain_metadata_result_t;
51	typedef boost::variant<bool, vector<pair<string, domain_metadata_result_t>>> get_all_domain_metadata_result_t;
52	typedef std::function<get_domain_metadata_result_t(const DNSName& domain, const string& kind)> get_domain_metadata_call_t;
53	typedef std::function<get_all_domain_metadata_result_t(const DNSName& domain)> get_all_domain_metadata_call_t;
54
55	typedef vector<pair<string, boost::variant<bool, int, string>>> keydata_result_t;
56	typedef boost::variant<bool, vector<pair<int, keydata_result_t>>> get_domain_keys_result_t;
57	typedef std::function<get_domain_keys_result_t(const DNSName& domain)> get_domain_keys_call_t;
58
59	typedef std::vector<std::pair<string, boost::variant<string, DNSName>>> before_and_after_names_result_t;
60	typedef boost::variant<bool, before_and_after_names_result_t> get_before_and_after_names_absolute_result_t;
61	typedef std::function<get_before_and_after_names_absolute_result_t(domainid_t id, const DNSName& qname)> get_before_and_after_names_absolute_call_t;
62
63	typedef std::function<void(domainid_t, long)> set_notified_call_t;
64
65	typedef std::function<string(const string& cmd)> direct_backend_cmd_call_t;
66
67	public:
68	Lua2BackendAPIv2(const string& suffix)
69	{	21✔
70	d_include_path = ::arg()["lua-global-include-dir"];	21✔
71	setArgPrefix("lua2" + suffix);	21✔
72	d_debug_log = mustDo("query-logging");	21✔
73	prepareContext();	21✔
74	loadFile(getArg("filename"));	21✔
75	}	21✔
76
77	~Lua2BackendAPIv2() override;
78
79	#define logCall(func, var) \
80	{ \	48✔
81	if (d_debug_log) { \	48✔
82	g_log << Logger::Debug << "[" << getPrefix() << "] Calling " << func << "(" << var << ")" << endl; \	×
83	} \	×
84	}	48✔
85	#define logResult(var) \
86	{ \	128✔
87	if (d_debug_log) { \	128✔
88	g_log << Logger::Debug << "[" << getPrefix() << "] Got result " \	×
89	<< "'" << var << "'" << endl; \	×
90	} \	×
91	}	128✔
92
93	void postPrepareContext() override
94	{	21✔
95	AuthLua4::postPrepareContext();	21✔
96	}	21✔
97
98	void postLoad() override
99	{	21✔
100	f_lookup = d_lw->readVariable<boost::optional<lookup_call_t>>("dns_lookup").get_value_or(0);	21✔
101	f_list = d_lw->readVariable<boost::optional<list_call_t>>("dns_list").get_value_or(0);	21✔
102	f_get_all_domains = d_lw->readVariable<boost::optional<get_all_domains_call_t>>("dns_get_all_domains").get_value_or(0);	21✔
103	f_get_domaininfo = d_lw->readVariable<boost::optional<get_domaininfo_call_t>>("dns_get_domaininfo").get_value_or(0);	21✔
104	f_get_domain_metadata = d_lw->readVariable<boost::optional<get_domain_metadata_call_t>>("dns_get_domain_metadata").get_value_or(0);	21✔
105	f_get_all_domain_metadata = d_lw->readVariable<boost::optional<get_all_domain_metadata_call_t>>("dns_get_all_domain_metadata").get_value_or(0);	21✔
106	f_get_domain_keys = d_lw->readVariable<boost::optional<get_domain_keys_call_t>>("dns_get_domain_keys").get_value_or(0);	21✔
107	f_get_before_and_after_names_absolute = d_lw->readVariable<boost::optional<get_before_and_after_names_absolute_call_t>>("dns_get_before_and_after_names_absolute").get_value_or(0);	21✔
108	f_set_notified = d_lw->readVariable<boost::optional<set_notified_call_t>>("dns_set_notified").get_value_or(0);	21✔
109
110	auto init = d_lw->readVariable<boost::optional<init_call_t>>("dns_init").get_value_or(0);	21✔
111	if (init)	21!
112	init();	×
113
114	f_deinit = d_lw->readVariable<boost::optional<deinit_call_t>>("dns_deinit").get_value_or(0);	21✔
115
116	if (f_lookup == nullptr)	21!
117	throw PDNSException("dns_lookup missing");	×
118
119	/* see if dnssec support is wanted */
120	d_dnssec = d_lw->readVariable<boost::optional<bool>>("dns_dnssec").get_value_or(false);	21✔
121	if (d_dnssec) {	21✔
122	if (f_get_domain_metadata == nullptr)	15!
123	throw PDNSException("dns_dnssec is true but dns_get_domain_metadata is missing");	×
124	if (f_get_before_and_after_names_absolute == nullptr)	15!
125	throw PDNSException("dns_dnssec is true but dns_get_before_and_after_names_absolute is missing");	×
126	/* domain keys is not strictly speaking necessary for dnssec backend */
127	if (f_get_domain_keys == nullptr)	15!
128	g_log << Logger::Warning << "dns_get_domain_keys missing - cannot do live signing" << endl;	×
129	}	15✔
130	}	21✔
131
132	unsigned int getCapabilities() override
133	{	6✔
134	unsigned int caps = CAP_DIRECT \| CAP_LIST;	6✔
135	if (d_dnssec) {	6!
136	caps \|= CAP_DNSSEC;	6✔
137	}	6✔
138	if (f_get_all_domains != nullptr) {	6!
139	caps \|= CAP_SEARCH;	6✔
140	}	6✔
141	return caps;	6✔
142	}	6✔
143
144	void parseLookup(const lookup_result_t& result)
145	{	29✔
146	for (const auto& row : result) {	103✔
147	DNSResourceRecord rec;	103✔
148	for (const auto& item : row.second) {	437✔
149	if (item.first == "type") {	437✔
150	if (item.second.which() == 1)	103!
UNCOV 151	rec.qtype = QType(boost::get<int>(item.second));	×
152	else if (item.second.which() == 3)	103!
153	rec.qtype = boost::get<string>(item.second);	×
154	else if (item.second.which() == 4)	103!
155	rec.qtype = boost::get<QType>(item.second);	103✔
UNCOV 156	else	×
UNCOV 157	throw PDNSException("Unsupported value for type");	×
158	}	103✔
159	else if (item.first == "name") {	334✔
160	if (item.second.which() == 3)	103!
161	rec.qname = DNSName(boost::get<string>(item.second));	×
162	else if (item.second.which() == 2)	103!
163	rec.qname = boost::get<DNSName>(item.second);	103✔
UNCOV 164	else	×
UNCOV 165	throw PDNSException("Unsupported value for name");	×
166	}	103✔
167	else if (item.first == "domain_id")	231✔
168	rec.domain_id = boost::get<int>(item.second);	25✔
169	else if (item.first == "auth")	206!
UNCOV 170	rec.auth = boost::get<bool>(item.second);	×
171	else if (item.first == "last_modified")	206!
UNCOV 172	rec.last_modified = static_cast<time_t>(boost::get<int>(item.second));	×
173	else if (item.first == "ttl")	206✔
174	rec.ttl = boost::get<int>(item.second);	103✔
175	else if (item.first == "content")	103!
176	rec.setContent(boost::get<string>(item.second));	103✔
177	else if (item.first == "scopeMask")	×
UNCOV 178	rec.scopeMask = boost::get<int>(item.second);	×
UNCOV 179	else	×
UNCOV 180	g_log << Logger::Warning << "Unsupported key '" << item.first << "' in lookup or list result" << endl;	×
181	}	437✔
182	logResult(rec.qname << " IN " << rec.qtype.toString() << " " << rec.ttl << " " << rec.getZoneRepresentation());	103!
183	d_result.push_back(rec);	103✔
184	}	103✔
185	if (d_result.empty() && d_debug_log)	29!
UNCOV 186	g_log << Logger::Debug << "[" << getPrefix() << "] Got empty result" << endl;	×
187	}	29✔
188
189	bool list(const ZoneName& target, domainid_t domain_id, bool /* include_disabled */ = false) override
190	{	6✔
191	if (f_list == nullptr) {	6!
UNCOV 192	g_log << Logger::Error << "[" << getPrefix() << "] dns_list missing - cannot do AXFR" << endl;	×
UNCOV 193	return false;	×
194	}	×
195
196	if (d_result.size() != 0)	6!
UNCOV 197	throw PDNSException("list attempted while another was running");	×
198
199	logCall("list", "target=" << target << ",domain_id=" << domain_id);	6!
200	list_result_t result = f_list(target.operator const DNSName&(), domain_id);	6✔
201
202	if (result.which() == 0)	6!
UNCOV 203	return false;	×
204
205	parseLookup(boost::get<lookup_result_t>(result));	6✔
206
207	return true;	6✔
208	}	6✔
209
210	void lookup(const QType& qtype, const DNSName& qname, domainid_t domain_id, DNSPacket* p = nullptr) override
211	{	23✔
212	if (d_result.size() != 0)	23!
UNCOV 213	throw PDNSException("lookup attempted while another was running");	×
214
215	lookup_context_t ctx;	23✔
216	if (p != NULL) {	23✔
217	ctx.emplace_back(lookup_context_t::value_type{"source_address", p->getInnerRemote().toString()});	5✔
218	ctx.emplace_back(lookup_context_t::value_type{"real_source_address", p->getRealRemote().toString()});	5✔
219	}	5✔
220
221	logCall("lookup", "qtype=" << qtype.toString() << ",qname=" << qname << ",domain_id=" << domain_id);	23!
222	lookup_result_t result = f_lookup(qtype, qname, domain_id, ctx);	23✔
223	parseLookup(result);	23✔
224	}	23✔
225
226	bool get(DNSResourceRecord& rr) override
227	{	132✔
228	if (d_result.size() == 0)	132✔
229	return false;	29✔
230	rr = std::move(d_result.front());	103✔
231	d_result.pop_front();	103✔
232	return true;	103✔
233	}	132✔
234
235	string directBackendCmd(const string& querystr) override
236	{	×
237	string::size_type pos = querystr.find_first_of(" \t");	×
238	string cmd = querystr;	×
239	string par = "";	×
240	if (pos != string::npos) {	×
241	cmd = querystr.substr(0, pos);	×
242	par = querystr.substr(pos + 1);	×
243	}	×
244	direct_backend_cmd_call_t f = d_lw->readVariable<boost::optional<direct_backend_cmd_call_t>>(cmd).get_value_or(0);	×
245	if (f == nullptr) {	×
246	return cmd + "not found";	×
247	}	×
UNCOV 248	logCall(cmd, "parameter=" << par);	×
UNCOV 249	return f(par);	×
250	}	×
251
252	void setNotified(domainid_t id, uint32_t serial) override
253	{	×
254	if (f_set_notified == NULL)	×
255	return;	×
UNCOV 256	logCall("dns_set_notified", "id=" << id << ",serial=" << serial);	×
UNCOV 257	f_set_notified(id, serial);	×
UNCOV 258	}	×
259
260	void parseDomainInfo(const domaininfo_result_t& row, DomainInfo& di)
261	{	5✔
262	di.id = UnknownDomainID;	5✔
263	for (const auto& item : row) {	10✔
264	if (item.first == "account")	10!
UNCOV 265	di.account = boost::get<string>(item.second);	×
266	else if (item.first == "last_check")	10!
267	di.last_check = static_cast<time_t>(boost::get<long>(item.second));	×
268	else if (item.first == "masters")	10!
UNCOV 269	for (const auto& primary : boost::get<vector<string>>(item.second))	×
UNCOV 270	di.primaries.push_back(ComboAddress(primary, 53));	×
271	else if (item.first == "id")	10✔
272	di.id = static_cast<domainid_t>(boost::get<long>(item.second));	5✔
273	else if (item.first == "notified_serial")	5!
274	di.notified_serial = static_cast<unsigned int>(boost::get<long>(item.second));	×
275	else if (item.first == "serial")	5!
276	di.serial = static_cast<unsigned int>(boost::get<long>(item.second));	5✔
277	else if (item.first == "kind")	×
UNCOV 278	di.kind = DomainInfo::stringToKind(boost::get<string>(item.second));	×
UNCOV 279	else	×
UNCOV 280	g_log << Logger::Warning << "Unsupported key '" << item.first << "' in domaininfo result" << endl;	×
281	}	10✔
282	di.backend = this;	5✔
283	logResult("zone=" << di.zone << ",serial=" << di.serial << ",kind=" << di.getKindString());	5!
284	}	5✔
285
286	bool getDomainInfo(const ZoneName& domain, DomainInfo& di, bool /* getSerial */ = true) override
287	{	6✔
288	if (f_get_domaininfo == nullptr) {	6✔
289	// use getAuth instead... but getAuth wraps getSOA which will call
290	// getDomainInfo if this is a domain variant, so protect against this
291	// would-be infinite recursion.
292	if (domain.hasVariant()) {	3!
UNCOV 293	g_log << Logger::Info << "Unable to return domain information for '" << domain.toLogString() << "' due to unimplemented dns_get_domaininfo" << endl;	×
UNCOV 294	return false;	×
295	}	×
296	SOAData sd;	3✔
297	if (!getAuth(domain, &sd))	3!
UNCOV 298	return false;	×
299
300	di.id = sd.domain_id;	3✔
301	di.zone = domain;	3✔
302	di.backend = this;	3✔
303	di.serial = sd.serial;	3✔
304	return true;	3✔
305	}	3✔
306
307	logCall("get_domaininfo", "domain=" << domain);	3!
308	get_domaininfo_result_t result = f_get_domaininfo(domain.operator const DNSName&());	3✔
309
310	if (result.which() == 0)	3!
UNCOV 311	return false;	×
312
313	di.zone = domain;	3✔
314	parseDomainInfo(boost::get<domaininfo_result_t>(result), di);	3✔
315
316	return true;	3✔
317	}	3✔
318
319	void getAllDomains(vector<DomainInfo>* domains, bool /* getSerial /, bool / include_disabled */) override
320	{	1✔
321	if (f_get_all_domains == nullptr)	1!
UNCOV 322	return;	×
323
324	logCall("get_all_domains", "");	1!
325	for (const auto& row : f_get_all_domains()) {	2✔
326	DomainInfo di;	2✔
327	di.zone = ZoneName(row.first);	2✔
328	logResult(di.zone);	2!
329	parseDomainInfo(row.second, di);	2✔
330	domains->push_back(di);	2✔
331	}	2✔
332	}	1✔
333
334	bool getAllDomainMetadata(const ZoneName& name, std::map<std::string, std::vector<std::string>>& meta) override
335	{	6✔
336	if (f_get_all_domain_metadata == nullptr)	6!
337	return false;	6✔
338
339	logCall("get_all_domain_metadata", "name=" << name);	×
UNCOV 340	get_all_domain_metadata_result_t result = f_get_all_domain_metadata(name.operator const DNSName&());	×
341	if (result.which() == 0)	×
342	return false;	×
343
344	for (const auto& row : boost::get<vector<pair<string, domain_metadata_result_t>>>(result)) {	×
345	meta[row.first].clear();	×
346	for (const auto& item : row.second)	×
UNCOV 347	meta[row.first].push_back(item.second);	×
348	logResult("kind=" << row.first << ",value=" << boost::algorithm::join(meta[row.first], ", "));	×
349	}	×
350
UNCOV 351	return true;	×
352	}	×
353
354	bool getDomainMetadata(const ZoneName& name, const std::string& kind, std::vector<std::string>& meta) override
UNCOV 355	{	×
356	if (f_get_domain_metadata == nullptr)	×
357	return false;	×
358
359	logCall("get_domain_metadata", "name=" << name << ",kind=" << kind);	×
UNCOV 360	get_domain_metadata_result_t result = f_get_domain_metadata(name.operator const DNSName&(), kind);	×
361	if (result.which() == 0)	×
362	return false;	×
363
UNCOV 364	meta.clear();	×
365	for (const auto& item : boost::get<domain_metadata_result_t>(result))	×
366	meta.push_back(item.second);	×
367
UNCOV 368	logResult("value=" << boost::algorithm::join(meta, ", "));	×
UNCOV 369	return true;	×
UNCOV 370	}	×
371
372	bool getDomainKeys(const ZoneName& name, std::vector<DNSBackend::KeyData>& keys) override
373	{	6✔
374	if (f_get_domain_keys == nullptr)	6✔
375	return false;	3✔
376
377	logCall("get_domain_keys", "name=" << name);	3!
378	get_domain_keys_result_t result = f_get_domain_keys(name.operator const DNSName&());	3✔
379
380	if (result.which() == 0)	3!
UNCOV 381	return false;	×
382
383	for (const auto& row : boost::get<vector<pair<int, keydata_result_t>>>(result)) {	6✔
384	DNSBackend::KeyData key;	6✔
385	key.published = true;	6✔
386	for (const auto& item : row.second) {	24✔
387	if (item.first == "content")	24✔
388	key.content = boost::get<string>(item.second);	6✔
389	else if (item.first == "id")	18✔
390	key.id = static_cast<unsigned int>(boost::get<int>(item.second));	6✔
391	else if (item.first == "flags")	12✔
392	key.flags = static_cast<unsigned int>(boost::get<int>(item.second));	6✔
393	else if (item.first == "active")	6!
394	key.active = boost::get<bool>(item.second);	6✔
395	else if (item.first == "published")	×
UNCOV 396	key.published = boost::get<bool>(item.second);	×
UNCOV 397	else	×
UNCOV 398	g_log << Logger::Warning << "[" << getPrefix() << "] Unsupported key '" << item.first << "' in keydata result" << endl;	×
399	}	24✔
400	logResult("id=" << key.id << ",flags=" << key.flags << ",active=" << (key.active ? "true" : "false") << ",published=" << (key.published ? "true" : "false"));	6!
401	keys.emplace_back(std::move(key));	6✔
402	}	6✔
403
404	return true;	3✔
405	}	3✔
406
407	bool getBeforeAndAfterNamesAbsolute(domainid_t id, const DNSName& qname, DNSName& unhashed, DNSName& before, DNSName& after) override
408	{	12✔
409	if (f_get_before_and_after_names_absolute == nullptr)	12!
UNCOV 410	return false;	×
411
412	logCall("get_before_and_after_names_absolute", "id=<<" << id << ",qname=" << qname);	12!
413	get_before_and_after_names_absolute_result_t result = f_get_before_and_after_names_absolute(id, qname);	12✔
414
415	if (result.which() == 0)	12!
UNCOV 416	return false;	×
417
418	before_and_after_names_result_t row = boost::get<before_and_after_names_result_t>(result);	12✔
419	if (row.size() != 3) {	12!
UNCOV 420	g_log << Logger::Error << "Invalid result from dns_get_before_and_after_names_absolute, expected array with 3 items, got " << row.size() << "item(s)" << endl;	×
UNCOV 421	return false;	×
UNCOV 422	}	×
423	for (const auto& item : row) {	36✔
424	DNSName value;	36✔
425	if (item.second.which() == 0)	36!
UNCOV 426	value = DNSName(boost::get<string>(item.second));	×
427	else	36✔
428	value = DNSName(boost::get<DNSName>(item.second));	36✔
429	if (item.first == "unhashed")	36✔
430	unhashed = value;	12✔
431	else if (item.first == "before")	24✔
432	before = value;	12✔
433	else if (item.first == "after")	12!
434	after = value;	12✔
435	else {	×
UNCOV 436	g_log << Logger::Error << "Invalid result from dns_get_before_and_after_names_absolute, unexpected key " << item.first << endl;	×
UNCOV 437	return false;	×
UNCOV 438	}	×
439	}	36✔
440
441	logResult("unhashed=" << unhashed << ",before=" << before << ",after=" << after);	12!
442	return true;	12✔
443	}	12✔
444
445	private:
446	std::list<DNSResourceRecord> d_result;
447	bool d_debug_log{false};
448	bool d_dnssec{false};
449
450	lookup_call_t f_lookup;
451	list_call_t f_list;
452
453	get_domaininfo_call_t f_get_domaininfo;
454	get_all_domains_call_t f_get_all_domains;
455
456	get_domain_metadata_call_t f_get_domain_metadata;
457	get_all_domain_metadata_call_t f_get_all_domain_metadata;
458
459	get_domain_keys_call_t f_get_domain_keys;
460
461	get_before_and_after_names_absolute_call_t f_get_before_and_after_names_absolute;
462
463	set_notified_call_t f_set_notified;
464
465	deinit_call_t f_deinit;
466	};

PowerDNS / pdns / 17210411594

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous