支持点对网

switch-desktop/src/windows/service.rs

@@ -5,6 +5,7 @@ use std::ffi::OsString;
 use std::sync::Arc;
 use std::thread;
 use std::time::Duration;
+use clap::Parser;
 
 use windows_service::{define_windows_service, service_control_handler, service_dispatcher};
 use windows_service::service::{
@@ -14,27 +15,36 @@ use windows_service::service_control_handler::ServiceControlHandlerResult;
 
 use switch::core::{Config, Switch};
 
-use crate::{config, StartArgs};
+use crate::{BaseArgs, Commands, config, StartArgs};
 use crate::windows::SERVICE_NAME;
 
 define_windows_service!(ffi_service_main, switch_service_main);
 pub fn switch_service_main(arguments: Vec<OsString>) {
-    if !arguments.is_empty() {
-        if let Some(str) = arguments[0].to_str() {
-            if str == "log" {
+    let base_args = BaseArgs::parse_from(arguments);
+    match base_args.command {
+        Commands::Start(args) => {
+            if args.log {
                 let _ = config::log_config::log_service_init();
             }
+            tokio::runtime::Builder::new_multi_thread()
+                .enable_all()
+                .build()
+                .unwrap()
+                .block_on(async {
+                    match service_main(args).await {
+                        Ok(_) => {}
+                        Err(e) => {
+                            log::error!("启动服务失败：{:?}",e);
+                        }
+                    }
+                })
         }
+        _ => {}
     }
-    thread::spawn(|| match service_main() {
-        Ok(_) => {}
-        Err(e) => {
-            log::error!("{:?}", e);
-        }
-    });
 }
 
-fn service_main() -> windows_service::Result<()> {
+async fn service_main(args: StartArgs) -> windows_service::Result<()> {
+    log::error!("service_main：{:?}",args);
     let parker = crossbeam::sync::Parker::new();
     let un_parker = parker.unparker().clone();
     let event_handler = move |control_event| -> ServiceControlHandlerResult {
@@ -68,7 +78,7 @@ fn service_main() -> windows_service::Result<()> {
         wait_hint: Duration::default(),
         process_id: None,
     })?;
-    match start_switch() {
+    match start_switch(args).await {
         Ok(switch) => {
             parker.park();
             if let Err(e) = switch.stop() {
@@ -90,36 +100,52 @@ fn service_main() -> windows_service::Result<()> {
     })
 }
 
-fn start_switch() -> switch::Result<Arc<Switch>> {
-    match config::default_config(StartArgs::default()) {
-        Ok(start_config) => {
-            let config = Config::new(
-                start_config.tap,
-                start_config.token,
-                start_config.device_id,
-                start_config.name,
-                start_config.server,
-                start_config.nat_test_server,
-            );
-            let switch = Switch::start(config)?;
-            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) = config::update_pid(std::process::id()) {
-                    log::error!("{:?}", e);
-                }
-                if let Err(e) = command_server.start(switch1) {
-                    log::error!("{:?}", e);
-                }
-            });
-            Ok(switch)
+async fn start_switch(args: StartArgs) -> switch::Result<Arc<Switch>> {
+    let start_config = if let Some(config_path) = &args.config {
+        match config::read_config_file(config_path.into()) {
+            Ok(start_config) => {
+                start_config
+            }
+            Err(e) => {
+                log::error!("{:?}", e);
+                return Err(switch::error::Error::Stop(e));
+            }
         }
-        Err(e) => {
-            return Err(switch::error::Error::Stop(e));
+    } else {
+        match config::default_config(args) {
+            Ok(start_config) => {
+                start_config
+            }
+            Err(e) => {
+                log::error!("{:?}", e);
+                return Err(switch::error::Error::Stop(e));
+            }
         }
-    }
+    };
+    let config = Config::new(
+        start_config.tap,
+        start_config.token,
+        start_config.device_id,
+        start_config.name,
+        start_config.server,
+        start_config.nat_test_server,
+        start_config.in_ips,
+        start_config.out_ips,
+    );
+    let switch = Switch::start(config).await?;
+    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) = config::update_pid(std::process::id()) {
+            log::error!("{:?}", e);
+        }
+        if let Err(e) = command_server.start(switch1) {
+            log::error!("{:?}", e);
+        }
+    });
+    Ok(switch)
 }
 
 pub fn start() {