1.增加设备名称和状态

2.测试windows服务

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