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 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 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 held_announce_count(&self, interface: &InterfaceId) -> usize

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 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.

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

Remove an identity hash from the blackhole list.

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, raw: &[u8], iface: InterfaceId, now: f64, 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, raw: &[u8], iface: InterfaceId, now: f64, 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).