AsyncTcpConnection.h

Go to the documentation of this file.

 
#ifndef ASYNC_TCP_CONNECTION_INCLUDED
#define ASYNC_TCP_CONNECTION_INCLUDED
 
 
/****************************************************************************
 *
 * System Includes
 *
 ****************************************************************************/
 
#include <sigc++/sigc++.h>
#include <stdint.h>
#include <openssl/bio.h>
#include <openssl/err.h>
#include <openssl/pem.h>
#include <openssl/ssl.h>
 
#include <string>
#include <cassert>
#include <cstring>
#include <vector>
#include <map>
 
 
/****************************************************************************
 *
 * Project Includes
 *
 ****************************************************************************/
 
#include <AsyncIpAddress.h>
#include <AsyncFdWatch.h>
#include <AsyncSslContext.h>
#include <AsyncSslX509.h>
 
 
/****************************************************************************
 *
 * Local Includes
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Forward declarations
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Namespace
 *
 ****************************************************************************/
 
namespace Async
{
 
/****************************************************************************
 *
 * Forward declarations of classes inside of the declared namespace
 *
 ****************************************************************************/
 
class IpAddress;
 
 
/****************************************************************************
 *
 * Defines & typedefs
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Exported Global Variables
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Class definitions
 *
 ****************************************************************************/

class TcpConnection : virtual public sigc::trackable
{
  public:
    typedef enum
    { 
      DR_HOST_NOT_FOUND,       
      DR_REMOTE_DISCONNECTED,  
      DR_SYSTEM_ERROR,         
      DR_ORDERED_DISCONNECT,   
      DR_PROTOCOL_ERROR,       
      DR_SWITCH_PEER,          
      DR_BAD_STATE             
    } DisconnectReason;

    struct if_all_true_acc
    {
      typedef int result_type;
      template <class I>
      result_type operator()(I first, I last)
      {
        for (; first != last; first ++)
        {
          if (!*first) return 0;
        }
        return 1;
      }
    };

    static const int DEFAULT_RECV_BUF_LEN = 1024;
    
    static const char *disconnectReasonStr(DisconnectReason reason);
    
    explicit TcpConnection(size_t recv_buf_len = DEFAULT_RECV_BUF_LEN);
    
    TcpConnection(int sock, const IpAddress& remote_addr,
                  uint16_t remote_port,
                  size_t recv_buf_len = DEFAULT_RECV_BUF_LEN);
    
    virtual ~TcpConnection(void);

    virtual TcpConnection& operator=(TcpConnection&& other);

    void setRecvBufLen(size_t recv_buf_len);
 
    size_t recvBufLen(void) const { return m_recv_buf.capacity(); }

    virtual void disconnect(void)
    {
      closeConnection();
      onDisconnected(DR_ORDERED_DISCONNECT);
    }

    virtual int write(const void *buf, int count);

    IpAddress localHost(void) const;

    uint16_t localPort(void) const;

    const IpAddress& remoteHost(void) const { return remote_addr; }
    
    uint16_t remotePort(void) const { return remote_port; }
    
    bool isConnected(void) const { return sock != -1; }

    bool isIdle(void) const { return sock == -1; }

    void enableSsl(bool enable);

    SslX509 sslPeerCertificate(void);

    Async::SslX509 sslCertificate(void) const;

    long sslVerifyResult(void) const;

    void setSslContext(SslContext& ctx, bool is_server);
 
    SslContext* sslContext(void) { return m_ssl_ctx; }
 
    bool isServer(void) const { return m_ssl_is_server; }

    void freeze(void);

    void unfreeze(void);

    //std::string sslCommonName(void) const;

    sigc::signal<void(TcpConnection*, DisconnectReason)> disconnected;
    
    sigc::signal<int(TcpConnection*, void*, int)> dataReceived;

    sigc::signal<if_all_true_acc::result_type(TcpConnection*, int,
                 X509_STORE_CTX*)>::accumulated<if_all_true_acc> verifyPeer;

    sigc::signal<void(TcpConnection*)> sslConnectionReady;
 
  protected:
    void setSocket(int sock);
    
    void setRemoteAddr(const IpAddress& remote_addr);
    
    void setRemotePort(uint16_t remote_port);
    
    int socket(void) const { return sock; }

    virtual void closeConnection(void);

    virtual void onDisconnected(DisconnectReason reason)
    {
      if (reason != DR_ORDERED_DISCONNECT)
      {
        emitDisconnected(reason);
      }
    }

    virtual int onDataReceived(void *buf, int count)
    {
      return dataReceived(this, buf, count);
    }

    virtual void emitDisconnected(DisconnectReason reason)
    {
      disconnected(this, reason);
    }

    virtual int emitVerifyPeer(int preverify_ok, X509_STORE_CTX* store_ctx)
    {
      if (verifyPeer.empty())
      {
        return preverify_ok;
      }
      return verifyPeer(this, preverify_ok, store_ctx);
    }
 
  private:
    friend class TcpClientBase;
 
    enum SslStatus { SSLSTATUS_OK, SSLSTATUS_WANT_IO, SSLSTATUS_FAIL };
    struct Char
    {
      char value;
      Char(void) noexcept
      {
        // Do nothing to suppress automatic initialization on container resize
        // for m_recv_buf.
        static_assert(sizeof *this == sizeof value, "invalid size");
        static_assert(__alignof *this == __alignof value, "invalid alignment");
      }
    };
 
    static constexpr const size_t DEFAULT_BUF_SIZE = 1024;
 
    static std::map<SSL*, TcpConnection*> ssl_con_map;
 
    IpAddress         remote_addr;
    uint16_t          remote_port         = 0;
    int               sock                = -1;
    FdWatch           rd_watch;
    std::vector<Char> m_recv_buf;
    Async::FdWatch    m_wr_watch;
    std::vector<char> m_write_buf;
 
    SslContext*       m_ssl_ctx           = nullptr;
    bool              m_ssl_is_server     = false;
    SSL*              m_ssl               = nullptr;
    BIO*              m_ssl_rd_bio        = nullptr; // SSL reads, we write
    BIO*              m_ssl_wr_bio        = nullptr; // SSL writes, we read
    std::vector<char> m_ssl_encrypt_buf;
 
    bool              m_freezed           = false;
 
    static TcpConnection* lookupConnection(SSL* ssl)
    {
      auto it = ssl_con_map.find(ssl);
      return (it != ssl_con_map.end()) ? it->second : nullptr;
    }
    static int sslVerifyCallback(int preverify_ok,
                                 X509_STORE_CTX* x509_store_ctx);
 
    void recvHandler(FdWatch *watch);
    void processRecvBuf(void);
    void addToWriteBuf(const char *buf, size_t len);
    void onWriteSpaceAvailable(Async::FdWatch* w);
    int rawWrite(const void* buf, int count);
 
    SslStatus sslGetStatus(int n);
    int sslRecvHandler(char* src, int count);
    SslStatus sslDoHandshake(void);
    int sslEncrypt(void);
    int sslWrite(const void* buf, int count);
 
};  /* class TcpConnection */
 
 
} /* namespace */
 
#endif /* ASYNC_TCP_CONNECTION_INCLUDED */
 
 
 
/*
 * This file has not been truncated
 */