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
{
    typedef cTCPLink super;

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
    ) 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_RemoteIP;

    UInt16 m_RemotePort;

    cTCPLinkImplPtr m_Self;

    bool m_ShouldShutdown;

    cLinkTlsContextPtr m_TlsContext;


    cTCPLinkImpl(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);
};