feat: add all service advertisement variants

Author: paroga

examples/apps/src/ble_bas_peripheral.rs

@@ -145,7 +145,7 @@ async fn advertise<'values, 'server, C: Controller>(
     let len = AdStructure::encode_slice(
         &[
             AdStructure::Flags(LE_GENERAL_DISCOVERABLE | BR_EDR_NOT_SUPPORTED),
-            AdStructure::ServiceUuids16(&[[0x0f, 0x18]]),
+            AdStructure::IncompleteServiceUuids16(&[[0x0f, 0x18]]),
             AdStructure::CompleteLocalName(name.as_bytes()),
         ],
         &mut advertiser_data[..],

examples/apps/src/ble_bas_peripheral_auth.rs

@@ -197,7 +197,7 @@ async fn advertise<'values, 'server, C: Controller>(
     let len = AdStructure::encode_slice(
         &[
             AdStructure::Flags(LE_GENERAL_DISCOVERABLE | BR_EDR_NOT_SUPPORTED),
-            AdStructure::ServiceUuids16(&[[0x0f, 0x18]]),
+            AdStructure::IncompleteServiceUuids16(&[[0x0f, 0x18]]),
             AdStructure::CompleteLocalName(name.as_bytes()),
         ],
         &mut advertiser_data[..],

examples/apps/src/ble_bas_peripheral_bonding.rs

@@ -337,7 +337,7 @@ async fn advertise<'values, 'server, C: Controller>(
     let len = AdStructure::encode_slice(
         &[
             AdStructure::Flags(LE_GENERAL_DISCOVERABLE | BR_EDR_NOT_SUPPORTED),
-            AdStructure::ServiceUuids16(&[
+            AdStructure::IncompleteServiceUuids16(&[
                 service::BATTERY.to_le_bytes(),
                 service::HUMAN_INTERFACE_DEVICE.to_le_bytes(),
             ]),

examples/apps/src/ble_bas_peripheral_pass_key.rs

@@ -181,7 +181,7 @@ async fn advertise<'values, 'server, C: Controller>(
     let len = AdStructure::encode_slice(
         &[
             AdStructure::Flags(LE_GENERAL_DISCOVERABLE | BR_EDR_NOT_SUPPORTED),
-            AdStructure::ServiceUuids16(&[[0x0f, 0x18]]),
+            AdStructure::IncompleteServiceUuids16(&[[0x0f, 0x18]]),
             AdStructure::CompleteLocalName(name.as_bytes()),
         ],
         &mut advertiser_data[..],

examples/apps/src/ble_bas_peripheral_sec.rs

@@ -177,7 +177,7 @@ async fn advertise<'values, 'server, C: Controller>(
     let len = AdStructure::encode_slice(
         &[
             AdStructure::Flags(LE_GENERAL_DISCOVERABLE | BR_EDR_NOT_SUPPORTED),
-            AdStructure::ServiceUuids16(&[[0x0f, 0x18]]),
+            AdStructure::IncompleteServiceUuids16(&[[0x0f, 0x18]]),
             AdStructure::CompleteLocalName(name.as_bytes()),
         ],
         &mut advertiser_data[..],

host/src/advertise.rs

@@ -360,13 +360,29 @@ pub enum AdStructure<'a> {
     /// Must not be used in scan response data.
     Flags(u8),
 
-    /// List of 16-bit service UUIDs.
+    /// Incomplete List of 16-bit service UUIDs.
     /// The UUID data matches the ble network's endian order (should be little endian).
-    ServiceUuids16(&'a [[u8; 2]]),
+    IncompleteServiceUuids16(&'a [[u8; 2]]),
 
-    /// List of 128-bit service UUIDs.
+    /// Complete List of 16-bit service UUIDs.
     /// The UUID data matches the ble network's endian order (should be little endian).
-    ServiceUuids128(&'a [[u8; 16]]),
+    CompleteServiceUuids16(&'a [[u8; 2]]),
+
+    /// Incomplete List of 32-bit service UUIDs.
+    /// The UUID data matches the ble network's endian order (should be little endian).
+    IncompleteServiceUuids32(&'a [[u8; 4]]),
+
+    /// Complete List of 32-bit service UUIDs.
+    /// The UUID data matches the ble network's endian order (should be little endian).
+    CompleteServiceUuids32(&'a [[u8; 4]]),
+
+    /// Incomplete List of 128-bit service UUIDs.
+    /// The UUID data matches the ble network's endian order (should be little endian).
+    IncompleteServiceUuids128(&'a [[u8; 16]]),
+
+    /// Complete List of 128-bit service UUIDs.
+    /// The UUID data matches the ble network's endian order (should be little endian).
+    CompleteServiceUuids128(&'a [[u8; 16]]),
 
     /// Service data with 16-bit service UUID.
     /// The UUID data matches the ble network's endian order (should be little endian).
@@ -417,13 +433,37 @@ impl AdStructure<'_> {
             AdStructure::Flags(flags) => {
                 w.append(&[0x02, 0x01, *flags])?;
             }
-            AdStructure::ServiceUuids16(uuids) => {
+            AdStructure::IncompleteServiceUuids16(uuids) => {
                 w.append(&[(uuids.len() * 2 + 1) as u8, 0x02])?;
                 for uuid in uuids.iter() {
                     w.write_ref(&Uuid::Uuid16(*uuid))?;
                 }
             }
-            AdStructure::ServiceUuids128(uuids) => {
+            AdStructure::CompleteServiceUuids16(uuids) => {
+                w.append(&[(uuids.len() * 2 + 1) as u8, 0x03])?;
+                for uuid in uuids.iter() {
+                    w.write_ref(&Uuid::Uuid16(*uuid))?;
+                }
+            }
+            AdStructure::IncompleteServiceUuids32(uuids) => {
+                w.append(&[(uuids.len() * 4 + 1) as u8, 0x04])?;
+                for uuid in uuids.iter() {
+                    w.write_ref(&Uuid::Uuid32(*uuid))?;
+                }
+            }
+            AdStructure::CompleteServiceUuids32(uuids) => {
+                w.append(&[(uuids.len() * 4 + 1) as u8, 0x05])?;
+                for uuid in uuids.iter() {
+                    w.write_ref(&Uuid::Uuid32(*uuid))?;
+                }
+            }
+            AdStructure::IncompleteServiceUuids128(uuids) => {
+                w.append(&[(uuids.len() * 16 + 1) as u8, 0x06])?;
+                for uuid in uuids.iter() {
+                    w.write_ref(&Uuid::Uuid128(*uuid))?;
+                }
+            }
+            AdStructure::CompleteServiceUuids128(uuids) => {
                 w.append(&[(uuids.len() * 16 + 1) as u8, 0x07])?;
                 for uuid in uuids.iter() {
                     w.write_ref(&Uuid::Uuid128(*uuid))?;
@@ -485,24 +525,48 @@ impl<'d> AdStructureIter<'d> {
             // Flags
             0x01 => Ok(AdStructure::Flags(data[0])),
             // Incomplete List of 16-bit Service or Service Class UUIDs
-            // 0x02 =>
+            0x02 => match zerocopy::FromBytes::ref_from_bytes(data) {
+                Ok(x) => Ok(AdStructure::IncompleteServiceUuids16(x)),
+                Err(e) => {
+                    let _ = zerocopy::SizeError::from(e);
+                    Err(codec::Error::InvalidValue)
+                }
+            },
             // Complete List of 16-bit Service or Service Class UUIDs
             0x03 => match zerocopy::FromBytes::ref_from_bytes(data) {
-                Ok(x) => Ok(AdStructure::ServiceUuids16(x)),
+                Ok(x) => Ok(AdStructure::CompleteServiceUuids16(x)),
                 Err(e) => {
                     let _ = zerocopy::SizeError::from(e);
                     Err(codec::Error::InvalidValue)
                 }
             },
             // Incomplete List of 32-bit Service or Service Class UUIDs
-            // 0x04 =>
+            0x04 => match zerocopy::FromBytes::ref_from_bytes(data) {
+                Ok(x) => Ok(AdStructure::IncompleteServiceUuids32(x)),
+                Err(e) => {
+                    let _ = zerocopy::SizeError::from(e);
+                    Err(codec::Error::InvalidValue)
+                }
+            },
             // Complete List of 32-bit Service or Service Class UUIDs
-            // 0x05
+            0x05 => match zerocopy::FromBytes::ref_from_bytes(data) {
+                Ok(x) => Ok(AdStructure::CompleteServiceUuids32(x)),
+                Err(e) => {
+                    let _ = zerocopy::SizeError::from(e);
+                    Err(codec::Error::InvalidValue)
+                }
+            },
             // Incomplete List of 128-bit Service or Service Class UUIDs
-            // 0x06
+            0x06 => match zerocopy::FromBytes::ref_from_bytes(data) {
+                Ok(x) => Ok(AdStructure::IncompleteServiceUuids128(x)),
+                Err(e) => {
+                    let _ = zerocopy::SizeError::from(e);
+                    Err(codec::Error::InvalidValue)
+                }
+            },
             // Complete List of 128-bit Service or Service Class UUIDs
             0x07 => match zerocopy::FromBytes::ref_from_bytes(data) {
-                Ok(x) => Ok(AdStructure::ServiceUuids128(x)),
+                Ok(x) => Ok(AdStructure::CompleteServiceUuids128(x)),
                 Err(e) => {
                     let _ = zerocopy::SizeError::from(e);
                     Err(codec::Error::InvalidValue)
@@ -594,7 +658,7 @@ mod tests {
         assert!(AdStructure::encode_slice(
             &[
                 AdStructure::Flags(LE_GENERAL_DISCOVERABLE | BR_EDR_NOT_SUPPORTED),
-                AdStructure::ServiceUuids16(&[[0x0f, 0x18]]),
+                AdStructure::IncompleteServiceUuids16(&[[0x0f, 0x18]]),
                 AdStructure::CompleteLocalName(b"12345678901234567890123"),
             ],
             &mut adv_data[..],