Struct TransportEngine 

pub struct TransportEngine { /* private fields */ }

The core transport/routing engine.

Maintains routing tables and processes packets without performing any I/O. Returns Vec<TransportAction> that the caller must execute.

Implementations

impl TransportEngine

pub fn handle_path_request( &mut self, data: &[u8], interface_id: InterfaceId, now: f64, ) -> Vec<TransportAction>

impl TransportEngine

pub fn persistence_snapshot(&self) -> TransportStateSnapshot

Copy the restart-relevant portion of transport state.

pub fn restore_persistence_snapshot<F>( &mut self, snapshot: TransportStateSnapshot, now: f64, announce_lookup: F, ) -> RestoreStats

where F: FnMut(&[u8; 32]) -> Option<Vec<u8>>,

Restore state after interfaces and the announce cache are available.

impl TransportEngine

pub fn path_table_entries( &self, ) -> impl Iterator<Item = (&[u8; 16], &PathEntry)>

pub fn path_table_sets(&self) -> impl Iterator<Item = (&[u8; 16], &PathSet)>

pub fn interface_count(&self) -> usize

pub fn link_table_count(&self) -> usize

pub fn path_table_count(&self) -> usize

pub fn announce_table_count(&self) -> usize

pub fn reverse_table_count(&self) -> usize

pub fn held_announces_count(&self) -> usize

pub fn packet_hashlist_len(&self) -> usize

pub fn announce_sig_cache_len(&self) -> usize

pub fn rate_limiter_count(&self) -> usize

pub fn blackholed_count(&self) -> usize

pub fn tunnel_count(&self) -> usize

pub fn discovery_pr_tags_count(&self) -> usize

pub fn discovery_path_requests_count(&self) -> usize

pub fn announce_queue_count(&self) -> usize

pub fn nonempty_announce_queue_count(&self) -> usize

pub fn queued_announce_count(&self) -> usize

pub fn queued_announce_bytes(&self) -> usize

pub fn announce_queue_interface_cap_drop_count(&self) -> u64

pub fn local_destinations_count(&self) -> usize

pub fn rate_limiter(&self) -> &AnnounceRateLimiter

pub fn interface_info(&self, id: &InterfaceId) -> Option<&InterfaceInfo>

pub fn redirect_path( &mut self, dest_hash: &[u8; 16], interface: InterfaceId, now: f64, )

pub fn inject_path(&mut self, dest_hash: [u8; 16], entry: PathEntry)

pub fn drop_path(&mut self, dest_hash: &[u8; 16]) -> bool

pub fn drop_all_via(&mut self, transport_hash: &[u8; 16]) -> usize

pub fn drop_paths_for_interface(&mut self, interface: InterfaceId) -> usize

pub fn drop_reverse_for_interface(&mut self, interface: InterfaceId) -> usize

pub fn drop_links_for_interface(&mut self, interface: InterfaceId) -> usize

pub fn drop_announce_queues(&mut self)

pub fn void_queues(&mut self)

pub fn identity_hash(&self) -> Option<&[u8; 16]>

pub fn transport_enabled(&self) -> bool

pub fn config(&self) -> &TransportConfig

pub fn set_packet_hashlist_max_entries(&mut self, max_entries: usize)

pub fn get_path_table(&self, max_hops: Option<u8>) -> Vec<PathTableRow>

pub fn get_rate_table(&self) -> Vec<RateTableRow>

pub fn get_blackholed(&self) -> Vec<([u8; 16], f64, f64, Option<String>)>

pub fn active_destination_hashes(&self) -> BTreeSet<[u8; 16]>

pub fn path_destination_cap_evict_count(&self) -> usize

pub fn active_packet_hashes(&self) -> Vec<[u8; 32]>

pub fn cull_rate_limiter( &mut self, active: &BTreeSet<[u8; 16]>, now: f64, ttl_secs: f64, ) -> usize

pub fn update_interface_freq(&mut self, id: InterfaceId, ia_freq: f64)

pub fn update_interface_freqs( &mut self, id: InterfaceId, ia_freq: f64, ip_freq: f64, op_freq: f64, op_samples: usize, )

pub fn held_announce_count(&self, interface: &InterfaceId) -> usize

pub fn burst_active(&self, interface: &InterfaceId) -> bool

pub fn burst_activated(&self, interface: &InterfaceId) -> f64

pub fn pr_burst_active(&self, interface: &InterfaceId) -> bool

pub fn pr_burst_activated(&self, interface: &InterfaceId) -> f64

impl TransportEngine

pub fn new(config: TransportConfig) -> Self

pub fn register_interface(&mut self, info: InterfaceInfo)

pub fn deregister_interface(&mut self, id: InterfaceId)

pub fn register_destination(&mut self, dest_hash: [u8; 16], dest_type: u8)

pub fn deregister_destination(&mut self, dest_hash: &[u8; 16])

pub fn has_path(&self, dest_hash: &[u8; 16]) -> bool

pub fn hops_to(&self, dest_hash: &[u8; 16]) -> Option<u8>

pub fn next_hop(&self, dest_hash: &[u8; 16]) -> Option<[u8; 16]>

pub fn next_hop_interface(&self, dest_hash: &[u8; 16]) -> Option<InterfaceId>

pub fn mark_path_unresponsive( &mut self, dest_hash: &[u8; 16], receiving_interface: Option<InterfaceId>, )

Mark a path as unresponsive.

If receiving_interface is provided and points to a MODE_BOUNDARY interface, the marking is skipped — boundary interfaces must not poison path tables. (Python Transport.py: mark_path_unknown/unresponsive boundary exemption)

pub fn mark_path_responsive(&mut self, dest_hash: &[u8; 16])

pub fn path_is_unresponsive(&self, dest_hash: &[u8; 16]) -> bool

pub fn expire_path(&mut self, dest_hash: &[u8; 16])

pub fn register_link(&mut self, link_id: [u8; 16], entry: LinkEntry)

pub fn validate_link(&mut self, link_id: &[u8; 16])

pub fn remove_link(&mut self, link_id: &[u8; 16])

pub fn link_rebalance_destination( &self, link_id: &[u8; 16], packet_hops: u8, receiving_interface: InterfaceId, ) -> Option<[u8; 16]>

Return the destination whose unvalidated link route can be rebalanced by a mismatched-hop LRPROOF received from its recorded next hop.

pub fn inbound_lrproof_rebalance_candidate( &self, raw: &[u8], receiving_interface: InterfaceId, ) -> Option<([u8; 16], [u8; 16], u8, Vec<u8>)>

Parse and filter an inbound frame before offering it for LRPROOF path rebalancing. The returned hops are the post-ingress metric used by the normal transport pipeline.

pub fn rebalance_link_path_from_lrproof( &mut self, link_id: &[u8; 16], packet_hops: u8, receiving_interface: InterfaceId, proof_data: &[u8], destination_sig_pub_bytes: &[u8; 32], ) -> bool

Validate a mismatched-hop LRPROOF and update the relay link route and destination path atomically enough for normal proof routing to resume.

pub fn rebalance_destination_path_hops( &mut self, destination_hash: &[u8; 16], packet_hops: u8, ) -> bool

Update the current path metric after a terminus validates an LRPROOF.

pub fn blackhole_identity( &mut self, identity_hash: [u8; 16], now: f64, duration_hours: Option<f64>, reason: Option<String>, )

Add an identity hash to the blackhole list.

identity_hash is the 16-byte identity hash to blackhole. now is the current Unix timestamp. If duration_hours is Some and greater than zero, the entry expires after that many hours; otherwise it does not expire. reason is optional descriptive text retained with the entry.

pub fn unblackhole_identity(&mut self, identity_hash: &[u8; 16]) -> bool

Remove an identity hash from the blackhole list.

Returns true if an entry was removed, or false if the identity was not blackholed.

pub fn is_blackholed(&self, identity_hash: &[u8; 16], now: f64) -> bool

Check if an identity hash is blackholed (and not expired).

pub fn blackholed_entries( &self, ) -> impl Iterator<Item = (&[u8; 16], &BlackholeEntry)>

Get all blackhole entries (for queries).

pub fn handle_tunnel( &mut self, tunnel_id: [u8; 32], interface: InterfaceId, now: f64, ) -> Vec<TransportAction>

Handle a validated tunnel synthesis — create new or reattach.

Returns actions for any restored paths.

pub fn synthesize_tunnel( &self, identity: &Identity, interface_id: InterfaceId, rng: &mut dyn Rng, ) -> Vec<TransportAction>

Synthesize a tunnel on an interface.

identity: the transport identity (must have private key for signing) interface_id: which interface to send the synthesis on rng: random number generator

Returns TunnelSynthesize action to send the synthesis packet.

pub fn void_tunnel_interface(&mut self, tunnel_id: &[u8; 32])

Void a tunnel’s interface connection (tunnel disconnected).

pub fn tunnel_table(&self) -> &TunnelTable

Access the tunnel table for queries.

pub fn handle_inbound( &mut self, frame: InboundFrame<'_>, rng: &mut dyn Rng, ) -> Vec<TransportAction>

Process an inbound raw packet from a network interface.

Returns a list of actions for the caller to execute.

pub fn handle_inbound_with_announce_queue( &mut self, frame: InboundFrame<'_>, rng: &mut dyn Rng, announce_queue: Option<&mut AnnounceVerifyQueue>, ) -> Vec<TransportAction>

pub fn complete_verified_announce( &mut self, pending: PendingAnnounce, validated: ValidatedAnnounce, sig_cache_key: [u8; 32], now: f64, rng: &mut dyn Rng, ) -> Vec<TransportAction>

pub fn clear_failed_verified_announce( &mut self, _sig_cache_key: [u8; 32], _now: f64, )

pub fn announce_sig_cache_contains(&self, sig_cache_key: &[u8; 32]) -> bool

pub fn handle_outbound( &mut self, packet: &RawPacket, dest_type: u8, attached_interface: Option<InterfaceId>, now: f64, ) -> Vec<TransportAction>

Route an outbound packet.

pub fn tick(&mut self, now: f64, rng: &mut dyn Rng) -> Vec<TransportAction>

Periodic maintenance. Call regularly (e.g., every 250ms).