6672067814

Committed 27 Oct 2023 08:44PM UTC coverage: 56.087% (-1.4%) from 57.482%

Build # 6672067814

Build Type

Pull #13226

github

Committed by

web-flow

Commit Message

Merge b1d18bb1f into f8c2901a6

Pull Request Pull Request #13226: Cleanup `ueberbackend.cc` a bit

Run Details

30178 of 84938 branches covered (0.0%)

Branch coverage included in aggregate %.

181 of 236 new or added lines in 1 file covered. (76.69%)

2284 existing lines in 46 files now uncovered.

103148 of 152775 relevant lines covered (67.52%)

2698193.54 hits per line

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

21.21

/pdns/communicator.hh

/*
 * This file is part of PowerDNS or dnsdist.
 * Copyright -- PowerDNS.COM B.V. and its contributors
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * In addition, for the avoidance of any doubt, permission is granted to
 * link this program with OpenSSL and to (re)distribute the binaries
 * produced as the result of such linking.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
#pragma once
#include <pthread.h>
#include <string>
#include <semaphore.h>
#include <queue>
#include <list>
#include <limits>
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/identity.hpp>
#include <boost/multi_index/sequenced_index.hpp>
using namespace boost::multi_index;

#include <unistd.h>
#include <fcntl.h>
#include <netdb.h>

#include "lock.hh"
#include "packethandler.hh"

#include "namespaces.hh"
#include "dns_random.hh"

struct SuckRequest
{
  DNSName domain;
  ComboAddress master;
  bool force;
  enum RequestPriority : uint8_t { PdnsControl, Api, Notify, SerialRefresh, SignaturesRefresh };
  std::pair<RequestPriority, uint64_t> priorityAndOrder;
  bool operator<(const SuckRequest& b) const
  {
    return std::tie(domain, master) < std::tie(b.domain, b.master);
  }
};

struct IDTag{};

typedef multi_index_container<
  SuckRequest,
  indexed_by<
    ordered_unique<member<SuckRequest,std::pair<SuckRequest::RequestPriority,uint64_t>,&SuckRequest::priorityAndOrder>>,
    ordered_unique<tag<IDTag>, identity<SuckRequest> >
  >
> UniQueue;
typedef UniQueue::index<IDTag>::type domains_by_name_t;

class NotificationQueue
{
public:
  void add(const DNSName &domain, const string &ip)
  {
    const ComboAddress caIp(ip);

    NotificationRequest nr;
    nr.domain   = domain;
    nr.ip       = caIp.toStringWithPort();
    nr.attempts = 0;
    nr.id       = dns_random_uint16();
    nr.next     = time(0);

    d_nqueue.push_back(nr);
  }

  bool removeIf(const ComboAddress& remote, uint16_t id, const DNSName& domain)
  {
    for (auto i = d_nqueue.begin(); i != d_nqueue.end(); ++i) {
      ComboAddress stQueued{i->ip};
      if (i->id == id && stQueued == remote && i->domain == domain) {
        d_nqueue.erase(i);
        return true;
      }
    }
    return false;
  }

  bool getOne(DNSName &domain, string &ip, uint16_t *id, bool &purged)
  {
    for(d_nqueue_t::iterator i=d_nqueue.begin();i!=d_nqueue.end();++i)
      if(i->next <= time(0)) {
        i->attempts++;
        purged=false;
        i->next=time(0)+1+(1<<i->attempts);
        domain=i->domain;
        ip=i->ip;
        *id=i->id;
        purged=false;
        if(i->attempts>4) {
          purged=true;
          d_nqueue.erase(i);
        }
        return true;
      }
    return false;
  }

  time_t earliest()
  {
    time_t early=std::numeric_limits<time_t>::max() - 1;
    for(d_nqueue_t::const_iterator i=d_nqueue.begin();i!=d_nqueue.end();++i)
      early=min(early,i->next);
    return early-time(0);
  }

  void dump();

private:
  struct NotificationRequest
  {
    DNSName domain;
    string ip;
    time_t next;
    int attempts;
    uint16_t id;
  };

  typedef std::list<NotificationRequest> d_nqueue_t;
  d_nqueue_t d_nqueue;

};

struct ZoneStatus;

/** this class contains a thread that communicates with other nameserver and does housekeeping.
    Initially, it is notified only of zones that need to be pulled in because they have been updated. */

class CommunicatorClass
{
public:
  CommunicatorClass()
  {
    d_tickinterval=60;
    d_slaveschanged = true;
    d_nsock4 = -1;
    d_nsock6 = -1;
    d_preventSelfNotification = false;
  }
  time_t doNotifications(PacketHandler *P);
  void go();


  void drillHole(const DNSName &domain, const string &ip);
  bool justNotified(const DNSName &domain, const string &ip);
  void addSuckRequest(const DNSName &domain, const ComboAddress& master, SuckRequest::RequestPriority, bool force=false);
  void addSlaveCheckRequest(const DomainInfo& di, const ComboAddress& remote);
  void addTrySuperMasterRequest(const DNSPacket& p);
  void notify(const DNSName &domain, const string &ip);
  void mainloop();
  void retrievalLoopThread();
  void sendNotification(int sock, const DNSName &domain, const ComboAddress& remote, uint16_t id, UeberBackend* B);
  bool notifyDomain(const DNSName &domain, UeberBackend* B);
  vector<pair<DNSName, ComboAddress> > getSuckRequests();
  size_t getSuckRequestsWaiting();
private:
  void loadArgsIntoSet(const char *listname, set<string> &listset);
  void makeNotifySockets();
  void queueNotifyDomain(const DomainInfo& di, UeberBackend* B);
  int d_nsock4, d_nsock6;
  LockGuarded<map<pair<DNSName,string>,time_t>> d_holes;

  void suck(const DNSName &domain, const ComboAddress& remote, bool force=false);
  void ixfrSuck(const DNSName& domain, const TSIGTriplet& tt, const ComboAddress& laddr, const ComboAddress& remote, ZoneStatus& zs, vector<DNSRecord>* axfr);

  void slaveRefresh(PacketHandler *P);
  void masterUpdateCheck(PacketHandler *P);
  void getUpdatedProducers(UeberBackend* B, vector<DomainInfo>& domains, const std::unordered_set<DNSName>& catalogs, CatalogHashMap& catalogHashes);

  Semaphore d_suck_sem;
  Semaphore d_any_sem;

  set<string> d_alsoNotify;
  NetmaskGroup d_onlyNotify;
  NotificationQueue d_nq;

  time_t d_tickinterval;
  bool d_slaveschanged;
  bool d_preventSelfNotification;

  struct Data
  {
    uint64_t d_sorthelper{0};
    UniQueue d_suckdomains;
    set<DNSName> d_inprogress;

    set<DomainInfo> d_tocheck;
    struct cmp {
      bool operator()(const DNSPacket& a, const DNSPacket& b) const {
        return a.qdomain < b.qdomain;
      };
    };

    std::set<DNSPacket, cmp> d_potentialsupermasters;

    // Used to keep some state on domains that failed their freshness checks.
    // uint64_t == counter of the number of failures (increased by 1 every consecutive slave-cycle-interval that the domain fails)
    // time_t == wait at least until this time before attempting a new check
    map<DNSName, pair<uint64_t, time_t> > d_failedSlaveRefresh;
  };

  LockGuarded<Data> d_data;

  struct RemoveSentinel
  {
    explicit RemoveSentinel(const DNSName& dn, CommunicatorClass* cc) : d_dn(dn), d_cc(cc)
    {}

    ~RemoveSentinel()
    {
      try {
        d_cc->d_data.lock()->d_inprogress.erase(d_dn);
      }
      catch(...) {
      }
    }
    DNSName d_dn;
    CommunicatorClass* d_cc;
};

};

// class that one day might be more than a function to help you get IP addresses for a nameserver
class FindNS
{
public:
  vector<string> lookup(const DNSName &name, UeberBackend *b)
  {
    vector<string> addresses;

    this->resolve_name(&addresses, name);

    if(b) {
        b->lookup(QType(QType::ANY),name,-1);
        DNSZoneRecord rr;
        while(b->get(rr))
          if(rr.dr.d_type == QType::A || rr.dr.d_type==QType::AAAA)
            addresses.push_back(rr.dr.getContent()->getZoneRepresentation());   // SOL if you have a CNAME for an NS
    }
    return addresses;
  }

private:
  void resolve_name(vector<string>* addresses, const DNSName& name)
  {
    struct addrinfo* res;
    struct addrinfo hints;
    memset(&hints, 0, sizeof(hints));
    hints.ai_socktype = SOCK_DGRAM; // otherwise we get everything in triplicate (!)
    for(int n = 0; n < 2; ++n) {
      hints.ai_family = n ? AF_INET : AF_INET6;
      ComboAddress remote;
      remote.sin4.sin_family = AF_INET6;
      if(!getaddrinfo(name.toString().c_str(), 0, &hints, &res)) {
        struct addrinfo* address = res;
        do {
          if (address->ai_addrlen <= sizeof(remote)) {
            remote.setSockaddr(address->ai_addr, address->ai_addrlen);
            addresses->push_back(remote.toString());
          }
        } while((address = address->ai_next));
        freeaddrinfo(res);
      }
    }
  }
};

1	/*
2	* This file is part of PowerDNS or dnsdist.
3	* Copyright -- PowerDNS.COM B.V. and its contributors
4	*
5	* This program is free software; you can redistribute it and/or modify
6	* it under the terms of version 2 of the GNU General Public License as
7	* published by the Free Software Foundation.
8	*
9	* In addition, for the avoidance of any doubt, permission is granted to
10	* link this program with OpenSSL and to (re)distribute the binaries
11	* produced as the result of such linking.
12	*
13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.
17	*
18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
21	*/
22	#pragma once
23	#include <pthread.h>
24	#include <string>
25	#include <semaphore.h>
26	#include <queue>
27	#include <list>
28	#include <limits>
29	#include <boost/multi_index_container.hpp>
30	#include <boost/multi_index/identity.hpp>
31	#include <boost/multi_index/sequenced_index.hpp>
32	using namespace boost::multi_index;
33
34	#include <unistd.h>
35	#include <fcntl.h>
36	#include <netdb.h>
37
38	#include "lock.hh"
39	#include "packethandler.hh"
40
41	#include "namespaces.hh"
42	#include "dns_random.hh"
43
44	struct SuckRequest
45	{
46	DNSName domain;
47	ComboAddress master;
48	bool force;
49	enum RequestPriority : uint8_t { PdnsControl, Api, Notify, SerialRefresh, SignaturesRefresh };
50	std::pair<RequestPriority, uint64_t> priorityAndOrder;
51	bool operator<(const SuckRequest& b) const
52	{	573✔
53	return std::tie(domain, master) < std::tie(b.domain, b.master);	573✔
54	}	573✔
55	};
56
57	struct IDTag{};
58
59	typedef multi_index_container<
60	SuckRequest,
61	indexed_by<
62	ordered_unique<member<SuckRequest,std::pair<SuckRequest::RequestPriority,uint64_t>,&SuckRequest::priorityAndOrder>>,
63	ordered_unique<tag<IDTag>, identity<SuckRequest> >
64	>
65	> UniQueue;
66	typedef UniQueue::index<IDTag>::type domains_by_name_t;
67
68	class NotificationQueue
69	{
70	public:
71	void add(const DNSName &domain, const string &ip)
UNCOV 72	{	×
UNCOV 73	const ComboAddress caIp(ip);	×
74
UNCOV 75	NotificationRequest nr;	×
UNCOV 76	nr.domain = domain;	×
UNCOV 77	nr.ip = caIp.toStringWithPort();	×
UNCOV 78	nr.attempts = 0;	×
UNCOV 79	nr.id = dns_random_uint16();	×
UNCOV 80	nr.next = time(0);	×
81
UNCOV 82	d_nqueue.push_back(nr);	×
UNCOV 83	}	×
84
85	bool removeIf(const ComboAddress& remote, uint16_t id, const DNSName& domain)
UNCOV 86	{	×
UNCOV 87	for (auto i = d_nqueue.begin(); i != d_nqueue.end(); ++i) {	×
UNCOV 88	ComboAddress stQueued{i->ip};	×
UNCOV 89	if (i->id == id && stQueued == remote && i->domain == domain) {	×
UNCOV 90	d_nqueue.erase(i);	×
UNCOV 91	return true;	×
UNCOV 92	}	×
UNCOV 93	}	×
94	return false;	×
UNCOV 95	}	×
96
97	bool getOne(DNSName &domain, string &ip, uint16_t *id, bool &purged)
98	{	190✔
99	for(d_nqueue_t::iterator i=d_nqueue.begin();i!=d_nqueue.end();++i)	190!
UNCOV 100	if(i->next <= time(0)) {	×
UNCOV 101	i->attempts++;	×
UNCOV 102	purged=false;	×
UNCOV 103	i->next=time(0)+1+(1<<i->attempts);	×
UNCOV 104	domain=i->domain;	×
UNCOV 105	ip=i->ip;	×
UNCOV 106	*id=i->id;	×
UNCOV 107	purged=false;	×
UNCOV 108	if(i->attempts>4) {	×
109	purged=true;	×
110	d_nqueue.erase(i);	×
111	}	×
UNCOV 112	return true;	×
UNCOV 113	}	×
114	return false;	190✔
115	}	190✔
116
117	time_t earliest()
118	{	190✔
119	time_t early=std::numeric_limits<time_t>::max() - 1;	190✔
120	for(d_nqueue_t::const_iterator i=d_nqueue.begin();i!=d_nqueue.end();++i)	190!
UNCOV 121	early=min(early,i->next);	×
122	return early-time(0);	190✔
123	}	190✔
124
125	void dump();
126
127	private:
128	struct NotificationRequest
129	{
130	DNSName domain;
131	string ip;
132	time_t next;
133	int attempts;
134	uint16_t id;
135	};
136
137	typedef std::list<NotificationRequest> d_nqueue_t;
138	d_nqueue_t d_nqueue;
139
140	};
141
142	struct ZoneStatus;
143
144	/** this class contains a thread that communicates with other nameserver and does housekeeping.
145	Initially, it is notified only of zones that need to be pulled in because they have been updated. */
146
147	class CommunicatorClass
148	{
149	public:
150	CommunicatorClass()
151	{	78✔
152	d_tickinterval=60;	78✔
153	d_slaveschanged = true;	78✔
154	d_nsock4 = -1;	78✔
155	d_nsock6 = -1;	78✔
156	d_preventSelfNotification = false;	78✔
157	}	78✔
158	time_t doNotifications(PacketHandler *P);
159	void go();
160
161
162	void drillHole(const DNSName &domain, const string &ip);
163	bool justNotified(const DNSName &domain, const string &ip);
164	void addSuckRequest(const DNSName &domain, const ComboAddress& master, SuckRequest::RequestPriority, bool force=false);
165	void addSlaveCheckRequest(const DomainInfo& di, const ComboAddress& remote);
166	void addTrySuperMasterRequest(const DNSPacket& p);
167	void notify(const DNSName &domain, const string &ip);
168	void mainloop();
169	void retrievalLoopThread();
170	void sendNotification(int sock, const DNSName &domain, const ComboAddress& remote, uint16_t id, UeberBackend* B);
171	bool notifyDomain(const DNSName &domain, UeberBackend* B);
172	vector<pair<DNSName, ComboAddress> > getSuckRequests();
173	size_t getSuckRequestsWaiting();
174	private:
175	void loadArgsIntoSet(const char *listname, set<string> &listset);
176	void makeNotifySockets();
177	void queueNotifyDomain(const DomainInfo& di, UeberBackend* B);
178	int d_nsock4, d_nsock6;
179	LockGuarded<map<pair<DNSName,string>,time_t>> d_holes;
180
181	void suck(const DNSName &domain, const ComboAddress& remote, bool force=false);
182	void ixfrSuck(const DNSName& domain, const TSIGTriplet& tt, const ComboAddress& laddr, const ComboAddress& remote, ZoneStatus& zs, vector<DNSRecord>* axfr);
183
184	void slaveRefresh(PacketHandler *P);
185	void masterUpdateCheck(PacketHandler *P);
186	void getUpdatedProducers(UeberBackend* B, vector<DomainInfo>& domains, const std::unordered_set<DNSName>& catalogs, CatalogHashMap& catalogHashes);
187
188	Semaphore d_suck_sem;
189	Semaphore d_any_sem;
190
191	set<string> d_alsoNotify;
192	NetmaskGroup d_onlyNotify;
193	NotificationQueue d_nq;
194
195	time_t d_tickinterval;
196	bool d_slaveschanged;
197	bool d_preventSelfNotification;
198
199	struct Data
200	{
201	uint64_t d_sorthelper{0};
202	UniQueue d_suckdomains;
203	set<DNSName> d_inprogress;
204
205	set<DomainInfo> d_tocheck;
206	struct cmp {
207	bool operator()(const DNSPacket& a, const DNSPacket& b) const {	×
208	return a.qdomain < b.qdomain;	×
209	};	×
210	};
211
212	std::set<DNSPacket, cmp> d_potentialsupermasters;
213
214	// Used to keep some state on domains that failed their freshness checks.
215	// uint64_t == counter of the number of failures (increased by 1 every consecutive slave-cycle-interval that the domain fails)
216	// time_t == wait at least until this time before attempting a new check
217	map<DNSName, pair<uint64_t, time_t> > d_failedSlaveRefresh;
218	};
219
220	LockGuarded<Data> d_data;
221
222	struct RemoveSentinel
223	{
224	explicit RemoveSentinel(const DNSName& dn, CommunicatorClass* cc) : d_dn(dn), d_cc(cc)
225	{}	144✔
226
227	~RemoveSentinel()
228	{	144✔
229	try {	144✔
230	d_cc->d_data.lock()->d_inprogress.erase(d_dn);	144✔
231	}	144✔
232	catch(...) {	144✔
233	}	×
234	}	144✔
235	DNSName d_dn;
236	CommunicatorClass* d_cc;
237	};
238
239	};
240
241	// class that one day might be more than a function to help you get IP addresses for a nameserver
242	class FindNS
243	{
244	public:
245	vector<string> lookup(const DNSName &name, UeberBackend *b)
UNCOV 246	{	×
UNCOV 247	vector<string> addresses;	×
248
UNCOV 249	this->resolve_name(&addresses, name);	×
250
UNCOV 251	if(b) {	×
UNCOV 252	b->lookup(QType(QType::ANY),name,-1);	×
UNCOV 253	DNSZoneRecord rr;	×
UNCOV 254	while(b->get(rr))	×
UNCOV 255	if(rr.dr.d_type == QType::A \|\| rr.dr.d_type==QType::AAAA)	×
UNCOV 256	addresses.push_back(rr.dr.getContent()->getZoneRepresentation()); // SOL if you have a CNAME for an NS	×
UNCOV 257	}	×
UNCOV 258	return addresses;	×
UNCOV 259	}	×
260
261	private:
262	void resolve_name(vector<string>* addresses, const DNSName& name)
UNCOV 263	{	×
UNCOV 264	struct addrinfo* res;	×
UNCOV 265	struct addrinfo hints;	×
UNCOV 266	memset(&hints, 0, sizeof(hints));	×
UNCOV 267	hints.ai_socktype = SOCK_DGRAM; // otherwise we get everything in triplicate (!)	×
UNCOV 268	for(int n = 0; n < 2; ++n) {	×
UNCOV 269	hints.ai_family = n ? AF_INET : AF_INET6;	×
UNCOV 270	ComboAddress remote;	×
UNCOV 271	remote.sin4.sin_family = AF_INET6;	×
UNCOV 272	if(!getaddrinfo(name.toString().c_str(), 0, &hints, &res)) {	×
273	struct addrinfo* address = res;	×
274	do {	×
275	if (address->ai_addrlen <= sizeof(remote)) {	×
276	remote.setSockaddr(address->ai_addr, address->ai_addrlen);	×
277	addresses->push_back(remote.toString());	×
278	}	×
279	} while((address = address->ai_next));	×
280	freeaddrinfo(res);	×
281	}	×
UNCOV 282	}	×
UNCOV 283	}	×
284	};

PowerDNS / pdns / 6672067814

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