summaryrefslogtreecommitdiff
path: root/src/sys
diff options
context:
space:
mode:
Diffstat (limited to 'src/sys')
-rw-r--r--src/sys/epoll.rs18
-rw-r--r--src/sys/event.rs21
-rw-r--r--src/sys/eventfd.rs8
-rw-r--r--src/sys/ioctl/platform/linux.rs6
-rw-r--r--src/sys/memfd.rs6
-rw-r--r--src/sys/mman.rs41
-rw-r--r--src/sys/ptrace.rs19
-rw-r--r--src/sys/quota.rs7
-rw-r--r--src/sys/select.rs9
-rw-r--r--src/sys/signal.rs43
-rw-r--r--src/sys/signalfd.rs8
-rw-r--r--src/sys/socket/addr.rs4
-rw-r--r--src/sys/socket/mod.rs102
-rw-r--r--src/sys/socket/sockopt.rs9
-rw-r--r--src/sys/stat.rs19
-rw-r--r--src/sys/statfs.rs9
-rw-r--r--src/sys/statvfs.rs9
-rw-r--r--src/sys/termios.rs35
-rw-r--r--src/sys/uio.rs42
-rw-r--r--src/sys/wait.rs14
20 files changed, 129 insertions, 300 deletions
diff --git a/src/sys/epoll.rs b/src/sys/epoll.rs
index 22587641..a079649a 100644
--- a/src/sys/epoll.rs
+++ b/src/sys/epoll.rs
@@ -1,5 +1,4 @@
-use {Error, Result, from_ffi};
-use errno::Errno;
+use errno::{Errno, Result};
use libc::c_int;
use std::os::unix::io::RawFd;
@@ -76,17 +75,14 @@ fn test_epoll_event_size() {
pub fn epoll_create() -> Result<RawFd> {
let res = unsafe { ffi::epoll_create(1024) };
- if res < 0 {
- return Err(Error::Sys(Errno::last()));
- }
-
- Ok(res)
+ Errno::result(res)
}
#[inline]
pub fn epoll_ctl(epfd: RawFd, op: EpollOp, fd: RawFd, event: &EpollEvent) -> Result<()> {
let res = unsafe { ffi::epoll_ctl(epfd, op as c_int, fd, event as *const EpollEvent) };
- from_ffi(res)
+
+ Errno::result(res).map(drop)
}
#[inline]
@@ -95,9 +91,5 @@ pub fn epoll_wait(epfd: RawFd, events: &mut [EpollEvent], timeout_ms: isize) ->
ffi::epoll_wait(epfd, events.as_mut_ptr(), events.len() as c_int, timeout_ms as c_int)
};
- if res < 0 {
- return Err(Error::Sys(Errno::last()));
- }
-
- Ok(res as usize)
+ Errno::result(res).map(|r| r as usize)
}
diff --git a/src/sys/event.rs b/src/sys/event.rs
index 6498cb97..eb99f7d9 100644
--- a/src/sys/event.rs
+++ b/src/sys/event.rs
@@ -1,8 +1,7 @@
/* TOOD: Implement for other kqueue based systems
*/
-use {Error, Result};
-use errno::Errno;
+use errno::{Errno, Result};
#[cfg(not(target_os = "netbsd"))]
use libc::{timespec, time_t, c_int, c_long, uintptr_t};
#[cfg(target_os = "netbsd")]
@@ -277,11 +276,7 @@ pub const EV_OOBAND: EventFlag = EV_FLAG1;
pub fn kqueue() -> Result<RawFd> {
let res = unsafe { ffi::kqueue() };
- if res < 0 {
- return Err(Error::Sys(Errno::last()));
- }
-
- Ok(res)
+ Errno::result(res)
}
pub fn kevent(kq: RawFd,
@@ -314,11 +309,7 @@ pub fn kevent_ts(kq: RawFd,
if let Some(ref timeout) = timeout_opt {timeout as *const timespec} else {ptr::null()})
};
- if res < 0 {
- return Err(Error::Sys(Errno::last()));
- }
-
- return Ok(res as usize)
+ Errno::result(res).map(|r| r as usize)
}
#[cfg(target_os = "netbsd")]
@@ -337,11 +328,7 @@ pub fn kevent_ts(kq: RawFd,
if let Some(ref timeout) = timeout_opt {timeout as *const timespec} else {ptr::null()})
};
- if res < 0 {
- return Err(Error::Sys(Errno::last()));
- }
-
- return Ok(res as usize)
+ Errno::result(res).map(|r| r as usize)
}
#[cfg(not(target_os = "netbsd"))]
diff --git a/src/sys/eventfd.rs b/src/sys/eventfd.rs
index 80f7f47c..d2cd6b93 100644
--- a/src/sys/eventfd.rs
+++ b/src/sys/eventfd.rs
@@ -1,6 +1,6 @@
use libc;
use std::os::unix::io::RawFd;
-use {Error, Result};
+use errno::{Errno, Result};
bitflags!(
flags EventFdFlag: libc::c_int {
@@ -22,10 +22,6 @@ pub fn eventfd(initval: usize, flags: EventFdFlag) -> Result<RawFd> {
unsafe {
let res = ffi::eventfd(initval as libc::c_uint, flags.bits());
- if res < 0 {
- return Err(Error::last());
- }
-
- Ok(res as RawFd)
+ Errno::result(res).map(|r| r as RawFd)
}
}
diff --git a/src/sys/ioctl/platform/linux.rs b/src/sys/ioctl/platform/linux.rs
index b0fa6bee..60311224 100644
--- a/src/sys/ioctl/platform/linux.rs
+++ b/src/sys/ioctl/platform/linux.rs
@@ -82,11 +82,7 @@ macro_rules! iorw {
macro_rules! convert_ioctl_res {
($w:expr) => (
{
- let res = $w;
- if res < 0 {
- return Err($crate::Error::Sys($crate::errno::Errno::last()))
- }
- Ok(res) // res may contain useful information for user
+ $crate::Errno::result($w)
}
);
}
diff --git a/src/sys/memfd.rs b/src/sys/memfd.rs
index e142218f..c5b7b803 100644
--- a/src/sys/memfd.rs
+++ b/src/sys/memfd.rs
@@ -1,6 +1,6 @@
use libc;
use std::os::unix::io::RawFd;
-use {Error, Result};
+use errno::{Errno, Result};
use std::ffi::CStr;
bitflags!(
@@ -13,6 +13,6 @@ bitflags!(
pub fn memfd_create(name: &CStr, flags: MemFdCreateFlag) -> Result<RawFd> {
use sys::syscall::{syscall, MEMFD_CREATE};
let res = unsafe { syscall(MEMFD_CREATE, name.as_ptr(), flags.bits()) };
- if res == -1 { Err(Error::last()) }
- else { Ok(res as RawFd) }
+
+ Errno::result(res).map(|r| r as RawFd)
}
diff --git a/src/sys/mman.rs b/src/sys/mman.rs
index f74f0b8e..cb36cf7b 100644
--- a/src/sys/mman.rs
+++ b/src/sys/mman.rs
@@ -1,5 +1,5 @@
-use {Error, Result, NixPath};
-use errno::Errno;
+use {NixPath, Error};
+use errno::{Errno, Result};
use fcntl::OFlag;
use libc::{c_void, size_t, off_t, mode_t};
use sys::stat::Mode;
@@ -191,17 +191,11 @@ mod ffi {
}
pub unsafe fn mlock(addr: *const c_void, length: size_t) -> Result<()> {
- match ffi::mlock(addr, length) {
- 0 => Ok(()),
- _ => Err(Error::Sys(Errno::last()))
- }
+ Errno::result(ffi::mlock(addr, length)).map(drop)
}
pub fn munlock(addr: *const c_void, length: size_t) -> Result<()> {
- match unsafe { ffi::munlock(addr, length) } {
- 0 => Ok(()),
- _ => Err(Error::Sys(Errno::last()))
- }
+ Errno::result(unsafe { ffi::munlock(addr, length) }).map(drop)
}
/// Calls to mmap are inherently unsafe, so they must be made in an unsafe block. Typically
@@ -217,24 +211,15 @@ pub fn mmap(addr: *mut c_void, length: size_t, prot: MmapProt, flags: MmapFlag,
}
pub fn munmap(addr: *mut c_void, len: size_t) -> Result<()> {
- match unsafe { ffi::munmap(addr, len) } {
- 0 => Ok(()),
- _ => Err(Error::Sys(Errno::last()))
- }
+ Errno::result(unsafe { ffi::munmap(addr, len) }).map(drop)
}
pub fn madvise(addr: *const c_void, length: size_t, advise: MmapAdvise) -> Result<()> {
- match unsafe { ffi::madvise(addr, length, advise) } {
- 0 => Ok(()),
- _ => Err(Error::Sys(Errno::last()))
- }
+ Errno::result(unsafe { ffi::madvise(addr, length, advise) }).map(drop)
}
pub fn msync(addr: *const c_void, length: size_t, flags: MmapSync) -> Result<()> {
- match unsafe { ffi::msync(addr, length, flags) } {
- 0 => Ok(()),
- _ => Err(Error::Sys(Errno::last()))
- }
+ Errno::result(unsafe { ffi::msync(addr, length, flags) }).map(drop)
}
pub fn shm_open<P: ?Sized + NixPath>(name: &P, flag: OFlag, mode: Mode) -> Result<RawFd> {
@@ -244,11 +229,7 @@ pub fn shm_open<P: ?Sized + NixPath>(name: &P, flag: OFlag, mode: Mode) -> Resul
}
}));
- if ret < 0 {
- Err(Error::Sys(Errno::last()))
- } else {
- Ok(ret)
- }
+ Errno::result(ret)
}
pub fn shm_unlink<P: ?Sized + NixPath>(name: &P) -> Result<()> {
@@ -256,9 +237,5 @@ pub fn shm_unlink<P: ?Sized + NixPath>(name: &P) -> Result<()> {
unsafe { ffi::shm_unlink(cstr.as_ptr()) }
}));
- if ret < 0 {
- Err(Error::Sys(Errno::last()))
- } else {
- Ok(())
- }
+ Errno::result(ret).map(drop)
}
diff --git a/src/sys/ptrace.rs b/src/sys/ptrace.rs
index 7c8c3e8e..9d8e6932 100644
--- a/src/sys/ptrace.rs
+++ b/src/sys/ptrace.rs
@@ -1,5 +1,5 @@
-use {Error, Result};
-use errno::Errno;
+use Error;
+use errno::{Errno, Result};
use libc::{pid_t, c_void, c_long};
#[cfg(all(target_os = "linux",
@@ -86,17 +86,14 @@ fn ptrace_peek(request: ptrace::PtraceRequest, pid: pid_t, addr: *mut c_void, da
Errno::clear();
ffi::ptrace(request, pid, addr, data)
};
- if ret == -1 && Errno::last() != Errno::UnknownErrno {
- return Err(Error::Sys(Errno::last()));
+ match Errno::result(ret) {
+ Ok(..) | Err(Error::Sys(Errno::UnknownErrno)) => Ok(ret),
+ err @ Err(..) => err,
}
- Ok::<c_long, Error>(ret)
}
fn ptrace_other(request: ptrace::PtraceRequest, pid: pid_t, addr: *mut c_void, data: *mut c_void) -> Result<c_long> {
- match unsafe { ffi::ptrace(request, pid, addr, data) } {
- -1 => Err(Error::Sys(Errno::last())),
- _ => Ok(0)
- }
+ Errno::result(unsafe { ffi::ptrace(request, pid, addr, data) }).map(|_| 0)
}
/// Set options, as with ptrace(PTRACE_SETOPTIONS,...).
@@ -104,7 +101,5 @@ pub fn ptrace_setoptions(pid: pid_t, options: ptrace::PtraceOptions) -> Result<(
use self::ptrace::*;
use std::ptr;
- try!(ptrace(PTRACE_SETOPTIONS, pid, ptr::null_mut(), options as *mut c_void));
- Ok(())
+ ptrace(PTRACE_SETOPTIONS, pid, ptr::null_mut(), options as *mut c_void).map(drop)
}
-
diff --git a/src/sys/quota.rs b/src/sys/quota.rs
index 4786f80d..7a7718e4 100644
--- a/src/sys/quota.rs
+++ b/src/sys/quota.rs
@@ -1,5 +1,5 @@
-use {Result, NixPath, from_ffi};
-use errno::Errno;
+use NixPath;
+use errno::{Errno, Result};
use libc::{c_int, c_char};
#[cfg(all(target_os = "linux",
@@ -90,7 +90,8 @@ fn quotactl<P: ?Sized + NixPath>(cmd: quota::QuotaCmd, special: Option<&P>, id:
None => Ok(ffi::quotactl(cmd.as_int(), ptr::null(), id, addr)),
}
);
- from_ffi(res)
+
+ Errno::result(res).map(drop)
}
}
diff --git a/src/sys/select.rs b/src/sys/select.rs
index 5cae88fd..db0a55b9 100644
--- a/src/sys/select.rs
+++ b/src/sys/select.rs
@@ -1,8 +1,7 @@
use std::ptr::null_mut;
use std::os::unix::io::RawFd;
use libc::c_int;
-use {Result, Error};
-use errno::Errno;
+use errno::{Errno, Result};
use sys::time::TimeVal;
pub const FD_SETSIZE: RawFd = 1024;
@@ -82,9 +81,5 @@ pub fn select(nfds: c_int,
ffi::select(nfds, readfds, writefds, errorfds, timeout)
};
- if res == -1 {
- Err(Error::Sys(Errno::last()))
- } else {
- Ok(res)
- }
+ Errno::result(res)
}
diff --git a/src/sys/signal.rs b/src/sys/signal.rs
index e3d5e407..76984f2c 100644
--- a/src/sys/signal.rs
+++ b/src/sys/signal.rs
@@ -2,10 +2,9 @@
// See http://rust-lang.org/COPYRIGHT.
use libc;
-use errno::Errno;
+use errno::{Errno, Result};
use std::mem;
use std::ptr;
-use {Error, Result};
pub use libc::{
SIGHUP,
@@ -324,30 +323,22 @@ impl SigSet {
pub fn add(&mut self, signum: SigNum) -> Result<()> {
let res = unsafe { ffi::sigaddset(&mut self.sigset as *mut sigset_t, signum) };
- if res < 0 {
- return Err(Error::Sys(Errno::last()));
- }
-
- Ok(())
+ Errno::result(res).map(drop)
}
pub fn remove(&mut self, signum: SigNum) -> Result<()> {
let res = unsafe { ffi::sigdelset(&mut self.sigset as *mut sigset_t, signum) };
- if res < 0 {
- return Err(Error::Sys(Errno::last()));
- }
-
- Ok(())
+ Errno::result(res).map(drop)
}
pub fn contains(&self, signum: SigNum) -> Result<bool> {
let res = unsafe { ffi::sigismember(&self.sigset as *const sigset_t, signum) };
- match res {
+ match try!(Errno::result(res)) {
1 => Ok(true),
0 => Ok(false),
- _ => Err(Error::Sys(Errno::last()))
+ _ => unreachable!("unexpected value from sigismember"),
}
}
@@ -410,11 +401,7 @@ pub unsafe fn sigaction(signum: SigNum, sigaction: &SigAction) -> Result<SigActi
let res =
ffi::sigaction(signum, &sigaction.sigaction as *const sigaction_t, &mut oldact as *mut sigaction_t);
- if res < 0 {
- return Err(Error::Sys(Errno::last()));
- }
-
- Ok(SigAction { sigaction: oldact })
+ Errno::result(res).map(|_| SigAction { sigaction: oldact })
}
/// Manages the signal mask (set of blocked signals) for the calling thread.
@@ -448,31 +435,19 @@ pub fn pthread_sigmask(how: HowFlag,
|os| &mut os.sigset as *mut sigset_t))
};
- if res != 0 {
- return Err(Error::Sys(Errno::last()));
- }
-
- Ok(())
+ Errno::result(res).map(drop)
}
pub fn kill(pid: libc::pid_t, signum: SigNum) -> Result<()> {
let res = unsafe { ffi::kill(pid, signum) };
- if res < 0 {
- return Err(Error::Sys(Errno::last()));
- }
-
- Ok(())
+ Errno::result(res).map(drop)
}
pub fn raise(signum: SigNum) -> Result<()> {
let res = unsafe { ffi::raise(signum) };
- if res < 0 {
- return Err(Error::Sys(Errno::last()));
- }
-
- Ok(())
+ Errno::result(res).map(drop)
}
#[cfg(test)]
diff --git a/src/sys/signalfd.rs b/src/sys/signalfd.rs
index 66eaa04e..7d1455e6 100644
--- a/src/sys/signalfd.rs
+++ b/src/sys/signalfd.rs
@@ -16,9 +16,8 @@
//! Please note that signal discarding is not specific to `signalfd`, but also happens with regular
//! signal handlers.
use libc::{c_int, pid_t, uid_t};
-use {Error, Result};
use unistd;
-use errno::Errno;
+use errno::{Errno, Result};
use sys::signal::signal::siginfo as signal_siginfo;
pub use sys::signal::{self, SigSet};
@@ -56,10 +55,7 @@ pub const CREATE_NEW_FD: RawFd = -1;
/// See [the signalfd man page for more information](http://man7.org/linux/man-pages/man2/signalfd.2.html)
pub fn signalfd(fd: RawFd, mask: &SigSet, flags: SfdFlags) -> Result<RawFd> {
unsafe {
- match ffi::signalfd(fd as c_int, mask.as_ref(), flags.bits()) {
- -1 => Err(Error::Sys(Errno::last())),
- res => Ok(res as RawFd),
- }
+ Errno::result(ffi::signalfd(fd as c_int, mask.as_ref(), flags.bits()))
}
}
diff --git a/src/sys/socket/addr.rs b/src/sys/socket/addr.rs
index 943df26e..49a1ecf5 100644
--- a/src/sys/socket/addr.rs
+++ b/src/sys/socket/addr.rs
@@ -1,6 +1,6 @@
-use {Result, Error, NixPath};
use super::{consts, sa_family_t};
-use errno::Errno;
+use {NixPath, Error};
+use errno::{Errno, Result};
use libc;
use std::{fmt, hash, mem, net, ptr};
use std::ffi::OsStr;
diff --git a/src/sys/socket/mod.rs b/src/sys/socket/mod.rs
index 8a74029f..60b138ed 100644
--- a/src/sys/socket/mod.rs
+++ b/src/sys/socket/mod.rs
@@ -1,8 +1,8 @@
//! Socket interface functions
//!
//! [Further reading](http://man7.org/linux/man-pages/man7/socket.7.html)
-use {Error, Result, from_ffi};
-use errno::Errno;
+use Error;
+use errno::{Errno, Result};
use features;
use fcntl::{fcntl, FD_CLOEXEC, O_NONBLOCK};
use fcntl::FcntlArg::{F_SETFD, F_SETFL};
@@ -293,11 +293,7 @@ pub fn sendmsg<'a>(fd: RawFd, iov: &[IoVec<&'a [u8]>], cmsgs: &[ControlMessage<'
};
let ret = unsafe { ffi::sendmsg(fd, &mhdr, flags) };
- if ret < 0 {
- Err(Error::Sys(Errno::last()))
- } else {
- Ok(ret as usize)
- }
+ Errno::result(ret).map(|r| r as usize)
}
/// Receive message in scatter-gather vectors from a socket, and
@@ -320,18 +316,14 @@ pub fn recvmsg<'a, T>(fd: RawFd, iov: &[IoVec<&mut [u8]>], cmsg_buffer: Option<&
};
let ret = unsafe { ffi::recvmsg(fd, &mut mhdr, flags) };
- if ret < 0 {
- Err(Error::Sys(Errno::last()))
- } else {
- Ok(unsafe { RecvMsg {
- bytes: ret as usize,
- cmsg_buffer: slice::from_raw_parts(mhdr.msg_control as *const u8,
- mhdr.msg_controllen as usize),
- address: sockaddr_storage_to_addr(&address,
- mhdr.msg_namelen as usize).ok(),
- flags: mhdr.msg_flags,
- } })
- }
+ Ok(unsafe { RecvMsg {
+ bytes: try!(Errno::result(ret)) as usize,
+ cmsg_buffer: slice::from_raw_parts(mhdr.msg_control as *const u8,
+ mhdr.msg_controllen as usize),
+ address: sockaddr_storage_to_addr(&address,
+ mhdr.msg_namelen as usize).ok(),
+ flags: mhdr.msg_flags,
+ } })
}
@@ -347,11 +339,7 @@ pub fn socket(domain: AddressFamily, ty: SockType, flags: SockFlag, protocol: c_
}
// TODO: Check the kernel version
- let res = unsafe { ffi::socket(domain as c_int, ty, protocol) };
-
- if res < 0 {
- return Err(Error::Sys(Errno::last()));
- }
+ let res = try!(Errno::result(unsafe { ffi::socket(domain as c_int, ty, protocol) }));
if !feat_atomic {
if flags.contains(SOCK_CLOEXEC) {
@@ -381,10 +369,7 @@ pub fn socketpair(domain: AddressFamily, ty: SockType, protocol: c_int,
let res = unsafe {
ffi::socketpair(domain as c_int, ty, protocol, fds.as_mut_ptr())
};
-
- if res < 0 {
- return Err(Error::Sys(Errno::last()));
- }
+ try!(Errno::result(res));
if !feat_atomic {
if flags.contains(SOCK_CLOEXEC) {
@@ -405,7 +390,8 @@ pub fn socketpair(domain: AddressFamily, ty: SockType, protocol: c_int,
/// [Further reading](http://man7.org/linux/man-pages/man2/listen.2.html)
pub fn listen(sockfd: RawFd, backlog: usize) -> Result<()> {
let res = unsafe { ffi::listen(sockfd, backlog as c_int) };
- from_ffi(res)
+
+ Errno::result(res).map(drop)
}
/// Bind a name to a socket
@@ -417,7 +403,7 @@ pub fn bind(fd: RawFd, addr: &SockAddr) -> Result<()> {
ffi::bind(fd, ptr, len)
};
- from_ffi(res)
+ Errno::result(res).map(drop)
}
/// Accept a connection on a socket
@@ -426,11 +412,7 @@ pub fn bind(fd: RawFd, addr: &SockAddr) -> Result<()> {
pub fn accept(sockfd: RawFd) -> Result<RawFd> {
let res = unsafe { ffi::accept(sockfd, ptr::null_mut(), ptr::null_mut()) };
- if res < 0 {
- return Err(Error::Sys(Errno::last()));
- }
-
- Ok(res)
+ Errno::result(res)
}
/// Accept a connection on a socket
@@ -442,11 +424,7 @@ pub fn accept4(sockfd: RawFd, flags: SockFlag) -> Result<RawFd> {
#[inline]
fn accept4_polyfill(sockfd: RawFd, flags: SockFlag) -> Result<RawFd> {
- let res = unsafe { ffi::accept(sockfd, ptr::null_mut(), ptr::null_mut()) };
-
- if res < 0 {
- return Err(Error::Sys(Errno::last()));
- }
+ let res = try!(Errno::result(unsafe { ffi::accept(sockfd, ptr::null_mut(), ptr::null_mut()) }));
if flags.contains(SOCK_CLOEXEC) {
try!(fcntl(res, F_SETFD(FD_CLOEXEC)));
@@ -468,7 +446,7 @@ pub fn connect(fd: RawFd, addr: &SockAddr) -> Result<()> {
ffi::connect(fd, ptr, len)
};
- from_ffi(res)
+ Errno::result(res).map(drop)
}
/// Receive data from a connection-oriented socket. Returns the number of
@@ -483,11 +461,7 @@ pub fn recv(sockfd: RawFd, buf: &mut [u8], flags: SockMessageFlags) -> Result<us
buf.len() as size_t,
flags);
- if ret < 0 {
- Err(Error::last())
- } else {
- Ok(ret as usize)
- }
+ Errno::result(ret).map(|r| r as usize)
}
}
@@ -500,17 +474,13 @@ pub fn recvfrom(sockfd: RawFd, buf: &mut [u8]) -> Result<(usize, SockAddr)> {
let addr: sockaddr_storage = mem::zeroed();
let mut len = mem::size_of::<sockaddr_storage>() as socklen_t;
- let ret = ffi::recvfrom(
+ let ret = try!(Errno::result(ffi::recvfrom(
sockfd,
buf.as_ptr() as *mut c_void,
buf.len() as size_t,
0,
mem::transmute(&addr),
- &mut len as *mut socklen_t);
-
- if ret < 0 {
- return Err(Error::last());
- }
+ &mut len as *mut socklen_t)));
sockaddr_storage_to_addr(&addr, len as usize)
.map(|addr| (ret as usize, addr))
@@ -523,11 +493,7 @@ pub fn sendto(fd: RawFd, buf: &[u8], addr: &SockAddr, flags: SockMessageFlags) -
ffi::sendto(fd, buf.as_ptr() as *const c_void, buf.len() as size_t, flags, ptr, len)
};
- if ret < 0 {
- Err(Error::Sys(Errno::last()))
- } else {
- Ok(ret as usize)
- }
+ Errno::result(ret).map(|r| r as usize)
}
/// Send data to a connection-oriented socket. Returns the number of bytes read
@@ -538,11 +504,7 @@ pub fn send(fd: RawFd, buf: &[u8], flags: SockMessageFlags) -> Result<usize> {
ffi::send(fd, buf.as_ptr() as *const c_void, buf.len() as size_t, flags)
};
- if ret < 0 {
- Err(Error::last())
- } else {
- Ok(ret as usize)
- }
+ Errno::result(ret).map(|r| r as usize)
}
#[repr(C)]
@@ -621,9 +583,7 @@ pub fn getpeername(fd: RawFd) -> Result<SockAddr> {
let ret = ffi::getpeername(fd, mem::transmute(&addr), &mut len);
- if ret < 0 {
- return Err(Error::last());
- }
+ try!(Errno::result(ret));
sockaddr_storage_to_addr(&addr, len as usize)
}
@@ -639,9 +599,7 @@ pub fn getsockname(fd: RawFd) -> Result<SockAddr> {
let ret = ffi::getsockname(fd, mem::transmute(&addr), &mut len);
- if ret < 0 {
- return Err(Error::last());
- }
+ try!(Errno::result(ret));
sockaddr_storage_to_addr(&addr, len as usize)
}
@@ -696,14 +654,8 @@ pub fn shutdown(df: RawFd, how: Shutdown) -> Result<()> {
Shutdown::Both => consts::SHUT_RDWR,
};
- let ret = shutdown(df, how);
-
- if ret < 0 {
- return Err(Error::last());
- }
+ Errno::result(shutdown(df, how)).map(drop)
}
-
- Ok(())
}
#[test]
diff --git a/src/sys/socket/sockopt.rs b/src/sys/socket/sockopt.rs
index 4fea8d53..a9d6e67c 100644
--- a/src/sys/socket/sockopt.rs
+++ b/src/sys/socket/sockopt.rs
@@ -1,6 +1,5 @@
-use {Result, Error, from_ffi};
use super::{ffi, consts, GetSockOpt, SetSockOpt};
-use errno::Errno;
+use errno::{Errno, Result};
use sys::time::TimeVal;
use libc::{c_int, uint8_t, c_void, socklen_t};
use std::mem;
@@ -18,7 +17,7 @@ macro_rules! setsockopt_impl {
let res = ffi::setsockopt(fd, $level, $flag,
setter.ffi_ptr(),
setter.ffi_len());
- from_ffi(res)
+ Errno::result(res).map(drop)
}
}
}
@@ -37,9 +36,7 @@ macro_rules! getsockopt_impl {
let res = ffi::getsockopt(fd, $level, $flag,
getter.ffi_ptr(),
getter.ffi_len());
- if res < 0 {
- return Err(Error::Sys(Errno::last()));
- }
+ try!(Errno::result(res));
Ok(getter.unwrap())
}
diff --git a/src/sys/stat.rs b/src/sys/stat.rs
index 2a34d282..391924da 100644
--- a/src/sys/stat.rs
+++ b/src/sys/stat.rs
@@ -1,8 +1,8 @@
pub use libc::dev_t;
pub use libc::stat as FileStat;
-use {Error, Result, NixPath, from_ffi};
-use errno::Errno;
+use NixPath;
+use errno::{Errno, Result};
use libc::mode_t;
use std::mem;
use std::os::unix::io::RawFd;
@@ -56,7 +56,8 @@ pub fn mknod<P: ?Sized + NixPath>(path: &P, kind: SFlag, perm: Mode, dev: dev_t)
ffi::mknod(cstr.as_ptr(), kind.bits | perm.bits() as mode_t, dev)
}
}));
- from_ffi(res)
+
+ Errno::result(res).map(drop)
}
#[cfg(target_os = "linux")]
@@ -80,9 +81,7 @@ pub fn stat<P: ?Sized + NixPath>(path: &P) -> Result<FileStat> {
}
}));
- if res < 0 {
- return Err(Error::Sys(Errno::last()));
- }
+ try!(Errno::result(res));
Ok(dst)
}
@@ -95,9 +94,7 @@ pub fn lstat<P: ?Sized + NixPath>(path: &P) -> Result<FileStat> {
}
}));
- if res < 0 {
- return Err(Error::Sys(Errno::last()));
- }
+ try!(Errno::result(res));
Ok(dst)
}
@@ -106,9 +103,7 @@ pub fn fstat(fd: RawFd) -> Result<FileStat> {
let mut dst = unsafe { mem::uninitialized() };
let res = unsafe { ffi::fstat(fd, &mut dst as *mut FileStat) };
- if res < 0 {
- return Err(Error::Sys(Errno::last()));
- }
+ try!(Errno::result(res));
Ok(dst)
}
diff --git a/src/sys/statfs.rs b/src/sys/statfs.rs
index 63ee1ac4..0552e3d0 100644
--- a/src/sys/statfs.rs
+++ b/src/sys/statfs.rs
@@ -1,5 +1,5 @@
-use {Result, NixPath, from_ffi};
-use errno::Errno;
+use NixPath;
+use errno::{Errno, Result};
use std::os::unix::io::AsRawFd;
pub mod vfs {
@@ -104,13 +104,14 @@ pub fn statfs<P: ?Sized + NixPath>(path: &P, stat: &mut vfs::Statfs) -> Result<(
let res = try!(
path.with_nix_path(|path| ffi::statfs(path.as_ptr(), stat))
);
- from_ffi(res)
+
+ Errno::result(res).map(drop)
}
}
pub fn fstatfs<T: AsRawFd>(fd: &T, stat: &mut vfs::Statfs) -> Result<()> {
unsafe {
Errno::clear();
- from_ffi(ffi::fstatfs(fd.as_raw_fd(), stat))
+ Errno::result(ffi::fstatfs(fd.as_raw_fd(), stat)).map(drop)
}
}
diff --git a/src/sys/statvfs.rs b/src/sys/statvfs.rs
index 0d996afe..abfc6c9b 100644
--- a/src/sys/statvfs.rs
+++ b/src/sys/statvfs.rs
@@ -2,8 +2,8 @@
//!
//! See the `vfs::Statvfs` struct for some rusty wrappers
-use {Result, NixPath, from_ffi};
-use errno::Errno;
+use NixPath;
+use errno::{Errno, Result};
use std::os::unix::io::AsRawFd;
pub mod vfs {
@@ -147,7 +147,8 @@ pub fn statvfs<P: ?Sized + NixPath>(path: &P, stat: &mut vfs::Statvfs) -> Result
let res = try!(
path.with_nix_path(|path| ffi::statvfs(path.as_ptr(), stat))
);
- from_ffi(res)
+
+ Errno::result(res).map(drop)
}
}
@@ -155,7 +156,7 @@ pub fn statvfs<P: ?Sized + NixPath>(path: &P, stat: &mut vfs::Statvfs) -> Result
pub fn fstatvfs<T: AsRawFd>(fd: &T, stat: &mut vfs::Statvfs) -> Result<()> {
unsafe {
Errno::clear();
- from_ffi(ffi::fstatvfs(fd.as_raw_fd(), stat))
+ Errno::result(ffi::fstatvfs(fd.as_raw_fd(), stat)).map(drop)
}
}
diff --git a/src/sys/termios.rs b/src/sys/termios.rs
index 4e6b2e51..9c26661f 100644
--- a/src/sys/termios.rs
+++ b/src/sys/termios.rs
@@ -1,5 +1,4 @@
-use {Error, Result, from_ffi};
-use errno::Errno;
+use errno::{Errno, Result};
use libc::c_int;
use std::mem;
use std::os::unix::io::RawFd;
@@ -440,15 +439,15 @@ pub fn cfgetospeed(termios: &Termios) -> speed_t {
}
pub fn cfsetispeed(termios: &mut Termios, speed: speed_t) -> Result<()> {
- from_ffi(unsafe {
+ Errno::result(unsafe {
ffi::cfsetispeed(termios, speed)
- })
+ }).map(drop)
}
pub fn cfsetospeed(termios: &mut Termios, speed: speed_t) -> Result<()> {
- from_ffi(unsafe {
+ Errno::result(unsafe {
ffi::cfsetospeed(termios, speed)
- })
+ }).map(drop)
}
pub fn tcgetattr(fd: RawFd) -> Result<Termios> {
@@ -458,9 +457,7 @@ pub fn tcgetattr(fd: RawFd) -> Result<Termios> {
ffi::tcgetattr(fd, &mut termios)
};
- if res < 0 {
- return Err(Error::Sys(Errno::last()));
- }
+ try!(Errno::result(res));
Ok(termios)
}
@@ -468,31 +465,31 @@ pub fn tcgetattr(fd: RawFd) -> Result<Termios> {
pub fn tcsetattr(fd: RawFd,
actions: SetArg,
termios: &Termios) -> Result<()> {
- from_ffi(unsafe {
+ Errno::result(unsafe {
ffi::tcsetattr(fd, actions as c_int, termios)
- })
+ }).map(drop)
}
pub fn tcdrain(fd: RawFd) -> Result<()> {
- from_ffi(unsafe {
+ Errno::result(unsafe {
ffi::tcdrain(fd)
- })
+ }).map(drop)
}
pub fn tcflow(fd: RawFd, action: FlowArg) -> Result<()> {
- from_ffi(unsafe {
+ Errno::result(unsafe {
ffi::tcflow(fd, action as c_int)
- })
+ }).map(drop)
}
pub fn tcflush(fd: RawFd, action: FlushArg) -> Result<()> {
- from_ffi(unsafe {
+ Errno::result(unsafe {
ffi::tcflush(fd, action as c_int)
- })
+ }).map(drop)
}
pub fn tcsendbreak(fd: RawFd, action: c_int) -> Result<()> {
- from_ffi(unsafe {
+ Errno::result(unsafe {
ffi::tcsendbreak(fd, action)
- })
+ }).map(drop)
}
diff --git a/src/sys/uio.rs b/src/sys/uio.rs
index b43ede3c..7e734f84 100644
--- a/src/sys/uio.rs
+++ b/src/sys/uio.rs
@@ -1,8 +1,7 @@
// Silence invalid warnings due to rust-lang/rust#16719
#![allow(improper_ctypes)]
-use {Result, Error};
-use errno::Errno;
+use errno::{Errno, Result};
use libc::{c_int, c_void, size_t, off_t};
use std::marker::PhantomData;
use std::os::unix::io::RawFd;
@@ -48,20 +47,13 @@ mod ffi {
pub fn writev(fd: RawFd, iov: &[IoVec<&[u8]>]) -> Result<usize> {
let res = unsafe { ffi::writev(fd, iov.as_ptr(), iov.len() as c_int) };
- if res < 0 {
- return Err(Error::Sys(Errno::last()));
- }
-
- return Ok(res as usize)
+ Errno::result(res).map(|r| r as usize)
}
pub fn readv(fd: RawFd, iov: &mut [IoVec<&mut [u8]>]) -> Result<usize> {
let res = unsafe { ffi::readv(fd, iov.as_ptr(), iov.len() as c_int) };
- if res < 0 {
- return Err(Error::Sys(Errno::last()));
- }
- return Ok(res as usize)
+ Errno::result(res).map(|r| r as usize)
}
#[cfg(feature = "preadv_pwritev")]
@@ -70,11 +62,8 @@ pub fn pwritev(fd: RawFd, iov: &[IoVec<&[u8]>],
let res = unsafe {
ffi::pwritev(fd, iov.as_ptr(), iov.len() as c_int, offset)
};
- if res < 0 {
- Err(Error::Sys(Errno::last()))
- } else {
- Ok(res as usize)
- }
+
+ Errno::result(res).map(|r| r as usize)
}
#[cfg(feature = "preadv_pwritev")]
@@ -83,11 +72,8 @@ pub fn preadv(fd: RawFd, iov: &mut [IoVec<&mut [u8]>],
let res = unsafe {
ffi::preadv(fd, iov.as_ptr(), iov.len() as c_int, offset)
};
- if res < 0 {
- Err(Error::Sys(Errno::last()))
- } else {
- Ok(res as usize)
- }
+
+ Errno::result(res).map(|r| r as usize)
}
pub fn pwrite(fd: RawFd, buf: &[u8], offset: off_t) -> Result<usize> {
@@ -95,11 +81,8 @@ pub fn pwrite(fd: RawFd, buf: &[u8], offset: off_t) -> Result<usize> {
ffi::pwrite(fd, buf.as_ptr() as *const c_void, buf.len() as size_t,
offset)
};
- if res < 0 {
- Err(Error::Sys(Errno::last()))
- } else {
- Ok(res as usize)
- }
+
+ Errno::result(res).map(|r| r as usize)
}
pub fn pread(fd: RawFd, buf: &mut [u8], offset: off_t) -> Result<usize>{
@@ -107,11 +90,8 @@ pub fn pread(fd: RawFd, buf: &mut [u8], offset: off_t) -> Result<usize>{
ffi::pread(fd, buf.as_mut_ptr() as *mut c_void, buf.len() as size_t,
offset)
};
- if res < 0 {
- Err(Error::Sys(Errno::last()))
- } else {
- Ok(res as usize)
- }
+
+ Errno::result(res).map(|r| r as usize)
}
#[repr(C)]
diff --git a/src/sys/wait.rs b/src/sys/wait.rs
index 530ef7fa..ab91a848 100644
--- a/src/sys/wait.rs
+++ b/src/sys/wait.rs
@@ -1,6 +1,5 @@
use libc::{pid_t, c_int};
-use errno::Errno;
-use {Error, Result};
+use errno::{Errno, Result};
use sys::signal;
@@ -203,13 +202,10 @@ pub fn waitpid(pid: pid_t, options: Option<WaitPidFlag>) -> Result<WaitStatus> {
let res = unsafe { ffi::waitpid(pid as pid_t, &mut status as *mut c_int, option_bits) };
- if res < 0 {
- Err(Error::Sys(Errno::last()))
- } else if res == 0 {
- Ok(StillAlive)
- } else {
- Ok(decode(res, status))
- }
+ Ok(match try!(Errno::result(res)) {
+ 0 => StillAlive,
+ res => decode(res, status),
+ })
}
pub fn wait() -> Result<WaitStatus> {
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-30 12:52:09 +0000