TlsSocket.hpp

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Commons/Net/IpAddress.hpp"
#include "Arp/System/Commons/Net/Socket.hpp"
#include "Arp/System/Commons/Logging.h"
#include "Arp/System/Commons/Exceptions/Exceptions.h"
#include "Arp/System/Commons/Security/IdentityStore.hpp"

using namespace Arp::System::Commons::Security;

// forwards
typedef struct ssl_st       SSL;
typedef struct ssl_ctx_st   SSL_CTX;

namespace Arp { namespace System { namespace Commons { namespace Net
{


class TlsSocket : private Loggable<TlsSocket>
{
private: // nested class TlsContext
    class TlsContext
    {
    public:
        using Ptr = shared_ptr<TlsContext>;

        // construction/destruction
        TlsContext(void);
        TlsContext(const TlsContext& arg) = delete;
        ~TlsContext(void);

    public: //operations
        TlsContext& operator=(const TlsContext& arg) = delete;

    public: // Properties
        SSL_CTX* pTlsCtx = nullptr;
    };




    friend class TlsContext;

public: // typedefs/usings

    typedef std::shared_ptr<TlsSocket> Ptr;

    using ISocketService = Arp::System::Ve::ISocketService;

public: // construction/destruction

    TlsSocket(SocketType type, SocketDomain domain, SocketBlockingMode blockingMode);

    TlsSocket(const TlsSocket& arg) = delete;

    TlsSocket& operator=(const TlsSocket& arg) = delete;

    ~TlsSocket(void);

private: // construction
    TlsSocket(Socket::Ptr pSocket, TlsContext::Ptr pContext, bool isInitialized);

public: // operators

public: // static operations

public: // setter/getter operations

    SocketType      GetSocketType(void);

    SocketDomain    GetSocketDomain(void);

    bool            IsBlocking(void);

    bool            IsConnected(void);

    bool            IsTlsConnected(void);

    IpAddress       GetRemoteIpAddress(void);

    int             GetRemotePort(void);

public: // operations

    Ptr             Accept(IpAddress& ip4address, int& port, SocketError& error);

    SocketError     Bind(const IpAddress& ip4Address, int port);

    SocketError     Listen(size_t backlog);

    SocketError     Connect(const IpAddress& ip4Address, int port);

    SocketError     Shutdown(void);

    SocketError     Close(void);

    int             Send(const void* pBuffer, size_t length, SocketError& error);

    int             Receive(void* pBuffer, size_t length, SocketError& error);

    bool            Select(SelectMode mode, Microseconds timeout, SocketError& error);

    SocketError     SetSocketOption(SocketOptionName optionName, const void* optionValue, size_t optionLength);

    SocketError     GetSocketOption(SocketOptionName optionName, void* optionValue, size_t *optionLength);

    SocketError     SetOptionReuseAddress(bool enabled);

    SocketError     GetOptionReuseAddress(bool& enabled);

    SocketError     SetOptionKeepAlive(bool enabled);

    SocketError     GetOptionKeepAlive(bool& enabled);

    SocketError     SetOptionBroadcast(bool enabled);

    SocketError     GetOptionBroadcast(bool& enabled);

    SocketError     SetOptionNoDelay(bool enabled);

    SocketError     GetOptionNoDelay(bool& enabled);

    SocketError     SetOptionLinger(bool enable, size_t timeout);

    SocketError     GetOptionLinger(bool& enable, size_t& timeout);

    SocketError     SetOptionBlocking(bool enable);

    SocketError InitClient(const String& trustStoreName, const String& identityStoreName, const String& hostName);

    SocketError InitServer(const String& identityStoreName, const String& trustStoreName = "");

    void SetCipherList(String cipherList);

protected: // operations

private: // static methods

private: // methods
    Ptr         TcpAccept(IpAddress& ip4address, int& port, SocketError& error);
    SocketError TlsAccept(void);
    SocketError TcpConnect(const IpAddress& ipAddress, int port);
    SocketError TlsConnect(void);
    SocketError HandleSslResult(int result, int* sslErrorOut = nullptr);
    int         GetFileDescriptor(void);
    void        ClearOpenSslErrors(void);

private: // fields
    Socket::Ptr pSocket = nullptr;
    SSL* sslConnection = nullptr;
    TlsContext::Ptr pContext;

    Ptr currentAcceptSocket;

    bool tlsIsConnected;    //true if TLS Handshake was completed
    bool hasSslError;
    bool socketIsConnected; //true if tcp socket is connected / accepted (set before SSL_connect / SSL_accept)
    bool tlsInitDone;
    bool isInitialized; // true if InitClient resp. InitServer has already been called
    bool tlsConnectIsPending;
    bool pendingTlsConnectNeedsRead;

    String hostNameToVerify;
};

// inline methods of class Socket

inline SocketType TlsSocket::GetSocketType(void)
{
    return this->pSocket->GetSocketType();
}

inline SocketDomain TlsSocket::GetSocketDomain(void)
{
    return this->pSocket->GetSocketDomain();
}

inline bool TlsSocket::IsBlocking(void)
{
    return this->pSocket->IsBlocking();
}

inline IpAddress TlsSocket::GetRemoteIpAddress(void)
{
    return this->pSocket->GetRemoteIpAddress();
}

inline int TlsSocket::GetRemotePort(void)
{
    return this->pSocket->GetRemotePort();
}

inline bool TlsSocket::IsConnected(void)
{
    return (!this->hasSslError) && (this->tlsIsConnected || this->socketIsConnected);
}

inline bool TlsSocket::IsTlsConnected(void)
{
    return (!this->hasSslError) && (this->tlsIsConnected);
}

inline SocketError TlsSocket::Bind(const IpAddress& ip4Address, int port)
{
    return pSocket->Bind(ip4Address, port);
}

inline SocketError TlsSocket::Listen(size_t backlog)
{
    return pSocket->Listen(backlog);
}

inline SocketError TlsSocket::SetSocketOption(SocketOptionName optionName, const void * optionValue, size_t optionLength)
{
    return this->pSocket->SetSocketOption(optionName, optionValue, optionLength);
}

inline SocketError TlsSocket::GetSocketOption(SocketOptionName optionName, void * optionValue, size_t * optionLength)
{
    return this->pSocket->GetSocketOption(optionName, optionValue, optionLength);
}

inline SocketError TlsSocket::SetOptionReuseAddress(bool enabled)
{
    return this->pSocket->SetOptionReuseAddress(enabled);
}

inline SocketError TlsSocket::GetOptionReuseAddress(bool& enabled)
{
    return this->pSocket->GetOptionReuseAddress(enabled);
}

inline SocketError TlsSocket::SetOptionKeepAlive(bool enabled)
{
    return this->pSocket->SetOptionKeepAlive(enabled);
}

inline SocketError TlsSocket::GetOptionKeepAlive(bool& enabled)
{
    return this->pSocket->GetOptionKeepAlive(enabled);
}

inline SocketError TlsSocket::SetOptionBroadcast(bool enabled)
{
    return this->pSocket->SetOptionBroadcast(enabled);
}

inline SocketError TlsSocket::GetOptionBroadcast(bool& enabled)
{
    return this->pSocket->GetOptionBroadcast(enabled);
}

inline SocketError TlsSocket::SetOptionNoDelay(bool enabled)
{
    return this->pSocket->SetOptionNoDelay(enabled);
}

inline SocketError TlsSocket::GetOptionNoDelay(bool& enabled)
{
    return this->pSocket->GetOptionNoDelay(enabled);
}

inline SocketError TlsSocket::SetOptionLinger(bool enable, size_t timeout)
{
    return this->pSocket->SetOptionLinger(enable, timeout);
}

inline SocketError TlsSocket::GetOptionLinger(bool& enable, size_t& timeout)
{
    return this->pSocket->GetOptionLinger(enable, timeout);
}

inline SocketError TlsSocket::SetOptionBlocking(bool enable)
{
    return this->pSocket->SetOptionBlocking(enable);
}

}}}} // end of namespace Arp::System::Commons::Net