c++ - 与浏览器通信时出现奇怪的 IOCP 行为

问题描述

我正在为从桌面客户端到浏览器的视频流编写 IOCP 服务器。双方都使用 WebSocket 协议来统一服务器的架构（并且因为浏览器没有其他方式来执行全双工交换）。

工作线程是这样开始的：

unsigned int __stdcall WorkerThread(void * param){
    int ThreadId = (int)param;
    OVERLAPPED *overlapped = nullptr;
    IO_Context *ctx = nullptr;
    Client *client = nullptr;
    DWORD transfered = 0;
    BOOL QCS = 0;

    while(WAIT_OBJECT_0 != WaitForSingleObject(EventShutdown, 0)){
        QCS = GetQueuedCompletionStatus(hIOCP, &transfered, (PULONG_PTR)&client, &overlapped, INFINITE);

        if(!client){
            if( Debug ) printf("No client\n");
            break;
        }
        ctx = (IO_Context *)overlapped;
        if(!QCS || (QCS && !transfered)){
            printf("Error %d\n", WSAGetLastError());
            DeleteClient(client);
            continue;
        }

        switch(auto opcode = client->ProcessCurrentEvent(ctx, transfered)){
            // Client owed to receive some data
            case OPCODE_RECV_DEBT:{ 
                if((SOCKET_ERROR == client->Recv()) && (WSA_IO_PENDING != WSAGetLastError())) DeleteClient(client);
                break;
            }
            // Client received all data or the beginning of new message
            case OPCODE_RECV_DONE:{ 
                std::string message;
                client->GetInput(message);
                // Analizing the first byte of WebSocket frame
                switch( opcode = message[0] & 0xFF ){ 
                    // HTTP_HANDSHAKE is 'G' - from GET HTTP...
                    case HTTP_HANDSHAKE:{
                        message = websocket::handshake(message);
                        while(!client->SetSend(message)) Sleep(1); // Set outgoing data
                        if((SOCKET_ERROR == client->Send()) && (WSA_IO_PENDING != WSAGetLastError())) DeleteClient(client);
                        break;
                    }
                    // Browser sent a closing frame (0x88) - performing clean WebSocket closure
                    case FIN_CLOSE:{
                        websocket::frame frame;
                        frame.parse(message);
                        frame.masked = false;
                        if( frame.pl_len == 0 ){
                            unsigned short reason = 1000;
                            frame.payload.resize(sizeof(reason));
                            frame.payload[0] = (reason >> 8) & 0xFF;
                            frame.payload[1] =  reason       & 0xFF;
                        }
                        frame.pack(message);
                        while(!client->SetSend(message)) Sleep(1);
                        if((SOCKET_ERROR == client->Send()) && (WSA_IO_PENDING != WSAGetLastError())) DeleteClient(client);
                        shutdown(client->Socket(), SD_SEND);
                        break;
                    }

IO上下文结构：

struct IO_Context{
    OVERLAPPED overlapped;
    WSABUF data;
    char buffer[IO_BUFFER_LENGTH];
    unsigned char opcode;
    unsigned long long debt;
    std::string message;
    IO_Context(){
        debt = 0;
        opcode = 0;
        data.buf = buffer;
        data.len = IO_BUFFER_LENGTH;
        overlapped.Offset = overlapped.OffsetHigh = 0;
        overlapped.Internal = overlapped.InternalHigh = 0;
        overlapped.Pointer = nullptr;
        overlapped.hEvent = nullptr;
    }
    ~IO_Context(){ while(!HasOverlappedIoCompleted(&overlapped)) Sleep(1); }
};

客户端发送功能：

int Client::Send(){
    int var_buf = O.message.size();
    // "O" is IO_Context for Output
    O.data.len = (var_buf>IO_BUFFER_LENGTH)?IO_BUFFER_LENGTH:var_buf;
    var_buf = O.data.len;
    while(var_buf > 0) O.data.buf[var_buf] = O.message[--var_buf];
    O.message.erase(0, O.data.len);
    return WSASend(connection, &O.data, 1, nullptr, 0, &O.overlapped, nullptr);
}

当桌面客户端断开连接时（它只使用 closesocket() 来完成，没有 shutdown()）GetQueuedCompletionStatus 返回 TRUE 并将 transfered 设置为 0 - 在这种情况下 WSAGetLastError() 返回 64（指定的网络名称不再可用），它有感觉 - 客户端断开连接（符合if(!QCS || (QCS && !transfered))）。但是当浏览器断开连接时，错误代码让我感到困惑......它可以是0、997（等待操作）、87（无效参数）......并且没有与连接结束相关的代码。

为什么 IOCP 选择此事件？它如何选择挂起的操作？为什么传输0字节时错误为0？它还会导致无休止地尝试删除与重叠结构关联的对象，因为析构函数要求~IO_Context(){ while(!HasOverlappedIoCompleted(&overlapped)) Sleep(1); }安全删除。在DeleteClient通话中，套接字以关闭closesocket()，但是，如您所见，我shutdown(client->Socket(), SD_SEND);在它之前发布了一个调用（在FIN_CLOSE部分中）。

我知道连接有两个方面，在服务器端关闭它并不意味着另一端也会关闭它。但是我需要创建一个稳定的服务器，不受坏连接和半开连接的影响。例如，Web 应用程序的用户可以快速按 F5 重新加载页面几次（是的，有些家伙这样做:)） - 连接将重新打开几次，并且服务器不能因为此操作而延迟或崩溃。

如何处理 IOCP 中的这种“坏”事件？

标签： c++socketswinapiwinsockiocp

解决方案

你这里有很多错误的代码。

while(WAIT_OBJECT_0 != WaitForSingleObject(EventShutdown, 0)){
    QCS = GetQueuedCompletionStatus(hIOCP, &transfered, (PULONG_PTR)&client, &overlapped, INFINITE);

这不是有效且错误的 stop 代码WorkerThread。起初你做多余的电话WaitForSingleObject，使用多余EventShutdown的和主要的，无论如何都无法关闭。如果您的代码等待GetQueuedCompletionStatus您所说的内部数据包EventShutdown- 而不是中断GetQueuedCompletionStatus呼叫 - 您将在此处继续无限等待。正确的关机方法 -PostQueuedCompletionStatus(hIOCP, 0, 0, 0)而是调用SetEvent(EventShutdown)，如果工作线程视图client == 0- 他打破循环。通常你需要有多个WorkerThread（而不是单个）。和多个调用PostQueuedCompletionStatus(hIOCP, 0, 0, 0)- 工作线程的确切计数。您还需要将此调用与 io 同步 - 只有在所有 io 已经完成并且没有新的 io 数据包将排队到 iocp 后才执行此操作。所以“空包”必须是最后一个排队到端口的

if(!QCS || (QCS && !transfered)){
            printf("Error %d\n", WSAGetLastError());
            DeleteClient(client);
            continue;
        }

if !QCS-client未初始化的值，您根本无法使用它并且DeleteClient(client);在这种情况下调用是错误的

当 object( client) 从多个线程中使用时——谁必须删除它？如果一个线程删除对象，而另一个线程仍在使用它会怎样？正确的解决方案是在此类对象（客户端）上使用引用计数。并根据您的代码 - 每个 hIOCP 都有一个客户端？因为您检索客户端的指针作为 hIOCP 的完成键，这对于绑定到 hIOCP 的套接字上的所有 I/O 操作都是单一的。这一切都是错误的设计。

您需要将指向客户端的指针存储在IO_Context. 并在析构函数中添加对客户端的引用IO_Context并释放客户端。IO_Context

class IO_Context : public OVERLAPPED {
    Client *client;
    ULONG opcode;
    // ...

public:
    IO_Context(Client *client, ULONG opcode) : client(client), opcode(opcode) {
        client->AddRef();
    }

    ~IO_Context() {
        client->Release();
    }

    void OnIoComplete(ULONG transfered) {
        OnIoComplete(RtlNtStatusToDosError(Internal), transfered);
    }

    void OnIoComplete(ULONG error, ULONG transfered) {
        client->OnIoComplete(opcode, error, transfered);
        delete this;
    }

    void CheckIoError(ULONG error) {
        switch(error) {
            case NOERROR:
            case ERROR_IO_PENDING:
                break;
            default:
                OnIoComplete(error, 0);
        }
    }
};

那你有单身IO_Context吗？如果是，这是致命错误。IO_Context必须对每个 I/O 操作都是唯一的。

if (IO_Context* ctx = new IO_Context(client, op))
{
    ctx->CheckIoError(WSAxxx(ctx) == 0 ? NOERROR : WSAGetLastError());
}

并从工作线程

ULONG WINAPI WorkerThread(void * param)
{
    ULONG_PTR key;
    OVERLAPPED *overlapped;
    ULONG transfered;
    while(GetQueuedCompletionStatus(hIOCP, &transfered, &key, &overlapped, INFINITE)) {
        switch (key){
        case '_io_':
            static_cast<IO_Context*>(overlapped)->OnIoComplete(transfered);
            continue;
        case 'stop':
            // ...
            return 0;
        default: __debugbreak();
        }
    }

    __debugbreak();
    return GetLastError();
}

喜欢的代码while(!HasOverlappedIoCompleted(&overlapped)) Sleep(1);总是错误的。绝对的，永远的。永远不要写这样的代码。

ctx = (IO_Context *)overlapped;尽管在您的具体情况下，这会给出正确的结果，但如果您更改IO_Context. 你可以使用CONTAINING_RECORD(overlapped, IO_Context, overlapped)如果你使用struct IO_Context{ OVERLAPPED overlapped; }但更好地使用class IO_Context : public OVERLAPPED和static_cast<IO_Context*>(overlapped)

现在关于为什么 IOCP 选择这个事件？如何处理 IOCP 中的这种“坏”事件？

IOCP什么都没有选择。他只是在 I/O 完成时发出信号。全部。您在不同的网络操作上遇到的特定 wsa 错误绝对独立于使用 IOCP 或任何其他完成机制。

当错误代码为 0 且在 recv 操作中传输 0 字节时，正常断开连接是正常的。您需要在连接完成后永久激活接收请求，如果接收完成并传输 0 个字节，这意味着发生断开连接

c++ - 与浏览器通信时出现奇怪的 IOCP 行为

问题描述

解决方案

推荐阅读