socket.hpp

Go to the documentation of this file.

 
#ifndef JOIN_CORE_SOCKET_HPP
#define JOIN_CORE_SOCKET_HPP
 
// libjoin.
#include <join/protocol.hpp>
#include <join/endpoint.hpp>
#include <join/utils.hpp>
#include <join/error.hpp>
 
// C++.
#include <algorithm>
#include <chrono>
#include <memory>
#include <string>
 
// C.
#include <linux/icmp.h>
#include <fcntl.h>
#include <poll.h>
 
namespace join
{
    template <class Protocol>
    class BasicSocket
    {
        template <class P, class E, size_t N>
        friend class BasicAsyncRawSocket;
 
    public:
        using Ptr = std::unique_ptr<BasicSocket<Protocol>>;
        using Endpoint = typename Protocol::Endpoint;
        using TimePoint = std::chrono::steady_clock::time_point;
 
        enum Mode
        {
            Blocking,    
            NonBlocking, 
        };
 
        enum State
        {
            Connecting,    
            Connected,     
            Disconnecting, 
            Disconnected,  
            Closed,        
        };
 
        BasicSocket () noexcept
        : BasicSocket (Mode::NonBlocking)
        {
        }
 
        explicit BasicSocket (Mode mode) noexcept
        : _mode (mode)
        {
        }
 
        BasicSocket (const BasicSocket& other) = delete;
 
        BasicSocket& operator= (const BasicSocket& other) = delete;
 
        BasicSocket (BasicSocket&& other) noexcept
        : _state (other._state)
        , _mode (other._mode)
        , _handle (other._handle)
        , _protocol (other._protocol)
        {
            other._state = State::Closed;
            other._mode = Mode::NonBlocking;
            other._handle = -1;
            other._protocol = Protocol ();
        }
 
        BasicSocket& operator= (BasicSocket&& other) noexcept
        {
            close ();
 
            _state = other._state;
            _mode = other._mode;
            _handle = other._handle;
            _protocol = other._protocol;
 
            other._state = State::Closed;
            other._mode = Mode::NonBlocking;
            other._handle = -1;
            other._protocol = Protocol ();
 
            return *this;
        }
 
        virtual ~BasicSocket ()
        {
            if (_handle != -1)
            {
                ::close (_handle);
            }
        }
 
        virtual int open (const Protocol& protocol = Protocol ()) noexcept
        {
            if (_state != State::Closed)
            {
                lastError = make_error_code (Errc::InUse);
                return -1;
            }
 
            if (_mode == Mode::NonBlocking)
            {
                _handle = ::socket (protocol.family (), protocol.type () | SOCK_NONBLOCK, protocol.protocol ());
            }
            else
            {
                _handle = ::socket (protocol.family (), protocol.type (), protocol.protocol ());
            }
 
            if (_handle == -1)
            {
                // LCOV_EXCL_START
                lastError = std::error_code (errno, std::generic_category ());
                close ();
                return -1;
                // LCOV_EXCL_STOP
            }
 
            _state = State::Disconnected;
            _protocol = protocol;
 
            return 0;
        }
 
        virtual void close () noexcept
        {
            if (_state != State::Closed)
            {
                ::close (_handle);
                _state = State::Closed;
                _handle = -1;
            }
        }
 
        virtual int bind (const Endpoint& endpoint) noexcept
        {
            if ((_state == State::Closed) && (open (endpoint.protocol ()) == -1))
            {
                return -1;  // LCOV_EXCL_LINE
            }
 
            if (::bind (_handle, endpoint.addr (), endpoint.length ()) == -1)
            {
                lastError = std::error_code (errno, std::generic_category ());
                return -1;
            }
 
            return 0;
        }
 
        bool waitReadyRead () const noexcept
        {
            return (waitUntil (true, false, TimePoint::max ()) == 0);
        }
 
        bool waitReadyRead (std::chrono::nanoseconds timeout) const noexcept
        {
            return (waitUntil (true, false, std::chrono::steady_clock::now () + timeout) == 0);
        }
 
        bool waitReadyRead (TimePoint deadline) const noexcept
        {
            return (waitUntil (true, false, deadline) == 0);
        }
 
        bool waitReadyWrite () const noexcept
        {
            return (waitUntil (false, true, TimePoint::max ()) == 0);
        }
 
        bool waitReadyWrite (std::chrono::nanoseconds timeout) const noexcept
        {
            return (waitUntil (false, true, std::chrono::steady_clock::now () + timeout) == 0);
        }
 
        bool waitReadyWrite (TimePoint deadline) const noexcept
        {
            return (waitUntil (false, true, deadline) == 0);
        }
 
        void setMode (Mode mode) noexcept
        {
            _mode = mode;
 
            if (_state != State::Closed)
            {
                int flags = ::fcntl (_handle, F_GETFL, 0);
 
                if (_mode == Mode::NonBlocking)
                {
                    flags = flags | O_NONBLOCK;
                }
                else
                {
                    flags = flags & ~O_NONBLOCK;
                }
 
                ::fcntl (_handle, F_SETFL, flags);
            }
        }
 
        Endpoint localEndpoint () const noexcept
        {
            struct sockaddr_storage sa;
            socklen_t sa_len = sizeof (struct sockaddr_storage);
 
            if (::getsockname (_handle, reinterpret_cast<struct sockaddr*> (&sa), &sa_len) == -1)
            {
                return {};
            }
 
            return Endpoint (reinterpret_cast<struct sockaddr*> (&sa), sa_len);
        }
 
        bool opened () const noexcept
        {
            return (_state != State::Closed);
        }
 
        int family () const noexcept
        {
            return _protocol.family ();
        }
 
        int type () const noexcept
        {
            return _protocol.type ();
        }
 
        int protocol () const noexcept
        {
            return _protocol.protocol ();
        }
 
        Mode mode () const noexcept
        {
            return _mode;
        }
 
        int handle () const noexcept
        {
            return _handle;
        }
 
        int wait (bool wantRead, bool wantWrite) const noexcept
        {
            return waitUntil (wantRead, wantWrite, TimePoint::max ());
        }
 
        int waitFor (bool wantRead, bool wantWrite, std::chrono::nanoseconds timeout) const noexcept
        {
            return waitUntil (wantRead, wantWrite, std::chrono::steady_clock::now () + timeout);
        }
 
        int waitUntil (bool wantRead, bool wantWrite, TimePoint deadline) const noexcept
        {
            struct pollfd handle;
            handle.fd = _handle;
            handle.events = 0;
            handle.revents = 0;
 
            if (wantRead)
            {
                handle.events |= POLLIN;
            }
 
            if (wantWrite)
            {
                handle.events |= POLLOUT;
            }
 
            struct timespec ts = {};
            const struct timespec* remaining = nullptr;
 
            if (deadline != TimePoint::max ())
            {
                ts = toTimespec (std::max (deadline - std::chrono::steady_clock::now (), TimePoint::duration::zero ()));
                remaining = &ts;
            }
 
            int nset = (handle.fd > -1) ? ::ppoll (&handle, 1, remaining, nullptr) : -1;
            if (nset != 1)
            {
                if (nset == -1)
                {
                    if (handle.fd == -1)
                    {
                        errno = EBADF;
                    }
                    lastError = std::error_code (errno, std::generic_category ());
                }
                else
                {
                    lastError = make_error_code (Errc::TimedOut);
                }
 
                return -1;
            }
 
            return 0;
        }
 
    protected:
        State _state = State::Closed;
 
        Mode _mode = Mode::NonBlocking;
 
        int _handle = -1;
 
        Protocol _protocol;
    };
 
    template <class Protocol>
    inline bool operator< (const BasicSocket<Protocol>& a, const BasicSocket<Protocol>& b) noexcept
    {
        return a.handle () < b.handle ();
    }
}
 
#endif