C_socket.hpp

/*
 * Copyright 2024 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_MAXDATAGRAMSIZE 65507
#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 Type
    {
        TYPE_UDP,
        TYPE_TCP,
        TYPE_LISTENER_TCP
    };
 
    enum Error
    {
        ERR_NOERROR = 0,
        ERR_SUCCESS = ERR_NOERROR,
        ERR_DONE = ERR_NOERROR,
 
        ERR_PARTIAL,
        ERR_NOTREADY,
        ERR_DISCONNECTED,
        ERR_REFUSED,
 
        ERR_ALREADYCONNECTED,
        ERR_ALREADYUSED,
        ERR_TOOMANYSOCKET,
 
        ERR_NOTINIT,
 
        ERR_INVALIDARGUMENT,
 
        ERR_UNSUCCESS,
        ERR_UNKNOWN = ERR_UNSUCCESS
    };
 
    [[nodiscard]] inline Type getType() const { return this->g_type; }
    [[nodiscard]] inline IpAddress::Types getAddressType() const { return this->g_addressType; }
    void setAddressType(IpAddress::Types type);
 
    virtual Error create() = 0;
    void close();
    [[nodiscard]] bool isValid() const;
 
    [[nodiscard]] fge::net::Port getLocalPort() const;
    [[nodiscard]] fge::net::IpAddress getLocalAddress() const;
    [[nodiscard]] fge::net::Port getRemotePort() const;
    [[nodiscard]] fge::net::IpAddress getRemoteAddress() const;
 
    [[nodiscard]] bool isBlocking() const;
 
    Error setBlocking(bool mode);
    Error setReuseAddress(bool mode);
    Error setBroadcastOption(bool mode);
 
    Error select(bool read, uint32_t timeoutms);
 
    static bool initSocket();
    static void uninitSocket();
 
    [[nodiscard]] static int getPlatformSpecifiedError();
 
    fge::net::Socket& operator=(fge::net::Socket const& r) = delete;
    Socket(fge::net::Socket const& r) = delete;
 
protected:
    explicit Socket(Type type, IpAddress::Types addressType = IpAddress::Types::Ipv4);
    virtual ~Socket() = default;
 
    Type g_type;
    IpAddress::Types g_addressType{IpAddress::Types::Ipv4};
    SocketDescriptor g_socket;
    bool g_isBlocking;
};
 
class FGE_API SocketUdp : public fge::net::Socket
{
public:
    explicit SocketUdp(IpAddress::Types addressType = IpAddress::Types::Ipv4);
    SocketUdp(IpAddress::Types addressType, bool blocking, bool broadcast);
    ~SocketUdp() override;
 
    fge::net::Socket::Error create() override;
 
    fge::net::Socket::Error connect(fge::net::IpAddress const& remoteAddress, fge::net::Port remotePort);
    fge::net::Socket::Error bind(fge::net::Port port, IpAddress const& address);
 
    fge::net::Socket::Error send(void const* data, std::size_t size);
    fge::net::Socket::Error
    sendTo(void const* data, std::size_t size, IpAddress const& remoteAddress, fge::net::Port remotePort);
    fge::net::Socket::Error receiveFrom(void* data,
                                        std::size_t size,
                                        std::size_t& received,
                                        fge::net::IpAddress& remoteAddress,
                                        fge::net::Port& remotePort);
    fge::net::Socket::Error receive(void* data, std::size_t size, std::size_t& received);
 
    fge::net::Socket::Error send(fge::net::Packet& packet);
    fge::net::Socket::Error sendTo(fge::net::Packet& packet, IpAddress const& remoteAddress, fge::net::Port remotePort);
    fge::net::Socket::Error
    receiveFrom(fge::net::Packet& packet, fge::net::IpAddress& remoteAddress, fge::net::Port& remotePort);
    fge::net::Socket::Error receive(fge::net::Packet& packet);
 
    fge::net::SocketUdp& operator=(fge::net::SocketUdp&& r) noexcept;
 
private:
    std::vector<uint8_t> g_buffer;
};
 
class FGE_API SocketTcp : public fge::net::Socket
{
public:
    explicit SocketTcp(IpAddress::Types addressType = IpAddress::Types::Ipv4);
    explicit SocketTcp(IpAddress::Types addressType, bool blocking);
    ~SocketTcp() override;
 
    void flush();
 
    fge::net::Socket::Error create(fge::net::Socket::SocketDescriptor sck);
    fge::net::Socket::Error create() override;
 
    fge::net::Socket::Error
    connect(fge::net::IpAddress const& remoteAddress, fge::net::Port remotePort, uint32_t timeoutms);
 
    fge::net::Socket::Error send(void const* data, std::size_t size);
    fge::net::Socket::Error send(void const* data, std::size_t size, std::size_t& sent);
    fge::net::Socket::Error receive(void* data, std::size_t size, std::size_t& received);
 
    fge::net::Socket::Error send(fge::net::Packet& packet);
    fge::net::Socket::Error receive(fge::net::Packet& packet);
 
    fge::net::Socket::Error
    sendAndReceive(fge::net::Packet& sendPacket, fge::net::Packet& receivePacket, uint32_t timeoutms);
    fge::net::Socket::Error receive(fge::net::Packet& packet, uint32_t timeoutms);
 
    fge::net::SocketTcp& operator=(fge::net::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 fge::net::Socket
{
public:
    explicit SocketListenerTcp(IpAddress::Types addressType = IpAddress::Types::Ipv4);
    explicit SocketListenerTcp(IpAddress::Types addressType, bool blocking);
    ~SocketListenerTcp() override;
 
    fge::net::Socket::Error create() override;
 
    fge::net::Socket::Error listen(fge::net::Port port, fge::net::IpAddress const& address);
    fge::net::Socket::Error accept(fge::net::SocketTcp& socket);
 
    fge::net::SocketListenerTcp& operator=(fge::net::SocketListenerTcp&& r) noexcept;
};
 
} // namespace fge::net
 
#endif // _FGE_C_SOCKET_HPP_INCLUDED_