mirror of
https://github.com/yuezk/GlobalProtect-openconnect.git
synced 2026-11-19 06:26:14 -05:00
release: prepare GP Connect 3.5.0 with Windows support
This commit is contained in:
172 files changed
+9629
-1171
No files matched your search
@@ -1,6 +1,8 @@
|
||||
use super::*;
|
||||
use gpapi::script_tun::{Bootstrap, ScriptTunRequest};
|
||||
use openconnect::{VpnSessionInfo, tunnel::Configuration};
|
||||
use tokio::io::AsyncWriteExt;
|
||||
use tokio::net::UnixStream;
|
||||
|
||||
// A generic consumer, with no proxy settings or private worker protocol.
|
||||
struct Consumer {
|
||||
@@ -23,16 +25,26 @@ impl Consumer {
|
||||
launch_id: uuid::Uuid::new_v4(),
|
||||
};
|
||||
let cancel = CancellationToken::new();
|
||||
let task = tokio::spawn(supervise(
|
||||
identity,
|
||||
PreparedScriptTun {
|
||||
control,
|
||||
let stopped = cancel.clone();
|
||||
let task = tokio::spawn(async move {
|
||||
let mut prepared = PreparedScriptTun {
|
||||
control: Some(control),
|
||||
bootstrap: Bootstrap::new(b"consumer bootstrap").unwrap(),
|
||||
},
|
||||
observations,
|
||||
cancel.clone(),
|
||||
events,
|
||||
));
|
||||
};
|
||||
let channel = prepared.connect().await?;
|
||||
let mut control = ConsumerControl::new(channel);
|
||||
let result = supervise(
|
||||
identity,
|
||||
&mut control,
|
||||
prepared.bootstrap,
|
||||
observations,
|
||||
stopped,
|
||||
events,
|
||||
)
|
||||
.await;
|
||||
control.stop().await;
|
||||
result
|
||||
});
|
||||
Self {
|
||||
control: UnixStream::from_std(child).unwrap(),
|
||||
native,
|
||||
@@ -291,3 +303,36 @@ async fn reconnect_during_activation_returns_clear_error_without_connected() {
|
||||
);
|
||||
assert!(consumer.events.try_recv().is_err());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn supervision_completion_keeps_consumer_alive_until_owner_stops_it() {
|
||||
let (channel, mut peer) = UnixStream::pair().unwrap();
|
||||
let mut control = ConsumerControl::new(channel);
|
||||
let (_native, observations) = mpsc::channel(1);
|
||||
let (events, _notifications) = mpsc::channel(1);
|
||||
let cancellation = CancellationToken::new();
|
||||
cancellation.cancel();
|
||||
supervise(
|
||||
Identity {
|
||||
service_instance: uuid::Uuid::new_v4(),
|
||||
attempt: 1,
|
||||
launch_id: uuid::Uuid::new_v4(),
|
||||
},
|
||||
&mut control,
|
||||
Bootstrap::default(),
|
||||
observations,
|
||||
cancellation,
|
||||
events,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(
|
||||
tokio::time::timeout(Duration::from_millis(30), receive(&mut peer))
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
control.stop().await;
|
||||
assert!(matches!(receive(&mut peer).await.unwrap(), Message::Stop));
|
||||
drop(control);
|
||||
assert!(receive(&mut peer).await.is_err());
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
use anyhow::{Context, ensure};
|
||||
use gpapi::script_tun::{Bootstrap, ScriptTunRequest};
|
||||
use openconnect::{Vpn, VpnBuilder};
|
||||
pub(super) type ControlStream = tokio::net::UnixStream;
|
||||
pub(crate) struct PreparedScriptTun {
|
||||
pub(super) control: Option<std::os::unix::net::UnixStream>,
|
||||
pub bootstrap: Bootstrap,
|
||||
}
|
||||
|
||||
pub(crate) 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: Some(control),
|
||||
bootstrap: request.bootstrap.clone(),
|
||||
},
|
||||
))
|
||||
}
|
||||
|
||||
impl PreparedScriptTun {
|
||||
pub(super) async fn connect(&mut self) -> anyhow::Result<ControlStream> {
|
||||
let control = self.control.take().context("Worker control pipe is unavailable")?;
|
||||
control.set_nonblocking(true)?;
|
||||
Ok(tokio::net::UnixStream::from_std(control)?)
|
||||
}
|
||||
// The native OpenConnect Unix launcher owns/reaps its child on disconnect.
|
||||
pub(super) fn stop_worker(&mut self) -> anyhow::Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
use anyhow::{Context, ensure};
|
||||
use gpapi::{
|
||||
process::user_process::UserProcess,
|
||||
script_tun::{Bootstrap, ScriptTunRequest},
|
||||
windows::PipeClientIdentity,
|
||||
};
|
||||
use openconnect::{Vpn, VpnBuilder};
|
||||
use std::{os::windows::io::AsRawHandle, sync::Arc, time::Duration};
|
||||
use tokio::net::windows::named_pipe::NamedPipeServer;
|
||||
use windows_sys::Win32::System::Pipes::GetNamedPipeClientProcessId;
|
||||
pub(super) type ControlStream = NamedPipeServer;
|
||||
|
||||
pub(crate) struct PreparedScriptTun {
|
||||
control: Option<NamedPipeServer>,
|
||||
worker: UserProcess,
|
||||
pub(super) bootstrap: Bootstrap,
|
||||
}
|
||||
pub(crate) fn builder(
|
||||
server: &str,
|
||||
cookie: &str,
|
||||
request: &ScriptTunRequest,
|
||||
owner: Arc<PipeClientIdentity>,
|
||||
) -> anyhow::Result<(VpnBuilder, PreparedScriptTun)> {
|
||||
request.validate()?;
|
||||
let attempt = uuid::Uuid::new_v4();
|
||||
let control_name = format!(r"\\.\pipe\GPConnect.ScriptTun.{attempt}.Control");
|
||||
let packet_name = format!(r"\\.\pipe\GPConnect.ScriptTun.{attempt}.Packets");
|
||||
let control = owner.create_control_pipe(&control_name)?;
|
||||
let mut packets = owner.create_packet_pipe(&packet_name)?;
|
||||
let worker = UserProcess::launch(
|
||||
owner.primary_token(),
|
||||
&request.program,
|
||||
&request.args,
|
||||
&[
|
||||
("OPENCONNECT_SCRIPT_TUN_CONTROL_PIPE", &control_name),
|
||||
("VPN_PIPE", &packet_name),
|
||||
],
|
||||
)
|
||||
.context("Could not launch the user-session packet worker")?;
|
||||
packets.connect(worker.id(), Duration::from_secs(10))?;
|
||||
// PacketPipe creates only raw overlapped Win32 I/O and never registers IOCP.
|
||||
let builder = unsafe { Vpn::builder(server, cookie).script_tun_pipe(packets.into_handle()) };
|
||||
Ok((
|
||||
builder,
|
||||
PreparedScriptTun {
|
||||
control: Some(control),
|
||||
worker,
|
||||
bootstrap: request.bootstrap.clone(),
|
||||
},
|
||||
))
|
||||
}
|
||||
impl PreparedScriptTun {
|
||||
pub(super) async fn connect(&mut self) -> anyhow::Result<ControlStream> {
|
||||
ensure!(!self.worker.has_exited()?, "The packet worker exited during startup");
|
||||
let control = self.control.take().context("Worker control pipe is unavailable")?;
|
||||
tokio::time::timeout(Duration::from_secs(10), control.connect())
|
||||
.await
|
||||
.context("Packet control connection timed out")??;
|
||||
let mut pid = 0;
|
||||
if unsafe { GetNamedPipeClientProcessId(control.as_raw_handle(), &mut pid) } == 0 {
|
||||
return Err(std::io::Error::last_os_error().into());
|
||||
}
|
||||
ensure!(pid == self.worker.id(), "Unexpected packet control client");
|
||||
Ok(control)
|
||||
}
|
||||
pub(super) fn stop_worker(&mut self) -> anyhow::Result<()> {
|
||||
Ok(self.worker.stop()?)
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user