Struct QuicTransport 

pub struct QuicTransport {
    conn: Connection,
}

QUIC transport wrapping a quinn::Connection.

Fields

conn: Connection

Implementations

impl QuicTransport

pub fn new(conn: Connection) -> Self

Create a new QUIC transport from a quinn connection.

pub async fn open_bi(&self) -> Result<(SendStream, RecvStream), TransportError>

Open a bidirectional stream.

pub async fn accept_bi( &self, ) -> Result<(SendStream, RecvStream), TransportError>

Accept an incoming bidirectional stream.

pub async fn open_uni(&self) -> Result<SendStream, TransportError>

Open a unidirectional send stream.

pub async fn accept_uni(&self) -> Result<RecvStream, TransportError>

Accept an incoming unidirectional stream.

pub fn send_datagram(&self, data: Bytes) -> Result<(), TransportError>

Send a datagram.

pub async fn recv_datagram(&self) -> Result<Bytes, TransportError>

Receive a datagram.

pub fn close(&self, code: u32, reason: &[u8])

Close the connection.

pub fn closed(&self) -> impl Future<Output = TransportError> + Send + 'static

A future resolving when the session ends, carrying the peer’s close.

Borrows nothing and outlives this transport, for the same reason SendStream::stopped does: the answer arrives after the call that wanted it has already returned. A peer refusing a handshake commonly finishes the control stream first and closes the session a round trip later, so the caller sees an end-of-stream, hands back an error, and drops the transport before the code it was refused with ever lands. Taking this handle before the transport is given away is what makes that code readable at all.

Holding the future keeps the connection alive; dropping it lets quinn close as usual.

pub fn peer_certificates(&self) -> Vec<Vec<u8>>

The certificate chain the peer presented, DER-encoded, leaf first.

Bytes, and no opinion about them: nothing here parses a certificate, checks a date, or decides whether a chain is trustworthy, because the verdict depends on what the caller is measuring. Empty is not an error — a chain is absent for ordinary reasons, including a handshake that has not completed.

A chain that a handshake failed over never reaches here, since there is no connection left to read it off; that is what QuicDialOptions::observing is for.