clash-verge-rev/src-tauri/src/core/sysopt.rs

use crate::{data::*, log_if_err};
use anyhow::{anyhow, bail, Result};
use auto_launch::{AutoLaunch, AutoLaunchBuilder};
use std::sync::Arc;
use sysproxy::Sysproxy;
use tauri::{async_runtime::Mutex, utils::platform::current_exe};

pub struct Sysopt {
    /// current system proxy setting
    cur_sysproxy: Option<Sysproxy>,

    /// record the original system proxy
    /// recover it when exit
    old_sysproxy: Option<Sysproxy>,

    /// helps to auto launch the app
    auto_launch: Option<AutoLaunch>,

    /// record whether the guard async is running or not
    guard_state: Arc<Mutex<bool>>,
}

#[cfg(target_os = "windows")]
static DEFAULT_BYPASS: &str = "localhost;127.*;192.168.*;<local>";
#[cfg(target_os = "linux")]
static DEFAULT_BYPASS: &str = "localhost,127.0.0.1/8,::1";
#[cfg(target_os = "macos")]
static DEFAULT_BYPASS: &str = "127.0.0.1,localhost,<local>";

impl Sysopt {
    pub fn new() -> Sysopt {
        Sysopt {
            cur_sysproxy: None,
            old_sysproxy: None,
            auto_launch: None,
            guard_state: Arc::new(Mutex::new(false)),
        }
    }

    /// init the sysproxy
    pub fn init_sysproxy(&mut self) -> Result<()> {
        let data = Data::global();
        let clash = data.clash.lock();
        let port = clash.info.port.clone();

        if port.is_none() {
            bail!("clash port is none");
        }

        let verge = data.verge.lock();

        let enable = verge.enable_system_proxy.clone().unwrap_or(false);
        let bypass = verge.system_proxy_bypass.clone();
        let bypass = bypass.unwrap_or(DEFAULT_BYPASS.into());

        let port = port.unwrap().parse::<u16>()?;
        let host = String::from("127.0.0.1");

        self.cur_sysproxy = Some(Sysproxy {
            enable,
            host,
            port,
            bypass,
        });

        if enable {
            self.old_sysproxy = Sysproxy::get_system_proxy().map_or(None, |p| Some(p));
            self.cur_sysproxy.as_ref().unwrap().set_system_proxy()?;
        }

        // run the system proxy guard
        self.guard_proxy();
        Ok(())
    }

    /// update the system proxy
    pub fn update_sysproxy(&mut self) -> Result<()> {
        if self.cur_sysproxy.is_none() || self.old_sysproxy.is_none() {
            return self.init_sysproxy();
        }

        let data = Data::global();
        let verge = data.verge.lock();

        let enable = verge.enable_system_proxy.clone().unwrap_or(false);
        let bypass = verge.system_proxy_bypass.clone();
        let bypass = bypass.unwrap_or(DEFAULT_BYPASS.into());

        let mut sysproxy = self.cur_sysproxy.take().unwrap();

        sysproxy.enable = enable;
        sysproxy.bypass = bypass;

        self.cur_sysproxy = Some(sysproxy);
        self.cur_sysproxy.as_ref().unwrap().set_system_proxy()?;

        Ok(())
    }

    /// reset the sysproxy
    pub fn reset_sysproxy(&mut self) -> Result<()> {
        let cur = self.cur_sysproxy.take();

        if let Some(mut old) = self.old_sysproxy.take() {
            // 如果原代理和当前代理 端口一致，就disable关闭，否则就恢复原代理设置
            // 当前没有设置代理的时候，不确定旧设置是否和当前一致，全关了
            let port_same = cur.map_or(true, |cur| old.port == cur.port);

            if old.enable && port_same {
                old.enable = false;
                log::info!(target: "app", "reset proxy by disabling the original proxy");
            } else {
                log::info!(target: "app", "reset proxy to the original proxy");
            }

            old.set_system_proxy()?;
        } else if let Some(mut cur @ Sysproxy { enable: true, .. }) = cur {
            // 没有原代理，就按现在的代理设置disable即可
            log::info!(target: "app", "reset proxy by disabling the current proxy");
            cur.enable = false;
            cur.set_system_proxy()?;
        } else {
            log::info!(target: "app", "reset proxy with no action");
        }

        Ok(())
    }

    /// init the auto launch
    pub fn init_launch(&mut self) -> Result<()> {
        let data = Data::global();
        let verge = data.verge.lock();
        let enable = verge.enable_auto_launch.clone().unwrap_or(false);

        let app_exe = current_exe()?;
        let app_exe = dunce::canonicalize(app_exe)?;
        let app_name = app_exe
            .file_stem()
            .and_then(|f| f.to_str())
            .ok_or(anyhow!("failed to get file stem"))?;

        let app_path = app_exe
            .as_os_str()
            .to_str()
            .ok_or(anyhow!("failed to get app_path"))?
            .to_string();

        // fix issue #26
        #[cfg(target_os = "windows")]
        let app_path = format!("\"{app_path}\"");

        // use the /Applications/Clash Verge.app path
        #[cfg(target_os = "macos")]
        let app_path = (|| -> Option<String> {
            let path = std::path::PathBuf::from(&app_path);
            let path = path.parent()?.parent()?.parent()?;
            let extension = path.extension()?.to_str()?;
            match extension == "app" {
                true => Some(path.as_os_str().to_str()?.to_string()),
                false => None,
            }
        })()
        .unwrap_or(app_path);

        let auto = AutoLaunchBuilder::new()
            .set_app_name(app_name)
            .set_app_path(&app_path)
            .build()?;

        self.auto_launch = Some(auto);

        // 避免在开发时将自启动关了
        #[cfg(feature = "verge-dev")]
        if !enable {
            return Ok(());
        }

        let auto = self.auto_launch.as_ref().unwrap();

        // macos每次启动都更新登录项，避免重复设置登录项
        #[cfg(target_os = "macos")]
        {
            let _ = auto.disable();
            if enable {
                auto.enable()?;
            }
        }

        #[cfg(not(target_os = "macos"))]
        {
            match enable {
                true => auto.enable()?,
                false => auto.disable()?,
            };
        }

        Ok(())
    }

    /// update the startup
    pub fn update_launch(&mut self) -> Result<()> {
        if self.auto_launch.is_none() {
            return self.init_launch();
        }

        let data = Data::global();
        let verge = data.verge.lock();
        let enable = verge.enable_auto_launch.clone().unwrap_or(false);

        let auto_launch = self.auto_launch.as_ref().unwrap();

        match enable {
            true => auto_launch.enable()?,
            false => crate::log_if_err!(auto_launch.disable()), // 忽略关闭的错误
        };

        Ok(())
    }

    /// launch a system proxy guard
    /// read config from file directly
    pub fn guard_proxy(&self) {
        use tokio::time::{sleep, Duration};

        let guard_state = self.guard_state.clone();

        tauri::async_runtime::spawn(async move {
            // if it is running, exit
            let mut state = guard_state.lock().await;
            if *state {
                return;
            }
            *state = true;
            drop(state);

            // default duration is 10s
            let mut wait_secs = 10u64;

            loop {
                sleep(Duration::from_secs(wait_secs)).await;

                let global = Data::global();
                let verge = global.verge.lock();

                let enable = verge.enable_system_proxy.clone().unwrap_or(false);
                let guard = verge.enable_proxy_guard.clone().unwrap_or(false);
                let guard_duration = verge.proxy_guard_duration.clone().unwrap_or(10);
                let bypass = verge.system_proxy_bypass.clone();
                drop(verge);

                // stop loop
                if !enable || !guard {
                    break;
                }

                // update duration
                wait_secs = guard_duration;

                let clash = global.clash.lock();
                let port = clash.info.port.clone();
                let port = port.unwrap_or("".into()).parse::<u16>();
                drop(clash);

                log::debug!(target: "app", "try to guard the system proxy");

                match port {
                    Ok(port) => {
                        let sysproxy = Sysproxy {
                            enable: true,
                            host: "127.0.0.1".into(),
                            port,
                            bypass: bypass.unwrap_or(DEFAULT_BYPASS.into()),
                        };

                        log_if_err!(sysproxy.set_system_proxy());
                    }
                    Err(_) => log::error!(target: "app", "failed to parse clash port"),
                }
            }

            let mut state = guard_state.lock().await;
            *state = false;
        });
    }
}