TCPLinkImpl.h

Go to the documentation of this file.

 
// TCPLinkImpl.h
 
// Declares the cTCPLinkImpl class implementing the TCP link functionality
 
// This is an internal header, no-one outside OSSupport should need to include it; use Network.h instead
 
 
 
 
 
#pragma once
 
#include "Network.h"
#include <event2/event.h>
#include <event2/bufferevent.h>
#include "../mbedTLS++/SslContext.h"
 
 
 
 
 
// fwd:
class cServerHandleImpl;
typedef std::shared_ptr<cServerHandleImpl> cServerHandleImplPtr;
class cTCPLinkImpl;
typedef std::shared_ptr<cTCPLinkImpl> cTCPLinkImplPtr;
typedef std::vector<cTCPLinkImplPtr> cTCPLinkImplPtrs;
 
 
 
 
 
class cTCPLinkImpl:
    public cTCPLink
{
    using Super = cTCPLink;
 
public:
 
    cTCPLinkImpl(
        evutil_socket_t a_Socket,
        cCallbacksPtr a_LinkCallbacks,
        cServerHandleImplPtr a_Server,
        const sockaddr * a_Address,
        socklen_t a_AddrLen
    );
 
    virtual ~cTCPLinkImpl() override;
 
    static cTCPLinkImplPtr Connect(const AString & a_Host, UInt16 a_Port, cTCPLink::cCallbacksPtr a_LinkCallbacks, cNetwork::cConnectCallbacksPtr a_ConnectCallbacks);
 
    void Enable(cTCPLinkImplPtr a_Self);
 
    // cTCPLink overrides:
    virtual bool Send(const void * a_Data, size_t a_Length) override;
    virtual AString GetLocalIP(void) const override { return m_LocalIP; }
    virtual UInt16 GetLocalPort(void) const override { return m_LocalPort; }
    virtual AString GetRemoteIP(void) const override { return m_RemoteIP; }
    virtual UInt16 GetRemotePort(void) const override { return m_RemotePort; }
    virtual void Shutdown(void) override;
    virtual void Close(void) override;
    virtual AString StartTLSClient(
        cX509CertPtr a_OwnCert,
        cCryptoKeyPtr a_OwnPrivKey,
        cX509CertPtr a_TrustedRootCAs
    ) override;
    virtual AString StartTLSServer(
        cX509CertPtr a_OwnCert,
        cCryptoKeyPtr a_OwnPrivKey,
        const AString & a_StartTLSData
    ) override;
 
protected:
 
    // fwd:
    class cLinkTlsContext;
    typedef std::shared_ptr<cLinkTlsContext> cLinkTlsContextPtr;
    typedef std::weak_ptr<cLinkTlsContext> cLinkTlsContextWPtr;
 
    class cLinkTlsContext :
        public cSslContext
    {
        cTCPLinkImpl & m_Link;
 
        AString m_EncryptedData;
 
        AString m_CleartextData;
 
        cLinkTlsContextWPtr m_Self;
 
    public:
        cLinkTlsContext(cTCPLinkImpl & a_Link);
 
        void SetSelf(cLinkTlsContextWPtr a_Self);
 
        void ResetSelf(void);
 
        void StoreReceivedData(const char * a_Data, size_t a_NumBytes);
 
        void FlushBuffers(void);
 
        void TryFinishHandshaking(void);
 
        void Send(const void * a_Data, size_t a_Length);
 
        // cSslContext overrides:
        virtual int ReceiveEncrypted(unsigned char * a_Buffer, size_t a_NumBytes) override;
        virtual int SendEncrypted(const unsigned char * a_Buffer, size_t a_NumBytes) override;
 
        bool IsLink(cTCPLinkImpl * a_Link)
        {
            return (a_Link == &m_Link);
        }
    };
 
 
    cNetwork::cConnectCallbacksPtr m_ConnectCallbacks;
 
    bufferevent * m_BufferEvent;
 
    cServerHandleImplPtr m_Server;
 
    AString m_LocalIP;
 
    UInt16 m_LocalPort;
 
    AString m_RemoteHost;
 
    AString m_RemoteIP;
 
    UInt16 m_RemotePort;
 
    cTCPLinkImplPtr m_Self;
 
    bool m_ShouldShutdown;
 
    cLinkTlsContextPtr m_TlsContext;
 
 
    cTCPLinkImpl(const std::string & a_Host, const cCallbacksPtr a_LinkCallbacks);
 
    static void ReadCallback(bufferevent * a_BufferEvent, void * a_Self);
 
    static void WriteCallback(bufferevent * a_BufferEvent, void * a_Self);
 
    static void EventCallback(bufferevent * a_BufferEvent, short a_What, void * a_Self);
 
    static void UpdateAddress(const sockaddr * a_Address, socklen_t a_AddrLen, AString & a_IP, UInt16 & a_Port);
 
    void UpdateLocalAddress(void);
 
    void UpdateRemoteAddress(void);
 
    void DoActualShutdown(void);
 
    bool SendRaw(const void * a_Data, size_t a_Length);
 
    void ReceivedCleartextData(const char * a_Data, size_t a_Length);
};