Struct Config 

pub struct Config {
    pub provider: Arc<dyn CryptoProvider>,
    pub transport: TransportConfig,
    pub reset_key: [u8; 32],
    pub token_key: [u8; 32],
    pub versions: Vec<u32>,
    pub retry: bool,
    pub retry_threshold: usize,
    pub retry_token_lifetime: Duration,
    pub new_token_lifetime: Option<Duration>,
    pub cid_len: usize,
    pub max_connections: usize,
    pub epoch: OnceLock<Instant>,
}

Endpoint-wide configuration shared by its connections.

Fields

provider: Arc<dyn CryptoProvider>

transport: TransportConfig

reset_key: [u8; 32]

Key for stateless reset tokens (HMAC of the connection ID).

token_key: [u8; 32]

Key for Retry and NEW_TOKEN address-validation tokens.

versions: Vec<u32>

Versions accepted by a server, preferred first. A client uses the first.

retry: bool

Server: always validate addresses with Retry.

retry_threshold: usize

Server: send Retry once this many connections are in the handshake.

retry_token_lifetime: Duration

Lifetime of Retry tokens.

new_token_lifetime: Option<Duration>

Server: issue NEW_TOKEN after the handshake; lifetime of those tokens.

cid_len: usize

Length of the connection IDs this endpoint issues (4..=20).

max_connections: usize

Server: most connections kept at once.

epoch: OnceLock<Instant>

Time base for token ages, set by the first time value the endpoint sees.

Implementations

impl Config

pub fn new(provider: Arc<dyn CryptoProvider>) -> Self

A configuration with random keys from the provider and default settings.

Examples found in repository

examples/bench_quic.rs (line 34)

fn pair(real: bool) -> (Pair, ConnHandle, ConnHandle) {
    let (cp, sp) = providers(real);
    let mut c = Config::new(cp);
    let mut s = Config::new(sp);
    for x in [&mut c, &mut s] {
        x.transport.max_data = 16 << 20;
        x.transport.stream_window_bidi_local = 8 << 20;
        x.transport.stream_window_bidi_remote = 8 << 20;
        x.transport.send_buffer = 8 << 20;
    }
    let mut p = Pair::new(Arc::new(c), Arc::new(s), link(), 7);
    p.batch = 16;
    let ch = p.connect();
    assert!(p.run_until(Duration::from_secs(10), |p| p.client.conn(ch).is_some_and(|c| c.is_established())
        && p.server_conn().and_then(|s| p.server.conn(s)).is_some_and(|c| c.is_established())));
    let sh = p.server_conn().unwrap();
    p.run_for(Duration::from_millis(50));
    (p, ch, sh)
}

pub fn reset_token(&self, cid: &[u8]) -> [u8; 16]

The stateless reset token for a connection ID (RFC 9000 §10.3.2).