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"
#include <fstream>
#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;
const int CurrentPasswordLen = 6;//according to guodan, we only use 6

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();
	m_bOpening = true;
	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();
		ErrorCodeEnum errClosePinPad = m_hDevHelper->StopInput();
		m_ullEndTime = SP::Module::Comm::RVCGetTickCount();
		if (errClosePinPad != Error_Succeed)
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::StopInput").setResultCode("RTA2614").setCostTime(m_ullEndTime - m_ullBeginTime)("OnExit:close pinpad(%d).", SpStrError(errClosePinPad));
		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;
	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_GETINPUT_JS:
	{
		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();
}
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_GETINPUT_JS_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();
}
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;
	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;
}
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[%s]", m_adapterInfo.adapterFilePath.IsNullOrEmpty() ? "null or empty" : m_adapterInfo.adapterFilePath.GetData());

	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)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DevOpen").setCostTime(m_ullEndTime - m_ullBeginTime)();
			ToLogRootINIInfo();
			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)
					SetErrorAndLog(errCode3, MEC_DEVAPI_EPP_SetParam, "DevAdapter::SetParam", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime);
				if (errCode4 != Error_Succeed)
					SetErrorAndLog(errCode4, MEC_DEVAPI_EPP_SetParam, "DevAdapter::SetParam", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime);
				return 1;
			}
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetParam").setCostTime(m_ullEndTime - m_ullBeginTime)();
			break;
		}
		else
		{
			SetErrorAndLog(eErr, MEC_DEVAPI_EPP_DevOpen, "DevAdapter::DevOpen", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime);
			initTries++;
			Sleep(1200);
			continue;
		}
	} while (initTries < PINPAD_INIT_TRIES);
	m_bOpening = false;
	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_ullEndTime = 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
		SetErrorAndLog(eErrDev, MEC_DEVAPI_EPP_GetDevCategory, "DevAdapter::GetDevCategory", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime);

	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.");

	//oiltmp@20240521 add for redundancy to check
	CSmartPointer<IConfigInfo> spConfigCen;
	int iTmp = 0;
	GetEntityBase()->GetFunction()->OpenConfig(Config_CenterSetting, spConfigCen);
	if (spConfigCen->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "UseBackupSN", iTmp) == Error_Succeed)
	{
		if (iTmp == 1)
			m_bUseBackupSN = true;
		else if (iTmp > 1)//to except default value 0
			m_bUseBackupSN = false;
	}
	CSimpleStringA csRunInfo, csSNBakFile;
	if ((eErr = GetEntityBase()->GetFunction()->GetPath("RunInfo", csRunInfo)) == Error_Succeed)
	{
		csSNBakFile = csRunInfo + SPLIT_SLASH_STR + "snbak.dat";
		ifstream infile(csSNBakFile, std::ofstream::binary);
		char* buffer = new char[16];
		ZeroMemory(buffer, 16);
		if (infile.is_open())
			infile.read(buffer, 16);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("bak.sn:%s", buffer);
		if (strlen(buffer) > 0 && m_keySNSM.Compare(buffer) != 0)
		{
			LogWarn(Severity_High, Error_Unexpect, PinPad_UserErrorCode_PinPad_SN_NOTMATCH, CSimpleStringA::Format("m_keySN:%s,snbak:%s", m_keySNSM.GetData(), buffer));
			if (m_bUseBackupSN)
			{
				m_keySNSM = buffer;
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("because save failed, use backup sn:%s", m_keySNSM);
			}
		}
		delete[] buffer;
		infile.close();
	}

	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 if (pFsm->IsInGetInputJS())
		{
			SpReqAnsContext<PinPadService_GetInputJS_Req, PinPadService_GetInputJS_Ans>::Pointer ctxJS;
			bool bRet = pFsm->GetJSCtx(ctxJS);
			if (!bRet)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("get ctx(JS) failed.doing nothing");
				continue;
			}
			ret = pFsm->GetInputJS(ctxJS);
			evt = new FSMEvent(USER_EVT_GETINPUT_JS_FINISHED);
		}
		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 (IsInBusiness())
		{
			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);

		SetErrorAndLog(errCode, MEC_DEVAPI_EPP_SetAccNo, "DevAdapter::SetAccNo", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime, PinPadService_LogCode_GetInputSM);
		ctxSM->Answer(Error_DevCommFailed, GetAlarmDEC());
		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)
	{
		SetErrorAndLog(errCode, MEC_DEVAPI_EPP_ActiveWorkingKey, "DevAdapter::ActiveWorkingKey", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime, PinPadService_LogCode_GetInputSM);
		ctxSM->Answer(Error_DevCommFailed, GetAlarmDEC());
		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)
	{
		SetErrorAndLog(errCode, MEC_DEVAPI_EPP_SetParam, "DevAdapter::SetParam", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime, PinPadService_LogCode_GetInputSM);
		ctxSM->Answer(Error_DevCommFailed, GetAlarmDEC());
		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)
	{
		SetErrorAndLog(errCode, MEC_DEVAPI_EPP_StartPinInput, "DevAdapter::StartPinInput", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime, PinPadService_LogCode_GetInputSM);
		ctxSM->Answer(Error_DevCommFailed, GetAlarmDEC());
		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);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("PinPad op: %d", readed);
			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)
		{
			SetErrorAndLog(errCode, MEC_DEVAPI_EPP_SetParam, "DevAdapter::SetParam", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime, PinPadService_LogCode_GetInputSM);
			ctxSM->Answer(Error_Param, GetAlarmDEC());
			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)
		{
			SetErrorAndLog(errCode, MEC_DEVAPI_EPP_EncryptData, "DevAdapter::EncryptData", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime, PinPadService_LogCode_GetInputSM);
			ctxSM->Answer(Error_DevCommFailed, GetAlarmDEC());
			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)
			SetErrorAndLog(Error_Unexpect, PinPad_UserErrorCode_KEY_LOST_SM, "", __FUNCTION__);
		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
	{
		SetErrorAndLog(errCode, MEC_DEVAPI_EPP_GetPinBlock, "DevAdapter::GetPinBlock", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime, PinPadService_LogCode_GetInputSM);
		ctxSM->Answer(Error_DevCommFailed, GetAlarmDEC());
		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)("获取密文成功");
	//oilyang@20240410 move to out space,after stopinput & turn off the light
	//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)
	{
		SetErrorAndLog(Error_Unexpect, PinPad_UserErrorCode_PinPad_Instance_Is_Null, "", __FUNCTION__, false, 0, PinPadService_LogCode_GetInputSM);
		m_inputSMCtx->Answer(Error_Unexpect, GetAlarmDEC());
		LogEvent(Severity_Middle, LOG_EVT_PINPAD_GREEN_OFF, "PinPad light off.");
		m_bPinInput = false;
		return 1;
	}

	if (!m_inputSMCtx->Req.encrypt)
	{
		SetErrorAndLog(Error_Unexpect, PinPad_UserErrorCode_NoPlainInput, "", __FUNCTION__, false, 0, PinPadService_LogCode_GetInputSM);
		m_inputSMCtx->Answer(Error_Unexpect, GetAlarmDEC());
		return 1;
	}
	ULLINT ullGetInputBegin = SP::Module::Comm::RVCGetTickCount();
	ErrorCodeEnum eErrCode = GetEncryptText(m_inputSMCtx);

	m_ullBeginTime = SP::Module::Comm::RVCGetTickCount();
	ErrorCodeEnum errClosePinPad = m_hDevHelper->StopInput();
	m_ullEndTime = SP::Module::Comm::RVCGetTickCount();
	if (errClosePinPad != Error_Succeed)
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::StopInput").setResultCode("RTA2614").setCostTime(m_ullEndTime - m_ullBeginTime)("close pinpad(%s).", SpStrError(errClosePinPad));
	else
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::StopInput").setCostTime(m_ullEndTime - m_ullBeginTime)("StopInput cost(%d)ms", m_ullEndTime - m_ullBeginTime);

	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.");

	if (eErrCode == Error_Succeed && !m_inputSMCtx->Req.confirm)
	{
		ULLINT ullGetInputEnd = SP::Module::Comm::RVCGetTickCount();
		LogWarn(Severity_Low, Error_Unexpect, PinPad_UserErrorCode_GetInput_TimeCost, CSimpleStringA::Format("%d", (ullGetInputEnd - ullGetInputBegin) / 1000));
		m_inputSMCtx->Answer(Error_Succeed);
	}

	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)
			{
				SetErrorAndLog(eErr, MEC_DEVAPI_EPP_LoadMasterKey, "DevAdapter::LoadMasterKey", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime);
				ctx->Ans.result = 0;
				ctx->Answer(Error_Unexpect, GetAlarmDEC());
				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)
			{
				SetErrorAndLog(eErr, MEC_DEVAPI_EPP_LoadMasterKey, "DevAdapter::LoadMasterKey", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime);
				ctx->Ans.result = 0;
				ctx->Answer(Error_Unexpect, GetAlarmDEC());
				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)
	{
		SetErrorAndLog(eErr, MEC_DEVAPI_EPP_LoadWorkingKey, "DevAdapter::LoadWorkingKey", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime);
		ctx->Ans.result = 1;
		ctx->Answer(Error_Unexpect, GetAlarmDEC());
		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)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("the new check code:%s", ctx->Req.reserved4.GetData());
		LogWarn(Severity_Low, Error_Unexpect, PinPad_UserErrorCode_PinPad_CkCode_While_Load_SM, ctx->Req.reserved4);
	}

	m_ullBeginTime = SP::Module::Comm::RVCGetTickCount();
	eErr = m_hDevHelper->LoadWorkingKey(wkParam2);
	m_ullEndTime = SP::Module::Comm::RVCGetTickCount();
	
	if (eErr != Error_Succeed)
	{
		SetErrorAndLog(eErr, MEC_DEVAPI_EPP_LoadWorkingKey, "DevAdapter::LoadWorkingKey", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime);
		ctx->Ans.result = 2;
		ctx->Answer(Error_Unexpect, GetAlarmDEC());
		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
				, CSimpleStringA::Format("{\"subject\":\"key_sn\",\"value\":\"%s\"}", m_keySNSM.GetData()));
			//oiltmp@20240521 add for redundancy to check
			CSimpleStringA csRunInfo,csSNBakFile;
			if ((eErr = GetEntityBase()->GetFunction()->GetPath("RunInfo", csRunInfo)) == Error_Succeed)
			{
				csSNBakFile = csRunInfo + SPLIT_SLASH_STR + "snbak.dat";
				ofstream outfile(csSNBakFile, std::ofstream::binary|ios::trunc);

				int size = m_keySNSM.GetLength();
				char* buffer = new char[size + 1];
				ZeroMemory(buffer, size + 1);
				memcpy(buffer, m_keySNSM.GetData(), size);
				outfile.write(buffer, size);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("write sn bak:%s", buffer);
				delete[] buffer;
				outfile.close();
			}
		}
		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)
	{
		SetErrorAndLog(Error_Unexpect, MEC_DEVAPI_EPP_SetParam, "DevAdapter::SetParam", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime);
		ctx->Answer(Error_Unexpect, GetAlarmDEC());
		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)
	{
		SetErrorAndLog(eErr, MEC_DEVAPI_EPP_ActiveWorkingKey, "DevAdapter::ActiveWorkingKey", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime);
		ctx->Answer(Error_Unexpect, GetAlarmDEC());
		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)
	{
		SetErrorAndLog(eErr, MEC_DEVAPI_EPP_EncryptData, "DevAdapter::EncryptData", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime);
		ctx->Answer(Error_Unexpect, GetAlarmDEC());
		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
		{
			SetErrorAndLog(eErr, MEC_DEVAPI_EPP_SetParam, "DevAdapter::SetParam", __FUNCTION__, false, m_ullEndTime - m_ullBeginTime, PinPadService_LogCode_GetCheckCode);
			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)
		{
			SetErrorAndLog(eErr, MEC_DEVAPI_EPP_ActiveWorkingKey, "DevAdapter::ActiveWorkingKey", __FUNCTION__, false, m_ullEndTime - m_ullBeginTime, PinPadService_LogCode_GetCheckCode);
			ctx->Ans.checkcode[i] = "";
			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)
			{
				SetErrorAndLog(eErr, MEC_DEVAPI_EPP_EncryptData, "DevAdapter::EncryptData", __FUNCTION__, false, m_ullEndTime - m_ullBeginTime, PinPadService_LogCode_GetCheckCode);
				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;
}
ErrorCodeEnum CPinPadFSM::GetDevInfo(DevCategoryInfo &devInfo)
{
	if (!m_bOpened)
		return Error_DevNotAvailable;
	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());
		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)
			strncpy(devInfo.szModel, m_szModel.GetData(), m_szModel.GetLength());
		if (m_szType.GetLength() > 1)
			strncpy(devInfo.szType, m_szType.GetData(), m_szType.GetLength());
		if (m_szVendor.GetLength() > 1)
			strncpy(devInfo.szVendor, m_szVendor.GetData(), m_szVendor.GetLength());
	}
	else
	{
		SetErrorAndLog(eErrDev, MEC_DEVAPI_EPP_GetDevCategory, "DevAdapter::GetDevCategory", __FUNCTION__, false, m_ullEndTime - m_ullBeginTime);
		m_szModel = "";
		m_szType = "";
		m_szVendor = "";
		m_eDevState = DEVICE_STATUS_NOT_READY;
	}

	return eErrDev;
}
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_DevNotAvailable);
	else
		pTransactionContext->SendAnswer(Error_InvalidState);
}
ErrorCodeEnum CPinPadFSM::GetEncryptTextJS(SpReqAnsContext<PinPadService_GetInputJS_Req, PinPadService_GetInputJS_Ans>::Pointer ctxJS)
{
	LOG_FUNCTION();
	ErrorCodeEnum errCode;
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	int timeout = ctxJS->Req.timeout;

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

	if (Get12Account(const_cast<char*>(ctxJS->Req.account.GetData())))
		memcpy(accInfo.account, m_szAccount + 4, 12);
	else
	{
		errMsg = CSimpleStringA::Format("Get12Account err(%s).", (const char*)ctxJS->Req.account);
		if (IsInBusiness())
		{
			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());
		ctxJS->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*)ctxJS->Req.account, accInfo.account, errCode);

		SetErrorAndLog(errCode, MEC_DEVAPI_EPP_SetAccNo, "DevAdapter::SetAccNo", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime, PinPadService_LogCode_GetInputSM);
		ctxJS->Answer(Error_DevCommFailed, GetAlarmDEC());
		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)
	{
		SetErrorAndLog(errCode, MEC_DEVAPI_EPP_ActiveWorkingKey, "DevAdapter::ActiveWorkingKey", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime, PinPadService_LogCode_GetInputSM);
		ctxJS->Answer(Error_DevCommFailed, GetAlarmDEC());
		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)
	{
		SetErrorAndLog(errCode, MEC_DEVAPI_EPP_SetParam, "DevAdapter::SetParam", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime, PinPadService_LogCode_GetInputSM);
		ctxJS->Answer(Error_DevCommFailed, GetAlarmDEC());
		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(CurrentPasswordLen);
	m_ullEndTime = SP::Module::Comm::RVCGetTickCount();

	if (errCode != Error_Succeed)
	{
		SetErrorAndLog(errCode, MEC_DEVAPI_EPP_StartPinInput, "DevAdapter::StartPinInput", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime, PinPadService_LogCode_GetInputSM);
		ctxJS->Answer(Error_DevCommFailed, GetAlarmDEC());
		return Error_DevCommFailed;
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::StartPinInput").setCostTime(m_ullEndTime - m_ullBeginTime)();
	char* buf = new char[CurrentPasswordLen + 1];
	memset(buf, 0, CurrentPasswordLen + 1);
	int readed = 0;
	DWORD elapsed = 0;
	DWORD dwStart = SP::Module::Comm::RVCGetTickCount();
	DWORD dwEnd = SP::Module::Comm::RVCGetTickCount();
	bool bCancelInput = false;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("req(pin),timeout:[%d]", timeout);
	while (elapsed < MAX_PINPAD_INPUT_TIMEOUT) {
		if (readed >= CurrentPasswordLen)
			break;
		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.", ctxJS->link);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("PinPad op: %d", readed);
			if (btCh == 0x0d) {
				dwEnd = SP::Module::Comm::RVCGetTickCount();
				elapsed = dwEnd - dwStart;
				continue;
			}
			else if (btCh == 0x08) { // back
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("clear input");
				pop_char(buf, &readed, true);
			}
			else if (btCh == 0x1b) { // quit
				bCancelInput = true;
				goto Err;
			}
			else if (btCh == 0x3f) {
				push_char(buf, &readed, '*');
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("else[%d]", btCh);
			}

		}
		else {
		}
		dwEnd = SP::Module::Comm::RVCGetTickCount();
		elapsed = dwEnd - dwStart;
	}
	buf[readed] = 0;

Err:

	if (buf != NULL)
		delete[]buf;
	if (bCancelInput)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220602")("input cancel(pin)");
		ctxJS->Answer(Error_Cancel);
		return Error_Cancel;
	}
	if (readed < CurrentPasswordLen) {
		if (elapsed >= MAX_PINPAD_INPUT_TIMEOUT) {
			ctxJS->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);

		ctxJS->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)
		{
			SetErrorAndLog(errCode, MEC_DEVAPI_EPP_SetParam, "DevAdapter::SetParam", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime, PinPadService_LogCode_GetInputSM);
			ctxJS->Answer(Error_Param, GetAlarmDEC());
			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)
		{
			SetErrorAndLog(errCode, MEC_DEVAPI_EPP_EncryptData, "DevAdapter::EncryptData", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime, PinPadService_LogCode_GetInputSM);
			ctxJS->Answer(Error_DevCommFailed, GetAlarmDEC());
			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)
			SetErrorAndLog(Error_Unexpect, PinPad_UserErrorCode_KEY_LOST_SM, "", __FUNCTION__);
		ctxJS->Ans.checkcode = tmpCheckCode;
		ctxJS->Ans.deviceno = m_deviceNo;
		ctxJS->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
	{
		SetErrorAndLog(errCode, MEC_DEVAPI_EPP_GetPinBlock, "DevAdapter::GetPinBlock", __FUNCTION__, IsInBusiness(), m_ullEndTime - m_ullBeginTime, PinPadService_LogCode_GetInputSM);
		ctxJS->Answer(Error_DevCommFailed, GetAlarmDEC());
		return Error_DevCommFailed;
	}
	DbgWithLink(LOG_LEVEL_INFO, ctxJS->link.checkEmpty() ? LOG_TYPE_SYSTEM : LOG_TYPE_USER).setLogCode(PinPadService_LogCode_GetInputSM)
		.setAPI("DevAdapter::GetPinBlock").setCostTime(m_ullEndTime - m_ullBeginTime)("获取密文成功");
	//oilyang@20240410 move to out space,after stopinput & turn off the light
	//Sleep(100);
	//ctxSM->Answer(Error_Succeed);
	return Error_Succeed;
}
int CPinPadFSM::GetInputJS(SpReqAnsContext<PinPadService_GetInputJS_Req, PinPadService_GetInputJS_Ans>::Pointer ctxJS)
{
	DWORD dwCurrThId = GetCurrentThreadId();
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("GetInput thread id:%d", dwCurrThId);
	m_bFrontCancel = false;
	LogEvent(Severity_Middle, LOG_EVT_PINPAD_GREEN_ON, "PinPad light on.");
	if (!m_hDevHelper)
	{
		SetErrorAndLog(Error_Unexpect, PinPad_UserErrorCode_PinPad_Instance_Is_Null, "", __FUNCTION__, false, 0, PinPadService_LogCode_GetInputSM);
		m_inputJSCtx->Answer(Error_Unexpect, GetAlarmDEC());
		LogEvent(Severity_Middle, LOG_EVT_PINPAD_GREEN_OFF, "PinPad light off.");
		m_bPinInputJS = false;
		return 1;
	}
	ULLINT ullGetInputBegin = SP::Module::Comm::RVCGetTickCount();
	ErrorCodeEnum eErrCode = GetEncryptTextJS(m_inputJSCtx);

	m_ullBeginTime = SP::Module::Comm::RVCGetTickCount();
	ErrorCodeEnum errClosePinPad = m_hDevHelper->StopInput();
	m_ullEndTime = SP::Module::Comm::RVCGetTickCount();
	if (errClosePinPad != Error_Succeed)
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI("DevAdapter::StopInput").setResultCode("RTA2614").setCostTime(m_ullEndTime - m_ullBeginTime)("close pinpad(%s).", SpStrError(errClosePinPad));
	else
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::StopInput").setCostTime(m_ullEndTime - m_ullBeginTime)("StopInput cost(%d)ms", m_ullEndTime - m_ullBeginTime);

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

	if (eErrCode == Error_Succeed)
	{
		ULLINT ullGetInputEnd = SP::Module::Comm::RVCGetTickCount();
		LogWarn(Severity_Low, Error_Unexpect, PinPad_UserErrorCode_GetInput_TimeCost, CSimpleStringA::Format("%d", (ullGetInputEnd - ullGetInputBegin) / 1000));
		m_inputJSCtx->Answer(Error_Succeed);
	}

	return 0;
}