}
else {
d_params[var] = val;
- d_cleared.insert(var);
+ d_cleared.insert(std::move(var));
}
}
else {
throw std::out_of_range("alpn length of 0");
}
xfrBlob(alpn, alpnLen);
- alpns.push_back(alpn);
+ alpns.push_back(std::move(alpn));
}
kvs.insert(SvcParam(key, std::move(alpns)));
break;
bool doAuto{d_internal && len == 0};
auto param = SvcParam(key, std::move(addresses));
param.setAutoHint(doAuto);
- kvs.insert(param);
+ kvs.insert(std::move(param));
break;
}
case SvcParam::ech: {
try {
auto newParam = SvcParam(key, std::move(h));
d_params.erase(p);
- d_params.insert(newParam);
+ d_params.insert(std::move(newParam));
} catch (...) {
// XXX maybe we should SERVFAIL instead?
return;
try {
auto p = SvcParam(key, std::move(hints));
p.setAutoHint(doAuto);
- val.insert(p);
+ val.insert(std::move(p));
}
catch (const std::invalid_argument& e) {
throw RecordTextException(e.what());
}
unescaped += ch;
}
- escaped.push_back(unescaped);
+ escaped.push_back(std::move(unescaped));
}
if (shouldQuote) {
d_string.append(1, '"');
dnsRecord.d_type = type;
dnsRecord.d_place = place;
dnsRecord.setContent(DNSRecordContent::make(type, QClass::IN, content));
- records.push_back(dnsRecord);
+ records.push_back(std::move(dnsRecord));
}
void RecursorLua4::DNSQuestion::addAnswer(uint16_t type, const std::string& content, boost::optional<int> ttl, boost::optional<string> name)
record.setContent(std::make_shared<CNAMERecordContent>(newquery));
// Copy the TTL of the synthesized CNAME from the actual answer
record.d_ttl = (rcode == RCode::NoError && !answers.empty()) ? answers.at(0).d_ttl : SyncRes::s_minimumTTL;
- ret.push_back(record);
+ ret.push_back(std::move(record));
ret.insert(ret.end(), answers.begin(), answers.end());
vector<string> parts;
stringtok(parts, low, ".");
reverse(parts.begin(), parts.end());
- pbList.push_back(parts);
+ pbList.push_back(std::move(parts));
}
}
try {
Lua->executeCode(ifs);
- newLuaConfig = lci;
+ newLuaConfig = std::move(lci);
}
catch (const LuaContext::ExecutionErrorException& e) {
SLOG(g_log << Logger::Error << "Unable to load Lua script from '" + fname + "': ",
case QType::NSEC3:
break;
case QType::RRSIG: {
- const auto rrsig = getRR<RRSIGRecordContent>(dnsRecord);
+ auto rrsig = getRR<RRSIGRecordContent>(dnsRecord);
if (rrsig == nullptr) {
break;
}
}
else {
vector<shared_ptr<const RRSIGRecordContent>> sigsrr;
- sigsrr.push_back(rrsig);
+ sigsrr.push_back(std::move(rrsig));
d_sigs.insert({sigkey, sigsrr});
}
break;
while (!parts.empty()) {
if (parts.size() == 1 || binary_search(g_pubs.begin(), g_pubs.end(), parts)) {
- string ret = last;
+ string ret = std::move(last);
if (!ret.empty())
ret += ".";
while (begin != end) {
try {
auto d = DNSName(*begin);
- toAdd.push_back(d);
+ toAdd.push_back(std::move(d));
}
catch (const std::exception& e) {
return "Problem parsing '" + *begin + "': " + e.what() + ", nothing added\n";
lci = g_luaconfs.getCopy();
if (broadcast) {
startLuaConfigDelayedThreads(lci, lci.generation);
- broadcastFunction([=] { return pleaseSupplantProxyMapping(proxyMapping); });
+ broadcastFunction([pmap = std::move(proxyMapping)] { return pleaseSupplantProxyMapping(pmap); });
}
else {
// Initial proxy mapping
// these explicitly-named captures should not be necessary, as lambda
// capture of tuple-like structured bindings is permitted, but some
// compilers still don't allow it
- broadcastFunction([dmap = newDomainMap] { return pleaseUseNewSDomainsMap(dmap); });
- broadcastFunction([nsset = newNotifySet] { return pleaseSupplantAllowNotifyFor(nsset); });
+ broadcastFunction([dmap = std::move(newDomainMap)] { return pleaseUseNewSDomainsMap(dmap); });
+ broadcastFunction([nsset = std::move(newNotifySet)] { return pleaseSupplantAllowNotifyFor(nsset); });
// Wipe the caches *after* the new auth domain info has been set
// up, as a query during setting up might fill the caches
file.write('const std::string& value, ::rust::String& section, ::rust::String& fieldname, ')
file.write('::rust::String& type_name, pdns::rust::settings::rec::Value& rustvalue)')
file.write('{ // NOLINT(readability-function-cognitive-complexity)\n')
- file.write(' if (const auto newname = arg().isDeprecated(key); !newname.empty()) {\n')
+ file.write(' if (const auto& newname = arg().isDeprecated(key); !newname.empty()) {\n')
file.write(' key = newname;\n')
file.write(' }\n')
for entry in entries:
if (ziter != d_records.end()) {
DNSRecord dnsRecord = *ziter;
dnsRecord.d_place = DNSResourceRecord::AUTHORITY;
- records.push_back(dnsRecord);
+ records.push_back(std::move(dnsRecord));
}
}
if (dnsRecord.d_type == qtype || qtype == QType::ANY || dnsRecord.d_type == QType::CNAME) {
dnsRecord.d_name = qname;
dnsRecord.d_place = DNSResourceRecord::ANSWER;
- records.push_back(dnsRecord);
+ records.push_back(std::move(dnsRecord));
}
}
break;
}
if (g_recCache->get(d_now.tv_sec, dnameName, QType::DNAME, flags, &cset, d_cacheRemote, d_routingTag, d_doDNSSEC ? &signatures : nullptr, d_doDNSSEC ? &authorityRecs : nullptr, &d_wasVariable, &context.state, &wasAuth, &authZone, &d_fromAuthIP) > 0) {
- foundName = dnameName;
+ foundName = std::move(dnameName);
foundQT = QType::DNAME;
break;
}
sigdr.setContent(signature);
sigdr.d_place = DNSResourceRecord::ANSWER;
sigdr.d_class = QClass::IN;
- ret.push_back(sigdr);
+ ret.push_back(std::move(sigdr));
}
for (const auto& rec : *authorityRecs) {
DNSRecord authDR(rec);
authDR.d_ttl = ttl;
- ret.push_back(authDR);
+ ret.push_back(std::move(authDR));
}
}
dnsRecord.setContent(signature);
dnsRecord.d_place = DNSResourceRecord::ANSWER;
dnsRecord.d_class = QClass::IN;
- ret.push_back(dnsRecord);
+ ret.push_back(std::move(dnsRecord));
}
for (const auto& rec : *authorityRecs) {
if (key.d_type == QType::DNSKEY) {
auto content = getRR<DNSKEYRecordContent>(key);
if (content) {
- keys.insert(content);
+ keys.insert(std::move(content));
}
}
}
if (target.isRoot()) {
target = rec.d_name;
}
- allowedAdditionals.insert(target);
+ allowedAdditionals.insert(std::move(target));
}
else {
// FIXME: Alias mode not implemented yet
tcache[{rec.d_name, rec.d_type, rec.d_place}].d_ttl_time = d_now.tv_sec;
dnsRecord.d_ttl += d_now.tv_sec;
dnsRecord.d_place = DNSResourceRecord::ANSWER;
- tcache[{rec.d_name, rec.d_type, rec.d_place}].records.push_back(dnsRecord);
+ tcache[{rec.d_name, rec.d_type, rec.d_place}].records.push_back(std::move(dnsRecord));
}
}
else
throw PDNSException("Unable to parse DNSKEY record '" + resourceRecord.qname.toString() + " " + resourceRecord.getZoneRepresentation() + "'");
}
auto dsr = makeDSFromDNSKey(resourceRecord.qname, *dnskeyr, DNSSECKeeper::DIGEST_SHA256);
- newDSAnchors[resourceRecord.qname].insert(dsr);
+ newDSAnchors[resourceRecord.qname].insert(std::move(dsr));
}
}
if (dsAnchors == newDSAnchors) {
projects / thirdparty / pdns.git / commitdiff
