Method ConnectEx

crates/stdlib/src/overlapped.rs:1008–1073

(
            zelf: &Py<Self>,
            socket: isize,
            address: PyTupleRef,
            vm: &VirtualMachine,
        )

        // ConnectEx
        #[pymethod]
        fn ConnectEx(
            zelf: &Py<Self>,
            socket: isize,
            address: PyTupleRef,
            vm: &VirtualMachine,
        ) -> PyResult {
            use windows_sys::Win32::Foundation::{ERROR_IO_PENDING, ERROR_SUCCESS};
            use windows_sys::Win32::Networking::WinSock::WSAGetLastError;

            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 = socket as HANDLE;
            // Store addr_bytes in OverlappedData to keep it alive during async operation
            inner.data = OverlappedData::Connect(addr_bytes);

            type ConnectExFn = unsafe extern "system" fn(
                s: usize,
                name: *const SOCKADDR,
                namelen: i32,
                lpSendBuffer: *const core::ffi::c_void,
                dwSendDataLength: u32,
                lpdwBytesSent: *mut u32,
                lpOverlapped: *mut OVERLAPPED,
            ) -> i32;

            let connect_ex: ConnectExFn =
                unsafe { core::mem::transmute(*CONNECT_EX.get().unwrap()) };

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

            let ret = unsafe {
                connect_ex(
                    socket as _,
                    addr_ptr as *const SOCKADDR,
                    addr_len,
                    core::ptr::null(),
                    0,
                    core::ptr::null_mut(),
                    &mut inner.overlapped,
                )
            };

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