本项目的重点是IOCP，至于HTTP服务，暂时只实现了GET方法，在浏览器输入IP:端口，则返回hello字符串。后面有空继续实现HTTP协议的其它方法。
首先对于一个服务器，首先要解决以下几个问题：
- 如何检测有新客户端连接？
- 如何接受客户端连接？
- 如何检测客户端是否有数据发来？
- 如何收取客户端发来的数据？
- 如何检测连接异常？发现连接异常之后，如何处理？
- 如何给客户端发送数据？
- 如何在给客户端发完数据后关闭连接？
以上几个问题是一个大佬提出的。
对于IOCP，如何检测客户端连接，如何接受连接，如何收发数据不需要我们自己去做，因为IOCP会帮我们完成。
而我们需要做的是：
- 准备好缓冲区，创建好的socket，Per Io Data和Per Socket Data。
- 投递接受连接请求，投递接收数据请求，投递发送数据请求。以下我们用postAccept，postRecv，postSend表示。
- 收到数据后解析处理，将响应数据放到发送缓冲区，然后投递发送请求
1. 什么是Per Io Data？
Per Io Data代表每一次IO请求，一个IO请求需要一个Per Io Context，这里我用IoContext实现：
//为了保证以下结构体第一个变量成员是OVERLAPPED，不能使用虚函数（具有虚函数的类第一个变量是虚表指针）
struct IoContext
{
IoContext(PostType type);
~IoContext();
void resetBuffer();
OVERLAPPED m_overlapped; //每一个重叠io操作都要有一个OVERLAPPED结构
PostType m_postType;
WSABUF m_wsaBuf; //重叠io需要的buf
};
struct AcceptIoContext : public IoContext
{
AcceptIoContext(SOCKET acceptSocket = INVALID_SOCKET);
~AcceptIoContext();
void resetBuffer();
SOCKET m_acceptSocket; //接受连接的socket
BYTE m_accpetBuf[IO_BUF_SIZE]; //用于acceptEx接收数据
};
struct RecvIoContext : public IoContext
{
RecvIoContext();
~RecvIoContext();
void resetBuffer();
BYTE m_recvBuf[IO_BUF_SIZE];
};每个IoContext都得有一个OVERLAPPED结构。这里我根据IO请求的类型不同，子类化了IoContext。我将收发数据的缓冲区也放在这里。这里的缓冲区是对应于IOCP的操作的，而后面处理业务数据我则使用了Buffer类和Slice类。
2. 什么是Per Socket Data？
我们在调用CreateIoCompletionPort将socket和完成端口绑定的时候还要传一个CompletionKey，一般是传一个结构体的指针，该结构体是关于客户端的（socket）。
以下用ClientContext实现Per Socket Context：
struct IoContext;
struct RecvIoContext;
struct ClientContext
{
ClientContext(const SOCKET& socket = INVALID_SOCKET);
//socket由IocpServer释放
~ClientContext();
void reset();
void appendToBuffer(PBYTE pInBuf, size_t len);
void appendToBuffer(const std::string& inBuf);
SOCKET m_socket; //客户端socket
//SOCKADDR_IN m_addr; //客户端地址
Addr m_addr;
ULONG m_nPendingIoCnt; //Avoids Access Violation，该值为0时才能释放ClientContext
RecvIoContext* m_recvIoCtx;
IoContext* m_sendIoCtx;
Buffer m_inBuf;
Buffer m_outBuf;
std::queue<Buffer> m_outBufQueue;
CRITICAL_SECTION m_csLock; //保护ClientContext
DWORD m_nLastHeartbeatTime;
};3. 我们再来看看IOCP工作线程的：主要是根据IoContext::PostType的类型调用不同的方法、
unsigned WINAPI IocpServer::IocpWorkerThread(LPVOID arg)
{
IocpServer* pThis = static_cast<IocpServer*>(arg);
int ret;
DWORD dwBytesTransferred;
DWORD dwMilliSeconds = INFINITE;
ULONG_PTR lpCompletionKey;
LPOVERLAPPED lpOverlapped = nullptr;
while (WAIT_OBJECT_0 != WaitForSingleObject(pThis->m_hExitEvent, 0))
{
ret = GetQueuedCompletionStatus(pThis->m_hComPort, &dwBytesTransferred,
&lpCompletionKey, &lpOverlapped, dwMilliSeconds);
if (EXIT_THREAD == lpCompletionKey)
{
//退出工作线程
cout << "EXIT_THREAD" << endl;
break;
}
//shutdown状态则停止接受连接
if (pThis->m_bIsShutdown && lpCompletionKey == (ULONG_PTR)pThis)
{
continue;
}
if (lpCompletionKey != (ULONG_PTR)pThis)
{
//文档说超时的时候触发，INFINITE不会触发
//实际上curl命令行ctrl+c强制关闭连接也会触发
if (0 == ret)
{
cout << "GetQueuedCompletionStatus failed with error: " << WSAGetLastError() << endl;
pThis->handleClose(lpCompletionKey);
continue;
}
//对端关闭
if (0 == dwBytesTransferred)
{
pThis->handleClose(lpCompletionKey);
continue;
}
}
IoContext* pIoCtx = (IoContext*)lpOverlapped;
switch (pIoCtx->m_postType)
{
case PostType::ACCEPT_EVENT:
pThis->handleAccept(lpOverlapped, dwBytesTransferred);
break;
case PostType::RECV_EVENT:
pThis->handleRecv(lpCompletionKey, lpOverlapped, dwBytesTransferred);
break;
case PostType::SEND_EVENT:
pThis->handleSend(lpCompletionKey, lpOverlapped, dwBytesTransferred);
break;
case PostType::CLOSE_EVENT:
pThis->handleClose(lpCompletionKey);
break;
default:
break;
}
}
cout << "exit" << endl;
return 0;
}4. IOCP中可以使用acceptEx函数来接受连接。使用acceptEx的好处是不需要我们主动接受连接，我们准备好socket和接收缓冲区就可以了。postAccept方法投递了一个accept请求出去，我这里预先投递10个accept请求，有客户端连接的话IOCP会自动帮我们连接，然后会触发GetQueuedCompletionStatus函数返回，根据IoContext::PostType可以判断是连接请求处理完成，然后就会调用handleAccept方法。使用acceptEx的另一个好处就是可以在接受连接的同时接收用户发来的第一份数据以及对端和本地的地址。
postAccept函数：
bool IocpServer::postAccept(AcceptIoContext* pAcceptIoCtx)
{
pAcceptIoCtx->resetBuffer();
DWORD dwRecvByte;
//PCHAR pBuf = pAcceptIoCtx->m_wsaBuf.buf;
//ULONG nLen = pAcceptIoCtx->m_wsaBuf.len - ACCEPT_ADDRS_SIZE;
LPOVERLAPPED pOverlapped = &pAcceptIoCtx->m_overlapped;
LPFN_ACCEPTEX lpfnAcceptEx = (LPFN_ACCEPTEX)m_lpfnAcceptEx;
//创建用于接受连接的socket
pAcceptIoCtx->m_acceptSocket = Net::WSASocket_();
if (SOCKET_ERROR == pAcceptIoCtx->m_acceptSocket)
{
cout << "create socket failed" << endl;
return false;
}
/*
* 使用acceptEx的一个问题：
* 如果客户端连上却没发送数据，则acceptEx不会触发完成包，则浪费服务器资源
* 解决方法：为了防止恶意连接，accpetEx不接收用户数据，只接收地址（没办法，接口调用必须提供缓冲区）
*/
static BYTE addrBuf[DOUBLE_ACCEPT_ADDRS_SIZE];
if (FALSE == lpfnAcceptEx(m_pListenCtx->m_socket, pAcceptIoCtx->m_acceptSocket,
addrBuf, 0, ACCEPT_ADDRS_SIZE, ACCEPT_ADDRS_SIZE,
&dwRecvByte, pOverlapped))
{
if (WSA_IO_PENDING != WSAGetLastError())
{
cout << "acceptEx failed" << endl;
return false;
}
}
else
{
// Accept completed synchronously. We need to marshal the data received over to the
// worker thread ourselves...
}
return true;
}注意这里使用acceptEx有一个问题：如果客户端连上却没发送数据，则acceptEx不会触发完成包，则浪费服务器资源。
目前我还没找到更好的方法去解决，所以为了避免恶意连接，我在acceptEx调用时传的用户数据大小是0，表示不在accpet的时候接收用户数据，那么客户端一连接上就会马上触发handleAccept函数。
handleAccept函数：
bool IocpServer::handleAccept(LPOVERLAPPED lpOverlapped, DWORD dwBytesTransferred)
{
AcceptIoContext* pAcceptIoCtx = (AcceptIoContext*)lpOverlapped;
Net::updateAcceptContext(m_pListenCtx->m_socket, pAcceptIoCtx->m_acceptSocket);
//达到最大连接数则关闭新的socket
if (m_nConnClientCnt >= m_nMaxConnClientCnt)
{
closesocket(pAcceptIoCtx->m_acceptSocket);
pAcceptIoCtx->m_acceptSocket = INVALID_SOCKET;
postAccept(pAcceptIoCtx);
return true;
}
InterlockedIncrement(&m_nConnClientCnt);
//创建新的ClientContext，原来的IoContext要用来接收新的连接
//ClientContext刚创建，在此函数不需要加锁
ClientContext* pConnClient = allocateClientContext(pAcceptIoCtx->m_acceptSocket);
if (NULL == associateWithCompletionPort(pConnClient->m_socket, (ULONG_PTR)pConnClient))
{
return false;
}
enterIoLoop(pConnClient);
//投递一个新的accpet请求
postAccept(pAcceptIoCtx);
notifyNewConnection(pConnClient);
//将客户端加入连接列表
addClient(pConnClient);
//投递recv请求,这里invalid socket是否要关闭客户端？
PostResult result = postRecv(pConnClient);
if (PostResult::PostResultFailed == result || PostResult::PostResultInvalidSocket == result)
{
CloseClient(pConnClient);
releaseClientContext(pConnClient);
}
return true;
}接受完一个连接后我们要继续补充一个postAccept，这样postAccept的数量一直是10。这个postAccept的目的其实是为了解决大量的并发请求的，如果连接来了再分配socket等数据的话，肯定是效率不高的。这个就个内存池的道理一样。
5. 第一次接受连接最后我会投递一个recv请求，用来接收用户数据。
IOCP收完用户数据就会触发GetQueuedCompletionStatus返回，然后调用handleRecv函数。
handleRecv实现：
bool IocpServer::handleRecv(ULONG_PTR lpCompletionKey, LPOVERLAPPED lpOverlapped, DWORD dwBytesTransferred)
{
ClientContext* pConnClient = (ClientContext*)lpCompletionKey;
RecvIoContext* pRecvIoCtx = (RecvIoContext*)lpOverlapped;
pConnClient->appendToBuffer(pRecvIoCtx->m_recvBuf, dwBytesTransferred);
notifyPackageReceived(pConnClient);
//投递recv请求
PostResult result = postRecv(pConnClient);
if (PostResult::PostResultFailed == result || PostResult::PostResultInvalidSocket == result)
{
CloseClient(pConnClient);
releaseClientContext(pConnClient);
}
return true;
}先将IOCP接收缓冲区的数据存到Buffer类中，然后调用回调函数notifyPackageReceived。该回调函数的默认实现是echo，而我的HttpServer是IocpServer的子类，重写了该函数，在该函数中对HTTP协议进行了解析，解析成功则发送HTTP响应消息给客户端。
这里我们知道IocpServer类是用来实现IOCP细节的，可看成网络层，而HttpServer类用来处理HTTP消息，可看成应用层。应用层不关心网络层细节是怎么实现的，IocpServer类只需要提供几个虚函数给子类重写，例如：
virtual void notifyNewConnection(ClientContext* pConnClient);
//virtual void notifyDisconnected(ClientContext* pConnClient);
virtual void notifyDisconnected(SOCKET s, Addr addr);
virtual void notifyPackageReceived(ClientContext* pConnClient);
virtual void notifyWritePackage();
virtual void notifyWriteCompleted();6. 发送数据我封装了个异步的接口send，ClientContext有一个发送数据队列std::queue<Buffer> m_outBufQueue，send会将数据投入到队列中。由postSend触发数据的发送，在handleSend判断数据是否发完，没发完继续投递postSend，发完则从队列中取下一份数据发送，如此反复直到发完。
7. 为什么需要异步的发送接口？
我个人的理解是：1.保证发送缓冲区的线程安全；2.用户调用send请求是异步的，例如某个可控制的服务端，用户操作会触发send请求，当然对于HTTP服务器不存在这个情况，因为HTTP服务器是响应式 的。
总结：
对于IOCP服务器的实现大概是这些，关键还是细节的处理。目前我的IOCP服务器只是一个pending send和一个pending recv。如果是多个pending IO的话还要考虑数据乱序和脏读等问题。所以要实现一个高性能的IOCP服务器还是不容易的。
另一方面就是HTTP协议的解析了，这个挺麻烦的，主要是字符串的处理，和各种功能的实现和扩展。
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
