New: clone_dirfd() may fix #34, ADD: FdType machinery, libc_ok()

* With FdType/fd_type() one can determine the kind of an underlying file descriptor.
  Lite descriptors are implemented only in Linux (for now).
  When O_DIRECTORY is supported it uses fcntl() in favo over stat()

* clone_dirfd() tries to do 'the right thing' for duplicating FD's

* libc_ok() is a simple wraper for libc calls that return -1 on error, I will refactor the
  code in the next commits to make use of that more.

Please test this! So far it works for me on Linux.

Author: cehteh

src/dir.rs

@@ -511,12 +511,78 @@ impl Dir {
 
     /// Creates a new independently owned handle to the underlying directory.
     pub fn try_clone(&self) -> io::Result<Self> {
-        let fd = unsafe { libc::dup(self.0) };
-        if fd == -1 {
-            Err(io::Error::last_os_error())
+        Ok(Dir(clone_dirfd(self.0)?))
+    }
+
+    //TODO(cehteh): clone/conversion full<->lite
+}
+
+const CURRENT_DIRECTORY: [libc::c_char; 2] = [b'.' as libc::c_char, 0];
+
+fn clone_dirfd(fd: libc::c_int) -> io::Result<libc::c_int> {
+    unsafe {
+        match fd_type(fd)? {
+            FdType::NormalDir => libc_ok(libc::openat(
+                fd,
+                &CURRENT_DIRECTORY as *const libc::c_char,
+                BASE_OPEN_FLAGS,
+            )),
+            #[cfg(target_os = "linux")]
+            FdType::LiteDir => libc_ok(libc::dup(fd)),
+            _ => Err(io::Error::from_raw_os_error(libc::ENOTDIR)),
+        }
+    }
+}
+
+enum FdType {
+    NormalDir,
+    LiteDir,
+    Other,
+}
+
+// OSes with O_DIRECTORY can use fcntl()
+// Linux hash O_PATH
+#[cfg(target_os = "linux")]
+fn fd_type(fd: libc::c_int) -> io::Result<FdType> {
+    let flags = unsafe { libc_ok(libc::fcntl(fd, libc::F_GETFL))? };
+    if flags & libc::O_DIRECTORY != 0 {
+        if flags & libc::O_PATH != 0 {
+            Ok(FdType::LiteDir)
         } else {
-            unsafe { Self::from_raw_fd_checked(fd) }
+            Ok(FdType::NormalDir)
         }
+    } else {
+        Ok(FdType::Other)
+    }
+}
+
+#[cfg(target_os = "freebsd")]
+fn fd_type(fd: libc::c_int) -> io::Result<FdType> {
+    let flags = unsafe { libc_ok(libc::fcntl(fd, libc::F_GETFL))? };
+    if flags & libc::O_DIRECTORY != 0 {
+        Ok(FdType::NormalDir)
+    } else {
+        Ok(FdType::Other)
+    }
+}
+
+// OSes without O_DIRECTORY use stat()
+#[cfg(not(any(target_os = "linux", target_os = "freebsd")))]
+fn fd_type(fd: libc::c_int) -> io::Result<DirType> {
+    let mut stat = mem::zeroed(); // TODO(cehteh): uninit
+    unsafe { libc_ok(libc::fstat(fd, &mut stat))? };
+    match stat.st_mode & libc::S_IFMT {
+        libc::S_IFDIR => Ok(FdType::NormalDir),
+        _ => Ok(FdType::Other),
+    }
+}
+
+#[inline]
+fn libc_ok(ret: libc::c_int) -> io::Result<libc::c_int> {
+    if ret != -1 {
+        Ok(ret)
+    } else {
+        Err(io::Error::last_os_error())
     }
 }