Add test

Author: Hasan6979

src/lib.rs

@@ -176,7 +176,6 @@ macro_rules! define_mmsg_if_supported {
     ($($item:item)*) => {
         $(
             #[cfg(all(
-                feature = "all",
                 any(
                     target_os = "linux",
                     target_os = "android",
@@ -714,105 +713,87 @@ impl<'name, 'bufs, 'control> fmt::Debug for MsgHdrMut<'name, 'bufs, 'control> {
 }
 
 define_mmsg_if_supported! {
-    /// Wraps `mmsghdr` on Unix for a `sendmmsg(2)` system call.
-    ///
-    /// Also see [`MsgHdr`] for the variant used by `sendmsg(2)`.
-    #[repr(transparent)]
-    pub struct MMsgHdr<'addr, 'bufs, 'control> {
-        inner: sys::mmsghdr,
-        #[allow(clippy::type_complexity)]
-        _lifetimes: PhantomData<(&'addr SockAddr, &'bufs IoSlice<'bufs>, &'control [u8])>,
-    }
-
-    impl<'addr, 'bufs, 'control> MMsgHdr<'addr, 'bufs, 'control> {
-        /// Create a new `MMsgHdr` from `MsgHdr` and with the `msg_len` set to zero.
-        pub fn new(msg: MsgHdr<'_, '_, '_>) -> Self {
-            Self {
-                inner: sys::mmsghdr {
-                    msg_hdr: msg.inner,
-                    msg_len: 0,
-                },
-                _lifetimes: PhantomData,
-            }
-        }
+/// Wraps `mmsghdr` on Unix for a `sendmmsg(2)` system call.
+///
+/// Also see [`MsgHdr`] for the variant used by `sendmsg(2)`.
+#[repr(transparent)]
+pub struct MMsgHdr<'addr, 'bufs, 'control> {
+    inner: sys::mmsghdr,
+    #[allow(clippy::type_complexity)]
+    _lifetimes: PhantomData<(&'addr SockAddr, &'bufs IoSlice<'bufs>, &'control [u8])>,
+}
 
-        /// Number of bytes transmitted.
-        pub fn transmitted_bytes(&self) -> u32 {
-            self.inner.msg_len
+impl<'addr, 'bufs, 'control> MMsgHdr<'addr, 'bufs, 'control> {
+    /// Create a new `MMsgHdr` from `MsgHdr` and with the `msg_len` set to zero.
+    pub fn new(msg: MsgHdr<'_, '_, '_>) -> Self {
+        Self {
+            inner: sys::mmsghdr {
+                msg_hdr: msg.inner,
+                msg_len: 0,
+            },
+            _lifetimes: PhantomData,
         }
     }
 
-    impl<'addr, 'bufs, 'control> From<MsgHdr<'addr, 'bufs, 'control>>
-        for MMsgHdr<'addr, 'bufs, 'control>
-    {
-        fn from(value: MsgHdr<'_, '_, '_>) -> Self {
-            Self::new(value)
-        }
+    /// Number of bytes transmitted.
+    pub fn transmitted_bytes(&self) -> u32 {
+        self.inner.msg_len
     }
+}
 
-    impl<'addr, 'bufs, 'control> fmt::Debug for MMsgHdr<'addr, 'bufs, 'control> {
-        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-            f.write_str("MMsgHdr({})", self.len())
-        }
+impl<'addr, 'bufs, 'control> fmt::Debug for MMsgHdr<'addr, 'bufs, 'control> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(&format!("MMsgHdr({})", self.transmitted_bytes()))
     }
+}
 
-    /// Wraps `mmsghdr` on Unix for a `recvmmsg(2)` system call.
-    ///
-    /// Also see [`MsgHdrMut`] for the variant used by `recvmsg(2)`.
-    #[repr(transparent)]
-    pub struct MMsgHdrMut<'addr, 'bufs, 'control> {
-        inner: sys::mmsghdr,
-        #[allow(clippy::type_complexity)]
-        _lifetimes: PhantomData<(
-            &'addr mut SockAddr,
-            &'bufs mut MaybeUninitSlice<'bufs>,
-            &'control mut [u8],
-        )>,
-    }
-
-    impl<'addr, 'bufs, 'control> MMsgHdrMut<'addr, 'bufs, 'control> {
-        /// Create a new `MMsgHdrMut` from `MsgHdrMut` and with the `msg_len` set to zero.
-        pub fn new(msg: MsgHdrMut<'_, '_, '_>) -> Self {
-            Self {
-                inner: sys::mmsghdr {
-                    msg_hdr: msg.inner,
-                    msg_len: 0,
-                },
-                _lifetimes: PhantomData,
-            }
-        }
+/// Wraps `mmsghdr` on Unix for a `recvmmsg(2)` system call.
+///
+/// Also see [`MsgHdrMut`] for the variant used by `recvmsg(2)`.
+#[repr(transparent)]
+pub struct MMsgHdrMut<'addr, 'bufs, 'control> {
+    inner: sys::mmsghdr,
+    #[allow(clippy::type_complexity)]
+    _lifetimes: PhantomData<(
+        &'addr mut SockAddr,
+        &'bufs mut MaybeUninitSlice<'bufs>,
+        &'control mut [u8],
+    )>,
+}
 
-        /// Number of received bytes.
-        pub fn transmitted_bytes(&self) -> u32 {
-            self.inner.msg_len
+impl<'addr, 'bufs, 'control> MMsgHdrMut<'addr, 'bufs, 'control> {
+    /// Create a new `MMsgHdrMut` from `MsgHdrMut` and with the `msg_len` set to zero.
+    pub fn new(msg: MsgHdrMut<'_, '_, '_>) -> Self {
+        Self {
+            inner: sys::mmsghdr {
+                msg_hdr: msg.inner,
+                msg_len: 0,
+            },
+            _lifetimes: PhantomData,
         }
+    }
 
-        /// Returns the flags of the message.
-        pub fn flags(&self) -> RecvFlags {
-            sys::msghdr_flags(&self.inner.msg_hdr)
-        }
+    /// Number of received bytes.
+    pub fn recieved_bytes(&self) -> u32 {
+        self.inner.msg_len
+    }
 
-        /// Gets the length of the control buffer.
-        ///
-        /// Can be used to determine how much, if any, of the control buffer was filled by `recvmsg`.
-        ///
-        /// Corresponds to `msg_controllen` on Unix and `Control.len` on Windows.
-        pub fn control_len(&self) -> usize {
-            sys::msghdr_control_len(&self.inner.msg_hdr)
-        }
+    /// Returns the flags of the message.
+    pub fn flags(&self) -> RecvFlags {
+        sys::msghdr_flags(&self.inner.msg_hdr)
     }
 
-    impl<'addr, 'bufs, 'control> From<MsgHdrMut<'addr, 'bufs, 'control>>
-        for MMsgHdrMut<'addr, 'bufs, 'control>
-    {
-        fn from(value: MsgHdrMut<'_, '_, '_>) -> Self {
-            Self::new(value)
-        }
+    /// Gets the length of the control buffer.
+    ///
+    /// Can be used to determine how much, if any, of the control buffer was filled by `recvmsg`.
+    pub fn control_len(&self) -> usize {
+        sys::msghdr_control_len(&self.inner.msg_hdr)
     }
+}
 
-    impl<'addr, 'bufs, 'control> fmt::Debug for MMsgHdrMut<'addr, 'bufs, 'control> {
-        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-            f.write_str("MMsgHdrMut({})", self.len())
-        }
+impl<'addr, 'bufs, 'control> fmt::Debug for MMsgHdrMut<'addr, 'bufs, 'control> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(&format!("MMsgHdrMut({})", self.recieved_bytes()))
     }
 }
+}

tests/socket.rs

@@ -771,28 +771,43 @@ fn sendmsg() {
 
 #[test]
 #[cfg(any(target_os = "linux", target_os = "android"))]
-fn sendmmsg() {
+fn send_and_recv_batched_msgs() {
     let (socket_a, socket_b) = udp_pair_unconnected();
 
     const DATA: &[u8] = b"Hello, World!";
 
-    let bufs = &[IoSlice::new(DATA)];
     let addr_b = socket_b.local_addr().unwrap();
-    let batched_msgs = Vec::new();
-    for _ in 0..5 {
+    let mut batched_msgs = Vec::new();
+    let mut recv_batched_msgs = Vec::new();
+    for _ in 0..10 {
+        let bufs = &[IoSlice::new(DATA)];
         batched_msgs.push(socket2::MMsgHdr::new(
             socket2::MsgHdr::new().with_addr(&addr_b).with_buffers(bufs),
         ));
+
+        let mut buf = [MaybeUninit::new(0u8); 20];
+        let recv_bufs = MaybeUninitSlice::new(buf.as_mut_slice());
+        recv_batched_msgs.push(socket2::MMsgHdrMut::new(
+            socket2::MsgHdrMut::new().with_buffers(&mut [recv_bufs]),
+        ));
     }
 
     let sent = socket_a.sendmmsg(batched_msgs.as_mut_slice(), 0).unwrap();
 
     let mut sent_data = 0;
     // Calculate transmitted length
-    for i in 0..5 {
-        sent_data += batched_msgs[i].transmitted_bytes()
+    for msg in batched_msgs.iter().take(sent) {
+        sent_data += msg.transmitted_bytes()
     }
-    assert!(sent_data == 5 * DATA.len());
+    assert!(sent_data as usize == 10 * DATA.len());
+
+    let recvd = socket_b
+        .recvmmsg(recv_batched_msgs.as_mut_slice(), 0, None)
+        .unwrap();
+
+    assert!(recvd == sent);
+
+    assert!(recv_batched_msgs[0].recieved_bytes() == DATA.len().try_into().unwrap());
 }
 
 #[test]