myvtm/Module/mod_UpgradeMgr/UpgradeMgrCnn.cpp

#include "UpgradeMgrConn.h"
#include <string.h>
#include "GetDevInfoHelper.h"
#include "UpgradeMgrFSM.h"
#include "mod_UpgradeMgr.h"

#ifdef RVC_OS_WIN
#else
#include <sys/utsname.h>
#include <errno.h>
#endif


namespace UpgradeConnect {

void CUpgradeMgrConn::OnDisconnect()
{
	Dbg("connection disconnect");
	m_pFSM->PostEventFIFO(new FSMEvent(CReportMgrFSM::Event_Disconnected));
}

void CUpgradeMgrConn::OnPkgAnswer(const CSmartPointer<IPackage> &pRecvPkg)
{
	string serviceCode = pRecvPkg->GetServiceCode();
	if (serviceCode == "POLL")
	{
		HandlePollUpgradeRet(pRecvPkg);
	}
	else if (serviceCode == "CONFIRM")
	{
		HandleConfirmUpgradeRet(pRecvPkg);
	}
	else if (serviceCode == "REPORT")
	{
		HandleReportRet(pRecvPkg);
	}
	else if (serviceCode == "QRYEXEC")
	{
		HandleQueryExecInfoRet(pRecvPkg);
	}
	else if (serviceCode == "MD5List")
	{
		HandleMD5ListRet(pRecvPkg);
	}
	else if (serviceCode == "CUSVER")
	{
		HandleReportSysCustomVerRet(pRecvPkg);
	}
	else
	{
		LOG_TRACE("unknown service code: %s", serviceCode.c_str());
	}
}

ErrorCodeEnum CUpgradeMgrConn::SendConfirmUpgradeReq(const char* pPackExecID)
{
	CSmartPointer<IPackage> package = CreateNewPackage("CONFIRM");
	Confirm_Req req = {};
#ifdef RVC_OS_WIN
	strncpy_s(req.PackExecID, sizeof(req.PackExecID), pPackExecID, _TRUNCATE);
#else
	strncpy(req.PackExecID, pPackExecID, sizeof(req.PackExecID));
#endif
	package->AddStruct("CONF_REQ", false, false, (BYTE*)&req, sizeof(req), 1);
	//Dbg("send upgrade confirm package");

	SendPackage(package);
	return Error_Succeed;
}

ErrorCodeEnum CUpgradeMgrConn::SendQueryExecInfoReq(const char* pPackExecID)
{
	CSmartPointer<IPackage> package = CreateNewPackage("QRYEXEC");
	QueryExec_Req req = {};
#ifdef RVC_OS_WIN
	strncpy_s(req.PackExecID, sizeof(req.PackExecID), pPackExecID, _TRUNCATE);
#else
	strncpy(req.PackExecID, pPackExecID, sizeof(req.PackExecID));
#endif
	package->AddStruct("EXEC_REQ", false, false, (BYTE*)&req, sizeof(req), 1);
	//Dbg("send upgrade confirm package");

	SendPackage(package);
	return Error_Succeed;
}

ErrorCodeEnum CUpgradeMgrConn::SendPollUpgradeReq(bool IsHashComputed)
{
	auto pFunc = m_pEntity->GetFunction();
	CSystemStaticInfo info;
	auto rc = pFunc->GetSystemStaticInfo(info);
	if (rc != Error_Succeed)
	{
		LogError(Severity_Middle, rc, 0, "get system static info error");
		return rc;
	}

	PollUpgrade_Req4 req1;
	memset(&req1, 0, sizeof(req1));

	strncpy(req1.TerminalNo, info.strTerminalID, sizeof(req1.TerminalNo)-1);
	strncpy(req1.MachineType, info.strMachineType, sizeof(req1.MachineType)-1);
	
	// 	设备版本，低两位为小版本号，高两位为大版本号	Binary	4
	WORD nMajor = info.MachineVersion.GetMajor();
	req1.MachineVersion[0] = (nMajor >> 8) & 0xFF;
	req1.MachineVersion[1] = nMajor & 0xFF;
	
	WORD nMinor = info.MachineVersion.GetMinor();
	req1.MachineVersion[2] = (nMinor >> 8) & 0xFF;
	req1.MachineVersion[3] = nMinor & 0xFF;
	
	//	安装版本，其中包含软件框架版本	binary	8
	WORD nTmp = info.InstallVersion.GetMajor();
	req1.InstallVersion[0] = (nTmp >> 8) & 0xFF;
	req1.InstallVersion[1] = nTmp & 0xFF;
	nTmp = info.InstallVersion.GetMinor();
	req1.InstallVersion[2] = (nTmp >> 8) & 0xFF;
	req1.InstallVersion[3] = nTmp & 0xFF;
	nTmp = info.InstallVersion.GetRevision();
	req1.InstallVersion[4] = (nTmp >> 8) & 0xFF;
	req1.InstallVersion[5] = nTmp & 0xFF;
	nTmp = info.InstallVersion.GetBuild();
	req1.InstallVersion[6] = (nTmp >> 8) & 0xFF;
	req1.InstallVersion[7] = nTmp & 0xFF;

	// OS版本
#ifdef RVC_OS_WIN
	OSVERSIONINFO osvi;
	ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
	osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
	GetVersionEx(&osvi);
	req1.OSVersion[0] = (osvi.dwMajorVersion >> 8) & 0xFF;
	req1.OSVersion[1] = osvi.dwMajorVersion & 0xFF;
	req1.OSVersion[2] = (osvi.dwMinorVersion >> 8) & 0xFF;
	req1.OSVersion[3] = osvi.dwMinorVersion & 0xFF;
	req1.OSVersion[4] = (osvi.dwBuildNumber >> 8) & 0xFF;
	req1.OSVersion[5] = osvi.dwBuildNumber & 0xFF;
#else
	DWORD dwMajorVersion(0), dwMinorVersion(0), dwBuildNumber(0);
	struct utsname kernel_info;
	int ret = uname(&kernel_info);
	if (ret == 0) {
		int n = sscanf((const char*)kernel_info.release, "%d.%d", &dwMajorVersion, &dwMinorVersion);
	}
	else {
		Dbg("get linux kernel version fail: %s", strerror(errno));
	}
	req1.OSVersion[0] = (dwMajorVersion >> 8) & 0xFF;
	req1.OSVersion[1] = dwMajorVersion & 0xFF;
	req1.OSVersion[2] = (dwMinorVersion >> 8) & 0xFF;
	req1.OSVersion[3] = dwMinorVersion & 0xFF;
	req1.OSVersion[4] = (dwBuildNumber >> 8) & 0xFF;
	req1.OSVersion[5] = dwBuildNumber & 0xFF;
#endif
	



	strncpy(req1.Sites, info.strSite, sizeof(req1.Sites)-1);

	CSmartPointer<IPackage> package = CreateNewPackage("POLL");
	package->AddStruct("POLLREQ4", false, false, (BYTE*)&req1, sizeof(req1));

	// 获取硬件信息
	CAutoArray<CSimpleStringA> devNames;
	rc = SpGetAllDevices(m_pEntity, devNames);
	if (rc != Error_Succeed)
	{
		LogError(Severity_Middle, rc, 0,  "get all device info error");
		return rc;
	}

	int nDevEntityCount = devNames.GetCount();
	if (nDevEntityCount >0)
	{
		int nBufLen = nDevEntityCount * sizeof(PollUpgrade_Req2);
		char *pBuf = new char[nBufLen];
		memset(pBuf, 0, nBufLen);

		PollUpgrade_Req2 *pDevInfo = (PollUpgrade_Req2*)pBuf;

		for(int i=0; i<nDevEntityCount; i++)
		{
			CSimpleStringA strVersion, strModel, strVendor;
			rc = SpGetDeviceInfo(m_pEntity, devNames[i], strModel, strVendor, strVersion);
			if (rc == Error_Succeed)
			{
				strncpy(pDevInfo->Type, (const char*)devNames[i], sizeof(pDevInfo->Type)-1);
				strncpy(pDevInfo->Modal, (const char*)strModel, sizeof(pDevInfo->Modal)-1);
				strncpy(pDevInfo->Factory,(const char*)strVendor, sizeof(pDevInfo->Factory)-1);

				if (strVersion.GetLength() >0)
				{
					CAutoArray<CSimpleStringA> arr = strVersion.Split('.');
					for(int i=0; i<4 && i<arr.GetCount(); i++)
					{
						WORD w = (WORD) atoi(arr[i]);
						((BYTE*)pDevInfo->Version)[i*2] = (w >> 8) & 0xFF;
						((BYTE*)pDevInfo->Version)[i*2+1] = w & 0xFF;
					}
				}
			}

			pDevInfo++;
		}
		
		package->AddStruct("POLLREQ2", false, false, (BYTE*)pBuf, nBufLen, nDevEntityCount);
		delete[] pBuf;		
	}		

	// 获取当前版本安装包信息
	vector<CSimpleStringA> installedPacks;
	for(int i=0; i<info.LightPackInfos.GetCount(); i++)
		installedPacks.push_back(info.LightPackInfos[i].strPackName);

	if (!info.InstallPack.IsNullOrEmpty())
		installedPacks.push_back(info.InstallPack);

	CVersion lastVer = info.PreviousInstallVersion;
	while (lastVer.IsValid())
	{
		CInstallInfo lastVerInfo = {};
		rc = pFunc->GetInstallInfo(lastVer, lastVerInfo);
		if (rc != Error_Succeed)
			break;

		if (!lastVerInfo.InstallPack.IsNullOrEmpty())
			installedPacks.push_back(lastVerInfo.InstallPack);

		lastVer = lastVerInfo.PreviousInstallVersion;
	}

	int nPackCount = installedPacks.size();
	if (nPackCount >0)
	{
		//Dbg("current version has %d packs installed", nPackCount);
		int nBufLen = nPackCount * sizeof(PollUpgrade_Req5);
		char *pBuf = new char[nBufLen];
		memset(pBuf, 0, nBufLen);

		PollUpgrade_Req5 *pPackInfo = (PollUpgrade_Req5*)pBuf;

		for(int i=0; i<nPackCount; i++)
		{
			CSimpleStringA &strPackName = installedPacks[i];
			strncpy(pPackInfo->UpgradePack, strPackName, strPackName.GetLength()>MAX_PACKNAME_LEN?MAX_PACKNAME_LEN:strPackName.GetLength());
			pPackInfo->PackState = 'D';//CUpgradeMgrEntity::GetInstallStateVal(info.LightPackInfos[i].State);
			pPackInfo++;

			//Dbg("pack %s installed", (const char*)installedPacks[i]);
		}
		
		package->AddStruct("POLLREQ5", false, false, (BYTE*)pBuf, nBufLen, nPackCount);
		delete[] pBuf;		
	}
	
	//CSimpleStringA strMD5List = "";
	//((CUpgradeMgrEntity*)m_pEntity)->GetMD5List(strMD5List);
	PollUpgrade_Req6 req6;
	memset(&req6, 0, sizeof(req6));	
	//hash完成才添加hash文件
	if(IsHashComputed){
		CSimpleStringA SM3Hash= ((CUpgradeMgrEntity*)m_pEntity)->m_strSM3Hash;
		if (!SM3Hash.IsNullOrEmpty())
		{
			Dbg("add md5list hash");
			strncpy(req6.MD5ListHash, SM3Hash, SM3Hash.GetLength());
		}else{
			Dbg("add md5list hash fail");
		}
	}
	//CSimpleStringA md5List = ((CUpgradeMgrEntity*)m_pEntity)->m_strMD5List;
	//if (!md5List.IsNullOrEmpty())
	//{
	//	CSimpleStringA strMD5ListHash = "";
	//	((CUpgradeMgrEntity*)m_pEntity)->MD5Data(md5List, strMD5ListHash);
	//	if (strMD5ListHash.IsNullOrEmpty())
	//	{
	//		Dbg("get md5list hash fail");
	//	}
	//	else
	//	{
	//		Dbg("add md5list hash");
	//		strncpy(req6.MD5ListHash, strMD5ListHash, strMD5ListHash.GetLength());
	//	}
	//}

	package->AddStruct("POLLREQ6", false, false, (BYTE*)&req6, sizeof(req6));

	Dbg("send poll upgrade package");
	SendPackage(package);
	return Error_Succeed;
}

ErrorCodeEnum CUpgradeMgrConn::SendMD5ListReq(CSimpleStringA strBlockId)
{
	m_BlockId = atoi(strBlockId);
	Dbg("send MD5 list m_BlockId=%d", m_BlockId);

	auto pFunc = m_pEntity->GetFunction();
	CSystemStaticInfo info;
	auto rc = pFunc->GetSystemStaticInfo(info);
	if (rc != Error_Succeed)
	{
		LogError(Severity_Middle, rc, 0, "get system static info error");
		return rc;
	}

	CSmartPointer<IPackage> package = CreateNewPackage("MD5List");

	MD5List_Req req;
	memset(&req, 0, sizeof(req));
	strncpy(req.TerminalNo, info.strTerminalID, sizeof(req.TerminalNo)-1);

	//	安装版本，其中包含软件框架版本	binary	8
	WORD nTmp = info.InstallVersion.GetMajor();
	req.InstallVersion[0] = (nTmp >> 8) & 0xFF;
	req.InstallVersion[1] = nTmp & 0xFF;
	nTmp = info.InstallVersion.GetMinor();
	req.InstallVersion[2] = (nTmp >> 8) & 0xFF;
	req.InstallVersion[3] = nTmp & 0xFF;
	nTmp = info.InstallVersion.GetRevision();
	req.InstallVersion[4] = (nTmp >> 8) & 0xFF;
	req.InstallVersion[5] = nTmp & 0xFF;
	nTmp = info.InstallVersion.GetBuild();
	req.InstallVersion[6] = (nTmp >> 8) & 0xFF;
	req.InstallVersion[7] = nTmp & 0xFF;
	
	req.BlockId = m_BlockId;

	CSimpleStringA strMD5List = "";
	((CUpgradeMgrEntity*)m_pEntity)->GetMD5List(strMD5List);
	Dbg("MD5 list len=%d", strMD5List.GetLength());
	
	if (!strMD5List.IsNullOrEmpty())
	{
		if (strMD5List.GetLength() > m_BlockId*MAX_MD5LIST_LEN)
		{
			req.bEnd = false;
			strncpy(req.MD5List, strMD5List.GetData()+(m_BlockId-1)*MAX_MD5LIST_LEN, MAX_MD5LIST_LEN);
		}
		else
		{
			req.bEnd = true;
			strncpy(req.MD5List, strMD5List.GetData()+(m_BlockId-1)*MAX_MD5LIST_LEN, strMD5List.GetLength()-(m_BlockId-1)*MAX_MD5LIST_LEN);
		}

		//SM3hash字符串拷贝
		if(((CUpgradeMgrEntity*)m_pEntity)->m_IsSM3listSucc){
			CSimpleStringA strMD5ListHash = ((CUpgradeMgrEntity*)m_pEntity)->m_strSM3Hash;
			strncpy(req.MD5ListHash, strMD5ListHash, strMD5ListHash.GetLength());	
		}else{
			Dbg("get md5list hash fail");
		}

		//CSimpleStringA strMD5ListHash = "";
		//((CUpgradeMgrEntity*)m_pEntity)->MD5Data(strMD5List, strMD5ListHash);

		//if (strMD5ListHash.IsNullOrEmpty())
		//{
		//	Dbg("get md5list hash fail");
		//}
		//else
		//{	
		//	strncpy(req.MD5ListHash, strMD5ListHash, strMD5ListHash.GetLength());			
		//}

		package->AddStruct("MD5REQ", false, false, (BYTE*)&req, sizeof(req));
	}
	else
	{
		Dbg("get MD5 list fail");
	}

	Dbg("send MD5 list package");
	SendPackage(package);
	return Error_Succeed;
}

//ErrorCodeEnum CUpgradeMgrConn::SendMD5ListReq(CSimpleStringA strTerminalNo,CSimpleStringA strBlockId)//test
//{
//	m_BlockId = atoi(strBlockId);
//	Dbg("send MD5 list m_BlockId=%d", m_BlockId);
//
//	auto pFunc = m_pEntity->GetFunction();
//	CSystemStaticInfo info;
//	auto rc = pFunc->GetSystemStaticInfo(info);
//	if (rc != Error_Succeed)
//	{
//		LogError(Severity_Middle, rc, 0, "get system static info error");
//		return rc;
//	}
//
//	CSmartPointer<IPackage> package = CreateNewPackage("MD5List");
//
//	MD5List_Req req;
//	memset(&req, 0, sizeof(req));
//	strncpy(req.TerminalNo, strTerminalNo, sizeof(req.TerminalNo)-1);
//
//	//	安装版本，其中包含软件框架版本	binary	8
//	WORD nTmp = info.InstallVersion.GetMajor();
//	req.InstallVersion[0] = (nTmp >> 8) & 0xFF;
//	req.InstallVersion[1] = nTmp & 0xFF;
//	nTmp = info.InstallVersion.GetMinor();
//	req.InstallVersion[2] = (nTmp >> 8) & 0xFF;
//	req.InstallVersion[3] = nTmp & 0xFF;
//	nTmp = info.InstallVersion.GetRevision();
//	req.InstallVersion[4] = (nTmp >> 8) & 0xFF;
//	req.InstallVersion[5] = nTmp & 0xFF;
//	nTmp = info.InstallVersion.GetBuild();
//	req.InstallVersion[6] = (nTmp >> 8) & 0xFF;
//	req.InstallVersion[7] = nTmp & 0xFF;
//
//	req.BlockId = m_BlockId;
//
//	CSimpleStringA strMD5List = "";
//	((CUpgradeMgrEntity*)m_pEntity)->GetMD5List(strMD5List);
//	Dbg("MD5 list len=%d", strMD5List.GetLength());
//
//	if (!strMD5List.IsNullOrEmpty())
//	{
//		if (strMD5List.GetLength() > m_BlockId*MAX_MD5LIST_LEN)
//		{
//			req.bEnd = false;
//			strncpy(req.MD5List, strMD5List.GetData()+(m_BlockId-1)*MAX_MD5LIST_LEN, MAX_MD5LIST_LEN);
//		}
//		else
//		{
//			req.bEnd = true;
//			strncpy(req.MD5List, strMD5List.GetData()+(m_BlockId-1)*MAX_MD5LIST_LEN, strMD5List.GetLength()-(m_BlockId-1)*MAX_MD5LIST_LEN);
//		}
//
//		CSimpleStringA strMD5ListHash = "";
//		((CUpgradeMgrEntity*)m_pEntity)->MD5Data(strMD5List, strMD5ListHash);
//		if (strMD5ListHash.IsNullOrEmpty())
//		{
//			Dbg("get md5list hash fail");
//		}
//		else
//		{				
//			strncpy(req.MD5ListHash, strMD5ListHash, strMD5ListHash.GetLength());			
//		}
//
//		package->AddStruct("MD5REQ", false, false, (BYTE*)&req, sizeof(req));
//	}
//	else
//	{
//		Dbg("get MD5 list fail");
//	}
//
//	Dbg("send MD5 list package");
//	//SendPackage(package);
//
//	if (SendPackage(package) == "")
//	{
//		Dbg("SendPackage failed, send MD5REQ failed");
//		return Error_Unexpect;
//	}
//	else
//	{
//		Dbg("send MD5REQ success");
//	}	
//
//	package = ReceivePackage(5);
//	if (package == NULL)
//	{
//		Dbg("ReceivePackage failed, don't revceive MD5REQ ans");
//		return Error_Unexpect;
//	}
//
//	int nRetLen = package->GetStructLen("MD5RET");
//	if (nRetLen > 0) 
//	{
//		BYTE *pBuf = new BYTE[nRetLen];
//		memset(pBuf, 0, nRetLen);
//
//		int nArrayNum(0);
//		int nBufLen = nRetLen;
//		bool bRet = package->GetStructData("MD5RET", pBuf, &nBufLen, &nArrayNum);
//		assert(bRet && nArrayNum>0);
//		MD5List_Ret md5Ret;
//		memset(&md5Ret,0,sizeof(MD5List_Ret));
//		memcpy(&md5Ret, pBuf, sizeof(MD5List_Ret));
//
//		if (md5Ret.BlockId == 0)
//		{
//			Dbg("recieve  blockid %d, start to poll new pack!", md5Ret.BlockId);
//			/*auto pEvent = new CUpgradeMgrFSM::RvcCommRetEvent(CUpgradeMgrFSM::Event_StartPoll, pBuf, nArrayNum);
//			m_pFSM->PostEventFIFO(pEvent);*/
//
//			m_BlockId = 0;
//		}
//		else if (md5Ret.BlockId == m_BlockId)
//		{
//			Dbg("recieve right blockid %d, start to send next block %d!", md5Ret.BlockId, md5Ret.BlockId+1);
//			CSimpleStringA nextBlockId = CSimpleStringA::Format("%d",md5Ret.BlockId+1);
//			SendMD5ListReq(strTerminalNo, nextBlockId);
//		}
//		else 
//		{
//			Dbg("recieve wrong blockid %d, resend md5list!",md5Ret.BlockId);
//			SendMD5ListReq(strTerminalNo, "1");
//		}
//		delete pBuf;
//	}
//	else
//	{
//		Dbg("don't recieve MD5RET packet!");
//		//OnDisconnect();
//	}
//
//	return Error_Succeed;
//}

ErrorCodeEnum CUpgradeMgrConn::HandleReportRet(const CSmartPointer<IPackage> &pRecvPkg)
{
	DWORD dwSysCode, dwUserCode;
	string strErrMsg;
	ErrorCodeEnum rc;
	if (pRecvPkg->GetErrMsg(dwSysCode, dwUserCode, strErrMsg))
	{
		rc = (ErrorCodeEnum)dwSysCode;
		CSimpleStringA strMsg = CSimpleStringA::Format("report upgrade state error: %s", strErrMsg.c_str());
		LogError(Severity_Middle, (ErrorCodeEnum)dwSysCode, dwUserCode, strMsg);		
	}

	return Error_Succeed;
}

ErrorCodeEnum CUpgradeMgrConn::HandleConfirmUpgradeRet(const CSmartPointer<IPackage> &pRecvPkg)
{
	DWORD dwSysCode, dwUserCode;
	string strErrMsg;
	ErrorCodeEnum rc;
	if (pRecvPkg->GetErrMsg(dwSysCode, dwUserCode, strErrMsg))
	{
		rc = (ErrorCodeEnum)dwSysCode;
		LogError(Severity_Middle, (ErrorCodeEnum)dwSysCode, dwUserCode, strErrMsg.c_str());
		return rc;
	}

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

		int nArrayNum(0);
		int nBufLen = nRetLen;
		bool bRet = pRecvPkg->GetStructData("CONF_RET", pBuf, &nBufLen, &nArrayNum);
		assert(bRet && nArrayNum>0);

		auto pEvent = new CUpgradeMgrFSM::RvcCommRetEvent(CUpgradeMgrFSM::Event_EndConfirm, pBuf, nArrayNum);
		m_pFSM->PostEventFIFO(pEvent);		
		return Error_Succeed;
	}
	else
	{
		LogError(Severity_Low, Error_Unexpect, 0, "get struct [CONF_RET] from confirm return package fail");
		return Error_Unexpect;
	}
}

ErrorCodeEnum CUpgradeMgrConn::HandleQueryExecInfoRet(const CSmartPointer<IPackage> &pRecvPkg)
{
	DWORD dwSysCode, dwUserCode;
	string strErrMsg;
	ErrorCodeEnum rc;
	if (pRecvPkg->GetErrMsg(dwSysCode, dwUserCode, strErrMsg))
	{
		rc = (ErrorCodeEnum)dwSysCode;
		LogError(Severity_Middle, (ErrorCodeEnum)dwSysCode, dwUserCode, strErrMsg.c_str());
		return rc;
	}

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

		int nArrayNum(0);
		int nBufLen = nRetLen;
		bool bRet = pRecvPkg->GetStructData("EXEC_RET", pBuf, &nBufLen, &nArrayNum);
		assert(bRet && nArrayNum>0);

		auto pEvent = new CUpgradeMgrFSM::RvcCommRetEvent(CUpgradeMgrFSM::Event_EndQueryExec, pBuf, nArrayNum);
		m_pFSM->PostEventFIFO(pEvent);
		return Error_Succeed;
	}
	else
	{
		LogError(Severity_Low, Error_Unexpect, 0, "get struct [EXEC_RET] fail");
		return Error_Unexpect;
	}
}

ErrorCodeEnum CUpgradeMgrConn::HandlePollUpgradeRet(const CSmartPointer<IPackage> &pRecvPkg)
{
	DWORD dwSysCode, dwUserCode;
	string strErrMsg;
	ErrorCodeEnum rc = Error_Succeed;
	if (pRecvPkg->GetErrMsg(dwSysCode, dwUserCode, strErrMsg))
	{
		rc = (ErrorCodeEnum)dwSysCode;
		LogError(Severity_Middle, (ErrorCodeEnum)dwSysCode, dwUserCode, strErrMsg.c_str());
		return rc;
	}

	int nRetLen = pRecvPkg->GetStructLen("POLLRET1");
	if (nRetLen >0)
	{
		BYTE *pBuf = new BYTE[nRetLen];
		memset(pBuf, 0, nRetLen);
		
		int nArrayNum(0);
		int nBufLen = nRetLen;
		bool bRet = pRecvPkg->GetStructData("POLLRET1", pBuf, &nBufLen, &nArrayNum);
		assert(bRet && nArrayNum>0);

		auto pEvent = new CUpgradeMgrFSM::RvcCommRetEvent(CUpgradeMgrFSM::Event_EndPoll, pBuf, nArrayNum);
		m_pFSM->PostEventFIFO(pEvent);		
	}
	else if ((nRetLen =pRecvPkg->GetStructLen("POLLRET3")) > 0)
	{
		BYTE *pBuf = new BYTE[nRetLen];
		memset(pBuf, 0, nRetLen);

		int nArrayNum(0);
		int nBufLen = nRetLen;
		bool bRet = pRecvPkg->GetStructData("POLLRET3", pBuf, &nBufLen, &nArrayNum);
		assert(bRet && nArrayNum>0);

		auto pEvent = new CUpgradeMgrFSM::RvcCommRetEvent(CUpgradeMgrFSM::Event_EndPoll, pBuf, nArrayNum);
		m_pFSM->PostEventFIFO(pEvent);	
	}
	else if ((nRetLen =pRecvPkg->GetStructLen("POLLRET5")) > 0)
	{
		BYTE *pBuf = new BYTE[nRetLen];
		memset(pBuf, 0, nRetLen);

		int nArrayNum(0);
		int nBufLen = nRetLen;
		bool bRet = pRecvPkg->GetStructData("POLLRET5", pBuf, &nBufLen, &nArrayNum);
		assert(bRet && nArrayNum>0);

		auto pEvent = new CUpgradeMgrFSM::RvcCommRetEvent(CUpgradeMgrFSM::Event_EndPoll, pBuf, nArrayNum);
		m_pFSM->PostEventFIFO(pEvent);	
	}
	else
	{
		m_pFSM->PostEventFIFO(new CUpgradeMgrFSM::RvcCommRetEvent(CUpgradeMgrFSM::Event_EndPoll, 0, 0));
	}

	nRetLen = pRecvPkg->GetStructLen("POLLRET2");
	if (nRetLen >0)
	{
		LogEvent(Severity_Low, 0, "receive cancell upgrade instruct");
		
		BYTE *pBuf = new BYTE[nRetLen];
		memset(pBuf, 0, nRetLen);

		int nArrayNum(0);
		int nBufLen = nRetLen;
		bool bRet = pRecvPkg->GetStructData("POLLRET2", pBuf, &nBufLen, &nArrayNum);
		assert(bRet && nArrayNum>0);		

		auto pEvent = new CUpgradeMgrFSM::RvcCommRetEvent(CUpgradeMgrFSM::Event_CancelUpgrade, pBuf, nArrayNum);
		m_pFSM->PostEventFIFO(pEvent);
	}

	return rc;
}

ErrorCodeEnum CUpgradeMgrConn::HandleMD5ListRet(const CSmartPointer<IPackage> &pRecvPkg)
{
	DWORD dwSysCode, dwUserCode;
	string strErrMsg;
	ErrorCodeEnum rc = Error_Succeed;
	if (pRecvPkg->GetErrMsg(dwSysCode, dwUserCode, strErrMsg))
	{
		rc = (ErrorCodeEnum)dwSysCode;
		LogError(Severity_Middle, (ErrorCodeEnum)dwSysCode, dwUserCode, strErrMsg.c_str());
		return rc;
	}

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

		int nArrayNum(0);
		int nBufLen = nRetLen;
		bool bRet = pRecvPkg->GetStructData("MD5RET", pBuf, &nBufLen, &nArrayNum);
		assert(bRet && nArrayNum>0);
		MD5List_Ret md5Ret;
		memset(&md5Ret,0,sizeof(MD5List_Ret));
		memcpy(&md5Ret, pBuf, sizeof(MD5List_Ret));

		if (md5Ret.BlockId == 0)
		{
			Dbg("recieve  blockid %d, send md5list succ", md5Ret.BlockId);
			//auto pEvent = new CUpgradeMgrFSM::RvcCommRetEvent(CUpgradeMgrFSM::Event_StartPoll, pBuf, nArrayNum);
			//m_pFSM->PostEventFIFO(pEvent);
			m_BlockId = 0;
		}
		else if (md5Ret.BlockId == m_BlockId)
		{
			Dbg("recieve right blockid %d, start to send next block %d!", md5Ret.BlockId, md5Ret.BlockId+1);
			CSimpleStringA nextBlockId = CSimpleStringA::Format("%d",md5Ret.BlockId+1);
			SendMD5ListReq(nextBlockId);
		}
		else 
		{
			Dbg("recieve wrong blockid %d, resend md5list!",md5Ret.BlockId);
			SendMD5ListReq("1");
		}
		//delete pBuf;
	}
	return rc;
}

ErrorCodeEnum CUpgradeMgrConn::ReportUpgradeResult(const char* pPackName, CVersion &installVersion, char installState, DWORD stateTime, DWORD dwErrCode, const char *pComment)
{
	CSmartPointer<IPackage> package = CreateNewPackage("REPORT");

	Report3_Req req = {};

	auto pFunc = m_pEntity->GetFunction();
	CSystemStaticInfo info;
	auto rc = pFunc->GetSystemStaticInfo(info);
	if (rc != Error_Succeed)
	{
		LogError(Severity_Middle, rc, 0, "get system static info error");
		return rc;
	}
	strncpy(req.TerminalNo, (const char*)info.strTerminalID, sizeof(req.TerminalNo)-1);
	strncpy(req.UpgradePack, pPackName, sizeof(req.UpgradePack)-1);

	__int64 ver64 = installVersion.GetVersion64();
	for(int i=0; i<8; i++)
		req.InstallVersion[7-i] = ((BYTE*)&ver64)[i];

	req.InstallState = installState;
	req.FailCode = dwErrCode;
	req.StateTime = stateTime;

	if (pComment != NULL)
		strncpy(req.Comment, pComment, sizeof(req.Comment) - 1);

	package->AddStruct("REP3_REQ", false, false, (BYTE*)&req, sizeof(req));
	//Dbg("send report package");
	SendPackage(package);
	return Error_Succeed;
}

ErrorCodeEnum CUpgradeMgrConn::ReportSysCustomVer(const char* pPackName, const char*  pSysCustomVer, const char*  pFWID, const char*  pSysPatchName)
{
	CSmartPointer<IPackage> package = CreateNewPackage("CUSVER");

	ReportSysCustomVer_Req3 req = {};

	auto pFunc = m_pEntity->GetFunction();
	CSystemStaticInfo info;
	auto rc = pFunc->GetSystemStaticInfo(info);
	if (rc != Error_Succeed)
	{
		LogError(Severity_Middle, rc, 0, "get system static info fail");
		return rc;
	}

	CSimpleStringA strSysCustomVer = pSysCustomVer;
	CSimpleStringA strFWID = pFWID;
	CSimpleStringA strSysPatchName = pSysPatchName;

	strncpy(req.TerminalNo, (const char*)info.strTerminalID, sizeof(req.TerminalNo) - 1);
	strncpy(req.SysPackName, pPackName, sizeof(req.SysPackName) - 1);

	if (!strSysCustomVer.IsNullOrEmpty())
	{
		strncpy(req.SysCustomVer, pSysCustomVer, sizeof(req.SysCustomVer) - 1);
	}
	
	if (!strFWID.IsNullOrEmpty())
	{
		strncpy(req.FWID, pFWID, sizeof(req.FWID) - 1);
	}

	if (!strSysPatchName.IsNullOrEmpty())
	{
		strncpy(req.SysPatchName, pSysPatchName, sizeof(req.SysPatchName) - 1);
	}

	package->AddStruct("CUSVER_R3", false, false, (BYTE*)&req, sizeof(req));
	SendPackage(package);
	Dbg("ReportSysCustomVer()");
	return Error_Succeed;
}

ErrorCodeEnum CUpgradeMgrConn::HandleReportSysCustomVerRet(const CSmartPointer<IPackage> &pRecvPkg)
{
	DWORD dwSysCode, dwUserCode;
	string strErrMsg;
	ErrorCodeEnum rc;
	if (pRecvPkg->GetErrMsg(dwSysCode, dwUserCode, strErrMsg))
	{
		rc = (ErrorCodeEnum)dwSysCode;
		CSimpleStringA strMsg = CSimpleStringA::Format("report system custom version error: %s", strErrMsg.c_str());
		LogError(Severity_Middle, (ErrorCodeEnum)dwSysCode, dwUserCode, strMsg);
	}

	return Error_Succeed;
}

}