Further SockAddr & NixPath cleanup

Author: carllerche

src/fcntl.rs

@@ -1,6 +1,6 @@
-use libc::mode_t;
+use {NixError, NixResult, NixPath, AsExtStr};
 use errno::Errno;
-use {NixError, NixResult, NixPath};
+use libc::mode_t;
 use sys::stat::Mode;
 
 pub use self::consts::*;
@@ -71,11 +71,9 @@ mod ffi {
     }
 }
 
-pub fn open<P: NixPath>(path: P, oflag: OFlag, mode: Mode) -> NixResult<Fd> {
-    let fd = try!(path.with_nix_path(|ptr| {
-        unsafe {
-            ffi::open(ptr, oflag.bits(), mode.bits() as mode_t)
-        }
+pub fn open<P: ?Sized + NixPath>(path: &P, oflag: OFlag, mode: Mode) -> NixResult<Fd> {
+    let fd = try!(path.with_nix_path(|osstr| {
+        unsafe { ffi::open(osstr.as_ext_str(), oflag.bits(), mode.bits() as mode_t) }
     }));
 
     if fd < 0 {

src/lib.rs

@@ -43,3 +43,23 @@ pub mod sys;
 
 #[cfg(unix)]
 pub mod unistd;
+
+/*
+ *
+ * ===== Impl utilities =====
+ *
+ */
+
+use std::ffi::OsStr;
+use std::os::unix::OsStrExt;
+
+/// Converts a value to an external (FFI) string representation
+trait AsExtStr {
+    fn as_ext_str(&self) -> *const libc::c_char;
+}
+
+impl AsExtStr for OsStr {
+    fn as_ext_str(&self) -> *const libc::c_char {
+        self.as_bytes().as_ptr() as *const libc::c_char
+    }
+}

src/mount.rs

@@ -66,7 +66,7 @@ mod ffi {
 }
 
 // XXX: Should `data` be a `NixPath` here?
-pub fn mount<P1: NixPath, P2: NixPath, P3: NixPath, P4: NixPath>(
+pub fn mount<P1: ?Sized + NixPath, P2: ?Sized + NixPath, P3: ?Sized + NixPath, P4: ?Sized + NixPath>(
         source: Option<P1>,
         target: P2,
         fstype: Option<P3>,
@@ -94,15 +94,15 @@ pub fn mount<P1: NixPath, P2: NixPath, P3: NixPath, P4: NixPath>(
     return from_ffi(res);
 }
 
-pub fn umount<P: NixPath>(target: P) -> NixResult<()> {
+pub fn umount<P: ?Sized + NixPath>(target: P) -> NixResult<()> {
     let res = try!(target.with_nix_path(|ptr| {
         unsafe { ffi::umount(ptr) }
     }));
 
     from_ffi(res)
 }
 
-pub fn umount2<P: NixPath>(target: P, flags: MntFlags) -> NixResult<()> {
+pub fn umount2<P: ?Sized + NixPath>(target: P, flags: MntFlags) -> NixResult<()> {
     let res = try!(target.with_nix_path(|ptr| {
         unsafe { ffi::umount2(ptr, flags.bits) }
     }));

src/nix.rs

@@ -1,5 +1,8 @@
 use libc;
-use std;
+use std::ffi::{OsStr, AsOsStr};
+use std::os::unix::OsStrExt;
+use std::path::{Path, PathBuf};
+use std::slice::bytes;
 
 use errno::{Errno, EINVAL};
 
@@ -23,13 +26,12 @@ impl NixError {
 
 pub trait NixPath {
     fn with_nix_path<T, F>(&self, f: F) -> Result<T, NixError>
-        where F: FnOnce(*const libc::c_char) -> T;
+        where F: FnOnce(&OsStr) -> T;
 }
 
-impl<'a> NixPath for &'a [u8] {
+impl NixPath for [u8] {
     fn with_nix_path<T, F>(&self, f: F) -> Result<T, NixError>
-        where F: FnOnce(*const libc::c_char) -> T
-    {
+            where F: FnOnce(&OsStr) -> T {
         // TODO: Extract this size as a const
         let mut buf = [0u8; 4096];
 
@@ -40,21 +42,24 @@ impl<'a> NixPath for &'a [u8] {
         match self.position_elem(&0) {
             Some(_) => Err(NixError::InvalidPath),
             None => {
-                std::slice::bytes::copy_memory(&mut buf, self);
-                Ok(f(buf.as_ptr() as *const libc::c_char))
+                bytes::copy_memory(&mut buf, self);
+                Ok(f(<OsStr as OsStrExt>::from_bytes(&buf[..self.len()])))
             }
         }
     }
 }
 
-impl<P: NixPath> NixPath for Option<P> {
+impl NixPath for Path {
     fn with_nix_path<T, F>(&self, f: F) -> Result<T, NixError>
-        where F: FnOnce(*const libc::c_char) -> T
-    {
-        match *self {
-            Some(ref some) => some.with_nix_path(f),
-            None           => b"".with_nix_path(f)
-        }
+            where F: FnOnce(&OsStr) -> T {
+        Ok(f(self.as_os_str()))
+    }
+}
+
+impl NixPath for PathBuf {
+    fn with_nix_path<T, F>(&self, f: F) -> Result<T, NixError>
+            where F: FnOnce(&OsStr) -> T {
+        Ok(f(self.as_os_str()))
     }
 }
 
@@ -63,5 +68,6 @@ pub fn from_ffi(res: libc::c_int) -> NixResult<()> {
     if res != 0 {
         return Err(NixError::Sys(Errno::last()));
     }
+
     Ok(())
 }

src/sys/mman.rs

@@ -1,8 +1,8 @@
+use {NixError, NixResult, NixPath, AsExtStr};
 use errno::Errno;
 use fcntl::{Fd, OFlag};
 use libc::{c_void, size_t, off_t, mode_t};
 use sys::stat::Mode;
-use {NixError, NixResult, NixPath};
 
 pub use self::consts::*;
 
@@ -175,10 +175,10 @@ pub fn msync(addr: *const c_void, length: size_t, flags: MmapSync) -> NixResult<
     }
 }
 
-pub fn shm_open<P: NixPath>(name: P, flag: OFlag, mode: Mode) -> NixResult<Fd> {
-    let ret = try!(name.with_nix_path(|ptr| {
+pub fn shm_open<P: ?Sized + NixPath>(name: &P, flag: OFlag, mode: Mode) -> NixResult<Fd> {
+    let ret = try!(name.with_nix_path(|osstr| {
         unsafe {
-            ffi::shm_open(ptr, flag.bits(), mode.bits() as mode_t)
+            ffi::shm_open(osstr.as_ext_str(), flag.bits(), mode.bits() as mode_t)
         }
     }));
 
@@ -189,9 +189,9 @@ pub fn shm_open<P: NixPath>(name: P, flag: OFlag, mode: Mode) -> NixResult<Fd> {
     }
 }
 
-pub fn shm_unlink<P: NixPath>(name: P) -> NixResult<()> {
-    let ret = try!(name.with_nix_path(|ptr| {
-        unsafe { ffi::shm_unlink(ptr) }
+pub fn shm_unlink<P: ?Sized + NixPath>(name: &P) -> NixResult<()> {
+    let ret = try!(name.with_nix_path(|osstr| {
+        unsafe { ffi::shm_unlink(osstr.as_ext_str()) }
     }));
 
     if ret < 0 {