Add methods for handing CStrings back and forth to C

Author: shepmaster

src/libstd/ffi/c_str.rs

@@ -200,6 +200,38 @@ impl CString {
         CString { inner: v }
     }
 
+    /// Retakes ownership of a CString that was transferred to C.
+    ///
+    /// The only appropriate argument is a pointer obtained by calling
+    /// `into_raw`.
+    #[unstable(feature = "c_str_memory", reason = "recently added")]
+    pub unsafe fn from_raw(ptr: *const libc::c_char) -> CString {
+        let len = libc::strlen(ptr);
+        let len_with_nul = len as usize + 1;
+        let vec = Vec::from_raw_parts(ptr as *mut u8, len_with_nul, len_with_nul);
+        CString::from_vec_unchecked(vec)
+    }
+
+    /// Transfers ownership of the string to a C caller.
+    ///
+    /// The pointer must be returned to Rust and reconstituted using
+    /// `from_raw` to be properly deallocated. Specifically, one
+    /// should *not* use the standard C `free` function to deallocate
+    /// this string.
+    ///
+    /// Failure to call `from_raw` will lead to a memory leak.
+    #[unstable(feature = "c_str_memory", reason = "recently added")]
+    pub fn into_raw(self) -> *const libc::c_char {
+        // Resize the vector to fit - we need the capacity to be
+        // determinable from the string length, and shrinking to fit
+        // is the only way to be sure.
+        let mut vec = self.inner;
+        vec.shrink_to_fit();
+        let ptr = vec.as_ptr() as *const libc::c_char;
+        mem::forget(vec);
+        ptr
+    }
+
     /// Returns the contents of this `CString` as a slice of bytes.
     ///
     /// The returned slice does **not** contain the trailing nul separator and