kawaiifi 0.2.0

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

use deku::DekuContainerRead;
#[cfg(debug_assertions)]
use deku::DekuContainerWrite;

use super::Ie;

/// Parses a sequence of Information Elements from raw bytes.
///
/// Returns all successfully parsed IEs. If parsing fails partway through,
/// returns the IEs that were successfully parsed before the error.
/// Parse failures are logged at the `warn` level.
///
/// # Example
///
/// ```
/// # use kawaiifi::ies;
/// // Two IEs: SSID "Hello" + DS Parameter Set (channel 6)
/// let ie_bytes = &[
///     0x00, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f,  // SSID IE
///     0x03, 0x01, 0x06,                           // DS Parameter Set IE
/// ];
/// let ies = ies::from_bytes(ie_bytes);
/// assert_eq!(ies.len(), 2);
/// ```
pub fn from_bytes(bytes: &[u8]) -> Vec<Ie> {
    let mut ies = Vec::new();
    let mut input = bytes;

    while !input.is_empty() {
        let offset = bytes.len() - input.len();
        match Ie::from_bytes((input, 0)) {
            Ok(((rest, _), ie)) => {
                let bytes_read = input.len() - rest.len();
                let expected_bytes = usize::from(ie.len) + 2;
                if bytes_read != expected_bytes {
                    tracing::warn!(
                        "Incorrect number of bytes read for IE at offset {}: read {}, expected {}. IE: {:?}",
                        offset,
                        bytes_read,
                        expected_bytes,
                        &ie
                    );
                }
                #[cfg(debug_assertions)]
                if let Ok(serialized) = ie.to_bytes()
                    && serialized.as_slice() != &input[..expected_bytes.min(input.len())]
                {
                    tracing::warn!(
                        "Mismatch between raw IE bytes and parsed Ie::to_bytes at offset {}. IE: {:?}",
                        offset,
                        &ie
                    );
                }
                ies.push(ie);
                if expected_bytes > input.len() {
                    tracing::warn!(
                        "IE at offset {} declares {} bytes but only {} bytes remain",
                        offset,
                        expected_bytes,
                        input.len()
                    );
                    break;
                }
                input = &input[expected_bytes..];
            }
            Err(error) => {
                let failed_bytes = bytes
                    .get(offset..offset.saturating_add(20).min(bytes.len()))
                    .unwrap_or(&[]);
                tracing::warn!(
                    "Failed to parse IE at offset {} (parsed {} IEs successfully): {:?}. Failed bytes: {:02x?}",
                    offset,
                    ies.len(),
                    error,
                    failed_bytes
                );
                break;
            }
        }
    }

    ies
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn from_bytes_stops_on_truncated_ie() {
        let ies = from_bytes(&[0x00, 0x05, b'H', b'i']);

        assert!(ies.is_empty());
    }
}