Use uninitialized buffer for recvfrom

`smoltcp::socket::tcp::Socket::recv_slice` takes a `&[u8]`, so inline it
and refactor. As a bonus, this avoids a copy and clear in the error
case.

Author: thaliaarchi

src/fd/mod.rs

@@ -231,7 +231,7 @@ pub(crate) trait ObjectInterface: Sync + Send + core::fmt::Debug {
 
 	/// receive a message from a socket
 	#[cfg(any(feature = "tcp", feature = "udp", feature = "vsock"))]
-	async fn recvfrom(&self, _buffer: &mut [u8]) -> io::Result<(usize, Endpoint)> {
+	async fn recvfrom(&self, _buffer: &mut [MaybeUninit<u8>]) -> io::Result<(usize, Endpoint)> {
 		Err(io::Error::ENOSYS)
 	}
 

src/fd/socket/udp.rs

@@ -142,24 +142,23 @@ impl Socket {
 		}
 	}
 
-	async fn recvfrom(&self, buffer: &mut [u8]) -> io::Result<(usize, Endpoint)> {
+	async fn recvfrom(&self, buffer: &mut [MaybeUninit<u8>]) -> io::Result<(usize, Endpoint)> {
 		future::poll_fn(|cx| {
 			self.with(|socket| {
 				if socket.is_open() {
 					if socket.can_recv() {
-						match socket.recv_slice(buffer) {
-							Ok((len, meta)) => match self.endpoint {
-								Some(ep) => {
-									if meta.endpoint == ep {
-										Poll::Ready(Ok((len, meta.endpoint)))
-									} else {
-										buffer[..len].iter_mut().for_each(|x| *x = 0);
-										socket.register_recv_waker(cx.waker());
-										Poll::Pending
-									}
+						match socket.recv() {
+							// Drop the packet when the provided buffer cannot
+							// fit the payload.
+							Ok((data, meta)) if data.len() <= buffer.len() => {
+								if self.endpoint.is_none_or(|ep| meta.endpoint == ep) {
+									buffer[..data.len()].write_copy_of_slice(data);
+									Poll::Ready(Ok((data.len(), meta.endpoint)))
+								} else {
+									socket.register_recv_waker(cx.waker());
+									Poll::Pending
 								}
-								None => Poll::Ready(Ok((len, meta.endpoint))),
-							},
+							}
 							_ => Poll::Ready(Err(io::Error::EIO)),
 						}
 					} else {
@@ -175,24 +174,23 @@ impl Socket {
 		.map(|(len, endpoint)| (len, Endpoint::Ip(endpoint)))
 	}
 
-	async fn read(&self, buffer: &mut [u8]) -> io::Result<usize> {
+	async fn read(&self, buffer: &mut [MaybeUninit<u8>]) -> io::Result<usize> {
 		future::poll_fn(|cx| {
 			self.with(|socket| {
 				if socket.is_open() {
 					if socket.can_recv() {
-						match socket.recv_slice(buffer) {
-							Ok((len, meta)) => match self.endpoint {
-								Some(ep) => {
-									if meta.endpoint == ep {
-										Poll::Ready(Ok(len))
-									} else {
-										buffer[..len].iter_mut().for_each(|x| *x = 0);
-										socket.register_recv_waker(cx.waker());
-										Poll::Pending
-									}
+						match socket.recv() {
+							// Drop the packet when the provided buffer cannot
+							// fit the payload.
+							Ok((data, meta)) if data.len() <= buffer.len() => {
+								if self.endpoint.is_none_or(|ep| meta.endpoint == ep) {
+									buffer[..data.len()].write_copy_of_slice(data);
+									Poll::Ready(Ok(data.len()))
+								} else {
+									socket.register_recv_waker(cx.waker());
+									Poll::Pending
 								}
-								None => Poll::Ready(Ok(len)),
-							},
+							}
 							_ => Poll::Ready(Err(io::Error::EIO)),
 						}
 					} else {
@@ -258,14 +256,11 @@ impl ObjectInterface for async_lock::RwLock<Socket> {
 		self.read().await.sendto(buffer, endpoint).await
 	}
 
-	async fn recvfrom(&self, buffer: &mut [u8]) -> io::Result<(usize, Endpoint)> {
+	async fn recvfrom(&self, buffer: &mut [MaybeUninit<u8>]) -> io::Result<(usize, Endpoint)> {
 		self.read().await.recvfrom(buffer).await
 	}
 
 	async fn read(&self, buffer: &mut [MaybeUninit<u8>]) -> io::Result<usize> {
-		// FIXME
-		let buffer =
-			unsafe { core::slice::from_raw_parts_mut(buffer.as_mut_ptr().cast(), buffer.len()) };
 		self.read().await.read(buffer).await
 	}
 

src/syscalls/socket.rs

@@ -962,7 +962,7 @@ pub unsafe extern "C" fn sys_recvfrom(
 	addr: *mut sockaddr,
 	addrlen: *mut socklen_t,
 ) -> isize {
-	let slice = unsafe { core::slice::from_raw_parts_mut(buf, len) };
+	let slice = unsafe { core::slice::from_raw_parts_mut(buf.cast(), len) };
 	let obj = get_object(fd);
 	obj.map_or_else(
 		|e| -num::ToPrimitive::to_isize(&e).unwrap(),