ssl.h

Go to the documentation of this file.

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
#ifndef PACKIO_EXTRA_SSL_H
#define PACKIO_EXTRA_SSL_H
 
 
#include "../internal/config.h"
#include "../internal/utils.h"
 
#if PACKIO_STANDALONE_ASIO
#include <asio/ssl.hpp>
#else // PACKIO_STANDALONE_ASIO
#include <boost/asio/ssl.hpp>
#endif // PACKIO_STANDALONE_ASIO
 
namespace packio {
namespace extra {
 
template <typename SslStream>
class ssl_stream_adapter : public SslStream {
public:
    using protocol_type = typename SslStream::lowest_layer_type::protocol_type;
 
    using SslStream::SslStream;
 
    bool is_open() const { return this->lowest_layer().is_open(); }
 
    template <typename... Args>
    auto close(Args&&... args)
    {
        return this->lowest_layer().close(std::forward<Args>(args)...);
    }
 
    template <typename... Args>
    auto cancel(Args&&...)
    {
        static_assert(
            internal::always_false_v<Args...>,
            "websockets do not support cancel operations");
    }
};
 
template <typename Acceptor, typename SslStreamAdapter>
class ssl_acceptor_adapter : public Acceptor {
public:
    template <typename Arg>
    explicit ssl_acceptor_adapter(Arg&& arg, packio::net::ssl::context& context)
        : Acceptor(std::forward<Arg>(arg)), context_(context)
    {
    }
 
    SslStreamAdapter accept();
 
    template <typename Handler>
    void async_accept(Handler&& handler)
    {
        Acceptor::async_accept([this, handler = std::forward<Handler>(handler)](
                                   auto ec, auto sock) mutable {
            if (ec) {
                handler(ec, SslStreamAdapter(std::move(sock), context_));
                return;
            }
            auto stream = std::make_unique<SslStreamAdapter>(
                std::move(sock), context_);
            stream->async_handshake(
                packio::net::ssl::stream_base::server,
                [handler = std::forward<Handler>(handler),
                 stream = std::move(stream)](auto ec) mutable {
                    handler(ec, std::move(*stream));
                });
        });
    }
 
private:
    packio::net::ssl::context& context_;
};
 
} // extra
} // packio
 
#endif // PACKIO_EXTRA_SSL_H