fips-core 0.3.68

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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use super::super::*;

// ========================================================================
// link_mtu tests
// ========================================================================

/// Minimal mock transport for testing the default link_mtu() behavior.
struct MockTransport {
    id: TransportId,
    mtu_value: u16,
}

impl MockTransport {
    fn new(mtu: u16) -> Self {
        Self {
            id: TransportId::new(99),
            mtu_value: mtu,
        }
    }
}

impl Transport for MockTransport {
    fn transport_id(&self) -> TransportId {
        self.id
    }
    fn transport_type(&self) -> &TransportType {
        &TransportType::UDP
    }
    fn state(&self) -> TransportState {
        TransportState::Up
    }
    fn mtu(&self) -> u16 {
        self.mtu_value
    }
    fn start(&mut self) -> Result<(), TransportError> {
        Ok(())
    }
    fn stop(&mut self) -> Result<(), TransportError> {
        Ok(())
    }
    fn send(&self, _addr: &TransportAddr, _data: &[u8]) -> Result<(), TransportError> {
        Ok(())
    }
    fn discover(&self) -> Result<Vec<DiscoveredPeer>, TransportError> {
        Ok(vec![])
    }
}

/// Mock transport that overrides link_mtu() to return per-link values.
struct PerLinkMtuTransport {
    id: TransportId,
    default_mtu: u16,
    /// Address-specific MTU overrides.
    overrides: Vec<(TransportAddr, u16)>,
}

impl PerLinkMtuTransport {
    fn new(default_mtu: u16, overrides: Vec<(TransportAddr, u16)>) -> Self {
        Self {
            id: TransportId::new(100),
            default_mtu,
            overrides,
        }
    }
}

impl Transport for PerLinkMtuTransport {
    fn transport_id(&self) -> TransportId {
        self.id
    }
    fn transport_type(&self) -> &TransportType {
        &TransportType::UDP
    }
    fn state(&self) -> TransportState {
        TransportState::Up
    }
    fn mtu(&self) -> u16 {
        self.default_mtu
    }
    fn link_mtu(&self, addr: &TransportAddr) -> u16 {
        for (a, mtu) in &self.overrides {
            if a == addr {
                return *mtu;
            }
        }
        self.mtu()
    }
    fn start(&mut self) -> Result<(), TransportError> {
        Ok(())
    }
    fn stop(&mut self) -> Result<(), TransportError> {
        Ok(())
    }
    fn send(&self, _addr: &TransportAddr, _data: &[u8]) -> Result<(), TransportError> {
        Ok(())
    }
    fn discover(&self) -> Result<Vec<DiscoveredPeer>, TransportError> {
        Ok(vec![])
    }
}

#[test]
fn test_link_mtu_default_falls_back_to_mtu() {
    let transport = MockTransport::new(1280);
    let addr = TransportAddr::from_string("192.168.1.1:2121");

    // Default link_mtu() should return the transport-wide mtu()
    assert_eq!(transport.link_mtu(&addr), 1280);
    assert_eq!(transport.link_mtu(&addr), transport.mtu());

    // Any address should return the same value
    let other_addr = TransportAddr::from_string("10.0.0.1:5000");
    assert_eq!(transport.link_mtu(&other_addr), 1280);
}

#[test]
fn test_link_mtu_per_link_override() {
    let addr_a = TransportAddr::from_string("192.168.1.1:2121");
    let addr_b = TransportAddr::from_string("10.0.0.1:5000");
    let addr_unknown = TransportAddr::from_string("172.16.0.1:6000");

    let transport =
        PerLinkMtuTransport::new(1280, vec![(addr_a.clone(), 512), (addr_b.clone(), 247)]);

    // Known addresses return their per-link MTU
    assert_eq!(transport.link_mtu(&addr_a), 512);
    assert_eq!(transport.link_mtu(&addr_b), 247);

    // Unknown address falls back to transport-wide default
    assert_eq!(transport.link_mtu(&addr_unknown), 1280);
    assert_eq!(transport.mtu(), 1280);
}

#[test]
fn test_transport_handle_link_mtu_delegation() {
    use crate::config::UdpConfig;
    use crate::transport::packet_channel;
    use crate::transport::udp::UdpTransport;

    let config = UdpConfig::default();
    let expected_mtu = config.mtu();
    let (tx, _rx) = packet_channel(1);
    let transport = UdpTransport::new(TransportId::new(1), None, config, tx);
    let handle = TransportHandle::Udp(transport);

    let addr = TransportAddr::from_string("192.168.1.1:2121");

    // TransportHandle::link_mtu() should delegate and return the same
    // as TransportHandle::mtu() for UDP (no per-link overrides)
    assert_eq!(handle.link_mtu(&addr), expected_mtu);
    assert_eq!(handle.link_mtu(&addr), handle.mtu());
}