Network.h

Go to the documentation of this file.

// Network.h

// Declares the classes used for the Network API





#pragma once





// fwd:
class cTCPLink;
typedef std::shared_ptr<cTCPLink> cTCPLinkPtr;
typedef std::vector<cTCPLinkPtr> cTCPLinkPtrs;
class cServerHandle;
typedef std::shared_ptr<cServerHandle> cServerHandlePtr;
typedef std::vector<cServerHandlePtr> cServerHandlePtrs;
class cCryptoKey;
typedef std::shared_ptr<cCryptoKey> cCryptoKeyPtr;
class cX509Cert;
typedef std::shared_ptr<cX509Cert> cX509CertPtr;





class cTCPLink
{
    friend class cNetwork;

public:
    class cCallbacks
    {
    public:
        // Force a virtual destructor for all descendants:
        virtual ~cCallbacks() {}

        virtual void OnLinkCreated(cTCPLinkPtr a_Link) = 0;

        virtual void OnReceivedData(const char * a_Data, size_t a_Length) = 0;

        virtual void OnRemoteClosed(void) = 0;

        virtual void OnTlsHandshakeCompleted(void) {}

        virtual void OnError(int a_ErrorCode, const AString & a_ErrorMsg) = 0;
    };
    typedef std::shared_ptr<cCallbacks> cCallbacksPtr;


    // Force a virtual destructor for all descendants:
    virtual ~cTCPLink() {}

    virtual bool Send(const void * a_Data, size_t a_Length) = 0;

    bool Send(const AString & a_Data)
    {
        return Send(a_Data.data(), a_Data.size());
    }

    virtual AString GetLocalIP(void) const = 0;

    virtual UInt16 GetLocalPort(void) const = 0;

    virtual AString GetRemoteIP(void) const = 0;

    virtual UInt16 GetRemotePort(void) const = 0;

    virtual void Shutdown(void) = 0;

    virtual void Close(void) = 0;

    virtual AString StartTLSClient(
        cX509CertPtr a_OwnCert,
        cCryptoKeyPtr a_OwnPrivKey
    ) = 0;

    virtual AString StartTLSServer(
        cX509CertPtr a_OwnCert,
        cCryptoKeyPtr a_OwnPrivKey,
        const AString & a_StartTLSData
    ) = 0;

    cCallbacksPtr GetCallbacks(void) const { return m_Callbacks; }

protected:
    cCallbacksPtr m_Callbacks;


    cTCPLink(cCallbacksPtr a_Callbacks):
        m_Callbacks(a_Callbacks)
    {
    }
};





class cServerHandle
{
    friend class cNetwork;
public:

    // Force a virtual destructor for all descendants:
    virtual ~cServerHandle() {}

    virtual void Close(void) = 0;

    virtual bool IsListening(void) const = 0;
};





class cUDPEndpoint
{
public:
    class cCallbacks
    {
    public:
        // Force a virtual destructor in all descendants:
        virtual ~cCallbacks() {}

        virtual void OnError(int a_ErrorCode, const AString & a_ErrorMsg) = 0;

        virtual void OnReceivedData(const char * a_Data, size_t a_Size, const AString & a_RemoteHost, UInt16 a_RemotePort) = 0;
    };


    // Force a virtual destructor for all descendants:
    virtual ~cUDPEndpoint() {}

    virtual void Close(void) = 0;

    virtual bool IsOpen(void) const = 0;

    virtual UInt16 GetPort(void) const = 0;

    virtual bool Send(const AString & a_Payload, const AString & a_Host, UInt16 a_Port) = 0;

    virtual void EnableBroadcasts(void) = 0;

protected:
    cCallbacks & m_Callbacks;


    cUDPEndpoint(cCallbacks & a_Callbacks):
        m_Callbacks(a_Callbacks)
    {
    }
};

typedef std::shared_ptr<cUDPEndpoint> cUDPEndpointPtr;





class cNetwork
{
public:
    class cConnectCallbacks
    {
    public:
        // Force a virtual destructor for all descendants:
        virtual ~cConnectCallbacks() {}

        virtual void OnConnected(cTCPLink & a_Link) = 0;

        virtual void OnError(int a_ErrorCode, const AString & a_ErrorMsg) = 0;
    };
    typedef std::shared_ptr<cConnectCallbacks> cConnectCallbacksPtr;


    class cListenCallbacks
    {
    public:
        // Force a virtual destructor for all descendants:
        virtual ~cListenCallbacks() {}

        virtual cTCPLink::cCallbacksPtr OnIncomingConnection(const AString & a_RemoteIPAddress, UInt16 a_RemotePort) = 0;

        virtual void OnAccepted(cTCPLink & a_Link) = 0;

        virtual void OnError(int a_ErrorCode, const AString & a_ErrorMsg) = 0;
    };
    typedef std::shared_ptr<cListenCallbacks> cListenCallbacksPtr;


    class cResolveNameCallbacks
    {
    public:
        // Force a virtual destructor for all descendants:
        virtual ~cResolveNameCallbacks() {}

        virtual void OnNameResolved(const AString & a_Name, const AString & a_IP) = 0;

        virtual bool OnNameResolvedV4(const AString & a_Name, const sockaddr_in * a_IP) { return true; }

        virtual bool OnNameResolvedV6(const AString & a_Name, const sockaddr_in6 * a_IP) { return true; }

        virtual void OnError(int a_ErrorCode, const AString & a_ErrorMsg) = 0;

        virtual void OnFinished(void) = 0;
    };
    typedef std::shared_ptr<cResolveNameCallbacks> cResolveNameCallbacksPtr;


    static bool Connect(
        const AString & a_Host,
        UInt16 a_Port,
        cConnectCallbacksPtr a_ConnectCallbacks,
        cTCPLink::cCallbacksPtr a_LinkCallbacks
    );


    static cServerHandlePtr Listen(
        UInt16 a_Port,
        cListenCallbacksPtr a_ListenCallbacks
    );


    static bool HostnameToIP(
        const AString & a_Hostname,
        cResolveNameCallbacksPtr a_Callbacks
    );


    static bool IPToHostName(
        const AString & a_IP,
        cResolveNameCallbacksPtr a_Callbacks
    );

    static cUDPEndpointPtr CreateUDPEndpoint(UInt16 a_Port, cUDPEndpoint::cCallbacks & a_Callbacks);

    static AStringVector EnumLocalIPAddresses(void);
};