Add unistd::{access, faccessat}

Author: bugaevc

src/unistd.rs

@@ -1,14 +1,14 @@
 //! Safe wrappers around functions found in libc "unistd.h" header
 
 use {Errno, Error, Result, NixPath};
-use fcntl::{fcntl, OFlag, O_CLOEXEC, FD_CLOEXEC};
+use fcntl::{fcntl, OFlag, AtFlags, O_CLOEXEC, FD_CLOEXEC};
 use fcntl::FcntlArg::F_SETFD;
 use libc::{self, c_char, c_void, c_int, c_uint, size_t, pid_t, off_t, uid_t, gid_t, mode_t};
 use std::mem;
 use std::ffi::{CString, CStr, OsString, OsStr};
 use std::os::unix::ffi::{OsStringExt, OsStrExt};
 use std::os::unix::io::RawFd;
-use std::path::{PathBuf};
+use std::path::PathBuf;
 use void::Void;
 use sys::stat::Mode;
 
@@ -819,6 +819,64 @@ pub fn mkstemp<P: ?Sized + NixPath>(template: &P) -> Result<(RawFd, PathBuf)> {
     Ok((fd, PathBuf::from(pathname)))
 }
 
+libc_bitflags!{
+    pub flags AccessFlags: c_int {
+        R_OK,
+        W_OK,
+        X_OK,
+    }
+}
+
+pub enum AccessMode {
+    F_OK,
+    Flags(AccessFlags),
+}
+
+impl AccessMode {
+    fn to_libc_type(&self) -> c_int {
+        match self {
+            &AccessMode::F_OK => libc::F_OK,
+            &AccessMode::Flags(flags) => flags.bits(),
+        }
+    }
+}
+
+/// Check whether a file exists or whether the current process can access a file.
+///
+/// # Example
+/// ```
+/// use nix::unistd::*;
+///
+/// let devnull_exists = access("/dev/null", AccessMode::F_OK);
+/// assert!(devnull_exists.is_ok());
+/// ```
+pub fn access<P: ?Sized + NixPath>(path: &P, mode: AccessMode) -> Result<()> {
+    let res = try!(path.with_nix_path(|path|
+        unsafe {
+            libc::access(path.as_ptr(), mode.to_libc_type())
+        }
+    ));
+    Errno::result(res).map(drop)
+}
+
+/// Check whether a file exists or whether the current process can access a file,
+/// relative to a directory file descriptor.
+pub fn faccessat<P: ?Sized + NixPath>(dirfd: RawFd,
+                                      path: &P,
+                                      mode: AccessMode,
+                                      flags: AtFlags)
+                                      -> Result<()> {
+    let res = try!(path.with_nix_path(|path|
+        unsafe {
+            libc::faccessat(dirfd,
+                            path.as_ptr(),
+                            mode.to_libc_type(),
+                            flags.bits())
+        }
+    ));
+    Errno::result(res).map(drop)
+}
+
 #[cfg(any(target_os = "linux", target_os = "android"))]
 mod linux {
     use libc::{self, uid_t, gid_t};