use std::collections::{BTreeMap, BTreeSet};
use thiserror::Error;
use crate::mesh::{DeviceId, KeyMaterial, MeshGraph, NetworkId, NodeState, ReplayWindow, Schedule};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct JoinRequest {
pub device: DeviceId,
pub network: NetworkId,
pub security_counter: u32,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum JoinDecision {
Accepted {
nickname: u16,
},
NotAllowed,
WrongNetwork,
AuthenticationFailed,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct MeshSnapshot {
pub nodes: usize,
pub links: usize,
pub cells: usize,
}
pub struct MeshManager {
network: NetworkId,
graph: MeshGraph,
schedule: Schedule,
allowlist: BTreeSet<DeviceId>,
join_keys: BTreeMap<DeviceId, KeyMaterial>,
replay: BTreeMap<DeviceId, ReplayWindow>,
next_nickname: u16,
}
impl core::fmt::Debug for MeshManager {
fn fmt(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter
.debug_struct("MeshManager")
.field("network", &self.network)
.field("graph", &self.graph)
.field("schedule", &self.schedule)
.field("allowlist", &self.allowlist)
.field("join_keys", &"[redacted]")
.field("replay", &self.replay)
.field("next_nickname", &self.next_nickname)
.finish()
}
}
impl MeshManager {
pub fn new(network: NetworkId, superframe_size: u16) -> Result<Self, MeshManagerError> {
Ok(Self {
network,
graph: MeshGraph::default(),
schedule: Schedule::new(superframe_size)?,
allowlist: BTreeSet::new(),
join_keys: BTreeMap::new(),
replay: BTreeMap::new(),
next_nickname: 1,
})
}
pub fn allow(&mut self, device: DeviceId, join_key: KeyMaterial) {
self.allowlist.insert(device);
if self.join_keys.insert(device, join_key).is_some() {
self.replay.remove(&device);
self.graph.remove_node(device);
self.schedule.remove_device(device);
}
}
pub fn revoke(&mut self, device: DeviceId) {
self.allowlist.remove(&device);
self.join_keys.remove(&device);
self.replay.remove(&device);
self.graph.remove_node(device);
self.schedule.remove_device(device);
}
fn apply_join(&mut self, request: JoinRequest) -> Result<JoinDecision, MeshManagerError> {
if request.network != self.network {
return Ok(JoinDecision::WrongNetwork);
}
if !self.allowlist.contains(&request.device)
|| !self.join_keys.contains_key(&request.device)
{
return Ok(JoinDecision::NotAllowed);
}
if let Some(node) = self.graph.node(request.device)
&& node.active
{
self.replay
.entry(request.device)
.or_default()
.accept(request.security_counter)?;
return Ok(JoinDecision::Accepted {
nickname: node.nickname,
});
}
if self.next_nickname == 0 {
return Err(MeshManagerError::AddressSpace);
}
self.replay
.entry(request.device)
.or_default()
.accept(request.security_counter)?;
let nickname = self.next_nickname;
self.next_nickname = self.next_nickname.checked_add(1).unwrap_or(0);
self.graph.upsert_node(NodeState {
id: request.device,
nickname,
active: true,
});
Ok(JoinDecision::Accepted { nickname })
}
pub fn join_authenticated(
&mut self,
request: JoinRequest,
authenticate: impl FnOnce(&JoinRequest, &[u8; 16]) -> bool,
) -> Result<JoinDecision, MeshManagerError> {
if request.network != self.network {
return Ok(JoinDecision::WrongNetwork);
}
let Some(join_key) = self.join_keys.get(&request.device) else {
return Ok(JoinDecision::NotAllowed);
};
if !self.allowlist.contains(&request.device) {
return Ok(JoinDecision::NotAllowed);
}
if !authenticate(&request, join_key.expose()) {
return Ok(JoinDecision::AuthenticationFailed);
}
self.apply_join(request)
}
pub const fn graph_mut(&mut self) -> &mut MeshGraph {
&mut self.graph
}
pub const fn schedule_mut(&mut self) -> &mut Schedule {
&mut self.schedule
}
pub fn snapshot(&self) -> MeshSnapshot {
MeshSnapshot {
nodes: self.graph.node_count(),
links: self.graph.link_count(),
cells: self.schedule.cells().len(),
}
}
}
#[derive(Debug, Error)]
pub enum MeshManagerError {
#[error(transparent)]
Schedule(#[from] crate::mesh::ScheduleError),
#[error(transparent)]
Security(#[from] crate::mesh::SecurityError),
#[error("short network-address space exhausted")]
AddressSpace,
}