11213411203

Committed 07 Oct 2024 10:15AM UTC coverage: 61.343% (-3.4%) from 64.722%

Build # 11213411203

Build Type

Pull #14506

github

Committed by

web-flow

Commit Message

Merge 2b1998f49 into 9dd0277ef

Pull Request Pull Request #14506: rec: notify_allowed should be processed for forward_zones and forward_zones_recurse

Run Details

34064 of 88058 branches covered (38.68%)

Branch coverage included in aggregate %.

5 of 9 new or added lines in 1 file covered. (55.56%)

5429 existing lines in 76 files now uncovered.

119466 of 162225 relevant lines covered (73.64%)

4198702.13 hits per line

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

65.5

/pdns/recursordist/nod.cc

/*
 * 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.
 */

#include "nod.hh"
#include <fstream>
#include "pdnsexception.hh"
#include <iostream>
#include <iomanip>
#include <ctime>
#include <thread>
#include "threadname.hh"
#include <cstdlib>
#include "logger.hh"
#include "logging.hh"
#include "misc.hh"

using namespace nod;
namespace filesystem = boost::filesystem;

// PersistentSBF Implementation

std::mutex PersistentSBF::d_cachedir_mutex;

void PersistentSBF::remove_tmp_files(const filesystem::path& path, std::lock_guard<std::mutex>& /* lock */)
{
  Regex file_regex(d_prefix + ".*\\." + bf_suffix + "\\..{8}$");
  for (const auto& file : filesystem::directory_iterator(path)) {
    if (filesystem::is_regular_file(file.path()) && file_regex.match(file.path().filename().string())) {
      filesystem::remove(file);
    }
  }
}

// This looks for the newest (per-thread) snapshot it can find and it restores from that. Then
// immediately snapshots with the current thread id, before removing the old snapshot.
// In this way, we can have per-thread SBFs, but still snapshot and restore.  The mutex has to be
// static because we can't have multiple (i.e. per-thread) instances iterating and writing to the
// cache dir at the same time
bool PersistentSBF::init(bool ignore_pid)
{
  auto log = g_slog->withName("nod");
  std::lock_guard<std::mutex> lock(d_cachedir_mutex);
  if (d_cachedir.length() != 0) {
    filesystem::path path(d_cachedir);
    try {
      if (filesystem::exists(path) && filesystem::is_directory(path)) {
        remove_tmp_files(path, lock);
        filesystem::path newest_file;
        std::time_t newest_time = 0;
        Regex file_regex(d_prefix + ".*\\." + bf_suffix + "$");
        for (const auto& file : filesystem::directory_iterator(path)) {
          if (filesystem::is_regular_file(file.path()) && file_regex.match(file.path().filename().string())) {
            if (ignore_pid || (file.path().filename().string().find(std::to_string(getpid())) == std::string::npos)) {
              // look for the newest file matching the regex
              if (last_write_time(file.path()) > newest_time) {
                newest_time = last_write_time(file.path());
                newest_file = file.path();
              }
            }
          }
        }
        if (!newest_file.empty() && filesystem::exists(newest_file)) {
          const std::string& filename = newest_file.string();
          std::ifstream infile;
          try {
            infile.open(filename, std::ios::in | std::ios::binary);
            SLOG(g_log << Logger::Warning << "Found SBF file " << filename << endl,
                 log->info(Logr::Warning, "Found SBF File", "file", Logging::Loggable(filename)));
            // read the file into the sbf
            d_sbf.lock()->restore(infile);
            infile.close();
            // now dump it out again with new thread id & process id
            snapshotCurrent(std::this_thread::get_id());
            // Remove the old file we just read to stop proliferation
            filesystem::remove(newest_file);
          }
          catch (const std::runtime_error& e) {
            infile.close();
            filesystem::remove(newest_file);
            SLOG(g_log << Logger::Warning << "NODDB init: Cannot parse file: " << filename << ": " << e.what() << "; removed" << endl,
                 log->error(Logr::Warning, e.what(), "NODDB init: Cannot parse file, removed", "file", Logging::Loggable(filename)));
          }
        }
      }
    }
    catch (const filesystem::filesystem_error& e) {
      SLOG(g_log << Logger::Warning << "NODDB init failed: " << e.what() << endl,
           log->error(Logr::Warning, e.what(), "NODDB init failed", "exception", Logging::Loggable("filesystem::filesystem_error")));
      return false;
    }
  }
  return true;
}

void PersistentSBF::setCacheDir(const std::string& cachedir)
{
  filesystem::path path(cachedir);
  if (!exists(path)) {
    throw PDNSException("NODDB setCacheDir specified nonexistent directory: " + cachedir);
  }
  if (!is_directory(path)) {
    throw PDNSException("NODDB setCacheDir specified a file not a directory: " + cachedir);
  }
  d_cachedir = cachedir;
}

// Dump the SBF to a file
// To spend the least amount of time inside the mutex, we dump to an
// intermediate stringstream, otherwise the lock would be waiting for
// file IO to complete
bool PersistentSBF::snapshotCurrent(std::thread::id tid)
{
  auto log = g_slog->withName("nod");
  if (d_cachedir.length() != 0) {
    filesystem::path path(d_cachedir);
    filesystem::path file(d_cachedir);
    std::stringstream strStream;
    strStream << d_prefix << "_" << tid;
    file /= strStream.str() + "_" + std::to_string(getpid()) + "." + bf_suffix;
    if (filesystem::exists(path) && filesystem::is_directory(path)) {
      try {
        std::ostringstream oss;
        {
          // only lock while dumping to a stringstream
          d_sbf.lock()->dump(oss);
        }
        // Now write it out to the file
        std::string ftmp = file.string() + ".XXXXXXXX";
        auto fileDesc = FDWrapper(mkstemp(ftmp.data()));
        if (fileDesc == -1) {
          throw std::runtime_error("Cannot create temp file: " + stringerror());
        }
        const std::string str = oss.str(); // XXX creates a copy, with c++20 we can use view()
        ssize_t len = write(fileDesc, str.data(), str.length());
        if (len != static_cast<ssize_t>(str.length())) {
          filesystem::remove(ftmp.c_str());
          throw std::runtime_error("Failed to write to file:" + ftmp);
        }
        if (fileDesc.reset() != 0) {
          filesystem::remove(ftmp);
          throw std::runtime_error("Failed to write to file:" + ftmp);
        }
        try {
          filesystem::rename(ftmp, file);
        }
        catch (const std::runtime_error& e) {
          SLOG(g_log << Logger::Warning << "NODDB snapshot: Cannot rename file: " << e.what() << endl,
               log->error(Logr::Warning, e.what(), "NODDB snapshot: Cannot rename file", "exception", Logging::Loggable("std::runtime_error")));
          filesystem::remove(ftmp);
          throw;
        }
        return true;
      }
      catch (const std::runtime_error& e) {
        SLOG(g_log << Logger::Warning << "NODDB snapshot: Cannot write file: " << e.what() << endl,
             log->error(Logr::Warning, e.what(), "NODDB snapshot: Cannot write file", "exception", Logging::Loggable("std::runtime_error")));
      }
    }
    else {
      SLOG(g_log << Logger::Warning << "NODDB snapshot: Cannot write file: " << file.string() << endl,
           log->info(Logr::Warning, "NODDB snapshot: Cannot write file", "file", Logging::Loggable(file.string())));
    }
  }
  return false;
}

// NODDB Implementation

void NODDB::housekeepingThread(std::thread::id tid)
{
  setThreadName("rec/nod-hk");
  for (;;) {
    std::this_thread::sleep_for(std::chrono::seconds(d_snapshot_interval));
    snapshotCurrent(tid);
  }
}

bool NODDB::isNewDomain(const std::string& domain)
{
  DNSName dname(domain);
  return isNewDomain(dname);
}

bool NODDB::isNewDomain(const DNSName& dname)
{
  std::string dname_lc = dname.toDNSStringLC();
  // the result is always the inverse of what is returned by the SBF
  return !d_psbf.testAndAdd(dname_lc);
}

bool NODDB::isNewDomainWithParent(const std::string& domain, std::string& observed)
{
  DNSName dname(domain);
  return isNewDomainWithParent(dname, observed);
}

bool NODDB::isNewDomainWithParent(const DNSName& dname, std::string& observed)
{
  bool ret = isNewDomain(dname);
  if (ret) {
    DNSName mdname = dname;
    while (mdname.chopOff()) {
      if (!isNewDomain(mdname)) {
        observed = mdname.toString();
        break;
      }
    }
  }
  return ret;
}

void NODDB::addDomain(const DNSName& dname)
{
  std::string native_domain = dname.toDNSStringLC();
  d_psbf.add(native_domain);
}

void NODDB::addDomain(const std::string& domain)
{
  DNSName dname(domain);
  addDomain(dname);
}

// UniqueResponseDB Implementation
bool UniqueResponseDB::isUniqueResponse(const std::string& response)
{
  return !d_psbf.testAndAdd(response);
}

void UniqueResponseDB::addResponse(const std::string& response)
{
  d_psbf.add(response);
}

void UniqueResponseDB::housekeepingThread(std::thread::id tid)
{
  setThreadName("rec/udr-hk");
  for (;;) {
    std::this_thread::sleep_for(std::chrono::seconds(d_snapshot_interval));
    snapshotCurrent(tid);
  }
}

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
23	#include "nod.hh"
24	#include <fstream>
25	#include "pdnsexception.hh"
26	#include <iostream>
27	#include <iomanip>
28	#include <ctime>
29	#include <thread>
30	#include "threadname.hh"
31	#include <cstdlib>
32	#include "logger.hh"
33	#include "logging.hh"
34	#include "misc.hh"
35
36	using namespace nod;
37	namespace filesystem = boost::filesystem;
38
39	// PersistentSBF Implementation
40
41	std::mutex PersistentSBF::d_cachedir_mutex;
42
43	void PersistentSBF::remove_tmp_files(const filesystem::path& path, std::lock_guard<std::mutex>& /* lock */)
44	{	3✔
45	Regex file_regex(d_prefix + ".*\\." + bf_suffix + "\\..{8}$");	3✔
46	for (const auto& file : filesystem::directory_iterator(path)) {	938✔
47	if (filesystem::is_regular_file(file.path()) && file_regex.match(file.path().filename().string())) {	938!
48	filesystem::remove(file);	×
49	}	×
50	}	938✔
51	}	3✔
52
53	// This looks for the newest (per-thread) snapshot it can find and it restores from that. Then
54	// immediately snapshots with the current thread id, before removing the old snapshot.
55	// In this way, we can have per-thread SBFs, but still snapshot and restore. The mutex has to be
56	// static because we can't have multiple (i.e. per-thread) instances iterating and writing to the
57	// cache dir at the same time
58	bool PersistentSBF::init(bool ignore_pid)
59	{	3✔
60	auto log = g_slog->withName("nod");	3✔
61	std::lock_guard<std::mutex> lock(d_cachedir_mutex);	3✔
62	if (d_cachedir.length() != 0) {	3!
63	filesystem::path path(d_cachedir);	3✔
64	try {	3✔
65	if (filesystem::exists(path) && filesystem::is_directory(path)) {	3!
66	remove_tmp_files(path, lock);	3✔
67	filesystem::path newest_file;	3✔
68	std::time_t newest_time = 0;	3✔
69	Regex file_regex(d_prefix + ".*\\." + bf_suffix + "$");	3✔
70	for (const auto& file : filesystem::directory_iterator(path)) {	938✔
71	if (filesystem::is_regular_file(file.path()) && file_regex.match(file.path().filename().string())) {	938✔
72	if (ignore_pid \|\| (file.path().filename().string().find(std::to_string(getpid())) == std::string::npos)) {	1!
73	// look for the newest file matching the regex
74	if (last_write_time(file.path()) > newest_time) {	1!
75	newest_time = last_write_time(file.path());	1✔
76	newest_file = file.path();	1✔
77	}	1✔
78	}	1✔
79	}	1✔
80	}	938✔
81	if (!newest_file.empty() && filesystem::exists(newest_file)) {	3!
82	const std::string& filename = newest_file.string();	1✔
83	std::ifstream infile;	1✔
84	try {	1✔
85	infile.open(filename, std::ios::in \| std::ios::binary);	1✔
86	SLOG(g_log << Logger::Warning << "Found SBF file " << filename << endl,	1✔
87	log->info(Logr::Warning, "Found SBF File", "file", Logging::Loggable(filename)));	1✔
88	// read the file into the sbf
89	d_sbf.lock()->restore(infile);	1✔
90	infile.close();	1✔
91	// now dump it out again with new thread id & process id
92	snapshotCurrent(std::this_thread::get_id());	1✔
93	// Remove the old file we just read to stop proliferation
94	filesystem::remove(newest_file);	1✔
95	}	1✔
96	catch (const std::runtime_error& e) {	1✔
97	infile.close();	×
98	filesystem::remove(newest_file);	×
99	SLOG(g_log << Logger::Warning << "NODDB init: Cannot parse file: " << filename << ": " << e.what() << "; removed" << endl,	×
100	log->error(Logr::Warning, e.what(), "NODDB init: Cannot parse file, removed", "file", Logging::Loggable(filename)));	×
101	}	×
102	}	1✔
103	}	3✔
104	}	3✔
105	catch (const filesystem::filesystem_error& e) {	3✔
106	SLOG(g_log << Logger::Warning << "NODDB init failed: " << e.what() << endl,	×
107	log->error(Logr::Warning, e.what(), "NODDB init failed", "exception", Logging::Loggable("filesystem::filesystem_error")));	×
108	return false;	×
109	}	×
110	}	3✔
111	return true;	3✔
112	}	3✔
113
114	void PersistentSBF::setCacheDir(const std::string& cachedir)
115	{	4✔
116	filesystem::path path(cachedir);	4✔
117	if (!exists(path)) {	4✔
118	throw PDNSException("NODDB setCacheDir specified nonexistent directory: " + cachedir);	1✔
119	}	1✔
120	if (!is_directory(path)) {	3!
121	throw PDNSException("NODDB setCacheDir specified a file not a directory: " + cachedir);	×
122	}	×
123	d_cachedir = cachedir;	3✔
124	}	3✔
125
126	// Dump the SBF to a file
127	// To spend the least amount of time inside the mutex, we dump to an
128	// intermediate stringstream, otherwise the lock would be waiting for
129	// file IO to complete
130	bool PersistentSBF::snapshotCurrent(std::thread::id tid)
131	{	2✔
132	auto log = g_slog->withName("nod");	2✔
133	if (d_cachedir.length() != 0) {	2!
134	filesystem::path path(d_cachedir);	2✔
135	filesystem::path file(d_cachedir);	2✔
136	std::stringstream strStream;	2✔
137	strStream << d_prefix << "_" << tid;	2✔
138	file /= strStream.str() + "_" + std::to_string(getpid()) + "." + bf_suffix;	2✔
139	if (filesystem::exists(path) && filesystem::is_directory(path)) {	2!
140	try {	2✔
141	std::ostringstream oss;	2✔
142	{	2✔
143	// only lock while dumping to a stringstream
144	d_sbf.lock()->dump(oss);	2✔
145	}	2✔
146	// Now write it out to the file
147	std::string ftmp = file.string() + ".XXXXXXXX";	2✔
148	auto fileDesc = FDWrapper(mkstemp(ftmp.data()));	2✔
149	if (fileDesc == -1) {	2!
150	throw std::runtime_error("Cannot create temp file: " + stringerror());	×
151	}	×
152	const std::string str = oss.str(); // XXX creates a copy, with c++20 we can use view()	2✔
153	ssize_t len = write(fileDesc, str.data(), str.length());	2✔
154	if (len != static_cast<ssize_t>(str.length())) {	2!
155	filesystem::remove(ftmp.c_str());	×
156	throw std::runtime_error("Failed to write to file:" + ftmp);	×
157	}	×
158	if (fileDesc.reset() != 0) {	2!
159	filesystem::remove(ftmp);	×
160	throw std::runtime_error("Failed to write to file:" + ftmp);	×
161	}	×
162	try {	2✔
163	filesystem::rename(ftmp, file);	2✔
164	}	2✔
165	catch (const std::runtime_error& e) {	2✔
166	SLOG(g_log << Logger::Warning << "NODDB snapshot: Cannot rename file: " << e.what() << endl,	×
167	log->error(Logr::Warning, e.what(), "NODDB snapshot: Cannot rename file", "exception", Logging::Loggable("std::runtime_error")));	×
168	filesystem::remove(ftmp);	×
169	throw;	×
170	}	×
171	return true;	2✔
172	}	2✔
173	catch (const std::runtime_error& e) {	2✔
174	SLOG(g_log << Logger::Warning << "NODDB snapshot: Cannot write file: " << e.what() << endl,	×
175	log->error(Logr::Warning, e.what(), "NODDB snapshot: Cannot write file", "exception", Logging::Loggable("std::runtime_error")));	×
176	}	×
177	}	2✔
178	else {	×
179	SLOG(g_log << Logger::Warning << "NODDB snapshot: Cannot write file: " << file.string() << endl,	×
180	log->info(Logr::Warning, "NODDB snapshot: Cannot write file", "file", Logging::Loggable(file.string())));	×
181	}	×
182	}	2✔
183	return false;	×
184	}	2✔
185
186	// NODDB Implementation
187
188	void NODDB::housekeepingThread(std::thread::id tid)
UNCOV 189	{	×
UNCOV 190	setThreadName("rec/nod-hk");	×
UNCOV 191	for (;;) {	×
UNCOV 192	std::this_thread::sleep_for(std::chrono::seconds(d_snapshot_interval));	×
UNCOV 193	snapshotCurrent(tid);	×
UNCOV 194	}	×
UNCOV 195	}	×
196
197	bool NODDB::isNewDomain(const std::string& domain)
198	{	1,000,000✔
199	DNSName dname(domain);	1,000,000✔
200	return isNewDomain(dname);	1,000,000✔
201	}	1,000,000✔
202
203	bool NODDB::isNewDomain(const DNSName& dname)
204	{	1,000,012✔
205	std::string dname_lc = dname.toDNSStringLC();	1,000,012✔
206	// the result is always the inverse of what is returned by the SBF
207	return !d_psbf.testAndAdd(dname_lc);	1,000,012✔
208	}	1,000,012✔
209
210	bool NODDB::isNewDomainWithParent(const std::string& domain, std::string& observed)
211	{	×
212	DNSName dname(domain);	×
213	return isNewDomainWithParent(dname, observed);	×
214	}	×
215
216	bool NODDB::isNewDomainWithParent(const DNSName& dname, std::string& observed)
217	{	1✔
218	bool ret = isNewDomain(dname);	1✔
219	if (ret) {	1!
220	DNSName mdname = dname;	1✔
221	while (mdname.chopOff()) {	1!
222	if (!isNewDomain(mdname)) {	1!
223	observed = mdname.toString();	1✔
224	break;	1✔
225	}	1✔
226	}	1✔
227	}	1✔
228	return ret;	1✔
229	}	1✔
230
231	void NODDB::addDomain(const DNSName& dname)
232	{	1✔
233	std::string native_domain = dname.toDNSStringLC();	1✔
234	d_psbf.add(native_domain);	1✔
235	}	1✔
236
237	void NODDB::addDomain(const std::string& domain)
238	{	1✔
239	DNSName dname(domain);	1✔
240	addDomain(dname);	1✔
241	}	1✔
242
243	// UniqueResponseDB Implementation
244	bool UniqueResponseDB::isUniqueResponse(const std::string& response)
UNCOV 245	{	×
UNCOV 246	return !d_psbf.testAndAdd(response);	×
UNCOV 247	}	×
248
249	void UniqueResponseDB::addResponse(const std::string& response)
250	{	×
251	d_psbf.add(response);	×
252	}	×
253
254	void UniqueResponseDB::housekeepingThread(std::thread::id tid)
UNCOV 255	{	×
UNCOV 256	setThreadName("rec/udr-hk");	×
UNCOV 257	for (;;) {	×
UNCOV 258	std::this_thread::sleep_for(std::chrono::seconds(d_snapshot_interval));	×
UNCOV 259	snapshotCurrent(tid);	×
UNCOV 260	}	×
UNCOV 261	}	×

PowerDNS / pdns / 11213411203

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