#include "dnscrypt.hh"
#ifdef HAVE_DNSCRYPT
-int handleDNSCryptQuery(PacketBuffer& packet, std::shared_ptr<DNSCryptQuery>& query, bool tcp, time_t now, PacketBuffer& response)
+int handleDNSCryptQuery(PacketBuffer& packet, DNSCryptQuery& query, bool tcp, time_t now, PacketBuffer& response)
{
- query->parsePacket(packet, tcp, now);
+ query.parsePacket(packet, tcp, now);
- if (query->isValid() == false) {
+ if (query.isValid() == false) {
vinfolog("Dropping DNSCrypt invalid query");
return false;
}
- if (query->isEncrypted() == false) {
- query->getCertificateResponse(now, response);
+ if (query.isEncrypted() == false) {
+ query.getCertificateResponse(now, response);
return false;
}
void start()
{
- if (gettime(&d_start, d_needRealTime) < 0) {
- unixDie("Getting timestamp");
- }
+ d_start = getCurrentTime();
}
void set(const struct timespec& from)
double udiff() const
{
- struct timespec now;
- if (gettime(&now, d_needRealTime) < 0) {
- unixDie("Getting timestamp");
- }
-
+ struct timespec now = getCurrentTime();
return 1000000.0 * (now.tv_sec - d_start.tv_sec) + (now.tv_nsec - d_start.tv_nsec) / 1000.0;
}
double udiffAndSet()
+ {
+ struct timespec now = getCurrentTime();
+ auto ret = 1000000.0 * (now.tv_sec - d_start.tv_sec) + (now.tv_nsec - d_start.tv_nsec) / 1000.0;
+ d_start = now;
+ return ret;
+ }
+
+ struct timespec getCurrentTime() const
{
struct timespec now;
if (gettime(&now, d_needRealTime) < 0) {
unixDie("Getting timestamp");
}
-
- auto ret = 1000000.0 * (now.tv_sec - d_start.tv_sec) + (now.tv_nsec - d_start.tv_nsec) / 1000.0;
- d_start = now;
- return ret;
+ return now;
}
struct timespec d_start
{
0, 0
};
-
private:
- bool d_needRealTime{false};
+ bool d_needRealTime;
};
/* g++ defines __SANITIZE_THREAD__
sentTime(true), tempFailureTTL(boost::none) { origDest.sin4.sin_family = 0; }
IDState(const IDState& orig) = delete;
IDState(IDState&& rhs) :
- subnet(rhs.subnet), origRemote(rhs.origRemote), origDest(rhs.origDest), hopRemote(rhs.hopRemote), hopLocal(rhs.hopLocal), qname(std::move(rhs.qname)), sentTime(rhs.sentTime), dnsCryptQuery(std::move(rhs.dnsCryptQuery)), packetCache(std::move(rhs.packetCache)), qTag(std::move(rhs.qTag)), tempFailureTTL(rhs.tempFailureTTL), cs(rhs.cs), du(std::move(rhs.du)), cacheKey(rhs.cacheKey), cacheKeyNoECS(rhs.cacheKeyNoECS), cacheKeyUDP(rhs.cacheKeyUDP), origFD(rhs.origFD), delayMsec(rhs.delayMsec), qtype(rhs.qtype), qclass(rhs.qclass), origID(rhs.origID), origFlags(rhs.origFlags), cacheFlags(rhs.cacheFlags), protocol(rhs.protocol), ednsAdded(rhs.ednsAdded), ecsAdded(rhs.ecsAdded), skipCache(rhs.skipCache), destHarvested(rhs.destHarvested), dnssecOK(rhs.dnssecOK), useZeroScope(rhs.useZeroScope)
+ subnet(rhs.subnet), origRemote(rhs.origRemote), origDest(rhs.origDest), hopRemote(rhs.hopRemote), hopLocal(rhs.hopLocal), qname(std::move(rhs.qname)), sentTime(rhs.sentTime), packetCache(std::move(rhs.packetCache)), dnsCryptQuery(std::move(rhs.dnsCryptQuery)), qTag(std::move(rhs.qTag)), tempFailureTTL(rhs.tempFailureTTL), cs(rhs.cs), du(std::move(rhs.du)), cacheKey(rhs.cacheKey), cacheKeyNoECS(rhs.cacheKeyNoECS), cacheKeyUDP(rhs.cacheKeyUDP), origFD(rhs.origFD), delayMsec(rhs.delayMsec), qtype(rhs.qtype), qclass(rhs.qclass), origID(rhs.origID), origFlags(rhs.origFlags), cacheFlags(rhs.cacheFlags), protocol(rhs.protocol), ednsAdded(rhs.ednsAdded), ecsAdded(rhs.ecsAdded), skipCache(rhs.skipCache), destHarvested(rhs.destHarvested), dnssecOK(rhs.dnssecOK), useZeroScope(rhs.useZeroScope)
{
if (rhs.isInUse()) {
throw std::runtime_error("Trying to move an in-use IDState");
ComboAddress hopLocal;
DNSName qname; // 24
StopWatch sentTime; // 16
- std::shared_ptr<DNSCryptQuery> dnsCryptQuery{nullptr}; // 16
std::shared_ptr<DNSDistPacketCache> packetCache{nullptr}; // 16
- std::shared_ptr<QTag> qTag{nullptr}; // 16
+ std::unique_ptr<DNSCryptQuery> dnsCryptQuery{nullptr}; // 8
+ std::unique_ptr<QTag> qTag{nullptr}; // 8
boost::optional<uint32_t> tempFailureTTL; // 8
const ClientState* cs{nullptr}; // 8
DOHUnit* du{nullptr}; // 8
struct timespec queryRealTime;
gettime(&queryRealTime, true);
- std::shared_ptr<DNSCryptQuery> dnsCryptQuery{nullptr};
+ std::unique_ptr<DNSCryptQuery> dnsCryptQuery{nullptr};
auto dnsCryptResponse = checkDNSCryptQuery(*state->d_ci.cs, state->d_buffer, dnsCryptQuery, queryRealTime.tv_sec, true);
if (dnsCryptResponse) {
TCPResponse response;
}
#ifdef HAVE_DNSCRYPT
-static bool encryptResponse(PacketBuffer& response, size_t maximumSize, bool tcp, std::shared_ptr<DNSCryptQuery> dnsCryptQuery)
+static bool encryptResponse(PacketBuffer& response, size_t maximumSize, bool tcp, std::unique_ptr<DNSCryptQuery>& dnsCryptQuery)
{
if (dnsCryptQuery) {
int res = dnsCryptQuery->encryptResponse(response, maximumSize, tcp);
return true;
}
-bool checkDNSCryptQuery(const ClientState& cs, PacketBuffer& query, std::shared_ptr<DNSCryptQuery>& dnsCryptQuery, time_t now, bool tcp)
+bool checkDNSCryptQuery(const ClientState& cs, PacketBuffer& query, std::unique_ptr<DNSCryptQuery>& dnsCryptQuery, time_t now, bool tcp)
{
if (cs.dnscryptCtx) {
#ifdef HAVE_DNSCRYPT
PacketBuffer response;
- dnsCryptQuery = std::make_shared<DNSCryptQuery>(cs.dnscryptCtx);
+ dnsCryptQuery = std::make_unique<DNSCryptQuery>(cs.dnscryptCtx);
- bool decrypted = handleDNSCryptQuery(query, dnsCryptQuery, tcp, now, response);
+ bool decrypted = handleDNSCryptQuery(query, *dnsCryptQuery, tcp, now, response);
if (!decrypted) {
if (response.size() > 0) {
DNSResponse dr(dq.qname, dq.qtype, dq.qclass, dq.local, dq.remote, dq.getMutableData(), dq.protocol, dq.queryTime);
dr.uniqueId = dq.uniqueId;
- dr.qTag = dq.qTag;
+ dr.qTag = std::move(dq.qTag);
dr.delayMsec = dq.delayMsec;
if (!applyRulesToResponse(cacheHit ? holders.cacheHitRespRuleactions : holders.selfAnsweredRespRuleactions, dr)) {
struct timespec queryRealTime;
gettime(&queryRealTime, true);
- std::shared_ptr<DNSCryptQuery> dnsCryptQuery = nullptr;
+ std::unique_ptr<DNSCryptQuery> dnsCryptQuery = nullptr;
auto dnsCryptResponse = checkDNSCryptQuery(cs, query, dnsCryptQuery, queryRealTime.tv_sec, false);
if (dnsCryptResponse) {
sendUDPResponse(cs.udpFD, query, 0, dest, remote);
void setTag(const std::string& key, std::string&& value) {
if (!qTag) {
- qTag = std::make_shared<QTag>();
+ qTag = std::make_unique<QTag>();
}
qTag->insert_or_assign(key, std::move(value));
}
void setTag(const std::string& key, const std::string& value) {
if (!qTag) {
- qTag = std::make_shared<QTag>();
+ qTag = std::make_unique<QTag>();
}
qTag->insert_or_assign(key, value);
}
boost::optional<Netmask> subnet;
std::string sni; /* Server Name Indication, if any (DoT or DoH) */
std::string poolname;
+ mutable std::shared_ptr<std::map<uint16_t, EDNSOptionView> > ednsOptions;
+ std::shared_ptr<DNSDistPacketCache> packetCache{nullptr};
const DNSName* qname{nullptr};
const ComboAddress* local{nullptr};
const ComboAddress* remote{nullptr};
is enabled */
const ComboAddress* hopLocal{nullptr}; /* the address dnsdist received the packet from, see above */
const ComboAddress* hopRemote{nullptr};
- std::shared_ptr<QTag> qTag{nullptr};
+ std::unique_ptr<QTag> qTag{nullptr};
std::unique_ptr<std::vector<ProxyProtocolValue>> proxyProtocolValues{nullptr};
- mutable std::shared_ptr<std::map<uint16_t, EDNSOptionView> > ednsOptions;
- std::shared_ptr<DNSCryptQuery> dnsCryptQuery{nullptr};
- std::shared_ptr<DNSDistPacketCache> packetCache{nullptr};
+ std::unique_ptr<DNSCryptQuery> dnsCryptQuery{nullptr};
const struct timespec* queryTime{nullptr};
struct DOHUnit* du{nullptr};
int delayMsec{0};
struct ClientState
{
- ClientState(const ComboAddress& local_, bool isTCP_, bool doReusePort, int fastOpenQueue, const std::string& itfName, const std::set<int>& cpus_): cpus(cpus_), local(local_), interface(itfName), fastOpenQueueSize(fastOpenQueue), tcp(isTCP_), reuseport(doReusePort)
+ ClientState(const ComboAddress& local_, bool isTCP_, bool doReusePort, int fastOpenQueue, const std::string& itfName, const std::set<int>& cpus_): cpus(cpus_), interface(itfName), local(local_), fastOpenQueueSize(fastOpenQueue), tcp(isTCP_), reuseport(doReusePort)
{
}
- std::set<int> cpus;
- ComboAddress local;
- std::shared_ptr<DNSCryptContext> dnscryptCtx{nullptr};
- std::shared_ptr<TLSFrontend> tlsFrontend{nullptr};
- std::shared_ptr<DOHFrontend> dohFrontend{nullptr};
- std::string interface;
stat_t queries{0};
mutable stat_t responses{0};
mutable stat_t tcpDiedReadingQuery{0};
pdns::stat_t_trait<double> tcpAvgQueriesPerConnection{0.0};
/* in ms */
pdns::stat_t_trait<double> tcpAvgConnectionDuration{0.0};
+ std::set<int> cpus;
+ std::string interface;
+ ComboAddress local;
+ std::shared_ptr<DNSCryptContext> dnscryptCtx{nullptr};
+ std::shared_ptr<TLSFrontend> tlsFrontend{nullptr};
+ std::shared_ptr<DOHFrontend> dohFrontend{nullptr};
+ std::shared_ptr<BPFFilter> d_filter{nullptr};
size_t d_maxInFlightQueriesPerConn{1};
size_t d_tcpConcurrentConnectionsLimit{0};
int udpFD{-1};
return result;
}
- shared_ptr<BPFFilter> d_filter;
-
void detachFilter()
{
if (d_filter) {
DownstreamState(const ComboAddress& remote_): DownstreamState(remote_, ComboAddress(), 0, std::string(), 1, true) {}
~DownstreamState();
- boost::uuids::uuid id;
- SharedLockGuarded<std::vector<unsigned int>> hashes;
- std::vector<int> sockets;
- const std::string sourceItfName;
- std::string d_tlsSubjectName;
- std::string d_dohPath;
- std::mutex connectLock;
- LockGuarded<std::unique_ptr<FDMultiplexer>> mplexer{nullptr};
- std::shared_ptr<TLSCtx> d_tlsCtx{nullptr};
- std::thread tid;
- const ComboAddress remote;
- QPSLimiter qps;
- vector<IDState> idStates;
- const ComboAddress sourceAddr;
- checkfunc_t checkFunction;
- DNSName checkName{"a.root-servers.net."};
- QType checkType{QType::A};
- uint16_t checkClass{QClass::IN};
- std::atomic<uint64_t> idOffset{0};
- std::atomic<bool> hashesComputed{false};
stat_t sendErrors{0};
stat_t outstanding{0};
stat_t reuseds{0};
pdns::stat_t_trait<double> tcpAvgQueriesPerConnection{0.0};
/* in ms */
pdns::stat_t_trait<double> tcpAvgConnectionDuration{0.0};
+ pdns::stat_t_trait<double> queryLoad{0.0};
+ pdns::stat_t_trait<double> dropRate{0.0};
+ boost::uuids::uuid id;
+ const ComboAddress remote;
+ const ComboAddress sourceAddr;
+ SharedLockGuarded<std::vector<unsigned int>> hashes;
+ LockGuarded<std::unique_ptr<FDMultiplexer>> mplexer{nullptr};
+ const std::string sourceItfName;
+ std::string d_tlsSubjectName;
+ std::string d_dohPath;
+private:
+ std::string name;
+ std::string nameWithAddr;
+public:
+ std::shared_ptr<TLSCtx> d_tlsCtx{nullptr};
+ std::vector<int> sockets;
+ vector<IDState> idStates;
+ set<string> pools;
+ std::mutex connectLock;
+ std::thread tid;
+ checkfunc_t checkFunction;
+ DNSName checkName{"a.root-servers.net."};
+ StopWatch sw;
+ QPSLimiter qps;
+ std::atomic<uint64_t> idOffset{0};
size_t socketsOffset{0};
size_t d_maxInFlightQueriesPerConn{1};
size_t d_tcpConcurrentConnectionsLimit{0};
- pdns::stat_t_trait<double> queryLoad{0.0};
- pdns::stat_t_trait<double> dropRate{0.0};
double latencyUsec{0.0};
double latencyUsecTCP{0.0};
int order{1};
unsigned int checkInterval{1};
unsigned int lastCheck{0};
const unsigned int sourceItf{0};
+ QType checkType{QType::A};
+ uint16_t checkClass{QClass::IN};
uint16_t d_retries{5};
uint16_t xpfRRCode{0};
uint16_t checkTimeout{1000}; /* in milliseconds */
uint8_t consecutiveSuccessfulChecks{0};
uint8_t maxCheckFailures{1};
uint8_t minRiseSuccesses{1};
- StopWatch sw;
- set<string> pools;
enum class Availability : uint8_t { Up, Down, Auto} availability{Availability::Auto};
+private:
+ bool d_stopped{false};
+public:
+ std::atomic<bool> hashesComputed{false};
bool mustResolve{false};
bool upStatus{false};
bool useECS{false};
}
return dnsdist::Protocol::DoUDP;
}
-private:
- std::string name;
- std::string nameWithAddr;
- bool d_stopped{false};
};
using servers_t =vector<std::shared_ptr<DownstreamState>>;
bool checkQueryHeaders(const struct dnsheader* dh);
extern std::vector<std::shared_ptr<DNSCryptContext>> g_dnsCryptLocals;
-int handleDNSCryptQuery(PacketBuffer& packet, std::shared_ptr<DNSCryptQuery>& query, bool tcp, time_t now, PacketBuffer& response);
-bool checkDNSCryptQuery(const ClientState& cs, PacketBuffer& query, std::shared_ptr<DNSCryptQuery>& dnsCryptQuery, time_t now, bool tcp);
+int handleDNSCryptQuery(PacketBuffer& packet, DNSCryptQuery& query, bool tcp, time_t now, PacketBuffer& response);
+bool checkDNSCryptQuery(const ClientState& cs, PacketBuffer& query, std::unique_ptr<DNSCryptQuery>& dnsCryptQuery, time_t now, bool tcp);
uint16_t getRandomDNSID();
}
}
-DownstreamState::DownstreamState(const ComboAddress& remote_, const ComboAddress& sourceAddr_, unsigned int sourceItf_, const std::string& sourceItfName_, size_t numberOfSockets, bool connect): sourceItfName(sourceItfName_), remote(remote_), idStates(connect ? g_maxOutstanding : 0), sourceAddr(sourceAddr_), sourceItf(sourceItf_), name(remote_.toStringWithPort()), nameWithAddr(remote_.toStringWithPort())
+DownstreamState::DownstreamState(const ComboAddress& remote_, const ComboAddress& sourceAddr_, unsigned int sourceItf_, const std::string& sourceItfName_, size_t numberOfSockets, bool connect): remote(remote_), sourceAddr(sourceAddr_), sourceItfName(sourceItfName_), name(remote_.toStringWithPort()), nameWithAddr(remote_.toStringWithPort()), idStates(connect ? g_maxOutstanding : 0), sourceItf(sourceItf_)
{
id = getUniqueID();
threadStarted.clear();
ids.ednsAdded = dq.ednsAdded;
ids.ecsAdded = dq.ecsAdded;
ids.useZeroScope = dq.useZeroScope;
- ids.qTag = dq.qTag;
+ ids.qTag = std::move(dq.qTag);
ids.dnssecOK = dq.dnssecOK;
ids.uniqueId = std::move(dq.uniqueId);
static const std::unordered_map<std::string, std::string> s_constants;
- std::unique_ptr<nghttp2_session, void (*)(nghttp2_session*)> d_session{nullptr, nghttp2_session_del};
std::unordered_map<int32_t, PendingRequest> d_currentStreams;
+ std::string d_proxyProtocolPayload;
PacketBuffer d_out;
PacketBuffer d_in;
- std::string d_proxyProtocolPayload;
+ std::unique_ptr<nghttp2_session, void (*)(nghttp2_session*)> d_session{nullptr, nghttp2_session_del};
size_t d_outPos{0};
size_t d_inPos{0};
uint32_t d_highestStreamID{0};
class TCPConnectionToBackend : public std::enable_shared_from_this<TCPConnectionToBackend>
{
public:
- TCPConnectionToBackend(std::shared_ptr<DownstreamState>& ds, std::unique_ptr<FDMultiplexer>& mplexer, const struct timeval& now): d_responseBuffer(s_maxPacketCacheEntrySize), d_mplexer(mplexer), d_ds(ds), d_connectionStartTime(now), d_lastDataReceivedTime(now), d_enableFastOpen(ds->tcpFastOpen)
+ TCPConnectionToBackend(std::shared_ptr<DownstreamState>& ds, std::unique_ptr<FDMultiplexer>& mplexer, const struct timeval& now): d_connectionStartTime(now), d_lastDataReceivedTime(now), d_ds(ds), d_responseBuffer(s_maxPacketCacheEntrySize), d_mplexer(mplexer), d_enableFastOpen(ds->tcpFastOpen)
{
reconnect();
}
return res;
}
- PacketBuffer d_responseBuffer;
+ TCPQuery d_currentQuery;
std::deque<TCPQuery> d_pendingQueries;
std::unordered_map<uint16_t, TCPQuery> d_pendingResponses;
+ struct timeval d_connectionStartTime;
+ struct timeval d_lastDataReceivedTime;
+ std::shared_ptr<DownstreamState> d_ds{nullptr};
+ std::shared_ptr<TCPQuerySender> d_sender{nullptr};
+ PacketBuffer d_responseBuffer;
std::unique_ptr<FDMultiplexer>& d_mplexer;
std::unique_ptr<std::vector<ProxyProtocolValue>> d_proxyProtocolValuesSent{nullptr};
std::unique_ptr<TCPIOHandler> d_handler{nullptr};
std::unique_ptr<IOStateHandler> d_ioState{nullptr};
- std::shared_ptr<DownstreamState> d_ds{nullptr};
- std::shared_ptr<TCPQuerySender> d_sender{nullptr};
- TCPQuery d_currentQuery;
- struct timeval d_connectionStartTime;
- struct timeval d_lastDataReceivedTime;
size_t d_currentPos{0};
uint64_t d_queries{0};
uint64_t d_downstreamFailures{0};
class IncomingTCPConnectionState : public TCPQuerySender, public std::enable_shared_from_this<IncomingTCPConnectionState>
{
public:
- IncomingTCPConnectionState(ConnectionInfo&& ci, TCPClientThreadData& threadData, const struct timeval& now): d_buffer(s_maxPacketCacheEntrySize), d_threadData(threadData), d_ci(std::move(ci)), d_handler(d_ci.fd, timeval{g_tcpRecvTimeout,0}, d_ci.cs->tlsFrontend ? d_ci.cs->tlsFrontend->getContext() : nullptr, now.tv_sec), d_ioState(make_unique<IOStateHandler>(*threadData.mplexer, d_ci.fd)), d_connectionStartTime(now)
+ IncomingTCPConnectionState(ConnectionInfo&& ci, TCPClientThreadData& threadData, const struct timeval& now): d_buffer(s_maxPacketCacheEntrySize), d_ci(std::move(ci)), d_handler(d_ci.fd, timeval{g_tcpRecvTimeout,0}, d_ci.cs->tlsFrontend ? d_ci.cs->tlsFrontend->getContext() : nullptr, now.tv_sec), d_connectionStartTime(now), d_ioState(make_unique<IOStateHandler>(*threadData.mplexer, d_ci.fd)), d_threadData(threadData)
{
d_origDest.reset();
d_origDest.sin4.sin_family = d_ci.remote.sin4.sin_family;
return o.str();
}
- enum class State { doingHandshake, readingProxyProtocolHeader, waitingForQuery, readingQuerySize, readingQuery, sendingResponse, idle /* in case of XFR, we stop processing queries */ };
+ enum class State : uint8_t { doingHandshake, readingProxyProtocolHeader, waitingForQuery, readingQuerySize, readingQuery, sendingResponse, idle /* in case of XFR, we stop processing queries */ };
+ TCPResponse d_currentResponse;
std::map<std::shared_ptr<DownstreamState>, std::deque<std::shared_ptr<TCPConnectionToBackend>>> d_activeConnectionsToBackend;
- PacketBuffer d_buffer;
std::deque<TCPResponse> d_queuedResponses;
- TCPClientThreadData& d_threadData;
- TCPResponse d_currentResponse;
+ PacketBuffer d_buffer;
ConnectionInfo d_ci;
ComboAddress d_origDest;
ComboAddress d_proxiedRemote;
ComboAddress d_proxiedDestination;
TCPIOHandler d_handler;
- std::unique_ptr<IOStateHandler> d_ioState{nullptr};
- std::unique_ptr<std::vector<ProxyProtocolValue>> d_proxyProtocolValues{nullptr};
struct timeval d_connectionStartTime;
struct timeval d_handshakeDoneTime;
struct timeval d_firstQuerySizeReadTime;
struct timeval d_querySizeReadTime;
struct timeval d_queryReadTime;
+ std::unique_ptr<IOStateHandler> d_ioState{nullptr};
+ std::unique_ptr<std::vector<ProxyProtocolValue>> d_proxyProtocolValues{nullptr};
+ TCPClientThreadData& d_threadData;
size_t d_currentPos{0};
size_t d_proxyProtocolNeed{0};
size_t d_queriesCount{0};
}
InternalQuery(InternalQuery&& rhs) :
- d_idstate(std::move(rhs.d_idstate)), d_buffer(std::move(rhs.d_buffer)), d_proxyProtocolPayload(std::move(rhs.d_proxyProtocolPayload)), d_xfrMasterSerial(rhs.d_xfrMasterSerial), d_xfrSerialCount(rhs.d_xfrSerialCount), d_downstreamFailures(rhs.d_downstreamFailures), d_xfrMasterSerialCount(rhs.d_xfrMasterSerialCount), d_proxyProtocolPayloadAdded(rhs.d_proxyProtocolPayloadAdded)
+ d_idstate(std::move(rhs.d_idstate)), d_proxyProtocolPayload(std::move(rhs.d_proxyProtocolPayload)), d_buffer(std::move(rhs.d_buffer)), d_xfrMasterSerial(rhs.d_xfrMasterSerial), d_xfrSerialCount(rhs.d_xfrSerialCount), d_downstreamFailures(rhs.d_downstreamFailures), d_xfrMasterSerialCount(rhs.d_xfrMasterSerialCount), d_proxyProtocolPayloadAdded(rhs.d_proxyProtocolPayloadAdded)
{
}
InternalQuery& operator=(InternalQuery&& rhs)
}
IDState d_idstate;
- PacketBuffer d_buffer;
std::string d_proxyProtocolPayload;
+ PacketBuffer d_buffer;
uint32_t d_xfrMasterSerial{0};
uint32_t d_xfrSerialCount{0};
uint32_t d_downstreamFailures{0};
// outside of the main DoH thread
return -1;
}
- remote = du->remote;
+ remote = du->ids.origRemote;
DOHServerConfig* dsc = du->dsc;
auto& holders = dsc->holders;
ClientState& cs = *dsc->cs;
uint16_t qtype, qclass;
unsigned int qnameWireLength = 0;
DNSName qname(reinterpret_cast<const char*>(du->query.data()), du->query.size(), sizeof(dnsheader), false, &qtype, &qclass, &qnameWireLength);
- DNSQuestion dq(&qname, qtype, qclass, &du->dest, &du->remote, du->query, dnsdist::Protocol::DoH, &queryRealTime);
- dq.ednsAdded = du->ednsAdded;
+ DNSQuestion dq(&qname, qtype, qclass, &du->ids.origDest, &du->ids.origRemote, du->query, dnsdist::Protocol::DoH, &queryRealTime);
+ dq.ednsAdded = du->ids.ednsAdded;
dq.du = du;
dq.sni = std::move(du->sni);
}
}
- ComboAddress dest = du->dest;
+ ComboAddress dest = du->ids.origDest;
unsigned int idOffset = (du->downstream->idOffset++) % du->downstream->idStates.size();
IDState* ids = &du->downstream->idStates[idOffset];
ids->age = 0;
auto du = std::unique_ptr<DOHUnit>(new DOHUnit);
du->dsc = dsc;
du->req = req;
- du->dest = local;
- du->remote = remote;
+ du->ids.origDest = local;
+ du->ids.origRemote = remote;
du->rsock = dsc->dohresponsepair[0];
du->query = std::move(query);
du->path = std::move(path);
if (generateOptRR(std::string(), du->query, 4096, 4096, 0, false)) {
dh = const_cast<struct dnsheader*>(reinterpret_cast<const struct dnsheader*>(du->query.data())); // may have reallocated
dh->arcount = htons(1);
- du->ednsAdded = true;
+ du->ids.ednsAdded = true;
}
}
else {
QueryCount g_qcount;
-bool checkDNSCryptQuery(const ClientState& cs, PacketBuffer& query, std::shared_ptr<DNSCryptQuery>& dnsCryptQuery, time_t now, bool tcp)
+bool checkDNSCryptQuery(const ClientState& cs, PacketBuffer& query, std::unique_ptr<DNSCryptQuery>& dnsCryptQuery, time_t now, bool tcp)
{
return false;
}
{
DOHUnit()
{
+ ids.ednsAdded = false;
}
DOHUnit(const DOHUnit&) = delete;
DOHUnit& operator=(const DOHUnit&) = delete;
void handleUDPResponse(PacketBuffer&& response, IDState&& state);
- std::vector<std::pair<std::string, std::string>> headers;
- PacketBuffer query;
- PacketBuffer response;
IDState ids;
std::string sni;
std::string path;
std::string scheme;
std::string host;
- ComboAddress remote;
- ComboAddress dest;
+ std::string contentType;
+ std::vector<std::pair<std::string, std::string>> headers;
+ PacketBuffer query;
+ PacketBuffer response;
+ std::shared_ptr<DownstreamState> downstream{nullptr};
st_h2o_req_t* req{nullptr};
DOHUnit** self{nullptr};
DOHServerConfig* dsc{nullptr};
- std::shared_ptr<DownstreamState> downstream{nullptr};
- std::string contentType;
std::atomic<uint64_t> d_refcnt{1};
size_t query_at{0};
size_t proxyProtocolPayloadSize{0};
the main DoH thread.
*/
uint16_t status_code{200};
- bool ednsAdded{false};
/* whether the query was re-sent to the backend over
TCP after receiving a truncated answer over UDP */
bool tcp{false};
projects / thirdparty / pdns.git / commitdiff
