Socket.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Foundation/AlignedStorage.h"
#include "../Foundation/Result.h"
#include "../Foundation/StringSpan.h"
#include "../Foundation/UniqueHandle.h"
#include "../Time/Time.h"
 
namespace SC
{
 
namespace detail
{
 
#if SC_PLATFORM_WINDOWS
 
struct SocketDescriptorDefinition
{
    using Handle = size_t; // SOCKET
    static Result releaseHandle(Handle& handle);
 
    static constexpr Handle Invalid = ~static_cast<Handle>(0); // INVALID_SOCKET
};
 
#else
 
struct SocketDescriptorDefinition
{
    using Handle = int; // fd
    static Result releaseHandle(Handle& handle);
 
    static constexpr Handle Invalid = -1; // invalid fd
};
 
#endif
} // namespace detail
 
struct 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 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 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(StringSpan interfaceAddress, uint16_t port);
 
    [[nodiscard]] uint32_t sizeOfHandle() const;
 
    [[nodiscard]] bool isValid() const;
 
    template <size_t N>
    [[nodiscard]] StringSpan toString(char (&buffer)[N]) const
    {
        static_assert(N >= MAX_ASCII_STRING_LENGTH, "Insufficient buffer");
        return formatAddress(buffer);
    }
 
    AlignedStorage<28> handle = {};
 
  private:
    [[nodiscard]] StringSpan formatAddress(Span<char> buffer) const;
    friend struct SocketServer;
    friend struct SocketClient;
 
    struct Internal;
};
 
struct SC_COMPILER_EXPORT 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);
};
 
struct SocketServer
{
    SocketServer(SocketDescriptor& socket) : socket(socket) {}
 
    [[nodiscard]] Result close();
 
    [[nodiscard]] Result bind(SocketIPAddress nativeAddress);
 
    [[nodiscard]] Result listen(uint32_t numberOfWaitingConnections);
 
    [[nodiscard]] Result accept(SocketFlags::AddressFamily addressFamily, SocketDescriptor& newClient);
 
  private:
    SocketDescriptor& socket;
};
 
struct SocketClient
{
    SocketClient(const SocketDescriptor& socket) : socket(socket) {}
 
    [[nodiscard]] Result connect(StringSpan address, uint16_t port);
 
    [[nodiscard]] Result connect(SocketIPAddress ipAddress);
 
    [[nodiscard]] Result write(Span<const char> data);
 
    [[nodiscard]] Result read(Span<char> data, Span<char>& readData);
 
    [[nodiscard]] Result readWithTimeout(Span<char> data, Span<char>& readData, Time::Milliseconds timeout);
 
  private:
    const SocketDescriptor& socket;
};
 
struct SocketDNS
{
    [[nodiscard]] static Result resolveDNS(StringSpan host, Span<char>& ipAddress);
};
 
struct SocketNetworking
{
    [[nodiscard]] static Result initNetworking();
 
    [[nodiscard]] static Result shutdownNetworking();
 
    [[nodiscard]] static bool isNetworkingInited();
 
  private:
    struct Internal;
};
 
} // namespace SC