8829878961

Committed 25 Apr 2024 09:04AM UTC coverage: 59.439% (-0.02%) from 59.454%

Build # 8829878961

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #14104 from rgacogne/ddist-fix-abort-nghttp2_session_mem_recv

dnsdist: Fix a crash in incoming DoH with nghttp2

Run Details

32594 of 87448 branches covered (37.27%)

Branch coverage included in aggregate %.

10 of 12 new or added lines in 1 file covered. (83.33%)

35 existing lines in 10 files now uncovered.

114114 of 159375 relevant lines covered (71.6%)

2943137.79 hits per line

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

65.17

/pdns/sstuff.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 <string>
#include <sstream>
#include <iostream>
#include "iputils.hh"
#include <cerrno>
#include <sys/types.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <sys/select.h>
#include <fcntl.h>
#include <stdexcept>

#include <boost/utility.hpp>
#include <csignal>
#include "namespaces.hh"
#include "noinitvector.hh"

using ProtocolType = int; //!< Supported protocol types

//! Representation of a Socket and many of the Berkeley functions available
class Socket : public boost::noncopyable
{
public:
  Socket(int fd): d_socket(fd)
  {
  }

  //! Construct a socket of specified address family and socket type.
  Socket(int af, int st, ProtocolType pt=0)
  {
    if((d_socket=socket(af, st, pt))<0)
      throw NetworkError(stringerror());
    setCloseOnExec(d_socket);
  }

  Socket(Socket&& rhs) noexcept :
    d_buffer(std::move(rhs.d_buffer)), d_socket(rhs.d_socket)
  {
    rhs.d_socket = -1;
  }

  Socket& operator=(Socket&& rhs) noexcept
  {
    if (d_socket != -1) {
      close(d_socket);
    }
    d_socket = rhs.d_socket;
    rhs.d_socket = -1;
    d_buffer = std::move(rhs.d_buffer);
    return *this;
  }

  ~Socket()
  {
    try {
      if (d_socket != -1) {
        closesocket(d_socket);
      }
    }
    catch(const PDNSException& e) {
    }
  }

  //! If the socket is capable of doing so, this function will wait for a connection
  std::unique_ptr<Socket> accept()
  {
    struct sockaddr_in remote;
    socklen_t remlen=sizeof(remote);
    memset(&remote, 0, sizeof(remote));
    int s=::accept(d_socket, reinterpret_cast<sockaddr *>(&remote), &remlen);
    if(s<0) {
      if(errno==EAGAIN)
        return nullptr;

      throw NetworkError("Accepting a connection: "+stringerror());
    }

    return std::make_unique<Socket>(s);
  }

  //! Get remote address
  bool getRemote(ComboAddress &remote) {
    socklen_t remotelen=sizeof(remote);
    return (getpeername(d_socket, reinterpret_cast<struct sockaddr *>(&remote), &remotelen) >= 0);
  }

  //! Check remote address against netmaskgroup ng
  bool acl(const NetmaskGroup &ng)
  {
    ComboAddress remote;
    if (getRemote(remote))
      return ng.match(remote);

    return false;
  }

  //! Set the socket to non-blocking
  void setNonBlocking()
  {
    ::setNonBlocking(d_socket);
  }

  //! Set the socket to blocking
  void setBlocking()
  {
    ::setBlocking(d_socket);
  }

  void setReuseAddr()
  {
    try {
      ::setReuseAddr(d_socket);
    } catch (const PDNSException &e) {
      throw NetworkError(e.reason);
    }
  }

  void setFastOpenConnect()
  {
#ifdef TCP_FASTOPEN_CONNECT
    int on = 1;
    if (setsockopt(d_socket, IPPROTO_TCP, TCP_FASTOPEN_CONNECT, &on, sizeof(on)) < 0) {
      throw NetworkError("While setting TCP_FASTOPEN_CONNECT: " + stringerror());
    }
#else
   throw NetworkError("While setting TCP_FASTOPEN_CONNECT: not compiled in");
#endif
  }

  //! Bind the socket to a specified endpoint
  void bind(const ComboAddress &local, bool reuseaddr=true)
  {
    int tmp=1;
    if(reuseaddr && setsockopt(d_socket, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<char*>(&tmp), sizeof tmp)<0)
      throw NetworkError("Setsockopt failed: "+stringerror());

    if(::bind(d_socket, reinterpret_cast<const struct sockaddr *>(&local), local.getSocklen())<0)
      throw NetworkError("While binding: "+stringerror());
  }

  //! Connect the socket to a specified endpoint
  void connect(const ComboAddress &ep, int timeout=0)
  {
    SConnectWithTimeout(d_socket, ep, timeval{timeout,0});
  }


  //! For datagram sockets, receive a datagram and learn where it came from
  /** For datagram sockets, receive a datagram and learn where it came from
      \param dgram Will be filled with the datagram
      \param ep Will be filled with the origin of the datagram */
  void recvFrom(string &dgram, ComboAddress& remote)
  {
    socklen_t remlen = sizeof(remote);
    if (dgram.size() < s_buflen) {
      dgram.resize(s_buflen);
    }
    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
    auto bytes = recvfrom(d_socket, dgram.data(), dgram.size(), 0, reinterpret_cast<sockaddr *>(&remote) , &remlen);
    if (bytes < 0) {
      throw NetworkError("After recvfrom: " + stringerror());
    }
    dgram.resize(static_cast<size_t>(bytes));
  }

  bool recvFromAsync(PacketBuffer& dgram, ComboAddress& remote)
  {
    socklen_t remlen = sizeof(remote);
    if (dgram.size() < s_buflen) {
      dgram.resize(s_buflen);
    }
    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
    auto bytes = recvfrom(d_socket, dgram.data(), dgram.size(), 0, reinterpret_cast<sockaddr *>(&remote), &remlen);
    if (bytes < 0) {
      if (errno != EAGAIN) {
        throw NetworkError("After async recvfrom: " + stringerror());
      }
      else {
        return false;
      }
    }
    dgram.resize(static_cast<size_t>(bytes));
    return true;
  }

  //! For datagram sockets, send a datagram to a destination
  void sendTo(const char* msg, size_t len, const ComboAddress& remote)
  {
    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
    if (sendto(d_socket, msg, len, 0, reinterpret_cast<const sockaddr *>(&remote), remote.getSocklen()) < 0) {
      throw NetworkError("After sendto: " + stringerror());
    }
  }

  //! For connected datagram sockets, send a datagram
  void send(const std::string& msg)
  {
    if (::send(d_socket, msg.data(), msg.size(), 0) < 0) {
      throw NetworkError("After send: "+stringerror());
    }
  }


  /** For datagram sockets, send a datagram to a destination
      \param dgram The datagram
      \param remote The intended destination of the datagram */
  void sendTo(const string& dgram, const ComboAddress& remote)
  {
    sendTo(dgram.data(), dgram.length(), remote);
  }


  //! Write this data to the socket, taking care that all bytes are written out
  void writen(const string &data)
  {
    if(data.empty())
      return;

    size_t toWrite=data.length();
    ssize_t res;
    const char *ptr=data.c_str();

    do {
      res=::send(d_socket, ptr, toWrite, 0);
      if(res<0)
        throw NetworkError("Writing to a socket: "+stringerror());
      if(!res)
        throw NetworkError("EOF on socket");
      toWrite -= static_cast<size_t>(res);
      ptr += static_cast<size_t>(res);
    } while(toWrite);

  }

  //! tries to write toWrite bytes from ptr to the socket
  /** tries to write toWrite bytes from ptr to the socket, but does not make sure they al get written out
      \param ptr Location to write from
      \param toWrite number of bytes to try
  */
  size_t tryWrite(const char *ptr, size_t toWrite)
  {
    ssize_t res;
    res=::send(d_socket,ptr,toWrite,0);
    if(res==0)
      throw NetworkError("EOF on writing to a socket");

    if(res>0)
      return res;

    if(errno==EAGAIN)
      return 0;

    throw NetworkError("Writing to a socket: "+stringerror());
  }

  //! Writes toWrite bytes from ptr to the socket
  /** Writes toWrite bytes from ptr to the socket. Returns how many bytes were written */
  size_t write(const char *ptr, size_t toWrite)
  {
    ssize_t res;
    res=::send(d_socket,ptr,toWrite,0);
    if(res<0) {
      throw NetworkError("Writing to a socket: "+stringerror());
    }
    return res;
  }

  void writenWithTimeout(const void *buffer, size_t n, int timeout)
  {
    size_t bytes=n;
    const char *ptr = reinterpret_cast<const char*>(buffer);
    ssize_t ret;
    while(bytes) {
      ret=::write(d_socket, ptr, bytes);
      if(ret < 0) {
        if(errno == EAGAIN) {
          ret=waitForRWData(d_socket, false, timeout, 0);
          if(ret < 0)
            throw NetworkError("Waiting for data write");
          if(!ret)
            throw NetworkError("Timeout writing data");
          continue;
        }
        else
          throw NetworkError("Writing data: "+stringerror());
      }
      if(!ret) {
        throw NetworkError("Did not fulfill TCP write due to EOF");
      }

      ptr += static_cast<size_t>(ret);
      bytes -= static_cast<size_t>(ret);
    }
  }

  //! reads one character from the socket
  int getChar()
  {
    char c;

    ssize_t res=::recv(d_socket,&c,1,0);
    if(res)
      return c;
    return -1;
  }

  void getline(string &data)
  {
    data="";
    int c;
    while((c=getChar())!=-1) {
      data+=(char)c;
      if(c=='\n')
        break;
    }
  }

  //! Reads a block of data from the socket to a string
  void read(string &data)
  {
    d_buffer.resize(s_buflen);
    ssize_t res=::recv(d_socket, &d_buffer[0], s_buflen, 0);
    if(res<0)
      throw NetworkError("Reading from a socket: "+stringerror());
    data.assign(d_buffer, 0, static_cast<size_t>(res));
  }

  //! Reads a block of data from the socket to a block of memory
  size_t read(char *buffer, size_t bytes)
  {
    ssize_t res=::recv(d_socket, buffer, bytes, 0);
    if(res<0)
      throw NetworkError("Reading from a socket: "+stringerror());
    return static_cast<size_t>(res);
  }

  /** Read a bock of data from the socket to a block of memory,
  *   waiting at most 'timeout' seconds for the data to become
  *   available. Be aware that this does _NOT_ handle partial reads
  *   for you.
  */
  ssize_t readWithTimeout(char* buffer, size_t n, int timeout)
  {
    int err = waitForRWData(d_socket, true, timeout, 0);

    if(err == 0)
      throw NetworkError("timeout reading");
    if(err < 0)
      throw NetworkError("nonblocking read failed: "+stringerror());

    return read(buffer, n);
  }

  //! Sets the socket to listen with a default listen backlog of 10 pending connections
  void listen(unsigned int length=10)
  {
    if(::listen(d_socket,length)<0)
      throw NetworkError("Setting socket to listen: "+stringerror());
  }

  //! Returns the internal file descriptor of the socket
  int getHandle() const
  {
    return d_socket;
  }

  int releaseHandle()
  {
    int ret = d_socket;
    d_socket = -1;
    return ret;
  }

private:
  static const size_t s_buflen{4096};
  std::string d_buffer;
  int d_socket;
};

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 <sstream>
25	#include <iostream>
26	#include "iputils.hh"
27	#include <cerrno>
28	#include <sys/types.h>
29	#include <unistd.h>
30	#include <sys/socket.h>
31	#include <netinet/in.h>
32	#include <netinet/tcp.h>
33	#include <arpa/inet.h>
34	#include <sys/select.h>
35	#include <fcntl.h>
36	#include <stdexcept>
37
38	#include <boost/utility.hpp>
39	#include <csignal>
40	#include "namespaces.hh"
41	#include "noinitvector.hh"
42
43	using ProtocolType = int; //!< Supported protocol types
44
45	//! Representation of a Socket and many of the Berkeley functions available
46	class Socket : public boost::noncopyable
47	{
48	public:
49	Socket(int fd): d_socket(fd)
50	{	7,474✔
51	}	7,474✔
52
53	//! Construct a socket of specified address family and socket type.
54	Socket(int af, int st, ProtocolType pt=0)
55	{	51,795✔
56	if((d_socket=socket(af, st, pt))<0)	51,795!
57	throw NetworkError(stringerror());	×
58	setCloseOnExec(d_socket);	51,795✔
59	}	51,795✔
60
61	Socket(Socket&& rhs) noexcept :
62	d_buffer(std::move(rhs.d_buffer)), d_socket(rhs.d_socket)
63	{	1,023✔
64	rhs.d_socket = -1;	1,023✔
65	}	1,023✔
66
67	Socket& operator=(Socket&& rhs) noexcept
68	{	1,078✔
69	if (d_socket != -1) {	1,078!
70	close(d_socket);	×
71	}	×
72	d_socket = rhs.d_socket;	1,078✔
73	rhs.d_socket = -1;	1,078✔
74	d_buffer = std::move(rhs.d_buffer);	1,078✔
75	return *this;	1,078✔
76	}	1,078✔
77
78	~Socket()
79	{	81,227✔
80	try {	81,227✔
81	if (d_socket != -1) {	81,227✔
82	closesocket(d_socket);	33,672✔
83	}	33,672✔
84	}	81,227✔
85	catch(const PDNSException& e) {	81,227✔
86	}	×
87	}	81,227✔
88
89	//! If the socket is capable of doing so, this function will wait for a connection
90	std::unique_ptr<Socket> accept()
91	{	1,472✔
92	struct sockaddr_in remote;	1,472✔
93	socklen_t remlen=sizeof(remote);	1,472✔
94	memset(&remote, 0, sizeof(remote));	1,472✔
95	int s=::accept(d_socket, reinterpret_cast<sockaddr *>(&remote), &remlen);	1,472✔
96	if(s<0) {	1,472!
97	if(errno==EAGAIN)	×
98	return nullptr;	×
99
100	throw NetworkError("Accepting a connection: "+stringerror());	×
101	}	×
102
103	return std::make_unique<Socket>(s);	1,472✔
104	}	1,472✔
105
106	//! Get remote address
107	bool getRemote(ComboAddress &remote) {	2,924✔
108	socklen_t remotelen=sizeof(remote);	2,924✔
109	return (getpeername(d_socket, reinterpret_cast<struct sockaddr *>(&remote), &remotelen) >= 0);	2,924✔
110	}	2,924✔
111
112	//! Check remote address against netmaskgroup ng
113	bool acl(const NetmaskGroup &ng)
114	{	1,462✔
115	ComboAddress remote;	1,462✔
116	if (getRemote(remote))	1,462!
117	return ng.match(remote);	1,462✔
118
119	return false;	×
120	}	1,462✔
121
122	//! Set the socket to non-blocking
123	void setNonBlocking()
124	{	32,751✔
125	::setNonBlocking(d_socket);	32,751✔
126	}	32,751✔
127
128	//! Set the socket to blocking
129	void setBlocking()
130	{	7✔
131	::setBlocking(d_socket);	7✔
132	}	7✔
133
134	void setReuseAddr()
135	{	34✔
136	try {	34✔
137	::setReuseAddr(d_socket);	34✔
138	} catch (const PDNSException &e) {	34✔
139	throw NetworkError(e.reason);	×
140	}	×
141	}	34✔
142
143	void setFastOpenConnect()
144	{	×
145	#ifdef TCP_FASTOPEN_CONNECT	×
146	int on = 1;	×
147	if (setsockopt(d_socket, IPPROTO_TCP, TCP_FASTOPEN_CONNECT, &on, sizeof(on)) < 0) {	×
148	throw NetworkError("While setting TCP_FASTOPEN_CONNECT: " + stringerror());	×
149	}	×
150	#else
151	throw NetworkError("While setting TCP_FASTOPEN_CONNECT: not compiled in");
152	#endif
153	}	×
154
155	//! Bind the socket to a specified endpoint
156	void bind(const ComboAddress &local, bool reuseaddr=true)
157	{	360✔
158	int tmp=1;	360✔
159	if(reuseaddr && setsockopt(d_socket, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<char*>(&tmp), sizeof tmp)<0)	360!
160	throw NetworkError("Setsockopt failed: "+stringerror());	×
161
162	if(::bind(d_socket, reinterpret_cast<const struct sockaddr *>(&local), local.getSocklen())<0)	360!
163	throw NetworkError("While binding: "+stringerror());	×
164	}	360✔
165
166	//! Connect the socket to a specified endpoint
167	void connect(const ComboAddress &ep, int timeout=0)
168	{	19,388✔
169	SConnectWithTimeout(d_socket, ep, timeval{timeout,0});	19,388✔
170	}	19,388✔
171
172
173	//! For datagram sockets, receive a datagram and learn where it came from
174	/** For datagram sockets, receive a datagram and learn where it came from
175	\param dgram Will be filled with the datagram
176	\param ep Will be filled with the origin of the datagram */
177	void recvFrom(string &dgram, ComboAddress& remote)
178	{
179	socklen_t remlen = sizeof(remote);
180	if (dgram.size() < s_buflen) {
181	dgram.resize(s_buflen);
182	}
183	// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
184	auto bytes = recvfrom(d_socket, dgram.data(), dgram.size(), 0, reinterpret_cast<sockaddr *>(&remote) , &remlen);
185	if (bytes < 0) {
186	throw NetworkError("After recvfrom: " + stringerror());
187	}
188	dgram.resize(static_cast<size_t>(bytes));
189	}
190
191	bool recvFromAsync(PacketBuffer& dgram, ComboAddress& remote)
192	{	2,116✔
193	socklen_t remlen = sizeof(remote);	2,116✔
194	if (dgram.size() < s_buflen) {	2,116!
195	dgram.resize(s_buflen);	×
196	}	×
197	// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
198	auto bytes = recvfrom(d_socket, dgram.data(), dgram.size(), 0, reinterpret_cast<sockaddr *>(&remote), &remlen);	2,116✔
199	if (bytes < 0) {	2,116✔
200	if (errno != EAGAIN) {	988!
201	throw NetworkError("After async recvfrom: " + stringerror());	×
202	}	×
203	else {	988✔
204	return false;	988✔
205	}	988✔
206	}	988✔
207	dgram.resize(static_cast<size_t>(bytes));	1,128✔
208	return true;	1,128✔
209	}	2,116✔
210
211	//! For datagram sockets, send a datagram to a destination
212	void sendTo(const char* msg, size_t len, const ComboAddress& remote)
213	{	471✔
214	// NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
215	if (sendto(d_socket, msg, len, 0, reinterpret_cast<const sockaddr *>(&remote), remote.getSocklen()) < 0) {	471!
216	throw NetworkError("After sendto: " + stringerror());
217	}
218	}	471✔
219
220	//! For connected datagram sockets, send a datagram
221	void send(const std::string& msg)
222	{	248✔
223	if (::send(d_socket, msg.data(), msg.size(), 0) < 0) {	248!
224	throw NetworkError("After send: "+stringerror());	×
225	}	×
226	}	248✔
227
228
229	/** For datagram sockets, send a datagram to a destination
230	\param dgram The datagram
231	\param remote The intended destination of the datagram */
232	void sendTo(const string& dgram, const ComboAddress& remote)
233	{
234	sendTo(dgram.data(), dgram.length(), remote);
235	}
236
237
238	//! Write this data to the socket, taking care that all bytes are written out
239	void writen(const string &data)
240	{	16✔
241	if(data.empty())	16!
242	return;
243
244	size_t toWrite=data.length();	16✔
245	ssize_t res;	16✔
246	const char *ptr=data.c_str();	16✔
247
248	do {	16✔
249	res=::send(d_socket, ptr, toWrite, 0);	16✔
250	if(res<0)	16!
251	throw NetworkError("Writing to a socket: "+stringerror());
252	if(!res)	16!
253	throw NetworkError("EOF on socket");
254	toWrite -= static_cast<size_t>(res);	16✔
255	ptr += static_cast<size_t>(res);	16✔
256	} while(toWrite);	16!
257
258	}	16✔
259
260	//! tries to write toWrite bytes from ptr to the socket
261	/** tries to write toWrite bytes from ptr to the socket, but does not make sure they al get written out
262	\param ptr Location to write from
263	\param toWrite number of bytes to try
264	*/
265	size_t tryWrite(const char *ptr, size_t toWrite)
266	{	×
267	ssize_t res;	×
268	res=::send(d_socket,ptr,toWrite,0);	×
269	if(res==0)	×
270	throw NetworkError("EOF on writing to a socket");	×
271		×
272	if(res>0)	×
273	return res;	×
274		×
275	if(errno==EAGAIN)	×
276	return 0;	×
277		×
278	throw NetworkError("Writing to a socket: "+stringerror());	×
279	}	×
280
281	//! Writes toWrite bytes from ptr to the socket
282	/** Writes toWrite bytes from ptr to the socket. Returns how many bytes were written */
283	size_t write(const char *ptr, size_t toWrite)
284	{
285	ssize_t res;
286	res=::send(d_socket,ptr,toWrite,0);
287	if(res<0) {
288	throw NetworkError("Writing to a socket: "+stringerror());
289	}
290	return res;
291	}
292
293	void writenWithTimeout(const void *buffer, size_t n, int timeout)
294	{	1,751✔
295	size_t bytes=n;	1,751✔
296	const char ptr = reinterpret_cast<const char>(buffer);	1,751✔
297	ssize_t ret;	1,751✔
298	while(bytes) {	3,510✔
299	ret=::write(d_socket, ptr, bytes);	1,759✔
300	if(ret < 0) {	1,759✔
301	if(errno == EAGAIN) {	4!
302	ret=waitForRWData(d_socket, false, timeout, 0);	4✔
303	if(ret < 0)	4!
304	throw NetworkError("Waiting for data write");	×
305	if(!ret)	4!
306	throw NetworkError("Timeout writing data");	×
307	continue;	4✔
308	}	4✔
309	else	×
310	throw NetworkError("Writing data: "+stringerror());	×
311	}	4✔
312	if(!ret) {	1,755!
313	throw NetworkError("Did not fulfill TCP write due to EOF");	×
314	}	×
315
316	ptr += static_cast<size_t>(ret);	1,755✔
317	bytes -= static_cast<size_t>(ret);	1,755✔
318	}	1,755✔
319	}	1,751✔
320
321	//! reads one character from the socket
322	int getChar()
323	{	×
324	char c;	×
325		×
326	ssize_t res=::recv(d_socket,&c,1,0);	×
327	if(res)	×
328	return c;	×
329	return -1;	×
330	}	×
331
332	void getline(string &data)
333	{	×
334	data="";	×
335	int c;	×
336	while((c=getChar())!=-1) {	×
337	data+=(char)c;	×
338	if(c=='\n')	×
339	break;	×
340	}	×
341	}	×
342
343	//! Reads a block of data from the socket to a string
344	void read(string &data)
345	{	248✔
346	d_buffer.resize(s_buflen);	248✔
347	ssize_t res=::recv(d_socket, &d_buffer[0], s_buflen, 0);	248✔
348	if(res<0)	248!
UNCOV 349	throw NetworkError("Reading from a socket: "+stringerror());	×
350	data.assign(d_buffer, 0, static_cast<size_t>(res));	248✔
351	}	248✔
352
353	//! Reads a block of data from the socket to a block of memory
354	size_t read(char *buffer, size_t bytes)
355	{	26,198✔
356	ssize_t res=::recv(d_socket, buffer, bytes, 0);	26,198✔
357	if(res<0)	26,198✔
358	throw NetworkError("Reading from a socket: "+stringerror());	4✔
359	return static_cast<size_t>(res);	26,194✔
360	}	26,198✔
361
362	/** Read a bock of data from the socket to a block of memory,
363	* waiting at most 'timeout' seconds for the data to become
364	* available. Be aware that this does _NOT_ handle partial reads
365	* for you.
366	*/
367	ssize_t readWithTimeout(char* buffer, size_t n, int timeout)
368	{	1,966✔
369	int err = waitForRWData(d_socket, true, timeout, 0);	1,966✔
370
371	if(err == 0)	1,966!
372	throw NetworkError("timeout reading");	×
373	if(err < 0)	1,966!
374	throw NetworkError("nonblocking read failed: "+stringerror());	×
375
376	return read(buffer, n);	1,966✔
377	}	1,966✔
378
379	//! Sets the socket to listen with a default listen backlog of 10 pending connections
380	void listen(unsigned int length=10)
381	{	66✔
382	if(::listen(d_socket,length)<0)	66!
383	throw NetworkError("Setting socket to listen: "+stringerror());	×
384	}	66✔
385
386	//! Returns the internal file descriptor of the socket
387	int getHandle() const
388	{	105,198✔
389	return d_socket;	105,198✔
390	}	105,198✔
391
392	int releaseHandle()
393	{	7,203✔
394	int ret = d_socket;	7,203✔
395	d_socket = -1;	7,203✔
396	return ret;	7,203✔
397	}	7,203✔
398
399	private:
400	static const size_t s_buflen{4096};
401	std::string d_buffer;
402	int d_socket;
403	};

PowerDNS / pdns / 8829878961

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