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,13 @@ 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;
+                let mut v = Vec::with_capacity(n);
+                unsafe { v.set_len(n) };
+                v
+            },
         }
     }
 
@@ -518,7 +524,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;
+            let mut v = Vec::with_capacity(n);
+            unsafe { v.set_len(n) };
+            packets_buf.push(v);
         }
 
         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,9 @@ 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::with_capacity(message_len);
+    unsafe { buffer.set_len(message_len) };
     recv_stream
         .read_exact(&mut buffer)
         .await

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

@@ -104,10 +104,12 @@ 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::with_capacity(MAX_RECEIVE_BUFFER_SIZE);
+        unsafe { recv_buf.set_len(MAX_RECEIVE_BUFFER_SIZE) };
 
         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,
@@ -89,11 +90,12 @@ impl StreamCopyBuffer {
 
     fn with_data(config: &StreamCopyConfig, mut buf: Vec<u8>) -> Self {
         let r_off = buf.len();
-        if buf.capacity() < config.buffer_size {
-            buf.resize(config.buffer_size, 0);
-        } else {
-            buf.resize(buf.capacity(), 0);
+        let new_len = config.buffer_size.max(buf.capacity());
+        if buf.capacity() < new_len {
+            buf.reserve_exact(new_len - buf.capacity());
         }
+        // SAFETY: only `[0..r_off]` is readable until subsequent reads fill more.
+        unsafe { buf.set_len(new_len) };
         StreamCopyBuffer {
             read_done: false,
             buf: buf.into_boxed_slice(),

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

@@ -22,15 +22,17 @@ 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() },
         }
     }
 
     pub fn with_data(data: &[u8], cap: usize) -> Self {
-        let mut buf = Vec::with_capacity(cap);
+        let mut buf = Vec::with_capacity(cap.max(data.len()));
         buf.extend_from_slice(data);
         if cap > data.len() {
-            buf.resize(cap, 0);
+            // SAFETY: only `[0..length]` is readable until subsequent reads fill more.
+            unsafe { buf.set_len(cap) };
         }
         LineRecvVec {
             length: data.len(),

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,