feat: release GP Connect 3.3.0 with Native Shell support

This commit is contained in:
Kevin Yue committed 2026-11-05 23:05:14 +08:00
1 parent d12d677208
commit fd08cdbe66
226 files changed
+7700 -5225

No files matched your search

+2 -1
View File
@@ -2,6 +2,7 @@
name = "gpservice"
version.workspace = true
edition.workspace = true
rust-version.workspace = true
license.workspace = true
[dependencies]
@@ -36,7 +37,7 @@ nix = { version = "0.31", features = ["fs", "socket", "user"] }
[dev-dependencies]
openssl.workspace = true
tokio-tungstenite = "0.29"
tokio-tungstenite.workspace = true
[target.'cfg(target_os = "macos")'.dependencies]
gpvpnc = { path = "../../crates/gpvpnc" }
+86 -8
View File
@@ -17,7 +17,10 @@ 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_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.
pub(crate) struct DesktopClient {
@@ -44,7 +47,8 @@ impl DesktopClient {
fcntl(&fd, FcntlArg::F_SETFD(FdFlag::FD_CLOEXEC))?;
let flags = OFlag::from_bits_truncate(fcntl(&fd, FcntlArg::F_GETFL)?);
fcntl(&fd, FcntlArg::F_SETFL(flags | OFlag::O_NONBLOCK))?;
Ok(AsyncFd::new(fd)?)
// SAFETY: OwnedFd keeps this descriptor open and unchanged until AsyncFd drops it.
Ok(unsafe { AsyncFd::register(fd) }?)
}
Ok(Self {
input: pipe(input)?,
@@ -62,15 +66,41 @@ 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
self.write_all(&credential.encode_frame()?).await?;
loop {
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_all(&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(()),
@@ -85,7 +115,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)) {
@@ -100,7 +130,7 @@ impl DesktopClient {
Ok(())
}
async fn gui_exited(&self) -> anyhow::Result<Option<u8>> {
async fn read_control(&self) -> anyhow::Result<Option<u8>> {
loop {
let mut ready = self.input.readable().await?;
let mut byte = [0];
@@ -145,7 +175,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;
@@ -253,6 +283,54 @@ 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_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());
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();
+4 -4
View File
@@ -87,14 +87,14 @@ pub fn install(request: InstallRequest, approving_uid: u32) -> anyhow::Result<Ap
}
pub fn resolve(approval_id: &str, desktop_uid: u32) -> anyhow::Result<ApprovedScript> {
let budget = gpapi::process::collection::CollectionBudget::new(std::time::Duration::from_secs(60));
let budget = gpapi::collection::CollectionBudget::new(std::time::Duration::from_secs(60));
resolve_with_control(approval_id, desktop_uid, &budget)
}
pub fn resolve_with_control(
approval_id: &str,
desktop_uid: u32,
control: &dyn gpapi::process::collection::CollectionControl,
control: &dyn gpapi::collection::CollectionControl,
) -> anyhow::Result<ApprovedScript> {
control.check()?;
ensure!(desktop_uid != 0, "Root is not a desktop HIP approval owner");
@@ -199,7 +199,7 @@ fn install_at(
}
fn resolve_at(base: &Path, approval_id: &str, desktop_uid: u32, file_owner: u32) -> anyhow::Result<ApprovedScript> {
let budget = gpapi::process::collection::CollectionBudget::new(std::time::Duration::from_secs(60));
let budget = gpapi::collection::CollectionBudget::new(std::time::Duration::from_secs(60));
resolve_at_with_control(base, approval_id, desktop_uid, file_owner, &budget)
}
@@ -208,7 +208,7 @@ fn resolve_at_with_control(
approval_id: &str,
desktop_uid: u32,
file_owner: u32,
control: &dyn gpapi::process::collection::CollectionControl,
control: &dyn gpapi::collection::CollectionControl,
) -> anyhow::Result<ApprovedScript> {
control.check()?;
let info = read_metadata_at(base, approval_id, desktop_uid, file_owner)?;
+3 -3
View File
@@ -158,12 +158,12 @@ fn generate(
request.host_id.as_ref().is_none_or(|id| id.len() <= 256),
"Invalid HIP host ID"
);
let budget = gpapi::process::collection::CollectionBudget::new(PREVIEW_TIMEOUT);
let budget = gpapi::collection::CollectionBudget::new(PREVIEW_TIMEOUT);
let check = || {
if cancellation.is_cancelled() {
return Err(io::Error::new(io::ErrorKind::Interrupted, "HIP preview cancelled"));
}
gpapi::process::collection::CollectionControl::check(&budget)
gpapi::collection::CollectionControl::check(&budget)
};
check()?;
let profile = crate::hip_source::profile(
@@ -227,7 +227,7 @@ mod tests {
},
edited_report: None,
desktop_uid: None,
identity: HostIdentity::from_parts(
identity: gpapi::os_profile::desktop::identity_from_parts(
"device".into(),
"host".into(),
"serial".into(),
+8 -8
View File
@@ -125,7 +125,7 @@ pub(crate) fn generate(
profile: &OsProfile,
edited: Option<&str>,
request: &HipRequest,
control: &dyn gpapi::process::collection::CollectionControl,
control: &dyn gpapi::collection::CollectionControl,
preview: bool,
) -> anyhow::Result<String> {
control.check()?;
@@ -177,9 +177,9 @@ pub(crate) fn profile(
os_version: Option<String>,
host_id: Option<String>,
hostname: Option<String>,
control: &dyn gpapi::process::collection::CollectionControl,
control: &dyn gpapi::collection::CollectionControl,
) -> io::Result<OsProfile> {
let identity = HostIdentity::from_parts(
let identity = gpapi::os_profile::desktop::identity_from_parts(
hostname.unwrap_or_else(|| identity.computer().into()),
host_id.unwrap_or_else(|| identity.host_id().into()),
identity.serialno().into(),
@@ -192,7 +192,7 @@ pub(crate) fn profile(
if let Some(os_version) = os_version {
builder = builder.os_version(os_version);
}
builder.build_with_control(control)
gpapi::os_profile::desktop::collect_profile_with_control(builder, None, control)
}
fn generation_error(error: anyhow::Error) -> io::Error {
@@ -209,7 +209,7 @@ mod tests {
fn fixture_profile() -> OsProfile {
profile(
&HostIdentity::from_parts(
&gpapi::os_profile::desktop::identity_from_parts(
"device".into(),
"host".into(),
"serial".into(),
@@ -220,7 +220,7 @@ mod tests {
Some("negotiated-version".into()),
None,
None,
&gpapi::process::collection::CollectionBudget::new(std::time::Duration::from_secs(60)),
&gpapi::collection::CollectionBudget::new(std::time::Duration::from_secs(60)),
)
.unwrap()
}
@@ -235,7 +235,7 @@ mod tests {
#[test]
fn profile_retains_negotiated_identity_and_os_version() {
let identity = HostIdentity::from_parts(
let identity = gpapi::os_profile::desktop::identity_from_parts(
"original".into(),
"original-id".into(),
"serial".into(),
@@ -248,7 +248,7 @@ mod tests {
Some("negotiated-os".into()),
Some("negotiated-host".into()),
Some("negotiated-name".into()),
&gpapi::process::collection::CollectionBudget::new(std::time::Duration::from_secs(60)),
&gpapi::collection::CollectionBudget::new(std::time::Duration::from_secs(60)),
)
.unwrap();
assert_eq!(profile.os_version(), "negotiated-os");
+122 -11
View File
@@ -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,11 +333,29 @@ 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())
pub(crate) fn gui_installer() -> Option<std::path::PathBuf> {
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"
@@ -343,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()
@@ -350,7 +394,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 +443,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 +474,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 +524,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 +533,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 +564,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 +580,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");
@@ -543,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(
+4 -1
View File
@@ -833,7 +833,10 @@ mod tests {
}
let valid = gphip::generate_report(&gphip::ReportInput {
profile: gpapi::os_profile::OsProfile::builder(gpapi::os_profile::ClientOs::Linux).build(),
profile: gpapi::os_profile::desktop::collect_profile(
gpapi::os_profile::OsProfile::builder(gpapi::os_profile::ClientOs::Linux),
None,
),
context: gphip::ReportContext::Preview,
})
.unwrap();
+6 -6
View File
@@ -420,7 +420,7 @@ enum LifecycleEvent {
MembersChanged {
attempt: u64,
members: Vec<gpapi::session::GatewaySessionSummary>,
failures: Vec<gpapi::session::GatewayFailureSummary>,
failures: Vec<gpapi::session::desktop::GatewayFailureSummary>,
},
Ended {
attempt: u64,
@@ -679,7 +679,7 @@ impl VpnTask {
&self,
attempt: u64,
members: Vec<gpapi::session::GatewaySessionSummary>,
failures: Vec<gpapi::session::GatewayFailureSummary>,
failures: Vec<gpapi::session::desktop::GatewayFailureSummary>,
) {
let Some(active) = &self.active else {
return;
@@ -855,12 +855,12 @@ pub(crate) fn test_connect_request(info: ConnectInfo) -> ConnectRequest {
} else {
"fixture"
};
let binding = gpapi::session::network::GatewayBinding::new(
let binding = gpapi::session::desktop::network::GatewayBinding::new(
endpoint,
std::net::SocketAddr::new(source, 0),
interface.into(),
1,
gpapi::session::ClientAddresses {
gpapi::session::desktop::ClientAddresses {
ipv4: match source {
std::net::IpAddr::V4(ip) => Some(ip),
_ => None,
@@ -873,8 +873,8 @@ pub(crate) fn test_connect_request(info: ConnectInfo) -> ConnectRequest {
"0".repeat(64),
)
.unwrap();
let plan = gpapi::session::ConnectionPlan::new(
vec![gpapi::session::AuthenticatedGateway {
let plan = gpapi::session::desktop::ConnectionPlan::new(
vec![gpapi::session::desktop::AuthenticatedGateway {
gateway: info.gateway().clone(),
binding: Some(binding),
authentication: gpapi::session::GatewayAuthentication::new("authcookie=token&user=user".into(), "tunnel".into())
+2 -2
View File
@@ -1,10 +1,10 @@
use std::{sync::Arc, time::Duration};
use anyhow::Context;
use gpapi::process::collection::CollectionControl;
use gpapi::collection::CollectionControl;
use gpapi::session::{
GatewaySessionSummary, MaintenanceState, SessionEndReason,
non_tunnel::{SessionCallbacks, SessionExit, maintain_non_tunnel_sessions},
desktop::non_tunnel::{SessionCallbacks, SessionExit, maintain_non_tunnel_sessions},
};
use log::warn;
use tokio::sync::{mpsc, watch};
@@ -11,7 +11,10 @@ use gpapi::{
transport::ServiceResult,
vpn_state::{ConnectInfo, VpnState},
},
session::{ClientAddresses, GatewayAuthentication, GatewaySession, GatewaySessions, transport::GatewayTransport},
session::{
GatewayAuthentication, desktop::ClientAddresses, desktop::GatewaySession, desktop::GatewaySessions,
transport::GatewayTransport,
},
};
use openssl::{
asn1::Asn1Time,
@@ -70,7 +73,7 @@ async fn cancelled_pending_owner_logs_out_and_releases_admission_after_response(
let mut member = fixture.plan().members()[0].clone();
member.authentication =
GatewayAuthentication::new("authcookie=fixture&user=fixture".into(), "internal".into()).unwrap();
let plan = gpapi::session::ConnectionPlan::new(vec![member], vec![], fixture.plan().policy()).unwrap();
let plan = gpapi::session::desktop::ConnectionPlan::new(vec![member], vec![], fixture.plan().policy()).unwrap();
let request = gpapi::service::request::ConnectRequest::new(fixture.info().clone(), plan);
let mut prepared = PreparedConnection::lifecycle_fixture(request);
let mut params = GpParams::builder(prepared.resources.profile.clone());
+26 -18
View File
@@ -2,11 +2,13 @@ use std::{sync::Arc, time::Duration};
use anyhow::Context;
use gpapi::{
collection::{CollectionBudget, CollectionControl},
gp_params::GpParams,
os_profile::OsProfile,
process::collection::{CollectionBudget, CollectionControl},
service::request::ConnectRequest,
session::{GatewaySession, GatewaySessions, network::PhysicalNetwork, transport::GatewayTransport},
session::{
desktop::GatewaySession, desktop::GatewaySessions, desktop::network::PhysicalNetwork, transport::GatewayTransport,
},
};
use tokio_util::sync::CancellationToken;
@@ -149,14 +151,17 @@ impl PreparedConnection {
/// Lifecycle-only fixtures own no issued server sessions. Protocol ownership
/// checks use actual gateway transports rather than this actor-state fixture.
pub(crate) fn lifecycle_fixture(request: ConnectRequest) -> Self {
let profile = OsProfile::builder(gpapi::os_profile::ClientOs::Linux)
.host_identity(gpapi::os_profile::HostIdentity::from_parts(
"fixture".into(),
"fixture-host".into(),
"fixture-serial".into(),
"02:00:00:00:00:01".into(),
))
.build();
let profile = gpapi::os_profile::desktop::collect_profile(
OsProfile::builder(gpapi::os_profile::ClientOs::Linux).host_identity(
gpapi::os_profile::desktop::identity_from_parts(
"fixture".into(),
"fixture-host".into(),
"fixture-serial".into(),
"02:00:00:00:00:01".into(),
),
),
None,
);
Self {
request,
resources: Arc::new(ConnectionResources {
@@ -217,14 +222,17 @@ mod tests {
#[tokio::test]
async fn ordinary_tunnel_preparation_needs_no_physical_binding_or_resolver() {
let gateway = Gateway::new("fixture".into(), "does-not-resolve.invalid".into());
let profile = OsProfile::builder(gpapi::os_profile::ClientOs::Linux)
.host_identity(gpapi::os_profile::HostIdentity::from_parts(
"fixture".into(),
"fixture-host".into(),
"fixture-serial".into(),
"02:00:00:00:00:01".into(),
))
.build();
let profile = gpapi::os_profile::desktop::collect_profile(
OsProfile::builder(gpapi::os_profile::ClientOs::Linux).host_identity(
gpapi::os_profile::desktop::identity_from_parts(
"fixture".into(),
"fixture-host".into(),
"fixture-serial".into(),
"02:00:00:00:00:01".into(),
),
),
None,
);
let request = super::super::test_connect_request(ConnectInfo::new("portal.example.com".into(), gateway, vec![]))
.with_os_profile(&profile)
.with_disable_ipv6(true);
+4 -4
View File
@@ -2,7 +2,7 @@ use std::{sync::Arc, time::Duration};
use anyhow::{Context, ensure};
use gpapi::{
process::collection::{CollectionBudget, CollectionControl},
collection::{CollectionBudget, CollectionControl},
service::request::ConnectRequest,
session::SessionMode,
};
@@ -77,8 +77,8 @@ pub(super) fn spawn(
.all(|member| member.authentication.mode() == SessionMode::NonTunnel)
{
match super::non_tunnel::run(&mut input, source, guard, cancellation.clone(), events.clone()).await {
Ok(gpapi::session::non_tunnel::SessionExit::Disconnected) => {}
Ok(gpapi::session::non_tunnel::SessionExit::Failed(reason)) => {
Ok(gpapi::session::desktop::non_tunnel::SessionExit::Disconnected) => {}
Ok(gpapi::session::desktop::non_tunnel::SessionExit::Failed(reason)) => {
let message = match reason {
gpapi::session::SessionEndReason::InvalidCookie => {
"Internal gateway authentication expired; connect again"
@@ -312,7 +312,7 @@ async fn run_tunnel(
prepared: &PreparedTunnel,
approval: &crate::hip_source::HipApproval,
lifecycle: &LifecycleHandle,
sessions: &mut gpapi::session::GatewaySessions,
sessions: &mut gpapi::session::desktop::GatewaySessions,
cancellation: CancellationToken,
events: mpsc::Sender<LifecycleEvent>,
) {
+3 -3
View File
@@ -60,7 +60,7 @@ pub(super) async fn run(
events: mpsc::Sender<LifecycleEvent>,
session_id: uuid::Uuid,
registry: Arc<crate::session_registry::SessionRegistry>,
sessions: &mut gpapi::session::GatewaySessions,
sessions: &mut gpapi::session::desktop::GatewaySessions,
) -> anyhow::Result<()> {
let attempt = identity.attempt;
let (native_tx, native) = mpsc::channel(64);
@@ -219,12 +219,12 @@ async fn supervise(
fn observed_network(
config: openconnect::tunnel::Configuration,
) -> anyhow::Result<gpapi::session::tunnel::NegotiatedNetwork> {
) -> anyhow::Result<gpapi::session::desktop::tunnel::NegotiatedNetwork> {
ensure!(
!config.truncated && !config.dns.truncated && !config.search_domains.truncated,
"VPN configuration is truncated"
);
Ok(gpapi::session::tunnel::NegotiatedNetwork {
Ok(gpapi::session::desktop::tunnel::NegotiatedNetwork {
addresses: [config.ipv4, config.ipv6.or(config.netmask6)]
.into_iter()
.flatten()
+7 -4
View File
@@ -41,7 +41,7 @@ pub(crate) struct ConnectionControl {
connection_id: Uuid,
tx: mpsc::Sender<ConnectionCommand>,
close_tx: watch::Sender<Option<CloseReason>>,
statistics: watch::Sender<Option<gpapi::session::tunnel::TunnelStatisticsSnapshot>>,
statistics: watch::Sender<Option<gpapi::session::desktop::tunnel::TunnelStatisticsSnapshot>>,
statistics_enabled: Arc<AtomicBool>,
committed: Arc<AtomicBool>,
}
@@ -102,13 +102,15 @@ impl ConnectionControl {
self.statistics.send_replace(None);
}
pub fn publish_statistics(&self, snapshot: gpapi::session::tunnel::TunnelStatisticsSnapshot) {
pub fn publish_statistics(&self, snapshot: gpapi::session::desktop::tunnel::TunnelStatisticsSnapshot) {
if self.statistics_enabled() && !self.is_closed() {
self.statistics.send_replace(Some(snapshot));
}
}
pub fn subscribe_statistics(&self) -> watch::Receiver<Option<gpapi::session::tunnel::TunnelStatisticsSnapshot>> {
pub fn subscribe_statistics(
&self,
) -> watch::Receiver<Option<gpapi::session::desktop::tunnel::TunnelStatisticsSnapshot>> {
self.statistics.subscribe()
}
@@ -750,7 +752,7 @@ mod tests {
.unwrap();
assert!(matches!(reply, ServerMessage::Reply {
id,
result: ServiceResult::TunnelStatisticsSnapshot(gpapi::session::tunnel::TunnelStatisticsSnapshot::Unavailable { reason: gpapi::session::tunnel::TunnelUnavailableReason::NoTunnel }),
result: ServiceResult::TunnelStatisticsSnapshot(gpapi::session::desktop::tunnel::TunnelStatisticsSnapshot::Unavailable { reason: gpapi::session::desktop::tunnel::TunnelUnavailableReason::NoTunnel }),
} if id == statistics_id));
let update_id = Uuid::new_v4();
@@ -761,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
+4 -4
View File
@@ -9,7 +9,7 @@ use gpapi::{
vpn_env::{HostInfo, VpnEnv},
vpn_state::VpnState,
},
session::tunnel::{TunnelStatisticsSnapshot, TunnelUnavailableReason},
session::desktop::tunnel::{TunnelStatisticsSnapshot, TunnelUnavailableReason},
utils::lock_file::LockFile,
};
use log::{info, warn};
@@ -397,7 +397,7 @@ fn build_snapshot(vpn_state: VpnState) -> VpnEnv {
vpnc_script: find_vpnc_script(),
auth_executable: binary_paths::gpauth().to_string_lossy().into_owned(),
host_info: HostInfo {
host_identity: HostIdentity::collect(),
host_identity: gpapi::os_profile::desktop::collect_identity(),
},
}
}
@@ -488,7 +488,7 @@ mod tests {
#[tokio::test]
async fn statistics_demand_is_per_attachment_and_does_not_consume_revisions() {
use gpapi::service::transport::ServiceResult;
use gpapi::session::tunnel::TunnelStatisticsState;
use gpapi::session::desktop::tunnel::TunnelStatisticsState;
let (context, registry) = context();
let (a, a_session, a_generation, _a_rx) = attach(&context, &registry).await;
let (b, b_session, b_generation, _b_rx) = attach(&context, &registry).await;
@@ -564,7 +564,7 @@ mod tests {
#[test]
fn snapshot_budget_trims_observation_without_changing_existing_metadata() {
use gpapi::session::tunnel::{TunnelConfiguration, TunnelPhase, TunnelState, TunnelTransport};
use gpapi::session::desktop::tunnel::{TunnelConfiguration, TunnelPhase, TunnelState, TunnelTransport};
let mut snapshot = build_snapshot(VpnState::Disconnected);
let mut configuration = TunnelConfiguration::default();
configuration.included_routes.items = vec!["r".repeat(1000); 15];