Support parsing elemtent ID for WIFI5 and WIFI6

Introduced `Nl80211ElementHeCap` and `Nl80211ElementVhtCap` for element
ID parsing.

Signed-off-by: Gris Ge <[email protected]>

Author: cathay4t

src/element.rs

@@ -6,7 +6,7 @@ use netlink_packet_core::{
 
 use crate::{
     bytes::{parse_u16_le, write_u16_le, write_u32_le},
-    Nl80211ElementHtCap,
+    Nl80211ElementHeCap, Nl80211ElementHtCap, Nl80211ElementVhtCap,
 };
 
 /// [Nl80211Elements] Vec
@@ -64,7 +64,10 @@ const ELEMENT_ID_CHANNEL: u8 = 3;
 const ELEMENT_ID_COUNTRY: u8 = 7;
 const ELEMENT_ID_HT_CAP: u8 = 45;
 const ELEMENT_ID_RSN: u8 = 48;
+const ELEMENT_ID_VHT_CAP: u8 = 191;
 const ELEMENT_ID_VENDOR: u8 = 221;
+const ELEMENT_ID_EXTENSION: u8 = 255;
+const ELEMENT_ID_EXTENSION_HE_CAP: u8 = 35;
 
 /// IEEE 802.11-2020 `9.4.2 Elements`
 #[derive(Debug, PartialEq, Eq, Clone)]
@@ -79,8 +82,10 @@ pub enum Nl80211Element {
     Country(Nl80211ElementCountry),
     HtCapability(Nl80211ElementHtCap),
     Rsn(Nl80211ElementRsn),
+    VhtCapability(Nl80211ElementVhtCap),
     /// Vendor specific data.
     Vendor(Vec<u8>),
+    HeCapability(Nl80211ElementHeCap),
     Other(u8, Vec<u8>),
 }
 
@@ -95,6 +100,8 @@ impl Nl80211Element {
             Self::Rsn(_) => ELEMENT_ID_RSN,
             Self::Vendor(_) => ELEMENT_ID_VENDOR,
             Self::HtCapability(_) => ELEMENT_ID_HT_CAP,
+            Self::VhtCapability(_) => ELEMENT_ID_VHT_CAP,
+            Self::HeCapability(_) => ELEMENT_ID_EXTENSION,
             Self::Other(id, _) => *id,
         }
     }
@@ -109,6 +116,8 @@ impl Nl80211Element {
             Self::Rsn(v) => v.buffer_len() as u8,
             Self::Vendor(v) => v.len() as u8,
             Self::HtCapability(v) => v.buffer_len() as u8,
+            Self::VhtCapability(v) => v.buffer_len() as u8,
+            Self::HeCapability(v) => v.buffer_len() as u8,
             Self::Other(_, data) => (data.len()) as u8,
         }
     }
@@ -147,6 +156,16 @@ impl<T: AsRef<[u8]> + ?Sized> Parseable<T> for Nl80211Element {
             ELEMENT_ID_HT_CAP => {
                 Self::HtCapability(Nl80211ElementHtCap::parse(payload)?)
             }
+            ELEMENT_ID_VHT_CAP => {
+                Self::VhtCapability(Nl80211ElementVhtCap::parse(payload)?)
+            }
+            ELEMENT_ID_EXTENSION => {
+                if payload[0] == ELEMENT_ID_EXTENSION_HE_CAP {
+                    Self::HeCapability(Nl80211ElementHeCap::parse(payload)?)
+                } else {
+                    Self::Other(ELEMENT_ID_EXTENSION, payload.to_vec())
+                }
+            }
             _ => Self::Other(id, payload.to_vec()),
         })
     }
@@ -160,25 +179,27 @@ impl Emitable for Nl80211Element {
     fn emit(&self, buffer: &mut [u8]) {
         buffer[0] = self.id();
         buffer[1] = self.length();
-        let payload = &mut buffer[2..self.length() as usize + 2];
+        let buffer = &mut buffer[2..self.length() as usize + 2];
         match self {
             Self::Ssid(s) => {
                 // IEEE 802.11-2020 indicate it is optional to have NULL
                 // terminator for this string.
-                payload.copy_from_slice(s.as_bytes());
+                buffer.copy_from_slice(s.as_bytes());
             }
             Self::SupportedRatesAndSelectors(v) => {
                 let raw: Vec<u8> =
                     v.as_slice().iter().map(|v| u8::from(*v)).collect();
-                payload.copy_from_slice(raw.as_slice());
+                buffer.copy_from_slice(raw.as_slice());
             }
             Self::Channel(v) => buffer[0] = *v,
             Self::Country(v) => v.emit(buffer),
             Self::Rsn(v) => v.emit(buffer),
             Self::Vendor(v) => buffer[..v.len()].copy_from_slice(v.as_slice()),
             Self::HtCapability(v) => v.emit(buffer),
+            Self::VhtCapability(v) => v.emit(buffer),
+            Self::HeCapability(v) => v.emit(buffer),
             Self::Other(_, data) => {
-                payload.copy_from_slice(data.as_slice());
+                buffer.copy_from_slice(data.as_slice());
             }
         }
     }

src/lib.rs

@@ -83,11 +83,12 @@ pub use self::wifi4::{
     Nl80211HtWiphyChannelType,
 };
 pub use self::wifi5::{
-    Nl80211VhtCapInfo, Nl80211VhtCapability, Nl80211VhtMcsInfo,
+    Nl80211ElementVhtCap, Nl80211VhtCapInfo, Nl80211VhtCapability,
+    Nl80211VhtMcsInfo,
 };
 pub use self::wifi6::{
-    Nl80211He6GhzCapa, Nl80211HeMacCapInfo, Nl80211HeMcsNssSupp,
-    Nl80211HePhyCapInfo, Nl80211HePpeThreshold,
+    Nl80211ElementHeCap, Nl80211He6GhzCapa, Nl80211HeMacCapInfo,
+    Nl80211HeMcsNssSupp, Nl80211HePhyCapInfo, Nl80211HePpeThreshold,
 };
 pub use self::wifi7::{
     Nl80211EhtMacCapInfo, Nl80211EhtMcsNssSupp,

src/wifi5.rs

@@ -12,6 +12,7 @@ const NL80211_BAND_VHT_MCS_INFO_LEN: usize = 8;
 
 // We cannot use buffer! macro here as these u16 are all little endian while
 // The `buffer!` does not support little endian yet.
+/// IEEE 802-11 2020: 9.4.2.157.3 Supported VHT-MCS and NSS Set field
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub struct Nl80211VhtMcsInfo {
     pub rx_mcs_map: u16,
@@ -105,6 +106,7 @@ const IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN: u32 = 0x20000000;
 const IEEE80211_VHT_CAP_EXT_NSS_BW_MASK: u32 = 0xc0000000;
 
 bitflags::bitflags! {
+    /// IEEE 802-11 2020: 9.4.2.157.2 VHT Capabilities Information field
     #[derive(Debug, Default, PartialEq, Eq, Clone, Copy)]
     #[non_exhaustive]
     pub struct Nl80211VhtCapInfo: u32 {
@@ -223,3 +225,57 @@ impl<T: AsRef<[u8]> + ?Sized> Parseable<T> for Nl80211VhtCapability {
         }
     }
 }
+
+/// IEEE 802-11 2020: 9.4.2.157 VHT Capabilities element
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub struct Nl80211ElementVhtCap {
+    /// Vht Capabilities Info
+    pub caps: Nl80211VhtCapInfo,
+    /// Supported VHT-MCS and NSS Set
+    pub mcs_nss_set: Nl80211VhtMcsInfo,
+}
+
+impl Nl80211ElementVhtCap {
+    // Hard coded by IEEE 802.11-2020: 9.4.2.157
+    pub const LENGTH: usize = 12;
+
+    pub fn parse(buf: &[u8]) -> Result<Self, DecodeError> {
+        if buf.len() < Self::LENGTH {
+            return Err(format!(
+                "Nl80211ElementVhtCap buffer size is smaller than \
+                required size {}: {buf:?}",
+                Self::LENGTH
+            )
+            .into());
+        }
+        let mut offset = 0;
+        let caps = Nl80211VhtCapInfo::parse(
+            &buf[offset..offset + Nl80211VhtCapInfo::LENGTH],
+        )?;
+        offset += Nl80211VhtCapInfo::LENGTH;
+
+        let mcs_nss_set = Nl80211VhtMcsInfo::parse(&buf[offset..])?;
+        Ok(Self { caps, mcs_nss_set })
+    }
+}
+
+impl Emitable for Nl80211ElementVhtCap {
+    fn buffer_len(&self) -> usize {
+        Self::LENGTH
+    }
+
+    fn emit(&self, buffer: &mut [u8]) {
+        if buffer.len() < Self::LENGTH {
+            log::error!(
+                "Nl80211ElementVhtCap buffer size is smaller than \
+                required size {}: {buffer:?}",
+                Self::LENGTH
+            );
+            return;
+        }
+        let mut offset = 0;
+        self.caps.emit(&mut buffer[offset..]);
+        offset += Nl80211VhtCapInfo::LENGTH;
+        self.mcs_nss_set.emit(&mut buffer[offset..]);
+    }
+}

src/wifi6.rs

@@ -11,7 +11,7 @@ const HE_MAC_CAP_INFO_LEN: usize = 6;
 /// "HE MAC Capabilities Information field"
 ///
 /// IEEE 802.11ax-2021 section 9.4.2.248.2
-#[derive(Debug, PartialEq, Eq, Clone)]
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub struct Nl80211HeMacCapInfo(pub [u8; HE_MAC_CAP_INFO_LEN]);
 
 impl Nl80211HeMacCapInfo {
@@ -160,7 +160,7 @@ const HE_PHY_CAP_INFO_LEN: usize = 11;
 /// "HE PHY Capabilities Information field"
 ///
 /// IEEE 802.11ax-2021 section 9.4.2.248.3
-#[derive(Debug, PartialEq, Eq, Clone)]
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub struct Nl80211HePhyCapInfo(pub [u8; HE_PHY_CAP_INFO_LEN]);
 
 impl Nl80211HePhyCapInfo {
@@ -204,9 +204,10 @@ const NL80211_HE_MCS_NSS_SUPP_LEN: usize = 12;
 
 /// Tx/Rx HE MCS NSS Support Field
 ///
-/// The released 802.11ax-2021 has no `Tx/Rx HE MCS NSS Support` section, this
-/// struct is merely copy of linux kernel `struct ieee80211_he_mcs_nss_supp`.
-#[derive(Debug, PartialEq, Eq, Clone)]
+/// IEEE 802-11 2020: 9.4.2.157.3 Supported VHT-MCS and NSS Set field
+/// The IEEE standard indicate the size is 4, 8, or 12. But kernel
+/// struct is `struct ieee80211_he_mcs_nss_supp` which is always size 12.
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
 #[non_exhaustive]
 pub struct Nl80211HeMcsNssSupp {
     /// Rx MCS map 2 bits for each stream, total 8 streams, for channel widths
@@ -414,3 +415,79 @@ impl Emitable for Nl80211He6GhzCapa {
         buffer[..IEEE80211_HE_6GHZ_CAP_LEN].copy_from_slice(&self.0)
     }
 }
+
+const ELEMENT_ID_EXTENSION_HE_CAP: u8 = 35;
+
+/// IEEE 802-11 2024: 9.4.2.247 HE Capabilities element
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub struct Nl80211ElementHeCap {
+    /// HE MAC Capabilities Info
+    pub mac_caps: Nl80211HeMacCapInfo,
+    /// HE PHY Capabilities Info
+    pub phy_caps: Nl80211HePhyCapInfo,
+    /// Supported VHT-MCS and NSS Set
+    pub mcs_nss_set: Nl80211HeMcsNssSupp,
+}
+
+impl Nl80211ElementHeCap {
+    // valid size is from 22 to 30
+    pub const LENGTH: usize = 22;
+    const MAX_LENGTH: usize = 30;
+
+    pub fn parse(buf: &[u8]) -> Result<Self, DecodeError> {
+        if buf.len() < Self::LENGTH {
+            return Err(format!(
+                "Nl80211ElementHeCap buffer size is smaller than \
+                minimum size {}: {buf:?}",
+                Self::LENGTH
+            )
+            .into());
+        }
+        // first byte is extension id 35
+        let mut offset = 1usize;
+        let mac_caps =
+            Nl80211HeMacCapInfo::new(&buf[offset..Nl80211HeMacCapInfo::LENGTH]);
+        offset += Nl80211HeMacCapInfo::LENGTH;
+
+        let phy_caps =
+            Nl80211HePhyCapInfo::new(&buf[offset..Nl80211HePhyCapInfo::LENGTH]);
+        offset += Nl80211HePhyCapInfo::LENGTH;
+
+        let remains = &buf[offset..];
+        let mut raw = vec![0u8; Nl80211HeMcsNssSupp::LENGTH];
+
+        raw[..remains.len()].copy_from_slice(remains);
+
+        let mcs_nss_set = Nl80211HeMcsNssSupp::parse(&raw)?;
+
+        Ok(Self {
+            mac_caps,
+            phy_caps,
+            mcs_nss_set,
+        })
+    }
+}
+
+impl Emitable for Nl80211ElementHeCap {
+    fn buffer_len(&self) -> usize {
+        Self::MAX_LENGTH
+    }
+
+    fn emit(&self, buffer: &mut [u8]) {
+        if buffer.len() < Self::MAX_LENGTH {
+            log::error!(
+                "Nl80211ElementHeCap buffer size is smaller than \
+                required size {}: {buffer:?}",
+                Self::LENGTH
+            );
+            return;
+        }
+        buffer[0] = ELEMENT_ID_EXTENSION_HE_CAP;
+        let mut offset = 1;
+        self.mac_caps.emit(&mut buffer[offset..]);
+        offset += Nl80211HeMacCapInfo::LENGTH;
+        self.phy_caps.emit(&mut buffer[offset..]);
+        offset += Nl80211HePhyCapInfo::LENGTH;
+        self.mcs_nss_set.emit(&mut buffer[offset..]);
+    }
+}