diff --git a/Cargo.lock b/Cargo.lock index 5b36274..8101db5 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2131,6 +2131,7 @@ dependencies = [ "getrandom 0.4.3", "gtk", "humantime", + "libloading 0.9.0", "log", "log-reload", "md5", @@ -3093,7 +3094,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6e9ec52138abedcc58dc17a7c6c0c00a2bdb4f3427c7f63fa97fd0d859155caf" dependencies = [ "gtk-sys", - "libloading", + "libloading 0.7.4", "once_cell", ] @@ -3122,6 +3123,16 @@ dependencies = [ "winapi", ] +[[package]] +name = "libloading" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "754ca22de805bb5744484a5b151a9e1a8e837d5dc232c2d7d8c2e3492edc8b60" +dependencies = [ + "cfg-if", + "windows-link", +] + [[package]] name = "libm" version = "0.2.16" diff --git a/README.md b/README.md index 83a47d5..4469c53 100644 --- a/README.md +++ b/README.md @@ -127,6 +127,8 @@ GP Connect provides a desktop interface for managing VPN connections. On macOS, gpclient launch-gui ``` +On Linux, switching to Native Shell checks for GTK 4.14 or later, GnuTLS 3, and D-Bus before offering a download. If a required runtime is missing or too old, the current interface stays open. Nix packages with the GUI installer supply these dependencies during installation instead. + > [!Note] > > The GUI version is partially open source. The background service ([gpservice](./apps/gpservice/)) is open source, while the GUI wrapper is proprietary. @@ -352,6 +354,14 @@ nix build "git+file://$PWD?submodules=1#fromSource" Local source builds require initialized Git submodules and a flake URL with `submodules=1`, as shown above. For a remote source flake, use a Git URL with submodules enabled, such as `git+https://github.com/yuezk/GlobalProtect-openconnect?submodules=1#fromSource`. The `prebuilt` package and NixOS module do not require Git submodules. Build output (`target`, `.build`, and `node_modules`) is excluded from the source input. Updating release asset hashes changes the prebuilt package, independently of source builds. +Source builds also support downloading either desktop interface on NixOS. The +downloader packages the verified Tauri or Native Shell archive with Nix, including +its runtime libraries. Each installed interface has a garbage-collection root +under `/var/lib/gpclient/nix-gui`, so its dependencies remain available after +system upgrades. No Rust compilation or NixOS rebuild is needed for GUI downloads. +Prebuilt packages gain this support when their release includes the updated +service; adding the flake installer alone does not change older service binaries. + ### Official Docker Image The [official Docker image](https://hub.docker.com/r/yuezk/globalprotect-openconnect) provides the CLI tools on Alpine Linux: diff --git a/apps/gpservice/src/desktop_client.rs b/apps/gpservice/src/desktop_client.rs index 8fc9a4b..40c571e 100644 --- a/apps/gpservice/src/desktop_client.rs +++ b/apps/gpservice/src/desktop_client.rs @@ -18,7 +18,8 @@ use tokio_util::sync::CancellationToken; use crate::session_registry::SessionRegistry; use gpapi::service::transport::{ - DESKTOP_GUI_EXITED, DESKTOP_RENDERING_RETRY, DESKTOP_SWITCH_BEGIN, DESKTOP_SWITCH_CANCEL, DESKTOP_SWITCH_COMMIT, + DESKTOP_GUI_EXITED, DESKTOP_GUI_INSTALLER, DESKTOP_RENDERING_RETRY, DESKTOP_SWITCH_BEGIN, DESKTOP_SWITCH_CANCEL, + DESKTOP_SWITCH_COMMIT, }; /// Private parent/service pipes; credentials never pass through argv, environment or files. @@ -69,14 +70,17 @@ impl DesktopClient { let result = tokio::select! { _ = cancel.cancelled() => Ok(None), result = async { - self.write_frame(&credential.encode_frame()?).await?; + self.write_all(&credential.encode_frame()?).await?; loop { - match self.gui_exited().await? { + match self.read_control().await? { + Some(DESKTOP_GUI_INSTALLER) => { + self.write_all(&[u8::from(crate::request_dispatcher::gui_installer().is_some())]).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?; + self.write_all(&credential.encode_frame()?).await?; } Some(DESKTOP_SWITCH_COMMIT) => { let replacement = pending.take().context("No GUI switch is pending")?; @@ -110,7 +114,7 @@ impl DesktopClient { } } - async fn write_frame(&self, mut bytes: &[u8]) -> anyhow::Result<()> { + async fn write_all(&self, mut bytes: &[u8]) -> anyhow::Result<()> { while !bytes.is_empty() { let mut ready = self.output.writable().await?; match ready.try_io(|fd| write(fd.get_ref(), bytes).map_err(io::Error::from)) { @@ -125,7 +129,7 @@ impl DesktopClient { Ok(()) } - async fn gui_exited(&self) -> anyhow::Result> { + async fn read_control(&self) -> anyhow::Result> { loop { let mut ready = self.input.readable().await?; let mut byte = [0]; @@ -170,7 +174,7 @@ mod tests { .unwrap() .success() ); - channel.write_frame(b"PRIVATE_FRAME").await.unwrap(); + channel.write_all(b"PRIVATE_FRAME").await.unwrap(); } use gpapi::service::transport::SessionCredential; use nix::unistd::pipe; @@ -289,6 +293,21 @@ mod tests { CancellationToken::new(), )); let (reader, first) = credential(reader).await; + write(&control, &[DESKTOP_GUI_INSTALLER]).unwrap(); + let reader = tokio::task::spawn_blocking(move || { + let mut reader = reader; + let mut capability = [0]; + reader.read_exact(&mut capability).unwrap(); + assert_eq!( + capability[0], + u8::from(crate::request_dispatcher::gui_installer().is_some()) + ); + reader + }) + .await + .unwrap(); + // A capability query leaves the current session intact and the next frame readable. + assert!(registry.last_successful_hip_report(first.session_id()).is_ok()); write(&control, &[DESKTOP_SWITCH_BEGIN]).unwrap(); let (reader, cancelled) = credential(reader).await; assert_ne!(first.session_id(), cancelled.session_id()); diff --git a/apps/gpservice/src/request_dispatcher.rs b/apps/gpservice/src/request_dispatcher.rs index b6fd574..7043f10 100644 --- a/apps/gpservice/src/request_dispatcher.rs +++ b/apps/gpservice/src/request_dispatcher.rs @@ -333,7 +333,29 @@ enum GuiInstallError { Install(anyhow::Error), } +pub(crate) fn gui_installer() -> Option { + std::env::current_exe() + .ok() + .and_then(|executable| { + executable + .parent()? + .parent() + .map(|prefix| prefix.join("libexec/gpclient/gp-gui-installer")) + }) + .filter(|path| path.is_file()) +} + fn install_gui_at(src: &Path, checksum: &str, target: &Path) -> Result<(), GuiInstallError> { + let installer = gui_installer(); + install_gui_with_installer(src, checksum, target, installer.as_deref()) +} + +fn install_gui_with_installer( + src: &Path, + checksum: &str, + target: &Path, + installer: Option<&Path>, +) -> Result<(), GuiInstallError> { let Some(dir) = target.parent() else { return Err(GuiInstallError::Install(anyhow::anyhow!( "Failed to get parent directory of GUI binary" @@ -345,6 +367,26 @@ fn install_gui_at(src: &Path, checksum: &str, target: &Path) -> Result<(), GuiIn let archive_path = staged_archive.path().to_string_lossy(); verify_checksum(&archive_path, checksum).map_err(GuiInstallError::Checksum)?; + // A package may need to prepare downloaded executables for its runtime. + // Resolve this helper beside the running service, never from the request or PATH. + if let Some(installer) = installer { + let status = std::process::Command::new(installer) + .arg(staged_archive.path()) + .arg(checksum) + .arg(target) + .stdin(std::process::Stdio::null()) + .stdout(std::process::Stdio::null()) + .status() + .map_err(|err| GuiInstallError::Install(err.into()))?; + return if status.success() { + Ok(()) + } else { + Err(GuiInstallError::Install(anyhow::anyhow!( + "GUI package installation failed: {status}" + ))) + }; + } + let tar = XzDecoder::new(BufReader::new( staged_archive .reopen() @@ -577,6 +619,41 @@ mod tests { assert_eq!(std::fs::read(target).unwrap(), b"existing"); } + #[test] + fn package_installer_receives_a_verified_staged_archive() { + let archive = compressed_gui_archive(b"gui binary"); + let checksum = gpapi::utils::checksum::file_sha256(archive.path()).unwrap(); + let output = tempfile::tempdir().unwrap(); + let target = output.path().join("gpgui-nsh"); + let installer = output.path().join("installer"); + std::fs::write( + &installer, + "#!/bin/sh\nset -eu\ntest -f \"$1\"\nprintf '%s' \"$2\" > \"$3\"\n", + ) + .unwrap(); + std::fs::set_permissions(&installer, Permissions::from_mode(0o755)).unwrap(); + + assert!(install_gui_with_installer(archive.path(), "invalid", &target, Some(&installer)).is_err()); + assert!(!target.exists()); + install_gui_with_installer(archive.path(), &checksum, &target, Some(&installer)).unwrap(); + assert_eq!(std::fs::read_to_string(target).unwrap(), checksum); + } + + #[test] + fn package_installation_failure_preserves_the_existing_gui() { + let archive = compressed_gui_archive(b"replacement"); + let checksum = gpapi::utils::checksum::file_sha256(archive.path()).unwrap(); + let output = tempfile::tempdir().unwrap(); + let target = output.path().join("gpgui"); + std::fs::write(&target, b"existing").unwrap(); + let installer = output.path().join("installer"); + std::fs::write(&installer, "#!/bin/sh\nexit 1\n").unwrap(); + std::fs::set_permissions(&installer, Permissions::from_mode(0o755)).unwrap(); + + assert!(install_gui_with_installer(archive.path(), &checksum, &target, Some(&installer)).is_err()); + assert_eq!(std::fs::read(target).unwrap(), b"existing"); + } + #[tokio::test] async fn brokered_mode_rejects_gui_management_and_root_readable_identity_paths() { let dispatcher = RequestDispatcher::new( diff --git a/crates/gpapi/Cargo.toml b/crates/gpapi/Cargo.toml index db668b4..238e293 100644 --- a/crates/gpapi/Cargo.toml +++ b/crates/gpapi/Cargo.toml @@ -63,18 +63,22 @@ oslog = { version = "0.2", default-features = false, optional = true } [target.'cfg(not(any(target_os="macos", target_os="windows")))'.dependencies] gtk = { version = "0.18", optional = true } +[target.'cfg(target_os="linux")'.dependencies] +libloading = { version = "0.9", optional = true } + [build-dependencies] cc = "1" pkg-config = "0.3" [dev-dependencies] openssl.workspace = true +libloading = "0.9" proptest.workspace = true tokio = { workspace = true, features = ["test-util"] } [features] default = ["desktop"] -desktop = ["tokio/process", "tokio/signal", "dep:directories", "dep:nix", "dep:uzers", "dep:netdev", "dep:os_info", "dep:whoami", "dep:dns-lookup", "dep:socket2"] +desktop = ["tokio/process", "tokio/signal", "dep:directories", "dep:nix", "dep:uzers", "dep:netdev", "dep:os_info", "dep:whoami", "dep:dns-lookup", "dep:socket2", "dep:libloading"] tauri = ["desktop", "dep:tauri", "dep:gtk"] clap = ["desktop", "dep:clap", "dep:clap-verbosity-flag"] webview-auth = [] diff --git a/crates/gpapi/src/process/gui_launcher.rs b/crates/gpapi/src/process/gui_launcher.rs index 6dd6052..fa13848 100644 --- a/crates/gpapi/src/process/gui_launcher.rs +++ b/crates/gpapi/src/process/gui_launcher.rs @@ -181,6 +181,18 @@ impl<'a> GuiLauncher<'a> { let variant = selection.variant; let candidate = Self::new(self.version, self.credential.clone(), variant).envs(self.envs.clone()); let program = candidate.find_compatible_program(cancellation).await?; + if program.is_none() && variant == crate::gui::GuiVariant::Nsh { + use crate::service::transport::DESKTOP_GUI_INSTALLER; + service_input.write_all(&[DESKTOP_GUI_INSTALLER]).await?; + let supplies_runtime = match service_output.read_u8().await? { + 0 => false, + 1 => true, + _ => anyhow::bail!("Invalid GUI installer capability response"), + }; + if !supplies_runtime { + super::nsh_runtime::check()?; + } + } if program.is_none() && !selection.allow_download { gui_switch::reply(&mut socket, Ok(GuiSwitchOutcome::DownloadRequired)).await?; return Ok(None); @@ -486,11 +498,21 @@ mod tests { #[test] #[cfg(target_os = "linux")] fn supervisor_switch_success_and_failure_preserve_child_ownership() { - for scenario in ["success", "failure", "missing", "incompatible"] { + for scenario in [ + "success", + "failure", + "missing", + "incompatible", + "runtime-too-old", + "runtime-too-old-confirmed", + ] { let directory = TempDir::new().unwrap(); let executable = std::env::current_exe().unwrap(); + // An old host GTK must block generic downloads, but not package-managed downloads. + let gtk = super::super::nsh_runtime::tests::gtk_fixture(directory.path(), 12); + fs::rename(gtk, directory.path().join("libgtk-4.so.1")).unwrap(); for name in ["gpgui", "gpgui-nsh"] { - if scenario == "missing" && name == "gpgui-nsh" { + if (scenario == "missing" || scenario.starts_with("runtime-too-old")) && name == "gpgui-nsh" { continue; } let version = if scenario == "incompatible" && name == "gpgui-nsh" { @@ -515,6 +537,7 @@ mod tests { .env("GP_SWITCH_SCENARIO", scenario) .env("GP_SWITCH_DIRECTORY", directory.path()) .env("GP_GUI_BINARY", directory.path().join("gpgui")) + .env("LD_LIBRARY_PATH", directory.path()) .env("XDG_CONFIG_HOME", directory.path().join("config")) .output() .unwrap(); @@ -629,12 +652,15 @@ mod tests { #[ignore = "subprocess supervisor fixture with isolated GUI paths and preferences"] #[cfg(target_os = "linux")] async fn supervisor_fixture() { - use crate::service::transport::{DESKTOP_SWITCH_BEGIN, DESKTOP_SWITCH_CANCEL, DESKTOP_SWITCH_COMMIT}; + use crate::service::transport::{ + DESKTOP_GUI_INSTALLER, DESKTOP_SWITCH_BEGIN, DESKTOP_SWITCH_CANCEL, DESKTOP_SWITCH_COMMIT, + }; use tokio::io::{AsyncReadExt, AsyncWriteExt}; let directory = PathBuf::from(std::env::var_os("GP_SWITCH_DIRECTORY").unwrap()); let scenario = std::env::var("GP_SWITCH_SCENARIO").unwrap(); let success = scenario == "success"; let download_required = matches!(scenario.as_str(), "missing" | "incompatible"); + let runtime_too_old = scenario.starts_with("runtime-too-old"); let listener = super::super::gui_switch::SwitchListener::new().unwrap(); let (mut service_input, mut control) = tokio::io::duplex(64); let (mut service_output, mut credentials) = tokio::io::duplex(2048); @@ -643,6 +669,9 @@ mod tests { loop { let message = control.read_u8().await.unwrap(); match message { + DESKTOP_GUI_INSTALLER => { + credentials.write_all(&[u8::from(!runtime_too_old)]).await.unwrap(); + } DESKTOP_SWITCH_BEGIN => { fs::write(&service_marker, "").unwrap(); let credential = SessionCredential::generate(Uuid::new_v4(), VERSION).unwrap(); @@ -676,23 +705,21 @@ mod tests { &listener.path(), crate::gui::GuiSwitchRequest { variant: crate::gui::GuiVariant::Nsh, - allow_download: false, + allow_download: scenario == "runtime-too-old-confirmed", }, ) .await; - if download_required { + if runtime_too_old { + let error = result.unwrap_err().to_string(); + anyhow::ensure!( + error.contains("4.14") && error.contains("4.12.1"), + "Unexpected runtime error: {error}" + ); + } else if download_required { anyhow::ensure!( result? == crate::gui::GuiSwitchOutcome::DownloadRequired, "Missing download confirmation" ); - anyhow::ensure!( - !directory.join("service-switch-started").exists(), - "Download check changed the service session" - ); - anyhow::ensure!( - !directory.join("gpgui-nsh-started").exists(), - "Download check launched the replacement" - ); } else { anyhow::ensure!(result.is_ok() == success, "Unexpected switch result: {result:?}"); if success { @@ -702,6 +729,16 @@ mod tests { ); } } + if download_required || runtime_too_old { + anyhow::ensure!( + !directory.join("service-switch-started").exists(), + "Download check changed the service session" + ); + anyhow::ensure!( + !directory.join("gpgui-nsh-started").exists(), + "Download check launched the replacement" + ); + } anyhow::ensure!( !directory.join("gpgui-exited").exists(), "Current GUI exited before acknowledgement" diff --git a/crates/gpapi/src/process/mod.rs b/crates/gpapi/src/process/mod.rs index cd19410..d00737c 100644 --- a/crates/gpapi/src/process/mod.rs +++ b/crates/gpapi/src/process/mod.rs @@ -11,6 +11,8 @@ pub mod desktop_launcher; pub mod gui_launcher; #[cfg(target_os = "linux")] pub mod gui_switch; +#[cfg(any(target_os = "linux", test))] +mod nsh_runtime; pub mod users; pub mod collection; diff --git a/crates/gpapi/src/process/nsh_runtime.rs b/crates/gpapi/src/process/nsh_runtime.rs new file mode 100644 index 0000000..8c875ef --- /dev/null +++ b/crates/gpapi/src/process/nsh_runtime.rs @@ -0,0 +1,105 @@ +//! Checks the generic Linux NSH runtime before offering a download. +//! Runs in the desktop supervisor, which does not load either GUI's GTK runtime. +use std::{ffi::OsStr, os::raw::c_uint}; + +use anyhow::{Context, ensure}; +use libloading::{ + Library, + os::unix::{RTLD_LOCAL, RTLD_NOW}, +}; + +// Match nsh-platform-linux's gtk4/v4_14 feature when changing the NSH build. +const MIN_GTK_MINOR: u32 = 14; + +#[cfg(target_os = "linux")] +pub(super) fn check() -> anyhow::Result<()> { + check_gtk(OsStr::new("libgtk-4.so.1"))?; + load_library(OsStr::new("libgnutls.so.30"), "GnuTLS 3")?; + load_library(OsStr::new("libdbus-1.so.3"), "D-Bus")?; + Ok(()) +} + +fn load_library(path: &OsStr, name: &str) -> anyhow::Result { + // Resolve symbols now as well as transitive dependencies, without initializing GTK. + let library = unsafe { libloading::os::unix::Library::open(Some(path), RTLD_LOCAL | RTLD_NOW) }; + library.map(Into::into).map_err(|error| { + log::warn!("Native Shell runtime check failed for {name}: {error}"); + anyhow::anyhow!("Native Shell could not load {name}. Install its runtime libraries and try again.") + }) +} + +fn check_gtk(path: &OsStr) -> anyhow::Result<()> { + let library = load_library(path, "GTK 4.14 or later")?; + type Version = unsafe extern "C" fn() -> c_uint; + // These public GTK getters take no arguments and do not initialize a display. + let (major, minor, micro) = unsafe { + let major = library.get::(b"gtk_get_major_version\0"); + let minor = library.get::(b"gtk_get_minor_version\0"); + let micro = library.get::(b"gtk_get_micro_version\0"); + let message = "Native Shell requires GTK 4.14 or later. Update GTK 4 and try again."; + ( + major.context(message)?(), + minor.context(message)?(), + micro.context(message)?(), + ) + }; + ensure!( + major == 4 && minor >= MIN_GTK_MINOR, + "Native Shell requires GTK 4.14 or later. This system has GTK {major}.{minor}.{micro}." + ); + Ok(()) +} + +#[cfg(test)] +pub(super) mod tests { + use super::*; + use std::{fs, process::Command}; + + pub(in crate::process) fn gtk_fixture(directory: &std::path::Path, minor: u32) -> std::path::PathBuf { + let source = directory.join(format!("gtk-{minor}.c")); + let library = directory.join(format!("gtk-{minor}.so")); + fs::write( + &source, + format!( + "unsigned gtk_get_major_version(void) {{ return 4; }}\n\ + unsigned gtk_get_minor_version(void) {{ return {minor}; }}\n\ + unsigned gtk_get_micro_version(void) {{ return 1; }}\n" + ), + ) + .unwrap(); + assert!( + Command::new("cc") + .args(["-shared", "-fPIC"]) + .arg(source) + .arg("-o") + .arg(&library) + .status() + .unwrap() + .success() + ); + library + } + + #[test] + fn loads_runtime_version_without_development_metadata_or_a_display() { + let directory = tempfile::tempdir().unwrap(); + let old = gtk_fixture(directory.path(), 12); + let supported = gtk_fixture(directory.path(), 14); + let newer = gtk_fixture(directory.path(), 20); + let error = check_gtk(old.as_os_str()).unwrap_err().to_string(); + assert!(error.contains("4.14"), "{error}"); + assert!(error.contains("4.12.1"), "{error}"); + check_gtk(supported.as_os_str()).unwrap(); + check_gtk(newer.as_os_str()).unwrap(); + } + + #[test] + fn missing_runtime_reports_an_actionable_error() { + let directory = tempfile::tempdir().unwrap(); + let error = check_gtk(directory.path().join("missing.so").as_os_str()) + .unwrap_err() + .to_string(); + assert!(error.contains("GTK 4.14 or later"), "{error}"); + assert!(error.contains("Install"), "{error}"); + } +} diff --git a/crates/gpapi/src/service/transport/mod.rs b/crates/gpapi/src/service/transport/mod.rs index 86e2291..85870b6 100644 --- a/crates/gpapi/src/service/transport/mod.rs +++ b/crates/gpapi/src/service/transport/mod.rs @@ -24,3 +24,5 @@ pub const DESKTOP_RENDERING_RETRY: u8 = 1; pub const DESKTOP_SWITCH_BEGIN: u8 = 2; pub const DESKTOP_SWITCH_COMMIT: u8 = 3; pub const DESKTOP_SWITCH_CANCEL: u8 = 4; +/// Query whether the service package can install GUI runtime dependencies; replies with 0 or 1. +pub const DESKTOP_GUI_INSTALLER: u8 = 5; diff --git a/flake.nix b/flake.nix index eec7a70..fd33e84 100644 --- a/flake.nix +++ b/flake.nix @@ -92,6 +92,49 @@ runtimeTools = with pkgs; [ coreutils iproute2 systemd procps util-linux nettools xdg-utils ]; + guiRecipe = pkgs.writeText "gp-downloaded-gui.nix" '' + { archive, checksum, binaryName }: + import ${./nix/gui-package.nix} { + pkgs = import ${pkgs.path} { + system = "${pkgs.stdenv.hostPlatform.system}"; + config = {}; + overlays = []; + }; + inherit archive checksum binaryName; + version = "${version}"; + } + ''; + + guiInstaller = pkgs.writeShellApplication { + name = "gp-gui-installer"; + runtimeInputs = [ pkgs.nix pkgs.coreutils ]; + text = '' + archive=$1 + checksum=$2 + target=$3 + binary_name=$(basename "$target") + case "$binary_name" in + gpgui|gpgui-nsh) ;; + *) echo "Unsupported GUI executable" >&2; exit 1 ;; + esac + directory=$(dirname "$target") + root="$directory/nix-gui/$binary_name" + mkdir -p "$directory/nix-gui" + nix-build ${guiRecipe} --out-link "$root" --no-build-output \ + --argstr archive "$archive" --argstr checksum "$checksum" \ + --argstr binaryName "$binary_name" + temporary=$(mktemp -d "$directory/.gui-link.XXXXXX") + trap 'rm -rf "$temporary"' EXIT + ln -s "$root/bin/$binary_name" "$temporary/$binary_name" + mv -Tf "$temporary/$binary_name" "$target" + ''; + }; + + installGuiInstaller = lib.optionalString pkgs.stdenv.isLinux '' + install -Dm755 ${guiInstaller}/bin/gp-gui-installer \ + "$out/libexec/gpclient/gp-gui-installer" + ''; + nativeRuntimeWrapping = lib.optionalString pkgs.stdenv.isLinux '' gappsWrapperArgs+=( --prefix PATH : "/run/wrappers/bin:${lib.makeBinPath runtimeTools}" @@ -152,6 +195,7 @@ fromSource = lib.makeOverridable ({ gui ? gpgui }: naersk'.buildPackage { inherit pname version; + SNAPSHOT = lib.boolToString (releaseTag == "snapshot"); src = assert lib.assertMsg (builtins.pathExists (src + "/crates/openconnect/deps/openconnect/configure.ac") && builtins.pathExists (src + "/crates/openconnect/deps/libxml2/configure.ac")) @@ -202,6 +246,7 @@ '' + lib.optionalString pkgs.stdenv.isLinux '' ${installNixosPolkitRule} + ${installGuiInstaller} '' + '' ${rewriteVpncScriptToolPaths} @@ -244,6 +289,7 @@ ${rewriteVpncScriptToolPaths} sh ${./scripts/relocate-install-paths.sh} "$out" /usr "$out" ${installNixosPolkitRule} + ${installGuiInstaller} runHook postInstall ''; diff --git a/nix/gui-package.nix b/nix/gui-package.nix new file mode 100644 index 0000000..b739f64 --- /dev/null +++ b/nix/gui-package.nix @@ -0,0 +1,34 @@ +{ pkgs, archive, checksum, binaryName, version }: +let + nativeShell = binaryName == "gpgui-nsh"; +in +assert builtins.elem binaryName [ "gpgui" "gpgui-nsh" ]; +pkgs.stdenv.mkDerivation { + pname = binaryName; + inherit version; + src = builtins.path { + path = builtins.toPath archive; + name = "${binaryName}.tar.xz"; + recursive = false; + sha256 = checksum; + }; + dontBuild = true; + nativeBuildInputs = [ pkgs.autoPatchelfHook ] ++ ( + if nativeShell then [ pkgs.wrapGAppsHook4 ] else [ pkgs.wrapGAppsHook3 ] + ); + buildInputs = with pkgs; + [ gnutls ] ++ (if nativeShell then [ gtk4 ] else [ + gtk3 webkitgtk_4_1 libsoup_3 glib-networking libsecret libayatana-appindicator + ]); + runtimeDependencies = [ pkgs.libglvnd ] ++ pkgs.lib.optionals (!nativeShell) [ + pkgs.glib-networking pkgs.libayatana-appindicator + ]; + installPhase = '' + runHook preInstall + install -Dm755 ${binaryName} "$out/bin/${binaryName}" + if [ -f ICU4X-LICENSE.txt ]; then + install -Dm644 ICU4X-LICENSE.txt "$out/share/licenses/${binaryName}/ICU4X-LICENSE.txt" + fi + runHook postInstall + ''; +}