feat(ip_recverr): Add ICMP error struct, start with linux

chore(ip_recverr): Testing with socket setup similar to cmsg in recv

feat(ip_recverr): Initialised socket options for IPV4 and V6

feat(ip_recverr): Add error read queue function

chore(ip_recverr): Add error handling after recieving normal packets

test(ip_recverr): Start the test cases for IP_RECVERR

test(ip_recverr): Complete the test cases for ip_recverr and ipv6

test(ip_recverr): handle expected send failure instead of panicking

style: Format the files using rustfmt

style(recv_err): Change the name of the unused function

refactor(ip_recverr): change the ICMPErr to enum kind

refactor(ip_recverr): COnversion from SockExtendedErr to ICMPErrKind

refactor(ip_recverr): Remove ICMPErr from recv and add seperate recv_icmp_err

test(ip_recverr): Change the test files following new method

Apply suggestions from code review

Co-authored-by: Thomas Eizinger <[email protected]>

refactor: address code review feedback
- Use early returns to reduce nesting
- Replace match with unwrap in tests
- Add non-Linux fallback implementation

fix(ip_recverr): Continue to next control message instead of return

test(ip_recverr): Fix the socket binding error from OS, now sends proper network error

fix(ip_recverr): rename IcmpError for non linux platforms

fix(pacing): allow ±0ns tolerance in computes_pause_correctly test on i386
-Used Duration::abs_diff() instead of manual difference for cleaner and more robust duration comparison.
-added inline formatting as required.

build(deps): bump rustls-platform-verifier from 0.6.1 to 0.6.2

Bumps [rustls-platform-verifier](https://github.com/rustls/rustls-platform-verifier) from 0.6.1 to 0.6.2.
- [Release notes](https://github.com/rustls/rustls-platform-verifier/releases)
- [Changelog](https://github.com/rustls/rustls-platform-verifier/blob/main/CHANGELOG)
- [Commits](rustls/rustls-platform-verifier@v/0.6.1...v/0.6.2)

---
updated-dependencies:
- dependency-name: rustls-platform-verifier
  dependency-version: 0.6.2
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <[email protected]>

refactor(ip_recverr): Change SockExtendedError as suggested

fix(ip_recverr): Add IcmpError for non linux platforms

refactor(ip_recverr): Change to SockExtendedError Kind

Author: RaghavendraRQ

Cargo.lock

@@ -273,14 +273,18 @@ mod tests {
 
         let pace_duration = Duration::from_nanos((TARGET_BURST_INTERVAL.as_nanos() * 4 / 5) as u64);
 
-        assert_eq!(
-            pacer
-                .delay(rtt, mtu as u64, mtu, window, old_instant)
-                .expect("Send must be delayed")
-                .duration_since(old_instant),
-            pace_duration
-        );
+        let actual_delay = pacer
+            .delay(rtt, mtu as u64, mtu, window, old_instant)
+            .expect("Send must be delayed")
+            .duration_since(old_instant);
+
+        let diff = actual_delay.abs_diff(pace_duration);
 
+        // Allow up to 2ns difference due to rounding
+        assert!(
+            diff < Duration::from_nanos(2),
+            "expected ≈ {pace_duration:?}, got {actual_delay:?} (diff {diff:?})"
+        );
         // Refill half of the tokens
         assert_eq!(
             pacer.delay(

quinn-proto/src/connection/pacing.rs

@@ -238,3 +238,23 @@ impl EcnCodepoint {
         })
     }
 }
+
+#[cfg(target_os = "linux")]
+#[derive(Clone, Debug, Copy)]
+pub struct IcmpError {
+    pub dst: SocketAddr,
+    pub kind: IcmpErrorKind,
+}
+
+#[cfg(not(target_os = "linux"))]
+pub struct IcmpError;
+
+#[cfg(target_os = "linux")]
+#[derive(Clone, Debug, Copy, PartialEq, Eq)]
+pub enum IcmpErrorKind {
+    NetworkUnreachable,
+    HostUnreachable,
+    PortUnreachable,
+    PacketTooBig,
+    Other { icmp_type: u8, icmp_code: u8 },
+}

quinn-udp/src/lib.rs

@@ -14,6 +14,11 @@ use std::{
 
 use socket2::SockRef;
 
+use crate::IcmpError;
+
+#[cfg(target_os = "linux")]
+use crate::IcmpErrorKind;
+
 use super::{
     EcnCodepoint, IO_ERROR_LOG_INTERVAL, RecvMeta, Transmit, UdpSockRef, cmsg, log_sendmsg_error,
 };
@@ -33,6 +38,66 @@ pub(crate) struct msghdr_x {
     pub msg_datalen: usize,
 }
 
+#[cfg(target_os = "linux")]
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+pub(crate) struct SockExtendedError {
+    pub errno: u32,
+    pub origin: u8,
+    pub r#type: u8,
+    pub code: u8,
+    pub pad: u8,
+    pub info: u32,
+    pub data: u32,
+}
+
+#[cfg(target_os = "linux")]
+impl SockExtendedError {
+    fn kind(&self) -> IcmpErrorKind {
+        const ICMP_DEST_UNREACH: u8 = 3; // Type 3: Destination Unreachable
+        const ICMP_NET_UNREACH: u8 = 0;
+        const ICMP_HOST_UNREACH: u8 = 1;
+        const ICMP_PORT_UNREACH: u8 = 3;
+        const ICMP_FRAG_NEEDED: u8 = 4;
+
+        const ICMPV6_DEST_UNREACH: u8 = 1; // Type 1: Destination Unreachable for IPv6
+        const ICMPV6_NO_ROUTE: u8 = 0;
+        const ICMPV6_ADDR_UNREACH: u8 = 1;
+        const ICMPV6_PORT_UNREACH: u8 = 4;
+
+        const ICMPV6_PACKET_TOO_BIG: u8 = 2;
+
+        match (self.origin, self.r#type, self.code) {
+            (libc::SO_EE_ORIGIN_ICMP, ICMP_DEST_UNREACH, ICMP_NET_UNREACH) => {
+                IcmpErrorKind::NetworkUnreachable
+            }
+            (libc::SO_EE_ORIGIN_ICMP, ICMP_DEST_UNREACH, ICMP_HOST_UNREACH) => {
+                IcmpErrorKind::HostUnreachable
+            }
+            (libc::SO_EE_ORIGIN_ICMP, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH) => {
+                IcmpErrorKind::PortUnreachable
+            }
+            (libc::SO_EE_ORIGIN_ICMP, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED) => {
+                IcmpErrorKind::PacketTooBig
+            }
+            (libc::SO_EE_ORIGIN_ICMP6, ICMPV6_DEST_UNREACH, ICMPV6_NO_ROUTE) => {
+                IcmpErrorKind::NetworkUnreachable
+            }
+            (libc::SO_EE_ORIGIN_ICMP6, ICMPV6_DEST_UNREACH, ICMPV6_ADDR_UNREACH) => {
+                IcmpErrorKind::HostUnreachable
+            }
+            (libc::SO_EE_ORIGIN_ICMP6, ICMPV6_DEST_UNREACH, ICMPV6_PORT_UNREACH) => {
+                IcmpErrorKind::PortUnreachable
+            }
+            (libc::SO_EE_ORIGIN_ICMP6, ICMPV6_PACKET_TOO_BIG, _) => IcmpErrorKind::PacketTooBig,
+            _ => IcmpErrorKind::Other {
+                icmp_type: self.r#type,
+                icmp_code: self.code,
+            },
+        }
+    }
+}
+
 #[cfg(apple_fast)]
 extern "C" {
     fn recvmsg_x(
@@ -122,6 +187,20 @@ impl UdpSocketState {
             }
         }
 
+        // Enable IP_RECVERR and IPV6_RECVERR for ICMP Errors
+        #[cfg(target_os = "linux")]
+        if is_ipv4 {
+            if let Err(_err) =
+                set_socket_option(&*io, libc::IPPROTO_IP, libc::IP_RECVERR, OPTION_ON)
+            {
+                crate::log::debug!("Failed to enable IP_RECVERR: {}", _err);
+            }
+        } else if let Err(_err) =
+            set_socket_option(&*io, libc::IPPROTO_IPV6, libc::IPV6_RECVERR, OPTION_ON)
+        {
+            crate::log::debug!("Failed to enable IPV6_RECVERR: {}", _err);
+        }
+
         let mut may_fragment = false;
         #[cfg(any(target_os = "linux", target_os = "android"))]
         {
@@ -233,6 +312,16 @@ impl UdpSocketState {
         recv(socket.0, bufs, meta)
     }
 
+    #[cfg(target_os = "linux")]
+    pub fn recv_icmp_err(&self, socket: UdpSockRef<'_>) -> io::Result<Option<IcmpError>> {
+        recv_err(socket.0)
+    }
+
+    #[cfg(not(target_os = "linux"))]
+    pub fn recv_icmp_err(&self, socket: UdpSockRef<'_>) -> io::Result<Option<IcmpError>> {
+        recv_err(socket.0)
+    }
+
     /// The maximum amount of segments which can be transmitted if a platform
     /// supports Generic Send Offload (GSO).
     ///
@@ -500,6 +589,7 @@ fn recv(io: SockRef<'_>, bufs: &mut [IoSliceMut<'_>], meta: &mut [RecvMeta]) ->
     for i in 0..(msg_count as usize) {
         meta[i] = decode_recv(&names[i], &hdrs[i].msg_hdr, hdrs[i].msg_len as usize)?;
     }
+
     Ok(msg_count as usize)
 }
 
@@ -795,6 +885,99 @@ fn decode_recv(
     })
 }
 
+#[cfg(target_os = "linux")]
+fn recv_err(io: SockRef<'_>) -> io::Result<Option<IcmpError>> {
+    use std::mem;
+
+    let fd = io.as_raw_fd();
+
+    let mut control = cmsg::Aligned([0u8; CMSG_LEN]);
+
+    // We don't need actual data, just the error info
+    let mut iovec = libc::iovec {
+        iov_base: std::ptr::null_mut(),
+        iov_len: 0,
+    };
+
+    let mut addr_storage: libc::sockaddr_storage = unsafe { mem::zeroed() };
+
+    // Have followed the previous declarations
+    let mut hdr: libc::msghdr = unsafe { mem::zeroed() };
+    hdr.msg_name = &mut addr_storage as *mut _ as *mut _;
+    hdr.msg_namelen = mem::size_of::<libc::sockaddr_storage>() as libc::socklen_t;
+    hdr.msg_iov = &mut iovec;
+    hdr.msg_iovlen = 1;
+    hdr.msg_control = control.0.as_mut_ptr() as *mut _;
+    hdr.msg_controllen = CMSG_LEN as _;
+
+    let ret = unsafe { libc::recvmsg(fd, &mut hdr, libc::MSG_ERRQUEUE) };
+
+    if ret < 0 {
+        let err = io::Error::last_os_error();
+        // EAGAIN/EWOULDBLOCK means no error in queue - this is normal
+        if err.kind() == io::ErrorKind::WouldBlock {
+            return Ok(None);
+        }
+        return Err(err);
+    }
+
+    let cmsg_iter = unsafe { cmsg::Iter::new(&hdr) };
+
+    for cmsg in cmsg_iter {
+        const IP_RECVERR: libc::c_int = 11;
+        const IPV6_RECVERR: libc::c_int = 25;
+
+        let is_ipv4_err = cmsg.cmsg_level == libc::IPPROTO_IP && cmsg.cmsg_type == IP_RECVERR;
+        let is_ipv6_err = cmsg.cmsg_level == libc::IPPROTO_IPV6 && cmsg.cmsg_type == IPV6_RECVERR;
+
+        if !is_ipv4_err && !is_ipv6_err {
+            continue;
+        }
+
+        let err_data = unsafe { cmsg::decode::<SockExtendedError, libc::cmsghdr>(cmsg) };
+
+        let dst = unsafe {
+            let addr_ptr = &addr_storage as *const _ as *const libc::sockaddr;
+            match (*addr_ptr).sa_family as i32 {
+                libc::AF_INET => {
+                    let addr_in = &*(addr_ptr as *const libc::sockaddr_in);
+                    SocketAddr::V4(std::net::SocketAddrV4::new(
+                        std::net::Ipv4Addr::from(u32::from_be(addr_in.sin_addr.s_addr)),
+                        u16::from_be(addr_in.sin_port),
+                    ))
+                }
+                libc::AF_INET6 => {
+                    let addr_in6 = &*(addr_ptr as *const libc::sockaddr_in6);
+                    SocketAddr::V6(std::net::SocketAddrV6::new(
+                        std::net::Ipv6Addr::from(addr_in6.sin6_addr.s6_addr),
+                        u16::from_be(addr_in6.sin6_port),
+                        addr_in6.sin6_flowinfo,
+                        addr_in6.sin6_scope_id,
+                    ))
+                }
+                _ => {
+                    crate::log::warn!(
+                        "Ignoring ICMP error with unknown address family: {}",
+                        addr_storage.ss_family
+                    );
+                    continue;
+                }
+            }
+        };
+
+        return Ok(Some(IcmpError {
+            dst,
+            kind: err_data.kind(),
+        }));
+    }
+    Ok(None)
+}
+
+#[cfg(not(target_os = "linux"))]
+fn recv_err(_io: SockRef<'_>) -> io::Result<Option<IcmpError>> {
+    Ok(None)
+}
+
 #[cfg(not(apple_slow))]
 // Chosen somewhat arbitrarily; might benefit from additional tuning.
 pub(crate) const BATCH_SIZE: usize = 32;