encryptengine.cc

五行MMORPG引擎系统V1.0

// EncryptEngine.cc
/*/////////////////////////////////////////////////////////////////////////////

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


// Command Input/Output Interface
//#include <windows.h>
#include "server/encrypt/EncryptEngine.h"
#include "server/net/IOSocket.h"


namespace CS
{

CEncryptHandlerManager::CEncryptHandlerManager()
{
	int i;
	for(i=0;i<MAX_ENCRYPTION_ENGINES;i++)
		m_pEncryptionEngines[i]=INVALID_ENCRYPTION_ENGINE;
}

CEncryptHandlerManager::~CEncryptHandlerManager()
{
	int i;
	for(i=0;i<MAX_ENCRYPTION_ENGINES;i++) 
	{
		if(m_pEncryptionEngines[i]!=INVALID_ENCRYPTION_ENGINE)
		{
			m_pEncryptionEngines[i]->pRemove();
			m_pEncryptionEngines[i]=INVALID_ENCRYPTION_ENGINE;
		}
	}
}

int CEncryptHandlerManager::Insert(CS_ENCRYPTHANDLER *engine)
{	
	int i;

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

	for(i=0;i<MAX_ENCRYPTION_ENGINES;i++) {
		if(m_pEncryptionEngines[i]==INVALID_ENCRYPTION_ENGINE) break;
	}
	if(i==MAX_ENCRYPTION_ENGINES) return E_IOFAILED;
	
	m_pEncryptionEngines[i]=engine;
	
	return i;
}

int CEncryptHandlerManager::GetEngineCount(void)
{
	int count,i;

	count=0;
	for(i=0;i<MAX_ENCRYPTION_ENGINES;i++)
	{
		if(m_pEncryptionEngines[i]==INVALID_ENCRYPTION_ENGINE) count++;
	}
	return count;
}
	
CS_ENCRYPTHANDLER *CEncryptHandlerManager::GetEngine(int nEngine)
{
	if(nEngine<0 || nEngine>=MAX_ENCRYPTION_ENGINES) return NULL;
	return m_pEncryptionEngines[nEngine];
}


CS_ENCRYPTHANDLER *CEncryptHandlerManager::GetEngineByID(char *svID)
{
	int i;
	
	for(i=0;i<MAX_ENCRYPTION_ENGINES;i++)
	{
		char *svQuery=Query(i);
		if(svQuery!=NULL) 
		{
			if(dStrnicmp(svQuery,svID,getMin(dStrlen(svID),dStrlen(svQuery)))==0)
				return m_pEncryptionEngines[i];
		}
	}

	return NULL;
}


char *CEncryptHandlerManager::Query(int nEngine)
{
	if(nEngine<0 || nEngine>=MAX_ENCRYPTION_ENGINES)
		return NULL;
	if(m_pEncryptionEngines[nEngine]==INVALID_ENCRYPTION_ENGINE) 
		return NULL;
	if(m_pEncryptionEngines[nEngine]->pQuery==NULL) 
		return NULL;
	
	return m_pEncryptionEngines[nEngine]->pQuery();
}


int CEncryptHandlerManager::Remove(int nEngine)
{
	int ret;

	if(nEngine<0 || nEngine>=MAX_ENCRYPTION_ENGINES)
		return NULL;
	if(m_pEncryptionEngines[nEngine]==INVALID_ENCRYPTION_ENGINE)
		return NULL;
	if(m_pEncryptionEngines[nEngine]->pRemove==NULL)
		return NULL;
	
	ret=m_pEncryptionEngines[nEngine]->pRemove();
	
	m_pEncryptionEngines[nEngine]=INVALID_ENCRYPTION_ENGINE;
	
	return ret;
}


//
///////
//////////////////// Encryption Engine /////////////////////////
///////
//



CEncryptionEngine::CEncryptionEngine(CS_ENCRYPTHANDLER *pEngine)
{
	m_pEngine=pEngine;
	m_pData=NULL;
}

CEncryptionEngine::~CEncryptionEngine()
{

}

char *CEncryptionEngine::Query(void)
{
	return m_pEngine->pQuery();
}

int CEncryptionEngine::Startup(void)
{
	if(m_pData!=NULL)
		return E_IOFAILED;
	if(m_pEngine->pStartup==NULL)
		return E_IOOK;

	m_pData=m_pEngine->pStartup();

	if(m_pData==NULL)
		return E_IOFAILED;
	return E_IOOK;
}

int CEncryptionEngine::Shutdown(void)
{
	int ret;
	if(m_pData==NULL) 
		return E_IOFAILED;
	if(m_pEngine->pShutdown==NULL)
		return E_IOOK;
	ret=m_pEngine->pShutdown(m_pData);
	if(ret == E_IOOK)
		m_pData=NULL;

	return ret;
}

int CEncryptionEngine::SetEncryptKey(char *svKey)
{
	if(m_pData==NULL) 
		return E_IOFAILED;
	if(m_pEngine->pSetEncryptKey==NULL)
		return E_IOOK;
	return m_pEngine->pSetEncryptKey(m_pData,svKey);
}

int CEncryptionEngine::SetDecryptKey(char *svKey)
{
	if(m_pData==NULL)
		return E_IOFAILED;
	if(m_pEngine->pSetDecryptKey==NULL) 
		return E_IOOK;
	return m_pEngine->pSetDecryptKey(m_pData,svKey);
}

char *CEncryptionEngine::GetEncryptKey(void)
{
	if(m_pData==NULL) 
		return NULL;
	if(m_pEngine->pGetEncryptKey==NULL) 
		return NULL;
	return m_pEngine->pGetEncryptKey(m_pData);
}

char *CEncryptionEngine::GetDecryptKey(void)
{
	if(m_pData==NULL) 
		return NULL;
	if(m_pEngine->pGetDecryptKey==NULL) 
		return NULL;
	return m_pEngine->pGetDecryptKey(m_pData);
}

BYTE *CEncryptionEngine::Encrypt(BYTE *pBuffer,int nBufLen, int *pnOutBufLen)
{
	if(m_pData==NULL)
		return NULL;
	if(m_pEngine->pEncrypt==NULL)
		return NULL;
	return m_pEngine->pEncrypt(m_pData,pBuffer,nBufLen,pnOutBufLen);
}

BYTE *CEncryptionEngine::Decrypt(BYTE *pBuffer,int nBufLen, int *pnOutBufLen)
{
	if(m_pData==NULL)
		return NULL;
	if(m_pEngine->pDecrypt==NULL) 
		return NULL;
	return m_pEngine->pDecrypt(m_pData,pBuffer,nBufLen,pnOutBufLen);
}

int CEncryptionEngine::CreateNewKeys(void)
{
	if(m_pData==NULL) 
		return E_IOFAILED;
	if(m_pEngine->pCreateNewKeys==NULL) 
		return E_IOFAILED;
	return m_pEngine->pCreateNewKeys(m_pData);
}

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

};//namespace CS