feat: prepare 3.0.0 release

This commit is contained in:
Kevin Yue committed 2026-10-09 18:21:44 +08:00
1 parent e98fd7894a
commit b7b708e9cd
252 files changed
+26210 -7457

No files matched your search

+88 -42
View File
@@ -1,26 +1,45 @@
use std::{collections::HashMap, env::temp_dir, fs, path::PathBuf};
use std::{fs, path::PathBuf};
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd", test))]
use std::process::{Command, ExitStatus};
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
use anyhow::Context;
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd", test))]
use anyhow::bail;
use clap::Args;
use common::constants::GP_CALLBACK_PORT_FILENAME;
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd", test))]
use common::binary_paths;
use directories::ProjectDirs;
use gpapi::{
process::service_launcher::ServiceLauncher,
utils::{endpoint::http_endpoint, env_utils, shutdown_signal},
};
use gpapi::{process::desktop_launcher::DesktopLauncher, utils::endpoint::http_endpoint};
use log::info;
use tokio::io::AsyncWriteExt;
#[derive(Args)]
pub(crate) struct LaunchGuiArgs {
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
#[arg(
required = false,
help = "The authentication data, used for the default browser authentication"
conflicts_with = "minimized",
value_parser = parse_auth_callback,
help = "The external-browser authentication callback URL"
)]
pub auth_data: Option<String>,
callback: Option<String>,
#[arg(long, help = "Launch the GUI minimized")]
minimized: bool,
}
impl LaunchGuiArgs {
pub(crate) fn is_auth_callback(&self) -> bool {
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
{
return self.callback.is_some();
}
#[cfg(not(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd")))]
false
}
}
pub(crate) struct LaunchGuiHandler<'a> {
args: &'a LaunchGuiArgs,
}
@@ -37,11 +56,9 @@ impl<'a> LaunchGuiHandler<'a> {
anyhow::bail!("`launch-gui` cannot be run as root");
}
let auth_data = self.args.auth_data.as_deref().unwrap_or_default();
if !auth_data.is_empty() {
info!("Received auth callback data");
// Process the authentication data, its format is `globalprotectcallback:<data>`
return feed_auth_data(auth_data).await;
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
if let Some(callback) = &self.args.callback {
return forward_auth_callback(callback);
}
if try_active_gui().await.is_ok() {
@@ -49,27 +66,13 @@ impl<'a> LaunchGuiHandler<'a> {
return Ok(());
}
tokio::spawn(async move {
shutdown_signal().await;
info!("Shutting down...");
});
let log_file = get_log_file()?;
let log_file_path = log_file.to_string_lossy().to_string();
info!("Log file: {}", log_file_path);
let mut extra_envs = HashMap::<String, String>::new();
extra_envs.insert("GP_LOG_FILE".into(), log_file_path.clone());
// Persist the environment variables to a file
let env_file = env_utils::persist_env_vars(Some(extra_envs))?;
let env_file = env_file.into_temp_path();
let env_file_path = env_file.to_string_lossy().to_string();
let exit_status = ServiceLauncher::new()
let exit_status = DesktopLauncher::new(env!("CARGO_PKG_VERSION"))
.minimized(self.args.minimized)
.env_file(&env_file_path)
.log_file(&log_file_path)
.launch()
.await?;
@@ -80,24 +83,36 @@ impl<'a> LaunchGuiHandler<'a> {
}
}
async fn feed_auth_data(auth_data: &str) -> anyhow::Result<()> {
if let Err(err) = feed_auth_data_cli(auth_data).await {
info!("Failed to feed auth data to the CLI: {}", err);
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
fn forward_auth_callback(callback: &str) -> anyhow::Result<()> {
let status = auth_callback_command(callback)
.status()
.context("Failed to start the authentication callback handler")?;
ensure_auth_callback_succeeded(status)
}
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd", test))]
fn auth_callback_command(callback: &str) -> Command {
let mut command = Command::new(binary_paths::gpauth());
command.args(["auth-callback", callback]);
command
}
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd", test))]
fn ensure_auth_callback_succeeded(status: ExitStatus) -> anyhow::Result<()> {
if !status.success() {
bail!("Authentication callback handler exited with {status}");
}
Ok(())
}
async fn feed_auth_data_cli(auth_data: &str) -> anyhow::Result<()> {
info!("Feeding auth data to the CLI");
let port_file = temp_dir().join(GP_CALLBACK_PORT_FILENAME);
let port = tokio::fs::read_to_string(port_file).await?;
let mut stream = tokio::net::TcpStream::connect(format!("127.0.0.1:{}", port.trim())).await?;
stream.write_all(auth_data.as_bytes()).await?;
Ok(())
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd", test))]
fn parse_auth_callback(callback: &str) -> Result<String, String> {
callback
.starts_with("globalprotectcallback:")
.then(|| callback.to_owned())
.ok_or_else(|| "callback URL must use the globalprotectcallback scheme".to_owned())
}
async fn try_active_gui() -> anyhow::Result<()> {
@@ -120,3 +135,34 @@ fn get_log_file() -> anyhow::Result<PathBuf> {
Ok(dirs.data_dir().join("gpclient.log"))
}
#[cfg(all(test, unix))]
mod tests {
use std::os::unix::process::ExitStatusExt;
use super::*;
const CALLBACK: &str = "globalprotectcallback:cas-as=1&[email protected]&token=token";
#[test]
fn callback_command_preserves_callback_argument() {
let command = auth_callback_command(CALLBACK);
let args = command
.get_args()
.map(|argument| argument.to_str().unwrap())
.collect::<Vec<_>>();
assert_eq!(args, ["auth-callback", CALLBACK]);
}
#[test]
fn callback_command_status_is_propagated() {
assert!(ensure_auth_callback_succeeded(ExitStatus::from_raw(0)).is_ok());
assert!(ensure_auth_callback_succeeded(ExitStatus::from_raw(1 << 8)).is_err());
}
#[test]
fn rejects_non_callback_url() {
assert!(parse_auth_callback("https://example.com/callback").is_err());
}
}