use heapless::Vec;
use super::{AccessList, ChangeLog, Device, EventLog, GroupKeyStore, Notice, Runtime};
use crate::clusters::access_control;
use crate::clusters::general_commissioning::Aftermath;
use crate::clusters::operational_credentials::FabricChange;
use crate::commissioning::failsafe::Cleanup;
use crate::config::Config;
use crate::crypto::KeyStore;
use crate::dm::EventPriority;
use crate::dm::events::{NewEvent, Timestamp};
use crate::im::{ClusterHandler, InteractionContext, Lifecycle};
use crate::msg::{FabricIndex, NodeId, SessionId};
use crate::platform::{Instant, Rng};
use crate::session::SessionKind;
#[derive(Debug, Default)]
pub(super) struct Deferred {
close_fabrics: Vec<FabricIndex, 2>,
close_pase: bool,
}
impl<
C: Config,
const S: usize,
const X: usize,
const I: usize,
const R: usize,
const Q: usize,
const B: usize,
> Runtime<C, S, X, I, R, Q, B>
{
pub(super) fn follow_up<K, G, H, Ac, Gk, Ev, V, const F: usize>(
&mut self,
device: &Device<'_, C, K, G, H, Ac, Gk, Ev, V, F>,
session: SessionId,
now: Instant,
) -> Deferred
where
K: KeyStore,
G: Rng,
H: ClusterHandler,
Ac: AccessList,
Gk: GroupKeyStore,
Ev: EventLog,
V: ChangeLog,
{
let mut deferred = Deferred::default();
let ctx = self.admin_context(session, now);
match device.commissioning.take_aftermath() {
Some(Aftermath::Rollback(cleanup)) => {
self.rollback(device, cleanup, &ctx, &mut deferred);
}
Some(Aftermath::Commissioned) => {
let committed = self
.stack
.sessions()
.find(session)
.map(|s| s.fabric_index)
.filter(|i| i.0 != 0);
device.credentials.commit_update();
if let Some(fabric) = committed {
device
.handler
.on_lifecycle(Lifecycle::CommissioningComplete(fabric));
self.notify(Notice::Commissioned(fabric));
}
deferred.close_pase = true;
}
None => {}
}
self.fabric_change(device, session, &ctx, &mut deferred);
self.audit(device, now);
deferred
}
fn admin_context(&self, session: SessionId, now: Instant) -> InteractionContext<'static> {
let mut ctx = InteractionContext::new().at(now).on_session(session);
if let Some(s) = self.stack.sessions().find(session) {
if s.fabric_index.0 != 0 {
ctx = ctx.with_fabric(s.fabric_index);
}
if s.peer_node_id.kind() == crate::msg::NodeIdKind::Operational {
ctx = ctx.from_peer(s.peer_node_id);
}
}
ctx
}
fn rollback<K, G, H, Ac, Gk, Ev, V, const F: usize>(
&mut self,
device: &Device<'_, C, K, G, H, Ac, Gk, Ev, V, F>,
cleanup: Cleanup,
ctx: &InteractionContext<'_>,
deferred: &mut Deferred,
) where
K: KeyStore,
G: Rng,
H: ClusterHandler,
Ac: AccessList,
Gk: GroupKeyStore,
Ev: EventLog,
V: ChangeLog,
{
deferred.close_pase |= cleanup.close_pase_sessions;
if let Some(fabric) = cleanup.close_case_sessions_for {
push_unique(&mut deferred.close_fabrics, fabric);
}
if let Some(fabric) = cleanup.revert_noc_for {
device.credentials.revert_update(fabric);
}
device.handler.on_lifecycle(Lifecycle::FailSafeExpired {
fabric: cleanup
.remove_fabric
.or(cleanup.revert_noc_for)
.or(cleanup.close_case_sessions_for),
});
if let Some(fabric) = cleanup.remove_fabric {
let _ = device.credentials.remove_fabric(fabric, ctx);
}
if cleanup.discard_operational_key || cleanup.prune_trusted_roots {
device.credentials.discard_pending();
}
self.notify(Notice::RolledBack);
}
fn fabric_change<K, G, H, Ac, Gk, Ev, V, const F: usize>(
&mut self,
device: &Device<'_, C, K, G, H, Ac, Gk, Ev, V, F>,
session: SessionId,
ctx: &InteractionContext<'_>,
deferred: &mut Deferred,
) where
K: KeyStore,
G: Rng,
H: ClusterHandler,
Ac: AccessList,
Gk: GroupKeyStore,
Ev: EventLog,
V: ChangeLog,
{
let Some(change) = device.credentials.take_change() else {
return;
};
match change {
FabricChange::Added {
index,
case_admin_subject,
bind_pase_session,
} => {
let _ = device
.access_control
.grant_admin(index, NodeId(case_admin_subject), ctx);
if bind_pase_session
&& let Some(s) = self.stack.sessions_mut().find_mut(session)
&& s.kind == SessionKind::Pase
{
s.fabric_index = index;
}
let ipk = device
.credentials
.fabrics
.borrow()
.find(index)
.map(|f| f.ipk.clone());
if let Some(ipk) = ipk {
let _ = device.group_keys.install_ipk(index, ipk);
}
self.notify(Notice::FabricAdded(index));
}
FabricChange::Updated { index } => self.notify(Notice::FabricUpdated(index)),
FabricChange::Removed { index, .. } => {
device.handler.on_lifecycle(Lifecycle::FabricRemoved(index));
self.im.subscriptions.remove_for_fabric(index);
device
.commissioning
.window
.borrow_mut()
.forget_fabric(index);
push_unique(&mut deferred.close_fabrics, index);
self.notify(Notice::FabricRemoved(index));
}
}
}
pub(super) fn audit<K, G, H, Ac, Gk, Ev, V, const F: usize>(
&mut self,
device: &Device<'_, C, K, G, H, Ac, Gk, Ev, V, F>,
now: Instant,
) where
K: KeyStore,
G: Rng,
H: ClusterHandler,
Ac: AccessList,
Gk: GroupKeyStore,
Ev: EventLog,
V: ChangeLog,
{
let mut lost: Vec<Option<crate::dm::events::RecordError>, 4> = Vec::new();
let mut recorded = false;
device.access_control.drain_changes(&mut |fabric, encoded| {
let Ok(data) = encoded else {
let _ = lost.push(None);
return;
};
let event = NewEvent {
endpoint: 0,
cluster: access_control::ID,
event: access_control::ACCESS_CONTROL_ENTRY_CHANGED,
priority: EventPriority::Info,
timestamp: Timestamp::System(now.as_millis()),
fabric_index: Some(fabric),
data,
};
match device.events.record(&event) {
Ok(_) => recorded = true,
Err(e) => {
let _ = lost.push(Some(e));
}
}
});
if recorded {
self.im.subscriptions.note_event(
0,
access_control::ID,
access_control::ACCESS_CONTROL_ENTRY_CHANGED,
);
}
for e in lost {
self.notify(Notice::EventLost(e));
}
}
pub(super) fn apply(&mut self, deferred: Deferred) {
for fabric in deferred.close_fabrics {
let sessions: Vec<SessionId, S> = self
.stack
.sessions()
.iter()
.filter(|s| s.fabric_index == fabric)
.map(|s| s.local_session_id)
.collect();
for session in sessions {
self.close_session(session);
}
self.im.subscriptions.remove_for_fabric(fabric);
}
if deferred.close_pase {
let sessions: Vec<SessionId, S> = self
.stack
.sessions()
.iter()
.filter(|s| s.kind == SessionKind::Pase)
.map(|s| s.local_session_id)
.collect();
for session in sessions {
self.close_session(session);
}
}
}
pub(super) fn expire_fail_safe<K, G, H, Ac, Gk, Ev, V, const F: usize>(
&mut self,
device: &Device<'_, C, K, G, H, Ac, Gk, Ev, V, F>,
now: Instant,
) where
K: KeyStore,
G: Rng,
H: ClusterHandler,
Ac: AccessList,
Gk: GroupKeyStore,
Ev: EventLog,
V: ChangeLog,
{
let lapsed = device.commissioning.fail_safe.borrow_mut().expire(now);
let Some(cleanup) = lapsed else {
return;
};
let mut deferred = Deferred::default();
let ctx = InteractionContext::new().at(now);
self.rollback(device, cleanup, &ctx, &mut deferred);
self.fabric_change(device, SessionId(0), &ctx, &mut deferred);
self.audit(device, now);
self.apply(deferred);
}
}
fn push_unique<const N: usize>(list: &mut Vec<FabricIndex, N>, fabric: FabricIndex) {
if !list.contains(&fabric) {
let _ = list.push(fabric);
}
}