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)
+}

vendor/quinn-udp/src/fallback.rs

@@ -0,0 +1,126 @@
+use std::{
+    io::{self, IoSliceMut},
+    sync::Mutex,
+    time::Instant,
+};
+
+use super::{IO_ERROR_LOG_INTERVAL, RecvMeta, Transmit, UdpSockRef, log_sendmsg_error};
+
+/// Fallback UDP socket interface that stubs out all special functionality
+///
+/// Used when a better implementation is not available for a particular target, at the cost of
+/// reduced performance compared to that enabled by some target-specific interfaces.
+#[derive(Debug)]
+pub struct UdpSocketState {
+    last_send_error: Mutex<Instant>,
+}
+
+impl UdpSocketState {
+    pub fn new(socket: UdpSockRef<'_>) -> io::Result<Self> {
+        socket.0.set_nonblocking(true)?;
+        let now = Instant::now();
+        Ok(Self {
+            last_send_error: Mutex::new(now.checked_sub(2 * IO_ERROR_LOG_INTERVAL).unwrap_or(now)),
+        })
+    }
+
+    /// Sends a [`Transmit`] on the given socket.
+    ///
+    /// This function will only ever return errors of kind [`io::ErrorKind::WouldBlock`].
+    /// All other errors will be logged and converted to `Ok`.
+    ///
+    /// UDP transmission errors are considered non-fatal because higher-level protocols must
+    /// employ retransmits and timeouts anyway in order to deal with UDP's unreliable nature.
+    /// Thus, logging is most likely the only thing you can do with these errors.
+    ///
+    /// If you would like to handle these errors yourself, use [`UdpSocketState::try_send`]
+    /// instead.
+    pub fn send(&self, socket: UdpSockRef<'_>, transmit: &Transmit<'_>) -> io::Result<()> {
+        match send(socket, transmit) {
+            Ok(()) => Ok(()),
+            Err(e) if e.kind() == io::ErrorKind::WouldBlock => Err(e),
+            Err(e) => {
+                log_sendmsg_error(&self.last_send_error, e, transmit);
+
+                Ok(())
+            }
+        }
+    }
+
+    /// Sends a [`Transmit`] on the given socket without any additional error handling.
+    pub fn try_send(&self, socket: UdpSockRef<'_>, transmit: &Transmit<'_>) -> io::Result<()> {
+        send(socket, transmit)
+    }
+
+    pub fn recv(
+        &self,
+        socket: UdpSockRef<'_>,
+        bufs: &mut [IoSliceMut<'_>],
+        meta: &mut [RecvMeta],
+    ) -> io::Result<usize> {
+        // Safety: both `IoSliceMut` and `MaybeUninitSlice` promise to have the
+        // same layout, that of `iovec`/`WSABUF`. Furthermore `recv_vectored`
+        // promises to not write unitialised bytes to the `bufs` and pass it
+        // directly to the `recvmsg` system call, so this is safe.
+        let bufs = unsafe {
+            &mut *(bufs as *mut [IoSliceMut<'_>] as *mut [socket2::MaybeUninitSlice<'_>])
+        };
+        let (len, _flags, addr) = socket.0.recv_from_vectored(bufs)?;
+        meta[0] = RecvMeta {
+            len,
+            stride: len,
+            addr: addr.as_socket().unwrap(),
+            ecn: None,
+            dst_ip: None,
+        };
+        Ok(1)
+    }
+
+    #[inline]
+    pub fn max_gso_segments(&self) -> usize {
+        1
+    }
+
+    #[inline]
+    pub fn gro_segments(&self) -> usize {
+        1
+    }
+
+    /// Resize the send buffer of `socket` to `bytes`
+    #[inline]
+    pub fn set_send_buffer_size(&self, socket: UdpSockRef<'_>, bytes: usize) -> io::Result<()> {
+        socket.0.set_send_buffer_size(bytes)
+    }
+
+    /// Resize the receive buffer of `socket` to `bytes`
+    #[inline]
+    pub fn set_recv_buffer_size(&self, socket: UdpSockRef<'_>, bytes: usize) -> io::Result<()> {
+        socket.0.set_recv_buffer_size(bytes)
+    }
+
+    /// Get the size of the `socket` send buffer
+    #[inline]
+    pub fn send_buffer_size(&self, socket: UdpSockRef<'_>) -> io::Result<usize> {
+        socket.0.send_buffer_size()
+    }
+
+    /// Get the size of the `socket` receive buffer
+    #[inline]
+    pub fn recv_buffer_size(&self, socket: UdpSockRef<'_>) -> io::Result<usize> {
+        socket.0.recv_buffer_size()
+    }
+
+    #[inline]
+    pub fn may_fragment(&self) -> bool {
+        true
+    }
+}
+
+fn send(socket: UdpSockRef<'_>, transmit: &Transmit<'_>) -> io::Result<()> {
+    socket.0.send_to(
+        transmit.contents,
+        &socket2::SockAddr::from(transmit.destination),
+    )
+}
+
+pub(crate) const BATCH_SIZE: usize = 1;

vendor/quinn-udp/src/lib.rs

@@ -0,0 +1,236 @@
+//! Uniform interface to send and receive UDP packets with advanced features useful for QUIC
+//!
+//! This crate exposes kernel UDP stack features available on most modern systems which are required
+//! for an efficient and conformant QUIC implementation. As of this writing, these are not available
+//! in std or major async runtimes, and their niche character and complexity are a barrier to adding
+//! them. Hence, a dedicated crate.
+//!
+//! Exposed features include:
+//!
+//! - Segmentation offload for bulk send and receive operations, reducing CPU load.
+//! - Reporting the exact destination address of received packets and specifying explicit source
+//!   addresses for sent packets, allowing responses to be sent from the address that the peer
+//!   expects when there are multiple possibilities. This is common when bound to a wildcard address
+//!   in IPv6 due to [RFC 8981] temporary addresses.
+//! - [Explicit Congestion Notification], which is required by QUIC to prevent packet loss and reduce
+//!   latency on congested links when supported by the network path.
+//! - Disabled IP-layer fragmentation, which allows the true physical MTU to be detected and reduces
+//!   risk of QUIC packet loss.
+//!
+//! Some features are unavailable in some environments. This can be due to an outdated operating
+//! system or drivers. Some operating systems may not implement desired features at all, or may not
+//! yet be supported by the crate. When support is unavailable, functionality will gracefully
+//! degrade.
+//!
+//! [RFC 8981]: https://www.rfc-editor.org/rfc/rfc8981.html
+//! [Explicit Congestion Notification]: https://www.rfc-editor.org/rfc/rfc3168.html
+#![warn(unreachable_pub)]
+#![warn(clippy::use_self)]
+
+use std::net::{IpAddr, Ipv6Addr, SocketAddr};
+#[cfg(unix)]
+use std::os::unix::io::AsFd;
+#[cfg(windows)]
+use std::os::windows::io::AsSocket;
+#[cfg(not(wasm_browser))]
+use std::{
+    sync::Mutex,
+    time::{Duration, Instant},
+};
+
+#[cfg(any(unix, windows))]
+mod cmsg;
+
+#[cfg(unix)]
+#[path = "unix.rs"]
+mod imp;
+
+#[cfg(windows)]
+#[path = "windows.rs"]
+mod imp;
+
+// No ECN support
+#[cfg(not(any(wasm_browser, unix, windows)))]
+#[path = "fallback.rs"]
+mod imp;
+
+#[allow(unused_imports, unused_macros)]
+mod log {
+    #[cfg(all(feature = "direct-log", not(feature = "tracing")))]
+    pub(crate) use log::{debug, error, info, trace, warn};
+
+    #[cfg(feature = "tracing")]
+    pub(crate) use tracing::{debug, error, info, trace, warn};
+
+    #[cfg(not(any(feature = "direct-log", feature = "tracing")))]
+    mod no_op {
+        macro_rules! trace    ( ($($tt:tt)*) => {{}} );
+        macro_rules! debug    ( ($($tt:tt)*) => {{}} );
+        macro_rules! info     ( ($($tt:tt)*) => {{}} );
+        macro_rules! log_warn ( ($($tt:tt)*) => {{}} );
+        macro_rules! error    ( ($($tt:tt)*) => {{}} );
+
+        pub(crate) use {debug, error, info, log_warn as warn, trace};
+    }
+
+    #[cfg(not(any(feature = "direct-log", feature = "tracing")))]
+    pub(crate) use no_op::*;
+}
+
+#[cfg(not(wasm_browser))]
+pub use imp::UdpSocketState;
+
+/// Number of UDP packets to send/receive at a time
+#[cfg(not(wasm_browser))]
+pub const BATCH_SIZE: usize = imp::BATCH_SIZE;
+/// Number of UDP packets to send/receive at a time
+#[cfg(wasm_browser)]
+pub const BATCH_SIZE: usize = 1;
+
+/// Metadata for a single buffer filled with bytes received from the network
+///
+/// This associated buffer can contain one or more datagrams, see [`stride`].
+///
+/// [`stride`]: RecvMeta::stride
+#[derive(Debug, Copy, Clone)]
+pub struct RecvMeta {
+    /// The source address of the datagram(s) contained in the buffer
+    pub addr: SocketAddr,
+    /// The number of bytes the associated buffer has
+    pub len: usize,
+    /// The size of a single datagram in the associated buffer
+    ///
+    /// When GRO (Generic Receive Offload) is used this indicates the size of a single
+    /// datagram inside the buffer. If the buffer is larger, that is if [`len`] is greater
+    /// then this value, then the individual datagrams contained have their boundaries at
+    /// `stride` increments from the start. The last datagram could be smaller than
+    /// `stride`.
+    ///
+    /// [`len`]: RecvMeta::len
+    pub stride: usize,
+    /// The Explicit Congestion Notification bits for the datagram(s) in the buffer
+    pub ecn: Option<EcnCodepoint>,
+    /// The destination IP address which was encoded in this datagram
+    ///
+    /// Populated on platforms: Windows, Linux, Android (API level > 25),
+    /// FreeBSD, OpenBSD, NetBSD, macOS, and iOS.
+    pub dst_ip: Option<IpAddr>,
+}
+
+impl Default for RecvMeta {
+    /// Constructs a value with arbitrary fields, intended to be overwritten
+    fn default() -> Self {
+        Self {
+            addr: SocketAddr::new(Ipv6Addr::UNSPECIFIED.into(), 0),
+            len: 0,
+            stride: 0,
+            ecn: None,
+            dst_ip: None,
+        }
+    }
+}
+
+/// An outgoing packet
+#[derive(Debug, Clone)]
+pub struct Transmit<'a> {
+    /// The socket this datagram should be sent to
+    pub destination: SocketAddr,
+    /// Explicit congestion notification bits to set on the packet
+    pub ecn: Option<EcnCodepoint>,
+    /// Contents of the datagram
+    pub contents: &'a [u8],
+    /// The segment size if this transmission contains multiple datagrams.
+    /// This is `None` if the transmit only contains a single datagram
+    pub segment_size: Option<usize>,
+    /// Optional source IP address for the datagram
+    pub src_ip: Option<IpAddr>,
+}
+
+/// Log at most 1 IO error per minute
+#[cfg(not(wasm_browser))]
+const IO_ERROR_LOG_INTERVAL: Duration = std::time::Duration::from_secs(60);
+
+/// Logs a warning message when sendmsg fails
+///
+/// Logging will only be performed if at least [`IO_ERROR_LOG_INTERVAL`]
+/// has elapsed since the last error was logged.
+#[cfg(all(not(wasm_browser), any(feature = "tracing", feature = "direct-log")))]
+fn log_sendmsg_error(
+    last_send_error: &Mutex<Instant>,
+    err: impl core::fmt::Debug,
+    transmit: &Transmit,
+) {
+    let now = Instant::now();
+    let last_send_error = &mut *last_send_error.lock().expect("poisend lock");
+    if now.saturating_duration_since(*last_send_error) > IO_ERROR_LOG_INTERVAL {
+        *last_send_error = now;
+        log::warn!(
+            "sendmsg error: {:?}, Transmit: {{ destination: {:?}, src_ip: {:?}, ecn: {:?}, len: {:?}, segment_size: {:?} }}",
+            err,
+            transmit.destination,
+            transmit.src_ip,
+            transmit.ecn,
+            transmit.contents.len(),
+            transmit.segment_size
+        );
+    }
+}
+
+// No-op
+#[cfg(not(any(wasm_browser, feature = "tracing", feature = "direct-log")))]
+fn log_sendmsg_error(_: &Mutex<Instant>, _: impl core::fmt::Debug, _: &Transmit) {}
+
+/// A borrowed UDP socket
+///
+/// On Unix, constructible via `From<T: AsFd>`. On Windows, constructible via `From<T:
+/// AsSocket>`.
+// Wrapper around socket2 to avoid making it a public dependency and incurring stability risk
+#[cfg(not(wasm_browser))]
+pub struct UdpSockRef<'a>(socket2::SockRef<'a>);
+
+#[cfg(unix)]
+impl<'s, S> From<&'s S> for UdpSockRef<'s>
+where
+    S: AsFd,
+{
+    fn from(socket: &'s S) -> Self {
+        Self(socket.into())
+    }
+}
+
+#[cfg(windows)]
+impl<'s, S> From<&'s S> for UdpSockRef<'s>
+where
+    S: AsSocket,
+{
+    fn from(socket: &'s S) -> Self {
+        Self(socket.into())
+    }
+}
+
+/// Explicit congestion notification codepoint
+#[repr(u8)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum EcnCodepoint {
+    /// The ECT(0) codepoint, indicating that an endpoint is ECN-capable
+    Ect0 = 0b10,
+    /// The ECT(1) codepoint, indicating that an endpoint is ECN-capable
+    Ect1 = 0b01,
+    /// The CE codepoint, signalling that congestion was experienced
+    Ce = 0b11,
+}
+
+impl EcnCodepoint {
+    /// Create new object from the given bits
+    pub fn from_bits(x: u8) -> Option<Self> {
+        use EcnCodepoint::*;
+        Some(match x & 0b11 {
+            0b10 => Ect0,
+            0b01 => Ect1,
+            0b11 => Ce,
+            _ => {
+                return None;
+            }
+        })
+    }
+}

vendor/quinn-udp/src/windows.rs

@@ -0,0 +1,513 @@
+use std::{
+    io::{self, IoSliceMut},
+    mem,
+    net::{IpAddr, Ipv4Addr},
+    os::windows::io::AsRawSocket,
+    ptr,
+    sync::Mutex,
+    time::Instant,
+};
+
+use libc::{c_int, c_uint};
+use once_cell::sync::Lazy;
+use windows_sys::Win32::Networking::WinSock;
+
+use crate::{
+    EcnCodepoint, IO_ERROR_LOG_INTERVAL, RecvMeta, Transmit, UdpSockRef,
+    cmsg::{self, CMsgHdr},
+    log::debug,
+    log_sendmsg_error,
+};
+
+/// QUIC-friendly UDP socket for Windows
+///
+/// Unlike a standard Windows UDP socket, this allows ECN bits to be read and written.
+#[derive(Debug)]
+pub struct UdpSocketState {
+    last_send_error: Mutex<Instant>,
+}
+
+impl UdpSocketState {
+    pub fn new(socket: UdpSockRef<'_>) -> io::Result<Self> {
+        assert!(
+            CMSG_LEN
+                >= WinSock::CMSGHDR::cmsg_space(mem::size_of::<WinSock::IN6_PKTINFO>())
+                    + WinSock::CMSGHDR::cmsg_space(mem::size_of::<c_int>())
+                    + WinSock::CMSGHDR::cmsg_space(mem::size_of::<u32>())
+        );
+        assert!(
+            mem::align_of::<WinSock::CMSGHDR>() <= mem::align_of::<cmsg::Aligned<[u8; 0]>>(),
+            "control message buffers will be misaligned"
+        );
+
+        socket.0.set_nonblocking(true)?;
+        let addr = socket.0.local_addr()?;
+        let is_ipv6 = addr.as_socket_ipv6().is_some();
+        let v6only = unsafe {
+            let mut result: u32 = 0;
+            let mut len = mem::size_of_val(&result) as i32;
+            let rc = WinSock::getsockopt(
+                socket.0.as_raw_socket() as _,
+                WinSock::IPPROTO_IPV6,
+                WinSock::IPV6_V6ONLY as _,
+                &mut result as *mut _ as _,
+                &mut len,
+            );
+            if rc == -1 {
+                return Err(io::Error::last_os_error());
+            }
+            result != 0
+        };
+        let is_ipv4 = addr.as_socket_ipv4().is_some() || !v6only;
+
+        // We don't support old versions of Windows that do not enable access to `WSARecvMsg()`
+        if WSARECVMSG_PTR.is_none() {
+            return Err(io::Error::new(
+                io::ErrorKind::Unsupported,
+                "network stack does not support WSARecvMsg function",
+            ));
+        }
+
+        if is_ipv4 {
+            set_socket_option(
+                &*socket.0,
+                WinSock::IPPROTO_IP,
+                WinSock::IP_DONTFRAGMENT,
+                OPTION_ON,
+            )?;
+
+            set_socket_option(
+                &*socket.0,
+                WinSock::IPPROTO_IP,
+                WinSock::IP_PKTINFO,
+                OPTION_ON,
+            )?;
+            set_socket_option(
+                &*socket.0,
+                WinSock::IPPROTO_IP,
+                WinSock::IP_RECVECN,
+                OPTION_ON,
+            )?;
+        }
+
+        if is_ipv6 {
+            set_socket_option(
+                &*socket.0,
+                WinSock::IPPROTO_IPV6,
+                WinSock::IPV6_DONTFRAG,
+                OPTION_ON,
+            )?;
+
+            set_socket_option(
+                &*socket.0,
+                WinSock::IPPROTO_IPV6,
+                WinSock::IPV6_PKTINFO,
+                OPTION_ON,
+            )?;
+
+            set_socket_option(
+                &*socket.0,
+                WinSock::IPPROTO_IPV6,
+                WinSock::IPV6_RECVECN,
+                OPTION_ON,
+            )?;
+        }
+
+        let now = Instant::now();
+        Ok(Self {
+            last_send_error: Mutex::new(now.checked_sub(2 * IO_ERROR_LOG_INTERVAL).unwrap_or(now)),
+        })
+    }
+
+    /// Enable or disable receive offloading.
+    ///
+    /// Also referred to as UDP Receive Segment Coalescing Offload (URO) on Windows.
+    ///
+    /// <https://learn.microsoft.com/en-us/windows-hardware/drivers/network/udp-rsc-offload>
+    ///
+    /// Disabled by default on Windows due to <https://github.com/quinn-rs/quinn/issues/2041>.
+    pub fn set_gro(&self, socket: UdpSockRef<'_>, enable: bool) -> io::Result<()> {
+        set_socket_option(
+            &*socket.0,
+            WinSock::IPPROTO_UDP,
+            WinSock::UDP_RECV_MAX_COALESCED_SIZE,
+            match enable {
+                // u32 per
+                // https://learn.microsoft.com/en-us/windows/win32/winsock/ipproto-udp-socket-options.
+                // Choice of 2^16 - 1 inspired by msquic.
+                true => u16::MAX as u32,
+                false => 0,
+            },
+        )
+    }
+
+    /// Sends a [`Transmit`] on the given socket.
+    ///
+    /// This function will only ever return errors of kind [`io::ErrorKind::WouldBlock`].
+    /// All other errors will be logged and converted to `Ok`.
+    ///
+    /// UDP transmission errors are considered non-fatal because higher-level protocols must
+    /// employ retransmits and timeouts anyway in order to deal with UDP's unreliable nature.
+    /// Thus, logging is most likely the only thing you can do with these errors.
+    ///
+    /// If you would like to handle these errors yourself, use [`UdpSocketState::try_send`]
+    /// instead.
+    pub fn send(&self, socket: UdpSockRef<'_>, transmit: &Transmit<'_>) -> io::Result<()> {
+        match send(socket, transmit) {
+            Ok(()) => Ok(()),
+            Err(e) if e.kind() == io::ErrorKind::WouldBlock => Err(e),
+            Err(e) => {
+                log_sendmsg_error(&self.last_send_error, e, transmit);
+
+                Ok(())
+            }
+        }
+    }
+
+    /// Sends a [`Transmit`] on the given socket without any additional error handling.
+    pub fn try_send(&self, socket: UdpSockRef<'_>, transmit: &Transmit<'_>) -> io::Result<()> {
+        send(socket, transmit)
+    }
+
+    pub fn recv(
+        &self,
+        socket: UdpSockRef<'_>,
+        bufs: &mut [IoSliceMut<'_>],
+        meta: &mut [RecvMeta],
+    ) -> io::Result<usize> {
+        let wsa_recvmsg_ptr = WSARECVMSG_PTR.expect("valid function pointer for WSARecvMsg");
+
+        // we cannot use [`socket2::MsgHdrMut`] as we do not have access to inner field which holds the WSAMSG
+        let mut ctrl_buf = cmsg::Aligned([0; CMSG_LEN]);
+        let mut source: WinSock::SOCKADDR_INET = unsafe { mem::zeroed() };
+        let mut data = WinSock::WSABUF {
+            buf: bufs[0].as_mut_ptr(),
+            len: bufs[0].len() as _,
+        };
+
+        let ctrl = WinSock::WSABUF {
+            buf: ctrl_buf.0.as_mut_ptr(),
+            len: ctrl_buf.0.len() as _,
+        };
+
+        let mut wsa_msg = WinSock::WSAMSG {
+            name: &mut source as *mut _ as *mut _,
+            namelen: mem::size_of_val(&source) as _,
+            lpBuffers: &mut data,
+            Control: ctrl,
+            dwBufferCount: 1,
+            dwFlags: 0,
+        };
+
+        let mut len = 0;
+        unsafe {
+            let rc = (wsa_recvmsg_ptr)(
+                socket.0.as_raw_socket() as usize,
+                &mut wsa_msg,
+                &mut len,
+                ptr::null_mut(),
+                None,
+            );
+            if rc == -1 {
+                return Err(io::Error::last_os_error());
+            }
+        }
+
+        let addr = unsafe {
+            let (_, addr) = socket2::SockAddr::try_init(|addr_storage, len| {
+                *len = mem::size_of_val(&source) as _;
+                ptr::copy_nonoverlapping(&source, addr_storage as _, 1);
+                Ok(())
+            })?;
+            addr.as_socket()
+        };
+
+        // Decode control messages (PKTINFO and ECN)
+        let mut ecn_bits = 0;
+        let mut dst_ip = None;
+        let mut stride = len;
+
+        let cmsg_iter = unsafe { cmsg::Iter::new(&wsa_msg) };
+        for cmsg in cmsg_iter {
+            const UDP_COALESCED_INFO: i32 = WinSock::UDP_COALESCED_INFO as i32;
+            // [header (len)][data][padding(len + sizeof(data))] -> [header][data][padding]
+            match (cmsg.cmsg_level, cmsg.cmsg_type) {
+                (WinSock::IPPROTO_IP, WinSock::IP_PKTINFO) => {
+                    let pktinfo =
+                        unsafe { cmsg::decode::<WinSock::IN_PKTINFO, WinSock::CMSGHDR>(cmsg) };
+                    // Addr is stored in big endian format
+                    let ip4 = Ipv4Addr::from(u32::from_be(unsafe { pktinfo.ipi_addr.S_un.S_addr }));
+                    dst_ip = Some(ip4.into());
+                }
+                (WinSock::IPPROTO_IPV6, WinSock::IPV6_PKTINFO) => {
+                    let pktinfo =
+                        unsafe { cmsg::decode::<WinSock::IN6_PKTINFO, WinSock::CMSGHDR>(cmsg) };
+                    // Addr is stored in big endian format
+                    dst_ip = Some(IpAddr::from(unsafe { pktinfo.ipi6_addr.u.Byte }));
+                }
+                (WinSock::IPPROTO_IP, WinSock::IP_ECN) => {
+                    // ECN is a C integer https://learn.microsoft.com/en-us/windows/win32/winsock/winsock-ecn
+                    ecn_bits = unsafe { cmsg::decode::<c_int, WinSock::CMSGHDR>(cmsg) };
+                }
+                (WinSock::IPPROTO_IPV6, WinSock::IPV6_ECN) => {
+                    // ECN is a C integer https://learn.microsoft.com/en-us/windows/win32/winsock/winsock-ecn
+                    ecn_bits = unsafe { cmsg::decode::<c_int, WinSock::CMSGHDR>(cmsg) };
+                }
+                (WinSock::IPPROTO_UDP, UDP_COALESCED_INFO) => {
+                    // Has type u32 (aka DWORD) per
+                    // https://learn.microsoft.com/en-us/windows/win32/winsock/ipproto-udp-socket-options
+                    stride = unsafe { cmsg::decode::<u32, WinSock::CMSGHDR>(cmsg) };
+                }
+                _ => {}
+            }
+        }
+
+        meta[0] = RecvMeta {
+            len: len as usize,
+            stride: stride as usize,
+            addr: addr.unwrap(),
+            ecn: EcnCodepoint::from_bits(ecn_bits as u8),
+            dst_ip,
+        };
+        Ok(1)
+    }
+
+    /// The maximum amount of segments which can be transmitted if a platform
+    /// supports Generic Send Offload (GSO).
+    ///
+    /// This is 1 if the platform doesn't support GSO. Subject to change if errors are detected
+    /// while using GSO.
+    #[inline]
+    pub fn max_gso_segments(&self) -> usize {
+        *MAX_GSO_SEGMENTS
+    }
+
+    /// The number of segments to read when GRO is enabled. Used as a factor to
+    /// compute the receive buffer size.
+    ///
+    /// Returns 1 if the platform doesn't support GRO.
+    #[inline]
+    pub fn gro_segments(&self) -> usize {
+        // Arbitrary reasonable value inspired by Linux and msquic
+        64
+    }
+
+    /// Resize the send buffer of `socket` to `bytes`
+    #[inline]
+    pub fn set_send_buffer_size(&self, socket: UdpSockRef<'_>, bytes: usize) -> io::Result<()> {
+        socket.0.set_send_buffer_size(bytes)
+    }
+
+    /// Resize the receive buffer of `socket` to `bytes`
+    #[inline]
+    pub fn set_recv_buffer_size(&self, socket: UdpSockRef<'_>, bytes: usize) -> io::Result<()> {
+        socket.0.set_recv_buffer_size(bytes)
+    }
+
+    /// Get the size of the `socket` send buffer
+    #[inline]
+    pub fn send_buffer_size(&self, socket: UdpSockRef<'_>) -> io::Result<usize> {
+        socket.0.send_buffer_size()
+    }
+
+    /// Get the size of the `socket` receive buffer
+    #[inline]
+    pub fn recv_buffer_size(&self, socket: UdpSockRef<'_>) -> io::Result<usize> {
+        socket.0.recv_buffer_size()
+    }
+
+    #[inline]
+    pub fn may_fragment(&self) -> bool {
+        false
+    }
+}
+
+fn send(socket: UdpSockRef<'_>, transmit: &Transmit<'_>) -> io::Result<()> {
+    // we cannot use [`socket2::sendmsg()`] and [`socket2::MsgHdr`] as we do not have access
+    // to the inner field which holds the WSAMSG
+    let mut ctrl_buf = cmsg::Aligned([0; CMSG_LEN]);
+    let daddr = socket2::SockAddr::from(transmit.destination);
+
+    let mut data = WinSock::WSABUF {
+        buf: transmit.contents.as_ptr() as *mut _,
+        len: transmit.contents.len() as _,
+    };
+
+    let ctrl = WinSock::WSABUF {
+        buf: ctrl_buf.0.as_mut_ptr(),
+        len: ctrl_buf.0.len() as _,
+    };
+
+    let mut wsa_msg = WinSock::WSAMSG {
+        name: daddr.as_ptr() as *mut _,
+        namelen: daddr.len(),
+        lpBuffers: &mut data,
+        Control: ctrl,
+        dwBufferCount: 1,
+        dwFlags: 0,
+    };
+
+    // Add control messages (ECN and PKTINFO)
+    let mut encoder = unsafe { cmsg::Encoder::new(&mut wsa_msg) };
+
+    if let Some(ip) = transmit.src_ip {
+        let ip = std::net::SocketAddr::new(ip, 0);
+        let ip = socket2::SockAddr::from(ip);
+        match ip.family() {
+            WinSock::AF_INET => {
+                let src_ip = unsafe { ptr::read(ip.as_ptr() as *const WinSock::SOCKADDR_IN) };
+                let pktinfo = WinSock::IN_PKTINFO {
+                    ipi_addr: src_ip.sin_addr,
+                    ipi_ifindex: 0,
+                };
+                encoder.push(WinSock::IPPROTO_IP, WinSock::IP_PKTINFO, pktinfo);
+            }
+            WinSock::AF_INET6 => {
+                let src_ip = unsafe { ptr::read(ip.as_ptr() as *const WinSock::SOCKADDR_IN6) };
+                let pktinfo = WinSock::IN6_PKTINFO {
+                    ipi6_addr: src_ip.sin6_addr,
+                    ipi6_ifindex: unsafe { src_ip.Anonymous.sin6_scope_id },
+                };
+                encoder.push(WinSock::IPPROTO_IPV6, WinSock::IPV6_PKTINFO, pktinfo);
+            }
+            _ => {
+                return Err(io::Error::from(io::ErrorKind::InvalidInput));
+            }
+        }
+    }
+
+    // ECN is a C integer https://learn.microsoft.com/en-us/windows/win32/winsock/winsock-ecn
+    let ecn = transmit.ecn.map_or(0, |x| x as c_int);
+    // True for IPv4 or IPv4-Mapped IPv6
+    let is_ipv4 = transmit.destination.is_ipv4()
+        || matches!(transmit.destination.ip(), IpAddr::V6(addr) if addr.to_ipv4_mapped().is_some());
+    if is_ipv4 {
+        encoder.push(WinSock::IPPROTO_IP, WinSock::IP_ECN, ecn);
+    } else {
+        encoder.push(WinSock::IPPROTO_IPV6, WinSock::IPV6_ECN, ecn);
+    }
+
+    // Segment size is a u32 https://learn.microsoft.com/en-us/windows/win32/api/ws2tcpip/nf-ws2tcpip-wsasetudpsendmessagesize
+    if let Some(segment_size) = transmit.segment_size {
+        encoder.push(
+            WinSock::IPPROTO_UDP,
+            WinSock::UDP_SEND_MSG_SIZE,
+            segment_size as u32,
+        );
+    }
+
+    encoder.finish();
+
+    let mut len = 0;
+    let rc = unsafe {
+        WinSock::WSASendMsg(
+            socket.0.as_raw_socket() as usize,
+            &wsa_msg,
+            0,
+            &mut len,
+            ptr::null_mut(),
+            None,
+        )
+    };
+
+    match rc {
+        0 => Ok(()),
+        _ => Err(io::Error::last_os_error()),
+    }
+}
+
+fn set_socket_option(
+    socket: &impl AsRawSocket,
+    level: i32,
+    name: i32,
+    value: u32,
+) -> io::Result<()> {
+    let rc = unsafe {
+        WinSock::setsockopt(
+            socket.as_raw_socket() as usize,
+            level,
+            name,
+            &value as *const _ as _,
+            mem::size_of_val(&value) as _,
+        )
+    };
+
+    match rc == 0 {
+        true => Ok(()),
+        false => Err(io::Error::last_os_error()),
+    }
+}
+
+pub(crate) const BATCH_SIZE: usize = 1;
+// Enough to store max(IP_PKTINFO + IP_ECN, IPV6_PKTINFO + IPV6_ECN) + max(UDP_SEND_MSG_SIZE, UDP_COALESCED_INFO) bytes (header + data) and some extra margin
+const CMSG_LEN: usize = 128;
+const OPTION_ON: u32 = 1;
+
+// FIXME this could use [`std::sync::OnceLock`] once the MSRV is bumped to 1.70 and upper
+static WSARECVMSG_PTR: Lazy<WinSock::LPFN_WSARECVMSG> = Lazy::new(|| {
+    let s = unsafe { WinSock::socket(WinSock::AF_INET as _, WinSock::SOCK_DGRAM as _, 0) };
+    if s == WinSock::INVALID_SOCKET {
+        debug!(
+            "ignoring WSARecvMsg function pointer due to socket creation error: {}",
+            io::Error::last_os_error()
+        );
+        return None;
+    }
+
+    // Detect if OS expose WSARecvMsg API based on
+    // https://github.com/Azure/mio-uds-windows/blob/a3c97df82018086add96d8821edb4aa85ec1b42b/src/stdnet/ext.rs#L601
+    let guid = WinSock::WSAID_WSARECVMSG;
+    let mut wsa_recvmsg_ptr = None;
+    let mut len = 0;
+
+    // Safety: Option handles the NULL pointer with a None value
+    let rc = unsafe {
+        WinSock::WSAIoctl(
+            s as _,
+            WinSock::SIO_GET_EXTENSION_FUNCTION_POINTER,
+            &guid as *const _ as *const _,
+            mem::size_of_val(&guid) as u32,
+            &mut wsa_recvmsg_ptr as *mut _ as *mut _,
+            mem::size_of_val(&wsa_recvmsg_ptr) as u32,
+            &mut len,
+            ptr::null_mut(),
+            None,
+        )
+    };
+
+    if rc == -1 {
+        debug!(
+            "ignoring WSARecvMsg function pointer due to ioctl error: {}",
+            io::Error::last_os_error()
+        );
+    } else if len as usize != mem::size_of::<WinSock::LPFN_WSARECVMSG>() {
+        debug!("ignoring WSARecvMsg function pointer due to pointer size mismatch");
+        wsa_recvmsg_ptr = None;
+    }
+
+    unsafe {
+        WinSock::closesocket(s);
+    }
+
+    wsa_recvmsg_ptr
+});
+
+static MAX_GSO_SEGMENTS: Lazy<usize> = Lazy::new(|| {
+    let socket = match std::net::UdpSocket::bind("[::]:0")
+        .or_else(|_| std::net::UdpSocket::bind((Ipv4Addr::LOCALHOST, 0)))
+    {
+        Ok(socket) => socket,
+        Err(_) => return 1,
+    };
+    const GSO_SIZE: c_uint = 1500;
+    match set_socket_option(
+        &socket,
+        WinSock::IPPROTO_UDP,
+        WinSock::UDP_SEND_MSG_SIZE,
+        GSO_SIZE,
+    ) {
+        // Empirically found on Windows 11 x64
+        Ok(()) => 512,
+        Err(_) => 1,
+    }
+});