Method sendmsg

crates/stdlib/src/socket.rs:1815–1871

(
            &self,
            buffers: Vec<ArgBytesLike>,
            ancdata: OptionalArg,
            flags: OptionalArg<i32>,
            addr: OptionalOption,
            vm: &VirtualMachine,
 

        #[cfg(all(unix, not(target_os = "redox")))]
        #[pymethod]
        fn sendmsg(
            &self,
            buffers: Vec<ArgBytesLike>,
            ancdata: OptionalArg,
            flags: OptionalArg<i32>,
            addr: OptionalOption,
            vm: &VirtualMachine,
        ) -> PyResult<usize> {
            let flags = flags.unwrap_or(0);
            let mut msg = socket2::MsgHdr::new();

            let sockaddr;
            if let Some(addr) = addr.flatten() {
                sockaddr = self
                    .extract_address(addr, "sendmsg", vm)
                    .map_err(|e| e.into_pyexception(vm))?;
                msg = msg.with_addr(&sockaddr);
            }

            let buffers = buffers
                .iter()
                .map(|buf| buf.borrow_buf())
                .collect::<Vec<_>>();
            let buffers = buffers
                .iter()
                .map(|buf| io::IoSlice::new(buf))
                .collect::<Vec<_>>();
            msg = msg.with_buffers(&buffers);

            let control_buf;
            if let OptionalArg::Present(ancdata) = ancdata {
                let cmsgs = vm.extract_elements_with(
                    &ancdata,
                    |obj| -> PyResult<(i32, i32, ArgBytesLike)> {
                        let seq: Vec<PyObjectRef> = obj.try_into_value(vm)?;
                        let [lvl, typ, data]: [PyObjectRef; 3] = seq
                            .try_into()
                            .map_err(|_| vm.new_type_error("expected a sequence of length 3"))?;
                        Ok((
                            lvl.try_into_value(vm)?,
                            typ.try_into_value(vm)?,
                            data.try_into_value(vm)?,
                        ))
                    },
                )?;
                control_buf = Self::pack_cmsgs_to_send(&cmsgs, vm)?;
                if !control_buf.is_empty() {
                    msg = msg.with_control(&control_buf);
                }
            }

            self.sock_op(vm, SelectKind::Write, || {
                let sock = self.sock()?;
                sock.sendmsg(&msg, flags)
            })
            .map_err(|e| e.into_pyexception(vm))
        }