kawaiifi 0.2.1

Wi-Fi scanning library for Linux, macOS, and Windows.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

use deku::{DekuContainerWrite, DekuRead, DekuWrite};
use serde::{Deserialize, Serialize};

use crate::ies::{BitRange, Field, IeId};

#[derive(Debug, Clone, PartialEq, Eq, Hash, DekuRead, DekuWrite, Serialize, Deserialize)]
pub struct MobilityDomain {
    pub mdid: u16,
    pub ft_capability_and_policy: FtCapabilityAndPolicy,
}

impl MobilityDomain {
    pub const NAME: &'static str = "Mobility Domain";
    pub const ID: u8 = 54;
    pub const ID_EXT: Option<u8> = None;
    pub(crate) const IE_ID: IeId = IeId::new(Self::ID, Self::ID_EXT);

    pub fn summary(&self) -> String {
        format!("MDID: {}", self.mdid)
    }

    pub fn fields(&self) -> Vec<Field> {
        vec![
            Field::builder()
                .title("MDID")
                .value(self.mdid)
                .bytes(self.mdid.to_le_bytes().to_vec())
                .build(),
            self.ft_capability_and_policy.to_field(),
        ]
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, DekuRead, DekuWrite, Serialize, Deserialize)]
#[deku(bit_order = "lsb")]
pub struct FtCapabilityAndPolicy {
    #[deku(bits = "1")]
    fast_bss_transition_over_ds: bool,
    #[deku(bits = "1")]
    resource_request_protocol_capability: bool,
    #[deku(bits = "6")]
    reserved: u8,
}

impl FtCapabilityAndPolicy {
    fn to_field(self) -> Field {
        let byte = self
            .to_bytes()
            .unwrap_or_default()
            .first()
            .cloned()
            .unwrap_or_default();

        Field::builder()
            .title("FT Capability and Policy")
            .value("")
            .subfields([
                Field::builder()
                    .title("Fast BSS Transition Over DS")
                    .value(self.fast_bss_transition_over_ds)
                    .bits(BitRange::from_byte(byte, 0, 1))
                    .build(),
                Field::builder()
                    .title("Resource Request Protocol Capability")
                    .value(self.resource_request_protocol_capability)
                    .bits(BitRange::from_byte(byte, 1, 1))
                    .build(),
                Field::reserved(BitRange::from_byte(byte, 2, 6)),
            ])
            .byte(byte)
            .build()
    }
}