IntoRef

Author: arcnmx

src/null_terminated.rs

@@ -4,6 +4,12 @@ use std::mem::transmute;
 use std::iter;
 use libc::c_char;
 
+pub trait IntoRef<'a, T: ?Sized> {
+    type Target: 'a + AsRef<T>;
+
+    fn into_ref(self) -> Self::Target;
+}
+
 pub struct NullTerminatedSlice<T> {
     inner: [Option<T>],
 }
@@ -55,29 +61,80 @@ impl<T> DerefMut for NullTerminatedSlice<T> {
     }
 }
 
-pub trait BorrowNullTerminatedSlice<T> {
-    fn borrow_null_terminated_slice<R, F: FnOnce(&NullTerminatedSlice<&T>) -> R>(self, f: F) -> R;
+impl<T> AsRef<NullTerminatedSlice<T>> for NullTerminatedSlice<T> {
+    fn as_ref(&self) -> &Self {
+        self
+    }
+}
+
+pub struct NullTerminatedVec<T> {
+    inner: Vec<Option<T>>,
+}
+
+impl<T> NullTerminatedVec<T> {
+    pub fn from_vec(vec: Vec<Option<T>>) -> Option<Self> {
+        if vec.last().map(Option::is_none).unwrap_or(false) {
+            Some(unsafe { Self::from_vec_unchecked(vec) })
+        } else {
+            None
+        }
+    }
+
+    pub unsafe fn from_vec_unchecked(vec: Vec<Option<T>>) -> Self {
+        NullTerminatedVec {
+            inner: vec,
+        }
+    }
+}
+
+impl<T> Deref for NullTerminatedVec<T> {
+    type Target = NullTerminatedSlice<T>;
+
+    fn deref(&self) -> &Self::Target {
+        unsafe {
+            NullTerminatedSlice::from_slice_unchecked(&self.inner)
+        }
+    }
+}
+
+impl<T> DerefMut for NullTerminatedVec<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        unsafe {
+            NullTerminatedSlice::from_slice_mut_unchecked(&mut self.inner)
+        }
+    }
+}
+
+impl<T> AsRef<NullTerminatedSlice<T>> for NullTerminatedVec<T> {
+    fn as_ref(&self) -> &NullTerminatedSlice<T> {
+        self
+    }
 }
 
-impl<T: AsRef<CStr>, I: IntoIterator<Item=T>> BorrowNullTerminatedSlice<c_char> for I {
-    fn borrow_null_terminated_slice<R, F: FnOnce(&NullTerminatedSlice<&c_char>) -> R>(self, f: F) -> R {
+impl<'a, T: 'a> IntoRef<'a, NullTerminatedSlice<&'a T>> for &'a NullTerminatedSlice<&'a T> {
+    type Target = &'a NullTerminatedSlice<&'a T>;
+
+    fn into_ref(self) -> Self::Target {
+        self
+    }
+}
+
+impl<'a, T: AsRef<CStr> + 'a, I: IntoIterator<Item=T>> IntoRef<'a, NullTerminatedSlice<&'a c_char>> for I {
+    type Target = NullTerminatedVec<&'a c_char>;
+
+    fn into_ref(self) -> Self::Target {
         fn cstr_char<'a, S: AsRef<CStr> + 'a>(s: S) -> &'a c_char {
             unsafe {
                 &*s.as_ref().as_ptr()
             }
         }
 
-        let values: Vec<_> = self.into_iter()
+        let terminated = self.into_iter()
             .map(cstr_char)
             .map(Some).chain(iter::once(None)).collect();
-        let terminated = unsafe { NullTerminatedSlice::from_slice_unchecked(&values[..]) };
 
-        f(terminated)
-    }
-}
-
-impl<'a, T: 'a> BorrowNullTerminatedSlice<T> for &'a NullTerminatedSlice<&'a T> {
-    fn borrow_null_terminated_slice<R, F: FnOnce(&NullTerminatedSlice<&T>) -> R>(self, f: F) -> R {
-        f(self)
+        unsafe {
+            NullTerminatedVec::from_vec_unchecked(terminated)
+        }
     }
 }

src/unistd.rs

@@ -1,7 +1,7 @@
 //! Standard symbolic constants and types
 //!
 use {Errno, Error, Result, NixPath};
-use null_terminated::BorrowNullTerminatedSlice;
+use null_terminated::{IntoRef, NullTerminatedSlice};
 use fcntl::{fcntl, OFlag, O_NONBLOCK, O_CLOEXEC, FD_CLOEXEC};
 use fcntl::FcntlArg::{F_SETFD, F_SETFL};
 use libc::{self, c_char, c_void, c_int, c_uint, size_t, pid_t, off_t, uid_t, gid_t};
@@ -123,38 +123,37 @@ pub fn chown<P: ?Sized + NixPath>(path: &P, owner: Option<uid_t>, group: Option<
 }
 
 #[inline]
-pub fn execv<A: BorrowNullTerminatedSlice<c_char>>(path: &CStr, argv: A) -> Result<Void> {
-    argv.borrow_null_terminated_slice(|args_p| {
-        unsafe {
-            libc::execv(path.as_ptr(), args_p.as_ptr())
-        };
+pub fn execv<'a, A: IntoRef<'a, NullTerminatedSlice<&'a c_char>>>(path: &CStr, argv: A) -> Result<Void> {
+    let argv = argv.into_ref();
 
-        Err(Error::Sys(Errno::last()))
-    })
+    unsafe {
+        libc::execv(path.as_ptr(), argv.as_ref().as_ptr())
+    };
+
+    Err(Error::Sys(Errno::last()))
 }
 
 #[inline]
-pub fn execve<A: BorrowNullTerminatedSlice<c_char>, E: BorrowNullTerminatedSlice<c_char>>(path: &CStr, args: A, env: E) -> Result<Void> {
-    args.borrow_null_terminated_slice(|args_p| {
-        env.borrow_null_terminated_slice(|env_p| {
-            unsafe {
-                libc::execve(path.as_ptr(), args_p.as_ptr(), env_p.as_ptr())
-            };
-
-            Err(Error::Sys(Errno::last()))
-        })
-    })
+pub fn execve<'a, 'e, A: IntoRef<'a, NullTerminatedSlice<&'a c_char>>, E: IntoRef<'e, NullTerminatedSlice<&'e c_char>>>(path: &CStr, args: A, env: E) -> Result<Void> {
+    let args = args.into_ref();
+    let env = env.into_ref();
+
+    unsafe {
+        libc::execve(path.as_ptr(), args.as_ref().as_ptr(), env.as_ref().as_ptr())
+    };
+
+    Err(Error::Sys(Errno::last()))
 }
 
 #[inline]
-pub fn execvp<A: BorrowNullTerminatedSlice<c_char>>(filename: &CStr, args: A) -> Result<Void> {
-    args.borrow_null_terminated_slice(|args_p| {
-        unsafe {
-            libc::execvp(filename.as_ptr(), args_p.as_ptr())
-        };
+pub fn execvp<'a, A: IntoRef<'a, NullTerminatedSlice<&'a c_char>>>(filename: &CStr, args: A) -> Result<Void> {
+    let args = args.into_ref();
 
-        Err(Error::Sys(Errno::last()))
-    })
+    unsafe {
+        libc::execvp(filename.as_ptr(), args.as_ref().as_ptr())
+    };
+
+    Err(Error::Sys(Errno::last()))
 }
 
 pub fn daemon(nochdir: bool, noclose: bool) -> Result<()> {