Struct PeekQuicClientHelloService 

pub struct PeekQuicClientHelloService<K, S, F = RejectService<(), NoQuicRejectError>, R = NoQuicPeekRouting> { /* private fields */ }

Available on crate features quic and std only.

Inspects the first datagrams of a UDP association for a QUIC client’s Initial flight and its ClientHello, then hands the association on with those datagrams replayed in front.

A complete ClientHello goes to the inner service as InputWithQuicClientHello. Anything else ends in a QuicPeekRejection: classes the QuicPeekFallbackPolicy admits go to the fallback with the same datagrams intact and the rejection in the input’s extensions, so the fallback can still forward the association untouched; the others fail with QuicPeekRejectedError. Nothing is ever sent while peeking: the decision is made before any local QUIC output exists. The deadline is absolute from serve, and the read ahead is bounded by CaptureLimits. Defaults use DEFAULT_QUIC_PEEK_LIMITS and select the configured fallback for every rejection. Use Self::with_malformed_tls_policy and Self::with_peek_policy for the same policy controls as TCP, or Self::with_fallback_policy for per-class QUIC control. The last applicable setter wins.

Both successful and fallback dispatch insert ClientHelloPeekStatus, replacing any earlier status. Non-QUIC input has no inspection failure. Unsupported or malformed QUIC maps to Rejected, budget exhaustion to MaxPeekSizeReached, and its own inspection deadline, a bound on buffered datagrams, to Cancelled. Receive errors always fail the service.

Like the TCP peekers, it waits within the scope the association runs in: once that scope is cancelled the PeekPolicy decides by the progress made (fallback with QuicPeekRejection::Cancelled, fail, or keep waiting), and once it is aborted the peek fails with PeekCutoffError. Strict routing should use QuicPeekFallbackPolicy::NOT_QUIC.

Routing sees the outer ClientHello only: with ECH that is the public name, never the encrypted inner one. 0-RTT in the first flight is never decrypted: it is flagged as PeekedClientHello::early_data_observed and replayed untouched to a forwarding service, while a terminating relay rejects it and the client resends that data after the handshake.

The fallback rejects by default; use Self::with_fallback to forward instead.

Implementations

impl<K, S> PeekQuicClientHelloService<K, S>

pub fn get_ref(&self) -> &S

Gets a reference to the underlying service.

pub fn into_inner(self) -> S

Consumes self, returning the underlying service.

pub fn new(keys: K, inner: S) -> PeekQuicClientHelloService<K, S>

Peek with keys deriving the Initial keys of the client’s offered version. No certificate or server identity is needed.

impl<K, S, F, R> PeekQuicClientHelloService<K, S, F, R>

pub fn with_router<T>(self, router: T) -> PeekQuicClientHelloService<K, S, F, T>

Route existing connections before inspecting a new handshake, using the same receive buffer, timeout and cancellation policy. Only the first datagram is offered to the router. The default adds no routing lookup.

pub fn with_fallback<G>( self, fallback: G, ) -> PeekQuicClientHelloService<K, S, G, R>

Hand associations the fallback policy admits to fallback.

pub fn with_first_flight_retention( self, retain: bool, ) -> PeekQuicClientHelloService<K, S, F, R>

Retain structural facts through the datagram completing ClientHello (default: on). A native mirror uses these facts for fresh Initial packetization and CID lengths.

pub fn set_first_flight_retention( &mut self, retain: bool, ) -> &mut PeekQuicClientHelloService<K, S, F, R>

Retain structural facts through the datagram completing ClientHello (default: on). A native mirror uses these facts for fresh Initial packetization and CID lengths.

pub fn with_limits( self, limits: CaptureLimits, ) -> PeekQuicClientHelloService<K, S, F, R>

Bounds on datagrams, packets, bytes, CRYPTO fragments and the ClientHello. Defaults to DEFAULT_QUIC_PEEK_LIMITS. Reaching a bound stops inspection and follows the configured fallback policy.

pub fn set_limits( &mut self, limits: CaptureLimits, ) -> &mut PeekQuicClientHelloService<K, S, F, R>

Bounds on datagrams, packets, bytes, CRYPTO fragments and the ClientHello. Defaults to DEFAULT_QUIC_PEEK_LIMITS. Reaching a bound stops inspection and follows the configured fallback policy.

pub fn with_peek_timeout( self, timeout: Duration, ) -> PeekQuicClientHelloService<K, S, F, R>

How long the whole inspection may take, from serve. Defaults to DEFAULT_QUIC_PEEK_TIMEOUT.

pub fn set_peek_timeout( &mut self, timeout: Duration, ) -> &mut PeekQuicClientHelloService<K, S, F, R>

How long the whole inspection may take, from serve. Defaults to DEFAULT_QUIC_PEEK_TIMEOUT.

pub fn with_malformed_tls_policy( self, policy: MalformedTlsPolicy, ) -> PeekQuicClientHelloService<K, S, F, R>

Whether malformed, unsupported or over-budget QUIC reaches fallback. Defaults to MalformedTlsPolicy::Fallback. This updates those three classes only; timeout and non-QUIC policy remain independent.

pub fn set_malformed_tls_policy( &mut self, policy: MalformedTlsPolicy, ) -> &mut PeekQuicClientHelloService<K, S, F, R>

Whether malformed, unsupported or over-budget QUIC reaches fallback. Defaults to MalformedTlsPolicy::Fallback. This updates those three classes only; timeout and non-QUIC policy remain independent.

pub fn with_peek_policy( self, policy: PeekPolicy, ) -> PeekQuicClientHelloService<K, S, F, R>

How a cancelled scope and the inspection deadline are handled. Defaults to PeekPolicy::FAIL_OPEN, independently of the malformed-TLS policy.

A cancelled scope the association runs in applies the cancel action for the progress made; an aborted scope always fails. The inspection deadline, a bound on buffered datagrams, follows the partial cancel action, as the first datagram is in hand; there PeekAction::Wait fails.

pub fn set_peek_policy( &mut self, policy: PeekPolicy, ) -> &mut PeekQuicClientHelloService<K, S, F, R>

How a cancelled scope and the inspection deadline are handled. Defaults to PeekPolicy::FAIL_OPEN, independently of the malformed-TLS policy.

A cancelled scope the association runs in applies the cancel action for the progress made; an aborted scope always fails. The inspection deadline, a bound on buffered datagrams, follows the partial cancel action, as the first datagram is in hand; there PeekAction::Wait fails.

pub fn with_fallback_policy( self, policy: QuicPeekFallbackPolicy, ) -> PeekQuicClientHelloService<K, S, F, R>

Which rejections reach the fallback. Defaults to QuicPeekFallbackPolicy::ALL.

pub fn set_fallback_policy( &mut self, policy: QuicPeekFallbackPolicy, ) -> &mut PeekQuicClientHelloService<K, S, F, R>

Which rejections reach the fallback. Defaults to QuicPeekFallbackPolicy::ALL.

Trait Implementations

impl<K, S, F, R> Clone for PeekQuicClientHelloService<K, S, F, R>

where K: Clone, S: Clone, F: Clone, R: Clone,

fn clone(&self) -> PeekQuicClientHelloService<K, S, F, R>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<K, S, F, R> Debug for PeekQuicClientHelloService<K, S, F, R>

where K: Debug, S: Debug, F: Debug, R: Debug,

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

Formats the value using the given formatter.

impl<K, S, F, R> ExtensionsRef for PeekQuicClientHelloService<K, S, F, R>

where S: ExtensionsRef,

fn extensions(&self) -> &Extensions

Get reference to the underlying Extensions store

impl<I, K, S, F, O, R> Service<I> for PeekQuicClientHelloService<K, S, F, R>

where I: DatagramPeekInput + ExtensionsRef, <I as DatagramPeekInput>::Mapped<PrefixedDatagramSocket<<I as DatagramPeekInput>::Socket>>: ExtensionsRef, K: KeyProvider + Send + Sync + 'static, S: Service<InputWithQuicClientHello<<I as DatagramPeekInput>::Mapped<PrefixedDatagramSocket<<I as DatagramPeekInput>::Socket>>>, Output = O>, <S as Service<InputWithQuicClientHello<<I as DatagramPeekInput>::Mapped<PrefixedDatagramSocket<<I as DatagramPeekInput>::Socket>>>>>::Error: Into<Box<dyn Error + Send + Sync>>, F: Service<<I as DatagramPeekInput>::Mapped<PrefixedDatagramSocket<<I as DatagramPeekInput>::Socket>>, Output = O>, <F as Service<<I as DatagramPeekInput>::Mapped<PrefixedDatagramSocket<<I as DatagramPeekInput>::Socket>>>>::Error: Into<Box<dyn Error + Send + Sync>>, O: Send + 'static, R: QuicPeekRouter<O>,

type Output = O

The type of the output returned by the service.

type Error = Box<dyn Error + Send + Sync>

The type of error returned by the service.

fn serve( &self, input: I, ) -> impl Future<Output = Result<O, Box<dyn Error + Send + Sync>>> + Send

Serve an output or an error for the given input

fn boxed(self) -> BoxService<Input, Self::Output, Self::Error>

Box this service to allow for dynamic dispatch.