Implement Netlink bind syscall

haxxpop · haxxpop · commit 7464ab5b4a58 · 2023-10-05T23:59:36.000+07:00
According to netlink(7), there are two issues worth mentioning.

If the pid of the address is zero, the kernel takes care of assigning it, but we will
leave it untouched at the moment. We can implement the assignment later when we want
to support it.

If the groups of the address is non-zero, it means that the socket wants to listen to
some groups. Since we don't support broadcasting to groups yet, we will emit the error
intead.
diff --git a/src/main/host/descriptor/socket/mod.rs b/src/main/host/descriptor/socket/mod.rs
@@ -92,7 +92,7 @@ impl Socket {
         match self {
             Self::Unix(socket) => UnixSocket::bind(socket, addr, net_ns, rng),
             Self::Inet(socket) => InetSocket::bind(socket, addr, net_ns, rng),
-            Self::Netlink(_) => todo!(),
+            Self::Netlink(socket) => NetlinkSocket::bind(socket, addr, net_ns, rng),
         }
     }
 
diff --git a/src/main/host/descriptor/socket/netlink.rs b/src/main/host/descriptor/socket/netlink.rs
@@ -11,9 +11,11 @@ use crate::host::descriptor::{
     FileMode, FileState, FileStatus, StateListenerFilter, SyscallResult,
 };
 use crate::host::memory_manager::MemoryManager;
+use crate::host::network::namespace::NetworkNamespace;
 use crate::host::syscall::io::IoVec;
 use crate::host::syscall_types::SyscallError;
 use crate::utility::callback_queue::{CallbackQueue, Handle};
+use crate::utility::sockaddr::SockaddrStorage;
 use crate::utility::HostTreePointer;
 
 pub struct NetlinkSocket {
@@ -112,6 +114,18 @@ impl NetlinkSocket {
         Err(Errno::ENOSYS.into())
     }
 
+    pub fn bind(
+        socket: &Arc<AtomicRefCell<Self>>,
+        addr: Option<&SockaddrStorage>,
+        _net_ns: &NetworkNamespace,
+        rng: impl rand::Rng,
+    ) -> SyscallResult {
+        let socket_ref = &mut *socket.borrow_mut();
+        socket_ref
+            .protocol_state
+            .bind(&mut socket_ref.common, socket, addr, rng)
+    }
+
     pub fn readv(
         &mut self,
         _iovs: &[IoVec],
@@ -173,7 +187,11 @@ impl NetlinkSocket {
     }
 }
 
-struct InitialState {}
+struct InitialState {
+    // Indicate that if the socket is already bound or not. We don't keep the bound address so that
+    // we won't need to fill it.
+    is_bound: bool,
+}
 struct ClosedState {}
 /// The current protocol state of the netlink socket. An `Option` is required for each variant so that
 /// the inner state object can be removed, transformed into a new state, and then re-added as a
@@ -200,7 +218,77 @@ state_upcast!(ClosedState, ProtocolState::Closed);
 
 impl ProtocolState {
     fn new(common: &mut NetlinkSocketCommon, socket: &Weak<AtomicRefCell<NetlinkSocket>>) -> Self {
-        ProtocolState::Initial(Some(InitialState {}))
+        ProtocolState::Initial(Some(InitialState { is_bound: false }))
+    }
+
+    fn bind(
+        &mut self,
+        common: &mut NetlinkSocketCommon,
+        socket: &Arc<AtomicRefCell<NetlinkSocket>>,
+        addr: Option<&SockaddrStorage>,
+        rng: impl rand::Rng,
+    ) -> SyscallResult {
+        match self {
+            Self::Initial(x) => x.as_mut().unwrap().bind(common, socket, addr, rng),
+            Self::Closed(x) => x.as_mut().unwrap().bind(common, socket, addr, rng),
+        }
+    }
+}
+
+impl InitialState {
+    fn bind(
+        &mut self,
+        _common: &mut NetlinkSocketCommon,
+        _socket: &Arc<AtomicRefCell<NetlinkSocket>>,
+        addr: Option<&SockaddrStorage>,
+        _rng: impl rand::Rng,
+    ) -> SyscallResult {
+        // if already bound
+        if self.is_bound {
+            return Err(Errno::EINVAL.into());
+        }
+
+        // get the netlink address
+        let Some(addr) = addr.and_then(|x| x.as_netlink()) else {
+            log::warn!(
+                "Attempted to bind netlink socket to non-netlink address {:?}",
+                addr
+            );
+            return Err(Errno::EINVAL.into());
+        };
+        // remember that the socket is bound
+        self.is_bound = true;
+
+        // According to netlink(7), if the pid is zero, the kernel takes care of assigning it, but
+        // we will leave it untouched at the moment. We can implement the assignment later when we
+        // want to support it.
+
+        // According to netlink(7), if the groups is non-zero, it means that the socket wants to
+        // listen to some groups. Since we don't support broadcasting to groups yet, we will emit
+        // the error here.
+        if addr.groups() != 0 {
+            log::warn!(
+                "Attempted to bind netlink socket to an address with non-zero groups {}",
+                addr.groups()
+            );
+            return Err(Errno::EINVAL.into());
+        }
+
+        Ok(0.into())
+    }
+}
+
+impl ClosedState {
+    fn bind(
+        &mut self,
+        _common: &mut NetlinkSocketCommon,
+        _socket: &Arc<AtomicRefCell<NetlinkSocket>>,
+        _addr: Option<&SockaddrStorage>,
+        _rng: impl rand::Rng,
+    ) -> SyscallResult {
+        // We follow the same approach as UnixSocket
+        log::warn!("bind() while in state {}", std::any::type_name::<Self>());
+        Err(Errno::EOPNOTSUPP.into())
     }
 }
 
diff --git a/src/main/utility/sockaddr.rs b/src/main/utility/sockaddr.rs
@@ -22,6 +22,7 @@ union Addr {
     inet: libc::sockaddr_in,
     inet6: libc::sockaddr_in6,
     unix: libc::sockaddr_un,
+    netlink: libc::sockaddr_nl,
 }
 
 // verify there are no larger fields larger than `libc::sockaddr_storage`
@@ -162,6 +163,34 @@ impl SockaddrStorage {
         unsafe { Self::from_ptr(ptr as *const MaybeUninit<u8>, len) }.unwrap()
     }
 
+    /// If the socket address represents a valid netlink socket address (correct family and length),
+    /// returns the netlink socket address.
+    pub fn as_netlink(&self) -> Option<&nix::sys::socket::NetlinkAddr> {
+        if (self.len as usize) < std::mem::size_of::<libc::sockaddr_nl>() {
+            return None;
+        }
+        if self.family() != Some(AddressFamily::Netlink) {
+            return None;
+        }
+
+        // SAFETY: Assume that `nix::sys::socket::NetlinkAddr` is a transparent wrapper around a
+        // `libc::sockaddr_nl`. Verify (as best we can) that this is true.
+        assert_eq_size!(libc::sockaddr_nl, nix::sys::socket::NetlinkAddr);
+        assert_eq_align!(libc::sockaddr_nl, nix::sys::socket::NetlinkAddr);
+
+        Some(unsafe { &*(&self.addr.netlink as *const _ as *const nix::sys::socket::NetlinkAddr) })
+    }
+
+    /// Get a new `SockaddrStorage` with a copy of the netlink socket address.
+    pub fn from_netlink(addr: &nix::sys::socket::NetlinkAddr) -> Self {
+        // SAFETY: Assume that `nix::sys::socket::NetlinkAddr` is a transparent wrapper around a
+        // `libc::sockaddr_nl`. Verify (as best we can) that this is true.
+        assert_eq_size!(libc::sockaddr_nl, nix::sys::socket::NetlinkAddr);
+        assert_eq_align!(libc::sockaddr_nl, nix::sys::socket::NetlinkAddr);
+
+        unsafe { Self::from_ptr(addr.as_ptr() as *const MaybeUninit<u8>, addr.len()) }.unwrap()
+    }
+
     /// A pointer to the socket address. Some bytes may be uninitialized.
     pub fn as_ptr(&self) -> (*const MaybeUninit<u8>, libc::socklen_t) {
         (unsafe { &self.addr.slice }.as_ptr(), self.len)
@@ -178,13 +207,15 @@ impl std::fmt::Debug for SockaddrStorage {
         let as_inet = self.as_inet();
         let as_inet6 = self.as_inet6();
         let as_unix = self.as_unix();
+        let as_netlink = self.as_netlink();
 
         let as_inet = as_inet.map(|x| x as &dyn std::fmt::Debug);
         let as_inet6 = as_inet6.map(|x| x as &dyn std::fmt::Debug);
         let as_unix = as_unix.as_ref().map(|x| x as &dyn std::fmt::Debug);
+        let as_netlink = as_netlink.as_ref().map(|x| x as &dyn std::fmt::Debug);
 
         // find a representation that is not None
-        let options = [as_inet, as_inet6, as_unix];
+        let options = [as_inet, as_inet6, as_unix, as_netlink];
         let addr = options.into_iter().find_map(std::convert::identity);
 
         if let Some(ref addr) = addr {
@@ -206,13 +237,15 @@ impl std::fmt::Display for SockaddrStorage {
         let as_inet = self.as_inet();
         let as_inet6 = self.as_inet6();
         let as_unix = self.as_unix();
+        let as_netlink = self.as_netlink();
 
         let as_inet = as_inet.map(|x| x as &dyn std::fmt::Display);
         let as_inet6 = as_inet6.map(|x| x as &dyn std::fmt::Display);
         let as_unix = as_unix.as_ref().map(|x| x as &dyn std::fmt::Display);
+        let as_netlink = as_netlink.as_ref().map(|x| x as &dyn std::fmt::Display);
 
         // find a representation that is not None
-        let options = [as_inet, as_inet6, as_unix];
+        let options = [as_inet, as_inet6, as_unix, as_netlink];
         let addr = options.into_iter().find_map(std::convert::identity);
 
         if let Some(ref addr) = addr {
@@ -259,6 +292,12 @@ impl From<std::net::SocketAddrV6> for SockaddrStorage {
     }
 }
 
+impl From<nix::sys::socket::NetlinkAddr> for SockaddrStorage {
+    fn from(addr: nix::sys::socket::NetlinkAddr) -> Self {
+        SockaddrStorage::from_netlink(&addr)
+    }
+}
+
 /// A Unix socket address. Typically will be used as an owned address
 /// `SockaddrUnix<libc::sockaddr_un>` or a borrowed address `SockaddrUnix<&libc::sockaddr_un>`, and
 /// you can convert between them using methods such as [`as_ref`](Self::as_ref) or
@@ -529,6 +568,7 @@ mod tests {
         assert!(addr.as_inet().is_some());
         assert!(addr.as_inet6().is_none());
         assert!(addr.as_unix().is_none());
+        assert!(addr.as_netlink().is_none());
     }
 
     /// Convert from a `sockaddr_un` to a `SockaddrStorage`.
@@ -549,6 +589,27 @@ mod tests {
         assert!(addr.as_unix().is_some());
         assert!(addr.as_inet().is_none());
         assert!(addr.as_inet6().is_none());
+        assert!(addr.as_netlink().is_none());
+    }
+
+    /// Convert from a `sockaddr_nl` to a `SockaddrStorage`.
+    #[test]
+    fn storage_from_netlink_ptr() {
+        let mut addr: libc::sockaddr_nl = unsafe { std::mem::zeroed() };
+        addr.nl_family = libc::AF_NETLINK as u16;
+        addr.nl_pid = 0x38deb915;
+        addr.nl_groups = 0xf229a8ea;
+
+        let ptr = &addr as *const _ as *const MaybeUninit<u8>;
+        let len = std::mem::size_of_val(&addr).try_into().unwrap();
+
+        let addr = unsafe { SockaddrStorage::from_ptr(ptr, len) }.unwrap();
+
+        assert_eq!(addr.family(), Some(AddressFamily::Netlink));
+        assert!(addr.as_netlink().is_some());
+        assert!(addr.as_inet().is_none());
+        assert!(addr.as_inet6().is_none());
+        assert!(addr.as_unix().is_none());
     }
 
     /// Convert from a `sockaddr_in` to a `SockaddrStorage` to a `SockaddrIn`.
@@ -588,6 +649,41 @@ mod tests {
         assert_eq!(u32::from_be(addr.sin_addr.s_addr), addr_original.ip());
     }
 
+    /// Convert from a `sockaddr_nl` to a `SockaddrStorage` to a `NetlinkAddr`.
+    #[test]
+    fn netlink_addr_from_libc() {
+        let mut addr_nl: libc::sockaddr_nl = unsafe { std::mem::zeroed() };
+        addr_nl.nl_family = libc::AF_NETLINK as u16;
+        addr_nl.nl_pid = 0x38deb915;
+        addr_nl.nl_groups = 0xf229a8ea;
+
+        let ptr = &addr_nl as *const _ as *const MaybeUninit<u8>;
+        let len = std::mem::size_of_val(&addr_nl).try_into().unwrap();
+
+        let addr = unsafe { SockaddrStorage::from_ptr(ptr, len) }.unwrap();
+        let addr = addr.as_netlink().unwrap();
+
+        assert_eq!(addr.pid(), u32::from_le(addr_nl.nl_pid));
+        assert_eq!(addr.groups(), u32::from_le(addr_nl.nl_groups));
+    }
+
+    /// Convert from a `NetlinkAddr` to a `SockaddrStorage` to a `sockaddr_nl`.
+    #[test]
+    fn netlink_addr_to_libc() {
+        let addr_original = nix::sys::socket::NetlinkAddr::new(0x38deb915, 0xf229a8ea);
+        let addr = SockaddrStorage::from_netlink(&addr_original);
+
+        let (ptr, len) = addr.as_ptr();
+        let ptr = ptr as *const libc::sockaddr_nl;
+        assert_eq!(len as usize, std::mem::size_of::<libc::sockaddr_nl>());
+
+        let addr = unsafe { ptr.as_ref() }.unwrap();
+
+        assert_eq!(addr.nl_family, libc::AF_NETLINK as u16);
+        assert_eq!(u32::from_le(addr.nl_pid), addr_original.pid());
+        assert_eq!(u32::from_le(addr.nl_groups), addr_original.groups());
+    }
+
     /// Convert from a pathname `sockaddr_un` to a `SockaddrStorage` to a `SockaddrUnix`.
     #[test]
     fn unix_addr_from_libc_to_path() {

Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,7 @@ impl Socket {`
`92`	`92`	`match self {`
`93`	`93`	`Self::Unix(socket) => UnixSocket::bind(socket, addr, net_ns, rng),`
`94`	`94`	`Self::Inet(socket) => InetSocket::bind(socket, addr, net_ns, rng),`
`95`		`- Self::Netlink(_) => todo!(),`
	`95`	`+ Self::Netlink(socket) => NetlinkSocket::bind(socket, addr, net_ns, rng),`
`96`	`96`	`}`
`97`	`97`	`}`
`98`	`98`