Struct StartHandshake 

#[non_exhaustive]
pub struct StartHandshake<IO> {
    pub accepted: Accepted,
    pub io: IO,
}

An incoming connection received through LazyConfigAcceptor.

This contains the generic IO asynchronous transport, ClientHello data, and all the state required to continue the TLS handshake (e.g. via StartHandshake::into_stream).

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

accepted: Accepted

io: IO

Implementations

impl<IO> StartHandshake<IO>

where IO: AsyncRead + AsyncWrite + Unpin,

pub fn from_parts(accepted: Accepted, transport: IO) -> Self

Create a new object from an IO transport and prior TLS metadata.

pub fn client_hello(&self) -> ClientHello<'_>

pub fn into_stream(self, config: Arc<ServerConfig>) -> Accept<IO>

Returns a future that performs the rest of the TLS handshake using config.

You likely want to wrap this in a timeout to bound the handshake time. Ideally with tokio::time::timeout_at, reusing the deadline that also bounded awaiting the LazyConfigAcceptor so both halves of the handshake share one budget. See LazyConfigAcceptor::new().

pub fn into_stream_with<F>(self, config: Arc<ServerConfig>, f: F) -> Accept<IO>

where F: FnOnce(&mut ServerConnection),

Similar to Self::into_stream(), but calls f before performing the handshake.

As with Self::into_stream() you likely want to wrap this in a timeout to bound the handshake time.

The f handler is given a mutable reference to a ServerConnection that can be used to configure the connection before the handshake.

Trait Implementations

impl<IO: Debug> Debug for StartHandshake<IO>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.