feat: prepare 3.0.0 release

This commit is contained in:
Kevin Yue committed 2026-10-09 18:21:44 +08:00
1 parent e98fd7894a
commit b7b708e9cd
252 files changed
+26210 -7457

No files matched your search

+192
View File
@@ -0,0 +1,192 @@
use std::{sync::Arc, time::Duration};
use anyhow::Context;
use gpapi::process::collection::CollectionControl;
use gpapi::session::{
GatewaySessionSummary, MaintenanceState, SessionEndReason,
non_tunnel::{SessionCallbacks, SessionExit, maintain_non_tunnel_sessions},
};
use log::warn;
use tokio::sync::{mpsc, watch};
use tokio_util::sync::CancellationToken;
use super::{
LifecycleEvent,
runtime::{AttemptInput, stop_for_revoked_approval},
};
/// Borrow the accepted ledger. The outer attempt owner retains identity/source
/// resources and joins this runtime before draining the remaining members.
pub(super) async fn run(
input: &mut AttemptInput,
source: Arc<openconnect::HipSource>,
approval: &crate::hip_source::HipApproval,
cancellation: CancellationToken,
events: mpsc::Sender<LifecycleEvent>,
) -> anyhow::Result<SessionExit> {
let request = &input.connection.request;
let args = request.args();
let resources = &input.connection.resources;
let sessions = &mut input.connection.sessions;
let network = resources
.network
.as_ref()
.context("Physical network context is missing")?;
let posture_enabled =
request.plan().policy().collect_hip_data() && !matches!(args.hip_source(), gpapi::hip::HipSource::Disabled);
let profile = resources.profile.clone();
let initial = sessions
.members()
.iter()
.map(|session| GatewaySessionSummary {
gateway: session.gateway.clone(),
mode: gpapi::session::SessionMode::NonTunnel,
client_ip: session.addresses.ipv4.map(|ip| ip.to_string()),
client_ipv6: session.addresses.ipv6.map(|ip| ip.to_string()),
maintenance: MaintenanceState::Authenticated,
})
.collect::<Vec<_>>();
let (status, mut changed) = watch::channel(initial);
let registry = input.registry.clone();
let session_id = input.session_id;
let validation_network = network.clone();
let validation_detection = request.plan().internal_detection().cloned();
let callbacks = SessionCallbacks {
validate_network: Arc::new(move |cancel| {
let network = validation_network.clone();
let detection = validation_detection.clone();
Box::pin(async move { network.validate_internal(detection.as_ref(), &cancel).await })
}),
produce_report: Arc::new(move |request, control| {
control.check()?;
let context = gphip::ReportContext::Connected {
cookie: request.cookie.clone(),
client_ip: request.client_ip.clone(),
client_ipv6: request.client_ipv6.clone(),
md5: request.md5.clone(),
};
if !posture_enabled {
return gphip::generate_identity_report(&gphip::ReportInput {
profile: profile.clone(),
context,
})
.map_err(std::io::Error::other);
}
source.collect(
&openconnect::HipRequest {
cookie: request.cookie.clone(),
client_ip: request.client_ip.clone(),
client_ipv6: request.client_ipv6.clone(),
md5: request.md5.clone(),
client_version: profile.client_version().into(),
client_os: profile.client_os().as_str().into(),
os_version: profile.os_version().into(),
host_id: Some(profile.host_id().into()),
local_hostname: Some(profile.computer().into()),
},
&|| control.check(),
)
}),
report_submitted: Arc::new(move |_, xml| {
if let Some(session_id) = session_id {
if let Err(error) = registry.store_successful_hip_report(session_id, xml) {
warn!("Could not retain submitted HIP report: {error}");
}
}
}),
status_changed: Arc::new(move |summary| {
status.send_modify(|members| {
if let Some(member) = members
.iter_mut()
.find(|member| member.gateway.server() == summary.gateway.server())
{
*member = summary;
}
});
}),
};
let monitor_cancel = cancellation.child_token();
let monitor_token = monitor_cancel.clone();
let network = network.clone();
let detection = request.plan().internal_detection().cloned();
let (network_changed, network_signal) = tokio::sync::oneshot::channel();
let monitor = tokio::spawn(async move {
match network.wait_for_change(detection, monitor_token).await {
Ok(false) => {}
Ok(true) => {
let _ = network_changed.send(SessionEndReason::NetworkChanged);
}
Err(error) => {
warn!("Physical network inspection failed: {error}");
let _ = network_changed.send(SessionEndReason::NetworkChanged);
}
}
});
let mut approval_revoked = false;
let result = {
let lifecycle_cancel = cancellation.clone();
let maintenance = maintain_non_tunnel_sessions(
sessions,
request.plan().policy(),
callbacks,
lifecycle_cancel,
async move { network_signal.await.unwrap_or(SessionEndReason::NetworkChanged) },
);
tokio::pin!(maintenance);
let mut approval_poll = tokio::time::interval(Duration::from_secs(1));
let mut publish = true;
let result = loop {
if publish && !cancellation.is_cancelled() {
let members = changed.borrow_and_update().clone();
let _ = events
.send(LifecycleEvent::MembersChanged {
attempt: input.attempt,
members,
failures: request.plan().failures().to_vec(),
})
.await;
publish = false;
}
tokio::select! {
biased;
result = &mut maintenance => break result,
_ = approval_poll.tick() => if !approval.approval_is_valid() {
approval_revoked = true;
stop_for_revoked_approval(&input.lifecycle, &cancellation);
},
result = changed.changed() => { if result.is_ok() { publish = true; } },
}
};
// Maintenance can invalidate every member and finish in the same poll.
// Forward that last snapshot before monitor/remote cleanup, even when the
// completed maintenance branch won over the watch notification.
if !cancellation.is_cancelled() {
let members = changed.borrow_and_update().clone();
let _ = events
.send(LifecycleEvent::MembersChanged {
attempt: input.attempt,
members,
failures: request.plan().failures().to_vec(),
})
.await;
}
result
};
monitor_cancel.cancel();
monitor.await.context("Network monitor worker failed")?;
if approval_revoked {
let _ = events
.send(LifecycleEvent::Failed {
attempt: input.attempt,
reason: "HIP script approval was revoked".into(),
})
.await;
}
// resources and approval remain owned until maintenance/logout and monitor
// inspection are drained. Deliberate disconnect wins throughout cleanup.
if cancellation.is_cancelled() {
Ok(SessionExit::Disconnected)
} else {
result
}
}
@@ -0,0 +1,213 @@
use std::{
io::{Read, Write},
sync::Arc,
time::Duration,
};
use gpapi::{
gateway::Gateway,
gp_params::GpParams,
service::{
transport::ServiceResult,
vpn_state::{ConnectInfo, VpnState},
},
session::{ClientAddresses, GatewayAuthentication, GatewaySession, GatewaySessions, transport::GatewayTransport},
};
use openssl::{
asn1::Asn1Time,
hash::MessageDigest,
pkey::PKey,
rsa::Rsa,
ssl::{SslAcceptor, SslMethod},
x509::{X509, X509NameBuilder},
};
use tokio::sync::{oneshot, watch};
use super::{LifecycleEvent, PreparedConnection, VpnTask, test_connect_request};
fn tls_acceptor() -> SslAcceptor {
let key = PKey::from_rsa(Rsa::generate(2048).unwrap()).unwrap();
let mut name = X509NameBuilder::new().unwrap();
name.append_entry_by_text("CN", "localhost").unwrap();
let name = name.build();
let mut cert = X509::builder().unwrap();
cert.set_version(2).unwrap();
cert.set_subject_name(&name).unwrap();
cert.set_issuer_name(&name).unwrap();
cert.set_pubkey(&key).unwrap();
cert.set_not_before(&Asn1Time::days_from_now(0).unwrap()).unwrap();
cert.set_not_after(&Asn1Time::days_from_now(1).unwrap()).unwrap();
cert.sign(&key, MessageDigest::sha256()).unwrap();
let mut acceptor = SslAcceptor::mozilla_intermediate(SslMethod::tls()).unwrap();
acceptor.set_private_key(&key).unwrap();
acceptor.set_certificate(&cert.build()).unwrap();
acceptor.check_private_key().unwrap();
acceptor.build()
}
/// Exercise the real HTTPS logout transport without any production network,
/// host collectors, or user identity files. The response gate proves admission
/// stays owned until the server request finishes.
#[tokio::test]
async fn cancelled_pending_owner_logs_out_and_releases_admission_after_response() {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let endpoint = listener.local_addr().unwrap();
let server_name = format!("https://{endpoint}");
let mut gateway = serde_json::to_value(Gateway::new("fixture".into(), server_name.clone())).unwrap();
gateway["kind"] = serde_json::json!("internal");
let gateway: Gateway = serde_json::from_value(gateway).unwrap();
let registry = Arc::new(crate::session_registry::SessionRegistry::new(uuid::Uuid::new_v4()));
let credential = registry.issue("fixture", None).unwrap();
let session_id = credential.session_id();
let permit = registry
.begin_handshake(credential.service_instance_id(), session_id, "fixture")
.unwrap();
let (tx, _rx) = tokio::sync::mpsc::channel(4);
let control = crate::ws_connection::ConnectionControl::new(uuid::Uuid::new_v4(), tx).0;
let connection_id = control.connection_id();
registry.commit_attach(&permit, control).unwrap();
let fixture = test_connect_request(ConnectInfo::new("portal.example.com".into(), gateway.clone(), vec![]));
let mut member = fixture.plan().members()[0].clone();
member.authentication =
GatewayAuthentication::new("authcookie=fixture&user=fixture".into(), "internal".into()).unwrap();
let plan = gpapi::session::ConnectionPlan::new(vec![member], vec![], fixture.plan().policy()).unwrap();
let request = gpapi::service::request::ConnectRequest::new(fixture.info().clone(), plan);
let mut prepared = PreparedConnection::lifecycle_fixture(request);
let mut params = GpParams::builder(prepared.resources.profile.clone());
params.ignore_tls_errors(true);
prepared.sessions = GatewaySessions::new(vec![GatewaySession {
gateway,
transport: GatewayTransport::new(
&server_name,
prepared.request.plan().members()[0].authentication.clone(),
&params.build(),
prepared.request.plan().members()[0].binding.as_ref(),
)
.unwrap(),
addresses: ClientAddresses::default(),
}]);
let acceptor = tls_acceptor();
let (arrived, arrival) = oneshot::channel();
let (release, response_gate) = oneshot::channel();
let server = tokio::spawn(async move {
let (socket, _) = tokio::time::timeout(Duration::from_secs(3), listener.accept())
.await
.unwrap()
.unwrap();
let socket = socket.into_std().unwrap();
socket.set_nonblocking(false).unwrap();
socket.set_read_timeout(Some(Duration::from_secs(3))).unwrap();
socket.set_write_timeout(Some(Duration::from_secs(3))).unwrap();
let request = tokio::task::spawn_blocking(move || {
let mut stream = acceptor.accept(socket).unwrap();
let mut bytes = Vec::new();
let (headers_end, body_len) = loop {
let mut chunk = [0; 1024];
let count = stream.read(&mut chunk).unwrap();
assert_ne!(count, 0);
bytes.extend_from_slice(&chunk[..count]);
if let Some(position) = bytes.windows(4).position(|part| part == b"\r\n\r\n") {
let headers = std::str::from_utf8(&bytes[..position]).unwrap();
let length = headers
.lines()
.find_map(|line| {
let (key, value) = line.split_once(':')?;
key
.eq_ignore_ascii_case("content-length")
.then(|| value.trim().parse::<usize>().unwrap())
})
.unwrap();
break (position + 4, length);
}
};
while bytes.len() < headers_end + body_len {
let mut chunk = [0; 1024];
let count = stream.read(&mut chunk).unwrap();
assert_ne!(count, 0);
bytes.extend_from_slice(&chunk[..count]);
}
arrived.send(()).unwrap();
response_gate.blocking_recv().unwrap();
let body = "<response status=\"success\"/>";
write!(
stream,
"HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
)
.unwrap();
stream.flush().unwrap();
String::from_utf8(bytes).unwrap()
})
.await
.unwrap();
// A single accepted authentication must produce a single logout.
assert!(
tokio::time::timeout(Duration::from_millis(100), listener.accept())
.await
.is_err()
);
request
});
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())
.unwrap();
assert_eq!(
registry.commit_connection(session_id, 1, true, || reservation.commit(
prepared,
None,
None,
Some(session_id)
)),
ServiceResult::Accepted
);
let drain = registry
.stop_non_tunnel_attachment(session_id, 1, connection_id)
.unwrap()
.unwrap();
let drain_waiter = tokio::spawn(async move {
drain.wait().await;
});
let start = task.events.recv().await.unwrap();
assert!(matches!(&start, LifecycleEvent::Start { .. }));
task.handle_event(start).await;
tokio::time::timeout(Duration::from_secs(3), arrival)
.await
.unwrap()
.unwrap();
assert!(lifecycle.has_attempt(0));
assert!(!drain_waiter.is_finished());
assert!(lifecycle.reserve_connect().is_err());
assert!(!task.active.as_ref().unwrap().task.is_finished());
assert!(matches!(*state_rx.borrow(), VpnState::Disconnected));
release.send(()).unwrap();
while task.active.is_some() {
let event = tokio::time::timeout(Duration::from_secs(3), task.events.recv())
.await
.unwrap()
.unwrap();
task.handle_event(event).await;
}
assert!(!lifecycle.has_attempt(0));
drain_waiter.await.unwrap();
assert!(lifecycle.reserve_connect().is_ok());
assert!(matches!(*state_rx.borrow(), VpnState::Disconnected));
let request = server.await.unwrap();
assert!(request.starts_with("POST /ssl-vpn/logout.esp "));
let form = request.split_once("\r\n\r\n").unwrap().1;
let fields = url_form(form);
assert_eq!(fields.get("user").map(String::as_str), Some("fixture"));
assert_eq!(fields.get("computer").map(String::as_str), Some("fixture"));
assert_eq!(fields.get("clientos").map(String::as_str), Some("Linux"));
}
fn url_form(form: &str) -> std::collections::HashMap<String, String> {
form
.split('&')
.map(|field| {
let (key, value) = field.split_once('=').unwrap();
(key.to_owned(), value.to_owned())
})
.collect()
}
+232
View File
@@ -0,0 +1,232 @@
use std::{sync::Arc, time::Duration};
use anyhow::Context;
use gpapi::{
gp_params::GpParams,
os_profile::OsProfile,
process::collection::{CollectionBudget, CollectionControl},
service::request::ConnectRequest,
session::{GatewaySession, GatewaySessions, network::PhysicalNetwork, transport::GatewayTransport},
};
use tokio_util::sync::CancellationToken;
pub(crate) struct PreparedConnection {
pub(super) request: ConnectRequest,
pub(super) resources: Arc<ConnectionResources>,
pub(super) sessions: GatewaySessions,
}
pub(super) struct ConnectionResources {
pub profile: OsProfile,
pub identity: Option<gpapi::utils::request::ClientIdentity>,
pub identity_files: Option<gpapi::utils::request::ClientIdentityFiles>,
pub network: Option<PhysicalNetwork>,
}
/// Preparation sends no authenticated gateway requests. Rejection leaves the
/// authentication owner responsible for logout; only queued admission transfers
/// the complete ledger and its retained identity resources to the service.
pub(crate) async fn prepare_connection(
request: ConnectRequest,
brokered_macos: bool,
cancellation: CancellationToken,
) -> anyhow::Result<PreparedConnection> {
let args = request.args();
let non_tunnel = request
.plan()
.members()
.iter()
.all(|member| member.authentication.mode() == gpapi::session::SessionMode::NonTunnel);
anyhow::ensure!(
non_tunnel || request.plan().members().len() == 1,
"Only one selected tunnel gateway can execute"
);
for member in request.plan().members() {
if non_tunnel {
let binding = member.binding.as_ref().context("Internal gateway binding is missing")?;
anyhow::ensure!(
!args.disable_ipv6() || (binding.endpoint().is_ipv4() && binding.addresses().ipv6.is_none()),
"IPv6 gateway transport or identity is disabled"
);
}
}
let setup_request = request.clone();
let setup_cancel = cancellation.clone();
let resources = tokio::task::spawn_blocking(move || {
let budget = CollectionBudget::new(Duration::from_secs(60));
let check = || {
if setup_cancel.is_cancelled() {
return Err(std::io::Error::new(
std::io::ErrorKind::Interrupted,
"Connection preparation cancelled",
));
}
budget.check()
};
check()?;
let args = setup_request.args();
let identity = super::prepare_identity(args, brokered_macos || non_tunnel)?;
let directory = brokered_macos.then(|| std::path::Path::new("/var/run/com.yuezk.gpgui"));
let identity_files = identity
.as_ref()
.map(|identity| identity.write_files(directory))
.transpose()?;
let host = args.host_identity().context("Authenticated host identity is missing")?;
let profile = crate::hip_source::profile(
host,
args.os().context("Authenticated client OS is missing")?,
args.client_version(),
args.os_version(),
args.host_id(),
args.local_hostname(),
&check,
)?;
let network = if non_tunnel {
Some(PhysicalNetwork::capture(&check)?)
} else {
None
};
check()?;
Ok::<_, anyhow::Error>(Arc::new(ConnectionResources {
profile,
identity,
identity_files,
network,
}))
})
.await??;
let args = request.args();
let mut builder = GpParams::builder(resources.profile.clone());
builder
.ignore_tls_errors(args.ignore_tls_errors())
.client_identity(resources.identity.clone());
let params = builder.build();
let mut sessions = Vec::new();
for member in request.plan().members() {
let binding = if non_tunnel {
Some(member.binding.as_ref().context("Internal gateway binding is missing")?)
} else {
None
};
if let Some(network) = &resources.network {
network
.validate_internal_binding(
binding.context("Internal gateway binding is missing")?,
request.plan().internal_detection(),
&cancellation,
)
.await?;
}
let transport = GatewayTransport::new(member.gateway.server(), member.authentication.clone(), &params, binding)?;
sessions.push(GatewaySession {
gateway: member.gateway.clone(),
transport,
addresses: binding.map(|binding| binding.addresses()).unwrap_or_default(),
});
}
if let Some(network) = &resources.network {
network.ensure_current(&cancellation).await?;
}
Ok(PreparedConnection {
request,
resources,
sessions: GatewaySessions::new(sessions),
})
}
#[cfg(test)]
impl PreparedConnection {
/// Lifecycle-only fixtures own no issued server sessions. Protocol ownership
/// checks use actual gateway transports rather than this actor-state fixture.
pub(crate) fn lifecycle_fixture(request: ConnectRequest) -> Self {
let profile = OsProfile::builder(gpapi::os_profile::ClientOs::Linux)
.host_identity(gpapi::os_profile::HostIdentity::from_parts(
"fixture".into(),
"fixture-host".into(),
"fixture-serial".into(),
"02:00:00:00:00:01".into(),
))
.build();
Self {
request,
resources: Arc::new(ConnectionResources {
profile,
identity: None,
identity_files: None,
network: None,
}),
sessions: GatewaySessions::new(vec![]),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use gpapi::{gateway::Gateway, service::vpn_state::ConnectInfo};
#[tokio::test]
async fn brokered_macos_and_non_tunnel_identity_reject_path_handoff() {
for (brokered_macos, non_tunnel) in [(true, false), (false, true), (true, true)] {
let gateway = Gateway::new("fixture".into(), "gateway.example.com".into());
let request = super::super::test_connect_request(ConnectInfo::new("portal.example.com".into(), gateway, vec![]))
.with_certificate(Some("/identity.pem".into()));
let mut wire = serde_json::to_value(request).unwrap();
if non_tunnel {
wire["plan"]["members"][0]["gateway"]["kind"] = serde_json::json!("internal");
wire["plan"]["members"][0]["authentication"]["connection_type"] = serde_json::json!("internal");
}
let request = serde_json::from_value(wire).unwrap();
let error = prepare_connection(request, brokered_macos, CancellationToken::new())
.await
.err()
.unwrap();
assert_eq!(error.to_string(), "Client identity must be a protected snapshot");
}
}
#[tokio::test]
async fn disabled_ipv6_rejects_ipv6_report_identity_before_setup() {
let gateway = Gateway::new("fixture".into(), "gateway.example.com".into());
let request = super::super::test_connect_request(ConnectInfo::new("portal.example.com".into(), gateway, vec![]))
.with_disable_ipv6(true);
let mut wire = serde_json::to_value(request).unwrap();
wire["plan"]["members"][0]["gateway"]["kind"] = serde_json::json!("internal");
wire["plan"]["members"][0]["authentication"]["connection_type"] = serde_json::json!("internal");
wire["plan"]["members"][0]["binding"]["addresses"]["ipv6"] = serde_json::json!("2001:db8::5");
let request: ConnectRequest = serde_json::from_value(wire).unwrap();
// The fixture has no host identity or usable physical interface. Policy
// rejection must happen before those collectors or transport setup run.
let error = prepare_connection(request, false, CancellationToken::new())
.await
.err()
.unwrap();
assert_eq!(error.to_string(), "IPv6 gateway transport or identity is disabled");
}
#[tokio::test]
async fn ordinary_tunnel_preparation_needs_no_physical_binding_or_resolver() {
let gateway = Gateway::new("fixture".into(), "does-not-resolve.invalid".into());
let profile = OsProfile::builder(gpapi::os_profile::ClientOs::Linux)
.host_identity(gpapi::os_profile::HostIdentity::from_parts(
"fixture".into(),
"fixture-host".into(),
"fixture-serial".into(),
"02:00:00:00:00:01".into(),
))
.build();
let request = super::super::test_connect_request(ConnectInfo::new("portal.example.com".into(), gateway, vec![]))
.with_os_profile(&profile)
.with_disable_ipv6(true);
let mut wire = serde_json::to_value(request).unwrap();
wire["plan"]["members"][0]["binding"] = serde_json::Value::Null;
let request: ConnectRequest = serde_json::from_value(wire).unwrap();
let prepared = prepare_connection(request, false, CancellationToken::new())
.await
.unwrap();
assert!(prepared.resources.network.is_none());
assert_eq!(prepared.sessions.members().len(), 1);
assert!(prepared.sessions.members()[0].addresses.ipv4.is_none());
assert!(prepared.sessions.members()[0].addresses.ipv6.is_none());
}
}
+302
View File
@@ -0,0 +1,302 @@
use std::{sync::Arc, time::Duration};
use anyhow::{Context, ensure};
use gpapi::{
process::collection::{CollectionBudget, CollectionControl},
service::request::ConnectRequest,
session::SessionMode,
};
use log::warn;
use openconnect::Vpn;
use tokio::{sync::mpsc, task::JoinHandle};
use tokio_util::sync::CancellationToken;
use uuid::Uuid;
use super::{LifecycleEvent, LifecycleHandle, PreparedConnection, preparation::ConnectionResources};
pub(super) struct AttemptInput {
pub attempt: u64,
pub connection: PreparedConnection,
pub desktop_uid: Option<u32>,
pub edited_report: Option<Arc<str>>,
pub session_id: Option<Uuid>,
pub brokered_macos: bool,
pub registry: Arc<crate::session_registry::SessionRegistry>,
pub lifecycle: LifecycleHandle,
}
struct TunnelInput {
request: ConnectRequest,
resources: Arc<ConnectionResources>,
source: Arc<openconnect::HipSource>,
session_id: Option<Uuid>,
registry: Arc<crate::session_registry::SessionRegistry>,
}
struct PreparedTunnel {
vpn: Arc<Vpn>,
}
/// The accepted attempt owns cleanup through fallible setup. Non-tunnel workers
/// borrow that ledger; a native tunnel takes its cleanup ownership when started.
/// Cancellation joins execution before draining any remaining issued sessions.
pub(super) fn spawn(
mut input: AttemptInput,
cancellation: CancellationToken,
events: mpsc::Sender<LifecycleEvent>,
) -> 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() {
let request = input.connection.request.clone();
let resources = input.connection.resources.clone();
let desktop_uid = input.desktop_uid;
let brokered = input.brokered_macos;
let edited = input.edited_report.clone();
let setup_cancel = cancellation.clone();
let execution = tokio::task::spawn_blocking(move || {
prepare_execution(request, resources, desktop_uid, brokered, edited, &setup_cancel)
})
.await;
match execution {
Ok(Ok(execution)) => {
let (source, guard) = execution.into_parts();
approval = Some(guard);
let source = Arc::new(source);
let guard = approval.as_ref().expect("execution approval is retained");
if input
.connection
.request
.plan()
.members()
.iter()
.all(|member| member.authentication.mode() == SessionMode::NonTunnel)
{
match super::non_tunnel::run(&mut input, source, guard, cancellation.clone(), events.clone()).await {
Ok(gpapi::session::non_tunnel::SessionExit::Disconnected) => {}
Ok(gpapi::session::non_tunnel::SessionExit::Failed(reason)) => {
let message = match reason {
gpapi::session::SessionEndReason::InvalidCookie => {
"Internal gateway authentication expired; connect again"
}
gpapi::session::SessionEndReason::NetworkChanged => {
"Physical network changed or could not be verified; connect again"
}
gpapi::session::SessionEndReason::AllMembersFailed => {
"All internal gateway sessions failed; connect again"
}
gpapi::session::SessionEndReason::AuthorizationRevoked => "HIP execution authorization was revoked",
};
failure = Some(message.into());
}
Err(error) => {
warn!("Non-tunnel maintenance failed: {error:#}");
failure = Some("Internal session maintenance failed".into());
}
}
} else {
let tunnel_input = TunnelInput {
request: input.connection.request.clone(),
resources: input.connection.resources.clone(),
source,
session_id: input.session_id,
registry: input.registry.clone(),
};
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(Err(error)) => warn!("Failed to prepare tunnel: {error:#}"),
Err(error) => warn!("Tunnel setup worker failed: {error}"),
}
}
}
Ok(Err(error)) => {
warn!("Failed to prepare HIP execution: {error:#}");
failure = Some("HIP execution could not be prepared".into());
}
Err(error) => {
warn!("HIP setup worker failed: {error}");
failure = Some("HIP setup worker failed".into());
}
}
}
input.connection.sessions.logout().await;
// 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 let Some(reason) = failure {
let _ = events.send(LifecycleEvent::Failed { attempt, reason }).await;
}
}
let _ = events.send(LifecycleEvent::Ended { attempt }).await;
})
}
fn prepare_execution(
request: ConnectRequest,
resources: Arc<ConnectionResources>,
desktop_uid: Option<u32>,
brokered: bool,
edited: Option<Arc<str>>,
cancellation: &CancellationToken,
) -> anyhow::Result<crate::hip_source::HipExecution> {
let budget = CollectionBudget::new(Duration::from_secs(60));
let check = || {
if cancellation.is_cancelled() {
return Err(std::io::Error::new(
std::io::ErrorKind::Interrupted,
"HIP setup cancelled",
));
}
budget.check()
};
check()?;
let args = request.args();
let pure_non_tunnel = request
.plan()
.members()
.iter()
.all(|member| member.authentication.mode() == SessionMode::NonTunnel);
let disabled = pure_non_tunnel && !request.plan().policy().collect_hip_data();
let source = if disabled {
&gpapi::hip::HipSource::Disabled
} else {
args.hip_source()
};
let execution = crate::hip_source::resolve(source, desktop_uid, brokered, edited, Some(resources.profile.clone()))?;
check()?;
Ok(execution)
}
fn prepare_tunnel(input: TunnelInput, cancellation: &CancellationToken) -> anyhow::Result<PreparedTunnel> {
let args = input.request.args();
let budget = CollectionBudget::new(Duration::from_secs(60));
let check = || {
if cancellation.is_cancelled() {
return Err(std::io::Error::new(
std::io::ErrorKind::Interrupted,
"Tunnel setup cancelled",
));
}
budget.check()
};
check()?;
ensure!(
input.request.plan().members().len() == 1
&& input.request.plan().members()[0].authentication.mode() == SessionMode::Tunnel,
"Tunnel execution requires one selected tunnel gateway"
);
let member = &input.request.plan().members()[0];
let identity_files = &input.resources.identity_files;
let vpn = Arc::new(
crate::vpn_script::builder(member.gateway.server(), member.authentication.cookie(), args)?
.user_agent(args.user_agent())
.os(args.openconnect_os())
.os_version(args.os_version())
.client_version(args.client_version())
.host_id(args.host_id())
.certificate(identity_files.as_ref().map(|files| files.certificate().to_owned()))
.sslkey(identity_files.as_ref().and_then(|files| files.key()).map(str::to_owned))
.key_password(
input
.resources
.identity
.as_ref()
.and_then(|identity| identity.key_password())
.map(str::to_owned),
)
.hip_source(input.source)
.reconnect_timeout(args.reconnect_timeout())
.mtu(args.mtu())
.disable_ipv6(args.disable_ipv6())
.no_dtls(args.no_dtls())
.local_hostname(args.local_hostname())
.dpd_interval(args.force_dpd())
.no_xmlpost(args.no_xmlpost())
.build()
.context("Failed to create tunnel worker")?,
);
check()?;
if let Some(session_id) = input.session_id {
let registry = input.registry;
vpn.set_hip_report_callback(move |xml| {
if let Err(error) = registry.store_successful_hip_report(session_id, xml) {
warn!("Could not retain submitted HIP report: {error}");
}
});
}
Ok(PreparedTunnel { vpn })
}
async fn run_tunnel(
attempt: u64,
prepared: &PreparedTunnel,
approval: &crate::hip_source::HipApproval,
lifecycle: &LifecycleHandle,
sessions: &mut gpapi::session::GatewaySessions,
cancellation: CancellationToken,
events: mpsc::Sender<LifecycleEvent>,
) {
if cancellation.is_cancelled() {
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.
// Service admission permits exactly one tunnel member.
std::mem::take(sessions).relinquish();
let worker = tokio::task::spawn_blocking(move || {
vpn.connect(move |session| {
let _ = events.blocking_send(LifecycleEvent::Established { attempt, session });
})
});
tokio::pin!(worker);
let mut approval_poll = tokio::time::interval(Duration::from_secs(1));
let result = loop {
tokio::select! {
biased;
_ = cancellation.cancelled() => { prepared.vpn.disconnect(); break (&mut worker).await; },
result = &mut worker => break result,
_ = approval_poll.tick() => if !approval.approval_is_valid() {
stop_for_revoked_approval(lifecycle, &cancellation);
prepared.vpn.disconnect();
break (&mut worker).await;
},
}
};
match result {
Ok(0 | -4) => {}
Ok(code) => warn!("Tunnel worker exited with status {code}"),
Err(error) => warn!("Tunnel worker failed: {error}"),
}
}
pub(super) fn stop_for_revoked_approval(lifecycle: &LifecycleHandle, cancellation: &CancellationToken) {
let result = lifecycle.request_disconnect();
if !matches!(result, gpapi::service::transport::ServiceResult::Accepted) {
warn!("Could not enqueue approval revocation stop: {result:?}");
}
cancellation.cancel();
}