rbroadlink 0.4.2

A library to control broadlink smart devices.
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

use packed_struct::prelude::PackedStruct;

use crate::network::util::checksum;

/// WirelessConnection represents the credentials for connecting to a wireless
/// network.
#[derive(Debug)]
pub enum WirelessConnection<'a> {
    /// None represents a network with no security
    None(&'a str),

    /// WEP represents a network with WEP security key.
    WEP(&'a str, &'a str),

    /// WPA1 represents a network with a WPA v1 security key.
    WPA1(&'a str, &'a str),

    /// WPA represents a network with a WPA v2 security key.
    WPA2(&'a str, &'a str),

    /// WPA represents a network with both WPA v1 and WPA v2 support.
    WPA(&'a str, &'a str),
}

/// WirelessConnectionMessage represents a message used for instructing a device
/// to connect to a specified wireless network.
#[derive(PackedStruct, Debug)]
#[packed_struct(bit_numbering = "msb0", endian = "lsb", size_bytes = "136")]
pub struct WirelessConnectionMessage {
    /// The message's checksum for verification purposes.
    #[packed_field(bytes = "32:33")]
    checksum: u16,

    /// A magic constant for this message. Always 0x14
    #[packed_field(bytes = "38")]
    magic_constant: i8,

    /// The SSID of the network.
    #[packed_field(bytes = "68:99")]
    ssid: [u8; 32],

    /// The password of the network, if needed.
    #[packed_field(bytes = "100:131")]
    password: [u8; 32],

    /// Length of the SSID
    #[packed_field(bytes = "132")]
    ssid_length: u8,

    /// Length of the password
    #[packed_field(bytes = "133")]
    password_length: u8,

    /// The security mode to use. 0 -> None, 1 -> WEP, 2 -> WPA1, 3 -> WPA2, 4 -> WPA
    #[packed_field(bytes = "134")]
    security_mode: u8,
}

impl WirelessConnection<'_> {
    /// Pack a WirelessCOnnection into its network transport format.
    pub fn to_message(&self) -> Result<WirelessConnectionMessage, String> {
        let empty_pass = "";
        let (ssid, pass, security_mode) = match self {
            WirelessConnection::None(ssid) => (ssid, &empty_pass, 0),
            WirelessConnection::WEP(ssid, pass) => (ssid, pass, 1),
            WirelessConnection::WPA1(ssid, pass) => (ssid, pass, 2),
            WirelessConnection::WPA2(ssid, pass) => (ssid, pass, 3),
            WirelessConnection::WPA(ssid, pass) => (ssid, pass, 4),
        };

        // Ensure that the fields aren't too long
        if ssid.len() > 32 {
            return Err("Could not use provided SSID! SSID longer than 32 characters.".into());
        }

        // Copy over the strings into their fixed buffers
        let mut ssid_fixed = [0u8; 32];
        let mut pass_fixed = [0u8; 32];
        for (i, c) in ssid.as_bytes().iter().enumerate() {
            ssid_fixed[i] = *c;
        }
        for (i, c) in pass.as_bytes().iter().enumerate() {
            pass_fixed[i] = *c;
        }

        // Construct the message
        let mut msg = WirelessConnectionMessage {
            // We will need to recalculate this after creating the message
            checksum: 0,

            // This is always 0x14
            magic_constant: 0x14,

            // Grab info from connection
            ssid: ssid_fixed,
            password: pass_fixed,
            ssid_length: u8::try_from(ssid.len()).map_err(|e| {
                format!(
                    "Could not use provided SSID! SSID is too long (max 32 characters). {}",
                    e
                )
            })?,
            password_length: u8::try_from(pass.len()).map_err(|e| {
                format!(
                    "Could not use provided password! Password is too long (max 32 characters). {}",
                    e
                )
            })?,

            security_mode: security_mode,
        };

        // Add the checksum into the msg
        msg.checksum = checksum(
            &msg.pack()
                .map_err(|e| format!("Could not pack WirelessConnectionMessage! {}", e))?,
        );

        // Return the newly created message
        return Ok(msg);
    }
}