| // Copyright 2026 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| use std::sync::Arc; |
| |
| use futures::stream::{SelectAll, StreamExt}; |
| use parking_lot::Mutex; |
| use thiserror::Error; |
| |
| use bt_common::packet_encoding::Decodable; |
| use bt_common::Uuid; |
| use bt_gatt::client::{PeerService, ServiceCharacteristic}; |
| use bt_gatt::types::{CharacteristicProperty, Handle}; |
| |
| use crate::types::*; |
| |
| pub mod event; |
| |
| pub use event::{CsisNotification, NotificationStream}; |
| |
| #[derive(Debug, Error)] |
| pub enum Error { |
| #[error("GATT operation error: {0}")] |
| Gatt(#[from] bt_gatt::types::Error), |
| |
| #[error("Packet serialization/deserialization error: {0}")] |
| Packet(#[from] bt_common::packet_encoding::Error), |
| |
| #[error("Missing required characteristic: {0}")] |
| MissingCharacteristic(Uuid), |
| |
| #[error("Extra characteristic found: {0}")] |
| ExtraCharacteristic(Uuid), |
| |
| #[error("Invalid characteristic value: {0}")] |
| InvalidCharacteristic(String), |
| |
| #[error("Notification from unexpected characteristic handle: {0:?}")] |
| UnexpectedNotification(Handle), |
| } |
| |
| /// The values of the characteristics exposed by the CSIS service. |
| #[derive(Debug, Clone)] |
| pub(crate) struct CsisClientState { |
| sirk: SetIdentityResolvingKey, |
| size: Option<CoordinatedSetSize>, |
| rank: Option<SetMemberRank>, |
| lock_state: Option<SetMemberLock>, |
| } |
| |
| impl CsisClientState { |
| pub(crate) fn sirk(&self) -> SetIdentityResolvingKey { |
| self.sirk |
| } |
| |
| pub(crate) fn set_sirk(&mut self, sirk: SetIdentityResolvingKey) { |
| self.sirk = sirk; |
| } |
| |
| pub(crate) fn size(&self) -> Option<CoordinatedSetSize> { |
| self.size |
| } |
| |
| pub(crate) fn set_size(&mut self, size: CoordinatedSetSize) { |
| self.size = Some(size); |
| } |
| |
| pub(crate) fn rank(&self) -> Option<SetMemberRank> { |
| self.rank |
| } |
| |
| pub(crate) fn lock_state(&self) -> Option<SetMemberLock> { |
| self.lock_state |
| } |
| |
| pub(crate) fn set_lock_state(&mut self, lock_state: SetMemberLock) { |
| self.lock_state = Some(lock_state); |
| } |
| } |
| |
| /// A GATT client for interacting with the Coordinated Set Identification |
| /// Service (CSIS). See CSIS v1.1 Section 2 & Section 5 and CSIP v1.1 Section |
| /// 4.2 & Section 4.3. |
| pub struct CoordinatedSetIdentificationServiceClient<T: bt_gatt::GattTypes> { |
| // The connection to this CSIS service instance. Held to keep it, and the |
| // notification subscriptions registered through it, alive. |
| gatt_client: T::PeerService, |
| sirk_handle: Handle, |
| size_handle: Option<Handle>, |
| lock_handle: Option<Handle>, |
| /// Set Member Rank is not notifiable, so a change is only seen by |
| /// re-reading. |
| // TODO(b/534436497): implement re-reading. |
| _rank_handle: Option<Handle>, |
| |
| /// Shared with the [`NotificationStream`] so that a value updated by a |
| /// GATT notification is visible through this client's accessors. |
| state: Arc<Mutex<CsisClientState>>, |
| |
| /// Handles of the notifiable characteristics. Taken by |
| /// [`Self::take_notification_stream`]. |
| notifiable_handles: Option<Vec<Handle>>, |
| } |
| |
| impl<T: bt_gatt::GattTypes> CoordinatedSetIdentificationServiceClient<T> { |
| /// Discovers CSIS characteristics and reads their initial values. See CSIS |
| /// v1.1 Section 5, Table 5.1 and CSIP v1.1 Section 4.3. |
| /// |
| /// Does not register for notifications; call |
| /// [`Self::take_notification_stream`] to subscribe. |
| pub async fn create(gatt_client: T::PeerService) -> Result<Self, Error> { |
| let discovered = gatt_client.discover_characteristics(None).await?; |
| |
| let mut sirk = None; |
| let mut size = None; |
| let mut rank = None; |
| let mut lock = None; |
| |
| let mut notifiable_handles = Vec::new(); |
| |
| // The CSIS service exposes at most one of each characteristic. |
| for ch in discovered { |
| let chr = ServiceCharacteristic::new(&gatt_client, ch); |
| let uuid = chr.uuid(); |
| let handle = *chr.handle(); |
| |
| match uuid { |
| SET_IDENTITY_RESOLVING_KEY_UUID => { |
| if sirk.is_some() { |
| return Err(Error::ExtraCharacteristic(uuid)); |
| } |
| sirk = Some((handle, Self::read_sirk(&chr).await?)); |
| } |
| COORDINATED_SET_SIZE_UUID => { |
| if size.is_some() { |
| return Err(Error::ExtraCharacteristic(uuid)); |
| } |
| size = Some((handle, Self::read_size(&chr).await?)); |
| } |
| SET_MEMBER_LOCK_UUID => { |
| if lock.is_some() { |
| return Err(Error::ExtraCharacteristic(uuid)); |
| } |
| lock = Some((handle, Self::read_lock(&chr).await?)); |
| } |
| SET_MEMBER_RANK_UUID => { |
| if rank.is_some() { |
| return Err(Error::ExtraCharacteristic(uuid)); |
| } |
| rank = Some((handle, Self::read_rank(&chr).await?)); |
| } |
| _ => continue, |
| } |
| |
| if chr.characteristic().properties.contains(CharacteristicProperty::Notify) { |
| notifiable_handles.push(handle); |
| } |
| } |
| |
| let (sirk_handle, sirk) = |
| sirk.ok_or(Error::MissingCharacteristic(SET_IDENTITY_RESOLVING_KEY_UUID))?; |
| let (size_handle, size) = size.unzip(); |
| let (rank_handle, rank) = rank.unzip(); |
| let (lock_handle, lock_state) = lock.unzip(); |
| |
| if lock_handle.is_some() && rank_handle.is_none() { |
| // CSIS v1.1 Section 5, Table 5.1 Note C.1: Mandatory if Set Member Lock is |
| // supported |
| return Err(Error::MissingCharacteristic(SET_MEMBER_RANK_UUID)); |
| } |
| |
| if let (Some(r), Some(s)) = (rank, size) { |
| if r.0.get() > s.0.get() { |
| return Err(Error::InvalidCharacteristic( |
| "SetMemberRank cannot be greater than CoordinatedSetSize".to_string(), |
| )); |
| } |
| } |
| |
| Ok(Self { |
| gatt_client, |
| sirk_handle, |
| size_handle, |
| lock_handle, |
| _rank_handle: rank_handle, |
| state: Arc::new(Mutex::new(CsisClientState { sirk, size, rank, lock_state })), |
| notifiable_handles: Some(notifiable_handles), |
| }) |
| } |
| |
| // TODO(b/534436497): Implement FromCharacteristic for the CSIS value types |
| // in place of these readers. |
| async fn read_sirk( |
| chr: &ServiceCharacteristic<'_, T>, |
| ) -> Result<SetIdentityResolvingKey, Error> { |
| let mut buf = [0; SetIdentityResolvingKey::BYTE_SIZE]; |
| let bytes_read = chr.read(&mut buf).await?; |
| let (sirk_res, _) = SetIdentityResolvingKey::decode(&buf[..bytes_read]); |
| Ok(sirk_res?) |
| } |
| |
| async fn read_size(chr: &ServiceCharacteristic<'_, T>) -> Result<CoordinatedSetSize, Error> { |
| let mut buf = [0; CoordinatedSetSize::BYTE_SIZE]; |
| let bytes_read = chr.read(&mut buf).await?; |
| let (size_res, _) = CoordinatedSetSize::decode(&buf[..bytes_read]); |
| Ok(size_res?) |
| } |
| |
| async fn read_rank(chr: &ServiceCharacteristic<'_, T>) -> Result<SetMemberRank, Error> { |
| let mut buf = [0; SetMemberRank::BYTE_SIZE]; |
| let bytes_read = chr.read(&mut buf).await?; |
| let (rank_res, _) = SetMemberRank::decode(&buf[..bytes_read]); |
| Ok(rank_res?) |
| } |
| |
| async fn read_lock(chr: &ServiceCharacteristic<'_, T>) -> Result<SetMemberLock, Error> { |
| // CSIS v1.1 Table 5.1: Notify is mandatory for Set Member Lock. |
| if !chr.characteristic().properties.contains(CharacteristicProperty::Notify) { |
| return Err(Error::InvalidCharacteristic( |
| "Set Member Lock characteristic must support notifications".to_string(), |
| )); |
| } |
| |
| let mut buf = [0; SetMemberLock::BYTE_SIZE]; |
| let bytes_read = chr.read(&mut buf).await?; |
| let (lock_res, _) = SetMemberLock::decode(&buf[..bytes_read]); |
| Ok(lock_res?) |
| } |
| |
| pub fn sirk(&self) -> SetIdentityResolvingKey { |
| self.state.lock().sirk() |
| } |
| |
| /// The last known value of the Coordinated Set Size characteristic, or |
| /// `None` if the Set Member does not support it. |
| pub fn size(&self) -> Option<CoordinatedSetSize> { |
| self.state.lock().size() |
| } |
| |
| /// The last known value of the Set Member Rank characteristic, or `None` if |
| /// the Set Member does not support it. |
| pub fn rank(&self) -> Option<SetMemberRank> { |
| self.state.lock().rank() |
| } |
| |
| /// The last known value of the Set Member Lock characteristic, or `None` if |
| /// the Set Member does not support it. |
| pub fn lock_state(&self) -> Option<SetMemberLock> { |
| self.state.lock().lock_state() |
| } |
| |
| /// Subscribes to the CSIS characteristics that support being notified and |
| /// takes the stream of the value changes they report. |
| /// |
| /// The stream is only available once; subsequent calls return `None`. It |
| /// yields no events if the Set Member does not support notifications on |
| /// any CSIS characteristic. |
| pub fn take_notification_stream(&mut self) -> Option<NotificationStream> |
| where |
| <T as bt_gatt::GattTypes>::NotificationStream: Send, |
| { |
| let handles = self.notifiable_handles.take()?; |
| let mut notification_streams = SelectAll::new(); |
| for handle in handles { |
| notification_streams.push(self.gatt_client.subscribe(&handle).boxed()); |
| } |
| Some(NotificationStream::new( |
| notification_streams, |
| event::NotifiedHandles { |
| sirk: self.sirk_handle, |
| size: self.size_handle, |
| lock: self.lock_handle, |
| }, |
| self.state.clone(), |
| )) |
| } |
| |
| // TODO(b/534436497): Add lock() and unlock(). See CSIS v1.1 Section 5.3.1. |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| use super::*; |
| use assert_matches::assert_matches; |
| use bt_gatt::test_utils::*; |
| use bt_gatt::types::{AttributePermissions, CharacteristicProperty, Handle}; |
| use bt_gatt::Characteristic; |
| use core::num::NonZeroU8; |
| use futures::{ |
| pin_mut, |
| task::{noop_waker_ref, Context, Poll}, |
| FutureExt, |
| }; |
| |
| const SIRK_HANDLE: Handle = Handle(1); |
| const SIZE_HANDLE: Handle = Handle(2); |
| const LOCK_HANDLE: Handle = Handle(3); |
| const RANK_HANDLE: Handle = Handle(4); |
| |
| fn add_char(service: &mut FakePeerService, handle: Handle, uuid: Uuid, value: Vec<u8>) { |
| service.add_characteristic( |
| Characteristic { |
| handle, |
| uuid, |
| properties: CharacteristicProperty::Read.into(), |
| permissions: AttributePermissions::default(), |
| descriptors: vec![], |
| }, |
| value, |
| ); |
| } |
| |
| /// Adds a Set Member Lock characteristic with Read, Write and Notify |
| /// properties. |
| fn add_lock_char(service: &mut FakePeerService, handle: Handle, value: Vec<u8>) { |
| service.add_characteristic( |
| Characteristic { |
| handle, |
| uuid: SET_MEMBER_LOCK_UUID, |
| properties: (&[ |
| CharacteristicProperty::Read, |
| CharacteristicProperty::Write, |
| CharacteristicProperty::Notify, |
| ]) |
| .into(), |
| permissions: AttributePermissions::default(), |
| descriptors: vec![], |
| }, |
| value, |
| ); |
| } |
| |
| #[test] |
| fn create_success_all_chars() { |
| let mut service = FakePeerService::new(); |
| let mut noop_cx = Context::from_waker(noop_waker_ref()); |
| |
| // Valid SIRK: Type 1 (Plaintext) + 16 bytes key |
| let mut sirk_val = vec![0x01]; |
| sirk_val.extend_from_slice(&[0xAB; 16]); |
| add_char(&mut service, SIRK_HANDLE, SET_IDENTITY_RESOLVING_KEY_UUID, sirk_val); |
| |
| add_char(&mut service, SIZE_HANDLE, COORDINATED_SET_SIZE_UUID, vec![0x02]); |
| add_lock_char(&mut service, LOCK_HANDLE, vec![0x01]); // 0x01 = Unlocked per CSIS v1.1 Section 5.3, Table 5.4 |
| add_char(&mut service, RANK_HANDLE, SET_MEMBER_RANK_UUID, vec![0x01]); |
| |
| let create_fut = CoordinatedSetIdentificationServiceClient::<FakeTypes>::create(service); |
| pin_mut!(create_fut); |
| let Poll::Ready(client) = create_fut.poll_unpin(&mut noop_cx) else { |
| panic!("Expected create to be ready"); |
| }; |
| let client = client.unwrap(); |
| |
| assert_eq!(client.sirk_handle, SIRK_HANDLE); |
| assert_eq!(client.size_handle, Some(SIZE_HANDLE)); |
| assert_eq!(client.lock_handle, Some(LOCK_HANDLE)); |
| assert_eq!(client._rank_handle, Some(RANK_HANDLE)); |
| |
| assert_eq!(client.sirk().sirk_type, SirkType::Plaintext); |
| assert_eq!(client.size(), Some(CoordinatedSetSize(NonZeroU8::new(2).unwrap()))); |
| assert_eq!(client.rank(), Some(SetMemberRank(NonZeroU8::new(1).unwrap()))); |
| assert_eq!(client.lock_state(), Some(SetMemberLock::Unlocked)); |
| } |
| |
| #[test] |
| fn create_success_only_mandatory() { |
| let mut service = FakePeerService::new(); |
| let mut noop_cx = Context::from_waker(noop_waker_ref()); |
| |
| let mut sirk_val = vec![0x01]; |
| sirk_val.extend_from_slice(&[0xAB; 16]); |
| add_char(&mut service, SIRK_HANDLE, SET_IDENTITY_RESOLVING_KEY_UUID, sirk_val); |
| |
| let create_fut = CoordinatedSetIdentificationServiceClient::<FakeTypes>::create(service); |
| pin_mut!(create_fut); |
| let Poll::Ready(client) = create_fut.poll_unpin(&mut noop_cx) else { |
| panic!("Expected create to be ready"); |
| }; |
| let client = client.unwrap(); |
| |
| assert_eq!(client.sirk_handle, SIRK_HANDLE); |
| assert_eq!(client.size_handle, None); |
| assert_eq!(client.lock_handle, None); |
| assert_eq!(client._rank_handle, None); |
| assert_eq!(client.lock_state(), None); |
| } |
| |
| #[test] |
| fn create_success_rank_present_without_lock() { |
| let mut service = FakePeerService::new(); |
| let mut noop_cx = Context::from_waker(noop_waker_ref()); |
| |
| let mut sirk_val = vec![0x01]; |
| sirk_val.extend_from_slice(&[0xAB; 16]); |
| add_char(&mut service, SIRK_HANDLE, SET_IDENTITY_RESOLVING_KEY_UUID, sirk_val); |
| add_char(&mut service, RANK_HANDLE, SET_MEMBER_RANK_UUID, vec![0x01]); |
| |
| let create_fut = CoordinatedSetIdentificationServiceClient::<FakeTypes>::create(service); |
| pin_mut!(create_fut); |
| let Poll::Ready(client) = create_fut.poll_unpin(&mut noop_cx) else { |
| panic!("Expected create to be ready"); |
| }; |
| let client = client.unwrap(); |
| |
| assert_eq!(client.sirk_handle, SIRK_HANDLE); |
| assert_eq!(client.size_handle, None); |
| assert_eq!(client.lock_handle, None); |
| assert_eq!(client._rank_handle, Some(RANK_HANDLE)); |
| assert_eq!(client.rank().unwrap().0.get(), 1); |
| } |
| |
| #[test] |
| fn create_fails_missing_sirk() { |
| let service = FakePeerService::new(); |
| let mut noop_cx = Context::from_waker(noop_waker_ref()); |
| let create_fut = CoordinatedSetIdentificationServiceClient::<FakeTypes>::create(service); |
| pin_mut!(create_fut); |
| let Poll::Ready(result) = create_fut.poll_unpin(&mut noop_cx) else { |
| panic!("Expected create to be ready"); |
| }; |
| assert!(result.is_err()); |
| assert_matches!(result.err().unwrap(), Error::MissingCharacteristic(uuid) if uuid == SET_IDENTITY_RESOLVING_KEY_UUID); |
| } |
| |
| #[test] |
| fn create_fails_duplicate_sirk() { |
| let mut service = FakePeerService::new(); |
| let mut noop_cx = Context::from_waker(noop_waker_ref()); |
| |
| let mut sirk_val = vec![0x01]; |
| sirk_val.extend_from_slice(&[0xAB; 16]); |
| add_char(&mut service, SIRK_HANDLE, SET_IDENTITY_RESOLVING_KEY_UUID, sirk_val.clone()); |
| add_char(&mut service, Handle(5), SET_IDENTITY_RESOLVING_KEY_UUID, sirk_val); |
| |
| let create_fut = CoordinatedSetIdentificationServiceClient::<FakeTypes>::create(service); |
| pin_mut!(create_fut); |
| let Poll::Ready(result) = create_fut.poll_unpin(&mut noop_cx) else { |
| panic!("Expected create to be ready"); |
| }; |
| assert!(result.is_err()); |
| assert_matches!(result.err().unwrap(), Error::ExtraCharacteristic(uuid) if uuid == SET_IDENTITY_RESOLVING_KEY_UUID); |
| } |
| |
| #[test] |
| fn create_fails_lock_present_rank_missing() { |
| let mut service = FakePeerService::new(); |
| let mut noop_cx = Context::from_waker(noop_waker_ref()); |
| |
| let mut sirk_val = vec![0x01]; |
| sirk_val.extend_from_slice(&[0xAB; 16]); |
| add_char(&mut service, SIRK_HANDLE, SET_IDENTITY_RESOLVING_KEY_UUID, sirk_val); |
| |
| add_lock_char(&mut service, LOCK_HANDLE, vec![0x01]); |
| // Missing Rank |
| |
| let create_fut = CoordinatedSetIdentificationServiceClient::<FakeTypes>::create(service); |
| pin_mut!(create_fut); |
| let Poll::Ready(result) = create_fut.poll_unpin(&mut noop_cx) else { |
| panic!("Expected create to be ready"); |
| }; |
| assert!(result.is_err()); |
| assert_matches!(result.err().unwrap(), Error::MissingCharacteristic(uuid) if uuid == SET_MEMBER_RANK_UUID); |
| } |
| |
| #[test] |
| fn create_fails_invalid_size() { |
| let mut service = FakePeerService::new(); |
| let mut noop_cx = Context::from_waker(noop_waker_ref()); |
| |
| let mut sirk_val = vec![0x01]; |
| sirk_val.extend_from_slice(&[0xAB; 16]); |
| add_char(&mut service, SIRK_HANDLE, SET_IDENTITY_RESOLVING_KEY_UUID, sirk_val); |
| |
| add_char(&mut service, SIZE_HANDLE, COORDINATED_SET_SIZE_UUID, vec![0x00]); // Invalid Size 0 |
| |
| let create_fut = CoordinatedSetIdentificationServiceClient::<FakeTypes>::create(service); |
| pin_mut!(create_fut); |
| let Poll::Ready(result) = create_fut.poll_unpin(&mut noop_cx) else { |
| panic!("Expected create to be ready"); |
| }; |
| assert!(result.is_err()); |
| assert_matches!(result.err().unwrap(), Error::Packet(_)); |
| } |
| |
| #[test] |
| fn create_fails_invalid_rank_zero() { |
| let mut service = FakePeerService::new(); |
| let mut noop_cx = Context::from_waker(noop_waker_ref()); |
| |
| let mut sirk_val = vec![0x01]; |
| sirk_val.extend_from_slice(&[0xAB; 16]); |
| add_char(&mut service, SIRK_HANDLE, SET_IDENTITY_RESOLVING_KEY_UUID, sirk_val); |
| add_char(&mut service, RANK_HANDLE, SET_MEMBER_RANK_UUID, vec![0x00]); // Invalid Rank 0 |
| |
| let create_fut = CoordinatedSetIdentificationServiceClient::<FakeTypes>::create(service); |
| pin_mut!(create_fut); |
| let Poll::Ready(result) = create_fut.poll_unpin(&mut noop_cx) else { |
| panic!("Expected create to be ready"); |
| }; |
| assert!(result.is_err()); |
| assert_matches!(result.err().unwrap(), Error::Packet(_)); |
| } |
| |
| #[test] |
| fn create_fails_rank_greater_than_size() { |
| let mut service = FakePeerService::new(); |
| let mut noop_cx = Context::from_waker(noop_waker_ref()); |
| |
| let mut sirk_val = vec![0x01]; |
| sirk_val.extend_from_slice(&[0xAB; 16]); |
| add_char(&mut service, SIRK_HANDLE, SET_IDENTITY_RESOLVING_KEY_UUID, sirk_val); |
| add_char(&mut service, SIZE_HANDLE, COORDINATED_SET_SIZE_UUID, vec![0x02]); |
| add_char(&mut service, RANK_HANDLE, SET_MEMBER_RANK_UUID, vec![0x03]); // Rank 3 > Size 2 |
| |
| let create_fut = CoordinatedSetIdentificationServiceClient::<FakeTypes>::create(service); |
| pin_mut!(create_fut); |
| let Poll::Ready(result) = create_fut.poll_unpin(&mut noop_cx) else { |
| panic!("Expected create to be ready"); |
| }; |
| assert!(result.is_err()); |
| assert_matches!(result.err().unwrap(), Error::InvalidCharacteristic(_)); |
| } |
| |
| #[test] |
| fn create_fails_duplicate_size() { |
| let mut service = FakePeerService::new(); |
| let mut noop_cx = Context::from_waker(noop_waker_ref()); |
| |
| let mut sirk_val = vec![0x01]; |
| sirk_val.extend_from_slice(&[0xAB; 16]); |
| add_char(&mut service, SIRK_HANDLE, SET_IDENTITY_RESOLVING_KEY_UUID, sirk_val); |
| |
| add_char(&mut service, SIZE_HANDLE, COORDINATED_SET_SIZE_UUID, vec![0x02]); |
| add_char(&mut service, Handle(5), COORDINATED_SET_SIZE_UUID, vec![0x03]); // Duplicate |
| |
| let create_fut = CoordinatedSetIdentificationServiceClient::<FakeTypes>::create(service); |
| pin_mut!(create_fut); |
| let Poll::Ready(result) = create_fut.poll_unpin(&mut noop_cx) else { |
| panic!("Expected create to be ready"); |
| }; |
| assert!(result.is_err()); |
| assert_matches!(result.err().unwrap(), Error::ExtraCharacteristic(uuid) if uuid == COORDINATED_SET_SIZE_UUID); |
| } |
| |
| #[test] |
| fn create_fails_duplicate_lock() { |
| let mut service = FakePeerService::new(); |
| let mut noop_cx = Context::from_waker(noop_waker_ref()); |
| |
| let mut sirk_val = vec![0x01]; |
| sirk_val.extend_from_slice(&[0xAB; 16]); |
| add_char(&mut service, SIRK_HANDLE, SET_IDENTITY_RESOLVING_KEY_UUID, sirk_val); |
| |
| add_lock_char(&mut service, LOCK_HANDLE, vec![0x01]); |
| add_lock_char(&mut service, Handle(5), vec![0x01]); // Duplicate |
| add_char(&mut service, RANK_HANDLE, SET_MEMBER_RANK_UUID, vec![0x01]); // Rank is mandatory if lock present per CSIS v1.1 Table 5.1 Note C.1 |
| |
| let create_fut = CoordinatedSetIdentificationServiceClient::<FakeTypes>::create(service); |
| pin_mut!(create_fut); |
| let Poll::Ready(result) = create_fut.poll_unpin(&mut noop_cx) else { |
| panic!("Expected create to be ready"); |
| }; |
| assert!(result.is_err()); |
| assert_matches!(result.err().unwrap(), Error::ExtraCharacteristic(uuid) if uuid == SET_MEMBER_LOCK_UUID); |
| } |
| |
| #[test] |
| fn create_fails_lock_without_notify() { |
| let mut service = FakePeerService::new(); |
| let mut noop_cx = Context::from_waker(noop_waker_ref()); |
| |
| let mut sirk_val = vec![0x01]; |
| sirk_val.extend_from_slice(&[0xAB; 16]); |
| add_char(&mut service, SIRK_HANDLE, SET_IDENTITY_RESOLVING_KEY_UUID, sirk_val); |
| |
| // A Lock characteristic without the mandatory Notify property. |
| add_char(&mut service, LOCK_HANDLE, SET_MEMBER_LOCK_UUID, vec![0x01]); |
| add_char(&mut service, RANK_HANDLE, SET_MEMBER_RANK_UUID, vec![0x01]); |
| |
| let create_fut = CoordinatedSetIdentificationServiceClient::<FakeTypes>::create(service); |
| pin_mut!(create_fut); |
| let Poll::Ready(result) = create_fut.poll_unpin(&mut noop_cx) else { |
| panic!("Expected create to be ready"); |
| }; |
| assert_matches!(result.err().unwrap(), Error::InvalidCharacteristic(_)); |
| } |
| |
| #[test] |
| fn create_fails_duplicate_rank() { |
| let mut service = FakePeerService::new(); |
| let mut noop_cx = Context::from_waker(noop_waker_ref()); |
| |
| let mut sirk_val = vec![0x01]; |
| sirk_val.extend_from_slice(&[0xAB; 16]); |
| add_char(&mut service, SIRK_HANDLE, SET_IDENTITY_RESOLVING_KEY_UUID, sirk_val); |
| |
| add_char(&mut service, RANK_HANDLE, SET_MEMBER_RANK_UUID, vec![0x01]); |
| add_char(&mut service, Handle(5), SET_MEMBER_RANK_UUID, vec![0x02]); // Duplicate |
| |
| let create_fut = CoordinatedSetIdentificationServiceClient::<FakeTypes>::create(service); |
| pin_mut!(create_fut); |
| let Poll::Ready(result) = create_fut.poll_unpin(&mut noop_cx) else { |
| panic!("Expected create to be ready"); |
| }; |
| assert!(result.is_err()); |
| assert_matches!(result.err().unwrap(), Error::ExtraCharacteristic(uuid) if uuid == SET_MEMBER_RANK_UUID); |
| } |
| |
| #[test] |
| fn create_fails_sirk_invalid_length() { |
| let invalid_payloads = vec![ |
| vec![], // Empty (0 bytes) |
| vec![0x01; 5], // Too short (5 bytes < 17 bytes) |
| ]; |
| |
| for payload in invalid_payloads { |
| let mut service = FakePeerService::new(); |
| let mut noop_cx = Context::from_waker(noop_waker_ref()); |
| add_char(&mut service, SIRK_HANDLE, SET_IDENTITY_RESOLVING_KEY_UUID, payload); |
| |
| let create_fut = |
| CoordinatedSetIdentificationServiceClient::<FakeTypes>::create(service); |
| pin_mut!(create_fut); |
| let Poll::Ready(result) = create_fut.poll_unpin(&mut noop_cx) else { |
| panic!("Expected create to be ready"); |
| }; |
| assert!(result.is_err()); |
| assert_matches!( |
| result.err().unwrap(), |
| Error::Packet(bt_common::packet_encoding::Error::UnexpectedDataLength) |
| ); |
| } |
| } |
| |
| #[test] |
| fn create_fails_size_invalid_length() { |
| let mut service = FakePeerService::new(); |
| let mut noop_cx = Context::from_waker(noop_waker_ref()); |
| |
| let mut sirk_val = vec![0x01]; |
| sirk_val.extend_from_slice(&[0xAB; 16]); |
| add_char(&mut service, SIRK_HANDLE, SET_IDENTITY_RESOLVING_KEY_UUID, sirk_val); |
| add_char(&mut service, SIZE_HANDLE, COORDINATED_SET_SIZE_UUID, vec![]); // Empty (0 bytes) |
| |
| let create_fut = CoordinatedSetIdentificationServiceClient::<FakeTypes>::create(service); |
| pin_mut!(create_fut); |
| let Poll::Ready(result) = create_fut.poll_unpin(&mut noop_cx) else { |
| panic!("Expected create to be ready"); |
| }; |
| assert!(result.is_err()); |
| assert_matches!( |
| result.err().unwrap(), |
| Error::Packet(bt_common::packet_encoding::Error::UnexpectedDataLength) |
| ); |
| } |
| |
| #[test] |
| fn create_fails_rank_invalid_length() { |
| let mut service = FakePeerService::new(); |
| let mut noop_cx = Context::from_waker(noop_waker_ref()); |
| |
| let mut sirk_val = vec![0x01]; |
| sirk_val.extend_from_slice(&[0xAB; 16]); |
| add_char(&mut service, SIRK_HANDLE, SET_IDENTITY_RESOLVING_KEY_UUID, sirk_val); |
| add_char(&mut service, RANK_HANDLE, SET_MEMBER_RANK_UUID, vec![]); // Empty (0 bytes) |
| |
| let create_fut = CoordinatedSetIdentificationServiceClient::<FakeTypes>::create(service); |
| pin_mut!(create_fut); |
| let Poll::Ready(result) = create_fut.poll_unpin(&mut noop_cx) else { |
| panic!("Expected create to be ready"); |
| }; |
| assert!(result.is_err()); |
| assert_matches!( |
| result.err().unwrap(), |
| Error::Packet(bt_common::packet_encoding::Error::UnexpectedDataLength) |
| ); |
| } |
| } |
