SocketDescriptor.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Foundation/AlignedStorage.h"
#include "../Foundation/Result.h"
#include "../Foundation/Span.h"
#include "../Foundation/UniqueHandle.h"
 
namespace SC
{
namespace detail
{
struct SocketDescriptorDefinition;
}
struct SC_COMPILER_EXPORT SocketDescriptor;
struct SocketFlags;
struct SocketIPAddress;
} // namespace SC
 
 
 
#if SC_PLATFORM_WINDOWS
 
struct SC::detail::SocketDescriptorDefinition
{
    using Handle = size_t; // SOCKET
    static Result releaseHandle(Handle& handle);
 
    static constexpr Handle Invalid = ~static_cast<Handle>(0); // INVALID_SOCKET
};
 
#else
 
struct SC::detail::SocketDescriptorDefinition
{
    using Handle = int; // fd
    static Result releaseHandle(Handle& handle);
 
    static constexpr Handle Invalid = -1; // invalid fd
};
 
#endif
 
struct SC::SocketFlags
{
    enum BlockingType
    {
        NonBlocking, 
        Blocking     
    };
 
    enum InheritableType
    {
        NonInheritable, 
        Inheritable     
    };
 
    enum AddressFamily
    {
        AddressFamilyIPV4, 
        AddressFamilyIPV6, 
    };
 
    enum SocketType
    {
        SocketStream, 
        SocketDgram   
    };
 
    enum ProtocolType
    {
        ProtocolTcp, 
        ProtocolUdp, 
    };
 
  private:
    friend struct SocketDescriptor;
    friend struct SocketDescriptor;
    friend struct SocketIPAddressInternal;
    [[nodiscard]] static AddressFamily AddressFamilyFromInt(int value);
    [[nodiscard]] static unsigned char toNative(AddressFamily family);
    [[nodiscard]] static SocketType    SocketTypeFromInt(int value);
    [[nodiscard]] static int           toNative(SocketType family);
 
    [[nodiscard]] static ProtocolType ProtocolTypeFromInt(int value);
    [[nodiscard]] static int          toNative(ProtocolType family);
};
 
struct SC::SocketIPAddress
{
    SocketIPAddress(SocketFlags::AddressFamily addressFamily = SocketFlags::AddressFamilyIPV4)
        : addressFamily(addressFamily)
    {}
 
    [[nodiscard]] SocketFlags::AddressFamily getAddressFamily() { return addressFamily; }
 
    [[nodiscard]] Result fromAddressPort(SpanStringView interfaceAddress, uint16_t port);
 
    uint32_t sizeOfHandle() const;
 
    AlignedStorage<28> handle = {};
 
  private:
    friend struct SocketServer;
    friend struct SocketClient;
 
    SocketFlags::AddressFamily addressFamily = SocketFlags::AddressFamilyIPV4;
    struct Internal;
};
 
struct SC::SocketDescriptor : public UniqueHandle<detail::SocketDescriptorDefinition>
{
    [[nodiscard]] Result create(SocketFlags::AddressFamily   addressFamily,
                                SocketFlags::SocketType      socketType  = SocketFlags::SocketStream,
                                SocketFlags::ProtocolType    protocol    = SocketFlags::ProtocolTcp,
                                SocketFlags::BlockingType    blocking    = SocketFlags::Blocking,
                                SocketFlags::InheritableType inheritable = SocketFlags::NonInheritable);
 
    [[nodiscard]] Result isInheritable(bool& value) const;
 
    [[nodiscard]] Result setInheritable(bool value);
 
    [[nodiscard]] Result setBlocking(bool value);
 
    [[nodiscard]] Result getAddressFamily(SocketFlags::AddressFamily& addressFamily) const;
};