Support processing ancillary outside rustix infrastructure (#1008)

Signed-off-by: Alex Saveau <saveau.alexandre@gmail.com>

Author: SUPERCILEX

src/net/send_recv/msg.rs

@@ -440,8 +440,7 @@ impl<'buf> RecvAncillaryBuffer<'buf> {
     pub fn drain(&mut self) -> AncillaryDrain<'_> {
         AncillaryDrain {
             messages: messages::Messages::new(&mut self.buffer[self.read..][..self.length]),
-            read: &mut self.read,
-            length: &mut self.length,
+            read_and_length: Some((&mut self.read, &mut self.length)),
         }
     }
 }
@@ -474,25 +473,40 @@ pub struct AncillaryDrain<'buf> {
     messages: messages::Messages<'buf>,
 
     /// Increment the number of messages we've read.
-    read: &'buf mut usize,
-
     /// Decrement the total length.
-    length: &'buf mut usize,
+    read_and_length: Option<(&'buf mut usize, &'buf mut usize)>,
 }
 
 impl<'buf> AncillaryDrain<'buf> {
-    /// A closure that converts a message into a [`RecvAncillaryMessage`].
-    fn cvt_msg(
-        read: &mut usize,
-        length: &mut usize,
+    /// Create an iterator for control messages that were received without [`RecvAncillaryBuffer`].
+    ///
+    /// # Safety
+    ///
+    /// The buffer must contain valid message data (or be empty).
+    pub unsafe fn parse(buffer: &'buf mut [u8]) -> Self {
+        Self {
+            messages: messages::Messages::new(buffer),
+            read_and_length: None,
+        }
+    }
+
+    fn advance(
+        read_and_length: &mut Option<(&'buf mut usize, &'buf mut usize)>,
         msg: &c::cmsghdr,
     ) -> Option<RecvAncillaryMessage<'buf>> {
-        unsafe {
-            // Advance the `read` pointer.
+        // Advance the `read` pointer.
+        if let Some((read, length)) = read_and_length {
             let msg_len = msg.cmsg_len as usize;
-            *read += msg_len;
-            *length -= msg_len;
+            **read += msg_len;
+            **length -= msg_len;
+        }
+
+        Self::cvt_msg(msg)
+    }
 
+    /// A closure that converts a message into a [`RecvAncillaryMessage`].
+    fn cvt_msg(msg: &c::cmsghdr) -> Option<RecvAncillaryMessage<'buf>> {
+        unsafe {
             // Get a pointer to the payload.
             let payload = c::CMSG_DATA(msg);
             let payload_len = msg.cmsg_len as usize - c::CMSG_LEN(0) as usize;
@@ -528,55 +542,46 @@ impl<'buf> Iterator for AncillaryDrain<'buf> {
     type Item = RecvAncillaryMessage<'buf>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        let read = &mut self.read;
-        let length = &mut self.length;
-        self.messages.find_map(|ev| Self::cvt_msg(read, length, ev))
+        self.messages
+            .find_map(|ev| Self::advance(&mut self.read_and_length, ev))
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
         let (_, max) = self.messages.size_hint();
         (0, max)
     }
 
-    fn fold<B, F>(self, init: B, f: F) -> B
+    fn fold<B, F>(mut self, init: B, f: F) -> B
     where
         Self: Sized,
         F: FnMut(B, Self::Item) -> B,
     {
-        let read = self.read;
-        let length = self.length;
         self.messages
-            .filter_map(|ev| Self::cvt_msg(read, length, ev))
+            .filter_map(|ev| Self::advance(&mut self.read_and_length, ev))
             .fold(init, f)
     }
 
-    fn count(self) -> usize {
-        let read = self.read;
-        let length = self.length;
+    fn count(mut self) -> usize {
         self.messages
-            .filter_map(|ev| Self::cvt_msg(read, length, ev))
+            .filter_map(|ev| Self::advance(&mut self.read_and_length, ev))
             .count()
     }
 
-    fn last(self) -> Option<Self::Item>
+    fn last(mut self) -> Option<Self::Item>
     where
         Self: Sized,
     {
-        let read = self.read;
-        let length = self.length;
         self.messages
-            .filter_map(|ev| Self::cvt_msg(read, length, ev))
+            .filter_map(|ev| Self::advance(&mut self.read_and_length, ev))
             .last()
     }
 
-    fn collect<B: FromIterator<Self::Item>>(self) -> B
+    fn collect<B: FromIterator<Self::Item>>(mut self) -> B
     where
         Self: Sized,
     {
-        let read = self.read;
-        let length = self.length;
         self.messages
-            .filter_map(|ev| Self::cvt_msg(read, length, ev))
+            .filter_map(|ev| Self::advance(&mut self.read_and_length, ev))
             .collect()
     }
 }