Struct s2n_quic_transport::path::Manager

pub struct Manager<Config: Config> { /* private fields */ }

The PathManager handles paths for a specific connection. It will handle path validation operations, and track the active path for a connection.

Implementations

impl<Config: Config> Manager<Config>

pub fn new(initial_path: Path<Config>, peer_id_registry: PeerIdRegistry) -> Self

pub fn active_path(&self) -> &Path<Config>

Return the active path

pub fn active_path_mut(&mut self) -> &mut Path<Config>

Return a mutable reference to the active path

pub fn active_path_id(&self) -> Id

Return the Id of the active path

pub fn check_active_path_is_synced(&self)

pub fn activate_path<Pub: ConnectionPublisher>(
    &mut self,
    publisher: &mut Pub,
    prev_path_id: Id,
    new_path_id: Id
)

pub fn path(&self, handle: &Config::PathHandle) -> Option<(Id, &Path<Config>)>

Returns the Path for the provided address if the PathManager knows about it

pub fn path_mut(
    &mut self,
    handle: &Config::PathHandle
) -> Option<(Id, &mut Path<Config>)>

Returns the Path for the provided address if the PathManager knows about it

pub fn paths_pending_validation(&mut self) -> PathsPendingValidation<'_, Config>

Returns an iterator over all paths pending path_challenge or path_response transmission.

pub fn on_datagram_received<Pub: ConnectionPublisher>(
    &mut self,
    path_handle: &Config::PathHandle,
    datagram: &DatagramInfo,
    handshake_confirmed: bool,
    congestion_controller_endpoint: &mut Config::CongestionControllerEndpoint,
    migration_validator: &mut Config::PathMigrationValidator,
    max_mtu: MaxMtu,
    publisher: &mut Pub
) -> Result<(Id, bool), DatagramDropReason>

Called when a datagram is received on a connection Upon success, returns a (Id, bool) containing the path ID and a boolean that is true if the path had been amplification limited prior to receiving the datagram and is now no longer amplification limited.

This function is called prior to packet authentication. If possible add business logic to Self::on_processed_packet, which is called after the packet has been authenticated.

pub fn valid_initial_received(&self) -> bool

Returns true if a valid initial packet has been received

pub fn on_transmit<W: WriteContext>(&mut self, context: &mut W)

Writes any frames the path manager wishes to transmit to the given context

pub fn on_packet_ack<A: Set>(&mut self, ack_set: &A)

Called when packets are acknowledged

pub fn on_packet_loss<A: Set>(&mut self, ack_set: &A)

Called when packets are lost

pub fn on_path_challenge(&mut self, path_id: Id, challenge: &PathChallenge<'_>)

pub fn on_path_response<Pub: ConnectionPublisher>(
    &mut self,
    response: &PathResponse<'_>,
    publisher: &mut Pub
)

pub fn on_processed_packet<Pub: ConnectionPublisher>(
    &mut self,
    path_id: Id,
    source_connection_id: Option<PeerId>,
    path_validation_probing: Probe,
    random_generator: &mut Config::RandomGenerator,
    publisher: &mut Pub
) -> Result<(), Error>

Process a packet and update internal state.

Check if the packet is a non-probing (path validation) packet and attempt to update the active path for the connection.

pub fn on_connection_id_retire(&self, _connection_id: &LocalId)

pub fn on_new_connection_id<Pub: ConnectionPublisher>(
    &mut self,
    connection_id: &PeerId,
    sequence_number: u32,
    retire_prior_to: u32,
    stateless_reset_token: &Token,
    publisher: &mut Pub
) -> Result<(), Error>

Called when a NEW_CONNECTION_ID frame is received from the peer

pub fn on_timeout<Pub: ConnectionPublisher>(
    &mut self,
    timestamp: Timestamp,
    random_generator: &mut Config::RandomGenerator,
    publisher: &mut Pub
) -> Result<(), Error>

pub fn on_closing(&mut self)

Notifies the path manager of the connection closing event

pub fn is_amplification_limited(&self) -> bool

true if ALL paths are amplification_limited

pub fn can_transmit(&self, interest: Interest) -> bool

true if ANY of the paths can transmit

pub fn transmission_constraint(&self) -> Constraint

pub fn max_mtu(&self) -> MaxMtu

Returns the maximum size the UDP payload can reach for any probe packet.

Trait Implementations

impl<Config: Debug + Config> Debug for Manager<Config>

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

Formats the value using the given formatter.

impl<Config: Config> Index<Id> for Manager<Config>

type Output = Path<Config>

The returned type after indexing.

fn index(&self, id: Id) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<Config: Config> IndexMut<Id> for Manager<Config>

fn index_mut(&mut self, id: Id) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<Config: Config> Provider for Manager<Config>

fn timers<Q: Query>(&self, query: &mut Q) -> Result

Notifies the query of any timers owned by the provider

fn next_expiration(&self) -> Option<Timestamp>

Returns the next Timestamp at which the earliest timer is armed in the provider

fn is_armed(&self) -> bool

Returns true if there are any timers armed

fn armed_timer_count(&self) -> usize

Counts the number of armed timers in the provider

fn for_each_timer<F>(&self, f: F) where
    F: FnMut(&Timer) -> Result<(), QueryBreak>, 

Iterates over each timer in the provider and calls the provided function