chore: checkpoint before Python removal

vendor/quinn-udp/src/cmsg/mod.rs

@@ -0,0 +1,157 @@
+use std::{
+    ffi::{c_int, c_uchar},
+    mem, ptr,
+};
+
+#[cfg(unix)]
+#[path = "unix.rs"]
+mod imp;
+
+#[cfg(windows)]
+#[path = "windows.rs"]
+mod imp;
+
+pub(crate) use imp::Aligned;
+
+/// Helper to encode a series of control messages (native "cmsgs") to a buffer for use in `sendmsg`
+//  like API.
+///
+/// The operation must be "finished" for the native msghdr to be usable, either by calling `finish`
+/// explicitly or by dropping the `Encoder`.
+pub(crate) struct Encoder<'a, M: MsgHdr> {
+    hdr: &'a mut M,
+    cmsg: Option<&'a mut M::ControlMessage>,
+    len: usize,
+}
+
+impl<'a, M: MsgHdr> Encoder<'a, M> {
+    /// # Safety
+    /// - `hdr` must contain a suitably aligned pointer to a big enough buffer to hold control messages
+    ///   bytes. All bytes of this buffer can be safely written.
+    /// - The `Encoder` must be dropped before `hdr` is passed to a system call, and must not be leaked.
+    pub(crate) unsafe fn new(hdr: &'a mut M) -> Self {
+        Self {
+            cmsg: hdr.cmsg_first_hdr().as_mut(),
+            hdr,
+            len: 0,
+        }
+    }
+
+    /// Append a control message to the buffer.
+    ///
+    /// # Panics
+    /// - If insufficient buffer space remains.
+    /// - If `T` has stricter alignment requirements than `M::ControlMessage`
+    pub(crate) fn push<T: Copy>(&mut self, level: c_int, ty: c_int, value: T) {
+        assert!(mem::align_of::<T>() <= mem::align_of::<M::ControlMessage>());
+        let space = M::ControlMessage::cmsg_space(mem::size_of_val(&value));
+        assert!(
+            self.hdr.control_len() >= self.len + space,
+            "control message buffer too small. Required: {}, Available: {}",
+            self.len + space,
+            self.hdr.control_len()
+        );
+        let cmsg = self.cmsg.take().expect("no control buffer space remaining");
+        cmsg.set(
+            level,
+            ty,
+            M::ControlMessage::cmsg_len(mem::size_of_val(&value)),
+        );
+        unsafe {
+            ptr::write(cmsg.cmsg_data() as *const T as *mut T, value);
+        }
+        self.len += space;
+        self.cmsg = unsafe { self.hdr.cmsg_nxt_hdr(cmsg).as_mut() };
+    }
+
+    /// Finishes appending control messages to the buffer
+    pub(crate) fn finish(self) {
+        // Delegates to the `Drop` impl
+    }
+}
+
+// Statically guarantees that the encoding operation is "finished" before the control buffer is read
+// by `sendmsg` like API.
+impl<M: MsgHdr> Drop for Encoder<'_, M> {
+    fn drop(&mut self) {
+        self.hdr.set_control_len(self.len as _);
+    }
+}
+
+/// # Safety
+///
+/// `cmsg` must refer to a native cmsg containing a payload of type `T`
+pub(crate) unsafe fn decode<T: Copy, C: CMsgHdr>(cmsg: &impl CMsgHdr) -> T {
+    assert!(mem::align_of::<T>() <= mem::align_of::<C>());
+    debug_assert_eq!(cmsg.len(), C::cmsg_len(mem::size_of::<T>()));
+    ptr::read(cmsg.cmsg_data() as *const T)
+}
+
+pub(crate) struct Iter<'a, M: MsgHdr> {
+    hdr: &'a M,
+    cmsg: Option<&'a M::ControlMessage>,
+}
+
+impl<'a, M: MsgHdr> Iter<'a, M> {
+    /// # Safety
+    ///
+    /// `hdr` must hold a pointer to memory outliving `'a` which can be soundly read for the
+    /// lifetime of the constructed `Iter` and contains a buffer of native cmsgs, i.e. is aligned
+    //  for native `cmsghdr`, is fully initialized, and has correct internal links.
+    pub(crate) unsafe fn new(hdr: &'a M) -> Self {
+        Self {
+            hdr,
+            cmsg: hdr.cmsg_first_hdr().as_ref(),
+        }
+    }
+}
+
+impl<'a, M: MsgHdr> Iterator for Iter<'a, M> {
+    type Item = &'a M::ControlMessage;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let current = self.cmsg.take()?;
+        self.cmsg = unsafe { self.hdr.cmsg_nxt_hdr(current).as_ref() };
+
+        #[cfg(apple_fast)]
+        {
+            // On MacOS < 14 CMSG_NXTHDR might continuously return a zeroed cmsg. In
+            // such case, return `None` instead, thus indicating the end of
+            // the cmsghdr chain.
+            if current.len() < mem::size_of::<M::ControlMessage>() {
+                return None;
+            }
+        }
+
+        Some(current)
+    }
+}
+
+// Helper traits for native types for control messages
+pub(crate) trait MsgHdr {
+    type ControlMessage: CMsgHdr;
+
+    fn cmsg_first_hdr(&self) -> *mut Self::ControlMessage;
+
+    fn cmsg_nxt_hdr(&self, cmsg: &Self::ControlMessage) -> *mut Self::ControlMessage;
+
+    /// Sets the number of control messages added to this `struct msghdr`.
+    ///
+    /// Note that this is a destructive operation and should only be done as a finalisation
+    /// step.
+    fn set_control_len(&mut self, len: usize);
+
+    fn control_len(&self) -> usize;
+}
+
+pub(crate) trait CMsgHdr {
+    fn cmsg_len(length: usize) -> usize;
+
+    fn cmsg_space(length: usize) -> usize;
+
+    fn cmsg_data(&self) -> *mut c_uchar;
+
+    fn set(&mut self, level: c_int, ty: c_int, len: usize);
+
+    fn len(&self) -> usize;
+}

vendor/quinn-udp/src/cmsg/unix.rs

@@ -0,0 +1,81 @@
+use std::ffi::{c_int, c_uchar};
+
+use super::{CMsgHdr, MsgHdr};
+
+#[derive(Copy, Clone)]
+#[repr(align(8))] // Conservative bound for align_of<libc::cmsghdr>
+pub(crate) struct Aligned<T>(pub(crate) T);
+
+/// Helpers for [`libc::msghdr`]
+impl MsgHdr for libc::msghdr {
+    type ControlMessage = libc::cmsghdr;
+
+    fn cmsg_first_hdr(&self) -> *mut Self::ControlMessage {
+        unsafe { libc::CMSG_FIRSTHDR(self) }
+    }
+
+    fn cmsg_nxt_hdr(&self, cmsg: &Self::ControlMessage) -> *mut Self::ControlMessage {
+        unsafe { libc::CMSG_NXTHDR(self, cmsg) }
+    }
+
+    fn set_control_len(&mut self, len: usize) {
+        self.msg_controllen = len as _;
+        if len == 0 {
+            // netbsd is particular about this being a NULL pointer if there are no control
+            // messages.
+            self.msg_control = std::ptr::null_mut();
+        }
+    }
+
+    fn control_len(&self) -> usize {
+        self.msg_controllen as _
+    }
+}
+
+#[cfg(apple_fast)]
+impl MsgHdr for crate::imp::msghdr_x {
+    type ControlMessage = libc::cmsghdr;
+
+    fn cmsg_first_hdr(&self) -> *mut Self::ControlMessage {
+        let selfp = self as *const _ as *mut libc::msghdr;
+        unsafe { libc::CMSG_FIRSTHDR(selfp) }
+    }
+
+    fn cmsg_nxt_hdr(&self, cmsg: &Self::ControlMessage) -> *mut Self::ControlMessage {
+        let selfp = self as *const _ as *mut libc::msghdr;
+        unsafe { libc::CMSG_NXTHDR(selfp, cmsg) }
+    }
+
+    fn set_control_len(&mut self, len: usize) {
+        self.msg_controllen = len as _;
+    }
+
+    fn control_len(&self) -> usize {
+        self.msg_controllen as _
+    }
+}
+
+/// Helpers for [`libc::cmsghdr`]
+impl CMsgHdr for libc::cmsghdr {
+    fn cmsg_len(length: usize) -> usize {
+        unsafe { libc::CMSG_LEN(length as _) as usize }
+    }
+
+    fn cmsg_space(length: usize) -> usize {
+        unsafe { libc::CMSG_SPACE(length as _) as usize }
+    }
+
+    fn cmsg_data(&self) -> *mut c_uchar {
+        unsafe { libc::CMSG_DATA(self) }
+    }
+
+    fn set(&mut self, level: c_int, ty: c_int, len: usize) {
+        self.cmsg_level = level as _;
+        self.cmsg_type = ty as _;
+        self.cmsg_len = len as _;
+    }
+
+    fn len(&self) -> usize {
+        self.cmsg_len as _
+    }
+}

vendor/quinn-udp/src/cmsg/windows.rs

@@ -0,0 +1,83 @@
+use std::{
+    ffi::{c_int, c_uchar},
+    mem, ptr,
+};
+
+use windows_sys::Win32::Networking::WinSock;
+
+use super::{CMsgHdr, MsgHdr};
+
+#[derive(Copy, Clone)]
+#[repr(align(8))] // Conservative bound for align_of<WinSock::CMSGHDR>
+pub(crate) struct Aligned<T>(pub(crate) T);
+
+/// Helpers for [`WinSock::WSAMSG`]
+// https://learn.microsoft.com/en-us/windows/win32/api/ws2def/ns-ws2def-wsamsg
+// https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Networking/WinSock/struct.WSAMSG.html
+impl MsgHdr for WinSock::WSAMSG {
+    type ControlMessage = WinSock::CMSGHDR;
+
+    fn cmsg_first_hdr(&self) -> *mut Self::ControlMessage {
+        if self.Control.len as usize >= mem::size_of::<WinSock::CMSGHDR>() {
+            self.Control.buf as *mut WinSock::CMSGHDR
+        } else {
+            ptr::null_mut::<WinSock::CMSGHDR>()
+        }
+    }
+
+    fn cmsg_nxt_hdr(&self, cmsg: &Self::ControlMessage) -> *mut Self::ControlMessage {
+        let next =
+            (cmsg as *const _ as usize + cmsghdr_align(cmsg.cmsg_len)) as *mut WinSock::CMSGHDR;
+        let max = self.Control.buf as usize + self.Control.len as usize;
+        if unsafe { next.offset(1) } as usize > max {
+            ptr::null_mut()
+        } else {
+            next
+        }
+    }
+
+    fn set_control_len(&mut self, len: usize) {
+        self.Control.len = len as _;
+    }
+
+    fn control_len(&self) -> usize {
+        self.Control.len as _
+    }
+}
+
+/// Helpers for [`WinSock::CMSGHDR`]
+// https://learn.microsoft.com/en-us/windows/win32/api/ws2def/ns-ws2def-wsacmsghdr
+// https://microsoft.github.io/windows-docs-rs/doc/windows/Win32/Networking/WinSock/struct.CMSGHDR.html
+impl CMsgHdr for WinSock::CMSGHDR {
+    fn cmsg_len(length: usize) -> usize {
+        cmsgdata_align(mem::size_of::<Self>()) + length
+    }
+
+    fn cmsg_space(length: usize) -> usize {
+        cmsgdata_align(mem::size_of::<Self>() + cmsghdr_align(length))
+    }
+
+    fn cmsg_data(&self) -> *mut c_uchar {
+        (self as *const _ as usize + cmsgdata_align(mem::size_of::<Self>())) as *mut c_uchar
+    }
+
+    fn set(&mut self, level: c_int, ty: c_int, len: usize) {
+        self.cmsg_level = level as _;
+        self.cmsg_type = ty as _;
+        self.cmsg_len = len as _;
+    }
+
+    fn len(&self) -> usize {
+        self.cmsg_len as _
+    }
+}
+
+// Helpers functions for `WinSock::WSAMSG` and `WinSock::CMSGHDR` are based on C macros from
+// https://github.com/microsoft/win32metadata/blob/main/generation/WinSDK/RecompiledIdlHeaders/shared/ws2def.h#L741
+fn cmsghdr_align(length: usize) -> usize {
+    (length + mem::align_of::<WinSock::CMSGHDR>() - 1) & !(mem::align_of::<WinSock::CMSGHDR>() - 1)
+}
+
+fn cmsgdata_align(length: usize) -> usize {
+    (length + mem::align_of::<usize>() - 1) & !(mem::align_of::<usize>() - 1)
+}