myvtm/Module/mod_cardswiper/CardSwiperFSM.cpp

#include "stdafx.h"
#include "SpBase.h"
#include "SpHelper.h"
#include "RVCComm.h"
#include "CardSwiperFSM.h"
#include "GetDevInfoHelper.h"
#include "EventCode.h"
#include "ModuleMix.h"
#include "publicFunExport.h"
#pragma comment(lib, "libpublicFun.lib")
#include "mod_cardswiper.h"
#include "CardSwiper_UserErrorCode.h"

#include <algorithm>
#define _ATL_NO_AUTOMATIC_NAMESPACE
#include <atltime.h>

#include <winsock2.h>
#include <Ws2bth.h>
#include <BluetoothAPIs.h>
#pragma comment (lib, "Ws2_32.lib")
#pragma comment (lib, "Bthprops.lib")
char tmpxx[1024];
char testIC[1024];
int jxx;
char x;

CRITICAL_SECTION g_csCntStatus; //For DevConnStatus Joseph
CRITICAL_SECTION g_csChannelStatus; //For Building transfer channel Joseph
CRITICAL_SECTION g_csAuthAccessStatus;
CRITICAL_SECTION g_csFwbRecord;

#define CARDREADER_INIT_COUNT 3
#define GET_DEV_STATUS_COUNT 3

const int TIMER1 = 1;
const int INSERT_TRY_NUM = 200;
const int READ_TRY_NUM = 1;//oiltmp
const int WAIT_TRY_NUM = 120;
const int WAIT_INTERVAL = 500;
const int READ_TRY_INTERVAL = 300;
const int ACCEPT_TRY_INTERVAL = 500;
const int ACCEPT_TRY_NUM = 110;

class CCardIssuerEntity;

SelfChekerClient::SelfChekerClient(CEntityBase* pEntity)
	: SelfCheckerService_ClientBase(pEntity)
{

}

HealthMngClient::HealthMngClient(CEntityBase* pEntity)
	: HealthManagerService_ClientBase(pEntity)
{

}

void CCardSwiperFSM::s0_on_entry()
{
	LOG_FUNCTION();
	m_eDevState = DEVICE_STATUS_NOT_READY;
	SendDevStatusMsg(4);
	FSMEvent* e = new FSMEvent(USER_EVT_INIT);
	PostEventFIFO(e);
}

void CCardSwiperFSM::s0_on_exit()
{
}

unsigned int CCardSwiperFSM::s0_on_event(FSMEvent* e)
{
	LOG_FUNCTION();
	if (e->iEvt == USER_EVT_INIT) {
		InitTask* task = new InitTask(this);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		e->SetHandled();
		return 0;
	}
	else if (e->iEvt == USER_EVT_QUIT) {
		e->SetHandled();
		return 0;
	}
	return 0;
}
void CCardSwiperFSM::s1_on_entry()
{
	LOG_FUNCTION();
	m_eDevState = DEVICE_STATUS_CONNECTING;
}

void CCardSwiperFSM::s1_on_exit()
{
}

unsigned int CCardSwiperFSM::s1_on_event(FSMEvent* pEvt)
{
	DbgInfo(CSimpleStringA::Format("s1 initializing evt %d,%d", pEvt->iEvt, pEvt->param1));
	if (pEvt->iEvt == USER_EVT_INITFINISHED) {
		pEvt->SetHandled();
		int err = pEvt->param1;
		if (err == 1 || err == 5)
		{
			return err;
		}
		else
		{
			return 0;
		}
	}
	else if (pEvt->iEvt == USER_EVT_QUIT)
	{
		pEvt->SetHandled();
		return 0;
	}
	return 0;
}
//Idle
void CCardSwiperFSM::s2_on_entry()
{
	LOG_FUNCTION();
	m_bDoingBindFWB = false;
	ToLogWarnInfoAboutTerm();
	SendDevStatusMsg(1);
	CSimpleStringA uiState("X");
	ErrorCodeEnum eErr = GetEntityBase()->GetFunction()->GetSysVar("UIState", uiState);
	if (eErr == Error_Succeed && _strnicmp(uiState, "M", strlen("M")) == 0)
	{
		DbgInfo("s2 to set in main page.");
		SetMainPageFlag(true);
	}
	m_testResult = Error_Succeed;
}
void CCardSwiperFSM::s2_on_exit()
{
}
unsigned int CCardSwiperFSM::s2_on_event(FSMEvent* pEvt)
{
	DbgInfo(CSimpleStringA::Format("s2 evt(%d)", pEvt->iEvt));
	switch (pEvt->iEvt) {
	case USER_EVT_READ:
	{
		CardReadEvent* cre = dynamic_cast<CardReadEvent*>(pEvt);
		ReadTask* task = new ReadTask(this);
		task->ctx = cre->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		pEvt->SetHandled();
		return 0;
	}
	case USER_EVT_PREONLINE:
	{
		PreOnlineEvent* poe = dynamic_cast<PreOnlineEvent*>(pEvt);
		PreOnlineTask* task = new PreOnlineTask(this);
		task->ctx = poe->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		pEvt->SetHandled();
		return 0;
	}
	case USER_EVT_POSTONLINE:
	{
		PostOnlineEvent* poe = dynamic_cast<PostOnlineEvent*>(pEvt);
		PostOnlineTask* task = new PostOnlineTask(this);
		task->ctx = poe->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		pEvt->SetHandled();
		return 0;
	}
	case USER_EVT_QUERY_CARD_INFO:
	{
		pEvt->SetHandled();
		QueryCardInfoEvent* pQCIE = dynamic_cast<QueryCardInfoEvent*>(pEvt);
		QueryCardInfoTask* task = new QueryCardInfoTask(this);
		task->ctx = pQCIE->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		return 0;
	}
	case USER_EVT_QUIT:
	{
		pEvt->SetHandled();
		return 0;
	}
	case USER_EVT_EJECT:
	{
		pEvt->SetHandled();
		EjectTask* pTask = new EjectTask(this);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		return 0;
	}
	case USER_EVT_MAGDATA_TRANSFER_INIT_V2:
	{
		pEvt->SetHandled();
		MagTransInitV2Task* task = new MagTransInitV2Task(this);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		return 0;
	}
	case USER_EVT_DEV_DISCONNECTED:
		if (IsValidFWBName(m_csDevNo.GetData(), m_csDevNo.GetLength()))
			GetEntityBase()->GetFunction()->SetSysVar("FWBReConn", "D");//通知其他模块处理
		pEvt->SetHandled();
		return 0;
	case USER_EVT_QUERY_FWB_LIST:
	{
		pEvt->SetHandled();
		QueryFWBListEvent* qfl = dynamic_cast<QueryFWBListEvent*>(pEvt);
		QueryFWBListTask* pTask = new QueryFWBListTask(this);
		pTask->ctx = qfl->ctx;
		pTask->fsmState = 2;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		return 0;
	}
	case USER_EVT_BIND_FWB:
	{
		pEvt->SetHandled();
		BindFWBEvent* bf = dynamic_cast<BindFWBEvent*>(pEvt);
		BindFWBTask* pTask = new BindFWBTask(this);
		pTask->ctx = bf->ctx;
		pTask->fsmState = 2;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		return 0;
	}
	default:
		break;
	}
	return 0;
}
//Reading
void CCardSwiperFSM::s3_on_entry()
{
	LOG_FUNCTION();
	GetEntityBase()->GetFunction()->SetUserDefineState(USER_CARDSWIPER_READING);
}
void CCardSwiperFSM::s3_on_exit()
{
}
unsigned int CCardSwiperFSM::s3_on_event(FSMEvent* pEvt)
{
	DbgInfo(CSimpleStringA::Format("s3 evt(%d)(%d)", pEvt->iEvt, pEvt->param1));
	switch (pEvt->iEvt)
	{
	case USER_EVT_READFINISHED:
	{
		m_bReading = false;
		pEvt->SetHandled();
		CardReadFinishedEvent* pCRFE = dynamic_cast<CardReadFinishedEvent*>(pEvt);
		int err = pCRFE->param1;

		if (err == 0)
		{
			pCRFE->ctx->Answer(Error_Succeed);
			if (m_nReadFailCnt != 0)
				m_nReadFailCnt = 0;
			SendDevStatusMsg(1);
		}
		else if (err == 2)
			return 2;
		else if (err == 3)
		{
			DbgInfo("front cancel read");
			pCRFE->ctx->Answer(Error_Cancel);
		}
		else if (err == 4)
		{
			DbgInfo("read timeout");
			pCRFE->ctx->Answer(Error_TimeOut);
		}
		else if (err == 5)
		{
			pCRFE->ctx->Answer(Error_Succeed);
		}
		else if (err == 7) {//返回的磁道数据长度有误，不再重试
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220201").setResultCode("RTA2204")("读取磁道数据长度有误");
			LogError(Severity_High, Error_Param, CardSwiper_UserErrorCode_Invalid_Track_Size, "ReadCard error: TrackData is invalid.");
			pCRFE->ctx->Answer(Error_Param, CardSwiper_UserErrorCode_Invalid_Track_Size);
		}
		else if (err == 8 || err == 9) {
			pCRFE->ctx->Answer(Error_Interact);//刷磁失败/ActiveContactlessICCard上电失败或交互失败，重试
		}
		else
		{
			//QueryCardStatus返回失败
			DbgInfo(CSimpleStringA::Format("ReadCard::QueryCardStatus err(%d)", err));
			pCRFE->ctx->Answer(Error_Interact);
		}
		return 0;
	}
	break;
	case USER_EVT_CANCELINSERT:
	{
		pEvt->SetHandled();
		//  --Josephus at 23:28:03 2016126
		CancelReadTask* task = new CancelReadTask(this);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
	break;
	case USER_EVT_EXIT:
	{
		//m_bReading = false;
		pEvt->SetHandled();
		ExitTask* task = new ExitTask(this);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		return 0;
	}
	break;
	case USER_EVT_QUERY_CARD_INFO:
	{
		pEvt->SetHandled();
		QueryCardInfoEvent* pQCIE = dynamic_cast<QueryCardInfoEvent*>(pEvt);
		QueryCardInfoTask* task = new QueryCardInfoTask(this);
		task->ctx = pQCIE->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		return 0;
	}
	case USER_EVT_QUIT:
	{
		pEvt->SetHandled();
		return 0;
	}
	default:
		break;
	}
	return 0;
}
//Hold
void CCardSwiperFSM::s4_on_entry()
{
	LOG_FUNCTION();
	GetEntityBase()->GetFunction()->SetUserDefineState(USER_CARDSWIPER_HOLD);
}
void CCardSwiperFSM::s4_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardSwiperFSM::s4_on_event(FSMEvent* pEvt)
{
	switch (pEvt->iEvt)
	{
	case USER_EVT_QUERY_CARD_INFO:
	{
		pEvt->SetHandled();
		QueryCardInfoEvent* pQCIE = dynamic_cast<QueryCardInfoEvent*>(pEvt);
		QueryCardInfoTask* task = new QueryCardInfoTask(this);
		task->ctx = pQCIE->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		return 0;
	}
	default:
		break;
	}
	return 0;
}
//Failed
void CCardSwiperFSM::s5_on_entry()
{
	LOG_FUNCTION();
	GetEntityBase()->GetFunction()->SetUserDefineState(USER_CARDSWIPER_FAILED);
	m_eDevState = DEVICE_STATUS_FAULT;
}
void CCardSwiperFSM::s5_on_exit()
{
	m_testResult = Error_Succeed;
}
unsigned int CCardSwiperFSM::s5_on_event(FSMEvent* pEvt)
{
	DbgInfo(CSimpleStringA::Format("s5(failed) evt(%d)(%d)", pEvt->iEvt, pEvt->param1));
	switch (pEvt->iEvt)
	{
	case USER_EVT_DEV_DISCONNECTED:
		if (IsValidFWBName(m_csDevNo.GetData(), m_csDevNo.GetLength()))
			GetEntityBase()->GetFunction()->SetSysVar("FWBReConn", "D");//通知其他模块处理
		pEvt->SetHandled();
		break;
	case USER_EVT_QUIT:
		pEvt->SetHandled();
		return 0;
	case USER_EVT_ACCEPT_CANCEL:
		m_bCancelAccept = true;
		pEvt->SetHandled();
		break;
	default:
		break;
	}
	return 0;
}

//Eject(WaitingFetch)
void CCardSwiperFSM::s6_on_entry()
{
	LOG_FUNCTION();
	GetEntityBase()->GetFunction()->SetUserDefineState(USER_CARDSWIPER_WAITFETCHING);
}
void CCardSwiperFSM::s6_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CCardSwiperFSM::s6_on_event(FSMEvent* pEvt)
{
	DbgInfo(CSimpleStringA::Format("s6(eject.waitingfetch) event(%d)(%d)", pEvt->iEvt, pEvt->param1));
	switch (pEvt->iEvt)
	{
	case USER_EVT_EJECTFINISHED:
	{
		SetExitFlag(false);
		pEvt->SetHandled();
		if (pEvt->param1 == 0) {
			FetchCard evt;
			evt.status = 0;
			SpSendBroadcast(m_pEntity->GetFunction(), SP_MSG_OF(FetchCard), SP_MSG_SIG_OF(FetchCard), evt);
			LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_OP, "CardIssuer op.");
			DbgInfo("客户取走卡片msg发送");
			return 0;
		}
		else if (pEvt->param1 == 2) {
			FetchCard evt;
			evt.status = 2;
			SpSendBroadcast(m_pEntity->GetFunction(), SP_MSG_OF(FetchCard), SP_MSG_SIG_OF(FetchCard), evt);
			DbgInfo("客户未取卡超时msg发送");
			LogWarn(Severity_Middle, Error_NotInit, CardSwiper_UserErrorCode_Customer_Forget_Fectch_Card, "Customer forget fetch card.");
			return 2;
		}
		else
		{
			return 1;
		}
	}
	break;//no use,just for sonar
	case USER_EVT_QUERY_CARD_INFO:
	{
		pEvt->SetHandled();
		QueryCardInfoEvent* pQCIE = dynamic_cast<QueryCardInfoEvent*>(pEvt);
		QueryCardInfoTask* task = new QueryCardInfoTask(this);
		task->ctx = pQCIE->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		return 0;
	}
	case USER_EVT_QUIT:
	{
		pEvt->SetHandled();
		return 0;
	}
	case USER_EVT_EXIT:
		pEvt->SetHandled();
		SetExitFlag();
		break;
	default:
		break;
	}
	return 0;
}

//DeviceOff
void CCardSwiperFSM::s7_on_entry()
{
	LOG_FUNCTION();
	GetEntityBase()->GetFunction()->SetUserDefineState(USER_CARDSWIPER_FAILED);
	//oilyang@20200519 only crypt machine need to show this message
	if (IsCryptMachinaType())
	{
		m_bNeedInitCh = true;
		//oilyang@20220406 MachineType is NOT RVC.PAD or RVC.PAD with FWB binded,we need to show this message.
		if (_strnicmp(m_rvcsysInfo.strMachineType.GetData(), "RVC.PAD", strlen("RVC.PAD")) != 0
			|| (_strnicmp(m_rvcsysInfo.strMachineType.GetData(), "RVC.PAD", strlen("RVC.PAD")) == 0 && IsValidFWBName((const char*)m_csDevNo, m_csDevNo.GetLength())))
			ShowFatalrForConnect("多合一设备已断开连接！");

		m_eDevState = DEVICE_STATUS_NOT_READY;
		if (_strnicmp(m_rvcsysInfo.strMachineType.GetData(), "RVC.PAD", strlen("RVC.PAD")) != 0)
		{
			LogWarn(Severity_Middle, Error_DevConnFailed, CardSwiper_UserErrorCode_DEV_DISCONNECTED, "CardSwiper device disconnected");
		}
		else
		{
			if (IsValidFWBName((const char*)m_csDevNo, m_csDevNo.GetLength()))
			{
				if (m_bFWBOpenSucEver) {
					LogWarn(Severity_Middle, Error_DevConnFailed, CardSwiper_UserErrorCode_FWB_DISCONNECTED_BLUETOOTH, "CardSwiper(fwb) device disconnected.");
					m_bOpened = false;
				}
			}
			else
				m_eDevState = DEVICE_STATUS_NOCFG;
		}
	}
	else
		m_eDevState = DEVICE_STATUS_NOCFG;
}

void CCardSwiperFSM::s7_on_exit()
{
}

unsigned int CCardSwiperFSM::s7_on_event(FSMEvent* pEvt)
{
	unsigned int uRet = 0;
	DbgInfo(CSimpleStringA::Format("s7(DeviceOff) event(%d)(%d),currStateName:%s", pEvt->iEvt, pEvt->param1, GetCurrStateName()));
	switch (pEvt->iEvt)
	{
	case USER_EVT_DEV_CONNECTED:
		pEvt->SetHandled();
		break;
	case USER_EVT_QUERY_CARD_INFO:
	{
		pEvt->SetHandled();
		QueryCardInfoEvent* pQCIE = dynamic_cast<QueryCardInfoEvent*>(pEvt);
		if (pQCIE && pQCIE->ctx != NULL) {
			pQCIE->ctx->Ans.position = 0;
			pQCIE->ctx->Ans.reserved1 = 0;
			pQCIE->ctx->Ans.reserved2 = "";
			DbgInfo("Abort to GetDevStatus, seems(set) no card status previously");
			pQCIE->ctx->Answer(Error_Succeed);
		}
		//QueryCardInfoTask* task = new QueryCardInfoTask(this);
		//task->ctx = pQCIE->ctx;
		//GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
	break;
	case USER_EVT_QUIT:
	{
		pEvt->SetHandled();
	}
	break;
	case USER_EVT_EXIT:
		pEvt->SetHandled();
		SetExitFlag();
		break;
	case USER_EVT_QUERY_FWB_LIST:
	{
		pEvt->SetHandled();
		QueryFWBListEvent* qfl = dynamic_cast<QueryFWBListEvent*>(pEvt);
		QueryFWBListTask* pTask = new QueryFWBListTask(this);
		pTask->ctx = qfl->ctx;
		pTask->fsmState = 8;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		return 0;
	}
	case USER_EVT_BIND_FWB:
	{
		pEvt->SetHandled();
		BindFWBEvent* bf = dynamic_cast<BindFWBEvent*>(pEvt);
		BindFWBTask* pTask = new BindFWBTask(this);
		pTask->ctx = bf->ctx;
		pTask->fsmState = 8;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		return 0;
	}
	case USER_EVT_QUERY_FWB_LIST_FINISHED:
	{
		pEvt->SetHandled();
		return pEvt->param1;
	}
	break;
	case USER_EVT_BIND_FWB_FINISHED:
	{
		pEvt->SetHandled();
		return pEvt->param1;
	}
	case USER_EVT_INIT:
		pEvt->SetHandled();
		break;
	default:
		break;
	}
	return uRet;
}

//FWB
void CCardSwiperFSM::s8_on_entry()
{

}
void CCardSwiperFSM::s8_on_exit()
{

}
unsigned int CCardSwiperFSM::s8_on_event(FSMEvent* pEvt)
{
	DbgInfo(CSimpleStringA::Format("s8(FWB) %d,%d", pEvt->iEvt, pEvt->param1));
	switch (pEvt->iEvt)
	{
	case USER_EVT_QUERY_FWB_LIST_FINISHED:
	{
		pEvt->SetHandled();
		return pEvt->param1;
	}
	break;
	case USER_EVT_BIND_FWB_FINISHED:
	{
		m_bDoingBindFWB = false;
		pEvt->SetHandled();
		return pEvt->param1;
	}
	break;
	default:
		break;
	}
	return 0;
}
ErrorCodeEnum CCardSwiperFSM::OnInit()
{
	LOG_FUNCTION();
	AddStateHooker(this);
	return Error_Succeed;
}
ErrorCodeEnum CCardSwiperFSM::OnExit()
{
	LOG_FUNCTION();
	ErrorCodeEnum eExit;
	if (m_hDevHelper != nullptr)
	{
		m_hDevHelper.TearDown();
	}
	if (m_connChecking)
	{
		m_bCancelQueryConn = true;
		DWORD dwStart = GetTickCount();
		while (m_connChecking && GetTickCount() <= dwStart + 3000)
		{
			Sleep(50);
		}
	}
	RemoveStateHooker(this);
	DeleteCriticalSection(&g_csCntStatus);
	DeleteCriticalSection(&g_csChannelStatus);
	DeleteCriticalSection(&g_csAuthAccessStatus);
	FSMImpl<CCardSwiperFSM>::OnExit();
	return Error_Succeed;
}

void TestShowRecvData(PBYTE hexBuf, DWORD len)
{
	char* show = new char[512];
	SP::Module::Util::HexBuf2StrBuf(hexBuf, &show, len);
	delete[] show;
}

int FindHexCharPosition(LPBYTE data, BYTE hexChar, int len)
{
	int notExist = -1, ret = 1, pos = 0;
	for (; pos < len; ++pos)
	{

		BYTE high = (*(data + pos)) & 0xf0;
		BYTE low = (*(data + pos)) & 0x0f;

		if ((high >> 4) != hexChar)
			ret++;
		else
			return ret;

		if (low != hexChar)
			ret++;
		else
			return ret;
	}
	ret = notExist;
	return ret;
}


bool CCardSwiperFSM::GetDevStatus()
{
	//LOG_FUNCTION();
	int getDevInfoCount = 0;
	ErrorCodeEnum err;
	long l_beginTime, l_endTime;

	do {
		l_beginTime = GetTickCount();
		err = m_hDevHelper->GetDevStatus(devStatus);
		l_endTime = GetTickCount();
		DbgInfo(CSimpleStringA::Format("GetDevStatus", l_beginTime, l_endTime, CSimpleStringA::Format("devStatus.eMedia:%d", devStatus.eMedia)));

		if (Error_Succeed == err)
			return true;
		else
		{
			DevErrorInfo devErrInfo;
			m_hDevHelper->GetLastErr(devErrInfo);
			DbgWarn(CSimpleStringA::Format("GetDevStatus::GetDevStatus failed with errCode = 0x%x, errMsg = %s", err, devErrInfo.szErrMsg));
			getDevInfoCount++;
			Sleep(3000);
		}
	} while (getDevInfoCount < GET_DEV_STATUS_COUNT);

	return false;
}


ErrorCodeEnum CCardSwiperFSM::Load(CSimpleStringA csDevSN)
{
	LOG_FUNCTION();
	auto pEntity = GET_DEV_ENTITY_BASE_POINTER();
	//oilyang@20220420 对于"FWBDevSN"的设置不再持久化，如果之前有持久化的，需要提前删除
	CSimpleStringA xTmpDevNo("");
	GetEntityBase()->GetFunction()->GetSysVar("FWBDevSN", xTmpDevNo);
	if (!xTmpDevNo.IsNullOrEmpty())
	{
		DbgInfo("clear FWBDevSN");
		GetEntityBase()->GetFunction()->SetSysVar("FWBDevSN", "", true);
	}

	int initTries = 0;
	bool bClosePort = false;
	ErrorCodeEnum eErrDev = GetEntityBase()->GetFunction()->GetSystemStaticInfo(m_rvcsysInfo);
	if (eErrDev != Error_Succeed)
	{
		DbgWarn(CSimpleStringA::Format("Get System Static info failed(%d).", eErrDev));
		return eErrDev;
	}
	CSimpleStringA csTmp(""), csBackslash("\\"), csVersion("8.1"), csVendor(true);
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfigRun;
	eErrDev = spEntityFunction->OpenConfig(Config_Run, spConfigRun);
	if (eErrDev == Error_Succeed)
	{
		//FWB
		if (csDevSN.GetLength() > 1) {
			csVendor = TransferAboutVendorShortName(csDevSN.SubString(0, 2));
		}
		else {
			spConfigRun->ReadConfigValue("fwb", "vendor", csVendor);
		}

		if (csDevSN.GetLength() > 1)
			m_csDevNo = csDevSN;
		else {
			spConfigRun->ReadConfigValue("fwb", "devSN", m_csDevNo);
		}

		HARDWARE_ENTITY_SET_VENDOR_NAME(m_entCode, m_csVendor);
		spConfigRun->ReadConfigValue("fwb", "version", csTmp);
		if (csTmp.GetLength() > 1)//如果忘记配置，则直接使用默认值8.1
			csVersion = csTmp;
		DbgInfo(CSimpleStringA::Format("<Load>, vendor:%s,devSN:%s", csVendor.GetData(), m_csDevNo.GetData()));
	}

	if (IsValidFWBName(m_csDevNo.GetData(), m_csDevNo.GetLength()))
	{
		m_isFWB = true;
		GetEntityBase()->GetFunction()->SetSysVar("FWBVendor", csVendor);
		GetEntityBase()->GetFunction()->SetSysVar("FWBVersion", csVersion);
		HARDWARE_ENTITY_SET_VENDOR_NAME(m_entCode, m_csVendor);

		VendorLibInfo vendorlibInfo(GetEntityBase()->GetEntityName());
		vendorlibInfo.strVendor = csVendor;
		CAutoArray<CSimpleStringA> dllVersions = csVersion.Split('.');
		if (dllVersions.GetCount() >= 2) {
			vendorlibInfo.strVersion = dllVersions[0];
			vendorlibInfo.strBatch = dllVersions[1];
		}
		else {
			vendorlibInfo.strVersion = csVersion;
		}
		pEntity->vendorLibInfo = vendorlibInfo;
		FulfillAdapterInfoFrom(pEntity->vendorLibInfo);
		DbgInfo(CSimpleStringA::Format("This is fwb, dllName = %s", m_adapterInfo.adapterFileName.GetData()));
		//m_adapterInfo.strPort.Clear();
		//m_adapterInfo.strBaudrate.Clear();
	}
	///*TODO(80374374@4/3/2023): 现在应该没有有线多合一了 */
	else//normal AllInOne device
	{
		//oilyang@20220406 AllInOne have been offline in All of Branch.
		if (_strnicmp(m_rvcsysInfo.strMachineType.GetData(), "RVC.PAD", strlen("RVC.PAD")) == 0)
		{
			GetEntityBase()->GetFunction()->SetSysVar("FWBVendor", "");
			GetEntityBase()->GetFunction()->SetSysVar("FWBDevSN", "");
			GetEntityBase()->GetFunction()->SetSysVar("FWBVersion", "");
			return Error_NotExist;
		}
		pEntity->LoadVendorLibName();
		FulfillAdapterInfoFrom(pEntity->vendorLibInfo);
	}
	HARDWARE_ENTITY_SET_VENDOR_NAME(m_entCode, csVendor);
	LogWarn(Severity_Low, Error_Unexpect, CardSwiper_UserErrorCode_RootInfo, m_adapterInfo.adapterFilePath.GetData());
	pEntity->InitializeVendorLogSwitch();

	ErrorCodeEnum rc = m_hDevHelper.LoadUp(m_adapterInfo.adapterFilePath);
	if (!IS_SUCCEED(rc))
	{
		DbgWarn(CSimpleStringA::Format("Load dll failed.%d", GetLastError()));
		SetErrPackage("Load::LoadLibraryA(dllName)", m_csDevNo, Error_Unexpect, CardSwiper_UserErrorCode_LOAD_FILE_FAILED);
		AlarmDEC();
		return Error_DevLoadFileFailed;
	}

	CSimpleStringA csBinPath;
	ErrorCodeEnum eErrPath = GetEntityBase()->GetFunction()->GetPath("Bin", csBinPath);
	if (eErrPath != Error_Succeed) {
		DbgWarn(CSimpleStringA::Format("GetBasePath failed (%d).", eErrPath));
		return Error_Param;
	}
	CSimpleStringA csCMBPrint("CMBPrint.dll");
	csCMBPrint = csBinPath + csBackslash + csCMBPrint;
	DbgInfo(CSimpleStringA::Format("CMBPrint path:%s",(LPCTSTR)csCMBPrint));
	HMODULE cmbPrinthr = LoadLibraryA(csCMBPrint);
	if (cmbPrinthr == NULL)
	{
		DbgWarn(CSimpleStringA::Format("Load CMBPrint failed(%d).", GetLastError()));
		SetErrPackage("Load::LoadLibraryA(CMBPrint)", m_csDevNo, Error_Unexpect, CardSwiper_UserErrorCode_LOAD_FILE_FAILED);
		AlarmDEC();
		return Error_DevLoadFileFailed;
	}
	if ((cmdDecodeMag2 = (lpCMBdecodeMag2)GetProcAddress(cmbPrinthr, "CMBdecodeMag2")) == NULL)
	{
		DbgWarn("Get Mag2 address failed.");
		return Error_DevLoadFileFailed;
	}
	if ((cmdDecodeEx = (lpCMBdecodeEx)GetProcAddress(cmbPrinthr, "CMBdecodeEx")) == NULL)
	{
		DbgWarn("Get Mag23Ex address failed.");
		return Error_DevLoadFileFailed;
	}
	do {
		ErrorCodeEnum eErr = Error_Unexpect;
		DbgInfo(CSimpleStringA::Format("open card swiper, port:%d, baudRate:%d, devNo:%s", m_adapterInfo.GetPortInt(), m_adapterInfo.GetBaudrateInt(), m_csDevNo.GetData()));
		long l_beginTime, l_endTime;
		BYTE btType = 0;
		if (IsValidFWBName(m_csDevNo.GetData(), m_csDevNo.GetLength()))
		{
			GetEntityBase()->GetFunction()->SetSysVar("FWBReConn", "N");
			m_bCallingDevOpenEx = true;
			DbgInfo("to call DevOpenEx");
			l_beginTime = GetTickCount();
			eErr = m_hDevHelper->DevOpenEx(m_adapterInfo.GetPortInt(), m_adapterInfo.GetBaudrateInt(), DEV_OPEN_TYPE_USB | DEV_OPEN_TYPE_BLUETOOTH, m_csDevNo.GetData(), btType);
			l_endTime = GetTickCount();
			DbgInfo("DevOpenEx", l_beginTime, l_endTime, eErr, CSimpleStringA::Format("btType:%d", btType));

			if (eErr != Error_Succeed) {
				SetErrPackage("Load::DevOpenEx", m_csDevNo, eErr, MEC_DEVAPI_CARDSWIPER_DevOpenEx);
				AlarmDEC();
			}
			m_bCallingDevOpenEx = false;
		}
		else {
			l_beginTime = GetTickCount();
			eErr = m_hDevHelper->DevOpen(m_adapterInfo.GetPortInt(), m_adapterInfo.GetBaudrateInt());
			l_endTime = GetTickCount();
			DbgInfo("DevOpen", l_beginTime, l_endTime, eErr, "DevOpen");

			if (eErr != Error_Succeed) {
				SetErrPackage("Load::DevOpen", m_csDevNo, eErr, MEC_DEVAPI_CARDSWIPER_DevOpen);
				AlarmDEC();
			}
		}
		m_nSplitRes = -1;
		if (eErr == Error_Succeed)
		{
			bClosePort = true;
			if (IsValidFWBName((const char*)m_csDevNo, m_csDevNo.GetLength()))
			{
				//oilyang@20200407 if csDevSN is null or invalid,no need to restart
				if (csDevSN.GetLength() < 2)
				{
					m_bFWBOpenSucEver = true;
				}
				//LogEvent(Severity_High, LOG_EVT_CARDREADER_OPEN_SUC_FWB, CSimpleStringA::Format("FWB %s (CardSwiper)open suc.", m_csDevNo.GetData()));
				//GetEntityBase()->GetFunction()->SetSysVar("FWBDevSN", m_csDevNo);
				//GetEntityBase()->GetFunction()->SetSysVar("FWBReConn", "Y");
				//StartEntity("PinPad", m_bFWBOpenSucEver);
				//StartEntity("IDCertificate", m_bFWBOpenSucEver);
				//StartEntity("FingerPrint", m_bFWBOpenSucEver);
			}

			l_beginTime = GetTickCount();
			eErr = m_hDevHelper->GetDevCategory(m_devCat);
			l_endTime = GetTickCount();
			DbgInfo("GetDevCategory", l_beginTime, l_endTime, eErr, "GetDevCategory");

			if (eErr == Error_Succeed)
			{
				m_nSplitRes = SplitDevModelInfo();
				m_adapterInfo.FulfillCategoryInfo(m_devCat);
			}
			else {
				SetErrPackage("Load::GetDevCategory", m_csDevNo, eErr, MEC_DEVAPI_CARDSWIPER_GetDevCategory);
				AlarmDEC();
			}
			initTries = 0;
			break;
		}
		else {
			initTries++;
		}
	} while (initTries < m_timesToTryOpen);
	DbgInfo(CSimpleStringA::Format("inittries[%d]", initTries));
	if (initTries != 0)
	{
		m_bOpened = false;
		LogWarn(Severity_Middle, Error_Unexpect, CardSwiper_UserErrorCode_Open_Failed
			, CSimpleStringA::Format("读卡器打开失败:%s", m_csDevNo.GetData()));
		return Error_DevCommFailed;
	}
	else
	{
		m_bOpened = true;
		LogWarn(Severity_Low, Error_Unexpect, CardSwiper_UserErrorCode_Open_Success
			, CSimpleStringA::Format("读卡器打开成功:%s", m_csDevNo.GetData()));
		return Error_Succeed;
	}
}
const int MAX_KEY_SIZE = 256;

void vSJLTransToGM(PBYTE pENCData, BYTE bENCDataLength)
{
	BYTE bResponseData[512];
	BYTE dwDataInLen = 0;
	//把C1C2C3调整为C1C3C2
	dwDataInLen = bENCDataLength - 0x60;
	memcpy(bResponseData, pENCData, bENCDataLength);
	memcpy(pENCData, bResponseData, 64);
	memcpy(pENCData + 64, bResponseData + 64 + dwDataInLen, 32);
	memcpy(pENCData + 96, bResponseData + 64, dwDataInLen);
}

int CCardSwiperFSM::Initial(CSimpleStringA csDevSN, bool bInitChannel)
{
	LOG_FUNCTION();
	DbgInfo(CSimpleStringA::Format("<Initial>, csDevSN:%s, bInitChannel:%d", csDevSN.GetData(), bInitChannel));
	InitializeCriticalSection(&g_csCntStatus);
	InitializeCriticalSection(&g_csChannelStatus);
	InitializeCriticalSection(&g_csAuthAccessStatus);
	InitializeCriticalSection(&g_csFwbRecord);
	m_pCardProcess = new CCardProcess();
	if (m_pCardProcess == NULL)//almost no use...
	{
		DbgWarn("create card process failed.");
		return 5;
	}
	CSmartPointer<IConfigInfo> spConfigCert;
	ErrorCodeEnum errCode = GetEntityBase()->GetFunction()->OpenConfig(Config_CenterSetting, spConfigCert);
	if (Error_Succeed == errCode)
	{
		m_timesToTryOpen = 0;
		spConfigCert->ReadConfigValueInt(m_pEntity->GetEntityName(), "TimeToTryOpen", m_timesToTryOpen);
		if (m_timesToTryOpen <= 0 || m_timesToTryOpen > 3)
			m_timesToTryOpen = 3;
	}
	errCode = Load(csDevSN);
	if (errCode != Error_Succeed)
	{

		DbgWarn(CSimpleStringA::Format("Load failed(%d).", errCode));
		//  --Josephus at 8:25:33 2016126
		delete m_pCardProcess;
		m_pCardProcess = NULL;
		return 1;
	}
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfigRun;
	errCode = spEntityFunction->OpenConfig(Config_Run, spConfigRun);

	devStatus.eMedia = CI_MEDIA_NOTPRESENT;

	int nRes = 0;
	m_periodResetCount = 0;
	if (IsCryptMachinaType())
	{
		int online = 0;
		int nTemp = 0;
		ErrorCodeEnum eErr = Error_Unexpect;
		EnterCriticalSection(&g_csCntStatus);
		eErr = m_hDevHelper->IfDevOnline(online);
		if (eErr == Error_Succeed && online == 1)
		{
			GetEntityBase()->GetFunction()->SetUserDefineState(USER_CARDSWIPER_IDLE);
			m_eDevState = DEVICE_STATUS_NORMAL;
			//  --Josephus at 9:50:47 2016126
			m_connStatus = 1;
			if (bInitChannel)
				nTemp = ProcessEnChannel();
			if (nTemp != 0)
			{//  --Josephus at 14:59:23 201754
				nRes = 2;
			}
		}
		else
		{
			DbgInfo(CSimpleStringA::Format("The device is disconnected rc(%d), online(%d).", eErr, online));
			//设备断开  --Josephus at 9:51:12 2016126
			m_eDevState = DEVICE_STATUS_NOT_READY;
			m_connStatus = 0;
			nRes = 1;
		}
		LeaveCriticalSection(&g_csCntStatus);

		if (!m_connChecking)
		{
			QueryConnectTask* pTask = new QueryConnectTask(this);
			if (nTemp != 0)
				pTask->nReserved = nTemp;
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
	}

	return nRes;
}

static CSimpleStringA GetStrData(TrackInfo trackInfo)
{
	LOG_FUNCTION();
	CSimpleStringA strRet;
	switch (trackInfo.eStatus) {
	case CI_DATA_OK:
		strRet = (char*)trackInfo.data;
		break;
	case CI_DATA_INVALID:
		strRet = "无效数据";
		break;
		//case CI_DATA_MISSING:
	default:
		strRet = "数据丢失";
	}
	return strRet;
}

int CCardSwiperFSM::SplitTrack2(CSimpleStringA pTrack2, Track2Data& decodeData)
{
	if (pTrack2.IsNullOrEmpty() || pTrack2.GetLength() == 0)
		return -1;
	int dataLen = strlen(pTrack2);
	DbgInfo(CSimpleStringA::Format("SplitTrack2, track2 len:%d", dataLen));

	switch (dataLen)
	{
	case 28:
		decodeData.t2Region = CSimpleString(pTrack2, 4);
		decodeData.t2Account = pTrack2.SubString(4, 8);
		decodeData.t2CardSerial = pTrack2.SubString(14, 8);//oilyang for 8 onecard
		decodeData.t2CVC = pTrack2.SubString(22, 6);
		decodeData.t2ExpireDate = "";
		break;
	case 31:
		decodeData.t2Account = CSimpleString(pTrack2, 16);
		decodeData.t2CardSerial = pTrack2.SubString(16, 1);
		decodeData.t2CVC = pTrack2.SubString(17, 6);
		decodeData.t2Region = pTrack2.SubString(23, 4);
		decodeData.t2ExpireDate = pTrack2.SubString(27, 4);
		break;
	case 25://AE Card
		decodeData.t2Account = CSimpleString(pTrack2, 15);
		decodeData.t2CardSerial = pTrack2.SubString(15, 1);
		decodeData.t2CVC = pTrack2.SubString(16, 5);
		decodeData.t2ExpireDate = pTrack2.SubString(21, 4);
		decodeData.t2Region = "";
		break;
	case 38:
		break;
	default:
		return -1;
	}
	decodeData.status = 0;
	return 0;
}
int CCardSwiperFSM::ReadCard(SpReqAnsContext<CardSwiperService_Read_Req, CardSwiperService_Read_Ans>::Pointer ctx)
{
	LOG_FUNCTION();

	m_pCardProcess->DataInit();
	bool bICSuc = false;
	m_bCancelRead = false;
	ErrorCodeEnum eErr;
	CSimpleStringA errMsg("");
	long l_beginTime, l_endTime;

	ctx->Ans.ICType = 0;
	DWORD dwStart = GetTickCount();
	MagTracks magTracks;
	memset(&magTracks, 0, sizeof(MagTracks));
	magTracks.eRange = CI_TRACK_RANGE_2_3;
	int iStatus = 0;

	bool bReadCardInfo = false;
	char chType;
	m_bReading = true;

	if ((ctx->Req.LightPos & CI_LIGHT_MAG) == CI_LIGHT_MAG)
		LogEvent(Severity_Middle, LOG_EVT_CARDREADER_GREEN_ON, "CardReader(MAG) warning on");

	DbgInfo(CSimpleString::Format("<ReadCard>, inParam:%d,%d", ctx->Req.LightPos, ctx->Req.reserved1));
	l_beginTime = GetTickCount();
	eErr = m_hDevHelper->QueryCardStatus(ctx->Req.LightPos, iStatus, magTracks);
	l_endTime = GetTickCount();
	DbgInfo("QueryCardStatus", l_beginTime, l_endTime, eErr, CSimpleString::Format("CancelRead:%d, WaitAccepteMore:%d, iStatus:%d, t2.state:%d, t2.size:%d, t3.state:%d, t3.size:%d",
		m_bCancelRead, m_bWaitAccepteMore, iStatus, magTracks.track[1].eStatus, magTracks.track[1].dwSize, magTracks.track[2].eStatus, magTracks.track[2].dwSize));

	if ((ctx->Req.LightPos & CI_LIGHT_MAG) == CI_LIGHT_MAG)
		LogEvent(Severity_Middle, LOG_EVT_CARDREADER_GREEN_OFF, "CardReader(MAG) warning off");

	ctx->Ans.CardPos = iStatus;

	if (m_bCancelRead)
		return 3;

	m_bReading = false;

	if (eErr != Error_Succeed)
	{
		SetErrPackage("ReadCard::QueryCardStatus", m_csDevNo, eErr, MEC_DEVAPI_CARDSWIPER_QueryCardStatus);
		AlarmDEC();
		return -1;
	}

	FetchCard evt;
	evt.status = 3;//oilyang@20190507 用于通知ContactlessCard取消等待读卡
	SpSendBroadcast(m_pEntity->GetFunction(), SP_MSG_OF(FetchCard), SP_MSG_SIG_OF(FetchCard), evt);
	ctx->Ans.t2Account = ctx->Ans.ICData = "";

	switch (iStatus)
	{
	case 0:
		return 4;
	case 1:
	{
		ctx->Ans.ICType = 2;
		ctx->Ans.CardPos = 1;//swipe mag card
		//oilyang@20200423 to check if the track size is valid
		if ((magTracks.track[1].eStatus == CI_DATA_OK && magTracks.track[1].dwSize > 40)
			|| (magTracks.track[2].eStatus == CI_DATA_OK && magTracks.track[2].dwSize > 107))
		{
			errMsg = CSimpleStringA::Format("track data is invalid, track2:status(%d) len(%d), track3:status(%d) len(%d)",
				magTracks.track[1].eStatus, magTracks.track[1].dwSize, magTracks.track[2].eStatus, magTracks.track[2].dwSize);
			LogWarn(Severity_Middle, Error_Unexpect, CardSwiper_UserErrorCode_TrackData_Invalid, errMsg.GetData());
			return 7;
		}
		if (Error_Succeed == eErr && magTracks.track[1].eStatus == CI_DATA_INVALID)
		{
			LogWarn(Severity_Middle, Error_Unexpect, CardSwiper_UserErrorCode_Wrong_Track2_Data, "mag track2 data invalid");
			return 8;
		}
		for (int i = 0; i < 20; ++i)
		{
			if (magTracks.track[1].data[i] < 0x30
				|| (magTracks.track[1].data[i] > 0x39 &&
					(magTracks.track[1].data[i] != 0x3d && magTracks.track[1].data[i] != 0x3e && magTracks.track[1].data[i] != 0x44)))//fixpoint 运通卡分隔符还要考虑为D的情况
			{
				//oilyang 20160523
				//not '0'-'9' or '=' or '>'
				//非法字符告警
				CSimpleStringA invalidChar = CSimpleStringA::Format("invalid char(%c) in track2", magTracks.track[1].data[i]);
				LogWarn(Severity_Middle, Error_Unexpect, CardSwiper_UserErrorCode_Has_Invalid_Char_In_Track2, invalidChar.GetData());
				return 8;
			}
		}

		if (Error_Succeed == eErr && magTracks.track[1].eStatus == CI_DATA_OK)
		{
			LogEvent(Severity_Middle, LOG_EVT_CARDISSUER_OP, "CardIssuer op.");
			ctx->Ans.track2 = (char*)magTracks.track[1].data;

			Track2Data track2Data;
			track2Data.status = 0;
			track2Data.t2Account = "";
			char tmpMag2_3[512];
			char* pTmpMag2 = new char[128];
			ZeroMemory(pTmpMag2, 128);
			ZeroMemory(tmpMag2_3, 512);
			memcpy(tmpMag2_3, GetStrData(magTracks.track[1]).GetData(), magTracks.track[1].dwSize);
			char cardType[8] = { 0 };
			if (magTracks.track[2].eStatus == CI_DATA_OK)
			{
				DbgInfo("do track 3");
				ctx->Ans.track3 = (char*)magTracks.track[2].data;
				memcpy(tmpMag2_3 + magTracks.track[1].dwSize, "A", 1);
				memcpy(tmpMag2_3 + magTracks.track[1].dwSize + 1, GetStrData(magTracks.track[2]).GetData(), magTracks.track[2].dwSize);
				cmdDecodeEx(tmpMag2_3, cardType, pTmpMag2);
			}
			if (magTracks.track[2].eStatus != CI_DATA_OK || strlen(cardType) < 4)
			{
				DbgInfo("no or wrong track 3");
				if (magTracks.track[2].eStatus == CI_DATA_OK) {
					SetErrPackage("mag track3 data invalid", m_csDevNo, Error_Unexpect, CardSwiper_UserErrorCode_Wrong_Track3_Data);
					AlarmDEC();
				}
				ctx->Ans.track3 = "";
				char* p37Buf = new char[37 + 1];
				ZeroMemory(p37Buf, 38);
				memcpy(p37Buf, tmpMag2_3, 37);
				cmdDecodeMag2(p37Buf, pTmpMag2);
				delete[]p37Buf;

			}
			//decode account from track 2
			DbgInfo("decode account from track 2");
			int pos = 0;
			for (int i = 0; i < magTracks.track[1].dwSize; ++i, ++pos)
			{
				if (magTracks.track[1].data[i] == 0x3d
					|| magTracks.track[1].data[i] == 0x3e
					|| magTracks.track[1].data[i] == 0x44)
					break;
			}
			DbgInfo(CSimpleString::Format("split pos:%d", pos));
			if (pos <= 0 || pos == magTracks.track[1].dwSize)
			{
				ctx->Ans.status = 1;
				break; //out
			}
			char* ddd = new char[40];
			memset(ddd, 0, 40);
			memcpy(ddd, magTracks.track[1].data, pos);

			//if ((SplitTrack2(pTmpMag2,track2Data) == 0) && (magTracks.track[2].eStatus == CI_DATA_OK))
			if ((SplitTrack2(pTmpMag2, track2Data) == 0) && (magTracks.track[1].eStatus == CI_DATA_OK))
			{
				DbgInfo(CSimpleString::Format("SplitTrack2 done."));
				ctx->Ans.status = track2Data.status;
				ctx->Ans.t2Account = track2Data.t2Account;
				ctx->Ans.t2Region = track2Data.t2Region;
				ctx->Ans.t2CardSerial = track2Data.t2CardSerial;
				ctx->Ans.t2CVC = track2Data.t2CVC;
				ctx->Ans.t2ExpireDate = track2Data.t2ExpireDate;
				bReadCardInfo = true;
				delete[]pTmpMag2;
				//break;
			}
			if (_strnicmp(track2Data.t2Account, ddd, strlen(ddd)) && (track2Data.t2Account.GetLength() != 8))
			{
				ctx->Ans.status = 0;
				ctx->Ans.t2Account = (char*)ddd;
				ctx->Ans.t2Region = "";
				ctx->Ans.t2CardSerial = "";
				ctx->Ans.t2CVC = "";
				ctx->Ans.t2ExpireDate = "";
				DbgWarn(CSimpleString::Format("account maybe some wrong, %s", (LPCTSTR)track2Data.t2Account));
				bReadCardInfo = true;
				delete[]ddd;
			}
			DbgInfo(CSimpleString::Format("<ReadCard>, t2Account:%s****%s",
				(LPCTSTR)ctx->Ans.t2Account.SubString(0, 6), (LPCTSTR)ctx->Ans.t2Account.SubString(pos - 4, 4)));
			break;
		}
		break;
	}
	case 2://ic
	{
		m_eReadType = CARD_MACHINE_SWIPER;
		ctx->Ans.CardPos = 2;//ic card deteced
		ctx->Ans.ICType = 3;
		ctx->Ans.status = 0;
		bReadCardInfo = true;
		ErrorCodeEnum eErr;
		l_beginTime = GetTickCount();
		eErr = m_hDevHelper->ContactIC();
		l_endTime = GetTickCount();
		DbgInfo("ContactIC", l_beginTime, l_endTime, eErr, "ReadCard");

		if (eErr != Error_Succeed) {
			SetErrPackage("iStatus-Value::ContactIC", m_csDevNo, eErr, MEC_DEVAPI_CARDSWIPER_ContactIC);
			AlarmDEC();
		}

		l_beginTime = GetTickCount();
		eErr = m_hDevHelper->ActiveICCard();
		l_endTime = GetTickCount();
		DbgInfo("ActiveICCard", l_beginTime, l_endTime, eErr, "ReadCard");

		if (eErr != Error_Succeed) {
			SetErrPackage("iStatus-Value::ActiveICCard", m_csDevNo, eErr, MEC_DEVAPI_CARDSWIPER_ActiveICCard);
			AlarmDEC();
		}

		//oilyang@20201014 add emv support
		int bGetICData = -3;
		if (ctx->Req.aid.IsNullOrEmpty())
		{
			DbgInfo("the front han't provide aid data.");
			bGetICData = m_pCardProcess->GetICDataFromCard(m_eReadType, m_hDevHelper, m_aidList);
		}
		else {
			DbgInfo(CSimpleString::Format("the aid is[%s],len:%d .", ctx->Req.aid.GetData(), ctx->Req.aid.GetLength()));
			CAutoArray<CSimpleStringA> preAIDs;
			preAIDs.Init(1);
			preAIDs[0] = ctx->Req.aid;
			bGetICData = m_pCardProcess->GetICDataFromCard(m_eReadType, m_hDevHelper, preAIDs);
		}
		ICData track2(false, 0x57, 0x00);
		eErr = Error_Unexpect;
		string t2ICAccount(""), t2ICCardSerial(""), t2ICCVC(""), t2ICTrack2(""), cardType;
		if (m_pCardProcess->FindTagValue(TAG_VECTOR_IC, track2, false, 0) == -1)
		{
			DbgInfo("no track2 data in ic");
			eErr = m_hDevHelper->ReleaseIC();
			if (eErr != Error_Succeed) {
				SetErrPackage("iStatus-Value::ActiveICCard::ReleaseIC", m_csDevNo, eErr, MEC_DEVAPI_CARDSWIPER_ReleaseIC);
				AlarmDEC();
			}
		}
		else
		{
			int pos = FindHexCharPosition(track2.value, 0x0d, track2.lenth);
			char* pICTrack2 = new char[128];
			ZeroMemory(pICTrack2, 128);
			HexBuf2StrBuf(track2.value, &pICTrack2, track2.lenth);
			pICTrack2[37] = '\0';

			{
				char* ddd = new char[128];
				memset(ddd, 0, 128);
				memcpy(ddd, pICTrack2, pos - 1);

				t2ICTrack2 = pICTrack2;
				t2ICAccount = (char*)ddd;//oiltest
				DbgInfo(CSimpleStringA::Format("ic acount : %s****%s", t2ICAccount.substr(0, 6).c_str(), t2ICAccount.substr(t2ICAccount.length() - 4, 4).c_str()));
				ctx->Ans.ICData = ctx->Ans.t2Account = t2ICAccount.c_str();
				delete[]ddd;
			}
			delete[]pICTrack2;
		}
		eErr = m_hDevHelper->ReleaseIC();
		if (eErr != Error_Succeed) {
			SetErrPackage("iStatus-Value::ActiveICCard::ReleaseIC", m_csDevNo, eErr, MEC_DEVAPI_CARDSWIPER_ReleaseIC);
			AlarmDEC();
		}
	}
	break;
	case 3:
		break;
	case 4://contactless card process
	{
		m_eReadType = CARD_MACHINE_SWIPER_RF;
		ctx->Ans.CardPos = 4;
		ctx->Ans.ICType = 4;
		ctx->Ans.status = 0;
		bReadCardInfo = true;
		l_beginTime = GetTickCount();
		eErr = m_hDevHelper->ActiveContactlessICCard('A', 'B', 'M', chType);
		l_endTime = GetTickCount();
		DbgInfo("ActiveContactlessICCard", l_beginTime, l_endTime, eErr, CSimpleStringA::Format("active type %d", chType));

		if (eErr != Error_Succeed)
		{
			SetErrPackage("iStatus-Value::ActiveContactlessICCard", m_csDevNo, eErr, MEC_DEVAPI_CARDSWIPER_ActiveContactlessICCard);
			AlarmDEC();
			return 9;
		}
		ctx->Ans.reserved3 = chType;
		//oilyang@20201014 add emv support
		int bGetICData = -3;
		if (ctx->Req.aid.IsNullOrEmpty())
		{
			DbgInfo("the front han't provide aid data.");
			bGetICData = m_pCardProcess->GetICDataFromCard(m_eReadType, m_hDevHelper, m_aidList);
		}
		else {
			DbgInfo(CSimpleStringA::Format("the aid is[%s],len:%d .", (const char*)ctx->Req.aid, ctx->Req.aid.GetLength()));
			CAutoArray<CSimpleStringA> preAIDs;
			preAIDs.Init(1);
			preAIDs[0] = ctx->Req.aid;
			bGetICData = m_pCardProcess->GetICDataFromCard(m_eReadType, m_hDevHelper, preAIDs);
		}
		ICData track2(false, 0x57, 0x00);
		eErr = Error_Unexpect;
		string t2ICAccount(""), t2ICCardSerial(""), t2ICCVC(""), t2ICTrack2(""), cardType;
		if (m_pCardProcess->FindTagValue(TAG_VECTOR_IC, track2, false, 0) == -1)
		{
			LogWarn(Severity_Middle, Error_Unexpect, CardSwiper_UserErrorCode_ReadCard_No_Track2Data_In_IC, "no track2 data in ic");
			l_beginTime = GetTickCount();
			eErr = m_hDevHelper->DeactContactlessICCard();
			l_endTime = GetTickCount();
			DbgInfo("DeactContactlessICCard", l_beginTime, l_endTime, eErr, CSimpleStringA::Format(""));

			if (eErr != Error_Succeed) {
				SetErrPackage("iStatus-Value::ActiveContactlessICCard::DeactContactlessICCard", m_csDevNo, eErr, MEC_DEVAPI_CARDSWIPER_DeactContactlessICCard);
				AlarmDEC();
			}
			if (bGetICData == -2)
				return 9;
			else
				return 1;
		}
		else
		{
			int pos = FindHexCharPosition(track2.value, 0x0d, track2.lenth);
			char* pICTrack2 = new char[128];
			ZeroMemory(pICTrack2, 128);
			HexBuf2StrBuf(track2.value, &pICTrack2, track2.lenth);
			pICTrack2[37] = '\0';

			{
				char* ddd = new char[128];
				memset(ddd, 0, 128);
				memcpy(ddd, pICTrack2, pos - 1);

				t2ICTrack2 = pICTrack2;
				t2ICAccount = (char*)ddd;//oiltest
				DbgInfo(CSimpleStringA::Format("ic acount:%s****%s", t2ICAccount.substr(0, 6).c_str(), t2ICAccount.substr(t2ICAccount.length() - 4, 4).c_str()));
				ctx->Ans.ICData = ctx->Ans.t2Account = t2ICAccount.c_str();
				delete[]ddd;
			}
			delete[]pICTrack2;
		}
	}
	break;
	case 5:
	case 6:
		DbgInfo("unexpected card or id card detected.");
		ctx->Ans.CardPos = iStatus;
		ctx->Ans.ICType = iStatus;
		ctx->Ans.status = 1;
		return 5;
	default:
		break;
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220201")("ReadCard suc.");
	m_bWaitAccepteMore = false;
	CSimpleStringA cardType = CSimpleStringA::Format("<ReadCard>, ICType:%d", ctx->Ans.ICType);
	LogWarn(Severity_Low, Error_Unexpect, CardSwiper_UserErrorCode_Card_Type, cardType.GetData());

	DWORD dwEnd = GetTickCount();
	DWORD dwCollapse = dwEnd - dwStart;
	if ((dwCollapse < 8000) && (!bReadCardInfo))
	{
		// duplicate!!! --Josephus at 7:04:41 2016127
		//bReadCardInfo = true; 
		ctx->Ans.status = 1;
		DbgWarn("cannot read mag.");
	}
	//oiltest temp, no chance return 2 josephus;
	bool bEjectSelf = false;
	if (!bReadCardInfo)
	{
		ctx->Ans.status = 1;
	}
	if (GetDevStatus())
		return (m_bCancelRead == true) ? 3 : ((bEjectSelf == true) ? 2 : 0);
	else
		return 1;
}
int CCardSwiperFSM::PreOnline(SpReqAnsContext<CardSwiperService_PreOnline_Req, CardSwiperService_PreOnline_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	m_pCardProcess->DataInit();
	//DbgInfo(CSimpleStringA::Format("<PreOnline>, bus data[%s]",(LPCTSTR)ctx->Req.businessData));
	m_pCardProcess->SplitBusinessData(ctx->Req.businessData, ctx->Req.businessData.GetLength());
	m_pCardProcess->SplitBusinessData("DF690101", strlen("DF690101"));
	int activeCardType;
	//oilyang@20201014 add emv card support
	int retDetectAndRead = -1;
	ICData aidFromBus(false, 0x4f, 0x00);
	if (m_pCardProcess->FindTagValue(TAG_VECTOR_BUS, aidFromBus, false, 0) == -1)
	{
		DbgInfo("the front BusinessData han't provide aid data.");
		retDetectAndRead = m_pCardProcess->DetectAndReadICData(m_eReadType, m_hDevHelper, m_aidList, activeCardType);
	}
	else {
		char* pAIDTmp = new char[64];
		memset(pAIDTmp, 0, 64);
		HexBuf2StrBuf(aidFromBus.value, &pAIDTmp, aidFromBus.lenth);
		DbgInfo(CSimpleStringA::Format("the aid is[%s],len:%d .", pAIDTmp, strlen(pAIDTmp)));
		CAutoArray<CSimpleString> preAIDs;
		preAIDs.Init(1);
		preAIDs[0] = (CSimpleStringA)pAIDTmp;
		retDetectAndRead = m_pCardProcess->DetectAndReadICData(m_eReadType, m_hDevHelper, preAIDs, activeCardType);
		if (pAIDTmp != NULL)
			delete[]pAIDTmp;
	}
	if (retDetectAndRead < 0)
	{
		// -1和-2是上电或APDU交互失败，功能集循环调用
		if (retDetectAndRead == -1) {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220202").setResultCode("RTA2201")("IC卡上电失败");
			SetErrPackage("PreOnline::DetectAndReadICData(-1)", m_csDevNo, Error_Unexpect, MEC_DEVAPI_CARDSWIPER_ActiveICCard);
			ctx->Answer(Error_Interact, AlarmDEC());
		}
		else if (retDetectAndRead == -2) {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220202").setResultCode("RTA2202")("IC卡交互失败");
			SetErrPackage("PreOnline::DetectAndReadICData(-2)", m_csDevNo, Error_Unexpect, MEC_DEVAPI_CARDSWIPER_ICCommand);
			ctx->Answer(Error_Interact, AlarmDEC());
		}
		else if (retDetectAndRead == -3) {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220202").setResultCode("RTA2202")("IC卡交互失败");
			SetErrPackage("PreOnline::DetectAndReadICData(-3)", m_csDevNo, Error_Unexpect, MEC_DEVAPI_CARDSWIPER_ICCommand);
			ctx->Answer(Error_Interact, AlarmDEC());
		}
		return 0;
	}
	//if (m_cardType == CI_CARDTYPE_IC)
	//{
	//	ProcessRestrict();
	//	CardholderVerify();
	m_pCardProcess->TermRiskManage();
	CSimpleStringA taaResult;
	BYTE bt9f27 = 0;
	int retTAA = m_pCardProcess->TermActionAnalyze(m_eReadType, m_hDevHelper, taaResult, true, m_bCDA, bt9f27);
	//DbgInfo(CSimpleStringA::Format("TermActionAnalyze %d",retTAA));
	switch (retTAA)
	{//to be added oiltest 20140929
	case -1:	//some data may be wrong
		break;
	case 1:		//terminal trans
		break;
	case 2:		//to do trans end "TransEnd"
		break;
	default:
		break;
	}
	ctx->Ans.result = taaResult;
	//	Dbg("[%d,%d,%d,%d]",m_TVR[0],m_TVR[1],m_TVR[2],m_TVR[3]);
	//}
	if (ctx->Ans.result.GetLength() == 0)
	{
		ctx->Answer(Error_Succeed);
		return 0;
	}
	//DbgInfo(CSimpleStringA::Format("term action analyze result[%s]", ctx->Ans.result.GetData()));

	//char tmpResult[1024,]result[1024];
	//ZeroMemory(tmpResult,sizeof(tmpResult));
	//ZeroMemory(result,sizeof(result));
	//memcpy(tmpResult,ctx->Ans.result,ctx->Ans.result.GetLength());
	string tmpResult, actionType, result = "", baseICData = "";
	tmpResult = ctx->Ans.result;
	char* pSomeICData = new char[ONE_K];
	ZeroMemory(pSomeICData, ONE_K);
	int lenRet = m_pCardProcess->ConstructARQCData(tmpResult.substr(6, 4).c_str(), m_pDataToARQC, pSomeICData);
	baseICData = pSomeICData;
	if (pSomeICData != NULL)
		delete[]pSomeICData;

	char arqcLen[8];
	ZeroMemory(arqcLen, sizeof(arqcLen));
	itoa(lenRet, arqcLen, 10);
	ICData appExpiryDate(false, 0x5f, 0x24);
	if (m_pCardProcess->FindTagValue(TAG_VECTOR_IC, appExpiryDate, false, 0) == -1)
	{
		DbgWarn("can't find expire date");
		return 0;
	}
	char* pExpireDate = new char[12];
	ZeroMemory(pExpireDate, 12);
	HexBuf2StrBuf(appExpiryDate.value, &pExpireDate, appExpiryDate.lenth);
	ICData track2(false, 0x57, 0x00), ICCardSerial(false, 0x5f, 0x34);
	ErrorCodeEnum eErr = Error_Unexpect;
	string t2ICAccount(""), t2ICCardSerial(""), t2ICCVC(""), t2ICTrack2(""), cardType("0");
	char* pICCardSerial = new char[4];
	ZeroMemory(pICCardSerial, 4);
	if (m_pCardProcess->FindTagValue(TAG_VECTOR_IC, ICCardSerial, false) == -1)
	{
		DbgWarn("can't find card serial.");
	}
	else
	{
		HexBuf2StrBuf(ICCardSerial.value, &pICCardSerial, ICCardSerial.lenth);
	}
	if (m_pCardProcess->FindTagValue(TAG_VECTOR_IC, track2, false, 0) == -1)
	{
		DbgWarn("[ic]no track2 data");
	}
	else
	{
		int pos = FindHexCharPosition(track2.value, 0x0d, track2.lenth);
		char* pICTrack2 = new char[128];
		ZeroMemory(pICTrack2, 128);
		HexBuf2StrBuf(track2.value, &pICTrack2, track2.lenth);
		pICTrack2[37] = '\0';
		DbgInfo(CSimpleStringA::Format("ic.track2, split pos:%d", pos));
		char* ddd = new char[40];
		ZeroMemory(ddd, 40);
		memcpy(ddd, pICTrack2, pos - 1);

		char icTrack2Data[128];

		ZeroMemory(icTrack2Data, sizeof(icTrack2Data));

		Track2Data track2Data;
		track2Data.status = 0;
		track2Data.t2Account = "";
		cmdDecodeMag2(pICTrack2, icTrack2Data);
		if (SplitTrack2(icTrack2Data, track2Data) == 0)
		{
			t2ICAccount = track2Data.t2Account;
			//t2ICCardSerial = track2Data.t2CardSerial;
			t2ICCVC = track2Data.t2CVC;
			t2ICTrack2 = pICTrack2;
			DbgInfo("done(ic).");
		}
		//}
		if (_strnicmp(track2Data.t2Account, ddd, strlen(ddd)))
		{

			t2ICCVC = "";
			t2ICTrack2 = pICTrack2;
			t2ICAccount = (char*)ddd;
			DbgInfo(CSimpleStringA::Format("ic acount : %s,%s", t2ICAccount.substr(0, 6).c_str(), t2ICAccount.substr(t2ICAccount.length() - 4, 4).c_str()));
		}
		t2ICCardSerial = pICCardSerial;
		delete[]ddd;
		delete[]pICTrack2;
	}
	//80 1e 80 0008 328ab54bfc986b85 07010103a0b000010a010000000000754048769000
	if (m_pCardProcess->GetP1() == 0x1)
		actionType = "ARQC";
	else
		actionType = "";
	//【55域】
	//	基本域：
	//	9F26	8b	应用密文AC
	//	9F27	1b	密文信息数据
	//	9F10	max.32b	发卡行应用数据IAD
	//	9F37	4b	不可预知数
	//	9F36	2b	应用交易计数器ATC
	//	95	5b	终端验证结果TVR
	//	9A	3cn	交易日期（6位有效数字，YYMMDD）
	//	9C	1cn	交易类型（2位有效数字）
	//	9F02	6cn	授权金额（12位有效数字）
	//	5F2A	2cn	交易货币代码（3位有效数字）
	//	82	2b	应用交互特征AIP
	//	9F1A	2cn	终端国家代码（3位有效数字）
	//	9F03	6cn	其他金额（12位有效数字）
	//	9F33	3b	终端性能 "E0C900"

	//	可选域：
	//添加9F26,9F27,9F10,9F33的数据
	char* pCID = new char[4];
	ZeroMemory(pCID, 4);
	HexBuf2StrBuf(&bt9f27, &pCID, 1);
	char* pIssueBankLen = new char[4];
	ZeroMemory(pIssueBankLen, 4);
	int len9f10 = tmpResult.length() - 26 - 4;
	int lenHigh, lenLow;
	len9f10 = len9f10 / 2;
	lenHigh = len9f10 / 16;
	lenLow = len9f10 % 16;
	BYTE bt9f10;
	bt9f10 = (lenHigh << 4) + lenLow;
	HexBuf2StrBuf(&bt9f10, &pIssueBankLen, 1);
	baseICData += "9F2608" + tmpResult.substr(10, 16) + "9F2701" + pCID + "9F10" + pIssueBankLen + tmpResult.substr(26, tmpResult.length() - 26 - 4) + "9F3303" + "E0C900";
	result = "ACTION," + actionType + "|" + "ATCCODE," + tmpResult.substr(6, 4) + "|" + "ARQCCODE," + tmpResult.substr(10, 16) + "|"
		+ "MAC," + tmpResult.substr(26, tmpResult.length() - 26 - 4) + "|" + "ARQCSIZE," + string(arqcLen) + "|"
		+ "ARQCDATA," + m_pDataToARQC + "|EXPIREDATE," + pExpireDate + "|T2ACCOUNT," + t2ICAccount + "|T2CARDSERIAL," + t2ICCardSerial
		+ "|T2CVC," + t2ICCVC + "|T2TRACK2," + t2ICTrack2 + "|CARDCAT," + cardType + "|ICTAGS," + baseICData;
	ctx->Ans.result = result.c_str();
	string txtresult = "";
	txtresult = "ACTION," + actionType + "|" + "ATCCODE," + tmpResult.substr(6, 4) + "|" + "ARQCCODE," + tmpResult.substr(10, 16) + "|"
		+ "MAC," + tmpResult.substr(26, tmpResult.length() - 26 - 4) + "|" + "ARQCSIZE," + string(arqcLen) + "|"
		+ "ARQCDATA," + m_pDataToARQC + "|T2ACCOUNT(F6)," + t2ICAccount.substr(0, 6) + "|T2ACCOUNT(L4)," + t2ICAccount.substr(t2ICAccount.length() - 4, 4)
		+ "|T2CARDSERIAL(len)," + t2ICCardSerial + "|CARDCAT," + cardType;
	//Dbg("data to host[%s]",(LPCTSTR)ctx->Ans.result);
	DbgInfo(CSimpleStringA::Format("data to host(less)[%s],baseICData length:%d", txtresult.c_str(), baseICData.length()));
	delete[]pExpireDate;
	if (m_pDataToARQC != NULL)
	{
		delete[]m_pDataToARQC;
		m_pDataToARQC = NULL;
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220202")("PreOnline suc.");
	ctx->Answer(Error_Succeed);
	return 0;
}
int CCardSwiperFSM::PostOnline(SpReqAnsContext<CardSwiperService_PostOnline_Req, CardSwiperService_PostOnline_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DbgInfo(CSimpleStringA::Format("<PostOnline>, post online data[%s]", (LPCTSTR)ctx->Req.data));
	m_pCardProcess->SplitOnlineReplyData(ctx->Req.data, strlen(ctx->Req.data));

	int issBnkAuth = m_pCardProcess->IssueBankAuth(m_eReadType, m_hDevHelper);
	CSimpleStringA csTransEnd;
	if (issBnkAuth == 0)
	{
		int transEnd = m_pCardProcess->TransEnd(m_eReadType, m_hDevHelper, m_bCDA);
		if (transEnd == 0)
			csTransEnd = "TRANSEND,0";
		else if (transEnd == 1)
			csTransEnd = "TRANSEND,1";
	}
	else
		csTransEnd = "TRANSEND,1";
	DbgInfo(CSimpleStringA::Format("issBnkAuth:%d, csTransEnd:%s", issBnkAuth, csTransEnd.GetData()));
	ctx->Ans.result = csTransEnd;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220203")("PostOnline suc");
	ctx->Answer(Error_Succeed);
	return 0;
}
int CCardSwiperFSM::QueryCardInfo(SpReqAnsContext<CardSwiperService_QueryCardInfo_Req, CardSwiperService_QueryCardInfo_Ans>::Pointer ctx)
{
	CardSwiperStatus devStatus;
	long l_beginTime, l_endTime;
	l_beginTime = GetTickCount();
	ErrorCodeEnum eErr = m_hDevHelper->GetDevStatus(devStatus);
	l_endTime = GetTickCount();
	DbgInfo("GetDevStatus", l_beginTime, l_endTime, eErr, CSimpleStringA::Format("QueryCardInfo, eMedia:%d", devStatus.eMedia));

	if (eErr != Error_Succeed)
	{
		SetErrPackage("QueryCardInfo::GetDevStatus", m_csDevNo, eErr, MEC_DEVAPI_CARDSWIPER_GetDevStatus);
		ctx->Answer(Error_Unexpect, AlarmDEC());
		return 1;
	}
	int ret = 0;
	switch (devStatus.eMedia)
	{
	case CI_MEDIA_IC:
		ret = 2;
		break;
	case CI_MEDIA_NOT_IC:
		ret = 3;
		break;
	case CI_MEDIA_RF:
		ret = 4;
		break;
	case CI_MEDIA_IDCARD:
		ret = 6;
		break;
	case CI_MEDIA_NOTPRESENT:
	default:
		ret = 0;
		break;
	}
	ctx->Ans.position = ret;
	ctx->Answer(Error_Succeed);
	return ret;
}
void CCardSwiperFSM::SelfTest(EntityTestEnum eTestType, CSmartPointer<ITransactionContext> pTransactionContext)
{
	if (!m_bDoingBindFWB && (m_eDevState == DEVICE_STATUS_FAULT || m_eDevState == DEVICE_STATUS_NOT_READY))
	{
		ReConnTask* task = new ReConnTask(this);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	}
	pTransactionContext->SendAnswer(Error_Succeed);
}

int CCardSwiperFSM::DoAbortRead()
{
	LOG_FUNCTION();
	long l_beginTime, l_endTime;
	ErrorCodeEnum eErr;

	if (m_bReading)
	{
		DbgInfo("do abort");
		m_bCancelRead = true;

		l_beginTime = GetTickCount();
		eErr = m_hDevHelper->AbortRead();
		l_endTime = GetTickCount();
		DbgInfo("AbortRead", l_beginTime, l_endTime, eErr, "");

		if (eErr == Error_Succeed)
		{
			return 0;
		}
		else
		{
			SetErrPackage("DoAbortRead::AbortRead", m_csDevNo, eErr, MEC_DEVAPI_CARDSWIPER_AbortRead);
			AlarmDEC();
			return 1;
		}
	}
	DbgInfo("Not reading situation, ignore it.");

	return -1;
}
int CCardSwiperFSM::Eject()
{
	LOG_FUNCTION();
	int ret = 0;
	DWORD dwStart = GetTickCount();
	DWORD dwEnd = dwStart;
	ErrorCodeEnum eErr = Error_Unexpect;
	long l_beginTime, l_endTime;

	l_beginTime = GetTickCount();
	eErr = m_hDevHelper->EjectCard(CI_MOVECARD_FRONT_GATE);
	l_endTime = GetTickCount();
	DbgInfo("EjectCard", l_beginTime, l_endTime, eErr, "CI_MOVECARD_FRONT_GATE");

	if (eErr == Error_Succeed)
	{
		//for RVC.Desk2S
		//oilyang@20200426 add Desk1S
		if (_strnicmp(m_rvcsysInfo.strMachineType.GetData(), "RVC.Desk2S", strlen("RVC.Desk2S")) == 0
			|| _strnicmp(m_rvcsysInfo.strMachineType.GetData(), "RVC.Desk1S", strlen("RVC.Desk1S")) == 0)
			LogEvent(Severity_Middle, LOG_EVT_CARDREADER_GREEN_ON, "CardReader(MAG) warning on");

		while (1)
		{
			if (m_bExit)
			{
				DbgInfo("bExit == true.");
				ret = 2;
				break;
			}
			dwEnd = GetTickCount();
			if ((dwEnd - dwStart) > 58 * 1000)
			{
				DbgInfo("TickCount timeout.");
				ret = 2;
				break;
			}

			l_beginTime = GetTickCount();
			eErr = m_hDevHelper->GetDevStatus(devStatus);
			l_endTime = GetTickCount();
			DbgInfo(CSimpleStringA::Format("GetDevStatus", l_beginTime, l_endTime, eErr, CSimpleStringA::Format("eMedia:%d", devStatus.eMedia)));

			if (eErr == Error_Succeed)
			{
				if (devStatus.eMedia != CI_MEDIA_IC && devStatus.eMedia != CI_MEDIA_NOT_IC
					&& devStatus.eMedia != CI_MEDIA_RF && devStatus.eMedia != CI_MEDIA_IDCARD
					&& devStatus.eMedia != CI_MEDIA_ENTERING)
				{
					ret = 0;
					break;
				}
			}
			Sleep(100);
		}
		//for RVC.Desk2S
		//oilyang@20200426 add Desk1S
		if (_strnicmp(m_rvcsysInfo.strMachineType.GetData(), "RVC.Desk2S", strlen("RVC.Desk2S")) == 0
			|| _strnicmp(m_rvcsysInfo.strMachineType.GetData(), "RVC.Desk1S", strlen("RVC.Desk1S")) == 0)
			LogEvent(Severity_Middle, LOG_EVT_CARDREADER_GREEN_OFF, "CardReader(MAG) warning off.");
		return ret;
	}
	else
	{
		SetErrPackage("Eject::EjectCard(CI_MOVECARD_FRONT_GATE)", m_csDevNo, eErr, MEC_DEVAPI_CARDSWIPER_EjectCard);
		AlarmDEC();
		return 2;
	}
}
int CCardSwiperFSM::QueryConnInfo(int nFlag /* = 0*/)
{
	LOG_FUNCTION();
	//if (m_bReading)
	{
		//	return 1;
	}
	//return 1;//oiltest 20160421
	m_connChecking = true;
	int OldFlag = nFlag;
	int online = 0, everOnline = 0;
	ErrorCodeEnum eErr = Error_Unexpect, eEverErr = Error_Unexpect;
	int preConnStatus = -1, count = 0, getBatteryCount = 0;
	m_bCancelQueryConn = false;
	while (!m_bCancelQueryConn)
	{
		if (m_hDevHelper == nullptr)
		{
			break;
		}
		if (m_bFWBOpenSucEver)
			getBatteryCount++;
		else
			getBatteryCount = 0;
		//if (!m_bReading && m_bInMainPage)
		if (!m_bReading && m_bOpened && !m_bDoingBindFWB)
		{
			EnterCriticalSection(&g_csCntStatus);
			//Dbg("to call IfDevOnline");
			eErr = m_hDevHelper->IfDevOnline(online);
			//oilyang@20200922 之前给厂商加日志，投产时需要加条件去掉没有变化时的日志输出
			if (eErr != eEverErr || online != everOnline)
			{
				eEverErr = eErr;
				everOnline = online;
				DbgInfo(CSimpleStringA::Format("QueryConnInfo::IfDevOnline, eErr:%d, online:%d", eErr, online));
			}
			if (eErr == Error_Succeed && online == 1)
			{
				//oilyang@20200618 add 
				if (m_bFWBOpenSucEver)
				{
					if ((getBatteryCount % 150) == 0 && m_bFWBOpenSucEver)//2000(ms)*150 = 5 minutes
					{
						DbgInfo("to get battery status");
						FWBStatus fwbStatus;
						eErr = m_hDevHelper->GetBatteryStatus(fwbStatus);
						if (eErr == Error_Succeed)
						{
							getBatteryCount = 0;
							if (fwbStatus.BatteryLeft > 0 && fwbStatus.BatteryLeft <= 100)
							{
								DbgInfo(CSimpleStringA::Format("fwb battery left:%d", fwbStatus.BatteryLeft));
								char buf[32] = { 0 };
								sprintf_s(buf, "fwb battery left:%d", fwbStatus.BatteryLeft);
								LogEvent(Severity_Low, LOG_EVT_BATTERY_LEFT, buf);
							}
						}
					}
				}

				if (preConnStatus != m_connStatus)
				{
					preConnStatus = 1;
					SendDevStatusMsg(1);
					DbgInfo("设备连接正常");
					if (!m_bDoingBindFWB)//oilyang@20200407 being in BindFWB,no need to post event
						PostEventFIFO(new FSMEvent(USER_EVT_DEV_CONNECTED));
				}
				m_connStatus = 1;
			}
			else
			{
				if (preConnStatus != m_connStatus)
				{
					preConnStatus = 0;
					SendDevStatusMsg(0);
					DbgWarn("设备连接断开");
					PostEventFIFO(new FSMEvent(USER_EVT_DEV_DISCONNECTED));
				}
				m_connStatus = 0;
			}
			LeaveCriticalSection(&g_csCntStatus);

			if (m_connStatus == 1)
			{
				if (m_bNeedInitCh)
				{
					count++;
				}
				else
					count = 0;

				int newFlag = GetAAState();
				if (newFlag == 0)
				{
					if (count > 60)//60*2 = 120s,两分钟
					{
						DbgInfo("两分钟内通道未建立，再次尝试建立");
						OldFlag = ProcessEnChannel();
						count = 0;
					}
					else if (count != 0 && OldFlag != 0)
					{
						DbgInfo("准入状态成功，再次尝试建立");
						OldFlag = ProcessEnChannel();
						count = 0;
					}
				}
			}
		}
		Sleep(2000);
	}
	m_connChecking = false;
	return 0;
}

int CCardSwiperFSM::TransInitEx(bool bPassvie/* = false*/)
{
	LOG_FUNCTION();
	AccessAuthService_ClientBase* pAccessAuthClient = new AccessAuthService_ClientBase(GetEntityBase());
	if (pAccessAuthClient == NULL)
	{
		DbgWarn(CSimpleStringA::Format("<TransInitEx>, new AccessAuthService_ClientBase failed."));
		return -1;
	}
	ErrorCodeEnum eErr = pAccessAuthClient->Connect();
	if (eErr != Error_Succeed)
	{
		LogWarn(Severity_Middle, eErr, CardSwiper_UserErrorCode_CONNECT_ACCESS_FAILED, "TransInitEx:connect to Entity AccessAuth failed");
		return -1;
	}
	DbgInfo("<TransInitEx>, Connect to AccessAuth ok.");
	ZeroMemory(m_priKey, ONE_K / 2);
	//AsciiToHex("16E532957F1F107F794C1F8157CC768A72BD425B6F425B3C67153DB9082B7F45", m_priKey, strlen("16E532957F1F107F794C1F8157CC768A72BD425B6F425B3C67153DB9082B7F45"));
	memcpy(m_priKey, "16E532957F1F107F794C1F8157CC768A72BD425B6F425B3C67153DB9082B7F45", strlen("16E532957F1F107F794C1F8157CC768A72BD425B6F425B3C67153DB9082B7F45"));
	int iStatus;
	BYTE* Cr1, * Cr3, * dKey;
	Cr1 = new BYTE[ONE_K / 4];
	Cr3 = new BYTE[ONE_K / 4];
	dKey = new BYTE[ONE_K / 4];
	ZeroMemory(Cr1, ONE_K / 4);
	ZeroMemory(Cr3, ONE_K / 4);
	ZeroMemory(dKey, ONE_K / 4);
	int lenCr1, lenCr3, lenDKey;
	bool bFirstFailed = false;

	long l_beginTime, l_endTime;
	l_beginTime = GetTickCount();
	eErr = m_hDevHelper->TransferEnInit(iStatus, Cr1, lenCr1, Cr3, lenCr3, dKey, lenDKey);
	l_endTime = GetTickCount();
	DbgInfo(CSimpleStringA::Format("TransferEnInit", l_beginTime, l_endTime, eErr, CSimpleStringA::Format("iStatus:%d, lenCr1:%d, lenCr3:%d, lenDKey:%d",
		iStatus, lenCr1, lenCr3, lenDKey)));

	if (eErr != Error_Succeed)
	{
		SetErrPackage("TransInitEx::TransferEnInit", m_csDevNo, eErr, MEC_DEVAPI_CARDSWIPER_TransferEnInit);
		AlarmDEC();
		return 1;
	}

	if (lenCr1 < 0 || lenCr3 < 0 || lenDKey < 0)
	{
		SetErrPackage("TransInitEx::TransferEnInit:lenErr", m_csDevNo, eErr, MEC_DEVAPI_CARDSWIPER_TransferEnInit);
		AlarmDEC();
		return 1;
	}
	ZeroMemory(m_r1, ONE_K / 8);
	char tmpCr1[2048], tmpCr3[2048], tmpDKey[2048];
	ZeroMemory(tmpCr1, ONE_K * 2);
	SP::Module::Util::ConvAscii(Cr1, tmpCr1, lenCr1);
	ZeroMemory(tmpCr3, ONE_K * 2);
	SP::Module::Util::ConvAscii(Cr3, tmpCr3, lenCr3);
	ZeroMemory(tmpDKey, ONE_K * 2);
	SP::Module::Util::ConvAscii(dKey, tmpDKey, lenDKey);

	char random_key[128];
	unsigned char tbuf[4096];
	int iloop;
	//取随机因子
	srand((int)time(NULL));
	for (iloop = 0; iloop < 32; iloop++)
		tbuf[iloop] = rand() % 256;
	SP::Module::Util::ConvAscii(tbuf, random_key, 32);
	//随机数2

	BYTE r2[16];
	ZeroMemory(r2, 16);
	for (int i = 0; i < 15; ++i)
	{
		unsigned int ram;
		int ret = rand_s(&ram);
		r2[i] = ram % 256;
		r2[15] ^= r2[i];
		m_r2[i] = r2[i];
	}
	m_r2[15] = r2[15];
	char* xxxR2 = new char[256];
	ZeroMemory(xxxR2, 256);
	SP::Module::Util::ConvAscii(r2, xxxR2, 16);

	AccessAuthService_InitDev_Req req;
	AccessAuthService_InitDev_Ans ans;
	req.EncR1 = tmpCr1;
	req.EncR3 = tmpCr3;
	req.EncDevPubKey = tmpDKey;
	req.R2 = xxxR2;
	//oiltmp@20200413 as the Vendor(grg) set the szVendor in wild disorder
	if (_strnicmp("GrgBanking", m_devCat.szVendor, strlen("GrgBanking")) == 0)
		req.Vendor = "grg";
	else
		req.Vendor = m_devCat.szVendor;
	DbgInfo(CSimpleStringA::Format("<TransInitEx>, to InitDev(%s).", req.Vendor.GetData()));
	eErr = (*pAccessAuthClient)(EntityResource::getLink().upgradeLink())->InitDev(req, ans, 5000);
	if (eErr != Error_Succeed)
	{
		LogWarn(Severity_Middle, eErr, CardSwiper_UserErrorCode_ACCESS_INITDEV_FAILED, "InitDev from AccessAuth returned failed.");
		if (Cr1 != NULL)
			delete[]Cr1;
		if (Cr3 != NULL)
			delete[]Cr3;
		if (dKey != NULL)
			delete[]dKey;
		return -1;
	}
	DbgInfo("<TransInitEx>, InitDev ok.");
	if (Cr1 != NULL)
		delete[]Cr1;
	if (Cr3 != NULL)
		delete[]Cr3;
	if (dKey != NULL)
		delete[]dKey;
	//Dbg("Cr2:%d,%s",ans.EncR2.GetLength(),(const char*)ans.EncR2);
	//Dbg("oiltest %s,%s",(const char*)ans.R1,(const char*)ans.R3);
	unsigned char* xxxCR2 = new unsigned char[512];
	ZeroMemory(xxxCR2, 512);
	SP::Module::Util::AsciiToHex(const_cast<char*>(ans.EncR2.GetData()), xxxCR2, ans.EncR2.GetLength());

	l_beginTime = GetTickCount();
	eErr = m_hDevHelper->SetR2(iStatus, xxxCR2, ans.EncR2.GetLength() / 2);
	l_endTime = GetTickCount();
	DbgInfo("SetR2", l_beginTime, l_endTime, eErr, CSimpleStringA::Format("iStatus:%d, ans.EncR2 len:%d", iStatus, ans.EncR2.GetLength()));

	if (eErr != Error_Succeed)
	{
		SetErrPackage("TransInitEx::SetR2", m_csDevNo, eErr, MEC_DEVAPI_CARDSWIPER_SetR2);
		AlarmDEC();
		return 3;
	}
	DbgInfo("Set R2 ok.");
	//oilyang@20220915 因为国密改造，推迟启动其他实体到加密通道建立成功
	if (IsValidFWBName((const char*)m_csDevNo, m_csDevNo.GetLength()))
	{
		LogEvent(Severity_High, LOG_EVT_CARDREADER_OPEN_SUC_FWB, CSimpleStringA::Format("FWB %s (CardSwiper)open suc.", m_csDevNo.GetData()));
		GetEntityBase()->GetFunction()->SetSysVar("FWBDevSN", m_csDevNo);
		GetEntityBase()->GetFunction()->SetSysVar("FWBReConn", "Y");
		StartEntity("PinPad", m_bFWBOpenSucEver);
		StartEntity("IDCertificate", m_bFWBOpenSucEver);
		StartEntity("FingerPrint", m_bFWBOpenSucEver);
	}
	SP::Module::Util::AsciiToHex(const_cast<char*>(ans.R1.GetData()), m_r1, ans.R1.GetLength());
	SP::Module::Util::AsciiToHex(const_cast<char*>(ans.R3.GetData()), m_r3, ans.R3.GetLength());
	int lenrandom1, lenrandom2, lenrandom3;
	lenrandom1 = lenrandom2 = lenrandom3 = 16;

	int ilen = 0;
	char databuf[2048];
	char key[128];

	memset(databuf, 0, sizeof(databuf));
	memset(tbuf, 0, sizeof(tbuf));

	memcpy(databuf, m_r2, lenrandom2);
	for (iloop = 0; iloop < 64; iloop++)
		databuf[iloop] ^= 0x5C;
	memcpy(tbuf, m_r2, lenrandom2);
	for (iloop = 0; iloop < 64; iloop++)
		tbuf[iloop] ^= 0x36;
	ilen = 64;
	memcpy(tbuf + ilen, "KEY", strlen("KEY"));
	ilen += strlen("KEY");
	memcpy(tbuf + ilen, m_r1, lenrandom1);
	ilen += lenrandom1;
	memcpy(tbuf + ilen, m_r3, lenrandom3);
	ilen += lenrandom3;
	DbgInfo("use new sm implementation");
	SM3Hash((unsigned char*)tbuf, ilen, (unsigned char*)(databuf + 64));
	SM3Hash((unsigned char*)databuf, 96, (unsigned char*)key);
	char* sessionKey = new char[1024];
	ZeroMemory(sessionKey, 1024);
	HexBuf2StrBuf((unsigned char*)key, &sessionKey, 16);
	//Dbg("oiltest key[%s]", sessionKey);

	l_beginTime = GetTickCount();
	eErr = m_hDevHelper->SendWorkingKey(sessionKey);
	l_endTime = GetTickCount();
	DbgInfo("SendWorkingKey", l_beginTime, l_endTime, eErr, CSimpleStringA::Format("sessionKey len:%d", strlen(sessionKey)));

	if (eErr != Error_Succeed)
	{
		SetErrPackage("TransInitEx::SendWorkingKey", m_csDevNo, eErr, MEC_DEVAPI_CARDSWIPER_SendWorkingKey);
		AlarmDEC();
		return 4;
	}
	m_bNeedInitCh = false;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR0402202Z101")("加密通道建立成功");
	return 0;
}
int CCardSwiperFSM::SplitDevModelInfo()
{
	LOG_FUNCTION();
	DbgInfo(CSimpleStringA::Format("<SplitDevModelInfo>, szModel:%s", m_devCat.szModel));
	if (strlen(m_devCat.szModel) < 3)
	{
		DbgWarn(CSimpleStringA::Format("Wrong szModel:%s", m_devCat.szModel));
		return -1;
	}
	m_csCM = m_csPM = "";
	CSimpleStringA csTmpModel(m_devCat.szModel);
	CAutoArray<CSimpleStringA> arrParam;
	arrParam.Init(16);
	arrParam = csTmpModel.Split('#');
	for (int i = 0; i < arrParam.GetCount(); ++i)
	{
		if (_strnicmp(arrParam[i], "CM", 2) == 0)
		{
			m_csCM = arrParam[i].SubString(3, arrParam[i].GetLength() - 3);
		}
		if (_strnicmp(arrParam[i], "PM", 2) == 0)
		{
			m_csPM = arrParam[i].SubString(3, arrParam[i].GetLength() - 3);
		}
	}
	return 0;
}
int CCardSwiperFSM::ProcessEnChannel(bool bIgnore/* = false*/)
{
	int ret = 0;
	long l_beginTime, l_endTime;
	EnterCriticalSection(&g_csChannelStatus);

	if (IsCryptMachinaType() && m_bNeedInitCh)
	{
		if (m_nSplitRes == -1)
		{
			l_beginTime = GetTickCount();
			ErrorCodeEnum erroCode = m_hDevHelper->GetDevCategory(m_devCat);
			l_endTime = GetTickCount();
			DbgInfo("GetDevCategory", l_beginTime, l_endTime, erroCode, CSimpleStringA::Format("szModel:%s", m_devCat.szModel));

			if (erroCode != Error_Succeed)
			{
				SetErrPackage("ProcessEnChannel::GetDevCategory", m_csDevNo, erroCode, MEC_DEVAPI_CARDSWIPER_GetDevCategory);
				AlarmDEC();
			}
			m_nSplitRes = SplitDevModelInfo();
		}
		DbgInfo(CSimpleStringA::Format("m_csCM len:%d, m_csCM:%s, %d", m_csCM.GetLength(), m_csCM.GetData(), strlen("V2.0")));
		if (m_csCM.GetLength() > 3 && _strnicmp(m_csCM, "V2.0", strlen("V2.0")) == 0)
		{
			DbgInfo("传输加密方案V2");
			if (!bIgnore)
			{
				int nStatus = GetAAState();
				if (nStatus != 0)
				{
					DbgWarn(CSimpleStringA::Format("准入状态无效：%d", nStatus));
					LeaveCriticalSection(&g_csChannelStatus);
					return nStatus;
				}
			}
			ret = TransInitEx();
			DbgInfo(CSimpleStringA::Format("<ProcessEnChannel>, TransInitEx return:%d", ret));

			if (ret != 0)
			{
				ShowFatalrForTransferChannel(2);
			}
			else
			{
				ShowFatalrForTransferChannel(2, FALSE);
			}
		}
	}
	LeaveCriticalSection(&g_csChannelStatus);
	return 0;
}
int CCardSwiperFSM::GetAccessAuthState()
{
	int nRes = -1;
	HealthMngClient* pClient = new HealthMngClient(this->GetEntityBase());
	if (pClient != NULL)
	{
		ErrorCodeEnum ec = pClient->Connect();
		if (ec != Error_Succeed)
		{
			pClient->SafeDelete();
			pClient = NULL;
			LogWarn(Severity_Middle, ec, CardSwiper_UserErrorCode_CONNECT_HEALTH_FAILED, "Connect to HealthManager entity failed");
			return nRes;
		}
		HealthManagerService_GetNetworkState_Req req;
		HealthManagerService_GetNetworkState_Ans ans;
		ans.reserved1 = 0;
		ec = pClient->GetNetworkState(req, ans, 5000);
		if (ec == Error_Succeed)
		{
			nRes = ans.reserved1;
			DbgInfo(CSimpleStringA::Format("AccessAuth state(reserved1): %d", nRes));
		}
		else
		{
			DbgWarn(CSimpleStringA::Format("GetNetworkState from HealthManager failed 0x%x.", ec));
		}
		pClient->GetFunction()->CloseSession();
		pClient->SafeDelete();
		pClient = NULL;
	}
	return nRes;
}

void CCardSwiperFSM::SetAAState(int val)
{
	DbgInfo(CSimpleStringA::Format("Start to Set accessauth state: %d", val));
	EnterCriticalSection(&g_csAuthAccessStatus);
	m_nAAStatus = val;
	DbgInfo(CSimpleStringA::Format("Real Set accessauth state: %d", m_nAAStatus));
	LeaveCriticalSection(&g_csAuthAccessStatus);
}
void CCardSwiperFSM::SetAcceptWaitMore(bool bValue)
{
	if (bValue)
	{
		if (m_bReading)
		{
			if (m_bWaitAccepteMore)
				m_bResetInsertMore = true;
			else
			{
				DbgInfo("to wait more...");
				InsertWaitMoreTask* pTask = new InsertWaitMoreTask(this);
				GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
			}
			m_bWaitAccepteMore = true;
		}
	}
	else
		m_bWaitAccepteMore = false;
}
void CCardSwiperFSM::InsertWaitMore()
{
	LOG_FUNCTION();
	INT64 iStart = GetTickCount64();
	INT64 iEnd = GetTickCount64();
	while ((iEnd - iStart) < 60 * 1000)
	{
		if (m_bCancelRead || !m_bReading)
		{
			DbgInfo(CSimpleStringA::Format("bCancelRead %d or m_bReading %d ", m_bCancelRead, m_bReading));
			SetAcceptWaitMore(false);
			return;
		}
		if (m_bResetInsertMore)
		{
			iStart = GetTickCount64();
			m_bResetInsertMore = false;
		}
		Sleep(1000);
		iEnd = GetTickCount64();
	}
	DbgInfo("InsertWaitMore timeout,to call AbortRead.");
	SetAcceptWaitMore(false);
	if (m_hDevHelper)
	{
		ErrorCodeEnum eErr = m_hDevHelper->AbortRead();
		if (eErr != Error_Succeed) {
			SetErrPackage("InsertWaitMore::AbortRead", m_csDevNo, eErr, MEC_DEVAPI_CARDSWIPER_AbortRead);
			AlarmDEC();
		}
	}
}
int CCardSwiperFSM::IsValidFWBName(const char* pName, int len)
{
	//设备唯一标识：约定序列号以厂商简称的大写形式开头（两个字母，避免重复，需报备行方）
	//+“FWB” + “A” + 6 位顺序序号，如：SZ-FWB-A000001，其中“SZ”是厂家简称，“A”为迭代版
	//	本，分隔符为“ - ”（短横杠），共 14 个字符
	//厂商 xxx
	if (len != 14)
		return 0;
	if (_strnicmp(pName + 3, "FWB", 3) == 0)
		return 1;
	else
		return 0;
}
void CCardSwiperFSM::AddToFWBRecords(const char* name, const char* remoteMac, bool bFirst)
{
	EnterCriticalSection(&g_csFwbRecord);
	if (bFirst) {
		m_vFWBRecords.clear();
	}
	FWBRecord record;
	record.name = name;
	record.remoteMac = remoteMac;
	m_vFWBRecords.push_back(record);
	DbgInfo(CSimpleStringA::Format("<AddToFWBRecords>, the %dth sci,name is:%s", m_vFWBRecords.size(), name));
	LeaveCriticalSection(&g_csFwbRecord);
}

void CCardSwiperFSM::ClearFWBRecords()
{
	EnterCriticalSection(&g_csFwbRecord);
	m_vFWBRecords.clear();
	LeaveCriticalSection(&g_csFwbRecord);
	return;
}

int CCardSwiperFSM::nameToBthAddr(bool isSearchNearBy)
{
	LOG_FUNCTION();
	BLUETOOTH_DEVICE_INFO bdi = { sizeof(BLUETOOTH_DEVICE_INFO) };
	BLUETOOTH_DEVICE_SEARCH_PARAMS bdsp;
	HBLUETOOTH_DEVICE_FIND hbf;
	//find hRadio
	HANDLE hRadio = NULL;
	BLUETOOTH_FIND_RADIO_PARAMS btfrp = { sizeof(btfrp) };

	HBLUETOOTH_RADIO_FIND hFind = BluetoothFindFirstRadio(&btfrp, &hRadio);
	int countHRadio = 0;
	if (NULL != hFind)
	{
		do
		{
			DbgInfo("BluetoothFindNextRadio");
			if (hRadio)
			{
				DbgInfo("BluetoothGetRadioInfo");
				BLUETOOTH_RADIO_INFO LocalRadioInfo = { sizeof(LocalRadioInfo) };
				if (ERROR_SUCCESS == BluetoothGetRadioInfo(hRadio, &LocalRadioInfo))
				{
					char output[256];
					ZeroMemory(output, 256);
					sprintf(output, "%ws", LocalRadioInfo.szName);
					DbgInfo(CSimpleStringA::Format("LocalRadioInfo.szName: %s, deviceClass:%d", output, LocalRadioInfo.ulClassofDevice));
					countHRadio++;
				}
			}
		} while (BluetoothFindNextRadio(hFind, &hRadio));
		//BluetoothFindRadioClose(hFind);
	}
	else
		DbgWarn("BluetoothFindFirstRadio faled.");
	DbgInfo("the end of BluetoothGetRadioInfo");
	//bdsp.hRadio
	//A handle for the radio on which to perform the inquiry.Set to NULL to perform the inquiry on all local Bluetooth radios.
	if (countHRadio > 1)
		hRadio = NULL;

	ZeroMemory(&bdsp, sizeof(BLUETOOTH_DEVICE_SEARCH_PARAMS));
	if (isSearchNearBy)
	{
		bdsp.dwSize = sizeof(BLUETOOTH_DEVICE_SEARCH_PARAMS);
		bdsp.hRadio = hRadio;
		bdsp.fReturnAuthenticated = TRUE;
		bdsp.fReturnRemembered = FALSE;
		bdsp.fReturnUnknown = TRUE;
		bdsp.fReturnConnected = FALSE;
		bdsp.fIssueInquiry = TRUE;
		bdsp.cTimeoutMultiplier = 4;// 4 * 1.28  s 用于搜索蓝牙的时间，经验值

	}
	else {
		bdsp.dwSize = sizeof(BLUETOOTH_DEVICE_SEARCH_PARAMS);
		bdsp.hRadio = hRadio;//设置执行搜索设备所在的句柄，应设为执行BluetoothFindFirstRadio函数所得到的句柄
		bdsp.fReturnAuthenticated = true;//是否搜索已配对的设备 
		bdsp.fReturnRemembered = false;//是否搜索已记忆的设备  
		bdsp.fReturnUnknown = false;//是否搜索未知设备 
		bdsp.fReturnConnected = false;//是否搜索已连接的设备
		bdsp.fIssueInquiry = false;//是否重新搜索，True的时候会执行新的搜索，时间较长，FALSE的时候会直接返回上次的搜索结果。
		bdsp.cTimeoutMultiplier = 2;//指示查询超时的值，以1.28秒为增量。 例如，12.8秒的查询的cTimeoutMultiplier值为10.此成员的最大值为48.当使用大于48的值时，调用函数立即失败并返回 
	}
	DbgInfo("start to BluetoothFindFirstDevice");
	hbf = BluetoothFindFirstDevice(&bdsp, &bdi);
	if (hbf == NULL)
	{
		DbgWarn(CSimpleStringA::Format("BluetoothFindFirstDevice failed,GetLastError:%d", GetLastError()));
		return 1;
	}
	char output[256];
	bool bFirst = false;
	while (true) {
		ZeroMemory(output, 256);
		sprintf(output, "%ws", bdi.szName);
		DbgInfo(CSimpleStringA::Format("find a device:%s", output));
		if (IsValidFWBName(output, strlen(output)))
		{
			DbgInfo(CSimpleStringA::Format("find a fwb: %s", output));
			AddToFWBRecords(output, "xx", bFirst);

			bFirst = false;
		}
		if (!BluetoothFindNextDevice(hbf, &bdi))
			break;
	}
	DbgInfo("BluetoothFindDeviceClose");
	BluetoothFindDeviceClose(hbf);
	return 0;
}
int CCardSwiperFSM::ScanNearbyBTDevice()
{
	LOG_FUNCTION();
	//oiltest@20200325
	ClearFWBRecords();
	nameToBthAddr(true);
	return 0;

	ClearFWBRecords();
	WSADATA m_data;
	SOCKET s;
	WSAPROTOCOL_INFO protocolInfo;
	int protocolInfoSize;
	WSAQUERYSET querySet, * pResults, querySet2;
	HANDLE hLookup;
	int result;
	static int i;
	BYTE buffer[1000];
	DWORD bufferLength, flags, addressSize;
	CSADDR_INFO* pCSAddr;
	BTH_DEVICE_INFO* pDeviceInfo;
	char addressAsString[2000];
	GUID protocol;

	// Load the winsock2 library
	if (WSAStartup(MAKEWORD(2, 2), &m_data) == 0)
	{
		// Create a blutooth socket
		s = socket(AF_BTH, SOCK_STREAM, BTHPROTO_RFCOMM);
		if (s == INVALID_SOCKET)
		{
			DbgWarn(CSimpleStringA::Format("Failed to get bluetooth socket with error code %ld", WSAGetLastError()));
			return -1;
		}

		protocolInfoSize = sizeof(protocolInfo);
		// Get the bluetooth device info using getsockopt()
		if (getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFO, (char*)&protocolInfo, &protocolInfoSize) != 0)
		{
			DbgWarn(CSimpleStringA::Format("getsockopt(SO_PROTOCOL_INFO) failed with error code %ld", WSAGetLastError()));
			return -1;
		}
		// Query set criteria
		memset(&querySet, 0, sizeof(querySet));
		querySet.dwSize = sizeof(querySet);
		querySet.dwNameSpace = NS_BTH;

		// Set the flags for query
		//LUP_RETURN_BLOB
		//flags = LUP_RETURN_NAME | LUP_CONTAINERS | LUP_RETURN_ADDR | LUP_NEAREST |
		//	LUP_RETURN_TYPE |   LUP_RES_SERVICE;
		flags = LUP_CONTAINERS | LUP_FLUSHCACHE;
		DbgInfo("Start a device in range query...");
		result = WSALookupServiceBegin(&querySet, flags, &hLookup);
		//if (WSAGetLastError() == 10108 && m_bBTConncting) {//oiltest@20200310
		if (WSAGetLastError() == 10108) {
			WSASetLastError(10108);
			const int maxWaitTimes = 12;
			int currentWaitTimes = 0;
			//oiltest comment the following lines
			//do {
			//	Dbg("waiting bluetooth connect operation finish...");
			//	Sleep(800);
			//	currentWaitTimes++;
			//	if (currentWaitTimes >= maxWaitTimes) {
			//		Dbg("Timeout break");
			//		break;
			//	}
			//} while (m_bBTConncting);
			memset(&querySet, 0, sizeof(querySet));
			querySet.dwSize = sizeof(querySet);
			querySet.dwNameSpace = NS_BTH;
			result = WSALookupServiceBegin(&querySet, flags, &hLookup);
		}

		bool bFirst = false;//oilyang@20170802 暂时不用
		if (result == 0)
		{
			i = 0;
			//sockaddr *pRemoteAddr = new sockaddr();
			while (result == 0)
			{
				bufferLength = sizeof(buffer);
				pResults = (WSAQUERYSET*)&buffer;
				// Next query...
				flags = LUP_RETURN_NAME | LUP_RETURN_ADDR | LUP_NEAREST |
					LUP_RETURN_TYPE | LUP_RES_SERVICE;
				result = WSALookupServiceNext(hLookup, flags, &bufferLength, pResults);
				if (result != 0)
				{
					DbgWarn(CSimpleStringA::Format("WSALookupServiceNext() failed with error code %ld", WSAGetLastError()));
				}
				else
				{
					// Get the device info, name, address etc
					// if (IsValidSCIName(pResults->lpszServiceInstanceName, strlen(pResults->lpszServiceInstanceName)))
					// {
					// }
					pCSAddr = (CSADDR_INFO*)pResults->lpcsaBuffer;
					pDeviceInfo = (BTH_DEVICE_INFO*)pResults->lpBlob;
					memset(&querySet2, 0, sizeof(querySet2));
					querySet2.dwSize = sizeof(querySet2);
					protocol = L2CAP_PROTOCOL_UUID;
					querySet2.lpServiceClassId = &protocol;
					querySet2.dwNameSpace = NS_BTH;

					if (strlen(pResults->lpszServiceInstanceName) > 0) {
						DbgInfo(CSimpleStringA::Format("instance name: %s,protocol:%d,socket type:%d",
							pResults->lpszServiceInstanceName, pCSAddr->iProtocol, pCSAddr->iSocketType));
					}

					addressSize = sizeof(addressAsString);
					// Print the remote bluetooth device address...
					if (WSAAddressToString(pCSAddr->RemoteAddr.lpSockaddr, pCSAddr->RemoteAddr.iSockaddrLength,
						&protocolInfo, (LPSTR)addressAsString, &addressSize) == 0)
					{
						if (IsValidFWBName(pResults->lpszServiceInstanceName, strlen(pResults->lpszServiceInstanceName)))
						{
							DbgInfo(CSimpleStringA::Format("The remote device address: %s", addressAsString));
							AddToFWBRecords(pResults->lpszServiceInstanceName, addressAsString, bFirst);

							bFirst = false;
						}

					}
					else {
						DbgWarn(CSimpleStringA::Format("WSAAddressToString() for remote address failed with error code %ld", WSAGetLastError()));
					}
				}
			}
			// Close handle to the device query
			if (WSALookupServiceEnd(hLookup) == 0) {
				DbgInfo("WSALookupServiceEnd(hLookup) is fine!");
			}
			else {
				DbgWarn(CSimpleStringA::Format("WSALookupServiceEnd(hLookup) failed with error code %ld", WSAGetLastError()));
			}
		}
		else
		{
			DbgWarn(CSimpleStringA::Format("WSALookupServiceBegin() failed with error code %ld", WSAGetLastError()));
		}// end WSALookupServiceBegin()
		// Cleanup the winsock library startup

		if (WSACleanup() == 0) {
			DbgInfo("WSACleanup() fine!");
		}
		else {
			DbgWarn(CSimpleStringA::Format("WSACleanup() failed with error code %ld", WSAGetLastError()));
		}
	} // end WSAStartup()
	return 0;

}
int CCardSwiperFSM::QueryFWBList(SpReqAnsContext<CardSwiperService_QueryFWBList_Req, CardSwiperService_QueryFWBList_Ans>::Pointer ctx, int fsmState)
{
	LOG_FUNCTION();
	if (!m_bBTScan)
	{
		DbgInfo("to ScanNearbyBTDevice");
		m_bBTScan = true;
		ScanNearbyBTDevice();
		m_bBTScan = false;
	}
	DbgInfo(CSimpleStringA::Format("have %d FWB Device.", m_vFWBRecords.size()));

	EnterCriticalSection(&g_csFwbRecord);
	if (m_vFWBRecords.size() > 0)
		ctx->Ans.fwbNo.Init(m_vFWBRecords.size());
	vector<FWBRecord>::iterator it;
	for (it = m_vFWBRecords.begin(); it != m_vFWBRecords.end(); it++)
	{
		ctx->Ans.fwbNo.Append(&(it->name), 0, 1);
	}
	LeaveCriticalSection(&g_csFwbRecord);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220210")("查询蓝牙多合一列表成功");
	ctx->Answer(Error_Succeed);
	return fsmState;
}

int CCardSwiperFSM::BindFWB(SpReqAnsContext<CardSwiperService_BindFWB_Req, CardSwiperService_BindFWB_Ans>::Pointer ctx, int fsmState)
{
	LOG_FUNCTION();
	m_bDoingBindFWB = true;
	DbgInfo(CSimpleStringA::Format("<BindFWB>, type:%d, frontBusiness fwbNo::%s, current devSN:%s, previous fsm state: %d",
		ctx->Req.type, ctx->Req.fwbNo.GetData(), m_csDevNo.GetData(), fsmState));

	ErrorCodeEnum eErr = Error_Unexpect;
	int ret = fsmState;;
	switch (ctx->Req.type)
	{//绑定类型：0：查询绑定，如果绑定则返回绑定设备序列号；1：绑定； 2：解绑
	case 0://查询绑定，如果绑定则返回绑定设备序列号
		ctx->Ans.fwbNo = "";
		if (IsValidFWBName(m_csDevNo.GetData(), m_csDevNo.GetLength()))
		{
			ctx->Ans.fwbNo = m_csDevNo;
		}
		ctx->Answer(Error_Succeed);
		break;
	case 1://绑定
		if (IsValidFWBName(m_csDevNo.GetData(), m_csDevNo.GetLength()))
		{
			DbgWarn(CSimpleStringA::Format("have already bind to %s", m_csDevNo.GetData()));
			ctx->Answer(Error_Duplication);
		}
		else
		{
			if (!IsValidFWBName(ctx->Req.fwbNo.GetData(), ctx->Req.fwbNo.GetLength()))
			{
				DbgWarn(CSimpleStringA::Format("frontBusiness fwbNo is invalid:%s", ctx->Req.fwbNo.GetData()));
				ctx->Answer(Error_Param);
			}
			else
			{
				ClearHandleOjbects();
				int retInit = Initial(ctx->Req.fwbNo, false);
				if (retInit == 0)
				{
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR040220211")("绑定%s成功", ctx->Req.fwbNo.GetData());
					AfterBindUpdateFWBNameToRunCfg(ctx->Req.fwbNo.GetData(), true);
					ctx->Answer(Error_Succeed);
					Sleep(3000);
					m_bNeedInitCh = true;
					ProcessEnChannel();
					ret = 2;
				}
				else
				{
					DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR040220211").setResultCode("RTA2203")("绑定后初始化蓝牙多合一失败");
					//ClearHandleOjbects();
					m_csDevNo = "";
					m_adapterInfo.strVendor = "";
					HARDWARE_ENTITY_SET_VENDOR_NAME(m_entCode, m_adapterInfo.strVendor);
					DbgWarn(CSimpleStringA::Format("bind fwb failed. ret:%d", retInit));
					ctx->Answer(TransECWithRepeat(Error_Unexpect), CardSwiper_UserErrorCode_After_Bind_FWB_Initial_Failed);
				}
			}
		}
		break;
	case 2://解绑
		if (m_csDevNo.GetLength() < 1)
		{
			DbgInfo("no bind relation in local.");
			ctx->Answer(Error_Succeed);
		}
		if (!IsValidFWBName(ctx->Req.fwbNo.GetData(), ctx->Req.fwbNo.GetLength())
			|| m_csDevNo.Compare(ctx->Req.fwbNo, true) != 0)
		{
			DbgWarn(CSimpleStringA::Format("the frontBusiness fwbNo is invalid:%s", ctx->Req.fwbNo.GetData()));
			ctx->Answer(Error_Param);
		}
		else
		{
			AfterBindUpdateFWBNameToRunCfg((const char*)ctx->Req.fwbNo, false);
			ClearHandleOjbects();
			GetEntityBase()->GetFunction()->SetSysVar("FWBReConn", "U");
			StartEntity("PinPad");
			StartEntity("IDCertificate");
			StartEntity("FingerPrint");
			ret = 0;
			ctx->Answer(Error_Succeed);
		}
		break;
	default:
		break;
	}
	m_bDoingBindFWB = false;
	return ret;
}
ErrorCodeEnum CCardSwiperFSM::AfterBindUpdateFWBNameToRunCfg(const char* name, bool bBind)
{
	LOG_FUNCTION();
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum eErrDev = spEntityFunction->OpenConfig(Config_Run, spConfig);
	if (eErrDev != Error_Succeed) {
		DbgWarn("(AfterBindUpdateFWBNameToRunCfg)open cfg file failed!");
		return eErrDev;
	}
	if (bBind)
	{
		CSimpleStringA csName(name);
		spConfig->WriteConfigValue("fwb", "devSN", name);
		CSimpleStringA csVendor = csName.SubString(0, 2);
		DbgInfo(CSimpleStringA::Format("fwb vendor: %s", csVendor.GetData()));
		spConfig->WriteConfigValue("fwb", "vendor", TransferAboutVendorShortName(csVendor).GetData());
	}
	else {
		spConfig->WriteConfigValue("fwb", "vendor", "");
		spConfig->WriteConfigValue("fwb", "devSN", "");
		GetEntityBase()->GetFunction()->SetSysVar("FWBVendor", "");
		GetEntityBase()->GetFunction()->SetSysVar("FWBDevSN", "");
		GetEntityBase()->GetFunction()->SetSysVar("FWBVersion", "");
		m_csDevNo = "";
	}
	return Error_Succeed;
}
//定期扫描，功能：
//1.搜索附近符合FWB规范的蓝牙，在业务取列表式，直接返回;对性能的影响？
//2.如果绑定过蓝牙多合一，而没有连接上，在搜索结果中发现对应序列号设备，定期尝试连接；
//3.如果蓝牙多合一已经连接上或者旧版多合一打开成功，不做任何事情
int CCardSwiperFSM::FWBBluetoothScanTask()
{
	while (1)
	{
		if (m_bDoingBindFWB)
		{
			Sleep(10 * 1000);
		}
		else if (m_bCallingDevOpenEx)
		{
			Sleep(10 * 1000);
		}
		else
		{
			if (!m_bBTScan)
			{
				m_bBTScan = true;
				ScanNearbyBTDevice();
				m_bBTScan = false;
			}
			else
				Sleep(10 * 1000);
		}
	}
	return 0;
}
void CCardSwiperFSM::ClearHandleOjbects()
{
	m_csDevNo = "";
	if (m_hDevHelper != nullptr)
	{
		DbgInfo("to clear m_hDevHelper");
		m_hDevHelper.TearDown();
		m_bOpened = false;
		m_bFWBOpenSucEver = false;
	}
	if (m_pCardProcess != NULL)
	{
		DbgInfo("to clear m_pCardProcess");
		delete m_pCardProcess;
	}
}
CSimpleStringA CCardSwiperFSM::TransferAboutVendorShortName(CSimpleStringA name)
{
	if (name.Compare("CT", true) == 0)
		return "Centerm";
	else if (name.Compare("GW", true) == 0)
		return "GWI";
	else if (name.Compare("NT", true) == 0)
		return "nantian";
	else
		return CSimpleStringA(name);
}

void CCardSwiperFSM::StartEntity(const char* pEntityName, bool bFWBOpenSucEver)
{
	DbgInfo(CSimpleStringA::Format("StartEntity [%s],bFWBOpenSucEver:%d", pEntityName, bFWBOpenSucEver));
	if (pEntityName == NULL || strlen(pEntityName) < 1)
		return;
	CSmartPointer<IEntityFunction> pFunc = GetEntityBase()->GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	CEntityRunInfo acInfo;
	ErrorCodeEnum eErrCode;
	eErrCode = pFunc->GetEntityRunInfo(pEntityName, acInfo);
	if (acInfo.eState == EntityState_Idle)//if in Idle state,left "FWBReConn" to trigger reconnect
		return;
	if (acInfo.eState == EntityState_NoStart || acInfo.eState == EntityState_Close || acInfo.eState == EntityState_Killed)
	{

		CSmartPointer<IAsynWaitSp> spWait;

		eErrCode = pFuncPrivilege->StartEntity(pEntityName, NULL, spWait);
		DbgInfo(CSimpleStringA::Format("start %s %d.", pEntityName, eErrCode));
		if (spWait != NULL)
			eErrCode = spWait->WaitAnswer(10000);
		DbgInfo(CSimpleStringA::Format("start %s wait %d", pEntityName, eErrCode));
	}
	else
	{
		CSmartPointer<IAsynWaitSp> spWait;
		eErrCode = pFuncPrivilege->TerminateEntity(pEntityName, spWait);
		if (spWait != NULL)
			eErrCode = spWait->WaitAnswer(10000);
		if (eErrCode != Error_Succeed)
		{
			DbgInfo(CSimpleStringA::Format("kill %s %d", pEntityName, eErrCode));
			return;
		}
		Sleep(3000);
		eErrCode = pFuncPrivilege->StartEntity(pEntityName, NULL, spWait);
		if (spWait != NULL)
			eErrCode = spWait->WaitAnswer(10000);
		if (eErrCode != Error_Succeed)
		{
			DbgInfo(CSimpleStringA::Format("start %s %d", pEntityName, eErrCode));
			return;
		}
	}
}
void CCardSwiperFSM::TodoReConn()
{
	m_bOpened = false;
	m_bFWBOpenSucEver = false;
	ClearHandleOjbects();
	FSMEvent* e = new FSMEvent(USER_EVT_INIT);
	PostEventFIFO(e);
}