Use libc definitions for wait module

Author: Susurrus

src/sys/wait.rs

@@ -4,42 +4,26 @@ use unistd::Pid;
 
 use sys::signal::Signal;
 
-mod ffi {
-    use libc::{pid_t, c_int};
-
-    extern {
-        pub fn waitpid(pid: pid_t, status: *mut c_int, options: c_int) -> pid_t;
-    }
-}
-
-#[cfg(not(any(target_os = "linux",
-              target_os = "android")))]
-libc_bitflags!(
-    pub flags WaitPidFlag: c_int {
-        WNOHANG,
-        WUNTRACED,
-    }
-);
-
-#[cfg(any(target_os = "linux",
-          target_os = "android"))]
 libc_bitflags!(
     pub flags WaitPidFlag: c_int {
         WNOHANG,
         WUNTRACED,
         WEXITED,
         WCONTINUED,
-        WNOWAIT, // Don't reap, just poll status.
-        __WNOTHREAD, // Don't wait on children of other threads in this group
-        __WALL, // Wait on all children, regardless of type
+        WSTOPPED,
+        /// Don't reap, just poll status.
+        WNOWAIT,
+        /// Don't wait on children of other threads in this group
+        #[cfg(any(target_os = "android", target_os = "linux"))]
+        __WNOTHREAD,
+        /// Wait on all children, regardless of type
+        #[cfg(any(target_os = "android", target_os = "linux"))]
+        __WALL,
+        #[cfg(any(target_os = "android", target_os = "linux"))]
         __WCLONE,
     }
 );
 
-#[cfg(any(target_os = "linux",
-          target_os = "android"))]
-const WSTOPPED: WaitPidFlag = WUNTRACED;
-
 /// Possible return values from `wait()` or `waitpid()`.
 ///
 /// Each status (other than `StillAlive`) describes a state transition
@@ -54,7 +38,7 @@ pub enum WaitStatus {
     /// The process exited normally (as with `exit()` or returning from
     /// `main`) with the given exit code. This case matches the C macro
     /// `WIFEXITED(status)`; the second field is `WEXITSTATUS(status)`.
-    Exited(Pid, i8),
+    Exited(Pid, i32),
     /// The process was killed by the given signal. The third field
     /// indicates whether the signal generated a core dump. This case
     /// matches the C macro `WIFSIGNALED(status)`; the last two fields
@@ -112,149 +96,52 @@ impl WaitStatus {
     }
 }
 
-#[cfg(any(target_os = "linux",
-          target_os = "android"))]
 mod status {
     use sys::signal::Signal;
-    use libc::c_int;
-    use libc::SIGTRAP;
+    use libc::{self, c_int, SIGTRAP};
 
     pub fn exited(status: i32) -> bool {
-        (status & 0x7F) == 0
+        unsafe { libc::WIFEXITED(status) }
     }
 
-    pub fn exit_status(status: i32) -> i8 {
-        ((status & 0xFF00) >> 8) as i8
+    pub fn exit_status(status: i32) -> i32 {
+        unsafe { libc::WEXITSTATUS(status) }
     }
 
     pub fn signaled(status: i32) -> bool {
-        ((((status & 0x7f) + 1) as i8) >> 1) > 0
+        unsafe { libc::WIFSIGNALED(status) }
     }
 
     pub fn term_signal(status: i32) -> Signal {
-        Signal::from_c_int(status & 0x7f).unwrap()
+        Signal::from_c_int(unsafe { libc::WTERMSIG(status) }).unwrap()
     }
 
     pub fn dumped_core(status: i32) -> bool {
-        (status & 0x80) != 0
+        unsafe { libc::WCOREDUMP(status) }
     }
 
     pub fn stopped(status: i32) -> bool {
-        (status & 0xff) == 0x7f
+        unsafe { libc::WIFSTOPPED(status) }
     }
 
     pub fn stop_signal(status: i32) -> Signal {
-        // Keep only 7 bits of the signal: the high bit
-        // is used to indicate syscall stops, below.
-        Signal::from_c_int((status & 0x7F00) >> 8).unwrap()
+        Signal::from_c_int(unsafe { libc::WSTOPSIG(status) }).unwrap()
     }
 
     pub fn syscall_stop(status: i32) -> bool {
         // From ptrace(2), setting PTRACE_O_TRACESYSGOOD has the effect
         // of delivering SIGTRAP | 0x80 as the signal number for syscall
         // stops. This allows easily distinguishing syscall stops from
         // genuine SIGTRAP signals.
-        ((status & 0xFF00) >> 8) == SIGTRAP | 0x80
+        unsafe { libc::WSTOPSIG(status) == SIGTRAP | 0x80 }
     }
 
     pub fn stop_additional(status: i32) -> c_int {
         (status >> 16) as c_int
     }
 
     pub fn continued(status: i32) -> bool {
-        status == 0xFFFF
-    }
-}
-
-#[cfg(any(target_os = "macos",
-          target_os = "ios"))]
-mod status {
-    use sys::signal::{Signal,SIGCONT};
-
-    const WCOREFLAG: i32 = 0x80;
-    const WSTOPPED: i32 = 0x7f;
-
-    fn wstatus(status: i32) -> i32 {
-        status & 0x7F
-    }
-
-    pub fn exit_status(status: i32) -> i8 {
-        ((status >> 8) & 0xFF) as i8
-    }
-
-    pub fn stop_signal(status: i32) -> Signal {
-        Signal::from_c_int(status >> 8).unwrap()
-    }
-
-    pub fn continued(status: i32) -> bool {
-        wstatus(status) == WSTOPPED && stop_signal(status) == SIGCONT
-    }
-
-    pub fn stopped(status: i32) -> bool {
-        wstatus(status) == WSTOPPED && stop_signal(status) != SIGCONT
-    }
-
-    pub fn exited(status: i32) -> bool {
-        wstatus(status) == 0
-    }
-
-    pub fn signaled(status: i32) -> bool {
-        wstatus(status) != WSTOPPED && wstatus(status) != 0
-    }
-
-    pub fn term_signal(status: i32) -> Signal {
-        Signal::from_c_int(wstatus(status)).unwrap()
-    }
-
-    pub fn dumped_core(status: i32) -> bool {
-        (status & WCOREFLAG) != 0
-    }
-}
-
-#[cfg(any(target_os = "freebsd",
-          target_os = "openbsd",
-          target_os = "dragonfly",
-          target_os = "netbsd"))]
-mod status {
-    use sys::signal::Signal;
-
-    const WCOREFLAG: i32 = 0x80;
-    const WSTOPPED: i32 = 0x7f;
-
-    fn wstatus(status: i32) -> i32 {
-        status & 0x7F
-    }
-
-    pub fn stopped(status: i32) -> bool {
-        wstatus(status) == WSTOPPED
-    }
-
-    pub fn stop_signal(status: i32) -> Signal {
-        Signal::from_c_int(status >> 8).unwrap()
-    }
-
-    pub fn signaled(status: i32) -> bool {
-        wstatus(status) != WSTOPPED && wstatus(status) != 0 && status != 0x13
-    }
-
-    pub fn term_signal(status: i32) -> Signal {
-        Signal::from_c_int(wstatus(status)).unwrap()
-    }
-
-    pub fn exited(status: i32) -> bool {
-        wstatus(status) == 0
-    }
-
-    pub fn exit_status(status: i32) -> i8 {
-        (status >> 8) as i8
-    }
-
-    pub fn continued(status: i32) -> bool {
-        status == 0x13
-    }
-
-    pub fn dumped_core(status: i32) -> bool {
-        (status & WCOREFLAG) != 0
+        unsafe { libc::WIFCONTINUED(status) }
     }
 }
 
@@ -299,7 +186,7 @@ pub fn waitpid<P: Into<Option<Pid>>>(pid: P, options: Option<WaitPidFlag>) -> Re
         None => 0
     };
 
-    let res = unsafe { ffi::waitpid(pid.into().unwrap_or(Pid::from_raw(-1)).into(), &mut status as *mut c_int, option_bits) };
+    let res = unsafe { libc::waitpid(pid.into().unwrap_or(Pid::from_raw(-1)).into(), &mut status as *mut c_int, option_bits) };
 
     Ok(match try!(Errno::result(res)) {
         0 => StillAlive,