myvtm/Framework/spbase/SpEntityPrivilege.cpp

#include "stdafx.h"

#include "SpBase.h"
#include "SpTimer.h"
#include "SpMisc.h"
#include "SpEntity.h"
#include "SpModule.h"
#include "SpEntityPrivilege.h"
#include "SpAsyncWait.h"

#include "sp_iom.h"
#include "sp_svc.h"
#include "sp_log.h"
#include "sp_var.h"
#include "sp_def.h"
#include "sp_cfg.h"
#include "sp_env.h"

#include "memutil.h"
#include "strutil.h"
#include "fileutil.h"
#include "shm_array.h"
#include "shm_mem.h"
#include "iobuffer.h"
#include "iniutil.h"
#include "def.h"
#include "dbgutil.h"
#include <algorithm>
#include "sp_httpDefine.h"

#ifdef RVC_OS_WIN
#include "CodeSignVerify.h"
#include <io.h>
#include "log_producer_config.h"
#else
#include "sp_dbg_export.h"
#include <winpr/ini.h>
#include <winpr/string.h>
#include <winpr/crt.h>
#include <winpr/file.h>
#endif //RVC_OS_WIN

static ErrorCodeEnum ControlEntity(
	SpEntity *pEntity, 
	const char *pszEntityName,
	int call_type, 
	const char *cmd_line,
	//don't change this type bcz: 1. ipc would not convey pointer-type, and receiver may receive as 4bytes type.  [4/2/2020 11:13 Gifur]
	int param1, int param2,
	CSmartPointer<IAsynWaitSp> &pAsynWaitSp)
{
	if (!pszEntityName) {
		return Error_Null;
	} else if (strlen(pszEntityName) == 0) {
		return Error_Param;
	}

	sp_env_t *env = sp_get_env();
	sp_entity_t *ent = sp_mod_mgr_find_entity_by_name(env->mod_mgr, pszEntityName);
	if (!ent)
		return Error_NotExist;

	iobuffer_t *req_pkt = iobuffer_create(-1, -1);
	int v 	= ent->cfg->idx;
	bool fetch_user_code = false;
	iobuffer_write(req_pkt, IOBUF_T_I4, &v, 0);
	if (call_type == SHELL_CMD_REQ_ENTITY_START)
		iobuffer_write(req_pkt, IOBUF_T_STR, cmd_line, -1);
	else if (call_type == SHELL_CMD_REQ_ENTITY_TEST) {
		/** prohibit user from sending test call in the absence of test mode   [5/20/2020 Gifur] */
		if (param1 == 1/*Test_Examine*/ && !is_own_test_mode( env->cfg->args->test_mode)) {
			iobuffer_destroy(req_pkt);
			return Error_NoPrivilege;
		}
		fetch_user_code = true;
		iobuffer_write(req_pkt, IOBUF_T_I4, &param1, 0);
	}

	SpAsyncWaitRPC *pAsyncWait	= new SpAsyncWaitRPC(pEntity, &req_pkt, call_type, fetch_user_code);
	ErrorCodeEnum Error = pAsyncWait->Begin();

	if (Error == Error_Succeed) {
		pAsynWaitSp.Attach(pAsyncWait, pAsyncWait->GetRefCountPtr());		
	}
	
	pAsyncWait->DecrementRef();		// xkm@20150115

	if (req_pkt)
		iobuffer_dec_ref(req_pkt);

	return Error;
}

SpEntityPrivilege::SpEntityPrivilege(SpModule *pModule, sp_entity_t *ent, sp_cfg_shell_entity_t *cfg_ent, CEntityBase *pEntityBase)
: SpEntity(pModule, ent, cfg_ent, pEntityBase), m_pEntityLifeListener(NULL)
{
	spinlock_init(&m_maplock);
	m_pEntityStateListenerMap = stringmap_create(0);
}

SpEntityPrivilege::~SpEntityPrivilege()
{
	UnregistEntityStateEvent(NULL);
	stringmap_destroy(m_pEntityStateListenerMap);
}

ErrorCodeEnum SpEntityPrivilege::Init()
{
	ErrorCodeEnum Error = SpEntity::Init();

	return Error;
	
}

void SpEntityPrivilege::Term()
{
	//....
	SpEntity::Term();

	UnregistEntityStateEvent(NULL); // unregister all
}

CSmartPointer<IEntityFunctionPrivilege> SpEntityPrivilege::GetPrivilegeFunction()
{
	IEntityFunctionPrivilege *pPrivilege = dynamic_cast<IEntityFunctionPrivilege*>(this);
	return pPrivilege;
}

ErrorCodeEnum SpEntityPrivilege::StartEntity(const char *pszEntityName, const char *pszCmdLine,CSmartPointer<IAsynWaitSp> &pAsynWaitSp)
{
	return ControlEntity(this, pszEntityName, SHELL_CMD_REQ_ENTITY_START, pszCmdLine, 0, 0, pAsynWaitSp);
}

/*To Close*/
ErrorCodeEnum SpEntityPrivilege::StopEntity(const char *pszEntityName,CSmartPointer<IAsynWaitSp> &pAsynWaitSp)
{
	return ControlEntity(this, pszEntityName, SHELL_CMD_REQ_ENTITY_STOP, NULL, 0, 0, pAsynWaitSp);
}
/*To Close*/
ErrorCodeEnum SpEntityPrivilege::CloseEntity(const char *pszEntityName,CSmartPointer<IAsynWaitSp> &pAsynWaitSp)
{
	return ControlEntity(this, pszEntityName, SHELL_CMD_REQ_ENTITY_STOP, NULL, 0, 0, pAsynWaitSp);
}

/*To kill*/
ErrorCodeEnum SpEntityPrivilege::TerminateEntity(const char *pszEntityName,CSmartPointer<IAsynWaitSp> &pAsynWaitSp)
{
	return ControlEntity(this, pszEntityName, SHELL_CMD_REQ_ENTITY_TERMINATE, NULL, 0, 0, pAsynWaitSp);
}

ErrorCodeEnum SpEntityPrivilege::PauseEntity(const char *pszEntityName,CSmartPointer<IAsynWaitSp> &pAsynWaitSp)
{
	return ControlEntity(this, pszEntityName, SHELL_CMD_REQ_ENTITY_PAUSE, NULL, 0, 0, pAsynWaitSp);
}

ErrorCodeEnum SpEntityPrivilege::ContinueEntity(const char *pszEntityName,CSmartPointer<IAsynWaitSp> &pAsynWaitSp)
{
	return ControlEntity(this, pszEntityName, SHELL_CMD_REQ_ENTITY_CONTINUE, NULL, 0, 0, pAsynWaitSp);
}

ErrorCodeEnum SpEntityPrivilege::TestEntity(const char *pszEntityName,EntityTestEnum eTestType, CSmartPointer<IAsynWaitSp> &pAsynWaitSp)
{
	return ControlEntity(this, pszEntityName, SHELL_CMD_REQ_ENTITY_TEST, NULL, (int)eTestType, 0, pAsynWaitSp);
}

ErrorCodeEnum SpEntityPrivilege::RegistEntityLifeEvent(IEntityLifeListener *pListener)
{
	if (!m_pEntityLifeListener) {
		sp_mod_entity_life_cb cb;
		cb.on_entity_close = &SpEntityPrivilege::__on_entity_close;
		cb.on_entity_create = &SpEntityPrivilege::__on_entity_create;
		cb.on_entity_exception = &SpEntityPrivilege::__on_entity_exception;
		cb.user_data = this;
		int rc = sp_mod_entity_life_listener_create(&cb, m_svc, pListener, &m_pEntityLifeListener);
		return SpTranslateError(rc);
	} else {
		return Error_Duplication;
	}
}

ErrorCodeEnum SpEntityPrivilege::UnregistLiftEvent()
{
	if (!m_pEntityLifeListener) {
		return Error_NotInit;
	} else {
		sp_mod_entity_life_listener_destroy(m_pEntityLifeListener);
		m_pEntityLifeListener = NULL;
		return Error_Succeed;
	}
}

ErrorCodeEnum SpEntityPrivilege::RegistEntityStateEvent(const char *pszEntityName,IEntityStateListener *pListener)
{
	sp_env_t *env = sp_get_env();
	int target_ent_id;

	if (!pListener)
		return Error_Null;
	if (pszEntityName) {
		sp_entity_t *ent;
		ent = sp_mod_mgr_find_entity_by_name(env->mod_mgr, pszEntityName);
		if (!ent)
			return Error_NotExist;
		target_ent_id = ent->cfg->idx;
	} else {
		LOG_TRACE("registered state event for all entities!");
		target_ent_id = -1; // regist for all entities
		pszEntityName = "*";
	}

	ErrorCodeEnum Error = Error_Succeed;

	spinlock_enter(&m_maplock, -1);
	if (stringmap_find(m_pEntityStateListenerMap, pszEntityName) ){
		Error = Error_AlreadyExist;
	} else {
		int rc;
		sp_mod_entity_state_listener_t *listener;
		sp_mod_entity_event_cb cb;
		cb.on_close_connection = &SpEntityPrivilege::__on_close_connection;
		cb.on_create_connection = &SpEntityPrivilege::__on_create_connection;
		cb.on_user_state = &SpEntityPrivilege::__on_user_state;;
		cb.on_entity_state = &SpEntityPrivilege::__on_entity_state;
		cb.user_data = this;
		rc = sp_mod_entity_listener_create(target_ent_id, &cb, m_svc, pListener, &listener);
		if (rc == 0) {
			stringmap_add(m_pEntityStateListenerMap, pszEntityName ? pszEntityName : "*", listener);
		} else {
			Error = SpTranslateError(rc);
		}
	}
	spinlock_leave(&m_maplock);

	return Error;
}

ErrorCodeEnum SpEntityPrivilege::UnregistEntityStateEvent(const char *pszEntityName)
{
	ErrorCodeEnum Error = Error_Succeed;

	if (pszEntityName == NULL) {
		pszEntityName = "*";
	}

	spinlock_enter(&m_maplock, -1);
	if (pszEntityName) {
		stringmap_kv_pair *kvp;
		kvp = stringmap_find(m_pEntityStateListenerMap, pszEntityName);
		if (kvp) {
			sp_mod_entity_state_listener_t *listener;
			listener = (sp_mod_entity_state_listener_t *)stringmap_kv_pair_get_value(kvp);
			stringmap_remove(m_pEntityStateListenerMap, pszEntityName);
			sp_mod_entity_listener_destroy(listener);
		} else {
			Error = Error_NotExist;
		}
	} else {  // unregist all
		stringmap_iterator *it = stringmap_iterator_create(m_pEntityStateListenerMap);
		while (stringmap_iterator_next(it) == 0) {
			const char *ent_name = (const char*)stringmap_iterator_get_key(it);
			sp_mod_entity_state_listener_t *listener = (sp_mod_entity_state_listener_t *)stringmap_iterator_get_value(it);
			stringmap_remove(m_pEntityStateListenerMap, ent_name);
			sp_mod_entity_listener_destroy(listener);
		}
		stringmap_iterator_destroy(it);
	}
	spinlock_leave(&m_maplock);

	return Error;
}

ErrorCodeEnum SpEntityPrivilege::GetSpecifiedEntityState(const char* pszEntityName, EntityStateEnum& eEntityState, DWORD& dwUserState)
{
    if (pszEntityName == NULL) {
		return Error_Param;
    }
	sp_env_t* env = sp_get_env();
    sp_entity_t* ent;
	if (strlen(pszEntityName) == 0) {
		ent = m_ent;
	} else {
        ent = sp_mod_mgr_find_entity_by_name(env->mod_mgr, pszEntityName);
	}
	if (!ent) {
        return Error_NotExist;
	}
	eEntityState = (EntityStateEnum)ent->state;
	dwUserState = ent->user_state;
	return Error_Succeed;
}

ErrorCodeEnum SpEntityPrivilege::DisplayBlueScreen(const char *pszTitle)
{
	ErrorCodeEnum Error;
	iobuffer_t *pkt = iobuffer_create(-1, -1);
	iobuffer_write(pkt, IOBUF_T_STR, pszTitle, -1);
	//int nBlueScreen = 1;
	//iobuffer_write(pkt, IOBUF_T_I4, &nBlueScreen, 0);
	Error = PostInfoShell(SHELL_CMD_INFO_BLUESCREEN_DISPLAY, &pkt);
	if (pkt)
		iobuffer_dec_ref(pkt);
	return Error;
}


ErrorCodeEnum SpEntityPrivilege::UndisplayBlueScreen()
{
	ErrorCodeEnum Error;
	iobuffer_t *pkt = iobuffer_create(-1, -1);
	Error = PostInfoShell(SHELL_CMD_INFO_BLUESCREEN_UNDISPLAY, &pkt);
	if (pkt)
		iobuffer_dec_ref(pkt);
	return Error;
}

ErrorCodeEnum SpEntityPrivilege::Reboot(RebootTriggerEnum eTriggerReason,RebootWayEnum eWay)
{
	ErrorCodeEnum Error;
	int v;
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("call SpEntityPrivilege::Reboot, reason:%d, way:%d", eTriggerReason, eWay);
	iobuffer_t *pkt = iobuffer_create(-1, -1);
	v = eTriggerReason;
	iobuffer_write(pkt, IOBUF_T_I4, &v, 0);
	v = eWay;
	iobuffer_write(pkt, IOBUF_T_I4, &v, 0);
	Error = PostInfoShell(SHELL_CMD_INFO_MACHINE_REBOOT, &pkt);
	if (pkt)
		iobuffer_dec_ref(pkt);
	return Error;
}

bool SpEntityPrivilege::WriteInstallLog(const char *pszPackName, const char *pszLogText)
{
	auto env = sp_get_env();

	// 创建安装包日志文件
	CSimpleStringA strInstallLogDir = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "InstallLog", env->dir->root_runinfo_path);
	if (!ExistsDirA(strInstallLogDir))
		CreateDirA(strInstallLogDir, TRUE);

	// 写安装包日志
	CSimpleStringA strInstallLog = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "%s.log", (const char*)strInstallLogDir, pszPackName);
	FILE *pInstallLog = fopen(strInstallLog, "a+");
	if (pInstallLog == NULL)
	{
		LogError(Severity_Low, Error_Unexpect, 0,  CSimpleStringA::Format("open install log file [%s] to write fail", pszPackName));
		return false;
	}
	
	fprintf_s(pInstallLog, "[%s] %s\r\n",  (const char*)CSmallDateTime::GetNow().ToTimeString(), pszLogText);
	fflush(pInstallLog);
	fclose(pInstallLog);
	return true;
}

bool SpEntityPrivilege::RecursiveCopyDir(const char *pszSourceDir, const char *pszDestDir, CSimpleStringA& strErrInfo)
{
	array_header_t *arr;
	
	if (!ExistsDirA(pszSourceDir))
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("source dir [%s] not exists", pszSourceDir);
		return false;
	}

	if (!ExistsDirA(pszDestDir))
	{
		if (!CreateDirRecursiveA(pszDestDir))
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("create dir [%s] fail: %d", pszDestDir, GetLastError());
			return false;
		}

		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("create dir [%s] succ", pszDestDir);
	}

	arr = fileutil_get_sub_files_a(pszSourceDir);
	if (arr)
	{
		int i;
		for (i = 0; i < arr->nelts; ++i)
		{
			char szDestFile[256] = { 0 };
			char *file = ARRAY_IDX(arr, i, char*);
			strcpy(szDestFile, pszDestDir);
			if (szDestFile[strlen(szDestFile) - 1] != SPLIT_SLASH)
				strcat(szDestFile, SPLIT_SLASH_STR);
			strcat(szDestFile, strrchr(file, SPLIT_SLASH) + 1);

			if (!CopyFileA(file, szDestFile, FALSE))
			{
				strErrInfo = CSimpleStringA::Format("copy file [%s] fail: %d", file, GetLastError());
				DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("copy file [%s] fail: %d", file, GetLastError());
				toolkit_array_free2(arr);
				return false;
			}

			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("copy file [%s] succ", file);
		}
		toolkit_array_free2(arr);
	}

	arr = fileutil_get_sub_dirs_a(pszSourceDir);
	if (arr)
	{
		int i;
		for (i = 0; i < arr->nelts; ++i)
		{
			char szDestSubDir[256] = { 0 };
			char *dir = ARRAY_IDX(arr, i, char*);
			strcpy(szDestSubDir, pszDestDir);
			if (szDestSubDir[strlen(szDestSubDir) - 1] != SPLIT_SLASH)
				strcat(szDestSubDir, SPLIT_SLASH_STR);
			strcat(szDestSubDir, strrchr(dir, SPLIT_SLASH) + 1);

			if (!RecursiveCopyDir(dir, szDestSubDir, strErrInfo))
			{
				DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("copy dir [%s] fail: %d", dir, GetLastError());
				toolkit_array_free2(arr);
				return false;
			}

			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("copy dir [%s] succ", dir);
		}
		toolkit_array_free2(arr);
	}

	return true;
}

ErrorCodeEnum SpEntityPrivilege::UpdateActiveTxt(const char* strActiveFilePath, const char* toWriteVersionStr, bool toCheck)
{
	HANDLE hFile = ::CreateFileA(strActiveFilePath, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
	BOOL bSetSucc = FALSE;
	if (hFile == INVALID_HANDLE_VALUE)
	{
		LogError(Severity_Low, Error_Unexpect, 0, "open active.txt fail");
		return Error_Unexpect;
	}
	DWORD dwWrittenLen(0);
	bSetSucc = WriteFile(hFile, toWriteVersionStr, strlen(toWriteVersionStr), &dwWrittenLen, NULL);
	FlushFileBuffers(hFile);
	SetEndOfFile(hFile);
	CloseHandle(hFile);
	LOG_TRACE("write version [%s] succeed", toWriteVersionStr);

	//出现active文件为空的问题，此处增加写文件件后再读一次，确认是否写成功，以此来确认是否是写文件导致
	if (toCheck) {
		hFile = ::CreateFileA(strActiveFilePath, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
		if (hFile == INVALID_HANDLE_VALUE)
		{
			LogError(Severity_Low, Error_Unexpect, 0, "open active.txt fail");
			return Error_Unexpect;
		}

		DWORD dwReadLen(0);
		char cVer[16] = { 0 };

		if (ReadFile(hFile, cVer, 16, &dwReadLen, NULL))
		{
			LOG_TRACE("read active.txt, version len[%d], version[%s]", dwReadLen, cVer);

			//如果为空，则重写
			if (strlen(cVer) == 0)
			{
				if (WriteFile(hFile, toWriteVersionStr, strlen(toWriteVersionStr), &dwWrittenLen, NULL))
				{
					LOG_TRACE("rewrite active.txt success, version[%s]", toWriteVersionStr);
				}
				else
				{
					LogError(Severity_Low, Error_Unexpect, 0, "rewrite active.txt fail");
				}
			}
		}
		else
		{
			LogError(Severity_Low, Error_Unexpect, 0, "Read active.txt fail");
		}

		FlushFileBuffers(hFile);
		SetEndOfFile(hFile);
		CloseHandle(hFile);
	}
	return bSetSucc ? Error_Succeed : Error_Unexpect;
}

ErrorCodeEnum CopyFolder(CSimpleStringA strSourcePath, CSimpleStringA strDestPath)
{
	if (strSourcePath.IsNullOrEmpty() || strDestPath.IsNullOrEmpty())
	{
		return Error_Null;
	}
	
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("Start to copy dir %s to dir %s", (const char*)strSourcePath,(const char*)strDestPath);


#ifdef _WIN32
	_finddata_t FileInfo;
	CSimpleStringA strfind = strSourcePath + "\\*";
	long Handle = _findfirst(strfind, &FileInfo);
	if (-1L == Handle)
	{
		_findclose(Handle);
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("%s文件夹为空", strSourcePath);
		return Error_Succeed;
	}

	CSimpleStringA newPath;

	do{
		if (FileInfo.attrib & _A_SUBDIR)
		{
			if ((strcmp(FileInfo.name, ".") != 0) && (strcmp(FileInfo.name, "..") != 0))
			{
				newPath = strSourcePath + "\\" + FileInfo.name;
				CSimpleStringA newDestPath = strDestPath + "\\" + FileInfo.name;
				
				/*if (strcmp(FileInfo.name, "") == 0)
				{
				continue;
				}*/

				if (!ExistsDirA(newDestPath))
				{
					CreateDirA(newDestPath, TRUE);
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("Create Dir %s success", (const char*)newDestPath);
				}
				
				CopyFolder(newPath, newDestPath);
			}
		}
		else
		{			
			CSimpleStringA strFindName = FileInfo.name;
			{
				CSimpleStringA strSourceFile = strSourcePath + "\\" + strFindName;
				CSimpleStringA strDestFile = strDestPath + "\\" + strFindName;
				if (ExistsFileA(strSourceFile))
				{	
					// 先去除目标文件只读属性
					if (ExistsFileA(strDestFile))
						RemoveFileReadOnlyAttributeA(strDestFile);

					LOG_TRACE("copy file from [%s] to [%s]", (const char*)strSourceFile, (const char*)strDestFile);
					BOOL bRet = CopyFileA(strSourceFile, strDestFile, FALSE);

					// 去除只读属性
					if (bRet)
						RemoveFileReadOnlyAttributeA(strDestFile);				
					else
					{
						// 覆盖失败，则生成.new副本
						DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("copy file [%s] to [%s] fail, now save as .new file",  (const char*) strSourcePath, (const char*) strDestFile);

						strDestFile += ".new";
						bRet = CopyFileA(strSourceFile, strDestFile, FALSE);
						if (bRet)
						{
							RemoveFileReadOnlyAttributeA(strDestPath);				
							DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("copy [%s] as [%s] succeed", (const char*)strSourceFile, (const char*) strDestFile);
						}
						else
						{
							LogError(Severity_Low, Error_Unexpect, 0, CSimpleStringA::Format("copy file [%s] as [%s] fail",  (const char*) strSourceFile, (const char*) strDestFile));
							return Error_Block;
						}
					}
				}
				else
				{
					LogError(Severity_Low, Error_NotExist, 0, CSimpleStringA::Format("file [%s] to copy not exists", (const char*)strSourceFile));
					return Error_NotExist;
				}
			}
		}
	} while (_findnext(Handle, &FileInfo) == 0);

	_findclose(Handle);
	return Error_Succeed;

#else
	if (CopyDirA(strSourcePath, strDestPath)) {
		return Error_Succeed;
	}
	return Error_Unexpect;

#endif //_WIN32


}

CSimpleStringA GetFileDirectory(const char *pszFullPath)
{
	int i=strlen(pszFullPath)-1;
	for( ; i>0 && pszFullPath[i]!=SPLIT_SLASH; i--)NULL;
	return CSimpleStringA(pszFullPath, i);
}

#ifdef _WIN32

bool SpEntityPrivilege::IsWow64Process()
{
	typedef BOOL(WINAPI *LPFN_ISWOW64PROCESS)(HANDLE, PBOOL);
	LPFN_ISWOW64PROCESS fnIsWow64Process = (LPFN_ISWOW64PROCESS)GetProcAddress(GetModuleHandle("kernel32"), "IsWow64Process");
	
	BOOL bIsWow64 = FALSE;
	if (NULL != fnIsWow64Process)
	{
		if (!fnIsWow64Process(GetCurrentProcess(), &bIsWow64))
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("call IsWow64Process error: %d", GetLastError());
			return false;
		}

		return bIsWow64 == TRUE;
	}
	else
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("get IsWow64Process error: %d", GetLastError());
		return false;
	}
}
#endif //_WIN32

// result=0&msg=install ok
bool SpEntityPrivilege::GetSysUpgradeResult(const char *pszResultLog, ErrorCodeEnum &eErrorCode, CSimpleStringA &strErrMsg)
{
	// 设置初始值
	eErrorCode = Error_Succeed;
	strErrMsg = "";

	if (!ExistsFileA(pszResultLog))
	{
		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)(CSimpleStringA::Format("result log [%s] not exist", pszResultLog));
		strErrMsg = "result.log not exist";
		return false;
	}

	FILE *pResultLog = fopen(pszResultLog, "r");
	if (pResultLog == NULL)
	{
		LogError(Severity_Low, Error_Unexpect, 0, CSimpleStringA::Format("open result log [%s] fail", pszResultLog));
		strErrMsg = "open result.log fail";
		return false;
	}

	char szTmp[4096] = {};
	int nRead = fread_s(szTmp, sizeof(szTmp), 1, sizeof(szTmp), pResultLog);
	CSimpleStringA strResult = szTmp;
	fclose(pResultLog);
	pResultLog = NULL;

	auto arr = strResult.Split('&');
	for (int i = 0; i < arr.GetCount(); i++)
	{
		auto arr2 = arr[i].Split('=');
		if (arr2.GetCount() == 2)
		{
			if (stricmp(arr2[0], "result") == 0)
				eErrorCode = (ErrorCodeEnum)(DWORD)atoi(arr2[1]);
			else if (stricmp(arr2[0], "msg") == 0)
				strErrMsg = arr2[1];
		}
	}

	return true;
}

// File*A.*
bool SpEntityPrivilege::IsFileMatch(const char *pszFilter, const char *pszFileName)
{
	if (stricmp(pszFilter, "*") == 0 || stricmp(pszFilter, "*.*") == 0)
		return true;

	const char *p1 = pszFilter;
	const char *p2 = pszFileName;

	if (p1 == NULL)
		return true;

	if (p2 == NULL)
		return false;

	if (*p1 ==NULL && *p2 ==NULL)
		return true;
	else if (*p1 == NULL)
		return false;
	else if (*p2 == NULL)
	{
		// 查找*p1是否全是*
		while(*p1 == '*') 
			p1++;

		if (*p1 == NULL)
			return true;
		else
			return false;
	}

	if (*p1 != '*')
	{
		if (tolower(*p1) != tolower(*p2))
			return false;
		else
			return IsFileMatch(p1+1, p2+1);
	}
	else
	{
		while(*++p1 == '*');

		if (*p1 == NULL)
			return true;

		while (*p2)
		{
			while(tolower(*p1) != tolower(*p2) && *++p2);

			if (*p2  == NULL)
				return false;

			if(IsFileMatch(p1+1, p2+1))
				return true;

			p2++;
		}

		return false;
	}
}

CSimpleStringA SpEntityPrivilege::GetFileDirectory(const char *pszFullPath)
{
	int i=strlen(pszFullPath);
	for( ; i>0 && pszFullPath[i-1]!=SPLIT_SLASH; i--)NULL;
	return CSimpleStringA(pszFullPath, i);
}

ErrorCodeEnum SpEntityPrivilege::SetSysDebugLevel(const char *pszEntityName,DebugLevelEnum eDebugLevel,bool bPersist)
{
	sp_env_t *env = sp_get_env();

	if (!pszEntityName)
		return Error_Null;

	if (stricmp(pszEntityName, "SpShell") == 0)
		env->cfg->shell_ini->shell_debug_level = (int)eDebugLevel;

	sp_cfg_shell_entity_t *cfg_ent = sp_cfg_get_entity_by_name(env->cfg, pszEntityName);
	if (cfg_ent) {
		int old = cfg_ent->debug_level;
		if (old != eDebugLevel) {
			cfg_ent->debug_level = (int)eDebugLevel;
			if (bPersist) {
				return SpTranslateError(sp_cfg_refresh_debug_level(env->cfg, cfg_ent));
			}
		}
	} else {
		return Error_NotExist;
	}
	return Error_Succeed;
}

ErrorCodeEnum SpEntityPrivilege::RefreshFrameworkState(FrameworkStateEnum eState)
{
	int rc = Error_Succeed;
	char n[12] = { '\0' };
	sp_env_t* env = sp_get_env();
	sp_cfg_t* cfg = env->cfg;
	const int old_state = cfg->shell_ini->shell_state;
	if (old_state != (int)eState) {
		cfg->shell_ini->shell_state = eState;
		_itoa(eState, n, 10);
		rc = sp_var_client_set((sp_var_client_t*)m_var_client, VAR_RSERVERD_KEY_TERM_STATE, n, 0);
		if (rc == Error_Succeed) {
            iobuffer_t* pkt = iobuffer_create(-1, -1);
			int v1 = (int)eState;
			int v2 = (int)old_state;
            iobuffer_write(pkt, IOBUF_T_I4, &v1, 0);
			iobuffer_write(pkt, IOBUF_T_I4, &v2, 0);
			rc = PostInfoShell(SHELL_CMD_INFO_TERMINALSTAGE_CHANGE, &pkt);
			if (pkt) {
				iobuffer_dec_ref(pkt);
			}
		}
	}

	return SpTranslateError(rc);
}

ErrorCodeEnum SpEntityPrivilege::ShowOuputConsole()
{
	ErrorCodeEnum Error;
	iobuffer_t *pkt = iobuffer_create(-1, -1);
	Error = PostInfoShell(SHELL_CMD_INFO_OUTPUT_CONSOLE_ON, &pkt);
	if (pkt)
		iobuffer_dec_ref(pkt);
	return Error;
}

ErrorCodeEnum SpEntityPrivilege::CloseOuputConsole()
{
	ErrorCodeEnum Error;
	iobuffer_t *pkt = iobuffer_create(-1, -1);
	Error = PostInfoShell(SHELL_CMD_INFO_OUTPUT_CONSOLE_OFF, &pkt);
	if (pkt)
		iobuffer_dec_ref(pkt);
	return Error;
}

ErrorCodeEnum SpEntityPrivilege::BeginLogSend(const char* endpoint, const char* topicSys, const char* topicUser, const char* topicBeidou
	, const char* bussSys, const char* bussUser, const char* vtmWeb)
{
    ErrorCodeEnum Error;
    iobuffer_t* pkt = iobuffer_create(-1, -1);
    iobuffer_write(pkt, IOBUF_T_STR, endpoint, -1);
    iobuffer_write(pkt, IOBUF_T_STR, topicSys, -1);
    iobuffer_write(pkt, IOBUF_T_STR, topicUser, -1);
    iobuffer_write(pkt, IOBUF_T_STR, topicBeidou, -1);
    iobuffer_write(pkt, IOBUF_T_STR, bussSys, -1);
    iobuffer_write(pkt, IOBUF_T_STR, bussUser, -1);
	iobuffer_write(pkt, IOBUF_T_STR, vtmWeb, -1);
    Error = PostInfoShell(SHELL_CMD_INFO_START_UPLOAD_LOG, &pkt);
    if (pkt)
        iobuffer_dec_ref(pkt);
    return Error;
}

ErrorCodeEnum SpEntityPrivilege::SetHttpToken(const char* channelId, const char* token)
{
	ErrorCodeEnum Error;
	iobuffer_t* pkt = iobuffer_create(-1, -1);
	iobuffer_write(pkt, IOBUF_T_STR, channelId, -1);
	iobuffer_write(pkt, IOBUF_T_STR, token, -1);
	Error = PostInfoShell(SHELL_CMD_INFO_UPDATE_TOKEN, &pkt);
	if (pkt)
		iobuffer_dec_ref(pkt);
	return Error;
}


ErrorCodeEnum SpEntityPrivilege::SetEntityPriority(const char* pszEntityName, EntityPriorityEnum nPriority)
{
    if (!pszEntityName)
        return Error_Null;

    sp_env_t* env = sp_get_env();
    sp_mod_mgr_t* mod_mgr = env->mod_mgr;
    sp_entity_t* ent = sp_mod_mgr_find_entity_by_name(mod_mgr, pszEntityName);
	if (!ent) {
		return Error_NotExist;
	}

#ifndef _WIN32
	auto func = [nPriority] {
		switch (nPriority) {
		case Priority_Low:
			return TOOLKIT_PRIORITY_LOW;
		case Priority_Below_Normal:
			return TOOLKIT_PRIORITY_BELOW_NORMAL;
		case Priority_Normal:
			return TOOLKIT_PRIORITY_NORMAL;
		case Priority_Above_Normal:
			return TOOLKIT_PRIORITY_ABOVE_NORMAL;
		case Priority_High:
			return TOOLKIT_PRIORITY_HIGH;
		case Priority_Highest:
			return TOOLKIT_PRIORITY_HIGHEST;
		default:
			return TOOLKIT_PRIORITY_NORMAL;
		}
	};

	int res = toolkit_os_setpriority(ent->mod->process.pid, func());
#else
	int priviliegeValue = TOOLKIT_PRIORITY_NORMAL;
	switch (nPriority) {
	case Priority_Low:
		priviliegeValue = TOOLKIT_PRIORITY_LOW;
		break;
	case Priority_Below_Normal:
		priviliegeValue = TOOLKIT_PRIORITY_BELOW_NORMAL;
		break;
	case Priority_Normal:
		priviliegeValue = TOOLKIT_PRIORITY_NORMAL;
		break;
	case Priority_Above_Normal:
		priviliegeValue = TOOLKIT_PRIORITY_ABOVE_NORMAL;
		break;
	case Priority_High:
		priviliegeValue = TOOLKIT_PRIORITY_HIGH;
		break;
	case Priority_Highest:
		priviliegeValue = TOOLKIT_PRIORITY_HIGHEST;
		break;
	default:
		priviliegeValue = TOOLKIT_PRIORITY_NORMAL;
		break;
	}
	int res = toolkit_os_setpriority(ent->mod->process.pid, priviliegeValue);
#endif //NOT _WIN32

    if (res != 0) {
        DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("toolkit_os_setpriority failed %s ", toolkit_strerror(res));
        return Error_Unexpect;
    }

    return Error_Succeed;
}

ErrorCodeEnum SpEntityPrivilege::GetEntityPriority(const char* pszEntityName, EntityPriorityEnum& nPriority)
{
    if (!pszEntityName)
        return Error_Null;

    sp_env_t* env = sp_get_env();
    sp_mod_mgr_t* mod_mgr = env->mod_mgr;
    sp_entity_t* ent = sp_mod_mgr_find_entity_by_name(mod_mgr, pszEntityName);
    if (!ent) {
        return Error_NotExist;
    }

    int priority;
    int res = toolkit_os_getpriority(ent->mod->process.pid, &priority);
    if (res != 0) {
        DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("toolkit_os_getpriority failed %s ", toolkit_strerror(res));
        return Error_Unexpect;
    }

#if defined(_MSC_VER)
		switch (priority) {
		case TOOLKIT_PRIORITY_LOW:
			nPriority = Priority_Low;
			break;
		case TOOLKIT_PRIORITY_BELOW_NORMAL:
			nPriority = Priority_Below_Normal;
			break;
		case TOOLKIT_PRIORITY_NORMAL:
			nPriority = Priority_Normal;
			break;
		case TOOLKIT_PRIORITY_ABOVE_NORMAL:
			nPriority = Priority_Above_Normal;
			break;
		case TOOLKIT_PRIORITY_HIGH:
			nPriority = Priority_High;
			break;
		case TOOLKIT_PRIORITY_HIGHEST:
			nPriority = Priority_Highest;
			break;
		default:
			nPriority = Priority_Unknown;
			break;
		}
#else
	auto func = [](int value) {
		switch (value) {
		case TOOLKIT_PRIORITY_LOW:
			return Priority_Low;
		case TOOLKIT_PRIORITY_BELOW_NORMAL:
			return Priority_Below_Normal;
		case TOOLKIT_PRIORITY_NORMAL:
			return Priority_Normal;
		case TOOLKIT_PRIORITY_ABOVE_NORMAL:
			return Priority_Above_Normal;
		case TOOLKIT_PRIORITY_HIGH:
			return Priority_High;
		case TOOLKIT_PRIORITY_HIGHEST:
			return Priority_Highest;
		default:
			return Priority_Unknown;
		}
	};

	nPriority = func(priority);
#endif //_MSC_VER

	return Error_Succeed;
}


ErrorCodeEnum SpEntityPrivilege::GetToken(CSimpleString& curToken)
{
	sp_env_t* env = sp_get_env();
	if (env->cfg->shell_ini->token == NULL || strlen(env->cfg->shell_ini->token) == 0)
		return ErrorCodeEnum::Error_NotConfig;

	curToken = env->cfg->shell_ini->token;
	return Error_Succeed;
}

ErrorCodeEnum SpEntityPrivilege::GetVTMErrMsgArr(CAutoArray<CSimpleStringA>& strErrorCodeArr, CAutoArray<CSimpleStringA>& strDescriptionArr,
	CAutoArray<CSimpleStringA>& strRemarkArr)
{
	sp_env_t* env = sp_get_env();
	if(env->cfg->root_ini->vtm_err_msg_config == NULL || strlen(env->cfg->root_ini->vtm_err_msg_config) == 0)
		return ErrorCodeEnum::Error_NotConfig;

	return (ErrorCodeEnum)ConvertStrToVTMErrMsg(env->cfg->root_ini->vtm_err_msg_config, strErrorCodeArr, strDescriptionArr, strRemarkArr);
}


ErrorCodeEnum SpEntityPrivilege::TryUpdateToken(CSimpleString& oldToken, CSimpleString& newToken)
{
	char t_oldToken[MAX_PATH] = "", t_newToken[MAX_PATH] = "";
	auto ret = sp_TryUpdateToken(t_oldToken, t_newToken);
	if (ret == Error_Succeed)
	{
		oldToken = t_oldToken;
		newToken = t_newToken;
	}
	return (ErrorCodeEnum)ret;

}



ErrorCodeEnum SpEntityPrivilege::InitCfgUrl(VTMInitParam& info)
{
	auto cfg = sp_get_env()->cfg;

	if (cfg == NULL || cfg->shell_ini == NULL || cfg->root_ini == NULL)
		return Error_Null;

	if (info.terminalNo.GetLength() > 0)
	{
		if (cfg->root_ini->terminal_no)
			shm_free(cfg->root_ini->terminal_no);
		cfg->root_ini->terminal_no = shm_strdup(info.terminalNo.GetData());
	}
	if (info.channelId.GetLength() > 0)
	{
	if (cfg->shell_ini->channelId)
		shm_free(cfg->shell_ini->channelId);
		cfg->shell_ini->channelId = shm_strdup(info.channelId.GetData());
	}
	if (info.tokenSecret.GetLength() > 0)
	{
	if (cfg->shell_ini->tokenSecret)
		shm_free(cfg->shell_ini->tokenSecret);
		cfg->shell_ini->tokenSecret = shm_strdup(info.tokenSecret.GetData());
	}
	if (info.CommonLaunchUrl.GetLength() > 0)
	{
	if (cfg->shell_ini->CommonLaunchUrl)
		shm_free(cfg->shell_ini->CommonLaunchUrl);
		cfg->shell_ini->CommonLaunchUrl = shm_strdup(info.CommonLaunchUrl.GetData());
	}
	if (info.CenterConfigTotal.GetLength() > 0)
	{
	if (cfg->shell_ini->CenterConfigTotal)
		shm_free(cfg->shell_ini->CenterConfigTotal);
		cfg->shell_ini->CenterConfigTotal = shm_strdup(info.CenterConfigTotal.GetData());
	}

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("TerminalNo:%s, CommonLaunchUrl:%s, CenterConfigTotal:%s"
		, cfg->root_ini->terminal_no == NULL ? "" : cfg->root_ini->terminal_no
		, cfg->shell_ini->CommonLaunchUrl == NULL ? "" : cfg->shell_ini->CommonLaunchUrl
		, cfg->shell_ini->CenterConfigTotal == NULL ? "" : cfg->shell_ini->CenterConfigTotal);
	return Error_Succeed;
}

ErrorCodeEnum SpEntityPrivilege::TryUpdateVTMERRMSG()
{
	LOG_FUNCTION();
	iobuffer_t* req_pkt = iobuffer_create(-1, -1);
	SpAsyncWaitRPC* pAsyncWait = new SpAsyncWaitRPC(this, &req_pkt, SHELL_CMD_REQ_TRY_UPDATE_VTMERRMSG);
	ErrorCodeEnum Error = pAsyncWait->Begin();

	if (Error == Error_Succeed)
	{
		Error = pAsyncWait->WaitAnswer(30000);//WaitAnswer如果设定为INFINE，则最大10s，在http访问中会触发超时
		if (Error == Error_Succeed)
		{
			CAutoBuffer AnsBuf;
			bool bEnd;
			Error = pAsyncWait->AsyncGetAnswer(AnsBuf, bEnd);
			if (Error == Error_Succeed)
			{
				iobuffer_t* pkt = iobuffer_create(-1, AnsBuf.GetCount());
				iobuffer_write(pkt, IOBUF_T_BUF, &AnsBuf[0], AnsBuf.GetCount());
			}
		}
	}
	pAsyncWait->DecrementRef();
	if (req_pkt)
		iobuffer_dec_ref(req_pkt);

	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("TryUpdateVTMERRMSG ret:%d", Error);
	return Error;
}

ErrorCodeEnum SpEntityPrivilege::TryUpdateCfg()
{
	LOG_FUNCTION();
	iobuffer_t* req_pkt = iobuffer_create(-1, -1);
	SpAsyncWaitRPC* pAsyncWait = new SpAsyncWaitRPC(this, &req_pkt, SHELL_CMD_REQ_TRY_UPDATE_CFG);
	ErrorCodeEnum Error = pAsyncWait->Begin();

	if (Error == Error_Succeed)
	{
		Error = pAsyncWait->WaitAnswer(30000);//WaitAnswer如果设定为INFINE，则最大10s，在http访问中会触发超时
		if (Error == Error_Succeed)
		{
			CAutoBuffer AnsBuf;
			bool bEnd;
			Error = pAsyncWait->AsyncGetAnswer(AnsBuf, bEnd);
			if (Error == Error_Succeed)
			{
				iobuffer_t* pkt = iobuffer_create(-1, AnsBuf.GetCount());
				iobuffer_write(pkt, IOBUF_T_BUF, &AnsBuf[0], AnsBuf.GetCount());
			}
		}
	}
	pAsyncWait->DecrementRef();	
	if (req_pkt)
		iobuffer_dec_ref(req_pkt);

	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("TryUpdateCfg ret:%d", Error);
	return Error;
}

ErrorCodeEnum SpEntityPrivilege::ModifyMemCfgParam(MemCfgParam& info)
{
	LOG_FUNCTION();
	iobuffer_t* req_pkt = iobuffer_create(-1, -1);
	iobuffer_write(req_pkt, IOBUF_T_STR, info.configType, -1);
	iobuffer_write(req_pkt, IOBUF_T_STR, info.module.GetData(), -1);
	iobuffer_write(req_pkt, IOBUF_T_STR, info.name.GetData(), -1);
	iobuffer_write(req_pkt, IOBUF_T_STR, info.value.GetData(), -1);
	SpAsyncWaitRPC* pAsyncWait = new SpAsyncWaitRPC(this, &req_pkt, SHELL_CMD_REQ_MODIFY_MEM_CFG);
	ErrorCodeEnum Error = pAsyncWait->Begin();

	if (Error == Error_Succeed)
	{
		Error = pAsyncWait->WaitAnswer(30000);//WaitAnswer如果设定为INFINE，则最大10s，在http访问中会触发超时
		if (Error == Error_Succeed)
		{
			CAutoBuffer AnsBuf;
			bool bEnd;
			Error = pAsyncWait->AsyncGetAnswer(AnsBuf, bEnd);
			if (Error == Error_Succeed)
			{
				iobuffer_t* pkt = iobuffer_create(-1, AnsBuf.GetCount());
				iobuffer_write(pkt, IOBUF_T_BUF, &AnsBuf[0], AnsBuf.GetCount());
			}
		}
	}
	pAsyncWait->DecrementRef();
	if (req_pkt)
		iobuffer_dec_ref(req_pkt);

	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("ModifyMemCfgParam ret:%d", Error);
	return Error;
}

ErrorCodeEnum SpEntityPrivilege::WriteTerminalNoToRootIni(CSimpleString terminalNo)
{
	LOG_FUNCTION();
	iobuffer_t* req_pkt = iobuffer_create(-1, -1);
	iobuffer_write(req_pkt, IOBUF_T_STR, terminalNo.GetData(), -1);
	SpAsyncWaitRPC* pAsyncWait = new SpAsyncWaitRPC(this, &req_pkt, SHELL_CMD_REQ_WRITE_TERMINALNO);
	ErrorCodeEnum Error = pAsyncWait->Begin();

	if (Error == Error_Succeed)
	{
		Error = pAsyncWait->WaitAnswer(30000);//WaitAnswer如果设定为INFINE，则最大10s，在http访问中会触发超时
		if (Error == Error_Succeed)
		{
			CAutoBuffer AnsBuf;
			bool bEnd;
			Error = pAsyncWait->AsyncGetAnswer(AnsBuf, bEnd);
			if (Error == Error_Succeed)
			{
				iobuffer_t* pkt = iobuffer_create(-1, AnsBuf.GetCount());
				iobuffer_write(pkt, IOBUF_T_BUF, &AnsBuf[0], AnsBuf.GetCount());
			}
		}
	}
	pAsyncWait->DecrementRef();
	if (req_pkt)
		iobuffer_dec_ref(req_pkt);

	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("WriteTerminalNoToRootIni ret:%d", Error);
	return Error;
}

ErrorCodeEnum SpEntityPrivilege::TryUpdateCenterCfg(bool& isUpdate, bool& isReset, CSimpleString& version)
{
	char t_version[MAX_PATH] = "";
	int t_isUpdate = 0, t_isReset = 0;
	auto ret = sp_TryUpdateCenterCfg(&t_isUpdate, &t_isReset, t_version);
	if (ret == Error_Succeed)
	{
		isUpdate = t_isUpdate;
		isReset = t_isReset;
		version = t_version;
	}
		
	return (ErrorCodeEnum)ret;
}

void SpEntityPrivilege::GetSendLogInfo(unsigned long* t_upload_TerminalSys_Suc, unsigned long* t_upload_TerminalUser_Suc,
	unsigned long* t_upload_BussinessSys_Suc, unsigned long* t_upload_BussinessUser_Suc, unsigned long* t_upload_beidou_Suc,
	unsigned long* t_upload_TerminalSys_Err, unsigned long* t_upload_TerminalUser_Err,
	unsigned long* t_upload_BussinessSys_Err, unsigned long* t_upload_BussinessUser_Err, unsigned long* t_upload_beidou_Err)
{
#if defined(_MSC_VER)
	log_producer_config_get_upload_info(t_upload_TerminalSys_Suc, t_upload_TerminalUser_Suc, t_upload_BussinessSys_Suc, t_upload_BussinessUser_Suc, t_upload_beidou_Suc,
		t_upload_TerminalSys_Err, t_upload_TerminalUser_Err, t_upload_BussinessSys_Err, t_upload_BussinessUser_Err, t_upload_beidou_Err);
#else
	///*TODO(80374374@3/9/2023):  */
#endif //_MSC_VER

}

void SpEntityPrivilege::on_entity_create(int entity_id, int trigger_entity_id)
{
	if (m_pEntityLifeListener) {
		sp_env_t *env = sp_get_env();
		IEntityLifeListener *pCallback = (IEntityLifeListener *)sp_mod_entity_life_listener_get_tag(m_pEntityLifeListener);
		sp_mod_mgr_t *mod_mgr = env->mod_mgr;
		sp_entity_t *ent = sp_mod_mgr_find_entity_by_idx(mod_mgr, entity_id);
		sp_entity_t *trigger_ent = sp_mod_mgr_find_entity_by_idx(mod_mgr, trigger_entity_id);
		pCallback->OnCreated(ent->cfg->name, Error_Succeed, trigger_ent->cfg->name);
	}
}

void SpEntityPrivilege::on_entity_close(int entity_id, int trigger_entity_id, int cause_code)
{
	if (m_pEntityLifeListener) {
		sp_env_t *env = sp_get_env();
		IEntityLifeListener *pCallback = (IEntityLifeListener *)sp_mod_entity_life_listener_get_tag(m_pEntityLifeListener);
		sp_mod_mgr_t *mod_mgr = env->mod_mgr;
		sp_entity_t *ent = sp_mod_mgr_find_entity_by_idx(mod_mgr, entity_id);
		sp_entity_t *trigger_ent = sp_mod_mgr_find_entity_by_idx(mod_mgr, trigger_entity_id);
		pCallback->OnClosed(ent->cfg->name, (EntityCloseCauseEnum)cause_code, Error_Succeed, trigger_ent->cfg->name);
	}
}

void SpEntityPrivilege::on_entity_exception(int entity_id, int error, int entity_state)
{
	if (m_pEntityLifeListener) {
		sp_env_t *env = sp_get_env();
		IEntityLifeListener *pCallback = (IEntityLifeListener *)sp_mod_entity_life_listener_get_tag(m_pEntityLifeListener);
		sp_mod_mgr_t *mod_mgr = env->mod_mgr;
		sp_entity_t *ent = sp_mod_mgr_find_entity_by_idx(mod_mgr, entity_id);
		pCallback->OnException(ent->cfg->name, "", (EntityStateEnum)entity_state, (EntityStateEnum)entity_state, (ErrorCodeEnum)error);
	}
}

void SpEntityPrivilege::__on_entity_create(sp_mod_entity_life_listener_t *listener, int entity_id, int trigger_entity_id, void *user_data)
{
	SpEntityPrivilege *pThis = static_cast<SpEntityPrivilege*>(user_data);
	pThis->on_entity_create(entity_id, trigger_entity_id);
}

void SpEntityPrivilege::__on_entity_close(sp_mod_entity_life_listener_t *listener, int entity_id, int trigger_entity_id, int cause_code, void *user_data)
{
	SpEntityPrivilege *pThis = static_cast<SpEntityPrivilege*>(user_data);
	pThis->on_entity_close(entity_id, trigger_entity_id, cause_code);
}

void SpEntityPrivilege::__on_entity_exception(sp_mod_entity_life_listener_t *listener, int entity_id, int error, int entity_state, void *user_data)
{
	SpEntityPrivilege *pThis = static_cast<SpEntityPrivilege*>(user_data);
	pThis->on_entity_exception(entity_id, error, entity_state);
}

void SpEntityPrivilege::on_user_state(sp_mod_entity_state_listener_t *listener, int entity_id, int last_state, int curr_state)
{
	sp_env_t *env = sp_get_env();
	IEntityStateListener *pListener = (IEntityStateListener *)sp_mod_entity_listener_get_tag(listener);
	sp_entity_t *ent = sp_mod_mgr_find_entity_by_idx(env->mod_mgr, entity_id);
	pListener->OnUserStateHook(ent->cfg->name, (DWORD)curr_state, (DWORD)last_state);
}

void SpEntityPrivilege::on_entity_state(sp_mod_entity_state_listener_t *listener, int entity_id, int trigger_entity_id, int last_state, int curr_state)
{
	sp_env_t *env = sp_get_env();
	IEntityStateListener *pListener = (IEntityStateListener *)sp_mod_entity_listener_get_tag(listener);
	sp_entity_t *ent = sp_mod_mgr_find_entity_by_idx(env->mod_mgr, entity_id);
	sp_entity_t *trigger_ent = sp_mod_mgr_find_entity_by_idx(env->mod_mgr, trigger_entity_id);
	pListener->OnEntityStateHook(ent->cfg->name, trigger_ent->cfg->name, (EntityStateEnum)curr_state, (EntityStateEnum)last_state);
}

void SpEntityPrivilege::on_create_connection(sp_mod_entity_state_listener_t *listener, int src_entity_id, int dst_entity_id)
{
	sp_env_t *env = sp_get_env();
	IEntityStateListener *pListener = (IEntityStateListener *)sp_mod_entity_listener_get_tag(listener);
	sp_entity_t *src_ent = sp_mod_mgr_find_entity_by_idx(env->mod_mgr, src_entity_id);
	sp_entity_t *dst_ent = sp_mod_mgr_find_entity_by_idx(env->mod_mgr, dst_entity_id);
	pListener->OnCeateConnection(src_ent->cfg->name, dst_ent->cfg->name);
}

void SpEntityPrivilege::on_close_connection(sp_mod_entity_state_listener_t *listener, int src_entity_id, int dst_entity_id)
{
	sp_env_t *env = sp_get_env();
	IEntityStateListener *pListener = (IEntityStateListener *)sp_mod_entity_listener_get_tag(listener);
	sp_entity_t *src_ent = sp_mod_mgr_find_entity_by_idx(env->mod_mgr, src_entity_id);
	sp_entity_t *dst_ent = sp_mod_mgr_find_entity_by_idx(env->mod_mgr, dst_entity_id);
	pListener->OnCloseConnection(src_ent->cfg->name, dst_ent->cfg->name);
}

void SpEntityPrivilege::__on_user_state(sp_mod_entity_state_listener_t *listener, int entity_id, int last_state, int curr_state, void *user_data)
{
	SpEntityPrivilege *pThis = static_cast<SpEntityPrivilege*>(user_data);
	pThis->on_user_state(listener, entity_id, last_state, curr_state);
}

void SpEntityPrivilege::__on_entity_state(sp_mod_entity_state_listener_t *listener, int entity_id, int trigger_entity_id, int last_state, int curr_state, void *user_data)
{
	SpEntityPrivilege *pThis = static_cast<SpEntityPrivilege*>(user_data);
	pThis->on_entity_state(listener, entity_id, trigger_entity_id, last_state, curr_state);
}

void SpEntityPrivilege::__on_create_connection(sp_mod_entity_state_listener_t *listener, int src_entity_id, int dst_entity_id, void *user_data)
{
	SpEntityPrivilege *pThis = static_cast<SpEntityPrivilege*>(user_data);
	pThis->on_create_connection(listener, src_entity_id, dst_entity_id);
}

void SpEntityPrivilege::__on_close_connection(sp_mod_entity_state_listener_t *listener, int src_entity_id, int dst_entity_id, void *user_data)
{
	SpEntityPrivilege *pThis = static_cast<SpEntityPrivilege*>(user_data);
	pThis->on_close_connection(listener, src_entity_id, dst_entity_id);
}