datagram_socket.hpp

Go to the documentation of this file.

 
#ifndef JOIN_CORE_DATAGRAM_SOCKET_HPP
#define JOIN_CORE_DATAGRAM_SOCKET_HPP
 
// libjoin.
#include <join/raw_socket.hpp>
 
// C.
#include <cstring>
 
namespace join
{
    template <class Protocol>
    class BasicDatagramSocket final : public BasicRawSocket<Protocol>
    {
    public:
        using Ptr = std::unique_ptr<BasicDatagramSocket<Protocol>>;
        using Mode = typename BasicRawSocket<Protocol>::Mode;
        using Option = typename BasicRawSocket<Protocol>::Option;
        using State = typename BasicRawSocket<Protocol>::State;
        using Endpoint = typename Protocol::Endpoint;
 
        BasicDatagramSocket () noexcept
        : BasicDatagramSocket (Mode::NonBlocking)
        {
        }
 
        explicit BasicDatagramSocket (int ttl) noexcept
        : BasicDatagramSocket (Mode::NonBlocking, ttl)
        {
        }
 
        explicit BasicDatagramSocket (Mode mode, int ttl = 60) noexcept
        : BasicRawSocket<Protocol> (mode)
        , _ttl (ttl)
        {
        }
 
        BasicDatagramSocket (const BasicDatagramSocket& other) = delete;
 
        BasicDatagramSocket& operator= (const BasicDatagramSocket& other) = delete;
 
        BasicDatagramSocket (BasicDatagramSocket&& other) noexcept
        : BasicRawSocket<Protocol> (std::move (other))
        , _remote (std::move (other._remote))
        , _ttl (other._ttl)
        {
            other._ttl = 60;
        }
 
        BasicDatagramSocket& operator= (BasicDatagramSocket&& other) noexcept
        {
            BasicRawSocket<Protocol>::operator= (std::move (other));
 
            _remote = std::move (other._remote);
            _ttl = other._ttl;
 
            other._ttl = 60;
 
            return *this;
        }
 
        ~BasicDatagramSocket () = default;
 
        int open (const Protocol& protocol = Protocol ()) noexcept override
        {
            int result = BasicRawSocket<Protocol>::open (protocol);
            if (result == -1)
            {
                return -1;
            }
 
            int off = 0;
 
            if ((protocol.protocol () == IPPROTO_UDP) || (protocol.protocol () == IPPROTO_TCP))
            {
                if ((protocol.family () == AF_INET6) &&
                    (::setsockopt (this->_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 ((protocol.protocol () == IPPROTO_ICMPV6) || (protocol.protocol () == IPPROTO_ICMP))
            {
                if ((protocol.family () == AF_INET) &&
                    (::setsockopt (this->_handle, IPPROTO_IP, IP_HDRINCL, &off, sizeof (off)) == -1))
                {
                    // LCOV_EXCL_START
                    lastError = std::error_code (errno, std::generic_category ());
                    close ();
                    return -1;
                    // LCOV_EXCL_STOP
                }
 
                this->setOption (Option::MulticastTtl, _ttl);
                this->setOption (Option::Ttl, _ttl);
            }
 
            return 0;
        }
 
        int connect (const Endpoint& endpoint) noexcept
        {
            if ((this->_state != State::Closed) && (this->_state != State::Disconnected))
            {
                lastError = make_error_code (Errc::InUse);
                return -1;
            }
 
            if ((this->_state == State::Closed) && (open (endpoint.protocol ()) == -1))
            {
                return -1;  // LCOV_EXCL_LINE
            }
 
            if (::connect (this->_handle, endpoint.addr (), endpoint.length ()) == -1)
            {
                lastError = std::error_code (errno, std::generic_category ());
                close ();
                return -1;
            }
 
            _remote = endpoint;
            this->_state = State::Connected;
 
            return 0;
        }
 
        int disconnect () noexcept
        {
            if (this->_state == State::Connected)
            {
                struct sockaddr_storage nullAddr;
                ::memset (&nullAddr, 0, sizeof (nullAddr));
 
                nullAddr.ss_family = AF_UNSPEC;
 
                int result = ::connect (this->_handle, reinterpret_cast<struct sockaddr*> (&nullAddr),
                                        sizeof (struct sockaddr_storage));
                if (result == -1)
                {
                    // LCOV_EXCL_START
                    if (errno != EAFNOSUPPORT)
                    {
                        lastError = std::error_code (errno, std::generic_category ());
                        return -1;
                    }
                    // LCOV_EXCL_STOP
                }
 
                this->_state = State::Disconnected;
                _remote = {};
            }
 
            return 0;
        }
 
        void close () noexcept override
        {
            BasicRawSocket<Protocol>::close ();
            _remote = {};
        }
 
        ssize_t readFrom (char* data, size_t maxSize, Endpoint* endpoint = nullptr) noexcept
        {
            struct sockaddr_storage sa;
 
            struct iovec iov;
            iov.iov_base = data;
            iov.iov_len = maxSize;
 
            struct msghdr message;
            message.msg_name = &sa;
            message.msg_namelen = sizeof (struct sockaddr_storage);
            message.msg_iov = &iov;
            message.msg_iovlen = 1;
            message.msg_control = nullptr;
            message.msg_controllen = 0;
 
            ssize_t size = ::recvmsg (this->_handle, &message, 0);
            if (size == -1)
            {
                lastError = std::error_code (errno, std::generic_category ());
                return -1;
            }
 
            if (message.msg_flags & MSG_TRUNC)
            {
                lastError = make_error_code (Errc::MessageTooLong);
                return -1;
            }
 
            if (endpoint != nullptr)
            {
                *endpoint = Endpoint (reinterpret_cast<struct sockaddr*> (&sa), message.msg_namelen);
            }
 
            return size;
        }
 
        ssize_t writeTo (const char* data, size_t maxSize, const Endpoint& endpoint) noexcept
        {
            if ((this->_state == State::Closed) && (open (endpoint.protocol ()) == -1))
            {
                return -1;  // LCOV_EXCL_LINE
            }
 
            ssize_t result = ::sendto (this->_handle, data, maxSize, 0, endpoint.addr (), endpoint.length ());
            if (result < 0)
            {
                lastError = std::error_code (errno, std::generic_category ());
                return -1;
            }
 
            return result;
        }
 
        const Endpoint& remoteEndpoint () const noexcept
        {
            return _remote;
        }
 
        bool connected () const noexcept
        {
            return (this->_state == State::Connected);
        }
 
        int mtu () const noexcept
        {
            if (this->_state == State::Closed)
            {
                lastError = make_error_code (Errc::OperationFailed);
                return -1;
            }
 
            int result = -1, value = -1;
            socklen_t valueLen = sizeof (value);
 
            if (this->family () == AF_INET6)
            {
                result = ::getsockopt (this->_handle, IPPROTO_IPV6, IPV6_MTU, &value, &valueLen);
            }
            else if (this->family () == AF_INET)
            {
                result = ::getsockopt (this->_handle, IPPROTO_IP, IP_MTU, &value, &valueLen);
            }
            else
            {
                lastError = make_error_code (Errc::OperationFailed);
                return -1;
            }
 
            if (result == -1)
            {
                lastError = std::error_code (errno, std::generic_category ());
                return -1;
            }
 
            return value;
        }
 
        int ttl () const noexcept
        {
            return _ttl;
        }
 
    protected:
        Endpoint _remote;
 
        int _ttl = 60;
    };
 
    template <class Protocol>
    inline bool operator< (const BasicDatagramSocket<Protocol>& a, const BasicDatagramSocket<Protocol>& b) noexcept
    {
        return a.handle () < b.handle ();
    }
}
 
#endif