C_socket.hpp

/*
 * Copyright 2025 Guillaume Guillet
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef _FGE_C_SOCKET_HPP_INCLUDED_
#define _FGE_C_SOCKET_HPP_INCLUDED_
 
/*
 * Original from : https://github.com/SFML/SFML
 * Copyright (C) 2007-2022 Laurent Gomila
 *
 * Altered/Modified by Guillaume Guillet
 */
 
#include "FastEngine/fge_extern.hpp"
#include "FastEngine/network/C_ipAddress.hpp"
#include <cstdint>
#include <vector>
 
#define FGE_SOCKET_ETHERNET_MTU 1500
#define FGE_SOCKET_IPV4_MIN_MTU 576
#define FGE_SOCKET_IPV6_MIN_MTU 1280
#define FGE_SOCKET_IPV4_HEADER_SIZE 20
#define FGE_SOCKET_IPV6_HEADER_SIZE 40
#define FGE_SOCKET_UDP_HEADER_SIZE 8
 
#define FGE_SOCKET_FULL_DATAGRAM_SIZE (0xFFFF)
#define FGE_SOCKET_IPV4_MAX_DATAGRAM_SIZE                                                                              \
    (FGE_SOCKET_FULL_DATAGRAM_SIZE - FGE_SOCKET_IPV4_HEADER_SIZE - FGE_SOCKET_UDP_HEADER_SIZE)
#define FGE_SOCKET_IPV6_MAX_DATAGRAM_SIZE                                                                              \
    (FGE_SOCKET_FULL_DATAGRAM_SIZE - FGE_SOCKET_IPV6_HEADER_SIZE - FGE_SOCKET_UDP_HEADER_SIZE)
#define FGE_SOCKET_IPV4_MAX_DATAGRAM_MTU_SIZE                                                                          \
    (FGE_SOCKET_IPV4_MIN_MTU - FGE_SOCKET_IPV4_HEADER_SIZE - FGE_SOCKET_UDP_HEADER_SIZE)
#define FGE_SOCKET_IPV6_MAX_DATAGRAM_MTU_SIZE                                                                          \
    (FGE_SOCKET_IPV6_MIN_MTU - FGE_SOCKET_IPV6_HEADER_SIZE - FGE_SOCKET_UDP_HEADER_SIZE)
#define FGE_SOCKET_IPV4_MAX_DATAGRAM_ETHMTU_SIZE                                                                       \
    (FGE_SOCKET_ETHERNET_MTU - FGE_SOCKET_IPV4_HEADER_SIZE - FGE_SOCKET_UDP_HEADER_SIZE)
#define FGE_SOCKET_IPV6_MAX_DATAGRAM_ETHMTU_SIZE                                                                       \
    (FGE_SOCKET_ETHERNET_MTU - FGE_SOCKET_IPV6_HEADER_SIZE - FGE_SOCKET_UDP_HEADER_SIZE)
 
#define FGE_SOCKET_TCP_DEFAULT_BUFFERSIZE 2048
 
namespace fge::net
{
 
class Packet;

class FGE_API Socket
{
public:
#ifdef _WIN32
    #if defined(_WIN64)
    using SocketDescriptor = uint64_t;
    #else
    using SocketDescriptor = unsigned int;
    #endif
#else
    using SocketDescriptor = int;
#endif

    enum class Types
    {
        UDP,
        TCP,
        TCP_LISTENER,
        UNKNOWN
    };

    enum class Errors
    {
        ERR_NOERROR = 0,
        ERR_SUCCESS = ERR_NOERROR,
        ERR_DONE = ERR_NOERROR,
 
        ERR_PARTIAL = 1,
        ERR_NOTREADY = 2,
        ERR_DISCONNECTED = 3,
        ERR_REFUSED = 4,
 
        ERR_ALREADYCONNECTED = 5,
        ERR_ALREADYUSED = 6,
        ERR_TOOMANYSOCKET = 7,
 
        ERR_NOTINIT = 8,
 
        ERR_INVALIDARGUMENT = 9,
 
        ERR_UNSUCCESS = 10,
        ERR_UNKNOWN = ERR_UNSUCCESS
    };
 
    struct AdapterInfo
    {
        struct Data
        {
            IpAddress _unicast;
        };
 
        std::string _name;
        std::string _description;
        uint16_t _mtu;
        std::vector<Data> _data;
    };

    [[nodiscard]] inline Types getType() const { return this->g_type; }
    [[nodiscard]] inline IpAddress::Types getAddressType() const { return this->g_addressType; }
    void setAddressType(IpAddress::Types type);

    virtual Errors create() = 0;
    void close();
    [[nodiscard]] bool isValid() const;

    [[nodiscard]] Port getLocalPort() const;
    [[nodiscard]] IpAddress getLocalAddress() const;
    [[nodiscard]] Port getRemotePort() const;
    [[nodiscard]] IpAddress getRemoteAddress() const;

    [[nodiscard]] bool isBlocking() const;

    Errors setBlocking(bool mode);
    Errors setReuseAddress(bool mode);
    Errors setBroadcastOption(bool mode);
    Errors setIpv6Only(bool mode);
    Errors setDontFragment(bool mode);

    Errors select(bool read, uint32_t timeoutms);

    static bool initSocket();
    static void uninitSocket();

    [[nodiscard]] std::optional<uint16_t> retrieveCurrentAdapterMTU() const;

    [[nodiscard]] static std::vector<AdapterInfo> getAdaptersInfo(IpAddress::Types type = IpAddress::Types::None);

    [[nodiscard]] static int getPlatformSpecifiedError();
 
    Socket& operator=(Socket const& r) = delete;
    Socket(Socket const& r) = delete;
 
protected:
    explicit Socket(Types type, IpAddress::Types addressType = IpAddress::Types::Ipv4);
    virtual ~Socket();
 
    Types g_type;
    IpAddress::Types g_addressType{IpAddress::Types::Ipv4};
    SocketDescriptor g_socket;
    bool g_isBlocking;
};

class FGE_API SocketUdp : public Socket
{
public:
    explicit SocketUdp(IpAddress::Types addressType = IpAddress::Types::Ipv4);
    SocketUdp(IpAddress::Types addressType, bool blocking, bool broadcast);
    ~SocketUdp() override = default;
 
    Errors create() override;

    Errors connect(IpAddress const& remoteAddress, Port remotePort);
    Errors disconnect();
    Errors bind(Port port, IpAddress const& address);

    Errors send(void const* data, std::size_t size);
    Errors sendTo(void const* data, std::size_t size, IpAddress const& remoteAddress, Port remotePort);
    Errors receiveFrom(void* data, std::size_t size, std::size_t& received, IpAddress& remoteAddress, Port& remotePort);
    Errors receive(void* data, std::size_t size, std::size_t& received);

    Errors send(Packet& packet);
    Errors sendTo(Packet& packet, IpAddress const& remoteAddress, Port remotePort);
    Errors receiveFrom(Packet& packet, IpAddress& remoteAddress, Port& remotePort);
    Errors receive(Packet& packet);

    [[nodiscard]] static std::optional<uint16_t> retrieveAdapterMTUForDestination(IpAddress const& destination);
 
    SocketUdp& operator=(SocketUdp&& r) noexcept;
 
private:
    std::vector<uint8_t> g_buffer;
};

class FGE_API SocketTcp : public Socket
{
public:
    explicit SocketTcp(IpAddress::Types addressType = IpAddress::Types::Ipv4);
    explicit SocketTcp(IpAddress::Types addressType, bool blocking);
    ~SocketTcp() override = default;

    void flush();

    Errors create(SocketDescriptor sck);
    Errors create() override;

    Errors connect(IpAddress const& remoteAddress, Port remotePort, uint32_t timeoutms);

    Errors send(void const* data, std::size_t size);
    Errors send(void const* data, std::size_t size, std::size_t& sent);
    Errors receive(void* data, std::size_t size, std::size_t& received);
    Errors receive(void* data, std::size_t size, std::size_t& received, uint32_t timeoutms);

    Errors send(Packet& packet);
    Errors receive(Packet& packet);

    Errors sendAndReceive(Packet& sendPacket, Packet& receivePacket, uint32_t timeoutms);
    Errors receive(Packet& packet, uint32_t timeoutms);
 
    SocketTcp& operator=(SocketTcp&& r) noexcept;
 
private:
    std::size_t g_receivedSize;
    std::size_t g_wantedSize;
    std::vector<uint8_t> g_buffer;
};

class FGE_API SocketListenerTcp : public Socket
{
public:
    explicit SocketListenerTcp(IpAddress::Types addressType = IpAddress::Types::Ipv4);
    explicit SocketListenerTcp(IpAddress::Types addressType, bool blocking);
    ~SocketListenerTcp() override = default;

    Errors create() override;

    Errors listen(Port port, IpAddress const& address);
    Errors accept(SocketTcp& socket);
 
    SocketListenerTcp& operator=(SocketListenerTcp&& r) noexcept;
};
 
} // namespace fge::net
 
#endif // _FGE_C_SOCKET_HPP_INCLUDED_