fix: keep background VPN worker running after reconnect (#687)

This commit is contained in:
Kevin Yue authored and GitHub committed 2026-11-01 18:32:50 +08:00
1 parent e509cbccdb
commit c3188ce1c8
1 file changed
+37 -9
+37 -9
View File
@@ -2,6 +2,7 @@
//! No process is forked after authentication or OpenConnect has started its threads. //! No process is forked after authentication or OpenConnect has started its threads.
use std::{ use std::{
cell::RefCell,
ffi::OsString, ffi::OsString,
fs::{File, OpenOptions}, fs::{File, OpenOptions},
io::{self, Write}, io::{self, Write},
@@ -27,7 +28,8 @@ use tokio::{io::AsyncReadExt, process::Command};
const READY: u8 = 1; const READY: u8 = 1;
pub(crate) struct BackgroundWorker { pub(crate) struct BackgroundWorker {
ready: UnixStream, // Consumed after detachment; later tunnels stay in the same background session.
ready: RefCell<Option<UnixStream>>,
log: File, log: File,
input: File, input: File,
} }
@@ -82,10 +84,17 @@ impl BackgroundWorker {
"Background log must not be readable or writable by other users" "Background log must not be readable or writable by other users"
); );
let input = File::open("/dev/null")?; let input = File::open("/dev/null")?;
Ok(Self { ready, log, input }) Ok(Self {
ready: RefCell::new(Some(ready)),
log,
input,
})
} }
pub(crate) fn redirect_stdio(&self) -> anyhow::Result<BackgroundStdio> { pub(crate) fn redirect_stdio(&self) -> anyhow::Result<BackgroundStdio> {
if self.ready.borrow().is_none() {
return Ok(BackgroundStdio { saved: None });
}
io::stdout().flush()?; io::stdout().flush()?;
io::stderr().flush()?; io::stderr().flush()?;
let save = |fd| -> anyhow::Result<OwnedFd> { let save = |fd| -> anyhow::Result<OwnedFd> {
@@ -107,13 +116,18 @@ impl BackgroundWorker {
} }
pub(crate) fn detach(&self, stdio: &mut BackgroundStdio) -> anyhow::Result<()> { pub(crate) fn detach(&self, stdio: &mut BackgroundStdio) -> anyhow::Result<()> {
let mut ready = self.ready.borrow_mut();
let Some(socket) = ready.as_mut() else {
return Ok(());
};
// The worker inherited the launcher's foreground group, so it can prompt normally. // The worker inherited the launcher's foreground group, so it can prompt normally.
// It becomes a session leader only when sign-in and tunnel configuration are done. // It becomes a session leader only when sign-in and tunnel configuration are done.
setsid().context("Cannot detach the VPN session from the terminal")?; setsid().context("Cannot detach the VPN session from the terminal")?;
(&self.ready) socket
.write_all(&[READY]) .write_all(&[READY])
.context("Background launcher exited before tunnel setup")?; .context("Background launcher exited before tunnel setup")?;
stdio.saved.take(); stdio.saved.take();
ready.take();
Ok(()) Ok(())
} }
} }
@@ -205,12 +219,13 @@ mod tests {
} }
#[tokio::test] #[tokio::test]
async fn detached_worker_survives_launcher_and_disconnects_by_pid() { async fn detached_worker_reconnects_after_launcher_exits() {
let directory = tempfile::tempdir().unwrap(); let directory = tempfile::tempdir().unwrap();
tokio::time::timeout(Duration::from_secs(5), launch(fixture(directory.path()), &[])) tokio::time::timeout(Duration::from_secs(5), launch(fixture(directory.path()), &[]))
.await .await
.unwrap() .unwrap()
.unwrap(); .unwrap();
std::fs::write(directory.path().join("reconnect"), "").unwrap();
let pid = std::fs::read_to_string(directory.path().join("pid")) let pid = std::fs::read_to_string(directory.path().join("pid"))
.unwrap() .unwrap()
.parse::<i32>() .parse::<i32>()
@@ -222,18 +237,19 @@ mod tests {
"Worker must own a terminal-independent session" "Worker must own a terminal-independent session"
); );
kill(pid, None).unwrap(); kill(pid, None).unwrap();
tokio::time::timeout(Duration::from_secs(5), async { let reconnected = tokio::time::timeout(Duration::from_secs(5), async {
while !std::fs::read_to_string(directory.path().join("worker.log")) while !std::fs::read_to_string(directory.path().join("worker.log"))
.unwrap() .unwrap()
.contains("helper-output") .contains("reconnected-output")
{ {
tokio::time::sleep(Duration::from_millis(10)).await; tokio::time::sleep(Duration::from_millis(10)).await;
} }
}) })
.await .await;
.unwrap();
let log = std::fs::read_to_string(directory.path().join("worker.log")).unwrap(); let log = std::fs::read_to_string(directory.path().join("worker.log")).unwrap();
assert!(reconnected.is_ok(), "Worker did not reconnect:\n{log}");
assert!(log.contains("failed-attempt-output")); assert!(log.contains("failed-attempt-output"));
assert!(log.contains("helper-output"));
assert!(!log.contains("restored-foreground-output")); assert!(!log.contains("restored-foreground-output"));
#[derive(clap::Parser)] #[derive(clap::Parser)]
struct Disconnect { struct Disconnect {
@@ -295,8 +311,20 @@ mod tests {
worker.detach(&mut stdio).unwrap(); worker.detach(&mut stdio).unwrap();
println!("detached-output"); println!("detached-output");
io::stdout().flush().unwrap(); io::stdout().flush().unwrap();
interrupt.recv().await; tokio::time::timeout(Duration::from_secs(5), async {
while !directory.join("reconnect").exists() {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.unwrap();
helper.wait().unwrap(); helper.wait().unwrap();
let mut stdio = worker.redirect_stdio().unwrap();
worker.detach(&mut stdio).unwrap();
assert_eq!(getsid(None).unwrap(), getpid());
println!("reconnected-output");
io::stdout().flush().unwrap();
interrupt.recv().await;
std::fs::write(directory.join("stopped"), "stopped").unwrap(); std::fs::write(directory.join("stopped"), "stopped").unwrap();
} }
} }