use core::cell::RefCell;
use crate::crypto::{SYMMETRIC_KEY_LENGTH_BYTES, SymmetricKey, ct_eq};
use crate::dm::spec::{Conforming, Optional};
use crate::dm::{Resolved, ResolvedCommand};
use crate::im::{
AttributeId, ClusterHandler, ClusterId, CommandId, EventId, InteractionContext, Status,
StatusIb,
};
use crate::tlv::{ContainerKind, Tag, TlvReader, TlvWriter, Value};
use super::Cluster;
pub const ID: ClusterId = 0x0033;
pub const REVISION: u16 = 3;
pub const FEATURE_DATA_MODEL_TEST: u32 = 1 << 0;
pub const NETWORK_INTERFACES: AttributeId = 0x0000;
pub const REBOOT_COUNT: AttributeId = 0x0001;
pub const UP_TIME: AttributeId = 0x0002;
pub const TOTAL_OPERATIONAL_HOURS: AttributeId = 0x0003;
pub const BOOT_REASON: AttributeId = 0x0004;
pub const ACTIVE_HARDWARE_FAULTS: AttributeId = 0x0005;
pub const ACTIVE_RADIO_FAULTS: AttributeId = 0x0006;
pub const ACTIVE_NETWORK_FAULTS: AttributeId = 0x0007;
pub const TEST_EVENT_TRIGGERS_ENABLED: AttributeId = 0x0008;
pub const DEVICE_LOAD_STATUS: AttributeId = 0x000A;
pub const TEST_EVENT_TRIGGER: CommandId = 0x00;
pub const TIME_SNAPSHOT: CommandId = 0x01;
pub const TIME_SNAPSHOT_RESPONSE: CommandId = 0x02;
pub const PAYLOAD_TEST_REQUEST: CommandId = 0x03;
pub const PAYLOAD_TEST_RESPONSE: CommandId = 0x04;
pub const HARDWARE_FAULT_CHANGE: EventId = 0x00;
pub const RADIO_FAULT_CHANGE: EventId = 0x01;
pub const NETWORK_FAULT_CHANGE: EventId = 0x02;
pub const BOOT_REASON_EVENT: EventId = 0x03;
pub const PAYLOAD_TEST_MAX: u16 = 2048;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(u8)]
pub enum HardwareFault {
Unspecified = 0,
Radio = 1,
Sensor = 2,
ResettableOverTemp = 3,
NonResettableOverTemp = 4,
PowerSource = 5,
VisualDisplayFault = 6,
AudioOutputFault = 7,
UserInterfaceFault = 8,
NonVolatileMemoryError = 9,
TamperDetected = 10,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(u8)]
pub enum RadioFault {
Unspecified = 0,
WiFiFault = 1,
CellularFault = 2,
ThreadFault = 3,
NfcFault = 4,
BleFault = 5,
EthernetFault = 6,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(u8)]
pub enum NetworkFault {
Unspecified = 0,
HardwareFailure = 1,
NetworkJammed = 2,
ConnectionFailed = 3,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
#[repr(u8)]
pub enum InterfaceType {
#[default]
Unspecified = 0,
WiFi = 1,
Ethernet = 2,
Cellular = 3,
Thread = 4,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
#[repr(u8)]
pub enum BootReason {
#[default]
Unspecified = 0,
PowerOnReboot = 1,
BrownOutReset = 2,
SoftwareWatchdogReset = 3,
HardwareWatchdogReset = 4,
SoftwareUpdateCompleted = 5,
SoftwareReset = 6,
}
#[derive(Debug, Clone, Copy)]
pub struct NetworkInterface<'a> {
pub name: &'a str,
pub is_operational: bool,
pub off_premise_ipv4: Option<bool>,
pub off_premise_ipv6: Option<bool>,
pub hardware_address: &'a [u8],
pub ipv4_addresses: &'a [[u8; 4]],
pub ipv6_addresses: &'a [[u8; 16]],
pub interface_type: InterfaceType,
}
impl NetworkInterface<'_> {
fn encode(&self, w: &mut TlvWriter<'_>) -> crate::error::Result<()> {
w.start_structure(Tag::Anonymous)?;
w.utf8(Tag::Context(0), self.name)?;
w.bool(Tag::Context(1), self.is_operational)?;
match self.off_premise_ipv4 {
Some(value) => w.bool(Tag::Context(2), value)?,
None => w.null(Tag::Context(2))?,
}
match self.off_premise_ipv6 {
Some(value) => w.bool(Tag::Context(3), value)?,
None => w.null(Tag::Context(3))?,
}
w.octets(Tag::Context(4), self.hardware_address)?;
w.start_array(Tag::Context(5))?;
for address in self.ipv4_addresses.iter().take(4) {
w.octets(Tag::Anonymous, address)?;
}
w.end_container()?;
w.start_array(Tag::Context(6))?;
for address in self.ipv6_addresses.iter().take(8) {
w.octets(Tag::Anonymous, address)?;
}
w.end_container()?;
w.unsigned(Tag::Context(7), self.interface_type as u64)?;
w.end_container()
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct DeviceLoad {
pub current_subscriptions: u16,
pub current_subscriptions_for_fabric: u16,
pub total_subscriptions_established: u32,
pub total_im_messages_sent: u32,
pub total_im_messages_received: u32,
}
impl DeviceLoad {
fn encode(&self, w: &mut TlvWriter<'_>, tag: Tag) -> crate::error::Result<()> {
w.start_structure(tag)?;
w.unsigned(Tag::Context(0), u64::from(self.current_subscriptions))?;
w.unsigned(
Tag::Context(1),
u64::from(self.current_subscriptions_for_fabric),
)?;
w.unsigned(
Tag::Context(2),
u64::from(self.total_subscriptions_established),
)?;
w.unsigned(Tag::Context(3), u64::from(self.total_im_messages_sent))?;
w.unsigned(Tag::Context(4), u64::from(self.total_im_messages_received))?;
w.end_container()
}
}
pub trait Diagnostics {
fn network_interfaces(&self, emit: &mut dyn FnMut(&NetworkInterface<'_>)) {
let _ = emit;
}
fn reboot_count(&self) -> u16 {
0
}
fn up_time(&self) -> u64 {
0
}
fn total_operational_hours(&self) -> Option<u32> {
None
}
fn boot_reason(&self) -> BootReason {
BootReason::Unspecified
}
fn active_hardware_faults(&self, emit: &mut dyn FnMut(HardwareFault)) {
let _ = emit;
}
fn active_radio_faults(&self, emit: &mut dyn FnMut(RadioFault)) {
let _ = emit;
}
fn active_network_faults(&self, emit: &mut dyn FnMut(NetworkFault)) {
let _ = emit;
}
fn device_load(&self, _ctx: &InteractionContext<'_>) -> Option<DeviceLoad> {
None
}
fn enable_key(&self) -> Option<&SymmetricKey> {
None
}
fn test_event_trigger(&self, trigger: u64) -> bool {
let _ = trigger;
false
}
fn posix_time_ms(&self) -> Option<u64> {
None
}
}
#[derive(Debug, Clone, Copy, Default)]
pub struct Unknown;
impl Diagnostics for Unknown {}
pub fn conforming(
features: u32,
optional: &Optional<'_>,
) -> crate::error::Result<Conforming<12, 4, 4, 4>> {
Conforming::new(
&crate::clusters::generated::general_diagnostics::CLUSTER,
features,
optional,
)
}
pub const ALL_OPTIONAL: Optional<'static> = Optional {
attributes: &[
TOTAL_OPERATIONAL_HOURS,
BOOT_REASON,
ACTIVE_HARDWARE_FAULTS,
ACTIVE_RADIO_FAULTS,
ACTIVE_NETWORK_FAULTS,
DEVICE_LOAD_STATUS,
],
commands: &[],
events: &[
HARDWARE_FAULT_CHANGE,
RADIO_FAULT_CHANGE,
NETWORK_FAULT_CHANGE,
],
};
#[derive(Debug)]
pub struct GeneralDiagnostics<'a, D: Diagnostics> {
device: &'a D,
features: u32,
triggers_enabled: RefCell<bool>,
}
impl<'a, D: Diagnostics> GeneralDiagnostics<'a, D> {
#[must_use]
pub fn new(device: &'a D, features: u32) -> Self {
let enabled = device.enable_key().is_some();
Self {
device,
features,
triggers_enabled: RefCell::new(enabled),
}
}
#[must_use]
pub fn triggers_enabled(&self) -> bool {
*self.triggers_enabled.borrow()
}
pub fn set_triggers_enabled(&self, enabled: bool) -> Result<(), Status> {
if enabled && self.device.enable_key().is_none() {
return Err(Status::ConstraintError);
}
*self.triggers_enabled.borrow_mut() = enabled;
Ok(())
}
fn check_enable_key(&self, offered: &[u8]) -> Result<(), StatusIb> {
if !self.triggers_enabled() {
return Err(Status::ConstraintError.into());
}
if offered.len() != SYMMETRIC_KEY_LENGTH_BYTES {
return Err(Status::ConstraintError.into());
}
if offered.iter().all(|&b| b == 0) {
return Err(Status::ConstraintError.into());
}
let Some(configured) = self.device.enable_key() else {
return Err(Status::ConstraintError.into());
};
if !ct_eq(offered, configured.as_bytes()) {
return Err(Status::ConstraintError.into());
}
Ok(())
}
}
fn decode_trigger(fields: &[u8]) -> Result<(heapless::Vec<u8, 32>, u64), Status> {
let mut reader = TlvReader::new_in(fields, ContainerKind::Structure);
let element = reader
.next_element()
.map_err(|_| Status::InvalidAction)?
.ok_or(Status::InvalidAction)?;
if element.value.container() != Some(ContainerKind::Structure) {
return Err(Status::InvalidAction);
}
let mut key: Option<heapless::Vec<u8, 32>> = None;
let mut trigger = None;
loop {
let Some(field) = reader.next_element().map_err(|_| Status::InvalidAction)? else {
return Err(Status::InvalidAction);
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => {
let bytes = field.octets().map_err(|_| Status::ConstraintError)?;
key = Some(heapless::Vec::from_slice(bytes).map_err(|_| Status::ConstraintError)?);
}
Some(1) => trigger = Some(field.unsigned().map_err(|_| Status::ConstraintError)?),
_ => {
reader
.skip_value(&field)
.map_err(|_| Status::InvalidAction)?;
}
}
}
match (key, trigger) {
(Some(key), Some(trigger)) => Ok((key, trigger)),
_ => Err(Status::InvalidCommand),
}
}
fn decode_payload_test(fields: &[u8]) -> Result<(heapless::Vec<u8, 32>, u8, u16), Status> {
let mut reader = TlvReader::new_in(fields, ContainerKind::Structure);
let element = reader
.next_element()
.map_err(|_| Status::InvalidAction)?
.ok_or(Status::InvalidAction)?;
if element.value.container() != Some(ContainerKind::Structure) {
return Err(Status::InvalidAction);
}
let mut key: Option<heapless::Vec<u8, 32>> = None;
let mut value = None;
let mut count = None;
loop {
let Some(field) = reader.next_element().map_err(|_| Status::InvalidAction)? else {
return Err(Status::InvalidAction);
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => {
let bytes = field.octets().map_err(|_| Status::ConstraintError)?;
key = Some(heapless::Vec::from_slice(bytes).map_err(|_| Status::ConstraintError)?);
}
Some(1) => {
value = Some(
u8::try_from(field.unsigned().map_err(|_| Status::ConstraintError)?)
.map_err(|_| Status::ConstraintError)?,
);
}
Some(2) => {
let raw = field.unsigned().map_err(|_| Status::ConstraintError)?;
let raw = u16::try_from(raw).map_err(|_| Status::ConstraintError)?;
if raw > PAYLOAD_TEST_MAX {
return Err(Status::ConstraintError);
}
count = Some(raw);
}
_ => {
reader
.skip_value(&field)
.map_err(|_| Status::InvalidAction)?;
}
}
}
match (key, value, count) {
(Some(key), Some(value), Some(count)) => Ok((key, value, count)),
_ => Err(Status::InvalidCommand),
}
}
impl<D: Diagnostics> ClusterHandler for GeneralDiagnostics<'_, D> {
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);
match resolved.attribute {
NETWORK_INTERFACES => {
full(w.start_array(tag))?;
let mut failure = None;
self.device.network_interfaces(&mut |interface| {
if failure.is_none()
&& let Err(error) = interface.encode(w)
{
failure = Some(error);
}
});
if failure.is_some() {
return Err(Status::ResourceExhausted);
}
full(w.end_container())
}
REBOOT_COUNT => full(w.unsigned(tag, u64::from(self.device.reboot_count()))),
UP_TIME => full(w.unsigned(tag, self.device.up_time())),
TOTAL_OPERATIONAL_HOURS => {
let Some(hours) = self.device.total_operational_hours() else {
return Err(Status::UnsupportedAttribute);
};
full(w.unsigned(tag, u64::from(hours)))
}
BOOT_REASON => full(w.unsigned(tag, self.device.boot_reason() as u64)),
ACTIVE_HARDWARE_FAULTS => {
full(w.start_array(tag))?;
let mut failure = false;
self.device.active_hardware_faults(&mut |fault| {
failure |= w.unsigned(Tag::Anonymous, fault as u64).is_err();
});
if failure {
return Err(Status::ResourceExhausted);
}
full(w.end_container())
}
ACTIVE_RADIO_FAULTS => {
full(w.start_array(tag))?;
let mut failure = false;
self.device.active_radio_faults(&mut |fault| {
failure |= w.unsigned(Tag::Anonymous, fault as u64).is_err();
});
if failure {
return Err(Status::ResourceExhausted);
}
full(w.end_container())
}
ACTIVE_NETWORK_FAULTS => {
full(w.start_array(tag))?;
let mut failure = false;
self.device.active_network_faults(&mut |fault| {
failure |= w.unsigned(Tag::Anonymous, fault as u64).is_err();
});
if failure {
return Err(Status::ResourceExhausted);
}
full(w.end_container())
}
TEST_EVENT_TRIGGERS_ENABLED => full(w.bool(tag, self.triggers_enabled())),
DEVICE_LOAD_STATUS => {
let Some(load) = self.device.device_load(ctx) else {
return Err(Status::UnsupportedAttribute);
};
full(load.encode(w, tag))
}
_ => Err(Status::UnsupportedAttribute),
}
}
fn invoke(
&self,
resolved: &ResolvedCommand<'_>,
fields: Option<&[u8]>,
ctx: &InteractionContext<'_>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<Option<CommandId>, StatusIb> {
let full = |r: crate::error::Result<()>| r.map_err(|_| StatusIb::from(Status::Failure));
match resolved.command.id {
TEST_EVENT_TRIGGER => {
let (key, trigger) =
decode_trigger(fields.ok_or(StatusIb::from(Status::InvalidCommand))?)?;
self.check_enable_key(&key)?;
if !self.device.test_event_trigger(trigger) {
return Err(Status::InvalidCommand.into());
}
Ok(None)
}
TIME_SNAPSHOT => {
full(w.start_structure(tag))?;
full(w.unsigned(Tag::Context(0), ctx.now.as_millis()))?;
match self.device.posix_time_ms() {
Some(posix) => full(w.unsigned(Tag::Context(1), posix))?,
None => full(w.null(Tag::Context(1)))?,
}
full(w.end_container())?;
Ok(Some(TIME_SNAPSHOT_RESPONSE))
}
PAYLOAD_TEST_REQUEST => {
if self.features & FEATURE_DATA_MODEL_TEST == 0 {
return Err(Status::UnsupportedCommand.into());
}
let (key, value, count) =
decode_payload_test(fields.ok_or(StatusIb::from(Status::InvalidCommand))?)?;
self.check_enable_key(&key)?;
full(w.start_structure(tag))?;
w.octets_fill(Tag::Context(0), usize::from(count), value)
.map_err(|_| StatusIb::from(Status::ResourceExhausted))?;
full(w.end_container())?;
Ok(Some(PAYLOAD_TEST_RESPONSE))
}
_ => Err(Status::UnsupportedCommand.into()),
}
}
}
impl<D: Diagnostics> Cluster for GeneralDiagnostics<'_, D> {
const ID: ClusterId = ID;
}