env: adds --ignore-signal (#6377)

* env: adds --ignore-signal
This commit implement #6164.

* env: handle STOP signal and fix styling issue

* env: fix encoded bytes

* env: adds SAFETY comment and handle special signals in ignore_signal

* env: fix parsing to have compatible behaviour

* env: remove derive from Options

* env: changed safety comment, handle duplications after parsing and non-unix cfg

* env: adds tests for ignore-signal parsing and invalid and special signals

* env: change signal values to be non-constant

* env: adds testing for signal ignoring

* env: styling and remove unix specific derive

* test_env: add SIGSTOP to cspell workspace wordlist

* env: makes signal handling unix specific

* env: make ignore-signal function invocation unix specific

* test_env: make signal vector use slices ref instead of vec (linter)

* env: makes ignore-signal in options unix specific

* test_env: add unix specific import

.vscode/cspell.dictionaries/workspace.wordlist.txt

@@ -166,6 +166,7 @@ RTLD_NEXT
     RTLD
 SIGINT
 SIGKILL
+SIGSTOP
 SIGTERM
 SYS_fdatasync
 SYS_syncfs

src/uu/env/src/env.rs

@@ -19,19 +19,25 @@ use native_int_str::{
     from_native_int_representation_owned, Convert, NCvt, NativeIntStr, NativeIntString, NativeStr,
 };
 #[cfg(unix)]
-use nix::sys::signal::{raise, sigaction, SaFlags, SigAction, SigHandler, SigSet, Signal};
+use nix::sys::signal::{
+    raise, sigaction, signal, SaFlags, SigAction, SigHandler, SigHandler::SigIgn, SigSet, Signal,
+};
 use std::borrow::Cow;
 use std::env;
 use std::ffi::{OsStr, OsString};
 use std::io::{self, Write};
 use std::ops::Deref;
 
+#[cfg(unix)]
+use std::os::unix::ffi::OsStrExt;
 #[cfg(unix)]
 use std::os::unix::process::{CommandExt, ExitStatusExt};
 use std::process::{self};
 use uucore::display::Quotable;
 use uucore::error::{ExitCode, UError, UResult, USimpleError, UUsageError};
 use uucore::line_ending::LineEnding;
+#[cfg(unix)]
+use uucore::signals::signal_by_name_or_value;
 use uucore::{format_usage, help_about, help_section, help_usage, show_warning};
 
 const ABOUT: &str = help_about!("env.md");
@@ -49,6 +55,8 @@ struct Options<'a> {
     sets: Vec<(Cow<'a, OsStr>, Cow<'a, OsStr>)>,
     program: Vec<&'a OsStr>,
     argv0: Option<&'a OsStr>,
+    #[cfg(unix)]
+    ignore_signal: Vec<usize>,
 }
 
 // print name=value env pairs on screen
@@ -87,6 +95,59 @@ fn parse_program_opt<'a>(opts: &mut Options<'a>, opt: &'a OsStr) -> UResult<()>
     }
 }
 
+#[cfg(unix)]
+fn parse_signal_value(signal_name: &str) -> UResult<usize> {
+    let signal_name_upcase = signal_name.to_uppercase();
+    let optional_signal_value = signal_by_name_or_value(&signal_name_upcase);
+    let error = USimpleError::new(125, format!("{}: invalid signal", signal_name.quote()));
+    match optional_signal_value {
+        Some(sig_val) => {
+            if sig_val == 0 {
+                Err(error)
+            } else {
+                Ok(sig_val)
+            }
+        }
+        None => Err(error),
+    }
+}
+
+#[cfg(unix)]
+fn parse_signal_opt<'a>(opts: &mut Options<'a>, opt: &'a OsStr) -> UResult<()> {
+    if opt.is_empty() {
+        return Ok(());
+    }
+    let signals: Vec<&'a OsStr> = opt
+        .as_bytes()
+        .split(|&b| b == b',')
+        .map(OsStr::from_bytes)
+        .collect();
+
+    let mut sig_vec = Vec::with_capacity(signals.len());
+    signals.into_iter().for_each(|sig| {
+        if !(sig.is_empty()) {
+            sig_vec.push(sig);
+        }
+    });
+    for sig in sig_vec {
+        let sig_str = match sig.to_str() {
+            Some(s) => s,
+            None => {
+                return Err(USimpleError::new(
+                    1,
+                    format!("{}: invalid signal", sig.quote()),
+                ))
+            }
+        };
+        let sig_val = parse_signal_value(sig_str)?;
+        if !opts.ignore_signal.contains(&sig_val) {
+            opts.ignore_signal.push(sig_val);
+        }
+    }
+
+    Ok(())
+}
+
 fn load_config_file(opts: &mut Options) -> UResult<()> {
     // NOTE: config files are parsed using an INI parser b/c it's available and compatible with ".env"-style files
     //   ... * but support for actual INI files, although working, is not intended, nor claimed
@@ -201,6 +262,14 @@ pub fn uu_app() -> Command {
                 .action(ArgAction::Append)
                 .value_parser(ValueParser::os_string())
         )
+        .arg(
+            Arg::new("ignore-signal")
+                .long("ignore-signal")
+                .value_name("SIG")
+                .action(ArgAction::Append)
+                .value_parser(ValueParser::os_string())
+                .help("set handling of SIG signal(s) to do nothing")
+        )
 }
 
 pub fn parse_args_from_str(text: &NativeIntStr) -> UResult<Vec<NativeIntString>> {
@@ -367,6 +436,9 @@ impl EnvAppData {
 
         apply_specified_env_vars(&opts);
 
+        #[cfg(unix)]
+        apply_ignore_signal(&opts)?;
+
         if opts.program.is_empty() {
             // no program provided, so just dump all env vars to stdout
             print_env(opts.line_ending);
@@ -502,8 +574,17 @@ fn make_options(matches: &clap::ArgMatches) -> UResult<Options<'_>> {
         sets: vec![],
         program: vec![],
         argv0,
+        #[cfg(unix)]
+        ignore_signal: vec![],
     };
 
+    #[cfg(unix)]
+    if let Some(iter) = matches.get_many::<OsString>("ignore-signal") {
+        for opt in iter {
+            parse_signal_opt(&mut opts, opt)?;
+        }
+    }
+
     let mut begin_prog_opts = false;
     if let Some(mut iter) = matches.get_many::<OsString>("vars") {
         // read NAME=VALUE arguments (and up to a single program argument)
@@ -602,6 +683,35 @@ fn apply_specified_env_vars(opts: &Options<'_>) {
     }
 }
 
+#[cfg(unix)]
+fn apply_ignore_signal(opts: &Options<'_>) -> UResult<()> {
+    for &sig_value in &opts.ignore_signal {
+        let sig: Signal = (sig_value as i32)
+            .try_into()
+            .map_err(|e| std::io::Error::from_raw_os_error(e as i32))?;
+
+        ignore_signal(sig)?;
+    }
+    Ok(())
+}
+
+#[cfg(unix)]
+fn ignore_signal(sig: Signal) -> UResult<()> {
+    // SAFETY: This is safe because we write the handler for each signal only once, and therefore "the current handler is the default", as the documentation requires it.
+    let result = unsafe { signal(sig, SigIgn) };
+    if let Err(err) = result {
+        return Err(USimpleError::new(
+            125,
+            format!(
+                "failed to set signal action for signal {}: {}",
+                sig as i32,
+                err.desc()
+            ),
+        ));
+    }
+    Ok(())
+}
+
 #[uucore::main]
 pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     EnvAppData::default().run_env(args)

tests/by-util/test_env.rs

@@ -5,11 +5,55 @@
 // spell-checker:ignore (words) bamf chdir rlimit prlimit COMSPEC cout cerr FFFD
 
 use crate::common::util::TestScenario;
+#[cfg(unix)]
+use crate::common::util::UChild;
+#[cfg(unix)]
+use nix::sys::signal::Signal;
 use regex::Regex;
 use std::env;
 use std::path::Path;
+#[cfg(unix)]
+use std::process::Command;
 use tempfile::tempdir;
 
+#[cfg(unix)]
+struct Target {
+    child: UChild,
+}
+#[cfg(unix)]
+impl Target {
+    fn new(signals: &[&str]) -> Self {
+        let mut child = new_ucmd!()
+            .args(&[
+                format!("--ignore-signal={}", signals.join(",")).as_str(),
+                "sleep",
+                "1000",
+            ])
+            .run_no_wait();
+        child.delay(500);
+        Self { child }
+    }
+    fn send_signal(&mut self, signal: Signal) {
+        Command::new("kill")
+            .args(&[
+                format!("-{}", signal as i32),
+                format!("{}", self.child.id()),
+            ])
+            .spawn()
+            .expect("failed to send signal");
+        self.child.delay(100);
+    }
+    fn is_alive(&mut self) -> bool {
+        self.child.is_alive()
+    }
+}
+#[cfg(unix)]
+impl Drop for Target {
+    fn drop(&mut self) {
+        self.child.kill();
+    }
+}
+
 #[test]
 fn test_invalid_arg() {
     new_ucmd!().arg("--definitely-invalid").fails().code_is(125);
@@ -735,6 +779,102 @@ fn test_env_arg_argv0_overwrite_mixed_with_string_args() {
         .stderr_is("");
 }
 
+#[test]
+#[cfg(unix)]
+fn test_env_arg_ignore_signal_invalid_signals() {
+    let ts = TestScenario::new(util_name!());
+    ts.ucmd()
+        .args(&["--ignore-signal=banana"])
+        .fails()
+        .code_is(125)
+        .stderr_contains("env: 'banana': invalid signal");
+    ts.ucmd()
+        .args(&["--ignore-signal=SIGbanana"])
+        .fails()
+        .code_is(125)
+        .stderr_contains("env: 'SIGbanana': invalid signal");
+    ts.ucmd()
+        .args(&["--ignore-signal=exit"])
+        .fails()
+        .code_is(125)
+        .stderr_contains("env: 'exit': invalid signal");
+    ts.ucmd()
+        .args(&["--ignore-signal=SIGexit"])
+        .fails()
+        .code_is(125)
+        .stderr_contains("env: 'SIGexit': invalid signal");
+}
+
+#[test]
+#[cfg(unix)]
+fn test_env_arg_ignore_signal_special_signals() {
+    let ts = TestScenario::new(util_name!());
+    let signal_stop = nix::sys::signal::SIGSTOP;
+    let signal_kill = nix::sys::signal::SIGKILL;
+    ts.ucmd()
+        .args(&["--ignore-signal=stop", "echo", "hello"])
+        .fails()
+        .code_is(125)
+        .stderr_contains(format!(
+            "env: failed to set signal action for signal {}: Invalid argument",
+            signal_stop as i32
+        ));
+    ts.ucmd()
+        .args(&["--ignore-signal=kill", "echo", "hello"])
+        .fails()
+        .code_is(125)
+        .stderr_contains(format!(
+            "env: failed to set signal action for signal {}: Invalid argument",
+            signal_kill as i32
+        ));
+    ts.ucmd()
+        .args(&["--ignore-signal=SToP", "echo", "hello"])
+        .fails()
+        .code_is(125)
+        .stderr_contains(format!(
+            "env: failed to set signal action for signal {}: Invalid argument",
+            signal_stop as i32
+        ));
+    ts.ucmd()
+        .args(&["--ignore-signal=SIGKILL", "echo", "hello"])
+        .fails()
+        .code_is(125)
+        .stderr_contains(format!(
+            "env: failed to set signal action for signal {}: Invalid argument",
+            signal_kill as i32
+        ));
+}
+
+#[test]
+#[cfg(unix)]
+fn test_env_arg_ignore_signal_valid_signals() {
+    {
+        let mut target = Target::new(&["int"]);
+        target.send_signal(Signal::SIGINT);
+        assert!(target.is_alive());
+    }
+    {
+        let mut target = Target::new(&["usr2"]);
+        target.send_signal(Signal::SIGUSR2);
+        assert!(target.is_alive());
+    }
+    {
+        let mut target = Target::new(&["int", "usr2"]);
+        target.send_signal(Signal::SIGUSR1);
+        assert!(!target.is_alive());
+    }
+}
+
+#[test]
+#[cfg(unix)]
+fn test_env_arg_ignore_signal_empty() {
+    let ts = TestScenario::new(util_name!());
+    ts.ucmd()
+        .args(&["--ignore-signal=", "echo", "hello"])
+        .succeeds()
+        .no_stderr()
+        .stdout_contains("hello");
+}
 #[cfg(test)]
 mod tests_split_iterator {