Struct StartHandshake 

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

Available on crate feature rustls only.

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) -> StartHandshake<IO>

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 for StartHandshake<IO>

where IO: Debug,

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

Formats the value using the given formatter.