SEDSnet 4.3.7

A memory safe, no_std-capable networking stack with routing, discovery, reliability, and Rust/C/Python bindings.
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

use super::*;

fn learn(receiver: &Router, name: &str, address: u32) {
    let packets = Arc::new(std::sync::Mutex::new(Vec::new()));
    let capture = packets.clone();
    let producer = Router::new_with_clock(
        RouterConfig::new([])
            .with_hostname(name)
            .with_static_address(address),
        Box::new(|| 1),
    );
    producer.add_side_packet("wire", move |packet| {
        capture.lock().unwrap().push(packet.clone());
        Ok(())
    });
    producer.announce_discovery().unwrap();
    producer.process_all_queues_with_timeout(0).unwrap();
    let side = receiver.add_side_packet(name, |_| Ok(()));
    for packet in packets.lock().unwrap().iter() {
        receiver.rx_from_side(packet, side).unwrap();
    }
    receiver.process_all_queues_with_timeout(0).unwrap();
    assert_eq!(receiver.resolve_hostname(name).unwrap().address, address);
}
#[test]
fn sender_match_named_invalid_unknown_and_discovered_aliases() {
    let receiver = Router::new_with_clock(
        RouterConfig::new([])
            .with_hostname("identity-receiver")
            .with_static_address(5000),
        Box::new(|| 1),
    );
    let name = "identity-source";
    let compact = format!("@addr:{}", sender_address_u32(name));
    assert!(receiver.sender_matches_hostname(name, name));
    assert!(
        !receiver.sender_matches_hostname(&compact, name),
        "a deterministic hash alone must never establish identity"
    );
    for source in [
        "",
        "other-source",
        "@addr:",
        "@addr:+101",
        "@addr:-1",
        "@addr: 101",
        "@addr:101 ",
        "@addr:4294967296",
        "@addr:abc",
        "@addr:0",
        "@addr:unknown",
        "identity-source\0",
    ] {
        assert!(
            !receiver.sender_matches_hostname(source, name),
            "{source:?}"
        );
    }
    assert!(!receiver.sender_matches_hostname(name, ""));
    assert!(!receiver.sender_matches_hostname("@addr:101", "@addr:101"));
    learn(&receiver, name, 101);
    assert!(receiver.sender_matches_hostname(&compact, name));
    assert!(receiver.sender_matches_hostname("@addr:101", name));
    assert!(!receiver.sender_matches_hostname("@addr:102", name));
    assert!(!receiver.sender_matches_hostname(&compact, "other-source"));
    assert!(!receiver.sender_matches_hostname("identity-source", "IDENTITY-SOURCE"));
}
#[test]
fn sender_match_compact_collisions_fail_closed_while_assigned_owners_match() {
    let receiver = Router::new_with_clock(
        RouterConfig::new([])
            .with_hostname("identity-collision-receiver")
            .with_static_address(5000),
        Box::new(|| 1),
    );
    let a = "identity-collision-51666";
    let b = "identity-collision-117548";
    assert_eq!(sender_address_u32(a), 2711038533);
    assert_eq!(sender_address_u32(a), sender_address_u32(b));
    learn(&receiver, a, 101);
    assert!(receiver.sender_matches_hostname("@addr:2711038533", a));
    learn(&receiver, b, 102);
    assert!(!receiver.sender_matches_hostname("@addr:2711038533", a));
    assert!(!receiver.sender_matches_hostname("@addr:2711038533", b));
    assert!(receiver.sender_matches_hostname("@addr:101", a));
    assert!(receiver.sender_matches_hostname("@addr:102", b));
    assert!(!receiver.sender_matches_hostname("@addr:101", b));
    assert!(!receiver.sender_matches_hostname("@addr:102", a));
    // The existing assigned-address namespace stays authoritative.
    let assigned = "identity-explicit-address-owner";
    learn(&receiver, assigned, 2711038533);
    assert!(receiver.sender_matches_hostname("@addr:2711038533", assigned));
    assert!(!receiver.sender_matches_hostname("@addr:2711038533", a));
    assert!(!receiver.sender_matches_hostname("@addr:2711038533", b));
}
#[test]
fn sender_match_retained_bridge_connections_without_address_advertisement() {
    let receiver = Router::new_with_clock(
        RouterConfig::new([]).with_hostname("identity-bridge-receiver"),
        Box::new(|| 1),
    );
    let name = "identity-far-source";
    let alias = format!("@addr:{}", sender_address_u32(name));
    assert!(!receiver.sender_matches_hostname(&alias, name));
    let topology = crate::discovery::build_discovery_topology(
        "identity-bridge",
        1,
        &[crate::discovery::TopologyBoardNode {
            sender_id: "identity-bridge".into(),
            reachable_endpoints: vec![],
            reachable_timesync_sources: vec![],
            connections: vec![name.into()],
        }],
    )
    .unwrap();
    let side = receiver.add_side_packet("bridge", |_| Ok(()));
    receiver.rx_from_side(&topology, side).unwrap();
    receiver.process_all_queues_with_timeout(0).unwrap();
    assert!(receiver.sender_matches_hostname(&alias, name));
}