Socket.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Common/CompilerMacrosExport.h"
#include "../Common/PlatformMacrosType.h"
#ifndef SC_EXPORT_LIBRARY_SOCKET
#define SC_EXPORT_LIBRARY_SOCKET 0
#endif
#define SC_SOCKET_EXPORT SC_COMPILER_LIBRARY_EXPORT(SC_EXPORT_LIBRARY_SOCKET)
 
#include "../Common/AlignedStorage.h"
#include "../Common/Assert.h"
#include "../Common/Result.h"
#include "../Common/StringSpan.h"
#include "../Common/UniqueHandle.h"
 
namespace SC
{
SC_DECLARE_ASSERT_PROVIDER(SocketAssert, SC_SOCKET_EXPORT);
 
#define SC_SOCKET_ASSERT_RELEASE(e)        SC_ASSERT_PROVIDER_RELEASE(SC::SocketAssert, e)
#define SC_SOCKET_ASSERT_DEBUG(e)          SC_ASSERT_PROVIDER_DEBUG(SC::SocketAssert, e)
#define SC_SOCKET_TRUST_RESULT(expression) SC_SOCKET_ASSERT_RELEASE(expression)
 
 
namespace detail
{
 
#if SC_PLATFORM_WINDOWS
 
struct SC_SOCKET_EXPORT SocketDescriptorDefinition
{
    using Handle = size_t; // SOCKET
    static Result releaseHandle(Handle& handle);
 
    static constexpr Handle Invalid = ~static_cast<Handle>(0); // INVALID_SOCKET
};
 
#else
 
struct SC_SOCKET_EXPORT SocketDescriptorDefinition
{
    using Handle = int; // fd
    static Result releaseHandle(Handle& handle);
 
    static constexpr Handle Invalid = -1; // invalid fd
};
 
#endif
} // namespace detail
 
struct SC_SOCKET_EXPORT SocketFlags
{
    enum BlockingType
    {
        NonBlocking, 
        Blocking     
    };
 
    enum InheritableType
    {
        NonInheritable, 
        Inheritable     
    };
 
    enum AddressFamily
    {
        AddressFamilyIPV4, 
        AddressFamilyIPV6, 
        AddressFamilyUnix  
    };
 
    enum SocketType
    {
        SocketStream, 
        SocketDgram   
    };
 
    enum ProtocolType
    {
        ProtocolTcp,     
        ProtocolUdp,     
        ProtocolDefault, 
    };
 
    enum ShutdownType
    {
        ShutdownBoth 
    };
 
  private:
    friend struct SocketDescriptor;
    friend struct SocketAddress;
    friend struct SocketIPAddressInternal;
    [[nodiscard]] static AddressFamily AddressFamilyFromInt(int value);
    [[nodiscard]] static unsigned char toNative(AddressFamily family);
 
    [[nodiscard]] static int toNative(SocketType family);
    [[nodiscard]] static int toNative(ProtocolType family);
};
 
struct SC_SOCKET_EXPORT 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;
 
    Result fromAddressPort(StringSpan interfaceAddress, uint16_t port);
 
    [[nodiscard]] uint32_t sizeOfHandle() const;
 
    [[nodiscard]] bool isValid() const;
 
    [[nodiscard]] bool toString(Span<char> inputSpan, StringSpan& outputSpan) const;
 
    AlignedStorage<28> handle = {};
 
  private:
    friend struct SocketServer;
    friend struct SocketClient;
 
    struct Internal;
};
 
struct SC_SOCKET_EXPORT SocketAddress
{
    enum class UnixNamespace
    {
        Unnamed,
        Pathname,
        Abstract
    };
 
    SocketAddress() = default;
    SocketAddress(const SocketIPAddress& ipAddress);
 
    Result fromUnixPath(StringSpan path);
 
    Result fromUnixAbstractName(Span<const char> name);
 
    [[nodiscard]] SocketFlags::AddressFamily getAddressFamily() const;
    [[nodiscard]] uint32_t                   sizeOfHandle() const;
    [[nodiscard]] bool                       isValid() const;
 
    Result getIPAddress(SocketIPAddress& output) const;
 
    Result getUnixName(Span<const char>& output, UnixNamespace& unixNamespace) const;
 
    AlignedStorage<128> handle     = {};
    uint32_t            nativeSize = 0;
};
 
struct SC_SOCKET_EXPORT SocketDescriptor : public UniqueHandle<detail::SocketDescriptorDefinition>
{
    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);
 
    Result setTcpNoDelay(bool tcpNoDelay);
 
    Result setBroadcast(bool enableBroadcast);
 
    Result joinMulticastGroup(const SocketIPAddress& multicastAddress, const SocketIPAddress& interfaceAddress);
 
    Result leaveMulticastGroup(const SocketIPAddress& multicastAddress, const SocketIPAddress& interfaceAddress);
 
    Result setMulticastLoopback(SocketFlags::AddressFamily addressFamily, bool enableLoopback);
 
    Result setMulticastHops(SocketFlags::AddressFamily addressFamily, int hops);
 
    Result setMulticastOutboundInterface(const SocketIPAddress& interfaceAddress);
 
    Result sendTo(Span<const char> data, const SocketAddress& destination);
 
    Result sendTo(Span<const char> data, const SocketIPAddress& destination);
 
    Result receiveFrom(Span<char> buffer, Span<char>& receivedData, SocketAddress& sourceAddress);
 
    Result receiveFrom(Span<char> buffer, Span<char>& receivedData, SocketIPAddress& sourceAddress);
};
 
struct SC_SOCKET_EXPORT SocketServer
{
    enum class BindReuseAddress : uint8_t
    {
        Disabled,
        Enabled,
    };
 
    enum class BindStatus : uint8_t
    {
        None,
        AddressInUse,
    };
 
    SocketServer(SocketDescriptor& socket) : socket(socket) {}
 
    Result close();
 
    Result bind(const SocketAddress& nativeAddress, BindReuseAddress reuseAddress = BindReuseAddress::Enabled,
                BindStatus* outStatus = nullptr);
 
    Result bind(SocketIPAddress nativeAddress, BindReuseAddress reuseAddress = BindReuseAddress::Enabled,
                BindStatus* outStatus = nullptr);
 
    Result listen(uint32_t numberOfWaitingConnections);
 
    Result accept(SocketFlags::AddressFamily addressFamily, SocketDescriptor& newClient);
 
    Result accept(SocketDescriptor& newClient, SocketAddress* peerAddress = nullptr);
 
  private:
    SocketDescriptor& socket;
};
 
struct SC_SOCKET_EXPORT SocketClient
{
    SocketClient(const SocketDescriptor& socket) : socket(socket) {}
 
    Result connect(StringSpan address, uint16_t port);
 
    Result connect(SocketIPAddress ipAddress);
 
    Result connect(const SocketAddress& address);
 
    Result write(Span<const char> data);
 
    Result read(Span<char> data, Span<char>& readData);
 
    Result readWithTimeout(Span<char> data, Span<char>& readData, int64_t timeout);
 
  private:
    const SocketDescriptor& socket;
};
 
struct SC_SOCKET_EXPORT SocketDNS
{
    [[nodiscard]] static Result resolveDNS(StringSpan host, Span<char>& ipAddress);
};
 
struct SC_SOCKET_EXPORT SocketNetworking
{
    static void initNetworking();
 
    static void shutdownNetworking();
 
    [[nodiscard]] static bool isNetworkingInited();
 
  private:
    struct Internal;
};
 
} // namespace SC