Build has been set to done!

6547751431

Committed 17 Oct 2023 01:15PM UTC coverage: 63.12% (+5.6%) from 57.471%

Build # 6547751431

Build Type

Pull #13385

github

Committed by

web-flow

Commit Message

Merge 514a3c922 into 8314f12e9

Pull Request Pull Request #13385: Assorted delinting, mark do while loops as ok

Run Details

30635 of 71270 branches covered (0.0%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

785 existing lines in 37 files now uncovered.

102963 of 140388 relevant lines covered (73.34%)

3019319.3 hits per line

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

61.76

/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"


typedef int ProtocolType; //!< 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): d_buffer(std::move(rhs.d_buffer)), d_socket(rhs.d_socket)
  {
    rhs.d_socket = -1;
  }

  Socket& operator=(Socket&& rhs)
  {
    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 &ep)
  {
    socklen_t remlen = sizeof(ep);
    ssize_t bytes;
    d_buffer.resize(s_buflen);
    if((bytes=recvfrom(d_socket, &d_buffer[0], s_buflen, 0, reinterpret_cast<sockaddr *>(&ep) , &remlen)) <0)
      throw NetworkError("After recvfrom: "+stringerror());

    dgram.assign(d_buffer, 0, static_cast<size_t>(bytes));
  }

  bool recvFromAsync(string &dgram)
  {
    struct sockaddr_in remote;
    socklen_t remlen = sizeof(remote);
    ssize_t bytes;
    d_buffer.resize(s_buflen);
    if((bytes=recvfrom(d_socket, &d_buffer[0], s_buflen, 0, reinterpret_cast<sockaddr *>(&remote), &remlen))<0) {
      if(errno!=EAGAIN) {
        throw NetworkError("After async recvfrom: "+stringerror());
      }
      else {
        return false;
      }
    }
    dgram.assign(d_buffer, 0, 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 &ep)
  {
    if(sendto(d_socket, msg, len, 0, reinterpret_cast<const sockaddr *>(&ep), ep.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.c_str(), msg.size(), 0)<0)
      throw NetworkError("After send: "+stringerror());
  }


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


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

PowerDNS / pdns / 6547751431

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