refactor: reuse socket utilities

Signed-off-by: Roman Volosatovs <rvolosatovs@riseup.net>

Author: rvolosatovs

crates/wasi/src/p2/host/network.rs

@@ -2,8 +2,8 @@ use crate::p2::bindings::sockets::network::{
     self, ErrorCode, IpAddress, IpAddressFamily, IpSocketAddress, Ipv4SocketAddress,
     Ipv6SocketAddress,
 };
-use crate::p2::network::{from_ipv4_addr, from_ipv6_addr, to_ipv4_addr, to_ipv6_addr};
 use crate::p2::{IoView, SocketError, WasiImpl, WasiView};
+use crate::sockets::util::{from_ipv4_addr, from_ipv6_addr, to_ipv4_addr, to_ipv6_addr};
 use anyhow::Error;
 use rustix::io::Errno;
 use std::io;
@@ -242,331 +242,3 @@ impl From<cap_net_ext::AddressFamily> for IpAddressFamily {
         }
     }
 }
-
-pub(crate) mod util {
-    use std::io;
-    use std::net::{IpAddr, Ipv6Addr, SocketAddr};
-    use std::time::Duration;
-
-    use crate::sockets::SocketAddressFamily;
-    use cap_net_ext::{AddressFamily, Blocking, UdpSocketExt};
-    use rustix::fd::{AsFd, OwnedFd};
-    use rustix::io::Errno;
-    use rustix::net::sockopt;
-
-    pub fn validate_unicast(addr: &SocketAddr) -> io::Result<()> {
-        match to_canonical(&addr.ip()) {
-            IpAddr::V4(ipv4) => {
-                if ipv4.is_multicast() || ipv4.is_broadcast() {
-                    Err(io::Error::new(
-                        io::ErrorKind::InvalidInput,
-                        "Both IPv4 broadcast and multicast addresses are not supported",
-                    ))
-                } else {
-                    Ok(())
-                }
-            }
-            IpAddr::V6(ipv6) => {
-                if ipv6.is_multicast() {
-                    Err(io::Error::new(
-                        io::ErrorKind::InvalidInput,
-                        "IPv6 multicast addresses are not supported",
-                    ))
-                } else {
-                    Ok(())
-                }
-            }
-        }
-    }
-
-    pub fn validate_remote_address(addr: &SocketAddr) -> io::Result<()> {
-        if to_canonical(&addr.ip()).is_unspecified() {
-            return Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                "Remote address may not be `0.0.0.0` or `::`",
-            ));
-        }
-
-        if addr.port() == 0 {
-            return Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                "Remote port may not be 0",
-            ));
-        }
-
-        Ok(())
-    }
-
-    pub fn validate_address_family(
-        addr: &SocketAddr,
-        socket_family: &SocketAddressFamily,
-    ) -> io::Result<()> {
-        match (socket_family, addr.ip()) {
-            (SocketAddressFamily::Ipv4, IpAddr::V4(_)) => Ok(()),
-            (SocketAddressFamily::Ipv6, IpAddr::V6(ipv6)) => {
-                if is_deprecated_ipv4_compatible(&ipv6) {
-                    // Reject IPv4-*compatible* IPv6 addresses. They have been deprecated
-                    // since 2006, OS handling of them is inconsistent and our own
-                    // validations don't take them into account either.
-                    // Note that these are not the same as IPv4-*mapped* IPv6 addresses.
-                    Err(io::Error::new(
-                        io::ErrorKind::InvalidInput,
-                        "IPv4-compatible IPv6 addresses are not supported",
-                    ))
-                } else if ipv6.to_ipv4_mapped().is_some() {
-                    Err(io::Error::new(
-                        io::ErrorKind::InvalidInput,
-                        "IPv4-mapped IPv6 address passed to an IPv6-only socket",
-                    ))
-                } else {
-                    Ok(())
-                }
-            }
-            _ => Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                "Address family mismatch",
-            )),
-        }
-    }
-
-    // Can be removed once `IpAddr::to_canonical` becomes stable.
-    pub fn to_canonical(addr: &IpAddr) -> IpAddr {
-        match addr {
-            IpAddr::V4(ipv4) => IpAddr::V4(*ipv4),
-            IpAddr::V6(ipv6) => {
-                if let Some(ipv4) = ipv6.to_ipv4_mapped() {
-                    IpAddr::V4(ipv4)
-                } else {
-                    IpAddr::V6(*ipv6)
-                }
-            }
-        }
-    }
-
-    fn is_deprecated_ipv4_compatible(addr: &Ipv6Addr) -> bool {
-        matches!(addr.segments(), [0, 0, 0, 0, 0, 0, _, _])
-            && *addr != Ipv6Addr::UNSPECIFIED
-            && *addr != Ipv6Addr::LOCALHOST
-    }
-
-    /*
-     * Syscalls wrappers with (opinionated) portability fixes.
-     */
-
-    pub fn udp_socket(family: AddressFamily, blocking: Blocking) -> io::Result<OwnedFd> {
-        // Delegate socket creation to cap_net_ext. They handle a couple of things for us:
-        // - On Windows: call WSAStartup if not done before.
-        // - Set the NONBLOCK and CLOEXEC flags. Either immediately during socket creation,
-        //   or afterwards using ioctl or fcntl. Exact method depends on the platform.
-
-        let socket = cap_std::net::UdpSocket::new(family, blocking)?;
-        Ok(OwnedFd::from(socket))
-    }
-
-    pub fn udp_bind<Fd: AsFd>(sockfd: Fd, addr: &SocketAddr) -> rustix::io::Result<()> {
-        rustix::net::bind(sockfd, addr).map_err(|error| match error {
-            // See: https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-bind#:~:text=WSAENOBUFS
-            // Windows returns WSAENOBUFS when the ephemeral ports have been exhausted.
-            #[cfg(windows)]
-            Errno::NOBUFS => Errno::ADDRINUSE,
-            _ => error,
-        })
-    }
-
-    pub fn udp_disconnect<Fd: AsFd>(sockfd: Fd) -> rustix::io::Result<()> {
-        match rustix::net::connect_unspec(sockfd) {
-            // BSD platforms return an error even if the UDP socket was disconnected successfully.
-            //
-            // MacOS was kind enough to document this: https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/connect.2.html
-            // > Datagram sockets may dissolve the association by connecting to an
-            // > invalid address, such as a null address or an address with the address
-            // > family set to AF_UNSPEC (the error EAFNOSUPPORT will be harmlessly
-            // > returned).
-            //
-            // ... except that this appears to be incomplete, because experiments
-            // have shown that MacOS actually returns EINVAL, depending on the
-            // address family of the socket.
-            #[cfg(target_os = "macos")]
-            Err(Errno::INVAL | Errno::AFNOSUPPORT) => Ok(()),
-            r => r,
-        }
-    }
-
-    // Even though SO_REUSEADDR is a SOL_* level option, this function contain a
-    // compatibility fix specific to TCP. That's why it contains the `_tcp_` infix instead of `_socket_`.
-    pub fn set_tcp_reuseaddr<Fd: AsFd>(sockfd: Fd, value: bool) -> rustix::io::Result<()> {
-        // When a TCP socket is closed, the system may
-        // temporarily reserve that specific address+port pair in a so called
-        // TIME_WAIT state. During that period, any attempt to rebind to that pair
-        // will fail. Setting SO_REUSEADDR to true bypasses that behaviour. Unlike
-        // the name "SO_REUSEADDR" might suggest, it does not allow multiple
-        // active sockets to share the same local address.
-
-        // On Windows that behavior is the default, so there is no need to manually
-        // configure such an option. But (!), Windows _does_ have an identically
-        // named socket option which allows users to "hijack" active sockets.
-        // This is definitely not what we want to do here.
-
-        // Microsoft's own documentation[1] states that we should set SO_EXCLUSIVEADDRUSE
-        // instead (to the inverse value), however the github issue below[2] seems
-        // to indicate that that may no longer be correct.
-        // [1]: https://docs.microsoft.com/en-us/windows/win32/winsock/using-so-reuseaddr-and-so-exclusiveaddruse
-        // [2]: https://github.com/python-trio/trio/issues/928
-
-        #[cfg(not(windows))]
-        sockopt::set_socket_reuseaddr(sockfd, value)?;
-        #[cfg(windows)]
-        let _ = (sockfd, value);
-
-        Ok(())
-    }
-
-    pub fn set_tcp_keepidle<Fd: AsFd>(sockfd: Fd, value: Duration) -> rustix::io::Result<()> {
-        if value <= Duration::ZERO {
-            // WIT: "If the provided value is 0, an `invalid-argument` error is returned."
-            return Err(Errno::INVAL);
-        }
-
-        // Ensure that the value passed to the actual syscall never gets rounded down to 0.
-        const MIN_SECS: u64 = 1;
-
-        // Cap it at Linux' maximum, which appears to have the lowest limit across our supported platforms.
-        const MAX_SECS: u64 = i16::MAX as u64;
-
-        sockopt::set_tcp_keepidle(
-            sockfd,
-            value.clamp(Duration::from_secs(MIN_SECS), Duration::from_secs(MAX_SECS)),
-        )
-    }
-
-    pub fn set_tcp_keepintvl<Fd: AsFd>(sockfd: Fd, value: Duration) -> rustix::io::Result<()> {
-        if value <= Duration::ZERO {
-            // WIT: "If the provided value is 0, an `invalid-argument` error is returned."
-            return Err(Errno::INVAL);
-        }
-
-        // Ensure that any fractional value passed to the actual syscall never gets rounded down to 0.
-        const MIN_SECS: u64 = 1;
-
-        // Cap it at Linux' maximum, which appears to have the lowest limit across our supported platforms.
-        const MAX_SECS: u64 = i16::MAX as u64;
-
-        sockopt::set_tcp_keepintvl(
-            sockfd,
-            value.clamp(Duration::from_secs(MIN_SECS), Duration::from_secs(MAX_SECS)),
-        )
-    }
-
-    pub fn set_tcp_keepcnt<Fd: AsFd>(sockfd: Fd, value: u32) -> rustix::io::Result<()> {
-        if value == 0 {
-            // WIT: "If the provided value is 0, an `invalid-argument` error is returned."
-            return Err(Errno::INVAL);
-        }
-
-        const MIN_CNT: u32 = 1;
-        // Cap it at Linux' maximum, which appears to have the lowest limit across our supported platforms.
-        const MAX_CNT: u32 = i8::MAX as u32;
-
-        sockopt::set_tcp_keepcnt(sockfd, value.clamp(MIN_CNT, MAX_CNT))
-    }
-
-    pub fn get_ip_ttl<Fd: AsFd>(sockfd: Fd) -> rustix::io::Result<u8> {
-        sockopt::ip_ttl(sockfd)?
-            .try_into()
-            .map_err(|_| Errno::OPNOTSUPP)
-    }
-
-    pub fn get_ipv6_unicast_hops<Fd: AsFd>(sockfd: Fd) -> rustix::io::Result<u8> {
-        sockopt::ipv6_unicast_hops(sockfd)
-    }
-
-    pub fn set_ip_ttl<Fd: AsFd>(sockfd: Fd, value: u8) -> rustix::io::Result<()> {
-        match value {
-            // WIT: "If the provided value is 0, an `invalid-argument` error is returned."
-            //
-            // A well-behaved IP application should never send out new packets with TTL 0.
-            // We validate the value ourselves because OS'es are not consistent in this.
-            // On Linux the validation is even inconsistent between their IPv4 and IPv6 implementation.
-            0 => Err(Errno::INVAL),
-            _ => sockopt::set_ip_ttl(sockfd, value.into()),
-        }
-    }
-
-    pub fn set_ipv6_unicast_hops<Fd: AsFd>(sockfd: Fd, value: u8) -> rustix::io::Result<()> {
-        match value {
-            0 => Err(Errno::INVAL), // See `set_ip_ttl`
-            _ => sockopt::set_ipv6_unicast_hops(sockfd, Some(value)),
-        }
-    }
-
-    fn normalize_get_buffer_size(value: usize) -> usize {
-        if cfg!(target_os = "linux") {
-            // Linux doubles the value passed to setsockopt to allow space for bookkeeping overhead.
-            // getsockopt returns this internally doubled value.
-            // We'll half the value to at least get it back into the same ballpark that the application requested it in.
-            //
-            // This normalized behavior is tested for in: test-programs/src/bin/preview2_tcp_sockopts.rs
-            value / 2
-        } else {
-            value
-        }
-    }
-
-    fn normalize_set_buffer_size(value: usize) -> usize {
-        value.clamp(1, i32::MAX as usize)
-    }
-
-    pub fn get_socket_recv_buffer_size<Fd: AsFd>(sockfd: Fd) -> rustix::io::Result<usize> {
-        let value = sockopt::socket_recv_buffer_size(sockfd)?;
-        Ok(normalize_get_buffer_size(value))
-    }
-
-    pub fn get_socket_send_buffer_size<Fd: AsFd>(sockfd: Fd) -> rustix::io::Result<usize> {
-        let value = sockopt::socket_send_buffer_size(sockfd)?;
-        Ok(normalize_get_buffer_size(value))
-    }
-
-    pub fn set_socket_recv_buffer_size<Fd: AsFd>(
-        sockfd: Fd,
-        value: usize,
-    ) -> rustix::io::Result<()> {
-        if value == 0 {
-            // WIT: "If the provided value is 0, an `invalid-argument` error is returned."
-            return Err(Errno::INVAL);
-        }
-
-        let value = normalize_set_buffer_size(value);
-
-        match sockopt::set_socket_recv_buffer_size(sockfd, value) {
-            // Most platforms (Linux, Windows, Fuchsia, Solaris, Illumos, Haiku, ESP-IDF, ..and more?) treat the value
-            // passed to SO_SNDBUF/SO_RCVBUF as a performance tuning hint and silently clamp the input if it exceeds
-            // their capability.
-            // As far as I can see, only the *BSD family views this option as a hard requirement and fails when the
-            // value is out of range. We normalize this behavior in favor of the more commonly understood
-            // "performance hint" semantics. In other words; even ENOBUFS is "Ok".
-            // A future improvement could be to query the corresponding sysctl on *BSD platforms and clamp the input
-            // `size` ourselves, to completely close the gap with other platforms.
-            //
-            // This normalized behavior is tested for in: test-programs/src/bin/preview2_tcp_sockopts.rs
-            Err(Errno::NOBUFS) => Ok(()),
-            r => r,
-        }
-    }
-
-    pub fn set_socket_send_buffer_size<Fd: AsFd>(
-        sockfd: Fd,
-        value: usize,
-    ) -> rustix::io::Result<()> {
-        if value == 0 {
-            // WIT: "If the provided value is 0, an `invalid-argument` error is returned."
-            return Err(Errno::INVAL);
-        }
-
-        let value = normalize_set_buffer_size(value);
-
-        match sockopt::set_socket_send_buffer_size(sockfd, value) {
-            Err(Errno::NOBUFS) => Ok(()), // See set_socket_recv_buffer_size
-            r => r,
-        }
-    }
-}

crates/wasi/src/p2/host/tcp.rs

@@ -197,8 +197,7 @@ where
     ) -> SocketResult<()> {
         let table = self.table();
         let socket = table.get_mut(&this)?;
-        let duration = Duration::from_nanos(value);
-        socket.set_keep_alive_idle_time(duration)
+        socket.set_keep_alive_idle_time(value)
     }
 
     fn keep_alive_interval(&mut self, this: Resource<tcp::TcpSocket>) -> SocketResult<u64> {
@@ -249,7 +248,7 @@ where
         let table = self.table();
         let socket = table.get(&this)?;
 
-        Ok(socket.receive_buffer_size()? as u64)
+        Ok(socket.receive_buffer_size()?)
     }
 
     fn set_receive_buffer_size(
@@ -259,15 +258,14 @@ where
     ) -> SocketResult<()> {
         let table = self.table();
         let socket = table.get_mut(&this)?;
-        let value = value.try_into().unwrap_or(usize::MAX);
         socket.set_receive_buffer_size(value)
     }
 
     fn send_buffer_size(&mut self, this: Resource<tcp::TcpSocket>) -> SocketResult<u64> {
         let table = self.table();
         let socket = table.get(&this)?;
 
-        Ok(socket.send_buffer_size()? as u64)
+        Ok(socket.send_buffer_size()?)
     }
 
     fn set_send_buffer_size(
@@ -277,7 +275,6 @@ where
     ) -> SocketResult<()> {
         let table = self.table();
         let socket = table.get_mut(&this)?;
-        let value = value.try_into().unwrap_or(usize::MAX);
         socket.set_send_buffer_size(value)
     }