return true;
}
-bool Bind2Backend::feedRecord(const DNSResourceRecord& rr, const DNSName& ordername, bool ordernameIsNSEC3)
+bool Bind2Backend::feedRecord(const DNSResourceRecord& rr, const DNSName& /* ordername */, bool /* ordernameIsNSEC3 */)
{
if (d_transaction_id < 1) {
throw DBException("Bind2Backend::feedRecord() called outside of transaction");
return true;
}
-void Bind2Backend::getUpdatedMasters(vector<DomainInfo>& changedDomains, std::unordered_set<DNSName>& catalogs, CatalogHashMap& catalogHashes)
+void Bind2Backend::getUpdatedMasters(vector<DomainInfo>& changedDomains, std::unordered_set<DNSName>& /* catalogs */, CatalogHashMap& /* catalogHashes */)
{
vector<DomainInfo> consider;
{
}
}
-void Bind2Backend::getAllDomains(vector<DomainInfo>* domains, bool getSerial, bool include_disabled)
+void Bind2Backend::getAllDomains(vector<DomainInfo>* domains, bool getSerial, bool /* include_disabled */)
{
SOAData soadata;
records->insert(std::move(bdr));
}
-string Bind2Backend::DLReloadNowHandler(const vector<string>& parts, Utility::pid_t ppid)
+string Bind2Backend::DLReloadNowHandler(const vector<string>& parts, Utility::pid_t /* ppid */)
{
ostringstream ret;
return ret.str();
}
-string Bind2Backend::DLDomStatusHandler(const vector<string>& parts, Utility::pid_t ppid)
+string Bind2Backend::DLDomStatusHandler(const vector<string>& parts, Utility::pid_t /* ppid */)
{
ostringstream ret;
ret << "\t Last notified: " << info.d_lastnotified << std::endl;
}
-string Bind2Backend::DLDomExtendedStatusHandler(const vector<string>& parts, Utility::pid_t ppid)
+string Bind2Backend::DLDomExtendedStatusHandler(const vector<string>& parts, Utility::pid_t /* ppid */)
{
ostringstream ret;
return ret.str();
}
-string Bind2Backend::DLListRejectsHandler(const vector<string>& parts, Utility::pid_t ppid)
+string Bind2Backend::DLListRejectsHandler(const vector<string>& /* parts */, Utility::pid_t /* ppid */)
{
ostringstream ret;
auto rstate = s_state.read_lock();
return ret.str();
}
-string Bind2Backend::DLAddDomainHandler(const vector<string>& parts, Utility::pid_t ppid)
+string Bind2Backend::DLAddDomainHandler(const vector<string>& parts, Utility::pid_t /* ppid */)
{
if (parts.size() < 3)
return "ERROR: Domain name and zone filename are required";
}
}
-bool Bind2Backend::findBeforeAndAfterUnhashed(std::shared_ptr<const recordstorage_t>& records, const DNSName& qname, DNSName& unhashed, DNSName& before, DNSName& after)
+bool Bind2Backend::findBeforeAndAfterUnhashed(std::shared_ptr<const recordstorage_t>& records, const DNSName& qname, DNSName& /* unhashed */, DNSName& before, DNSName& after)
{
// for(const auto& record: *records)
// cerr<<record.qname<<"\t"<<makeHexDump(record.qname.toDNSString())<<endl;
}
}
-void Bind2Backend::lookup(const QType& qtype, const DNSName& qname, int zoneId, DNSPacket* pkt_p)
+void Bind2Backend::lookup(const QType& qtype, const DNSName& qname, int zoneId, DNSPacket* /* pkt_p */)
{
d_handle.reset();
return true;
}
-bool Bind2Backend::list(const DNSName& target, int id, bool include_disabled)
+bool Bind2Backend::list(const DNSName& /* target */, int id, bool /* include_disabled */)
{
BB2DomainInfo bbd;
return true;
}
-bool Bind2Backend::superMasterBackend(const string& ip, const DNSName& domain, const vector<DNSResourceRecord>& nsset, string* nameserver, string* account, DNSBackend** db)
+bool Bind2Backend::superMasterBackend(const string& ip, const DNSName& /* domain */, const vector<DNSResourceRecord>& /* nsset */, string* /* nameserver */, string* account, DNSBackend** db)
{
// Check whether we have a configfile available.
if (getArg("supermaster-config").empty())
return bbd;
}
-bool Bind2Backend::createSlaveDomain(const string& ip, const DNSName& domain, const string& nameserver, const string& account)
+bool Bind2Backend::createSlaveDomain(const string& ip, const DNSName& domain, const string& /* nameserver */, const string& account)
{
string filename = getArg("supermaster-destdir") + '/' + domain.toStringNoDot();
}
}
-void GeoIPBackend::rediscover(string* status)
+void GeoIPBackend::rediscover(string* /* status */)
{
reload();
}
-bool GeoIPBackend::getDomainInfo(const DNSName& domain, DomainInfo& di, bool getSerial)
+bool GeoIPBackend::getDomainInfo(const DNSName& domain, DomainInfo& di, bool /* getSerial */)
{
ReadLock rl(&s_state_lock);
return false;
}
-void GeoIPBackend::getAllDomains(vector<DomainInfo>* domains, bool getSerial, bool include_disabled)
+void GeoIPBackend::getAllDomains(vector<DomainInfo>* domains, bool /* getSerial */, bool /* include_disabled */)
{
ReadLock rl(&s_state_lock);
return false;
}
-bool GeoIPBackend::publishDomainKey(const DNSName& name, unsigned int id)
+bool GeoIPBackend::publishDomainKey(const DNSName& /* name */, unsigned int /* id */)
{
return false;
}
-bool GeoIPBackend::unpublishDomainKey(const DNSName& name, unsigned int id)
+bool GeoIPBackend::unpublishDomainKey(const DNSName& /* name */, unsigned int /* id */)
{
return false;
}
~GeoIPBackend();
void lookup(const QType& qtype, const DNSName& qdomain, int zoneId, DNSPacket* pkt_p = nullptr) override;
- bool list(const DNSName& target, int domain_id, bool include_disabled = false) override { return false; } // not supported
+ bool list(const DNSName& /* target */, int /* domain_id */, bool /* include_disabled */ = false) override { return false; } // not supported
bool get(DNSResourceRecord& r) override;
void reload() override;
- void rediscover(string* status = 0) override;
+ void rediscover(string* status = nullptr) override;
bool getDomainInfo(const DNSName& domain, DomainInfo& di, bool getSerial = true) override;
void getAllDomains(vector<DomainInfo>* domains, bool getSerial, bool include_disabled) override;
bool queryLocationV6(GeoIPNetmask& gl, const string& ip,
double& latitude, double& longitude,
- boost::optional<int>& alt, boost::optional<int>& prec) override
+ boost::optional<int>& /* alt */, boost::optional<int>& /* prec */) override
{
if (d_db_type == GEOIP_REGION_EDITION_REV0 || d_db_type == GEOIP_REGION_EDITION_REV1 || d_db_type == GEOIP_CITY_EDITION_REV0_V6 || d_db_type == GEOIP_CITY_EDITION_REV1_V6) {
std::unique_ptr<GeoIPRecord, geoiprecord_deleter> gir(GeoIP_record_by_addr_v6(d_gi.get(), ip.c_str()));
bool queryLocation(GeoIPNetmask& gl, const string& ip,
double& latitude, double& longitude,
- boost::optional<int>& alt, boost::optional<int>& prec) override
+ boost::optional<int>& /* alt */, boost::optional<int>& /* prec */) override
{
if (d_db_type == GEOIP_REGION_EDITION_REV0 || d_db_type == GEOIP_REGION_EDITION_REV1 || d_db_type == GEOIP_CITY_EDITION_REV0 || d_db_type == GEOIP_CITY_EDITION_REV1) {
std::unique_ptr<GeoIPRecord, geoiprecord_deleter> gir(GeoIP_record_by_addr(d_gi.get(), ip.c_str()));
bool queryLocation(GeoIPNetmask& gl, const string& ip,
double& latitude, double& longitude,
- boost::optional<int>& alt, boost::optional<int>& prec) override
+ boost::optional<int>& /* alt */, boost::optional<int>& prec) override
{
MMDB_entry_data_s data;
MMDB_lookup_result_s res;
bool queryLocationV6(GeoIPNetmask& gl, const string& ip,
double& latitude, double& longitude,
- boost::optional<int>& alt, boost::optional<int>& prec) override
+ boost::optional<int>& /* alt */, boost::optional<int>& prec) override
{
MMDB_entry_data_s data;
MMDB_lookup_result_s res;
}
}
- SSqlStatement* bind(const string& name, bool value)
+ SSqlStatement* bind(const string& /* name */, bool value)
{
prepareStatement();
if (d_paridx >= d_parnum) {
{
return bind(name, (unsigned long)value);
}
- SSqlStatement* bind(const string& name, long value)
+ SSqlStatement* bind(const string& /* name */, long value)
{
prepareStatement();
if (d_paridx >= d_parnum) {
d_paridx++;
return this;
}
- SSqlStatement* bind(const string& name, unsigned long value)
+ SSqlStatement* bind(const string& /* name */, unsigned long value)
{
prepareStatement();
if (d_paridx >= d_parnum) {
d_paridx++;
return this;
}
- SSqlStatement* bind(const string& name, long long value)
+ SSqlStatement* bind(const string& /* name */, long long value)
{
prepareStatement();
if (d_paridx >= d_parnum) {
d_paridx++;
return this;
}
- SSqlStatement* bind(const string& name, unsigned long long value)
+ SSqlStatement* bind(const string& /* name */, unsigned long long value)
{
prepareStatement();
if (d_paridx >= d_parnum) {
d_paridx++;
return this;
}
- SSqlStatement* bind(const string& name, const std::string& value)
+ SSqlStatement* bind(const string& /* name */, const std::string& value)
{
prepareStatement();
if (d_paridx >= d_parnum) {
d_paridx++;
return this;
}
- SSqlStatement* bindNull(const string& name)
+ SSqlStatement* bindNull(const string& /* name */)
{
prepareStatement();
if (d_paridx >= d_parnum) {
vector<ODBCParam> d_req_bind;
- SSqlStatement* bind(const string& name, ODBCParam& p)
+ SSqlStatement* bind(const string& /* name */, ODBCParam& p)
{
prepareStatement();
d_req_bind.push_back(p);
SSqlStatement* bind(const string& name, unsigned long value) { return bind(name, std::to_string(value)); }
SSqlStatement* bind(const string& name, long long value) { return bind(name, std::to_string(value)); }
SSqlStatement* bind(const string& name, unsigned long long value) { return bind(name, std::to_string(value)); }
- SSqlStatement* bind(const string& name, const std::string& value)
+ SSqlStatement* bind(const string& /* name */, const std::string& value)
{
prepareStatement();
allocate();
d_paridx++;
return this;
}
- SSqlStatement* bindNull(const string& name)
+ SSqlStatement* bindNull(const string& /* name */)
{
prepareStatement();
d_paridx++;
*
****************************/
-static int ldapGssapiAuthenticatorSaslInteractCallback(LDAP* conn, unsigned flags, void* defaults, void* in)
+static int ldapGssapiAuthenticatorSaslInteractCallback(LDAP* /* conn */, unsigned /* flags */, void* /* defaults */, void* /* in */)
{
return LDAP_SUCCESS;
}
-LdapGssapiAuthenticator::LdapGssapiAuthenticator(const std::string& kt, const std::string& ccache, int tmout) :
+LdapGssapiAuthenticator::LdapGssapiAuthenticator(const std::string& kt, const std::string& ccache, int /* tmout */) :
d_logPrefix("[LDAP GSSAPI] "), d_keytabFile(kt), d_cCacheFile(ccache)
{
krb5_error_code code;
#include "ldapbackend.hh"
#include <cstdlib>
-bool LdapBackend::list(const DNSName& target, int domain_id, bool include_disabled)
+bool LdapBackend::list(const DNSName& target, int domain_id, bool /* include_disabled */)
{
try {
d_in_list = true;
return false;
}
-bool LdapBackend::list_simple(const DNSName& target, int domain_id)
+bool LdapBackend::list_simple(const DNSName& target, int /* domain_id */)
{
string dn;
string filter;
}
}
-void LdapBackend::lookup_simple(const QType& qtype, const DNSName& qname, DNSPacket* dnspkt, int zoneid)
+void LdapBackend::lookup_simple(const QType& qtype, const DNSName& qname, DNSPacket* /* dnspkt */, int /* zoneid */)
{
string filter, attr, qesc;
const char** attributes = ldap_attrany + 1; // skip associatedDomain
d_search = d_pldap->search(getArg("basedn"), LDAP_SCOPE_SUBTREE, filter, attributes);
}
-void LdapBackend::lookup_strict(const QType& qtype, const DNSName& qname, DNSPacket* dnspkt, int zoneid)
+void LdapBackend::lookup_strict(const QType& qtype, const DNSName& qname, DNSPacket* /* dnspkt */, int /* zoneid */)
{
int len;
vector<string> parts;
d_search = d_pldap->search(getArg("basedn"), LDAP_SCOPE_SUBTREE, filter, attributes);
}
-void LdapBackend::lookup_tree(const QType& qtype, const DNSName& qname, DNSPacket* dnspkt, int zoneid)
+void LdapBackend::lookup_tree(const QType& qtype, const DNSName& qname, DNSPacket* /* dnspkt */, int /* zoneid */)
{
string filter, attr, qesc, dn;
const char** attributes = ldap_attrany + 1; // skip associatedDomain
return true;
}
-bool LdapBackend::getDomainInfo(const DNSName& domain, DomainInfo& di, bool getSerial)
+bool LdapBackend::getDomainInfo(const DNSName& domain, DomainInfo& di, bool /* getSerial */)
{
string filter;
SOAData sd;
// not much we can do now
}
-bool PowerLDAP::SearchResult::getNext(PowerLDAP::sentry_t& entry, bool dn, int timeout)
+bool PowerLDAP::SearchResult::getNext(PowerLDAP::sentry_t& entry, bool dn, int /* timeout */)
{
int i;
char* attr;
throw LDAPException("Failed to bind to LDAP server: " + authenticator->getError());
}
-void PowerLDAP::bind(const string& ldapbinddn, const string& ldapsecret, int method)
+void PowerLDAP::bind(const string& ldapbinddn, const string& ldapsecret, int /* method */)
{
int msgid;
{
template <class Archive>
- void save(Archive& ar, const DNSName& g, const unsigned int version)
+ void save(Archive& ar, const DNSName& g, const unsigned int /* version */)
{
if (g.empty()) {
ar& std::string();
}
template <class Archive>
- void load(Archive& ar, DNSName& g, const unsigned int version)
+ void load(Archive& ar, DNSName& g, const unsigned int /* version */)
{
string tmp;
ar& tmp;
}
template <class Archive>
- void save(Archive& ar, const QType& g, const unsigned int version)
+ void save(Archive& ar, const QType& g, const unsigned int /* version */)
{
ar& g.getCode();
}
template <class Archive>
- void load(Archive& ar, QType& g, const unsigned int version)
+ void load(Archive& ar, QType& g, const unsigned int /* version */)
{
uint16_t tmp;
ar& tmp;
}
template <class Archive>
- void save(Archive& ar, const DomainInfo& g, const unsigned int version)
+ void save(Archive& ar, const DomainInfo& g, const unsigned int /* version */)
{
ar& g.zone;
ar& g.last_check;
}
template <class Archive>
- void serialize(Archive& ar, LMDBBackend::DomainMeta& g, const unsigned int version)
+ void serialize(Archive& ar, LMDBBackend::DomainMeta& g, const unsigned int /* version */)
{
ar& g.domain& g.key& g.value;
}
template <class Archive>
- void save(Archive& ar, const LMDBBackend::KeyDataDB& g, const unsigned int version)
+ void save(Archive& ar, const LMDBBackend::KeyDataDB& g, const unsigned int /* version */)
{
ar& g.domain& g.content& g.flags& g.active& g.published;
}
}
template <class Archive>
- void serialize(Archive& ar, TSIGKey& g, const unsigned int version)
+ void serialize(Archive& ar, TSIGKey& g, const unsigned int /* version */)
{
ar& g.name;
ar& g.algorithm; // this is the ordername
return true;
}
-bool LMDBBackend::list(const DNSName& target, int id, bool include_disabled)
+bool LMDBBackend::list(const DNSName& target, int /* id */, bool include_disabled)
{
d_includedisabled = include_disabled;
return true;
}
-void LMDBBackend::lookup(const QType& type, const DNSName& qdomain, int zoneId, DNSPacket* p)
+void LMDBBackend::lookup(const QType& type, const DNSName& qdomain, int zoneId, DNSPacket* /* p */)
{
if (d_dolog) {
g_log << Logger::Warning << "Got lookup for " << qdomain << "|" << type.toString() << " in zone " << zoneId << endl;
return true;
}
-void LMDBBackend::getAllDomains(vector<DomainInfo>* domains, bool doSerial, bool include_disabled)
+void LMDBBackend::getAllDomains(vector<DomainInfo>* domains, bool /* doSerial */, bool include_disabled)
{
domains->clear();
auto txn = d_tdomains->getROTransaction();
g_log << Logger::Debug << "[" << getPrefix() << "] Got empty result" << endl;
}
- bool list(const DNSName& target, int domain_id, bool include_disabled = false) override
+ bool list(const DNSName& target, int domain_id, bool /* include_disabled */ = false) override
{
if (f_list == nullptr) {
g_log << Logger::Error << "[" << getPrefix() << "] dns_list missing - cannot do AXFR" << endl;
logResult("zone=" << di.zone << ",serial=" << di.serial << ",kind=" << di.getKindString());
}
- bool getDomainInfo(const DNSName& domain, DomainInfo& di, bool getSerial = true) override
+ bool getDomainInfo(const DNSName& domain, DomainInfo& di, bool /* getSerial */ = true) override
{
if (f_get_domaininfo == nullptr) {
// use getAuth instead
return true;
}
- void getAllDomains(vector<DomainInfo>* domains, bool getSerial, bool include_disabled) override
+ void getAllDomains(vector<DomainInfo>* domains, bool /* getSerial */, bool /* include_disabled */) override
{
if (f_get_all_domains == nullptr)
return;
receive(rcv);
}
-UnixRemote::UnixRemote(const string& path, int timeout)
+UnixRemote::UnixRemote(const string& path, int /* timeout */)
{
d_fd = socket(AF_UNIX, SOCK_STREAM, 0);
if (d_fd < 0)
d_qname = qname;
}
-bool PipeBackend::list(const DNSName& target, int inZoneId, bool include_disabled)
+bool PipeBackend::list(const DNSName& target, int inZoneId, bool /* include_disabled */)
{
try {
launch();
di.backend = this;
}
-bool RemoteBackend::getDomainInfo(const DNSName& domain, DomainInfo& di, bool getSerial)
+bool RemoteBackend::getDomainInfo(const DNSName& domain, DomainInfo& di, bool /* getSerial */)
{
if (domain.empty())
return false;
return true;
}
-bool RemoteBackend::feedRecord(const DNSResourceRecord& rr, const DNSName& ordername, bool ordernameIsNSEC3)
+bool RemoteBackend::feedRecord(const DNSResourceRecord& rr, const DNSName& ordername, bool /* ordernameIsNSEC3 */)
{
Json query = Json::object{
{"method", "feedRecord"},
return true;
}
-bool RemoteBackend::searchComments(const string& pattern, int maxResults, vector<Comment>& result)
+bool RemoteBackend::searchComments(const string& /* pattern */, int /* maxResults */, vector<Comment>& /* result */)
{
// FIXME: Implement Comment API
return false;
}
-void RemoteBackend::getAllDomains(vector<DomainInfo>* domains, bool getSerial, bool include_disabled)
+void RemoteBackend::getAllDomains(vector<DomainInfo>* domains, bool /* getSerial */, bool include_disabled)
{
Json query = Json::object{
{"method", "getAllDomains"},
}
}
-void RemoteBackend::getUpdatedMasters(vector<DomainInfo>& domains, std::unordered_set<DNSName>& catalogs, CatalogHashMap& catalogHashes)
+void RemoteBackend::getUpdatedMasters(vector<DomainInfo>& domains, std::unordered_set<DNSName>& /* catalogs */, CatalogHashMap& /* catalogHashes */)
{
Json query = Json::object{
{"method", "getUpdatedMasters"},
d_isWildcardQuery = false;
}
-void TinyDNSBackend::getUpdatedMasters(vector<DomainInfo>& retDomains, std::unordered_set<DNSName>& catalogs, CatalogHashMap& catalogHashes)
+void TinyDNSBackend::getUpdatedMasters(vector<DomainInfo>& retDomains, std::unordered_set<DNSName>& /* catalogs */, CatalogHashMap& /* catalogHashes */)
{
auto domainInfo = s_domainInfo.lock(); //TODO: We could actually lock less if we do it per suffix.
if (!domainInfo->count(d_suffix)) {
(*domainInfo)[d_suffix] = *domains;
}
-void TinyDNSBackend::getAllDomains(vector<DomainInfo>* domains, bool getSerial, bool include_disabled)
+void TinyDNSBackend::getAllDomains(vector<DomainInfo>* domains, bool getSerial, bool /* include_disabled */)
{
d_isAxfr = true;
d_isGetDomains = true;
}
}
-bool TinyDNSBackend::list(const DNSName& target, int domain_id, bool include_disabled)
+bool TinyDNSBackend::list(const DNSName& target, int /* domain_id */, bool /* include_disabled */)
{
d_isAxfr = true;
d_isGetDomains = false;
return d_cdbReader->searchSuffix(key);
}
-void TinyDNSBackend::lookup(const QType& qtype, const DNSName& qdomain, int zoneId, DNSPacket* pkt_p)
+void TinyDNSBackend::lookup(const QType& qtype, const DNSName& qdomain, int /* zoneId */, DNSPacket* pkt_p)
{
d_isAxfr = false;
d_isGetDomains = false;
}
static time_t s_start = time(nullptr);
-static uint64_t uptimeOfProcess(const std::string& str)
+static uint64_t uptimeOfProcess(const std::string& /* str */)
{
return time(nullptr) - s_start;
}
return (ru.ru_utime.tv_sec * 1000ULL + ru.ru_utime.tv_usec / 1000);
}
-static uint64_t getTCPConnectionCount(const std::string& str)
+static uint64_t getTCPConnectionCount(const std::string& /* str */)
{
return s_tcpNameserver->numTCPConnections();
}
-static uint64_t getQCount(const std::string& str)
+static uint64_t getQCount(const std::string& /* str */)
try {
int totcount = 0;
for (const auto& d : s_distributors) {
return 0;
}
-static uint64_t getLatency(const std::string& str)
+static uint64_t getLatency(const std::string& /* str */)
{
return round(avg_latency);
}
-static uint64_t getReceiveLatency(const std::string& str)
+static uint64_t getReceiveLatency(const std::string& /* str */)
{
return round(receive_latency);
}
-static uint64_t getCacheLatency(const std::string& str)
+static uint64_t getCacheLatency(const std::string& /* str */)
{
return round(cache_latency);
}
-static uint64_t getBackendLatency(const std::string& str)
+static uint64_t getBackendLatency(const std::string& /* str */)
{
return round(backend_latency);
}
-static uint64_t getSendLatency(const std::string& str)
+static uint64_t getSendLatency(const std::string& /* str */)
{
return round(send_latency);
}
}
static int cpid;
-static void takedown(int i)
+static void takedown(int /* i */)
{
if (cpid) {
g_log << Logger::Error << "Guardian is killed, taking down children with us" << endl;
static std::mutex g_guardian_lock;
// The next two methods are not in dynhandler.cc because they use a few items declared in this file.
-static string DLCycleHandler(const vector<string>& parts, pid_t ppid)
+static string DLCycleHandler(const vector<string>& /* parts */, pid_t /* ppid */)
{
kill(cpid, SIGKILL); // why?
kill(cpid, SIGKILL); // why?
return "ok";
}
-static string DLRestHandler(const vector<string>& parts, pid_t ppid)
+static string DLRestHandler(const vector<string>& parts, pid_t /* ppid */)
{
string line;
return true;
}
-void GSQLBackend::lookup(const QType &qtype,const DNSName &qname, int domain_id, DNSPacket *pkt_p)
+void GSQLBackend::lookup(const QType& qtype, const DNSName& qname, int domain_id, DNSPacket* /* pkt_p */)
{
try {
reconnectIfNeeded();
return true;
}
-bool GSQLBackend::feedRecord(const DNSResourceRecord &r, const DNSName &ordername, bool ordernameIsNSEC3)
+bool GSQLBackend::feedRecord(const DNSResourceRecord& r, const DNSName& ordername, bool /* ordernameIsNSEC3 */)
{
int prio=0;
string content(r.content);
return true;
}
-bool GSQLBackend::feedEnts3(int domain_id, const DNSName &domain, map<DNSName,bool> &nonterm, const NSEC3PARAMRecordContent& ns3prc, bool narrow)
+bool GSQLBackend::feedEnts3(int domain_id, const DNSName& /* domain */, map<DNSName, bool>& nonterm, const NSEC3PARAMRecordContent& ns3prc, bool narrow)
{
if(!d_dnssecQueries)
return false;
virtual void startTransaction()=0;
virtual void rollback()=0;
virtual void commit()=0;
- virtual void setLog(bool state){}
+ virtual void setLog(bool /* state */){}
virtual bool isConnectionUsable()
{
return true;
// the ritual is that the oldest entries are in *front* of the sequence collection, so on a hit, move an item to the end
// and optionally, on a miss, move it to the beginning
template <typename S, typename C, typename T>
-void pruneCollection(C& container, T& collection, size_t maxCached, size_t scanFraction = 1000)
+void pruneCollection(C& /* container */, T& collection, size_t maxCached, size_t scanFraction = 1000)
{
const time_t now = time(nullptr);
size_t toTrim = 0;
struct sigaction sa;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
- sa.sa_handler = [](int s) {};
+ sa.sa_handler = [](int /* s */) {};
sigaction(SIGALRM, &sa, &signals[SIGALRM]);
sigaction(SIGHUP, &sa, &signals[SIGHUP]);
sigaction(SIGINT, &sa, &signals[SIGINT]);
return false;
}
-bool DNSSECKeeper::getTSIGForAccess(const DNSName& zone, const ComboAddress& master, DNSName* keyname)
+bool DNSSECKeeper::getTSIGForAccess(const DNSName& zone, const ComboAddress& /* master */, DNSName* keyname)
{
vector<string> keynames;
d_keymetadb->getDomainMetadata(zone, "AXFR-MASTER-TSIG", keynames);
return false;
}
-bool DNSSECKeeper::unSecureZone(const DNSName& zone, string& error, string& info) {
+bool DNSSECKeeper::unSecureZone(const DNSName& zone, string& error, string& /* info */) {
// Not calling isSecuredZone(), as it will return false for zones with zero
// active keys.
DNSSECKeeper::keyset_t keyset=getKeys(zone);
return ret;
}
-void DNSBackend::getAllDomains(vector<DomainInfo>* domains, bool getSerial, bool include_disabled)
+void DNSBackend::getAllDomains(vector<DomainInfo>* /* domains */, bool /* getSerial */, bool /* include_disabled */)
{
if (g_zoneCache.isEnabled()) {
g_log << Logger::Error << "One of the backends does not support zone caching. Put zone-cache-refresh-interval=0 in the config file to disable this cache." << endl;
//! 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 replaceRRSet(uint32_t domain_id, const DNSName& qname, const QType& qt, const vector<DNSResourceRecord>& rrset)
+ virtual bool replaceRRSet(uint32_t /* domain_id */, const DNSName& /* qname */, const QType& /* qt */, const vector<DNSResourceRecord>& /* rrset */)
{
return false;
}
- virtual bool listSubZone(const DNSName &zone, int domain_id)
+ virtual bool listSubZone(const DNSName& /* zone */, int /* domain_id */)
{
return false;
}
bool isDnssecDomainMetadata (const string& name) {
return (name == "PRESIGNED" || name == "NSEC3PARAM" || name == "NSEC3NARROW");
}
- virtual bool getAllDomainMetadata(const DNSName& name, std::map<std::string, std::vector<std::string> >& meta) { return false; };
- virtual bool getDomainMetadata(const DNSName& name, const std::string& kind, std::vector<std::string>& meta) { return false; }
+ virtual bool getAllDomainMetadata(const DNSName& /* name */, std::map<std::string, std::vector<std::string>>& /* meta */) { return false; };
+ virtual bool getDomainMetadata(const DNSName& /* name */, const std::string& /* kind */, std::vector<std::string>& /* meta */) { return false; }
virtual bool getDomainMetadataOne(const DNSName& name, const std::string& kind, std::string& value)
{
std::vector<std::string> meta;
return false;
}
- virtual bool setDomainMetadata(const DNSName& name, const std::string& kind, const std::vector<std::string>& meta) {return false;}
+ virtual bool setDomainMetadata(const DNSName& /* name */, const std::string& /* kind */, const std::vector<std::string>& /* meta */) { return false; }
virtual bool setDomainMetadataOne(const DNSName& name, const std::string& kind, const std::string& value)
{
const std::vector<std::string> meta(1, value);
virtual void getAllDomains(vector<DomainInfo>* domains, bool getSerial, bool include_disabled);
/** Determines if we are authoritative for a zone, and at what level */
- virtual bool getAuth(const DNSName &target, SOAData *sd);
+ virtual bool getAuth(const DNSName& target, SOAData* /* sd */);
struct KeyData {
std::string content;
bool published;
};
- virtual bool getDomainKeys(const DNSName& name, std::vector<KeyData>& keys) { return false;}
- virtual bool removeDomainKey(const DNSName& name, unsigned int id) { return false; }
- virtual bool addDomainKey(const DNSName& name, const KeyData& key, int64_t& id){ return false; }
- virtual bool activateDomainKey(const DNSName& name, unsigned int id) { return false; }
- virtual bool deactivateDomainKey(const DNSName& name, unsigned int id) { return false; }
- virtual bool publishDomainKey(const DNSName& name, unsigned int id) { return false; }
- virtual bool unpublishDomainKey(const DNSName& name, unsigned int id) { return false; }
+ virtual bool getDomainKeys(const DNSName& /* name */, std::vector<KeyData>& /* keys */) { return false; }
+ virtual bool removeDomainKey(const DNSName& /* name */, unsigned int /* id */) { return false; }
+ virtual bool addDomainKey(const DNSName& /* name */, const KeyData& /* key */, int64_t& /* id */) { return false; }
+ virtual bool activateDomainKey(const DNSName& /* name */, unsigned int /* id */) { return false; }
+ virtual bool deactivateDomainKey(const DNSName& /* name */, unsigned int /* id */) { return false; }
+ virtual bool publishDomainKey(const DNSName& /* name */, unsigned int /* id */) { return false; }
+ virtual bool unpublishDomainKey(const DNSName& /* name */, unsigned int /* id */) { return false; }
- virtual bool setTSIGKey(const DNSName& name, const DNSName& algorithm, const string& content) { return false; }
- virtual bool getTSIGKey(const DNSName& name, DNSName& algorithm, string& content) { return false; }
- virtual bool getTSIGKeys(std::vector<struct TSIGKey>& keys) { return false; }
- virtual bool deleteTSIGKey(const DNSName& name) { return false; }
+ virtual bool setTSIGKey(const DNSName& /* name */, const DNSName& /* algorithm */, const string& /* content */) { return false; }
+ virtual bool getTSIGKey(const DNSName& /* name */, DNSName& /* algorithm */, string& /* content */) { return false; }
+ virtual bool getTSIGKeys(std::vector<struct TSIGKey>& /* keys */) { return false; }
+ virtual bool deleteTSIGKey(const DNSName& /* name */) { return false; }
- virtual bool getBeforeAndAfterNamesAbsolute(uint32_t id, const DNSName& qname, DNSName& unhashed, DNSName& before, DNSName& after)
+ virtual bool getBeforeAndAfterNamesAbsolute(uint32_t /* id */, const DNSName& /* qname */, DNSName& /* unhashed */, DNSName& /* before */, DNSName& /* after */)
{
- std::cerr<<"Default beforeAndAfterAbsolute called!"<<std::endl;
+ std::cerr << "Default beforeAndAfterAbsolute called!" << std::endl;
abort();
return false;
}
- virtual bool getBeforeAndAfterNames(uint32_t id, const DNSName& zonename, const DNSName& qname, DNSName& before, DNSName& after);
+ virtual bool getBeforeAndAfterNames(uint32_t /* id */, const DNSName& zonename, const DNSName& qname, DNSName& before, DNSName& after);
- virtual bool updateDNSSECOrderNameAndAuth(uint32_t domain_id, const DNSName& qname, const DNSName& ordername, bool auth, const uint16_t qtype=QType::ANY)
+ virtual bool updateDNSSECOrderNameAndAuth(uint32_t /* domain_id */, const DNSName& /* qname */, const DNSName& /* ordername */, bool /* auth */, const uint16_t /* qtype */ = QType::ANY)
{
return false;
}
- virtual bool updateEmptyNonTerminals(uint32_t domain_id, set<DNSName>& insert, set<DNSName>& erase, bool remove)
+ virtual bool updateEmptyNonTerminals(uint32_t /* domain_id */, set<DNSName>& /* insert */, set<DNSName>& /* erase */, bool /* remove */)
{
return false;
}
// end DNSSEC
// comments support
- virtual bool listComments(uint32_t domain_id)
+ virtual bool listComments(uint32_t /* domain_id */)
{
return false; // unsupported by this backend
}
- virtual bool getComment(Comment& comment)
+ virtual bool getComment(Comment& /* comment */)
{
return false;
}
- virtual void feedComment(const Comment& comment)
+ virtual void feedComment(const Comment& /* comment */)
{
}
- virtual bool replaceComments(const uint32_t domain_id, const DNSName& qname, const QType& qt, const vector<Comment>& comments)
+ virtual bool replaceComments(const uint32_t /* domain_id */, const DNSName& /* qname */, const QType& /* qt */, const vector<Comment>& /* comments */)
{
return false;
}
//! returns true if master ip is master for domain name.
//! starts the transaction for updating domain qname (FIXME: what is id?)
- virtual bool startTransaction(const DNSName &qname, int id=-1)
+ virtual bool startTransaction(const DNSName& /* qname */, int /* id */ = -1)
{
return false;
}
{
}
- virtual void rediscover(string* status=0)
+ virtual void rediscover(string* /* status */ = nullptr)
{
}
//! feeds a record to a zone, needs a call to startTransaction first
- virtual bool feedRecord(const DNSResourceRecord &rr, const DNSName &ordername, bool ordernameIsNSEC3=false)
+ virtual bool feedRecord(const DNSResourceRecord& /* rr */, const DNSName& /* ordername */, bool /* ordernameIsNSEC3 */ = false)
{
return false; // no problem!
}
- virtual bool feedEnts(int domain_id, map<DNSName,bool> &nonterm)
+ virtual bool feedEnts(int /* domain_id */, map<DNSName, bool>& /* nonterm */)
{
return false;
}
- virtual bool feedEnts3(int domain_id, const DNSName &domain, map<DNSName,bool> &nonterm, const NSEC3PARAMRecordContent& ns3prc, bool narrow)
+ virtual bool feedEnts3(int /* domain_id */, const DNSName& /* domain */, map<DNSName, bool>& /* nonterm */, const NSEC3PARAMRecordContent& /* ns3prc */, bool /* narrow */)
{
return false;
}
//! if this returns true, DomainInfo di contains information about the domain
- virtual bool getDomainInfo(const DNSName &domain, DomainInfo &di, bool getSerial=true)
+ virtual bool getDomainInfo(const DNSName& /* domain */, DomainInfo& /* di */, bool /* getSerial */ = true)
{
return false;
}
//! slave capable backends should return a list of slaves that should be rechecked for staleness
- virtual void getUnfreshSlaveInfos(vector<DomainInfo>* domains)
+ virtual void getUnfreshSlaveInfos(vector<DomainInfo>* /* domains */)
{
}
//! get a list of IP addresses that should also be notified for a domain
- virtual void alsoNotifies(const DNSName &domain, set<string> *ips)
+ virtual void alsoNotifies(const DNSName& domain, set<string>* ips)
{
std::vector<std::string> meta;
getDomainMetadata(domain, "ALSO-NOTIFY", meta);
}
//! get list of domains that have been changed since their last notification to slaves
- virtual void getUpdatedMasters(vector<DomainInfo>& domains, std::unordered_set<DNSName>& catalogs, CatalogHashMap& catalogHashes)
+ virtual void getUpdatedMasters(vector<DomainInfo>& /* domains */, std::unordered_set<DNSName>& /* catalogs */, CatalogHashMap& /* catalogHashes */)
{
}
//! get list of all members in a catalog
- virtual bool getCatalogMembers(const DNSName& catalog, vector<CatalogInfo>& members, CatalogInfo::CatalogType type)
+ virtual bool getCatalogMembers(const DNSName& /* catalog */, vector<CatalogInfo>& /* members */, CatalogInfo::CatalogType /* type */)
{
return false;
}
//! Called by PowerDNS to inform a backend that a domain need to be checked for freshness
- virtual void setStale(uint32_t domain_id)
+ virtual void setStale(uint32_t /* domain_id */)
{
}
//! Called by PowerDNS to inform a backend that a domain has been checked for freshness
- virtual void setFresh(uint32_t domain_id)
+ virtual void setFresh(uint32_t /* domain_id */)
{
}
//! Called by PowerDNS to inform a backend that the changes in the domain have been reported to slaves
- virtual void setNotified(uint32_t id, uint32_t serial)
+ virtual void setNotified(uint32_t /* id */, uint32_t /* serial */)
{
}
//! Called when the Master list of a domain should be changed
- virtual bool setMasters(const DNSName &domain, const vector<ComboAddress> &masters)
+ virtual bool setMasters(const DNSName& /* domain */, const vector<ComboAddress>& /* masters */)
{
return false;
}
//! Called when the Kind of a domain should be changed (master -> native and similar)
- virtual bool setKind(const DNSName &domain, const DomainInfo::DomainKind kind)
+ virtual bool setKind(const DNSName& /* domain */, const DomainInfo::DomainKind /* kind */)
{
return false;
}
//! Called when the options of a domain should be changed
- virtual bool setOptions(const DNSName& domain, const string& options)
+ virtual bool setOptions(const DNSName& /* domain */, const string& /* options */)
{
return false;
}
//! Called when the catalog of a domain should be changed
- virtual bool setCatalog(const DNSName& domain, const DNSName& catalog)
+ virtual bool setCatalog(const DNSName& /* domain */, const DNSName& /* catalog */)
{
return false;
}
//! Called when the Account of a domain should be changed
- virtual bool setAccount(const DNSName &domain, const string &account)
+ virtual bool setAccount(const DNSName& /* domain */, const string& /* account */)
{
return false;
}
void setArgPrefix(const string &prefix);
//! Add an entry for a super master
- virtual bool superMasterAdd(const struct AutoPrimary& primary)
+ virtual bool superMasterAdd(const struct AutoPrimary& /* primary */)
{
- return false;
+ return false;
}
//! Remove an entry for a super master
- virtual bool autoPrimaryRemove(const struct AutoPrimary& primary)
+ virtual bool autoPrimaryRemove(const struct AutoPrimary& /* primary */)
{
return false;
}
//! List all SuperMasters, returns false if feature not supported.
- virtual bool autoPrimariesList(std::vector<AutoPrimary>& primaries)
+ virtual bool autoPrimariesList(std::vector<AutoPrimary>& /* primaries */)
{
return false;
}
//! determine if ip is a supermaster or a domain
- virtual bool superMasterBackend(const string &ip, const DNSName &domain, const vector<DNSResourceRecord>&nsset, string *nameserver, string *account, DNSBackend **db)
+ virtual bool superMasterBackend(const string& /* ip */, const DNSName& /* domain */, const vector<DNSResourceRecord>& /* nsset */, string* /* nameserver */, string* /* account */, DNSBackend** /* db */)
{
return false;
}
//! called by PowerDNS to create a new domain
- virtual bool createDomain(const DNSName& domain, const DomainInfo::DomainKind kind, const vector<ComboAddress>& masters, const string& account)
+ virtual bool createDomain(const DNSName& /* domain */, const DomainInfo::DomainKind /* kind */, const vector<ComboAddress>& /* masters */, const string& /* account */)
{
return false;
}
//! called by PowerDNS to create a slave record for a superMaster
- virtual bool createSlaveDomain(const string& ip, const DNSName& domain, const string& nameserver, const string& account)
+ virtual bool createSlaveDomain(const string& /* ip */, const DNSName& /* domain */, const string& /* nameserver */, const string& /* account */)
{
return false;
}
//! called to delete a domain, incl. all metadata, zone contents, etc.
- virtual bool deleteDomain(const DNSName &domain)
+ virtual bool deleteDomain(const DNSName& /* domain */)
{
return false;
}
- virtual string directBackendCmd(const string &query)
+ virtual string directBackendCmd(const string& /* query */)
{
return "directBackendCmd not supported for this backend\n";
}
//! Search for records, returns true if search was done successfully.
- virtual bool searchRecords(const string &pattern, int maxResults, vector<DNSResourceRecord>& result)
+ virtual bool searchRecords(const string& /* pattern */, int /* maxResults */, vector<DNSResourceRecord>& /* result */)
{
return false;
}
//! Search for comments, returns true if search was done successfully.
- virtual bool searchComments(const string &pattern, int maxResults, vector<Comment>& result)
+ virtual bool searchComments(const string& /* pattern */, int /* maxResults */, vector<Comment>& /* result */)
{
return false;
}
{
return this->make(suffix);
}
- virtual void declareArguments(const string &suffix=""){}
- const string &getName() const;
-
+ virtual void declareArguments(const string& /* suffix */ = "") {}
+ [[nodiscard]] const string& getName() const;
+
protected:
void declare(const string &suffix, const string ¶m, const string &explanation, const string &value);
ageDNSPacket(reinterpret_cast<char *>(&response[0]), response.size(), age);
}
else {
- editDNSPacketTTL(reinterpret_cast<char *>(&response[0]), response.size(),
- [staleTTL = d_staleTTL](uint8_t section, uint16_t class_, uint16_t type, uint32_t ttl) { return staleTTL; });
+ editDNSPacketTTL(reinterpret_cast<char*>(&response[0]), response.size(),
+ [staleTTL = d_staleTTL](uint8_t /* section */, uint16_t /* class_ */, uint16_t /* type */, uint32_t /* ttl */) { return staleTTL; });
}
}
}
bool found = false;
- bool valid = visitDNSPacket(value.value, [addr, &found](uint8_t section, uint16_t qclass, uint16_t qtype, uint32_t ttl, uint16_t rdatalength, const char* rdata) {
-
+ bool valid = visitDNSPacket(value.value, [addr, &found](uint8_t /* section */, uint16_t qclass, uint16_t qtype, uint32_t /* ttl */, uint16_t rdatalength, const char* rdata) {
if (qtype == QType::A && qclass == QClass::IN && addr.isIPv4() && rdatalength == 4 && rdata != nullptr) {
ComboAddress parsed;
parsed.sin4.sin_family = AF_INET;
continue;
}
- visitDNSPacket(value.value, [&addresses](uint8_t section, uint16_t qclass, uint16_t qtype, uint32_t ttl, uint16_t rdatalength, const char* rdata) {
-
+ visitDNSPacket(value.value, [&addresses](uint8_t /* section */, uint16_t qclass, uint16_t qtype, uint32_t /* ttl */, uint16_t rdatalength, const char* rdata) {
if (qtype == QType::A && qclass == QClass::IN && rdatalength == 4 && rdata != nullptr) {
ComboAddress parsed;
parsed.sin4.sin_family = AF_INET;
CacheShard()
{
}
- CacheShard(const CacheShard& old)
+ CacheShard(const CacheShard& /* old */)
{
}
d_record.insert(d_record.end(), out.begin(), out.end());
}
-string UnknownRecordContent::getZoneRepresentation(bool noDot) const
+string UnknownRecordContent::getZoneRepresentation(bool /* noDot */) const
{
ostringstream str;
str<<"\\# "<<(unsigned int)d_record.size()<<" ";
}
-void PacketReader::xfrHexBlob(string& blob, bool keepReading)
+void PacketReader::xfrHexBlob(string& blob, bool /* keepReading */)
{
xfrBlob(blob);
}
val=get8BitInt();
}
-
- void xfrName(DNSName &name, bool compress=false, bool noDot=false)
+ void xfrName(DNSName& name, bool /* compress */ = false, bool /* noDot */ = false)
{
- name=getName();
+ name = getName();
}
void xfrText(string &text, bool multi=false, bool lenField=true)
string blob(d_eui48, d_eui48+6);
pw.xfrBlob(blob);
}
-string EUI48RecordContent::getZoneRepresentation(bool noDot) const
+
+string EUI48RecordContent::getZoneRepresentation(bool /* noDot */) const
{
char tmp[18];
snprintf(tmp,sizeof(tmp),"%02x-%02x-%02x-%02x-%02x-%02x",
string blob(d_eui64, d_eui64+8);
pw.xfrBlob(blob);
}
-string EUI64RecordContent::getZoneRepresentation(bool noDot) const
+
+string EUI64RecordContent::getZoneRepresentation(bool /* noDot */) const
{
char tmp[24];
snprintf(tmp,sizeof(tmp),"%02x-%02x-%02x-%02x-%02x-%02x-%02x-%02x",
}
// Decode record into string
-string APLRecordContent::getZoneRepresentation(bool noDot) const {
+string APLRecordContent::getZoneRepresentation(bool /* noDot */) const {
string s_n, s_family, output;
ComboAddress ca;
Netmask nm;
return false;
}
-DNSRecord makeOpt(const uint16_t udpsize, const uint16_t extRCode, const uint16_t extFlags)
+DNSRecord makeOpt(const uint16_t udpsize, const uint16_t /* extRCode */, const uint16_t extFlags)
{
EDNS0Record stuff;
stuff.extRCode=0;
}
-#define boilerplate_conv(RNAME, CONV) \
-boilerplate(RNAME) \
-template<class Convertor> \
-void RNAME##RecordContent::xfrPacket(Convertor& conv, bool noDot) \
-{ \
- CONV; \
+#define boilerplate_conv(RNAME, CONV) \
+boilerplate(RNAME) \
+template<class Convertor> \
+void RNAME##RecordContent::xfrPacket(Convertor& conv, bool /* noDot */) \
+{ \
+ CONV; \
if (conv.eof() == false) throw MOADNSException("When parsing " #RNAME " trailing data was not parsed: '" + conv.getRemaining() + "'"); \
-} \
+} \
struct EDNSOpts
{
}
};
-static void visitor(const StatNode* node, const StatNode::Stat& selfstat, const StatNode::Stat& childstat)
+static void visitor(const StatNode* node, const StatNode::Stat& /* selfstat */, const StatNode::Stat& childstat)
{
// 20% servfails, >100 children, on average less than 2 copies of a query
// >100 different subqueries
toSign.clear();
}
-uint64_t signatureCacheSize(const std::string& str)
+uint64_t signatureCacheSize(const std::string& /* str */)
{
return g_signatures.read_lock()->size();
}
xfrBlob(blob);
}
-template <typename Container> void GenericDNSPacketWriter<Container>::xfrHexBlob(const string& blob, bool keepReading)
+template <typename Container> void GenericDNSPacketWriter<Container>::xfrHexBlob(const string& blob, bool /* keepReading */)
{
xfrBlob(blob);
}
{
}
- void rotateTicketsKey(time_t now)
+ void rotateTicketsKey(time_t /* now */)
{
}
- void loadTicketsKeys(const std::string& keyFile)
+ void loadTicketsKeys(const std::string& /* keyFile */)
{
}
return s_pleasequit;
}
-string DLQuitHandler(const vector<string>&parts, Utility::pid_t ppid)
+string DLQuitHandler(const vector<string>& parts, Utility::pid_t /* ppid */)
{
string ret="No return value";
if(parts[0]=="QUIT") {
exit(0);
}
-string DLCurrentConfigHandler(const vector<string>&parts, Utility::pid_t ppid)
+string DLCurrentConfigHandler(const vector<string>& parts, Utility::pid_t /* ppid */)
{
if(parts.size() > 1) {
if(parts.size() == 2 && parts[1] == "diff") {
return ::arg().configstring(true, true);
}
-string DLRQuitHandler(const vector<string>&parts, Utility::pid_t ppid)
+string DLRQuitHandler(const vector<string>& /* parts */, Utility::pid_t /* ppid */)
{
signal(SIGALRM, dokill);
alarm(1);
return "Exiting";
}
-string DLPingHandler(const vector<string>&parts, Utility::pid_t ppid)
+string DLPingHandler(const vector<string>& /* parts */, Utility::pid_t /* ppid */)
{
return "PONG";
}
-string DLShowHandler(const vector<string>&parts, Utility::pid_t ppid) {
+string DLShowHandler(const vector<string>& parts, Utility::pid_t /* ppid */)
+{
try {
extern StatBag S;
string ret("Wrong number of parameters");
d_status=str;
}
-string DLStatusHandler(const vector<string>&parts, Utility::pid_t ppid)
+string DLStatusHandler(const vector<string>& /* parts */, Utility::pid_t ppid)
{
ostringstream os;
os<<ppid<<": "<<d_status;
return os.str();
}
-string DLUptimeHandler(const vector<string>&parts, Utility::pid_t ppid)
+string DLUptimeHandler(const vector<string>& /* parts */, Utility::pid_t /* ppid */)
{
ostringstream os;
os<<humanDuration(time(nullptr)-g_starttime);
return os.str();
}
-string DLPurgeHandler(const vector<string>&parts, Utility::pid_t ppid)
+string DLPurgeHandler(const vector<string>& parts, Utility::pid_t /* ppid */)
{
ostringstream os;
int ret=0;
return os.str();
}
-string DLCCHandler(const vector<string>&parts, Utility::pid_t ppid)
+string DLCCHandler(const vector<string>& /* parts */, Utility::pid_t /* ppid */)
{
extern AuthPacketCache PC;
extern AuthQueryCache QC;
ostringstream os;
bool first=true;
for(map<char,uint64_t>::const_iterator i=counts.begin();i!=counts.end();++i) {
- if(!first)
+ if(!first)
os<<", ";
first=false;
os<<"negative queries: ";
else if(i->first=='Q')
os<<"queries: ";
- else
+ else
os<<"unknown: ";
os<<i->second;
}
- if(!first)
+ if(!first)
os<<", ";
os<<"packets: "<<packetEntries;
return os.str();
}
-string DLQTypesHandler(const vector<string>&parts, Utility::pid_t ppid)
+string DLQTypesHandler(const vector<string>& /* parts */, Utility::pid_t /* ppid */)
{
return g_rs.getQTypeReport();
}
-string DLRSizesHandler(const vector<string>&parts, Utility::pid_t ppid)
+string DLRSizesHandler(const vector<string>& /* parts */, Utility::pid_t /* ppid */)
{
typedef map<uint16_t, uint64_t> respsizes_t;
respsizes_t respsizes = g_rs.getSizeResponseCounts();
return os.str();
}
-string DLRemotesHandler(const vector<string>&parts, Utility::pid_t ppid)
+string DLRemotesHandler(const vector<string>& /* parts */, Utility::pid_t /* ppid */)
{
extern StatBag S;
typedef vector<pair<string, unsigned int> > totals_t;
return ret;
}
-string DLSettingsHandler(const vector<string>&parts, Utility::pid_t ppid)
+string DLSettingsHandler(const vector<string>& parts, Utility::pid_t /* ppid */)
{
static const char *whitelist[]={"query-logging",nullptr};
const char **p;
if(parts.size()!=3) {
return "Syntax: set variable value";
}
-
+
for(p=whitelist;*p;p++)
if(*p==parts[1])
break;
}
-string DLVersionHandler(const vector<string>&parts, Utility::pid_t ppid)
+string DLVersionHandler(const vector<string>& /* parts */, Utility::pid_t /* ppid */)
{
return VERSION;
}
-string DLNotifyRetrieveHandler(const vector<string>&parts, Utility::pid_t ppid)
+string DLNotifyRetrieveHandler(const vector<string>& parts, Utility::pid_t /* ppid */)
{
extern CommunicatorClass Communicator;
ostringstream os;
return "Added retrieval request for '" + domain.toLogString() + "' from primary " + master.toLogString();
}
-string DLNotifyHostHandler(const vector<string>&parts, Utility::pid_t ppid)
+string DLNotifyHostHandler(const vector<string>& parts, Utility::pid_t /* ppid */)
{
extern CommunicatorClass Communicator;
ostringstream os;
return "Added to queue";
}
-string DLNotifyHandler(const vector<string>&parts, Utility::pid_t ppid)
+string DLNotifyHandler(const vector<string>& parts, Utility::pid_t /* ppid */)
{
extern CommunicatorClass Communicator;
UeberBackend B;
}
}
-string DLRediscoverHandler(const vector<string>&parts, Utility::pid_t ppid)
+string DLRediscoverHandler(const vector<string>& /* parts */, Utility::pid_t /* ppid */)
{
UeberBackend B;
try {
}
-string DLReloadHandler(const vector<string>&parts, Utility::pid_t ppid)
+string DLReloadHandler(const vector<string>& /* parts */, Utility::pid_t /* ppid */)
{
UeberBackend B;
B.reload();
return "Ok";
}
-
-string DLListZones(const vector<string>&parts, Utility::pid_t ppid)
+string DLListZones(const vector<string>& parts, Utility::pid_t /* ppid */)
{
UeberBackend B;
g_log<<Logger::Notice<<"Received request to list zones."<<endl;
extern bool PKCS11ModuleSlotLogin(const std::string& module, const string& tokenId, const std::string& pin);
#endif
-string DLTokenLogin(const vector<string>&parts, Utility::pid_t ppid)
+string DLTokenLogin(const vector<string>& parts, Utility::pid_t /* ppid */)
{
#ifndef HAVE_P11KIT1
return "PKCS#11 support not compiled in";
#endif
}
-string DLSuckRequests(const vector<string> &parts, Utility::pid_t ppid) {
+string DLSuckRequests(const vector<string>& /* parts */, Utility::pid_t /* ppid */)
+{
string ret;
for (auto const &d: Communicator.getSuckRequests()) {
ret += d.first.toString() + " " + d.second.toString() + "\n";
void registerDomain(const DNSName& d) {
domainStats[d].haveZone = false;
}
- void incrementUnknownDomainInQueries(const DNSName &d) { // the name is ignored. It would be great to report it, but we don't want to blow up Prometheus
+
+ void incrementUnknownDomainInQueries(const DNSName& /* d */)
+ { // the name is ignored. It would be great to report it, but we don't want to blow up Prometheus
progStats.unknownDomainInQueries += 1;
}
+
private:
class perDomainStat {
public:
/* Produces an IXFR if one can be made according to the rules in RFC 1995 and
* creates a SOA or AXFR packet when required by the RFC.
*/
-static bool handleIXFR(int fd, const ComboAddress& destination, const MOADNSParser& mdp, const shared_ptr<SOARecordContent>& clientSOA) {
+static bool handleIXFR(int fd, const ComboAddress& /* destination */, const MOADNSParser& mdp, const shared_ptr<SOARecordContent>& clientSOA) {
vector<std::shared_ptr<ixfrdiff_t>> toSend;
/* we get a shared pointer of the zone info that we can't modify, ever.
lua.executeCode(boost::str(boost::format("debug.sethook(report, '', %d)") % g_luaRecordExecLimit));
}
- lua.writeFunction("report", [](string event, boost::optional<string> line){
+ lua.writeFunction("report", [](string /* event */, boost::optional<string> /* line */){
throw std::runtime_error("Script took too long");
});
}
#if defined(LIBCURL_VERSION_NUM) && LIBCURL_VERSION_NUM >= 0x072000 // 7.32.0
-size_t MiniCurl::progress_callback(void *clientp, curl_off_t dltotal, curl_off_t dlnow, curl_off_t ultotal, curl_off_t ulnow)
+size_t MiniCurl::progress_callback(void *clientp, curl_off_t /* dltotal */, curl_off_t dlnow, curl_off_t /* ultotal */, curl_off_t /* ulnow */)
{
if (clientp != nullptr) {
MiniCurl* us = static_cast<MiniCurl*>(clientp);
return 0;
}
-uint64_t tcpErrorStats(const std::string& str)
+uint64_t tcpErrorStats(const std::string& /* str */)
{
#ifdef __linux__
ifstream ifs("/proc/net/netstat");
return 0;
}
-uint64_t getCPUIOWait(const std::string& str)
+uint64_t getCPUIOWait(const std::string& /* str */)
{
#ifdef __linux__
ifstream ifs("/proc/stat");
return 0;
}
-uint64_t getCPUSteal(const std::string& str)
+uint64_t getCPUSteal(const std::string& /* str */)
{
#ifdef __linux__
ifstream ifs("/proc/stat");
d_bitmap.toPacket(pw);
}
-std::shared_ptr<NSECRecordContent::DNSRecordContent> NSECRecordContent::make(const DNSRecord &dr, PacketReader& pr)
+std::shared_ptr<NSECRecordContent::DNSRecordContent> NSECRecordContent::make(const DNSRecord & /* dr */, PacketReader& pr)
{
auto ret=std::make_shared<NSECRecordContent>();
pr.xfrName(ret->d_next);
return ret;
}
-string NSECRecordContent::getZoneRepresentation(bool noDot) const
+string NSECRecordContent::getZoneRepresentation(bool /* noDot */) const
{
string ret;
RecordTextWriter rtw(ret);
d_bitmap.toPacket(pw);
}
-std::shared_ptr<NSEC3RecordContent::DNSRecordContent> NSEC3RecordContent::make(const DNSRecord &dr, PacketReader& pr)
+std::shared_ptr<NSEC3RecordContent::DNSRecordContent> NSEC3RecordContent::make(const DNSRecord& /* dr */, PacketReader& pr)
{
auto ret=std::make_shared<NSEC3RecordContent>();
pr.xfr8BitInt(ret->d_algorithm);
return ret;
}
-string NSEC3RecordContent::getZoneRepresentation(bool noDot) const
+string NSEC3RecordContent::getZoneRepresentation(bool /* noDot */) const
{
string ret;
RecordTextWriter rtw(ret);
pw.xfrBlob(d_salt);
}
-std::shared_ptr<NSEC3PARAMRecordContent::DNSRecordContent> NSEC3PARAMRecordContent::make(const DNSRecord &dr, PacketReader& pr)
+std::shared_ptr<NSEC3PARAMRecordContent::DNSRecordContent> NSEC3PARAMRecordContent::make(const DNSRecord& /* dr */, PacketReader& pr)
{
auto ret=std::make_shared<NSEC3PARAMRecordContent>();
pr.xfr8BitInt(ret->d_algorithm);
return ret;
}
-string NSEC3PARAMRecordContent::getZoneRepresentation(bool noDot) const
+string NSEC3PARAMRecordContent::getZoneRepresentation(bool /* noDot */) const
{
string ret;
RecordTextWriter rtw(ret);
d_bitmap.toPacket(pw);
}
-std::shared_ptr<CSYNCRecordContent::DNSRecordContent> CSYNCRecordContent::make(const DNSRecord &dr, PacketReader& pr)
+std::shared_ptr<CSYNCRecordContent::DNSRecordContent> CSYNCRecordContent::make(const DNSRecord& /* dr */, PacketReader& pr)
{
auto ret=std::make_shared<CSYNCRecordContent>();
pr.xfr32BitInt(ret->d_serial);
return ret;
}
-string CSYNCRecordContent::getZoneRepresentation(bool noDot) const
+string CSYNCRecordContent::getZoneRepresentation(bool /* noDot */) const
{
string ret;
RecordTextWriter rtw(ret);
return haveSomething;
}
-DNSName PacketHandler::doAdditionalServiceProcessing(const DNSName &firstTarget, const uint16_t &qtype, std::unique_ptr<DNSPacket>& r, vector<DNSZoneRecord>& extraRecords) {
+DNSName PacketHandler::doAdditionalServiceProcessing(const DNSName &firstTarget, const uint16_t &qtype, std::unique_ptr<DNSPacket>& /* r */, vector<DNSZoneRecord>& extraRecords) {
DNSName ret = firstTarget;
size_t ctr = 5; // Max 5 SVCB Aliasforms per query
bool done = false;
}
}
-void PacketHandler::addNSEC(DNSPacket& p, std::unique_ptr<DNSPacket>& r, const DNSName& target, const DNSName& wildcard, int mode)
+void PacketHandler::addNSEC(DNSPacket& /* p */, std::unique_ptr<DNSPacket>& r, const DNSName& target, const DNSName& wildcard, int mode)
{
DLOG(g_log<<"addNSEC() mode="<<mode<<" auth="<<d_sd.qname<<" target="<<target<<" wildcard="<<wildcard<<endl);
return c;
}
-static int clearZone(DNSSECKeeper& dk, const DNSName &zone) {
+static int clearZone(DNSSECKeeper& /* dk */, const DNSName &zone) {
UeberBackend B;
DomainInfo di;
return DNSCryptoKeyEngine::testAll();
}
-static void testSpeed(DNSSECKeeper& dk, const DNSName& zone, const string& remote, int cores)
+static void testSpeed(DNSSECKeeper& /* dk */, const DNSName& zone, const string& /* remote */, int cores)
{
DNSResourceRecord rr;
rr.qname=DNSName("blah")+zone;
PKCS11DNSCryptoKeyEngine(unsigned int algorithm);
~PKCS11DNSCryptoKeyEngine();
- bool operator<(const PKCS11DNSCryptoKeyEngine& rhs) const
+ bool operator<(const PKCS11DNSCryptoKeyEngine& /* rhs */) const
{
return false;
}
void fromISCMap(DNSKEYRecordContent& drc, stormap_t& stormap) override;
- void fromPublicKeyString(const std::string& content) override { throw "Unimplemented"; };
+ void fromPublicKeyString(const std::string& /* content */) override { throw "Unimplemented"; };
static std::unique_ptr<DNSCryptoKeyEngine> maker(unsigned int algorithm);
};
class PollFDMultiplexer : public FDMultiplexer
{
public:
- PollFDMultiplexer(unsigned int maxEventsHint)
+ PollFDMultiplexer(unsigned int /* maxEventsHint */)
{}
~PollFDMultiplexer()
{
}
-void RecordTextReader::xfrText(string& val, bool multi, bool lenField)
+void RecordTextReader::xfrText(string& val, bool multi, bool /* lenField */)
{
val.clear();
val.reserve(d_end - d_pos);
}
}
-void RecordTextReader::xfrUnquotedText(string& val, bool lenField)
+void RecordTextReader::xfrUnquotedText(string& val, bool /* lenField */)
{
val.clear();
val.reserve(d_end - d_pos);
d_string += std::string(addrbuf);
}
-void RecordTextWriter::xfrCAWithoutPort(uint8_t version, ComboAddress &val)
+void RecordTextWriter::xfrCAWithoutPort(uint8_t /* version */, ComboAddress &val)
{
string ip = val.toString();
}
// should not mess with the escapes
-void RecordTextWriter::xfrName(const DNSName& val, bool, bool noDot)
+void RecordTextWriter::xfrName(const DNSName& val, bool /* unused */, bool /* noDot */)
{
if(!d_string.empty())
d_string.append(1,' ');
}
}
-void RecordTextWriter::xfrText(const string& val, bool multi, bool lenField)
+void RecordTextWriter::xfrText(const string& val, bool /* multi */, bool /* lenField */)
{
if(!d_string.empty())
d_string.append(1,' ');
d_string.append(val);
}
-void RecordTextWriter::xfrUnquotedText(const string& val, bool lenField)
+void RecordTextWriter::xfrUnquotedText(const string& val, bool /* lenField */)
{
if(!d_string.empty())
d_string.append(1,' ');
namespace pdns {
namespace resolver {
- int parseResult(MOADNSParser& mdp, const DNSName& origQname, uint16_t origQtype, uint16_t id, Resolver::res_t* result)
+ int parseResult(MOADNSParser& mdp, const DNSName& origQname, uint16_t /* origQtype */, uint16_t id, Resolver::res_t* result)
{
result->clear();
submitResponse(qtype, respsize, udpOrTCP);
}
-void ResponseStats::submitResponse(uint16_t qtype, uint16_t respsize, bool udpOrTCP) const
+void ResponseStats::submitResponse(uint16_t qtype, uint16_t respsize, bool /* udpOrTCP */) const
{
d_qtypecounters.at(qtype).value++;
d_sizecounters(respsize);
pw.xfr32BitInt(d_altitude);
}
-std::shared_ptr<LOCRecordContent::DNSRecordContent> LOCRecordContent::make(const DNSRecord &dr, PacketReader& pr)
+std::shared_ptr<LOCRecordContent::DNSRecordContent> LOCRecordContent::make(const DNSRecord& /* dr */, PacketReader& pr)
{
auto ret=std::make_shared<LOCRecordContent>();
pr.xfr8BitInt(ret->d_version);
return ret;
}
-LOCRecordContent::LOCRecordContent(const string& content, const string& zone)
+LOCRecordContent::LOCRecordContent(const string& content, const string& /* zone */)
{
// 51 59 00.000 N 5 55 00.000 E 4.00m 1.00m 10000.00m 10.00m
// convert this to d_version, d_size, d_horiz/vertpre, d_latitude, d_longitude, d_altitude
}
-string LOCRecordContent::getZoneRepresentation(bool noDot) const
+string LOCRecordContent::getZoneRepresentation(bool /* noDot */) const
{
// convert d_version, d_size, d_horiz/vertpre, d_latitude, d_longitude, d_altitude to:
// 51 59 00.000 N 5 55 00.000 E 4.00m 1.00m 10000.00m 10.00m
return catalogDiff(di, fromXFR, fromDB, logPrefix);
}
-void CommunicatorClass::ixfrSuck(const DNSName &domain, const TSIGTriplet& tt, const ComboAddress& laddr, const ComboAddress& remote, unique_ptr<AuthLua4>& pdl,
- ZoneStatus& zs, vector<DNSRecord>* axfr)
+void CommunicatorClass::ixfrSuck(const DNSName& domain, const TSIGTriplet& tt, const ComboAddress& laddr, const ComboAddress& remote, unique_ptr<AuthLua4>& /* pdl */, ZoneStatus& zs, vector<DNSRecord>* axfr)
{
string logPrefix="IXFR-in zone '"+domain.toLogString()+"', primary '"+remote.toString()+"', ";
{
}
- void deliverTimeout(const Identifier& i)
+ void deliverTimeout(const Identifier& /* i */)
{
}
return d_resolver.tryGetSOASerial(&(std::get<0>(id)), &(std::get<1>(id)), &a.theirSerial, &a.theirInception, &a.theirExpire, &(std::get<2>(id)));
}
- void deliverAnswer(const DomainNotificationInfo& dni, const Answer& a, unsigned int usec)
+ void deliverAnswer(const DomainNotificationInfo& dni, const Answer& a, unsigned int /* usec */)
{
d_freshness[dni.di.id]=a;
}
dgram.assign(d_buffer, 0, static_cast<size_t>(bytes));
}
- bool recvFromAsync(string &dgram, ComboAddress &ep)
+ bool recvFromAsync(string &dgram, ComboAddress& /* ep */)
{
struct sockaddr_in remote;
socklen_t remlen = sizeof(remote);
virtual std::unique_ptr<TLSConnection> getConnection(int socket, const struct timeval& timeout, time_t now) = 0;
virtual std::unique_ptr<TLSConnection> getClientConnection(const std::string& host, bool hostIsAddr, int socket, const struct timeval& timeout) = 0;
virtual void rotateTicketsKey(time_t now) = 0;
- virtual void loadTicketsKeys(const std::string& file)
+ virtual void loadTicketsKeys(const std::string& /* file */)
{
throw std::runtime_error("This TLS backend does not have the capability to load a tickets key from a file");
}
virtual std::string getName() const = 0;
/* set the advertised ALPN protocols, in client or server context */
- virtual bool setALPNProtos(const std::vector<std::vector<uint8_t>>& protos)
+ virtual bool setALPNProtos(const std::vector<std::vector<uint8_t>>& /* protos */)
{
return false;
}
public:
enum class Type : uint8_t { Client, Server };
- TCPIOHandler(const std::string& host, bool hostIsAddr, int socket, const struct timeval& timeout, std::shared_ptr<TLSCtx> ctx, time_t now): d_socket(socket)
+ TCPIOHandler(const std::string& host, bool hostIsAddr, int socket, const struct timeval& timeout, std::shared_ptr<TLSCtx> ctx, time_t /* now */): d_socket(socket)
{
if (ctx) {
d_conn = ctx->getClientConnection(host, hostIsAddr, d_socket, timeout);
};
static std::atomic<int> g_receivedAnswers;
-static void report(std::unique_ptr<DNSPacket>& A, int B)
+static void report(std::unique_ptr<DNSPacket>& /* A */, int /* B */)
{
g_receivedAnswers++;
}
};
static std::atomic<int> g_receivedAnswers1;
-static void report1(std::unique_ptr<DNSPacket>& A, int B)
+static void report1(std::unique_ptr<DNSPacket>& /* A */, int /* B */)
{
g_receivedAnswers1++;
}
~BackendDies()
{
}
- std::unique_ptr<DNSPacket> question(Question& q)
+ std::unique_ptr<DNSPacket> question(Question& /* q */)
{
// cout<<"Q: "<<q->qdomain<<endl;
if(!d_ourcount && ++d_count == 10) {
std::atomic<int> g_receivedAnswers2;
-static void report2(std::unique_ptr<DNSPacket>& A, int B)
+static void report2(std::unique_ptr<DNSPacket>& /* A */, int /* B */)
{
g_receivedAnswers2++;
}
}
}
-static bool test_dnsrecords_cc_predicate( std::exception const &ex ) { return true; }
+static bool test_dnsrecords_cc_predicate(std::exception const& /* ex */) { return true; }
// these *MUST NOT* parse properly!
BOOST_AUTO_TEST_CASE(test_record_types_bad_values) {
return true;
}
- bool list(const DNSName& target, int zoneId, bool include_disabled = false) override
+ bool list(const DNSName& target, int zoneId, bool /* include_disabled */ = false) override
{
findZone(target, zoneId, d_records, d_currentZone);
{
}
- bool getDomainMetadata(const DNSName& name, const std::string& kind, std::vector<std::string>& meta) override
+ bool getDomainMetadata(const DNSName& /* name */, const std::string& /* kind */, std::vector<std::string>& /* meta */) override
{
return false;
}
- bool setDomainMetadata(const DNSName& name, const std::string& kind, const std::vector<std::string>& meta) override
+ bool setDomainMetadata(const DNSName& /* name */, const std::string& /* kind */, const std::vector<std::string>& /* meta */) override
{
return false;
}
}
}
-void WebServer::logResponse(const HttpResponse& resp, const ComboAddress& remote, const string& logprefix) const {
+void WebServer::logResponse(const HttpResponse& resp, const ComboAddress& /* remote */, const string& logprefix) const {
if (d_loglevel >= WebServer::LogLevel::Detailed) {
#ifdef RECURSOR
if (!g_slogStructured) {
}
}
-static void gatherRecords(UeberBackend& B, const string& logprefix, const Json& container, const DNSName& qname, const QType& qtype, const int ttl, vector<DNSResourceRecord>& new_records) {
+static void gatherRecords(UeberBackend& /* B */, const string& /* logprefix */, const Json& container, const DNSName& qname, const QType& qtype, const int ttl, vector<DNSResourceRecord>& new_records) {
DNSResourceRecord rr;
rr.qname = qname;
rr.qtype = qtype;
resp->status = 200;
}
-void AuthWebServer::cssfunction(HttpRequest* req, HttpResponse* resp)
+void AuthWebServer::cssfunction(HttpRequest* /* req */, HttpResponse* resp)
{
resp->headers["Cache-Control"] = "max-age=86400";
resp->headers["Content-Type"] = "text/css";
StatBag S;
static int g_numRecords;
-static Json::object emitRecord(const string& zoneName, const DNSName &DNSqname, const string &qtype, const string &ocontent, int ttl)
+static Json::object emitRecord(const string& /* zoneName */, const DNSName &DNSqname, const string &qtype, const string &ocontent, int ttl)
{
int prio=0;
string retval;
projects / thirdparty / pdns.git / commitdiff
