                         address name: UnsafePointer<sockaddr>,
                         address_len namelen: socklen_t) throws -> Bool {
         if WinSDK.connect(s, name, namelen) == SOCKET_ERROR {
+            let iResult = WSAGetLastError()
+            if iResult == WSAEWOULDBLOCK { return true }
             throw IOError(winsock: WSAGetLastError(), reason: "connect")
         }
         return true

    @inline(never)
    static func recvmmsg(socket: NIOBSDSocket.Handle,
                         msgvec: UnsafeMutablePointer<MMsgHdr>,
                         vlen: CUnsignedInt,
                         flags: CInt,
                         timeout: UnsafeMutablePointer<timespec>?) throws -> IOResult<Int> {
        return try Posix.recvmmsg(sockfd: socket,
                                  msgvec: msgvec,
                                  vlen: vlen,
                                  flags: flags,
                                  timeout: timeout)
    }

    @inline(never)
    static func sendmmsg(socket: NIOBSDSocket.Handle,
                         msgvec: UnsafeMutablePointer<MMsgHdr>,
                         vlen: CUnsignedInt,
                         flags: CInt) throws -> IOResult<Int> {
        return try Posix.sendmmsg(sockfd: socket,
                                  msgvec: msgvec,
                                  vlen: vlen,
                                  flags: flags)
    }

    // NOTE: this should return a `ssize_t`, however, that is not a standard

                     &nNumberOfBytesRead, &ovlOverlapped) {
            throw IOError(windows: GetLastError(), reason: "ReadFile")
        }
        return .processed(size_t(nNumberOfBytesRead))
    }

    // NOTE: this should return a `ssize_t`, however, that is not a standard
    // type, and defining that type is difficult.  Opt to return a `size_t`
    // which is the same size, but is unsigned.
    @inline(never)
    static func pwrite(socket: NIOBSDSocket.Handle, pointer: UnsafeRawPointer,
                       size: size_t, offset: off_t) throws -> IOResult<size_t> {
        var ovlOverlapped: OVERLAPPED = OVERLAPPED()
        ovlOverlapped.OffsetHigh = DWORD(UInt32(offset >> 32) & 0xffffffff)
        ovlOverlapped.Offset = DWORD(UInt32(offset >> 0) & 0xffffffff)
