移植了开源远程控制Gh0st3.6中的IOCP完成端口到dll（C++源码）

Ghost3.6 是性能很好的一款开源远程控制。其IOCP模型算是比较好的了。我将其中的IOCP完成端口模型抠出来封装成了DLL。。只是没有进行网络测试。

源代码:http://download.csdn.net/detail/witch_soya/4882068

服务器端初始化函数

bool NetEngineServer::InitServer( DWORD a_dwPort )
{
	//创建套接字
	m_Listen = WSASocket(AF_INET, SOCK_STREAM, 0, NULL, 0,WSA_FLAG_OVERLAPPED);

	//IO事件
	m_hEvent = WSACreateEvent();
	if (m_hEvent == INVALID_HANDLE_VALUE)
	{
		closesocket(m_Listen);
		return FALSE;
	}
	//选择模型
	int nRet = WSAEventSelect(m_Listen,m_hEvent,FD_ACCEPT);
	if (nRet == SOCKET_ERROR)
	{
		closesocket(m_Listen);
		return FALSE;
	}

	
	//地址初始化	
	sockaddr_in						t_ServerAddress;	
	memset(&t_ServerAddress,0,sizeof(t_ServerAddress));
	t_ServerAddress.sin_family      = AF_INET;
	t_ServerAddress.sin_addr.s_addr = htonl(INADDR_ANY);
	t_ServerAddress.sin_port        = htons(a_dwPort);

	//绑定
	nRet = bind(m_Listen,(struct sockaddr *)&t_ServerAddress,sizeof(t_ServerAddress));
	if (nRet == SOCKET_ERROR)
	{
		DWORD dwErr = GetLastError();
		closesocket(m_Listen);
		return FALSE;
	}

	//监听
	nRet = listen( m_Listen,5);
	if (nRet == SOCKET_ERROR)
	{
		closesocket(m_Listen);
		return FALSE;
	}

	//创建IO端口
	m_hCompletionPort = CreateIoCompletionPort( INVALID_HANDLE_VALUE,
												NULL,   // No prior port
												0,      // No key
												0       // Use default  # of threads
												);
	if( m_hCompletionPort == NULL )
	{
		MessageBox( NULL,"CreateIoCompletionPort错误","InitServer",NULL );
		return false;
	}

	
	//创建监听线程
	nRet = this->CreateListenThread();
	if (nRet == FALSE)
	{
		return FALSE;
		closesocket(m_Listen);
	}

	//创建工作线程
	this->CreateWorkerThread();
		
	return true;
}

服务器端监听线程

/************************************************************************/
/* 
函数说明:监听线程
*/
/************************************************************************/
DWORD WINAPI NetEngineServer::ListenThread(LPVOID lPvoid)
{
	NetEngineServer* pThis = reinterpret_cast<NetEngineServer*>(lPvoid);

	WSANETWORKEVENTS events;
	while(TRUE)
	{
		if (WaitForSingleObject(pThis->m_hKillEvent, 100) == WAIT_OBJECT_0)
			break;

		DWORD dwRet;
		dwRet = WSAWaitForMultipleEvents(1,
										 &pThis->m_hEvent,
										  FALSE,
										  100,
										  FALSE);

		if (dwRet == WSA_WAIT_TIMEOUT)
			continue;

		int nRet = WSAEnumNetworkEvents(pThis->m_Listen,
										pThis->m_hEvent,
										&events);
		if (nRet == SOCKET_ERROR)
		{
			break;
		}

		// Handle Network events //
		// ACCEPT
		if (events.lNetworkEvents & FD_ACCEPT)
		{
			if (events.iErrorCode[FD_ACCEPT_BIT] == 0)
				pThis->OnAccept();  //连接上.
			else
			{
				break;
			}
		}

	} // while....

	return NULL;
}

服务器端工作者线程

/************************************************************************/
/* 
函数类型:线程函数
函数功能:工作者线程
*/
/************************************************************************/
DWORD WINAPI NetEngineServer::ThreadFunc( LPVOID lPvoid )
{
	ULONG ulFlags = MSG_PARTIAL;
	NetEngineServer* pThis = reinterpret_cast<NetEngineServer*>(lPvoid);
	
	HANDLE hCompletionPort = pThis->m_hCompletionPort;
	
	DWORD			dwIoSize;
	LPOVERLAPPED	lpOverlapped;
	ClientContext*	lpClientContext;
	OVERLAPPEDPLUS*	pOverlapPlus;
	BOOL			bError;
	BOOL			bEnterRead;

	InterlockedIncrement(&pThis->m_nCurrentThreads);
	InterlockedIncrement(&pThis->m_nBusyThreads);

	for (BOOL bStayInPool = TRUE; bStayInPool && pThis->m_bTimeToKill == false; ) 
	{
		pOverlapPlus	= NULL;
		lpClientContext = NULL;
		bError			= false;
		bEnterRead		= false;
		// Thread is Block waiting for IO completion
		InterlockedDecrement(&pThis->m_nBusyThreads);


		// Get a completed IO request.  调用成功返回非零
		BOOL bIORet = GetQueuedCompletionStatus(hCompletionPort,
												&dwIoSize,
												(LPDWORD) &lpClientContext,
												&lpOverlapped, INFINITE);

		DWORD dwIOError = GetLastError();
		pOverlapPlus = CONTAINING_RECORD(lpOverlapped, OVERLAPPEDPLUS, m_ol);


		int nBusyThreads = InterlockedIncrement(&pThis->m_nBusyThreads);

		if (!bIORet && dwIOError != WAIT_TIMEOUT )  //调用GetQueuedCompletionStatus不成功返回0  而失败原因不是超时
		{
			if (lpClientContext && pThis->m_bTimeToKill == false)	
			{
				pThis->RemoveStaleClient(lpClientContext, FALSE);
			}
			continue;

			// anyway, this was an error and we should exit
			bError = true;
		}

		if (!bError)		//过程中没有发生错误
		{
			// Allocate another thread to the thread Pool?
			if (nBusyThreads == pThis->m_nCurrentThreads)
			{
				if (nBusyThreads < pThis->m_nThreadPoolMax)
				{
					if (pThis->m_cpu.GetUsage() > pThis->m_nCPUHiThreshold)
					{
						UINT nThreadID = -1;
					}
				}
			}
			
			// Thread timed out - IDLE?
			if (!bIORet && dwIOError == WAIT_TIMEOUT) 
			{
				if (lpClientContext == NULL)
				{
					if (pThis->m_cpu.GetUsage() < pThis->m_nCPULoThreshold)
					{
						// Thread has no outstanding IO - Server hasn't much to do so die
						if (pThis->m_nCurrentThreads > pThis->m_nThreadPoolMin)
							bStayInPool =  FALSE;
					}

					bError = true;
				}
			}
		}
	
		//这里开始处理接收到的数据
		if (!bError)
		{
			if(bIORet && NULL != pOverlapPlus && NULL != lpClientContext) 
			{
				try
				{
					pThis->ProcessIOMessage(pOverlapPlus->m_ioType, lpClientContext, dwIoSize);
				}
				catch (...) {}
			}
		}

		if(pOverlapPlus)
			delete pOverlapPlus; // from previous call
	}

	InterlockedDecrement(&pThis->m_nWorkerCnt);

	InterlockedDecrement(&pThis->m_nCurrentThreads);
	InterlockedDecrement(&pThis->m_nBusyThreads);
	return 0;
}