emplace* forwards the arguments directly. Avoids needing make_pair.
Signed-off-by: Rosen Penev <rosenp@gmail.com>
auto domainInfo = s_domainInfo.lock(); //TODO: We could actually lock less if we do it per suffix.
if (!domainInfo->count(d_suffix)) {
TDI_t tmp;
- domainInfo->insert(make_pair(d_suffix, tmp));
+ domainInfo->emplace(d_suffix, tmp);
}
TDI_t* domains = &(*domainInfo)[d_suffix];
{
auto pending = d_pending.lock();
if (pending->d_replacePending) {
- pending->d_pendingAdds.push_back({zone, zoneId});
+ pending->d_pendingAdds.emplace_back(zone, zoneId);
}
}
v4Key = nextV4Key;
if (bpf_lookup_elem(maps->d_v4map.getHandle(), &v4Key, &value) == 0) {
v4Addr.sin_addr.s_addr = ntohl(v4Key);
- result.push_back(make_pair(ComboAddress(&v4Addr), value));
+ result.emplace_back(ComboAddress(&v4Addr), value);
}
res = bpf_get_next_key(maps->d_v4map.getHandle(), &v4Key, &nextV4Key);
if (bpf_lookup_elem(maps->d_v6map.getHandle(), &nextV6Key, &value) == 0) {
memcpy(&v6Addr.sin6_addr.s6_addr, &nextV6Key, sizeof(nextV6Key));
- result.push_back(make_pair(ComboAddress(&v6Addr), value));
+ result.emplace_back(ComboAddress(&v6Addr), value);
}
res = bpf_get_next_key(maps->d_v6map.getHandle(), &nextV6Key, &nextV6Key);
if(!subnet.empty() || !ecsRange.empty()) {
EDNSSubnetOpts opt;
opt.source = Netmask(subnet.empty() ? "0.0.0.0/32" : subnet);
- ednsOptions.push_back(std::make_pair(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt)));
+ ednsOptions.emplace_back(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt));
}
if(!ednsOptions.empty() || pw.getHeader()->id % 2) {
pw.addOpt(1500, 0, EDNSOpts::DNSSECOK, ednsOptions);
pw.commit();
}
- unknown.emplace_back(std::make_shared<vector<uint8_t>>(packet));
+ unknown.push_back(std::make_shared<vector<uint8_t>>(packet));
}
shuffle(unknown.begin(), unknown.end(), pdns::dns_random_engine());
throw std::runtime_error("Error while reading value for key '" + key + "' from CDB database: " + std::to_string(ret));
}
- value = make_pair(std::move(key), std::move(val));
+ value = {std::move(key), std::move(val)};
return true;
}
else
kmd.keyType = ZSK;
- retkeyset.push_back(make_pair(dpk, kmd));
+ retkeyset.emplace_back(dpk, kmd);
}
sort(retkeyset.begin(), retkeyset.end(), keyCompareByKindAndID);
PrivateKey: ODIyNjAzODQ2MjgwODAxMjI2NDUxOTAyMDQxNDIyNjI=
*/
- storvector_t storvector;
-
- storvector.push_back(make_pair("Algorithm", "15 (ED25519)"));
- storvector.push_back(make_pair("PrivateKey", string((char*)d_seckey, DECAF_EDDSA_25519_PRIVATE_BYTES)));
+ auto storvector = storvector_t{
+ {"Algorithm", "15 (ED25519)"},
+ {"PrivateKey", string((char*)d_seckey, DECAF_EDDSA_25519_PRIVATE_BYTES)},
+ };
return storvector;
}
PrivateKey: xZ+5Cgm463xugtkY5B0Jx6erFTXp13rYegst0qRtNsOYnaVpMx0Z/c5EiA9x8wWbDDct/U3FhYWA
*/
- storvector_t storvector;
-
- storvector.push_back(make_pair("Algorithm", "16 (ED448)"));
- storvector.push_back(make_pair("PrivateKey", string((char*)d_seckey, DECAF_EDDSA_448_PRIVATE_BYTES)));
+ auto storvector = storvector_t{
+ {"Algorithm", "16 (ED448)"},
+ {"PrivateKey", string((char*)d_seckey, DECAF_EDDSA_448_PRIVATE_BYTES)},
+ };
return storvector;
}
if(delay != 0 ) {
int ret = d_pipe.readTimeout(&c, delay);
if(ret > 0) { // we got an object
- d_work.insert(make_pair(c.when, c.what));
+ d_work.emplace(c.when, c.what);
}
else if(ret==0) { // EOF
break;
int fds[2];
if(pipe(fds) < 0)
unixDie("Creating pipe");
- d_pipes.push_back({fds[0],fds[1]});
+ d_pipes.emplace_back(fds[0], fds[1]);
}
if (n<1) {
throw ArgException("Trying to launch unknown backend '"+module+"'");
}
d_repository[module]->declareArguments(name);
- d_instances.push_back(make_pair(module,name));
+ d_instances.emplace_back(module, name);
}
}
return;
struct timeval now;
gettimeofday(&now, 0);
- g_confDelta.push_back({now,line});
+ g_confDelta.emplace_back(now, line);
}
static string historyFile(const bool &ignoreHOME = false)
vector<pair<unsigned int, DNSName>> rcounts;
rcounts.reserve(counts.size());
for(const auto& c : counts)
- rcounts.push_back(make_pair(c.second, c.first.makeLowerCase()));
+ rcounts.emplace_back(c.second, c.first.makeLowerCase());
sort(rcounts.begin(), rcounts.end(), [](const decltype(rcounts)::value_type& a,
const decltype(rcounts)::value_type& b) {
continue;
e["qname"]=c.name.toString();
e["rcode"]=std::to_string(c.dh.rcode);
- ret.push_back(std::make_pair(count,e));
+ ret.emplace_back(count, e);
count++;
}
}
vector<pair<unsigned int, ComboAddress>> rcounts;
rcounts.reserve(counts.size());
for(const auto& c : counts)
- rcounts.push_back(make_pair(c.second, c.first));
+ rcounts.emplace_back(c.second, c.first);
sort(rcounts.begin(), rcounts.end(), [](const decltype(rcounts)::value_type& a,
const decltype(rcounts)::value_type& b) {
vector<pair<unsigned int, DNSName>> rcounts;
rcounts.reserve(counts.size());
for(const auto& c : counts)
- rcounts.push_back(make_pair(c.second, c.first.makeLowerCase()));
+ rcounts.emplace_back(c.second, c.first.makeLowerCase());
sort(rcounts.begin(), rcounts.end(), [](const decltype(rcounts)::value_type& a,
const decltype(rcounts)::value_type& b) {
if (c.dh.opcode != 0) {
extra = " (" + Opcode::to_s(c.dh.opcode) + ")";
}
- out.insert(make_pair(c.when, (fmt % DiffTime(now, c.when) % c.requestor.toStringWithPort() % dnsdist::Protocol(c.protocol).toString() % "" % htons(c.dh.id) % c.name.toString() % qt.toString() % "" % (c.dh.tc ? "TC" : "") % (c.dh.rd? "RD" : "") % (c.dh.aa? "AA" : "") % ("Question" + extra)).str() )) ;
+ out.emplace(c.when, (fmt % DiffTime(now, c.when) % c.requestor.toStringWithPort() % dnsdist::Protocol(c.protocol).toString() % "" % htons(c.dh.id) % c.name.toString() % qt.toString() % "" % (c.dh.tc ? "TC" : "") % (c.dh.rd ? "RD" : "") % (c.dh.aa ? "AA" : "") % ("Question" + extra)).str());
if(limit && *limit==++num)
break;
}
if (c.usec != std::numeric_limits<decltype(c.usec)>::max()) {
- out.insert(make_pair(c.when, (fmt % DiffTime(now, c.when) % c.requestor.toStringWithPort() % dnsdist::Protocol(c.protocol).toString() % c.ds.toStringWithPort() % htons(c.dh.id) % c.name.toString() % qt.toString() % (c.usec/1000.0) % (c.dh.tc ? "TC" : "") % (c.dh.rd? "RD" : "") % (c.dh.aa? "AA" : "") % (RCode::to_s(c.dh.rcode) + extra)).str() )) ;
+ out.emplace(c.when, (fmt % DiffTime(now, c.when) % c.requestor.toStringWithPort() % dnsdist::Protocol(c.protocol).toString() % c.ds.toStringWithPort() % htons(c.dh.id) % c.name.toString() % qt.toString() % (c.usec / 1000.0) % (c.dh.tc ? "TC" : "") % (c.dh.rd ? "RD" : "") % (c.dh.aa ? "AA" : "") % (RCode::to_s(c.dh.rcode) + extra)).str());
}
else {
- out.insert(make_pair(c.when, (fmt % DiffTime(now, c.when) % c.requestor.toStringWithPort() % dnsdist::Protocol(c.protocol).toString() % c.ds.toStringWithPort() % htons(c.dh.id) % c.name.toString() % qt.toString() % "T.O" % (c.dh.tc ? "TC" : "") % (c.dh.rd? "RD" : "") % (c.dh.aa? "AA" : "") % (RCode::to_s(c.dh.rcode) + extra)).str() )) ;
+ out.emplace(c.when, (fmt % DiffTime(now, c.when) % c.requestor.toStringWithPort() % dnsdist::Protocol(c.protocol).toString() % c.ds.toStringWithPort() % htons(c.dh.id) % c.name.toString() % qt.toString() % "T.O" % (c.dh.tc ? "TC" : "") % (c.dh.rd ? "RD" : "") % (c.dh.aa ? "AA" : "") % (RCode::to_s(c.dh.rcode) + extra)).str());
}
if (limit && *limit == ++num) {
auto certFile = boost::get<std::string>(certFiles);
auto keyFile = boost::get<std::string>(keyFiles);
pairs.clear();
- pairs.push_back({certFile, keyFile});
+ pairs.emplace_back(certFile, keyFile);
}
else if (certFiles.type() == typeid(std::vector<std::pair<int,std::string>>) && keyFiles.type() == typeid(std::vector<std::pair<int,std::string>>))
{
if (certFilesVect.size() == keyFilesVect.size()) {
pairs.clear();
for (size_t idx = 0; idx < certFilesVect.size(); idx++) {
- pairs.push_back({certFilesVect.at(idx).second, keyFilesVect.at(idx).second});
+ pairs.emplace_back(certFilesVect.at(idx).second, keyFilesVect.at(idx).second);
}
}
else {
vector<pair<int, std::shared_ptr<DownstreamState> > > ret;
int count=1;
for(const auto& s : g_dstates.getCopy()) {
- ret.push_back(make_pair(count++, s));
+ ret.emplace_back(count++, s);
}
return ret;
});
if (vars->count("customResponseHeaders")) {
for (auto const& headerMap : boost::get<std::map<std::string,std::string>>((*vars)["customResponseHeaders"])) {
- std::pair<std::string,std::string> headerResponse = std::make_pair(boost::to_lower_copy(headerMap.first), headerMap.second);
- frontend->d_customResponseHeaders.push_back(headerResponse);
+ auto headerResponse = std::make_pair(boost::to_lower_copy(headerMap.first), headerMap.second);
+ frontend->d_customResponseHeaders.push_back(std::move(headerResponse));
}
}
as other threads might hold a copy. We can however update the pointer as long as we hold the lock. */
unsigned int count = static_cast<unsigned int>((*servers)->size());
auto newServers = std::make_shared<ServerPolicy::NumberedServerVector>(*(*servers));
- newServers->push_back(make_pair(++count, server));
+ newServers->emplace_back(++count, server);
/* we need to reorder based on the server 'order' */
std::stable_sort(newServers->begin(), newServers->end(), [](const std::pair<unsigned int,std::shared_ptr<DownstreamState> >& a, const std::pair<unsigned int,std::shared_ptr<DownstreamState> >& b) {
return a.second->order < b.second->order;
du->query_at = req->query_at;
du->headers.reserve(req->headers.size);
for (size_t i = 0; i < req->headers.size; ++i) {
- du->headers.push_back(std::make_pair(std::string(req->headers.entries[i].name->base, req->headers.entries[i].name->len),
- std::string(req->headers.entries[i].value.base, req->headers.entries[i].value.len)));
+ du->headers.emplace_back(std::string(req->headers.entries[i].name->base, req->headers.entries[i].name->len),
+ std::string(req->headers.entries[i].value.base, req->headers.entries[i].value.len));
}
#ifdef HAVE_H2O_SOCKET_GET_SSL_SERVER_NAME
g_clientQuestions++;
totalQueries++;
counts[make_pair(mdp.d_qname, mdp.d_qtype)]++;
- questions.insert(make_pair(mdp.d_qname, mdp.d_qtype));
+ questions.emplace(mdp.d_qname, mdp.d_qtype);
}
else if(mdp.d_header.rd && mdp.d_header.qr) {
rdacounts[pr.d_pheader.ts.tv_sec + 0.01*(pr.d_pheader.ts.tv_usec/10000)]++;
g_lastanswerTime=pr.d_pheader.ts;
g_clientResponses++;
- answers.insert(make_pair(mdp.d_qname, mdp.d_qtype));
+ answers.emplace(mdp.d_qname, mdp.d_qtype);
}
else if(!mdp.d_header.rd && !mdp.d_header.qr) {
g_lastquestionTime=pr.d_pheader.ts;
g_serverQuestions++;
counts[make_pair(mdp.d_qname, mdp.d_qtype)]++;
- questions.insert(make_pair(mdp.d_qname, mdp.d_qtype));
+ questions.emplace(mdp.d_qname, mdp.d_qtype);
totalQueries++;
}
else if(!mdp.d_header.rd && mdp.d_header.qr) {
- answers.insert(make_pair(mdp.d_qname, mdp.d_qtype));
+ answers.emplace(mdp.d_qname, mdp.d_qtype);
g_serverResponses++;
}
if(d_wantsnsid) {
const static string mode_server_id=::arg()["server-id"];
if(mode_server_id != "disabled") {
- opts.push_back(make_pair(EDNSOptionCode::NSID, mode_server_id));
+ opts.emplace_back(EDNSOptionCode::NSID, mode_server_id);
optsize += EDNS_OPTION_CODE_SIZE + EDNS_OPTION_LENGTH_SIZE + mode_server_id.size();
}
}
eso.scope = Netmask(eso.source.getNetwork(), maxScopeMask);
string opt = makeEDNSSubnetOptsString(eso);
- opts.push_back(make_pair(8, opt)); // 'EDNS SUBNET'
+ opts.emplace_back(8, opt); // 'EDNS SUBNET'
}
if (d_haveednscookie && d_eco.isWellFormed()) {
d_eco.makeServerCookie(s_EDNSCookieKey, getInnerRemote());
- opts.push_back(make_pair(EDNSOptionCode::COOKIE, d_eco.makeOptString()));
+ opts.emplace_back(EDNSOptionCode::COOKIE, d_eco.makeOptString());
}
if(!opts.empty() || d_haveednssection || d_dnssecOk)
{
uint16_t searchclass = (dr.d_type == QType::OPT) ? 1 : dr.d_class; // class is invalid for OPT
- typemap_t::const_iterator i=getTypemap().find(make_pair(searchclass, dr.d_type));
+ auto i = getTypemap().find(make_pair(searchclass, dr.d_type));
if(i==getTypemap().end() || !i->second) {
return std::make_shared<UnknownRecordContent>(dr, pr);
}
std::shared_ptr<DNSRecordContent> DNSRecordContent::mastermake(uint16_t qtype, uint16_t qclass,
const string& content)
{
- zmakermap_t::const_iterator i=getZmakermap().find(make_pair(qclass, qtype));
+ auto i = getZmakermap().find(make_pair(qclass, qtype));
if(i==getZmakermap().end()) {
return std::make_shared<UnknownRecordContent>(content);
}
uint16_t searchclass = (dr.d_type == QType::OPT) ? 1 : dr.d_class; // class is invalid for OPT
- typemap_t::const_iterator i=getTypemap().find(make_pair(searchclass, dr.d_type));
+ auto i = getTypemap().find(make_pair(searchclass, dr.d_type));
if(i==getTypemap().end() || !i->second) {
return std::make_shared<UnknownRecordContent>(dr, pr);
}
d_tsigPos = recordStartPos;
}
- d_answers.push_back(make_pair(std::move(dr), pr.getPosition() - sizeof(dnsheader)));
+ d_answers.emplace_back(std::move(dr), pr.getPosition() - sizeof(dnsheader));
}
#if 0
if(z)
getZmakermap()[make_pair(cl,ty)]=z;
- getT2Namemap().insert(make_pair(make_pair(cl,ty), name));
- getN2Typemap().insert(make_pair(name, make_pair(cl,ty)));
+ getT2Namemap().emplace(make_pair(cl, ty), name);
+ getN2Typemap().emplace(name, make_pair(cl, ty));
}
static void unregist(uint16_t cl, uint16_t ty)
{
- pair<uint16_t, uint16_t> key=make_pair(cl, ty);
+ auto key = make_pair(cl, ty);
getTypemap().erase(key);
getZmakermap().erase(key);
}
static const string NumberToType(uint16_t num, uint16_t classnum=1)
{
- t2namemap_t::const_iterator iter = getT2Namemap().find(make_pair(classnum, num));
+ auto iter = getT2Namemap().find(make_pair(classnum, num));
if(iter == getT2Namemap().end())
return "TYPE" + std::to_string(num);
// throw runtime_error("Unknown DNS type with numerical id "+std::to_string(num));
queryTime.tv_sec = pr.d_pheader.ts.tv_sec;
queryTime.tv_usec = pr.d_pheader.ts.tv_usec;
uniqueId = getUniqueID();
- ids[dh->id] = std::make_pair(uniqueId, queryTime);
+ ids[dh->id] = {uniqueId, queryTime};
}
else {
const auto& it = ids.find(dh->id);
string field(d_data.c_str() + pos, len);
pos+=len;
- options.push_back(make_pair(code, std::move(field)));
+ options.emplace_back(code, std::move(field));
}
}
if(!g_quiet)
cout<<"\t* orig better *"<<endl;
s_origbetter++;
- if(!g_quiet)
- if(s_origbetterset.insert(make_pair(qd.d_qi.d_qname, qd.d_qi.d_qtype)).second) {
+ if (!g_quiet)
+ if (s_origbetterset.emplace(qd.d_qi.d_qname, qd.d_qi.d_qtype).second) {
cout<<"orig better: " << qd.d_qi.d_qname<<" "<< qd.d_qi.d_qtype<<endl;
}
}
lc.outstanding = liveQuestions();
LiveCounts diff = lc - lastcounts;
- pcounts.push_back(make_pair(pr.d_pheader.ts.tv_sec, diff));
-
- }
- lastsec = pr.d_pheader.ts.tv_sec;
- lastcounts = lc;
- }
+ pcounts.emplace_back(pr.d_pheader.ts.tv_sec, diff);
+ }
+ lastsec = pr.d_pheader.ts.tv_sec;
+ lastcounts = lc;
+ }
if(lowestTime) { lowestTime = min((time_t)lowestTime, (time_t)pr.d_pheader.ts.tv_sec); }
else { lowestTime = pr.d_pheader.ts.tv_sec; }
vector<pair<uint8_t, string>> ret;
for (auto const& value : getMakers()) {
auto dcke = value.second(value.first);
- ret.push_back(make_pair(value.first, dcke->getName()));
+ ret.emplace_back(value.first, dcke->getName());
}
return ret;
}
}
}
- ret.push_back(make_pair(remove,add));
+ ret.emplace_back(remove, add);
}
return ret;
vector<pair<int, ComboAddress> > pick;
for(auto& i : wips) {
sum += i.first;
- pick.push_back({sum, i.second});
+ pick.emplace_back(sum, i.second);
}
int r = dns_random(sum);
auto p = upper_bound(pick.begin(), pick.end(), r, [](int rarg, const decltype(pick)::value_type& a) { return rarg < a.first; });
{
// Add key-values pairs below.
// Make sure you add string values explicitly converted to string.
- // e.g. features.push_back(make_pair("somekey", string("stringvalue"));
+ // e.g. features.emplace_back("somekey", string("stringvalue");
// Both int and double end up as a lua number type.
- features.push_back(make_pair("PR8001_devicename", true));
+ features.emplace_back("PR8001_devicename", true);
}
void RecursorLua4::maintenance() const
outgoingECSBits = srcmask->getBits();
outgoingECSAddr = srcmask->getNetwork();
// cout<<"Adding request mask: "<<eo.source.toString()<<endl;
- opts.push_back(make_pair(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(eo)));
+ opts.emplace_back(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(eo));
weWantEDNSSubnet=true;
}
l_active=true;
allocators_t ret;
for(const auto& e : d_stats) {
- ret.push_back(make_pair(e.second, e.first));
+ ret.emplace_back(e.second, e.first);
}
std::sort(ret.begin(), ret.end(),
[](const allocators_t::value_type& a,
// push token
if (j == string::npos) {
- container.push_back (make_pair(i, len));
+ container.emplace_back(i, len);
return;
} else
- container.push_back (make_pair(i, j));
+ container.emplace_back(i, j);
// set up for next loop
i = j + 1;
if (it->d_ttd.tv_sec == 0 || tied <= boost::tie(it->d_ttd.tv_sec, it->d_ttd.tv_usec)) {
break;
}
- ret.push_back(std::make_pair(it->d_fd, it->d_parameter));
+ ret.emplace_back(it->d_fd, it->d_parameter);
}
return ret;
}
// nsec3.insert(new nsec3()
// cerr<<toBase32Hex(r.d_nexthash)<<endl;
- nsec3s.insert(make_pair(toLower(i->first.d_name.getRawLabel(0)), toBase32Hex(r->d_nexthash)));
+ nsec3s.emplace(toLower(i->first.d_name.getRawLabel(0)), toBase32Hex(r->d_nexthash));
nsec3salt = r->d_salt;
nsec3iters = r->d_iterations;
- nsec3t.insert(make_pair(toLower(i->first.d_name.getRawLabel(0)), r->numberOfTypesSet()));
+ nsec3t.emplace(toLower(i->first.d_name.getRawLabel(0)), r->numberOfTypesSet());
}
else
{
RSA_get0_key(d_key.get(), &n, &e, &d);
RSA_get0_factors(d_key.get(), &p, &q);
RSA_get0_crt_params(d_key.get(), &dmp1, &dmq1, &iqmp);
- outputs.push_back(make_pair("Modulus", n));
- outputs.push_back(make_pair("PublicExponent", e));
- outputs.push_back(make_pair("PrivateExponent", d));
- outputs.push_back(make_pair("Prime1", p));
- outputs.push_back(make_pair("Prime2", q));
- outputs.push_back(make_pair("Exponent1", dmp1));
- outputs.push_back(make_pair("Exponent2", dmq1));
- outputs.push_back(make_pair("Coefficient", iqmp));
+ outputs.emplace_back("Modulus", n);
+ outputs.emplace_back("PublicExponent", e);
+ outputs.emplace_back("PrivateExponent", d);
+ outputs.emplace_back("Prime1", p);
+ outputs.emplace_back("Prime2", q);
+ outputs.emplace_back("Exponent1", dmp1);
+ outputs.emplace_back("Exponent2", dmq1);
+ outputs.emplace_back("Coefficient", iqmp);
string algorithm=std::to_string(d_algorithm);
switch(d_algorithm) {
default:
algorithm += " (?)";
}
- storvect.push_back(make_pair("Algorithm", algorithm));
+ storvect.emplace_back("Algorithm", algorithm);
for(const outputs_t::value_type& value : outputs) {
std::string tmp;
int len = BN_bn2bin(value.second, reinterpret_cast<unsigned char*>(&tmp.at(0)));
if (len >= 0) {
tmp.resize(len);
- storvect.push_back(make_pair(value.first, tmp));
+ storvect.emplace_back(value.first, tmp);
}
}
else
algorithm = " ? (?)";
- storvect.push_back(make_pair("Algorithm", algorithm));
+ storvect.emplace_back("Algorithm", algorithm);
const BIGNUM *key = EC_KEY_get0_private_key(d_eckey.get());
if (key == nullptr) {
if (d_len - len)
prefix.append(d_len - len, 0x00);
- storvect.push_back(make_pair("PrivateKey", prefix + tmp));
+ storvect.emplace_back("PrivateKey", prefix + tmp);
return storvect;
}
algorithm = " ? (?)";
}
- storvect.push_back(make_pair("Algorithm", algorithm));
+ storvect.emplace_back("Algorithm", algorithm);
string buf;
size_t len = d_len;
if (EVP_PKEY_get_raw_private_key(d_edkey.get(), reinterpret_cast<unsigned char*>(&buf.at(0)), &len) < 1) {
throw runtime_error(getName() + " Could not get private key from d_edkey");
}
- storvect.push_back(make_pair("PrivateKey", buf));
+ storvect.emplace_back("PrivateKey", buf);
return storvect;
}
if(t_servfailremotes) {
t_servfailremotes->push_back(remote);
if(query && t_servfailqueryring) // packet cache
- t_servfailqueryring->push_back(make_pair(*query, qtype));
+ t_servfailqueryring->push_back({*query, qtype});
}
g_stats.servFails++;
break;
auto dc=std::unique_ptr<DNSComboWriter>(reinterpret_cast<DNSComboWriter*>(p));
try {
if (t_queryring)
- t_queryring->push_back(make_pair(dc->d_mdp.d_qname, dc->d_mdp.d_qtype));
+ t_queryring->push_back({dc->d_mdp.d_qname, dc->d_mdp.d_qtype});
uint16_t maxanswersize = dc->d_tcp ? 65535 : min(static_cast<uint16_t>(512), g_udpTruncationThreshold);
EDNSOpts edo;
const static string mode_server_id = ::arg()["server-id"];
if (mode_server_id != "disabled" && !mode_server_id.empty() &&
maxanswersize > (EDNSOptionCodeSize + EDNSOptionLengthSize + mode_server_id.size())) {
- returnedEdnsOptions.push_back(make_pair(EDNSOptionCode::NSID, mode_server_id));
+ returnedEdnsOptions.emplace_back(EDNSOptionCode::NSID, mode_server_id);
variableAnswer = true; // Can't packetcache an answer with NSID
maxanswersize -= EDNSOptionCodeSize + EDNSOptionLengthSize + mode_server_id.size();
}
if(t_bogusremotes)
t_bogusremotes->push_back(dc->d_source);
if(t_bogusqueryring)
- t_bogusqueryring->push_back(make_pair(dc->d_mdp.d_qname, dc->d_mdp.d_qtype));
+ t_bogusqueryring->push_back({dc->d_mdp.d_qname, dc->d_mdp.d_qtype});
if(g_dnssecLogBogus || sr.doLog() || g_dnssecmode == DNSSECMode::ValidateForLog) {
g_log<<Logger::Warning<<"Answer to "<<dc->d_mdp.d_qname<<"|"<<QType(dc->d_mdp.d_qtype)<<x_marker<<" for "<<dc->getRemote()<<" validates as "<<vStateToString(state)<<endl;
}
maxanswersize -= EDNSOptionCodeSize + EDNSOptionLengthSize + ecsPayload.size();
- returnedEdnsOptions.push_back(make_pair(EDNSOptionCode::ECS, std::move(ecsPayload)));
+ returnedEdnsOptions.emplace_back(EDNSOptionCode::ECS, std::move(ecsPayload));
}
}
if (modulo > 0) {
padSize = std::min(blockSize - modulo, remaining);
}
- returnedEdnsOptions.push_back(make_pair(EDNSOptionCode::PADDING, makeEDNSPaddingOptString(padSize)));
+ returnedEdnsOptions.emplace_back(EDNSOptionCode::PADDING, makeEDNSPaddingOptString(padSize));
}
}
eee.extraText = std::move(extra);
if (pw.size() < maxanswersize && (maxanswersize - pw.size()) >= (EDNSOptionCodeSize + EDNSOptionLengthSize + sizeof(eee.infoCode) + eee.extraText.size())) {
- returnedEdnsOptions.push_back(make_pair(EDNSOptionCode::EXTENDEDERROR, makeEDNSExtendedErrorOptString(eee)));
+ returnedEdnsOptions.emplace_back(EDNSOptionCode::EXTENDEDERROR, makeEDNSExtendedErrorOptString(eee));
}
}
t_bogusremotes->push_back(source);
}
if (t_bogusqueryring) {
- t_bogusqueryring->push_back(make_pair(qname, qtype));
+ t_bogusqueryring->push_back({qname, qtype});
}
}
setNonBlocking(fd);
setSocketSendBuffer(fd, 65000);
listen(fd, 128);
- deferredAdds.push_back(make_pair(fd, handleNewTCPQuestion));
+ deferredAdds.emplace_back(fd, handleNewTCPQuestion);
tcpSockets.insert(fd);
// we don't need to update g_listenSocketsAddresses since it doesn't work for TCP/IP:
setNonBlocking(fd);
- deferredAdds.push_back(make_pair(fd, handleNewUDPQuestion));
+ deferredAdds.emplace_back(fd, handleNewUDPQuestion);
g_listenSocketsAddresses[fd]=sin; // this is written to only from the startup thread, not from the workers
if(sin.sin4.sin_family == AF_INET)
g_log<<Logger::Info<<"Listening for UDP queries on "<< sin.toString() <<":"<<st.port<<endl;
};
DNSCryptoKeyEngine::storvector_t PKCS11DNSCryptoKeyEngine::convertToISCVector() const {
- storvector_t storvect;
- typedef std::vector<std::pair<std::string, std::string> > outputs_t;
- outputs_t outputs;
-
- boost::assign::push_back(storvect)
- (make_pair("Algorithm", std::to_string(d_algorithm)))
- (make_pair("Engine", d_module))
- (make_pair("Slot", d_slot_id))
- (make_pair("PIN", d_pin))
- (make_pair("Label", d_label))
- (make_pair("PubLabel", d_pub_label));
+ auto storvect = storvector_t{
+ {"Algorithm", std::to_string(d_algorithm)},
+ {"Engine", d_module},
+ {"Slot", d_slot_id},
+ {"PIN", d_pin},
+ {"Label", d_label},
+ {"PubLabel", d_pub_label},
+ };
return storvect;
};
return 0;
}
- values.push_back({ std::string(reinterpret_cast<const char*>(&header.at(pos)), len), type });
+ values.push_back({std::string(reinterpret_cast<const char*>(&header.at(pos)), len), type});
pos += len;
}
else {
- values.push_back({ std::string(), type });
+ values.push_back({"", type});
}
remaining = got - pos;
map<uint16_t, const string> ret;
for (const auto& n : names) {
- ret.insert(make_pair(n.second, n.first));
+ ret.emplace(n.second, n.first);
}
return ret;
}
{
auto i = a.length();
if (i == 0) {
- return make_pair(a, "");
+ return {a, ""};
}
--i;
if (!std::isdigit(a[i])) {
- return make_pair(a, "");
+ return {a, ""};
}
while (i > 0) {
if (!std::isdigit(a[i])) {
}
--i;
}
- return make_pair(a.substr(0, i + 1), a.substr(i + 1, a.size() - i - 1));
+ return {a.substr(0, i + 1), a.substr(i + 1, a.size() - i - 1)};
}
bool PrefixDashNumberCompare::operator()(const std::string& a, const std::string& b) const
for(const auto& the32bits : d_get32bitpointers) {
if (disabledlistMap.count(the32bits.first) == 0) {
- ret.insert(make_pair(the32bits.first, StatsMapEntry{getPrometheusName(the32bits.first), std::to_string(*the32bits.second)}));
+ ret.emplace(the32bits.first, StatsMapEntry{getPrometheusName(the32bits.first), std::to_string(*the32bits.second)});
}
}
for(const auto& atomic : d_getatomics) {
if (disabledlistMap.count(atomic.first) == 0) {
- ret.insert(make_pair(atomic.first, StatsMapEntry{getPrometheusName(atomic.first), std::to_string(atomic.second->load())}));
+ ret.emplace(atomic.first, StatsMapEntry{getPrometheusName(atomic.first), std::to_string(atomic.second->load())});
}
}
for(const auto& the64bitmembers : d_get64bitmembers) {
if (disabledlistMap.count(the64bitmembers.first) == 0) {
- ret.insert(make_pair(the64bitmembers.first, StatsMapEntry{getPrometheusName(the64bitmembers.first), std::to_string(the64bitmembers.second())}));
+ ret.emplace(the64bitmembers.first, StatsMapEntry{getPrometheusName(the64bitmembers.first), std::to_string(the64bitmembers.second())});
}
}
{
for(const auto& a : *(d_dynmetrics.lock())) {
if (disabledlistMap.count(a.first) == 0) {
- ret.insert(make_pair(a.first, StatsMapEntry{a.second.d_prometheusName, std::to_string(*a.second.d_ptr)}));
+ ret.emplace(a.first, StatsMapEntry{a.second.d_prometheusName, std::to_string(*a.second.d_ptr)});
}
}
}
} catch (std::exception &e) {
return "Error: " + std::string(e.what()) + ", nothing wiped\n";
}
- toWipe.push_back({canon, subtree});
+ toWipe.emplace_back(canon, subtree);
}
int count=0, pcount=0, countNeg=0;
for (unsigned int n = 0; n < g_numThreads; ++n) {
uint64_t tm = doGetThreadCPUMsec(n);
std::string pname = pbasename + "{thread=\"" + std::to_string(n) + "\"}";
- entries.emplace(make_pair(name + "-thread-" + std::to_string(n), StatsMapEntry{pname, std::to_string(tm)}));
+ entries.emplace(name + "-thread-" + std::to_string(n), StatsMapEntry{pname, std::to_string(tm)});
}
return entries;
}
typedef std::multimap<int, ComboAddress> rcounts_t;
rcounts_t rcounts;
-
- for(counts_t::const_iterator i=counts.begin(); i != counts.end(); ++i)
- rcounts.insert(make_pair(-i->second, i->first));
+
+ for (auto&& c : counts)
+ rcounts.emplace(-c.second, c.first);
ostringstream ret;
ret<<"Over last "<<total<<" entries:\n";
typedef std::multimap<int, query_t> rcounts_t;
rcounts_t rcounts;
-
- for(counts_t::const_iterator i=counts.begin(); i != counts.end(); ++i)
- rcounts.insert(make_pair(-i->second, i->first));
+
+ for (auto&& c : counts)
+ rcounts.emplace(-c.second, c.first);
ostringstream ret;
ret<<"Over last "<<total<<" entries:\n";
ecsOpts.source = ecs;
string origECSOptionStr = makeEDNSSubnetOptsString(ecsOpts);
DNSPacketWriter::optvect_t opts;
- opts.push_back(make_pair(EDNSOptionCode::COOKIE, cookiesOptionStr));
- opts.push_back(make_pair(EDNSOptionCode::ECS, origECSOptionStr));
- opts.push_back(make_pair(EDNSOptionCode::COOKIE, cookiesOptionStr));
+ opts.emplace_back(EDNSOptionCode::COOKIE, cookiesOptionStr);
+ opts.emplace_back(EDNSOptionCode::ECS, origECSOptionStr);
+ opts.emplace_back(EDNSOptionCode::COOKIE, cookiesOptionStr);
pw.addOpt(512, 0, 0, opts);
pw.commit();
}
return RCode::FormErr;
if (rr->d_class == QClass::IN) {
- rrSetKey_t key = make_pair(rr->d_name, QType(rr->d_type));
+ rrSetKey_t key = {rr->d_name, QType(rr->d_type)};
rrVector_t *vec = &preReqRRsets[key];
vec->push_back(DNSResourceRecord::fromWire(*rr));
}
o<<"\t"<<i->first.d_content->getZoneRepresentation();
}
- records.push_back(make_pair(i->first.d_name,o.str()));
+ records.emplace_back(i->first.d_name, o.str());
DNSName shorter(i->first.d_name);
do {
if (ednsnm) {
EDNSSubnetOpts eo;
eo.source = *ednsnm;
- opts.push_back(
- make_pair(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(eo)));
+ opts.emplace_back(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(eo));
}
pw.addOpt(bufsize, 0, dnssec ? EDNSOpts::DNSSECOK : 0, opts);
while (getline(std::cin, line)) {
auto fields = splitField(line, ' ');
- questions.push_back(make_pair(fields.first, fields.second));
+ questions.emplace_back(fields.first, fields.second);
}
} else {
- questions.push_back(make_pair(name, type));
+ questions.emplace_back(name, type);
}
if (doh) {
xpfproto, xpfsrc, xpfdst, qclass, opcode, 0);
MiniCurl mc;
MiniCurl::MiniCurlHeaders mch;
- mch.insert(std::make_pair("Content-Type", "application/dns-message"));
- mch.insert(std::make_pair("Accept", "application/dns-message"));
+ mch.emplace("Content-Type", "application/dns-message");
+ mch.emplace("Accept", "application/dns-message");
string question(packet.begin(), packet.end());
// FIXME: how do we use proxyheader here?
reply = mc.postURL(argv[1], question, mch, timeout.tv_sec, fastOpen);
auto data = d_data.lock();
ret.reserve(data->d_suckdomains.size());
for (auto const &d : data->d_suckdomains) {
- ret.push_back(make_pair(d.domain, d.master));
+ ret.emplace_back(d.domain, d.master);
}
return ret;
}
storvector_t storvector;
string algorithm = "15 (ED25519)";
- storvector.push_back(make_pair("Algorithm", algorithm));
+ storvector.emplace_back("Algorithm", algorithm);
vector<unsigned char> buffer;
- storvector.push_back(make_pair("PrivateKey", string((char*)d_seckey, crypto_sign_ed25519_SEEDBYTES)));
+ storvector.emplace_back("PrivateKey", string((char*)d_seckey, crypto_sign_ed25519_SEEDBYTES));
return storvector;
}
typedef pair<SComboAddress, unsigned int> stor_t;
vector<stor_t> raw =d_comboRings[name].lock()->get();
for(const stor_t& stor : raw) {
- ret.push_back(make_pair(stor.first.ca.toString(), stor.second));
+ ret.emplace_back(stor.first.ca.toString(), stor.second);
}
} else if (d_dnsnameqtyperings.count(name)) {
auto raw = d_dnsnameqtyperings[name].lock()->get();
for (auto const &e : raw) {
- ret.push_back(make_pair(std::get<0>(e.first).toLogString() + "/" + std::get<1>(e.first).toString(), e.second));
+ ret.emplace_back(std::get<0>(e.first).toLogString() + "/" + std::get<1>(e.first).toString(), e.second);
}
}
return ret;
qclass == QClass::IN) {
handled = true;
if (qtype == QType::PTR || qtype == QType::ANY)
- answers.push_back({QType::PTR, "localhost."});
+ answers.emplace_back(QType::PTR, "localhost.");
}
if (qname.isPartOf(localhost) &&
qclass == QClass::IN) {
handled = true;
if (qtype == QType::A || qtype == QType::ANY)
- answers.push_back({QType::A, "127.0.0.1"});
+ answers.emplace_back(QType::A, "127.0.0.1");
if (qtype == QType::AAAA || qtype == QType::ANY)
- answers.push_back({QType::AAAA, "::1"});
+ answers.emplace_back(QType::AAAA, "::1");
}
if ((qname == versionbind || qname == idserver || qname == versionpdns) &&
handled = true;
if (qtype == QType::TXT || qtype == QType::ANY) {
if(qname == versionbind || qname == versionpdns)
- answers.push_back({QType::TXT, "\""+::arg()["version-string"]+"\""});
+ answers.emplace_back(QType::TXT, "\"" + ::arg()["version-string"] + "\"");
else if (s_serverID != "disabled")
- answers.push_back({QType::TXT, "\""+s_serverID+"\""});
+ answers.emplace_back(QType::TXT, "\"" + s_serverID + "\"");
}
}
ans<<dsRecord.d_tag;
}
ans << "\"";
- answers.push_back({QType::TXT, ans.str()});
+ answers.emplace_back(QType::TXT, ans.str());
}
}
}
if (negAnchor.second.length())
ans<<" "<<negAnchor.second;
ans << "\"";
- answers.push_back({QType::TXT, ans.str()});
+ answers.emplace_back(QType::TXT, ans.str());
}
}
}
answer.qtype=qtype.getCode();
for(const auto& dr : bestns) {
if (auto nsContent = getRR<NSRecordContent>(dr)) {
- answer.bestns.insert(make_pair(dr.d_name, nsContent->getNS()));
+ answer.bestns.emplace(dr.d_name, nsContent->getNS());
}
}
rnameservers.reserve(tnameservers.size());
for(const auto& tns: tnameservers) {
float speed = t_sstorage.nsSpeeds[tns.first].get(d_now);
- rnameservers.push_back({tns.first, speed});
+ rnameservers.emplace_back(tns.first, speed);
if(tns.first.empty()) // this was an authoritative OOB zone, don't pollute the nsSpeeds with that
return rnameservers;
}
ecsOpts.source = Netmask(origRemote, ECSSourcePrefixV4);
string origECSOption = makeEDNSSubnetOptsString(ecsOpts);
GenericDNSPacketWriter<PacketBuffer>::optvect_t opts;
- opts.push_back(make_pair(EDNSOptionCode::ECS, origECSOption));
+ opts.emplace_back(EDNSOptionCode::ECS, origECSOption);
pw.addOpt(512, 0, 0, opts);
pw.commit();
ecsOpts.source = Netmask(origRemote, ECSSourcePrefixV4);
string origECSOption = makeEDNSSubnetOptsString(ecsOpts);
GenericDNSPacketWriter<PacketBuffer>::optvect_t opts;
- opts.push_back(make_pair(EDNSOptionCode::ECS, origECSOption));
+ opts.emplace_back(EDNSOptionCode::ECS, origECSOption);
pw.addOpt(512, 0, 0, opts);
pw.commit();
ecsOpts.source = Netmask(origRemote, 32);
string origECSOption = makeEDNSSubnetOptsString(ecsOpts);
GenericDNSPacketWriter<PacketBuffer>::optvect_t opts;
- opts.push_back(make_pair(EDNSOptionCode::ECS, origECSOption));
+ opts.emplace_back(EDNSOptionCode::ECS, origECSOption);
pw.addOpt(512, 0, 0, opts);
pw.commit();
ecsOpts.source = Netmask(origRemote, 8);
string origECSOption = makeEDNSSubnetOptsString(ecsOpts);
GenericDNSPacketWriter<PacketBuffer>::optvect_t opts;
- opts.push_back(make_pair(EDNSOptionCode::ECS, origECSOption));
+ opts.emplace_back(EDNSOptionCode::ECS, origECSOption);
pw.addOpt(512, 0, 0, opts);
pw.commit();
ecsOpts.source = Netmask(origRemote, 8);
string origECSOption = makeEDNSSubnetOptsString(ecsOpts);
GenericDNSPacketWriter<PacketBuffer>::optvect_t opts;
- opts.push_back(make_pair(EDNSOptionCode::ECS, origECSOption));
+ opts.emplace_back(EDNSOptionCode::ECS, origECSOption);
pw.addOpt(512, 0, 0, opts);
pw.startRecord(DNSName("tsigname."), QType::TSIG, 0, QClass::ANY, DNSResourceRecord::ADDITIONAL, false);
pw.commit();
ecsOpts.source = Netmask(origRemote, 8);
string origECSOption = makeEDNSSubnetOptsString(ecsOpts);
GenericDNSPacketWriter<PacketBuffer>::optvect_t opts;
- opts.push_back(make_pair(EDNSOptionCode::ECS, origECSOption));
+ opts.emplace_back(EDNSOptionCode::ECS, origECSOption);
pw.addOpt(512, 0, 0, opts);
pw.commit();
ecsOpts.source = Netmask(origRemote, 8);
string origECSOption = makeEDNSSubnetOptsString(ecsOpts);
GenericDNSPacketWriter<PacketBuffer>::optvect_t opts;
- opts.push_back(make_pair(EDNSOptionCode::ECS, origECSOption));
+ opts.emplace_back(EDNSOptionCode::ECS, origECSOption);
pw.addOpt(512, 0, 0, opts);
pw.commit();
ecsOpts.source = Netmask(origRemote, 8);
string origECSOption = makeEDNSSubnetOptsString(ecsOpts);
GenericDNSPacketWriter<PacketBuffer>::optvect_t opts;
- opts.push_back(make_pair(EDNSOptionCode::ECS, origECSOption));
+ opts.emplace_back(EDNSOptionCode::ECS, origECSOption);
pw.startRecord(DNSName("additional"), QType::A, 0, QClass::IN, DNSResourceRecord::ADDITIONAL, false);
pw.xfr32BitInt(0x01020304);
pw.addOpt(512, 0, 0, opts);
ecsOpts.source = Netmask(origRemote, ECSSourcePrefixV4);
string origECSOptionStr = makeEDNSSubnetOptsString(ecsOpts);
GenericDNSPacketWriter<PacketBuffer>::optvect_t opts;
- opts.push_back(make_pair(EDNSOptionCode::ECS, origECSOptionStr));
+ opts.emplace_back(EDNSOptionCode::ECS, origECSOptionStr);
pw.addOpt(512, 0, 0, opts);
pw.commit();
EDNSCookiesOpt cookiesOpt("deadbeefdeadbeef");
string cookiesOptionStr = cookiesOpt.makeOptString();
GenericDNSPacketWriter<PacketBuffer>::optvect_t opts;
- opts.push_back(make_pair(EDNSOptionCode::ECS, origECSOptionStr));
- opts.push_back(make_pair(EDNSOptionCode::COOKIE, cookiesOptionStr));
+ opts.emplace_back(EDNSOptionCode::ECS, origECSOptionStr);
+ opts.emplace_back(EDNSOptionCode::COOKIE, cookiesOptionStr);
pw.addOpt(512, 0, 0, opts);
pw.commit();
string cookiesOptionStr2 = cookiesOpt.makeOptString();
GenericDNSPacketWriter<PacketBuffer>::optvect_t opts;
- opts.push_back(make_pair(EDNSOptionCode::COOKIE, cookiesOptionStr1));
- opts.push_back(make_pair(EDNSOptionCode::ECS, origECSOptionStr));
- opts.push_back(make_pair(EDNSOptionCode::COOKIE, cookiesOptionStr2));
+ opts.emplace_back(EDNSOptionCode::COOKIE, cookiesOptionStr1);
+ opts.emplace_back(EDNSOptionCode::ECS, origECSOptionStr);
+ opts.emplace_back(EDNSOptionCode::COOKIE, cookiesOptionStr2);
pw.addOpt(512, 0, 0, opts);
pw.commit();
ecsOpts.source = Netmask(origRemote, ECSSourcePrefixV4);
string origECSOptionStr = makeEDNSSubnetOptsString(ecsOpts);
GenericDNSPacketWriter<PacketBuffer>::optvect_t opts;
- opts.push_back(make_pair(EDNSOptionCode::COOKIE, cookiesOptionStr));
- opts.push_back(make_pair(EDNSOptionCode::ECS, origECSOptionStr));
+ opts.emplace_back(EDNSOptionCode::COOKIE, cookiesOptionStr);
+ opts.emplace_back(EDNSOptionCode::ECS, origECSOptionStr);
pw.addOpt(512, 0, 0, opts);
pw.commit();
ecsOpts.source = Netmask(origRemote, ECSSourcePrefixV4);
string origECSOptionStr = makeEDNSSubnetOptsString(ecsOpts);
GenericDNSPacketWriter<PacketBuffer>::optvect_t opts;
- opts.push_back(make_pair(EDNSOptionCode::ECS, origECSOptionStr));
+ opts.emplace_back(EDNSOptionCode::ECS, origECSOptionStr);
pw.addOpt(512, 0, 0, opts);
pw.commit();
EDNSCookiesOpt cookiesOpt("deadbeefdeadbeef");
string cookiesOptionStr = cookiesOpt.makeOptString();
GenericDNSPacketWriter<PacketBuffer>::optvect_t opts;
- opts.push_back(make_pair(EDNSOptionCode::ECS, origECSOptionStr));
- opts.push_back(make_pair(EDNSOptionCode::COOKIE, cookiesOptionStr));
+ opts.emplace_back(EDNSOptionCode::ECS, origECSOptionStr);
+ opts.emplace_back(EDNSOptionCode::COOKIE, cookiesOptionStr);
pw.addOpt(512, 0, 0, opts);
pw.commit();
string cookiesOptionStr1 = cookiesOpt.makeOptString();
string cookiesOptionStr2 = cookiesOpt.makeOptString();
GenericDNSPacketWriter<PacketBuffer>::optvect_t opts;
- opts.push_back(make_pair(EDNSOptionCode::COOKIE, cookiesOptionStr1));
- opts.push_back(make_pair(EDNSOptionCode::ECS, origECSOptionStr));
- opts.push_back(make_pair(EDNSOptionCode::COOKIE, cookiesOptionStr2));
+ opts.emplace_back(EDNSOptionCode::COOKIE, cookiesOptionStr1);
+ opts.emplace_back(EDNSOptionCode::ECS, origECSOptionStr);
+ opts.emplace_back(EDNSOptionCode::COOKIE, cookiesOptionStr2);
pw.addOpt(512, 0, 0, opts);
pw.commit();
EDNSCookiesOpt cookiesOpt("deadbeefdeadbeef");
string cookiesOptionStr = cookiesOpt.makeOptString();
GenericDNSPacketWriter<PacketBuffer>::optvect_t opts;
- opts.push_back(make_pair(EDNSOptionCode::COOKIE, cookiesOptionStr));
- opts.push_back(make_pair(EDNSOptionCode::ECS, origECSOptionStr));
+ opts.emplace_back(EDNSOptionCode::COOKIE, cookiesOptionStr);
+ opts.emplace_back(EDNSOptionCode::ECS, origECSOptionStr);
pw.addOpt(512, 0, 0, opts);
pw.commit();
EDNSCookiesOpt cookiesOpt("deadbeefdeadbeef");
string cookiesOptionStr = cookiesOpt.makeOptString();
GenericDNSPacketWriter<PacketBuffer>::optvect_t opts;
- opts.push_back(make_pair(EDNSOptionCode::COOKIE, cookiesOptionStr));
- opts.push_back(make_pair(EDNSOptionCode::ECS, origECSOptionStr));
+ opts.emplace_back(EDNSOptionCode::COOKIE, cookiesOptionStr);
+ opts.emplace_back(EDNSOptionCode::ECS, origECSOptionStr);
{
/* no EDNS */
EDNSCookiesOpt cookiesOpt("deadbeefdeadbeef");
string cookiesOptionStr = cookiesOpt.makeOptString();
GenericDNSPacketWriter<PacketBuffer>::optvect_t opts;
- opts.push_back(make_pair(EDNSOptionCode::COOKIE, cookiesOptionStr));
- opts.push_back(make_pair(EDNSOptionCode::ECS, origECSOptionStr));
+ opts.emplace_back(EDNSOptionCode::COOKIE, cookiesOptionStr);
+ opts.emplace_back(EDNSOptionCode::ECS, origECSOptionStr);
ComboAddress lc("127.0.0.1");
ComboAddress rem("127.0.0.1");
struct timespec queryRealTime;
ecsOpts.source = Netmask(ComboAddress("127.0.0.1"), ECSSourcePrefixV4);
const string ecsOptionStr = makeEDNSSubnetOptsString(ecsOpts);
GenericDNSPacketWriter<PacketBuffer>::optvect_t opts;
- opts.push_back(make_pair(EDNSOptionCode::ECS, ecsOptionStr));
+ opts.emplace_back(EDNSOptionCode::ECS, ecsOptionStr);
const ComboAddress lc("127.0.0.1");
const ComboAddress rem("127.0.0.1");
uint16_t optRDPosition;
const size_t sizeOfCookieOption = /* option code */ 2 + /* option length */ 2 + cookiesOpt.size();
/*
GenericDNSPacketWriter<PacketBuffer>::optvect_t opts;
- opts.push_back(make_pair(EDNSOptionCode::COOKIE, cookiesOptionStr));
- opts.push_back(make_pair(EDNSOptionCode::ECS, ecsOptionStr));
- opts.push_back(make_pair(EDNSOptionCode::COOKIE, cookiesOptionStr));
+ opts.emplace_back(EDNSOptionCode::COOKIE, cookiesOptionStr);
+ opts.emplace_back(EDNSOptionCode::ECS, ecsOptionStr);
+ opts.emplace_back(EDNSOptionCode::COOKIE, cookiesOptionStr);
*/
const ComboAddress lc("127.0.0.1");
const ComboAddress rem("127.0.0.1");
PacketBuffer query;
GenericDNSPacketWriter<PacketBuffer> pw(query, qname, qtype, qclass, 0);
GenericDNSPacketWriter<PacketBuffer>::optvect_t opts;
- opts.push_back(make_pair(EDNSOptionCode::COOKIE, cookiesOptionStr));
- opts.push_back(make_pair(EDNSOptionCode::COOKIE, cookiesOptionStr));
+ opts.emplace_back(EDNSOptionCode::COOKIE, cookiesOptionStr);
+ opts.emplace_back(EDNSOptionCode::COOKIE, cookiesOptionStr);
pw.addOpt(512, 0, 0, opts);
pw.commit();
PacketBuffer query;
GenericDNSPacketWriter<PacketBuffer> pw(query, qname, qtype, qclass, 0);
GenericDNSPacketWriter<PacketBuffer>::optvect_t opts;
- opts.push_back(make_pair(EDNSOptionCode::ECS, ecsOptionStr));
- opts.push_back(make_pair(EDNSOptionCode::ECS, ecsOptionStr));
+ opts.emplace_back(EDNSOptionCode::ECS, ecsOptionStr);
+ opts.emplace_back(EDNSOptionCode::ECS, ecsOptionStr);
pw.addOpt(512, 0, 0, opts);
pw.commit();
PacketBuffer query;
GenericDNSPacketWriter<PacketBuffer> pw(query, qname, qtype, qclass, 0);
GenericDNSPacketWriter<PacketBuffer>::optvect_t opts;
- opts.push_back(make_pair(EDNSOptionCode::COOKIE, cookiesOptionStr));
- opts.push_back(make_pair(EDNSOptionCode::ECS, ecsOptionStr));
- opts.push_back(make_pair(EDNSOptionCode::COOKIE, cookiesOptionStr));
+ opts.emplace_back(EDNSOptionCode::COOKIE, cookiesOptionStr);
+ opts.emplace_back(EDNSOptionCode::ECS, ecsOptionStr);
+ opts.emplace_back(EDNSOptionCode::COOKIE, cookiesOptionStr);
pw.addOpt(512, 0, 0, opts);
pw.commit();
PacketBuffer query;
GenericDNSPacketWriter<PacketBuffer> pw(query, qname, qtype, qclass, 0);
GenericDNSPacketWriter<PacketBuffer>::optvect_t opts;
- opts.push_back(make_pair(EDNSOptionCode::ECS, ecsOptionStr));
- opts.push_back(make_pair(65535, cookiesOptionStr));
+ opts.emplace_back(EDNSOptionCode::ECS, ecsOptionStr);
+ opts.emplace_back(65535, cookiesOptionStr);
pw.addOpt(512, 0, 0, opts);
pw.commit();
GenericDNSPacketWriter<PacketBuffer>::optvect_t ednsOptions;
EDNSSubnetOpts opt;
opt.source = Netmask("10.0.59.220/32");
- ednsOptions.push_back(std::make_pair(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt)));
+ ednsOptions.emplace_back(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt));
pwQ.addOpt(512, 0, 0, ednsOptions);
pwQ.commit();
GenericDNSPacketWriter<PacketBuffer>::optvect_t ednsOptions;
EDNSSubnetOpts opt;
opt.source = Netmask("10.0.167.48/32");
- ednsOptions.push_back(std::make_pair(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt)));
+ ednsOptions.emplace_back(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt));
pwQ.addOpt(512, 0, 0, ednsOptions);
pwQ.commit();
pwFQ.getHeader()->id = 0x42;
opt.source = Netmask("10." + std::to_string(idxA) + "." + std::to_string(idxB) + "." + std::to_string(idxC) + "/32");
ednsOptions.clear();
- ednsOptions.push_back(std::make_pair(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt)));
+ ednsOptions.emplace_back(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt));
pwFQ.addOpt(512, 0, 0, ednsOptions);
pwFQ.commit();
secondKey = pc.getKey(qname.toDNSString(), qname.wirelength(), secondQuery, false);
- auto pair = colMap.insert(std::make_pair(secondKey, opt.source));
+ auto pair = colMap.emplace(secondKey, opt.source);
total++;
if (!pair.second) {
collisions++;
DNSPacketWriter pw(pak, DNSName("www.powerdns.com"), QType::A);
pw.startRecord(DNSName("www.powerdns.com"), QType::A, 16, 1, DNSResourceRecord::ANSWER);
pw.xfrIP(htonl(0x7f000001));
- opts.push_back(pair<uint16_t,string>(3, "powerdns"));
+ opts.emplace_back(3, "powerdns");
pw.addOpt(1280, 0, 0, opts);
pw.getHeader()->id = htons(0xf001);
pw.getHeader()->rd = 1;
BOOST_AUTO_TEST_CASE(test_CIStringPairCompare) {
set<typedns_t, CIStringPairCompare> nsset2;
- nsset2.insert(make_pair("ns.example.com", 1));
- nsset2.insert(make_pair("abc", 1));
- nsset2.insert(make_pair("", 1));
- nsset2.insert(make_pair("def", 1));
- nsset2.insert(make_pair("abc", 2));
- nsset2.insert(make_pair("abc", 1));
- nsset2.insert(make_pair("ns.example.com", 0));
- nsset2.insert(make_pair("abc", 2));
- nsset2.insert(make_pair("ABC", 2));
+ nsset2.emplace("ns.example.com", 1);
+ nsset2.emplace("abc", 1);
+ nsset2.emplace("", 1);
+ nsset2.emplace("def", 1);
+ nsset2.emplace("abc", 2);
+ nsset2.emplace("abc", 1);
+ nsset2.emplace("ns.example.com", 0);
+ nsset2.emplace("abc", 2);
+ nsset2.emplace("ABC", 2);
BOOST_CHECK_EQUAL(nsset2.size(), 6U);
ostringstream s;
{
ecsOpts.source = Netmask(ComboAddress("192.0.2.1"), 32);
- opts.push_back(make_pair(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(ecsOpts)));
+ opts.emplace_back(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(ecsOpts));
DNSPacketWriter pw(pak, DNSName("www.powerdns.com"), QType::A);
pw.addOpt(512, 0, 0, opts);
pw.commit();
{
DNSPacketWriter pw(pak, DNSName("www.powerdns.com"), QType::A);
ecsOpts.source = Netmask(ComboAddress("192.0.2.2"), 32);
- opts.push_back(make_pair(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(ecsOpts)));
+ opts.emplace_back(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(ecsOpts));
pw.addOpt(512, 0, 0, opts);
pw.commit();
ecs2.parse((char*)&pak[0], pak.size());
{
DNSPacketWriter pw(pak, DNSName("www.powerdns.com"), QType::A);
ecsOpts.source = Netmask(ComboAddress("192.0.2.3"), 16);
- opts.push_back(make_pair(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(ecsOpts)));
+ opts.emplace_back(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(ecsOpts));
pw.addOpt(512, 0, 0, opts);
pw.commit();
ecs3.parse((char*)&pak[0], pak.size());
pw1.getHeader()->id = 0x42;
opt.source = Netmask("10.0.152.74/32");
ednsOptions.clear();
- ednsOptions.push_back(std::make_pair(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt)));
+ ednsOptions.emplace_back(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt));
pw1.addOpt(512, 0, 0, ednsOptions);
pw1.commit();
pw2.getHeader()->id = 0x84;
opt.source = Netmask("10.2.70.250/32");
ednsOptions.clear();
- ednsOptions.push_back(std::make_pair(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt)));
+ ednsOptions.emplace_back(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt));
pw2.addOpt(512, 0, 0, ednsOptions);
pw2.commit();
pwFQ.getHeader()->id = 0x42;
opt.source = Netmask("10." + std::to_string(idxA) + "." + std::to_string(idxB) + "." + std::to_string(idxC) + "/32");
ednsOptions.clear();
- ednsOptions.push_back(std::make_pair(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt)));
+ ednsOptions.emplace_back(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt));
pwFQ.addOpt(512, 0, 0, ednsOptions);
pwFQ.commit();
auto secondKey = PacketCache::canHashPacket(std::string(reinterpret_cast<const char *>(secondQuery.data()), secondQuery.size()), optionsToSkip);
- auto pair = colMap.insert(std::make_pair(secondKey, opt.source));
+ auto pair = colMap.emplace(secondKey, opt.source);
total++;
if (!pair.second) {
collisions++;
pw1.getHeader()->id = 0x42;
opt.source = Netmask("10.0.34.159/32");
ednsOptions.clear();
- ednsOptions.push_back(std::make_pair(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt)));
+ ednsOptions.emplace_back(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt));
pw1.addOpt(512, 0, EDNSOpts::DNSSECOK, ednsOptions);
pw1.commit();
pw2.getHeader()->id = 0x84;
opt.source = Netmask("10.0.179.58/32");
ednsOptions.clear();
- ednsOptions.push_back(std::make_pair(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt)));
+ ednsOptions.emplace_back(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt));
/* no EDNSOpts::DNSSECOK !! */
pw2.addOpt(512, 0, 0, ednsOptions);
pw2.commit();
pw1.getHeader()->id = 0x42;
opt.source = Netmask("192.0.2.1/32");
ednsOptions.clear();
- ednsOptions.push_back(std::make_pair(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt)));
+ ednsOptions.emplace_back(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt));
EDNSCookiesOpt cookiesOpt(string("deadbeefdeadbeef"));
- ednsOptions.push_back(std::make_pair(EDNSOptionCode::COOKIE, cookiesOpt.makeOptString()));
+ ednsOptions.emplace_back(EDNSOptionCode::COOKIE, cookiesOpt.makeOptString());
pw1.addOpt(512, 0, EDNSOpts::DNSSECOK, ednsOptions);
pw1.commit();
pw2.getHeader()->id = 0x84;
opt.source = Netmask("192.0.2.1/32");
ednsOptions.clear();
- ednsOptions.push_back(std::make_pair(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt)));
+ ednsOptions.emplace_back(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt));
cookiesOpt.makeFromString(string("deadbeefbadc0fee"));
- ednsOptions.push_back(std::make_pair(EDNSOptionCode::COOKIE, cookiesOpt.makeOptString()));
+ ednsOptions.emplace_back(EDNSOptionCode::COOKIE, cookiesOpt.makeOptString());
pw2.addOpt(512, 0, EDNSOpts::DNSSECOK, ednsOptions);
pw2.commit();
pwFQ.getHeader()->id = 0x42;
opt.source = Netmask("10." + std::to_string(idxA) + "." + std::to_string(idxB) + "." + std::to_string(idxC) + "/32");
ednsOptions.clear();
- ednsOptions.push_back(std::make_pair(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt)));
+ ednsOptions.emplace_back(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt));
pwFQ.addOpt(512, 0, 32768, ednsOptions);
pwFQ.commit();
auto secondKey = PacketCache::canHashPacket(std::string(reinterpret_cast<const char *>(secondQuery.data()), secondQuery.size()), optionsToSkip);
- colMap.insert(std::make_pair(secondKey, opt.source));
+ colMap.emplace(secondKey, opt.source);
secondQuery.clear();
DNSPacketWriter pwSQ(secondQuery, qname, QType::AAAA, QClass::IN, 0);
pwSQ.getHeader()->id = 0x42;
opt.source = Netmask("10." + std::to_string(idxA) + "." + std::to_string(idxB) + "." + std::to_string(idxC) + "/32");
ednsOptions.clear();
- ednsOptions.push_back(std::make_pair(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt)));
+ ednsOptions.emplace_back(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt));
pwSQ.addOpt(512, 0, 0, ednsOptions);
pwSQ.commit();
secondKey = PacketCache::canHashPacket(std::string(reinterpret_cast<const char *>(secondQuery.data()), secondQuery.size()), optionsToSkip);
pw1.getHeader()->id = 0x42;
opt.source = Netmask("10.0.18.199/32");
ednsOptions.clear();
- ednsOptions.push_back(std::make_pair(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt)));
+ ednsOptions.emplace_back(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt));
pw1.addOpt(512, 0, 0, ednsOptions);
pw1.commit();
pw2.getHeader()->id = 0x84;
opt.source = Netmask("10.0.131.66/32");
ednsOptions.clear();
- ednsOptions.push_back(std::make_pair(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt)));
+ ednsOptions.emplace_back(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt));
pw2.addOpt(512, 0, 0, ednsOptions);
pw2.commit();
pw1.getHeader()->id = 0x42;
opt.source = Netmask("192.0.2.1/32");
ednsOptions.clear();
- ednsOptions.push_back(std::make_pair(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt)));
+ ednsOptions.emplace_back(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt));
EDNSCookiesOpt cookiesOpt(string("deadbeefdead\x11\xee\x00\x00").c_str(), 16);
- ednsOptions.push_back(std::make_pair(EDNSOptionCode::COOKIE, cookiesOpt.makeOptString()));
+ ednsOptions.emplace_back(EDNSOptionCode::COOKIE, cookiesOpt.makeOptString());
pw1.addOpt(512, 0, EDNSOpts::DNSSECOK, ednsOptions);
pw1.commit();
pw2.getHeader()->id = 0x84;
opt.source = Netmask("192.0.2.1/32");
ednsOptions.clear();
- ednsOptions.push_back(std::make_pair(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt)));
+ ednsOptions.emplace_back(EDNSOptionCode::ECS, makeEDNSSubnetOptsString(opt));
cookiesOpt.makeFromString(string("deadbeefdead\x67\x44\x00\x00").c_str(), 16);
- ednsOptions.push_back(std::make_pair(EDNSOptionCode::COOKIE, cookiesOpt.makeOptString()));
+ ednsOptions.emplace_back(EDNSOptionCode::COOKIE, cookiesOpt.makeOptString());
pw2.addOpt(512, 0, EDNSOpts::DNSSECOK, ednsOptions);
pw2.commit();
cerr<<"got rrsig "<<sig->d_signer<<"/"<<sig->d_tag<<endl;
vState state = getKeysFor(tro, sig->d_signer, keys);
cerr<<"! state = "<<state<<", now have "<<keys.size()<<" keys at "<<qname<<endl;
- // dsmap.insert(make_pair(dsrc.d_tag, dsrc));
+ // dsmap.emplace(dsrc.d_tag, dsrc);
}
}
vector<DomainInfo> zones;
(*i)->getAllDomains(&zones, false, true);
for(auto& di: zones) {
- zone_indices.push_back({std::move(di.zone), (int)di.id}); // this cast should not be necessary
+ zone_indices.emplace_back(std::move(di.zone), (int)di.id); // this cast should not be necessary
}
}
g_zoneCache.replace(zone_indices);
auto stats = getAllStatsMap(StatComponent::API);
map<string,string> ret;
for (const auto& entry: stats) {
- ret.insert(make_pair(entry.first, entry.second.d_value));
+ ret.emplace(entry.first, entry.second.d_value);
}
out.swap(ret);
}
rcounts_t rcounts;
for(counts_t::const_iterator i=counts.begin(); i != counts.end(); ++i)
- rcounts.insert(make_pair(-i->second, i->first));
+ rcounts.emplace(-i->second, i->first);
Json::array entries;
unsigned int tot=0, totIncluded=0;
rcounts_t rcounts;
for(counts_t::const_iterator i=counts.begin(); i != counts.end(); ++i)
- rcounts.insert(make_pair(-i->second, i->first));
+ rcounts.emplace(-i->second, i->first);
Json::array entries;
unsigned int tot=0, totIncluded=0;
projects / thirdparty / pdns.git / commitdiff
