Introduce a SocketAddrLen type and use it for SocketAddrOpaque sizes.

sunfishcode · sunfishcode · commit 85541399d6d3 · 2025-02-10T18:40:17.000-08:00
diff --git a/src/backend/libc/net/addr.rs b/src/backend/libc/net/addr.rs
@@ -169,7 +169,7 @@ impl SocketAddrUnix {
 
     #[inline]
     fn bytes(&self) -> Option<&[u8]> {
-        let len = self.len() as usize;
+        let len = self.len();
         if len != 0 {
             let bytes = &self.unix.sun_path[..len - offsetof_sun_path()];
             // SAFETY: `from_raw_parts` to convert from `&[c_char]` to `&[u8]`.
diff --git a/src/backend/libc/net/msghdr.rs b/src/backend/libc/net/msghdr.rs
@@ -73,7 +73,7 @@ pub(crate) fn with_msghdr<R>(
         f({
             let mut h = zero_msghdr();
             h.msg_name = addr_ptr as *mut _;
-            h.msg_namelen = addr_len as c::socklen_t;
+            h.msg_namelen = addr_len;
             h.msg_iov = iov.as_ptr() as _;
             h.msg_iovlen = msg_iov_len(iov.len());
             h.msg_control = control.as_control_ptr().cast();
diff --git a/src/backend/libc/net/read_sockaddr.rs b/src/backend/libc/net/read_sockaddr.rs
@@ -113,12 +113,12 @@ unsafe fn read_sun_path0(storage: *const c::sockaddr) -> u8 {
 ///
 /// `storage` must point to a valid socket address returned from the OS.
 #[inline]
-pub(crate) unsafe fn sockaddr_nonempty(storage: *const c::sockaddr, len: usize) -> bool {
+pub(crate) unsafe fn sockaddr_nonempty(storage: *const c::sockaddr, len: c::socklen_t) -> bool {
     if len == 0 {
         return false;
     }
 
-    assert!(len >= size_of::<c::sa_family_t>());
+    assert!(len as usize >= size_of::<c::sa_family_t>());
     let family: c::c_int = read_sa_family(storage.cast::<c::sockaddr>()).into();
     if family == c::AF_UNSPEC {
         return false;
@@ -145,7 +145,7 @@ pub(crate) fn read_sockaddr_v4(addr: &SocketAddrAny) -> Result<SocketAddrV4, Err
     if addr.address_family() != AddressFamily::INET {
         return Err(Errno::AFNOSUPPORT);
     }
-    assert!(addr.len() >= size_of::<c::sockaddr_in>());
+    assert!(addr.len() as usize >= size_of::<c::sockaddr_in>());
     let decode = unsafe { &*addr.as_ptr().cast::<c::sockaddr_in>() };
     Ok(SocketAddrV4::new(
         Ipv4Addr::from(u32::from_be(in_addr_s_addr(decode.sin_addr))),
@@ -158,7 +158,7 @@ pub(crate) fn read_sockaddr_v6(addr: &SocketAddrAny) -> Result<SocketAddrV6, Err
     if addr.address_family() != AddressFamily::INET6 {
         return Err(Errno::AFNOSUPPORT);
     }
-    assert!(addr.len() >= size_of::<c::sockaddr_in6>());
+    assert!(addr.len() as usize >= size_of::<c::sockaddr_in6>());
     let decode = unsafe { &*addr.as_ptr().cast::<c::sockaddr_in6>() };
     Ok(SocketAddrV6::new(
         Ipv6Addr::from(in6_addr_s6_addr(decode.sin6_addr)),
@@ -176,7 +176,7 @@ pub(crate) fn read_sockaddr_unix(addr: &SocketAddrAny) -> Result<SocketAddrUnix,
     }
 
     let offsetof_sun_path = super::addr::offsetof_sun_path();
-    let len = addr.len();
+    let len = addr.len() as usize;
 
     assert!(len >= offsetof_sun_path);
 
@@ -232,7 +232,7 @@ pub(crate) fn read_sockaddr_xdp(addr: &SocketAddrAny) -> Result<SocketAddrXdp, E
     if addr.address_family() != AddressFamily::XDP {
         return Err(Errno::AFNOSUPPORT);
     }
-    assert!(addr.len() >= size_of::<c::sockaddr_xdp>());
+    assert!(addr.len() as usize >= size_of::<c::sockaddr_xdp>());
     let decode = unsafe { &*addr.as_ptr().cast::<c::sockaddr_xdp>() };
     Ok(SocketAddrXdp::new(
         SockaddrXdpFlags::from_bits_retain(decode.sxdp_flags),
@@ -248,7 +248,7 @@ pub(crate) fn read_sockaddr_netlink(addr: &SocketAddrAny) -> Result<SocketAddrNe
     if addr.address_family() != AddressFamily::NETLINK {
         return Err(Errno::AFNOSUPPORT);
     }
-    assert!(addr.len() >= size_of::<c::sockaddr_nl>());
+    assert!(addr.len() as usize >= size_of::<c::sockaddr_nl>());
     let decode = unsafe { &*addr.as_ptr().cast::<c::sockaddr_nl>() };
     Ok(SocketAddrNetlink::new(decode.nl_pid, decode.nl_groups))
 }
diff --git a/src/backend/libc/net/syscalls.rs b/src/backend/libc/net/syscalls.rs
@@ -85,7 +85,7 @@ pub(crate) fn sendto(
                 send_recv_len(buf.len()),
                 bitflags_bits!(flags),
                 addr_ptr.cast(),
-                addr_len as c::socklen_t,
+                addr_len,
             ))
         })
     }
@@ -131,23 +131,15 @@ pub(crate) fn socket_with(
 pub(crate) fn bind(sockfd: BorrowedFd<'_>, addr: &impl SocketAddrArg) -> io::Result<()> {
     unsafe {
         addr.with_sockaddr(|addr_ptr, addr_len| {
-            ret(c::bind(
-                borrowed_fd(sockfd),
-                addr_ptr.cast(),
-                addr_len as c::socklen_t,
-            ))
+            ret(c::bind(borrowed_fd(sockfd), addr_ptr.cast(), addr_len))
         })
     }
 }
 
 pub(crate) fn connect(sockfd: BorrowedFd<'_>, addr: &impl SocketAddrArg) -> io::Result<()> {
     unsafe {
         addr.with_sockaddr(|addr_ptr, addr_len| {
-            ret(c::connect(
-                borrowed_fd(sockfd),
-                addr_ptr.cast(),
-                addr_len as c::socklen_t,
-            ))
+            ret(c::connect(borrowed_fd(sockfd), addr_ptr.cast(), addr_len))
         })
     }
 }
diff --git a/src/backend/linux_raw/net/addr.rs b/src/backend/linux_raw/net/addr.rs
@@ -132,7 +132,7 @@ impl SocketAddrUnix {
 
     #[inline]
     fn bytes(&self) -> Option<&[u8]> {
-        let len = self.len() as usize;
+        let len = self.len();
         if len != 0 {
             let bytes = &self.unix.sun_path[..len - offsetof_sun_path()];
             // SAFETY: `from_raw_parts` to convert from `&[c_char]` to `&[u8]`.
diff --git a/src/backend/linux_raw/net/read_sockaddr.rs b/src/backend/linux_raw/net/read_sockaddr.rs
@@ -50,7 +50,7 @@ pub(crate) unsafe fn initialize_family_to_unspec(storage: *mut c::sockaddr) {
 
 /// Check if a socket address returned from the OS is considered non-empty.
 #[inline]
-pub(crate) unsafe fn sockaddr_nonempty(_storage: *const c::sockaddr, len: usize) -> bool {
+pub(crate) unsafe fn sockaddr_nonempty(_storage: *const c::sockaddr, len: c::socklen_t) -> bool {
     len != 0
 }
 
@@ -59,7 +59,7 @@ pub(crate) fn read_sockaddr_v4(addr: &SocketAddrAny) -> Result<SocketAddrV4, Err
     if addr.address_family() != AddressFamily::INET {
         return Err(Errno::AFNOSUPPORT);
     }
-    assert!(addr.len() >= size_of::<c::sockaddr_in>());
+    assert!(addr.len() as usize >= size_of::<c::sockaddr_in>());
     let decode = unsafe { &*addr.as_ptr().cast::<c::sockaddr_in>() };
     Ok(SocketAddrV4::new(
         Ipv4Addr::from(u32::from_be(decode.sin_addr.s_addr)),
@@ -72,7 +72,7 @@ pub(crate) fn read_sockaddr_v6(addr: &SocketAddrAny) -> Result<SocketAddrV6, Err
     if addr.address_family() != AddressFamily::INET6 {
         return Err(Errno::AFNOSUPPORT);
     }
-    assert!(addr.len() >= size_of::<c::sockaddr_in6>());
+    assert!(addr.len() as usize >= size_of::<c::sockaddr_in6>());
     let decode = unsafe { &*addr.as_ptr().cast::<c::sockaddr_in6>() };
     Ok(SocketAddrV6::new(
         Ipv6Addr::from(unsafe { decode.sin6_addr.in6_u.u6_addr8 }),
@@ -88,7 +88,7 @@ pub(crate) fn read_sockaddr_unix(addr: &SocketAddrAny) -> Result<SocketAddrUnix,
         return Err(Errno::AFNOSUPPORT);
     }
     let offsetof_sun_path = super::addr::offsetof_sun_path();
-    let len = addr.len();
+    let len = addr.len() as usize;
 
     assert!(len >= offsetof_sun_path);
 
@@ -125,7 +125,7 @@ pub(crate) fn read_sockaddr_xdp(addr: &SocketAddrAny) -> Result<SocketAddrXdp, E
     if addr.address_family() != AddressFamily::XDP {
         return Err(Errno::AFNOSUPPORT);
     }
-    assert!(addr.len() >= size_of::<c::sockaddr_xdp>());
+    assert!(addr.len() as usize >= size_of::<c::sockaddr_xdp>());
     let decode = unsafe { &*addr.as_ptr().cast::<c::sockaddr_xdp>() };
     Ok(SocketAddrXdp::new(
         SockaddrXdpFlags::from_bits_retain(decode.sxdp_flags),
@@ -140,7 +140,7 @@ pub(crate) fn read_sockaddr_netlink(addr: &SocketAddrAny) -> Result<SocketAddrNe
     if addr.address_family() != AddressFamily::NETLINK {
         return Err(Errno::AFNOSUPPORT);
     }
-    assert!(addr.len() >= size_of::<c::sockaddr_nl>());
+    assert!(addr.len() as usize >= size_of::<c::sockaddr_nl>());
     let decode = unsafe { &*addr.as_ptr().cast::<c::sockaddr_nl>() };
     Ok(SocketAddrNetlink::new(decode.nl_pid, decode.nl_groups))
 }
diff --git a/src/backend/linux_raw/net/syscalls.rs b/src/backend/linux_raw/net/syscalls.rs
@@ -21,7 +21,6 @@ use crate::net::{
     addr::SocketAddrArg, AddressFamily, Protocol, RecvAncillaryBuffer, RecvMsg,
     SendAncillaryBuffer, Shutdown, SocketAddrAny, SocketFlags, SocketType,
 };
-use c::socklen_t;
 use core::mem::MaybeUninit;
 #[cfg(target_arch = "x86")]
 use {
@@ -421,7 +420,7 @@ pub(crate) fn sendto(
                 buf_len,
                 flags,
                 raw_arg(addr_ptr as *mut _),
-                socklen_t(addr_len as socklen_t)
+                socklen_t(addr_len)
             ))
         }
         #[cfg(target_arch = "x86")]
@@ -435,7 +434,7 @@ pub(crate) fn sendto(
                     buf_len,
                     flags.into(),
                     raw_arg(addr_ptr as *mut _),
-                    socklen_t(addr_len as socklen_t)
+                    socklen_t(addr_len)
                 ])
             ))
         }
@@ -603,7 +602,7 @@ pub(crate) fn bind(fd: BorrowedFd<'_>, addr: &impl SocketAddrArg) -> io::Result<
                 __NR_bind,
                 fd,
                 raw_arg(addr_ptr as *mut _),
-                socklen_t(addr_len as socklen_t)
+                socklen_t(addr_len)
             ))
         }
         #[cfg(target_arch = "x86")]
@@ -614,7 +613,7 @@ pub(crate) fn bind(fd: BorrowedFd<'_>, addr: &impl SocketAddrArg) -> io::Result<
                 slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
                     fd.into(),
                     raw_arg(addr_ptr as *mut _),
-                    socklen_t(addr_len as socklen_t)
+                    socklen_t(addr_len)
                 ])
             ))
         }
@@ -630,7 +629,7 @@ pub(crate) fn connect(fd: BorrowedFd<'_>, addr: &impl SocketAddrArg) -> io::Resu
                 __NR_connect,
                 fd,
                 raw_arg(addr_ptr as *mut _),
-                socklen_t(addr_len as socklen_t)
+                socklen_t(addr_len)
             ))
         }
         #[cfg(target_arch = "x86")]
@@ -641,7 +640,7 @@ pub(crate) fn connect(fd: BorrowedFd<'_>, addr: &impl SocketAddrArg) -> io::Resu
                 slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
                     fd.into(),
                     raw_arg(addr_ptr as *mut _),
-                    socklen_t(addr_len as socklen_t)
+                    socklen_t(addr_len)
                 ])
             ))
         }
diff --git a/src/net/addr.rs b/src/net/addr.rs
@@ -28,6 +28,12 @@ pub struct SocketAddrOpaque {
     _data: [u8; 0],
 }
 
+/// A type for the length of a socket address.
+///
+/// This type will always be big enough to hold any socket address, but never
+/// bigger than `usize`.
+pub type SocketAddrLen = u32;
+
 /// A trait abstracting over the types that can be passed as a `sockaddr`.
 ///
 /// # Safety
@@ -44,13 +50,17 @@ pub unsafe trait SocketAddrArg {
     ///     C type can pass it directly without a copy.
     ///   * Other socket types can construct their C-compatible struct on the
     ///     stack and call the closure with a pointer to it.
-    fn with_sockaddr<R>(&self, f: impl FnOnce(*const SocketAddrOpaque, usize) -> R) -> R;
+    fn with_sockaddr<R>(&self, f: impl FnOnce(*const SocketAddrOpaque, SocketAddrLen) -> R) -> R;
 
     /// Convert to `SocketAddrAny`.
     fn as_any(&self) -> SocketAddrAny {
         self.with_sockaddr(|ptr, len| unsafe {
             let mut storage = MaybeUninit::<SocketAddrStorage>::uninit();
-            ptr::copy_nonoverlapping(ptr.cast::<u8>(), storage.as_mut_ptr().cast::<u8>(), len);
+            ptr::copy_nonoverlapping(
+                ptr.cast::<u8>(),
+                storage.as_mut_ptr().cast::<u8>(),
+                len as usize,
+            );
             SocketAddrAny::new(storage, len)
         })
     }
@@ -59,15 +69,15 @@ pub unsafe trait SocketAddrArg {
 /// Helper for implementing SocketAddrArg::with_sockaddr
 pub(crate) fn call_with_sockaddr<A, R>(
     addr: &A,
-    f: impl FnOnce(*const SocketAddrOpaque, usize) -> R,
+    f: impl FnOnce(*const SocketAddrOpaque, SocketAddrLen) -> R,
 ) -> R {
     let ptr = (addr as *const A).cast();
-    let len = size_of::<A>();
+    let len = size_of::<A>() as SocketAddrLen;
     f(ptr, len)
 }
 
 unsafe impl SocketAddrArg for super::SocketAddr {
-    fn with_sockaddr<R>(&self, f: impl FnOnce(*const SocketAddrOpaque, usize) -> R) -> R {
+    fn with_sockaddr<R>(&self, f: impl FnOnce(*const SocketAddrOpaque, SocketAddrLen) -> R) -> R {
         match self {
             SocketAddr::V4(v4) => v4.with_sockaddr(f),
             SocketAddr::V6(v6) => v6.with_sockaddr(f),
@@ -76,23 +86,39 @@ unsafe impl SocketAddrArg for super::SocketAddr {
 }
 
 unsafe impl SocketAddrArg for SocketAddrV4 {
-    fn with_sockaddr<R>(&self, f: impl FnOnce(*const SocketAddrOpaque, usize) -> R) -> R {
+    fn with_sockaddr<R>(&self, f: impl FnOnce(*const SocketAddrOpaque, SocketAddrLen) -> R) -> R {
         call_with_sockaddr(&encode_sockaddr_v4(self), f)
     }
 }
 
 unsafe impl SocketAddrArg for SocketAddrV6 {
-    fn with_sockaddr<R>(&self, f: impl FnOnce(*const SocketAddrOpaque, usize) -> R) -> R {
+    fn with_sockaddr<R>(&self, f: impl FnOnce(*const SocketAddrOpaque, SocketAddrLen) -> R) -> R {
         call_with_sockaddr(&encode_sockaddr_v6(self), f)
     }
 }
 
 #[cfg(unix)]
 unsafe impl SocketAddrArg for SocketAddrUnix {
-    fn with_sockaddr<R>(&self, f: impl FnOnce(*const SocketAddrOpaque, usize) -> R) -> R {
+    fn with_sockaddr<R>(&self, f: impl FnOnce(*const SocketAddrOpaque, SocketAddrLen) -> R) -> R {
         f(
             (&self.unix as *const crate::backend::c::sockaddr_un).cast(),
-            self.addr_len() as usize,
+            self.addr_len(),
         )
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::backend::c;
+
+    #[test]
+    fn test_layouts() {
+        assert_eq_size!(SocketAddrLen, c::socklen_t);
+        assert_eq!(
+            memoffset::span_of!(c::msghdr, msg_namelen).len(),
+            size_of::<SocketAddrLen>()
+        );
+        assert!(size_of::<SocketAddrLen>() <= size_of::<usize>());
+    }
+}
diff --git a/src/net/socket_addr_any.rs b/src/net/socket_addr_any.rs
diff --git a/src/net/types.rs b/src/net/types.rs
