boost stuff now needs explicit scoping.
CoProcess::CoProcess(const string &command,int timeout, int infd, int outfd): d_infd(infd), d_outfd(outfd), d_timeout(timeout)
{
- split(d_params, command, is_any_of(" "));
+ split(d_params, command, boost::is_any_of(" "));
d_argv.resize(d_params.size()+1);
d_argv[d_params.size()]=nullptr;
}
received.resize(eolPos);
- trim_right(received);
+ boost::trim_right(received);
}
void CoProcess::sendReceive(const string &snd, string &rcv)
{
line.clear();
stringfgets(d_fp.get(), line);
- trim_right(line);
+ boost::trim_right(line);
}
void UnixRemote::sendReceive(const string &snd, string &rcv)
if (d_pid > 0 && checkStatus()) return;
std::vector <std::string> v;
- split(v, command, is_any_of(" "));
+ split(v, command, boost::is_any_of(" "));
std::vector<const char *>argv(v.size()+1);
argv[v.size()]=0;
return false;
while(getline(f,pline)) {
- trim_right(pline);
+ boost::trim_right(pline);
if(!pline.empty() && pline[pline.size()-1]=='\\') {
line+=pline.substr(0,pline.length()-1);
}
// strip trailing spaces
- trim_right(line);
+ boost::trim_right(line);
// strip leading spaces
if((pos=line.find_first_not_of(" \t\r\n"))!=string::npos)
uint64_t delcount = 0;
- if(ends_with(match, "$")) {
+ if(boost::ends_with(match, "$")) {
delcount = purgeLockedCollectionsVector<NameTag>(d_maps, match);
*d_statnumentries -= delcount;
}
{
uint64_t delcount = 0;
- if(ends_with(match, "$")) {
+ if(boost::ends_with(match, "$")) {
delcount = purgeLockedCollectionsVector<NameTag>(d_maps, match);
*d_statnumentries -= delcount;
}
d_sock = makeQuerySocket(local, false); // make a TCP socket
if (d_sock < 0)
throw ResolverException("Error creating socket for AXFR request to "+d_remote.toStringWithPort());
- d_buf = shared_array<char>(new char[65536]);
+ d_buf = boost::shared_array<char>(new char[65536]);
d_remote = remote; // mostly for error reporting
this->connect(timeout);
d_soacount = 0;
*/
#pragma once
#include <boost/utility.hpp>
+#include <boost/shared_array.hpp>
#include "iputils.hh"
#include "dnsname.hh"
int getLength(uint16_t timeout);
void timeoutReadn(uint16_t bytes, uint16_t timeoutsec=10);
- shared_array<char> d_buf;
+ boost::shared_array<char> d_buf;
string d_domain;
int d_sock;
int d_soacount;
prio=pdns_stou(content.substr(0,pos));
boost::erase_head(content, pos);
}
- trim_left(content);
+ boost::trim_left(content);
}
try {
typedef int Identifier;
typedef DNSResult Answer; // ip
int d_socket;
- deque<uint16_t> d_idqueue;
+ std::deque<uint16_t> d_idqueue;
typedef accumulator_set<
double
if(limit && domains.size() >= limit)
break;
- trim_right(line);
+ boost::trim_right(line);
if(line.empty() || line[0] == '#')
continue;
split=splitField(line,',');
#include <fstream>
#include <pwd.h>
#include <thread>
+#include <boost/scoped_array.hpp>
#if defined (__OpenBSD__) || defined(__NetBSD__)
// If this is not undeffed, __attribute__ wil be redefined by /usr/include/readline/rlstdc.h
#endif
break;
case 'l':
- g_cmdLine.locals.push_back(trim_copy(string(optarg)));
+ g_cmdLine.locals.push_back(boost::trim_copy(string(optarg)));
break;
case 'u':
g_cmdLine.uid=optarg;
vector<string> parts;
stringtok(parts, zone);
// we need exactly 3 parts, except if the length field is set to 0 then we only need 2
- if (parts.size() != 3 && !(parts.size() == 2 && equals(parts.at(1), "0"))) {
+ if (parts.size() != 3 && !(parts.size() == 2 && boost::equals(parts.at(1), "0"))) {
throw MOADNSException("Unknown record was stored incorrectly, need 3 fields, got " + std::to_string(parts.size()) + ": " + zone);
}
checkedFread(&d_pfh);
if (d_pfh.magic != 2712847316UL) {
- throw runtime_error((format("PCAP file %s has bad magic %x, should be %x") % fname % d_pfh.magic % 2712847316UL).str());
+ throw runtime_error((boost::format("PCAP file %s has bad magic %x, should be %x") % fname % d_pfh.magic % 2712847316UL).str());
}
if( d_pfh.linktype==1) {
else if(d_pfh.linktype==113) {
d_skipMediaHeader=16;
}
- else throw runtime_error((format("Unsupported link type %d") % d_pfh.linktype).str());
+ else throw runtime_error((boost::format("Unsupported link type %d") % d_pfh.linktype).str());
d_runts = d_oversized = d_correctpackets = d_nonetheripudp = 0;
}
{
int ret = fread(ptr, 1, size, d_fp.get());
if (ret < 0) {
- unixDie( (format("Error reading %d bytes from %s") % size % d_fname).str());
+ unixDie( (boost::format("Error reading %d bytes from %s") % size % d_fname).str());
}
if(!ret)
throw EofException();
if((size_t)ret != size)
- throw EofException((format("Incomplete read from '%s', got only %d bytes") % d_fname % ret).str());
+ throw EofException((boost::format("Incomplete read from '%s', got only %d bytes") % d_fname % ret).str());
}
bool PcapPacketReader::getUDPPacket()
if(d_pheader.caplen > sizeof(d_buffer)) {
d_oversized++;
- throw runtime_error((format("Can't handle a %d byte packet, have space for %d") % d_pheader.caplen % sizeof(d_buffer)).str());
+ throw runtime_error((boost::format("Can't handle a %d byte packet, have space for %d") % d_pheader.caplen % sizeof(d_buffer)).str());
}
checkedFreadSize(d_buffer, d_pheader.caplen);
#include "dnsrecords.hh"
#include "iputils.hh"
-
void DNSResourceRecord::setContent(const string &cont) {
content = cont;
switch(qtype.getCode()) {
}
private:
- deque<uint16_t> d_available;
+ std::deque<uint16_t> d_available;
} s_idmanager;
static void printStats(uint64_t origWaitingFor=0, uint64_t weWaitingFor=0)
{
- format headerfmt ("%|9t|Questions - Pend. - Drop = Answers = (On time + Late) = (Err + Ok)\n");
- format datafmt("%s%|9t|%d %|21t|%d %|29t|%d %|36t|%d %|47t|%d %|57t|%d %|66t|%d %|72t|%d\n");
+ boost::format headerfmt ("%|9t|Questions - Pend. - Drop = Answers = (On time + Late) = (Err + Ok)\n");
+ boost::format datafmt("%s%|9t|%d %|21t|%d %|29t|%d %|36t|%d %|47t|%d %|57t|%d %|66t|%d %|72t|%d\n");
cerr<<headerfmt;
cerr<<(datafmt % "Orig" % s_questions % origWaitingFor % s_orignever % s_origanswers % 0 % s_origtimedout % 0 % 0);
while(std::getline(str, sline)) {
tie(key,value)=splitField(sline, ':');
- trim(value);
+ boost::trim(value);
if(pdns_iequals(key,"algorithm")) {
algorithm = pdns_stou(value);
stormap["algorithm"]=std::to_string(algorithm);
while(std::getline(str, sline)) {
tie(key,value)=splitField(sline, ':');
- trim(value);
+ boost::trim(value);
if(pdns_iequals(key,"algorithm")) {
algorithm = pdns_stou(value);
stormap["algorithm"]=std::to_string(algorithm);
pair<string, string> q;
string line;
while(stringfgets(fp.get(), line)) {
- trim_right(line);
+ boost::trim_right(line);
q=splitField(line, ' ');
g_queries.push_back(BenchQuery(q.first, DNSRecordContent::TypeToNumber(q.second)));
}
d_lw->writeFunction("getStat", [](const std::string& str) {
uint64_t result = 0;
- optional<uint64_t> value = getStatByName(str);
+ boost::optional<uint64_t> value = getStatByName(str);
if (value) {
result = *value;
}
#include <sys/types.h>
#include <dirent.h>
#include <algorithm>
-#include <boost/optional.hpp>
#include <poll.h>
#include <iomanip>
#include <netinet/tcp.h>
string line;
while(std::getline(ifs, line)) {
- boost::trim_right_if(line, is_any_of(" \r\n\x1a"));
+ boost::trim_right_if(line, boost::is_any_of(" \r\n\x1a"));
boost::trim_left(line); // leading spaces, let's be nice
string::size_type tpos = line.find_first_of(";#");
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#pragma once
-#include <boost/tuple/tuple.hpp>
-#include <boost/shared_array.hpp>
-#include <boost/scoped_array.hpp>
-#include <boost/optional.hpp>
-#include <boost/any.hpp>
-#include <boost/function.hpp>
+
#include <boost/format.hpp>
-#include <boost/algorithm/string.hpp>
-#include <memory>
-#include <vector>
+#include <boost/optional.hpp>
+#include <iostream>
#include <map>
+#include <memory>
#include <set>
-#include <deque>
#include <string>
-#include <iostream>
+#include <tuple>
+#include <vector>
-using std::vector;
-using std::map;
-using std::pair;
-using std::make_pair;
-using std::runtime_error;
-using std::ostringstream;
-using std::set;
-using std::deque;
using std::cerr;
-using std::cout;
using std::clog;
+using std::cout;
using std::endl;
using std::ifstream;
+using std::make_pair;
+using std::make_tuple;
+using std::map;
+using std::max;
+using std::min;
using std::ofstream;
using std::ostream;
-using std::min; // these are a bit scary, everybody uses 'min'
-using std::max;
-using std::string;
-
-using boost::tie;
+using std::ostringstream;
+using std::pair;
+using std::runtime_error;
+using std::set;
using std::shared_ptr;
+using std::string;
+using std::tie;
+using std::tuple;
using std::unique_ptr;
-using boost::shared_array;
-using boost::scoped_array;
-using boost::tuple;
-using boost::format;
-using boost::make_tuple;
-using boost::optional;
-using boost::any_cast;
-using boost::any;
-using boost::function;
-using boost::trim;
-using boost::trim_copy;
-using boost::trim_left;
-using boost::trim_right;
-using boost::is_any_of;
-using boost::trim_right_copy_if;
-using boost::equals;
-using boost::ends_with;
-using boost::iends_with;
+using std::vector;
#include <fstream>
#include "sortlist.hh"
#include "sstuff.hh"
+#include <boost/any.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/tuple/tuple_comparison.hpp>
#include <boost/shared_array.hpp>
#endif /* NOD_ENABLED */
__thread struct timeval g_now; // timestamp, updated (too) frequently
-typedef vector<pair<int, function< void(int, any&) > > > deferredAdd_t;
+typedef vector<pair<int, boost::function< void(int, boost::any&) > > > deferredAdd_t;
// for communicating with our threads
// effectively readonly after startup
static void handleGenUDPQueryResponse(int fd, FDMultiplexer::funcparam_t& var)
{
- PacketID pident=*any_cast<PacketID>(&var);
+ PacketID pident=*
boost::any_cast<PacketID>(&var);
char resp[512];
ComboAddress fromaddr;
socklen_t addrlen=sizeof(fromaddr);
LWResult::Result arecvfrom(std::string& packet, int flags, const ComboAddress& fromaddr, size_t *d_len,
uint16_t id, const DNSName& domain, uint16_t qtype, int fd, const struct timeval* now)
{
- static optional<unsigned int> nearMissLimit;
+ static boost::optional<unsigned int> nearMissLimit;
if(!nearMissLimit)
nearMissLimit=::arg().asNum("spoof-nearmiss-max");
static void handleRunningTCPQuestion(int fd, FDMultiplexer::funcparam_t& var)
{
- shared_ptr<TCPConnection> conn=any_cast<shared_ptr<TCPConnection> >(var);
+ shared_ptr<TCPConnection> conn=boost::any_cast<shared_ptr<TCPConnection> >(var);
if (conn->state == TCPConnection::PROXYPROTOCOLHEADER) {
ssize_t bytes = recv(conn->getFD(), &conn->data.at(conn->proxyProtocolGot), conn->proxyProtocolNeed, 0);
static void handleTCPClientReadable(int fd, FDMultiplexer::funcparam_t& var)
{
- PacketID* pident=any_cast<PacketID>(&var);
+ PacketID* pident=
boost::any_cast<PacketID>(&var);
// cerr<<"handleTCPClientReadable called for fd "<<fd<<", pident->inNeeded: "<<pident->inNeeded<<", "<<pident->sock->getHandle()<<endl;
- shared_array<char> buffer(new char[pident->inNeeded]);
+ boost::shared_array<char> buffer(new char[pident->inNeeded]);
ssize_t ret=recv(fd, buffer.get(), pident->inNeeded,0);
if(ret > 0) {
static void handleTCPClientWritable(int fd, FDMultiplexer::funcparam_t& var)
{
- PacketID* pid=any_cast<PacketID>(&var);
+ PacketID* pid=
boost::any_cast<PacketID>(&var);
ssize_t ret=send(fd, pid->outMSG.c_str() + pid->outPos, pid->outMSG.size() - pid->outPos,0);
if(ret > 0) {
pid->outPos+=(ssize_t)ret;
static void handleUDPServerResponse(int fd, FDMultiplexer::funcparam_t& var)
{
- PacketID pid=any_cast<PacketID>(var);
+ PacketID pid=
boost::any_cast<PacketID>(var);
ssize_t len;
std::string packet;
packet.resize(g_outgoingEDNSBufsize);
pos=line.find('#');
if(pos!=string::npos)
line.resize(pos);
- trim(line);
+ boost::trim(line);
if(line.empty())
continue;
try {
auto headers = splitField(part, '=');
- trim(headers.first);
- trim(headers.second);
+ boost::trim(headers.first);
+ boost::trim(headers.second);
unsigned int threadId = pdns_stou(headers.first);
std::vector<std::string> cpus;
expired_t expired=t_fdm->getTimeouts(g_now);
for(expired_t::iterator i=expired.begin() ; i != expired.end(); ++i) {
- shared_ptr<TCPConnection> conn=any_cast<shared_ptr<TCPConnection> >(i->second);
+ shared_ptr<TCPConnection> conn=boost::any_cast<shared_ptr<TCPConnection> >(i->second);
if(g_logCommonErrors)
g_log<<Logger::Warning<<"Timeout from remote TCP client "<< conn->d_remote.toStringWithPort() <<endl;
t_fdm->removeReadFD(i->first);
}
string line;
while(getline(ifs,line)) {
- trim(line);
+ boost::trim(line);
domains.push_back(line);
}
}
while(getline(ifs, line)) {
if(line[0]=='-')
continue;
- trim(line);
+ boost::trim(line);
interim += line;
}
B64Decode(interim, raw);
return SNMP_ERR_GENERR;
}
- optional<uint64_t> value = getStatByName(it->second);
+ boost::optional<uint64_t> value = getStatByName(it->second);
if (value) {
return RecursorSNMPAgent::setCounter64Value(requests, *value);
} else {
#include "dnsname.hh"
#include "sholder.hh"
#include <atomic>
+#include <boost/optional.hpp>
extern GlobalStateHolder<SuffixMatchNode> g_dontThrottleNames;
extern GlobalStateHolder<NetmaskGroup> g_dontThrottleNetmasks;
static map<string, const uint32_t*> d_get32bitpointers;
static map<string, const std::atomic<uint64_t>*> d_getatomics;
-static map<string, function< uint64_t() > > d_get64bitmembers;
+static map<string, std::function< uint64_t() > > d_get64bitmembers;
static std::mutex d_dynmetricslock;
struct dynmetrics {
std::atomic<unsigned long> *d_ptr;
d_getatomics[name]=place;
}
-static void addGetStat(const string& name, function<uint64_t ()> f )
+static void addGetStat(const string& name, std::function<uint64_t ()> f )
{
d_get64bitmembers[name]=f;
}
return ret.d_ptr;
}
-static optional<uint64_t> get(const string& name)
+static boost::optional<uint64_t> get(const string& name)
{
- optional<uint64_t> ret;
+ boost::optional<uint64_t> ret;
if(d_get32bitpointers.count(name))
return *d_get32bitpointers.find(name)->second;
return ret;
}
-optional<uint64_t> getStatByName(const std::string& name)
+boost::optional<uint64_t> getStatByName(const std::string& name)
{
return get(name);
}
string ret;
for(T i=begin; i != end; ++i) {
- optional<uint64_t> num=get(*i);
+ boost::optional<uint64_t> num=get(*i);
if(num)
ret+=std::to_string(*num)+"\n";
else
ostringstream ret;
ret<<"Over last "<<total<<" entries:\n";
- format fmt("%.02f%%\t%s\n");
+ boost::format fmt("%.02f%%\t%s\n");
int limit=0, accounted=0;
if(total) {
for(rcounts_t::const_iterator i=rcounts.begin(); i != rcounts.end() && limit < 20; ++i, ++limit) {
ostringstream ret;
ret<<"Over last "<<total<<" entries:\n";
- format fmt("%.02f%%\t%s\n");
+ boost::format fmt("%.02f%%\t%s\n");
int limit=0, accounted=0;
if(total) {
for(rcounts_t::const_iterator i=rcounts.begin(); i != rcounts.end() && limit < 20; ++i, ++limit) {
#include <boost/multi_index/hashed_index.hpp>
#include <boost/tuple/tuple_comparison.hpp>
#include <boost/multi_index/sequenced_index.hpp>
+#include <boost/optional.hpp>
#include "packetcache.hh"
#include "validate.hh"
#include <vector>
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/hashed_index.hpp>
+#include <boost/optional.hpp>
#include "dnsparser.hh"
#include "dnsname.hh"
#include "dns.hh"
vector<DNSRecord> ret;
int res = sr->beginResolve(target, QType(QType::A), QClass::IN, ret);
BOOST_CHECK_EQUAL(res, RCode::ServFail);
- BOOST_CHECK_EQUAL(ret.size(), 0);
+ BOOST_CHECK_EQUAL(ret.size(), 0U);
BOOST_CHECK_EQUAL(downServers.size(), 2U);
BOOST_CHECK_EQUAL(queriesCount, 2U);
vector<DNSRecord> ret;
int res = sr->beginResolve(target, QType(QType::A), QClass::IN, ret);
BOOST_CHECK_EQUAL(res, RCode::ServFail);
- BOOST_CHECK_EQUAL(ret.size(), 0);
+ BOOST_CHECK_EQUAL(ret.size(), 0U);
BOOST_CHECK_EQUAL(downServers.size(), 2U);
BOOST_CHECK_EQUAL(queriesCount, 2U);
if ((*iter).find('=') == string::npos)
throw PDNSException("Error parsing '" + *iter + "', missing =");
pair<string,string> headers=splitField(*iter, '=');
- trim(headers.first);
- trim(headers.second);
+ boost::trim(headers.first);
+ boost::trim(headers.second);
// headers.first=toCanonic("", headers.first);
if(n==0) {
ad.d_rdForward = false;
int linenum=0;
uint64_t before = newMap->size();
while(linenum++, stringfgets(fp.get(), line)) {
- trim(line);
+ boost::trim(line);
if (line[0] == '#') // Comment line, skip to the next line
continue;
string domain, instructions;
tie(domain, instructions)=splitField(line, '=');
instructions = splitField(instructions, '#').first; // Remove EOL comments
- trim(domain);
- trim(instructions);
+ boost::trim(domain);
+ boost::trim(instructions);
if(domain.empty() && instructions.empty()) { // empty line
continue;
}
pos=line.find('#');
if(pos!=string::npos)
line.resize(pos);
- trim(line);
+ boost::trim(line);
if(line.empty())
continue;
parts.clear();
#ifdef HAVE_PROTOBUF
#include <boost/uuid/uuid.hpp>
+#include <boost/optional.hpp>
#endif
struct ResolveContext {
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#pragma once
-#include "misc.hh"
+
+#include <boost/scoped_array.hpp>
+
#include "dnspacket.hh"
class ResponseStats
setNonBlocking(fd);
try {
int mesgsize=65535;
- scoped_array<char> mesg(new char[mesgsize]);
+ boost::scoped_array<char> mesg(new char[mesgsize]);
DLOG(g_log<<"TCP Connection accepted on fd "<<fd<<endl);
bool logDNSQueries= ::arg().mustDo("log-dns-queries");
RecordTextReader rtr(source);
set<SvcParam> v;
rtr.xfrSvcParamKeyVals(v);
- BOOST_CHECK_EQUAL(v.size(), 1);
+ BOOST_CHECK_EQUAL(v.size(), 1U);
auto alpn = v.begin()->getALPN();
- BOOST_CHECK_EQUAL(alpn.size(), 1);
+ BOOST_CHECK_EQUAL(alpn.size(), 1U);
auto val = alpn.begin();
BOOST_CHECK_EQUAL(*val, "h2");
source = "alpn=h2,h3";
RecordTextReader rtr2(source);
rtr2.xfrSvcParamKeyVals(v);
- BOOST_CHECK_EQUAL(v.size(), 1);
+ BOOST_CHECK_EQUAL(v.size(), 1U);
alpn = v.begin()->getALPN();
- BOOST_CHECK_EQUAL(alpn.size(), 2);
+ BOOST_CHECK_EQUAL(alpn.size(), 2U);
val = alpn.begin();
BOOST_CHECK_EQUAL(*val, "h2");
val++;
RecordTextReader rtr(source);
set<SvcParam> v;
rtr.xfrSvcParamKeyVals(v);
- BOOST_CHECK_EQUAL(v.size(), 1);
+ BOOST_CHECK_EQUAL(v.size(), 1U);
auto m = v.begin()->getMandatory();
- BOOST_CHECK_EQUAL(m.size(), 1);
+ BOOST_CHECK_EQUAL(m.size(), 1U);
auto val = m.begin();
BOOST_CHECK(*val == SvcParam::alpn);
source = "mandatory=alpn,ipv4hint";
RecordTextReader rtr2("mandatory=alpn,ipv4hint");
rtr2.xfrSvcParamKeyVals(v);
- BOOST_CHECK_EQUAL(v.size(), 1);
+ BOOST_CHECK_EQUAL(v.size(), 1U);
m = v.begin()->getMandatory();
- BOOST_CHECK_EQUAL(m.size(), 2);
+ BOOST_CHECK_EQUAL(m.size(), 2U);
val = m.begin();
BOOST_CHECK(*val == SvcParam::alpn);
val++;
RecordTextReader rtr(source);
set<SvcParam> v;
rtr.xfrSvcParamKeyVals(v);
- BOOST_CHECK_EQUAL(v.size(), 1);
+ BOOST_CHECK_EQUAL(v.size(), 1U);
auto k = v.begin()->getKey();
BOOST_CHECK(k == SvcParam::no_default_alpn);
RecordTextReader rtr(source);
set<SvcParam> v;
rtr.xfrSvcParamKeyVals(v);
- BOOST_CHECK_EQUAL(v.size(), 1);
+ BOOST_CHECK_EQUAL(v.size(), 1U);
auto k = v.begin()->getKey();
BOOST_CHECK(k == SvcParam::ipv4hint);
auto val = v.begin()->getIPHints();
- BOOST_CHECK_EQUAL(val.size(), 1);
+ BOOST_CHECK_EQUAL(val.size(), 1U);
BOOST_CHECK_EQUAL(val.begin()->toString(), "192.0.2.1");
// Check the writer
source = "ipv4hint=192.0.2.1,192.0.2.2,192.0.2.3";
RecordTextReader rtr2(source);
rtr2.xfrSvcParamKeyVals(v);
- BOOST_CHECK_EQUAL(v.size(), 1);
+ BOOST_CHECK_EQUAL(v.size(), 1U);
k = v.begin()->getKey();
BOOST_CHECK(k == SvcParam::ipv4hint);
val = v.begin()->getIPHints();
- BOOST_CHECK_EQUAL(val.size(), 3);
+ BOOST_CHECK_EQUAL(val.size(), 3U);
auto valit = val.begin();
BOOST_CHECK_EQUAL(valit->toString(), "192.0.2.1");
valit++;
RecordTextReader rtr(source);
set<SvcParam> v;
rtr.xfrSvcParamKeyVals(v);
- BOOST_CHECK_EQUAL(v.size(), 1);
+ BOOST_CHECK_EQUAL(v.size(), 1U);
auto k = v.begin()->getKey();
BOOST_CHECK(k == SvcParam::ipv6hint);
auto val = v.begin()->getIPHints();
- BOOST_CHECK_EQUAL(val.size(), 1);
+ BOOST_CHECK_EQUAL(val.size(), 1U);
BOOST_CHECK_EQUAL(val.begin()->toString(), "2001:db8::1");
// Check the writer
source = "ipv6hint=2001:db8::1,2001:db8::2,2001:db8::3";
RecordTextReader rtr2(source);
rtr2.xfrSvcParamKeyVals(v);
- BOOST_CHECK_EQUAL(v.size(), 1);
+ BOOST_CHECK_EQUAL(v.size(), 1U);
k = v.begin()->getKey();
BOOST_CHECK(k == SvcParam::ipv6hint);
val = v.begin()->getIPHints();
- BOOST_CHECK_EQUAL(val.size(), 3);
+ BOOST_CHECK_EQUAL(val.size(), 3U);
auto valit = val.begin();
BOOST_CHECK_EQUAL(valit->toString(), "2001:db8::1");
valit++;
RecordTextReader rtr(source);
set<SvcParam> v;
rtr.xfrSvcParamKeyVals(v);
- BOOST_CHECK_EQUAL(v.size(), 1);
+ BOOST_CHECK_EQUAL(v.size(), 1U);
auto k = v.begin()->getKey();
BOOST_CHECK(k == SvcParam::port);
auto val = v.begin()->getPort();
RecordTextReader rtr(source);
set<SvcParam> v;
rtr.xfrSvcParamKeyVals(v);
- BOOST_CHECK_EQUAL(v.size(), 1);
+ BOOST_CHECK_EQUAL(v.size(), 1U);
auto k = v.begin()->getKey();
BOOST_CHECK(k == 666);
auto val = v.begin()->getValue();
source = "key666=\"blablabla\"";
RecordTextReader rtr4(source);
rtr4.xfrSvcParamKeyVals(v);
- BOOST_CHECK_EQUAL(v.size(), 1);
+ BOOST_CHECK_EQUAL(v.size(), 1U);
k = v.begin()->getKey();
BOOST_CHECK(k == SvcParam::keyFromString("key666"));
val = v.begin()->getValue();
RecordTextReader rtr("key666=foobar echconfig=\"dG90YWxseSBib2d1cyBlY2hjb25maWcgdmFsdWU=\" ipv6hint=2001:db8::1 alpn=h2,h3 mandatory=alpn ipv4hint=192.0.2.1,192.0.2.2"); // out of order, resulting set should be in-order
set<SvcParam> v;
rtr.xfrSvcParamKeyVals(v);
- BOOST_CHECK_EQUAL(v.size(), 6);
+ BOOST_CHECK_EQUAL(v.size(), 6U);
auto vit = v.begin();
// Check ordering
RecordTextReader rtr(source);
set<SvcParam> v;
rtr.xfrSvcParamKeyVals(v);
- BOOST_CHECK_EQUAL(v.size(), 1);
+ BOOST_CHECK_EQUAL(v.size(), 1U);
auto k = v.begin()->getKey();
BOOST_CHECK(k == SvcParam::echconfig);
auto val = v.begin()->getEchConfig();
BOOST_CHECK_EQUAL(source, target);
}
-BOOST_AUTO_TEST_SUITE_END()
\ No newline at end of file
+BOOST_AUTO_TEST_SUITE_END()
string::size_type pos = content.find_first_not_of("0123456789");
if(pos != string::npos)
boost::erase_head(content, pos);
- trim_left(content);
+ boost::trim_left(content);
}
Json::object dict;
string::size_type pos = content.find_first_not_of("0123456789");
if(pos != string::npos)
boost::erase_head(content, pos);
- trim_left(content);
+ boost::trim_left(content);
}
cout<<"insert into records (domain_id, name, type,content,ttl,prio,disabled) select id ,"<<
if(!getTemplateLine() && !getLine())
return false;
- boost::trim_right_if(d_line, is_any_of(" \t\r\n\x1a"));
+ boost::trim_right_if(d_line, boost::is_any_of(" \t\r\n\x1a"));
if(comment)
comment->clear();
if(comment && d_line.find(';') != string::npos)
if(d_line[0]=='$') {
string command=makeString(d_line, d_parts[0]);
if(pdns_iequals(command,"$TTL") && d_parts.size() > 1) {
- d_defaultttl=makeTTLFromZone(trim_right_copy_if(makeString(d_line, d_parts[1]), is_any_of(";")));
+ d_defaultttl=makeTTLFromZone(trim_right_copy_if(makeString(d_line, d_parts[1]), boost::is_any_of(";")));
d_havedollarttl=true;
}
else if(pdns_iequals(command,"$INCLUDE") && d_parts.size() > 1 && d_fromfile) {
// rr.content=d_line.substr(range.first);
rr.content.assign(d_line, range.first, string::npos);
chopComment(rr.content);
- trim_if(rr.content, is_any_of(" \r\n\t\x1a"));
+ trim_if(rr.content, boost::is_any_of(" \r\n\t\x1a"));
if(rr.content.size()==1 && rr.content[0]=='@')
rr.content=d_zonename.toString();
if(findAndElide(rr.content, '(')) { // have found a ( and elided it
if(!findAndElide(rr.content, ')')) {
while(getLine()) {
- trim_right(d_line);
+ boost::trim_right(d_line);
chopComment(d_line);
- trim(d_line);
+ boost::trim(d_line);
bool ended = findAndElide(d_line, ')');
rr.content+=" "+d_line;
}
}
}
- trim_if(rr.content, is_any_of(" \r\n\t\x1a"));
+ boost::trim_if(rr.content, boost::is_any_of(" \r\n\t\x1a"));
if (d_upgradeContent && DNSRecordContent::isUnknownType(qtypeString)) {
rr.content = DNSRecordContent::upgradeContent(rr.qname, rr.qtype, rr.content);
#include <cstdio>
#include <stdexcept>
#include <stack>
+#include <deque>
#include "namespaces.hh"
~ZoneParserTNG();
bool get(DNSResourceRecord& rr, std::string* comment=0);
typedef runtime_error exception;
- typedef deque<pair<string::size_type, string::size_type> > parts_t;
+ typedef
std::deque<pair<string::size_type, string::size_type> > parts_t;
DNSName getZoneName();
string getLineOfFile(); // for error reporting purposes
pair<string,int> getLineNumAndFile(); // idem
projects / thirdparty / pdns.git / commitdiff
