use std::io;
use std::process::Child;
use std::sync::{Mutex, MutexGuard, OnceLock, PoisonError};
use std::thread::Builder;
use std::time::{Duration, Instant};
use rustix::process::{Pid, Signal as Raw};
use signal_hook::consts::{SIGHUP, SIGINT, SIGTERM};
use signal_hook::iterator::Signals;
use crate::sys;
#[cfg(test)]
mod tests;
pub const FORWARD_GRACE: Duration = Duration::from_secs(1);
const CHECK: Duration = Duration::from_millis(10);
static LISTED: Mutex<Vec<Pid>> = Mutex::new(Vec::new());
static CLEAN_UPS: Mutex<Vec<fn()>> = Mutex::new(Vec::new());
static INSTALLED: OnceLock<Result<(), io::ErrorKind>> = OnceLock::new();
pub fn install() -> io::Result<()> {
match INSTALLED.get_or_init(start) {
Ok(()) => Ok(()),
Err(kind) => Err(io::Error::new(
*kind,
"cannot start the thread that forwards signals",
)),
}
}
pub fn clean_up(clean_up: fn()) {
let mut clean_ups = CLEAN_UPS.lock().unwrap_or_else(PoisonError::into_inner);
if !clean_ups
.iter()
.any(|kept| std::ptr::fn_addr_eq(*kept, clean_up))
{
clean_ups.push(clean_up);
}
}
fn start() -> Result<(), io::ErrorKind> {
let mut signals = Signals::new([SIGINT, SIGTERM, SIGHUP]).map_err(|error| error.kind())?;
Builder::new()
.name("crumbkit-process forward".to_owned())
.spawn(move || {
for raw in signals.forever() {
forward(raw);
}
})
.map(drop)
.map_err(|error| error.kind())
}
fn forward(raw: i32) {
let listed = listed_children();
if let Some(signal) = Raw::from_named_raw(raw) {
signal_each(&listed, signal);
}
let until = Instant::now().checked_add(FORWARD_GRACE);
while until.is_some_and(|until| Instant::now() < until)
&& listed
.iter()
.any(|pid| !sys::has_exited(*pid).unwrap_or(true))
{
std::thread::sleep(CHECK);
}
signal_each(&listed, Raw::KILL);
let clean_ups = CLEAN_UPS
.lock()
.unwrap_or_else(PoisonError::into_inner)
.clone();
for clean_up in clean_ups {
let _ = std::panic::catch_unwind(clean_up);
}
let _ = signal_hook::low_level::emulate_default_handler(raw);
}
fn signal_each(listed: &[Pid], signal: Raw) {
for pid in listed {
let _ = sys::signal_group(*pid, signal);
}
}
pub(crate) fn listed(spawn: impl FnOnce() -> io::Result<Child>) -> io::Result<Child> {
let mut listed = listed_children();
let child = spawn()?;
listed.push(Pid::from_child(&child));
Ok(child)
}
pub(crate) fn unlisted<T>(pid: Pid, reap: impl FnOnce() -> T) -> T {
let mut listed = listed_children();
listed.retain(|listed| *listed != pid);
reap()
}
fn listed_children() -> MutexGuard<'static, Vec<Pid>> {
LISTED.lock().unwrap_or_else(PoisonError::into_inner)
}