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 <linux/netlink.h>
#include <net/ethernet.h>
 
namespace join
{
    template <class Protocol>
    class BasicSocket;
    template <class Protocol>
    class BasicDatagramSocket;
    template <class Protocol>
    class BasicStreamSocket;
    template <class Protocol>
    class BasicTlsSocket;
 
    template <class Protocol>
    class BasicSocketStream;
    template <class Protocol>
    class BasicTlsStream;
 
    template <class Protocol>
    class BasicStreamAcceptor;
    template <class Protocol>
    class BasicTlsAcceptor;
 
    template <class Protocol>
    class BasicDatagramResolver;
    template <class Protocol>
    class BasicTlsResolver;
 
    template <class Protocol>
    class BasicDatagramNameServer;
    template <class Protocol>
    class BasicDatagramPeer;
 
    template <class Protocol>
    class BasicHttpClient;
    template <class Protocol>
    class BasicHttpSecureClient;
 
    template <class Protocol>
    class BasicHttpWorker;
    template <class Protocol>
    class BasicHttpServer;
    template <class Protocol>
    class BasicHttpSecureServer;
 
    template <class Protocol>
    class BasicSmtpClient;
    template <class Protocol>
    class BasicSmtpSecureClient;
 
    class UnixDgram
    {
    public:
        using Endpoint = BasicUnixEndpoint<UnixDgram>;
        using Socket = BasicDatagramSocket<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>;
 
        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 Netlink
    {
    public:
        using Endpoint = BasicNetlinkEndpoint<Netlink>;
        using Socket = BasicDatagramSocket<Netlink>;
 
        constexpr Netlink (int proto = NETLINK_ROUTE) noexcept
        : _proto (proto)
        {
        }
 
        static inline Netlink& rt () noexcept
        {
            static Netlink route (NETLINK_ROUTE);
            return route;
        }
 
        static inline Netlink& nf () noexcept
        {
            static Netlink netfilter (NETLINK_NETFILTER);
            return netfilter;
        }
 
        constexpr int family () const noexcept
        {
            return AF_NETLINK;
        }
 
        constexpr int type () const noexcept
        {
            return SOCK_RAW;
        }
 
        constexpr int protocol () const noexcept
        {
            return _proto;
        }
 
    private:
        int _proto;
    };
 
    constexpr bool operator== (const Netlink& a, const Netlink& b) noexcept
    {
        return a.protocol () == b.protocol ();
    }
 
    constexpr bool operator!= (const Netlink& a, const Netlink& b) noexcept
    {
        return !(a == b);
    }
 
    class Raw
    {
    public:
        using Endpoint = BasicLinkLayerEndpoint<Raw>;
        using Socket = BasicSocket<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 (BYTE_ORDER == LITTLE_ENDIAN)
            {
                return (ETH_P_ALL >> 8) | (ETH_P_ALL << 8);
            }
            return ETH_P_ALL;
        }
    };
 
    class Udp
    {
    public:
        using Endpoint = BasicInternetEndpoint<Udp>;
        using Socket = BasicDatagramSocket<Udp>;
 
        constexpr 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 ();
    }
 
    constexpr bool operator!= (const Udp& a, const Udp& b) noexcept
    {
        return !(a == b);
    }
 
    class Icmp
    {
    public:
        using Endpoint = BasicInternetEndpoint<Icmp>;
        using Socket = BasicDatagramSocket<Icmp>;
 
        constexpr 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 ();
    }
 
    constexpr bool operator!= (const Icmp& a, const Icmp& b) noexcept
    {
        return !(a == b);
    }
 
    class Tcp
    {
    public:
        using Endpoint = BasicInternetEndpoint<Tcp>;
        using Socket = BasicStreamSocket<Tcp>;
        using Stream = BasicSocketStream<Tcp>;
        using Acceptor = BasicStreamAcceptor<Tcp>;
 
        constexpr 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 ();
    }
 
    constexpr bool operator!= (const Tcp& a, const Tcp& b) noexcept
    {
        return !(a == b);
    }
 
    class Tls
    {
    public:
        using Endpoint = BasicInternetEndpoint<Tls>;
        using Socket = BasicTlsSocket<Tls>;
        using Stream = BasicTlsStream<Tls>;
        using Acceptor = BasicTlsAcceptor<Tls>;
 
        constexpr Tls (int family = AF_INET) noexcept
        : _family (family)
        {
        }
 
        static inline Tls& v4 () noexcept
        {
            static Tls tlsv4 (AF_INET);
            return tlsv4;
        }
 
        static inline Tls& v6 () noexcept
        {
            static Tls tlsv6 (AF_INET6);
            return tlsv6;
        }
 
        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 Tls& a, const Tls& b) noexcept
    {
        return a.family () == b.family ();
    }
 
    constexpr bool operator!= (const Tls& a, const Tls& b) noexcept
    {
        return !(a == b);
    }
 
    class Dns
    {
    public:
        using Endpoint = BasicInternetEndpoint<Dns>;
        using Socket = BasicDatagramSocket<Dns>;
        using Resolver = BasicDatagramResolver<Dns>;
        using NameServer = BasicDatagramNameServer<Dns>;
 
        constexpr Dns (int family = AF_INET) noexcept
        : _family (family)
        {
        }
 
        static inline Dns& v4 () noexcept
        {
            static Dns dnsv4 (AF_INET);
            return dnsv4;
        }
 
        static inline Dns& v6 () noexcept
        {
            static Dns dnsv6 (AF_INET6);
            return dnsv6;
        }
 
        constexpr int family () const noexcept
        {
            return _family;
        }
 
        constexpr int type () const noexcept
        {
            return SOCK_DGRAM;
        }
 
        constexpr int protocol () const noexcept
        {
            return IPPROTO_UDP;
        }
 
        static constexpr uint16_t defaultPort = 53;
 
        static constexpr size_t maxMsgSize = 8192;
 
    private:
        int _family;
    };
 
    constexpr bool operator== (const Dns& a, const Dns& b) noexcept
    {
        return a.family () == b.family ();
    }
 
    constexpr bool operator!= (const Dns& a, const Dns& b) noexcept
    {
        return !(a == b);
    }
 
    class Mdns
    {
    public:
        using Endpoint = BasicInternetEndpoint<Mdns>;
        using Socket = BasicDatagramSocket<Mdns>;
        using Peer = BasicDatagramPeer<Mdns>;
 
        constexpr Mdns (int family = AF_INET) noexcept
        : _family (family)
        {
        }
 
        static inline Mdns& v4 () noexcept
        {
            static Mdns mdnsv4 (AF_INET);
            return mdnsv4;
        }
 
        static inline Mdns& v6 () noexcept
        {
            static Mdns mdnsv6 (AF_INET6);
            return mdnsv6;
        }
 
        constexpr int family () const noexcept
        {
            return _family;
        }
 
        constexpr int type () const noexcept
        {
            return SOCK_DGRAM;
        }
 
        constexpr int protocol () const noexcept
        {
            return IPPROTO_UDP;
        }
 
        static IpAddress multicastAddress (int family) noexcept
        {
            return (family == AF_INET6) ? "ff02::fb" : "224.0.0.251";
        }
 
        static constexpr uint16_t defaultPort = 5353;
 
        static constexpr size_t maxMsgSize = 8192;
 
    private:
        int _family;
    };
 
    constexpr bool operator== (const Mdns& a, const Mdns& b) noexcept
    {
        return a.family () == b.family ();
    }
 
    constexpr bool operator!= (const Mdns& a, const Mdns& b) noexcept
    {
        return !(a == b);
    }
 
    class Dot
    {
    public:
        using Endpoint = BasicInternetEndpoint<Dot>;
        using Socket = BasicTlsSocket<Dot>;
        using Resolver = BasicTlsResolver<Dot>;
 
        constexpr Dot (int family = AF_INET) noexcept
        : _family (family)
        {
        }
 
        static inline Dot& v4 () noexcept
        {
            static Dot dotv4 (AF_INET);
            return dotv4;
        }
 
        static inline Dot& v6 () noexcept
        {
            static Dot dotv6 (AF_INET6);
            return dotv6;
        }
 
        constexpr int family () const noexcept
        {
            return _family;
        }
 
        constexpr int type () const noexcept
        {
            return SOCK_STREAM;
        }
 
        constexpr int protocol () const noexcept
        {
            return IPPROTO_TCP;
        }
 
        static constexpr uint16_t defaultPort = 853;
 
        static constexpr size_t maxMsgSize = 16384;
 
    private:
        int _family;
    };
 
    constexpr bool operator== (const Dot& a, const Dot& b) noexcept
    {
        return a.family () == b.family ();
    }
 
    constexpr bool operator!= (const Dot& a, const Dot& b) noexcept
    {
        return !(a == b);
    }
 
    class Http
    {
    public:
        using Endpoint = BasicInternetEndpoint<Http>;
        using Socket = BasicStreamSocket<Http>;
        using Stream = BasicSocketStream<Http>;
        using Acceptor = BasicStreamAcceptor<Http>;
        using Client = BasicHttpClient<Http>;
        using Worker = BasicHttpWorker<Http>;
        using Server = BasicHttpServer<Http>;
 
        constexpr Http (int family = AF_INET) noexcept
        : _family (family)
        {
        }
 
        static inline Http& v4 () noexcept
        {
            static Http httpv4 (AF_INET);
            return httpv4;
        }
 
        static inline Http& v6 () noexcept
        {
            static Http httpv6 (AF_INET6);
            return httpv6;
        }
 
        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 Http& a, const Http& b) noexcept
    {
        return a.family () == b.family ();
    }
 
    constexpr bool operator!= (const Http& a, const Http& b) noexcept
    {
        return !(a == b);
    }
 
    class Https
    {
    public:
        using Endpoint = BasicInternetEndpoint<Https>;
        using Socket = BasicTlsSocket<Https>;
        using Stream = BasicTlsStream<Https>;
        using Acceptor = BasicTlsAcceptor<Https>;
        using Client = BasicHttpSecureClient<Https>;
        using Worker = BasicHttpWorker<Https>;
        using Server = BasicHttpSecureServer<Https>;
 
        constexpr Https (int family = AF_INET) noexcept
        : _family (family)
        {
        }
 
        static inline Https& v4 () noexcept
        {
            static Https httpsv4 (AF_INET);
            return httpsv4;
        }
 
        static inline Https& v6 () noexcept
        {
            static Https httpsv6 (AF_INET6);
            return httpsv6;
        }
 
        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 Https& a, const Https& b) noexcept
    {
        return a.family () == b.family ();
    }
 
    constexpr bool operator!= (const Https& a, const Https& b) noexcept
    {
        return !(a == b);
    }
 
    class Smtp
    {
    public:
        using Endpoint = BasicInternetEndpoint<Smtp>;
        using Socket = BasicTlsSocket<Smtp>;
        using Stream = BasicTlsStream<Smtp>;
        using Client = BasicSmtpClient<Smtp>;
 
        constexpr Smtp (int family = AF_INET) noexcept
        : _family (family)
        {
        }
 
        static inline Smtp& v4 () noexcept
        {
            static Smtp smtpv4 (AF_INET);
            return smtpv4;
        }
 
        static inline Smtp& v6 () noexcept
        {
            static Smtp smtpv6 (AF_INET6);
            return smtpv6;
        }
 
        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 Smtp& a, const Smtp& b) noexcept
    {
        return a.family () == b.family ();
    }
 
    constexpr bool operator!= (const Smtp& a, const Smtp& b) noexcept
    {
        return !(a == b);
    }
 
    class Smtps
    {
    public:
        using Endpoint = BasicInternetEndpoint<Smtps>;
        using Socket = BasicTlsSocket<Smtps>;
        using Stream = BasicTlsStream<Smtps>;
        using Client = BasicSmtpSecureClient<Smtps>;
 
        constexpr Smtps (int family = AF_INET) noexcept
        : _family (family)
        {
        }
 
        static inline Smtps& v4 () noexcept
        {
            static Smtps smtpsv4 (AF_INET);
            return smtpsv4;
        }
 
        static inline Smtps& v6 () noexcept
        {
            static Smtps smtpsv6 (AF_INET6);
            return smtpsv6;
        }
 
        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 Smtps& a, const Smtps& b) noexcept
    {
        return a.family () == b.family ();
    }
 
    constexpr bool operator!= (const Smtps& a, const Smtps& b) noexcept
    {
        return !(a == b);
    }
}
 
#endif