fips-core 0.3.90

Reusable FIPS mesh, endpoint, transport, and protocol library
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

fn copy_forwarded_session_datagram(payload: &[u8], ttl: u8, path_mtu: u16) -> Vec<u8> {
    let mut buf = Vec::with_capacity(1 + payload.len());
    buf.push(LinkMessageType::SessionDatagram.to_byte());
    buf.extend_from_slice(payload);
    let rewritten = rewrite_forwarded_session_datagram_bytes(&mut buf, ttl, path_mtu);
    debug_assert!(
        rewritten,
        "decoded session datagram must remain rewriteable"
    );
    buf
}

fn rewrite_forwarded_session_datagram(
    plaintext: &mut PacketBuffer,
    ttl: u8,
    path_mtu: u16,
) -> bool {
    rewrite_forwarded_session_datagram_bytes(plaintext.as_mut_slice(), ttl, path_mtu)
}

fn rewrite_forwarded_session_datagram_bytes(plaintext: &mut [u8], ttl: u8, path_mtu: u16) -> bool {
    let Some(header) = plaintext.get_mut(..4) else {
        return false;
    };
    if header[0] != LinkMessageType::SessionDatagram.to_byte() {
        return false;
    }
    header[1] = ttl;
    header[2..4].copy_from_slice(&path_mtu.to_le_bytes());
    true
}

fn owned_session_datagram_from_ref(
    datagram: &SessionDatagramRef<'_>,
    ttl: u8,
    path_mtu: u16,
) -> SessionDatagram {
    SessionDatagram {
        src_addr: datagram.src_addr,
        dest_addr: datagram.dest_addr,
        ttl,
        path_mtu,
        payload: datagram.payload.to_vec(),
    }
}

fn claim_route_failure_once(
    failed_routes: &mut std::collections::HashSet<(NodeAddr, NodeAddr)>,
    dest_addr: NodeAddr,
    next_hop_addr: NodeAddr,
    failed: bool,
) -> bool {
    failed && failed_routes.insert((dest_addr, next_hop_addr))
}

fn forward_run_reached_limit(run_len: usize, configured_limit: usize) -> bool {
    run_len >= configured_limit.max(1)
}

fn forwarding_lane(forward: &PreparedSessionForward) -> ForwardingLane {
    if crate::node::endpoint_traffic::fmp_plaintext_is_bulk_session_datagram(
        forward.plaintext.as_slice(),
    ) {
        ForwardingLane::Bulk
    } else {
        ForwardingLane::Priority
    }
}

fn forwarding_submission_limit(transport_batch_packets: usize) -> usize {
    transport_batch_packets
        .clamp(1, crate::dataplane::DATAPLANE_TRANSPORT_SEND_BATCH_PACKETS)
        .saturating_mul(FORWARDING_IN_FLIGHT_TRANSPORT_BATCHES)
}