use core::cell::RefCell;
use heapless::{String, Vec};
use crate::clusters::generated::joint_fabric_datastore as spec_ds;
use crate::dm::spec::{Conforming, Optional};
use crate::dm::{Resolved, ResolvedCommand};
use crate::im::{
ClusterHandler, ClusterId, CommandId, EndpointId, InteractionContext, Status, StatusIb,
};
use crate::msg::{CaseAuthenticatedTag, GroupId, NodeId, VendorId};
use crate::tlv::{Tag, TlvWriter};
use super::Cluster;
pub use spec_ds::attribute::{
ADMIN_LIST, ANCHOR_NODE_ID, ANCHOR_ROOT_CA, ANCHOR_VENDOR_ID, ENDPOINT_BINDING_LIST,
ENDPOINT_GROUP_ID_LIST, FRIENDLY_NAME, GROUP_KEY_SET_LIST, GROUP_LIST, NODE_ACL_LIST,
NODE_ENDPOINT_LIST, NODE_KEY_SET_LIST, NODE_LIST, STATUS,
};
pub use spec_ds::command::{
ADD_ACL_TO_NODE, ADD_ADMIN, ADD_BINDING_TO_ENDPOINT_FOR_NODE, ADD_GROUP,
ADD_GROUP_ID_TO_ENDPOINT_FOR_NODE, ADD_KEY_SET, ADD_PENDING_NODE, REFRESH_NODE,
REMOVE_ACL_FROM_NODE, REMOVE_ADMIN, REMOVE_BINDING_FROM_ENDPOINT_FOR_NODE, REMOVE_GROUP,
REMOVE_GROUP_ID_FROM_ENDPOINT_FOR_NODE, REMOVE_KEY_SET, REMOVE_NODE, UPDATE_ADMIN,
UPDATE_ENDPOINT_FOR_NODE, UPDATE_GROUP, UPDATE_KEY_SET, UPDATE_NODE,
};
pub use spec_ds::{
DatastoreAccessControlEntryPrivilegeEnum, DatastoreStateEnum, ID, PICS, REVISION,
};
pub const FRIENDLY_NAME_MAX: usize = 32;
pub const IPK_KEY_SET: u16 = 0;
pub const GROUP_CAT_MIN: u16 = 1;
pub const GROUP_CAT_MAX: u16 = 65534;
pub type FriendlyName = String<FRIENDLY_NAME_MAX>;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct StatusEntry {
pub state: DatastoreStateEnum,
pub updated_at: u32,
pub failure: Option<Status>,
}
impl StatusEntry {
#[must_use]
pub const fn pending(now: u32) -> Self {
Self {
state: DatastoreStateEnum::Pending,
updated_at: now,
failure: None,
}
}
#[must_use]
pub const fn is_live(&self) -> bool {
!matches!(self.state, DatastoreStateEnum::DeletePending)
}
}
#[derive(Debug, Clone)]
pub struct NodeEntry {
pub node: NodeId,
pub friendly_name: FriendlyName,
pub commissioning: StatusEntry,
}
#[derive(Debug, Clone)]
pub struct GroupEntry {
pub group: GroupId,
pub friendly_name: FriendlyName,
pub key_set: Option<u16>,
pub cat: Option<u16>,
pub cat_version: Option<u16>,
pub permission: DatastoreAccessControlEntryPrivilegeEnum,
}
#[derive(Debug, Clone)]
pub struct AdminEntry {
pub node: NodeId,
pub friendly_name: FriendlyName,
pub vendor: VendorId,
pub icac_len: usize,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct NodeKeySet {
pub node: NodeId,
pub key_set: u16,
pub status: StatusEntry,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct EndpointGroup {
pub node: NodeId,
pub endpoint: EndpointId,
pub group: GroupId,
pub status: StatusEntry,
}
#[derive(Debug)]
pub struct Datastore<const N: usize, const G: usize, const K: usize, const A: usize, const M: usize>
{
nodes: Vec<NodeEntry, N>,
groups: Vec<GroupEntry, G>,
key_sets: Vec<u16, K>,
admins: Vec<AdminEntry, A>,
node_key_sets: Vec<NodeKeySet, M>,
endpoint_groups: Vec<EndpointGroup, M>,
anchor: Option<(NodeId, VendorId)>,
friendly_name: FriendlyName,
}
impl<const N: usize, const G: usize, const K: usize, const A: usize, const M: usize> Default
for Datastore<N, G, K, A, M>
{
fn default() -> Self {
Self::new()
}
}
impl<const N: usize, const G: usize, const K: usize, const A: usize, const M: usize>
Datastore<N, G, K, A, M>
{
#[must_use]
pub const fn new() -> Self {
Self {
nodes: Vec::new(),
groups: Vec::new(),
key_sets: Vec::new(),
admins: Vec::new(),
node_key_sets: Vec::new(),
endpoint_groups: Vec::new(),
anchor: None,
friendly_name: String::new(),
}
}
pub fn set_anchor(&mut self, node: NodeId, vendor: VendorId, name: &str) -> Result<(), Status> {
self.anchor = Some((node, vendor));
self.friendly_name = FriendlyName::try_from(name).map_err(|_| Status::ConstraintError)?;
Ok(())
}
#[must_use]
pub const fn anchor(&self) -> Option<(NodeId, VendorId)> {
self.anchor
}
#[must_use]
pub fn nodes(&self) -> &[NodeEntry] {
&self.nodes
}
#[must_use]
pub fn groups(&self) -> &[GroupEntry] {
&self.groups
}
#[must_use]
pub fn admins(&self) -> &[AdminEntry] {
&self.admins
}
#[must_use]
pub fn key_sets(&self) -> &[u16] {
&self.key_sets
}
#[must_use]
pub fn node_key_sets(&self) -> &[NodeKeySet] {
&self.node_key_sets
}
#[must_use]
pub fn endpoint_groups(&self) -> &[EndpointGroup] {
&self.endpoint_groups
}
pub fn add_key_set(&mut self, key_set: u16) -> Result<(), Status> {
if self.key_sets.contains(&key_set) {
return Err(Status::ConstraintError);
}
self.key_sets
.push(key_set)
.map_err(|_| Status::ResourceExhausted)
}
pub fn remove_key_set(&mut self, key_set: u16) -> Result<(), Status> {
if key_set == IPK_KEY_SET {
return Err(Status::ConstraintError);
}
if !self.key_sets.contains(&key_set) {
return Err(Status::NotFound);
}
if self
.node_key_sets
.iter()
.any(|entry| entry.key_set == key_set && entry.status.is_live())
{
return Err(Status::ConstraintError);
}
self.key_sets.retain(|id| *id != key_set);
Ok(())
}
pub fn add_group(&mut self, entry: GroupEntry) -> Result<(), Status> {
if let Some(cat) = entry.cat
&& (!(GROUP_CAT_MIN..=GROUP_CAT_MAX).contains(&cat) || is_reserved_cat(cat))
{
return Err(Status::ConstraintError);
}
if self.groups.iter().any(|g| g.group == entry.group) {
return Err(Status::ConstraintError);
}
if let Some(key_set) = entry.key_set
&& !self.key_sets.contains(&key_set)
{
return Err(Status::NotFound);
}
self.groups
.push(entry)
.map_err(|_| Status::ResourceExhausted)
}
pub fn remove_group(&mut self, group: GroupId) -> Result<(), Status> {
let Some(entry) = self.groups.iter().find(|g| g.group == group) else {
return Err(Status::NotFound);
};
if entry.cat.is_some_and(is_reserved_cat) {
return Err(Status::ConstraintError);
}
if self
.endpoint_groups
.iter()
.any(|m| m.group == group && m.status.is_live())
{
return Err(Status::ConstraintError);
}
self.groups.retain(|g| g.group != group);
Ok(())
}
pub fn add_pending_node(
&mut self,
node: NodeId,
friendly_name: &str,
now: u32,
) -> Result<(), Status> {
if self.nodes.iter().any(|n| n.node == node) {
return Err(Status::ConstraintError);
}
let friendly_name =
FriendlyName::try_from(friendly_name).map_err(|_| Status::ConstraintError)?;
self.nodes
.push(NodeEntry {
node,
friendly_name,
commissioning: StatusEntry::pending(now),
})
.map_err(|_| Status::ResourceExhausted)
}
pub fn refresh_node(&mut self, node: NodeId, now: u32) -> Result<(), Status> {
let Some(entry) = self.nodes.iter_mut().find(|n| n.node == node) else {
return Err(Status::NotFound);
};
entry.commissioning = StatusEntry::pending(now);
Ok(())
}
pub fn node_refreshed(&mut self, node: NodeId, outcome: Result<(), Status>, now: u32) {
if let Some(entry) = self.nodes.iter_mut().find(|n| n.node == node) {
entry.commissioning = match outcome {
Ok(()) => StatusEntry {
state: DatastoreStateEnum::Committed,
updated_at: now,
failure: None,
},
Err(status) => StatusEntry {
state: DatastoreStateEnum::CommitFailed,
updated_at: now,
failure: Some(status),
},
};
}
}
pub fn remove_node(&mut self, node: NodeId) -> Result<(), Status> {
if !self.nodes.iter().any(|n| n.node == node) {
return Err(Status::NotFound);
}
self.nodes.retain(|n| n.node != node);
self.node_key_sets.retain(|e| e.node != node);
self.endpoint_groups.retain(|e| e.node != node);
Ok(())
}
pub fn add_admin(&mut self, entry: AdminEntry) -> Result<(), Status> {
if self.admins.iter().any(|a| a.node == entry.node) {
return Err(Status::ConstraintError);
}
self.admins
.push(entry)
.map_err(|_| Status::ResourceExhausted)
}
pub fn remove_admin(&mut self, node: NodeId) -> Result<(), Status> {
if !self.admins.iter().any(|a| a.node == node) {
return Err(Status::NotFound);
}
self.admins.retain(|a| a.node != node);
Ok(())
}
pub fn add_node_key_set(&mut self, node: NodeId, key_set: u16, now: u32) -> Result<(), Status> {
if !self.nodes.iter().any(|n| n.node == node) {
return Err(Status::NotFound);
}
if !self.key_sets.contains(&key_set) {
return Err(Status::NotFound);
}
if self
.node_key_sets
.iter()
.any(|e| e.node == node && e.key_set == key_set)
{
return Err(Status::ConstraintError);
}
self.node_key_sets
.push(NodeKeySet {
node,
key_set,
status: StatusEntry::pending(now),
})
.map_err(|_| Status::ResourceExhausted)
}
pub fn add_group_to_endpoint(
&mut self,
node: NodeId,
endpoint: EndpointId,
group: GroupId,
now: u32,
) -> Result<(), Status> {
if !self.nodes.iter().any(|n| n.node == node) {
return Err(Status::NotFound);
}
if !self.groups.iter().any(|g| g.group == group) {
return Err(Status::NotFound);
}
if self
.endpoint_groups
.iter()
.any(|m| m.node == node && m.endpoint == endpoint && m.group == group)
{
return Err(Status::ConstraintError);
}
self.endpoint_groups
.push(EndpointGroup {
node,
endpoint,
group,
status: StatusEntry::pending(now),
})
.map_err(|_| Status::ResourceExhausted)
}
pub fn remove_group_from_endpoint(
&mut self,
node: NodeId,
endpoint: EndpointId,
group: GroupId,
now: u32,
) -> Result<(), Status> {
let Some(entry) = self
.endpoint_groups
.iter_mut()
.find(|m| m.node == node && m.endpoint == endpoint && m.group == group)
else {
return Err(Status::NotFound);
};
entry.status = StatusEntry {
state: DatastoreStateEnum::DeletePending,
updated_at: now,
failure: None,
};
Ok(())
}
pub fn deletion_applied(&mut self, node: NodeId, endpoint: EndpointId, group: GroupId) {
self.endpoint_groups.retain(|m| {
!(m.node == node && m.endpoint == endpoint && m.group == group && !m.status.is_live())
});
}
pub fn nodes_needing_review<const R: usize>(&self) -> Vec<NodeId, R> {
let mut out: Vec<NodeId, R> = Vec::new();
let note = |node: NodeId, out: &mut Vec<NodeId, R>| {
if !out.contains(&node) {
let _ = out.push(node);
}
};
for entry in &self.nodes {
if matches!(
entry.commissioning.state,
DatastoreStateEnum::Pending
| DatastoreStateEnum::DeletePending
| DatastoreStateEnum::CommitFailed
) {
note(entry.node, &mut out);
}
}
for entry in &self.node_key_sets {
if entry.status.state != DatastoreStateEnum::Committed {
note(entry.node, &mut out);
}
}
for entry in &self.endpoint_groups {
if entry.status.state != DatastoreStateEnum::Committed {
note(entry.node, &mut out);
}
}
out
}
}
#[derive(Debug)]
pub struct JointFabricDatastore<
'a,
const N: usize,
const G: usize,
const K: usize,
const A: usize,
const M: usize,
> {
store: &'a RefCell<Datastore<N, G, K, A, M>>,
}
impl<'a, const N: usize, const G: usize, const K: usize, const A: usize, const M: usize>
JointFabricDatastore<'a, N, G, K, A, M>
{
#[must_use]
pub const fn new(store: &'a RefCell<Datastore<N, G, K, A, M>>) -> Self {
Self { store }
}
pub fn conforming(
feature_map: u32,
optional: &Optional<'_>,
) -> crate::error::Result<Conforming<14, 20, 0, 0>> {
Conforming::new(&spec_ds::CLUSTER, feature_map, optional)
}
#[must_use]
pub const fn store(&self) -> &'a RefCell<Datastore<N, G, K, A, M>> {
self.store
}
}
impl<const N: usize, const G: usize, const K: usize, const A: usize, const M: usize> ClusterHandler
for JointFabricDatastore<'_, N, G, K, A, M>
{
fn read(
&self,
resolved: &Resolved<'_>,
_ctx: &InteractionContext<'_>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<(), Status> {
let full = |r: crate::error::Result<()>| r.map_err(|_| Status::ResourceExhausted);
let store = self.store.borrow();
match resolved.attribute {
ANCHOR_NODE_ID => match store.anchor() {
Some((node, _)) => full(w.unsigned(tag, node.0)),
None => full(w.null(tag)),
},
ANCHOR_VENDOR_ID => match store.anchor() {
Some((_, vendor)) => full(w.unsigned(tag, u64::from(vendor.0))),
None => full(w.null(tag)),
},
FRIENDLY_NAME => full(w.utf8(tag, &store.friendly_name)),
GROUP_KEY_SET_LIST => {
full(w.start_array(tag))?;
for key_set in store.key_sets() {
full(w.start_structure(Tag::Anonymous))?;
full(w.unsigned(Tag::Context(0), u64::from(*key_set)))?;
full(w.end_container())?;
}
full(w.end_container())
}
NODE_LIST => {
full(w.start_array(tag))?;
for entry in store.nodes() {
full(w.start_structure(Tag::Anonymous))?;
full(w.unsigned(Tag::Context(0), entry.node.0))?;
full(w.utf8(Tag::Context(1), &entry.friendly_name))?;
full(encode_status(&entry.commissioning, w, Tag::Context(2)))?;
full(w.end_container())?;
}
full(w.end_container())
}
GROUP_LIST => {
full(w.start_array(tag))?;
for entry in store.groups() {
full(w.start_structure(Tag::Anonymous))?;
full(w.unsigned(Tag::Context(0), u64::from(entry.group.0)))?;
full(w.utf8(Tag::Context(1), &entry.friendly_name))?;
match entry.key_set {
Some(key_set) => full(w.unsigned(Tag::Context(2), u64::from(key_set)))?,
None => full(w.null(Tag::Context(2)))?,
}
match entry.cat {
Some(cat) => full(w.unsigned(Tag::Context(3), u64::from(cat)))?,
None => full(w.null(Tag::Context(3)))?,
}
match entry.cat_version {
Some(v) => full(w.unsigned(Tag::Context(4), u64::from(v)))?,
None => full(w.null(Tag::Context(4)))?,
}
full(w.unsigned(Tag::Context(5), u64::from(entry.permission.value())))?;
full(w.end_container())?;
}
full(w.end_container())
}
ADMIN_LIST => {
full(w.start_array(tag))?;
for entry in store.admins() {
full(w.start_structure(Tag::Anonymous))?;
full(w.unsigned(Tag::Context(0), entry.node.0))?;
full(w.utf8(Tag::Context(1), &entry.friendly_name))?;
full(w.unsigned(Tag::Context(2), u64::from(entry.vendor.0)))?;
full(w.end_container())?;
}
full(w.end_container())
}
NODE_KEY_SET_LIST => {
full(w.start_array(tag))?;
for entry in store.node_key_sets() {
full(w.start_structure(Tag::Anonymous))?;
full(w.unsigned(Tag::Context(0), entry.node.0))?;
full(w.unsigned(Tag::Context(1), u64::from(entry.key_set)))?;
full(encode_status(&entry.status, w, Tag::Context(2)))?;
full(w.end_container())?;
}
full(w.end_container())
}
ENDPOINT_GROUP_ID_LIST => {
full(w.start_array(tag))?;
for entry in store.endpoint_groups() {
full(w.start_structure(Tag::Anonymous))?;
full(w.unsigned(Tag::Context(0), entry.node.0))?;
full(w.unsigned(Tag::Context(1), u64::from(entry.endpoint)))?;
full(w.unsigned(Tag::Context(2), u64::from(entry.group.0)))?;
full(encode_status(&entry.status, w, Tag::Context(3)))?;
full(w.end_container())?;
}
full(w.end_container())
}
_ => Err(Status::UnsupportedAttribute),
}
}
fn invoke(
&self,
resolved: &ResolvedCommand<'_>,
fields: Option<&[u8]>,
ctx: &InteractionContext<'_>,
_w: &mut TlvWriter<'_>,
_tag: Tag,
) -> Result<Option<CommandId>, StatusIb> {
if ctx.fabric_index.filter(|f| f.0 != 0).is_none() {
return Err(Status::UnsupportedAccess.into());
}
let payload = fields.ok_or(StatusIb::from(Status::InvalidCommand))?;
let now = u32::try_from(ctx.now.as_micros() / 1_000_000).unwrap_or(u32::MAX);
let mut store = self.store.borrow_mut();
match resolved.command.id {
ADD_KEY_SET => {
let decoded: spec_ds::AddKeySetFields<'_> = super::decode_fields(payload)?;
store.add_key_set(decoded.group_key_set.group_key_set_id)?;
}
REMOVE_KEY_SET => {
let decoded: spec_ds::RemoveKeySetFields = super::decode_fields(payload)?;
store.remove_key_set(decoded.group_key_set_id)?;
}
ADD_GROUP => {
let decoded: spec_ds::AddGroupFields<'_> = super::decode_fields(payload)?;
store.add_group(GroupEntry {
group: decoded.group_id,
friendly_name: FriendlyName::try_from(decoded.friendly_name)
.map_err(|_| StatusIb::from(Status::ConstraintError))?,
key_set: decoded.group_key_set_id.0,
cat: decoded.group_cat.0,
cat_version: decoded.group_cat_version.0,
permission: decoded.group_permission,
})?;
}
REMOVE_GROUP => {
let decoded: spec_ds::RemoveGroupFields = super::decode_fields(payload)?;
store.remove_group(decoded.group_id)?;
}
ADD_ADMIN => {
let decoded: spec_ds::AddAdminFields<'_> = super::decode_fields(payload)?;
store.add_admin(AdminEntry {
node: decoded.node_id,
friendly_name: FriendlyName::try_from(decoded.friendly_name)
.map_err(|_| StatusIb::from(Status::ConstraintError))?,
vendor: decoded.vendor_id,
icac_len: decoded.icac.len(),
})?;
}
REMOVE_ADMIN => {
let decoded: spec_ds::RemoveAdminFields = super::decode_fields(payload)?;
store.remove_admin(decoded.node_id)?;
}
ADD_PENDING_NODE => {
let decoded: spec_ds::AddPendingNodeFields<'_> = super::decode_fields(payload)?;
store.add_pending_node(decoded.node_id, decoded.friendly_name, now)?;
}
REFRESH_NODE => {
let decoded: spec_ds::RefreshNodeFields = super::decode_fields(payload)?;
store.refresh_node(decoded.node_id, now)?;
}
REMOVE_NODE => {
let decoded: spec_ds::RemoveNodeFields = super::decode_fields(payload)?;
store.remove_node(decoded.node_id)?;
}
ADD_GROUP_ID_TO_ENDPOINT_FOR_NODE => {
let decoded: spec_ds::AddGroupIDToEndpointForNodeFields =
super::decode_fields(payload)?;
store.add_group_to_endpoint(
decoded.node_id,
decoded.endpoint_id,
decoded.group_id,
now,
)?;
}
REMOVE_GROUP_ID_FROM_ENDPOINT_FOR_NODE => {
let decoded: spec_ds::RemoveGroupIDFromEndpointForNodeFields =
super::decode_fields(payload)?;
store.remove_group_from_endpoint(
decoded.node_id,
decoded.endpoint_id,
decoded.group_id,
now,
)?;
}
_ => return Err(Status::UnsupportedCommand.into()),
}
Ok(None)
}
}
const fn is_reserved_cat(cat: u16) -> bool {
cat == CaseAuthenticatedTag::ADMINISTRATOR_IDENTIFIER
|| cat == CaseAuthenticatedTag::ANCHOR_IDENTIFIER
}
fn encode_status(
status: &StatusEntry,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> crate::error::Result<()> {
w.start_structure(tag)?;
w.unsigned(Tag::Context(0), u64::from(status.state.value()))?;
w.unsigned(Tag::Context(1), u64::from(status.updated_at))?;
match status.failure {
Some(failure) => w.unsigned(Tag::Context(2), u64::from(failure.value()))?,
None => w.unsigned(Tag::Context(2), 0)?,
}
w.end_container()
}
impl<const N: usize, const G: usize, const K: usize, const A: usize, const M: usize> Cluster
for JointFabricDatastore<'_, N, G, K, A, M>
{
const ID: ClusterId = ID;
}