add support for dirent family

Author: Mic92

CHANGELOG.md

@@ -8,6 +8,8 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 <!--### Added-->
 - Added `nix::unistd::{openat, fstatat, readlink, readlinkat}`
   ([#497](https://github.com/nix-rust/nix/pull/551))
+- Added `nix::dirent::{opendir, fdopendir, readdir, telldir, seekdir}`
+  ([#558](https://github.com/nix-rust/nix/pull/558))
 
 ### Changed
 - Marked `sys::mman::{ mmap, munmap, madvise, munlock, msync }` as unsafe.

src/dirent.rs

@@ -0,0 +1,93 @@
+use {Result, Error, Errno, NixPath};
+use errno;
+use libc::{self, DIR, c_long};
+use std::convert::{AsRef, Into};
+use std::ffi::CStr;
+use std::mem;
+
+#[cfg(not(any(target_os = "ios", target_os = "macos")))]
+use std::os::unix::io::RawFd;
+
+pub struct Dir(*mut DIR);
+
+impl AsRef<DIR> for Dir {
+    fn as_ref(&self) -> &DIR {
+        unsafe { &*self.0 }
+    }
+}
+
+impl Into<*mut DIR> for Dir {
+    fn into(self) -> *mut DIR {
+        let dirp = self.0;
+        mem::forget(self);
+        dirp
+    }
+}
+
+impl Drop for Dir {
+    fn drop(&mut self) {
+        unsafe { libc::closedir(self.0) };
+    }
+}
+
+pub struct Dirent<'a>(&'a libc::dirent);
+
+impl<'a> Dirent<'a> {
+    pub fn name(&self) -> &CStr {
+        unsafe{
+            CStr::from_ptr(self.0.d_name.as_ptr())
+        }
+    }
+
+    pub fn ino(&self) -> libc::ino_t {
+        self.0.d_ino
+    }
+}
+
+impl<'a> AsRef<libc::dirent> for Dirent<'a> {
+    fn as_ref(&self) -> &libc::dirent {
+        self.0
+    }
+}
+
+pub fn opendir<P: ?Sized + NixPath>(name: &P) -> Result<Dir> {
+    let dirp = try!(name.with_nix_path(|cstr| unsafe { libc::opendir(cstr.as_ptr()) }));
+    if dirp.is_null() {
+        Err(Error::last().into())
+    } else {
+        Ok(Dir(dirp))
+    }
+}
+
+#[cfg(not(any(target_os = "ios", target_os = "macos")))]
+pub fn fdopendir(fd: RawFd) -> Result<Dir> {
+    let dirp = unsafe { libc::fdopendir(fd) };
+    if dirp.is_null() {
+        Err(Error::last().into())
+    } else {
+        Ok(Dir(dirp))
+    }
+}
+
+pub fn readdir<'a>(dir: &'a mut Dir) -> Result<Option<Dirent>> {
+    let dirent = unsafe {
+        Errno::clear();
+        libc::readdir(dir.0)
+    };
+    if dirent.is_null() {
+        match Errno::last() {
+            errno::UnknownErrno => Ok(None),
+            _ => Err(Error::last().into()),
+        }
+    } else {
+        Ok(Some(Dirent(unsafe { &*dirent })))
+    }
+}
+
+pub fn seekdir<'a>(dir: &'a mut Dir, loc: c_long) {
+    unsafe { libc::seekdir(dir.0, loc) };
+}
+
+pub fn telldir<'a>(dir: &'a mut Dir) -> c_long {
+    unsafe { libc::telldir(dir.0) }
+}

src/lib.rs

@@ -34,6 +34,7 @@ pub mod libc {
 pub use libc::{c_int, c_void};
 pub use errno::Errno;
 
+pub mod dirent;
 pub mod errno;
 pub mod features;
 pub mod fcntl;

test/test.rs

@@ -8,6 +8,7 @@ extern crate tempfile;
 extern crate nix_test as nixtest;
 
 mod sys;
+mod test_dirent;
 mod test_fcntl;
 mod test_net;
 mod test_nix_path;

test/test_dirent.rs

@@ -0,0 +1,42 @@
+use nix::dirent::{self, opendir, readdir, seekdir, telldir, Dir};
+use std::path::Path;
+use tempdir::TempDir;
+
+fn test_readdir<OPEN>(open_fn: OPEN)
+    where OPEN: Fn(&Path) -> Dir
+{
+    let tempdir = TempDir::new("nix-test_readdir")
+        .unwrap_or_else(|e| panic!("tempdir failed: {}", e));
+    let mut dir = open_fn(tempdir.path());
+    let letter1 = readdir(&mut dir)
+                       .unwrap()
+                       .unwrap()
+                       .name()
+                       .to_bytes()[0];
+    assert_eq!(letter1, '.' as u8);
+
+    let pos = telldir(&mut dir);
+    seekdir(&mut dir, pos); // no-op
+
+    let letter2 = readdir(&mut dir)
+                       .unwrap()
+                       .unwrap()
+                       .name()
+                       .to_bytes()[0];
+    assert_eq!(letter2, '.' as u8);
+
+    assert!(readdir(&mut dir).unwrap().is_none());
+}
+
+#[test]
+fn test_opendir() {
+    test_readdir(|path| opendir(path).unwrap());
+}
+
+#[cfg(not(any(target_os = "ios", target_os = "macos")))]
+#[test]
+fn test_fdopendir() {
+    use std::os::unix::io::IntoRawFd;
+    use std::fs::File;
+    test_readdir(|path| dirent::fdopendir(File::open(path).unwrap().into_raw_fd()).unwrap());
+}