Add support for Netlink socket addresses

Author: kevinmehall

src/backend/libc/net/read_sockaddr.rs

@@ -10,6 +10,8 @@ use crate::ffi::CStr;
 use crate::io;
 #[cfg(target_os = "linux")]
 use crate::net::xdp::{SockaddrXdpFlags, SocketAddrXdp};
+#[cfg(target_os = "linux")]
+use crate::net::netlink::SocketAddrNetlink;
 use crate::net::{Ipv4Addr, Ipv6Addr, SocketAddrAny, SocketAddrV4, SocketAddrV6};
 use core::mem::size_of;
 
@@ -210,6 +212,17 @@ pub(crate) unsafe fn read_sockaddr(
                 u32::from_be(decode.sxdp_shared_umem_fd),
             )))
         }
+        #[cfg(target_os = "linux")]
+        c::AF_NETLINK => {
+            if len < size_of::<c::sockaddr_nl>() {
+                return Err(io::Errno::INVAL);
+            }
+            let decode = &*storage.cast::<c::sockaddr_nl>();
+            Ok(SocketAddrAny::Netlink(SocketAddrNetlink::new(
+                decode.nl_pid,
+                decode.nl_groups,
+            )))
+        }
         _ => Err(io::Errno::INVAL),
     }
 }
@@ -329,6 +342,12 @@ unsafe fn inner_read_sockaddr_os(
                 u32::from_be(decode.sxdp_shared_umem_fd),
             ))
         }
+        #[cfg(target_os = "linux")]
+        c::AF_NETLINK => {
+            assert!(len >= size_of::<c::sockaddr_nl>());
+            let decode = &*storage.cast::<c::sockaddr_nl>();
+            SocketAddrAny::Netlink(SocketAddrNetlink::new(decode.nl_pid, decode.nl_groups))
+        }
         other => unimplemented!("{:?}", other),
     }
 }

src/backend/linux_raw/net/read_sockaddr.rs

@@ -6,6 +6,8 @@ use crate::backend::c;
 use crate::io;
 #[cfg(target_os = "linux")]
 use crate::net::xdp::{SockaddrXdpFlags, SocketAddrXdp};
+#[cfg(target_os = "linux")]
+use crate::net::netlink::SocketAddrNetlink;
 use crate::net::{Ipv4Addr, Ipv6Addr, SocketAddrAny, SocketAddrUnix, SocketAddrV4, SocketAddrV6};
 use core::mem::size_of;
 use core::slice;
@@ -127,6 +129,17 @@ pub(crate) unsafe fn read_sockaddr(
                 u32::from_be(decode.sxdp_shared_umem_fd),
             )))
         }
+        #[cfg(target_os = "linux")]
+        c::AF_NETLINK => {
+            if len < size_of::<c::sockaddr_nl>() {
+                return Err(io::Errno::INVAL);
+            }
+            let decode = &*storage.cast::<c::sockaddr_nl>();
+            Ok(SocketAddrAny::Netlink(SocketAddrNetlink::new(
+                decode.nl_pid,
+                decode.nl_groups,
+            )))
+        }
         _ => Err(io::Errno::NOTSUP),
     }
 }
@@ -216,6 +229,12 @@ pub(crate) unsafe fn read_sockaddr_os(storage: *const c::sockaddr, len: usize) -
                 u32::from_be(decode.sxdp_shared_umem_fd),
             ))
         }
+        #[cfg(target_os = "linux")]
+        c::AF_NETLINK => {
+            assert!(len >= size_of::<c::sockaddr_nl>());
+            let decode = &*storage.cast::<c::sockaddr_nl>();
+            SocketAddrAny::Netlink(SocketAddrNetlink::new(decode.nl_pid, decode.nl_groups))
+        }
         other => unimplemented!("{:?}", other),
     }
 }

src/net/socket_addr_any.rs

@@ -11,6 +11,8 @@
 
 #[cfg(target_os = "linux")]
 use crate::net::xdp::SocketAddrXdp;
+#[cfg(target_os = "linux")]
+use crate::net::netlink::SocketAddrNetlink;
 #[cfg(unix)]
 use crate::net::SocketAddrUnix;
 use crate::net::{AddressFamily, SocketAddr, SockAddr, SockAddrRaw, SocketAddrV4, SocketAddrV6};
@@ -36,6 +38,9 @@ pub enum SocketAddrAny {
     /// `struct sockaddr_xdp`
     #[cfg(target_os = "linux")]
     Xdp(SocketAddrXdp),
+    /// `struct sockaddr_nl`
+    #[cfg(target_os = "linux")]
+    Netlink(SocketAddrNetlink),
 }
 
 impl From<SocketAddr> for SocketAddrAny {
@@ -81,6 +86,8 @@ impl SocketAddrAny {
             Self::Unix(_) => AddressFamily::UNIX,
             #[cfg(target_os = "linux")]
             Self::Xdp(_) => AddressFamily::XDP,
+            #[cfg(target_os = "linux")]
+            Self::Netlink(_) => AddressFamily::NETLINK,
         }
     }
 
@@ -123,6 +130,8 @@ impl fmt::Debug for SocketAddrAny {
             Self::Unix(unix) => unix.fmt(fmt),
             #[cfg(target_os = "linux")]
             Self::Xdp(xdp) => xdp.fmt(fmt),
+            #[cfg(target_os = "linux")]
+            Self::Netlink(nl) => nl.fmt(fmt),
         }
     }
 }
@@ -139,6 +148,8 @@ unsafe impl SockAddr for SocketAddrAny {
             Self::Unix(a) => a.with_sockaddr(f),
             #[cfg(target_os = "linux")]
             Self::Xdp(a) => a.with_sockaddr(f),
+            #[cfg(target_os = "linux")]
+            Self::Netlink(a) => a.with_sockaddr(f),
         }
     }
 }

src/net/types.rs

@@ -915,6 +915,8 @@ pub mod netlink {
     use {
         super::{new_raw_protocol, Protocol},
         crate::backend::c,
+        crate::net::{SockAddr, SockAddrRaw, socket_address::call_with_sockaddr},
+        core::mem,
     };
 
     /// `NETLINK_UNUSED`
@@ -1024,6 +1026,66 @@ pub mod netlink {
     /// `NETLINK_GET_STRICT_CHK`
     #[cfg(linux_kernel)]
     pub const GET_STRICT_CHK: Protocol = Protocol(new_raw_protocol(c::NETLINK_GET_STRICT_CHK as _));
+
+    /// A Netlink socket address.
+    ///
+    /// Used to bind to a Netlink socket.
+    ///
+    /// Not ABI compatible with `struct sockaddr_nl`
+    #[derive(Clone, PartialEq, PartialOrd, Eq, Ord, Hash, Debug)]
+    #[cfg(linux_kernel)]
+    pub struct SocketAddrNetlink {
+        /// Port ID
+        pid: u32,
+
+        /// Multicast groups mask
+        groups: u32,
+    }
+
+    #[cfg(linux_kernel)]
+    impl SocketAddrNetlink {
+        /// Construct a netlink address
+        #[inline]
+        pub fn new(pid: u32, groups: u32) -> Self {
+            Self { pid, groups }
+        }
+
+        /// Return port id.
+        #[inline]
+        pub fn pid(&self) -> u32 {
+            self.pid
+        }
+
+        /// Set port id.
+        #[inline]
+        pub fn set_pid(&mut self, pid: u32) {
+            self.pid = pid;
+        }
+
+        /// Return multicast groups mask.
+        #[inline]
+        pub fn groups(&self) -> u32 {
+            self.groups
+        }
+
+        /// Set multicast groups mask.
+        #[inline]
+        pub fn set_groups(&mut self, groups: u32) {
+            self.groups = groups;
+        }
+    }
+
+    #[cfg(linux_kernel)]
+    #[allow(unsafe_code)]
+    unsafe impl SockAddr for SocketAddrNetlink {
+        fn with_sockaddr<R>(&self, f: impl FnOnce(*const SockAddrRaw, usize) -> R) -> R {
+            let mut addr: c::sockaddr_nl = unsafe { mem::zeroed() };
+            addr.nl_family = c::AF_NETLINK as _;
+            addr.nl_pid = self.pid;
+            addr.nl_groups = self.groups;
+            call_with_sockaddr(&addr, f)
+        }
+    }
 }
 
 /// `ETH_P_*` constants.