Method ioctl

crates/stdlib/src/socket.rs:2363–2459

(
            &self,
            cmd: PyObjectRef,
            option: PyObjectRef,
            vm: &VirtualMachine,
        )

        #[cfg(windows)]
        #[pymethod]
        fn ioctl(
            &self,
            cmd: PyObjectRef,
            option: PyObjectRef,
            vm: &VirtualMachine,
        ) -> Result<u32, IoOrPyException> {
            use crate::vm::builtins::PyInt;
            use crate::vm::convert::TryFromObject;

            let sock = self.sock()?;
            let fd = sock_fileno(&sock);
            let mut recv: u32 = 0;

            // Convert cmd to u32, returning ValueError for invalid/negative values
            let cmd_int = cmd
                .downcast::<PyInt>()
                .map_err(|_| vm.new_type_error("an integer is required"))?;
            let cmd_val = cmd_int.as_bigint();
            let cmd: u32 = cmd_val
                .to_u32()
                .ok_or_else(|| vm.new_value_error(format!("invalid ioctl command {}", cmd_val)))?;

            match cmd {
                c::SIO_RCVALL | c::SIO_LOOPBACK_FAST_PATH => {
                    // Option must be an integer, not None
                    if vm.is_none(&option) {
                        return Err(vm
                            .new_type_error("an integer is required (got type NoneType)")
                            .into());
                    }
                    let option_val: u32 = TryFromObject::try_from_object(vm, option)?;
                    let ret = unsafe {
                        c::WSAIoctl(
                            fd as _,
                            cmd,
                            &option_val as *const u32 as *const _,
                            core::mem::size_of::<u32>() as u32,
                            core::ptr::null_mut(),
                            0,
                            &mut recv,
                            core::ptr::null_mut(),
                            None,
                        )
                    };
                    if ret == c::SOCKET_ERROR {
                        return Err(Self::wsa_error().into());
                    }
                    Ok(recv)
                }
                c::SIO_KEEPALIVE_VALS => {
                    let tuple: PyTupleRef = option
                        .downcast()
                        .map_err(|_| vm.new_type_error("SIO_KEEPALIVE_VALS requires a tuple"))?;
                    if tuple.len() != 3 {
                        return Err(vm
                            .new_type_error(
                                "SIO_KEEPALIVE_VALS requires (onoff, keepalivetime, keepaliveinterval)",
                            )