1use crate::reader::Reader;
5use crate::uuid::Uuid;
6use crate::AddressBytes;
7
8#[cfg(feature = "serde")]
9use serde::Serialize;
10
11#[cfg(feature = "serde")]
12pub(crate) fn ser_hex<S: serde::Serializer, T: AsRef<[u8]>>(
13 v: &T,
14 s: S,
15) -> Result<S::Ok, S::Error> {
16 s.serialize_str(&hex::encode(v.as_ref()))
17}
18
19#[cfg(feature = "serde")]
20fn ser_hex_opt<S: serde::Serializer, T: AsRef<[u8]>>(
21 v: &Option<T>,
22 s: S,
23) -> Result<S::Ok, S::Error> {
24 match v {
25 Some(v) => s.serialize_str(&hex::encode(v.as_ref())),
26 None => s.serialize_none(),
27 }
28}
29
30#[cfg(feature = "serde")]
31fn ser_addrs<S: serde::Serializer>(v: &[AddressBytes], s: S) -> Result<S::Ok, S::Error> {
32 s.collect_seq(v.iter().map(crate::format_address))
33}
34
35#[derive(Debug, Clone, Copy, PartialEq, Eq)]
37pub struct AdStructure<'a> {
38 pub ad_type: u8,
40 pub data: &'a [u8],
42}
43
44impl AdStructure<'_> {
45 pub fn type_name(&self) -> Option<&'static str> {
47 bluetooth_numbers::ad_type(self.ad_type)
48 }
49}
50
51#[derive(Debug, Clone, Copy, PartialEq, Eq)]
53#[cfg_attr(feature = "serde", derive(Serialize))]
54pub struct Malformed {
55 pub offset: usize,
57}
58
59#[derive(Debug, Clone)]
65pub struct AdStructures<'a> {
66 data: &'a [u8],
67 offset: usize,
68 done: bool,
69}
70
71impl<'a> AdStructures<'a> {
72 pub fn new(data: &'a [u8]) -> Self {
74 Self {
75 data,
76 offset: 0,
77 done: false,
78 }
79 }
80}
81
82impl<'a> Iterator for AdStructures<'a> {
83 type Item = Result<AdStructure<'a>, Malformed>;
84
85 fn next(&mut self) -> Option<Self::Item> {
86 if self.done || self.offset >= self.data.len() {
87 return None;
88 }
89 let len = usize::from(self.data[self.offset]);
90 if len == 0 {
91 self.done = true;
92 return None;
93 }
94 let start = self.offset + 1;
95 let end = start + len;
96 if end > self.data.len() {
97 self.done = true;
98 return Some(Err(Malformed {
99 offset: self.offset,
100 }));
101 }
102 self.offset = end;
103 Some(Ok(AdStructure {
104 ad_type: self.data[start],
105 data: &self.data[start + 1..end],
106 }))
107 }
108}
109
110#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
112#[cfg_attr(feature = "serde", derive(Serialize))]
113pub struct Flags {
114 pub raw: u8,
116 pub le_limited_discoverable: bool,
118 pub le_general_discoverable: bool,
120 pub br_edr_not_supported: bool,
122 pub le_br_edr_controller: bool,
124}
125
126impl From<u8> for Flags {
127 fn from(raw: u8) -> Self {
128 Flags {
129 raw,
130 le_limited_discoverable: raw & 0x01 != 0,
131 le_general_discoverable: raw & 0x02 != 0,
132 br_edr_not_supported: raw & 0x04 != 0,
133 le_br_edr_controller: raw & 0x08 != 0,
134 }
135 }
136}
137
138#[derive(Debug, Clone, Copy, PartialEq, Eq)]
140#[cfg_attr(feature = "serde", derive(Serialize))]
141pub struct ServiceUuid {
142 pub uuid: Uuid,
144 pub complete: bool,
146 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
148 pub name: Option<&'static str>,
149}
150
151#[derive(Debug, Clone, PartialEq, Eq)]
153#[cfg_attr(feature = "serde", derive(Serialize))]
154pub struct LocalName {
155 pub name: String,
157 pub complete: bool,
159}
160
161#[derive(Debug, Clone, PartialEq, Eq)]
163#[cfg_attr(feature = "serde", derive(Serialize))]
164pub struct ServiceData {
165 pub uuid: Uuid,
167 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
169 pub name: Option<&'static str>,
170 #[cfg_attr(feature = "serde", serde(serialize_with = "ser_hex"))]
172 pub data: Vec<u8>,
173}
174
175#[derive(Debug, Clone, PartialEq, Eq)]
177#[cfg_attr(feature = "serde", derive(Serialize))]
178pub struct ManufacturerData {
179 pub company_id: u16,
181 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
183 pub company: Option<&'static str>,
184 #[cfg_attr(feature = "serde", serde(serialize_with = "ser_hex"))]
186 pub data: Vec<u8>,
187}
188
189#[derive(Debug, Clone, Copy, PartialEq, Eq)]
191#[cfg_attr(feature = "serde", derive(Serialize))]
192pub struct DeviceId {
193 pub vendor_id_source: u16,
195 pub vendor_id: u16,
197 pub product_id: u16,
199 pub version: u16,
201}
202
203#[derive(Debug, Clone, PartialEq, Eq)]
207#[cfg_attr(feature = "serde", derive(Serialize))]
208pub struct RawAd {
209 pub ad_type: u8,
211 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
213 pub name: Option<&'static str>,
214 #[cfg_attr(feature = "serde", serde(serialize_with = "ser_hex"))]
216 pub data: Vec<u8>,
217}
218
219#[derive(Debug, Clone, Default, PartialEq)]
225#[cfg_attr(feature = "serde", derive(Serialize))]
226#[non_exhaustive]
227pub struct Advertisement {
228 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
230 pub flags: Option<Flags>,
231 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Vec::is_empty"))]
233 pub services: Vec<ServiceUuid>,
234 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Vec::is_empty"))]
236 pub solicited_services: Vec<Uuid>,
237 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
239 pub local_name: Option<LocalName>,
240 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
242 pub broadcast_name: Option<String>,
243 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
245 pub tx_power: Option<i8>,
246 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
248 pub appearance: Option<u16>,
249 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
251 pub appearance_name: Option<String>,
252 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
254 pub class_of_device: Option<u32>,
255 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
257 pub device_id: Option<DeviceId>,
258 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Vec::is_empty"))]
260 pub service_data: Vec<ServiceData>,
261 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Vec::is_empty"))]
263 pub manufacturer_data: Vec<ManufacturerData>,
264 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
266 pub peripheral_connection_interval: Option<(u16, u16)>,
267 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
269 pub advertising_interval: Option<u32>,
270 #[cfg_attr(
272 feature = "serde",
273 serde(skip_serializing_if = "Vec::is_empty", serialize_with = "ser_addrs")
274 )]
275 pub public_target_addresses: Vec<AddressBytes>,
276 #[cfg_attr(
278 feature = "serde",
279 serde(skip_serializing_if = "Vec::is_empty", serialize_with = "ser_addrs")
280 )]
281 pub random_target_addresses: Vec<AddressBytes>,
282 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
284 pub le_address: Option<(String, bool)>,
285 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
288 pub le_role: Option<u8>,
289 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
291 pub uri: Option<String>,
292 #[cfg_attr(
294 feature = "serde",
295 serde(
296 skip_serializing_if = "Option::is_none",
297 serialize_with = "ser_hex_opt"
298 )
299 )]
300 pub le_supported_features: Option<Vec<u8>>,
301 #[cfg_attr(
303 feature = "serde",
304 serde(
305 skip_serializing_if = "Option::is_none",
306 serialize_with = "ser_hex_opt"
307 )
308 )]
309 pub resolvable_set_identifier: Option<[u8; 6]>,
310 #[cfg_attr(
312 feature = "serde",
313 serde(
314 skip_serializing_if = "Option::is_none",
315 serialize_with = "ser_hex_opt"
316 )
317 )]
318 pub sm_tk: Option<[u8; 16]>,
319 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
321 pub sm_oob_flags: Option<u8>,
322 #[cfg_attr(
324 feature = "serde",
325 serde(
326 skip_serializing_if = "Option::is_none",
327 serialize_with = "ser_hex_opt"
328 )
329 )]
330 pub le_sc_confirmation: Option<[u8; 16]>,
331 #[cfg_attr(
333 feature = "serde",
334 serde(
335 skip_serializing_if = "Option::is_none",
336 serialize_with = "ser_hex_opt"
337 )
338 )]
339 pub le_sc_random: Option<[u8; 16]>,
340 #[cfg_attr(
342 feature = "serde",
343 serde(
344 skip_serializing_if = "Option::is_none",
345 serialize_with = "ser_hex_opt"
346 )
347 )]
348 pub ssp_hash: Option<[u8; 16]>,
349 #[cfg_attr(
351 feature = "serde",
352 serde(
353 skip_serializing_if = "Option::is_none",
354 serialize_with = "ser_hex_opt"
355 )
356 )]
357 pub ssp_randomizer: Option<[u8; 16]>,
358 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Vec::is_empty"))]
362 pub other: Vec<RawAd>,
363 #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
366 pub malformed: Option<Malformed>,
367}
368
369impl Advertisement {
370 pub fn parse(data: &[u8]) -> Advertisement {
373 let mut adv = Advertisement::default();
374 adv.extend(data);
375 adv
376 }
377
378 pub fn extend(&mut self, data: &[u8]) {
380 for s in AdStructures::new(data) {
381 match s {
382 Ok(s) => {
383 if !self.add(s) {
384 self.other.push(RawAd {
385 ad_type: s.ad_type,
386 name: s.type_name(),
387 data: s.data.to_vec(),
388 });
389 }
390 }
391 Err(m) => self.malformed = Some(m),
392 }
393 }
394 }
395
396 fn add(&mut self, s: AdStructure<'_>) -> bool {
398 let d = s.data;
399 let mut r = Reader::new(d);
400 match s.ad_type {
401 0x01 => match d {
402 [f, ..] => self.flags = Some(Flags::from(*f)),
403 [] => return false,
404 },
405 0x02..=0x07 => {
406 let size = match s.ad_type {
407 0x02 | 0x03 => 2,
408 0x04 | 0x05 => 4,
409 _ => 16,
410 };
411 if !d.len().is_multiple_of(size) {
412 return false;
413 }
414 let complete = s.ad_type % 2 == 1;
415 for c in d.chunks_exact(size) {
416 if let Some(uuid) = Uuid::from_le_bytes(c) {
417 self.services.push(ServiceUuid {
418 uuid,
419 complete,
420 name: uuid.name(),
421 });
422 }
423 }
424 }
425 0x14 | 0x15 | 0x1f => {
426 let size = match s.ad_type {
427 0x14 => 2,
428 0x1f => 4,
429 _ => 16,
430 };
431 if !d.len().is_multiple_of(size) {
432 return false;
433 }
434 self.solicited_services
435 .extend(d.chunks_exact(size).filter_map(Uuid::from_le_bytes));
436 }
437 0x08 | 0x09 => {
438 let complete = s.ad_type == 0x09;
439 if complete || self.local_name.as_ref().is_none_or(|n| !n.complete) {
440 self.local_name = Some(LocalName {
441 name: String::from_utf8_lossy(d).into_owned(),
442 complete,
443 });
444 }
445 }
446 0x30 => self.broadcast_name = Some(String::from_utf8_lossy(d).into_owned()),
447 0x0a => match d {
448 [p] => self.tx_power = Some(*p as i8),
449 _ => return false,
450 },
451 0x0d => match d {
452 [a, b, c] => self.class_of_device = Some(u32::from_le_bytes([*a, *b, *c, 0])),
453 _ => return false,
454 },
455 0x10 => match d.len() {
456 8 => {
457 self.device_id = Some(DeviceId {
458 vendor_id_source: r.u16_le().unwrap_or_default(),
459 vendor_id: r.u16_le().unwrap_or_default(),
460 product_id: r.u16_le().unwrap_or_default(),
461 version: r.u16_le().unwrap_or_default(),
462 })
463 }
464 16 => self.sm_tk = r.array(),
465 _ => return false,
466 },
467 0x11 => match d {
468 [f] => self.sm_oob_flags = Some(*f),
469 _ => return false,
470 },
471 0x12 => match (r.u16_le(), r.u16_le(), r.remaining()) {
472 (Some(min), Some(max), 0) => self.peripheral_connection_interval = Some((min, max)),
473 _ => return false,
474 },
475 0x16 | 0x20 | 0x21 => {
476 let size = match s.ad_type {
477 0x16 => 2,
478 0x20 => 4,
479 _ => 16,
480 };
481 let Some(uuid) = r.take(size).and_then(Uuid::from_le_bytes) else {
482 return false;
483 };
484 self.service_data.push(ServiceData {
485 uuid,
486 name: uuid.name(),
487 data: r.rest().to_vec(),
488 });
489 }
490 0x17 | 0x18 => {
491 if d.is_empty() || !d.len().is_multiple_of(6) {
492 return false;
493 }
494 let list = d.as_chunks::<6>().0.iter().copied();
495 if s.ad_type == 0x17 {
496 self.public_target_addresses.extend(list);
497 } else {
498 self.random_target_addresses.extend(list);
499 }
500 }
501 0x19 => match r.u16_le() {
502 Some(v) if r.remaining() == 0 => {
503 self.appearance = Some(v);
504 let a = bluetooth_numbers::appearance(v);
505 self.appearance_name = match (a.category, a.subcategory) {
506 (Some(c), Some(s)) => Some(format!("{c}: {s}")),
507 (Some(c), None) => Some(c.to_string()),
508 _ => None,
509 };
510 }
511 _ => return false,
512 },
513 0x1a | 0x2f => match d.len() {
514 2..=4 => self.advertising_interval = r.uint_le(d.len()),
515 _ => return false,
516 },
517 0x1b => match (r.array::<6>(), r.u8(), r.remaining()) {
518 (Some(a), Some(t), 0) => {
519 self.le_address = Some((crate::format_address(&a), t & 1 == 1))
520 }
521 _ => return false,
522 },
523 0x1c => match d {
524 [role] => self.le_role = Some(*role),
525 _ => return false,
526 },
527 0x0e | 0x1d => match r.array() {
528 Some(v) if r.remaining() == 0 => self.ssp_hash = Some(v),
529 _ => return false,
530 },
531 0x0f | 0x1e => match r.array() {
532 Some(v) if r.remaining() == 0 => self.ssp_randomizer = Some(v),
533 _ => return false,
534 },
535 0x22 => match r.array() {
536 Some(v) if r.remaining() == 0 => self.le_sc_confirmation = Some(v),
537 _ => return false,
538 },
539 0x23 => match r.array() {
540 Some(v) if r.remaining() == 0 => self.le_sc_random = Some(v),
541 _ => return false,
542 },
543 0x24 => match decode_uri(d) {
544 Some(u) => self.uri = Some(u),
545 None => return false,
546 },
547 0x27 => self.le_supported_features = Some(d.to_vec()),
548 0x2e => match r.array() {
549 Some(v) if r.remaining() == 0 => self.resolvable_set_identifier = Some(v),
550 _ => return false,
551 },
552 0xff => match r.u16_le() {
553 Some(company_id) => self.manufacturer_data.push(ManufacturerData {
554 company_id,
555 company: bluetooth_numbers::company(company_id),
556 data: r.rest().to_vec(),
557 }),
558 None => return false,
559 },
560 _ => return false,
561 }
562 true
563 }
564
565 pub fn service_data_for(&self, uuid: impl Into<Uuid>) -> Option<&[u8]> {
567 let uuid = uuid.into();
568 self.service_data
569 .iter()
570 .find(|s| s.uuid == uuid)
571 .map(|s| s.data.as_slice())
572 }
573
574 pub fn manufacturer_data_for(&self, company_id: u16) -> Option<&[u8]> {
576 self.manufacturer_data
577 .iter()
578 .find(|m| m.company_id == company_id)
579 .map(|m| m.data.as_slice())
580 }
581}
582
583fn decode_uri(d: &[u8]) -> Option<String> {
586 let s = core::str::from_utf8(d).ok()?;
587 let mut chars = s.chars();
588 let code = chars.next()? as u32;
589 let rest = chars.as_str();
590 if code == 0x01 {
591 return Some(rest.to_string());
592 }
593 let scheme = bluetooth_numbers::uri_scheme(u16::try_from(code).ok()?)?;
594 Some(format!("{scheme}{rest}"))
595}
596
597#[cfg(test)]
598mod tests {
599 use super::*;
600
601 #[test]
602 fn structures_stop_at_padding_and_report_truncation() {
603 let all: Vec<_> = AdStructures::new(&[2, 1, 6, 0, 9, 9]).collect();
604 assert_eq!(
605 all,
606 vec![Ok(AdStructure {
607 ad_type: 1,
608 data: &[6]
609 })]
610 );
611 let all: Vec<_> = AdStructures::new(&[2, 1, 6, 5, 9, b'a']).collect();
612 assert_eq!(all[1], Err(Malformed { offset: 3 }));
613 assert!(AdStructures::new(&[]).next().is_none());
614 }
615
616 #[test]
617 fn parses_common_fields() {
618 let data = hex_lit(concat!(
619 "020106", "0303 0f18", "0809 4b42 5072 6f2d 31", "020a f4", "0319 c100", "0516 0f18 6400", "05ff 4c00 0102", "0524 17 2f2f 61", "03ee 0102", ));
629 let adv = Advertisement::parse(&data);
630 assert!(adv.flags.unwrap().le_general_discoverable);
631 assert_eq!(adv.services[0].uuid, Uuid::Uuid16(0x180f));
632 assert!(adv.services[0].complete);
633 assert_eq!(adv.local_name.as_ref().unwrap().name, "KBPro-1");
634 assert_eq!(adv.tx_power, Some(-12));
635 assert_eq!(adv.appearance_name.as_deref(), Some("Watch: Sports Watch"));
636 assert_eq!(adv.service_data_for(0x180f), Some(&[0x64, 0x00][..]));
637 assert_eq!(adv.manufacturer_data[0].company, Some("Apple, Inc."));
638 assert_eq!(adv.uri.as_deref(), Some("https://a"));
639 assert_eq!(adv.other[0].ad_type, 0xee);
640 assert!(adv.malformed.is_none());
641 }
642
643 #[test]
644 fn wrong_lengths_are_kept_raw() {
645 let adv = Advertisement::parse(&hex_lit("030a0102 0219 01"));
646 assert_eq!(adv.tx_power, None);
647 assert_eq!(adv.other.len(), 2);
648 }
649
650 pub(crate) fn hex_lit(s: &str) -> Vec<u8> {
651 hex::decode(s.replace(' ', "")).unwrap()
652 }
653}