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
#include <SpHelper.h>

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)
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("mod %s not exist", pszEntityName);
		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;
}

ErrorCodeEnum SpEntityPrivilege::UpdateVerTxt(const char* strActiveFilePath, const char* toWriteVersionStr, bool toCheck)
{
	HANDLE hFile = ::CreateFileA(strActiveFilePath, GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
	BOOL bSetSucc = FALSE;
	if (hFile == INVALID_HANDLE_VALUE)
	{
		LogError(Severity_Low, Error_Unexpect, 0, CSimpleStringA::Format("open %s failed! err=%u", strActiveFilePath, GetLastError()));
		return Error_IO;
	}
	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);
	}
#if defined(RVC_OS_LINUX)
	if (bSetSucc) {
		mode_t f_attrib = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IXOTH | S_IWOTH;
		chmod(strActiveFilePath, f_attrib);
	}
	else {
		LogError(Severity_Low, Error_Unexpect, 0, "bSetSucc fail");
	}
#endif //RVC_OS_LINUX
	return bSetSucc ? Error_Succeed : Error_Unexpect;
}

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::RewriteDepVersion(const CSimpleStringA& strVersion, bool bRefresh)
{
	ErrorCodeEnum rc(Error_Succeed);
	auto dir = sp_get_env()->dir;
	auto cfg = sp_get_env()->cfg;
	
	if (dir == NULL)
		return Error_Null;

	if (strVersion.IsNullOrEmpty())
		return Error_Param;

	CSimpleStringA strOldVer(true);
	rc = GetRunningDepVersion(strOldVer);
	if (rc == Error_Succeed && !strOldVer.IsNullOrEmpty() && strOldVer.Compare(strVersion) == 0) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("the new vesion %s is the same as the current one: %s", strVersion.GetData(), strOldVer.GetData());
		return Error_Succeed;
	}

	char path[MAX_PATH] = {'\0'};
	rc = (ErrorCodeEnum)sp_dir_get_path(dir, SP_DIR_DEPVER_TXT, NULL, path, MAX_PATH);
	if (rc != 0) {
		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("get dep ver txt failed!");
		return rc;
	}
	else {
		//TODO: 测试专用，待移除  [Gifur@20241016]
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("path:%s", path);
	}

	rc = UpdateVerTxt(path, strVersion, true);
	if (rc == Error_Succeed && bRefresh) {
		//TODO: 调试专用，后移除  [Gifur@20241015]
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("to refresh...");
		rc = (ErrorCodeEnum)sp_dir_refresh_dep_path(dir);
		if (rc == Error_Succeed) {
			//TODO: 调试专用，后移除  [Gifur@20241015]
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("to send fresh post");
			iobuffer_t* pkt = iobuffer_create(-1, -1);
			rc = PostInfoShell(SHELL_CMD_INFO_REFRESH_ENV, &pkt);
			if (pkt)
				iobuffer_dec_ref(pkt);
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("send fresh post return %s", SpStrError(rc));
		}
	}
	return rc;
}

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;
}
struct Log_Info
{
	unsigned int t_upload_TerminalSys_Suc;
	unsigned int t_upload_TerminalUser_Suc;
	unsigned int t_upload_BussinessSys_Suc;
	unsigned int t_upload_BussinessUser_Suc;
	unsigned int t_upload_beidou_Suc;
	unsigned int t_upload_TerminalSys_Err;
	unsigned int t_upload_TerminalUser_Err;
	unsigned int t_upload_BussinessSys_Err;
	unsigned int t_upload_BussinessUser_Err;
	unsigned int t_upload_beidou_Err;
	unsigned int t_discard_full;
	unsigned int t_discard_RTI1002;
	unsigned int curLogNum;

	void Serialize(SpBuffer& Buf)
	{
		auto& buf = Buf & 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 & t_discard_full & t_discard_RTI1002 & curLogNum;
	}
};


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, 
	unsigned long* t_discard_full, unsigned long* t_discard_RTI1002, unsigned long* curLogNum)
{
	iobuffer_t* req_pkt = iobuffer_create(-1, -1);
	SpAsyncWaitRPC* pAsyncWait = new SpAsyncWaitRPC(this, &req_pkt, SHELL_CMD_REQ_GET_UPLOAD_LOGS_INFO);
	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)
			{
				Log_Info cur;
				SpBuffer2Object(AnsBuf, cur);

				*t_upload_TerminalSys_Suc = cur.t_upload_TerminalSys_Suc;
				*t_upload_TerminalUser_Suc = cur.t_upload_TerminalUser_Suc;
				*t_upload_BussinessSys_Suc = cur.t_upload_BussinessSys_Suc;
				*t_upload_BussinessUser_Suc = cur.t_upload_BussinessUser_Suc;
				*t_upload_beidou_Suc = cur.t_upload_beidou_Suc;
				*t_upload_TerminalSys_Err = cur.t_upload_TerminalSys_Err;
				*t_upload_TerminalUser_Err = cur.t_upload_TerminalUser_Err;
				*t_upload_BussinessSys_Err = cur.t_upload_BussinessSys_Err;
				*t_upload_BussinessUser_Err = cur.t_upload_BussinessUser_Err;
				*t_upload_beidou_Err = cur.t_upload_beidou_Err;
				*t_discard_full = cur.t_discard_full;
				*t_discard_RTI1002 = cur.t_discard_RTI1002;
				*curLogNum = cur.curLogNum;
				/*
				DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("checkUrlActive::GetSendLogInfo, TS_Suc:%d, TU_Suc:%d, BS_Suc:%d, BU_Suc:%d, beidou_Suc:%d, TS_Err:%d, TU_Err:%d, BS_Err:%d, BU_Err:%d, beidou_Err:%d, discard_forFull:%d, discard_forRTI1002:%d, curNum:%d"
					, cur.t_upload_TerminalSys_Suc, cur.t_upload_TerminalUser_Suc, cur.t_upload_BussinessSys_Suc, cur.t_upload_BussinessUser_Suc, cur.t_upload_beidou_Suc,
					cur.t_upload_TerminalSys_Err, cur.t_upload_TerminalUser_Err, cur.t_upload_BussinessSys_Err, cur.t_upload_BussinessUser_Err, cur.t_upload_beidou_Err
					, cur.t_discard_full, cur.t_discard_RTI1002, cur.curLogNum);
				*/
			}
		}
	}
	pAsyncWait->DecrementRef();
	if (req_pkt)
		iobuffer_dec_ref(req_pkt);

}

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);
}