7222382716

Committed 15 Dec 2023 01:02PM UTC coverage: 57.703% (-0.007%) from 57.71%

Build # 7222382716

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #13566 from omoerbeek/rec-qperq-limit

rec: lower default max-qperq limit.

Run Details

31973 of 86758 branches covered (0.0%)

Branch coverage included in aggregate %.

2 of 2 new or added lines in 1 file covered. (100.0%)

46 existing lines in 9 files now uncovered.

107601 of 155126 relevant lines covered (69.36%)

4227195.46 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

81.63

/pdns/stubresolver.cc

#include <sys/stat.h>

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "logger.hh"
#include "arguments.hh"
#include "version.hh"
#include "misc.hh"

#include "sstuff.hh"
#include "dnswriter.hh"
#include "dns_random.hh"
#include "namespaces.hh"
#include "statbag.hh"
#include "stubresolver.hh"

#define LOCAL_RESOLV_CONF_PATH "/etc/resolv.conf"
// don't stat() for local resolv.conf more than once every INTERVAL secs.
#define LOCAL_RESOLV_CONF_MAX_CHECK_INTERVAL 60

// s_resolversForStub contains the ComboAddresses that are used by
// stubDoResolve
static SharedLockGuarded<vector<ComboAddress>> s_resolversForStub;
static bool s_stubResolvConfigured = false;

// /etc/resolv.conf last modification time
static time_t s_localResolvConfMtime = 0;
static time_t s_localResolvConfLastCheck = 0;

static string logPrefix = "[stub-resolver] ";

/*
 * Returns false if no resolvers are configured, while emitting a warning about this
 */
bool resolversDefined()
{
  if (s_resolversForStub.read_lock()->empty()) {
    g_log<<Logger::Warning<<logPrefix<<"No upstream resolvers configured, stub resolving (including secpoll and ALIAS) impossible."<<endl;
    return false;
  }
  return true;
}

/*
 * Parse /etc/resolv.conf and add those nameservers to s_resolversForStub
 */
static void parseLocalResolvConf_locked(vector<ComboAddress>& resolversForStub, const time_t& now)
{
  struct stat st;
  s_localResolvConfLastCheck = now;

  if (stat(LOCAL_RESOLV_CONF_PATH, &st) != -1) {
    if (st.st_mtime != s_localResolvConfMtime) {
      std::vector<ComboAddress> resolvers = getResolvers(LOCAL_RESOLV_CONF_PATH);

      s_localResolvConfMtime = st.st_mtime;

      if (resolvers.empty()) {
        return;
      }

      resolversForStub = std::move(resolvers);
    }
  }
}

static void parseLocalResolvConf()
{
  const time_t now = time(nullptr);
  if ((s_localResolvConfLastCheck + LOCAL_RESOLV_CONF_MAX_CHECK_INTERVAL) > now)
    return ;

  parseLocalResolvConf_locked(*(s_resolversForStub.write_lock()), now);
}


/*
 * Fill the s_resolversForStub vector with addresses for the upstream resolvers.
 * First, parse the `resolver` configuration option for IP addresses to use.
 * If that doesn't work, parse /etc/resolv.conf and add those nameservers to
 * s_resolversForStub.
 *
 * mainthread() calls this so you don't have to.
 */
void stubParseResolveConf()
{
  if(::arg().mustDo("resolver")) {
    auto resolversForStub = s_resolversForStub.write_lock();
    vector<string> parts;
    stringtok(parts, ::arg()["resolver"], " ,\t");
    for (const auto& addr : parts)
      resolversForStub->push_back(ComboAddress(addr, 53));
  }

  if (s_resolversForStub.read_lock()->empty()) {
    parseLocalResolvConf();
  }
  // Emit a warning if there are no stubs.
  resolversDefined();
  s_stubResolvConfigured = true;
}

// s_resolversForStub contains the ComboAddresses that are used to resolve the
int stubDoResolve(const DNSName& qname, uint16_t qtype, vector<DNSZoneRecord>& ret)
{
  // ensure resolver gets always configured
  if (!s_stubResolvConfigured) {
    stubParseResolveConf();
  }
  // only check if resolvers come from local resolv.conf in the first place
  if (s_localResolvConfMtime != 0) {
        parseLocalResolvConf();
  }
  if (!resolversDefined())
    return RCode::ServFail;

  auto resolversForStub = s_resolversForStub.read_lock();
  vector<uint8_t> packet;

  DNSPacketWriter pw(packet, qname, qtype);
  pw.getHeader()->id=dns_random_uint16();
  pw.getHeader()->rd=1;

  string queryNameType = qname.toString() + "|" + QType(qtype).toString();
  string msg ="Doing stub resolving for '" + queryNameType + "', using resolvers: ";
  for (const auto& server : *resolversForStub) {
    msg += server.toString() + ", ";
  }
  g_log<<Logger::Debug<<logPrefix<<msg.substr(0, msg.length() - 2)<<endl;

  for(const ComboAddress& dest : *resolversForStub) {
    Socket sock(dest.sin4.sin_family, SOCK_DGRAM);
    sock.setNonBlocking();
    sock.connect(dest);
    sock.send(string(packet.begin(), packet.end()));

    string reply;

    // error handled after this
    (void)waitForData(sock.getHandle(), 2, 0);
    try {
    retry:
      sock.read(reply); // this calls recv
      if(reply.size() > sizeof(struct dnsheader)) {
        struct dnsheader d;
        memcpy(&d, reply.c_str(), sizeof(d));
        if(d.id != pw.getHeader()->id)
          goto retry;
      }
    }
    catch(...) {
      continue;
    }
    MOADNSParser mdp(false, reply);
    if(mdp.d_header.rcode == RCode::ServFail)
      continue;

    for(const auto & answer : mdp.d_answers) {
      if(answer.first.d_place == 1 && answer.first.d_type==qtype) {
        DNSZoneRecord zrr;
        zrr.dr = answer.first;
        zrr.auth=true;
        ret.push_back(zrr);
      }
    }
    g_log<<Logger::Debug<<logPrefix<<"Question for '"<<queryNameType<<"' got answered by "<<dest.toString()<<endl;
    return mdp.d_header.rcode;
  }
  return RCode::ServFail;
}

int stubDoResolve(const DNSName& qname, uint16_t qtype, vector<DNSRecord>& ret) {
  vector<DNSZoneRecord> ret2;
  int res = stubDoResolve(qname, qtype, ret2);
  for (const auto &r : ret2) {
    ret.push_back(r.dr);
  }
  return res;
}

1	#include <sys/stat.h>
2
3	#ifdef HAVE_CONFIG_H
4	#include "config.h"
5	#endif
6
7	#include "logger.hh"
8	#include "arguments.hh"
9	#include "version.hh"
10	#include "misc.hh"
11
12	#include "sstuff.hh"
13	#include "dnswriter.hh"
14	#include "dns_random.hh"
15	#include "namespaces.hh"
16	#include "statbag.hh"
17	#include "stubresolver.hh"
18
19	#define LOCAL_RESOLV_CONF_PATH "/etc/resolv.conf"	118✔
20	// don't stat() for local resolv.conf more than once every INTERVAL secs.
21	#define LOCAL_RESOLV_CONF_MAX_CHECK_INTERVAL 60	118✔
22
23	// s_resolversForStub contains the ComboAddresses that are used by
24	// stubDoResolve
25	static SharedLockGuarded<vector<ComboAddress>> s_resolversForStub;
26	static bool s_stubResolvConfigured = false;
27
28	// /etc/resolv.conf last modification time
29	static time_t s_localResolvConfMtime = 0;
30	static time_t s_localResolvConfLastCheck = 0;
31
32	static string logPrefix = "[stub-resolver] ";
33
34	/*
35	* Returns false if no resolvers are configured, while emitting a warning about this
36	*/
37	bool resolversDefined()
38	{	344✔
39	if (s_resolversForStub.read_lock()->empty()) {	344!
40	g_log<<Logger::Warning<<logPrefix<<"No upstream resolvers configured, stub resolving (including secpoll and ALIAS) impossible."<<endl;	×
41	return false;	×
42	}	×
43	return true;	344✔
44	}	344✔
45
46	/*
47	* Parse /etc/resolv.conf and add those nameservers to s_resolversForStub
48	*/
49	static void parseLocalResolvConf_locked(vector<ComboAddress>& resolversForStub, const time_t& now)
50	{	59✔
51	struct stat st;	59✔
52	s_localResolvConfLastCheck = now;	59✔
53
54	if (stat(LOCAL_RESOLV_CONF_PATH, &st) != -1) {	59!
55	if (st.st_mtime != s_localResolvConfMtime) {	59!
56	std::vector<ComboAddress> resolvers = getResolvers(LOCAL_RESOLV_CONF_PATH);	59✔
57
58	s_localResolvConfMtime = st.st_mtime;	59✔
59
60	if (resolvers.empty()) {	59!
61	return;	×
62	}	×
63
64	resolversForStub = std::move(resolvers);	59✔
65	}	59✔
66	}	59✔
67	}	59✔
68
69	static void parseLocalResolvConf()
70	{	118✔
71	const time_t now = time(nullptr);	118✔
72	if ((s_localResolvConfLastCheck + LOCAL_RESOLV_CONF_MAX_CHECK_INTERVAL) > now)	118✔
73	return ;	59✔
74
75	parseLocalResolvConf_locked(*(s_resolversForStub.write_lock()), now);	59✔
76	}	59✔
77
78
79	/*
80	* Fill the s_resolversForStub vector with addresses for the upstream resolvers.
81	* First, parse the `resolver` configuration option for IP addresses to use.
82	* If that doesn't work, parse /etc/resolv.conf and add those nameservers to
83	* s_resolversForStub.
84	*
85	* mainthread() calls this so you don't have to.
86	*/
87	void stubParseResolveConf()
88	{	96✔
89	if(::arg().mustDo("resolver")) {	96✔
90	auto resolversForStub = s_resolversForStub.write_lock();	37✔
91	vector<string> parts;	37✔
92	stringtok(parts, ::arg()["resolver"], " ,\t");	37✔
93	for (const auto& addr : parts)	37✔
94	resolversForStub->push_back(ComboAddress(addr, 53));	37✔
95	}	37✔
96
97	if (s_resolversForStub.read_lock()->empty()) {	96✔
98	parseLocalResolvConf();	59✔
99	}	59✔
100	// Emit a warning if there are no stubs.
101	resolversDefined();	96✔
102	s_stubResolvConfigured = true;	96✔
103	}	96✔
104
105	// s_resolversForStub contains the ComboAddresses that are used to resolve the
106	int stubDoResolve(const DNSName& qname, uint16_t qtype, vector<DNSZoneRecord>& ret)
107	{	248✔
108	// ensure resolver gets always configured
109	if (!s_stubResolvConfigured) {	248!
110	stubParseResolveConf();	×
111	}	×
112	// only check if resolvers come from local resolv.conf in the first place
113	if (s_localResolvConfMtime != 0) {	248✔
114	parseLocalResolvConf();	59✔
115	}	59✔
116	if (!resolversDefined())	248!
117	return RCode::ServFail;	×
118
119	auto resolversForStub = s_resolversForStub.read_lock();	248✔
120	vector<uint8_t> packet;	248✔
121
122	DNSPacketWriter pw(packet, qname, qtype);	248✔
123	pw.getHeader()->id=dns_random_uint16();	248✔
124	pw.getHeader()->rd=1;	248✔
125
126	string queryNameType = qname.toString() + "\|" + QType(qtype).toString();	248✔
127	string msg ="Doing stub resolving for '" + queryNameType + "', using resolvers: ";	248✔
128	for (const auto& server : *resolversForStub) {	248✔
129	msg += server.toString() + ", ";	248✔
130	}	248✔
131	g_log<<Logger::Debug<<logPrefix<<msg.substr(0, msg.length() - 2)<<endl;	248✔
132
133	for(const ComboAddress& dest : *resolversForStub) {	248!
134	Socket sock(dest.sin4.sin_family, SOCK_DGRAM);	248✔
135	sock.setNonBlocking();	248✔
136	sock.connect(dest);	248✔
137	sock.send(string(packet.begin(), packet.end()));	248✔
138
139	string reply;	248✔
140
141	// error handled after this
142	(void)waitForData(sock.getHandle(), 2, 0);	248✔
143	try {	248✔
144	retry:	248✔
145	sock.read(reply); // this calls recv	248✔
146	if(reply.size() > sizeof(struct dnsheader)) {	248!
147	struct dnsheader d;	248✔
148	memcpy(&d, reply.c_str(), sizeof(d));	248✔
149	if(d.id != pw.getHeader()->id)	248!
150	goto retry;	×
151	}	248✔
152	}	248✔
153	catch(...) {	248✔
UNCOV 154	continue;	×
UNCOV 155	}	×
156	MOADNSParser mdp(false, reply);	248✔
157	if(mdp.d_header.rcode == RCode::ServFail)	248!
158	continue;	×
159
160	for(const auto & answer : mdp.d_answers) {	248✔
161	if(answer.first.d_place == 1 && answer.first.d_type==qtype) {	248!
162	DNSZoneRecord zrr;	152✔
163	zrr.dr = answer.first;	152✔
164	zrr.auth=true;	152✔
165	ret.push_back(zrr);	152✔
166	}	152✔
167	}	248✔
168	g_log<<Logger::Debug<<logPrefix<<"Question for '"<<queryNameType<<"' got answered by "<<dest.toString()<<endl;	248✔
169	return mdp.d_header.rcode;	248✔
170	}	248✔
UNCOV 171	return RCode::ServFail;	×
172	}	248✔
173
174	int stubDoResolve(const DNSName& qname, uint16_t qtype, vector<DNSRecord>& ret) {	96✔
175	vector<DNSZoneRecord> ret2;	96✔
176	int res = stubDoResolve(qname, qtype, ret2);	96✔
177	for (const auto &r : ret2) {	96!
178	ret.push_back(r.dr);	×
179	}	×
180	return res;	96✔
181	}	96✔

PowerDNS / pdns / 7222382716

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous