mirror of
https://github.com/VCMP-SqMod/SqMod.git
synced 2025-07-05 08:27:10 +02:00
Initial preparations for CURL and Discord integration.
This commit is contained in:
119
module/Vendor/ASIO/include/asio/ssl/detail/buffered_handshake_op.hpp
vendored
Normal file
119
module/Vendor/ASIO/include/asio/ssl/detail/buffered_handshake_op.hpp
vendored
Normal file
@ -0,0 +1,119 @@
|
||||
//
|
||||
// ssl/detail/buffered_handshake_op.hpp
|
||||
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
//
|
||||
// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#ifndef ASIO_SSL_DETAIL_BUFFERED_HANDSHAKE_OP_HPP
|
||||
#define ASIO_SSL_DETAIL_BUFFERED_HANDSHAKE_OP_HPP
|
||||
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||
# pragma once
|
||||
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||
|
||||
#include "asio/detail/config.hpp"
|
||||
|
||||
#include "asio/ssl/detail/engine.hpp"
|
||||
|
||||
#include "asio/detail/push_options.hpp"
|
||||
|
||||
namespace asio {
|
||||
namespace ssl {
|
||||
namespace detail {
|
||||
|
||||
template <typename ConstBufferSequence>
|
||||
class buffered_handshake_op
|
||||
{
|
||||
public:
|
||||
static ASIO_CONSTEXPR const char* tracking_name()
|
||||
{
|
||||
return "ssl::stream<>::async_buffered_handshake";
|
||||
}
|
||||
|
||||
buffered_handshake_op(stream_base::handshake_type type,
|
||||
const ConstBufferSequence& buffers)
|
||||
: type_(type),
|
||||
buffers_(buffers),
|
||||
total_buffer_size_(asio::buffer_size(buffers_))
|
||||
{
|
||||
}
|
||||
|
||||
engine::want operator()(engine& eng,
|
||||
asio::error_code& ec,
|
||||
std::size_t& bytes_transferred) const
|
||||
{
|
||||
return this->process(eng, ec, bytes_transferred,
|
||||
asio::buffer_sequence_begin(buffers_),
|
||||
asio::buffer_sequence_end(buffers_));
|
||||
}
|
||||
|
||||
template <typename Handler>
|
||||
void call_handler(Handler& handler,
|
||||
const asio::error_code& ec,
|
||||
const std::size_t& bytes_transferred) const
|
||||
{
|
||||
handler(ec, bytes_transferred);
|
||||
}
|
||||
|
||||
private:
|
||||
template <typename Iterator>
|
||||
engine::want process(engine& eng,
|
||||
asio::error_code& ec,
|
||||
std::size_t& bytes_transferred,
|
||||
Iterator begin, Iterator end) const
|
||||
{
|
||||
Iterator iter = begin;
|
||||
std::size_t accumulated_size = 0;
|
||||
|
||||
for (;;)
|
||||
{
|
||||
engine::want want = eng.handshake(type_, ec);
|
||||
if (want != engine::want_input_and_retry
|
||||
|| bytes_transferred == total_buffer_size_)
|
||||
return want;
|
||||
|
||||
// Find the next buffer piece to be fed to the engine.
|
||||
while (iter != end)
|
||||
{
|
||||
const_buffer buffer(*iter);
|
||||
|
||||
// Skip over any buffers which have already been consumed by the engine.
|
||||
if (bytes_transferred >= accumulated_size + buffer.size())
|
||||
{
|
||||
accumulated_size += buffer.size();
|
||||
++iter;
|
||||
continue;
|
||||
}
|
||||
|
||||
// The current buffer may have been partially consumed by the engine on
|
||||
// a previous iteration. If so, adjust the buffer to point to the
|
||||
// unused portion.
|
||||
if (bytes_transferred > accumulated_size)
|
||||
buffer = buffer + (bytes_transferred - accumulated_size);
|
||||
|
||||
// Pass the buffer to the engine, and update the bytes transferred to
|
||||
// reflect the total number of bytes consumed so far.
|
||||
bytes_transferred += buffer.size();
|
||||
buffer = eng.put_input(buffer);
|
||||
bytes_transferred -= buffer.size();
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
stream_base::handshake_type type_;
|
||||
ConstBufferSequence buffers_;
|
||||
std::size_t total_buffer_size_;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace ssl
|
||||
} // namespace asio
|
||||
|
||||
#include "asio/detail/pop_options.hpp"
|
||||
|
||||
#endif // ASIO_SSL_DETAIL_BUFFERED_HANDSHAKE_OP_HPP
|
165
module/Vendor/ASIO/include/asio/ssl/detail/engine.hpp
vendored
Normal file
165
module/Vendor/ASIO/include/asio/ssl/detail/engine.hpp
vendored
Normal file
@ -0,0 +1,165 @@
|
||||
//
|
||||
// ssl/detail/engine.hpp
|
||||
// ~~~~~~~~~~~~~~~~~~~~~
|
||||
//
|
||||
// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#ifndef ASIO_SSL_DETAIL_ENGINE_HPP
|
||||
#define ASIO_SSL_DETAIL_ENGINE_HPP
|
||||
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||
# pragma once
|
||||
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||
|
||||
#include "asio/detail/config.hpp"
|
||||
|
||||
#include "asio/buffer.hpp"
|
||||
#include "asio/detail/static_mutex.hpp"
|
||||
#include "asio/ssl/detail/openssl_types.hpp"
|
||||
#include "asio/ssl/detail/verify_callback.hpp"
|
||||
#include "asio/ssl/stream_base.hpp"
|
||||
#include "asio/ssl/verify_mode.hpp"
|
||||
|
||||
#include "asio/detail/push_options.hpp"
|
||||
|
||||
namespace asio {
|
||||
namespace ssl {
|
||||
namespace detail {
|
||||
|
||||
class engine
|
||||
{
|
||||
public:
|
||||
enum want
|
||||
{
|
||||
// Returned by functions to indicate that the engine wants input. The input
|
||||
// buffer should be updated to point to the data. The engine then needs to
|
||||
// be called again to retry the operation.
|
||||
want_input_and_retry = -2,
|
||||
|
||||
// Returned by functions to indicate that the engine wants to write output.
|
||||
// The output buffer points to the data to be written. The engine then
|
||||
// needs to be called again to retry the operation.
|
||||
want_output_and_retry = -1,
|
||||
|
||||
// Returned by functions to indicate that the engine doesn't need input or
|
||||
// output.
|
||||
want_nothing = 0,
|
||||
|
||||
// Returned by functions to indicate that the engine wants to write output.
|
||||
// The output buffer points to the data to be written. After that the
|
||||
// operation is complete, and the engine does not need to be called again.
|
||||
want_output = 1
|
||||
};
|
||||
|
||||
// Construct a new engine for the specified context.
|
||||
ASIO_DECL explicit engine(SSL_CTX* context);
|
||||
|
||||
#if defined(ASIO_HAS_MOVE)
|
||||
// Move construct from another engine.
|
||||
ASIO_DECL engine(engine&& other) ASIO_NOEXCEPT;
|
||||
#endif // defined(ASIO_HAS_MOVE)
|
||||
|
||||
// Destructor.
|
||||
ASIO_DECL ~engine();
|
||||
|
||||
// Get the underlying implementation in the native type.
|
||||
ASIO_DECL SSL* native_handle();
|
||||
|
||||
// Set the peer verification mode.
|
||||
ASIO_DECL asio::error_code set_verify_mode(
|
||||
verify_mode v, asio::error_code& ec);
|
||||
|
||||
// Set the peer verification depth.
|
||||
ASIO_DECL asio::error_code set_verify_depth(
|
||||
int depth, asio::error_code& ec);
|
||||
|
||||
// Set a peer certificate verification callback.
|
||||
ASIO_DECL asio::error_code set_verify_callback(
|
||||
verify_callback_base* callback, asio::error_code& ec);
|
||||
|
||||
// Perform an SSL handshake using either SSL_connect (client-side) or
|
||||
// SSL_accept (server-side).
|
||||
ASIO_DECL want handshake(
|
||||
stream_base::handshake_type type, asio::error_code& ec);
|
||||
|
||||
// Perform a graceful shutdown of the SSL session.
|
||||
ASIO_DECL want shutdown(asio::error_code& ec);
|
||||
|
||||
// Write bytes to the SSL session.
|
||||
ASIO_DECL want write(const asio::const_buffer& data,
|
||||
asio::error_code& ec, std::size_t& bytes_transferred);
|
||||
|
||||
// Read bytes from the SSL session.
|
||||
ASIO_DECL want read(const asio::mutable_buffer& data,
|
||||
asio::error_code& ec, std::size_t& bytes_transferred);
|
||||
|
||||
// Get output data to be written to the transport.
|
||||
ASIO_DECL asio::mutable_buffer get_output(
|
||||
const asio::mutable_buffer& data);
|
||||
|
||||
// Put input data that was read from the transport.
|
||||
ASIO_DECL asio::const_buffer put_input(
|
||||
const asio::const_buffer& data);
|
||||
|
||||
// Map an error::eof code returned by the underlying transport according to
|
||||
// the type and state of the SSL session. Returns a const reference to the
|
||||
// error code object, suitable for passing to a completion handler.
|
||||
ASIO_DECL const asio::error_code& map_error_code(
|
||||
asio::error_code& ec) const;
|
||||
|
||||
private:
|
||||
// Disallow copying and assignment.
|
||||
engine(const engine&);
|
||||
engine& operator=(const engine&);
|
||||
|
||||
// Callback used when the SSL implementation wants to verify a certificate.
|
||||
ASIO_DECL static int verify_callback_function(
|
||||
int preverified, X509_STORE_CTX* ctx);
|
||||
|
||||
#if (OPENSSL_VERSION_NUMBER < 0x10000000L)
|
||||
// The SSL_accept function may not be thread safe. This mutex is used to
|
||||
// protect all calls to the SSL_accept function.
|
||||
ASIO_DECL static asio::detail::static_mutex& accept_mutex();
|
||||
#endif // (OPENSSL_VERSION_NUMBER < 0x10000000L)
|
||||
|
||||
// Perform one operation. Returns >= 0 on success or error, want_read if the
|
||||
// operation needs more input, or want_write if it needs to write some output
|
||||
// before the operation can complete.
|
||||
ASIO_DECL want perform(int (engine::* op)(void*, std::size_t),
|
||||
void* data, std::size_t length, asio::error_code& ec,
|
||||
std::size_t* bytes_transferred);
|
||||
|
||||
// Adapt the SSL_accept function to the signature needed for perform().
|
||||
ASIO_DECL int do_accept(void*, std::size_t);
|
||||
|
||||
// Adapt the SSL_connect function to the signature needed for perform().
|
||||
ASIO_DECL int do_connect(void*, std::size_t);
|
||||
|
||||
// Adapt the SSL_shutdown function to the signature needed for perform().
|
||||
ASIO_DECL int do_shutdown(void*, std::size_t);
|
||||
|
||||
// Adapt the SSL_read function to the signature needed for perform().
|
||||
ASIO_DECL int do_read(void* data, std::size_t length);
|
||||
|
||||
// Adapt the SSL_write function to the signature needed for perform().
|
||||
ASIO_DECL int do_write(void* data, std::size_t length);
|
||||
|
||||
SSL* ssl_;
|
||||
BIO* ext_bio_;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace ssl
|
||||
} // namespace asio
|
||||
|
||||
#include "asio/detail/pop_options.hpp"
|
||||
|
||||
#if defined(ASIO_HEADER_ONLY)
|
||||
# include "asio/ssl/detail/impl/engine.ipp"
|
||||
#endif // defined(ASIO_HEADER_ONLY)
|
||||
|
||||
#endif // ASIO_SSL_DETAIL_ENGINE_HPP
|
67
module/Vendor/ASIO/include/asio/ssl/detail/handshake_op.hpp
vendored
Normal file
67
module/Vendor/ASIO/include/asio/ssl/detail/handshake_op.hpp
vendored
Normal file
@ -0,0 +1,67 @@
|
||||
//
|
||||
// ssl/detail/handshake_op.hpp
|
||||
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
//
|
||||
// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#ifndef ASIO_SSL_DETAIL_HANDSHAKE_OP_HPP
|
||||
#define ASIO_SSL_DETAIL_HANDSHAKE_OP_HPP
|
||||
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||
# pragma once
|
||||
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||
|
||||
#include "asio/detail/config.hpp"
|
||||
|
||||
#include "asio/ssl/detail/engine.hpp"
|
||||
|
||||
#include "asio/detail/push_options.hpp"
|
||||
|
||||
namespace asio {
|
||||
namespace ssl {
|
||||
namespace detail {
|
||||
|
||||
class handshake_op
|
||||
{
|
||||
public:
|
||||
static ASIO_CONSTEXPR const char* tracking_name()
|
||||
{
|
||||
return "ssl::stream<>::async_handshake";
|
||||
}
|
||||
|
||||
handshake_op(stream_base::handshake_type type)
|
||||
: type_(type)
|
||||
{
|
||||
}
|
||||
|
||||
engine::want operator()(engine& eng,
|
||||
asio::error_code& ec,
|
||||
std::size_t& bytes_transferred) const
|
||||
{
|
||||
bytes_transferred = 0;
|
||||
return eng.handshake(type_, ec);
|
||||
}
|
||||
|
||||
template <typename Handler>
|
||||
void call_handler(Handler& handler,
|
||||
const asio::error_code& ec,
|
||||
const std::size_t&) const
|
||||
{
|
||||
handler(ec);
|
||||
}
|
||||
|
||||
private:
|
||||
stream_base::handshake_type type_;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace ssl
|
||||
} // namespace asio
|
||||
|
||||
#include "asio/detail/pop_options.hpp"
|
||||
|
||||
#endif // ASIO_SSL_DETAIL_HANDSHAKE_OP_HPP
|
349
module/Vendor/ASIO/include/asio/ssl/detail/impl/engine.ipp
vendored
Normal file
349
module/Vendor/ASIO/include/asio/ssl/detail/impl/engine.ipp
vendored
Normal file
@ -0,0 +1,349 @@
|
||||
//
|
||||
// ssl/detail/impl/engine.ipp
|
||||
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
//
|
||||
// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#ifndef ASIO_SSL_DETAIL_IMPL_ENGINE_IPP
|
||||
#define ASIO_SSL_DETAIL_IMPL_ENGINE_IPP
|
||||
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||
# pragma once
|
||||
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||
|
||||
#include "asio/detail/config.hpp"
|
||||
|
||||
#include "asio/detail/throw_error.hpp"
|
||||
#include "asio/error.hpp"
|
||||
#include "asio/ssl/detail/engine.hpp"
|
||||
#include "asio/ssl/error.hpp"
|
||||
#include "asio/ssl/verify_context.hpp"
|
||||
|
||||
#include "asio/detail/push_options.hpp"
|
||||
|
||||
namespace asio {
|
||||
namespace ssl {
|
||||
namespace detail {
|
||||
|
||||
engine::engine(SSL_CTX* context)
|
||||
: ssl_(::SSL_new(context))
|
||||
{
|
||||
if (!ssl_)
|
||||
{
|
||||
asio::error_code ec(
|
||||
static_cast<int>(::ERR_get_error()),
|
||||
asio::error::get_ssl_category());
|
||||
asio::detail::throw_error(ec, "engine");
|
||||
}
|
||||
|
||||
#if (OPENSSL_VERSION_NUMBER < 0x10000000L)
|
||||
accept_mutex().init();
|
||||
#endif // (OPENSSL_VERSION_NUMBER < 0x10000000L)
|
||||
|
||||
::SSL_set_mode(ssl_, SSL_MODE_ENABLE_PARTIAL_WRITE);
|
||||
::SSL_set_mode(ssl_, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
|
||||
#if defined(SSL_MODE_RELEASE_BUFFERS)
|
||||
::SSL_set_mode(ssl_, SSL_MODE_RELEASE_BUFFERS);
|
||||
#endif // defined(SSL_MODE_RELEASE_BUFFERS)
|
||||
|
||||
::BIO* int_bio = 0;
|
||||
::BIO_new_bio_pair(&int_bio, 0, &ext_bio_, 0);
|
||||
::SSL_set_bio(ssl_, int_bio, int_bio);
|
||||
}
|
||||
|
||||
#if defined(ASIO_HAS_MOVE)
|
||||
engine::engine(engine&& other) ASIO_NOEXCEPT
|
||||
: ssl_(other.ssl_),
|
||||
ext_bio_(other.ext_bio_)
|
||||
{
|
||||
other.ssl_ = 0;
|
||||
other.ext_bio_ = 0;
|
||||
}
|
||||
#endif // defined(ASIO_HAS_MOVE)
|
||||
|
||||
engine::~engine()
|
||||
{
|
||||
if (ssl_ && SSL_get_app_data(ssl_))
|
||||
{
|
||||
delete static_cast<verify_callback_base*>(SSL_get_app_data(ssl_));
|
||||
SSL_set_app_data(ssl_, 0);
|
||||
}
|
||||
|
||||
if (ext_bio_)
|
||||
::BIO_free(ext_bio_);
|
||||
|
||||
if (ssl_)
|
||||
::SSL_free(ssl_);
|
||||
}
|
||||
|
||||
SSL* engine::native_handle()
|
||||
{
|
||||
return ssl_;
|
||||
}
|
||||
|
||||
asio::error_code engine::set_verify_mode(
|
||||
verify_mode v, asio::error_code& ec)
|
||||
{
|
||||
::SSL_set_verify(ssl_, v, ::SSL_get_verify_callback(ssl_));
|
||||
|
||||
ec = asio::error_code();
|
||||
return ec;
|
||||
}
|
||||
|
||||
asio::error_code engine::set_verify_depth(
|
||||
int depth, asio::error_code& ec)
|
||||
{
|
||||
::SSL_set_verify_depth(ssl_, depth);
|
||||
|
||||
ec = asio::error_code();
|
||||
return ec;
|
||||
}
|
||||
|
||||
asio::error_code engine::set_verify_callback(
|
||||
verify_callback_base* callback, asio::error_code& ec)
|
||||
{
|
||||
if (SSL_get_app_data(ssl_))
|
||||
delete static_cast<verify_callback_base*>(SSL_get_app_data(ssl_));
|
||||
|
||||
SSL_set_app_data(ssl_, callback);
|
||||
|
||||
::SSL_set_verify(ssl_, ::SSL_get_verify_mode(ssl_),
|
||||
&engine::verify_callback_function);
|
||||
|
||||
ec = asio::error_code();
|
||||
return ec;
|
||||
}
|
||||
|
||||
int engine::verify_callback_function(int preverified, X509_STORE_CTX* ctx)
|
||||
{
|
||||
if (ctx)
|
||||
{
|
||||
if (SSL* ssl = static_cast<SSL*>(
|
||||
::X509_STORE_CTX_get_ex_data(
|
||||
ctx, ::SSL_get_ex_data_X509_STORE_CTX_idx())))
|
||||
{
|
||||
if (SSL_get_app_data(ssl))
|
||||
{
|
||||
verify_callback_base* callback =
|
||||
static_cast<verify_callback_base*>(
|
||||
SSL_get_app_data(ssl));
|
||||
|
||||
verify_context verify_ctx(ctx);
|
||||
return callback->call(preverified != 0, verify_ctx) ? 1 : 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
engine::want engine::handshake(
|
||||
stream_base::handshake_type type, asio::error_code& ec)
|
||||
{
|
||||
return perform((type == asio::ssl::stream_base::client)
|
||||
? &engine::do_connect : &engine::do_accept, 0, 0, ec, 0);
|
||||
}
|
||||
|
||||
engine::want engine::shutdown(asio::error_code& ec)
|
||||
{
|
||||
return perform(&engine::do_shutdown, 0, 0, ec, 0);
|
||||
}
|
||||
|
||||
engine::want engine::write(const asio::const_buffer& data,
|
||||
asio::error_code& ec, std::size_t& bytes_transferred)
|
||||
{
|
||||
if (data.size() == 0)
|
||||
{
|
||||
ec = asio::error_code();
|
||||
return engine::want_nothing;
|
||||
}
|
||||
|
||||
return perform(&engine::do_write,
|
||||
const_cast<void*>(data.data()),
|
||||
data.size(), ec, &bytes_transferred);
|
||||
}
|
||||
|
||||
engine::want engine::read(const asio::mutable_buffer& data,
|
||||
asio::error_code& ec, std::size_t& bytes_transferred)
|
||||
{
|
||||
if (data.size() == 0)
|
||||
{
|
||||
ec = asio::error_code();
|
||||
return engine::want_nothing;
|
||||
}
|
||||
|
||||
return perform(&engine::do_read, data.data(),
|
||||
data.size(), ec, &bytes_transferred);
|
||||
}
|
||||
|
||||
asio::mutable_buffer engine::get_output(
|
||||
const asio::mutable_buffer& data)
|
||||
{
|
||||
int length = ::BIO_read(ext_bio_,
|
||||
data.data(), static_cast<int>(data.size()));
|
||||
|
||||
return asio::buffer(data,
|
||||
length > 0 ? static_cast<std::size_t>(length) : 0);
|
||||
}
|
||||
|
||||
asio::const_buffer engine::put_input(
|
||||
const asio::const_buffer& data)
|
||||
{
|
||||
int length = ::BIO_write(ext_bio_,
|
||||
data.data(), static_cast<int>(data.size()));
|
||||
|
||||
return asio::buffer(data +
|
||||
(length > 0 ? static_cast<std::size_t>(length) : 0));
|
||||
}
|
||||
|
||||
const asio::error_code& engine::map_error_code(
|
||||
asio::error_code& ec) const
|
||||
{
|
||||
// We only want to map the error::eof code.
|
||||
if (ec != asio::error::eof)
|
||||
return ec;
|
||||
|
||||
// If there's data yet to be read, it's an error.
|
||||
if (BIO_wpending(ext_bio_))
|
||||
{
|
||||
ec = asio::ssl::error::stream_truncated;
|
||||
return ec;
|
||||
}
|
||||
|
||||
// SSL v2 doesn't provide a protocol-level shutdown, so an eof on the
|
||||
// underlying transport is passed through.
|
||||
#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
|
||||
if (SSL_version(ssl_) == SSL2_VERSION)
|
||||
return ec;
|
||||
#endif // (OPENSSL_VERSION_NUMBER < 0x10100000L)
|
||||
|
||||
// Otherwise, the peer should have negotiated a proper shutdown.
|
||||
if ((::SSL_get_shutdown(ssl_) & SSL_RECEIVED_SHUTDOWN) == 0)
|
||||
{
|
||||
ec = asio::ssl::error::stream_truncated;
|
||||
}
|
||||
|
||||
return ec;
|
||||
}
|
||||
|
||||
#if (OPENSSL_VERSION_NUMBER < 0x10000000L)
|
||||
asio::detail::static_mutex& engine::accept_mutex()
|
||||
{
|
||||
static asio::detail::static_mutex mutex = ASIO_STATIC_MUTEX_INIT;
|
||||
return mutex;
|
||||
}
|
||||
#endif // (OPENSSL_VERSION_NUMBER < 0x10000000L)
|
||||
|
||||
engine::want engine::perform(int (engine::* op)(void*, std::size_t),
|
||||
void* data, std::size_t length, asio::error_code& ec,
|
||||
std::size_t* bytes_transferred)
|
||||
{
|
||||
std::size_t pending_output_before = ::BIO_ctrl_pending(ext_bio_);
|
||||
::ERR_clear_error();
|
||||
int result = (this->*op)(data, length);
|
||||
int ssl_error = ::SSL_get_error(ssl_, result);
|
||||
int sys_error = static_cast<int>(::ERR_get_error());
|
||||
std::size_t pending_output_after = ::BIO_ctrl_pending(ext_bio_);
|
||||
|
||||
if (ssl_error == SSL_ERROR_SSL)
|
||||
{
|
||||
ec = asio::error_code(sys_error,
|
||||
asio::error::get_ssl_category());
|
||||
return pending_output_after > pending_output_before
|
||||
? want_output : want_nothing;
|
||||
}
|
||||
|
||||
if (ssl_error == SSL_ERROR_SYSCALL)
|
||||
{
|
||||
if (sys_error == 0)
|
||||
{
|
||||
ec = asio::ssl::error::unspecified_system_error;
|
||||
}
|
||||
else
|
||||
{
|
||||
ec = asio::error_code(sys_error,
|
||||
asio::error::get_ssl_category());
|
||||
}
|
||||
return pending_output_after > pending_output_before
|
||||
? want_output : want_nothing;
|
||||
}
|
||||
|
||||
if (result > 0 && bytes_transferred)
|
||||
*bytes_transferred = static_cast<std::size_t>(result);
|
||||
|
||||
if (ssl_error == SSL_ERROR_WANT_WRITE)
|
||||
{
|
||||
ec = asio::error_code();
|
||||
return want_output_and_retry;
|
||||
}
|
||||
else if (pending_output_after > pending_output_before)
|
||||
{
|
||||
ec = asio::error_code();
|
||||
return result > 0 ? want_output : want_output_and_retry;
|
||||
}
|
||||
else if (ssl_error == SSL_ERROR_WANT_READ)
|
||||
{
|
||||
ec = asio::error_code();
|
||||
return want_input_and_retry;
|
||||
}
|
||||
else if (ssl_error == SSL_ERROR_ZERO_RETURN)
|
||||
{
|
||||
ec = asio::error::eof;
|
||||
return want_nothing;
|
||||
}
|
||||
else if (ssl_error == SSL_ERROR_NONE)
|
||||
{
|
||||
ec = asio::error_code();
|
||||
return want_nothing;
|
||||
}
|
||||
else
|
||||
{
|
||||
ec = asio::ssl::error::unexpected_result;
|
||||
return want_nothing;
|
||||
}
|
||||
}
|
||||
|
||||
int engine::do_accept(void*, std::size_t)
|
||||
{
|
||||
#if (OPENSSL_VERSION_NUMBER < 0x10000000L)
|
||||
asio::detail::static_mutex::scoped_lock lock(accept_mutex());
|
||||
#endif // (OPENSSL_VERSION_NUMBER < 0x10000000L)
|
||||
return ::SSL_accept(ssl_);
|
||||
}
|
||||
|
||||
int engine::do_connect(void*, std::size_t)
|
||||
{
|
||||
return ::SSL_connect(ssl_);
|
||||
}
|
||||
|
||||
int engine::do_shutdown(void*, std::size_t)
|
||||
{
|
||||
int result = ::SSL_shutdown(ssl_);
|
||||
if (result == 0)
|
||||
result = ::SSL_shutdown(ssl_);
|
||||
return result;
|
||||
}
|
||||
|
||||
int engine::do_read(void* data, std::size_t length)
|
||||
{
|
||||
return ::SSL_read(ssl_, data,
|
||||
length < INT_MAX ? static_cast<int>(length) : INT_MAX);
|
||||
}
|
||||
|
||||
int engine::do_write(void* data, std::size_t length)
|
||||
{
|
||||
return ::SSL_write(ssl_, data,
|
||||
length < INT_MAX ? static_cast<int>(length) : INT_MAX);
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
} // namespace ssl
|
||||
} // namespace asio
|
||||
|
||||
#include "asio/detail/pop_options.hpp"
|
||||
|
||||
#endif // ASIO_SSL_DETAIL_IMPL_ENGINE_IPP
|
165
module/Vendor/ASIO/include/asio/ssl/detail/impl/openssl_init.ipp
vendored
Normal file
165
module/Vendor/ASIO/include/asio/ssl/detail/impl/openssl_init.ipp
vendored
Normal file
@ -0,0 +1,165 @@
|
||||
//
|
||||
// ssl/detail/impl/openssl_init.ipp
|
||||
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
//
|
||||
// Copyright (c) 2005 Voipster / Indrek dot Juhani at voipster dot com
|
||||
// Copyright (c) 2005-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#ifndef ASIO_SSL_DETAIL_IMPL_OPENSSL_INIT_IPP
|
||||
#define ASIO_SSL_DETAIL_IMPL_OPENSSL_INIT_IPP
|
||||
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||
# pragma once
|
||||
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||
|
||||
#include "asio/detail/config.hpp"
|
||||
#include <vector>
|
||||
#include "asio/detail/assert.hpp"
|
||||
#include "asio/detail/mutex.hpp"
|
||||
#include "asio/detail/tss_ptr.hpp"
|
||||
#include "asio/ssl/detail/openssl_init.hpp"
|
||||
#include "asio/ssl/detail/openssl_types.hpp"
|
||||
|
||||
#include "asio/detail/push_options.hpp"
|
||||
|
||||
namespace asio {
|
||||
namespace ssl {
|
||||
namespace detail {
|
||||
|
||||
class openssl_init_base::do_init
|
||||
{
|
||||
public:
|
||||
do_init()
|
||||
{
|
||||
#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
|
||||
::SSL_library_init();
|
||||
::SSL_load_error_strings();
|
||||
::OpenSSL_add_all_algorithms();
|
||||
|
||||
mutexes_.resize(::CRYPTO_num_locks());
|
||||
for (size_t i = 0; i < mutexes_.size(); ++i)
|
||||
mutexes_[i].reset(new asio::detail::mutex);
|
||||
::CRYPTO_set_locking_callback(&do_init::openssl_locking_func);
|
||||
#endif // (OPENSSL_VERSION_NUMBER < 0x10100000L)
|
||||
#if (OPENSSL_VERSION_NUMBER < 0x10000000L)
|
||||
::CRYPTO_set_id_callback(&do_init::openssl_id_func);
|
||||
#endif // (OPENSSL_VERSION_NUMBER < 0x10000000L)
|
||||
|
||||
#if !defined(SSL_OP_NO_COMPRESSION) \
|
||||
&& (OPENSSL_VERSION_NUMBER >= 0x00908000L)
|
||||
null_compression_methods_ = sk_SSL_COMP_new_null();
|
||||
#endif // !defined(SSL_OP_NO_COMPRESSION)
|
||||
// && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
|
||||
}
|
||||
|
||||
~do_init()
|
||||
{
|
||||
#if !defined(SSL_OP_NO_COMPRESSION) \
|
||||
&& (OPENSSL_VERSION_NUMBER >= 0x00908000L)
|
||||
sk_SSL_COMP_free(null_compression_methods_);
|
||||
#endif // !defined(SSL_OP_NO_COMPRESSION)
|
||||
// && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
|
||||
|
||||
#if (OPENSSL_VERSION_NUMBER < 0x10000000L)
|
||||
::CRYPTO_set_id_callback(0);
|
||||
#endif // (OPENSSL_VERSION_NUMBER < 0x10000000L)
|
||||
#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
|
||||
::CRYPTO_set_locking_callback(0);
|
||||
::ERR_free_strings();
|
||||
::EVP_cleanup();
|
||||
::CRYPTO_cleanup_all_ex_data();
|
||||
#endif // (OPENSSL_VERSION_NUMBER < 0x10100000L)
|
||||
#if (OPENSSL_VERSION_NUMBER < 0x10000000L)
|
||||
::ERR_remove_state(0);
|
||||
#elif (OPENSSL_VERSION_NUMBER < 0x10100000L)
|
||||
::ERR_remove_thread_state(NULL);
|
||||
#endif // (OPENSSL_VERSION_NUMBER < 0x10000000L)
|
||||
#if (OPENSSL_VERSION_NUMBER >= 0x10002000L) \
|
||||
&& (OPENSSL_VERSION_NUMBER < 0x10100000L) \
|
||||
&& !defined(SSL_OP_NO_COMPRESSION)
|
||||
::SSL_COMP_free_compression_methods();
|
||||
#endif // (OPENSSL_VERSION_NUMBER >= 0x10002000L)
|
||||
// && (OPENSSL_VERSION_NUMBER < 0x10100000L)
|
||||
// && !defined(SSL_OP_NO_COMPRESSION)
|
||||
#if !defined(OPENSSL_IS_BORINGSSL) && !defined(ASIO_USE_WOLFSSL)
|
||||
::CONF_modules_unload(1);
|
||||
#endif // !defined(OPENSSL_IS_BORINGSSL) && !defined(ASIO_USE_WOLFSSL)
|
||||
#if !defined(OPENSSL_NO_ENGINE) \
|
||||
&& (OPENSSL_VERSION_NUMBER < 0x10100000L)
|
||||
::ENGINE_cleanup();
|
||||
#endif // !defined(OPENSSL_NO_ENGINE)
|
||||
// && (OPENSSL_VERSION_NUMBER < 0x10100000L)
|
||||
}
|
||||
|
||||
#if !defined(SSL_OP_NO_COMPRESSION) \
|
||||
&& (OPENSSL_VERSION_NUMBER >= 0x00908000L)
|
||||
STACK_OF(SSL_COMP)* get_null_compression_methods() const
|
||||
{
|
||||
return null_compression_methods_;
|
||||
}
|
||||
#endif // !defined(SSL_OP_NO_COMPRESSION)
|
||||
// && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
|
||||
|
||||
private:
|
||||
#if (OPENSSL_VERSION_NUMBER < 0x10000000L)
|
||||
static unsigned long openssl_id_func()
|
||||
{
|
||||
#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
|
||||
return ::GetCurrentThreadId();
|
||||
#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
|
||||
void* id = &errno;
|
||||
ASIO_ASSERT(sizeof(unsigned long) >= sizeof(void*));
|
||||
return reinterpret_cast<unsigned long>(id);
|
||||
#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
|
||||
}
|
||||
#endif // (OPENSSL_VERSION_NUMBER < 0x10000000L)
|
||||
|
||||
#if (OPENSSL_VERSION_NUMBER < 0x10100000L)
|
||||
static void openssl_locking_func(int mode, int n,
|
||||
const char* /*file*/, int /*line*/)
|
||||
{
|
||||
if (mode & CRYPTO_LOCK)
|
||||
instance()->mutexes_[n]->lock();
|
||||
else
|
||||
instance()->mutexes_[n]->unlock();
|
||||
}
|
||||
|
||||
// Mutexes to be used in locking callbacks.
|
||||
std::vector<asio::detail::shared_ptr<
|
||||
asio::detail::mutex> > mutexes_;
|
||||
#endif // (OPENSSL_VERSION_NUMBER < 0x10100000L)
|
||||
|
||||
#if !defined(SSL_OP_NO_COMPRESSION) \
|
||||
&& (OPENSSL_VERSION_NUMBER >= 0x00908000L)
|
||||
STACK_OF(SSL_COMP)* null_compression_methods_;
|
||||
#endif // !defined(SSL_OP_NO_COMPRESSION)
|
||||
// && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
|
||||
};
|
||||
|
||||
asio::detail::shared_ptr<openssl_init_base::do_init>
|
||||
openssl_init_base::instance()
|
||||
{
|
||||
static asio::detail::shared_ptr<do_init> init(new do_init);
|
||||
return init;
|
||||
}
|
||||
|
||||
#if !defined(SSL_OP_NO_COMPRESSION) \
|
||||
&& (OPENSSL_VERSION_NUMBER >= 0x00908000L)
|
||||
STACK_OF(SSL_COMP)* openssl_init_base::get_null_compression_methods()
|
||||
{
|
||||
return instance()->get_null_compression_methods();
|
||||
}
|
||||
#endif // !defined(SSL_OP_NO_COMPRESSION)
|
||||
// && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
|
||||
|
||||
} // namespace detail
|
||||
} // namespace ssl
|
||||
} // namespace asio
|
||||
|
||||
#include "asio/detail/pop_options.hpp"
|
||||
|
||||
#endif // ASIO_SSL_DETAIL_IMPL_OPENSSL_INIT_IPP
|
416
module/Vendor/ASIO/include/asio/ssl/detail/io.hpp
vendored
Normal file
416
module/Vendor/ASIO/include/asio/ssl/detail/io.hpp
vendored
Normal file
@ -0,0 +1,416 @@
|
||||
//
|
||||
// ssl/detail/io.hpp
|
||||
// ~~~~~~~~~~~~~~~~~
|
||||
//
|
||||
// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#ifndef ASIO_SSL_DETAIL_IO_HPP
|
||||
#define ASIO_SSL_DETAIL_IO_HPP
|
||||
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||
# pragma once
|
||||
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||
|
||||
#include "asio/detail/config.hpp"
|
||||
|
||||
#include "asio/detail/handler_tracking.hpp"
|
||||
#include "asio/ssl/detail/engine.hpp"
|
||||
#include "asio/ssl/detail/stream_core.hpp"
|
||||
#include "asio/write.hpp"
|
||||
|
||||
#include "asio/detail/push_options.hpp"
|
||||
|
||||
namespace asio {
|
||||
namespace ssl {
|
||||
namespace detail {
|
||||
|
||||
template <typename Stream, typename Operation>
|
||||
std::size_t io(Stream& next_layer, stream_core& core,
|
||||
const Operation& op, asio::error_code& ec)
|
||||
{
|
||||
asio::error_code io_ec;
|
||||
std::size_t bytes_transferred = 0;
|
||||
do switch (op(core.engine_, ec, bytes_transferred))
|
||||
{
|
||||
case engine::want_input_and_retry:
|
||||
|
||||
// If the input buffer is empty then we need to read some more data from
|
||||
// the underlying transport.
|
||||
if (core.input_.size() == 0)
|
||||
{
|
||||
core.input_ = asio::buffer(core.input_buffer_,
|
||||
next_layer.read_some(core.input_buffer_, io_ec));
|
||||
if (!ec)
|
||||
ec = io_ec;
|
||||
}
|
||||
|
||||
// Pass the new input data to the engine.
|
||||
core.input_ = core.engine_.put_input(core.input_);
|
||||
|
||||
// Try the operation again.
|
||||
continue;
|
||||
|
||||
case engine::want_output_and_retry:
|
||||
|
||||
// Get output data from the engine and write it to the underlying
|
||||
// transport.
|
||||
asio::write(next_layer,
|
||||
core.engine_.get_output(core.output_buffer_), io_ec);
|
||||
if (!ec)
|
||||
ec = io_ec;
|
||||
|
||||
// Try the operation again.
|
||||
continue;
|
||||
|
||||
case engine::want_output:
|
||||
|
||||
// Get output data from the engine and write it to the underlying
|
||||
// transport.
|
||||
asio::write(next_layer,
|
||||
core.engine_.get_output(core.output_buffer_), io_ec);
|
||||
if (!ec)
|
||||
ec = io_ec;
|
||||
|
||||
// Operation is complete. Return result to caller.
|
||||
core.engine_.map_error_code(ec);
|
||||
return bytes_transferred;
|
||||
|
||||
default:
|
||||
|
||||
// Operation is complete. Return result to caller.
|
||||
core.engine_.map_error_code(ec);
|
||||
return bytes_transferred;
|
||||
|
||||
} while (!ec);
|
||||
|
||||
// Operation failed. Return result to caller.
|
||||
core.engine_.map_error_code(ec);
|
||||
return 0;
|
||||
}
|
||||
|
||||
template <typename Stream, typename Operation, typename Handler>
|
||||
class io_op
|
||||
{
|
||||
public:
|
||||
io_op(Stream& next_layer, stream_core& core,
|
||||
const Operation& op, Handler& handler)
|
||||
: next_layer_(next_layer),
|
||||
core_(core),
|
||||
op_(op),
|
||||
start_(0),
|
||||
want_(engine::want_nothing),
|
||||
bytes_transferred_(0),
|
||||
handler_(ASIO_MOVE_CAST(Handler)(handler))
|
||||
{
|
||||
}
|
||||
|
||||
#if defined(ASIO_HAS_MOVE)
|
||||
io_op(const io_op& other)
|
||||
: next_layer_(other.next_layer_),
|
||||
core_(other.core_),
|
||||
op_(other.op_),
|
||||
start_(other.start_),
|
||||
want_(other.want_),
|
||||
ec_(other.ec_),
|
||||
bytes_transferred_(other.bytes_transferred_),
|
||||
handler_(other.handler_)
|
||||
{
|
||||
}
|
||||
|
||||
io_op(io_op&& other)
|
||||
: next_layer_(other.next_layer_),
|
||||
core_(other.core_),
|
||||
op_(ASIO_MOVE_CAST(Operation)(other.op_)),
|
||||
start_(other.start_),
|
||||
want_(other.want_),
|
||||
ec_(other.ec_),
|
||||
bytes_transferred_(other.bytes_transferred_),
|
||||
handler_(ASIO_MOVE_CAST(Handler)(other.handler_))
|
||||
{
|
||||
}
|
||||
#endif // defined(ASIO_HAS_MOVE)
|
||||
|
||||
void operator()(asio::error_code ec,
|
||||
std::size_t bytes_transferred = ~std::size_t(0), int start = 0)
|
||||
{
|
||||
switch (start_ = start)
|
||||
{
|
||||
case 1: // Called after at least one async operation.
|
||||
do
|
||||
{
|
||||
switch (want_ = op_(core_.engine_, ec_, bytes_transferred_))
|
||||
{
|
||||
case engine::want_input_and_retry:
|
||||
|
||||
// If the input buffer already has data in it we can pass it to the
|
||||
// engine and then retry the operation immediately.
|
||||
if (core_.input_.size() != 0)
|
||||
{
|
||||
core_.input_ = core_.engine_.put_input(core_.input_);
|
||||
continue;
|
||||
}
|
||||
|
||||
// The engine wants more data to be read from input. However, we
|
||||
// cannot allow more than one read operation at a time on the
|
||||
// underlying transport. The pending_read_ timer's expiry is set to
|
||||
// pos_infin if a read is in progress, and neg_infin otherwise.
|
||||
if (core_.expiry(core_.pending_read_) == core_.neg_infin())
|
||||
{
|
||||
// Prevent other read operations from being started.
|
||||
core_.pending_read_.expires_at(core_.pos_infin());
|
||||
|
||||
ASIO_HANDLER_LOCATION((
|
||||
__FILE__, __LINE__, Operation::tracking_name()));
|
||||
|
||||
// Start reading some data from the underlying transport.
|
||||
next_layer_.async_read_some(
|
||||
asio::buffer(core_.input_buffer_),
|
||||
ASIO_MOVE_CAST(io_op)(*this));
|
||||
}
|
||||
else
|
||||
{
|
||||
ASIO_HANDLER_LOCATION((
|
||||
__FILE__, __LINE__, Operation::tracking_name()));
|
||||
|
||||
// Wait until the current read operation completes.
|
||||
core_.pending_read_.async_wait(ASIO_MOVE_CAST(io_op)(*this));
|
||||
}
|
||||
|
||||
// Yield control until asynchronous operation completes. Control
|
||||
// resumes at the "default:" label below.
|
||||
return;
|
||||
|
||||
case engine::want_output_and_retry:
|
||||
case engine::want_output:
|
||||
|
||||
// The engine wants some data to be written to the output. However, we
|
||||
// cannot allow more than one write operation at a time on the
|
||||
// underlying transport. The pending_write_ timer's expiry is set to
|
||||
// pos_infin if a write is in progress, and neg_infin otherwise.
|
||||
if (core_.expiry(core_.pending_write_) == core_.neg_infin())
|
||||
{
|
||||
// Prevent other write operations from being started.
|
||||
core_.pending_write_.expires_at(core_.pos_infin());
|
||||
|
||||
ASIO_HANDLER_LOCATION((
|
||||
__FILE__, __LINE__, Operation::tracking_name()));
|
||||
|
||||
// Start writing all the data to the underlying transport.
|
||||
asio::async_write(next_layer_,
|
||||
core_.engine_.get_output(core_.output_buffer_),
|
||||
ASIO_MOVE_CAST(io_op)(*this));
|
||||
}
|
||||
else
|
||||
{
|
||||
ASIO_HANDLER_LOCATION((
|
||||
__FILE__, __LINE__, Operation::tracking_name()));
|
||||
|
||||
// Wait until the current write operation completes.
|
||||
core_.pending_write_.async_wait(ASIO_MOVE_CAST(io_op)(*this));
|
||||
}
|
||||
|
||||
// Yield control until asynchronous operation completes. Control
|
||||
// resumes at the "default:" label below.
|
||||
return;
|
||||
|
||||
default:
|
||||
|
||||
// The SSL operation is done and we can invoke the handler, but we
|
||||
// have to keep in mind that this function might be being called from
|
||||
// the async operation's initiating function. In this case we're not
|
||||
// allowed to call the handler directly. Instead, issue a zero-sized
|
||||
// read so the handler runs "as-if" posted using io_context::post().
|
||||
if (start)
|
||||
{
|
||||
ASIO_HANDLER_LOCATION((
|
||||
__FILE__, __LINE__, Operation::tracking_name()));
|
||||
|
||||
next_layer_.async_read_some(
|
||||
asio::buffer(core_.input_buffer_, 0),
|
||||
ASIO_MOVE_CAST(io_op)(*this));
|
||||
|
||||
// Yield control until asynchronous operation completes. Control
|
||||
// resumes at the "default:" label below.
|
||||
return;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Continue on to run handler directly.
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
default:
|
||||
if (bytes_transferred == ~std::size_t(0))
|
||||
bytes_transferred = 0; // Timer cancellation, no data transferred.
|
||||
else if (!ec_)
|
||||
ec_ = ec;
|
||||
|
||||
switch (want_)
|
||||
{
|
||||
case engine::want_input_and_retry:
|
||||
|
||||
// Add received data to the engine's input.
|
||||
core_.input_ = asio::buffer(
|
||||
core_.input_buffer_, bytes_transferred);
|
||||
core_.input_ = core_.engine_.put_input(core_.input_);
|
||||
|
||||
// Release any waiting read operations.
|
||||
core_.pending_read_.expires_at(core_.neg_infin());
|
||||
|
||||
// Try the operation again.
|
||||
continue;
|
||||
|
||||
case engine::want_output_and_retry:
|
||||
|
||||
// Release any waiting write operations.
|
||||
core_.pending_write_.expires_at(core_.neg_infin());
|
||||
|
||||
// Try the operation again.
|
||||
continue;
|
||||
|
||||
case engine::want_output:
|
||||
|
||||
// Release any waiting write operations.
|
||||
core_.pending_write_.expires_at(core_.neg_infin());
|
||||
|
||||
// Fall through to call handler.
|
||||
|
||||
default:
|
||||
|
||||
// Pass the result to the handler.
|
||||
op_.call_handler(handler_,
|
||||
core_.engine_.map_error_code(ec_),
|
||||
ec_ ? 0 : bytes_transferred_);
|
||||
|
||||
// Our work here is done.
|
||||
return;
|
||||
}
|
||||
} while (!ec_);
|
||||
|
||||
// Operation failed. Pass the result to the handler.
|
||||
op_.call_handler(handler_, core_.engine_.map_error_code(ec_), 0);
|
||||
}
|
||||
}
|
||||
|
||||
//private:
|
||||
Stream& next_layer_;
|
||||
stream_core& core_;
|
||||
Operation op_;
|
||||
int start_;
|
||||
engine::want want_;
|
||||
asio::error_code ec_;
|
||||
std::size_t bytes_transferred_;
|
||||
Handler handler_;
|
||||
};
|
||||
|
||||
template <typename Stream, typename Operation, typename Handler>
|
||||
inline asio_handler_allocate_is_deprecated
|
||||
asio_handler_allocate(std::size_t size,
|
||||
io_op<Stream, Operation, Handler>* this_handler)
|
||||
{
|
||||
#if defined(ASIO_NO_DEPRECATED)
|
||||
asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
|
||||
return asio_handler_allocate_is_no_longer_used();
|
||||
#else // defined(ASIO_NO_DEPRECATED)
|
||||
return asio_handler_alloc_helpers::allocate(
|
||||
size, this_handler->handler_);
|
||||
#endif // defined(ASIO_NO_DEPRECATED)
|
||||
}
|
||||
|
||||
template <typename Stream, typename Operation, typename Handler>
|
||||
inline asio_handler_deallocate_is_deprecated
|
||||
asio_handler_deallocate(void* pointer, std::size_t size,
|
||||
io_op<Stream, Operation, Handler>* this_handler)
|
||||
{
|
||||
asio_handler_alloc_helpers::deallocate(
|
||||
pointer, size, this_handler->handler_);
|
||||
#if defined(ASIO_NO_DEPRECATED)
|
||||
return asio_handler_deallocate_is_no_longer_used();
|
||||
#endif // defined(ASIO_NO_DEPRECATED)
|
||||
}
|
||||
|
||||
template <typename Stream, typename Operation, typename Handler>
|
||||
inline bool asio_handler_is_continuation(
|
||||
io_op<Stream, Operation, Handler>* this_handler)
|
||||
{
|
||||
return this_handler->start_ == 0 ? true
|
||||
: asio_handler_cont_helpers::is_continuation(this_handler->handler_);
|
||||
}
|
||||
|
||||
template <typename Function, typename Stream,
|
||||
typename Operation, typename Handler>
|
||||
inline asio_handler_invoke_is_deprecated
|
||||
asio_handler_invoke(Function& function,
|
||||
io_op<Stream, Operation, Handler>* this_handler)
|
||||
{
|
||||
asio_handler_invoke_helpers::invoke(
|
||||
function, this_handler->handler_);
|
||||
#if defined(ASIO_NO_DEPRECATED)
|
||||
return asio_handler_invoke_is_no_longer_used();
|
||||
#endif // defined(ASIO_NO_DEPRECATED)
|
||||
}
|
||||
|
||||
template <typename Function, typename Stream,
|
||||
typename Operation, typename Handler>
|
||||
inline asio_handler_invoke_is_deprecated
|
||||
asio_handler_invoke(const Function& function,
|
||||
io_op<Stream, Operation, Handler>* this_handler)
|
||||
{
|
||||
asio_handler_invoke_helpers::invoke(
|
||||
function, this_handler->handler_);
|
||||
#if defined(ASIO_NO_DEPRECATED)
|
||||
return asio_handler_invoke_is_no_longer_used();
|
||||
#endif // defined(ASIO_NO_DEPRECATED)
|
||||
}
|
||||
|
||||
template <typename Stream, typename Operation, typename Handler>
|
||||
inline void async_io(Stream& next_layer, stream_core& core,
|
||||
const Operation& op, Handler& handler)
|
||||
{
|
||||
io_op<Stream, Operation, Handler>(
|
||||
next_layer, core, op, handler)(
|
||||
asio::error_code(), 0, 1);
|
||||
}
|
||||
|
||||
} // namespace detail
|
||||
} // namespace ssl
|
||||
|
||||
template <typename Stream, typename Operation,
|
||||
typename Handler, typename Allocator>
|
||||
struct associated_allocator<
|
||||
ssl::detail::io_op<Stream, Operation, Handler>, Allocator>
|
||||
{
|
||||
typedef typename associated_allocator<Handler, Allocator>::type type;
|
||||
|
||||
static type get(const ssl::detail::io_op<Stream, Operation, Handler>& h,
|
||||
const Allocator& a = Allocator()) ASIO_NOEXCEPT
|
||||
{
|
||||
return associated_allocator<Handler, Allocator>::get(h.handler_, a);
|
||||
}
|
||||
};
|
||||
|
||||
template <typename Stream, typename Operation,
|
||||
typename Handler, typename Executor>
|
||||
struct associated_executor<
|
||||
ssl::detail::io_op<Stream, Operation, Handler>, Executor>
|
||||
: detail::associated_executor_forwarding_base<Handler, Executor>
|
||||
{
|
||||
typedef typename associated_executor<Handler, Executor>::type type;
|
||||
|
||||
static type get(const ssl::detail::io_op<Stream, Operation, Handler>& h,
|
||||
const Executor& ex = Executor()) ASIO_NOEXCEPT
|
||||
{
|
||||
return associated_executor<Handler, Executor>::get(h.handler_, ex);
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace asio
|
||||
|
||||
#include "asio/detail/pop_options.hpp"
|
||||
|
||||
#endif // ASIO_SSL_DETAIL_IO_HPP
|
101
module/Vendor/ASIO/include/asio/ssl/detail/openssl_init.hpp
vendored
Normal file
101
module/Vendor/ASIO/include/asio/ssl/detail/openssl_init.hpp
vendored
Normal file
@ -0,0 +1,101 @@
|
||||
//
|
||||
// ssl/detail/openssl_init.hpp
|
||||
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
//
|
||||
// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#ifndef ASIO_SSL_DETAIL_OPENSSL_INIT_HPP
|
||||
#define ASIO_SSL_DETAIL_OPENSSL_INIT_HPP
|
||||
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||
# pragma once
|
||||
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||
|
||||
#include "asio/detail/config.hpp"
|
||||
#include <cstring>
|
||||
#include "asio/detail/memory.hpp"
|
||||
#include "asio/detail/noncopyable.hpp"
|
||||
#include "asio/ssl/detail/openssl_types.hpp"
|
||||
|
||||
#include "asio/detail/push_options.hpp"
|
||||
|
||||
namespace asio {
|
||||
namespace ssl {
|
||||
namespace detail {
|
||||
|
||||
class openssl_init_base
|
||||
: private noncopyable
|
||||
{
|
||||
protected:
|
||||
// Class that performs the actual initialisation.
|
||||
class do_init;
|
||||
|
||||
// Helper function to manage a do_init singleton. The static instance of the
|
||||
// openssl_init object ensures that this function is always called before
|
||||
// main, and therefore before any other threads can get started. The do_init
|
||||
// instance must be static in this function to ensure that it gets
|
||||
// initialised before any other global objects try to use it.
|
||||
ASIO_DECL static asio::detail::shared_ptr<do_init> instance();
|
||||
|
||||
#if !defined(SSL_OP_NO_COMPRESSION) \
|
||||
&& (OPENSSL_VERSION_NUMBER >= 0x00908000L)
|
||||
// Get an empty stack of compression methods, to be used when disabling
|
||||
// compression.
|
||||
ASIO_DECL static STACK_OF(SSL_COMP)* get_null_compression_methods();
|
||||
#endif // !defined(SSL_OP_NO_COMPRESSION)
|
||||
// && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
|
||||
};
|
||||
|
||||
template <bool Do_Init = true>
|
||||
class openssl_init : private openssl_init_base
|
||||
{
|
||||
public:
|
||||
// Constructor.
|
||||
openssl_init()
|
||||
: ref_(instance())
|
||||
{
|
||||
using namespace std; // For memmove.
|
||||
|
||||
// Ensure openssl_init::instance_ is linked in.
|
||||
openssl_init* tmp = &instance_;
|
||||
memmove(&tmp, &tmp, sizeof(openssl_init*));
|
||||
}
|
||||
|
||||
// Destructor.
|
||||
~openssl_init()
|
||||
{
|
||||
}
|
||||
|
||||
#if !defined(SSL_OP_NO_COMPRESSION) \
|
||||
&& (OPENSSL_VERSION_NUMBER >= 0x00908000L)
|
||||
using openssl_init_base::get_null_compression_methods;
|
||||
#endif // !defined(SSL_OP_NO_COMPRESSION)
|
||||
// && (OPENSSL_VERSION_NUMBER >= 0x00908000L)
|
||||
|
||||
private:
|
||||
// Instance to force initialisation of openssl at global scope.
|
||||
static openssl_init instance_;
|
||||
|
||||
// Reference to singleton do_init object to ensure that openssl does not get
|
||||
// cleaned up until the last user has finished with it.
|
||||
asio::detail::shared_ptr<do_init> ref_;
|
||||
};
|
||||
|
||||
template <bool Do_Init>
|
||||
openssl_init<Do_Init> openssl_init<Do_Init>::instance_;
|
||||
|
||||
} // namespace detail
|
||||
} // namespace ssl
|
||||
} // namespace asio
|
||||
|
||||
#include "asio/detail/pop_options.hpp"
|
||||
|
||||
#if defined(ASIO_HEADER_ONLY)
|
||||
# include "asio/ssl/detail/impl/openssl_init.ipp"
|
||||
#endif // defined(ASIO_HEADER_ONLY)
|
||||
|
||||
#endif // ASIO_SSL_DETAIL_OPENSSL_INIT_HPP
|
34
module/Vendor/ASIO/include/asio/ssl/detail/openssl_types.hpp
vendored
Normal file
34
module/Vendor/ASIO/include/asio/ssl/detail/openssl_types.hpp
vendored
Normal file
@ -0,0 +1,34 @@
|
||||
//
|
||||
// ssl/detail/openssl_types.hpp
|
||||
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
//
|
||||
// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#ifndef ASIO_SSL_DETAIL_OPENSSL_TYPES_HPP
|
||||
#define ASIO_SSL_DETAIL_OPENSSL_TYPES_HPP
|
||||
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||
# pragma once
|
||||
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||
|
||||
#include "asio/detail/config.hpp"
|
||||
#include "asio/detail/socket_types.hpp"
|
||||
#if defined(ASIO_USE_WOLFSSL)
|
||||
# include <wolfssl/options.h>
|
||||
#endif // defined(ASIO_USE_WOLFSSL)
|
||||
#include <openssl/conf.h>
|
||||
#include <openssl/ssl.h>
|
||||
#if !defined(OPENSSL_NO_ENGINE)
|
||||
# include <openssl/engine.h>
|
||||
#endif // !defined(OPENSSL_NO_ENGINE)
|
||||
#include <openssl/dh.h>
|
||||
#include <openssl/err.h>
|
||||
#include <openssl/rsa.h>
|
||||
#include <openssl/x509.h>
|
||||
#include <openssl/x509v3.h>
|
||||
|
||||
#endif // ASIO_SSL_DETAIL_OPENSSL_TYPES_HPP
|
66
module/Vendor/ASIO/include/asio/ssl/detail/password_callback.hpp
vendored
Normal file
66
module/Vendor/ASIO/include/asio/ssl/detail/password_callback.hpp
vendored
Normal file
@ -0,0 +1,66 @@
|
||||
//
|
||||
// ssl/detail/password_callback.hpp
|
||||
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
//
|
||||
// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#ifndef ASIO_SSL_DETAIL_PASSWORD_CALLBACK_HPP
|
||||
#define ASIO_SSL_DETAIL_PASSWORD_CALLBACK_HPP
|
||||
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||
# pragma once
|
||||
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||
|
||||
#include "asio/detail/config.hpp"
|
||||
|
||||
#include <cstddef>
|
||||
#include <string>
|
||||
#include "asio/ssl/context_base.hpp"
|
||||
|
||||
#include "asio/detail/push_options.hpp"
|
||||
|
||||
namespace asio {
|
||||
namespace ssl {
|
||||
namespace detail {
|
||||
|
||||
class password_callback_base
|
||||
{
|
||||
public:
|
||||
virtual ~password_callback_base()
|
||||
{
|
||||
}
|
||||
|
||||
virtual std::string call(std::size_t size,
|
||||
context_base::password_purpose purpose) = 0;
|
||||
};
|
||||
|
||||
template <typename PasswordCallback>
|
||||
class password_callback : public password_callback_base
|
||||
{
|
||||
public:
|
||||
explicit password_callback(PasswordCallback callback)
|
||||
: callback_(callback)
|
||||
{
|
||||
}
|
||||
|
||||
virtual std::string call(std::size_t size,
|
||||
context_base::password_purpose purpose)
|
||||
{
|
||||
return callback_(size, purpose);
|
||||
}
|
||||
|
||||
private:
|
||||
PasswordCallback callback_;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace ssl
|
||||
} // namespace asio
|
||||
|
||||
#include "asio/detail/pop_options.hpp"
|
||||
|
||||
#endif // ASIO_SSL_DETAIL_PASSWORD_CALLBACK_HPP
|
72
module/Vendor/ASIO/include/asio/ssl/detail/read_op.hpp
vendored
Normal file
72
module/Vendor/ASIO/include/asio/ssl/detail/read_op.hpp
vendored
Normal file
@ -0,0 +1,72 @@
|
||||
//
|
||||
// ssl/detail/read_op.hpp
|
||||
// ~~~~~~~~~~~~~~~~~~~~~~
|
||||
//
|
||||
// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#ifndef ASIO_SSL_DETAIL_READ_OP_HPP
|
||||
#define ASIO_SSL_DETAIL_READ_OP_HPP
|
||||
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||
# pragma once
|
||||
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||
|
||||
#include "asio/detail/config.hpp"
|
||||
|
||||
#include "asio/detail/buffer_sequence_adapter.hpp"
|
||||
#include "asio/ssl/detail/engine.hpp"
|
||||
|
||||
#include "asio/detail/push_options.hpp"
|
||||
|
||||
namespace asio {
|
||||
namespace ssl {
|
||||
namespace detail {
|
||||
|
||||
template <typename MutableBufferSequence>
|
||||
class read_op
|
||||
{
|
||||
public:
|
||||
static ASIO_CONSTEXPR const char* tracking_name()
|
||||
{
|
||||
return "ssl::stream<>::async_read_some";
|
||||
}
|
||||
|
||||
read_op(const MutableBufferSequence& buffers)
|
||||
: buffers_(buffers)
|
||||
{
|
||||
}
|
||||
|
||||
engine::want operator()(engine& eng,
|
||||
asio::error_code& ec,
|
||||
std::size_t& bytes_transferred) const
|
||||
{
|
||||
asio::mutable_buffer buffer =
|
||||
asio::detail::buffer_sequence_adapter<asio::mutable_buffer,
|
||||
MutableBufferSequence>::first(buffers_);
|
||||
|
||||
return eng.read(buffer, ec, bytes_transferred);
|
||||
}
|
||||
|
||||
template <typename Handler>
|
||||
void call_handler(Handler& handler,
|
||||
const asio::error_code& ec,
|
||||
const std::size_t& bytes_transferred) const
|
||||
{
|
||||
handler(ec, bytes_transferred);
|
||||
}
|
||||
|
||||
private:
|
||||
MutableBufferSequence buffers_;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace ssl
|
||||
} // namespace asio
|
||||
|
||||
#include "asio/detail/pop_options.hpp"
|
||||
|
||||
#endif // ASIO_SSL_DETAIL_READ_OP_HPP
|
69
module/Vendor/ASIO/include/asio/ssl/detail/shutdown_op.hpp
vendored
Normal file
69
module/Vendor/ASIO/include/asio/ssl/detail/shutdown_op.hpp
vendored
Normal file
@ -0,0 +1,69 @@
|
||||
//
|
||||
// ssl/detail/shutdown_op.hpp
|
||||
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
//
|
||||
// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#ifndef ASIO_SSL_DETAIL_SHUTDOWN_OP_HPP
|
||||
#define ASIO_SSL_DETAIL_SHUTDOWN_OP_HPP
|
||||
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||
# pragma once
|
||||
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||
|
||||
#include "asio/detail/config.hpp"
|
||||
|
||||
#include "asio/ssl/detail/engine.hpp"
|
||||
|
||||
#include "asio/detail/push_options.hpp"
|
||||
|
||||
namespace asio {
|
||||
namespace ssl {
|
||||
namespace detail {
|
||||
|
||||
class shutdown_op
|
||||
{
|
||||
public:
|
||||
static ASIO_CONSTEXPR const char* tracking_name()
|
||||
{
|
||||
return "ssl::stream<>::async_shutdown";
|
||||
}
|
||||
|
||||
engine::want operator()(engine& eng,
|
||||
asio::error_code& ec,
|
||||
std::size_t& bytes_transferred) const
|
||||
{
|
||||
bytes_transferred = 0;
|
||||
return eng.shutdown(ec);
|
||||
}
|
||||
|
||||
template <typename Handler>
|
||||
void call_handler(Handler& handler,
|
||||
const asio::error_code& ec,
|
||||
const std::size_t&) const
|
||||
{
|
||||
if (ec == asio::error::eof)
|
||||
{
|
||||
// The engine only generates an eof when the shutdown notification has
|
||||
// been received from the peer. This indicates that the shutdown has
|
||||
// completed successfully, and thus need not be passed on to the handler.
|
||||
handler(asio::error_code());
|
||||
}
|
||||
else
|
||||
{
|
||||
handler(ec);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace ssl
|
||||
} // namespace asio
|
||||
|
||||
#include "asio/detail/pop_options.hpp"
|
||||
|
||||
#endif // ASIO_SSL_DETAIL_SHUTDOWN_OP_HPP
|
169
module/Vendor/ASIO/include/asio/ssl/detail/stream_core.hpp
vendored
Normal file
169
module/Vendor/ASIO/include/asio/ssl/detail/stream_core.hpp
vendored
Normal file
@ -0,0 +1,169 @@
|
||||
//
|
||||
// ssl/detail/stream_core.hpp
|
||||
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
//
|
||||
// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#ifndef ASIO_SSL_DETAIL_STREAM_CORE_HPP
|
||||
#define ASIO_SSL_DETAIL_STREAM_CORE_HPP
|
||||
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||
# pragma once
|
||||
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||
|
||||
#include "asio/detail/config.hpp"
|
||||
|
||||
#if defined(ASIO_HAS_BOOST_DATE_TIME)
|
||||
# include "asio/deadline_timer.hpp"
|
||||
#else // defined(ASIO_HAS_BOOST_DATE_TIME)
|
||||
# include "asio/steady_timer.hpp"
|
||||
#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
|
||||
#include "asio/ssl/detail/engine.hpp"
|
||||
#include "asio/buffer.hpp"
|
||||
|
||||
#include "asio/detail/push_options.hpp"
|
||||
|
||||
namespace asio {
|
||||
namespace ssl {
|
||||
namespace detail {
|
||||
|
||||
struct stream_core
|
||||
{
|
||||
// According to the OpenSSL documentation, this is the buffer size that is
|
||||
// sufficient to hold the largest possible TLS record.
|
||||
enum { max_tls_record_size = 17 * 1024 };
|
||||
|
||||
template <typename Executor>
|
||||
stream_core(SSL_CTX* context, const Executor& ex)
|
||||
: engine_(context),
|
||||
pending_read_(ex),
|
||||
pending_write_(ex),
|
||||
output_buffer_space_(max_tls_record_size),
|
||||
output_buffer_(asio::buffer(output_buffer_space_)),
|
||||
input_buffer_space_(max_tls_record_size),
|
||||
input_buffer_(asio::buffer(input_buffer_space_))
|
||||
{
|
||||
pending_read_.expires_at(neg_infin());
|
||||
pending_write_.expires_at(neg_infin());
|
||||
}
|
||||
|
||||
#if defined(ASIO_HAS_MOVE)
|
||||
stream_core(stream_core&& other)
|
||||
: engine_(ASIO_MOVE_CAST(engine)(other.engine_)),
|
||||
#if defined(ASIO_HAS_BOOST_DATE_TIME)
|
||||
pending_read_(
|
||||
ASIO_MOVE_CAST(asio::deadline_timer)(
|
||||
other.pending_read_)),
|
||||
pending_write_(
|
||||
ASIO_MOVE_CAST(asio::deadline_timer)(
|
||||
other.pending_write_)),
|
||||
#else // defined(ASIO_HAS_BOOST_DATE_TIME)
|
||||
pending_read_(
|
||||
ASIO_MOVE_CAST(asio::steady_timer)(
|
||||
other.pending_read_)),
|
||||
pending_write_(
|
||||
ASIO_MOVE_CAST(asio::steady_timer)(
|
||||
other.pending_write_)),
|
||||
#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
|
||||
output_buffer_space_(
|
||||
ASIO_MOVE_CAST(std::vector<unsigned char>)(
|
||||
other.output_buffer_space_)),
|
||||
output_buffer_(other.output_buffer_),
|
||||
input_buffer_space_(
|
||||
ASIO_MOVE_CAST(std::vector<unsigned char>)(
|
||||
other.input_buffer_space_)),
|
||||
input_buffer_(other.input_buffer_),
|
||||
input_(other.input_)
|
||||
{
|
||||
other.output_buffer_ = asio::mutable_buffer(0, 0);
|
||||
other.input_buffer_ = asio::mutable_buffer(0, 0);
|
||||
other.input_ = asio::const_buffer(0, 0);
|
||||
}
|
||||
#endif // defined(ASIO_HAS_MOVE)
|
||||
|
||||
~stream_core()
|
||||
{
|
||||
}
|
||||
|
||||
// The SSL engine.
|
||||
engine engine_;
|
||||
|
||||
#if defined(ASIO_HAS_BOOST_DATE_TIME)
|
||||
// Timer used for storing queued read operations.
|
||||
asio::deadline_timer pending_read_;
|
||||
|
||||
// Timer used for storing queued write operations.
|
||||
asio::deadline_timer pending_write_;
|
||||
|
||||
// Helper function for obtaining a time value that always fires.
|
||||
static asio::deadline_timer::time_type neg_infin()
|
||||
{
|
||||
return boost::posix_time::neg_infin;
|
||||
}
|
||||
|
||||
// Helper function for obtaining a time value that never fires.
|
||||
static asio::deadline_timer::time_type pos_infin()
|
||||
{
|
||||
return boost::posix_time::pos_infin;
|
||||
}
|
||||
|
||||
// Helper function to get a timer's expiry time.
|
||||
static asio::deadline_timer::time_type expiry(
|
||||
const asio::deadline_timer& timer)
|
||||
{
|
||||
return timer.expires_at();
|
||||
}
|
||||
#else // defined(ASIO_HAS_BOOST_DATE_TIME)
|
||||
// Timer used for storing queued read operations.
|
||||
asio::steady_timer pending_read_;
|
||||
|
||||
// Timer used for storing queued write operations.
|
||||
asio::steady_timer pending_write_;
|
||||
|
||||
// Helper function for obtaining a time value that always fires.
|
||||
static asio::steady_timer::time_point neg_infin()
|
||||
{
|
||||
return (asio::steady_timer::time_point::min)();
|
||||
}
|
||||
|
||||
// Helper function for obtaining a time value that never fires.
|
||||
static asio::steady_timer::time_point pos_infin()
|
||||
{
|
||||
return (asio::steady_timer::time_point::max)();
|
||||
}
|
||||
|
||||
// Helper function to get a timer's expiry time.
|
||||
static asio::steady_timer::time_point expiry(
|
||||
const asio::steady_timer& timer)
|
||||
{
|
||||
return timer.expiry();
|
||||
}
|
||||
#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
|
||||
|
||||
// Buffer space used to prepare output intended for the transport.
|
||||
std::vector<unsigned char> output_buffer_space_;
|
||||
|
||||
// A buffer that may be used to prepare output intended for the transport.
|
||||
asio::mutable_buffer output_buffer_;
|
||||
|
||||
// Buffer space used to read input intended for the engine.
|
||||
std::vector<unsigned char> input_buffer_space_;
|
||||
|
||||
// A buffer that may be used to read input intended for the engine.
|
||||
asio::mutable_buffer input_buffer_;
|
||||
|
||||
// The buffer pointing to the engine's unconsumed input.
|
||||
asio::const_buffer input_;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace ssl
|
||||
} // namespace asio
|
||||
|
||||
#include "asio/detail/pop_options.hpp"
|
||||
|
||||
#endif // ASIO_SSL_DETAIL_STREAM_CORE_HPP
|
62
module/Vendor/ASIO/include/asio/ssl/detail/verify_callback.hpp
vendored
Normal file
62
module/Vendor/ASIO/include/asio/ssl/detail/verify_callback.hpp
vendored
Normal file
@ -0,0 +1,62 @@
|
||||
//
|
||||
// ssl/detail/verify_callback.hpp
|
||||
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
//
|
||||
// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#ifndef ASIO_SSL_DETAIL_VERIFY_CALLBACK_HPP
|
||||
#define ASIO_SSL_DETAIL_VERIFY_CALLBACK_HPP
|
||||
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||
# pragma once
|
||||
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||
|
||||
#include "asio/detail/config.hpp"
|
||||
|
||||
#include "asio/ssl/verify_context.hpp"
|
||||
|
||||
#include "asio/detail/push_options.hpp"
|
||||
|
||||
namespace asio {
|
||||
namespace ssl {
|
||||
namespace detail {
|
||||
|
||||
class verify_callback_base
|
||||
{
|
||||
public:
|
||||
virtual ~verify_callback_base()
|
||||
{
|
||||
}
|
||||
|
||||
virtual bool call(bool preverified, verify_context& ctx) = 0;
|
||||
};
|
||||
|
||||
template <typename VerifyCallback>
|
||||
class verify_callback : public verify_callback_base
|
||||
{
|
||||
public:
|
||||
explicit verify_callback(VerifyCallback callback)
|
||||
: callback_(callback)
|
||||
{
|
||||
}
|
||||
|
||||
virtual bool call(bool preverified, verify_context& ctx)
|
||||
{
|
||||
return callback_(preverified, ctx);
|
||||
}
|
||||
|
||||
private:
|
||||
VerifyCallback callback_;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace ssl
|
||||
} // namespace asio
|
||||
|
||||
#include "asio/detail/pop_options.hpp"
|
||||
|
||||
#endif // ASIO_SSL_DETAIL_VERIFY_CALLBACK_HPP
|
76
module/Vendor/ASIO/include/asio/ssl/detail/write_op.hpp
vendored
Normal file
76
module/Vendor/ASIO/include/asio/ssl/detail/write_op.hpp
vendored
Normal file
@ -0,0 +1,76 @@
|
||||
//
|
||||
// ssl/detail/write_op.hpp
|
||||
// ~~~~~~~~~~~~~~~~~~~~~~~
|
||||
//
|
||||
// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
#ifndef ASIO_SSL_DETAIL_WRITE_OP_HPP
|
||||
#define ASIO_SSL_DETAIL_WRITE_OP_HPP
|
||||
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||
# pragma once
|
||||
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||
|
||||
#include "asio/detail/config.hpp"
|
||||
|
||||
#include "asio/detail/buffer_sequence_adapter.hpp"
|
||||
#include "asio/ssl/detail/engine.hpp"
|
||||
|
||||
#include "asio/detail/push_options.hpp"
|
||||
|
||||
namespace asio {
|
||||
namespace ssl {
|
||||
namespace detail {
|
||||
|
||||
template <typename ConstBufferSequence>
|
||||
class write_op
|
||||
{
|
||||
public:
|
||||
static ASIO_CONSTEXPR const char* tracking_name()
|
||||
{
|
||||
return "ssl::stream<>::async_write_some";
|
||||
}
|
||||
|
||||
write_op(const ConstBufferSequence& buffers)
|
||||
: buffers_(buffers)
|
||||
{
|
||||
}
|
||||
|
||||
engine::want operator()(engine& eng,
|
||||
asio::error_code& ec,
|
||||
std::size_t& bytes_transferred) const
|
||||
{
|
||||
unsigned char storage[
|
||||
asio::detail::buffer_sequence_adapter<asio::const_buffer,
|
||||
ConstBufferSequence>::linearisation_storage_size];
|
||||
|
||||
asio::const_buffer buffer =
|
||||
asio::detail::buffer_sequence_adapter<asio::const_buffer,
|
||||
ConstBufferSequence>::linearise(buffers_, asio::buffer(storage));
|
||||
|
||||
return eng.write(buffer, ec, bytes_transferred);
|
||||
}
|
||||
|
||||
template <typename Handler>
|
||||
void call_handler(Handler& handler,
|
||||
const asio::error_code& ec,
|
||||
const std::size_t& bytes_transferred) const
|
||||
{
|
||||
handler(ec, bytes_transferred);
|
||||
}
|
||||
|
||||
private:
|
||||
ConstBufferSequence buffers_;
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace ssl
|
||||
} // namespace asio
|
||||
|
||||
#include "asio/detail/pop_options.hpp"
|
||||
|
||||
#endif // ASIO_SSL_DETAIL_WRITE_OP_HPP
|
Reference in New Issue
Block a user