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"
#include "../Strings/StringView.h"
#include "../Time/Time.h" // Milliseconds
 
namespace SC
{
struct String;
} // namespace SC
 
namespace SC
{
struct SC_COMPILER_EXPORT SocketDescriptor;
struct SocketFlags;
struct SocketIPAddress;
struct SocketNetworking;
struct SocketClient;
struct SocketServer;
struct SocketDNS;
namespace detail
{
struct SocketDescriptorDefinition;
}
} // 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 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(StringView interfaceAddress, uint16_t port);
 
    friend struct SocketServer;
    friend struct SocketClient;
 
    uint32_t sizeOfHandle() const;
 
    AlignedStorage<28> handle = {};
 
  private:
    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;
};
 
struct SC::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 SC::SocketClient
{
    SocketClient(const SocketDescriptor& socket) : socket(socket) {}
 
    [[nodiscard]] Result connect(StringView 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 SC::SocketDNS
{
    [[nodiscard]] static Result resolveDNS(StringView host, String& ipAddress);
};
 
struct SC::SocketNetworking
{
    [[nodiscard]] static Result initNetworking();
 
    [[nodiscard]] static Result shutdownNetworking();
 
    [[nodiscard]] static bool isNetworkingInited();
 
  private:
    struct Internal;
};