Method WSARecvInto

crates/stdlib/src/overlapped.rs:750–816

(
            zelf: &Py<Self>,
            handle: isize,
            buf: PyBuffer,
            flags: u32,
            vm: &VirtualMachine,
        )

        // WSARecvInto
        #[pymethod]
        fn WSARecvInto(
            zelf: &Py<Self>,
            handle: isize,
            buf: PyBuffer,
            flags: u32,
            vm: &VirtualMachine,
        ) -> PyResult {
            use windows_sys::Win32::Foundation::{
                ERROR_BROKEN_PIPE, ERROR_IO_PENDING, ERROR_MORE_DATA, ERROR_SUCCESS,
            };
            use windows_sys::Win32::Networking::WinSock::{WSABUF, WSAGetLastError, WSARecv};

            let mut inner = zelf.inner.lock();
            if !matches!(inner.data, OverlappedData::None) {
                return Err(vm.new_value_error("operation already attempted"));
            }

            let mut flags = flags;
            inner.handle = handle as HANDLE;
            let buf_len = buf.desc.len;
            if buf_len > u32::MAX as usize {
                return Err(vm.new_value_error("buffer too large"));
            }

            let Some(contiguous) = buf.as_contiguous_mut() else {
                return Err(vm.new_buffer_error("buffer is not contiguous"));
            };

            inner.data = OverlappedData::ReadInto(buf.clone());

            let wsabuf = WSABUF {
                buf: contiguous.as_ptr() as *mut _,
                len: buf_len as u32,
            };
            let mut nread: u32 = 0;

            let ret = unsafe {
                WSARecv(
                    handle as _,
                    &wsabuf,
                    1,
                    &mut nread,
                    &mut flags,
                    &mut inner.overlapped,
                    None,
                )
            };

            let err = if ret < 0 {
                unsafe { WSAGetLastError() as u32 }
            } else {
                ERROR_SUCCESS
            };
            inner.error = err;

            match err {
                ERROR_BROKEN_PIPE => {
                    mark_as_completed(&mut inner.overlapped);