src/settings.rs - master - pushamp/PACman

src/settings.rs
99 строк3 KB
Dmitry Zhiltsov
feat(core): Init commit
19 фев 2026, 18:01
19 фев 2026, 18:011fadda9
use serde::{Deserialize, Serialize};
use std::path::PathBuf;
use std::sync::{Arc, RwLock};

pub type SharedConfig = Arc<RwLock<Config>>;

const DEFAULT_PAC: &str = r#"function FindProxyForURL(url, host) {
    if (isInNet(dnsResolve(host), "10.0.0.0", "255.0.0.0") ||
        isInNet(dnsResolve(host), "172.16.0.0", "255.240.0.0") ||
        isInNet(dnsResolve(host), "192.168.0.0", "255.255.0.0")) {
        return "DIRECT";
    }
    return "DIRECT";
}"#;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Config {
    #[serde(default = "default_vpn_interface")]
    pub vpn_interface: String,
    #[serde(default = "default_network_service")]
    pub network_service: String,
    #[serde(default = "default_poll_interval")]
    pub poll_interval_secs: u64,
    #[serde(default = "default_http_port")]
    pub http_port: u16,
    #[serde(default = "default_pac_content")]
    pub pac_content: String,
    #[serde(default)]
    pub launch_at_login: bool,
}

fn default_vpn_interface() -> String {
    "utun4".to_string()
}
fn default_network_service() -> String {
    "Wi-Fi".to_string()
}
fn default_poll_interval() -> u64 {
    30
}
fn default_http_port() -> u16 {
    8888
}
fn default_pac_content() -> String {
    DEFAULT_PAC.to_string()
}

impl Default for Config {
    fn default() -> Self {
        Self {
            vpn_interface: default_vpn_interface(),
            network_service: default_network_service(),
            poll_interval_secs: default_poll_interval(),
            http_port: default_http_port(),
            pac_content: default_pac_content(),
            launch_at_login: false,
        }
    }
}

fn config_path() -> PathBuf {
    let home = std::env::var("HOME").unwrap_or_else(|_| "/tmp".to_string());
    PathBuf::from(home)
        .join("Library/Preferences")
        .join(format!("{}.plist", crate::APP_ID))
}

impl Config {
    pub fn load() -> Self {
        let path = config_path();
        if path.exists() {
            match std::fs::File::open(&path) {
                Ok(file) => match plist::from_reader(std::io::BufReader::new(file)) {
                    Ok(config) => return config,
                    Err(e) => {
                        crate::logging::log_error(&format!("Failed to parse config: {e}"));
                    }
                },
                Err(e) => {
                    crate::logging::log_error(&format!("Failed to open config: {e}"));
                }
            }
        }
        Config::default()
    }

    pub fn save(&self) -> Result<(), String> {
        let path = config_path();
        let file = std::fs::File::create(&path).map_err(|e| format!("Create config: {e}"))?;
        plist::to_writer_xml(std::io::BufWriter::new(file), self)
            .map_err(|e| format!("Write config: {e}"))?;
        crate::logging::log_info("Settings saved");
        Ok(())
    }
}

pub fn load_shared() -> SharedConfig {
    Arc::new(RwLock::new(Config::load()))
}