Client向Server send数据，返回 WSAEWOULDBLOCK 错误

参见MSDN中的一段：

The FD_WRITE network event is handled slightly differently. An FD_WRITE network event is recorded when a socket is first connected with connect/ WSAConnect or accepted with accept/ WSAAccept, and then after a send fails with WSAEWOULDBLOCK and buffer space becomes available. Therefore, an application can assume that sends are possible starting from the first FD_WRITE network event setting and lasting until a send returns WSAEWOULDBLOCK. After such a failure the application will find out that sends are again possible when an FD_WRITE network event is recorded and the associated event object is set.

参考http://blog.youkuaiyun.com/strikebone/article/details/1765839这篇文章，如下解释：

首先，Winsock 异常 WSAEWOULDBLOCK (WSAGetLastError) 的意思是 Output Buffer 已经满了，无法再写入数据。确切的说它其实不算是个错误，出现这种异常的绝大部分时候其实都不存在 Output Buffer 已满情况，而是处于一种“忙”的状态，而这种“忙”的状态还很大程度上是由于接收方造成的。意思就是你要发送的对象，对方收的没你发的快或者对方的接受缓冲区已被填满，所以就返回你一个“忙”的标志，而这时你再发多少数据都没任何意义，所以系统就返回 WSAEWOULDBLOCK 异常通知你。

那么，该怎么办呢？网上有很多朋友的做法是遇到这种情况就 Sleep 一段时间，一般短暂停顿后 Output Buffer 就空出来了，那就又可以继续发送了。推荐的方法：根据 MSDN 文档所示，当出现 WSAEWOULDBLOCK 异常后直到空出 Output Buffer 时，系统会发送一个 FD_WRITE 给发送方。我们完全可以在等收到 FD_WRITE 消息后再重新发送从出现异常开始的数据包即可（该包需要全部重新发送）。

至此，该问题结案。最后顺便提一下：FD_WRITE 消息会在至少三钟情况下出现，而上面只是其中的一种，所以我建议给 Socket 做个标志判断以便于规范性。

客户端可能的实现如下：

 

static BOOL ComWrite(PSFTHREAD pSFThread, size_t length, int type, size_t bufsize, void *buf, WCHAR *fname)
{
    BOOL bRet;

    PSENDLOG_PRIVATE_DATA ses = (PSENDLOG_PRIVATE_DATA)pSFThread->privateData;
    PSMON_ENV pEnv = pSFThread->pEnv;

    DWORD dwEvent;
    WSANETWORKEVENTS nEvents;
    int nRet;
    size_t send_size = 0;
    size_t read_size = 0;
    HANDLE fd;
    char *fileBuf = NULL;
    DWORD fileSize;
    DWORD rBytes;

    HANDLE hEvents[] = {
        GET_EXIT_EVENT(pEnv),
        ses->socEvent
    };

    // Parameter check
    if(type >= SFCOM_INPUTTYPE_TAILNUM){
        return FALSE;
    }
    if(bufsize == 0){
        bufsize = length;
    }

    if(type == SFCOM_INPUTTYPE_FILE){
        fd = CreateFile(fname,
                        GENERIC_READ | GENERIC_WRITE,
                        FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                        NULL,
                        OPEN_EXISTING,
                        FILE_ATTRIBUTE_NORMAL,
                        NULL);
        if(fd == INVALID_HANDLE_VALUE){
            SFERRLOG();
            return FALSE;
        }
        fileSize = GetFileSize(fd, NULL);
        if(fileSize == -1){
            goto Cleanup;
        }else if(fileSize == 0){
            // File empty
            goto Cleanup;
        }
        fileBuf = (char*)malloc(fileSize);
        if(fileBuf == NULL){
            goto Cleanup;
        }
        bRet = ReadFile(fd, fileBuf, fileSize, &rBytes, NULL);
        if(!bRet || rBytes != fileSize){
            goto Cleanup;
        }
        buf = fileBuf;
    }

    size_t length_remained = length;
    while(1){
        nRet = send(ses->soc, (char*)buf + send_size, (int)min(length_remained, SFCOM_TCP_SEND_MAX_SIZE), 0);
        if(nRet == SOCKET_ERROR){
            if(WSAGetLastError() != WSAEWOULDBLOCK){
                // Error
                SFCOMDBGOUT("Error occured:%d\n", WSAGetLastError());
                goto Cleanup;
            }
            // WSAEWOULDBLOCK WaitForMultipleObjects FD_WRITE
            SFCOMDBGOUT("ComWrite send WSAEWOULDBLOCK");
        }else{
            if(nRet <= length_remained) length_remained -= nRet;

            send_size += nRet;
            SFCOMDBGOUT("send %dbytes(total %dbytes)\n", nRet, send_size);

            if(send_size == length){
                return TRUE;
            }else if(send_size < length){
                continue;
            }
        }

        dwEvent = WaitForMultipleObjects(2, hEvents, FALSE, INFINITE);
        if(dwEvent == WAIT_OBJECT_0){
            // Exit thread event.
            ses->exitEventFlag = TRUE;
            goto Cleanup;
        }else if(dwEvent == WAIT_OBJECT_0 + 1){
            // Socket event.
            nRet = WSAEnumNetworkEvents(ses->soc, ses->socEvent, &nEvents);
            if(nRet == SOCKET_ERROR){
                // Error
                SFCOMDBGOUT("ComWrite Error occured:%d\n", WSAGetLastError());
                goto Cleanup;
            }
            if(nEvents.lNetworkEvents & FD_CLOSE){
                // FD_CLOSE
                SFCOMDBGOUT("ComWrite FD_CLOSE\n");
                goto Cleanup;
            }
            if((nEvents.lNetworkEvents & FD_WRITE) && (nEvents.iErrorCode[FD_WRITE_BIT] == 0)){
                continue;
            }else{
                goto Cleanup;
            }
        }else if(dwEvent == WAIT_TIMEOUT){
            // Timeout
            SFCOMDBGOUT("ComWrite WAIT_TIMEOUT\n");
            goto Cleanup;
        }else{
            // Error
            SFCOMDBGOUT("ComWrite WAIT_FAILED\n");
            goto Cleanup;
        }
    }

    return TRUE;

Cleanup:
    if(type == SFCOM_INPUTTYPE_FILE){
        CloseHandle(fd);
        if(fileBuf != NULL){
            free(fileBuf);
        }
    }

    ComClose(ses);
    return FALSE;
}