Null terminated slices for exec

Author: arcnmx

src/lib.rs

@@ -32,6 +32,8 @@ pub mod libc {
 pub use libc::{c_int, c_void};
 pub use errno::Errno;
 
+pub mod null_terminated;
+
 pub mod errno;
 pub mod features;
 pub mod fcntl;

src/null_terminated.rs

@@ -0,0 +1,83 @@
+use std::ops::{Deref, DerefMut};
+use std::ffi::CStr;
+use std::mem::transmute;
+use std::iter;
+use libc::c_char;
+
+pub struct NullTerminatedSlice<T> {
+    inner: [Option<T>],
+}
+
+impl<T> NullTerminatedSlice<T> {
+    pub fn from_slice(slice: &[Option<T>]) -> Option<&Self> {
+        if slice.last().map(Option::is_none).unwrap_or(false) {
+            Some(unsafe { Self::from_slice_unchecked(slice) })
+        } else {
+            None
+        }
+    }
+
+    pub fn from_slice_mut(slice: &mut [Option<T>]) -> Option<&mut Self> {
+        if slice.last().map(Option::is_none).unwrap_or(false) {
+            Some(unsafe { Self::from_slice_mut_unchecked(slice) })
+        } else {
+            None
+        }
+    }
+
+    pub unsafe fn from_slice_unchecked(slice: &[Option<T>]) -> &Self {
+        transmute(slice)
+    }
+
+    pub unsafe fn from_slice_mut_unchecked(slice: &mut [Option<T>]) -> &mut Self {
+        transmute(slice)
+    }
+}
+
+impl<'a, U: Sized> NullTerminatedSlice<&'a U> {
+    pub fn as_ptr(&self) -> *const *const U {
+        self.inner.as_ptr() as *const _
+    }
+}
+
+impl<T> Deref for NullTerminatedSlice<T> {
+    type Target = [Option<T>];
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner[..self.inner.len() - 1]
+    }
+}
+
+impl<T> DerefMut for NullTerminatedSlice<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        let len = self.inner.len();
+        &mut self.inner[..len - 1]
+    }
+}
+
+pub trait BorrowNullTerminatedSlice<T> {
+    fn borrow_null_terminated_slice<R, F: FnOnce(&NullTerminatedSlice<&T>) -> R>(self, f: F) -> R;
+}
+
+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 {
+        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()
+            .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)
+    }
+}

src/unistd.rs

@@ -1,11 +1,12 @@
 //! Standard symbolic constants and types
 //!
 use {Errno, Error, Result, NixPath};
+use null_terminated::BorrowNullTerminatedSlice;
 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};
 use std::mem;
-use std::ffi::CString;
+use std::ffi::CStr;
 use std::os::unix::io::RawFd;
 
 #[cfg(any(target_os = "linux", target_os = "android"))]
@@ -120,47 +121,39 @@ pub fn chown<P: ?Sized + NixPath>(path: &P, owner: Option<uid_t>, group: Option<
     Errno::result(res).map(drop)
 }
 
-fn to_exec_array(args: &[CString]) -> Vec<*const c_char> {
-    use std::ptr;
-    use libc::c_char;
-
-    let mut args_p: Vec<*const c_char> = args.iter().map(|s| s.as_ptr()).collect();
-    args_p.push(ptr::null());
-    args_p
-}
-
 #[inline]
-pub fn execv(path: &CString, argv: &[CString]) -> Result<()> {
-    let args_p = to_exec_array(argv);
-
-    unsafe {
-        libc::execv(path.as_ptr(), args_p.as_ptr())
-    };
+pub fn execv<A: BorrowNullTerminatedSlice<c_char>>(path: &CStr, argv: A) -> Result<()> {
+    argv.borrow_null_terminated_slice(|args_p| {
+        unsafe {
+            libc::execv(path.as_ptr(), args_p.as_ptr())
+        };
 
-    Err(Error::Sys(Errno::last()))
+        Err(Error::Sys(Errno::last()))
+    })
 }
 
 #[inline]
-pub fn execve(path: &CString, args: &[CString], env: &[CString]) -> Result<()> {
-    let args_p = to_exec_array(args);
-    let env_p = to_exec_array(env);
-
-    unsafe {
-        libc::execve(path.as_ptr(), args_p.as_ptr(), env_p.as_ptr())
-    };
-
-    Err(Error::Sys(Errno::last()))
+pub fn execve<A: BorrowNullTerminatedSlice<c_char>, E: BorrowNullTerminatedSlice<c_char>>(path: &CStr, args: A, env: E) -> Result<()> {
+    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()))
+        })
+    })
 }
 
 #[inline]
-pub fn execvp(filename: &CString, args: &[CString]) -> Result<()> {
-    let args_p = to_exec_array(args);
-
-    unsafe {
-        libc::execvp(filename.as_ptr(), args_p.as_ptr())
-    };
+pub fn execvp<A: BorrowNullTerminatedSlice<c_char>>(filename: &CStr, args: A) -> Result<()> {
+    args.borrow_null_terminated_slice(|args_p| {
+        unsafe {
+            libc::execvp(filename.as_ptr(), args_p.as_ptr())
+        };
 
-    Err(Error::Sys(Errno::last()))
+        Err(Error::Sys(Errno::last()))
+    })
 }
 
 pub fn daemon(nochdir: bool, noclose: bool) -> Result<()> {
@@ -378,9 +371,6 @@ mod linux {
     use sys::syscall::{syscall, SYSPIVOTROOT};
     use {Errno, Result, NixPath};
 
-    #[cfg(feature = "execvpe")]
-    use std::ffi::CString;
-
     pub fn pivot_root<P1: ?Sized + NixPath, P2: ?Sized + NixPath>(
             new_root: &P1, put_old: &P2) -> Result<()> {
         let res = try!(try!(new_root.with_nix_path(|new_root| {
@@ -394,7 +384,6 @@ mod linux {
         Errno::result(res).map(drop)
     }
 
-    #[inline]
     #[cfg(feature = "execvpe")]
     pub fn execvpe(filename: &CString, args: &[CString], env: &[CString]) -> Result<()> {
         use std::ptr;