Tweaks + fix accept4

Author: carllerche

src/fcntl.rs

@@ -16,6 +16,7 @@ mod ffi {
     mod os {
         use libc::{c_int, c_short, off_t, pid_t};
 
+        #[repr(C)]
         pub struct flock {
             pub l_type: c_short,
             pub l_whence: c_short,
@@ -43,6 +44,7 @@ mod ffi {
     mod os {
         use libc::{c_int, c_short, off_t, pid_t};
 
+        #[repr(C)]
         pub struct flock {
             pub l_start: off_t,
             pub l_len: off_t,

src/lib.rs

@@ -1,5 +1,6 @@
 #![crate_name = "nix"]
 #![feature(globs)]
+#![feature(linkage)]
 #![allow(non_camel_case_types)]
 
 extern crate libc;

src/sched.rs

@@ -34,7 +34,7 @@ pub type CloneCb<'a> = ||:'a -> int;
 mod ffi {
     use libc::{c_void, c_int};
 
-    type CloneCb = extern fn (data: *const super::CloneCb) -> c_int;
+    type CloneCb = extern "C" fn (data: *const super::CloneCb) -> c_int;
 
     extern {
         // create a child process

src/sys/epoll.rs

@@ -1,3 +1,4 @@
+use std::fmt;
 use libc::c_int;
 use fcntl::Fd;
 use errno::{SysResult, SysError, from_ffi};
@@ -32,13 +33,49 @@ bitflags!(
     }
 )
 
+impl fmt::Show for EpollEventKind {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        let variants = [
+            (EPOLLIN,       "EPOLLIN"),
+            (EPOLLPRI,      "EPOLLPRI"),
+            (EPOLLOUT,      "EPOLLOUT"),
+            (EPOLLRDNORM,   "EPOLLRDNORM"),
+            (EPOLLRDBAND,   "EPOLLRDBAND"),
+            (EPOLLWRNORM,   "EPOLLWRNORM"),
+            (EPOLLWRBAND,   "EPOLLWRBAND"),
+            (EPOLLMSG,      "EPOLLMSG"),
+            (EPOLLERR,      "EPOLLERR"),
+            (EPOLLHUP,      "EPOLLHUP"),
+            (EPOLLRDHUP,    "EPOLLRDHUP"),
+            (EPOLLWAKEUP,   "EPOLLWAKEUP"),
+            (EPOLLONESHOT,  "EPOLLONESHOT"),
+            (EPOLLET,       "EPOLLET")];
+
+        let mut first = true;
+
+        for &(val, name) in variants.iter() {
+            if self.contains(val) {
+                if first {
+                    first = false;
+                    try!(write!(fmt, "{}", name));
+                } else {
+                    try!(write!(fmt, "|{}", name));
+                }
+            }
+        }
+
+        Ok(())
+    }
+}
+
 #[repr(C)]
 pub enum EpollOp {
     EpollCtlAdd = 1,
     EpollCtlDel = 2,
     EpollCtlMod = 3
 }
 
+#[repr(C)]
 pub struct EpollEvent {
     pub events: EpollEventKind,
     pub data: u64

src/sys/event.rs

@@ -1,4 +1,4 @@
-use libc::{timespec, time_t, c_int, c_long, c_void};
+use libc::{timespec, time_t, c_int, c_long};
 use errno::{SysResult, SysError};
 use fcntl::Fd;
 
@@ -8,7 +8,7 @@ mod ffi {
     pub use libc::{c_int, c_void, uintptr_t, intptr_t, timespec};
     use super::{EventFilter, EventFlag, FilterFlag};
 
-    // Packed to 32 bytes
+    #[repr(C)]
     pub struct kevent {
         pub ident: uintptr_t,       // 8
         pub filter: EventFilter,    // 2

src/sys/socket.rs

@@ -9,16 +9,10 @@ pub use libc::{in_addr, sockaddr_in, sockaddr_in6, sockaddr_un, sa_family_t};
 pub use self::consts::*;
 
 mod ffi {
-    use libc::{c_int, c_void, sockaddr, socklen_t};
+    use libc::{c_int, c_void, socklen_t};
     pub use libc::{socket, listen, bind, accept, connect, setsockopt};
 
     extern {
-        pub fn accept4(
-            sockfd: c_int,
-            addr: *mut sockaddr,
-            addrlen: *mut socklen_t,
-            flags: c_int) -> c_int;
-
         pub fn getsockopt(
             sockfd: c_int,
             level: c_int,
@@ -169,7 +163,7 @@ mod consts {
 }
 
 pub fn socket(domain: AddressFamily, mut ty: SockType, flags: SockFlag) -> SysResult<Fd> {
-    let feat_atomic = features::atomic_cloexec(); // TODO: detect
+    let feat_atomic = features::atomic_cloexec();
 
     if feat_atomic {
         ty = ty | flags.bits();
@@ -183,8 +177,13 @@ pub fn socket(domain: AddressFamily, mut ty: SockType, flags: SockFlag) -> SysRe
     }
 
     if !feat_atomic {
-        try!(fcntl(res, F_SETFD(FD_CLOEXEC)));
-        try!(fcntl(res, F_SETFL(O_NONBLOCK)));
+        if flags.contains(SOCK_CLOEXEC) {
+            try!(fcntl(res, F_SETFD(FD_CLOEXEC)));
+        }
+
+        if flags.contains(SOCK_NONBLOCK) {
+            try!(fcntl(res, F_SETFL(O_NONBLOCK)));
+        }
     }
 
     Ok(res)
@@ -217,17 +216,66 @@ pub fn accept(sockfd: Fd) -> SysResult<Fd> {
     Ok(res)
 }
 
+#[cfg(target_os = "linux")]
 pub fn accept4(sockfd: Fd, flags: SockFlag) -> SysResult<Fd> {
-    // TODO: Check the kernel version
-    let res = unsafe { ffi::accept4(sockfd, ptr::mut_null(), ptr::mut_null(), flags.bits) };
+    use libc::sockaddr;
+
+    type F = unsafe extern "C" fn(c_int, *mut sockaddr, *mut socklen_t, c_int) -> c_int;
+
+    extern {
+        #[linkage = "extern_weak"]
+        static accept4: *const ();
+    }
+
+    let feat_atomic = !accept4.is_null();
+
+    let res = if feat_atomic {
+        unsafe {
+            mem::transmute::<*const (), F>(accept4)(
+                sockfd, ptr::mut_null(), ptr::mut_null(), flags.bits)
+        }
+    } else {
+        unsafe { ffi::accept(sockfd, ptr::mut_null(), ptr::mut_null()) }
+    };
+
+    if res < 0 {
+        return Err(SysError::last());
+    }
+
+    if !feat_atomic {
+        if flags.contains(SOCK_CLOEXEC) {
+            try!(fcntl(res, F_SETFD(FD_CLOEXEC)));
+        }
+
+        if flags.contains(SOCK_NONBLOCK) {
+            try!(fcntl(res, F_SETFL(O_NONBLOCK)));
+        }
+    }
+
+    Ok(res)
+}
+
+#[cfg(target_os = "macos")]
+#[cfg(target_os = "ios")]
+pub fn accept4(sockfd: Fd, flags: SockFlag) -> SysResult<Fd> {
+    let res = unsafe { ffi::accept(sockfd, ptr::mut_null(), ptr::mut_null()) };
 
     if res < 0 {
         return Err(SysError::last());
     }
 
+    if flags.contains(SOCK_CLOEXEC) {
+        try!(fcntl(res, F_SETFD(FD_CLOEXEC)));
+    }
+
+    if flags.contains(SOCK_NONBLOCK) {
+        try!(fcntl(res, F_SETFL(O_NONBLOCK)));
+    }
+
     Ok(res)
 }
 
+
 pub fn connect(sockfd: Fd, addr: &SockAddr) -> SysResult<()> {
     let res = unsafe {
         match *addr {

src/sys/utsname.rs

@@ -15,6 +15,7 @@ mod ffi {
 #[cfg(target_arch = "x86_64")]
 static UTSNAME_LEN: uint = 65;
 
+#[repr(C)]
 pub struct UtsName {
     sysname: [c_char, ..UTSNAME_LEN],
     nodename: [c_char, ..UTSNAME_LEN],