#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 #include "sp_httpDefine.h" #ifdef RVC_OS_WIN #include "CodeSignVerify.h" #include #include "log_producer_config.h" #else #include "sp_dbg_export.h" #include #include #include #include #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 &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, ¶m1, 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 SpEntityPrivilege::GetPrivilegeFunction() { IEntityFunctionPrivilege *pPrivilege = dynamic_cast(this); return pPrivilege; } ErrorCodeEnum SpEntityPrivilege::StartEntity(const char *pszEntityName, const char *pszCmdLine,CSmartPointer &pAsynWaitSp) { return ControlEntity(this, pszEntityName, SHELL_CMD_REQ_ENTITY_START, pszCmdLine, 0, 0, pAsynWaitSp); } /*To Close*/ ErrorCodeEnum SpEntityPrivilege::StopEntity(const char *pszEntityName,CSmartPointer &pAsynWaitSp) { return ControlEntity(this, pszEntityName, SHELL_CMD_REQ_ENTITY_STOP, NULL, 0, 0, pAsynWaitSp); } /*To Close*/ ErrorCodeEnum SpEntityPrivilege::CloseEntity(const char *pszEntityName,CSmartPointer &pAsynWaitSp) { return ControlEntity(this, pszEntityName, SHELL_CMD_REQ_ENTITY_STOP, NULL, 0, 0, pAsynWaitSp); } /*To kill*/ ErrorCodeEnum SpEntityPrivilege::TerminateEntity(const char *pszEntityName,CSmartPointer &pAsynWaitSp) { return ControlEntity(this, pszEntityName, SHELL_CMD_REQ_ENTITY_TERMINATE, NULL, 0, 0, pAsynWaitSp); } ErrorCodeEnum SpEntityPrivilege::PauseEntity(const char *pszEntityName,CSmartPointer &pAsynWaitSp) { return ControlEntity(this, pszEntityName, SHELL_CMD_REQ_ENTITY_PAUSE, NULL, 0, 0, pAsynWaitSp); } ErrorCodeEnum SpEntityPrivilege::ContinueEntity(const char *pszEntityName,CSmartPointer &pAsynWaitSp) { return ControlEntity(this, pszEntityName, SHELL_CMD_REQ_ENTITY_CONTINUE, NULL, 0, 0, pAsynWaitSp); } ErrorCodeEnum SpEntityPrivilege::TestEntity(const char *pszEntityName,EntityTestEnum eTestType, CSmartPointer &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::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::UpdateVerTxt(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& strErrorCodeArr, CAutoArray& strDescriptionArr, CAutoArray& 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) { return Error_AlreadyExist; } 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 { DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("path:%s", path); } rc = UpdateVerTxt(path, strVersion, true); if (rc == Error_Succeed && bRefresh) { DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("to refresh..."); rc = (ErrorCodeEnum)sp_dir_refresh_dep_path(dir); if (rc == Error_Succeed) { 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; } 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(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(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(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(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(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(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(user_data); pThis->on_close_connection(listener, src_entity_id, dst_entity_id); }