refactor(kill): remove unsafe libc::kill, use safe rustix process APIs

Replace the single unsafe libc::kill() call with safe rustix
equivalents: kill_process, kill_process_group,
kill_current_process_group, and their test_kill_* variants for
signal 0.

Author: sylvestre

Cargo.lock

@@ -24,7 +24,7 @@ uucore = { workspace = true, features = ["signals"] }
 fluent = { workspace = true }
 
 [target.'cfg(unix)'.dependencies]
-nix = { workspace = true, features = ["signal"] }
+rustix = { workspace = true, features = ["process"] }
 
 [[bin]]
 name = "kill"

src/uu/kill/Cargo.toml

@@ -250,11 +250,43 @@ fn parse_pids(pids: &[String]) -> UResult<Vec<i32>> {
         .collect()
 }
 
-fn kill(sig: Option<Signal>, pids: &[i32]) {
+fn kill(sig: i32, pids: &[i32]) {
+    use rustix::process::{
+        Pid, Signal, kill_current_process_group, kill_process, kill_process_group,
+        test_kill_current_process_group, test_kill_process, test_kill_process_group,
+    };
+
     for &pid in pids {
-        if let Err(e) = signal::kill(Pid::from_raw(pid), sig) {
+        let esrch = || Err(rustix::io::Errno::SRCH);
+        let result = if sig == 0 {
+            // Signal 0: test if process/group exists
+            match pid.cmp(&0) {
+                std::cmp::Ordering::Greater => {
+                    Pid::from_raw(pid).map_or_else(esrch, test_kill_process)
+                }
+                std::cmp::Ordering::Equal => test_kill_current_process_group(),
+                std::cmp::Ordering::Less => {
+                    Pid::from_raw(-pid).map_or_else(esrch, test_kill_process_group)
+                }
+            }
+        } else {
+            // SAFETY: sig is a non-zero value from user input; the kernel
+            // will reject truly invalid signal numbers with EINVAL.
+            let signal = unsafe { Signal::from_raw_unchecked(sig) };
+            match pid.cmp(&0) {
+                std::cmp::Ordering::Greater => {
+                    Pid::from_raw(pid).map_or_else(esrch, |p| kill_process(p, signal))
+                }
+                std::cmp::Ordering::Equal => kill_current_process_group(signal),
+                std::cmp::Ordering::Less => {
+                    Pid::from_raw(-pid).map_or_else(esrch, |p| kill_process_group(p, signal))
+                }
+            }
+        };
+
+        if let Err(e) = result {
             show!(
-                Error::from_raw_os_error(e as i32)
+                Error::from(e)
                     .map_err_context(|| { translate!("kill-error-sending-signal", "pid" => pid) })
             );
         }