rns-net 0.11.0

Network interfaces and node driver for the Reticulum Network Stack
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

use super::*;

type RemoteIdentity = ([u8; 16], [u8; 64]);
type ImmediateRequestHandler =
    dyn Fn(LinkId, &str, &[u8], Option<&RemoteIdentity>) -> Option<RequestResponse> + Send;
type DeferredHandler = dyn Fn(LinkId, &str, [u8; 16], &[u8], Option<&RemoteIdentity>) + Send;

/// A managed link wrapping LinkEngine + optional Channel + resources.
pub(super) struct ManagedLink {
    pub(super) resource_generation: std::sync::Arc<()>,
    pub(super) engine: LinkEngine,
    pub(super) channel: Option<Channel>,
    /// Authenticated identity/request packets received before the responder's LRRTT.
    pub(super) pre_rtt_packets: Vec<PreRttPacket>,
    pub(super) pending_channel_packets: HashMap<[u8; 32], Sequence>,
    pub(super) channel_send_ok: u64,
    pub(super) channel_send_not_ready: u64,
    pub(super) channel_send_too_big: u64,
    pub(super) channel_send_other_error: u64,
    pub(super) channel_messages_received: u64,
    pub(super) channel_proofs_sent: u64,
    pub(super) channel_proofs_received: u64,
    /// Destination hash this link belongs to.
    pub(super) dest_hash: [u8; 16],
    /// Remote identity (hash, public_key) once identified.
    pub(super) remote_identity: Option<([u8; 16], [u8; 64])>,
    /// Destination's Ed25519 signing public key (for initiator to verify LRPROOF).
    pub(super) dest_sig_pub_bytes: Option<[u8; 32]>,
    /// Active incoming resource transfers.
    pub(super) incoming_resources: Vec<ResourceReceiver>,
    /// Hashes of incoming resources concluded since the last tick, so that an
    /// advertisement retry of one is still ignored after its receiver is gone.
    pub(super) concluded_incoming: std::collections::HashSet<Vec<u8>>,
    /// Active outgoing resource transfers.
    pub(super) outgoing_resources: Vec<ResourceSender>,
    /// Request IDs awaiting a packet or resource response.
    pub(super) pending_requests: HashMap<[u8; 16], PendingRequest>,
    /// Logical incoming split transfers, keyed by original resource hash.
    pub(super) incoming_splits: HashMap<[u8; 32], IncomingSplitTransfer>,
    /// Logical outgoing split transfers, keyed by original resource hash.
    pub(super) outgoing_splits: HashMap<[u8; 32], OutgoingSplitTransfer>,
    /// Reader state for bounded-memory outgoing transfers.
    pub(super) outgoing_streams: HashMap<[u8; 32], OutgoingStreamTransfer>,
    /// Resource acceptance strategy.
    pub(super) resource_strategy: ResourceStrategy,
    /// Delivery policy for independent incoming Resources.
    pub(super) resource_receive_mode: ResourceReceiveMode,
    /// Maximum accepted request size inherited from the local destination.
    pub(super) max_request_size: Option<usize>,
    /// Interface this link's packets should be sent on when known.
    pub(super) route_interface: Option<rns_core::transport::types::InterfaceId>,
    /// Next-hop transport ID seen on inbound HEADER_2 link traffic.
    ///
    /// When present, outbound link packets can be rewritten to HEADER_2 using
    /// this transport ID to preserve multi-hop routing.
    pub(super) route_transport_id: Option<[u8; 16]>,
}
pub(super) struct PendingRequest {
    pub(super) deadline: Option<f64>,
    pub(super) max_response_size: Option<usize>,
}

/// A registered link destination that can accept incoming LINKREQUEST.
pub(super) struct LinkDestination {
    pub(super) sig_prv: Ed25519PrivateKey,
    pub(super) sig_pub_bytes: [u8; 32],
    pub(super) resource_strategy: ResourceStrategy,
    pub(super) max_request_size: Option<usize>,
}

/// A registered request handler for a path.
pub(super) struct RequestHandlerEntry {
    /// The path this handler serves (e.g. "/status").
    pub(super) path: String,
    /// The truncated hash of the path (first 16 bytes of SHA-256).
    pub(super) path_hash: [u8; 16],
    /// Access control: None means allow all, Some(list) means allow only listed identities.
    pub(super) allowed_list: Option<Vec<[u8; 16]>>,
    /// Handler function: (link_id, path, request_id, data, remote_identity) -> Option<response>.
    pub(super) handler: Box<ImmediateRequestHandler>,
}

pub(super) struct DeferredRequestHandlerEntry {
    pub(super) path: String,
    pub(super) path_hash: [u8; 16],
    pub(super) allowed_list: Option<Vec<[u8; 16]>>,
    pub(super) handler: Box<DeferredHandler>,
}

pub(super) struct PreRttPacket {
    pub(super) packet: RawPacket,
    pub(super) packet_hash: [u8; 32],
    pub(super) receiving_interface: rns_core::transport::types::InterfaceId,
}