iosocket.cc

五行MMORPG引擎系统V1.0

//IOSocket.cc
/*/////////////////////////////////////////////////////////////////////////////
	Socket IO模型控制管理
	李亦
	2006.06.20
/*//////////////////////////////////////////////////////////////////////////////


// Command Input/Output Interface
//#include <windows.h>

#include "server/net/IOSocket.h"


namespace CS
{
//                                               //
//////////////// IO Handler Class /////////////////
//                                               //

CIOHandlerManager::CIOHandlerManager()
{
	int i;
	for(i = 0;i < MAX_IO_HANDLERS; i++)
		m_pIOHandlers[i] = INVALID_IO_HANDLER;
}

CIOHandlerManager::~CIOHandlerManager()
{
	int i;
	for(i=0;i < MAX_IO_HANDLERS;i++) 
	{
		if(m_pIOHandlers[i] != INVALID_IO_HANDLER) 
		{
			m_pIOHandlers[i]->pRemove();
			m_pIOHandlers[i] = INVALID_IO_HANDLER;
		}
	}
}


int CIOHandlerManager::Insert(CS_IOHANDLER *handler)
{	
	int i;

	if(handler->pInsert == NULL)
		return E_IOFAILED;
	if(handler->pInsert() == -1) 
		return E_IOFAILED;

	for(i=0;i < MAX_IO_HANDLERS; i++) 
	{
		if(m_pIOHandlers[i] == INVALID_IO_HANDLER)
			break;
	}
	if(i == MAX_IO_HANDLERS)
		return E_IOFAILED;
	
	m_pIOHandlers[i] = handler;
	
	return i;
}


int CIOHandlerManager::GetHandlerCount(void)
{
	int count,i;

	count=0;
	for(i = 0; i < MAX_IO_HANDLERS; i++)
	{
		if(m_pIOHandlers[i] != INVALID_IO_HANDLER)
			count++;
	}
	return count;
}
	

CS_IOHANDLER *CIOHandlerManager::GetHandler(int nHandler)
{
	if(nHandler < 0 || nHandler >= MAX_IO_HANDLERS)
		return NULL;
	return m_pIOHandlers[nHandler];
}


CS_IOHANDLER *CIOHandlerManager::GetHandlerByID(char *svID)
{
	int i;

	for(i = 0; i < MAX_IO_HANDLERS; i++) 
	{
		char *svQuery = Query(i);
		if(svQuery != NULL)
		{
			if(dStrnicmp(svQuery, svID, getMin(dStrlen(svID), dStrlen(svQuery))) == 0)
				return m_pIOHandlers[i];
		}
	}

	return NULL;
}



char *CIOHandlerManager::Query(int nHandler)
{
	if(nHandler < 0 || nHandler >= MAX_IO_HANDLERS)
		return NULL;
	if(m_pIOHandlers[nHandler] == INVALID_IO_HANDLER) 
		return NULL;
	if(m_pIOHandlers[nHandler]->pQuery == NULL) 
		return NULL;
	
	return m_pIOHandlers[nHandler]->pQuery();
}


int CIOHandlerManager::Remove(int nHandler)
{
	int nRet;

	if(nHandler < 0 || nHandler >= MAX_IO_HANDLERS)
		return NULL;
	if(m_pIOHandlers[nHandler] == INVALID_IO_HANDLER) 
		return NULL;
	if(m_pIOHandlers[nHandler]->pRemove == NULL)
		return NULL;
	
	nRet = m_pIOHandlers[nHandler]->pRemove();
	
	m_pIOHandlers[nHandler] = INVALID_IO_HANDLER;
	
	return nRet;
}





//                                               //
//////////////// Socket Class /////////////////////
//                                               //


CIOSocket::CIOSocket(CS_IOHANDLER *pHandler)
{
	m_pIOSockHandle		= pHandler;
	m_pData			= NULL;
	//m_svRmtAddr[0]	= 0;
	m_nLastError	= 0;
	m_bNeedToKill	= FALSE;
}

CIOSocket::~CIOSocket()
{
	//Close();
}


void CIOSocket::SaveError()
{
	m_nLastError = 0;
	if(m_pIOSockHandle->pGetError == NULL)
		return;
	m_nLastError = m_pIOSockHandle->pGetError(m_pData);
}

int CIOSocket::Listen(char *svTarget)
{
	if(m_pIOSockHandle->pListen == NULL)
		return E_IOFAILED;
	if(m_pData != NULL)
		return E_IOFAILED;

	m_pData = m_pIOSockHandle->pListen(svTarget);
	if(m_pData == NULL)
		return E_IOFAILED;

	return E_IOOK;
}


int CIOSocket::Connect(char *svTarget)
{
	if(m_pIOSockHandle->pConnect == NULL)
		return E_IOFAILED;
	if(m_pData != NULL)
		return E_IOFAILED;

	m_pData = m_pIOSockHandle->pConnect(svTarget);
	if(m_pData==NULL) 
		return E_IOFAILED;

	//dStrncpy(m_svRmtAddr, svTarget, ADDR_MAX);

	return E_IOOK;
}


CIOSocket *CIOSocket::Accept(void)
{
	CIOSocket *pIOSocket;
	if(m_pIOSockHandle->pAccept == NULL)
		return NULL;
	if(m_pData == NULL)
		return NULL;

	void	*pNewAccept;
	char	svAddr[ADDR_MAX];

	pNewAccept	= m_pIOSockHandle->pAccept(m_pData, svAddr, ADDR_MAX);
	if(pNewAccept == NULL) 
		return NULL;

	pIOSocket = new CIOSocket(m_pIOSockHandle);
	pIOSocket->m_pData = pNewAccept;
	//dStrncpy(pIOSocket->m_svRmtAddr, svAddr, ADDR_MAX);

	return pIOSocket;
}

int CIOSocket::Close(void)
{
	int nRet;
	if(m_pIOSockHandle->pClose == NULL)
		return E_IOFAILED;
	if(m_pData == NULL) 
		return E_IOOK;
	
	nRet = m_pIOSockHandle->pClose(m_pData);
	if(nRet < 0)
		return nRet;

	//m_svRmtAddr[0] = '\0';
	m_pData			= NULL;
	return nRet;
}	


inline BOOL CIOSocket::CheckAccept()
{
	if(m_pIOSockHandle->pCheckAccept == NULL)
	if(m_pData == NULL) 
		return FALSE;
	return m_pIOSockHandle->pCheckAccept(m_pData);
}

inline BOOL CIOSocket::CheckRecv()
{
	if(m_pIOSockHandle->pCheckRecv == NULL)
	if(m_pData == NULL) 
		return FALSE;
	return m_pIOSockHandle->pCheckRecv(m_pData);
}

inline BOOL CIOSocket::CheckSend()
{
	if(m_pIOSockHandle->pCheckSend == NULL)
	if(m_pData == NULL) 
		return FALSE;
	return m_pIOSockHandle->pCheckSend(m_pData);
}




int CIOSocket::Recv(BYTE *pInData, int *pnInDataLen)
{
	if(m_pIOSockHandle->pRecv == NULL)
		return E_IOFAILED;
	if(m_pData == NULL) 
	{
		*pnInDataLen= 0;
		return E_IOFAILED;
	}
	
	return m_pIOSockHandle->pRecv(m_pData, pInData, pnInDataLen);
}


int CIOSocket::Send(BYTE *pData, int nDataLen)
{
	if(m_pIOSockHandle->pSend == NULL) 
		return E_IOFAILED;
	if(m_pData == NULL) 
		return E_IOFAILED;
	
	return m_pIOSockHandle->pSend(m_pData, pData, nDataLen);
}


int CIOSocket::RecvEx(BYTE **pInData, int *pnInDataLen)
{
	if(m_pIOSockHandle->pRecvEx == NULL)
		return E_IOFAILED;
	if(m_pData == NULL) 
	{
		*pInData		= NULL;
		*pnInDataLen= 0;
		return E_IOFAILED;
	}
	
	return m_pIOSockHandle->pRecvEx(m_pData, pInData, pnInDataLen);
}



int CIOSocket::SendEx(BYTE *pData, int nDataLen)
{
	if(m_pIOSockHandle->pSendEx == NULL) 
		return E_IOFAILED;
	if(m_pData == NULL) 
		return E_IOFAILED;
	
	return m_pIOSockHandle->pSendEx(m_pData, pData, nDataLen);
}


void CIOSocket::Free(BYTE *pBuffer)
{
	if(m_pIOSockHandle->pFree == NULL)
		return;
	if(m_pData == NULL)
		return;
	
	m_pIOSockHandle->pFree(m_pData,pBuffer);
}

void* CIOSocket::GetNetAddress()
{
	if(m_pIOSockHandle->pGetNetAddress == NULL)
		return  0;
	if(m_pData == NULL)
		return  0;
	return m_pIOSockHandle->pGetNetAddress(m_pData);
}

int CIOSocket::GetRemoteAddr(char *svAddr,int nMaxLen)
{
	if(m_pIOSockHandle->pGetConnectAddr == NULL)
		return  0;
	if(m_pData == NULL)
		return  0;

	m_pIOSockHandle->pGetConnectAddr(m_pData,svAddr,nMaxLen);
	//dStrncpy(svAddr, m_svRmtAddr, nMaxLen);
	return dStrlen(svAddr);
}

int CIOSocket::GetConnectAddr(char *svAddr,int nMaxLen)
{
	if(m_pIOSockHandle->pGetConnectAddr == NULL)
		return E_IOFAILED;
	if(m_pData == NULL)
		return E_IOFAILED;

	return m_pIOSockHandle->pGetConnectAddr(m_pData, svAddr, nMaxLen);
}


};//namespace CS