use core::cell::{Cell, RefCell};
use heapless::Vec;
use crate::dm::access::{Access, Privilege};
use crate::dm::meta::{
AttributeDescriptor, AttributeQualities, ClusterDescriptor, CommandDescriptor,
};
use crate::dm::{Resolved, ResolvedCommand};
use crate::im::{
AttributeId, ClusterHandler, ClusterId, CommandId, InteractionContext, Status, StatusIb,
WriteOp,
};
use crate::tlv::{ContainerKind, Tag, TlvReader, TlvWriter, set_once};
use super::Cluster;
pub const ID: ClusterId = 0x0031;
pub const REVISION: u16 = 2;
pub const FEATURE_WIFI: u32 = 1 << 0;
pub const FEATURE_THREAD: u32 = 1 << 1;
pub const FEATURE_ETHERNET: u32 = 1 << 2;
pub const MAX_NETWORKS: AttributeId = 0x0000;
pub const NETWORKS: AttributeId = 0x0001;
pub const SCAN_MAX_TIME_SECONDS: AttributeId = 0x0002;
pub const CONNECT_MAX_TIME_SECONDS: AttributeId = 0x0003;
pub const INTERFACE_ENABLED: AttributeId = 0x0004;
pub const LAST_NETWORKING_STATUS: AttributeId = 0x0005;
pub const LAST_NETWORK_ID: AttributeId = 0x0006;
pub const LAST_CONNECT_ERROR_VALUE: AttributeId = 0x0007;
pub const SUPPORTED_WIFI_BANDS: AttributeId = 0x0008;
pub const SUPPORTED_THREAD_FEATURES: AttributeId = 0x0009;
pub const THREAD_VERSION: AttributeId = 0x000A;
pub const SCAN_NETWORKS: CommandId = 0x00;
pub const SCAN_NETWORKS_RESPONSE: CommandId = 0x01;
pub const ADD_OR_UPDATE_WIFI_NETWORK: CommandId = 0x02;
pub const ADD_OR_UPDATE_THREAD_NETWORK: CommandId = 0x03;
pub const REMOVE_NETWORK: CommandId = 0x04;
pub const NETWORK_CONFIG_RESPONSE: CommandId = 0x05;
pub const CONNECT_NETWORK: CommandId = 0x06;
pub const CONNECT_NETWORK_RESPONSE: CommandId = 0x07;
pub const REORDER_NETWORK: CommandId = 0x08;
pub const NETWORK_ID_MAX: usize = 32;
pub const CREDENTIALS_MAX: usize = 64;
pub const OPERATIONAL_DATASET_MAX: usize = 254;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(u8)]
#[non_exhaustive]
pub enum NetworkStatus {
Success = 0,
OutOfRange = 1,
BoundsExceeded = 2,
NetworkIdNotFound = 3,
DuplicateNetworkId = 4,
NetworkNotFound = 5,
RegulatoryError = 6,
AuthFailure = 7,
UnsupportedSecurity = 8,
OtherConnectionFailure = 9,
Ipv6Failed = 10,
IpBindFailed = 11,
UnknownError = 12,
}
impl NetworkStatus {
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
#[must_use]
pub const fn is_success(self) -> bool {
matches!(self, Self::Success)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum NetworkKind {
WiFi,
Thread,
Ethernet,
}
impl NetworkKind {
#[must_use]
pub const fn feature(self) -> u32 {
match self {
Self::WiFi => FEATURE_WIFI,
Self::Thread => FEATURE_THREAD,
Self::Ethernet => FEATURE_ETHERNET,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(u8)]
#[non_exhaustive]
pub enum WiFiBand {
Band2G4 = 0,
Band3G65 = 1,
Band5G = 2,
Band6G = 3,
Band60G = 4,
Band1G = 5,
}
impl WiFiBand {
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
bitflags::bitflags! {
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub struct WiFiSecurity: u8 {
const UNENCRYPTED = 1 << 0;
const WEP = 1 << 1;
const WPA_PERSONAL = 1 << 2;
const WPA2_PERSONAL = 1 << 3;
const WPA3_PERSONAL = 1 << 4;
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub struct ThreadCapabilities: u16 {
const IS_BORDER_ROUTER_CAPABLE = 1 << 0;
const IS_ROUTER_CAPABLE = 1 << 1;
const IS_SLEEPY_END_DEVICE_CAPABLE = 1 << 2;
const IS_FULL_THREAD_DEVICE = 1 << 3;
const IS_SYNCHRONIZED_SLEEPY_END_DEVICE_CAPABLE = 1 << 4;
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NetworkInfo {
pub id: Vec<u8, NETWORK_ID_MAX>,
pub connected: bool,
}
impl NetworkInfo {
pub fn new(id: &[u8]) -> Result<Self, NetworkStatus> {
Ok(Self {
id: copy_id(id)?,
connected: false,
})
}
}
fn copy_id(id: &[u8]) -> Result<Vec<u8, NETWORK_ID_MAX>, NetworkStatus> {
if id.is_empty() || id.len() > NETWORK_ID_MAX {
return Err(NetworkStatus::OutOfRange);
}
Vec::from_slice(id).map_err(|_| NetworkStatus::OutOfRange)
}
#[derive(Debug, Clone)]
pub struct NetworkStore<const N: usize> {
networks: Vec<NetworkInfo, N>,
saved: Option<Vec<NetworkInfo, N>>,
}
impl<const N: usize> Default for NetworkStore<N> {
fn default() -> Self {
Self::new()
}
}
impl<const N: usize> NetworkStore<N> {
#[must_use]
pub const fn new() -> Self {
Self {
networks: Vec::new(),
saved: None,
}
}
#[must_use]
pub const fn capacity(&self) -> usize {
N
}
#[must_use]
pub fn entries(&self) -> &[NetworkInfo] {
&self.networks
}
#[must_use]
pub fn position(&self, id: &[u8]) -> Option<usize> {
self.networks.iter().position(|n| n.id.as_slice() == id)
}
pub fn add_or_update(&mut self, id: &[u8]) -> Result<u8, NetworkStatus> {
let id = copy_id(id)?;
if let Some(index) = self.position(&id) {
return index_of(index);
}
if self.networks.len() >= N {
return Err(NetworkStatus::BoundsExceeded);
}
self.networks
.push(NetworkInfo {
id,
connected: false,
})
.map_err(|_| NetworkStatus::BoundsExceeded)?;
index_of(self.networks.len().saturating_sub(1))
}
pub fn remove(&mut self, id: &[u8]) -> Result<u8, NetworkStatus> {
let index = self.position(id).ok_or(NetworkStatus::NetworkIdNotFound)?;
self.networks.remove(index);
index_of(index)
}
pub fn reorder(&mut self, id: &[u8], to: u8) -> Result<u8, NetworkStatus> {
let from = self.position(id).ok_or(NetworkStatus::NetworkIdNotFound)?;
let to_index = usize::from(to);
if to_index >= self.networks.len() {
return Err(NetworkStatus::OutOfRange);
}
if from == to_index {
return Ok(to);
}
let entry = self.networks.remove(from);
self.networks
.insert(to_index, entry)
.map_err(|_| NetworkStatus::UnknownError)?;
Ok(to)
}
pub fn set_connected(&mut self, id: &[u8]) -> Result<(), NetworkStatus> {
if self.position(id).is_none() {
return Err(NetworkStatus::NetworkIdNotFound);
}
for entry in &mut self.networks {
entry.connected = entry.id.as_slice() == id;
}
Ok(())
}
pub fn set_all_disconnected(&mut self) {
for entry in &mut self.networks {
entry.connected = false;
}
}
pub fn snapshot(&mut self) {
if self.saved.is_none() {
self.saved = Some(self.networks.clone());
}
}
pub fn restore(&mut self) {
if let Some(saved) = self.saved.take() {
self.networks = saved;
}
}
pub fn commit(&mut self) {
self.saved = None;
}
pub fn seed(&mut self, id: &[u8], connected: bool) -> Result<(), NetworkStatus> {
let id = copy_id(id)?;
self.networks.clear();
self.networks
.push(NetworkInfo { id, connected })
.map_err(|_| NetworkStatus::BoundsExceeded)
}
}
fn index_of(index: usize) -> Result<u8, NetworkStatus> {
u8::try_from(index).map_err(|_| NetworkStatus::OutOfRange)
}
#[must_use]
pub fn thread_extended_pan_id(dataset: &[u8]) -> Option<[u8; 8]> {
const EXTENDED_PAN_ID: u8 = 2;
const EXTENDED_LENGTH: u8 = 0xFF;
let mut at = 0usize;
loop {
let kind = *dataset.get(at)?;
let short = *dataset.get(at.checked_add(1)?)?;
let (header, len) = if short == EXTENDED_LENGTH {
let hi = u16::from(*dataset.get(at.checked_add(2)?)?);
let lo = u16::from(*dataset.get(at.checked_add(3)?)?);
(4usize, usize::from((hi << 8) | lo))
} else {
(2usize, usize::from(short))
};
let start = at.checked_add(header)?;
let end = start.checked_add(len)?;
let value = dataset.get(start..end)?;
if kind == EXTENDED_PAN_ID {
let bytes: [u8; 8] = value.try_into().ok()?;
return Some(bytes);
}
at = end;
if at >= dataset.len() {
return None;
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct WiFiScanResult<'a> {
pub security: WiFiSecurity,
pub ssid: &'a [u8],
pub bssid: [u8; 6],
pub channel: u16,
pub band: Option<WiFiBand>,
pub rssi: Option<i8>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ThreadScanResult<'a> {
pub pan_id: u16,
pub extended_pan_id: u64,
pub network_name: &'a str,
pub channel: u16,
pub version: u8,
pub extended_address: [u8; 8],
pub rssi: i8,
pub lqi: u8,
}
pub struct ScanResults<'w, 'b> {
w: &'w mut TlvWriter<'b>,
count: usize,
full: bool,
}
const ONE_RESULT_BYTES: usize = 128;
impl ScanResults<'_, '_> {
pub fn wifi(&mut self, result: &WiFiScanResult<'_>) -> Result<(), NetworkStatus> {
self.append(|w| {
w.start_structure(Tag::Anonymous)?;
w.unsigned(Tag::Context(0), u64::from(result.security.bits()))?;
w.octets(Tag::Context(1), result.ssid)?;
w.octets(Tag::Context(2), &result.bssid)?;
w.unsigned(Tag::Context(3), u64::from(result.channel))?;
if let Some(band) = result.band {
w.unsigned(Tag::Context(4), u64::from(band.value()))?;
}
if let Some(rssi) = result.rssi {
w.signed(Tag::Context(5), i64::from(rssi))?;
}
w.end_container()
})
}
pub fn thread(&mut self, result: &ThreadScanResult<'_>) -> Result<(), NetworkStatus> {
self.append(|w| {
w.start_structure(Tag::Anonymous)?;
w.unsigned(Tag::Context(0), u64::from(result.pan_id))?;
w.unsigned(Tag::Context(1), result.extended_pan_id)?;
w.utf8(Tag::Context(2), result.network_name)?;
w.unsigned(Tag::Context(3), u64::from(result.channel))?;
w.unsigned(Tag::Context(4), u64::from(result.version))?;
w.octets(Tag::Context(5), &result.extended_address)?;
w.signed(Tag::Context(6), i64::from(result.rssi))?;
w.unsigned(Tag::Context(7), u64::from(result.lqi))?;
w.end_container()
})
}
fn append(
&mut self,
build: impl FnOnce(&mut TlvWriter<'_>) -> crate::error::Result<()>,
) -> Result<(), NetworkStatus> {
if self.full {
return Err(NetworkStatus::BoundsExceeded);
}
let mut scratch = [0u8; ONE_RESULT_BYTES];
let encoded = {
let mut one = TlvWriter::new_in(&mut scratch, ContainerKind::Array);
build(&mut one).and_then(|()| one.finish())
};
let Ok(encoded) = encoded else {
self.full = true;
return Err(NetworkStatus::BoundsExceeded);
};
if self.w.raw_element(encoded).is_err() {
self.full = true;
return Err(NetworkStatus::BoundsExceeded);
}
self.count = self.count.saturating_add(1);
Ok(())
}
#[must_use]
pub const fn len(&self) -> usize {
self.count
}
#[must_use]
pub const fn is_empty(&self) -> bool {
self.count == 0
}
#[must_use]
pub const fn is_full(&self) -> bool {
self.full
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ConnectOutcome {
pub status: NetworkStatus,
pub error_value: Option<i32>,
}
impl ConnectOutcome {
#[must_use]
pub const fn success() -> Self {
Self {
status: NetworkStatus::Success,
error_value: None,
}
}
#[must_use]
pub const fn failed(status: NetworkStatus) -> Self {
Self {
status,
error_value: None,
}
}
#[must_use]
pub const fn failed_with(status: NetworkStatus, error_value: i32) -> Self {
Self {
status,
error_value: Some(error_value),
}
}
}
pub trait NetworkDriver {
fn kind(&self) -> NetworkKind;
fn scan(&self, _ssid: Option<&[u8]>, _results: &mut ScanResults<'_, '_>) -> NetworkStatus {
NetworkStatus::UnknownError
}
fn add_or_update_wifi(&self, _ssid: &[u8], _credentials: &[u8]) -> NetworkStatus {
NetworkStatus::UnknownError
}
fn add_or_update_thread(&self, _dataset: &[u8]) -> NetworkStatus {
NetworkStatus::UnknownError
}
fn forget(&self, _id: &[u8]) {}
fn connect(&self, _id: &[u8]) -> ConnectOutcome {
ConnectOutcome::failed(NetworkStatus::UnknownError)
}
fn set_interface_enabled(&self, _enabled: bool) -> Result<(), Status> {
Err(Status::InvalidAction)
}
}
#[derive(Debug, Clone, Copy, Default)]
pub struct EthernetDriver;
impl NetworkDriver for EthernetDriver {
fn kind(&self) -> NetworkKind {
NetworkKind::Ethernet
}
fn set_interface_enabled(&self, enabled: bool) -> Result<(), Status> {
if enabled {
Ok(())
} else {
Err(Status::InvalidAction)
}
}
}
const fn fixed(id: AttributeId) -> AttributeDescriptor {
AttributeDescriptor::read_only(id).with_qualities(AttributeQualities::FIXED)
}
const fn administered(id: AttributeId) -> AttributeDescriptor {
AttributeDescriptor::read_only(id).with_access(Access::read_only(Privilege::Administer))
}
const COMMON: [AttributeDescriptor; 6] = [
administered(MAX_NETWORKS).with_qualities(AttributeQualities::FIXED),
administered(NETWORKS),
AttributeDescriptor::read_write(INTERFACE_ENABLED)
.with_access(Access::read_write_with(
Privilege::View,
Privilege::Administer,
))
.with_qualities(AttributeQualities::NON_VOLATILE),
administered(LAST_NETWORKING_STATUS).with_qualities(AttributeQualities::NULLABLE),
administered(LAST_NETWORK_ID).with_qualities(AttributeQualities::NULLABLE),
administered(LAST_CONNECT_ERROR_VALUE).with_qualities(AttributeQualities::NULLABLE),
];
const ETHERNET_ATTRIBUTES: &[AttributeDescriptor] = &[
COMMON[0], COMMON[1], COMMON[2], COMMON[3], COMMON[4], COMMON[5],
];
const WIFI_ATTRIBUTES: &[AttributeDescriptor] = &[
COMMON[0],
COMMON[1],
fixed(SCAN_MAX_TIME_SECONDS),
fixed(CONNECT_MAX_TIME_SECONDS),
COMMON[2],
COMMON[3],
COMMON[4],
COMMON[5],
fixed(SUPPORTED_WIFI_BANDS),
];
const THREAD_ATTRIBUTES: &[AttributeDescriptor] = &[
COMMON[0],
COMMON[1],
fixed(SCAN_MAX_TIME_SECONDS),
fixed(CONNECT_MAX_TIME_SECONDS),
COMMON[2],
COMMON[3],
COMMON[4],
COMMON[5],
fixed(SUPPORTED_THREAD_FEATURES),
fixed(THREAD_VERSION),
];
const fn invoke_admin(id: CommandId) -> CommandDescriptor {
CommandDescriptor::new(id).with_access(Access::invoke(Privilege::Administer))
}
const SHARED_COMMANDS: [CommandDescriptor; 4] = [
invoke_admin(SCAN_NETWORKS).with_response(SCAN_NETWORKS_RESPONSE),
invoke_admin(REMOVE_NETWORK).with_response(NETWORK_CONFIG_RESPONSE),
invoke_admin(CONNECT_NETWORK).with_response(CONNECT_NETWORK_RESPONSE),
invoke_admin(REORDER_NETWORK).with_response(NETWORK_CONFIG_RESPONSE),
];
const WIFI_COMMANDS: &[CommandDescriptor] = &[
SHARED_COMMANDS[0],
invoke_admin(ADD_OR_UPDATE_WIFI_NETWORK).with_response(NETWORK_CONFIG_RESPONSE),
SHARED_COMMANDS[1],
SHARED_COMMANDS[2],
SHARED_COMMANDS[3],
];
const THREAD_COMMANDS: &[CommandDescriptor] = &[
SHARED_COMMANDS[0],
invoke_admin(ADD_OR_UPDATE_THREAD_NETWORK).with_response(NETWORK_CONFIG_RESPONSE),
SHARED_COMMANDS[1],
SHARED_COMMANDS[2],
SHARED_COMMANDS[3],
];
#[must_use]
pub const fn ethernet() -> ClusterDescriptor<'static> {
ClusterDescriptor {
id: ID,
revision: REVISION,
feature_map: FEATURE_ETHERNET,
attributes: ETHERNET_ATTRIBUTES,
accepted_commands: &[],
generated_commands: &[],
events: &[],
}
}
#[must_use]
pub const fn wifi() -> ClusterDescriptor<'static> {
ClusterDescriptor {
id: ID,
revision: REVISION,
feature_map: FEATURE_WIFI,
attributes: WIFI_ATTRIBUTES,
accepted_commands: WIFI_COMMANDS,
generated_commands: &[],
events: &[],
}
}
#[must_use]
pub const fn thread() -> ClusterDescriptor<'static> {
ClusterDescriptor {
id: ID,
revision: REVISION,
feature_map: FEATURE_THREAD,
attributes: THREAD_ATTRIBUTES,
accepted_commands: THREAD_COMMANDS,
generated_commands: &[],
events: &[],
}
}
#[derive(Debug, Clone, Copy)]
pub struct Capabilities<'a> {
pub scan_max_time_seconds: u8,
pub connect_max_time_seconds: u8,
pub wifi_bands: &'a [WiFiBand],
pub thread_features: ThreadCapabilities,
pub thread_version: u16,
}
impl Default for Capabilities<'_> {
fn default() -> Self {
Self {
scan_max_time_seconds: 10,
connect_max_time_seconds: 30,
wifi_bands: &[WiFiBand::Band2G4],
thread_features: ThreadCapabilities::empty(),
thread_version: 4,
}
}
}
pub struct NetworkCommissioning<'a, D: NetworkDriver, const N: usize> {
pub driver: &'a D,
pub fail_safe: &'a RefCell<crate::commissioning::failsafe::FailSafe>,
pub capabilities: Capabilities<'a>,
store: RefCell<NetworkStore<N>>,
enabled: Cell<bool>,
last_status: Cell<Option<NetworkStatus>>,
last_network_id: RefCell<Option<Vec<u8, NETWORK_ID_MAX>>>,
last_connect_error: Cell<Option<i32>>,
}
impl<'a, D: NetworkDriver, const N: usize> NetworkCommissioning<'a, D, N> {
#[must_use]
pub fn new(
driver: &'a D,
fail_safe: &'a RefCell<crate::commissioning::failsafe::FailSafe>,
capabilities: Capabilities<'a>,
) -> Self {
Self {
driver,
fail_safe,
capabilities,
store: RefCell::new(NetworkStore::new()),
enabled: Cell::new(true),
last_status: Cell::new(None),
last_network_id: RefCell::new(None),
last_connect_error: Cell::new(None),
}
}
#[must_use]
pub fn descriptor(&self) -> ClusterDescriptor<'static> {
match self.driver.kind() {
NetworkKind::WiFi => wifi(),
NetworkKind::Thread => thread(),
NetworkKind::Ethernet => ethernet(),
}
}
#[must_use]
pub fn store(&self) -> core::cell::Ref<'_, NetworkStore<N>> {
self.store.borrow()
}
#[must_use]
pub fn store_mut(&self) -> core::cell::RefMut<'_, NetworkStore<N>> {
self.store.borrow_mut()
}
#[must_use]
pub fn is_enabled(&self) -> bool {
self.enabled.get()
}
pub fn on_fail_safe_expired(&self) {
self.store.borrow_mut().restore();
}
pub fn on_commissioning_complete(&self) {
self.store.borrow_mut().commit();
}
fn record_outcome(&self, status: NetworkStatus, id: Option<&[u8]>, error: Option<i32>) {
self.last_status.set(Some(status));
if let Some(id) = id {
*self.last_network_id.borrow_mut() = Vec::from_slice(id).ok();
}
self.last_connect_error.set(error);
}
fn require_fail_safe(&self, ctx: &InteractionContext<'_>) -> Result<(), Status> {
if self.fail_safe.borrow().is_armed(ctx.now) {
Ok(())
} else {
Err(Status::FailsafeRequired)
}
}
fn record_change(&self, ctx: &InteractionContext<'_>) {
let already = self
.fail_safe
.borrow()
.armed(ctx.now)
.is_some_and(|armed| armed.progress.changed_networks);
if !already {
self.store.borrow_mut().snapshot();
}
let _ = self
.fail_safe
.borrow_mut()
.record(ctx.now, |p| p.changed_networks = true);
}
fn set_breadcrumb(&self, breadcrumb: Option<u64>, status: NetworkStatus) {
if status.is_success()
&& let Some(breadcrumb) = breadcrumb
{
self.fail_safe.borrow_mut().set_breadcrumb(breadcrumb);
}
}
}
impl<D: NetworkDriver, const N: usize> NetworkCommissioning<'_, D, N> {
pub fn scan(
&self,
ssid: Option<&[u8]>,
breadcrumb: Option<u64>,
ctx: &InteractionContext<'_>,
scratch: &mut [u8],
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<(), Status> {
self.require_fail_safe(ctx)?;
let ssid = ssid.filter(|_| self.driver.kind() == NetworkKind::WiFi);
if let Some(ssid) = ssid
&& (ssid.is_empty() || ssid.len() > NETWORK_ID_MAX)
{
self.record_outcome(NetworkStatus::OutOfRange, Some(ssid), None);
return write_scan_response(NetworkStatus::OutOfRange, None, w, tag);
}
let results_tag = match self.driver.kind() {
NetworkKind::Thread => Tag::Context(3),
_ => Tag::Context(2),
};
let mut results = TlvWriter::new_in(scratch, ContainerKind::Structure);
results
.start_array(results_tag)
.map_err(|_| Status::ResourceExhausted)?;
let status = {
let mut sink = ScanResults {
w: &mut results,
count: 0,
full: false,
};
self.driver.scan(ssid, &mut sink)
};
results
.end_container()
.map_err(|_| Status::ResourceExhausted)?;
let encoded = results.finish().map_err(|_| Status::ResourceExhausted)?;
self.record_outcome(status, ssid, None);
self.set_breadcrumb(breadcrumb, status);
write_scan_response(status, status.is_success().then_some(encoded), w, tag)
}
pub fn add_or_update_wifi(
&self,
ssid: &[u8],
credentials: &[u8],
breadcrumb: Option<u64>,
ctx: &InteractionContext<'_>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<(), Status> {
self.require_fail_safe(ctx)?;
if self.driver.kind() != NetworkKind::WiFi {
return Err(Status::UnsupportedCommand);
}
self.record_change(ctx);
let outcome = match self.driver.add_or_update_wifi(ssid, credentials) {
NetworkStatus::Success => self.store.borrow_mut().add_or_update(ssid),
other => Err(other),
};
self.finish_config(outcome, ssid, breadcrumb, w, tag)
}
pub fn add_or_update_thread(
&self,
dataset: &[u8],
breadcrumb: Option<u64>,
ctx: &InteractionContext<'_>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<(), Status> {
self.require_fail_safe(ctx)?;
if self.driver.kind() != NetworkKind::Thread {
return Err(Status::UnsupportedCommand);
}
self.record_change(ctx);
let Some(xpan) = thread_extended_pan_id(dataset) else {
self.record_outcome(NetworkStatus::OutOfRange, None, None);
return write_config_response(NetworkStatus::OutOfRange, None, w, tag);
};
let outcome = match self.driver.add_or_update_thread(dataset) {
NetworkStatus::Success => self.store.borrow_mut().add_or_update(&xpan),
other => Err(other),
};
self.finish_config(outcome, &xpan, breadcrumb, w, tag)
}
pub fn remove_network(
&self,
id: &[u8],
breadcrumb: Option<u64>,
ctx: &InteractionContext<'_>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<(), Status> {
self.require_fail_safe(ctx)?;
self.record_change(ctx);
let outcome = self.store.borrow_mut().remove(id);
if outcome.is_ok() {
self.driver.forget(id);
}
self.finish_config(outcome, id, breadcrumb, w, tag)
}
pub fn reorder_network(
&self,
id: &[u8],
index: u8,
breadcrumb: Option<u64>,
ctx: &InteractionContext<'_>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<(), Status> {
self.require_fail_safe(ctx)?;
self.record_change(ctx);
let outcome = self.store.borrow_mut().reorder(id, index);
self.finish_config(outcome, id, breadcrumb, w, tag)
}
pub fn connect_network(
&self,
id: &[u8],
breadcrumb: Option<u64>,
ctx: &InteractionContext<'_>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<(), Status> {
self.require_fail_safe(ctx)?;
self.record_change(ctx);
if self.store.borrow().position(id).is_none() {
self.record_outcome(NetworkStatus::NetworkIdNotFound, Some(id), None);
return write_connect_response(
ConnectOutcome::failed(NetworkStatus::NetworkIdNotFound),
w,
tag,
);
}
let outcome = self.driver.connect(id);
{
let mut store = self.store.borrow_mut();
if outcome.status.is_success() {
let _ = store.set_connected(id);
} else {
store.set_all_disconnected();
}
}
self.record_outcome(outcome.status, Some(id), outcome.error_value);
self.set_breadcrumb(breadcrumb, outcome.status);
write_connect_response(outcome, w, tag)
}
fn finish_config(
&self,
outcome: Result<u8, NetworkStatus>,
id: &[u8],
breadcrumb: Option<u64>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<(), Status> {
let (status, index) = match outcome {
Ok(index) => (NetworkStatus::Success, Some(index)),
Err(status) => (status, None),
};
self.record_outcome(status, Some(id), None);
self.set_breadcrumb(breadcrumb, status);
write_config_response(status, index, w, tag)
}
}
fn write_scan_response(
status: NetworkStatus,
results: Option<&[u8]>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<(), Status> {
let full = |r: crate::error::Result<()>| r.map_err(|_| Status::ResourceExhausted);
full(w.start_structure(tag))?;
full(w.unsigned(Tag::Context(0), u64::from(status.value())))?;
if let Some(results) = results {
full(w.raw_element(results))?;
}
full(w.end_container())
}
fn write_config_response(
status: NetworkStatus,
index: Option<u8>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<(), Status> {
let full = |r: crate::error::Result<()>| r.map_err(|_| Status::ResourceExhausted);
full(w.start_structure(tag))?;
full(w.unsigned(Tag::Context(0), u64::from(status.value())))?;
if let Some(index) = index {
full(w.unsigned(Tag::Context(2), u64::from(index)))?;
}
full(w.end_container())
}
fn write_connect_response(
outcome: ConnectOutcome,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<(), Status> {
let full = |r: crate::error::Result<()>| r.map_err(|_| Status::ResourceExhausted);
full(w.start_structure(tag))?;
full(w.unsigned(Tag::Context(0), u64::from(outcome.status.value())))?;
match outcome.error_value {
Some(value) => full(w.signed(Tag::Context(2), i64::from(value)))?,
None => full(w.null(Tag::Context(2)))?,
}
full(w.end_container())
}
pub const SCAN_SCRATCH_BYTES: usize = 1024;
impl<D: NetworkDriver, const N: usize> ClusterHandler for NetworkCommissioning<'_, D, N> {
fn on_lifecycle(&self, event: crate::im::Lifecycle) {
match event {
crate::im::Lifecycle::FailSafeExpired { .. } => self.on_fail_safe_expired(),
crate::im::Lifecycle::CommissioningComplete(_) => self.on_commissioning_complete(),
crate::im::Lifecycle::FabricRemoved(_) => {}
}
}
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 {
MAX_NETWORKS => {
let capacity = u8::try_from(N).unwrap_or(u8::MAX);
full(w.unsigned(tag, u64::from(capacity)))
}
NETWORKS => {
let store = self.store.borrow();
full(w.start_array(tag))?;
for entry in store.entries() {
full(w.start_structure(Tag::Anonymous))?;
full(w.octets(Tag::Context(0), &entry.id))?;
full(w.bool(Tag::Context(1), entry.connected))?;
full(w.end_container())?;
}
full(w.end_container())
}
SCAN_MAX_TIME_SECONDS => {
full(w.unsigned(tag, u64::from(self.capabilities.scan_max_time_seconds)))
}
CONNECT_MAX_TIME_SECONDS => {
full(w.unsigned(tag, u64::from(self.capabilities.connect_max_time_seconds)))
}
INTERFACE_ENABLED => full(w.bool(tag, self.enabled.get())),
LAST_NETWORKING_STATUS => match self.last_status.get() {
Some(status) => full(w.unsigned(tag, u64::from(status.value()))),
None => full(w.null(tag)),
},
LAST_NETWORK_ID => match self.last_network_id.borrow().as_deref() {
Some(id) => full(w.octets(tag, id)),
None => full(w.null(tag)),
},
LAST_CONNECT_ERROR_VALUE => match self.last_connect_error.get() {
Some(value) => full(w.signed(tag, i64::from(value))),
None => full(w.null(tag)),
},
SUPPORTED_WIFI_BANDS => {
full(w.start_array(tag))?;
for band in self.capabilities.wifi_bands {
full(w.unsigned(Tag::Anonymous, u64::from(band.value())))?;
}
full(w.end_container())
}
SUPPORTED_THREAD_FEATURES => {
full(w.unsigned(tag, u64::from(self.capabilities.thread_features.bits())))
}
THREAD_VERSION => full(w.unsigned(tag, u64::from(self.capabilities.thread_version))),
_ => Err(Status::UnsupportedAttribute),
}
}
fn write(
&self,
resolved: &Resolved<'_>,
data: &[u8],
_op: WriteOp,
_ctx: &InteractionContext<'_>,
) -> Result<(), Status> {
match resolved.attribute {
INTERFACE_ENABLED => {
let mut reader = TlvReader::new_in(data, ContainerKind::Structure);
let value = reader
.next_element()
.ok()
.flatten()
.and_then(|element| element.bool().ok())
.ok_or(Status::InvalidDataType)?;
self.driver.set_interface_enabled(value)?;
self.enabled.set(value);
Ok(())
}
_ => Err(Status::UnsupportedWrite),
}
}
fn invoke(
&self,
resolved: &ResolvedCommand<'_>,
fields: Option<&[u8]>,
ctx: &InteractionContext<'_>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<Option<CommandId>, StatusIb> {
match resolved.command.id {
SCAN_NETWORKS => {
let request = ScanRequest::decode(fields)?;
let mut scratch = [0u8; SCAN_SCRATCH_BYTES];
self.scan(request.ssid, request.breadcrumb, ctx, &mut scratch, w, tag)?;
Ok(Some(SCAN_NETWORKS_RESPONSE))
}
ADD_OR_UPDATE_WIFI_NETWORK => {
let request = WiFiRequest::decode(fields)?;
self.add_or_update_wifi(
request.ssid,
request.credentials,
request.breadcrumb,
ctx,
w,
tag,
)?;
Ok(Some(NETWORK_CONFIG_RESPONSE))
}
ADD_OR_UPDATE_THREAD_NETWORK => {
let request = ThreadRequest::decode(fields)?;
self.add_or_update_thread(request.dataset, request.breadcrumb, ctx, w, tag)?;
Ok(Some(NETWORK_CONFIG_RESPONSE))
}
REMOVE_NETWORK => {
let request = NetworkIdRequest::decode(fields)?;
self.remove_network(request.id, request.breadcrumb, ctx, w, tag)?;
Ok(Some(NETWORK_CONFIG_RESPONSE))
}
CONNECT_NETWORK => {
let request = NetworkIdRequest::decode(fields)?;
self.connect_network(request.id, request.breadcrumb, ctx, w, tag)?;
Ok(Some(CONNECT_NETWORK_RESPONSE))
}
REORDER_NETWORK => {
let request = ReorderRequest::decode(fields)?;
self.reorder_network(request.id, request.index, request.breadcrumb, ctx, w, tag)?;
Ok(Some(NETWORK_CONFIG_RESPONSE))
}
_ => Err(Status::UnsupportedCommand.into()),
}
}
}
impl<D: NetworkDriver, const N: usize> Cluster for NetworkCommissioning<'_, D, N> {
const ID: ClusterId = ID;
}
fn walk_fields<'a>(
fields: Option<&'a [u8]>,
mut on_field: impl FnMut(u8, &crate::tlv::Element<'a>) -> Result<bool, Status>,
) -> Result<(), Status> {
let fields = fields.ok_or(Status::InvalidCommand)?;
let mut reader = TlvReader::new_in(fields, ContainerKind::Structure);
let element = reader
.next_element()
.map_err(|_| Status::InvalidCommand)?
.ok_or(Status::InvalidCommand)?;
if element.value.container() != Some(ContainerKind::Structure) {
return Err(Status::InvalidCommand);
}
let start_depth = reader.depth();
loop {
let Some(field) = reader.next_element().map_err(|_| Status::InvalidCommand)? else {
return Err(Status::InvalidCommand);
};
if reader.depth() < start_depth {
break;
}
let Tag::Context(number) = field.tag else {
reader
.skip_value(&field)
.map_err(|_| Status::InvalidCommand)?;
continue;
};
if !on_field(number, &field)? {
reader
.skip_value(&field)
.map_err(|_| Status::InvalidCommand)?;
}
}
Ok(())
}
struct ScanRequest<'a> {
ssid: Option<&'a [u8]>,
breadcrumb: Option<u64>,
}
impl<'a> ScanRequest<'a> {
fn decode(fields: Option<&'a [u8]>) -> Result<Self, Status> {
let mut ssid = None;
let mut breadcrumb = None;
walk_fields(fields, |number, element| {
match number {
0 => {
if !element.value.is_null() {
set_once(
&mut ssid,
element.octets().map_err(|_| Status::InvalidCommand)?,
)
.map_err(|_| Status::InvalidCommand)?;
}
}
1 => set_once(
&mut breadcrumb,
element.unsigned().map_err(|_| Status::InvalidCommand)?,
)
.map_err(|_| Status::InvalidCommand)?,
_ => return Ok(false),
}
Ok(true)
})?;
Ok(Self { ssid, breadcrumb })
}
}
struct WiFiRequest<'a> {
ssid: &'a [u8],
credentials: &'a [u8],
breadcrumb: Option<u64>,
}
impl<'a> WiFiRequest<'a> {
fn decode(fields: Option<&'a [u8]>) -> Result<Self, Status> {
let mut ssid = None;
let mut credentials = None;
let mut breadcrumb = None;
walk_fields(fields, |number, element| {
match number {
0 => set_once(
&mut ssid,
element.octets().map_err(|_| Status::InvalidCommand)?,
),
1 => set_once(
&mut credentials,
element.octets().map_err(|_| Status::InvalidCommand)?,
),
2 => set_once(
&mut breadcrumb,
element.unsigned().map_err(|_| Status::InvalidCommand)?,
),
_ => return Ok(false),
}
.map_err(|_| Status::InvalidCommand)?;
Ok(true)
})?;
let ssid = ssid.ok_or(Status::InvalidCommand)?;
let credentials = credentials.ok_or(Status::InvalidCommand)?;
if ssid.len() > NETWORK_ID_MAX || credentials.len() > CREDENTIALS_MAX {
return Err(Status::ConstraintError);
}
Ok(Self {
ssid,
credentials,
breadcrumb,
})
}
}
struct ThreadRequest<'a> {
dataset: &'a [u8],
breadcrumb: Option<u64>,
}
impl<'a> ThreadRequest<'a> {
fn decode(fields: Option<&'a [u8]>) -> Result<Self, Status> {
let mut dataset = None;
let mut breadcrumb = None;
walk_fields(fields, |number, element| {
match number {
0 => set_once(
&mut dataset,
element.octets().map_err(|_| Status::InvalidCommand)?,
),
1 => set_once(
&mut breadcrumb,
element.unsigned().map_err(|_| Status::InvalidCommand)?,
),
_ => return Ok(false),
}
.map_err(|_| Status::InvalidCommand)?;
Ok(true)
})?;
let dataset = dataset.ok_or(Status::InvalidCommand)?;
if dataset.len() > OPERATIONAL_DATASET_MAX {
return Err(Status::ConstraintError);
}
Ok(Self {
dataset,
breadcrumb,
})
}
}
struct NetworkIdRequest<'a> {
id: &'a [u8],
breadcrumb: Option<u64>,
}
impl<'a> NetworkIdRequest<'a> {
fn decode(fields: Option<&'a [u8]>) -> Result<Self, Status> {
let mut id = None;
let mut breadcrumb = None;
walk_fields(fields, |number, element| {
match number {
0 => set_once(
&mut id,
element.octets().map_err(|_| Status::InvalidCommand)?,
),
1 => set_once(
&mut breadcrumb,
element.unsigned().map_err(|_| Status::InvalidCommand)?,
),
_ => return Ok(false),
}
.map_err(|_| Status::InvalidCommand)?;
Ok(true)
})?;
Ok(Self {
id: id.ok_or(Status::InvalidCommand)?,
breadcrumb,
})
}
}
struct ReorderRequest<'a> {
id: &'a [u8],
index: u8,
breadcrumb: Option<u64>,
}
impl<'a> ReorderRequest<'a> {
fn decode(fields: Option<&'a [u8]>) -> Result<Self, Status> {
let mut id = None;
let mut index = None;
let mut breadcrumb = None;
walk_fields(fields, |number, element| {
match number {
0 => set_once(
&mut id,
element.octets().map_err(|_| Status::InvalidCommand)?,
),
1 => {
let value = element.unsigned().map_err(|_| Status::InvalidCommand)?;
set_once(
&mut index,
u8::try_from(value).map_err(|_| Status::ConstraintError)?,
)
}
2 => set_once(
&mut breadcrumb,
element.unsigned().map_err(|_| Status::InvalidCommand)?,
),
_ => return Ok(false),
}
.map_err(|_| Status::InvalidCommand)?;
Ok(true)
})?;
Ok(Self {
id: id.ok_or(Status::InvalidCommand)?,
index: index.ok_or(Status::InvalidCommand)?,
breadcrumb,
})
}
}