network: change implementation of sockopt

The goal is to permit non boolean options in the future, and also to add the keepalive option which is required by some other software

Author: zyuiop

src/executor/network.rs

@@ -314,6 +314,8 @@ pub(crate) fn init() {
 		spawn(network_run());
 		#[cfg(feature = "dhcpv4")]
 		spawn(dhcpv4_run());
+	} else {
+		warn!("Network initialization failed.");
 	}
 }
 

src/fd/delegate.rs

@@ -17,7 +17,7 @@ use crate::fd::socket::vsock;
 use crate::fd::stdio::{ConsoleStderr, ConsoleStdin, ConsoleStdout};
 #[cfg(feature = "uhyve")]
 use crate::fd::stdio::{UhyveStderr, UhyveStdin, UhyveStdout};
-use crate::fd::{AccessPermission, ObjectInterface, PollEvent, StatusFlags};
+use crate::fd::{AccessPermission, ObjectInterface, PollEvent, SocketOptionValue, StatusFlags};
 #[cfg(any(feature = "net", feature = "virtio-vsock"))]
 use crate::fd::{Endpoint, ListenEndpoint, SocketOption};
 use crate::fs::mem::{MemDirectoryInterface, RamFileInterface, RomFileInterface};
@@ -158,7 +158,7 @@ impl ObjectInterface for Fd {
 			#[cfg(any(feature = "net", feature = "virtio-vsock"))]
 			async fn listen(&mut self, _backlog: i32) -> io::Result<()>;
 			#[cfg(any(feature = "net", feature = "virtio-vsock"))]
-			async fn setsockopt(&self, _opt: SocketOption, _optval: bool) -> io::Result<()>;
+			async fn setsockopt(&self, _opt: SocketOption, _optval: SocketOptionValue) -> io::Result<()>;
 			#[cfg(any(feature = "net", feature = "virtio-vsock"))]
 			async fn getsockopt(&self, _opt: SocketOption) -> io::Result<c_int>;
 			#[cfg(any(feature = "net", feature = "virtio-vsock"))]

src/fd/mod.rs

@@ -1,14 +1,12 @@
 use alloc::sync::Arc;
-#[cfg(any(feature = "net", feature = "virtio-vsock"))]
 use core::ffi::c_int;
 use core::future;
 use core::mem::MaybeUninit;
 use core::pin::pin;
 use core::task::Poll::{Pending, Ready};
 use core::time::Duration;
 
-#[cfg(any(feature = "net", feature = "virtio-vsock"))]
-use num_enum::TryFromPrimitive;
+use num_enum::{IntoPrimitive, TryFromPrimitive};
 #[cfg(feature = "net")]
 use smoltcp::wire::{IpEndpoint, IpListenEndpoint};
 
@@ -18,6 +16,8 @@ use crate::errno::Errno;
 use crate::executor::block_on;
 use crate::fs::{FileAttr, SeekWhence};
 use crate::io;
+#[cfg(feature = "net")]
+use crate::syscalls::socket::{Ipproto, SOL_SOCKET, socklen_t};
 
 mod delegate;
 mod eventfd;
@@ -48,12 +48,100 @@ pub(crate) enum ListenEndpoint {
 	Vsock(socket::vsock::VsockListenEndpoint),
 }
 
-#[cfg(any(feature = "net", feature = "virtio-vsock"))]
-#[derive(TryFromPrimitive, PartialEq, Eq, Clone, Copy, Debug)]
-#[repr(i32)]
+#[allow(dead_code)]
+#[derive(Debug, PartialEq, Eq)]
 pub(crate) enum SocketOption {
-	TcpNodelay = 1,
+	TcpOption(SocketOptionTcp),
+	SocketOption(SocketOptionSocket),
+}
+
+#[cfg(feature = "net")]
+impl SocketOption {
+	pub fn from_level_optname(level: i32, optname: i32) -> Option<SocketOption> {
+		if level == SOL_SOCKET {
+			SocketOptionSocket::try_from(optname)
+				.ok()
+				.map(SocketOption::SocketOption)
+		} else {
+			let protocol = u8::try_from(level)
+				.ok()
+				.and_then(|proto| Ipproto::try_from(proto).ok())?;
+
+			match protocol {
+				Ipproto::Tcp => SocketOptionTcp::try_from(optname)
+					.ok()
+					.map(SocketOption::TcpOption),
+				_ => None,
+			}
+		}
+	}
+}
+
+#[cfg(feature = "net")]
+pub struct SocketOptionValue {
+	optval: *const core::ffi::c_void,
+	optlen: socklen_t,
+}
+
+#[cfg(not(feature = "net"))]
+pub struct SocketOptionValue;
+
+unsafe impl Send for SocketOptionValue {}
+
+#[cfg(feature = "net")]
+impl SocketOptionValue {
+	pub fn new(optval: *const core::ffi::c_void, optlen: socklen_t) -> Self {
+		Self { optval, optlen }
+	}
+}
+
+#[cfg(feature = "net")]
+impl TryFrom<&SocketOptionValue> for i32 {
+	type Error = Errno;
+
+	fn try_from(value: &SocketOptionValue) -> Result<Self, Self::Error> {
+		if value.optval.is_null() {
+			return Err(Errno::Inval);
+		}
+
+		if value.optlen != size_of::<i32>() as u32 {
+			return Err(Errno::Inval);
+		}
+
+		let value = unsafe { *value.optval.cast::<i32>() };
+		Ok(value)
+	}
+}
+
+#[cfg(feature = "net")]
+impl TryFrom<&SocketOptionValue> for bool {
+	type Error = Errno;
+
+	fn try_from(value: &SocketOptionValue) -> Result<Self, Self::Error> {
+		let value: i32 = value.try_into()?;
+		Ok(value != 0)
+	}
+}
+
+#[derive(TryFromPrimitive, IntoPrimitive, PartialEq, Eq, Clone, Copy, Debug)]
+#[repr(i32)]
+#[non_exhaustive]
+pub(crate) enum SocketOptionTcp {
+	#[doc(alias = "TCP_NODELAY")]
+	TcpNoDelay = 1,
+}
+
+#[derive(TryFromPrimitive, IntoPrimitive, PartialEq, Eq, Clone, Copy, Debug)]
+#[repr(i32)]
+#[non_exhaustive]
+pub(crate) enum SocketOptionSocket {
+	#[doc(alias = "SO_REUSEADDR")]
+	ReuseAddr = 1,
+	#[doc(alias = "SO_KEEPALIVE")]
+	KeepAlive = 8,
+	#[doc(alias = "SO_SNDBUF")]
 	SoSndbuf = 0x1001,
+	#[doc(alias = "SO_RCVBUF")]
 	SoRcvbuf = 0x1002,
 }
 
@@ -265,7 +353,7 @@ pub(crate) trait ObjectInterface: Sync + Send {
 
 	/// `setsockopt` sets options on sockets
 	#[cfg(any(feature = "net", feature = "virtio-vsock"))]
-	async fn setsockopt(&self, _opt: SocketOption, _optval: bool) -> io::Result<()> {
+	async fn setsockopt(&self, _opt: SocketOption, _optval: SocketOptionValue) -> io::Result<()> {
 		Err(Errno::Notsock)
 	}
 

src/fd/socket/tcp.rs

@@ -13,7 +13,10 @@ use smoltcp::wire::{IpEndpoint, Ipv4Address, Ipv6Address};
 use crate::errno::Errno;
 use crate::executor::block_on;
 use crate::executor::network::{Handle, NIC, wake_network_waker};
-use crate::fd::{self, Endpoint, Fd, ListenEndpoint, ObjectInterface, PollEvent, SocketOption};
+use crate::fd::{
+	self, Endpoint, Fd, ListenEndpoint, ObjectInterface, PollEvent, SocketOption,
+	SocketOptionSocket, SocketOptionTcp, SocketOptionValue,
+};
 use crate::syscalls::socket::Af;
 use crate::{DEFAULT_KEEP_ALIVE_INTERVAL, io};
 
@@ -426,19 +429,38 @@ impl ObjectInterface for Socket {
 		Ok(())
 	}
 
-	async fn setsockopt(&self, opt: SocketOption, optval: bool) -> io::Result<()> {
-		if opt == SocketOption::TcpNodelay {
-			let mut guard = NIC.lock();
-			let nic = guard.as_nic_mut().unwrap();
+	async fn setsockopt(&self, opt: SocketOption, optval: SocketOptionValue) -> io::Result<()> {
+		let mut guard = NIC.lock();
+		let nic = guard.as_nic_mut().unwrap();
 
-			for handle in self.handle.iter().copied() {
-				let socket = nic.get_mut_socket::<tcp::Socket<'_>>(handle);
-				socket.set_nagle_enabled(optval);
+		match opt {
+			SocketOption::TcpOption(SocketOptionTcp::TcpNoDelay) => {
+				let is_enabled = (&optval).try_into()?;
+				for handle in self.handle.iter().copied() {
+					let socket = nic.get_mut_socket::<tcp::Socket<'_>>(handle);
+					socket.set_nagle_enabled(is_enabled);
+				}
+				Ok(())
 			}
+			SocketOption::SocketOption(SocketOptionSocket::KeepAlive) => {
+				let keepalive: bool = (&optval).try_into()?;
+				let keepalive = if keepalive {
+					Some(Duration::from_secs(120))
+				} else {
+					None
+				};
 
-			Ok(())
-		} else {
-			Err(Errno::Inval)
+				for i in self.handle.iter() {
+					let socket = nic.get_mut_socket::<tcp::Socket<'_>>(*i);
+					socket.set_keep_alive(keepalive);
+				}
+
+				Ok(())
+			}
+			other => {
+				warn!("TCP: unsupported option {other:?}");
+				Err(Errno::Inval)
+			}
 		}
 	}
 
@@ -448,9 +470,22 @@ impl ObjectInterface for Socket {
 		let socket = nic.get_mut_socket::<tcp::Socket<'_>>(*self.handle.first().unwrap());
 
 		match opt {
-			SocketOption::TcpNodelay => Ok(socket.nagle_enabled().into()),
-			SocketOption::SoSndbuf => Ok(c_int::try_from(socket.send_capacity()).unwrap()),
-			SocketOption::SoRcvbuf => Ok(c_int::try_from(socket.recv_capacity()).unwrap()),
+			SocketOption::TcpOption(SocketOptionTcp::TcpNoDelay) => {
+				Ok(socket.nagle_enabled().into())
+			}
+			SocketOption::SocketOption(SocketOptionSocket::KeepAlive) => {
+				Ok(socket.keep_alive().is_some().into())
+			}
+			SocketOption::SocketOption(SocketOptionSocket::SoSndbuf) => {
+				Ok(c_int::try_from(socket.send_capacity()).unwrap())
+			}
+			SocketOption::SocketOption(SocketOptionSocket::SoRcvbuf) => {
+				Ok(c_int::try_from(socket.recv_capacity()).unwrap())
+			}
+			other => {
+				warn!("TCP: unsupported option {other:?}");
+				Err(Errno::Inval)
+			}
 		}
 	}