use crate::bytes::Cursor;
use crate::commissioning::OnboardingPayload;
use crate::error::{ErrorCode, Result, bail};
use crate::msg::VendorId;
pub const SERVICE_UUID: u16 = 0xFFF6;
pub const C1_UUID: [u8; 16] = [
0x18, 0xEE, 0x2E, 0xF5, 0x26, 0x3D, 0x45, 0x59, 0x95, 0x9F, 0x4F, 0x9C, 0x42, 0x9F, 0x9D, 0x11,
];
pub const C2_UUID: [u8; 16] = [
0x18, 0xEE, 0x2E, 0xF5, 0x26, 0x3D, 0x45, 0x59, 0x95, 0x9F, 0x4F, 0x9C, 0x42, 0x9F, 0x9D, 0x12,
];
pub const C3_UUID: [u8; 16] = [
0x64, 0x63, 0x02, 0x38, 0x87, 0x72, 0x45, 0xF2, 0xB8, 0x7D, 0x74, 0x8A, 0x83, 0x21, 0x8F, 0x04,
];
pub const CHARACTERISTIC_MAX: usize = 244;
pub const AD_TYPE_FLAGS: u8 = 0x01;
pub const AD_TYPE_SERVICE_DATA: u8 = 0x16;
pub const FLAGS_COMMISSIONABLE: u8 = 0x06;
pub const FLAGS_RECOVERY: u8 = 0x05;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(u8)]
pub enum OpCode {
Commissionable = 0x00,
NetworkRecovery = 0x01,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Advertisement {
Commissionable {
discriminator: u16,
vendor_id: VendorId,
product_id: u16,
additional_data: bool,
extended_announcement: bool,
},
NetworkRecovery {
recovery_id: u64,
additional_data: bool,
},
}
impl Advertisement {
pub const SERVICE_DATA_MAX: usize = 11;
pub const MAX: usize = 3 + 4 + Self::SERVICE_DATA_MAX;
#[must_use]
pub const fn for_onboarding(payload: &OnboardingPayload) -> Self {
Self::Commissionable {
discriminator: payload.discriminator,
vendor_id: payload.vendor_id,
product_id: payload.product_id,
additional_data: false,
extended_announcement: false,
}
}
#[must_use]
pub const fn elide_identity(self) -> Self {
match self {
Self::Commissionable {
discriminator,
additional_data,
extended_announcement,
..
} => Self::Commissionable {
discriminator,
vendor_id: VendorId(0),
product_id: 0,
additional_data,
extended_announcement,
},
other => other,
}
}
#[must_use]
pub const fn with_additional_data(self, present: bool) -> Self {
match self {
Self::Commissionable {
discriminator,
vendor_id,
product_id,
extended_announcement,
..
} => Self::Commissionable {
discriminator,
vendor_id,
product_id,
additional_data: present,
extended_announcement,
},
Self::NetworkRecovery { recovery_id, .. } => Self::NetworkRecovery {
recovery_id,
additional_data: present,
},
}
}
#[must_use]
pub const fn with_extended_announcement(self, extended: bool) -> Self {
match self {
Self::Commissionable {
discriminator,
vendor_id,
product_id,
additional_data,
..
} => Self::Commissionable {
discriminator,
vendor_id,
product_id,
additional_data,
extended_announcement: extended,
},
other => other,
}
}
#[must_use]
pub const fn opcode(&self) -> OpCode {
match self {
Self::Commissionable { .. } => OpCode::Commissionable,
Self::NetworkRecovery { .. } => OpCode::NetworkRecovery,
}
}
pub fn encode_service_data(&self, out: &mut [u8]) -> Result<usize> {
match *self {
Self::Commissionable {
discriminator,
vendor_id,
product_id,
additional_data,
extended_announcement,
} => {
if discriminator > 0x0FFF {
bail!(InvalidArgument)
}
if vendor_id.0 == 0 && product_id != 0 {
bail!(InvalidArgument)
}
let mut w = Cursor::writer(out);
w.u8(OpCode::Commissionable as u8)?;
w.u16(discriminator)?;
w.u16(vendor_id.0)?;
w.u16(product_id)?;
w.u8(u8::from(additional_data) | (u8::from(extended_announcement) << 1))?;
Ok(w.position())
}
Self::NetworkRecovery {
recovery_id,
additional_data,
} => {
let mut w = Cursor::writer(out);
w.u8(OpCode::NetworkRecovery as u8)?;
w.u8(0)?; w.u64(recovery_id)?;
w.u8(u8::from(additional_data))?;
Ok(w.position())
}
}
}
pub fn encode(&self, out: &mut [u8]) -> Result<usize> {
let flags = match self {
Self::Commissionable { .. } => FLAGS_COMMISSIONABLE,
Self::NetworkRecovery { .. } => FLAGS_RECOVERY,
};
let mut payload = [0u8; Self::SERVICE_DATA_MAX];
let n = self.encode_service_data(&mut payload)?;
let (Some(body), Ok(length)) = (payload.get(..n), u8::try_from(n.saturating_add(3))) else {
bail!(BufferTooSmall)
};
let mut w = Cursor::writer(out);
w.u8(2)?; w.u8(AD_TYPE_FLAGS)?;
w.u8(flags)?;
w.u8(length)?;
w.u8(AD_TYPE_SERVICE_DATA)?;
w.u16(SERVICE_UUID)?;
w.put(body)?;
Ok(w.position())
}
pub fn decode_service_data(buf: &[u8]) -> Result<Self> {
let mut r = Cursor::reader(buf, ErrorCode::BtpMalformed);
match r.read_u8()? {
0x00 => {
let versioned = r.read_u16()?;
if versioned >> 12 != 0 {
bail!(UnsupportedVersion)
}
let vendor_id = VendorId(r.read_u16()?);
let product_id = r.read_u16()?;
let flags = r.read_u8()?;
Ok(Self::Commissionable {
discriminator: versioned & 0x0FFF,
vendor_id,
product_id,
additional_data: flags & 0x01 != 0,
extended_announcement: flags & 0x02 != 0,
})
}
0x01 => {
if r.read_u8()? >> 4 != 0 {
bail!(UnsupportedVersion)
}
let recovery_id = r.read_u64()?;
Ok(Self::NetworkRecovery {
recovery_id,
additional_data: r.read_u8()? & 0x01 != 0,
})
}
_ => bail!(UnsupportedVersion),
}
}
pub fn decode(advertisement: &[u8]) -> Result<Self> {
let mut r = Cursor::reader(advertisement, ErrorCode::BtpMalformed);
while let Ok(length) = r.read_u8() {
if length == 0 {
break;
}
let mut structure =
Cursor::reader(r.take(usize::from(length))?, ErrorCode::BtpMalformed);
if structure.read_u8() == Ok(AD_TYPE_SERVICE_DATA)
&& structure.read_u16() == Ok(SERVICE_UUID)
{
return Self::decode_service_data(structure.rest());
}
}
bail!(TlvNotFound)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_commissionable_advertisement_matches_table_73() {
let advert = Advertisement::Commissionable {
discriminator: 0x3AB,
vendor_id: VendorId(0xFFF1),
product_id: 0x8000,
additional_data: true,
extended_announcement: false,
};
let mut buf = [0u8; Advertisement::MAX];
let n = advert.encode(&mut buf).expect("encode");
assert_eq!(
&buf[..n],
&[
0x02, 0x01, 0x06, 0x0B, 0x16, 0xF6, 0xFF, 0x00, 0xAB, 0x03, 0xF1, 0xFF, 0x00, 0x80, 0x01, ]
);
assert_eq!(Advertisement::decode(&buf[..n]).expect("decode"), advert);
}
#[test]
fn a_network_recovery_advertisement_matches_table_75() {
let advert = Advertisement::NetworkRecovery {
recovery_id: u64::from_le_bytes([0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88]),
additional_data: false,
};
let mut buf = [0u8; Advertisement::MAX];
let n = advert.encode(&mut buf).expect("encode");
assert_eq!(
&buf[..n],
&[
0x02, 0x01, 0x05, 0x0E, 0x16, 0xF6, 0xFF, 0x01, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x00,
]
);
assert_eq!(Advertisement::decode(&buf[..n]).expect("decode"), advert);
}
#[test]
fn the_service_data_is_found_wherever_it_sits() {
let advert = Advertisement::Commissionable {
discriminator: 0xFFF,
vendor_id: VendorId(0xFFF1),
product_id: 0x8001,
additional_data: false,
extended_announcement: true,
};
let mut service_data = [0u8; 16];
let n = advert
.encode_service_data(&mut service_data)
.expect("encode");
let mut payload = heapless::Vec::<u8, 64>::new();
payload
.extend_from_slice(&[0x05, 0x09, b'l', b'a', b'm', b'p'])
.expect("name");
payload
.extend_from_slice(&[0x04, 0x16, 0x0F, 0x18, 0x64])
.expect("battery");
payload
.extend_from_slice(&[u8::try_from(n + 3).expect("fits"), 0x16, 0xF6, 0xFF])
.expect("header");
payload
.extend_from_slice(&service_data[..n])
.expect("service data");
assert_eq!(Advertisement::decode(&payload).expect("decode"), advert);
}
#[test]
fn an_advertisement_with_no_matter_service_data_is_not_a_matter_device() {
let other = [0x05u8, 0x09, b'l', b'a', b'm', b'p'];
assert_eq!(
Advertisement::decode(&other).map_err(|e| e.code()),
Err(crate::ErrorCode::TlvNotFound)
);
}
#[test]
fn a_truncated_ad_structure_is_refused() {
let clipped = [0x0Bu8, 0x16, 0xF6, 0xFF, 0x00];
assert_eq!(
Advertisement::decode(&clipped).map_err(|e| e.code()),
Err(crate::ErrorCode::BtpMalformed)
);
}
#[test]
fn a_discriminator_wider_than_twelve_bits_is_refused() {
let bad = Advertisement::Commissionable {
discriminator: 0x1000,
vendor_id: VendorId(0xFFF1),
product_id: 0x8000,
additional_data: false,
extended_announcement: false,
};
let mut buf = [0u8; Advertisement::MAX];
assert_eq!(
bad.encode(&mut buf).map_err(|e| e.code()),
Err(crate::ErrorCode::InvalidArgument)
);
}
#[test]
fn a_product_id_without_a_vendor_id_is_refused() {
let bad = Advertisement::Commissionable {
discriminator: 0x3AB,
vendor_id: VendorId(0),
product_id: 0x8000,
additional_data: false,
extended_announcement: false,
};
let mut buf = [0u8; Advertisement::MAX];
assert_eq!(
bad.encode(&mut buf).map_err(|e| e.code()),
Err(crate::ErrorCode::InvalidArgument)
);
let elided = Advertisement::Commissionable {
discriminator: 0x3AB,
vendor_id: VendorId(0),
product_id: 0,
additional_data: false,
extended_announcement: false,
};
elided.encode(&mut buf).expect("eliding both is allowed");
}
#[test]
fn a_reserved_opcode_is_not_guessed_at() {
assert_eq!(
Advertisement::decode_service_data(&[0x02, 0, 0, 0, 0, 0, 0, 0]).map_err(|e| e.code()),
Err(crate::ErrorCode::UnsupportedVersion)
);
}
#[test]
fn the_advertisement_and_the_qr_code_agree_on_the_discriminator() {
use crate::commissioning::{CustomFlow, DiscoveryCapabilities, Passcode};
let payload = OnboardingPayload::new(
VendorId(0xFFF1),
0x8000,
0x3AB,
Passcode::new(20_202_021).expect("passcode"),
DiscoveryCapabilities::BLE,
CustomFlow::Standard,
)
.expect("payload");
let advert = Advertisement::for_onboarding(&payload);
let mut buf = [0u8; Advertisement::MAX];
let n = advert.encode(&mut buf).expect("encode");
let Advertisement::Commissionable {
discriminator,
vendor_id,
product_id,
..
} = Advertisement::decode(&buf[..n]).expect("decode")
else {
panic!("a commissionable advertisement")
};
assert_eq!(discriminator, payload.discriminator);
assert_eq!(vendor_id, payload.vendor_id);
assert_eq!(product_id, payload.product_id);
let private = advert.elide_identity().with_extended_announcement(true);
let n = private.encode(&mut buf).expect("encode");
assert_eq!(Advertisement::decode(&buf[..n]).expect("decode"), private);
let Advertisement::Commissionable {
discriminator,
vendor_id,
product_id,
extended_announcement,
..
} = private
else {
panic!("still commissionable")
};
assert_eq!(discriminator, 0x3AB, "the discriminator is what finds it");
assert_eq!((vendor_id, product_id), (VendorId(0), 0));
assert!(extended_announcement);
}
#[test]
fn the_characteristic_uuids_are_the_ones_in_table_34() {
assert_eq!(&C1_UUID[12..], &[0x42, 0x9F, 0x9D, 0x11]);
assert_eq!(&C2_UUID[12..], &[0x42, 0x9F, 0x9D, 0x12]);
assert_eq!(
C1_UUID[..12],
C2_UUID[..12],
"C1 and C2 differ in one nibble"
);
assert_eq!(C3_UUID[0], 0x64);
}
}