关于WSAWaitForMultipleEvents的奇怪问题-CSDN论坛

关于WSAWaitForMultipleEvents的奇怪问题

VC/MFC > 网络编程

收藏回复

[问题点数：100分，结帖人udknight]

⋅TransmitFile文件发送虚拟内存占用过大的问题 ⋅很神奇的图片 ⋅关于WSAWaitForMultipleEvents的奇怪问题 更多帖子 关注私信空间博客 udknight 等级 本版专家分：1932 结帖率 100%: 近来想学学网络编程，就修改了网络流传的一个IOCP封装类编写了一个服务器框架。奇怪的是无法接受客户端的连接请求。我一步一步排查。发现出错地址在这：
unsigned __stdcall NetCompletionPort::AcceptThreadFun(LPVOID param)
{
OutputDebugString("NetCompletionPort::AcceptThreadFun(LPVOID param)");
NetCompletionPort* p = (NetCompletionPort*)param;

DWORD dwRet = 0;
while(p->m_isCreate)
{
OutputDebugString("进行AcceptThreadFun 循环");
if (!p->m_isCreate)
break;
OutputDebugString("before WSAWaitForMultipleEvents");
dwRet = ::WSAWaitForMultipleEvents(1,
        &(p->m_hEventListen),
        FALSE,
        100,
        FALSE);

if (WSA_WAIT_TIMEOUT == dwRet)
{
OutputDebugString("WSAWaitForMultipleEvents WSA_WAIT_TIMEOUT");
continue;
}

WSANETWORKEVENTS WSAEvents;
dwRet = WSAEnumNetworkEvents(p->m_listenSocket,                                                p->m_hEventListen,
&WSAEvents);

if (SOCKET_ERROR == dwRet)
break;

if ((WSAEvents.lNetworkEvents & FD_ACCEPT) && (0 == WSAEvents.iErrorCode[FD_ACCEPT_BIT]))
{
OutputDebugString("PostAcceptEx");
if(!p->PostAcceptEx())
return FALSE;
else
return TRUE;
}

}
return TRUE;
}

当客户端发出连接请求后，WSAWaitForMultipleEvents还是会返回WSA_WAIT_TIMEOUT ，而不会执行到下面的PostAcceptEx（）函数。

2009-06-11 13:57:50

点赞只看楼主引用举报楼主收起

展开阅读全文

⋅TransmitFile文件发送虚拟内存占用过大的问题 ⋅很神奇的图片 ⋅关于WSAWaitForMultipleEvents的奇怪问题 更多帖子 关注私信空间博客 udknight 等级 本版专家分：1932

下面是NetCompletionPort类的代码
NetCompletionPort.h 代码



#ifndef _COMPLETIONPORT_H

#define _COMPLETIONPORT_H



#include <winsock2.h>

#include <mswsock.h>

#include <process.h>

#include <vector>

#include <map>

#include <deque>

#include <set>

#pragma comment (lib,"ws2_32.lib")



#define MAX_MEM_COUNT   1000

#define MAX_BUF         1024

#define RECV_COUNT      5



#pragma pack (push)

#pragma pack (1)



enum

{

	IO_ACCEPT,

	IO_READ,

	IO_WRITE,

	IO_END,

};



enum

{ 

	IO_SEND,

	IO_RECV

};





//单IO数据

typedef struct _PER_IO_CONTEXT

{

	WSAOVERLAPPED ol;

	char buf[MAX_BUF];

	WSABUF wsabuf;

	SOCKET sClient;

	DWORD id;

	BYTE IoOperation;

}PER_IO_CONTEXT,*LPPER_IO_CONTEXT;



//完成键（单句炳数据）

typedef struct _PER_HANDLE_CONTEXT

{

	SOCKET IoSocket;



}PER_HANDLE_CONTEXT,*LPPER_HANDLE_CONTEXT;



static GUID g_GUIDAcceptEx             = WSAID_ACCEPTEX;

static GUID g_GUIDGetAcceptExSockaddrs = WSAID_GETACCEPTEXSOCKADDRS;



class WorkThread

{

private:

	HANDLE m_hThread;

	unsigned int  m_nThreadID;

	unsigned int (__stdcall*pnThreadFun)(LPVOID param);

	void* m_pParam;

public:

	WorkThread();

	WorkThread(unsigned int (__stdcall*pnThreadFun)(LPVOID param),void* param);

	~WorkThread();

	bool Init();

	void Start();

	void Stop();

	void SendMessage(UINT Msg, WPARAM wParam, LPARAM lParam);

	void SetPriority(int priority);

};



class NetClient 

{

public:

	SOCKET m_socket;

	SOCKADDR_IN m_address;

	LPPER_HANDLE_CONTEXT m_pComKey;

	NetClient();

	NetClient(int socket);

	~NetClient();

	void SendPacket(void* pData,bool encrypt = TRUE);

	void Disconnect();

};







class NetCompletionPort

{

private:

	LPFN_ACCEPTEX m_pAcceptEx;

	LPFN_GETACCEPTEXSOCKADDRS m_pGetAcceptExSockaddrs;

	HANDLE m_comPort;

	int    m_port;

	SOCKET m_listenSocket;

	WSAEVENT m_hEventListen;

	bool m_isCreate;



	std::vector<WorkThread*>* m_pWorkThreadList;

	WorkThread* m_pThreadAccept;



	bool InitWinSock();

	bool InitListenSocket();

	bool InitListenEvent();

	bool InitWorkThread();

	

	std::map<int,NetClient*>* m_pClientList;

	CRITICAL_SECTION m_clientListSection;

	void DeleteClient(NetClient* pClient);

	void AddClient(NetClient* pClient);

	NetClient* GetClient(int socket);

	

	std::set<LPPER_IO_CONTEXT>* m_pConnectList;

	CRITICAL_SECTION m_conSection;

	void InsertConnect(LPPER_IO_CONTEXT pConnect);

	void ReleaseConnect(int socket);

	

	std::deque<LPPER_IO_CONTEXT>* m_pIoMemList;

	std::deque<LPPER_HANDLE_CONTEXT>* m_pHandleMemList;

	CRITICAL_SECTION m_ioMenListSection;

	CRITICAL_SECTION m_hdMemListSection;

	LPPER_IO_CONTEXT GetIoMem();

	LPPER_HANDLE_CONTEXT GetHandleMem();

	void InsertIoMem(LPPER_IO_CONTEXT pMem);

	void InsertHandleMem(LPPER_HANDLE_CONTEXT pMem);



	bool PostAcceptEx();

	

protected:

public:

	NetCompletionPort();

	virtual ~NetCompletionPort();

	bool StartServer(int port);

	void StopServer();



	virtual bool Disconnect(int socket);

	void SendPacket(int socket,void * pData,bool encrypt = TRUE);

	virtual void EncryptPacket(void * pData,int & length,BYTE type,bool encrypt = TRUE);

	virtual void RecvData(void * pData,NetClient* pClient);

	

	void AcceptEvent(LPPER_IO_CONTEXT pIo,LPPER_HANDLE_CONTEXT pHd,DWORD dwByte);

	void SendEvent(LPPER_IO_CONTEXT pIo,LPPER_HANDLE_CONTEXT pHd,DWORD dwByte);

	void RecvEvent(LPPER_IO_CONTEXT pIo,LPPER_HANDLE_CONTEXT pHd,DWORD dwByte);

	void CloseEvent(LPPER_IO_CONTEXT pIo,LPPER_HANDLE_CONTEXT pHd);



	static unsigned __stdcall WorkThreadFun(LPVOID param);

	static unsigned __stdcall AcceptThreadFun(LPVOID param);

	

};



#pragma pack (pop)



#endif

2009-06-11 13:59:12

点赞只看TA 引用举报 #1得分 0

NetCompletionPort.cpp 代码上



#include "stdafx.h"

#include "NetCompletionPort.h"

#include <ws2tcpip.h>



/////////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////WorkThrerd



NetCompletionPort* g_pHostServer = NULL;



WorkThread::WorkThread()

{

	OutputDebugString("WorkThread::WorkThread()");

	m_hThread = NULL;

	m_nThreadID = 0;

	pnThreadFun = NULL;

	m_pParam = NULL;

}



WorkThread::WorkThread(unsigned int (__stdcall*pnThreadFun)(LPVOID param),void* param)

{

	OutputDebugString("WorkThread::WorkThread(unsigned int (__stdcall*pnThreadFun)(LPVOID param),void* param)");

	m_hThread = NULL;

	m_nThreadID = 0;

	this->pnThreadFun = pnThreadFun;

	m_pParam = param;

}



WorkThread::~WorkThread()

{

}



bool WorkThread::Init()

{

	OutputDebugString("WorkThread::Init()");

	m_hThread = (HANDLE)_beginthreadex(NULL,0,pnThreadFun,m_pParam,CREATE_SUSPENDED,&m_nThreadID);//CREATE_SUSPENDED

	if(m_hThread)

		return TRUE;

	return FALSE;

}



void WorkThread::Start()

{

	OutputDebugString("WorkThread::Start()");

	if(m_hThread)

		ResumeThread(m_hThread);	

}



void WorkThread::Stop()

{	

	OutputDebugString("WorkThread::Stop()");

	if (m_hThread)

	{

		DWORD code;

		int count = 0;

		while(TRUE)

		{

			if(count++ >= 5)

			{

				TerminateThread(m_hThread,0);

				break;

			}

			GetExitCodeThread(m_hThread,&code);

			if(code == STILL_ACTIVE)

			{

				Sleep(1000);

				continue;

			}

			else

				break;

		}

		CloseHandle(m_hThread);

		m_hThread = NULL;

	}

}



void WorkThread::SendMessage(UINT Msg, WPARAM wParam, LPARAM lParam)

{

	OutputDebugString("WorkThread::SendMessage()");

	if (m_hThread)

		PostThreadMessage(m_nThreadID, Msg, wParam, lParam);

}



void WorkThread::SetPriority(int priority)

{

	OutputDebugString("WorkThread::SetPriority()");

	if (m_hThread)

		SetThreadPriority(m_hThread, priority);

}



/////////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////NetClient



NetClient::NetClient()

{

	m_socket = NULL;

	m_pComKey = NULL;

}



NetClient::NetClient(int socket)

{

	m_socket = socket;

}



NetClient::~NetClient()

{

	if(m_socket)

		closesocket(m_socket);

}



void NetClient::SendPacket(void* pData,bool encrypt)

{

	g_pHostServer->SendPacket(m_socket,pData,encrypt);

}



void NetClient::Disconnect()

{

	if(m_socket)

	{

		closesocket(m_socket);

		m_socket = NULL;

	}

}

2009-06-11 14:01:50

点赞只看TA 引用举报 #2得分 0

NetCompletionPort.cpp 代码中



/////////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////NetCompletionPort



NetCompletionPort::NetCompletionPort()

{

	OutputDebugString("NetCompletionPort::NetCompletionPort()");

	g_pHostServer = this;

	m_pAcceptEx = NULL;

	m_comPort = NULL;

	m_port = 0;

	m_listenSocket = NULL;

	m_hEventListen = NULL;

	m_isCreate = FALSE;

	

	m_pWorkThreadList = new std::vector<WorkThread*>;

	m_pThreadAccept = NULL;

	m_pClientList = new std::map<int,NetClient*>;

	m_pConnectList = new std::set<LPPER_IO_CONTEXT>;

	m_pIoMemList = new std::deque<LPPER_IO_CONTEXT>;

	m_pHandleMemList = new std::deque<LPPER_HANDLE_CONTEXT>;



	m_pClientList->clear();

	m_pConnectList->clear();

	m_pIoMemList->clear();

	m_pHandleMemList->clear();

	

	InitializeCriticalSection(&m_clientListSection); 

	InitializeCriticalSection(&m_conSection); 

	InitializeCriticalSection(&m_ioMenListSection); 

	InitializeCriticalSection(&m_hdMemListSection); 

}



NetCompletionPort::~NetCompletionPort()

{

	OutputDebugString("NetCompletionPort::~NetCompletionPort()");

//	NetCompletionPort::StopServer();

	delete m_pClientList;

	delete m_pConnectList;

	delete m_pIoMemList;

	delete m_pHandleMemList;



	DeleteCriticalSection(&m_clientListSection);

	DeleteCriticalSection(&m_conSection);

	DeleteCriticalSection(&m_ioMenListSection);

	DeleteCriticalSection(&m_hdMemListSection);

}



bool NetCompletionPort::StartServer(int port)

{

	OutputDebugString("NetCompletionPort::StartServer()");

	WSADATA m_wsaData;

	m_port = port;

	if(WSAStartup(MAKEWORD(2,2), &m_wsaData))

		return FALSE;

	if(InitWinSock() && InitListenSocket() && InitListenEvent() && InitWorkThread())

	{

		m_isCreate = TRUE;



		//将挂起的工作线程和接受线程都启动

		m_pThreadAccept->Start();

		std::vector<WorkThread*>::iterator pos = m_pWorkThreadList->begin();

		while (pos != m_pWorkThreadList->end())

		{

			(*pos)->Start();

			pos++;

		}

	}

	else

	{

		StopServer();

		return FALSE;

	}

	return TRUE;

}



bool NetCompletionPort::InitWinSock()

{

	OutputDebugString("NetCompletionPort::InitWinSock()");

	m_comPort = CreateIoCompletionPort(INVALID_HANDLE_VALUE,NULL,0,0);

	if(!m_comPort)

		return FALSE;

	SYSTEM_INFO sysInfo;

	GetSystemInfo(&sysInfo);

	for(int i=0;i<(sysInfo.dwNumberOfProcessors*2+2);i++)

	{

		WorkThread* pThread = new WorkThread(&WorkThreadFun,this);

		if(pThread->Init())

			m_pWorkThreadList->push_back(pThread);

		else

		{

			delete pThread;

			return FALSE;

		}

	}

	return TRUE;

}



bool NetCompletionPort::InitListenSocket()

{

	OutputDebugString("NetCompletionPort::InitListenSocket()");

	m_listenSocket = WSASocket(AF_INET,

							   SOCK_STREAM,

							   0,

							   NULL,

							   0,

							   WSA_FLAG_OVERLAPPED);



	if(INVALID_SOCKET == m_listenSocket)

	{

		m_listenSocket = NULL;

		return FALSE;

	}

	if(!CreateIoCompletionPort((HANDLE)m_listenSocket,m_comPort,0,0))

		return FALSE;

	

	SOCKADDR_IN SockAddr;

	ZeroMemory((char*)&SockAddr,sizeof(SOCKADDR_IN));

	SockAddr.sin_family       = AF_INET;

	SockAddr.sin_port         = htons(m_port);

	SockAddr.sin_addr.s_addr  = INADDR_ANY;

	if(SOCKET_ERROR == bind(m_listenSocket,(PSOCKADDR)&SockAddr,sizeof(SockAddr)))

		return FALSE;

	if(SOCKET_ERROR == listen(m_listenSocket,SOMAXCONN))

		return FALSE;



	DWORD dwTemp=0;

	if(SOCKET_ERROR == WSAIoctl(m_listenSocket,SIO_GET_EXTENSION_FUNCTION_POINTER,

		&g_GUIDAcceptEx,sizeof(g_GUIDAcceptEx),&m_pAcceptEx,sizeof(m_pAcceptEx),

		&dwTemp,NULL,NULL))

	{

		m_pAcceptEx = NULL;

		return FALSE;

	}

	if(SOCKET_ERROR == WSAIoctl(m_listenSocket,SIO_GET_EXTENSION_FUNCTION_POINTER,

		&g_GUIDGetAcceptExSockaddrs,sizeof(g_GUIDGetAcceptExSockaddrs),&m_pGetAcceptExSockaddrs,sizeof(m_pGetAcceptExSockaddrs),

		&dwTemp,NULL,NULL))

	{

		m_pGetAcceptExSockaddrs = NULL;

		return FALSE;

	}

	

	return TRUE;

}



bool NetCompletionPort::InitListenEvent()

{

	OutputDebugString("NetCompletionPort::InitListenEvent()");

	m_hEventListen = WSACreateEvent();

	if(WSA_INVALID_EVENT == m_hEventListen)

		return FALSE;

	if(SOCKET_ERROR == WSAEventSelect(m_listenSocket,m_hEventListen,FD_ACCEPT))

		return FALSE;

	return TRUE;

}



bool NetCompletionPort::InitWorkThread()

{

	OutputDebugString("NetCompletionPort::InitWorkThread()");

	m_pThreadAccept = new WorkThread(AcceptThreadFun,this);

	if(!m_pThreadAccept->Init())

	{

		delete m_pThreadAccept;

		return FALSE;

	}

	return TRUE;

}



void NetCompletionPort::StopServer()

{

	OutputDebugString("NetCompletionPort::StopServer()");

	m_isCreate = FALSE;

	if(m_comPort)

	{

		PostQueuedCompletionStatus(m_comPort,0,0,NULL);

        CloseHandle(m_comPort);

		m_comPort = NULL;

	}

	if(m_pThreadAccept != NULL)

	{

		m_pThreadAccept->Stop();

		delete m_pThreadAccept;

		m_pThreadAccept = NULL;

	}

	std::vector<WorkThread*>::iterator pos = m_pWorkThreadList->begin();

	while (pos != m_pWorkThreadList->end())

	{

		(*pos)->Stop();

		delete (*pos);

		pos++;

	}

	m_pWorkThreadList->clear();

	if(m_listenSocket != NULL)

	{

		closesocket(m_listenSocket);

		m_listenSocket = NULL;

	}

	if(m_hEventListen != NULL)

	{

		CloseHandle(m_hEventListen);

		m_hEventListen = NULL;

	}

	std::map<int,NetClient*>::iterator pos1 = m_pClientList->begin();

	while(pos1 != m_pClientList->end())

	{

		NetClient* pClient = pos1->second;

		pClient->Disconnect();

		InsertHandleMem(pClient->m_pComKey);

		delete pClient;

		pos1++;

	}

	m_pClientList->clear();

	std::set<LPPER_IO_CONTEXT>::iterator pos2 = m_pConnectList->begin();

	while(pos2 != m_pConnectList->end())

	{

		free(*pos);

		pos2++;

	}

	m_pConnectList->clear();

	std::deque<LPPER_IO_CONTEXT>::iterator pos3 = m_pIoMemList->begin();

	while(pos3 != m_pIoMemList->end())

	{

		free(*pos3);

		pos3++;

	}

	m_pIoMemList->clear();

	std::deque<LPPER_HANDLE_CONTEXT>::iterator pos4 = m_pHandleMemList->begin();

	while(pos4 != m_pHandleMemList->end())

	{

		free(*pos4);

		pos4++;

	}

	m_pHandleMemList->clear();

	WSACleanup();

}



void NetCompletionPort::DeleteClient(NetClient* pClient)

{

	OutputDebugString("NetCompletionPort::DeleteClient(NetClient* pClient)");

	if(pClient == NULL)

		return;

	EnterCriticalSection(&m_clientListSection);

	std::map<int,NetClient*>::iterator pos = m_pClientList->find(pClient->m_socket);

	if(pos != m_pClientList->end())

	{

		NetClient* pClient = pos->second;

		pClient->Disconnect();

		InsertHandleMem(pClient->m_pComKey);

		delete pClient;

		m_pClientList->erase(pClient->m_socket);

	}

	LeaveCriticalSection(&m_clientListSection);	

}



void NetCompletionPort::AddClient(NetClient* pClient)

{

	OutputDebugString("NetCompletionPort::AddClient(NetClient* pClient)");

	if(pClient == NULL)

		return;

	EnterCriticalSection(&m_clientListSection);

	m_pClientList->insert(std::make_pair(pClient->m_socket,pClient));

	LeaveCriticalSection(&m_clientListSection);	

}



NetClient* NetCompletionPort::GetClient(int socket)

{

	OutputDebugString("NetCompletionPort::GetClient(int socket)");

	NetClient* pClient = NULL;

	EnterCriticalSection(&m_clientListSection);

	std::map<int,NetClient*>::iterator pos = m_pClientList->find(socket);

	if(pos != m_pClientList->end())

		pClient = pos->second;

	LeaveCriticalSection(&m_clientListSection);	

	return pClient;

}



void NetCompletionPort::InsertConnect(LPPER_IO_CONTEXT pConnect)

{

	OutputDebugString("NetCompletionPort::InsertConnect(LPPER_IO_CONTEXT pConnect)");

	if(pConnect != NULL)

	{

		EnterCriticalSection(&m_conSection);

		m_pConnectList->insert(pConnect);

		LeaveCriticalSection(&m_conSection);	

	}

}



void NetCompletionPort::ReleaseConnect(int socket)

{

	OutputDebugString("NetCompletionPort::ReleaseConnect(int socket)");

	EnterCriticalSection(&m_conSection);

	std::set<LPPER_IO_CONTEXT>::iterator pos = m_pConnectList->begin();

	while (pos != m_pConnectList->end())

	{

		if((*pos)->sClient == socket)

		{

			m_pConnectList->erase(pos);

			break;

		}

		pos++;

	}

	LeaveCriticalSection(&m_conSection);

}



LPPER_IO_CONTEXT NetCompletionPort::GetIoMem()

{

	OutputDebugString("NetCompletionPort::GetIoMem()");

	LPPER_IO_CONTEXT pData = NULL;

	EnterCriticalSection(&m_ioMenListSection);

	if(m_pIoMemList->size() > 0)

	{

		pData = m_pIoMemList->front();

		m_pIoMemList->pop_front();

	}

	else

	{

		pData = (LPPER_IO_CONTEXT)malloc(sizeof(PER_IO_CONTEXT));

	}

	LeaveCriticalSection(&m_ioMenListSection);	

	memset(pData,0,sizeof(PER_IO_CONTEXT));

	return pData;

}



LPPER_HANDLE_CONTEXT NetCompletionPort::GetHandleMem()

{

	OutputDebugString("NetCompletionPort::GetHandleMem()");

	LPPER_HANDLE_CONTEXT pData = NULL;

	EnterCriticalSection(&m_hdMemListSection);

	if(m_pHandleMemList->size() > 0)

	{

		pData = m_pHandleMemList->front();

		m_pHandleMemList->pop_front();

	}

	else

	{

		pData = (LPPER_HANDLE_CONTEXT)malloc(sizeof(PER_HANDLE_CONTEXT));

	}

	LeaveCriticalSection(&m_hdMemListSection);	

	memset(pData,0,sizeof(PER_HANDLE_CONTEXT));

	return pData;

}



void NetCompletionPort::InsertIoMem(LPPER_IO_CONTEXT pMem)

{

	OutputDebugString("NetCompletionPort::InsertIoMem(LPPER_IO_CONTEXT pMem)");

	EnterCriticalSection(&m_ioMenListSection);

	if(m_pIoMemList->size() < MAX_MEM_COUNT)

		m_pIoMemList->push_back(pMem);

	else

		free(pMem);

	LeaveCriticalSection(&m_ioMenListSection);	

}



void NetCompletionPort::InsertHandleMem(LPPER_HANDLE_CONTEXT pMem)

{

	OutputDebugString("NetCompletionPort::InsertHandleMem(LPPER_HANDLE_CONTEXT pMem)");

	EnterCriticalSection(&m_hdMemListSection);

	if(m_pHandleMemList->size() < MAX_MEM_COUNT)

		m_pHandleMemList->push_back(pMem);

	else

		free(pMem);

	LeaveCriticalSection(&m_hdMemListSection);	

}

2009-06-11 14:04:13

点赞只看TA 引用举报 #3得分 0

⋅fopen打开文件异常的问题 ⋅如何给客户端分配一个唯一的ID ⋅求一个封装过的IOCP完成端口类 更多帖子 关注私信空间博客 IGAWhoyo 等级 本版专家分：0

NetCompletionPort.cpp 代码下



bool NetCompletionPort::PostAcceptEx()

{

	OutputDebugString("NetCompletionPort::PostAcceptEx()");

	SOCKET socketAcp = WSASocket(PF_INET,SOCK_STREAM,IPPROTO_TCP,NULL,0,WSA_FLAG_OVERLAPPED);

	if(INVALID_SOCKET == socketAcp)

		return FALSE;

	LPPER_IO_CONTEXT temp = GetIoMem();

	temp->IoOperation = IO_ACCEPT;

	temp->sClient = socketAcp;

	temp->id = socketAcp;

	temp->wsabuf.len = MAX_BUF;

	DWORD dwByte;

	if(!m_pAcceptEx(m_listenSocket,socketAcp,temp->buf,MAX_BUF-((sizeof(SOCKADDR_IN)+16)*2),

		sizeof(SOCKADDR_IN)+16,sizeof(SOCKADDR_IN)+16,&dwByte,&temp->ol))

	{

		if(ERROR_IO_PENDING != WSAGetLastError())

		{

			::closesocket(socketAcp);

			InsertIoMem(temp);

			return FALSE;

		}

	}

	return TRUE;

}



bool NetCompletionPort::Disconnect(int socket)

{

	OutputDebugString("NetCompletionPort::Disconnect(int socket)");

	bool rlt = FALSE;

	EnterCriticalSection(&m_clientListSection);

	std::map<int,NetClient*>::iterator pos = m_pClientList->find(socket);

	if(pos != m_pClientList->end())

	{

		NetClient* pClient = pos->second;

		pClient->Disconnect();

		InsertHandleMem(pClient->m_pComKey);

		delete pClient;

		m_pClientList->erase(socket);

		rlt = TRUE;

	}

	LeaveCriticalSection(&m_clientListSection);	

	return rlt;

}



void NetCompletionPort::SendPacket(int socket,void * pData,bool encrypt)

{

	OutputDebugString("NetCompletionPort::SendPacket(int socket,void * pData,bool encrypt)");

	DWORD SendBytes,Flags;

	Flags = 0;

	int length = 0;

	EncryptPacket(pData,length,IO_SEND,encrypt);

	if(length > MAX_BUF)

		return;

	LPPER_IO_CONTEXT pIoMem = GetIoMem();

	pIoMem->IoOperation = IO_WRITE;

	pIoMem->sClient = socket;

	pIoMem->id = socket;

	memset(pIoMem->buf,0,MAX_BUF);

	pIoMem->wsabuf.buf = pIoMem->buf;

	pIoMem->wsabuf.len = MAX_BUF;

	memset(&(pIoMem->ol),0,sizeof(WSAOVERLAPPED));

	memcpy(pIoMem->buf,pData,length);

	WSASend(socket,&pIoMem->wsabuf,1,&SendBytes,Flags,&(pIoMem->ol),NULL);

	EncryptPacket(pData,length,IO_SEND,encrypt);

}



void NetCompletionPort::EncryptPacket(void * pData,int & length,BYTE type,bool encrypt)

{

}



void NetCompletionPort::RecvData(void * pData,NetClient* pClient)

{

}



void NetCompletionPort::AcceptEvent(LPPER_IO_CONTEXT pIo,LPPER_HANDLE_CONTEXT pHd,DWORD dwByte)

{

	OutputDebugString("NetCompletionPort::AcceptEvent(LPPER_IO_CONTEXT pIo,LPPER_HANDLE_CONTEXT pHd,DWORD dwByte)");

	DWORD flag = 0;

	DWORD dwRecv = 0;

	DWORD ret = 0;

	NetClient* pClient = new NetClient(pHd->IoSocket);

	pClient->m_pComKey = pHd;		

	AddClient(pClient);

	int count = 0;

	while(count < (RECV_COUNT - 1))

	{

		LPPER_IO_CONTEXT p = GetIoMem();

		memset(p,0,sizeof(PER_IO_CONTEXT));

		p->sClient = pIo->sClient;

		p->id = pIo->id;

		p->wsabuf.buf = p->buf;

		p->wsabuf.len = MAX_BUF;

		p->IoOperation = IO_READ;

		ret = WSARecv(pHd->IoSocket,&(p->wsabuf),1,&dwRecv,&flag,&(p->ol),NULL);

		if(SOCKET_ERROR == ret)

		{

			if(WSA_IO_PENDING != WSAGetLastError())

			{

				Disconnect(pHd->IoSocket);

				InsertIoMem(pIo);

				return;

			}

		}	

		count++;

	}

	if(dwByte > 0)

	{

		SOCKADDR * lpLocalSockaddr = NULL,* lpRemoteSockaddr = NULL;

		int LocalSockAddrLen = 0,RemoteSockaddrLen = 0;

		m_pGetAcceptExSockaddrs(pIo->buf,pIo->wsabuf.len - ((sizeof(SOCKADDR_IN) + 16)*2),

			  sizeof(SOCKADDR_IN) + 16,sizeof(SOCKADDR_IN) + 16,&lpLocalSockaddr,&LocalSockAddrLen,

			  &lpRemoteSockaddr,&RemoteSockaddrLen);

		if(lpRemoteSockaddr != NULL)

			memcpy(&pClient->m_address,lpRemoteSockaddr,sizeof(SOCKADDR_IN));

		RecvData(pIo->buf,pClient);

	}

	memset(pIo->buf,0,MAX_BUF);

	memset(&(pIo->ol),0,sizeof(WSAOVERLAPPED));

	pIo->wsabuf.buf = pIo->buf;

	pIo->wsabuf.len = MAX_BUF;

	pIo->IoOperation = IO_READ;

	ret = WSARecv(pHd->IoSocket,&(pIo->wsabuf),1,&dwRecv,&flag,&(pIo->ol),NULL);

	if(SOCKET_ERROR == ret)

	{

		if(WSA_IO_PENDING != WSAGetLastError())

		{

			Disconnect(pHd->IoSocket);

			InsertIoMem(pIo);

			return;

		}

	}	

}



void NetCompletionPort::SendEvent(LPPER_IO_CONTEXT pIo,LPPER_HANDLE_CONTEXT pHd,DWORD dwByte)

{

	OutputDebugString("NetCompletionPort::SendEvent(LPPER_IO_CONTEXT pIo,LPPER_HANDLE_CONTEXT pHd,DWORD dwByte)");

	if(dwByte < 0)

	{

		InsertIoMem(pIo);

		Disconnect(pHd->IoSocket);

	}

	else

		InsertIoMem(pIo);

}



void NetCompletionPort::RecvEvent(LPPER_IO_CONTEXT pIo,LPPER_HANDLE_CONTEXT pHd,DWORD dwByte)

{

	OutputDebugString("NetCompletionPort::RecvEvent(LPPER_IO_CONTEXT pIo,LPPER_HANDLE_CONTEXT pHd,DWORD dwByte)");

	if(dwByte < 0)

	{

		InsertIoMem(pIo);

		Disconnect(pHd->IoSocket);

	}

	else

	{

		RecvData(pIo->buf,GetClient(pHd->IoSocket));

		DWORD flag = 0;

		DWORD dwRecv = 0;

		DWORD ret = 0;

		memset(pIo->buf,0,MAX_BUF);

		memset(&(pIo->ol),0,sizeof(WSAOVERLAPPED));

		pIo->wsabuf.buf = pIo->buf;

		pIo->wsabuf.len = MAX_BUF;

		pIo->IoOperation = IO_READ;

		ret = WSARecv(pHd->IoSocket,&(pIo->wsabuf),1,&dwRecv,&flag,&(pIo->ol),NULL);

		if(SOCKET_ERROR == ret)

		{

			if(WSA_IO_PENDING != WSAGetLastError())

			{

				Disconnect(pHd->IoSocket);

				InsertIoMem(pIo);

				return;

			}

		}	

	}

}



void NetCompletionPort::CloseEvent(LPPER_IO_CONTEXT pIo,LPPER_HANDLE_CONTEXT pHd)

{

	OutputDebugString("NetCompletionPort::CloseEvent(LPPER_IO_CONTEXT pIo,LPPER_HANDLE_CONTEXT pHd)");

	Disconnect(pIo->sClient);

	InsertIoMem(pIo);

}



unsigned __stdcall NetCompletionPort::WorkThreadFun(LPVOID param)

{

	OutputDebugString("NetCompletionPort::WorkThreadFun(LPVOID param)");

	DWORD	dwByteSend					= 0;

	DWORD	dwByteRecv					= 0;

	DWORD	dwByteTrans					= 0;

	bool	flag						= FALSE;

	BOOL	bRet						= FALSE;

	BYTE	opType						= 0;



	NetCompletionPort* p				= (NetCompletionPort*)param;

	HANDLE	hComPort					= p->m_comPort;

	LPPER_IO_CONTEXT pIoData			= NULL;

	LPPER_HANDLE_CONTEXT pHandleData	= NULL;



	while(p->m_isCreate)

	{

		pIoData = NULL;

	    pHandleData = NULL;

		bRet = GetQueuedCompletionStatus(hComPort,

										&dwByteTrans,

										(LPDWORD)&pHandleData,

										(LPOVERLAPPED*)&pIoData,

										INFINITE);

		if(FALSE == bRet)

			continue;

		

		else if(pIoData == NULL)

			return FALSE;



		opType = pIoData->IoOperation;

		if(opType != IO_ACCEPT && dwByteTrans == 0)

		{

			p->Disconnect(pHandleData->IoSocket);

			p->InsertIoMem(pIoData);

			continue;

		}

		if(opType == IO_ACCEPT)

		{

			//释放节点

			p->ReleaseConnect((DWORD)pIoData->sClient);

			if(SOCKET_ERROR == setsockopt(p->m_listenSocket,SOL_SOCKET,SO_UPDATE_ACCEPT_CONTEXT,

				(char*)&(pIoData->sClient),sizeof(pIoData->sClient)))

			{

				::closesocket(pIoData->sClient);

				p->InsertIoMem(pIoData);

				continue;

			}

			else

			{

				//分配单句柄数据

				LPPER_HANDLE_CONTEXT pNeW = p->GetHandleMem();

				pNeW->IoSocket = pIoData->sClient;

				if(!CreateIoCompletionPort((HANDLE)pIoData->sClient,p->m_comPort,(DWORD)pNeW,0))

				{

					::closesocket(pIoData->sClient);

				    p->InsertIoMem(pIoData);

					p->InsertHandleMem(pNeW);

				    continue;

				}				

				p->AcceptEvent(pIoData,pNeW,dwByteTrans);				

			}

			continue;

		}

		else if(opType == IO_READ)

		{

			p->RecvEvent(pIoData,pHandleData,dwByteTrans);

			continue;

		}

		else if(opType == IO_WRITE)

		{

			p->SendEvent(pIoData,pHandleData,dwByteTrans);

			continue;

		}

		else

		{

			p->Disconnect(pHandleData->IoSocket);

			p->InsertIoMem(pIoData);

			continue;

		}

	}

	return 1;

}



unsigned __stdcall NetCompletionPort::AcceptThreadFun(LPVOID param)

{

	OutputDebugString("NetCompletionPort::AcceptThreadFun(LPVOID param)");

	NetCompletionPort* p = (NetCompletionPort*)param;

	

	DWORD dwRet = 0;

	while(p->m_isCreate)

	{

		OutputDebugString("进行AcceptThreadFun 循环");

		if (!p->m_isCreate)

			break;

		OutputDebugString("before WSAWaitForMultipleEvents");

		dwRet = ::WSAWaitForMultipleEvents(1,

										   &(p->m_hEventListen),

										   FALSE,

										   100,

										   FALSE);

	

		if (WSA_WAIT_TIMEOUT == dwRet)

		{

			OutputDebugString("WSAWaitForMultipleEvents WSA_WAIT_TIMEOUT");

			continue;

		}

			

		

		OutputDebugString("after WSAWaitForMultipleEvents");

		WSANETWORKEVENTS WSAEvents;

		dwRet = WSAEnumNetworkEvents(p->m_listenSocket,         //自动重置事件

									 p->m_hEventListen,

							         &WSAEvents);

		OutputDebugString("after WSAEnumNetworkEvents");

		if (SOCKET_ERROR == dwRet)

			break;

		

		OutputDebugString("Before PostAcceptEx");

		if ((WSAEvents.lNetworkEvents & FD_ACCEPT) && (0 == WSAEvents.iErrorCode[FD_ACCEPT_BIT]))

		{

			OutputDebugString("PostAcceptEx");

			if(!p->PostAcceptEx())

				return FALSE;

			else

				return TRUE;

		}

	

	}

	return TRUE;

}

2009-06-11 14:07:17

点赞只看TA 引用举报 #4得分 0

⋅fopen打开文件异常的问题 ⋅如何给客户端分配一个唯一的ID ⋅求一个封装过的IOCP完成端口类 更多帖子 关注私信空间博客 IGAWhoyo 等级 本版专家分：0: 我简单的调用了下

NetCompletionPort m_iocp;
m_iocp.StartServer(m_ServPort);

2009-06-11 14:09:12

点赞只看TA 引用举报 #5得分 0

⋅fopen打开文件异常的问题 ⋅如何给客户端分配一个唯一的ID ⋅求一个封装过的IOCP完成端口类 更多帖子 关注私信空间博客 IGAWhoyo 等级 本版专家分：0: UP

2009-06-11 14:28:51

点赞只看TA 引用举报 #6得分 0

⋅TransmitFile文件发送虚拟内存占用过大的问题 ⋅很神奇的图片 ⋅关于WSAWaitForMultipleEvents的奇怪问题 更多帖子 关注私信空间博客 udknight 等级 本版专家分：1932: up

2009-06-11 15:21:34

点赞只看TA 引用举报 #7得分 0

⋅TransmitFile文件发送虚拟内存占用过大的问题 ⋅很神奇的图片 ⋅关于WSAWaitForMultipleEvents的奇怪问题 更多帖子 关注私信空间博客 udknight 等级 本版专家分：1932: 代码贴的这么详细了。怎么没有人说句话呢？

2009-06-11 16:19:25

点赞只看TA 引用举报 #8得分 0

⋅ 貌似论坛处理白色字体有bug，其它正常，顺便散分 ⋅貌似论坛处理白色字体有bug，其它正常，顺便散分 ⋅北京的第一场雪 更多帖子 关注私信空间博客 Conry 等级 本版专家分：20779: 我这里测试没有问题
是不是客户端的问题
你可以用命令行的telnet试一下

telnet 127.0.0.1 你的端口

2009-06-11 16:39:23

点赞只看TA 引用举报 #9得分 100

⋅TransmitFile文件发送虚拟内存占用过大的问题 ⋅很神奇的图片 ⋅关于WSAWaitForMultipleEvents的奇怪问题 更多帖子 关注私信空间博客 udknight 等级 本版专家分：1932: 我用SocketTool测试的。连接不上去。

2009-06-11 16:46:53

点赞只看TA 引用举报 #10得分 0

1 2

收起

收藏回复

udknight

等级：

关注私信 TA的帖子

WSAWaitForMultipleEvents() .: 简述：只要指定事件对象中的一个或全部处于有信号状态，或者超时间...WSAWaitForMultipleEvents( DWORD cEvents, const WSAEVENTFAR * lphEvents, BOOL fWaitAll, DWORD dwTimeout, BOOL fAlertable ); c...

WSAWaitForMultipleEvents(): 简述：只要指定事件对象中的一个或全部处于有信号状态，...　#include DWORD WSAAPI WSAWaitForMultipleEvents( DWORD　cEvents,　const WSAEVENT FAR * lphEvents, BOOL fWaitAll,　DWORD dwTimeout,　BOOL fAlertab

WSAWaitForMultipleEvents Function: WSAWaitForMultipleEvents Function The WSAWaitForMultipleEvents function returns when one or all of the specified event objects are in the signaled state, when the time-out interval expires, or wh

WSAWaitForMultipleEvents等待非socket事件的问题: 今日写了一个小MFC程序，在创建一个对话框的同时创建一个线程，线程里同时等待对话框的close事件和socket的读事件，调用的等待函数是 WSAWaitForMultipleEvents，收到close事件后线程退出，对话框在OnClose响应函数...

WSAWaitForMultipleEvents的用法: // wsawaitformultipleeventsTest.cpp : 定义控制台应用程序的入口点。 // ...WSAWaitForMultipleEvents(4, EventArray, FALSE, WSA_INFINITE, FALSE); 其中，第一个参数为事件的个数。第二个参

Windows的异步通知I/O模型: 同步和异步直接百度一下应该还算很容易理解吧，虽然我一开始看这个同步和异步的时候也是疑惑了一下，觉得名字起的好奇怪啊。但是现在来看的话，名字起的还是意外的形象呢？有点迷。同步方法：调用一旦开始，调用...

Overlapped重叠I/O之事件通知: 在 Winsock 中，重叠 I/O（Overlapped I/O）模型能达到更佳的系统性能，高于select模型、异步选择和事件选择三种。重叠模型的基本设计原理便是让应用程序使用一个重叠的数据结构（WSAOVERLAPPED），一次投递一个...

关于同步、异步，阻塞、非阻塞的解释: 在windows socket api 下：异步方式指的是发送方不等接收方响应，便接着发下个数据包的通信方式；而同步指发送方发出数据后，等收到接收方发回的响应，才发下一个数据包的通信方式。阻塞套接字是指执行此套接字的...

基础: 各位兄弟，在SDK编程中如果实现...求助：通过编程DirectX抓屏------>masterz:再麻烦你一下，谢谢熟悉RichEdit的朋友过来看一下,RichEdit的几个问题.如何对 I/O 端口进行操作?有了该问题就有了思考（100分献礼！）如何

WinSock 异步I/O模型[4]---重叠 I/O - Overlapped I/O: 在 Winsock 中，重叠 I/O（Overlapped I/O）模型能达到更佳的系统性能，高于之前讲过的三种。因为它和这3种模型不同的是，使用重叠模型的应用程序通知缓冲区收发系统直接使用数据。也就是说，如果应用程序投递了一个...

一个TCP端口最多可以同时连接多少个客户端呢？: pp616 (傻小子) 2003-12-08 17:54:11 在...发现一个问题。服务器只能接受3900多个Client端再多了就Accept不了了。开始怀疑是服务器程序写的有问题。后来我打开本机的http服务和ftp服务。模拟Client去连接80 或是 21端

MFC 网络编程: 一、IP地址 IP地址用于表示网络上的各个不同主机的节点，就像家庭住址一样，邮递员通过家庭住址以决定将该信件投往何处。IP地址是一个32位的二进制数。 IP地址包含两部分：网络号和主机号，又称为前缀地址和后缀...

Winsock 编程学习小结: 初识 socket第一份工作实习期间，上头就给我下达了一个对我来说较有挑战性的任务——按照原来的设计要求实现一个网络传输组件。说它有挑战性，一是因为之前我从未涉及过网络编程，即使是在 DXTetris 中实现了联机...

WinSock编程(06)_重叠（overlapped）模型: 重叠（overlapped）模型　在 Winsock 中，重叠 I/O（Overlapped I/O）模型能达到更佳的系统性能，高于之前讲过的三种。重叠模型的基本设计原理便是让应用程序使用一个重叠的数据结构（WSAOVERLAPPED），一次投递...

重叠I/O之事件通知: 在 Winsock 中，重叠 I/O（Overlapped I/O）模型能达到更佳的系统性能，高于select模型、异步选择和事件选择三种。重叠模型的基本设计原理便是让应用程序使用一个重叠的数据结构（WSAOVERLAPPED），一次投递一个或...

io重叠模式: 在 Winsock 中，重叠 I/O（Overlapped I/O）模型能达到更佳的系统性能，高于select模型、异步选择和事件选择三种。重叠模型的基本设计原理便是让应用程序使用一个重叠的数据结构（WSAOVERLAPPED），一次投递一个或...

Overlapped I/O模型--事件通知【摘录自《Windows网络编程》】: 原文：... 重叠I / O的事件通知方法要求将Wi n 3 2事件对象与W S A O V E R L A P P E D结构关联在一起。若使用一个W S A O V E R L A P P E D结构，发出像W S A S e n d和W S A R e c v

重叠I/O（Overlapped I/O）: 重叠I/O（Overlapped I/O）　在 Winsock 中，重叠 I/O（Overlapped I/O）模型能达到更佳的系统性能，高于之前讲过的三种。重叠模型的基本设计原理便是让应用程序使用一个重叠的数据结构（WSAOVERLAPPED），一次投递...

Windows下异步IO模型详解: 1.选择模型1.1选择模型介绍选择（select）模型是Winsock中最常见的 I/O模型。核心便是利用 select 函数，实现对 I/O的管理。利用 select 函数来判断某Socket上是否有数据可读，或者能否向一个套接字写入数据，防止...

Winsock I/O 模型详解: Winsock共有五种类型的套接字I/O模型，可让Winsock应用程序对I/O进行管理，它们包括： select(选择)、WSAAsyncSelect(异步选择)、WSAEventSelect(事件选择)、overlapped(重叠)、以及completion port(完成端口)。...

Winsock I/O网络模型: Winsock共有五种类型的套接字I/O模型，可让Winsock应用程序对I/O进行管理，它们包括： select(选择)、WSAAsyncSelect(异步选择)、WSAEventSelect(事件选择)、overlapped(重叠)、以及completion port(完成端口)。...

CAsyncSocket及CSocket的区别和用法: 文章来源：http://blog.chinaunix.net/uid-20743151-id-326359.html

csocket和casyncsocket的区别: 微软的MFC把复杂的WinSock API函数封装到类里，这使得编写网络应用程序更容易。CAsyncSocket类逐个封装了WinSock API，为高级网络程序员提供了更加有力而灵活的方法。这个类基于程序员了解网络通讯的假设，目的是...

navicat简体中文版绿色版（64位）: 解压后安装navicat，打开navicat执行PatchNavicat即破解成功。可以正常使用啦。

MATLAB　2018a正式版【全平台官方包+图文教程+独创破解程序】: MATLAB R2018a 于16日正式发布，其中包含一系列 MATLAB/Simulink 的新功能和新产品，还包括 94 个其他产品的更新和修补程序。解压密码：CSDN 其他说明见：https://www.52pojie.cn/thread-713048-1-1.html

python实现扫描线填充算法，可以画凹多边形，采用matplotlib模块绘制图形: python实现扫描线填充算法，使用matplotlib模块将绘制的图形保存并画出来，可以画凹多边形

javaWeb图书馆管理系统源码mysql版本: 系统介绍图书馆管理系统主要的目的是实现图书馆的信息化管理。图书馆的主要业务就是新书的借阅和归还，因此系统最核心的功能便是实现图书的借阅和归还。此外，还需要提供图书的信息查询、读者图书借阅情况的查询等功能。项目实施后，能够提高图书馆的图书借阅、归还流程，提高工作效率。整个项目需要在两个月的时间内交付用户使用。操作注意事项（1）本系统的用户名为：tsoft，密码为：111 （2）读者类型不同，可借图书的本数也有所区别。操作流程（1）用户登录图书馆管理系统后，可看到图书借阅排行榜，通过排行榜可以看出借阅图书的名称、图书类型、借阅次数等相关信息。（2）单击“系统设置”/“图书馆信息”命令，对图书馆信息进行设置操作。（3）单击“系统设置”/“管理员设置”命令，对管理员信息进行添加、权限设置、查询及删除操作。（4）单击“系统设置”/“参数设置”命令，对办证费用及有效期限信息进行添加操作。（5）单击“系统设置”/“书架设置”命令，对书架信息进行添加、修改及删除操作。（6）单击“读者管理”/“读者类型管理”命令，对读者类型信息进行添加、修改及删除操作。（7）单击“读者管理”/“读者档案管理”命令，对读者信息进行添加、修改及删除操作。（8）单击“图书管理”/“图书类型设置”命令，对图书类型信息进行添加、修改及删除操作。（9）单击“图书管理”/“图书档案管理”命令，对图书信息进行添加、修改及删除操作。（10）单击“图书借还”/“图书借阅”命令，对图书借阅信息添加操作。（11）单击“图书借还”/“图书续借”命令，对图书续借信息进行添加操作。（12）单击“图书借还”/“图书归还”命令，对图书归还信息进行添加操作。（13）单击“系统查询”/“图书档案查询”命令，对图书档案信息进行查询操作。（14）单击“系统查询”/“图书借阅查询”命令，对借阅的图书信息进行查询操作。（15）单击“系统查询”/“借阅到期提醒”命令，对借阅到期提醒信息进行查询操作。（16）单击“更改口令”按钮，对当前的用户密码进行修改操作。（17）单击“退出系统”按钮，退出当前操作系统。

非常漂亮的100个前端案例: 非常漂亮的100个前端案例，包含幻灯片切换、图片缩放、相册、放大镜、图片拖着滚动等等，只有你想不到。

Office2016专业增强版中文免费正式版(附安装教程)64位: Microsoft office 2016专业增强版是一款由官方发布的Microsoft office办公软件，而且免费开放给所有Windows用户免费使用，其中Excel、word、PPT都非常智能化，界面最新加入暗黑主题，并且按钮的设计风格开始向Windows10靠拢。本平台提供Office 2016专业增强版，需要的朋友可下载试试！ Office 2016 专业增强版安装教程 1. 下载

vs 2017最新离线安装包（全功能完整版）: vs2017最新离线安装包，将官网文件整合成4个压缩包，包含所有组件的功能，安装过程无需联网。很方便。

相关热词 c#后台模拟鼠标点击 c# 不足两位加0 c#中银行存取款问题 c# p2p服务端 c# 工具数据校验 c#停止位1.5 c# java 通讯 c# 有没有list c#保存字体 c#登陆验证码