tcpsocket.h

Go to the documentation of this file.

 
#ifndef TCP_SOCKET_H
#define TCP_SOCKET_H
 
#include <iostream>
#include <deque>
#include <map>
#include <vector>
#include <thread>
#include <mutex>
#include <arpa/inet.h>
#include <sys/epoll.h>
#include "tcpssl.h"
 
namespace tcp {
 
using namespace std;
 
void setLogStream(ostream *os);
 
void error(string msg);
 
void error(string label, string msg);
 
void warning(string msg);
 
void warning(string label, string msg);
 
void log(string msg);
 
void log(string label, string msg);
 
class Socket;
class SSLContext;
 
enum class SocketState {UNCONNECTED=0, LISTENING, CONNECTING, CONNECTED, DISCONNECTED};
 
class EPoll {
  public:
    EPoll();
 
    ~EPoll();
    
    void poll(int timeout); 
  private:
    static const int MAX_EVENTS = 10; 
    bool add(Socket& socket, int events);
    bool update(Socket& socket, int events);
    bool remove(Socket& socket);    
    void handleEvents(uint32_t events, int fd);
    int handle_;
    epoll_event events[MAX_EVENTS];
    std::map<int,tcp::Socket*> sockets;
    friend class Socket;
};
 
class Socket {
  public:
  
    Socket(EPoll &epoll, const int domain = AF_INET, const int socket = 0, const bool blocking = false, const int events = (EPOLLIN | EPOLLRDHUP));
 
    ~Socket();
  
    int socket() const { return socket_; }
    
    int domain() const { return domain_; }
 
    virtual void disconnect();
 
  protected:
 
    bool setEvents(int events);
 
    virtual void handleEvents(uint32_t events) = 0;
 
    virtual void disconnected();
 
    recursive_mutex mtx;
 
    EPoll &epoll() { return epoll_; }
 
    SocketState state_;    
 
  private:
    EPoll &epoll_;
    int events_;
    int domain_;
    int socket_;
    friend class EPoll;
};
 
class DataSocket : public Socket {
  public:
    DataSocket(EPoll &epoll, const int domain = AF_INET, const int socket = 0, const bool blocking = false, const int events = (EPOLLIN | EPOLLRDHUP)) :
      Socket(epoll,domain,socket,blocking,events) {}
 
    size_t available() { return inputBuffer.size(); }
 
    size_t read(void *buffer, size_t size);
    
    size_t write(const void *buffer, size_t size);
 
  protected:
 
    void readToInputBuffer();
 
    void sendOutputBuffer();
 
    void canSend(bool value);
 
    void handleEvents(uint32_t events) override;
    
    void disconnect() override;
 
    void disconnected() override;
 
    virtual void dataAvailable() = 0;
 
    virtual SSL *createSSL(SSLContext *context);
 
    SSL *ssl_ {nullptr};
 
  private:    
    size_t read_(void *buffer, size_t size);
    size_t write_(const void *buffer, size_t size);
    deque<uint8_t> inputBuffer;
    deque<uint8_t> outputBuffer;
    friend class SSL;
};
 
int getDomainFromHostAndPort(const char* host, const char* port, int def_domain = AF_INET);
 
} // namespace tcp
 
#endif // include guard