authhandlermanager.cc

五行MMORPG引擎系统V1.0

// AuthSocket.cc
/*/////////////////////////////////////////////////////////////////////////////

	李亦
	2006.06.
/*//////////////////////////////////////////////////////////////////////////////

//#include <platforms.h>
//#include "platform/event.h"
//#include "core/dataChunker.h"
#include "server/net/IOSocket.h"
//#include "server/encrypt/EncryptEngine.h"
#include "server/net/authHandlerManager.h"
//#include "sim/netConnection.h"

namespace CS
{
//#include"config.h"

////////////////////////////////////////////////////////////////////////
//数据包缓冲池管理

//#define PACKETQUEUE_MAX			128
//
//static FreeListChunker<PacketBuffer>	gs_pkBufPool;




////////////////////////////////////////////////////////////////////////
//循环队列
PacketQueueCycle::PacketQueueCycle(U32 uSize,U32 uGrow)
:Parent(uSize,uGrow)
{
	m_nHeader		= -1;
	m_nTail			= -1;
	//mElementCount	= uSize;	//占满全部元素，

	if(uSize == 0)
		increment(Parent::mGrowSize);
}

BOOL PacketQueueCycle::IsFull()
{
	if(Parent::mElementCount == 0)
		return TRUE;

	S32 nPos  = m_nTail;
	if(m_nTail == Parent::mElementCount -1)
		nPos = -1;
	//已满
	return nPos == m_nHeader-1;
}

BOOL PacketQueueCycle::Push(PacketBuffer* pUnit)
{

	if(IsFull())
	{	
		//if(bAlways == FALSE)
		//	return FALSE;
		//满的话，增加队列空间
		U32 uSize = mElementCount;
		increment(Parent::mGrowSize);
		//如果头元素在数组中间，则需要把 H--END间的数据，移后
		if(m_nHeader > 0)
		{
			U32 uCount = mElementCount - uSize;
			U32 nHeader= m_nHeader + uCount;
			dMemmove(&mArray[nHeader],
							&mArray[m_nHeader],
							(uSize - m_nHeader) * sizeof(PacketBuffer*));
			m_nHeader = nHeader;
		}

		//Shift();
	}

	if(m_nHeader == -1)
	{	
		m_nHeader	= 0;
		m_nTail		= 0;
	}
	else
		m_nTail++;

	Parent::mArray[m_nTail] = pUnit;

	if(m_nTail >= Parent::mElementCount)
		m_nTail = 0;
	return TRUE;
}


PacketBuffer* PacketQueueCycle::Shift()
{
	if(m_nHeader == -1 || Parent::mElementCount == 0)
		return NULL;

	PacketBuffer* pRet = Parent::mArray[m_nHeader];
	m_nHeader++;

	if(m_nHeader >= Parent::mElementCount)
		m_nHeader = 0;

	//置为Empty标志
	if(IsFull())
		m_nHeader = -1;

	return pRet;
}


PacketBuffer* PacketQueueCycle::Pop()
{
	if(m_nHeader == -1 || Parent::mElementCount == 0)
		return NULL;

	PacketBuffer* pRet = Parent::mArray[m_nTail];
	m_nTail--;

	if(m_nTail < 0 )
		m_nTail = Parent::mElementCount - 1;

	//置为Empty标志
	if(IsFull())
		m_nHeader = -1;

	return pRet;
}


PacketBuffer* PacketQueueCycle::GetHeader()
{
	if(IsEmpty() || Parent::mElementCount == 0)
		return NULL;
	return Parent::mArray[m_nHeader];
}

PacketBuffer* PacketQueueCycle::GetTail()
{
	if(IsEmpty() || Parent::mElementCount == 0)
		return NULL;
	return Parent::mArray[m_nTail];
}



//                                               //
//////////////// IO Handler Class /////////////////
//                                              //

CAuthHandlerManager::CAuthHandlerManager()
{
	int i;
	for(i = 0;i < MAX_AUTH_HANDLERS; i++)
		m_pAuthHandlers[i] = INVALID_AUTH_HANDLER;
}

CAuthHandlerManager::~CAuthHandlerManager()
{
	int i;
	for(i = 0;i < MAX_AUTH_HANDLERS; i++)
	{	
		if(m_pAuthHandlers[i] != INVALID_AUTH_HANDLER) 
		{
			m_pAuthHandlers[i]->pRemove();
			m_pAuthHandlers[i] = INVALID_AUTH_HANDLER;
		}
	}
}

int CAuthHandlerManager::Insert(CS_AUTHHANDLER *handler)
{	
	int i;

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

	for(i = 0;i < MAX_AUTH_HANDLERS; i++) 
	{
		if(m_pAuthHandlers[i] == INVALID_AUTH_HANDLER)
			break;
	}
	if(i == MAX_AUTH_HANDLERS) 
		return E_IOFAILED;
	
	m_pAuthHandlers[i] = handler;
	
	return i;
}


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

	count = 0;
	for(i = 0; i < MAX_AUTH_HANDLERS; i++)
	{
		if(m_pAuthHandlers[i] != INVALID_AUTH_HANDLER)
			count++;
	}
	return count;
}


CS_AUTHHANDLER *CAuthHandlerManager::GetHandler(int nHandler)
{
	if(nHandler < 0 || nHandler >= MAX_AUTH_HANDLERS) 
		return NULL;
	return m_pAuthHandlers[nHandler];
}

CS_AUTHHANDLER *CAuthHandlerManager::GetHandlerByID(char *svID)
{
	int i;
	char *svQuery;

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

	return NULL;
}



char *CAuthHandlerManager::Query(int nHandler)
{
	if(nHandler < 0 || nHandler >= MAX_AUTH_HANDLERS) 
		return NULL;
	if(m_pAuthHandlers[nHandler] == INVALID_AUTH_HANDLER)
		return NULL;
	if(m_pAuthHandlers[nHandler]->pQuery == NULL)
		return NULL;
	
	return m_pAuthHandlers[nHandler]->pQuery();
}


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

	if(nHandler < 0 || nHandler >= MAX_AUTH_HANDLERS) 
		return NULL;
	if(m_pAuthHandlers[nHandler] == INVALID_AUTH_HANDLER)
		return NULL;
	if(m_pAuthHandlers[nHandler]->pRemove == NULL)
		return NULL;
	
	nRet = m_pAuthHandlers[nHandler]->pRemove();
	
	m_pAuthHandlers[nHandler] = INVALID_AUTH_HANDLER;
	
	return nRet;
}



};//namespace CS