zhujimajiang_redis/俱乐部/Source/ServerControl/KernelEngine/AttemperEngine.cpp

#include "StdAfx.h"
#include "TraceService.h" // #include "EventService.h"
#include "AttemperEngine.h"
#include <string>
#include "../curl-7.32.0/include/curl/curl.h"
#include "ChineseCode.h"
#include "../Json/json.h"
#include "AES.h"
#include "ZBase64.h"

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

//构造函数
CAttemperEngine::CAttemperEngine(void)
{
	m_bService = false;
	m_pITCPSocketService = NULL;
	m_pTCPNetworkEngine = NULL;
	m_pIAttemperEngineSink = NULL;
	return;
}

//析构函数
CAttemperEngine::~CAttemperEngine(void)
{
}

//接口查询
void *  CAttemperEngine::QueryInterface(const IID & Guid, DWORD dwQueryVer)
{
	QUERYINTERFACE(IAttemperEngine, Guid, dwQueryVer);
	QUERYINTERFACE(IQueueServiceSink, Guid, dwQueryVer);
	QUERYINTERFACE(IDataBaseEngineEvent, Guid, dwQueryVer);
	QUERYINTERFACE(ITCPNetworkEngineEvent, Guid, dwQueryVer);
	QUERYINTERFACE_IUNKNOWNEX(IAttemperEngine, Guid, dwQueryVer);
	return NULL;
}

//启动服务
bool  CAttemperEngine::StartService()
{
	//判断状态
	if (m_bService == true)
	{
		CTraceService::TraceString(TEXT("调度引擎重复启动，启动操作忽略"), TraceLevel_Warning);
		return true;
	}

	//外挂接口
	if (m_pIAttemperEngineSink == NULL)
	{
		CTraceService::TraceString(TEXT("调度引擎外挂服务不存在"), TraceLevel_Exception);
		return false;
	}

	//设置队列
	if (m_QueueService.SetQueueServiceSink(QUERY_ME_INTERFACE(IUnknownEx)) == false)
	{
		CTraceService::TraceString(TEXT("调度引擎与队列服务绑定失败"), TraceLevel_Exception);
		return false;
	}

	//启动外挂
	if (m_pIAttemperEngineSink->OnAttemperEngineStart(QUERY_ME_INTERFACE(IUnknownEx)) == false)
	{
		CTraceService::TraceString(TEXT("调度引擎外挂服务启动失败"), TraceLevel_Exception);
		return false;
	}

	//启动队列
	if (m_QueueService.StartService() == false)
	{
		CTraceService::TraceString(TEXT("调度引擎队列服务启动失败"), TraceLevel_Exception);
		return false;
	}

	//清空机器人
	m_AndroidUserSocketIDArray.RemoveAll();

	//设置变量
	m_bService = true;

	return true;
}

//停止服务
bool  CAttemperEngine::ConcludeService()
{
	//设置变量
	m_bService = false;

	//停止请求队列
	m_QueueService.ConcludeService();

	//停止外挂
	if (m_pIAttemperEngineSink != NULL)
	{
		m_pIAttemperEngineSink->OnAttemperEngineConclude(QUERY_ME_INTERFACE(IUnknownEx));
		m_pIAttemperEngineSink = NULL;
	}

	//清空机器人
	m_AndroidUserSocketIDArray.RemoveAll();

	return true;
}

//设置网络
bool  CAttemperEngine::SetSocketEngine(IUnknownEx * pIUnknownEx)
{
	ASSERT(pIUnknownEx != NULL);
	m_pITCPSocketService = QUERY_OBJECT_PTR_INTERFACE(pIUnknownEx, ITCPSocketService);
	ASSERT(m_pITCPSocketService != NULL);
	return (m_pITCPSocketService != NULL);
}

//设置网络
bool  CAttemperEngine::SetNetworkEngine(IUnknownEx * pIUnknownEx)
{
	ASSERT(pIUnknownEx != NULL);
	m_pTCPNetworkEngine = QUERY_OBJECT_PTR_INTERFACE(pIUnknownEx, ITCPNetworkEngine);
	ASSERT(m_pTCPNetworkEngine != NULL);
	return (m_pTCPNetworkEngine != NULL);
}

#pragma region <<程序验证使用时限>>

//需要转UTF-8字符编码格式
//const char g_key[17] = "asdfwetyhjuytrfd";
//const char g_iv[17] = "302";
string EncryptionAES(const string& strSrc, const char g_iv[17],const char g_key[17]) //AES加密
{
	size_t length = strSrc.length();
	int block_num = length / BLOCK_SIZE + 1;
	//明文
	char* szDataIn = new char[block_num * BLOCK_SIZE + 1];
	memset(szDataIn, 0x00, block_num * BLOCK_SIZE + 1);
	memcpy(szDataIn, strSrc.c_str(), strSrc.size());

	//进行PKCS7Padding填充。
	int k = length % BLOCK_SIZE;
	int j = length / BLOCK_SIZE;
	int padding = BLOCK_SIZE - k;
	for (int i = 0; i < padding; i++)
	{
		szDataIn[j * BLOCK_SIZE + k + i] = padding;
	}
	szDataIn[block_num * BLOCK_SIZE] = '\0';

	//加密后的密文
	char *szDataOut = new char[block_num * BLOCK_SIZE + 1];
	memset(szDataOut, 0, block_num * BLOCK_SIZE + 1);

	//进行进行AES的CBC模式加密
	AES aes;
	aes.MakeKey(g_key, g_iv, 16, 16);
	aes.Encrypt(szDataIn, szDataOut, block_num * BLOCK_SIZE, AES::CBC);
	string str = base64_encode((unsigned char*)szDataOut,
		block_num * BLOCK_SIZE);
	delete[] szDataIn;
	delete[] szDataOut;
	return str;
}
string DecryptionAES(const string& strSrc, const char g_iv[17], const char g_key[17]) //AES解密
{
	string strData = base64_decode(strSrc);
	size_t length = strData.length();
	//密文
	char *szDataIn = new char[length + 1];
	memcpy(szDataIn, strData.c_str(), length + 1);
	//明文
	char *szDataOut = new char[length + 1];
	memcpy(szDataOut, strData.c_str(), length + 1);

	//进行AES的CBC模式解密
	AES aes;
	aes.MakeKey(g_key, g_iv, 16, 16);
	aes.Decrypt(szDataIn, szDataOut, length, AES::CBC);

	//去PKCS7Padding填充
	if (0x00 < szDataOut[length - 1] && szDataOut[length - 1] <= 0x16)
	{
		int tmp = szDataOut[length - 1];
		for (int i = length - 1; i >= (static_cast<int>(length) - tmp); i--)
		{
			if (szDataOut[i] != tmp)
			{
				memset(szDataOut, 0, length);
				cout << "去填充失败！解密出错！！" << endl;
				break;
			}
			else
				szDataOut[i] = 0;
		}
	}
	string strDest(szDataOut);
	delete[] szDataIn;
	delete[] szDataOut;
	return strDest;
}


static size_t OnWriteData(void* buffer, size_t size, size_t nmemb, void* lpVoid)
{
	std::string* str = dynamic_cast<std::string*>((std::string *)lpVoid);
	if (NULL == str || NULL == buffer)
	{
		return -1;
	}

	char* pData = (char*)buffer;
	str->append(pData, size * nmemb);
	return nmemb;
}
static int Post(const std::string & strUrl, const std::string & strPost, std::string & strResponse)
{
	CURLcode res;
	CURL* curl = curl_easy_init();
	if (NULL == curl)
	{
		return CURLE_FAILED_INIT;
	}
	/*if (m_bDebug)
	{
	curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
	curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, OnDebug);
	}*/
	curl_easy_setopt(curl, CURLOPT_URL, strUrl.c_str());
	curl_easy_setopt(curl, CURLOPT_POST, 1);
	curl_easy_setopt(curl, CURLOPT_POSTFIELDS, strPost.c_str());
	curl_easy_setopt(curl, CURLOPT_READFUNCTION, NULL);
	curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, OnWriteData);
	curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&strResponse);
	curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);
	curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 3);
	curl_easy_setopt(curl, CURLOPT_TIMEOUT, 3);
	res = curl_easy_perform(curl);
	curl_easy_cleanup(curl);
	return res;
}
// 获取 验证码
static bool  OnGetVerificationCode()
{
	DWORD dStart = GetTickCount();
	CString csGet = _T(""), HttpPath = _T("");

#ifdef  _DEBUG
	HttpPath.Format(_T("http://192.168.0.223:8084/game/validate/secret"));
#else
	HttpPath.Format(_T("http://cycz.legaogame.com/game/validate/secret"));
#endif
	


	CTime t = CTime::GetCurrentTime();
	CString time = t.Format("%Y%m%d%H%M%S");
	CString key = _T("VwZkLv0m0G^5T@2v");

	//内容AES加密 (CBC[128]+PKCS7Padding+base64)
	CString secret;//
	string strContent = "dPBmFWuzQkxrxbR8";
	char p0[1024] = { 0 };
	CopyMemory(p0, strContent.c_str(), strContent.size());
	*(p0 + strContent.size()) = '\0';//注意手动加结束符！！！
	string strUtf8;
	CChineseCode::GB2312ToUTF_8(strUtf8, p0, strContent.size());//转UTF-8
	const char g_key[17] = "dPBmFWuzQkxrxbR8";//秘钥
	const char g_iv[17] = "cyhh01";//偏移量
	string strEnc = EncryptionAES(strUtf8, g_iv, g_key);
	secret = strEnc.c_str();

	//MD5加密
	CString stringSource = _T(""), stringTarget = _T("");
	TCHAR strTemp[LEN_MD5];
	stringSource.Format(_T("%s%s%s"), secret, time, key);
	CWHEncrypt::MD5Encrypt(stringSource, strTemp); //生成加密串
	stringTarget.Format(_T("%s"), strTemp);
	csGet.Format(_T("secret=%s&time=%s&sign=%s"), secret, time, stringTarget);


	const std::string szUrl = CW2AEX<1024>(HttpPath).m_psz;
	const std::string szParam = CW2AEX<1024>(csGet).m_psz;
	std::string csRet;
	const int iRet = Post(szUrl, szParam, csRet);
	if (CURLE_OK == iRet)
	{
		string strDecryption = DecryptionAES(csRet, g_iv, g_key), strGB2312;//解密
		char p1[256] = { 0 };
		CopyMemory(p1, strDecryption.c_str(), strDecryption.size());
		*(p1 + strDecryption.size()) = '\0';//注意手动加结束符！！！

		CChineseCode::UTF_8ToGB2312(strGB2312, p1, strDecryption.size());
		dStart = GetTickCount() - dStart;
		CString strTip;
		strTip.Format(L"校验请求:%s,Post:%s,返回数据：%s,返回值iRet:%d,消耗时间:%d", csGet, HttpPath, static_cast<CString>(strGB2312.c_str()), iRet, dStart);
		//剩余天数判断
		const int ndayNum = atoi(strGB2312.c_str());
		if (0 < ndayNum)
		{
			return true;
		}
		////解析返回的数据
		//Json::Reader m_reader;
		//Json::Value m_root;
		//std::string strbb(CW2A(csRetUnicode.GetString()));
		//if (!m_reader.parse(strbb, m_root))
		//	return false;
		//int nCode = 0;
		//if (m_root["Code"].isString())
		//{
		//	std::string Cmd = m_root["Code"].asString();
		//	//aes解密
		//	//...
		//	//nCode = static_cast<INT>(atoi(m_root["Code"].asString().c_str()));
		//}
		//else if (m_root["Code"].isInt()){
		//	nCode = static_cast<INT>(m_root["Code"].asInt());
		//}

	}
	
	return false;
}
#pragma endregion 

//注册钩子
bool  CAttemperEngine::SetAttemperEngineSink(IUnknownEx * pIUnknownEx)
{
#ifndef  _DEBUG
	//请求验证服务器 软件是否超过有效使用时限 2019-5-15 ADD L
	if (!OnGetVerificationCode())
	{
		//abort();
		exit(-1);
	}
#endif

	//效验参数
	ASSERT(pIUnknownEx != NULL);
	ASSERT(m_pIAttemperEngineSink == NULL);
	if (pIUnknownEx == NULL) return false;
	if (m_pIAttemperEngineSink != NULL) return false;

	//查询接口
	m_pIAttemperEngineSink = QUERY_OBJECT_PTR_INTERFACE(pIUnknownEx, IAttemperEngineSink);
	if (m_pIAttemperEngineSink == NULL)
	{
		CTraceService::TraceString(TEXT("调度引擎外挂服务接口获取失败，挂接操作失败"), TraceLevel_Exception);
		return false;
	}
	return true;
}

//获取接口
void *  CAttemperEngine::GetQueueService(const IID & Guid, DWORD dwQueryVer)
{
	return m_QueueService.QueryInterface(Guid, dwQueryVer);
}

//控制事件
//////////////////////////////////////////////////////////////////////////
//自定事件
bool  CAttemperEngine::OnEventCustom(WORD wRequestID, VOID * pData, WORD wDataSize)
{
	ASSERT(m_pIAttemperEngineSink);
	if (m_pIAttemperEngineSink == NULL) return false;

	return m_pIAttemperEngineSink->OnEventAttemperData(wRequestID, pData, wDataSize);
}

//控制事件
bool  CAttemperEngine::OnEventControl(WORD wControlID, VOID * pData, WORD wDataSize)
{
	ASSERT(m_pIAttemperEngineSink);
	if (m_pIAttemperEngineSink == NULL) return false;

	return m_pIAttemperEngineSink->OnEventControl(wControlID, pData, wDataSize);
}

//队列接口
void  CAttemperEngine::OnQueueServiceSink(WORD wIdentifier, void * pBuffer, WORD wDataSize)
{
	//内核事件
	ASSERT(m_pIAttemperEngineSink != NULL);
	switch (wIdentifier)
	{
	case EVENT_TCP_TONGBU:
	{
		//效验参数
		ASSERT(wDataSize >= 8);
		if (wDataSize < 8) return;
		int* iCommend = (int *)pBuffer;
		int* pSecond = iCommend + 1;
		char *pData = (char *)pBuffer;
		pData = pData + 8;

		try
		{
			if (m_pIAttemperEngineSink) m_pIAttemperEngineSink->OnTongBu(*iCommend, *pSecond, pData, wDataSize - 8);
		}
		catch (...)
		{
		}
		return;
	}
	case EVENT_TIMER:			//定时器事件
	{
		//效验参数
		ASSERT(wDataSize == sizeof(NTY_TimerEvent));
		if (wDataSize != sizeof(NTY_TimerEvent)) return;

		//处理消息
		NTY_TimerEvent * pTimerEvent = (NTY_TimerEvent *)pBuffer;
		try
		{
			if (m_pIAttemperEngineSink) m_pIAttemperEngineSink->OnEventTimer(pTimerEvent->dwTimerID, pTimerEvent->dwBindParameter);
		}
		catch (...)
		{
		}

		return;
	}

	case EVENT_DATABASE:		//数据库事件
	{
		//效验参数
		ASSERT(wDataSize >= sizeof(NTY_DataBaseEvent));
		if (wDataSize < sizeof(NTY_DataBaseEvent)) return;

		//处理消息
		NTY_DataBaseEvent * pDataBaseEvent = (NTY_DataBaseEvent *)pBuffer;
		try
		{
			if (m_pIAttemperEngineSink) m_pIAttemperEngineSink->OnEventDataBase(pDataBaseEvent->wRequestID, pDataBaseEvent->dwContextID, pDataBaseEvent + 1, wDataSize - sizeof(NTY_DataBaseEvent));
		}
		catch (...)
		{
		}
		return;
	}

	case EVENT_TCP_NETWORK_ACCEPT:	//网络应答事件
	{
		//效验大小
		ASSERT(wDataSize == sizeof(NTY_TCPNetworkAcceptEvent));
		if (wDataSize != sizeof(NTY_TCPNetworkAcceptEvent)) return;

		//处理消息
		NTY_TCPNetworkAcceptEvent * pSocketAcceptEvent = (NTY_TCPNetworkAcceptEvent *)pBuffer;
		bool bSuccess = false;
		try
		{
			if (m_pIAttemperEngineSink) bSuccess = m_pIAttemperEngineSink->OnEventTCPNetworkBind(pSocketAcceptEvent->dwClientAddr, pSocketAcceptEvent->dwSocketID);
		}
		catch (...) {}
		if (bSuccess == false)
		{
			m_pTCPNetworkEngine->CloseSocket(pSocketAcceptEvent->dwSocketID);
		}

		return;
	}

	case EVENT_TCP_NETWORK_READ:	//网络读取事件
	{
		//效验大小
		NTY_TCPNetworkReadEvent * pSocketReadEvent = (NTY_TCPNetworkReadEvent *)pBuffer;
		ASSERT(wDataSize >= sizeof(NTY_TCPNetworkReadEvent));
		ASSERT(wDataSize == (sizeof(NTY_TCPNetworkReadEvent) + pSocketReadEvent->wDataSize));
		if (wDataSize < sizeof(NTY_TCPNetworkReadEvent)) return;
		if (wDataSize != (sizeof(NTY_TCPNetworkReadEvent) + pSocketReadEvent->wDataSize)) return;

		//处理消息
		bool bSuccess = false;
		try
		{
			if (m_pIAttemperEngineSink) bSuccess = m_pIAttemperEngineSink->OnEventTCPNetworkRead(pSocketReadEvent->Command, pSocketReadEvent + 1, pSocketReadEvent->wDataSize, pSocketReadEvent->dwSocketID);
		}
		catch (...) {}
		if (bSuccess == false)
		{
			m_pTCPNetworkEngine->CloseSocket(pSocketReadEvent->dwSocketID);
		}

		return;
	}

	case EVENT_TCP_NETWORK_SHUT:	//关闭读取事件
	{
		//效验大小
		ASSERT(wDataSize == sizeof(NTY_TCPNetworkShutEvent));
		if (wDataSize != sizeof(NTY_TCPNetworkShutEvent)) return;

		//处理消息
		NTY_TCPNetworkShutEvent * pSocketCloseEvent = (NTY_TCPNetworkShutEvent *)pBuffer;

		bool bSuccess = false;
		try
		{
			if (m_pIAttemperEngineSink) bSuccess = m_pIAttemperEngineSink->OnEventTCPNetworkShut(pSocketCloseEvent->dwClientAddr, pSocketCloseEvent->dwActiveTime, pSocketCloseEvent->dwSocketID);
		}
		catch (...) {}
		if (bSuccess == false)
		{
			m_pTCPNetworkEngine->CloseSocket(pSocketCloseEvent->dwSocketID);
		}

		return;
	}

	case EVENT_TCP_SOCKET_READ:		//网络读取事件
	{
		//效验大小
		NTY_TCPSocketReadEvent * pSocketReadEvent = (NTY_TCPSocketReadEvent *)pBuffer;
		ASSERT(wDataSize >= sizeof(NTY_TCPSocketReadEvent));
		ASSERT(wDataSize == (sizeof(NTY_TCPSocketReadEvent) + pSocketReadEvent->wDataSize));
		if (wDataSize < sizeof(NTY_TCPSocketReadEvent)) return;
		if (wDataSize != (sizeof(NTY_TCPSocketReadEvent) + pSocketReadEvent->wDataSize)) return;

		//处理消息
		bool bSuccess = false;
		try
		{
			if (m_pIAttemperEngineSink) bSuccess = m_pIAttemperEngineSink->OnEventTCPSocketRead(pSocketReadEvent->wServiceID, pSocketReadEvent->Command, pSocketReadEvent + 1, pSocketReadEvent->wDataSize);
		}
		catch (...) {}
		if (bSuccess == false)
		{
			if (m_pITCPSocketService)
				m_pITCPSocketService->CloseSocket();
		}

		return;
	}

	case EVENT_TCP_SOCKET_SHUT:	//网络关闭事件
	{
		//效验大小
		ASSERT(wDataSize == sizeof(NTY_TCPSocketShutEvent));
		if (wDataSize != sizeof(NTY_TCPSocketShutEvent)) return;

		//处理消息
		NTY_TCPSocketShutEvent * pSocketCloseEvent = (NTY_TCPSocketShutEvent *)pBuffer;

		bool bSuccess = false;
		try
		{
			if (m_pIAttemperEngineSink) bSuccess = m_pIAttemperEngineSink->OnEventTCPSocketShut(pSocketCloseEvent->wServiceID, pSocketCloseEvent->cbShutReason);
		}
		catch (...) {}
		if (bSuccess == false)
			m_pITCPSocketService->CloseSocket();

		return;
	}

	case EVENT_TCP_SOCKET_LINK:
	{
		//效验大小
		ASSERT(wDataSize == sizeof(NTY_TCPSocketLinkEvent));
		if (wDataSize != sizeof(NTY_TCPSocketLinkEvent)) return;

		//处理消息
		NTY_TCPSocketLinkEvent * pSocketCloseEvent = (NTY_TCPSocketLinkEvent *)pBuffer;

		bool bSuccess = false;
		try
		{
			if (m_pIAttemperEngineSink) bSuccess = m_pIAttemperEngineSink->OnEventTCPSocketLink(pSocketCloseEvent->wServiceID, pSocketCloseEvent->nErrorCode);
		}
		catch (...) {}
		if (bSuccess == false)
			m_pITCPSocketService->CloseSocket();

		return;
	}

	case EVENT_CONTROL:
	{
		//效验大小
		ASSERT(wDataSize == sizeof(NTY_ControlEvent));
		if (wDataSize != sizeof(NTY_ControlEvent)) return;

		//处理消息
		NTY_ControlEvent * pControlEvent = (NTY_ControlEvent *)pBuffer;
		try
		{
			if (m_pIAttemperEngineSink) m_pIAttemperEngineSink->OnEventControl(wIdentifier, pBuffer, wDataSize);
		}
		catch (...) {}

		return;
	}
	}

	//其他事件
	try
	{
		if (m_pIAttemperEngineSink) m_pIAttemperEngineSink->OnEventAttemperData(wIdentifier, pBuffer, wDataSize);
	}
	catch (...) {}

	return;
}

bool CAttemperEngine::OnEventDataBaseResult(WORD wRequestID, DWORD dwContextID, VOID * pData, WORD wDataSize)
{
	try
	{
		if (!m_pIAttemperEngineSink) return false;
		return m_pIAttemperEngineSink->OnEventDataBase(wRequestID, dwContextID, pData, wDataSize);
	}
	catch (...)
	{
		return false;
	}
}

//机器模拟接口
//////////////////////////////////////////////////////////////////////////
//应答事件
bool  CAttemperEngine::OnEventTCPNetworkBind(DWORD dwSocketID, DWORD dwClientIP)
{
	//缓冲锁定
	CWHDataLocker lock(m_CriticalSection);

	try
	{
		m_AndroidUserSocketIDArray.Add(dwSocketID);
		m_pIAttemperEngineSink->OnEventTCPNetworkBind(dwClientIP, dwSocketID);
	}
	catch (...) { return false; }

	return true;
}

//关闭事件
bool  CAttemperEngine::OnEventTCPNetworkShut(DWORD dwSocketID, DWORD dwClientIP, DWORD dwActiveTime)
{
	//缓冲锁定
	CWHDataLocker lock(m_CriticalSection);

	try
	{
		for (int i = 0; i < m_AndroidUserSocketIDArray.GetCount(); i++)
		{
			if (dwSocketID == m_AndroidUserSocketIDArray[i])
			{
				m_AndroidUserSocketIDArray.RemoveAt(i);
				break;
			}
		}
		m_pIAttemperEngineSink->OnEventTCPNetworkShut(dwClientIP, dwActiveTime, dwSocketID);
	}
	catch (...) { return false; }

	return true;
}

//读取事件
bool  CAttemperEngine::OnEventTCPNetworkRead(DWORD dwSocketID, TCP_Command Command, VOID * pData, WORD wDataSize)
{
	//缓冲锁定
	CWHDataLocker lock(m_CriticalSection);

	try
	{
		bool bIsConnected = false;
		for (int i = 0; i < m_AndroidUserSocketIDArray.GetCount(); i++)
		{
			if (dwSocketID == m_AndroidUserSocketIDArray[i])
			{
				bIsConnected = true;
				break;
			}
		}
		ASSERT(bIsConnected);
		if (bIsConnected == false) return false;

		m_pIAttemperEngineSink->OnEventTCPNetworkRead(Command, pData, wDataSize, dwSocketID);
	}
	catch (...) { return false; }

	return true;
}

//////////////////////////////////////////////////////////////////////////
//建立对象函数
//
extern "C" __declspec(dllexport) void *  CreateAttemperEngine(const GUID & Guid, DWORD dwInterfaceVer)
{
	//建立对象
	CAttemperEngine * pAttemperEngine = NULL;
	try
	{
		pAttemperEngine = new CAttemperEngine();
		if (pAttemperEngine == NULL) throw TEXT("创建失败");
		void * pObject = pAttemperEngine->QueryInterface(Guid, dwInterfaceVer);
		if (pObject == NULL) throw TEXT("接口查询失败");
		return pObject;
	}
	catch (...) {}

	//清理对象
	SafeDelete(pAttemperEngine);
	return NULL;
}

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