Project import generated by Copybara.
GitOrigin-RevId: 5028dd6db990e351e6ce4b988267b60f3ac785d7
Change-Id: I981c26f33d52d775acde707d87df1c10a602e26f
diff --git a/nearby/Cargo.lock b/nearby/Cargo.lock
index 7441c1b..657ac34 100644
--- a/nearby/Cargo.lock
+++ b/nearby/Cargo.lock
@@ -279,6 +279,7 @@
"globset",
"log",
"owo-colors",
+ "regex",
"semver",
"serde_json",
"shell-escape",
@@ -1022,7 +1023,6 @@
version = "0.1.0"
dependencies = [
"criterion",
- "crypto_provider",
"lazy_static",
"lock_adapter",
]
@@ -1338,9 +1338,9 @@
[[package]]
name = "memchr"
-version = "2.5.0"
+version = "2.6.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+checksum = "f665ee40bc4a3c5590afb1e9677db74a508659dfd71e126420da8274909a0167"
[[package]]
name = "memoffset"
@@ -1861,9 +1861,9 @@
[[package]]
name = "regex"
-version = "1.9.1"
+version = "1.10.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2eae68fc220f7cf2532e4494aded17545fce192d59cd996e0fe7887f4ceb575"
+checksum = "380b951a9c5e80ddfd6136919eef32310721aa4aacd4889a8d39124b026ab343"
dependencies = [
"aho-corasick",
"memchr",
@@ -1873,9 +1873,9 @@
[[package]]
name = "regex-automata"
-version = "0.3.4"
+version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7b6d6190b7594385f61bd3911cd1be99dfddcfc365a4160cc2ab5bff4aed294"
+checksum = "5f804c7828047e88b2d32e2d7fe5a105da8ee3264f01902f796c8e067dc2483f"
dependencies = [
"aho-corasick",
"memchr",
@@ -1884,9 +1884,9 @@
[[package]]
name = "regex-syntax"
-version = "0.7.4"
+version = "0.8.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5ea92a5b6195c6ef2a0295ea818b312502c6fc94dde986c5553242e18fd4ce2"
+checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
[[package]]
name = "reword"
diff --git a/nearby/Cargo.toml b/nearby/Cargo.toml
index 1416e24..df92f64 100644
--- a/nearby/Cargo.toml
+++ b/nearby/Cargo.toml
@@ -171,6 +171,7 @@
which = "4.4.0"
file-header = "0.1.2"
serde_json.workspace = true
+regex = "1.10.2"
[dev-dependencies]
tempfile.workspace = true
diff --git a/nearby/presence/np_adv/Cargo.toml b/nearby/presence/np_adv/Cargo.toml
index 5123737..97e12f5 100644
--- a/nearby/presence/np_adv/Cargo.toml
+++ b/nearby/presence/np_adv/Cargo.toml
@@ -14,7 +14,7 @@
crypto_provider.workspace = true
strum.workspace = true
strum_macros.workspace = true
-nom = { version = "7.1.3", default-features = false, features = ["alloc"] }
+nom = { version = "7.1.3", default-features = false }
lazy_static.workspace = true
sink.workspace = true
tinyvec.workspace = true
diff --git a/nearby/presence/np_adv/src/array_vec.rs b/nearby/presence/np_adv/src/array_vec.rs
new file mode 100644
index 0000000..a92ff5b
--- /dev/null
+++ b/nearby/presence/np_adv/src/array_vec.rs
@@ -0,0 +1,203 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Provides an [`ArrayVecOption`] wrapper implementation over [`ArrayVec`],
+//! which stores all the elements in an `Option` in order to satisfy
+//! `ArrayVec`'s requirement that the elements must implement `Default`.
+
+use tinyvec::{ArrayVec, ArrayVecIterator};
+#[cfg(any(test, feature = "alloc"))]
+extern crate alloc;
+#[cfg(any(test, feature = "alloc"))]
+use alloc::vec::Vec;
+
+/// A wrapper of [`ArrayVec`] that stores it values as [`Option`], in order to
+/// satisfy `ArrayVec`'s requirement that the elements must implement `Default`.
+/// The implementation guarantees that any items in the wrapped `ArrayVec`
+/// within `0..len` is `Some`, and therefore will not panic when unwrapped.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ArrayVecOption<A, const N: usize>(ArrayVec<[Option<A>; N]>);
+
+// Cannot derive due to https://github.com/rust-lang/rust/issues/74462
+impl<A, const N: usize> Default for ArrayVecOption<A, N> {
+ fn default() -> Self {
+ Self(Default::default())
+ }
+}
+
+/// Iterator type returned by `ArrayVecOption.iter()`, which can be used as
+/// `impl Iterator<Item = &A>`
+pub type ArrayVecOptionRefIter<'a, A> =
+ core::iter::Map<core::slice::Iter<'a, Option<A>>, fn(&'a Option<A>) -> &'a A>;
+
+/// Iterator type returned by `ArrayVecOption.into_iter()`, which can be used as
+/// `impl Iterator<Item = A>`
+pub type ArrayVecOptionIntoIter<A, const N: usize> =
+ core::iter::Map<ArrayVecIterator<[Option<A>; N]>, fn(Option<A>) -> A>;
+
+impl<A, const N: usize> ArrayVecOption<A, N> {
+ /// Returns an iterator over this vec.
+ pub fn iter(&self) -> ArrayVecOptionRefIter<A> {
+ self.0
+ .iter()
+ .map(|v| v.as_ref().expect("ArrayVecOption value before .len() should not be None"))
+ }
+
+ /// The length of the vec (in elements).
+ pub fn len(&self) -> usize {
+ self.0.len()
+ }
+
+ /// Checks if the length is 0.
+ pub fn is_empty(&self) -> bool {
+ self.0.is_empty()
+ }
+
+ /// Returns the first element of the vec, or `None` if it is empty.
+ pub fn first(&self) -> Option<&A> {
+ self.iter().next()
+ }
+
+ /// Place an element onto the end of the vec.
+ ///
+ /// # Panics
+ /// * If the length of the vec would overflow the capacity.
+ pub fn push(&mut self, value: A) {
+ self.0.push(Some(value))
+ }
+
+ /// Returns a reference to an element at the given index.
+ pub fn get(&self, index: usize) -> Option<&A> {
+ self.0.get(index).and_then(|opt| opt.as_ref())
+ }
+
+ /// Sorts the slice with a key extraction function, but might not preserve
+ /// the order of equal elements.
+ ///
+ /// This sort is unstable (i.e., may reorder equal elements), in-place
+ /// (i.e., does not allocate), and *O*(*m* \* *n* \* log(*n*)) worst-case,
+ /// where the key function is *O*(*m*).
+ pub fn sort_unstable_by_key<K: Ord>(&mut self, f: impl Fn(&A) -> K) {
+ self.0.sort_unstable_by_key(|a| f(a.as_ref().unwrap()))
+ }
+
+ /// Remove an element, swapping the end of the vec into its place.
+ pub fn swap_remove(&mut self, index: usize) -> A {
+ self.0.swap_remove(index).unwrap()
+ }
+
+ /// Converts this vector into a regular `Vec`, unwrapping all of the
+ /// `Option` in the process.
+ #[cfg(any(test, feature = "alloc"))]
+ pub fn into_vec(self) -> Vec<A> {
+ self.into_iter().collect()
+ }
+}
+
+impl<A, const N: usize> IntoIterator for ArrayVecOption<A, N> {
+ type Item = A;
+ type IntoIter = ArrayVecOptionIntoIter<A, N>;
+ fn into_iter(self) -> Self::IntoIter {
+ self.0
+ .into_iter()
+ .map(|v| v.expect("ArrayVecOption value before .len() should not be None"))
+ }
+}
+
+// Implement `FromIterator` to enable `iter.collect::<ArrayVecOption<_>>()`
+impl<A, const N: usize> FromIterator<A> for ArrayVecOption<A, N> {
+ fn from_iter<T: IntoIterator<Item = A>>(iter: T) -> Self {
+ Self(iter.into_iter().map(Some).collect())
+ }
+}
+
+impl<A, const N: usize> core::ops::Index<usize> for ArrayVecOption<A, N> {
+ type Output = A;
+ fn index(&self, index: usize) -> &Self::Output {
+ self.0[index].as_ref().unwrap()
+ }
+}
+
+#[cfg(test)]
+mod test {
+ extern crate std;
+ use super::ArrayVecOption;
+ use std::vec;
+
+ #[test]
+ fn test_default_array_vec() {
+ let vec = ArrayVecOption::<u32, 5>::default();
+ assert_eq!(0, vec.len());
+ assert_eq!(None, vec.iter().next());
+ assert!(vec.is_empty());
+ assert_eq!(None, vec.first());
+ assert_eq!(None, vec.get(0));
+ assert_eq!(vec![0_u32; 0], vec.into_vec());
+ }
+
+ #[test]
+ fn test_array_vec_with_contents() {
+ let mut vec = ArrayVecOption::<u32, 5>::default();
+ vec.push(1);
+ vec.push(2);
+ vec.push(3);
+ vec.push(4);
+ vec.push(5);
+ assert_eq!(5, vec.len());
+ let mut iter = vec.iter();
+ assert_eq!(Some(&1_u32), iter.next());
+ assert_eq!(Some(&2_u32), iter.next());
+ assert_eq!(Some(&3_u32), iter.next());
+ assert_eq!(Some(&4_u32), iter.next());
+ assert_eq!(Some(&5_u32), iter.next());
+ assert_eq!(None, iter.next());
+ assert!(!vec.is_empty());
+ assert_eq!(Some(&1_u32), vec.first());
+ assert_eq!(Some(&5_u32), vec.get(4));
+ assert_eq!(vec![1_u32, 2, 3, 4, 5], vec.clone().into_vec());
+
+ vec.swap_remove(2);
+ assert_eq!(vec![1_u32, 2, 5, 4], vec.clone().into_vec());
+ }
+
+ #[test]
+ #[should_panic]
+ fn test_array_vec_push_overflow() {
+ let mut vec = ArrayVecOption::<u32, 5>::default();
+ vec.push(1);
+ vec.push(2);
+ vec.push(3);
+ vec.push(4);
+ vec.push(5);
+ vec.push(6);
+ }
+
+ #[test]
+ fn test_sort() {
+ let mut vec = ArrayVecOption::<u32, 5>::default();
+ vec.push(3);
+ vec.push(1);
+ vec.push(4);
+ vec.push(1);
+ vec.push(2);
+ vec.sort_unstable_by_key(|k| *k);
+ assert_eq!(vec![1_u32, 1, 2, 3, 4], vec.clone().into_vec());
+ }
+
+ #[test]
+ fn test_collect() {
+ let vec: ArrayVecOption<u32, 5> = [5_u32, 4, 3, 2, 1].into_iter().collect();
+ assert_eq!(vec![5_u32, 4, 3, 2, 1], vec.clone().into_vec());
+ }
+}
diff --git a/nearby/presence/np_adv/src/credential/book.rs b/nearby/presence/np_adv/src/credential/book.rs
index 9e6361d..902d55a 100644
--- a/nearby/presence/np_adv/src/credential/book.rs
+++ b/nearby/presence/np_adv/src/credential/book.rs
@@ -35,6 +35,8 @@
use crypto_provider::CryptoProvider;
#[cfg(feature = "alloc")]
+extern crate alloc;
+#[cfg(feature = "alloc")]
use alloc::vec::Vec;
/// A collection of credentials to try when attempting to deserialize
diff --git a/nearby/presence/np_adv/src/credential/tests.rs b/nearby/presence/np_adv/src/credential/tests.rs
index 297fdb5..8b12bfc 100644
--- a/nearby/presence/np_adv/src/credential/tests.rs
+++ b/nearby/presence/np_adv/src/credential/tests.rs
@@ -13,6 +13,8 @@
//! Tests of functionality related to credentials, credential-views, and credential suppliers.
+extern crate alloc;
+
use crate::credential::{
book::{
init_cache_from_source, CachedCredentialSource, PossiblyCachedDiscoveryCryptoMaterialKind,
diff --git a/nearby/presence/np_adv/src/deser_v0_tests.rs b/nearby/presence/np_adv/src/deser_v0_tests.rs
index 2fb6f38..93c3b97 100644
--- a/nearby/presence/np_adv/src/deser_v0_tests.rs
+++ b/nearby/presence/np_adv/src/deser_v0_tests.rs
@@ -38,7 +38,7 @@
HasIdentityMatch, PlaintextIdentityMode, PublicIdentity, V0AdvertisementContents,
};
use array_view::ArrayView;
-use core::{borrow::BorrowMut, marker::PhantomData};
+use core::marker::PhantomData;
use crypto_provider::CryptoProvider;
use crypto_provider_default::CryptoProviderImpl;
use ldt_np_adv::LegacySalt;
@@ -61,10 +61,10 @@
})
.collect::<Vec<_>>();
- let mut arena = deserialization_arena!();
+ let arena = deserialization_arena!();
let cred_book =
CredentialBookBuilder::build_cached_slice_book::<0, 0, CryptoProviderImpl>(&creds, &[]);
- let contents = deser_v0::<_, CryptoProviderImpl>(&mut arena, adv.as_slice(), &cred_book);
+ let contents = deser_v0::<_, CryptoProviderImpl>(arena, adv.as_slice(), &cred_book);
assert_adv_equals(&adv_config, &contents);
}
@@ -90,12 +90,12 @@
})
.collect::<Vec<_>>();
- let mut arena = deserialization_arena!();
+ let arena = deserialization_arena!();
let cred_book = CredentialBookBuilder::build_cached_slice_book::<0, 0, CryptoProviderImpl>(
&credentials,
&[],
);
- let contents = deser_v0::<_, CryptoProviderImpl>(&mut arena, adv.as_slice(), &cred_book);
+ let contents = deser_v0::<_, CryptoProviderImpl>(arena, adv.as_slice(), &cred_book);
match adv_config.identity {
// we ended up generating plaintext, so it's fine
@@ -118,10 +118,10 @@
let creds = Vec::<MatchableCredential<V0, EmptyMatchedCredential>>::new();
- let mut arena = deserialization_arena!();
+ let arena = deserialization_arena!();
let cred_book =
CredentialBookBuilder::build_cached_slice_book::<0, 0, CryptoProviderImpl>(&creds, &[]);
- let contents = deser_v0::<_, CryptoProviderImpl>(&mut arena, adv.as_slice(), &cred_book);
+ let contents = deser_v0::<_, CryptoProviderImpl>(arena, adv.as_slice(), &cred_book);
match adv_config.identity {
// we ended up generating plaintext, so it's fine
@@ -150,8 +150,8 @@
assert_eq!(adv_config.plaintext_mode.unwrap(), p.identity());
assert_eq!(
- vec![&PlainDataElement::Actions(de)],
- p.data_elements().collect::<Vec<_>>()
+ vec![PlainDataElement::Actions(de)],
+ p.data_elements().collect::<Result<Vec<_>, _>>().unwrap()
)
}
_ => panic!("should be a plaintext adv"),
@@ -166,8 +166,8 @@
let de = ActionsDataElement::from(action_bits);
assert_eq!(
- vec![&PlainDataElement::Actions(de)],
- wmc.contents().data_elements().collect::<Vec<_>>()
+ vec![PlainDataElement::Actions(de)],
+ wmc.contents().data_elements().collect::<Result<Vec<_>, _>>().unwrap()
);
assert_eq!(
adv_config.identity.unwrap().identity_type,
@@ -184,10 +184,10 @@
}
fn deser_v0<'adv, B, P>(
- arena: impl BorrowMut<DeserializationArena<'adv>>,
+ arena: DeserializationArena<'adv>,
adv: &'adv [u8],
cred_book: &'adv B,
-) -> V0AdvertisementContents<B::Matched>
+) -> V0AdvertisementContents<'adv, B::Matched>
where
B: CredentialBook<'adv>,
P: CryptoProvider,
diff --git a/nearby/presence/np_adv/src/deser_v1_tests.rs b/nearby/presence/np_adv/src/deser_v1_tests.rs
index 80f646e..903ed3d 100644
--- a/nearby/presence/np_adv/src/deser_v1_tests.rs
+++ b/nearby/presence/np_adv/src/deser_v1_tests.rs
@@ -68,12 +68,12 @@
})
.collect::<Vec<_>>();
- let mut arena = deserialization_arena!();
+ let arena = deserialization_arena!();
// check if the section is empty or there is more than one public section
let cred_book =
CredentialBookBuilder::build_cached_slice_book::<0, 0, CryptoProviderImpl>(&[], &creds);
if section_configs.is_empty() {
- let v1_error = deser_v1_error::<_, CryptoProviderImpl>(&mut arena, &adv, &cred_book);
+ let v1_error = deser_v1_error::<_, CryptoProviderImpl>(arena, &adv, &cred_book);
assert_eq!(
v1_error,
AdvDeserializationError::ParseError {
@@ -82,7 +82,7 @@
}
); //assert a adv deserialization error
} else {
- let v1_contents = deser_v1::<_, CryptoProviderImpl>(&mut arena, &adv, &cred_book);
+ let v1_contents = deser_v1::<_, CryptoProviderImpl>(arena, &adv, &cred_book);
assert_eq!(0, v1_contents.invalid_sections_count());
assert_eq!(section_configs.len(), v1_contents.sections.len());
for (section_config, section) in section_configs.iter().zip(v1_contents.sections.iter())
@@ -111,12 +111,12 @@
match_data: EmptyMatchedCredential,
})
.collect::<Vec<_>>();
- let mut arena = deserialization_arena!();
+ let arena = deserialization_arena!();
// check if the section header would be 0 or if the section is empty
let cred_book =
CredentialBookBuilder::build_cached_slice_book::<0, 0, CryptoProviderImpl>(&[], &creds);
if section_configs.is_empty() {
- let v1_error = deser_v1_error::<_, CryptoProviderImpl>(&mut arena, &adv, &cred_book);
+ let v1_error = deser_v1_error::<_, CryptoProviderImpl>(arena, &adv, &cred_book);
assert_eq!(
v1_error,
AdvDeserializationError::ParseError {
@@ -125,7 +125,7 @@
}
); //assert a adv deserialization error
} else {
- let v1_contents = deser_v1::<_, CryptoProviderImpl>(&mut arena, &adv, &cred_book);
+ let v1_contents = deser_v1::<_, CryptoProviderImpl>(arena, &adv, &cred_book);
assert_eq!(0, v1_contents.invalid_sections_count());
assert_eq!(section_configs.len(), v1_contents.sections.len());
for (section_config, section) in section_configs.iter().zip(v1_contents.sections.iter())
@@ -161,12 +161,12 @@
})
.collect::<Vec<_>>();
- let mut arena = deserialization_arena!();
+ let arena = deserialization_arena!();
// check if the section header would be 0
let cred_book =
CredentialBookBuilder::build_cached_slice_book::<0, 0, CryptoProviderImpl>(&[], &creds);
if section_configs.is_empty() {
- let v1_error = deser_v1_error::<_, CryptoProviderImpl>(&mut arena, &adv, &cred_book);
+ let v1_error = deser_v1_error::<_, CryptoProviderImpl>(arena, &adv, &cred_book);
assert_eq!(
v1_error,
AdvDeserializationError::ParseError {
@@ -175,7 +175,7 @@
}
); //assert a adv deserialization error
} else {
- let v1_contents = deser_v1::<_, CryptoProviderImpl>(&mut arena, &adv, &cred_book);
+ let v1_contents = deser_v1::<_, CryptoProviderImpl>(arena, &adv, &cred_book);
// all encrypted identity sections are invalid
let encrypted_section_count =
section_configs.iter().filter(|sc| sc.identity.is_some()).count();
@@ -206,7 +206,7 @@
&mut adv_builder,
);
let adv = adv_builder.into_advertisement();
- let mut arena = deserialization_arena!();
+ let arena = deserialization_arena!();
// check if the section header would be 0
let cred_book = CredentialBookBuilder::<EmptyMatchedCredential>::build_cached_slice_book::<
0,
@@ -214,7 +214,7 @@
CryptoProviderImpl,
>(&[], &[]);
if section_configs.is_empty() {
- let v1_error = deser_v1_error::<_, CryptoProviderImpl>(&mut arena, &adv, &cred_book);
+ let v1_error = deser_v1_error::<_, CryptoProviderImpl>(arena, &adv, &cred_book);
assert_eq!(
v1_error,
AdvDeserializationError::ParseError {
@@ -223,7 +223,7 @@
}
); //assert a adv deserialization error
} else {
- let v1_contents = deser_v1::<_, CryptoProviderImpl>(&mut arena, &adv, &cred_book);
+ let v1_contents = deser_v1::<_, CryptoProviderImpl>(arena, &adv, &cred_book);
// all encrypted identity sections are invalid
let encrypted_section_count =
section_configs.iter().filter(|sc| sc.identity.is_some()).count();
@@ -276,14 +276,14 @@
})
.collect::<Vec<_>>();
- let mut arena = deserialization_arena!();
+ let arena = deserialization_arena!();
let cred_book =
CredentialBookBuilder::build_cached_slice_book::<0, 0, CryptoProviderImpl>(&[], &creds);
// check if the section header would be 0
if section_configs.is_empty() {
- let v1_error = deser_v1_error::<_, CryptoProviderImpl>(&mut arena, &adv, &cred_book);
+ let v1_error = deser_v1_error::<_, CryptoProviderImpl>(arena, &adv, &cred_book);
assert_eq!(
v1_error,
AdvDeserializationError::ParseError {
@@ -292,7 +292,7 @@
}
); //assert a adv deserialization error
} else {
- let v1_contents = deser_v1::<_, CryptoProviderImpl>(&mut arena, &adv, &cred_book);
+ let v1_contents = deser_v1::<_, CryptoProviderImpl>(arena, &adv, &cred_book);
let affected_sections: Vec<_> = section_configs
.iter()
@@ -367,7 +367,7 @@
}
fn deser_v1_error<'a, B, P>(
- arena: &'a mut DeserializationArena<'a>,
+ arena: DeserializationArena<'a>,
adv: &'a EncodedAdvertisement,
cred_book: &'a B,
) -> AdvDeserializationError
@@ -383,7 +383,7 @@
}
fn deser_v1<'adv, B, P>(
- arena: &'adv mut DeserializationArena<'adv>,
+ arena: DeserializationArena<'adv>,
adv: &'adv EncodedAdvertisement,
cred_book: &'adv B,
) -> V1AdvertisementContents<'adv, B::Matched>
diff --git a/nearby/presence/np_adv/src/deserialization_arena.rs b/nearby/presence/np_adv/src/deserialization_arena.rs
index 6b5f651..9b58cbf 100644
--- a/nearby/presence/np_adv/src/deserialization_arena.rs
+++ b/nearby/presence/np_adv/src/deserialization_arena.rs
@@ -27,24 +27,19 @@
// Reference: https://doc.rust-lang.org/reference/destructors.html#temporary-lifetime-extension
() => {
$crate::deserialization_arena::DeserializationArena {
- slice: &mut $crate::deserialization_arena::DeserializationArena::buffer(),
+ buffer: &mut $crate::deserialization_arena::DeserializationArena::new_buffer(),
}
};
}
/// A simple allocator that simply keeps splitting the given slice on allocation. Use the
/// [`deserialization_arena!`][crate::deserialization_arena!] macro to create an instance.
-pub struct DeserializationArena<'a> {
- #[doc(hidden)] // Exposed for use by `deserialization_arena!` only.
- pub slice: &'a mut [u8],
+pub(crate) struct DeserializationArenaAllocator<'a> {
+ #[doc(hidden)]
+ slice: &'a mut [u8],
}
-impl<'a> DeserializationArena<'a> {
- #[doc(hidden)] // Exposed for use by `deserialization_arena!` only.
- pub fn buffer() -> [u8; BLE_ADV_SVC_CONTENT_LEN] {
- [0; BLE_ADV_SVC_CONTENT_LEN]
- }
-
+impl<'a> DeserializationArenaAllocator<'a> {
/// Allocates `len` bytes from the slice given upon construction. In the expected use case, the
/// allocated slice should be written to with actual data, overwriting what's contained in
/// there. While reading from the allocated slice without first writing to it is safe in the
@@ -59,17 +54,36 @@
}
let (allocated, remaining) = core::mem::take(&mut self.slice).split_at_mut(len.into());
self.slice = remaining;
- // Note: the returned data is logically garbage, but in practice it's all zeroes assuming
- // `deserialization_arena!` was used to create this allocator.
+ // Note: the returned data is logically garbage. While it's deterministic (not UB),
+ // semantically this should be treated as a write only slice.
Ok(allocated)
}
}
+/// A simple allocator that simply keeps splitting the given slice on allocation. Use the
+/// [`deserialization_arena!`][crate::deserialization_arena!] macro to create an instance.
+pub struct DeserializationArena<'a> {
+ #[doc(hidden)] // Exposed for use by `deserialization_arena!` only.
+ pub buffer: &'a mut [u8; BLE_ADV_SVC_CONTENT_LEN],
+}
+
+impl<'a> DeserializationArena<'a> {
+ #[doc(hidden)] // Exposed for use by `deserialization_arena!` only.
+ pub fn new_buffer() -> [u8; BLE_ADV_SVC_CONTENT_LEN] {
+ [0; BLE_ADV_SVC_CONTENT_LEN]
+ }
+
+ /// Convert this arena into an allocator that can start allocating.
+ pub(crate) fn into_allocator(self) -> DeserializationArenaAllocator<'a> {
+ DeserializationArenaAllocator { slice: self.buffer }
+ }
+}
+
/// Error indicating that the arena has ran out of space, and deserialization cannot proceed. This
/// should never happen if the arena is created with [`crate::deserialization_arena!`], since the
/// total size of decrypted sections should be less than the size of the incoming BLE advertisement.
#[derive(Debug, PartialEq, Eq)]
-pub struct ArenaOutOfSpace;
+pub(crate) struct ArenaOutOfSpace;
#[cfg(test)]
mod test {
@@ -77,26 +91,29 @@
#[test]
fn test_creation() {
- assert_eq!(BLE_ADV_SVC_CONTENT_LEN, deserialization_arena!().slice.len());
+ assert_eq!(BLE_ADV_SVC_CONTENT_LEN, deserialization_arena!().buffer.len());
}
#[test]
fn test_allocation() {
- let mut arena = deserialization_arena!();
- assert_eq!(Ok(&mut [0_u8; 100][..]), arena.allocate(100));
- assert_eq!(BLE_ADV_SVC_CONTENT_LEN - 100, arena.slice.len());
+ let arena = deserialization_arena!();
+ let mut allocator = arena.into_allocator();
+ assert_eq!(Ok(&mut [0_u8; 100][..]), allocator.allocate(100));
+ assert_eq!(BLE_ADV_SVC_CONTENT_LEN - 100, allocator.slice.len());
}
#[test]
fn test_allocation_overflow() {
- let mut arena = deserialization_arena!();
- assert_eq!(Err(ArenaOutOfSpace), arena.allocate(u8::MAX));
+ let arena = deserialization_arena!();
+ let mut allocator = arena.into_allocator();
+ assert_eq!(Err(ArenaOutOfSpace), allocator.allocate(u8::MAX));
}
#[test]
fn test_allocation_twice_overflow() {
- let mut arena = deserialization_arena!();
- assert_eq!(Ok(&mut [0_u8; 128][..]), arena.allocate(128));
- assert_eq!(Err(ArenaOutOfSpace), arena.allocate(128));
+ let arena = deserialization_arena!();
+ let mut allocator = arena.into_allocator();
+ assert_eq!(Ok(&mut [0_u8; 128][..]), allocator.allocate(128));
+ assert_eq!(Err(ArenaOutOfSpace), allocator.allocate(128));
}
}
diff --git a/nearby/presence/np_adv/src/extended/deserialize/encrypted_section/mic_decrypt_tests.rs b/nearby/presence/np_adv/src/extended/deserialize/encrypted_section/mic_decrypt_tests.rs
index dfab7ce..9bd54b8 100644
--- a/nearby/presence/np_adv/src/extended/deserialize/encrypted_section/mic_decrypt_tests.rs
+++ b/nearby/presence/np_adv/src/extended/deserialize/encrypted_section/mic_decrypt_tests.rs
@@ -99,10 +99,11 @@
let verification_material =
discovery_credential.unsigned_verification_material::<CryptoProviderImpl>();
- let mut arena = deserialization_arena!();
+ let arena = deserialization_arena!();
+ let mut allocator = arena.into_allocator();
let section = contents
.try_resolve_identity_and_deserialize::<CryptoProviderImpl>(
- &mut arena,
+ &mut allocator,
&identity_resolution_material,
&verification_material,
)
@@ -179,10 +180,11 @@
&identity_resolution_material.into_raw_resolution_material(),
)
.unwrap();
- let mut arena = deserialization_arena!();
+ let arena = deserialization_arena!();
+ let mut allocator = arena.into_allocator();
let decrypted = contents
.contents
- .decrypt_ciphertext::<CryptoProviderImpl>(&mut arena, identity_match)
+ .decrypt_ciphertext::<CryptoProviderImpl>(&mut allocator, identity_match)
.unwrap();
let mut expected = Vec::new();
@@ -366,7 +368,7 @@
error,
contents
.try_resolve_identity_and_deserialize::<C>(
- &mut deserialization_arena!(),
+ &mut deserialization_arena!().into_allocator(),
&identity_resolution_material,
&verification_material,
)
@@ -447,7 +449,7 @@
discovery_credential.unsigned_verification_material::<CryptoProviderImpl>();
match contents.try_resolve_identity_and_deserialize::<CryptoProviderImpl>(
- &mut deserialization_arena!(),
+ &mut deserialization_arena!().into_allocator(),
&identity_resolution_material,
&verification_material,
) {
diff --git a/nearby/presence/np_adv/src/extended/deserialize/encrypted_section/mod.rs b/nearby/presence/np_adv/src/extended/deserialize/encrypted_section/mod.rs
index 0afeb08..2236630 100644
--- a/nearby/presence/np_adv/src/extended/deserialize/encrypted_section/mod.rs
+++ b/nearby/presence/np_adv/src/extended/deserialize/encrypted_section/mod.rs
@@ -14,7 +14,7 @@
use crate::{
credential::v1::*,
- deserialization_arena::DeserializationArena,
+ deserialization_arena::DeserializationArenaAllocator,
extended::{
deserialize::{
DecryptedSection, EncryptedIdentityMetadata, EncryptionInfo, SectionContents,
@@ -27,6 +27,8 @@
};
#[cfg(any(feature = "devtools", test))]
+extern crate alloc;
+#[cfg(any(feature = "devtools", test))]
use alloc::vec::Vec;
#[cfg(feature = "devtools")]
use array_view::ArrayView;
@@ -189,7 +191,7 @@
/// and returns the raw bytes of the decrypted plaintext.
pub(crate) fn decrypt_ciphertext<C: CryptoProvider>(
&self,
- arena: &mut DeserializationArena<'a>,
+ arena: &mut DeserializationArenaAllocator<'a>,
mut identity_match: IdentityMatch<C>,
) -> Result<RawDecryptedSection<'a>, ArenaOutOfSpace> {
// Fill decrypt_buf with the ciphertext after the metadata key
@@ -213,12 +215,12 @@
#[cfg(feature = "devtools")]
pub(crate) fn try_resolve_identity_and_decrypt<P: CryptoProvider>(
&self,
- arena: &mut DeserializationArena<'a>,
+ allocator: &mut DeserializationArenaAllocator<'a>,
identity_resolution_material: &SectionIdentityResolutionMaterial,
) -> Option<Result<ArrayView<u8, NP_ADV_MAX_SECTION_LEN>, ArenaOutOfSpace>> {
let identity_resolution_contents = self.compute_identity_resolution_contents::<P>();
identity_resolution_contents.try_match(identity_resolution_material).map(|identity_match| {
- let decrypted_section = self.decrypt_ciphertext::<P>(arena, identity_match)?;
+ let decrypted_section = self.decrypt_ciphertext::<P>(allocator, identity_match)?;
Ok(decrypted_section.to_raw_bytes())
})
}
@@ -235,7 +237,7 @@
/// with some paired verification material for the matched identity.
pub(crate) fn try_deserialize<P>(
&self,
- arena: &mut DeserializationArena<'a>,
+ arena: &mut DeserializationArenaAllocator<'a>,
identity_match: IdentityMatch<P>,
verification_material: &SignedSectionVerificationMaterial,
) -> Result<DecryptedSection<'a>, DeserializationError<SignatureVerificationError>>
@@ -294,11 +296,11 @@
#[cfg(feature = "devtools")]
pub(crate) fn try_resolve_identity_and_decrypt<P: CryptoProvider>(
&self,
- arena: &mut DeserializationArena<'a>,
+ allocator: &mut DeserializationArenaAllocator<'a>,
identity_resolution_material: &SignedSectionIdentityResolutionMaterial,
) -> Option<Result<ArrayView<u8, NP_ADV_MAX_SECTION_LEN>, ArenaOutOfSpace>> {
self.contents.try_resolve_identity_and_decrypt::<P>(
- arena,
+ allocator,
identity_resolution_material.as_raw_resolution_material(),
)
}
@@ -307,7 +309,7 @@
#[cfg(test)]
pub(crate) fn try_resolve_identity_and_deserialize<P: CryptoProvider>(
&self,
- arena: &mut DeserializationArena<'a>,
+ allocator: &mut DeserializationArenaAllocator<'a>,
identity_resolution_material: &SignedSectionIdentityResolutionMaterial,
verification_material: &SignedSectionVerificationMaterial,
) -> Result<
@@ -320,7 +322,7 @@
.try_match::<P>(identity_resolution_material.as_raw_resolution_material())
{
Some(identity_match) => self
- .try_deserialize(arena, identity_match, verification_material)
+ .try_deserialize(allocator, identity_match, verification_material)
.map_err(|e| e.into()),
None => Err(IdentityResolutionOrDeserializationError::IdentityMatchingError),
}
@@ -413,14 +415,14 @@
/// Returns an error if the credential is incorrect or if the section data is malformed.
pub(crate) fn try_deserialize<P>(
&self,
- arena: &mut DeserializationArena<'a>,
+ allocator: &mut DeserializationArenaAllocator<'a>,
identity_match: IdentityMatch<P>,
verification_material: &UnsignedSectionVerificationMaterial,
) -> Result<DecryptedSection<'a>, DeserializationError<MicVerificationError>>
where
P: CryptoProvider,
{
- let raw_decrypted = self.contents.decrypt_ciphertext(arena, identity_match)?;
+ let raw_decrypted = self.contents.decrypt_ciphertext(allocator, identity_match)?;
let metadata_key = raw_decrypted.metadata_key_plaintext;
let nonce = raw_decrypted.nonce;
let remaining_des = raw_decrypted.plaintext_contents;
@@ -455,11 +457,11 @@
#[cfg(feature = "devtools")]
pub(crate) fn try_resolve_identity_and_decrypt<P: CryptoProvider>(
&self,
- arena: &mut DeserializationArena<'a>,
+ allocator: &mut DeserializationArenaAllocator<'a>,
identity_resolution_material: &UnsignedSectionIdentityResolutionMaterial,
) -> Option<Result<ArrayView<u8, NP_ADV_MAX_SECTION_LEN>, ArenaOutOfSpace>> {
self.contents.try_resolve_identity_and_decrypt::<P>(
- arena,
+ allocator,
identity_resolution_material.as_raw_resolution_material(),
)
}
@@ -468,7 +470,7 @@
#[cfg(test)]
pub(crate) fn try_resolve_identity_and_deserialize<P: CryptoProvider>(
&self,
- arena: &mut DeserializationArena<'a>,
+ allocator: &mut DeserializationArenaAllocator<'a>,
identity_resolution_material: &UnsignedSectionIdentityResolutionMaterial,
verification_material: &UnsignedSectionVerificationMaterial,
) -> Result<DecryptedSection, IdentityResolutionOrDeserializationError<MicVerificationError>>
@@ -479,7 +481,7 @@
.try_match::<P>(identity_resolution_material.as_raw_resolution_material())
{
Some(identity_match) => self
- .try_deserialize(arena, identity_match, verification_material)
+ .try_deserialize(allocator, identity_match, verification_material)
.map_err(|e| e.into()),
None => Err(IdentityResolutionOrDeserializationError::IdentityMatchingError),
}
diff --git a/nearby/presence/np_adv/src/extended/deserialize/encrypted_section/signature_decrypt_tests.rs b/nearby/presence/np_adv/src/extended/deserialize/encrypted_section/signature_decrypt_tests.rs
index 10fc46b..2370aeb 100644
--- a/nearby/presence/np_adv/src/extended/deserialize/encrypted_section/signature_decrypt_tests.rs
+++ b/nearby/presence/np_adv/src/extended/deserialize/encrypted_section/signature_decrypt_tests.rs
@@ -143,8 +143,10 @@
)
.unwrap();
- let mut arena = deserialization_arena!();
- let decrypted = contents.contents.decrypt_ciphertext(&mut arena, identity_match).unwrap();
+ let arena = deserialization_arena!();
+ let mut allocator = arena.into_allocator();
+ let decrypted =
+ contents.contents.decrypt_ciphertext(&mut allocator, identity_match).unwrap();
let mut expected = Vec::new();
expected.extend_from_slice(txpower_de.de_header().serialize().as_slice());
@@ -186,10 +188,11 @@
let signed_verification_material =
crypto_material.signed_verification_material::<CryptoProviderImpl>();
- let mut arena = deserialization_arena!();
+ let arena = deserialization_arena!();
+ let mut allocator = arena.into_allocator();
let section = contents
.try_resolve_identity_and_deserialize::<CryptoProviderImpl>(
- &mut arena,
+ &mut allocator,
&signed_identity_resolution_material,
&signed_verification_material,
)
@@ -424,7 +427,7 @@
error,
contents
.try_resolve_identity_and_deserialize::<C>(
- &mut deserialization_arena!(),
+ &mut deserialization_arena!().into_allocator(),
&signed_identity_resolution_material,
&signed_verification_material,
)
@@ -533,7 +536,7 @@
crypto_material.signed_verification_material::<CryptoProviderImpl>();
match contents.try_resolve_identity_and_deserialize::<CryptoProviderImpl>(
- &mut deserialization_arena!(),
+ &mut deserialization_arena!().into_allocator(),
&identity_resolution_material,
&verification_material,
) {
diff --git a/nearby/presence/np_adv/src/extended/deserialize/mod.rs b/nearby/presence/np_adv/src/extended/deserialize/mod.rs
index d431325..4b78a32 100644
--- a/nearby/presence/np_adv/src/extended/deserialize/mod.rs
+++ b/nearby/presence/np_adv/src/extended/deserialize/mod.rs
@@ -14,8 +14,10 @@
//! Deserialization for V1 advertisement contents
+#[cfg(any(test, feature = "alloc"))]
extern crate alloc;
+#[cfg(any(test, feature = "alloc"))]
use alloc::vec::Vec;
use core::array::TryFromSliceError;
@@ -27,12 +29,13 @@
use crypto_provider::CryptoProvider;
use np_hkdf::v1_salt::{self, V1Salt};
+use crate::array_vec::ArrayVecOption;
#[cfg(any(feature = "devtools", test))]
use crate::credential::v1::V1DiscoveryCryptoMaterial;
use crate::credential::v1::V1;
use crate::deserialization_arena::ArenaOutOfSpace;
#[cfg(any(feature = "devtools", test))]
-use crate::deserialization_arena::DeserializationArena;
+use crate::deserialization_arena::DeserializationArenaAllocator;
#[cfg(test)]
use crate::extended::deserialize::encrypted_section::IdentityResolutionOrDeserializationError;
use crate::extended::{NP_V1_ADV_MAX_ENCRYPTED_SECTION_COUNT, NP_V1_ADV_MAX_PUBLIC_SECTION_COUNT};
@@ -66,19 +69,32 @@
pub(crate) fn parse_sections(
adv_header: V1Header,
adv_body: &[u8],
-) -> Result<Vec<IntermediateSection>, nom::Err<error::Error<&[u8]>>> {
+) -> Result<
+ ArrayVecOption<IntermediateSection, NP_V1_ADV_MAX_ENCRYPTED_SECTION_COUNT>,
+ nom::Err<error::Error<&[u8]>>,
+> {
combinator::all_consuming(branch::alt((
// Public advertisement
- multi::many_m_n(
+ multi::fold_many_m_n(
1,
NP_V1_ADV_MAX_PUBLIC_SECTION_COUNT,
IntermediateSection::parser_public_section(),
+ ArrayVecOption::default,
+ |mut acc, item| {
+ acc.push(item);
+ acc
+ },
),
// Encrypted advertisement
- multi::many_m_n(
+ multi::fold_many_m_n(
1,
NP_V1_ADV_MAX_ENCRYPTED_SECTION_COUNT,
IntermediateSection::parser_encrypted_with_header(adv_header),
+ ArrayVecOption::default,
+ |mut acc, item| {
+ acc.push(item);
+ acc
+ },
),
)))(adv_body)
.map(|(_rem, sections)| sections)
@@ -395,7 +411,7 @@
#[cfg(test)]
pub(crate) fn try_resolve_identity_and_deserialize<C, P>(
&'a self,
- arena: &mut DeserializationArena<'a>,
+ allocator: &mut DeserializationArenaAllocator<'a>,
crypto_material: &C,
) -> Result<DecryptedSection<'a>, SectionDeserializeError>
where
@@ -410,7 +426,7 @@
contents
.try_resolve_identity_and_deserialize::<P>(
- arena,
+ allocator,
&identity_resolution_material,
&verification_material,
)
@@ -423,7 +439,7 @@
contents
.try_resolve_identity_and_deserialize::<P>(
- arena,
+ allocator,
&identity_resolution_material,
&verification_material,
)
@@ -439,19 +455,19 @@
P: CryptoProvider,
>(
&self,
- arena: &mut DeserializationArena<'a>,
+ allocator: &mut DeserializationArenaAllocator<'a>,
crypto_material: &C,
) -> Option<Result<ArrayView<u8, NP_ADV_MAX_SECTION_LEN>, ArenaOutOfSpace>> {
match self {
CiphertextSection::SignatureEncryptedIdentity(x) => {
let identity_resolution_material =
crypto_material.signed_identity_resolution_material::<P>();
- x.try_resolve_identity_and_decrypt::<P>(arena, &identity_resolution_material)
+ x.try_resolve_identity_and_decrypt::<P>(allocator, &identity_resolution_material)
}
CiphertextSection::MicEncryptedIdentity(x) => {
let identity_resolution_material =
crypto_material.unsigned_identity_resolution_material::<P>();
- x.try_resolve_identity_and_decrypt::<P>(arena, &identity_resolution_material)
+ x.try_resolve_identity_and_decrypt::<P>(allocator, &identity_resolution_material)
}
}
}
diff --git a/nearby/presence/np_adv/src/extended/deserialize/parse_tests.rs b/nearby/presence/np_adv/src/extended/deserialize/parse_tests.rs
index 506a127..4afa3ec 100644
--- a/nearby/presence/np_adv/src/extended/deserialize/parse_tests.rs
+++ b/nearby/presence/np_adv/src/extended/deserialize/parse_tests.rs
@@ -36,7 +36,8 @@
// de 2 byte header, type 6, len 1
adv_body.extend_from_slice(&[0x81, 0x06, 0x01]);
- let parsed_sections = parse_sections(V1Header { header_byte: 0x20 }, &adv_body).unwrap();
+ let parsed_sections =
+ parse_sections(V1Header { header_byte: 0x20 }, &adv_body).unwrap().into_vec();
assert_eq!(
vec![IntermediateSection::from(PlaintextSection::new(
PlaintextIdentityMode::Public,
@@ -168,7 +169,7 @@
},
];
let parsed_sections = parse_sections(adv_header, &adv_body).unwrap();
- assert_eq!(parsed_sections, &expected_sections.map(IntermediateSection::from));
+ assert_eq!(parsed_sections.into_vec(), expected_sections.map(IntermediateSection::from));
}
#[test]
@@ -296,7 +297,7 @@
},
];
let parsed_sections = parse_sections(adv_header, &adv_body).unwrap();
- assert_eq!(parsed_sections, &expected_sections.map(IntermediateSection::from));
+ assert_eq!(parsed_sections.into_vec(), &expected_sections.map(IntermediateSection::from));
}
#[test]
diff --git a/nearby/presence/np_adv/src/extended/deserialize/section_tests.rs b/nearby/presence/np_adv/src/extended/deserialize/section_tests.rs
index 39644ab..5b1290f 100644
--- a/nearby/presence/np_adv/src/extended/deserialize/section_tests.rs
+++ b/nearby/presence/np_adv/src/extended/deserialize/section_tests.rs
@@ -16,6 +16,7 @@
use super::*;
use crate::deserialization_arena;
+use crate::deserialization_arena::DeserializationArena;
use crate::extended::serialize::AdvertisementType;
use crate::extended::NP_V1_ADV_MAX_PUBLIC_SECTION_COUNT;
use crate::{
@@ -36,7 +37,7 @@
},
parse_adv_header, AdvHeader, WithMatchedCredential,
};
-use core::borrow::{Borrow, BorrowMut};
+use core::borrow::Borrow;
use core::convert::Into;
use crypto_provider::{CryptoProvider, CryptoRng};
use crypto_provider_default::CryptoProviderImpl;
@@ -569,7 +570,7 @@
/// - `Ok(None)` if no matching credential was found, or if `cred_source` provides no credentials
/// - `Err` if an error occurred.
fn try_deserialize_all_creds<'a, S, P>(
- mut arena: impl BorrowMut<DeserializationArena<'a>>,
+ arena: DeserializationArena<'a>,
section: &'a CiphertextSection,
cred_source: &'a S,
) -> Result<TryDeserOutput<'a, S::Matched>, BatchSectionDeserializeError>
@@ -577,11 +578,11 @@
S: DiscoveryCredentialSource<'a, V1>,
P: CryptoProvider,
{
+ let mut allocator = arena.into_allocator();
for (crypto_material, match_data) in cred_source.iter() {
- match section.try_resolve_identity_and_deserialize::<_, P>(
- arena.borrow_mut(),
- crypto_material.borrow(),
- ) {
+ match section
+ .try_resolve_identity_and_deserialize::<_, P>(&mut allocator, crypto_material.borrow())
+ {
Ok(s) => {
let metadata_nonce = crypto_material.metadata_nonce::<P>();
return Ok(Some(WithMatchedCredential::new(match_data, metadata_nonce, s)));
diff --git a/nearby/presence/np_adv/src/filter/mod.rs b/nearby/presence/np_adv/src/filter/mod.rs
index cb020cf..a2b2d9c 100644
--- a/nearby/presence/np_adv/src/filter/mod.rs
+++ b/nearby/presence/np_adv/src/filter/mod.rs
@@ -17,6 +17,7 @@
//! it matched with. Used as a first pass option to quickly check if a buffer should
//! further processed.
use crate::credential::MatchedCredential;
+use crate::legacy::data_elements::DataElementDeserializeError;
use crate::legacy::deserialize::DecryptedAdvContents;
use crate::{
credential::{book::CredentialBook, v0::V0DiscoveryCryptoMaterial},
@@ -157,7 +158,7 @@
IntermediateAdvContents::Plaintext(p) => match self.identity {
IdentityFilterType::Public | IdentityFilterType::Any => self
.data_elements
- .match_v0_legible_adv(p.data_elements())
+ .match_v0_legible_adv(|| p.data_elements())
.map(|()| FilterResult::Public),
_ => Err(NoMatch),
},
@@ -165,7 +166,7 @@
IdentityFilterType::Private | IdentityFilterType::Any => {
let (legible_adv, m) = try_decrypt_and_match::<B, P>(cred_book.v0_iter(), &c)?;
self.data_elements
- .match_v0_legible_adv(legible_adv.data_elements())
+ .match_v0_legible_adv(|| legible_adv.data_elements())
.map(|()| FilterResult::Private(m))
}
_ => Err(NoMatch),
@@ -174,12 +175,12 @@
}
}
-fn try_decrypt_and_match<'a, B, P>(
+fn try_decrypt_and_match<'cred, B, P>(
v0_creds: B::V0Iterator,
adv: &EncryptedAdvContents,
) -> Result<(DecryptedAdvContents, B::Matched), NoMatch>
where
- B: CredentialBook<'a>,
+ B: CredentialBook<'cred>,
P: CryptoProvider,
{
for (crypto_material, m) in v0_creds {
@@ -199,14 +200,15 @@
impl V0DataElementsFilter {
/// A legible adv is either plaintext to begin with, or decrypted contents from an encrypted adv
- fn match_v0_legible_adv<'a, F: PacketFlavor + 'a>(
- &self,
- mut data_elements: impl ExactSizeIterator<Item = &'a PlainDataElement<F>>,
- ) -> Result<(), NoMatch> {
+ fn match_v0_legible_adv<F, I>(&self, data_elements: impl Fn() -> I) -> Result<(), NoMatch>
+ where
+ F: PacketFlavor,
+ I: Iterator<Item = Result<PlainDataElement<F>, DataElementDeserializeError>>,
+ {
match &self.contains_tx_power {
None => Ok(()),
Some(c) => {
- if c == &data_elements.any(|de| matches!(de, PlainDataElement::TxPower(_))) {
+ if c == &data_elements().any(|de| matches!(de, Ok(PlainDataElement::TxPower(_)))) {
Ok(())
} else {
Err(NoMatch)
@@ -217,13 +219,16 @@
match &self.actions_filter {
None => Ok(()),
Some(filter) => {
+ if let Some(_err) = data_elements().find_map(|result| result.err()) {
+ return Err(NoMatch);
+ }
// find if an actions DE exists, if so match on the provided action filter
- let actions = data_elements.find_map(|de| match de {
- PlainDataElement::Actions(actions) => Some(actions),
+ let actions = data_elements().find_map(|de| match de {
+ Ok(PlainDataElement::Actions(actions)) => Some(actions),
_ => None,
});
if let Some(actions) = actions {
- filter.match_v0_actions(actions)
+ filter.match_v0_actions(&actions)
} else {
return Err(NoMatch);
}
diff --git a/nearby/presence/np_adv/src/filter/tests/data_elements_filter_tests.rs b/nearby/presence/np_adv/src/filter/tests/data_elements_filter_tests.rs
index cb7c067..4a893a2 100644
--- a/nearby/presence/np_adv/src/filter/tests/data_elements_filter_tests.rs
+++ b/nearby/presence/np_adv/src/filter/tests/data_elements_filter_tests.rs
@@ -23,16 +23,17 @@
let filter = V0DataElementsFilter { contains_tx_power: Some(true), actions_filter: None };
let tx_power = TxPower::try_from(5).expect("within range");
- let tx_power_de = TxPowerDataElement::from(tx_power);
- let result =
- filter.match_v0_legible_adv([PlainDataElement::<Ciphertext>::TxPower(tx_power_de)].iter());
+ let result = filter.match_v0_legible_adv(|| {
+ [Ok(PlainDataElement::<Ciphertext>::TxPower(TxPowerDataElement::from(tx_power.clone())))]
+ .into_iter()
+ });
assert_eq!(result, Ok(()))
}
#[test]
fn match_not_contains_tx_power() {
let filter = V0DataElementsFilter { contains_tx_power: Some(true), actions_filter: None };
- let result = filter.match_v0_legible_adv::<Plaintext>([].iter());
+ let result = filter.match_v0_legible_adv::<Plaintext, _>(|| [].into_iter());
assert_eq!(result, Err(NoMatch))
}
@@ -42,9 +43,10 @@
.expect("1 is a valid length");
let filter = V0DataElementsFilter { contains_tx_power: None, actions_filter: Some(filter) };
let tx_power = TxPower::try_from(5).expect("within range");
- let tx_power_de = TxPowerDataElement::from(tx_power);
- let result =
- filter.match_v0_legible_adv([PlainDataElement::<Ciphertext>::TxPower(tx_power_de)].iter());
+ let result = filter.match_v0_legible_adv(|| {
+ [Ok(PlainDataElement::<Ciphertext>::TxPower(TxPowerDataElement::from(tx_power.clone())))]
+ .into_iter()
+ });
assert_eq!(result, Err(NoMatch))
}
@@ -54,18 +56,17 @@
.expect("1 is a valid length");
let filter = V0DataElementsFilter { contains_tx_power: None, actions_filter: Some(filter) };
let tx_power = TxPower::try_from(5).expect("within range");
- let tx_power_de = TxPowerDataElement::from(tx_power);
let mut action_bits = ActionBits::<Ciphertext>::default();
action_bits.set_action(ActiveUnlock::from(true));
- let result = filter.match_v0_legible_adv(
+ let result = filter.match_v0_legible_adv(|| {
[
- PlainDataElement::<Ciphertext>::TxPower(tx_power_de),
- PlainDataElement::Actions(action_bits.into()),
+ Ok(PlainDataElement::<Ciphertext>::TxPower(TxPowerDataElement::from(tx_power.clone()))),
+ Ok(PlainDataElement::Actions(action_bits.into())),
]
- .iter(),
- );
+ .into_iter()
+ });
assert_eq!(result, Ok(()))
}
@@ -76,18 +77,17 @@
let filter =
V0DataElementsFilter { contains_tx_power: Some(true), actions_filter: Some(filter) };
let tx_power = TxPower::try_from(5).expect("within range");
- let tx_power_de = TxPowerDataElement::from(tx_power);
let mut action_bits = ActionBits::<Ciphertext>::default();
action_bits.set_action(ActiveUnlock::from(true));
- let result = filter.match_v0_legible_adv(
+ let result = filter.match_v0_legible_adv(|| {
[
- PlainDataElement::<Ciphertext>::TxPower(tx_power_de),
- PlainDataElement::Actions(action_bits.into()),
+ Ok(PlainDataElement::<Ciphertext>::TxPower(TxPowerDataElement::from(tx_power.clone()))),
+ Ok(PlainDataElement::Actions(action_bits.into())),
]
- .iter(),
- );
+ .into_iter()
+ });
assert_eq!(result, Ok(()))
}
@@ -98,9 +98,10 @@
let filter =
V0DataElementsFilter { contains_tx_power: Some(true), actions_filter: Some(filter) };
let tx_power = TxPower::try_from(5).expect("within range");
- let tx_power_de = TxPowerDataElement::from(tx_power);
- let result =
- filter.match_v0_legible_adv([PlainDataElement::<Ciphertext>::TxPower(tx_power_de)].iter());
+ let result = filter.match_v0_legible_adv(|| {
+ [Ok(PlainDataElement::<Ciphertext>::TxPower(TxPowerDataElement::from(tx_power.clone())))]
+ .into_iter()
+ });
assert_eq!(result, Err(NoMatch))
}
diff --git a/nearby/presence/np_adv/src/legacy/data_elements.rs b/nearby/presence/np_adv/src/legacy/data_elements.rs
index 505fdd9..c97cb25 100644
--- a/nearby/presence/np_adv/src/legacy/data_elements.rs
+++ b/nearby/presence/np_adv/src/legacy/data_elements.rs
@@ -13,6 +13,8 @@
// limitations under the License.
//! V0 data elements and core trait impls.
+use nom::error::{ErrorKind, FromExternalError};
+
use crate::legacy::{
de_type::{DataElementType, PlainDataElementType},
serialize::{DataElementBundle, ToDataElementBundle},
@@ -53,6 +55,37 @@
/// The DE type attempting to be deserialized
de_type: DataElementType,
},
+ /// Only one identity data element is allowed in an advertisement, but a duplicate is found
+ /// while parsing.
+ DuplicateIdentityDataElement,
+ /// There is unexpected data remaining in the incoming payload.
+ UnexpectedDataRemaining,
+ /// Parsing error returned from Nom.
+ NomError(nom::error::ErrorKind),
+}
+
+impl FromExternalError<&[u8], DataElementDeserializeError> for DataElementDeserializeError {
+ fn from_external_error(
+ _input: &[u8],
+ _kind: ErrorKind,
+ e: DataElementDeserializeError,
+ ) -> Self {
+ e
+ }
+}
+
+impl nom::error::ParseError<&[u8]> for DataElementDeserializeError {
+ /// Creates an error from the input position and an [ErrorKind]
+ fn from_error_kind(_input: &[u8], kind: ErrorKind) -> Self {
+ Self::NomError(kind)
+ }
+
+ /// Combines an existing error with a new one created from the input
+ /// position and an [ErrorKind]. This is useful when backtracking
+ /// through a parse tree, accumulating error context on the way
+ fn append(_input: &[u8], kind: ErrorKind, _other: Self) -> Self {
+ Self::NomError(kind)
+ }
}
/// Data element holding a [TxPower].
diff --git a/nearby/presence/np_adv/src/legacy/deserialize/mod.rs b/nearby/presence/np_adv/src/legacy/deserialize/mod.rs
index 48555be..938045d 100644
--- a/nearby/presence/np_adv/src/legacy/deserialize/mod.rs
+++ b/nearby/presence/np_adv/src/legacy/deserialize/mod.rs
@@ -16,7 +16,7 @@
//!
//! This module only deals with the _contents_ of an advertisement, not the advertisement header.
-extern crate alloc;
+use core::marker::PhantomData;
use crate::{
credential::v0::V0,
@@ -29,10 +29,12 @@
},
HasIdentityMatch, PlaintextIdentityMode,
};
-use alloc::vec::Vec;
+use array_view::ArrayView;
use crypto_provider::CryptoProvider;
use ldt_np_adv::{LegacySalt, NP_LEGACY_METADATA_KEY_LEN};
-use nom::{bytes, combinator, multi, number, sequence};
+use nom::{bytes, combinator, number, sequence};
+
+use super::BLE_ADV_SVC_CONTENT_LEN;
#[cfg(test)]
mod tests;
@@ -41,16 +43,14 @@
/// ciphertext.
pub(crate) fn deserialize_adv_contents<C: CryptoProvider>(
input: &[u8],
-) -> Result<IntermediateAdvContents, AdvDeserializeError> {
+) -> Result<IntermediateAdvContents<'_>, AdvDeserializeError> {
parse_raw_adv_contents::<C>(input).and_then(|raw_adv| match raw_adv {
- RawAdvertisement::Plaintext(parc) => {
- if parc.data_elements.is_empty() {
+ RawAdvertisement::Plaintext(adv_contents) => {
+ if adv_contents.data_elements().next().is_none() {
return Err(AdvDeserializeError::NoPublicDataElements);
}
- parc.try_deserialize()
- .map(IntermediateAdvContents::Plaintext)
- .map_err(AdvDeserializeError::DataElementDeserializeError)
+ Ok(IntermediateAdvContents::Plaintext(adv_contents))
}
RawAdvertisement::Ciphertext(eac) => Ok(IntermediateAdvContents::Ciphertext(eac)),
})
@@ -63,50 +63,56 @@
fn parse_raw_adv_contents<C: CryptoProvider>(
input: &[u8],
) -> Result<RawAdvertisement, AdvDeserializeError> {
- let (_, data_elements) = parse_data_elements(input)
- .map_err(|_e| AdvDeserializeError::AdvertisementDeserializeError)?;
-
- if let Some(identity_de_type) =
- data_elements.first().and_then(|de| de.de_type.try_as_identity_de_type())
- {
- match identity_de_type.as_encrypted_identity_de_type() {
- Some(encrypted_de_type) => {
- if data_elements.len() == 1 {
- match encrypted_de_type {
- // TODO handle length=0 provisioned identity DEs
- EncryptedIdentityDataElementType::Private
- | EncryptedIdentityDataElementType::Trusted
- | EncryptedIdentityDataElementType::Provisioned => {
- combinator::map(
- parse_encrypted_identity_de_contents,
- |(salt, payload)| {
- RawAdvertisement::Ciphertext(EncryptedAdvContents {
- identity_type: encrypted_de_type,
- salt_padder: ldt_np_adv::salt_padder::<16, C>(salt),
- salt,
- ciphertext: payload,
- })
- },
- )(data_elements[0].contents)
- .map(|(_rem, contents)| contents)
- .map_err(|_e| AdvDeserializeError::AdvertisementDeserializeError)
+ if input.is_empty() {
+ return Err(AdvDeserializeError::MissingIdentity);
+ }
+ match parse_de(input) {
+ Ok((rem, identity_de)) => {
+ if let Some(identity_de_type) = identity_de.de_type.try_as_identity_de_type() {
+ match identity_de_type.as_encrypted_identity_de_type() {
+ Some(encrypted_de_type) => {
+ if matches!(parse_de(rem), Err(nom::Err::Error(..))) {
+ match encrypted_de_type {
+ // TODO handle length=0 provisioned identity DEs
+ EncryptedIdentityDataElementType::Private
+ | EncryptedIdentityDataElementType::Trusted
+ | EncryptedIdentityDataElementType::Provisioned => combinator::map(
+ parse_encrypted_identity_de_contents,
+ |(salt, payload)| {
+ RawAdvertisement::Ciphertext(EncryptedAdvContents {
+ identity_type: encrypted_de_type,
+ salt_padder: ldt_np_adv::salt_padder::<16, C>(salt),
+ salt,
+ ciphertext: payload,
+ })
+ },
+ )(
+ identity_de.contents,
+ )
+ .map(|(_rem, contents)| contents)
+ .map_err(|_e| AdvDeserializeError::AdvertisementDeserializeError),
+ }
+ } else {
+ Err(AdvDeserializeError::TooManyTopLevelDataElements)
}
}
- } else {
- Err(AdvDeserializeError::TooManyTopLevelDataElements)
+ // It's an identity de, but not encrypted, so it must be public, and the rest
+ // must be plain
+ None => Ok(RawAdvertisement::Plaintext(PlaintextAdvContents {
+ identity_type: PlaintextIdentityMode::Public,
+ data: rem,
+ })),
}
+ } else {
+ Err(AdvDeserializeError::MissingIdentity)
}
- // It's an identity de, but not encrypted, so it must be public, and the rest must be
- // plain
- None => plain_data_elements(&data_elements[1..]).map(|pdes| {
- RawAdvertisement::Plaintext(PlaintextAdvRawContents {
- identity_type: PlaintextIdentityMode::Public,
- data_elements: pdes,
- })
- }),
}
- } else {
- Err(AdvDeserializeError::MissingIdentity)
+ Err(nom::Err::Error(_)) | Err(nom::Err::Failure(_)) => {
+ Err(AdvDeserializeError::AdvertisementDeserializeError)
+ }
+ Err(nom::Err::Incomplete(_)) => {
+ panic!("Should not hit Incomplete when using nom::complete parsers")
+ }
}
}
@@ -115,27 +121,16 @@
pub(crate) enum AdvDeserializeError {
/// Parsing the overall advertisement or DE structure failed
AdvertisementDeserializeError,
- /// Deserializing an individual DE from its DE contents failed
- DataElementDeserializeError(DataElementDeserializeError),
/// Must not have any other top level data elements if there is an encrypted identity DE
TooManyTopLevelDataElements,
- /// Must not have an identity DE inside an identity DE
- InvalidDataElementHierarchy,
/// Missing identity DE
MissingIdentity,
/// Non-identity DE contents must not be empty
NoPublicDataElements,
}
-/// Parse an advertisement's contents into raw DEs.
-///
-/// Consumes the entire input.
-fn parse_data_elements(adv_contents: &[u8]) -> nom::IResult<&[u8], Vec<RawDataElement>> {
- combinator::all_consuming(multi::many0(parse_de))(adv_contents)
-}
-
/// Parse an individual DE into its header and contents.
-fn parse_de(input: &[u8]) -> nom::IResult<&[u8], RawDataElement> {
+fn parse_de(input: &[u8]) -> nom::IResult<&[u8], RawDataElement, DataElementDeserializeError> {
let (remaining, (de_type, actual_len)) =
combinator::map_opt(number::complete::u8, |de_header| {
// header: LLLLTTTT
@@ -159,22 +154,6 @@
})(remaining)
}
-/// Returns `Err`` if any DEs are not of a plain DE type.
-fn plain_data_elements<'d, D: AsRef<[RawDataElement<'d>]>>(
- data_elements: D,
-) -> Result<Vec<RawPlainDataElement<'d>>, AdvDeserializeError> {
- data_elements
- .as_ref()
- .iter()
- .map(|de| {
- de.de_type
- .try_as_plain_de_type()
- .map(|de_type| RawPlainDataElement { de_type, contents: de.contents })
- })
- .collect::<Option<Vec<_>>>()
- .ok_or(AdvDeserializeError::InvalidDataElementHierarchy)
-}
-
/// Parse legacy encrypted identity DEs (private, trusted, provisioned) into salt and ciphertext
/// (encrypted metadata key and at least 2 bytes of DEs).
///
@@ -199,6 +178,7 @@
#[derive(Debug, PartialEq, Eq)]
struct RawDataElement<'d> {
de_type: DataElementType,
+ /// Byte array payload of the data element, without the DE header.
contents: &'d [u8],
}
@@ -206,30 +186,76 @@
/// level DE representations.
#[derive(Debug, PartialEq, Eq)]
enum RawAdvertisement<'d> {
- Plaintext(PlaintextAdvRawContents<'d>),
+ Plaintext(PlaintextAdvContents<'d>),
Ciphertext(EncryptedAdvContents<'d>),
}
-/// A plaintext advertisement's content in raw DEs but without further deserialization.
-#[derive(Debug, PartialEq, Eq)]
-struct PlaintextAdvRawContents<'d> {
- identity_type: PlaintextIdentityMode,
- data_elements: Vec<RawPlainDataElement<'d>>,
+/// An iterator that parses the given data elements iteratively. In environments
+/// where memory is not severely constrained, it is usually safer to collect
+/// this into `Result<Vec<PlainDataElement>>` so the validity of the whole
+/// advertisement can be checked before proceeding with further processing.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct PlainDeIterator<'d, F>
+where
+ F: PacketFlavor,
+ actions::ActionsDataElement<F>: DataElement,
+{
+ /// Data to be parsed, containing a sequence of data elements in serialized
+ /// form. This should not contain the identity data elements.
+ data: &'d [u8],
+ _marker: PhantomData<F>,
}
-impl<'d> PlaintextAdvRawContents<'d> {
- /// Deserialize the DE contents into per-DE-type structures.
- ///
- /// Returns `Some` if each DE's contents can be successfully deserialized, otherwise `None`.
- fn try_deserialize(&self) -> Result<PlaintextAdvContents, DataElementDeserializeError> {
- self.data_elements
- .iter()
- .map(|de| de.try_deserialize::<Plaintext>())
- .collect::<Result<Vec<_>, _>>()
- .map(|des| PlaintextAdvContents {
- identity_type: self.identity_type,
- data_elements: des,
- })
+impl<'d, F> PlainDeIterator<'d, F>
+where
+ F: PacketFlavor,
+ actions::ActionsDataElement<F>: DataElement,
+{
+ fn raw_de_to_plain_de(
+ raw_de: RawDataElement<'d>,
+ ) -> Result<PlainDataElement<F>, DataElementDeserializeError> {
+ let de_type = raw_de
+ .de_type
+ .try_as_plain_de_type()
+ .ok_or(DataElementDeserializeError::DuplicateIdentityDataElement)?;
+ (RawPlainDataElement { de_type, contents: raw_de.contents }).try_deserialize()
+ }
+}
+
+impl<'d, F> Iterator for PlainDeIterator<'d, F>
+where
+ F: PacketFlavor,
+ actions::ActionsDataElement<F>: DataElement,
+{
+ type Item = Result<PlainDataElement<F>, DataElementDeserializeError>;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ let parse_result = nom::combinator::cut(nom::combinator::map_res(
+ parse_de,
+ Self::raw_de_to_plain_de,
+ ))(self.data);
+ match parse_result {
+ Ok((rem, de)) => {
+ self.data = rem;
+ Some(Ok(de))
+ }
+ Err(nom::Err::Error(_)) => {
+ panic!("All Errors are turned into Failures with `cut` above");
+ }
+ Err(nom::Err::Failure(DataElementDeserializeError::NomError(
+ nom::error::ErrorKind::Eof,
+ ))) => {
+ if self.data.is_empty() {
+ None
+ } else {
+ Some(Err(DataElementDeserializeError::UnexpectedDataRemaining))
+ }
+ }
+ Err(nom::Err::Failure(e)) => Some(Err(e)),
+ Err(nom::Err::Incomplete(_)) => {
+ panic!("Incomplete unexpected when using nom::complete APIs")
+ }
+ }
}
}
@@ -237,6 +263,7 @@
#[derive(Debug, PartialEq, Eq)]
pub(crate) struct RawPlainDataElement<'d> {
de_type: PlainDataElementType,
+ /// Byte array payload of the data element, without the DE header.
contents: &'d [u8],
}
@@ -297,26 +324,15 @@
DecryptError::DeserializeError(AdvDeserializeError::AdvertisementDeserializeError)
})?;
- let (_remaining, raw_des) = combinator::all_consuming(parse_data_elements)(remaining)
- .map_err(|_e| {
- DecryptError::DeserializeError(AdvDeserializeError::AdvertisementDeserializeError)
- })?;
+ let remaining_arr = ArrayView::try_from_slice(remaining)
+ .expect("Max remaining = 31 - 14 = 17 bytes < BLE_ADV_SVC_CONTENT_LEN");
- plain_data_elements(&raw_des)?
- .into_iter()
- .map(|de| de.try_deserialize())
- .collect::<Result<Vec<_>, _>>()
- .map_err(|e| {
- DecryptError::DeserializeError(AdvDeserializeError::DataElementDeserializeError(e))
- })
- .map(|data_elements| {
- DecryptedAdvContents::new(
- self.identity_type,
- ShortMetadataKey(metadata_key),
- self.salt,
- data_elements,
- )
- })
+ Ok(DecryptedAdvContents::new(
+ self.identity_type,
+ ShortMetadataKey(metadata_key),
+ self.salt,
+ remaining_arr,
+ ))
}
}
@@ -345,26 +361,21 @@
/// The contents of a plaintext advertisement after deserializing DE contents
#[derive(Debug, PartialEq, Eq)]
-pub struct PlaintextAdvContents {
+pub struct PlaintextAdvContents<'d> {
identity_type: PlaintextIdentityMode,
- data_elements: Vec<PlainDataElement<Plaintext>>,
+ /// Contents of the advertisement excluding the identity DE
+ data: &'d [u8],
}
-impl PlaintextAdvContents {
+impl<'d> PlaintextAdvContents<'d> {
/// Returns the identity type used for the advertisement
pub fn identity(&self) -> PlaintextIdentityMode {
self.identity_type
}
/// Returns an iterator over the v0 data elements
- pub fn data_elements(&self) -> impl ExactSizeIterator<Item = &PlainDataElement<Plaintext>> {
- self.data_elements.iter()
- }
-
- /// Destructures this V0 plaintext advertisement
- /// into just the contained data elements
- pub fn to_data_elements(self) -> Vec<PlainDataElement<Plaintext>> {
- self.data_elements
+ pub fn data_elements(&self) -> PlainDeIterator<'d, Plaintext> {
+ PlainDeIterator { data: self.data, _marker: PhantomData }
}
}
@@ -374,7 +385,9 @@
identity_type: EncryptedIdentityDataElementType,
metadata_key: ShortMetadataKey,
salt: LegacySalt,
- data_elements: Vec<PlainDataElement<Ciphertext>>,
+ /// The decrypted data in this advertisement. This should be a sequence of
+ /// serialized data elements, excluding the identity DE.
+ data: ArrayView<u8, { BLE_ADV_SVC_CONTENT_LEN }>,
}
impl DecryptedAdvContents {
@@ -383,9 +396,9 @@
identity_type: EncryptedIdentityDataElementType,
metadata_key: ShortMetadataKey,
salt: LegacySalt,
- data_elements: Vec<PlainDataElement<Ciphertext>>,
+ data: ArrayView<u8, { BLE_ADV_SVC_CONTENT_LEN }>,
) -> Self {
- Self { identity_type, metadata_key, salt, data_elements }
+ Self { identity_type, metadata_key, salt, data }
}
/// The type of identity DE used in the advertisement.
@@ -396,8 +409,8 @@
/// Iterator over the data elements in an advertisement, except for any DEs related to resolving
/// the identity or otherwise validating the payload (e.g. any identity DEs like Private
/// Identity).
- pub fn data_elements(&self) -> impl ExactSizeIterator<Item = &PlainDataElement<Ciphertext>> {
- self.data_elements.iter()
+ pub fn data_elements(&self) -> PlainDeIterator<Ciphertext> {
+ PlainDeIterator { data: self.data.as_slice(), _marker: PhantomData }
}
/// The salt used for decryption of this advertisement.
@@ -418,7 +431,7 @@
#[derive(Debug, PartialEq, Eq)]
pub(crate) enum IntermediateAdvContents<'d> {
/// Plaintext advertisements
- Plaintext(PlaintextAdvContents),
+ Plaintext(PlaintextAdvContents<'d>),
/// Ciphertext advertisements
Ciphertext(EncryptedAdvContents<'d>),
}
diff --git a/nearby/presence/np_adv/src/legacy/deserialize/tests.rs b/nearby/presence/np_adv/src/legacy/deserialize/tests.rs
index 4512bf7..5725e0b 100644
--- a/nearby/presence/np_adv/src/legacy/deserialize/tests.rs
+++ b/nearby/presence/np_adv/src/legacy/deserialize/tests.rs
@@ -12,10 +12,12 @@
// See the License for the specific language governing permissions and
// limitations under the License.
+extern crate alloc;
extern crate std;
use super::*;
-use crate::legacy::actions::{ActionBits, ActionsDataElement};
+use crate::legacy::actions::{ActionBits, ActionsDataElement, Finder, NearbyShare};
+use crate::legacy::serialize::id_de_type_as_generic_de_type;
use crate::shared_data::TxPower;
use crate::{
credential::{v0::V0, SimpleBroadcastCryptoMaterial},
@@ -25,18 +27,19 @@
de_type::DeActualLength,
random_data_elements::{random_de_ciphertext, random_de_plaintext},
serialize::{
- encode_de_header_actual_len, id_de_type_as_generic_de_type, AdvBuilder,
- DataElementBundle, Identity, LdtIdentity, ToDataElementBundle as _,
+ encode_de_header_actual_len, AdvBuilder, DataElementBundle, Identity, LdtIdentity,
+ ToDataElementBundle as _,
},
PacketFlavorEnum, BLE_ADV_SVC_CONTENT_LEN,
},
parse_adv_header, shared_data, AdvHeader, PublicIdentity,
};
+use alloc::vec::Vec;
use array_view::ArrayView;
use crypto_provider_default::CryptoProviderImpl;
use init_with::InitWith as _;
use ldt_np_adv::LdtEncrypterXtsAes128;
-use nom::error;
+use nom::error::{self, ErrorKind};
use rand_ext::rand::{prelude::SliceRandom, Rng as _};
use std::vec;
use strum::IntoEnumIterator as _;
@@ -76,22 +79,27 @@
let adv = parse_raw_adv_contents::<CryptoProviderImpl>(&[
0x03, // public identity
0x15, 0x05, // tx power 5
- 0x36, 0x11, 0x12, 0x13, // actions
+ 0x26, 0x00, 0x44, // actions
])
.unwrap();
- assert_eq!(
- RawAdvertisement::Plaintext(PlaintextAdvRawContents {
- identity_type: PlaintextIdentityMode::Public,
- data_elements: vec![
- RawPlainDataElement { de_type: PlainDataElementType::TxPower, contents: &[0x05] },
- RawPlainDataElement {
- de_type: PlainDataElementType::Actions,
- contents: &[0x11, 0x12, 0x13]
- }
- ],
- }),
- adv
- );
+ match adv {
+ RawAdvertisement::Plaintext(plaintext) => {
+ assert_eq!(PlaintextIdentityMode::Public, plaintext.identity_type);
+ let mut action_bits = ActionBits::default();
+ action_bits.set_action(NearbyShare::from(true));
+ action_bits.set_action(Finder::from(true));
+ assert_eq!(
+ vec![
+ PlainDataElement::<Plaintext>::TxPower(TxPowerDataElement::from(
+ TxPower::try_from(5).unwrap()
+ )),
+ PlainDataElement::Actions(ActionsDataElement::from(action_bits)),
+ ],
+ plaintext.data_elements().collect::<Result<Vec<_>, _>>().unwrap(),
+ );
+ }
+ RawAdvertisement::Ciphertext(_) => panic!("adv should be plaintext"),
+ }
}
#[test]
@@ -100,13 +108,16 @@
0x03, // public identity
])
.unwrap();
- assert_eq!(
- RawAdvertisement::Plaintext(PlaintextAdvRawContents {
- identity_type: PlaintextIdentityMode::Public,
- data_elements: vec![],
- }),
- adv
- );
+ match adv {
+ RawAdvertisement::Plaintext(plaintext) => {
+ assert_eq!(PlaintextIdentityMode::Public, plaintext.identity_type);
+ assert_eq!(
+ Vec::<PlainDataElement<Plaintext>>::new(),
+ plaintext.data_elements().collect::<Result<Vec<_>, _>>().unwrap()
+ );
+ }
+ RawAdvertisement::Ciphertext(_) => panic!("adv should be plaintext"),
+ }
}
#[test]
@@ -114,8 +125,8 @@
// battery uses the header length as is
let input = &[0xFB, 0x01, 0x02, 0x03];
assert_eq!(
- nom::Err::Error(error::Error { input: input.as_slice(), code: error::ErrorKind::Eof }),
- parse_data_elements(input).unwrap_err()
+ nom::Err::Error(DataElementDeserializeError::NomError(ErrorKind::MapOpt)),
+ parse_de(input).unwrap_err(),
);
}
@@ -126,10 +137,15 @@
0x03, // another public identity
0x15, 0x03, // tx power de
];
- assert_eq!(
- AdvDeserializeError::InvalidDataElementHierarchy,
- parse_raw_adv_contents::<CryptoProviderImpl>(input).unwrap_err()
- );
+ match parse_raw_adv_contents::<CryptoProviderImpl>(input).unwrap() {
+ RawAdvertisement::Plaintext(content) => {
+ assert_eq!(
+ DataElementDeserializeError::DuplicateIdentityDataElement,
+ content.data_elements().collect::<Result<Vec<_>, _>>().unwrap_err(),
+ );
+ }
+ RawAdvertisement::Ciphertext(_) => panic!("Adv should be plaintext"),
+ }
}
#[test]
@@ -297,35 +313,42 @@
];
assert_eq!(
- nom::Err::Error(error::Error { input: input.as_slice(), code: error::ErrorKind::MapOpt }),
+ nom::Err::Error(DataElementDeserializeError::NomError(ErrorKind::MapOpt)),
parse_de(&input[..]).unwrap_err()
);
}
#[test]
-fn plain_data_elements_matches_plain_des() {
+fn raw_de_to_plain_de_matches_plain_des() {
assert_eq!(
- vec![
- RawPlainDataElement { de_type: PlainDataElementType::TxPower, contents: &[0x01] },
- RawPlainDataElement { de_type: PlainDataElementType::Actions, contents: &[0x02] }
- ],
- plain_data_elements(&[
- RawDataElement { de_type: DataElementType::TxPower, contents: &[0x01] },
- RawDataElement { de_type: DataElementType::Actions, contents: &[0x02] }
- ])
- .unwrap()
+ PlainDataElement::TxPower(TxPowerDataElement::from(TxPower::try_from(1).unwrap())),
+ PlainDeIterator::<Plaintext>::raw_de_to_plain_de(RawDataElement {
+ de_type: DataElementType::TxPower,
+ contents: &[0x01]
+ })
+ .unwrap(),
+ );
+ assert_eq!(
+ PlainDataElement::Actions(ActionsDataElement::from(
+ ActionBits::try_from(0x00400000).unwrap()
+ )),
+ PlainDeIterator::<Plaintext>::raw_de_to_plain_de(RawDataElement {
+ de_type: DataElementType::Actions,
+ contents: &[0x00, 0x40]
+ })
+ .unwrap(),
);
}
#[test]
-fn plain_data_elements_rejects_identity_de_error() {
+fn raw_de_to_plain_de_rejects_identity_de_error() {
for idet in IdentityDataElementType::iter() {
assert_eq!(
- AdvDeserializeError::InvalidDataElementHierarchy,
- plain_data_elements(&[
- RawDataElement { de_type: DataElementType::TxPower, contents: &[0x01] },
- RawDataElement { de_type: id_de_type_as_generic_de_type(idet), contents: &[0x02] }
- ])
+ DataElementDeserializeError::DuplicateIdentityDataElement,
+ PlainDeIterator::<Plaintext>::raw_de_to_plain_de(RawDataElement {
+ de_type: id_de_type_as_generic_de_type(idet),
+ contents: &[0x02],
+ })
.unwrap_err()
);
}
@@ -432,10 +455,11 @@
eac
);
- assert_eq!(
- DecryptedAdvContents { identity_type, metadata_key, salt, data_elements: des },
- eac.try_decrypt(&cipher).unwrap()
- )
+ let contents = eac.try_decrypt(&cipher).unwrap();
+ assert_eq!(identity_type, contents.identity_type);
+ assert_eq!(metadata_key, contents.metadata_key);
+ assert_eq!(salt, contents.salt);
+ assert_eq!(des, contents.data_elements().collect::<Result<Vec<_>, _>>().unwrap());
} else {
panic!("Unexpected variant: {:?}", parsed_adv);
}
@@ -496,17 +520,16 @@
eac
);
+ let decrypted = eac.try_decrypt(&cipher).unwrap();
+ assert_eq!(EncryptedIdentityDataElementType::Private, decrypted.identity_type);
+ assert_eq!(metadata_key, decrypted.metadata_key);
+ assert_eq!(salt, decrypted.salt);
assert_eq!(
- DecryptedAdvContents {
- identity_type: EncryptedIdentityDataElementType::Private,
- metadata_key,
- salt,
- data_elements: vec![PlainDataElement::TxPower(TxPowerDataElement::from(
- TxPower::try_from(3).unwrap()
- ))],
- },
- eac.try_decrypt(&cipher).unwrap()
- )
+ vec![PlainDataElement::TxPower(TxPowerDataElement::from(
+ TxPower::try_from(3).unwrap()
+ ))],
+ decrypted.data_elements().collect::<Result<Vec<_>, _>>().unwrap()
+ );
} else {
panic!("Unexpected variant: {:?}", parsed_adv);
}
@@ -534,16 +557,14 @@
assert_eq!(AdvHeader::V0, header);
let parsed_adv = deserialize_adv_contents::<CryptoProviderImpl>(remaining).unwrap();
- if let IntermediateAdvContents::Plaintext(parc) = parsed_adv {
+ if let IntermediateAdvContents::Plaintext(adv_contents) = parsed_adv {
+ assert_eq!(PlaintextIdentityMode::Public, adv_contents.identity());
assert_eq!(
- PlaintextAdvContents {
- identity_type: PlaintextIdentityMode::Public,
- data_elements: vec![PlainDataElement::Actions(ActionsDataElement::from(
- ActionBits::default()
- ))],
- },
- parc
- )
+ vec![PlainDataElement::<Plaintext>::Actions(ActionsDataElement::from(
+ ActionBits::default()
+ ))],
+ adv_contents.data_elements().collect::<Result<Vec<_>, _>>().unwrap()
+ );
} else {
panic!("Unexpected variant: {:?}", parsed_adv);
}
@@ -670,8 +691,12 @@
let parsed_adv = deserialize_adv_contents::<CryptoProviderImpl>(&adv[1..]).unwrap();
if let IntermediateAdvContents::Ciphertext(eac) = parsed_adv {
assert_eq!(
- DecryptError::DeserializeError(AdvDeserializeError::InvalidDataElementHierarchy),
- eac.try_decrypt(&cipher).unwrap_err()
+ DataElementDeserializeError::DuplicateIdentityDataElement,
+ eac.try_decrypt(&cipher)
+ .unwrap()
+ .data_elements()
+ .collect::<Result<Vec<_>, _>>()
+ .unwrap_err()
)
} else {
panic!("Unexpected variant: {:?}", parsed_adv);
@@ -734,11 +759,11 @@
);
buf.extend_from_slice(contents);
- let raw_de = combinator::all_consuming(parse_de)(&buf).map(|(_remaining, de)| de).unwrap();
-
- let plain_des = plain_data_elements(&[raw_de]).unwrap();
+ let mut plain_des = PlainDeIterator { data: &buf, _marker: PhantomData }
+ .collect::<Result<Vec<_>, _>>()
+ .unwrap();
assert_eq!(1, plain_des.len());
- plain_des.first().unwrap().try_deserialize().unwrap()
+ plain_des.swap_remove(0)
}
fn plaintext_random_adv_contents_round_trip<I: Identity<Flavor = Plaintext>, F: Fn() -> I>(
@@ -774,31 +799,12 @@
parse_raw_adv_contents::<CryptoProviderImpl>(&serialized.as_slice()[1..]).unwrap();
assert_eq!(AdvHeader::V0, header);
- if let RawAdvertisement::Plaintext(parc) = parsed_adv {
+ if let RawAdvertisement::Plaintext(adv_contents) = parsed_adv {
+ assert_eq!(identity_type, adv_contents.identity_type);
assert_eq!(
- PlaintextAdvRawContents {
- identity_type,
- data_elements: de_tuples
- .iter()
- .map(|(_de, de_type, bundle)| RawPlainDataElement {
- de_type: *de_type,
- contents: bundle.contents_as_slice(),
- })
- .collect()
- },
- parc
+ de_tuples.into_iter().map(|(de, _de_type, _bundle)| de).collect::<Vec<_>>(),
+ adv_contents.data_elements().collect::<Result<Vec<_>, _>>().unwrap(),
);
-
- assert_eq!(
- PlaintextAdvContents {
- identity_type,
- data_elements: de_tuples
- .into_iter()
- .map(|(de, _de_type, _bundle)| de)
- .collect(),
- },
- parc.try_deserialize().unwrap()
- )
} else {
panic!("Unexpected variant: {:?}", parsed_adv);
}
diff --git a/nearby/presence/np_adv/src/lib.rs b/nearby/presence/np_adv/src/lib.rs
index 45207ff..1c42796 100644
--- a/nearby/presence/np_adv/src/lib.rs
+++ b/nearby/presence/np_adv/src/lib.rs
@@ -21,6 +21,7 @@
#![forbid(unsafe_code)]
#![deny(missing_docs)]
+#[cfg(any(test, feature = "alloc"))]
extern crate alloc;
extern crate core;
use crate::{
@@ -39,20 +40,22 @@
},
};
+#[cfg(any(test, feature = "alloc"))]
use alloc::vec::Vec;
+use array_vec::ArrayVecOption;
#[cfg(feature = "devtools")]
use array_view::ArrayView;
-use core::borrow::BorrowMut;
use core::fmt::Debug;
use crypto_provider::CryptoProvider;
-use deserialization_arena::DeserializationArena;
-
+use deserialization_arena::{DeserializationArena, DeserializationArenaAllocator};
#[cfg(feature = "devtools")]
use extended::NP_ADV_MAX_SECTION_LEN;
+use extended::NP_V1_ADV_MAX_ENCRYPTED_SECTION_COUNT;
use legacy::{data_elements::DataElementDeserializeError, deserialize::AdvDeserializeError};
use nom::{combinator, number};
pub use strum;
+mod array_vec;
pub mod credential;
pub mod de_type;
#[cfg(test)]
@@ -76,21 +79,7 @@
/// Parse, deserialize, decrypt, and validate a complete NP advertisement (the entire contents of
/// the service data for the NP UUID).
pub fn deserialize_advertisement<'adv, 'cred, B, P>(
- mut arena: impl BorrowMut<DeserializationArena<'adv>>,
- adv: &'adv [u8],
- cred_book: &'cred B,
-) -> Result<DeserializedAdvertisement<'adv, B::Matched>, AdvDeserializationError>
-where
- B: CredentialBook<'cred>,
- P: CryptoProvider,
-{
- // Turn `impl BorrowMut` into the concrete `&mut` reference so that the compiler does not need
- // to duplicate the function code for different concrete types.
- deserialize_advertisement_impl::<B, P>(arena.borrow_mut(), adv, cred_book)
-}
-
-fn deserialize_advertisement_impl<'adv, 'cred, B, P>(
- arena: &mut DeserializationArena<'adv>,
+ arena: DeserializationArena<'adv>,
adv: &'adv [u8],
cred_book: &'cred B,
) -> Result<DeserializedAdvertisement<'adv, B::Matched>, AdvDeserializationError>
@@ -128,15 +117,6 @@
ParseError,
/// No suitable credential found to decrypt the given section.
NoMatchingCredentials,
- /// Given Arena is not large enough to hold the decrypted data.
- ArenaOutOfSpace,
-}
-
-#[cfg(feature = "devtools")]
-impl From<ArenaOutOfSpace> for AdvDecryptionError {
- fn from(_: ArenaOutOfSpace) -> Self {
- Self::ArenaOutOfSpace
- }
}
/// Decrypt, but do not further deserialize the v1 bytes, intended for developer tooling uses only.
@@ -144,7 +124,7 @@
/// structured format and provides extra type safety.
#[cfg(feature = "devtools")]
pub fn deser_decrypt_v1_section_bytes_for_dev_tools<'adv, 'cred, B, P>(
- arena: &mut DeserializationArena<'adv>,
+ arena: DeserializationArena<'adv>,
cred_book: &'cred B,
header_byte: u8,
section_bytes: &'adv [u8],
@@ -161,21 +141,22 @@
IntermediateSection::Ciphertext(section) => section,
};
+ let mut allocator = arena.into_allocator();
for (crypto_material, _) in cred_book.v1_iter() {
if let Some(plaintext) = cipher_section
- .try_resolve_identity_and_decrypt::<_, P>(arena.borrow_mut(), &crypto_material)
+ .try_resolve_identity_and_decrypt::<_, P>(&mut allocator, &crypto_material)
{
- return plaintext
- .map(|pt| {
- let encryption_scheme = match cipher_section {
- CiphertextSection::SignatureEncryptedIdentity(_) => {
- V1EncryptionScheme::Signature
- }
- CiphertextSection::MicEncryptedIdentity(_) => V1EncryptionScheme::Mic,
- };
- (pt, encryption_scheme)
- })
- .map_err(|e| e.into());
+ let pt = plaintext.expect(concat!(
+ "Should not run out of space because DeserializationArenaAllocator is big ",
+ "enough to hold a single advertisement, and we exit immediately upon ",
+ "successful decryption",
+ ));
+
+ let encryption_scheme = match cipher_section {
+ CiphertextSection::SignatureEncryptedIdentity(_) => V1EncryptionScheme::Signature,
+ CiphertextSection::MicEncryptedIdentity(_) => V1EncryptionScheme::Mic,
+ };
+ return Ok((pt, encryption_scheme));
}
}
Err(AdvDecryptionError::NoMatchingCredentials)
@@ -197,8 +178,14 @@
/// section ordering as they appeared within the original advertisement to ensure
/// that the fully-deserialized advertisement may be correctly reconstructed.
struct SectionsInProcessing<'adv, M: MatchedCredential> {
- deserialized_sections: Vec<(usize, V1DeserializedSection<'adv, M>)>,
- encrypted_sections: Vec<(usize, ResolvableCiphertextSection<'adv>)>,
+ deserialized_sections: ArrayVecOption<
+ (usize, V1DeserializedSection<'adv, M>),
+ { NP_V1_ADV_MAX_ENCRYPTED_SECTION_COUNT },
+ >,
+ encrypted_sections: ArrayVecOption<
+ (usize, ResolvableCiphertextSection<'adv>),
+ { NP_V1_ADV_MAX_ENCRYPTED_SECTION_COUNT },
+ >,
malformed_sections_count: usize,
}
@@ -214,8 +201,8 @@
parse_sections(header, remaining).map_err(|_| AdvDeserializationError::ParseError {
details_hazmat: AdvDeserializationErrorDetailsHazmat::AdvertisementDeserializeError,
})?;
- let mut deserialized_sections = Vec::new();
- let mut encrypted_sections = Vec::new();
+ let mut deserialized_sections = ArrayVecOption::default();
+ let mut encrypted_sections = ArrayVecOption::default();
// keep track of ordering for later sorting during `self.finished_with_decryption_attempts()`.
for (idx, s) in int_sections.into_iter().enumerate() {
match s {
@@ -247,7 +234,7 @@
/// the cost of iterating over sections-in-memory.
fn try_decrypt_with_credential<C: V1DiscoveryCryptoMaterial, P: CryptoProvider>(
&mut self,
- arena: &mut DeserializationArena<'adv>,
+ arena: &mut DeserializationArenaAllocator<'adv>,
crypto_material: C,
match_data: M,
) -> Result<(), ArenaOutOfSpace> {
@@ -278,14 +265,14 @@
let deserialization_result = match §ion.ciphertext_section {
CiphertextSection::SignatureEncryptedIdentity(c) => c
.try_deserialize(
- arena.borrow_mut(),
+ arena,
identity_match,
&crypto_material.signed_verification_material::<P>(),
)
.map_err(SectionDeserializeError::from),
CiphertextSection::MicEncryptedIdentity(c) => c
.try_deserialize(
- arena.borrow_mut(),
+ arena,
identity_match,
&crypto_material.unsigned_verification_material::<P>(),
)
@@ -351,7 +338,7 @@
/// Deserialize and decrypt the contents of a v1 adv after the version header
fn deser_decrypt_v1<'adv, 'cred, B, P>(
- arena: &mut DeserializationArena<'adv>,
+ arena: DeserializationArena<'adv>,
cred_book: &'cred B,
remaining: &'adv [u8],
header: V1Header,
@@ -365,14 +352,18 @@
header, remaining,
)?;
+ let mut allocator = arena.into_allocator();
+
// Hot loop
// We assume that iterating credentials is more expensive than iterating sections
for (crypto_material, match_data) in cred_book.v1_iter() {
- sections_in_processing.try_decrypt_with_credential::<_, P>(
- arena.borrow_mut(),
- crypto_material,
- match_data,
- )?;
+ sections_in_processing
+ .try_decrypt_with_credential::<_, P>(&mut allocator, crypto_material, match_data)
+ .expect(concat!(
+ "Should not run out of space because DeserializationArenaAllocator is big ",
+ "enough to hold a single advertisement, and we exit immediately upon ",
+ "successful decryption",
+ ));
if sections_in_processing.resolved_all_identities() {
// No need to consider the other credentials
break;
@@ -382,12 +373,12 @@
}
/// Deserialize and decrypt the contents of a v0 adv after the version header
-fn deser_decrypt_v0<'a, B, P>(
- cred_book: &'a B,
- remaining: &[u8],
-) -> Result<V0AdvertisementContents<B::Matched>, AdvDeserializationError>
+fn deser_decrypt_v0<'adv, 'cred, B, P>(
+ cred_book: &'cred B,
+ remaining: &'adv [u8],
+) -> Result<V0AdvertisementContents<'adv, B::Matched>, AdvDeserializationError>
where
- B: CredentialBook<'a>,
+ B: CredentialBook<'cred>,
P: CryptoProvider,
{
let contents = legacy::deserialize::deserialize_adv_contents::<P>(remaining)?;
@@ -449,11 +440,12 @@
}
/// An NP advertisement with its header parsed.
+#[allow(clippy::large_enum_variant)]
#[derive(Debug, PartialEq, Eq)]
pub enum DeserializedAdvertisement<'adv, M: MatchedCredential> {
/// V0 header has all reserved bits, so there is no data to represent other than the version
/// itself.
- V0(V0AdvertisementContents<M>),
+ V0(V0AdvertisementContents<'adv, M>),
/// V1 advertisement
V1(V1AdvertisementContents<'adv, M>),
}
@@ -461,7 +453,7 @@
impl<'adv, M: MatchedCredential> DeserializedAdvertisement<'adv, M> {
/// Attempts to cast this deserialized advertisement into the `V0AdvertisementContents`
/// variant. If the underlying advertisement is not V0, this will instead return `None`.
- pub fn into_v0(self) -> Option<V0AdvertisementContents<M>> {
+ pub fn into_v0(self) -> Option<V0AdvertisementContents<'adv, M>> {
match self {
Self::V0(x) => Some(x),
_ => None,
@@ -480,18 +472,26 @@
/// The contents of a deserialized and decrypted V1 advertisement.
#[derive(Debug, PartialEq, Eq)]
pub struct V1AdvertisementContents<'adv, M: MatchedCredential> {
- sections: Vec<V1DeserializedSection<'adv, M>>,
+ sections: ArrayVecOption<V1DeserializedSection<'adv, M>, NP_V1_ADV_MAX_ENCRYPTED_SECTION_COUNT>,
invalid_sections: usize,
}
impl<'adv, M: MatchedCredential> V1AdvertisementContents<'adv, M> {
- fn new(sections: Vec<V1DeserializedSection<'adv, M>>, invalid_sections: usize) -> Self {
+ fn new(
+ sections: ArrayVecOption<
+ V1DeserializedSection<'adv, M>,
+ NP_V1_ADV_MAX_ENCRYPTED_SECTION_COUNT,
+ >,
+ invalid_sections: usize,
+ ) -> Self {
Self { sections, invalid_sections }
}
/// Destructures this V1 advertisement into just the sections
/// which could be successfully deserialized and decrypted
- pub fn into_sections(self) -> Vec<V1DeserializedSection<'adv, M>> {
+ pub fn into_sections(
+ self,
+ ) -> ArrayVecOption<V1DeserializedSection<'adv, M>, NP_V1_ADV_MAX_ENCRYPTED_SECTION_COUNT> {
self.sections
}
@@ -508,9 +508,9 @@
/// Advertisement content that was either already plaintext or has been decrypted.
#[derive(Debug, PartialEq, Eq)]
-pub enum V0AdvertisementContents<M: MatchedCredential> {
+pub enum V0AdvertisementContents<'adv, M: MatchedCredential> {
/// Contents of an originally plaintext advertisement
- Plaintext(PlaintextAdvContents),
+ Plaintext(PlaintextAdvContents<'adv>),
/// Contents that was ciphertext in the original advertisement, and has been decrypted
/// with the credential in the [MatchedCredential]
Decrypted(WithMatchedCredential<M, DecryptedAdvContents>),
@@ -650,14 +650,6 @@
/// [AdvDeserializationErrorDetailsHazmat] before using this field.
details_hazmat: AdvDeserializationErrorDetailsHazmat,
},
- /// The given arena is not large enough to hold the decrypted data.
- ArenaOutOfSpace,
-}
-
-impl From<ArenaOutOfSpace> for AdvDeserializationError {
- fn from(_: ArenaOutOfSpace) -> Self {
- Self::ArenaOutOfSpace
- }
}
impl Debug for AdvDeserializationError {
@@ -665,7 +657,6 @@
match self {
AdvDeserializationError::HeaderParseError => write!(f, "HeaderParseError"),
AdvDeserializationError::ParseError { .. } => write!(f, "ParseError"),
- AdvDeserializationError::ArenaOutOfSpace => write!(f, "ArenaOutOfSpace"),
}
}
}
@@ -699,24 +690,12 @@
AdvDeserializationErrorDetailsHazmat::AdvertisementDeserializeError,
}
}
- AdvDeserializeError::DataElementDeserializeError(e) => {
- AdvDeserializationError::ParseError {
- details_hazmat:
- AdvDeserializationErrorDetailsHazmat::V0DataElementDeserializeError(e),
- }
- }
AdvDeserializeError::TooManyTopLevelDataElements => {
AdvDeserializationError::ParseError {
details_hazmat:
AdvDeserializationErrorDetailsHazmat::TooManyTopLevelDataElements,
}
}
- AdvDeserializeError::InvalidDataElementHierarchy => {
- AdvDeserializationError::ParseError {
- details_hazmat:
- AdvDeserializationErrorDetailsHazmat::InvalidDataElementHierarchy,
- }
- }
AdvDeserializeError::MissingIdentity => AdvDeserializationError::ParseError {
details_hazmat: AdvDeserializationErrorDetailsHazmat::MissingIdentity,
},
diff --git a/nearby/presence/np_adv/tests/examples_v0.rs b/nearby/presence/np_adv/tests/examples_v0.rs
index 27ea7c5..8310531 100644
--- a/nearby/presence/np_adv/tests/examples_v0.rs
+++ b/nearby/presence/np_adv/tests/examples_v0.rs
@@ -35,8 +35,9 @@
0,
CryptoProviderImpl,
>(&[], &[]);
+ let arena = deserialization_arena!();
let adv = deserialize_advertisement::<_, CryptoProviderImpl>(
- deserialization_arena!(),
+ arena,
&[
0x00, // adv header
0x03, // public identity
@@ -52,10 +53,10 @@
V0AdvertisementContents::Plaintext(p) => {
assert_eq!(PlaintextIdentityMode::Public, p.identity());
assert_eq!(
- vec![&PlainDataElement::TxPower(TxPowerDataElement::from(
+ vec![PlainDataElement::TxPower(TxPowerDataElement::from(
TxPower::try_from(3).unwrap()
- )),],
- p.data_elements().collect::<Vec<_>>()
+ ))],
+ p.data_elements().collect::<Result<Vec<_>, _>>().unwrap()
);
}
_ => panic!("this example is plaintext"),
@@ -154,7 +155,7 @@
assert_eq!(metadata_key, decrypted.metadata_key());
assert_eq!(
- vec![&PlainDataElement::TxPower(TxPowerDataElement::from(TxPower::try_from(3).unwrap())),],
- decrypted.data_elements().collect::<Vec<_>>()
+ vec![PlainDataElement::TxPower(TxPowerDataElement::from(TxPower::try_from(3).unwrap())),],
+ decrypted.data_elements().collect::<Result<Vec<_>, _>>().unwrap(),
);
}
diff --git a/nearby/presence/np_c_ffi/Cargo.lock b/nearby/presence/np_c_ffi/Cargo.lock
index f55cf29..796292b 100644
--- a/nearby/presence/np_c_ffi/Cargo.lock
+++ b/nearby/presence/np_c_ffi/Cargo.lock
@@ -473,7 +473,6 @@
name = "handle_map"
version = "0.1.0"
dependencies = [
- "crypto_provider",
"lock_adapter",
]
diff --git a/nearby/presence/np_cpp_ffi/tests/CMakeLists.txt b/nearby/presence/np_cpp_ffi/tests/CMakeLists.txt
index bddda64..7ca9eb0 100644
--- a/nearby/presence/np_cpp_ffi/tests/CMakeLists.txt
+++ b/nearby/presence/np_cpp_ffi/tests/CMakeLists.txt
@@ -17,9 +17,10 @@
deserialize_result_tests.cc
deserialize_v0_tests.cc
deserialize_v1_tests.cc
- global_config_tests.cc
credential_book_tests.cc
byte_buffer_tests.cc
+ np_cpp_test.h
+ np_cpp_test.cc
)
target_link_libraries(
diff --git a/nearby/presence/np_cpp_ffi/tests/credential_book_tests.cc b/nearby/presence/np_cpp_ffi/tests/credential_book_tests.cc
index 53218ee..3a32904 100644
--- a/nearby/presence/np_cpp_ffi/tests/credential_book_tests.cc
+++ b/nearby/presence/np_cpp_ffi/tests/credential_book_tests.cc
@@ -14,13 +14,27 @@
#include "nearby_protocol.h"
#include "shared_test_util.h"
+#include "np_cpp_test.h"
#include "gtest/gtest.h"
-TEST(NpFfiCredentialBookTests, TestMoveConstructor) {
+TEST_F(NpCppTest, TestSetMaxCredBooks) {
+ auto book1_result = nearby_protocol::CredentialBook::TryCreate();
+ ASSERT_TRUE(book1_result.ok());
+
+ auto book2_result = nearby_protocol::CredentialBook::TryCreate();
+ ASSERT_TRUE(book2_result.ok());
+
+ auto book3_result = nearby_protocol::CredentialBook::TryCreate();
+ ASSERT_FALSE(book3_result.ok());
+ ASSERT_TRUE(absl::IsResourceExhausted(book3_result.status()));
+}
+
+TEST_F(NpCppTest, TestMoveConstructor) {
auto book = nearby_protocol::CredentialBook::TryCreate().value();
auto deserialize_result =
- nearby_protocol::Deserializer::DeserializeAdvertisement(V0AdvSimple, book);
+ nearby_protocol::Deserializer::DeserializeAdvertisement(V0AdvSimple,
+ book);
ASSERT_EQ(deserialize_result.GetKind(),
np_ffi::internal::DeserializeAdvertisementResultKind::V0);
@@ -47,10 +61,11 @@
"");
}
-TEST(NpFfiCredentialBookTests, TestMoveAssignment) {
+TEST_F(NpCppTest, TestMoveAssignment) {
auto book = nearby_protocol::CredentialBook::TryCreate().value();
auto deserialize_result =
- nearby_protocol::Deserializer::DeserializeAdvertisement(V0AdvSimple, book);
+ nearby_protocol::Deserializer::DeserializeAdvertisement(V0AdvSimple,
+ book);
ASSERT_EQ(deserialize_result.GetKind(),
np_ffi::internal::DeserializeAdvertisementResultKind::V0);
diff --git a/nearby/presence/np_cpp_ffi/tests/deserialize_result_tests.cc b/nearby/presence/np_cpp_ffi/tests/deserialize_result_tests.cc
index 54872c6..737fd18 100644
--- a/nearby/presence/np_cpp_ffi/tests/deserialize_result_tests.cc
+++ b/nearby/presence/np_cpp_ffi/tests/deserialize_result_tests.cc
@@ -14,14 +14,15 @@
#include "nearby_protocol.h"
#include "shared_test_util.h"
+#include "np_cpp_test.h"
#include "absl/strings/escaping.h"
#include "gtest/gtest.h"
-TEST(NpFfiDeserializeResultTests, TestResultMoveConstructor) {
+TEST_F(NpCppTest, TestResultMoveConstructor) {
auto book = nearby_protocol::CredentialBook::TryCreate().value();
- auto result =
- nearby_protocol::Deserializer::DeserializeAdvertisement(V0AdvSimple, book);
+ auto result = nearby_protocol::Deserializer::DeserializeAdvertisement(
+ V0AdvSimple, book);
ASSERT_EQ(result.GetKind(),
np_ffi::internal::DeserializeAdvertisementResultKind::V0);
@@ -49,7 +50,7 @@
ASSERT_DEATH([[maybe_unused]] auto failure = moved_again.GetKind(), "");
}
-TEST(NpFfiDeserializeResultTests, DeserializeFromStringView) {
+TEST_F(NpCppTest, DeserializeFromStringView) {
auto bytes = absl::HexStringToBytes("00031503");
auto buffer = nearby_protocol::ByteBuffer<255>::CopyFrom(bytes);
ASSERT_TRUE(buffer.ok());
@@ -86,16 +87,16 @@
ASSERT_EQ(tx_power.tx_power, 3);
}
-TEST(NpFfiDeserializeResultTests, TestResultMoveAssignment) {
+TEST_F(NpCppTest, TestResultMoveAssignment) {
auto book = nearby_protocol::CredentialBook::TryCreate().value();
- auto result =
- nearby_protocol::Deserializer::DeserializeAdvertisement(V0AdvSimple, book);
+ auto result = nearby_protocol::Deserializer::DeserializeAdvertisement(
+ V0AdvSimple, book);
ASSERT_EQ(result.GetKind(),
np_ffi::internal::DeserializeAdvertisementResultKind::V0);
// create a second result
- auto another_result =
- nearby_protocol::Deserializer::DeserializeAdvertisement(V0AdvSimple, book);
+ auto another_result = nearby_protocol::Deserializer::DeserializeAdvertisement(
+ V0AdvSimple, book);
ASSERT_EQ(another_result.GetKind(),
np_ffi::internal::DeserializeAdvertisementResultKind::V0);
@@ -119,10 +120,7 @@
ASSERT_DEATH([[maybe_unused]] auto failure = moved_again.GetKind(), "");
}
-TEST(NpFfiDeserializeResultTests, TestInvalidPayloadHeader) {
- ASSERT_TRUE(
- nearby_protocol::GlobalConfig::SetPanicHandler(test_panic_handler));
-
+TEST_F(NpCppTest, TestInvalidPayloadHeader) {
// An invalid header result should result in error
nearby_protocol::RawAdvertisementPayload InvalidHeaderPayload(
nearby_protocol::ByteBuffer<255>({1, {0xFF}}));
@@ -141,10 +139,7 @@
"");
}
-TEST(NpFfiDeserializeResultTests, TestInvalidV0Cast) {
- ASSERT_TRUE(
- nearby_protocol::GlobalConfig::SetPanicHandler(test_panic_handler));
-
+TEST_F(NpCppTest, TestInvalidV0Cast) {
auto maybe_credential_book = nearby_protocol::CredentialBook::TryCreate();
auto deserialize_result =
nearby_protocol::Deserializer::DeserializeAdvertisement(
@@ -156,10 +151,7 @@
"");
}
-TEST(NpFfiDeserializeResultTests, TestInvalidV1Cast) {
- ASSERT_TRUE(
- nearby_protocol::GlobalConfig::SetPanicHandler(test_panic_handler));
-
+TEST_F(NpCppTest, TestInvalidV1Cast) {
// Create an empty credential book and verify that is is successful
auto maybe_credential_book = nearby_protocol::CredentialBook::TryCreate();
ASSERT_TRUE(maybe_credential_book.ok());
@@ -173,7 +165,7 @@
"");
}
-TEST(NpFfiDeserializeResultTests, V0UseResultTwice) {
+TEST_F(NpCppTest, V0UseResultTwice) {
auto book_result = nearby_protocol::CredentialBook::TryCreate();
ASSERT_TRUE(book_result.ok());
@@ -191,7 +183,7 @@
"");
}
-TEST(NpFfiDeserializeResultTests, V1UseResultTwice) {
+TEST_F(NpCppTest, V1UseResultTwice) {
auto book_result = nearby_protocol::CredentialBook::TryCreate();
ASSERT_TRUE(book_result.ok());
@@ -209,7 +201,7 @@
"");
}
-TEST(NpFfiDeserializeResultTests, IntoV0AfterOutOfScope) {
+TEST_F(NpCppTest, IntoV0AfterOutOfScope) {
auto book_result = nearby_protocol::CredentialBook::TryCreate();
ASSERT_TRUE(book_result.ok());
@@ -228,7 +220,7 @@
"");
}
-TEST(NpFfiDeserializeResultTests, IntoV1AfterOutOfScope) {
+TEST_F(NpCppTest, IntoV1AfterOutOfScope) {
auto book_result = nearby_protocol::CredentialBook::TryCreate();
ASSERT_TRUE(book_result.ok());
@@ -247,7 +239,7 @@
"");
}
-TEST(NpFfiDeserializeV0Tests, V0ResultKindAfterOutOfScope) {
+TEST_F(NpCppTest, V0ResultKindAfterOutOfScope) {
auto book_result = nearby_protocol::CredentialBook::TryCreate();
ASSERT_TRUE(book_result.ok());
@@ -266,7 +258,7 @@
{ [[maybe_unused]] auto failure = deserialize_result.GetKind(); }, "");
}
-TEST(NpFfiDeserializeResultTests, V1ResultKindAfterOutOfScope) {
+TEST_F(NpCppTest, V1ResultKindAfterOutOfScope) {
auto book_result = nearby_protocol::CredentialBook::TryCreate();
ASSERT_TRUE(book_result.ok());
diff --git a/nearby/presence/np_cpp_ffi/tests/deserialize_v0_tests.cc b/nearby/presence/np_cpp_ffi/tests/deserialize_v0_tests.cc
index cd95c48..e2a10a0 100644
--- a/nearby/presence/np_cpp_ffi/tests/deserialize_v0_tests.cc
+++ b/nearby/presence/np_cpp_ffi/tests/deserialize_v0_tests.cc
@@ -14,10 +14,24 @@
#include "nearby_protocol.h"
#include "shared_test_util.h"
+#include "np_cpp_test.h"
#include "gtest/gtest.h"
-TEST(NpFfiDeserializeV0Tests, V0SingleDataElementTxPower) {
+TEST_F(NpCppTest, InvalidCast) {
+ auto book = nearby_protocol::CredentialBook::TryCreate().value();
+ auto deserialize_result =
+ nearby_protocol::Deserializer::DeserializeAdvertisement(V0AdvSimple, book);
+ ASSERT_EQ(deserialize_result.GetKind(),
+ np_ffi::internal::DeserializeAdvertisementResultKind::V0);
+
+ // Now try to cast the result into the wrong type and verify the process
+ // aborts
+ ASSERT_DEATH({ [[maybe_unused]] auto failure = deserialize_result.IntoV1(); },
+ "");
+}
+
+TEST_F(NpCppTest, V0SingleDataElementTxPower) {
nearby_protocol::RawAdvertisementPayload adv(
nearby_protocol::ByteBuffer<255>({
4,
@@ -56,7 +70,7 @@
ASSERT_EQ(tx_power.tx_power, 3);
}
-TEST(NpFfiDeserializeV0Tests, V0LengthOneActionsDataElement) {
+TEST_F(NpCppTest, V0LengthOneActionsDataElement) {
nearby_protocol::RawAdvertisementPayload adv(
nearby_protocol::ByteBuffer<255>({
4,
@@ -92,10 +106,10 @@
ASSERT_EQ(de.GetKind(), nearby_protocol::V0DataElementKind::Actions);
auto actions = de.AsActions();
- ASSERT_EQ(actions.GetAsU32(), 0);
+ ASSERT_EQ(actions.GetAsU32(), (uint32_t)0);
}
-TEST(NpFfiDeserializeV0Tests, V0LengthTwoActionsDataElement) {
+TEST_F(NpCppTest, V0LengthTwoActionsDataElement) {
nearby_protocol::RawAdvertisementPayload adv(
nearby_protocol::ByteBuffer<255>({
5,
@@ -150,7 +164,7 @@
ASSERT_EQ(actions.GetContextSyncSequenceNumber(), 0xD);
}
-TEST(NpFfiDeserializeV0Tests, V0MultipleDataElements) {
+TEST_F(NpCppTest, V0MultipleDataElements) {
nearby_protocol::RawAdvertisementPayload adv(nearby_protocol::ByteBuffer<255>(
{7,
{
@@ -195,11 +209,11 @@
ASSERT_EQ(second_de.GetKind(), nearby_protocol::V0DataElementKind::Actions);
auto actions = second_de.AsActions();
- ASSERT_EQ(actions.GetAsU32(), 0x00460000);
- ASSERT_EQ(actions.GetContextSyncSequenceNumber(), 0);
+ ASSERT_EQ(actions.GetAsU32(), (uint32_t)0x00460000);
+ ASSERT_EQ(actions.GetContextSyncSequenceNumber(), (uint8_t)0);
}
-TEST(NpFfiDeserializeV0Tests, V0EmptyPayload) {
+TEST_F(NpCppTest, V0EmptyPayload) {
auto maybe_credential_book = nearby_protocol::CredentialBook::TryCreate();
ASSERT_TRUE(maybe_credential_book.ok());
auto deserialize_result =
@@ -210,10 +224,10 @@
nearby_protocol::DeserializeAdvertisementResultKind::Error);
}
-TEST(NpFfiDeserializeV0Tests, TestV0AdvMoveConstructor) {
+TEST_F(NpCppTest, TestV0AdvMoveConstructor) {
auto book = nearby_protocol::CredentialBook::TryCreate().value();
- auto result =
- nearby_protocol::Deserializer::DeserializeAdvertisement(V0AdvSimple, book);
+ auto result = nearby_protocol::Deserializer::DeserializeAdvertisement(
+ V0AdvSimple, book);
ASSERT_EQ(result.GetKind(),
np_ffi::internal::DeserializeAdvertisementResultKind::V0);
auto adv = result.IntoV0();
@@ -237,17 +251,17 @@
ASSERT_DEATH([[maybe_unused]] auto failure = moved_again.GetKind(), "");
}
-TEST(NpFfiDeserializeResultTests, TestV0AdvMoveAssignment) {
+TEST_F(NpCppTest, TestV0AdvMoveAssignment) {
auto book = nearby_protocol::CredentialBook::TryCreate().value();
- auto result =
- nearby_protocol::Deserializer::DeserializeAdvertisement(V0AdvSimple, book);
+ auto result = nearby_protocol::Deserializer::DeserializeAdvertisement(
+ V0AdvSimple, book);
ASSERT_EQ(result.GetKind(),
np_ffi::internal::DeserializeAdvertisementResultKind::V0);
auto adv = result.IntoV0();
// create a second result
- auto another_result =
- nearby_protocol::Deserializer::DeserializeAdvertisement(V0AdvSimple, book);
+ auto another_result = nearby_protocol::Deserializer::DeserializeAdvertisement(
+ V0AdvSimple, book);
ASSERT_EQ(another_result.GetKind(),
np_ffi::internal::DeserializeAdvertisementResultKind::V0);
auto adv2 = another_result.IntoV0();
@@ -270,39 +284,48 @@
ASSERT_DEATH([[maybe_unused]] auto failure = moved_again.GetKind(), "");
}
-TEST(NpFfiDeserializeV0Tests, V0AdvDestructor) {
- nearby_protocol::GlobalConfig::SetMaxNumDeserializedV0Advertisements(1);
+static nearby_protocol::DeserializeAdvertisementResult
+CreateAdv(nearby_protocol::CredentialBook &book) {
+ auto adv = nearby_protocol::Deserializer::DeserializeAdvertisement(
+ V0AdvSimple, book);
+ return adv;
+}
+
+TEST_F(NpCppTest, V0AdvDestructor) {
auto book_result = nearby_protocol::CredentialBook::TryCreate();
ASSERT_TRUE(book_result.ok());
{
- auto deserialize_result =
- nearby_protocol::Deserializer::DeserializeAdvertisement(
- V0AdvSimple, book_result.value());
+ auto deserialize_result = CreateAdv(book_result.value());
+ auto deserialize_result2 = CreateAdv(book_result.value());
+ // Deserialize 2 advertisements, which will take up 2 slots in the handle
+ // map
ASSERT_EQ(deserialize_result.GetKind(),
np_ffi::internal::DeserializeAdvertisementResultKind::V0);
+ ASSERT_EQ(deserialize_result2.GetKind(),
+ np_ffi::internal::DeserializeAdvertisementResultKind::V0);
// Going over max amount should result in error
- auto deserialize_result2 =
+ auto deserialize_result3 =
nearby_protocol::Deserializer::DeserializeAdvertisement(
V0AdvSimple, book_result.value());
- ASSERT_EQ(deserialize_result2.GetKind(),
+ ASSERT_EQ(deserialize_result3.GetKind(),
np_ffi::internal::DeserializeAdvertisementResultKind::Error);
- // Calling IntoV0() should move the underlying resources into the v0 object
- // when both go out of scope only one should be freed
+ // Calling IntoV0() should move the underlying resources into the v0
+ // object when both go out of scope only one should be freed
auto v0_adv = deserialize_result.IntoV0();
}
// Now that the first v0 adv is out of scope, it should be de-allocated which
// will create room for one more to be created.
- auto deserialize_result3 =
+ auto deserialize_result =
nearby_protocol::Deserializer::DeserializeAdvertisement(
V0AdvSimple, book_result.value());
- ASSERT_EQ(deserialize_result3.GetKind(),
+ ASSERT_EQ(deserialize_result.GetKind(),
np_ffi::internal::DeserializeAdvertisementResultKind::V0);
}
-TEST(NpFfiDeserializeV0Tests, V0AdvUseAfterMove) {
+TEST_F(NpCppTest, V0AdvUseAfterMove) {
auto maybe_credential_book = nearby_protocol::CredentialBook::TryCreate();
ASSERT_TRUE(maybe_credential_book.ok());
auto deserialize_result =
@@ -322,10 +345,10 @@
ASSERT_DEATH([[maybe_unused]] auto failure = v0_adv.IntoLegible(), "");
}
-TEST(NpFfiDeserializeV0Tests, TestLegibleAdvMoveConstructor) {
+TEST_F(NpCppTest, TestLegibleAdvMoveConstructor) {
auto book = nearby_protocol::CredentialBook::TryCreate().value();
- auto result =
- nearby_protocol::Deserializer::DeserializeAdvertisement(V0AdvSimple, book);
+ auto result = nearby_protocol::Deserializer::DeserializeAdvertisement(
+ V0AdvSimple, book);
ASSERT_EQ(result.GetKind(),
np_ffi::internal::DeserializeAdvertisementResultKind::V0);
auto legible = result.IntoV0().IntoLegible();
@@ -356,17 +379,17 @@
ASSERT_DEATH([[maybe_unused]] auto failure = moved_again.IntoPayload(), "");
}
-TEST(NpFfiDeserializeResultTests, TestLegibleAdvMoveAssignment) {
+TEST_F(NpCppTest, TestLegibleAdvMoveAssignment) {
auto book = nearby_protocol::CredentialBook::TryCreate().value();
- auto result =
- nearby_protocol::Deserializer::DeserializeAdvertisement(V0AdvSimple, book);
+ auto result = nearby_protocol::Deserializer::DeserializeAdvertisement(
+ V0AdvSimple, book);
ASSERT_EQ(result.GetKind(),
np_ffi::internal::DeserializeAdvertisementResultKind::V0);
auto legible = result.IntoV0().IntoLegible();
// create a second result
- auto another_result =
- nearby_protocol::Deserializer::DeserializeAdvertisement(V0AdvSimple, book);
+ auto another_result = nearby_protocol::Deserializer::DeserializeAdvertisement(
+ V0AdvSimple, book);
ASSERT_EQ(another_result.GetKind(),
np_ffi::internal::DeserializeAdvertisementResultKind::V0);
auto legible2 = another_result.IntoV0().IntoLegible();
@@ -402,7 +425,7 @@
return v0_adv.IntoLegible();
}
-TEST(NpFfiDeserializeV0Tests, V0LegibleAdvUseAfterMove) {
+TEST_F(NpCppTest, V0LegibleAdvUseAfterMove) {
auto book = nearby_protocol::CredentialBook::TryCreate().value();
auto legible_adv = CreateLegibleAdv(book);
@@ -422,16 +445,19 @@
ASSERT_DEATH([[maybe_unused]] auto failure = legible_adv.IntoPayload(), "");
}
-TEST(NpFfiDeserializeV0Tests, LegibleAdvDestructor) {
+TEST_F(NpCppTest, LegibleAdvDestructor) {
auto book = nearby_protocol::CredentialBook::TryCreate().value();
- nearby_protocol::GlobalConfig::SetMaxNumDeserializedV0Advertisements(1);
{
auto legible_adv = CreateLegibleAdv(book);
+ auto legible_adv2 = CreateLegibleAdv(book);
- // check that legible adv is valid.
+ // check that legible advs are valid.
ASSERT_EQ(legible_adv.GetIdentity().GetKind(),
nearby_protocol::DeserializedV0IdentityKind::Plaintext);
ASSERT_EQ(legible_adv.GetNumberOfDataElements(), 1);
+ ASSERT_EQ(legible_adv2.GetIdentity().GetKind(),
+ nearby_protocol::DeserializedV0IdentityKind::Plaintext);
+ ASSERT_EQ(legible_adv2.GetNumberOfDataElements(), 1);
// allocation slots should be full
ASSERT_EQ(nearby_protocol::Deserializer::DeserializeAdvertisement(
@@ -453,14 +479,15 @@
return legible_adv.IntoPayload();
}
-TEST(NpFfiDeserializeV0Tests, V0PayloadDestructor) {
+TEST_F(NpCppTest, V0PayloadDestructor) {
auto book = nearby_protocol::CredentialBook::TryCreate().value();
- nearby_protocol::GlobalConfig::SetMaxNumDeserializedV0Advertisements(1);
{
auto payload = CreatePayload(book);
+ auto payload2 = CreatePayload(book);
// check that payload adv is valid even though its parent is out of scope
ASSERT_TRUE(payload.TryGetDataElement(0).ok());
+ ASSERT_TRUE(payload2.TryGetDataElement(0).ok());
// allocation slots should be full
ASSERT_EQ(nearby_protocol::Deserializer::DeserializeAdvertisement(
@@ -477,7 +504,7 @@
nearby_protocol::DeserializeAdvertisementResultKind::V0);
}
-TEST(NpFfiDeserializeV0Tests, TestV0PayloadMoveConstructor) {
+TEST_F(NpCppTest, TestV0PayloadMoveConstructor) {
auto book = nearby_protocol::CredentialBook::TryCreate().value();
auto result = nearby_protocol::Deserializer::DeserializeAdvertisement(
V0AdvSimple, book);
@@ -503,7 +530,7 @@
"");
}
-TEST(NpFfiDeserializeResultTests, TestV0PayloadMoveAssignment) {
+TEST_F(NpCppTest, TestV0PayloadMoveAssignment) {
auto book = nearby_protocol::CredentialBook::TryCreate().value();
auto result = nearby_protocol::Deserializer::DeserializeAdvertisement(
V0AdvSimple, book);
@@ -534,10 +561,7 @@
"");
}
-TEST(NpFfiDeserializeV0Tests, InvalidDataElementCast) {
- ASSERT_TRUE(
- nearby_protocol::GlobalConfig::SetPanicHandler(test_panic_handler));
-
+TEST_F(NpCppTest, InvalidDataElementCast) {
auto maybe_credential_book = nearby_protocol::CredentialBook::TryCreate();
ASSERT_TRUE(maybe_credential_book.ok());
auto deserialize_result =
@@ -566,7 +590,7 @@
ASSERT_DEATH([[maybe_unused]] auto failure = de.AsActions();, "");
}
-TEST(NpFfiDeserializeV0Tests, InvalidDataElementIndex) {
+TEST_F(NpCppTest, InvalidDataElementIndex) {
auto maybe_credential_book = nearby_protocol::CredentialBook::TryCreate();
ASSERT_TRUE(maybe_credential_book.ok());
auto deserialize_result =
diff --git a/nearby/presence/np_cpp_ffi/tests/deserialize_v1_tests.cc b/nearby/presence/np_cpp_ffi/tests/deserialize_v1_tests.cc
index 115ad14..f46457e 100644
--- a/nearby/presence/np_cpp_ffi/tests/deserialize_v1_tests.cc
+++ b/nearby/presence/np_cpp_ffi/tests/deserialize_v1_tests.cc
@@ -14,10 +14,11 @@
#include "nearby_protocol.h"
#include "shared_test_util.h"
+#include "np_cpp_test.h"
#include "gtest/gtest.h"
-TEST(NpFfiDeserializeV1Tests, V1SimpleTestCase) {
+TEST_F(NpCppTest, V1SimpleTestCase) {
auto maybe_credential_book = nearby_protocol::CredentialBook::TryCreate();
ASSERT_TRUE(maybe_credential_book.ok());
@@ -47,7 +48,7 @@
auto de = section.value().TryGetDataElement(0);
ASSERT_TRUE(de.ok());
- ASSERT_EQ(de.value().GetDataElementTypeCode(), 5);
+ ASSERT_EQ(de.value().GetDataElementTypeCode(), (uint8_t)5);
auto payload = de.value().GetPayload();
auto vec = payload.ToVector();
@@ -55,7 +56,7 @@
ASSERT_EQ(vec, expected);
}
-TEST(NpFfiDeserializeV1Tests, TestV1AdvMoveConstructor) {
+TEST_F(NpCppTest, TestV1AdvMoveConstructor) {
auto book = nearby_protocol::CredentialBook::TryCreate().value();
auto result = nearby_protocol::Deserializer::DeserializeAdvertisement(
V1AdvSimple, book);
@@ -91,7 +92,7 @@
"");
}
-TEST(NpFfiDeserializeV1Tests, TestV1AdvMoveAssignment) {
+TEST_F(NpCppTest, TestV1AdvMoveAssignment) {
auto book = nearby_protocol::CredentialBook::TryCreate().value();
auto result = nearby_protocol::Deserializer::DeserializeAdvertisement(
V1AdvSimple, book);
@@ -151,9 +152,7 @@
np_ffi::internal::DeserializeAdvertisementResultKind::V1;
}
-TEST(NpFfiDeserializeV1Tests, TestSectionOwnership) {
- // Capping the max number so we can verify that de-allocations are happening
- nearby_protocol::GlobalConfig::SetMaxNumDeserializedV1Advertisements(1);
+TEST_F(NpCppTest, TestSectionOwnership) {
auto maybe_credential_book = nearby_protocol::CredentialBook::TryCreate();
ASSERT_TRUE(maybe_credential_book.ok());
@@ -164,6 +163,12 @@
ASSERT_EQ(section.NumberOfDataElements(), 1);
ASSERT_TRUE(section.TryGetDataElement(0).ok());
+ auto section2 = GetSection(maybe_credential_book.value());
+ ASSERT_EQ(section2.GetIdentityKind(),
+ nearby_protocol::DeserializedV1IdentityKind::Plaintext);
+ ASSERT_EQ(section2.NumberOfDataElements(), 1);
+ ASSERT_TRUE(section2.TryGetDataElement(0).ok());
+
ASSERT_FALSE(TryDeserializeNewV1Adv(maybe_credential_book.value()));
}
@@ -175,7 +180,7 @@
/*
* Multiple sections are not supported in plaintext advertisements
* TODO Update the below test to use encrypted sections
-TEST(NpFfiDeserializeV1Tests, V1MultipleSections) {
+TEST(NpCppTest, V1MultipleSections) {
auto maybe_credential_book = nearby_protocol::CredentialBook::TryCreate();
ASSERT_TRUE(maybe_credential_book.ok());
diff --git a/nearby/presence/np_cpp_ffi/tests/global_config_tests.cc b/nearby/presence/np_cpp_ffi/tests/global_config_tests.cc
deleted file mode 100644
index 6936f23..0000000
--- a/nearby/presence/np_cpp_ffi/tests/global_config_tests.cc
+++ /dev/null
@@ -1,205 +0,0 @@
-// Copyright 2023 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "nearby_protocol.h"
-#include "shared_test_util.h"
-
-#include <iostream>
-
-#include "gtest/gtest.h"
-
-TEST(NpFfiGlobalConfigTests, TestPanicHandler) {
- ASSERT_TRUE(
- nearby_protocol::GlobalConfig::SetPanicHandler(test_panic_handler));
- auto book = nearby_protocol::CredentialBook::TryCreate().value();
- auto deserialize_result =
- nearby_protocol::Deserializer::DeserializeAdvertisement(V0AdvSimple, book);
- ASSERT_EQ(deserialize_result.GetKind(),
- np_ffi::internal::DeserializeAdvertisementResultKind::V0);
-
- // Now try to cast the result into the wrong type and verify the process
- // aborts
- ASSERT_DEATH({ [[maybe_unused]] auto failure = deserialize_result.IntoV1(); },
- "");
-}
-
-TEST(NpFfiGlobalConfigTests, TestPanicHandlerTwice) {
- ASSERT_TRUE(
- nearby_protocol::GlobalConfig::SetPanicHandler(test_panic_handler));
-
- // Second time trying to set should fail
- ASSERT_FALSE(
- nearby_protocol::GlobalConfig::SetPanicHandler(test_panic_handler));
-}
-
-// There is not much we can actually test here since this will affect memory
-// consumption. This is more of just a simple check that things still work after
-// configuring this
-TEST(NpFfiGlobalConfigTests, TestSetMaxShardsDefault) {
- // 0 should still work as default behavior
- nearby_protocol::GlobalConfig::SetNumShards(0);
-
- auto book = nearby_protocol::CredentialBook::TryCreate().value();
- auto book2 = nearby_protocol::CredentialBook::TryCreate().value();
- auto book3 = nearby_protocol::CredentialBook::TryCreate().value();
- auto deserialize_result =
- nearby_protocol::Deserializer::DeserializeAdvertisement(V0AdvSimple, book);
-
- // Should still work
- ASSERT_EQ(deserialize_result.GetKind(),
- np_ffi::internal::DeserializeAdvertisementResultKind::V0);
-
- // Call again with a lower number, should have no effect. books 2 and 3 should
- // still work.
- nearby_protocol::GlobalConfig::SetNumShards(1);
- auto deserialize_result_2 =
- nearby_protocol::Deserializer::DeserializeAdvertisement(V0AdvSimple,
- book2);
- ASSERT_EQ(deserialize_result_2.GetKind(),
- np_ffi::internal::DeserializeAdvertisementResultKind::V0);
- auto deserialize_result_3 =
- nearby_protocol::Deserializer::DeserializeAdvertisement(V0AdvSimple,
- book3);
- ASSERT_EQ(deserialize_result_3.GetKind(),
- np_ffi::internal::DeserializeAdvertisementResultKind::V0);
-}
-
-TEST(NpFfiGlobalConfigTests, TestSetMaxShardsSmall) {
- nearby_protocol::GlobalConfig::SetNumShards(1);
- auto book = nearby_protocol::CredentialBook::TryCreate().value();
-
- // should still be able to parse 2 payloads with only one shard
- auto deserialize_result1 =
- nearby_protocol::Deserializer::DeserializeAdvertisement(V0AdvSimple, book);
- ASSERT_EQ(deserialize_result1.GetKind(),
- np_ffi::internal::DeserializeAdvertisementResultKind::V0);
- auto deserialize_result2 =
- nearby_protocol::Deserializer::DeserializeAdvertisement(V0AdvSimple, book);
- ASSERT_EQ(deserialize_result2.GetKind(),
- np_ffi::internal::DeserializeAdvertisementResultKind::V0);
-}
-
-TEST(NpFfiGlobalConfigTests, TestSetMaxCredBooks) {
- nearby_protocol::GlobalConfig::SetMaxNumCredentialBooks(1);
- auto book1_result = nearby_protocol::CredentialBook::TryCreate();
- ASSERT_TRUE(book1_result.ok());
-
- auto book2_result = nearby_protocol::CredentialBook::TryCreate();
- ASSERT_FALSE(book2_result.ok());
- ASSERT_TRUE(absl::IsResourceExhausted(book2_result.status()));
-}
-
-TEST(NpFfiGlobalConfigTests, TestSetMaxCredBooksAfterFirstCall) {
- auto book = nearby_protocol::CredentialBook::TryCreate().value();
- auto book2 = nearby_protocol::CredentialBook::TryCreate().value();
- auto book3 = nearby_protocol::CredentialBook::TryCreate().value();
-
- // setting this after books have already been created should have no affect
- nearby_protocol::GlobalConfig::SetMaxNumCredentialBooks(1);
- auto book4_result = nearby_protocol::CredentialBook::TryCreate();
- ASSERT_TRUE(book4_result.ok());
-}
-
-TEST(NpFfiGlobalConfigTests, TestSetMaxV0Advs) {
- nearby_protocol::GlobalConfig::SetMaxNumDeserializedV0Advertisements(1);
- auto book_result = nearby_protocol::CredentialBook::TryCreate();
- ASSERT_TRUE(book_result.ok());
-
- {
- auto deserialize_result =
- nearby_protocol::Deserializer::DeserializeAdvertisement(
- V0AdvSimple, book_result.value());
- ASSERT_EQ(deserialize_result.GetKind(),
- np_ffi::internal::DeserializeAdvertisementResultKind::V0);
-
- // Going over max amount should result in error
- auto deserialize_result2 =
- nearby_protocol::Deserializer::DeserializeAdvertisement(
- V0AdvSimple, book_result.value());
- ASSERT_EQ(deserialize_result2.GetKind(),
- np_ffi::internal::DeserializeAdvertisementResultKind::Error);
- }
-
- // Now that the first v0 adv is out of scope, it will be de-allocated which
- // will create room for one more to be created.
- auto deserialize_result3 =
- nearby_protocol::Deserializer::DeserializeAdvertisement(
- V0AdvSimple, book_result.value());
- ASSERT_EQ(deserialize_result3.GetKind(),
- np_ffi::internal::DeserializeAdvertisementResultKind::V0);
-}
-
-TEST(NpFfiGlobalConfigTests, TestSetMaxV1Advs) {
- nearby_protocol::GlobalConfig::SetMaxNumDeserializedV1Advertisements(1);
- auto book_result = nearby_protocol::CredentialBook::TryCreate();
- ASSERT_TRUE(book_result.ok());
-
- {
- auto deserialize_result =
- nearby_protocol::Deserializer::DeserializeAdvertisement(
- V1AdvSimple, book_result.value());
- ASSERT_EQ(deserialize_result.GetKind(),
- np_ffi::internal::DeserializeAdvertisementResultKind::V1);
-
- // Going over max amount should result in error
- auto deserialize_result2 =
- nearby_protocol::Deserializer::DeserializeAdvertisement(
- V1AdvSimple, book_result.value());
- ASSERT_EQ(deserialize_result2.GetKind(),
- np_ffi::internal::DeserializeAdvertisementResultKind::Error);
- }
-
- // Now that the first v1 adv is out of scope, it will be de-allocated which
- // will create room for one more to be created.
- auto deserialize_result3 =
- nearby_protocol::Deserializer::DeserializeAdvertisement(
- V1AdvSimple, book_result.value());
- ASSERT_EQ(deserialize_result3.GetKind(),
- np_ffi::internal::DeserializeAdvertisementResultKind::V1);
-}
-
-// Same test case as above, but verifies that the de-allocation still succeeds
-// after calling IntoV1() and that no double frees occur.
-TEST(NpFfiGlobalConfigTests, TestSetMaxV1AdvsFreeAfterInto) {
- nearby_protocol::GlobalConfig::SetMaxNumDeserializedV1Advertisements(1);
- auto book_result = nearby_protocol::CredentialBook::TryCreate();
- ASSERT_TRUE(book_result.ok());
-
- {
- auto deserialize_result =
- nearby_protocol::Deserializer::DeserializeAdvertisement(
- V1AdvSimple, book_result.value());
- ASSERT_EQ(deserialize_result.GetKind(),
- np_ffi::internal::DeserializeAdvertisementResultKind::V1);
-
- // Going over max amount should result in error
- auto deserialize_result2 =
- nearby_protocol::Deserializer::DeserializeAdvertisement(
- V1AdvSimple, book_result.value());
- ASSERT_EQ(deserialize_result2.GetKind(),
- np_ffi::internal::DeserializeAdvertisementResultKind::Error);
-
- // Calling IntoV1() should move the underlying resources into the v0 object
- // when both go out of scope only one should be freed
- auto v0_adv = deserialize_result.IntoV1();
- }
-
- // Now that the first v1 adv is out of scope, it will be de-allocated which
- // will create room for one more to be created.
- auto deserialize_result3 =
- nearby_protocol::Deserializer::DeserializeAdvertisement(
- V1AdvSimple, book_result.value());
- ASSERT_EQ(deserialize_result3.GetKind(),
- np_ffi::internal::DeserializeAdvertisementResultKind::V1);
-}
\ No newline at end of file
diff --git a/nearby/presence/np_cpp_ffi/tests/np_cpp_test.cc b/nearby/presence/np_cpp_ffi/tests/np_cpp_test.cc
new file mode 100644
index 0000000..52049e7
--- /dev/null
+++ b/nearby/presence/np_cpp_ffi/tests/np_cpp_test.cc
@@ -0,0 +1,17 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "np_cpp_test.h"
+
+bool NpCppTest::panic_handler_set = false;
\ No newline at end of file
diff --git a/nearby/presence/np_cpp_ffi/tests/np_cpp_test.h b/nearby/presence/np_cpp_ffi/tests/np_cpp_test.h
new file mode 100644
index 0000000..4fc20e1
--- /dev/null
+++ b/nearby/presence/np_cpp_ffi/tests/np_cpp_test.h
@@ -0,0 +1,41 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef NEARBY_PRESENCE_NP_CPP_FFI_TESTS_NP_CPP_TEST_H_
+#define NEARBY_PRESENCE_NP_CPP_FFI_TESTS_NP_CPP_TEST_H_
+
+#include "nearby_protocol.h"
+#include "shared_test_util.h"
+
+#include <gtest/gtest.h>
+
+class NpCppTest : public testing::Test {
+protected:
+ static void SetUpTestSuite() {
+ if (!panic_handler_set) {
+ ASSERT_TRUE(
+ nearby_protocol::GlobalConfig::SetPanicHandler(test_panic_handler));
+ panic_handler_set = true;
+ nearby_protocol::GlobalConfig::SetMaxNumDeserializedV0Advertisements(2);
+ nearby_protocol::GlobalConfig::SetMaxNumDeserializedV1Advertisements(2);
+ nearby_protocol::GlobalConfig::SetMaxNumCredentialBooks(2);
+ } else {
+ ASSERT_FALSE(
+ nearby_protocol::GlobalConfig::SetPanicHandler(test_panic_handler));
+ }
+ }
+ static bool panic_handler_set;
+};
+
+#endif // NEARBY_PRESENCE_NP_CPP_FFI_TESTS_NP_CPP_TEST_H_
diff --git a/nearby/presence/np_ffi_core/Cargo.toml b/nearby/presence/np_ffi_core/Cargo.toml
index cdcc7d3..126302f 100644
--- a/nearby/presence/np_ffi_core/Cargo.toml
+++ b/nearby/presence/np_ffi_core/Cargo.toml
@@ -6,7 +6,7 @@
[dependencies]
array_view.workspace = true
-np_adv.workspace = true
+np_adv = { workspace = true, features = ["alloc"] }
handle_map.workspace = true
crypto_provider.workspace = true
crypto_provider_default = {workspace = true, default-features = false}
diff --git a/nearby/presence/np_ffi_core/src/deserialize/mod.rs b/nearby/presence/np_ffi_core/src/deserialize/mod.rs
index 9c20fde..38f59ba 100644
--- a/nearby/presence/np_ffi_core/src/deserialize/mod.rs
+++ b/nearby/presence/np_ffi_core/src/deserialize/mod.rs
@@ -87,7 +87,7 @@
V1(DeserializedV1Advertisement),
}
-struct DeserializeAdvertisementError;
+pub(crate) struct DeserializeAdvertisementError;
impl From<HandleMapFullError> for DeserializeAdvertisementError {
fn from(_: HandleMapFullError) -> Self {
diff --git a/nearby/presence/np_ffi_core/src/deserialize/v0.rs b/nearby/presence/np_ffi_core/src/deserialize/v0.rs
index 7b9ee75..d8c008a 100644
--- a/nearby/presence/np_ffi_core/src/deserialize/v0.rs
+++ b/nearby/presence/np_ffi_core/src/deserialize/v0.rs
@@ -68,7 +68,7 @@
pub(crate) fn allocate_with_contents<M: np_adv::credential::MatchedCredential>(
contents: np_adv::V0AdvertisementContents<M>,
- ) -> Result<Self, HandleMapFullError> {
+ ) -> Result<Self, DeserializeAdvertisementError> {
match contents {
np_adv::V0AdvertisementContents::Plaintext(plaintext_contents) => {
let adv = LegibleDeserializedV0Advertisement::allocate_with_plaintext_contents(
@@ -99,8 +99,11 @@
impl LegibleDeserializedV0Advertisement {
pub(crate) fn allocate_with_plaintext_contents(
contents: np_adv::legacy::deserialize::PlaintextAdvContents,
- ) -> Result<Self, HandleMapFullError> {
- let data_elements = contents.to_data_elements();
+ ) -> Result<Self, DeserializeAdvertisementError> {
+ let data_elements = contents
+ .data_elements()
+ .collect::<Result<Vec<_>, _>>()
+ .map_err(|_| DeserializeAdvertisementError)?;
let num_des = data_elements.len() as u8;
let payload = V0Payload::allocate_with_data_elements(data_elements)?;
Ok(Self { num_des, payload, identity: DeserializedV0Identity::Plaintext })
@@ -187,6 +190,8 @@
}
use v0_payload::V0Payload;
+use super::DeserializeAdvertisementError;
+
impl LocksLongerThan<V0Payload> for CredentialBook {}
impl V0Payload {
diff --git a/nearby/presence/np_ffi_core/src/deserialize/v1.rs b/nearby/presence/np_ffi_core/src/deserialize/v1.rs
index be44fb7..819bb8c 100644
--- a/nearby/presence/np_ffi_core/src/deserialize/v1.rs
+++ b/nearby/presence/np_ffi_core/src/deserialize/v1.rs
@@ -13,11 +13,13 @@
// limitations under the License.
//! Core NP Rust FFI structures and methods for v1 advertisement deserialization.
+use super::DeserializeAdvertisementError;
use crate::common::*;
use crate::credentials::credential_book::CredentialBook;
use crate::utils::*;
use array_view::ArrayView;
-use handle_map::{declare_handle_map, HandleLike, HandleMapDimensions, HandleMapFullError};
+use handle_map::{declare_handle_map, HandleLike, HandleMapDimensions};
+use legible_v1_sections::LegibleV1Sections;
use np_adv::extended::deserialize::DataElementParseError;
use std::vec::Vec;
@@ -59,12 +61,13 @@
pub(crate) fn allocate_with_contents<M: np_adv::credential::MatchedCredential>(
contents: np_adv::V1AdvertisementContents<M>,
- ) -> Result<Self, HandleMapFullError> {
+ ) -> Result<Self, DeserializeAdvertisementError> {
// 16-section limit enforced by np_adv
let num_undecryptable_sections = contents.invalid_sections_count() as u8;
let legible_sections = contents.into_sections();
let num_legible_sections = legible_sections.len() as u8;
- let legible_sections = LegibleV1Sections::allocate_with_contents(legible_sections)?;
+ let legible_sections =
+ LegibleV1Sections::allocate_with_contents(legible_sections.into_vec())?;
Ok(Self { num_undecryptable_sections, num_legible_sections, legible_sections })
}
}
@@ -107,14 +110,18 @@
}
impl<'adv, M: np_adv::credential::MatchedCredential>
- From<Vec<np_adv::V1DeserializedSection<'adv, M>>> for LegibleV1SectionsInternals
+ TryFrom<Vec<np_adv::V1DeserializedSection<'adv, M>>> for LegibleV1SectionsInternals
{
- fn from(contents: Vec<np_adv::V1DeserializedSection<'adv, M>>) -> Self {
+ type Error = DataElementParseError;
+
+ fn try_from(
+ contents: Vec<np_adv::V1DeserializedSection<'adv, M>>,
+ ) -> Result<Self, Self::Error> {
let sections = contents
.into_iter()
- .filter_map(|s| DeserializedV1SectionInternals::try_from(s).ok())
- .collect();
- Self { sections }
+ .map(DeserializedV1SectionInternals::try_from)
+ .collect::<Result<Vec<_>, _>>()?;
+ Ok(Self { sections })
}
}
@@ -131,15 +138,16 @@
type LegibleV1Sections: HandleLike<Object = super::LegibleV1SectionsInternals>;
}
}
-use legible_v1_sections::LegibleV1Sections;
impl LocksLongerThan<LegibleV1Sections> for CredentialBook {}
impl LegibleV1Sections {
pub(crate) fn allocate_with_contents<M: np_adv::credential::MatchedCredential>(
contents: Vec<np_adv::V1DeserializedSection<M>>,
- ) -> Result<Self, HandleMapFullError> {
- Self::allocate(move || LegibleV1SectionsInternals::from(contents))
+ ) -> Result<Self, DeserializeAdvertisementError> {
+ let section = LegibleV1SectionsInternals::try_from(contents)
+ .map_err(|_| DeserializeAdvertisementError)?;
+ Self::allocate(move || section).map_err(|e| e.into())
}
}
diff --git a/nearby/util/handle_map/Cargo.toml b/nearby/util/handle_map/Cargo.toml
index ee9dbf3..fbe3a20 100644
--- a/nearby/util/handle_map/Cargo.toml
+++ b/nearby/util/handle_map/Cargo.toml
@@ -6,7 +6,6 @@
[dependencies]
lock_adapter.workspace = true
-crypto_provider.workspace = true
[dev-dependencies]
criterion.workspace = true
