For recvmmsg split lifetime 'a

into separate lifetimes for 'data, headers ('hdr) and related iterator

Author: pacak

src/sys/socket/mod.rs

@@ -17,6 +17,7 @@ use libc::{
 };
 #[cfg(not(target_os = "redox"))]
 use std::io::{IoSlice, IoSliceMut};
+use std::marker::PhantomData;
 #[cfg(feature = "net")]
 use std::net;
 use std::os::unix::io::{AsFd, AsRawFd, FromRawFd, OwnedFd, RawFd};
@@ -1765,7 +1766,7 @@ pub fn sendmmsg<'a, XS, AS, C, I, S>(
     // shared across all the messages
     cmsgs: C,
     flags: MsgFlags
-) -> crate::Result<MultiResults<'a, S>>
+) -> crate::Result<MultiResults<'a, 'a, S>>
     where
         XS: IntoIterator<Item = &'a I>,
         AS: AsRef<[Option<S>]>,
@@ -1820,6 +1821,7 @@ pub fn sendmmsg<'a, XS, AS, C, I, S>(
     Ok(MultiResults {
         rmm: data,
         current_index: 0,
+        slices: PhantomData,
         received: sent
     })
 
@@ -1908,16 +1910,16 @@ impl<S> MultiHeaders<S> {
 // always produce the desired results - see https://github.com/nix-rust/nix/pull/1744 for more
 // details
 #[cfg(any(linux_android, target_os = "freebsd", target_os = "netbsd"))]
-pub fn recvmmsg<'a, XS, S, I>(
+pub fn recvmmsg<'hdr, 'iter, 'data, XS, S, I>(
     fd: RawFd,
-    data: &'a mut MultiHeaders<S>,
+    data: &'hdr mut MultiHeaders<S>,
     slices: XS,
     flags: MsgFlags,
     mut timeout: Option<crate::sys::time::TimeSpec>,
-) -> crate::Result<MultiResults<'a, S>>
+) -> crate::Result<MultiResults<'hdr, 'data, S>>
 where
-    XS: IntoIterator<Item = &'a mut I>,
-    I: AsMut<[IoSliceMut<'a>]> + 'a,
+    XS: IntoIterator<Item = &'iter mut I>,
+    I: AsMut<[IoSliceMut<'data>]> + 'iter,
 {
     let mut count = 0;
     for (i, (slice, mmsghdr)) in slices.into_iter().zip(data.items.iter_mut()).enumerate() {
@@ -1949,6 +1951,7 @@ where
     })? as usize;
 
     Ok(MultiResults {
+        slices: PhantomData,
         rmm: data,
         current_index: 0,
         received,
@@ -1958,19 +1961,20 @@ where
 /// Iterator over results of [`recvmmsg`]/[`sendmmsg`]
 #[cfg(any(linux_android, target_os = "freebsd", target_os = "netbsd"))]
 #[derive(Debug)]
-pub struct MultiResults<'a, S> {
+pub struct MultiResults<'hdrs, 'data, S> {
     // preallocated structures
-    rmm: &'a MultiHeaders<S>,
+    rmm: &'hdrs MultiHeaders<S>,
+    slices: PhantomData<&'data ()>,
     current_index: usize,
     received: usize,
 }
 
 #[cfg(any(linux_android, target_os = "freebsd", target_os = "netbsd"))]
-impl<'a, S> Iterator for MultiResults<'a, S>
+impl<'hdrs, 'data, S> Iterator for MultiResults<'hdrs, 'data, S>
 where
     S: Copy + SockaddrLike,
 {
-    type Item = RecvMsg<'a, 'a, S>;
+    type Item = RecvMsg<'hdrs, 'data, S>;
 
     // The cast is not unnecessary on all platforms.
     #[allow(clippy::unnecessary_cast)]

test/sys/test_socket.rs

@@ -671,24 +671,29 @@ mod recvfrom {
         let mut data =
             MultiHeaders::<SockaddrIn>::preallocate(msgs.len(), None);
 
-        let res: Vec<RecvMsg<SockaddrIn>> = recvmmsg(
-            rsock.as_raw_fd(),
-            &mut data,
-            msgs.iter_mut(),
-            MsgFlags::empty(),
-            None,
-        )
-        .expect("recvmmsg")
-        .collect();
-        assert_eq!(res.len(), DATA.len());
+        for _ in 0..3 {
+            let res: Vec<RecvMsg<SockaddrIn>> = recvmmsg(
+                rsock.as_raw_fd(),
+                &mut data,
+                msgs.iter_mut(),
+                MsgFlags::empty(),
+                None,
+            )
+            .expect("recvmmsg")
+            .collect();
+            assert_eq!(res.len(), DATA.len());
 
-        for RecvMsg { address, bytes, .. } in res.into_iter() {
-            assert_eq!(AddressFamily::Inet, address.unwrap().family().unwrap());
-            assert_eq!(DATA.len(), bytes);
-        }
+            for RecvMsg { address, bytes, .. } in res.into_iter() {
+                assert_eq!(
+                    AddressFamily::Inet,
+                    address.unwrap().family().unwrap()
+                );
+                assert_eq!(DATA.len(), bytes);
+            }
 
-        for buf in &receive_buffers {
-            assert_eq!(&buf[..DATA.len()], DATA);
+            for buf in msgs.iter().flatten() {
+                assert_eq!(&buf[..DATA.len()], DATA);
+            }
         }
 
         send_thread.join().unwrap();