style: Format the files using rustfmt

Author: RaghavendraRQ

quinn-udp/src/lib.rs

@@ -239,7 +239,6 @@ impl EcnCodepoint {
     }
 }
 
-
 #[cfg(target_os = "linux")]
 #[repr(C)]
 #[derive(Clone, Copy, Debug)]
@@ -251,13 +250,13 @@ struct SockExtendedErr {
     ee_pad: u8,
     ee_info: u32,
     ee_data: u32,
-} 
+}
 
 #[cfg(target_os = "linux")]
 #[derive(Clone, Debug, Copy)]
 pub struct ICMPError {
     pub errno: u32,
     pub origin: u8,
     pub err_no: u8,
-    pub code: u8
+    pub code: u8,
 }

quinn-udp/src/unix.rs

@@ -125,27 +125,18 @@ impl UdpSocketState {
             }
         }
 
-
         // Enable IP_RECVERR and IPV6_RECVERR for ICMP Errors
         #[cfg(target_os = "linux")]
         if is_ipv4 {
-            if let Err(e) = set_socket_option(
-                &*io,
-                libc::IPPROTO_IP,
-                libc::IP_RECVERR,
-                OPTION_ON
-            ) {
+            if let Err(e) = set_socket_option(&*io, libc::IPPROTO_IP, libc::IP_RECVERR, OPTION_ON) {
                 crate::log::warn!("Failed to enable IP_RECVERR: {}", e);
-            } 
+            }
         } else {
-            if let Err(e) = set_socket_option(
-                &*io,
-                libc::IPPROTO_IPV6,
-                libc::IPV6_RECVERR,
-                OPTION_ON
-            ) {
+            if let Err(e) =
+                set_socket_option(&*io, libc::IPPROTO_IPV6, libc::IPV6_RECVERR, OPTION_ON)
+            {
                 crate::log::warn!("Failed to enable IPV6_RECVERR: {}", e);
-            } 
+            }
         }
 
         let mut may_fragment = false;
@@ -533,19 +524,22 @@ fn recv(io: SockRef<'_>, bufs: &mut [IoSliceMut<'_>], meta: &mut [RecvMeta]) ->
         use std::os::fd::AsFd;
         // Clear the error queue after processing normal packets
         while let Ok(Some((addr, err))) = recv_err(&io.as_fd()) {
-            crate::log::debug!("ICMP error from {}: origin: {}, type: {}, code: {}, err_no: {} ", 
-            addr, 
-            err.ee_origin, 
-            err.ee_type, 
-            err.ee_code, 
-            err.ee_errno
-        );
-        match (err.ee_origin, err.ee_type, err.ee_code) {
-            (libc::SO_EE_ORIGIN_ICMP, 3, 0) => crate::log::warn!("Network Unreachable: {}", addr),
-            (libc::SO_EE_ORIGIN_ICMP, 3, 1) => crate::log::warn!("Host Unreachable: {}", addr),
-            (libc::SO_EE_ORIGIN_ICMP, 3, 2) => crate::log::warn!("PORT Unreachable: {}", addr),
-            (libc::SO_EE_ORIGIN_ICMP6, 1, 0) => crate::log::warn!("IPv6 Unreachable: {}", addr),
-            _ => crate::log::warn!("Other ICMP error: {:?}", err)
+            crate::log::debug!(
+                "ICMP error from {}: origin: {}, type: {}, code: {}, err_no: {} ",
+                addr,
+                err.ee_origin,
+                err.ee_type,
+                err.ee_code,
+                err.ee_errno
+            );
+            match (err.ee_origin, err.ee_type, err.ee_code) {
+                (libc::SO_EE_ORIGIN_ICMP, 3, 0) => {
+                    crate::log::warn!("Network Unreachable: {}", addr)
+                }
+                (libc::SO_EE_ORIGIN_ICMP, 3, 1) => crate::log::warn!("Host Unreachable: {}", addr),
+                (libc::SO_EE_ORIGIN_ICMP, 3, 2) => crate::log::warn!("PORT Unreachable: {}", addr),
+                (libc::SO_EE_ORIGIN_ICMP6, 1, 0) => crate::log::warn!("IPv6 Unreachable: {}", addr),
+                _ => crate::log::warn!("Other ICMP error: {:?}", err),
             };
         }
     }
@@ -845,7 +839,6 @@ fn decode_recv(
     })
 }
 
-
 #[cfg(target_os = "linux")]
 fn recv_err(io: &impl AsRawFd) -> io::Result<Option<(SocketAddr, SockExtendedErr)>> {
     use std::mem;
@@ -860,7 +853,7 @@ fn recv_err(io: &impl AsRawFd) -> io::Result<Option<(SocketAddr, SockExtendedErr
         iov_len: 0,
     };
 
-    let mut addr_storage: libc::sockaddr_storage  = unsafe { mem::zeroed() };
+    let mut addr_storage: libc::sockaddr_storage = unsafe { mem::zeroed() };
 
     // Have followed the previous declarations
     let mut hdr: libc::msghdr = unsafe { mem::zeroed() };
@@ -871,10 +864,7 @@ fn recv_err(io: &impl AsRawFd) -> io::Result<Option<(SocketAddr, SockExtendedErr
     hdr.msg_control = control.0.as_mut_ptr() as *mut _;
     hdr.msg_controllen = control.0.len() as _;
 
-
-    let ret = unsafe {
-        libc::recvmsg(fd, &mut hdr, libc::MSG_ERRQUEUE)
-    };
+    let ret = unsafe { libc::recvmsg(fd, &mut hdr, libc::MSG_ERRQUEUE) };
 
     if ret < 0 {
         let err = io::Error::last_os_error();
@@ -885,19 +875,17 @@ fn recv_err(io: &impl AsRawFd) -> io::Result<Option<(SocketAddr, SockExtendedErr
         return Err(err);
     }
 
-    let mut cmsg_ptr = unsafe { libc::CMSG_FIRSTHDR(&hdr)};
+    let mut cmsg_ptr = unsafe { libc::CMSG_FIRSTHDR(&hdr) };
 
     while !cmsg_ptr.is_null() {
         let cmsg = unsafe { &*cmsg_ptr };
-        
+
         const IP_RECVERR: libc::c_int = 11;
         const IPV6_RECVERR: libc::c_int = 25;
-        
-        let is_ip_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;
-        
+
+        let is_ip_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_ip_err || is_ipv6_err {
             let err_data = unsafe {
                 let data_ptr = libc::CMSG_DATA(cmsg_ptr);
@@ -926,24 +914,21 @@ fn recv_err(io: &impl AsRawFd) -> io::Result<Option<(SocketAddr, SockExtendedErr
                     _ => return Ok(None), // Unknown address family
                 }
             };
-            
+
             return Ok(Some((addr, *err_data)));
         }
 
-        cmsg_ptr = unsafe { libc::CMSG_NXTHDR(&hdr, cmsg_ptr)};
-
+        cmsg_ptr = unsafe { libc::CMSG_NXTHDR(&hdr, cmsg_ptr) };
     }
     Ok(None)
 }
 
-
-// I don't know about how other platforms handle this.  
+// I don't know about how other platforms handle this.
 #[cfg(not(target_os = "linux"))]
 fn recv_error_queue(_io: &impl AsRawFd) -> io::Result<Option<(SocketAddr, ())>> {
-    Ok(None) 
+    Ok(None)
 }
 
-
 #[cfg(not(apple_slow))]
 // Chosen somewhat arbitrarily; might benefit from additional tuning.
 pub(crate) const BATCH_SIZE: usize = 32;

quinn-udp/tests/tests.rs

@@ -375,47 +375,42 @@ fn ip_to_v6_mapped(x: IpAddr) -> IpAddr {
 fn test_ip_recverr() {
     use std::io::IoSliceMut;
     use std::time::Duration;
-    
+
     let socket = socket2::Socket::new(
         socket2::Domain::IPV4,
         socket2::Type::DGRAM,
         Some(socket2::Protocol::UDP),
     )
     .expect("failed to create socket");
-    
+
     // Bind to localhost
     let bind_addr = socket2::SockAddr::from(SocketAddrV4::new(Ipv4Addr::LOCALHOST, 0));
     socket.bind(&bind_addr).expect("failed to bind");
-    
+
     // Create UdpSocketState (this should enable IP_RECVERR)
-    let state = UdpSocketState::new((&socket).into())
-        .expect("failed to create UdpSocketState");
-    
+    let state = UdpSocketState::new((&socket).into()).expect("failed to create UdpSocketState");
+
     // Send to an unreachable address in the documentation range (192.0.2.0/24)
-    let unreachable_addr = SocketAddr::V4(SocketAddrV4::new(
-        Ipv4Addr::new(192, 0, 2, 1),
-        12345,
-    ));
-    
+    let unreachable_addr = SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(192, 0, 2, 1), 12345));
+
     let transmit = Transmit {
         destination: unreachable_addr,
         ecn: None,
         contents: b"test packet to unreachable destination",
         segment_size: None,
         src_ip: None,
     };
-    
+
     // Send the packet
     let state_result = state.try_send((&socket).into(), &transmit);
     assert!(state_result.is_err(), "Expected to fail to transmit");
 
-    
     std::thread::sleep(Duration::from_millis(200));
-    
+
     let mut buf = [0u8; 1500];
     let mut meta = RecvMeta::default();
     let mut received_icmp_error = false;
-    
+
     for attempt in 0..5 {
         match state.recv(
             (&socket).into(),
@@ -426,9 +421,14 @@ fn test_ip_recverr() {
                 println!("Attempt {}: Received {} messages", attempt, n);
             }
             Err(e) => {
-                println!("Attempt {}: Received error: {} (kind: {:?}, raw: {:?})", 
-                    attempt, e, e.kind(), e.raw_os_error());
-                
+                println!(
+                    "Attempt {}: Received error: {} (kind: {:?}, raw: {:?})",
+                    attempt,
+                    e,
+                    e.kind(),
+                    e.raw_os_error()
+                );
+
                 // Check if this is an ICMP-related error
                 match e.raw_os_error() {
                     Some(libc::EHOSTUNREACH) => {
@@ -457,7 +457,7 @@ fn test_ip_recverr() {
         }
         std::thread::sleep(Duration::from_millis(10));
     }
-    
+
     if received_icmp_error {
         println!("IP_RECVERR is working! Received ICMP error.");
     } else {
@@ -470,50 +470,44 @@ fn test_ip_recverr() {
 fn test_ipv6_recverr() {
     use std::io::IoSliceMut;
     use std::time::Duration;
-    
+
     let socket = socket2::Socket::new(
         socket2::Domain::IPV6,
         socket2::Type::DGRAM,
         Some(socket2::Protocol::UDP),
     )
     .expect("failed to create IPv6 socket");
-    
-    let bind_addr = socket2::SockAddr::from(SocketAddrV6::new(
-        Ipv6Addr::LOCALHOST,
-        0,
-        0,
-        0,
-    ));
+
+    let bind_addr = socket2::SockAddr::from(SocketAddrV6::new(Ipv6Addr::LOCALHOST, 0, 0, 0));
     socket.bind(&bind_addr).expect("failed to bind");
-    
-    let state = UdpSocketState::new((&socket).into())
-        .expect("failed to create UdpSocketState");
-    
+
+    let state = UdpSocketState::new((&socket).into()).expect("failed to create UdpSocketState");
+
     // Send to unreachable IPv6 address
     let unreachable_addr = SocketAddr::V6(SocketAddrV6::new(
         Ipv6Addr::new(0x2001, 0x0db8, 0, 0, 0, 0, 0, 1),
         12345,
         0,
         0,
     ));
-    
+
     let transmit = Transmit {
         destination: unreachable_addr,
         ecn: None,
         contents: b"test IPv6 packet",
         segment_size: None,
         src_ip: None,
     };
-    
+
     let state_res = state.try_send((&socket).into(), &transmit);
     assert!(state_res.is_err(), "Expected to fail to transmit");
-    
+
     std::thread::sleep(Duration::from_millis(200));
-    
+
     let mut buf = [0u8; 1500];
     let mut meta = RecvMeta::default();
     let mut received_icmp_error = false;
-    
+
     for attempt in 0..5 {
         match state.recv(
             (&socket).into(),
@@ -524,11 +518,18 @@ fn test_ipv6_recverr() {
                 println!("Attempt {}: Received {} messages", attempt, n);
             }
             Err(e) => {
-                println!("Attempt {}: Error: {} (raw: {:?})", attempt, e, e.raw_os_error());
-                
+                println!(
+                    "Attempt {}: Error: {} (raw: {:?})",
+                    attempt,
+                    e,
+                    e.raw_os_error()
+                );
+
                 match e.raw_os_error() {
-                    Some(libc::EHOSTUNREACH) | Some(libc::ENETUNREACH) | 
-                    Some(libc::ECONNREFUSED) | Some(libc::ETIMEDOUT) => {
+                    Some(libc::EHOSTUNREACH)
+                    | Some(libc::ENETUNREACH)
+                    | Some(libc::ECONNREFUSED)
+                    | Some(libc::ETIMEDOUT) => {
                         println!("✓ Received ICMPv6 error");
                         received_icmp_error = true;
                         break;
@@ -542,7 +543,7 @@ fn test_ipv6_recverr() {
         }
         std::thread::sleep(Duration::from_millis(10));
     }
-    
+
     if received_icmp_error {
         println!("IPV6_RECVERR is working!");
     } else {