use crate::error::{Result, bail};
use crate::msg::FabricIndex;
use crate::platform::{Duration, Instant};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(u8)]
#[non_exhaustive]
pub enum CommissioningError {
Ok = 0,
ValueOutsideRange = 1,
InvalidAuthentication = 2,
NoFailSafe = 3,
BusyWithOtherAdmin = 4,
RequiredTcNotAccepted = 5,
TcAcknowledgementsNotReceived = 6,
TcMinVersionNotMet = 7,
}
impl CommissioningError {
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
#[must_use]
pub const fn is_ok(self) -> bool {
matches!(self, Self::Ok)
}
}
pub const DEFAULT_EXPIRY_SECONDS: u16 = 900;
pub const DEFAULT_MAX_CUMULATIVE_SECONDS: u16 = 900;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct BasicCommissioningInfo {
pub expiry_length_seconds: u16,
pub max_cumulative_seconds: u16,
}
impl Default for BasicCommissioningInfo {
fn default() -> Self {
Self {
expiry_length_seconds: DEFAULT_EXPIRY_SECONDS,
max_cumulative_seconds: DEFAULT_MAX_CUMULATIVE_SECONDS,
}
}
}
impl BasicCommissioningInfo {
#[must_use]
pub const fn is_valid(&self) -> bool {
self.max_cumulative_seconds >= self.expiry_length_seconds
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct Progress {
pub added_noc: bool,
pub updated_noc: bool,
pub csr_requested: bool,
pub added_trusted_root: bool,
pub changed_networks: bool,
}
impl Progress {
#[must_use]
pub const fn orphaned_operational_key(&self) -> bool {
self.csr_requested && !self.added_noc && !self.updated_noc
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Armed {
pub expires_at: Instant,
pub cumulative_expires_at: Instant,
pub fabric_index: Option<FabricIndex>,
pub progress: Progress,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct FailSafe {
info: BasicCommissioningInfo,
armed: Option<Armed>,
breadcrumb: u64,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Cleanup {
pub close_pase_sessions: bool,
pub close_case_sessions_for: Option<FabricIndex>,
pub restore_networks: bool,
pub revert_noc_for: Option<FabricIndex>,
pub remove_fabric: Option<FabricIndex>,
pub discard_operational_key: bool,
pub prune_trusted_roots: bool,
}
impl FailSafe {
#[must_use]
pub const fn new(info: BasicCommissioningInfo) -> Self {
Self {
info,
armed: None,
breadcrumb: 0,
}
}
#[must_use]
pub const fn info(&self) -> BasicCommissioningInfo {
self.info
}
#[must_use]
pub const fn breadcrumb(&self) -> u64 {
self.breadcrumb
}
pub const fn set_breadcrumb(&mut self, value: u64) {
self.breadcrumb = value;
}
#[must_use]
pub fn is_armed(&self, now: Instant) -> bool {
self.armed
.is_some_and(|armed| !Self::has_expired(&armed, now))
}
#[must_use]
pub fn armed(&self, now: Instant) -> Option<Armed> {
self.armed.filter(|armed| !Self::has_expired(armed, now))
}
#[must_use]
pub fn next_deadline(&self) -> Option<Instant> {
self.armed.map(|armed| {
if armed.cumulative_expires_at < armed.expires_at {
armed.cumulative_expires_at
} else {
armed.expires_at
}
})
}
fn has_expired(armed: &Armed, now: Instant) -> bool {
now >= armed.expires_at || now >= armed.cumulative_expires_at
}
pub fn arm(
&mut self,
expiry_length_seconds: u16,
breadcrumb: u64,
accessing_fabric: Option<FabricIndex>,
now: Instant,
window_open_over_case: bool,
) -> ArmResult {
let lapsed = self.expire(now);
let live = self.armed(now);
let outcome = if live.is_none() && window_open_over_case {
ArmOutcome::Refused(CommissioningError::BusyWithOtherAdmin)
} else {
match (expiry_length_seconds, live) {
(0, Some(armed)) if armed.fabric_index == accessing_fabric => {
let cleanup = self.expire_now(armed);
return ArmResult {
outcome: ArmOutcome::Disarmed,
cleanup: lapsed.or(Some(cleanup)),
};
}
(0, None) => {
self.breadcrumb = breadcrumb;
ArmOutcome::NoChange
}
(0, Some(_)) => ArmOutcome::Refused(CommissioningError::BusyWithOtherAdmin),
(seconds, None) => {
let cumulative = now.saturating_add(Duration::from_secs(u64::from(
self.info.max_cumulative_seconds,
)));
self.armed = Some(Armed {
expires_at: Self::deadline(now, seconds, cumulative),
cumulative_expires_at: cumulative,
fabric_index: accessing_fabric,
progress: Progress::default(),
});
self.breadcrumb = breadcrumb;
ArmOutcome::Armed
}
(seconds, Some(armed)) if armed.fabric_index == accessing_fabric => {
self.armed = Some(Armed {
expires_at: Self::deadline(now, seconds, armed.cumulative_expires_at),
..armed
});
self.breadcrumb = breadcrumb;
ArmOutcome::Armed
}
(_, Some(_)) => ArmOutcome::Refused(CommissioningError::BusyWithOtherAdmin),
}
};
ArmResult {
outcome,
cleanup: lapsed,
}
}
fn deadline(now: Instant, seconds: u16, cumulative: Instant) -> Instant {
let requested = now.saturating_add(Duration::from_secs(u64::from(seconds)));
if requested > cumulative {
cumulative
} else {
requested
}
}
pub fn record(&mut self, now: Instant, f: impl FnOnce(&mut Progress)) -> Result<()> {
let Some(armed) = self.armed.as_mut().filter(|a| !Self::has_expired(a, now)) else {
bail!(InvalidState)
};
f(&mut armed.progress);
Ok(())
}
pub fn adopt_fabric(&mut self, fabric: FabricIndex, now: Instant) -> Result<()> {
let Some(armed) = self.armed.as_mut().filter(|a| !Self::has_expired(a, now)) else {
bail!(InvalidState)
};
armed.fabric_index = Some(fabric);
Ok(())
}
pub fn complete(
&mut self,
over_case: bool,
accessing_fabric: Option<FabricIndex>,
now: Instant,
) -> CompleteResult {
let lapsed = self.expire(now);
let Some(armed) = self.armed(now) else {
return CompleteResult {
error: CommissioningError::NoFailSafe,
cleanup: lapsed,
};
};
if !over_case {
return CompleteResult {
error: CommissioningError::InvalidAuthentication,
cleanup: lapsed,
};
}
if accessing_fabric.is_none() || accessing_fabric != armed.fabric_index {
return CompleteResult {
error: CommissioningError::InvalidAuthentication,
cleanup: lapsed,
};
}
self.armed = None;
self.breadcrumb = 0;
CompleteResult {
error: CommissioningError::Ok,
cleanup: lapsed,
}
}
pub fn expire(&mut self, now: Instant) -> Option<Cleanup> {
let armed = self.armed?;
if !Self::has_expired(&armed, now) {
return None;
}
Some(self.expire_now(armed))
}
fn expire_now(&mut self, armed: Armed) -> Cleanup {
self.armed = None;
self.breadcrumb = 0;
let progress = armed.progress;
Cleanup {
close_pase_sessions: true,
close_case_sessions_for: (progress.added_noc || progress.updated_noc)
.then_some(armed.fabric_index)
.flatten(),
restore_networks: progress.changed_networks,
revert_noc_for: progress.updated_noc.then_some(armed.fabric_index).flatten(),
remove_fabric: progress.added_noc.then_some(armed.fabric_index).flatten(),
discard_operational_key: progress.orphaned_operational_key(),
prune_trusted_roots: progress.added_trusted_root,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ArmOutcome {
Armed,
NoChange,
Disarmed,
Refused(CommissioningError),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ArmResult {
pub outcome: ArmOutcome,
pub cleanup: Option<Cleanup>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct CompleteResult {
pub error: CommissioningError,
pub cleanup: Option<Cleanup>,
}
impl ArmOutcome {
#[must_use]
pub const fn error_code(&self) -> CommissioningError {
match self {
Self::Armed | Self::NoChange | Self::Disarmed => CommissioningError::Ok,
Self::Refused(error) => *error,
}
}
}