network 1.0.0

Network Basic Library: Network Basic Operations, WiFi Definition, Linux WPA Implementation
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

pub mod client;
pub mod conn;
pub mod event;
pub mod wifi;
use crate::wifi::dto::Event;
pub use client::*;
use conn::*;
use event::*;
use std::path::PathBuf;
use std::str::FromStr;
use tokio::sync::{mpsc, oneshot};
use tokio::time::Duration;
pub use wifi::*;

pub type AppResult<T = ()> = std::result::Result<T, anyhow::Error>;
#[derive(Clone)]
pub struct Config {
    //请求命令队列长度
    pub cmd_channel_len: usize,
    //wifi socket 路径
    pub server_socket_path: String,
    //连接超时
    pub conn_timeout: Duration,
    //事件回调
    pub event_callback: Option<fn(String)>,
}

impl Default for Config {
    fn default() -> Self {
        Self {
            cmd_channel_len: 32,
            server_socket_path: "/var/run/wpa_supplicant/wlan0".to_string(),
            conn_timeout: Duration::from_secs(5),
            event_callback: None,
        }
    }
}
#[allow(dead_code)]
impl Config {
    pub fn set_socket_path(&mut self, path: String) {
        self.server_socket_path = path;
    }

    pub fn set_timeout(&mut self, timeout: Duration) {
        self.conn_timeout = timeout;
    }

    pub fn set_iface_name(&mut self, name: String) {
        self.server_socket_path = format!("/var/run/wpa_supplicant/{}", name);
    }

    pub fn set_event_callback(&mut self, callback: fn(String)) {
        self.event_callback = Some(callback);
    }
}

pub async fn connect(cfg: Config) -> AppResult<Client> {
    let (cmd_sender, cmd_recv) = mpsc::channel(cfg.cmd_channel_len);

    let cmd = Client::new(cmd_sender.clone());

    let wpa = Wifi {
        event_callback: cfg.event_callback, 
        cmd_recv,
        cmd_sender,
    };

    let socket_path: PathBuf = cfg.server_socket_path.clone().into();
    //client cli 发收
    let cli = Conn::<10240>::connect(&socket_path, "wpa_cli.sock").await?;
    //ATTACH 事件
    let (event, evt_recv) = EventConn::new(&socket_path).await?;

    if let Some(cb) = &wpa.event_callback {
        cb(Event::Ready.to_string());
    }

    tokio::spawn(async move {
        let res = tokio::select!(
            res = event.listening() => res,
            resp = wpa.listening(evt_recv, cli) => resp,
        );
        if res.is_err() {
            log::error!("[wap] listening exit by err:{:?}", res);
        } else {
            log::debug!("[wap] listening exit");
        }
    });

    Ok(cmd)
}