Network.h

Go to the documentation of this file.

 
// Network.h
 
// Declares the classes used for the Network API
 
 
 
 
 
#pragma once
 
 
 
 
 
#ifdef __FreeBSD__
    #include <netinet/in.h>
#endif
 
 
 
 
 
// 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(std::move(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);
};