feat: add web api

Author: xiekun1992

.editorconfig

@@ -0,0 +1,8 @@
+root = true
+
+[*]
+end_of_line = lf
+indent_size = 4
+insert_final_newline = true
+charset = utf-8
+indent_style = space

.gitignore

@@ -0,0 +1 @@
+/target

Cargo.lock

@@ -15,3 +15,4 @@ serde = { version = "1.0", features = ["derive"] }
 # sysinfo = "0.29.4"
 serde_json = "1.0"
 tokio = "1.32.0"
+lazy_static = "1.4.0"

Cargo.toml

@@ -1,22 +1,23 @@
 pub mod udp_server;
 
-use std::{sync::Arc, thread};
 use crate::global::state::State;
+use std::{
+    sync::{Arc, Mutex},
+    thread,
+};
 use udp_server::UDPServer;
 
-pub fn init(global_state: Arc<State>) {
-  let udp_discover = UDPServer::new("0.0.0.0".to_string(), 1232);
-  let server = Arc::new(udp_discover);
+pub fn init() {
+    let udp_discover = UDPServer::new("0.0.0.0".to_string(), 1232);
+    let server = Arc::new(udp_discover);
 
-  let recv_state = Arc::clone(&global_state);
-  let recv_server = Arc::clone(&server);
-  thread::spawn(move || {
-    recv_server.recv(recv_state);
-  });
-  
-  let send_state = Arc::clone(&global_state);
-  let send_server = Arc::clone(&server);
-  thread::spawn(move || {
-      send_server.send(send_state);
-  });
+    let recv_server = Arc::clone(&server);
+    thread::spawn(move || {
+        recv_server.recv();
+    });
+
+    let send_server = Arc::clone(&server);
+    thread::spawn(move || {
+        send_server.send();
+    });
 }

libcapture.dll

@@ -1,63 +1,68 @@
+use std::str;
 use std::sync::Arc;
 use std::time::Duration;
 use std::{net::UdpSocket, thread};
-use std::str;
 
-use chrono::prelude::*;
 use crate::global::device::{DeviceInfo, RemoteDevice};
-use crate::global::state::State;
+use crate::global::state::{State, STATE};
+use chrono::prelude::*;
 
 pub struct UDPServer {
-  socket: UdpSocket,
-  ip: String,
-  port: u16
+    socket: UdpSocket,
+    ip: String,
+    port: u16,
 }
 
 impl UDPServer {
-  pub fn new(ip: String, port: u16) -> UDPServer {
-    let socket = UdpSocket::bind(format!("{ip}:{port}")).unwrap();
-    // socket.set_nonblocking(true).unwrap();
-    socket.set_broadcast(true).unwrap();
-    UDPServer {
-      socket,
-      ip,
-      port
+    pub fn new(ip: String, port: u16) -> UDPServer {
+        let socket = UdpSocket::bind(format!("{ip}:{port}")).unwrap();
+        // socket.set_nonblocking(true).unwrap();
+        socket.set_broadcast(true).unwrap();
+        UDPServer { socket, ip, port }
     }
-  }
-  pub fn recv(&self, state: Arc<State>) {
-    let dev = &state.cur_device;
-    // let dev = DeviceInfo::new();
-    let mut buf = [0; 64 * 1024];
-    loop {
-      let (data, rinfo) = self.socket.recv_from(&mut buf).unwrap();
-      let remote = DeviceInfo::from_json(str::from_utf8(&buf[..data]).unwrap().to_string());
-
-      if dev.ifs.iter().all(|interface| {
-        interface.addr.to_string() != rinfo.ip().to_string()
-      }) {
-        println!("{} - {:?}", Local::now(), remote);
-        state.add_remote(remote);
-      }
-    }
-  }
-  pub fn send(&self, state: Arc<State>) {
-    // let dev = DeviceInfo::new();
-    let dev = &state.cur_device;
-    let mut remote_infos = Vec::new();
-    for interface in &dev.ifs {
-      let addr = format!("{}:{}", interface.broadcast_addr, self.port);
-      let remote = RemoteDevice {
-        hostname: dev.hostname.clone(),
-        ip: interface.addr.to_string()
-      }.to_json();
-      remote_infos.push((remote, addr));
+    pub fn recv(&self) {
+        // let dev = DeviceInfo::new();
+        let mut buf = [0; 64 * 1024];
+        loop {
+            let (data, rinfo) = self.socket.recv_from(&mut buf).unwrap();
+            let remote = DeviceInfo::from_json(str::from_utf8(&buf[..data]).unwrap().to_string());
+            
+            let state = STATE.lock().unwrap();
+            let dev = &state.cur_device;
+            if dev
+                .ifs
+                .iter()
+                .all(|interface| interface.addr.to_string() != rinfo.ip().to_string())
+            {
+                println!("{} - {:?}", Local::now(), remote);
+                state.add_remote(remote);
+            }
+        }
     }
-    loop {
-      for (remote, addr) in &remote_infos {
-        self.socket.send_to(remote.as_bytes(), addr).expect("send failed");
-        // println!("send to {:?}", interface.broadcast_addr);
-      }
-      thread::sleep(Duration::from_secs(1));
+    pub fn send(&self) {
+        // let dev = DeviceInfo::new();
+        let mut remote_infos = Vec::new();
+        {
+            let state = STATE.lock().unwrap();
+            let dev = &state.cur_device;
+            for interface in &dev.ifs {
+                let addr = format!("{}:{}", interface.broadcast_addr, self.port);
+                let remote = RemoteDevice {
+                    hostname: dev.hostname.clone(),
+                    ip: interface.addr.to_string(),
+                }
+                .to_json();
+                remote_infos.push((remote, addr));
+            }
+        }
+        loop {
+            for (remote, addr) in &remote_infos {
+                self.socket
+                    .send_to(remote.as_bytes(), addr)
+                    .expect("send failed");
+                // println!("send to {:?}", interface.broadcast_addr);
+            }
+            thread::sleep(Duration::from_secs(1));
+        }
     }
-  }
-}
+}

libcapture.lib

@@ -12,13 +12,13 @@ pub struct Interface {
     pub broadcast_addr: Ipv4Addr
 }
 
-#[derive(Serialize, Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct DeviceInfo {
     pub hostname: String,
     pub ifs: Vec<Interface>
 }
 
-#[derive(Serialize, Deserialize, Debug, PartialEq)]
+#[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
 pub struct RemoteDevice {
     pub hostname: String,
     pub ip: String
@@ -62,9 +62,10 @@ impl DeviceInfo {
         let remote: RemoteDevice = serde_json::from_str(&json_str).unwrap();
         remote
     }
-    // pub fn to_json(&self) -> String {
-    //     serde_json::to_string(&self).unwrap()
-    // }
+
+    pub fn to_json(&self) -> String {
+        serde_json::to_string(&self).unwrap()
+    }
 }
 
 fn calc_broadcast_addr(addr: Ipv4Addr, netmask: Ipv4Addr) -> Ipv4Addr {
@@ -90,4 +91,4 @@ fn calc_broadcast_addr_test() {
         Ipv4Addr::new(255, 128, 0, 0)
     );
     assert_eq!(b1, Ipv4Addr::new(200, 255, 255, 255));
-}
+}

src/discover/mod.rs

@@ -1,24 +1,53 @@
-use std::sync::Mutex;
+use std::sync::{Arc, Mutex};
 
-use super::device::{RemoteDevice, DeviceInfo};
+use super::device::{DeviceInfo, RemoteDevice};
+use lazy_static::lazy_static;
+
+lazy_static! {
+   pub static ref STATE: Mutex<State> = Mutex::new(State::new());
+}
 
 pub struct State {
-  remotes: Mutex<Vec<RemoteDevice>>,
-  pub cur_device: DeviceInfo
+    pub remotes: Mutex<Vec<RemoteDevice>>,
+    pub cur_device: DeviceInfo,
+    remote_peer: Option<RemoteDevice>,
 }
 
 impl State {
-  pub fn new() -> State {
-    State {
-      remotes: Mutex::new(Vec::new()),
-      cur_device: DeviceInfo::new()
+    // pub fn get_instance() -> State {
+    //     STATE.lock().unwrap().try_into()
+    // }
+
+    fn new() -> State {
+        State {
+            remotes: Mutex::new(Vec::new()),
+            cur_device: DeviceInfo::new(),
+            remote_peer: None,
+        }
+    }
+
+    pub fn set_remote_peer(&mut self, peer: Option<RemoteDevice>) {
+        self.remote_peer = peer;
     }
-  }
 
-  pub fn add_remote(&self, remote: RemoteDevice) {
-    let mut remotes = self.remotes.lock().unwrap();
-    if !remotes.contains(&remote) {
-      remotes.push(remote);
+    pub fn get_remote(&self) -> Vec<RemoteDevice> {
+        self.remotes.lock().unwrap().clone()
     }
-  }
-}
+
+    pub fn add_remote(&self, remote: RemoteDevice) {
+        let mut remotes = self.remotes.lock().unwrap();
+        if !remotes.contains(&remote) {
+            remotes.push(remote);
+        }
+    }
+
+    pub fn find_remote_by_ip(&self, ip: &str) -> Option<RemoteDevice> {
+        let remotes = self.remotes.lock().unwrap();
+        for r in remotes.clone().into_iter() {
+            if r.ip.as_str() == ip {
+                return Some(r.clone());
+            }
+        }
+        None
+    }
+}

src/discover/udp_server.rs

@@ -0,0 +1,73 @@
+
+
+use std::{ffi::{c_int, c_long, c_char, CStr, c_uchar, OsString, OsStr, c_ushort}, thread, time::Duration, slice, os::windows::prelude::{OsStrExt, OsStringExt}, iter::once};
+
+#[repr(C)]
+// #[no_mangle]
+struct Square {
+    a: c_int,
+    b: c_int
+}
+#[repr(C)]
+enum MouseButton {
+    MouseLeft = 1,
+    MouseMiddle,
+    MouseRight
+}
+#[repr(C)]
+enum MouseWheel {
+    WheelUp = -1,
+    WheelDown = 1
+}
+enum MouseType {
+    MouseWheel = 0,
+    MouseMove,
+    MouseDown,
+    MouseUp,
+    KeyDown,
+    KeyUp
+}
+type CInputHandler = extern fn(ev: *const c_long);
+type CClipboardHandler = extern fn();
+#[link(name = "libcapture")]
+extern "C" {
+    fn mouse_move(x: c_int, y: c_int);
+    fn mouse_wheel(direction: MouseWheel);
+    fn mouse_down(button: MouseButton);
+    fn mouse_up(button: MouseButton);
+
+    fn listener_init(
+        mouseHanlder: CInputHandler,
+        keyboardHanlder: CInputHandler
+    );
+    fn listener_listen();
+    fn charToKeycode(scancode: c_int) -> c_int;
+
+    fn clipboard_init();
+    fn clipboard_dispose();
+    fn read_text() -> *const c_ushort;
+    fn capture(cb: CClipboardHandler);
+    fn write_text(text: *const c_ushort) -> c_int;
+
+    fn utils_open(path: *const c_ushort);
+}
+
+
+fn string_to_vec_u16(msg: String) -> Vec<u16> {
+  let wide: Vec<u16> = OsStr::new(msg.as_str()).encode_wide().chain(once(0)).collect();
+  return wide;
+}
+
+fn const_u16_to_string(wide_str_ptr: *const u16) -> String {
+  // 计算以 null 结尾的 u16 数组的长度
+  let mut len = 0;
+  while unsafe { *wide_str_ptr.offset(len as isize) } != 0 {
+      len += 1;
+  }
+  let wide_str = unsafe {
+      slice::from_raw_parts(wide_str_ptr, len)
+  };
+  // println!("const_u16_to_string={:?}", wide_str);
+  let str = String::from_utf16_lossy(wide_str);
+  return str;
+}