use std::sync::{ Arc, Mutex, atomic::{AtomicBool, Ordering}, }; use gpapi::{ service::{ transport::{ServiceErrorCode, ServiceResult}, vpn_state::{ConnectInfo, ConnectedInfo, VpnState}, }, session::{SessionInfo, SessionWarning}, }; use log::{info, warn}; use openconnect::VpnSessionInfo; use tokio::sync::{Notify, mpsc, watch}; use tokio_util::sync::CancellationToken; use uuid::Uuid; use zeroize::Zeroizing; #[cfg(test)] use gpapi::service::request::ConnectRequest; #[cfg(test)] mod ownership_tests; mod non_tunnel; mod preparation; pub(crate) use preparation::{PreparedConnection, prepare_connection}; mod runtime; mod script_tun; #[derive(Clone)] pub(crate) struct LifecycleHandle { #[cfg(windows)] pub(crate) patch_checks: Arc, events: mpsc::Sender, admissions: Arc>, tunnel: watch::Sender, state: watch::Sender, } #[derive(Clone, Default)] pub(crate) struct TunnelBinding { pub attempt: u64, pub monitor: Option>, pub non_tunnel: bool, } impl LifecycleHandle { pub fn subscribe_tunnel(&self) -> watch::Receiver { self.tunnel.subscribe() } pub fn reserve_connect(&self, restart: Option<(u64, Uuid)>) -> Result { let mut admissions = self.admissions.lock().expect("VPN lifecycle admissions mutex poisoned"); if admissions.closed { return Err(ServiceResult::rejected( ServiceErrorCode::Internal, "VPN task is unavailable", )); } if admissions.current.is_some() { return Err(ServiceResult::rejected( ServiceErrorCode::Busy, "A VPN connection is already in progress", )); } if restart.is_some() && admissions.restart != restart { return Err(ServiceResult::rejected( ServiceErrorCode::InvalidRequest, "Reconnect request is no longer current", )); } admissions.restart = None; let attempt = admissions.next_attempt; admissions.next_attempt += 1; let cancellation = CancellationToken::new(); admissions.current = Some(Admission { attempt, phase: AdmissionPhase::Preparing, stop_requested: false, cancellation: cancellation.clone(), completion: Arc::new(AttemptCompletion::default()), }); Ok(ConnectReservation { attempt, lifecycle: self.clone(), cancellation, transferred: false, }) } #[cfg(test)] fn submit_test_connection( &self, request: ConnectRequest, desktop_uid: Option, edited_report: Option>, session_id: Option, ) -> ServiceResult { match self.reserve_connect(None) { Ok(reservation) => reservation.commit( PreparedConnection::lifecycle_fixture(request), desktop_uid, edited_report, session_id, ), Err(result) => result, } } pub fn request_disconnect(&self) -> ServiceResult { let mut admissions = self.admissions.lock().expect("VPN lifecycle admissions mutex poisoned"); admissions.restart = None; let Some(admission) = admissions.current.as_mut() else { self.state.send_replace(VpnState::Disconnected); return ServiceResult::Accepted; }; if admission.stop_requested { return ServiceResult::Accepted; } admission.stop_requested = true; admission.cancellation.cancel(); admission.phase = AdmissionPhase::Stopping; let _ = self.events.try_send(LifecycleEvent::Stop { attempt: admission.attempt, }); ServiceResult::Accepted } #[cfg(any(unix, test))] pub async fn disconnect_and_wait(&self) -> bool { let completion = { let mut admissions = self.admissions.lock().expect("VPN lifecycle admissions mutex poisoned"); let Some(admission) = admissions.current.as_mut() else { return false; }; if !admission.stop_requested { let _ = self.events.try_send(LifecycleEvent::Stop { attempt: admission.attempt, }); admission.stop_requested = true; admission.cancellation.cancel(); admission.phase = AdmissionPhase::Stopping; } Arc::clone(&admission.completion) }; loop { let notified = completion.notify.notified(); if completion.completed.load(Ordering::Acquire) { return true; } notified.await; } } #[cfg(test)] fn has_attempt(&self, attempt: u64) -> bool { self .admissions .lock() .expect("VPN lifecycle admissions mutex poisoned") .current .as_ref() .is_some_and(|admission| admission.attempt == attempt) } fn is_stop_requested(&self, attempt: u64) -> bool { self .admissions .lock() .expect("VPN lifecycle admissions mutex poisoned") .current .as_ref() .is_some_and(|admission| admission.attempt == attempt && admission.stop_requested) } fn close_admission(&self) { let mut admissions = self.admissions.lock().expect("VPN lifecycle admissions mutex poisoned"); admissions.closed = true; if let Some(admission) = &mut admissions.current { admission.stop_requested = true; admission.phase = AdmissionPhase::Stopping; admission.cancellation.cancel(); } } fn attempt_cancellation(&self, attempt: u64) -> CancellationToken { let admissions = self.admissions.lock().expect("VPN lifecycle admissions mutex poisoned"); if let Some(admission) = admissions .current .as_ref() .filter(|admission| admission.attempt == attempt) { return admission.cancellation.clone(); } // A stale queued owner must still drain its transferred sessions. let cancellation = CancellationToken::new(); cancellation.cancel(); cancellation } fn activate_attempt(&self, attempt: u64) -> bool { let mut admissions = self.admissions.lock().expect("VPN lifecycle admissions mutex poisoned"); let Some(admission) = admissions.current.as_mut() else { return false; }; if admission.attempt != attempt || admission.stop_requested || admission.cancellation.is_cancelled() || admission.phase != AdmissionPhase::Pending { return false; } admission.phase = AdmissionPhase::Active; true } fn clear_attempt(&self, attempt: u64) { let completion = { let mut admissions = self.admissions.lock().expect("VPN lifecycle admissions mutex poisoned"); let Some(admission) = admissions.current.as_ref() else { return; }; if admission.attempt != attempt { return; } let completion = Arc::clone(&admission.completion); admissions.current = None; completion }; completion.completed.store(true, Ordering::Release); completion.notify.notify_waiters(); } #[cfg(test)] pub(crate) fn for_tests() -> Self { let (vpn_state_tx, _vpn_state_rx) = watch::channel(VpnState::Disconnected); let registry = Arc::new(crate::session_registry::SessionRegistry::for_tests(Uuid::new_v4())); let (_task, lifecycle) = VpnTask::new(vpn_state_tx, false, registry); lifecycle } } /// A pre-admission reservation owns no server authentication. Dropping it after /// joined preparation releases admission and wakes shutdown; commit transfers /// cleanup ownership atomically with successful queue insertion. pub(crate) struct ConnectReservation { attempt: u64, lifecycle: LifecycleHandle, cancellation: CancellationToken, transferred: bool, } #[derive(Clone)] pub(crate) struct AttemptDrain { cancellation: CancellationToken, completion: Arc, } impl AttemptDrain { pub fn cancel(&self) { self.cancellation.cancel(); } pub fn is_complete(&self) -> bool { self.completion.completed.load(Ordering::Acquire) } pub async fn wait(&self) { loop { let notified = self.completion.notify.notified(); if self.is_complete() { return; } notified.await; } } } impl ConnectReservation { pub fn drain(&self) -> AttemptDrain { let admissions = self .lifecycle .admissions .lock() .expect("VPN lifecycle admissions mutex poisoned"); let admission = admissions .current .as_ref() .filter(|admission| admission.attempt == self.attempt) .expect("reservation retains its admission"); AttemptDrain { cancellation: self.cancellation.clone(), completion: Arc::clone(&admission.completion), } } pub fn cancellation(&self) -> CancellationToken { self.cancellation.clone() } pub fn commit( mut self, connection: PreparedConnection, desktop_uid: Option, edited_report: Option>, session_id: Option, ) -> ServiceResult { let result = { let mut admissions = self .lifecycle .admissions .lock() .expect("VPN lifecycle admissions mutex poisoned"); if admissions.closed { return ServiceResult::rejected(ServiceErrorCode::Internal, "VPN task is unavailable"); } let Some(admission) = admissions .current .as_mut() .filter(|admission| admission.attempt == self.attempt) else { return ServiceResult::rejected( ServiceErrorCode::InvalidRequest, "Connection preparation was superseded", ); }; if admission.stop_requested || self.cancellation.is_cancelled() { return ServiceResult::rejected(ServiceErrorCode::InvalidRequest, "Connection preparation was cancelled"); } match self.lifecycle.events.try_send(LifecycleEvent::Start { attempt: self.attempt, connection, desktop_uid, edited_report, session_id, }) { Ok(()) => { admission.phase = AdmissionPhase::Pending; self.transferred = true; ServiceResult::Accepted } Err(mpsc::error::TrySendError::Full(_)) => { ServiceResult::rejected(ServiceErrorCode::Busy, "VPN lifecycle queue is full") } Err(mpsc::error::TrySendError::Closed(_)) => { ServiceResult::rejected(ServiceErrorCode::Internal, "VPN task is unavailable") } } }; result } } impl Drop for ConnectReservation { fn drop(&mut self) { if !self.transferred { self.cancellation.cancel(); self.lifecycle.clear_attempt(self.attempt); // A full queue already wakes the actor; a closed queue has no actor to wake. let _ = self.lifecycle.events.try_send(LifecycleEvent::PreparationReleased); } } } #[derive(Default)] struct Admissions { closed: bool, next_attempt: u64, current: Option, restart: Option<(u64, Uuid)>, } #[derive(Clone)] struct Admission { attempt: u64, phase: AdmissionPhase, stop_requested: bool, cancellation: CancellationToken, completion: Arc, } #[derive(Default)] struct AttemptCompletion { completed: AtomicBool, notify: Notify, } #[derive(Clone, Copy, Eq, PartialEq)] enum AdmissionPhase { Preparing, Pending, Active, Stopping, } enum LifecycleEvent { TunnelMonitor { attempt: u64, monitor: Arc, }, Start { attempt: u64, connection: PreparedConnection, desktop_uid: Option, edited_report: Option>, session_id: Option, }, Stop { attempt: u64, }, ScriptTunSuspended { attempt: u64, }, ReconnectRequired { attempt: u64, }, Established { attempt: u64, session: VpnSessionInfo, }, MembersChanged { attempt: u64, members: Vec, failures: Vec, }, Ended { attempt: u64, }, Failed { attempt: u64, reason: String, }, PreparationReleased, } struct ActiveAttempt { attempt: u64, session_id: Option, info: ConnectInfo, allow_extend_session: bool, cancellation: CancellationToken, task: tokio::task::JoinHandle<()>, failure: Option, reconnect_required: bool, } pub(crate) struct VpnTask { events: mpsc::Receiver, lifecycle: LifecycleHandle, vpn_state_tx: watch::Sender, restricted_desktop: bool, registry: Arc, active: Option, cancel_token: CancellationToken, } impl VpnTask { pub fn new( vpn_state_tx: watch::Sender, restricted_desktop: bool, registry: Arc, ) -> (Self, LifecycleHandle) { let (events_tx, events) = mpsc::channel(4); let lifecycle = LifecycleHandle { #[cfg(windows)] patch_checks: crate::windows_patches::PatchChecks::new(), events: events_tx, admissions: Arc::new(Mutex::new(Admissions::default())), tunnel: watch::channel(TunnelBinding::default()).0, state: vpn_state_tx.clone(), }; let task = Self { events, lifecycle: lifecycle.clone(), vpn_state_tx, restricted_desktop, registry, active: None, cancel_token: CancellationToken::new(), }; (task, lifecycle) } pub fn cancel_token(&self) -> CancellationToken { self.cancel_token.clone() } pub async fn start(&mut self, server_cancel_token: CancellationToken) { let cancel_token = self.cancel_token.clone(); let mut shutting_down = false; loop { if shutting_down { if self.active.is_none() && !self.has_admission() { break; } let Some(event) = self.events.recv().await else { break }; self.handle_event(event).await; continue; } tokio::select! { event = self.events.recv() => { let Some(event) = event else { break }; self.handle_event(event).await; } _ = cancel_token.cancelled() => { info!("VPN task cancelled"); shutting_down = true; self.lifecycle.close_admission(); if let Some(active) = self.active.as_ref() { self.stop_attempt(active.attempt); } } } } self.lifecycle.close_admission(); server_cancel_token.cancel(); info!("VPN task stopped"); } fn has_admission(&self) -> bool { self .lifecycle .admissions .lock() .expect("VPN lifecycle admissions mutex poisoned") .current .is_some() } 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, desktop_uid, edited_report, session_id, } => self.start_attempt(attempt, connection, desktop_uid, edited_report, session_id), LifecycleEvent::Stop { attempt } => self.stop_attempt(attempt), LifecycleEvent::Established { attempt, session } => self.establish_attempt(attempt, session), LifecycleEvent::MembersChanged { attempt, members, failures, } => self.publish_members(attempt, members, failures), LifecycleEvent::Ended { attempt } => self.end_attempt(attempt).await, LifecycleEvent::Failed { attempt, reason } => { if let Some(active) = self.active.as_mut().filter(|active| active.attempt == attempt) { active.failure = Some(reason); } } LifecycleEvent::ScriptTunSuspended { attempt } => { if let Some(active) = self .active .as_mut() .filter(|a| a.attempt == attempt && !a.cancellation.is_cancelled()) { let info = active.info.clone(); self.send_state(VpnState::Connecting(Box::new(info))); } } LifecycleEvent::ReconnectRequired { attempt } => { if let Some(active) = self.active.as_mut().filter(|a| a.attempt == attempt) { active.reconnect_required = true; } } LifecycleEvent::PreparationReleased => {} } } fn start_attempt( &mut self, attempt: u64, connection: PreparedConnection, desktop_uid: Option, edited_report: Option>, session_id: Option, ) { 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 mut info = connection.request.info().clone(); if let gpapi::script_tun::PacketDelivery::ScriptTun(request) = connection.request.args().packet_delivery() { info.set_script_tun_identity(gpapi::script_tun::Identity { service_instance: self.registry.service_instance_id(), attempt, launch_id: request.launch_id, }); } let allow_extend_session = connection.request.args().allow_extend_session(); let cancellation = self.lifecycle.attempt_cancellation(attempt); if !activated { cancellation.cancel(); } let task = runtime::spawn( runtime::AttemptInput { attempt, connection, desktop_uid, edited_report, session_id, restricted_desktop: self.restricted_desktop, registry: self.registry.clone(), lifecycle: self.lifecycle.clone(), }, cancellation.clone(), self.lifecycle.events.clone(), ); self.active = Some(ActiveAttempt { attempt, session_id, info: info.clone(), allow_extend_session, cancellation, task, failure: None, reconnect_required: false, }); if activated { self.send_state(VpnState::Connecting(Box::new(info))); } } fn stop_attempt(&mut self, attempt: u64) { let Some(active) = self.active.as_ref() else { return; }; if active.attempt != attempt || !self.lifecycle.is_stop_requested(attempt) { return; } info!("Disconnecting VPN..."); self.send_state(VpnState::Disconnecting); active.cancellation.cancel(); } fn establish_attempt(&mut self, attempt: u64, vpn_session_info: VpnSessionInfo) { let Some(active) = self.active.as_ref() else { return; }; if active.attempt != attempt { return; } if active.cancellation.is_cancelled() { return; } let session_info = SessionInfo::from_vpn_session_fields( vpn_session_info.lifetime_secs, vpn_session_info.user_expires, vpn_session_info.lifetime_warning.map(|warning| SessionWarning { prior_secs: warning.prior_secs, message: warning.message, }), active.allow_extend_session, ); self.publish_connected(attempt, active.info.clone(), session_info); } fn publish_members( &self, attempt: u64, members: Vec, failures: Vec, ) { let Some(active) = &self.active else { return; }; if active.attempt != attempt || active.cancellation.is_cancelled() { return; } if !members .iter() .any(|member| member.maintenance == gpapi::session::MaintenanceState::Healthy) { if matches!(&*self.vpn_state_tx.borrow(), VpnState::Connected(_)) { self.send_state(VpnState::Connecting(Box::new(active.info.clone()))); } return; } let admissions = self .lifecycle .admissions .lock() .expect("VPN lifecycle admissions mutex poisoned"); if admissions .current .as_ref() .is_none_or(|admission| admission.attempt != attempt || admission.stop_requested) { return; } let info = match &*self.vpn_state_tx.borrow() { VpnState::Connected(connected) => (**connected).clone(), _ => ConnectedInfo::new(active.info.clone(), None), }; self.send_state(VpnState::Connected(Box::new(info.with_members(members, failures)))); } fn publish_connected(&self, attempt: u64, info: ConnectInfo, session_info: SessionInfo) { let connected = VpnState::Connected(Box::new(ConnectedInfo::new(info, Some(session_info)))); let admissions = self .lifecycle .admissions .lock() .expect("VPN lifecycle admissions mutex poisoned"); if admissions.current.as_ref().is_some_and(|admission| { admission.attempt == attempt && admission.phase == AdmissionPhase::Active && !admission.stop_requested }) { self.send_state(connected); } } async fn end_attempt(&mut self, attempt: u64) { if self.active.as_ref().is_none_or(|active| active.attempt != attempt) { return; } let active = self.active.take().expect("active attempt checked above"); if let Err(error) = active.task.await { warn!("Connection attempt worker failed: {error}"); } 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 active.reconnect_required && !active.cancellation.is_cancelled() && active.session_id.is_some_and(|id| self.registry.has_session(id)) { let mut admissions = self .lifecycle .admissions .lock() .expect("VPN lifecycle admissions mutex poisoned"); if let Some(admission) = admissions.current.take() { if !admission.cancellation.is_cancelled() && !admission.stop_requested { let owner = active.session_id.unwrap(); admissions.restart = Some((attempt, owner)); self.send_state(VpnState::ReconnectRequired(Box::new( gpapi::service::vpn_state::ReconnectRequest { attempt, owner, info: active.info, }, ))); } else { self.send_state(VpnState::Disconnected); } admission.completion.completed.store(true, Ordering::Release); admission.completion.notify.notify_waiters(); } } else if let Some(reason) = active.failure { self.send_state(VpnState::Failed(reason)); self.lifecycle.clear_attempt(attempt); } else { self.finish_attempt(attempt); } } fn finish_attempt(&self, attempt: u64) { self.send_state(VpnState::Disconnected); self.lifecycle.clear_attempt(attempt); } fn send_state(&self, state: VpnState) { let _ = self.vpn_state_tx.send(state); } } fn prepare_identity( args: &gpapi::service::request::ConnectArgs, protected_snapshot_required: bool, ) -> anyhow::Result> { let certificate_path = args.certificate(); let key_path = args.sslkey(); let certificate = args.certificate_data()?.map(Zeroizing::new); let key = args.sslkey_data()?.map(Zeroizing::new); let password = args.key_password().map(Zeroizing::new); if certificate_path.is_some() || key_path.is_some() { anyhow::ensure!( certificate.is_none() && key.is_none(), "Client identity cannot mix paths and protected data" ); anyhow::ensure!( !protected_snapshot_required, "Client identity must be a protected snapshot" ); let certificate_path = certificate_path .as_deref() .ok_or_else(|| anyhow::anyhow!("Client identity key requires a certificate path"))?; return gpapi::utils::request::ClientIdentity::load( certificate_path, key_path.as_deref(), password.as_deref().map(String::as_str), ) .map(Some); } let size = certificate .as_ref() .map_or(0, |data| data.len()) .checked_add(key.as_ref().map_or(0, |data| data.len())); anyhow::ensure!( size.is_some_and(|size| size <= gpapi::service::request::MAX_CLIENT_IDENTITY_DATA), "Client identity exceeds its size limit" ); match (certificate, key) { (None, None) => Ok(None), (Some(certificate), key) => Ok(Some(gpapi::utils::request::ClientIdentity::from_data( certificate, key, password.as_deref().map(String::as_str), )?)), (None, Some(_)) => anyhow::bail!("Client identity key requires certificate data"), } } #[cfg(test)] pub(crate) fn test_connect_request(info: ConnectInfo) -> ConnectRequest { let endpoint = info .gateway() .server() .trim_start_matches("https://") .parse::() .unwrap_or_else(|_| "192.0.2.10:443".parse().unwrap()); let source = if endpoint.ip().is_loopback() { endpoint.ip() } else { "192.0.2.5".parse().unwrap() }; let interface = if endpoint.ip().is_loopback() { if cfg!(target_os = "linux") { "lo" } else { "lo0" } } else { "fixture" }; let binding = gpapi::session::desktop::network::GatewayBinding::new( endpoint, std::net::SocketAddr::new(source, 0), interface.into(), 1, gpapi::session::desktop::ClientAddresses { ipv4: match source { std::net::IpAddr::V4(ip) => Some(ip), _ => None, }, ipv6: match source { std::net::IpAddr::V6(ip) => Some(ip), _ => None, }, }, "0".repeat(64), ) .unwrap(); 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()) .unwrap(), }], vec![], gpapi::session::InternalSessionPolicy::default(), ) .unwrap(); ConnectRequest::new(info, plan) } #[cfg(test)] mod tests { use super::*; use crate::session_registry::SessionRegistry; fn registry() -> Arc { Arc::new(SessionRegistry::for_tests(Uuid::new_v4())) } fn identity_request() -> ConnectRequest { test_connect_request(ConnectInfo::new( "portal.example.com".into(), gpapi::gateway::Gateway::new("gateway".into(), "gateway.example.com".into()), vec![], )) } #[test] fn protected_identity_size_limit_covers_pkcs12_and_combined_pem_before_import() { let limit = gpapi::service::request::MAX_CLIENT_IDENTITY_DATA; for request in [ identity_request().with_certificate_data(Some(vec![0; limit + 1])), identity_request() .with_certificate_data(Some(vec![0; limit])) .with_sslkey_data(Some(vec![0])), ] { assert_eq!( prepare_identity(request.args(), true).unwrap_err().to_string(), "Client identity exceeds its size limit" ); } assert_eq!( prepare_identity(identity_request().with_sslkey_data(Some(vec![0])).args(), true) .unwrap_err() .to_string(), "Client identity key requires certificate data" ); } #[test] fn tunnel_identity_paths_allow_large_files_and_retain_loaded_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_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); let files = identity.write_files(None).unwrap(); assert_eq!(std::fs::read(files.certificate()).unwrap(), certificate); assert!(files.key().is_some()); } #[test] fn protected_identity_rejects_paths_and_all_handoffs_reject_mixed_material() { let path = identity_request().with_certificate(Some("/identity.pem".into())); assert_eq!( prepare_identity(path.args(), true).unwrap_err().to_string(), "Client identity must be a protected snapshot" ); let mixed = path.with_certificate_data(Some(vec![0])); for protected_snapshot_required in [false, true] { assert_eq!( prepare_identity(mixed.args(), protected_snapshot_required) .unwrap_err() .to_string(), "Client identity cannot mix paths and protected data" ); } } #[test] fn protected_pkcs12_import_retains_password_and_single_file_material() { 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())); let wire = serde_json::to_vec(&request).unwrap(); let request: ConnectRequest = serde_json::from_slice(&wire).unwrap(); let identity = prepare_identity(request.args(), true).unwrap().unwrap(); assert_eq!(identity.certificate_data(), p12); assert!(identity.key_data().is_none()); assert_eq!(identity.key_password(), Some(password)); let files = identity.write_files(None).unwrap(); assert!(files.certificate().ends_with(".p12")); assert!(files.key().is_none()); assert_eq!(std::fs::read(files.certificate()).unwrap(), p12); assert!(!format!("{request:?}").contains(password)); } #[test] fn shutdown_cancels_preparation_despite_a_full_queue_and_rejects_commit() { let (state, _state_rx) = watch::channel(VpnState::Disconnected); let (_task, lifecycle) = VpnTask::new(state, false, registry()); let reservation = lifecycle.reserve_connect(None).unwrap(); let cancellation = reservation.cancellation(); while lifecycle.events.try_send(LifecycleEvent::PreparationReleased).is_ok() {} lifecycle.close_admission(); assert!(cancellation.is_cancelled()); assert!(lifecycle.reserve_connect(None).is_err()); let request = test_connect_request(ConnectInfo::new( "portal.example.com".into(), gpapi::gateway::Gateway::new("vpn".into(), "vpn.example.com".into()), vec![], )); assert!(matches!( reservation.commit(PreparedConnection::lifecycle_fixture(request), None, None, None,), ServiceResult::Rejected(..) )); assert!(!lifecycle.has_attempt(0)); assert!(lifecycle.reserve_connect(None).is_err()); } #[test] fn disconnect_cancels_preparation_even_when_stop_notification_queue_is_full() { let (state, _state_rx) = watch::channel(VpnState::Disconnected); let (_task, lifecycle) = VpnTask::new(state, false, registry()); let reservation = lifecycle.reserve_connect(None).unwrap(); while lifecycle.events.try_send(LifecycleEvent::PreparationReleased).is_ok() {} assert_eq!(lifecycle.request_disconnect(), ServiceResult::Accepted); assert!(reservation.cancellation().is_cancelled()); assert!(!reservation.drain().is_complete()); assert!(lifecycle.reserve_connect(None).is_err()); } #[test] fn reconnect_admission_is_owned_single_use_and_cancelled_by_disconnect() { let lifecycle = LifecycleHandle::for_tests(); let owner = Uuid::new_v4(); lifecycle.admissions.lock().unwrap().restart = Some((42, owner)); assert!(lifecycle.reserve_connect(Some((42, Uuid::new_v4()))).is_err()); assert!(lifecycle.reserve_connect(Some((41, owner))).is_err()); let reservation = lifecycle.reserve_connect(Some((42, owner))).unwrap(); drop(reservation); assert!(lifecycle.reserve_connect(Some((42, owner))).is_err()); lifecycle.admissions.lock().unwrap().restart = Some((43, owner)); assert_eq!(lifecycle.request_disconnect(), ServiceResult::Accepted); assert!(lifecycle.reserve_connect(Some((43, owner))).is_err()); assert!(lifecycle.reserve_connect(None).is_ok()); } #[tokio::test] async fn non_tunnel_connected_requires_healthy_hip_and_disappears_when_none_remain() { let (state, state_rx) = watch::channel(VpnState::Disconnected); let (mut task, lifecycle) = VpnTask::new(state, false, registry()); let gateway = gpapi::gateway::Gateway::new("vpn".into(), "vpn.example.com".into()); let info = ConnectInfo::new("portal.example.com".into(), gateway.clone(), vec![]); let reservation = lifecycle.reserve_connect(None).unwrap(); let cancellation = reservation.cancellation(); assert_eq!( reservation.commit( PreparedConnection::lifecycle_fixture(test_connect_request(info.clone())), None, None, None ), ServiceResult::Accepted ); let _ = task.events.recv().await.unwrap(); assert!(lifecycle.activate_attempt(0)); task.active = Some(ActiveAttempt { attempt: 0, session_id: None, info: info.clone(), allow_extend_session: false, cancellation, task: tokio::spawn(async {}), failure: None, reconnect_required: false, }); task.send_state(VpnState::Connecting(Box::new(info))); let mut member = gpapi::session::GatewaySessionSummary { gateway, mode: gpapi::session::SessionMode::NonTunnel, client_ip: Some("192.0.2.1".into()), client_ipv6: None, maintenance: gpapi::session::MaintenanceState::Authenticated, }; task.publish_members(0, vec![member.clone()], vec![]); assert!(matches!(*state_rx.borrow(), VpnState::Connecting(_))); member.maintenance = gpapi::session::MaintenanceState::Healthy; task.publish_members(0, vec![member.clone()], vec![]); assert!(matches!(*state_rx.borrow(), VpnState::Connected(_))); member.maintenance = gpapi::session::MaintenanceState::Rejected; task.publish_members(0, vec![member], vec![]); assert!(!matches!(*state_rx.borrow(), VpnState::Connected(_))); task.end_attempt(0).await; } #[tokio::test] async fn disconnect_completion_waits_for_the_owned_attempt_task() { let (state, state_rx) = watch::channel(VpnState::Disconnected); let (mut task, lifecycle) = VpnTask::new(state, false, registry()); let info = ConnectInfo::new( "portal.example.com".into(), gpapi::gateway::Gateway::new("vpn".into(), "vpn.example.com".into()), vec![], ); assert_eq!( lifecycle.submit_test_connection(test_connect_request(info.clone()), None, None, None), ServiceResult::Accepted ); let _ = task.events.try_recv().unwrap(); assert!(lifecycle.activate_attempt(0)); let cancellation = CancellationToken::new(); let worker_cancel = cancellation.clone(); let events = lifecycle.events.clone(); let (release, wait_release) = tokio::sync::oneshot::channel(); let worker = tokio::spawn(async move { worker_cancel.cancelled().await; events.send(LifecycleEvent::Ended { attempt: 0 }).await.unwrap(); // An Ended notification alone cannot release service admission. The // actor must also join the owned task before admitting another attempt. wait_release.await.unwrap(); }); task.active = Some(ActiveAttempt { attempt: 0, session_id: None, info, allow_extend_session: false, cancellation: cancellation.clone(), task: worker, failure: None, reconnect_required: false, }); assert_eq!(lifecycle.request_disconnect(), ServiceResult::Accepted); let stop = task.events.recv().await.unwrap(); task.handle_event(stop).await; assert!(cancellation.is_cancelled()); assert!(matches!(*state_rx.borrow(), VpnState::Disconnecting)); let ended = task.events.recv().await.unwrap(); let owner = tokio::spawn(async move { task.handle_event(ended).await; task }); tokio::task::yield_now().await; assert!(!owner.is_finished()); assert!(lifecycle.has_attempt(0)); assert!(matches!(*state_rx.borrow(), VpnState::Disconnecting)); release.send(()).unwrap(); let task = owner.await.unwrap(); assert!(task.active.is_none()); assert!(!lifecycle.has_attempt(0)); assert!(matches!(*state_rx.borrow(), VpnState::Disconnected)); } #[tokio::test] async fn approval_revocation_suppresses_a_queued_established_event() { let (state, state_rx) = watch::channel(VpnState::Disconnected); let (mut task, lifecycle) = VpnTask::new(state, false, registry()); let info = ConnectInfo::new( "portal.example.com".into(), gpapi::gateway::Gateway::new("vpn".into(), "vpn.example.com".into()), vec![], ); assert_eq!( lifecycle.submit_test_connection(test_connect_request(info.clone()), None, None, None), ServiceResult::Accepted ); let _ = task.events.try_recv().unwrap(); assert!(lifecycle.activate_attempt(0)); let cancellation = CancellationToken::new(); task.active = Some(ActiveAttempt { attempt: 0, session_id: None, info, allow_extend_session: true, cancellation: cancellation.clone(), task: tokio::spawn(async {}), failure: None, reconnect_required: false, }); task.send_state(VpnState::Connecting(Box::new( task.active.as_ref().unwrap().info.clone(), ))); runtime::stop_for_revoked_approval(&lifecycle, &cancellation); assert!(lifecycle.is_stop_requested(0)); assert!(cancellation.is_cancelled()); task .handle_event(LifecycleEvent::Established { attempt: 0, session: VpnSessionInfo::default(), }) .await; assert!(matches!(*state_rx.borrow(), VpnState::Connecting(_))); task.end_attempt(0).await; } #[tokio::test] async fn disconnect_before_start_drains_the_pending_owner() { let (vpn_state_tx, _vpn_state_rx) = watch::channel(VpnState::Disconnected); let (mut task, lifecycle) = VpnTask::new(vpn_state_tx, false, registry()); let request = test_connect_request(ConnectInfo::new( "portal.example.com".to_string(), gpapi::gateway::Gateway::new("vpn".to_string(), "vpn.example.com".to_string()), vec![], )); assert!(matches!( lifecycle.submit_test_connection(request, None, None, None), ServiceResult::Accepted )); assert!(matches!(lifecycle.request_disconnect(), ServiceResult::Accepted)); let start = task.events.try_recv().unwrap(); task.handle_event(start).await; assert!(lifecycle.has_attempt(0)); assert!(task.active.as_ref().unwrap().cancellation.is_cancelled()); while task.active.is_some() { let event = tokio::time::timeout(std::time::Duration::from_secs(1), task.events.recv()) .await .unwrap() .unwrap(); task.handle_event(event).await; } assert!(!lifecycle.has_attempt(0)); } #[test] fn late_established_event_is_ignored_after_disconnect_is_accepted() { let (vpn_state_tx, vpn_state_rx) = watch::channel(VpnState::Disconnected); let state_rx = vpn_state_rx.clone(); let (task, lifecycle) = VpnTask::new(vpn_state_tx, false, registry()); let info = ConnectInfo::new( "portal.example.com".to_string(), gpapi::gateway::Gateway::new("vpn".to_string(), "vpn.example.com".to_string()), vec![], ); let request = test_connect_request(info.clone()); assert!(matches!( lifecycle.submit_test_connection(request, None, None, None), ServiceResult::Accepted )); assert!(lifecycle.activate_attempt(0)); assert!(matches!(lifecycle.request_disconnect(), ServiceResult::Accepted)); task.publish_connected(0, info, SessionInfo::default()); assert!(matches!(*state_rx.borrow(), VpnState::Disconnected)); } #[tokio::test] async fn disconnect_waiter_completes_for_its_attempt_before_a_later_connect() { let (vpn_state_tx, _vpn_state_rx) = watch::channel(VpnState::Disconnected); let (task, lifecycle) = VpnTask::new(vpn_state_tx, false, registry()); let request = || { test_connect_request(ConnectInfo::new( "portal.example.com".to_string(), gpapi::gateway::Gateway::new("vpn".to_string(), "vpn.example.com".to_string()), vec![], )) }; assert!(matches!( lifecycle.submit_test_connection(request(), None, None, None), ServiceResult::Accepted )); let waiter_lifecycle = lifecycle.clone(); let waiter = tokio::spawn(async move { waiter_lifecycle.disconnect_and_wait().await }); while !lifecycle.is_stop_requested(0) { tokio::task::yield_now().await; } task.finish_attempt(0); assert!(matches!( lifecycle.submit_test_connection(request(), None, None, None), ServiceResult::Accepted )); assert!( tokio::time::timeout(std::time::Duration::from_secs(1), waiter) .await .unwrap() .unwrap() ); } #[test] fn repeated_disconnects_enqueue_one_stop_for_an_attempt() { let (vpn_state_tx, _vpn_state_rx) = watch::channel(VpnState::Disconnected); let (mut task, lifecycle) = VpnTask::new(vpn_state_tx, false, registry()); let request = test_connect_request(ConnectInfo::new( "portal.example.com".to_string(), gpapi::gateway::Gateway::new("vpn".to_string(), "vpn.example.com".to_string()), vec![], )); assert!(matches!( lifecycle.submit_test_connection(request, None, None, None), ServiceResult::Accepted )); assert!(matches!(lifecycle.request_disconnect(), ServiceResult::Accepted)); assert!(matches!(lifecycle.request_disconnect(), ServiceResult::Accepted)); assert!(matches!(task.events.try_recv(), Ok(LifecycleEvent::Start { .. }))); assert!(matches!(task.events.try_recv(), Ok(LifecycleEvent::Stop { .. }))); assert!(matches!(task.events.try_recv(), Err(mpsc::error::TryRecvError::Empty))); } #[test] fn second_connect_is_rejected_while_an_attempt_is_admitted() { let (vpn_state_tx, _vpn_state_rx) = watch::channel(VpnState::Disconnected); let (_task, lifecycle) = VpnTask::new(vpn_state_tx, false, registry()); let request = || { test_connect_request(ConnectInfo::new( "portal.example.com".to_string(), gpapi::gateway::Gateway::new("vpn".to_string(), "vpn.example.com".to_string()), vec![], )) }; assert!(matches!( lifecycle.submit_test_connection(request(), None, None, None), ServiceResult::Accepted )); assert!(matches!( lifecycle.submit_test_connection(request(), None, None, None), ServiceResult::Rejected(rejection) if rejection.code() == ServiceErrorCode::Busy )); } #[test] fn maps_openconnect_session_metadata_to_service_session_info() { let info = SessionInfo::from_vpn_session_fields( Some(43_200), None, Some(SessionWarning { prior_secs: 1_800, message: "Session expires soon".to_string(), }), true, ); assert_eq!(info.lifetime_secs, Some(43_200)); assert_eq!(info.expires_in_human.as_deref(), Some("12h")); assert_eq!(info.lifetime_warning.unwrap().prior_secs, 1_800); assert!(info.allow_extend_session); } #[test] fn direct_request_session_metadata_keeps_extension_disabled() { let info = SessionInfo::from_vpn_session_fields( Some(43_200), None, Some(SessionWarning { prior_secs: 1_800, message: "Session expires soon".to_string(), }), false, ); assert_eq!(info.lifetime_secs, Some(43_200)); assert!(!info.allow_extend_session); } }