//! SMH-SPEC-SPEC0001, SMH-SPEC-PLUG0001: Unix `SIGINT` bridge for foreground OAuth login. //! //! The process blocks `SIGINT` before it creates worker threads. //! One waiter receives it through `sigwait`; login then durably aborts its admitted root. use smith::error::{Result, SmithError}; use std::sync::mpsc::{self, Receiver}; /// Receive one process interrupt for one foreground login. pub struct LoginCancellation { receiver: Option>, #[cfg(target_os = "linux")] waiter: Option>>, #[cfg(target_os = "linux")] waiter_thread: nix::sys::pthread::Pthread, #[cfg(target_os = "linux")] old_mask: Option, } impl LoginCancellation { /// Install the process-local interrupt waiter before starting OAuth work. /// /// # Errors /// Returns a configuration error when Linux cannot block or wait for `SIGINT`. #[cfg(target_os = "linux")] pub(crate) fn install() -> Result { use nix::sys::pthread::pthread_self; use nix::sys::signal::{SigSet, SigmaskHow, Signal}; let mut signals = SigSet::empty(); signals.add(Signal::SIGINT); signals.add(Signal::SIGUSR1); let old_mask = signals .thread_swap_mask(SigmaskHow::SIG_BLOCK) .map_err(|_| signal_fault())?; let (send, receiver) = mpsc::sync_channel(1); let (ready_send, ready_receive) = mpsc::sync_channel(1); let waiter = std::thread::spawn(move || { if ready_send.send(pthread_self()).is_err() { return Ok(()); } loop { match signals.wait()? { Signal::SIGINT => { let _sent = send.try_send(()); } Signal::SIGUSR1 => return Ok(()), _ => {} } } }); let Ok(waiter_thread) = ready_receive.recv() else { let _joined = waiter.join(); let _restored = old_mask.thread_set_mask(); return Err(signal_fault()); }; Ok(Self { receiver: Some(receiver), waiter: Some(waiter), waiter_thread, old_mask: Some(old_mask), }) } /// Unsupported hosts retain normal platform signal semantics. #[cfg(not(target_os = "linux"))] pub(crate) fn install() -> Result { let (_send, receiver) = mpsc::sync_channel(1); Ok(Self { receiver: Some(receiver), }) } /// Transfer the one-shot interrupt signal to the admitted login while retaining its guard. pub(crate) fn take_receiver(&mut self) -> Result> { self.receiver.take().ok_or_else(signal_fault) } /// Wake, join, and restore the caller's exact previous signal mask. /// /// # Errors /// Returns a configuration error when the waiter cannot stop or the previous mask cannot restore. pub(crate) fn finish(&mut self) -> Result<()> { #[cfg(target_os = "linux")] { use nix::sys::pthread::pthread_kill; use nix::sys::signal::Signal; let wake = self .waiter .as_ref() .map(|_| pthread_kill(self.waiter_thread, Signal::SIGUSR1)); let joined = self.waiter.take().map_or(Ok(()), |waiter| { waiter .join() .map_err(|_| signal_fault())? .map_err(|_| signal_fault()) }); let restored = self.old_mask.take().map_or(Ok(()), |old_mask| { old_mask.thread_set_mask().map_err(|_| signal_fault()) }); wake.transpose().map_err(|_| signal_fault())?; joined?; restored?; } Ok(()) } } impl Drop for LoginCancellation { fn drop(&mut self) { let _finished = self.finish(); } } fn signal_fault() -> SmithError { SmithError::Config { field: "login".into(), message: "OAuth login interrupt setup failed".into(), } } #[cfg(all(test, target_os = "linux"))] mod tests { //! SMH-SPEC-SPEC0001, SMH-SPEC-PLUG0001: Linux signal guard lifecycle. use super::LoginCancellation; #[test] fn normal_completion_restores_the_calling_thread_mask() { let before = nix::sys::signal::SigSet::thread_get_mask().unwrap(); let mut cancellation = LoginCancellation::install().unwrap(); cancellation.finish().unwrap(); assert_eq!(nix::sys::signal::SigSet::thread_get_mask().unwrap(), before); } }