myvtm/Module/mod_pinpad/PinPadFSM.cpp

#include "stdafx.h"
#include "PinPadFSM.h"
#include "PinPad_msg_g.h"
#include "GetDevInfoHelper.h"
#include "EventCode.h"
#include "ModuleMix.h"
#include <map>
#include "RVCComm.h"
#include "sm4.h"
#include "publicFunExport.h"
#if defined(RVC_OS_LINUX)
#include <thread>
#include <chrono>
#include <winpr/sysinfo.h>
#endif

using namespace std;

const int PINPAD_INIT_TRIES = 3;
const int PINPAD_ANY_INPUT_TIMEOUT = 100;
const int MAX_PINPAD_INPUT_TIMEOUT = 60000;
const int MAX_INPUT_TIMER_TIMEOUT = 600000;

void CPinPadFSM::ToLogWarnInfoAboutTermCustom()
{
	LOG_FUNCTION();
	std::map<std::string, std::string> termInfo;
	char* strFileHash = new char[128];
	memset(strFileHash, 0, 128);
	termInfo["keyType"] = _itoa(m_encryptkey, strFileHash,10);
	if (strFileHash != nullptr) {
		delete[] strFileHash;
		strFileHash = nullptr;
	}

	if (m_bSMLoaded)
		termInfo["SMKeyLoad"] = "true";
	else
		termInfo["SMKeyLoad"] = "false";
	
	ToLogWarnInfoAboutTermExtend(termInfo);
}

ErrorCodeEnum CPinPadFSM::OnInit()
{
	LOG_FUNCTION();
	CSystemStaticInfo sysInfo;
	m_csMachineType = m_csSite = m_terminalNo = "";
	GetEntityBase()->GetFunction()->GetSystemStaticInfo(sysInfo);
	m_csMachineType = sysInfo.strMachineType;
	m_csSite = sysInfo.strSite;
	m_terminalNo = sysInfo.strTerminalID;
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("machineType:%s,site:%s,terminalNo:%s",
		(const char*)m_csMachineType, (const char*)m_csSite, (const char*)m_terminalNo);
	_beginthreadex(NULL,0,DoWork,(void*)this,0,NULL);

	return Error_Succeed;
}
ErrorCodeEnum CPinPadFSM::OnExit()
{
	LOG_FUNCTION();
	m_bEntityExit = true;
	m_hInputConVar.Broadcast();
	ErrorCodeEnum eErr = Error_Succeed;
	if (m_hDevHelper != nullptr)
	{
		m_ullBeginTime = SP::Module::Comm::RVCGetTickCount();
		eErr = m_hDevHelper->StopInput();
		m_ullEndTime = SP::Module::Comm::RVCGetTickCount();
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::StopInput").setCostTime(m_ullEndTime - m_ullBeginTime)("%s", SpStrError(eErr));
		m_hDevHelper.TearDown();
	}
	return eErr;
}
void CPinPadFSM::s0_on_entry()
{
	LOG_FUNCTION();
	FSMEvent *e = new FSMEvent(USER_EVT_INIT);
	PostEventFIFO(e);
	m_ullConnectCost = SP::Module::Comm::RVCGetTickCount();
}
void CPinPadFSM::s0_on_exit()
{
}
unsigned int CPinPadFSM::s0_on_event(FSMEvent* evt)
{
	LOG_FUNCTION();
	if (evt->iEvt == USER_EVT_INIT) {
		m_hInputConVar.Broadcast();
		evt->SetHandled();
		return 0;
	}else if (evt->iEvt == USER_EVT_QUIT) {
		evt->SetHandled();
		return 0;
	}
	return 0;
}
void CPinPadFSM::s1_on_entry()
{
	LOG_FUNCTION();
}
void CPinPadFSM::s1_on_exit()
{
}
unsigned int CPinPadFSM::s1_on_event(FSMEvent* evt)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("s1 event %d",evt->iEvt);
	int ret = 0;
	if (evt->iEvt == USER_EVT_INITFINISHED) {
		evt->SetHandled();
		int err = evt->param1;
		if (err == 0)
			ret = 0;
		else
			ret = 1;
		//SetEvent(m_hInitEvt);
		return ret;
	}else if (evt->iEvt == USER_EVT_QUIT) {
		evt->SetHandled();
		return 0;
	}
	return 0;
}
//Idle
void CPinPadFSM::s2_on_entry()
{
	LOG_FUNCTION();
	m_eDevState = DEVICE_STATUS_NORMAL;
	GetEntityBase()->GetFunction()->SetUserDefineState(USER_PINPAD_IDLE);
	m_testResult = Error_Succeed;
}

void CPinPadFSM::s2_on_exit()
{
}
unsigned int CPinPadFSM::s2_on_event(FSMEvent* pEvt)
{
	if (pEvt->iEvt != 1) 
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("s2 %d,%d",pEvt->iEvt,pEvt->param1);
	switch(pEvt->iEvt)
	{
	case USER_EVT_GETINPUT_SM:
		{
			m_hInputConVar.Broadcast();
			pEvt->SetHandled();
			return 0;
		}
	case USER_EVT_LOADKEY_SM:
		{
			pEvt->SetHandled();
			m_bLoadKey = true;
			LoadKeySMTask* task = new LoadKeySMTask(this);
			LoadKeySMEvent* lke = dynamic_cast<LoadKeySMEvent*>(pEvt);
			task->ctx = lke->ctx;
			GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
			return 2;
		}
	case USER_EVT_ENCRYPT_SM:
		{
			pEvt->SetHandled();
			m_bEncrypt = true;
			EncryptSMTask* task = new EncryptSMTask(this);
			EncryptSMEvent* ee = dynamic_cast<EncryptSMEvent*>(pEvt);
			task->ctx = ee->ctx;
			GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
			return 2;
		}
	case USER_EVT_GET_CHECKCODE:
	{
		pEvt->SetHandled();
		GetCheckCodeTask* task = new GetCheckCodeTask(this);
		GetCheckCodeEvent* gcce = dynamic_cast<GetCheckCodeEvent*>(pEvt);
		task->ctx = gcce->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		return 0;
	}
	case USER_EVT_QUIT:
		pEvt->SetHandled();
		break;

	default:
		break;
	}
	return 1;
}
//Input
void CPinPadFSM::s3_on_entry()
{
	LOG_FUNCTION();
	GetEntityBase()->GetFunction()->SetUserDefineState(USER_PINPAD_PININPUT);
}
void CPinPadFSM::s3_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CPinPadFSM::s3_on_event(FSMEvent* evt)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("s3 event %d",evt->iEvt);
	switch(evt->iEvt)
	{
	case USER_EVT_GETINPUT_SM_FINISHED:
		evt->SetHandled();
		break;
	case USER_EVT_INPUTCANCEL:
		evt->SetHandled();
		m_bFrontCancel = true;
		break;
	case USER_EVT_INPUTWAITINGMORE:
		evt->SetHandled();
		m_bWaitingMore = true;
		break;
	case USER_EVT_EXIT:
		SetExitFlag();
		break;
	case USER_EVT_QUIT:
		evt->SetHandled();
		break;
	default:
		break;
	}
	return 0;
}
//AccessAuth
void CPinPadFSM::s4_on_entry()
{
	LOG_FUNCTION();
	GetEntityBase()->GetFunction()->SetUserDefineState(USER_PINPAD_PARAM_ENCRYPTE);
}
void CPinPadFSM::s4_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CPinPadFSM::s4_on_event(FSMEvent* pEvt)
{
	switch(pEvt->iEvt)
	{
	case USER_EVT_LOADKEY_SM_FINISHED:
		pEvt->SetHandled();
		break;
	case USER_EVT_ENCRYPT_SM_FINISHED:
		pEvt->SetHandled();
		break;
	case USER_EVT_GET_CHECKCODE:
	{
		pEvt->SetHandled();
		GetCheckCodeTask* task = new GetCheckCodeTask(this);
		GetCheckCodeEvent* gcce = dynamic_cast<GetCheckCodeEvent*>(pEvt);
		task->ctx = gcce->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		return 0;
	}
	default:
		break;
	}
	return 0;
}
void CPinPadFSM::s5_on_entry()
{
	LOG_FUNCTION();
	if (m_bOpened)
		m_eDevState = DEVICE_STATUS_FAULT;
	GetEntityBase()->GetFunction()->SetUserDefineState(USER_PINPAD_FAILED);
	m_testResult = Error_InvalidState;
}
void CPinPadFSM::s5_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CPinPadFSM::s5_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("s5 evt %d",pEvt->iEvt);
	switch (pEvt->iEvt)
	{
	default:
		break;
	}
	return 0;
}
void CPinPadFSM::s6_on_entry()
{
	LOG_FUNCTION();
	m_eDevState = DEVICE_STATUS_NOT_READY;
	GetEntityBase()->GetFunction()->SetUserDefineState(USER_PINPAD_FAILED);
}
void CPinPadFSM::s6_on_exit()
{
}
unsigned int CPinPadFSM::s6_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("s6 evt %d", pEvt->iEvt);
	switch (pEvt->iEvt)
	{
	default:
		break;
	}
	return 0;
}
int CPinPadFSM::Initial()
{
	LOG_FUNCTION();
#if defined(RVC_OS_WIN)
	DWORD dwCurrThId = GetCurrentThreadId();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Initial thread id:%d", dwCurrThId);
#endif
	ErrorCodeEnum eErrDev;
	auto pEntity = GET_DEV_ENTITY_BASE_POINTER();

	GetEntityBase()->GetFunction()->GetSystemStaticInfo(m_sysStaticInfo);
	m_deviceNo = m_sysStaticInfo.strTerminalID;
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("m_deviceNo:%s", m_deviceNo.GetData());
	m_devCheckData = "0000000000000000";

	CSimpleStringA csDepPath(""), csBackslash(SPLIT_SLASH_STR);

	m_devSN = "";
	eErrDev = pEntity->LoadVendorLibName();
	if (eErrDev != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("SpGetDevAdaptorPath(%d) failed.", eErrDev);
		LogWarn(Severity_Middle, eErrDev, PinPad_UserErrorCode_Get_DevAdapter_Path_Failed, "Initial:SpGetDevAdaptorPath");
		return Error_DevLoadFileFailed;
	}
	FulfillAdapterInfoFrom(pEntity->vendorLibInfo);
	HARDWARE_ENTITY_SET_VENDOR_NAME(m_entCode, m_adapterInfo.strVendor);

	pEntity->InitializeVendorLogSwitch();


	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("to load vendor dll.");

	eErrDev = m_hDevHelper.LoadUp(m_adapterInfo.adapterFilePath);
	if (!IS_SUCCEED(eErrDev))
	{
		LogWarn(Severity_Middle, Error_NotInit, PinPad_UserErrorCode_Load_Dll_File_Failed, "密码键盘加载厂商适配器失败！请检查root.ini配置是否正确。");
		return Error_DevLoadFileFailed;
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("load vendor dll suc.");
	}

	int initTries = 0;
	ErrorCodeEnum eErr = Error_Unexpect;
	do
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("port:%d,baudRate:%d", m_adapterInfo.GetPortInt(), m_adapterInfo.GetBaudrateInt());
		m_ullBeginTime = SP::Module::Comm::RVCGetTickCount();
		eErr = m_hDevHelper->DevOpen(m_adapterInfo.GetPortInt(), m_adapterInfo.GetBaudrateInt());
		m_ullEndTime = SP::Module::Comm::RVCGetTickCount();

		if (eErr == Error_Succeed)
		{
			ToLogRootINIInfo();
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DevOpen").setCostTime(m_ullEndTime - m_ullBeginTime)();
			initTries = 0;
			ErrorCodeEnum errCode3, errCode4;
			m_ullBeginTime = SP::Module::Comm::RVCGetTickCount();
			//errCode1 = m_hDevHelper->SetParam(EPP_PT_SET_ENCRYPT_METHOD,EPP_ALGO_METHOD_3DES);
			//errCode2 = m_hDevHelper->SetParam(EPP_PT_SET_MAC_ALGORITH,EPP_MAC_ALGO_ASNIX99);
			errCode3 = m_hDevHelper->SetParam(EPP_PT_SET_PIN_ALGORITH, EPP_PIN_ALGO_SM4);
			errCode4 = m_hDevHelper->SetParam(EPP_PT_SET_ECB_CBC_MODE, EPP_ALGO_MODE_3DEC_CBC);
			m_ullEndTime = SP::Module::Comm::RVCGetTickCount();

			if (errCode3 != Error_Succeed || errCode4 != Error_Succeed)
			{
				if (errCode3 != Error_Succeed)
				{
					SetErrPackage("Initial::SetParm(3)", m_devSN, errCode3, MEC_DEVAPI_EPP_SetParam);
					AlarmDEC();
				}
				if (errCode4 != Error_Succeed)
				{
					SetErrPackage("Initial::SetParm(4)", m_devSN, errCode4, MEC_DEVAPI_EPP_SetParam);
					AlarmDEC();
				}
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetParam").setResultCode("RTA260B")
					.setCostTime(m_ullEndTime - m_ullBeginTime)("errCode3:%s, errCode4:%s", SpStrError(errCode3), SpStrError(errCode4));
				return 1;
			}
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetParam").setCostTime(m_ullEndTime - m_ullBeginTime)();
			break;
		}
		else
		{
			DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DevOpen").setResultCode("RTA2602").setCostTime(m_ullEndTime - m_ullBeginTime)("%s", SpStrError(eErr));
			initTries++;
			SetErrPackage("Initial::DevOpen", m_devSN, eErr, MEC_DEVAPI_EPP_DevOpen);
			AlarmDEC();
			Sleep(1200);
			continue;
		}
	} while (initTries < PINPAD_INIT_TRIES);

	if (initTries != 0)
	{
		LogEvent(Severity_Middle, LOG_EVT_PINPAD_OPEN_FAIL, "Open pinpad failed.");
		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("Open pinpad failed.");
		return 1;
	}
	m_bOpened = true;

	//oiltmp comment the following 20160406
	//update with the version 1.7.1
	m_ullBeginTime = SP::Module::Comm::RVCGetTickCount();
	m_encryptkey = m_hDevHelper->GetEncryptFunc();
	m_ullEndTime = SP::Module::Comm::RVCGetTickCount();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetEncryptFunc").setCostTime(m_ullEndTime - m_ullBeginTime)("Error_Succeed");
	CSmartPointer<IConfigInfo> spConfig;
	eErrDev = GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfig);
	if (eErrDev != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("read run cfg failed(sm).");
		m_bSMLoaded = false;
		LogWarn(Severity_Middle, eErrDev, PinPad_UserErrorCode_Open_RunCfgFile_Failed, "Initial:OpenConfig");
	}
	else
	{
		int tmpLoad = 0;
		eErrDev = spConfig->ReadConfigValueInt("Load", "SM", tmpLoad);
		if (eErrDev == Error_Succeed)
			m_bSMLoaded = tmpLoad;
		//oilyang@20201026 from kmc micro service
		spConfig->ReadConfigValue("Load", "SN_SM", m_keySNSM);
		spConfig->ReadConfigValue("Load", "ckckck", m_lastCheckCode);
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("encrypt key :%d,load key :%d", m_encryptkey, m_bSMLoaded);
	DevCategoryInfo devInfo;
	ZeroMemory(devInfo.szModel, MAX_DEV_MODEL_LEN);
	ZeroMemory(devInfo.szType, MAX_DEV_TYPE_LEN);
	ZeroMemory(devInfo.szVendor, MAX_DEV_VENDOR_LEN);
	m_ullBeginTime = SP::Module::Comm::RVCGetTickCount();
	eErrDev = m_hDevHelper->GetDevCategory(devInfo);
	m_ullBeginTime = SP::Module::Comm::RVCGetTickCount();

	if (eErrDev == Error_Succeed)
	{
		m_szModel = devInfo.szModel;
		m_szType = devInfo.szType;
		m_szVendor = devInfo.szVendor;
		m_adapterInfo.FulfillCategoryInfo(devInfo);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevCategory").setCostTime(m_ullEndTime - m_ullBeginTime)
			("model,%d,%s;type,%d,%s;vendor,%d,%s", strlen(devInfo.szModel), m_szModel.GetData(), strlen(devInfo.szType), m_szType.GetData(), strlen(devInfo.szVendor), m_szVendor.GetData());
	}
	else
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevCategory").setResultCode("RTA2606").setCostTime(m_ullEndTime - m_ullBeginTime)("%s", SpStrError(eErrDev));
		SetErrPackage("Initial::GetDevCategory", m_devSN, eErrDev, MEC_DEVAPI_EPP_GetDevCategory);
		AlarmDEC();
	}

	CSimpleStringA xTmpStr = CSimpleStringA::Format("(hw support):%d,load key :%d,SMSN:%s", m_encryptkey, m_bSMLoaded, m_keySNSM.GetData());
	LogWarn(Severity_Low, Error_Unexpect, PinPad_UserErrorCode_DevConnect_CostTime, CSimpleStringA::Format("%d", (SP::Module::Comm::RVCGetTickCount() - m_ullConnectCost) / 1000));
	LogWarn(Severity_Low, Error_Unexpect, PinPad_UserErrorCode_PinPad_InfoAboutKey_Onboot, xTmpStr.GetData());
	LogEvent(Severity_Middle, LOG_EVT_PINPAD_OPEN_SUC, "Open pinpad suc.");
	return 0;
}
unsigned int __stdcall DoWork(void *pData)
{
	while(1)
	{
		CPinPadFSM *pFsm = (CPinPadFSM*)pData;
		pFsm->m_hInputConVar.Wait();
		if (pFsm->GetEntityExit())
			break;
		FSMEvent *evt;
		int ret;
		if (!pFsm->GetDevInitFlag())
		{
			ret = pFsm->Initial();
			evt = new FSMEvent(USER_EVT_INITFINISHED);
		}
		else
		{
			SpReqAnsContext<PinPadService_GetInputSM_Req, PinPadService_GetInputSM_Ans>::Pointer ctxSM;
			bool bRet = pFsm->GetCtx(ctxSM);
			if (!bRet)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("get ctx failed.doing nothing");
				continue;
			}
			ret = pFsm->GetInput(ctxSM);
			evt = new FSMEvent(USER_EVT_GETINPUT_SM_FINISHED);
		}
		if (ret == 0)
			evt->param1 = 0;
		else
			evt->param1 = 1;
		pFsm->PostEventFIFO(evt);
	}
#if defined(RVC_OS_WIN)
	_endthreadex(0);
#else
	pthread_exit(0);
#endif //RVC_OS_WIN
	return 0;
}

void CPinPadFSM::push_char(char *buf, int *len, int c)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("len:%d",*len);
	buf[*len] = c;
	*len = *len + 1;
	buf[*len] = 0;
	InputContent evt;
	evt.data = buf;
	SpSendBroadcast(GetEntityBase()->GetFunction(), SP_MSG_OF(InputContent), SP_MSG_SIG_OF(InputContent), evt);
}
void CPinPadFSM::PushInputChar(char *buf,int c)
{
	buf[0] = c;
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("anyinput[%d][%s]",c,buf);
	InputContent evt;
	evt.data = buf;
	SpSendBroadcast(GetEntityBase()->GetFunction(), SP_MSG_OF(InputContent), SP_MSG_SIG_OF(InputContent), evt);
}
void CPinPadFSM::pop_char(char *buf, int *len, bool bClear)
{
	if (*len > 0) {
		if (bClear){
			memset(buf,0,*len);
			*len = 0;
		}else {
			*len -= 1;
			buf[*len] = 0;
		}
		InputContent evt;
		evt.data = buf;
		SpSendBroadcast(GetEntityBase()->GetFunction(), SP_MSG_OF(InputContent), SP_MSG_SIG_OF(InputContent), evt);
	}
}

void CPinPadFSM::clear_char(char *buf, int *len)
{
	if (*len > 0) {
		*len = 0;
		buf[*len] = 0;
		InputContent evt;
		evt.data = buf;
		SpSendBroadcast(GetEntityBase()->GetFunction(), SP_MSG_OF(InputContent), SP_MSG_SIG_OF(InputContent), evt);
	}
}
bool CPinPadFSM::Get12Account(char *szAcc)
{
	memset(m_szAccount,0,sizeof(m_szAccount));
	const int accLen = strlen(szAcc);
	if (accLen == 0) {
		return false;
	}

	if (accLen > 12)
		memcpy(m_szAccount + 4, szAcc + (accLen - 12 -1), 12);
	else if (accLen == 12)
	{
		if (strncmp(szAcc, "0755", 4) == 0)
			memcpy(m_szAccount + 4, szAcc, 12);
		else
		{
			m_szAccount[4] = '5';
			memcpy(m_szAccount + 5, szAcc + 1, 11);
		}
	}
	else if (accLen == 9)
	{
		memcpy(m_szAccount + 4, szAcc, 3);
		memcpy(m_szAccount + 7, szAcc, 9);
	}
	else
		memcpy(m_szAccount + 4, szAcc, accLen);

	return true;
}

ErrorCodeEnum CPinPadFSM::GetEncryptText(SpReqAnsContext<PinPadService_GetInputSM_Req, PinPadService_GetInputSM_Ans>::Pointer ctxSM)
{
	LOG_FUNCTION();
	ErrorCodeEnum errCode;
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	int len, timeout;
	bool confirm, bSMFlag = false;


	len = ctxSM->Req.length;
	timeout = ctxSM->Req.timeout;
	confirm = ctxSM->Req.confirm;
	if (ctxSM->Req.smflag == 1 || ctxSM->Req.smflag == 11)
	{
		bSMFlag = true;
	}

	if (!bSMFlag)
	{
		LogWarn(Severity_Low, Error_Unexpect, PinPad_UserErrorCode_PinPad_Not_SM, "Encryption is not SM");
		ctxSM->Answer(Error_Unexpect, PinPad_UserErrorCode_UnknownSMFlag);
		return Error_Unexpect;
	}

	AccountInfo accInfo;
	memset(accInfo.account, 0, MAX_ACCOUNT_LEN);
	CSimpleStringA errMsg(true);

	if (Get12Account(const_cast<char*>(ctxSM->Req.account.GetData())))
		memcpy(accInfo.account, m_szAccount + 4, 12);
	else
	{
		errMsg = CSimpleStringA::Format("Get12Account err(%s).", (const char*)ctxSM->Req.account);
		if (m_iInWhatPage == PageType_Other)
		{
			DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setLogCode(PinPadService_LogCode_GetInputSM).setResultCode("RTA2607")(errMsg.GetData());
			LogError(Severity_High, Error_Unexpect, PinPad_UserErrorCode_PinPad_GetEncryptText_Get12Account_Error, errMsg.GetData());
		}
		else
			LogWarn(Severity_High, Error_Unexpect, PinPad_UserErrorCode_PinPad_GetEncryptText_Get12Account_Error, errMsg.GetData());
		ctxSM->Answer(Error_DevCommFailed, PinPad_UserErrorCode_PinPad_GetEncryptText_Get12Account_Error);
		return Error_DevCommFailed;
	}

	//memcpy(accInfo.account,"588571006555",12);
	accInfo.dwAccLen = 12;
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("acc(%s)", accInfo.account);
	m_ullBeginTime = SP::Module::Comm::RVCGetTickCount();
	errCode = m_hDevHelper->SetAccNo(accInfo);
	m_ullEndTime = SP::Module::Comm::RVCGetTickCount();
	if (errCode != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("[sm]set accout(%s)(%s) failed(%d).", (const char*)ctxSM->Req.account, accInfo.account, errCode);

		SetErrPackage("GetEncryptText::SetAccNo", m_devSN, errCode, MEC_DEVAPI_EPP_SetAccNo);
		if (IsInBusiness())
		{
			ctxSM->Answer(Error_DevCommFailed, AlarmDEC(true));
			DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setLogCode(PinPadService_LogCode_GetInputSM).setAPI("DevAdapter::SetAccNo")
				.setCostTime(m_ullEndTime - m_ullBeginTime).setResultCode("RTA2608")("设置账号失败:%s", SpStrError(errCode));
		}
		else
		{
			ctxSM->Answer(Error_DevCommFailed, AlarmDEC());
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(PinPadService_LogCode_GetInputSM).setAPI("DevAdapter::SetAccNo")
				.setCostTime(m_ullEndTime - m_ullBeginTime).setResultCode("RTA2608")("设置账号失败:%s", SpStrError(errCode));
		}
		
		return Error_DevCommFailed;
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetAccNo").setCostTime(m_ullEndTime - m_ullBeginTime)();

	m_ullBeginTime = SP::Module::Comm::RVCGetTickCount();
	errCode = m_hDevHelper->ActiveWorkingKey(1, 0);
	m_ullEndTime = SP::Module::Comm::RVCGetTickCount();
	
	if (errCode != Error_Succeed)
	{
		SetErrPackage("GetEncryptText::ActiveWorkingKey", m_devSN, errCode, MEC_DEVAPI_EPP_ActiveWorkingKey);
		if (IsInBusiness())
		{
			ctxSM->Answer(Error_DevCommFailed, AlarmDEC(true));
			DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setLogCode(PinPadService_LogCode_GetInputSM).setAPI("DevAdapter::ActiveWorkingKey")
				.setResultCode("RTA260C").setCostTime(m_ullEndTime - m_ullBeginTime)("计算密文时激活工作密钥失败");
		}
		else
		{
			ctxSM->Answer(Error_DevCommFailed, AlarmDEC());
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(PinPadService_LogCode_GetInputSM).setAPI("DevAdapter::ActiveWorkingKey")
				.setResultCode("RTA260C").setCostTime(m_ullEndTime - m_ullBeginTime)("计算密文时激活工作密钥失败");
		}
		return Error_DevCommFailed;
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setAPI("DevAdapter::ActiveWorkingKey").setCostTime(m_ullEndTime - m_ullBeginTime)();
	m_ullBeginTime = SP::Module::Comm::RVCGetTickCount();
	errCode = m_hDevHelper->SetParam(EPP_PT_SET_PIN_ALGORITH, EPP_PIN_ALGO_SM4);
	m_ullEndTime = SP::Module::Comm::RVCGetTickCount();
	
	if (errCode != Error_Succeed)
	{
		SetErrPackage("GetEncryptText::SetParam", m_devSN, errCode, MEC_DEVAPI_EPP_SetParam);
		if (IsInBusiness())
		{
			ctxSM->Answer(Error_DevCommFailed, AlarmDEC(true));
			DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setLogCode(PinPadService_LogCode_GetInputSM).setAPI("DevAdapter::SetParam")
				.setResultCode("RTA260B")("计算密文时设置参数失败:%s", SpStrError(errCode));
		}
		else
		{
			ctxSM->Answer(Error_DevCommFailed, AlarmDEC());
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(PinPadService_LogCode_GetInputSM).setAPI("DevAdapter::SetParam")
				.setResultCode("RTA260B")("计算密文时设置参数失败:%s", SpStrError(errCode));
		}
		return Error_DevCommFailed;
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetParam").setCostTime(m_ullEndTime - m_ullBeginTime)();
	m_ullBeginTime = SP::Module::Comm::RVCGetTickCount();
	errCode = m_hDevHelper->StartPinInput(len);
	m_ullEndTime = SP::Module::Comm::RVCGetTickCount();

	if (errCode != Error_Succeed)
	{
		SetErrPackage("GetEncryptText::StartPinInput", m_devSN, errCode, MEC_DEVAPI_EPP_StartPinInput);
		if (IsInBusiness())
		{
			ctxSM->Answer(Error_DevCommFailed, AlarmDEC(true));
			DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setLogCode(PinPadService_LogCode_GetInputSM).setAPI("DevAdapter::StartPinInput")
				.setResultCode("RTA2609").setCostTime(m_ullEndTime - m_ullBeginTime)("%s", SpStrError(errCode));
		}
		else
		{
			ctxSM->Answer(Error_DevCommFailed, AlarmDEC());
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(PinPadService_LogCode_GetInputSM).setAPI("DevAdapter::StartPinInput")
				.setResultCode("RTA2609").setCostTime(m_ullEndTime - m_ullBeginTime)("%s", SpStrError(errCode));
		}
		return Error_DevCommFailed;
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::StartPinInput").setCostTime(m_ullEndTime - m_ullBeginTime)();
	char* buf = new char[len + 1];
	memset(buf, 0, len + 1);
	int readed = 0;
	DWORD elapsed = 0;
	DWORD dwStart = GetTickCount();
	DWORD dwEnd = GetTickCount();
	bool bCancelInput = false;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("req(pin)len:[%d],timeout:[%d],confirm:[%d],bExit(%d)", len, timeout, confirm, m_bExit);
	while (elapsed < MAX_PINPAD_INPUT_TIMEOUT) {
		if (m_bExit)
			break;
		if (!confirm && readed >= len)
			break;
		if (m_bWaitingMore)
		{
			dwStart = GetTickCount();
			elapsed = 0;
			m_bWaitingMore = false;
			continue;
		}
		if (m_bFrontCancel)
		{
			bCancelInput = true;
			goto Err;
		}
		BYTE btCh;
		Sleep(100);
		errCode = m_hDevHelper->KeyRead(btCh);//循环调用，无需计算耗时
		if (errCode == Error_Succeed) {
			LogEvent(Severity_Middle, LOG_EVT_PINPAD_OP, "PinPad op.", ctxSM->link);
			if (btCh == 0x0d) {
				if (confirm)
				{
					ctxSM->Ans.enter = true;
					if (buf != NULL)
						delete[]buf;
					ctxSM->Answer(Error_Succeed);
					return Error_Succeed;
				}
				else
				{
					dwEnd = GetTickCount();
					elapsed = dwEnd - dwStart;
					continue;
				}
			}
			else if (btCh == 0x08) { // back
				if (confirm)
				{
					dwEnd = GetTickCount();
					elapsed = dwEnd - dwStart;
					continue;
				}
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("clear input");
				pop_char(buf, &readed,true);
			} else if (btCh == 0x1b) { // quit
				if (confirm)
				{
					ctxSM->Ans.enter = true;
					if (buf != NULL)
						delete[]buf;
					ctxSM->Answer(Error_Succeed);
					return Error_Succeed;
				}
				else
				{
					bCancelInput = true;
					goto Err;
				}
			}
			else if (btCh == 0x3f) {
				if (confirm)
				{
					dwEnd = GetTickCount();
					elapsed = dwEnd - dwStart;
					continue;
				}
				push_char(buf, &readed, '*');
			}else{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("else[%d]",btCh);
			}

		}
		else {
		}
		dwEnd = GetTickCount();
		elapsed = dwEnd - dwStart;
	}
	buf[readed] = 0;

Err:
	if (m_bExit)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("exit");
		ctxSM->Answer(Error_Unexpect, PinPad_UserErrorCode_Unexpected_Exit);
		return Error_Unexpect;
	}
	m_bExit = false;
	if (buf != NULL)
		delete[]buf;
	if (bCancelInput)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220602")("input cancel(pin)");
		ctxSM->Answer(Error_Cancel);
		return Error_Cancel;
	}
	if (readed < len) {
		if (elapsed >= MAX_PINPAD_INPUT_TIMEOUT) {
			ctxSM->Answer(Error_TimeOut);
			return Error_TimeOut;
		}
	}
	PinBlock pinBlk;
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("to getpinblk");
	Sleep(500);//nantian
	m_ullBeginTime = SP::Module::Comm::RVCGetTickCount();
	errCode = m_hDevHelper->GetPinBlock(pinBlk);
	m_ullEndTime = SP::Module::Comm::RVCGetTickCount();

	
	LogWarn(Severity_Low, Error_Succeed, PinPad_UserErrorCode_PinPad_GetPinBlock_Call
		, CSimpleStringA::Format("{\"cost\":%d}", m_ullEndTime - m_ullBeginTime));
	if (errCode == Error_Succeed)
	{
		char* tmpPinData = new char[MAX_PIN_BLOCK_SIZE];
		if (tmpPinData == NULL)
			return Error_Resource;
		memset(tmpPinData, 0, MAX_PIN_BLOCK_SIZE);
		memcpy(tmpPinData, pinBlk.data, pinBlk.dwSize);

		ctxSM->Ans.data = tmpPinData;
		//Dbg("pinblk(%s)",tmpPinData);
		if (tmpPinData != NULL)
		{
			delete[]tmpPinData;
			tmpPinData = NULL;
		}
		EnDecryptInfo srcInfo, dstInfo;
		memset(srcInfo.data, 0, MAX_EN_DECRYPT_DATA_SIZE);
		memcpy(srcInfo.data, m_devCheckData, m_devCheckData.GetLength());
		srcInfo.dwSize = m_devCheckData.GetLength();
		memset(dstInfo.data, 0, MAX_EN_DECRYPT_DATA_SIZE);
		//set param
		m_ullBeginTime = SP::Module::Comm::RVCGetTickCount();
		errCode = m_hDevHelper->SetParam(EPP_PT_SET_ENCRYPT_METHOD, EPP_ALGO_METHOD_SM4);
		if (errCode == Error_Succeed)
			errCode = m_hDevHelper->SetParam(EPP_PT_SET_ECB_CBC_MODE, EPP_ALGO_MODE_CBC);
		m_ullEndTime = SP::Module::Comm::RVCGetTickCount();
		
		if (errCode != Error_Succeed)
		{
			SetErrPackage("GetEncryptText::SetParam", m_devSN, errCode, MEC_DEVAPI_EPP_SetParam);
			if (IsInBusiness())
			{
				ctxSM->Answer(Error_Param, AlarmDEC(true));
				DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setLogCode(PinPadService_LogCode_GetInputSM).setAPI("DevAdapter::SetParam")
					.setResultCode("RTA260B").setCostTime(m_ullEndTime - m_ullBeginTime)("计算密文时设置参数失败:%s", SpStrError(errCode));
			}
			else
			{
				ctxSM->Answer(Error_Param, AlarmDEC());
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(PinPadService_LogCode_GetInputSM).setAPI("DevAdapter::SetParam")
					.setResultCode("RTA260B").setCostTime(m_ullEndTime - m_ullBeginTime)("计算密文时设置参数失败:%s", SpStrError(errCode));
			}
			return Error_Param;
		}
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetParam").setCostTime(m_ullEndTime - m_ullBeginTime)();
		m_ullBeginTime = SP::Module::Comm::RVCGetTickCount();
		errCode = m_hDevHelper->EncryptData(srcInfo, dstInfo);
		m_ullEndTime = SP::Module::Comm::RVCGetTickCount();
		
		if (errCode != Error_Succeed)
		{
			SetErrPackage("GetEncryptText::EncryptData", m_devSN, errCode, MEC_DEVAPI_EPP_EncryptData);
			if (IsInBusiness())
			{
				ctxSM->Answer(Error_DevCommFailed, AlarmDEC(true));
				DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setLogCode(PinPadService_LogCode_GetInputSM).setAPI("DevAdapter::EncryptData")
					.setResultCode("RTA260D").setCostTime(m_ullEndTime - m_ullBeginTime)("计算密文时数据加密失败", SpStrError(errCode));
			}
			else
			{
				ctxSM->Answer(Error_DevCommFailed, AlarmDEC());
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(PinPadService_LogCode_GetInputSM).setAPI("DevAdapter::EncryptData")
					.setResultCode("RTA260D").setCostTime(m_ullEndTime - m_ullBeginTime)("计算密文时数据加密失败", SpStrError(errCode));
			}
			return Error_DevCommFailed;
		}
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::EncryptData").setCostTime(m_ullEndTime - m_ullBeginTime)();

		char* tmpCheckCode = new char[MAX_PIN_BLOCK_SIZE];
		if (tmpCheckCode == NULL)
			return Error_Resource;
		memset(tmpCheckCode, 0, MAX_PIN_BLOCK_SIZE);
		//HexBuf2StrBuf(dstInfo.data,&tmpCheckCode,dstInfo.dwSize);
		memcpy(tmpCheckCode, dstInfo.data, dstInfo.dwSize);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("ckckck[%s], m_keySNSM:%s", tmpCheckCode, m_keySNSM.GetData());


		if (strnicmp(tmpCheckCode, "9F1F7BFF6F5511384D9430531E538FD3",
			strlen("9F1F7BFF6F5511384D9430531E538FD3")) == 0)
		{
			SetErrPackage("GetEncryptText::EncryptData(SM)", m_devSN, Error_Unexpect, PinPad_UserErrorCode_KEY_LOST_SM);
			AlarmDEC();
		}
		ctxSM->Ans.checkcode = tmpCheckCode;
		ctxSM->Ans.deviceno = m_deviceNo;
		ctxSM->Ans.keyseq = m_keySNSM;

		CSimpleStringA tmpLastCkCode = m_lastCheckCode;
		if (m_lastCheckCode.IsNullOrEmpty() || strnicmp(tmpCheckCode, m_lastCheckCode, m_lastCheckCode.GetLength()) != 0)
		{
			ErrorCodeEnum eErr;
			CSmartPointer<IConfigInfo> spConfigRun;
			eErr = GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);
			if (eErr == Error_Succeed)
			{
				spConfigRun->WriteConfigValue("Load", "ckckck", tmpCheckCode);
				m_lastCheckCode = tmpCheckCode;
			}
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("write ckckck:%s", tmpCheckCode);
		}
		if (!tmpLastCkCode.IsNullOrEmpty() && strnicmp(tmpCheckCode, tmpLastCkCode, tmpLastCkCode.GetLength()) != 0)
		{
			CSimpleStringA xCkChangeMsg = CSimpleStringA::Format("last ck:%s,current ck:%s,m_keySNSM:%s", tmpLastCkCode.GetData()
				, tmpCheckCode, m_keySNSM.GetData());
			LogWarn(Severity_Low, Error_Unexpect, PinPad_UserErrorCode_PinPad_CheckCode_Changed, xCkChangeMsg.GetData());
		}
	}
	else
	{
		SetErrPackage("GetEncryptText::GetPinBlock", m_devSN, errCode, MEC_DEVAPI_EPP_GetPinBlock);
		if (IsInBusiness())
		{
			ctxSM->Answer(Error_DevCommFailed, AlarmDEC(true));
			DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setLogCode(PinPadService_LogCode_GetInputSM).setAPI("DevAdapter::GetPinBlock")
				.setResultCode("RTA260A").setCostTime(m_ullEndTime - m_ullBeginTime)("计算密文失败:%s", SpStrError(errCode));
		}
		else
		{
			ctxSM->Answer(Error_DevCommFailed, AlarmDEC());
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(PinPadService_LogCode_GetInputSM).setAPI("DevAdapter::GetPinBlock")
				.setResultCode("RTA260A").setCostTime(m_ullEndTime - m_ullBeginTime)("计算密文失败:%s", SpStrError(errCode));
		}
		
		return Error_DevCommFailed;
	}
	DbgWithLink(LOG_LEVEL_INFO, ctxSM->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setLogCode(PinPadService_LogCode_GetInputSM)
		.setAPI("DevAdapter::GetPinBlock").setCostTime(m_ullEndTime - m_ullBeginTime)("获取密文成功");
	m_ullBeginTime = SP::Module::Comm::RVCGetTickCount();
	ErrorCodeEnum errClosePinPad = m_hDevHelper->StopInput();
	if (errClosePinPad != Error_Succeed)
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("close pinpad(%d).", errClosePinPad);
	m_ullEndTime = SP::Module::Comm::RVCGetTickCount();
	Sleep(100);
	ctxSM->Answer(Error_Succeed);
	return Error_Succeed;
}

int CPinPadFSM::GetInput(SpReqAnsContext<PinPadService_GetInputSM_Req, PinPadService_GetInputSM_Ans>::Pointer ctxSM)
{
	DWORD dwCurrThId = GetCurrentThreadId();
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("GetInput thread id:%d",dwCurrThId);
	m_bWaitingMore = false;
	m_bFrontCancel = false;
	m_bExit = false;
	LogEvent(Severity_Middle, LOG_EVT_PINPAD_GREEN_ON, "PinPad light on.");
	if (!m_hDevHelper)
	{
		SetErrPackage("GetInput(SM)", m_devSN, Error_Unexpect, PinPad_UserErrorCode_PinPad_Instance_Is_Null);
		m_inputSMCtx->Answer(Error_Unexpect, AlarmDEC());
		LogEvent(Severity_Middle, LOG_EVT_PINPAD_GREEN_OFF, "PinPad light off.");
		m_bPinInput = false;
		return 1;
	}

	if (!m_inputSMCtx->Req.encrypt)
	{
		SetErrPackage("GetInput(SM)", m_devSN, Error_Unexpect, PinPad_UserErrorCode_NoPlainInput);
		m_inputSMCtx->Answer(Error_Unexpect, AlarmDEC());
		return 1;
	}
	ErrorCodeEnum err;
	err = GetEncryptText(m_inputSMCtx);

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)
		("req acc.len:%d,confirm:%d,len:%d. ans:ck.len:%d", m_inputSMCtx->Req.account.GetLength(), m_inputSMCtx->Req.confirm
			, m_inputSMCtx->Req.length, m_inputSMCtx->Ans.checkcode.IsNullOrEmpty() ? 0 : m_inputSMCtx->Ans.checkcode.GetLength());
	DbgToBeidou(m_inputSMCtx->link, "GetInput")();
	m_bPinInput = false;
	LogEvent(Severity_Middle, LOG_EVT_PINPAD_GREEN_OFF, "PinPad light off.");

	return 0;
}
int CPinPadFSM::LoadKeySM(SpReqAnsContext<PinPadService_LoadKeysSM_Req, PinPadService_LoadKeysSM_Ans>::Pointer ctx)
{
	ErrorCodeEnum eErr;
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	eErr = spEntityFunction->OpenConfig(Config_Run, spConfig);
	if (eErr != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("LoadKeySM::OpenConfig failed,eErr:%d", eErr);
		spConfig = NULL;
		ctx->Answer(eErr, PinPad_UserErrorCode_Open_RunCfgFile_Failed);
		return 0;
	}

	if (!(ctx->Req.smflag == 1 || ctx->Req.smflag == 11))
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("密钥标识不支持，ctx->Req.smflag:%d", ctx->Req.smflag);
		ctx->Answer(Error_Unexpect, PinPad_UserErrorCode_UnknownSMFlag);
		return 0;
	}
	//initialization need load master key
	if (ctx->Req.initializeflag)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("mkey len:%d,ctx->Req.smflag:%d", strlen(ctx->Req.masterkey), ctx->Req.smflag);
		if (ctx->Req.smflag == 11)
		{
#if defined(RVC_OS_WIN)
			MasterKeyParamEx mkParamEx;

			mkParamEx.dwSN = 1;
			mkParamEx.smFlag = ctx->Req.smflag;
			memset(mkParamEx.key, 0, MAX_EN_DECRYPT_DATA_SIZE);

			memcpy(mkParamEx.key, ctx->Req.masterkey, strlen(ctx->Req.masterkey));
			m_ullBeginTime = SP::Module::Comm::RVCGetTickCount();
			eErr = m_hDevHelper->LoadMasterKeyEx(mkParamEx);
			m_ullEndTime = SP::Module::Comm::RVCGetTickCount();
			
			if (eErr != Error_Succeed)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(PinPadService_LogCode_LoadKeysSM).setAPI("DevAdapter::LoadMasterKeyEx")
					.setCostTime(m_ullEndTime - m_ullBeginTime).setResultCode("RTA2604")("加载主密钥失败,eErr:%s", SpStrError(eErr));
				ctx->Ans.result = 0;
				SetErrPackage("LoadKeySM::LoadMasterKeyEx", m_devSN, eErr, MEC_DEVAPI_EPP_LoadMasterKey);
				ctx->Answer(Error_Unexpect, AlarmDEC());
				m_bLoadKey = false;
				return 0;
			}
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::LoadMasterKeyEx").setCostTime(m_ullEndTime - m_ullBeginTime)();
#endif
		}
		else
		{
			MasterKeyParam mkParam;
			mkParam.dwSN = 1;
			mkParam.smFlag = ctx->Req.smflag;
			memset(mkParam.key, 0, MAX_MASTER_KEY_SIZE);
			memcpy(mkParam.key, ctx->Req.masterkey, strlen(ctx->Req.masterkey));
			
			m_ullBeginTime = SP::Module::Comm::RVCGetTickCount();
			eErr = m_hDevHelper->LoadMasterKey(mkParam);
			m_ullEndTime = SP::Module::Comm::RVCGetTickCount();
			
			if (eErr != Error_Succeed)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("PinPadService_LogCode_LoadKeysSM").setAPI("DevAdapter::LoadMasterKey")
					.setResultCode("RTA2604").setCostTime(m_ullEndTime - m_ullBeginTime)("加载主密钥失败,eErr:%s", SpStrError(eErr));
				ctx->Ans.result = 0;
				SetErrPackage("LoadKeySM::LoadMasterKey", m_devSN, eErr, MEC_DEVAPI_EPP_LoadMasterKey);
				ctx->Answer(Error_Unexpect, AlarmDEC());
				m_bLoadKey = false;
				return 0;
			}
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::LoadMasterKey").setCostTime(m_ullEndTime - m_ullBeginTime)();
		}
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(PinPadService_LogCode_LoadKeysSM)("Load master key suc.");
		//after load Master key,clear the load key status
		spConfig->WriteConfigValueInt("Load", "SM", 0);
	}

	WorkKeyParam wkParam1, wkParam2;
	memset(wkParam1.key, 0, MAX_WORKING_KEY_SIZE);
	memset(wkParam2.key, 0, MAX_WORKING_KEY_SIZE);
	wkParam1.dwMasterSN = wkParam2.dwMasterSN = 1;
	wkParam1.dwWorkingSN = 0;
	wkParam2.dwWorkingSN = 1;
	wkParam1.smFlag = ctx->Req.smflag;
	wkParam2.smFlag = ctx->Req.smflag;
	memcpy(wkParam1.key, ctx->Req.workingkey1, strlen(ctx->Req.workingkey1));
	memcpy(wkParam2.key, ctx->Req.workingkey2, strlen(ctx->Req.workingkey2));
	m_ullBeginTime = SP::Module::Comm::RVCGetTickCount();
	eErr = m_hDevHelper->LoadWorkingKey(wkParam1);
	m_ullEndTime = SP::Module::Comm::RVCGetTickCount();
	
	if (eErr != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(PinPadService_LogCode_LoadKeysSM).setAPI("DevAdapter::LoadWorkingKey")
			.setResultCode("RTA2605").setCostTime(m_ullEndTime - m_ullBeginTime)("加载工作密钥1（TPK）失败,eErr:%s", SpStrError(eErr));
		ctx->Ans.result = 1;
		SetErrPackage("LoadKeySM::LoadMasterKey 1", m_devSN, eErr, MEC_DEVAPI_EPP_LoadWorkingKey);
		ctx->Answer(Error_Unexpect, AlarmDEC());
		m_bLoadKey = false;
		return 0;
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::LoadWorkingKey").setCostTime(m_ullEndTime - m_ullBeginTime)("Load working key1 suc.");
	//oilyang@20220308 to calc checkcode if called Initializer
	if (ctx->Req.initializeflag)
	{
		PBYTE pCtMasterKey = new BYTE[48];
		PBYTE pCtPinKey = new BYTE[48];
		BYTE pinKey[16] = { 0 };
		int pinKeyLen = 16;

		int ctMLen = SP::Module::Util::StrBuf2HexBuf(ctx->Req.masterkey.GetData(), &pCtMasterKey);
		int ctPinLen = SP::Module::Util::StrBuf2HexBuf(ctx->Req.workingkey1.GetData(), &pCtPinKey);
		//sm4 decrypt
		sm4_context sm4Contxt;
		sm4_setkey_dec(&sm4Contxt, pCtMasterKey);
		sm4_crypt_ecb(&sm4Contxt, SM4_DECRYPT, ctPinLen, pCtPinKey, (BYTE*)pinKey);

		BYTE ck[16] = { 0 };
		BYTE ckCode[128] = { 0 };
		sm4_setkey_enc(&sm4Contxt, pinKey);
		sm4_crypt_ecb(&sm4Contxt, SM4_ENCRYPT, 8, ck, (BYTE*)ckCode);
		char* strCkCode = new char[256];
		memset(strCkCode, 0, 256);
		SP::Module::Util::HexBuf2StrBuf((PBYTE)ckCode, &strCkCode, 16);
		LogWarn(Severity_Low, Error_Unexpect, PinPad_UserErrorCode_PinPad_CkCode_While_Load_SM, strCkCode);

		BYTE ckMaster[16] = { 0 };
		BYTE ckCodeMaster[128] = { 0 };
		sm4_setkey_enc(&sm4Contxt, pCtMasterKey);
		sm4_crypt_ecb(&sm4Contxt, SM4_ENCRYPT, 8, ckMaster, (BYTE*)ckCodeMaster);
		char* strCkCodeMaster = new char[256];
		memset(strCkCodeMaster, 0, 256);
		SP::Module::Util::HexBuf2StrBuf((PBYTE)ckCodeMaster, &strCkCodeMaster, 16);
		GetEntityBase()->GetFunction()->SetSysVar("ckCode", strCkCodeMaster, true);

		delete[] pCtMasterKey;
		delete[] pCtPinKey;
		delete[] strCkCode;
		delete[] strCkCodeMaster;
	}

	m_ullBeginTime = SP::Module::Comm::RVCGetTickCount();
	eErr = m_hDevHelper->LoadWorkingKey(wkParam2);
	m_ullEndTime = SP::Module::Comm::RVCGetTickCount();
	
	if (eErr != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(PinPadService_LogCode_LoadKeysSM).setAPI("DevAdapter::LoadWorkingKey")
			.setCostTime(m_ullEndTime - m_ullBeginTime).setResultCode("RTA2605")("加载工作密钥2（EDK）失败,eErr:%s", SpStrError(eErr));
		ctx->Ans.result = 2;
		SetErrPackage("LoadKeySM::LoadMasterKey 2", m_devSN, eErr, MEC_DEVAPI_EPP_LoadWorkingKey);
		ctx->Answer(Error_Unexpect, AlarmDEC());
		m_bLoadKey = false;
		return 0;
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::LoadWorkingKey").setCostTime(m_ullEndTime - m_ullBeginTime)("Load working key2 suc.");
	if (spConfig != NULL)
	{

		eErr = spConfig->WriteConfigValueInt("Load", "SM", 1);
		if (eErr != Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM).setResultCode("RTA2613")("写密钥加载标识失败:%s", SpStrError(eErr));
			LogWarn(Severity_Middle, Error_Unexpect, PinPad_UserErrorCode_Write_RunCfgFile_Failed, CSimpleStringA::Format("写密钥加载标识失败:%s", SpStrError(eErr)));
		}

		if (!ctx->Req.reserved3.IsNullOrEmpty())
		{
			if ((eErr = spConfig->WriteConfigValue("Load", "SN_SM", ctx->Req.reserved3)) != Error_Succeed)
			{
				DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM).setResultCode("RTA2613")("写密钥序号失败:%s", SpStrError(eErr));
				LogWarn(Severity_Middle, Error_Unexpect, PinPad_UserErrorCode_Write_RunCfgFile_Failed, CSimpleStringA::Format("写密钥序号失败:%s", SpStrError(eErr)));
			}
			m_keySNSM = ctx->Req.reserved3;
			LogWarn(Severity_Low, Error_Unexpect, PinPad_UserErrorCode_PinPad_LoadKey_SMSN, m_keySNSM.GetData());
		}
		else
		{
			spConfig->WriteConfigValue("Load", "SN_SM", "");
			m_keySNSM = "";
			LogWarn(Severity_Low, Error_Unexpect, PinPad_UserErrorCode_PinPad_LoadKey_Clear_SMSN, "clear sm key sn");
		}

	}
	m_bLoadKey = false;
	m_bSMLoaded = true;

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(PinPadService_LogCode_LoadKeysSM)("加载密钥成功");
	ctx->Answer(Error_Succeed);
	return 0;
}
int CPinPadFSM::EncryptSM(SpReqAnsContext<PinPadService_EncryptDataSM_Req, PinPadService_EncryptDataSM_Ans>::Pointer ctx)
{

	if (!(ctx->Req.smflag == 1 || ctx->Req.smflag == 11))
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("密钥标识不支持，ctx->Req.smflag:%d", ctx->Req.smflag);
		ctx->Answer(Error_Unexpect, PinPad_UserErrorCode_UnknownSMFlag);
		return 0;
	}
	//set param
	m_ullBeginTime = SP::Module::Comm::RVCGetTickCount();
	if (m_hDevHelper->SetParam(EPP_PT_SET_ENCRYPT_METHOD, EPP_ALGO_METHOD_SM4) != Error_Succeed
		|| m_hDevHelper->SetParam(EPP_PT_SET_ECB_CBC_MODE, EPP_ALGO_MODE_CBC) != Error_Succeed)
	{
		SetErrPackage("EncryptSM::SetParam", m_devSN, Error_Unexpect, MEC_DEVAPI_EPP_SetParam);
		ctx->Answer(Error_Unexpect, AlarmDEC(IsInBusiness()));
		m_bEncrypt = false;
		return 0;
	}
	m_ullEndTime = SP::Module::Comm::RVCGetTickCount();

	m_ullBeginTime = SP::Module::Comm::RVCGetTickCount();
	ErrorCodeEnum eErr = m_hDevHelper->ActiveWorkingKey(1, 1);
	m_ullEndTime = SP::Module::Comm::RVCGetTickCount();
	DbgToBeidou(ctx->link, "ActiveWorkingKey")();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(PinPadService_LogCode_EncryptDataSM).setCostTime(m_ullEndTime - m_ullBeginTime)("%s", SpStrError(eErr));
	if (eErr != Error_Succeed)
	{
		SetErrPackage("EncryptSM::ActiveWorkingKey", m_devSN, eErr, MEC_DEVAPI_EPP_ActiveWorkingKey);
		ctx->Answer(Error_Unexpect, AlarmDEC(IsInBusiness()));
		m_bEncrypt = false;
		return 0;
	}
	EnDecryptInfo srcData, dstData;
	ZeroMemory(srcData.data, MAX_EN_DECRYPT_DATA_SIZE);
	ZeroMemory(dstData.data, MAX_EN_DECRYPT_DATA_SIZE);
	srcData.dwSize = strlen(ctx->Req.data);
	memcpy(srcData.data, ctx->Req.data, srcData.dwSize);

	m_ullBeginTime = SP::Module::Comm::RVCGetTickCount();
	eErr = m_hDevHelper->EncryptData(srcData, dstData);
	m_ullEndTime = SP::Module::Comm::RVCGetTickCount();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setAPI("DevAdapter::EncryptData").setCostTime(m_ullEndTime - m_ullBeginTime)("%s", SpStrError(eErr));
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(PinPadService_LogCode_EncryptDataSM)("srcData.dwSize:%d,dstData.dwSize", srcData.dwSize, dstData.dwSize);
	DbgToBeidou(ctx->link, "EncryptData")();
	if (eErr != Error_Succeed)
	{
		SetErrPackage("EncryptSM::EncryptData", m_devSN, eErr, MEC_DEVAPI_EPP_EncryptData);
		ctx->Answer(Error_Unexpect, AlarmDEC(IsInBusiness()));
		m_bEncrypt = false;
		return 0;
	}
	
	ctx->Ans.ciphertext = (char*)dstData.data;
	m_bEncrypt = false;
	ctx->Answer(Error_Succeed);
	return 0;
}
ErrorCodeEnum CPinPadFSM::GetCheckCode(SpReqAnsContext<PinPadService_GetCheckCode_Req, PinPadService_GetCheckCode_Ans>::Pointer ctx)
{
	ErrorCodeEnum eErr = Error_Unexpect;
	bool bGetOK = true;
	ctx->Ans.checkcode.Init(ctx->Req.mSN.GetCount());
	ctx->Ans.index.Init(ctx->Req.mSN.GetCount());
	for (int i = 0; i < ctx->Req.mSN.GetCount(); i++)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("mSN:%d,wSN:%d,origData[%s]", ctx->Req.mSN[i], ctx->Req.wSN[i], m_devCheckData.GetData());
		//set param
		m_ullBeginTime = SP::Module::Comm::RVCGetTickCount();
		if (ctx->Req.mSN[i] == 1)
			eErr = m_hDevHelper->SetParam(EPP_PT_SET_ENCRYPT_METHOD, EPP_ALGO_METHOD_SM4);
		else
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(PinPadService_LogCode_GetCheckCode).setResultCode("RTA260B")("mSN:%d", ctx->Req.mSN[i]);
			ctx->Ans.checkcode[i] = "";
			ctx->Ans.index[i] = "";
			continue;
		}
		if (eErr == Error_Succeed)
			eErr = m_hDevHelper->SetParam(EPP_PT_SET_ECB_CBC_MODE, EPP_ALGO_MODE_CBC);
		else
		{
			SetErrPackage("GetCheckCode::SetParam", m_devSN, eErr, MEC_DEVAPI_EPP_SetParam);
			AlarmDEC();
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(PinPadService_LogCode_GetCheckCode).setAPI("DevAdapter::SetParam")
				.setResultCode("RTA260B")("计算校验码时设置参数失败");
			return Error_DevCommFailed;
		}
		m_ullEndTime = SP::Module::Comm::RVCGetTickCount();

		m_ullBeginTime = SP::Module::Comm::RVCGetTickCount();
		eErr = m_hDevHelper->ActiveWorkingKey(ctx->Req.mSN[i], ctx->Req.wSN[i]);
		m_ullEndTime = SP::Module::Comm::RVCGetTickCount();
		if (eErr != Error_Succeed)
		{
			SetErrPackage("GetCheckCode::ActiveWorkingKey", m_devSN, eErr, MEC_DEVAPI_EPP_ActiveWorkingKey);
			AlarmDEC();
			ctx->Ans.checkcode[i] = "";
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setLogCode(PinPadService_LogCode_GetCheckCode).setResultCode("RTA260C")("计算校验码时激活工作密钥失败");
			return Error_DevCommFailed;
		}
		else
		{
			EnDecryptInfo srcInfo, dstInfo;
			memset(srcInfo.data, 0, MAX_EN_DECRYPT_DATA_SIZE);
			memcpy(srcInfo.data, m_devCheckData, m_devCheckData.GetLength());
			srcInfo.dwSize = m_devCheckData.GetLength();
			memset(dstInfo.data, 0, MAX_EN_DECRYPT_DATA_SIZE);
			m_ullBeginTime = SP::Module::Comm::RVCGetTickCount();
			eErr = m_hDevHelper->EncryptData(srcInfo, dstInfo);
			m_ullEndTime = SP::Module::Comm::RVCGetTickCount();
			if (eErr != Error_Succeed)
			{
				SetErrPackage("GetCheckCode::EncryptData", m_devSN, eErr, MEC_DEVAPI_EPP_EncryptData);
				AlarmDEC();
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setLogCode(PinPadService_LogCode_GetCheckCode).setResultCode("RTA260D")("计算校验码时数据加密失败");
				return Error_DevCommFailed;
			}
			ctx->Ans.checkcode[i] = (const char*)dstInfo.data;
			if (ctx->Req.wSN[i] == 0)
				ctx->Ans.index[i] = m_keySNSM;
		}
		DbgWithLink(LOG_LEVEL_INFO, ctx->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setLogCode("QLR040220610")("计算校验码成功");
	}
	
	ctx->Answer(Error_Succeed);
	return Error_Succeed;
}
bool CPinPadFSM::GetDevInfo(DevCategoryInfo &devInfo)
{
	if (!m_bOpened)
	{
		devInfo.eState = m_eDevState;
		return false;
	}
	DevCategoryInfo info;
	ZeroMemory(info.szModel, MAX_DEV_MODEL_LEN);
	ZeroMemory(info.szType, MAX_DEV_TYPE_LEN);
	ZeroMemory(info.szVendor, MAX_DEV_VENDOR_LEN);
	m_ullBeginTime = SP::Module::Comm::RVCGetTickCount();
	ErrorCodeEnum eErrDev = m_hDevHelper->GetDevCategory(info);
	m_ullEndTime = SP::Module::Comm::RVCGetTickCount();
	if (eErrDev == Error_Succeed)
	{
		m_szModel = info.szModel;
		m_szType = info.szType;
		m_szVendor = info.szVendor;
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevCategory").setCostTime(m_ullEndTime - m_ullBeginTime)
			("model,%d,%s;type,%d,%s;vendor,%d,%s", strlen(devInfo.szModel), m_szModel.GetData(), strlen(devInfo.szType), m_szType.GetData(), strlen(devInfo.szVendor), m_szVendor.GetData());
	}
	else
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::GetDevCategory").setResultCode("RTA2606").setCostTime(m_ullEndTime - m_ullBeginTime)("%s", SpStrError(eErrDev));
		SetErrPackage("GetDevInfo::GetDevCategory", m_devSN, eErrDev, MEC_DEVAPI_EPP_GetDevCategory);
		AlarmDEC();
		m_szModel = "";
		m_szType = "";
		m_szVendor = "";
		m_eDevState = DEVICE_STATUS_NOT_READY;
	}
	ZeroMemory(devInfo.szModel,MAX_DEV_MODEL_LEN);//CM=V2.0#PM=V1.0#MID=75500001#PID=12345678#FWID=V1234567#Vendor=nantian
	ZeroMemory(devInfo.szType,MAX_DEV_TYPE_LEN);
	ZeroMemory(devInfo.szVendor,MAX_DEV_VENDOR_LEN);
	CSimpleStringA tmpModel("");
	if (m_szModel.GetLength() > 1)
	{
		CSimpleStringA tmpAddStr("");
		tmpAddStr = tmpAddStr + "Vendor=" + m_szVendor;
		if (m_szModel[m_szModel.GetLength() - 1] == '#')
			tmpModel = m_szModel + tmpAddStr;
		else
			tmpModel = m_szModel + "#" + tmpAddStr;
		strncpy(devInfo.szModel, (const char*)tmpModel, tmpModel.GetLength());
	}
	if (m_szType.GetLength() > 1)
		strncpy(devInfo.szType, (const char*)m_szType, m_szType.GetLength());
	if (m_szVendor.GetLength() > 1)
		strncpy(devInfo.szVendor, (const char*)m_szVendor, m_szVendor.GetLength());
	devInfo.eState = m_eDevState;
	return true;
}
void CPinPadFSM::SetInWhatPage(int iPageType)
{
	m_iInWhatPage = iPageType;
	return;//oilyang@20200319 去掉任意情况下可输入
}
void CPinPadFSM::SelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext)
{
	if (m_eDevState == DEVICE_STATUS_NORMAL)
		pTransactionContext->SendAnswer(Error_Succeed);
	else if (m_eDevState == DEVICE_STATUS_NOT_READY)
		pTransactionContext->SendAnswer(Error_NotInit);
	else
		pTransactionContext->SendAnswer(Error_InvalidState);
}

int CPinPadFSM::ProcFWBReConn()
{
	if (m_hDevHelper != nullptr)
	{
		if (GetDevInitFlag())
		{
			m_bOpened = false;
			m_hDevHelper->StopInput();
		}
		m_hDevHelper.TearDown();
	}
	return 0;
}