use std::{ collections::HashMap, fs::{File, OpenOptions}, path::Path, process::{ExitStatus, Stdio}, sync::Arc, }; use super::rendering_recovery::RecoveryState; use crate::service::transport::{DESKTOP_GUI_EXITED, DESKTOP_RENDERING_RETRY}; use anyhow::{Context, ensure}; use common::binary_paths; use log::warn; use tokio::{ io::{AsyncRead, AsyncReadExt, AsyncWriteExt}, process::Command, }; use tokio_util::sync::CancellationToken; use zeroize::Zeroizing; use super::{CommandExt, gui_launcher::GuiLauncher}; use crate::service::transport::{MAX_CREDENTIAL_FRAME, SessionCredential}; /// Owns the desktop GUI and its privileged service without leaving the desktop session. pub struct DesktopLauncher<'a> { version: &'a str, minimized: bool, log_file: Option, } impl<'a> DesktopLauncher<'a> { /// Bring an already-running GUI to the foreground through its service. pub async fn activate_existing() -> anyhow::Result<()> { let endpoint = crate::utils::endpoint::http_endpoint().await?; crate::utils::request::client_builder() .build()? .post(format!("{endpoint}/active-gui")) .send() .await? .error_for_status()?; Ok(()) } pub fn new(version: &'a str) -> Self { Self { version, minimized: false, log_file: None, } } pub fn minimized(mut self, minimized: bool) -> Self { self.minimized = minimized; self } pub fn log_file(mut self, log_file: &str) -> Self { self.log_file = Some(log_file.to_owned()); self } pub async fn launch(&self) -> anyhow::Result { ensure!( uzers::get_effective_uid() != 0, "The desktop launcher must not run as root" ); let mut command = Command::new_pkexec(binary_paths::gpservice()); command .arg("--desktop-credentials") .stdin(Stdio::piped()) .stdout(Stdio::piped()); if let Some(path) = &self.log_file { command.stderr(Stdio::from(create_log_file(Path::new(path))?)); } let mut service = command.spawn().context("Failed to start the privileged service")?; let mut input = service.stdin.take().context("Service input pipe is unavailable")?; let mut output = service .stdout .take() .context("Service credential pipe is unavailable")?; let mut received_credential = false; let mut cancelled = false; let cancellation = CancellationToken::new(); let mut recovery = RecoveryState::default(); #[cfg(target_os = "linux")] let switch_listener = super::gui_switch::SwitchListener::new()?; let result = { let operation = async { let mut minimized = self.minimized; let mut expecting_renewal = false; loop { let credential = tokio::select! { biased; _ = cancellation.cancelled() => return Ok(()), result = read_credential(&mut output) => result?, }; let Some(credential) = credential else { ensure!( !expecting_renewal, "Service closed before issuing the recovery credential" ); return Ok(()); }; expecting_renewal = false; received_credential = true; ensure!( credential.product_version() == self.version, "Service product version mismatch" ); let mut envs: HashMap = std::env::vars().collect(); #[cfg(target_os = "linux")] envs.insert( super::gui_switch::SOCKET_ENV.into(), switch_listener.path().to_string_lossy().into_owned(), ); if recovery.dmabuf_disabled() { envs.insert("WEBKIT_DISABLE_DMABUF_RENDERER".into(), "1".into()); } if let Some(path) = &self.log_file { envs.insert("GP_LOG_FILE".into(), path.clone()); } let launcher = GuiLauncher::new(self.version, Arc::new(credential), crate::gui::preferred()?) .envs(envs) .minimized(minimized); #[cfg(not(target_os = "linux"))] let mut unexpected = [0]; // Program resolution may launch the WebKit download helper. Keep it under // the same cancellation, service ownership and recovery budget as gpgui. let outcome = { let attempt = async { let program = launcher .resolve_program(&cancellation, crate::gui::GuiTheme::System) .await?; #[cfg(target_os = "linux")] return launcher .launch_with_switches( &program, &cancellation, &switch_listener.listener, &mut input, &mut output, ) .await; #[cfg(not(target_os = "linux"))] launcher.launch_program(&program, &cancellation).await }; tokio::pin!(attempt); tokio::select! { biased; _ = cancellation.cancelled() => { let _ = attempt.await; return Ok(()); } result = &mut attempt => result, status = service.wait() => { cancellation.cancel(); let _ = attempt.await; anyhow::bail!("The privileged service exited while the GUI was running: {}", status?); } result = async { #[cfg(not(target_os = "linux"))] return output.read(&mut unexpected).await; #[cfg(target_os = "linux")] std::future::pending::>().await } => { cancellation.cancel(); let _ = attempt.await; ensure!(result? == 0, "Unexpected service credential data while the GUI is running"); anyhow::bail!("The privileged service closed its credential channel"); } } }; if cancellation.is_cancelled() { return Ok(()); } match outcome { Err(error) if recovery.recover(&error) => { warn!("{error}; restarting the desktop launch with DMABUF disabled and opaque windows"); expecting_renewal = true; input.write_all(&[DESKTOP_RENDERING_RETRY]).await?; } Err(error) => return Err(recovery.terminal(error)), Ok(_) => { input.write_all(&[DESKTOP_GUI_EXITED]).await?; minimized = false; } } } }; tokio::pin!(operation); let result = tokio::select! { biased; _ = crate::utils::shutdown_signal() => { cancelled = true; cancellation.cancel(); operation.await }, result = &mut operation => result, }; result }; let result = recovery.finish(result); // EOF lets the service revoke the credential and disconnect the VPN gracefully. drop(input); if cancelled && !received_credential { // pkexec is still user-owned during authorization. After elevation, EOF owns shutdown. if let Err(error) = service.start_kill() && error.kind() != std::io::ErrorKind::PermissionDenied { return Err(error.into()); } } let status = service.wait().await?; result?; ensure!( cancelled || status.success(), "The privileged service exited with {status}" ); Ok(status) } } fn create_log_file(path: &Path) -> std::io::Result { // Start a fresh desktop session, then let both processes append without overwriting each other. File::create(path)?; OpenOptions::new().append(true).open(path) } pub(super) async fn read_credential( reader: &mut (impl AsyncRead + Unpin), ) -> anyhow::Result> { let mut header = [0; 2]; if reader.read(&mut header[..1]).await? == 0 { return Ok(None); } reader.read_exact(&mut header[1..]).await?; let length = usize::from(u16::from_be_bytes(header)); ensure!( length != 0 && length + 2 <= MAX_CREDENTIAL_FRAME, "Invalid service credential length" ); let mut frame = Zeroizing::new(vec![0; length + 2]); frame[..2].copy_from_slice(&header); reader.read_exact(&mut frame[2..]).await?; Ok(Some(SessionCredential::decode_frame(&frame)?)) } #[cfg(test)] mod tests { use std::io::Write; use super::*; #[test] fn desktop_log_starts_fresh_and_service_writes_preserve_gui_logs() { let dir = tempfile::TempDir::new().unwrap(); let path = dir.path().join("desktop.log"); std::fs::write(&path, "previous session\n").unwrap(); let mut service = create_log_file(&path).unwrap(); writeln!(service, "[gpservice] started").unwrap(); let mut gui = OpenOptions::new().append(true).open(&path).unwrap(); writeln!(gui, "[gpgui] initialized").unwrap(); writeln!(service, "[gpservice] connected").unwrap(); assert_eq!( std::fs::read_to_string(&path).unwrap(), "[gpservice] started\n[gpgui] initialized\n[gpservice] connected\n" ); } #[tokio::test] async fn credential_channel_distinguishes_clean_close_from_truncated_or_oversized_frames() { assert!(read_credential(&mut &[][..]).await.unwrap().is_none()); assert!(read_credential(&mut &[0][..]).await.is_err()); assert!(read_credential(&mut &[0, 0][..]).await.is_err()); assert!(read_credential(&mut &[255, 255][..]).await.is_err()); let credential = SessionCredential::generate(uuid::Uuid::new_v4(), "test").unwrap(); let frame = credential.encode_frame().unwrap(); let decoded = read_credential(&mut frame.as_slice()).await.unwrap().unwrap(); assert_eq!(decoded.session_id(), credential.session_id()); } }