socketserver.cpp

这是我做的一个iocp的服务器端的测试代码

#include "StdAfx.h"
#include "SocketServer.h"

CSocketServer::CSocketServer(void)
:m_pcSocket(new CMySocket)
,m_pcClientManager(new ClientManager)
,m_pcIocp(new CIOCompletionPort)
,m_pcIEventNotify(NULL)
{
	
}

CSocketServer::~CSocketServer(void)
{ 
	if (m_pcSocket)
	{
		delete m_pcSocket;
		m_pcSocket = NULL;
	}

	if (m_pcClientManager )
	{
		delete m_pcClientManager;
		m_pcClientManager = NULL;
	}

	if (m_pcIocp )
	{
		delete m_pcIocp;
		m_pcIocp = NULL ;
	}
}

int CSocketServer::StartupListen()
{
	MYEXCEPTIONFUNC_START(); 
	  
    iRetCode= Start();
	if (iRetCode != 0 )
	{
		throw_NWException("Start CSocketServer Error");
	}
	MYEXCEPTIONFUNC_END("CSocketServer::Startup()");
}

void CSocketServer::StopListen()
{
     MYEXCEPTIONFUNC_START();
     iRetCode = Stop();
	 iRetCode = 0 ;
	 MYEXCEPTIONFUNC_NOREV_END("CSocketServer::Cleanup()");
}


int CSocketServer::Init()
{
	MYEXCEPTIONFUNC_START();
	WORD wVersionRequested = 0x202;

	if ( 0 != ::WSAStartup( wVersionRequested, &m_data ) )
	{
		throw_NWExceptionC("CUsesWinsock::CUsesWinsock()", ::WSAGetLastError() );
	}
	m_pcSocket->Attach(socket(AF_INET,SOCK_STREAM,0));

	m_pcSocket->Bind(m_usListenPort);

	m_pcSocket->Listen(5);

	m_hHaveAcceptEvent = WSACreateEvent();
	if (m_hHaveAcceptEvent == WSA_INVALID_EVENT)
	{	
		m_pcSocket->Close();
		throw_NWExceptionC("WSACreateEvent() error ", WSAGetLastError() );
	} 
	int nRet = WSAEventSelect(m_pcSocket->GetSocket(),
		m_hHaveAcceptEvent,
		FD_ACCEPT);

	if (nRet == SOCKET_ERROR)
	{
		m_pcSocket->Close();
        WSACloseEvent(m_hHaveAcceptEvent);   
		throw_NWExceptionC("WSAAsyncSelect() error: %s",WSAGetLastError());
	}
	m_bAcceptConnections = true ;
	iRetCode = 0 ;
	MYEXCEPTIONFUNC_END("CSocketServer::Init()");
}
//监听线程
int CSocketServer::Run()
{
    MYEXCEPTIONFUNC_START();
	HANDLE handlesToWaitFor[2];

	handlesToWaitFor[0] = m_hExitEvent;
	handlesToWaitFor[1] = m_hHaveAcceptEvent;
    WSANETWORKEVENTS events;
	while (m_bContinue)
	{
		DWORD waitResult = ::WaitForMultipleObjects( 2,
			handlesToWaitFor, 
			false, 
			INFINITE );
		if (waitResult == WAIT_TIMEOUT)
		{
			Trace("CSocketServer::Run::WaitForMultipleObjects timeout");
			continue ;
		}
		else if ( waitResult == WAIT_OBJECT_0 )
		{
			Trace("线程收倒退出事件");
			break;
		}
		else if (waitResult == WAIT_OBJECT_0 + 1)
		{
			MYEXCEPTIONFUNC_START();
			int nRet = WSAEnumNetworkEvents(m_pcSocket->GetSocket(),
				m_hHaveAcceptEvent,
				&events);
            
			if (nRet == SOCKET_ERROR)
			{
				throw_NWExceptionC("WSAEnumNetworkEvents error %d\n",WSAGetLastError());
			}
			if (events.lNetworkEvents & FD_ACCEPT)
			{
				if (events.iErrorCode[FD_ACCEPT_BIT] == 0&&m_bAcceptConnections&&m_bContinue)
				{
					//SOCKADDR_IN	SockAddr;
					SOCKET		clientSocket=INVALID_SOCKET;
					int			nRet=-1;
					int			nLen=-1;
					//
					// accept the new socket descriptor
					//
					nLen = sizeof(SOCKADDR_IN);
					SOCKADDR_IN ClientAddr ;
					
					clientSocket = WSAAccept(m_pcSocket->GetSocket(),
						(sockaddr *)&ClientAddr ,
						&nLen,0,0); 

					if (clientSocket == SOCKET_ERROR)
					{
						nRet = WSAGetLastError();
						if (nRet != WSAEWOULDBLOCK)
						{
							//
							// Just log the error and return
							// 
							Trace("Wsaaccept() error:%d",WSAGetLastError() );  
						}
					}
					else
					{
                         iRetCode = CreateOneClientConnect(clientSocket, (CSockAddr *)&ClientAddr);
						 if (iRetCode != 0)
						 {
							 throw_NWException("CreateOneClientConnect Error");
						 }
						 if (m_pcIEventNotify != NULL)
						 {
							 iRetCode = m_pcIEventNotify->OnConnectionEstablished((CSockAddr *)&ClientAddr);
							 if (iRetCode != 0)
							 {
								 throw_NWException("OnConnectionEstablished Error");
							 }
						 }						 
					}
				}
				else
				{
					throw_NWExceptionC("Unknown network event error %d\n",WSAGetLastError());
				}	
			}	
			MYEXCEPTIONFUNC_NOREV_END("");
			if (!WSAResetEvent(m_hHaveAcceptEvent))
			{
				throw_NWException("Reset HaveAcceptEvent Error");
			}
			 ;
		}
		else
		{
			Trace("CSocketServer::Run() - WaitForMultipleObjects: %d", ::GetLastError() ); 
		}
	}
	iRetCode = 0 ;
	MYEXCEPTIONFUNC_END("CSocketServer::Run()");
}

int CSocketServer::CreateOneClientConnect(SOCKET clientSocket,CSockAddr * pcClientAddrInfo)
{
	MYEXCEPTIONFUNC_START();
	if (!m_bContinue||!m_bAcceptConnections||clientSocket==INVALID_SOCKET) 
	{
		throw_NWException("!m_bContinue||!m_bAcceptConnections||clientSocket==INVALID_SOCKET");
	}
    NWClientConnect * pClientConnect = NULL ;
    
    pClientConnect = new NWClientConnect(clientSocket,pcClientAddrInfo);
    if (!pClientConnect)
    {
		throw_NWException("new NWClientConnect  Error");
    }
    iRetCode = pClientConnect->BindToIOCP();
	if (iRetCode != 0)
	{
		throw_NWException("BindToIOCP Error");
	}

	iRetCode = pClientConnect->StartRead();
	if (iRetCode != 0)
	{
		throw_NWException("Start Read Error");
	}
	iRetCode = m_pcClientManager->AddOneClient(pClientConnect);
	if (iRetCode != 0 )
	{
		throw_NWException("m_pcClientManager->AddOneClient Error");
	}

	iRetCode = 0 ;
    MYEXCEPTIONFUNC_END("CSocketServer::CreateOneClientConnect()");
}

int CSocketServer::UnInit()
{
	m_bAcceptConnections = false ;
	::WSACloseEvent(m_hHaveAcceptEvent);
	m_pcSocket->Close();
    ::WSACleanup();
    return 0 ;
}
 //////////////////////////////////////////////////////////////////////////

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

CSocketServer::ClientManager::ClientManager()
{
    InitClManager();
}

CSocketServer::ClientManager::~ClientManager()
{
    UninitClManager();
}

void CSocketServer::ClientManager::InitClManager()
{
	MYEXCEPTIONFUNC_START();
	m_pClientPorint = new pNWClientConnect[MAX_CLIENT_CONNECT_COUNT];
	memset(m_pClientPorint,0,sizeof(pNWClientConnect) * MAX_CLIENT_CONNECT_COUNT);

    for (unsigned int nIndex  = 0 ; nIndex < MAX_CLIENT_CONNECT_COUNT; nIndex ++)
    {
         m_lsNullClientList.AddTail(nIndex);
    }
	iRetCode = 0 ;
	MYEXCEPTIONFUNC_NOREV_END("CSocketServer::ClientManager::InitClManager");
}

void CSocketServer::ClientManager::UninitClManager()
{
	MYEXCEPTIONFUNC_START();
	m_lsNullClientList.RemoveAll();

    for (int nIndex = 0 ; nIndex < MAX_CLIENT_CONNECT_COUNT; nIndex ++)
    {
		if (m_pClientPorint[nIndex])
		{
			delete m_pClientPorint[nIndex];
			m_pClientPorint[nIndex ] = NULL;
		}
    }

	if (m_pClientPorint != NULL)
	{
		delete [] m_pClientPorint;
	}
	iRetCode = 0 ;
	MYEXCEPTIONFUNC_NOREV_END("CSocketServer::ClientManager::UninitClManager()");
}

int CSocketServer::ClientManager::AddOneClient(pNWClientConnect pClientPoint)
{
	MYEXCEPTIONFUNC_START();
	UINT nCID = 0 ;
	m_lsNullClientList.RemoveHead(nCID);
	if (nCID < 0)
	{
		throw_NWExceptionC("nCID Error",nCID);
	}
	m_pClientPorint[nCID] = pClientPoint ;	 
    
	pClientPoint->m_ulClientIndex = nCID ;
    
	iRetCode = 0 ;
	MYEXCEPTIONFUNC_END("CSocketServer::ClientManager::AddOneClient()");
}
//删除一个节点，但具体的实体必须在外面删除
int CSocketServer::ClientManager::DeleteOneClient(UINT ulClientID)
{
	MYEXCEPTIONFUNC_START();
    pNWClientConnect pClient = NULL;

	pClient = m_pClientPorint[ulClientID];
    
    if (pClient->m_ulClientIndex != ulClientID)
    {
		throw_NWException("pClient->m_ulClientIndex != ulClientID");
    }
    if (pClient)
    {
        delete pClient ;
	    pClient = NULL ;
	}
	m_pClientPorint[ulClientID] = NULL ;

	m_lsNullClientList.AddTail(ulClientID);

	iRetCode = 0 ;
	MYEXCEPTIONFUNC_END("CSocketServer::ClientManager::DeleteOneClient()");
}

bool CSocketServer::ClientManager::ClientIsExists(UINT ulClientID)
{
	return (m_pClientPorint[ulClientID] != NULL);
}

int CSocketServer::ClientManager::GetClient(pNWClientConnect & pClientPoint,UINT ulClientID)
{
	MYEXCEPTIONFUNC_START();
	pClientPoint = m_pClientPorint[ulClientID];
	iRetCode = 0 ;
	MYEXCEPTIONFUNC_END("CSocketServer::ClientManager::GetClient()");
}

int CSocketServer::ClientManager::RemoveAllClient()
{
	MYEXCEPTIONFUNC_START();
	m_lsNullClientList.RemoveAll();
	for (UINT nIndex = 0 ; nIndex < MAX_CLIENT_CONNECT_COUNT; nIndex ++)
	{
		if (m_pClientPorint[nIndex])
		{
			delete m_pClientPorint[nIndex];
			m_pClientPorint[nIndex ] = NULL;
		}
		m_lsNullClientList.AddTail(nIndex);
	} 
	iRetCode = 0 ;
	MYEXCEPTIONFUNC_END("");
}