Struct LinkManager 

pub struct LinkManager { /* private fields */ }

Manages multiple links, link destinations, and request/response.

Implementations

impl LinkManager

pub fn flush_channel_tx(&mut self, link_id: &LinkId)

Flush the channel TX ring for a link, clearing outstanding messages. Called after holepunch completion where signaling messages are fire-and-forget.

pub fn send_channel_message( &mut self, link_id: &LinkId, msgtype: u16, payload: &[u8], rng: &mut dyn Rng, ) -> Result<Vec<LinkManagerAction>, String>

Send a channel message on a link.

impl LinkManager

pub fn send_deferred_response( &mut self, link_id: &LinkId, request_id: &[u8; 16], response_data: &[u8], rng: &mut dyn Rng, ) -> Vec<LinkManagerAction>

Send the value for a previously accepted deferred request.

pub fn send_management_response( &mut self, link_id: &LinkId, request_id: &[u8; 16], response_data: &[u8], rng: &mut dyn Rng, ) -> Vec<LinkManagerAction>

Send a management response on a link. Called by the driver after building the response for a ManagementRequest.

pub fn send_request( &mut self, link_id: &LinkId, path: &str, data: &[u8], rng: &mut dyn Rng, ) -> Vec<LinkManagerAction>

Send a request on a link.

data is the msgpack-encoded request data value (e.g. msgpack([True]) for /status).

Uses Python-compatible format: plaintext = msgpack([timestamp, path_hash_bytes, data_value]). Returns actions (the encrypted request packet). The response will arrive later via handle_local_delivery with CONTEXT_RESPONSE.

pub fn send_request_with_max_response_size( &mut self, link_id: &LinkId, path: &str, data: &[u8], max_response_size: Option<usize>, rng: &mut dyn Rng, ) -> Vec<LinkManagerAction>

Send a request with an optional maximum accepted response size.

impl LinkManager

pub fn accept_resource( &mut self, link_id: &LinkId, resource_hash: &[u8], accept: bool, rng: &mut dyn Rng, ) -> Vec<LinkManagerAction>

Accept or reject a pending resource (for AcceptApp strategy).

pub fn send_resource( &mut self, link_id: &LinkId, data: &[u8], metadata: Option<&[u8]>, rng: &mut dyn Rng, ) -> Vec<LinkManagerAction>

Start sending a resource on a link.

pub fn send_resource_with_auto_compress( &mut self, link_id: &LinkId, data: &[u8], metadata: Option<&[u8]>, auto_compress: bool, rng: &mut dyn Rng, ) -> Vec<LinkManagerAction>

Start sending a resource on a link, controlling automatic compression.

pub fn send_resource_stream( &mut self, link_id: &LinkId, transfer_id: ResourceTransferId, reader: Box<dyn Read + Send>, declared_length: u64, metadata: Option<Vec<u8>>, auto_compress: bool, rng: &mut dyn Rng, ) -> Vec<LinkManagerAction>

Start a bounded-memory Resource transfer from a sequential reader.

The declared-length reader is consumed directly. Unlike the upstream zero-stat compatibility path, no temporary buffered proxy must be flushed and rewound before its size or first segment can be observed.

pub fn set_resource_strategy( &mut self, link_id: &LinkId, strategy: ResourceStrategy, )

Set the resource acceptance strategy for a link.

pub fn set_resource_receive_mode( &mut self, link_id: &LinkId, mode: ResourceReceiveMode, )

impl LinkManager

pub fn new() -> Self

Create a new empty link manager.

pub fn register_management_path(&mut self, path_hash: [u8; 16])

Register a path hash as a management path. Management requests are returned as ManagementRequest actions for the driver to handle (since they need access to engine state).

pub fn get_derived_key(&self, link_id: &LinkId) -> Option<Vec<u8>>

Get the derived session key for a link (needed for hole-punch token derivation).

pub fn remote_identity_hash(&self, link_id: &LinkId) -> Option<[u8; 16]>

Return the identity hash learned from a successful LINKIDENTIFY exchange.

pub fn get_link_route_hint(&self, link_id: &LinkId) -> Option<LinkRouteHint>

Return best-known routing hint for link packets.

pub fn set_link_route_hint( &mut self, link_id: &LinkId, interface: InterfaceId, transport_id: Option<[u8; 16]>, ) -> bool

Set the best-known outbound route for a link.

pub fn register_link_destination( &mut self, dest_hash: [u8; 16], sig_prv: Ed25519PrivateKey, sig_pub_bytes: [u8; 32], resource_strategy: ResourceStrategy, )

Register a destination that can accept incoming links.

pub fn set_link_destination_max_request_size( &mut self, dest_hash: &[u8; 16], max_request_size: Option<usize>, ) -> bool

Configure the maximum request size for this destination.

The new limit also applies to responder links that are already active. Returns false when the destination is not registered.

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

Deregister a link destination.

pub fn register_request_handler<F>( &mut self, path: &str, allowed_list: Option<Vec<[u8; 16]>>, handler: F, )

where F: Fn(LinkId, &str, &[u8], Option<&([u8; 16], [u8; 64])>) -> Option<Vec<u8>> + Send + 'static,

Register a request handler for a given path.

path: the request path string (e.g. “/status”) allowed_list: None = allow all, Some(list) = restrict to these identity hashes handler: called with (link_id, path, request_data, remote_identity) -> Option

pub fn register_request_handler_response<F>( &mut self, path: &str, allowed_list: Option<Vec<[u8; 16]>>, handler: F, )

where F: Fn(LinkId, &str, &[u8], Option<&([u8; 16], [u8; 64])>) -> Option<RequestResponse> + Send + 'static,

Register a request handler that can return resource responses with metadata.

pub fn register_deferred_request_handler<F>( &mut self, path: &str, allowed_list: Option<Vec<[u8; 16]>>, handler: F, )

where F: Fn(LinkId, &str, [u8; 16], &[u8], Option<&([u8; 16], [u8; 64])>) + Send + 'static,

Register a request handler that produces its response asynchronously.

pub fn create_link( &mut self, dest_hash: &[u8; 16], dest_sig_pub_bytes: &[u8; 32], hops: u8, mtu: u32, rng: &mut dyn Rng, ) -> (LinkId, Vec<LinkManagerAction>)

Create an outbound link to a destination.

dest_sig_pub_bytes is the destination’s Ed25519 signing public key (needed to verify LRPROOF). In Python this comes from the Destination’s Identity.

Returns (link_id, actions). The first action will be a SendPacket with the LINKREQUEST.

pub fn handle_local_delivery( &mut self, dest_hash: [u8; 16], raw: &[u8], packet_hash: [u8; 32], receiving_interface: InterfaceId, rng: &mut dyn Rng, ) -> Vec<LinkManagerAction>

Handle a packet delivered locally (via DeliverLocal).

Returns actions for the driver to dispatch. The dest_hash is the packet’s destination_hash field. raw is the full packet bytes. packet_hash is the SHA-256 hash.

pub fn send_on_link( &self, link_id: &LinkId, plaintext: &[u8], context: u8, rng: &mut dyn Rng, ) -> Vec<LinkManagerAction>

pub fn try_send_on_link( &self, link_id: &LinkId, plaintext: &[u8], context: u8, rng: &mut dyn Rng, ) -> Result<Vec<LinkManagerAction>, LinkDatagramError>

Prepare a best-effort direct Link packet and report admission failures.

pub fn identify( &self, link_id: &LinkId, identity: &Identity, rng: &mut dyn Rng, ) -> Vec<LinkManagerAction>

Send an identify message on a link (initiator reveals identity to responder).

pub fn teardown_link(&mut self, link_id: &LinkId) -> Vec<LinkManagerAction>

Tear down a link.

pub fn teardown_all_links(&mut self) -> Vec<LinkManagerAction>

Tear down all managed links.

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

Periodic tick: check keepalive, stale, timeouts for all links.

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

Check if a destination hash is a known link_id managed by this manager.

pub fn link_state(&self, link_id: &LinkId) -> Option<LinkState>

Get the state of a link.

pub fn link_rtt(&self, link_id: &LinkId) -> Option<f64>

Get the RTT of a link.

pub fn set_link_rtt(&mut self, link_id: &LinkId, rtt: f64)

Update the RTT of a link (e.g., after path redirect to a direct connection).

pub fn record_link_inbound(&mut self, link_id: &LinkId)

Reset the inbound timer for a link (e.g., after path redirect).

pub fn set_link_mtu(&mut self, link_id: &LinkId, mtu: u32)

Update the MTU of a link (e.g., after path redirect to a different interface).

pub fn link_count(&self) -> usize

Get the number of tracked links in any state.

pub fn active_link_count(&self) -> usize

Get the number of established, active links.

pub fn resource_transfer_count(&self) -> usize

Get the number of active resource transfers across all links.

pub fn cancel_all_resources( &mut self, rng: &mut dyn Rng, ) -> Vec<LinkManagerAction>

Cancel all active resource transfers and return the generated actions.

pub fn link_entries(&self) -> Vec<LinkInfoEntry>

Get information about all active links.

pub fn record_outbound_packet(&mut self, packet: &RawPacket)

Account a packed outbound action at the single driver dispatch point. LINKREQUEST is accounted when its engine is created since its wire destination is not the resulting link ID.

pub fn resource_entries(&self) -> Vec<ResourceInfoEntry>

Get information about all active resource transfers.

Trait Implementations

impl Default for LinkManager

fn default() -> Self

Returns the “default value” for a type.