rust: fix windows build

Author: rizsotto

rust/Cargo.toml

@@ -23,6 +23,7 @@ nom = { version = "7.1", default-features = false, features = ["std"] }
 regex = "1.9"
 shell-words = "1.1"
 tempfile = "3.13"
+signal-hook = { version = "0.3", features = ["iterator"] }
 
 [workspace.package]
 version = "4.0.0"

rust/bear/Cargo.toml

@@ -40,15 +40,7 @@ nom.workspace = true
 regex.workspace = true
 rand.workspace = true
 tempfile.workspace = true
-nix = { version = "0.29", optional = true, features = ["signal", "process"] }
-winapi = { version = "0.3", optional = true, features = ["processthreadsapi", "winnt", "handleapi"] }
-signal-hook = "0.3.17"
-
-[target.'cfg(unix)'.dependencies]
-nix = { version = "0.29", features = ["signal", "process"] }
-
-[target.'cfg(windows)'.dependencies]
-winapi = { version = "0.3", features = ["processthreadsapi", "winnt", "handleapi"] }
+signal-hook.workspace = true
 
 [profile.release]
 strip = true

rust/bear/src/intercept/supervise.rs

@@ -1,118 +1,44 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 use anyhow::Result;
-use nix::libc::c_int;
-#[cfg(unix)]
-use nix::sys::signal::{kill, Signal};
-#[cfg(unix)]
-use nix::unistd::Pid;
 use std::process::{Command, ExitStatus};
-use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;
 use std::thread;
-use std::time::Duration;
-#[cfg(windows)]
-use winapi::shared::minwindef::FALSE;
-#[cfg(windows)]
-use winapi::um::processthreadsapi::{OpenProcess, TerminateProcess};
-#[cfg(windows)]
-use winapi::um::winnt::{PROCESS_TERMINATE, SYNCHRONIZE};
+use std::time;
 
 /// This method supervises the execution of a command.
 ///
 /// It starts the command and waits for its completion. It also forwards
 /// signals to the child process. The method returns the exit status of the
 /// child process.
 pub fn supervise(command: &mut Command) -> Result<ExitStatus> {
-    let mut child = command.spawn()?;
-
-    let child_pid = child.id();
-    let running = Arc::new(AtomicBool::new(true));
-    let running_in_thread = running.clone();
-
-    let mut signals = signal_hook::iterator::Signals::new([
-        signal_hook::consts::SIGINT,
-        signal_hook::consts::SIGTERM,
-    ])?;
-
-    #[cfg(unix)]
-    {
-        signals.add_signal(signal_hook::consts::SIGHUP)?;
-        signals.add_signal(signal_hook::consts::SIGQUIT)?;
-        signals.add_signal(signal_hook::consts::SIGALRM)?;
-        signals.add_signal(signal_hook::consts::SIGUSR1)?;
-        signals.add_signal(signal_hook::consts::SIGUSR2)?;
-        signals.add_signal(signal_hook::consts::SIGCONT)?;
-        signals.add_signal(signal_hook::consts::SIGSTOP)?;
+    let signaled = Arc::new(AtomicUsize::new(0));
+    for signal in signal_hook::consts::TERM_SIGNALS {
+        signal_hook::flag::register_usize(*signal, Arc::clone(&signaled), *signal as usize)?;
     }
 
-    let handler = thread::spawn(move || {
-        for signal in signals.forever() {
-            log::debug!("Received signal: {:?}", signal);
-            if forward_signal(signal, child_pid) {
-                // If the signal caused termination, we should stop the process.
-                running_in_thread.store(false, Ordering::SeqCst);
-                break;
-            }
+    let mut child = command.spawn()?;
+    loop {
+        // Forward signals to the child process, but don't exit the loop while it is running
+        if signaled.swap(0usize, Ordering::SeqCst) != 0 {
+            log::debug!("Received signal, forwarding to child process");
+            child.kill()?;
         }
-    });
-
-    while running.load(Ordering::SeqCst) {
-        thread::sleep(Duration::from_millis(100));
-    }
-    handler.join().unwrap();
-
-    let exit_status = child.wait()?;
-
-    Ok(exit_status)
-}
-
-#[cfg(windows)]
-fn forward_signal(_: c_int, child_pid: u32) -> bool {
-    let process_handle = unsafe { OpenProcess(PROCESS_TERMINATE | SYNCHRONIZE, FALSE, child_pid) };
-    if process_handle.is_null() {
-        let err = unsafe { winapi::um::errhandling::GetLastError() };
-        log::error!("Failed to open process: {}", err);
-        // If the process handle is not valid, presume the process is not running anymore.
-        return true;
-    }
 
-    let terminated = unsafe { TerminateProcess(process_handle, 1) };
-    if terminated == FALSE {
-        let err = unsafe { winapi::um::errhandling::GetLastError() };
-        log::error!("Failed to terminate process: {}", err);
-    }
-
-    // Ensure proper handle closure
-    unsafe { winapi::um::handleapi::CloseHandle(process_handle) };
-
-    // Return true if the process was terminated.
-    terminated == TRUE
-}
-
-#[cfg(unix)]
-fn forward_signal(signal: c_int, child_pid: u32) -> bool {
-    // Forward the signal to the child process
-    if let Err(e) = kill(
-        Pid::from_raw(child_pid as i32),
-        Signal::try_from(signal).ok(),
-    ) {
-        log::error!("Error forwarding signal: {}", e);
-    }
-
-    // Return true if the process was terminated.
-    match kill(Pid::from_raw(child_pid as i32), None) {
-        Ok(_) => {
-            log::debug!("Checking if the process is still running... yes");
-            false
-        }
-        Err(nix::Error::ESRCH) => {
-            log::debug!("Checking if the process is still running... no");
-            true
-        }
-        Err(_) => {
-            log::debug!("Checking if the process is still running... presume dead");
-            true
+        // Check if the child process has exited
+        match child.try_wait() {
+            Ok(Some(exit_status)) => {
+                log::debug!("Child process exited");
+                return Ok(exit_status);
+            }
+            Ok(None) => {
+                thread::sleep(time::Duration::from_millis(100));
+            }
+            Err(e) => {
+                log::error!("Error waiting for child process: {}", e);
+                return Err(e.into());
+            }
         }
     }
 }