myvtm/Module/mod_accessauth/AccessAuthFSM.cpp

#include "stdafx.h"
#include "AccessAuthFSM.h"
#include "mod_AccessAuth.h"

#ifdef RVC_OS_WIN
#include  <io.h>
#endif
#include  <stdio.h>
#include  <stdlib.h>

#include "comm.h"

CAccessAuthFSM::CAccessAuthFSM()
	:m_pConnection(NULL)
{
}

CAccessAuthFSM::~CAccessAuthFSM()
{
	m_iState = FSM_STATE_EXIT;		// 屏蔽退出ASSERT错误
}

void CAccessAuthFSM::OnStateTrans(int iSrcState, int iDstState)
{
	Dbg("trans from %s to %s", GetStateName(iSrcState), GetStateName(iDstState));
}

// 初始化PinPad及KMC
ErrorCodeEnum CAccessAuthFSM::OnInit()
{
	LOG_FUNCTION();
	AddStateHooker(this);
	m_finishAccess = 0;
	//设置初始锁定状态，0
	CSmartPointer<IEntityFunction> spFunction = m_pEntity->GetFunction();
	spFunction->SetSysVar("LockState", "0", true);
	
	ErrorCodeEnum Error = LoadCenterConfig();
	if (Error != Error_Succeed) 
	{
		LOG_TRACE("load CenterSetting.ini failed!");
	}	

	return Error_Succeed;
}

ErrorCodeEnum CAccessAuthFSM::OnExit()
{
	RemoveStateHooker(this);
	return Error_Succeed;
}

void CAccessAuthFSM::s1_on_entry()
{
	SetSysVar("I");
}

void CAccessAuthFSM::s1_on_exit()
{
}

unsigned int CAccessAuthFSM::s1_on_event(FSMEvent* pEvent)
{
	LOG_FUNCTION();
	Dbg("s1_on_event: %d", pEvent->iEvt);
	if (pEvent->iEvt == Event_ReportStage)
	{
		// 上报状态
		if (SecureClientConnect() == Error_Succeed)
		{
			ReportStateEvent *pReportEvent = (ReportStateEvent*)pEvent;
			m_pConnection->SendTerminalStagePackage(pReportEvent->cNewStage, pReportEvent->dwNewStageTime,
				pReportEvent->cOldStage, pReportEvent->dwOldStageTime);
		}
	}

	return 0;
}

ErrorCodeEnum CAccessAuthFSM::SecureClientConnect()
{
	if (m_pConnection != NULL && m_pConnection->IsConnectionOK())
		return Error_Succeed;

	SecureClientRelease();

	m_pConnection = new CAccessAuthConn(m_pEntity, this);
	if (m_pConnection->ConnectFromCentralSetting() && m_pConnection->IsConnectionOK())
		return Error_Succeed;

	SecureClientRelease();
	return Error_PeerReject;
}

ErrorCodeEnum CAccessAuthFSM::SecureClientRelease()
{
	if (m_pConnection != NULL)
	{
		m_pConnection->Close();
		m_pConnection->DecRefCount();
		m_pConnection = NULL;
	}

	return Error_Succeed;
}
std::mutex mut;
struct TimeOutTask : public ITaskSp {
	CAccessAuthFSM* m_fsm;
	long m_timeOut;//毫秒级
	TimeOutTask(CAccessAuthFSM* fsm,long timeOut) :m_fsm(fsm),m_timeOut(timeOut) {}

	void Process()
	{
		Sleep(m_timeOut);
		MyMutex myMut(&mut);
		if (!m_fsm->m_finishAccess) {
			Dbg("准入超时[%d]",m_fsm->m_finishAccess);
			m_fsm->PostEventFIFO(new FSMEvent(m_fsm->Event_ReqTokenCancel));
			m_fsm->m_finishAccess = 1;
		}
	}
};
void CAccessAuthFSM::s2_on_entry()
{
	LOG_FUNCTION();

	m_finishAccess = 0;
	TimeOutTask* timeOutTask = new TimeOutTask(this,120 * 1000);// 设定30秒准入超时
	GetEntityBase()->GetFunction()->PostThreadPoolTask(timeOutTask);
	Dbg("启动了准入超时定时器2分钟[%d]",m_finishAccess);

	auto pEntity = (CAccessAuthEntity*)m_pEntity;
	
	auto rc = pEntity->InitKMC();
	if (rc != Error_Succeed)
	{
		FSMEvent *pEvent = new FSMEvent(Event_UpdateWKFail);
		PostEventFIFO(pEvent);
		LogWarn(Severity_Middle, Error_Unexpect, ERR_ACCESSAUTH_INIT_KMC,
			GetOutPutStr("%s%08X", "InitKMC", rc).c_str());
		return;
	}
	
	SetSysVar("C");

	if ((rc = SecureClientConnect()) != Error_Succeed)
	{
		// 启动定时器尝试重试
		LogWarn(Severity_Middle, Error_Unexpect, ERR_ACCESSAUTH_CONNECT_SERVER,
			GetOutPutStr("%s%08X", "SecureClientConnect", rc).c_str());
		ScheduleTimer(1, 8000);
		return;
	}

	PostEventFIFO(new FSMEvent(Event_ConnectionOK));
}

void CAccessAuthFSM::s2_on_exit()
{
	// 关闭连接
	auto pEntity = (CAccessAuthEntity*)m_pEntity;
	pEntity->ReleaseKMC();

	SecureClientRelease();
	CancelTimer(1);
}

// 会收到Event_UpdateWKResult和Event_ReqTokenResult和EVT_TIMER
unsigned int CAccessAuthFSM::s2_on_event(FSMEvent* pEvent)
{
	LOG_FUNCTION();
	if (pEvent->iEvt == EVT_TIMER)
	{
		if (pEvent->param1 == 2)		// access timeout
		{
			// 重试超时
			Dbg("access authorize timeout");
			PostEventFIFO(new FSMEvent(Event_ReqTokenCancel));
		}
		else if (pEvent->param1 == 1 || pEvent->param1 == 3)	 // reconnect
		{
			Dbg("reconnect");
			auto rc = SecureClientConnect();
			if (rc != Error_Succeed)
			{
				// 启动定时器尝试重试
				LogWarn(Severity_Middle, Error_Unexpect, ERR_ACCESSAUTH_CONNECT_SERVER,
					GetOutPutStr("%s%08X","SecureClientConnect",rc).c_str());
				ScheduleTimer(1, 8000);
				return 1;
			}

			PostEventFIFO(new FSMEvent(Event_ConnectionOK));
			return 0;
		}
	}
	else if (pEvent->iEvt == Event_ConnectionOK)
	{
		Dbg("判断是否第一次准入！");
		auto pEntity = ((CAccessAuthEntity*)m_pEntity);
		int isFirstAccessAfterSM = pEntity->GetOrSetIsFirstSM(0);
		if (isFirstAccessAfterSM != 1) {
			Dbg("否则继续！");
			FSMEvent* pEvent = new FSMEvent(Event_CheckMD5Succ);
			PostEventFIFO(pEvent);
			return 0;
		}
		Dbg("等待自动初始化完成！");
		CSimpleStringA strInitState;
		pEntity->GetFunction()->GetSysVar("InitState", strInitState);
		if (strInitState == "1") {
			//2020/5/29 删除了各个文件MD5检验的代码		
			FSMEvent* pEvent = new FSMEvent(Event_CheckMD5Succ);
			PostEventFIFO(pEvent);
		}
		else {
			ScheduleTimer(3, 1500);
		}
	}
	else if (pEvent->iEvt == Event_CheckMD5Fail)
	{
		// 上报状态
		m_pConnection->SendReportStatePackage("CheckMD5", Error_Unexpect, ((CAccessAuthEntity*)m_pEntity)->GetAuthErrMsg());
		return 0;
	}
	else if (pEvent->iEvt == Event_CheckMD5Succ)
	{
		// 同步服务器时间
		DWORD rc = m_pConnection->SendSyncTimePackage();
		if (rc != Error_Succeed)
		{
			FSMEvent *pEvent = new FSMEvent(Event_EndSyncTime);
			PostEventFIFO(pEvent);
			LogWarn(Severity_Middle, Error_Unexpect, ERR_ACCESSAUTH_SYNC_TIME,
				GetOutPutStr("%s%08X", "SendSyncTimePackage", rc).c_str());
		}

		//获取终端锁定状态
		rc = m_pConnection->SendLockStatePackage();
		if (rc != Error_Succeed)
		{
			LogWarn(Severity_Middle, Error_Unexpect, rc,
				GetOutPutStr("%s%08X", "SendLockStatePackage", rc).c_str());
		}		
	}
	else if (pEvent->iEvt == Event_EndSyncTime)
	{		
		auto pEntity = ((CAccessAuthEntity*)m_pEntity);
		
		if (!pEntity->HasPinPad())
		{
			// 没有密码键盘，直接准入
			Dbg("has no pinpad, ignore update wk");
			PostEventFIFO(new FSMEvent(CAccessAuthFSM::Event_IgnoreUpdateWK));
			return 0;
		}

		int nWKLastSyncTime(0);
		int nWKSyncFailCount(0);
		
		CSimpleStringA strWKSyncSuccTime = "";
		CSimpleStringA strWKSyncFailCount = "";
#ifdef RVC_OS_WIN
		auto rc = pEntity->GetFunction()->GetSysVar("WKSyncSuccTime", strWKSyncSuccTime);
		assert(rc == Error_Succeed);
		nWKLastSyncTime = atoi(strWKSyncSuccTime);

		rc = pEntity->GetFunction()->GetSysVar("WKSyncFailCount", strWKSyncFailCount);
		assert(rc == Error_Succeed);
		nWKSyncFailCount = atoi(strWKSyncFailCount);

		SYSTEMTIME stSyncTime = CSmallDateTime(nWKLastSyncTime).ToSystemTime();
		Dbg("last WK sync time: %04d-%02d-%02d %02d:%02d:%02d", 
			stSyncTime.wYear, stSyncTime.wMonth, stSyncTime.wDay,
			stSyncTime.wHour, stSyncTime.wMinute, stSyncTime.wSecond);
		SYSTEMTIME stNow = {};
		GetLocalTime(&stNow);
		if (nWKLastSyncTime > 0 && stSyncTime.wYear == stNow.wYear
			&& stSyncTime.wMonth == stNow.wMonth && stSyncTime.wDay == stNow.wDay
			&& nWKSyncFailCount == 0 )		// 最近一次同步成功，才能跳过
#else
		Dbg("获取WKSyncSuccTime。。。");
		auto rc = pEntity->GetFunction()->GetSysVar("WKSyncSuccTime", strWKSyncSuccTime);
		if (rc != Error_Succeed) Dbg("获取WKSyncSuccTime失败");

		rc = pEntity->GetFunction()->GetSysVar("WKSyncFailCount", strWKSyncFailCount);
		if (rc != Error_Succeed) Dbg("获取WKSyncFailCount失败");

		Dbg("strWKSyncSuccTime=%s", strWKSyncSuccTime.GetData());
		Dbg("strWKSyncFailCount=%s", strWKSyncFailCount.GetData());

		nWKSyncFailCount = str2int(strWKSyncFailCount.GetData());
		TIME* lastTime = str2time(strWKSyncSuccTime.GetData());
		if (lastTime != NULL)
		{
			Dbg("last WK sync time: %04d-%02d-%02d %02d:%02d:%02d",
				lastTime->year, lastTime->month, lastTime->day,
				lastTime->hour, lastTime->minute, lastTime->second);
		}
		else {
			Dbg("lastTime = NULL");
		}
		TIME *currentTime = get_system_time();
		if (lastTime != NULL
			&& lastTime->year == currentTime->year
			&& lastTime->month == currentTime->month 
			&& lastTime->day == currentTime->day
			&& nWKSyncFailCount == 0)		// 最近一次同步成功，才能跳过
#endif
		
		
		{
			Dbg("WK has been updated today, last sync time: %s", (const char*)CSmallDateTime(nWKLastSyncTime).ToTimeString());
			FSMEvent *pEvent = new FSMEvent(Event_IgnoreUpdateWK);
			PostEventFIFO(pEvent);	
		}		
		else
		{	
			Dbg("begin update WK now");
		
			// 请求WK
			DWORD rc = m_pConnection->SendWKUpdatePackage();
			if (rc != Error_Succeed)
			{
				LogWarn(Severity_Middle, Error_Unexpect, ERR_ACCESSAUTH_UPDATE_WK,
					GetOutPutStr("%s%08X", "SendWKUpdatePackage", rc).c_str());
				FSMEvent *pEvent = new FSMEvent(Event_UpdateWKFail);
				PostEventFIFO(pEvent);	
			}
		}
#ifdef RVC_OS_WIN
#else
		if(lastTime != NULL) delete lastTime;
		if(currentTime != NULL) delete currentTime;
#endif
		return 0;
	}
	else if (pEvent->iEvt == Event_UpdateWKSucc)
	{
		// 上报状态
		m_pConnection->SendReportStatePackage("UpdateWK", Error_Succeed, "更新工作密钥成功");

		// 保存WK同步时间
#ifdef RVC_OS_WIN
		DWORD rc = m_pEntity->GetFunction()->SetSysVar("WKSyncSuccTime", (const char*)CSimpleStringA::Format("0x%08X", (DWORD)CSmallDateTime::GetNow()), true);
#else
		TIME* tim = get_system_time();
		
		DWORD rc = m_pEntity->GetFunction()->SetSysVar("WKSyncSuccTime", time2str(tim).c_str(), true);

		delete tim;
#endif
		assert(rc == Error_Succeed);
		rc = m_pEntity->GetFunction()->SetSysVar("WKSyncFailCount", "0", true);
		assert(rc == Error_Succeed);

		// 请求Token
		Dbg("begin get token now");
		rc = SecureClientConnect();
		if (rc == Error_Succeed)
			rc = m_pConnection->SendGetTokenPackage();
	 
		if (rc != Error_Succeed)
		{
			FSMEvent *pEvent = new FSMEvent(Event_ReqTokenFail);
			PostEventFIFO(pEvent);	
		}

		return 0;
	}
	else if (pEvent->iEvt == Event_IgnoreUpdateWK)
	{
		// 忽略同步WK，直接准入
		Dbg("ignore update wk, get token now");
		DWORD rc = SecureClientConnect();
		if (rc == Error_Succeed)
			rc = m_pConnection->SendGetTokenPackage();
	
		if (rc != Error_Succeed)
		{
			FSMEvent *pEvent = new FSMEvent(Event_ReqTokenFail);
			PostEventFIFO(pEvent);	
		}
	}
	else if (pEvent->iEvt == Event_UpdateWKFail)
	{
		Dbg("update pinpad WK fail");

		// 上报状态
		m_pConnection->SendReportStatePackage("UpdateWK", Error_Unexpect, ((CAccessAuthEntity*)m_pEntity)->GetAuthErrMsg());

		// zl@20190624 WKSyncFailCount迁移到系统变量
		CSimpleStringA strWKSyncFailCount = "";
		auto rc = m_pEntity->GetFunction()->GetSysVar("WKSyncFailCount", strWKSyncFailCount);
		assert(rc == Error_Succeed);

		int nWKSyncFailCount = atoi(strWKSyncFailCount);
		nWKSyncFailCount++;

		rc = m_pEntity->GetFunction()->SetSysVar("WKSyncFailCount", CSimpleStringA::Format("%d", nWKSyncFailCount), true);
		assert(rc == Error_Succeed);

		// xkm@20150702 启用新准入方案，密钥同步失败不得准入
		// xkm@20151116 失败3次以上应直接跳过同步，避免KMC故障时影响可视柜台准入
		// xkm@20161220 更新密钥失败直接准入
		
		PostEventFIFO(new FSMEvent(CAccessAuthFSM::Event_IgnoreUpdateWK));
	}
	else if (pEvent->iEvt == Event_ReqTokenFail)
	{
		do {
			MyMutex myMut(&mut);
			if (m_finishAccess) return 0;
			m_finishAccess = 1;
			auto pEntity = (CAccessAuthEntity*)m_pEntity;
			CSimpleStringA strErrMsg = CSimpleStringA::Format("准入失败(%d)", m_finishAccess);
			pEntity->GetFunction()->ShowFatalError(strErrMsg);
		} while (0);
		// 上报状态
		m_pConnection->SendReportStatePackage("AccessAuth", Error_Unexpect, ((CAccessAuthEntity*)m_pEntity)->GetAuthErrMsg());

		return 0;
	}
	else if (pEvent->iEvt == Event_ReqTokenCancel)
	{
		auto pEntity = (CAccessAuthEntity*)m_pEntity;
		CSimpleStringA strErrMsg = CSimpleStringA::Format("准入超时(%d)", m_finishAccess);
		pEntity->GetFunction()->ShowFatalError(strErrMsg);
		// 上报状态
		if (m_pConnection != NULL && m_pConnection->IsConnectionOK())
		{
			m_pConnection->SendReportStatePackage("AccessAuth", Error_TimeOut, "准入超时");
		}	
		return 0;
	}
	else if (pEvent->iEvt == Event_ReqTokenSucc)
	{
		do {
			MyMutex myMut(&mut);
			if (m_finishAccess) return 0;
			m_finishAccess = 1;
		} while (0);
		// 上报状态
		m_pConnection->SendReportStatePackage("AccessAuth", Error_Succeed, "准入成功");
		return 0;
	}

	return 0;
}

void CAccessAuthFSM::s3_on_entry()
{
	SetSysVar("F");

	auto pEntity = (CAccessAuthEntity*)m_pEntity;
	CSimpleStringA strErrMsg = CSimpleStringA::Format("准入失败(%s)", (const char*)pEntity->GetAuthErrMsg());
	
	// 发送准入失败事件
	LogWarn(Severity_Middle, Error_Unexpect, ERR_ACCESSAUTH_FAILED,
		GetOutPutStr("%s%s","准入", (const char*)pEntity->GetAuthErrMsg()).c_str());
	pEntity->GetFunction()->ShowFatalError(strErrMsg);
}

void CAccessAuthFSM::s3_on_exit()
{
}

unsigned int CAccessAuthFSM::s3_on_event(FSMEvent* event)
{
	return 0;
}

void CAccessAuthFSM::s4_on_entry()
{
	SetSysVar("A");

	// 发送准入超时事件
	LogWarn(Severity_Middle, Error_Unexpect, ERR_ACCESSAUTH_TIMEOUT,
		    GetOutPutStr("%s%s", "准入", "超时").c_str());
	// 切换到s1
	PostEventFIFO(new FSMEvent(Event_StateTimeout));
}

void CAccessAuthFSM::s4_on_exit()
{
}

unsigned int CAccessAuthFSM::s4_on_event(FSMEvent* event)
{
	return 0;
}

void CAccessAuthFSM::s5_on_entry()
{
	SetSysVar("L");
	LogEvent(Severity_Middle, EVENT_ACCESSAUTH_SUCCEED, "终端准入成功");
	m_pEntity->GetFunction()->ShowStartupInfo("准入成功");
}

void CAccessAuthFSM::s5_on_exit()
{		
}

unsigned int CAccessAuthFSM::s5_on_event(FSMEvent* pEvent)
{
	if (pEvent->iEvt == Event_StartUnregist)
	{
		// 取出参数先保存
		m_nExitReason = pEvent->param1;
		m_nExitWay = pEvent->param2;
	}
	else if (pEvent->iEvt == Event_ReportStage)
	{
		// 上报状态
		if (SecureClientConnect() == Error_Succeed)
		{
			ReportStateEvent *pReportEvent = (ReportStateEvent*)pEvent;
			m_pConnection->SendTerminalStagePackage(pReportEvent->cNewStage, pReportEvent->dwNewStageTime,
				pReportEvent->cOldStage, pReportEvent->dwOldStageTime);
		}
	}

	return 0;
}

void CAccessAuthFSM::s6_on_entry()
{
	SetSysVar("E");

	if (SecureClientConnect() != Error_Succeed)
	{
		// 启动定时器尝试重试
		Dbg("connect to AccessAuthorization service fail, start timer(30s) to retry");
		ScheduleTimer(2, 30000);
		return;
	}

	PostEventFIFO(new FSMEvent(Event_ConnectionOK));
}

void CAccessAuthFSM::s6_on_exit()
{
	CancelTimer(2);
}

unsigned int CAccessAuthFSM::s6_on_event(FSMEvent* pEvent)
{
	if (pEvent->iEvt == EVT_TIMER)
	{
		if (SecureClientConnect() != Error_Succeed)
		{
			// 启动定时器尝试重试
			Dbg("connect to AccessAuthorization service fail, start timer to retry");
			ScheduleTimer(2, 30000);
			return 1;
		}

		PostEventFIFO(new FSMEvent(Event_ConnectionOK));
	}
	else if (pEvent->iEvt == Event_ConnectionOK)
	{
		// 请求退出
		DWORD rc = m_pConnection->SendExitNoticePackage(m_nExitReason, m_nExitWay);

		// 切换到s1
		PostEventFIFO(new FSMEvent(Event_StateTimeout));
	}

	return 0;
}

void CAccessAuthFSM::s7_on_entry()
{
	SetSysVar("T");

	// 过渡状态，立刻转入孤立状态
	PostEventFIFO(new FSMEvent(Event_StateTimeout));
}

void CAccessAuthFSM::s7_on_exit()
{
}

unsigned int CAccessAuthFSM::s7_on_event(FSMEvent* event)
{
	return 0;
}

ErrorCodeEnum CAccessAuthFSM::SetSysVar(const CSimpleStringA &newVal)
{
	CSmartPointer<IEntityFunction> spFunction = m_pEntity->GetFunction();
	return spFunction->SetSysVar("EntryPermit", (const char*)newVal);
}

DWORD CAccessAuthFSM::InitDevice(SpReqAnsContext<AccessAuthService_InitDev_Req, AccessAuthService_InitDev_Ans>::Pointer &ctx)
{
	DWORD rc = SecureClientConnect();

	if (rc == Error_Succeed)
		rc = m_pConnection->SendInitDevicePackage(ctx);
	else
		Dbg("secure connect fail");

	if (rc != Error_Succeed)
	{
		ctx->Answer(rc? Error_Unexpect: Error_Succeed);
		return rc;
	}	

	return Error_Succeed;
}

DWORD CAccessAuthFSM::SyncTime()
{
	auto rc = SecureClientConnect();
	if (rc == Error_Succeed)
	{
		return m_pConnection->SendSyncTimePackageNew();
	}
	else
	{
		Dbg("secure connect fail");
		return rc;
	}	
}

ErrorCodeEnum CAccessAuthFSM::LoadCenterConfig()
{
	CSmartPointer<IEntityFunction> spFunction = m_pEntity->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	ErrorCodeEnum Error = spFunction->OpenConfig(Config_CenterSetting, spConfig);
	if (Error_Succeed == Error) 
	{
		Error = spConfig->ReadConfigValueInt("AccessAuthorization", "CheckMD5", m_nCheckMD5);
		if (Error_Succeed == Error)
		{
			Dbg("get CheckMD5=%d from CenterSetting.ini", m_nCheckMD5);
		} 
		else
		{
			Dbg("get CheckMD5 from CenterSetting.ini failed");
		}
	}

	return Error;
}