Avoid zeroing I/O buffers that are filled before read

Allocate recv/copy buffers with uninitialized capacity instead of
vec![0]/BytesMut::zeroed, since only the filled prefix is ever observed.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: zh-jq

lib/vey-cert-agent/src/query.rs

@@ -39,7 +39,8 @@ impl QueryRuntime {
         QueryRuntime {
             socket,
             query_handle,
-            read_buffer: vec![0u8; 16384].into_boxed_slice(),
+            // SAFETY: only `read_buffer[..len]` is parsed after poll_recv fills it.
+            read_buffer: unsafe { Box::<[u8]>::new_uninit_slice(16384).assume_init() },
             write_queue: VecDeque::new(),
             protective_ttl: config.protective_cache_ttl,
             maximum_ttl: config.maximum_cache_ttl,

lib/vey-daemon/src/listen/udp/listen.rs

@@ -494,7 +494,11 @@ where
             ingress_net_filter: None,
             _alive_guard: None,
 
-            packet_buf: vec![0; self.packet_max_size as usize],
+            // SAFETY: only `packet_buf[..nr]` is copied after recv fills it.
+            packet_buf: {
+                let n = self.packet_max_size as usize;
+                Vec::from(unsafe { Box::<[u8]>::new_uninit_slice(n).assume_init() })
+            },
         }
     }
 
@@ -518,7 +522,11 @@ where
 
         let mut packets_buf = Vec::with_capacity(self.conn_track.batch_recv_size());
         for _i in 0..self.conn_track.batch_recv_size() {
-            packets_buf.push(vec![0; self.packet_max_size as usize]);
+            // SAFETY: only `packets_buf[i][..nr]` is copied after recv fills it.
+            let n = self.packet_max_size as usize;
+            packets_buf.push(Vec::from(unsafe {
+                Box::<[u8]>::new_uninit_slice(n).assume_init()
+            }));
         }
 
         ListenUdpRuntimeInstance {

lib/vey-h2/src/body/encoder.rs

@@ -107,7 +107,9 @@ impl H2BodyEncodeTransferInternal {
                     }
                 }
             } else {
-                let mut data = BytesMut::zeroed(self.buffer_size);
+                let mut data = BytesMut::with_capacity(self.buffer_size);
+                // SAFETY: only `filled()` / `split_to(nr)` is used after poll_read.
+                unsafe { data.set_len(self.buffer_size) };
                 let mut buf = ReadBuf::new(&mut data);
                 ready!(reader.as_mut().poll_read(cx, &mut buf))
                     .map_err(H2StreamBodyEncodeTransferError::ReadError)?;

lib/vey-hickory-client/src/io/quic.rs

@@ -144,7 +144,10 @@ async fn quic_recv(mut recv_stream: RecvStream) -> Result<DnsResponse, NetError>
         .map_err(|e| format!("quic read len error: {e}"))?;
     let message_len = u16::from_be_bytes(len_buf) as usize;
 
-    let mut buffer = vec![0u8; message_len];
+    // SAFETY: `read_exact` fully initializes `buffer` before it is parsed.
+    let mut buffer = Vec::from(unsafe {
+        Box::<[u8]>::new_uninit_slice(message_len).assume_init()
+    });
     recv_stream
         .read_exact(&mut buffer)
         .await

lib/vey-hickory-client/src/io/udp.rs

@@ -104,10 +104,13 @@ async fn udp_send_recv(
     }
 
     loop {
-        let mut recv_buf = vec![0; MAX_RECEIVE_BUFFER_SIZE];
+        // SAFETY: only `[..nr]` is kept after recv fills it.
+        let mut recv_buf = Vec::from(unsafe {
+            Box::<[u8]>::new_uninit_slice(MAX_RECEIVE_BUFFER_SIZE).assume_init()
+        });
 
         let nr = socket.recv(&mut recv_buf).await?;
-        recv_buf.resize(nr, 0);
+        recv_buf.truncate(nr);
         let response = DnsResponse::from_buffer(recv_buf)?;
         if response.id() != id {
             continue;

lib/vey-io-ext/src/stream/copy.rs

@@ -76,7 +76,8 @@ impl StreamCopyBuffer {
     fn new(config: &StreamCopyConfig) -> Self {
         StreamCopyBuffer {
             read_done: false,
-            buf: vec![0; config.buffer_size].into_boxed_slice(),
+            // SAFETY: only `buf[w_off..r_off]` is read after poll_read fills it.
+            buf: unsafe { Box::<[u8]>::new_uninit_slice(config.buffer_size).assume_init() },
             yield_size: config.yield_size,
             r_off: 0,
             w_off: 0,
@@ -435,3 +436,23 @@ where
             .poll_copy(cx, Pin::new(&mut me.reader), Pin::new(&mut *me.writer))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn with_data_handles_spare_capacity_below_buffer_size() {
+        // len << capacity < buffer_size used to panic: reserve_exact is based on len.
+        let mut data = Vec::with_capacity(64);
+        data.extend_from_slice(b"hello");
+        assert!(data.len() < data.capacity());
+        assert!(data.capacity() < MINIMAL_COPY_BUFFER_SIZE);
+
+        let mut config = StreamCopyConfig::default();
+        config.set_buffer_size(MINIMAL_COPY_BUFFER_SIZE);
+        let buf = StreamCopyBuffer::with_data(&config, data);
+        assert_eq!(&buf.buf[..buf.r_off], b"hello");
+        assert_eq!(buf.buf.len(), MINIMAL_COPY_BUFFER_SIZE);
+    }
+}

lib/vey-io-ext/src/stream/line_recv_vec.rs

@@ -22,7 +22,8 @@ impl LineRecvVec {
             length: 0,
             line_start: 0,
             line_end: 0,
-            buf: vec![0; cap].into_boxed_slice(),
+            // SAFETY: only `buf[line_start..line_end]` / `[0..length]` are read after fills.
+            buf: unsafe { Box::<[u8]>::new_uninit_slice(cap).assume_init() },
         }
     }
 

lib/vey-io-ext/src/udp/relay/mod.rs

@@ -32,7 +32,8 @@ impl UdpRelayPacket {
     fn new(reserved_size: usize, packet_size: u16) -> Self {
         let buf_size = packet_size as usize + reserved_size;
         UdpRelayPacket {
-            buf: vec![0; buf_size].into_boxed_slice(),
+            // SAFETY: only `buf[off..end]` is read after recv fills that range.
+            buf: unsafe { Box::<[u8]>::new_uninit_slice(buf_size).assume_init() },
             buf_data_off: 0,
             buf_data_end: 0,
             ups: UpstreamAddr::empty(),

lib/vey-io-ext/src/udp/stream_copy/mod.rs

@@ -37,8 +37,11 @@ pub struct UdpCopyPacket {
 impl UdpCopyPacket {
     pub(crate) fn new(reserved_size: usize, packet_size: u16) -> Self {
         let buf_size = packet_size as usize + reserved_size;
+        let mut buf = BytesMut::with_capacity(buf_size);
+        // SAFETY: only `buf[off..end]` is read after recv fills that range.
+        unsafe { buf.set_len(buf_size) };
         UdpCopyPacket {
-            buf: BytesMut::zeroed(buf_size),
+            buf,
             buf_data_off: 0,
             buf_data_end: 0,
         }

lib/vey-ip-locate/src/query.rs

@@ -38,7 +38,8 @@ impl IpLocationQueryRuntime {
         IpLocationQueryRuntime {
             socket,
             query_handle,
-            read_buffer: vec![0u8; 16384].into_boxed_slice(),
+            // SAFETY: only `read_buffer[..len]` is parsed after poll_recv fills it.
+            read_buffer: unsafe { Box::<[u8]>::new_uninit_slice(16384).assume_init() },
             write_queue: VecDeque::new(),
             default_expire_ttl: config.default_expire_ttl,
             maximum_expire_ttl: config.maximum_expire_ttl,