Struct TransportParameters 

pub struct TransportParameters { /* private fields */ }

Transport parameters used to negotiate connection-level preferences between peers

Implementations

impl TransportParameters

pub fn nat_traversal_config(&self) -> Option<&NatTraversalConfig>

Get the NAT traversal configuration for this connection

This is a public accessor method for tests and external code that need to examine the negotiated NAT traversal parameters.

pub fn supports_rfc_nat_traversal(&self) -> bool

Check if RFC-compliant NAT traversal frames are supported

Returns true if both endpoints support RFC NAT traversal

pub fn pqc_algorithms(&self) -> Option<&PqcAlgorithms>

Get the PQC algorithms configuration for this connection

This is a public accessor method for tests and external code that need to examine the negotiated PQC algorithm support.

impl TransportParameters

pub fn write<W: BufMut>(&self, w: &mut W)

Encode TransportParameters into buffer

pub fn read<R: Buf>(side: Side, r: &mut R) -> Result<Self, Error>

Decode TransportParameters from buffer

pub fn negotiated_nat_concurrency_limit( &self, local_config: &NatTraversalConfig, ) -> Option<u64>

Negotiate effective NAT traversal concurrency limit for this connection

Returns the effective concurrency limit based on local and remote NAT traversal configurations. For P2P connections where both peers have ServerSupport, returns the minimum of the two limits. For traditional client/server, returns the server’s limit. Returns None if NAT traversal is not configured.

Examples

use ant_quic::VarInt;
use ant_quic::TransportParameters;
use ant_quic::NatTraversalConfig;

// P2P: Both peers have ServerSupport - use minimum
let local = NatTraversalConfig::ServerSupport {
    concurrency_limit: VarInt::from_u32(10),
};
let mut remote_params = TransportParameters::default();
remote_params.nat_traversal = Some(NatTraversalConfig::ServerSupport {
    concurrency_limit: VarInt::from_u32(5),
});
assert_eq!(remote_params.negotiated_nat_concurrency_limit(&local), Some(5));

pub fn supports_bidirectional_nat_traversal(&self) -> bool

Check if this connection supports bidirectional NAT traversal (P2P)

Returns true if the remote peer sent ServerSupport, indicating they can accept NAT traversal path validation requests. This is used to detect P2P connections where both peers have equal capabilities.

Examples

use ant_quic::VarInt;
use ant_quic::TransportParameters;
use ant_quic::NatTraversalConfig;

let mut params = TransportParameters::default();
params.nat_traversal = Some(NatTraversalConfig::ServerSupport {
    concurrency_limit: VarInt::from_u32(5),
});
assert!(params.supports_bidirectional_nat_traversal());

let mut client_params = TransportParameters::default();
client_params.nat_traversal = Some(NatTraversalConfig::ClientSupport);
assert!(!client_params.supports_bidirectional_nat_traversal());

Trait Implementations

impl Clone for TransportParameters

fn clone(&self) -> TransportParameters

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TransportParameters

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

Formats the value using the given formatter.

impl PartialEq for TransportParameters

fn eq(&self, other: &TransportParameters) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for TransportParameters

impl StructuralPartialEq for TransportParameters