Struct Incoming 

pub struct Incoming(/* private fields */);

Available on crate features quic and std only.

An incoming connection for which the server has not yet begun its part of the handshake

Implementations

impl Incoming

pub fn accept(self) -> Result<Connecting, ConnectionError>

Attempt to accept this incoming connection (an error may still occur)

A server configuration whose TLS provider resolves its configuration per ClientHello, such as one issuing certificates on demand, cannot start here: await this attempt or use Self::accept_or_retry instead, or resolve one with Self::client_hello and use Self::accept_with.

pub fn accept_with( self, server_config: Arc<ServerConfig>, ) -> Result<Connecting, ConnectionError>

Accept this incoming connection using a custom configuration

See accept() for more details.

pub fn refuse(self)

Reject this incoming connection attempt

pub fn retry(self) -> Result<(), RetryError>

Respond with a retry packet, requiring the client to retry with address validation

Errors if may_retry() is false.

pub fn ignore(self)

Ignore this incoming connection attempt, not sending any packet in response

pub fn local_ip(&self) -> Option<IpAddr>

The local IP address which was used when the peer established the connection

pub fn local_address(&self) -> Option<SocketAddr>

The local address the peer’s first flight arrived on: the port of the socket that received it, with the IP the packet was sent to when that socket is a wildcard.

None when neither tells a specific IP.

pub fn remote_address(&self) -> SocketAddr

The peer’s UDP address

pub fn remote_address_validated(&self) -> bool

Whether the socket address that is initiating this connection has been validated

This means that the sender of the initial packet has proved that they can receive traffic sent to self.remote_address().

Before expiry, if self.remote_address_validated() is false, self.may_retry() is true. The inverse is not guaranteed.

pub fn is_expired(&self) -> bool

Whether this pending attempt has expired or was retired by endpoint shutdown.

pub fn may_retry(&self) -> bool

Whether it is legal to respond with a retry packet

Before expiry, if self.remote_address_validated() is false, self.may_retry() is true. The inverse is not guaranteed.

pub fn orig_dst_cid(&self) -> ConnectionId

The original destination CID when initiating the connection

pub async fn client_hello(&mut self) -> Result<ClientHello, ConnectionError>

The client’s ClientHello, once its first flight delivered all of it.

A ClientHello can span several Initial packets; this waits for the rest until the attempt expires or the endpoint closes. One larger than 16 KiB is refused. Use it to choose a configuration for Self::accept_with.

pub async fn accept_or_retry(self) -> Result<IncomingOutcome, ConnectionError>

Accept this attempt as awaiting it does, but answer with a Retry instead when resolving its TLS configuration takes real work, such as issuing a certificate, for a client whose address is not validated yet (RFC 9000 §8.1.2). A provider that cannot tell, such as a rustls dynamic configuration, always takes real work.

When no Retry can be sent, the attempt is dropped without a response, so an unproven address never costs that work.

Trait Implementations

impl Debug for Incoming

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

Formats the value using the given formatter.

impl Drop for Incoming

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl IntoFuture for Incoming

type Output = Result<Connection, ConnectionError>

The output that the future will produce on completion.

type IntoFuture = IncomingFuture

Which kind of future are we turning this into?

fn into_future(self) -> <Incoming as IntoFuture>::IntoFuture

Creates a future from a value.