myvtm/Module/mod_ResourceWatcher/mod_ResourceWatcher.h

#pragma once

#include "modVer.h"
#include "ResourceWatcherFSM.h"
#include "UOSTools.hpp"
#include "fileutil.h"
#include "UpgradeManager_msg_g.h"

class ResourceWatcherEntity;

#define ENT_TIMERID_CHECK_SOGOU_INPUT_INSTALLED_STATE 1
#define ENT_TIMERINTERVAL_CHECK_SOGOU_INPUT_INSTALLED_STATE 60 * 1000

#define ENT_TIMERID_CHECK_SOGOU_INPUT_PROCESS_STATUS_CHANGE 3
#define ENT_TIMERINTERVAL_CHECK_SOGOU_INPUT_PROCESS_STATUS_CHANGE 30 * 1000

#define ENT_TIMERID_PROCESS_CHECK 66
#define ENT_TIMERINTERVAL_PROCESS_CHECK 60 * 60 * 1000  //进程检测间隔默认一小时

#define ENCODING (X509_ASN_ENCODING | PKCS_7_ASN_ENCODING)  

const int AbsolutePath = 0;
const int AudioDefaultPath = 1; 
const int VideoDefaultPath = 2; 

class ResourceWatcherServiceSession : public ResourceWatcherService_ServerSessionBase
{
public:

	ResourceWatcherServiceSession(ResourceWatcherEntity* pEntity) : m_pEntity(pEntity) {}

	virtual ~ResourceWatcherServiceSession() {}

	virtual void Handle_GetDevInfo(SpReqAnsContext<ResourceWatcherService_GetDevInfo_Req,
		ResourceWatcherService_GetDevInfo_Ans>::Pointer ctx);

	virtual void Handle_OperateFile(SpReqAnsContext<ResourceWatcherService_OperateFile_Req, ResourceWatcherService_OperateFile_Ans>::Pointer ctx);

	virtual void Handle_BizLinkDetect(SpReqAnsContext<ResourceWatcherService_BizLinkDetect_Req, ResourceWatcherService_BizLinkDetect_Ans>::Pointer ctx);

	virtual void Handle_CheckNetType(SpReqAnsContext<ResourceWatcherService_CheckNetType_Req, ResourceWatcherService_CheckNetType_Ans>::Pointer ctx);

	virtual void Handle_GetBizLinks(SpReqAnsContext<ResourceWatcherService_GetBizLinks_Req, ResourceWatcherService_GetBizLinks_Ans>::Pointer ctx);

	virtual void Handle_GetThirdPartyInstallState(SpReqAnsContext<ResourceWatcherService_GetThirdPartyInstallState_Req, ResourceWatcherService_GetThirdPartyInstallState_Ans>::Pointer ctx);

	virtual void Handle_InstallThirdPartyProgram(SpReqAnsContext<ResourceWatcherService_InstallThirdPartyProgram_Req, ResourceWatcherService_InstallThirdPartyProgram_Ans>::Pointer ctx);

	virtual void Handle_UninstallThirdPartyProgram(SpReqAnsContext<ResourceWatcherService_UninstallThirdPartyProgram_Req, ResourceWatcherService_UninstallThirdPartyProgram_Ans>::Pointer ctx);

	virtual void Handle_RestartThirdPartyProgram(SpReqAnsContext<ResourceWatcherService_RestartThirdPartyProgram_Req, ResourceWatcherService_RestartThirdPartyProgram_Ans>::Pointer ctx);

	virtual void Handle_ProcessDetectThirdPartyProgram(SpReqAnsContext<ResourceWatcherService_ProcessDetectThirdPartyProgram_Req, ResourceWatcherService_ProcessDetectThirdPartyProgram_Ans>::Pointer ctx);

	virtual void Handle_FilesClean(SpReqAnsContext<ResourceWatcherService_FilesClean_Req, ResourceWatcherService_FilesClean_Ans>::Pointer ctx);

	virtual void Handle_FetchSystemSnapshot(SpReqAnsContext<ResourceWatcherService_FetchSystemSnapshot_Req, ResourceWatcherService_FetchSystemSnapshot_Ans>::Pointer ctx);

	virtual void Handle_CheckIsFileExists(SpReqAnsContext<ResourceWatcherService_CheckIsFileExists_Req, ResourceWatcherService_CheckIsFileExists_Ans>::Pointer ctx);

private:
	ResourceWatcherEntity* m_pEntity;
};

class ResourceWatcherEntity : public CEntityBase, public IBroadcastListener, public ITimerListener, public ISysVarListener
{
public:
	ResourceWatcherEntity(){}
	virtual ~ResourceWatcherEntity() {}
	virtual const char* GetEntityName() const { return "ResourceWatcher"; }
    const char* GetEntityVersion() const { return MODULE_VERSION_FULL; }

	virtual CServerSessionBase* OnNewSession(const char*, const char*)
	{
		return new ResourceWatcherServiceSession(this);
	}

	virtual void OnPreStart(CAutoArray<CSimpleStringA> strArgs,
		CSmartPointer<ITransactionContext> pTransactionContext)
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Version %s; Complied at: %s %s", MOD_VERSION, __DATE__, __TIME__);

		ErrorCodeEnum errorCode = Error_Succeed;

		errorCode = m_fsm.Init(this);

		if (errorCode == Error_Succeed) {

            CSmartPointer<IEntityFunction> spEntityFunction = GetFunction();
            CSystemStaticInfo staticInfo;
            spEntityFunction->GetSystemStaticInfo(staticInfo);
			
			updateShowFlag = false;
			newestSogouInstall = false;
			lastUpgradeInstallTime = 0; //上次升级安装时间
			lastUpgradeSwitchTime = 0;  //上次升级切换时间
			lastSogouChangeEndTime = 0;    //上一次切换结束判定的时间
			lastSogouChangeWarn = "";  //上一次搜狗告警信息
			sogouProcessRun = 0;      //搜狗进程是否启动

			errorCode = spEntityFunction->SubscribeBroadcast("UpgradeManager", NULL, this, m_uuidUpgradeStateEventListener);
			if (errorCode != Error_Succeed)
			{
				LOG_TRACE("Subscribe UpgradeManager evt failed 0x%x", errorCode);
				pTransactionContext->SendAnswer(errorCode);
				return;
			}
		}
		
		pTransactionContext->SendAnswer(errorCode);
	}

	void OnStarted()
	{
		m_fsm.AfterInit();

		CSmartPointer<IEntityFunction> spEntityFunction = GetFunction();
		spEntityFunction->SetTimer(ENT_TIMERID_CHECK_SOGOU_INPUT_INSTALLED_STATE,
			this, ENT_TIMERINTERVAL_CHECK_SOGOU_INPUT_INSTALLED_STATE);

		CSimpleStringA uiState;
		spEntityFunction->GetSysVar("UIState", uiState);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("NETWORK_PROBE Timer GetUIState %s", (LPCTSTR)uiState);
		if (uiState[0] == 'M') {
			m_fsm.TriggerAtStatusChanged(true);
		}
		spEntityFunction->RegistSysVarEvent("UIState", this);

		CSmartPointer<IConfigInfo> spCtSettingConfig;
		GetFunction()->OpenConfig(Config_CenterSetting, spCtSettingConfig);

		int procFlag = 0;
		int closeSecCheck = 0;
#if defined(RVC_OS_WIN)
		spCtSettingConfig->ReadConfigValueInt("ResourceWatcher", "ProcDetectFlag", procFlag);
#else
		spCtSettingConfig->ReadConfigValueInt("ResourceWatcher", "ProcDetectFlag4UOS", procFlag);
#endif //RVC_OS_WIN
		if (procFlag > 0)
		{
			CheckProcessStatus(); //启动时检测一次进程

			spCtSettingConfig->ReadConfigValueInt("ResourceWatcher", "CloseSecProcDetect", closeSecCheck);
			if (!closeSecCheck)
			{
				SecProcCheck(); //检测一次安全软件
			}

			int tTime = 0;
			spCtSettingConfig->ReadConfigValueInt("ResourceWatcher", "ProcCheckTime", tTime);
			if (tTime >= 0)
			{
				if (tTime == 0) tTime = ENT_TIMERINTERVAL_PROCESS_CHECK; //没设置时间的话默认一小时间隔
				spEntityFunction->SetTimer(ENT_TIMERID_PROCESS_CHECK, this, tTime);
			}
			else
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Invalid proccess check time:%d", tTime);
			}
		}

#if defined(RVC_OS_WIN)

		ReadFileContent();
		ReadFileInfo();
#endif //RVC_OS_WIN
	}

	/*ignore*/
	virtual void OnPrePause(CSmartPointer<ITransactionContext> pTransactionContext)
	{
		OnTimeout(ENT_TIMERID_CHECK_SOGOU_INPUT_INSTALLED_STATE);
		pTransactionContext->SendAnswer(Error_Succeed);
	}

	/*ignore*/
	virtual void OnPreContinue(CSmartPointer<ITransactionContext> pTransactionContext)
	{
		pTransactionContext->SendAnswer(Error_Succeed);
	}

	/*invoke fsm.onExit(), invoked when	entity will be closed*/
	virtual void OnPreClose(EntityCloseCauseEnum eCloseCause, CSmartPointer<ITransactionContext>pTransactionContext)
	{
		ErrorCodeEnum errorCode = m_fsm.OnExit();
		pTransactionContext->SendAnswer(errorCode);
	}

	virtual void OnSelfTest(EntityTestEnum eTestType,
		CSmartPointer<ITransactionContext>pTransactionContext)
	{
		m_fsm.SelfTest(eTestType, pTransactionContext);
	}

	virtual bool IsService() const
	{
		return true;
	}

	virtual bool IsMultiThread() const
	{
		return false;
	}

	void GetDevInfo(SpReqAnsContext<ResourceWatcherService_GetDevInfo_Req,
		ResourceWatcherService_GetDevInfo_Ans>::Pointer ctx)
	{
		LOG_FUNCTION();

		SystemBasicInfo info;
		ErrorCodeEnum result = m_fsm.CatchSystemBasicInfo(info);
		if (Error_Succeed == result) {
			ctx->Ans.type = info.strProductName;
			ctx->Ans.model = info.strManufacturer;
			ctx->Ans.version = info.strSerialNumber;
			ctx->Ans.state = 0;
		}
		ctx->Answer(result);
	}

	void BizLinkDetect(SpReqAnsContext<ResourceWatcherService_BizLinkDetect_Req,
		ResourceWatcherService_BizLinkDetect_Ans>::Pointer ctx)
	{
		m_fsm.BizLinkDetect(ctx);
	}

	void CheckNetType(SpReqAnsContext<ResourceWatcherService_CheckNetType_Req,
		ResourceWatcherService_CheckNetType_Ans>::Pointer ctx)
	{
		m_fsm.CheckNetType(ctx);
	}

	void GetBizLinks(SpReqAnsContext<ResourceWatcherService_GetBizLinks_Req,
		ResourceWatcherService_GetBizLinks_Ans>::Pointer ctx)
	{
		m_fsm.GetBizLinks(ctx);
	}

	void OperateFile(
		SpReqAnsContext<ResourceWatcherService_OperateFile_Req,
		ResourceWatcherService_OperateFile_Ans>::Pointer ctx)
	{
		ctx->Answer(Error_NotSupport);
	}

	void GetThirdPartyInstallState(SpReqAnsContext<ResourceWatcherService_GetThirdPartyInstallState_Req,
		ResourceWatcherService_GetThirdPartyInstallState_Ans>::Pointer ctx);

	void InstallThirdPartyProgram(SpReqAnsContext<ResourceWatcherService_InstallThirdPartyProgram_Req,
		ResourceWatcherService_InstallThirdPartyProgram_Ans>::Pointer ctx);

	void UninstallThirdPartyProgram(SpReqAnsContext<ResourceWatcherService_UninstallThirdPartyProgram_Req,
		ResourceWatcherService_UninstallThirdPartyProgram_Ans>::Pointer ctx);

	void RestartThirdPartyProgram(SpReqAnsContext<ResourceWatcherService_RestartThirdPartyProgram_Req,
		ResourceWatcherService_RestartThirdPartyProgram_Ans>::Pointer ctx);

	void ProcessDetectThirdPartyProgram(SpReqAnsContext<ResourceWatcherService_ProcessDetectThirdPartyProgram_Req,
		ResourceWatcherService_ProcessDetectThirdPartyProgram_Ans>::Pointer ctx);

	void FilesClean(SpReqAnsContext<ResourceWatcherService_FilesClean_Req,
		ResourceWatcherService_FilesClean_Ans>::Pointer ctx);

	void FetchSystemSnapshot(SpReqAnsContext<ResourceWatcherService_FetchSystemSnapshot_Req, ResourceWatcherService_FetchSystemSnapshot_Ans>::Pointer ctx);

	void InstallSogou(SpReqAnsContext<ResourceWatcherService_InstallThirdPartyProgram_Req,
		ResourceWatcherService_InstallThirdPartyProgram_Ans>::Pointer ctx);

	void UninstallSogou(SpReqAnsContext<ResourceWatcherService_UninstallThirdPartyProgram_Req,
		ResourceWatcherService_UninstallThirdPartyProgram_Ans>::Pointer ctx);

	void CheckIsFileExists(SpReqAnsContext<ResourceWatcherService_CheckIsFileExists_Req, 
		ResourceWatcherService_CheckIsFileExists_Ans>::Pointer ctx);

	int CheckMediaResource(int iFileType, const char* pFileName);

#if defined(_MSC_VER)
	SP_BEGIN_MSG_DISPATCH_MAP(ResourceWatcherEntity)
		SP_BEGIN_ENTITY_MSG("UpgradeManager")
		SP_MSG_HANDLE_NS(UpgradeManager, UpgradeStateEvent, OnUpgradeStateEvent)
		SP_END_ENTITY_MSG()
		SP_END_MSG_DISPATCH_MAP()
#else
	virtual void OnBroadcastEvent(CUUID SubID, const char* pszEntityName, DWORD dwMessageId, DWORD dwMessageSignature, CAutoBuffer Buffer) \
	{
		if (!pszEntityName) {
			LOG_TRACE("pszEntityName cannot empty!");
		}
		else if (_stricmp("UpgradeManager", pszEntityName) == 0) {
			switch (dwMessageId) {
			case eMsg_UpgradeStateEvent:
				if (eMsgSig_UpgradeStateEvent == dwMessageSignature) {
					UpgradeManager::UpgradeStateEvent t;
					ErrorCodeEnum Error = SpBuffer2Object(Buffer, t);
					if (Error == Error_Succeed)
						OnUpgradeStateEvent(pszEntityName, dwMessageId, dwMessageSignature, t);
				}
				else {
					LOG_TRACE("%s signature mismatched!", "UpgradeStateEvent");
				}
				break;
			default:
				LOG_TRACE("msg id %d ignored!", dwMessageId);
				break;
			}
		}
		else {
			LOG_TRACE("ignore pszEntityName");
		}
	}
#endif //_MSC_VER
	void OnSysVarEvent(const char* pszKey, const char* pszValue, const char* pszOldValue, const char* pszEntityName)
	{
		if ((_strnicmp(pszKey, "UIState", strlen("UIState")) == 0)) {
			m_fsm.TriggerAtStatusChanged(_strnicmp(pszValue, "M", strlen("M")) == 0);
		}
	}
private:

	void OnUpgradeStateEvent(const char* pszEntityName, DWORD dwMessageId, DWORD dwMessageSignature, UpgradeManager::UpgradeStateEvent& evt);

	//report sogou input software install state and installed information
	ErrorCodeEnum ReportSogouInstallState();

	void OnTimeout(DWORD dwTimerID)
	{
		if (dwTimerID == ENT_TIMERID_CHECK_SOGOU_INPUT_INSTALLED_STATE) {

			CSimpleStringA strState;
			auto err = GetFunction()->GetSysVar("UIState", strState);

			if (err == Error_Succeed && strState == "M") {
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("to check Sogou input install state...");
				if (Error_Succeed == ReportSogouInstallState()) {//如果安装了搜狗输入法，就去除检测搜狗输入法安装的定时器，并设置进程检测的定时器。
					GetFunction()->KillTimer(ENT_TIMERID_CHECK_SOGOU_INPUT_INSTALLED_STATE);
					GetFunction()->SetTimer(ENT_TIMERID_CHECK_SOGOU_INPUT_PROCESS_STATUS_CHANGE,
						this, ENT_TIMERINTERVAL_CHECK_SOGOU_INPUT_PROCESS_STATUS_CHANGE);
				}
			}
			else {
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Get UIState result: %s, %s", SpStrError(err), strState.GetData());
			}
		}
		else if (dwTimerID == ENT_TIMERID_CHECK_SOGOU_INPUT_PROCESS_STATUS_CHANGE) {
			DoCheckSogouProcessStatus();
		}
		else if (dwTimerID == ENT_TIMERID_PROCESS_CHECK) {
			CheckProcessStatus();
		}
		else {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Unkonwn timer id: %u", dwTimerID);
		}
	}
	void DoCheckSogouProcessStatus();
	std::string DoCheckCertainProcessStatus(const CAutoArray<CSimpleStringA>& pName);
	void SecProcCheck(); //检测终端安全软件应用

	ErrorCodeEnum UnzipPack(const char* unZipPackName);//解压文件
	CSimpleStringA GetFilePathWithDir(CSimpleStringA dir, CSimpleStringA fileName);
	std::vector<std::string> GetUserNameList(bool bExcludeRoot = false);
	ErrorCodeEnum RunShellScript(LPCTSTR cmdline);
	ErrorCodeEnum DeleteUnzipDir();//清理临时解压包文件
	BOOL KillProcessFromName(const CSimpleStringA& strProcessName);
	bool is_str_utf8(const char* str);
	/// <summary>
	/// 通过集中配置检测指定进程是否存在
	/// </summary>
	void CheckProcessStatus();

#if defined(RVC_OS_WIN)
	void ReadFileContent();
	void ReadFileInfo();
	void ChcekDiskFileSpace();
#else
	ErrorCodeEnum GetSogouPkgDirPath(CSimpleStringA& strPkgPath);
#endif //RVC_OS_WIN

private:
	ResourceWatcherFSM m_fsm;
	CUUID m_uuidUpgradeStateEventListener;
	BOOL updateShowFlag;
	BOOL newestSogouInstall; //最近一次安装的标志

	time_t lastUpgradeInstallTime; //上次升级安装时间
	time_t lastUpgradeSwitchTime;  //上次升级切换时间
	time_t lastSogouChangeEndTime;    //上一次进程切换时间
	CSimpleStringA lastSogouChangeWarn;  //上一次搜狗告警信息
	BOOL isSogouUpdateChange;
	int sogouProcessRun;

	vector<CSimpleStringA> sogouChangeWarn;
	vector<time_t> sogouChangeTime;
};

struct InstallSogouTask : public ITaskSp
{
	SpReqAnsContext<ResourceWatcherService_InstallThirdPartyProgram_Req,
		ResourceWatcherService_InstallThirdPartyProgram_Ans>::Pointer ctx;

	ResourceWatcherEntity* m_pEntity;
	InstallSogouTask(ResourceWatcherEntity* entity) :m_pEntity(entity) {}
	void Process()
	{
		m_pEntity->InstallSogou(ctx);
	}
};

struct UninstallSogouTask : public ITaskSp
{
	SpReqAnsContext<ResourceWatcherService_UninstallThirdPartyProgram_Req,
		ResourceWatcherService_UninstallThirdPartyProgram_Ans>::Pointer ctx;

	ResourceWatcherEntity* m_pEntity;
	UninstallSogouTask(ResourceWatcherEntity* entity) :m_pEntity(entity) {}
	void Process()
	{
		m_pEntity->UninstallSogou(ctx);
	}
};