myvtm/Module/mod_MaintainWatcher/ConsoleFSM.h

#pragma once
#include "SpBase.h"
#include "SpFSM.h"
#include "USBKeyAPI.h"
#include "VerifyCertificate.h"
//#include "libsharememory.h"
#include "SpSecureClient.h"
#include "MaintainWatcher_msg_g.h"
#include "..\mod_cardissuer\CardIssuer_client_g.h"
#include "..\mod_DeviceControl\DeviceControl_client_g.h"
#include "MaintainWatcherErrorCode.h"
using namespace CardIssuer;
using namespace DeviceControl;

#define USER_EVT_JMP_VERIFYPWD			EVT_USER+1
#define USER_EVT_JMP_VERIFYTASK			EVT_USER+2
#define USER_EVT_JMP_RELEASE			EVT_USER+3
#define USER_EVT_CERT_ANS               EVT_USER+4
#define USER_EVT_DISCONNECT             EVT_USER+5
#define USER_EVT_TASK_ANS               EVT_USER+6
#define USER_EVT_USBKEYINFO_ANS         EVT_USER+7
#define USER_EVT_JMP_UKEYINSERT			EVT_USER+8
#define USER_EVT_JMP_UKEYPULLOUT		EVT_USER+9
#define USER_EVT_JMP_PWDSUCCESS			EVT_USER+10
#define USER_EVT_JMP_PWDERR				EVT_USER+11

#define SHARE_MEM_NAME       "VerifyResult"
#define ROOT_CERT_PATH       ".\\cfg\\certs\\RootCert.pem"
#define CA_CERT_PATH         ".\\cfg\\certs\\CaCert.pem"
#define USER_CERT_PATH		 ".\\cfg\\certs\\userCert.pem"
#define CERT_DIR			 ".\\cfg\\certs"

//用户类型
#define USER_TYPE_MAINTAIN		    00		//维护用户
#define USER_TYPE_MATERIAL_MANAGER  01		//物料管理用户
#define USER_TYPE_CUSTOMER_MANAGER  02		//客户经理
#define USER_TYPE_AGENT3			03      //Agent3用户
#define USER_TYPE_FINANCING_MANAGER 04      //理财经理

//机型
#define MACHINETYPE_STAND2S     "RVC.Stand2S" //站立式双屏
#define MACHINETYPE_STAND1S     "RVC.Stand1S" //站立式单屏
#define MACHINETYPE_WALL		"RVC.Wall"	  //挂墙式
#define MACHINETYPE_EMBED2S     "RVC.Embed2S" //嵌墙式双屏
#define MACHINETYPE_EMBED1S     "RVC.Embed1S" //嵌墙式单屏
#define MACHINETYPE_PAD			"RVC.PAD"	  //携带式移动终端

//场所
#define SIT_LIB   "cmb.LIB" //银行大堂内
#define SIT_SSB   "cmb.SSB" //自助营业网点
#define SIT_FLB   "cmb.FLB" //离行机器，银行业务为主界面，如企业，商场
#define SIT_LSS   "cmb.LSS" //面向生活销售机，一般部署在小区，面向销售广告
#define SIT_SMM   "cmb.SMM" //商场销售门户，放置在商场，多商户门户



// [StructName("RvcCertReq")]
struct CertReq
{
	char CertVersion[8];
};
//    [StructName("RvcCertAns")]
struct CertAns
{
	char RootCert[4096];
	char CaCert[4096];
};

#pragma pack(1)
typedef struct 	// 45
{
	char state;
}CertBlackListReq;

typedef struct
{
	char ukeyID[20];
}CertBlackListRet;
#pragma pack()

struct CertAnsEvent : public FSMEvent 
{
	CertAnsEvent(BYTE *pBuf, int nLen) : FSMEvent(USER_EVT_CERT_ANS) 
	{
		memcpy(&m_reply, pBuf, sizeof(CertAns));
	}
	virtual ~CertAnsEvent() {}
	CertAns m_reply;
};

struct TaskReq
{
	char TaskID[16];
};

struct TaskAns
{
	char TaskStatus[1];
};

struct TaskAnsEvent : public FSMEvent 
{
	TaskAnsEvent(BYTE *pBuf, int nLen) : FSMEvent(USER_EVT_TASK_ANS) 
	{
		memcpy(&m_reply, pBuf, sizeof(TaskAns));
	}
	virtual ~TaskAnsEvent() {}
	TaskAns m_reply;
};

struct USBKeyInfoReq
{
	char USBKeyID[16];
};

struct USBKeyInfoAns
{
	char USBKeyInitTime[20];
};

struct USBKeyInfoAnsEvent : public FSMEvent 
{
	USBKeyInfoAnsEvent(BYTE *pBuf, int nLen) : FSMEvent(USER_EVT_USBKEYINFO_ANS) 
	{
		memcpy(&m_reply, pBuf, sizeof(USBKeyInfoAns));
	}
	virtual ~USBKeyInfoAnsEvent() {}
	USBKeyInfoAns m_reply;
};

class CAConnection;
class ConsoleFSM : public FSMImpl<ConsoleFSM>, public IFSMStateHooker
{
public:
	enum {s0,s1,s2,s3,s4,s5};

	BEGIN_FSM_STATE(ConsoleFSM)
		FSM_STATE_ENTRY(s0,"Starting",s0_on_entry,s0_on_exit,s0_on_event)
		FSM_STATE_ENTRY(s1, "Ukey Insert", s1_on_entry, s1_on_exit, s1_on_event)
		FSM_STATE_ENTRY(s2, "Ukey pullout", s2_on_entry, s2_on_exit, s2_on_event)
		FSM_STATE_ENTRY(s3, "Verify", s3_on_entry, s3_on_exit, s3_on_event)
		FSM_STATE_ENTRY(s4, "Realse", s4_on_entry, s4_on_exit, s4_on_event)
		END_FSM_STATE()

		BEGIN_FSM_RULE(ConsoleFSM,s0)
		FSM_RULE_ENTRY_ANY(s0, s1, USER_EVT_JMP_UKEYINSERT)
		FSM_RULE_ENTRY_ANY(s0, s2, USER_EVT_JMP_UKEYPULLOUT)
		FSM_RULE_ENTRY_ANY(s1, s2, USER_EVT_JMP_UKEYPULLOUT)
		FSM_RULE_ENTRY_ANY(s1, s3, USER_EVT_JMP_VERIFYPWD)
		FSM_RULE_ENTRY_ANY(s1, s4, USER_EVT_JMP_RELEASE)
		FSM_RULE_ENTRY_ANY(s2, s4, USER_EVT_JMP_RELEASE)
		FSM_RULE_ENTRY_ANY(s3, s2, USER_EVT_JMP_UKEYPULLOUT)
		FSM_RULE_ENTRY_ANY(s3, s4, USER_EVT_JMP_RELEASE)
		FSM_RULE_ENTRY_ANY(s4, s0, EVT_TIMER)
		FSM_RULE_ENTRY_ANY(s4, s2, USER_EVT_JMP_UKEYPULLOUT)
		END_FSM_RULE()

	ConsoleFSM();
	~ConsoleFSM();

	virtual void OnStateTrans(int iSrcState, int iDstState);

	virtual void OnSysVarEvent(const char *pszKey, const char *pszValue,const char *pszOldValue,const char *pszEntityName);

	virtual ErrorCodeEnum OnInit();
	virtual ErrorCodeEnum OnExit();

	void s0_on_entry();
	void s0_on_exit();
	unsigned int s0_on_event(FSMEvent* event);

	void s1_on_entry();
	void s1_on_exit();
	unsigned int s1_on_event(FSMEvent* event);

	void s2_on_entry();
	void s2_on_exit();
	unsigned int s2_on_event(FSMEvent* event);

	void s3_on_entry();
	void s3_on_exit();
	unsigned int s3_on_event(FSMEvent* event);

	void s4_on_entry();
	void s4_on_exit();
	unsigned int s4_on_event(FSMEvent* event);

	//DWORD VerifyUser();
	DWORD VerifyUser(const char* pcPIN);
	DWORD VerifyOther();
	void DownloadCerts();
	void DownloadCertBlackList();
	BOOL GetTaskStatus(const char* pTaskID);
	BOOL VerifyTaskStatus(const char* pTaskID);
	DWORD VerifyTerminalInfo();
	DWORD VerifyTerminalNo();	
	DWORD VerifyCardIssuerSN();
	DWORD CheckCertVaildity();
	BOOL CheckUSBKeyLife(const char* pUSBKeyID);
	BOOL GetUserInfo();
	ErrorCodeEnum SetRunConfig();
	ErrorCodeEnum LoadRunConfig();
	ErrorCodeEnum LoadCenterConfig();
	BOOL GetMenuStatus();
	BOOL GetIssuerNum();
	ErrorCodeEnum OpenGpio(BOOL bOpen);
	BOOL SetRecommender();
	void CloseConnection();
	CSmartPointer<IEntityFunction> GetFunction();
	void GetEkeyStatus(int &);

	int m_nSRState; //是否进入录音录像业务状态值，0：在业务状态；1：正在录音录像
	CSimpleStringA m_strPwd; //界面输入的电子钥匙密码
	DWORD m_errcode;
	string m_strTerminalId; //终端号
	string m_strKeyHID;     //电子钥匙ID
	string m_strUserID;     //用户ID
	string m_strNowTime;    //当前时间
	BOOL m_bAns;//是否收到分行服务的回复，0：未收到；1：收到
	BOOL m_bInputpwdDlg;//是否已经弹出输入密码对话框
	BOOL m_bVerifyPwd;//是否验证完密码
	CSimpleStringA m_strMachineType, m_strSite;

	typedef struct TaskRecord 
	{
		string strWarningId;
		char startTime[20];
		char endTime[20];
	}*PTaskRecord;

	typedef struct EventInfo
	{
		BOOL bOpenRVC;
		BOOL bLocalMaintance;
		USBKEY_HANDLE hHandle;
	}*PEventInfo;

	char m_TaskStatus[1]; //'O',打开；'D',已下载；'C',已关闭；
	char m_USBKeyInitTime[20];
private:
	//读配置文件
	ErrorCodeEnum LoadServerConfig();
	ErrorCodeEnum LoadRootConfig();
		
	int m_nUkeyStatus;
	int m_nCheckTerminalNo; //物料类型电子钥匙是否校验任务标志，0：不校验；1：校验
	int m_nCheckMaintainTask; //维护类型的电子钥匙是否校验任务标志，0：不校验；1：校验
	int m_nVerifyBlackList;	//是否校验电子钥匙黑名单，0：不校验；1：校验
	CSimpleStringA m_StringVerifyKey,m_StringConsoleName;	
	CSimpleStringA m_strUIstate;	
	BOOL m_bMenu;    //是否在首页状态 0：不在；1：在
	

	ErrorCodeEnum AsyncStartEntity(const char *entity_name, const char *cmdline, void *pData);
	ErrorCodeEnum AsyncStopEntity(const char *entity_name, void *pData);
	//USBKEY_INFO g_USBKeyInfo; //Ukey信息
	USBKEY_HANDLE m_Handle; //Ukey句柄
	//string m_strTerminalId; //终端号
	//string m_strKeyHID;     //电子钥匙ID
	//string m_strUserID;     //用户ID
	string m_strUserType;   //用户类型
	char m_StartTime[20];  //操作起始时间
	char m_EndTime[20];    //操作结束时间
	TaskRecord* m_TaskRecords[128]; //任务记录信息数组
	unsigned int m_RecordNum; //当前终端号对应的任务记录数
	CSimpleStringA m_CardIssuerSN;//当前连接的卡机号

	PEventInfo m_EventInfo; //用户界面信息
	LPVOID m_lpMem; //共享内存指针

	BOOL m_bHaveFindUkey;//识别到Ukey
	BOOL m_bVerifySuccess;//用户验证成功

	CRITICAL_SECTION cs;
	CAConnection *m_pConnection;
	CardIssuerService_ClientBase *m_pCardIssuerService;
	DeviceControlService_ClientBase *m_pDeviceControlService;
private:
};

void Black_init(unsigned char *s, unsigned char *key, unsigned long Len);
void Black_crypt(unsigned char*s, unsigned char*Data, unsigned long  Len);
void certBlackCrypt(char *dstStr, char *srcStr);
BOOL checkDirExist(TCHAR *filePath);
BOOL checkFileExist(TCHAR *filePath, BOOL isCreate);
BOOL IsCertInBlack(char *certNo);



class CAConnection : public SpSecureClient
{
public:
	CAConnection(CEntityBase *pEntity, ConsoleFSM *pFSM) : SpSecureClient(pEntity), m_pFSM(pFSM) {}
	virtual ~CAConnection() {}

	void SendVersionReq()
	{
		CertReq req = {0};
		
		////检测本地是否存在根证书和分行证书
		//FILE* fp = fopen("RootCert.pem", "r");
		//if (NULL != fp)
		//{
		//	//有则获取证书版本
		//} 
		//else
		//{
		//	//没有则发生默认版本，下载证书
		//	memcpy(req.CertVersion, "10000000", 8);
		//}

		memcpy(req.CertVersion, "10000000", 8);

		CSmartPointer<IPackage> pkt = CreateNewPackage("CertReq");
		pkt->AddStruct("CertReq", false, false, (LPBYTE)&req, sizeof(CertReq));
		SendPackage(pkt);
	}

	void SendCertBlackListReq()
	{
		CertBlackListReq req;
		memset(&req, 0, sizeof(CertBlackListReq));
		req.state = 'L';//get black list

		CSmartPointer<IPackage> package = CreateNewPackage("CertBla");
		package->AddStruct("CertBlackListReq", true, false, (BYTE*)&req, sizeof(req));
		SendPackage(package);
	}
	
	void SendTaskReq(const char* pTaskID)
	{
		TaskReq req = {0};

		memcpy(req.TaskID, pTaskID, 16);

		CSmartPointer<IPackage> pkt = CreateNewPackage("TaskReq");	
		pkt->AddStruct("TaskReq", false, false, (LPBYTE)&req, sizeof(TaskReq));
		if (SendPackage(pkt) == "")
		{
			Dbg("SendPackage failed, send Task req failed");
			return;
		}
		else
		{
			Dbg("send get task req success");
		}	
		

		pkt = ReceivePackage(5);
		if (pkt == NULL)
		{
			Dbg("ReceivePackage failed, don't revceive TaskReq ans");
			return;
		}

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

			if (pkt->GetStructData("TaskAns", pBuf, &nLen, &nArrayNum)) 
			{
				Dbg("recieve task ans success");

				FSMEvent *evt = new TaskAnsEvent(pBuf, nLen);
				TaskAnsEvent *ans = (TaskAnsEvent *)evt;
				if (ans->m_reply.TaskStatus == NULL)
				{
					Dbg("Don't get <TaskID=%s> status!",pTaskID);
				}
				else 
				{
					Dbg("get <TaskID=%s> status <%c>!",pTaskID,ans->m_reply.TaskStatus[0]);
					memcpy(m_pFSM->m_TaskStatus, ans->m_reply.TaskStatus, 1);
				}
				delete evt;
			} 
			else 
			{
				Dbg("create invalid TaskAns packet!");
				OnDisconnect();
			}
			delete pBuf;
		}
		else
		{
			Dbg("don't recieve TaskAns packet!");
			//OnDisconnect();
		}
	}

	void SendUSBKeyInfoReq(const char* pUSBKeyID)
	{
		USBKeyInfoReq req = {0};

		memcpy(req.USBKeyID, pUSBKeyID, 16);

		CSmartPointer<IPackage> pkt = CreateNewPackage("USBKeyInfoReq");	
		pkt->AddStruct("USBKeyInfoReq", false, false, (LPBYTE)&req, sizeof(USBKeyInfoReq));
		if (SendPackage(pkt) == "")
		{
			Dbg("SendPackage failed, send USBKeyInfo req failed");
			return;
		}
		else
		{
			Dbg("send USBKeyInfo req success");
		}	


		pkt = ReceivePackage(5);
		if (pkt == NULL)
		{
			Dbg("ReceivePackage failed, don't revceive USBKeyInfo ans");
			return;
		}

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

			if (pkt->GetStructData("USBKeyInfoAns", pBuf, &nLen, &nArrayNum)) 
			{
				Dbg("recieve USBKeyInfo ans success");

				FSMEvent *evt = new USBKeyInfoAnsEvent(pBuf, nLen);
				USBKeyInfoAnsEvent *ans = (USBKeyInfoAnsEvent *)evt;
				if (ans->m_reply.USBKeyInitTime == NULL)
				{
					Dbg("Don't get <TaskID=%s> info!",pUSBKeyID);
				}
				else 
				{
					Dbg("get <USBKeyID=%s> info <%s>!",pUSBKeyID,ans->m_reply.USBKeyInitTime);
					memcpy(m_pFSM->m_USBKeyInitTime, ans->m_reply.USBKeyInitTime, 20);
				}
				delete evt;
			} 
			else 
			{
				Dbg("create invalid TaskAns packet!");
				//OnDisconnect();
			}
			delete pBuf;
		}
		else
		{
			Dbg("don't recieve TaskAns packet!");
			//OnDisconnect();
		}
	}

protected:
	virtual void OnPkgAnswer(const CSmartPointer<IPackage> &pRecvPkg) 
	{
		Dbg("start OnReceivePackage!");
		string serviceCode = pRecvPkg->GetServiceCode();

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

				if (pRecvPkg->GetStructData("CertAns", pBuf, &nLen, &nArrayNum)) 
				{
					FSMEvent *evt = new CertAnsEvent(pBuf, nLen);
					CertAnsEvent *ans = (CertAnsEvent *)evt;
					if (ans->m_reply.RootCert == NULL
						|| ans->m_reply.CaCert == NULL)
					{
						Dbg("Don't update ca cert!");
					}
					else 
					{
						Dbg("Update ca cert!");
						//保存证书到指定目录
						FILE* fp = fopen(ROOT_CERT_PATH, "w");						
						fwrite(ans->m_reply.RootCert, 1, strlen(ans->m_reply.RootCert), fp);
						fclose(fp);

						fp = fopen(CA_CERT_PATH, "w");
						fwrite(ans->m_reply.CaCert, 1, strlen(ans->m_reply.CaCert), fp);
						fclose(fp);
					}
					delete evt;
				} 
				else 
				{
					Dbg("create invalid cert RvcCertAns packet!");
					//OnDisconnect();
				}
				delete pBuf;
			}
		}
		else if (serviceCode == "CertBla")
		{
			HandleCertBlackListRet(pRecvPkg);
		}
		else 
		{
			Dbg("unknown service code!");
			//OnDisconnect();
		}		
	};

	void HandleCertBlackListRet(const CSmartPointer<IPackage> &pRecvPkg)
	{
		DWORD dwSysCode, dwUserCode;
		string strErrMsg;

		m_pFSM->m_bAns = TRUE;//告诉状态机收到回复

		if (pRecvPkg->GetErrMsg(dwSysCode, dwUserCode, strErrMsg))
		{
			cout << "error in package: " << strErrMsg.c_str() << " [" << dwSysCode << "]" << endl;
		}
		else
		{
			int nLen = pRecvPkg->GetStructLen("CertBlackListRet");
			if (nLen <= 0)
			{
				Dbg("not find struct [CertBlackListRet] in package");
			}
			else
			{
				//Save File
				char activePath1[1024], activePath2[1024], realActivePath[1024], dirPath[1024], blackListPath[1024];

				sprintf(activePath1, "D:\\Run\\version\\active.txt");
				sprintf(activePath2, "C:\\Run\\version\\active.txt");
				if (checkFileExist(activePath1, FALSE))
				{
					memcpy(realActivePath, activePath1, strlen(activePath1) + 1);
					sprintf(dirPath, "D:\\Run\\version");
				}
				else if (checkFileExist(activePath2, FALSE))
				{
					memcpy(realActivePath, activePath2, strlen(activePath2) + 1);
					sprintf(dirPath, "C:\\Run\\version");
				}
				else
					return;
				//read version
				char buffer[255];
				ifstream iniFile(realActivePath);
				iniFile.getline(buffer, 100);
				iniFile.close();
				sprintf(blackListPath, "%s\\%s\\cfg\\certs", dirPath, buffer);
				//certs文件夹，需要判断该文件夹是否存在，不存在则创建该文件夹
				if (!checkDirExist(blackListPath))
					return;
				sprintf(blackListPath, "%s\\CertBlackList.txt", blackListPath);
				//CertBlackList.txt文件，不存在则创建
				if (!checkFileExist(blackListPath, TRUE))
					return;
				ofstream blackFile(blackListPath);
				if (blackFile.is_open())
				{
					blackFile << "";
					blackFile.close();
				}
				else
					return;

				BYTE *pBuf = new BYTE[nLen];
				memset(pBuf, 0, nLen);

				int nArrayNum = 0;
				if (!pRecvPkg->GetStructData("CertBlackListRet", pBuf, &nLen, &nArrayNum))
				{
					Dbg("get struct [CertBlackListRet] data fail");
				}
				else
				{

					CertBlackListRet *pReq = (CertBlackListRet*)pBuf;
					ofstream blackFile(blackListPath);
					for (int i = 0; i < nArrayNum; i++)
					{
						char dstID[300];
						cout << (char *)pReq[i].ukeyID << endl;
						certBlackCrypt(dstID, pReq[i].ukeyID);
						blackFile << dstID << endl;
					}
					blackFile.close();
				}

				delete[] pBuf;
			}
		}
	}

	/*virtual void OnDisconnect() 
	{
		m_pFSM->PostEventFIFO(new FSMEvent(USER_EVT_DISCONNECT));
	}*/

	virtual void OnReceivePackage(IPackage *pRecvPkg)
	{
	}

private:
	ConsoleFSM *m_pFSM;
};