use core::cell::{Cell, RefCell};
use crate::clusters::generated::commissioner_control as spec_cctrl;
use crate::dm::spec::{Conforming, Optional};
use crate::dm::{Resolved, ResolvedCommand};
use crate::im::{ClusterHandler, ClusterId, CommandId, InteractionContext, Status, StatusIb};
use crate::msg::{FabricIndex, NodeId, VendorId};
use crate::tlv::{Tag, TlvWriter, ToTlv};
use super::Cluster;
pub use spec_cctrl::attribute::SUPPORTED_DEVICE_CATEGORIES;
pub use spec_cctrl::command::{
COMMISSION_NODE, REQUEST_COMMISSIONING_APPROVAL, REVERSE_OPEN_COMMISSIONING_WINDOW,
};
pub use spec_cctrl::event::COMMISSIONING_REQUEST_RESULT;
pub use spec_cctrl::{ID, PICS, REVISION, SupportedDeviceCategoryBitmap};
pub const LABEL_MAX: usize = 64;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Request {
pub request_id: u64,
pub client_node_id: NodeId,
pub fabric: FabricIndex,
pub vendor_id: VendorId,
pub product_id: u16,
pub approved: Option<bool>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Decision {
Approved,
TimedOut,
Refused,
}
impl Decision {
#[must_use]
pub const fn status(self) -> Status {
match self {
Self::Approved => Status::Success,
Self::TimedOut => Status::Timeout,
Self::Refused => Status::Failure,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct CommissioningRequestResult {
pub request_id: u64,
pub client_node_id: NodeId,
pub decision: Decision,
}
#[derive(Debug, Clone, Copy)]
pub struct Window<'a> {
pub commissioning_timeout: u16,
pub pake_passcode_verifier: &'a [u8],
pub discriminator: u16,
pub iterations: u32,
pub salt: &'a [u8],
}
pub const VERIFIER_LEN: usize = 97;
pub trait CommissionerControlHooks {
fn requested(&self, request: &Request);
fn window(&self, request: &Request) -> Option<Window<'_>>;
}
#[derive(Debug)]
pub struct CommissionerControl<'a, H: CommissionerControlHooks, const N: usize = 4> {
hooks: &'a H,
categories: SupportedDeviceCategoryBitmap,
pending: RefCell<heapless::Vec<Request, N>>,
events: RefCell<heapless::Vec<CommissioningRequestResult, N>>,
reverse: Cell<bool>,
}
impl<'a, H: CommissionerControlHooks, const N: usize> CommissionerControl<'a, H, N> {
#[must_use]
pub fn new(hooks: &'a H, categories: SupportedDeviceCategoryBitmap) -> Self {
Self {
hooks,
categories,
pending: RefCell::new(heapless::Vec::new()),
events: RefCell::new(heapless::Vec::new()),
reverse: Cell::new(false),
}
}
pub fn conforming(
feature_map: u32,
optional: &Optional<'_>,
) -> crate::error::Result<Conforming<1, 2, 1, 1>> {
Conforming::new(&spec_cctrl::CLUSTER, feature_map, optional)
}
#[must_use]
pub const fn categories(&self) -> SupportedDeviceCategoryBitmap {
self.categories
}
#[must_use]
pub fn pending(&self) -> core::cell::Ref<'_, heapless::Vec<Request, N>> {
self.pending.borrow()
}
pub fn decide(&self, request_id: u64, client: NodeId, decision: Decision) -> bool {
let mut pending = self.pending.borrow_mut();
let Some(request) = pending
.iter_mut()
.find(|r| r.request_id == request_id && r.client_node_id == client)
else {
return false;
};
request.approved = Some(decision == Decision::Approved);
drop(pending);
let mut events = self.events.borrow_mut();
if events.is_full() {
events.remove(0);
}
let _ = events.push(CommissioningRequestResult {
request_id,
client_node_id: client,
decision,
});
true
}
pub fn take_events(&self) -> heapless::Vec<CommissioningRequestResult, N> {
core::mem::take(&mut self.events.borrow_mut())
}
#[must_use]
pub fn reverse_pending(&self) -> bool {
self.reverse.replace(false)
}
pub fn forget(&self, request_id: u64, client: NodeId) {
self.pending
.borrow_mut()
.retain(|r| !(r.request_id == request_id && r.client_node_id == client));
}
}
impl<H: CommissionerControlHooks, const N: usize> ClusterHandler for CommissionerControl<'_, H, N> {
fn read(
&self,
resolved: &Resolved<'_>,
_ctx: &InteractionContext<'_>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<(), Status> {
if resolved.attribute != SUPPORTED_DEVICE_CATEGORIES {
return Err(Status::UnsupportedAttribute);
}
w.unsigned(tag, u64::from(self.categories.bits()))
.map_err(|_| Status::ResourceExhausted)
}
fn invoke(
&self,
resolved: &ResolvedCommand<'_>,
fields: Option<&[u8]>,
ctx: &InteractionContext<'_>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<Option<CommandId>, StatusIb> {
let payload = || fields.ok_or(StatusIb::from(Status::InvalidCommand));
let (Some(fabric), Some(client)) = (ctx.fabric_index, ctx.peer_node_id) else {
return Err(Status::UnsupportedAccess.into());
};
match resolved.command.id {
REQUEST_COMMISSIONING_APPROVAL => {
let decoded: spec_cctrl::RequestCommissioningApprovalFields<'_> =
super::decode_fields(payload()?)?;
if decoded.label.is_some_and(|label| label.len() > LABEL_MAX) {
return Err(Status::ConstraintError.into());
}
let mut pending = self.pending.borrow_mut();
if pending
.iter()
.any(|r| r.request_id == decoded.request_id && r.client_node_id == client)
{
return Err(Status::Failure.into());
}
let request = Request {
request_id: decoded.request_id,
client_node_id: client,
fabric,
vendor_id: decoded.vendor_id,
product_id: decoded.product_id,
approved: None,
};
pending
.push(request)
.map_err(|_| StatusIb::from(Status::ResourceExhausted))?;
drop(pending);
self.hooks.requested(&request);
Ok(None)
}
COMMISSION_NODE => {
let decoded: spec_cctrl::CommissionNodeFields = super::decode_fields(payload()?)?;
let pending = self.pending.borrow();
let Some(request) = pending.iter().copied().find(|r| {
r.request_id == decoded.request_id
&& r.client_node_id == client
&& r.fabric == fabric
}) else {
return Err(Status::Failure.into());
};
drop(pending);
if request.approved != Some(true) {
return Err(Status::Failure.into());
}
let Some(window) = self.hooks.window(&request) else {
return Err(Status::Failure.into());
};
if window.pake_passcode_verifier.len() != VERIFIER_LEN
|| window.discriminator > 0x0FFF
|| !(1_000..=100_000).contains(&window.iterations)
|| !(16..=32).contains(&window.salt.len())
{
return Err(Status::Failure.into());
}
let _ = decoded.response_timeout_seconds;
self.reverse.set(true);
spec_cctrl::ReverseOpenCommissioningWindowFields {
commissioning_timeout: window.commissioning_timeout,
pake_passcode_verifier: window.pake_passcode_verifier,
discriminator: window.discriminator,
iterations: window.iterations,
salt: window.salt,
}
.to_tlv(w, tag)
.map_err(|_| StatusIb::from(Status::Failure))?;
Ok(Some(REVERSE_OPEN_COMMISSIONING_WINDOW))
}
_ => Err(Status::UnsupportedCommand.into()),
}
}
}
impl<H: CommissionerControlHooks, const N: usize> Cluster for CommissionerControl<'_, H, N> {
const ID: ClusterId = ID;
}