#![allow(unused_imports)]
use crate::dm::conformance::{Clause, Condition, Conform, Conformance};
use crate::dm::meta::{EventPriority, Reporting};
use crate::dm::spec::{Attribute, Cluster, Command, Event, Feature};
use crate::dm::{Access, AccessQualities, AttributeQualities, Privilege};
use crate::error::Result;
use crate::im::{AttributeId, ClusterId, CommandId, EventId};
use crate::tlv::{
ContainerKind, Element, FromTlv, Nullable, Tag, TlvList, TlvReader, TlvWriter, ToTlv, Value,
};
pub const ID: ClusterId = 0x003E;
pub const REVISION: u16 = 2;
pub const PICS: &str = "OPCREDS";
pub const FEATURES: &[Feature] = &[];
pub mod attribute {
use crate::im::AttributeId;
pub const NO_CS: AttributeId = 0x00;
pub const FABRICS: AttributeId = 0x01;
pub const SUPPORTED_FABRICS: AttributeId = 0x02;
pub const COMMISSIONED_FABRICS: AttributeId = 0x03;
pub const TRUSTED_ROOT_CERTIFICATES: AttributeId = 0x04;
pub const CURRENT_FABRIC_INDEX: AttributeId = 0x05;
}
pub mod command {
use crate::im::CommandId;
pub const ATTESTATION_REQUEST: CommandId = 0x00;
pub const ATTESTATION_RESPONSE: CommandId = 0x01;
pub const CERTIFICATE_CHAIN_REQUEST: CommandId = 0x02;
pub const CERTIFICATE_CHAIN_RESPONSE: CommandId = 0x03;
pub const CSR_REQUEST: CommandId = 0x04;
pub const CSR_RESPONSE: CommandId = 0x05;
pub const ADD_NOC: CommandId = 0x06;
pub const UPDATE_NOC: CommandId = 0x07;
pub const NOC_RESPONSE: CommandId = 0x08;
pub const UPDATE_FABRIC_LABEL: CommandId = 0x09;
pub const REMOVE_FABRIC: CommandId = 0x0A;
pub const ADD_TRUSTED_ROOT_CERTIFICATE: CommandId = 0x0B;
pub const SET_VID_VERIFICATION_STATEMENT: CommandId = 0x0C;
pub const SIGN_VID_VERIFICATION_REQUEST: CommandId = 0x0D;
pub const SIGN_VID_VERIFICATION_RESPONSE: CommandId = 0x0E;
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum CertificateChainTypeEnum {
DACCertificate = 1,
PAICertificate = 2,
}
impl CertificateChainTypeEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
1 => Some(Self::DACCertificate),
2 => Some(Self::PAICertificate),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for CertificateChainTypeEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for CertificateChainTypeEnum {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
let value = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
Self::from_value(value).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum NodeOperationalCertStatusEnum {
OK = 0,
InvalidPublicKey = 1,
InvalidNodeOpId = 2,
InvalidNOC = 3,
MissingCsr = 4,
TableFull = 5,
InvalidAdminSubject = 6,
FabricConflict = 9,
LabelConflict = 10,
InvalidFabricIndex = 11,
}
impl NodeOperationalCertStatusEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::OK),
1 => Some(Self::InvalidPublicKey),
2 => Some(Self::InvalidNodeOpId),
3 => Some(Self::InvalidNOC),
4 => Some(Self::MissingCsr),
5 => Some(Self::TableFull),
6 => Some(Self::InvalidAdminSubject),
9 => Some(Self::FabricConflict),
10 => Some(Self::LabelConflict),
11 => Some(Self::InvalidFabricIndex),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for NodeOperationalCertStatusEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for NodeOperationalCertStatusEnum {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
let value = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
Self::from_value(value).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct FabricDescriptorStruct<'a> {
pub root_public_key: &'a [u8],
pub vendor_id: crate::msg::VendorId,
pub fabric_id: u64,
pub node_id: crate::msg::NodeId,
pub label: &'a str,
pub vid_verification_statement: Option<&'a [u8]>,
pub fabric_index: crate::msg::FabricIndex,
}
impl<'a> ToTlv for FabricDescriptorStruct<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.root_public_key.to_tlv(w, Tag::Context(1))?;
self.vendor_id.to_tlv(w, Tag::Context(2))?;
self.fabric_id.to_tlv(w, Tag::Context(3))?;
self.node_id.to_tlv(w, Tag::Context(4))?;
self.label.to_tlv(w, Tag::Context(5))?;
if let Some(value) = &self.vid_verification_statement {
value.to_tlv(w, Tag::Context(6))?;
}
self.fabric_index.to_tlv(w, Tag::Context(254))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for FabricDescriptorStruct<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut root_public_key = None;
let mut vendor_id = None;
let mut fabric_id = None;
let mut node_id = None;
let mut label = None;
let mut vid_verification_statement = None;
let mut fabric_index = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(1) => root_public_key = Some(<&'a [u8]>::from_tlv(reader, &field)?),
Some(2) => vendor_id = Some(<crate::msg::VendorId>::from_tlv(reader, &field)?),
Some(3) => fabric_id = Some(<u64>::from_tlv(reader, &field)?),
Some(4) => node_id = Some(<crate::msg::NodeId>::from_tlv(reader, &field)?),
Some(5) => label = Some(<&'a str>::from_tlv(reader, &field)?),
Some(6) => vid_verification_statement = Some(<&'a [u8]>::from_tlv(reader, &field)?),
Some(254) => {
fabric_index = Some(<crate::msg::FabricIndex>::from_tlv(reader, &field)?)
}
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
root_public_key: root_public_key
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
vendor_id: vendor_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
fabric_id: fabric_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
node_id: node_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
label: label.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
vid_verification_statement,
fabric_index: fabric_index.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct NOCStruct<'a> {
pub noc: &'a [u8],
pub icac: Nullable<&'a [u8]>,
pub vvsc: Option<&'a [u8]>,
pub fabric_index: crate::msg::FabricIndex,
}
impl<'a> ToTlv for NOCStruct<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.noc.to_tlv(w, Tag::Context(1))?;
self.icac.to_tlv(w, Tag::Context(2))?;
if let Some(value) = &self.vvsc {
value.to_tlv(w, Tag::Context(3))?;
}
self.fabric_index.to_tlv(w, Tag::Context(254))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for NOCStruct<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut noc = None;
let mut icac = None;
let mut vvsc = None;
let mut fabric_index = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(1) => noc = Some(<&'a [u8]>::from_tlv(reader, &field)?),
Some(2) => icac = Some(<Nullable<&'a [u8]>>::from_tlv(reader, &field)?),
Some(3) => vvsc = Some(<&'a [u8]>::from_tlv(reader, &field)?),
Some(254) => {
fabric_index = Some(<crate::msg::FabricIndex>::from_tlv(reader, &field)?)
}
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
noc: noc.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
icac: icac.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
vvsc,
fabric_index: fabric_index.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct AttestationRequestFields<'a> {
pub attestation_nonce: &'a [u8],
}
impl<'a> ToTlv for AttestationRequestFields<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.attestation_nonce.to_tlv(w, Tag::Context(0))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for AttestationRequestFields<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut attestation_nonce = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => attestation_nonce = Some(<&'a [u8]>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
attestation_nonce: attestation_nonce
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct AttestationResponseFields<'a> {
pub attestation_elements: &'a [u8],
pub attestation_signature: &'a [u8],
}
impl<'a> ToTlv for AttestationResponseFields<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.attestation_elements.to_tlv(w, Tag::Context(0))?;
self.attestation_signature.to_tlv(w, Tag::Context(1))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for AttestationResponseFields<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut attestation_elements = None;
let mut attestation_signature = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => attestation_elements = Some(<&'a [u8]>::from_tlv(reader, &field)?),
Some(1) => attestation_signature = Some(<&'a [u8]>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
attestation_elements: attestation_elements
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
attestation_signature: attestation_signature
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct CertificateChainRequestFields {
pub certificate_type: CertificateChainTypeEnum,
}
impl ToTlv for CertificateChainRequestFields {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.certificate_type.to_tlv(w, Tag::Context(0))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for CertificateChainRequestFields {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut certificate_type = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => {
certificate_type = Some(<CertificateChainTypeEnum>::from_tlv(reader, &field)?)
}
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
certificate_type: certificate_type
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct CertificateChainResponseFields<'a> {
pub certificate: &'a [u8],
}
impl<'a> ToTlv for CertificateChainResponseFields<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.certificate.to_tlv(w, Tag::Context(0))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for CertificateChainResponseFields<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut certificate = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => certificate = Some(<&'a [u8]>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
certificate: certificate.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct CSRRequestFields<'a> {
pub csr_nonce: &'a [u8],
pub is_for_update_noc: Option<bool>,
}
impl<'a> ToTlv for CSRRequestFields<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.csr_nonce.to_tlv(w, Tag::Context(0))?;
if let Some(value) = &self.is_for_update_noc {
value.to_tlv(w, Tag::Context(1))?;
}
w.end_container()
}
}
impl<'a> FromTlv<'a> for CSRRequestFields<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut csr_nonce = None;
let mut is_for_update_noc = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => csr_nonce = Some(<&'a [u8]>::from_tlv(reader, &field)?),
Some(1) => is_for_update_noc = Some(<bool>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
csr_nonce: csr_nonce.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
is_for_update_noc,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct CSRResponseFields<'a> {
pub nocsr_elements: &'a [u8],
pub attestation_signature: &'a [u8],
}
impl<'a> ToTlv for CSRResponseFields<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.nocsr_elements.to_tlv(w, Tag::Context(0))?;
self.attestation_signature.to_tlv(w, Tag::Context(1))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for CSRResponseFields<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut nocsr_elements = None;
let mut attestation_signature = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => nocsr_elements = Some(<&'a [u8]>::from_tlv(reader, &field)?),
Some(1) => attestation_signature = Some(<&'a [u8]>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
nocsr_elements: nocsr_elements
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
attestation_signature: attestation_signature
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct AddNOCFields<'a> {
pub noc_value: &'a [u8],
pub icac_value: Option<&'a [u8]>,
pub ipk_value: &'a [u8],
pub case_admin_subject: u64,
pub admin_vendor_id: crate::msg::VendorId,
}
impl<'a> ToTlv for AddNOCFields<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.noc_value.to_tlv(w, Tag::Context(0))?;
if let Some(value) = &self.icac_value {
value.to_tlv(w, Tag::Context(1))?;
}
self.ipk_value.to_tlv(w, Tag::Context(2))?;
self.case_admin_subject.to_tlv(w, Tag::Context(3))?;
self.admin_vendor_id.to_tlv(w, Tag::Context(4))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for AddNOCFields<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut noc_value = None;
let mut icac_value = None;
let mut ipk_value = None;
let mut case_admin_subject = None;
let mut admin_vendor_id = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => noc_value = Some(<&'a [u8]>::from_tlv(reader, &field)?),
Some(1) => icac_value = Some(<&'a [u8]>::from_tlv(reader, &field)?),
Some(2) => ipk_value = Some(<&'a [u8]>::from_tlv(reader, &field)?),
Some(3) => case_admin_subject = Some(<u64>::from_tlv(reader, &field)?),
Some(4) => {
admin_vendor_id = Some(<crate::msg::VendorId>::from_tlv(reader, &field)?)
}
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
noc_value: noc_value.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
icac_value,
ipk_value: ipk_value.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
case_admin_subject: case_admin_subject
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
admin_vendor_id: admin_vendor_id
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct UpdateNOCFields<'a> {
pub noc_value: &'a [u8],
pub icac_value: Option<&'a [u8]>,
}
impl<'a> ToTlv for UpdateNOCFields<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.noc_value.to_tlv(w, Tag::Context(0))?;
if let Some(value) = &self.icac_value {
value.to_tlv(w, Tag::Context(1))?;
}
w.end_container()
}
}
impl<'a> FromTlv<'a> for UpdateNOCFields<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut noc_value = None;
let mut icac_value = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => noc_value = Some(<&'a [u8]>::from_tlv(reader, &field)?),
Some(1) => icac_value = Some(<&'a [u8]>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
noc_value: noc_value.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
icac_value,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct NOCResponseFields<'a> {
pub status_code: NodeOperationalCertStatusEnum,
pub fabric_index: Option<crate::msg::FabricIndex>,
pub debug_text: Option<&'a str>,
}
impl<'a> ToTlv for NOCResponseFields<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.status_code.to_tlv(w, Tag::Context(0))?;
if let Some(value) = &self.fabric_index {
value.to_tlv(w, Tag::Context(1))?;
}
if let Some(value) = &self.debug_text {
value.to_tlv(w, Tag::Context(2))?;
}
w.end_container()
}
}
impl<'a> FromTlv<'a> for NOCResponseFields<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut status_code = None;
let mut fabric_index = None;
let mut debug_text = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => {
status_code = Some(<NodeOperationalCertStatusEnum>::from_tlv(reader, &field)?)
}
Some(1) => {
fabric_index = Some(<crate::msg::FabricIndex>::from_tlv(reader, &field)?)
}
Some(2) => debug_text = Some(<&'a str>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
status_code: status_code.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
fabric_index,
debug_text,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct UpdateFabricLabelFields<'a> {
pub label: &'a str,
}
impl<'a> ToTlv for UpdateFabricLabelFields<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.label.to_tlv(w, Tag::Context(0))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for UpdateFabricLabelFields<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut label = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => label = Some(<&'a str>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
label: label.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct RemoveFabricFields {
pub fabric_index: crate::msg::FabricIndex,
}
impl ToTlv for RemoveFabricFields {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.fabric_index.to_tlv(w, Tag::Context(0))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for RemoveFabricFields {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut fabric_index = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => {
fabric_index = Some(<crate::msg::FabricIndex>::from_tlv(reader, &field)?)
}
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
fabric_index: fabric_index.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct AddTrustedRootCertificateFields<'a> {
pub root_ca_certificate: &'a [u8],
}
impl<'a> ToTlv for AddTrustedRootCertificateFields<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.root_ca_certificate.to_tlv(w, Tag::Context(0))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for AddTrustedRootCertificateFields<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut root_ca_certificate = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => root_ca_certificate = Some(<&'a [u8]>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
root_ca_certificate: root_ca_certificate
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct SetVIDVerificationStatementFields<'a> {
pub vendor_id: Option<crate::msg::VendorId>,
pub vid_verification_statement: Option<&'a [u8]>,
pub vvsc: Option<&'a [u8]>,
}
impl<'a> ToTlv for SetVIDVerificationStatementFields<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
if let Some(value) = &self.vendor_id {
value.to_tlv(w, Tag::Context(0))?;
}
if let Some(value) = &self.vid_verification_statement {
value.to_tlv(w, Tag::Context(1))?;
}
if let Some(value) = &self.vvsc {
value.to_tlv(w, Tag::Context(2))?;
}
w.end_container()
}
}
impl<'a> FromTlv<'a> for SetVIDVerificationStatementFields<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut vendor_id = None;
let mut vid_verification_statement = None;
let mut vvsc = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => vendor_id = Some(<crate::msg::VendorId>::from_tlv(reader, &field)?),
Some(1) => vid_verification_statement = Some(<&'a [u8]>::from_tlv(reader, &field)?),
Some(2) => vvsc = Some(<&'a [u8]>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
vendor_id,
vid_verification_statement,
vvsc,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct SignVIDVerificationRequestFields<'a> {
pub fabric_index: crate::msg::FabricIndex,
pub client_challenge: &'a [u8],
}
impl<'a> ToTlv for SignVIDVerificationRequestFields<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.fabric_index.to_tlv(w, Tag::Context(0))?;
self.client_challenge.to_tlv(w, Tag::Context(1))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for SignVIDVerificationRequestFields<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut fabric_index = None;
let mut client_challenge = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => {
fabric_index = Some(<crate::msg::FabricIndex>::from_tlv(reader, &field)?)
}
Some(1) => client_challenge = Some(<&'a [u8]>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
fabric_index: fabric_index.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
client_challenge: client_challenge
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct SignVIDVerificationResponseFields<'a> {
pub fabric_index: crate::msg::FabricIndex,
pub fabric_binding_version: u8,
pub signature: &'a [u8],
}
impl<'a> ToTlv for SignVIDVerificationResponseFields<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.fabric_index.to_tlv(w, Tag::Context(0))?;
self.fabric_binding_version.to_tlv(w, Tag::Context(1))?;
self.signature.to_tlv(w, Tag::Context(2))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for SignVIDVerificationResponseFields<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut fabric_index = None;
let mut fabric_binding_version = None;
let mut signature = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => {
fabric_index = Some(<crate::msg::FabricIndex>::from_tlv(reader, &field)?)
}
Some(1) => fabric_binding_version = Some(<u8>::from_tlv(reader, &field)?),
Some(2) => signature = Some(<&'a [u8]>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
fabric_index: fabric_index.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
fabric_binding_version: fabric_binding_version
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
signature: signature.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
pub const ATTRIBUTES: &[Attribute] = &[
Attribute {
id: 0x0000,
name: "NOCs",
kind: "list[NOCStruct]",
access: Access::read_only(Privilege::Administer)
.with_qualities(AccessQualities::FABRIC_SCOPED),
qualities: AttributeQualities::NON_VOLATILE,
reporting: Reporting::ChangesOmitted,
conform: Conform::MANDATORY,
},
Attribute {
id: 0x0001,
name: "Fabrics",
kind: "list[FabricDescriptorStruct]",
access: Access::read_only(Privilege::View).with_qualities(AccessQualities::FABRIC_SCOPED),
qualities: AttributeQualities::NON_VOLATILE,
reporting: Reporting::OnChange,
conform: Conform::MANDATORY,
},
Attribute {
id: 0x0002,
name: "SupportedFabrics",
kind: "uint8",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::FIXED,
reporting: Reporting::OnChange,
conform: Conform::MANDATORY,
},
Attribute {
id: 0x0003,
name: "CommissionedFabrics",
kind: "uint8",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::NON_VOLATILE,
reporting: Reporting::OnChange,
conform: Conform::MANDATORY,
},
Attribute {
id: 0x0004,
name: "TrustedRootCertificates",
kind: "list[octstr]",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::NON_VOLATILE,
reporting: Reporting::ChangesOmitted,
conform: Conform::MANDATORY,
},
Attribute {
id: 0x0005,
name: "CurrentFabricIndex",
kind: "uint8",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::empty(),
reporting: Reporting::OnChange,
conform: Conform::MANDATORY,
},
];
pub const COMMANDS: &[Command] = &[
Command {
id: 0x00,
name: "AttestationRequest",
to_server: true,
response: Some(0x01),
access: Access::invoke(Privilege::Administer),
conform: Conform::MANDATORY,
},
Command {
id: 0x01,
name: "AttestationResponse",
to_server: false,
response: None,
access: Access::invoke(Privilege::Operate),
conform: Conform::MANDATORY,
},
Command {
id: 0x02,
name: "CertificateChainRequest",
to_server: true,
response: Some(0x03),
access: Access::invoke(Privilege::Administer),
conform: Conform::MANDATORY,
},
Command {
id: 0x03,
name: "CertificateChainResponse",
to_server: false,
response: None,
access: Access::invoke(Privilege::Operate),
conform: Conform::MANDATORY,
},
Command {
id: 0x04,
name: "CSRRequest",
to_server: true,
response: Some(0x05),
access: Access::invoke(Privilege::Administer),
conform: Conform::MANDATORY,
},
Command {
id: 0x05,
name: "CSRResponse",
to_server: false,
response: None,
access: Access::invoke(Privilege::Operate),
conform: Conform::MANDATORY,
},
Command {
id: 0x06,
name: "AddNOC",
to_server: true,
response: Some(0x08),
access: Access::invoke(Privilege::Administer),
conform: Conform::MANDATORY,
},
Command {
id: 0x07,
name: "UpdateNOC",
to_server: true,
response: Some(0x08),
access: Access::invoke(Privilege::Administer)
.with_qualities(AccessQualities::FABRIC_SCOPED),
conform: Conform::MANDATORY,
},
Command {
id: 0x08,
name: "NOCResponse",
to_server: false,
response: None,
access: Access::invoke(Privilege::Operate),
conform: Conform::MANDATORY,
},
Command {
id: 0x09,
name: "UpdateFabricLabel",
to_server: true,
response: Some(0x08),
access: Access::invoke(Privilege::Administer)
.with_qualities(AccessQualities::FABRIC_SCOPED),
conform: Conform::MANDATORY,
},
Command {
id: 0x0A,
name: "RemoveFabric",
to_server: true,
response: Some(0x08),
access: Access::invoke(Privilege::Administer),
conform: Conform::MANDATORY,
},
Command {
id: 0x0B,
name: "AddTrustedRootCertificate",
to_server: true,
response: None,
access: Access::invoke(Privilege::Administer),
conform: Conform::MANDATORY,
},
Command {
id: 0x0C,
name: "SetVIDVerificationStatement",
to_server: true,
response: None,
access: Access::invoke(Privilege::Administer)
.with_qualities(AccessQualities::FABRIC_SCOPED),
conform: Conform::MANDATORY,
},
Command {
id: 0x0D,
name: "SignVIDVerificationRequest",
to_server: true,
response: Some(0x0E),
access: Access::invoke(Privilege::Administer),
conform: Conform::MANDATORY,
},
Command {
id: 0x0E,
name: "SignVIDVerificationResponse",
to_server: false,
response: None,
access: Access::invoke(Privilege::Operate),
conform: Conform::MANDATORY,
},
];
pub const EVENTS: &[Event] = &[];
pub const CLUSTER: Cluster = Cluster {
id: ID,
name: "Operational Credentials",
revision: REVISION,
pics: "OPCREDS",
derived_from: None,
features: FEATURES,
attributes: ATTRIBUTES,
commands: COMMANDS,
events: EVENTS,
};