Winsock IO模型之Overlapped模型

    这个模型的基本思想是使用重叠数据结构一次投递一个或多个异步I/O请求。当提交的I/O请求完成之后，与之关联的重叠数据结构中的事件对象受信，应用程序便可使用WSAGetOverlappedResult函数获取重叠操作结果。这个和使用重叠结构调用ReadFile和WriteFile函数操作文件类似。

    使用这个模型，必须要搞清楚以下这几个异步I/O函数：WSASocket，AcceptEx，WSASend（UDP的：WSASendTo），WSARecv（UDP的：WSARecvFrom），WSAGetOverlappedResult，最关键的还需要知道WSAOVERLAPPED在这些异步IO调用中所起的作用（其实是通过事件），以及WSABUF（WSASend/WSARecv类似函数中需要填入的一个重要参数，在投递完后未受信之前这块buffer将被system锁定）结构体和OVERLAPPED（比WSAOVERLAPPED看起来更通用，但其本质是一样的，WSAOVERLAPPED名称看起来多了WSA）结构体，最后需要与那些通用的I/O函数（如recv，send等）进行对比才能理解得更深。

    以下是从《Windows网络与通信程序设计》中摘出来的几条注意点：

    以下是这本书上给出的一个tcp回显的实例：

///////////////////////////////////////////////////////
// OverlappedServer.cpp文件

#include "../common/initsock.h"

#include <Mswsock.h>
#include <stdio.h>
#include <windows.h>

CInitSock theSock;

#define BUFFER_SIZE 1024

typedef struct _SOCKET_OBJ
{
SOCKET s;// 套节字句柄
int nOutstandingOps;// 记录此套节字上的重叠I/O数量

LPFN_ACCEPTEX lpfnAcceptEx;// 扩展函数AcceptEx的指针（仅对监听套节字而言）
} SOCKET_OBJ, *PSOCKET_OBJ;

typedef struct _BUFFER_OBJ
{
OVERLAPPED ol;// 重叠结构
char *buff;// send/recv/AcceptEx所使用的缓冲区
int nLen;// buff的长度
PSOCKET_OBJ pSocket;// 此I/O所属的套节字对象

int nOperation;// 提交的操作类型
#define OP_ACCEPT1
#define OP_READ2
#define OP_WRITE3

SOCKET sAccept;// 用来保存AcceptEx接受的客户套节字（仅对监听套节字而言）
_BUFFER_OBJ *pNext;
} BUFFER_OBJ, *PBUFFER_OBJ;

HANDLE g_events[WSA_MAXIMUM_WAIT_EVENTS];// I/O事件句柄数组
int g_nBufferCount;// 上数组中有效句柄数量
PBUFFER_OBJ g_pBufferHead, g_pBufferTail;// 记录缓冲区对象组成的表的地址

// 申请套节字对象和释放套节字对象的函数
PSOCKET_OBJ GetSocketObj(SOCKET s)
{
PSOCKET_OBJ pSocket = (PSOCKET_OBJ)::GlobalAlloc(GPTR, sizeof(SOCKET_OBJ));
if(pSocket != NULL)
{
pSocket->s = s;
}
return pSocket;
}
void FreeSocketObj(PSOCKET_OBJ pSocket)
{
if(pSocket->s != INVALID_SOCKET)
::closesocket(pSocket->s);
::GlobalFree(pSocket);
}

PBUFFER_OBJ GetBufferObj(PSOCKET_OBJ pSocket, ULONG nLen)
{
if(g_nBufferCount > WSA_MAXIMUM_WAIT_EVENTS - 1)
return NULL;

PBUFFER_OBJ pBuffer = (PBUFFER_OBJ)::GlobalAlloc(GPTR, sizeof(BUFFER_OBJ));
if(pBuffer != NULL)
{
pBuffer->buff = (char*)::GlobalAlloc(GPTR, nLen);
pBuffer->ol.hEvent = ::WSACreateEvent();
pBuffer->pSocket = pSocket;
pBuffer->sAccept = INVALID_SOCKET;

// 将新的BUFFER_OBJ添加到列表中
if(g_pBufferHead == NULL)
{
g_pBufferHead = g_pBufferTail = pBuffer;
}
else
{
g_pBufferTail->pNext = pBuffer;
g_pBufferTail = pBuffer;
}
g_events[++ g_nBufferCount] = pBuffer->ol.hEvent;
}
return pBuffer;
}

void FreeBufferObj(PBUFFER_OBJ pBuffer)
{
// 从列表中移除BUFFER_OBJ对象
PBUFFER_OBJ pTest = g_pBufferHead;
BOOL bFind = FALSE;
if(pTest == pBuffer)
{
g_pBufferHead = g_pBufferTail = NULL;
bFind = TRUE;
}
else
{
while(pTest != NULL && pTest->pNext != pBuffer)
pTest = pTest->pNext;
if(pTest != NULL)
{
pTest->pNext = pBuffer->pNext;
if(pTest->pNext == NULL)
g_pBufferTail = pTest;
bFind = TRUE;
}
}
// 释放它占用的内存空间
if(bFind)
{
g_nBufferCount --;
::CloseHandle(pBuffer->ol.hEvent);
::GlobalFree(pBuffer->buff);
::GlobalFree(pBuffer);
}
}

PBUFFER_OBJ FindBufferObj(HANDLE hEvent)
{
PBUFFER_OBJ pBuffer = g_pBufferHead;
while(pBuffer != NULL)
{
if(pBuffer->ol.hEvent == hEvent)
break;
pBuffer = pBuffer->pNext;
}
return pBuffer;
}

void RebuildArray()
{
PBUFFER_OBJ pBuffer = g_pBufferHead;
int i =  1;
while(pBuffer != NULL)
{
g_events[i++] = pBuffer->ol.hEvent;
pBuffer = pBuffer->pNext;
}
}

BOOL PostAccept(PBUFFER_OBJ pBuffer)
{
PSOCKET_OBJ pSocket = pBuffer->pSocket;
if(pSocket->lpfnAcceptEx != NULL)
{
// 设置I/O类型，增加套节字上的重叠I/O计数
pBuffer->nOperation = OP_ACCEPT;
pSocket->nOutstandingOps ++;

// 投递此重叠I/O  
DWORD dwBytes;
pBuffer->sAccept = 
::WSASocket(AF_INET, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED);
BOOL b = pSocket->lpfnAcceptEx(pSocket->s, 
pBuffer->sAccept,
pBuffer->buff, 
BUFFER_SIZE - ((sizeof(sockaddr_in) + 16) * 2),
sizeof(sockaddr_in) + 16, 
sizeof(sockaddr_in) + 16, 
&dwBytes, 
&pBuffer->ol);
if(!b)
{
if(::WSAGetLastError() != WSA_IO_PENDING)
return FALSE;
}
return TRUE;
}
return FALSE;
};

BOOL PostRecv(PBUFFER_OBJ pBuffer)
{
// 设置I/O类型，增加套节字上的重叠I/O计数
pBuffer->nOperation = OP_READ;
pBuffer->pSocket->nOutstandingOps ++;

// 投递此重叠I/O
DWORD dwBytes;
DWORD dwFlags = 0;
WSABUF buf;
buf.buf = pBuffer->buff;
buf.len = pBuffer->nLen;
if(::WSARecv(pBuffer->pSocket->s, &buf, 1, &dwBytes, &dwFlags, &pBuffer->ol, NULL) != NO_ERROR)
{
if(::WSAGetLastError() != WSA_IO_PENDING)
return FALSE;
}
return TRUE;
}

BOOL PostSend(PBUFFER_OBJ pBuffer)
{
// 设置I/O类型，增加套节字上的重叠I/O计数
pBuffer->nOperation = OP_WRITE;
pBuffer->pSocket->nOutstandingOps ++;

// 投递此重叠I/O
DWORD dwBytes;
DWORD dwFlags = 0;
WSABUF buf;
buf.buf = pBuffer->buff;
buf.len = pBuffer->nLen;
if(::WSASend(pBuffer->pSocket->s, 
&buf, 1, &dwBytes, dwFlags, &pBuffer->ol, NULL) != NO_ERROR)
{
if(::WSAGetLastError() != WSA_IO_PENDING)
return FALSE;
}
return TRUE;
}

BOOL HandleIO(PBUFFER_OBJ pBuffer)
{
PSOCKET_OBJ pSocket = pBuffer->pSocket; // 从BUFFER_OBJ对象中提取SOCKET_OBJ对象指针，为的是方便引用
pSocket->nOutstandingOps --;

// 获取重叠操作结果
DWORD dwTrans;
DWORD dwFlags;
BOOL bRet = ::WSAGetOverlappedResult(pSocket->s, &pBuffer->ol, &dwTrans, FALSE, &dwFlags);
if(!bRet)
{
// 在此套节字上有错误发生，因此，关闭套节字，移除此缓冲区对象。
// 如果没有其它抛出的I/O请求了，释放此缓冲区对象，否则，等待此套节字上的其它I/O也完成
if(pSocket->s != INVALID_SOCKET)
{
::closesocket(pSocket->s);
pSocket->s = INVALID_SOCKET;
}

if(pSocket->nOutstandingOps == 0)
FreeSocketObj(pSocket);

FreeBufferObj(pBuffer);
return FALSE;
}

// 没有错误发生，处理已完成的I/O
switch(pBuffer->nOperation)
{
case OP_ACCEPT:// 接收到一个新的连接，并接收到了对方发来的第一个封包
{
// 为新客户创建一个SOCKET_OBJ对象
PSOCKET_OBJ pClient = GetSocketObj(pBuffer->sAccept);

// 为发送数据创建一个BUFFER_OBJ对象，这个对象会在套节字出错或者关闭时释放
PBUFFER_OBJ pSend = GetBufferObj(pClient, BUFFER_SIZE);
if(pSend == NULL)
{
printf(" Too much connections! \n");
FreeSocketObj(pClient);
return FALSE;
}
RebuildArray();

// 将数据复制到发送缓冲区
pSend->nLen = dwTrans;
memcpy(pSend->buff, pBuffer->buff, dwTrans);

// 投递此发送I/O（将数据回显给客户）
if(!PostSend(pSend))
{
// 万一出错的话，释放上面刚申请的两个对象
FreeSocketObj(pSocket);
FreeBufferObj(pSend);
return FALSE;
}
// 继续投递接受I/O
PostAccept(pBuffer);
}
break;
case OP_READ:// 接收数据完成
{
if(dwTrans > 0)
{
// 创建一个缓冲区，以发送数据。这里就使用原来的缓冲区
PBUFFER_OBJ pSend = pBuffer;
pSend->nLen = dwTrans;

// 投递发送I/O（将数据回显给客户）
PostSend(pSend);
}
else// 套节字关闭
{

// 必须先关闭套节字，以便在此套节字上投递的其它I/O也返回
if(pSocket->s != INVALID_SOCKET)
{
::closesocket(pSocket->s);
pSocket->s = INVALID_SOCKET;
}

if(pSocket->nOutstandingOps == 0)
FreeSocketObj(pSocket);

FreeBufferObj(pBuffer);
return FALSE;
}
}
break;
case OP_WRITE:// 发送数据完成
{
if(dwTrans > 0)
{
// 继续使用这个缓冲区投递接收数据的请求
pBuffer->nLen = BUFFER_SIZE;
PostRecv(pBuffer);
}
else// 套节字关闭
{
// 同样，要先关闭套节字
if(pSocket->s != INVALID_SOCKET)
{
::closesocket(pSocket->s);
pSocket->s = INVALID_SOCKET;
}

if(pSocket->nOutstandingOps == 0)
FreeSocketObj(pSocket);

FreeBufferObj(pBuffer);
return FALSE;
}
}
break;
}
return TRUE;
}


void main()
{
// 创建监听套节字，绑定到本地端口，进入监听模式
int nPort = 4567;
SOCKET sListen = 
::WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
SOCKADDR_IN si;
si.sin_family = AF_INET;
si.sin_port = ::ntohs(nPort);
si.sin_addr.S_un.S_addr = INADDR_ANY;
::bind(sListen, (sockaddr*)&si, sizeof(si));
::listen(sListen, 200);

// 为监听套节字创建一个SOCKET_OBJ对象
PSOCKET_OBJ pListen = GetSocketObj(sListen);

// 加载扩展函数AcceptEx
GUID GuidAcceptEx = WSAID_ACCEPTEX;
DWORD dwBytes;
WSAIoctl(pListen->s, 
SIO_GET_EXTENSION_FUNCTION_POINTER, 
&GuidAcceptEx, 
sizeof(GuidAcceptEx),
&pListen->lpfnAcceptEx, 
sizeof(pListen->lpfnAcceptEx), 
&dwBytes, 
NULL, 
NULL);

// 创建用来重新建立g_events数组的事件对象
g_events[0] = ::WSACreateEvent();

// 在此可以投递多个接受I/O请求
for(int i=0; i<5; i++)
{
PostAccept(GetBufferObj(pListen, BUFFER_SIZE));
}
::WSASetEvent(g_events[0]);

while(TRUE)
{
int nIndex = 
::WSAWaitForMultipleEvents(g_nBufferCount + 1, g_events, FALSE, WSA_INFINITE, FALSE);
if(nIndex == WSA_WAIT_FAILED)
{
printf("WSAWaitForMultipleEvents() failed \n");
break;
}
nIndex = nIndex - WSA_WAIT_EVENT_0;
for(int i=0; i<=nIndex; i++) // 这里我认为应该改为：for(int i = nIndex; i <= g_nBufferCount; i++)
{
int nRet = ::WSAWaitForMultipleEvents(1, &g_events[i], TRUE, 0, FALSE);
if(nRet == WSA_WAIT_TIMEOUT)
continue;
else
{
::WSAResetEvent(g_events[i]);
// 重新建立g_events数组
if(i == 0)
{
RebuildArray();
continue;
}

// 处理这个I/O
PBUFFER_OBJ pBuffer = FindBufferObj(g_events[i]);
if(pBuffer != NULL)
{
if(!HandleIO(pBuffer))
RebuildArray();
}
}
}
}
}

参考：王艳平 张越 《Windows网络与通信程序设计》

转载请注明！