use core::sync::atomic::AtomicU8;
use core::sync::atomic::Ordering;
use config::Config;
use embedded_hal_async::delay::DelayNs;
use zigbee_mac::mlme::Mlme;
use zigbee_types::IeeeAddress;
use zigbee_types::ShortAddress;
pub mod config;
pub mod descriptor;
pub mod device_annce;
use zigbee_types::StorageVec;
use zigbee_types::sync::Event;
use zigbee_types::sync::Signal;
use crate::apl::descriptors::node_descriptor::LogicalType;
use crate::aps::aib;
use crate::aps::aib::DeviceKeyPairDescriptor;
use crate::aps::aib::KeyAttribute;
use crate::aps::aib::LinkKeyType;
use crate::aps::aib::MAX_APS_BINDING_TABLE;
use crate::aps::apsde::ApsdeSapConfirm;
use crate::aps::apsde::ApsdeSapConfirmStatus;
use crate::aps::apsde::ApsdeSapIndication;
use crate::aps::apsde::ApsdeSapRequest;
use crate::aps::apsme::Apsme;
use crate::aps::frame::CommandFrame;
use crate::aps::frame::Frame;
use crate::aps::frame::command::Command;
use crate::aps::frame::command::TransportKey;
use crate::aps::types::TxOptions;
use crate::nwk::frame::command::network_status::NetworkStatusCode;
use crate::nwk::nib;
use crate::nwk::nib::NWK_BROADCAST_ADDRESS_MIN;
use crate::nwk::nib::NetworkSecurityMaterialDescriptor;
use crate::nwk::nlme::KeepaliveMethod;
use crate::nwk::nlme::NetworkError;
use crate::nwk::nlme::Nlme;
use crate::nwk::nlme::management::NlmeJoinConfirm;
use crate::nwk::nlme::management::NlmeJoinRequest;
use crate::nwk::nlme::management::NlmeJoinStatus;
use crate::nwk::nlme::management::NlmeLeaveRequest;
use crate::nwk::nlme::management::NlmeLeaveStatus;
use crate::nwk::nlme::management::RejoinNetwork;
use crate::security::SecurityContext;
const TRANSPORT_KEY_POLL_RETRIES: u8 = 20;
pub struct ZigbeeDevice<M> {
config: Config,
nlme: Nlme<M>,
apsme: Apsme,
zdp_seq: AtomicU8,
joined: Event,
node_desc_rsp: Signal<descriptor::NodeDescRsp>,
rejoin_requested: Event,
}
const ZDP_PROFILE_ID: u16 = 0x0000;
const ZDO_ENDPOINT: u8 = 0x00;
const ZDP_RESPONSE_CLUSTER_FLAG: u16 = 0x8000;
const MAX_MATCHING_ENDPOINTS: usize = 16;
#[derive(Debug, Clone, Copy)]
pub struct ClusterRequest<'a> {
pub profile_id: u16,
pub cluster_id: u16,
pub src_endpoint: u8,
pub dst_endpoint: u8,
pub unicast: bool,
pub asdu: &'a [u8],
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ClusterReply {
pub cluster_id: u16,
pub profile_id: u16,
pub dst_endpoint: u8,
pub src_endpoint: u8,
pub len: usize,
}
impl ClusterReply {
pub const fn matching(request: &ClusterRequest<'_>, len: usize) -> Self {
Self {
cluster_id: request.cluster_id,
profile_id: request.profile_id,
dst_endpoint: request.src_endpoint,
src_endpoint: request.dst_endpoint,
len,
}
}
}
pub trait ClusterRequestHandler {
fn handle(&self, request: &ClusterRequest<'_>, out: &mut [u8]) -> Option<ClusterReply>;
}
impl<T: ClusterRequestHandler + ?Sized> ClusterRequestHandler for &T {
fn handle(&self, request: &ClusterRequest<'_>, out: &mut [u8]) -> Option<ClusterReply> {
(**self).handle(request, out)
}
}
impl<A: ClusterRequestHandler, B: ClusterRequestHandler> ClusterRequestHandler for (A, B) {
fn handle(&self, request: &ClusterRequest<'_>, out: &mut [u8]) -> Option<ClusterReply> {
self.0
.handle(request, out)
.or_else(|| self.1.handle(request, out))
}
}
impl<A, B, C> ClusterRequestHandler for (A, B, C)
where
A: ClusterRequestHandler,
B: ClusterRequestHandler,
C: ClusterRequestHandler,
{
fn handle(&self, request: &ClusterRequest<'_>, out: &mut [u8]) -> Option<ClusterReply> {
(&self.0, (&self.1, &self.2)).handle(request, out)
}
}
impl<A, B, C, D> ClusterRequestHandler for (A, B, C, D)
where
A: ClusterRequestHandler,
B: ClusterRequestHandler,
C: ClusterRequestHandler,
D: ClusterRequestHandler,
{
fn handle(&self, request: &ClusterRequest<'_>, out: &mut [u8]) -> Option<ClusterReply> {
(&self.0, (&self.1, &self.2, &self.3)).handle(request, out)
}
}
impl<A, B, C, D, E> ClusterRequestHandler for (A, B, C, D, E)
where
A: ClusterRequestHandler,
B: ClusterRequestHandler,
C: ClusterRequestHandler,
D: ClusterRequestHandler,
E: ClusterRequestHandler,
{
fn handle(&self, request: &ClusterRequest<'_>, out: &mut [u8]) -> Option<ClusterReply> {
(&self.0, (&self.1, &self.2, &self.3, &self.4)).handle(request, out)
}
}
const fn zdp_reply(cluster_id: u16, len: usize) -> ClusterReply {
ClusterReply {
cluster_id,
profile_id: ZDP_PROFILE_ID,
dst_endpoint: ZDO_ENDPOINT,
src_endpoint: ZDO_ENDPOINT,
len,
}
}
impl<M: Mlme> ZigbeeDevice<M> {
pub fn new(config: Config, nlme: Nlme<M>) -> Self {
let aps_counter_init = nlme.random_u8();
let zdp_seq_init = nlme.random_u8();
Self {
config,
nlme,
apsme: Apsme::new(aps_counter_init),
zdp_seq: AtomicU8::new(zdp_seq_init),
joined: Event::new(),
node_desc_rsp: Signal::new(),
rejoin_requested: Event::new(),
}
}
pub fn forget_network(&self) {
let nib = nib::get_ref();
nib.update_network_address(|value| *value = 0xffff);
nib.update_security_material_set(|set| set.clear());
self.reset_trust_center_link_keys();
}
pub fn reset_trust_center_link_keys(&self) {
let aib = aib::get_ref();
aib.update_device_key_pair_set(|set| set.clear());
aib.update_trust_center_address(|value| *value = IeeeAddress(0xffff_ffff_ffff_ffff));
}
pub fn nlme(&self) -> &Nlme<M> {
&self.nlme
}
fn next_zdp_seq(&self) -> u8 {
self.zdp_seq.fetch_add(1, Ordering::Relaxed).wrapping_add(1)
}
pub fn configure(&self, _config: Config) {}
pub fn is_connected(&self) -> bool {
false }
pub fn logical_type(&self) -> LogicalType {
self.config.device_type
}
pub fn send_keep_alive(&self) {}
pub async fn data_request(
&self,
request: ApsdeSapRequest<'_>,
delay: &mut impl DelayNs,
) -> ApsdeSapConfirm {
use crate::aps::types::Address;
use crate::aps::types::DstAddrMode;
let status = match (request.dst_addr_mode, request.dst_address) {
(DstAddrMode::Network, Address::Network(short)) => {
self.send_asdu(ShortAddress(short), &request, request.dst_endpoint, delay)
.await
}
(DstAddrMode::None, _) => self.send_to_bindings(&request, delay).await,
_ => ApsdeSapConfirmStatus::Unsupported,
};
ApsdeSapConfirm {
dst_addr_mode: request.dst_addr_mode,
dst_address: request.dst_address,
dst_endpoint: request.dst_endpoint,
src_endpoint: request.src_endpoint,
status,
tx_time: 0,
}
}
async fn send_asdu(
&self,
destination: ShortAddress,
request: &ApsdeSapRequest<'_>,
dst_endpoint: u8,
delay: &mut impl DelayNs,
) -> ApsdeSapConfirmStatus {
let result = if request.tx_options == TxOptions::Acknowledged {
self.apsme
.unicast_data_acked(
&self.nlme,
destination,
dst_endpoint,
request.cluster_id,
request.profile_id,
request.src_endpoint.value,
request.asdu,
delay,
)
.await
} else {
self.apsme
.unicast_data(
&self.nlme,
destination,
dst_endpoint,
request.cluster_id,
request.profile_id,
request.src_endpoint.value,
request.asdu,
)
.await
};
match result {
Ok(()) => ApsdeSapConfirmStatus::Success,
Err(NetworkError::FrameTooLong) => ApsdeSapConfirmStatus::AsduTooLong,
Err(NetworkError::SecurityError(_)) => ApsdeSapConfirmStatus::SecurityFail,
Err(NetworkError::NotJoined) => ApsdeSapConfirmStatus::NoShortAddress,
Err(e) => {
log::debug!("[ZDO] tx failed: {e:?}");
ApsdeSapConfirmStatus::NoAck
}
}
}
async fn send_to_bindings(
&self,
request: &ApsdeSapRequest<'_>,
delay: &mut impl DelayNs,
) -> ApsdeSapConfirmStatus {
let mut destinations: heapless::Vec<(ShortAddress, u8), MAX_APS_BINDING_TABLE> =
heapless::Vec::new();
let mut unresolved = false;
let mut group_binding = false;
for binding in aib::get_ref()
.binding_table()
.iter()
.filter(|b| b.matches(request.src_endpoint.value, request.cluster_id))
{
let (Some(ieee), Some(dst_endpoint)) = (binding.dst_ieee, binding.dst_endpoint) else {
group_binding = true;
continue;
};
match self.resolve_binding_address(ieee) {
Some(short) => {
let _ = destinations.push((short, dst_endpoint));
}
None => unresolved = true,
}
}
if destinations.is_empty() {
return match (group_binding, unresolved) {
(_, true) => ApsdeSapConfirmStatus::NoShortAddress,
(true, _) => ApsdeSapConfirmStatus::Unsupported,
_ => ApsdeSapConfirmStatus::NoBoundDevice,
};
}
let mut status = ApsdeSapConfirmStatus::Success;
for (destination, dst_endpoint) in destinations {
let result = self
.send_asdu(destination, request, dst_endpoint, delay)
.await;
if result != ApsdeSapConfirmStatus::Success && status == ApsdeSapConfirmStatus::Success
{
status = result;
}
}
status
}
fn resolve_binding_address(&self, ieee: IeeeAddress) -> Option<ShortAddress> {
if ieee == *aib::get_ref().trust_center_address() {
return Some(ShortAddress::COORDINATOR);
}
self.nlme.short_address_for_ieee(ieee)
}
pub fn start_device_discovery(&self) {
match self.config.device_discovery_type {
config::DiscoveryType::IEEE => todo!(),
config::DiscoveryType::NWK => todo!(),
}
}
pub fn start_service_discovery(&self) {}
pub async fn device_annce(&self, annce: device_annce::DeviceAnnce) -> Result<(), NetworkError> {
device_annce::broadcast(&self.nlme, &self.apsme, self.next_zdp_seq(), annce).await
}
pub async fn announce_self(&self) -> Result<(), NetworkError> {
let nib = nib::get_ref();
let annce = device_annce::DeviceAnnce {
nwk_addr: ShortAddress(*nib.network_address()),
ieee_addr: *nib.ieee_address(),
capability: *nib.capability_information(),
};
self.device_annce(annce).await
}
pub async fn rejoin(
&self,
extended_pan_id: IeeeAddress,
channels: core::ops::Range<u8>,
scan_duration: u8,
) -> Result<NlmeJoinConfirm, NetworkError> {
let capability_information = *nib::get_ref().capability_information();
let request = |security_enabled| NlmeJoinRequest {
extended_pan_id,
rejoin_network: RejoinNetwork::NwkRejoin,
capability_information,
security_enabled,
scan_channels: channels.clone(),
scan_duration,
};
log::debug!("[ZDO] secure rejoin, EPID={extended_pan_id:?}");
let confirm = self.nlme.join(request(true)).await;
if confirm.status == NlmeJoinStatus::Success {
self.finish_rejoin().await?;
return Ok(confirm);
}
log::warn!(
"[ZDO] secure rejoin failed ({:?}), falling back to trust center rejoin",
confirm.status
);
let confirm = self.nlme.join(request(false)).await;
if confirm.status != NlmeJoinStatus::Success {
log::warn!("[ZDO] trust center rejoin failed ({:?})", confirm.status);
return Ok(confirm);
}
self.poll_transport_key().await?;
self.finish_rejoin().await?;
Ok(confirm)
}
async fn finish_rejoin(&self) -> Result<(), NetworkError> {
self.mark_rejoined();
log::debug!("[ZDO] rejoined, negotiating end-device timeout");
let _ = self.nlme.negotiate_end_device_timeout().await;
log::debug!("[ZDO] announcing self");
let result = self.announce_self().await;
log::debug!("[ZDO] rejoin complete: {result:?}");
result
}
pub async fn poll_transport_key(&self) -> Result<(), NetworkError> {
let mut buf = [0u8; 128];
let mut nwk_data = self
.nlme
.poll_nwk_data(&mut buf, TRANSPORT_KEY_POLL_RETRIES)
.await?;
let aps_buf = unsafe { nwk_data.payload_as_mut() };
let cx = SecurityContext::get();
let aps_frame = cx.decrypt_aps_frame_in_place(aps_buf)?;
let Frame::ApsCommand(CommandFrame {
command: Command::TransportKey(transport_key),
..
}) = aps_frame
else {
return Err(NetworkError::NoTransportKey);
};
match transport_key {
TransportKey::StandardNetworkKey(nwk_key) => {
log::debug!("[ZDO] received network key {:02x?}", nwk_key.key);
let aib = aib::get_ref();
aib.update_trust_center_address(|value| *value = nwk_key.source_address);
aib.update_device_key_pair_set(|key_set| {
if !key_set
.iter()
.any(|k| k.device_address == nwk_key.source_address)
{
let _ = key_set.push(DeviceKeyPairDescriptor {
device_address: nwk_key.source_address,
key_attributes: KeyAttribute::ProvisionalKey,
link_key: zigbee_types::ByteArray(
crate::security::TRUST_CENTER_LINK_KEY,
),
outgoing_frame_counter: 0,
incoming_frame_counter: 0,
link_key_type: LinkKeyType::GlobalLinkKey,
});
}
});
let nib = nib::get_ref();
nib.update_security_material_set(|sec_material| {
sec_material.clear();
let _ = sec_material.push(NetworkSecurityMaterialDescriptor {
key_seq_number: nwk_key.sequence_number,
outgoing_frame_counter: 0,
incoming_frame_counter_set: StorageVec::new(),
key: nwk_key.key,
network_key_type: 0x01,
});
});
nib.update_active_key_seq_number(|value| *value = nwk_key.sequence_number);
self.mark_joined(true);
}
TransportKey::ApplicationLinkKey(_)
| TransportKey::TrustCenterLinkKey(_)
| TransportKey::Reserved(_) => return Err(NetworkError::NoTransportKey),
}
Ok(())
}
pub async fn send_aps_command(
&self,
destination: ShortAddress,
dest_ieee: IeeeAddress,
command: Command,
aps_secure: bool,
) -> Result<(), NetworkError> {
self.apsme
.send_command(&self.nlme, destination, dest_ieee, command, aps_secure)
.await
}
pub async fn wait_until_joined(&self) {
self.joined.wait_set().await;
}
fn mark_joined(&self, joined: bool) {
if joined {
self.joined.signal();
} else {
self.joined.reset();
}
self.apsme.set_joined(joined);
}
fn close_gate_on_leave_indication(&self) {
let Some(indication) = self.nlme.take_leave_indication() else {
return;
};
if indication.device_address.is_some() {
return;
}
log::info!(
"[ZDO] removed from the network (rejoin={})",
indication.rejoin
);
self.mark_joined(false);
if indication.rejoin {
self.rejoin_requested.signal();
}
}
pub fn take_rejoin_request(&self) -> bool {
if !self.rejoin_requested.is_set() {
return false;
}
self.rejoin_requested.reset();
true
}
pub async fn wait_rejoin_request(&self) {
self.rejoin_requested.wait().await;
}
pub fn mark_rejoined(&self) {
self.mark_joined(true);
}
pub fn begin_tc_link_key_exchange(&self) {
self.apsme.begin_tc_key_exchange();
}
pub fn end_tc_link_key_exchange(&self) {
self.apsme.end_tc_key_exchange();
}
pub async fn wait_tc_link_key_received(&self) -> bool {
self.apsme.tc_key_received.wait().await
}
pub async fn node_desc_req(&self, destination: ShortAddress) -> Result<(), NetworkError> {
self.node_desc_rsp.reset();
let mut asdu = [0u8; 3];
let len = descriptor::node_desc_req(self.next_zdp_seq(), destination.0, &mut asdu)?;
self.apsme
.unicast_data(
&self.nlme,
destination,
ZDO_ENDPOINT,
descriptor::NODE_DESC_REQ,
ZDP_PROFILE_ID,
ZDO_ENDPOINT,
&asdu[..len],
)
.await
}
pub async fn wait_node_desc_rsp(&self) -> descriptor::NodeDescRsp {
self.node_desc_rsp.wait().await
}
pub async fn leave_network(&self, rejoin: bool) -> NlmeLeaveStatus {
let confirm = self
.nlme
.leave(NlmeLeaveRequest {
device_address: None,
remove_children: false,
rejoin,
})
.await;
self.mark_joined(false);
self.reset_trust_center_link_keys();
confirm.status
}
pub async fn wait_tc_link_key_verified(&self) -> u8 {
self.apsme.tc_key_verified.wait().await
}
pub async fn poll_and_dispatch(
&self,
cfg: &descriptor::DeviceDescriptorConfig<'_>,
handler: &impl ClusterRequestHandler,
) -> Result<(), NetworkError> {
let mut rx = [0u8; 256];
let indication = match self.apsme.poll_aps_frame(&self.nlme, &mut rx).await {
Ok(indication) => indication,
Err(e @ (NetworkError::ParseError | NetworkError::SecurityError(_))) => {
log::debug!("[ZDO] dropped undecodable frame on poll: {e:?}");
return Ok(());
}
Err(e) => return Err(e),
};
self.dispatch(indication, cfg, handler).await
}
pub async fn receive_and_dispatch(
&self,
cfg: &descriptor::DeviceDescriptorConfig<'_>,
handler: &impl ClusterRequestHandler,
) -> Result<(), NetworkError> {
let mut rx = [0u8; 256];
let indication = match self.apsme.receive_aps_frame(&self.nlme, &mut rx).await {
Ok(indication) => indication,
Err(e @ (NetworkError::ParseError | NetworkError::SecurityError(_))) => {
log::debug!("[ZDO] dropped undecodable frame on receive: {e:?}");
return Ok(());
}
Err(e) => return Err(e),
};
self.dispatch(indication, cfg, handler).await
}
async fn dispatch(
&self,
indication: Option<ApsdeSapIndication<'_>>,
cfg: &descriptor::DeviceDescriptorConfig<'_>,
handler: &impl ClusterRequestHandler,
) -> Result<(), NetworkError> {
use crate::aps::types::Address;
let mut out = [0u8; 128];
self.close_gate_on_leave_indication();
let Some(indication) = indication else {
return Ok(());
};
let Address::Network(src) = indication.src_address else {
return Ok(());
};
let profile = indication.profile_id;
let cluster = indication.cluster_id;
let src_endpoint = indication.src_endpoint.value;
let dst_endpoint = indication.dst_endpoint;
log::debug!(
"[ZDO] rx profile={profile:#06x} cluster={cluster:#06x} from {src:#06x} ep {src_endpoint}->{dst_endpoint}"
);
let mut leave_after_reply = None;
let nwk_dst = match indication.dst_address {
Address::Network(dst) => dst,
_ => *self.nlme.nib().network_address(),
};
let response = if profile == ZDP_PROFILE_ID && cluster == descriptor::MGMT_LEAVE_REQ {
self.build_mgmt_leave_rsp(indication.asdu, ShortAddress(nwk_dst), &mut out)
.map(|(len, request)| {
leave_after_reply = request;
zdp_reply(descriptor::MGMT_LEAVE_RSP, len)
})
} else if profile == ZDP_PROFILE_ID && cluster == descriptor::NODE_DESC_RSP {
if let Some(response) = descriptor::parse_node_desc_rsp(indication.asdu) {
self.node_desc_rsp.signal(response);
}
None
} else if profile == ZDP_PROFILE_ID {
self.build_zdp_response(cluster, indication.asdu, nwk_dst, cfg, &mut out)
.map(|(rsp_cluster, len)| zdp_reply(rsp_cluster, len))
} else {
let request = ClusterRequest {
profile_id: profile,
cluster_id: cluster,
src_endpoint,
dst_endpoint,
unicast: nwk_dst < NWK_BROADCAST_ADDRESS_MIN,
asdu: indication.asdu,
};
handler.handle(&request, &mut out)
};
if let Some(reply) = response {
log::debug!(
"[ZDO] tx response cluster={:#06x} ({} bytes) to {src:#06x}",
reply.cluster_id,
reply.len
);
self.apsme
.unicast_data(
&self.nlme,
ShortAddress(src),
reply.dst_endpoint,
reply.cluster_id,
reply.profile_id,
reply.src_endpoint,
&out[..reply.len],
)
.await?;
} else {
log::trace!("[ZDO] no response for cluster {cluster:#06x}");
}
if let Some(request) = leave_after_reply {
let confirm = self.nlme.leave(request).await;
log::info!(
"[ZDO] leaving network after Mgmt_Leave_req: {:?}",
confirm.status
);
self.mark_joined(false);
}
Ok(())
}
fn build_match_desc_rsp(
&self,
asdu: &[u8],
nwk_dst: u16,
nwk_addr: u16,
cfg: &descriptor::DeviceDescriptorConfig<'_>,
out: &mut [u8],
) -> Option<(u16, usize)> {
let request = descriptor::parse_match_desc_req(asdu)?;
let broadcast = nwk_dst >= NWK_BROADCAST_ADDRESS_MIN;
let about_us = request.nwk_addr_of_interest == nwk_addr
|| request.nwk_addr_of_interest >= NWK_BROADCAST_ADDRESS_MIN;
if !about_us {
if broadcast && cfg.node.logical_type == LogicalType::EndDevice {
return None;
}
let error = Self::discovery_error(cfg);
return Some((
descriptor::MATCH_DESC_RSP,
descriptor::match_desc_rsp_error(request.seq, error, out).ok()?,
));
}
let mut matches = [0u8; MAX_MATCHING_ENDPOINTS];
let count = cfg.matching_endpoints(&request, &mut matches);
if count == 0 && broadcast {
return None;
}
Some((
descriptor::MATCH_DESC_RSP,
descriptor::match_desc_rsp(request.seq, nwk_addr, &matches[..count], out).ok()?,
))
}
fn build_mgmt_leave_rsp(
&self,
asdu: &[u8],
destination: ShortAddress,
out: &mut [u8],
) -> Option<(usize, Option<NlmeLeaveRequest>)> {
let request = descriptor::parse_mgmt_leave_req(asdu)?;
let own_ieee = *self.nlme.nib().ieee_address();
let is_self = request.device_address.is_none_or(|addr| addr == own_ieee);
let (status, leave) = if !is_self {
(NlmeLeaveStatus::UnknownDevice, None)
} else if !self.nlme.accepts_leave_request(destination, true) {
(NlmeLeaveStatus::NotAuthorized, None)
} else {
(
NlmeLeaveStatus::Success,
Some(NlmeLeaveRequest {
device_address: None,
remove_children: request.remove_children,
rejoin: request.rejoin,
}),
)
};
let len =
descriptor::mgmt_leave_rsp(request.seq, descriptor::leave_status(status), out).ok()?;
Some((len, leave))
}
fn apply_bind_req(
&self,
asdu: &[u8],
cfg: &descriptor::DeviceDescriptorConfig<'_>,
bind: bool,
) -> descriptor::BindStatus {
use crate::aps::apsme::ApsmeSap;
use crate::aps::apsme::basemgt::ApsmeBindRequest;
use crate::aps::apsme::basemgt::ApsmeBindRequestStatus;
use crate::aps::apsme::basemgt::ApsmeUnbindRequest;
use crate::aps::apsme::basemgt::ApsmeUnbindRequestStatus;
use crate::aps::binding::BindingAddrMode;
use crate::aps::types::Address;
use crate::aps::types::SrcEndpoint;
use crate::zdo::descriptor::BindReqDestination;
use crate::zdo::descriptor::BindStatus;
let Some(request) = descriptor::parse_bind_req(asdu) else {
return BindStatus::NotSupported;
};
if request.src_address != *self.nlme.nib().ieee_address() {
return BindStatus::NotSupported;
}
let Ok(src_endpoint) = SrcEndpoint::new(request.src_endpoint) else {
return BindStatus::InvalidEndpoint;
};
if !cfg.supports_endpoint(request.src_endpoint) {
return BindStatus::InvalidEndpoint;
}
let (dst_addr_mode, dst_address, dst_endpoint) = match request.destination {
BindReqDestination::Device { ieee, endpoint } => {
(BindingAddrMode::Device, Address::Extended(ieee.0), endpoint)
}
BindReqDestination::Group(group) => (BindingAddrMode::Group, Address::Group(group), 0),
};
let bind_request = ApsmeBindRequest {
src_address: Address::Extended(request.src_address.0),
src_endpoint,
cluster_id: request.cluster_id,
dst_addr_mode,
dst_address,
dst_endpoint,
};
if bind {
return match self.apsme.bind_request(bind_request).status {
ApsmeBindRequestStatus::Success => BindStatus::Success,
ApsmeBindRequestStatus::TableFull => BindStatus::TableFull,
_ => BindStatus::NotSupported,
};
}
let unbind_request = ApsmeUnbindRequest {
src_address: bind_request.src_address,
src_endpoint: bind_request.src_endpoint,
cluster_id: bind_request.cluster_id,
dst_addr_mode: bind_request.dst_addr_mode,
dst_address: bind_request.dst_address,
dst_endpoint: bind_request.dst_endpoint,
};
match self.apsme.unbind_request(unbind_request).status {
ApsmeUnbindRequestStatus::Success => BindStatus::Success,
ApsmeUnbindRequestStatus::InvalidBinding => BindStatus::NoEntry,
ApsmeUnbindRequestStatus::IllegalRequest => BindStatus::NotSupported,
}
}
fn discovery_error(cfg: &descriptor::DeviceDescriptorConfig<'_>) -> descriptor::DiscoveryError {
if cfg.node.logical_type == LogicalType::EndDevice {
descriptor::DiscoveryError::InvalidRequestType
} else {
descriptor::DiscoveryError::DeviceNotFound
}
}
fn build_addr_rsp(
&self,
cluster: u16,
asdu: &[u8],
nwk_dst: u16,
cfg: &descriptor::DeviceDescriptorConfig<'_>,
out: &mut [u8],
) -> Option<(u16, usize)> {
let nwk_addr = *self.nlme.nib().network_address();
let ieee_addr = *self.nlme.nib().ieee_address();
let (rsp_cluster, seq, request_type, about_us, asked_ieee, asked_nwk) =
if cluster == descriptor::NWK_ADDR_REQ {
let request = descriptor::parse_nwk_addr_req(asdu)?;
(
descriptor::NWK_ADDR_RSP,
request.seq,
request.request_type,
request.ieee_addr == ieee_addr,
request.ieee_addr,
ShortAddress::default().0,
)
} else {
let request = descriptor::parse_ieee_addr_req(asdu)?;
(
descriptor::IEEE_ADDR_RSP,
request.seq,
request.request_type,
request.nwk_addr_of_interest == nwk_addr,
IeeeAddress(u64::MAX),
request.nwk_addr_of_interest,
)
};
if !about_us {
if nwk_dst >= NWK_BROADCAST_ADDRESS_MIN {
return None;
}
let error = Self::discovery_error(cfg);
let len = descriptor::addr_rsp_error(seq, error, asked_ieee, asked_nwk, out).ok()?;
return Some((rsp_cluster, len));
}
let extended = match request_type {
descriptor::ADDR_REQUEST_SINGLE => false,
descriptor::ADDR_REQUEST_EXTENDED => true,
_ => {
let len = descriptor::addr_rsp_error(
seq,
descriptor::DiscoveryError::InvalidRequestType,
ieee_addr,
nwk_addr,
out,
)
.ok()?;
return Some((rsp_cluster, len));
}
};
let len = descriptor::addr_rsp(seq, ieee_addr, nwk_addr, extended, out).ok()?;
Some((rsp_cluster, len))
}
fn build_zdp_response(
&self,
cluster: u16,
asdu: &[u8],
nwk_dst: u16,
cfg: &descriptor::DeviceDescriptorConfig<'_>,
out: &mut [u8],
) -> Option<(u16, usize)> {
let seq = *asdu.first()?;
let nwk_addr = *self.nlme.nib().network_address();
let descriptor_request = matches!(
cluster,
descriptor::NODE_DESC_REQ
| descriptor::POWER_DESC_REQ
| descriptor::ACTIVE_EP_REQ
| descriptor::SIMPLE_DESC_REQ
);
if descriptor_request {
let addr_of_interest = descriptor::parse_addr_of_interest(asdu)?;
if addr_of_interest != nwk_addr {
if nwk_dst >= NWK_BROADCAST_ADDRESS_MIN {
return None;
}
let error = Self::discovery_error(cfg);
let rsp_cluster = cluster | ZDP_RESPONSE_CLUSTER_FLAG;
let len = match cluster {
descriptor::SIMPLE_DESC_REQ => {
descriptor::simple_desc_rsp_error(seq, error, addr_of_interest, out).ok()?
}
descriptor::ACTIVE_EP_REQ => {
descriptor::active_ep_rsp_error(seq, error, addr_of_interest, out).ok()?
}
_ => {
descriptor::descriptor_rsp_error(seq, error, addr_of_interest, out).ok()?
}
};
return Some((rsp_cluster, len));
}
}
let result = match cluster {
descriptor::NODE_DESC_REQ => (
descriptor::NODE_DESC_RSP,
cfg.node_desc_rsp(seq, nwk_addr, out).ok()?,
),
descriptor::POWER_DESC_REQ => (
descriptor::POWER_DESC_RSP,
cfg.power_desc_rsp(seq, nwk_addr, out).ok()?,
),
descriptor::MATCH_DESC_REQ => {
return self.build_match_desc_rsp(asdu, nwk_dst, nwk_addr, cfg, out);
}
descriptor::ACTIVE_EP_REQ => (
descriptor::ACTIVE_EP_RSP,
cfg.active_ep_rsp(seq, nwk_addr, out).ok()?,
),
descriptor::SIMPLE_DESC_REQ => {
let endpoint = *asdu.get(3)?;
(
descriptor::SIMPLE_DESC_RSP,
cfg.simple_desc_rsp(seq, nwk_addr, endpoint, out).ok()?,
)
}
descriptor::IEEE_ADDR_REQ | descriptor::NWK_ADDR_REQ => {
return self.build_addr_rsp(cluster, asdu, nwk_dst, cfg, out);
}
descriptor::BIND_REQ => (
descriptor::BIND_RSP,
descriptor::bind_rsp(seq, self.apply_bind_req(asdu, cfg, true), out).ok()?,
),
descriptor::UNBIND_REQ => (
descriptor::UNBIND_RSP,
descriptor::bind_rsp(seq, self.apply_bind_req(asdu, cfg, false), out).ok()?,
),
_ => return None,
};
Some(result)
}
}
#[cfg(test)]
mod tests {
use zigbee_mac::Address;
use zigbee_mac::mlme::AssociationResponse;
use zigbee_mac::mlme::MacConfig;
use zigbee_mac::mlme::MacError;
use zigbee_mac::mlme::ScanResult;
use zigbee_mac::mlme::ScanType;
use super::*;
use crate::TEST_MUTEX;
use crate::apl::descriptors::node_power_descriptor::CurrentPowerMode;
use crate::apl::descriptors::node_power_descriptor::CurrentPowerSourceLevel;
use crate::apl::descriptors::node_power_descriptor::PowerSource;
use crate::zdo::descriptor::DeviceDescriptorConfig;
use crate::zdo::descriptor::EndpointDescriptor;
use crate::zdo::descriptor::NodeDescriptorConfig;
use crate::zdo::descriptor::PowerDescriptorConfig;
const OUR_NWK_ADDR: u16 = 0x1234;
const OTHER_NWK_ADDR: u16 = 0x9999;
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;
}
}
const NODE: NodeDescriptorConfig = NodeDescriptorConfig {
logical_type: LogicalType::EndDevice,
complex_descriptor_available: false,
user_descriptor_available: false,
frequency_band: 0x08,
mac_capability_flags: 0x88,
manufacturer_code: 0x1037,
maximum_buffer_size: 80,
maximum_incoming_transfer_size: 128,
server_mask: 0,
maximum_outgoing_transfer_size: 128,
descriptor_capability_field: 0,
};
const POWER: PowerDescriptorConfig = PowerDescriptorConfig {
current_power_mode: CurrentPowerMode::Synchronized,
available_power_sources: &[PowerSource::ConstantMainPower],
current_power_source: PowerSource::ConstantMainPower,
current_power_source_level: CurrentPowerSourceLevel::Full,
};
const ENDPOINTS: [EndpointDescriptor; 1] = [EndpointDescriptor {
endpoint: 1,
profile_id: 0x0104,
device_id: 0x0302,
device_version: 1,
input_clusters: &[0x0000, 0x0402],
output_clusters: &[0x0019],
}];
fn cfg(logical_type: LogicalType) -> DeviceDescriptorConfig<'static> {
DeviceDescriptorConfig {
node: NodeDescriptorConfig {
logical_type,
..NODE
},
power: POWER,
endpoints: &ENDPOINTS,
}
}
fn make_device(logical_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: logical_type,
..Config::default()
};
ZigbeeDevice::new(config, nlme)
}
fn descriptor_req(seq: u8, addr_of_interest: u16) -> [u8; 3] {
let [lo, hi] = addr_of_interest.to_le_bytes();
[seq, lo, hi]
}
#[test]
fn discovery_error_responses_carry_their_count_fields() {
let _guard = TEST_MUTEX
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
nib::try_init();
nib::reset();
aib::try_init();
let mut out = [0u8; 32];
let router = make_device(LogicalType::Router);
nib::get_ref().update_network_address(|value| *value = OUR_NWK_ADDR);
let (cluster, len) = router
.build_zdp_response(
descriptor::NODE_DESC_REQ,
&descriptor_req(0x07, OTHER_NWK_ADDR),
OUR_NWK_ADDR,
&cfg(LogicalType::Router),
&mut out,
)
.expect("a unicast Node_Desc_req naming another device is answered");
assert_eq!(cluster, descriptor::NODE_DESC_RSP);
assert_eq!(&out[..len], &[0x07, 0x81, 0x99, 0x99]);
let (cluster, len) = router
.build_zdp_response(
descriptor::POWER_DESC_REQ,
&descriptor_req(0x08, OTHER_NWK_ADDR),
OUR_NWK_ADDR,
&cfg(LogicalType::Router),
&mut out,
)
.expect("a unicast Power_Desc_req naming another device is answered");
assert_eq!(cluster, descriptor::POWER_DESC_RSP);
assert_eq!(&out[..len], &[0x08, 0x81, 0x99, 0x99]);
let (cluster, len) = router
.build_zdp_response(
descriptor::SIMPLE_DESC_REQ,
&descriptor_req(0x09, OTHER_NWK_ADDR),
OUR_NWK_ADDR,
&cfg(LogicalType::Router),
&mut out,
)
.expect("a unicast Simple_Desc_req naming another device is answered");
assert_eq!(cluster, descriptor::SIMPLE_DESC_RSP);
assert_eq!(&out[..len], &[0x09, 0x81, 0x99, 0x99, 0x00]);
let (cluster, len) = router
.build_zdp_response(
descriptor::ACTIVE_EP_REQ,
&descriptor_req(0x0a, OTHER_NWK_ADDR),
OUR_NWK_ADDR,
&cfg(LogicalType::Router),
&mut out,
)
.expect("a unicast Active_EP_req naming another device is answered");
assert_eq!(cluster, descriptor::ACTIVE_EP_RSP);
assert_eq!(
&out[..len],
&[0x0a, 0x81, 0x99, 0x99, 0x00],
"Active_EP_rsp must carry ActiveEPCount = 0 (2.4.4.2.6); a four-byte \
response is short by that field and reads as malformed"
);
}
#[test]
fn active_ep_rsp_invalid_request_type_carries_the_count() {
let _guard = TEST_MUTEX
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
nib::try_init();
nib::reset();
aib::try_init();
let mut out = [0u8; 32];
let end_device = make_device(LogicalType::EndDevice);
nib::get_ref().update_network_address(|value| *value = OUR_NWK_ADDR);
let (cluster, len) = end_device
.build_zdp_response(
descriptor::ACTIVE_EP_REQ,
&descriptor_req(0x0b, OTHER_NWK_ADDR),
OUR_NWK_ADDR,
&cfg(LogicalType::EndDevice),
&mut out,
)
.expect("a unicast Active_EP_req naming another device is answered");
assert_eq!(cluster, descriptor::ACTIVE_EP_RSP);
assert_eq!(
&out[..len],
&[0x0b, 0x80, 0x99, 0x99, 0x00],
"Active_EP_rsp must carry ActiveEPCount = 0 (2.4.4.2.6)"
);
}
}