Fixup dnsbackend.cc and dnsbackend.hh

diff --git a/pdns/dnsbackend.cc b/pdns/dnsbackend.cc
index 8fb9e370c4aa1910463bc277ccfd77083d35ca5f..8f45251a612164308a4ac848e2710231cc89c258 100644 (file)
--- a/pdns/dnsbackend.cc
+++ b/pdns/dnsbackend.cc
@@ -42,9 +42,9 @@ extern StatBag S;
 // this is so the geoipbackend can set this pointer if loaded for lua-record.cc
 std::function<std::string(const std::string&, int)> g_getGeo;
 
-bool DNSBackend::getAuth(const DNSName& target, SOAData* sd)
+bool DNSBackend::getAuth(const DNSName& target, SOAData* soaData)
 {
-  return this->getSOA(target, *sd);
+  return this->getSOA(target, *soaData);
 }
 
 void DNSBackend::setArgPrefix(const string& prefix)
@@ -67,10 +67,10 @@ int DNSBackend::getArgAsNum(const string& key)
   return arg().asNum(d_prefix + "-" + key);
 }
 
-void BackendFactory::declare(const string& suffix, const string& param, const string& help, const string& value)
+void BackendFactory::declare(const string& suffix, const string& param, const string& explanation, const string& value)
 {
   string fullname = d_name + suffix + "-" + param;
-  arg().set(fullname, help) = value;
+  arg().set(fullname, explanation) = value;
   arg().setDefault(fullname, value);
 }
 
@@ -85,9 +85,9 @@ BackendMakerClass& BackendMakers()
   return bmc;
 }
 
-void BackendMakerClass::report(BackendFactory* bf)
+void BackendMakerClass::report(BackendFactory* backendFactory)
 {
-  d_repository[bf->getName()] = bf;
+  d_repository[backendFactory->getName()] = backendFactory;
 }
 
 void BackendMakerClass::clear()
@@ -105,14 +105,15 @@ vector<string> BackendMakerClass::getModules()
   load_all();
   vector<string> ret;
   //  copy(d_repository.begin(), d_repository.end(),back_inserter(ret));
-  for (d_repository_t::const_iterator i = d_repository.begin(); i != d_repository.end(); ++i)
-    ret.push_back(i->first);
+  for (auto& repo : d_repository) {
+    ret.push_back(repo.first);
+  }
   return ret;
 }
 
 void BackendMakerClass::load_all()
 {
-  auto directoryError = pdns::visit_directory(arg()["module-dir"], [this]([[maybe_unused]] ino_t inodeNumber, const std::string_view& name) {
+  auto directoryError = pdns::visit_directory(arg()["module-dir"], []([[maybe_unused]] ino_t inodeNumber, const std::string_view& name) {
     if (boost::starts_with(name, "lib") && name.size() > 13 && boost::ends_with(name, "backend.so")) {
       load(std::string(name));
     }
@@ -125,16 +126,19 @@ void BackendMakerClass::load_all()
 
 void BackendMakerClass::load(const string& module)
 {
-  bool res;
+  bool res = false;
 
-  if (module.find('.') == string::npos)
+  if (module.find('.') == string::npos) {
     res = UeberBackend::loadmodule(arg()["module-dir"] + "/lib" + module + "backend.so");
-  else if (module[0] == '/' || (module[0] == '.' && module[1] == '/') || (module[0] == '.' && module[1] == '.')) // absolute or current path
+  }
+  else if (module[0] == '/' || (module[0] == '.' && module[1] == '/') || (module[0] == '.' && module[1] == '.')) { // absolute or current path
     res = UeberBackend::loadmodule(module);
-  else
+  }
+  else {
     res = UeberBackend::loadmodule(arg()["module-dir"] + "/" + module);
+  }
 
-  if (res == false) {
+  if (!res) {
     g_log << Logger::Error << "DNSBackend unable to load module in " << module << endl;
     exit(1);
   }
@@ -148,23 +152,28 @@ void BackendMakerClass::launch(const string& instr)
   vector<string> parts;
   stringtok(parts, instr, ", ");
 
-  for (const auto& part : parts)
-    if (count(parts.begin(), parts.end(), part) > 1)
+  for (const auto& part : parts) {
+    if (count(parts.begin(), parts.end(), part) > 1) {
       throw ArgException("Refusing to launch multiple backends with the same name '" + part + "', verify all 'launch' statements in your configuration");
+    }
+  }
 
   for (const auto& part : parts) {
-    string module, name;
+    string module;
+    string name;
     vector<string> pparts;
     stringtok(pparts, part, ": ");
     module = pparts[0];
-    if (pparts.size() > 1)
+    if (pparts.size() > 1) {
       name = "-" + pparts[1];
+    }
 
     if (d_repository.find(module) == d_repository.end()) {
       // this is *so* userfriendly
       load(module);
-      if (d_repository.find(module) == d_repository.end())
+      if (d_repository.find(module) == d_repository.end()) {
         throw ArgException("Trying to launch unknown backend '" + module + "'");
+      }
     }
     d_repository[module]->declareArguments(name);
     d_instances.emplace_back(module, name);
@@ -229,56 +238,59 @@ vector<std::unique_ptr<DNSBackend>> BackendMakerClass::all(bool metadataOnly)
     \param sd SOAData which is filled with the SOA details
     \param unmodifiedSerial bool if set, serial will be returned as stored in the backend (maybe 0)
 */
-bool DNSBackend::getSOA(const DNSName& domain, SOAData& sd)
+bool DNSBackend::getSOA(const DNSName& domain, SOAData& soaData)
 {
   this->lookup(QType(QType::SOA), domain, -1);
   S.inc("backend-queries");
 
-  DNSResourceRecord rr;
+  DNSResourceRecord resourceRecord;
   int hits = 0;
 
-  sd.db = nullptr;
+  soaData.db = nullptr;
 
   try {
-    while (this->get(rr)) {
-      if (rr.qtype != QType::SOA) {
+    while (this->get(resourceRecord)) {
+      if (resourceRecord.qtype != QType::SOA) {
         throw PDNSException("Got non-SOA record when asking for SOA, zone: '" + domain.toLogString() + "'");
       }
       hits++;
-      sd.qname = domain;
-      sd.ttl = rr.ttl;
-      sd.db = this;
-      sd.domain_id = rr.domain_id;
-      fillSOAData(rr.content, sd);
+      soaData.qname = domain;
+      soaData.ttl = resourceRecord.ttl;
+      soaData.db = this;
+      soaData.domain_id = resourceRecord.domain_id;
+      fillSOAData(resourceRecord.content, soaData);
     }
   }
   catch (...) {
-    while (this->get(rr)) {
+    while (this->get(resourceRecord)) {
       ;
     }
     throw;
   }
 
-  return hits;
+  return hits != 0;
 }
 
-bool DNSBackend::get(DNSZoneRecord& dzr)
+bool DNSBackend::get(DNSZoneRecord& zoneRecord)
 {
   //  cout<<"DNSBackend::get(DNSZoneRecord&) called - translating into DNSResourceRecord query"<<endl;
-  DNSResourceRecord rr;
-  if (!this->get(rr))
+  DNSResourceRecord resourceRecord;
+  if (!this->get(resourceRecord)) {
     return false;
-  dzr.auth = rr.auth;
-  dzr.domain_id = rr.domain_id;
-  dzr.scopeMask = rr.scopeMask;
-  if (rr.qtype.getCode() == QType::TXT && !rr.content.empty() && rr.content[0] != '"')
-    rr.content = "\"" + rr.content + "\"";
+  }
+  zoneRecord.auth = resourceRecord.auth;
+  zoneRecord.domain_id = resourceRecord.domain_id;
+  zoneRecord.scopeMask = resourceRecord.scopeMask;
+  if (resourceRecord.qtype.getCode() == QType::TXT && !resourceRecord.content.empty() && resourceRecord.content[0] != '"') {
+    resourceRecord.content = "\"" + resourceRecord.content + "\"";
+  }
   try {
-    dzr.dr = DNSRecord(rr);
+    zoneRecord.dr = DNSRecord(resourceRecord);
   }
   catch (...) {
-    while (this->get(rr))
+    while (this->get(resourceRecord)) {
       ;
+    }
     throw;
   }
   return true;
@@ -302,46 +314,48 @@ void DNSBackend::getAllDomains(vector<DomainInfo>* /* domains */, bool /* getSer
   }
 }
 
-void fillSOAData(const DNSZoneRecord& in, SOAData& sd)
+void fillSOAData(const DNSZoneRecord& inZoneRecord, SOAData& soaData)
 {
-  sd.domain_id = in.domain_id;
-  sd.ttl = in.dr.d_ttl;
-
-  auto src = getRR<SOARecordContent>(in.dr);
-  sd.nameserver = src->d_mname;
-  sd.rname = src->d_rname;
-  sd.serial = src->d_st.serial;
-  sd.refresh = src->d_st.refresh;
-  sd.retry = src->d_st.retry;
-  sd.expire = src->d_st.expire;
-  sd.minimum = src->d_st.minimum;
+  soaData.domain_id = inZoneRecord.domain_id;
+  soaData.ttl = inZoneRecord.dr.d_ttl;
+
+  auto src = getRR<SOARecordContent>(inZoneRecord.dr);
+  soaData.nameserver = src->d_mname;
+  soaData.rname = src->d_rname;
+  soaData.serial = src->d_st.serial;
+  soaData.refresh = src->d_st.refresh;
+  soaData.retry = src->d_st.retry;
+  soaData.expire = src->d_st.expire;
+  soaData.minimum = src->d_st.minimum;
 }
 
-std::shared_ptr<DNSRecordContent> makeSOAContent(const SOAData& sd)
+std::shared_ptr<DNSRecordContent> makeSOAContent(const SOAData& soaData)
 {
-  struct soatimes st;
-  st.serial = sd.serial;
-  st.refresh = sd.refresh;
-  st.retry = sd.retry;
-  st.expire = sd.expire;
-  st.minimum = sd.minimum;
-  return std::make_shared<SOARecordContent>(sd.nameserver, sd.rname, st);
+  struct soatimes soaTimes
+  {
+    .serial = soaData.serial,
+    .refresh = soaData.refresh,
+    .retry = soaData.retry,
+    .expire = soaData.expire,
+    .minimum = soaData.minimum,
+  };
+  return std::make_shared<SOARecordContent>(soaData.nameserver, soaData.rname, soaTimes);
 }
 
-void fillSOAData(const string& content, SOAData& data)
+void fillSOAData(const string& content, SOAData& soaData)
 {
   vector<string> parts;
   parts.reserve(7);
   stringtok(parts, content);
 
   try {
-    data.nameserver = DNSName(parts.at(0));
-    data.rname = DNSName(parts.at(1));
-    pdns::checked_stoi_into(data.serial, parts.at(2));
-    pdns::checked_stoi_into(data.refresh, parts.at(3));
-    pdns::checked_stoi_into(data.retry, parts.at(4));
-    pdns::checked_stoi_into(data.expire, parts.at(5));
-    pdns::checked_stoi_into(data.minimum, parts.at(6));
+    soaData.nameserver = DNSName(parts.at(0));
+    soaData.rname = DNSName(parts.at(1));
+    pdns::checked_stoi_into(soaData.serial, parts.at(2));
+    pdns::checked_stoi_into(soaData.refresh, parts.at(3));
+    pdns::checked_stoi_into(soaData.retry, parts.at(4));
+    pdns::checked_stoi_into(soaData.expire, parts.at(5));
+    pdns::checked_stoi_into(soaData.minimum, parts.at(6));
   }
   catch (const std::out_of_range& oor) {
     throw PDNSException("Out of range exception parsing '" + content + "'");

diff --git a/pdns/dnsbackend.hh b/pdns/dnsbackend.hh
index d099d537ae5177d183604b269e38cd408caf98f0..d79f851f732fac96b66ec87538020338cba452bc 100644 (file)
--- a/pdns/dnsbackend.hh
+++ b/pdns/dnsbackend.hh
@@ -27,6 +27,7 @@ class DNSPacket;
 
 #include "utility.hh"
 #include <string>
+#include <utility>
 #include <vector>
 #include <map>
 #include <sys/types.h>
@@ -51,8 +52,7 @@ struct SOAData;
 
 struct DomainInfo
 {
-  DomainInfo() :
-    last_check(0), backend(nullptr), id(0), notified_serial(0), receivedNotify(false), serial(0), kind(DomainInfo::Native) {}
+  DomainInfo() = default;
 
   DNSName zone;
   DNSName catalog;
@@ -83,7 +83,7 @@ struct DomainInfo
     Producer,
     Consumer,
     All
-  } kind;
+  } kind{DomainInfo::Native};
 
   [[nodiscard]] const char* getKindString() const
   {
@@ -92,8 +92,8 @@ struct DomainInfo
 
   static const char* getKindString(enum DomainKind kind)
   {
-    const char* kinds[] = {"Master", "Slave", "Native", "Producer", "Consumer", "All"};
-    return kinds[kind];
+    std::array<const char*, 6> kinds{"Master", "Slave", "Native", "Producer", "Consumer", "All"};
+    return kinds.at(kind);
   }
 
   static DomainKind stringToKind(const string& kind)
@@ -133,8 +133,8 @@ struct TSIGKey
 
 struct AutoPrimary
 {
-  AutoPrimary(const string& new_ip, const string& new_nameserver, const string& new_account) :
-    ip(new_ip), nameserver(new_nameserver), account(new_account){};
+  AutoPrimary(string new_ip, string new_nameserver, string new_account) :
+    ip(std::move(new_ip)), nameserver(std::move(new_nameserver)), account(std::move(new_account)){};
   std::string ip;
   std::string nameserver;
   std::string account;
@@ -159,7 +159,7 @@ public:
   //! lookup() initiates a lookup. A lookup without results should not throw!
   virtual void lookup(const QType& qtype, const DNSName& qdomain, int zoneId = -1, DNSPacket* pkt_p = nullptr) = 0;
   virtual bool get(DNSResourceRecord&) = 0; //!< retrieves one DNSResource record, returns false if no more were available
-  virtual bool get(DNSZoneRecord& r);
+  virtual bool get(DNSZoneRecord& zoneRecord);
 
   //! Initiates a list of the specified domain
   /** Once initiated, DNSResourceRecord objects can be retrieved using get(). Should return false
@@ -171,7 +171,7 @@ public:
   virtual ~DNSBackend() = default;
 
   //! fills the soadata struct with the SOA details. Returns false if there is no SOA.
-  virtual bool getSOA(const DNSName& name, SOAData& soadata);
+  virtual bool getSOA(const DNSName& domain, SOAData& soaData);
 
   virtual bool replaceRRSet(uint32_t /* domain_id */, const DNSName& /* qname */, const QType& /* qt */, const vector<DNSResourceRecord>& /* rrset */)
   {
@@ -494,22 +494,22 @@ protected:
   void declare(const string& suffix, const string& param, const string& explanation, const string& value);
 
 private:
-  const string d_name;
+  string d_name;
 };
 
 class BackendMakerClass
 {
 public:
-  void report(BackendFactory* bf);
+  void report(BackendFactory* backendFactory);
   void launch(const string& instr);
   vector<std::unique_ptr<DNSBackend>> all(bool metadataOnly = false);
-  void load(const string& module);
+  static void load(const string& module);
   [[nodiscard]] size_t numLauncheable() const;
   vector<string> getModules();
   void clear();
 
 private:
-  void load_all();
+  static void load_all();
   using d_repository_t = map<string, BackendFactory*>;
   d_repository_t d_repository;
   vector<pair<string, string>> d_instances;
@@ -546,8 +546,8 @@ struct SOAData
 };
 
 /** helper function for both DNSPacket and addSOARecord() - converts a line into a struct, for easier parsing */
-void fillSOAData(const string& content, SOAData& data);
+void fillSOAData(const string& content, SOAData& soaData);
 // same but more karmic
-void fillSOAData(const DNSZoneRecord& in, SOAData& data);
+void fillSOAData(const DNSZoneRecord& inZoneRecord, SOAData& soaData);
 // the reverse
-std::shared_ptr<DNSRecordContent> makeSOAContent(const SOAData& sd);
+std::shared_ptr<DNSRecordContent> makeSOAContent(const SOAData& soaData);