myvtm/Module/mod_MaintainWatcher/mod_MaintainWatcher.cpp

#include "stdafx2.h"
#include "SpBase.h"
#include "ConsoleFSM.h"
#include "MaintainWatcher_server_g.h"
#include "MaintainWatcher_def_g.h"
#include "..\EventCode.h"

using namespace  MaintainWatcher;
class CUKEYConsoleEntity;

class MaintainWatcherSession : public MaintainCertificate_ServerSessionBase
{
public:
	MaintainWatcherSession(CUKEYConsoleEntity *pEntity): m_pEntity(pEntity) {}
	virtual ~MaintainWatcherSession() {}

	virtual void Handle_GetUserID(SpReqAnsContext<MaintainCertificate_GetUserID_Req, MaintainCertificate_GetUserID_Ans>::Pointer ctx);
	virtual void Handle_GetUkeyID(SpReqAnsContext<MaintainCertificate_GetUkeyID_Req, MaintainCertificate_GetUkeyID_Ans>::Pointer ctx);
	virtual void Handle_GetSerialNumber(SpReqAnsContext<MaintainCertificate_GetSerialNumber_Req, MaintainCertificate_GetSerialNumber_Ans>::Pointer ctx);
	virtual void Handle_GetCertLife(SpReqAnsContext<MaintainCertificate_GetCertLife_Req, MaintainCertificate_GetCertLife_Ans>::Pointer ctx);
	virtual void Handle_GetAuthorizedID(SpReqAnsContext<MaintainCertificate_GetAuthorizedID_Req, MaintainCertificate_GetAuthorizedID_Ans>::Pointer ctx);
	virtual void Handle_GetAuthorizeTime(SpReqAnsContext<MaintainCertificate_GetAuthorizeTime_Req, MaintainCertificate_GetAuthorizeTime_Ans>::Pointer ctx);
	virtual void Handle_GetUserInfo(SpReqAnsContext<MaintainCertificate_GetUserInfo_Req, MaintainCertificate_GetUserInfo_Ans>::Pointer ctx);
	virtual void Handle_SetSRStatus(SpReqAnsContext<MaintainCertificate_SetSRStatus_Req, MaintainCertificate_SetSRStatus_Ans>::Pointer ctx);
	virtual void Handle_GetSignedInfo(SpReqAnsContext<MaintainCertificate_GetSignedInfo_Req, MaintainCertificate_GetSignedInfo_Ans>::Pointer ctx);
	virtual void Handle_VerifyPwd(SpReqAnsContext<MaintainCertificate_VerifyPwd_Req, MaintainCertificate_VerifyPwd_Ans>::Pointer ctx);
	virtual void Handle_USB(SpReqAnsContext<MaintainCertificate_USB_Req, MaintainCertificate_USB_Ans>::Pointer ctx);
	virtual void Handle_GetEKeyStatus(SpReqAnsContext<MaintainCertificate_GetEKeyStatus_Req, MaintainCertificate_GetEKeyStatus_Ans>::Pointer ctx);
	
private:
	CUKEYConsoleEntity *m_pEntity;
};

class CUKEYConsoleEntity : public CEntityBase, public ILogListener
{
public:
	CUKEYConsoleEntity() {}
	virtual ~CUKEYConsoleEntity() {}
	virtual const char *GetEntityName() const { return "MaintainWatcher"; }

	virtual void OnPreStart(CAutoArray<CSimpleStringA> strArgs,CSmartPointer<ITransactionContext> pTransactionContext) 
	{ 
		// 定阅所有日志和Dbg信息显示用
		//MessageBoxA(0,0,0,0);
		//GetFunction()->SubscribeLog(m_logSubID, this, Log_Ignore, Severity_None, Error_IgnoreAll, -2, NULL, false);

		//订阅进入推荐人事件
		CUUID m_SubIDReturnMenu;
		ErrorCodeEnum Error = GetFunction()->SubscribeLog(m_SubIDReturnMenu, this, Log_Event, Severity_None, Error_IgnoreAll, LOG_EVT_IEBROWSER_SET_RECOMMANDDER, "IEBrowser", false);
		if (Error_Succeed != Error) 
		{
			Dbg("SubScribe LOG_EVT_BROWSER_SET_RECOMMANDDER failed.");
			LogWarn(Severity_Middle, Error_Unexpect, ERR_MAINTAINWATCHER_SUBSCRIBE,
				GetOutPutStr("%s%08X%s%08X","SubscribeLog",Error,"Event", LOG_EVT_IEBROWSER_SET_RECOMMANDDER).c_str());
		}

		//Error = Error_Succeed;
		Error = m_fsm.Init(this);
		pTransactionContext->SendAnswer(Error) ;
	}

	virtual void OnPreClose(EntityCloseCauseEnum eCloseCause,CSmartPointer<ITransactionContext> pTransactionContext) 
	{ 
		pTransactionContext->SendAnswer(Error_Succeed); 
	}

	virtual void OnLog(const CAutoArray<CUUID> &SubIDs, const CUUID nLogID,const LogTypeEnum eLogType, const SeverityLevelEnum eLevel,
		const DWORD dwSysError,const DWORD dwUserCode,const DWORD dwEntityInstanceID, const WORD wEntityDevelID, 
		const CAutoArray<DWORD> &Param, const char *pszEntityName, const char *pszModuleName,const char *pszMessage) 
	{
		if (dwUserCode == LOG_EVT_IEBROWSER_SET_RECOMMANDDER) 
		{
			Dbg("recv LOG_EVT_BROWSER_SET_RECOMMANDDER event from IEBrowser");
			m_fsm.SetRecommender();
		}	

		if (strlen(pszMessage)>2)
		{
			CSimpleStringA str = pszMessage;
			if (str[str.GetLength()-2] == '\r' && str[str.GetLength()-1]=='\n')
				str[str.GetLength()-2] = 0;
						
			if (eLogType == Log_Error)
				str = CSimpleStringA::Format("[%s] %s || SysCode: 0x%X, UserCode: 0x%X\r\n", pszEntityName, (const char*)str, dwSysError, dwUserCode);
			else
				str = CSimpleStringA::Format("[%s] %s\r\n", pszEntityName, (const char*)str);
		}
	}

	virtual bool IsService()const{return true;}
	virtual CServerSessionBase *OnNewSession(const char* /*pszRemoteEntityName*/, const char * /*pszParam*/){return new MaintainWatcherSession(this);}
	void GetEkeyStatus(int &status) {
		m_fsm.GetEkeyStatus(status);
	}
public:
	ConsoleFSM m_fsm;
};

void MaintainWatcherSession::Handle_GetUserID(SpReqAnsContext<MaintainCertificate_GetUserID_Req, MaintainCertificate_GetUserID_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	char cUserID[17] = {0};
	bool bRet = GetUserIDFromCert(USER_CERT_PATH, FORMAT_PEM, cUserID);
	//DWORD dwRet = GetHIDFromCert(cHID);
	if (bRet)
	{
		ctx->Ans.UserID = cUserID;
		ctx->Answer(Error_Succeed);
	}
	else
	{
		ctx->Ans.UserID = "";
		ctx->Answer(Error_Unexpect);
	}


}
void MaintainWatcherSession::Handle_GetEKeyStatus(SpReqAnsContext<MaintainCertificate_GetEKeyStatus_Req, MaintainCertificate_GetEKeyStatus_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	int status;
	m_pEntity->GetEkeyStatus(status);
	ctx->Ans.status = status;
	ctx->Answer(Error_Succeed);
}
void MaintainWatcherSession::Handle_GetUkeyID(SpReqAnsContext<MaintainCertificate_GetUkeyID_Req, MaintainCertificate_GetUkeyID_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	char cHID[32] = {0};
	bool bRet = GetHIDFromCert(USER_CERT_PATH, FORMAT_PEM, cHID);
	if (bRet)
	{
		ctx->Ans.UkeyID = cHID;
		ctx->Answer(Error_Succeed);
	}
	else
	{
		ctx->Ans.UkeyID = "";
		ctx->Answer(Error_Unexpect);
	}
}

void MaintainWatcherSession::Handle_GetSerialNumber(SpReqAnsContext<MaintainCertificate_GetSerialNumber_Req, MaintainCertificate_GetSerialNumber_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	char cSerialNum[32] = {0};
	bool bRet = GetSerialNoFromCert(USER_CERT_PATH, FORMAT_PEM, cSerialNum);
	if (bRet)
	{
		ctx->Ans.SerialNumber = cSerialNum;
		ctx->Answer(Error_Succeed);
	}
	else
	{
		ctx->Ans.SerialNumber = "";
		ctx->Answer(Error_Unexpect);
	}
}

void MaintainWatcherSession::Handle_GetCertLife(SpReqAnsContext<MaintainCertificate_GetCertLife_Req, MaintainCertificate_GetCertLife_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	char cStratTime[32] = {0};
	char cEndTime[32] = {0};
	bool bRet = GetValidityFromCert(USER_CERT_PATH, FORMAT_PEM, cStratTime, cEndTime);
	if (bRet)
	{
		ctx->Ans.StartTime = cStratTime;
		ctx->Ans.EndTime = cEndTime;
		ctx->Answer(Error_Succeed);
	}
	else
	{
		ctx->Ans.StartTime = "";
		ctx->Ans.EndTime = "";
		ctx->Answer(Error_Unexpect);
	}
}

void MaintainWatcherSession::Handle_GetAuthorizedID(SpReqAnsContext<MaintainCertificate_GetAuthorizedID_Req, MaintainCertificate_GetAuthorizedID_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	char cAuthorizedID[32] = {0};
	bool bRet = GetAuthorizerIDFromCert(USER_CERT_PATH, FORMAT_PEM, cAuthorizedID);
	if (bRet)
	{
		ctx->Ans.AuthorizedID = cAuthorizedID;
		ctx->Answer(Error_Succeed);
	}
	else
	{
		ctx->Ans.AuthorizedID = "";
		ctx->Answer(Error_Unexpect);
	}
}

void MaintainWatcherSession::Handle_GetAuthorizeTime(SpReqAnsContext<MaintainCertificate_GetAuthorizeTime_Req, MaintainCertificate_GetAuthorizeTime_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	char cAuthorizeTime[32] = {0};
	bool bRet = GetAuthorizeTimeFromCert(USER_CERT_PATH, FORMAT_PEM, cAuthorizeTime);
	if (bRet)
	{
		ctx->Ans.AuthorizeTime = cAuthorizeTime;
		ctx->Answer(Error_Succeed);
	}
	else
	{
		ctx->Ans.AuthorizeTime = "";
		ctx->Answer(Error_Unexpect);
	}
}

void MaintainWatcherSession::Handle_GetUserInfo(SpReqAnsContext<MaintainCertificate_GetUserInfo_Req, MaintainCertificate_GetUserInfo_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	char cUserType[3] = {0};
	bool bRet = GetUserTypeFromCert(USER_CERT_PATH, FORMAT_PEM, cUserType);
	if (!bRet)
	{
		Dbg("GetUserTypeFromCert err!");
		//return;
	}

	char cUserInfo[2048] = {0};
	bRet = GetUserInfoFromCert(USER_CERT_PATH, FORMAT_PEM, cUserInfo);

	string strUserInfo = cUserInfo;
	strUserInfo += "UserType=";
	strUserInfo += cUserType;
	strUserInfo += ";";
	memcpy(cUserInfo, strUserInfo.c_str(), strUserInfo.length());
	Dbg("Handle_GetUserInfo:UserInfo=%s", strUserInfo.c_str());

	if (bRet)
	{
		ctx->Ans.UserInfo = cUserInfo;
		ctx->Answer(Error_Succeed);
	}
	else
	{
		ctx->Ans.UserInfo = "";
		ctx->Answer(Error_Unexpect);
	}
}

void MaintainWatcherSession::Handle_SetSRStatus(SpReqAnsContext<MaintainCertificate_SetSRStatus_Req, MaintainCertificate_SetSRStatus_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	ctx->Answer(Error_Succeed); // 告知中台已经收到状态设置
	m_pEntity->m_fsm.m_nSRState = ctx->Req.status;

}

void MaintainWatcherSession::Handle_VerifyPwd(SpReqAnsContext<MaintainCertificate_VerifyPwd_Req, MaintainCertificate_VerifyPwd_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	DWORD dwRet = 0;
	CSimpleStringA strErrmsg;
	
	if (8 == ctx->Req.Pwd.GetLength())
	{
		dwRet = m_pEntity->m_fsm.VerifyUser(ctx->Req.Pwd.GetData());
	}
	else
	{
		dwRet = 0xF000FFFF;
	}

	if (dwRet != 0)
	{
		switch (dwRet)
		{
		case 0xF0000001:
			strErrmsg = "没有检测到电子钥匙，请插入电子钥匙!";
			break;

		case 0xF1000002:
			strErrmsg = "加载电子钥匙失败，请确认电子钥匙是否初始化!";
			break;

		case 0xF1000007:
			strErrmsg = "电子钥匙未开始生效，请确认电子钥匙有效期!";
			break;

		case 0xF1000008:
			strErrmsg = "电子钥匙超过有效期，请续期!";
			break;

		case 0xF100000a:
			strErrmsg = "电子钥匙CRL签名验证失败!";
			break;

		case 0xF100000b:
			strErrmsg = "电子钥匙已被撤销， 请重新初始化电子钥匙!";
			break;

		case 0xF100000c:
			strErrmsg = "电子钥匙HID(硬件ID)验证失败， 请重新初始化电子钥匙!";
			break;

		case 0xF100000d:
			strErrmsg = "电子钥匙验证失败，请确认电子钥匙是否正确初始化!";
			break;

		case 0xF100000e:
			strErrmsg = "申请内存失败， 终端内存不足!";
			break;

		case 0xF1000012:
			strErrmsg = "从电子钥匙获取任务信息错误， 请确认是否下载任务到电子钥匙!";
			break;

		case 0xF1000013:
			strErrmsg = "电子钥匙验证失败，请确认电子钥匙是否正确初始化!";
			break;

		case 0xF1000014:
			strErrmsg = "电子钥匙未开始生效，请确认电子钥匙有效期!";
			break;

		case 0xF1000015:
			strErrmsg = "电子钥匙超过有效期，请续期!";
			break;

		case 0xF0000018:
			strErrmsg = "当前登录用户访问权限不够，请登录到Administrator用户!";/*打开本地3des密钥文件失败!*/
			break;

		case 0xF0000019:
			strErrmsg = "当前登录用户访问权限不够，请登录到Administrator用户!";/*打开本地3des密钥长度错误!*/
			break;

		case 0xF000001a:
			strErrmsg = "找不到电子钥匙驱动，请确认是否成功安装驱动!";
			break;

		case 0xF000001b:
			strErrmsg = "当前登录用户访问权限不够，请登录到Administrator用户!";
			break;

		case 0xF000FF00:
		case 0xF000FFFF:
			strErrmsg = "电子钥匙密码错误，请确认后重新输入!";
			break;

		case 0xF000000F:
			strErrmsg = "电子钥匙未初始化，请初始化!";
			break;

		case VERIFYTYPE_ERR:
			strErrmsg = "电子钥匙不具备系统登录权限，认证类型错误!";
			break;

		case USERTYPE_ERR:
			strErrmsg = "电子钥匙不具备系统登录权限，用户类型错误!";
			break;

		case GET_USERINFO_ERR:
			strErrmsg = "从电子钥匙获取用户信息失败!";
			break;

		case IN_BLACKLIST_ERR:
			strErrmsg = "当前电子钥匙已被禁用，请取消挂失或更换其他电子钥匙!";
			break;

		case GET_ISSUERNUM_ERR:
			strErrmsg = "获取外拓卡箱号失败!";
			break;

		case VERIFY_ISSUERNUM_ERR:
			strErrmsg = "不具备当前外拓卡箱号的操作授权，请下载任务!";
			break;

		case VERIFY_TERMINALNO_ERR:
			strErrmsg = "不具备当前终端的操作授权，请下载任务!";
			break;

		case LOG_FULL_ERR:
			strErrmsg = "电子钥匙操作日志记录已满,请先登录作业平台上传操作日志!";
			break;

		case GET_NO_FRAMEWORK_PERMIT_ERR:
			strErrmsg = "电子钥匙类型不支持此操作!";
			break;
		
		case TERMINAL_NO_TASK:
			strErrmsg = "电子钥匙未下载设备的操作权限，请下载!!";
			break;

		case TERMINAL_AUTHORIZED_ERR:
			strErrmsg = "电子钥匙不具备此设备操作授权，请确认是否已授权!";
			break;

		case TERMINAL_AUTHORIZED_OVERTIME_ERR:
			strErrmsg = "设备授权已过期，请确认授权时间!";
			break;

		case TERMINAL_AUTHORIZED_NOTBEGIN_ERR:
			strErrmsg = "设备授权未开始生效，请确认授权时间!";
			break;

		case GET_CERT_VALIDITY_ERR:
			strErrmsg = "获取证书有效时间失败!";
			break;

		case OVERTTIMER_WAR:
			strErrmsg = "电子钥匙即将过期，请及时续期!";
			break;

		default:
			strErrmsg = "电子钥匙验证失败，请联系维护人员!";
			break;
		}
	}

	m_pEntity->m_fsm.m_strPwd = ctx->Req.Pwd;
	m_pEntity->m_fsm.m_errcode = dwRet;
	Dbg("VerifyUser return %08X, errmsg:%s",dwRet, strErrmsg);
	LogWarn(Severity_Middle, Error_Unexpect, ERR_MAINTAINWATCHER_EKEY_VERIFY,
		GetOutPutStr("%s%08X%s%s", "VerifyUser", dwRet, "strErrmsg", strErrmsg).c_str());
	m_pEntity->m_fsm.VerifyOther();
	ctx->Ans.Errcode = dwRet;
	ctx->Ans.ErrMsg = strErrmsg;
	ctx->Answer(Error_Succeed);
}

void MaintainWatcherSession::Handle_GetSignedInfo(SpReqAnsContext<MaintainCertificate_GetSignedInfo_Req, MaintainCertificate_GetSignedInfo_Ans>::Pointer ctx)
{
	LOG_FUNCTION();

	//拼装待签名的内容
	//格式：电子钥匙ID@AgentID@终端ID@时间@业务号@流水号
	char cIndata[128];
	sprintf(cIndata, "%s@%s@%s@%s@%s@%s",
		m_pEntity->m_fsm.m_strKeyHID, 
		m_pEntity->m_fsm.m_strTerminalId,
		m_pEntity->m_fsm.m_strUserID, 
		m_pEntity->m_fsm.m_strNowTime,
		ctx->Req.SerialNo,  
		ctx->Req.ServiceNo);

	/*char cSignedInfo[128] = {0};
	DWORD dwRet = GenSignedInfo(hHandle, pIndata, cSignedInfo);
	if (0 == dwRet)
	{
		ctx->Ans.SignedInfo = cSignedInfo;
		ctx->Answer(Error_Succeed);
	}
	else
	{
		ctx->Ans.SignedInfo = "";
		ctx->Answer(Error_Unexpect);
	}*/
}

void MaintainWatcherSession::Handle_USB(SpReqAnsContext<MaintainCertificate_USB_Req, MaintainCertificate_USB_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	ErrorCodeEnum eErr = m_pEntity->m_fsm.OpenGpio(ctx->Req.open);
	ctx->Answer(eErr);	
}
SP_BEGIN_ENTITY_MAP()
	SP_ENTITY(CUKEYConsoleEntity)
SP_END_ENTITY_MAP()