Function with_c_str_slow_path

src/path/arg.rs:991–1050

(bytes: &[u8], f: F)

#[allow(unsafe_code, clippy::int_plus_one)]
#[cold]
fn with_c_str_slow_path<T, F>(bytes: &[u8], f: F) -> io::Result<T>
where
    F: FnOnce(&CStr) -> io::Result<T>,
{
    #[cfg(feature = "alloc")]
    {
        f(&CString::new(bytes).map_err(|_cstr_err| io::Errno::INVAL)?)
    }

    #[cfg(not(feature = "alloc"))]
    {
        #[cfg(all(
            libc,
            not(any(
                target_os = "espidf",
                target_os = "horizon",
                target_os = "hurd",
                target_os = "vita",
                target_os = "wasi"
            ))
        ))]
        const LARGE_PATH_BUFFER_SIZE: usize = libc::PATH_MAX as usize;
        #[cfg(linux_raw)]
        const LARGE_PATH_BUFFER_SIZE: usize = linux_raw_sys::general::PATH_MAX as usize;
        #[cfg(any(
            target_os = "espidf",
            target_os = "horizon",
            target_os = "hurd",
            target_os = "vita",
            target_os = "wasi"
        ))]
        const LARGE_PATH_BUFFER_SIZE: usize = 4096 as usize; // TODO: upstream this

        // Taken from
        // <https://github.com/rust-lang/rust/blob/a00f8ba7fcac1b27341679c51bf5a3271fa82df3/library/std/src/sys/common/small_c_string.rs>
        let mut buf = MaybeUninit::<[u8; LARGE_PATH_BUFFER_SIZE]>::uninit();
        let buf_ptr = buf.as_mut_ptr().cast::<u8>();

        // This helps test our safety condition below.
        if bytes.len() + 1 > LARGE_PATH_BUFFER_SIZE {
            return Err(io::Errno::NAMETOOLONG);
        }

        // SAFETY: `bytes.len() < LARGE_PATH_BUFFER_SIZE` which means we have
        // space for `bytes.len() + 1` `u8`s:
        unsafe {
            ptr::copy_nonoverlapping(bytes.as_ptr(), buf_ptr, bytes.len());
            buf_ptr.add(bytes.len()).write(b'\0');
        }

        // SAFETY: We just wrote the bytes above and they will remain valid for
        // the duration of `f` because `buf` doesn't get dropped until the end
        // of the function.
        match CStr::from_bytes_with_nul(unsafe { slice::from_raw_parts(buf_ptr, bytes.len() + 1) })
        {
            Ok(s) => f(s),
            Err(_) => Err(io::Errno::INVAL),
        }