Socket.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/SocketType.hpp"
#include "Arp/System/Commons/Net/PollMode.hpp"
#include "Arp/System/Commons/Net/SelectMode.hpp"
#include "Arp/System/Commons/Net/ShutdownMode.hpp"
#include "Arp/System/Commons/Net/SocketError.hpp"
#include "Arp/System/Commons/Net/SocketDomain.hpp"
#include "Arp/System/Commons/Net/SocketOptionName.hpp"
 
// forwards
namespace Arp { namespace System { namespace Ve
{
class ISocketService;
}}}
 
namespace Arp { namespace System { namespace Commons { namespace Net
{
 
enum class SocketBlockingMode
{
    None = 0,
    Blocking = 1,
    NoneBlocking = 2
};
 
class Socket
{
public: // typedefs/usings
 
    typedef std::shared_ptr<Socket> Ptr;
 
public: // friends
    friend class TlsSocket;
    friend class TlsSocket2;
 
public: // construction/destruction
 
    Socket(SocketType type, SocketDomain domain, SocketBlockingMode blockingMode);
 
    Socket(const Socket& arg) = delete;
 
    Socket& operator=(const Socket& arg) = delete;
 
    ~Socket(void);
 
public: // operators
 
public: // static operations
 
public: // setter/getter operations
 
    SocketType      GetSocketType(void) const;
 
    SocketDomain    GetSocketDomain(void) const;
 
    bool            IsBlocking(void) const;
 
    bool            IsConnected(void) const;
 
    IpAddress          GetRemoteIpAddress(void) const;
 
    int          GetRemotePort(void) const;
 
public: // operations
 
    Ptr             Accept(IpAddress& ip4address, int& port, SocketError& error);
 
    SocketError     Bind(const IpAddress& ip4Address, int port);
 
    SocketError     Bind2(const IpAddress& ip4Address, int& port);
 
    SocketError     Connect(const IpAddress& ip4Address, int port);
 
    SocketError     Listen(size_t backlog);
 
    SocketError     Shutdown(void);
 
    SocketError     Shutdown(ShutdownMode mode);
 
    SocketError     Close(void);
 
    int             Send(const void *pBuffer, size_t length, SocketError& error);
 
    int             SendTo(const void *pBuffer, size_t length, IpAddress ip4Adress, int port, SocketError& error);
 
    int             Receive(void *pBuffer, size_t length, SocketError& error);
 
    int             ReceiveFrom(void *pBuffer, size_t length, IpAddress& ip4Adress, int& port, SocketError& error);
 
    bool            Select(SelectMode mode, Microseconds timeout, SocketError& error);
 
    int             Poll(PollMode mode, Milliseconds timeout, SocketError& error);
 
    SocketError     SetSocketOption(SocketOptionName optionName, const void* optionValue, size_t optionLength);
 
    SocketError     GetSocketOption(SocketOptionName optionName, void* optionValue, size_t *optionLength) const;
 
    SocketError     SetOptionReuseAddress(bool enabled);
 
    SocketError     GetOptionReuseAddress(bool& enabled) const;
 
    SocketError     SetOptionKeepAlive(bool enabled);
 
    SocketError     GetOptionKeepAlive(bool& enabled) const;
 
    SocketError     SetOptionBroadcast(bool enabled);
 
    SocketError     GetOptionBroadcast(bool& enabled) const;
 
    SocketError     SetOptionNoDelay(bool enabled);
 
    SocketError     GetOptionNoDelay(bool& enabled) const;
 
    SocketError     SetOptionBlocking(bool enable);
 
    SocketError     SetOptionLinger(bool enable, size_t timeout);
 
    SocketError     GetOptionLinger(bool& enable, size_t& timeout);
 
    SocketError     SetOptionUserTimeout(size_t timeout_ms);
 
    SocketError     GetOptionUserTimeout(size_t& timeout_ms);
 
    SocketError     SetOptionKeepAliveIdleTime(int seconds);
 
    SocketError     GetOptionKeepAliveIdleTime(int& seconds);
 
    SocketError     SetOptionKeepAliveProbeInterval(int seconds);
 
    SocketError     GetOptionKeepAliveProbeInterval(int& seconds);
 
    SocketError     SetOptionKeepAliveProbeCount(int probeCount);
 
    SocketError     GetOptionKeepAliveProbeCount(int& probeCount);
 
 
protected: // operations
 
private: // usings/typedefs
 
    using ISocketService = Arp::System::Ve::ISocketService;
 
private: // construction/destruction
 
    Socket(ISocketService *pSocket); //contruct a new Socket Object from a given ISocketService
 
private: // static methods
 
private: // methods
 
private: // fields
    ISocketService *pSocketService;
 
    SocketType socketType;
    SocketDomain socketDomain;
    bool isBlocking;
    IpAddress remoteIpAddress;
    int remotePort;
    bool isConnected;
 
private: // static fields
 
};
 
// inline methods of class Socket
 
inline SocketType Socket::GetSocketType(void) const
{
    return socketType;
}
 
inline SocketDomain Socket::GetSocketDomain(void) const
{
    return socketDomain;
}
 
inline bool Socket::IsBlocking(void) const
{
    return isBlocking;
}
 
inline IpAddress Socket::GetRemoteIpAddress(void) const
{
    return remoteIpAddress;
}
 
inline int Socket::GetRemotePort(void) const
{
    return remotePort;
}
 
inline bool Socket::IsConnected(void) const
{
    return this->isConnected;
}
 
}}}} // end of namespace Arp::System::Commons::Net