Major redesign. Remove InterruptibleCommand trait. Change to ctrl-break on Windows. Stop add creation flags on Windows.

Author: nu11ptr

README.md

@@ -28,7 +28,7 @@ cargo add send_ctrlc -F tokio
 ## Examples
 
 ```rust
-use send_ctrlc::{Interruptible as _, InterruptibleCommand as _};
+use send_ctrlc::{Interruptible as _};
 
 // Synchronous...
 
@@ -41,7 +41,7 @@ fn main() {
         command.arg("127.0.0.1");
 
         // Spawn the ping, interrupt it, and wait for it to complete
-        let mut child = command.spawn_interruptible().unwrap();
+        let mut child = command.spawn().unwrap();
         child.interrupt().unwrap();
         child.wait().unwrap();
 }
@@ -58,7 +58,7 @@ async fn main() {
         command.arg("127.0.0.1");
 
         // Spawn the ping, interrupt it, and wait for it to complete
-        let mut child = command.spawn_interruptible().unwrap();
+        let mut child = command.spawn().unwrap();
         child.interrupt().unwrap();
         child.wait().await.unwrap();
 }

src/lib.rs

@@ -11,21 +11,6 @@ mod readme_tests {}
 
 use std::io;
 
-pub use stdlib::InterruptibleChild;
-
-#[cfg(windows)]
-const CREATE_NEW_PROCESS_GROUP: u32 = 0x00000200;
-
-/// A trait for spawning interruptible child processes
-pub trait InterruptibleCommand {
-    type Child: Interruptible;
-
-    /// Spawn a new interruptible child process that has been specifically configured
-    /// to ensure it is interruptible. An error is returned if one occurs while attempting
-    /// to spawn the child process.
-    fn spawn_interruptible(&mut self) -> io::Result<Self::Child>;
-}
-
 /// A trait for sending interrupts/ctrl-c to child processes.
 ///
 /// NOTE: By implementing this trait, you are stating that the correct steps have been taken to
@@ -67,12 +52,16 @@ mod inner {
 
     #[cfg(windows)]
     pub fn interrupt(pid: u32) -> io::Result<()> {
-        use windows_sys::Win32::System::Console::{CTRL_C_EVENT, GenerateConsoleCtrlEvent};
+        use windows_sys::Win32::System::Console::{CTRL_BREAK_EVENT, GenerateConsoleCtrlEvent};
 
-        // NOTE: This only works if the process is in a new process group
+        // NOTE: After testing, it seems CTRL_BREAK_EVENT works in all cases (or all the ones I tried).
+        // CTRL_C_EVENT didn't work for the `ctrlc` crate, for example, which is my primary use case.
+        // NOTE 2: Despite what the docs say, and I found them confusing, it seems that no special
+        // creation flags are actually needed anymore on Windows 10+. According to ChatGPT, this changed
+        // around Windows 10+. I don't have anything older to test on to confirm or deny this.
         // SAFETY: This is a standard Windows console function. Any number passed in is memory safe,
         // even if it impacts a process the user hadn't intended.
-        if unsafe { GenerateConsoleCtrlEvent(CTRL_C_EVENT, pid) } != 0 {
+        if unsafe { GenerateConsoleCtrlEvent(CTRL_BREAK_EVENT, pid) } != 0 {
             Ok(())
         } else {
             Err(io::Error::last_os_error())

src/stdlib.rs

@@ -1,54 +1,17 @@
-use std::{
-    io,
-    ops::{Deref, DerefMut},
-    process::{Child, Command},
-};
+use std::{io, process::Child};
 
-use crate::{Interruptible, InterruptibleCommand};
+use crate::Interruptible;
 
-#[cfg(windows)]
-fn set_creation_flags(command: &mut Command) {
-    use std::os::windows::process::CommandExt as _;
-    command.creation_flags(crate::CREATE_NEW_PROCESS_GROUP);
-}
-
-impl InterruptibleCommand for Command {
-    type Child = InterruptibleChild;
-
-    fn spawn_interruptible(&mut self) -> io::Result<InterruptibleChild> {
-        #[cfg(windows)]
-        set_creation_flags(self);
-        self.spawn().map(InterruptibleChild)
-    }
-}
-
-/// A child process that can be interrupted
-pub struct InterruptibleChild(Child);
-
-impl Interruptible for InterruptibleChild {
+impl Interruptible for Child {
     fn pid(&mut self) -> io::Result<Option<u32>> {
-        match self.0.try_wait() {
+        match self.try_wait() {
             Ok(Some(_)) => Ok(None),
-            Ok(None) => Ok(Some(self.0.id())),
+            Ok(None) => Ok(Some(self.id())),
             Err(e) => Err(e),
         }
     }
 }
 
-impl Deref for InterruptibleChild {
-    type Target = Child;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl DerefMut for InterruptibleChild {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -60,7 +23,7 @@ mod tests {
         command.arg("-t");
         command.arg("127.0.0.1");
 
-        let mut child = command.spawn_interruptible().unwrap();
+        let mut child = command.spawn().unwrap();
         child.interrupt().unwrap();
         child.wait().unwrap();
     }
@@ -69,7 +32,7 @@ mod tests {
     fn test_completed_interruptible_command() {
         let mut command = std::process::Command::new("ping");
 
-        let mut child = command.spawn_interruptible().unwrap();
+        let mut child = command.spawn().unwrap();
         child.wait().unwrap();
         assert!(child.interrupt().is_err());
     }

src/tokio.rs

@@ -1,47 +1,12 @@
-use std::{
-    io,
-    ops::{Deref, DerefMut},
-};
+use std::io;
 
-use crate::{Interruptible, InterruptibleCommand};
+use crate::Interruptible;
 
-use tokio::process::{Child, Command};
+use tokio::process::Child;
 
-#[cfg(windows)]
-fn set_creation_flags(command: &mut Command) {
-    command.creation_flags(crate::CREATE_NEW_PROCESS_GROUP);
-}
-
-impl InterruptibleCommand for Command {
-    type Child = InterruptibleChild;
-
-    fn spawn_interruptible(&mut self) -> io::Result<InterruptibleChild> {
-        #[cfg(windows)]
-        set_creation_flags(self);
-        self.spawn().map(InterruptibleChild)
-    }
-}
-
-/// A child process that can be interrupted
-pub struct InterruptibleChild(Child);
-
-impl Interruptible for InterruptibleChild {
+impl Interruptible for Child {
     fn pid(&mut self) -> io::Result<Option<u32>> {
-        Ok(self.0.id())
-    }
-}
-
-impl Deref for InterruptibleChild {
-    type Target = Child;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl DerefMut for InterruptibleChild {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
+        Ok(self.id())
     }
 }
 
@@ -56,7 +21,7 @@ mod tests {
         command.arg("-t");
         command.arg("127.0.0.1");
 
-        let mut child = command.spawn_interruptible().unwrap();
+        let mut child = command.spawn().unwrap();
         child.interrupt().unwrap();
         child.wait().await.unwrap();
     }
@@ -65,7 +30,7 @@ mod tests {
     async fn test_completed_interruptible_command() {
         let mut command = tokio::process::Command::new("ping");
 
-        let mut child = command.spawn_interruptible().unwrap();
+        let mut child = command.spawn().unwrap();
         child.wait().await.unwrap();
         assert!(child.interrupt().is_err());
     }