10#ifndef BOTAN_ASIO_STREAM_H_
11#define BOTAN_ASIO_STREAM_H_
13#include <botan/asio_compat.h>
14#if !defined(BOTAN_FOUND_COMPATIBLE_BOOST_ASIO_VERSION)
15 #error Available boost headers are too old for the boost asio stream.
18 #include <botan/asio_async_ops.h>
19 #include <botan/asio_context.h>
20 #include <botan/asio_error.h>
22 #include <botan/tls_callbacks.h>
23 #include <botan/tls_channel.h>
24 #include <botan/tls_client.h>
25 #include <botan/tls_magic.h>
26 #include <botan/tls_server.h>
30 #define BOOST_ASIO_DISABLE_SERIAL_PORT
31 #include <boost/asio.hpp>
32 #include <boost/beast/core.hpp>
40 #include <type_traits>
46template <
class SL,
class C>
65 void push(std::span<const uint8_t> record) {
66 if(record.size() > m_queued.max_size() - m_queued.size()) {
67 throw std::length_error(
"TLS record does not fit the output queue");
69 m_queued.insert(m_queued.end(), record.begin(), record.end());
73 bool write_in_progress()
const {
return m_write_in_progress; }
76 bool has_data()
const {
return !m_queued.empty() || (!m_write_in_progress && in_flight().size() > 0); }
87 boost::asio::const_buffer begin_write() {
88 if(m_write_in_progress || !has_data()) {
89 throw Botan::Invalid_State(
"ASIO TLS stream write already in progress or nothing to write");
92 if(in_flight().size() == 0) {
94 m_in_flight_offset = 0;
95 std::swap(m_in_flight, m_queued);
97 m_write_in_progress =
true;
109 void end_write(std::size_t bytes_transferred) {
110 const auto accepted = std::min(bytes_transferred, in_flight().size());
111 m_in_flight_offset += accepted;
112 m_written += accepted;
113 if(m_in_flight_offset == m_in_flight.size()) {
115 m_in_flight_offset = 0;
117 m_write_in_progress =
false;
121 void mark_pending() {
123 m_pending_mark = position();
128 bool pending()
const {
return m_written < m_pending_mark; }
131 std::size_t queued_size()
const {
return m_queued.size(); }
134 void truncate(std::size_t keep) {
135 if(m_queued.size() > keep) {
136 m_queued.resize(keep);
138 m_pending_mark = std::min(m_pending_mark, position());
146 m_in_flight_offset = 0;
147 m_write_in_progress =
false;
154 boost::asio::const_buffer in_flight()
const {
155 return {m_in_flight.data() + m_in_flight_offset, m_in_flight.size() - m_in_flight_offset};
159 uint64_t position()
const {
return m_written + in_flight().size() + m_queued.size(); }
161 std::vector<uint8_t> m_queued;
162 std::vector<uint8_t> m_in_flight;
163 std::size_t m_in_flight_offset = 0;
164 bool m_write_in_progress =
false;
165 uint64_t m_written = 0;
166 uint64_t m_pending_mark = 0;
188class StreamCallbacks :
public Callbacks {
190 StreamCallbacks() =
default;
192 void tls_emit_data(std::span<const uint8_t> data)
final {
198 m_emit_failure = std::current_exception();
203 void tls_record_received(uint64_t , std::span<const uint8_t> data)
final {
204 m_receive_buffer.commit(boost::asio::buffer_copy(m_receive_buffer.prepare(data.size()),
205 boost::asio::const_buffer(data.data(), data.size())));
208 bool tls_peer_closed_connection() final {
222 void tls_alert(TLS::Alert alert)
final {
223 if(alert.is_fatal() || alert.type() == TLS::AlertType::CloseNotify) {
228 m_alert_from_peer = alert;
232 void tls_verify_cert_chain(
const std::vector<X509_Certificate>& cert_chain,
233 const std::vector<std::optional<OCSP::Response>>& ocsp_responses,
234 const std::vector<Certificate_Store*>& trusted_roots,
236 std::string_view hostname,
237 const TLS::Policy& policy)
override {
238 const auto ctx = m_context.lock();
240 if(ctx && ctx->has_verify_callback()) {
241 ctx->get_verify_callback()(cert_chain, ocsp_responses, trusted_roots, usage, hostname, policy);
243 Callbacks::tls_verify_cert_chain(cert_chain, ocsp_responses, trusted_roots, usage, hostname, policy);
247 std::string tls_server_choose_app_protocol(
const std::vector<std::string>& client_protos)
override {
248 if(client_protos.empty()) {
251 const auto ctx = m_context.lock();
253 if(!ctx || ctx->m_app_protocols.empty()) {
257 for(
const auto& server_proto : ctx->m_app_protocols) {
258 for(
const auto& client_proto : client_protos) {
259 if(server_proto == client_proto) {
266 Alert::NoApplicationProtocol,
267 "Rejecting ALPN request: no overlap between client-offered and server-configured application protocols");
272 template <
class SL,
class C>
280 void bind_to_stream(
const std::shared_ptr<const void>& stream_token, std::weak_ptr<Botan::TLS::Context> context) {
281 if(!m_stream_token.expired()) {
282 throw Invalid_Argument(
"TLS::StreamCallbacks instance is already in use by another TLS::Stream");
285 m_stream_token = stream_token;
286 m_context = std::move(context);
289 m_alert_from_peer.reset();
290 m_receive_buffer.clear();
292 m_emit_failure =
nullptr;
295 detail::OutputQueue& output_queue() {
return m_output; }
297 const detail::OutputQueue& output_queue()
const {
return m_output; }
300 std::exception_ptr take_emit_failure() {
return std::exchange(m_emit_failure,
nullptr); }
302 boost::beast::flat_buffer& receive_buffer() {
return m_receive_buffer; }
304 const boost::beast::flat_buffer& receive_buffer()
const {
return m_receive_buffer; }
306 bool shutdown_received()
const {
307 return m_alert_from_peer && m_alert_from_peer->type() == AlertType::CloseNotify;
310 std::optional<Alert> alert_from_peer()
const {
return m_alert_from_peer; }
313 std::optional<Alert> m_alert_from_peer;
314 boost::beast::flat_buffer m_receive_buffer;
315 detail::OutputQueue m_output;
316 std::exception_ptr m_emit_failure;
318 std::weak_ptr<TLS::Context> m_context;
319 std::weak_ptr<const void> m_stream_token;
325concept basic_completion_token = boost::asio::completion_token_for<T, void(boost::system::error_code)>;
328concept byte_size_completion_token = boost::asio::completion_token_for<T, void(boost::system::error_code,
size_t)>;
354template <
class StreamLayer,
class ChannelT = Channel>
357 using default_completion_token =
358 boost::asio::default_completion_token_t<boost::beast::executor_type<StreamLayer>>;
377 template <
typename... Args>
378 explicit Stream(std::shared_ptr<Context> context, std::shared_ptr<StreamCallbacks> callbacks, Args&&... args) :
379 m_context(std::move(context)),
380 m_nextLayer(std::forward<Args>(args)...),
381 m_core(std::move(callbacks)),
382 m_core_token(std::make_shared<int>(0)),
384 m_pending_write(m_nextLayer.get_executor(), std::chrono::steady_clock::time_point::max()) {
385 if(!m_context || !m_core) {
386 throw Invalid_Argument(
"TLS::Stream requires a context and a callbacks object");
388 m_core->bind_to_stream(m_core_token, m_context);
397 template <
typename... Args>
398 explicit Stream(std::shared_ptr<Context> context, Args&&... args) :
399 Stream(std::move(context), std::make_shared<StreamCallbacks>(), std::forward<Args>(args)...) {}
412 template <
typename Arg>
413 explicit Stream(Arg&& arg,
414 std::shared_ptr<Context> context,
415 std::shared_ptr<StreamCallbacks> callbacks = std::make_shared<StreamCallbacks>()) :
416 Stream(std::move(context), std::move(callbacks), std::forward<Arg>(arg)) {}
418 #if defined(BOTAN_HAS_DEFAULT_TLS_CONTEXT)
429 template <
typename... Args>
430 explicit Stream(Server_Information server_info, Args&&... args) :
431 Stream(std::make_shared<Context>(std::move(server_info)), std::forward<Args>(args)...) {}
434 virtual ~Stream() =
default;
437 Stream(Stream&& other) =
default;
438 Stream& operator=(Stream&& other) =
default;
440 Stream(
const Stream& other) =
delete;
441 Stream& operator=(
const Stream& other) =
delete;
447 using next_layer_type = std::remove_reference_t<StreamLayer>;
449 const next_layer_type& next_layer()
const {
return m_nextLayer; }
451 next_layer_type& next_layer() {
return m_nextLayer; }
453 using lowest_layer_type =
typename boost::beast::lowest_layer_type<StreamLayer>;
455 lowest_layer_type& lowest_layer() {
return boost::beast::get_lowest_layer(m_nextLayer); }
457 const lowest_layer_type& lowest_layer()
const {
return boost::beast::get_lowest_layer(m_nextLayer); }
459 using executor_type =
typename next_layer_type::executor_type;
461 executor_type get_executor() noexcept {
return m_nextLayer.get_executor(); }
463 using native_handle_type = std::add_pointer_t<ChannelT>;
465 native_handle_type native_handle() {
466 if(m_native_handle ==
nullptr) {
467 throw Botan::Invalid_State(
"ASIO native handle unexpectedly null");
469 return m_native_handle.get();
485 void set_verify_callback(Context::Verify_Callback callback) {
486 m_context->set_verify_callback(std::move(callback));
495 void set_verify_callback(Context::Verify_Callback callback, [[maybe_unused]] boost::system::error_code& ec) {
496 m_context->set_verify_callback(std::move(callback));
504 void set_verify_depth([[maybe_unused]]
int depth) {
505 throw Not_Implemented(
"set_verify_depth is not implemented");
513 void set_verify_depth([[maybe_unused]]
int depth, boost::system::error_code& ec) {
514 ec = ErrorType::NotImplemented;
522 template <
typename verify_mode>
523 void set_verify_mode([[maybe_unused]] verify_mode v) {
524 throw Not_Implemented(
"set_verify_mode is not implemented");
532 template <
typename verify_mode>
533 void set_verify_mode([[maybe_unused]] verify_mode v, boost::system::error_code& ec) {
534 ec = ErrorType::NotImplemented;
549 void handshake(Connection_Side side) {
550 boost::system::error_code ec;
552 boost::asio::detail::throw_error(ec,
"handshake");
563 void handshake(Connection_Side side, boost::system::error_code& ec) {
565 if(async_write_in_flight(ec)) {
569 ec = setup_native_handle(side);
578 if(has_data_to_send()) {
579 send_pending_encrypted_data(ec);
584 if(native_handle()->is_handshake_complete()) {
592 handle_tls_protocol_errors(ec);
598 read_and_process_encrypted_data_from_peer(ec);
611 template <detail::basic_completion_token CompletionToken = default_completion_token>
614 CompletionToken&& completion_token = default_completion_token{}) {
615 return boost::asio::async_initiate<CompletionToken, void(boost::system::error_code)>(
616 [
this](
auto&& completion_handler, TLS::Connection_Side connection_side) {
617 using completion_handler_t = std::decay_t<
decltype(completion_handler)>;
619 const detail::AsyncHandshakeOperation<completion_handler_t, Stream> op{
620 std::forward<completion_handler_t>(completion_handler), *
this, setup_native_handle(connection_side)};
630 template <
typename ConstBufferSequence, detail::basic_completion_token BufferedHandshakeHandler>
631 auto async_handshake([[maybe_unused]] Connection_Side side,
632 [[maybe_unused]]
const ConstBufferSequence& buffers,
633 [[maybe_unused]] BufferedHandshakeHandler&& handler ) {
634 throw Not_Implemented(
"buffered async handshake is not implemented");
651 void shutdown(boost::system::error_code& ec) {
653 if(async_write_in_flight(ec)) {
658 send_pending_encrypted_data(ec);
672 boost::system::error_code ec;
674 boost::asio::detail::throw_error(ec,
"shutdown");
686 template <
typename Handler,
typename Executor>
688 void operator()(boost::system::error_code ec, std::size_t ) { handler(ec); }
690 using executor_type = boost::asio::associated_executor_t<Handler, Executor>;
692 executor_type get_executor() const noexcept {
693 return boost::asio::get_associated_executor(handler, io_executor);
696 using allocator_type = boost::asio::associated_allocator_t<Handler>;
698 allocator_type get_allocator() const noexcept {
return boost::asio::get_associated_allocator(handler); }
700 using cancellation_slot_type = boost::asio::associated_cancellation_slot_t<Handler>;
702 cancellation_slot_type get_cancellation_slot() const noexcept {
703 return boost::asio::get_associated_cancellation_slot(handler);
707 Executor io_executor;
721 template <detail::basic_completion_token CompletionToken = default_completion_token>
723 auto async_shutdown(CompletionToken&& completion_token = default_completion_token{}) {
724 return boost::asio::async_initiate<CompletionToken, void(boost::system::error_code)>(
725 [
this](
auto&& completion_handler) {
726 using completion_handler_t = std::decay_t<
decltype(completion_handler)>;
727 using write_handler_t = Wrapper<completion_handler_t, typename Stream::executor_type>;
730 const TLS::detail::AsyncWriteOperation<write_handler_t, Stream, boost::asio::const_buffer> op{
731 write_handler_t{std::forward<completion_handler_t>(completion_handler), get_executor()},
753 template <
typename MutableBufferSequence>
754 std::size_t read_some(
const MutableBufferSequence& buffers, boost::system::error_code& ec) {
759 if(boost::asio::buffer_size(buffers) == 0) {
764 if(async_write_in_flight(ec) || native_handle_missing(ec)) {
775 if(has_received_data()) {
776 return copy_received_data(buffers);
783 if(has_data_to_send()) {
784 send_pending_encrypted_data(ec);
794 handle_tls_protocol_errors(ec);
801 read_and_process_encrypted_data_from_peer(ec);
817 template <
typename MutableBufferSequence>
818 std::size_t read_some(
const MutableBufferSequence& buffers) {
819 boost::system::error_code ec;
820 const auto n = read_some(buffers, ec);
821 boost::asio::detail::throw_error(ec,
"read_some");
835 template <
typename ConstBufferSequence>
836 std::size_t write_some(
const ConstBufferSequence& buffers, boost::system::error_code& ec) {
841 if(boost::asio::buffer_size(buffers) == 0) {
845 if(async_write_in_flight(ec)) {
849 ec = tls_encrypt(buffers);
856 send_pending_encrypted_data(ec);
857 return boost::asio::buffer_size(buffers);
870 template <
typename ConstBufferSequence>
871 std::size_t write_some(
const ConstBufferSequence& buffers) {
872 boost::system::error_code ec;
873 const auto n = write_some(buffers, ec);
874 boost::asio::detail::throw_error(ec,
"write_some");
889 template <
typename ConstBufferSequence,
890 detail::byte_size_completion_token CompletionToken = default_completion_token>
891 auto async_write_some(
const ConstBufferSequence& buffers,
893 CompletionToken&& completion_token = default_completion_token{}) {
894 return boost::asio::async_initiate<CompletionToken, void(boost::system::error_code, std::size_t)>(
895 [
this](
auto&& completion_handler,
const auto& bufs) {
896 using completion_handler_t = std::decay_t<
decltype(completion_handler)>;
899 const detail::AsyncWriteOperation<completion_handler_t, Stream, ConstBufferSequence> op{
900 std::forward<completion_handler_t>(completion_handler), *
this, bufs};
915 template <
typename MutableBufferSequence,
916 detail::byte_size_completion_token CompletionToken = default_completion_token>
917 auto async_read_some(
const MutableBufferSequence& buffers,
919 CompletionToken&& completion_token = default_completion_token{}) {
920 return boost::asio::async_initiate<CompletionToken, void(boost::system::error_code, std::size_t)>(
921 [
this](
auto&& completion_handler,
const auto& bufs) {
922 using completion_handler_t = std::decay_t<
decltype(completion_handler)>;
925 boost::system::error_code ec;
926 if(boost::asio::buffer_size(bufs) > 0) {
927 native_handle_missing(ec);
930 const detail::AsyncReadOperation<completion_handler_t, Stream, MutableBufferSequence> op{
931 std::forward<completion_handler_t>(completion_handler), *
this, bufs, ec};
943 bool shutdown_received()
const {
return m_core->shutdown_received(); }
946 template <
class H,
class S,
class M,
class A>
947 friend class detail::AsyncReadOperation;
948 template <
class H,
class S,
class B,
class A>
949 friend class detail::AsyncWriteOperation;
950 template <
class H,
class S,
class A>
951 friend class detail::AsyncHandshakeOperation;
952 template <
class O,
class S>
953 friend class detail::WriteQueuedStep;
954 template <
class O,
class S>
955 friend class detail::ReadAndProcessStep;
958 boost::asio::mutable_buffer input_buffer() {
return boost::asio::buffer(m_input_buffer_space); }
961 bool write_in_progress()
const {
return m_core->output_queue().write_in_progress(); }
964 bool async_write_in_flight(boost::system::error_code& ec)
const {
965 if(write_in_progress()) {
966 ec = boost::asio::error::already_started;
968 return write_in_progress();
972 bool native_handle_missing(boost::system::error_code& ec)
const {
973 if(m_native_handle ==
nullptr) {
974 ec = ErrorType::InvalidObjectState;
976 return m_native_handle ==
nullptr;
980 boost::asio::const_buffer begin_write() {
return m_core->output_queue().begin_write(); }
983 void end_write(std::size_t bytes_transferred) {
984 m_core->output_queue().end_write(bytes_transferred);
985 m_pending_write.cancel();
994 void mark_output_to_send() { m_core->output_queue().mark_pending(); }
997 bool output_pending()
const {
return m_core->output_queue().pending(); }
1006 template <
class Operation>
1007 void async_send_queued(Operation operation) {
1008 if(write_in_progress()) {
1009 m_pending_write.async_wait(detail::WaitForWriteStep<Operation>(std::move(operation)));
1011 boost::asio::async_write(
1012 m_nextLayer, begin_write(), detail::WriteQueuedStep<Operation, Stream>(std::move(operation), *
this));
1021 template <
class Operation>
1022 void async_read_and_process(Operation operation) {
1023 m_nextLayer.async_read_some(input_buffer(),
1024 detail::ReadAndProcessStep<Operation, Stream>(std::move(operation), *
this));
1028 void translate_eof(boost::system::error_code& ec)
const {
1029 if(ec == boost::asio::error::eof && !shutdown_received()) {
1030 ec = StreamError::StreamTruncated;
1035 bool has_received_data()
const {
return m_core->receive_buffer().size() > 0; }
1038 template <
typename MutableBufferSequence>
1039 std::size_t copy_received_data(MutableBufferSequence buffers) {
1044 const auto copiedBytes = boost::asio::buffer_copy(buffers, m_core->receive_buffer().data());
1045 m_core->receive_buffer().consume(copiedBytes);
1050 bool has_data_to_send()
const {
return m_core->output_queue().has_data(); }
1061 boost::system::error_code setup_native_handle(Connection_Side side) {
1064 if constexpr(std::is_same_v<ChannelT, Channel>) {
1066 if(m_native_handle !=
nullptr) {
1067 return ErrorType::InvalidObjectState;
1072 return call_tls_discarding_output([&] {
1073 if(side == Connection_Side::Client) {
1074 m_native_handle = std::unique_ptr<Client>(
1076 m_context->m_session_manager,
1077 m_context->m_credentials_manager,
1078 m_context->m_policy,
1080 m_context->m_server_info,
1081 m_context->m_policy->latest_supported_version(
false ),
1082 m_context->m_app_protocols));
1084 m_native_handle = std::unique_ptr<Server>(
new Server(m_core,
1085 m_context->m_session_manager,
1086 m_context->m_credentials_manager,
1087 m_context->m_policy,
1113 void handle_tls_protocol_errors(boost::system::error_code& ec) {
1122 else if(
const auto error = error_from_us()) {
1134 else if(
auto alert = alert_from_peer()) {
1135 if(alert->type() == AlertType::CloseNotify) {
1136 ec = boost::asio::error::eof;
1152 void read_and_process_encrypted_data_from_peer(boost::system::error_code& ec) {
1160 if(has_received_data()) {
1161 throw Botan::Invalid_State(
"ASIO receive buffer not empty");
1164 if(error_from_us() || alert_from_peer()) {
1165 throw Botan::Invalid_State(
"ASIO TLS session no longer healthy");
1172 const boost::asio::const_buffer read_buffer{input_buffer().data(), m_nextLayer.read_some(input_buffer(), ec)};
1175 process_encrypted_data(read_buffer);
1186 void send_pending_encrypted_data(boost::system::error_code& ec) {
1187 if(ec || async_write_in_flight(ec)) {
1192 while(!ec && has_data_to_send()) {
1193 const auto written = boost::asio::write(m_nextLayer, begin_write(), ec);
1204 boost::system::error_code tls_close() {
1205 boost::system::error_code ec;
1206 if(native_handle_missing(ec)) {
1210 return call_tls_discarding_output([&] { native_handle()->close(); });
1220 template <
typename ConstBufferSequence>
1221 boost::system::error_code tls_encrypt(
const ConstBufferSequence& buffers) {
1222 boost::system::error_code ec;
1223 if(native_handle_missing(ec) || output_failed(ec)) {
1230 std::vector<uint8_t> copy_buffer;
1231 auto unpack = [©_buffer](
const auto& bufs) -> std::span<const uint8_t> {
1232 const auto buffers_in_sequence =
1233 std::distance(boost::asio::buffer_sequence_begin(bufs), boost::asio::buffer_sequence_end(bufs));
1235 if(buffers_in_sequence == 0) {
1237 }
else if(buffers_in_sequence == 1) {
1238 const boost::asio::const_buffer buf = *boost::asio::buffer_sequence_begin(bufs);
1239 return {
static_cast<const uint8_t*
>(buf.data()), buf.size()};
1241 copy_buffer.resize(boost::asio::buffer_size(bufs));
1242 boost::asio::buffer_copy(boost::asio::buffer(copy_buffer), bufs);
1248 std::span<const uint8_t> plaintext;
1249 ec = try_with_error_code([&] { plaintext =
unpack(buffers); });
1257 return call_tls_discarding_output([&] { native_handle()->send(plaintext); });
1271 void process_encrypted_data(
const boost::asio::const_buffer& read_buffer) {
1272 if(alert_from_peer() || error_from_us()) {
1273 throw Botan::Invalid_State(
"ASIO TLS session no longer healthy");
1281 m_ec_from_last_read = call_tls_keeping_output([&] {
1282 native_handle()->received_data({
static_cast<const uint8_t*
>(read_buffer.data()), read_buffer.size()});
1288 mark_output_to_send();
1292 template <
typename Fun>
1293 static boost::system::error_code try_with_error_code(Fun f) {
1296 }
catch(
const TLS_Exception& e) {
1298 }
catch(
const Exception& e) {
1299 return e.error_type();
1300 }
catch(
const std::bad_alloc&) {
1301 return ErrorType::OutOfMemory;
1302 }
catch(
const std::exception&) {
1303 return ErrorType::Unknown;
1318 template <
typename Fun>
1319 boost::system::error_code call_tls_keeping_output(Fun f) {
1320 return call_tls(f,
false);
1332 template <
typename Fun>
1333 boost::system::error_code call_tls_discarding_output(Fun f) {
1334 boost::system::error_code ec;
1335 if(output_failed(ec)) {
1339 return call_tls(f,
true);
1343 bool output_failed(boost::system::error_code& ec)
const {
1344 if(m_ec_from_failed_output) {
1345 ec = m_ec_from_failed_output;
1347 return static_cast<bool>(m_ec_from_failed_output);
1365 template <
typename Fun>
1366 boost::system::error_code call_tls(Fun f,
bool discard_output_on_failure) {
1367 auto& output = m_core->output_queue();
1368 const auto queued_before = output.queued_size();
1370 auto ec = try_with_error_code(f);
1371 const auto emit_failure = m_core->take_emit_failure();
1372 if(emit_failure && !ec) {
1373 ec = try_with_error_code([&] { std::rethrow_exception(emit_failure); });
1379 if(ec && !m_ec_from_failed_output && m_native_handle !=
nullptr &&
1380 (emit_failure || m_native_handle->is_active())) {
1381 m_ec_from_failed_output = ec;
1384 if(m_ec_from_failed_output || (ec && discard_output_on_failure)) {
1385 output.truncate(queued_before);
1397 std::optional<Alert> alert_from_peer()
const {
return m_core->alert_from_peer(); }
1405 boost::system::error_code error_from_us()
const {
return m_ec_from_last_read; }
1408 using timer_type = boost::asio::basic_waitable_timer<std::chrono::steady_clock,
1409 boost::asio::wait_traits<std::chrono::steady_clock>,
1412 std::shared_ptr<Context> m_context;
1413 StreamLayer m_nextLayer;
1415 std::shared_ptr<StreamCallbacks> m_core;
1417 std::shared_ptr<const void> m_core_token;
1418 std::unique_ptr<ChannelT> m_native_handle;
1419 boost::system::error_code m_ec_from_last_read;
1421 boost::system::error_code m_ec_from_failed_output;
1424 std::vector<uint8_t> m_input_buffer_space;
1427 timer_type m_pending_write;
1432template <
typename T>
1434template <
typename T>
1435Stream(std::shared_ptr<Context>, std::shared_ptr<StreamCallbacks>, T) -> Stream<T>;
1436template <
typename T>
1437Stream(std::shared_ptr<Context>, T) -> Stream<T>;
1438template <
typename T>
1439Stream(T, std::shared_ptr<Context>) -> Stream<T>;
constexpr void unpack(Polynomial< PolyTrait, D > &p, ByteSourceT &byte_source, UnmapFnT unmap)