socket.h

Go to the documentation of this file.

#pragma once
#include <string>
#include <sstream>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>
#include <deque>

//for being friendly with Socket::Connection down below
namespace Buffer {
  class user;
}

namespace Socket {

  class Buffer {
    private:
      std::deque<std::string> data;
    public:
      unsigned int size();
      unsigned int bytes(unsigned int max);
      void append(const std::string & newdata);
      void append(const char * newdata, const unsigned int newdatasize);
      void prepend(const std::string & newdata);
      void prepend(const char * newdata, const unsigned int newdatasize);
      std::string & get();
      bool available(unsigned int count);
      std::string remove(unsigned int count);
      std::string copy(unsigned int count);
      void clear();
  };
  //Buffer

  class Connection {
    private:
      int sock; 
      int pipes[2]; 
      std::string remotehost; 
      unsigned int up;
      unsigned int down;
      long long int conntime;
      Buffer downbuffer; 
      int iread(void * buffer, int len, int flags = 0); 
      unsigned int iwrite(const void * buffer, int len); 
      bool iread(Buffer & buffer, int flags = 0); 
      bool iwrite(std::string & buffer); 
    public:
      //friends
      friend class ::Buffer::user;
      //constructors
      Connection(); 
      Connection(int sockNo); 
      Connection(std::string hostname, int port, bool nonblock); 
      Connection(std::string adres, bool nonblock = false); 
      Connection(int write, int read); 
      //generic methods
      void close(); 
      void drop(); 
      void setBlocking(bool blocking); 
      bool isBlocking(); 
      std::string getHost() const; 
      std::string getBinHost();
      void setHost(std::string host); 
      int getSocket(); 
      int getPureSocket(); 
      std::string getError(); 
      bool connected() const; 
      bool isAddress(std::string addr);
      //buffered i/o methods
      bool spool(); 
      bool peek(); 
      Buffer & Received(); 
      void SendNow(const std::string & data); 
      void SendNow(const char * data); 
      void SendNow(const char * data, size_t len); 
      //stats related methods
      unsigned int connTime();
      unsigned int dataUp(); 
      unsigned int dataDown(); 
      std::string getStats(std::string C); 
      friend class Server;
      bool Error; 
      bool Blocking; 
      //overloaded operators
      bool operator==(const Connection & B) const;
      bool operator!=(const Connection & B) const;
      operator bool() const;
  };

  class Server {
    private:
      std::string errors; 
      int sock; 
      bool IPv6bind(int port, std::string hostname, bool nonblock); 
      bool IPv4bind(int port, std::string hostname, bool nonblock); 
    public:
      Server(); 
      Server(int port, std::string hostname = "0.0.0.0", bool nonblock = false); 
      Server(std::string adres, bool nonblock = false); 
      Connection accept(bool nonblock = false); 
      void setBlocking(bool blocking); 
      bool connected() const; 
      bool isBlocking(); 
      void close(); 
      void drop(); 
      int getSocket(); 
  };

  class UDPConnection {
    private:
      int sock; 
      std::string remotehost;
      void * destAddr;
      unsigned int destAddr_size;
      unsigned int up;
      unsigned int down;
      unsigned int data_size;
      bool isIPv6;//<<< True if IPv6 socket, false otherwise.
    public:
      char * data;
      unsigned int data_len; 
      UDPConnection(const UDPConnection & o);
      UDPConnection(bool nonblock = false);
      ~UDPConnection();
      int getSock();
      int bind(int port, std::string iface = "", const std::string & multicastAddress = "");
      void setBlocking(bool blocking);
      void SetDestination(std::string hostname, uint32_t port);
      void GetDestination(std::string & hostname, uint32_t & port);
      bool Receive();
      void SendNow(const std::string & data);
      void SendNow(const char * data);
      void SendNow(const char * data, size_t len);
  };

}