From effb423fdb26843612edca6a748e479522089c1d Mon Sep 17 00:00:00 2001
From: Utkarsh Kukreti <utkarshkukreti@gmail.com>
Date: Tue, 10 Feb 2015 12:10:57 +0530
Subject: Add `NixPath`, `NixError`, and `NixResult`.

---
 src/sys/epoll.rs   | 13 +++++++------
 src/sys/event.rs   | 11 ++++++-----
 src/sys/eventfd.rs |  7 ++++---
 src/sys/ioctl.rs   |  4 ++--
 src/sys/mman.rs    | 46 ++++++++++++++++++++++++++--------------------
 src/sys/signal.rs  | 19 ++++++++++---------
 src/sys/socket.rs  | 53 +++++++++++++++++++++++++++--------------------------
 src/sys/stat.rs    | 27 +++++++++++++++++----------
 src/sys/termios.rs | 21 +++++++++++----------
 src/sys/wait.rs    |  7 ++++---
 10 files changed, 114 insertions(+), 94 deletions(-)

(limited to 'src/sys')

diff --git a/src/sys/epoll.rs b/src/sys/epoll.rs
index 31a46836..b9b31c9a 100644
--- a/src/sys/epoll.rs
+++ b/src/sys/epoll.rs
@@ -1,7 +1,8 @@
 use std::fmt;
 use libc::c_int;
+use errno::Errno;
+use {NixError, NixResult, from_ffi};
 use fcntl::Fd;
-use errno::{SysResult, SysError, from_ffi};
 
 mod ffi {
     use libc::{c_int};
@@ -85,30 +86,30 @@ pub struct EpollEvent {
 }
 
 #[inline]
-pub fn epoll_create() -> SysResult<Fd> {
+pub fn epoll_create() -> NixResult<Fd> {
     let res = unsafe { ffi::epoll_create(1024) };
 
     if res < 0 {
-        return Err(SysError::last());
+        return Err(NixError::Sys(Errno::last()));
     }
 
     Ok(res)
 }
 
 #[inline]
-pub fn epoll_ctl(epfd: Fd, op: EpollOp, fd: Fd, event: &EpollEvent) -> SysResult<()> {
+pub fn epoll_ctl(epfd: Fd, op: EpollOp, fd: Fd, event: &EpollEvent) -> NixResult<()> {
     let res = unsafe { ffi::epoll_ctl(epfd, op as c_int, fd, event as *const EpollEvent) };
     from_ffi(res)
 }
 
 #[inline]
-pub fn epoll_wait(epfd: Fd, events: &mut [EpollEvent], timeout_ms: usize) -> SysResult<usize> {
+pub fn epoll_wait(epfd: Fd, events: &mut [EpollEvent], timeout_ms: usize) -> NixResult<usize> {
     let res = unsafe {
         ffi::epoll_wait(epfd, events.as_mut_ptr(), events.len() as c_int, timeout_ms as c_int)
     };
 
     if res < 0 {
-        return Err(SysError::last());
+        return Err(NixError::Sys(Errno::last()));
     }
 
     Ok(res as usize)
diff --git a/src/sys/event.rs b/src/sys/event.rs
index fa85d84e..efe54b19 100644
--- a/src/sys/event.rs
+++ b/src/sys/event.rs
@@ -2,9 +2,10 @@
  */
 
 use libc::{timespec, time_t, c_int, c_long, uintptr_t};
-use errno::{SysResult, SysError};
+use errno::Errno;
 use fcntl::Fd;
 use std::fmt;
+use {NixError, NixResult};
 
 pub use self::ffi::kevent as KEvent;
 
@@ -158,11 +159,11 @@ bitflags!(
 pub const EV_POLL: EventFlag = EV_FLAG0;
 pub const EV_OOBAND: EventFlag = EV_FLAG1;
 
-pub fn kqueue() -> SysResult<Fd> {
+pub fn kqueue() -> NixResult<Fd> {
     let res = unsafe { ffi::kqueue() };
 
     if res < 0 {
-        return Err(SysError::last());
+        return Err(NixError::Sys(Errno::last()));
     }
 
     Ok(res)
@@ -171,7 +172,7 @@ pub fn kqueue() -> SysResult<Fd> {
 pub fn kevent(kq: Fd,
               changelist: &[KEvent],
               eventlist: &mut [KEvent],
-              timeout_ms: usize) -> SysResult<usize> {
+              timeout_ms: usize) -> NixResult<usize> {
 
     // Convert ms to timespec
     let timeout = timespec {
@@ -190,7 +191,7 @@ pub fn kevent(kq: Fd,
     };
 
     if res < 0 {
-        return Err(SysError::last());
+        return Err(NixError::Sys(Errno::last()));
     }
 
     return Ok(res as usize)
diff --git a/src/sys/eventfd.rs b/src/sys/eventfd.rs
index fa6389a4..07162f85 100644
--- a/src/sys/eventfd.rs
+++ b/src/sys/eventfd.rs
@@ -1,7 +1,8 @@
 use std::mem;
 use libc::{c_int, c_uint};
+use errno::Errno;
 use fcntl::Fd;
-use errno::{SysResult, SysError};
+use {NixError, NixResult};
 
 bitflags!(
     flags EventFdFlag: c_int {
@@ -11,7 +12,7 @@ bitflags!(
     }
 );
 
-pub fn eventfd(initval: usize, flags: EventFdFlag) -> SysResult<Fd> {
+pub fn eventfd(initval: usize, flags: EventFdFlag) -> NixResult<Fd> {
     type F = unsafe extern "C" fn(initval: c_uint, flags: c_int) -> c_int;
 
     extern {
@@ -29,7 +30,7 @@ pub fn eventfd(initval: usize, flags: EventFdFlag) -> SysResult<Fd> {
     };
 
     if res < 0 {
-        return Err(SysError::last());
+        return Err(NixError::Sys(Errno::last()));
     }
 
     Ok(res)
diff --git a/src/sys/ioctl.rs b/src/sys/ioctl.rs
index 4b2370c1..847733f2 100644
--- a/src/sys/ioctl.rs
+++ b/src/sys/ioctl.rs
@@ -1,6 +1,6 @@
 use libc;
-use errno::{SysResult, from_ffi};
 use fcntl::Fd;
+use {NixResult, from_ffi};
 
 pub use self::ffi::Winsize;
 pub use self::IoctlArg::*;
@@ -33,7 +33,7 @@ pub enum IoctlArg<'a> {
     TIOCGWINSZ(&'a mut Winsize)
 }
 
-pub fn ioctl(fd: Fd, arg: IoctlArg) -> SysResult<()> {
+pub fn ioctl(fd: Fd, arg: IoctlArg) -> NixResult<()> {
     match arg {
         TIOCGWINSZ(&mut ref winsize) => {
             from_ffi(unsafe {
diff --git a/src/sys/mman.rs b/src/sys/mman.rs
index b301b967..9129aa6e 100644
--- a/src/sys/mman.rs
+++ b/src/sys/mman.rs
@@ -1,8 +1,8 @@
-use errno::{SysResult, SysError};
+use errno::Errno;
 use fcntl::{Fd, OFlag};
 use libc::{c_void, size_t, off_t, mode_t};
 use sys::stat::Mode;
-use utils::ToCStr;
+use {NixError, NixResult, NixPath};
 
 pub use self::consts::*;
 
@@ -128,68 +128,74 @@ mod ffi {
     }
 }
 
-pub unsafe fn mlock(addr: *const c_void, length: size_t) -> SysResult<()> {
+pub unsafe fn mlock(addr: *const c_void, length: size_t) -> NixResult<()> {
     match ffi::mlock(addr, length) {
         0 => Ok(()),
-        _ => Err(SysError::last())
+        _ => Err(NixError::Sys(Errno::last()))
     }
 }
 
-pub fn munlock(addr: *const c_void, length: size_t) -> SysResult<()> {
+pub fn munlock(addr: *const c_void, length: size_t) -> NixResult<()> {
     match unsafe { ffi::munlock(addr, length) } {
         0 => Ok(()),
-        _ => Err(SysError::last())
+        _ => Err(NixError::Sys(Errno::last()))
     }
 }
 
 /// Calls to mmap are inherently unsafe, so they must be made in an unsafe block. Typically
 /// a higher-level abstraction will hide the unsafe interactions with the mmap'd region.
-pub fn mmap(addr: *mut c_void, length: size_t, prot: MmapProt, flags: MmapFlag, fd: Fd, offset: off_t) -> SysResult<*mut c_void> {
+pub fn mmap(addr: *mut c_void, length: size_t, prot: MmapProt, flags: MmapFlag, fd: Fd, offset: off_t) -> NixResult<*mut c_void> {
     let ret = unsafe { ffi::mmap(addr, length, prot, flags, fd, offset) };
 
     if ret as isize == MAP_FAILED  {
-        Err(SysError::last())
+        Err(NixError::Sys(Errno::last()))
     } else {
         Ok(ret)
     }
 }
 
-pub fn munmap(addr: *mut c_void, len: size_t) -> SysResult<()> {
+pub fn munmap(addr: *mut c_void, len: size_t) -> NixResult<()> {
     match unsafe { ffi::munmap(addr, len) } {
         0 => Ok(()),
-        _ => Err(SysError::last())
+        _ => Err(NixError::Sys(Errno::last()))
     }
 }
 
-pub fn madvise(addr: *const c_void, length: size_t, advise: MmapAdvise) -> SysResult<()> {
+pub fn madvise(addr: *const c_void, length: size_t, advise: MmapAdvise) -> NixResult<()> {
     match unsafe { ffi::madvise(addr, length, advise) } {
         0 => Ok(()),
-        _ => Err(SysError::last())
+        _ => Err(NixError::Sys(Errno::last()))
     }
 }
 
-pub fn msync(addr: *const c_void, length: size_t, flags: MmapSync) -> SysResult<()> {
+pub fn msync(addr: *const c_void, length: size_t, flags: MmapSync) -> NixResult<()> {
     match unsafe { ffi::msync(addr, length, flags) } {
         0 => Ok(()),
-        _ => Err(SysError::last())
+        _ => Err(NixError::Sys(Errno::last()))
     }
 }
 
-pub fn shm_open(name: &String, flag: OFlag, mode: Mode) -> SysResult<Fd> {
-    let ret = unsafe { ffi::shm_open(name.to_c_str().as_ptr(), flag.bits(), mode.bits() as mode_t) };
+pub fn shm_open<P: NixPath>(name: P, flag: OFlag, mode: Mode) -> NixResult<Fd> {
+    let ret = try!(name.with_nix_path(|ptr| {
+        unsafe {
+            ffi::shm_open(ptr, flag.bits(), mode.bits() as mode_t)
+        }
+    }));
 
     if ret < 0 {
-        Err(SysError::last())
+        Err(NixError::Sys(Errno::last()))
     } else {
         Ok(ret)
     }
 }
 
-pub fn shm_unlink(name: &String) -> SysResult<()> {
-    let ret = unsafe { ffi::shm_unlink(name.to_c_str().as_ptr()) };
+pub fn shm_unlink<P: NixPath>(name: P) -> NixResult<()> {
+    let ret = try!(name.with_nix_path(|ptr| {
+        unsafe { ffi::shm_unlink(ptr) }
+    }));
 
     if ret < 0 {
-        Err(SysError::last())
+        Err(NixError::Sys(Errno::last()))
     } else {
         Ok(())
     }
diff --git a/src/sys/signal.rs b/src/sys/signal.rs
index bead902f..e63cff13 100644
--- a/src/sys/signal.rs
+++ b/src/sys/signal.rs
@@ -2,8 +2,9 @@
 // See http://rust-lang.org/COPYRIGHT.
 
 use libc;
+use errno::Errno;
 use core::mem;
-use errno::{SysError, SysResult};
+use {NixError, NixResult};
 
 pub use libc::consts::os::posix88::{
     SIGHUP,   // 1
@@ -311,21 +312,21 @@ impl SigSet {
         SigSet { sigset: sigset }
     }
 
-    pub fn add(&mut self, signum: SigNum) -> SysResult<()> {
+    pub fn add(&mut self, signum: SigNum) -> NixResult<()> {
         let res = unsafe { ffi::sigaddset(&mut self.sigset as *mut sigset_t, signum) };
 
         if res < 0 {
-            return Err(SysError::last());
+            return Err(NixError::Sys(Errno::last()));
         }
 
         Ok(())
     }
 
-    pub fn remove(&mut self, signum: SigNum) -> SysResult<()> {
+    pub fn remove(&mut self, signum: SigNum) -> NixResult<()> {
         let res = unsafe { ffi::sigdelset(&mut self.sigset as *mut sigset_t, signum) };
 
         if res < 0 {
-            return Err(SysError::last());
+            return Err(NixError::Sys(Errno::last()));
         }
 
         Ok(())
@@ -349,7 +350,7 @@ impl SigAction {
     }
 }
 
-pub fn sigaction(signum: SigNum, sigaction: &SigAction) -> SysResult<SigAction> {
+pub fn sigaction(signum: SigNum, sigaction: &SigAction) -> NixResult<SigAction> {
     let mut oldact = unsafe { mem::uninitialized::<sigaction_t>() };
 
     let res = unsafe {
@@ -357,17 +358,17 @@ pub fn sigaction(signum: SigNum, sigaction: &SigAction) -> SysResult<SigAction>
     };
 
     if res < 0 {
-        return Err(SysError::last());
+        return Err(NixError::Sys(Errno::last()));
     }
 
     Ok(SigAction { sigaction: oldact })
 }
 
-pub fn kill(pid: libc::pid_t, signum: SigNum) -> SysResult<()> {
+pub fn kill(pid: libc::pid_t, signum: SigNum) -> NixResult<()> {
     let res = unsafe { ffi::kill(pid, signum) };
 
     if res < 0 {
-        return Err(SysError::last());
+        return Err(NixError::Sys(Errno::last()));
     }
 
     Ok(())
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 {
diff --git a/src/sys/stat.rs b/src/sys/stat.rs
index ca17039c..1397ad24 100644
--- a/src/sys/stat.rs
+++ b/src/sys/stat.rs
@@ -3,11 +3,10 @@ pub use libc::stat as FileStat;
 
 use std::fmt;
 use std::mem;
-use std::old_path::Path;
+use errno::Errno;
 use libc::mode_t;
-use errno::{SysResult, SysError, from_ffi};
 use fcntl::Fd;
-use utils::ToCStr;
+use {NixError, NixResult, NixPath, from_ffi};
 
 mod ffi {
     use libc::{c_char, c_int, mode_t, dev_t};
@@ -58,8 +57,12 @@ impl fmt::Debug for SFlag {
     }
 }
 
-pub fn mknod(path: &Path, kind: SFlag, perm: Mode, dev: dev_t) -> SysResult<()> {
-    let res = unsafe { ffi::mknod(path.to_c_str().as_ptr(), kind.bits | perm.bits() as mode_t, dev) };
+pub fn mknod<P: NixPath>(path: P, kind: SFlag, perm: Mode, dev: dev_t) -> NixResult<()> {
+    let res = try!(path.with_nix_path(|ptr| {
+        unsafe {
+            ffi::mknod(ptr, kind.bits | perm.bits() as mode_t, dev)
+        }
+    }));
     from_ffi(res)
 }
 
@@ -76,23 +79,27 @@ pub fn umask(mode: Mode) -> Mode {
     Mode::from_bits(prev).expect("[BUG] umask returned invalid Mode")
 }
 
-pub fn stat(path: &Path) -> SysResult<FileStat> {
+pub fn stat<P: NixPath>(path: P) -> NixResult<FileStat> {
     let mut dst = unsafe { mem::uninitialized() };
-    let res = unsafe { ffi::stat(path.to_c_str().as_ptr(), &mut dst as *mut FileStat) };
+    let res = try!(path.with_nix_path(|ptr| {
+        unsafe {
+            ffi::stat(ptr, &mut dst as *mut FileStat)
+        }
+    }));
 
     if res < 0 {
-        return Err(SysError::last());
+        return Err(NixError::Sys(Errno::last()));
     }
 
     Ok(dst)
 }
 
-pub fn fstat(fd: Fd) -> SysResult<FileStat> {
+pub fn fstat(fd: Fd) -> NixResult<FileStat> {
     let mut dst = unsafe { mem::uninitialized() };
     let res = unsafe { ffi::fstat(fd, &mut dst as *mut FileStat) };
 
     if res < 0 {
-        return Err(SysError::last());
+        return Err(NixError::Sys(Errno::last()));
     }
 
     Ok(dst)
diff --git a/src/sys/termios.rs b/src/sys/termios.rs
index 525a13ff..56beca2e 100644
--- a/src/sys/termios.rs
+++ b/src/sys/termios.rs
@@ -1,7 +1,8 @@
-use errno::{SysError, SysResult, from_ffi};
+use errno::Errno;
 use fcntl::Fd;
 use libc::c_int;
 use std::mem;
+use {NixError, NixResult, from_ffi};
 
 pub use self::ffi::consts::*;
 pub use self::ffi::consts::SetArg::*;
@@ -361,19 +362,19 @@ pub fn cfgetospeed(termios: &Termios) -> speed_t {
     }
 }
 
-pub fn cfsetispeed(termios: &mut Termios, speed: speed_t) -> SysResult<()> {
+pub fn cfsetispeed(termios: &mut Termios, speed: speed_t) -> NixResult<()> {
     from_ffi(unsafe {
         ffi::cfsetispeed(termios, speed)
     })
 }
 
-pub fn cfsetospeed(termios: &mut Termios, speed: speed_t) -> SysResult<()> {
+pub fn cfsetospeed(termios: &mut Termios, speed: speed_t) -> NixResult<()> {
     from_ffi(unsafe {
         ffi::cfsetospeed(termios, speed)
     })
 }
 
-pub fn tcgetattr(fd: Fd) -> SysResult<Termios> {
+pub fn tcgetattr(fd: Fd) -> NixResult<Termios> {
     let mut termios = unsafe { mem::uninitialized() };
 
     let res = unsafe {
@@ -381,7 +382,7 @@ pub fn tcgetattr(fd: Fd) -> SysResult<Termios> {
     };
 
     if res < 0 {
-        return Err(SysError::last());
+        return Err(NixError::Sys(Errno::last()));
     }
 
     Ok(termios)
@@ -389,31 +390,31 @@ pub fn tcgetattr(fd: Fd) -> SysResult<Termios> {
 
 pub fn tcsetattr(fd: Fd,
                  actions: SetArg,
-                 termios: &Termios) -> SysResult<()> {
+                 termios: &Termios) -> NixResult<()> {
     from_ffi(unsafe {
         ffi::tcsetattr(fd, actions as c_int, termios)
     })
 }
 
-pub fn tcdrain(fd: Fd) -> SysResult<()> {
+pub fn tcdrain(fd: Fd) -> NixResult<()> {
     from_ffi(unsafe {
         ffi::tcdrain(fd)
     })
 }
 
-pub fn tcflow(fd: Fd, action: FlowArg) -> SysResult<()> {
+pub fn tcflow(fd: Fd, action: FlowArg) -> NixResult<()> {
     from_ffi(unsafe {
         ffi::tcflow(fd, action as c_int)
     })
 }
 
-pub fn tcflush(fd: Fd, action: FlushArg) -> SysResult<()> {
+pub fn tcflush(fd: Fd, action: FlushArg) -> NixResult<()> {
     from_ffi(unsafe {
         ffi::tcflush(fd, action as c_int)
     })
 }
 
-pub fn tcsendbreak(fd: Fd, action: c_int) -> SysResult<()> {
+pub fn tcsendbreak(fd: Fd, action: c_int) -> NixResult<()> {
     from_ffi(unsafe {
         ffi::tcsendbreak(fd, action)
     })
diff --git a/src/sys/wait.rs b/src/sys/wait.rs
index e2273d2f..b07c68b5 100644
--- a/src/sys/wait.rs
+++ b/src/sys/wait.rs
@@ -1,5 +1,6 @@
 use libc::{pid_t, c_int};
-use errno::{SysResult, SysError};
+use errno::Errno;
+use {NixError, NixResult};
 
 mod ffi {
     use libc::{pid_t, c_int};
@@ -21,7 +22,7 @@ pub enum WaitStatus {
     StillAlive
 }
 
-pub fn waitpid(pid: pid_t, options: Option<WaitPidFlag>) -> SysResult<WaitStatus> {
+pub fn waitpid(pid: pid_t, options: Option<WaitPidFlag>) -> NixResult<WaitStatus> {
     use self::WaitStatus::*;
 
     let mut status: i32 = 0;
@@ -34,7 +35,7 @@ pub fn waitpid(pid: pid_t, options: Option<WaitPidFlag>) -> SysResult<WaitStatus
     let res = unsafe { ffi::waitpid(pid as pid_t, &mut status as *mut c_int, option_bits) };
 
     if res < 0 {
-        Err(SysError::last())
+        Err(NixError::Sys(Errno::last()))
     } else if res == 0 {
         Ok(StillAlive)
     } else {
-- 
cgit v1.2.3