fix(stat): block ignored signals to imitate GNU

Also added a test case for it.

Author: Alonely0

src/uu/timeout/src/timeout.rs

@@ -20,7 +20,10 @@ use uucore::process::{ChildExt, CommandExt, SelfPipe, WaitOrTimeoutRet};
 use uucore::translate;
 
 #[cfg(unix)]
-use uucore::signals::enable_pipe_errors;
+use ::{
+    nix::sys::signal::{SigSet, SigmaskHow, pthread_sigmask},
+    uucore::signals::{enable_pipe_errors, is_ignored},
+};
 
 use uucore::{
     format_usage, show_error,
@@ -233,7 +236,7 @@ fn wait_or_kill_process(
     self_pipe: &mut SelfPipe,
 ) -> std::io::Result<i32> {
     // ignore `SIGTERM` here
-    self_pipe.unset_other()?;
+    self_pipe.unset_other(Signal::SIGTERM)?;
 
     match process.wait_or_timeout(duration, self_pipe) {
         Ok(WaitOrTimeoutRet::InTime(status)) => {
@@ -280,6 +283,34 @@ fn preserve_signal_info(signal: libc::c_int) -> libc::c_int {
     signal
 }
 
+#[cfg(unix)]
+#[allow(clippy::reversed_empty_ranges)]
+fn block_ignored_signals() -> nix::Result<()> {
+    let mut set = SigSet::empty();
+    let rt_signals = if cfg!(target_os = "linux") {
+        libc::SIGRTMIN()..=libc::SIGRTMAX()
+    } else {
+        0..=(-1)
+    };
+    for s in Signal::iterator()
+        .filter_map(|s| {
+            if matches!(s, Signal::SIGSTOP | Signal::SIGKILL | Signal::SIGTERM) {
+                None
+            } else {
+                Some(s as i32)
+            }
+        })
+        .chain(rt_signals)
+    {
+        if is_ignored(s)? {
+            // We use raw libc bindings because [`nix`] does not support RT signals.
+            // SAFETY: SigSet is repr(transparent) over sigset_t.
+            unsafe { libc::sigaddset((&mut set as *mut SigSet).cast(), s) };
+        }
+    }
+    pthread_sigmask(SigmaskHow::SIG_BLOCK, Some(&set), None)
+}
+
 fn timeout(
     cmd: &[String],
     duration: Duration,
@@ -293,15 +324,23 @@ fn timeout(
         unsafe { libc::setpgid(0, 0) };
     }
     #[cfg(unix)]
-    enable_pipe_errors()?;
+    // We keep the inherited SIGPIPE disposition if ignored.
+    if !is_ignored(Signal::SIGPIPE as _)? {
+        enable_pipe_errors()?;
+    }
 
     let mut command = process::Command::new(&cmd[0]);
     command
         .args(&cmd[1..])
         .stdin(Stdio::inherit())
         .stdout(Stdio::inherit())
         .stderr(Stdio::inherit());
-    let mut self_pipe = command.set_up_timeout(Some(Signal::SIGTERM))?;
+    #[cfg(unix)]
+    block_ignored_signals()?;
+    let mut set = SigSet::empty();
+    set.add(Signal::SIGTERM);
+    set.add(Signal::SIGUSR1);
+    let mut self_pipe = command.set_up_timeout(set)?;
     let process = &mut command.spawn().map_err(|err| {
         let status_code = match err.kind() {
             ErrorKind::NotFound => ExitStatus::CommandNotFound.into(),

src/uucore/src/lib/features/signals.rs

@@ -10,6 +10,9 @@
 //! It provides a way to convert signal names to their corresponding values and vice versa.
 //! It also provides a way to ignore the SIGINT signal and enable pipe errors.
 
+use std::mem::MaybeUninit;
+use std::ptr::null;
+
 #[cfg(unix)]
 use nix::errno::Errno;
 #[cfg(unix)]
@@ -410,6 +413,17 @@ pub fn signal_name_by_value(signal_value: usize) -> Option<&'static str> {
     ALL_SIGNALS.get(signal_value).copied()
 }
 
+/// Returns whether signal disposition is to ignore. We use raw i32 because [`nix`] does not currently
+/// support RT signals.
+#[cfg(unix)]
+pub fn is_ignored(signal: i32) -> Result<bool, Errno> {
+    let mut prev_handler = MaybeUninit::uninit();
+    // We use libc functions here because nix does not properly
+    // support real-time signals nor null sigaction handlers.
+    Errno::result(unsafe { libc::sigaction(signal, null(), prev_handler.as_mut_ptr()) })?;
+    Ok(unsafe { prev_handler.assume_init() }.sa_sigaction == libc::SIG_IGN)
+}
+
 /// Returns the default signal value.
 #[cfg(unix)]
 pub fn enable_pipe_errors() -> Result<(), Errno> {

tests/by-util/test_timeout.rs

@@ -1,3 +1,4 @@
+use std::process::Command;
 use std::time::{Duration, Instant};
 use uutests::util::TestScenario;
 
@@ -255,11 +256,7 @@ fn test_command_cannot_invoke() {
 #[test]
 fn test_cascaded_timeout_with_bash_trap() {
     // Use bash if available, otherwise skip
-    if std::process::Command::new("bash")
-        .arg("--version")
-        .output()
-        .is_err()
-    {
+    if Command::new("bash").arg("--version").output().is_err() {
         // Skip test if bash is not available
         return;
     }
@@ -291,3 +288,26 @@ fn test_cascaded_timeout_with_bash_trap() {
         .fails_with_code(124)
         .stdout_contains("bash_trap_fired");
 }
+
+#[test]
+fn test_signal_block_on_ignore() {
+    let ts = TestScenario::new("timeout");
+    let res = ts
+        .cmd("/bin/sh")
+        .arg("-c")
+        .arg(format!(
+            "(trap '' PIPE; {} timeout -v 10 yes | :)",
+            ts.bin_path.to_str().unwrap()
+        ))
+        .timeout(Duration::from_secs(2))
+        .succeeds();
+    // If the signal disposition is correct, instead of being silently killed
+    // by SIGPIPE, `yes` receives an EPIPE error and outputs it.
+    assert_eq!(
+        res.stderr_str()
+            .to_string()
+            .trim_end_matches('\n')
+            .trim_end_matches('\r'),
+        "yes: standard output: Broken pipe"
+    );
+}