myvtm/Module/mod_accessauth/AccessAuthConn.cpp

#include "stdafx.h"
#include "AccessAuthConn.h"
#include "mod_AccessAuth.h"
#include "GetDevInfoHelper.h"
#include "comm.h"
#include "access_basefun.h"
#ifdef RVC_OS_WIN
#pragma comment(lib, "crypt32.lib")
#include <windows.h>
#include <Wincrypt.h>
#endif // RVC_OS_WIN
#include "Event.h"
#include <fstream>
using namespace std;

#define MY_ENCODING_TYPE  (PKCS_7_ASN_ENCODING | X509_ASN_ENCODING)
//oiltest need to public function
CAccessAuthConn::CAccessAuthConn(CEntityBase *pEntity, CAccessAuthFSM *pFSM)
	:SpSecureClient(pEntity), m_pFSM(pFSM)
{	
}

CAccessAuthConn::~CAccessAuthConn()
{
}

void CAccessAuthConn::OnDisconnect()
{
	DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("connection disconnected");
}

static inline bool is_base64(unsigned char c) 
{
	return (isalnum(c) || (c == '+') || (c == '/'));
}

int base64_decode(const unsigned char * pEncodedString, long lEncodedLen,
	unsigned char * pBytesDecoded, long &lDecodedLen)
{
	static const std::string base64_chars =
		"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
		"abcdefghijklmnopqrstuvwxyz"
		"0123456789+/";

	unsigned char * pBytesDecodedStart = pBytesDecoded;
	const long lENCODEDLEN = lEncodedLen;
	int i = 0;
	int j = 0;
	int in_ = 0;
	unsigned char char_array_4[4], char_array_3[3];

	while (lEncodedLen-- && (pEncodedString[in_] != '='))
	{
		if (!is_base64(pEncodedString[in_]))
		{
			if (0x0D == pEncodedString[in_] || 0x0A == pEncodedString[in_])
			{
				in_++;
				continue;
			}
			return -1;
		}
		char_array_4[i++] = pEncodedString[in_]; in_++;
		if (i == 4) {
			for (i = 0; i <4; i++)
				char_array_4[i] = base64_chars.find(char_array_4[i]);

			char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
			char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
			char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

			for (i = 0; (i < 3); i++)
			{
				*pBytesDecoded = char_array_3[i];
				++pBytesDecoded;
			}
			i = 0;
		}
	}

	if (i) {
		for (j = i; j <4; j++)
			char_array_4[j] = 0;

		for (j = 0; j <4; j++)
			char_array_4[j] = base64_chars.find(char_array_4[j]);

		char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
		char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
		char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

		for (j = 0; (j < i - 1); j++)
		{
			*pBytesDecoded = char_array_3[j];
			++pBytesDecoded;
		}
	}
	*pBytesDecoded = 0;
	lDecodedLen = pBytesDecoded - pBytesDecodedStart;
	return 0;
}

//同步时间
DWORD CAccessAuthConn::SendSyncTimePackage()
{
	assert(IsConnectionOK());

	SyncTimeReq req;
	memset(&req, 0, sizeof(req));

	CSystemStaticInfo si;
	m_pEntity->GetFunction()->GetSystemStaticInfo(si);

	// 设备号
	strncpy(&req.szTerminalNo[0], (const char*)si.strTerminalID, sizeof(req.szTerminalNo) - 1);

	// 终端时间
	req.dwCurTime = (DWORD)CSmallDateTime::GetNow();

	SyncTimeReq2 req2;
	req2.isSm = 1;
		
	CSmartPointer<IPackage> package = CreateNewPackage("SyncTime");
	package->AddStruct("SYNC_R1", false, false, (BYTE*)&req, sizeof(req));
	package->AddStruct("SYNC_R2", false, false, (BYTE*)&req2, sizeof(req2));
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("send sync time package");
	return SendPackage(package) == "" ? Error_Unexpect : Error_Succeed;
}


DWORD CAccessAuthConn::SendSyncTimePackageNew()
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("SendSyncTimePackageNew");

	assert(IsConnectionOK());
	DWORD dwSysCode, dwUserCode;
	string strErrMsg;
	DWORD rc = Error_Succeed;
	SyncTimeReq req;
	memset(&req, 0, sizeof(req));

	CSystemStaticInfo si;
	m_pEntity->GetFunction()->GetSystemStaticInfo(si);

	// 设备号
	strncpy(&req.szTerminalNo[0], (const char*)si.strTerminalID, sizeof(req.szTerminalNo) - 1);

	// 终端时间
	req.dwCurTime = (DWORD)CSmallDateTime::GetNow();
	CSmartPointer<IPackage> package = CreateNewPackage("SyncTime");
	package->AddStruct("SYNC_R1", false, false, (BYTE*)&req, sizeof(req));
	if (SendPackage(package) == "")
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("send sync time package failed");
		return Error_Unexpect;
	}
	else
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("send sync time package success");
	}

	CSmartPointer<IPackage> pRecvPkg = ReceivePackage(5);
	if (pRecvPkg == NULL)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("ReceivePackage failed, don't revceive SyncTime ans");
		return Error_Unexpect;
	}

	if (pRecvPkg->GetErrMsg(dwSysCode, dwUserCode, strErrMsg))
	{
		rc = dwUserCode;
		m_pFSM->doWarnMsg(dwUserCode, GetOutPutStr("%s%08X%s%s", "GetErrMsg", dwUserCode, "strErrMsg", strErrMsg.c_str()).c_str());
	}		
	else
	{
		int nRetLen = pRecvPkg->GetStructLen("SYNC_A1");
		if (nRetLen >0)
		{
			assert(nRetLen == sizeof(SyncTimeAns));
			SyncTimeAns ret;
			memset(&ret, 0, sizeof(ret));

			int nArrayNum(0);
			int nBufLen = sizeof(ret);
			pRecvPkg->GetStructData("SYNC_A1", (BYTE*)&ret, &nBufLen, &nArrayNum);

			// 比较终端和服务器时间， 时差小于3分钟不纠正	
			DWORD dwTimeDiff = ret.nTimeDiff;
			if (dwTimeDiff > 180)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("time diff is too large (%ds), sync time now", dwTimeDiff);

				CSmallDateTime dtServerTime(CSmallDateTime::GetNow() + dwTimeDiff);
				SYSTEMTIME stServerTime = dtServerTime.ToSystemTime();
#ifdef RVC_OS_WIN
				if (SetLocalTime(&stServerTime))
#else
				get_system_time();
				if(set_system_time_by_sec((int)dwTimeDiff))
#endif // RVC_OS_WIN
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("sync time with server succeed, server time: [%s]", (const char*)dtServerTime.ToTimeString());
				else
				{
					m_pFSM->doWarnMsg(ERR_ACCESSAUTH_SET_LOCALE_TIME, GetOutPutStr("%s%s", "stServerTime", dtServerTime.ToTimeString()).c_str());
					rc = ERR_ACCESSAUTH_SET_LOCALE_TIME;
				}
			}
			else
			{
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("time diff is acceptable (%ds)", dwTimeDiff);
			}
		}
		else
		{
			
			m_pFSM->doWarnMsg(ERR_ACCESSAUTH_SYNC_TIME,	GetOutPutStr("%s%d", "GetStructLen", nRetLen).c_str());
			rc = ERR_ACCESSAUTH_SYNC_TIME;
		}
	}

	return rc;
}

DWORD CAccessAuthConn::HandleSyncTimeRet(const CSmartPointer<IPackage> &pRecvPkg)
{
	LOG_FUNCTION();
	DWORD dwSysCode, dwUserCode;
	string strErrMsg;
	DWORD rc = Error_Succeed;
	int nAuthVersion = 1;		// 默认使用KMC准入
	BYTE *pSessionKey = NULL;

	return rc;
}

DWORD CAccessAuthConn::SendInitDevicePackage(SpReqAnsContext<AccessAuthService_InitDev_Req, AccessAuthService_InitDev_Ans>::Pointer &ctx)
{
	assert(IsConnectionOK());

	InitDeviceReq req;
	memset(&req, 0, sizeof(req));
	
	strncpy(req.vtmCR1, (const char*)ctx->Req.EncR1, sizeof(req.vtmCR1));
	strncpy(req.R2, (const char*)ctx->Req.R2, sizeof(req.R2));
	strncpy(req.vtmCR3, (const char*)ctx->Req.EncR3, sizeof(req.vtmCR3));
	strncpy(req.CDevPubKey, (const char*)ctx->Req.EncDevPubKey, sizeof(req.CDevPubKey));
	strncpy(req.Verdor, (const char*)ctx->Req.Vendor, sizeof(req.Verdor));

	CSmartPointer<IPackage> package = CreateNewPackage("InitDev");
	package->AddStruct("InitDevR", false, false, (BYTE*)&req, sizeof(req));

	InitDeviceReq0 req0;
	req0.isSM = 1;
	package->AddStruct("SMSyn", false, false, (BYTE*)& req0, sizeof(req0));

	if (SendPackage(package) == "")
	{
		m_pFSM->doWarnMsg(ERR_ACCESSAUTH_INIT_DEV_SEND_PKG,	GetOutPutStr("%s%s", "发送初始化设备数据包失败", "").c_str());
		return ERR_ACCESSAUTH_INIT_DEV_SEND_PKG;
	}
	else
	{
		//Dbg("send init device req succ, CR1:%s, R2:%s, CR3:%s, CDevPubKey:%s",  (const char*)ctx->Req.EncR1, 
		//	(const char*)ctx->Req.R2, (const char*)ctx->Req.EncR3, (const char*)ctx->Req.EncDevPubKey);
		m_ctxInitDev = ctx;
		return Error_Succeed;
	}
}

DWORD CAccessAuthConn::HandleInitDeviceRet(const CSmartPointer<IPackage> &pRecvPkg)
{
	DWORD dwSysCode, dwUserCode;
	string strErrMsg;
	ErrorCodeEnum rc = Error_Succeed;

	if (pRecvPkg->GetErrMsg(dwSysCode, dwUserCode, strErrMsg))
	{
		rc = (ErrorCodeEnum)dwSysCode;

		m_pFSM->doWarnMsg(ERR_ACCESSAUTH_INIT_DEV, GetOutPutStr("%s%08X%s%s", "初始化设备错误", rc,"strErrMsg", strErrMsg.c_str()).c_str());
	}
	else if (m_ctxInitDev == NULL)
	{
		Dbg("m_ctxInitDev is NULL");
		rc = Error_Unexpect;
	}
	else
	{
		int nRetLen = pRecvPkg->GetStructLen("InitDevA");
		if (nRetLen > 0)
		{
			assert(nRetLen == sizeof(InitDeviceAns));
			InitDeviceAns ret;
			memset(&ret, 0, sizeof(ret));

			int nArrayNum(0);
			int nBufLen = sizeof(ret);
			pRecvPkg->GetStructData("InitDevA", (BYTE*)&ret, &nBufLen, &nArrayNum);

			Dbg("init device succ");

			//Dbg("init device ret, R1:%s, CR2:%s, R3:%s", ret.R1, ret.CR2, ret.R3);
			m_ctxInitDev->Ans.R1 = ret.R1;
			m_ctxInitDev->Ans.EncR2 = ret.CR2;
			m_ctxInitDev->Ans.R3 = ret.R3;
		}
		else
		{
			m_pFSM->doWarnMsg(ERR_ACCESSAUTH_INIT_DEV, GetOutPutStr("%s%d", "GetStructLen", nRetLen).c_str());
			rc = Error_Bug;
		}
	}

	if (m_ctxInitDev != NULL)
	{
		m_ctxInitDev->Answer(rc);
		m_ctxInitDev.Clear();
	}

	return rc;
}

//上报状态
DWORD CAccessAuthConn::SendReportStatePackage(const char*pszEventType, DWORD dwErrCode, const char *pszErrMsg)
{
	auto pFunc = m_pEntity->GetFunction();

	CSystemStaticInfo ssInfo;
	pFunc->GetSystemStaticInfo(ssInfo);

	ReportStateReq req = {};
	strncpy(req.TerminalNo, ssInfo.strTerminalID, sizeof(req.TerminalNo) - 1);
	strncpy(req.EventType, pszEventType, sizeof(req.EventType) - 1);
	req.ErrorCode = dwErrCode;
	if (pszErrMsg != NULL)
		strncpy(req.ErrorMsg, pszErrMsg, sizeof(req.ErrorMsg) - 1);

	auto package = CreateNewPackage("RepState");
	package->AddStruct("REPSTA_R", false, false, (BYTE*)&req, sizeof(req));

	return SendPackage(package) != "" ? Error_Succeed : Error_Unexpect;
}

DWORD CAccessAuthConn::HandleReportStateRet(const CSmartPointer<IPackage> &pRecvPkg)
{
	DWORD rc = Error_Succeed;
	DWORD dwSysCode, dwUserCode;
	string strErrMsg;

	if (pRecvPkg->GetErrMsg(dwSysCode, dwUserCode, strErrMsg))
	{
		rc = dwUserCode;
		m_pFSM->doWarnMsg(rc, strErrMsg);
	}
	
	return rc;
}

//同步锁定状态
DWORD CAccessAuthConn::SendLockStatePackage()
{
	LockStateReq req = {0};

	auto pFunc = m_pEntity->GetFunction();
	CSystemStaticInfo info;
	DWORD rc = pFunc->GetSystemStaticInfo(info);
	if (rc != Error_Succeed)
	{
		m_pFSM->doWarnMsg(ERR_ACCESSAUTH_GET_SYSTEM_STATIC_INFO, GetOutPutStr("%s%08X", "GetSystemStaticInfo", rc).c_str());
		return ERR_ACCESSAUTH_GET_SYSTEM_STATIC_INFO;
	}
	strncpy(req.TerminalNo, (const char*)info.strTerminalID, sizeof(req.TerminalNo)-1);

	CSmartPointer<IPackage> pkt = CreateNewPackage("LockSta");
	pkt->AddStruct("LockStateReq", false, false, (LPBYTE)&req, sizeof(LockStateReq));
	if (SendPackage(pkt) == "")
	{
		m_pFSM->doWarnMsg(ERR_ACCESSAUTH_LOCK_SEND_PKG,	GetOutPutStr("%s%08X", "SendLockStatePackage", Error_Unexpect).c_str());
		return ERR_ACCESSAUTH_LOCK_SEND_PKG;
	}
	else
	{
		Dbg("send  Lock State req success");
	}		

	return Error_Succeed;
}

DWORD CAccessAuthConn::HandleLockStateRet(const CSmartPointer<IPackage> &pRecvPkg)
{
	DWORD rc = Error_Succeed;
	DWORD dwSysCode, dwUserCode;
	string strErrMsg;

	if (pRecvPkg->GetErrMsg(dwSysCode, dwUserCode, strErrMsg))
	{
		rc = dwUserCode;
		((CAccessAuthEntity*)m_pEntity)->SetAuthErrMsg(strErrMsg.c_str());
		CSmartPointer<IEntityFunction> spFunction = m_pEntity->GetFunction();
		spFunction->SetSysVar("AuthErrMsg", strErrMsg.c_str(), true);

		m_pFSM->doWarnMsg(rc, GetOutPutStr("%s%08X%s%s", "GetErrMsg", rc,"AuthErrMsg", strErrMsg.c_str()).c_str());

		return rc;
	}

	int nLen = pRecvPkg->GetStructLen("LockStateAns");
	if (nLen > 0) 
	{
		BYTE *pBuf = new BYTE[nLen];
		memset(pBuf, 0, nLen);
		int nArrayNum = 0;

		if (pRecvPkg->GetStructData("LockStateAns", pBuf, &nLen, &nArrayNum)) 
		{
			Dbg("收到LockStateAns");

			LockStateAns * pRet = (LockStateAns*)pBuf;
			int nState = pRet->LockState;
			Dbg("nLockState[%d]",nState);

			//设置系统变量LockState, 0，正常；1，锁定；2，罚出；(准入服务返回，6:罚出 7：锁定)
			CSmartPointer<IEntityFunction> spFunction = m_pEntity->GetFunction();
			if (6 == nState)
			{
				spFunction->SetSysVar("LockState", "2", true);
			}
			else if (7 == nState)
			{
				spFunction->SetSysVar("LockState", "1", true);
			}
		} 
		else 
		{
			m_pFSM->doWarnMsg(ERR_ACCESSAUTH_LOCK_STATE, GetOutPutStr("%s%s", "GetStructLen", "False").c_str());
			return ERR_ACCESSAUTH_LOCK_STATE;
		}
		delete pBuf;
	}
	else
	{
		m_pFSM->doWarnMsg(ERR_ACCESSAUTH_LOCK_STATE, GetOutPutStr("%s%s%s%d", "GetStructData", "False","nLen", nLen).c_str());
		return ERR_ACCESSAUTH_LOCK_STATE;
	}

	return rc;
}

DWORD CAccessAuthConn::SendCheckMD5Package(const char* pMD5Value)
{
	assert(IsConnectionOK());
	CheckMD5Req req;
	memset(&req, 0, sizeof(req));

	CSimpleStringA strMD5Value = pMD5Value;
	Dbg("MD5[%s]", strMD5Value.GetData());

	CSystemStaticInfo si;
	m_pEntity->GetFunction()->GetSystemStaticInfo(si);	

	strncpy(&req.TerminalNo[0], (const char*)si.strTerminalID, sizeof(req.TerminalNo)-1);// 设备号
	strncpy(req.MD5Value, strMD5Value, 16);//MD5值

	CSmartPointer<IPackage> pkt = CreateNewPackage("CheckMD5");
	pkt->AddStruct("MD5REQ", false, false, (BYTE*)&req, sizeof(req));

	Dbg("send check MD5 request now");
	return SendPackage(pkt) != "" ? Error_Succeed : Error_Unexpect;			
}

DWORD CAccessAuthConn::SendUpdateMD5Package(const char* pMD5Value)
{
	assert(IsConnectionOK());
	CheckMD5Req req;
	memset(&req, 0, sizeof(req));

	CSimpleStringA strMD5Value = pMD5Value;
	Dbg("MD5[%s]", strMD5Value.GetData());

	CSystemStaticInfo si;
	m_pEntity->GetFunction()->GetSystemStaticInfo(si);	

	strncpy(&req.TerminalNo[0], (const char*)si.strTerminalID, sizeof(req.TerminalNo)-1);// 设备号
	strncpy(req.MD5Value, strMD5Value, 16);//MD5值

	CSmartPointer<IPackage> pkt = CreateNewPackage("UpdMD5");
	pkt->AddStruct("MD5REQ", false, false, (BYTE*)&req, sizeof(req));

	Dbg("send update MD5 request now");
	return SendPackage(pkt) != "" ? Error_Succeed : Error_Unexpect;			
}

DWORD CAccessAuthConn::HandleCheckMD5Ret(const CSmartPointer<IPackage> &pRecvPkg)
{
	ErrorCodeEnum rc = Error_Succeed;
	DWORD dwSysCode, dwUserCode;
	string strErrMsg;

	/*if (pRecvPkg->GetErrMsg(dwSysCode, dwUserCode, strErrMsg))
	{
		rc = (ErrorCodeEnum)dwSysCode;
		m_pFSM->doWarnMsg(dwUserCode, strErrMsg);
		CSmartPointer<IEntityFunction> spFunction = m_pEntity->GetFunction();
	}

	m_pFSM->PostEventFIFO(new FSMEvent(rc==Error_Succeed ? CAccessAuthFSM::Event_CheckMD5Succ:CAccessAuthFSM::Event_CheckMD5Fail));*/

	return rc;
}

DWORD CAccessAuthConn::HandleUpdateMD5Ret(const CSmartPointer<IPackage> &pRecvPkg)
{
	ErrorCodeEnum rc = Error_Succeed;
	DWORD dwSysCode, dwUserCode;
	string strErrMsg;
	return rc;
}

DWORD CAccessAuthConn::HandleLockState(int nState)
{
	Dbg("%s:lock state: %d", __FUNCTION__, nState);

    DWORD rc = Error_Succeed;
	//设置系统变量LockState, 0，正常；1，锁定；2，罚出；(准入服务返回，6:罚出 7：锁定)
	CSmartPointer<IEntityFunction> spFunction = m_pEntity->GetFunction();

	if (6 == nState)
	{
		rc = spFunction->SetSysVar("LockState", "2", true);
		((CAccessAuthEntity*)m_pEntity)->SetAuthErrMsg("终端已罚出");
	}
	else if (7 == nState)
	{
		rc = spFunction->SetSysVar("LockState", "1", true);
		((CAccessAuthEntity*)m_pEntity)->SetAuthErrMsg("终端已锁定");
	}

	return rc;
}

DWORD CAccessAuthConn::GetDeviceInfo(CEntityBase* pCallerEntity, const CSimpleStringA& devDeviceName,
	CSimpleStringA& strModel, CSimpleStringA& strVendor, CSimpleStringA& strVersion)
{
	CSmartPointer<IConfigInfo> pConfig;
	DWORD rc = pCallerEntity->GetFunction()->OpenConfig(Config_Root, pConfig);
	if (rc == Error_Succeed)
	{
		CSimpleStringA strSection = CSimpleStringA("Device.") + devDeviceName;

		pConfig->ReadConfigValue(strSection, "Vendor", strVendor);
		pConfig->ReadConfigValue(strSection, "Version", strVersion);

		strModel = devDeviceName;
		if (!strVendor.IsNullOrEmpty())
		{
			strModel += ".";
			strModel += strVendor;
		}

		if (!strVersion.IsNullOrEmpty())
		{
			strModel += ".";
			strModel += strVersion;
		}
	}

	return rc;
}