tls_wrapper.hpp

Go to the documentation of this file.

 
#ifndef JOIN_CRYPTO_TLS_WRAPPER_HPP
#define JOIN_CRYPTO_TLS_WRAPPER_HPP
 
// libjoin.
#include <join/tls.hpp>
 
namespace join
{
    template <class Protocol>
    class BasicTlsWrapper : public BasicTls<Protocol>
    {
    public:
        using Endpoint = typename BasicTls<Protocol>::Endpoint;
        using TimePoint = typename BasicTls<Protocol>::TimePoint;
 
        using BasicTls<Protocol>::BasicTls;
 
        bool connecting () const noexcept
        {
            return this->_socket.connecting ();
        }
 
        bool waitConnected ()
        {
            return this->_socket.waitConnected ();
        }
 
        bool waitConnected (std::chrono::nanoseconds timeout)
        {
            return this->_socket.waitConnected (timeout);
        }
 
        bool waitConnected (TimePoint deadline)
        {
            return this->_socket.waitConnected (deadline);
        }
 
        bool waitDisconnected ()
        {
            return this->_socket.waitDisconnected ();
        }
 
        bool waitDisconnected (std::chrono::nanoseconds timeout)
        {
            return this->_socket.waitDisconnected (timeout);
        }
 
        bool waitDisconnected (TimePoint deadline)
        {
            return this->_socket.waitDisconnected (deadline);
        }
 
        using BasicTls<Protocol>::waitHandshake;
 
        bool waitHandshake (TimePoint deadline) override
        {
            if (!this->_socket.waitConnected (deadline))
            {
                return false;
            }
 
            return BasicTls<Protocol>::waitHandshake (deadline);
        }
 
        int canRead () const noexcept
        {
            if (this->_ssl)
            {
                return SSL_pending (this->_ssl.get ());
            }
 
            return this->_socket.canRead ();
        }
    };
 
    template <class Protocol>
    inline bool operator< (const BasicTlsWrapper<Protocol>& a, const BasicTlsWrapper<Protocol>& b) noexcept
    {
        return a.handle () < b.handle ();
    }
}
 
#endif