Method pack_cmsgs_to_send

crates/stdlib/src/socket.rs:2117–2168

(
            cmsgs: &[(i32, i32, ArgBytesLike)],
            vm: &VirtualMachine,
        )

        // based on nix's implementation
        #[cfg(all(unix, not(target_os = "redox")))]
        fn pack_cmsgs_to_send(
            cmsgs: &[(i32, i32, ArgBytesLike)],
            vm: &VirtualMachine,
        ) -> PyResult<Vec<u8>> {
            use core::{mem, ptr};

            if cmsgs.is_empty() {
                return Ok(vec![]);
            }

            let capacity = cmsgs
                .iter()
                .map(|(_, _, buf)| buf.len())
                .try_fold(0, |sum, len| {
                    let space = checked_cmsg_space(len).ok_or_else(|| {
                        vm.new_os_error("ancillary data item too large".to_owned())
                    })?;
                    usize::checked_add(sum, space)
                        .ok_or_else(|| vm.new_os_error("too much ancillary data".to_owned()))
                })?;

            let mut cmsg_buffer = vec![0u8; capacity];

            // make a dummy msghdr so we can use the CMSG_* apis
            let mut mhdr = unsafe { mem::zeroed::<libc::msghdr>() };
            mhdr.msg_control = cmsg_buffer.as_mut_ptr().cast();
            mhdr.msg_controllen = capacity as _;

            let mut pmhdr: *mut libc::cmsghdr = unsafe { libc::CMSG_FIRSTHDR(&mhdr) };
            for (lvl, typ, buf) in cmsgs {
                if pmhdr.is_null() {
                    return Err(vm.new_runtime_error(
                        "unexpected NULL result from CMSG_FIRSTHDR/CMSG_NXTHDR",
                    ));
                }
                let data = &*buf.borrow_buf();
                assert_eq!(data.len(), buf.len());
                // Safe because we know that pmhdr is valid, and we initialized it with
                // sufficient space
                unsafe {
                    (*pmhdr).cmsg_level = *lvl;
                    (*pmhdr).cmsg_type = *typ;
                    (*pmhdr).cmsg_len = libc::CMSG_LEN(data.len() as _) as _;
                    ptr::copy_nonoverlapping(data.as_ptr(), libc::CMSG_DATA(pmhdr), data.len());
                }

                // Safe because mhdr is valid
                pmhdr = unsafe { libc::CMSG_NXTHDR(&mhdr, pmhdr) };
            }

            Ok(cmsg_buffer)
        }

        #[pymethod]
        fn close(&self) -> io::Result<()> {