unix: Add HopLimit to IpAncillary

Extend UdpSocket to send and receive hop-limit.

Author: LinkTed

library/std/src/os/unix/net/ancillary/ip.rs

@@ -60,6 +60,7 @@ impl Socket {
 #[non_exhaustive]
 pub enum IpAncillaryData {
     Ttl(u8),
+    HopLimit(u8),
 }
 
 impl IpAncillaryData {
@@ -84,6 +85,17 @@ impl IpAncillaryData {
         IpAncillaryData::Ttl(ttl)
     }
 
+    /// Create a `AncillaryData::HopLimit` variant.
+    ///
+    /// # Safety
+    ///
+    /// `data` must contain a valid control message and the control message must be type of
+    /// `IPPROTO_IPV6` and level of `IPV6_HOPLIMIT`.
+    unsafe fn as_hop_limit(data: &[u8]) -> Self {
+        let hop_limit = IpAncillaryData::as_u8(data);
+        IpAncillaryData::HopLimit(hop_limit)
+    }
+
     unsafe fn try_from(cmsg: &libc::cmsghdr) -> Result<Self, AncillaryError> {
         let data = get_data_from_cmsghdr(cmsg);
 
@@ -94,6 +106,12 @@ impl IpAncillaryData {
                     Err(AncillaryError::Unknown { cmsg_level: libc::IPPROTO_IP, cmsg_type })
                 }
             },
+            libc::IPPROTO_IPV6 => match (*cmsg).cmsg_type {
+                libc::IPV6_HOPLIMIT => Ok(IpAncillaryData::as_hop_limit(data)),
+                cmsg_type => {
+                    Err(AncillaryError::Unknown { cmsg_level: libc::IPPROTO_IPV6, cmsg_type })
+                }
+            },
             cmsg_level => Err(AncillaryError::Unknown { cmsg_level, cmsg_type: (*cmsg).cmsg_type }),
         }
     }
@@ -146,7 +164,7 @@ pub struct IpAncillary<'a> {
 }
 
 impl<'a> IpAncillary<'a> {
-    /// Create an ancillary data with the given buffer.
+    /// Create ancillary data backed by the given buffer.
     ///
     /// # Example
     ///
@@ -186,12 +204,53 @@ impl<'a> IpAncillary<'a> {
         self.inner.messages()
     }
 
+    /// Add hop-limit to the ancillary data.
+    ///
+    /// The function returns `true` if there was enough space in the buffer.
+    /// If there was not enough space then no hop-limit was appended.
+    /// This adds a control message with the level `IPPROTO_IPV6` and type `IPV6_HOPLIMIT`.
+    ///
+    /// # Example
+    /// ```no_run
+    /// #![feature(unix_socket_ancillary_data)]
+    /// use std::io::IoSlice;
+    /// use std::net::UdpSocket;
+    /// use std::os::unix::net::IpAncillary;
+    ///
+    /// fn main() -> std::io::Result<()> {
+    ///     let sock = UdpSocket::bind("[::1]:34254")?;
+    ///     sock.connect("[::1]:41203")?;
+    ///     let buf1 = [1; 8];
+    ///     let buf2 = [2; 16];
+    ///     let buf3 = [3; 8];
+    ///     let bufs = &[
+    ///         IoSlice::new(&buf1),
+    ///         IoSlice::new(&buf2),
+    ///         IoSlice::new(&buf3),
+    ///     ][..];
+    ///     let mut ancillary_buffer = [0; 128];
+    ///     let mut ancillary = IpAncillary::new(&mut ancillary_buffer[..]);
+    ///     ancillary.add_hop_limit(20);
+    ///     sock.send_vectored_with_ancillary(bufs, &mut ancillary)
+    ///         .expect("send_vectored_with_ancillary function failed");
+    ///     Ok(())
+    /// }
+    /// ```
+    #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+    pub fn add_hop_limit(&mut self, hop_limit: u8) -> bool {
+        let hop_limit: libc::c_int = hop_limit as libc::c_int;
+        self.inner.add_to_ancillary_data(
+            from_ref(&hop_limit),
+            libc::IPPROTO_IPV6,
+            libc::IPV6_HOPLIMIT,
+        )
+    }
+
     /// Add TTL to the ancillary data.
     ///
     /// The function returns `true` if there was enough space in the buffer.
     /// If there was not enough space then no file descriptors was appended.
-    /// Technically, that means this operation adds a control message with the level `IPPROTO_IP`
-    /// and type `IP_TTL`.
+    /// This adds a control message with the level `IPPROTO_IP` and type `IP_TTL`.
     ///
     /// # Example
     /// ```no_run

library/std/src/os/unix/net/ancillary/unix.rs

@@ -323,8 +323,7 @@ impl<'a> UnixAncillary<'a> {
     ///
     /// The function returns `true` if there was enough space in the buffer.
     /// If there was not enough space then no file descriptors was appended.
-    /// Technically, that means this operation adds a control message with the level `SOL_SOCKET`
-    /// and type `SCM_RIGHTS`.
+    /// This adds a control message with the level `SOL_SOCKET` and type `SCM_RIGHTS`.
     ///
     /// # Example
     ///
@@ -356,8 +355,8 @@ impl<'a> UnixAncillary<'a> {
     ///
     /// The function returns `true` if there was enough space in the buffer.
     /// If there was not enough space then no credentials was appended.
-    /// Technically, that means this operation adds a control message with the level `SOL_SOCKET`
-    /// and type `SCM_CREDENTIALS` or `SCM_CREDS`.
+    /// This adds a control message with the level `SOL_SOCKET` and type `SCM_CREDENTIALS`
+    /// or `SCM_CREDS`.
     ///
     #[doc(cfg(any(target_os = "android", target_os = "linux",)))]
     #[cfg(any(doc, target_os = "android", target_os = "linux",))]

library/std/src/os/unix/net/tests.rs

@@ -1,6 +1,8 @@
 use super::*;
 use crate::io::prelude::*;
 use crate::io::{self, ErrorKind, IoSlice, IoSliceMut};
+#[cfg(any(target_os = "android", target_os = "emscripten", target_os = "linux"))]
+use crate::net::UdpSocket;
 use crate::sys_common::io::test::tmpdir;
 use crate::thread;
 use crate::time::Duration;
@@ -631,14 +633,7 @@ fn test_send_vectored_with_ancillary_unix_datagram() {
 
 #[cfg(any(target_os = "android", target_os = "emscripten", target_os = "linux"))]
 #[test]
-fn test_send_vectored_with_ancillary_to_udp_socket() {
-    use super::{IpAncillary, IpAncillaryData};
-    use crate::{
-        io::{IoSlice, IoSliceMut},
-        iter::FromIterator,
-        net::UdpSocket,
-    };
-
+fn test_send_vectored_with_ancillary_to_udp_socket_ttl() {
     let socket1 = or_panic!(UdpSocket::bind("127.0.0.1:0"));
     let socket2 = or_panic!(UdpSocket::bind("127.0.0.1:0"));
 
@@ -673,6 +668,49 @@ fn test_send_vectored_with_ancillary_to_udp_socket() {
 
     let mut ancillary_data_vec = Vec::from_iter(ancillary2.messages());
     assert_eq!(ancillary_data_vec.len(), 1);
-    let IpAncillaryData::Ttl(ttl) = ancillary_data_vec.pop().unwrap().unwrap();
-    assert_eq!(ttl, 20);
+    assert!(
+        matches!(ancillary_data_vec.pop().unwrap().unwrap(), IpAncillaryData::Ttl(ttl) if ttl == 20)
+    );
+}
+
+#[cfg(any(target_os = "android", target_os = "emscripten", target_os = "linux"))]
+#[test]
+fn test_send_vectored_with_ancillary_to_udp_socket_hop_limit() {
+    let socket1 = or_panic!(UdpSocket::bind("[::1]:0"));
+    let socket2 = or_panic!(UdpSocket::bind("[::1]:0"));
+
+    let addr1 = or_panic!(socket1.local_addr());
+    let addr2 = or_panic!(socket2.local_addr());
+
+    or_panic!(socket2.set_recvhoplimit(true));
+
+    let buf1 = [1; 8];
+    let bufs_send = &[IoSlice::new(&buf1[..])][..];
+
+    let mut ancillary1_buffer = [0; 64];
+    let mut ancillary1 = IpAncillary::new(&mut ancillary1_buffer[..]);
+    assert!(ancillary1.add_hop_limit(20));
+
+    let usize =
+        or_panic!(socket1.send_vectored_with_ancillary_to(&bufs_send, &mut ancillary1, &addr2));
+    assert_eq!(usize, 8);
+
+    let mut buf2 = [0; 8];
+    let mut bufs_recv = &mut [IoSliceMut::new(&mut buf2[..])][..];
+
+    let mut ancillary2_buffer = [0; 64];
+    let mut ancillary2 = IpAncillary::new(&mut ancillary2_buffer[..]);
+
+    let (usize, truncated, addr) =
+        or_panic!(socket2.recv_vectored_with_ancillary_from(&mut bufs_recv, &mut ancillary2));
+    assert_eq!(usize, 8);
+    assert_eq!(truncated, false);
+    assert_eq!(addr1, addr);
+    assert_eq!(buf1, buf2);
+
+    let mut ancillary_data_vec = Vec::from_iter(ancillary2.messages());
+    assert_eq!(ancillary_data_vec.len(), 1);
+    assert!(
+        matches!(ancillary_data_vec.pop().unwrap().unwrap(), IpAncillaryData::HopLimit(ttl) if ttl == 20)
+    );
 }

library/std/src/os/unix/net/udp.rs

@@ -6,6 +6,39 @@ use crate::{
 };
 
 impl UdpSocket {
+    /// Sets the value of the `IPV6_RECVHOPLIMIT` option for this socket.
+    ///
+    /// If enabled, received packets will come with ancillary data ([`IpAncillary`]) providing
+    /// the hop-limit value of the packet.
+    ///
+    /// # Examples
+    ///
+    ///```no_run
+    /// #![feature(unix_socket_ancillary_data)]
+    /// use std::net::UdpSocket;
+    ///
+    /// fn main() -> std::io::Result<()> {
+    ///     let socket = UdpSocket::bind("[::1]:34254")?;
+    ///     socket.set_recvhoplimit(true)?;
+    ///     Ok(())
+    /// }
+    /// ```
+    #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+    pub fn set_recvhoplimit(&self, recvhoplimit: bool) -> io::Result<()> {
+        self.as_inner().set_recvhoplimit(recvhoplimit)
+    }
+
+    /// Get the current value of the socket for receiving TTL in [`IpAncillary`].
+    /// This value can be change by [`set_recvhoplimit`].
+    ///
+    /// Get the socket option `IPV6_RECVHOPLIMIT`.
+    ///
+    /// [`set_recvhoplimit`]: UdpSocket::set_recvhoplimit
+    #[unstable(feature = "unix_socket_ancillary_data", issue = "76915")]
+    pub fn recvhoplimit(&self) -> io::Result<bool> {
+        self.as_inner().recvhoplimit()
+    }
+
     /// Sets the value of the `IP_RECVTTL` option for this socket.
     ///
     /// If enabled, received packets will come with ancillary data ([`IpAncillary`]) providing

library/std/src/sys/unix/net.rs

@@ -393,6 +393,18 @@ impl Socket {
         Ok(passcred != 0)
     }
 
+    #[cfg(any(target_os = "android", target_os = "emscripten", target_os = "linux"))]
+    pub fn set_recvhoplimit(&self, recvhoplimit: bool) -> io::Result<()> {
+        setsockopt(self, libc::IPPROTO_IPV6, libc::IPV6_RECVHOPLIMIT, recvhoplimit as libc::c_int)
+    }
+
+    #[cfg(any(target_os = "android", target_os = "emscripten", target_os = "linux"))]
+    pub fn recvhoplimit(&self) -> io::Result<bool> {
+        let recvhoplimit: libc::c_int =
+            getsockopt(self, libc::IPPROTO_IPV6, libc::IPV6_RECVHOPLIMIT)?;
+        Ok(recvhoplimit != 0)
+    }
+
     #[cfg(any(target_os = "android", target_os = "emscripten", target_os = "linux"))]
     pub fn set_recvttl(&self, recvttl: bool) -> io::Result<()> {
         setsockopt(self, libc::IPPROTO_IP, libc::IP_RECVTTL, recvttl as libc::c_int)

library/std/src/sys_common/net.rs

@@ -507,6 +507,16 @@ impl UdpSocket {
         self.inner.recv_from(buf)
     }
 
+    #[cfg(any(target_os = "android", target_os = "emscripten", target_os = "linux"))]
+    pub fn set_recvhoplimit(&self, recvhoplimit: bool) -> io::Result<()> {
+        self.inner.set_recvhoplimit(recvhoplimit)
+    }
+
+    #[cfg(any(target_os = "android", target_os = "emscripten", target_os = "linux"))]
+    pub fn recvhoplimit(&self) -> io::Result<bool> {
+        self.inner.recvhoplimit()
+    }
+
     #[cfg(any(target_os = "android", target_os = "emscripten", target_os = "linux"))]
     pub fn set_recvttl(&self, recvttl: bool) -> io::Result<()> {
         self.inner.set_recvttl(recvttl)