use heapless::Vec;
use crate::msg::{CounterKind, CounterWindow, FabricIndex, NodeId, Verdict};
use super::keys::GroupKeySecurityPolicy;
pub const MIN_DATA_PEERS_PER_FABRIC: usize = 10;
pub const MIN_CONTROL_PEERS_PER_FABRIC: usize = 2;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Admitted {
Process,
Duplicate,
NeedsSync,
Untracked,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PeerState {
pub fabric_index: FabricIndex,
pub node: NodeId,
pub control: bool,
pub window: CounterWindow,
pub synchronized: bool,
}
#[derive(Debug)]
pub struct PeerTable<const D: usize, const C: usize> {
data: Vec<PeerState, D>,
control: Vec<PeerState, C>,
}
impl<const D: usize, const C: usize> Default for PeerTable<D, C> {
fn default() -> Self {
Self::new()
}
}
impl<const D: usize, const C: usize> PeerTable<D, C> {
#[must_use]
pub const fn new() -> Self {
Self {
data: Vec::new(),
control: Vec::new(),
}
}
#[must_use]
pub fn len(&self) -> (usize, usize) {
(self.data.len(), self.control.len())
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.data.is_empty() && self.control.is_empty()
}
#[must_use]
pub fn peer(&self, fabric: FabricIndex, node: NodeId, control: bool) -> Option<&PeerState> {
self.space(control)
.iter()
.find(|p| p.fabric_index == fabric && p.node == node)
}
pub fn admit(
&mut self,
fabric: FabricIndex,
node: NodeId,
control: bool,
counter: u32,
policy: GroupKeySecurityPolicy,
) -> Admitted {
if let Some(peer) = self.find_mut(fabric, node, control) {
if !peer.synchronized {
return Admitted::NeedsSync;
}
return match peer.window.accept(counter) {
Verdict::New => Admitted::Process,
Verdict::Duplicate => Admitted::Duplicate,
};
}
let trust_first = control || policy == GroupKeySecurityPolicy::TrustFirst;
let state = PeerState {
fabric_index: fabric,
node,
control,
window: CounterWindow::primed_at(CounterKind::Rollover, counter),
synchronized: trust_first,
};
if self.push(state, control).is_err() {
return Admitted::Untracked;
}
if trust_first {
Admitted::Process
} else {
Admitted::NeedsSync
}
}
pub fn synchronize(&mut self, fabric: FabricIndex, node: NodeId, counter: u32) -> bool {
let Some(peer) = self.find_mut(fabric, node, false) else {
return false;
};
peer.window = CounterWindow::primed_at(CounterKind::Rollover, counter);
peer.synchronized = true;
true
}
pub fn remove_fabric(&mut self, fabric: FabricIndex) {
self.data.retain(|p| p.fabric_index != fabric);
self.control.retain(|p| p.fabric_index != fabric);
}
fn space(&self, control: bool) -> &[PeerState] {
if control { &self.control } else { &self.data }
}
fn find_mut(
&mut self,
fabric: FabricIndex,
node: NodeId,
control: bool,
) -> Option<&mut PeerState> {
let space: &mut [PeerState] = if control {
&mut self.control
} else {
&mut self.data
};
space
.iter_mut()
.find(|p| p.fabric_index == fabric && p.node == node)
}
fn push(&mut self, state: PeerState, control: bool) -> core::result::Result<(), ()> {
if control {
self.control.push(state).map_err(|_| ())
} else {
self.data.push(state).map_err(|_| ())
}
}
}
#[cfg(test)]
mod tests {
use super::*;
const F1: FabricIndex = FabricIndex(1);
const A: NodeId = NodeId(0x1111);
const B: NodeId = NodeId(0x2222);
type Table = PeerTable<2, 1>;
#[test]
fn trust_first_accepts_whatever_arrives_first() {
let mut table = Table::new();
let policy = GroupKeySecurityPolicy::TrustFirst;
assert_eq!(table.admit(F1, A, false, 5000, policy), Admitted::Process);
assert_eq!(table.admit(F1, A, false, 5001, policy), Admitted::Process);
assert_eq!(table.admit(F1, A, false, 5001, policy), Admitted::Duplicate);
assert_eq!(table.admit(F1, A, false, 4000, policy), Admitted::Duplicate);
}
#[test]
fn cache_and_sync_holds_the_first_message() {
let mut table = Table::new();
let policy = GroupKeySecurityPolicy::CacheAndSync;
assert_eq!(table.admit(F1, A, false, 5000, policy), Admitted::NeedsSync);
assert_eq!(table.admit(F1, A, false, 5001, policy), Admitted::NeedsSync);
assert!(table.synchronize(F1, A, 5000));
assert_eq!(table.admit(F1, A, false, 5001, policy), Admitted::Process);
assert_eq!(table.admit(F1, A, false, 5000, policy), Admitted::Duplicate);
}
#[test]
fn a_control_message_is_always_trust_first() {
let mut table = Table::new();
assert_eq!(
table.admit(F1, A, true, 9, GroupKeySecurityPolicy::CacheAndSync),
Admitted::Process
);
}
#[test]
fn the_two_counter_spaces_are_independent() {
let mut table = Table::new();
let policy = GroupKeySecurityPolicy::TrustFirst;
assert_eq!(table.admit(F1, A, false, 100, policy), Admitted::Process);
assert_eq!(table.admit(F1, A, true, 100, policy), Admitted::Process);
assert_eq!(table.admit(F1, A, false, 101, policy), Admitted::Process);
assert_eq!(table.peer(F1, A, true).unwrap().window.max(), 100);
}
#[test]
fn a_full_table_refuses_rather_than_recycling() {
let mut table = PeerTable::<1, 1>::new();
let policy = GroupKeySecurityPolicy::TrustFirst;
assert_eq!(table.admit(F1, A, false, 1, policy), Admitted::Process);
assert_eq!(table.admit(F1, B, false, 1, policy), Admitted::Untracked);
assert_eq!(table.admit(F1, A, false, 2, policy), Admitted::Process);
}
#[test]
fn a_group_counter_rolls_over() {
let mut table = Table::new();
let policy = GroupKeySecurityPolicy::TrustFirst;
assert_eq!(
table.admit(F1, A, false, u32::MAX, policy),
Admitted::Process
);
assert_eq!(table.admit(F1, A, false, 0, policy), Admitted::Process);
assert_eq!(table.admit(F1, A, false, 1, policy), Admitted::Process);
}
}