7142875844

Committed 08 Dec 2023 03:00PM UTC coverage: 57.633% (+0.003%) from 57.63%

Build # 7142875844

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #13584 from rgacogne/ddist-network-listener-data

dnsdist: Fix a small race in the NetworkListener

Run Details

31759 of 86282 branches covered (0.0%)

Branch coverage included in aggregate %.

27 of 29 new or added lines in 1 file covered. (93.1%)

27 existing lines in 8 files now uncovered.

106775 of 154091 relevant lines covered (69.29%)

3717644.18 hits per line

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

90.4

/pdns/dnsdistdist/dnsdist-lua-network.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 <sys/socket.h>
#include <sys/un.h>

#include "dnsdist-lua-network.hh"
#include "dolog.hh"
#include "threadname.hh"

namespace dnsdist
{
NetworkListener::ListenerData::ListenerData() :
  d_mplexer(std::unique_ptr<FDMultiplexer>(FDMultiplexer::getMultiplexerSilent(10)))
{
}

NetworkListener::NetworkListener() :
  d_data(std::make_shared<ListenerData>())
{
}

NetworkListener::~NetworkListener()
{
  d_data->d_exiting = true;
}

void NetworkListener::readCB(int desc, FDMultiplexer::funcparam_t& param)
{
  auto cbData = boost::any_cast<std::shared_ptr<NetworkListener::CBData>>(param);
  std::string packet;

#ifdef MSG_TRUNC
  /* first we peek to avoid allocating a very large buffer. "MSG_TRUNC [...] return the real length of the datagram, even when it was longer than the passed buffer" */
  auto peeked = recvfrom(desc, nullptr, 0, MSG_PEEK | MSG_TRUNC, nullptr, nullptr);
  if (peeked > 0) {
    packet.resize(static_cast<size_t>(peeked));
  }
#endif
  if (packet.empty()) {
    packet.resize(65535);
  }

  sockaddr_un from{};
  memset(&from, 0, sizeof(from));

  socklen_t fromLen = sizeof(from);
  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
  auto got = recvfrom(desc, &packet.at(0), packet.size(), 0, reinterpret_cast<sockaddr*>(&from), &fromLen);
  if (got > 0) {
    packet.resize(static_cast<size_t>(got));
    std::string fromAddr;
    if (fromLen <= sizeof(from)) {
      // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-array-to-pointer-decay)
      fromAddr = std::string(from.sun_path, strlen(from.sun_path));
    }
    try {
      cbData->d_cb(cbData->d_endpoint, std::move(packet), fromAddr);
    }
    catch (const std::exception& e) {
      vinfolog("Exception in the read callback of a NetworkListener: %s", e.what());
    }
    catch (...) {
      vinfolog("Exception in the read callback of a NetworkListener");
    }
  }
}

bool NetworkListener::addUnixListeningEndpoint(const std::string& path, NetworkListener::EndpointID endpointID, NetworkListener::NetworkDatagramCB callback)
{
  if (d_data->d_running) {
    throw std::runtime_error("NetworkListener should not be altered at runtime");
  }

  sockaddr_un sun{};
  if (makeUNsockaddr(path, &sun) != 0) {
    throw std::runtime_error("Invalid Unix socket path '" + path + "'");
  }

  bool abstractPath = path.at(0) == '\0';
  if (!abstractPath) {
    int err = unlink(path.c_str());
    if (err != 0) {
      err = errno;
      if (err != ENOENT) {
        vinfolog("Error removing Unix socket to path '%s': %s", path, stringerror(err));
      }
    }
  }

  Socket sock(sun.sun_family, SOCK_DGRAM, 0);
  socklen_t sunLength = sizeof(sun);
  if (abstractPath) {
    /* abstract paths can contain null bytes so we need to set the actual size */
    sunLength = sizeof(sa_family_t) + path.size();
  }

  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
  if (bind(sock.getHandle(), reinterpret_cast<const struct sockaddr*>(&sun), sunLength) != 0) {
    std::string sanitizedPath(path);
    if (abstractPath) {
      sanitizedPath[0] = '@';
    }
    throw std::runtime_error("Error binding Unix socket to path '" + sanitizedPath + "': " + stringerror());
  }

  sock.setNonBlocking();

  auto cbData = std::make_shared<CBData>();
  cbData->d_endpoint = endpointID;
  cbData->d_cb = std::move(callback);
  d_data->d_mplexer->addReadFD(sock.getHandle(), readCB, cbData);

  d_data->d_sockets.insert({path, std::move(sock)});
  return true;
}

void NetworkListener::runOnce(ListenerData& data, timeval& now, uint32_t timeout)
{
  if (data.d_exiting) {
    return;
  }

  data.d_running = true;
  if (data.d_sockets.empty()) {
    throw runtime_error("NetworkListener started with no sockets");
  }

  data.d_mplexer->run(&now, static_cast<int>(timeout));
}

void NetworkListener::runOnce(timeval& now, uint32_t timeout)
{
  runOnce(*d_data, now, timeout);
}

void NetworkListener::mainThread(std::shared_ptr<ListenerData>& dataArg)
{
  /* take our own copy of the shared_ptr so it's still alive if the NetworkListener object
     gets destroyed while we are still running */
  // NOLINTNEXTLINE(performance-unnecessary-copy-initialization): we really need a copy here, or we end up with use-after-free as explained above
  auto data = dataArg;
  setThreadName("dnsdist/lua-net");
  timeval now{};

  while (!data->d_exiting) {
    runOnce(*data, now, -1);
  }
}

void NetworkListener::start()
{
  std::thread main = std::thread([this] {
    mainThread(d_data);
  });
  main.detach();
}

NetworkEndpoint::NetworkEndpoint(const std::string& path) :
  d_socket(AF_UNIX, SOCK_DGRAM, 0)
{
  sockaddr_un sun{};
  if (makeUNsockaddr(path, &sun) != 0) {
    throw std::runtime_error("Invalid Unix socket path '" + path + "'");
  }

  socklen_t sunLength = sizeof(sun);
  bool abstractPath = path.at(0) == '\0';

  if (abstractPath) {
    /* abstract paths can contain null bytes so we need to set the actual size */
    sunLength = sizeof(sa_family_t) + path.size();
  }
  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
  if (connect(d_socket.getHandle(), reinterpret_cast<const struct sockaddr*>(&sun), sunLength) != 0) {
    std::string sanitizedPath(path);
    if (abstractPath) {
      sanitizedPath[0] = '@';
    }
    throw std::runtime_error("Error connecting Unix socket to path '" + sanitizedPath + "': " + stringerror());
  }

  d_socket.setNonBlocking();
}

bool NetworkEndpoint::send(const std::string_view& payload) const
{
  auto sent = ::send(d_socket.getHandle(), payload.data(), payload.size(), 0);
  if (sent <= 0) {
    return false;
  }

  return static_cast<size_t>(sent) == payload.size();
}
}

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	#include <sys/socket.h>
23	#include <sys/un.h>
24
25	#include "dnsdist-lua-network.hh"
26	#include "dolog.hh"
27	#include "threadname.hh"
28
29	namespace dnsdist
30	{
31	NetworkListener::ListenerData::ListenerData() :
32	d_mplexer(std::unique_ptr<FDMultiplexer>(FDMultiplexer::getMultiplexerSilent(10)))
33	{	21✔
34	}	21✔
35
36	NetworkListener::NetworkListener() :
37	d_data(std::make_shared<ListenerData>())
38	{	21✔
39	}	21✔
40
41	NetworkListener::~NetworkListener()
42	{	17✔
43	d_data->d_exiting = true;	17✔
44	}	17✔
45
46	void NetworkListener::readCB(int desc, FDMultiplexer::funcparam_t& param)
47	{	315✔
48	auto cbData = boost::any_cast<std::shared_ptr<NetworkListener::CBData>>(param);	315✔
49	std::string packet;	315✔
50
51	#ifdef MSG_TRUNC	315✔
52	/* first we peek to avoid allocating a very large buffer. "MSG_TRUNC [...] return the real length of the datagram, even when it was longer than the passed buffer" */
53	auto peeked = recvfrom(desc, nullptr, 0, MSG_PEEK \| MSG_TRUNC, nullptr, nullptr);	315✔
54	if (peeked > 0) {	315!
55	packet.resize(static_cast<size_t>(peeked));	315✔
56	}	315✔
57	#endif	315✔
58	if (packet.empty()) {	315!
59	packet.resize(65535);	×
60	}	×
61
62	sockaddr_un from{};	315✔
63	memset(&from, 0, sizeof(from));	315✔
64
65	socklen_t fromLen = sizeof(from);	315✔
66	// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
67	auto got = recvfrom(desc, &packet.at(0), packet.size(), 0, reinterpret_cast<sockaddr*>(&from), &fromLen);	315✔
68	if (got > 0) {	315!
69	packet.resize(static_cast<size_t>(got));	315✔
70	std::string fromAddr;	315✔
71	if (fromLen <= sizeof(from)) {	315!
72	// NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-array-to-pointer-decay)
73	fromAddr = std::string(from.sun_path, strlen(from.sun_path));	315✔
74	}	315✔
75	try {	315✔
76	cbData->d_cb(cbData->d_endpoint, std::move(packet), fromAddr);	315✔
77	}	315✔
78	catch (const std::exception& e) {	315✔
79	vinfolog("Exception in the read callback of a NetworkListener: %s", e.what());	2!
80	}	2✔
81	catch (...) {	315✔
82	vinfolog("Exception in the read callback of a NetworkListener");	2!
83	}	2✔
84	}	315✔
85	}	315✔
86
87	bool NetworkListener::addUnixListeningEndpoint(const std::string& path, NetworkListener::EndpointID endpointID, NetworkListener::NetworkDatagramCB callback)
88	{	23✔
89	if (d_data->d_running) {	23✔
90	throw std::runtime_error("NetworkListener should not be altered at runtime");	2✔
91	}	2✔
92
93	sockaddr_un sun{};	21✔
94	if (makeUNsockaddr(path, &sun) != 0) {	21✔
95	throw std::runtime_error("Invalid Unix socket path '" + path + "'");	2✔
96	}	2✔
97
98	bool abstractPath = path.at(0) == '\0';	19✔
99	if (!abstractPath) {	19✔
100	int err = unlink(path.c_str());	13✔
101	if (err != 0) {	13✔
102	err = errno;	2✔
103	if (err != ENOENT) {	2!
104	vinfolog("Error removing Unix socket to path '%s': %s", path, stringerror(err));	×
105	}	×
106	}	2✔
107	}	13✔
108
109	Socket sock(sun.sun_family, SOCK_DGRAM, 0);	19✔
110	socklen_t sunLength = sizeof(sun);	19✔
111	if (abstractPath) {	19✔
112	/* abstract paths can contain null bytes so we need to set the actual size */
113	sunLength = sizeof(sa_family_t) + path.size();	6✔
114	}	6✔
115
116	// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
117	if (bind(sock.getHandle(), reinterpret_cast<const struct sockaddr*>(&sun), sunLength) != 0) {	19✔
118	std::string sanitizedPath(path);	2✔
119	if (abstractPath) {	2!
120	sanitizedPath[0] = '@';	2✔
121	}	2✔
122	throw std::runtime_error("Error binding Unix socket to path '" + sanitizedPath + "': " + stringerror());	2✔
123	}	2✔
124
125	sock.setNonBlocking();	17✔
126
127	auto cbData = std::make_shared<CBData>();	17✔
128	cbData->d_endpoint = endpointID;	17✔
129	cbData->d_cb = std::move(callback);	17✔
130	d_data->d_mplexer->addReadFD(sock.getHandle(), readCB, cbData);	17✔
131
132	d_data->d_sockets.insert({path, std::move(sock)});	17✔
133	return true;	17✔
134	}	19✔
135
136	void NetworkListener::runOnce(ListenerData& data, timeval& now, uint32_t timeout)
137	{	320✔
138	if (data.d_exiting) {	320!
NEW 139	return;	×
NEW 140	}	×
141
142	data.d_running = true;	320✔
143	if (data.d_sockets.empty()) {	320✔
144	throw runtime_error("NetworkListener started with no sockets");	2✔
145	}	2✔
146
147	data.d_mplexer->run(&now, static_cast<int>(timeout));	318✔
148	}	318✔
149
150	void NetworkListener::runOnce(timeval& now, uint32_t timeout)
151	{	12✔
152	runOnce(*d_data, now, timeout);	12✔
153	}	12✔
154
155	void NetworkListener::mainThread(std::shared_ptr<ListenerData>& dataArg)
156	{	4✔
157	/* take our own copy of the shared_ptr so it's still alive if the NetworkListener object
158	gets destroyed while we are still running */
159	// NOLINTNEXTLINE(performance-unnecessary-copy-initialization): we really need a copy here, or we end up with use-after-free as explained above
160	auto data = dataArg;	4✔
161	setThreadName("dnsdist/lua-net");	4✔
162	timeval now{};	4✔
163
164	while (!data->d_exiting) {	312✔
165	runOnce(*data, now, -1);	308✔
166	}	308✔
167	}	4✔
168
169	void NetworkListener::start()
170	{	4✔
171	std::thread main = std::thread([this] {	4✔
172	mainThread(d_data);	4✔
173	});	4✔
174	main.detach();	4✔
175	}	4✔
176
177	NetworkEndpoint::NetworkEndpoint(const std::string& path) :
178	d_socket(AF_UNIX, SOCK_DGRAM, 0)
179	{	22✔
180	sockaddr_un sun{};	22✔
181	if (makeUNsockaddr(path, &sun) != 0) {	22✔
182	throw std::runtime_error("Invalid Unix socket path '" + path + "'");	2✔
183	}	2✔
184
185	socklen_t sunLength = sizeof(sun);	20✔
186	bool abstractPath = path.at(0) == '\0';	20✔
187
188	if (abstractPath) {	20✔
189	/* abstract paths can contain null bytes so we need to set the actual size */
190	sunLength = sizeof(sa_family_t) + path.size();	4✔
191	}	4✔
192	// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
193	if (connect(d_socket.getHandle(), reinterpret_cast<const struct sockaddr*>(&sun), sunLength) != 0) {	20✔
194	std::string sanitizedPath(path);	5✔
195	if (abstractPath) {	5✔
196	sanitizedPath[0] = '@';	2✔
197	}	2✔
198	throw std::runtime_error("Error connecting Unix socket to path '" + sanitizedPath + "': " + stringerror());	5✔
199	}	5✔
200
201	d_socket.setNonBlocking();	15✔
202	}	15✔
203
204	bool NetworkEndpoint::send(const std::string_view& payload) const
205	{	379✔
206	auto sent = ::send(d_socket.getHandle(), payload.data(), payload.size(), 0);	379✔
207	if (sent <= 0) {	379✔
208	return false;	20✔
209	}	20✔
210
211	return static_cast<size_t>(sent) == payload.size();	359✔
212	}	379✔
213	}

PowerDNS / pdns / 7142875844

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