dtls_wrapper.hpp

Go to the documentation of this file.

 
#ifndef JOIN_CRYPTO_DTLS_WRAPPER_HPP
#define JOIN_CRYPTO_DTLS_WRAPPER_HPP
 
// libjoin.
#include <join/tls.hpp>
 
namespace join
{
    template <class Protocol>
    class BasicDtlsWrapper : public BasicTls<Protocol>
    {
    public:
        using Endpoint = typename BasicTls<Protocol>::Endpoint;
 
        using BasicTls<Protocol>::BasicTls;
 
        ssize_t readFrom (char* buf, size_t len, Endpoint* endpoint = nullptr) noexcept
        {
            if (this->_ssl)
            {
                int nread = SSL_read (this->_ssl.get (), buf, static_cast<int> (len));
                if (nread < 1)
                {
                    return this->handleTlsError (nread);
                }
 
                if (endpoint != nullptr)
                {
                    BIO* rbio = SSL_get_rbio (this->_ssl.get ());
                    if (!rbio)
                    {
                        lastError = make_error_code (Errc::OperationFailed);
                        return -1;
                    }
 
                    struct sockaddr_storage sa;
                    socklen_t sa_len = sizeof (struct sockaddr_storage);
                    if (BIO_dgram_get_peer (rbio, &sa) <= 0)
                    {
                        lastError = make_error_code (Errc::OperationFailed);
                        return -1;
                    }
 
                    *endpoint = Endpoint (reinterpret_cast<struct sockaddr*> (&sa), sa_len);
                }
 
                return nread;
            }
 
            return this->_socket.readFrom (buf, len, endpoint);
        }
 
        ssize_t writeTo (const char* buf, size_t len, const Endpoint& endpoint) noexcept
        {
            if (this->_ssl)
            {
                BIO* wbio = SSL_get_wbio (this->_ssl.get ());
                if (!wbio)
                {
                    lastError = make_error_code (Errc::OperationFailed);
                    return -1;
                }
 
                struct sockaddr_storage sa;
                socklen_t sa_len = sizeof (struct sockaddr_storage);
                if (BIO_dgram_get_peer (wbio, &sa) <= 0)
                {
                    lastError = make_error_code (Errc::OperationFailed);
                    return -1;
                }
 
                Endpoint remote (reinterpret_cast<struct sockaddr*> (&sa), sa_len);
                if (remote != endpoint)
                {
                    lastError = make_error_code (Errc::InvalidParam);
                    return -1;
                }
 
                int nwritten = SSL_write (this->_ssl.get (), buf, static_cast<int> (len));
                if (nwritten < 1)
                {
                    return this->handleTlsError (nwritten);
                }
 
                return nwritten;
            }
 
            return this->_socket.writeTo (buf, len, endpoint);
        }
 
        int ttl () const noexcept
        {
            return this->_socket.ttl ();
        }
    };
 
    template <class Protocol>
    inline bool operator< (const BasicDtlsWrapper<Protocol>& a, const BasicDtlsWrapper<Protocol>& b) noexcept
    {
        return a.handle () < b.handle ();
    }
}
 
#endif