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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

use std::fmt::Display;

use deku::{DekuContainerWrite, DekuError, DekuRead, DekuWrite};
use num_enum::{IntoPrimitive, TryFromPrimitive};
use serde::{Deserialize, Serialize};

use crate::ChannelWidth;
use crate::ies::{Field, IeId, vht_capabilities::VhtMcsMap};

#[derive(Debug, Clone, PartialEq, Eq, Hash, DekuRead, DekuWrite, Serialize, Deserialize)]
pub struct VhtOperation {
    pub vht_operation_information: VhtOperationInformation,
    pub basic_vht_mcs_and_nss_set: VhtMcsMap,
}

impl VhtOperation {
    pub const NAME: &'static str = "VHT Operation";
    pub const ID: u8 = 192;
    pub const ID_EXT: Option<u8> = None;
    pub(crate) const IE_ID: IeId = IeId::new(Self::ID, Self::ID_EXT);
    pub const LENGTH: usize = 5;

    pub fn channel_width(&self) -> Option<ChannelWidth> {
        self.vht_operation_information.channel_width()
    }

    pub fn summary(&self) -> String {
        let mut summary = Vec::new();
        summary.push(format!(
            "{} MHz",
            self.vht_operation_information.channel_width
        ));

        if self
            .vht_operation_information
            .channel_center_frequency_segment_0
            > 0
        {
            summary.push(format!(
                "Channel Center Frequency Segment 0: {}",
                self.vht_operation_information
                    .channel_center_frequency_segment_0
            ));
        }

        if self
            .vht_operation_information
            .channel_center_frequency_segment_1
            > 0
        {
            summary.push(format!(
                "Channel Center Frequency Segment 1: {}",
                self.vht_operation_information
                    .channel_center_frequency_segment_1
            ));
        }

        summary.join(", ")
    }

    pub fn fields(&self) -> Vec<Field> {
        vec![
            self.vht_operation_information.to_field(),
            self.basic_vht_mcs_and_nss_set
                .to_field("Basic VHT-MCS and NSS Set"),
        ]
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, DekuRead, DekuWrite, Serialize, Deserialize)]
pub struct VhtOperationInformation {
    #[deku(
        bytes = 1,
        map = "|value: u8| VhtChannelWidth::try_from(value).map_err(|_| DekuError::Parse(\"Invalid VhtChannelWidth\".into()))",
        writer = "u8::from(*channel_width).to_writer(deku::writer, ())"
    )]
    pub channel_width: VhtChannelWidth,
    #[deku(bytes = 1)]
    pub channel_center_frequency_segment_0: u8,
    #[deku(bytes = 1)]
    pub channel_center_frequency_segment_1: u8,
}

impl VhtOperationInformation {
    pub fn channel_width(&self) -> Option<ChannelWidth> {
        match self.channel_width {
            VhtChannelWidth::TwentyOrFortyMhz => None,
            VhtChannelWidth::EightyOrOneHundredSixtyOrEightyPlusEightyMhz => {
                if self.channel_center_frequency_segment_1 == 0 {
                    Some(ChannelWidth::EightyMhz)
                } else if self
                    .channel_center_frequency_segment_1
                    .abs_diff(self.channel_center_frequency_segment_0)
                    == 8
                {
                    Some(ChannelWidth::OneSixtyMhz)
                } else {
                    Some(ChannelWidth::EightyPlusEightyMhz)
                }
            }
            VhtChannelWidth::OneHundredSixtyMhz => Some(ChannelWidth::OneSixtyMhz),
            VhtChannelWidth::EightyPlusEightyMhz => Some(ChannelWidth::EightyPlusEightyMhz),
        }
    }

    pub fn to_field(&self) -> Field {
        Field::builder()
            .title("VHT Operation Information")
            .value("")
            .bytes(self.to_bytes().unwrap_or_default())
            .subfields([
                Field::builder()
                    .title("VHT Channel Width")
                    .value(self.channel_width)
                    .units("MHz")
                    .byte(self.channel_width.into())
                    .build(),
                Field::builder()
                    .title("Channel Center Frequency Segment 0")
                    .value(self.channel_center_frequency_segment_0)
                    .byte(self.channel_center_frequency_segment_0)
                    .build(),
                Field::builder()
                    .title("Channel Center Frequency Segment 1")
                    .value(self.channel_center_frequency_segment_1)
                    .byte(self.channel_center_frequency_segment_1)
                    .build(),
            ])
            .build()
    }
}

#[derive(
    Debug, Clone, Copy, PartialEq, Eq, Hash, TryFromPrimitive, IntoPrimitive, Serialize, Deserialize,
)]
#[repr(u8)]
pub enum VhtChannelWidth {
    TwentyOrFortyMhz = 0,
    EightyOrOneHundredSixtyOrEightyPlusEightyMhz = 1,
    OneHundredSixtyMhz = 2,
    EightyPlusEightyMhz = 3,
}

impl Display for VhtChannelWidth {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::TwentyOrFortyMhz => write!(f, "20/40"),
            Self::EightyOrOneHundredSixtyOrEightyPlusEightyMhz => write!(f, "80/160/80+80"),
            Self::OneHundredSixtyMhz => write!(f, "160"),
            Self::EightyPlusEightyMhz => write!(f, "80+80"),
        }
    }
}