完成端口封装(修复Windows 网络与通信程序设计 可伸缩IOCP模型的bug)

最新推荐文章于 2022-01-04 11:19:39 发布
最新推荐文章于 2022-01-04 11:19:39 发布
阅读量1.8k 收藏 2
点赞数
分类专栏： vc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gotosola/article/details/52326527
版权

前言

看过《Windows网络与通信程序设计》的人都知道，里面有一段有关于IOCP的经典封装。大大方便了“伸手党”服务器端程序的开发（我也是其中之一)。但是应用到实际程序中你会发现经常出现一个莫名奇妙的问题：一旦客户端发送的字节数过多，服务器端接受其中几条后就“死掉”了，我也深受其害，于是乎 今天花了2小时时间通读了代码，把其中的bug找到（PS:不敢保证是否还是其他bug，暂时还未发现）


问题

引起上述现象的是由于作者的小疏忽导致的，我们知道采用完成端口时要开辟多个线程（一般为CPU核心数）来监听请求，如果客户端在短时间内发送了一大堆字节，
这些字节在客户端上肯定是分多次顺序进行发送。服务端接受的时候却是多个线程（单线程CPU例外）各自接受各自的原来的顺序就被打乱了，如果只是简单拼凑起来肯定会出现问题，如何解决这个问题呢，作者已经帮我想好了。虽然各个线程处理数据的顺序可能不一直，但是投递读请求的顺序肯定是与客户端发送的顺序是一直的，于是作者CIOCPBuffer中添加了一个顺序标识 nSequenceNumber 用来标识当前读取数据的发送顺序，并建立了一个队列将当前接受CIOCPBuffer联系起来。 
   
   
  1. // 这是per-I/O数据。它包含了在套节字上处理I/O操作的必要信息
  2. struct CIOCPBuffer
  3. {
  4. 	WSAOVERLAPPED ol;
  6. 	SOCKET sClient;			// AcceptEx接收的客户方套节字
  8. 	char *buff;				// I/O操作使用的缓冲区
  9. 	int nLen;				// buff缓冲区（使用的）大小
  11. 	ULONG nSequenceNumber;	// 此I/O的序列号
  13. 	int nOperation;			// 操作类型
  14. #define OP_ACCEPT	1
  15. #define OP_WRITE	2
  16. #define OP_READ		3
  18. 	CIOCPBuffer *pNext;
  19. };

读取数据的时候先判断读取数据CIOCPBuffer的nSequenceNumber与当前队列头的CIOCPBuffer是否一致，一致则循环将队列中的所有Buffer按顺序传递给用户，不一致就将它按顺序加入队列。
这种设计是不是很巧妙。


作者的代码： 
   
   
  1. CIOCPBuffer *CIOCPServer::GetNextReadBuffer(CIOCPContext *pContext, CIOCPBuffer *pBuffer)
  2. {
  3. 	if(pBuffer != NULL)
  4. 	{
  5. 		// 如果与要读的下一个序列号相等，则读这块缓冲区
  6. 		if(pBuffer->nSequenceNumber == pContext->nCurrentReadSequence)
  7. 		{
  8. 			return pBuffer;
  9. 		}
  10. 		
  11. 		// 如果不相等，则说明没有按顺序接收数据，将这块缓冲区保存到连接的pOutOfOrderReads列表中
  13. 		// 列表中的缓冲区是按照其序列号从小到大的顺序排列的
  15. 		pBuffer->pNext = NULL;
  16. 		
  17. 		CIOCPBuffer *ptr = pContext->pOutOfOrderReads;
  18. 		CIOCPBuffer *pPre = NULL;
  19. 		while(ptr != NULL)
  20. 		{
  21. 			if(pBuffer->nSequenceNumber < ptr->nSequenceNumber)
  22. 				break;
  23. 			
  24. 			pPre = ptr;
  25. 			ptr = ptr->pNext;
  26. 		}
  27. 		
  28. 		if(pPre == NULL) // 应该插入到表头
  29. 		{
  30. 			pBuffer->pNext = pContext->pOutOfOrderReads;
  31. 			pContext->pOutOfOrderReads = pBuffer;
  32. 		}
  33. 		else			// 应该插入到表的中间
  34. 		{
  35. 			pBuffer->pNext = pPre->pNext;
  36. 			pPre->pNext = pBuffer->pNext;
  37. 		}
  38. 	}
  40. 	// 检查表头元素的序列号，如果与要读的序列号一致，就将它从表中移除，返回给用户
  41. 	CIOCPBuffer *ptr = pContext->pOutOfOrderReads;
  42. 	if(ptr != NULL && (ptr->nSequenceNumber == pContext->nCurrentReadSequence))
  43. 	{
  44. 		pContext->pOutOfOrderReads = ptr->pNext;
  45. 		return ptr;
  46. 	}
  47. 	return NULL;
  48. }

我处理后的代码 
  
  
  1. CIOCPBuffer *CIOCPServer::GetNextReadBuffer(CIOCPContext *pContext, CIOCPBuffer *pBuffer)
  2. {
  3. 	if(pBuffer != NULL)
  4. 	{
  5. 		// 如果与要读的下一个序列号相等，则读这块缓冲区
  6. 		if(pBuffer->nSequenceNumber == pContext->nCurrentReadSequence)
  7. 		{
  8. 			return pBuffer;
  9. 		}
  10. 		
  11. 		// 如果不相等，则说明没有按顺序接收数据，将这块缓冲区保存到连接的pOutOfOrderReads列表中
  13. 		// 列表中的缓冲区是按照其序列号从小到大的顺序排列的
  15. 		pBuffer->pNext = NULL;
  16. 		
  17. 		CIOCPBuffer *ptr = pContext->pOutOfOrderReads;
  18. 		CIOCPBuffer *pPre = NULL;
  19. 		while(ptr != NULL)
  20. 		{
  21. 			if(pBuffer->nSequenceNumber < ptr->nSequenceNumber)
  22. 				break;
  23. 			
  24. 			pPre = ptr;
  25. 			ptr = ptr->pNext;
  26. 		}
  27. 		
  28. 		if(pPre == NULL) // 应该插入到表头
  29. 		{
  30. 			pBuffer->pNext = pContext->pOutOfOrderReads;
  31. 			pContext->pOutOfOrderReads = pBuffer;
  32. 		}
  33. 		else			// 应该插入到表的中间
  34. 		{
  35. 			pBuffer->pNext = pPre->pNext;
  36. 			pPre->pNext = pBuffer;
  37. 		}
  38. 	}
  40. 	// 检查表头元素的序列号，如果与要读的序列号一致，就将它从表中移除，返回给用户
  41. 	CIOCPBuffer *ptr = pContext->pOutOfOrderReads;
  42. 	if(ptr != NULL && (ptr->nSequenceNumber == pContext->nCurrentReadSequence))
  43. 	{
  44. 		pContext->pOutOfOrderReads = ptr->pNext;
  45. 		return ptr;
  46. 	}
  47. 	return NULL;
  48. }

对，你没有看错，仅仅是这么简单一句代码，就造成了整个程序的错误。 看不懂的同学自己去看看如何向链表中见插入一个元素吧。

废话不多说上一段完整程序： 
   
   
  2. // IOCP.h文件
  4. #ifndef __IOCP_H__
  5. #define __IOCP_H__
  7. #include <winsock2.h>
  8. #include <windows.h>
  9. #include <Mswsock.h>
  11. #define BUFFER_SIZE 1024*2		// I/O请求的缓冲区大小
  14. // 这是per-I/O数据。它包含了在套节字上处理I/O操作的必要信息
  15. struct CIOCPBuffer
  16. {
  17. 	WSAOVERLAPPED ol;
  19. 	SOCKET sClient;			// AcceptEx接收的客户方套节字
  21. 	char *buff;				// I/O操作使用的缓冲区
  22. 	int nLen;				// buff缓冲区（使用的）大小
  24. 	ULONG nSequenceNumber;	// 此I/O的序列号
  26. 	int nOperation;			// 操作类型
  27. #define OP_ACCEPT	1
  28. #define OP_WRITE	2
  29. #define OP_READ		3
  31. 	CIOCPBuffer *pNext;
  32. };
  34. // 这是per-Handle数据。它包含了一个套节字的信息
  35. struct CIOCPContext
  36. {
  37. 	SOCKET s;						// 套节字句柄
  39. 	SOCKADDR_IN addrLocal;			// 连接的本地地址
  40. 	SOCKADDR_IN addrRemote;			// 连接的远程地址
  42. 	BOOL bClosing;					// 套节字是否关闭
  44. 	int nOutstandingRecv;			// 此套节字上抛出的重叠操作的数量
  45. 	int nOutstandingSend;
  48. 	ULONG nReadSequence;			// 安排给接收的下一个序列号
  49. 	ULONG nCurrentReadSequence;		// 当前要读的序列号
  50. 	CIOCPBuffer *pOutOfOrderReads;	// 记录没有按顺序完成的读I/O
  52. 	CRITICAL_SECTION Lock;			// 保护这个结构
  54. 	CIOCPContext *pNext;
  55. };
  58. class CIOCPServer   // 处理线程
  59. {
  60. public:
  61. 	CIOCPServer();
  62. 	~CIOCPServer();
  64. 	// 开始服务
  65. 	BOOL Start(int nPort = 4567, int nMaxConnections = 2000, 
  66. 			int nMaxFreeBuffers = 200, int nMaxFreeContexts = 100, int nInitialReads = 4);
  67. 	// 停止服务
  68. 	void Shutdown();
  70. 	// 关闭一个连接和关闭所有连接
  71. 	void CloseAConnection(CIOCPContext *pContext);
  72. 	void CloseAllConnections();	
  74. 	// 取得当前的连接数量
  75. 	ULONG GetCurrentConnection() { return m_nCurrentConnection; }
  77. 	// 向指定客户发送文本
  78. 	BOOL SendText(CIOCPContext *pContext, char *pszText, int nLen); 
  80. 	// 获得本机处理器的数量
  81. 	static int _GetNoOfProcessors();
  83. protected:
  85. 	// 申请和释放缓冲区对象
  86. 	CIOCPBuffer *AllocateBuffer(int nLen);
  87. 	void ReleaseBuffer(CIOCPBuffer *pBuffer);
  89. 	// 申请和释放套节字上下文
  90. 	CIOCPContext *AllocateContext(SOCKET s);
  91. 	void ReleaseContext(CIOCPContext *pContext);
  93. 	// 释放空闲缓冲区对象列表和空闲上下文对象列表
  94. 	void FreeBuffers();
  95. 	void FreeContexts();
  97. 	// 向连接列表中添加一个连接
  98. 	BOOL AddAConnection(CIOCPContext *pContext);
  100. 	// 插入和移除未决的接受请求
  101. 	BOOL InsertPendingAccept(CIOCPBuffer *pBuffer);
  102. 	BOOL RemovePendingAccept(CIOCPBuffer *pBuffer);
  104. 	// 取得下一个要读取的
  105. 	CIOCPBuffer *GetNextReadBuffer(CIOCPContext *pContext, CIOCPBuffer *pBuffer);
  108. 	// 投递接受I/O、发送I/O、接收I/O
  109. 	BOOL PostAccept(CIOCPBuffer *pBuffer);
  110. 	BOOL PostSend(CIOCPContext *pContext, CIOCPBuffer *pBuffer);
  111. 	BOOL PostRecv(CIOCPContext *pContext, CIOCPBuffer *pBuffer);
  113. 	void HandleIO(DWORD dwKey, CIOCPBuffer *pBuffer, DWORD dwTrans, int nError);
  116. 		// 事件通知函数
  117. 	// 建立了一个新的连接
  118. 	virtual void OnConnectionEstablished(CIOCPContext *pContext, CIOCPBuffer *pBuffer);
  119. 	// 一个连接关闭
  120. 	virtual void OnConnectionClosing(CIOCPContext *pContext, CIOCPBuffer *pBuffer);
  121. 	// 在一个连接上发生了错误
  122. 	virtual void OnConnectionError(CIOCPContext *pContext, CIOCPBuffer *pBuffer, int nError);
  123. 	// 一个连接上的读操作完成
  124. 	virtual void OnReadCompleted(CIOCPContext *pContext, CIOCPBuffer *pBuffer);
  125. 	// 一个连接上的写操作完成
  126. 	virtual void OnWriteCompleted(CIOCPContext *pContext, CIOCPBuffer *pBuffer);
  128. protected:
  130. 	// 记录空闲结构信息
  131. 	CIOCPBuffer *m_pFreeBufferList;
  132. 	CIOCPContext *m_pFreeContextList;
  133. 	int m_nFreeBufferCount;
  134. 	int m_nFreeContextCount;	
  135. 	CRITICAL_SECTION m_FreeBufferListLock;
  136. 	CRITICAL_SECTION m_FreeContextListLock;
  138. 	// 记录抛出的Accept请求
  139. 	CIOCPBuffer *m_pPendingAccepts;   // 抛出请求列表。
  140. 	long m_nPendingAcceptCount;
  141. 	CRITICAL_SECTION m_PendingAcceptsLock;
  143. 	// 记录连接列表
  144. 	CIOCPContext *m_pConnectionList;
  145. 	int m_nCurrentConnection;
  146. 	CRITICAL_SECTION m_ConnectionListLock;
  148. 	// 用于投递Accept请求
  149. 	HANDLE m_hAcceptEvent;
  150. 	HANDLE m_hRepostEvent;
  151. 	LONG m_nRepostCount;
  153. 	int	m_nThread;
  154. 	int m_nPort;				// 服务器监听的端口
  156. 	int m_nInitialAccepts;
  157. 	int m_nInitialReads;
  158. 	int m_nMaxAccepts;
  159. 	int m_nMaxSends;
  160. 	int m_nMaxFreeBuffers;
  161. 	int m_nMaxFreeContexts;
  162. 	int m_nMaxConnections;
  164. 	HANDLE m_hListenThread;			// 监听线程
  165. 	HANDLE m_hCompletion;			// 完成端口句柄
  166. 	SOCKET m_sListen;				// 监听套节字句柄
  167. 	LPFN_ACCEPTEX m_lpfnAcceptEx;	// AcceptEx函数地址
  168. 	LPFN_GETACCEPTEXSOCKADDRS m_lpfnGetAcceptExSockaddrs; // GetAcceptExSockaddrs函数地址
  170. 	BOOL m_bShutDown;		// 用于通知监听线程退出
  171. 	BOOL m_bServerStarted;	// 记录服务是否启动
  173. 	HANDLE		m_hMutex;
  175. private:	// 线程函数
  176. 	static DWORD WINAPI _ListenThreadProc(LPVOID lpParam);
  177. 	static DWORD WINAPI _WorkerThreadProc(LPVOID lpParam);
  178. };
  181. #endif // __IOCP_H__

   
   
  1. //
  2. // IOCP.cpp文件
  3. #include "StdAfx.h"
  4. #include "iocp.h"
  5. #pragma comment(lib, "WS2_32.lib")
  6. #include <stdio.h>
  7. CIOCPServer::CIOCPServer()
  8. {
  9. 	// 列表
  10. 	m_pFreeBufferList = NULL;
  11. 	m_pFreeContextList = NULL;	
  12. 	m_pPendingAccepts = NULL;
  13. 	m_pConnectionList = NULL;
  15. 	m_nFreeBufferCount = 0;
  16. 	m_nFreeContextCount = 0;
  17. 	m_nPendingAcceptCount = 0;
  18. 	m_nCurrentConnection = 0;
  20. 	::InitializeCriticalSection(&m_FreeBufferListLock);
  21. 	::InitializeCriticalSection(&m_FreeContextListLock);
  22. 	::InitializeCriticalSection(&m_PendingAcceptsLock);
  23. 	::InitializeCriticalSection(&m_ConnectionListLock);
  25. 	// Accept请求
  26. 	m_hAcceptEvent = ::CreateEvent(NULL, FALSE, FALSE, NULL);
  27. 	m_hRepostEvent = ::CreateEvent(NULL, FALSE, FALSE, NULL);
  28. 	m_nRepostCount = 0;
  30. 	m_nThread = 0;
  31. 	m_nPort = 4567;
  33. 	m_nInitialAccepts = 10;
  34. 	m_nInitialReads = 4;
  35. 	m_nMaxAccepts = 100;
  36. 	m_nMaxSends = 20;
  37. 	m_nMaxFreeBuffers = 200;
  38. 	m_nMaxFreeContexts = 100;
  39. 	m_nMaxConnections = 2000;
  41. 	m_hListenThread = NULL;
  42. 	m_hCompletion = NULL;
  43. 	m_sListen = INVALID_SOCKET;
  44. 	m_lpfnAcceptEx = NULL;
  45. 	m_lpfnGetAcceptExSockaddrs = NULL;
  47. 	m_bShutDown = FALSE;
  48. 	m_bServerStarted = FALSE;
  50. 	m_hMutex = CreateMutex(NULL,FALSE,"LOCK");
  51. 	
  52. 	// 初始化WS2_32.dll
  53. 	WSADATA wsaData;
  54. 	WORD sockVersion = MAKEWORD(2, 2);
  55. 	::WSAStartup(sockVersion, &wsaData);
  56. }
  58. CIOCPServer::~CIOCPServer()
  59. {
  60. 	Shutdown();
  62. 	if(m_sListen != INVALID_SOCKET)
  63. 		::closesocket(m_sListen);
  64. 	if(m_hListenThread != NULL)
  65. 		::CloseHandle(m_hListenThread);
  67. 	::CloseHandle(m_hRepostEvent);
  68. 	::CloseHandle(m_hAcceptEvent);
  70. 	::DeleteCriticalSection(&m_FreeBufferListLock);
  71. 	::DeleteCriticalSection(&m_FreeContextListLock);
  72. 	::DeleteCriticalSection(&m_PendingAcceptsLock);
  73. 	::DeleteCriticalSection(&m_ConnectionListLock);
  75. 	::WSACleanup();	
  76. }
  79. ///
  80. // 自定义帮助函数
  82. CIOCPBuffer *CIOCPServer::AllocateBuffer(int nLen)
  83. {
  84. 	CIOCPBuffer *pBuffer = NULL;
  85. 	if(nLen > BUFFER_SIZE)
  86. 		return NULL;
  88. 	// 为缓冲区对象申请内存
  89. 	::EnterCriticalSection(&m_FreeBufferListLock);
  90. 	if(m_pFreeBufferList == NULL)  // 内存池为空，申请新的内存
  91. 	{
  92. 		pBuffer = (CIOCPBuffer *)::HeapAlloc(GetProcessHeap(), 
  93. 						HEAP_ZERO_MEMORY, sizeof(CIOCPBuffer) + BUFFER_SIZE);
  94. 	}
  95. 	else	// 从内存池中取一块来使用
  96. 	{
  97. 		pBuffer = m_pFreeBufferList;
  98. 		m_pFreeBufferList = m_pFreeBufferList->pNext;	
  99. 		pBuffer->pNext = NULL;
  100. 		m_nFreeBufferCount --;
  101. 	}
  102. 	::LeaveCriticalSection(&m_FreeBufferListLock);
  104. 	// 初始化新的缓冲区对象
  105. 	if(pBuffer != NULL)
  106. 	{
  107. 		pBuffer->buff = (char*)(pBuffer + 1);
  108. 		pBuffer->nLen = nLen;
  109. 	}
  110. 	return pBuffer;
  111. }
  113. void CIOCPServer::ReleaseBuffer(CIOCPBuffer *pBuffer)
  114. {
  115. 	::EnterCriticalSection(&m_FreeBufferListLock);
  117. 	if(m_nFreeBufferCount <= m_nMaxFreeBuffers)	// 将要释放的内存添加到空闲列表中
  118. 	{
  119. 		memset(pBuffer, 0, sizeof(CIOCPBuffer) + BUFFER_SIZE);
  120. 		pBuffer->pNext = m_pFreeBufferList;
  121. 		m_pFreeBufferList = pBuffer;
  123. 		m_nFreeBufferCount ++ ;
  124. 	}
  125. 	else			// 已经达到最大值，真正的释放内存
  126. 	{
  127. 		::HeapFree(::GetProcessHeap(), 0, pBuffer);
  128. 	}
  130. 	::LeaveCriticalSection(&m_FreeBufferListLock);
  131. }
  134. CIOCPContext *CIOCPServer::AllocateContext(SOCKET s)
  135. {
  136. 	CIOCPContext *pContext;
  138. 	// 申请一个CIOCPContext对象
  139. 	::EnterCriticalSection(&m_FreeContextListLock);
  140. 	if(m_pFreeContextList == NULL)
  141. 	{
  142. 		pContext = (CIOCPContext *)
  143. 				::HeapAlloc(::GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CIOCPContext)); 
  145. 		::InitializeCriticalSection(&pContext->Lock);
  146. 	}
  147. 	else	
  148. 	{
  149. 		// 在空闲列表中申请
  150. 		pContext = m_pFreeContextList;
  151. 		m_pFreeContextList = m_pFreeContextList->pNext;
  152. 		pContext->pNext = NULL;
  154. 		m_nFreeBufferCount --;
  155. 	}
  156. 	::LeaveCriticalSection(&m_FreeContextListLock);
  158. 	// 初始化对象成员
  159. 	if(pContext != NULL)
  160. 	{
  161. 		pContext->s = s;
  162. 	}
  163. 	return pContext;
  164. }
  166. void CIOCPServer::ReleaseContext(CIOCPContext *pContext)
  167. {
  168. 	if(pContext->s != INVALID_SOCKET)
  169. 		::closesocket(pContext->s);
  171. 	// 首先释放（如果有的话）此套节字上的没有按顺序完成的读I/O的缓冲区
  172. 	CIOCPBuffer *pNext;
  173. 	while(pContext->pOutOfOrderReads != NULL)
  174. 	{
  175. 		pNext = pContext->pOutOfOrderReads->pNext;
  176. 		ReleaseBuffer(pContext->pOutOfOrderReads);
  177. 		pContext->pOutOfOrderReads = pNext;
  178. 	}
  180. 	::EnterCriticalSection(&m_FreeContextListLock);
  181. 	
  182. 	if(m_nFreeContextCount <= m_nMaxFreeContexts) // 添加到空闲列表
  183. 	{
  184. 		// 先将关键代码段变量保存到一个临时变量中
  185. 		CRITICAL_SECTION cstmp = pContext->Lock;
  186. 		// 将要释放的上下文对象初始化为0
  187. 		memset(pContext, 0, sizeof(CIOCPContext));
  189. 		// 再放会关键代码段变量，将要释放的上下文对象添加到空闲列表的表头
  190. 		pContext->Lock = cstmp;
  191. 		pContext->pNext = m_pFreeContextList;
  192. 		m_pFreeContextList = pContext;
  193. 		
  194. 		// 更新计数
  195. 		m_nFreeContextCount ++;
  196. 	}
  197. 	else
  198. 	{
  199. 		::DeleteCriticalSection(&pContext->Lock);
  200. 		::HeapFree(::GetProcessHeap(), 0, pContext);
  201. 	}
  203. 	::LeaveCriticalSection(&m_FreeContextListLock);
  204. }
  206. void CIOCPServer::FreeBuffers()
  207. {
  208. 	// 遍历m_pFreeBufferList空闲列表，释放缓冲区池内存
  209. 	::EnterCriticalSection(&m_FreeBufferListLock);
  211. 	CIOCPBuffer *pFreeBuffer = m_pFreeBufferList;
  212. 	CIOCPBuffer *pNextBuffer;
  213. 	while(pFreeBuffer != NULL)
  214. 	{
  215. 		pNextBuffer = pFreeBuffer->pNext;
  216. 		if(!::HeapFree(::GetProcessHeap(), 0, pFreeBuffer))
  217. 		{
  218. #ifdef _DEBUG
  219. 			::OutputDebugString("  FreeBuffers释放内存出错！");
  220. #endif // _DEBUG
  221. 			break;
  222. 		}
  223. 		pFreeBuffer = pNextBuffer;
  224. 	}
  225. 	m_pFreeBufferList = NULL;
  226. 	m_nFreeBufferCount = 0;
  228. 	::LeaveCriticalSection(&m_FreeBufferListLock);
  229. }
  231. void CIOCPServer::FreeContexts()
  232. {
  233. 	// 遍历m_pFreeContextList空闲列表，释放缓冲区池内存
  234. 	::EnterCriticalSection(&m_FreeContextListLock);
  235. 	
  236. 	CIOCPContext *pFreeContext = m_pFreeContextList;
  237. 	CIOCPContext *pNextContext;
  238. 	while(pFreeContext != NULL)
  239. 	{
  240. 		pNextContext = pFreeContext->pNext;
  241. 		
  242. 		::DeleteCriticalSection(&pFreeContext->Lock);
  243. 		if(!::HeapFree(::GetProcessHeap(), 0, pFreeContext))
  244. 		{
  245. #ifdef _DEBUG
  246. 			::OutputDebugString("  FreeBuffers释放内存出错！");
  247. #endif // _DEBUG
  248. 			break;
  249. 		}
  250. 		pFreeContext = pNextContext;
  251. 	}
  252. 	m_pFreeContextList = NULL;
  253. 	m_nFreeContextCount = 0;
  255. 	::LeaveCriticalSection(&m_FreeContextListLock);
  256. }
  259. BOOL CIOCPServer::AddAConnection(CIOCPContext *pContext)
  260. {
  261. 	// 向客户连接列表添加一个CIOCPContext对象
  263. 	::EnterCriticalSection(&m_ConnectionListLock);
  264. 	if(m_nCurrentConnection <= m_nMaxConnections)
  265. 	{
  266. 		// 添加到表头
  267. 		pContext->pNext = m_pConnectionList;
  268. 		m_pConnectionList = pContext;
  269. 		// 更新计数
  270. 		m_nCurrentConnection ++;
  272. 		::LeaveCriticalSection(&m_ConnectionListLock);
  273. 		return TRUE;
  274. 	}
  275. 	::LeaveCriticalSection(&m_ConnectionListLock);
  277. 	return FALSE;
  278. }
  280. void CIOCPServer::CloseAConnection(CIOCPContext *pContext)
  281. {
  282. 	// 首先从列表中移除要关闭的连接
  283. 	::EnterCriticalSection(&m_ConnectionListLock);
  285. 	CIOCPContext* pTest = m_pConnectionList;
  286. 	if(pTest == pContext)
  287. 	{
  288. 		m_pConnectionList =  pContext->pNext;
  289. 		m_nCurrentConnection --;
  290. 	}
  291. 	else
  292. 	{
  293. 		while(pTest != NULL && pTest->pNext !=  pContext)
  294. 			pTest = pTest->pNext;
  295. 		if(pTest != NULL)
  296. 		{
  297. 			pTest->pNext =  pContext->pNext;
  298. 			m_nCurrentConnection --;
  299. 		}
  300. 	}
  301. 	
  302. 	::LeaveCriticalSection(&m_ConnectionListLock);
  304. 	// 然后关闭客户套节字
  305. 	::EnterCriticalSection(&pContext->Lock);
  307. 	if(pContext->s != INVALID_SOCKET)
  308. 	{
  309. 		::closesocket(pContext->s);	
  310. 		pContext->s = INVALID_SOCKET;
  311. 	}
  312. 	pContext->bClosing = TRUE;
  314. 	::LeaveCriticalSection(&pContext->Lock);
  315. }
  317. void CIOCPServer::CloseAllConnections()
  318. {
  319. 	// 遍历整个连接列表，关闭所有的客户套节字
  321. 	::EnterCriticalSection(&m_ConnectionListLock);
  323. 	CIOCPContext *pContext = m_pConnectionList;
  324. 	while(pContext != NULL)
  325. 	{	
  326. 		::EnterCriticalSection(&pContext->Lock);
  328. 		if(pContext->s != INVALID_SOCKET)
  329. 		{
  330. 			::closesocket(pContext->s);
  331. 			pContext->s = INVALID_SOCKET;
  332. 		}
  334. 		pContext->bClosing = TRUE;
  336. 		::LeaveCriticalSection(&pContext->Lock);	
  337. 		
  338. 		pContext = pContext->pNext;
  339. 	}
  341. 	m_pConnectionList = NULL;
  342. 	m_nCurrentConnection = 0;
  344. 	::LeaveCriticalSection(&m_ConnectionListLock);
  345. }
  348. BOOL CIOCPServer::InsertPendingAccept(CIOCPBuffer *pBuffer)
  349. {
  350. 	// 将一个I/O缓冲区对象插入到m_pPendingAccepts表中
  352. 	::EnterCriticalSection(&m_PendingAcceptsLock);
  354. 	if(m_pPendingAccepts == NULL)
  355. 		m_pPendingAccepts = pBuffer;
  356. 	else
  357. 	{
  358. 		pBuffer->pNext = m_pPendingAccepts;
  359. 		m_pPendingAccepts = pBuffer;
  360. 	}
  361. 	m_nPendingAcceptCount ++;
  363. 	::LeaveCriticalSection(&m_PendingAcceptsLock);
  365. 	return TRUE;
  366. }
  368. BOOL CIOCPServer::RemovePendingAccept(CIOCPBuffer *pBuffer)
  369. {
  370. 	BOOL bResult = FALSE;
  372. 	// 遍历m_pPendingAccepts表，从中移除pBuffer所指向的缓冲区对象
  373. 	::EnterCriticalSection(&m_PendingAcceptsLock);
  375. 	CIOCPBuffer *pTest = m_pPendingAccepts;
  376. 	if(pTest == pBuffer)	// 如果是表头元素
  377. 	{
  378. 		m_pPendingAccepts = pBuffer->pNext;
  379. 		bResult = TRUE;
  380. 	}
  381. 	else					// 不是表头元素的话，就要遍历这个表来查找了
  382. 	{
  383. 		while(pTest != NULL && pTest->pNext != pBuffer)
  384. 			pTest = pTest->pNext;
  385. 		if(pTest != NULL)
  386. 		{
  387. 			pTest->pNext = pBuffer->pNext;
  388. 			 bResult = TRUE;
  389. 		}
  390. 	}
  391. 	// 更新计数
  392. 	if(bResult)
  393. 		m_nPendingAcceptCount --;
  395. 	::LeaveCriticalSection(&m_PendingAcceptsLock);
  397. 	return  bResult;
  398. }
  401. CIOCPBuffer *CIOCPServer::GetNextReadBuffer(CIOCPContext *pContext, CIOCPBuffer *pBuffer)
  402. {
  403. 	if(pBuffer != NULL)
  404. 	{
  405. 		// 如果与要读的下一个序列号相等，则读这块缓冲区
  406. 		if(pBuffer->nSequenceNumber == pContext->nCurrentReadSequence)
  407. 		{
  408. 			return pBuffer;
  409. 		}
  410. 		
  411. 		// 如果不相等，则说明没有按顺序接收数据，将这块缓冲区保存到连接的pOutOfOrderReads列表中
  413. 		// 列表中的缓冲区是按照其序列号从小到大的顺序排列的
  415. 		pBuffer->pNext = NULL;
  416. 		
  417. 		CIOCPBuffer *ptr = pContext->pOutOfOrderReads;
  418. 		CIOCPBuffer *pPre = NULL;
  419. 		while(ptr != NULL)
  420. 		{
  421. 			if(pBuffer->nSequenceNumber < ptr->nSequenceNumber)
  422. 				break;
  423. 			
  424. 			pPre = ptr;
  425. 			ptr = ptr->pNext;
  426. 		}
  427. 		
  428. 		if(pPre == NULL) // 应该插入到表头
  429. 		{
  430. 			pBuffer->pNext = pContext->pOutOfOrderReads;
  431. 			pContext->pOutOfOrderReads = pBuffer;
  432. 		}
  433. 		else			// 应该插入到表的中间
  434. 		{
  435. 			pBuffer->pNext = pPre->pNext;
  436. 			pPre->pNext = pBuffer;
  437. 		}
  438. 	}
  440. 	// 检查表头元素的序列号，如果与要读的序列号一致，就将它从表中移除，返回给用户
  441. 	CIOCPBuffer *ptr = pContext->pOutOfOrderReads;
  442. 	if(ptr != NULL && (ptr->nSequenceNumber == pContext->nCurrentReadSequence))
  443. 	{
  444. 		pContext->pOutOfOrderReads = ptr->pNext;
  445. 		return ptr;
  446. 	}
  447. 	return NULL;
  448. }
  451. BOOL CIOCPServer::PostAccept(CIOCPBuffer *pBuffer)	// 在监听套节字上投递Accept请求
  452. {
  453. 		// 设置I/O类型
  454. 		pBuffer->nOperation = OP_ACCEPT;
  456. 		// 投递此重叠I/O  
  457. 		DWORD dwBytes;
  458. 		pBuffer->sClient = ::WSASocket(AF_INET, SOCK_STREAM, 0, NULL, 0, WSA_FLAG_OVERLAPPED);
  459. 		BOOL b = m_lpfnAcceptEx(m_sListen, 
  460. 			pBuffer->sClient,
  461. 			pBuffer->buff, 
  462. 			pBuffer->nLen - ((sizeof(sockaddr_in) + 16) * 2),
  463. 			sizeof(sockaddr_in) + 16, 
  464. 			sizeof(sockaddr_in) + 16, 
  465. 			&dwBytes, 
  466. 			&pBuffer->ol);
  467. 		if(!b && ::WSAGetLastError() != WSA_IO_PENDING)
  468. 		{
  469. 			return FALSE;
  470. 		}
  471. 		return TRUE;
  472. };
  474. BOOL CIOCPServer::PostRecv(CIOCPContext *pContext, CIOCPBuffer *pBuffer)
  475. {
  476. 	// 设置I/O类型
  477. 	pBuffer->nOperation = OP_READ;	
  478. 	
  479. 	::EnterCriticalSection(&pContext->Lock);
  481. 	// 设置序列号
  482. 	pBuffer->nSequenceNumber = pContext->nReadSequence;
  484. 	// 投递此重叠I/O
  485. 	DWORD dwBytes;
  486. 	DWORD dwFlags = 0;
  487. 	WSABUF buf;
  488. 	buf.buf = pBuffer->buff;
  489. 	buf.len = pBuffer->nLen;
  490. 	if(::WSARecv(pContext->s, &buf, 1, &dwBytes, &dwFlags, &pBuffer->ol, NULL) != NO_ERROR)
  491. 	{
  492. 		if(::WSAGetLastError() != WSA_IO_PENDING)
  493. 		{
  494. 			::LeaveCriticalSection(&pContext->Lock);
  495. 			return FALSE;
  496. 		}
  497. 	}
  499. 	// 增加套节字上的重叠I/O计数和读序列号计数
  501. 	pContext->nOutstandingRecv ++;
  502. 	pContext->nReadSequence ++;
  504. 	::LeaveCriticalSection(&pContext->Lock);
  506. 	return TRUE;
  507. }
  509. BOOL CIOCPServer::PostSend(CIOCPContext *pContext, CIOCPBuffer *pBuffer)
  510. {	
  511. 	// 跟踪投递的发送的数量，防止用户仅发送数据而不接收，导致服务器抛出大量发送操作
  512. 	if(pContext->nOutstandingSend > m_nMaxSends)
  513. 		return FALSE;
  515. 	// 设置I/O类型，增加套节字上的重叠I/O计数
  516. 	pBuffer->nOperation = OP_WRITE;
  518. 	// 投递此重叠I/O
  519. 	DWORD dwBytes;
  520. 	DWORD dwFlags = 0;
  521. 	WSABUF buf;
  522. 	buf.buf = pBuffer->buff;
  523. 	buf.len = pBuffer->nLen;
  524. 	if(::WSASend(pContext->s, 
  525. 			&buf, 1, &dwBytes, dwFlags, &pBuffer->ol, NULL) != NO_ERROR)
  526. 	{
  527. 		if(::WSAGetLastError() != WSA_IO_PENDING)
  528. 			return FALSE;
  529. 	}	
  530. 	
  531. 	// 增加套节字上的重叠I/O计数
  532. 	::EnterCriticalSection(&pContext->Lock);
  533. 	pContext->nOutstandingSend ++;
  534. 	::LeaveCriticalSection(&pContext->Lock);
  536. 	return TRUE;
  537. }
  540. BOOL CIOCPServer::Start(int nPort, int nMaxConnections, 
  541. 			int nMaxFreeBuffers, int nMaxFreeContexts, int nInitialReads)
  542. {
  543. 	// 检查服务是否已经启动
  544. 	if(m_bServerStarted)
  545. 		return FALSE;
  546. OutputDebugString("测试！/r\n");
  547. 	// 保存用户参数
  548. 	m_nPort = nPort;
  549. 	m_nMaxConnections = nMaxConnections;
  550. 	m_nMaxFreeBuffers = nMaxFreeBuffers;
  551. 	m_nMaxFreeContexts = nMaxFreeContexts;
  552. 	m_nInitialReads = nInitialReads;
  554. 	// 初始化状态变量
  555. 	m_bShutDown = FALSE;
  556. 	m_bServerStarted = TRUE;
  559. 	// 创建监听套节字，绑定到本地端口，进入监听模式
  560. 	m_sListen = ::WSASocket(AF_INET, SOCK_STREAM,IPPROTO_IP, NULL, 0, WSA_FLAG_OVERLAPPED);
  561. 	SOCKADDR_IN si;
  562. 	si.sin_family = AF_INET;
  563. 	si.sin_port = ::ntohs(m_nPort);
  564. 	si.sin_addr.S_un.S_addr = INADDR_ANY;
  565. 	if(::bind(m_sListen, (sockaddr*)&si, sizeof(si)) == SOCKET_ERROR)
  566. 	{
  567. 		m_bServerStarted = FALSE;
  568. 		return FALSE;
  569. 	}
  570. 	::listen(m_sListen, 200);
  572. 	// 创建完成端口对象
  573. 	m_hCompletion = ::CreateIoCompletionPort(INVALID_HANDLE_VALUE, 0, 0, 0);
  575. 	// 加载扩展函数AcceptEx
  576. 	GUID GuidAcceptEx = WSAID_ACCEPTEX;
  577. 	DWORD dwBytes;
  578. 	::WSAIoctl(m_sListen, 
  579. 		SIO_GET_EXTENSION_FUNCTION_POINTER, 
  580. 		&GuidAcceptEx, 
  581. 		sizeof(GuidAcceptEx),
  582. 		&m_lpfnAcceptEx, 
  583. 		sizeof(m_lpfnAcceptEx), 
  584. 		&dwBytes, 
  585. 		NULL, 
  586. 		NULL);
  587. 	
  588. 	// 加载扩展函数GetAcceptExSockaddrs
  589. 	GUID GuidGetAcceptExSockaddrs = WSAID_GETACCEPTEXSOCKADDRS;
  590. 	::WSAIoctl(m_sListen,
  591. 		SIO_GET_EXTENSION_FUNCTION_POINTER,
  592. 		&GuidGetAcceptExSockaddrs,
  593. 		sizeof(GuidGetAcceptExSockaddrs),
  594. 		&m_lpfnGetAcceptExSockaddrs,
  595. 		sizeof(m_lpfnGetAcceptExSockaddrs),
  596. 		&dwBytes,
  597. 		NULL,
  598. 		NULL
  599. 		);
  600. 	
  601. 	
  602. 	// 将监听套节字关联到完成端口，注意，这里为它传递的CompletionKey为0
  603. 	::CreateIoCompletionPort((HANDLE)m_sListen, m_hCompletion, (DWORD)0, 0);
  605. 	// 注册FD_ACCEPT事件。
  606. 	// 如果投递的AcceptEx I/O不够，线程会接收到FD_ACCEPT网络事件，说明应该投递更多的AcceptEx I/O
  607. 	WSAEventSelect(m_sListen, m_hAcceptEvent, FD_ACCEPT);
  609. 	// 创建监听线程
  610. 	m_hListenThread = ::CreateThread(NULL, 0, _ListenThreadProc, this, 0, NULL);
  611. 	
  612. 	return TRUE;
  613. }
  615. void CIOCPServer::Shutdown()
  616. {
  617. 	if(!m_bServerStarted)
  618. 		return;
  620. 	// 通知监听线程，马上停止服务
  621. 	m_bShutDown = TRUE;
  622. 	::SetEvent(m_hAcceptEvent);
  623. 	// 等待监听线程退出
  624. 	::WaitForSingleObject(m_hListenThread, INFINITE);
  625. 	::CloseHandle(m_hListenThread);
  626. 	m_hListenThread = NULL;
  628. 	m_bServerStarted = FALSE;
  629. }
  631. DWORD WINAPI CIOCPServer::_ListenThreadProc(LPVOID lpParam)
  632. {
  633. 	CIOCPServer *pThis = (CIOCPServer*)lpParam;
  635. 	// 先在监听套节字上投递几个Accept I/O
  636. 	CIOCPBuffer *pBuffer;
  637. 	for(int i=0; i<pThis->m_nInitialAccepts; i++)
  638. 	{
  639. 		pBuffer = pThis->AllocateBuffer(BUFFER_SIZE);
  640. 		if(pBuffer == NULL)
  641. 			return -1;
  642. 		pThis->InsertPendingAccept(pBuffer);
  643. 		pThis->PostAccept(pBuffer);
  644. 	}
  646. 	// 构建事件对象数组，以便在上面调用WSAWaitForMultipleEvents函数
  647. 	pThis->m_nThread = _GetNoOfProcessors();
  648. 	HANDLE *hWaitEvents = new HANDLE[2 + pThis->m_nThread ];
  649. 	int nEventCount = 0;
  650. 	hWaitEvents[nEventCount ++] = pThis->m_hAcceptEvent;
  651. 	hWaitEvents[nEventCount ++] = pThis->m_hRepostEvent;
  653. 	// 创建指定数量的工作线程在完成端口上处理I/O
  654. 	for(int i=0; i<pThis->m_nThread ; i++)
  655. 	{
  656. 		hWaitEvents[nEventCount ++] = ::CreateThread(NULL, 0, _WorkerThreadProc, pThis, 0, NULL);
  657. 	}
  659. 	// 下面进入无限循环，处理事件对象数组中的事件
  660. 	while(TRUE)
  661. 	{
  662. 		//::OutputDebugString("WSAWaitForMultipleEvents begin\n");
  663. 		int nIndex = ::WSAWaitForMultipleEvents(nEventCount, hWaitEvents, FALSE,30*1000, FALSE);
  664. 		//::OutputDebugString("WSAWaitForMultipleEvents end\n");
  665. 		char temp[256];
  666. 		//::OutputDebugString(itoa(nIndex,temp,10));
  667. 		// 首先检查是否要停止服务
  668. 		if(pThis->m_bShutDown || nIndex == WSA_WAIT_FAILED)
  669. 		{::OutputDebugString("pThis->m_bShutDown\n");
  670. 			// 关闭所有连接
  671. 			pThis->CloseAllConnections();
  672. 			::Sleep(0);		// 给I/O工作线程一个执行的机会
  673. 			// 关闭监听套节字
  674. 			::closesocket(pThis->m_sListen);
  675. 			pThis->m_sListen = INVALID_SOCKET;
  676. 			::Sleep(0);		// 给I/O工作线程一个执行的机会
  678. 			// 通知所有I/O处理线程退出
  679. 			for(int i=2; i<pThis->m_nThread + 2; i++)
  680. 			{	
  681. 				::PostQueuedCompletionStatus(pThis->m_hCompletion, -1, 0, NULL);
  682. 			}
  684. 			// 等待I/O处理线程退出
  685. 			::WaitForMultipleObjects(pThis->m_nThread , &hWaitEvents[2], TRUE, 5*1000);
  687. 			for(int i=2; i<pThis->m_nThread  + 2; i++)
  688. 			{	
  689. 				::CloseHandle(hWaitEvents[i]);
  690. 			}
  691. 		
  692. 			::CloseHandle(pThis->m_hCompletion);
  694. 			pThis->FreeBuffers();
  695. 			pThis->FreeContexts();
  696. 			::ExitThread(0);
  697. 		}	
  698. 		
  699. 		// 1）定时检查所有未返回的AcceptEx I/O的连接建立了多长时间
  700. 		if(nIndex == WSA_WAIT_TIMEOUT)
  701. 		{::OutputDebugString("WSA_WAIT_TIMEOUT\n");
  702. 			pBuffer = pThis->m_pPendingAccepts;
  703. 			while(pBuffer != NULL)
  704. 			{
  705. 				int nSeconds;
  706. 				int nLen = sizeof(nSeconds);
  707. 				// 取得连接建立的时间
  708. 				::getsockopt(pBuffer->sClient, 
  709. 					SOL_SOCKET, SO_CONNECT_TIME, (char *)&nSeconds, &nLen);	
  710. 				// 如果超过2分钟客户还不发送初始数据，就让这个客户go away
  711. 				if(nSeconds != -1 && nSeconds > 2*60)
  712. 				{   
  713. 					closesocket(pBuffer->sClient);
  714.                     pBuffer->sClient = INVALID_SOCKET;
  715. 				}
  717. 				pBuffer = pBuffer->pNext;
  718. 			}
  719. 		}
  720. 		else
  721. 		{
  722. 			nIndex = nIndex - WAIT_OBJECT_0;
  723. 			//int nRet = ::WSAWaitForMultipleEvents(1, &hWaitEvents[nIndex], TRUE, 0, FALSE);
  724. 			WSANETWORKEVENTS ne;
  725.             int nLimit=0;
  726. 			if(nIndex == 0)			// 2）m_hAcceptEvent事件对象受信，说明投递的Accept请求不够，需要增加
  727. 			{
  728. 				::WSAEnumNetworkEvents(pThis->m_sListen, hWaitEvents[nIndex], &ne);
  729. 				if(ne.lNetworkEvents & FD_ACCEPT)
  730. 				{
  731. 					nLimit = 50;  // 增加的个数，这里设为50个
  732. 				}
  733. 			}
  734. 			else if(nIndex == 1)	// 3）m_hRepostEvent事件对象受信，说明处理I/O的线程接受到新的客户
  735. 			{
  736. 				nLimit = InterlockedExchange(&pThis->m_nRepostCount, 0);
  737. 				::OutputDebugString("处理I/O的线程接受到新的客户\n");
  738. 			}
  739. 			else if(nIndex > 1)		// I/O服务线程退出，说明有错误发生，关闭服务器
  740. 			{
  741. 				pThis->m_bShutDown = TRUE;
  742. 				continue;
  743. 			}
  744. ::OutputDebugString("投递nLimit个AcceptEx I/O请求\n");
  745. 			// 投递nLimit个AcceptEx I/O请求
  746. 			int i = 0;
  747. 			while(i++ < nLimit && pThis->m_nPendingAcceptCount < pThis->m_nMaxAccepts)
  748. 			{
  749. 				pBuffer = pThis->AllocateBuffer(BUFFER_SIZE);
  750. 				if(pBuffer != NULL)
  751. 				{
  752. 					pThis->InsertPendingAccept(pBuffer);
  753. 					pThis->PostAccept(pBuffer);
  754. 				}
  755. 			}
  756. 		}
  757. 	}
  759. 	delete []hWaitEvents;
  760. 	return 0;
  761. }
  763. DWORD WINAPI CIOCPServer::_WorkerThreadProc(LPVOID lpParam)
  764. {
  765. #ifdef _DEBUG
  766. 			::OutputDebugString("	WorkerThread 启动... \n");
  767. #endif // _DEBUG
  769. 	CIOCPServer *pThis = (CIOCPServer*)lpParam;
  771. 	CIOCPBuffer *pBuffer;
  772. 	DWORD dwKey;
  773. 	DWORD dwTrans;
  774. 	LPOVERLAPPED lpol;
  775. 	while(TRUE)
  776. 	{
  777. 		::OutputDebugString("GetQueuedCompletionStatus begin\n");
  778. 		// 在关联到此完成端口的所有套节字上等待I/O完成
  779. 		BOOL bOK = ::GetQueuedCompletionStatus(pThis->m_hCompletion, 
  780. 					&dwTrans, (LPDWORD)&dwKey, (LPOVERLAPPED*)&lpol, WSA_INFINITE);
  781. 		::OutputDebugString("GetQueuedCompletionStatus completed\n");
  782. 		if(dwTrans == -1) // 用户通知退出
  783. 		{
  784. #ifdef _DEBUG
  785. 			::OutputDebugString("	WorkerThread 退出 \n");
  786. #endif // _DEBUG
  787. 			::ExitThread(0);
  788. 		}
  790. 		pBuffer = CONTAINING_RECORD(lpol, CIOCPBuffer, ol);
  791. 		int nError = NO_ERROR;
  792. 		if(!bOK)						// 在此套节字上有错误发生
  793. 		{
  794. 			SOCKET s;
  795. 			if(pBuffer->nOperation == OP_ACCEPT)
  796. 			{
  797. 				s = pThis->m_sListen;
  798. 			}
  799. 			else
  800. 			{
  801. 				if(dwKey == 0)
  802. 					break;
  803. 				s = ((CIOCPContext*)dwKey)->s;
  804. 			}
  805. 			DWORD dwFlags = 0;
  806. 			if(!::WSAGetOverlappedResult(s, &pBuffer->ol, &dwTrans, FALSE, &dwFlags))
  807. 			{
  808. 				nError = ::WSAGetLastError();
  809. 			}
  810. 		}
  811. 		WaitForSingleObject(pThis->m_hMutex,INFINITE);
  812. 		pThis->HandleIO(dwKey, pBuffer, dwTrans, nError);
  813. 		ReleaseMutex(pThis->m_hMutex);
  814. 	}
  816. #ifdef _DEBUG
  817. 			::OutputDebugString("	WorkerThread 退出 \n");
  818. #endif // _DEBUG
  819. 	return 0;
  820. }
  823. void CIOCPServer::HandleIO(DWORD dwKey, CIOCPBuffer *pBuffer, DWORD dwTrans, int nError)
  824. {
  825. 	CIOCPContext *pContext = (CIOCPContext *)dwKey;
  827. #ifdef _DEBUG
  828. 			::OutputDebugString("	HandleIO... \n");
  829. #endif // _DEBUG
  830. 	
  831. 	// 1）首先减少套节字上的未决I/O计数
  832. 	if(pContext != NULL)
  833. 	{
  834. 		::EnterCriticalSection(&pContext->Lock);
  835. 		
  836. 		if(pBuffer->nOperation == OP_READ)
  837. 			pContext->nOutstandingRecv --;
  838. 		else if(pBuffer->nOperation == OP_WRITE)
  839. 			pContext->nOutstandingSend --;
  840. 		
  841. 		::LeaveCriticalSection(&pContext->Lock);
  842. 		
  843. 		// 2）检查套节字是否已经被我们关闭
  844. 		if(pContext->bClosing) 
  845. 		{
  846. #ifdef _DEBUG
  847. 			::OutputDebugString("	检查到套节字已经被我们关闭 \n");
  848. #endif // _DEBUG
  849. 			if(pContext->nOutstandingRecv == 0 && pContext->nOutstandingSend == 0)
  850. 			{		
  851. 				ReleaseContext(pContext);
  852. 			}
  853. 			// 释放已关闭套节字的未决I/O
  854. 			ReleaseBuffer(pBuffer);	
  855. 			return;
  856. 		}
  857. 	}
  858. 	else
  859. 	{
  860. 		RemovePendingAccept(pBuffer);
  861. #ifdef _DEBUG
  862. 		::OutputDebugString("RemovePendingAccept(pBuffer);\n");
  863. #endif // _DEBUG
  864. 	}
  866. 	// 3）检查套节字上发生的错误，如果有的话，通知用户，然后关闭套节字
  867. 	if(nError != NO_ERROR)
  868. 	{
  869. 		if(pBuffer->nOperation != OP_ACCEPT)
  870. 		{
  871. 			OnConnectionError(pContext, pBuffer, nError);
  872. 			CloseAConnection(pContext);
  873. 			if(pContext->nOutstandingRecv == 0 && pContext->nOutstandingSend == 0)
  874. 			{		
  875. 				ReleaseContext(pContext);
  876. 			}
  877. #ifdef _DEBUG
  878. 			::OutputDebugString("	检查到客户套节字上发生错误 \n");
  879. #endif // _DEBUG
  880. 		}
  881. 		else // 在监听套节字上发生错误，也就是监听套节字处理的客户出错了
  882. 		{
  883. 			// 客户端出错，释放I/O缓冲区
  884. 			if(pBuffer->sClient != INVALID_SOCKET)
  885. 			{
  886. 				::closesocket(pBuffer->sClient);
  887. 				pBuffer->sClient = INVALID_SOCKET;
  888. 			}
  889. #ifdef _DEBUG
  890. 			::OutputDebugString("	检查到监听套节字上发生错误 \n");
  891. #endif // _DEBUG
  892. 		}
  894. 		ReleaseBuffer(pBuffer);
  895. 		return;
  896. 	}
  897. //printf("%d\n",pBuffer->nOperation);
  898. //#ifdef _DEBUG
  899. //	::OutputDebugString((const char *)pBuffer->nOperation);
  900. //#endif // _DEBUG
  902. 	// 开始处理
  903. 	if(pBuffer->nOperation == OP_ACCEPT)
  904. 	{
  905. 		if(dwTrans == 0)
  906. 		{
  907. #ifdef _DEBUG
  908. 			::OutputDebugString("	监听套节字上客户端关闭 \n");
  909. #endif // _DEBUG
  910. 			
  911. 			if(pBuffer->sClient != INVALID_SOCKET)
  912. 			{
  913. 				::closesocket(pBuffer->sClient);
  914. 				pBuffer->sClient = INVALID_SOCKET;
  915. 			}
  916. 		}
  917. 		else
  918. 		{
  919. 			// 为新接受的连接申请客户上下文对象
  920. 			CIOCPContext *pClient = AllocateContext(pBuffer->sClient);
  921. 			if(pClient != NULL)
  922. 			{
  923. 				if(AddAConnection(pClient))
  924. 				{	
  925. 					// 取得客户地址
  926. 					::OutputDebugString("AddAConnection(pClient)\n");
  927. 					int nLocalLen, nRmoteLen;
  928. 					LPSOCKADDR pLocalAddr, pRemoteAddr;
  929. 					m_lpfnGetAcceptExSockaddrs(
  930. 						pBuffer->buff,
  931. 						pBuffer->nLen - ((sizeof(sockaddr_in) + 16) * 2),
  932. 						sizeof(sockaddr_in) + 16,
  933. 						sizeof(sockaddr_in) + 16,
  934. 						(SOCKADDR **)&pLocalAddr,
  935. 						&nLocalLen,
  936. 						(SOCKADDR **)&pRemoteAddr,
  937. 						&nRmoteLen);
  938. 					memcpy(&pClient->addrLocal, pLocalAddr, nLocalLen);
  939. 					memcpy(&pClient->addrRemote, pRemoteAddr, nRmoteLen);
  940. 					
  941. 					// 关联新连接到完成端口对象
  942. 					::CreateIoCompletionPort((HANDLE)pClient->s, m_hCompletion, (DWORD)pClient, 0);
  943. 					
  944. 					// 通知用户
  945. 					pBuffer->nLen = dwTrans;
  946. 					OnConnectionEstablished(pClient, pBuffer);
  947. 					
  948. 					// 向新连接投递几个Read请求，这些空间在套节字关闭或出错时释放
  949. 					::OutputDebugString("New Connect Post 5 Recv Request\n");
  950. 					for(int i=0; i<5; i++)
  951. 					{
  952. 						CIOCPBuffer *p = AllocateBuffer(BUFFER_SIZE);
  953. 						if(p != NULL)
  954. 						{
  955. 							if(!PostRecv(pClient, p))
  956. 							{
  957. 								CloseAConnection(pClient);
  958. 								break;
  959. 							}
  960. 						}
  961. 					}
  962. 				}
  963. 				else	// 连接数量已满，关闭连接
  964. 				{
  965. 					CloseAConnection(pClient);
  966. 					ReleaseContext(pClient);
  967. 				}
  968. 			}
  969. 			else
  970. 			{
  971. 				// 资源不足，关闭与客户的连接即可
  972. 				::closesocket(pBuffer->sClient);
  973. 				pBuffer->sClient = INVALID_SOCKET;
  974. 			}
  975. 		}
  976. 		
  977. 		// Accept请求完成，释放I/O缓冲区
  978. 		ReleaseBuffer(pBuffer);	
  980. 		// 通知监听线程继续再投递一个Accept请求
  981. 		::InterlockedIncrement(&m_nRepostCount);
  982. 		::SetEvent(m_hRepostEvent);
  983. 	}
  984. 	else if(pBuffer->nOperation == OP_READ)
  985. 	{
  986. 		if(dwTrans == 0)	// 对方关闭套节字
  987. 		{
  988. 			// 先通知用户
  989. 			pBuffer->nLen = 0;
  990. 			OnConnectionClosing(pContext, pBuffer);	
  991. 			// 再关闭连接
  992. 			CloseAConnection(pContext);
  993. 			// 释放客户上下文和缓冲区对象
  994. 			if(pContext->nOutstandingRecv == 0 && pContext->nOutstandingSend == 0)
  995. 			{		
  996. 				ReleaseContext(pContext);
  997. 			}
  998. 			ReleaseBuffer(pBuffer);	
  999. 		}
  1000. 		else
  1001. 		{
  1002. 			pBuffer->nLen = dwTrans;
  1003. 			// 按照I/O投递的顺序读取接收到的数据
  1004. 			CIOCPBuffer *p = GetNextReadBuffer(pContext, pBuffer);
  1005. 			while(p != NULL)
  1006. 			{
  1007. 				// 通知用户
  1008. 				OnReadCompleted(pContext, p);
  1009. 				// 增加要读的序列号的值
  1010. 				::InterlockedIncrement((LONG*)&pContext->nCurrentReadSequence);
  1011. 				// 释放这个已完成的I/O
  1012. 				ReleaseBuffer(p);
  1013. 				p = GetNextReadBuffer(pContext, NULL);
  1014. 			}
  1016. 			// 继续投递一个新的接收请求
  1017. 			pBuffer = AllocateBuffer(BUFFER_SIZE);
  1018. 			if(pBuffer == NULL || !PostRecv(pContext, pBuffer))
  1019. 			{
  1020. 				CloseAConnection(pContext);
  1021. 			}
  1022. 		}
  1023. 	}
  1024. 	else if(pBuffer->nOperation == OP_WRITE)
  1025. 	{
  1027. 		if(dwTrans == 0)	// 对方关闭套节字
  1028. 		{
  1029. 			// 先通知用户
  1030. 			pBuffer->nLen = 0;
  1031. 			OnConnectionClosing(pContext, pBuffer);	
  1033. 			// 再关闭连接
  1034. 			CloseAConnection(pContext);
  1036. 			// 释放客户上下文和缓冲区对象
  1037. 			if(pContext->nOutstandingRecv == 0 && pContext->nOutstandingSend == 0)
  1038. 			{		
  1039. 				ReleaseContext(pContext);
  1040. 			}
  1041. 			ReleaseBuffer(pBuffer);	
  1042. 		}
  1043. 		else
  1044. 		{
  1045. 			// 写操作完成，通知用户
  1046. 			pBuffer->nLen = dwTrans;
  1047. 			OnWriteCompleted(pContext, pBuffer);
  1048. 			// 释放SendText函数申请的缓冲区
  1049. 			ReleaseBuffer(pBuffer);
  1050. 		}
  1051. 	}
  1052. }
  1055. BOOL CIOCPServer::SendText(CIOCPContext *pContext, char *pszText, int nLen)
  1056. {
  1057. 	CIOCPBuffer *pBuffer = AllocateBuffer(nLen);
  1058. 	if(pBuffer != NULL)
  1059. 	{
  1060. 		memcpy(pBuffer->buff, pszText, nLen);
  1061. 		return PostSend(pContext, pBuffer);
  1062. 	}
  1063. 	return FALSE;
  1064. }
  1066. int CIOCPServer::_GetNoOfProcessors()
  1067. {
  1068. 		SYSTEM_INFO si;
  1070. 		GetSystemInfo(&si);
  1072. 		return si.dwNumberOfProcessors;
  1073. }
  1075. void CIOCPServer::OnConnectionEstablished(CIOCPContext *pContext, CIOCPBuffer *pBuffer)
  1076. {
  1077. }
  1079. void CIOCPServer::OnConnectionClosing(CIOCPContext *pContext, CIOCPBuffer *pBuffer)
  1080. {
  1081. }
  1084. void CIOCPServer::OnReadCompleted(CIOCPContext *pContext, CIOCPBuffer *pBuffer)
  1085. {
  1086. }
  1088. void CIOCPServer::OnWriteCompleted(CIOCPContext *pContext, CIOCPBuffer *pBuffer)
  1089. {
  1090. }
  1092. void CIOCPServer::OnConnectionError(CIOCPContext *pContext, CIOCPBuffer *pBuffer, int nError)
  1093. {
  1094. }
PS：不排除其他bug，如有问题请指正，喷子滚一表去。
阿特图
关注
专栏目录
Windows网络与通信程序设计中简单实用的IOCP类
08-05
Windows网络与通信程序设计中简单实用的IOCP类 很好用，很简单，也容易扩展，供学习用很好
IOCP系统Bug
heartrude的专栏
07-30 846
对IOCP对象进行GuidDisconnectEx。很小的概率会导致没有IOCP返回。 具体原因还不清楚，已经排除没有进行适当IOCP的问题。我们把其成为僵尸问题。 目前的解决方案是记录连接对象的GuidDisconnectEx调用次数，如果超过4次，就直接进行Closesocket操作。
《Windows网络与通信程序设计》读书笔记－－－－IOCP与可伸缩网络程序
劉俊的专栏
05-06 1499
完成端口I/O模型 I/O完成端口是应用程序使用线程池处理I/O请求的一种机制。处理多个并发异步I/O请求时，使用I/O完成端口比在I/O请求时创建线程更快更有效。   CreateIoCompletionPort函数有点复杂，需要说明一下 CreateIoCompletionPort函数有两个功能。 1、创建一个完成端口对象。 2、将一个或者多个文件句柄(套接字句柄)关联到I/O完成
Windows 网络与通信程序设计
03-07
在TCP/IP网络应用中，通信的两个进程间相互作用的主要模式是客户/服务器模式（Client/Server model），即客户向服务器发出服务请求，服务器接收到请求后，提供相应的服务。客户/服务器模式的建立基于以下两点：首先，建立网络的起因是网络中软硬件资源、运算能力和信息不均等，需要共享，从而造就拥有众多资源的主机提供服务，资源较少的客户请求服务这一非对等作用。其次，网间进程通信完全是异步的，相互通信的进程间既不存在父子关系，又不共享内存缓冲区，因此需要一种机制为希望通信的进程间建立联系，为二者的数据交换提供同步，这就是客户/服务器模式的TCP/IP。
Windows网络与通信程序设计
03-28
学习使用winsock函数编写网络客户程序和服务器程序，学习windows网络驱动程序了解标准的网络协议在windows平台下如何实现。
把socket IOCP完成端口网络通信模型封装成c++类.zip
03-30
在Windows系统中，IOCP（I/O完成端口）是一种高效、多线程的I/O模型，用于处理大量并发的网络连接。IOCP利用操作系统的内核态完成I/O操作，减少了用户态与内核态之间的上下文切换，提高了系统的吞吐量。本项目将...
IOCP 完成端口模型简单封装
11-04
IOCP（完成端口，英文名I/O Completion Ports）是一种在Windows操作系统中实现高并发网络通信的重要机制。它为高性能服务器设计提供了强大的支持，尤其适用于处理大量并发连接请求。本文将对IOCP模型进行简单的封装...
windows socket网络编程之iocp完成端口模型的例子
04-17
在Windows Socket（Winsock）网络编程中，I/O完成端口（I/O Completion Port, IOCP）是一种高效处理大量并发I/O操作的机制。本文将深入探讨IOCP完成端口模型，并通过具体例子来阐述其工作原理和实现方法。 IOCP是...
IOCP.rar_C语言IOCP_IOCP_windows iocp_完成端口_完成端口模型
最新发布
09-24
完成端口（IOCP）是Windows系统提供的一种异步I/O模型，它允许应用程序通过一个单一的线程池来处理来自多个套接字的I/O完成。相比于传统的轮询或线程一对一模型，IOCP可以显著提高系统性能，减少上下文切换和线程...
Windows网络与通信程序设计_.rar_IOCP_dropped8x7_windows_windows socket_驱动
07-14
windows网络编程，设计到基本的socket入门，异步socket，iocp，后面还有驱动，
Windows-网络与通信程序设计.pdf
05-21
王艳平写的Windows网络与通信程序设计，感觉不错，就放上去了。
Windows网络与通信程序设计及源代码
03-28
学习windows平台下winsock编程，学习如何编写客户程序和服务器程序。学习windwos网络驱动程序设计。了解标准的网络协议在windows平台下如何实现。
windows网络与通信程序设计pdf以及源码
12-11
c++ windows网络与通信程序设计pdf以及源码 ，六种网络通信模式，p2p核心实现，iocp网络服务器实现等等。
Windows网络与通信程序设计pdf+源码.rar
10-14
Windows网络与通信程序设计pdf+源码.rar
IOCPDemo-完成端口I/O模型编程
08-25
完成端口I/O模型编程完成端口I/O模型编程完成端口I/O模型编程完成端口I/O模型编程
完成端口GetQueuedCompletionStatus返回值的问题
xuwei2007的专栏
09-05 7279
 完成端口GetQueuedCompletionStatus返回值的问题先看看GetQueuedCompletionStatus函数的完整声明：BOOL GetQueuedCompletionStatus(  HANDLE CompletionPort,         LPDWORD lpNumberOfBytes,      PULONG_PTR lpCompletionKey,    L
关于IOCP（IO完成端口）服务器在X86与X64下异常报错解决
kason的博客
01-04 1371
问题:在X64 GetQueuedCompletionStatus获取消息对象PULONG_PTR越界报错 在X86下没有此问题 解决思路 GetQueuedCompletionStatus()的作用 在扫描完成端口的队列里是否有网络通信的请求存在(例如读取数据，发送数据等)，一旦有的话，就将这个请求从完成端口的队列中取回来，继续执行处理代码 GetQueuedCompletionStatus()的数据来源 绑定Socket到一个完成端口的时候，用的CreateIoCompletionPort()函数，传
iocp端口断开_iocp-完成端口内存泄露问题，求高手解答？
weixin_29728529的博客
01-17 254
关键源码/****************************************************************************************** @ 关闭socket*****************************************************************************************/#def...
Windows 网络与通信程序设计 王艳平 Phoenix 金羽 防火墙
snifftiger的专栏
11-29 1419
终于成功了
Windows服务器网络通信：完成端口实现与异步I/O模型解析
"完成端口的实现步骤及Windows网络通信IO模型" 在Windows网络编程中，完成端口（Completion Port，简称CP）是一种高效的多线程I/O模型，尤其适用于高并发的服务器应用。实现一个基于完成端口的网络服务需要遵循一...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值