feat(io): fix ancillary API to avoid UB (#737)

* feat(io): new AncillaryBuf::build() API

* fix(io): redo new AncillaryBuilder API

* fix(io): address CR issues

* fix(io): fix API to avoid UB

* fix(io): gate libc::in_pktinfo for Linux/Android

* fix(io): replace with Pod, fix hirarchy and docs

* fix(io,quic): fix decode_data(), propagate error

* fix(quic): unsafe union access on Windows

* chore(quic): use helpful panic message

* fix(io): enable bytemuck:min_const_generics

Author: fantix

Cargo.toml

@@ -40,6 +40,7 @@ compio-quic = { path = "./compio-quic", version = "0.7.0", default-features = fa
 compio-ws = { path = "./compio-ws", version = "0.3.0", default-features = false }
 
 bytes = "1.7.1"
+bytemuck = "1.25.0"
 cfg_aliases = "0.2.1"
 cfg-if = "1.0.0"
 compio-send-wrapper = "0.7.0"

compio-io/Cargo.toml

@@ -20,6 +20,7 @@ cfg-if = { workspace = true, optional = true }
 thiserror = { workspace = true, optional = true }
 serde = { version = "1.0.219", optional = true }
 serde_json = { version = "1.0.140", optional = true }
+bytemuck = { workspace = true, optional = true, features = ["min_const_generics"] }
 
 [target.'cfg(unix)'.dependencies]
 libc = { workspace = true, optional = true }
@@ -30,7 +31,6 @@ windows-sys = { workspace = true, optional = true, features = [
 ] }
 
 [dev-dependencies]
-aligned-array = "1.0.1"
 tokio = { workspace = true, features = ["macros", "rt"] }
 serde = { version = "1.0.219", features = ["derive"] }
 futures-executor = "0.3.30"
@@ -58,3 +58,7 @@ required-features = ["compat"]
 [[test]]
 name = "framed"
 required-features = ["codec-serde-json"]
+
+[[test]]
+name = "ancillary"
+required-features = ["ancillary"]

compio-io/src/ancillary/bytemuck_ext.rs

@@ -0,0 +1,74 @@
+//! Extension module for automatic [`AncillaryData`] implementation via
+//! bytemuck.
+//!
+//! See [`BitwiseAncillaryData`] for details.
+
+use std::mem::MaybeUninit;
+
+pub use bytemuck::{Pod, Zeroable};
+
+use super::{AncillaryData, CodecError, copy_from_bytes, copy_to_bytes};
+
+/// Marker trait to enable automatic `AncillaryData` implementation via
+/// bytemuck.
+///
+/// Types that implement this trait (which requires [`bytemuck::Pod`]) will
+/// automatically implement [`AncillaryData`] using a simple byte-wise
+/// encoding/decoding.
+///
+/// # Example
+///
+/// ```
+/// use compio_io::ancillary::bytemuck_ext;
+///
+/// #[derive(Clone, Copy)]
+/// #[repr(C)]
+/// struct MyType {
+///     value: u32,
+/// }
+///
+/// unsafe impl bytemuck_ext::Zeroable for MyType {}
+/// unsafe impl bytemuck_ext::Pod for MyType {}
+/// impl bytemuck_ext::BitwiseAncillaryData for MyType {}
+///
+/// // Now MyType automatically implements AncillaryData
+/// ```
+pub trait BitwiseAncillaryData: Pod {}
+
+impl<T: BitwiseAncillaryData> AncillaryData for T {
+    fn encode(&self, buffer: &mut [MaybeUninit<u8>]) -> Result<(), CodecError> {
+        unsafe { copy_to_bytes(self, buffer) }
+    }
+
+    fn decode(buffer: &[u8]) -> Result<Self, CodecError> {
+        unsafe { copy_from_bytes(buffer) }
+    }
+}
+
+macro_rules! impl_bytemuck_marker {
+    ($($t:ty),* $(,)?) => {
+        $(
+            impl BitwiseAncillaryData for $t {}
+        )*
+    };
+}
+
+impl_bytemuck_marker!(
+    (),
+    u8,
+    u16,
+    u32,
+    u64,
+    u128,
+    usize,
+    i8,
+    i16,
+    i32,
+    i64,
+    i128,
+    isize,
+    f32,
+    f64,
+);
+
+impl<T: BitwiseAncillaryData, const N: usize> BitwiseAncillaryData for [T; N] {}