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/StringViewData.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, 
    };
 
    enum ShutdownType
    {
        ShutdownRead,  
        ShutdownWrite, 
        ShutdownBoth   
    };
 
  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
{
    static constexpr int MAX_ASCII_STRING_LENGTH = 46;
 
    using AsciiBuffer = char[MAX_ASCII_STRING_LENGTH];
 
    SocketIPAddress(SocketFlags::AddressFamily addressFamily = SocketFlags::AddressFamilyIPV4);
 
    [[nodiscard]] SocketFlags::AddressFamily getAddressFamily() const;
 
    [[nodiscard]] uint16_t getPort() const;
 
    [[nodiscard]] Result fromAddressPort(StringViewData interfaceAddress, uint16_t port);
 
    [[nodiscard]] uint32_t sizeOfHandle() const;
 
    [[nodiscard]] bool isValid() const;
 
    template <size_t N>
    [[nodiscard]] StringViewData toString(char (&buffer)[N]) const
    {
        static_assert(N >= MAX_ASCII_STRING_LENGTH, "Insufficient buffer");
        return formatAddress(buffer);
    }
 
    AlignedStorage<28> handle = {};
 
  private:
    [[nodiscard]] StringViewData formatAddress(Span<char> buffer) const;
    friend struct SocketServer;
    friend struct SocketClient;
 
    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);
 
    Result isInheritable(bool& value) const;
 
    Result setInheritable(bool value);
 
    Result setBlocking(bool value);
 
    Result getAddressFamily(SocketFlags::AddressFamily& addressFamily) const;
 
    Result shutdown(SocketFlags::ShutdownType shutdownType);
};