Add methods to TCP and UDP sockets to modify hop limit (refresh of #94678)

library/std/src/lib.rs

@@ -365,6 +365,7 @@
 #![feature(io_error_uncategorized)]
 #![feature(io_slice_as_bytes)]
 #![feature(ip)]
+#![feature(ipv6_hop_limit)]
 #![feature(iter_advance_by)]
 #![feature(iter_next_chunk)]
 #![feature(maybe_dangling)]

library/std/src/net/tcp.rs

@@ -604,6 +604,46 @@ impl TcpStream {
         self.0.ttl()
     }
 
+    /// Sets the value for the `IPV6_UNICAST_HOPS` option on this socket.
+    ///
+    /// This value sets the unicast hop limit field that is used in every packet
+    /// sent from this socket.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// #![feature(ipv6_hop_limit)]
+    /// use std::net::TcpStream;
+    ///
+    /// let stream = TcpStream::connect("[::1]:12345")
+    ///                        .expect("Couldn't connect to the server...");
+    /// stream.set_hop_limit_v6(88).expect("set_hop_limit_v6 call failed");
+    /// ```
+    #[unstable(feature = "ipv6_hop_limit", issue = "139166")]
+    pub fn set_hop_limit_v6(&self, limit: u8) -> io::Result<()> {
+        self.0.set_hop_limit_v6(limit)
+    }
+
+    /// Gets the value of the `IPV6_UNICAST_HOPS` option on this socket.
+    ///
+    /// For more information about this option, see [`TcpStream::set_hop_limit_v6`].
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// #![feature(ipv6_hop_limit)]
+    /// use std::net::TcpStream;
+    ///
+    /// let stream = TcpStream::connect("[::1]:12345")
+    ///                        .expect("Couldn't connect to the server...");
+    /// stream.set_hop_limit_v6(88).expect("set_hop_limit_v6 call failed");
+    /// assert_eq!(stream.hop_limit_v6().unwrap(), 88);
+    /// ```
+    #[unstable(feature = "ipv6_hop_limit", issue = "139166")]
+    pub fn hop_limit_v6(&self) -> io::Result<u8> {
+        self.0.hop_limit_v6()
+    }
+
     /// Gets the value of the `SO_ERROR` option on this socket.
     ///
     /// This will retrieve the stored error in the underlying socket, clearing
@@ -1031,6 +1071,44 @@ impl TcpListener {
         self.0.ttl()
     }
 
+    /// Sets the value for the `IPV6_UNICAST_HOPS` option on this socket.
+    ///
+    /// This value sets the unicast hop limit field that is used in every packet
+    /// sent from this socket.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// #![feature(ipv6_hop_limit)]
+    /// use std::net::TcpListener;
+    ///
+    /// let listener = TcpListener::bind("[::1]:12345").unwrap();
+    /// listener.set_hop_limit_v6(88).expect("set_hop_limit_v6 call failed");
+    /// ```
+    #[unstable(feature = "ipv6_hop_limit", issue = "139166")]
+    pub fn set_hop_limit_v6(&self, limit: u8) -> io::Result<()> {
+        self.0.set_hop_limit_v6(limit)
+    }
+
+    /// Gets the value of the `IPV6_UNICAST_HOPS` option on this socket.
+    ///
+    /// For more information about this option, see [`TcpListener::set_hop_limit_v6`].
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// #![feature(ipv6_hop_limit)]
+    /// use std::net::TcpListener;
+    ///
+    /// let listener = TcpListener::bind("[::1]:12345").unwrap();
+    /// listener.set_hop_limit_v6(88).expect("set_hop_limit_v6 call failed");
+    /// assert_eq!(listener.hop_limit_v6().unwrap(), 88);
+    /// ```
+    #[unstable(feature = "ipv6_hop_limit", issue = "139166")]
+    pub fn hop_limit_v6(&self) -> io::Result<u8> {
+        self.0.hop_limit_v6()
+    }
+
     #[stable(feature = "net2_mutators", since = "1.9.0")]
     #[deprecated(since = "1.16.0", note = "this option can only be set before the socket is bound")]
     #[allow(missing_docs)]

library/std/src/net/tcp/tests.rs

@@ -894,6 +894,23 @@ fn ttl() {
     assert_eq!(ttl, t!(stream.ttl()));
 }
 
+#[test]
+#[cfg_attr(target_env = "sgx", ignore)]
+#[cfg(not(all(target_os = "wasi", any(target_env = "p2", target_env = "p3"))))]
+fn hop_limit() {
+    let hlim = 100;
+
+    let listener = t!(TcpListener::bind(LOCALHOST_IP6));
+
+    t!(listener.set_hop_limit_v6(hlim));
+    assert_eq!(hlim, t!(listener.hop_limit_v6()));
+
+    let stream = t!(TcpStream::connect(t!(listener.local_addr())));
+
+    t!(stream.set_hop_limit_v6(hlim));
+    assert_eq!(hlim, t!(stream.hop_limit_v6()));
+}
+
 #[test]
 #[cfg_attr(target_env = "sgx", ignore)]
 fn set_nonblocking() {

library/std/src/net/udp.rs

@@ -585,6 +585,82 @@ impl UdpSocket {
         self.0.ttl()
     }
 
+    /// Sets the value for the `IPV6_UNICAST_HOPS` option on this socket.
+    ///
+    /// This value sets the unicast hop limit field that is used in every packet
+    /// sent from this socket.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// #![feature(ipv6_hop_limit)]
+    /// use std::net::UdpSocket;
+    ///
+    /// let socket = UdpSocket::bind("[::1]:12345").expect("couldn't bind to address");
+    /// socket.set_hop_limit_v6(88).expect("set_hop_limit_v6 call failed");
+    /// ```
+    #[unstable(feature = "ipv6_hop_limit", issue = "139166")]
+    pub fn set_hop_limit_v6(&self, limit: u8) -> io::Result<()> {
+        self.0.set_hop_limit_v6(limit)
+    }
+
+    /// Gets the value of the `IPV6_UNICAST_HOPS` option on this socket.
+    ///
+    /// For more information about this option, see [`UdpSocket::set_hop_limit_v6`].
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// #![feature(ipv6_hop_limit)]
+    /// use std::net::UdpSocket;
+    ///
+    /// let socket = UdpSocket::bind("[::1]:12345").expect("couldn't bind to address");
+    /// socket.set_hop_limit_v6(88).expect("set_hop_limit_v6 call failed");
+    /// assert_eq!(socket.hop_limit_v6().unwrap(), 88);
+    /// ```
+    #[unstable(feature = "ipv6_hop_limit", issue = "139166")]
+    pub fn hop_limit_v6(&self) -> io::Result<u8> {
+        self.0.hop_limit_v6()
+    }
+
+    /// Sets the value for the `IPV6_MULTICAST_HOPS` option on this socket.
+    ///
+    /// This value sets the hop limit field for outgoing multicast packets
+    /// sent from this socket.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// #![feature(ipv6_hop_limit)]
+    /// use std::net::UdpSocket;
+    ///
+    /// let socket = UdpSocket::bind("[::1]:12345").expect("couldn't bind to address");
+    /// socket.set_multicast_hop_limit_v6(88).expect("set_multicast_hop_limit_v6 call failed");
+    /// ```
+    #[unstable(feature = "ipv6_hop_limit", issue = "139166")]
+    pub fn set_multicast_hop_limit_v6(&self, limit: u8) -> io::Result<()> {
+        self.0.set_multicast_hop_limit_v6(limit)
+    }
+
+    /// Gets the value of the `IPV6_MULTICAST_HOPS` option on this socket.
+    ///
+    /// For more information about this option, see [`UdpSocket::set_multicast_hop_limit_v6`].
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// #![feature(ipv6_hop_limit)]
+    /// use std::net::UdpSocket;
+    ///
+    /// let socket = UdpSocket::bind("[::1]:12345").expect("couldn't bind to address");
+    /// socket.set_multicast_hop_limit_v6(88).expect("set_multicast_hop_limit_v6 call failed");
+    /// assert_eq!(socket.multicast_hop_limit_v6().unwrap(), 88);
+    /// ```
+    #[unstable(feature = "ipv6_hop_limit", issue = "139166")]
+    pub fn multicast_hop_limit_v6(&self) -> io::Result<u8> {
+        self.0.multicast_hop_limit_v6()
+    }
+
     /// Executes an operation of the `IP_ADD_MEMBERSHIP` type.
     ///
     /// This function specifies a new multicast group for this socket to join.

library/std/src/net/udp/tests.rs

@@ -353,6 +353,17 @@ fn ttl() {
     assert_eq!(ttl, t!(stream.ttl()));
 }
 
+#[test]
+#[cfg(not(all(target_os = "wasi", any(target_env = "p2", target_env = "p3"))))]
+fn hop_limit() {
+    let hlim = 100;
+
+    let stream = t!(UdpSocket::bind(LOCALHOST_IP6));
+
+    t!(stream.set_hop_limit_v6(hlim));
+    assert_eq!(hlim, t!(stream.hop_limit_v6()));
+}
+
 #[test]
 fn set_nonblocking() {
     each_ip(&mut |socket, _| {

library/std/src/sys/net/connection/sgx.rs

@@ -9,6 +9,7 @@ use crate::sys::{AsInner, FromInner, IntoInner, TryIntoInner, sgx_ineffective, u
 use crate::time::Duration;
 
 const DEFAULT_FAKE_TTL: u32 = 64;
+const DEFAULT_FAKE_HLIM: u8 = 64;
 
 #[derive(Debug, Clone)]
 pub struct Socket {
@@ -243,6 +244,14 @@ impl TcpStream {
         sgx_ineffective(DEFAULT_FAKE_TTL)
     }
 
+    pub fn set_hop_limit_v6(&self, _: u8) -> io::Result<()> {
+        sgx_ineffective(())
+    }
+
+    pub fn hop_limit_v6(&self) -> io::Result<u8> {
+        sgx_ineffective(DEFAULT_FAKE_HLIM)
+    }
+
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
         Ok(None)
     }
@@ -322,6 +331,14 @@ impl TcpListener {
         sgx_ineffective(DEFAULT_FAKE_TTL)
     }
 
+    pub fn set_hop_limit_v6(&self, _: u8) -> io::Result<()> {
+        sgx_ineffective(())
+    }
+
+    pub fn hop_limit_v6(&self) -> io::Result<u8> {
+        sgx_ineffective(DEFAULT_FAKE_HLIM)
+    }
+
     pub fn set_only_v6(&self, _: bool) -> io::Result<()> {
         sgx_ineffective(())
     }
@@ -461,6 +478,22 @@ impl UdpSocket {
         self.0
     }
 
+    pub fn set_hop_limit_v6(&self, _: u8) -> io::Result<()> {
+        self.0
+    }
+
+    pub fn hop_limit_v6(&self) -> io::Result<u8> {
+        self.0
+    }
+
+    pub fn set_multicast_hop_limit_v6(&self, _: u8) -> io::Result<()> {
+        self.0
+    }
+
+    pub fn multicast_hop_limit_v6(&self) -> io::Result<u8> {
+        self.0
+    }
+
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
         self.0
     }

library/std/src/sys/net/connection/socket/mod.rs

@@ -498,6 +498,27 @@ impl TcpStream {
         Ok(raw as u32)
     }
 
+    #[cfg(not(all(target_os = "wasi", any(target_env = "p2", target_env = "p3"))))]
+    pub fn set_hop_limit_v6(&self, limit: u8) -> io::Result<()> {
+        unsafe { setsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_UNICAST_HOPS, limit as c_int) }
+    }
+
+    #[cfg(all(target_os = "wasi", any(target_env = "p2", target_env = "p3")))]
+    pub fn set_hop_limit_v6(&self, _: u8) -> io::Result<()> {
+        Err(io::Error::new(ErrorKind::Unsupported, "not supported on this platform"))
+    }
+
+    #[cfg(not(all(target_os = "wasi", any(target_env = "p2", target_env = "p3"))))]
+    pub fn hop_limit_v6(&self) -> io::Result<u8> {
+        let raw: c_int = unsafe { getsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_UNICAST_HOPS)? };
+        Ok(raw as u8)
+    }
+
+    #[cfg(all(target_os = "wasi", any(target_env = "p2", target_env = "p3")))]
+    pub fn hop_limit_v6(&self) -> io::Result<u8> {
+        Err(io::Error::new(ErrorKind::Unsupported, "not supported on this platform"))
+    }
+
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
         self.inner.take_error()
     }
@@ -626,6 +647,27 @@ impl TcpListener {
         Ok(raw as u32)
     }
 
+    #[cfg(not(all(target_os = "wasi", any(target_env = "p2", target_env = "p3"))))]
+    pub fn set_hop_limit_v6(&self, limit: u8) -> io::Result<()> {
+        unsafe { setsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_UNICAST_HOPS, limit as c_int) }
+    }
+
+    #[cfg(all(target_os = "wasi", any(target_env = "p2", target_env = "p3")))]
+    pub fn set_hop_limit_v6(&self, _: u8) -> io::Result<()> {
+        Err(io::Error::new(ErrorKind::Unsupported, "not supported on this platform"))
+    }
+
+    #[cfg(not(all(target_os = "wasi", any(target_env = "p2", target_env = "p3"))))]
+    pub fn hop_limit_v6(&self) -> io::Result<u8> {
+        let raw: c_int = unsafe { getsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_UNICAST_HOPS)? };
+        Ok(raw as u8)
+    }
+
+    #[cfg(all(target_os = "wasi", any(target_env = "p2", target_env = "p3")))]
+    pub fn hop_limit_v6(&self) -> io::Result<u8> {
+        Err(io::Error::new(ErrorKind::Unsupported, "not supported on this platform"))
+    }
+
     pub fn set_only_v6(&self, only_v6: bool) -> io::Result<()> {
         unsafe { setsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_V6ONLY, only_v6 as c_int) }
     }
@@ -850,6 +892,49 @@ impl UdpSocket {
         Ok(raw as u32)
     }
 
+    #[cfg(not(all(target_os = "wasi", any(target_env = "p2", target_env = "p3"))))]
+    pub fn set_hop_limit_v6(&self, limit: u8) -> io::Result<()> {
+        unsafe { setsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_UNICAST_HOPS, limit as c_int) }
+    }
+
+    #[cfg(all(target_os = "wasi", any(target_env = "p2", target_env = "p3")))]
+    pub fn set_hop_limit_v6(&self, _: u8) -> io::Result<()> {
+        Err(io::Error::new(ErrorKind::Unsupported, "not supported on this platform"))
+    }
+
+    #[cfg(not(all(target_os = "wasi", any(target_env = "p2", target_env = "p3"))))]
+    pub fn hop_limit_v6(&self) -> io::Result<u8> {
+        let raw: c_int = unsafe { getsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_UNICAST_HOPS)? };
+        Ok(raw as u8)
+    }
+
+    #[cfg(all(target_os = "wasi", any(target_env = "p2", target_env = "p3")))]
+    pub fn hop_limit_v6(&self) -> io::Result<u8> {
+        Err(io::Error::new(ErrorKind::Unsupported, "not supported on this platform"))
+    }
+
+    #[cfg(not(all(target_os = "wasi", any(target_env = "p2", target_env = "p3"))))]
+    pub fn set_multicast_hop_limit_v6(&self, limit: u8) -> io::Result<()> {
+        unsafe { setsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_MULTICAST_HOPS, limit as c_int) }
+    }
+
+    #[cfg(all(target_os = "wasi", any(target_env = "p2", target_env = "p3")))]
+    pub fn set_multicast_hop_limit_v6(&self, _: u8) -> io::Result<()> {
+        Err(io::Error::new(ErrorKind::Unsupported, "not supported on this platform"))
+    }
+
+    #[cfg(not(all(target_os = "wasi", any(target_env = "p2", target_env = "p3"))))]
+    pub fn multicast_hop_limit_v6(&self) -> io::Result<u8> {
+        let raw: c_int =
+            unsafe { getsockopt(&self.inner, c::IPPROTO_IPV6, c::IPV6_MULTICAST_HOPS)? };
+        Ok(raw as u8)
+    }
+
+    #[cfg(all(target_os = "wasi", any(target_env = "p2", target_env = "p3")))]
+    pub fn multicast_hop_limit_v6(&self) -> io::Result<u8> {
+        Err(io::Error::new(ErrorKind::Unsupported, "not supported on this platform"))
+    }
+
     pub fn take_error(&self) -> io::Result<Option<io::Error>> {
         self.inner.take_error()
     }