use crate::classifier::{classify, Protection};
use nix::sys::signal::{kill as nix_kill, Signal};
use nix::unistd::Pid;
use std::time::Duration;
#[derive(Debug, PartialEq, Eq)]
pub enum KillError {
Protected,
PermissionDenied,
NotFound,
Other,
}
pub fn is_alive(pid: u32) -> bool {
let Ok(raw) = i32::try_from(pid) else {
return false;
};
match nix_kill(Pid::from_raw(raw), None) {
Ok(()) => true,
Err(nix::errno::Errno::EPERM) => true, Err(_) => false,
}
}
pub fn should_sigkill(pid: u32, name: &str) -> bool {
is_alive(pid) && classify(name, pid) == Protection::Killable
}
pub fn kill(pid: u32, name: &str) -> Result<(), KillError> {
if classify(name, pid) == Protection::Protected {
return Err(KillError::Protected);
}
let raw = i32::try_from(pid).map_err(|_| KillError::Other)?;
let target = Pid::from_raw(raw);
match nix_kill(target, Signal::SIGTERM) {
Ok(()) => {}
Err(nix::errno::Errno::ESRCH) => return Err(KillError::NotFound),
Err(nix::errno::Errno::EPERM) => return Err(KillError::PermissionDenied),
Err(_) => return Err(KillError::Other),
}
let owned_name = name.to_owned();
std::thread::spawn(move || {
std::thread::sleep(Duration::from_secs(2));
if should_sigkill(pid, &owned_name) {
let _ = nix_kill(target, Signal::SIGKILL);
}
});
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use nix::sys::wait::{waitpid, WaitPidFlag};
use std::process::Command;
use std::thread::sleep;
#[test]
fn should_sigkill_false_for_protected_name() {
assert!(!should_sigkill(5000, "launchd"));
assert!(!should_sigkill(5000, "kernel_task"));
}
#[test]
fn should_sigkill_false_for_dead_pid() {
assert!(!should_sigkill(999_999, "ghost"));
}
#[test]
fn should_sigkill_false_for_low_pid_regardless_of_name() {
assert!(!should_sigkill(1, "sleep"));
}
fn spawn_sleeper() -> u32 {
Command::new("sleep")
.arg("60")
.spawn()
.expect("spawn sleep")
.id()
}
fn reap(pid: u32) {
let _ = waitpid(Pid::from_raw(pid as i32), Some(WaitPidFlag::WNOHANG));
sleep(Duration::from_millis(50));
let _ = waitpid(Pid::from_raw(pid as i32), None);
}
#[test]
fn is_alive_true_for_running_then_false_after_kill() {
let pid = spawn_sleeper();
assert!(is_alive(pid), "sleeper should be alive");
nix_kill(Pid::from_raw(pid as i32), Signal::SIGKILL).unwrap();
sleep(Duration::from_millis(300));
reap(pid);
assert!(!is_alive(pid), "sleeper should be dead after SIGKILL");
}
#[test]
fn kill_refuses_protected() {
assert_eq!(kill(1, "launchd"), Err(KillError::Protected));
}
#[test]
fn kill_terminates_killable_process() {
let pid = spawn_sleeper();
assert_eq!(kill(pid, "sleep"), Ok(()));
sleep(Duration::from_millis(500));
reap(pid);
assert!(!is_alive(pid), "sleeper should be terminated by SIGTERM");
}
#[test]
fn kill_not_found_for_dead_pid() {
let pid = spawn_sleeper();
nix_kill(Pid::from_raw(pid as i32), Signal::SIGKILL).unwrap();
sleep(Duration::from_millis(300));
assert_eq!(kill(999_999, "ghost"), Err(KillError::NotFound));
}
}