Add `NixPath`, `NixError`, and `NixResult`.

1 files changed, 27 insertions, 26 deletions

diff --git a/src/sys/socket.rs b/src/sys/socket.rs
index b26f909c..b462570d 100644
--- a/src/sys/socket.rs
+++ b/src/sys/socket.rs
@@ -1,9 +1,10 @@
 use std::{mem, ptr, fmt};
 use libc::{c_void, c_int, socklen_t, size_t, ssize_t};
+use errno::Errno;
 use fcntl::{Fd, fcntl, FD_CLOEXEC, O_NONBLOCK};
 use fcntl::FcntlArg::{F_SETFD, F_SETFL};
-use errno::{SysResult, SysError, from_ffi};
 use features;
+use {NixError, NixResult, from_ffi};
 
 pub use libc::{in_addr, sockaddr, sockaddr_storage, sockaddr_in, sockaddr_in6, sockaddr_un, sa_family_t, ip_mreq};
 
@@ -225,7 +226,7 @@ mod consts {
     pub const MSG_DONTWAIT: SockMessageFlags = 0x80;
 }
 
-pub fn socket(domain: AddressFamily, mut ty: SockType, flags: SockFlag) -> SysResult<Fd> {
+pub fn socket(domain: AddressFamily, mut ty: SockType, flags: SockFlag) -> NixResult<Fd> {
     let feat_atomic = features::socket_atomic_cloexec();
 
     if feat_atomic {
@@ -236,7 +237,7 @@ pub fn socket(domain: AddressFamily, mut ty: SockType, flags: SockFlag) -> SysRe
     let res = unsafe { ffi::socket(domain, ty, 0) };
 
     if res < 0 {
-        return Err(SysError::last());
+        return Err(NixError::Sys(Errno::last()));
     }
 
     if !feat_atomic {
@@ -252,12 +253,12 @@ pub fn socket(domain: AddressFamily, mut ty: SockType, flags: SockFlag) -> SysRe
     Ok(res)
 }
 
-pub fn listen(sockfd: Fd, backlog: usize) -> SysResult<()> {
+pub fn listen(sockfd: Fd, backlog: usize) -> NixResult<()> {
     let res = unsafe { ffi::listen(sockfd, backlog as c_int) };
     from_ffi(res)
 }
 
-pub fn bind(sockfd: Fd, addr: &SockAddr) -> SysResult<()> {
+pub fn bind(sockfd: Fd, addr: &SockAddr) -> NixResult<()> {
     use self::SockAddr::*;
 
     let res = unsafe {
@@ -271,18 +272,18 @@ pub fn bind(sockfd: Fd, addr: &SockAddr) -> SysResult<()> {
     from_ffi(res)
 }
 
-pub fn accept(sockfd: Fd) -> SysResult<Fd> {
+pub fn accept(sockfd: Fd) -> NixResult<Fd> {
     let res = unsafe { ffi::accept(sockfd, ptr::null_mut(), ptr::null_mut()) };
 
     if res < 0 {
-        return Err(SysError::last());
+        return Err(NixError::Sys(Errno::last()));
     }
 
     Ok(res)
 }
 
 #[cfg(not(any(target_os = "macos", target_os = "ios")))]
-pub fn accept4(sockfd: Fd, flags: SockFlag) -> SysResult<Fd> {
+pub fn accept4(sockfd: Fd, flags: SockFlag) -> NixResult<Fd> {
     use libc::sockaddr;
 
     type F = unsafe extern "C" fn(c_int, *mut sockaddr, *mut socklen_t, c_int) -> c_int;
@@ -299,7 +300,7 @@ pub fn accept4(sockfd: Fd, flags: SockFlag) -> SysResult<Fd> {
         };
 
         if res < 0 {
-            return Err(SysError::last());
+            return Err(NixError::Sys(Errno::last()));
         }
 
         Ok(res)
@@ -309,16 +310,16 @@ pub fn accept4(sockfd: Fd, flags: SockFlag) -> SysResult<Fd> {
 }
 
 #[cfg(any(target_os = "macos", target_os = "ios"))]
-pub fn accept4(sockfd: Fd, flags: SockFlag) -> SysResult<Fd> {
+pub fn accept4(sockfd: Fd, flags: SockFlag) -> NixResult<Fd> {
     accept4_polyfill(sockfd, flags)
 }
 
 #[inline]
-fn accept4_polyfill(sockfd: Fd, flags: SockFlag) -> SysResult<Fd> {
+fn accept4_polyfill(sockfd: Fd, flags: SockFlag) -> NixResult<Fd> {
     let res =  unsafe { ffi::accept(sockfd, ptr::null_mut(), ptr::null_mut()) };
 
     if res < 0 {
-        return Err(SysError::last());
+        return Err(NixError::Sys(Errno::last()));
     }
 
     if flags.contains(SOCK_CLOEXEC) {
@@ -332,7 +333,7 @@ fn accept4_polyfill(sockfd: Fd, flags: SockFlag) -> SysResult<Fd> {
     Ok(res)
 }
 
-pub fn connect(sockfd: Fd, addr: &SockAddr) -> SysResult<()> {
+pub fn connect(sockfd: Fd, addr: &SockAddr) -> NixResult<()> {
     use self::SockAddr::*;
 
     let res = unsafe {
@@ -368,7 +369,7 @@ mod sa_helpers {
     }
 }
 
-pub fn recvfrom(sockfd: Fd, buf: &mut [u8]) -> SysResult<(usize, SockAddr)> {
+pub fn recvfrom(sockfd: Fd, buf: &mut [u8]) -> NixResult<(usize, SockAddr)> {
     let saddr : sockaddr_storage = unsafe { mem::zeroed() };
     let mut len = mem::size_of::<sockaddr_storage>() as socklen_t;
 
@@ -377,7 +378,7 @@ pub fn recvfrom(sockfd: Fd, buf: &mut [u8]) -> SysResult<(usize, SockAddr)> {
     };
 
     if ret < 0 {
-        return Err(SysError::last());
+        return Err(NixError::Sys(Errno::last()));
     }
 
     Ok((ret as usize,
@@ -427,7 +428,7 @@ fn sendto_sockaddr<T>(sockfd: Fd, buf: &[u8], flags: SockMessageFlags, addr: &T)
     }
 }
 
-pub fn sendto(sockfd: Fd, buf: &[u8], addr: &SockAddr, flags: SockMessageFlags) -> SysResult<usize> {
+pub fn sendto(sockfd: Fd, buf: &[u8], addr: &SockAddr, flags: SockMessageFlags) -> NixResult<usize> {
     use self::SockAddr::*;
 
     let ret = match *addr {
@@ -437,7 +438,7 @@ pub fn sendto(sockfd: Fd, buf: &[u8], addr: &SockAddr, flags: SockMessageFlags)
     };
 
     if ret < 0 {
-        Err(SysError::last())
+        Err(NixError::Sys(Errno::last()))
     } else {
         Ok(ret as usize)
     }
@@ -450,7 +451,7 @@ pub struct linger {
     pub l_linger: c_int
 }
 
-pub fn getsockopt<T>(fd: Fd, level: SockLevel, opt: SockOpt, val: &mut T) -> SysResult<usize> {
+pub fn getsockopt<T>(fd: Fd, level: SockLevel, opt: SockOpt, val: &mut T) -> NixResult<usize> {
     let mut len = mem::size_of::<T>() as socklen_t;
 
     let res = unsafe {
@@ -461,13 +462,13 @@ pub fn getsockopt<T>(fd: Fd, level: SockLevel, opt: SockOpt, val: &mut T) -> Sys
     };
 
     if res < 0 {
-        return Err(SysError::last());
+        return Err(NixError::Sys(Errno::last()));
     }
 
     Ok(len as usize)
 }
 
-pub fn setsockopt<T>(fd: Fd, level: SockLevel, opt: SockOpt, val: &T) -> SysResult<()> {
+pub fn setsockopt<T>(fd: Fd, level: SockLevel, opt: SockOpt, val: &T) -> NixResult<()> {
     let len = mem::size_of::<T>() as socklen_t;
 
     let res = unsafe {
@@ -480,19 +481,19 @@ pub fn setsockopt<T>(fd: Fd, level: SockLevel, opt: SockOpt, val: &T) -> SysResu
     from_ffi(res)
 }
 
-fn getpeername_sockaddr<T>(sockfd: Fd, addr: &T) -> SysResult<bool> {
+fn getpeername_sockaddr<T>(sockfd: Fd, addr: &T) -> NixResult<bool> {
     let addrlen_expected = mem::size_of::<T>() as socklen_t;
     let mut addrlen = addrlen_expected;
 
     let ret = unsafe { ffi::getpeername(sockfd, mem::transmute(addr), &mut addrlen) };
     if ret < 0 {
-        return Err(SysError::last());
+        return Err(NixError::Sys(Errno::last()));
     }
 
     Ok(addrlen == addrlen_expected)
 }
 
-pub fn getpeername(sockfd: Fd, addr: &mut SockAddr) -> SysResult<bool> {
+pub fn getpeername(sockfd: Fd, addr: &mut SockAddr) -> NixResult<bool> {
     use self::SockAddr::*;
 
     match *addr {
@@ -502,19 +503,19 @@ pub fn getpeername(sockfd: Fd, addr: &mut SockAddr) -> SysResult<bool> {
     }
 }
 
-fn getsockname_sockaddr<T>(sockfd: Fd, addr: &T) -> SysResult<bool> {
+fn getsockname_sockaddr<T>(sockfd: Fd, addr: &T) -> NixResult<bool> {
     let addrlen_expected = mem::size_of::<T>() as socklen_t;
     let mut addrlen = addrlen_expected;
 
     let ret = unsafe { ffi::getsockname(sockfd, mem::transmute(addr), &mut addrlen) };
     if ret < 0 {
-        return Err(SysError::last());
+        return Err(NixError::Sys(Errno::last()));
     }
 
     Ok(addrlen == addrlen_expected)
 }
 
-pub fn getsockname(sockfd: Fd, addr: &mut SockAddr) -> SysResult<bool> {
+pub fn getsockname(sockfd: Fd, addr: &mut SockAddr) -> NixResult<bool> {
     use self::SockAddr::*;
 
     match *addr {