diff --git a/.github/workflows/build.yaml b/.github/workflows/build.yaml index fb15eb7..cdcf774 100644 --- a/.github/workflows/build.yaml +++ b/.github/workflows/build.yaml @@ -415,6 +415,7 @@ jobs: brew install \ autoconf \ automake \ + create-dmg \ dylibbundler \ gettext \ gmp \ diff --git a/Cargo.lock b/Cargo.lock index 6f8863a..1c5f8f4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1852,6 +1852,7 @@ dependencies = [ "netdev", "openssl", "os_info", + "oslog", "pem", "proptest", "redact-engine", @@ -1886,7 +1887,6 @@ dependencies = [ "clap", "common", "compile-time", - "env_logger", "gpapi", "home", "log", @@ -3368,6 +3368,15 @@ dependencies = [ "windows-sys 0.61.2", ] +[[package]] +name = "oslog" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "80d2043d1f61d77cb2f4b1f7b7b2295f40507f5f8e9d1c8bf10a1ca5f97a3969" +dependencies = [ + "cc", +] + [[package]] name = "pango" version = "0.18.3" diff --git a/apps/gpauth/Cargo.toml b/apps/gpauth/Cargo.toml index fb08b73..f62a191 100644 --- a/apps/gpauth/Cargo.toml +++ b/apps/gpauth/Cargo.toml @@ -11,14 +11,13 @@ tauri-build = { version = "2", features = [], optional = true } [dependencies] common = { path = "../../crates/common" } -gpapi = { path = "../../crates/gpapi", features = ["clap"] } +gpapi = { path = "../../crates/gpapi", features = ["clap", "logger"] } auth = { path = "../../crates/auth", features = ["browser-auth"] } # Shared dependencies anyhow.workspace = true clap.workspace = true -env_logger.workspace = true log.workspace = true serde_json.workspace = true tokio = { workspace = true, features = ["rt-multi-thread"] } diff --git a/apps/gpauth/src/cli.rs b/apps/gpauth/src/cli.rs index 58d686b..532cd7a 100644 --- a/apps/gpauth/src/cli.rs +++ b/apps/gpauth/src/cli.rs @@ -206,9 +206,11 @@ impl Cli { } fn init_logger(cli: &Cli) { - env_logger::builder() - .filter_level(cli.verbose.log_level_filter()) - .init(); + if let Some(level) = cli.verbose.log_level_filter().to_level() { + gpapi::logger::init(level, "com.yuezk.gpgui", "gpauth"); + } else { + log::set_max_level(log::LevelFilter::Off); + } } pub async fn run() { diff --git a/apps/gpservice/src/cli.rs b/apps/gpservice/src/cli.rs index ad4cb1f..b8e81eb 100644 --- a/apps/gpservice/src/cli.rs +++ b/apps/gpservice/src/cli.rs @@ -18,6 +18,8 @@ use gpapi::{ service::{request::WsRequest, vpn_state::VpnState}, utils::{env_utils, lock_file::LockFile, redact::Redaction, shutdown_signal}, }; +#[cfg(target_os = "macos")] +use log::{Log, Metadata, Record}; use log::{info, warn}; use tokio::sync::{mpsc, watch}; use uuid::Uuid; @@ -35,6 +37,28 @@ const VERSION: &str = concat!( ")" ); +#[cfg(target_os = "macos")] +struct RedactingMacosLogger { + logger: logger::MacosLogger, + redaction: Arc, +} + +#[cfg(target_os = "macos")] +impl Log for RedactingMacosLogger { + fn enabled(&self, metadata: &Metadata<'_>) -> bool { + self.logger.enabled(metadata) + } + + fn log(&self, record: &Record<'_>) { + if self.enabled(record.metadata()) { + let message = self.redaction.redact_str(&record.args().to_string()); + self.logger.write(record.level(), record.target(), &message); + } + } + + fn flush(&self) {} +} + #[derive(Parser)] #[command(version = VERSION)] struct Cli { @@ -77,15 +101,22 @@ impl Cli { let gui_restart_requested = Arc::new(AtomicBool::new(false)); let registry = Arc::new(SessionRegistry::new(Uuid::new_v4())); let externally_brokered = self.externally_brokered(); - let brokered_helpers_dir = externally_brokered - .then(|| std::env::current_exe().ok()?.parent().map(ToOwned::to_owned)) - .flatten(); + let brokered_scripts_dir = if externally_brokered { + let executable = std::env::current_exe().context("Failed to locate the gpservice executable")?; + let contents_dir = executable + .parent() + .and_then(std::path::Path::parent) + .context("gpservice is not inside a macOS application bundle")?; + Some(contents_dir.join("Resources/Scripts")) + } else { + None + }; let dispatcher = Arc::new(RequestDispatcher::new( ws_req_tx.clone(), Arc::clone(&gui_restart_requested), Arc::clone(&redaction), !externally_brokered, - brokered_helpers_dir, + brokered_scripts_dir, )); let mut vpn_task = VpnTask::new(ws_req_rx, vpn_state_tx, externally_brokered); @@ -201,6 +232,20 @@ impl Cli { fn init_logger(&self) -> Arc { let redaction = Arc::new(Redaction::new()); + let level = self.verbose.log_level_filter().to_level().unwrap_or(log::Level::Info); + + #[cfg(target_os = "macos")] + if logger::macos_unified_log_enabled() { + logger::init_with_logger( + level, + RedactingMacosLogger { + logger: logger::MacosLogger::new("com.yuezk.gpgui", "gpservice"), + redaction: Arc::clone(&redaction), + }, + ); + return redaction; + } + let redaction_clone = Arc::clone(&redaction); let inner_logger = env_logger::builder() @@ -219,8 +264,6 @@ impl Cli { }) .build(); - let level = self.verbose.log_level_filter().to_level().unwrap_or(log::Level::Info); - logger::init_with_logger(level, inner_logger); redaction diff --git a/apps/gpservice/src/request_dispatcher.rs b/apps/gpservice/src/request_dispatcher.rs index 834a62c..369eba0 100644 --- a/apps/gpservice/src/request_dispatcher.rs +++ b/apps/gpservice/src/request_dispatcher.rs @@ -30,7 +30,7 @@ pub struct RequestDispatcher { redaction: Arc, install_lock: Mutex<()>, gui_management_enabled: bool, - brokered_helpers_dir: Option, + brokered_scripts_dir: Option, } impl RequestDispatcher { @@ -39,7 +39,7 @@ impl RequestDispatcher { gui_restart_requested: Arc, redaction: Arc, gui_management_enabled: bool, - brokered_helpers_dir: Option, + brokered_scripts_dir: Option, ) -> Self { Self { ws_req_tx, @@ -47,7 +47,7 @@ impl RequestDispatcher { redaction, install_lock: Mutex::new(()), gui_management_enabled, - brokered_helpers_dir, + brokered_scripts_dir, } } @@ -97,11 +97,11 @@ impl RequestDispatcher { } fn validate_connect_paths(&self, request: &gpapi::service::request::ConnectRequest) -> Result<(), &'static str> { - let Some(helpers) = &self.brokered_helpers_dir else { + let Some(scripts) = &self.brokered_scripts_dir else { return Ok(()); }; - let expected_script = helpers.join("vpnc-script").to_string_lossy().into_owned(); - let expected_wrapper = helpers.join("hipreport.sh").to_string_lossy().into_owned(); + let expected_script = scripts.join("vpnc-script").to_string_lossy().into_owned(); + let expected_wrapper = scripts.join("hipreport.sh").to_string_lossy().into_owned(); if request.args().vpnc_script().as_deref() != Some(expected_script.as_str()) { return Err("macOS VPN script must be the bundled script"); } @@ -329,7 +329,7 @@ mod tests { Arc::new(AtomicBool::new(false)), Arc::new(Redaction::new()), false, - Some(std::path::PathBuf::from("/app/Contents/Helpers")), + Some(std::path::PathBuf::from("/app/Contents/Resources/Scripts")), ); let ServiceResult::Rejected(rejection) = dispatcher.dispatch(WsRequest::RestartGui).await else { panic!("brokered mode accepted GUI restart"); @@ -339,12 +339,38 @@ mod tests { let gateway = Gateway::new("Gateway".into(), "vpn.example.com".into()); let info = gpapi::service::vpn_state::ConnectInfo::new("portal.example.com".into(), gateway.clone(), vec![gateway]); let request = ConnectRequest::new(info, "cookie".into()) - .with_vpnc_script(Some("/app/Contents/Helpers/vpnc-script".to_string())) - .with_csd_wrapper(Some("/app/Contents/Helpers/hipreport.sh".to_string())) + .with_vpnc_script(Some("/app/Contents/Resources/Scripts/vpnc-script".to_string())) + .with_csd_wrapper(Some("/app/Contents/Resources/Scripts/hipreport.sh".to_string())) .with_certificate(Some("/Users/example/client.pem".to_string())); let ServiceResult::Rejected(rejection) = dispatcher.dispatch(WsRequest::Connect(Box::new(request))).await else { panic!("brokered mode accepted a root-readable identity path"); }; assert_eq!(rejection.code(), ServiceErrorCode::InvalidRequest); } + + #[test] + fn brokered_mode_accepts_only_resource_script_paths() { + let (request_tx, _request_rx) = mpsc::channel(1); + let dispatcher = RequestDispatcher::new( + request_tx, + Arc::new(AtomicBool::new(false)), + Arc::new(Redaction::new()), + false, + Some(std::path::PathBuf::from("/app/Contents/Resources/Scripts")), + ); + let gateway = Gateway::new("Gateway".into(), "vpn.example.com".into()); + let info = gpapi::service::vpn_state::ConnectInfo::new("portal.example.com".into(), gateway.clone(), vec![gateway]); + let bundled = ConnectRequest::new(info.clone(), "cookie".into()) + .with_vpnc_script(Some("/app/Contents/Resources/Scripts/vpnc-script".to_string())) + .with_csd_wrapper(Some("/app/Contents/Resources/Scripts/hipreport.sh".to_string())); + assert_eq!(dispatcher.validate_connect_paths(&bundled), Ok(())); + + let old_layout = ConnectRequest::new(info, "cookie".into()) + .with_vpnc_script(Some("/app/Contents/Helpers/vpnc-script".to_string())) + .with_csd_wrapper(Some("/app/Contents/Helpers/hipreport.sh".to_string())); + assert_eq!( + dispatcher.validate_connect_paths(&old_layout), + Err("macOS VPN script must be the bundled script") + ); + } } diff --git a/crates/gpapi/Cargo.toml b/crates/gpapi/Cargo.toml index 1debd36..20521c7 100644 --- a/crates/gpapi/Cargo.toml +++ b/crates/gpapi/Cargo.toml @@ -49,6 +49,9 @@ clap-verbosity-flag = { workspace = true, optional = true } env_logger = { workspace = true, optional = true } log-reload = { version = "0.1", optional = true } +[target.'cfg(target_os="macos")'.dependencies] +oslog = { version = "0.2", default-features = false, optional = true } + # Dependencies for Linux and other OSes only [target.'cfg(not(any(target_os="macos", target_os="windows")))'.dependencies] gtk = { version = "0.18", optional = true } @@ -60,4 +63,4 @@ proptest.workspace = true tauri = ["dep:tauri", "dep:gtk"] clap = ["dep:clap", "dep:clap-verbosity-flag"] webview-auth = [] -logger = ["dep:env_logger", "dep:log-reload"] +logger = ["dep:env_logger", "dep:log-reload", "dep:oslog"] diff --git a/crates/gpapi/src/logger.rs b/crates/gpapi/src/logger.rs index e287d5f..9f47685 100644 --- a/crates/gpapi/src/logger.rs +++ b/crates/gpapi/src/logger.rs @@ -1,21 +1,33 @@ use std::sync::OnceLock; use anyhow::bail; -use env_logger::Logger; -use log::{Level, warn}; +use log::{Level, Log, warn}; use log_reload::{ReloadHandle, ReloadLog}; -static LOG_HANDLE: OnceLock>> = OnceLock::new(); +pub const LOG_BACKEND_ENV: &str = "GP_LOG_BACKEND"; +pub const MACOS_UNIFIED_LOG_BACKEND: &str = "macos-unified"; + +type BoxedLogger = Box; +static LOG_HANDLE: OnceLock>> = OnceLock::new(); + +pub fn init(level: Level, subsystem: &str, category: &str) { + #[cfg(target_os = "macos")] + if macos_unified_log_enabled() { + init_with_logger(level, MacosLogger::new(subsystem, category)); + return; + } + + #[cfg(not(target_os = "macos"))] + let _ = (subsystem, category); -pub fn init(level: Level) { // Initialize the env_logger and global max level to trace, the logs will be // filtered by the outer logger let logger = env_logger::builder().filter_level(log::LevelFilter::Trace).build(); init_with_logger(level, logger); } -pub fn init_with_logger(level: Level, logger: Logger) { - if let Some(_) = LOG_HANDLE.get() { +pub fn init_with_logger(level: Level, logger: impl Log + Send + Sync + 'static) { + if LOG_HANDLE.get().is_some() { warn!("Logger already initialized"); return; } @@ -23,7 +35,7 @@ pub fn init_with_logger(level: Level, logger: Logger) { log::set_max_level(log::LevelFilter::Trace); // Create a new logger that will filter the logs based on the max level - let level_filter_logger = log_reload::LevelFilter::new(level, logger); + let level_filter_logger = log_reload::LevelFilter::new(level, Box::new(logger) as BoxedLogger); let reload_log = ReloadLog::new(level_filter_logger); let handle = reload_log.handle(); @@ -42,3 +54,61 @@ pub fn set_max_level(level: Level) -> anyhow::Result<()> { .modify(|logger| logger.set_level(level)) .map_err(|e| anyhow::anyhow!(e)) } + +pub fn macos_unified_log_enabled() -> bool { + cfg!(target_os = "macos") && std::env::var(LOG_BACKEND_ENV).as_deref() == Ok(MACOS_UNIFIED_LOG_BACKEND) +} + +#[cfg(target_os = "macos")] +pub struct MacosLogger { + inner: oslog::OsLog, +} + +#[cfg(target_os = "macos")] +impl MacosLogger { + pub fn new(subsystem: &str, category: &str) -> Self { + Self { + inner: oslog::OsLog::new(subsystem, category), + } + } + + pub fn write(&self, level: Level, target: &str, message: &str) { + self + .inner + .with_level(macos_log_level(level), &format!("[{target}] {message}")); + } +} + +#[cfg(target_os = "macos")] +impl Log for MacosLogger { + fn enabled(&self, metadata: &log::Metadata<'_>) -> bool { + self.inner.level_is_enabled(macos_log_level(metadata.level())) + } + + fn log(&self, record: &log::Record<'_>) { + if self.enabled(record.metadata()) { + self.write(record.level(), record.target(), &record.args().to_string()); + } + } + + fn flush(&self) {} +} + +#[cfg(target_os = "macos")] +fn macos_log_level(level: Level) -> oslog::Level { + match level { + Level::Trace | Level::Debug => oslog::Level::Debug, + Level::Info => oslog::Level::Default, + Level::Warn | Level::Error => oslog::Level::Error, + } +} + +#[cfg(all(test, target_os = "macos"))] +mod tests { + use super::*; + + #[test] + fn info_logs_use_the_persistent_macos_level() { + assert_eq!(macos_log_level(Level::Info) as u8, oslog::Level::Default as u8); + } +}