Converting output of libc::getcwd into a string - rust

Question

I'd like to print out the result of libc::getcwd. My issue is that to create getcwd takes an i8 (c_char) buffer, whereas String::from_utf8 needs a u8 buffer. I started with:
static BUF_BYTES: usize = 4096;
fn main() {
unsafe {
let mut buf: Vec<i8> = Vec::with_capacity(BUF_BYTES as usize);
libc::getcwd(buf.as_mut_ptr(), buf.len());
let s = String::from_utf8(buf).expect("Found invalid UTF-8");
println!("result: {}", s);
}
}
Which produces the error:
14:32 error: mismatched types:
expected `std::vec::Vec<u8>`,
found `std::vec::Vec<i8>` [E0308]
Thanks to the comments, I changed the buf into a Vec<u8> and cast it to a c_char buffer in the getcwd call:
let mut buf: Vec<u8> = Vec::with_capacity(BUF_BYTES as usize);
libc::getcwd(buf.as_mut_ptr() as *mut c_char, buf.len());
This compiles but now, when printing the string it is empty (length: 0)
I found that getcwd returns NULL (libc::getcwd(...).is_null() is true), reading the last error via external crate errno (why is this a separate crate to libc?) reveals that getcwd fails with "Invalid argument". The source of the problem seems that buf.len() returns 0.

Answer 1

In most cases, you should just use env::current_dir. This correctly handles all the platform-specifics for you, such as the "other" encodings mentioned in the comments.
C strings are kind of terrible. getcwd fills a buffer of some length, but doesn't tell you where it ends; you have to manually find the terminating NUL byte.
extern crate libc;
static BUF_BYTES: usize = 4096;
fn main() {
let buf = unsafe {
let mut buf = Vec::with_capacity(BUF_BYTES);
let res = libc::getcwd(buf.as_mut_ptr() as *mut i8, buf.capacity());
if res.is_null() {
panic!("Not long enough");
}
let mut len = 0;
while *buf.as_mut_ptr().offset(len as isize) != 0 { len += 1 }
buf.set_len(len);
buf
};
let s = String::from_utf8(buf).expect("Found invalid UTF-8");
println!("result: {}", s);
}
seems that buf.len() returns 0
Yes, the length is zero because no one told the vector that data was added. Vectors are comprised of three parts - a pointer to data, a length, and a capacity.
The capacity is how much memory is available, the size is how much is used. When treating the vector as a blob to store data into, you want to use the capacity. You then need to inform the vector how many of those bytes were used, so that String::from_utf8 knows where the end is.
You'll note that I changed the scope of unsafe to only include the truly unsafe aspects and the code that makes that code actually safe.
In fact, you could just copy the implementation of env::current_dir for Unix-like systems. It handles the failure cases much nicer and uses the proper types (paths aren't strings). Of course, it's even easier to just call env::current_dir. ^_^
fyi: I ended up with this
extern crate libc;
use std::ffi::CStr;
use std::io;
use std::str;
static BUF_BYTES: usize = 4096;
fn main() {
let buf = unsafe {
let mut buf = Vec::with_capacity(BUF_BYTES);
let ptr = buf.as_mut_ptr() as *mut libc::c_char;
if libc::getcwd(ptr, buf.capacity()).is_null() {
panic!(io::Error::last_os_error());
}
CStr::from_ptr(ptr).to_bytes()
};
println!("result: {}", str::from_utf8(buf).unwrap());
}
This is unsafe and will lead to crashes (in the best case) or silent memory corruption or worse.
When a block ends, any variables within it will be dropped. In this case, the unsafe block creates buf, takes a pointer to it, makes a CStr with the pointer, then frees the Vec, invalidating the pointer. It then returns that CStr containing an invalid reference from the block.
Something like this is better:
extern crate libc;
use std::ffi::{CStr, CString};
use std::io;
use std::str;
static BUF_BYTES: usize = 4096;
fn main() {
let buf = unsafe {
// Allocate some space to store the result
let mut buf = Vec::with_capacity(BUF_BYTES);
// Call the function, panicking if it fails
let ptr = buf.as_mut_ptr() as *mut libc::c_char;
if libc::getcwd(ptr, buf.capacity()).is_null() {
panic!(io::Error::last_os_error());
}
// Find the first NUL and inform the vector of that
let s = CStr::from_ptr(ptr);
buf.set_len(s.to_bytes().len());
// Transfer ownership of the Vec to a CString, ensuring there are no interior NULs
CString::new(buf)
};
let s = buf.expect("Not a C string").into_string().expect("Not UTF-8");
println!("result: {}", s);
}
I wonder why this has actually worked
Likely because nothing changed the memory before you attempted to access it. In a heavily multithreaded environment, I could see more issues arising.
why is it possible to have two mutable references to the vector? First as mut buf and then as ptr = buf.as_mut_ptr(). The ownership has not moved, has it? Otherwise, why is it possible to call buf.capacity()
You don't actually have two references. buf owns the value, then you get a mutable pointer. There is no compiler protection for pointers, which is part of the reason that an unsafe block is needed