1.更新对称NAT的打洞方式；2.支持windows服务；3.更新协议内容

switch-desktop/src/command/client.rs

@@ -0,0 +1,35 @@
+use std::io;
+use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4, UdpSocket};
+use std::time::Duration;
+
+pub struct CommandClient {
+    udp: UdpSocket,
+}
+
+impl CommandClient {
+    pub fn new() -> io::Result<Self> {
+        let port = crate::config::read_command_port().unwrap();
+        let udp = UdpSocket::bind("127.0.0.1:0")?;
+        udp.set_read_timeout(Some(Duration::from_secs(5)))?;
+        udp.connect(SocketAddr::V4(SocketAddrV4::new(
+            Ipv4Addr::new(127, 0, 0, 1),
+            port,
+        )))?;
+        Ok(Self { udp })
+    }
+}
+
+impl CommandClient {
+    pub fn list(&self) -> io::Result<String> {
+        self.udp.send(b"list")?;
+        let mut buf = [0; 10240];
+        let len = self.udp.recv(&mut buf)?;
+        Ok(String::from_utf8(buf[..len].to_vec()).unwrap())
+    }
+    pub fn status(&self) -> io::Result<String> {
+        self.udp.send(b"status")?;
+        let mut buf = [0; 10240];
+        let len = self.udp.recv(&mut buf)?;
+        Ok(String::from_utf8(buf[..len].to_vec()).unwrap())
+    }
+}

switch-desktop/src/command/mod.rs

@@ -0,0 +1,2 @@
+pub mod client;
+pub mod server;

switch-desktop/src/command/server.rs

@@ -0,0 +1,157 @@
+use std::io;
+use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4, UdpSocket};
+
+use std::sync::Arc;
+
+use console::style;
+
+use switch::handle::{PeerDeviceStatus, RouteType};
+use switch::Switch;
+
+pub struct CommandServer {}
+
+impl CommandServer {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
+impl CommandServer {
+    pub fn start(&self, switch: Arc<Switch>) -> io::Result<()> {
+        let mut port = 21637 as u16;
+        let udp = loop {
+            match UdpSocket::bind(SocketAddr::V4(SocketAddrV4::new(
+                Ipv4Addr::new(127, 0, 0, 1),
+                port,
+            ))) {
+                Ok(udp) => {
+                    break udp;
+                }
+                Err(e) => {
+                    if e.kind() == io::ErrorKind::AddrInUse {
+                        port += 1;
+                    } else {
+                        log::error!("创建udp失败 {:?}", e);
+                        return Err(e);
+                    }
+                }
+            }
+        };
+        crate::config::update_command_port(port)?;
+        let mut buf = [0u8; 64];
+        loop {
+            let (len, addr) = udp.recv_from(&mut buf)?;
+            match std::str::from_utf8(&buf[..len]) {
+                Ok(cmd) => {
+                    if let Ok(out) = command(cmd, &switch) {
+                        udp.send_to(out.as_bytes(), addr)?;
+                    }
+                }
+                Err(e) => {
+                    log::warn!("{:?}", e);
+                }
+            }
+        }
+    }
+}
+fn command(cmd: &str, switch: &Switch) -> io::Result<String> {
+    let mut out_str = String::new();
+    match cmd {
+        "list" => {
+            let server_rt = switch.server_rt();
+            let device_list = switch.device_list();
+            if device_list.is_empty() {
+                return Ok("No other devices found\n".to_string());
+            }
+            for peer_device_info in device_list {
+                let route = switch.route(&peer_device_info.virtual_ip);
+                let str = if peer_device_info.status == PeerDeviceStatus::Online {
+                    if route.route_type == RouteType::P2P {
+                        let str = if route.rt >= 0 {
+                            format!(
+                                "[{}] {}(p2p delay:{}ms)\n",
+                                peer_device_info.name, peer_device_info.virtual_ip, route.rt
+                            )
+                        } else {
+                            format!(
+                                "[{}] {}(p2p)",
+                                peer_device_info.name, peer_device_info.virtual_ip
+                            )
+                        };
+                        style(str).green().to_string()
+                    } else {
+                        let str = if server_rt >= 0 {
+                            format!(
+                                "[{}] {}(relay delay:{}ms)\n",
+                                peer_device_info.name,
+                                peer_device_info.virtual_ip,
+                                server_rt * 2
+                            )
+                        } else {
+                            format!(
+                                "[{}] {}(relay)\n",
+                                peer_device_info.name, peer_device_info.virtual_ip
+                            )
+                        };
+                        style(str).blue().to_string()
+                    }
+                } else {
+                    let str = format!(
+                        "[{}] {}(Offline)\n",
+                        peer_device_info.name, peer_device_info.virtual_ip
+                    );
+                    style(str).red().to_string()
+                };
+                out_str.push_str(&str);
+            }
+        }
+        "status" => {
+            let server_rt = switch.server_rt();
+            let current_device = switch.current_device();
+            let str = format!("Virtual ip:{}\n", style(current_device.virtual_ip).green());
+            out_str.push_str(&str);
+            let str = format!(
+                "Virtual gateway:{}\n",
+                style(current_device.virtual_gateway).green()
+            );
+            out_str.push_str(&str);
+            let str = format!(
+                "Connection status :{}\n",
+                style(format!("{:?}", switch.connection_status())).green()
+            );
+            out_str.push_str(&str);
+            let str = format!(
+                "Relay server :{}\n",
+                style(current_device.connect_server).green()
+            );
+            out_str.push_str(&str);
+            if server_rt >= 0 {
+                let str = format!("Delay of relay server :{}ms\n", style(server_rt).green());
+                out_str.push_str(&str);
+            }
+        }
+        "help" | "h" => {
+            let str = format!("Options: \n");
+            out_str.push_str(&str);
+            let str = format!(
+                "{} , Query the virtual IP of other devices\n",
+                style("list").green()
+            );
+            out_str.push_str(&str);
+            let str = format!("{} , View current device status\n", style("status").green());
+            out_str.push_str(&str);
+            let str = format!("{} , Exit the program\n", style("exit").green());
+            out_str.push_str(&str);
+        }
+        "exit" => {
+            switch.stop_async();
+        }
+        _ => {
+            let str = format!("command '{}' not fount. \n", style(cmd).red());
+            out_str.push_str(&str);
+            let str = format!("Try to enter: '{}'\n", style("help").green());
+            out_str.push_str(&str);
+        }
+    }
+    Ok(out_str)
+}

switch-desktop/src/config/mod.rs

@@ -0,0 +1,100 @@
+use std::fs::File;
+use std::io;
+use std::io::{Read, Write};
+use std::path::PathBuf;
+
+use lazy_static::lazy_static;
+use parking_lot::Mutex;
+use serde::{Deserialize, Serialize};
+
+lazy_static! {
+    static ref CONFIG: Mutex<Option<ArgsConfig>> = Mutex::new(None);
+    static ref SWITCH_HOME_PATH: Mutex<Option<PathBuf>> = Mutex::new(None);
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct ArgsConfig {
+    pub token: String,
+    pub name: Option<String>,
+    pub command_port: Option<u16>,
+}
+
+impl ArgsConfig {
+    pub fn new(token: String, name: Option<String>) -> Self {
+        Self {
+            token,
+            name,
+            command_port: None,
+        }
+    }
+}
+
+pub fn save_config(config: ArgsConfig) -> io::Result<()> {
+    let config_path = dirs::home_dir().unwrap().join(".switch").join("config");
+    save_config_(config, config_path)
+}
+
+fn save_config_(config: ArgsConfig, config_path: PathBuf) -> io::Result<()> {
+    let str = serde_yaml::to_string(&config).unwrap();
+    let mut file = File::create(config_path)?;
+    file.write_all(str.as_bytes())
+}
+
+pub fn update_command_port(port: u16) -> io::Result<()> {
+    let home_lock = SWITCH_HOME_PATH.lock();
+    if let Some(home) = home_lock.clone() {
+        drop(home_lock);
+        let config_path = home.join("config");
+        if let Some(mut config) = read_config() {
+            config.command_port = Some(port);
+            return save_config_(config, config_path);
+        }
+    }
+    Err(io::Error::new(io::ErrorKind::Other, "not found"))
+}
+
+pub fn read_command_port() -> io::Result<u16> {
+    let home = dirs::home_dir().unwrap().join(".switch");
+    let config = read_config_(home)?;
+    Ok(config.command_port.unwrap())
+}
+
+pub fn read_config() -> Option<ArgsConfig> {
+    let mut lock = CONFIG.lock();
+    let c = lock.clone();
+    if c.is_some() {
+        return c;
+    }
+    if let Some(home) = SWITCH_HOME_PATH.lock().clone() {
+        match read_config_(home) {
+            Ok(config) => {
+                lock.replace(config.clone());
+                Some(config)
+            }
+            Err(e) => {
+                log::error!("{:?}", e);
+                None
+            }
+        }
+    } else {
+        None
+    }
+}
+
+pub fn set_home(home: PathBuf) {
+    SWITCH_HOME_PATH.lock().replace(home);
+}
+
+fn read_config_(home: PathBuf) -> io::Result<ArgsConfig> {
+    let config_path = home.join("config");
+    let mut file = File::open(config_path)?;
+    let mut str = String::new();
+    file.read_to_string(&mut str)?;
+    match serde_yaml::from_str::<ArgsConfig>(&str) {
+        Ok(config) => Ok(config),
+        Err(e) => {
+            log::warn!("{:?}", e);
+            Err(io::Error::new(io::ErrorKind::Other, "config error"))
+        }
+    }
+}

switch-desktop/src/main.rs

@@ -1,19 +1,23 @@
+use std::io;
+use std::path::PathBuf;
+
 use clap::Parser;
 use console::style;
 
-use switch::*;
-use switch::handle::{PeerDeviceStatus, RouteType};
 
-#[cfg(windows)]
-mod windows_admin_check;
+use switch::handle::{PeerDeviceStatus, RouteType};
+use switch::*;
+
+mod command;
+mod config;
 #[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位字符
@@ -29,24 +33,52 @@ struct Args {
     name: Option<String>,
 }
 
-fn log_init() {
-    let home = dirs::home_dir().unwrap().join(".switch");
+fn log_init_service(home: PathBuf) -> io::Result<()> {
     if !home.exists() {
-        std::fs::create_dir(&home).expect(" Failed to create '.switch' directory");
+        std::fs::create_dir(&home)?;
     }
-    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(
             "{d(%+)(utc)} [{f}:{L}] {h({l})} {M}:{m}{n}\n",
         )))
-        .build(home.join("switch.log"))
-        .unwrap();
-    let config = log4rs::Config::builder()
+        .build(home.join("switch-service.log"))?;
+    match log4rs::Config::builder()
+        .appender(log4rs::config::Appender::builder().build("logfile", Box::new(logfile)))
+        .build(
+            log4rs::config::Root::builder()
+                .appender("logfile")
+                .build(log::LevelFilter::Info),
+        ) {
+        Ok(config) => {
+            let _ = log4rs::init_config(config);
+        }
+        Err(_) => {}
+    }
+    Ok(())
+}
+
+fn log_init() -> io::Result<()> {
+    let home = dirs::home_dir().unwrap().join(".switch");
+    if !home.exists() {
+        std::fs::create_dir(&home)?;
+    }
+    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(
+            "{d(%+)(utc)} [{f}:{L}] {h({l})} {M}:{m}{n}\n",
+        )))
+        .build(home.join("switch.log"))?;
+    match 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)))
+                .filter(Box::new(log4rs::filter::threshold::ThresholdFilter::new(
+                    log::LevelFilter::Error,
+                )))
                 .build("stderr", Box::new(stderr)),
         )
         .build(
@@ -54,53 +86,57 @@ fn log_init() {
                 .appender("logfile")
                 .appender("stderr")
                 .build(log::LevelFilter::Info),
-        )
-        .unwrap();
-    let _ = log4rs::init_config(config);
+        ) {
+        Ok(config) => {
+            let _ = log4rs::init_config(config);
+        }
+        Err(_) => {}
+    }
+    Ok(())
 }
 
+#[cfg(windows)]
+fn main() {
+    let args: Vec<_> = std::env::args().collect();
+    if args.len() == 3 && args[1] == windows::SERVICE_FLAG {
+        //以服务的方式启动
+        let _ = log_init_service(PathBuf::from(&args[2]));
+        config::set_home(PathBuf::from(&args[2]));
+        log::info!("config  {:?}", PathBuf::from(&args[2]));
+        log::info!("config  {:?}", config::read_config());
+        windows::service::start();
+        return;
+    } else {
+        let _ = log_init();
+        windows::main0();
+    }
+    // println!("{}", style("starting...").green());
+}
+
+#[cfg(any(target_os = "linux", target_os = "macos"))]
 fn main() {
     log_init();
     let args = Args::parse();
-    #[cfg(windows)]
-    if !windows_admin_check::is_app_elevated() {
-        let args: Vec<_> = std::env::args().collect();
-        println!("{}", style("正在启动管理员权限执行...").red());
-        if let Some(absolute_path) = std::env::current_exe()
-            .ok()
-            .and_then(|p| p.to_str().map(|p| p.to_string()))
-        {
-            let _ = runas::Command::new(&absolute_path)
-                .args(&args[1..])
-                .status()
-                .expect("failed to execute");
-        } else {
-            panic!("failed to execute")
-        }
-        return;
-    }
-
-    #[cfg(any(unix))]
     if sudo::RunningAs::Root != sudo::check() {
         println!("{}", style("需要使用root权限执行...").red());
         sudo::escalate_if_needed().unwrap();
     }
     println!("{}", style("starting...").green());
+    start(args.token, args.name);
+}
+
+pub fn start(token: String, name: Option<String>) {
     let mac_address = mac_address::get_mac_address().unwrap().unwrap().to_string();
-    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;
-                }
+    let switch = match Config::new(token, mac_address, name, || {}) {
+        Ok(config) => match Switch::start(config) {
+            Ok(switch) => switch,
+            Err(e) => {
+                log::error!("{:?}", e);
+                return;
             }
-        }
+        },
         Err(e) => {
-            log::error!("{:?}",e);
+            log::error!("{:?}", e);
             return;
         }
     };
@@ -155,21 +191,38 @@ fn command(cmd: &str, switch: &Switch) -> Result<(), ()> {
                 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)
+                            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)
+                            format!(
+                                "[{}] {}(p2p)",
+                                peer_device_info.name, peer_device_info.virtual_ip
+                            )
                         };
                         println!("{}", style(str).green());
                     } else {
                         let str = if server_rt >= 0 {
-                            format!("[{}] {}(relay delay:{}ms)", peer_device_info.name, peer_device_info.virtual_ip, server_rt * 2)
+                            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)
+                            format!(
+                                "[{}] {}(relay)",
+                                peer_device_info.name, peer_device_info.virtual_ip
+                            )
                         };
                         println!("{}", style(str).blue());
                     }
                 } else {
-                    let str = format!("[{}] {}(Offline)", peer_device_info.name, peer_device_info.virtual_ip);
+                    let str = format!(
+                        "[{}] {}(Offline)",
+                        peer_device_info.name, peer_device_info.virtual_ip
+                    );
                     println!("{}", style(str).red());
                 }
             }

switch-desktop/src/windows/mod.rs

@@ -1,7 +1,20 @@
+use std::{io, thread};
+use std::ffi::OsString;
+use std::path::PathBuf;
+use std::time::Duration;
+
 use clap::Parser;
 use console::style;
+use windows_service::Error;
+use windows_service::service::{
+    ServiceAccess, ServiceErrorControl, ServiceInfo, ServiceStartType, ServiceState, ServiceType,
+};
+use windows_service::service_manager::{ServiceManager, ServiceManagerAccess};
+
+use crate::config;
 
 pub mod service;
+mod windows_admin_check;
 
 #[derive(Parser, Debug)]
 #[command(
@@ -17,13 +30,13 @@ struct Args {
     /// Only devices with the same token can communicate with each other.
     /// It is recommended to use uuid to ensure uniqueness
     #[arg(long)]
-    token: String,
+    token: Option<String>,
     /// 给设备一个名称，为空时默认用系统版本信息
     #[arg(long)]
     name: Option<String>,
-    /// 安装服务，安装后可以后台运行
+    /// 安装服务，安装后可以后台运行，需要指定安装路径
     #[arg(long)]
-    install: bool,
+    install: Option<String>,
     /// 卸载服务
     #[arg(long)]
     uninstall: bool,
@@ -32,72 +45,165 @@ struct Args {
     #[arg(long)]
     start: bool,
     #[arg(long)]
-    /// 停止，安装服务后，使用--stop停止服务
+    /// 停止，安装服务后，使用 --stop停止服务
     stop: bool,
-
+    /// 启动服务后，使用 --list 查看设备列表
+    #[arg(long)]
+    list: bool,
+    /// 启动服务后，使用 --status 查看设备状态
+    #[arg(long)]
+    status: bool,
 }
 
-const SERVICE_FLAG: &'static str = "start_switch_service_";
-const SERVICE_NAME: &'static str = "switch-service";
+pub const SERVICE_FLAG: &'static str = "start_switch_service_";
+pub const SERVICE_NAME: &'static str = "switch-service";
+pub const SERVICE_TYPE: ServiceType = ServiceType::OWN_PROCESS;
 
 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())
+    if args.list || args.status {
+        match service_state() {
+            Ok(state) => {
+                if state == ServiceState::Running {
+                    let command_client = crate::command::client::CommandClient::new().unwrap();
+                    let out = if args.list {
+                        command_client.list().unwrap()
+                    } else if args.status {
+                        command_client.status().unwrap()
+                    } else {
+                        "".to_string()
+                    };
+                    println!("{}", out);
+                } else {
+                    println!("服务未启动")
+                }
+            }
+            Err(e) => {
+                println!("{:?}", e);
+            }
         }
-        pause();
         return;
     }
-    if args.uninstall {
+    if !windows_admin_check::is_app_elevated() {
+        println!("{}", style("请使用管理员权限运行").red());
+        return;
+    }
+    if let Some(path) = args.install {
+        let path: PathBuf = path.into();
+        if !path.exists() {
+            std::fs::create_dir_all(&path).unwrap();
+        }
+        if !path.is_dir() {
+            println!("参数必须为文件目录");
+        } else {
+            if let Err(e) = install(path) {
+                log::error!("{:?}", e);
+            } else {
+                println!("{}", style("安装成功").green())
+            }
+        }
+    } else if args.uninstall {
         if let Err(e) = uninstall() {
-            log::error!("{:?}",e);
-        }else{
-            println!("{}",style("卸载成功").green())
+            log::error!("{:?}", e);
+        } else {
+            println!("{}", style("卸载成功").green())
         }
-        pause();
-        return;
-    }
-    if args.start {
-        if let Err(e) = start() {
-            log::error!("{:?}",e);
-            // 在当前进程启动
+    } else if args.start {
+        match service_state() {
+            Ok(state) => {
+                if state == ServiceState::Stopped {
+                    if args.token.is_none() {
+                        println!("{}", style("需要参数 --token").red());
+                    } else {
+                        let token = args.token.clone().unwrap();
+                        config::save_config(config::ArgsConfig::new(
+                            token.clone(),
+                            args.name.clone(),
+                        ))
+                            .unwrap();
+                        match start() {
+                            Ok(_) => {
+                                //需要检查启动状态
+                                println!("{}", style("启动成功").green())
+                            }
+                            Err(e) => {
+                                match e {
+                                    Error::Winapi(ref e) => {
+                                        if let Some(code) = e.raw_os_error() {
+                                            if code == 1060 {
+                                                //指定的服务未安装。
+                                                println!(
+                                                    "{}",
+                                                    style("服务未安装，在当前进程启动").red()
+                                                );
+                                                crate::start(token, args.name);
+                                                return;
+                                            }
+                                        }
+                                    }
+                                    _ => {}
+                                }
+                                log::error!("{:?}", e);
+                            }
+                        }
+                    }
+                } else {
+                    println!("服务未停止");
+                }
+            }
+            Err(e) => {
+                println!("{:?}", e);
+            }
         }
-        pause();
+    } else if args.stop {
+        match stop() {
+            Ok(_) => {
+                println!("{}", style("停止成功").green())
+            }
+            Err(e) => {
+                log::error!("{:?}", e);
+            }
+        }
+    } else {
+        println!("使用参数 -h 查看帮助")
     }
+    pause();
 }
 
 fn pause() {
-    println!("按任意键退出...");
-    std::io::stdin().read_u8().unwrap();
+    println!("{}", style("按任意键退出...").green());
+    use console::Term;
+    let term = Term::stdout();
+    let _ = term.read_char().unwrap();
 }
 
-
-fn install() -> Result<(), windows_service::Error> {
-    use std::ffi::OsString;
-    use windows_service::{
-        service::{ServiceAccess, ServiceErrorControl, ServiceInfo, ServiceStartType, ServiceType},
-        service_manager::{ServiceManager, ServiceManagerAccess},
-    };
-
+fn install(path: PathBuf) -> Result<(), Error> {
     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 current_exe_path = std::env::current_exe().unwrap();
+    let service_path = path.join("switch-service.exe");
+    std::fs::copy(current_exe_path, service_path.as_path()).unwrap();
+    if let Err(e) = std::fs::copy("wintun.dll", path.join("wintun.dll").as_path()) {
+        if e.kind() == io::ErrorKind::NotFound {
+            println!("Not fount 'wintun.dll'. Please put 'wintun.dll' in the current directory");
+            std::process::exit(0);
+        } else {
+            panic!("{:?}", e)
+        }
+    }
+    let mut launch_arguments = Vec::new();
+    launch_arguments.push(OsString::from(SERVICE_FLAG));
+    launch_arguments.push(OsString::from(
+        dirs::home_dir().unwrap().join(".switch").to_str().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],
+        executable_path: service_path.into(),
+        launch_arguments,
         dependencies: vec![],
         account_name: None, // run as System
         account_password: None,
@@ -107,13 +213,7 @@ fn install() -> Result<(), windows_service::Error> {
     Ok(())
 }
 
-fn uninstall() -> Result<(), windows_service::Error> {
-    use std::{thread, time::Duration};
-    use windows_service::{
-        service::{ServiceAccess, ServiceState},
-        service_manager::{ServiceManager, ServiceManagerAccess},
-    };
-
+fn uninstall() -> Result<(), Error> {
     let manager_access = ServiceManagerAccess::CONNECT;
     let service_manager = ServiceManager::local_computer(None::<&str>, manager_access)?;
 
@@ -131,14 +231,27 @@ fn uninstall() -> Result<(), windows_service::Error> {
     Ok(())
 }
 
-fn start() -> Result<(), windows_service::Error> {
-    use std::env;
-    use windows_service::{
-        service::ServiceAccess,
-        service_manager::{ServiceManager, ServiceManagerAccess},
-    };
+fn start() -> Result<(), Error> {
     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(&[])
-}
+    service.start(&[""])
+}
+
+fn service_state() -> Result<ServiceState, Error> {
+    let manager_access = ServiceManagerAccess::CONNECT;
+    let service_manager = ServiceManager::local_computer(None::<&str>, manager_access)?;
+
+    let service_access = ServiceAccess::QUERY_STATUS;
+    let service = service_manager.open_service(SERVICE_NAME, service_access)?;
+    let service_status = service.query_status()?;
+    return Ok(service_status.current_state);
+}
+
+fn stop() -> Result<(), Error> {
+    let manager_access = ServiceManagerAccess::CONNECT;
+    let service_manager = ServiceManager::local_computer(None::<&str>, manager_access)?;
+    let service = service_manager.open_service(SERVICE_NAME, ServiceAccess::STOP)?;
+    service.stop()?;
+    Ok(())
+}

switch-desktop/src/windows/service.rs

@@ -2,12 +2,110 @@
 // extern crate windows_service;
 
 use std::ffi::OsString;
-use windows_service::{define_windows_service, service_dispatcher};
+use std::sync::Arc;
+use std::thread;
+use std::time::Duration;
+
+
+use windows_service::service::{
+    ServiceControl, ServiceControlAccept, ServiceExitCode, ServiceState, ServiceStatus,
+};
+use windows_service::service_control_handler::ServiceControlHandlerResult;
+use windows_service::{define_windows_service, service_control_handler, service_dispatcher};
+
+use switch::{Config, Switch};
+
+use crate::windows::config::read_config;
 
 define_windows_service!(ffi_service_main, switch_service_main);
-pub fn switch_service_main(arguments: Vec<OsString>) {
+pub fn switch_service_main(_arguments: Vec<OsString>) {
+    thread::spawn(|| match service_main() {
+        Ok(_) => {}
+        Err(e) => {
+            log::warn!("{:?}", e);
+        }
+    });
+}
 
+fn service_main() -> windows_service::Result<()> {
+    let parker = crossbeam::sync::Parker::new();
+    let un_parker = parker.unparker().clone();
+    let event_handler = move |control_event| -> ServiceControlHandlerResult {
+        match control_event {
+            // Notifies a service to report its current status information to the service
+            // control manager. Always return NoError even if not implemented.
+            ServiceControl::Interrogate => ServiceControlHandlerResult::NoError,
+
+            // Handle stop
+            ServiceControl::Stop => {
+                log::info!("handler 服务停止");
+                un_parker.unpark();
+                ServiceControlHandlerResult::NoError
+            }
+            _ => ServiceControlHandlerResult::NotImplemented,
+        }
+    };
+
+    // Register system service event handler.
+    // The returned status handle should be used to report service status changes to the system.
+    let status_handle =
+        service_control_handler::register(crate::windows::SERVICE_NAME, event_handler)?;
+
+    // Tell the system that service is running
+    status_handle.set_service_status(ServiceStatus {
+        service_type: crate::windows::SERVICE_TYPE,
+        current_state: ServiceState::Running,
+        controls_accepted: ServiceControlAccept::STOP,
+        exit_code: ServiceExitCode::Win32(0),
+        checkpoint: 0,
+        wait_hint: Duration::default(),
+        process_id: None,
+    })?;
+    if let Some(config) = read_config() {
+        let mac_address = mac_address::get_mac_address().unwrap().unwrap().to_string();
+        let un_parker = parker.unparker().clone();
+        match Config::new(config.token, mac_address, config.name, move || {
+            un_parker.unpark();
+        }) {
+            Ok(config) => match Switch::start(config) {
+                Ok(switch) => {
+                    log::info!("switch-service服务启动");
+                    let switch = Arc::new(switch);
+                    let command_server = crate::command::server::CommandServer::new();
+                    let switch1 = switch.clone();
+                    thread::spawn(move || {
+                        if let Err(e) = command_server.start(switch1) {
+                            log::warn!("{:?}", e);
+                        }
+                    });
+                    parker.park();
+                    switch.stop_async();
+                    thread::sleep(Duration::from_secs(1));
+                    log::info!("switch-service服务停止");
+                }
+                Err(e) => {
+                    log::error!("{:?}", e);
+                }
+            },
+            Err(e) => {
+                log::error!("{:?}", e);
+            }
+        };
+    } else {
+        log::info!("配置文件为空");
+    }
+    status_handle.set_service_status(ServiceStatus {
+        service_type: crate::windows::SERVICE_TYPE,
+        current_state: ServiceState::Stopped,
+        controls_accepted: ServiceControlAccept::empty(),
+        exit_code: ServiceExitCode::Win32(0),
+        checkpoint: 0,
+        wait_hint: Duration::default(),
+        process_id: None,
+    })
+}
+
+pub fn start() {
+    log::info!("以服务的方式启动");
+    service_dispatcher::start("switch-service", ffi_service_main).unwrap();
 }
-pub fn start(){
-   service_dispatcher::start("switch-service",ffi_service_main).unwrap();
-}