tls_stream.hpp

Go to the documentation of this file.

 
#ifndef JOIN_CRYPTO_TLS_STREAM_HPP
#define JOIN_CRYPTO_TLS_STREAM_HPP
 
// libjoin.
#include <join/socket_stream.hpp>
#include <join/tls_wrapper.hpp>
 
// C++.
#include <chrono>
#include <utility>
 
namespace join
{
    template <class Protocol>
    class BasicTlsStream : public BasicSocketStream<Protocol>
    {
    public:
        using Endpoint = typename Protocol::Endpoint;
        using Socket = typename Protocol::Socket;
        using Transport = typename Protocol::Transport::Socket;
        using Mode = typename Socket::Mode;
 
        BasicTlsStream ()
        : BasicTlsStream (TlsContext{})
        {
        }
 
        explicit BasicTlsStream (TlsContext ctx, Mode mode = Mode::NonBlocking)
        : BasicSocketStream<Protocol> (Socket{std::move (ctx), mode})
        {
        }
 
        explicit BasicTlsStream (Socket&& socket)
        : BasicSocketStream<Protocol> (std::move (socket))
        {
        }
 
        explicit BasicTlsStream (Transport&& socket, TlsContext ctx = TlsContext{})
        : BasicSocketStream<Protocol> (Socket{std::move (socket), std::move (ctx)})
        {
        }
 
        BasicTlsStream (const BasicTlsStream& other) = delete;
 
        BasicTlsStream& operator= (const BasicTlsStream& other) = delete;
 
        BasicTlsStream (BasicTlsStream&& other)
        : BasicSocketStream<Protocol> (std::move (other))
        {
        }
 
        BasicTlsStream& operator= (BasicTlsStream&& other)
        {
            BasicSocketStream<Protocol>::operator= (std::move (other));
 
            return *this;
        }
 
        virtual ~BasicTlsStream () = default;
 
        void handshake ()
        {
            if (this->_sockbuf.socket ().handshake () == -1)
            {
                if (lastError == Errc::TemporaryError)
                {
                    if (this->_sockbuf.socket ().waitHandshake (this->_sockbuf.deadline ()))
                    {
                        return;
                    }
                }
 
                this->setstate (std::ios_base::failbit);
            }
        }
 
        void shutdown ()
        {
            if (this->_sockbuf.socket ().shutdown () == -1)
            {
                if (lastError == Errc::TemporaryError)
                {
                    if (this->_sockbuf.socket ().waitShutdown (this->_sockbuf.deadline ()))
                    {
                        return;
                    }
                }
 
                this->setstate (std::ios_base::failbit);
            }
        }
 
        bool encrypted ()
        {
            return this->_sockbuf.socket ().encrypted ();
        }
    };
}
 
#endif