1.增加设备名称和状态

2.测试windows服务

switch/src/handle/registration_handler.rs

@@ -11,10 +11,11 @@ use protobuf::Message;
 use crate::error::*;
 use crate::handle::ConnectStatus;
 use crate::proto::message::{RegistrationRequest, RegistrationResponse};
-use crate::protocol::{error_packet, service_packet, NetPacket, Protocol, Version};
+use crate::protocol::{error_packet, NetPacket, Protocol, service_packet, Version};
+use crate::protocol::error_packet::InErrorPacket;
 
 lazy_static::lazy_static! {
-    static ref REQUEST:RwLock<Option<(String,String)>> = parking_lot::const_rwlock(None);
+    static ref REQUEST:RwLock<Option<(String,String,String)>> = parking_lot::const_rwlock(None);
     static ref REGISTRATION_TIME:AtomicI64=AtomicI64::new(0);
     pub(crate) static ref CONNECTION_STATUS:AtomicCell<ConnectStatus> = AtomicCell::new(ConnectStatus::Connecting);
 }
@@ -25,9 +26,10 @@ pub fn registration(
     server_address: SocketAddr,
     token: String,
     mac_address: String,
+    name: String,
 ) -> Result<RegistrationResponse> {
     // todo 和服务器通信加密
-    let request_packet = registration_request_packet(token.clone(), mac_address.clone())?;
+    let request_packet = registration_request_packet(token.clone(), mac_address.clone(), name.clone(), false)?;
     let buf = request_packet.buffer();
     let mut counter = 0;
     let mut recv_buf = [0u8; 10240];
@@ -57,7 +59,7 @@ pub fn registration(
                     service_packet::Protocol::RegistrationResponse => {
                         let response =
                             RegistrationResponse::parse_from_bytes(net_packet.payload())?;
-                        let _ = REQUEST.write().replace((token, mac_address));
+                        let _ = REQUEST.write().replace((token, mac_address, name));
                         udp.set_read_timeout(None)?;
                         CONNECTION_STATUS.store(ConnectStatus::Connected);
                         return Ok(response);
@@ -66,22 +68,45 @@ pub fn registration(
                 }
             }
             Protocol::Error => {
-                match error_packet::Protocol::from(net_packet.transport_protocol()) {
-                    error_packet::Protocol::TokenError => {
-                        return Err(Error::Stop("token错误".to_string()));
+                return match InErrorPacket::new(net_packet.transport_protocol(), net_packet.payload()) {
+                    Ok(e) => {
+                        match e {
+                            InErrorPacket::TokenError => {
+                                Err(Error::Stop("token错误".to_string()))
+                            }
+                            InErrorPacket::Disconnect => {
+                                Err(Error::Stop("断开连接".to_string()))
+                            }
+                            InErrorPacket::OtherError(e) => {
+                                match e.message() {
+                                    Ok(str) => {
+                                        Err(Error::Stop(str))
+                                    }
+                                    Err(e) => {
+                                        Err(Error::Stop(format!("{:?}", e)))
+                                    }
+                                }
+                            }
+                        }
                     }
-                    _ => {}
-                }
+                    Err(e) => {
+                        Err(Error::Stop(format!("{:?}", e)))
+                    }
+                };
+            }
+            _ => {
+                return Err(Error::Stop(format!("数据错误：{:?}", net_packet)));
             }
-            _ => {}
         }
     }
 }
 
-fn registration_request_packet(token: String, mac_address: String) -> Result<NetPacket<Vec<u8>>> {
+fn registration_request_packet(token: String, mac_address: String, name: String, is_fast: bool) -> Result<NetPacket<Vec<u8>>> {
     let mut request = RegistrationRequest::new();
     request.token = token;
     request.mac_address = mac_address;
+    request.name = name;
+    request.is_fast = is_fast;
     let bytes = request.write_to_bytes()?;
     let buf = vec![0u8; 4 + bytes.len()];
     let mut net_packet = NetPacket::new(buf)?;
@@ -98,8 +123,8 @@ pub fn fast_registration(udp: &UdpSocket, server_address: SocketAddr) -> Result<
     let new = Local::now().timestamp_millis();
     if new - last < 2000
         || REGISTRATION_TIME
-            .compare_exchange(last, new, Ordering::Relaxed, Ordering::Relaxed)
-            .is_err()
+        .compare_exchange(last, new, Ordering::Relaxed, Ordering::Relaxed)
+        .is_err()
     {
         //短时间不重复注册
         return Ok(());
@@ -108,8 +133,8 @@ pub fn fast_registration(udp: &UdpSocket, server_address: SocketAddr) -> Result<
     let lock = REQUEST.read();
     let option = lock.clone();
     drop(lock);
-    if let Some((token, mac_address)) = option {
-        let request_packet = registration_request_packet(token, mac_address)?;
+    if let Some((token, mac_address, name)) = option {
+        let request_packet = registration_request_packet(token, mac_address, name, true)?;
         udp.send_to(request_packet.buffer(), server_address)?;
         REGISTRATION_TIME.store(Local::now().timestamp_millis(), Ordering::Relaxed);
         return Ok(());