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
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

#![allow(dead_code)]

use super::*;
use anyhow::anyhow;
use std::net::Shutdown;
use std::path::PathBuf;
use tokio::net::UnixDatagram;
use tokio::time::Duration;

pub struct Conn<const N: usize> {
    tmp_dir: tempfile::TempDir,
    pub socket: UnixDatagram,
    pub buffer: [u8; N],
}

impl<const N: usize> Conn<N> {
    pub(crate) async fn connect(server_path: &PathBuf, label: &str) -> AppResult<Self> {
        #[cfg(target_os = "linux")]
        {
            let tmp_dir = tempfile::tempdir()?;
            let client_path = tmp_dir.path().join(label);
            let socket = UnixDatagram::bind(client_path)?;
            socket.connect(&server_path)?;
            Ok(Self {
                socket,
                tmp_dir,
                buffer: [0; N],
            })
        }

        #[cfg(target_os = "windows")]
        return Err(anyhow!("Implemented"));
    }

    pub fn shutdown(&self) -> AppResult {
        #[cfg(target_os = "linux")]
        {
            self.socket
                .shutdown(Shutdown::Both)
                .map_err(|e| anyhow!("{}", e))
        }

        #[cfg(target_os = "windows")]
        return Err(anyhow!("Implemented"));
    }
    /// 发送命令 并判断是否返回ok
    pub async fn send_cmd_ok(&mut self, cmd: &[u8]) -> AppResult {
        #[cfg(target_os = "linux")]
        {
            let n = self.socket.send(cmd).await?;
            if n != cmd.len() {
                return Err(anyhow!("socket send err: ok: {n}, cmd_len: {}", cmd.len()));
            }
            self.revc_ok_with_timeout(Duration::from_secs(3)).await
        }
        #[cfg(target_os = "windows")]
        return Err(anyhow!("Implemented"));
    }

    /// 发送命令
    pub async fn send_cmd_result(&mut self, cmd: &[u8]) -> AppResult<String> {
        #[cfg(target_os = "linux")]
        {
            let n = self.socket.send(cmd).await?;
            if n != cmd.len() {
                return Err(anyhow!("socket send err: ok: {n}, cmd_len: {}", cmd.len()));
            }
            self.revc_with_timeout(Duration::from_secs(3)).await
        }
        #[cfg(target_os = "windows")]
        return Err(anyhow!("Implemented"));
    }

    //接收消息超时
    async fn revc_with_timeout(&mut self, timeout: Duration) -> AppResult<String> {
        tokio::select!(
            res = self.revc_string() => res,
            _ =tokio::time::sleep(timeout) => Err(anyhow!("socket recv timeout"))
        )
    }

    async fn revc_string(&mut self) -> AppResult<String> {
        #[cfg(target_os = "linux")]
        {
            match self.socket.recv(&mut self.buffer).await {
                Ok(n) => {
                    let data_str = std::str::from_utf8(&self.buffer[..n])?.trim_end();
                    Ok(data_str.to_owned())
                }
                Err(e) => Err(anyhow!("socket recv err::{}", e)),
            }
        }
        #[cfg(target_os = "windows")]
        return Err(anyhow!("Implemented"));
    }

    //判断是否成功
    async fn revc_is_ok(&mut self) -> AppResult {
        #[cfg(target_os = "linux")]
        {
            match self.socket.recv(&mut self.buffer).await {
                Ok(n) => {
                    let data_str = std::str::from_utf8(&self.buffer[..n])?.trim_end();
                    if data_str.trim() == "OK" {
                        Ok(())
                    } else {
                        log::error!("[wpa] revc_is_ok err: {} ", data_str);
                        Err(anyhow!("{}", data_str))
                    }
                }
                Err(e) => Err(anyhow!("socket recv err::{}", e)),
            }
        }
        #[cfg(target_os = "windows")]
        return Err(anyhow!("Implemented"));
    }

    //接收消息超时
    async fn revc_ok_with_timeout(&mut self, timeout: Duration) -> AppResult {
        tokio::select!(
            res = self.revc_is_ok() => res,
            _ =tokio::time::sleep(timeout) => Err(anyhow!("socket recv timeout"))
        )
    }
}