void GOSTDNSCryptoKeyEngine::fromISCMap(DNSKEYRecordContent& drc, std::map<std::string, std::string>& stormap )
{
- drc.d_algorithm = atoi(stormap["algorithm"].c_str());
+ drc.d_algorithm = pdns_stou(stormap["algorithm"]);
string privateKey=stormap["gostasn1"];
//cerr<<"PrivateKey.size() = "<<privateKey.size()<<endl;
//cerr<<makeHexDump(string(privateKey.c_str(), 39))<<endl;
else if(algorithm == 14)
return EC_Domain_Params("1.3.132.0.34");
else
- throw runtime_error("Requested for unknown EC domain parameters for algorithm "+lexical_cast<string>(algorithm));
+ throw runtime_error("Requested for unknown EC domain parameters for algorithm "+to_string(algorithm));
}
void ECDSADNSCryptoKeyEngine::create(unsigned int bits)
params = getECParams(14);
}
else {
- throw runtime_error("Unknown key length of "+lexical_cast<string>(bits)+" bits requested from ECDSA class");
+ throw runtime_error("Unknown key length of "+to_string(bits)+" bits requested from ECDSA class");
}
d_key = shared_ptr<ECDSA_PrivateKey>(new ECDSA_PrivateKey(rng, params));
}
Algorithm: 13 (ECDSAP256SHA256)
PrivateKey: GU6SnQ/Ou+xC5RumuIUIuJZteXT2z0O/ok1s38Et6mQ= */
- drc.d_algorithm = atoi(stormap["algorithm"].c_str());
+ drc.d_algorithm = pdns_stou(stormap["algorithm"]);
if(drc.d_algorithm != d_algorithm)
- throw runtime_error("Tried to feed an algorithm "+lexical_cast<string>(drc.d_algorithm)+" to a "+lexical_cast<string>(d_algorithm)+" key!");
+ throw runtime_error("Tried to feed an algorithm "+to_string(drc.d_algorithm)+" to a "+to_string(d_algorithm)+" key!");
string privateKey=stormap["privatekey"];
BigInt bigint((byte*)privateKey.c_str(), privateKey.length());
DNSCryptoKeyEngine::storvector_t BotanRSADNSCryptoKeyEngine::convertToISCVector() const
{
storvector_t storvect;
- string algorithm = lexical_cast<string>(d_algorithm);
+ string algorithm = std::to_string(d_algorithm);
if(d_algorithm == 5 || d_algorithm ==7 )
algorithm += " (RSASHA1)";
else if(d_algorithm == 8)
e=fromRaw(stormap["publicexponent"]);
n=fromRaw(stormap["modulus"]);
- drc.d_algorithm = atoi(stormap["algorithm"].c_str());
+ drc.d_algorithm = pdns_stou(stormap["algorithm"]);
if(drc.d_algorithm != d_algorithm)
throw runtime_error("Unpossible, loaded a key from storage with wrong algorithm!");
#include "dns.hh"
#include "arguments.hh"
#include "packetcache.hh"
-#include <boost/lexical_cast.hpp>
// #include "namespaces.hh"
template<class HASHER, class CURVE, int BITS> void CryptoPPECDSADNSCryptoKeyEngine<HASHER,CURVE,BITS>::create(unsigned int bits)
{
if(bits != BITS)
- throw runtime_error("This CryptoPP class can only hosts keys of length "+lexical_cast<string>(BITS));
+ throw runtime_error("This CryptoPP class can only hosts keys of length "+to_string(BITS));
AutoSeededRandomPool prng;
privatekey_t* privateKey = new privatekey_t();
CryptoPP::OID oid=CURVE();
{
/* Algorithm: 13 (ECDSAP256SHA256)
PrivateKey: GU6SnQ/Ou+xC5RumuIUIuJZteXT2z0O/ok1s38Et6mQ= */
- string algostr=lexical_cast<string>(d_algorithm);
+ string algostr=to_string(d_algorithm);
if(d_algorithm==13)
algostr+=" (ECDSAP256SHA256)";
else if(d_algorithm==14)
publickey_t* publicKey = new publickey_t();
d_key->MakePublicKey(*publicKey);
d_pubkey = shared_ptr<publickey_t>(publicKey);
- drc.d_algorithm = atoi(stormap["algorithm"].c_str());
+ drc.d_algorithm = pdns_stou(stormap["algorithm"]);
}
template<class HASHER, class CURVE, int BITS>
else if(algorithm == 14) // ECDSAP384SHA384
bits = 384;
else {
- throw runtime_error("Can't guess key size for algorithm "+lexical_cast<string>(algorithm));
+ throw runtime_error("Can't guess key size for algorithm "+std::to_string(algorithm));
}
}
}
return dpk;
}
- throw runtime_error("Can't find a key with id "+lexical_cast<string>(id)+" for zone '"+zname.toString()+"'");
+ throw runtime_error("Can't find a key with id "+std::to_string(id)+" for zone '"+zname.toString()+"'");
}
#include <iostream>
#include <unistd.h>
#include "misc.hh"
-#include <boost/lexical_cast.hpp>
#include "syncres.hh"
#include "namespaces.hh"
void DevPollFDMultiplexer::removeFD(callbackmap_t& cbmap, int fd)
{
if(!cbmap.erase(fd))
- throw FDMultiplexerException("Tried to remove unlisted fd "+lexical_cast<string>(fd)+ " from multiplexer");
+ throw FDMultiplexerException("Tried to remove unlisted fd "+std::to_string(fd)+ " from multiplexer");
struct pollfd devent;
devent.fd=fd;
#include <stdexcept>
#include <iostream>
#include <boost/algorithm/string.hpp>
-#include <boost/lexical_cast.hpp>
#include <boost/assign/list_of.hpp>
#include "dnsparser.hh"
std::string RCode::to_s(unsigned short rcode) {
if (rcode > RCode::rcodes_s.size()-1 )
- return std::string("Err#")+boost::lexical_cast<std::string>(rcode);
+ return std::string("Err#")+std::to_string(rcode);
return RCode::rcodes_s[rcode];
}
{
if(offset < d_length)
return d_ptr[offset];
- throw runtime_error("out of bounds: "+boost::lexical_cast<string>(offset)+" >= " + boost::lexical_cast<string>(d_length));
+ throw runtime_error("out of bounds: "+std::to_string(offset)+" >= " + std::to_string(d_length));
}
private:
const char* d_ptr;
if(pleft>1)
data.hostmaster=DNSName(attodot(parts[1])); // ahu@ds9a.nl -> ahu.ds9a.nl, piet.puk@ds9a.nl -> piet\.puk.ds9a.nl
- data.serial = pleft > 2 ? pdns_strtoui(parts[2].c_str(), NULL, 10) : 0;
+ data.serial = pleft > 2 ? pdns_stou(parts[2]) : 0;
if (data.serial == UINT_MAX && errno == ERANGE) throw PDNSException("serial number too large in '"+parts[2]+"'");
- data.refresh = pleft > 3 ? atoi(parts[3].c_str())
+ data.refresh = pleft > 3 ? pdns_stou(parts[3])
: ::arg().asNum("soa-refresh-default");
- data.retry = pleft > 4 ? atoi(parts[4].c_str())
+ data.retry = pleft > 4 ? pdns_stou(parts[4].c_str())
: ::arg().asNum("soa-retry-default");
- data.expire = pleft > 5 ? atoi(parts[5].c_str())
+ data.expire = pleft > 5 ? pdns_stou(parts[5].c_str())
: ::arg().asNum("soa-expire-default");
- data.default_ttl = pleft > 6 ?atoi(parts[6].c_str())
+ data.default_ttl = pleft > 6 ? pdns_stou(parts[6].c_str())
: ::arg().asNum("soa-minimum-ttl");
}
}
if(vars.count("qps")) {
- int qps=boost::lexical_cast<int>(boost::get<string>(vars["qps"]));
+ int qps=std::stoi(boost::get<string>(vars["qps"]));
ret->qps=QPSLimiter(qps, qps);
}
}
if(vars.count("order")) {
- ret->order=boost::lexical_cast<int>(boost::get<string>(vars["order"]));
+ ret->order=std::stoi(boost::get<string>(vars["order"]));
}
if(vars.count("weight")) {
- ret->weight=boost::lexical_cast<int>(boost::get<string>(vars["weight"]));
+ ret->weight=std::stoi(boost::get<string>(vars["weight"]));
}
if(vars.count("retries")) {
- ret->retries=boost::lexical_cast<int>(boost::get<string>(vars["retries"]));
+ ret->retries=std::stoi(boost::get<string>(vars["retries"]));
}
if(vars.count("tcpSendTimeout")) {
- ret->tcpSendTimeout=boost::lexical_cast<int>(boost::get<string>(vars["tcpSendTimeout"]));
+ ret->tcpSendTimeout=std::stoi(boost::get<string>(vars["tcpSendTimeout"]));
}
if(vars.count("tcpRecvTimeout")) {
- ret->tcpRecvTimeout=boost::lexical_cast<int>(boost::get<string>(vars["tcpRecvTimeout"]));
+ ret->tcpRecvTimeout=std::stoi(boost::get<string>(vars["tcpRecvTimeout"]));
}
if(vars.count("name")) {
break;
case DNSAction::Action::Delay:
- delayMsec = atoi(ruleresult.c_str()); // sorry
+ delayMsec = static_cast<int>(pdns_stou(ruleresult)); // sorry
break;
case DNSAction::Action::Allow:
case DNSAction::Action::None:
#include "dnsparser.hh"
#include "dnswriter.hh"
-#include <boost/lexical_cast.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/format.hpp>
vector<string> parts;
stringtok(parts, zone);
if(parts.size()!=3 && !(parts.size()==2 && equals(parts[1],"0")) )
- throw MOADNSException("Unknown record was stored incorrectly, need 3 fields, got "+lexical_cast<string>(parts.size())+": "+zone );
+ throw MOADNSException("Unknown record was stored incorrectly, need 3 fields, got "+std::to_string(parts.size())+": "+zone );
const string& relevant=(parts.size() > 2) ? parts[2] : "";
- unsigned int total=atoi(parts[1].c_str());
+ unsigned int total=pdns_stou(parts[1]);
if(relevant.size()!=2*total)
throw MOADNSException((boost::format("invalid unknown record length for label %s: size not equal to length field (%d != %d)") % d_dr.d_name.toString() % relevant.size() % (2*total)).str());
string out;
memcpy(&d_header, packet, sizeof(dnsheader));
if(d_header.opcode != Opcode::Query && d_header.opcode != Opcode::Notify && d_header.opcode != Opcode::Update)
- throw MOADNSException("Can't parse non-query packet with opcode="+ lexical_cast<string>(d_header.opcode));
+ throw MOADNSException("Can't parse non-query packet with opcode="+ std::to_string(d_header.opcode));
d_header.qdcount=ntohs(d_header.qdcount);
d_header.ancount=ntohs(d_header.ancount);
#if 0
if(pr.d_pos!=contentlen) {
- throw MOADNSException("Packet ("+d_qname+"|#"+lexical_cast<string>(d_qtype)+") has trailing garbage ("+ lexical_cast<string>(pr.d_pos) + " < " +
- lexical_cast<string>(contentlen) + ")");
+ throw MOADNSException("Packet ("+d_qname+"|#"+std::to_string(d_qtype)+") has trailing garbage ("+ std::to_string(pr.d_pos) + " < " +
+ std::to_string(contentlen) + ")");
}
#endif
}
}
}
else {
- throw MOADNSException("Error parsing packet of "+lexical_cast<string>(len)+" bytes (rd="+
- lexical_cast<string>(d_header.rd)+
+ throw MOADNSException("Error parsing packet of "+std::to_string(len)+" bytes (rd="+
+ std::to_string(d_header.rd)+
"), out of bounds: "+string(re.what()));
}
}
{
d_notyouroffset += by;
if(d_notyouroffset > d_packet.length())
- throw std::out_of_range("dns packet out of range: "+lexical_cast<string>(d_notyouroffset) +" > "
- + lexical_cast<string>(d_packet.length()) );
+ throw std::out_of_range("dns packet out of range: "+std::to_string(d_notyouroffset) +" > "
+ + std::to_string(d_packet.length()) );
}
std::string& d_packet;
// #include <netinet/in.h>
#include "misc.hh"
-#include <boost/lexical_cast.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/tuple/tuple_comparison.hpp>
#include "dns.hh"
return iter->second.second;
if(boost::starts_with(name, "TYPE"))
- return atoi(name.c_str()+4);
+ return pdns_stou(name.substr(4));
throw runtime_error("Unknown DNS type '"+name+"'");
}
{
t2namemap_t::const_iterator iter = getT2Namemap().find(make_pair(classnum, num));
if(iter == getT2Namemap().end())
- return "TYPE" + lexical_cast<string>(num);
- // throw runtime_error("Unknown DNS type with numerical id "+lexical_cast<string>(num));
+ return "TYPE" + std::to_string(num);
+ // throw runtime_error("Unknown DNS type with numerical id "+std::to_string(num));
return iter->second;
}
void ARecordContent::doRecordCheck(const DNSRecord& dr)
{
if(dr.d_clen!=4)
- throw MOADNSException("Wrong size for A record ("+lexical_cast<string>(dr.d_clen)+")");
+ throw MOADNSException("Wrong size for A record ("+std::to_string(dr.d_clen)+")");
}
boilerplate_conv(AAAA, QType::AAAA, conv.xfrIP6(d_ip6); );
#include "dnsparser.hh"
#include "dnswriter.hh"
#include "rcpgenerator.hh"
-#include <boost/lexical_cast.hpp>
#include <set>
#include <bitset>
#include "namespaces.hh"
tie(key,value)=splitField(sline, ':');
trim(value);
if(pdns_iequals(key,"algorithm")) {
- algorithm = atoi(value.c_str());
- stormap["algorithm"]=lexical_cast<string>(algorithm);
+ algorithm = pdns_stou(value);
+ stormap["algorithm"]=std::to_string(algorithm);
continue;
} else if (pdns_iequals(key,"pin")) {
stormap["pin"]=value;
if(iter != makers.end())
return (iter->second)(algo);
else {
- throw runtime_error("Request to create key object for unknown algorithm number "+lexical_cast<string>(algo));
+ throw runtime_error("Request to create key object for unknown algorithm number "+std::to_string(algo));
}
}
else if(algo == 14) // ECDSAP384SHA384
bits = 384;
else
- throw runtime_error("Can't guess key size for algorithm "+lexical_cast<string>(algo));
+ throw runtime_error("Can't guess key size for algorithm "+std::to_string(algo));
dckeCreate->create(bits);
tie(key,value)=splitField(sline, ':');
trim(value);
if(pdns_iequals(key,"algorithm")) {
- algorithm = atoi(value.c_str());
- stormap["algorithm"]=lexical_cast<string>(algorithm);
+ algorithm = pdns_stou(value);
+ stormap["algorithm"]=std::to_string(algorithm);
continue;
} else if (pdns_iequals(key,"pin")) {
stormap["pin"]=value;
stormap["engine"]=value;
continue;
} else if (pdns_iequals(key,"slot")) {
- int slot = atoi(value.c_str());
- stormap["slot"]=lexical_cast<string>(slot);
+ int slot = std::stoi(value);
+ stormap["slot"]=std::to_string(slot);
continue;
} else if (pdns_iequals(key,"label")) {
stormap["label"]=value;
dsrc.d_digest = dpk->hash(toHash);
}
else
- throw std::runtime_error("Asked to a DS of unknown digest type " + lexical_cast<string>(digest)+"\n");
+ throw std::runtime_error("Asked to a DS of unknown digest type " + std::to_string(digest)+"\n");
dsrc.d_algorithm= drc.d_algorithm;
dsrc.d_digesttype=digest;
for(;;) {
uint8_t kind = de.getByte();
if(kind != 0x02)
- throw runtime_error("DER Sequence contained non-INTEGER component: "+lexical_cast<string>((unsigned int)kind) );
+ throw runtime_error("DER Sequence contained non-INTEGER component: "+std::to_string(static_cast<unsigned int>(kind)) );
len = de.getLength();
ret = de.getBytes(len);
output.push_back(ret);
return "PKCS#11 support not compiled in";
#else
if (parts.size() != 4) {
- return "invalid number of parameters, needs 4, got " + boost::lexical_cast<string>(parts.size());
+ return "invalid number of parameters, needs 4, got " + std::to_string(parts.size());
}
if (PKCS11ModuleSlotLogin(parts[1], parts[2], parts[3])) {
else {
uint16_t port;
try {
- port = lexical_cast<uint16_t>(::arg()["remote-port"]);
+ port = static_cast<uint16_t>(pdns_stou(::arg()["remote-port"]));
}
catch(...) {
cerr<<"Unable to convert '"<<::arg()["remote-port"]<<"' to a port number for connecting to remote PowerDNS\n";
#include <iostream>
#include <unistd.h>
#include "misc.hh"
-#include <boost/lexical_cast.hpp>
#include "syncres.hh"
#ifdef __linux__
#include <sys/epoll.h>
void EpollFDMultiplexer::removeFD(callbackmap_t& cbmap, int fd)
{
if(!cbmap.erase(fd))
- throw FDMultiplexerException("Tried to remove unlisted fd "+lexical_cast<string>(fd)+ " from multiplexer");
+ throw FDMultiplexerException("Tried to remove unlisted fd "+std::to_string(fd)+ " from multiplexer");
struct epoll_event dummy;
dummy.events = 0;
buffer.value = (void*)name.c_str();
maj = gss_import_name(&min, &buffer, (gss_OID)GSS_KRB5_NT_PRINCIPAL_NAME, &comp);
if (maj != GSS_S_COMPLETE)
- throw PDNSException("Could not import " + name + ": " + boost::lexical_cast<std::string>(maj) + string(",") + boost::lexical_cast<std::string>(min));
+ throw PDNSException("Could not import " + name + ": " + std::to_string(maj) + string(",") + std::to_string(min));
// do comparison
maj = gss_compare_name(&min, d_name, comp, &result);
gss_release_name(&min, &comp);
#include "misc.hh"
#include <sys/socket.h>
#include <netdb.h>
-
+#include <sstream>
#include <boost/tuple/tuple.hpp>
#include <boost/tuple/tuple_comparison.hpp>
-#include <boost/lexical_cast.hpp>
#include "namespaces.hh"
string toStringWithPort() const
{
if(sin4.sin_family==AF_INET)
- return toString() + ":" + boost::lexical_cast<string>(ntohs(sin4.sin_port));
+ return toString() + ":" + std::to_string(ntohs(sin4.sin_port));
else
- return "["+toString() + "]:" + boost::lexical_cast<string>(ntohs(sin4.sin_port));
+ return "["+toString() + "]:" + std::to_string(ntohs(sin4.sin_port));
}
void truncate(unsigned int bits);
d_network=makeComboAddress(split.first);
if(!split.second.empty()) {
- d_bits = lexical_cast<unsigned int>(split.second);
+ d_bits = pdns_stou(split.second);
if(d_bits<32)
d_mask=~(0xFFFFFFFF>>d_bits);
else
string toString() const
{
- return d_network.toString()+"/"+boost::lexical_cast<string>((unsigned int)d_bits);
+ return d_network.toString()+"/"+std::to_string((unsigned int)d_bits);
}
string toStringNoMask() const
if (val.IsInt()) {
return val.GetInt();
} else if (val.IsString()) {
- return atoi(val.GetString());
+ return std::stoi(val.GetString());
} else {
throw JsonException("Key '" + string(key) + "' not an Integer or not present");
}
if (val.IsInt()) {
return val.GetInt();
} else if (val.IsString()) {
- return atoi(val.GetString());
+ return std::stoi(val.GetString());
} else {
// TODO: check if value really isn't present
return default_value;
#include <iostream>
#include <unistd.h>
#include "misc.hh"
-#include <boost/lexical_cast.hpp>
#include "syncres.hh"
#include <sys/types.h>
#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
if(pos == string::npos || pos + 2 > addr.size() || addr[pos+1]!=':')
return -1;
ourAddr.assign(addr.c_str() + 1, pos-1);
- port = atoi(addr.c_str()+pos+2);
+ port = pdns_stou(addr.substr(pos+2));
}
ret->sin6_scope_id=0;
ret->sin6_family=AF_INET6;
string newquery;
for(int n = 0; n < 4; ++n) {
newquery +=
- lexical_cast<string>(strtol(parts[n*2].c_str(), 0, 16) + 16*strtol(parts[n*2+1].c_str(), 0, 16));
+ std::to_string(std::stol(parts[n*2], 0, 16) + 16*std::stol(parts[n*2+1], 0, 16));
newquery.append(1,'.');
}
newquery += "in-addr.arpa.";
#include "dns.hh"
#include "arguments.hh"
#include "packetcache.hh"
-#include <boost/lexical_cast.hpp>
#include "namespaces.hh"
mbedtls_sha512((unsigned char*)toHash.c_str(), toHash.length(), hash, 0);
return string((char*)hash, sizeof(hash));
}
- throw runtime_error("mbed TLS hashing method can't hash algorithm "+lexical_cast<string>(d_algorithm));
+ throw runtime_error("mbed TLS hashing method can't hash algorithm "+std::to_string(d_algorithm));
}
("Exponent2",&d_context.DQ)
("Coefficient",&d_context.QP);
- string algorithm=lexical_cast<string>(d_algorithm);
+ string algorithm=std::to_string(d_algorithm);
switch(d_algorithm) {
case 5:
case 7 :
places["Exponent2"]=&d_context.DQ;
places["Coefficient"]=&d_context.QP;
- drc.d_algorithm = atoi(stormap["algorithm"].c_str());
+ drc.d_algorithm = pdns_stou(stormap["algorithm"]);
string raw;
for(const places_t::value_type& val : places) {
throw PDNSException("Unable to parse '"+descr+"' as a service");
st.host=parts[0];
if(parts.size()>1)
- st.port=atoi(parts[1].c_str());
+ st.port=pdns_stou(parts[1]);
}
static void parseService6(const string &descr, ServiceTuple &st)
st.host=descr.substr(1, pos-1);
if(pos + 2 < descr.length())
- st.port=atoi(descr.c_str() + pos +2);
+ st.port=pdns_stou(descr.substr(pos+2));
}
if(pos == string::npos || pos + 2 > addr.size() || addr[pos+1]!=':')
return -1;
ourAddr.assign(addr.c_str() + 1, pos-1);
- port = atoi(addr.c_str()+pos+2);
+ port = pdns_stou(addr.substr(pos+2));
}
ret->sin6_scope_id=0;
ret->sin6_family=AF_INET6;
if(parts.size() < 7)
break;
if(str=="udp-rcvbuf-errors")
- return boost::lexical_cast<uint64_t>(parts[5]);
+ return std::stoull(parts[5]);
else if(str=="udp-sndbuf-errors")
- return boost::lexical_cast<uint64_t>(parts[6]);
+ return std::stoull(parts[6]);
else if(str=="udp-noport-errors")
- return boost::lexical_cast<uint64_t>(parts[2]);
+ return std::stoull(parts[2]);
else if(str=="udp-in-errors")
- return boost::lexical_cast<uint64_t>(parts[3]);
+ return std::stoull(parts[3]);
else
return 0;
}
struct dirent *entry;
int ret=0;
while((entry = readdir(dirhdl))) {
- uint32_t num = atoi(entry->d_name);
+ uint32_t num;
+ try {
+ num = pdns_stou(entry->d_name);
+ } catch (...) {
+ continue; // was not a number.
+ }
if(std::to_string(num) == entry->d_name)
ret++;
}
string header("Private_Dirty:");
while(getline(ifs, line)) {
if(boost::starts_with(line, header)) {
- bytes += atoi(line.c_str() + header.length() +1)*1024;
+ bytes += std::stoull(line.substr(header.length() + 1))*1024;
}
}
return bytes;
return result;
}
-unsigned int pdns_stou(const std::string& str, size_t * idx, int base);
+unsigned int pdns_stou(const std::string& str, size_t * idx, int base)
{
if (str.empty()) return 0; // compability
unsigned long result = std::stoul(str, idx, base);
#include <boost/shared_array.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/tuple/tuple_comparison.hpp>
-#include <boost/lexical_cast.hpp>
#include <vector>
#include <map>
#include <stdexcept>
virtual funcparam_t& getReadParameter(int fd)
{
if(!d_readCallbacks.count(fd))
- throw FDMultiplexerException("attempt to look up data in multiplexer for unlisted fd "+boost::lexical_cast<std::string>(fd));
+ throw FDMultiplexerException("attempt to look up data in multiplexer for unlisted fd "+std::to_string(fd));
return d_readCallbacks[fd].d_parameter;
}
memset(&cb.d_ttd, 0, sizeof(cb.d_ttd));
if(cbmap.count(fd))
- throw FDMultiplexerException("Tried to add fd "+boost::lexical_cast<std::string>(fd)+ " to multiplexer twice");
+ throw FDMultiplexerException("Tried to add fd "+std::to_string(fd)+ " to multiplexer twice");
cbmap[fd]=cb;
}
void accountingRemoveFD(callbackmap_t& cbmap, int fd)
{
if(!cbmap.erase(fd))
- throw FDMultiplexerException("Tried to remove unlisted fd "+boost::lexical_cast<std::string>(fd)+ " from multiplexer");
+ throw FDMultiplexerException("Tried to remove unlisted fd "+std::to_string(fd)+ " from multiplexer");
}
};
#ifndef PDNS_NAMESPACES_HH
#define PDNS_NAMESPACES_HH
-#include <boost/lexical_cast.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/shared_array.hpp>
using std::max;
using std::string;
-using boost::lexical_cast;
using boost::tie;
using std::shared_ptr;
using std::unique_ptr;
if(g_vm.count("setgid")) {
if(setgid(g_vm["setgid"].as<int>()) < 0)
- throw runtime_error("while changing gid to "+boost::lexical_cast<std::string>(g_vm["setgid"].as<int>()));
+ throw runtime_error("while changing gid to "+std::to_string(g_vm["setgid"].as<int>()));
syslogFmt(boost::format("Changed gid to %d") % g_vm["setgid"].as<int>());
if(setgroups(0, NULL) < 0)
throw runtime_error("while dropping supplementary groups");
if(g_vm.count("setuid")) {
if(setuid(g_vm["setuid"].as<int>()) < 0)
- throw runtime_error("while changing uid to "+boost::lexical_cast<std::string>(g_vm["setuid"].as<int>()));
+ throw runtime_error("while changing uid to "+std::to_string(g_vm["setuid"].as<int>()));
syslogFmt(boost::format("Changed uid to %d") % g_vm["setuid"].as<int>());
}
continue;
}
for(auto const &digestAlgo : digestAlgos){
- rr.content=makeDSFromDNSKey(p->qdomain, value.first.getDNSKEY(), lexical_cast<int>(digestAlgo)).getZoneRepresentation();
+ rr.content=makeDSFromDNSKey(p->qdomain, value.first.getDNSKEY(), std::stoi(digestAlgo)).getZoneRepresentation();
r->addRecord(rr);
haveOne=true;
}
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
-#include <boost/lexical_cast.hpp>
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/tuple/tuple_comparison.hpp>
int main()
{
ostringstream str;
- str << "Everything is ok!"<< boost::lexical_cast<string>("") <<"\n";
+ str << "Everything is ok!"<<"\n"; // FIXME400: boost test?
exit(0);
}
#include <boost/tuple/tuple.hpp>
#include <boost/tuple/tuple_comparison.hpp>
#include <boost/shared_array.hpp>
-#include <boost/lexical_cast.hpp>
#include <boost/function.hpp>
#include <boost/algorithm/string.hpp>
#ifdef MALLOC_TRACE
{
socks_t::iterator i=d_socks.find(fd);
if(i==d_socks.end()) {
- throw PDNSException("Trying to return a socket (fd="+lexical_cast<string>(fd)+") not in the pool");
+ throw PDNSException("Trying to return a socket (fd="+std::to_string(fd)+") not in the pool");
}
returnSocketLocked(i);
}
return ret;
if(ret<0)
- throw PDNSException("Making a socket for resolver (family = "+lexical_cast<string>(family)+"): "+stringerror());
+ throw PDNSException("Making a socket for resolver (family = "+std::to_string(family)+"): "+stringerror());
setCloseOnExec(ret);
{
string sockname=::arg()["socket-dir"]+"/"+s_programname;
if(processNum >= 0)
- sockname += "."+lexical_cast<string>(processNum);
+ sockname += "."+std::to_string(processNum);
sockname+=".controlsocket";
s_rcc.listen(sockname);
int socklen=sin.sin4.sin_family==AF_INET ? sizeof(sin.sin4) : sizeof(sin.sin6);
if (::bind(fd, (struct sockaddr *)&sin, socklen)<0)
- throw PDNSException("Resolver binding to server socket on port "+ lexical_cast<string>(st.port) +" for "+ st.host+": "+stringerror());
+ throw PDNSException("Resolver binding to server socket on port "+ std::to_string(st.port) +" for "+ st.host+": "+stringerror());
setNonBlocking(fd);
#ifdef __linux__
string line;
if(readFileIfThere("/proc/sys/net/ipv6/route/max_size", &line)) {
- int lim=atoi(line.c_str());
+ int lim=std::stoi(line);
if(lim < 16384) {
L<<Logger::Error<<"If using IPv6, please raise sysctl net.ipv6.route.max_size, currently set to "<<lim<<" which is < 16384"<<endl;
}
while(B.get(rr)) {
hits++;
}
- B.lookup(QType(QType::A), DNSName(boost::lexical_cast<string>(random()))+domain);
+ B.lookup(QType(QType::A), DNSName(std::to_string(random()))+domain);
while(B.get(rr)) {
}
misses++;
cout<<(key.second.keyOrZone ? "KSK" : "ZSK")<<" ";
- spacelen = (lexical_cast<string>(key.first.getKey()->getBits()).length() >= 8) ? 1 : 8 - lexical_cast<string>(key.first.getKey()->getBits()).length();
+ spacelen = (std::to_string(key.first.getKey()->getBits()).length() >= 8) ? 1 : 8 - std::to_string(key.first.getKey()->getBits()).length();
if (key.first.getKey()->getBits() < 1) {
cout<<"invalid "<<endl;
continue;
spacelen = (algname.length() >= 13) ? 1 : 13 - algname.length();
cout<<algname<<string(spacelen, ' ');
- spacelen = (lexical_cast<string>(key.second.id).length() > 5) ? 1 : 5 - lexical_cast<string>(key.second.id).length();
+ spacelen = (std::to_string(key.second.id).length() > 5) ? 1 : 5 - std::to_string(key.second.id).length();
cout<<key.second.id<<string(spacelen, ' ');
#ifdef HAVE_P11KIT1
cerr << "Syntax: pdnsutil test-algorithm algonum"<<endl;
return 0;
}
- if (testAlgorithm(lexical_cast<int>(cmds[1])))
+ if (testAlgorithm(pdns_stou(cmds[1])))
return 0;
return 1;
}
cerr << "Syntax: pdnsutil test-speed numcores [signing-server]"<<endl;
return 0;
}
- testSpeed(dk, DNSName(cmds[1]), (cmds.size() > 3) ? cmds[3] : "", atoi(cmds[2].c_str()));
+ testSpeed(dk, DNSName(cmds[1]), (cmds.size() > 3) ? cmds[3] : "", pdns_stou(cmds[2]));
}
else if(cmds[0] == "verify-crypto") {
if(cmds.size() != 2) {
return 0;
}
DNSName zone(cmds[1]);
- unsigned int id=atoi(cmds[2].c_str());
+ unsigned int id=pdns_stou(cmds[2]);
if(!id)
{
cerr<<"Invalid KEY-ID"<<endl;
return 0;
}
DNSName zone(cmds[1]);
- unsigned int id=atoi(cmds[2].c_str());
+ unsigned int id=pdns_stou(cmds[2]);
if(!id)
{
cerr<<"Invalid KEY-ID"<<endl;
active=true;
} else if(pdns_iequals(cmds[n], "inactive") || pdns_iequals(cmds[n], "passive")) {
active=false;
- } else if(atoi(cmds[n].c_str())) {
- bits = atoi(cmds[n].c_str());
+ } else if(pdns_stou(cmds[n])) {
+ bits = pdns_stou(cmds[n]);
} else {
cerr<<"Unknown algorithm, key flag or size '"<<cmds[n]<<"'"<<endl;
exit(EXIT_FAILURE);;
return 0;
}
DNSName zone(cmds[1]);
- unsigned int id=atoi(cmds[2].c_str());
+ unsigned int id=pdns_stou(cmds[2]);
if (!dk.removeKey(zone, id)) {
cerr<<"Cannot remove key " << id << " from " << zone <<endl;
return 1;
}
string zone=cmds[1];
- unsigned int id=atoi(cmds[2].c_str());
+ unsigned int id=pdns_stou(cmds[2]);
DNSSECPrivateKey dpk=dk.getKeyById(DNSName(zone), id);
cout << dpk.getKey()->convertToISC() <<endl;
}
shared_ptr<DNSCryptoKeyEngine> key(DNSCryptoKeyEngine::makeFromPEMString(drc, raw));
dpk.setKey(key);
- dpk.d_algorithm = atoi(cmds[3].c_str());
+ dpk.d_algorithm = pdns_stou(cmds[3]);
if(dpk.d_algorithm == 7)
dpk.d_algorithm = 5;
}
DNSName zone(cmds[1]);
- unsigned int id=atoi(cmds[2].c_str());
+ unsigned int id=pdns_stou(cmds[2]);
DNSSECPrivateKey dpk=dk.getKeyById(zone, id);
cout << zone<<" IN DNSKEY "<<dpk.getDNSKEY().getZoneRepresentation() <<endl;
if(dpk.d_flags == 257) {
keyOrZone = true;
else if((tmp_algo = shorthand2algorithm(cmds[n]))>0) {
algorithm = tmp_algo;
- } else if(atoi(cmds[n].c_str()))
- bits = atoi(cmds[n].c_str());
+ } else if(pdns_stou(cmds[n]))
+ bits = pdns_stou(cmds[n]);
else {
cerr<<"Unknown algorithm, key flag or size '"<<cmds[n]<<"'"<<endl;
return 0;
else if(algorithm == 14)
bits = 384;
else {
- throw runtime_error("Can't guess key size for algorithm "+lexical_cast<string>(algorithm));
+ throw runtime_error("Can't guess key size for algorithm "+std::to_string(algorithm));
}
}
}
return 1;
}
- id = boost::lexical_cast<unsigned int>(cmds[3]);
+ id = pdns_stou(cmds[3]);
std::vector<DNSBackend::KeyData> keys;
if (!B.getDomainKeys(zone, 0, keys)) {
cerr << "No keys found for zone " << zone << std::endl;
return 1;
}
if (cmds.size() > 4) {
- bits = boost::lexical_cast<int>(cmds[4]);
+ bits = pdns_stou(cmds[4]);
}
if (bits < 1) {
cerr << "Invalid bit size " << bits << "given, must be positive integer";
d_logged_in = !((tokenInfo.flags & CKF_LOGIN_REQUIRED) == CKF_LOGIN_REQUIRED);
} else {
logError("C_GetTokenInfo");
- throw PDNSException("Cannot get token info for slot " + boost::lexical_cast<std::string>(slot));
+ throw PDNSException("Cannot get token info for slot " + std::to_string(slot));
}
}
// see if we can find it with slotId
try {
- slotId = boost::lexical_cast<int>(tokenId);
+ slotId = std::stoi(tokenId);
if ((err = functions->C_GetSlotInfo(slotId, info))) {
L<<Logger::Warning<<"C_GetSlotList("<<slotId<<", info) = " << err << std::endl;
return err;
// see if we can find module
std::string tidx = module;
tidx.append("|");
- tidx.append(boost::lexical_cast<std::string>(tokenId));
+ tidx.append(tokenId);
tidx.append("|");
tidx.append(label);
std::map<std::string, std::shared_ptr<Pkcs11Token> >::iterator tokenIter;
outputs_t outputs;
boost::assign::push_back(storvect)
- (make_pair("Algorithm", boost::lexical_cast<std::string>(d_algorithm)))
+ (make_pair("Algorithm", std::to_string(d_algorithm)))
(make_pair("Engine", d_module))
(make_pair("Slot", d_slot_id))
(make_pair("PIN", d_pin))
};
void PKCS11DNSCryptoKeyEngine::fromISCMap(DNSKEYRecordContent& drc, stormap_t& stormap) {
- drc.d_algorithm = atoi(stormap["algorithm"].c_str());
+ drc.d_algorithm = pdns_stou(stormap["algorithm"]);
d_module = stormap["engine"];
d_slot_id = stormap["slot"];
boost::trim(d_slot_id);
#include <iostream>
#include <poll.h>
#include "misc.hh"
-#include <boost/lexical_cast.hpp>
#include "syncres.hh"
#include "utility.hh"
#include "namespaces.hh"
cb.d_parameter=parameter;
memset(&cb.d_ttd, 0, sizeof(cb.d_ttd));
if(cbmap.count(fd))
- throw FDMultiplexerException("Tried to add fd "+lexical_cast<string>(fd)+ " to multiplexer twice");
+ throw FDMultiplexerException("Tried to add fd "+std::to_string(fd)+ " to multiplexer twice");
cbmap[fd]=cb;
}
d_iter++;
if(!cbmap.erase(fd))
- throw FDMultiplexerException("Tried to remove unlisted fd "+lexical_cast<string>(fd)+ " from multiplexer");
+ throw FDMultiplexerException("Tried to remove unlisted fd "+std::to_string(fd)+ " from multiplexer");
}
bool pollfdcomp(const struct pollfd& a, const struct pollfd& b)
#include <iostream>
#include "misc.hh"
-#include <boost/lexical_cast.hpp>
#include "syncres.hh"
#include "namespaces.hh"
void PortsFDMultiplexer::removeFD(callbackmap_t& cbmap, int fd)
{
if(!cbmap.erase(fd))
- throw FDMultiplexerException("Tried to remove unlisted fd "+lexical_cast<string>(fd)+ " from multiplexer");
+ throw FDMultiplexerException("Tried to remove unlisted fd "+std::to_string(fd)+ " from multiplexer");
if(port_dissociate(d_portfd, PORT_SOURCE_FD, fd) < 0 && errno != ENOENT) // it appears under some circumstances, ENOENT will be returned, without this being an error. Apache has this same "fix"
throw FDMultiplexerException("Removing fd from port set: "+stringerror());
#include "dnsparser.hh"
#include "misc.hh"
#include "utility.hh"
-#include <boost/lexical_cast.hpp>
#include <boost/algorithm/string.hpp>
#include <iostream>
#include "base32.hh"
void RecordTextReader::xfr48BitInt(uint64_t &val)
{
xfr64BitInt(val);
+ if (val > 281474976710655LL)
+ throw RecordTextException("Overflow reading 48 bit integer from record content"); // fixme improve
}
void RecordTextReader::xfr64BitInt(uint64_t &val)
skipSpaces();
if(!isdigit(d_string.at(d_pos)))
- throw RecordTextException("expected digits at position "+lexical_cast<string>(d_pos)+" in '"+d_string+"'");
+ throw RecordTextException("expected digits at position "+std::to_string(d_pos)+" in '"+d_string+"'");
- char *endptr;
- val=strtoull(d_string.c_str() + d_pos, &endptr, 10);
+ size_t pos;
+ val=std::stoull(d_string.substr(d_pos), &pos);
- d_pos = endptr - d_string.c_str();
+ d_pos += pos;
}
skipSpaces();
if(!isdigit(d_string.at(d_pos)))
- throw RecordTextException("expected digits at position "+lexical_cast<string>(d_pos)+" in '"+d_string+"'");
+ throw RecordTextException("expected digits at position "+std::to_string(d_pos)+" in '"+d_string+"'");
- char *endptr;
- unsigned long ret=pdns_strtoui(d_string.c_str() + d_pos, &endptr, 10);
- if (ret == UINT_MAX && errno == ERANGE) throw RecordTextException("serial number too large in '"+d_string+"'");
- val=ret;
-
- d_pos = endptr - d_string.c_str();
+ size_t pos;
+ val=pdns_stou(d_string.substr(d_pos), &pos);
+
+ d_pos += pos;
}
void RecordTextReader::xfrTime(uint32_t &val)
skipSpaces();
if(!isdigit(d_string.at(d_pos)))
- throw RecordTextException("while parsing IP address, expected digits at position "+lexical_cast<string>(d_pos)+" in '"+d_string+"'");
+ throw RecordTextException("while parsing IP address, expected digits at position "+std::to_string(d_pos)+" in '"+d_string+"'");
uint32_t octet=0;
val=0;
len++);
if(!len)
- throw RecordTextException("while parsing IPv6 address, expected xdigits at position "+lexical_cast<string>(d_pos)+" in '"+d_string+"'");
+ throw RecordTextException("while parsing IPv6 address, expected xdigits at position "+std::to_string(d_pos)+" in '"+d_string+"'");
// end of value is here, try parse as IPv6
string address=d_string.substr(d_pos, len);
B64Decode(tmp, val);
if (len>-1 && val.size() != static_cast<size_t>(len))
- throw RecordTextException("Record length "+lexical_cast<string>(val.size()) + " does not match expected length '"+lexical_cast<string>(len));
+ throw RecordTextException("Record length "+std::to_string(val.size()) + " does not match expected length '"+std::to_string(len));
}
void RecordTextReader::xfrBlob(string& val, int)
else if(val >= 'a' && val<='f')
return 10+(val-'a');
else
- throw RecordTextException("Unknown hexadecimal character '"+lexical_cast<string>(val)+"'");
+ throw RecordTextException("Unknown hexadecimal character '"+std::to_string(val)+"'");
}
d_pos = d_end;
break;
}
- throw RecordTextException("Data field in DNS should start with quote (\") at position "+lexical_cast<string>(d_pos)+" of '"+d_string+"'");
+ throw RecordTextException("Data field in DNS should start with quote (\") at position "+std::to_string(d_pos)+" of '"+d_string+"'");
}
val.append(1, '"');
while(++d_pos < d_end && d_string[d_pos]!='"') {
{
if(!d_string.empty())
d_string.append(1,' ');
- d_string+=lexical_cast<string>(val);
+ d_string+=std::to_string(val);
}
{
if(!d_string.empty())
d_string.append(1,' ');
- d_string+=lexical_cast<string>(val);
+ d_string+=std::to_string(val);
}
void RecordTextWriter::xfrType(const uint16_t& val)
#endif
#include "utility.hh"
#include "rec_channel.hh"
-#include <boost/lexical_cast.hpp>
#include <boost/bind.hpp>
#include <vector>
#ifdef MALLOC_TRACE
map<string,string> ret;
for(const auto& the32bits : d_get32bitpointers) {
- ret.insert(make_pair(the32bits.first, lexical_cast<string>(*the32bits.second)));
+ ret.insert(make_pair(the32bits.first, std::to_string(*the32bits.second)));
}
for(const auto& the64bits : d_get64bitpointers) {
- ret.insert(make_pair(the64bits.first, lexical_cast<string>(*the64bits.second)));
+ ret.insert(make_pair(the64bits.first, std::to_string(*the64bits.second)));
}
for(const auto& the32bitmembers : d_get32bitmembers) {
if(the32bitmembers.first == "cache-bytes" || the32bitmembers.first=="packetcache-bytes")
continue; // too slow for 'get-all'
- ret.insert(make_pair(the32bitmembers.first, lexical_cast<string>(the32bitmembers.second())));
+ ret.insert(make_pair(the32bitmembers.first, std::to_string(the32bitmembers.second())));
}
return ret;
}
for(T i=begin; i != end; ++i) {
optional<uint64_t> num=get(*i);
if(num)
- ret+=lexical_cast<string>(*num)+"\n";
+ ret+=std::to_string(*num)+"\n";
else
ret+="UNKNOWN\n";
}
catch(...){}
close(fd);
- return "dumped "+lexical_cast<string>(total)+" records\n";
+ return "dumped "+std::to_string(total)+" records\n";
}
template<typename T>
catch(...){}
close(fd);
- return "dumped "+lexical_cast<string>(total)+" records\n";
+ return "dumped "+std::to_string(total)+" records\n";
}
template<typename T>
{
if(end-begin != 1)
return "Need to supply new minimum TTL number\n";
- SyncRes::s_minimumTTL = atoi(begin->c_str());
+ SyncRes::s_minimumTTL = pdns_stou(*begin);
return "New minimum TTL: " + std::to_string(SyncRes::s_minimumTTL) + "\n";
}
try { // case 2
both=splitField(input,':');
- uint16_t newport=boost::lexical_cast<uint16_t>(both.second);
+ uint16_t newport=static_cast<uint16_t>(pdns_stou(both.second));
return ComboAddress(both.first, newport);
}
catch(...){}
if(input[0]=='[') { // case 4
both=splitField(input.substr(1),']');
- return ComboAddress(both.first, both.second.empty() ? port : boost::lexical_cast<uint16_t>(both.second.substr(1)));
+ return ComboAddress(both.first, both.second.empty() ? port : static_cast<uint16_t>(pdns_stou(both.second.substr(1))));
}
return ComboAddress(input, port); // case 3
ad.d_rdForward = false;
if(domain.empty()) {
delete newMap;
- throw PDNSException("Error parsing line "+lexical_cast<string>(linenum)+" of " +::arg()["forward-zones-file"]);
+ throw PDNSException("Error parsing line "+std::to_string(linenum)+" of " +::arg()["forward-zones-file"]);
}
try {
}
catch(...) {
delete newMap;
- throw PDNSException("Conversion error parsing line "+lexical_cast<string>(linenum)+" of " +::arg()["forward-zones-file"]);
+ throw PDNSException("Conversion error parsing line "+std::to_string(linenum)+" of " +::arg()["forward-zones-file"]);
}
(*newMap)[DNSName(domain)]=ad;
parts[0]="192.168";
makeIPToNamesZone(newMap, parts);
for(int n=16; n < 32; n++) {
- parts[0]="172."+lexical_cast<string>(n);
+ parts[0]="172."+std::to_string(n);
makeIPToNamesZone(newMap,parts);
}
}
if(parts.size()<3)
throw ResolverException("Query to '" + ipport + "' for SOA of '" + domain.toString() + "' produced an unparseable response");
- *serial=(uint32_t)atol(parts[2].c_str());
+ *serial=pdns_stou(parts[2]);
}
AXFRRetriever::AXFRRetriever(const ComboAddress& remote,
MOADNSParser mdp(string(creply, len));
if (mdp.d_header.rcode != 0) {
- throw PDNSException(string("Remote server refused: ") + boost::lexical_cast<string>(mdp.d_header.rcode));
+ throw PDNSException(string("Remote server refused: ") + std::to_string(mdp.d_header.rcode));
}
for(MOADNSParser::answers_t::const_iterator i=mdp.d_answers.begin(); i!=mdp.d_answers.end(); ++i) {
if(i->first.d_type != QType::TKEY) continue;
MOADNSParser mdp(packet);
if (mdp.d_header.rcode != 0) {
- throw PDNSException(string("Remote server refused: ") + boost::lexical_cast<string>(mdp.d_header.rcode));
+ throw PDNSException(string("Remote server refused: ") + std::to_string(mdp.d_header.rcode));
}
for(MOADNSParser::answers_t::const_iterator i=mdp.d_answers.begin(); i!=mdp.d_answers.end(); ++i) {
if (i->first.d_type == QType::TSIG) {
pair<string, string> split = splitField(content, ' ');
- security_status = atoi(split.first.c_str());
+ security_status = std::stoi(split.first);
g_security_message = split.second;
}
pair<string, string> split = splitField(content, ' ');
- g_security_status = atoi(split.first.c_str());
+ g_security_status = std::stoi(split.first);
g_security_message = split.second;
*last_secpoll=now.tv_sec;
#include "sstuff.hh"
#include <iostream>
#include "misc.hh"
-#include <boost/lexical_cast.hpp>
#include "syncres.hh"
#include "utility.hh"
cb.d_parameter=parameter;
memset(&cb.d_ttd, 0, sizeof(cb.d_ttd));
if(cbmap.count(fd))
- throw FDMultiplexerException("Tried to add fd "+lexical_cast<string>(fd)+ " to multiplexer twice");
+ throw FDMultiplexerException("Tried to add fd "+std::to_string(fd)+ " to multiplexer twice");
cbmap[fd]=cb;
}
d_iter++;
if(!cbmap.erase(fd))
- throw FDMultiplexerException("Tried to remove unlisted fd "+lexical_cast<string>(fd)+ " from multiplexer");
+ throw FDMultiplexerException("Tried to remove unlisted fd "+std::to_string(fd)+ " from multiplexer");
}
int SelectFDMultiplexer::run(struct timeval* now)
localtime_r(&now, &tm);
boost::format fmt("%04d%02d%02d%02d");
string newdate = (fmt % (tm.tm_year + 1900) % (tm.tm_mon + 1) % tm.tm_mday % 1).str();
- uint32_t new_serial = atol(newdate.c_str());
+ uint32_t new_serial = pdns_stou(newdate);
if (new_serial <= sd.serial) {
new_serial = sd.serial + 1;
}
int res = poll(&pfds[0], pfds.size(), (seconds < 0) ? -1 : (seconds * 1000)); // -1 = infinite
if(res < 0)
- unixDie("polling for activity from signers, "+lexical_cast<string>(d_sockets.size()));
+ unixDie("polling for activity from signers, "+std::to_string(d_sockets.size()));
pair<vector<int>, vector<int> > vects;
for(unsigned int n = 0; n < pfds.size(); ++n)
if(pfds[n].revents & POLLIN)
#include "arguments.hh"
#include "packetcache.hh"
-#include <boost/lexical_cast.hpp>
#include "base64.hh"
#include "inflighter.cc"
#include "lua-auth.hh"
void SodiumED25519DNSCryptoKeyEngine::create(unsigned int bits)
{
if(bits != crypto_sign_ed25519_SEEDBYTES * 8) {
- throw runtime_error("Unsupported key length of "+lexical_cast<string>(bits)+" bits requested, SodiumED25519 class");
+ throw runtime_error("Unsupported key length of "+std::to_string(bits)+" bits requested, SodiumED25519 class");
}
crypto_sign_ed25519_keypair(d_pubkey, d_seckey);
}
PrivateKey: GU6SnQ/Ou+xC5RumuIUIuJZteXT2z0O/ok1s38Et6mQ=
*/
- drc.d_algorithm = atoi(stormap["algorithm"].c_str());
+ drc.d_algorithm = pdns_stou(stormap["algorithm"]);
string privateKey = stormap["privatekey"];
if (privateKey.length() != crypto_sign_ed25519_SEEDBYTES)
}
else {
s_outqueries++; d_outqueries++;
- if(d_outqueries + d_throttledqueries > s_maxqperq) throw ImmediateServFailException("more than "+lexical_cast<string>(s_maxqperq)+" (max-qperq) queries sent while resolving "+qname.toString());
+ if(d_outqueries + d_throttledqueries > s_maxqperq) throw ImmediateServFailException("more than "+std::to_string(s_maxqperq)+" (max-qperq) queries sent while resolving "+qname.toString());
TryTCP:
if(doTCP) {
LOG(prefix<<qname.toString()<<": using TCP with "<< remoteIP->toStringWithPort() <<endl);
}
if(s_maxtotusec && d_totUsec > s_maxtotusec)
- throw ImmediateServFailException("Too much time waiting for "+qname.toString()+"|"+qtype.getName()+", timeouts: "+boost::lexical_cast<string>(d_timeouts) +", throttles: "+boost::lexical_cast<string>(d_throttledqueries) + ", queries: "+lexical_cast<string>(d_outqueries)+", "+lexical_cast<string>(d_totUsec/1000)+"msec");
+ throw ImmediateServFailException("Too much time waiting for "+qname.toString()+"|"+qtype.getName()+", timeouts: "+std::to_string(d_timeouts) +", throttles: "+std::to_string(d_throttledqueries) + ", queries: "+std::to_string(d_outqueries)+", "+std::to_string(d_totUsec/1000)+"msec");
if(d_pdl && d_pdl->preoutquery(*remoteIP, d_requestor, qname, qtype, lwr.d_records, resolveret)) {
LOG(prefix<<qname.toString()<<": query handled by Lua"<<endl);
continue;
}
-// if(d_timeouts + 0.5*d_throttledqueries > 6.0 && d_timeouts > 2) throw ImmediateServFailException("Too much work resolving "+qname+"|"+qtype.getName()+", timeouts: "+boost::lexical_cast<string>(d_timeouts) +", throttles: "+boost::lexical_cast<string>(d_throttledqueries));
+// if(d_timeouts + 0.5*d_throttledqueries > 6.0 && d_timeouts > 2) throw ImmediateServFailException("Too much work resolving "+qname+"|"+qtype.getName()+", timeouts: "+std::to_string(d_timeouts) +", throttles: "+std::to_string(d_throttledqueries));
if(lwr.d_rcode==RCode::ServFail || lwr.d_rcode==RCode::Refused) {
LOG(prefix<<qname.toString()<<": "<<tns->toString()<<" returned a "<< (lwr.d_rcode==RCode::ServFail ? "ServFail" : "Refused") << ", trying sibling IP or NS"<<endl);
vector<string> digestAlgos;
stringtok(digestAlgos, publishCDS, ", ");
for(auto const &digestAlgo : digestAlgos) {
- rr.content=makeDSFromDNSKey(target, value.first.getDNSKEY(), lexical_cast<int>(digestAlgo)).getZoneRepresentation();
+ rr.content=makeDSFromDNSKey(target, value.first.getDNSKEY(), pdns_stou(digestAlgo)).getZoneRepresentation();
cds.push_back(rr);
}
}
vector<string>parts;
stringtok(parts, rr->d_content->getZoneRepresentation());
if (parts.size() >= 3) {
- serial=atoi(parts[2].c_str());
+ serial=pdns_stou(parts[2]);
} else {
L<<Logger::Error<<"No serial in IXFR query"<<endl;
outpacket->setRcode(RCode::FormErr);
}
}
-bool test_dnsrecords_cc_predicate( std::runtime_error const &ex ) { return true; }
+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) {
if (val.get<2>()) {
bool success=true;
- BOOST_WARN_EXCEPTION( { boost::scoped_ptr<DNSRecordContent> drc(DNSRecordContent::mastermake(q.getCode(), 1, val.get<1>())); pw.startRecord(DNSName("unit.test"), q.getCode()); drc->toPacket(pw); success=false; }, std::runtime_error, test_dnsrecords_cc_predicate );
+ BOOST_WARN_EXCEPTION( { boost::scoped_ptr<DNSRecordContent> drc(DNSRecordContent::mastermake(q.getCode(), 1, val.get<1>())); pw.startRecord(DNSName("unit.test"), q.getCode()); drc->toPacket(pw); success=false; }, std::exception, test_dnsrecords_cc_predicate );
if (success==false) REC_FAIL_XSUCCESS2(q.getName() << " test #" << n << " has unexpectedly passed"); // a bad record was detected when it was supposed not to be detected
} else {
- BOOST_CHECK_EXCEPTION( { boost::scoped_ptr<DNSRecordContent> drc(DNSRecordContent::mastermake(q.getCode(), 1, val.get<1>())); pw.startRecord(DNSName("unit.test"), q.getCode()); drc->toPacket(pw); }, std::runtime_error, test_dnsrecords_cc_predicate );
+ BOOST_CHECK_EXCEPTION( { boost::scoped_ptr<DNSRecordContent> drc(DNSRecordContent::mastermake(q.getCode(), 1, val.get<1>())); pw.startRecord(DNSName("unit.test"), q.getCode()); drc->toPacket(pw); }, std::exception, test_dnsrecords_cc_predicate );
}
};
}
int counter=0;
try {
for(counter = 0; counter < 100000; ++counter) {
- DNSName a=DNSName("hello ")+DNSName(boost::lexical_cast<string>(counter));
+ DNSName a=DNSName("hello ")+DNSName(std::to_string(counter));
BOOST_CHECK_EQUAL(DNSName(a.toString()), a);
PC.insert(a, QType(QType::A), PacketCache::QUERYCACHE, "something", 3600, 1);
int delcounter=0;
for(delcounter=0; delcounter < counter/100; ++delcounter) {
- DNSName a=DNSName("hello ")+DNSName(boost::lexical_cast<string>(delcounter));
+ DNSName a=DNSName("hello ")+DNSName(std::to_string(delcounter));
PC.purge(a.toString());
}
vector<DNSResourceRecord> entry;
int expected=counter-delcounter;
for(; delcounter < counter; ++delcounter) {
- if(PC.getEntry(DNSName("hello ")+DNSName(boost::lexical_cast<string>(delcounter)), QType(QType::A), PacketCache::QUERYCACHE, entry, 1)) {
+ if(PC.getEntry(DNSName("hello ")+DNSName(std::to_string(delcounter)), QType(QType::A), PacketCache::QUERYCACHE, entry, 1)) {
matches++;
}
}
{
unsigned int offset=(unsigned int)(unsigned long)a;
for(unsigned int counter=0; counter < 100000; ++counter)
- g_PC->insert(DNSName("hello ")+DNSName(boost::lexical_cast<string>(counter+offset)), QType(QType::A), PacketCache::QUERYCACHE, "something", 3600, 1);
+ g_PC->insert(DNSName("hello ")+DNSName(std::to_string(counter+offset)), QType(QType::A), PacketCache::QUERYCACHE, "something", 3600, 1);
return 0;
}
catch(PDNSException& e) {
unsigned int offset=(unsigned int)(unsigned long)a;
vector<DNSResourceRecord> entry;
for(unsigned int counter=0; counter < 100000; ++counter)
- if(!g_PC->getEntry(DNSName("hello ")+DNSName(boost::lexical_cast<string>(counter+offset)), QType(QType::A), PacketCache::QUERYCACHE, entry, 1)) {
+ if(!g_PC->getEntry(DNSName("hello ")+DNSName(std::to_string(counter+offset)), QType(QType::A), PacketCache::QUERYCACHE, entry, 1)) {
g_missing++;
}
return 0;
PacketCache PC;
for(unsigned int counter = 0; counter < 1000000; ++counter) {
- PC.insert(DNSName("hello ")+DNSName(boost::lexical_cast<string>(counter)), QType(QType::A), PacketCache::QUERYCACHE, "something", 1, 1);
+ PC.insert(DNSName("hello ")+DNSName(std::to_string(counter)), QType(QType::A), PacketCache::QUERYCACHE, "something", 1, 1);
}
sleep(1);
#include <boost/tuple/tuple.hpp>
#include <boost/iostreams/stream.hpp>
#include <boost/iostreams/device/file.hpp>
-#include <boost/lexical_cast.hpp>
#include "dns.hh"
#include "zoneparser-tng.hh"
#include "dnsrecords.hh"
while(zp.get(rr)) {
// make sure these concur.
std::string host, type, data;
- int ttl;
+ unsigned int ttl;
std::getline(ifs, host, ' ');
std::getline(ifs, type, ' ');
- ttl = boost::lexical_cast<int>(type);
+ ttl = pdns_stou(type);
std::getline(ifs, type, ' ');
std::getline(ifs, type, ' ');
std::getline(ifs, data, '\n');
; // cerr<<"signature invalid"<<endl;
if(signature->d_type != QType::DNSKEY) {
dotEdge(signature->d_signer,
- "DNSKEY", signature->d_signer, lexical_cast<string>(signature->d_tag),
+ "DNSKEY", signature->d_signer, std::to_string(signature->d_tag),
DNSRecordContent::NumberToType(signature->d_type), i->first.first, "", isValid ? "green" : "red");
}
auto drc=getRR<DNSKEYRecordContent> (rec);
tkeys.insert(*drc);
// cerr<<"Inserting key with tag "<<drc->getTag()<<": "<<drc->getZoneRepresentation()<<endl;
- dotNode("DNSKEY", qname, lexical_cast<string>(drc->getTag()), (boost::format("tag=%d, algo=%d") % drc->getTag() % static_cast<int>(drc->d_algorithm)).str());
+ dotNode("DNSKEY", qname, std::to_string(drc->getTag()), (boost::format("tag=%d, algo=%d") % drc->getTag() % static_cast<int>(drc->d_algorithm)).str());
toSign.push_back(rec.d_content);
toSignTags.push_back(drc->getTag());
// cerr<<"got valid DNSKEY (it matches the DS) for "<<qname<<endl;
validkeys.insert(drc);
- dotNode("DS", qname, "" /*lexical_cast<string>(dsrc.d_tag)*/, (boost::format("tag=%d, digest algo=%d, algo=%d") % dsrc.d_tag % static_cast<int>(dsrc.d_digesttype) % static_cast<int>(dsrc.d_algorithm)).str());
+ dotNode("DS", qname, "" /*std::to_string(dsrc.d_tag)*/, (boost::format("tag=%d, digest algo=%d, algo=%d") % dsrc.d_tag % static_cast<int>(dsrc.d_digesttype) % static_cast<int>(dsrc.d_algorithm)).str());
}
else {
// cerr<<"DNSKEY did not match the DS, parent DS: "<<drc.getZoneRepresentation() << " ! = "<<dsrc2.getZoneRepresentation()<<endl;
}
// cout<<" subgraph "<<dotEscape("cluster "+qname)<<" { "<<dotEscape("DS "+qname)<<" -> "<<dotEscape("DNSKEY "+qname)<<" [ label = \""<<dsrc.d_tag<<"/"<<static_cast<int>(dsrc.d_digesttype)<<"\" ]; label = \"zone: "<<qname<<"\"; }"<<endl;
- dotEdge(DNSName("."), "DS", qname, "" /*lexical_cast<string>(dsrc.d_tag)*/, "DNSKEY", qname, lexical_cast<string>(drc.getTag()), isValid ? "green" : "red");
+ dotEdge(DNSName("."), "DS", qname, "" /*std::to_string(dsrc.d_tag)*/, "DNSKEY", qname, std::to_string(drc.getTag()), isValid ? "green" : "red");
// dotNode("DNSKEY", qname, (boost::format("tag=%d, algo=%d") % drc.getTag() % static_cast<int>(drc.d_algorithm)).str());
}
}
}
for(uint16_t tag : toSignTags) {
dotEdge(qname,
- "DNSKEY", qname, lexical_cast<string>(i->d_tag),
- "DNSKEY", qname, lexical_cast<string>(tag), isValid ? "green" : "red");
+ "DNSKEY", qname, std::to_string(i->d_tag),
+ "DNSKEY", qname, std::to_string(tag), isValid ? "green" : "red");
}
if(isValid)
dsmap.insert(make_pair(dsrc->d_tag, *dsrc));
// dotEdge(keyqname,
// "DNSKEY", keyqname, ,
- // "DS", qname, lexical_cast<string>(dsrc.d_tag));
+ // "DS", qname, std::to_string(dsrc.d_tag));
// cout<<" "<<dotEscape("DNSKEY "+keyqname)<<" -> "<<dotEscape("DS "+qname)<<";"<<endl;
}
}
if (req.method == "HEAD") {
resp.body = "";
} else {
- resp.headers["Content-Length"] = lexical_cast<string>(resp.body.size());
+ resp.headers["Content-Length"] = std::to_string(resp.body.size());
}
return resp;
return;
}
if(!req->getvars["resizering"].empty()){
- int size=atoi(req->getvars["size"].c_str());
+ int size=std::stoi(req->getvars["size"]);
if (S.ringExists(req->getvars["resizering"]) && size > 0 && size <= 500000)
- S.resizeRing(req->getvars["resizering"], atoi(req->getvars["size"].c_str()));
+ S.resizeRing(req->getvars["resizering"], std::stoi(req->getvars["size"]));
resp->status = 301;
resp->headers["Location"] = req->url.path;
return;
{
vector<string> items = S.getEntries();
for(const string& item : items) {
- out[item] = lexical_cast<string>(S.read(item));
+ out[item] = std::to_string(S.read(item));
}
// add uptime
- out["uptime"] = lexical_cast<string>(time(0) - s_starttime);
+ out["uptime"] = std::to_string(time(0) - s_starttime);
}
static void gatherRecords(const Value& container, vector<DNSResourceRecord>& new_records, vector<DNSResourceRecord>& new_ptrs) {
for(DNSSECKeeper::keyset_t::value_type value : keyset) {
if (req->parameters.count("key_id")) {
- int keyid = lexical_cast<int>(req->parameters["key_id"]);
- int curid = lexical_cast<int>(value.second.id);
+ int keyid = std::stoi(req->parameters["key_id"]);
+ int curid = value.second.id;
if (keyid != curid)
continue;
}
Value dnskey(value.first.getDNSKEY().getZoneRepresentation().c_str(), doc.GetAllocator());
key.AddMember("dnskey", dnskey, doc.GetAllocator());
if (req->parameters.count("key_id")) {
- DNSSECPrivateKey dpk=dk.getKeyById(zonename, lexical_cast<int>(req->parameters["key_id"]));
+ DNSSECPrivateKey dpk=dk.getKeyById(zonename, std::stoi(req->parameters["key_id"]));
Value content(dpk.getKey()->convertToISC().c_str(), doc.GetAllocator());
key.AddMember("content", content, doc.GetAllocator());
}
if (q.empty())
throw ApiException("Query q can't be blank");
if (sMax.empty() == false)
- maxEnts = boost::lexical_cast<int>(sMax);
+ maxEnts = std::stoi(sMax);
if (maxEnts < 1)
throw ApiException("Maximum entries must be larger than 0");
int count = PC.purgeExact(canon);
map<string, string> object;
- object["count"] = lexical_cast<string>(count);
+ object["count"] = std::to_string(count);
object["result"] = "Flushed cache.";
resp->body = returnJsonObject(object);
}
count += broadcastAccFunction<uint64_t>(boost::bind(pleaseWipePacketCache, canon, false));
count += broadcastAccFunction<uint64_t>(boost::bind(pleaseWipeAndCountNegCache, canon, false));
map<string, string> object;
- object["count"] = lexical_cast<string>(count);
+ object["count"] = std::to_string(count);
object["result"] = "Flushed cache.";
resp->body = returnJsonObject(object);
}
g_numRecords++;
string content(ocontent);
if(qtype == "MX" || qtype == "SRV") {
- prio=atoi(content.c_str());
+ prio=pdns_stou(content);
string::size_type pos = content.find_first_not_of("0123456789");
if(pos != string::npos)
return; // NSECs do not go in the database
if((qtype == "MX" || qtype == "SRV") && g_mode!=ORACLE) {
- prio=atoi(content.c_str());
+ prio=pdns_stou(content);
string::size_type pos = content.find_first_not_of("0123456789");
if(pos != string::npos)
stringtok(parts, content);
cout<<"INSERT INTO soa(origin, ns, mbox, serial, refresh, retry, expire, minimum, ttl) VALUES("<<
- sqlstr(toLower(zoneNameDot))<<", "<<sqlstr(parts[0])<<", "<<sqlstr(parts[1])<<", "<<atoi(parts[2].c_str())<<", "<<
- atoi(parts[3].c_str())<<", "<<atoi(parts[4].c_str())<<", "<<atoi(parts[5].c_str())<<", "<<atoi(parts[6].c_str())<<", "<<ttl<<");\n";
+ sqlstr(toLower(zoneNameDot))<<", "<<sqlstr(parts[0])<<", "<<sqlstr(parts[1])<<", "<<pdns_stou(parts[2])<<", "<<
+ pdns_stou(parts[3])<<", "<<pdns_stou(parts[4])<<", "<<pdns_stou(parts[5])<<", "<<pdns_stou(parts[6])<<", "<<ttl<<");\n";
}
else
{
#include "zoneparser-tng.hh"
#include <deque>
#include <boost/algorithm/string.hpp>
-#include <boost/lexical_cast.hpp>
ZoneParserTNG::ZoneParserTNG(const string& fname, const DNSName& zname, const string& reldir) : d_reldir(reldir),
d_zonename(zname), d_defaultttl(3600),
if(str.empty())
return 0;
- unsigned int val=atoi(str.c_str());
+ unsigned int val=pdns_stou(str);
char lc=toupper(str[str.length()-1]);
if(!isdigit(lc))
switch(lc) {
}
if(c=='$') {
if(pos + 1 == part.size() || part[pos+1]!='{') { // a trailing $, or not followed by {
- outpart.append(lexical_cast<string>(d_templatecounter));
+ outpart.append(std::to_string(d_templatecounter));
continue;
}
string ZoneParserTNG::getLineOfFile()
{
if (d_zonedata.size() > 0)
- return "on line "+lexical_cast<string>(std::distance(d_zonedata.begin(), d_zonedataline))+" of given string";
+ return "on line "+std::to_string(std::distance(d_zonedata.begin(), d_zonedataline))+" of given string";
- return "on line "+lexical_cast<string>(d_filestates.top().d_lineno)+" of file '"+d_filestates.top().d_filename+"'";
+ return "on line "+std::to_string(d_filestates.top().d_lineno)+" of file '"+d_filestates.top().d_filename+"'";
}
// ODD: this function never fills out the prio field! rest of pdns compensates though
rr.content.append(1,' ');
if(n > 1)
- rr.content+=lexical_cast<string>(makeTTLFromZone(recparts[n]));
+ rr.content+=std::to_string(makeTTLFromZone(recparts[n]));
else
rr.content+=recparts[n];
projects / thirdparty / pdns.git / commitdiff
