重叠IO模型（之二）
三、编程步骤
1、创建一个套接字，开始在指定的端口上监听连接请求。
2、接收一个入站的连接请求。
3、为接受的套接字创建新的WSAOVERLAPPED结构，并分配事件对象句柄。
4、以WSAOVERLAPPED结构为参数，在套接字上投递WSARecv调用。
5、将所有接受套接字的事件组建事件数组，并调用WSAWaitForMultipleEvents函数，等待与重叠调用关联在一起的事件受信。
6、使用WSAGetOverlappedResult函数，判断重叠调用的返回状态。
7、重新组建事件数组。
8、在套接字上重投递WSARecv请求。
9、重复5～8。
例子：初步封装了OverLapped类
/*SockObject*/
#include <winsock2.h>
class SockObject
{
public:
SOCKET m_sock;
int m_operatNum;
public:
SockObject(void);
SockObject(SOCKET mySock);
SockObject(SockObject &mySockObject);
~SockObject(void);
};
SockObject::SockObject(SOCKET mySock)
{
m_sock = mySock;
m_operatNum = 0;
}
SockObject::SockObject(SockObject &mySockObject)
{
m_sock = mySockObject.m_sock;
m_operatNum = mySockObject.m_operatNum;
}
/******************************************************************************
*数据结构名称：OverObject
*功能：记录一个套接字的一个操作、一个事件和一个重叠I/O的关联
*****************************************************************************/
class OverObject
{
public:
SOCKET m_sock; /*绑定的套接字*/
OVERLAPPED m_overlapped; /*绑定的重叠I/O*/
char *m_buf; /*用于存放数据的缓冲区*/
int m_len; /*缓冲区的长度*/
int m_operation; /*套接字针对的操作*/
public:
bool operator==(const OverObject &myOverObject) const;
public:
OverObject(void);
OverObject(const OverObject &myOverObject);
OverObject(SOCKET mySock, int myLen);
~OverObject(void);
};
/*定义指向重叠对象的指针类型*/
typedef OverObject * PtrOverObject;
OverObject::~OverObject(void)
{
delete m_buf;
}
/********************************************************************************
* 函数介绍：本函数是OverObject类的复制构造函数。
*********************************************************************************/
OverObject::OverObject(const OverObject &myOverObject)
{
m_sock = myOverObject.m_sock;
m_overlapped = myOverObject.m_overlapped;
m_buf = new char[myOverObject.m_len];
strcpy(m_buf,myOverObject.m_buf);
m_len = myOverObject.m_len;
m_operation = myOverObject.m_operation;
}
/********************************************************************************
* 函数介绍：本函数是OverObject类带参数的构造函数。
*********************************************************************************/
OverObject::OverObject(SOCKET mySock, int myLen)
{
m_sock = mySock;
m_buf = new char[myLen];
m_len = myLen;
m_overlapped.hEvent = ::WSACreateEvent();
}
/********************************************************************************
* 函数介绍：本函数是OverObject类的＝＝运算符重载函数
*********************************************************************************/
bool OverObject::operator==(const OverObject &myOverObject) const
{
if(this->m_sock == myOverObject.m_sock && this->m_operation == myOverObject.m_operation && this->m_len == myOverObject.m_len && !strcmp(this->m_buf, myOverObject.m_buf))
{
cout << "the two overObject is eque !" << endl;
return true;
}
else
{
return false;
}
}
/******************************************************************************
*类名称：Overlapped
*功能：记录系统中需要维护的所有重叠I/O
*****************************************************************************/
#define OP_ACCEPT 1
#define OP_READ 2
#define OP_WRITE 3
class Overlapped
{
public:
list<OverObject> overObjects; /*需要维护的所有重叠I/O*/
vector<HANDLE> eventArray; /*所有重叠I/O所对应的事件组成的数组，作为等待函数的参数*/
vector<SockObject> sockArray; /*需要维护的所有套接字，当操作为零时关闭套接字*/
public:
list<OverObject>::iterator GetOverObject(SOCKET mySock, int myLen);
void FreeOverObject(list<OverObject>::iterator myPtrOverObject);
list<OverObject>::iterator Overlapped::FindOverObject(HANDLE myEvent);
void RebuildEventArray();
void CreateAcceptEvent();
void SetAcceptEvent();
void ResetAcceptEvent();
bool IsAcceptEvent(int index);
bool PostRecv(list<OverObject>::iterator myPtrOverObject);
bool PostSend(list<OverObject>::iterator myPtrOverObject);
bool PostAccept(list<OverObject>::iterator myPtrOverObject);
Overlapped(void);
~Overlapped(void);
void InitSocket();
};
/********************************************************************************
* 函数介绍：创建重叠对象的类对象，并插入重叠对象链表中。
*********************************************************************************/
list<OverObject>::iterator Overlapped::GetOverObject(SOCKET mySock, int myLen)
{
OverObject localOverObject(mySock, myLen);
overObjects.push_back(localOverObject);
eventArray.push_back(localOverObject.m_overlapped.hEvent);
list<OverObject>::iterator ret = overObjects.end();
ret--;
return ret;
}
/********************************************************************************
* 函数介绍：释放重叠对象链表中指定的重叠对象。
*********************************************************************************/
void Overlapped::FreeOverObject(list<OverObject>::iterator myPtrOverObject)
{
overObjects.erase(myPtrOverObject);
}
/********************************************************************************
* 函数介绍：从重叠对象列表中查找指定事件所对应的重叠对象。
*********************************************************************************/
list<OverObject>::iterator Overlapped::FindOverObject(HANDLE myEvent)
{
list<OverObject>::iterator localIerator;
for(localIerator = overObjects.begin(); localIerator != overObjects.end(); localIerator++)
{
if(localIerator->m_overlapped.hEvent == myEvent)
{
break;
}
}
return localIerator;
}
/********************************************************************************
* 函数介绍：遍历重叠对象列表，重建重叠对象列表所对应的事件数组。
*********************************************************************************/
void Overlapped::RebuildEventArray()
{
eventArray.clear();
list<OverObject>::iterator overObjIterator;
overObjIterator = overObjects.begin();
for(overObjIterator; overObjIterator != overObjects.end(); ++overObjIterator)
{
eventArray.push_back(overObjIterator->m_overlapped.hEvent);
}
}
/********************************************************************************
* 函数介绍：投放接受操作，即将指定套接字的Recv操作与重叠I/O对象关联起来。
*********************************************************************************/
bool Overlapped::PostRecv(list<OverObject>::iterator myPtrOverObject)
{
myPtrOverObject->m_operation = OP_READ;
DWORD dwBytes;
DWORD dwFlags = 0;
WSABUF buf;
buf.buf = myPtrOverObject->m_buf;
buf.len = myPtrOverObject->m_len;
memset(buf.buf, 0, buf.len);
if(::WSARecv(myPtrOverObject->m_sock, &buf, 1, &dwBytes, &dwFlags, &myPtrOverObject->m_overlapped,NULL)!=NO_ERROR)
{
if(::WSAGetLastError() != WSA_IO_PENDING)
{
return false;
}
}
return true;
}
/********************************************************************************
* 函数介绍：投放发送操作，即将指定套接字的Send操作与重叠I/O对象关联起来。
*********************************************************************************/
bool Overlapped::PostSend(list<OverObject>::iterator myPtrOverObject)
{
myPtrOverObject->m_operation = OP_WRITE;
DWORD dwBytes;
DWORD dwFlags = 0;
WSABUF buf;
buf.buf = myPtrOverObject->m_buf;
buf.len = myPtrOverObject->m_len;
if(::WSASend(myPtrOverObject->m_sock, &buf, 1, &dwBytes, dwFlags, &myPtrOverObject->m_overlapped,NULL)!=NO_ERROR)
{
if(::WSAGetLastError() != WSA_IO_PENDING)
{
return false;
}
}
return true;
}
/********************************************************************************
* 函数介绍：创建accept函数完成事件，用于处理accepe后等待函数的等待事件句柄数组发
生变化，若此时无事件触发，等待事件句柄数组仍以原来的事件句柄数组为依
据等待。
*********************************************************************************/
void Overlapped::CreateAcceptEvent()
{
//标志套接字，用于触发accept完成事件。
SOCKET myClient = ::WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
list<OverObject>::iterator acceptIterator = GetOverObject(myClient, 512);
RebuildEventArray();
}
/********************************************************************************
* 函数介绍：当accept函数完成时，重置accept所对应的事件，从而使得等待函数能够在改
变后的事件句柄数组上等待。
*********************************************************************************/
void Overlapped::SetAcceptEvent()
{
::SetEvent(eventArray.front());
}
void Overlapped::ResetAcceptEvent()
{
::ResetEvent(eventArray.front());
}
bool Overlapped::IsAcceptEvent(int index)
{
if(index == 0)
{
return true;
}
else
{
return false;
}
}
/*主程序*/
#include "Overlapped.h"
#include <windows.h>
#include <process.h>
bool OperateFunction(PtrOverObject myPtrOverObject);
UINT WINAPI ServerThread(PVOID pvParam);
Overlapped myOverlapped;
int main()
{
WSADATA wsaData;
if(WSAStartup(MAKEWORD(2,2),&wsaData)!=0)
{
cout<<"failed to load winsock !"<<endl;
exit(0);
}
SOCKET mylisten, myClient;
mylisten = ::WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
struct sockaddr_in localAddr, clientAddr;
localAddr.sin_family = AF_INET;
localAddr.sin_port = ntohs(5500);
localAddr.sin_addr.S_un.S_addr = inet_addr("59.73.161.221");
bind(mylisten, (sockaddr*)&localAddr, sizeof(localAddr));
listen(mylisten, 5);
int sizeAddr = sizeof(clientAddr);
cout << "server is listening......" << endl;
myOverlapped.CreateAcceptEvent();
int x;
_beginthreadex(NULL, 0, ServerThread, &x, 0, NULL);
/*循环接收客户端的连接，创建与客户端通信的重叠IO对象，并重建事件句柄数组*/
while(true)
{
myClient = accept(mylisten, (struct sockaddr*)&clientAddr, &sizeAddr);
if(myClient==INVALID_SOCKET)
{
cout<<"accept is failed !"<<endl;
return -1;
}
list<OverObject>::iterator localIterator = myOverlapped.GetOverObject(myClient, 512);
myOverlapped.PostRecv(localIterator);
myOverlapped.RebuildEventArray();
myOverlapped.SetAcceptEvent();
}
char ch;
cin >> ch;
return 0;
}
/********************************************************************************
* 函数介绍：数据处理函数，按照不同操作类型，处理数据的发送或接受。
*********************************************************************************/
bool OperateFunction(list<OverObject>::iterator myOverObjectIterator)
{
DWORD dwTrans;
DWORD dwFlags;
BOOL ret = ::WSAGetOverlappedResult(myOverObjectIterator->m_sock, &(myOverObjectIterator->m_overlapped), &dwTrans, false, &dwFlags);
if(!ret)
{
if(myOverObjectIterator->m_sock != INVALID_SOCKET)
{
closesocket(myOverObjectIterator->m_sock);
}
cout << "socket error : " << ::GetLastError() << endl;
myOverlapped.FreeOverObject(myOverObjectIterator);
myOverlapped.RebuildEventArray();
return false;
}
switch(myOverObjectIterator->m_operation)
{
case OP_READ: /*接收数据完成*/
if(dwTrans > 0)
{
cout << myOverObjectIterator->m_buf << endl;
list<OverObject>::iterator localIterator = myOverlapped.GetOverObject(myOverObjectIterator->m_sock, 512);
localIterator->m_len = myOverObjectIterator->m_len;
strcpy(localIterator->m_buf, myOverObjectIterator->m_buf);
myOverlapped.PostSend(localIterator);
myOverlapped.RebuildEventArray();
return true;
}
else
{
closesocket(myOverObjectIterator->m_sock);
myOverlapped.FreeOverObject(myOverObjectIterator);
myOverlapped.RebuildEventArray();
cout << "the client socket is close !" << endl;
return false;
}
break;
case OP_WRITE: /*发送数据完成*/
if(dwTrans > 0)
{
return true;
}
else
{
closesocket(myOverObjectIterator->m_sock);
myOverlapped.FreeOverObject(myOverObjectIterator);
myOverlapped.RebuildEventArray();
return false;
}
break;
}
}
/********************************************************************************
* 函数介绍：服务线程函数，平常处于等待状态，完成数据处理。
*********************************************************************************/
UINT WINAPI ServerThread(PVOID pvParam)
{
while(true)
{
int index;
DWORD eventNum = (DWORD)(myOverlapped.eventArray.size());
index = ::WSAWaitForMultipleEvents(eventNum, &(myOverlapped.eventArray[0]), false, WSA_INFINITE, false);
if(index == WSA_WAIT_FAILED)
{
cout << "wait error is : " << ::GetLastError() << endl;
break;
}
else
{
index = index - WSA_WAIT_EVENT_0;
if(myOverlapped.IsAcceptEvent(index))
{
myOverlapped.ResetAcceptEvent();
continue;
}
list<OverObject>::iterator nowIterator = (myOverlapped.FindOverObject(myOverlapped.eventArray[index]));
if(nowIterator != NULL)
{
bool ret = OperateFunction(nowIterator);
if(ret)
{
::WSAResetEvent(myOverlapped.eventArray[index]);
myOverlapped.PostRecv(nowIterator);
}
}
}
}
return 0;
}