将libc :: getcwd的输出转换为字符串

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