Files
GlobalProtect-openconnect/apps/gpgui-helper/src-tauri/src/cli.rs
T

157 lines
4.3 KiB
Rust

use clap::Parser;
use std::{io::Read, sync::Arc};
use anyhow::{Context, bail};
use gpapi::{
clap::InfoLevelVerbosity,
gui::GuiTheme,
service::transport::{MAX_CREDENTIAL_FRAME, SessionCredential},
utils::env_utils,
};
use log::info;
use tokio::sync::watch;
use zeroize::Zeroizing;
use crate::app::App;
const VERSION: &str = concat!(
env!("CARGO_PKG_VERSION"),
" (",
env!("GPGUI_HELPER_GIT_COMMIT"),
" ",
compile_time::date_str!(),
")"
);
#[derive(Parser)]
#[command(version = VERSION)]
struct Cli {
#[arg(long, help = "Read the service credential from stdin")]
service_credential_on_stdin: bool,
#[arg(long, default_value = env!("CARGO_PKG_VERSION"), help = "The version of the GUI")]
gui_version: String,
#[arg(long, default_value = "tauri", value_parser = ["tauri", "nsh"])]
gui_variant: String,
#[arg(long, value_enum, default_value = "system", help = "Window appearance")]
theme: GuiTheme,
#[command(flatten)]
verbose: InfoLevelVerbosity,
}
impl Cli {
fn run(&self) -> anyhow::Result<()> {
let credential = self.read_credential()?;
let credential_lease = monitor_credential_lease().context("Failed to monitor service credential lifetime")?;
let variant = if self.gui_variant == "nsh" {
gpapi::gui::GuiVariant::Nsh
} else {
gpapi::gui::GuiVariant::Tauri
};
anyhow::ensure!(
variant != gpapi::gui::GuiVariant::Nsh || cfg!(target_os = "linux"),
"Native Shell is available only on Linux"
);
let app = App::new(
Arc::new(credential),
credential_lease,
&self.gui_version,
variant,
self.theme,
);
env_utils::patch_gui_runtime_env(false);
app.run()
}
fn read_credential(&self) -> anyhow::Result<SessionCredential> {
if !self.service_credential_on_stdin {
bail!("Service credential must be provided via --service-credential-on-stdin");
}
let stdin = std::io::stdin();
let mut input = stdin.lock();
let mut header = [0_u8; 2];
input
.read_exact(&mut header)
.context("Failed to read service credential header")?;
let payload_len = u16::from_be_bytes(header) as usize;
if payload_len == 0 || payload_len + header.len() > MAX_CREDENTIAL_FRAME {
bail!("Invalid service credential length");
}
let mut frame = Zeroizing::new(Vec::with_capacity(payload_len + header.len()));
frame.extend_from_slice(&header);
frame.resize(payload_len + header.len(), 0);
input
.read_exact(&mut frame[header.len()..])
.context("Failed to read service credential")?;
SessionCredential::decode_frame(&frame).context("Invalid service credential")
}
}
fn monitor_credential_lease() -> std::io::Result<watch::Receiver<bool>> {
let (lease_tx, lease_rx) = watch::channel(true);
std::thread::Builder::new()
.name("credential-lease".to_owned())
.spawn(move || {
let stdin = std::io::stdin();
close_credential_lease_at_eof(stdin.lock(), lease_tx);
})?;
Ok(lease_rx)
}
fn close_credential_lease_at_eof(mut input: impl Read, lease_tx: watch::Sender<bool>) {
let mut buffer = [0_u8; 256];
while matches!(input.read(&mut buffer), Ok(len) if len > 0) {}
let _ = lease_tx.send(false);
}
fn init_logger(cli: &Cli) {
env_logger::builder()
.filter_level(cli.verbose.log_level_filter())
.init();
}
pub fn run() {
let cli = Cli::parse();
init_logger(&cli);
info!("gpgui-helper started: {}", VERSION);
if let Err(e) = cli.run() {
eprintln!("{}", e);
std::process::exit(1);
}
}
#[cfg(test)]
mod tests {
use std::io::Cursor;
use super::*;
#[test]
fn theme_defaults_to_system_and_accepts_explicit_modes() {
assert_eq!(Cli::try_parse_from(["gpgui-helper"]).unwrap().theme, GuiTheme::System);
for (value, expected) in [
("system", GuiTheme::System),
("light", GuiTheme::Light),
("dark", GuiTheme::Dark),
] {
assert_eq!(
Cli::try_parse_from(["gpgui-helper", "--theme", value]).unwrap().theme,
expected
);
}
assert!(Cli::try_parse_from(["gpgui-helper", "--theme", "invalid"]).is_err());
}
#[test]
fn credential_lease_closes_at_eof() {
let (lease_tx, lease_rx) = watch::channel(true);
close_credential_lease_at_eof(Cursor::new(b"ignored lease bytes"), lease_tx);
assert!(!*lease_rx.borrow());
}
}