mirror of
https://github.com/yuezk/GlobalProtect-openconnect.git
synced 2026-11-19 14:36:15 -05:00
feat: add connection dashboard and improve desktop authentication
Add tunnel configuration reporting, an optional CLI dashboard, manual browser authentication, native authentication controls, and broader client identity support. Improve TLS recovery, certificate validation, desktop notifications, and platform integration.
This commit is contained in:
158 files changed
+13735
-1038
No files matched your search
@@ -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" }
|
||||
@@ -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(®istry));
|
||||
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();
|
||||
|
||||
@@ -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()?;
|
||||
|
||||
@@ -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")
|
||||
);
|
||||
}
|
||||
|
||||
@@ -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)
|
||||
}),
|
||||
)
|
||||
}
|
||||
@@ -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))]
|
||||
|
||||
@@ -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()));
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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
@@ -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, ®istry).await;
|
||||
let (b, b_session, b_generation, _b_rx) = attach(&context, ®istry).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, ®istry).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;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user