use crate::clusters::generated::ota_software_update_provider as spec_ota;
use crate::dm::spec::{Conforming, Optional};
use crate::dm::{Resolved, ResolvedCommand};
use crate::im::{ClusterHandler, ClusterId, CommandId, InteractionContext, Status, StatusIb};
use crate::msg::{NodeId, VendorId};
use crate::tlv::{Tag, TlvWriter, ToTlv};
use super::Cluster;
pub use spec_ota::command::{
APPLY_UPDATE_REQUEST, APPLY_UPDATE_RESPONSE, NOTIFY_UPDATE_APPLIED, QUERY_IMAGE,
QUERY_IMAGE_RESPONSE,
};
pub use spec_ota::{ApplyUpdateActionEnum, DownloadProtocolEnum, ID, PICS, REVISION, StatusEnum};
pub const TOKEN_MIN: usize = 8;
pub const TOKEN_MAX: usize = 32;
pub const URI_MAX: usize = 256;
pub const VERSION_STRING_MAX: usize = 64;
pub const MAX_USEFUL_DELAY_S: u32 = 86_400;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Query {
pub vendor_id: VendorId,
pub product_id: u16,
pub software_version: u32,
pub hardware_version: Option<u16>,
pub requestor_can_consent: bool,
pub supports_bdx: bool,
pub supports_https: bool,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Answer<'a> {
Available {
uri: &'a str,
software_version: u32,
software_version_string: &'a str,
update_token: &'a [u8],
user_consent_needed: bool,
},
Busy {
delay_s: u32,
},
NotAvailable,
ProtocolNotSupported,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ApplyDecision {
pub action: ApplyUpdateActionEnum,
pub delay_s: u32,
}
impl ApplyDecision {
#[must_use]
pub const fn proceed() -> Self {
Self {
action: ApplyUpdateActionEnum::Proceed,
delay_s: 0,
}
}
#[must_use]
pub const fn wait(delay_s: u32) -> Self {
Self {
action: ApplyUpdateActionEnum::AwaitNextAction,
delay_s,
}
}
#[must_use]
pub const fn discontinue() -> Self {
Self {
action: ApplyUpdateActionEnum::Discontinue,
delay_s: 0,
}
}
}
pub trait OtaProviderHooks {
fn query(&self, query: &Query) -> Answer<'_>;
fn apply(&self, update_token: &[u8], new_version: u32) -> ApplyDecision {
let _ = (update_token, new_version);
ApplyDecision::proceed()
}
fn applied(&self, update_token: &[u8], software_version: u32) {
let _ = (update_token, software_version);
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ImageUri<'a> {
pub node_id: NodeId,
pub file: &'a str,
}
impl<'a> ImageUri<'a> {
pub const MIN_LEN: usize = 24;
pub fn write<'b>(&self, buf: &'b mut [u8]) -> crate::error::Result<&'b str> {
let needed = 6usize
.saturating_add(16)
.saturating_add(1)
.saturating_add(self.file.len());
if needed > URI_MAX || needed > buf.len() {
return Err(crate::Error::new(crate::ErrorCode::BufferTooSmall));
}
let mut at = 0usize;
let mut put = |bytes: &[u8], at: &mut usize| {
for byte in bytes {
if let Some(slot) = buf.get_mut(*at) {
*slot = *byte;
}
*at = at.saturating_add(1);
}
};
put(b"bdx://", &mut at);
for shift in (0..16u32).rev().map(|nibble| nibble.saturating_mul(4)) {
let nibble = u8::try_from((self.node_id.0 >> shift) & 0xF).unwrap_or(0);
let digit = match nibble {
0..=9 => b'0'.saturating_add(nibble),
_ => b'A'.saturating_add(nibble.saturating_sub(10)),
};
put(&[digit], &mut at);
}
put(b"/", &mut at);
put(self.file.as_bytes(), &mut at);
let written = buf
.get(..at)
.ok_or_else(|| crate::Error::new(crate::ErrorCode::BufferTooSmall))?;
core::str::from_utf8(written)
.map_err(|_| crate::Error::new(crate::ErrorCode::InvalidArgument))
}
pub fn parse(uri: &'a str) -> crate::error::Result<Self> {
let invalid = || crate::Error::new(crate::ErrorCode::InvalidArgument);
if uri.len() < Self::MIN_LEN {
return Err(invalid());
}
let rest = uri.strip_prefix("bdx://").ok_or_else(invalid)?;
let (host, file) = rest.split_at_checked(16).ok_or_else(invalid)?;
let mut node = 0u64;
for byte in host.bytes() {
let nibble = match byte {
b'0'..=b'9' => byte.saturating_sub(b'0'),
b'A'..=b'F' => byte.saturating_sub(b'A').saturating_add(10),
_ => return Err(invalid()),
};
node = node
.checked_mul(16)
.and_then(|n| n.checked_add(u64::from(nibble)))
.ok_or_else(invalid)?;
}
let file = file.strip_prefix('/').ok_or_else(invalid)?;
if file.is_empty() || file.contains('?') || file.contains('#') {
return Err(invalid());
}
Ok(Self {
node_id: NodeId(node),
file,
})
}
}
#[derive(Debug)]
pub struct OtaProvider<'a, H: OtaProviderHooks> {
hooks: &'a H,
}
impl<'a, H: OtaProviderHooks> OtaProvider<'a, H> {
#[must_use]
pub const fn new(hooks: &'a H) -> Self {
Self { hooks }
}
pub fn conforming(
feature_map: u32,
optional: &Optional<'_>,
) -> crate::error::Result<Conforming<0, 3, 2, 0>> {
Conforming::new(&spec_ota::CLUSTER, feature_map, optional)
}
}
impl<H: OtaProviderHooks> ClusterHandler for OtaProvider<'_, H> {
fn read(
&self,
_resolved: &Resolved<'_>,
_ctx: &InteractionContext<'_>,
_w: &mut TlvWriter<'_>,
_tag: Tag,
) -> Result<(), Status> {
Err(Status::UnsupportedAttribute)
}
fn invoke(
&self,
resolved: &ResolvedCommand<'_>,
fields: Option<&[u8]>,
_ctx: &InteractionContext<'_>,
w: &mut TlvWriter<'_>,
tag: Tag,
) -> Result<Option<CommandId>, StatusIb> {
let payload = || fields.ok_or(StatusIb::from(Status::InvalidCommand));
let full = |r: crate::error::Result<()>| r.map_err(|_| StatusIb::from(Status::Failure));
match resolved.command.id {
QUERY_IMAGE => {
let decoded: spec_ota::QueryImageFields<'_> = super::decode_fields(payload()?)?;
let mut supports_bdx = false;
let mut supports_https = false;
for protocol in decoded.protocols_supported.iter() {
match protocol {
Ok(DownloadProtocolEnum::BDXSynchronous)
| Ok(DownloadProtocolEnum::BDXAsynchronous) => supports_bdx = true,
Ok(DownloadProtocolEnum::HTTPS) => supports_https = true,
_ => {}
}
}
let query = Query {
vendor_id: decoded.vendor_id,
product_id: decoded.product_id,
software_version: decoded.software_version,
hardware_version: decoded.hardware_version,
requestor_can_consent: decoded.requestor_can_consent.unwrap_or(false),
supports_bdx,
supports_https,
};
let answer = self.hooks.query(&query);
let response = Self::response(&answer, &query)?;
full(response.to_tlv(w, tag))?;
Ok(Some(QUERY_IMAGE_RESPONSE))
}
APPLY_UPDATE_REQUEST => {
let decoded: spec_ota::ApplyUpdateRequestFields<'_> =
super::decode_fields(payload()?)?;
if !(TOKEN_MIN..=TOKEN_MAX).contains(&decoded.update_token.len()) {
return Err(Status::ConstraintError.into());
}
let decision = self.hooks.apply(decoded.update_token, decoded.new_version);
full(
spec_ota::ApplyUpdateResponseFields {
action: decision.action,
delayed_action_time: decision.delay_s.min(MAX_USEFUL_DELAY_S),
}
.to_tlv(w, tag),
)?;
Ok(Some(APPLY_UPDATE_RESPONSE))
}
NOTIFY_UPDATE_APPLIED => {
let decoded: spec_ota::NotifyUpdateAppliedFields<'_> =
super::decode_fields(payload()?)?;
if !(TOKEN_MIN..=TOKEN_MAX).contains(&decoded.update_token.len()) {
return Err(Status::ConstraintError.into());
}
self.hooks
.applied(decoded.update_token, decoded.software_version);
Ok(None)
}
_ => Err(Status::UnsupportedCommand.into()),
}
}
}
impl<H: OtaProviderHooks> OtaProvider<'_, H> {
fn response<'r>(
answer: &Answer<'r>,
query: &Query,
) -> Result<spec_ota::QueryImageResponseFields<'r>, StatusIb> {
let empty = spec_ota::QueryImageResponseFields {
status: StatusEnum::NotAvailable,
delayed_action_time: None,
image_uri: None,
software_version: None,
software_version_string: None,
update_token: None,
user_consent_needed: None,
metadata_for_requestor: None,
};
Ok(match *answer {
Answer::NotAvailable => empty,
Answer::ProtocolNotSupported => spec_ota::QueryImageResponseFields {
status: StatusEnum::DownloadProtocolNotSupported,
..empty
},
Answer::Busy { delay_s } => spec_ota::QueryImageResponseFields {
status: StatusEnum::Busy,
delayed_action_time: Some(delay_s.min(MAX_USEFUL_DELAY_S)),
..empty
},
Answer::Available {
uri,
software_version,
software_version_string,
update_token,
user_consent_needed,
} => {
if uri.len() > URI_MAX
|| software_version_string.is_empty()
|| software_version_string.len() > VERSION_STRING_MAX
|| !(TOKEN_MIN..=TOKEN_MAX).contains(&update_token.len())
{
return Err(Status::Failure.into());
}
let consent = user_consent_needed && query.requestor_can_consent;
spec_ota::QueryImageResponseFields {
status: StatusEnum::UpdateAvailable,
delayed_action_time: None,
image_uri: Some(uri),
software_version: Some(software_version),
software_version_string: Some(software_version_string),
update_token: Some(update_token),
user_consent_needed: Some(consent),
metadata_for_requestor: None,
}
}
})
}
}
impl<H: OtaProviderHooks> Cluster for OtaProvider<'_, H> {
const ID: ClusterId = ID;
}