Auto merge of nix-rust#486 - hicqu:master, r=fiveop

fix nix-rust#480 and add simple test cases for that.

r? @fiveop

Author: homu

CHANGELOG.md

@@ -30,6 +30,9 @@ This project adheres to [Semantic Versioning](http://semver.org/).
   ([#491](https://github.com/nix-rust/nix/pull/491))
 
 ### Changed
+- `epoll_ctl` now could accept None as argument `event`
+  when op is `EpollOp::EpollCtlDel`.
+  ([#480](https://github.com/nix-rust/nix/pull/480))
 - Removed the `bad` keyword from the `ioctl!` macro
   ([#478](https://github.com/nix-rust/nix/pull/478))
 - Changed `TimeVal` into an opaque Newtype

src/sys/epoll.rs

@@ -1,6 +1,9 @@
 use {Errno, Result};
 use libc::{self, c_int};
 use std::os::unix::io::RawFd;
+use std::ptr;
+use std::mem;
+use ::Error;
 
 bitflags!(
     #[repr(C)]
@@ -23,7 +26,7 @@ bitflags!(
     }
 );
 
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Eq, PartialEq)]
 #[repr(C)]
 pub enum EpollOp {
     EpollCtlAdd = 1,
@@ -44,10 +47,14 @@ pub struct EpollEvent {
 }
 
 impl EpollEvent {
-    pub fn new(events: EpollFlags, data: u64) -> EpollEvent {
+    pub fn new(events: EpollFlags, data: u64) -> Self {
         EpollEvent { event: libc::epoll_event { events: events.bits(), u64: data } }
     }
 
+    pub fn empty() -> Self {
+        unsafe { mem::zeroed::<EpollEvent>() }
+    }
+
     pub fn events(&self) -> EpollFlags {
         EpollFlags::from_bits(self.event.events).unwrap()
     }
@@ -57,6 +64,16 @@ impl EpollEvent {
     }
 }
 
+impl<'a> Into<&'a mut EpollEvent> for Option<&'a mut EpollEvent> {
+    #[inline]
+    fn into(self) -> &'a mut EpollEvent {
+        match self {
+            Some(epoll_event) => epoll_event,
+            None => unsafe { &mut *ptr::null_mut::<EpollEvent>() }
+        }
+    }
+}
+
 #[inline]
 pub fn epoll_create() -> Result<RawFd> {
     let res = unsafe { libc::epoll_create(1024) };
@@ -72,10 +89,16 @@ pub fn epoll_create1(flags: EpollCreateFlags) -> Result<RawFd> {
 }
 
 #[inline]
-pub fn epoll_ctl(epfd: RawFd, op: EpollOp, fd: RawFd, event: &mut EpollEvent) -> Result<()> {
-    let res = unsafe { libc::epoll_ctl(epfd, op as c_int, fd, &mut event.event) };
-
-    Errno::result(res).map(drop)
+pub fn epoll_ctl<'a, T>(epfd: RawFd, op: EpollOp, fd: RawFd, event: T) -> Result<()>
+    where T: Into<&'a mut EpollEvent>
+{
+    let event: &mut EpollEvent = event.into();
+    if event as *const EpollEvent == ptr::null() && op != EpollOp::EpollCtlDel {
+        Err(Error::Sys(Errno::EINVAL))
+    } else {
+        let res = unsafe { libc::epoll_ctl(epfd, op as c_int, fd, &mut event.event) };
+        Errno::result(res).map(drop)
+    }
 }
 
 #[inline]

test/sys/mod.rs

@@ -6,3 +6,6 @@ mod test_ioctl;
 mod test_wait;
 mod test_select;
 mod test_uio;
+
+#[cfg(target_os = "linux")]
+mod test_epoll;

test/sys/test_epoll.rs

@@ -0,0 +1,24 @@
+use nix::sys::epoll::{EpollCreateFlags, EpollOp, EpollEvent};
+use nix::sys::epoll::{EPOLLIN, EPOLLERR};
+use nix::sys::epoll::{epoll_create1, epoll_ctl};
+use nix::{Error, Errno};
+
+#[test]
+pub fn test_epoll_errno() {
+    let efd = epoll_create1(EpollCreateFlags::empty()).unwrap();
+    let result = epoll_ctl(efd, EpollOp::EpollCtlDel, 1, None);
+    assert!(result.is_err());
+    assert_eq!(result.unwrap_err(), Error::Sys(Errno::ENOENT));
+
+    let result = epoll_ctl(efd, EpollOp::EpollCtlAdd, 1, None);
+    assert!(result.is_err());
+    assert_eq!(result.unwrap_err(), Error::Sys(Errno::EINVAL));
+}
+
+#[test]
+pub fn test_epoll_ctl() {
+    let efd = epoll_create1(EpollCreateFlags::empty()).unwrap();
+    let mut event = EpollEvent::new(EPOLLIN | EPOLLERR, 1);
+    epoll_ctl(efd, EpollOp::EpollCtlAdd, 1, &mut event).unwrap();
+    epoll_ctl(efd, EpollOp::EpollCtlDel, 1, None).unwrap();
+}