rec: fix a set of move optimizations, as suggested by coverity

diff --git a/pdns/recursordist/logging.cc b/pdns/recursordist/logging.cc
index 5cfef1752c0de7f353d2fe7575e741a8a5e2a2b0..42c1d2a20d330cbf318e76c84951d9fc08153fa0 100644 (file)
--- a/pdns/recursordist/logging.cc
+++ b/pdns/recursordist/logging.cc
@@ -49,7 +49,7 @@ void Logger::info(Logr::Priority p, const std::string& msg) const
 
 void Logger::logMessage(const std::string& msg, boost::optional<const std::string> err) const
 {
-  return logMessage(msg, Logr::Absent, err);
+  return logMessage(msg, Logr::Absent, std::move(err));
 }
 
 void Logger::logMessage(const std::string& msg, Logr::Priority p, boost::optional<const std::string> err) const
@@ -142,11 +142,11 @@ Logger::Logger(EntryLogger callback) :
 {
 }
 Logger::Logger(EntryLogger callback, boost::optional<std::string> name) :
-  _callback(callback), _name(name)
+  _callback(callback), _name(std::move(name))
 {
 }
 Logger::Logger(std::shared_ptr<const Logger> parent, boost::optional<std::string> name, size_t verbosity, size_t lvl, EntryLogger callback) :
-  _parent(parent), _callback(callback), _name(name), _level(lvl), _verbosity(verbosity)
+  _parent(std::move(parent)), _callback(callback), _name(std::move(name)), _level(lvl), _verbosity(verbosity)
 {
 }
 

diff --git a/pdns/recursordist/rec-main.hh b/pdns/recursordist/rec-main.hh
index e84a89e9d5083b896298decb819251920083df7d..303306837f514d5e625a9df8e45ab1196599b999 100644 (file)
--- a/pdns/recursordist/rec-main.hh
+++ b/pdns/recursordist/rec-main.hh
@@ -54,12 +54,12 @@ extern std::shared_ptr<Logr::Logger> g_slogudpin;
 struct DNSComboWriter
 {
   DNSComboWriter(const std::string& query, const struct timeval& now, shared_ptr<RecursorLua4> luaContext) :
-    d_mdp(true, query), d_now(now), d_query(query), d_luaContext(luaContext)
+    d_mdp(true, query), d_now(now), d_query(query), d_luaContext(std::move(luaContext))
   {
   }
 
   DNSComboWriter(const std::string& query, const struct timeval& now, std::unordered_set<std::string>&& policyTags, shared_ptr<RecursorLua4> luaContext, LuaContext::LuaObject&& data, std::vector<DNSRecord>&& records) :
-    d_mdp(true, query), d_now(now), d_query(query), d_policyTags(std::move(policyTags)), d_records(std::move(records)), d_luaContext(luaContext), d_data(std::move(data))
+    d_mdp(true, query), d_now(now), d_query(query), d_policyTags(std::move(policyTags)), d_records(std::move(records)), d_luaContext(std::move(luaContext)), d_data(std::move(data))
   {
   }
 

diff --git a/pdns/recursordist/rec_channel_rec.cc b/pdns/recursordist/rec_channel_rec.cc
index a91dea3cd8c6bd68ce7c4d56cbfac792a55ac5e5..34305559f546305796bb54d5797048a4810dc6d8 100644 (file)
--- a/pdns/recursordist/rec_channel_rec.cc
+++ b/pdns/recursordist/rec_channel_rec.cc
@@ -117,12 +117,12 @@ static void addGetStat(const string& name, const pdns::stat_t* place)
 
 static void addGetStat(const string& name, std::function<uint64_t()> f)
 {
-  d_get64bitmembers[name] = f;
+  d_get64bitmembers[name] = std::move(f);
 }
 
 static void addGetStat(const string& name, std::function<StatsMap()> f)
 {
-  d_getmultimembers[name] = f;
+  d_getmultimembers[name] = std::move(f);
 }
 
 static std::string getPrometheusName(const std::string& arg)
@@ -1094,7 +1094,7 @@ static StatsMap toStatsMap(const string& name, const pdns::Histogram& histogram)
   for (const auto& bucket : data) {
     snprintf(buf, sizeof(buf), "%g", bucket.d_boundary / 1e6);
     std::string pname = pbasename + "seconds_bucket{" + "le=\"" + (bucket.d_boundary == std::numeric_limits<uint64_t>::max() ? "+Inf" : buf) + "\"}";
-    entries.emplace(bucket.d_name, StatsMapEntry{pname, std::to_string(bucket.d_count)});
+    entries.emplace(bucket.d_name, StatsMapEntry{std::move(pname), std::to_string(bucket.d_count)});
   }
 
   snprintf(buf, sizeof(buf), "%g", histogram.getSum() / 1e6);
@@ -1144,7 +1144,7 @@ static StatsMap toAuthRCodeStatsMap(const string& name)
   for (const auto& entry : rcodes) {
     const auto key = RCode::to_short_s(n);
     std::string pname = pbasename + "{rcode=\"" + key + "\"}";
-    entries.emplace("auth-" + key + "-answers", StatsMapEntry{pname, std::to_string(entry)});
+    entries.emplace("auth-" + key + "-answers", StatsMapEntry{std::move(pname), std::to_string(entry)});
     n++;
   }
   return entries;
@@ -1159,7 +1159,7 @@ static StatsMap toCPUStatsMap(const string& name)
   for (unsigned int n = 0; n < RecThreadInfo::numDistributors() + RecThreadInfo::numWorkers(); ++n) {
     uint64_t tm = doGetThreadCPUMsec(n);
     std::string pname = pbasename + "{thread=\"" + std::to_string(n) + "\"}";
-    entries.emplace(name + "-thread-" + std::to_string(n), StatsMapEntry{pname, std::to_string(tm)});
+    entries.emplace(name + "-thread-" + std::to_string(n), StatsMapEntry{std::move(pname), std::to_string(tm)});
   }
   return entries;
 }
@@ -1200,10 +1200,10 @@ static StatsMap toProxyMappingStatsMap(const string& name)
     auto keyname = pbasename + "{netmask=\"" + key.toString() + "\",count=\"";
     auto sname1 = name + "-n-" + std::to_string(count);
     auto pname1 = keyname + "netmaskmatches\"}";
-    entries.emplace(sname1, StatsMapEntry{pname1, std::to_string(entry.netmaskMatches)});
+    entries.emplace(sname1, StatsMapEntry{std::move(pname1), std::to_string(entry.netmaskMatches)});
     auto sname2 = name + "-s-" + std::to_string(count);
     auto pname2 = keyname + "suffixmatches\"}";
-    entries.emplace(sname2, StatsMapEntry{pname2, std::to_string(entry.suffixMatches)});
+    entries.emplace(sname2, StatsMapEntry{std::move(pname2), std::to_string(entry.suffixMatches)});
     count++;
   }
   return entries;
@@ -1231,16 +1231,16 @@ static StatsMap toRemoteLoggerStatsMap(const string& name)
       auto keyname = pbasename + "{address=\"" + key + "\",type=\"" + type + "\",count=\"";
       auto sname1 = name + "-q-" + std::to_string(count);
       auto pname1 = keyname + "queued\"}";
-      entries.emplace(sname1, StatsMapEntry{pname1, std::to_string(entry.d_queued)});
+      entries.emplace(sname1, StatsMapEntry{std::move(pname1), std::to_string(entry.d_queued)});
       auto sname2 = name + "-p-" + std::to_string(count);
       auto pname2 = keyname + "pipeFull\"}";
-      entries.emplace(sname2, StatsMapEntry{pname2, std::to_string(entry.d_pipeFull)});
+      entries.emplace(sname2, StatsMapEntry{std::move(pname2), std::to_string(entry.d_pipeFull)});
       auto sname3 = name + "-t-" + std::to_string(count);
       auto pname3 = keyname + "tooLarge\"}";
-      entries.emplace(sname3, StatsMapEntry{pname3, std::to_string(entry.d_tooLarge)});
+      entries.emplace(sname3, StatsMapEntry{std::move(pname3), std::to_string(entry.d_tooLarge)});
       auto sname4 = name + "-o-" + std::to_string(count);
       auto pname4 = keyname + "otherError\"}";
-      entries.emplace(sname4, StatsMapEntry{pname4, std::to_string(entry.d_otherError)});
+      entries.emplace(sname4, StatsMapEntry{std::move(pname4), std::to_string(entry.d_otherError)});
       ++count;
     }
   }

diff --git a/pdns/recursordist/reczones-helpers.cc b/pdns/recursordist/reczones-helpers.cc
index 721a8d2e7db42f44259556470773a6d4372cae06..dd82ee3d034d7e33f1b91448b3267d160697056d 100644 (file)
--- a/pdns/recursordist/reczones-helpers.cc
+++ b/pdns/recursordist/reczones-helpers.cc
@@ -191,7 +191,7 @@ static SyncRes::AuthDomain makeSOAAndNSNodes(DNSRecord& dr, T content)
 
 static void addToDomainMap(SyncRes::domainmap_t& newMap,
                            SyncRes::AuthDomain ad,
-                           DNSName& name,
+                           const DNSName& name,
                            Logr::log_t log,
                            const bool partial = false,
                            const bool reverse = false)
@@ -250,7 +250,7 @@ static void makeIPToNamesZone(SyncRes::domainmap_t& newMap,
   dr.setContent(DNSRecordContent::mastermake(QType::PTR, 1, DNSName(canonicalHostname).toString()));
   ad.d_records.insert(dr);
 
-  addToDomainMap(newMap, ad, dr.d_name, log, false, true);
+  addToDomainMap(newMap, std::move(ad), dr.d_name, log, false, true);
 }
 
 void makePartialIPZone(SyncRes::domainmap_t& newMap,
@@ -266,7 +266,7 @@ void makePartialIPZone(SyncRes::domainmap_t& newMap,
 
   SyncRes::AuthDomain ad = makeSOAAndNSNodes(dr, DNSName("localhost."));
 
-  addToDomainMap(newMap, ad, dr.d_name, log, true, true);
+  addToDomainMap(newMap, std::move(ad), dr.d_name, log, true, true);
 }
 
 void addForwardAndReverseLookupEntries(SyncRes::domainmap_t& newMap,

diff --git a/pdns/recursordist/reczones.cc b/pdns/recursordist/reczones.cc
index 389dcaee1c0e30525f09085f4b97bf13368a9f87..907a89fbe4b0b872ed1d3c0fb4112339591bfd0d 100644 (file)
--- a/pdns/recursordist/reczones.cc
+++ b/pdns/recursordist/reczones.cc
@@ -100,7 +100,7 @@ static void convertServersForAD(const std::string& zone, const std::string& inpu
 
 static void* pleaseUseNewSDomainsMap(std::shared_ptr<SyncRes::domainmap_t> newmap)
 {
-  SyncRes::setDomainMap(newmap);
+  SyncRes::setDomainMap(std::move(newmap));
   return 0;
 }
 

diff --git a/pdns/recursordist/syncres.cc b/pdns/recursordist/syncres.cc
index 69584cd101400817f4996d6d40586c53b7a2c0a6..2de8e592b8f322c714acea315a29a622ca64d75b 100644 (file)
--- a/pdns/recursordist/syncres.cc
+++ b/pdns/recursordist/syncres.cc
@@ -324,7 +324,7 @@ static LockGuarded<Throttle<std::tuple<ComboAddress, DNSName, QType>>> s_throttl
 struct SavedParentEntry
 {
   SavedParentEntry(const DNSName& name, map<DNSName, vector<ComboAddress>>&& nsAddresses, time_t ttd) :
-    d_domain(name), d_nsAddresses(nsAddresses), d_ttd(ttd)
+    d_domain(name), d_nsAddresses(std::move(nsAddresses)), d_ttd(ttd)
   {
   }
   DNSName d_domain;
@@ -1779,7 +1779,7 @@ int SyncRes::doResolve(const DNSName& qname, const QType qtype, vector<DNSRecord
         else {
           // as doResolveNoQNameMinimization clears the EDE, we put it back here, it is relevant but might not be set by the last effort attempt
           if (!context.extendedError) {
-            context.extendedError = oldEDE;
+            context.extendedError = std::move(oldEDE);
           }
         }
 
@@ -5835,12 +5835,12 @@ void SyncRes::parseEDNSSubnetAddFor(const std::string& subnetlist)
 }
 
 // used by PowerDNSLua - note that this neglects to add the packet count & statistics back to pdns_recursor.cc
-int directResolve(const DNSName& qname, const QType qtype, const QClass qclass, vector<DNSRecord>& ret, shared_ptr<RecursorLua4> pdl, Logr::log_t log)
+int directResolve(const DNSName& qname, const QType qtype, const QClass qclass, vector<DNSRecord>& ret, const shared_ptr<RecursorLua4>& pdl, Logr::log_t log)
 {
   return directResolve(qname, qtype, qclass, ret, pdl, SyncRes::s_qnameminimization, log);
 }
 
-int directResolve(const DNSName& qname, const QType qtype, const QClass qclass, vector<DNSRecord>& ret, shared_ptr<RecursorLua4> pdl, bool qm, Logr::log_t slog)
+int directResolve(const DNSName& qname, const QType qtype, const QClass qclass, vector<DNSRecord>& ret, const shared_ptr<RecursorLua4>& pdl, bool qnamemin, Logr::log_t slog)
 {
   auto log = slog->withValues("qname", Logging::Loggable(qname), "qtype", Logging::Loggable(qtype));
 
@@ -5848,7 +5848,7 @@ int directResolve(const DNSName& qname, const QType qtype, const QClass qclass,
   gettimeofday(&now, 0);
 
   SyncRes sr(now);
-  sr.setQNameMinimization(qm);
+  sr.setQNameMinimization(qnamemin);
   if (pdl) {
     sr.setLuaEngine(pdl);
   }
@@ -5898,7 +5898,7 @@ int SyncRes::getRootNS(struct timeval now, asyncresolve_t asyncCallback, unsigne
   sr.setUpdatingRootNS();
   sr.setDoDNSSEC(g_dnssecmode != DNSSECMode::Off);
   sr.setDNSSECValidationRequested(g_dnssecmode != DNSSECMode::Off && g_dnssecmode != DNSSECMode::ProcessNoValidate);
-  sr.setAsyncCallback(asyncCallback);
+  sr.setAsyncCallback(std::move(asyncCallback));
   sr.setRefreshAlmostExpired(true);
 
   const string msg = "Failed to update . records";

diff --git a/pdns/recursordist/syncres.hh b/pdns/recursordist/syncres.hh
index 2b3a3082d1122c0288771c76f44bf2f6e5db6b98..38d823d686b8ebd0f6cd65a4ab55c16484b455fe 100644 (file)
--- a/pdns/recursordist/syncres.hh
+++ b/pdns/recursordist/syncres.hh
@@ -282,7 +282,7 @@ public:
 
   static void setDomainMap(std::shared_ptr<domainmap_t> newMap)
   {
-    t_sstorage.domainmap = newMap;
+    t_sstorage.domainmap = std::move(newMap);
   }
   static const std::shared_ptr<domainmap_t> getDomainMap()
   {
@@ -417,7 +417,7 @@ public:
 
   void setLuaEngine(shared_ptr<RecursorLua4> pdl)
   {
-    d_pdl = pdl;
+    d_pdl = std::move(pdl);
   }
 
   bool wasVariable() const
@@ -463,7 +463,7 @@ public:
 
   void setAsyncCallback(asyncresolve_t func)
   {
-    d_asyncResolve = func;
+    d_asyncResolve = std::move(func);
   }
 
   vState getValidationState() const
@@ -873,8 +873,8 @@ private:
 class ImmediateServFailException
 {
 public:
-  ImmediateServFailException(string r) :
-    reason(r){};
+  ImmediateServFailException(string reason_) :
+    reason(std::move(reason_)){};
 
   string reason; //! Print this to tell the user what went wrong
 };
@@ -907,8 +907,8 @@ typedef std::function<void*(void)> pipefunc_t;
 void broadcastFunction(const pipefunc_t& func);
 void distributeAsyncFunction(const std::string& question, const pipefunc_t& func);
 
-int directResolve(const DNSName& qname, const QType qtype, const QClass qclass, vector<DNSRecord>& ret, shared_ptr<RecursorLua4> pdl, Logr::log_t);
-int directResolve(const DNSName& qname, const QType qtype, const QClass qclass, vector<DNSRecord>& ret, shared_ptr<RecursorLua4> pdl, bool qm, Logr::log_t);
+int directResolve(const DNSName& qname, QType qtype, QClass qclass, vector<DNSRecord>& ret, const shared_ptr<RecursorLua4>& pdl, Logr::log_t);
+int directResolve(const DNSName& qname, QType qtype, QClass qclass, vector<DNSRecord>& ret, const shared_ptr<RecursorLua4>& pdl, bool qnamemin, Logr::log_t);
 int followCNAMERecords(std::vector<DNSRecord>& ret, const QType qtype, int oldret);
 int getFakeAAAARecords(const DNSName& qname, ComboAddress prefix, vector<DNSRecord>& ret);
 int getFakePTRRecords(const DNSName& qname, vector<DNSRecord>& ret);