rns-embedded-core 0.5.1

Embedded-friendly Reticulum core primitives for no-std and constrained runtimes.
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

#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub struct ReplayWindow {
    highest: Option<u64>,
    seen: u64,
}

impl ReplayWindow {
    pub fn new() -> Self {
        Self { highest: None, seen: 0 }
    }

    pub fn highest(&self) -> Option<u64> {
        self.highest
    }

    pub fn accept(&mut self, sequence: u64) -> bool {
        match self.highest {
            None => {
                self.highest = Some(sequence);
                self.seen = 1;
                true
            }
            Some(highest) if sequence > highest => {
                let shift = sequence.saturating_sub(highest);
                self.seen = if shift >= 64 { 0 } else { self.seen << (shift as u32) };
                self.highest = Some(sequence);
                self.seen |= 1;
                true
            }
            Some(highest) => {
                let delta = highest - sequence;
                if delta >= 64 {
                    return false;
                }
                let bit = 1_u64 << (delta as u32);
                if (self.seen & bit) != 0 {
                    return false;
                }
                self.seen |= bit;
                true
            }
        }
    }
}

impl Default for ReplayWindow {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod tests {
    use super::ReplayWindow;

    #[test]
    fn accepts_forward_and_rejects_duplicates() {
        let mut window = ReplayWindow::new();
        assert!(window.accept(10));
        assert!(window.accept(11));
        assert!(!window.accept(11));
        assert!(window.accept(9));
        assert!(!window.accept(9));
    }

    #[test]
    fn rejects_far_old_sequences() {
        let mut window = ReplayWindow::new();
        assert!(window.accept(200));
        assert!(!window.accept(100));
    }
}