socket_base.hpp

浏览该文件的文档.

#ifndef NEFORCE_NETWORK_SOCKET_BASE_HPP__
#define NEFORCE_NETWORK_SOCKET_BASE_HPP__

 
#include "NeForce/core/exception/system_exception.hpp"
#include "NeForce/core/time/duration.hpp"
#include "NeForce/network/util/ip_address.hpp"
#ifdef NEFORCE_PLATFORM_LINUX
#    include <linux/if_ether.h>
#endif
NEFORCE_BEGIN_NAMESPACE__


struct NEFORCE_API socket_exception final : network_exception {
    static int last_error() noexcept;

    static bool is_would_block(int error) noexcept;
 
    explicit socket_exception(const char* info = "Socket Operation Failed.",
                              const error_code code = error_code(last_error(), system_category())) noexcept :
    network_exception(info, code) {}
 
    explicit socket_exception(const exception& e) :
    network_exception(e) {}
 
    ~socket_exception() override = default;
 
    NEFORCE_NODISCARD const char* type() const noexcept override { return "socket_exception"; }
};
 // Exceptions


class NEFORCE_API socket_base {
public:
    using native_handle_type =
#ifdef NEFORCE_PLATFORM_WINDOWS
            uintptr_t; 
#else
            int; 
#endif

    static constexpr native_handle_type invalid_handle =
#ifdef NEFORCE_PLATFORM_WINDOWS
            numeric_traits<native_handle_type>::max(); 
#else
            -1; 
#endif
 
    using family = ip_address::family; 

    enum class type : int32_t {
        STREAM = SOCK_STREAM,       
        DGRAM = SOCK_DGRAM,         
        RAW = SOCK_RAW,             
        RDM = SOCK_RDM,             
        SEQPACKET = SOCK_SEQPACKET, 
#ifdef NEFORCE_PLATFORM_LINUX
        CLOEXEC = SOCK_CLOEXEC,   
        NONBLOCK = SOCK_NONBLOCK, 
        DCCP = SOCK_DCCP,         
#endif
    };

    enum class protocol : int32_t {
        AUTO = 0,            
        ICMP = IPPROTO_ICMP, 
        TCP = IPPROTO_TCP,   
        UDP = IPPROTO_UDP,   
        SCTP = IPPROTO_SCTP, 
        RAW = IPPROTO_RAW,   
        ESP = IPPROTO_ESP,   
        AH = IPPROTO_AH,     
#ifdef NEFORCE_PLATFORM_LINUX
        DCCP = IPPROTO_DCCP, 
 
        IP = ETH_P_IP,       
        ARP = ETH_P_ARP,     
        IPV6 = ETH_P_IPV6,   
        LAT = ETH_P_LAT,     
        VLAN = ETH_P_8021Q,  
        LLDP = ETH_P_LLDP,   
        MPLS = ETH_P_MPLS_UC 
#endif
    };
 
protected:
    native_handle_type fd_ = invalid_handle; 
    bool nonblocking_{false};                
 
public:
    socket_base();

    explicit socket_base(const native_handle_type fd) noexcept :
    fd_(fd) {}
 
    socket_base(const socket_base&) = delete;
    socket_base& operator=(const socket_base&) = delete;

    socket_base(socket_base&& other) noexcept :
    fd_(exchange(other.fd_, invalid_handle)),
    nonblocking_(exchange(other.nonblocking_, false)) {}

    socket_base& operator=(socket_base&& other) noexcept;

    virtual ~socket_base() { socket_base::close(); }

    NEFORCE_NODISCARD native_handle_type native_handle() const noexcept { return fd_; }

    NEFORCE_NODISCARD bool is_open() const noexcept { return fd_ != invalid_handle; }

    explicit operator bool() const noexcept { return is_open(); }

    void open(family f, type t = type::STREAM, protocol p = protocol::AUTO);

    virtual bool close() noexcept;

    bool try_open(family f, type t = type::STREAM, protocol p = protocol::AUTO) noexcept;

    NEFORCE_NODISCARD bool is_nonblocking() const noexcept;

    bool set_nonblocking(bool enable) noexcept;

    bool shutdown_send() noexcept;

    bool shutdown_receive() noexcept;

    bool shutdown_both() noexcept;

    bool set_option(int level, int optname, const void* value, ::socklen_t len) noexcept;

    bool get_option(int level, int optname, void* optval, ::socklen_t* optlen) const noexcept;

    NEFORCE_NODISCARD bool get_reuse_address() const noexcept;

    bool set_reuse_address(bool enable = true) noexcept;

    NEFORCE_NODISCARD bool get_reuse_port() const noexcept;

    bool set_reuse_port(bool enable = true) noexcept;

    NEFORCE_NODISCARD bool get_keep_alive() const noexcept;

    bool set_keep_alive(bool enable = true) noexcept;

    NEFORCE_NODISCARD bool get_tcp_nodelay() const noexcept;

    bool set_tcp_nodelay(bool enable = true) noexcept;

    NEFORCE_NODISCARD int get_receive_buffer_size() const noexcept;

    bool set_receive_buffer_size(int size) noexcept;

    NEFORCE_NODISCARD int get_send_buffer_size() const noexcept;

    bool set_send_buffer_size(int size) noexcept;

    NEFORCE_NODISCARD optional<milliseconds> get_send_timeout() const noexcept;

    bool set_send_timeout(milliseconds timeout) noexcept;

    NEFORCE_NODISCARD optional<milliseconds> get_receive_timeout() const noexcept;

    bool set_receive_timeout(milliseconds timeout) noexcept;

    NEFORCE_NODISCARD optional<ip_address> local_endpoint() const;

    NEFORCE_NODISCARD optional<ip_address> remote_endpoint() const;

    void bind(const ip_address& endpoint);

    void listen(int backlog);

    NEFORCE_NODISCARD native_handle_type release() noexcept { return exchange(fd_, invalid_handle); }
};
 // SocketBase
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_NETWORK_SOCKET_BASE_HPP__