use core::cell::{Cell, RefCell};
use crate::clusters::generated::joint_fabric_administrator as spec_jf;
use crate::commissioning::failsafe::FailSafe;
use crate::commissioning::window::CommissioningWindow;
use crate::dm::spec::{Conforming, Optional};
use crate::dm::{Resolved, ResolvedCommand};
use crate::im::{
ClusterHandler, ClusterId, CommandId, EndpointId, InteractionContext, Status, StatusIb,
};
use crate::msg::FabricIndex;
use crate::tlv::{Tag, TlvWriter, ToTlv};
use super::Cluster;
pub use spec_jf::attribute::ADMINISTRATOR_FABRIC_INDEX;
pub use spec_jf::command::{
ADD_ICAC, ANNOUNCE_JOINT_FABRIC_ADMINISTRATOR, ICAC_RESPONSE, ICACCSR_REQUEST,
ICACCSR_RESPONSE, OPEN_JOINT_COMMISSIONING_WINDOW, TRANSFER_ANCHOR_COMPLETE,
TRANSFER_ANCHOR_REQUEST, TRANSFER_ANCHOR_RESPONSE,
};
pub use spec_jf::{
ICACCSRResponseStatusCodeEnum, ICACResponseStatusEnum, ID, PICS, REVISION,
TransferAnchorResponseStatusEnum,
};
pub const ICACCSR_MAX: usize = 600;
pub const ICAC_MAX: usize = 400;
pub trait JointFabricHooks {
fn write_icac_csr(&self, out: &mut [u8]) -> core::result::Result<usize, Status>;
fn validate_icac(&self, icac: &[u8], fabric: FabricIndex) -> ICACResponseStatusEnum;
fn install_icac(&self, icac: &[u8], fabric: FabricIndex) -> core::result::Result<(), Status>;
fn anchor_transfer(&self) -> AnchorTransfer {
AnchorTransfer::Refused(TransferAnchorResponseStatusEnum::TransferAnchorStatusNoUserConsent)
}
fn anchor_transferred(&self) {}
fn administrator_announced(&self, endpoint: EndpointId) {
let _ = endpoint;
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AnchorTransfer {
Accepted,
Refused(TransferAnchorResponseStatusEnum),
}
#[derive(Debug)]
pub struct JointFabricAdministrator<'a, H: JointFabricHooks> {
hooks: &'a H,
fail_safe: &'a RefCell<FailSafe>,
window: &'a RefCell<CommissioningWindow>,
administrator_fabric: Cell<Option<FabricIndex>>,
csr_issued_to: Cell<Option<FabricIndex>>,
icac_added: Cell<bool>,
}
impl<'a, H: JointFabricHooks> JointFabricAdministrator<'a, H> {
#[must_use]
pub const fn new(
hooks: &'a H,
fail_safe: &'a RefCell<FailSafe>,
window: &'a RefCell<CommissioningWindow>,
) -> Self {
Self {
hooks,
fail_safe,
window,
administrator_fabric: Cell::new(None),
csr_issued_to: Cell::new(None),
icac_added: Cell::new(false),
}
}
pub fn conforming(
feature_map: u32,
optional: &Optional<'_>,
) -> crate::error::Result<Conforming<1, 6, 3, 0>> {
Conforming::new(&spec_jf::CLUSTER, feature_map, optional)
}
#[must_use]
pub fn administrator_fabric(&self) -> Option<FabricIndex> {
self.administrator_fabric.get()
}
pub fn set_administrator_fabric(&self, fabric: Option<FabricIndex>) {
self.administrator_fabric.set(fabric);
}
pub fn reset_fail_safe_state(&self) {
self.csr_issued_to.set(None);
self.icac_added.set(false);
}
fn fail_safe_armed(&self, ctx: &InteractionContext<'_>) -> bool {
self.fail_safe.borrow().is_armed(ctx.now)
}
}
impl<H: JointFabricHooks> ClusterHandler for JointFabricAdministrator<'_, H> {
fn read(
&self,
resolved: &Resolved<'_>,
_ctx: &InteractionContext<'_>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> core::result::Result<(), Status> {
let full = |r: crate::error::Result<()>| r.map_err(|_| Status::ResourceExhausted);
match resolved.attribute {
ADMINISTRATOR_FABRIC_INDEX => match self.administrator_fabric.get() {
Some(fabric) => full(w.unsigned(tag, u64::from(fabric.0))),
None => full(w.null(tag)),
},
_ => Err(Status::UnsupportedAttribute),
}
}
fn invoke(
&self,
resolved: &ResolvedCommand<'_>,
fields: Option<&[u8]>,
ctx: &InteractionContext<'_>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> core::result::Result<Option<CommandId>, StatusIb> {
let full = |r: crate::error::Result<()>| r.map_err(|_| StatusIb::from(Status::Failure));
match resolved.command.id {
ICACCSR_REQUEST => {
let status = self.icac_csr_request(ctx);
let mut buf = [0u8; ICACCSR_MAX];
let csr = match status {
ICACCSRResponseStatusCodeEnum::OK => {
let written = self.hooks.write_icac_csr(&mut buf)?;
let csr = buf
.get(..written)
.filter(|csr| csr.len() <= ICACCSR_MAX)
.ok_or(StatusIb::from(Status::Failure))?;
self.csr_issued_to.set(ctx.fabric_index);
Some(csr)
}
_ => None,
};
full(
spec_jf::ICACCSRResponseFields {
status_code: status,
icaccsr: csr,
}
.to_tlv(w, tag),
)?;
Ok(Some(ICACCSR_RESPONSE))
}
ADD_ICAC => {
let payload = fields.ok_or(StatusIb::from(Status::InvalidCommand))?;
let decoded: spec_jf::AddICACFields<'_> = super::decode_fields(payload)?;
let status = self.add_icac(&decoded, ctx)?;
full(
spec_jf::ICACResponseFields {
status_code: status,
}
.to_tlv(w, tag),
)?;
Ok(Some(ICAC_RESPONSE))
}
OPEN_JOINT_COMMISSIONING_WINDOW => {
let payload = fields.ok_or(StatusIb::from(Status::InvalidCommand))?;
let decoded: spec_jf::OpenJointCommissioningWindowFields<'_> =
super::decode_fields(payload)?;
self.open_joint_window(&decoded, ctx)?;
Ok(None)
}
TRANSFER_ANCHOR_REQUEST => {
let status = match self.hooks.anchor_transfer() {
AnchorTransfer::Accepted => TransferAnchorResponseStatusEnum::OK,
AnchorTransfer::Refused(why) => why,
};
full(
spec_jf::TransferAnchorResponseFields {
status_code: status,
}
.to_tlv(w, tag),
)?;
Ok(Some(TRANSFER_ANCHOR_RESPONSE))
}
TRANSFER_ANCHOR_COMPLETE => {
self.hooks.anchor_transferred();
self.administrator_fabric.set(None);
Ok(None)
}
ANNOUNCE_JOINT_FABRIC_ADMINISTRATOR => {
let payload = fields.ok_or(StatusIb::from(Status::InvalidCommand))?;
let decoded: spec_jf::AnnounceJointFabricAdministratorFields =
super::decode_fields(payload)?;
self.hooks.administrator_announced(decoded.endpoint_id);
Ok(None)
}
_ => Err(Status::UnsupportedCommand.into()),
}
}
}
impl<H: JointFabricHooks> JointFabricAdministrator<'_, H> {
fn icac_csr_request(&self, ctx: &InteractionContext<'_>) -> ICACCSRResponseStatusCodeEnum {
if !self.fail_safe_armed(ctx) {
return ICACCSRResponseStatusCodeEnum::Busy;
}
if !ctx.vendor_id_verified {
return ICACCSRResponseStatusCodeEnum::VIDNotVerified;
}
if self.administrator_fabric.get().is_none() {
return ICACCSRResponseStatusCodeEnum::InvalidAdministratorFabricIndex;
}
if self.icac_added.get() {
return ICACCSRResponseStatusCodeEnum::Busy;
}
ICACCSRResponseStatusCodeEnum::OK
}
fn add_icac(
&self,
request: &spec_jf::AddICACFields<'_>,
ctx: &InteractionContext<'_>,
) -> core::result::Result<ICACResponseStatusEnum, StatusIb> {
let Some(fabric) = ctx.fabric_index.filter(|f| f.0 != 0) else {
return Err(Status::InvalidCommand.into());
};
if !self.fail_safe_armed(ctx) {
return Err(Status::FailsafeRequired.into());
}
if self.icac_added.get() {
return Err(Status::ConstraintError.into());
}
if request.icac_value.len() > ICAC_MAX {
return Err(Status::ConstraintError.into());
}
if self.csr_issued_to.get() != Some(fabric) {
return Ok(ICACResponseStatusEnum::InvalidPublicKey);
}
let status = self.hooks.validate_icac(request.icac_value, fabric);
if status != ICACResponseStatusEnum::OK {
return Ok(status);
}
self.hooks.install_icac(request.icac_value, fabric)?;
self.icac_added.set(true);
self.administrator_fabric.set(Some(fabric));
Ok(ICACResponseStatusEnum::OK)
}
fn open_joint_window(
&self,
request: &spec_jf::OpenJointCommissioningWindowFields<'_>,
ctx: &InteractionContext<'_>,
) -> core::result::Result<(), StatusIb> {
if self.administrator_fabric.get().is_none() {
return Err(StatusIb::cluster_failure(
ICACCSRResponseStatusCodeEnum::InvalidAdministratorFabricIndex.value(),
));
}
let admin = crate::clusters::administrator_commissioning::AdministratorCommissioning::new(
self.window,
self.fail_safe,
&|_| None,
);
admin.open_commissioning_window(
&crate::clusters::administrator_commissioning::OpenWindowRequest {
timeout_seconds: request.commissioning_timeout,
verifier: request.pake_passcode_verifier,
discriminator: request.discriminator,
iterations: request.iterations,
salt: request.salt,
},
ctx,
)
}
}
impl<H: JointFabricHooks> Cluster for JointFabricAdministrator<'_, H> {
const ID: ClusterId = ID;
}