Fix recv_uninit to handle the TRUNC flag. (#1159)

* Fix `recv_uninit` to handle the `TRUNC` flag.

With the `TRUNC` flag, `recv` returns the untruncated length, which may
be longer than the provided buffer. Fix `recv_uninit` and
`recvfrom_uninit` to handle this case.

This mean that `recv_uninit` and `recvfrom_uninit` are unable to return
the full untruncated length returned by `recv` with the `TRUNC` flag,
however it appears that fixing that may require API changes.

Fixes #1153.

* Add comments mentioning alternatives.

Author: sunfishcode

src/net/send_recv/mod.rs

@@ -10,6 +10,7 @@ use crate::net::SocketAddrUnix;
 use crate::net::{SocketAddr, SocketAddrAny, SocketAddrV4, SocketAddrV6};
 use crate::{backend, io};
 use backend::fd::{AsFd, BorrowedFd};
+use core::cmp::min;
 use core::mem::MaybeUninit;
 
 pub use backend::net::send_recv::{RecvFlags, SendFlags};
@@ -71,17 +72,24 @@ pub fn recv<Fd: AsFd>(fd: Fd, buf: &mut [u8], flags: RecvFlags) -> io::Result<us
 /// This is equivalent to [`recv`], except that it can read into uninitialized
 /// memory. It returns the slice that was initialized by this function and the
 /// slice that remains uninitialized.
+///
+/// Because this interface returns the length via the returned slice, it's
+/// unsable to return the untruncated length that would be returned when the
+/// `RecvFlags::TRUNC` flag is used. If you need the untruncated length, use
+/// [`recv`].
 #[inline]
 pub fn recv_uninit<Fd: AsFd>(
     fd: Fd,
     buf: &mut [MaybeUninit<u8>],
     flags: RecvFlags,
 ) -> io::Result<(&mut [u8], &mut [MaybeUninit<u8>])> {
     let length = unsafe {
-        backend::net::syscalls::recv(fd.as_fd(), buf.as_mut_ptr().cast::<u8>(), buf.len(), flags)
+        backend::net::syscalls::recv(fd.as_fd(), buf.as_mut_ptr().cast::<u8>(), buf.len(), flags)?
     };
 
-    Ok(unsafe { split_init(buf, length?) })
+    // If the `TRUNC` flag is set, the returned `length` may be longer than the
+    // buffer length.
+    Ok(unsafe { split_init(buf, min(length, buf.len())) })
 }
 
 /// `send(fd, buf, flags)`—Writes data to a socket.
@@ -160,6 +168,11 @@ pub fn recvfrom<Fd: AsFd>(
 /// This is equivalent to [`recvfrom`], except that it can read into
 /// uninitialized memory. It returns the slice that was initialized by this
 /// function and the slice that remains uninitialized.
+///
+/// Because this interface returns the length via the returned slice, it's
+/// unsable to return the untruncated length that would be returned when the
+/// `RecvFlags::TRUNC` flag is used. If you need the untruncated length, use
+/// [`recvfrom`].
 #[allow(clippy::type_complexity)]
 #[inline]
 pub fn recvfrom_uninit<Fd: AsFd>(
@@ -175,7 +188,10 @@ pub fn recvfrom_uninit<Fd: AsFd>(
             flags,
         )?
     };
-    let (init, uninit) = unsafe { split_init(buf, length) };
+
+    // If the `TRUNC` flag is set, the returned `length` may be longer than the
+    // buffer length.
+    let (init, uninit) = unsafe { split_init(buf, min(length, buf.len())) };
     Ok((init, uninit, addr))
 }
 

tests/net/main.rs

@@ -12,6 +12,8 @@ mod connect_bind_send;
 mod dgram;
 #[cfg(feature = "event")]
 mod poll;
+#[cfg(unix)]
+mod recv_trunc;
 mod sockopt;
 #[cfg(unix)]
 mod unix;

tests/net/recv_trunc.rs

@@ -0,0 +1,29 @@
+use rustix::net::{AddressFamily, RecvFlags, SendFlags, SocketAddrUnix, SocketType};
+use std::mem::MaybeUninit;
+
+/// Test `recv_uninit` with the `RecvFlags::Trunc` flag.
+#[test]
+fn net_recv_uninit_trunc() {
+    crate::init();
+
+    let tmpdir = tempfile::tempdir().unwrap();
+    let path = tmpdir.path().join("recv_uninit_trunc");
+    let name = SocketAddrUnix::new(&path).unwrap();
+
+    let receiver = rustix::net::socket(AddressFamily::UNIX, SocketType::DGRAM, None).unwrap();
+    rustix::net::bind_unix(&receiver, &name).expect("bind");
+
+    let sender = rustix::net::socket(AddressFamily::UNIX, SocketType::DGRAM, None).unwrap();
+    let request = b"Hello, World!!!";
+    let n = rustix::net::sendto_unix(&sender, request, SendFlags::empty(), &name).expect("send");
+    assert_eq!(n, request.len());
+    drop(sender);
+
+    let mut response = [MaybeUninit::<u8>::zeroed(); 5];
+    let (init, uninit) =
+        rustix::net::recv_uninit(&receiver, &mut response, RecvFlags::TRUNC).expect("recv_uninit");
+
+    // We used the `TRUNC` flag, so we should have only gotten 5 bytes.
+    assert_eq!(init, b"Hello");
+    assert!(uninit.is_empty());
+}