Merge 7dcc0ae70e into 4fc3ff8ce8

Adjust the error handling logic

Cargo.lock

@@ -1191,6 +1191,15 @@ dependencies = [
  "objc",
 ]
 
+[[package]]
+name = "codepage"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48f68d061bc2828ae826206326e61251aca94c1e4a5305cf52d9138639c918b4"
+dependencies = [
+ "encoding_rs",
+]
+
 [[package]]
 name = "color_quant"
 version = "1.1.0"
@@ -1866,6 +1875,7 @@ dependencies = [
  "serde",
  "serde_json",
  "serial_test",
+ "service-manager",
  "smoltcp",
  "socket2",
  "stun_codec",
@@ -2063,6 +2073,17 @@ dependencies = [
  "encoding_index_tests",
 ]
 
+[[package]]
+name = "encoding-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87b881ab2524b96a5ce932056c7482ba6152e2226fed3936b3e592adeb95ca6d"
+dependencies = [
+ "codepage",
+ "encoding_rs",
+ "windows-sys 0.52.0",
+]
+
 [[package]]
 name = "encoding_index_tests"
 version = "0.1.4"
@@ -6543,6 +6564,20 @@ dependencies = [
  "syn 1.0.109",
 ]
 
+[[package]]
+name = "service-manager"
+version = "0.7.1"
+source = "git+https://github.com/chipsenkbeil/service-manager-rs.git?branch=main#13dae5e8160f91fdc9834d847165cc5ce0a72fb3"
+dependencies = [
+ "cfg-if",
+ "dirs 4.0.0",
+ "encoding-utils",
+ "encoding_rs",
+ "plist",
+ "which",
+ "xml-rs",
+]
+
 [[package]]
 name = "servo_arc"
 version = "0.1.1"
@@ -9339,6 +9374,12 @@ dependencies = [
  "windows-sys 0.59.0",
 ]
 
+[[package]]
+name = "xml-rs"
+version = "0.8.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af4e2e2f7cba5a093896c1e150fbfe177d1883e7448200efb81d40b9d339ef26"
+
 [[package]]
 name = "yansi"
 version = "1.0.1"

easytier/Cargo.toml

@@ -181,6 +181,8 @@ sys-locale = "0.3"
 ringbuf = "0.4.5"
 async-ringbuf = "0.3.1"
 
+service-manager = {git = "https://github.com/chipsenkbeil/service-manager-rs.git", branch = "main"}
+
 [target.'cfg(any(target_os = "linux", target_os = "macos", target_os = "windows", target_os = "freebsd"))'.dependencies]
 machine-uid = "0.5.3"
 

easytier/src/common/constants.rs

@@ -25,6 +25,8 @@ define_global_var!(OSPF_UPDATE_MY_GLOBAL_FOREIGN_NETWORK_INTERVAL_SEC, u64, 10);
 
 pub const UDP_HOLE_PUNCH_CONNECTOR_SERVICE_ID: u32 = 2;
 
+pub const WIN_SERVICE_WORK_DIR_REG_KEY: &str = "SOFTWARE\\EasyTier\\Service\\WorkDir";
+
 pub const EASYTIER_VERSION: &str = git_version::git_version!(
     args = ["--abbrev=8", "--always", "--dirty=~"],
     prefix = concat!(env!("CARGO_PKG_VERSION"), "-"),

easytier/src/easytier-cli.rs

@@ -1,8 +1,11 @@
-use std::{net::SocketAddr, sync::Mutex, time::Duration, vec};
+use std::{
+    ffi::OsString, fmt::Write, net::SocketAddr, path::PathBuf, sync::Mutex, time::Duration, vec,
+};
 
 use anyhow::{Context, Ok};
 use clap::{command, Args, Parser, Subcommand};
 use humansize::format_size;
+use service_manager::*;
 use tabled::settings::Style;
 use tokio::time::timeout;
 
@@ -54,6 +57,7 @@ enum SubCommand {
     PeerCenter,
     VpnPortal,
     Node(NodeArgs),
+    Service(ServiceArgs),
 }
 
 #[derive(Args, Debug)]
@@ -120,6 +124,45 @@ struct NodeArgs {
     sub_command: Option<NodeSubCommand>,
 }
 
+#[derive(Args, Debug)]
+struct ServiceArgs {
+    #[arg(short, long, default_value = env!("CARGO_PKG_NAME"), help = "service name")]
+    name: String,
+
+    #[command(subcommand)]
+    sub_command: ServiceSubCommand,
+}
+
+#[derive(Subcommand, Debug)]
+enum ServiceSubCommand {
+    Install(InstallArgs),
+    Uninstall,
+    Status,
+    Start,
+    Stop,
+}
+
+#[derive(Args, Debug)]
+struct InstallArgs {
+    #[arg(long, default_value = env!("CARGO_PKG_DESCRIPTION"), help = "service description")]
+    description: String,
+
+    #[arg(long)]
+    display_name: Option<String>,
+
+    #[arg(long, default_value = "false")]
+    disable_autostart: bool,
+
+    #[arg(long)]
+    core_path: Option<PathBuf>,
+
+    #[arg(long)]
+    service_work_dir: Option<PathBuf>,
+
+    #[arg(trailing_var_arg = true, allow_hyphen_values = true)]
+    core_args: Option<Vec<OsString>>,
+}
+
 type Error = anyhow::Error;
 
 struct CommandHandler {
@@ -476,6 +519,257 @@ impl CommandHandler {
     }
 }
 
+pub struct ServiceInstallOptions {
+    pub program: PathBuf,
+    pub args: Vec<OsString>,
+    pub work_directory: PathBuf,
+    pub disable_autostart: bool,
+    pub description: Option<String>,
+    pub display_name: Option<String>,
+}
+pub struct Service {
+    lable: ServiceLabel,
+    kind: ServiceManagerKind,
+    service_manager: Box<dyn ServiceManager>,
+}
+
+impl Service {
+    pub fn new(name: String) -> Result<Self, Error> {
+        #[cfg(target_os = "windows")]
+        let service_manager = Box::new(crate::win_service_manager::WinServiceManager::new()?);
+
+        #[cfg(not(target_os = "windows"))]
+        let service_manager = <dyn ServiceManager>::native()?;
+        let kind = ServiceManagerKind::native()?;
+
+        Ok(Self {
+            lable: name.parse()?,
+            kind,
+            service_manager,
+        })
+    }
+
+    pub fn install(&self, options: &ServiceInstallOptions) -> Result<(), Error> {
+        let ctx = ServiceInstallCtx {
+            label: self.lable.clone(),
+            program: options.program.clone(),
+            args: options.args.clone(),
+            contents: self.make_install_content_option(options),
+            autostart: !options.disable_autostart,
+            username: None,
+            working_directory: Some(options.work_directory.clone()),
+            environment: None,
+        };
+        if self.status()? != ServiceStatus::NotInstalled {
+            return Err(anyhow::anyhow!("Service is already installed"));
+        }
+
+        self.service_manager
+            .install(ctx)
+            .map_err(|e| anyhow::anyhow!("failed to install service: {}", e))
+    }
+
+    pub fn uninstall(&self) -> Result<(), Error> {
+        let ctx = ServiceUninstallCtx {
+            label: self.lable.clone(),
+        };
+        let status = self.status()?;
+
+        if status == ServiceStatus::NotInstalled {
+            return Err(anyhow::anyhow!("Service is not installed"));
+        }
+
+        if status == ServiceStatus::Running {
+            self.service_manager.stop(ServiceStopCtx {
+                label: self.lable.clone(),
+            })?;
+        }
+
+        self.service_manager
+            .uninstall(ctx)
+            .map_err(|e| anyhow::anyhow!("failed to uninstall service: {}", e))
+    }
+
+    pub fn status(&self) -> Result<ServiceStatus, Error> {
+        let ctx = ServiceStatusCtx {
+            label: self.lable.clone(),
+        };
+        let status = self.service_manager.status(ctx)?;
+
+        Ok(status)
+    }
+
+    pub fn start(&self) -> Result<(), Error> {
+        let ctx = ServiceStartCtx {
+            label: self.lable.clone(),
+        };
+        let status = self.status()?;
+
+        match status {
+            ServiceStatus::Running => Err(anyhow::anyhow!("Service is already running")),
+            ServiceStatus::Stopped(_) => {
+                self.service_manager
+                    .start(ctx)
+                    .map_err(|e| anyhow::anyhow!("failed to start service: {}", e))?;
+                Ok(())
+            }
+            ServiceStatus::NotInstalled => Err(anyhow::anyhow!("Service is not installed")),
+        }
+    }
+
+    pub fn stop(&self) -> Result<(), Error> {
+        let ctx = ServiceStopCtx {
+            label: self.lable.clone(),
+        };
+        let status = self.status()?;
+
+        match status {
+            ServiceStatus::Running => {
+                self.service_manager
+                    .stop(ctx)
+                    .map_err(|e| anyhow::anyhow!("failed to stop service: {}", e))?;
+                Ok(())
+            }
+            ServiceStatus::Stopped(_) => Err(anyhow::anyhow!("Service is already stopped")),
+            ServiceStatus::NotInstalled => Err(anyhow::anyhow!("Service is not installed")),
+        }
+    }
+
+    fn make_install_content_option(&self, options: &ServiceInstallOptions) -> Option<String> {
+        match self.kind {
+            ServiceManagerKind::Systemd => Some(self.make_systemd_unit(options).unwrap()),
+            ServiceManagerKind::Rcd => Some(self.make_rcd_script(options).unwrap()),
+            ServiceManagerKind::OpenRc => Some(self.make_open_rc_script(options).unwrap()),
+            _ => {
+                #[cfg(target_os = "windows")]
+                {
+                    let win_options = win_service_manager::WinServiceInstallOptions {
+                        description: options.description.clone(),
+                        display_name: options.display_name.clone(),
+                        dependencies: Some(vec!["rpcss".to_string(), "dnscache".to_string()]),
+                    };
+
+                    Some(serde_json::to_string(&win_options).unwrap())
+                }
+
+                #[cfg(not(target_os = "windows"))]
+                None
+            }
+        }
+    }
+
+    fn make_systemd_unit(
+        &self,
+        options: &ServiceInstallOptions,
+    ) -> Result<String, std::fmt::Error> {
+        let args = options
+            .args
+            .iter()
+            .map(|a| a.to_string_lossy())
+            .collect::<Vec<_>>()
+            .join(" ");
+        let target_app = options.program.display().to_string();
+        let work_dir = options.work_directory.display().to_string();
+        let mut unit_content = String::new();
+
+        writeln!(unit_content, "[Unit]")?;
+        writeln!(unit_content, "After=network.target syslog.target")?;
+        if let Some(ref d) = options.description {
+            writeln!(unit_content, "Description={d}")?;
+        }
+        writeln!(unit_content, "StartLimitIntervalSec=0")?;
+        writeln!(unit_content)?;
+        writeln!(unit_content, "[Service]")?;
+        writeln!(unit_content, "Type=simple")?;
+        writeln!(unit_content, "WorkingDirectory={work_dir}")?;
+        writeln!(unit_content, "ExecStart={target_app} {args}")?;
+        writeln!(unit_content, "Restart=Always")?;
+        writeln!(unit_content, "LimitNOFILE=infinity")?;
+        writeln!(unit_content)?;
+        writeln!(unit_content, "[Install]")?;
+        writeln!(unit_content, "WantedBy=multi-user.target")?;
+
+        std::result::Result::Ok(unit_content)
+    }
+
+    fn make_rcd_script(&self, options: &ServiceInstallOptions) -> Result<String, std::fmt::Error> {
+        let name = self.lable.to_qualified_name();
+        let args = options
+            .args
+            .iter()
+            .map(|a| a.to_string_lossy())
+            .collect::<Vec<_>>()
+            .join(" ");
+        let target_app = options.program.display().to_string();
+        let work_dir = options.work_directory.display().to_string();
+        let mut script = String::new();
+
+        writeln!(script, "#!/bin/sh")?;
+        writeln!(script, "#")?;
+        writeln!(script, "# PROVIDE: {name}")?;
+        writeln!(script, "# REQUIRE: LOGIN FILESYSTEMS NETWORKING ")?;
+        writeln!(script, "# KEYWORD: shutdown")?;
+        writeln!(script)?;
+        writeln!(script, ". /etc/rc.subr")?;
+        writeln!(script)?;
+        writeln!(script, "name=\"{name}\"")?;
+        if let Some(ref d) = options.description {
+            writeln!(script, "desc=\"{d}\"")?;
+        }
+        writeln!(script, "rcvar=\"{name}_enable\"")?;
+        writeln!(script)?;
+        writeln!(script, "load_rc_config ${{name}}")?;
+        writeln!(script)?;
+        writeln!(script, ": ${{{name}_options=\"{args}\"}}")?;
+        writeln!(script)?;
+        writeln!(script, "{name}_chdir=\"{work_dir}\"")?;
+        writeln!(script, "pidfile=\"/var/run/${{name}}.pid\"")?;
+        writeln!(script, "procname=\"{target_app}\"")?;
+        writeln!(script, "command=\"/usr/sbin/daemon\"")?;
+        writeln!(
+            script,
+            "command_args=\"-c -S -T ${{name}} -p ${{pidfile}} ${{procname}} ${{{name}_options}}\""
+        )?;
+        writeln!(script)?;
+        writeln!(script, "run_rc_command \"$1\"")?;
+
+        std::result::Result::Ok(script)
+    }
+
+    fn make_open_rc_script(
+        &self,
+        options: &ServiceInstallOptions,
+    ) -> Result<String, std::fmt::Error> {
+        let args = options
+            .args
+            .iter()
+            .map(|a| a.to_string_lossy())
+            .collect::<Vec<_>>()
+            .join(" ");
+        let target_app = options.program.display().to_string();
+        let work_dir = options.work_directory.display().to_string();
+        let mut script = String::new();
+
+        writeln!(script, "#!/sbin/openrc-run")?;
+        writeln!(script)?;
+        if let Some(ref d) = options.description {
+            writeln!(script, "description=\"{d}\"")?;
+        }
+        writeln!(script, "command=\"{target_app}\"")?;
+        writeln!(script, "command_args=\"{args}\"")?;
+        writeln!(script, "pidfile=\"/run/${{RC_SVCNAME}}.pid\"")?;
+        writeln!(script, "command_background=\"yes\"")?;
+        writeln!(script, "directory=\"{work_dir}\"")?;
+        writeln!(script)?;
+        writeln!(script, "depend() {{")?;
+        writeln!(script, "    need net")?;
+        writeln!(script, "    use looger")?;
+        writeln!(script, "}}")?;
+
+        std::result::Result::Ok(script)
+    }
+}
+
 #[tokio::main]
 #[tracing::instrument]
 async fn main() -> Result<(), Error> {
@@ -638,7 +932,265 @@ async fn main() -> Result<(), Error> {
                 }
             }
         }
+        SubCommand::Service(service_args) => {
+            let service = Service::new(service_args.name)?;
+            match service_args.sub_command {
+                ServiceSubCommand::Install(install_args) => {
+                    let bin_path = install_args.core_path.unwrap_or_else(|| {
+                        let mut ret = std::env::current_exe()
+                            .unwrap()
+                            .parent()
+                            .unwrap()
+                            .join("easytier-core");
+
+                        if cfg!(target_os = "windows") {
+                            ret.set_extension("exe");
+                        }
+
+                        ret
+                    });
+                    let bin_path = std::fs::canonicalize(bin_path).map_err(|e| {
+                        anyhow::anyhow!("failed to get easytier core application: {}", e)
+                    })?;
+                    let bin_args = install_args.core_args.unwrap_or_default();
+                    let work_dir = install_args.service_work_dir.unwrap_or_else(|| {
+                        if cfg!(target_os = "windows") {
+                            bin_path.parent().unwrap().to_path_buf()
+                        } else {
+                            std::env::temp_dir()
+                        }
+                    });
+
+                    let work_dir = std::fs::canonicalize(&work_dir).map_err(|e| {
+                        anyhow::anyhow!(
+                            "failed to get service work directory[{}]: {}",
+                            work_dir.display(),
+                            e
+                        )
+                    })?;
+
+                    if !work_dir.is_dir() {
+                        return Err(anyhow::anyhow!("work directory is not a directory"));
+                    }
+
+                    let install_options = ServiceInstallOptions {
+                        program: bin_path,
+                        args: bin_args,
+                        work_directory: work_dir,
+                        disable_autostart: install_args.disable_autostart,
+                        description: Some(install_args.description),
+                        display_name: install_args.display_name,
+                    };
+                    service.install(&install_options)?;
+                }
+                ServiceSubCommand::Uninstall => {
+                    service.uninstall()?;
+                }
+                ServiceSubCommand::Status => {
+                    let status = service.status()?;
+                    match status {
+                        ServiceStatus::Running => println!("Service is running"),
+                        ServiceStatus::Stopped(_) => println!("Service is stopped"),
+                        ServiceStatus::NotInstalled => println!("Service is not installed"),
+                    }
+                }
+                ServiceSubCommand::Start => {
+                    service.start()?;
+                }
+                ServiceSubCommand::Stop => {
+                    service.stop()?;
+                }
+            }
+        }
     }
 
     Ok(())
 }
+
+#[cfg(target_os = "windows")]
+mod win_service_manager {
+    use std::{ffi::OsStr, ffi::OsString, io, path::PathBuf};
+    use windows_service::{
+        service::{
+            ServiceAccess, ServiceDependency, ServiceErrorControl, ServiceInfo, ServiceStartType,
+            ServiceType,
+        },
+        service_manager::{ServiceManager, ServiceManagerAccess},
+    };
+
+    use service_manager::{
+        ServiceInstallCtx, ServiceLevel, ServiceStartCtx, ServiceStatus, ServiceStatusCtx,
+        ServiceStopCtx, ServiceUninstallCtx,
+    };
+
+    use winreg::{enums::*, RegKey};
+
+    use easytier::common::constants::WIN_SERVICE_WORK_DIR_REG_KEY;
+
+    use serde::{Deserialize, Serialize};
+
+    #[derive(Serialize, Deserialize)]
+    pub struct WinServiceInstallOptions {
+        pub dependencies: Option<Vec<String>>,
+        pub description: Option<String>,
+        pub display_name: Option<String>,
+    }
+
+    pub struct WinServiceManager {
+        service_manager: ServiceManager,
+    }
+
+    impl WinServiceManager {
+        pub fn new() -> Result<Self, crate::Error> {
+            let service_manager =
+                ServiceManager::local_computer(None::<&str>, ServiceManagerAccess::ALL_ACCESS)?;
+            Ok(Self { service_manager })
+        }
+    }
+    impl service_manager::ServiceManager for WinServiceManager {
+        fn available(&self) -> io::Result<bool> {
+            Ok(true)
+        }
+
+        fn install(&self, ctx: ServiceInstallCtx) -> io::Result<()> {
+            let start_type_ = if ctx.autostart {
+                ServiceStartType::AutoStart
+            } else {
+                ServiceStartType::OnDemand
+            };
+            let srv_name = OsString::from(ctx.label.to_qualified_name());
+            let mut dis_name = srv_name.clone();
+            let mut description: Option<OsString> = None;
+            let mut dependencies = Vec::<ServiceDependency>::new();
+
+            if let Some(s) = ctx.contents.as_ref() {
+                let options: WinServiceInstallOptions = serde_json::from_str(s.as_str()).unwrap();
+                if let Some(d) = options.dependencies {
+                    dependencies = d
+                        .iter()
+                        .map(|dep| ServiceDependency::Service(OsString::from(dep.clone())))
+                        .collect::<Vec<_>>();
+                }
+                if let Some(d) = options.description {
+                    description = Some(OsString::from(d));
+                }
+                if let Some(d) = options.display_name {
+                    dis_name = OsString::from(d);
+                }
+            }
+
+            let service_info = ServiceInfo {
+                name: srv_name,
+                display_name: dis_name,
+                service_type: ServiceType::OWN_PROCESS,
+                start_type: start_type_,
+                error_control: ServiceErrorControl::Normal,
+                executable_path: ctx.program,
+                launch_arguments: ctx.args,
+                dependencies: dependencies.clone(),
+                account_name: None,
+                account_password: None,
+            };
+
+            let service = self
+                .service_manager
+                .create_service(&service_info, ServiceAccess::ALL_ACCESS)
+                .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+
+            if let Some(s) = description {
+                service
+                    .set_description(s.clone())
+                    .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+            }
+
+            if let Some(work_dir) = ctx.working_directory {
+                set_service_work_directory(&ctx.label.to_qualified_name(), work_dir)?;
+            }
+
+            Ok(())
+        }
+
+        fn uninstall(&self, ctx: ServiceUninstallCtx) -> io::Result<()> {
+            let service = self
+                .service_manager
+                .open_service(ctx.label.to_qualified_name(), ServiceAccess::ALL_ACCESS)
+                .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+
+            service
+                .delete()
+                .map_err(|e| io::Error::new(io::ErrorKind::Other, e))
+        }
+
+        fn start(&self, ctx: ServiceStartCtx) -> io::Result<()> {
+            let service = self
+                .service_manager
+                .open_service(ctx.label.to_qualified_name(), ServiceAccess::ALL_ACCESS)
+                .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+
+            service
+                .start(&[] as &[&OsStr])
+                .map_err(|e| io::Error::new(io::ErrorKind::Other, e))
+        }
+
+        fn stop(&self, ctx: ServiceStopCtx) -> io::Result<()> {
+            let service = self
+                .service_manager
+                .open_service(ctx.label.to_qualified_name(), ServiceAccess::ALL_ACCESS)
+                .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+
+            _ = service
+                .stop()
+                .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+
+            Ok(())
+        }
+
+        fn level(&self) -> ServiceLevel {
+            ServiceLevel::System
+        }
+
+        fn set_level(&mut self, level: ServiceLevel) -> io::Result<()> {
+            match level {
+                ServiceLevel::System => Ok(()),
+                _ => Err(io::Error::new(
+                    io::ErrorKind::Other,
+                    "Unsupported service level",
+                )),
+            }
+        }
+
+        fn status(&self, ctx: ServiceStatusCtx) -> io::Result<ServiceStatus> {
+            let service = match self
+                .service_manager
+                .open_service(ctx.label.to_qualified_name(), ServiceAccess::QUERY_STATUS)
+            {
+                Ok(s) => s,
+                Err(e) => {
+                    if let windows_service::Error::Winapi(ref win_err) = e {
+                        if win_err.raw_os_error() == Some(0x424) {
+                            return Ok(ServiceStatus::NotInstalled);
+                        }
+                    }
+                    return Err(io::Error::new(io::ErrorKind::Other, e));
+                }
+            };
+
+            let status = service
+                .query_status()
+                .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+
+            match status.current_state {
+                windows_service::service::ServiceState::Stopped => Ok(ServiceStatus::Stopped(None)),
+                _ => Ok(ServiceStatus::Running),
+            }
+        }
+    }
+
+    fn set_service_work_directory(service_name: &str, work_directory: PathBuf) -> io::Result<()> {
+        let (reg_key, _) =
+            RegKey::predef(HKEY_LOCAL_MACHINE).create_subkey(WIN_SERVICE_WORK_DIR_REG_KEY)?;
+        reg_key
+            .set_value::<OsString, _>(service_name, &work_directory.as_os_str().to_os_string())?;
+        Ok(())
+    }
+}

easytier/src/easytier-core.rs

@@ -294,11 +294,11 @@ struct Cli {
 rust_i18n::i18n!("locales", fallback = "en");
 
 impl Cli {
-    fn parse_listeners(no_listener: bool, listeners: Vec<String>) -> Vec<String> {
+    fn parse_listeners(no_listener: bool, listeners: Vec<String>) -> anyhow::Result<Vec<String>> {
         let proto_port_offset = vec![("tcp", 0), ("udp", 0), ("wg", 1), ("ws", 1), ("wss", 2)];
 
         if no_listener || listeners.is_empty() {
-            return vec![];
+            return Ok(vec![]);
         }
 
         let origin_listners = listeners;
@@ -308,7 +308,7 @@ impl Cli {
                 for (proto, offset) in proto_port_offset {
                     listeners.push(format!("{}://0.0.0.0:{}", proto, port + offset));
                 }
-                return listeners;
+                return Ok(listeners);
             }
         }
 
@@ -325,7 +325,7 @@ impl Cli {
                     .iter()
                     .find(|(proto, _)| *proto == proto_port[0])
                 else {
-                    panic!("unknown protocol: {}", proto_port[0]);
+                    return Err(anyhow::anyhow!("unknown protocol: {}", proto_port[0]));
                 };
 
                 let port = if proto_port.len() == 2 {
@@ -338,7 +338,7 @@ impl Cli {
             }
         }
 
-        listeners
+        Ok(listeners)
     }
 
     fn check_tcp_available(port: u16) -> Option<SocketAddr> {
@@ -346,66 +346,66 @@ impl Cli {
         TcpSocket::new_v4().unwrap().bind(s).map(|_| s).ok()
     }
 
-    fn parse_rpc_portal(rpc_portal: String) -> SocketAddr {
+    fn parse_rpc_portal(rpc_portal: String) -> anyhow::Result<SocketAddr> {
         if let Ok(port) = rpc_portal.parse::<u16>() {
             if port == 0 {
                 // check tcp 15888 first
                 for i in 15888..15900 {
                     if let Some(s) = Cli::check_tcp_available(i) {
-                        return s;
+                        return Ok(s);
                     }
                 }
-                return "0.0.0.0:0".parse().unwrap();
+                return Ok("0.0.0.0:0".parse().unwrap());
             }
-            return format!("0.0.0.0:{}", port).parse().unwrap();
+            return Ok(format!("0.0.0.0:{}", port).parse().unwrap());
         }
 
-        rpc_portal.parse().unwrap()
+        Ok(rpc_portal.parse()?)
     }
 }
 
-impl From<Cli> for TomlConfigLoader {
+impl TryFrom<&Cli> for TomlConfigLoader {
-    fn from(cli: Cli) -> Self {
+    type Error = anyhow::Error;
+
+    fn try_from(cli: &Cli) -> Result<Self, Self::Error> {
         if let Some(config_file) = &cli.config_file {
             println!(
                 "NOTICE: loading config file: {:?}, will ignore all command line flags\n",
                 config_file
             );
-            return TomlConfigLoader::new(config_file)
+            return Ok(TomlConfigLoader::new(config_file)
-                .with_context(|| format!("failed to load config file: {:?}", cli.config_file))
+                .with_context(|| format!("failed to load config file: {:?}", cli.config_file))?);
-                .unwrap();
         }
 
         let cfg = TomlConfigLoader::default();
 
-        cfg.set_hostname(cli.hostname);
+        cfg.set_hostname(cli.hostname.clone());
 
-        cfg.set_network_identity(NetworkIdentity::new(cli.network_name, cli.network_secret));
+        cfg.set_network_identity(NetworkIdentity::new(
+            cli.network_name.clone(),
+            cli.network_secret.clone(),
+        ));
 
         cfg.set_dhcp(cli.dhcp);
 
         if let Some(ipv4) = &cli.ipv4 {
-            cfg.set_ipv4(Some(
+            cfg.set_ipv4(Some(ipv4.parse().with_context(|| {
-                ipv4.parse()
+                format!("failed to parse ipv4 address: {}", ipv4)
-                    .with_context(|| format!("failed to parse ipv4 address: {}", ipv4))
+            })?))
-                    .unwrap(),
-            ))
         }
 
-        cfg.set_peers(
+        let mut peers = Vec::<PeerConfig>::with_capacity(cli.peers.len());
-            cli.peers
+        for p in &cli.peers {
-                .iter()
+            peers.push(PeerConfig {
-                .map(|s| PeerConfig {
+                uri: p
-                    uri: s
                     .parse()
-                        .with_context(|| format!("failed to parse peer uri: {}", s))
+                    .with_context(|| format!("failed to parse peer uri: {}", p))?,
-                        .unwrap(),
+            });
-                })
+        }
-                .collect(),
+        cfg.set_peers(peers);
-        );
 
         cfg.set_listeners(
-            Cli::parse_listeners(cli.no_listener, cli.listeners)
+            Cli::parse_listeners(cli.no_listener, cli.listeners.clone())?
                 .into_iter()
                 .map(|s| s.parse().unwrap())
                 .collect(),
@@ -414,29 +414,28 @@ impl From<Cli> for TomlConfigLoader {
         for n in cli.proxy_networks.iter() {
             cfg.add_proxy_cidr(
                 n.parse()
-                    .with_context(|| format!("failed to parse proxy network: {}", n))
+                    .with_context(|| format!("failed to parse proxy network: {}", n))?,
-                    .unwrap(),
             );
         }
 
-        cfg.set_rpc_portal(Cli::parse_rpc_portal(cli.rpc_portal));
+        cfg.set_rpc_portal(
+            Cli::parse_rpc_portal(cli.rpc_portal.clone())
+                .with_context(|| format!("failed to parse rpc portal: {}", cli.rpc_portal))?,
+        );
 
-        if let Some(external_nodes) = cli.external_node {
+        if let Some(external_nodes) = cli.external_node.as_ref() {
             let mut old_peers = cfg.get_peers();
             old_peers.push(PeerConfig {
-                uri: external_nodes
+                uri: external_nodes.parse().with_context(|| {
-                    .parse()
-                    .with_context(|| {
                     format!("failed to parse external node uri: {}", external_nodes)
-                    })
+                })?,
-                    .unwrap(),
             });
             cfg.set_peers(old_peers);
         }
 
         if cli.console_log_level.is_some() {
             cfg.set_console_logger_config(ConsoleLoggerConfig {
-                level: cli.console_log_level,
+                level: cli.console_log_level.clone(),
             });
         }
 
@@ -448,43 +447,37 @@ impl From<Cli> for TomlConfigLoader {
             });
         }
 
-        cfg.set_inst_name(cli.instance_name);
+        cfg.set_inst_name(cli.instance_name.clone());
 
-        if let Some(vpn_portal) = cli.vpn_portal {
+        if let Some(vpn_portal) = cli.vpn_portal.as_ref() {
             let url: url::Url = vpn_portal
                 .parse()
-                .with_context(|| format!("failed to parse vpn portal url: {}", vpn_portal))
+                .with_context(|| format!("failed to parse vpn portal url: {}", vpn_portal))?;
-                .unwrap();
+            let host = url
-            cfg.set_vpn_portal_config(VpnPortalConfig {
+                .host_str()
-                client_cidr: url.path()[1..]
+                .ok_or_else(|| anyhow::anyhow!("vpn portal url missing host"))?;
-                    .parse()
+            let port = url
-                    .with_context(|| {
+                .port()
+                .ok_or_else(|| anyhow::anyhow!("vpn portal url missing port"))?;
+            let client_cidr = url.path()[1..].parse().with_context(|| {
                 format!("failed to parse vpn portal client cidr: {}", url.path())
-                    })
+            })?;
-                    .unwrap(),
+            let wireguard_listen: SocketAddr = format!("{}:{}", host, port).parse().unwrap();
-                wireguard_listen: format!("{}:{}", url.host_str().unwrap(), url.port().unwrap())
+            cfg.set_vpn_portal_config(VpnPortalConfig {
-                    .parse()
+                wireguard_listen,
-                    .with_context(|| {
+                client_cidr,
-                        format!(
-                            "failed to parse vpn portal wireguard listen address: {}",
-                            url.host_str().unwrap()
-                        )
-                    })
-                    .unwrap(),
             });
         }
 
-        if let Some(manual_routes) = cli.manual_routes {
+        if let Some(manual_routes) = cli.manual_routes.as_ref() {
-            cfg.set_routes(Some(
+            let mut routes = Vec::<cidr::Ipv4Cidr>::with_capacity(manual_routes.len());
-                manual_routes
+            for r in manual_routes {
-                    .iter()
+                routes.push(
-                    .map(|s| {
+                    r.parse()
-                        s.parse()
+                        .with_context(|| format!("failed to parse route: {}", r))?,
-                            .with_context(|| format!("failed to parse route: {}", s))
+                );
-                            .unwrap()
+            }
-                    })
+            cfg.set_routes(Some(routes));
-                    .collect(),
-            ));
         }
 
         #[cfg(feature = "socks5")]
@@ -503,30 +496,29 @@ impl From<Cli> for TomlConfigLoader {
         f.enable_encryption = !cli.disable_encryption;
         f.enable_ipv6 = !cli.disable_ipv6;
         f.latency_first = cli.latency_first;
-        f.dev_name = cli.dev_name.unwrap_or_default();
+        f.dev_name = cli.dev_name.clone().unwrap_or_default();
         if let Some(mtu) = cli.mtu {
             f.mtu = mtu as u32;
         }
         f.enable_exit_node = cli.enable_exit_node;
         f.no_tun = cli.no_tun || cfg!(not(feature = "tun"));
         f.use_smoltcp = cli.use_smoltcp;
-        if let Some(wl) = cli.relay_network_whitelist {
+        if let Some(wl) = cli.relay_network_whitelist.as_ref() {
             f.foreign_network_whitelist = wl.join(" ");
         }
         f.disable_p2p = cli.disable_p2p;
         f.relay_all_peer_rpc = cli.relay_all_peer_rpc;
-        if let Some(ipv6_listener) = cli.ipv6_listener {
+        if let Some(ipv6_listener) = cli.ipv6_listener.as_ref() {
             f.ipv6_listener = ipv6_listener
                 .parse()
-                .with_context(|| format!("failed to parse ipv6 listener: {}", ipv6_listener))
+                .with_context(|| format!("failed to parse ipv6 listener: {}", ipv6_listener))?
-                .unwrap();
         }
         f.multi_thread = cli.multi_thread;
         cfg.set_flags(f);
 
         cfg.set_exit_nodes(cli.exit_nodes.clone());
 
-        cfg
+        Ok(cfg)
     }
 }
 
@@ -652,44 +644,69 @@ pub fn handle_event(mut events: EventBusSubscriber) -> tokio::task::JoinHandle<(
     })
 }
 
+#[cfg(target_os = "windows")]
+fn win_service_set_work_dir(service_name: &std::ffi::OsString) -> anyhow::Result<()> {
+    use easytier::common::constants::WIN_SERVICE_WORK_DIR_REG_KEY;
+    use winreg::enums::*;
+    use winreg::RegKey;
+
+    let hklm = RegKey::predef(HKEY_LOCAL_MACHINE);
+    let key = hklm.open_subkey_with_flags(WIN_SERVICE_WORK_DIR_REG_KEY, KEY_READ)?;
+    let dir_pat_str = key.get_value::<std::ffi::OsString, _>(service_name)?;
+    let dir_path = std::fs::canonicalize(dir_pat_str)?;
+
+    std::env::set_current_dir(dir_path)?;
+
+    Ok(())
+}
+
 #[cfg(target_os = "windows")]
 fn win_service_event_loop(
     stop_notify: std::sync::Arc<tokio::sync::Notify>,
-    inst: launcher::NetworkInstance,
+    cli: Cli,
     status_handle: windows_service::service_control_handler::ServiceStatusHandle,
 ) {
     use std::time::Duration;
     use tokio::runtime::Runtime;
     use windows_service::service::*;
 
+    let normal_status = ServiceStatus {
+        service_type: ServiceType::OWN_PROCESS,
+        current_state: ServiceState::Running,
+        controls_accepted: ServiceControlAccept::STOP,
+        exit_code: ServiceExitCode::Win32(0),
+        checkpoint: 0,
+        wait_hint: Duration::default(),
+        process_id: None,
+    };
+    let error_status = ServiceStatus {
+        service_type: ServiceType::OWN_PROCESS,
+        current_state: ServiceState::Stopped,
+        controls_accepted: ServiceControlAccept::empty(),
+        exit_code: ServiceExitCode::ServiceSpecific(1u32),
+        checkpoint: 0,
+        wait_hint: Duration::default(),
+        process_id: None,
+    };
+
     std::thread::spawn(move || {
         let rt = Runtime::new().unwrap();
         rt.block_on(async move {
             tokio::select! {
-                res = inst.wait() => {
+                res = run_main(cli) => {
-                    if let Some(e) = res {
+                    match res {
-                        status_handle.set_service_status(ServiceStatus {
+                        Ok(_) => {
-                            service_type: ServiceType::OWN_PROCESS,
+                            status_handle.set_service_status(normal_status).unwrap();
-                            current_state: ServiceState::Stopped,
+                            std::process::exit(0);
-                            controls_accepted: ServiceControlAccept::empty(),
+                        }
-                            checkpoint: 0,
+                        Err(e) => {
-                            wait_hint: Duration::default(),
+                            status_handle.set_service_status(error_status).unwrap();
-                            exit_code: ServiceExitCode::ServiceSpecific(1u32),
+                            eprintln!("error: {}", e);
-                            process_id: None
+                        }
-                        }).unwrap();
-                        panic!("launcher error: {:?}", e);
                     }
                 },
                 _ = stop_notify.notified() => {
-                    status_handle.set_service_status(ServiceStatus {
+                    _ = status_handle.set_service_status(normal_status);
-                        service_type: ServiceType::OWN_PROCESS,
-                        current_state: ServiceState::Stopped,
-                        controls_accepted: ServiceControlAccept::empty(),
-                        checkpoint: 0,
-                        wait_hint: Duration::default(),
-                        exit_code: ServiceExitCode::Win32(0),
-                        process_id: None
-                    }).unwrap();
                     std::process::exit(0);
                 }
             }
@@ -698,17 +715,16 @@ fn win_service_event_loop(
 }
 
 #[cfg(target_os = "windows")]
-fn win_service_main(_: Vec<std::ffi::OsString>) {
+fn win_service_main(arg: Vec<std::ffi::OsString>) {
     use std::sync::Arc;
     use std::time::Duration;
     use tokio::sync::Notify;
     use windows_service::service::*;
     use windows_service::service_control_handler::*;
 
-    let cli = Cli::parse();
+    _ = win_service_set_work_dir(&arg[0]);
-    let cfg = TomlConfigLoader::from(cli);
 
-    init_logger(&cfg, false).unwrap();
+    let cli = Cli::parse();
 
     let stop_notify_send = Arc::new(Notify::new());
     let stop_notify_recv = Arc::clone(&stop_notify_send);
@@ -732,39 +748,16 @@ fn win_service_main(_: Vec<std::ffi::OsString>) {
         wait_hint: Duration::default(),
         process_id: None,
     };
-    let mut inst = launcher::NetworkInstance::new(cfg).set_fetch_node_info(false);
-
-    inst.start().unwrap();
     status_handle
         .set_service_status(next_status)
         .expect("set service status fail");
-    win_service_event_loop(stop_notify_recv, inst, status_handle);
+
+    win_service_event_loop(stop_notify_recv, cli, status_handle);
 }
 
-#[tokio::main]
+async fn run_main(cli: Cli) -> anyhow::Result<()> {
-async fn main() {
+    let cfg = TomlConfigLoader::try_from(&cli)?;
-    let locale = sys_locale::get_locale().unwrap_or_else(|| String::from("en-US"));
+    init_logger(&cfg, false)?;
-    rust_i18n::set_locale(&locale);
-
-    #[cfg(target_os = "windows")]
-    match windows_service::service_dispatcher::start(String::new(), ffi_service_main) {
-        Ok(_) => std::thread::park(),
-        Err(e) => {
-            let should_panic = if let windows_service::Error::Winapi(ref io_error) = e {
-                io_error.raw_os_error() != Some(0x427) // ERROR_FAILED_SERVICE_CONTROLLER_CONNECT
-            } else {
-                true
-            };
-
-            if should_panic {
-                panic!("SCM start an error: {}", e);
-            }
-        }
-    };
-
-    let cli = Cli::parse();
-
-    setup_panic_handler();
 
     if cli.config_server.is_some() {
         let config_server_url_s = cli.config_server.clone().unwrap();
@@ -797,12 +790,9 @@ async fn main() {
 
         let _wc = web_client::WebClient::new(UdpTunnelConnector::new(c_url), token.to_string());
         tokio::signal::ctrl_c().await.unwrap();
-        return;
+        return Ok(());
     }
 
-    let cfg = TomlConfigLoader::from(cli);
-    init_logger(&cfg, false).unwrap();
-
     println!("Starting easytier with config:");
     println!("############### TOML ###############\n");
     println!("{}", cfg.dump());
@@ -811,6 +801,37 @@ async fn main() {
     let mut l = launcher::NetworkInstance::new(cfg).set_fetch_node_info(false);
     let _t = ScopedTask::from(handle_event(l.start().unwrap()));
     if let Some(e) = l.wait().await {
-        panic!("launcher error: {:?}", e);
+        anyhow::bail!("launcher error: {}", e);
+    }
+    Ok(())
+}
+
+#[tokio::main]
+async fn main() {
+    let locale = sys_locale::get_locale().unwrap_or_else(|| String::from("en-US"));
+    rust_i18n::set_locale(&locale);
+    setup_panic_handler();
+
+    #[cfg(target_os = "windows")]
+    match windows_service::service_dispatcher::start(String::new(), ffi_service_main) {
+        Ok(_) => std::thread::park(),
+        Err(e) => {
+            let should_panic = if let windows_service::Error::Winapi(ref io_error) = e {
+                io_error.raw_os_error() != Some(0x427) // ERROR_FAILED_SERVICE_CONTROLLER_CONNECT
+            } else {
+                true
+            };
+
+            if should_panic {
+                panic!("SCM start an error: {}", e);
+            }
+        }
+    };
+
+    let cli = Cli::parse();
+
+    if let Err(e) = run_main(cli).await {
+        eprintln!("error: {:?}", e);
+        std::process::exit(1);
     }
 }