Method WSASendTo

crates/stdlib/src/overlapped.rs:1233–1307

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

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

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

            let (addr_bytes, addr_len) = parse_address(&address, vm)?;

            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() else {
                return Err(vm.new_buffer_error("buffer is not contiguous"));
            };

            // Store both buffer and address in OverlappedData to keep them alive
            inner.data = OverlappedData::WriteTo(OverlappedWriteTo {
                buf: buf.clone(),
                address: addr_bytes,
            });

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

            // Get pointer to the stored address data
            let addr_ptr = match &inner.data {
                OverlappedData::WriteTo(wt) => wt.address.as_ptr(),
                _ => unreachable!(),
            };

            let ret = unsafe {
                WSASendTo(
                    handle as _,
                    &wsabuf,
                    1,
                    &mut written,
                    flags,
                    addr_ptr as *const SOCKADDR,
                    addr_len,
                    &mut inner.overlapped,
                    None,
                )