boost::asio compatible SSL/TLS stream More...

#include <asio_stream.h>

Classes
class	StreamCore
	Helper class that implements TLS::Callbacks. More...

Public Member Functions
bool	shutdown_received () const
	Indicates whether a close_notify alert has been received from the peer.

construction
template<typename... Args>
	Stream (std::shared_ptr< Context > context, Args &&... args)
	Construct a new Stream.

template<typename Arg >
	Stream (Arg &&arg, std::shared_ptr< Context > context)
	Construct a new Stream.

virtual	~Stream ()=default

	Stream (Stream &&other)=default

Stream &	operator= (Stream &&other)=default

	Stream (const Stream &other)=delete

Stream &	operator= (const Stream &other)=delete

configuration and callback setters
void	set_verify_callback (Context::Verify_Callback callback)
	Override the tls_verify_cert_chain callback.

void	set_verify_callback (Context::Verify_Callback callback, boost::system::error_code &ec)
	Compatibility overload of set_verify_callback.

void	set_verify_depth (int depth)

void	set_verify_depth (int depth, boost::system::error_code &ec)

template<typename verify_mode >
void	set_verify_mode (verify_mode v)

template<typename verify_mode >
void	set_verify_mode (verify_mode v, boost::system::error_code &ec)

handshake methods
void	handshake (Connection_Side side)
	Performs SSL handshaking.

void	handshake (Connection_Side side, boost::system::error_code &ec)
	Performs SSL handshaking.

template<typename CompletionToken >
auto	async_handshake (Botan::TLS::Connection_Side side, CompletionToken &&completion_token)
	Starts an asynchronous SSL handshake.

template<typename ConstBufferSequence , typename BufferedHandshakeHandler >
	async_handshake (Connection_Side side, const ConstBufferSequence &buffers, BufferedHandshakeHandler &&handler)

shutdown methods
void	shutdown (boost::system::error_code &ec)
	Shut down SSL on the stream.

void	shutdown ()
	Shut down SSL on the stream.

template<typename CompletionToken >
auto	async_shutdown (CompletionToken &&completion_token)
	Asynchronously shut down SSL on the stream.

I/O methods
template<typename MutableBufferSequence >
std::size_t	read_some (const MutableBufferSequence &buffers, boost::system::error_code &ec)
	Read some data from the stream.

template<typename MutableBufferSequence >
std::size_t	read_some (const MutableBufferSequence &buffers)
	Read some data from the stream.

template<typename ConstBufferSequence >
std::size_t	write_some (const ConstBufferSequence &buffers, boost::system::error_code &ec)
	Write some data to the stream.

template<typename ConstBufferSequence >
std::size_t	write_some (const ConstBufferSequence &buffers)
	Write some data to the stream.

template<typename ConstBufferSequence , typename CompletionToken >
auto	async_write_some (const ConstBufferSequence &buffers, CompletionToken &&completion_token)
	Start an asynchronous write. The function call always returns immediately.

template<typename MutableBufferSequence , typename CompletionToken >
auto	async_read_some (const MutableBufferSequence &buffers, CompletionToken &&completion_token)
	Start an asynchronous read. The function call always returns immediately.

Protected Member Functions
void	consume_send_buffer (std::size_t bytesConsumed)
	Mark bytes in the send buffer as consumed, removing them from the buffer.

template<typename MutableBufferSequence >
std::size_t	copy_received_data (MutableBufferSequence buffers)
	Copy decrypted data into the user-provided buffer.

bool	has_data_to_send () const
	Check if encrypted data is available in the send buffer.

bool	has_received_data () const
	Check if decrypted data is available in the receive buffer.

const boost::asio::mutable_buffer &	input_buffer ()

void	process_encrypted_data (const boost::asio::const_buffer &read_buffer, boost::system::error_code &ec)
	Pass encrypted data to the native handle for processing.

boost::asio::const_buffer	send_buffer () const

size_t	send_pending_encrypted_data (boost::system::error_code &ec)
	Synchronously write encrypted data from the send buffer to the next layer.

void	setup_native_handle (Connection_Side side, boost::system::error_code &ec)
	Create the native handle.

template<typename ConstBufferSequence >
void	tls_encrypt (const ConstBufferSequence &buffers, boost::system::error_code &ec)
	Pass plaintext data to the native handle for processing.

template<typename Fun >
void	try_with_error_code (Fun f, boost::system::error_code &ec)
	Catch exceptions and set an error_code.

Protected Attributes
std::shared_ptr< Context >	m_context

std::shared_ptr< StreamCore >	m_core

const boost::asio::mutable_buffer	m_input_buffer

std::vector< uint8_t >	m_input_buffer_space

std::unique_ptr< ChannelT >	m_native_handle

StreamLayer	m_nextLayer

Friends
template<class H , class S , class A >
class	detail::AsyncHandshakeOperation

template<class H , class S , class M , class A >
class	detail::AsyncReadOperation

template<class H , class S , class A >
class	detail::AsyncWriteOperation

boost::asio accessor methods
using	next_layer_type = typename std::remove_reference< StreamLayer >::type

using	lowest_layer_type = typename next_layer_type::lowest_layer_type

using	executor_type = typename next_layer_type::executor_type

using	native_handle_type = typename std::add_pointer< ChannelT >::type

const next_layer_type &	next_layer () const

next_layer_type &	next_layer ()

lowest_layer_type &	lowest_layer ()

const lowest_layer_type &	lowest_layer () const

executor_type	get_executor () noexcept

native_handle_type	native_handle ()

Detailed Description

template<class StreamLayer, class ChannelT = Channel>
class Botan::TLS::Stream< StreamLayer, ChannelT >

boost::asio compatible SSL/TLS stream

Template Parameters

StreamLayer	type of the next layer, usually a network socket
ChannelT	type of the native_handle, defaults to TLS::Channel, only needed for testing purposes

Definition at line 47 of file asio_stream.h.

Member Typedef Documentation

◆ executor_type

template<class StreamLayer , class ChannelT = Channel>

using Botan::TLS::Stream< StreamLayer, ChannelT >::executor_type = typename next_layer_type::executor_type

Definition at line 123 of file asio_stream.h.

◆ lowest_layer_type

template<class StreamLayer , class ChannelT = Channel>

using Botan::TLS::Stream< StreamLayer, ChannelT >::lowest_layer_type = typename next_layer_type::lowest_layer_type

Definition at line 116 of file asio_stream.h.

◆ native_handle_type

template<class StreamLayer , class ChannelT = Channel>

using Botan::TLS::Stream< StreamLayer, ChannelT >::native_handle_type = typename std::add_pointer<ChannelT>::type

Definition at line 127 of file asio_stream.h.

◆ next_layer_type

template<class StreamLayer , class ChannelT = Channel>

using Botan::TLS::Stream< StreamLayer, ChannelT >::next_layer_type = typename std::remove_reference<StreamLayer>::type

Definition at line 98 of file asio_stream.h.

Constructor & Destructor Documentation

◆ Stream() [1/4]

template<class StreamLayer , class ChannelT = Channel>

template<typename... Args>

Botan::TLS::Stream< StreamLayer, ChannelT >::Stream	(	std::shared_ptr< Context >	context,
		Args &&...	args
	)

inlineexplicit

Construct a new Stream.

Parameters

context	The context parameter is used to set up the underlying native handle. Using code is responsible for lifetime management of the context and must ensure that it is available for the lifetime of the stream.
args	Arguments to be forwarded to the construction of the next layer.

Definition at line 61 of file asio_stream.h.

                                                                      :
            m_context(context),
            m_nextLayer(std::forward<Args>(args)...),
            m_core(std::make_shared<StreamCore>(context)),
            m_input_buffer_space(MAX_CIPHERTEXT_SIZE, '\0'),
            m_input_buffer(m_input_buffer_space.data(), m_input_buffer_space.size()) {}

◆ Stream() [2/4]

template<class StreamLayer , class ChannelT = Channel>

template<typename Arg >

Botan::TLS::Stream< StreamLayer, ChannelT >::Stream	(	Arg &&	arg,
		std::shared_ptr< Context >	context
	)

inlineexplicit

Construct a new Stream.

Convenience overload for boost::asio::ssl::stream compatibility.

Parameters

arg	This argument is forwarded to the construction of the next layer.
context	The context parameter is used to set up the underlying native handle. Using code is responsible for lifetime management of the context and must ensure that is available for the lifetime of the stream.

Definition at line 79 of file asio_stream.h.

                                                                 :
            m_context(context),
            m_nextLayer(std::forward<Arg>(arg)),
            m_core(std::make_shared<StreamCore>(context)),
            m_input_buffer_space(MAX_CIPHERTEXT_SIZE, '\0'),
            m_input_buffer(m_input_buffer_space.data(), m_input_buffer_space.size()) {}

◆ ~Stream()

template<class StreamLayer , class ChannelT = Channel>

virtual Botan::TLS::Stream< StreamLayer, ChannelT >::~Stream ( )

virtualdefault

◆ Stream() [3/4]

template<class StreamLayer , class ChannelT = Channel>

Botan::TLS::Stream< StreamLayer, ChannelT >::Stream ( Stream< StreamLayer, ChannelT > && other )

default

◆ Stream() [4/4]

template<class StreamLayer , class ChannelT = Channel>

Botan::TLS::Stream< StreamLayer, ChannelT >::Stream ( const Stream< StreamLayer, ChannelT > & other )

delete

Member Function Documentation

◆ async_handshake() [1/2]

template<class StreamLayer , class ChannelT = Channel>

template<typename CompletionToken >

auto Botan::TLS::Stream< StreamLayer, ChannelT >::async_handshake	(	Botan::TLS::Connection_Side	side,
		CompletionToken &&	completion_token
	)

inline

Starts an asynchronous SSL handshake.

This function call always returns immediately.

Parameters

side	The type of handshaking to be performed, i.e. as a client or as a server.
completion_token	The completion handler to be called when the handshake operation completes. The completion signature of the handler must be: void(boost::system::error_code).

Definition at line 254 of file asio_stream.h.

                                                                                             {
         return boost::asio::async_initiate<CompletionToken, void(boost::system::error_code)>(
            [this](auto&& completion_handler, TLS::Connection_Side connection_side) {
               using completion_handler_t = std::decay_t<decltype(completion_handler)>;
 
               BOOST_ASIO_HANDSHAKE_HANDLER_CHECK(completion_handler_t, completion_handler) type_check;
 
               boost::system::error_code ec;
               setup_native_handle(connection_side, ec);
 
               detail::AsyncHandshakeOperation<completion_handler_t, Stream> op{
                  std::forward<completion_handler_t>(completion_handler), *this, ec};
            },
            completion_token,
            side);
      }

References Botan::TLS::Stream< StreamLayer, ChannelT >::setup_native_handle().

◆ async_handshake() [2/2]

template<class StreamLayer , class ChannelT = Channel>

template<typename ConstBufferSequence , typename BufferedHandshakeHandler >

Botan::TLS::Stream< StreamLayer, ChannelT >::async_handshake	(	Connection_Side	side,
		const ConstBufferSequence &	buffers,
		BufferedHandshakeHandler &&	handler
	)

inline

Exceptions

Not_Implemented

Definition at line 274 of file asio_stream.h.

                                                                                                                    {
         BOTAN_UNUSED(side, buffers, handler);
         BOOST_ASIO_HANDSHAKE_HANDLER_CHECK(BufferedHandshakeHandler, handler) type_check;
         throw Not_Implemented("buffered async handshake is not implemented");
      }

References BOTAN_UNUSED.

◆ async_read_some()

template<class StreamLayer , class ChannelT = Channel>

template<typename MutableBufferSequence , typename CompletionToken >

auto Botan::TLS::Stream< StreamLayer, ChannelT >::async_read_some	(	const MutableBufferSequence &	buffers,
		CompletionToken &&	completion_token
	)

inline

Start an asynchronous read. The function call always returns immediately.

Parameters

buffers	The buffers into which the data will be read. Although the buffers object may be copied as necessary, ownership of the underlying buffers is retained by the caller, which must guarantee that they remain valid until the handler is called.
completion_token	The completion handler to be called when the read operation completes. The completion signature of the handler must be: void(boost::system::error_code, std::size_t).

Definition at line 517 of file asio_stream.h.

                                                                                                     {
         return boost::asio::async_initiate<CompletionToken, void(boost::system::error_code, std::size_t)>(
            [this](auto&& completion_handler, const auto& bufs) {
               using completion_handler_t = std::decay_t<decltype(completion_handler)>;
 
               BOOST_ASIO_READ_HANDLER_CHECK(completion_handler_t, completion_handler) type_check;
 
               detail::AsyncReadOperation<completion_handler_t, Stream, MutableBufferSequence> op{
                  std::forward<completion_handler_t>(completion_handler), *this, bufs};
            },
            completion_token,
            buffers);
      }

◆ async_shutdown()

template<class StreamLayer , class ChannelT = Channel>

template<typename CompletionToken >

auto Botan::TLS::Stream< StreamLayer, ChannelT >::async_shutdown ( CompletionToken && completion_token )

inline

Asynchronously shut down SSL on the stream.

This function call always returns immediately.

Note that this can be used in reaction of a received shutdown alert from the peer.

Parameters

completion_token The completion handler to be called when the shutdown operation completes. The completion signature of the handler must be: void(boost::system::error_code).

Definition at line 354 of file asio_stream.h.

                                                              {
         return boost::asio::async_initiate<CompletionToken, void(boost::system::error_code)>(
            [this](auto&& completion_handler) {
               using completion_handler_t = std::decay_t<decltype(completion_handler)>;
 
               BOOST_ASIO_SHUTDOWN_HANDLER_CHECK(completion_handler_t, completion_handler) type_check;
 
               boost::system::error_code ec;
               try_with_error_code([&] { native_handle()->close(); }, ec);
 
               using write_handler_t = Wrapper<completion_handler_t, typename Stream::executor_type>;
 
               TLS::detail::AsyncWriteOperation<write_handler_t, Stream> op{
                  write_handler_t{std::forward<completion_handler_t>(completion_handler), get_executor()},
                  *this,
                  boost::asio::buffer_size(send_buffer()),
                  ec};
            },
            completion_token);
      }

References Botan::TLS::Stream< StreamLayer, ChannelT >::get_executor(), Botan::TLS::Stream< StreamLayer, ChannelT >::native_handle(), Botan::TLS::Stream< StreamLayer, ChannelT >::send_buffer(), and Botan::TLS::Stream< StreamLayer, ChannelT >::try_with_error_code().

◆ async_write_some()

template<class StreamLayer , class ChannelT = Channel>

template<typename ConstBufferSequence , typename CompletionToken >

auto Botan::TLS::Stream< StreamLayer, ChannelT >::async_write_some	(	const ConstBufferSequence &	buffers,
		CompletionToken &&	completion_token
	)

inline

Start an asynchronous write. The function call always returns immediately.

Parameters

buffers	The data to be written.
completion_token	The completion handler to be called when the write operation completes. Copies of the handler will be made as required. The completion signature of the handler must be: void(boost::system::error_code, std::size_t).

Definition at line 481 of file asio_stream.h.

                                                                                                    {
         return boost::asio::async_initiate<CompletionToken, void(boost::system::error_code, std::size_t)>(
            [this](auto&& completion_handler, const auto& bufs) {
               using completion_handler_t = std::decay_t<decltype(completion_handler)>;
 
               BOOST_ASIO_WRITE_HANDLER_CHECK(completion_handler_t, completion_handler) type_check;
 
               boost::system::error_code ec;
               tls_encrypt(bufs, ec);
 
               if(ec) {
                  // we cannot be sure how many bytes were committed here so clear the send_buffer and let the
                  // AsyncWriteOperation call the handler with the error_code set
                  consume_send_buffer(m_core->send_buffer.size());
               }
 
               detail::AsyncWriteOperation<completion_handler_t, Stream> op{
                  std::forward<completion_handler_t>(completion_handler),
                  *this,
                  ec ? 0 : boost::asio::buffer_size(bufs),
                  ec};
            },
            completion_token,
            buffers);
      }

References Botan::TLS::Stream< StreamLayer, ChannelT >::consume_send_buffer(), Botan::TLS::Stream< StreamLayer, ChannelT >::m_core, and Botan::TLS::Stream< StreamLayer, ChannelT >::tls_encrypt().

◆ consume_send_buffer()

template<class StreamLayer , class ChannelT = Channel>

void Botan::TLS::Stream< StreamLayer, ChannelT >::consume_send_buffer ( std::size_t bytesConsumed )

inlineprotected

Mark bytes in the send buffer as consumed, removing them from the buffer.

Definition at line 633 of file asio_stream.h.

633{ m_core->send_buffer.consume(bytesConsumed); }

References Botan::TLS::Stream< StreamLayer, ChannelT >::m_core.

Referenced by Botan::TLS::Stream< StreamLayer, ChannelT >::async_write_some(), Botan::TLS::detail::AsyncWriteOperation< Handler, Stream, Allocator >::operator()(), and Botan::TLS::Stream< StreamLayer, ChannelT >::send_pending_encrypted_data().

◆ copy_received_data()

template<class StreamLayer , class ChannelT = Channel>

template<typename MutableBufferSequence >

std::size_t Botan::TLS::Stream< StreamLayer, ChannelT >::copy_received_data ( MutableBufferSequence buffers )

inlineprotected

Copy decrypted data into the user-provided buffer.

Definition at line 619 of file asio_stream.h.

                                                                  {
         // Note: It would be nice to avoid this buffer copy. This could be achieved by equipping the StreamCore with
         // the user's desired target buffer once a read is started, and reading directly into that buffer in tls_record
         // received. However, we need to deal with the case that the receive buffer provided by the caller is smaller
         // than the decrypted record, so this optimization might not be worth the additional complexity.
         const auto copiedBytes = boost::asio::buffer_copy(buffers, m_core->receive_buffer.data());
         m_core->receive_buffer.consume(copiedBytes);
         return copiedBytes;
      }

References Botan::TLS::Stream< StreamLayer, ChannelT >::m_core.

Referenced by Botan::TLS::detail::AsyncReadOperation< Handler, Stream, MutableBufferSequence, Allocator >::operator()(), and Botan::TLS::Stream< StreamLayer, ChannelT >::read_some().

◆ get_executor()

template<class StreamLayer , class ChannelT = Channel>

executor_type Botan::TLS::Stream< StreamLayer, ChannelT >::get_executor ( )

inlinenoexcept

Definition at line 125 of file asio_stream.h.

125{ return m_nextLayer.get_executor(); }

References Botan::TLS::Stream< StreamLayer, ChannelT >::m_nextLayer.

Referenced by Botan::TLS::Stream< StreamLayer, ChannelT >::async_shutdown().

◆ handshake() [1/2]

template<class StreamLayer , class ChannelT = Channel>

void Botan::TLS::Stream< StreamLayer, ChannelT >::handshake ( Connection_Side side )

inline

Performs SSL handshaking.

The function call will block until handshaking is complete or an error occurs.

Parameters

side	The type of handshaking to be performed, i.e. as a client or as a server.

Exceptions

boost::system::system_error if error occured

Definition at line 210 of file asio_stream.h.

                                           {
         boost::system::error_code ec;
         handshake(side, ec);
         boost::asio::detail::throw_error(ec, "handshake");
      }

References Botan::TLS::Stream< StreamLayer, ChannelT >::handshake().

Referenced by Botan::TLS::Stream< StreamLayer, ChannelT >::handshake().

◆ handshake() [2/2]

template<class StreamLayer , class ChannelT = Channel>

void Botan::TLS::Stream< StreamLayer, ChannelT >::handshake	(	Connection_Side	side,
		boost::system::error_code &	ec
	)

inline

Performs SSL handshaking.

The function call will block until handshaking is complete or an error occurs.

Parameters

side	The type of handshaking to be performed, i.e. as a client or as a server.
ec	Set to indicate what error occurred, if any.

Definition at line 224 of file asio_stream.h.

                                                                      {
         setup_native_handle(side, ec);
 
         if(side == Connection_Side::Client) {
            // send client hello, which was written to the send buffer on client instantiation
            send_pending_encrypted_data(ec);
         }
 
         while(!native_handle()->is_active() && !ec) {
            boost::asio::const_buffer read_buffer{input_buffer().data(), m_nextLayer.read_some(input_buffer(), ec)};
            if(ec) {
               return;
            }
 
            process_encrypted_data(read_buffer, ec);
 
            send_pending_encrypted_data(ec);
         }
      }

References Botan::TLS::Client, Botan::TLS::Stream< StreamLayer, ChannelT >::input_buffer(), Botan::TLS::Stream< StreamLayer, ChannelT >::m_nextLayer, Botan::TLS::Stream< StreamLayer, ChannelT >::native_handle(), Botan::TLS::Stream< StreamLayer, ChannelT >::process_encrypted_data(), Botan::TLS::Stream< StreamLayer, ChannelT >::send_pending_encrypted_data(), and Botan::TLS::Stream< StreamLayer, ChannelT >::setup_native_handle().

◆ has_data_to_send()

template<class StreamLayer , class ChannelT = Channel>

bool Botan::TLS::Stream< StreamLayer, ChannelT >::has_data_to_send ( ) const

inlineprotected

Check if encrypted data is available in the send buffer.

Definition at line 630 of file asio_stream.h.

630{ return m_core->send_buffer.size() > 0; }

References Botan::TLS::Stream< StreamLayer, ChannelT >::m_core.

Referenced by Botan::TLS::detail::AsyncWriteOperation< Handler, Stream, Allocator >::operator()(), and Botan::TLS::detail::AsyncHandshakeOperation< Handler, Stream, Allocator >::operator()().

◆ has_received_data()

template<class StreamLayer , class ChannelT = Channel>

bool Botan::TLS::Stream< StreamLayer, ChannelT >::has_received_data ( ) const

inlineprotected

Check if decrypted data is available in the receive buffer.

Definition at line 615 of file asio_stream.h.

615{ return m_core->receive_buffer.size() > 0; }

References Botan::TLS::Stream< StreamLayer, ChannelT >::m_core.

Referenced by Botan::TLS::detail::AsyncReadOperation< Handler, Stream, MutableBufferSequence, Allocator >::operator()(), and Botan::TLS::Stream< StreamLayer, ChannelT >::read_some().

◆ input_buffer()

template<class StreamLayer , class ChannelT = Channel>

const boost::asio::mutable_buffer & Botan::TLS::Stream< StreamLayer, ChannelT >::input_buffer ( )

inlineprotected

Definition at line 610 of file asio_stream.h.

610{ return m_input_buffer; }

References Botan::TLS::Stream< StreamLayer, ChannelT >::m_input_buffer.

Referenced by Botan::TLS::Stream< StreamLayer, ChannelT >::handshake(), Botan::TLS::detail::AsyncReadOperation< Handler, Stream, MutableBufferSequence, Allocator >::operator()(), Botan::TLS::detail::AsyncHandshakeOperation< Handler, Stream, Allocator >::operator()(), and Botan::TLS::Stream< StreamLayer, ChannelT >::read_some().

◆ lowest_layer() [1/2]

template<class StreamLayer , class ChannelT = Channel>

lowest_layer_type & Botan::TLS::Stream< StreamLayer, ChannelT >::lowest_layer ( )

inline

Definition at line 118 of file asio_stream.h.

118{ return m_nextLayer.lowest_layer(); }

References Botan::TLS::Stream< StreamLayer, ChannelT >::m_nextLayer.

◆ lowest_layer() [2/2]

template<class StreamLayer , class ChannelT = Channel>

const lowest_layer_type & Botan::TLS::Stream< StreamLayer, ChannelT >::lowest_layer ( ) const

inline

Definition at line 120 of file asio_stream.h.

120{ return m_nextLayer.lowest_layer(); }

References Botan::TLS::Stream< StreamLayer, ChannelT >::m_nextLayer.

◆ native_handle()

template<class StreamLayer , class ChannelT = Channel>

native_handle_type Botan::TLS::Stream< StreamLayer, ChannelT >::native_handle ( )

inline

Definition at line 129 of file asio_stream.h.

                                         {
         if(m_native_handle == nullptr) {
            throw Invalid_State("Invalid handshake state");
         }
         return m_native_handle.get();
      }

References Botan::TLS::Stream< StreamLayer, ChannelT >::m_native_handle.

Referenced by Botan::TLS::Stream< StreamLayer, ChannelT >::async_shutdown(), Botan::TLS::Stream< StreamLayer, ChannelT >::handshake(), Botan::TLS::detail::AsyncHandshakeOperation< Handler, Stream, Allocator >::operator()(), Botan::TLS::Stream< StreamLayer, ChannelT >::process_encrypted_data(), Botan::TLS::Stream< StreamLayer, ChannelT >::shutdown(), and Botan::TLS::Stream< StreamLayer, ChannelT >::tls_encrypt().

◆ next_layer() [1/2]

template<class StreamLayer , class ChannelT = Channel>

next_layer_type & Botan::TLS::Stream< StreamLayer, ChannelT >::next_layer ( )

inline

Definition at line 102 of file asio_stream.h.

102{ return m_nextLayer; }

References Botan::TLS::Stream< StreamLayer, ChannelT >::m_nextLayer.

◆ next_layer() [2/2]

template<class StreamLayer , class ChannelT = Channel>

const next_layer_type & Botan::TLS::Stream< StreamLayer, ChannelT >::next_layer ( ) const

inline

Definition at line 100 of file asio_stream.h.

100{ return m_nextLayer; }

References Botan::TLS::Stream< StreamLayer, ChannelT >::m_nextLayer.

Referenced by Botan::TLS::detail::AsyncReadOperation< Handler, Stream, MutableBufferSequence, Allocator >::operator()(), Botan::TLS::detail::AsyncWriteOperation< Handler, Stream, Allocator >::operator()(), and Botan::TLS::detail::AsyncHandshakeOperation< Handler, Stream, Allocator >::operator()().

◆ operator=() [1/2]

template<class StreamLayer , class ChannelT = Channel>

Stream & Botan::TLS::Stream< StreamLayer, ChannelT >::operator= ( const Stream< StreamLayer, ChannelT > & other )

delete

◆ operator=() [2/2]

template<class StreamLayer , class ChannelT = Channel>

Stream & Botan::TLS::Stream< StreamLayer, ChannelT >::operator= ( Stream< StreamLayer, ChannelT > && other )

default

◆ process_encrypted_data()

template<class StreamLayer , class ChannelT = Channel>

void Botan::TLS::Stream< StreamLayer, ChannelT >::process_encrypted_data	(	const boost::asio::const_buffer &	read_buffer,
		boost::system::error_code &	ec
	)

inlineprotected

Pass encrypted data to the native handle for processing.

If an exception occurs while processing the data, an error code will be set.

Parameters

read_buffer	Input buffer containing the encrypted data.
ec	Set to indicate what error occurred, if any.

Definition at line 728 of file asio_stream.h.

                                                                                                       {
         try_with_error_code(
            [&] {
               native_handle()->received_data({static_cast<const uint8_t*>(read_buffer.data()), read_buffer.size()});
            },
            ec);
      }

References Botan::TLS::Stream< StreamLayer, ChannelT >::native_handle(), and Botan::TLS::Stream< StreamLayer, ChannelT >::try_with_error_code().

Referenced by Botan::TLS::Stream< StreamLayer, ChannelT >::handshake(), Botan::TLS::detail::AsyncReadOperation< Handler, Stream, MutableBufferSequence, Allocator >::operator()(), Botan::TLS::detail::AsyncHandshakeOperation< Handler, Stream, Allocator >::operator()(), and Botan::TLS::Stream< StreamLayer, ChannelT >::read_some().

◆ read_some() [1/2]

template<class StreamLayer , class ChannelT = Channel>

template<typename MutableBufferSequence >

std::size_t Botan::TLS::Stream< StreamLayer, ChannelT >::read_some ( const MutableBufferSequence & buffers )

inline

Read some data from the stream.

The function call will block until one or more bytes of data has been read successfully, or until an error occurs.

Parameters

buffers The buffers into which the data will be read.

Returns: The number of bytes read. Returns 0 if an error occurred.

Exceptions

boost::system::system_error if error occured

Definition at line 430 of file asio_stream.h.

                                                                {
         boost::system::error_code ec;
         const auto n = read_some(buffers, ec);
         boost::asio::detail::throw_error(ec, "read_some");
         return n;
      }

References Botan::TLS::Stream< StreamLayer, ChannelT >::read_some().

◆ read_some() [2/2]

template<class StreamLayer , class ChannelT = Channel>

template<typename MutableBufferSequence >

std::size_t Botan::TLS::Stream< StreamLayer, ChannelT >::read_some	(	const MutableBufferSequence &	buffers,
		boost::system::error_code &	ec
	)

inline

Read some data from the stream.

The function call will block until one or more bytes of data has been read successfully, or until an error occurs.

Parameters

buffers	The buffers into which the data will be read.
ec	Set to indicate what error occurred, if any. Specifically, StreamTruncated will be set if the peer has closed the connection but did not properly shut down the SSL connection.

Returns: The number of bytes read. Returns 0 if an error occurred.

Definition at line 391 of file asio_stream.h.

                                                                                           {
         if(has_received_data()) {
            return copy_received_data(buffers);
         }
 
         boost::asio::const_buffer read_buffer{input_buffer().data(), m_nextLayer.read_some(input_buffer(), ec)};
         if(ec) {
            return 0;
         }
 
         process_encrypted_data(read_buffer, ec);
 
         if(ec)  // something went wrong in process_encrypted_data()
         {
            return 0;
         }
 
         if(shutdown_received()) {
            // we just received a 'close_notify' from the peer and don't expect any more data
            ec = boost::asio::error::eof;
         } else if(ec == boost::asio::error::eof) {
            // we did not expect this disconnection from the peer
            ec = StreamError::StreamTruncated;
         }
 
         return !ec ? copy_received_data(buffers) : 0;
      }

References Botan::TLS::Stream< StreamLayer, ChannelT >::copy_received_data(), Botan::TLS::Stream< StreamLayer, ChannelT >::has_received_data(), Botan::TLS::Stream< StreamLayer, ChannelT >::input_buffer(), Botan::TLS::Stream< StreamLayer, ChannelT >::m_nextLayer, Botan::TLS::Stream< StreamLayer, ChannelT >::process_encrypted_data(), Botan::TLS::Stream< StreamLayer, ChannelT >::shutdown_received(), and Botan::TLS::StreamTruncated.

Referenced by Botan::TLS::Stream< StreamLayer, ChannelT >::read_some().

◆ send_buffer()

template<class StreamLayer , class ChannelT = Channel>

boost::asio::const_buffer Botan::TLS::Stream< StreamLayer, ChannelT >::send_buffer ( ) const

inlineprotected

Definition at line 612 of file asio_stream.h.

612{ return m_core->send_buffer.data(); }

References Botan::TLS::Stream< StreamLayer, ChannelT >::m_core.

Referenced by Botan::TLS::Stream< StreamLayer, ChannelT >::async_shutdown(), Botan::TLS::detail::AsyncWriteOperation< Handler, Stream, Allocator >::operator()(), and Botan::TLS::Stream< StreamLayer, ChannelT >::send_pending_encrypted_data().

◆ send_pending_encrypted_data()

template<class StreamLayer , class ChannelT = Channel>

size_t Botan::TLS::Stream< StreamLayer, ChannelT >::send_pending_encrypted_data ( boost::system::error_code & ec )

inlineprotected

Synchronously write encrypted data from the send buffer to the next layer.

If this function is called with an error code other than 'Success', it will do nothing and return 0.

Parameters

ec	Set to indicate what error occurred, if any. Specifically, StreamTruncated will be set if the peer has closed the connection but did not properly shut down the SSL connection.

Returns: The number of bytes written.

Definition at line 682 of file asio_stream.h.

                                                                    {
         if(ec) {
            return 0;
         }
 
         auto writtenBytes = boost::asio::write(m_nextLayer, send_buffer(), ec);
         consume_send_buffer(writtenBytes);
 
         if(ec == boost::asio::error::eof && !shutdown_received()) {
            // transport layer was closed by peer without receiving 'close_notify'
            ec = StreamError::StreamTruncated;
         }
 
         return writtenBytes;
      }

References Botan::TLS::Stream< StreamLayer, ChannelT >::consume_send_buffer(), Botan::TLS::Stream< StreamLayer, ChannelT >::m_nextLayer, Botan::TLS::Stream< StreamLayer, ChannelT >::send_buffer(), Botan::TLS::Stream< StreamLayer, ChannelT >::shutdown_received(), and Botan::TLS::StreamTruncated.

Referenced by Botan::TLS::Stream< StreamLayer, ChannelT >::handshake(), Botan::TLS::Stream< StreamLayer, ChannelT >::shutdown(), and Botan::TLS::Stream< StreamLayer, ChannelT >::write_some().

◆ set_verify_callback() [1/2]

template<class StreamLayer , class ChannelT = Channel>

void Botan::TLS::Stream< StreamLayer, ChannelT >::set_verify_callback ( Context::Verify_Callback callback )

inline

Override the tls_verify_cert_chain callback.

This changes the verify_callback in the stream's TLS::Context, and hence the tls_verify_cert_chain callback used in the handshake. Using this function is equivalent to setting the callback via

See also: Botan::TLS::Context::set_verify_callback

Note: This function should only be called before initiating the TLS handshake

Definition at line 149 of file asio_stream.h.

                                                                {
         m_context->set_verify_callback(std::move(callback));
      }

References Botan::TLS::Stream< StreamLayer, ChannelT >::m_context.

◆ set_verify_callback() [2/2]

template<class StreamLayer , class ChannelT = Channel>

void Botan::TLS::Stream< StreamLayer, ChannelT >::set_verify_callback	(	Context::Verify_Callback	callback,
		boost::system::error_code &	ec
	)

inline

Compatibility overload of set_verify_callback.

Parameters

callback	the callback implementation
ec	This parameter is unused.

Definition at line 159 of file asio_stream.h.

                                                                                           {
         BOTAN_UNUSED(ec);
         m_context->set_verify_callback(std::move(callback));
      }

References BOTAN_UNUSED, and Botan::TLS::Stream< StreamLayer, ChannelT >::m_context.

◆ set_verify_depth() [1/2]

template<class StreamLayer , class ChannelT = Channel>

void Botan::TLS::Stream< StreamLayer, ChannelT >::set_verify_depth ( int depth )

inline

Exceptions

Not_Implemented

Definition at line 165 of file asio_stream.h.

                                       {
         BOTAN_UNUSED(depth);
         throw Not_Implemented("set_verify_depth is not implemented");
      }

References BOTAN_UNUSED.

◆ set_verify_depth() [2/2]

template<class StreamLayer , class ChannelT = Channel>

void Botan::TLS::Stream< StreamLayer, ChannelT >::set_verify_depth	(	int	depth,
		boost::system::error_code &	ec
	)

inline

Not Implemented.

Parameters

depth	the desired verification depth
ec	Will be set to `Botan::ErrorType::NotImplemented`

Definition at line 175 of file asio_stream.h.

                                                                  {
         BOTAN_UNUSED(depth);
         ec = ErrorType::NotImplemented;
      }

References BOTAN_UNUSED, and Botan::NotImplemented.

◆ set_verify_mode() [1/2]

template<class StreamLayer , class ChannelT = Channel>

template<typename verify_mode >

void Botan::TLS::Stream< StreamLayer, ChannelT >::set_verify_mode ( verify_mode v )

inline

Exceptions

Not_Implemented

Definition at line 182 of file asio_stream.h.

                                          {
         BOTAN_UNUSED(v);
         throw Not_Implemented("set_verify_mode is not implemented");
      }

References BOTAN_UNUSED.

◆ set_verify_mode() [2/2]

template<class StreamLayer , class ChannelT = Channel>

template<typename verify_mode >

void Botan::TLS::Stream< StreamLayer, ChannelT >::set_verify_mode	(	verify_mode	v,
		boost::system::error_code &	ec
	)

inline

Not Implemented.

Parameters

v	the desired verify mode
ec	Will be set to `Botan::ErrorType::NotImplemented`

Definition at line 193 of file asio_stream.h.

                                                                     {
         BOTAN_UNUSED(v);
         ec = ErrorType::NotImplemented;
      }

References BOTAN_UNUSED, and Botan::NotImplemented.

◆ setup_native_handle()

template<class StreamLayer , class ChannelT = Channel>

void Botan::TLS::Stream< StreamLayer, ChannelT >::setup_native_handle	(	Connection_Side	side,
		boost::system::error_code &	ec
	)

inlineprotected

Create the native handle.

Depending on the desired connection side, this function will create a TLS::Client or a TLS::Server.

Parameters

side	The desired connection side (client or server)
ec	Set to indicate what error occurred, if any.

Definition at line 644 of file asio_stream.h.

                                                                                {
         BOTAN_UNUSED(side);  // workaround: GCC 9 produces a warning claiming side is unused
 
         // Do not attempt to instantiate the native_handle when a custom (mocked) channel type template parameter has
         // been specified. This allows mocking the native_handle in test code.
         if constexpr(std::is_same<ChannelT, Channel>::value) {
            try_with_error_code(
               [&] {
                  if(side == Connection_Side::Client) {
                     m_native_handle = std::unique_ptr<Client>(
                        new Client(m_core,
                                   m_context->m_session_manager,
                                   m_context->m_credentials_manager,
                                   m_context->m_policy,
                                   m_context->m_rng,
                                   m_context->m_server_info,
                                   m_context->m_policy->latest_supported_version(false /* no DTLS */)));
                  } else {
                     m_native_handle = std::unique_ptr<Server>(new Server(m_core,
                                                                          m_context->m_session_manager,
                                                                          m_context->m_credentials_manager,
                                                                          m_context->m_policy,
                                                                          m_context->m_rng,
                                                                          false /* no DTLS */));
                  }
               },
               ec);
         }
      }

References BOTAN_UNUSED, Botan::TLS::Client, Botan::TLS::Stream< StreamLayer, ChannelT >::m_context, Botan::TLS::Stream< StreamLayer, ChannelT >::m_core, Botan::TLS::Stream< StreamLayer, ChannelT >::m_native_handle, and Botan::TLS::Stream< StreamLayer, ChannelT >::try_with_error_code().

Referenced by Botan::TLS::Stream< StreamLayer, ChannelT >::async_handshake(), and Botan::TLS::Stream< StreamLayer, ChannelT >::handshake().

◆ shutdown() [1/2]

template<class StreamLayer , class ChannelT = Channel>

void Botan::TLS::Stream< StreamLayer, ChannelT >::shutdown ( )

inline

Shut down SSL on the stream.

This function is used to shut down SSL on the stream. The function call will block until SSL has been shut down or an error occurs. Note that this will not close the lowest layer.

Note that this can be used in reaction of a received shutdown alert from the peer.

Exceptions

boost::system::system_error if error occured

Definition at line 310 of file asio_stream.h.

                      {
         boost::system::error_code ec;
         shutdown(ec);
         boost::asio::detail::throw_error(ec, "shutdown");
      }

References Botan::TLS::Stream< StreamLayer, ChannelT >::shutdown().

Referenced by Botan::TLS::Stream< StreamLayer, ChannelT >::shutdown().

◆ shutdown() [2/2]

template<class StreamLayer , class ChannelT = Channel>

void Botan::TLS::Stream< StreamLayer, ChannelT >::shutdown ( boost::system::error_code & ec )

inline

Shut down SSL on the stream.

This function is used to shut down SSL on the stream. The function call will block until SSL has been shut down or an error occurs. Note that this will not close the lowest layer.

Note that this can be used in reaction of a received shutdown alert from the peer.

Parameters

ec	Set to indicate what error occured, if any.

Definition at line 294 of file asio_stream.h.

                                               {
         try_with_error_code([&] { native_handle()->close(); }, ec);
 
         send_pending_encrypted_data(ec);
      }

References Botan::TLS::Stream< StreamLayer, ChannelT >::native_handle(), Botan::TLS::Stream< StreamLayer, ChannelT >::send_pending_encrypted_data(), and Botan::TLS::Stream< StreamLayer, ChannelT >::try_with_error_code().

◆ shutdown_received()

template<class StreamLayer , class ChannelT = Channel>

bool Botan::TLS::Stream< StreamLayer, ChannelT >::shutdown_received ( ) const

inline

Indicates whether a close_notify alert has been received from the peer.

Note that we cannot m_core.is_closed_for_reading() because this wants to explicitly check that the peer sent close_notify.

Definition at line 537 of file asio_stream.h.

537{ return m_core->shutdown_received; }

References Botan::TLS::Stream< StreamLayer, ChannelT >::m_core.

Referenced by Botan::TLS::detail::AsyncReadOperation< Handler, Stream, MutableBufferSequence, Allocator >::operator()(), Botan::TLS::detail::AsyncWriteOperation< Handler, Stream, Allocator >::operator()(), Botan::TLS::Stream< StreamLayer, ChannelT >::read_some(), and Botan::TLS::Stream< StreamLayer, ChannelT >::send_pending_encrypted_data().

◆ tls_encrypt()

template<class StreamLayer , class ChannelT = Channel>

template<typename ConstBufferSequence >

void Botan::TLS::Stream< StreamLayer, ChannelT >::tls_encrypt	(	const ConstBufferSequence &	buffers,
		boost::system::error_code &	ec
	)

inlineprotected

Pass plaintext data to the native handle for processing.

The native handle will then create TLS records and hand them back to the Stream via the tls_emit_data callback.

Definition at line 704 of file asio_stream.h.

                                                                                      {
         // NOTE: This is not asynchronous: it encrypts the data synchronously.
         // The data encrypted by native_handle()->send() is synchronously stored in the send_buffer of m_core,
         // but is not actually written to the wire, yet.
         for(auto it = boost::asio::buffer_sequence_begin(buffers);
             !ec && it != boost::asio::buffer_sequence_end(buffers);
             it++) {
            const boost::asio::const_buffer buffer = *it;
            try_with_error_code(
               [&] {
                  native_handle()->send({static_cast<const uint8_t*>(buffer.data()), buffer.size()});
               },
               ec);
         }
      }

References Botan::TLS::Stream< StreamLayer, ChannelT >::native_handle(), and Botan::TLS::Stream< StreamLayer, ChannelT >::try_with_error_code().

Referenced by Botan::TLS::Stream< StreamLayer, ChannelT >::async_write_some(), and Botan::TLS::Stream< StreamLayer, ChannelT >::write_some().

◆ try_with_error_code()

template<class StreamLayer , class ChannelT = Channel>

template<typename Fun >

void Botan::TLS::Stream< StreamLayer, ChannelT >::try_with_error_code	(	Fun	f,
		boost::system::error_code &	ec
	)

inlineprotected

Catch exceptions and set an error_code.

Definition at line 738 of file asio_stream.h.

                                                                 {
         try {
            f();
         } catch(const TLS_Exception& e) {
            ec = e.type();
         } catch(const Exception& e) {
            ec = e.error_type();
         } catch(const std::exception&) {
            ec = ErrorType::Unknown;
         }
      }

References Botan::TLS::TLS_Exception::error_type(), Botan::TLS::TLS_Exception::type(), and Botan::Unknown.

Referenced by Botan::TLS::Stream< StreamLayer, ChannelT >::async_shutdown(), Botan::TLS::Stream< StreamLayer, ChannelT >::process_encrypted_data(), Botan::TLS::Stream< StreamLayer, ChannelT >::setup_native_handle(), Botan::TLS::Stream< StreamLayer, ChannelT >::shutdown(), and Botan::TLS::Stream< StreamLayer, ChannelT >::tls_encrypt().

◆ write_some() [1/2]

template<class StreamLayer , class ChannelT = Channel>

template<typename ConstBufferSequence >

std::size_t Botan::TLS::Stream< StreamLayer, ChannelT >::write_some ( const ConstBufferSequence & buffers )

inline

Write some data to the stream.

The function call will block until one or more bytes of data has been written successfully, or until an error occurs.

Parameters

buffers The data to be written.

Returns: The number of bytes written.

Exceptions

boost::system::system_error if error occured

Definition at line 465 of file asio_stream.h.

                                                               {
         boost::system::error_code ec;
         const auto n = write_some(buffers, ec);
         boost::asio::detail::throw_error(ec, "write_some");
         return n;
      }

References Botan::TLS::Stream< StreamLayer, ChannelT >::write_some().

◆ write_some() [2/2]

template<class StreamLayer , class ChannelT = Channel>

template<typename ConstBufferSequence >

std::size_t Botan::TLS::Stream< StreamLayer, ChannelT >::write_some	(	const ConstBufferSequence &	buffers,
		boost::system::error_code &	ec
	)

inline

Write some data to the stream.

The function call will block until one or more bytes of data has been written successfully, or until an error occurs.

Parameters

buffers	The data to be written.
ec	Set to indicate what error occurred, if any.

Returns: The number of bytes processed from the input buffers.

Definition at line 448 of file asio_stream.h.

                                                                                          {
         tls_encrypt(buffers, ec);
         send_pending_encrypted_data(ec);
         return !ec ? boost::asio::buffer_size(buffers) : 0;
      }

References Botan::TLS::Stream< StreamLayer, ChannelT >::send_pending_encrypted_data(), and Botan::TLS::Stream< StreamLayer, ChannelT >::tls_encrypt().

Referenced by Botan::TLS::Stream< StreamLayer, ChannelT >::write_some().

Friends And Related Symbol Documentation

◆ detail::AsyncHandshakeOperation

template<class StreamLayer , class ChannelT = Channel>

template<class H , class S , class A >

friend class detail::AsyncHandshakeOperation

friend

Definition at line 545 of file asio_stream.h.

◆ detail::AsyncReadOperation

template<class StreamLayer , class ChannelT = Channel>

template<class H , class S , class M , class A >

friend class detail::AsyncReadOperation

friend

Definition at line 541 of file asio_stream.h.

◆ detail::AsyncWriteOperation

template<class StreamLayer , class ChannelT = Channel>

template<class H , class S , class A >

friend class detail::AsyncWriteOperation

friend

Definition at line 543 of file asio_stream.h.

Member Data Documentation

◆ m_context

template<class StreamLayer , class ChannelT = Channel>

std::shared_ptr<Context> Botan::TLS::Stream< StreamLayer, ChannelT >::m_context

protected

Definition at line 750 of file asio_stream.h.

Referenced by Botan::TLS::Stream< StreamLayer, ChannelT >::set_verify_callback(), Botan::TLS::Stream< StreamLayer, ChannelT >::set_verify_callback(), and Botan::TLS::Stream< StreamLayer, ChannelT >::setup_native_handle().

◆ m_core

template<class StreamLayer , class ChannelT = Channel>

std::shared_ptr<StreamCore> Botan::TLS::Stream< StreamLayer, ChannelT >::m_core

protected

Definition at line 753 of file asio_stream.h.

◆ m_input_buffer

template<class StreamLayer , class ChannelT = Channel>

const boost::asio::mutable_buffer Botan::TLS::Stream< StreamLayer, ChannelT >::m_input_buffer

protected

Definition at line 758 of file asio_stream.h.

Referenced by Botan::TLS::Stream< StreamLayer, ChannelT >::input_buffer().

◆ m_input_buffer_space

template<class StreamLayer , class ChannelT = Channel>

std::vector<uint8_t> Botan::TLS::Stream< StreamLayer, ChannelT >::m_input_buffer_space

protected

Definition at line 757 of file asio_stream.h.

◆ m_native_handle

template<class StreamLayer , class ChannelT = Channel>

std::unique_ptr<ChannelT> Botan::TLS::Stream< StreamLayer, ChannelT >::m_native_handle

protected

Definition at line 754 of file asio_stream.h.

Referenced by Botan::TLS::Stream< StreamLayer, ChannelT >::native_handle(), and Botan::TLS::Stream< StreamLayer, ChannelT >::setup_native_handle().

◆ m_nextLayer

template<class StreamLayer , class ChannelT = Channel>

StreamLayer Botan::TLS::Stream< StreamLayer, ChannelT >::m_nextLayer

protected

Definition at line 751 of file asio_stream.h.

The documentation for this class was generated from the following file:

src/lib/tls/asio/asio_stream.h

Classes

Public Member Functions

Protected Member Functions

Protected Attributes

Friends

boost::asio accessor methods

Detailed Description

Member Typedef Documentation

◆ executor_type

◆ lowest_layer_type

◆ native_handle_type

◆ next_layer_type

Constructor & Destructor Documentation

◆ Stream() [1/4]

◆ Stream() [2/4]

◆ ~Stream()

◆ Stream() [3/4]

◆ Stream() [4/4]

Member Function Documentation

◆ async_handshake() [1/2]

◆ async_handshake() [2/2]

◆ async_read_some()

◆ async_shutdown()

◆ async_write_some()

◆ consume_send_buffer()

◆ copy_received_data()

◆ get_executor()

◆ handshake() [1/2]

◆ handshake() [2/2]

◆ has_data_to_send()

◆ has_received_data()

◆ input_buffer()

◆ lowest_layer() [1/2]

◆ lowest_layer() [2/2]

◆ native_handle()

◆ next_layer() [1/2]

◆ next_layer() [2/2]

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ process_encrypted_data()

◆ read_some() [1/2]

◆ read_some() [2/2]

◆ send_buffer()

◆ send_pending_encrypted_data()

◆ set_verify_callback() [1/2]

◆ set_verify_callback() [2/2]

◆ set_verify_depth() [1/2]

◆ set_verify_depth() [2/2]

◆ set_verify_mode() [1/2]

◆ set_verify_mode() [2/2]

◆ setup_native_handle()

◆ shutdown() [1/2]

◆ shutdown() [2/2]

◆ shutdown_received()

◆ tls_encrypt()

◆ try_with_error_code()

◆ write_some() [1/2]

◆ write_some() [2/2]

Friends And Related Symbol Documentation

◆ detail::AsyncHandshakeOperation

◆ detail::AsyncReadOperation

◆ detail::AsyncWriteOperation

Member Data Documentation

◆ m_context

◆ m_core

◆ m_input_buffer

◆ m_input_buffer_space

◆ m_native_handle

◆ m_nextLayer