1.增加设备名称和状态

2.测试windows服务

switch-desktop/Cargo.toml

@@ -14,10 +14,11 @@ dirs = "4.0.0"
 log = "0.4.17"
 log4rs = "1.2.0"
 tokio = { version = "1.24.1", features = ["full"] }
-
+chrono = "0.4.23"
 [target.'cfg(any(target_os = "linux",target_os = "macos"))'.dependencies]
 sudo = "0.6.0"
 
 [target.'cfg(target_os = "windows")'.dependencies]
 winapi = { version = "0.3.9", features = ["handleapi", "processthreadsapi", "winnt", "securitybaseapi", "impl-default"] }
 runas = "0.2.1"
+windows-service = "0.5.0"

switch-desktop/src/main.rs

@@ -1,17 +1,19 @@
 use clap::Parser;
 use console::style;
 
-use switch::handle::RouteType;
 use switch::*;
+use switch::handle::{PeerDeviceStatus, RouteType};
 
 #[cfg(windows)]
 mod windows_admin_check;
+#[cfg(windows)]
+mod windows;
 
 #[derive(Parser, Debug)]
 #[command(
-    author = "Lu Beilin",
-    version,
-    about = "一个虚拟网络工具,启动后会获取一个ip,相同token下的设备之间可以用ip直接通信"
+author = "Lu Beilin",
+version,
+about = "一个虚拟网络工具,启动后会获取一个ip,相同token下的设备之间可以用ip直接通信"
 )]
 struct Args {
     /// 32位字符
@@ -20,8 +22,11 @@ struct Args {
     /// 32-bit characters.
     /// Only devices with the same token can communicate with each other.
     /// It is recommended to use uuid to ensure uniqueness
-    #[arg(short, long)]
+    #[arg(long)]
     token: String,
+    /// 给设备一个名称，为空时默认用系统版本信息
+    #[arg(long)]
+    name: Option<String>,
 }
 
 fn log_init() {
@@ -29,6 +34,7 @@ fn log_init() {
     if !home.exists() {
         std::fs::create_dir(&home).expect(" Failed to create '.switch' directory");
     }
+    let stderr = log4rs::append::console::ConsoleAppender::builder().target(log4rs::append::console::Target::Stderr).build();
     let logfile = log4rs::append::file::FileAppender::builder()
         // Pattern: https://docs.rs/log4rs/*/log4rs/encode/pattern/index.html
         .encoder(Box::new(log4rs::encode::pattern::PatternEncoder::new(
@@ -38,9 +44,15 @@ fn log_init() {
         .unwrap();
     let config = log4rs::Config::builder()
         .appender(log4rs::config::Appender::builder().build("logfile", Box::new(logfile)))
+        .appender(
+            log4rs::config::Appender::builder()
+                .filter(Box::new(log4rs::filter::threshold::ThresholdFilter::new(log::LevelFilter::Error)))
+                .build("stderr", Box::new(stderr)),
+        )
         .build(
             log4rs::config::Root::builder()
                 .appender("logfile")
+                .appender("stderr")
                 .build(log::LevelFilter::Info),
         )
         .unwrap();
@@ -75,7 +87,23 @@ fn main() {
     }
     println!("{}", style("starting...").green());
     let mac_address = mac_address::get_mac_address().unwrap().unwrap().to_string();
-    let switch = Switch::start(Config::new(args.token, mac_address)).unwrap();
+    let switch = match Config::new(args.token, mac_address, args.name, || {}) {
+        Ok(config) => {
+            match Switch::start(config) {
+                Ok(switch) => {
+                    switch
+                }
+                Err(e) => {
+                    log::error!("{:?}",e);
+                    return;
+                }
+            }
+        }
+        Err(e) => {
+            log::error!("{:?}",e);
+            return;
+        }
+    };
     use console::Term;
     let term = Term::stdout();
     println!("{}", style("started").green());
@@ -122,22 +150,27 @@ fn command(cmd: &str, switch: &Switch) -> Result<(), ()> {
                 println!("No other devices found");
                 return Ok(());
             }
-            for ip in device_list {
-                let route = switch.route(&ip);
-                if route.route_type == RouteType::P2P {
-                    let str = if route.rt >= 0 {
-                        format!("{}(p2p delay:{}ms)", ip, route.rt)
+            for peer_device_info in device_list {
+                let route = switch.route(&peer_device_info.virtual_ip);
+                if peer_device_info.status == PeerDeviceStatus::Online {
+                    if route.route_type == RouteType::P2P {
+                        let str = if route.rt >= 0 {
+                            format!("[{}] {}(p2p delay:{}ms)", peer_device_info.name, peer_device_info.virtual_ip, route.rt)
+                        } else {
+                            format!("[{}] {}(p2p)", peer_device_info.name, peer_device_info.virtual_ip)
+                        };
+                        println!("{}", style(str).green());
                     } else {
-                        format!("{}(p2p)", ip)
-                    };
-                    println!("{}", style(str).green());
+                        let str = if server_rt >= 0 {
+                            format!("[{}] {}(relay delay:{}ms)", peer_device_info.name, peer_device_info.virtual_ip, server_rt * 2)
+                        } else {
+                            format!("[{}] {}(relay)", peer_device_info.name, peer_device_info.virtual_ip)
+                        };
+                        println!("{}", style(str).blue());
+                    }
                 } else {
-                    let str = if server_rt >= 0 {
-                        format!("{}(relay delay:{}ms)", ip, server_rt * 2)
-                    } else {
-                        format!("{}(relay)", ip)
-                    };
-                    println!("{}", style(str).blue());
+                    let str = format!("[{}] {}(Offline)", peer_device_info.name, peer_device_info.virtual_ip);
+                    println!("{}", style(str).red());
                 }
             }
         }

switch-desktop/src/windows/mod.rs

@@ -0,0 +1,144 @@
+use clap::Parser;
+use console::style;
+
+pub mod service;
+
+#[derive(Parser, Debug)]
+#[command(
+author = "Lu Beilin",
+version,
+about = "一个虚拟网络工具,启动后会获取一个ip,相同token下的设备之间可以用ip直接通信"
+)]
+struct Args {
+    /// 32位字符
+    /// 相同token的设备之间才能通信。
+    /// 建议使用uuid保证唯一性。
+    /// 32-bit characters.
+    /// Only devices with the same token can communicate with each other.
+    /// It is recommended to use uuid to ensure uniqueness
+    #[arg(long)]
+    token: String,
+    /// 给设备一个名称，为空时默认用系统版本信息
+    #[arg(long)]
+    name: Option<String>,
+    /// 安装服务，安装后可以后台运行
+    #[arg(long)]
+    install: bool,
+    /// 卸载服务
+    #[arg(long)]
+    uninstall: bool,
+    /// 启动，启动时可以附加参数 --token，如果没有token，则会读取配置文件中上一次使用的token
+    /// 安装服务后，会以服务的方式在后台启动，此时可以关闭命令行窗口
+    #[arg(long)]
+    start: bool,
+    #[arg(long)]
+    /// 停止，安装服务后，使用--stop停止服务
+    stop: bool,
+
+}
+
+const SERVICE_FLAG: &'static str = "start_switch_service_";
+const SERVICE_NAME: &'static str = "switch-service";
+
+pub fn main0() {
+    let args: Vec<_> = std::env::args().collect();
+    if args.len() == 2 && args[1] == SERVICE_FLAG {
+        //以服务的方式启动
+        service::start();
+    }
+    let args = Args::parse();
+    if args.install {
+        if let Err(e) = install() {
+            log::error!("{:?}",e);
+        }else{
+            println!("{}",style("安装成功").green())
+        }
+        pause();
+        return;
+    }
+    if args.uninstall {
+        if let Err(e) = uninstall() {
+            log::error!("{:?}",e);
+        }else{
+            println!("{}",style("卸载成功").green())
+        }
+        pause();
+        return;
+    }
+    if args.start {
+        if let Err(e) = start() {
+            log::error!("{:?}",e);
+            // 在当前进程启动
+        }
+        pause();
+    }
+}
+
+fn pause() {
+    println!("按任意键退出...");
+    std::io::stdin().read_u8().unwrap();
+}
+
+
+fn install() -> Result<(), windows_service::Error> {
+    use std::ffi::OsString;
+    use windows_service::{
+        service::{ServiceAccess, ServiceErrorControl, ServiceInfo, ServiceStartType, ServiceType},
+        service_manager::{ServiceManager, ServiceManagerAccess},
+    };
+
+    let manager_access = ServiceManagerAccess::CONNECT | ServiceManagerAccess::CREATE_SERVICE;
+    let service_manager = ServiceManager::local_computer(None::<&str>, manager_access)?;
+    let service_binary_path = std::env::current_exe().unwrap();
+    let service_info = ServiceInfo {
+        name: OsString::from(SERVICE_NAME),
+        display_name: OsString::from("switch service"),
+        service_type: ServiceType::OWN_PROCESS,
+        start_type: ServiceStartType::OnDemand,
+        error_control: ServiceErrorControl::Normal,
+        executable_path: service_binary_path.into(),
+        launch_arguments: vec![OsString::from(SERVICE_FLAG); 1],
+        dependencies: vec![],
+        account_name: None, // run as System
+        account_password: None,
+    };
+    let service = service_manager.create_service(&service_info, ServiceAccess::CHANGE_CONFIG)?;
+    service.set_description("A VPN")?;
+    Ok(())
+}
+
+fn uninstall() -> Result<(), windows_service::Error> {
+    use std::{thread, time::Duration};
+    use windows_service::{
+        service::{ServiceAccess, ServiceState},
+        service_manager::{ServiceManager, ServiceManagerAccess},
+    };
+
+    let manager_access = ServiceManagerAccess::CONNECT;
+    let service_manager = ServiceManager::local_computer(None::<&str>, manager_access)?;
+
+    let service_access = ServiceAccess::QUERY_STATUS | ServiceAccess::STOP | ServiceAccess::DELETE;
+    let service = service_manager.open_service(SERVICE_NAME, service_access)?;
+
+    let service_status = service.query_status()?;
+    if service_status.current_state != ServiceState::Stopped {
+        service.stop()?;
+        // Wait for service to stop
+        thread::sleep(Duration::from_secs(1));
+    }
+
+    service.delete()?;
+    Ok(())
+}
+
+fn start() -> Result<(), windows_service::Error> {
+    use std::env;
+    use windows_service::{
+        service::ServiceAccess,
+        service_manager::{ServiceManager, ServiceManagerAccess},
+    };
+    let manager_access = ServiceManagerAccess::CONNECT;
+    let service_manager = ServiceManager::local_computer(None::<&str>, manager_access)?;
+    let service = service_manager.open_service(SERVICE_NAME, ServiceAccess::START)?;
+    service.start(&[])
+}

switch-desktop/src/windows/service.rs

@@ -0,0 +1,13 @@
+// #[macro_use]
+// extern crate windows_service;
+
+use std::ffi::OsString;
+use windows_service::{define_windows_service, service_dispatcher};
+
+define_windows_service!(ffi_service_main, switch_service_main);
+pub fn switch_service_main(arguments: Vec<OsString>) {
+
+}
+pub fn start(){
+   service_dispatcher::start("switch-service",ffi_service_main).unwrap();
+}

switch-jni/src/lib.rs

@@ -1,19 +1,34 @@
 use std::net::{IpAddr, Ipv4Addr};
 
-
 use jni::errors::Error;
-use jni::objects::{JClass, JObject, JString, JValue};
-use jni::sys::{jbyte, jint, jintArray, jlong, jobject, jsize};
 use jni::JNIEnv;
+use jni::objects::{JClass, JObject, JString, JValue};
+use jni::sys::{jbyte, jint, jintArray, jlong, jobject, jobjectArray, jsize};
 
-use switch::handle::{CurrentDeviceInfo, Route};
 use switch::{Config, Switch};
+use switch::handle::{CurrentDeviceInfo, PeerDeviceInfo, Route};
 
-fn to_string(env: &JNIEnv, config: JObject, name: &str) -> Result<Option<String>, Error> {
+fn to_string_not_null(env: &JNIEnv, config: JObject, name: &str) -> Result<String, Error> {
     let value = env.get_field(config, name, "Ljava/lang/String;")?.l()?;
     if value.is_null() {
         env.throw_new("Ljava/lang/NullPointerException", &name)
             .expect("throw");
+        return Err(Error::NullPtr(name));
+    }
+    let value = env.get_string(JString::from(value))?;
+    match value.to_str() {
+        Ok(value) => Ok(value.to_string()),
+        Err(_) => {
+            env.throw_new("Ljava/lang/RuntimeException", "not utf-8")
+                .expect("throw");
+            return Err(Error::JavaException);
+        }
+    }
+}
+
+fn to_string(env: &JNIEnv, config: JObject, name: &str) -> Result<Option<String>, Error> {
+    let value = env.get_field(config, name, "Ljava/lang/String;")?.l()?;
+    if value.is_null() {
         return Ok(None);
     }
     let value = env.get_string(JString::from(value))?;
@@ -22,26 +37,36 @@ fn to_string(env: &JNIEnv, config: JObject, name: &str) -> Result<Option<String>
         Err(_) => {
             env.throw_new("Ljava/lang/RuntimeException", "not utf-8")
                 .expect("throw");
-            Ok(None)
+            return Err(Error::JavaException);
         }
     }
 }
 
 fn start(env: &JNIEnv, config: JObject) -> Result<Option<Switch>, Error> {
-    if let Some(token) = to_string(&env, config, "token")? {
-        if let Some(mac_address) = to_string(&env, config, "macAddress")? {
-            match Switch::start(Config::new(token, mac_address)) {
-                Ok(switch) => {
-                    return Ok(Some(switch));
-                }
-                Err(e) => {
-                    env.throw_new(
-                        "Ljava/lang/RuntimeException",
-                        format!("switch start failed {:?}", e),
-                    )
-                    .expect("throw");
-                }
-            }
+    let token = to_string_not_null(&env, config, "token")?;
+    let mac_address = to_string_not_null(&env, config, "macAddress")?;
+    let name = to_string(&env, config, "name")?;
+    let config = match Config::new(token, mac_address, name,||{}) {
+        Ok(config) => { config }
+        Err(e) => {
+            env.throw_new(
+                "Ljava/lang/RuntimeException",
+                format!("switch start failed {:?}", e),
+            )
+                .expect("throw");
+            return Ok(None);
+        }
+    };
+    match Switch::start(config) {
+        Ok(switch) => {
+            return Ok(Some(switch));
+        }
+        Err(e) => {
+            env.throw_new(
+                "Ljava/lang/RuntimeException",
+                format!("switch start failed {:?}", e),
+            )
+                .expect("throw");
         }
     }
     Ok(None)
@@ -93,7 +118,7 @@ pub unsafe extern "C" fn Java_org_switches_jni_Switch_deviceList0(
     env: JNIEnv,
     _class: JClass,
     raw_switch: jlong,
-) -> jintArray {
+) -> jobjectArray {
     let switch = raw_switch as *mut Switch;
     match device_list(&env, (&*switch).device_list()) {
         Ok(arr) => arr,
@@ -149,19 +174,28 @@ fn route(env: &JNIEnv, route: Route) -> Result<jobject, Error> {
     Ok(route.into_raw())
 }
 
-fn device_list(env: &JNIEnv, device_list: Vec<Ipv4Addr>) -> Result<jintArray, Error> {
+fn device_list(env: &JNIEnv, device_list: Vec<PeerDeviceInfo>) -> Result<jobjectArray, Error> {
     if device_list.is_empty() {
         return Ok(std::ptr::null_mut());
     }
-    let arr = env.new_int_array(device_list.len() as jsize)?;
-    let devices: Vec<jint> = device_list
-        .iter()
-        .map(|ip| {
-            let ip: u32 = (*ip).into();
-            ip as jint
-        })
-        .collect();
-    env.set_int_array_region(arr, 0, &devices)?;
+    let arr = env.new_object_array(device_list.len() as jsize,
+                                   "org/switches/jni/PeerDeviceInfo",
+                                   JObject::null())?;
+    let mut index = 0;
+    for peer_info in device_list {
+        let virtual_ip: u32 = peer_info.virtual_ip.into();
+        let name = peer_info.name;
+        let status = peer_info.status.into();
+        let info = env.new_object(
+            "org/switches/jni/PeerDeviceInfo",
+            "(BLjava/lang/String;J)V",
+            &[JValue::Int(virtual_ip as jint),
+                JValue::Object(env.new_string(name)?.into()),
+                JValue::Byte(status as jbyte)],
+        )?;
+        env.set_object_array_element(arr, index, info)?;
+        index += 1;
+    }
     Ok(arr)
 }
 

switch/Cargo.toml

@@ -24,7 +24,7 @@ chrono = "0.4.23"
 lazy_static = "1.4.0"
 moka = "0.9.6"
 protobuf = "3.2.0"
-
+os_info = "3.5.1"
 tokio = { version = "1.24.1", features = ["full"] }
 [target.'cfg(any(unix))'.dependencies]
 tun = { path = "./rust-tun" }

switch/proto/message.proto

@@ -2,6 +2,8 @@ syntax = "proto3";
 message RegistrationRequest{
   string token = 1;
   string mac_address = 2;
+  string name = 3;
+  bool is_fast = 4;
 }
 
 message RegistrationResponse{
@@ -9,14 +11,19 @@ message RegistrationResponse{
   fixed32 virtual_gateway = 2;
   fixed32 virtual_netmask = 3;
   uint32 epoch = 4;
-  repeated fixed32 virtual_ip_list = 5;
+  repeated DeviceInfo device_info_list = 5;
   fixed32 public_ip = 6;
   uint32 public_port = 7;
 }
+message DeviceInfo{
+  string name = 1;
+  fixed32 virtual_ip = 2;
+  uint32 device_status = 3;
+}
 
 message DeviceList{
   uint32 epoch = 1;
-  repeated fixed32 virtual_ip_list = 2;
+  repeated DeviceInfo device_info_list = 2;
 }
 
 message Punch{

switch/src/handle/heartbeat_handler.rs

@@ -23,7 +23,7 @@ pub async fn start<F>(
         match handle_loop(status_watch, udp, cur_info.connect_server).await {
             Ok(_) => {}
             Err(e) => {
-                log::error!("{:?}", e)
+                log::warn!("{:?}", e)
             }
         }
         stop_fn();

switch/src/handle/mod.rs

@@ -19,7 +19,7 @@ lazy_static! {
     /// 0. 机器纪元，每一次上线或者下线都会增1，由服务端维护，用于感知网络中机器变化
     /// 服务端和客户端的不一致，则服务端会推送新的设备列表
     /// 1. 网络中的虚拟ip列表
-    pub static ref DEVICE_LIST:Mutex<(u32,Vec<Ipv4Addr>)> = const_mutex((0,Vec::new()));
+    pub static ref DEVICE_LIST:Mutex<(u32,Vec<PeerDeviceInfo>)> = const_mutex((0,Vec::new()));
     /// 服务器延迟
     pub static ref SERVER_RT:AtomicI64 = AtomicI64::new(-1);
     /// id
@@ -32,6 +32,49 @@ lazy_static! {
     /// 当前设备的nat信息
     pub static ref NAT_INFO:Mutex<Option<NatInfo>> = const_mutex(None);
 }
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct PeerDeviceInfo {
+    pub virtual_ip: Ipv4Addr,
+    pub name: String,
+    pub status: PeerDeviceStatus,
+}
+
+impl PeerDeviceInfo {
+    pub fn new(virtual_ip: Ipv4Addr,
+               name: String,
+               status: u8, ) -> Self {
+        Self {
+            virtual_ip,
+            name,
+            status: PeerDeviceStatus::from(status),
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum PeerDeviceStatus {
+    Online,
+    Offline,
+}
+
+impl Into<u8> for PeerDeviceStatus {
+    fn into(self) -> u8 {
+        match self {
+            PeerDeviceStatus::Online => 0,
+            PeerDeviceStatus::Offline => 1,
+        }
+    }
+}
+
+impl From<u8> for PeerDeviceStatus {
+    fn from(value: u8) -> Self {
+        match value {
+            0 => PeerDeviceStatus::Online,
+            _ => PeerDeviceStatus::Offline
+        }
+    }
+}
+
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 pub enum ApplicationStatus {
     Starting,

switch/src/handle/punch_handler.rs

@@ -5,17 +5,17 @@ use std::time::Duration;
 use dashmap::DashMap;
 use lazy_static::lazy_static;
 use protobuf::Message;
-use tokio::sync::mpsc::error::TrySendError;
 use tokio::sync::mpsc::{Receiver, Sender};
+use tokio::sync::mpsc::error::TrySendError;
 use tokio::sync::watch;
 
+use crate::{CurrentDeviceInfo, DEVICE_LIST, handle::NAT_INFO, handle::NatInfo};
 use crate::error::*;
 use crate::handle::{ApplicationStatus, DIRECT_ROUTE_TABLE};
 use crate::proto::message::{NatType, Punch, Step};
+use crate::protocol::{control_packet, NetPacket, Protocol, turn_packet, Version};
 use crate::protocol::control_packet::PunchRequestPacket;
 use crate::protocol::turn_packet::TurnPacket;
-use crate::protocol::{control_packet, turn_packet, NetPacket, Protocol, Version};
-use crate::{handle::NatInfo, handle::NAT_INFO, CurrentDeviceInfo, DEVICE_LIST};
 
 lazy_static! {
     pub static ref STEP_MAP: DashMap<Ipv4Addr, Step> = DashMap::new();
@@ -193,7 +193,7 @@ pub async fn req_symmetric_handler_start<F>(
         match handle_loop(status_watch, receiver, udp, cur_info).await {
             Ok(_) => {}
             Err(e) => {
-                log::error!("{:?}", e)
+                log::warn!("{:?}", e)
             }
         }
         stop_fn()
@@ -224,7 +224,7 @@ pub async fn res_symmetric_handler_start<F>(
         match res_symmetric_handle_loop(status_watch, receiver, udp, cur_info).await {
             Ok(_) => {}
             Err(e) => {
-                log::error!("{:?}", e)
+                log::warn!("{:?}", e)
             }
         }
         stop_fn()
@@ -287,7 +287,7 @@ async fn res_symmetric_handle_loop(
                                 }
                             }
                             if let Err(e) = handle(&status_watch,&udp, list, packet.buffer()) {
-                                log::error!("{:?}",e)
+                                log::warn!("{:?}",e)
                             }
                         }else {
                             return Err(Error::Stop("打洞线程通道关闭".to_string()));
@@ -323,7 +323,7 @@ pub async fn cone_handler_start<F>(
         match handle_loop(status_watch, receiver, udp, cur_info).await {
             Ok(_) => {}
             Err(e) => {
-                log::error!("{:?}", e)
+                log::warn!("{:?}", e)
             }
         }
         stop_fn();
@@ -363,7 +363,7 @@ async fn handle_loop(
                             }
                         }
                         if let Err(e) = handle(&status_watch,&udp, list, packet.buffer()) {
-                            log::error!("{:?}",e)
+                            log::warn!("{:?}",e)
                         }
                  }else {
                      return Err(Error::Stop("打洞线程通道关闭".to_string()));
@@ -390,7 +390,7 @@ fn punch_request_handle(udp: &UdpSocket, cur_info: &CurrentDeviceInfo) -> Result
     drop(nat_info_lock);
     if let Some(nat_info) = nat_info {
         if let Err(e) = send_punch(&udp, &cur_info, nat_info) {
-            log::error!("发送打洞数据失败 {:?}", e)
+            log::warn!("发送打洞数据失败 {:?}", e)
         }
         Ok(())
     } else {
@@ -402,7 +402,8 @@ fn send_punch(udp: &UdpSocket, cur_info: &CurrentDeviceInfo, nat_info: NatInfo)
     let lock = DEVICE_LIST.lock();
     let list = lock.1.clone();
     drop(lock);
-    for ip in list {
+    for peer_info in list {
+        let ip = peer_info.virtual_ip;
         //只向ip比自己大的发起打洞，避免双方同时发起打洞浪费流量
         if ip > cur_info.virtual_ip && !DIRECT_ROUTE_TABLE.contains_key(&ip) {
             let step = if let Some(step) = STEP_MAP.get(&ip) {

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(());

switch/src/handle/tun_handler.rs

@@ -10,12 +10,12 @@ use packet::icmp::Kind;
 use packet::ip::ipv4;
 use packet::ip::ipv4::packet::IpV4Packet;
 
+use crate::ApplicationStatus;
 use crate::error::*;
 use crate::handle::{CurrentDeviceInfo, DIRECT_ROUTE_TABLE};
-use crate::protocol::turn_packet::TurnPacket;
 use crate::protocol::{NetPacket, Protocol, Version};
+use crate::protocol::turn_packet::TurnPacket;
 use crate::tun_device::TunReader;
-use crate::ApplicationStatus;
 
 /// 是否在一个网段
 fn check_dest(dest: Ipv4Addr, cur_info: &CurrentDeviceInfo) -> bool {
@@ -114,7 +114,7 @@ pub async fn handler_start<F>(
     });
     thread::spawn(move || {
         if let Err(e) = handle_loop(udp, tun_reader, cur_info) {
-            log::error!("tun数据处理线程停止 {:?}", e);
+            log::warn!("tun数据处理线程停止 {:?}", e);
         }
         stop_fn();
     });
@@ -132,7 +132,7 @@ fn handle_loop(udp: UdpSocket, tun_reader: TunReader, cur_info: CurrentDeviceInf
         match handle(&udp, data.bytes_mut(), &cur_info, &mut net_packet) {
             Ok(_) => {}
             Err(e) => {
-                println!("{:?}", e)
+                log::warn!("{:?}", e)
             }
         }
     }
@@ -164,7 +164,7 @@ pub async fn handler_start<F>(
     });
     thread::spawn(move || {
         if let Err(e) = handle_loop(udp, tun_reader, cur_info) {
-            log::error!(" tun数据处理线程停止 {:?}", e);
+            log::warn!(" tun数据处理线程停止 {:?}", e);
         }
         stop_fn();
     });
@@ -187,7 +187,7 @@ pub fn handle_loop(
         match handle(&udp, data, &cur_info, &mut net_packet) {
             Ok(_) => {}
             Err(e) => {
-                log::error!("{:?}", e)
+                log::warn!("{:?}", e)
             }
         }
     }

switch/src/handle/udp_recv_handler.rs

@@ -23,7 +23,7 @@ use crate::protocol::error_packet::InErrorPacket;
 use crate::protocol::turn_packet::TurnPacket;
 use crate::protocol::{control_packet, service_packet, turn_packet, NetPacket, Protocol, Version};
 use crate::tun_device::TunWriter;
-use crate::{ApplicationStatus, CurrentDeviceInfo};
+use crate::{ApplicationStatus, CurrentDeviceInfo, PeerDeviceInfo};
 
 const UDP_STOP_BUF: [u8; 1] = [0u8];
 
@@ -50,7 +50,7 @@ pub async fn udp_recv_start<F>(
 
     thread::spawn(move || {
         if let Err(e) = recv_loop(udp, server_addr, other_sender, tun_writer, current_device) {
-            log::error!("udp数据处理线程停止 {:?}", e);
+            log::warn!("udp数据处理线程停止 {:?}", e);
         }
         stop_fn();
     });
@@ -95,12 +95,12 @@ fn recv_loop(
                         return Err(Error::Stop(str));
                     }
                     Err(e) => {
-                        log::error!("{:?}", e);
+                        log::warn!("{:?}", e);
                     }
                 }
             }
             Err(e) => {
-                log::error!("{:?}", e);
+                log::warn!("{:?}", e);
             }
         };
     }
@@ -156,7 +156,7 @@ fn recv_handle(
                     return Err(Error::Stop("子处理线程停止".to_string()));
                 }
                 Err(e) => {
-                    log::error!("子线程处理 {:?}", e);
+                    log::warn!("子线程处理 {:?}", e);
                 }
             }
         }
@@ -178,7 +178,7 @@ pub async fn udp_other_recv_start<F>(
         match other_loop(status_watch, udp, receiver, current_device, sender).await {
             Ok(_) => {}
             Err(e) => {
-                log::error!("{:?}", e);
+                log::warn!("{:?}", e);
             }
         }
         stop_fn();
@@ -202,7 +202,7 @@ async fn other_loop(
                             return Err(Error::Stop(str));
                         }
                         Err(e) => {
-                            log::error!("other_loop {:?}",e);
+                            log::warn!("other_loop {:?}",e);
                         }
                     }
                 }
@@ -241,10 +241,10 @@ fn other_handle(
                 }
                 service_packet::Protocol::UpdateDeviceList => {
                     let device_list = DeviceList::parse_from_bytes(net_packet.payload())?;
-                    let ip_list: Vec<Ipv4Addr> = device_list
-                        .virtual_ip_list
-                        .iter()
-                        .map(|ip| Ipv4Addr::from(*ip))
+                    let ip_list = device_list
+                        .device_info_list
+                        .into_iter()
+                        .map(|info| PeerDeviceInfo::new(Ipv4Addr::from(info.virtual_ip), info.name, info.device_status as u8))
                         .collect();
                     let mut dev = DEVICE_LIST.lock();
                     if dev.0 < device_list.epoch || device_list.epoch - dev.0 > u32::MAX >> 2 {
@@ -269,7 +269,7 @@ fn other_handle(
                     }
                 }
                 InErrorPacket::OtherError(e) => {
-                    log::error!("OtherError {:?}", e.message());
+                    log::warn!("OtherError {:?}", e.message());
                 }
             }
         }
@@ -369,12 +369,10 @@ fn other_handle(
                     }
                     turn_packet::Protocol::UnKnow(_) => {}
                 }
-            } else {
-                panic!("ip")
             }
         }
         Protocol::UnKnow(p) => {
-            log::error!("未知协议 {}", p);
+            log::warn!("未知协议 {}", p);
         }
     }
     Ok(())

switch/src/lib.rs

@@ -1,17 +1,18 @@
+use std::borrow::Borrow;
 use std::io;
 use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4, ToSocketAddrs, UdpSocket};
-use std::sync::atomic::Ordering;
+use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
 
+use crossbeam::atomic::AtomicCell;
 use crossbeam::sync::WaitGroup;
+use parking_lot::Mutex;
 use tokio::sync::watch;
 
 use error::*;
 
+use crate::handle::{ApplicationStatus, ConnectStatus, CurrentDeviceInfo, DEVICE_LIST, DIRECT_ROUTE_TABLE, PeerDeviceInfo, Route, RouteType, SERVER_RT};
 use crate::handle::registration_handler::CONNECTION_STATUS;
-use crate::handle::{
-    ApplicationStatus, ConnectStatus, CurrentDeviceInfo, Route, RouteType, DEVICE_LIST,
-    DIRECT_ROUTE_TABLE, SERVER_RT,
-};
 
 pub mod error;
 pub mod handle;
@@ -21,31 +22,54 @@ pub mod protocol;
 pub mod tun_device;
 
 #[derive(Clone, Debug)]
-pub struct Config {
+pub struct Config<F> {
     pub token: String,
     pub mac_address: String,
+    pub name: String,
+    pub abnormal_call: F,
 }
 
-impl Config {
-    pub fn new(token: String, mac_address: String) -> Self {
-        Self { token, mac_address }
+impl<F> Config<F> {
+    pub fn new(token: String, mac_address: String, name: Option<String>, abnormal_call: F) -> Result<Self> where
+        F: FnOnce() + Send + 'static {
+        if token.is_empty() || token.len() > 64 {
+            return Err(Error::Stop("token invalid".to_string()));
+        }
+        if mac_address.len() != 12 + 5 {
+            return Err(Error::Stop("mac_address invalid".to_string()));
+        }
+        if let Some(name) = name {
+            if name.is_empty() || name.len() > 64 {
+                return Err(Error::Stop("name invalid".to_string()));
+            }
+            Ok(Self { token, mac_address, name, abnormal_call })
+        } else {
+            let info = os_info::get();
+            let name = if info.version() != &os_info::Version::Unknown {
+                format!("{} {}", info.os_type(), info.version())
+            } else {
+                format!("{}", info.os_type())
+            };
+            Ok(Self { token, mac_address, name, abnormal_call })
+        }
     }
 }
 
 pub struct Switch {
     current_device: CurrentDeviceInfo,
-    status_sender: watch::Sender<ApplicationStatus>,
+    status_sender: Arc<Mutex<watch::Sender<ApplicationStatus>>>,
     wait_group: WaitGroup,
     runtime: Option<tokio::runtime::Runtime>,
 }
 
 impl Switch {
-    pub fn start(config: Config) -> Result<Self> {
+    pub fn start<F>(config: Config<F>) -> Result<Self> where
+        F: FnOnce() + Send + 'static {
         let runtime = tokio::runtime::Builder::new_multi_thread()
             .enable_all()
             .build()
             .unwrap();
-        return match runtime.block_on(Switch::start_(config.token, config.mac_address)) {
+        return match runtime.block_on(Switch::start_(config)) {
             Ok(mut switch) => {
                 switch.runtime = Some(runtime);
                 Ok(switch)
@@ -54,7 +78,7 @@ impl Switch {
         };
     }
     pub fn stop(self) {
-        let _ = self.status_sender.send(ApplicationStatus::Stopping);
+        Self::call_stop(self.status_sender);
         self.wait_group.wait();
     }
     pub fn current_device(&self) -> &CurrentDeviceInfo {
@@ -66,7 +90,7 @@ impl Switch {
     pub fn connection_status(&self) -> ConnectStatus {
         CONNECTION_STATUS.load()
     }
-    pub fn device_list(&self) -> Vec<Ipv4Addr> {
+    pub fn device_list(&self) -> Vec<PeerDeviceInfo> {
         let device_list_lock = DEVICE_LIST.lock();
         let (_epoch, device_list) = device_list_lock.clone();
         drop(device_list_lock);
@@ -86,8 +110,15 @@ impl Switch {
 }
 
 impl Switch {
-    pub async fn start_(token: String, mac_address: String) -> Result<Self> {
-        let server_address = "nat1.wherewego.top:29876"
+    fn call_stop(status_sender: Arc<Mutex<watch::Sender<ApplicationStatus>>>) -> bool {
+        let lock = status_sender.lock();
+        let status = lock.send_replace(ApplicationStatus::Stopping);
+        return status == ApplicationStatus::Starting;
+    }
+    pub async fn start_<F>(config: Config<F>) -> Result<Self> where
+        F: FnOnce() + Send + 'static {
+        // let server_address = "nat1.wherewego.top:29876"
+        let server_address = "127.0.0.1:29876"
             .to_socket_addrs()
             .unwrap()
             .next()
@@ -110,12 +141,12 @@ impl Switch {
         };
         //注册
         let response =
-            handle::registration_handler::registration(&udp, server_address, token, mac_address)?;
+            handle::registration_handler::registration(&udp, server_address, config.token, config.mac_address, config.name)?;
         {
             let ip_list = response
-                .virtual_ip_list
-                .iter()
-                .map(|ip| Ipv4Addr::from(*ip))
+                .device_info_list
+                .into_iter()
+                .map(|info| PeerDeviceInfo::new(Ipv4Addr::from(info.virtual_ip), info.name, info.device_status as u8))
                 .collect();
             let mut dev = DEVICE_LIST.lock();
             dev.0 = response.epoch;
@@ -125,18 +156,27 @@ impl Switch {
         let virtual_gateway = Ipv4Addr::from(response.virtual_gateway);
         let virtual_netmask = Ipv4Addr::from(response.virtual_netmask);
         let (status_sender, status_receiver) =
-            tokio::sync::watch::channel(ApplicationStatus::Starting);
+            watch::channel(ApplicationStatus::Starting);
         let current_device =
             CurrentDeviceInfo::new(virtual_ip, virtual_gateway, virtual_netmask, server_address);
         let wait_group = WaitGroup::new();
+        let status_sender = Arc::new(parking_lot::const_mutex(status_sender));
+        let call = Arc::new(AtomicCell::new(Some(config.abnormal_call)));
         //心跳线程
         {
             let udp = udp.try_clone()?;
             let wait_group1 = wait_group.clone();
-            handle::heartbeat_handler::start(status_receiver.clone(), udp, current_device, || {
+            let status_sender1 = status_sender.clone();
+            let call1 = call.clone();
+            handle::heartbeat_handler::start(status_receiver.clone(), udp, current_device, move || {
+                if Self::call_stop(status_sender1) {
+                    if let Some(call) = call1.take() {
+                        call();
+                    }
+                }
                 drop(wait_group1);
             })
-            .await;
+                .await;
         }
         //初始化nat数据
         handle::init_nat_info(response.public_ip, response.public_port as u16);
@@ -152,6 +192,8 @@ impl Switch {
             let (sender, receiver) = tokio::sync::mpsc::channel(50);
             let udp1 = udp.try_clone()?;
             let wait_group1 = wait_group.clone();
+            let status_sender1 = status_sender.clone();
+            let call1 = call.clone();
             handle::udp_recv_handler::udp_recv_start(
                 status_receiver.clone(),
                 udp1,
@@ -159,77 +201,117 @@ impl Switch {
                 sender,
                 tun_writer,
                 current_device,
-                || {
+                move || {
+                    if Self::call_stop(status_sender1) {
+                        if let Some(call) = call1.take() {
+                            call();
+                        }
+                    }
                     drop(wait_group1);
                 },
             )
-            .await;
+                .await;
             let udp1 = udp.try_clone()?;
             let wait_group1 = wait_group.clone();
+            let status_sender1 = status_sender.clone();
+            let call1 = call.clone();
             handle::udp_recv_handler::udp_other_recv_start(
                 status_receiver.clone(),
                 udp1,
                 receiver,
                 current_device,
                 punch_sender,
-                || {
+                move || {
+                    if Self::call_stop(status_sender1) {
+                        if let Some(call) = call1.take() {
+                            call();
+                        }
+                    }
                     drop(wait_group1);
                 },
             )
-            .await;
+                .await;
         }
         //打洞处理
         {
             let udp1 = udp.try_clone()?;
             let wait_group1 = wait_group.clone();
+            let status_sender1 = status_sender.clone();
+            let call1 = call.clone();
             handle::punch_handler::cone_handler_start(
                 status_receiver.clone(),
                 cone_receiver,
                 udp1,
                 current_device,
-                || {
+                move || {
+                    if Self::call_stop(status_sender1) {
+                        if let Some(call) = call1.take() {
+                            call();
+                        }
+                    }
                     drop(wait_group1);
                 },
             )
-            .await;
+                .await;
             let udp1 = udp.try_clone()?;
             let wait_group1 = wait_group.clone();
+            let status_sender1 = status_sender.clone();
+            let call1 = call.clone();
             handle::punch_handler::req_symmetric_handler_start(
                 status_receiver.clone(),
                 req_symmetric_receiver,
                 udp1,
                 current_device,
-                || {
+                move || {
+                    if Self::call_stop(status_sender1) {
+                        if let Some(call) = call1.take() {
+                            call();
+                        }
+                    }
                     drop(wait_group1);
                 },
             )
-            .await;
+                .await;
             let udp1 = udp.try_clone()?;
             let wait_group1 = wait_group.clone();
+            let status_sender1 = status_sender.clone();
+            let call1 = call.clone();
             handle::punch_handler::res_symmetric_handler_start(
                 status_receiver.clone(),
                 res_symmetric_receiver,
                 udp1,
                 current_device,
-                || {
+                move || {
+                    if Self::call_stop(status_sender1) {
+                        if let Some(call) = call1.take() {
+                            call();
+                        }
+                    }
                     drop(wait_group1);
                 },
             )
-            .await;
+                .await;
         }
         //tun数据处理
         {
             let wait_group1 = wait_group.clone();
+            let status_sender1 = status_sender.clone();
+            let call1 = call.clone();
             handle::tun_handler::handler_start(
                 status_receiver.clone(),
                 udp,
                 tun_reader,
                 current_device,
-                || {
+                move || {
+                    if Self::call_stop(status_sender1) {
+                        if let Some(call) = call1.take() {
+                            call();
+                        }
+                    }
                     drop(wait_group1);
                 },
             )
-            .await;
+                .await;
         }
         Ok(Switch {
             current_device,

switch/src/proto/message.rs

@@ -33,6 +33,10 @@ pub struct RegistrationRequest {
     pub token: ::std::string::String,
     // @@protoc_insertion_point(field:RegistrationRequest.mac_address)
     pub mac_address: ::std::string::String,
+    // @@protoc_insertion_point(field:RegistrationRequest.name)
+    pub name: ::std::string::String,
+    // @@protoc_insertion_point(field:RegistrationRequest.is_fast)
+    pub is_fast: bool,
     // special fields
     // @@protoc_insertion_point(special_field:RegistrationRequest.special_fields)
     pub special_fields: ::protobuf::SpecialFields,
@@ -50,7 +54,7 @@ impl RegistrationRequest {
     }
 
     fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
-        let mut fields = ::std::vec::Vec::with_capacity(2);
+        let mut fields = ::std::vec::Vec::with_capacity(4);
         let mut oneofs = ::std::vec::Vec::with_capacity(0);
         fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
             "token",
@@ -62,6 +66,16 @@ impl RegistrationRequest {
             |m: &RegistrationRequest| { &m.mac_address },
             |m: &mut RegistrationRequest| { &mut m.mac_address },
         ));
+        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
+            "name",
+            |m: &RegistrationRequest| { &m.name },
+            |m: &mut RegistrationRequest| { &mut m.name },
+        ));
+        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
+            "is_fast",
+            |m: &RegistrationRequest| { &m.is_fast },
+            |m: &mut RegistrationRequest| { &mut m.is_fast },
+        ));
         ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<RegistrationRequest>(
             "RegistrationRequest",
             fields,
@@ -86,6 +100,12 @@ impl ::protobuf::Message for RegistrationRequest {
                 18 => {
                     self.mac_address = is.read_string()?;
                 },
+                26 => {
+                    self.name = is.read_string()?;
+                },
+                32 => {
+                    self.is_fast = is.read_bool()?;
+                },
                 tag => {
                     ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
                 },
@@ -104,6 +124,12 @@ impl ::protobuf::Message for RegistrationRequest {
         if !self.mac_address.is_empty() {
             my_size += ::protobuf::rt::string_size(2, &self.mac_address);
         }
+        if !self.name.is_empty() {
+            my_size += ::protobuf::rt::string_size(3, &self.name);
+        }
+        if self.is_fast != false {
+            my_size += 1 + 1;
+        }
         my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
         self.special_fields.cached_size().set(my_size as u32);
         my_size
@@ -116,6 +142,12 @@ impl ::protobuf::Message for RegistrationRequest {
         if !self.mac_address.is_empty() {
             os.write_string(2, &self.mac_address)?;
         }
+        if !self.name.is_empty() {
+            os.write_string(3, &self.name)?;
+        }
+        if self.is_fast != false {
+            os.write_bool(4, self.is_fast)?;
+        }
         os.write_unknown_fields(self.special_fields.unknown_fields())?;
         ::std::result::Result::Ok(())
     }
@@ -135,6 +167,8 @@ impl ::protobuf::Message for RegistrationRequest {
     fn clear(&mut self) {
         self.token.clear();
         self.mac_address.clear();
+        self.name.clear();
+        self.is_fast = false;
         self.special_fields.clear();
     }
 
@@ -142,6 +176,8 @@ impl ::protobuf::Message for RegistrationRequest {
         static instance: RegistrationRequest = RegistrationRequest {
             token: ::std::string::String::new(),
             mac_address: ::std::string::String::new(),
+            name: ::std::string::String::new(),
+            is_fast: false,
             special_fields: ::protobuf::SpecialFields::new(),
         };
         &instance
@@ -177,8 +213,8 @@ pub struct RegistrationResponse {
     pub virtual_netmask: u32,
     // @@protoc_insertion_point(field:RegistrationResponse.epoch)
     pub epoch: u32,
-    // @@protoc_insertion_point(field:RegistrationResponse.virtual_ip_list)
-    pub virtual_ip_list: ::std::vec::Vec<u32>,
+    // @@protoc_insertion_point(field:RegistrationResponse.device_info_list)
+    pub device_info_list: ::std::vec::Vec<DeviceInfo>,
     // @@protoc_insertion_point(field:RegistrationResponse.public_ip)
     pub public_ip: u32,
     // @@protoc_insertion_point(field:RegistrationResponse.public_port)
@@ -223,9 +259,9 @@ impl RegistrationResponse {
             |m: &mut RegistrationResponse| { &mut m.epoch },
         ));
         fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
-            "virtual_ip_list",
-            |m: &RegistrationResponse| { &m.virtual_ip_list },
-            |m: &mut RegistrationResponse| { &mut m.virtual_ip_list },
+            "device_info_list",
+            |m: &RegistrationResponse| { &m.device_info_list },
+            |m: &mut RegistrationResponse| { &mut m.device_info_list },
         ));
         fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
             "public_ip",
@@ -268,10 +304,7 @@ impl ::protobuf::Message for RegistrationResponse {
                     self.epoch = is.read_uint32()?;
                 },
                 42 => {
-                    is.read_repeated_packed_fixed32_into(&mut self.virtual_ip_list)?;
-                },
-                45 => {
-                    self.virtual_ip_list.push(is.read_fixed32()?);
+                    self.device_info_list.push(is.read_message()?);
                 },
                 53 => {
                     self.public_ip = is.read_fixed32()?;
@@ -303,7 +336,10 @@ impl ::protobuf::Message for RegistrationResponse {
         if self.epoch != 0 {
             my_size += ::protobuf::rt::uint32_size(4, self.epoch);
         }
-        my_size += 5 * self.virtual_ip_list.len() as u64;
+        for value in &self.device_info_list {
+            let len = value.compute_size();
+            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
+        };
         if self.public_ip != 0 {
             my_size += 1 + 4;
         }
@@ -328,8 +364,8 @@ impl ::protobuf::Message for RegistrationResponse {
         if self.epoch != 0 {
             os.write_uint32(4, self.epoch)?;
         }
-        for v in &self.virtual_ip_list {
-            os.write_fixed32(5, *v)?;
+        for v in &self.device_info_list {
+            ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?;
         };
         if self.public_ip != 0 {
             os.write_fixed32(6, self.public_ip)?;
@@ -358,7 +394,7 @@ impl ::protobuf::Message for RegistrationResponse {
         self.virtual_gateway = 0;
         self.virtual_netmask = 0;
         self.epoch = 0;
-        self.virtual_ip_list.clear();
+        self.device_info_list.clear();
         self.public_ip = 0;
         self.public_port = 0;
         self.special_fields.clear();
@@ -370,7 +406,7 @@ impl ::protobuf::Message for RegistrationResponse {
             virtual_gateway: 0,
             virtual_netmask: 0,
             epoch: 0,
-            virtual_ip_list: ::std::vec::Vec::new(),
+            device_info_list: ::std::vec::Vec::new(),
             public_ip: 0,
             public_port: 0,
             special_fields: ::protobuf::SpecialFields::new(),
@@ -396,14 +432,172 @@ impl ::protobuf::reflect::ProtobufValue for RegistrationResponse {
     type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
 }
 
+#[derive(PartialEq,Clone,Default,Debug)]
+// @@protoc_insertion_point(message:DeviceInfo)
+pub struct DeviceInfo {
+    // message fields
+    // @@protoc_insertion_point(field:DeviceInfo.name)
+    pub name: ::std::string::String,
+    // @@protoc_insertion_point(field:DeviceInfo.virtual_ip)
+    pub virtual_ip: u32,
+    // @@protoc_insertion_point(field:DeviceInfo.device_status)
+    pub device_status: u32,
+    // special fields
+    // @@protoc_insertion_point(special_field:DeviceInfo.special_fields)
+    pub special_fields: ::protobuf::SpecialFields,
+}
+
+impl<'a> ::std::default::Default for &'a DeviceInfo {
+    fn default() -> &'a DeviceInfo {
+        <DeviceInfo as ::protobuf::Message>::default_instance()
+    }
+}
+
+impl DeviceInfo {
+    pub fn new() -> DeviceInfo {
+        ::std::default::Default::default()
+    }
+
+    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
+        let mut fields = ::std::vec::Vec::with_capacity(3);
+        let mut oneofs = ::std::vec::Vec::with_capacity(0);
+        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
+            "name",
+            |m: &DeviceInfo| { &m.name },
+            |m: &mut DeviceInfo| { &mut m.name },
+        ));
+        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
+            "virtual_ip",
+            |m: &DeviceInfo| { &m.virtual_ip },
+            |m: &mut DeviceInfo| { &mut m.virtual_ip },
+        ));
+        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
+            "device_status",
+            |m: &DeviceInfo| { &m.device_status },
+            |m: &mut DeviceInfo| { &mut m.device_status },
+        ));
+        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<DeviceInfo>(
+            "DeviceInfo",
+            fields,
+            oneofs,
+        )
+    }
+}
+
+impl ::protobuf::Message for DeviceInfo {
+    const NAME: &'static str = "DeviceInfo";
+
+    fn is_initialized(&self) -> bool {
+        true
+    }
+
+    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
+        while let Some(tag) = is.read_raw_tag_or_eof()? {
+            match tag {
+                10 => {
+                    self.name = is.read_string()?;
+                },
+                21 => {
+                    self.virtual_ip = is.read_fixed32()?;
+                },
+                24 => {
+                    self.device_status = is.read_uint32()?;
+                },
+                tag => {
+                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
+                },
+            };
+        }
+        ::std::result::Result::Ok(())
+    }
+
+    // Compute sizes of nested messages
+    #[allow(unused_variables)]
+    fn compute_size(&self) -> u64 {
+        let mut my_size = 0;
+        if !self.name.is_empty() {
+            my_size += ::protobuf::rt::string_size(1, &self.name);
+        }
+        if self.virtual_ip != 0 {
+            my_size += 1 + 4;
+        }
+        if self.device_status != 0 {
+            my_size += ::protobuf::rt::uint32_size(3, self.device_status);
+        }
+        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
+        self.special_fields.cached_size().set(my_size as u32);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
+        if !self.name.is_empty() {
+            os.write_string(1, &self.name)?;
+        }
+        if self.virtual_ip != 0 {
+            os.write_fixed32(2, self.virtual_ip)?;
+        }
+        if self.device_status != 0 {
+            os.write_uint32(3, self.device_status)?;
+        }
+        os.write_unknown_fields(self.special_fields.unknown_fields())?;
+        ::std::result::Result::Ok(())
+    }
+
+    fn special_fields(&self) -> &::protobuf::SpecialFields {
+        &self.special_fields
+    }
+
+    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
+        &mut self.special_fields
+    }
+
+    fn new() -> DeviceInfo {
+        DeviceInfo::new()
+    }
+
+    fn clear(&mut self) {
+        self.name.clear();
+        self.virtual_ip = 0;
+        self.device_status = 0;
+        self.special_fields.clear();
+    }
+
+    fn default_instance() -> &'static DeviceInfo {
+        static instance: DeviceInfo = DeviceInfo {
+            name: ::std::string::String::new(),
+            virtual_ip: 0,
+            device_status: 0,
+            special_fields: ::protobuf::SpecialFields::new(),
+        };
+        &instance
+    }
+}
+
+impl ::protobuf::MessageFull for DeviceInfo {
+    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
+        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
+        descriptor.get(|| file_descriptor().message_by_package_relative_name("DeviceInfo").unwrap()).clone()
+    }
+}
+
+impl ::std::fmt::Display for DeviceInfo {
+    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        ::protobuf::text_format::fmt(self, f)
+    }
+}
+
+impl ::protobuf::reflect::ProtobufValue for DeviceInfo {
+    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
+}
+
 #[derive(PartialEq,Clone,Default,Debug)]
 // @@protoc_insertion_point(message:DeviceList)
 pub struct DeviceList {
     // message fields
     // @@protoc_insertion_point(field:DeviceList.epoch)
     pub epoch: u32,
-    // @@protoc_insertion_point(field:DeviceList.virtual_ip_list)
-    pub virtual_ip_list: ::std::vec::Vec<u32>,
+    // @@protoc_insertion_point(field:DeviceList.device_info_list)
+    pub device_info_list: ::std::vec::Vec<DeviceInfo>,
     // special fields
     // @@protoc_insertion_point(special_field:DeviceList.special_fields)
     pub special_fields: ::protobuf::SpecialFields,
@@ -429,9 +623,9 @@ impl DeviceList {
             |m: &mut DeviceList| { &mut m.epoch },
         ));
         fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
-            "virtual_ip_list",
-            |m: &DeviceList| { &m.virtual_ip_list },
-            |m: &mut DeviceList| { &mut m.virtual_ip_list },
+            "device_info_list",
+            |m: &DeviceList| { &m.device_info_list },
+            |m: &mut DeviceList| { &mut m.device_info_list },
         ));
         ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<DeviceList>(
             "DeviceList",
@@ -455,10 +649,7 @@ impl ::protobuf::Message for DeviceList {
                     self.epoch = is.read_uint32()?;
                 },
                 18 => {
-                    is.read_repeated_packed_fixed32_into(&mut self.virtual_ip_list)?;
-                },
-                21 => {
-                    self.virtual_ip_list.push(is.read_fixed32()?);
+                    self.device_info_list.push(is.read_message()?);
                 },
                 tag => {
                     ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
@@ -475,7 +666,10 @@ impl ::protobuf::Message for DeviceList {
         if self.epoch != 0 {
             my_size += ::protobuf::rt::uint32_size(1, self.epoch);
         }
-        my_size += 5 * self.virtual_ip_list.len() as u64;
+        for value in &self.device_info_list {
+            let len = value.compute_size();
+            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
+        };
         my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
         self.special_fields.cached_size().set(my_size as u32);
         my_size
@@ -485,8 +679,8 @@ impl ::protobuf::Message for DeviceList {
         if self.epoch != 0 {
             os.write_uint32(1, self.epoch)?;
         }
-        for v in &self.virtual_ip_list {
-            os.write_fixed32(2, *v)?;
+        for v in &self.device_info_list {
+            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
         };
         os.write_unknown_fields(self.special_fields.unknown_fields())?;
         ::std::result::Result::Ok(())
@@ -506,14 +700,14 @@ impl ::protobuf::Message for DeviceList {
 
     fn clear(&mut self) {
         self.epoch = 0;
-        self.virtual_ip_list.clear();
+        self.device_info_list.clear();
         self.special_fields.clear();
     }
 
     fn default_instance() -> &'static DeviceList {
         static instance: DeviceList = DeviceList {
             epoch: 0,
-            virtual_ip_list: ::std::vec::Vec::new(),
+            device_info_list: ::std::vec::Vec::new(),
             special_fields: ::protobuf::SpecialFields::new(),
         };
         &instance
@@ -885,25 +1079,30 @@ impl Step {
 }
 
 static file_descriptor_proto_data: &'static [u8] = b"\
-    \n\rmessage.proto\"L\n\x13RegistrationRequest\x12\x14\n\x05token\x18\x01\
+    \n\rmessage.proto\"y\n\x13RegistrationRequest\x12\x14\n\x05token\x18\x01\
     \x20\x01(\tR\x05token\x12\x1f\n\x0bmac_address\x18\x02\x20\x01(\tR\nmacA\
-    ddress\"\x83\x02\n\x14RegistrationResponse\x12\x1d\n\nvirtual_ip\x18\x01\
-    \x20\x01(\x07R\tvirtualIp\x12'\n\x0fvirtual_gateway\x18\x02\x20\x01(\x07\
-    R\x0evirtualGateway\x12'\n\x0fvirtual_netmask\x18\x03\x20\x01(\x07R\x0ev\
-    irtualNetmask\x12\x14\n\x05epoch\x18\x04\x20\x01(\rR\x05epoch\x12&\n\x0f\
-    virtual_ip_list\x18\x05\x20\x03(\x07R\rvirtualIpList\x12\x1b\n\tpublic_i\
-    p\x18\x06\x20\x01(\x07R\x08publicIp\x12\x1f\n\x0bpublic_port\x18\x07\x20\
-    \x01(\rR\npublicPort\"J\n\nDeviceList\x12\x14\n\x05epoch\x18\x01\x20\x01\
-    (\rR\x05epoch\x12&\n\x0fvirtual_ip_list\x18\x02\x20\x03(\x07R\rvirtualIp\
-    List\"\xef\x01\n\x05Punch\x12\x1d\n\nvirtual_ip\x18\x01\x20\x01(\x07R\tv\
-    irtualIp\x12$\n\x0epublic_ip_list\x18\x02\x20\x03(\x07R\x0cpublicIpList\
-    \x12\x1f\n\x0bpublic_port\x18\x03\x20\x01(\rR\npublicPort\x12*\n\x11publ\
-    ic_port_range\x18\x04\x20\x01(\rR\x0fpublicPortRange\x12#\n\x08nat_type\
-    \x18\x05\x20\x01(\x0e2\x08.NatTypeR\x07natType\x12\x14\n\x05reply\x18\
-    \x06\x20\x01(\x08R\x05reply\x12\x19\n\x04step\x18\x07\x20\x01(\x0e2\x05.\
-    StepR\x04step*\"\n\x07NatType\x12\r\n\tSymmetric\x10\0\x12\x08\n\x04Cone\
-    \x10\x01*2\n\x04Step\x12\t\n\x05Step1\x10\0\x12\t\n\x05Step2\x10\x01\x12\
-    \t\n\x05Step3\x10\x02\x12\t\n\x05Step4\x10\x03b\x06proto3\
+    ddress\x12\x12\n\x04name\x18\x03\x20\x01(\tR\x04name\x12\x17\n\x07is_fas\
+    t\x18\x04\x20\x01(\x08R\x06isFast\"\x92\x02\n\x14RegistrationResponse\
+    \x12\x1d\n\nvirtual_ip\x18\x01\x20\x01(\x07R\tvirtualIp\x12'\n\x0fvirtua\
+    l_gateway\x18\x02\x20\x01(\x07R\x0evirtualGateway\x12'\n\x0fvirtual_netm\
+    ask\x18\x03\x20\x01(\x07R\x0evirtualNetmask\x12\x14\n\x05epoch\x18\x04\
+    \x20\x01(\rR\x05epoch\x125\n\x10device_info_list\x18\x05\x20\x03(\x0b2\
+    \x0b.DeviceInfoR\x0edeviceInfoList\x12\x1b\n\tpublic_ip\x18\x06\x20\x01(\
+    \x07R\x08publicIp\x12\x1f\n\x0bpublic_port\x18\x07\x20\x01(\rR\npublicPo\
+    rt\"d\n\nDeviceInfo\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04name\x12\
+    \x1d\n\nvirtual_ip\x18\x02\x20\x01(\x07R\tvirtualIp\x12#\n\rdevice_statu\
+    s\x18\x03\x20\x01(\rR\x0cdeviceStatus\"Y\n\nDeviceList\x12\x14\n\x05epoc\
+    h\x18\x01\x20\x01(\rR\x05epoch\x125\n\x10device_info_list\x18\x02\x20\
+    \x03(\x0b2\x0b.DeviceInfoR\x0edeviceInfoList\"\xef\x01\n\x05Punch\x12\
+    \x1d\n\nvirtual_ip\x18\x01\x20\x01(\x07R\tvirtualIp\x12$\n\x0epublic_ip_\
+    list\x18\x02\x20\x03(\x07R\x0cpublicIpList\x12\x1f\n\x0bpublic_port\x18\
+    \x03\x20\x01(\rR\npublicPort\x12*\n\x11public_port_range\x18\x04\x20\x01\
+    (\rR\x0fpublicPortRange\x12#\n\x08nat_type\x18\x05\x20\x01(\x0e2\x08.Nat\
+    TypeR\x07natType\x12\x14\n\x05reply\x18\x06\x20\x01(\x08R\x05reply\x12\
+    \x19\n\x04step\x18\x07\x20\x01(\x0e2\x05.StepR\x04step*\"\n\x07NatType\
+    \x12\r\n\tSymmetric\x10\0\x12\x08\n\x04Cone\x10\x01*2\n\x04Step\x12\t\n\
+    \x05Step1\x10\0\x12\t\n\x05Step2\x10\x01\x12\t\n\x05Step3\x10\x02\x12\t\
+    \n\x05Step4\x10\x03b\x06proto3\
 ";
 
 /// `FileDescriptorProto` object which was a source for this generated file
@@ -921,9 +1120,10 @@ pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor {
     file_descriptor.get(|| {
         let generated_file_descriptor = generated_file_descriptor_lazy.get(|| {
             let mut deps = ::std::vec::Vec::with_capacity(0);
-            let mut messages = ::std::vec::Vec::with_capacity(4);
+            let mut messages = ::std::vec::Vec::with_capacity(5);
             messages.push(RegistrationRequest::generated_message_descriptor_data());
             messages.push(RegistrationResponse::generated_message_descriptor_data());
+            messages.push(DeviceInfo::generated_message_descriptor_data());
             messages.push(DeviceList::generated_message_descriptor_data());
             messages.push(Punch::generated_message_descriptor_data());
             let mut enums = ::std::vec::Vec::with_capacity(2);