Re-enable.

src/backend/libc/net/read_sockaddr.rs

@@ -120,7 +120,6 @@ pub(crate) unsafe fn read_sockaddr(
     storage: *const c::sockaddr_storage,
     len: usize,
 ) -> io::Result<SocketAddrAny> {
-    dbg!(len);
     #[cfg(unix)]
     let offsetof_sun_path = super::addr::offsetof_sun_path();
 
@@ -239,14 +238,12 @@ pub(crate) unsafe fn maybe_read_sockaddr_os(
     storage: *const c::sockaddr_storage,
     len: usize,
 ) -> Option<SocketAddrAny> {
-    dbg!(len);
     if len == 0 {
         return None;
     }
 
     assert!(len >= size_of::<c::sa_family_t>());
     let family = read_ss_family(storage).into();
-    dbg!(&family);
     if family == c::AF_UNSPEC {
         return None;
     }
@@ -270,10 +267,8 @@ pub(crate) unsafe fn read_sockaddr_os(
     storage: *const c::sockaddr_storage,
     len: usize,
 ) -> SocketAddrAny {
-    dbg!(len);
     assert!(len >= size_of::<c::sa_family_t>());
     let family = read_ss_family(storage).into();
-    dbg!(&family);
     inner_read_sockaddr_os(family, storage, len)
 }
 
@@ -282,7 +277,6 @@ unsafe fn inner_read_sockaddr_os(
     storage: *const c::sockaddr_storage,
     len: usize,
 ) -> SocketAddrAny {
-    dbg!(len);
     #[cfg(unix)]
     let offsetof_sun_path = super::addr::offsetof_sun_path();
 
@@ -308,8 +302,6 @@ unsafe fn inner_read_sockaddr_os(
         }
         #[cfg(unix)]
         c::AF_UNIX => {
-            dbg!("line");
-            dbg!(len, offsetof_sun_path);
             assert!(len >= offsetof_sun_path);
             if len == offsetof_sun_path {
                 SocketAddrAny::Unix(SocketAddrUnix::new(&[][..]).unwrap())
@@ -336,14 +328,12 @@ unsafe fn inner_read_sockaddr_os(
                 assert_eq!(decode.sun_path[len - 1 - offsetof_sun_path], 0);
                 let path_bytes = &decode.sun_path[..len - 1 - offsetof_sun_path];
 
-                dbg!(&path_bytes);
                 // FreeBSD and illumos sometimes set the length to longer than
                 // the length of the NUL-terminated string. Find the NUL and
                 // truncate the string accordingly.
                 #[cfg(any(solarish, target_os = "freebsd"))]
                 let path_bytes = &path_bytes[..path_bytes.iter().position(|b| *b == 0).unwrap()];
 
-                dbg!(&path_bytes);
                 SocketAddrAny::Unix(
                     SocketAddrUnix::new(core::mem::transmute::<&[c::c_char], &[u8]>(path_bytes))
                         .unwrap(),

tests/net/main.rs

@@ -5,26 +5,22 @@
 #![cfg(not(any(target_os = "redox", target_os = "wasi")))]
 #![cfg_attr(core_c_str, feature(core_c_str))]
 
-/*
 mod addr;
 #[cfg(unix)]
 mod cmsg;
 mod connect_bind_send;
 mod dgram;
 #[cfg(feature = "event")]
 mod poll;
-*/
 #[cfg(unix)]
 mod recv_trunc;
-/*
 mod sockopt;
 #[cfg(unix)]
 mod unix;
 #[cfg(unix)]
 mod unix_alloc;
 mod v4;
 mod v6;
-*/
 
 #[cfg(windows)]
 mod windows {

tests/net/recv_trunc.rs

@@ -4,7 +4,6 @@ use std::mem::MaybeUninit;
 
 /// Test `recv_uninit` with the `RecvFlags::Trunc` flag.
 #[test]
-#[ignore]
 fn net_recv_uninit_trunc() {
     crate::init();
 
@@ -55,9 +54,7 @@ fn net_recvmsg_trunc() {
 
     let tmpdir = tempfile::tempdir().unwrap();
     let path = tmpdir.path().join("recvmsg_trunc");
-    dbg!(&path);
     let name = SocketAddrUnix::new(&path).unwrap();
-    dbg!(&name);
 
     let receiver = rustix::net::socket(AddressFamily::UNIX, SocketType::DGRAM, None).unwrap();
     rustix::net::bind_unix(&receiver, &name).expect("bind");
@@ -73,7 +70,6 @@ fn net_recvmsg_trunc() {
         assert_eq!(n, request.len());
 
         let mut response = [0_u8; 5];
-        dbg!("line");
         let result = rustix::net::recvmsg(
             &receiver,
             &mut [IoSliceMut::new(&mut response)],
@@ -82,8 +78,6 @@ fn net_recvmsg_trunc() {
         )
         .expect("recvmsg");
 
-        dbg!(&result.address);
-
         // We used the `TRUNC` flag, so we should have received 15 bytes,
         // truncated to 5 bytes, and the `TRUNC` flag should have been returned.
         assert_eq!(&response, b"Hello");
@@ -97,7 +91,6 @@ fn net_recvmsg_trunc() {
 
         // This time receive it with `TRUNC` and a big enough buffer.
         let mut response = [0_u8; 30];
-        dbg!("line");
         let result = rustix::net::recvmsg(
             &receiver,
             &mut [IoSliceMut::new(&mut response)],
@@ -106,7 +99,6 @@ fn net_recvmsg_trunc() {
         )
         .expect("recvmsg");
 
-        dbg!(&result.address);
         // We used the `TRUNC` flag, so we should have received 15 bytes
         // and the buffer was big enough so the `TRUNC` flag should not have
         // been returned.
@@ -120,7 +112,6 @@ fn net_recvmsg_trunc() {
 
     // This time receive it without `TRUNC` but a big enough buffer.
     let mut response = [0_u8; 30];
-    dbg!("line");
     let result = rustix::net::recvmsg(
         &receiver,
         &mut [IoSliceMut::new(&mut response)],
@@ -129,7 +120,6 @@ fn net_recvmsg_trunc() {
     )
     .expect("recvmsg");
 
-    dbg!(&result.address);
     // We didn't use the `TRUNC` flag, but the buffer was big enough,
     // so we should have received 15 bytes, and the `TRUNC` flag should
     // have been returned.
@@ -142,7 +132,6 @@ fn net_recvmsg_trunc() {
 
     // This time receive it without `TRUNC` and a small buffer.
     let mut response = [0_u8; 5];
-    dbg!("line");
     let result = rustix::net::recvmsg(
         &receiver,
         &mut [IoSliceMut::new(&mut response)],
@@ -151,7 +140,6 @@ fn net_recvmsg_trunc() {
     )
     .expect("recvmsg");
 
-    dbg!(&result.address);
     // We didn't use the `TRUNC` flag, so we should have received 15 bytes,
     // truncated to 5 bytes, and the `TRUNC` flag should have been returned.
     assert_eq!(&response[..result.bytes], b"Hello");