mirror of
https://github.com/yuezk/GlobalProtect-openconnect.git
synced 2026-11-18 22:16:18 -05:00
feat: prepare 3.2.0 with Local Proxy and gateway IP preference
This commit is contained in:
47 files changed
+3965
-233
No files matched your search
@@ -112,7 +112,15 @@ pub(crate) struct ConnectArgs {
|
||||
#[arg(short, long, help = "Request MTU from server (legacy servers only)")]
|
||||
pub(super) mtu: Option<u32>,
|
||||
|
||||
#[arg(long, help = "Do not ask for IPv6 connectivity")]
|
||||
#[arg(
|
||||
long,
|
||||
value_enum,
|
||||
default_value = "auto",
|
||||
help = "Choose which IP version to try first when connecting to the gateway"
|
||||
)]
|
||||
pub(super) ip_preference: gpapi::gateway::GatewayIpPreference,
|
||||
|
||||
#[arg(long, help = "Use only IPv4 for traffic inside the VPN tunnel")]
|
||||
pub(super) disable_ipv6: bool,
|
||||
|
||||
#[arg(long = "user-agent", hide = true)]
|
||||
@@ -469,4 +477,28 @@ mod tests {
|
||||
|
||||
assert!(!cli.args.cookie_only);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ip_preference_parses_independently_of_tunnel_ipv6() {
|
||||
use clap::Parser;
|
||||
use gpapi::gateway::GatewayIpPreference;
|
||||
let default = ConnectArgsTestCli::try_parse_from(["test", "portal.example.com"]).unwrap();
|
||||
assert_eq!(default.args.ip_preference, GatewayIpPreference::Auto);
|
||||
for (value, expected) in [
|
||||
("auto", GatewayIpPreference::Auto),
|
||||
("ipv4", GatewayIpPreference::Ipv4),
|
||||
("ipv6", GatewayIpPreference::Ipv6),
|
||||
] {
|
||||
let cli = ConnectArgsTestCli::try_parse_from([
|
||||
"test",
|
||||
"portal.example.com",
|
||||
"--ip-preference",
|
||||
value,
|
||||
"--disable-ipv6",
|
||||
])
|
||||
.unwrap();
|
||||
assert_eq!(cli.args.ip_preference, expected);
|
||||
assert!(cli.args.disable_ipv6);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -452,6 +452,11 @@ impl ConnectHandler<'_> {
|
||||
.reconnect_timeout(self.args.reconnect_timeout)
|
||||
.mtu(mtu)
|
||||
.disable_ipv6(self.args.disable_ipv6)
|
||||
.gateway_ip_preference(match self.args.ip_preference {
|
||||
gpapi::gateway::GatewayIpPreference::Auto => openconnect::GatewayIpPreference::Auto,
|
||||
gpapi::gateway::GatewayIpPreference::Ipv4 => openconnect::GatewayIpPreference::Ipv4,
|
||||
gpapi::gateway::GatewayIpPreference::Ipv6 => openconnect::GatewayIpPreference::Ipv6,
|
||||
})
|
||||
.no_dtls(self.args.no_dtls)
|
||||
.local_hostname(self.args.local_hostname.clone())
|
||||
.dpd_interval(self.args.dpd_interval.unwrap_or(0))
|
||||
|
||||
@@ -3,6 +3,7 @@ use std::{
|
||||
path::{Path, PathBuf},
|
||||
sync::Arc,
|
||||
};
|
||||
use tokio::io::{AsyncReadExt, AsyncWriteExt};
|
||||
|
||||
use anyhow::{Context, bail};
|
||||
use log::{info, warn};
|
||||
@@ -43,14 +44,20 @@ impl CredentialServer {
|
||||
tokio::select! {
|
||||
_ = cancel.cancelled() => break,
|
||||
accepted = listener.accept() => {
|
||||
let (stream, _) = accepted?;
|
||||
let (mut stream, _) = accepted?;
|
||||
if peer_uid(&stream)? != 0 {
|
||||
warn!("Rejected non-root broker credential client");
|
||||
continue;
|
||||
}
|
||||
let registry = Arc::clone(&self.registry);
|
||||
tokio::spawn(async move {
|
||||
if let Err(err) = credential_lease::serve(stream, registry, None).await {
|
||||
let identity = tokio::time::timeout(std::time::Duration::from_secs(5), stream.read_u32()).await;
|
||||
let uid = match identity {
|
||||
Ok(Ok(0)) => { let _ = stream.write_u8(1).await; return; }
|
||||
Ok(Ok(uid)) => uid,
|
||||
_ => { warn!("Invalid desktop identity from broker"); return; }
|
||||
};
|
||||
if let Err(err) = credential_lease::serve(stream, registry, Some(uid)).await {
|
||||
warn!("Broker credential lease ended: {err}");
|
||||
}
|
||||
});
|
||||
|
||||
@@ -138,7 +138,9 @@ impl RequestDispatcher {
|
||||
authority
|
||||
.registry
|
||||
.reserve_connection(authority.session_id, authority.generation, non_tunnel, || {
|
||||
self.lifecycle.reserve_connect()
|
||||
self
|
||||
.lifecycle
|
||||
.reserve_connect(request.restart_of().map(|attempt| (attempt, authority.session_id)))
|
||||
})?;
|
||||
let preparation = ConnectionPreparation {
|
||||
authority,
|
||||
@@ -599,4 +601,29 @@ mod tests {
|
||||
Err("macOS does not support custom HIP scripts")
|
||||
);
|
||||
}
|
||||
#[test]
|
||||
#[ignore = "requires GP_TEST_GUI_BINARY pointing to a built gpgui"]
|
||||
fn installs_single_gui_binary_for_fresh_and_upgrade_downloads() {
|
||||
let binary = std::fs::read(std::env::var("GP_TEST_GUI_BINARY").expect("GP_TEST_GUI_BINARY")).unwrap();
|
||||
let archive = compressed_gui_archive(&binary);
|
||||
let checksum = gpapi::utils::checksum::file_sha256(archive.path()).unwrap();
|
||||
let temporary = tempfile::tempdir().unwrap();
|
||||
let output = std::env::var_os("GP_TEST_GUI_INSTALL_DIR")
|
||||
.map(std::path::PathBuf::from)
|
||||
.unwrap_or_else(|| temporary.path().to_owned());
|
||||
std::fs::create_dir_all(&output).unwrap();
|
||||
std::fs::set_permissions(&output, std::fs::Permissions::from_mode(0o755)).unwrap();
|
||||
let target = output.join("gpclient/gpgui");
|
||||
for upgrade in [false, true] {
|
||||
if upgrade {
|
||||
std::fs::write(&target, b"old GUI").unwrap();
|
||||
}
|
||||
install_gui_at(archive.path(), &checksum, &target).unwrap();
|
||||
assert_eq!(std::fs::read_dir(target.parent().unwrap()).unwrap().count(), 1);
|
||||
assert_eq!(std::fs::read(&target).unwrap(), binary);
|
||||
let result = std::process::Command::new(&target).arg("--version").output().unwrap();
|
||||
assert!(result.status.success(), "{}", String::from_utf8_lossy(&result.stderr));
|
||||
assert!(String::from_utf8_lossy(&result.stdout).contains(env!("CARGO_PKG_VERSION")));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -190,6 +190,10 @@ impl SessionRegistry {
|
||||
Ok(None)
|
||||
}
|
||||
|
||||
pub fn service_instance_id(&self) -> Uuid {
|
||||
self.service_instance_id
|
||||
}
|
||||
|
||||
pub fn new(service_instance_id: Uuid) -> Self {
|
||||
Self {
|
||||
service_instance_id,
|
||||
@@ -425,6 +429,13 @@ impl SessionRegistry {
|
||||
}
|
||||
}
|
||||
|
||||
pub fn has_session(&self, session_id: Uuid) -> bool {
|
||||
self
|
||||
.sessions
|
||||
.lock()
|
||||
.is_ok_and(|sessions| sessions.contains_key(&session_id))
|
||||
}
|
||||
|
||||
pub fn is_current(&self, session_id: Uuid, generation: u64) -> bool {
|
||||
let Ok(sessions) = self.sessions.lock() else {
|
||||
return false;
|
||||
@@ -653,7 +664,7 @@ mod tests {
|
||||
let (state, _state_rx) = tokio::sync::watch::channel(gpapi::service::vpn_state::VpnState::Disconnected);
|
||||
let (_task, lifecycle) = crate::vpn_task::VpnTask::new(state, false, registry.clone());
|
||||
let reservation = registry
|
||||
.reserve_connection(session, 1, true, || lifecycle.reserve_connect())
|
||||
.reserve_connection(session, 1, true, || lifecycle.reserve_connect(None))
|
||||
.unwrap();
|
||||
let drain = reservation.drain();
|
||||
let cancel = reservation.cancellation();
|
||||
@@ -669,7 +680,7 @@ mod tests {
|
||||
assert!(!drain.is_complete());
|
||||
assert!(
|
||||
registry
|
||||
.reserve_connection(session, 2, true, || lifecycle.reserve_connect())
|
||||
.reserve_connection(session, 2, true, || lifecycle.reserve_connect(None))
|
||||
.is_err()
|
||||
);
|
||||
assert!(matches!(
|
||||
@@ -680,7 +691,7 @@ mod tests {
|
||||
drain.wait().await;
|
||||
|
||||
let next_reservation = registry
|
||||
.reserve_connection(session, 2, true, || lifecycle.reserve_connect())
|
||||
.reserve_connection(session, 2, true, || lifecycle.reserve_connect(None))
|
||||
.unwrap();
|
||||
assert!(
|
||||
registry
|
||||
@@ -710,7 +721,7 @@ mod tests {
|
||||
let (state, _state_rx) = tokio::sync::watch::channel(gpapi::service::vpn_state::VpnState::Disconnected);
|
||||
let (_task, lifecycle) = crate::vpn_task::VpnTask::new(state, false, registry.clone());
|
||||
let reservation = registry
|
||||
.reserve_connection(session, 1, true, || lifecycle.reserve_connect())
|
||||
.reserve_connection(session, 1, true, || lifecycle.reserve_connect(None))
|
||||
.unwrap();
|
||||
let drain = registry.stop_non_tunnel_attachment(session, 1, id).unwrap().unwrap();
|
||||
assert!(reservation.cancellation().is_cancelled());
|
||||
@@ -728,7 +739,7 @@ mod tests {
|
||||
);
|
||||
assert!(
|
||||
registry
|
||||
.reserve_connection(session, 1, false, || lifecycle.reserve_connect())
|
||||
.reserve_connection(session, 1, false, || lifecycle.reserve_connect(None))
|
||||
.is_ok()
|
||||
);
|
||||
}
|
||||
@@ -748,7 +759,7 @@ mod tests {
|
||||
let (state, _state_rx) = tokio::sync::watch::channel(gpapi::service::vpn_state::VpnState::Disconnected);
|
||||
let (_task, lifecycle) = crate::vpn_task::VpnTask::new(state, false, registry.clone());
|
||||
let tunnel = registry
|
||||
.reserve_connection(session, 1, false, || lifecycle.reserve_connect())
|
||||
.reserve_connection(session, 1, false, || lifecycle.reserve_connect(None))
|
||||
.unwrap();
|
||||
registry.disconnect_if_current(session, 1);
|
||||
assert!(!tunnel.cancellation().is_cancelled());
|
||||
@@ -765,7 +776,7 @@ mod tests {
|
||||
.commit_attach(&permit, ConnectionControl::new(Uuid::new_v4(), tx).0)
|
||||
.unwrap();
|
||||
let session_work = registry
|
||||
.reserve_connection(session, 2, true, || lifecycle.reserve_connect())
|
||||
.reserve_connection(session, 2, true, || lifecycle.reserve_connect(None))
|
||||
.unwrap();
|
||||
registry.revoke(session);
|
||||
assert!(session_work.cancellation().is_cancelled());
|
||||
|
||||
@@ -27,12 +27,14 @@ mod non_tunnel;
|
||||
mod preparation;
|
||||
pub(crate) use preparation::{PreparedConnection, prepare_connection};
|
||||
mod runtime;
|
||||
mod script_tun;
|
||||
|
||||
#[derive(Clone)]
|
||||
pub(crate) struct LifecycleHandle {
|
||||
events: mpsc::Sender<LifecycleEvent>,
|
||||
admissions: Arc<Mutex<Admissions>>,
|
||||
tunnel: watch::Sender<TunnelBinding>,
|
||||
state: watch::Sender<VpnState>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Default)]
|
||||
@@ -46,7 +48,7 @@ impl LifecycleHandle {
|
||||
pub fn subscribe_tunnel(&self) -> watch::Receiver<TunnelBinding> {
|
||||
self.tunnel.subscribe()
|
||||
}
|
||||
pub fn reserve_connect(&self) -> Result<ConnectReservation, ServiceResult> {
|
||||
pub fn reserve_connect(&self, restart: Option<(u64, Uuid)>) -> Result<ConnectReservation, ServiceResult> {
|
||||
let mut admissions = self.admissions.lock().expect("VPN lifecycle admissions mutex poisoned");
|
||||
if admissions.closed {
|
||||
return Err(ServiceResult::rejected(
|
||||
@@ -60,6 +62,13 @@ impl LifecycleHandle {
|
||||
"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();
|
||||
@@ -86,7 +95,7 @@ impl LifecycleHandle {
|
||||
edited_report: Option<Arc<str>>,
|
||||
session_id: Option<Uuid>,
|
||||
) -> ServiceResult {
|
||||
match self.reserve_connect() {
|
||||
match self.reserve_connect(None) {
|
||||
Ok(reservation) => reservation.commit(
|
||||
PreparedConnection::lifecycle_fixture(request),
|
||||
desktop_uid,
|
||||
@@ -99,7 +108,9 @@ impl LifecycleHandle {
|
||||
|
||||
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 {
|
||||
@@ -355,6 +366,7 @@ struct Admissions {
|
||||
closed: bool,
|
||||
next_attempt: u64,
|
||||
current: Option<Admission>,
|
||||
restart: Option<(u64, Uuid)>,
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
@@ -395,6 +407,12 @@ enum LifecycleEvent {
|
||||
Stop {
|
||||
attempt: u64,
|
||||
},
|
||||
ScriptTunSuspended {
|
||||
attempt: u64,
|
||||
},
|
||||
ReconnectRequired {
|
||||
attempt: u64,
|
||||
},
|
||||
Established {
|
||||
attempt: u64,
|
||||
session: VpnSessionInfo,
|
||||
@@ -422,6 +440,7 @@ struct ActiveAttempt {
|
||||
cancellation: CancellationToken,
|
||||
task: tokio::task::JoinHandle<()>,
|
||||
failure: Option<String>,
|
||||
reconnect_required: bool,
|
||||
}
|
||||
|
||||
pub(crate) struct VpnTask {
|
||||
@@ -445,6 +464,7 @@ impl VpnTask {
|
||||
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,
|
||||
@@ -539,6 +559,21 @@ impl VpnTask {
|
||||
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 => {}
|
||||
}
|
||||
}
|
||||
@@ -562,7 +597,14 @@ impl VpnTask {
|
||||
.iter()
|
||||
.all(|member| member.authentication.mode() == gpapi::session::SessionMode::NonTunnel),
|
||||
});
|
||||
let info = connection.request.info().clone();
|
||||
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 {
|
||||
@@ -590,6 +632,7 @@ impl VpnTask {
|
||||
cancellation,
|
||||
task,
|
||||
failure: None,
|
||||
reconnect_required: false,
|
||||
});
|
||||
if activated {
|
||||
self.send_state(VpnState::Connecting(Box::new(info)));
|
||||
@@ -703,7 +746,33 @@ impl VpnTask {
|
||||
..Default::default()
|
||||
});
|
||||
}
|
||||
if let Some(reason) = active.failure {
|
||||
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 {
|
||||
@@ -918,12 +987,12 @@ mod tests {
|
||||
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().unwrap();
|
||||
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().is_err());
|
||||
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()),
|
||||
@@ -934,19 +1003,35 @@ mod tests {
|
||||
ServiceResult::Rejected(..)
|
||||
));
|
||||
assert!(!lifecycle.has_attempt(0));
|
||||
assert!(lifecycle.reserve_connect().is_err());
|
||||
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().unwrap();
|
||||
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().is_err());
|
||||
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]
|
||||
@@ -955,7 +1040,7 @@ mod tests {
|
||||
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().unwrap();
|
||||
let reservation = lifecycle.reserve_connect(None).unwrap();
|
||||
let cancellation = reservation.cancellation();
|
||||
assert_eq!(
|
||||
reservation.commit(
|
||||
@@ -976,6 +1061,7 @@ mod tests {
|
||||
cancellation,
|
||||
task: tokio::spawn(async {}),
|
||||
failure: None,
|
||||
reconnect_required: false,
|
||||
});
|
||||
task.send_state(VpnState::Connecting(Box::new(info)));
|
||||
let mut member = gpapi::session::GatewaySessionSummary {
|
||||
@@ -1030,6 +1116,7 @@ mod tests {
|
||||
cancellation: cancellation.clone(),
|
||||
task: worker,
|
||||
failure: None,
|
||||
reconnect_required: false,
|
||||
});
|
||||
assert_eq!(lifecycle.request_disconnect(), ServiceResult::Accepted);
|
||||
let stop = task.events.recv().await.unwrap();
|
||||
@@ -1076,6 +1163,7 @@ mod tests {
|
||||
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(),
|
||||
|
||||
@@ -151,7 +151,7 @@ async fn cancelled_pending_owner_logs_out_and_releases_admission_after_response(
|
||||
let (state, state_rx) = watch::channel(VpnState::Disconnected);
|
||||
let (mut task, lifecycle) = VpnTask::new(state, false, registry.clone());
|
||||
let reservation = registry
|
||||
.reserve_connection(session_id, 1, true, || lifecycle.reserve_connect())
|
||||
.reserve_connection(session_id, 1, true, || lifecycle.reserve_connect(None))
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
registry.commit_connection(session_id, 1, true, || reservation.commit(
|
||||
@@ -178,7 +178,7 @@ async fn cancelled_pending_owner_logs_out_and_releases_admission_after_response(
|
||||
.unwrap();
|
||||
assert!(lifecycle.has_attempt(0));
|
||||
assert!(!drain_waiter.is_finished());
|
||||
assert!(lifecycle.reserve_connect().is_err());
|
||||
assert!(lifecycle.reserve_connect(None).is_err());
|
||||
assert!(!task.active.as_ref().unwrap().task.is_finished());
|
||||
assert!(matches!(*state_rx.borrow(), VpnState::Disconnected));
|
||||
release.send(()).unwrap();
|
||||
@@ -191,7 +191,7 @@ async fn cancelled_pending_owner_logs_out_and_releases_admission_after_response(
|
||||
}
|
||||
assert!(!lifecycle.has_attempt(0));
|
||||
drain_waiter.await.unwrap();
|
||||
assert!(lifecycle.reserve_connect().is_ok());
|
||||
assert!(lifecycle.reserve_connect(None).is_ok());
|
||||
assert!(matches!(*state_rx.borrow(), VpnState::Disconnected));
|
||||
let request = server.await.unwrap();
|
||||
assert!(request.starts_with("POST /ssl-vpn/logout.esp "));
|
||||
|
||||
@@ -31,7 +31,17 @@ pub(crate) async fn prepare_connection(
|
||||
brokered_macos: bool,
|
||||
cancellation: CancellationToken,
|
||||
) -> anyhow::Result<PreparedConnection> {
|
||||
let mode = request.args().packet_delivery().clone();
|
||||
let request = request.with_packet_delivery(mode);
|
||||
let args = request.args();
|
||||
if let gpapi::script_tun::PacketDelivery::ScriptTun(consumer) = args.packet_delivery() {
|
||||
consumer.validate()?;
|
||||
anyhow::ensure!(
|
||||
request.plan().members().len() == 1
|
||||
&& request.plan().members()[0].authentication.mode() == gpapi::session::SessionMode::Tunnel,
|
||||
"Script-tun requires a tunnel gateway"
|
||||
);
|
||||
}
|
||||
let non_tunnel = request
|
||||
.plan()
|
||||
.members()
|
||||
|
||||
@@ -31,10 +31,12 @@ struct TunnelInput {
|
||||
source: Arc<openconnect::HipSource>,
|
||||
session_id: Option<Uuid>,
|
||||
registry: Arc<crate::session_registry::SessionRegistry>,
|
||||
desktop_uid: Option<u32>,
|
||||
}
|
||||
|
||||
struct PreparedTunnel {
|
||||
vpn: Arc<Vpn>,
|
||||
script_tun: Option<super::script_tun::PreparedScriptTun>,
|
||||
}
|
||||
|
||||
/// The accepted attempt owns cleanup through fallible setup. Non-tunnel workers
|
||||
@@ -47,13 +49,6 @@ pub(super) fn spawn(
|
||||
) -> JoinHandle<()> {
|
||||
tokio::spawn(async move {
|
||||
let attempt = input.attempt;
|
||||
let non_tunnel = input
|
||||
.connection
|
||||
.request
|
||||
.plan()
|
||||
.members()
|
||||
.iter()
|
||||
.all(|member| member.authentication.mode() == SessionMode::NonTunnel);
|
||||
let mut failure = None;
|
||||
let mut approval = None;
|
||||
if !cancellation.is_cancelled() {
|
||||
@@ -110,24 +105,65 @@ pub(super) fn spawn(
|
||||
source,
|
||||
session_id: input.session_id,
|
||||
registry: input.registry.clone(),
|
||||
desktop_uid: input.desktop_uid,
|
||||
};
|
||||
input.connection.request.release_script_tun_bootstrap();
|
||||
let setup_cancel = cancellation.clone();
|
||||
let prepared = tokio::task::spawn_blocking(move || prepare_tunnel(tunnel_input, &setup_cancel)).await;
|
||||
match prepared {
|
||||
Ok(Ok(prepared)) => {
|
||||
run_tunnel(
|
||||
attempt,
|
||||
&prepared,
|
||||
guard,
|
||||
&input.lifecycle,
|
||||
&mut input.connection.sessions,
|
||||
cancellation.clone(),
|
||||
events.clone(),
|
||||
)
|
||||
.await
|
||||
Ok(Ok(mut prepared)) => {
|
||||
if let Some(script_tun) = prepared.script_tun.take() {
|
||||
if let Some(session_id) = input.session_id {
|
||||
match super::script_tun::run(
|
||||
gpapi::script_tun::Identity {
|
||||
service_instance: input.registry.service_instance_id(),
|
||||
attempt,
|
||||
launch_id: match input.connection.request.args().packet_delivery() {
|
||||
gpapi::script_tun::PacketDelivery::ScriptTun(request) => request.launch_id,
|
||||
_ => unreachable!(),
|
||||
},
|
||||
},
|
||||
prepared.vpn.clone(),
|
||||
script_tun,
|
||||
guard,
|
||||
&input.lifecycle,
|
||||
cancellation.clone(),
|
||||
events.clone(),
|
||||
session_id,
|
||||
input.registry.clone(),
|
||||
&mut input.connection.sessions,
|
||||
)
|
||||
.await
|
||||
{
|
||||
Ok(()) => {}
|
||||
Err(error) if error.is::<super::script_tun::NetworkChanged>() && !cancellation.is_cancelled() => {
|
||||
let _ = events.send(LifecycleEvent::ReconnectRequired { attempt }).await;
|
||||
}
|
||||
Err(error) if !cancellation.is_cancelled() => {
|
||||
failure = Some(error.to_string());
|
||||
}
|
||||
Err(_) => {}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
run_tunnel(
|
||||
attempt,
|
||||
&prepared,
|
||||
guard,
|
||||
&input.lifecycle,
|
||||
&mut input.connection.sessions,
|
||||
cancellation.clone(),
|
||||
events.clone(),
|
||||
)
|
||||
.await;
|
||||
}
|
||||
}
|
||||
Ok(Err(error)) => {
|
||||
failure = Some(format!("Failed to prepare tunnel: {error:#}"));
|
||||
}
|
||||
Err(error) => {
|
||||
failure = Some(format!("Tunnel setup worker failed: {error}"));
|
||||
}
|
||||
Ok(Err(error)) => warn!("Failed to prepare tunnel: {error:#}"),
|
||||
Err(error) => warn!("Tunnel setup worker failed: {error}"),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -145,7 +181,7 @@ pub(super) fn spawn(
|
||||
// Identity and approval remain alive through worker drain and logout. Ended
|
||||
// only releases admission after the actor also joins this task.
|
||||
drop(approval);
|
||||
if non_tunnel && !cancellation.is_cancelled() {
|
||||
if !cancellation.is_cancelled() {
|
||||
if let Some(reason) = failure {
|
||||
let _ = events.send(LifecycleEvent::Failed { attempt, reason }).await;
|
||||
}
|
||||
@@ -210,8 +246,24 @@ fn prepare_tunnel(input: TunnelInput, cancellation: &CancellationToken) -> anyho
|
||||
);
|
||||
let member = &input.request.plan().members()[0];
|
||||
let identity_files = &input.resources.identity_files;
|
||||
let (builder, script_tun) = match args.packet_delivery() {
|
||||
gpapi::script_tun::PacketDelivery::System => (
|
||||
crate::vpn_script::builder(member.gateway.server(), member.authentication.cookie(), args)?,
|
||||
None,
|
||||
),
|
||||
gpapi::script_tun::PacketDelivery::ScriptTun(request) => {
|
||||
ensure!(input.session_id.is_some(), "Script-tun requires a desktop session");
|
||||
let (builder, script_tun) = super::script_tun::builder(
|
||||
member.gateway.server(),
|
||||
member.authentication.cookie(),
|
||||
request,
|
||||
input.desktop_uid.context("Desktop identity is unavailable")?,
|
||||
)?;
|
||||
(builder, Some(script_tun))
|
||||
}
|
||||
};
|
||||
let vpn = Arc::new(
|
||||
crate::vpn_script::builder(member.gateway.server(), member.authentication.cookie(), args)?
|
||||
builder
|
||||
.user_agent(args.user_agent())
|
||||
.os(args.openconnect_os())
|
||||
.os_version(args.os_version())
|
||||
@@ -231,6 +283,11 @@ fn prepare_tunnel(input: TunnelInput, cancellation: &CancellationToken) -> anyho
|
||||
.reconnect_timeout(args.reconnect_timeout())
|
||||
.mtu(args.mtu())
|
||||
.disable_ipv6(args.disable_ipv6())
|
||||
.gateway_ip_preference(match args.gateway_ip_preference() {
|
||||
gpapi::gateway::GatewayIpPreference::Auto => openconnect::GatewayIpPreference::Auto,
|
||||
gpapi::gateway::GatewayIpPreference::Ipv4 => openconnect::GatewayIpPreference::Ipv4,
|
||||
gpapi::gateway::GatewayIpPreference::Ipv6 => openconnect::GatewayIpPreference::Ipv6,
|
||||
})
|
||||
.no_dtls(args.no_dtls())
|
||||
.local_hostname(args.local_hostname())
|
||||
.dpd_interval(args.force_dpd())
|
||||
@@ -247,7 +304,7 @@ fn prepare_tunnel(input: TunnelInput, cancellation: &CancellationToken) -> anyho
|
||||
}
|
||||
});
|
||||
}
|
||||
Ok(PreparedTunnel { vpn })
|
||||
Ok(PreparedTunnel { vpn, script_tun })
|
||||
}
|
||||
|
||||
async fn run_tunnel(
|
||||
|
||||
@@ -0,0 +1,247 @@
|
||||
//! Supervision of an unprivileged script-tun consumer; payload semantics belong to the caller.
|
||||
use super::{LifecycleEvent, LifecycleHandle};
|
||||
use anyhow::{Context, bail, ensure};
|
||||
use gpapi::script_tun::{Bootstrap, Identity, Message, ScriptTunRequest, receive, send as send_message};
|
||||
use openconnect::{Vpn, VpnBuilder, tunnel::Event};
|
||||
use std::{sync::Arc, time::Duration};
|
||||
use tokio::{net::UnixStream, sync::mpsc, time::Instant};
|
||||
use tokio_util::sync::CancellationToken;
|
||||
|
||||
pub(super) struct PreparedScriptTun {
|
||||
pub control: std::os::unix::net::UnixStream,
|
||||
pub bootstrap: Bootstrap,
|
||||
}
|
||||
|
||||
pub(super) fn builder(
|
||||
server: &str,
|
||||
cookie: &str,
|
||||
request: &ScriptTunRequest,
|
||||
uid: u32,
|
||||
) -> anyhow::Result<(VpnBuilder, PreparedScriptTun)> {
|
||||
request.validate()?;
|
||||
ensure!(uid != 0, "Script-tun worker requires a desktop user");
|
||||
let (control, child) = std::os::unix::net::UnixStream::pair()?;
|
||||
let builder = Vpn::builder(server, cookie).script_tun_program(
|
||||
request.program.to_str().context("Program is not UTF-8")?,
|
||||
&request.args,
|
||||
uid,
|
||||
child.into(),
|
||||
)?;
|
||||
Ok((
|
||||
builder,
|
||||
PreparedScriptTun {
|
||||
control,
|
||||
bootstrap: request.bootstrap.clone(),
|
||||
},
|
||||
))
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub(super) struct NetworkChanged;
|
||||
impl std::fmt::Display for NetworkChanged {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
f.write_str("VPN network configuration changed")
|
||||
}
|
||||
}
|
||||
impl std::error::Error for NetworkChanged {}
|
||||
|
||||
enum Native {
|
||||
Event(Event),
|
||||
Established(openconnect::VpnSessionInfo),
|
||||
}
|
||||
|
||||
pub(super) async fn run(
|
||||
identity: Identity,
|
||||
vpn: Arc<Vpn>,
|
||||
prepared: PreparedScriptTun,
|
||||
approval: &crate::hip_source::HipApproval,
|
||||
lifecycle: &LifecycleHandle,
|
||||
cancellation: CancellationToken,
|
||||
events: mpsc::Sender<LifecycleEvent>,
|
||||
session_id: uuid::Uuid,
|
||||
registry: Arc<crate::session_registry::SessionRegistry>,
|
||||
sessions: &mut gpapi::session::GatewaySessions,
|
||||
) -> anyhow::Result<()> {
|
||||
let attempt = identity.attempt;
|
||||
let (native_tx, native) = mpsc::channel(64);
|
||||
let observed = native_tx.clone();
|
||||
let overflow = cancellation.clone();
|
||||
let monitor = gptunnel::TunnelMonitor::attach_with_observer(vpn.clone(), move |event| {
|
||||
if !matches!(event, Event::Statistics(_)) && observed.try_send(Native::Event(event.clone())).is_err() {
|
||||
overflow.cancel();
|
||||
}
|
||||
});
|
||||
let event_result = events
|
||||
.send(LifecycleEvent::TunnelMonitor {
|
||||
attempt,
|
||||
monitor: monitor.clone(),
|
||||
})
|
||||
.await;
|
||||
if event_result.is_err() {
|
||||
monitor.stop().await;
|
||||
return Ok(());
|
||||
}
|
||||
let worker_vpn = vpn.clone();
|
||||
std::mem::take(sessions).relinquish();
|
||||
let worker = tokio::task::spawn_blocking(move || {
|
||||
worker_vpn.connect(move |session| {
|
||||
let _ = native_tx.try_send(Native::Established(session));
|
||||
})
|
||||
});
|
||||
tokio::pin!(worker);
|
||||
let mut worker_done = false;
|
||||
let stop = cancellation.child_token();
|
||||
let supervisor = supervise(identity, prepared, native, stop.clone(), events);
|
||||
tokio::pin!(supervisor);
|
||||
let mut supervisor_done = false;
|
||||
let mut approval_poll = tokio::time::interval(Duration::from_millis(250));
|
||||
let result = loop {
|
||||
tokio::select! {
|
||||
biased;
|
||||
result = &mut supervisor => { supervisor_done = true; break result; }
|
||||
result = &mut worker => { worker_done = true; break Err(anyhow::anyhow!("VPN worker ended: {:?}", result)); }
|
||||
_ = approval_poll.tick() => {
|
||||
if !approval.approval_is_valid() || !registry.has_session(session_id) {
|
||||
super::runtime::stop_for_revoked_approval(lifecycle, &cancellation);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
stop.cancel();
|
||||
if !supervisor_done {
|
||||
let _ = supervisor.await;
|
||||
}
|
||||
vpn.disconnect();
|
||||
if !worker_done {
|
||||
let _ = worker.await;
|
||||
}
|
||||
monitor.stop().await;
|
||||
result
|
||||
}
|
||||
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
enum WorkerState {
|
||||
Preparing,
|
||||
Ready,
|
||||
Activating,
|
||||
Active,
|
||||
Suspending,
|
||||
}
|
||||
|
||||
// The same control loop runs against native observations in production and a
|
||||
// generic socket consumer in tests; VPN ownership stays in run().
|
||||
async fn supervise(
|
||||
identity: Identity,
|
||||
mut prepared: PreparedScriptTun,
|
||||
mut native: mpsc::Receiver<Native>,
|
||||
cancellation: CancellationToken,
|
||||
events: mpsc::Sender<LifecycleEvent>,
|
||||
) -> anyhow::Result<()> {
|
||||
let attempt = identity.attempt;
|
||||
prepared.control.set_nonblocking(true)?;
|
||||
let control = UnixStream::from_std(prepared.control)?;
|
||||
let (mut input, mut output) = control.into_split();
|
||||
let (messages_tx, mut messages) = mpsc::channel(8);
|
||||
let reader = tokio::spawn(async move {
|
||||
loop {
|
||||
let message = receive(&mut input).await;
|
||||
let failed = message.is_err();
|
||||
if messages_tx.send(message).await.is_err() || failed {
|
||||
break;
|
||||
}
|
||||
}
|
||||
});
|
||||
let mut network = None;
|
||||
let mut session = None;
|
||||
let mut worker = WorkerState::Preparing;
|
||||
let mut online = false;
|
||||
let mut was_connected = false;
|
||||
let mut deadline: Option<Instant> = None;
|
||||
let result = async {
|
||||
loop {
|
||||
tokio::select! {
|
||||
biased;
|
||||
_ = cancellation.cancelled() => break,
|
||||
_ = async { if let Some(at) = deadline { tokio::time::sleep_until(at).await } else { std::future::pending().await } } => bail!("Script-tun worker activation timed out"),
|
||||
message = messages.recv() => match message.context("Script-tun control reader stopped")?? {
|
||||
Message::Ready if worker == WorkerState::Preparing && network.is_some() => {
|
||||
worker = WorkerState::Ready;
|
||||
}
|
||||
Message::Activated if worker == WorkerState::Activating => {
|
||||
ensure!(online, "Script-tun activation completed while VPN was offline");
|
||||
ensure!(!cancellation.is_cancelled(), "Script-tun startup cancelled");
|
||||
events.send(LifecycleEvent::Established { attempt, session: session.clone().context("Native session is missing")? }).await?;
|
||||
worker = WorkerState::Active; was_connected = true; deadline = None;
|
||||
}
|
||||
Message::Suspended if worker == WorkerState::Suspending => { worker = WorkerState::Ready; deadline = None; }
|
||||
Message::Error { message } => bail!("Script-tun worker: {message}"),
|
||||
_ => bail!("Unexpected script-tun consumer message"),
|
||||
},
|
||||
event = native.recv() => match event.context("Native event stream ended")? {
|
||||
Native::Established(value) => { session = Some(value); online = true; deadline.get_or_insert(Instant::now() + Duration::from_secs(10)); }
|
||||
Native::Event(Event::Configuration(config)) => {
|
||||
let observed = config.context("VPN configuration is absent").and_then(observed_network);
|
||||
if was_connected && (observed.is_err() || network.as_ref().is_some_and(|old| observed.as_ref().is_ok_and(|new| old != new))) { return Err(NetworkChanged.into()); }
|
||||
let observed = observed?;
|
||||
if let Some(old) = &network { ensure!(old == &observed, "VPN configuration changed during startup"); }
|
||||
else {
|
||||
send(&mut output, &Message::Configure { identity, bootstrap: std::mem::take(&mut prepared.bootstrap), network: observed.clone() }).await?;
|
||||
network = Some(observed);
|
||||
deadline = Some(Instant::now() + Duration::from_secs(10));
|
||||
}
|
||||
}
|
||||
Native::Event(Event::Reconnecting) => {
|
||||
ensure!(worker != WorkerState::Activating, "VPN connection interrupted during script-tun activation; reconnect the VPN");
|
||||
online = false;
|
||||
events.send(LifecycleEvent::ScriptTunSuspended { attempt }).await?;
|
||||
if matches!(worker, WorkerState::Ready | WorkerState::Active) {
|
||||
send(&mut output, &Message::Suspend).await?; worker = WorkerState::Suspending;
|
||||
deadline = Some(Instant::now() + Duration::from_secs(10));
|
||||
}
|
||||
}
|
||||
Native::Event(Event::Reconnected) => online = true,
|
||||
Native::Event(_) => {},
|
||||
}
|
||||
}
|
||||
if online && session.is_some() && worker == WorkerState::Ready && !cancellation.is_cancelled() {
|
||||
send(&mut output, &Message::Activate).await?; worker = WorkerState::Activating;
|
||||
deadline = Some(Instant::now() + Duration::from_secs(10));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}.await;
|
||||
let _ = tokio::time::timeout(Duration::from_millis(250), send(&mut output, &Message::Stop)).await;
|
||||
drop(output);
|
||||
reader.abort();
|
||||
let _ = reader.await;
|
||||
result
|
||||
}
|
||||
|
||||
fn observed_network(
|
||||
config: openconnect::tunnel::Configuration,
|
||||
) -> anyhow::Result<gpapi::session::tunnel::NegotiatedNetwork> {
|
||||
ensure!(
|
||||
!config.truncated && !config.dns.truncated && !config.search_domains.truncated,
|
||||
"VPN configuration is truncated"
|
||||
);
|
||||
Ok(gpapi::session::tunnel::NegotiatedNetwork {
|
||||
addresses: [config.ipv4, config.ipv6.or(config.netmask6)]
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.map(|a| a.split('/').next().unwrap().parse())
|
||||
.collect::<Result<_, _>>()?,
|
||||
dns: config.dns.items.iter().map(|a| a.parse()).collect::<Result<_, _>>()?,
|
||||
search: config.search_domains.items,
|
||||
mtu: config.mtu.context("VPN MTU is absent")? as usize,
|
||||
})
|
||||
}
|
||||
|
||||
async fn send(writer: &mut (impl tokio::io::AsyncWrite + Unpin), message: &Message) -> anyhow::Result<()> {
|
||||
tokio::time::timeout(Duration::from_secs(10), send_message(writer, message))
|
||||
.await
|
||||
.context("Script-tun control write timed out")??;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
@@ -0,0 +1,293 @@
|
||||
use super::*;
|
||||
use openconnect::{VpnSessionInfo, tunnel::Configuration};
|
||||
use tokio::io::AsyncWriteExt;
|
||||
|
||||
// A generic consumer, with no proxy settings or private worker protocol.
|
||||
struct Consumer {
|
||||
control: UnixStream,
|
||||
native: mpsc::Sender<Native>,
|
||||
events: mpsc::Receiver<LifecycleEvent>,
|
||||
cancel: CancellationToken,
|
||||
task: tokio::task::JoinHandle<anyhow::Result<()>>,
|
||||
identity: Identity,
|
||||
}
|
||||
impl Consumer {
|
||||
fn new() -> Self {
|
||||
let (control, child) = std::os::unix::net::UnixStream::pair().unwrap();
|
||||
child.set_nonblocking(true).unwrap();
|
||||
let (native, observations) = mpsc::channel(64);
|
||||
let (events, notifications) = mpsc::channel(8);
|
||||
let identity = Identity {
|
||||
service_instance: uuid::Uuid::new_v4(),
|
||||
attempt: 7,
|
||||
launch_id: uuid::Uuid::new_v4(),
|
||||
};
|
||||
let cancel = CancellationToken::new();
|
||||
let task = tokio::spawn(supervise(
|
||||
identity,
|
||||
PreparedScriptTun {
|
||||
control,
|
||||
bootstrap: Bootstrap::new(b"consumer bootstrap").unwrap(),
|
||||
},
|
||||
observations,
|
||||
cancel.clone(),
|
||||
events,
|
||||
));
|
||||
Self {
|
||||
control: UnixStream::from_std(child).unwrap(),
|
||||
native,
|
||||
events: notifications,
|
||||
cancel,
|
||||
task,
|
||||
identity,
|
||||
}
|
||||
}
|
||||
async fn message(&mut self) -> Message {
|
||||
tokio::time::timeout(Duration::from_secs(2), receive(&mut self.control))
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap()
|
||||
}
|
||||
async fn event(&mut self) -> LifecycleEvent {
|
||||
tokio::time::timeout(Duration::from_secs(2), self.events.recv())
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap()
|
||||
}
|
||||
async fn configure(&mut self) {
|
||||
self
|
||||
.native
|
||||
.send(Native::Event(Event::Configuration(Some(configuration()))))
|
||||
.await
|
||||
.unwrap();
|
||||
let Message::Configure {
|
||||
identity,
|
||||
network,
|
||||
bootstrap,
|
||||
} = self.message().await
|
||||
else {
|
||||
panic!("expected Configure")
|
||||
};
|
||||
assert_eq!(identity, self.identity);
|
||||
assert_eq!(network.addresses, vec!["10.0.0.2".parse::<std::net::IpAddr>().unwrap()]);
|
||||
assert_eq!(network.mtu, 1400);
|
||||
assert_eq!(bootstrap.decode().unwrap(), b"consumer bootstrap");
|
||||
}
|
||||
async fn activate(&mut self) {
|
||||
self.configure().await;
|
||||
self
|
||||
.native
|
||||
.send(Native::Established(VpnSessionInfo::default()))
|
||||
.await
|
||||
.unwrap();
|
||||
send_message(&mut self.control, &Message::Ready).await.unwrap();
|
||||
assert!(matches!(self.message().await, Message::Activate));
|
||||
send_message(&mut self.control, &Message::Activated).await.unwrap();
|
||||
assert!(matches!(
|
||||
self.event().await,
|
||||
LifecycleEvent::Established { attempt: 7, .. }
|
||||
));
|
||||
}
|
||||
async fn finish(&mut self) -> anyhow::Result<()> {
|
||||
tokio::time::timeout(Duration::from_secs(2), &mut self.task)
|
||||
.await
|
||||
.unwrap()
|
||||
.unwrap()
|
||||
}
|
||||
}
|
||||
impl Drop for Consumer {
|
||||
fn drop(&mut self) {
|
||||
self.cancel.cancel();
|
||||
self.task.abort();
|
||||
}
|
||||
}
|
||||
fn configuration() -> Configuration {
|
||||
Configuration {
|
||||
ipv4: Some("10.0.0.2".into()),
|
||||
mtu: Some(1400),
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn connected_requires_native_establishment_and_consumer_acknowledgment() {
|
||||
let mut consumer = Consumer::new();
|
||||
consumer.configure().await;
|
||||
send_message(&mut consumer.control, &Message::Ready).await.unwrap();
|
||||
assert!(
|
||||
tokio::time::timeout(Duration::from_millis(30), receive(&mut consumer.control))
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
assert!(consumer.events.try_recv().is_err());
|
||||
let session = VpnSessionInfo {
|
||||
lifetime_secs: Some(3600),
|
||||
..Default::default()
|
||||
};
|
||||
consumer
|
||||
.native
|
||||
.send(Native::Established(session.clone()))
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(matches!(consumer.message().await, Message::Activate));
|
||||
assert!(consumer.events.try_recv().is_err());
|
||||
send_message(&mut consumer.control, &Message::Activated).await.unwrap();
|
||||
let LifecycleEvent::Established {
|
||||
attempt,
|
||||
session: reported,
|
||||
} = consumer.event().await
|
||||
else {
|
||||
panic!("expected Established")
|
||||
};
|
||||
assert_eq!(attempt, consumer.identity.attempt);
|
||||
assert_eq!(reported, session);
|
||||
consumer.cancel.cancel();
|
||||
assert!(matches!(consumer.message().await, Message::Stop));
|
||||
consumer.finish().await.unwrap();
|
||||
assert!(receive(&mut consumer.control).await.is_err());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn unchanged_reconnect_waits_for_suspension_before_reactivation() {
|
||||
let mut consumer = Consumer::new();
|
||||
consumer.activate().await;
|
||||
consumer.native.send(Native::Event(Event::Reconnecting)).await.unwrap();
|
||||
assert!(matches!(
|
||||
consumer.event().await,
|
||||
LifecycleEvent::ScriptTunSuspended { attempt: 7 }
|
||||
));
|
||||
assert!(matches!(consumer.message().await, Message::Suspend));
|
||||
consumer
|
||||
.native
|
||||
.send(Native::Event(Event::Configuration(Some(configuration()))))
|
||||
.await
|
||||
.unwrap();
|
||||
consumer.native.send(Native::Event(Event::Reconnected)).await.unwrap();
|
||||
assert!(
|
||||
tokio::time::timeout(Duration::from_millis(30), receive(&mut consumer.control))
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
send_message(&mut consumer.control, &Message::Suspended).await.unwrap();
|
||||
assert!(matches!(consumer.message().await, Message::Activate));
|
||||
assert!(consumer.events.try_recv().is_err());
|
||||
send_message(&mut consumer.control, &Message::Activated).await.unwrap();
|
||||
assert!(matches!(
|
||||
consumer.event().await,
|
||||
LifecycleEvent::Established { attempt: 7, .. }
|
||||
));
|
||||
consumer.cancel.cancel();
|
||||
assert!(matches!(consumer.message().await, Message::Stop));
|
||||
consumer.finish().await.unwrap();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn changed_reconnect_stops_consumer_and_returns_network_changed() {
|
||||
let mut consumer = Consumer::new();
|
||||
consumer.activate().await;
|
||||
consumer.native.send(Native::Event(Event::Reconnecting)).await.unwrap();
|
||||
assert!(matches!(
|
||||
consumer.event().await,
|
||||
LifecycleEvent::ScriptTunSuspended { .. }
|
||||
));
|
||||
assert!(matches!(consumer.message().await, Message::Suspend));
|
||||
send_message(&mut consumer.control, &Message::Suspended).await.unwrap();
|
||||
let mut changed = configuration();
|
||||
changed.ipv4 = Some("10.0.0.3".into());
|
||||
consumer
|
||||
.native
|
||||
.send(Native::Event(Event::Configuration(Some(changed))))
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(matches!(consumer.message().await, Message::Stop));
|
||||
assert!(consumer.finish().await.unwrap_err().is::<NetworkChanged>());
|
||||
assert!(
|
||||
!consumer.cancel.is_cancelled(),
|
||||
"restart must not look like explicit cancellation"
|
||||
);
|
||||
assert!(consumer.events.try_recv().is_err());
|
||||
assert!(receive(&mut consumer.control).await.is_err());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn cancellation_during_activation_prevents_connected() {
|
||||
let mut consumer = Consumer::new();
|
||||
consumer.configure().await;
|
||||
consumer
|
||||
.native
|
||||
.send(Native::Established(VpnSessionInfo::default()))
|
||||
.await
|
||||
.unwrap();
|
||||
send_message(&mut consumer.control, &Message::Ready).await.unwrap();
|
||||
assert!(matches!(consumer.message().await, Message::Activate));
|
||||
consumer.cancel.cancel();
|
||||
// A late acknowledgment must not publish Connected after cancellation.
|
||||
let _ = send_message(&mut consumer.control, &Message::Activated).await;
|
||||
assert!(matches!(consumer.message().await, Message::Stop));
|
||||
consumer.finish().await.unwrap();
|
||||
assert!(consumer.events.try_recv().is_err());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn consumer_eof_ends_startup_and_active_sessions() {
|
||||
for active in [false, true] {
|
||||
let mut consumer = Consumer::new();
|
||||
if active {
|
||||
consumer.activate().await;
|
||||
} else {
|
||||
consumer.configure().await;
|
||||
}
|
||||
consumer.control.shutdown().await.unwrap();
|
||||
assert!(consumer.finish().await.is_err());
|
||||
assert!(consumer.events.try_recv().is_err());
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn unexpected_acknowledgment_fails_before_connected() {
|
||||
let mut consumer = Consumer::new();
|
||||
consumer.configure().await;
|
||||
send_message(&mut consumer.control, &Message::Activated).await.unwrap();
|
||||
assert!(matches!(consumer.message().await, Message::Stop));
|
||||
assert!(consumer.finish().await.unwrap_err().to_string().contains("Unexpected"));
|
||||
assert!(consumer.events.try_recv().is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn prepares_worker_for_current_desktop_user_without_enumerating_groups() {
|
||||
let uid = unsafe { nix::libc::getuid() };
|
||||
if uid == 0 {
|
||||
return;
|
||||
}
|
||||
let request = ScriptTunRequest {
|
||||
launch_id: uuid::Uuid::new_v4(),
|
||||
program: "/usr/bin/true".into(),
|
||||
args: vec![],
|
||||
bootstrap: Bootstrap::default(),
|
||||
};
|
||||
builder("https://vpn.example", "test", &request, uid).unwrap();
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn reconnect_during_activation_returns_clear_error_without_connected() {
|
||||
let mut consumer = Consumer::new();
|
||||
consumer.configure().await;
|
||||
consumer
|
||||
.native
|
||||
.send(Native::Established(VpnSessionInfo::default()))
|
||||
.await
|
||||
.unwrap();
|
||||
send_message(&mut consumer.control, &Message::Ready).await.unwrap();
|
||||
assert!(matches!(consumer.message().await, Message::Activate));
|
||||
consumer.native.send(Native::Event(Event::Reconnecting)).await.unwrap();
|
||||
assert!(matches!(consumer.message().await, Message::Stop));
|
||||
assert!(
|
||||
consumer
|
||||
.finish()
|
||||
.await
|
||||
.unwrap_err()
|
||||
.to_string()
|
||||
.contains("during script-tun activation")
|
||||
);
|
||||
assert!(consumer.events.try_recv().is_err());
|
||||
}
|
||||
Reference in new issue
Block a user