crackmgr.cpp

网络游戏龙族 完整的登陆器 C++ 源代码

// CrackMgr.cpp: implementation of the CCrackMgr class.
//
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "CrackMgr.h"
#include "network.h"
#include "dragon.h"
#include "CurrentMsgMgr.h"
#include <Process.h>
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

const int CHECK_ACCEL_RECOMMAND_TIME	=	30000; // 30檬父俊 览翠 茄促

CCrackMgr CrackMgr;
CCrackMgr::CCrackMgr()
{
	m_i64Clock = 0;
	m_hCrackThread = INVALID_HANDLE_VALUE;
	SetThreadApplyGab(0);
	SetCTRun(false);
}

CCrackMgr::~CCrackMgr()
{

}

void CCrackMgr::InitCrackMgr()
{
	::memset(&RecvPacketSave,0,sizeof(t_server_check_accel));//罐篮 菩哦 绊措肺 焊包
	dwRecommandTime = 0;//览翠 秦具 且 矫埃
	dwRealTime		= 0;
	dwRecvedTime	= 0;
}

void CCrackMgr::RecvCheckAccel(t_server_check_accel *packet)//罐扁
{
	dwRealTime = timeGetTime();
	RecvPacketSave = *packet;
	dwRecvedTime	= dwRealTime;//罐篮 矫埃 悸泼
	dwRecommandTime = dwRealTime + CHECK_ACCEL_RECOMMAND_TIME;
}

void CCrackMgr::AutoCheckAccel()//焊郴扁 //磊悼栏肺 矫埃 拌魂 秦辑
{
//努扼捞攫飘 竣伎
	//霉 眉农饶 1檬 第俊 眉农茄促
	//眉农 沁阑锭 5% 捞惑狼 坷瞒啊 唱搁 肛苗 滚府磊
/*	CLOCK cl;
	GetNowClock(&cl);
	static __int64 s_i64Clock = *(__int64*)&cl;
	static	DWORD s_dwPreTime = ::timeGetTime();
	const DWORD dwTimeGab = ::timeGetTime() - s_dwPreTime;
	if( dwTimeGab > 1000 )//1檬啊 瘤车促搁
	{
		s_dwPreTime = ::timeGetTime();//矫埃 盎脚

		CLOCK cl2;
		GetNowClock(&cl2);//泅犁 努钒
		
		__int64 i64Curr = *(__int64*)&cl2;
		__int64 i64Result = i64Curr - s_i64Clock;

		if(i64Result)//乞闭 犁辑 m_i64Clock客 倔付唱 瞒捞唱绰瘤 犬牢
		{
			const __int64 i64NowClock = i64Result*1000/dwTimeGab;
//			::AddCurrentStatusMessage(FONT_COLOR_RED,"%d",i64NowClock);
			if( i64NowClock )//5%沥档肺 谗栏搁 亮阑鳖? .. -_-;..
			{
				if( m_i64Clock + (m_i64Clock*3/100) < i64NowClock //3% 倾侩 坷瞒甫 哈绢唱搁
				||	m_i64Clock - (m_i64Clock*3/100) > i64NowClock )
				{
//					JustMsg("Your System have problem");
//					g_DBGLog.Log(LOG_LV1, "Your System have problem (%d)", m_i64Clock);//葛靛 悸泼 扁废 瞪 颇老狼 绊蜡 捞抚涝聪促.
//					g_DBGLog.Log(LOG_LV1, "Your System have problem2 (%d)", i64NowClock);//葛靛 悸泼 扁废 瞪 颇老狼 绊蜡 捞抚涝聪促.
//					::ExitApplication(EA_CPU_CLOCK_ERROR);
//					::exit(0);
				}
			}
		}
		GetNowClock(&cl);
		s_i64Clock = *(__int64*)&cl;//货肺款 扁霖痢 努钒阑 悸泼
	}
*/

	if(!IsCrackThreadRun())
	{
		::ExitApplication(EA_CRACK_THREAD_FIND_CRACK);
	}
//辑滚竣伎饭捞磐
	if	((	!dwRecommandTime && dwRecvedTime)
		||(	dwRecommandTime && !dwRecvedTime))
	{//绢蠢 茄率父 悸泼捞 瞪锭
		ExitApplication(EA_CHECK_ACCEL);
	}
	const int iResult = (int)((int)dwRealTime-(int)dwRecommandTime);
	dwRealTime = timeGetTime();
	if(dwRecommandTime && dwRecvedTime)//览翠 矫埃捞 悸泼 登绢 乐促. 罐篮 矫埃捞 悸泼 登绢 乐促
	{	//	if( dwRealTime > dwRecommandTime)//捞霸 歹 农搁
		if(	0 < iResult )
		{
			t_packet	packet;
			packet.h.header.type		= CMD_CHECK_ACCEL;
			packet.h.header.size	= sizeof( t_server_check_accel );
			memcpy(&packet.u.server_check_accel ,&RecvPacketSave,sizeof( t_server_check_accel ));//酒鳖 罐篮芭
			QueuePacket( &packet, 1 );
			InitCrackMgr();//檬扁拳
		}
	}
}

void CCrackMgr::SetInitClock()
{
	m_i64Clock = GetAverageClock();//弥檬狼 努钒蔼阑 啊廉 可聪促.
}

__int64 CCrackMgr::GetAverageClock()
{
	CLOCK	cl ={0,};
	GetNowClock(&cl);
	__int64 prv = *(__int64*)&cl;

	Sleep(1000);// 1檬埃狼 努钒阑 眉农窍磊...
	
	GetNowClock(&cl);// 唱吝 努钒阑 掘绢辑..
	__int64 cur = *(__int64*)&cl;

	return cur - prv;// 哗搁...		// 600MHz cpu扼搁...ex) 600698387, 
}

void __stdcall CCrackMgr::GetNowClock(CLOCK* pClock)
{
	__asm
	{
		mov			esi,dword ptr[pClock]
		rdtsc
		mov			dword ptr[esi],eax
		mov			dword ptr[esi+4],edx
	}
}

bool CCrackMgr::StartCrackThread()//农发 眉农 静饭靛 矫累窍霸 窍扁
{//扩档快 滚傈阑 眉农窍咯 牢沥 瞪 荐 乐绰 案阑 悸泼 钦聪促.
	const DWORD dwVersion = ::GetVersion();

	// Get the Windows version.
	const DWORD dwWindowsMajorVersion =  (DWORD)(LOBYTE(LOWORD(dwVersion)));
	const DWORD dwWindowsMinorVersion =  (DWORD)(HIBYTE(LOWORD(dwVersion)));

	// Get the build number.
	if (dwVersion < 0x80000000)              // Windows NT/2000/XP
	{
//		dwBuild = (DWORD)(HIWORD(dwVersion));
		SetThreadApplyGab(500);
	}
	else if (dwWindowsMajorVersion < 4)      // Win32s
	{
//		dwBuild = (DWORD)(HIWORD(dwVersion) & ~0x8000);
		SetThreadApplyGab(1500);
	}
	else                                     // Windows 95/98/Me
	{
//		dwBuild =  0;
		SetThreadApplyGab(2000);
	}


	m_hCrackThread = (HANDLE)::_beginthreadex(NULL,0, &CrackCheckThread, NULL,0,(unsigned int*)&m_dwThreadNo);
	
	int temp = GetThreadPriority(m_hCrackThread);
	
	const BOOL bIsOk = ::SetThreadPriority(m_hCrackThread,THREAD_PRIORITY_TIME_CRITICAL);
	const int ret = ::GetThreadPriority(m_hCrackThread);

	if(INVALID_HANDLE_VALUE == m_hCrackThread)
	{
		SetCTRun(false);
	}
	else
	{
		SetCTRun(true);
	}
	return (GetCTRun() && bIsOk);
}

bool CCrackMgr::StopCrackThread()//农发 眉农 静饭靛 肛眠霸窍扁
{
	if(IsCrackThreadRun())
	{
		SetCTRun(false);
		::CloseHandle(m_hCrackThread);
		m_hCrackThread = INVALID_HANDLE_VALUE;
		return true;
	}
	return false;
}

bool CCrackMgr::IsCrackThreadRun()//农发 眉农 静饭靛 肛眠霸窍扁
{
	if(m_hCrackThread != INVALID_HANDLE_VALUE //勤甸捞 冠混 车芭唱
	|| GetCTRun())//敲贰弊啊 波柳促搁
	{
		return true;
	}
	return false;
}

unsigned __stdcall CrackCheckThread(LPVOID pValue)
{	//< CSD-030808
	// 031110 YGI
#ifdef _DEBUG	
	return 0;
#endif
	////////////////
	const int i1Sec = 1000;

	BOOL bTGT_SLP	= false;
	BOOL bGTC_SLP	= false;
	BOOL bTGT_GTC	= false;
	DWORD dwPrevTGT = 0, dwNowTGT = 0;
	DWORD dwPrevGTC = 0, dwNowGTC = 0;
	while(true)
	{
		if(!CrackMgr.IsCrackThreadRun())
		{
			::_endthread();
			::exit(0);
		}

		dwPrevTGT = ::timeGetTime();		
		::Sleep(1000);
		dwNowTGT = ::timeGetTime();
		
		DWORD dwRetTGT = dwNowTGT-dwPrevTGT;
		if(	i1Sec+CrackMgr.GetThreadApplyGab() < dwRetTGT)
		{
//			g_DBGLog.Log(LOG_LV1, "Your System have problem Type(%d) ", dwRetTGT);//	,dwRetGTC);//葛靛 悸泼 扁废 瞪 颇老狼 绊蜡 捞抚涝聪促.
//			::ExitApplication(EA_CRACK_THREAD_FIND_CRACK);
			bTGT_SLP = true;
		}


		t_packet	p;
		p.h.header.type = CMD_SEND_ACCEL_TYPE;
		p.h.header.size = sizeof(t_ACCEL_TYPE);
		p.u.Accel_Type.nType = 0;//泅犁绰 静捞瘤 臼绰促.
		
		dwPrevGTC = ::GetTickCount();
		::Sleep(1000);
		dwNowGTC = ::GetTickCount();

		DWORD dwRetGTC = dwNowGTC - dwPrevGTC;

		if(	i1Sec+CrackMgr.GetThreadApplyGab() < dwRetGTC)
		{
			bGTC_SLP = true;
		}

		
		dwPrevGTC	 = GetTickCount();
		dwPrevTGT = ::timeGetTime();		
		while (GetTickCount() - dwPrevGTC < 1000)
		{	// 1檬埃 掉饭捞
			Sleep(1);
		}

		dwNowTGT = ::timeGetTime();
		dwRetTGT = dwNowTGT-dwPrevTGT;
		if(	i1Sec+CrackMgr.GetThreadApplyGab() < dwRetTGT)
		{
//			g_DBGLog.Log(LOG_LV1, "Your System have problem Type(%d) ", dwRetTGT);//	,dwRetGTC);//葛靛 悸泼 扁废 瞪 颇老狼 绊蜡 捞抚涝聪促.
//			::ExitApplication(EA_CRACK_THREAD_FIND_CRACK);
			bTGT_GTC = true;
		}
		
		if(bTGT_SLP)//timeGetTime苞 sleep俊辑 巩力啊 积板促.
		{
			if(!bGTC_SLP)//GetTickCount 客 sleep巩力绰 绝促.
			{
				if(bTGT_GTC)//timeGetTime苞 GetTickCount俊 巩力啊 积板促.
				{
					//timeGetTime捞 扰欧 寸沁促.
					strcpy(p.u.Accel_Type.strMsg,"timeGetTime");
					::QueuePacket(&p,1);//辑滚肺 焊辰促.
				}
			}
			else
			{
				if(bTGT_GTC)//timeGetTime苞 GetTickCount俊 巩力啊 积板促.
				{
					//悸促 巩力啊 乐促.
					strcpy(p.u.Accel_Type.strMsg,"timeGetTime and GetTickCount and Sleep");
					::QueuePacket(&p,1);//辑滚肺 焊辰促.
				}
				else
				{
					//Sleep捞 巩力促.
					strcpy(p.u.Accel_Type.strMsg,"Sleep");
					::QueuePacket(&p,1);//辑滚肺 焊辰促.
				}
			}
		}
		else if(bTGT_GTC)//timeGetTime苞 GetTickCount啊 巩力啊 积板促.
		{
			if(bGTC_SLP)
			{
				//GetTickCount啊 巩力促.
				strcpy(p.u.Accel_Type.strMsg,"GetTickCount");
				::QueuePacket(&p,1);//辑滚肺 焊辰促.
			}
			else
			{
				//绢蠢 巩力牢瘤 舅荐啊 绝促.
				strcpy(p.u.Accel_Type.strMsg,"Unknown");
				::QueuePacket(&p,1);//辑滚肺 焊辰促.

			}
			
		}
		else if(bGTC_SLP)
		{
			//绢蠢 巩力牢瘤 舅荐啊 绝促.
			strcpy(p.u.Accel_Type.strMsg,"Unknown");
//			::QueuePacket(&p,1);//辑滚肺 焊辰促.
		}
		
	}
	CrackMgr.SetCTRun(false);
//#endif
	return 0;
}	//> CSD-030808

BOOL DumpException(LPEXCEPTION_POINTERS lpExcep,char* szOutMsg)
{
	if (!lpExcep)
		return FALSE;

	BOOL		result = TRUE;
	SYSTEMTIME time;

	const DWORD		dwExceptionAddress = (DWORD)lpExcep->ExceptionRecord->ExceptionAddress;
	const DWORD		dwExceptionCode = lpExcep->ExceptionRecord->ExceptionCode;
	const DWORD		dwExceptionFlags = lpExcep->ExceptionRecord->ExceptionFlags;
	const DWORD		dwNumberParameters = lpExcep->ExceptionRecord->NumberParameters;
	const DWORD		dwDr0 = lpExcep->ContextRecord->Dr0;
	const DWORD		dwDr1 = lpExcep->ContextRecord->Dr1;
	const DWORD		dwDr2 = lpExcep->ContextRecord->Dr2;
	const DWORD		dwDr3 = lpExcep->ContextRecord->Dr3;
	const DWORD		dwDr6 = lpExcep->ContextRecord->Dr6;
	const DWORD		dwDr7 = lpExcep->ContextRecord->Dr7;

	const DWORD		dwSegCs = lpExcep->ContextRecord->SegCs;

	const DWORD		dwSegGs = lpExcep->ContextRecord->SegGs;
	const DWORD		dwSegFs = lpExcep->ContextRecord->SegFs;
	const DWORD		dwSegEs = lpExcep->ContextRecord->SegEs;
	const DWORD		dwEFlags = lpExcep->ContextRecord->EFlags;

	const DWORD		dwEsi = lpExcep->ContextRecord->Esi;
	const DWORD		dwEdi = lpExcep->ContextRecord->Edi;
	const DWORD		dwEbp = lpExcep->ContextRecord->Ebp;
	const DWORD		dwEsp = lpExcep->ContextRecord->Esp;
	const DWORD		dwEip = lpExcep->ContextRecord->Eip;

	const DWORD		dwEax = lpExcep->ContextRecord->Eax;
	const DWORD		dwEbx = lpExcep->ContextRecord->Ebx;
	const DWORD		dwEcx = lpExcep->ContextRecord->Ecx;
	const DWORD		dwEdx = lpExcep->ContextRecord->Edx;
	__try
	{
		GetLocalTime(&time);
	
		g_CrashLog.Log(LOG_LV1,"%04d-%02d-%02d-%02d-%02d-%02d",
			time.wYear,time.wMonth,time.wDay,time.wMinute,time.wSecond);
		
		g_CrashLog.Log(LOG_LV1,szOutMsg);

		g_CrashLog.Log(LOG_LV1,"Crashed address %xh",dwExceptionAddress);

		g_CrashLog.Log(LOG_LV1,"Crashed Map Address %04X:%08X",
			dwSegCs,
			dwExceptionAddress);

		g_CrashLog.Log(LOG_LV1,"Exception Code %u",dwExceptionCode);
		g_CrashLog.Log(LOG_LV1,"Exception Flag %xh",dwExceptionFlags);
		g_CrashLog.Log(LOG_LV1,"NumberParameters %d",dwNumberParameters);
		g_CrashLog.Log(LOG_LV1,"Dr0 %xh",dwDr0);
		g_CrashLog.Log(LOG_LV1,"Dr1 %xh",dwDr1);
		g_CrashLog.Log(LOG_LV1,"Dr2 %xh",dwDr2);
		g_CrashLog.Log(LOG_LV1,"Dr3 %xh",dwDr3);
		g_CrashLog.Log(LOG_LV1,"Dr6 %xh",dwDr6);
		g_CrashLog.Log(LOG_LV1,"Dr7 %xh",dwDr7);
		
		g_CrashLog.Log(LOG_LV1,"SegGs %xh",dwSegGs);
		g_CrashLog.Log(LOG_LV1,"SegFs %xh",dwSegFs);
		g_CrashLog.Log(LOG_LV1,"SegEs %xh",dwSegEs);
		g_CrashLog.Log(LOG_LV1,"EFlags %xh",dwEFlags);
		
		g_CrashLog.Log(LOG_LV1,"Esi %xh",dwEsi);
		g_CrashLog.Log(LOG_LV1,"Edi %xh",dwEdi);
		g_CrashLog.Log(LOG_LV1,"Ebp %xh",dwEbp);
		g_CrashLog.Log(LOG_LV1,"Esp %xh",dwEsp);
		g_CrashLog.Log(LOG_LV1,"Eip %xh",dwEip);
		

		g_CrashLog.Log(LOG_LV1,"Eax %xh",dwEax);
		g_CrashLog.Log(LOG_LV1,"Ebx %xh",dwEbx);
		g_CrashLog.Log(LOG_LV1,"Ecx %xh",dwEcx);
		g_CrashLog.Log(LOG_LV1,"Edx %xh",dwEdx);

		g_CrashLog.Log(LOG_LV1,"Log Complete!");

	}
	__except (GetExceptionCode())
	{
		result = FALSE;
	}

	return result;
}