在完成端口IOCP模型判断客户端是否已关闭连接(掉线)

判断客户端是否关闭：
  1   GetQueuedCompletionStatus 返回 FALSE，根据错误号判断。
  2   客户端端定时发送(也就是心跳包判断)
补:GetQueuedCompletionStatus 的返回值为 ERROR_SUCCESS 和lpNumberOfBytes 为0的时，客户端sockt关闭。在测试的时候，连接的客户端发生异常崩溃，强制关闭客户端后，GetQueuedCompletionStatus 的返回值并不为 ERROR_SUCCESS，不过 lpNumberOfBytes 为0。所以判断客户端是否关闭可以只判断 lpNumberOfBytes 的值是否为0。

完成端口类：

#pragma once

#include <winsock2.h>
#pragma comment( lib, "ws2_32.lib" )

const int OP_READ = 0;
const int OP_WRITE = 1;
const int OP_ACCEPT = 2;

struct OVERLAPPEDPLUS
{
OVERLAPPED ol;
SOCKET s;
int OpCode;
WSABUF wbuf;
DWORD dwBytes, dwFlags;
char buf[4096];
};

class CIOCP
{
protected:
HANDLE g_hwThread; // 工作线程句柄
DWORD  m_wthreadID;
HANDLE g_haThread; // 连接线程句柄
DWORD  m_athreadID;
public:
bool m_workThread;
bool m_acceptThread;
HANDLE m_hIocp; // 完成端口的句柄
SOCKET m_sSocket;

public:
CIOCP(void);
~CIOCP(void);
virtual void OnRead(void * p, char *buf, int len){};
virtual void OnAccept(SOCKET socket);
virtual void OnClose(void * p){};
bool SetIoCompletionPort(SOCKET socket, void *p);
bool Init(void);
bool Listen(char * ip, int port);
};


//  iocp.cpp
#include "iocp.h"

static bool bInit = false;

DWORD __stdcall WorkThread(LPVOID Param)
{
CIOCP * pthis = (CIOCP *)Param;

void * re;
OVERLAPPED * pOverlap;
DWORD berByte;
while(pthis->m_workThread)
{
int ret;
ret = GetQueuedCompletionStatus(pthis->m_hIocp, &berByte, (LPDWORD)&re, (LPOVERLAPPED *)&pOverlap, INFINITE);

if (ret == ERROR_SUCCESS)
{

}

if (berByte == 0)
{
// 客户端断开连接
pthis->OnClose(re);
OVERLAPPEDPLUS *olp = (OVERLAPPEDPLUS *)pOverlap;
closesocket(olp->s);
continue;
}

if (re == NULL) return 0;

OVERLAPPEDPLUS *olp = (OVERLAPPEDPLUS *)pOverlap;

switch(olp->OpCode)
{
case OP_READ:
pthis->OnRead(re, olp->wbuf.buf, berByte);
WSARecv(olp->s, &olp->wbuf, 1, &olp->dwBytes, &olp->dwFlags, &olp->ol, NULL);
break;
case OP_WRITE:
break;
case OP_ACCEPT:
break;
}
}
return 0;
}

DWORD __stdcall AcceptThread(LPVOID Param)
{
CIOCP * pthis = (CIOCP *)Param;
while(pthis->m_acceptThread)
{
SOCKET client;
if ((client= accept(pthis->m_sSocket, NULL, NULL)) == INVALID_SOCKET)
{
// 错误处理
}
pthis->OnAccept(client);

}
return 1;
}

CIOCP::CIOCP(void)
{
}

CIOCP::~CIOCP(void)
{
}

bool CIOCP::Init(void)
{
if (bInit)
return true;

WSADATA wsd;
if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)  
return false;  

bInit = true;
return true;
}

bool CIOCP::Listen(char * ip, int port)
{
m_sSocket = socket(AF_INET, SOCK_STREAM, 0);  

if (m_sSocket == INVALID_SOCKET)  
return false;  

SOCKADDR_IN addr;  
addr.sin_family = AF_INET;  
addr.sin_port = htons(port);  
addr.sin_addr.S_un.S_addr = inet_addr(ip);  

if (bind(m_sSocket, (struct sockaddr *)&addr, sizeof(addr)) == SOCKET_ERROR)  
return false;  

if (listen(m_sSocket, 10) == SOCKET_ERROR)  
return false;  

if ((m_hIocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, NULL, 0)) == NULL) // 创建完成端口的句柄
return false;

this->m_acceptThread = true;
g_haThread = CreateThread(NULL, 0, AcceptThread, (LPVOID)this, 0, &m_athreadID); // 创建连接线程，用来接收客户端的连接

this->m_workThread = true;
g_hwThread = CreateThread(NULL, 0, WorkThread, (LPVOID)this, 0, &m_wthreadID); // 创建工作线程，用来处理完成端口消息的
return true;
}

bool CIOCP::SetIoCompletionPort(SOCKET socket, void *p)
{
if (CreateIoCompletionPort((HANDLE)socket, m_hIocp, (ULONG_PTR)p, 0) == NULL)
return false;

OVERLAPPEDPLUS *olp = new OVERLAPPEDPLUS;
memset(olp, 0, sizeof(OVERLAPPEDPLUS));
olp->s = socket;
olp->wbuf.buf = olp->buf;
olp->wbuf.len = 4096;
olp->OpCode = OP_READ;
int ret = WSARecv(olp->s, &olp->wbuf, 1, &olp->dwBytes, &olp->dwFlags, &olp->ol, NULL);
if (ret == SOCKET_ERROR)
if (WSAGetLastError() != ERROR_IO_PENDING)
return false;
return true;
}

void CIOCP::OnAccept(SOCKET socket)
{
this->SetIoCompletionPort(socket, new OVERLAPPEDPLUS);
}