rust-ctrlc -> rust-simple-signal

Author: swizard0

.gitignore

@@ -1,2 +1,3 @@
 target
 Cargo.lock
+*~

Cargo.toml

@@ -1,18 +1,19 @@
 [package]
 
-name = "ctrlc"
+name = "simple-signal"
 version = "1.0.0"
-authors = ["Antti Keränen <detegr@gmail.com>"]
+authors = ["Antti Keränen <detegr@gmail.com>", "Alexey Voznyuk <me@swizard.info"]
 license = "MIT"
-keywords = ["ctrlc", "signal", "SIGINT"]
-description = "Easy Ctrl-C handler for Rust projects"
-homepage = "https://github.com/Detegr/rust-ctrlc"
-repository = "https://github.com/Detegr/rust-ctrlc.git"
+keywords = ["signal", "SIGINT", "SIGTERM", "SIGQUIT"]
+description = "Easy unix signals handler for Rust projects"
+homepage = "https://github.com/swizard0/rust-simple-signal"
+repository = "https://github.com/swizard0/rust-simple-signal.git"
+
+[lib]
+name = "simple_signal"
 
 [dependencies]
-libc = "0.1"
-winapi = "0.2"
-kernel32-sys = "0.1"
+libc = "*"
 
 [dependencies.lazy_static]
 version = "0.1"

README.md

@@ -1,22 +1,20 @@
-# CtrlC
-[![Build Status](https://travis-ci.org/Detegr/rust-ctrlc.svg?branch=master)](https://travis-ci.org/Detegr/rust-ctrlc)
-
-A simple easy to use wrapper around Ctrl-C signal.
+# simple-signale
+A simple easy to use wrapper around unix signals.
 
 ## Example usage
 ```rust
-extern crate ctrlc;
-use ctrlc::CtrlC;
+extern crate simple_signal;
+use simple_signal::{Signals, Signal};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 
 fn main() {
     let running = Arc::new(AtomicBool::new(true));
     let r = running.clone();
-    CtrlC::set_handler(move || {
+    Signals::set_handler(&[Signal::Int, Signal::Term], move |_signals| {
         r.store(false, Ordering::SeqCst);
     });
-	println!("Waiting for Ctrl-C...");
+    println!("Waiting for a signal...");
     while running.load(Ordering::SeqCst) {}
     println!("Got it! Exiting...");
 }

examples/readme_example.rs

@@ -1,15 +1,15 @@
-extern crate ctrlc;
-use ctrlc::CtrlC;
+extern crate simple_signal;
+use simple_signal::{Signals, Signal};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 
 fn main() {
     let running = Arc::new(AtomicBool::new(true));
     let r = running.clone();
-    CtrlC::set_handler(move || {
+    Signals::set_handler(&[Signal::Int, Signal::Term], move |_signals| {
         r.store(false, Ordering::SeqCst);
     });
-    println!("Waiting for Ctrl-C...");
+    println!("Waiting for a signal...");
     while running.load(Ordering::SeqCst) {}
     println!("Got it! Exiting...");
 }

examples/simple.rs

@@ -3,9 +3,9 @@
 // 100% of CPU. This is because cargo seems to kill the process even
 // though you have set up Ctrl-C handler of your own.
 
-extern crate ctrlc;
-use ctrlc::CtrlC;
+extern crate simple_signal;
+use simple_signal::{Signals, Signal};
 fn main() {
-    CtrlC::set_handler(|| println!("Hello world!"));
+    Signals::set_handler(&[Signal::Int, Signal::Term], |signals| println!("Caught: {:?}", signals));
     loop {}
 }

src/lib.rs

@@ -1,4 +1,4 @@
-//! A simple easy to use wrapper around Ctrl-C signal.
+//! A simple easy to use wrapper around unix signals.
 
 #![cfg_attr(feature="nightly", feature(static_condvar))]
 #![cfg_attr(feature="nightly", feature(static_mutex))]
@@ -9,84 +9,131 @@ extern crate lazy_static;
 
 use std::sync::atomic::Ordering;
 
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum Signal {
+    Hup,
+    Int,
+    Quit,
+    Ill,
+    Abrt,
+    Fpe,
+    Kill,
+    Segv,
+    Pipe,
+    Alrm,
+    Term,
+}
+
 #[cfg(feature="nightly")]
 mod features {
-    use std::sync::atomic::{AtomicBool, ATOMIC_BOOL_INIT};
+    use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT};
     use std::sync::{StaticCondvar, CONDVAR_INIT, StaticMutex, MUTEX_INIT};
     pub static CVAR: StaticCondvar = CONDVAR_INIT;
     pub static MUTEX: StaticMutex = MUTEX_INIT;
-    pub static DONE: AtomicBool = ATOMIC_BOOL_INIT;
+    pub static MASK: AtomicUsize = ATOMIC_USIZE_INIT;
 }
 #[cfg(not(feature="nightly"))]
 mod features {
-    use std::sync::atomic::{AtomicBool, ATOMIC_BOOL_INIT};
+    use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT};
     use std::sync::{Condvar, Mutex};
     lazy_static! {
         pub static ref CVAR: Condvar = Condvar::new();
         pub static ref MUTEX: Mutex<bool> = Mutex::new(false);
     }
-    pub static DONE: AtomicBool = ATOMIC_BOOL_INIT;
+    pub static MASK: AtomicUsize = ATOMIC_USIZE_INIT;
 }
 use self::features::*;
 
 #[cfg(unix)]
 mod platform {
     extern crate libc;
-    use self::libc::c_int;
-    use self::libc::types::os::common::posix01::sighandler_t;
-    use self::libc::consts::os::posix88::SIGINT;
-    use self::libc::funcs::posix01::signal::signal;
+    use self::libc::{c_int, signal, sighandler_t};
+    use self::libc::{SIGHUP, SIGINT, SIGQUIT, SIGILL, SIGABRT, SIGFPE, SIGKILL, SIGSEGV, SIGPIPE, SIGALRM, SIGTERM};
     use std::sync::atomic::Ordering;
+    use super::Signal;
 
     #[repr(C)]
-    pub fn handler(_: c_int) {
-        super::features::DONE.store(true, Ordering::Relaxed);
-        super::features::CVAR.notify_all();
-    }
-    #[inline]
-    pub unsafe fn set_os_handler(handler: fn(c_int)) {
-        signal(SIGINT, ::std::mem::transmute::<_, sighandler_t>(handler));
-    }
-}
-#[cfg(windows)]
-mod platform {
-    extern crate winapi;
-    extern crate kernel32;
-    use self::kernel32::SetConsoleCtrlHandler;
-    use self::winapi::{BOOL, DWORD, TRUE};
-    use std::sync::atomic::Ordering;
+    pub fn handler(sig: c_int) {
+        let mask = match sig {
+            SIGHUP => 1,
+            SIGINT => 2,
+            SIGQUIT => 4,
+            SIGILL => 8,
+            SIGABRT => 16,
+            SIGFPE => 32,
+            SIGKILL => 64,
+            SIGSEGV => 128,
+            SIGPIPE => 256,
+            SIGALRM => 512,
+            SIGTERM => 1024,
+            _ => return,
+        };
 
-    pub unsafe extern "system" fn handler(_: DWORD) -> BOOL {
-        super::features::DONE.store(true, Ordering::Relaxed);
+        loop {
+            let prev_mask = super::features::MASK.load(Ordering::Relaxed);
+            let new_mask = prev_mask | mask;
+            if super::features::MASK.compare_and_swap(prev_mask, new_mask, Ordering::Relaxed) == new_mask {
+                break
+            }
+        }
         super::features::CVAR.notify_all();
-        TRUE
     }
     #[inline]
-    pub unsafe fn set_os_handler(handler: unsafe extern "system" fn(DWORD) -> BOOL) {
-        SetConsoleCtrlHandler(Some(handler), TRUE);
+    pub unsafe fn set_os_handler(sig: Signal) {
+        let os_sig = match sig {
+            Signal::Hup => SIGHUP,
+            Signal::Int => SIGINT,
+            Signal::Quit => SIGQUIT,
+            Signal::Ill => SIGILL,
+            Signal::Abrt => SIGABRT,
+            Signal::Fpe => SIGFPE,
+            Signal::Kill => SIGKILL,
+            Signal::Segv => SIGSEGV,
+            Signal::Pipe => SIGPIPE,
+            Signal::Alrm => SIGALRM,
+            Signal::Term => SIGTERM,
+        };
+
+        signal(os_sig, ::std::mem::transmute::<_, sighandler_t>(handler));
     }
 }
+
 use self::platform::*;
 
-pub struct CtrlC;
-impl CtrlC {
-    /// Sets up the signal handler for Ctrl-C
+pub struct Signals;
+impl Signals {
+    /// Sets up some signals handler
     /// # Example
     /// ```
-    /// use ctrlc::CtrlC;
-    /// CtrlC::set_handler(|| println!("Hello world!"));
+    /// use simple_signal::{Signals, Signal};
+    /// Signals::set_handler(&[Signal::Int, Signal::Term], |signals| println!("Caught: {:?}", signals));
     /// ```
-    pub fn set_handler<F: Fn() -> () + 'static + Send>(user_handler: F) -> () {
-        unsafe {
-            set_os_handler(handler);
+    pub fn set_handler<F>(signals: &[Signal], user_handler: F) where F: Fn(&[Signal]) + 'static + Send {
+        for &signal in signals.iter() {
+            unsafe { set_os_handler(signal) }
         }
         ::std::thread::spawn(move || {
+            let mut signals = Vec::new();
             loop {
-                if !DONE.load(Ordering::Relaxed) {
+                let mask = MASK.load(Ordering::Relaxed);
+                if mask == 0 {
                     let _ = CVAR.wait(MUTEX.lock().unwrap());
-                    DONE.store(false, Ordering::Relaxed);
+                    continue
                 }
-                user_handler();
+                signals.clear();
+                if mask & 1 != 0 { signals.push(Signal::Hup) }
+                if mask & 2 != 0 { signals.push(Signal::Int) }
+                if mask & 4 != 0 { signals.push(Signal::Quit) }
+                if mask & 8 != 0 { signals.push(Signal::Ill) }
+                if mask & 16 != 0 { signals.push(Signal::Abrt) }
+                if mask & 32 != 0 { signals.push(Signal::Fpe) }
+                if mask & 64 != 0 { signals.push(Signal::Kill) }
+                if mask & 128 != 0 { signals.push(Signal::Segv) }
+                if mask & 256 != 0 { signals.push(Signal::Pipe) }
+                if mask & 512 != 0 { signals.push(Signal::Alrm) }
+                if mask & 1024 != 0 { signals.push(Signal::Term) }
+                MASK.store(0, Ordering::Relaxed);
+                user_handler(&signals);
             }
         });
     }