Struct QuicConnection 

pub struct QuicConnection { /* private fields */ }

Available on crate feature boring only.

Owns a TLS session without a TLS record stream or socket. Configuration must restrict the session to TLS 1.3 before construction.

Implementations

impl QuicConnection

pub fn new( ssl: Ssl, method: Arc<dyn QuicMethod>, ) -> Result<QuicConnection, ErrorStack>

pub fn set_accept_state(&mut self)

Select the server role before starting the handshake.

pub fn set_connect_state(&mut self)

Select the client role before starting the handshake.

pub fn ssl(&self) -> &SslRef

pub fn ssl_mut(&mut self) -> &mut SslRef

pub fn set_transport_parameters( &mut self, params: &[u8], ) -> Result<(), ErrorStack>

pub fn peer_transport_parameters(&self) -> &[u8]

pub fn set_early_data_enabled(&mut self, enabled: bool)

pub fn set_early_data_context( &mut self, context: &[u8], ) -> Result<(), ErrorStack>

pub fn early_data_accepted(&self) -> bool

pub fn reset_early_data_rejection(&mut self) -> Result<(), QuicError>

Resume TLS after reporting rejection to the transport and resetting early state.

pub fn max_handshake_flight_len(&self, level: EncryptionLevel) -> usize

pub fn provide_data( &mut self, level: EncryptionLevel, data: &[u8], ) -> Result<(), QuicError>

pub fn process_post_handshake(&mut self) -> Result<(), QuicError>

pub fn abort_handshake(&mut self)

Permanently stop TLS and drop pending asynchronous callback work now.

A QUIC transport may retain this connection while it drains packets. After this call no callback factory, future or finish closure runs again and every operation returns QuicError::InvalidState. Repeated calls are harmless. This does not undo external effects or cancel independently spawned tasks.

pub fn poll_handshake( &mut self, cx: &mut Context<'_>, ) -> Poll<Result<HandshakeStatus, QuicError>>

Advance the handshake like Self::handshake, registering the waker of cx for asynchronous certificate selection, verification, session lookup and private-key callbacks.

Pending means such a callback is waiting: poll again once woken, without waiting for peer input. Ready(Ok(HandshakeStatus::WantRead)) instead waits for peer CRYPTO data. While pending, the latest waker stays installed, so a Self::handshake call in between resumes the same work instead of abandoning it. The waker is released once a step no longer waits on a callback. Cancel with Self::abort_handshake or by dropping this connection.

A synchronous callback that requests a retry also yields Pending, but nothing wakes the task for it.

pub fn handshake(&mut self) -> Result<HandshakeStatus, QuicError>

Advance the handshake.

A QuicError::Tls whose Error::would_block holds reports a callback waiting on asynchronous work. It is not terminal: call again once that work is ready. Asynchronous callbacks need the task waker that Self::poll_handshake installs; without one they fail the handshake.

Trait Implementations

impl Debug for QuicConnection

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

Formats the value using the given formatter.