#include "namespaces.hh"
-class NetworkError : public runtime_error
-{
-public:
- NetworkError(const string& why="Network Error") : runtime_error(why.c_str())
- {}
- NetworkError(const char *why="Network Error") : runtime_error(why)
- {}
-};
-
-
typedef int ProtocolType; //!< Supported protocol types
//! Representation of a Socket and many of the Berkeley functions available
class Socket : public boost::noncopyable
{
- Socket(int fd)
+ Socket(int fd): d_socket(fd)
{
- d_socket = fd;
- d_buflen=4096;
- d_buffer=new char[d_buflen];
}
public:
//! 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)
+ if((d_socket=socket(af, st, pt))<0)
throw NetworkError(strerror(errno));
setCloseOnExec(d_socket);
+ }
- d_buflen=4096;
- d_buffer=new char[d_buflen];
+ Socket(Socket&& rhs): d_buffer(std::move(rhs.d_buffer)), d_socket(rhs.d_socket)
+ {
+ rhs.d_socket = -1;
}
~Socket()
{
try {
- closesocket(d_socket);
+ if (d_socket != -1) {
+ closesocket(d_socket);
+ }
}
catch(const PDNSException& e) {
}
-
- delete[] d_buffer;
}
//! If the socket is capable of doing so, this function will wait for a connection
- Socket *accept()
+ std::unique_ptr<Socket> accept()
{
struct sockaddr_in remote;
socklen_t remlen=sizeof(remote);
memset(&remote, 0, sizeof(remote));
- int s=::accept(d_socket,(sockaddr *)&remote, &remlen);
+ int s=::accept(d_socket, reinterpret_cast<sockaddr *>(&remote), &remlen);
if(s<0) {
if(errno==EAGAIN)
- return 0;
+ return nullptr;
throw NetworkError("Accepting a connection: "+string(strerror(errno)));
}
- return new Socket(s);
+ return std::unique_ptr<Socket>(new Socket(s));
}
//! Get remote address
bool getRemote(ComboAddress &remote) {
socklen_t remotelen=sizeof(remote);
- return (getpeername(d_socket, (struct sockaddr *)&remote, &remotelen) >= 0);
+ return (getpeername(d_socket, reinterpret_cast<struct sockaddr *>(&remote), &remotelen) >= 0);
}
//! Check remote address against netmaskgroup ng
- bool acl(NetmaskGroup &ng)
+ bool acl(const NetmaskGroup &ng)
{
ComboAddress remote;
if (getRemote(remote))
- return ng.match((ComboAddress *) &remote);
+ return ng.match(remote);
return false;
}
{
::setNonBlocking(d_socket);
}
+
//! Set the socket to blocking
void setBlocking()
{
void setReuseAddr()
{
- int tmp = 1;
- if (setsockopt(d_socket, SOL_SOCKET, SO_REUSEADDR, (char*)&tmp, static_cast<unsigned>(sizeof tmp))<0)
- throw NetworkError(string("Setsockopt failed: ")+strerror(errno));
+ try {
+ ::setReuseAddr(d_socket);
+ } catch (const PDNSException &e) {
+ throw NetworkError(e.reason);
+ }
}
//! Bind the socket to a specified endpoint
- void bind(const ComboAddress &local)
+ void bind(const ComboAddress &local, bool reuseaddr=true)
{
int tmp=1;
- if(setsockopt(d_socket, SOL_SOCKET, SO_REUSEADDR,(char*)&tmp,sizeof tmp)<0)
+ if(reuseaddr && setsockopt(d_socket, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<char*>(&tmp), sizeof tmp)<0)
throw NetworkError(string("Setsockopt failed: ")+strerror(errno));
- if(::bind(d_socket,(struct sockaddr *)&local, local.getSocklen())<0)
+ if(::bind(d_socket, reinterpret_cast<const struct sockaddr *>(&local), local.getSocklen())<0)
throw NetworkError("While binding: "+string(strerror(errno)));
}
-#if 0
- //! Bind the socket to a specified endpoint
- void bind(const ComboAddress &ep)
- {
- ComboAddress local;
- memset(reinterpret_cast<char *>(&local),0,sizeof(local));
- local.sin_family=d_family;
- local.sin_addr.s_addr=ep.address.byte;
- local.sin_port=htons(ep.port);
-
- bind(local);
- }
-#endif
//! Connect the socket to a specified endpoint
void connect(const ComboAddress &ep, int timeout=0)
{
- if(::connect(d_socket,(struct sockaddr *)&ep, ep.getSocklen()) < 0) {
- if(errno == EINPROGRESS) {
- if (timeout > 0) {
- /* if a timeout is provided, we wait until the connection has been established */
- int res = waitForRWData(d_socket, false, timeout, 0);
- if (res == 0) {
- throw NetworkError("timeout while connecting to "+ep.toStringWithPort());
- } else if (res < 0) {
- throw NetworkError("while waiting to connect to "+ep.toStringWithPort()+": "+string(strerror(errno)));
- }
- }
- }
- else {
- throw NetworkError("While connecting to "+ep.toStringWithPort()+": "+string(strerror(errno)));
- }
- }
+ SConnectWithTimeout(d_socket, ep, timeout);
}
\param ep Will be filled with the origin of the datagram */
void recvFrom(string &dgram, ComboAddress &ep)
{
- socklen_t remlen=sizeof(ep);
+ socklen_t remlen = sizeof(ep);
ssize_t bytes;
- if((bytes=recvfrom(d_socket, d_buffer, d_buflen, 0, (sockaddr *)&ep , &remlen)) <0)
+ 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: "+string(strerror(errno)));
- dgram.assign(d_buffer,bytes);
+ dgram.assign(d_buffer, 0, static_cast<size_t>(bytes));
}
bool recvFromAsync(string &dgram, ComboAddress &ep)
{
struct sockaddr_in remote;
- socklen_t remlen=sizeof(remote);
+ socklen_t remlen = sizeof(remote);
ssize_t bytes;
- if((bytes=recvfrom(d_socket, d_buffer, d_buflen, 0, (sockaddr *)&remote, &remlen))<0) {
+ 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: "+string(strerror(errno)));
}
return false;
}
}
- dgram.assign(d_buffer,bytes);
+ 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, (sockaddr *)&ep, ep.getSocklen())<0)
+ if(sendto(d_socket, msg, len, 0, reinterpret_cast<const sockaddr *>(&ep), ep.getSocklen())<0)
throw NetworkError("After sendto: "+string(strerror(errno)));
}
throw NetworkError("Writing to a socket: "+string(strerror(errno)));
if(!res)
throw NetworkError("EOF on socket");
- toWrite-=(size_t)res;
- ptr+=(size_t)res;
- }while(toWrite);
+ toWrite -= static_cast<size_t>(res);
+ ptr += static_cast<size_t>(res);
+ } while(toWrite);
}
void writenWithTimeout(const void *buffer, size_t n, int timeout)
{
size_t bytes=n;
- const char *ptr = (char*)buffer;
+ const char *ptr = reinterpret_cast<const char*>(buffer);
ssize_t ret;
while(bytes) {
ret=::write(d_socket, ptr, bytes);
throw NetworkError("Did not fulfill TCP write due to EOF");
}
- ptr += (size_t) ret;
- bytes -= (size_t) ret;
+ ptr += static_cast<size_t>(ret);
+ bytes -= static_cast<size_t>(ret);
}
}
//! Reads a block of data from the socket to a string
void read(string &data)
{
- ssize_t res=::recv(d_socket,d_buffer,d_buflen,0);
+ 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: "+string(strerror(errno)));
- data.assign(d_buffer,res);
+ 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);
+ ssize_t res=::recv(d_socket, buffer, bytes, 0);
if(res<0)
throw NetworkError("Reading from a socket: "+string(strerror(errno)));
- return (size_t) res;
+ return static_cast<size_t>(res);
}
ssize_t readWithTimeout(char* buffer, size_t n, int timeout)
}
private:
- char *d_buffer;
+ static const size_t s_buflen{4096};
+ std::string d_buffer;
int d_socket;
- size_t d_buflen;
};
projects / thirdparty / pdns.git / blobdiff