如何正确循环使用Winsock recv函数？解决HTTP服务器收数异常问题

你的代码存在两个核心问题，导致依赖Sleep才能稳定接收POST数据：

1. 非阻塞recv的轮询逻辑缺陷：去掉Sleep(5)后，recv可能在客户端POST数据尚未完全发送到服务器时就返回WSAEWOULDBLOCK，导致提前跳出接收循环，无法获取完整请求数据。
2. 阻塞模式的接收逻辑错误：若直接将客户端套接字设为阻塞，recv会一直阻塞到有数据或连接关闭，但HTTP请求（尤其是持久连接场景）中客户端发送完数据后不会立刻关闭连接，导致程序无限等待。

以下是两种可行的修复方案：

方案1：用IO多路复用优化非阻塞套接字接收 #

放弃低效的Sleep轮询，使用select等待套接字可读，确保仅在数据到达时调用recv，既保证接收完整性又提升效率。

修改后的接收循环代码：

// 初始化fd_set与超时配置
fd_set read_fds;
timeval timeout;
FD_ZERO(&read_fds);
FD_SET(ud.ClientSocket, &read_fds);

// 设置超时时间（可根据业务需求调整，示例为5秒）
timeout.tv_sec = 5;
timeout.tv_usec = 0;

while (true) {
    // 等待套接字可读或超时
    int selectResult = select(0, &read_fds, NULL, NULL, &timeout);
    if (selectResult == SOCKET_ERROR) {
        int err = WSAGetLastError();
        // 处理select调用错误，例如打印日志后跳出循环
        break;
    }
    if (selectResult == 0) {
        // 超时判定为请求不完整，断开连接
        break;
    }

    // 套接字可读，执行recv操作
    ZeroMemory(szRecvBuffer, sizeof(szRecvBuffer));
    iResult = recv(ud.ClientSocket, szRecvBuffer, sizeof(szRecvBuffer) - 6, 0);
    iLastError = WSAGetLastError();

    if (iResult > 0) {
        ud.ReceivedData.append(szRecvBuffer);
        
        // 可选优化：解析HTTP请求头中的Content-Length，判断是否已接收完整数据
        // 若已接收足够字节，可直接跳出循环，无需继续等待
        continue;
    }

    if (iResult == 0) {
        // 客户端主动关闭连接
        break;
    }

    // 仅忽略WSAEWOULDBLOCK，其他错误需处理
    if (iLastError != WSAEWOULDBLOCK) {
        break;
    }

    // 重置fd_set，因为select会修改集合内容
    FD_ZERO(&read_fds);
    FD_SET(ud.ClientSocket, &read_fds);
}

方案2：阻塞套接字+HTTP协议规范接收 #

若偏好阻塞模式的简单性，需严格遵循HTTP协议规则判断数据接收边界，而非依赖连接关闭信号：

1. 先接收并解析请求头，提取Content-Length字段；
2. 根据Content-Length的值接收对应长度的请求体，接收完成后立即停止，无需等待连接关闭。

修改后的代码示例：

// 将客户端套接字设为阻塞模式
SetBlockingMode(ud.ClientSocket, TRUE);

std::string requestHeader;
char buffer[1024];

// 第一步：接收并解析HTTP请求头（以\r\n\r\n为结束标志）
while (true) {
    iResult = recv(ud.ClientSocket, buffer, sizeof(buffer)-1, 0);
    if (iResult <= 0) {
        // 处理错误或连接异常关闭
        break;
    }
    buffer[iResult] = '\0';
    requestHeader += buffer;

    // 检查请求头是否结束
    size_t headerEndPos = requestHeader.find("\r\n\r\n");
    if (headerEndPos != std::string::npos) {
        ud.ReceivedData = requestHeader;
        
        // 第二步：解析Content-Length，接收完整请求体
        size_t contentLenMarkerPos = requestHeader.find("Content-Length: ");
        if (contentLenMarkerPos != std::string::npos) {
            contentLenMarkerPos += strlen("Content-Length: ");
            size_t contentLenEndPos = requestHeader.find("\r\n", contentLenMarkerPos);
            std::string contentLenStr = requestHeader.substr(contentLenMarkerPos, contentLenEndPos - contentLenMarkerPos);
            int totalBodyLen = std::stoi(contentLenStr);
            
            // 计算已接收的请求体长度，剩余需要接收的字节数
            int receivedBodyLen = ud.ReceivedData.size() - (headerEndPos + 4);
            int remainingBytes = totalBodyLen - receivedBodyLen;
            
            // 循环接收剩余的请求体数据
            while (remainingBytes > 0 && iResult > 0) {
                int recvChunkSize = std::min(remainingBytes, (int)sizeof(buffer)-1);
                iResult = recv(ud.ClientSocket, buffer, recvChunkSize, 0);
                if (iResult > 0) {
                    buffer[iResult] = '\0';
                    ud.ReceivedData += buffer;
                    remainingBytes -= iResult;
                }
            }
        }
        break;
    }
}

// 后续执行请求处理、套接字关闭逻辑...

关键注意事项 #

• 无论采用哪种方案，严格遵循HTTP协议规范处理请求边界是稳定接收POST数据的核心，尤其是要正确解析Content-Length或分块编码（若支持）。
• 非阻塞模式+IO多路复用适合高并发场景，阻塞模式更适合小并发、逻辑简单的服务端程序。

内容的提问来源于stack exchange，提问作者Roland Smith