增加命令

src/handle/heartbeat_handler.rs

@@ -4,15 +4,15 @@ use std::time::Duration;
 
 use chrono::Local;
 
+use crate::DEVICE_LIST;
 use crate::error::*;
 use crate::handle::DIRECT_ROUTE_TABLE;
-use crate::protocol::control_packet::PingPacket;
 use crate::protocol::{control_packet, NetPacket, Protocol, Version};
-use crate::DEVICE_LIST;
+use crate::protocol::control_packet::PingPacket;
 
 pub fn handle_loop(udp: UdpSocket, server_addr: SocketAddr) -> Result<()> {
     const INTERVAL: u64 = 3000;
-    const MAX_INTERVAL: i64 = 3000 * 5;
+    const MAX_INTERVAL: i64 = 3000 * 3;
     let mut buf = [0u8; (4 + 8 + 4)];
     let mut net_packet = NetPacket::new(&mut buf)?;
     net_packet.set_version(Version::V1);
@@ -20,23 +20,23 @@ pub fn handle_loop(udp: UdpSocket, server_addr: SocketAddr) -> Result<()> {
     net_packet.set_transport_protocol(control_packet::Protocol::Ping.into());
     net_packet.set_ttl(255);
     loop {
-        let current_time = Local::now().timestamp();
+        let current_time = Local::now().timestamp_millis();
         {
             let mut ping = PingPacket::new(net_packet.payload_mut())?;
             ping.set_time(current_time);
             let epoch = { DEVICE_LIST.lock().0 };
             ping.set_epoch(epoch);
         }
-        udp.send_to(net_packet.buffer(), server_addr)?;
+        let _ = udp.send_to(net_packet.buffer(), server_addr);
         for x in DIRECT_ROUTE_TABLE.iter() {
             let virtual_ip = x.key().clone();
             let route = x.value().clone();
             drop(x);
             if current_time - route.recv_time <= MAX_INTERVAL {
-                udp.send_to(net_packet.buffer(), route.address)?;
+                let _ = udp.send_to(net_packet.buffer(), route.address);
             } else {
                 DIRECT_ROUTE_TABLE.remove_if(&virtual_ip, |_, route| {
-                    current_time - route.recv_time > MAX_INTERVAL
+                    current_time - route.recv_time <= MAX_INTERVAL
                 });
             }
         }

src/handle/mod.rs

@@ -82,15 +82,15 @@ pub fn init_nat_info(public_ip: u32, public_port: u16) {
 
 #[derive(Clone, Debug)]
 pub struct CurrentDeviceInfo {
-    virtual_ip: Ipv4Addr,
-    virtual_gateway: Ipv4Addr,
-    virtual_netmask: Ipv4Addr,
+    pub(crate) virtual_ip: Ipv4Addr,
+    pub(crate) virtual_gateway: Ipv4Addr,
+    pub(crate)  virtual_netmask: Ipv4Addr,
     //网络地址
-    virtual_network: Ipv4Addr,
+    pub(crate)  virtual_network: Ipv4Addr,
     //直接广播地址
-    broadcast_address: Ipv4Addr,
+    pub(crate)   broadcast_address: Ipv4Addr,
     //链接的服务器地址
-    connect_server: SocketAddr,
+    pub(crate)  connect_server: SocketAddr,
 }
 
 impl CurrentDeviceInfo {
@@ -114,11 +114,11 @@ impl CurrentDeviceInfo {
 
 #[derive(Clone,Debug)]
 pub struct Route {
-    address: SocketAddr,
+    pub(crate) address: SocketAddr,
     //用心跳探测延迟，收包时更新
-    delay: i64,
+    pub(crate) delay: i64,
     //收包时更新，如果太久没有收到消息则剔除
-    recv_time: i64,
+    pub(crate) recv_time: i64,
 }
 
 impl Route {
@@ -126,7 +126,7 @@ impl Route {
         Self {
             address,
             delay: -1,
-            recv_time: Local::now().timestamp(),
+            recv_time: Local::now().timestamp_millis(),
         }
     }
 }

src/handle/registration_handler.rs

@@ -91,7 +91,7 @@ fn registration_request_packet(token: String, mac_address: String) -> Result<Net
 
 pub fn fast_registration(udp: &UdpSocket, server_address: SocketAddr) -> Result<()> {
     let last = REGISTRATION_TIME.load(Ordering::Relaxed);
-    let new = Local::now().timestamp();
+    let new = Local::now().timestamp_millis();
     if new - last < 2000
         || REGISTRATION_TIME
         .compare_exchange(last, new, Ordering::Relaxed, Ordering::Relaxed)
@@ -106,7 +106,7 @@ pub fn fast_registration(udp: &UdpSocket, server_address: SocketAddr) -> Result<
     if let Some((token, mac_address)) = option {
         let request_packet = registration_request_packet(token, mac_address)?;
         udp.send_to(request_packet.buffer(), server_address)?;
-        REGISTRATION_TIME.store(Local::now().timestamp(), Ordering::Relaxed);
+        REGISTRATION_TIME.store(Local::now().timestamp_millis(), Ordering::Relaxed);
         return Ok(());
     }
     return Err(Error::Stop("注册信息不存在".to_string()));

src/handle/tun_handler.rs

@@ -71,7 +71,7 @@ fn handle(
     ipv4_turn_packet.set_payload(ipv4_packet.buffer);
     //优先发到直连到地址
     if let Some(route) = DIRECT_ROUTE_TABLE.get(&dest_ip) {
-        let current_time = Local::now().timestamp();
+        let current_time = Local::now().timestamp_millis();
         if current_time - route.recv_time < 3_000 {
             udp.send_to(&net_packet.buffer()[..(4 + 8 + data_len)], route.address)?;
             return Ok(());

src/handle/udp_recv_handler.rs

@@ -200,12 +200,12 @@ fn other_handle(
         }
         Protocol::Control => {
             match ControlPacket::new(net_packet.transport_protocol(), net_packet.payload())? {
-                ControlPacket::PingPacket(_) => {
+                ControlPacket::PingPacket(ping) => {
                     net_packet.set_transport_protocol(control_packet::Protocol::Pong.into());
                     udp.send_to(&net_packet.buffer()[..12], peer_addr)?;
                 }
                 ControlPacket::PongPacket(pong_packet) => {
-                    let current_time = Local::now().timestamp();
+                    let current_time = Local::now().timestamp_millis();
                     let rt = current_time - pong_packet.time();
                     if rt >= 0 {
                         if peer_addr == server_addr {