rs-wifi 0.1.8

`rswifi` is cross-platform wireless network (WiFi) management.
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 nix::sys::stat;
use crate::*;

pub(crate) const S_IFSOCK: stat::SFlag = stat::SFlag::S_IFSOCK;

pub(crate) fn remove_file(name: &str) -> Result<()> {
    if std::fs::exists(name)
        .map_err(Into::<Error>::into)? {
        let mode = stat::stat(name)
            .map_err(Into::<Error>::into)?
            .st_mode;
        if stat::SFlag::from_bits_truncate(mode).contains(S_IFSOCK) {
            std::fs::remove_file(name)
                .map_err(Into::<Error>::into)?;
        }
    }

    Ok(())
}

impl From<&str> for IFaceStatus {
    fn from(v: &str) -> Self {
        match v {
            "completed" => Self::Connected,
            "inactive" => Self::Inactive,
            "authenticating" => Self::Connecting,
            "associating" => Self::Connecting,
            "associated" => Self::Connecting,
            "4way_handshake" => Self::Connecting,
            "group_handshake" => Self::Connecting,
            "interface_disabled" => Self::Inactive,
            "disconnected" => Self::Disconnected,
            "scanning" => Self::Scanning,
            _ => Self::Unknown,
        }
    }
}

impl From<String> for IFaceStatus {
    #[inline]
    fn from(v: String) -> Self {
        v.as_str().into()
    }
}

impl AkmType {
    pub fn key_mgmt(&self) -> &str {
        match self {
            Self::Wpa => "WPA-EAP",
            Self::WpaPsk => "WPA-PSK",
            Self::Wpa2 => "WPA-EAP",
            Self::Wpa2Psk => "WPA-PSK",
            Self::None => "NONE",
            _ => "",
        }
    }

    pub fn proto(&self) -> &str {
        match self {
            Self::Wpa => "WPA",
            Self::WpaPsk => "WPA",
            Self::Wpa2 => "RSN",
            Self::Wpa2Psk => "RSN",
            _ => "",
        }
    }

    #[inline]
    pub fn key_required(&self) -> bool {
        matches!(self, Self::WpaPsk | Self::Wpa2Psk)
    }
}