uucore: handle SIGRTMIN+N and SIGRTMAX-N notation

On Linux, signals in the range SIGRTMIN..SIGRTMAX are valid in addition
to SIGRTMIN and SIGRTMAX themselves. The notation SIGRTMIN+N and
SIGRTMAX-N is used to reference signals in that range.

Adapt signal helpers to understand this.

Author: enr0n

src/uu/env/src/env.rs

@@ -1148,7 +1148,7 @@ fn list_signal_handling(log: &SignalActionLog) {
             SignalActionKind::Ignore => "IGNORE",
             SignalActionKind::Block => "BLOCK",
         };
-        let signal_name = signal_name_by_value(sig_value).unwrap_or("?");
+        let signal_name = signal_name_by_value(sig_value).unwrap_or("?".to_string());
         eprintln!("{signal_name:<10} ({}): {action}", sig_value as i32);
     }
 }

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

@@ -399,31 +399,67 @@ pub fn signal_by_name_or_value(signal_name_or_value: &str) -> Option<usize> {
         if is_signal(value) {
             return Some(value);
         }
-        return realtime_signal_bounds()
-            .filter(|&(rtmin, rtmax)| value >= rtmin && value <= rtmax)
-            .map(|_| value);
     }
     let signal_name = signal_name_upcase.trim_start_matches("SIG");
 
     if let Some(pos) = ALL_SIGNALS.iter().position(|&s| s == signal_name) {
         return Some(pos);
     }
 
-    realtime_signal_bounds().and_then(|(rtmin, rtmax)| match signal_name {
-        "RTMIN" => Some(rtmin),
-        "RTMAX" => Some(rtmax),
-        _ => None,
+    realtime_signal_bounds().and_then(|(rtmin, rtmax)| {
+        if signal_name.starts_with("RTMIN+") {
+            if let Ok(n) = signal_name.trim_start_matches("RTMIN+").parse::<usize>() {
+                let value = rtmin + n;
+                return (value >= rtmin && value <= rtmax).then_some(value);
+            }
+        }
+
+        if signal_name.starts_with("RTMAX-") {
+            if let Ok(n) = signal_name.trim_start_matches("RTMAX-").parse::<usize>() {
+                let value = rtmax - n;
+                return (value >= rtmin && value <= rtmax).then_some(value);
+            }
+        }
+
+        match signal_name {
+            "RTMIN" => Some(rtmin),
+            "RTMAX" => Some(rtmax),
+            _ => None,
+        }
     })
 }
 
 /// Returns true if the given number is a valid signal number.
 pub fn is_signal(num: usize) -> bool {
-    num < ALL_SIGNALS.len()
+    if num < ALL_SIGNALS.len() {
+        return true;
+    }
+
+    if let Some((rtmin, rtmax)) = realtime_signal_bounds() {
+        return num >= rtmin && num <= rtmax;
+    }
+
+    false
 }
 
 /// Returns the signal name for a given signal value.
-pub fn signal_name_by_value(signal_value: usize) -> Option<&'static str> {
-    ALL_SIGNALS.get(signal_value).copied()
+pub fn signal_name_by_value(signal_value: usize) -> Option<String> {
+    if let Some(name) = ALL_SIGNALS.get(signal_value).copied() {
+        return Some(name.to_string());
+    }
+
+    realtime_signal_bounds().and_then(|(rtmin, rtmax)| {
+        if signal_value == rtmin {
+            Some("RTMIN".to_string())
+        } else if signal_value == rtmax {
+            Some("RTMAX".to_string())
+        } else if signal_value > rtmin && signal_value < rtmax {
+            let n = signal_value - rtmin;
+            Some(format!("RTMIN+{n}"))
+        } else {
+            None
+        }
+    })
 }
 
 #[cfg(any(target_os = "linux", target_os = "android"))]
@@ -449,7 +485,7 @@ pub fn signal_number_upper_bound() -> usize {
 /// Returns the signal name for list-style interfaces.
 pub fn signal_list_name_by_value(signal_value: usize) -> Option<String> {
     if let Some(signal_name) = signal_name_by_value(signal_value) {
-        return Some(signal_name.to_string());
+        return Some(signal_name);
     }
 
     realtime_signal_bounds().and_then(|(rtmin, rtmax)| {
@@ -719,7 +755,7 @@ fn signal_by_long_name() {
 #[test]
 fn name() {
     for (value, signal) in ALL_SIGNALS.iter().enumerate() {
-        assert_eq!(signal_name_by_value(value), Some(*signal));
+        assert_eq!(signal_name_by_value(value), Some(signal.to_string()));
     }
 }
 
@@ -783,11 +819,35 @@ fn linux_realtime_signals_resolve_by_name_or_value() {
 
     // By name
     assert_eq!(signal_by_name_or_value("RTMIN"), Some(rtmin));
+    for i in 1..rtmax - rtmin - 1 {
+        assert_eq!(
+            signal_by_name_or_value(&format!("RTMIN+{i}")),
+            Some(rtmin + i)
+        );
+        assert_eq!(
+            signal_by_name_or_value(&format!("RTMAX-{i}")),
+            Some(rtmax - i)
+        );
+    }
     assert_eq!(signal_by_name_or_value("RTMAX"), Some(rtmax));
     assert_eq!(signal_by_name_or_value("SIGRTMIN"), Some(rtmin));
+    for i in 1..rtmax - rtmin - 1 {
+        assert_eq!(
+            signal_by_name_or_value(&format!("SIGRTMIN+{i}")),
+            Some(rtmin + i)
+        );
+        assert_eq!(
+            signal_by_name_or_value(&format!("SIGRTMAX-{i}")),
+            Some(rtmax - i)
+        );
+    }
     assert_eq!(signal_by_name_or_value("SIGRTMAX"), Some(rtmax));
 
     // By numeric value
     assert_eq!(signal_by_name_or_value(&rtmin.to_string()), Some(rtmin));
+    for i in 1..rtmax - rtmin - 1 {
+        let value = rtmin + i;
+        assert_eq!(signal_by_name_or_value(&value.to_string()), Some(value));
+    }
     assert_eq!(signal_by_name_or_value(&rtmax.to_string()), Some(rtmax));
 }