myvtm/Module/mod_heartbeat/HeartBeatFSM.cpp

#include "stdafx.h"
#include <string.h>
#include "HeartBeatFSM.h"
#include "HeartBeat_UserErrorCode.h"
#include <regex>
#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")
#else
#include "json/json.h"
#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]

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;
	
	m_isCardStore = !sysInfo.strMachineType.Compare("RVC.CardStore", true);

	ErrorCodeEnum rc = GetServerAddr(spConfig, m_isCardStore);
	if(Error_Succeed != rc)
		return rc;
	
	spConfig->ReadConfigValueInt(GetEntityBase()->GetEntityName(),"TestFlag",m_tmpTestFlag);
	spConfig->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "LongConnInterval", m_longConnInterval);
	if (m_longConnInterval < 20000) {
		m_longConnInterval = 20000;//默认20s
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("LongConnInterval<20000ms ,use default 20s", m_longConnInterval);
	}
	int intervalTemp = 0;
	spConfig->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "HandShakeConnInterval", intervalTemp);
	if (intervalTemp == 0) {
		//未配置
		m_handShakeConnInterval = 20000;
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("m_handShakeConnInterval is not configured ,use default 20s", m_handShakeConnInterval);
	}
	else {
		//已配置
		if (intervalTemp < 10000) {
			m_handShakeConnInterval = 10000;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("m_handShakeConnInterval %d ms<10000ms ,use default 10s", intervalTemp);
		}
		else {
			m_handShakeConnInterval = intervalTemp;
		}
	}
	
	//网络字节序
	//由于双活改造，改成固定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);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Split rundisk file string(%s) failed", (LPCTSTR)csRunDiskName);
		return Error_Unexpect;
	}
	CSimpleStringA temp="";
	spConfig->ReadConfigValue(GetEntityBase()->GetEntityName(), "HandShakeUrl", temp);
	m_strHandShakeUrl = temp;
	//有心跳地址才启动心跳新线程
	if (!m_strHandShakeUrl.IsNullOrEmpty()) {
		NewHandShakeTask* task = new NewHandShakeTask(this);
		Error = this->GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		if (rc != Error_Succeed)
		{
			LogError(Severity_Middle, rc, 0, CSimpleStringA::Format("NewHandShakeTask Thread is fail,%d", (int)rc).GetData());
			m_testResult = Error_InvalidState;//启动心跳线程失败
			return Error_Exception;
		}
		else {
			LogWarn(Severity_Low, Error_Exception, LOG_EVT_HEARTBEAT_TASK_START,
				CSimpleStringA::Format("NewHandShakeTask task start,HandShakeConnInterval= %d ms, LongConnInterval = %d ms, url=%s", m_handShakeConnInterval,m_longConnInterval,m_strHandShakeUrl.GetData()));
		}
	}
	else {
		//提醒无心跳地址，旧心跳时间默认设置为20s
		m_longConnInterval = 20000;//设置为20s
		LogWarn(Severity_Low, Error_Exception, LOG_EVT_HEARTBEAT_TASK_NOT_START,"NewHandShakeTask task not start,HandShakeUrl is temp,LongConnInterval use default 20s");
	}




	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)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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.");
	LogWarn(Severity_Low, Error_Unexpect, 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:
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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;
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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()
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("HeartBeat start to connect.");

	if (!m_pHandShakeConn) 
	{
		//HeartBeatConnection* pHandShakeConn;
		m_pHandShakeConn = new HeartBeatConnection(m_pEntity, this);
		if (m_pHandShakeConn != NULL)
		{
			bool bConn = false;

			if(m_isCardStore)
			{
				bConn = m_pHandShakeConn->Connect(m_servIP, m_port, 3);
			}
			else
			{
				bConn = m_pHandShakeConn->ConnectFromCentralSetting();
			}
			if (!bConn) 
			{
				m_pHandShakeConn->Close();
				//delete m_pHandShakeConn;//oiltest
				m_pHandShakeConn->DecRefCount();
				m_pHandShakeConn = NULL;
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("cannot connect to server.");
				LogEvent(Severity_Middle, LOG_EVT_HEARTBEAT_UN_CONNECTED, "Branch heartbeat service unconnected.");
				LogWarn(Severity_Middle, Error_Unexpect, LOG_EVT_HEARTBEAT_UN_CONNECTED, "Branch heartbeat service unconnected.");
				return 1;
			}
		}
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("HeartBeat connected.");
	return 0;
}
int CHeartBeatFSM::DoHandShake()
{
	if (m_pHandShakeConn) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("start handshake");
		//oiltest sp_var_client_set has no write privilege!
		//GetEntityBase()->GetFunction()->SetSysVar("HeartbeatState","C");
		while (1)
		{
			
			if (!m_pHandShakeConn || !m_pHandShakeConn->IsConnectionOK())
			{
				FSMEvent *e = new FSMEvent(USER_EVT_START);
				PostEventFIFO(e);
				break;
			}
			GetEntityBase()->GetFunction()->SetSysVar("HeartbeatState", "C");
			m_pHandShakeConn->SendHandShake();

			if(m_pHandShakeConn->IsConnectionOK() && !m_bAlarmed)
			{
				regex reg("((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])");
				if(regex_match(m_servIP.GetData(), reg))
				{
					CSimpleStringA msg = CSimpleStringA::Format("Branch server IP: %s, backup ip: %s", m_servIP.GetData(), m_servIPB.GetData());
					LogWarn(Severity_Low, Error_Succeed, LOG_EVT_CONNECT_BRANCH, msg);
				}
				else
				{
					CSimpleStringA msg = CSimpleStringA::Format("Center server url: %s", m_servIP.GetData());
					LogWarn(Severity_Low, Error_Succeed, LOG_EVT_CONNECT_CENTER, msg);
				}
				m_bAlarmed = true;
			}
			Sleep(m_longConnInterval);//修改成可配置的时间间隔
			//Sleep(20000);//oiltest
			if (m_tmpTestFlag)
			{
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("send spshell.exe restart event.");
				LogEvent(Severity_Middle, Event_Req_Framework_Restart, "spshell.exe restart");
			}
		}
	}
	return 0;
}

int CHeartBeatFSM::DoNewHandShake() {
	int warnSum = 0;
	while (true)
	{
		if (warnSum == 50) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("HandShakeHttp")("HandShakeHttp send 50 times");
			warnSum = 0;
		}		
		IHttpFunc* client;
		client = create_http(HttpsLogCallBack);
		//发送心跳http请求
		bool isHeartBeatOk=false;
		bool bRet = HandShakeHttp(client, isHeartBeatOk);
		if (bRet) {
			if (!isHeartBeatOk) {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("HandShakeHttp")("HandShakeHttp isHeartBeatOk=false");
			}
		}
		client->Destory();
		Sleep(m_handShakeConnInterval);//改为参数配置
		warnSum++;
	}
	return 0;
}

bool CHeartBeatFSM::HandShakeHttp(IHttpFunc* client,bool &isHeartBeatOk) {
	HttpStruct::SendHandShakeReq qTempReq;
	HttpStruct::SendHandShakeRet qTempRet;

	CSystemStaticInfo info;
	qTempReq.m_reqStr = HandShakeJsonStr();//请求参数
	qTempReq.m_url = m_strHandShakeUrl.GetData();//访问地址
	qTempReq.m_timeOut = 60;//设置传送超时时间为60s


	//qTempReq.m_printDbg = true;

	if (!client->Post(qTempReq, qTempRet)) {
		LogWarn(Severity_Low, Error_Exception, LOG_EVT_HEARTBEAT_HTTP_ERROR, CSimpleStringA::Format("HandShakeHttp http req fail,url=%s, err=%s", qTempReq.m_url.c_str(), qTempRet.m_errMsg.c_str()).GetData());
		return false;//通讯失败
	}

	//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("HandShakeHttp")("qTempRet=%s", qTempRet.m_retStr.c_str());


	Json::Reader reader;
	Json::Value rootRet;
	if (!reader.parse(qTempRet.m_retStr, rootRet, false))
	{
		LogWarn(Severity_Low, Error_Exception, LOG_EVT_HEARTBEAT_HTTP_ERROR, CSimpleStringA::Format("HandShakeHttp parse resp is fail,url=%s", qTempReq.m_url.c_str()).GetData());
		return false;//服务异常
	}
	
	bool isSucc = rootRet["success"].asBool();
	if (isSucc) {
		if (rootRet.isMember("data")) {
			if (rootRet["data"].asBool()) {
				isHeartBeatOk = true;//心跳正常
				return true;//服务正常
			}
			else {
				isHeartBeatOk = false;//心跳不正常
				return true;//服务正常
			}
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("HandShakeHttp")("HandShakeHttp [success] is true,param [data] is lost");
			return false;//服务异常
		}
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("HandShakeHttp")("HandShakeHttp [success] is false,errCode=%s,errStr=%s", qTempRet.m_userCode.c_str(),qTempRet.m_errMsg.c_str());
		return false;//服务异常
	}
}


string CHeartBeatFSM::HandShakeJsonStr() {
	//LOG_FUNCTION();
	string jsonStr = "";
	Json::Value root;
	Json::FastWriter fw;//写入对象
	Json::Value obj1, obj2, obj3;

	//写入shakehandvo对象
	CSystemStaticInfo sysSInfo;
	m_pEntity->GetFunction()->GetSystemStaticInfo(sysSInfo);
	CSimpleStringA warningLevel("w"), runState("r"), customerHandle("c"), callState("s"),
		localMaintain("l"), remoteMaintain("m"), termStage("U");
	m_pEntity->GetFunction()->GetSysVar("RunState", runState);
	m_pEntity->GetFunction()->GetSysVar("CustomerHandle", customerHandle);
	m_pEntity->GetFunction()->GetSysVar("CallState", callState);
	m_pEntity->GetFunction()->GetSysVar("TerminalStage", termStage);
#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;
				}
			}
		}
	}
#endif //RVC_OS_WIN
	obj1["terminalNo"] = sysSInfo.strTerminalID.GetData();
	obj1["ip"] = 0;//默认不获取
	obj1["warningLevel"] = warningLevel.GetData();
	obj1["runState"] = runState.GetData();
	obj1["customerHandle"] = customerHandle.GetData();
	obj1["callState"] = callState.GetData();
	obj1["localMaintain"] = localMaintain.GetData();
	obj1["remoteMaintain"] = remoteMaintain.GetData();
	obj1["termStage"] = termStage.GetData();
	obj1["preTermStage"] = "";
	obj1["netState"] = "";
	obj1["preNetState"] = "";
	root["shakeHandVO"]=Json::Value(obj1);

	//写入shakeHandSystemInfo对象
	TermianlCounter counter;
	ErrorCodeEnum erroCode = GetPerformCounter(counter);
	if (erroCode != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Get Terminal Performance Information failed !!!");
	}
	//Dbg("dwServIP 0x%x", counter.serverIP);
#ifdef RVC_OS_WIN
	const char* diskPath = GetRunDiskPath();
	ULARGE_INTEGER uliFreeBytesAvailable;
	if (GetDiskFreeSpaceEx(diskPath, &uliFreeBytesAvailable, NULL, NULL))
	{
		counter.freeDisk = (unsigned int)(uliFreeBytesAvailable.QuadPart / 1024.0 / 1024.0);
	}
	else
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("GetDiskFreeSpaceEx with %s failed failed 0x%x", diskPath, GetLastError());
	}
#else
	//oiltestlinux
	counter.freeDisk = 0;
#endif //RVC_OS_WIN
	obj2["serverIP"] = (unsigned int)m_dwServIP;
	obj2["totalMem"] = (int)counter.totalMem;
	obj2["freeMem"] = (int)counter.freeMem;
	obj2["procNum"] = (int)counter.procNum;
	obj2["threadNum"] = (int)counter.threadNum;;
	obj2["handleNum"] = (unsigned int)counter.handleNum;;
	obj2["freeDisk"] = (unsigned int)counter.freeDisk;
	obj2["osStartTime"] = CSimpleStringA::Format("%s",counter.osStartTime).GetData();
	obj2["cpuLoad"] = (int)counter.cpuLoad;
	root["shakeHandSystemInfo"]=Json::Value(obj2);

	//写入shakeHandErrorVO对象
	HandErrListReq errListReq;
	errListReq.warnLevel = GetWarnLevel();
	errListReq.reserved1 = GetTradeManagerState();
	ZeroMemory(errListReq.errList, 512);
	strncpy(errListReq.errList, GetEntityErrorList(), GetEntityErrorList().GetLength());

	obj3["warnLevel"] = errListReq.warnLevel;
	string tmp_string(1, errListReq.reserved1);
	obj3["reserved1"] = tmp_string.c_str();
	obj3["errList"] = CSimpleStringA::Format("%s", errListReq.errList).GetData();
	root["shakeHandErrorVO"]=Json::Value(obj3); 

	
	jsonStr = fw.write(root);
	//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("HandShakeJsonStr")("HandShakeJsonStr=%s", jsonStr.c_str());
	return jsonStr;
}

void CHeartBeatFSM::HttpsLogCallBack(const char* logtxt)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("HttpsLogCallBack")("http dbg: %s", logtxt);
}
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)
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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());
	eErr = pCardReadAdapterClient->Connect();
	if (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());
		pCardReadAdapterClient->SafeDelete();
		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);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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);
		if (eErr == Error_Duplication)
		{
			ReceivePreOnlineBack(Error_Duplication, "", 0, 0);
			pCardReadAdapterClient->GetFunction()->CloseSession();
			return;
		}
		LogWarn(Severity_Low, Error_Unexpect, HeartBeat_UserErrorCode_Connect_CardStore_Invoke_PreOnline_Falied, outParam.GetData());
	}
	Sleep(500);
	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, outParam.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);
	}
	pCardReadAdapterClient->GetFunction()->CloseSession();
}
void CHeartBeatFSM::ReceivePreOnlineBack(unsigned long errCode,CSimpleStringA data, unsigned long findCard, unsigned long cardPos)
{
	LOG_FUNCTION();
	CardIssuerService_ClientBase *pCardIssuerClient = NULL;
	ErrorCodeEnum eErr = Error_Unexpect;
	pCardIssuerClient = new CardIssuerService_ClientBase(GetEntityBase());
	eErr = pCardIssuerClient->Connect();	
	if (eErr != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("pGuiConsoleClient is null or connect to cardissuer failed.%d", eErr);
		pCardIssuerClient->SafeDelete();
		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);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("NotifyPreonline ret:%d",eErr);
	pCardIssuerClient->GetFunction()->CloseSession();
}
int CHeartBeatFSM::CrossTermCall(SpReqAnsContext<HeartBeatService_CrossTermCall_Req, HeartBeatService_CrossTermCall_Ans>::Pointer ctx)
{
	int ret = 0;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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"))
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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;
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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);
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("offset %d, %d", FIELD_OFFSET(CrossCallReq, StrParamX), xSize);
				bool bBuf = spbuf2.OpenRead((const char*)&(reqInfo->StrParamX[0]), xSize);
				if (bBuf) {
					DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("offset succ.");
					if (xSize > 0)
						info.paramX = spbuf2.ToBlob();
				}

				ec = pClient->CrossTermInvokeInfo(info);
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("CrossTermInvokeInfo return %d", ec);
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("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);
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("offset %d, %d", FIELD_OFFSET(CrossCallReq, StrParamX), xSize);
				bool bBuf = spbuf2.OpenRead((const char*)&(reqInfo->StrParamX[0]), xSize);
				if (bBuf) {
					DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("offset succ.");
					if (xSize > 0)
						info.paramX = spbuf2.ToBlob();
				}

				ec = pClient->CrossTermInvokeInfo(info);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CrossTermInvokeInfo return %d", ec);
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Connect to PinPad failed %d", ec);
			}
		}
		break;
		case 0x218:
			{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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);
					DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("offset %d, %d", FIELD_OFFSET(CrossCallReq, StrParamX) , size);
					bool bBuf = spbuf2.OpenRead((const char*)&(reqInfo->StrParamX[0]), size);
					if(bBuf) {
						DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("offset succ.");
						if(size > 0) {
							info.paramX = spbuf2.ToBlob();
						}
					}
					ec = pClient->CrossTermInvokeInfo(info);
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CrossTermInvokeInfo return %d", ec);
				} else {
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("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);
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("offset %d, %d", FIELD_OFFSET(CrossCallReq, StrParamX), xSize);
				bool bBuf = spbuf2.OpenRead((const char*)&(reqInfo->StrParamX[0]), xSize);
				if (bBuf) {
					DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("offset succ.");
					if (xSize > 0)
						info.paramX = spbuf2.ToBlob();
				}

				ec = pClient->CrossTermInvokeInfo(info);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CrossTermInvokeInfo return %d", ec);
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Connect to CardReadAdapter failed %d", ec);
			}
		}
		break;
		case 0x999:
		{
			if (reqInfo->numOfBlobInParamX == 1)
			{
				NotifyIECallResult resultNote;
				resultNote.ans_context = reqInfo->StrParamX;
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("oiltest %s", (const char*)resultNote.ans_context.SubString(0, 512));
				resultNote.error = reqInfo->ErrorCode;
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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)
						DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("oiltest substr %s", (const char*)resultNote.ans_context.SubString(0, 512));
					else
						DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("oiltest %s", (const char*)resultNote.ans_context);
					if (resultNote.ans_context.GetLength() > 100)
						DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("oiltest the last 100 str %s", (const char*)resultNote.ans_context.SubString(resultNote.ans_context.GetLength()-100, 100));
					resultNote.error = reqInfo->ErrorCode;
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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)
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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());
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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;
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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长度
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("send pkg to client: %d,Y len:%d", ec, reqY.paramX.m_iLength);
					SendToHeartBeatService(reqY, ansY);
				}
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Connect to IDCertificate failed %d", ec);
				m_pIDClient->SafeDelete();
				m_pIDClient = NULL;
			}
		}
		break;
		case 0x206://pinpad
		{
			ErrorCodeEnum ec = Error_Succeed;
			if (m_pPinPadClient == NULL)
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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());
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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;
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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长度
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("send pkg to client: %d,Y len:%d", ec, reqY.paramX.m_iLength);
					SendToHeartBeatService(reqY, ansY);
				}
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("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;
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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);
					 DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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;
						 DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("send pkg to client: %d", ec);
						 SendToHeartBeatService(reqY, ansY);
					 }
				} else {
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Connect to scanner failed %d", ec);
				}
			}
			break;
		case 0x21B:
		{
			ErrorCodeEnum ec = Error_Succeed;
			if (m_pCRAClient == NULL)
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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());
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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;
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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长度
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("send pkg to client: %d,X len:%d", ec, reqY.paramX.m_iLength);
					SendToHeartBeatService(reqY, ansY);
				}
			}
			else {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Connect to CardReadAdapter failed %d", ec);
			}
		}
		break;
		case 0x999:
		{
			m_ILDeviceNo = reqInfo->FromTerminalNo;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("save il TerminalNo:%s",(const char*)m_ILDeviceNo);
			NotifyIEToCall note;
			note.context = reqInfo->StrParamX;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("oiltest %s",(const char*)note.context);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("note IE to call:%d", reqInfo->lensOfBlobInParamX[0]);
			SpSendBroadcast(GetEntityBase()->GetFunction(), SP_MSG_OF(NotifyIEToCall), SP_MSG_SIG_OF(NotifyIEToCall), note);
		}
		break;
		default:
			break;
		}
	}


}

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)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("PdhOpenQuery failed with status 0x%x.", Status);
		goto Cleanup;
	}
	Status = PdhAddCounter(Query, ProcessTimeQuery, NULL, &hcProcessTimeCount);
	if (Status != ERROR_SUCCESS)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("PdhAddCounter for ProcessTimeQuery failed with status 0x%x.", Status);
		goto Cleanup;
	}
	Status = PdhAddCounter(Query, HandleNumQuery, NULL, &hcHandleCount);
	if (Status != ERROR_SUCCESS)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("PdhAddCounter for HandleNumQuery failed with status 0x%x.", Status);
		goto Cleanup;
	}
	Status = PdhAddCounter(Query, ThreadNumQuery, NULL, &hcThreadCount);
	if (Status != ERROR_SUCCESS)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("PdhAddCounter for ThreadNumQuery failed with status 0x%x.", Status);
		goto Cleanup;
	}
	Status = PdhAddCounter(Query, ProcessNumQuery, NULL, &hcProcessCount);
	if (Status != ERROR_SUCCESS)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("PdhAddCounter for ProcessNumQuery failed with status 0x%x.", Status);
		goto Cleanup;
	}
	Status = PdhAddCounter(Query, SystemElapsedQuery, NULL, &hcElapsedTimeCount);
	if (Status != ERROR_SUCCESS)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("PdhAddCounter for SystemElapsedQuery failed with status 0x%x.", Status);
		goto Cleanup;
	}

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

	do
	{
		Sleep(COUNTER_INTERVAL_MS);

		Status = PdhCollectQueryData(Query);
		if (Status != ERROR_SUCCESS)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("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 :
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("The counter path could not be parsed or interpreted.");
			break;
		case PDH_CSTATUS_NO_COUNTER :
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Unable to find the specified counter on the computer or in the log file.");
			break;
		case PDH_CSTATUS_NO_COUNTERNAME  :
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("The counter path is empty.");
			break;
		case PDH_CSTATUS_NO_MACHINE  :
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("The path did not contain a computer name, and function was unable to retrieve local computer name.");
			break;
		case PDH_CSTATUS_NO_OBJECT  :
			{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("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  :
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Unable to determine the calculation function to use for this counter.");
			break;
		case PDH_INVALID_ARGUMENT :
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("One or more arguments are not valid.");
			break;
		case PDH_INVALID_HANDLE  :
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("The query handle is not valid.");
			break;
		case PDH_MEMORY_ALLOCATION_FAILURE  :
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Unable to allocate memory required to complete the function.");
			break;
		default :
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("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
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("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");
	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)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("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
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("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);
}

void HeartBeatConnection::PkgRcvProcCardActive(const CSmartPointer<IPackage> &pRecvPkg)
{
	LOG_FUNCTION();
	int nLen = pRecvPkg->GetStructLen("INSREQX");
	if (nLen > 0) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("nLen %d", nLen);
		BYTE *pBuf = new BYTE[nLen+1];
		memset(pBuf, 0, nLen+1);
		int nArrayNum = 0;
		if (pRecvPkg->GetStructData("INSREQX", pBuf, &nLen, &nArrayNum)) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s,%d,%d", pBuf, nLen, nArrayNum);
			CardActiveReq* pAns = (CardActiveReq*)pBuf;
			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 {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("invalid insreqx packet!");
		}
		delete pBuf;
	}
}

void HeartBeatConnection::PkgRcvProcCrossCall(const CSmartPointer<IPackage> &pRecvPkg)
{
	LOG_FUNCTION();
	int nLen = pRecvPkg->GetStructLen("CRSSREQ");
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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)) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%d,array num:%d,last 3:%d,%d,%d", nLen, nArrayNum,pBuf[nLen-3], pBuf[nLen - 2], pBuf[nLen - 1]);
			CrossCallReq* pAnsArray = (CrossCallReq*)pBuf;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%x", ((CrossCallReq*)pBuf)->nEntityID);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("num %x", ((CrossCallReq*)pBuf)->numOfBlobInParamX);
			int tmpXLen = 0;
			for (int i = 0; i < nArrayNum; ++i)
			{
				tmpXLen += strlen(pAnsArray[i].StrParamX);
			}

			tmpXLen += (sizeof(CrossCallReq)*nArrayNum);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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);

			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("%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);
			}
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("type:%x,from %s,to %s", pAns->CallType, pAns->FromTerminalNo, pAns->ToTerminalNo);
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("nEntityID: %x", pAns->nEntityID);
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("appendix1: %d", pAns->Appendix1);
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("bTwoWay:[%d]", pAns->bTwoWay);
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("blobSN:[%d]", pAns->blobSN);
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("param2:[%s]", pAns->StrParam2);
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("param3:[%d]", pAns->Appendix2);//oiltest
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("ErrorCode:[%x]", pAns->ErrorCode);//oiltest

			m_pFSM->DoLocalProcessCrossCallTask(pAns, nLen);
		}
		else {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("invalid CRSSREQ packet!");
		}
		delete pBuf;
	}
}

ErrorCodeEnum CHeartBeatFSM::GetServerAddr(CSmartPointer<IConfigInfo> &spConfig, bool isCardStore)
{
	//卡库用新地址
	if(isCardStore)
	{
		spConfig->ReadConfigValue(GetEntityBase()->GetEntityName(),"ServerNew",m_servStr);
		if (!m_servStr.IsNullOrEmpty())
		{
			CAutoArray<CSimpleStringA> aaServ = m_servStr.Split(' ');
			if (aaServ.GetCount() >= 2)
			{
				m_servIP = aaServ[0];
				m_port = atoi(aaServ[1]);

			}
			else
			{
				GetEntityBase()->GetFunction()->ShowFatalError("实体HeartBeat找不到对应的配置，请检查集中配置");
				return Error_Param;
			}
		}
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s,%d",(LPCTSTR)m_servIP,m_port);
	}
	else
	{
		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
			{
				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
			{
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("no backup(%s).",(LPCSTR)m_servStrB);
				m_servIPB = m_servIP;
				m_portB = m_port;
			}
		}

		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s,%d;%s,%d",(LPCTSTR)m_servIP,m_port,(LPCTSTR)m_servIPB,m_portB);
	}

	return Error_Succeed;
}