Use pthread_sigmask from "nix" crate (since 0.4.1)

Author: tailhook

Cargo.toml

@@ -11,6 +11,6 @@ repository = "http://github.com/tailhook/signal"
 documentation = "http://tailhook.github.io/signal/"
 
 [dependencies]
-nix = "0.4.0"
+nix = "0.4.1"
 libc = "0.1.10"
 time = "0.1.32"

src/exec_handler.rs

@@ -9,15 +9,16 @@
 
 use std::io::Write;
 use std::mem::{forget, transmute};
-use std::ptr::{null, null_mut};
+use std::ptr::{null};
 use std::ffi::CString;
 use std::env::{current_exe, args_os, vars_os};
 
 use nix;
 use libc::{execve, c_char};
 use nix::sys::signal::{sigaction, SigAction, SigNum, SigSet, SockFlag};
+use nix::sys::signal::{pthread_sigmask, SIG_UNBLOCK};
 
-use ffi::{ToCString, pthread_sigmask, SIG_UNBLOCK};
+use ffi::{ToCString};
 
 
 static mut exec_command_line: *const ExecCommandLine =
@@ -125,7 +126,7 @@ pub fn set_handler(signals: &[SigNum], avoid_race_condition: bool)
         }
         // TODO(tailhook) is this error reporting is ok? or maybe just panic?
         if avoid_race_condition && res.is_ok() {
-            pthread_sigmask(SIG_UNBLOCK, &sigset, null_mut());
+            pthread_sigmask(SIG_UNBLOCK, Some(&sigset), None).unwrap();
         }
         res
     }

src/ffi.rs

@@ -1,7 +1,7 @@
 use std::ffi::{CString, OsStr};
 use std::os::unix::ffi::OsStrExt;
 
-use nix::sys::signal::{SigSet, SigNum};
+use nix::sys::signal::{sigset_t, SigNum};
 use libc::{c_int, c_void, timespec};
 
 
@@ -22,14 +22,8 @@ impl<T:AsRef<OsStr>> ToCString for T {
 
 
 // All the following should be moved to nix-rust
-
-pub const SIG_BLOCK: c_int = 0;
-pub const SIG_UNBLOCK: c_int = 1;
-pub const SIG_SETMASK: c_int = 2;
 extern {
-    pub fn pthread_sigmask(how: c_int, set: *const SigSet,
-                           oldset: *mut SigSet) -> c_int;
-    pub fn sigwait(set: *const SigSet, sig: *mut SigNum) -> c_int;
-    pub fn sigtimedwait(set: *const SigSet, info: *mut c_void,
+    pub fn sigwait(set: *const sigset_t, sig: *mut SigNum) -> c_int;
+    pub fn sigtimedwait(set: *const sigset_t, info: *mut c_void,
         timeout: *const timespec) -> c_int;
 }

src/trap.rs

@@ -15,10 +15,11 @@ use std::ptr::null_mut;
 
 use time::{SteadyTime, Duration};
 use nix::sys::signal::{sigaction, SigAction, SigNum, SigSet, SockFlag};
+use nix::sys::signal::{pthread_sigmask, SIG_BLOCK, SIG_SETMASK};
 use nix::errno::{Errno, errno};
 use libc::timespec;
 
-use ffi::{pthread_sigmask, sigwait, sigtimedwait, SIG_BLOCK, SIG_SETMASK};
+use ffi::{sigwait, sigtimedwait};
 
 /// A RAII guard for masking out signals and waiting for them synchronously
 pub struct Trap {
@@ -40,7 +41,8 @@ impl Trap {
             }
             let mut oldset = uninitialized();
             let mut oldsigs = Vec::new();
-            pthread_sigmask(SIG_BLOCK, &sigset, &mut oldset);
+            pthread_sigmask(SIG_BLOCK, Some(&sigset), Some(&mut oldset))
+                .unwrap();
             for &sig in signals {
                 oldsigs.push((sig, sigaction(sig,
                     &SigAction::new(empty_handler, SockFlag::empty(), sigset))
@@ -67,7 +69,8 @@ impl Trap {
                 tv_nsec: (timeout - Duration::seconds(timeout.num_seconds()))
                          .num_nanoseconds().unwrap(),
             };
-            let sig = unsafe { sigtimedwait(&self.sigset, null_mut(), &tm) };
+            let sig = unsafe { sigtimedwait(self.sigset.as_ref(),
+                                            null_mut(), &tm) };
             if sig > 0 {
                 return Some(sig);
             } else {
@@ -92,7 +95,7 @@ impl Iterator for Trap {
     fn next(&mut self) -> Option<SigNum> {
         let mut sig: SigNum = 0;
         loop {
-            if unsafe { sigwait(&self.sigset, &mut sig) } == 0 {
+            if unsafe { sigwait(self.sigset.as_ref(), &mut sig) } == 0 {
                 return Some(sig);
             } else {
                 if Errno::last() == Errno::EINTR {
@@ -110,7 +113,8 @@ impl Drop for Trap {
             for &(sig, ref sigact) in self.oldsigs.iter() {
                 sigaction(sig, sigact).unwrap();
             }
-            pthread_sigmask(SIG_SETMASK, &self.oldset, null_mut());
+            pthread_sigmask(SIG_SETMASK, Some(&self.oldset), None)
+                .unwrap();
         }
     }
 }