| // Copyright 2019 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| use { |
| crate::utils::skip, |
| bitfield::bitfield, |
| byteorder::{BigEndian, ByteOrder, LittleEndian}, |
| num::{One, Unsigned}, |
| zerocopy::{AsBytes, ByteSlice, FromBytes, LayoutVerified, Unaligned}, |
| }; |
| |
| type MacAddr = [u8; 6]; |
| pub const BCAST_ADDR: MacAddr = [0xFF; 6]; |
| |
| // IEEE Std 802.11-2016, 9.2.4.1.3 |
| // Frame types: |
| pub const FRAME_TYPE_MGMT: u16 = 0; |
| pub const FRAME_TYPE_DATA: u16 = 2; |
| // Management subtypes: |
| pub const MGMT_SUBTYPE_ASSOC_RESP: u16 = 0x01; |
| pub const MGMT_SUBTYPE_BEACON: u16 = 0x08; |
| pub const MGMT_SUBTYPE_AUTH: u16 = 0x0B; |
| // Data subtypes: |
| pub const DATA_SUBTYPE_DATA: u16 = 0x00; |
| pub const DATA_SUBTYPE_NULL_DATA: u16 = 0x04; |
| pub const DATA_SUBTYPE_QOS_DATA: u16 = 0x08; |
| |
| // IEEE Std 802.11-2016, 9.2.4.1.3, Table 9-1 |
| const BITMASK_NULL: u16 = 1 << 2; |
| const BITMASK_QOS: u16 = 1 << 3; |
| |
| // IEEE Std 802.11-2016, 9.2.4.1.1 |
| bitfield! { |
| #[derive(PartialEq)] |
| pub struct FrameControl(u16); |
| impl Debug; |
| |
| pub protocol_version, set_protocol_version: 1, 0; |
| pub frame_type, set_frame_type: 3, 2; |
| pub frame_subtype, set_frame_subtype: 7, 4; |
| pub to_ds, set_to_ds: 8; |
| pub from_ds, set_from_ds: 9; |
| pub more_frag, set_more_frag: 19; |
| pub retry, set_retry: 11; |
| pub pwr_mgmt, set_pwr_mgmt: 12; |
| pub more_data, set_more_data: 13; |
| pub protected, set_protected: 14; |
| pub htc_order, set_htc_order: 15; |
| |
| pub value, _: 15,0; |
| } |
| |
| impl FrameControl { |
| pub fn from_bytes(bytes: &[u8]) -> Option<FrameControl> { |
| if bytes.len() < 2 { |
| None |
| } else { |
| Some(FrameControl(LittleEndian::read_u16(bytes))) |
| } |
| } |
| } |
| |
| // IEEE Std 802.11-2016, 9.2.4.4 |
| bitfield! { |
| pub struct SequenceControl(u16); |
| impl Debug; |
| |
| pub frag_num, set_frag_num: 3, 0; |
| pub seq_num, set_seq_num: 15, 4; |
| |
| pub value, _: 15,0; |
| } |
| |
| impl SequenceControl { |
| pub fn from_bytes(bytes: &[u8]) -> Option<SequenceControl> { |
| if bytes.len() < 2 { |
| None |
| } else { |
| Some(SequenceControl(LittleEndian::read_u16(bytes))) |
| } |
| } |
| } |
| |
| // IEEE Std 802.11-2016, 9.2.4.6 |
| bitfield! { |
| #[derive(PartialEq)] |
| pub struct HtControl(u32); |
| impl Debug; |
| |
| pub vht, set_vht: 0; |
| // Structure of this middle section is defined in 9.2.4.6.2 for HT, |
| // and 9.2.4.6.3 for VHT. |
| pub middle, set_middle: 29, 1; |
| pub ac_constraint, set_ac_constraint: 30; |
| pub rdg_more_ppdu, setrdg_more_ppdu: 31; |
| |
| pub value, _: 31,0; |
| } |
| |
| impl HtControl { |
| pub fn from_bytes(bytes: &[u8]) -> Option<HtControl> { |
| if bytes.len() < 4 { |
| None |
| } else { |
| Some(HtControl(LittleEndian::read_u32(bytes))) |
| } |
| } |
| } |
| |
| // IEEE Std 802.11-2016, 9.4.1.4 |
| bitfield! { |
| pub struct CapabilityInfo(u16); |
| impl Debug; |
| |
| pub ess, set_ess: 0; |
| pub ibss, set_ibss: 1; |
| pub cf_pollable, set_cf_pollable: 2; |
| pub cf_poll_req, set_cf_poll_req: 3; |
| pub privacy, set_privacy: 4; |
| pub short_preamble, set_short_preamble: 5; |
| // bit 6-7 reserved |
| pub spectrum_mgmt, set_spectrum_mgmt: 8; |
| pub qos, set_qos: 9; |
| pub short_slot_time, set_short_slot_time: 10; |
| pub apsd, set_apsd: 11; |
| pub radio_msmt, set_radio_msmt: 12; |
| // bit 13 reserved |
| pub delayed_block_ack, set_delayed_block_ack: 14; |
| pub immediate_block_ack, set_immediate_block_ack: 15; |
| |
| pub value, _: 15, 0; |
| } |
| |
| impl CapabilityInfo { |
| pub fn from_bytes(bytes: &[u8]) -> Option<CapabilityInfo> { |
| if bytes.len() < 4 { |
| None |
| } else { |
| Some(CapabilityInfo(LittleEndian::read_u16(bytes))) |
| } |
| } |
| } |
| |
| // IEEE Std 802.11-2016, 9.3.3.2 |
| #[repr(C, packed)] |
| pub struct MgmtHdr { |
| pub frame_ctrl: [u8; 2], |
| pub duration: [u8; 2], |
| pub addr1: MacAddr, |
| pub addr2: MacAddr, |
| pub addr3: MacAddr, |
| pub seq_ctrl: [u8; 2], |
| } |
| // Safe: see macro explanation. |
| unsafe_impl_zerocopy_traits!(MgmtHdr); |
| |
| impl MgmtHdr { |
| pub fn frame_ctrl(&self) -> u16 { |
| LittleEndian::read_u16(&self.frame_ctrl) |
| } |
| |
| pub fn duration(&self) -> u16 { |
| LittleEndian::read_u16(&self.duration) |
| } |
| |
| pub fn seq_ctrl(&self) -> u16 { |
| LittleEndian::read_u16(&self.seq_ctrl) |
| } |
| |
| pub fn set_frame_ctrl(&mut self, val: u16) { |
| LittleEndian::write_u16(&mut self.frame_ctrl, val) |
| } |
| |
| pub fn set_duration(&mut self, val: u16) { |
| LittleEndian::write_u16(&mut self.duration, val) |
| } |
| |
| pub fn set_seq_ctrl(&mut self, val: u16) { |
| LittleEndian::write_u16(&mut self.seq_ctrl, val) |
| } |
| |
| /// Returns the length in bytes of a mgmt header including all its fixed and optional |
| /// fields (if they are present). |
| pub fn len(has_ht_ctrl: bool) -> usize { |
| let mut bytes = std::mem::size_of::<DataHdr>(); |
| bytes += if has_ht_ctrl { std::mem::size_of::<RawHtControl>() } else { 0 }; |
| bytes |
| } |
| } |
| |
| // IEEE Std 802.11-2016, 9.3.2.1 |
| #[repr(C, packed)] |
| pub struct DataHdr { |
| pub frame_ctrl: [u8; 2], |
| pub duration: [u8; 2], |
| pub addr1: MacAddr, |
| pub addr2: MacAddr, |
| pub addr3: MacAddr, |
| pub seq_ctrl: [u8; 2], |
| } |
| // Safe: see macro explanation. |
| unsafe_impl_zerocopy_traits!(DataHdr); |
| |
| impl DataHdr { |
| pub fn frame_ctrl(&self) -> u16 { |
| LittleEndian::read_u16(&self.frame_ctrl) |
| } |
| |
| pub fn duration(&self) -> u16 { |
| LittleEndian::read_u16(&self.duration) |
| } |
| |
| pub fn seq_ctrl(&self) -> u16 { |
| LittleEndian::read_u16(&self.seq_ctrl) |
| } |
| |
| pub fn set_frame_ctrl(&mut self, val: u16) { |
| LittleEndian::write_u16(&mut self.frame_ctrl, val) |
| } |
| |
| pub fn set_duration(&mut self, val: u16) { |
| LittleEndian::write_u16(&mut self.duration, val) |
| } |
| |
| pub fn set_seq_ctrl(&mut self, val: u16) { |
| LittleEndian::write_u16(&mut self.seq_ctrl, val) |
| } |
| |
| /// Returns the length in bytes of a data header including all its fixed and optional |
| /// fields (if they are present). |
| pub fn len(has_addr4: bool, has_qos_ctrl: bool, has_ht_ctrl: bool) -> usize { |
| let mut bytes = std::mem::size_of::<DataHdr>(); |
| bytes += if has_addr4 { std::mem::size_of::<MacAddr>() } else { 0 }; |
| bytes += if has_qos_ctrl { std::mem::size_of::<RawQosControl>() } else { 0 }; |
| bytes += if has_ht_ctrl { std::mem::size_of::<RawHtControl>() } else { 0 }; |
| bytes |
| } |
| } |
| |
| type RawHtControl = [u8; 4]; |
| type RawQosControl = [u8; 2]; |
| |
| pub enum MacFrame<B> { |
| Mgmt { |
| // Management Header: fixed fields |
| mgmt_hdr: LayoutVerified<B, MgmtHdr>, |
| // Management Header: optional fields |
| ht_ctrl: Option<LayoutVerified<B, RawHtControl>>, |
| // Body |
| body: B, |
| }, |
| Data { |
| // Data Header: fixed fields |
| data_hdr: LayoutVerified<B, DataHdr>, |
| // Data Header: optional fields |
| addr4: Option<LayoutVerified<B, MacAddr>>, |
| qos_ctrl: Option<LayoutVerified<B, RawQosControl>>, |
| ht_ctrl: Option<LayoutVerified<B, RawHtControl>>, |
| // Body |
| body: B, |
| }, |
| Unsupported { |
| type_: u16, |
| }, |
| } |
| |
| impl<B: ByteSlice> MacFrame<B> { |
| /// If `body_aligned` is |true| the frame's body is expected to be 4 byte aligned. |
| pub fn parse(bytes: B, body_aligned: bool) -> Option<MacFrame<B>> { |
| let fc = FrameControl::from_bytes(&bytes[..])?; |
| match fc.frame_type() { |
| FRAME_TYPE_MGMT => { |
| // Parse fixed header fields: |
| let (mgmt_hdr, body) = LayoutVerified::new_unaligned_from_prefix(bytes)?; |
| |
| // Parse optional header fields: |
| let (ht_ctrl, body) = parse_ht_ctrl_if_present(&fc, body)?; |
| |
| // Skip optional padding if body alignment is used. |
| let body = if body_aligned { |
| let full_hdr_len = MgmtHdr::len(ht_ctrl.is_some()); |
| skip_body_alignment_padding(full_hdr_len, body)? |
| } else { |
| body |
| }; |
| |
| Some(MacFrame::Mgmt { |
| mgmt_hdr, |
| ht_ctrl, |
| body, |
| }) |
| } |
| FRAME_TYPE_DATA => { |
| // Parse fixed header fields: |
| let (data_hdr, body) = LayoutVerified::new_unaligned_from_prefix(bytes)?; |
| |
| // Parse optional header fields: |
| let (addr4, body) = parse_addr4_if_present(&fc, body)?; |
| let (qos_ctrl, body) = parse_qos_if_present(&fc, body)?; |
| let (ht_ctrl, body) = parse_ht_ctrl_if_present(&fc, body)?; |
| |
| // Skip optional padding if body alignment is used. |
| let body = if body_aligned { |
| let full_hdr_len = DataHdr::len(addr4.is_some(), qos_ctrl.is_some(), |
| ht_ctrl.is_some()); |
| skip_body_alignment_padding(full_hdr_len, body)? |
| } else { |
| body |
| }; |
| |
| Some(MacFrame::Data { |
| data_hdr, |
| addr4, |
| qos_ctrl, |
| ht_ctrl, |
| body, |
| }) |
| } |
| type_ => Some(MacFrame::Unsupported { type_ }), |
| } |
| } |
| } |
| |
| |
| /// Returns |None| if parsing fails. Otherwise returns |Some(tuple)| with `tuple` holding a |
| /// `MacAddr` if it is present and the remaining bytes. |
| fn parse_addr4_if_present<B: ByteSlice>(fc: &FrameControl, bytes: B) |
| -> Option<(Option<LayoutVerified<B, MacAddr>>, B)> |
| { |
| if fc.to_ds() && fc.from_ds() { |
| let (addr4, bytes) = LayoutVerified::new_unaligned_from_prefix(bytes)?; |
| Some((Some(addr4), bytes)) |
| } else { |
| Some((None, bytes)) |
| } |
| } |
| |
| |
| /// Returns |None| if parsing fails. Otherwise returns |Some(tuple)| with `tuple` holding the |
| /// `QosControl` if it is present and the remaining bytes. |
| fn parse_qos_if_present<B: ByteSlice>(fc: &FrameControl, bytes: B) |
| -> Option<(Option<LayoutVerified<B, RawQosControl>>, B)> |
| { |
| if fc.frame_subtype() & BITMASK_QOS != 0 { |
| let (qos_ctrl, bytes) = LayoutVerified::new_unaligned_from_prefix(bytes)?; |
| Some((Some(qos_ctrl), bytes)) |
| } else { |
| Some((None, bytes)) |
| } |
| } |
| |
| /// Returns |None| if parsing fails. Otherwise returns |Some(tuple)| with `tuple` holding the |
| /// `HtControl` if it is present and the remaining bytes. |
| fn parse_ht_ctrl_if_present<B: ByteSlice>(fc: &FrameControl, bytes: B) |
| -> Option<(Option<LayoutVerified<B, RawHtControl>>, B)> |
| { |
| if fc.htc_order() { |
| let (ht_ctrl, bytes) = LayoutVerified::new_unaligned_from_prefix(bytes)?; |
| Some((Some(ht_ctrl), bytes)) |
| } else { |
| Some((None, bytes)) |
| } |
| } |
| |
| /// Skips optional padding required for body alignment. |
| fn skip_body_alignment_padding<B: ByteSlice>(hdr_len: usize, bytes: B) -> Option<B> { |
| const OPTIONAL_BODY_ALIGNMENT_BYTES: usize = 4; |
| |
| let padded_len = round_up(hdr_len, OPTIONAL_BODY_ALIGNMENT_BYTES); |
| let padding = padded_len - hdr_len; |
| skip(bytes, padding) |
| } |
| |
| // IEEE Std 802.11-2016, 9.3.3.3 |
| #[repr(C, packed)] |
| pub struct BeaconHdr { |
| pub timestamp: [u8; 8], |
| pub beacon_interval: [u8; 2], |
| // IEEE Std 802.11-2016, 9.4.1.4 |
| pub capabilities: [u8; 2], |
| } |
| // Safe: see macro explanation. |
| unsafe_impl_zerocopy_traits!(BeaconHdr); |
| |
| impl BeaconHdr { |
| pub fn timestamp(&self) -> u64 { |
| LittleEndian::read_u64(&self.timestamp) |
| } |
| |
| pub fn beacon_interval(&self) -> u16 { |
| LittleEndian::read_u16(&self.beacon_interval) |
| } |
| |
| pub fn capabilities(&self) -> u16 { |
| LittleEndian::read_u16(&self.capabilities) |
| } |
| } |
| |
| // IEEE Std 802.11-2016, 9.4.1.1 |
| #[repr(u16)] |
| pub enum AuthAlgorithm { |
| Open = 0, |
| _SharedKey = 1, |
| _FastBssTransition = 2, |
| Sae = 3, |
| // 4-65534 Reserved |
| _VendorSpecific = 65535, |
| } |
| |
| // IEEE Std 802.11-2016, 9.3.3.12 |
| #[repr(C, packed)] |
| #[derive(Default)] |
| pub struct AuthHdr { |
| pub auth_alg_num: [u8; 2], |
| pub auth_txn_seq_num: [u8; 2], |
| pub status_code: [u8; 2], |
| } |
| // Safe: see macro explanation. |
| unsafe_impl_zerocopy_traits!(AuthHdr); |
| |
| impl AuthHdr { |
| pub fn auth_alg_num(&self) -> u16 { |
| LittleEndian::read_u16(&self.auth_alg_num) |
| } |
| |
| pub fn set_auth_alg_num(&mut self, val: u16) { |
| LittleEndian::write_u16(&mut self.auth_alg_num, val) |
| } |
| |
| pub fn auth_txn_seq_num(&self) -> u16 { |
| LittleEndian::read_u16(&self.auth_txn_seq_num) |
| } |
| |
| pub fn set_auth_txn_seq_num(&mut self, val: u16) { |
| LittleEndian::write_u16(&mut self.auth_txn_seq_num, val) |
| } |
| |
| pub fn status_code(&self) -> u16 { |
| LittleEndian::read_u16(&self.status_code) |
| } |
| |
| pub fn set_status_code(&mut self, val: u16) { |
| LittleEndian::write_u16(&mut self.status_code, val) |
| } |
| } |
| |
| // IEEE Std 802.11-2016, 9.3.3.6 |
| #[repr(C, packed)] |
| pub struct AssocRespHdr { |
| // IEEE Std 802.11-2016, 9.4.1.4 |
| pub capabilities: [u8; 2], |
| pub status_code: [u8; 2], |
| pub aid: [u8; 2], |
| } |
| // Safe: see macro explanation. |
| unsafe_impl_zerocopy_traits!(AssocRespHdr); |
| |
| impl AssocRespHdr { |
| pub fn capabilities(&self) -> u16 { |
| LittleEndian::read_u16(&self.capabilities) |
| } |
| |
| pub fn status_code(&self) -> u16 { |
| LittleEndian::read_u16(&self.status_code) |
| } |
| |
| pub fn aid(&self) -> u16 { |
| LittleEndian::read_u16(&self.aid) |
| } |
| } |
| |
| pub enum MgmtSubtype<B> { |
| Beacon { |
| bcn_hdr: LayoutVerified<B, BeaconHdr>, |
| elements: B, |
| }, |
| Authentication { |
| auth_hdr: LayoutVerified<B, AuthHdr>, |
| elements: B, |
| }, |
| AssociationResp { |
| assoc_resp_hdr: LayoutVerified<B, AssocRespHdr>, |
| elements: B, |
| }, |
| Unsupported { |
| subtype: u16, |
| }, |
| } |
| |
| impl<B: ByteSlice> MgmtSubtype<B> { |
| pub fn parse(subtype: u16, bytes: B) -> Option<MgmtSubtype<B>> { |
| match subtype { |
| MGMT_SUBTYPE_BEACON => { |
| let (bcn_hdr, elements) = LayoutVerified::new_unaligned_from_prefix(bytes)?; |
| Some(MgmtSubtype::Beacon { bcn_hdr, elements }) |
| } |
| MGMT_SUBTYPE_AUTH => { |
| let (auth_hdr, elements) = LayoutVerified::new_unaligned_from_prefix(bytes)?; |
| Some(MgmtSubtype::Authentication { auth_hdr, elements }) |
| } |
| MGMT_SUBTYPE_ASSOC_RESP => { |
| let (assoc_resp_hdr, elements) = LayoutVerified::new_unaligned_from_prefix(bytes)?; |
| Some(MgmtSubtype::AssociationResp { assoc_resp_hdr, elements }) |
| } |
| subtype => Some(MgmtSubtype::Unsupported { subtype }), |
| } |
| } |
| } |
| |
| // IEEE Std 802.2-1998, 3.2 |
| // IETF RFC 1042 |
| #[repr(C, packed)] |
| pub struct LlcHdr { |
| pub dsap: u8, |
| pub ssap: u8, |
| pub control: u8, |
| pub oui: [u8; 3], |
| pub protocol_id: [u8; 2], |
| } |
| // Safe: see macro explanation. |
| unsafe_impl_zerocopy_traits!(LlcHdr); |
| |
| impl LlcHdr { |
| pub fn protocol_id(&self) -> u16 { |
| LittleEndian::read_u16(&self.protocol_id) |
| } |
| } |
| |
| // IEEE Std 802.11-2016, 9.3.2.2.2 |
| #[repr(C, packed)] |
| pub struct AmsduSubframeHdr { |
| // Note this is the same as the IEEE 802.3 frame format. |
| pub da: MacAddr, |
| pub sa: MacAddr, |
| pub msdu_len_be: [u8; 2], // In network byte order (big endian). |
| } |
| // Safe: see macro explanation. |
| unsafe_impl_zerocopy_traits!(AmsduSubframeHdr); |
| |
| impl AmsduSubframeHdr { |
| pub fn msdu_len(&self) -> u16 { |
| BigEndian::read_u16(&self.msdu_len_be) |
| } |
| } |
| |
| /// Iterates through an A-MSDU frame and provides access to |
| /// individual MSDUs. |
| /// The reader expects the byte stream to start with an |
| /// `AmsduSubframeHdr`. |
| pub struct AmsduReader<'a>(&'a [u8]); |
| |
| impl<'a> AmsduReader<'a> { |
| pub fn has_remaining(&self) -> bool { |
| !self.0.is_empty() |
| } |
| |
| pub fn remaining(&self) -> &'a [u8] { |
| self.0 |
| } |
| } |
| |
| impl<'a> Iterator for AmsduReader<'a> { |
| type Item = &'a [u8]; |
| |
| fn next(&mut self) -> Option<Self::Item> { |
| let (amsdu_subframe_hdr, msdu) = |
| LayoutVerified::<_, AmsduSubframeHdr>::new_unaligned_from_prefix(&self.0[..])?; |
| let msdu_len = amsdu_subframe_hdr.msdu_len() as usize; |
| if msdu.len() < msdu_len { |
| // A-MSDU subframe header is valid, but MSDU doesn't fit into the buffer. |
| None |
| } else { |
| let (msdu, next_padded) = msdu.split_at(msdu_len); |
| |
| // Padding following the last MSDU is optional. |
| if next_padded.is_empty() { |
| self.0 = next_padded; |
| Some(msdu) |
| } else { |
| let base_len = std::mem::size_of::<AmsduSubframeHdr>() + msdu_len; |
| let padded_len = round_up(base_len, 4); |
| let padding_len = padded_len - base_len; |
| if next_padded.len() < padding_len { |
| // Corrupted: buffer to short to hold padding. |
| None |
| } else { |
| let (_padding, next) = next_padded.split_at(padding_len); |
| self.0 = next; |
| Some(msdu) |
| } |
| } |
| } |
| } |
| } |
| |
| pub enum DataSubtype<B> { |
| // QoS or regular data type. |
| Data { |
| is_qos: bool, |
| hdr: LayoutVerified<B, LlcHdr>, |
| payload: B, |
| }, |
| Unsupported { |
| subtype: u16, |
| }, |
| } |
| |
| impl<B: ByteSlice> DataSubtype<B> { |
| pub fn parse(subtype: u16, bytes: B) -> Option<DataSubtype<B>> { |
| match subtype { |
| DATA_SUBTYPE_DATA | DATA_SUBTYPE_QOS_DATA => { |
| let (hdr, payload) = LayoutVerified::new_unaligned_from_prefix(bytes)?; |
| let is_qos = subtype == DATA_SUBTYPE_QOS_DATA; |
| Some(DataSubtype::Data { |
| hdr, |
| is_qos, |
| payload, |
| }) |
| } |
| subtype => Some(DataSubtype::Unsupported { subtype }), |
| } |
| } |
| } |
| |
| |
| // IEEE Std 802.11-2016, 9.4.1.9, Table 9-46 |
| #[repr(u16)] |
| pub enum StatusCode { |
| Success = 0, |
| // ... defined remaining status codes. |
| } |
| |
| fn round_up<T: Unsigned + Copy>(value: T, multiple: T) -> T { |
| let overshoot = value + multiple - T::one(); |
| overshoot - overshoot % multiple |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| use super::*; |
| use std::mem::transmute; |
| |
| fn make_mgmt_frame(ht_ctrl: bool) -> Vec<u8> { |
| #[cfg_attr(rustfmt, rustfmt_skip)] |
| let mut bytes = vec![ |
| 1, if ht_ctrl { 128 } else { 1 }, // fc |
| 2, 2, // duration |
| 3, 3, 3, 3, 3, 3, // addr1 |
| 4, 4, 4, 4, 4, 4, // addr2 |
| 5, 5, 5, 5, 5, 5, // addr3 |
| 6, 6, // sequence control |
| ]; |
| if ht_ctrl { |
| bytes.extend_from_slice(&[8, 8, 8, 8]); |
| } |
| bytes.extend_from_slice(&[9, 9, 9]); |
| bytes |
| } |
| |
| fn make_data_frame(addr4: Option<[u8; 6]>, ht_ctrl: Option<[u8; 4]>) -> Vec<u8> { |
| let mut fc = FrameControl(0); |
| fc.set_frame_type(FRAME_TYPE_DATA); |
| fc.set_frame_subtype(DATA_SUBTYPE_QOS_DATA); |
| fc.set_from_ds(addr4.is_some()); |
| fc.set_to_ds(addr4.is_some()); |
| fc.set_htc_order(ht_ctrl.is_some()); |
| let fc: [u8; 2] = unsafe { transmute(fc.value().to_le()) }; |
| |
| #[cfg_attr(rustfmt, rustfmt_skip)] |
| let mut bytes = vec![ |
| // Data Header |
| fc[0], fc[1], // fc |
| 2, 2, // duration |
| 3, 3, 3, 3, 3, 3, // addr1 |
| 4, 4, 4, 4, 4, 4, // addr2 |
| 5, 5, 5, 5, 5, 5, // addr3 |
| 6, 6, // sequence control |
| ]; |
| |
| if let Some(addr4) = addr4 { |
| bytes.extend_from_slice(&addr4); |
| } |
| |
| // QoS Control |
| bytes.extend_from_slice(&[1, 1]); |
| |
| if let Some(ht_ctrl) = ht_ctrl { |
| bytes.extend_from_slice(&ht_ctrl); |
| } |
| |
| bytes.extend_from_slice(&[ |
| // LLC Header |
| 7, 7, 7, // DSAP, SSAP & control |
| 8, 8, 8, // OUI |
| 9, 9, // eth type |
| // Trailing bytes |
| 10, 10, 10, |
| ]); |
| bytes |
| } |
| |
| fn make_data_frame_with_padding() -> Vec<u8> { |
| let mut fc = FrameControl(0); |
| fc.set_frame_type(FRAME_TYPE_DATA); |
| fc.set_frame_subtype(DATA_SUBTYPE_QOS_DATA); |
| let fc: [u8; 2] = unsafe { transmute(fc.value().to_le()) }; |
| |
| #[cfg_attr(rustfmt, rustfmt_skip)] |
| let bytes = vec![ |
| // Data Header |
| fc[0], fc[1], // fc |
| 2, 2, // duration |
| 3, 3, 3, 3, 3, 3, // addr1 |
| 4, 4, 4, 4, 4, 4, // addr2 |
| 5, 5, 5, 5, 5, 5, // addr3 |
| 6, 6, // sequence control |
| // QoS Control |
| 1, 1, |
| // Padding |
| 2, 2, |
| // Body |
| 7, 7, 7, |
| ]; |
| bytes |
| } |
| |
| #[test] |
| fn mgmt_hdr_len() { |
| assert_eq!(MgmtHdr::len(false), 24); |
| assert_eq!(MgmtHdr::len(true), 28); |
| } |
| |
| #[test] |
| fn data_hdr_len() { |
| assert_eq!(DataHdr::len(false, false, false), 24); |
| assert_eq!(DataHdr::len(true, false, false), 30); |
| assert_eq!(DataHdr::len(false, true, false), 26); |
| assert_eq!(DataHdr::len(false, false, true), 28); |
| assert_eq!(DataHdr::len(true, true, false), 32); |
| assert_eq!(DataHdr::len(false, true, true), 30); |
| assert_eq!(DataHdr::len(true, false, true), 34); |
| assert_eq!(DataHdr::len(true, true, true), 36); |
| } |
| |
| #[test] |
| fn parse_mgmt_frame() { |
| let bytes = make_mgmt_frame(false); |
| match MacFrame::parse(&bytes[..], false) { |
| Some(MacFrame::Mgmt { |
| mgmt_hdr, |
| ht_ctrl, |
| body, |
| }) => { |
| assert_eq!([1, 1], mgmt_hdr.frame_ctrl); |
| assert_eq!([2, 2], mgmt_hdr.duration); |
| assert_eq!([3, 3, 3, 3, 3, 3], mgmt_hdr.addr1); |
| assert_eq!([4, 4, 4, 4, 4, 4], mgmt_hdr.addr2); |
| assert_eq!([5, 5, 5, 5, 5, 5], mgmt_hdr.addr3); |
| assert_eq!([6, 6], mgmt_hdr.seq_ctrl); |
| assert!(ht_ctrl.is_none()); |
| assert_eq!(&body[..], &[9, 9, 9]); |
| } |
| _ => panic!("failed parsing mgmt frame"), |
| }; |
| } |
| |
| #[test] |
| fn parse_mgmt_frame_too_short_unsupported() { |
| // Valid MGMT header must have a minium length of 24 bytes. |
| assert!(MacFrame::parse(&[0; 22][..], false).is_none()); |
| |
| // Unsupported frame type. |
| match MacFrame::parse(&[0xFF; 24][..], false) { |
| Some(MacFrame::Unsupported { type_ }) => assert_eq!(3, type_), |
| _ => panic!("didn't detect unsupported frame"), |
| }; |
| } |
| |
| #[test] |
| fn parse_beacon_frame() { |
| #[cfg_attr(rustfmt, rustfmt_skip)] |
| let bytes = vec![ |
| 1,1,1,1,1,1,1,1, // timestamp |
| 2,2, // beacon_interval |
| 3,3, // capabilities |
| 0,5,1,2,3,4,5 // SSID IE: "12345" |
| ]; |
| match MgmtSubtype::parse(MGMT_SUBTYPE_BEACON, &bytes[..]) { |
| Some(MgmtSubtype::Beacon { bcn_hdr, elements }) => { |
| assert_eq!(0x0101010101010101, bcn_hdr.timestamp()); |
| assert_eq!(0x0202, bcn_hdr.beacon_interval()); |
| assert_eq!(0x0303, bcn_hdr.capabilities()); |
| assert_eq!(&[0, 5, 1, 2, 3, 4, 5], &elements[..]); |
| } |
| _ => panic!("failed parsing beacon frame"), |
| }; |
| } |
| |
| #[test] |
| fn parse_data_frame() { |
| let bytes = make_data_frame(None, None); |
| match MacFrame::parse(&bytes[..], false) { |
| Some(MacFrame::Data { |
| data_hdr, |
| addr4, |
| qos_ctrl, |
| ht_ctrl, |
| body, |
| }) => { |
| assert_eq!([0b10001000, 0], data_hdr.frame_ctrl); |
| assert_eq!([2, 2], data_hdr.duration); |
| assert_eq!([3, 3, 3, 3, 3, 3], data_hdr.addr1); |
| assert_eq!([4, 4, 4, 4, 4, 4], data_hdr.addr2); |
| assert_eq!([5, 5, 5, 5, 5, 5], data_hdr.addr3); |
| assert_eq!([6, 6], data_hdr.seq_ctrl); |
| assert!(addr4.is_none()); |
| match qos_ctrl { |
| None => panic!("qos_ctrl expected to be present"), |
| Some(qos_ctrl) => { |
| assert_eq!(&[1, 1][..], &qos_ctrl[..]); |
| } |
| }; |
| assert!(ht_ctrl.is_none()); |
| assert_eq!(&body[..], &[7, 7, 7, 8, 8, 8, 9, 9, 10, 10, 10]); |
| } |
| _ => panic!("failed parsing data frame"), |
| }; |
| } |
| |
| #[test] |
| fn parse_data_frame_with_padding() { |
| let bytes = make_data_frame_with_padding(); |
| match MacFrame::parse(&bytes[..], true) { |
| Some(MacFrame::Data { qos_ctrl, body, .. }) => { |
| assert_eq!([1, 1], *qos_ctrl.expect("qos_ctrl not present")); |
| assert_eq!(&[7, 7, 7], &body[..]); |
| } |
| _ => panic!("failed parsing data frame"), |
| }; |
| } |
| |
| #[test] |
| fn parse_llc_with_addr4_ht_ctrl() { |
| let bytes = make_data_frame(Some([1, 2, 3, 4, 5, 6]), Some([4, 3, 2, 1])); |
| match MacFrame::parse(&bytes[..], false) { |
| Some(MacFrame::Data { data_hdr, body, .. }) => { |
| let fc = FrameControl(data_hdr.frame_ctrl()); |
| match DataSubtype::parse(fc.frame_subtype(), &body[..]) { |
| Some(DataSubtype::Data { hdr, payload, is_qos }) => { |
| assert!(is_qos); |
| assert_eq!(7, hdr.dsap); |
| assert_eq!(7, hdr.ssap); |
| assert_eq!(7, hdr.control); |
| assert_eq!([8, 8, 8], hdr.oui); |
| assert_eq!([9, 9], hdr.protocol_id); |
| assert_eq!(&[10, 10, 10], payload); |
| }, |
| _ => panic!("failed parsing LLC"), |
| } |
| } |
| _ => panic!("failed parsing data frame"), |
| }; |
| } |
| |
| #[test] |
| fn parse_amsdu() { |
| #[cfg_attr(rustfmt, rustfmt_skip)] |
| let first_msdu = vec![ |
| // LLC header |
| 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00, |
| // Payload |
| 0x33, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, |
| 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, |
| 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, |
| 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, |
| 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, |
| 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, |
| 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, |
| 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, |
| 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, |
| 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, |
| 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, |
| 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, |
| 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, |
| 0x01, 0x02, 0x03, 0x04, |
| ]; |
| #[cfg_attr(rustfmt, rustfmt_skip)] |
| let second_msdu = vec![ |
| // LLC header |
| 0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00, |
| // Payload |
| 0x99, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, |
| 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, |
| 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, |
| 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, |
| 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, |
| 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, |
| 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, |
| 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, |
| 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, |
| 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, |
| 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, |
| 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, |
| ]; |
| |
| #[cfg_attr(rustfmt, rustfmt_skip)] |
| let mut amsdu_frame = vec![ |
| // A-MSDU Subframe #1 |
| 0x78, 0x8a, 0x20, 0x0d, 0x67, 0x03, 0xb4, 0xf7, |
| 0xa1, 0xbe, 0xb9, 0xab, |
| 0x00, 0x74, // MSDU length |
| ]; |
| amsdu_frame.extend(&first_msdu[..]); |
| amsdu_frame.extend(vec![ |
| // Padding |
| 0x00, 0x00, // A-MSDU Subframe #2 |
| 0x78, 0x8a, 0x20, 0x0d, 0x67, 0x03, 0xb4, 0xf7, 0xa1, 0xbe, 0xb9, 0xab, 0x00, |
| 0x66, // MSDU length |
| ]); |
| amsdu_frame.extend(&second_msdu[..]); |
| |
| let mut found_msdus = (false, false); |
| let mut rdr = AmsduReader(&amsdu_frame[..]); |
| for msdu in &mut rdr { |
| match found_msdus { |
| (false, false) => { |
| assert_eq!(msdu, &first_msdu[..]); |
| found_msdus = (true, false); |
| } |
| (true, false) => { |
| assert_eq!(msdu, &second_msdu[..]); |
| found_msdus = (true, true); |
| } |
| _ => panic!("unexpected MSDU: {:x?}", msdu), |
| } |
| } |
| assert_eq!((true, true), found_msdus); |
| } |
| } |
