myvtm/Module/mod_heartbeat/HeartBeatFSM.cpp

#include "stdafx.h"
#include <string.h>
#include "HeartBeatFSM.h"
#include "HeartBeat_UserErrorCode.h"

#ifdef RVC_OS_WIN
#pragma comment (lib, "Ws2_32.lib")
#pragma comment (lib, "Mswsock.lib")
#pragma comment (lib, "AdvApi32.lib")
#pragma comment(lib, "pdh.lib")
#endif //RVC_OS_WIN
using namespace CardIssuer;
using namespace PinPad;
using namespace CardReadAdapter;
using namespace IDCertificate;
#include "EventCode.h"
#include "DeviceCrossHelper.h"
const int DEFAULT_BUFLEN = 2048;
const int MAX_SEND_FAILED_TIMES = 5;
const int MAX_INIT_TIMES = 5;
//#define DEFAULT_PORT "408"

// Termainal Performance Counter Component [Josephus in 9:31:27 2016/4/23]
CONST ULONG COUNTER_INTERVAL_MS = 1000;

const char * AvailMemoryQuery	= "\\Memory\\Available MBytes";
const char * HandleNumQuery		= "\\Process(_Total)\\Handle Count";
const char * ThreadNumQuery		= "\\Process(_Total)\\Thread Count";
const char * ProcessNumQuery	= "\\System\\Processes";
const char * SystemElapsedQuery = "\\System\\System Up Time";
const char * ProcessTimeQuery	= "\\Processor Information(_Total)\\% Processor Time";

#define DIV (1024 * 1024)
#define DAY_DIV (24 * 60 * 60)
#define HOURS_DIV (60 * 60)
#define MINUS_DIV (60)

// End Performance Component [Josephus in 9:32:05 2016/4/23]
//oiltmp need to move together?
int StrBuf2HexBuf(LPCTSTR strBuf, PBYTE* hexBuf)
{
	int len = strlen(strBuf);
	if (len == 0 || len % 2 != 0)
		return 0;
	BYTE* buf = new BYTE[len / 2];
	if (buf == NULL)
		return 0;
	int j = 0;
	for (int i = 0; i < len;)
	{
		int tmpVal;
		sscanf(strBuf + i, "%2X", &tmpVal);
		buf[j] = tmpVal;
		//buf[j] = char2int(strBuf[i])*16 + char2int(strBuf[i+1]);
		i += 2;
		j++;
	}
	//memcpy(buf,strBuf,len);
	*hexBuf = buf;
	return j;
}
int HexBuf2StrBuf(PBYTE hexBuf, char** strBuf, DWORD len)
{
	char* tmpStr = *strBuf;
	int count = 0;
	for (int i = 0; i < len; ++i)
	{
		sprintf(tmpStr + count, "%0.2X", hexBuf[i]);
		count += 2;
	}
	return count;
}
ErrorCodeEnum CHeartBeatFSM::OnInit()
{
	LOG_FUNCTION();
	GetEntityBase()->GetFunction()->SetSysVar("HeartbeatState","S");
	ErrorCodeEnum Error;
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	CSystemStaticInfo sysInfo;
	Error = GetEntityBase()->GetFunction()->GetSystemStaticInfo(sysInfo);
	if(Error == Error_Succeed) {
		m_bJBMachine = !sysInfo.strMachineType.Compare("RVC.IL", true);
		m_localDeviceNo = sysInfo.strTerminalID;
	}

	Error = spEntityFunction->OpenConfig(Config_CenterSetting, spConfig);
	if (Error != Error_Succeed) {
		LOG_TRACE("open cfg file failed!");
		//logwarn oiltest
		return Error_DevLoadFileFailed;
	}
	m_tmpTestFlag = 0;
	spConfig->ReadConfigValue(GetEntityBase()->GetEntityName(),"Server",m_servStr);
	spConfig->ReadConfigValue(GetEntityBase()->GetEntityName(),"Server_Backup",m_servStrB);
	if (!m_servStr.IsNullOrEmpty())
	{
		CAutoArray<CSimpleStringA> aaServ = m_servStr.Split(' ');
		if (aaServ.GetCount() >= 2)
		{
			m_servIP = aaServ[0];
			m_port = atoi(aaServ[1]);
		}
		else
		{
			Dbg("cfg error!");
			GetEntityBase()->GetFunction()->ShowFatalError("实体HeartBeat找不到对应的配置，请检查集中配置");
			return Error_Param;
		}
	}
	if (!m_servStrB.IsNullOrEmpty())
	{
		CAutoArray<CSimpleStringA> aaServB = m_servStrB.Split(' ');
		if (aaServB.GetCount() >= 2)
		{
			m_servIPB = aaServB[0];
			m_portB = atoi(aaServB[1]);
		}
		else
		{
			Dbg("no backup(%s).",(LPCSTR)m_servStrB);
			m_servIPB = m_servIP;
			m_portB = m_port;
		}
	}
	Dbg("%s,%d;%s,%d",(LPCTSTR)m_servIP,m_port,(LPCTSTR)m_servIPB,m_portB);
	spConfig->ReadConfigValueInt(GetEntityBase()->GetEntityName(),"TestFlag",m_tmpTestFlag);
	//网络字节序
	//由于双活改造，改成固定ip，分行服务有处理
	m_servIP = "99.1.100.215";
	m_dwServIP = inet_addr(m_servIP);
	m_csServerIP = m_servIP;

	CSimpleStringA csRunDiskName("C:\\");
	Error = GetEntityBase()->GetFunction()->GetPath("Run", csRunDiskName);
	Dbg("GetPath of run is %s 0x%x", (LPCTSTR)csRunDiskName, Error);
	CAutoArray<CSimpleStringA> arrays = csRunDiskName.Split('\\');
	if(arrays.GetCount() > 0)
	{
		m_csRunDiskName = arrays[0] + "\\";
		Dbg("m_csRunDiskName is %s", (LPCTSTR)m_csRunDiskName);
	}
	else
	{
		Dbg("Split rundisk file string(%s) failed", (LPCTSTR)csRunDiskName);
		return Error_Unexpect;
	}
	//CSimpleStringA csTradeState("B");
	//Error = GetEntityBase()->GetFunction()->GetSysVar("TradeManageState",csTradeState);
	//if (Error == Error_Succeed)
	//{
	//	Dbg("First get TradeManageState:%s",(const char*)csTradeState);
	//	if (csTradeState.Compare("L",true) == 0)
	//		m_tradeState = 8;
	//}
	return Error_Succeed;
}
ErrorCodeEnum CHeartBeatFSM::OnExit()
{
	return Error_NotImpl;
}
//Init(Stop)
void CHeartBeatFSM::s0_on_entry()
{
	//LOG_FUNCTION();
	
	{
		//check if can start to work(handshake...)
		//1.check if AccessAuthorization have finished
		//2.check if network connected
		//3.check if framework on Exitting or Terminating

		//all of above have checked,start to work
		if (m_pHandShakeConn != NULL)
		{
			Dbg("init connection.");
			m_pHandShakeConn->Close();
			m_pHandShakeConn->DecRefCount();
			m_pHandShakeConn = NULL;
		}
		FSMEvent *e = new FSMEvent(USER_EVT_START);
		PostEventFIFO(e);
		m_initTimes++;
		if (m_initTimes > 1)
			Sleep(30000);
		if (m_initTimes > MAX_INIT_TIMES)
		{
			Dbg("have try to init x times,give up!");
			//logwarn oiltest
			m_initTimes = 0;
		}
	}
	
}
void CHeartBeatFSM::s0_on_exit()
{
}
unsigned int CHeartBeatFSM::s0_on_event(FSMEvent* pEvt)
{
	switch(pEvt->iEvt)
	{
	case USER_EVT_START:
		{
			StartTask* task = new StartTask(this);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
			pEvt->SetHandled();
		}
		return 0;
	default:
		break;
	}
	return 0;
}
//Starting
void CHeartBeatFSM::s1_on_entry()
{
	//LOG_FUNCTION();
}
void CHeartBeatFSM::s1_on_exit()
{
}
unsigned int CHeartBeatFSM::s1_on_event(FSMEvent* pEvt)
{
	switch(pEvt->iEvt)
	{
	case USER_EVT_STARTFINISHED:
		pEvt->SetHandled();
		if (pEvt->param1 == 0)
		{
			HandShakeTask* task = new HandShakeTask(this);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
			pEvt->SetHandled();
			return 0;
		}
		else 
		{
			// SetFlag for MobileDial entity. [Josephus in 11:40:29 2016/8/16]
			GetEntityBase()->GetFunction()->SetSysVar("HeartbeatState","D");
			return 1;
		}
		break;
	default:
		break;
	}
	return 0;
}
//Connnected
void CHeartBeatFSM::s2_on_entry()
{
	LOG_FUNCTION();
	m_initTimes = 0;
	m_testResult = Error_Succeed;
	LogEvent(Severity_Middle, LOG_EVT_HEARTBEAT_CONNECTED, "Branch heartbeat service connected.");
}
void CHeartBeatFSM::s2_on_exit()
{
}
unsigned int CHeartBeatFSM::s2_on_event(FSMEvent* pEvt)
{
	switch(pEvt->iEvt)
	{
	case USER_EVT_INSTRUCTION:
		{
			InstructionEvent *pIE = dynamic_cast<InstructionEvent*>(pEvt);
			pEvt->SetHandled();
			DoInstruction(pIE->ctx);
		}
		break;
	case USER_EVT_HANDSHAKEFINISHED:
		pEvt->SetHandled();
		break;
	case USER_EVT_STOP:
		pEvt->SetHandled();
		break;
	case USER_EVT_START:
		pEvt->SetHandled();
		break;
	case USER_EVT_CARD_ACTIVE:
	{
								 Dbg("s2 card active.");
								 pEvt->SetHandled();
								 CardActiveEvent *pcae = dynamic_cast<CardActiveEvent*>(pEvt);
								 CardActiveTask *pTask = new CardActiveTask(this);
								 pTask->ctx = pcae->ctx;
								 GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
	}
		
		break;
	case USER_EVT_CARD_ACTIVE_FINISHED:
		pEvt->SetHandled();
		break;
	case USER_EVT_CROSS_TERM_CALL:
	{
		pEvt->SetHandled();
		CrossTermCallEvent* pCTCE = dynamic_cast<CrossTermCallEvent*>(pEvt);
		CrossTermCallTask *pTask = new CrossTermCallTask(this);
		pTask->ctx = pCTCE->ctx;
		Dbg("s2 cross call,type %x.",pCTCE->ctx->Req.type);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
	}
	break;
	case USER_EVT_CROSS_TERM_CALL_FINISHED:
		pEvt->SetHandled();
		break;
	case USER_EVT_ILCallToRVC:
	{
		pEvt->SetHandled();
		ILCallToRVCEvent* pCTCE = dynamic_cast<ILCallToRVCEvent*>(pEvt);
		ILCallToRVCTask *pTask = new ILCallToRVCTask(this);
		pTask->ctx = pCTCE->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
	}
	break;
	case USER_EVT_CallResultToIL:
	{
		pEvt->SetHandled();
		CallResultToILEvent* pCTCE = dynamic_cast<CallResultToILEvent*>(pEvt);
		CallResultToILTask *pTask = new CallResultToILTask(this);
		pTask->ctx = pCTCE->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
	}
	break;
	default:
		break;
	}
	return 0;
}
//Lost
void CHeartBeatFSM::s3_on_entry()
{
	GetEntityBase()->GetFunction()->SetSysVar("HeartbeatState","L");
}
void CHeartBeatFSM::s3_on_exit()
{
}
unsigned int CHeartBeatFSM::s3_on_event(FSMEvent* pEvt)
{
	return 0;
}
//Reject
void CHeartBeatFSM::s4_on_entry()
{
	GetEntityBase()->GetFunction()->SetSysVar("HeartbeatState","R");
	FSMEvent *pStopEvt = new FSMEvent(USER_EVT_STOP);
	PostEventFIFO(pStopEvt);
}
void CHeartBeatFSM::s4_on_exit()
{
}
unsigned int CHeartBeatFSM::s4_on_event(FSMEvent* pEvt)
{
	switch(pEvt->iEvt)
	{
	case USER_EVT_STOP:
		pEvt->SetHandled();
		break;
	default:
		break;
	}
	return 0;
}
//Failed
void CHeartBeatFSM::s5_on_entry()
{
	m_testResult = Error_InvalidState;
}
void CHeartBeatFSM::s5_on_exit()
{
}
unsigned int CHeartBeatFSM::s5_on_event(FSMEvent* pEvt)
{
	return 0;
}
int CHeartBeatFSM::Starting()
{
	Dbg("starting.....");

	if (!m_pHandShakeConn) 
	{
		//HeartBeatConnection* pHandShakeConn;
		m_pHandShakeConn = new HeartBeatConnection(m_pEntity, this);
		if (m_pHandShakeConn != NULL)
		{
			bool bConn = false;
			bConn = m_pHandShakeConn->ConnectFromCentralSetting();
			//if (!m_bUseBackup)
			//{
			//	bConn = m_pHandShakeConn->Connect(m_servIP, m_port, 3);
			//	m_dwServIP = inet_addr(m_servIP);
			//	m_csServerIP = m_servIP;
			//}
			//else
			//{
			//	bConn = m_pHandShakeConn->Connect(m_servIPB, m_portB, 3);
			//	m_dwServIP = inet_addr(m_servIPB);
			//	m_csServerIP = m_servIPB;
			//}
			if (!bConn) 
			{
				m_pHandShakeConn->Close();
				//delete m_pHandShakeConn;//oiltest
				m_pHandShakeConn->DecRefCount();
				m_pHandShakeConn = NULL;
				Dbg("cannot connect to server.");
				//if (m_bUseBackup)
					LogEvent(Severity_Middle, LOG_EVT_HEARTBEAT_UN_CONNECTED, "Branch heartbeat service unconnected.");
				//m_bUseBackup = !m_bUseBackup;
				return 1;
			}
		}
		//else
			//Dbg("new heartbeatconnection failed.");
	}
	Dbg("start ok.");
	return 0;

/*
    WSADATA wsaData;
    m_ConnSocket = INVALID_SOCKET;
    struct addrinfo *result = NULL,*ptr = NULL,hints;
    int iResult;
    int recvbuflen = DEFAULT_BUFLEN;
    
    // Initialize Winsock
    iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
    if (iResult != 0) 
	{
        Dbg("WSAStartup failed with error: %d\n", iResult);
        return 1;
    }

    ZeroMemory( &hints, sizeof(hints) );
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_protocol = IPPROTO_TCP;

	//oiltest get from ini file
	Dbg("server %s,port %d",(LPCSTR)m_servIP,m_port);
    iResult = getaddrinfo(m_servIP, m_servPort, &hints, &result);
    if ( iResult != 0 ) 
	{
        Dbg("getaddrinfo failed with error: %d\n", iResult);
        WSACleanup();
        return 1;
    }

    for(ptr=result; ptr != NULL ;ptr=ptr->ai_next) 
	{
        m_ConnSocket = socket(ptr->ai_family, ptr->ai_socktype, 
            ptr->ai_protocol);
        if (m_ConnSocket == INVALID_SOCKET) 
		{
            Dbg("socket failed with error: %ld\n", WSAGetLastError());
            WSACleanup();
            return 1;
        }

        iResult = connect(m_ConnSocket, ptr->ai_addr, (int)ptr->ai_addrlen);
        if (iResult == SOCKET_ERROR) 
		{
            closesocket(m_ConnSocket);
            m_ConnSocket = INVALID_SOCKET;
            continue;
        }
        break;
    }
	Dbg("conn socket %d",m_ConnSocket);
    freeaddrinfo(result);

    if (m_ConnSocket == INVALID_SOCKET) 
	{
        Dbg("Unable to connect to server!\n");
        WSACleanup();
        return 1;
    }
	*/
}
int CHeartBeatFSM::DoHandShake()
{
	if (m_pHandShakeConn) {
		Dbg("start handshake");
		//oiltest sp_var_client_set has no write privilege!
		//GetEntityBase()->GetFunction()->SetSysVar("HeartbeatState","C");
		while (1)
		{
			//HeartBeatConnection* pHandShakeConn;
			//pHandShakeConn = new HeartBeatConnection(m_pEntity, this);
			//if (pHandShakeConn != NULL)
			//{
			//	bool bConn = false;
			//	if (!m_bUseBackup)
			//		bConn = pHandShakeConn->Connect(m_servIP, m_port, 3);
			//	else
			//		bConn = pHandShakeConn->Connect(m_servIPB, m_portB, 3);
			//	if (!bConn)
			//	{
			//		pHandShakeConn->Close();
			//		//delete m_pHandShakeConn;//oiltest
			//		pHandShakeConn->DecRefCount();
			//		pHandShakeConn = NULL;
			//		Dbg("cannot connect to server(%d).", m_bUseBackup);
			//		m_bUseBackup = !m_bUseBackup;
			//	}
			//}
			if (!m_pHandShakeConn || !m_pHandShakeConn->IsConnectionOK())
			{
				FSMEvent *e = new FSMEvent(USER_EVT_START);
				PostEventFIFO(e);
				break;
			}
			GetEntityBase()->GetFunction()->SetSysVar("HeartbeatState", "C");
			m_pHandShakeConn->SendHandShake();

			Sleep(20000);//oiltest
			if (m_tmpTestFlag)
			{
				Dbg("send spshell.exe restart event.");
				LogEvent(Severity_Middle, Event_Req_Framework_Restart, "spshell.exe restart");
			}
		}
	}
	/*
	char sendbuf[DEFAULT_BUFLEN];
	memset(sendbuf,0,sizeof(sendbuf));
	TerminalInfo* pTermInfo = (TerminalInfo*)sendbuf;
	memcpy(pTermInfo->TerminalNo,"12345678",8);

	//CSimpleStringA warningLevel,runState,customerHandle,callState,localMaintain,remoteMaintain;
	//oiltest set default value
	CSimpleStringA warningLevel("w"),runState("r"),customerHandle("c"),callState("s"),
		localMaintain("l"),remoteMaintain("m");
	Dbg("get sysvar");
	GetEntityBase()->GetFunction()->GetSysVar("WarningLevel",warningLevel);
	GetEntityBase()->GetFunction()->GetSysVar("RunState",runState);
	GetEntityBase()->GetFunction()->GetSysVar("CustomerHandle",customerHandle);
	GetEntityBase()->GetFunction()->GetSysVar("CallState",callState);
	GetEntityBase()->GetFunction()->GetSysVar("LocalMaintain",localMaintain);
	GetEntityBase()->GetFunction()->GetSysVar("RemoteMaintain",remoteMaintain);
	//oiltest byteorder
	pTermInfo->ip = m_ulServIP;
	pTermInfo->WarningLevel = warningLevel[0];
	pTermInfo->RunState = runState[0];
	pTermInfo->CustomerHandle = customerHandle[0];
	pTermInfo->CallState = callState[0];
	pTermInfo->LocalMaintain = localMaintain[0];
	pTermInfo->RemoteMaintain = remoteMaintain[0];
	Dbg("before send socket %d",m_ConnSocket);
	int sendFailedTimes = 0;
	while(1)
	{
		//oiltest break condition...
		//send machine info
		int iResult = send(m_ConnSocket, sendbuf, (int)sizeof(sendbuf), 0 );
		if (iResult == SOCKET_ERROR) 
		{
			Dbg("send failed with error: %d\n", WSAGetLastError());
			sendFailedTimes++;
			if (sendFailedTimes > MAX_SEND_FAILED_TIMES)
			{
				Dbg("have failed %d times,no send anymore.",sendFailedTimes);
				closesocket(m_ConnSocket);
				WSACleanup();
				break;
			}
		}

		Sleep(20000);//oiltest
	}
	*/
	return 0;
}
int CHeartBeatFSM::CardActive(SpReqAnsContext<HeartBeatService_CardActive_Req, HeartBeatService_CardActive_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	if (m_pHandShakeConn && m_pHandShakeConn->IsConnectionOK())
	{
		m_pHandShakeConn->SendCardActive(0,ctx->Req.slot, 0,(const char*)ctx->Req.term,(const char*)ctx->Req.account, ctx->Req.account.GetLength(), (const char*)ctx->Req.data, ctx->Req.data.GetLength(),0,0);
		ctx->Answer(Error_Succeed);
	}
	else
	{
		if (ctx->Req.account.GetLength() > 6)
			Dbg("acc:%s****%s,no connection.", (const char*)ctx->Req.account.SubString(0, 6), (const char*)ctx->Req.account.SubString(ctx->Req.account.GetLength() - 4, 4));
		else
			Dbg("acc:%s, size:%d", (const char*)ctx->Req.account,ctx->Req.account.GetLength());
		ctx->Answer(Error_Unexpect);
	}
	return 0;
}
void CHeartBeatFSM::DoInstruction(SpReqAnsContext<HeartBeatService_Instruction_Req, HeartBeatService_Instruction_Ans>::Pointer ctx)
{
	switch(ctx->Req.type)
	{
	case INC_GLOBAL_SETTING_SYNC:
		break;
	case INC_COMM_RECONNECT:
		break;
	case INC_START_REMOTE_CONTROL:
		break;
	case INC_UPDATE_CHECK:
		break;
	case INC_RECOVER_SERVICE:
		break;
	case INC_PAUSE_SERVICE:
		break;
	case INC_AREA_SERVICE_SWITCH:
		break;
	default:
		break;
	}
}
ErrorCodeEnum CHeartBeatFSM::SetErrorList(int warmLevel,CSimpleStringA strList)
{
	m_warnLevel = warmLevel;
	m_entErrorList = strList;
	Dbg("strList[%s]",(LPCTSTR)strList);
	return Error_Succeed;
}
void CHeartBeatFSM::SelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext)
{
	//for simple
	pTransactionContext->SendAnswer(m_testResult);
}
void CHeartBeatFSM::LocalPreOnline(int slot, CSimpleStringA fromTermNo,CSimpleStringA termNo, CSimpleStringA account, CSimpleStringA data)
{
	LOG_FUNCTION();
	CardReadAdapterService_ClientBase *pCardReadAdapterClient = NULL;
	ErrorCodeEnum eErr = Error_Unexpect;
	pCardReadAdapterClient = new CardReadAdapterService_ClientBase(GetEntityBase());
	if (pCardReadAdapterClient != NULL)
		eErr = pCardReadAdapterClient->Connect();
	if (pCardReadAdapterClient == NULL || eErr != Error_Succeed)
	{
		CSimpleStringA errMsg = CSimpleStringA::Format("LocalPreOnline, pGuiConsoleClient is null or connect CardReadAdapter failed:%d(0x%x)", eErr, eErr);
		LogWarn(Severity_Low, Error_Unexpect, HeartBeat_UserErrorCode_Connect_CardReader_Failed, errMsg.GetData());
		return;
	}
	CardReadAdapterService_PreOnline_Req req;
	CardReadAdapterService_PreOnline_Ans ans;
	CSimpleStringA outParam("");
	req.businessData = data;
	char buf[16];
	ZeroMemory(buf, sizeof(buf));
	_itoa(slot, buf, 10);
	CSimpleStringA kaku("kaku#");
	req.module = 1;
	req.reserved2.Init(2);
	req.reserved2[0] = kaku + CSimpleStringA(buf);
	Dbg("local:%s", (const char*)req.reserved2[0]);
	req.reserved2[1] = account;
	CSimpleStringA inParam = CSimpleStringA::Format("PreOnline, CardStore heartbeat invodk PreOnline, slot:%s, accountLen:%d", req.reserved2[0].GetData(), account.GetLength());
	LogWarn(Severity_Low, Error_Unexpect, HeartBeat_UserErrorCode_Connect_CardStore_Invoke_PreOnline_Inparam, inParam.GetData());
	eErr = pCardReadAdapterClient->PreOnline(req, ans, 65000);
	if (eErr != Error_Succeed) {
		outParam = CSimpleStringA::Format("local preonline failed:%d(0x%x)", eErr, eErr);
		LogWarn(Severity_Low, Error_Unexpect, HeartBeat_UserErrorCode_Connect_CardStore_Invoke_PreOnline_Falied, inParam.GetData());
	}
	CardReadAdapterService_QueryCardInfoOnStore_Req reqX;
	CardReadAdapterService_QueryCardInfoOnStore_Ans ansX;
	ErrorCodeEnum eErrX = Error_Unexpect;
	eErrX = pCardReadAdapterClient->QueryCardInfoOnStore(reqX, ansX,12000);
	if (eErrX != Error_Succeed)
	{
		outParam = CSimpleStringA::Format("QueryCardInfoOnStore failed.%d", eErrX);
		LogWarn(Severity_Low, Error_Unexpect, HeartBeat_UserErrorCode_Connect_CardStore_Invoke_QueryCardInfoOnStore_Falied, inParam.GetData());
		ansX.findCard = ansX.cardPos = 9999;
	}
	if (m_pHandShakeConn && m_pHandShakeConn->IsConnectionOK())
	{
		m_pHandShakeConn->SendCardActive(1,slot,eErr, (const char*)termNo, (const char*)account,
			account.GetLength(), (const char*)ans.result, ans.result.GetLength(),ansX.findCard,ansX.cardPos);
	}
}
void CHeartBeatFSM::ReceivePreOnlineBack(unsigned long errCode,CSimpleStringA data, unsigned long findCard, unsigned long cardPos)
{
	CardIssuerService_ClientBase *pCardIssuerClient = NULL;
	ErrorCodeEnum eErr = Error_Unexpect;
	pCardIssuerClient = new CardIssuerService_ClientBase(GetEntityBase());
	if (pCardIssuerClient != NULL)
		eErr = pCardIssuerClient->Connect();
	if (pCardIssuerClient == NULL || eErr != Error_Succeed)
	{
		Dbg("pGuiConsoleClient is null or connect to cardissuer failed.%d", eErr);
		return;
	}
	CardIssuerService_NotifyPreonline_Req req;
	CardIssuerService_NotifyPreonline_Ans ans;
	req.data = data;
	req.findCard = findCard;
	req.cardPos = cardPos;
	req.errCode = errCode;
	eErr = pCardIssuerClient->NotifyPreonline(req, ans, 10000);
	Dbg("NotifyPreonline ret:%d",eErr);
}
int CHeartBeatFSM::CrossTermCall(SpReqAnsContext<HeartBeatService_CrossTermCall_Req, HeartBeatService_CrossTermCall_Ans>::Pointer ctx)
{
	int ret = 0;
	Dbg("cross term call,type:%x, entity: 0x%x",ctx->Req.type, ctx->Req.nEntityID);
	switch (ctx->Req.nEntityID)
	{
	case 0x206:
	case 0x201:
	case 0x218:
	case 0x21B:
		ret = ProcessCrossCallToHBService(ctx->Req.type,ctx);
		break;
	default:
		break;
	}
	return ret;
}
int CHeartBeatFSM::ProcessCrossCallToHBService(int callType, SpReqAnsContext<HeartBeatService_CrossTermCall_Req, HeartBeatService_CrossTermCall_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	ctx->Answer(Error_Succeed);
	return SendToHeartBeatService(ctx->Req,ctx->Ans);
}
void CHeartBeatFSM::DoLocalProcessCrossCallTask(CrossCallReq *reqInfo, const int nBufSize)
{
	if (GetTerminalStageState().Compare("A"))
	{
		Dbg("Terminal havn't been auth suc,forbid cross call.");
		return;
	}

	LocalProcessCrossCallTask *pTask = new LocalProcessCrossCallTask(this, reqInfo, nBufSize);
	GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
}
int CHeartBeatFSM::LocalProcessCrossCall(CrossCallReq* reqInfo, const int nBufSize)
{
	LOG_FUNCTION();

	if(reqInfo == NULL) {
		return -1;
	}
	Dbg("entity sn:%x,is RVC.IL:%d,bTwoWay:%d", reqInfo->nEntityID, m_bJBMachine, reqInfo->bTwoWay);
	if(m_bJBMachine) { //简版心跳逻辑，那么接收到的应该是回收包
		switch(reqInfo->nEntityID) //实体ID
		{
		case 0x201:
		{
			ErrorCodeEnum ec = Error_Succeed;
			IDCertService_ClientBase* pClient = new IDCertService_ClientBase(GetEntityBase());
			ec = pClient->Connect();
			if (ec == Error_Succeed) {
				IDCertService_CrossTermInvokeInfo_Info info;
				info.type = reqInfo->CallType;
				info.nEntityID = reqInfo->nEntityID;
				info.result = reqInfo->ErrorCode;
				SpBuffer spbuf2;
				int xSize = nBufSize - FIELD_OFFSET(CrossCallReq, StrParamX);
				Dbg("offset %d, %d", FIELD_OFFSET(CrossCallReq, StrParamX), xSize);
				bool bBuf = spbuf2.OpenRead((const char*)&(reqInfo->StrParamX[0]), xSize);
				if (bBuf) {
					Dbg("offset succ.");
					if (xSize > 0)
						info.paramX = spbuf2.ToBlob();
				}

				ec = pClient->CrossTermInvokeInfo(info);
				Dbg("CrossTermInvokeInfo return %d", ec);
			}
			else {
				Dbg("Connect to IDCertificate failed %d", ec);
			}
		}
			break;
		case 0x206://pinpad
		{
			ErrorCodeEnum ec = Error_Succeed;
			PinPadService_ClientBase* pClient = new PinPadService_ClientBase(GetEntityBase());
			ec = pClient->Connect();
			if (ec == Error_Succeed) {
				PinPadService_CrossTermInvokeInfo_Info info;
				info.type = reqInfo->CallType;
				info.nEntityID = reqInfo->nEntityID;
				info.result = reqInfo->ErrorCode;
				SpBuffer spbuf2;
				int xSize = nBufSize - FIELD_OFFSET(CrossCallReq, StrParamX);
				Dbg("offset %d, %d", FIELD_OFFSET(CrossCallReq, StrParamX), xSize);
				bool bBuf = spbuf2.OpenRead((const char*)&(reqInfo->StrParamX[0]), xSize);
				if (bBuf) {
					Dbg("offset succ.");
					if (xSize > 0)
						info.paramX = spbuf2.ToBlob();
				}

				ec = pClient->CrossTermInvokeInfo(info);
				Dbg("CrossTermInvokeInfo return %d", ec);
			}
			else {
				Dbg("Connect to PinPad failed %d", ec);
			}
		}
		break;
		case 0x218:
			{
				Dbg("Scanner set");
				ErrorCodeEnum ec = Error_Succeed;
				ScannerService_ClientBase* pClient = new ScannerService_ClientBase(GetEntityBase());
				ec = pClient->Connect();
				if(ec == Error_Succeed) {
					ScannerService_CrossTermInvokeInfo_Info info;
					info.type = reqInfo->CallType;
					info.nEntityID = reqInfo->nEntityID;
					info.result = reqInfo->ErrorCode;
					SpBuffer spbuf2;
					int size = nBufSize - FIELD_OFFSET(CrossCallReq, StrParamX);
					Dbg("offset %d, %d", FIELD_OFFSET(CrossCallReq, StrParamX) , size);
					bool bBuf = spbuf2.OpenRead((const char*)&(reqInfo->StrParamX[0]), size);
					if(bBuf) {
						Dbg("offset succ.");
						if(size > 0) {
							info.paramX = spbuf2.ToBlob();
						}
					}
					ec = pClient->CrossTermInvokeInfo(info);
					Dbg("CrossTermInvokeInfo return %d", ec);
				} else {
					Dbg("Connect to scanner failed %d", ec);
				}
			}
			break;
		case 0x21B:
		{
			ErrorCodeEnum ec = Error_Succeed;
			CardReadAdapterService_ClientBase* pClient = new CardReadAdapterService_ClientBase(GetEntityBase());
			ec = pClient->Connect();
			if (ec == Error_Succeed) {
				CardReadAdapterService_CrossTermInvokeInfo_Info info;
				info.type = reqInfo->CallType;
				info.nEntityID = reqInfo->nEntityID;
				info.result = reqInfo->ErrorCode;
				SpBuffer spbuf2;
				int xSize = nBufSize - FIELD_OFFSET(CrossCallReq, StrParamX);
				Dbg("offset %d, %d", FIELD_OFFSET(CrossCallReq, StrParamX), xSize);
				bool bBuf = spbuf2.OpenRead((const char*)&(reqInfo->StrParamX[0]), xSize);
				if (bBuf) {
					Dbg("offset succ.");
					if (xSize > 0)
						info.paramX = spbuf2.ToBlob();
				}

				ec = pClient->CrossTermInvokeInfo(info);
				Dbg("CrossTermInvokeInfo return %d", ec);
			}
			else {
				Dbg("Connect to CardReadAdapter failed %d", ec);
			}
		}
		break;
		case 0x999:
		{
			if (reqInfo->numOfBlobInParamX == 1)
			{
				NotifyIECallResult resultNote;
				resultNote.ans_context = reqInfo->StrParamX;
				Dbg("oiltest %s", (const char*)resultNote.ans_context.SubString(0, 512));
				resultNote.error = reqInfo->ErrorCode;
				Dbg("notify result to IE:error %d,len of ans_context %d", resultNote.error, reqInfo->lensOfBlobInParamX[0]);
				SpSendBroadcast(GetEntityBase()->GetFunction(), SP_MSG_OF(NotifyIECallResult), SP_MSG_SIG_OF(NotifyIECallResult), resultNote);
			}
			else
			{//oiltest 需要改成按照序号组包
				m_tmpMultiBlob += reqInfo->StrParamX;
				if (reqInfo->blobSN == reqInfo->numOfBlobInParamX-1)
				{
					NotifyIECallResult resultNote;
					resultNote.ans_context = m_tmpMultiBlob;
					if (resultNote.ans_context.GetLength() > 512)
						Dbg("oiltest substr %s", (const char*)resultNote.ans_context.SubString(0, 512));
					else
						Dbg("oiltest %s", (const char*)resultNote.ans_context);
					if (resultNote.ans_context.GetLength() > 100)
						Dbg("oiltest the last 100 str %s", (const char*)resultNote.ans_context.SubString(resultNote.ans_context.GetLength()-100, 100));
					resultNote.error = reqInfo->ErrorCode;
					Dbg("notify result to IE:error %d,len of ans_context %d", resultNote.error, resultNote.ans_context.GetLength());
					SpSendBroadcast(GetEntityBase()->GetFunction(), SP_MSG_OF(NotifyIECallResult), SP_MSG_SIG_OF(NotifyIECallResult), resultNote);
					m_tmpMultiBlob = "";
				}
			}
		}
		break;
		default:
			break;
		}
	} else { //常规机型，连接适配器
		switch(reqInfo->nEntityID) //实体ID
		{
		case 0x201:
		{
			ErrorCodeEnum ec = Error_Succeed;
			if (m_pIDClient == NULL)
			{
				Dbg("creat IDCertService_ClientBase client");
				m_pIDClient = new IDCertService_ClientBase(GetEntityBase());
			}
			if (m_pIDClient != NULL)
			{
				if (m_pIDClient->QuerySessionClosed())
				{
					m_pIDClient->SafeDelete();
					m_pIDClient = new IDCertService_ClientBase(GetEntityBase());
					Dbg("to connect to IDCertificate...");
					if (m_pIDClient != NULL)
						ec = m_pIDClient->Connect();
				}
			}
			if (ec == Error_Succeed) {
				IDCertService_CrossTermCall_Req reqX;
				IDCertService_CrossTermCall_Ans ansX;
				reqX.type = reqInfo->CallType;
				//这个应该不用存储
				reqX.fromTerminalNo = reqInfo->ToTerminalNo;
				reqX.toTerminalNo = reqInfo->FromTerminalNo;

				SpBuffer spbuf2;
				Dbg("offset %d", FIELD_OFFSET(CrossCallReq, StrParamX));
				bool bBuf = spbuf2.OpenRead((const char*)&(reqInfo->StrParamX[0]), nBufSize - FIELD_OFFSET(CrossCallReq, StrParamX) + 1);
				if (bBuf) {
					reqX.paramX = spbuf2.ToBlob();
				}
				ec = m_pIDClient->CrossTermCall(reqX, ansX, 20000);
				Dbg("local term call ret:%x", ec);
				if (reqInfo->bTwoWay)//if one way call, no need to feed back
				{
					HeartBeatService_CrossTermCall_Req reqY;
					HeartBeatService_CrossTermCall_Ans ansY;
					reqY.type = reqInfo->CallType;
					reqY.nEntityID = reqInfo->nEntityID;
					//做返回
					ansY.retCode = ec;
					reqY.fromTerminalNo = reqInfo->ToTerminalNo;
					reqY.toTerminalNo = reqInfo->FromTerminalNo;
					reqY.paramX = ansX.retParamX;
					//reqY. = ansX.retParamY.m_iLength;//oiltest 暂时用来传递blob长度
					Dbg("send pkg to client: %d,Y len:%d", ec, reqY.paramX.m_iLength);
					SendToHeartBeatService(reqY, ansY);
				}
			}
			else {
				Dbg("Connect to IDCertificate failed %d", ec);
				m_pIDClient->SafeDelete();
				m_pIDClient = NULL;
			}
		}
		break;
		case 0x206://pinpad
		{
			ErrorCodeEnum ec = Error_Succeed;
			if (m_pPinPadClient == NULL)
			{
				Dbg("creat PinPadService_ClientBase client");
				m_pPinPadClient = new PinPadService_ClientBase(GetEntityBase());
			}
			if (m_pPinPadClient != NULL)
			{
				if (m_pPinPadClient->QuerySessionClosed())
				{
					m_pPinPadClient->SafeDelete();
					m_pPinPadClient = new PinPadService_ClientBase(GetEntityBase());
					Dbg("to connect to PinPad...");
					if (m_pPinPadClient != NULL)
						ec = m_pPinPadClient->Connect();
				}
			}
			if (ec == Error_Succeed) {
				PinPadService_CrossTermCall_Req reqX;
				PinPadService_CrossTermCall_Ans ansX;
				reqX.type = reqInfo->CallType;
				//这个应该不用存储
				reqX.fromTerminalNo = reqInfo->ToTerminalNo;
				reqX.toTerminalNo = reqInfo->FromTerminalNo;

				SpBuffer spbuf2;
				Dbg("offset %d", FIELD_OFFSET(CrossCallReq, StrParamX));
				bool bBuf = spbuf2.OpenRead((const char*)&(reqInfo->StrParamX[0]), nBufSize - FIELD_OFFSET(CrossCallReq, StrParamX) + 1);
				if (bBuf) {
					reqX.paramX = spbuf2.ToBlob();
				}
				ec = m_pPinPadClient->CrossTermCall(reqX, ansX, 20000);
				Dbg("local term call ret:%x", ec);
				if (reqInfo->bTwoWay)//if one way call, no need to feed back
				{
					HeartBeatService_CrossTermCall_Req reqY;
					HeartBeatService_CrossTermCall_Ans ansY;
					reqY.type = reqInfo->CallType;
					reqY.nEntityID = reqInfo->nEntityID;
					//做返回
					ansY.retCode = ec;
					reqY.fromTerminalNo = reqInfo->ToTerminalNo;
					reqY.toTerminalNo = reqInfo->FromTerminalNo;
					reqY.paramX = ansX.retParamX;
					//reqY. = ansX.retParamY.m_iLength;//oiltest 暂时用来传递blob长度
					Dbg("send pkg to client: %d,Y len:%d", ec, reqY.paramX.m_iLength);
					SendToHeartBeatService(reqY, ansY);
				}
			}
			else {
				Dbg("Connect to PinPad failed %d", ec);
			}
		}
		break;
		case 0x218: // 高拍仪功能集
			{
				ErrorCodeEnum ec = Error_Succeed;
				ScannerService_ClientBase* pClient = new ScannerService_ClientBase(GetEntityBase());
				ec = pClient->Connect();
				if(ec == Error_Succeed) {
					ScannerService_CrossTermCall_Req reqX;
					ScannerService_CrossTermCall_Ans ansX;
					reqX.type = reqInfo->CallType;
					//这个应该不用存储
					reqX.fromTerminalNo = reqInfo->ToTerminalNo;
					reqX.toTerminalNo = reqInfo->FromTerminalNo;

					SpBuffer spbuf2;
					Dbg("offset %d", FIELD_OFFSET(CrossCallReq, StrParamX) );
					bool bBuf = spbuf2.OpenRead((const char*)&(reqInfo->StrParamX[0]), nBufSize - FIELD_OFFSET(CrossCallReq, StrParamX) + 1 );
					if(bBuf) {
						reqX.paramX = spbuf2.ToBlob();
					}
					 ec = pClient->CrossTermCall(reqX, ansX, 20000);
					 Dbg("local term call ret:%x",ec);
					 if (reqInfo->bTwoWay)//if one way call, no need to feed back
					 {
						 HeartBeatService_CrossTermCall_Req reqY;
						 HeartBeatService_CrossTermCall_Ans ansY;
						 reqY.type = reqInfo->CallType;
						 reqY.nEntityID = reqInfo->nEntityID;
						 //做返回
						 ansY.retCode = ec;
						 reqY.fromTerminalNo = reqInfo->ToTerminalNo;
						 reqY.toTerminalNo = reqInfo->FromTerminalNo;
						 reqY.paramX = ansY.retParamX;
						 Dbg("send pkg to client: %d", ec);
						 SendToHeartBeatService(reqY, ansY);
					 }
				} else {
					Dbg("Connect to scanner failed %d", ec);
				}
			}
			break;
		case 0x21B:
		{
			ErrorCodeEnum ec = Error_Succeed;
			if (m_pCRAClient == NULL)
			{
				Dbg("creat CardReadAdapterService_ClientBase client");
				m_pCRAClient = new CardReadAdapterService_ClientBase(GetEntityBase());
			}
			if (m_pCRAClient != NULL)
			{
				if (m_pCRAClient->QuerySessionClosed())
				{
					m_pCRAClient = NULL;
					m_pCRAClient = new CardReadAdapterService_ClientBase(GetEntityBase());
					Dbg("to connect to CardReadAdapter");
					ec = m_pCRAClient->Connect();
				}
			}
			if (ec == Error_Succeed) {
				CardReadAdapterService_CrossTermCall_Req reqX;
				CardReadAdapterService_CrossTermCall_Ans ansX;
				reqX.type = reqInfo->CallType;
				//这个应该不用存储
				reqX.fromTerminalNo = reqInfo->ToTerminalNo;
				reqX.toTerminalNo = reqInfo->FromTerminalNo;

				SpBuffer spbuf2;
				Dbg("offset %d", FIELD_OFFSET(CrossCallReq, StrParamX));
				bool bBuf = spbuf2.OpenRead((const char*)&(reqInfo->StrParamX[0]), nBufSize - FIELD_OFFSET(CrossCallReq, StrParamX) + 1);
				if (bBuf) {
					reqX.paramX = spbuf2.ToBlob();
				}
				ec = m_pCRAClient->CrossTermCall(reqX, ansX, 20000);
				Dbg("local term call ret:%x", ec);
				if (reqInfo->bTwoWay)//if one way call, no need to feed back
				{
					HeartBeatService_CrossTermCall_Req reqY;
					HeartBeatService_CrossTermCall_Ans ansY;
					reqY.type = reqInfo->CallType;
					reqY.nEntityID = reqInfo->nEntityID;
					//做返回
					ansY.retCode = ec;
					reqY.fromTerminalNo = reqInfo->ToTerminalNo;
					reqY.toTerminalNo = reqInfo->FromTerminalNo;
					reqY.paramX = ansX.retParamX;
					//reqY. = ansX.retParamY.m_iLength;//oiltest 暂时用来传递blob长度
					Dbg("send pkg to client: %d,X len:%d", ec, reqY.paramX.m_iLength);
					SendToHeartBeatService(reqY, ansY);
				}
			}
			else {
				Dbg("Connect to CardReadAdapter failed %d", ec);
			}
		}
		break;
		case 0x999:
		{
			m_ILDeviceNo = reqInfo->FromTerminalNo;
			Dbg("save il TerminalNo:%s",(const char*)m_ILDeviceNo);
			NotifyIEToCall note;
			note.context = reqInfo->StrParamX;
			Dbg("oiltest %s",(const char*)note.context);
			Dbg("note IE to call:%d", reqInfo->lensOfBlobInParamX[0]);
			SpSendBroadcast(GetEntityBase()->GetFunction(), SP_MSG_OF(NotifyIEToCall), SP_MSG_SIG_OF(NotifyIEToCall), note);
		}
		break;
		default:
			break;
		}
	}

	//TODO: return
}

ErrorCodeEnum CHeartBeatFSM::GetPerformCounter(TermianlCounter& counter)
{
	memset(&counter, 0, sizeof(TermianlCounter));//oiltmp@20210611
#ifdef RVC_OS_WIN
	//oilyang@20171122 数量太多，暂时去掉
	//LOG_FUNCTION();
	PDH_STATUS Status;
	HQUERY Query = NULL;
	//HCOUNTER hcMemoryCount;
	HCOUNTER hcHandleCount, hcProcessCount, hcThreadCount;
	HCOUNTER hcElapsedTimeCount, hcProcessTimeCount;
	DWORD CounterType;
	MEMORYSTATUSEX statex;

	

	Status = PdhOpenQuery(NULL, NULL, &Query);
	if (Status != ERROR_SUCCESS)
	{
		Dbg("PdhOpenQuery failed with status 0x%x.", Status);
		goto Cleanup;
	}
	Status = PdhAddCounter(Query, ProcessTimeQuery, NULL, &hcProcessTimeCount);
	if (Status != ERROR_SUCCESS)
	{
		Dbg("PdhAddCounter for ProcessTimeQuery failed with status 0x%x.", Status);
		goto Cleanup;
	}
	Status = PdhAddCounter(Query, HandleNumQuery, NULL, &hcHandleCount);
	if (Status != ERROR_SUCCESS)
	{
		Dbg("PdhAddCounter for HandleNumQuery failed with status 0x%x.", Status);
		goto Cleanup;
	}
	Status = PdhAddCounter(Query, ThreadNumQuery, NULL, &hcThreadCount);
	if (Status != ERROR_SUCCESS)
	{
		Dbg("PdhAddCounter for ThreadNumQuery failed with status 0x%x.", Status);
		goto Cleanup;
	}
	Status = PdhAddCounter(Query, ProcessNumQuery, NULL, &hcProcessCount);
	if (Status != ERROR_SUCCESS)
	{
		Dbg("PdhAddCounter for ProcessNumQuery failed with status 0x%x.", Status);
		goto Cleanup;
	}
	Status = PdhAddCounter(Query, SystemElapsedQuery, NULL, &hcElapsedTimeCount);
	if (Status != ERROR_SUCCESS)
	{
		Dbg("PdhAddCounter for SystemElapsedQuery failed with status 0x%x.", Status);
		goto Cleanup;
	}

	Status = PdhCollectQueryData(Query);
	if (Status != ERROR_SUCCESS)
	{
		Dbg("PdhCollectQueryData failed with 0x%x.\n", Status);
		goto Cleanup;
	}

	do
	{
		Sleep(COUNTER_INTERVAL_MS);

		Status = PdhCollectQueryData(Query);
		if (Status != ERROR_SUCCESS)
		{
			Dbg("PdhCollectQueryData failed with status 0x%x.", Status);
			break;
		}

		memset(&statex, 0, sizeof(MEMORYSTATUSEX));
		statex.dwLength = sizeof(statex);

		if (GlobalMemoryStatusEx(&statex))
		{
			//Dbg("CPUUseRate:%u%%", statex.dwMemoryLoad);
			counter.totalMem = (unsigned short)(statex.ullTotalPhys / DIV);
			//Dbg("TotalPhysMemory:%I64dMB %d", statex.ullTotalPhys / DIV, counter.totalMem);
			counter.freeMem = (unsigned short)(statex.ullAvailPhys / DIV);
			//Dbg("AvailableMemory:%I64dMB %d", statex.ullAvailPhys / DIV, counter.freeMem);
		}

		PDH_FMT_COUNTERVALUE counterValue;
		//Status = PdhGetFormattedCounterValue(hcMemoryCount, PDH_FMT_DOUBLE, NULL, &counterValue);
		//if (Status == ERROR_SUCCESS)
		//{
		//	Dbg("AvailableMemory:%.20gMB\n", counterValue.doubleValue);
		//}
		Status = PdhGetFormattedCounterValue(hcProcessTimeCount, PDH_FMT_DOUBLE, &CounterType, &counterValue);
		if (Status == ERROR_SUCCESS)
		{
			counter.cpuLoad = (unsigned short)(counterValue.doubleValue + 0.5);
			//Dbg("CPURate:%d %u", (long)counterValue.doubleValue, counter.cpuLoad);
		}
		Status = PdhGetFormattedCounterValue(hcHandleCount, PDH_FMT_LONG, NULL, &counterValue);
		if (Status == ERROR_SUCCESS)
		{
			counter.handleNum = (unsigned int)(counterValue.longValue);
			//Dbg("HandlesNum:%ld %u", counterValue.longValue, counter.handleNum);
		}
		Status = PdhGetFormattedCounterValue(hcThreadCount, PDH_FMT_LONG, NULL, &counterValue);
		if (Status == ERROR_SUCCESS)
		{
			counter.threadNum = (unsigned short)(counterValue.longValue);
			//Dbg("ThreadsNum:%ld %u", counterValue.longValue, counter.threadNum);

		}
		Status = PdhGetFormattedCounterValue(hcProcessCount, PDH_FMT_LONG, NULL, &counterValue);
		if (Status == ERROR_SUCCESS)
		{
			counter.procNum = (unsigned short)(counterValue.longValue);
			//Dbg("ProcessesNum:%ld %u", counterValue.longValue, counter.procNum);

		}
		Status = PdhGetFormattedCounterValue(hcElapsedTimeCount, PDH_FMT_LARGE, NULL, &counterValue);
		if (Status == ERROR_SUCCESS)
		{
			ULONGLONG ulSinceSeconds = counterValue.largeValue;
			ULONG days = 0, hours = 0, minutes = 0, seconds = 0;
			days = ULONG(ulSinceSeconds / DAY_DIV);
			ulSinceSeconds %= DAY_DIV;
			hours = ULONG(ulSinceSeconds / HOURS_DIV);
			ulSinceSeconds %= HOURS_DIV;
			minutes = ULONG(ulSinceSeconds / MINUS_DIV);
			ulSinceSeconds %= MINUS_DIV;
			seconds = ULONG(ulSinceSeconds);

			//Dbg("SystemElapseTime: %u:%02u:%02u:%02u", days, hours, minutes, seconds);

			FILETIME ftCurTime, ftStartTime;
			GetSystemTimeAsFileTime(&ftCurTime);
			ULARGE_INTEGER uliCurTime;
			uliCurTime.HighPart = ftCurTime.dwHighDateTime;
			uliCurTime.LowPart = ftCurTime.dwLowDateTime;
			uliCurTime.QuadPart -= counterValue.largeValue * 1e7;

			ftStartTime.dwHighDateTime = uliCurTime.HighPart;
			ftStartTime.dwLowDateTime = uliCurTime.LowPart;

			SYSTEMTIME stUTC, stLocal;

			FileTimeToSystemTime(&ftStartTime, &stUTC);

			SystemTimeToTzSpecificLocalTime(NULL, &stUTC, &stLocal);
			sprintf_s(counter.osStartTime, 22, "%d-%02d-%02d %02d:%02d:%02d",
				stLocal.wYear, stLocal.wMonth, stLocal.wDay, stLocal.wHour, stLocal.wMinute, stLocal.wSecond);
			//Dbg("OSStartTime: %s", counter.osStartTime);
		}

	}while(false);

	//Status = PdhRemoveCounter(hcMemoryCount);
	Status = PdhRemoveCounter(hcHandleCount);
	Status = PdhRemoveCounter(hcThreadCount);
	Status = PdhRemoveCounter(hcProcessCount);
	Status = PdhRemoveCounter(hcElapsedTimeCount);

Cleanup:

	if (Query)
	{
		PdhCloseQuery(Query);
	}
	if(Status != ERROR_SUCCESS)
	{
		switch(Status)
		{
		case PDH_CSTATUS_BAD_COUNTERNAME :
			Dbg("The counter path could not be parsed or interpreted.");
			break;
		case PDH_CSTATUS_NO_COUNTER :
			Dbg("Unable to find the specified counter on the computer or in the log file.");
			break;
		case PDH_CSTATUS_NO_COUNTERNAME  :
			Dbg("The counter path is empty.");
			break;
		case PDH_CSTATUS_NO_MACHINE  :
			Dbg("The path did not contain a computer name, and function was unable to retrieve local computer name.");
			break;
		case PDH_CSTATUS_NO_OBJECT  :
			{
				Dbg("Unable to find the specified object on the computer or in the log file.");
				//CSystemStaticInfo sysInfo;
				//if(GetEntityBase()->GetFunction()->GetSystemStaticInfo(sysInfo) == Error_Succeed)
				//{
				//	if(!sysInfo.strMachineType.Compare("RVC.PAD", true))
				//	{
				//		Dbg("Pad MachineType, abort lodctr operation.");
				//		break;
				//	}
				//}
				if(!m_nLodCtrFlag || m_nLodCtrFlag == 2)
				{
					LodctrTask* task = new LodctrTask(this);
					GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
				}

			}
			break;
		case PDH_FUNCTION_NOT_FOUND  :
			Dbg("Unable to determine the calculation function to use for this counter.");
			break;
		case PDH_INVALID_ARGUMENT :
			Dbg("One or more arguments are not valid.");
			break;
		case PDH_INVALID_HANDLE  :
			Dbg("The query handle is not valid.");
			break;
		case PDH_MEMORY_ALLOCATION_FAILURE  :
			Dbg("Unable to allocate memory required to complete the function.");
			break;
		default :
			Dbg("Cannot figure the erroCode(0x%08x)(%d) in GetPerformCounter", Status, GetLastError());
			break;
		}
		return Error_Unexpect;
	}
	return Error_Succeed;
#else
	return Error_Succeed;
//oiltestlinux
#endif //RVC_OS_WIN
}
int CHeartBeatFSM::SendToHeartBeatService(HeartBeatService_CrossTermCall_Req &req, HeartBeatService_CrossTermCall_Ans &ans)
{
	LOG_FUNCTION();
	if (m_pHandShakeConn && m_pHandShakeConn->IsConnectionOK())
	{
		m_pHandShakeConn->SendCrossCallToService(req,ans);
	}
	return 0;
}
void CHeartBeatFSM::ILCallToRVC(SpOnewayCallContext<HeartBeatService_CallFromILToRVC_Info>::Pointer ctx)
{
	if (m_pHandShakeConn && m_pHandShakeConn->IsConnectionOK())
	{
		CSimpleStringA csTerm("");
		GetEntityBase()->GetFunction()->GetSysVar("AttachedTerminal", csTerm);
		m_pHandShakeConn->SendILCallToService(ctx->Info.req_context,0,true, m_localDeviceNo,csTerm);
	}
}
void CHeartBeatFSM::CallResultToIL(SpOnewayCallContext<HeartBeatService_CallResultToIL_Info>::Pointer ctx)
{
	if (m_pHandShakeConn && m_pHandShakeConn->IsConnectionOK())
	{
		m_pHandShakeConn->SendILCallToService(ctx->Info.ans_context, ctx->Info.error, false, m_localDeviceNo,m_ILDeviceNo);
	}
}
void HeartBeatConnection::OnPkgAnswer(const CSmartPointer<IPackage> &pRecvPkg)
{
	string serviceCode = pRecvPkg->GetServiceCode();
	
	if (serviceCode.compare("HANDSHK") == 0 || serviceCode.compare("INSTRUC") == 0)
	{
		PkgRcvProcHandAndInstruc(pRecvPkg);
	}
	else if (serviceCode.compare("CARDACT") == 0)
	{
		PkgRcvProcCardActive(pRecvPkg);
	}
	else if (serviceCode.compare("CRSSACT") == 0)
	{
		PkgRcvProcCrossCall(pRecvPkg);
	}
	else
	{
		Dbg("unknown service code!");
	}
};
void HeartBeatConnection::SendHandShake()
{
	HandReq req = {0};

	//oiltest
	//strcpy(req.TerminalNo,"75500000002");

	//Dbg("get sysvar");
	//oiltest set default value
	CSimpleStringA warningLevel("w"),runState("r"),customerHandle("c"),callState("s"),
		localMaintain("l"),remoteMaintain("m"),termStage("U");
	//m_pEntity->GetFunction()->GetSysVar("WarningLevel",warningLevel);

	strncpy(req.TerminalNo,m_TerminalNo.GetData(),m_TerminalNo.GetLength());
	m_pEntity->GetFunction()->GetSysVar("RunState",runState);
	m_pEntity->GetFunction()->GetSysVar("CustomerHandle",customerHandle);
	m_pEntity->GetFunction()->GetSysVar("CallState",callState);
	//m_pEntity->GetFunction()->GetSysVar("LocalMaintain",localMaintain);
	//m_pEntity->GetFunction()->GetSysVar("RemoteMaintain",remoteMaintain);
	m_pEntity->GetFunction()->GetSysVar("TerminalStage",termStage);
	//Dbg("ts[%s]",(LPCTSTR)termStage);
	//oiltest byteorder
#ifdef RVC_OS_WIN
	char tmp[256];
	gethostname(tmp, sizeof(tmp));
	hostent *ent = gethostbyname(tmp);
	unsigned long ip = 0xffffffff;
	if (ent) {
		for (int i = 0; ent->h_addr_list[i]; ++i) {
			if (ent->h_addrtype == AF_INET) {
				struct in_addr *in = (struct in_addr*)ent->h_addr_list[i];
				if (in->S_un.S_un_b.s_b1 != 0) {
					if (in->S_un.S_un_b.s_b1 == 192)
						continue;
					ip = (in->S_un.S_un_b.s_b1<<24)+(in->S_un.S_un_b.s_b2<<16)
						+(in->S_un.S_un_b.s_b3<<8)+in->S_un.S_un_b.s_b4;
					break;
				}
			}
		}
	}

	req.ip = ip;
#else
	//oiltest
	req.ip = 0x0;
#endif //RVC_OS_WIN
	req.WarningLevel = warningLevel[0];
	req.RunState = runState[0];
	req.CustomerHandle = customerHandle[0];
	req.CallState = callState[0];
	req.LocalMaintain = localMaintain[0];
	req.RemoteMaintain = remoteMaintain[0];
	req.TermStage = termStage[0];
	CSmartPointer<IPackage> pkt = CreateNewPackage("HANDSHK");
	Dbg("sizeof(HandReq):%d",sizeof(HandReq));
	Dbg("sizeof(int):%d", sizeof(int));
	Dbg("sizeof(long):%d", sizeof(long));
	pkt->AddStruct("FNTSTAT", false, false, (LPBYTE)&req, sizeof(HandReq));

	HandErrListReq errListReq;
	errListReq.warnLevel = m_pFSM->GetWarnLevel();
	errListReq.reserved1 = m_pFSM->GetTradeManagerState();
	ZeroMemory(errListReq.errList, 512);
	strncpy(errListReq.errList,m_pFSM->GetEntityErrorList(),m_pFSM->GetEntityErrorList().GetLength());
	pkt->AddStruct("ENTSTAT", false, false, (LPBYTE)&errListReq, sizeof(HandErrListReq));

	// [Josephus in 9:38:25 2016/4/23]
	TermianlCounter counter;
	ErrorCodeEnum erroCode = m_pFSM->GetPerformCounter(counter);
	if(erroCode != Error_Succeed)
	{
		Dbg("Get Terminal Performance Information failed !!!");
	}
	else
	{
		//oilyang@20171122 数量太多，暂时去掉
		//Dbg("Get Terminal Performance Information suc");
	}
	//const char* szIP = m_pFSM->GetRealIP();
	//memset(tmp, 0, sizeof(tmp));
	//strcpy_s(tmp, 256, szIP);
	//Dbg("Calling gethostbyname with %s %s", tmp, szIP);
	//ent = gethostbyname(tmp);
	//ip = 0xffffffff;
	//if (ent == NULL)
	//{
	//	DWORD dwError = WSAGetLastError();
	//	if (dwError != 0)
	//	{
	//		if (dwError == WSAHOST_NOT_FOUND)
	//		{
	//			Dbg("Host not found");
	//		} else if (dwError == WSANO_DATA)
	//		{
	//			Dbg("No data record found");
	//		} else 
	//		{
	//			Dbg("Function failed with error: %ld", dwError);
	//		}
	//	}
	//	counter.serverIP = 0xffffffff;
	//} 
	//else 
	//{
	//	//unsigned long ulIP = ((struct in_addr*)ent->h_addr)->S_un.S_addr;
	//	for (int i = 0; ent->h_addr_list[i]; ++i) 
	//	{
	//		if (ent->h_addrtype == AF_INET) 
	//		{
	//			struct in_addr *in = (struct in_addr*)ent->h_addr_list[i];
	//			if (in->S_un.S_un_b.s_b1 != 0) 
	//			{
	//				if (in->S_un.S_un_b.s_b1 == 192)
	//					continue;
	//				ip = (in->S_un.S_un_b.s_b1<<24)+(in->S_un.S_un_b.s_b2<<16)
	//					+(in->S_un.S_un_b.s_b3<<8)+in->S_un.S_un_b.s_b4;
	//				// test for ip with S_addr [Josephus in 11:15:43 2016/4/22]
	//				unsigned long ulIP = in->S_un.S_addr;
	//				unsigned long ul2IP = inet_addr(tmp);
	//				Dbg("joseph-test2: ip=0x%x, ulIp=0x%x, ul2IP=0x%x", ip, ulIP, ul2IP);
	//				break;
	//			}
	//		}
	//	}
	//}

	counter.serverIP = m_pFSM->m_dwServIP;
	//Dbg("dwServIP 0x%x", counter.serverIP);
#ifdef RVC_OS_WIN
	const char* diskPath = m_pFSM->GetRunDiskPath();
	ULARGE_INTEGER uliFreeBytesAvailable;
	if(GetDiskFreeSpaceEx(diskPath, &uliFreeBytesAvailable, NULL, NULL))
	{
		counter.freeDisk = (unsigned int)(uliFreeBytesAvailable.QuadPart / 1024.0 / 1024.0);
		//Dbg("FreeDisk:%.2fMB, %u", uliFreeBytesAvailable.QuadPart / 1024.0 / 1024.0, counter.freeDisk);
	}
	else
	{
		Dbg("GetDiskFreeSpaceEx with %s failed failed 0x%x", diskPath, GetLastError());
	}
#else
	//oiltestlinux
	counter.freeDisk = 0;
#endif //RVC_OS_WIN
	pkt->AddStruct("CNTSTAT", false, false, (LPBYTE)&counter, sizeof(TermianlCounter));


	SendPackage(pkt);
	//delete pkt;
}

void HeartBeatConnection::SendCardActive(const int type,const int slot,unsigned long errCode,const char *termNo, const char *account, const int accSize, const char *data, const int dataSize,int findCard,int cardPos)
{
	CSimpleStringA inParm = CSimpleStringA::Format("SendCardActive,type:%d, slot:%d, errCode:%d, fromTerm:%s, termNo:%s, findCard:%d, cardPos:%d, dataSize:%d",
		type, slot, errCode, m_TerminalNo.GetData(), termNo, findCard, cardPos, dataSize);
	LogWarn(Severity_Low, Error_Unexpect, HeartBeat_UserErrorCode_SendCardActive_InParam, inParm.GetData());
	//发起跨机调用包
	if (type == 0)
	{
		CardActiveReq req = { 0 };
		CSystemStaticInfo sysSInfo;
		m_pEntity->GetFunction()->GetSystemStaticInfo(sysSInfo);
		req.type = 0;
		req.slot = slot;
		strcpy_s(req.FromTerminalNo, sizeof(req.FromTerminalNo), m_TerminalNo.GetData());
		strcpy_s(req.Account, accSize, account);
		strcpy_s(req.TerminalNo, sizeof(req.TerminalNo), termNo);
		strcpy_s(req.Param2, dataSize, data);
		CSmartPointer<IPackage> pkt = CreateNewPackage("CARDACT");
		pkt->AddStruct("INSREQX", false, false, (LPBYTE)&req, sizeof(CardActiveReq));

		SendPackage(pkt);
	}
	//发送跨机调用返回包
	else if (type == 1)
	{
		CardActiveReq req = { 0 };
		CSystemStaticInfo sysSInfo;
		m_pEntity->GetFunction()->GetSystemStaticInfo(sysSInfo);
		req.type = 1;
		req.ErrCode = errCode;
		req.findCard = findCard;
		req.cardPos = cardPos;
		strcpy_s(req.FromTerminalNo, sizeof(req.FromTerminalNo), m_TerminalNo.GetData());
		strcpy_s(req.Account, accSize, account);
		strcpy_s(req.TerminalNo, sizeof(req.TerminalNo), termNo);
		strcpy_s(req.Param2, dataSize, data);
		CSmartPointer<IPackage> pkt = CreateNewPackage("CARDACT");
		pkt->AddStruct("INSREQX", false, false, (LPBYTE)&req, sizeof(CardActiveReq));

		SendPackage(pkt);
	}
}
void HeartBeatConnection::SendCrossCallToService(HeartBeatService_CrossTermCall_Req &req, HeartBeatService_CrossTermCall_Ans &ans)
{
	LOG_FUNCTION();
	Dbg("from term %s to term %s for entity %x,twoway:%d", (const char*)req.fromTerminalNo, (const char*)req.toTerminalNo, req.nEntityID, req.isTwoWay);

	if (req.paramX.m_iLength > 0)
	{
		//char *pBuf = new char[64 * 1024];
		//ZeroMemory(pBuf, 64 * 1024);
		//HexBuf2StrBuf((PBYTE)req.paramX.m_pData, &pBuf, req.paramX.m_iLength);
		//CSimpleStringA xStr(pBuf);
		//int i = 0;
		//for (; i < req.paramX.m_iLength / 900; i++)
		//{
		//	Dbg("%s", xStr.SubString(i * 900, 900));
		//}
		//Dbg("%s", xStr.SubString(i * 900, req.paramX.m_iLength - i * 900));
	}
	int count = req.paramX.m_iLength / (50 * 1000);
	int size = sizeof(CrossCallReq)*(count + 1) + req.paramX.m_iLength + count;
	char* pBuf = new char[size];
	ZeroMemory(pBuf, size);
	CrossCallReq* pReqX = (CrossCallReq*)pBuf;
	for (int i = 0; i < count+1; i++)
	{
		pReqX[i].CallType = req.type;
		pReqX[i].bTwoWay = req.isTwoWay;
		pReqX[i].nEntityID = req.nEntityID;
		pReqX[i].ErrorCode = ans.retCode;
		pReqX[i].lensOfBlobInParamX[0] = req.paramX.m_iLength;
		pReqX[i].numOfBlobInParamX = count+1;
		strcpy_s(pReqX[i].FromTerminalNo, sizeof(pReqX[i].FromTerminalNo),req.fromTerminalNo);
		strcpy_s(pReqX[i].ToTerminalNo, sizeof(pReqX[i].ToTerminalNo), req.toTerminalNo);
		strcpy_s(pReqX[i].StrParam1, sizeof(pReqX[i].StrParam1), req.param1);
		strcpy_s(pReqX[i].StrParam2, sizeof(pReqX[i].StrParam2), req.param2);
		if (i == count)
			memcpy_s(pReqX[i].StrParamX, (req.paramX.m_iLength-50*1000*i), (char*)req.paramX.m_pData+50*1000*i, req.paramX.m_iLength - 50 * 1000 * i);
		else
			memcpy_s(pReqX[i].StrParamX, 50*1000, (char*)req.paramX.m_pData + 50 * 1000 *i, 50 * 1000);
	}
	//memcpy_s(pReqX->StrParamX,req.paramY.GetLength(),req.paramX, req.paramX.GetLength());
	Dbg("from %s to %s,struct X size:%d, len:%d,struct count:%d", pReqX->FromTerminalNo, pReqX->ToTerminalNo, size, req.paramX.m_iLength,count);
	CSmartPointer<IPackage> pkt = CreateNewPackage("CRSSACT");
	pkt->AddStruct("CRSSREQ", false, false, (LPBYTE)pReqX, size,count+1);
	SendPackage(pkt);
	delete [] pBuf;
}
void HeartBeatConnection::SendILCallToService(CSimpleStringA csContent, int err, bool bFromIL, CSimpleStringA fromDevNo, CSimpleStringA toDevNo)
{
	LOG_FUNCTION();
	int count = csContent.GetLength() / (50 * 1000);
	Dbg("count %d,size of content %d",count,csContent.GetLength());
	if (csContent.GetLength() > 32)
		Dbg("the last 32 str %s", (const char*)csContent.SubString(csContent.GetLength()-32,32));
	
	for (int i = 0; i < count + 1; i++)
	{
		int size;
		if (i == count)
		{
			size = sizeof(CrossCallReq) + csContent.GetLength() - 50*1000*i + 1;
		}
		else
			size = sizeof(CrossCallReq) + 50 * 1000 + 1;
		
		char* pBuf = new char[size];
		ZeroMemory(pBuf, size);
		Dbg("sz %d", size);
		CrossCallReq* pReqX = (CrossCallReq*)pBuf;
		pReqX->CallType = 999;
		pReqX->bTwoWay = false;
		pReqX->nEntityID = 0x999;
		pReqX->blobSN = i;
		pReqX->lensOfBlobInParamX[0] = csContent.GetLength();//no use 实际用到的时候需要修改这里
		pReqX->numOfBlobInParamX = count + 1;
		if (bFromIL)
		{
			pReqX->ErrorCode = 0;
		}
		else
		{
			pReqX->ErrorCode = err;
		}
		strcpy_s(pReqX->FromTerminalNo,sizeof(pReqX->FromTerminalNo), fromDevNo);
		strcpy_s(pReqX->ToTerminalNo, sizeof(pReqX->ToTerminalNo), toDevNo);
		CSmartPointer<IPackage> pkt = CreateNewPackage("CRSSACT");
		if (i == count)
		{
			memcpy_s(pReqX->StrParamX, csContent.GetLength() - 50 * 1000 * i, (const char*)csContent+50 * 1000 * i, csContent.GetLength() - 50 * 1000 * i);
			Dbg("to add the %d packet from %d",i, csContent.GetLength() - 50 * 1000 * i);
			Dbg("[%d],%d%d%d", strlen(pReqX->StrParamX), pReqX->StrParamX[strlen(pReqX->StrParamX) - 3], pReqX->StrParamX[strlen(pReqX->StrParamX) - 2],pReqX->StrParamX[strlen(pReqX->StrParamX)-1]);
			pkt->AddStruct("CRSSREQ", false, false, (LPBYTE)pReqX, sizeof(CrossCallReq) + csContent.GetLength() - 50 * 1000 * i);
			Dbg("p len:%d", sizeof(CrossCallReq) + csContent.GetLength() -  50 * 1000 * i);
			SendPackage(pkt);
			Dbg("the last of %d",i);
			
		}
		else
		{
			memcpy_s(pReqX->StrParamX, 50 * 1000, (const char*)csContent + 50 * 1000 * i, 50 * 1000);
			pkt->AddStruct("CRSSREQ", false, false, (LPBYTE)pReqX, sizeof(CrossCallReq)+50*1000);
			Dbg("p len %d:%d,last 3:%d,%d,%d",i, sizeof(CrossCallReq) + 50 * 1000, pReqX->StrParamX[strlen(pReqX->StrParamX) - 3], pReqX->StrParamX[strlen(pReqX->StrParamX) - 2], pReqX->StrParamX[strlen(pReqX->StrParamX) - 1]);
			SendPackage(pkt);
			Dbg("the %d packet",i);
		}
		delete[] pBuf;
	}	
	
	
}
void HeartBeatConnection::PkgRcvProcHandAndInstruc(const CSmartPointer<IPackage> &pRecvPkg)
{
	int nLen = pRecvPkg->GetStructLen("FNTHAND");
	if (nLen > 0) {
		Dbg("nLen %d", nLen);
		BYTE *pBuf = new BYTE[nLen+1];
		memset(pBuf, 0, nLen+1);
		int nArrayNum = 0;
		if (pRecvPkg->GetStructData("FNTHAND", pBuf, &nLen, &nArrayNum)) {
			Dbg("%s,%d,%d", pBuf, nLen, nArrayNum);
			HandAns* pAns = (HandAns*)pBuf;
			Dbg("hand recv %d events", nArrayNum);
			for (int i = 0; i < nArrayNum; ++i)
			{
				bool bKnownEvent = true;
				DWORD userEvtCode = 0;
				unsigned long ulTmp = (pAns + i)->EventCode;
				Dbg("event %d,param1 %s", ulTmp, (pAns + i)->param1);
				switch (ulTmp)
				{
				case INC_GLOBAL_SETTING_SYNC:
					userEvtCode = LOG_EVT_INC_GLOBAL_SETTING_SYNC;
					break;
				case INC_COMM_RECONNECT:
					userEvtCode = LOG_EVT_INC_COMM_RECONNECT;
					break;
				case INC_START_REMOTE_CONTROL:
					userEvtCode = LOG_EVT_INC_START_REMOTE_CONTROL;
					break;
				case INC_UPDATE_CHECK:
					userEvtCode = LOG_EVT_INC_UPDATE_CHECK;
					break;
				case INC_RECOVER_SERVICE:
					userEvtCode = LOG_EVT_INC_RECOVER_SERVICE;
					break;
				case INC_PAUSE_SERVICE:
					userEvtCode = LOG_EVT_INC_PAUSE_SERVICE;
					break;
				case INC_AREA_SERVICE_SWITCH:
					userEvtCode = LOG_EVT_INC_AREA_SERVICE_SWITCH;
					break;
				case INC_VERSION_ROLLBACK:
					userEvtCode = LOG_EVT_INC_VERSION_ROLLBACK;
					break;
				case INC_BRIDGE:
					userEvtCode = LOG_EVT_INC_BRIDGE;
					break;
				case INC_VEDIO_CONNECTING:
					userEvtCode = LOG_EVT_INC_VEDIO_CONNECTING;
					break;
				case INC_TRADE_MANAGER_NORMAL:
					userEvtCode = LOG_EVT_INC_TRADE_MANAGER_NORMAL;
					break;
				case INC_TRADE_MANAGER_ON:
					userEvtCode = LOG_EVT_INC_TRADE_MANAGER_ON;
					break;
				case INC_TRADE_MANAGER_OFF:
					userEvtCode = LOG_EVT_INC_TRADE_MANAGER_OFF;
					break;
				case INC_DEVICE_LOCK_ON:
					userEvtCode = LOG_EVT_INC_DEVICE_LOCK_ON;
					break;
				case INC_DEVICE_UNLOCK:
					userEvtCode = LOG_EVT_INC_DEVICE_UNLOCK;
					break;
				case INC_DEVICE_KICK_OFF:
					userEvtCode = LOG_EVT_INC_DEVICE_KICK_OFF;
					break;
				default:
					bKnownEvent = false;
					Dbg("unknown ins %d", ulTmp);
					break;
				}
				if (bKnownEvent)
				{
					LogEvent(Severity_Middle, userEvtCode, (pAns + i)->param1);
				}
			}
		}
		else {
			Dbg("invalid handshakeans packet!");
			//OnDisconnect();
		}
		delete pBuf;
	}
}

void CHeartBeatFSM::ProcessCardActive(CardActiveReq* req)
{
	ProcessPreOnlineTask* ppTask = new ProcessPreOnlineTask(this, req);
	GetEntityBase()->GetFunction()->PostThreadPoolTask(ppTask);
}

void CHeartBeatFSM::ProcessPreOnline(CardActiveReq* req)
{
	if (req->type == 0)
		LocalPreOnline(req->slot, req->TerminalNo, req->FromTerminalNo, req->Account, req->Param2);
	else if (req->type == 1)
		ReceivePreOnlineBack(req->ErrCode, req->Param2, req->findCard, req->cardPos);
	delete req;
}

void HeartBeatConnection::PkgRcvProcCardActive(const CSmartPointer<IPackage> &pRecvPkg)
{
	LOG_FUNCTION();
	int nLen = pRecvPkg->GetStructLen("INSREQX");
	if (nLen > 0) {
		Dbg("nLen %d", nLen);
		BYTE *pBuf = new BYTE[nLen+1];
		memset(pBuf, 0, nLen+1);
		int nArrayNum = 0;
		if (pRecvPkg->GetStructData("INSREQX", pBuf, &nLen, &nArrayNum)) {
			Dbg("%s,%d,%d", pBuf, nLen, nArrayNum);
			CardActiveReq* pAns = (CardActiveReq*)pBuf;
			//Dbg("hand recv %d events", nArrayNum);
			//for (int i = 0; i < nArrayNum; ++i)
			if (nArrayNum > 0)
			{
				CSimpleStringA inParam = CSimpleStringA::Format("PkgRcvProcCardActive, type %d, from term:%s, term:%s, accLen:%d, param2Len:%d, findCard:%d,cardPos:%d",
					pAns->type, pAns->FromTerminalNo, pAns->TerminalNo, strlen(pAns->Account), strlen(pAns->Param2), pAns->findCard, pAns->cardPos);
				LogWarn(Severity_Low, Error_Unexpect, HeartBeat_UserErrorCode_PkgRcvProcCardActive_InParam, inParam.GetData());
				m_pFSM->ProcessCardActive(pAns);
			}
		}
		else {
			Dbg("invalid insreqx packet!");
		}
		delete pBuf;
	}
}

void HeartBeatConnection::PkgRcvProcCrossCall(const CSmartPointer<IPackage> &pRecvPkg)
{
	LOG_FUNCTION();
	int nLen = pRecvPkg->GetStructLen("CRSSREQ");
	Dbg("nLen: %d", nLen);
	if (nLen > 0) {
		
		BYTE *pBuf = new BYTE[nLen+1];
		ZeroMemory(pBuf,nLen+1);
		int nArrayNum = 0;
		if (pRecvPkg->GetStructData("CRSSREQ", pBuf, &nLen, &nArrayNum)) {
			Dbg("%d,array num:%d,last 3:%d,%d,%d", nLen, nArrayNum,pBuf[nLen-3], pBuf[nLen - 2], pBuf[nLen - 1]);
			CrossCallReq* pAnsArray = (CrossCallReq*)pBuf;
			Dbg("%x", ((CrossCallReq*)pBuf)->nEntityID);
			Dbg("num %x", ((CrossCallReq*)pBuf)->numOfBlobInParamX);
			int tmpXLen = 0;
			for (int i = 0; i < nArrayNum; ++i)
			{
				tmpXLen += strlen(pAnsArray[i].StrParamX);
			}

			tmpXLen += (sizeof(CrossCallReq)*nArrayNum);
			Dbg("tmpXLen:%d", tmpXLen);
			BYTE *pAnsBuf = new BYTE[tmpXLen + 1];
			ZeroMemory(pAnsBuf, tmpXLen + 1);
			memcpy_s(pAnsBuf, tmpXLen+1, pBuf, tmpXLen);
			CrossCallReq* pAns = (CrossCallReq*)pAnsBuf;
			pAns->Appendix1 = pAnsArray->Appendix1;
			pAns->Appendix2 = pAnsArray->Appendix2;
			pAns->bTwoWay = pAnsArray->bTwoWay;
			pAns->CallType = pAnsArray->CallType;
			pAns->ErrorCode = pAnsArray->ErrorCode;
			pAns->nEntityID = pAnsArray->nEntityID;
			pAns->numOfBlobInParamX = pAnsArray->numOfBlobInParamX;
			for (int i = 0; i < sizeof(pAns->lensOfBlobInParamX); i++)
				pAns->lensOfBlobInParamX[i] = pAnsArray->lensOfBlobInParamX[i];
			strcpy_s(pAns->FromTerminalNo, sizeof(pAns->FromTerminalNo), pAnsArray->FromTerminalNo);
			strcpy_s(pAns->StrParam1, sizeof(pAns->StrParam1), pAnsArray->StrParam1);
			strcpy_s(pAns->StrParam2, sizeof(pAns->StrParam2), pAnsArray->StrParam2);
			strcpy_s(pAns->ToTerminalNo, sizeof(pAns->ToTerminalNo), pAnsArray->ToTerminalNo);

			Dbg("%x",pAns->nEntityID);
			for (int i = 0, start = 0; i < nArrayNum; ++i)
			{
				strcpy_s(pAns->StrParamX + start, tmpXLen - start, pAnsArray[i].StrParamX);
				start += strlen(pAnsArray[i].StrParamX);
			}
			Dbg("type:%x,from %s,to %s", pAns->CallType, pAns->FromTerminalNo, pAns->ToTerminalNo);
			Dbg("nEntityID: %x", pAns->nEntityID);
			Dbg("appendix1: %d", pAns->Appendix1);
			Dbg("bTwoWay:[%d]", pAns->bTwoWay);
			Dbg("blobSN:[%d]", pAns->blobSN);
			Dbg("param2:[%s]", pAns->StrParam2);
			Dbg("param3:[%d]", pAns->Appendix2);//oiltest
			Dbg("ErrorCode:[%x]", pAns->ErrorCode);//oiltest
			//Dbg("paramX:[%s]", pAns->StrParamX);
			//if (pAns->Appendix2 > 0)
			//{
			//	char *pBuf = new char[64 * 1024];
			//	ZeroMemory(pBuf, 64 * 1024);
			//	HexBuf2StrBuf((PBYTE)pAns->StrParamX, &pBuf, pAns->Appendix2);
			//	CSimpleStringA xStr(pBuf);
			//	int i = 0;
			//	for (; i < pAns->Appendix2 / 900; i++)
			//	{
			//		Dbg("%s", xStr.SubString(i * 900, 900));
			//	}
			//	Dbg("%s", xStr.SubString(i * 900, pAns->Appendix2 - i * 900));
			//}
			m_pFSM->DoLocalProcessCrossCallTask(pAns, nLen);
		}
		else {
			Dbg("invalid CRSSREQ packet!");
		}
		delete pBuf;
	}
}