sstuff.hh

#include <string>
#include <sstream>
#include <iostream>
#include <errno.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/select.h>
#include <fcntl.h>

using namespace std;


typedef string NetworkError;

class IPAddress
{
public:
  u_int32_t byte; 

  IPAddress()
  {
    byte=0;
  }
  IPAddress(const string &remote)
  {
    struct in_addr addr;
    if(!inet_aton(remote.c_str(), &addr))
      throw NetworkError("Could not convert '"+remote+"' to an IP address");
    byte=addr.s_addr;
  }

  string asString() const
  {
    ostringstream o;
    const unsigned char *n=reinterpret_cast<const unsigned char*>(&byte);
    o<<(unsigned int)*n++<<".";
    o<<(unsigned int)*n++<<".";
    o<<(unsigned int)*n++<<".";
    o<<(int)*n++;
    return o.str();
  }
};

typedef u_int16_t IPPort;

class IPEndpoint
{
public:

  IPEndpoint(){}   
  IPEndpoint(const string &remote, IPPort aport=0) : address(remote), port(aport){} 
  IPAddress address;
  IPPort port;
  enum PortTypes {ANY=0};
};


enum AddressFamily {InterNetwork=AF_INET}; 
enum SocketType {Datagram=SOCK_DGRAM,Stream=SOCK_STREAM}; 
typedef int ProtocolType; 

class Socket
{
private:
  Socket(const Socket &);
  Socket &operator=(const Socket &);

  Socket(int fd)
  {
    d_buflen=1024;
    d_buffer=new char[d_buflen];
    d_socket=fd;
  }
public:
  Socket(AddressFamily af, SocketType st, ProtocolType pt=0)
  {
    d_family=af;
    if((d_socket=socket(af,st, pt))<0)
      throw NetworkError(strerror(errno));
    d_buflen=1024;
    d_buffer=new char[d_buflen];
  }

  ~Socket()
  {
    close(d_socket);
    delete[] d_buffer;
  }

  Socket *accept()
  {
    struct sockaddr_in remote;
    socklen_t remlen=sizeof(remote);
    int s=::accept(d_socket,(sockaddr *)&remote, &remlen);
    if(s<0) {
      if(errno==EAGAIN)
        return 0;

      throw NetworkError("Accepting a connection: "+string(strerror(errno)));
    }
    return new Socket(s);
  }

  void setNonBlocking()
  {
    int flags=fcntl(d_socket,F_GETFL,0);    
    if(flags<0 || fcntl(d_socket, F_SETFL,flags|O_NONBLOCK) <0)
      throw NetworkError("Setting socket to nonblocking: "+string(strerror(errno)));
  }

  void bind(const IPEndpoint &ep)
  {
    struct sockaddr_in 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);
    
    int tmp=1;
    if(setsockopt(d_socket,SOL_SOCKET,SO_REUSEADDR,(char*)&tmp,sizeof tmp)<0)
      throw NetworkError(string("Setsockopt failed: ")+strerror(errno));

    if(::bind(d_socket,(struct sockaddr *)&local,sizeof(local))<0)
      throw NetworkError(strerror(errno));
  }


  void recvFrom(string &dgram, IPEndpoint &ep)
  {
    struct sockaddr_in remote;
    socklen_t remlen=sizeof(remote);
    int bytes;
    if((bytes=recvfrom(d_socket, d_buffer, d_buflen, 0, (sockaddr *)&remote, &remlen))<0)
      throw NetworkError(strerror(errno));
    
    dgram.assign(d_buffer,bytes);
    ep.address.byte=remote.sin_addr.s_addr;
    ep.port=ntohs(remote.sin_port);
  }


  void sendTo(const string &dgram, const IPEndpoint &ep)
  {
    struct sockaddr_in remote;
    remote.sin_family=d_family;
    remote.sin_addr.s_addr=ep.address.byte;
    remote.sin_port=ntohs(ep.port);

    if(sendto(d_socket, dgram.c_str(), dgram.size(), 0, (sockaddr *)&remote, sizeof(remote))<0)
      throw NetworkError(strerror(errno));
  }

  void writen(const string &data)
  {
    int toWrite=data.length();
    int res;
    const char *ptr=data.c_str();
    do {
      res=::write(d_socket,ptr,toWrite);
      if(res<0) 
        throw NetworkError("Writing to a socket: "+string(strerror(errno)));
      toWrite-=res;
    }while(toWrite);
  }


  unsigned int tryWrite(const char *ptr, int toWrite)
  {
    int res;
    res=::write(d_socket,ptr,toWrite);
    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: "+string(strerror(errno)));
  }


  unsigned int write(const char *ptr, int toWrite)
  {
    int res;
    res=::write(d_socket,ptr,toWrite);
    if(res<0) {
      throw NetworkError("Writing to a socket: "+string(strerror(errno)));
    }
    return res;
  }


  int getchar()
  {
    char c;

    int res=::read(d_socket,&c,1);
    if(res)
      return c;
    return -1;
  }

  void read(string &data)
  {
    int res=::read(d_socket,d_buffer,d_buflen);
    if(res<0) 
      throw NetworkError("Reading from a socket: "+string(strerror(errno)));
    data.assign(d_buffer,res);
  }

  int read(char *buffer, int bytes)
  {
    int res=::read(d_socket,buffer,bytes);
    if(res<0) 
      throw NetworkError("Reading from a socket: "+string(strerror(errno)));
    return res;

  }

  void listen(unsigned int length=10)
  {
    if(::listen(d_socket,length)<0)
      throw NetworkError("Setting socket to listen: "+string(strerror(errno)));
  }

  int getHandle() const
  {
    return d_socket;
  }
  
private:
  int d_socket;
  char *d_buffer;
  int d_buflen;
  int d_family;
};

class UDPListener
{
public:
  UDPListener(const IPEndpoint &ep)
  {
    d_ep=ep;
    initSocket();
  }
  UDPListener(IPPort port)
  {
    d_ep.address.byte=0; // =IPAddress::ANY;
    d_ep.port=port;
    initSocket();
  }
  UDPListener()
  {
    d_ep.address.byte=0; // =IPEndpoint::ANY;
    d_ep.port=0;
    initSocket();
  }
  ~UDPListener()
  {
    delete d_socket;
  }
  void recvFrom(string &dgram, IPEndpoint &remote)
  {
    d_socket->recvFrom(dgram,remote);
  }

  void sendTo(const string &dgram, const IPEndpoint &remote)
  {
    d_socket->sendTo(dgram,remote);
  }

private:
  void initSocket()
  {
    d_socket=new Socket(InterNetwork, Datagram);
    d_socket->bind(d_ep);
  }



private:
  UDPListener(const UDPListener &);
  UDPListener &operator=(const UDPListener &);
  IPEndpoint d_ep;
  Socket *d_socket;

};

---