protocol.hpp

Go to the documentation of this file.

 
#ifndef JOIN_CORE_PROTOCOL_HPP
#define JOIN_CORE_PROTOCOL_HPP
 
// libjoin.
#include <join/endpoint.hpp>
 
// C++.
#include <bit>
 
// C.
#include <net/ethernet.h>
#ifdef JOIN_HAS_XDP
#include <linux/if_xdp.h>
#endif
#include <cstddef>
 
namespace join
{
    template <class Protocol>
    class BasicSocket;
 
    template <class Protocol>
    class BasicRawSocket;
 
    template <class Protocol>
    class BasicDatagramSocket;
 
    template <class Protocol>
    class BasicStreamSocket;
 
    template <class Protocol>
    class BasicStreamAcceptor;
 
    template <class Protocol>
    class BasicSocketStream;
 
#ifdef JOIN_HAS_IO_URING
    struct IoDefaultPolicy;
 
    template <typename IoPolicy>
    class BasicProactor;
 
    template <class Protocol, class ProactorType = BasicProactor<IoDefaultPolicy>, size_t OpCount = 16>
    class BasicAsyncSocket;
 
    template <class Protocol, class ProactorType = BasicProactor<IoDefaultPolicy>, size_t OpCount = 16>
    class BasicAsyncRawSocket;
 
    template <class Protocol, class ProactorType = BasicProactor<IoDefaultPolicy>, size_t OpCount = 16>
    class BasicAsyncDatagramSocket;
 
    template <class Protocol, class ProactorType = BasicProactor<IoDefaultPolicy>, size_t OpCount = 16>
    class BasicAsyncStreamSocket;
 
    template <class Protocol, class ProactorType = BasicProactor<IoDefaultPolicy>>
    class BasicAsyncStreamAcceptor;
#else
    class BasicProactor;
 
    template <class Protocol, class ProactorType = BasicProactor, size_t OpCount = 16>
    class BasicAsyncSocket;
 
    template <class Protocol, class ProactorType = BasicProactor, size_t OpCount = 16>
    class BasicAsyncRawSocket;
 
    template <class Protocol, class ProactorType = BasicProactor, size_t OpCount = 16>
    class BasicAsyncDatagramSocket;
 
    template <class Protocol, class ProactorType = BasicProactor, size_t OpCount = 16>
    class BasicAsyncStreamSocket;
 
    template <class Protocol, class ProactorType = BasicProactor>
    class BasicAsyncStreamAcceptor;
#endif
 
    class Raw
    {
    public:
        using Endpoint = BasicLinkLayerEndpoint<Raw>;
        using Socket = BasicRawSocket<Raw>;
        using AsyncSocket = BasicAsyncRawSocket<Raw>;
 
        constexpr Raw () noexcept = default;
 
        constexpr int family () const noexcept
        {
            return AF_PACKET;
        }
 
        constexpr int type () const noexcept
        {
            return SOCK_RAW;
        }
 
        constexpr int protocol () const noexcept
        {
            if constexpr (std::endian::native == std::endian::little)
            {
                return (ETH_P_ALL >> 8) | (ETH_P_ALL << 8);
            }
            return ETH_P_ALL;
        }
    };
 
#ifdef JOIN_HAS_XDP
    class Xdp
    {
    public:
        using Endpoint = BasicXdpEndpoint<Xdp>;
 
        constexpr Xdp () noexcept = default;
 
        constexpr int family () const noexcept
        {
            return AF_XDP;
        }
 
        constexpr int type () const noexcept
        {
            return SOCK_RAW;
        }
 
        constexpr int protocol () const noexcept
        {
            return 0;
        }
    };
#endif
 
    class UnixDgram
    {
    public:
        using Endpoint = BasicUnixEndpoint<UnixDgram>;
        using Socket = BasicDatagramSocket<UnixDgram>;
        using AsyncSocket = BasicAsyncDatagramSocket<UnixDgram>;
 
        constexpr UnixDgram () noexcept = default;
 
        constexpr int family () const noexcept
        {
            return AF_UNIX;
        }
 
        constexpr int type () const noexcept
        {
            return SOCK_DGRAM;
        }
 
        constexpr int protocol () const noexcept
        {
            return 0;
        }
    };
 
    class UnixStream
    {
    public:
        using Endpoint = BasicUnixEndpoint<UnixStream>;
        using Socket = BasicStreamSocket<UnixStream>;
        using Stream = BasicSocketStream<UnixStream>;
        using Acceptor = BasicStreamAcceptor<UnixStream>;
        using AsyncSocket = BasicAsyncStreamSocket<UnixStream>;
        using AsyncAcceptor = BasicAsyncStreamAcceptor<UnixStream>;
 
        constexpr UnixStream () noexcept = default;
 
        constexpr int family () const noexcept
        {
            return AF_UNIX;
        }
 
        constexpr int type () const noexcept
        {
            return SOCK_STREAM;
        }
 
        constexpr int protocol () const noexcept
        {
            return 0;
        }
    };
 
    class Udp
    {
    public:
        using Endpoint = BasicInternetEndpoint<Udp>;
        using Socket = BasicDatagramSocket<Udp>;
        using AsyncSocket = BasicAsyncDatagramSocket<Udp>;
 
        constexpr explicit Udp (int family = AF_INET) noexcept
        : _family (family)
        {
        }
 
        static inline Udp& v4 () noexcept
        {
            static Udp udpv4 (AF_INET);
            return udpv4;
        }
 
        static inline Udp& v6 () noexcept
        {
            static Udp udpv6 (AF_INET6);
            return udpv6;
        }
 
        constexpr int family () const noexcept
        {
            return _family;
        }
 
        constexpr int type () const noexcept
        {
            return SOCK_DGRAM;
        }
 
        constexpr int protocol () const noexcept
        {
            return IPPROTO_UDP;
        }
 
    private:
        int _family;
    };
 
    constexpr bool operator== (const Udp& a, const Udp& b) noexcept
    {
        return a.family () == b.family ();
    }
 
    class Icmp
    {
    public:
        using Endpoint = BasicInternetEndpoint<Icmp>;
        using Socket = BasicDatagramSocket<Icmp>;
        using AsyncSocket = BasicAsyncDatagramSocket<Icmp>;
 
        constexpr explicit Icmp (int family = AF_INET) noexcept
        : _family (family)
        {
        }
 
        static inline Icmp& v4 () noexcept
        {
            static Icmp icmpv4 (AF_INET);
            return icmpv4;
        }
 
        static inline Icmp& v6 () noexcept
        {
            static Icmp icmpv6 (AF_INET6);
            return icmpv6;
        }
 
        constexpr int family () const noexcept
        {
            return _family;
        }
 
        constexpr int type () const noexcept
        {
            return SOCK_RAW;
        }
 
        constexpr int protocol () const noexcept
        {
            if (family () == AF_INET6)
            {
                return int (IPPROTO_ICMPV6);
            }
 
            return IPPROTO_ICMP;
        }
 
    private:
        int _family;
    };
 
    constexpr bool operator== (const Icmp& a, const Icmp& b) noexcept
    {
        return a.family () == b.family ();
    }
 
    class Tcp
    {
    public:
        using Endpoint = BasicInternetEndpoint<Tcp>;
        using Socket = BasicStreamSocket<Tcp>;
        using Stream = BasicSocketStream<Tcp>;
        using Acceptor = BasicStreamAcceptor<Tcp>;
        using AsyncSocket = BasicAsyncStreamSocket<Tcp>;
        using AsyncAcceptor = BasicAsyncStreamAcceptor<Tcp>;
 
        constexpr explicit Tcp (int family = AF_INET) noexcept
        : _family (family)
        {
        }
 
        static inline Tcp& v4 () noexcept
        {
            static Tcp tcpv4 (AF_INET);
            return tcpv4;
        }
 
        static inline Tcp& v6 () noexcept
        {
            static Tcp tcpv6 (AF_INET6);
            return tcpv6;
        }
 
        constexpr int family () const noexcept
        {
            return _family;
        }
 
        constexpr int type () const noexcept
        {
            return SOCK_STREAM;
        }
 
        constexpr int protocol () const noexcept
        {
            return IPPROTO_TCP;
        }
 
    private:
        int _family;
    };
 
    constexpr bool operator== (const Tcp& a, const Tcp& b) noexcept
    {
        return a.family () == b.family ();
    }
}
 
#endif