#![no_std]
#![allow(unused)]
#[cfg(test)]
extern crate std;
use core::future::Future;
use core::future::poll_fn;
use core::pin::pin;
use core::sync::atomic::AtomicBool;
use core::sync::atomic::Ordering;
use core::task::Poll;
use embedded_hal_async::delay::DelayNs;
use spin::Mutex;
use thiserror::Error;
pub mod types;
const BDBC_MAX_SAME_NETWORK_RETRY_ATTEMPTS: u8 = 10;
const BDBC_MIN_COMMISSIONING_TIME: u8 = 0xb4;
const BDBC_REC_SAME_NETWORK_RETRY_ATTEMPTS: u8 = 3;
const BDBC_TC_LINK_KEY_EXCHANGE_TIMEOUT: u8 = 5;
const TC_LINK_KEY_EXCHANGE_ATTEMPTS_MAX: u8 = 3;
const LEGACY_STACK_REVISION: u8 = 20;
const TC_LINK_KEY_EXCHANGE_TIMEOUT_MS: u32 = BDBC_TC_LINK_KEY_EXCHANGE_TIMEOUT as u32 * 1_000;
use types::BdbCommissioningStatus;
use types::CommissioningMode;
use zigbee_core::Config;
use zigbee_core::LogicalType;
use zigbee_core::aps::aib;
use zigbee_core::aps::frame::command::Command;
use zigbee_core::aps::frame::command::RequestKey;
use zigbee_core::aps::frame::command::VerifyKey;
use zigbee_core::nwk::nib;
use zigbee_core::nwk::nib::CapabilityInformation;
use zigbee_core::nwk::nib::Nib;
use zigbee_core::nwk::nlme::NetworkError;
use zigbee_core::nwk::nlme::Nlme;
use zigbee_core::nwk::nlme::management::NlmeJoinConfirm;
use zigbee_core::nwk::nlme::management::NlmeJoinRequest;
use zigbee_core::nwk::nlme::management::NlmeJoinStatus;
use zigbee_core::nwk::nlme::management::NlmeNetworkFormationRequest;
use zigbee_core::nwk::nlme::management::NlmePermitJoiningRequest;
use zigbee_core::nwk::nlme::management::RejoinNetwork;
use zigbee_core::security::primitives::HmacAes128Mmo;
use zigbee_core::zdo::ZigbeeDevice;
use zigbee_core::zdo::descriptor::NodeDescRsp;
use zigbee_mac::mlme::MacConfig;
use zigbee_mac::mlme::Mlme;
use zigbee_types::ByteArray;
use zigbee_types::IeeeAddress;
use zigbee_types::ShortAddress;
use zigbee_types::sync::with_timeout;
pub struct BaseDeviceBehavior {
config: Config,
bdb_node_is_on_a_network: AtomicBool,
bdb_commissioning_mode: Mutex<CommissioningMode>,
bdb_commissioning_status: Mutex<BdbCommissioningStatus>,
tc_link_key_exchange_enabled: AtomicBool,
}
impl BaseDeviceBehavior {
pub fn new(config: Config) -> Self {
Self {
config,
bdb_node_is_on_a_network: AtomicBool::new(false),
bdb_commissioning_mode: Mutex::new(CommissioningMode::NetworkSteering),
bdb_commissioning_status: Mutex::new(BdbCommissioningStatus::Success),
tc_link_key_exchange_enabled: AtomicBool::new(true),
}
}
pub fn nib(&self) -> &'static Nib {
nib::get_ref()
}
pub fn commissioning_status(&self) -> BdbCommissioningStatus {
*self.bdb_commissioning_status.lock()
}
pub fn commissioning_mode(&self) -> CommissioningMode {
*self.bdb_commissioning_mode.lock()
}
pub fn node_is_on_a_network(&self) -> bool {
self.bdb_node_is_on_a_network.load(Ordering::Relaxed)
}
pub fn set_tc_link_key_exchange(&self, enabled: bool) {
self.tc_link_key_exchange_enabled
.store(enabled, Ordering::Relaxed);
}
fn set_commissioning_status(&self, status: BdbCommissioningStatus) {
*self.bdb_commissioning_status.lock() = status;
}
pub async fn start_initialization_procedure<M: Mlme>(
&self,
device: &ZigbeeDevice<M>,
delay: &mut impl DelayNs,
) -> Result<Option<NlmeJoinConfirm>, NetworkError> {
let nib = self.nib();
let on_a_network = *nib.network_address() != 0xffff;
self.bdb_node_is_on_a_network
.store(on_a_network, Ordering::Relaxed);
if !on_a_network {
return Ok(None);
}
if !self.is_end_device() {
return Ok(None);
}
log::debug!("[BDB] step 4: attempt NWK rejoin");
let extended_panid = *nib.extended_panid();
let confirm = device.rejoin(IeeeAddress(extended_panid), 0..0, 0).await?;
if confirm.status == NlmeJoinStatus::Success {
log::debug!("[BDB] step 5: rejoin succeeded");
self.set_commissioning_status(BdbCommissioningStatus::Success);
} else {
log::warn!("[BDB] step 5: rejoin failed ({:?})", confirm.status);
self.set_commissioning_status(BdbCommissioningStatus::NoNetwork);
}
Ok(Some(confirm))
}
pub async fn network_steering<M: Mlme>(
&self,
device: &ZigbeeDevice<M>,
delay: &mut impl DelayNs,
extended_pan_id: IeeeAddress,
channels: core::ops::Range<u8>,
scan_duration: u8,
capability_information: CapabilityInformation,
) -> Result<NlmeJoinConfirm, NetworkError> {
log::debug!(
"[BDB] start network steering, EPID={extended_pan_id:?}, channels={channels:?}"
);
self.set_commissioning_status(BdbCommissioningStatus::InProgress);
device.reset_trust_center_link_keys();
device
.nlme()
.network_discovery(channels, scan_duration)
.await?;
let request = NlmeJoinRequest {
extended_pan_id,
rejoin_network: RejoinNetwork::Association,
capability_information,
security_enabled: false,
scan_channels: 0..0,
scan_duration: 0,
};
let confirm = device.nlme().join(request).await;
if confirm.status != NlmeJoinStatus::Success {
self.set_commissioning_status(BdbCommissioningStatus::NoNetwork);
return Ok(confirm);
}
log::debug!("[BDB] step 9: poll for network key (transport-key)");
device.poll_transport_key().await?;
log::debug!("[BDB] step 9: network key installed");
let _ = device.nlme().negotiate_end_device_timeout().await;
log::debug!("[BDB] step 11: broadcast Device_annce");
device.announce_self().await?;
if self.tc_link_key_exchange_enabled.load(Ordering::Relaxed) {
log::debug!("[BDB] step 12: TC link key exchange");
if let Err(e) = self.tc_link_key_exchange(device, delay).await {
log::warn!("[BDB] step 12: TC link key exchange failed ({e:?}), leaving network");
self.set_commissioning_status(BdbCommissioningStatus::TclkExFailure);
self.bdb_node_is_on_a_network
.store(false, Ordering::Relaxed);
let status = device.leave_network(false).await;
log::info!("[BDB] left the network after TCLK failure: {status:?}");
return Err(e);
}
log::debug!("[BDB] step 12: TC link key exchange complete");
} else {
log::debug!("[BDB] step 12: TC link key exchange disabled, skipping");
}
self.bdb_node_is_on_a_network.store(true, Ordering::Relaxed);
self.set_commissioning_status(BdbCommissioningStatus::Success);
Ok(confirm)
}
async fn tc_link_key_exchange<M: Mlme>(
&self,
device: &ZigbeeDevice<M>,
delay: &mut impl DelayNs,
) -> Result<(), NetworkError> {
device.begin_tc_link_key_exchange();
let result = self.run_tc_link_key_exchange(device, delay).await;
device.end_tc_link_key_exchange();
result
}
async fn run_tc_link_key_exchange<M: Mlme>(
&self,
device: &ZigbeeDevice<M>,
delay: &mut impl DelayNs,
) -> Result<(), NetworkError> {
let tc_short = ShortAddress(0x0000);
let aib = aib::get_ref();
let tc_ieee = *aib.trust_center_address();
log::debug!("[BDB] start TC link key exchange, TC={tc_ieee:?}");
let Some(node_desc) = self
.request_trust_center_node_desc(device, delay, tc_short)
.await
else {
log::warn!("[BDB] TC link key exchange failed: no Node_Desc_rsp");
self.set_commissioning_status(BdbCommissioningStatus::TclkExFailure);
return Err(NetworkError::NoTransportKey);
};
if node_desc
.stack_revision()
.is_some_and(|revision| revision <= LEGACY_STACK_REVISION)
{
log::info!(
"[BDB] trust center reports stack revision {:?}, keeping the default TC link key",
node_desc.stack_revision()
);
return Ok(());
}
let mut attempts = 0u8;
loop {
device
.send_aps_command(
tc_short,
tc_ieee,
Command::RequestKey(RequestKey::TrustCenterLinkKey),
true,
)
.await?;
attempts += 1;
match with_timeout(
device.wait_tc_link_key_received(),
delay.delay_ms(TC_LINK_KEY_EXCHANGE_TIMEOUT_MS),
)
.await
{
Some(true) => {
log::debug!("[BDB] received new TC link key");
break;
}
Some(false) => {
log::warn!("[BDB] TC link key exchange failed: unusable TRANSPORT-KEY");
self.set_commissioning_status(BdbCommissioningStatus::TclkExFailure);
return Err(NetworkError::NoTransportKey);
}
None if attempts >= TC_LINK_KEY_EXCHANGE_ATTEMPTS_MAX => {
log::warn!("[BDB] TC link key exchange failed: no TRANSPORT-KEY");
self.set_commissioning_status(BdbCommissioningStatus::TclkExFailure);
return Err(NetworkError::NoTransportKey);
}
None => continue,
}
}
let new_key = aib
.device_key_pair_set()
.iter()
.find(|k| k.device_address == tc_ieee)
.map(|k| k.link_key)
.ok_or(NetworkError::NoTransportKey)?;
let hash = HmacAes128Mmo::hmac(new_key.as_slice(), &[0x03]).map_err(|_| {
NetworkError::SecurityError(zigbee_core::security::SecurityError::Unspecified)
})?;
let device_addr = *nib::get_ref().ieee_address();
let mut attempts = 0u8;
loop {
device
.send_aps_command(
tc_short,
tc_ieee,
Command::VerifyKey(VerifyKey {
key_type: 0x04,
source_address: device_addr,
hash: ByteArray(hash),
}),
false,
)
.await?;
attempts += 1;
match with_timeout(
device.wait_tc_link_key_verified(),
delay.delay_ms(TC_LINK_KEY_EXCHANGE_TIMEOUT_MS),
)
.await
{
Some(0x00) => {
log::debug!("[BDB] TC link key verified successfully");
return Ok(());
}
Some(status) if attempts < BDBC_MAX_SAME_NETWORK_RETRY_ATTEMPTS => {
log::warn!("[BDB] CONFIRM-KEY status {status:#04x}, retrying");
}
None if attempts < BDBC_MAX_SAME_NETWORK_RETRY_ATTEMPTS => continue,
_ => {
log::warn!("[BDB] TC link key exchange failed: no CONFIRM-KEY");
self.set_commissioning_status(BdbCommissioningStatus::TclkExFailure);
return Err(NetworkError::NoTransportKey);
}
}
}
}
async fn request_trust_center_node_desc<M: Mlme>(
&self,
device: &ZigbeeDevice<M>,
delay: &mut impl DelayNs,
tc_short: ShortAddress,
) -> Option<NodeDescRsp> {
for _ in 0..TC_LINK_KEY_EXCHANGE_ATTEMPTS_MAX {
if let Err(e) = device.node_desc_req(tc_short).await {
log::warn!("[BDB] Node_Desc_req to the trust center failed ({e:?})");
delay.delay_ms(TC_LINK_KEY_EXCHANGE_TIMEOUT_MS).await;
continue;
}
if let Some(response) = with_timeout(
device.wait_node_desc_rsp(),
delay.delay_ms(TC_LINK_KEY_EXCHANGE_TIMEOUT_MS),
)
.await
{
return Some(response);
}
}
None
}
fn is_end_device(&self) -> bool {
self.config.device_type == LogicalType::EndDevice
}
fn is_router(&self) -> bool {
self.config.device_type == LogicalType::Router
}
}
#[derive(Debug, Error)]
pub enum BdbError {
#[error("network error")]
NetworkError(#[from] NetworkError),
#[error("no open network discovered to join")]
NoNetwork,
}
#[cfg(test)]
mod tests {
use core::future::Future;
use core::sync::atomic::AtomicBool;
use core::sync::atomic::Ordering;
use zigbee_core::nwk::nib;
use zigbee_mac::Address;
use zigbee_mac::mlme::AssociationResponse;
use zigbee_mac::mlme::MacError;
use zigbee_mac::mlme::ScanResult;
use zigbee_mac::mlme::ScanType;
use super::*;
#[allow(clippy::panic)]
fn block_on<F: Future>(f: F) -> F::Output {
use core::pin::pin;
use core::task::Context;
use core::task::Poll;
use core::task::RawWaker;
use core::task::RawWakerVTable;
use core::task::Waker;
fn noop(_: *const ()) {}
fn clone(p: *const ()) -> RawWaker {
RawWaker::new(p, &VTABLE)
}
static VTABLE: RawWakerVTable = RawWakerVTable::new(clone, noop, noop, noop);
let waker = unsafe { Waker::from_raw(RawWaker::new(core::ptr::null(), &VTABLE)) };
let mut cx = Context::from_waker(&waker);
let mut f = pin!(f);
match f.as_mut().poll(&mut cx) {
Poll::Ready(val) => val,
Poll::Pending => panic!("block_on: future returned Pending"),
}
}
mockall::mock! {
Mlme {}
impl Mlme for Mlme {
fn ieee_address(&self) -> IeeeAddress;
async fn configure(&self, config: MacConfig);
async fn scan_network(
&self,
ty: ScanType,
channels: core::ops::Range<u8>,
duration: u8,
) -> Result<ScanResult, MacError>;
async fn associate(
&self,
channel: u8,
dest: Address,
capabilities: zigbee_mac::CapabilityInformation,
) -> Result<AssociationResponse, MacError>;
async fn poll_data(
&self,
coord_address: Address,
buf: &mut [u8],
) -> Result<(usize, u8), MacError>;
async fn receive(
&self,
buf: &mut [u8],
) -> Result<(usize, u8), MacError>;
async fn transmit_data(
&self,
dest: Address,
payload: &[u8],
) -> Result<(), MacError>;
fn random_u32(&self) -> u32;
}
}
struct NoopDelay;
impl DelayNs for NoopDelay {
async fn delay_ns(&mut self, _ns: u32) {}
}
fn make_device(device_type: LogicalType) -> ZigbeeDevice<MockMlme> {
let mut mac = MockMlme::new();
mac.expect_ieee_address()
.return_const(IeeeAddress(0xa4c1_0000_0000_0001));
mac.expect_random_u32().return_const(0u32);
let nlme = Nlme::new(mac);
let config = Config {
device_type,
..Config::default()
};
ZigbeeDevice::new(config, nlme)
}
#[test]
fn start_initialization_procedure_early_returns() {
nib::init();
zigbee_core::aps::aib::init();
let device = make_device(LogicalType::EndDevice);
let bdb = BaseDeviceBehavior::new(Config {
device_type: LogicalType::EndDevice,
..Config::default()
});
let result = block_on(bdb.start_initialization_procedure(&device, &mut NoopDelay));
assert!(matches!(result, Ok(None)));
assert!(!bdb.node_is_on_a_network());
nib::get_ref().update_network_address(|value| *value = 0x1234);
let router_device = make_device(LogicalType::Router);
let router_bdb = BaseDeviceBehavior::new(Config {
device_type: LogicalType::Router,
..Config::default()
});
let result =
block_on(router_bdb.start_initialization_procedure(&router_device, &mut NoopDelay));
assert!(matches!(result, Ok(None)));
assert!(router_bdb.node_is_on_a_network());
}
}