acceptor.hpp

Go to the documentation of this file.

 
#ifndef JOIN_CORE_ACCEPTOR_HPP
#define JOIN_CORE_ACCEPTOR_HPP
 
// libjoin.
#include <join/socket_stream.hpp>
 
namespace join
{
    template <class Protocol>
    class BasicStreamAcceptor
    {
    public:
        using Endpoint = typename Protocol::Endpoint;
        using Socket = typename Protocol::Socket;
        using Stream = typename Protocol::Stream;
 
        BasicStreamAcceptor () = default;
 
        BasicStreamAcceptor (const BasicStreamAcceptor& other) = delete;
 
        BasicStreamAcceptor& operator= (const BasicStreamAcceptor& other) = delete;
 
        BasicStreamAcceptor (BasicStreamAcceptor&& other)
        : _handle (other._handle)
        , _protocol (other._protocol)
        {
            other._handle = -1;
            other._protocol = Protocol ();
        }
 
        BasicStreamAcceptor& operator= (BasicStreamAcceptor&& other)
        {
            close ();
 
            _handle = other._handle;
            _protocol = other._protocol;
 
            other._handle = -1;
            other._protocol = Protocol ();
 
            return *this;
        }
 
        ~BasicStreamAcceptor ()
        {
            close ();
        }
 
        int create (const Endpoint& endpoint, int flags = SOCK_CLOEXEC) noexcept
        {
            if (opened ())
            {
                lastError = make_error_code (Errc::InUse);
                return -1;
            }
 
            _handle = ::socket (endpoint.protocol ().family (), endpoint.protocol ().type () | flags,
                                endpoint.protocol ().protocol ());
            if (_handle == -1)
            {
                // LCOV_EXCL_START
                lastError = std::error_code (errno, std::generic_category ());
                close ();
                return -1;
                // LCOV_EXCL_STOP
            }
 
            if (endpoint.protocol ().family () == AF_INET6)
            {
                int off = 0;
 
                if (::setsockopt (_handle, IPPROTO_IPV6, IPV6_V6ONLY, &off, sizeof (off)) == -1)
                {
                    // LCOV_EXCL_START
                    lastError = std::error_code (errno, std::generic_category ());
                    close ();
                    return -1;
                    // LCOV_EXCL_STOP
                }
            }
 
            if (endpoint.protocol ().family () == AF_UNIX)
            {
                ::unlink (endpoint.device ().c_str ());
            }
            else if (endpoint.protocol ().protocol () == IPPROTO_TCP)
            {
                int on = 1;
 
                if (::setsockopt (_handle, SOL_SOCKET, SO_REUSEADDR, &on, sizeof (on)) == -1)
                {
                    // LCOV_EXCL_START
                    lastError = std::error_code (errno, std::generic_category ());
                    close ();
                    return -1;
                    // LCOV_EXCL_STOP
                }
            }
 
            if ((::bind (_handle, endpoint.addr (), endpoint.length ()) == -1) || (::listen (_handle, SOMAXCONN) == -1))
            {
                lastError = std::error_code (errno, std::generic_category ());
                close ();
                return -1;
            }
 
            _protocol = endpoint.protocol ();
 
            return 0;
        }
 
        void close () noexcept
        {
            if (_handle != -1)
            {
                ::close (_handle);
                _handle = -1;
            }
 
            _protocol = Protocol ();
        }
 
        Socket accept (int flags = SOCK_NONBLOCK | SOCK_CLOEXEC) const
        {
            struct sockaddr_storage sa;
            socklen_t sa_len = sizeof (struct sockaddr_storage);
 
            int fd = ::accept4 (_handle, reinterpret_cast<struct sockaddr*> (&sa), &sa_len, flags);
            if (fd == -1)
            {
                lastError = std::error_code (errno, std::generic_category ());
                return {};
            }
 
            return Socket (fd, Endpoint (reinterpret_cast<struct sockaddr*> (&sa), sa_len),
                           (flags & SOCK_NONBLOCK) ? Socket::NonBlocking : Socket::Blocking);
        }
 
        Stream acceptStream () const
        {
            Stream stream;
            stream.socket () = accept ();
            return stream;
        }
 
        Endpoint localEndpoint () const
        {
            struct sockaddr_storage sa;
            socklen_t sa_len = sizeof (struct sockaddr_storage);
 
            if (::getsockname (_handle, reinterpret_cast<struct sockaddr*> (&sa), &sa_len) == -1)
            {
                lastError = std::error_code (errno, std::generic_category ());
                return {};
            }
 
            return Endpoint (reinterpret_cast<struct sockaddr*> (&sa), sa_len);
        }
 
        bool opened () const noexcept
        {
            return (_handle != -1);
        }
 
        int family () const noexcept
        {
            return _protocol.family ();
        }
 
        int type () const noexcept
        {
            return _protocol.type ();
        }
 
        int protocol () const noexcept
        {
            return _protocol.protocol ();
        }
 
        int handle () const noexcept
        {
            return _handle;
        }
 
    private:
        int _handle = -1;
 
        Protocol _protocol;
    };
}
 
#endif