mirror of
https://github.com/yuezk/GlobalProtect-openconnect.git
synced 2026-11-18 22:16:18 -05:00
feat(linux): switch desktop interfaces and preserve selection on upgrade
This commit is contained in:
17 files changed
+818
-58
No files matched your search
@@ -11,19 +11,27 @@ pub struct App {
|
||||
credential: Arc<SessionCredential>,
|
||||
credential_lease: watch::Receiver<bool>,
|
||||
gui_version: String,
|
||||
variant: gpapi::gui::GuiVariant,
|
||||
}
|
||||
|
||||
impl App {
|
||||
pub fn new(credential: Arc<SessionCredential>, credential_lease: watch::Receiver<bool>, gui_version: &str) -> Self {
|
||||
pub fn new(
|
||||
credential: Arc<SessionCredential>,
|
||||
credential_lease: watch::Receiver<bool>,
|
||||
gui_version: &str,
|
||||
variant: gpapi::gui::GuiVariant,
|
||||
) -> Self {
|
||||
Self {
|
||||
credential,
|
||||
credential_lease,
|
||||
gui_version: gui_version.to_string(),
|
||||
variant,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn run(&self) -> anyhow::Result<()> {
|
||||
let gui_version = self.gui_version.clone();
|
||||
let variant = self.variant;
|
||||
let credential = Arc::clone(&self.credential);
|
||||
let credential_lease = self.credential_lease.clone();
|
||||
|
||||
@@ -34,7 +42,7 @@ impl App {
|
||||
|
||||
let notifier = ProgressNotifier::new(win.clone());
|
||||
let installer = Installer::new(credential, credential_lease.clone());
|
||||
let updater = Arc::new(GuiUpdater::new(gui_version, notifier, installer));
|
||||
let updater = Arc::new(GuiUpdater::new(gui_version, notifier, installer, variant));
|
||||
|
||||
let app_handle = app.handle().clone();
|
||||
let mut app_credential_lease = credential_lease;
|
||||
|
||||
@@ -29,6 +29,8 @@ struct Cli {
|
||||
|
||||
#[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,
|
||||
|
||||
#[command(flatten)]
|
||||
verbose: InfoLevelVerbosity,
|
||||
@@ -38,7 +40,16 @@ 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 app = App::new(Arc::new(credential), credential_lease, &self.gui_version);
|
||||
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);
|
||||
|
||||
env_utils::patch_gui_runtime_env(false);
|
||||
|
||||
|
||||
@@ -41,10 +41,20 @@ const GUI_LIBC_SUFFIX: &str = "-musl";
|
||||
#[cfg(not(target_env = "musl"))]
|
||||
const GUI_LIBC_SUFFIX: &str = "";
|
||||
|
||||
fn gui_asset_name() -> Option<String> {
|
||||
fn gui_asset_name(variant: gpapi::gui::GuiVariant) -> Option<String> {
|
||||
if variant == gpapi::gui::GuiVariant::Nsh {
|
||||
return nsh_asset_name_for(std::env::consts::OS, std::env::consts::ARCH);
|
||||
}
|
||||
gui_asset_name_for(std::env::consts::OS, std::env::consts::ARCH, GUI_LIBC_SUFFIX)
|
||||
}
|
||||
|
||||
fn nsh_asset_name_for(os: &str, arch: &str) -> Option<String> {
|
||||
match (os, arch) {
|
||||
("linux", "x86_64" | "aarch64") => Some(format!("gpgui-nsh_{arch}.bin.tar.xz")),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn gui_asset_name_for(os: &str, arch: &str, libc_suffix: &str) -> Option<String> {
|
||||
let name = match (os, arch) {
|
||||
("linux", "x86_64" | "aarch64") => format!("gpgui_{arch}{libc_suffix}.bin.tar.xz"),
|
||||
@@ -97,10 +107,11 @@ impl Installer {
|
||||
Self { command_tx }
|
||||
}
|
||||
|
||||
async fn install(&self, path: &str, checksum: &str) -> anyhow::Result<()> {
|
||||
async fn install(&self, path: &str, checksum: &str, variant: gpapi::gui::GuiVariant) -> anyhow::Result<()> {
|
||||
let request = UpdateGuiRequest {
|
||||
path: path.to_string(),
|
||||
checksum: checksum.to_string(),
|
||||
variant,
|
||||
};
|
||||
let (reply, result) = oneshot::channel();
|
||||
self
|
||||
@@ -363,6 +374,7 @@ async fn receive_binary(socket: &mut Socket) -> anyhow::Result<Vec<u8>> {
|
||||
|
||||
pub struct GuiUpdater {
|
||||
version: String,
|
||||
variant: gpapi::gui::GuiVariant,
|
||||
notifier: Arc<ProgressNotifier>,
|
||||
installer: Installer,
|
||||
in_progress: RwLock<bool>,
|
||||
@@ -370,9 +382,15 @@ pub struct GuiUpdater {
|
||||
}
|
||||
|
||||
impl GuiUpdater {
|
||||
pub fn new(version: String, notifier: ProgressNotifier, installer: Installer) -> Self {
|
||||
pub fn new(
|
||||
version: String,
|
||||
notifier: ProgressNotifier,
|
||||
installer: Installer,
|
||||
variant: gpapi::gui::GuiVariant,
|
||||
) -> Self {
|
||||
Self {
|
||||
version,
|
||||
variant,
|
||||
notifier: Arc::new(notifier),
|
||||
installer,
|
||||
in_progress: Default::default(),
|
||||
@@ -381,7 +399,7 @@ impl GuiUpdater {
|
||||
}
|
||||
|
||||
pub async fn update(&self) {
|
||||
let Some(asset_name) = gui_asset_name() else {
|
||||
let Some(asset_name) = gui_asset_name(self.variant) else {
|
||||
info!("GUI updates are not supported on this platform.");
|
||||
return;
|
||||
};
|
||||
@@ -438,7 +456,7 @@ impl GuiUpdater {
|
||||
|
||||
info!("Checksum success");
|
||||
|
||||
if let Err(err) = self.installer.install(&file_path, &checksum).await {
|
||||
if let Err(err) = self.installer.install(&file_path, &checksum, self.variant).await {
|
||||
warn!("Install error: {}", err);
|
||||
self.notify_error();
|
||||
} else {
|
||||
@@ -488,13 +506,10 @@ impl GuiUpdater {
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use gpapi::{
|
||||
os_profile::HostIdentity,
|
||||
service::{
|
||||
transport::{ClientPrelude, NoiseResponder},
|
||||
vpn_env::{HostInfo, VpnEnv},
|
||||
vpn_state::VpnState,
|
||||
},
|
||||
use gpapi::service::{
|
||||
transport::{ClientPrelude, NoiseResponder},
|
||||
vpn_env::{HostInfo, VpnEnv},
|
||||
vpn_state::VpnState,
|
||||
};
|
||||
use tokio::net::TcpListener;
|
||||
use tokio_tungstenite::accept_async;
|
||||
@@ -522,6 +537,21 @@ mod tests {
|
||||
assert_eq!(gui_asset_name_for("macos", "aarch64", ""), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn nsh_assets_are_linux_only_and_use_the_nsh_binary_archive() {
|
||||
assert_eq!(
|
||||
nsh_asset_name_for("linux", "x86_64"),
|
||||
Some("gpgui-nsh_x86_64.bin.tar.xz".into())
|
||||
);
|
||||
assert_eq!(
|
||||
nsh_asset_name_for("linux", "aarch64"),
|
||||
Some("gpgui-nsh_aarch64.bin.tar.xz".into())
|
||||
);
|
||||
for os in ["freebsd", "openbsd", "macos"] {
|
||||
assert_eq!(nsh_asset_name_for(os, "x86_64"), None);
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn pending_install_reconnects_with_a_fresh_handshake() {
|
||||
let credential = Arc::new(SessionCredential::generate(Uuid::new_v4(), env!("CARGO_PKG_VERSION")).unwrap());
|
||||
@@ -532,6 +562,7 @@ mod tests {
|
||||
request: UpdateGuiRequest {
|
||||
path: "/tmp/gpgui-update".to_owned(),
|
||||
checksum: "checksum".to_owned(),
|
||||
variant: gpapi::gui::GuiVariant::Tauri,
|
||||
},
|
||||
reply: reply_tx,
|
||||
})
|
||||
|
||||
@@ -17,7 +17,9 @@ use tokio::io::unix::AsyncFd;
|
||||
use tokio_util::sync::CancellationToken;
|
||||
|
||||
use crate::session_registry::SessionRegistry;
|
||||
use gpapi::service::transport::{DESKTOP_GUI_EXITED, DESKTOP_RENDERING_RETRY};
|
||||
use gpapi::service::transport::{
|
||||
DESKTOP_GUI_EXITED, DESKTOP_RENDERING_RETRY, DESKTOP_SWITCH_BEGIN, DESKTOP_SWITCH_CANCEL, DESKTOP_SWITCH_COMMIT,
|
||||
};
|
||||
|
||||
/// Private parent/service pipes; credentials never pass through argv, environment or files.
|
||||
pub(crate) struct DesktopClient {
|
||||
@@ -62,15 +64,38 @@ impl DesktopClient {
|
||||
let mut rendering_renewed = false;
|
||||
loop {
|
||||
let credential = registry.issue(env!("CARGO_PKG_VERSION"), Some(uid))?;
|
||||
let session_id = credential.session_id();
|
||||
let mut session_id = credential.session_id();
|
||||
let mut pending = None;
|
||||
let result = tokio::select! {
|
||||
_ = cancel.cancelled() => Ok(None),
|
||||
result = async {
|
||||
self.write_frame(&credential.encode_frame()?).await?;
|
||||
self.gui_exited().await
|
||||
loop {
|
||||
match self.gui_exited().await? {
|
||||
Some(DESKTOP_SWITCH_BEGIN) => {
|
||||
ensure!(pending.is_none(), "A GUI switch is already pending");
|
||||
let credential = registry.issue(env!("CARGO_PKG_VERSION"), Some(uid))?;
|
||||
pending = Some(credential.session_id());
|
||||
self.write_frame(&credential.encode_frame()?).await?;
|
||||
}
|
||||
Some(DESKTOP_SWITCH_COMMIT) => {
|
||||
let replacement = pending.take().context("No GUI switch is pending")?;
|
||||
registry.revoke(session_id);
|
||||
session_id = replacement;
|
||||
}
|
||||
Some(DESKTOP_SWITCH_CANCEL) => {
|
||||
let replacement = pending.take().context("No GUI switch is pending")?;
|
||||
registry.revoke(replacement);
|
||||
}
|
||||
message => break Ok(message),
|
||||
}
|
||||
}
|
||||
} => result,
|
||||
};
|
||||
registry.revoke(session_id);
|
||||
if let Some(session_id) = pending {
|
||||
registry.revoke(session_id);
|
||||
}
|
||||
let requested = restart.swap(false, Ordering::SeqCst);
|
||||
match result? {
|
||||
None => return Ok(()),
|
||||
@@ -253,6 +278,39 @@ mod tests {
|
||||
assert!(registry.last_successful_hip_report(issued.session_id()).is_err());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn switch_cancel_preserves_current_session_and_commit_replaces_it() {
|
||||
let (channel, control, reader) = pipes();
|
||||
let registry = Arc::new(SessionRegistry::for_tests(uuid::Uuid::new_v4()));
|
||||
let task = tokio::spawn(channel.serve(
|
||||
registry.clone(),
|
||||
1000,
|
||||
Arc::new(AtomicBool::new(false)),
|
||||
CancellationToken::new(),
|
||||
));
|
||||
let (reader, first) = credential(reader).await;
|
||||
write(&control, &[DESKTOP_SWITCH_BEGIN]).unwrap();
|
||||
let (reader, cancelled) = credential(reader).await;
|
||||
assert_ne!(first.session_id(), cancelled.session_id());
|
||||
assert!(registry.last_successful_hip_report(first.session_id()).is_ok());
|
||||
write(&control, &[DESKTOP_SWITCH_CANCEL, DESKTOP_SWITCH_BEGIN]).unwrap();
|
||||
let (reader, replacement) = credential(reader).await;
|
||||
assert!(registry.last_successful_hip_report(cancelled.session_id()).is_err());
|
||||
assert!(registry.last_successful_hip_report(first.session_id()).is_ok());
|
||||
write(&control, &[DESKTOP_SWITCH_COMMIT, DESKTOP_SWITCH_BEGIN]).unwrap();
|
||||
let (_, pending) = credential(reader).await;
|
||||
assert!(registry.last_successful_hip_report(first.session_id()).is_err());
|
||||
assert!(registry.last_successful_hip_report(replacement.session_id()).is_ok());
|
||||
drop(control);
|
||||
tokio::time::timeout(Duration::from_secs(1), task)
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
assert!(registry.last_successful_hip_report(replacement.session_id()).is_err());
|
||||
assert!(registry.last_successful_hip_report(pending.session_id()).is_err());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn desktop_channel_rejects_invalid_control_messages_and_revokes() {
|
||||
let (channel, control, reader) = pipes();
|
||||
|
||||
@@ -6,7 +6,6 @@ use std::{
|
||||
sync::{Arc, atomic::AtomicBool},
|
||||
};
|
||||
|
||||
use common::binary_paths;
|
||||
use gpapi::{
|
||||
service::{
|
||||
request::{UpdateGuiRequest, UpdateLogLevelRequest, WsRequest},
|
||||
@@ -299,10 +298,17 @@ impl RequestDispatcher {
|
||||
}
|
||||
|
||||
async fn update_gui(&self, request: UpdateGuiRequest) -> ServiceResult {
|
||||
if request.variant == gpapi::gui::GuiVariant::Nsh && !cfg!(target_os = "linux") {
|
||||
return ServiceResult::rejected(
|
||||
ServiceErrorCode::InvalidRequest,
|
||||
"Native Shell is available only on Linux",
|
||||
);
|
||||
}
|
||||
let _install = self.install_lock.lock().await;
|
||||
let path = request.path;
|
||||
let checksum = request.checksum;
|
||||
let installed = tokio::task::spawn_blocking(move || install_gui(&path, &checksum)).await;
|
||||
let target = request.variant.update_target();
|
||||
let installed = tokio::task::spawn_blocking(move || install_gui_at(Path::new(&path), &checksum, &target)).await;
|
||||
match installed {
|
||||
Ok(Ok(())) => ServiceResult::Accepted,
|
||||
Ok(Err(GuiInstallError::Checksum(err))) => {
|
||||
@@ -327,10 +333,6 @@ enum GuiInstallError {
|
||||
Install(anyhow::Error),
|
||||
}
|
||||
|
||||
fn install_gui(src: &str, checksum: &str) -> Result<(), GuiInstallError> {
|
||||
install_gui_at(Path::new(src), checksum, &binary_paths::gpgui_update_target())
|
||||
}
|
||||
|
||||
fn install_gui_at(src: &Path, checksum: &str, target: &Path) -> Result<(), GuiInstallError> {
|
||||
let Some(dir) = target.parent() else {
|
||||
return Err(GuiInstallError::Install(anyhow::anyhow!(
|
||||
@@ -350,7 +352,8 @@ fn install_gui_at(src: &Path, checksum: &str, target: &Path) -> Result<(), GuiIn
|
||||
))
|
||||
.take(MAX_GUI_ARCHIVE_CONTENT_SIZE);
|
||||
let mut archive = Archive::new(tar);
|
||||
let file = extract_gui_binary(&mut archive, dir)?;
|
||||
let binary_name = target.file_name().and_then(|name| name.to_str()).unwrap_or("gpgui");
|
||||
let file = extract_gui_binary(&mut archive, dir, binary_name)?;
|
||||
file
|
||||
.as_file()
|
||||
.set_permissions(Permissions::from_mode(0o755))
|
||||
@@ -398,14 +401,18 @@ fn stage_gui_archive(src: &Path, dir: &Path) -> Result<NamedTempFile, GuiInstall
|
||||
Ok(staged)
|
||||
}
|
||||
|
||||
fn extract_gui_binary<R: Read>(archive: &mut Archive<R>, dir: &Path) -> Result<NamedTempFile, GuiInstallError> {
|
||||
fn extract_gui_binary<R: Read>(
|
||||
archive: &mut Archive<R>,
|
||||
dir: &Path,
|
||||
binary_name: &str,
|
||||
) -> Result<NamedTempFile, GuiInstallError> {
|
||||
for entry in archive.entries().map_err(|err| GuiInstallError::Install(err.into()))? {
|
||||
let mut entry = entry.map_err(|err| GuiInstallError::Install(err.into()))?;
|
||||
let is_gui = entry
|
||||
.path()
|
||||
.map_err(|err| GuiInstallError::Install(err.into()))?
|
||||
.file_name()
|
||||
.is_some_and(|name| name == "gpgui");
|
||||
.is_some_and(|name| name == binary_name);
|
||||
if is_gui && entry.header().entry_type().is_file() {
|
||||
let declared_size = entry.size();
|
||||
if declared_size == 0 || declared_size > MAX_GUI_BINARY_SIZE {
|
||||
@@ -425,7 +432,7 @@ fn extract_gui_binary<R: Read>(archive: &mut Archive<R>, dir: &Path) -> Result<N
|
||||
}
|
||||
}
|
||||
Err(GuiInstallError::Install(anyhow::anyhow!(
|
||||
"GUI update archive does not contain a non-empty regular gpgui file"
|
||||
"GUI update archive does not contain a non-empty regular {binary_name} file"
|
||||
)))
|
||||
}
|
||||
|
||||
@@ -475,7 +482,7 @@ mod tests {
|
||||
for (entry_type, contents) in [(EntryType::Directory, &[][..]), (EntryType::Regular, &[][..])] {
|
||||
let data = archive_with_entry(entry_type, contents);
|
||||
let mut archive = Archive::new(Cursor::new(data));
|
||||
assert!(extract_gui_binary(&mut archive, output.path()).is_err());
|
||||
assert!(extract_gui_binary(&mut archive, output.path(), "gpgui").is_err());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -484,7 +491,7 @@ mod tests {
|
||||
let output = tempfile::tempdir().unwrap();
|
||||
let data = archive_with_entry(EntryType::Regular, b"gui binary");
|
||||
let mut archive = Archive::new(Cursor::new(data));
|
||||
let extracted = extract_gui_binary(&mut archive, output.path()).unwrap();
|
||||
let extracted = extract_gui_binary(&mut archive, output.path(), "gpgui").unwrap();
|
||||
let contents = std::fs::read(extracted.path()).unwrap();
|
||||
assert_eq!(contents, b"gui binary");
|
||||
}
|
||||
@@ -515,7 +522,7 @@ mod tests {
|
||||
data.resize(512 * 3, 0);
|
||||
|
||||
let mut archive = Archive::new(Cursor::new(data));
|
||||
assert!(extract_gui_binary(&mut archive, output.path()).is_err());
|
||||
assert!(extract_gui_binary(&mut archive, output.path(), "gpgui").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -531,6 +538,33 @@ mod tests {
|
||||
assert_eq!(std::fs::metadata(&target).unwrap().permissions().mode() & 0o777, 0o755);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn installs_nsh_beside_tauri_without_replacing_it() {
|
||||
let output = tempfile::tempdir().unwrap();
|
||||
let tauri = output.path().join("gpgui");
|
||||
std::fs::write(&tauri, b"tauri").unwrap();
|
||||
let mut encoder = XzEncoder::new(Vec::new(), 1);
|
||||
{
|
||||
let mut archive = Builder::new(&mut encoder);
|
||||
let mut header = Header::new_gnu();
|
||||
header.set_size(3);
|
||||
header.set_mode(0o755);
|
||||
header.set_cksum();
|
||||
archive
|
||||
.append_data(&mut header, "gpgui-nsh_3.2.0/gpgui-nsh", &b"nsh"[..])
|
||||
.unwrap();
|
||||
archive.finish().unwrap();
|
||||
}
|
||||
let mut archive = NamedTempFile::new().unwrap();
|
||||
archive.write_all(&encoder.finish().unwrap()).unwrap();
|
||||
archive.flush().unwrap();
|
||||
let checksum = gpapi::utils::checksum::file_sha256(archive.path()).unwrap();
|
||||
let nsh = output.path().join("gpgui-nsh");
|
||||
install_gui_at(archive.path(), &checksum, &nsh).unwrap();
|
||||
assert_eq!(std::fs::read(nsh).unwrap(), b"nsh");
|
||||
assert_eq!(std::fs::read(tauri).unwrap(), b"tauri");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn checksum_failure_preserves_the_existing_gui() {
|
||||
let archive = compressed_gui_archive(b"replacement");
|
||||
|
||||
@@ -763,6 +763,7 @@ mod tests {
|
||||
request: WsRequest::UpdateGui(UpdateGuiRequest {
|
||||
path: update_file.path().to_string_lossy().into_owned(),
|
||||
checksum: "invalid".to_owned(),
|
||||
variant: gpapi::gui::GuiVariant::Tauri,
|
||||
}),
|
||||
};
|
||||
socket
|
||||
|
||||
Reference in new issue
Block a user