feat: prepare 3.1.0 with connection details and improved authentication

Add tunnel statistics and an optional CLI dashboard, native sign-in controls and recovery, and broader client certificate support. Include platform integration fixes and the approved release notes.
This commit is contained in:
Kevin Yue committed 2026-10-19 23:47:11 +08:00
1 parent 18ed6bac1a
commit 4faa2ecb0d
158 files changed
+13752 -1038

No files matched your search

+4 -1
View File
@@ -8,8 +8,8 @@ license.workspace = true
common = { path = "../../crates/common" }
gpapi = { path = "../../crates/gpapi", features = ["clap", "logger"] }
gphip = { path = "../../crates/gphip" }
gptunnel = { path = "../../crates/gptunnel" }
base64.workspace = true
sha256.workspace = true
openconnect = { path = "../../crates/openconnect" }
clap.workspace = true
anyhow.workspace = true
@@ -37,3 +37,6 @@ nix = { version = "0.31", features = ["fs", "socket", "user"] }
[dev-dependencies]
openssl.workspace = true
tokio-tungstenite = "0.29"
[target.'cfg(target_os = "macos")'.dependencies]
gpvpnc = { path = "../../crates/gpvpnc" }
+1 -11
View File
@@ -119,23 +119,13 @@ impl Cli {
} else {
None
};
let brokered_scripts_dir = if externally_brokered {
let executable = std::env::current_exe().context("Failed to locate the gpservice executable")?;
let contents_dir = executable
.parent()
.and_then(std::path::Path::parent)
.context("gpservice is not inside a macOS application bundle")?;
Some(contents_dir.join("Resources/Scripts"))
} else {
None
};
let (mut vpn_task, lifecycle) = VpnTask::new(vpn_state_tx, externally_brokered, Arc::clone(&registry));
let dispatcher = Arc::new(RequestDispatcher::new(
lifecycle.clone(),
Arc::clone(&gui_restart_requested),
Arc::clone(&redaction),
!externally_brokered,
brokered_scripts_dir,
externally_brokered,
));
#[cfg(target_os = "macos")]
let idle_vpn_state_rx = vpn_state_rx.clone();
+3 -3
View File
@@ -7,7 +7,7 @@ use std::{
use anyhow::{Context, ensure};
use base64::{Engine, engine::general_purpose::STANDARD};
use gpapi::hip::HipApprovalStatus;
use gpapi::{hip::HipApprovalStatus, utils::checksum::sha256_hex};
use serde::{Deserialize, Serialize};
use tempfile::Builder;
use uuid::Uuid;
@@ -169,7 +169,7 @@ fn install_at(
let info = ApprovalInfo {
approval_id: approval_id.clone(),
owner_uid: approving_uid,
sha256: sha256::digest(contents),
sha256: sha256_hex(contents),
original_path,
};
let staged = Builder::new().prefix(".install-").tempdir_in(base)?;
@@ -232,7 +232,7 @@ fn resolve_at_with_control(
}
ensure!(!contents.is_empty(), "Approved HIP script is empty");
ensure!(
sha256::digest(&contents) == info.sha256,
sha256_hex(&contents) == info.sha256,
"Approved HIP script digest mismatch"
);
control.check()?;
+39 -38
View File
@@ -78,16 +78,19 @@ pub struct RequestDispatcher {
redaction: Arc<Redaction>,
install_lock: Mutex<()>,
gui_management_enabled: bool,
brokered_scripts_dir: Option<std::path::PathBuf>,
externally_brokered: bool,
}
impl RequestDispatcher {
pub fn subscribe_tunnel(&self) -> tokio::sync::watch::Receiver<crate::vpn_task::TunnelBinding> {
self.lifecycle.subscribe_tunnel()
}
pub fn new(
lifecycle: crate::vpn_task::LifecycleHandle,
gui_restart_requested: Arc<AtomicBool>,
redaction: Arc<Redaction>,
gui_management_enabled: bool,
brokered_scripts_dir: Option<std::path::PathBuf>,
externally_brokered: bool,
) -> Self {
Self {
lifecycle,
@@ -95,7 +98,7 @@ impl RequestDispatcher {
redaction,
install_lock: Mutex::new(()),
gui_management_enabled,
brokered_scripts_dir,
externally_brokered,
}
}
@@ -108,7 +111,7 @@ impl RequestDispatcher {
) -> Result<PendingDispatch, ServiceResult> {
match request {
WsRequest::Connect(request) => {
if let Err(message) = self.validate_connect_paths(&request) {
if let Err(message) = self.validate_connect_request(&request) {
return Err(ServiceResult::rejected(ServiceErrorCode::InvalidRequest, message));
}
let redaction_values = request
@@ -197,12 +200,8 @@ impl RequestDispatcher {
desktop_uid,
edited_report,
} => {
let prepared = crate::vpn_task::prepare_connection(
*request,
self.brokered_scripts_dir.is_some(),
preparation.cancellation(),
)
.await;
let prepared =
crate::vpn_task::prepare_connection(*request, self.externally_brokered, preparation.cancellation()).await;
return match prepared {
Ok(connection) => preparation.commit(connection, desktop_uid, edited_report),
Err(error) => {
@@ -271,19 +270,19 @@ impl RequestDispatcher {
| WsRequest::PreviewHipReport(_)
| WsRequest::GetHipApprovalStatus { .. }
| WsRequest::ReadHipPreviewChunk(_)
| WsRequest::GetLastSubmittedHipReport => {
| WsRequest::GetLastSubmittedHipReport
| WsRequest::SetTunnelStatisticsEnabled { .. } => {
unreachable!("session-bound request was already dispatched")
}
}
}
fn validate_connect_paths(&self, request: &gpapi::service::request::ConnectRequest) -> Result<(), &'static str> {
let Some(scripts) = &self.brokered_scripts_dir else {
fn validate_connect_request(&self, request: &gpapi::service::request::ConnectRequest) -> Result<(), &'static str> {
if !self.externally_brokered {
return Ok(());
};
let expected_script = scripts.join("vpnc-script").to_string_lossy().into_owned();
if request.args().vpnc_script().as_deref() != Some(expected_script.as_str()) {
return Err("macOS VPN script must be the bundled script");
}
if request.args().vpnc_script().is_some() {
return Err("macOS does not support custom VPN scripts");
}
if matches!(
request.args().hip_source(),
@@ -520,7 +519,7 @@ mod tests {
#[test]
fn installs_gui_at_the_supplied_target() {
let archive = compressed_gui_archive(b"gui binary");
let checksum = sha256::try_digest(archive.path()).unwrap();
let checksum = gpapi::utils::checksum::file_sha256(archive.path()).unwrap();
let output = tempfile::tempdir().unwrap();
let target = output.path().join("gpclient/gpgui");
@@ -549,7 +548,7 @@ mod tests {
Arc::new(AtomicBool::new(false)),
Arc::new(Redaction::new()),
false,
Some(std::path::PathBuf::from("/app/Contents/Resources/Scripts")),
true,
);
let ServiceResult::Rejected(rejection) = dispatcher.dispatch(WsRequest::RestartGui).await else {
panic!("brokered mode accepted GUI restart");
@@ -558,9 +557,7 @@ mod tests {
let gateway = Gateway::new("Gateway".into(), "vpn.example.com".into());
let info = gpapi::service::vpn_state::ConnectInfo::new("portal.example.com".into(), gateway.clone(), vec![gateway]);
let request = test_request(info)
.with_vpnc_script(Some("/app/Contents/Resources/Scripts/vpnc-script".to_string()))
.with_certificate(Some("/Users/example/client.pem".to_string()));
let request = test_request(info).with_certificate(Some("/Users/example/client.pem".to_string()));
let ServiceResult::Rejected(rejection) = dispatcher.dispatch(WsRequest::Connect(Box::new(request))).await else {
panic!("brokered mode accepted a root-readable identity path");
};
@@ -568,33 +565,37 @@ mod tests {
}
#[test]
fn brokered_mode_accepts_only_resource_script_paths() {
fn brokered_mode_rejects_script_overrides() {
let dispatcher = RequestDispatcher::new(
crate::vpn_task::LifecycleHandle::for_tests(),
Arc::new(AtomicBool::new(false)),
Arc::new(Redaction::new()),
false,
Some(std::path::PathBuf::from("/app/Contents/Resources/Scripts")),
true,
);
let gateway = Gateway::new("Gateway".into(), "vpn.example.com".into());
let info = gpapi::service::vpn_state::ConnectInfo::new("portal.example.com".into(), gateway.clone(), vec![gateway]);
let bundled =
test_request(info.clone()).with_vpnc_script(Some("/app/Contents/Resources/Scripts/vpnc-script".to_string()));
assert_eq!(dispatcher.validate_connect_paths(&bundled), Ok(()));
let embedded = test_request(info.clone());
assert_eq!(dispatcher.validate_connect_request(&embedded), Ok(()));
let old_layout = test_request(info.clone()).with_vpnc_script(Some("/app/Contents/Helpers/vpnc-script".to_string()));
assert_eq!(
dispatcher.validate_connect_paths(&old_layout),
Err("macOS VPN script must be the bundled script")
);
for script in [
"/app/Contents/Resources/Scripts/vpnc-script",
"/tmp/custom-vpnc-script",
"echo untrusted",
"",
] {
let custom = test_request(info.clone()).with_vpnc_script(Some(script.to_string()));
assert_eq!(
dispatcher.validate_connect_request(&custom),
Err("macOS does not support custom VPN scripts")
);
}
let custom = test_request(info)
.with_vpnc_script(Some("/app/Contents/Resources/Scripts/vpnc-script".to_string()))
.with_hip_source(gpapi::hip::HipSource::UserScript {
path: "/tmp/hip.sh".into(),
});
let custom = test_request(info).with_hip_source(gpapi::hip::HipSource::UserScript {
path: "/tmp/hip.sh".into(),
});
assert_eq!(
dispatcher.validate_connect_paths(&custom),
dispatcher.validate_connect_request(&custom),
Err("macOS does not support custom HIP scripts")
);
}
+14
View File
@@ -0,0 +1,14 @@
use gpapi::service::request::ConnectArgs;
use openconnect::{Vpn, VpnBuilder};
pub(crate) fn builder(server: &str, cookie: &str, args: &ConnectArgs) -> anyhow::Result<VpnBuilder> {
anyhow::ensure!(
args.vpnc_script().is_none(),
"macOS does not support custom VPN scripts"
);
Ok(
Vpn::builder(server, cookie).network_configuration_handler(|configuration| {
gpvpnc::macos::configure_network(&configuration.reason, &configuration.environment)
}),
)
}
+9 -1
View File
@@ -1,7 +1,15 @@
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd"))]
#[path = "privileged_unix.rs"]
mod platform;
#[cfg(not(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd")))]
#[cfg(target_os = "macos")]
#[path = "macos.rs"]
mod platform;
#[cfg(not(any(
target_os = "linux",
target_os = "freebsd",
target_os = "openbsd",
target_os = "macos"
)))]
#[path = "default.rs"]
mod platform;
#[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "openbsd", test))]
+50 -44
View File
@@ -32,9 +32,20 @@ mod runtime;
pub(crate) struct LifecycleHandle {
events: mpsc::Sender<LifecycleEvent>,
admissions: Arc<Mutex<Admissions>>,
tunnel: watch::Sender<TunnelBinding>,
}
#[derive(Clone, Default)]
pub(crate) struct TunnelBinding {
pub attempt: u64,
pub monitor: Option<Arc<gptunnel::TunnelMonitor>>,
pub non_tunnel: bool,
}
impl LifecycleHandle {
pub fn subscribe_tunnel(&self) -> watch::Receiver<TunnelBinding> {
self.tunnel.subscribe()
}
pub fn reserve_connect(&self) -> Result<ConnectReservation, ServiceResult> {
let mut admissions = self.admissions.lock().expect("VPN lifecycle admissions mutex poisoned");
if admissions.closed {
@@ -370,6 +381,10 @@ enum AdmissionPhase {
}
enum LifecycleEvent {
TunnelMonitor {
attempt: u64,
monitor: Arc<gptunnel::TunnelMonitor>,
},
Start {
attempt: u64,
connection: PreparedConnection,
@@ -429,6 +444,7 @@ impl VpnTask {
let lifecycle = LifecycleHandle {
events: events_tx,
admissions: Arc::new(Mutex::new(Admissions::default())),
tunnel: watch::channel(TunnelBinding::default()).0,
};
let task = Self {
events,
@@ -493,6 +509,16 @@ impl VpnTask {
async fn handle_event(&mut self, event: LifecycleEvent) {
match event {
LifecycleEvent::TunnelMonitor { attempt, monitor } => {
if self.active.as_ref().is_some_and(|active| active.attempt == attempt) {
let non_tunnel = false;
self.lifecycle.tunnel.send_replace(TunnelBinding {
attempt,
monitor: Some(monitor),
non_tunnel,
});
}
}
LifecycleEvent::Start {
attempt,
connection,
@@ -526,6 +552,16 @@ impl VpnTask {
session_id: Option<Uuid>,
) {
let activated = self.lifecycle.activate_attempt(attempt);
self.lifecycle.tunnel.send_replace(TunnelBinding {
attempt,
monitor: None,
non_tunnel: connection
.request
.plan()
.members()
.iter()
.all(|member| member.authentication.mode() == gpapi::session::SessionMode::NonTunnel),
});
let info = connection.request.info().clone();
let allow_extend_session = connection.request.args().allow_extend_session();
let cancellation = self.lifecycle.attempt_cancellation(attempt);
@@ -661,6 +697,12 @@ impl VpnTask {
if let Some(session_id) = active.session_id {
self.registry.clear_successful_hip_report(session_id);
}
if self.lifecycle.tunnel.borrow().monitor.is_none() {
self.lifecycle.tunnel.send_replace(TunnelBinding {
attempt,
..Default::default()
});
}
if let Some(reason) = active.failure {
self.send_state(VpnState::Failed(reason));
self.lifecycle.clear_attempt(attempt);
@@ -815,49 +857,22 @@ mod tests {
);
}
fn identity_material() -> (openssl::pkey::PKey<openssl::pkey::Private>, openssl::x509::X509) {
use openssl::{
asn1::Asn1Time,
hash::MessageDigest,
pkey::PKey,
rsa::Rsa,
x509::{X509, X509NameBuilder},
};
let key = PKey::from_rsa(Rsa::generate(2048).unwrap()).unwrap();
let mut name = X509NameBuilder::new().unwrap();
name.append_entry_by_text("CN", "service-identity-fixture").unwrap();
let name = name.build();
let mut certificate = X509::builder().unwrap();
certificate.set_version(2).unwrap();
certificate.set_subject_name(&name).unwrap();
certificate.set_issuer_name(&name).unwrap();
certificate.set_pubkey(&key).unwrap();
certificate
.set_not_before(&Asn1Time::days_from_now(0).unwrap())
.unwrap();
certificate.set_not_after(&Asn1Time::days_from_now(1).unwrap()).unwrap();
certificate.sign(&key, MessageDigest::sha256()).unwrap();
(key, certificate.build())
}
#[test]
fn tunnel_identity_paths_allow_large_files_and_retain_loaded_material() {
let (key, certificate) = identity_material();
let certificate = include_bytes!("../../../crates/gpapi/tests/files/client-identity/rsa-cert.pem");
let key = include_bytes!("../../../crates/gpapi/tests/files/client-identity/rsa-pkcs8.pem");
let directory = tempfile::tempdir().unwrap();
let path = directory.path().join("identity.pem");
let mut pem = certificate.to_pem().unwrap();
pem.extend(key.private_key_to_pem_pkcs8().unwrap());
let mut pem = certificate.to_vec();
pem.extend(key);
pem.resize(gpapi::service::request::MAX_CLIENT_IDENTITY_DATA + 1, b'\n');
std::fs::write(&path, pem).unwrap();
let request = identity_request().with_certificate(Some(path.to_str().unwrap().into()));
let identity = prepare_identity(request.args(), false).unwrap().unwrap();
std::fs::remove_file(path).unwrap();
assert_eq!(identity.certificate_data(), certificate.to_pem().unwrap());
assert_eq!(identity.certificate_data(), certificate);
let files = identity.write_files(None).unwrap();
assert_eq!(
std::fs::read(files.certificate()).unwrap(),
certificate.to_pem().unwrap()
);
assert_eq!(std::fs::read(files.certificate()).unwrap(), certificate);
assert!(files.key().is_some());
}
@@ -881,17 +896,8 @@ mod tests {
#[test]
fn protected_pkcs12_import_retains_password_and_single_file_material() {
use openssl::pkcs12::Pkcs12;
let (key, certificate) = identity_material();
let password = "service-fixture-password";
let p12 = Pkcs12::builder()
.name("fixture")
.pkey(&key)
.cert(&certificate)
.build2(password)
.unwrap()
.to_der()
.unwrap();
let password = "fixture-password";
let p12 = include_bytes!("../../../crates/gpapi/tests/files/client-identity/modern.p12").to_vec();
let request = identity_request()
.with_certificate_data(Some(p12.clone()))
.with_key_password(Some(password.into()));
+13
View File
@@ -262,6 +262,18 @@ async fn run_tunnel(
if cancellation.is_cancelled() {
return;
}
let monitor = gptunnel::TunnelMonitor::attach(prepared.vpn.clone());
if events
.send(LifecycleEvent::TunnelMonitor {
attempt,
monitor: monitor.clone(),
})
.await
.is_err()
{
monitor.stop().await;
return;
}
let vpn = prepared.vpn.clone();
// The native tunnel keeps its reconnect endpoint and cookie current and owns
// normal logout. The ledger remains responsible only before native execution.
@@ -291,6 +303,7 @@ async fn run_tunnel(
Ok(code) => warn!("Tunnel worker exited with status {code}"),
Err(error) => warn!("Tunnel worker failed: {error}"),
}
monitor.stop().await;
}
pub(super) fn stop_for_revoked_approval(lifecycle: &LifecycleHandle, cancellation: &CancellationToken) {
+86 -2
View File
@@ -1,4 +1,11 @@
use std::{collections::HashSet, sync::Arc, time::Duration};
use std::{
collections::HashSet,
sync::{
Arc,
atomic::{AtomicBool, Ordering},
},
time::Duration,
};
use axum::extract::ws::{CloseFrame, Message, Utf8Bytes, WebSocket};
use futures::StreamExt;
@@ -34,6 +41,9 @@ 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_enabled: Arc<AtomicBool>,
committed: Arc<AtomicBool>,
}
impl ConnectionControl {
@@ -44,6 +54,9 @@ impl ConnectionControl {
connection_id,
tx,
close_tx,
statistics: watch::channel(None).0,
statistics_enabled: Arc::new(AtomicBool::new(false)),
committed: Arc::new(AtomicBool::new(false)),
},
close_rx,
)
@@ -62,9 +75,43 @@ impl ConnectionControl {
}
pub fn close(&self, reason: CloseReason) {
self.set_statistics_enabled(false);
self.close_tx.send_replace(Some(reason));
}
pub fn mark_committed(&self) {
self.committed.store(true, Ordering::Release);
}
pub fn is_committed(&self) -> bool {
self.committed.load(Ordering::Acquire)
}
pub fn statistics_enabled(&self) -> bool {
self.statistics_enabled.load(Ordering::Acquire)
}
pub fn set_statistics_enabled(&self, enabled: bool) {
self.statistics_enabled.store(enabled, Ordering::Release);
if !enabled {
self.statistics.send_replace(None);
}
}
pub fn clear_statistics(&self) {
self.statistics.send_replace(None);
}
pub fn publish_statistics(&self, snapshot: gpapi::session::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>> {
self.statistics.subscribe()
}
pub async fn send_reply(&self, id: Uuid, result: ServiceResult) {
let _ = self.tx.send(ConnectionCommand::Reply { id, result }).await;
}
@@ -96,12 +143,14 @@ impl WsConnection {
info!("Authenticated GUI connection {}", control.connection_id());
let mut pending_requests = HashSet::new();
let mut statistics_rx = control.subscribe_statistics();
let mut heartbeat = tokio::time::interval(Duration::from_secs(1));
let mut last_outbound = Instant::now();
let mut pong_deadline = None;
loop {
tokio::select! {
biased;
command = command_rx.recv() => {
let Some(command) = command else { break };
match command {
@@ -181,6 +230,16 @@ impl WsConnection {
pong_deadline = Some(now + PONG_TIMEOUT);
}
}
changed = statistics_rx.changed() => {
if changed.is_err() { break; }
let snapshot = statistics_rx.borrow_and_update().clone();
if control.statistics_enabled() {
if let Some(snapshot) = snapshot {
if send_encrypted(&mut socket, &mut noise, &ServerMessage::TunnelStatistics { snapshot }).await.is_err() { break; }
last_outbound = Instant::now();
}
}
}
}
}
@@ -341,6 +400,14 @@ async fn handle_client_message(
return Err(());
}
if let WsRequest::SetTunnelStatisticsEnabled { enabled } = request {
let result = ctx
.set_statistics_enabled(control, session_id, generation, enabled)
.await;
control.send(ConnectionCommand::Reply { id, result }).map_err(|_| ())?;
return Ok(());
}
if let WsRequest::StoreEditedHipReportChunk(report) = request {
let upload_id = report.upload_id.as_deref().and_then(|id| Uuid::parse_str(id).ok());
let result = if report.upload_id.is_some() && upload_id.is_none() {
@@ -596,7 +663,7 @@ mod tests {
Arc::new(AtomicBool::new(false)),
Arc::new(Redaction::new()),
true,
None,
false,
));
let (_state_tx, state_rx) = watch::channel(VpnState::Disconnected);
let context = Arc::new(WsServerContext::new(
@@ -669,6 +736,23 @@ mod tests {
} if id == request_id
));
let statistics_id = Uuid::new_v4();
let request = ClientMessage::Request {
id: statistics_id,
request: WsRequest::SetTunnelStatisticsEnabled { enabled: true },
};
socket
.send(ClientFrame::Binary(noise.encrypt(&request).unwrap().into()))
.await
.unwrap();
let reply = noise
.decrypt::<ServerMessage>(&receive_client_binary(&mut socket).await)
.unwrap();
assert!(matches!(reply, ServerMessage::Reply {
id,
result: ServiceResult::TunnelStatisticsSnapshot(gpapi::session::tunnel::TunnelStatisticsSnapshot::Unavailable { reason: gpapi::session::tunnel::TunnelUnavailableReason::NoTunnel }),
} if id == statistics_id));
let update_id = Uuid::new_v4();
let update_file = tempfile::NamedTempFile::new().unwrap();
std::fs::write(update_file.path(), b"invalid archive").unwrap();
+371 -18
View File
@@ -9,6 +9,7 @@ use gpapi::{
vpn_env::{HostInfo, VpnEnv},
vpn_state::VpnState,
},
session::tunnel::{TunnelStatisticsSnapshot, TunnelUnavailableReason},
utils::lock_file::LockFile,
};
use log::{info, warn};
@@ -31,6 +32,28 @@ struct ServiceState {
revision: u64,
snapshot: VpnEnv,
connections: HashMap<Uuid, ConnectionControl>,
tunnel: crate::vpn_task::TunnelBinding,
}
impl ServiceState {
fn refresh_demand(&self) {
if let Some(monitor) = &self.tunnel.monitor {
monitor.set_statistics_enabled(
self
.connections
.values()
.any(|connection| connection.statistics_enabled() && !connection.is_closed()),
);
}
}
fn snapshot(&self) -> VpnEnv {
let mut snapshot = self.snapshot.clone();
if let Some(monitor) = &self.tunnel.monitor {
snapshot.tunnel_state = Some(monitor.state());
}
snapshot
}
}
pub(crate) struct WsServerContext {
@@ -57,6 +80,7 @@ impl WsServerContext {
revision: 0,
snapshot: build_snapshot(vpn_state_rx.borrow().clone()),
connections: HashMap::new(),
tunnel: Default::default(),
}),
handshake_slots: Arc::new(Semaphore::new(16)),
hip_previews: crate::hip_preview::HipPreviews::new(),
@@ -91,12 +115,14 @@ impl WsServerContext {
let mut state = self.state.lock().await;
let prepared = self.registry.prepare_attach(permit)?;
let mut attached = ServerMessage::Attached {
connection_id: control.connection_id(),
current_revision: state.revision,
snapshot: state.snapshot(),
};
fit_snapshot_message(&mut attached).map_err(|_| SessionError::Unavailable)?;
control
.send(ConnectionCommand::Send(ServerMessage::Attached {
connection_id: control.connection_id(),
current_revision: state.revision,
snapshot: state.snapshot.clone(),
}))
.send(ConnectionCommand::Send(attached))
.map_err(|_| SessionError::Unavailable)?;
state.connections.insert(control.connection_id(), control);
Ok(prepared)
@@ -117,42 +143,49 @@ impl WsServerContext {
}
match self.registry.commit_attach(permit, connection.clone()) {
Ok(replaced) => {
connection.mark_committed();
if let Some(replaced) = &replaced {
replaced.set_statistics_enabled(false);
state.connections.remove(&replaced.connection_id());
}
state.refresh_demand();
Ok(replaced)
}
Err(err) => {
state.connections.remove(&connection.connection_id());
state.refresh_demand();
Err(err)
}
}
}
pub async fn abandon_connection(&self, connection_id: Uuid) {
self.state.lock().await.connections.remove(&connection_id);
let mut state = self.state.lock().await;
state.connections.remove(&connection_id);
state.refresh_demand();
}
pub async fn remove_closed_connections(&self) {
self
.state
.lock()
.await
.connections
.retain(|_, connection| !connection.is_closed());
let mut state = self.state.lock().await;
state.connections.retain(|_, connection| !connection.is_closed());
state.refresh_demand();
}
pub async fn send_snapshot(&self, control: &ConnectionControl) -> Result<(), ()> {
let state = self.state.lock().await;
control.send(ConnectionCommand::Send(ServerMessage::Snapshot {
let mut message = ServerMessage::Snapshot {
current_revision: state.revision,
snapshot: state.snapshot.clone(),
}))
snapshot: state.snapshot(),
};
fit_snapshot_message(&mut message)?;
control.send(ConnectionCommand::Send(message))
}
pub async fn remove_connection(&self, connection_id: Uuid, session_id: Uuid, generation: u64) {
self.registry.disconnect_if_current(session_id, generation);
self.state.lock().await.connections.remove(&connection_id);
let mut state = self.state.lock().await;
state.connections.remove(&connection_id);
state.refresh_demand();
}
pub async fn send_event(&self, event: WsEvent) {
@@ -161,6 +194,8 @@ impl WsServerContext {
state.snapshot = env.clone();
} else if let WsEvent::VpnState(vpn_state) = &event {
state.snapshot.vpn_state = vpn_state.clone();
} else if let WsEvent::TunnelState(tunnel) = &event {
state.snapshot.tunnel_state = tunnel.clone();
}
let Some(revision) = state.revision.checked_add(1) else {
@@ -168,6 +203,7 @@ impl WsServerContext {
connection.close(CloseReason::InternalError);
}
state.connections.clear();
state.refresh_demand();
return;
};
state.revision = revision;
@@ -186,6 +222,97 @@ impl WsServerContext {
false
}
});
state.refresh_demand();
}
pub async fn set_statistics_enabled(
&self,
control: &ConnectionControl,
session_id: Uuid,
generation: u64,
enabled: bool,
) -> gpapi::service::transport::ServiceResult {
use gpapi::service::transport::{ServiceErrorCode, ServiceResult};
let state = self.state.lock().await;
if !control.is_committed()
|| control.is_closed()
|| !state.connections.contains_key(&control.connection_id())
|| !self.registry.is_current(session_id, generation)
{
return ServiceResult::rejected(
ServiceErrorCode::InvalidRequest,
"Service attachment is no longer active",
);
}
control.set_statistics_enabled(enabled);
state.refresh_demand();
let snapshot = match &state.tunnel.monitor {
Some(monitor) => monitor.statistics(),
None => TunnelStatisticsSnapshot::Unavailable {
reason: if state.tunnel.non_tunnel {
TunnelUnavailableReason::NonTunnel
} else {
TunnelUnavailableReason::NoTunnel
},
},
};
ServiceResult::TunnelStatisticsSnapshot(if enabled { snapshot } else { snapshot.disabled() })
}
async fn bind_tunnel(&self, binding: crate::vpn_task::TunnelBinding) {
let mut state = self.state.lock().await;
if let Some(previous) = &state.tunnel.monitor {
previous.set_statistics_enabled(false);
}
state.tunnel = binding;
for connection in state.connections.values() {
connection.clear_statistics();
}
state.refresh_demand();
let tunnel_state = state.tunnel.monitor.as_ref().map(|monitor| monitor.state());
drop(state);
self.send_event(WsEvent::TunnelState(tunnel_state)).await;
let state = self.state.lock().await;
let snapshot = match &state.tunnel.monitor {
Some(monitor) => monitor.statistics(),
None => TunnelStatisticsSnapshot::unavailable(if state.tunnel.non_tunnel {
TunnelUnavailableReason::NonTunnel
} else {
TunnelUnavailableReason::NoTunnel
}),
};
for connection in state.connections.values() {
connection.publish_statistics(snapshot.clone());
}
}
async fn publish_tunnel(&self, attempt: u64) {
let state = self.state.lock().await;
if state.tunnel.attempt != attempt {
return;
}
let Some(monitor) = &state.tunnel.monitor else {
return;
};
let current = monitor.state();
let changed = state
.snapshot
.tunnel_state
.as_ref()
.is_none_or(|previous| previous.tunnel_id != current.tunnel_id || previous.sequence != current.sequence);
drop(state);
if changed {
self.send_event(WsEvent::TunnelState(Some(current))).await;
}
let state = self.state.lock().await;
if state.tunnel.attempt != attempt {
return;
}
if let Some(monitor) = &state.tunnel.monitor {
for connection in state.connections.values() {
connection.publish_statistics(monitor.statistics());
}
}
}
}
@@ -240,6 +367,7 @@ impl WsServer {
_ = watch_vpn_state(self.vpn_state_rx.clone(), Arc::clone(&self.ctx)) => {
info!("VPN state watch task completed");
}
_ = watch_tunnel(self.ctx.dispatcher.subscribe_tunnel(), Arc::clone(&self.ctx)) => {}
result = axum::serve(listener, routes::routes(Arc::clone(&self.ctx))) => {
if let Err(err) = result {
warn!("WS server stopped: {err}");
@@ -264,6 +392,7 @@ impl WsServer {
fn build_snapshot(vpn_state: VpnState) -> VpnEnv {
VpnEnv {
tunnel_state: None,
vpn_state,
vpnc_script: find_vpnc_script(),
auth_executable: binary_paths::gpauth().to_string_lossy().into_owned(),
@@ -273,6 +402,36 @@ fn build_snapshot(vpn_state: VpnState) -> VpnEnv {
}
}
/// Apply the observation's explicit truncation policy to the space remaining in
/// a complete envelope. Existing host/connection facts are never shortened.
fn fit_snapshot_message(message: &mut ServerMessage) -> Result<(), ()> {
let encoded_size = serde_json::to_vec(&message).map_err(|_| ())?.len();
let Some(excess) = encoded_size.checked_sub(gpapi::service::transport::MAX_PLAINTEXT) else {
return Ok(());
};
if excess == 0 {
return Ok(());
}
let snapshot = match message {
ServerMessage::Attached { snapshot, .. } | ServerMessage::Snapshot { snapshot, .. } => snapshot,
_ => return Err(()),
};
let configuration = snapshot
.tunnel_state
.as_mut()
.and_then(|state| state.configuration.as_mut())
.ok_or(())?;
let configuration_size = serde_json::to_vec(&configuration).map_err(|_| ())?.len();
let remaining = configuration_size.checked_sub(excess).ok_or(())?;
if !configuration.limit_encoded_size(remaining) {
return Err(());
}
if serde_json::to_vec(message).map_err(|_| ())?.len() > gpapi::service::transport::MAX_PLAINTEXT {
return Err(());
}
Ok(())
}
#[cfg(test)]
mod tests {
use std::sync::{Arc, atomic::AtomicBool};
@@ -285,6 +444,171 @@ mod tests {
use super::*;
fn context() -> (Arc<WsServerContext>, Arc<SessionRegistry>) {
let registry = Arc::new(SessionRegistry::for_tests(Uuid::new_v4()));
let dispatcher = Arc::new(RequestDispatcher::new(
crate::vpn_task::LifecycleHandle::for_tests(),
Arc::new(AtomicBool::new(false)),
Arc::new(Redaction::new()),
true,
false,
));
let (_, state_rx) = watch::channel(VpnState::Disconnected);
(
Arc::new(WsServerContext::new(
env!("CARGO_PKG_VERSION"),
registry.clone(),
dispatcher,
&state_rx,
)),
registry,
)
}
async fn attach(
context: &WsServerContext,
registry: &Arc<SessionRegistry>,
) -> (ConnectionControl, Uuid, u64, mpsc::Receiver<ConnectionCommand>) {
let credential = registry.issue(env!("CARGO_PKG_VERSION"), None).unwrap();
let permit = registry
.begin_handshake(
credential.service_instance_id(),
credential.session_id(),
credential.product_version(),
)
.unwrap();
let (tx, mut rx) = mpsc::channel(8);
let (control, _) = ConnectionControl::new(Uuid::new_v4(), tx);
let prepared = context.prepare_connection(&permit, control.clone()).await.unwrap();
rx.recv().await.unwrap();
context.commit_connection(&permit, &control).await.unwrap();
(control, credential.session_id(), prepared.generation, rx)
}
#[tokio::test]
async fn statistics_demand_is_per_attachment_and_does_not_consume_revisions() {
use gpapi::service::transport::ServiceResult;
use gpapi::session::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;
let vpn = Arc::new(
openconnect::Vpn::builder("vpn.example.com", "cookie")
.network_configuration_handler(|_| Ok(()))
.build()
.unwrap(),
);
let monitor = gptunnel::TunnelMonitor::attach(vpn);
context
.bind_tunnel(crate::vpn_task::TunnelBinding {
attempt: 1,
monitor: Some(monitor.clone()),
non_tunnel: false,
})
.await;
let revision = context.state.lock().await.revision;
for (connection, session, generation) in [(&a, a_session, a_generation), (&b, b_session, b_generation)] {
assert!(matches!(
context
.set_statistics_enabled(connection, session, generation, true)
.await,
ServiceResult::TunnelStatisticsSnapshot(_)
));
}
assert_eq!(
monitor.statistics().view().unwrap().state,
TunnelStatisticsState::Waiting
);
let ServiceResult::TunnelStatisticsSnapshot(disabled) =
context.set_statistics_enabled(&b, b_session, b_generation, false).await
else {
panic!("expected snapshot");
};
assert_eq!(disabled.view().unwrap().state, TunnelStatisticsState::Disabled);
assert_eq!(
monitor.statistics().view().unwrap().state,
TunnelStatisticsState::Waiting
);
context
.remove_connection(a.connection_id(), a_session, a_generation)
.await;
assert_eq!(
monitor.statistics().view().unwrap().state,
TunnelStatisticsState::Disabled
);
assert_eq!(context.state.lock().await.revision, revision);
monitor.stop().await;
}
#[tokio::test]
async fn sample_slot_coalesces_without_consuming_control_queue_and_disable_clears_it() {
let (context, registry) = context();
let (control, session, generation, mut commands) = attach(&context, &registry).await;
context
.set_statistics_enabled(&control, session, generation, true)
.await;
let mut samples = control.subscribe_statistics();
let snapshot = TunnelStatisticsSnapshot::unavailable(TunnelUnavailableReason::NoTunnel);
for _ in 0..1000 {
control.publish_statistics(snapshot.clone());
}
assert_eq!(samples.borrow_and_update().as_ref(), Some(&snapshot));
assert!(commands.try_recv().is_err());
context
.set_statistics_enabled(&control, session, generation, false)
.await;
assert!(samples.borrow().is_none());
control.publish_statistics(snapshot);
assert!(samples.borrow().is_none());
}
#[test]
fn snapshot_budget_trims_observation_without_changing_existing_metadata() {
use gpapi::session::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];
configuration.included_routes.total_count = 15;
snapshot.tunnel_state = Some(TunnelState {
tunnel_id: Uuid::nil(),
sequence: 4,
phase: TunnelPhase::Connected,
configuration_revision: 1,
configuration: Some(configuration),
transport: TunnelTransport::IpsecEsp,
elapsed_ms: 600_000,
});
let original_metadata = "a".repeat(52_000);
snapshot.auth_executable = original_metadata.clone();
let mut message = ServerMessage::Snapshot {
current_revision: 9,
snapshot,
};
assert!(serde_json::to_vec(&message).unwrap().len() > gpapi::service::transport::MAX_PLAINTEXT);
fit_snapshot_message(&mut message).unwrap();
assert!(serde_json::to_vec(&message).unwrap().len() <= gpapi::service::transport::MAX_PLAINTEXT);
let ServerMessage::Snapshot {
mut snapshot,
current_revision,
} = message
else {
unreachable!()
};
assert_eq!(current_revision, 9);
assert_eq!(snapshot.auth_executable, original_metadata);
let configuration = snapshot.tunnel_state.as_ref().unwrap().configuration.as_ref().unwrap();
assert!(configuration.included_routes.truncated);
assert_eq!(configuration.included_routes.total_count, 15);
snapshot.auth_executable = "a".repeat(gpapi::service::transport::MAX_PLAINTEXT);
assert!(
fit_snapshot_message(&mut ServerMessage::Snapshot {
current_revision: 9,
snapshot
})
.is_err()
);
}
#[tokio::test]
async fn resync_snapshot_is_ordered_with_state_events() {
let registry = Arc::new(SessionRegistry::for_tests(Uuid::new_v4()));
@@ -301,7 +625,7 @@ mod tests {
Arc::new(AtomicBool::new(false)),
Arc::new(Redaction::new()),
true,
None,
false,
));
let (_state_tx, state_rx) = watch::channel(VpnState::Disconnected);
let context = Arc::new(WsServerContext::new(
@@ -351,7 +675,7 @@ mod tests {
Arc::new(AtomicBool::new(false)),
Arc::new(Redaction::new()),
true,
None,
false,
));
let (_state_tx, state_rx) = watch::channel(VpnState::Disconnected);
let context = Arc::new(WsServerContext::new(
@@ -397,3 +721,32 @@ async fn watch_vpn_state(mut vpn_state_rx: watch::Receiver<VpnState>, ctx: Arc<W
ctx.send_event(WsEvent::VpnState(vpn_state)).await;
}
}
async fn watch_tunnel(mut binding_rx: watch::Receiver<crate::vpn_task::TunnelBinding>, ctx: Arc<WsServerContext>) {
loop {
let binding = binding_rx.borrow_and_update().clone();
let mut updates = binding.monitor.as_ref().map(|monitor| monitor.subscribe());
let attempt = binding.attempt;
ctx.bind_tunnel(binding).await;
loop {
tokio::select! {
biased;
changed = binding_rx.changed() => {
if changed.is_err() { return; }
break;
}
changed = async {
match &mut updates {
Some(receiver) => receiver.changed().await,
None => std::future::pending().await,
}
} => {
if changed.is_err() { break; }
// Fence an update against a new lifecycle binding already published.
if binding_rx.has_changed().unwrap_or(true) { break; }
ctx.publish_tunnel(attempt).await;
}
}
}
}
}