PowerDNS/pdns | Build 19151133429 | modules/bindbackend/bindbackend2.hh | Coveralls

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 <string>

24

#include <map>

25

#include <set>

26

#include <pthread.h>

27

#include <time.h>

28

#include <fstream>

29

#include <mutex>

30

#include <boost/utility.hpp>

31

32

#include <boost/multi_index_container.hpp>

33

#include <boost/multi_index/hashed_index.hpp>

34

#include <boost/multi_index/ordered_index.hpp>

35

#include <boost/multi_index/identity.hpp>

36

#include <boost/multi_index/member.hpp>

37

#include <sys/types.h>

38

#include <sys/stat.h>

39

#include <unistd.h>

40

#include "pdns/lock.hh"

41

#include "pdns/misc.hh"

42

#include "pdns/dnsbackend.hh"

43

#include "pdns/namespaces.hh"

44

#include "pdns/backends/gsql/ssql.hh"

45

46

using namespace ::boost::multi_index;

47

48

/**

49

  This struct is used within the Bind2Backend to store DNS information. It is

50

  almost identical to a DNSResourceRecord, but then a bit smaller and with

51

  different sorting rules, which make sure that the SOA record comes up front.

52

*/

53

54

struct Bind2DNSRecord

55

56

  DNSName qname;

57

  string content;

58

  string nsec3hash;

59

  uint32_t ttl;

60

  uint16_t qtype;

61

  mutable bool auth;

62

  bool operator<(const Bind2DNSRecord& rhs) const

71

};

72

73

struct Bind2DNSCompare : std::less<Bind2DNSRecord>

74

75

  using std::less<Bind2DNSRecord>::operator();

76

  // use operator<

77

  bool operator()(const DNSName& a, const Bind2DNSRecord& b) const

78

81

  bool operator()(const Bind2DNSRecord& a, const DNSName& b) const

82

85

  bool operator()(const Bind2DNSRecord& a, const Bind2DNSRecord& b) const

86

90

91

struct NSEC3Tag

92

93

};

94

struct UnorderedNameTag

95

96

};

97

98

typedef multi_index_container<

99

  Bind2DNSRecord,

100

  indexed_by<

101

    ordered_non_unique<identity<Bind2DNSRecord>, Bind2DNSCompare>,

102

    hashed_non_unique<tag<UnorderedNameTag>, member<Bind2DNSRecord, DNSName, &Bind2DNSRecord::qname>>,

103

    ordered_non_unique<tag<NSEC3Tag>, member<Bind2DNSRecord, std::string, &Bind2DNSRecord::nsec3hash>>>>

104

  recordstorage_t;

105

106

template <typename T>

107

class LookButDontTouch

108

109

public:

112

    d_records(std::move(records))

113

116

  shared_ptr<const T> get()

117

120

121

  size_t getEntriesCount() const

122

128

129

private:

130

  /* we can increase the number of references to that object,

131

     but never update the object itself */

132

  shared_ptr<const T> d_records;

133

};

134

135

/** Class which describes all metadata of a domain for storage by the Bind2Backend, and also contains a pointer to a vector of Bind2DNSRecord's */

136

class BB2DomainInfo

137

138

public:

139

  BB2DomainInfo();

140

  void updateCtime();

141

  bool current();

142

  //! configure how often this domain should be checked for changes (on disk)

143

  void setCheckInterval(time_t seconds);

144

  time_t getCheckInterval() const

145

148

149

  ZoneName d_name; //!< actual name of the domain

150

  DomainInfo::DomainKind d_kind{DomainInfo::Native}; //!< the kind of domain

151

  std::vector<std::pair<std::string, time_t>> d_fileinfo; //!< list of full absolute filename of the zone on disk, and any included file, with their last verified ctime

152

  string d_status; //!< message describing status of a domain, for human consumption

153

  vector<ComboAddress> d_primaries; //!< IP address of the primary of this domain

154

  set<string> d_also_notify; //!< IP list of hosts to also notify

155

  LookButDontTouch<recordstorage_t> d_records; //!< the actual records belonging to this domain

156

  time_t d_lastcheck{0}; //!< last time files were checked for freshness

157

  uint32_t d_lastnotified{0}; //!< Last serial number we notified our secondaries of

158

  domainid_t d_id{0}; //!< internal id of the domain

159

  mutable bool d_checknow; //!< if this domain has been flagged for a check

160

  bool d_loaded{false}; //!< if a domain is loaded

161

  bool d_wasRejectedLastReload{false}; //!< if the domain was rejected during Bind2Backend::queueReloadAndStore

162

  bool d_nsec3zone{false};

163

  NSEC3PARAMRecordContent d_nsec3param;

164

165

  // Sugar for the main filename. Only use if d_fileinfo is NOT empty!

166

  const std::string& main_filename() const { return d_fileinfo.front().first; }

167

168

private:

169

  static time_t getCtime(const std::string&);

170

  time_t d_checkinterval{0};

171

};

172

173

class SSQLite3;

174

class NSEC3PARAMRecordContent;

175

176

struct NameTag

177

178

};

179

180

class Bind2Backend : public DNSBackend

181

182

public:

183

  Bind2Backend(const string& suffix = "", bool loadZones = true);

184

  ~Bind2Backend() override;

185

  unsigned int getCapabilities() override;

186

  void getUnfreshSecondaryInfos(vector<DomainInfo>* unfreshDomains) override;

187

  void getUpdatedPrimaries(vector<DomainInfo>& changedDomains, std::unordered_set<DNSName>& catalogs, CatalogHashMap& catalogHashes) override;

188

  bool getDomainInfo(const ZoneName& domain, DomainInfo& info, bool getSerial = true) override;

189

  // DNSSEC

190

  bool getBeforeAndAfterNamesAbsolute(domainid_t id, const DNSName& qname, DNSName& unhashed, DNSName& before, DNSName& after) override;

191

  void lookup(const QType& qtype, const DNSName& qname, domainid_t zoneId, DNSPacket* p = nullptr) override;

192

  bool list(const ZoneName& target, domainid_t domainId, bool include_disabled = false) override;

193

  bool get(DNSResourceRecord&) override;

194

  void lookupEnd() override;

195

  void getAllDomains(vector<DomainInfo>* domains, bool getSerial, bool include_disabled = false) override;

196

197

  static std::mutex s_startup_lock;

198

199

  void setStale(domainid_t domain_id) override;

200

  void setFresh(domainid_t domain_id) override;

201

  void setNotified(domainid_t id, uint32_t serial) override;

202

  bool startTransaction(const ZoneName& qname, domainid_t domainId) override;

203

  bool feedRecord(const DNSResourceRecord& rr, const DNSName& ordername, bool ordernameIsNSEC3 = false) override;

204

  bool commitTransaction() override;

205

  bool abortTransaction() override;

206

  void alsoNotifies(const ZoneName& domain, set<string>* ips) override;

207

  bool searchRecords(const string& pattern, size_t maxResults, vector<DNSResourceRecord>& result) override;

208

209

  // the DNSSEC related (getDomainMetadata has broader uses too)

210

  bool getAllDomainMetadata(const ZoneName& name, std::map<std::string, std::vector<std::string>>& meta) override;

211

  bool getDomainMetadata(const ZoneName& name, const std::string& kind, std::vector<std::string>& meta) override;

212

  bool setDomainMetadata(const ZoneName& name, const std::string& kind, const std::vector<std::string>& meta) override;

213

  bool getDomainKeys(const ZoneName& name, std::vector<KeyData>& keys) override;

214

  bool removeDomainKey(const ZoneName& name, unsigned int keyId) override;

215

  bool addDomainKey(const ZoneName& name, const KeyData& key, int64_t& keyId) override;

216

  bool activateDomainKey(const ZoneName& name, unsigned int keyId) override;

217

  bool deactivateDomainKey(const ZoneName& name, unsigned int keyId) override;

218

  bool publishDomainKey(const ZoneName& name, unsigned int keyId) override;

219

  bool unpublishDomainKey(const ZoneName& name, unsigned int keyId) override;

220

  bool getTSIGKey(const DNSName& name, DNSName& algorithm, string& content) override;

221

  bool setTSIGKey(const DNSName& name, const DNSName& algorithm, const string& content) override;

222

  bool deleteTSIGKey(const DNSName& name) override;

223

  bool getTSIGKeys(std::vector<struct TSIGKey>& keys) override;

224

  // end of DNSSEC

225

226

  typedef multi_index_container<BB2DomainInfo,

227

                                indexed_by<ordered_unique<member<BB2DomainInfo, domainid_t, &BB2DomainInfo::d_id>>,

228

                                           ordered_unique<tag<NameTag>, member<BB2DomainInfo, ZoneName, &BB2DomainInfo::d_name>>>>

229

    state_t;

230

  static SharedLockGuarded<state_t> s_state;

231

232

  void parseZoneFile(BB2DomainInfo* bbd);

233

  void rediscover(string* status = nullptr) override;

234

235

  // for autoprimary support

236

  bool autoPrimariesList(std::vector<AutoPrimary>& primaries) override;

237

  bool autoPrimaryBackend(const string& ipAddress, const ZoneName& domain, const vector<DNSResourceRecord>& nsset, string* nameserver, string* account, DNSBackend** backend) override;

238

  static std::mutex s_autosecondary_config_lock;

239

  bool createSecondaryDomain(const string& ipAddress, const ZoneName& domain, const string& nameserver, const string& account) override;

240

241

private:

242

  void setupDNSSEC();

243

  void setupStatements();

244

  void freeStatements();

245

  static bool safeGetBBDomainInfo(domainid_t id, BB2DomainInfo* bbd);

246

  static void safePutBBDomainInfo(const BB2DomainInfo& bbd);

247

  static bool safeGetBBDomainInfo(const ZoneName& name, BB2DomainInfo* bbd);

248

  static bool safeRemoveBBDomainInfo(const ZoneName& name);

249

  shared_ptr<SSQLite3> d_dnssecdb;

250

  bool getNSEC3PARAM(const ZoneName& name, NSEC3PARAMRecordContent* ns3p);

251

  static void setLastCheck(domainid_t domain_id, time_t lastcheck);

252

  bool getNSEC3PARAMuncached(const ZoneName& name, NSEC3PARAMRecordContent* ns3p);

253

  class handle

254

255

  public:

256

    bool get(DNSResourceRecord&);

257

    void reset();

258

259

    handle();

260

261

    handle(const handle&) = delete;

262

    handle& operator=(const handle&) = delete; // don't go copying this

263

264

    shared_ptr<const recordstorage_t> d_records;

265

    recordstorage_t::index<UnorderedNameTag>::type::const_iterator d_iter, d_end_iter;

266

267

    recordstorage_t::const_iterator d_qname_iter, d_qname_end;

268

269

    DNSName qname;

270

    ZoneName domain;

271

272

    domainid_t id{UnknownDomainID};

273

    QType qtype;

274

    bool d_list{false};

275

    bool mustlog{false};

276

277

  private:

278

    bool get_normal(DNSResourceRecord&);

279

    bool get_list(DNSResourceRecord&);

280

};

281

282

  unique_ptr<SSqlStatement> d_getAllDomainMetadataQuery_stmt;

283

  unique_ptr<SSqlStatement> d_getDomainMetadataQuery_stmt;

284

  unique_ptr<SSqlStatement> d_deleteDomainMetadataQuery_stmt;

285

  unique_ptr<SSqlStatement> d_insertDomainMetadataQuery_stmt;

286

  unique_ptr<SSqlStatement> d_getDomainKeysQuery_stmt;

287

  unique_ptr<SSqlStatement> d_deleteDomainKeyQuery_stmt;

288

  unique_ptr<SSqlStatement> d_insertDomainKeyQuery_stmt;

289

  unique_ptr<SSqlStatement> d_GetLastInsertedKeyIdQuery_stmt;

290

  unique_ptr<SSqlStatement> d_activateDomainKeyQuery_stmt;

291

  unique_ptr<SSqlStatement> d_deactivateDomainKeyQuery_stmt;

292

  unique_ptr<SSqlStatement> d_publishDomainKeyQuery_stmt;

293

  unique_ptr<SSqlStatement> d_unpublishDomainKeyQuery_stmt;

294

  unique_ptr<SSqlStatement> d_getTSIGKeyQuery_stmt;

295

  unique_ptr<SSqlStatement> d_setTSIGKeyQuery_stmt;

296

  unique_ptr<SSqlStatement> d_deleteTSIGKeyQuery_stmt;

297

  unique_ptr<SSqlStatement> d_getTSIGKeysQuery_stmt;

298

299

  ZoneName d_transaction_qname;

300

  string d_transaction_tmpname;

301

  string d_logprefix;

302

  set<string> alsoNotify; //!< this is used to store the also-notify list of interested peers.

303

  std::unique_ptr<ofstream> d_of;

304

  handle d_handle;

305

  static string s_binddirectory; //!< this is used to store the 'directory' setting of the bind configuration

306

  static int s_first; //!< this is raised on construction to prevent multiple instances of us being generated

307

  domainid_t d_transaction_id;

308

  static bool s_ignore_broken_records;

309

  bool d_hybrid;

310

  bool d_upgradeContent;

311

312

  BB2DomainInfo createDomainEntry(const ZoneName& domain); //!< does not insert in s_state

313

314

  void queueReloadAndStore(domainid_t id);

315

  static bool findBeforeAndAfterUnhashed(std::shared_ptr<const recordstorage_t>& records, const DNSName& qname, DNSName& unhashed, DNSName& before, DNSName& after);

316

  static void insertRecord(std::shared_ptr<recordstorage_t>& records, const ZoneName& zoneName, const DNSName& qname, const QType& qtype, const string& content, int ttl, const std::string& hashed = string(), const bool* auth = nullptr);

317

  void reload() override;

318

  static string DLDomStatusHandler(const vector<string>& parts, Utility::pid_t ppid);

319

  static string DLDomExtendedStatusHandler(const vector<string>& parts, Utility::pid_t ppid);

320

  static string DLListRejectsHandler(const vector<string>& parts, Utility::pid_t ppid);

321

  static string DLReloadNowHandler(const vector<string>& parts, Utility::pid_t ppid);

322

  static string DLAddDomainHandler(const vector<string>& parts, Utility::pid_t ppid);

323

  static void fixupOrderAndAuth(std::shared_ptr<recordstorage_t>& records, const ZoneName& zoneName, bool nsec3zone, const NSEC3PARAMRecordContent& ns3pr);

324

  static void doEmptyNonTerminals(std::shared_ptr<recordstorage_t>& records, const ZoneName& zoneName, bool nsec3zone, const NSEC3PARAMRecordContent& ns3pr);

325

  void loadConfig(string* status = nullptr);

326

};

PowerDNS / pdns / 19151133429

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

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 <string>
24	#include <map>
25	#include <set>
26	#include <pthread.h>
27	#include <time.h>
28	#include <fstream>
29	#include <mutex>
30	#include <boost/utility.hpp>
31
32	#include <boost/multi_index_container.hpp>
33	#include <boost/multi_index/hashed_index.hpp>
34	#include <boost/multi_index/ordered_index.hpp>
35	#include <boost/multi_index/identity.hpp>
36	#include <boost/multi_index/member.hpp>
37	#include <sys/types.h>
38	#include <sys/stat.h>
39	#include <unistd.h>
40	#include "pdns/lock.hh"
41	#include "pdns/misc.hh"
42	#include "pdns/dnsbackend.hh"
43	#include "pdns/namespaces.hh"
44	#include "pdns/backends/gsql/ssql.hh"
45
46	using namespace ::boost::multi_index;
47
48	/**
49	This struct is used within the Bind2Backend to store DNS information. It is
50	almost identical to a DNSResourceRecord, but then a bit smaller and with
51	different sorting rules, which make sure that the SOA record comes up front.
52	*/
53
54	struct Bind2DNSRecord
55	{
56	DNSName qname;
57	string content;
58	string nsec3hash;
59	uint32_t ttl;
60	uint16_t qtype;
61	mutable bool auth;
62	bool operator<(const Bind2DNSRecord& rhs) const
63	{	×
64	if (int rc = qname.canonCompare_three_way(rhs.qname); rc != 0) {	×
65	return rc < 0;	×
66	}	×
67	if (qtype == QType::SOA && rhs.qtype != QType::SOA)	×
68	return true;	×
69	return std::tie(qtype, content, ttl) < std::tie(rhs.qtype, rhs.content, rhs.ttl);	×
70	}	×
71	};
72
73	struct Bind2DNSCompare : std::less<Bind2DNSRecord>
74	{
75	using std::less<Bind2DNSRecord>::operator();
76	// use operator<
77	bool operator()(const DNSName& a, const Bind2DNSRecord& b) const
78	{
79	return a.canonCompare(b.qname);	×
80	}	×
81	bool operator()(const Bind2DNSRecord& a, const DNSName& b) const
82	{
83	return a.qname.canonCompare(b);	×
84	}	×
85	bool operator()(const Bind2DNSRecord& a, const Bind2DNSRecord& b) const
86	{
87	return a.qname.canonCompare(b.qname);	16✔
88	}	16✔
89	};	16✔
90
91	struct NSEC3Tag
92	{
93	};
94	struct UnorderedNameTag
95	{
96	};
97
98	typedef multi_index_container<
99	Bind2DNSRecord,
100	indexed_by<
101	ordered_non_unique<identity<Bind2DNSRecord>, Bind2DNSCompare>,
102	hashed_non_unique<tag<UnorderedNameTag>, member<Bind2DNSRecord, DNSName, &Bind2DNSRecord::qname>>,
103	ordered_non_unique<tag<NSEC3Tag>, member<Bind2DNSRecord, std::string, &Bind2DNSRecord::nsec3hash>>>>
104	recordstorage_t;
105
106	template <typename T>
107	class LookButDontTouch
108	{
109	public:
110	LookButDontTouch() = default;	581✔
111	LookButDontTouch(shared_ptr<T>&& records) :	151✔
112	d_records(std::move(records))
113	{
114	}	2✔
115		2✔
116	shared_ptr<const T> get()
117	{
118	return d_records;	×
119	}	×
120
121	size_t getEntriesCount() const
122	{
123	if (!d_records) {	×
124	return 0;	×
125	}	×
126	return d_records->size();	×
127	}	×
128
129	private:
130	/* we can increase the number of references to that object,
131	but never update the object itself */
132	shared_ptr<const T> d_records;
133	};
134
135	/** Class which describes all metadata of a domain for storage by the Bind2Backend, and also contains a pointer to a vector of Bind2DNSRecord's */
136	class BB2DomainInfo
137	{
138	public:
139	BB2DomainInfo();
140	void updateCtime();
141	bool current();
142	//! configure how often this domain should be checked for changes (on disk)
143	void setCheckInterval(time_t seconds);
144	time_t getCheckInterval() const
145	{
146	return d_checkinterval;	×
147	}	×
148
149	ZoneName d_name; //!< actual name of the domain
150	DomainInfo::DomainKind d_kind{DomainInfo::Native}; //!< the kind of domain
151	std::vector<std::pair<std::string, time_t>> d_fileinfo; //!< list of full absolute filename of the zone on disk, and any included file, with their last verified ctime
152	string d_status; //!< message describing status of a domain, for human consumption
153	vector<ComboAddress> d_primaries; //!< IP address of the primary of this domain
154	set<string> d_also_notify; //!< IP list of hosts to also notify
155	LookButDontTouch<recordstorage_t> d_records; //!< the actual records belonging to this domain
156	time_t d_lastcheck{0}; //!< last time files were checked for freshness
157	uint32_t d_lastnotified{0}; //!< Last serial number we notified our secondaries of
158	domainid_t d_id{0}; //!< internal id of the domain
159	mutable bool d_checknow; //!< if this domain has been flagged for a check
160	bool d_loaded{false}; //!< if a domain is loaded
161	bool d_wasRejectedLastReload{false}; //!< if the domain was rejected during Bind2Backend::queueReloadAndStore
162	bool d_nsec3zone{false};
163	NSEC3PARAMRecordContent d_nsec3param;
164
165	// Sugar for the main filename. Only use if d_fileinfo is NOT empty!
166	const std::string& main_filename() const { return d_fileinfo.front().first; }
167
168	private:
169	static time_t getCtime(const std::string&);
170	time_t d_checkinterval{0};
171	};
172
173	class SSQLite3;
174	class NSEC3PARAMRecordContent;
175
176	struct NameTag
177	{
178	};
179
180	class Bind2Backend : public DNSBackend
181	{
182	public:
183	Bind2Backend(const string& suffix = "", bool loadZones = true);
184	~Bind2Backend() override;
185	unsigned int getCapabilities() override;
186	void getUnfreshSecondaryInfos(vector<DomainInfo>* unfreshDomains) override;
187	void getUpdatedPrimaries(vector<DomainInfo>& changedDomains, std::unordered_set<DNSName>& catalogs, CatalogHashMap& catalogHashes) override;
188	bool getDomainInfo(const ZoneName& domain, DomainInfo& info, bool getSerial = true) override;
189	// DNSSEC
190	bool getBeforeAndAfterNamesAbsolute(domainid_t id, const DNSName& qname, DNSName& unhashed, DNSName& before, DNSName& after) override;
191	void lookup(const QType& qtype, const DNSName& qname, domainid_t zoneId, DNSPacket* p = nullptr) override;
192	bool list(const ZoneName& target, domainid_t domainId, bool include_disabled = false) override;
193	bool get(DNSResourceRecord&) override;
194	void lookupEnd() override;
195	void getAllDomains(vector<DomainInfo>* domains, bool getSerial, bool include_disabled = false) override;
196
197	static std::mutex s_startup_lock;
198
199	void setStale(domainid_t domain_id) override;
200	void setFresh(domainid_t domain_id) override;
201	void setNotified(domainid_t id, uint32_t serial) override;
202	bool startTransaction(const ZoneName& qname, domainid_t domainId) override;
203	bool feedRecord(const DNSResourceRecord& rr, const DNSName& ordername, bool ordernameIsNSEC3 = false) override;
204	bool commitTransaction() override;
205	bool abortTransaction() override;
206	void alsoNotifies(const ZoneName& domain, set<string>* ips) override;
207	bool searchRecords(const string& pattern, size_t maxResults, vector<DNSResourceRecord>& result) override;
208
209	// the DNSSEC related (getDomainMetadata has broader uses too)
210	bool getAllDomainMetadata(const ZoneName& name, std::map<std::string, std::vector<std::string>>& meta) override;
211	bool getDomainMetadata(const ZoneName& name, const std::string& kind, std::vector<std::string>& meta) override;
212	bool setDomainMetadata(const ZoneName& name, const std::string& kind, const std::vector<std::string>& meta) override;
213	bool getDomainKeys(const ZoneName& name, std::vector<KeyData>& keys) override;
214	bool removeDomainKey(const ZoneName& name, unsigned int keyId) override;
215	bool addDomainKey(const ZoneName& name, const KeyData& key, int64_t& keyId) override;
216	bool activateDomainKey(const ZoneName& name, unsigned int keyId) override;
217	bool deactivateDomainKey(const ZoneName& name, unsigned int keyId) override;
218	bool publishDomainKey(const ZoneName& name, unsigned int keyId) override;
219	bool unpublishDomainKey(const ZoneName& name, unsigned int keyId) override;
220	bool getTSIGKey(const DNSName& name, DNSName& algorithm, string& content) override;
221	bool setTSIGKey(const DNSName& name, const DNSName& algorithm, const string& content) override;
222	bool deleteTSIGKey(const DNSName& name) override;
223	bool getTSIGKeys(std::vector<struct TSIGKey>& keys) override;
224	// end of DNSSEC
225
226	typedef multi_index_container<BB2DomainInfo,
227	indexed_by<ordered_unique<member<BB2DomainInfo, domainid_t, &BB2DomainInfo::d_id>>,
228	ordered_unique<tag<NameTag>, member<BB2DomainInfo, ZoneName, &BB2DomainInfo::d_name>>>>
229	state_t;
230	static SharedLockGuarded<state_t> s_state;
231
232	void parseZoneFile(BB2DomainInfo* bbd);
233	void rediscover(string* status = nullptr) override;
234
235	// for autoprimary support
236	bool autoPrimariesList(std::vector<AutoPrimary>& primaries) override;
237	bool autoPrimaryBackend(const string& ipAddress, const ZoneName& domain, const vector<DNSResourceRecord>& nsset, string* nameserver, string* account, DNSBackend** backend) override;
238	static std::mutex s_autosecondary_config_lock;
239	bool createSecondaryDomain(const string& ipAddress, const ZoneName& domain, const string& nameserver, const string& account) override;
240
241	private:
242	void setupDNSSEC();
243	void setupStatements();
244	void freeStatements();
245	static bool safeGetBBDomainInfo(domainid_t id, BB2DomainInfo* bbd);
246	static void safePutBBDomainInfo(const BB2DomainInfo& bbd);
247	static bool safeGetBBDomainInfo(const ZoneName& name, BB2DomainInfo* bbd);
248	static bool safeRemoveBBDomainInfo(const ZoneName& name);
249	shared_ptr<SSQLite3> d_dnssecdb;
250	bool getNSEC3PARAM(const ZoneName& name, NSEC3PARAMRecordContent* ns3p);
251	static void setLastCheck(domainid_t domain_id, time_t lastcheck);
252	bool getNSEC3PARAMuncached(const ZoneName& name, NSEC3PARAMRecordContent* ns3p);
253	class handle
254	{
255	public:
256	bool get(DNSResourceRecord&);
257	void reset();
258
259	handle();
260
261	handle(const handle&) = delete;
262	handle& operator=(const handle&) = delete; // don't go copying this
263
264	shared_ptr<const recordstorage_t> d_records;
265	recordstorage_t::index<UnorderedNameTag>::type::const_iterator d_iter, d_end_iter;
266
267	recordstorage_t::const_iterator d_qname_iter, d_qname_end;
268
269	DNSName qname;
270	ZoneName domain;
271
272	domainid_t id{UnknownDomainID};
273	QType qtype;
274	bool d_list{false};
275	bool mustlog{false};
276
277	private:
278	bool get_normal(DNSResourceRecord&);
279	bool get_list(DNSResourceRecord&);
280	};
281
282	unique_ptr<SSqlStatement> d_getAllDomainMetadataQuery_stmt;
283	unique_ptr<SSqlStatement> d_getDomainMetadataQuery_stmt;
284	unique_ptr<SSqlStatement> d_deleteDomainMetadataQuery_stmt;
285	unique_ptr<SSqlStatement> d_insertDomainMetadataQuery_stmt;
286	unique_ptr<SSqlStatement> d_getDomainKeysQuery_stmt;
287	unique_ptr<SSqlStatement> d_deleteDomainKeyQuery_stmt;
288	unique_ptr<SSqlStatement> d_insertDomainKeyQuery_stmt;
289	unique_ptr<SSqlStatement> d_GetLastInsertedKeyIdQuery_stmt;
290	unique_ptr<SSqlStatement> d_activateDomainKeyQuery_stmt;
291	unique_ptr<SSqlStatement> d_deactivateDomainKeyQuery_stmt;
292	unique_ptr<SSqlStatement> d_publishDomainKeyQuery_stmt;
293	unique_ptr<SSqlStatement> d_unpublishDomainKeyQuery_stmt;
294	unique_ptr<SSqlStatement> d_getTSIGKeyQuery_stmt;
295	unique_ptr<SSqlStatement> d_setTSIGKeyQuery_stmt;
296	unique_ptr<SSqlStatement> d_deleteTSIGKeyQuery_stmt;
297	unique_ptr<SSqlStatement> d_getTSIGKeysQuery_stmt;
298
299	ZoneName d_transaction_qname;
300	string d_transaction_tmpname;
301	string d_logprefix;
302	set<string> alsoNotify; //!< this is used to store the also-notify list of interested peers.
303	std::unique_ptr<ofstream> d_of;
304	handle d_handle;
305	static string s_binddirectory; //!< this is used to store the 'directory' setting of the bind configuration
306	static int s_first; //!< this is raised on construction to prevent multiple instances of us being generated
307	domainid_t d_transaction_id;
308	static bool s_ignore_broken_records;
309	bool d_hybrid;
310	bool d_upgradeContent;
311
312	BB2DomainInfo createDomainEntry(const ZoneName& domain); //!< does not insert in s_state
313
314	void queueReloadAndStore(domainid_t id);
315	static bool findBeforeAndAfterUnhashed(std::shared_ptr<const recordstorage_t>& records, const DNSName& qname, DNSName& unhashed, DNSName& before, DNSName& after);
316	static void insertRecord(std::shared_ptr<recordstorage_t>& records, const ZoneName& zoneName, const DNSName& qname, const QType& qtype, const string& content, int ttl, const std::string& hashed = string(), const bool* auth = nullptr);
317	void reload() override;
318	static string DLDomStatusHandler(const vector<string>& parts, Utility::pid_t ppid);
319	static string DLDomExtendedStatusHandler(const vector<string>& parts, Utility::pid_t ppid);
320	static string DLListRejectsHandler(const vector<string>& parts, Utility::pid_t ppid);
321	static string DLReloadNowHandler(const vector<string>& parts, Utility::pid_t ppid);
322	static string DLAddDomainHandler(const vector<string>& parts, Utility::pid_t ppid);
323	static void fixupOrderAndAuth(std::shared_ptr<recordstorage_t>& records, const ZoneName& zoneName, bool nsec3zone, const NSEC3PARAMRecordContent& ns3pr);
324	static void doEmptyNonTerminals(std::shared_ptr<recordstorage_t>& records, const ZoneName& zoneName, bool nsec3zone, const NSEC3PARAMRecordContent& ns3pr);
325	void loadConfig(string* status = nullptr);
326	};

PowerDNS / pdns / 19151133429

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