protocol.hpp

Go to the documentation of this file.

 
#ifndef __JOIN_PROTOCOL_HPP__
#define __JOIN_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 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 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