MaybeUninit<T> & Sound Buffer Initialization

The Danger of mem::uninitialized()

Historically, developers wrote let x: T = std::mem::uninitialized(); to allocate stack memory before reading into it from a socket or file. In modern Rust, mem::uninitialized is deprecated and fundamentally instant Undefined Behavior for types that possess invalid bit patterns (e.g., references, bool which must be 0 or 1, or non-nullable types).

Sound Initialization with MaybeUninit

MaybeUninit<T> instructs the compiler that the memory location may contain arbitrary uninitialized bits without violating any type invariants. Crucially, when reading from a file descriptor, you must only assume initialization for the exact byte slice actually populated by the kernel, never the uninitialized tail:

use std::mem::MaybeUninit;

pub fn read_packet_zero_copy(fd: i32) -> Result, std::io::Error> {
    // Sound: Memory is uninitialized, but explicitly tracked as MaybeUninit
    // In Rust 1.79+, initialized safely with const block expression:
    let mut buffer: [MaybeUninit; 4096] = [const { MaybeUninit::uninit() }; 4096];

    let bytes_read = unsafe {
        libc::read(
            fd,
            buffer.as_mut_ptr() as *mut libc::c_void,
            buffer.len(),
        )
    };

    if bytes_read < 0 {
        return Err(std::io::Error::last_os_error());
    }

    let bytes_read = bytes_read as usize;
    // Sound: We ONLY assume initialization for the exact prefix returned by read()!
    // Transmuting the entire 4096-byte array would be UB if bytes_read < 4096.
    let initialized_slice: &[u8] = unsafe {
        std::slice::from_raw_parts(buffer.as_ptr() as *const u8, bytes_read)
    };

    Ok(initialized_slice.to_vec())
}