void SystemWrapper::CMD_UnloadModule(char *cmdLine) { TokenLine params(cmdLine); if (params.CountToken() < 2) { Printf("Syntax: unloadmodule <module> [<name>]\n"); return; } ISystemModule *module = nullptr; switch (params.CountToken()) { case 2: module = FindModule(params.GetToken(1)); break; case 3: module = FindModule(params.GetToken(1), params.GetToken(2)); break; } if (!module) { Printf("Module not found.\n"); return; } RemoveModule(module); }
Module* VirtualMachine::LoadModule(const ModuleName &name, bool noreflection, bool debug, Module *hint) { // Check for an already loaded module. // TODO: Add security. LoadedModulesByName::iterator it = loadedModulesByName.find(name.name); if(it != loadedModulesByName.end()) return it->second; // Use the filename if present if(!name.filename.empty()) return LoadModule(name.filename, debug); // Try to load the module. std::string baseName = name.name + ".cbm"; std::string fileName; if(FindModule(baseName, &fileName, hint)) return LoadModule(fileName, noreflection, debug); // Try to load embedded module. // ELF module. baseName = "lib" + name.name + ".so"; if(FindModule(baseName, &fileName, hint)) return LoadModule(fileName, noreflection, debug); // PE module. baseName = name.name + ".dll"; if(FindModule(baseName, &fileName, hint)) return LoadModule(fileName, noreflection, debug); return NULL; }
BOOL WINAPI GetModuleInformation( HANDLE hProcess, HMODULE hModule, LPMODULEINFO lpmodinfo, DWORD cb ) { LDR_DATA_TABLE_ENTRY LdrEntryData; MODULEINFO modinfo; if (cb < sizeof(MODULEINFO)) { SetLastError( ERROR_INSUFFICIENT_BUFFER ); return(FALSE); } if (!FindModule(hProcess, hModule, &LdrEntryData)) { return(0); } modinfo.lpBaseOfDll = (PVOID) hModule; modinfo.SizeOfImage = LdrEntryData.SizeOfImage; modinfo.EntryPoint = LdrEntryData.EntryPoint; try { *lpmodinfo = modinfo; } except (EXCEPTION_EXECUTE_HANDLER) { SetLastError( RtlNtStatusToDosError( GetExceptionCode() ) ); return(FALSE); } return(TRUE); }
LWRESULT Cx_PluginLoader::RegisterPlugin(const Ix_Module* pModule) { ASSERT_CHECK_RET(LWDP_MODULE_LOG, LWDP_PARAMETER_ERROR, (pModule), "RegisterPlugin Para Error"); if (FindModule(pModule->GetModuleMODID()) >= 0) { return false; } MODULE moduleInfo; moduleInfo.modid = pModule->GetModuleMODID(); moduleInfo.module = (Ix_Module *)pModule; moduleInfo.owned = (pModule->GetModuleInstance())? true: false; moduleInfo.inited = false; int32_ moduleIndex = GetPluginIndex(pModule->GetModuleMODID()); if (moduleIndex >= 0) { ASSERT_CHECK_RET(LWDP_MODULE_LOG, false, (m_modules[moduleIndex] != NULL), "Get Plugin Index Error"); *m_modules[moduleIndex] = moduleInfo; } else { moduleIndex = m_modules.size(); MODULE* module = new MODULE; *module = moduleInfo; m_modules.push_back(module); } RegisterClassEntryTable(moduleIndex); return LWDP_OK; }
LWRESULT Cx_PluginLoader::RegisterFrameWork(Ix_Module* pModule) { ASSERT_CHECK_RET(LWDP_MODULE_LOG, LWDP_PARAMETER_ERROR, (pModule), "Cx_PluginLoader::RegisterFrameWork Para Error"); int32_ existIndex = GetPluginIndex(pModule->GetModuleMODID()); if (existIndex >= 0 && m_modules[existIndex]->modid.empty()) { return LWDP_PLUGINMGR_MODULE_ALREADY_LOAD; } LWRESULT stat = LWDP_ERROR; if (pModule) { pModule->Initialize(this, 0); if(RegisterPlugin(pModule) == LWDP_OK) { int32_ moduleIndex = FindModule(pModule->GetModuleMODID()); ASSERT_CHECK_RET(LWDP_MODULE_LOG, LWDP_PLUGINMGR_MODULE_INDEX_ERROR, (moduleIndex >= 0), "Module Index Error"); ASSERT_CHECK_RET(LWDP_MODULE_LOG, LWDP_PLUGINMGR_MODULE_INDEX_ERROR, (existIndex < 0 || existIndex == moduleIndex), "Module Index Error"); } } else { return LWDP_PLUGINMGR_LOADMODULE_ERROR; } return LWDP_OK; }
////////////////////////////////////////////////////////////////////////// // // ƯÁ¤ ¹ÙÀ̳ʸ® ÆÐÄ¡ // ////////////////////////////////////////////////////////////////////////// BOOL CRawHookMgr::preHook(LPVOID pfnOld, unsigned char* cBuff, size_t copysize) { pfnOld = GetFixedFuncAddr(pfnOld); if(NULL == pfnOld) return FALSE; // ÇÔ¼ö°¡ µé¾îÀÖ´Â ¸ðµâÀ» ¾Ë¾Æ³½´Ù HMODULE hModule = HandleFromAddress(pfnOld); if(NULL == hModule) return FALSE; // ÇöÀç °ü¸®µÇ°í ÀÖ´Â ¸ðµâµé Áß ÀÌ ¸ðµâÀÌ Àִ ã¾Æº¸°í CRawHookedModule* pModule = FindModule(hModule); // ¾øÀ¸¸é »õ ¸ðµâ µî·Ï if( NULL == pModule ) { pModule = new CRawHookedModule(); if( pModule->Init( hModule ) == FALSE ) { delete pModule; return FALSE; } m_listModules.push_back(pModule); } return pModule->preHook(pfnOld, cBuff, copysize); }
static INT_PTR VoiceUnregister(WPARAM wParam, LPARAM lParam) { char *moduleName = (char *) wParam; if (moduleName == NULL || moduleName[0] == 0) return -1; VoiceProvider *module = FindModule(moduleName); if (module == NULL) return -2; for(int i = calls.getCount() - 1; i >= 0; --i) { VoiceCall *call = &calls[i]; if (call->module == module) { call->Drop(); call->SetState(VOICE_STATE_ENDED); calls.remove(i); } } modules.remove(module); if (hwnd_frame != NULL) PostMessage(hwnd_frame, WMU_REFRESH, 0, 0); return 0; }
XnStatus XnDeviceBase::UnregisterFromPropertyChange(const XnChar* Module, const XnChar* PropertyName, XnCallbackHandle hCallback) { XnStatus nRetVal = XN_STATUS_OK; XN_VALIDATE_INPUT_PTR(Module); XN_VALIDATE_INPUT_PTR(PropertyName); XN_VALIDATE_INPUT_PTR(hCallback); XnPropertyCallback* pRealCookie = (XnPropertyCallback*)hCallback; XnDeviceModule* pModule; nRetVal = FindModule(Module, &pModule); XN_IS_STATUS_OK(nRetVal); // first unregister it from property nRetVal = pModule->UnregisterFromOnPropertyValueChanged(PropertyName, pRealCookie->hCallback); XN_IS_STATUS_OK(nRetVal); XnValue val = pRealCookie; XnList::Iterator it = m_PropertyCallbacks.Find(val); if (it != m_PropertyCallbacks.end()) { m_PropertyCallbacks.Remove(it); } // now free the memory XN_DELETE(pRealCookie); return (XN_STATUS_OK); }
XnStatus XnDeviceBase::RegisterToPropertyChange(const XnChar* Module, const XnChar* PropertyName, XnDeviceOnPropertyChangedEventHandler Handler, void* pCookie, XnCallbackHandle* phCallback) { XnStatus nRetVal = XN_STATUS_OK; XnDeviceModule* pModule; nRetVal = FindModule(Module, &pModule); XN_IS_STATUS_OK(nRetVal); XnPropertyCallback* pRealCookie; XN_VALIDATE_NEW(pRealCookie, XnPropertyCallback, GetDeviceHandle(), Module, PropertyName, Handler, pCookie); // register nRetVal = pModule->RegisterForOnPropertyValueChanged(PropertyName, PropertyValueChangedCallback, pRealCookie, &pRealCookie->hCallback); if (nRetVal != XN_STATUS_OK) { XN_DELETE(pRealCookie); return (nRetVal); } m_PropertyCallbacks.AddLast(pRealCookie); *phCallback = pRealCookie; return (XN_STATUS_OK); }
XnStatus XnDeviceBase::BatchConfig(const XnPropertySet* pChangeSet) { XnStatus nRetVal = XN_STATUS_OK; XN_VALIDATE_INPUT_PTR(pChangeSet); // start a transaction nRetVal = StartTransaction(); XN_IS_STATUS_OK(nRetVal); for (XnPropertySetData::ConstIterator itModule = pChangeSet->pData->begin(); itModule != pChangeSet->pData->end(); ++itModule) { // find this module XnDeviceModule* pModule = NULL; nRetVal = FindModule(itModule.Key(), &pModule); XN_CHECK_RC_ROLLBACK(nRetVal); nRetVal = pModule->BatchConfig(*itModule.Value()); XN_CHECK_RC_ROLLBACK(nRetVal); } nRetVal = CommitTransaction(); XN_IS_STATUS_OK(nRetVal); return (XN_STATUS_OK); }
void NFCPluginManager::AddModule(const std::string& strModuleName, NFIModule* pModule) { if (!FindModule(strModuleName)) { mModuleInstanceMap.insert(ModuleInstanceMap::value_type(strModuleName, pModule)); } }
Bool ModuleManager::LoadModule( const Char* pModuleName, const Char* pModuleDir ) { GD_ASSERT(pModuleName); GD_ASSERT(pModuleDir); Char fullPath[260]; if( IsModuleLoaded(pModuleName) ) return true; strcpy(fullPath, pModuleDir); strcat(fullPath, pModuleName); Handle libHandle = Core::OpenLibrary( fullPath ); if( !libHandle ) throw ModuleNotFoundException( pModuleName, Here ); Module* module = const_cast<Module*>(FindModule(pModuleName)); if( !module ) throw ModuleNotRegisteredException( pModuleName, Here ); module->mHandle = libHandle; module->mDynamicLoad = true; return true; }
void Cx_ObjectFactory::ReleaseModule(HMODULE hModule) { int index = FindModule(hModule); ASSERT(index >= 0); MODULE* item = m_modules[index]; CLSIDS::const_iterator it = item->clsids.begin(); for (; it != item->clsids.end(); ++it) { CLSMAP::iterator mit = m_clsmap.find(it->str()); if (mit != m_clsmap.end()) { m_clsmap.erase(mit); } } if (item->owned) { FreeLibrary(hModule); } // don't remove: m_modules.erase(m_modules.begin() + index); item->hdll = NULL; item->module = NULL; item->clsids.clear(); }
////////////////////////////////////////////////////////////////////////// // // ƯÁ¤ ÇÔ¼ö ÈÄÅ· // ////////////////////////////////////////////////////////////////////////// BOOL CRawHookMgr::Hook(LPVOID pfnOld, LPVOID pfnNew, BOOL bWriteCallCode, INT nHookType) { NOTIFY_DEBUG_MESSAGE(_T("CRawHookMgr:Hook: called, pfnOld=%p, pfnNew=%p, bWrite=%s\n"), pfnOld, pfnNew, (bWriteCallCode?_T("TRUE"):_T("FALSE"))); pfnOld = GetFixedFuncAddr(pfnOld); if(NULL == pfnOld) return FALSE; // ÇÔ¼ö°¡ µé¾îÀÖ´Â ¸ðµâÀ» ¾Ë¾Æ³½´Ù HMODULE hModule = HandleFromAddress(pfnOld); if(NULL == hModule) return FALSE; // ÇöÀç °ü¸®µÇ°í ÀÖ´Â ¸ðµâµé Áß ÀÌ ¸ðµâÀÌ Àִ ã¾Æº¸°í CRawHookedModule* pModule = FindModule(hModule); // ¾øÀ¸¸é »õ ¸ðµâ µî·Ï if( NULL == pModule ) { pModule = new CRawHookedModule(); if( pModule->Init( hModule ) == FALSE ) { delete pModule; return FALSE; } m_listModules.push_back(pModule); } // ¸ðµâ°´Ã¼¿¡ ÀÌ ÇÔ¼ö¸¦ ÈÄÅ·Ç϶ó Áö½Ã if(nHookType == ATHOOKTYPE_SOURCE) return pModule->Hook2(pfnOld, pfnNew, bWriteCallCode); else return pModule->Hook(pfnOld, pfnNew, bWriteCallCode); }
static bool InjectDLL(HANDLE process, const char* dllname) { SIZE_T bytesRet = 0; DWORD oldProtect = 0; LPVOID remote_addr = NULL; HANDLE hThread = NULL; size_t len = strlen(dllname) + 1; remote_addr = ::VirtualAllocEx(process, 0, 1024, MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE); if(remote_addr==NULL) { return false; } ::VirtualProtectEx(process, remote_addr, len, PAGE_EXECUTE_READWRITE, &oldProtect); ::WriteProcessMemory(process, remote_addr, dllname, len, &bytesRet); ::VirtualProtectEx(process, remote_addr, len, oldProtect, &oldProtect); HMODULE kernel32 = ::GetModuleHandleA(KernelDLLFileName); HMODULE tkernel32 = FindModule(process, KernelDLLFileName); void *loadlib = ::GetProcAddress(kernel32, "LoadLibraryA"); void *entrypoint = (void*) ((size_t)tkernel32+((size_t)loadlib-(size_t)kernel32)); hThread = ::CreateRemoteThread(process, NULL, 0, (LPTHREAD_START_ROUTINE)entrypoint, remote_addr, 0, NULL); // デバッガがスレッド止めてるので以下の Wait は永久停止を招く //::WaitForSingleObject(hThread, INFINITE); //::VirtualFreeEx(process, remote_addr, 0, MEM_RELEASE); return hThread!=nullptr; }
InterModuleData Global::ModuleInternalApiCall(const String& module, int method, void* arg) { Module* mod = FindModule(module); if (mod == NULL) return InterModuleData(); void* data = mod->InternalApiCall(method, arg); return InterModuleData(data, mod, method); };
bool Injector::Inject(DWORD processID) { HANDLE process = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, processID); if(!process) { return false; } std::vector<HANDLE> threads; EnumerateThreads(process, [&](DWORD tid){ if(HANDLE thread=::OpenThread(THREAD_ALL_ACCESS, FALSE, tid)) { ::SuspendThread(thread); threads.push_back(thread); } }); { HMODULE kernel32 = ::GetModuleHandleA(KernelDLLFileName); HMODULE tkernel32 = FindModule(process, KernelDLLFileName); void *base = ::GetProcAddress(kernel32, "SetUnhandledExceptionFilter"); void *tbase = (void*) ((size_t)tkernel32+((size_t)base-(size_t)kernel32)); SetThreadTrap(process, tbase); } std::for_each(threads.begin(), threads.end(), [](HANDLE thread){ ::ResumeThread(thread); }); std::string dll_path = std::getenv("USERPROFILE"); dll_path += AddInDir; dll_path += MLBDllFileName; bool result = InjectDLL(process, dll_path.c_str()); ::CloseHandle(process); return result; }
bool CModules::UnloadModule(const CString& sModule, CString& sRetMsg) { CString sMod = sModule; // Make a copy incase the reference passed in is from CModule::GetModName() CModule* pModule = FindModule(sMod); sRetMsg = ""; if (!pModule) { sRetMsg = "Module [" + sMod + "] not loaded."; return false; } bool bSuccess; GLOBALMODULECALL(OnModuleUnloading(pModule, bSuccess, sRetMsg), pModule->GetUser(), NULL, return bSuccess); ModHandle p = pModule->GetDLL(); if (p) { delete pModule; for (iterator it = begin(); it != end(); ++it) { if (*it == pModule) { erase(it); break; } } dlclose(p); sRetMsg = "Module [" + sMod + "] unloaded"; return true; } sRetMsg = "Unable to unload module [" + sMod + "]"; return false; }
//--------------------------------------------------------------------------- void __fastcall TGUIConfiguration::FreeResourceModule(HANDLE Instance) { TLibModule * MainModule = FindModule(HInstance); if ((unsigned)Instance != MainModule->Instance) { FreeLibrary(static_cast<HMODULE>(Instance)); } }
Renderer* Plugin::FindRenderer(const char* rendererName) { Module* module = FindModule(eMT_Renderer, rendererName); if( module ) { return (Renderer*)module->mModulePointer; } return 0; }
A_STATUS a_get_module_mask(A_CHAR *module_name, A_UINT32 *pMask) { ATH_DEBUG_MODULE_DBG_INFO *pInfo = FindModule(module_name); if (NULL == pInfo) { return A_ERROR; } *pMask = pInfo->CurrentMask; return A_OK; }
//_____________________________________________________________________________ THaAnalysisObject::EStatus THaReacPointFoil::Init( const TDatime& run_time ) { // Initialize the module. // Locate the spectrometer apparatus named in fSpectroName and save // pointer to it. // Standard initialization. Calls this object's DefineVariables(). if( THaPhysicsModule::Init( run_time ) != kOK ) return fStatus; fSpectro = static_cast<THaSpectrometer*> ( FindModule( fSpectroName.Data(), "THaSpectrometer")); if( !fSpectro ) return fStatus; if( fBeamName.Length() > 0 ) fBeam = static_cast<THaBeam*>( FindModule( fBeamName.Data(), "THaBeam") ); return fStatus; }
XnStatus XnDeviceBase::FindModule(const XnChar* ModuleName, XnDeviceModule** ppModule) { XnStatus nRetVal = XN_STATUS_OK; XnDeviceModuleHolder* pHolder; nRetVal = FindModule(ModuleName, &pHolder); XN_IS_STATUS_OK(nRetVal); *ppModule = pHolder->GetModule(); return (XN_STATUS_OK); }
A_STATUS a_set_module_mask(A_CHAR *module_name, A_UINT32 Mask) { ATH_DEBUG_MODULE_DBG_INFO *pInfo = FindModule(module_name); if (NULL == pInfo) { return A_ERROR; } pInfo->CurrentMask = Mask; A_PRINTF("Module %s, new mask: 0x%8.8X \n",module_name,pInfo->CurrentMask); return A_OK; }
//--------------------------------------------------------------------------- HANDLE __fastcall TGUIConfiguration::ChangeResourceModule(HANDLE Instance) { if (Instance == NULL) { Instance = HInstance; } TLibModule * MainModule = FindModule(HInstance); HANDLE Result = (HANDLE)MainModule->ResInstance; MainModule->ResInstance = (unsigned)Instance; CoreSetResourceModule(Instance); return Result; }
bool CModules::UnloadModule(const CString& sModule, CString& sRetMsg) { CString sMod = sModule; // Make a copy incase the reference passed in is from CModule::GetModName() CModule* pModule = FindModule(sMod); sRetMsg = ""; if (!pModule) { sRetMsg = "Module [" + sMod + "] not loaded."; return false; } if (pModule->IsFake()) { for (iterator it = begin(); it != end(); it++) { if (*it == pModule) { erase(it); sRetMsg = "Fake module [" + sMod + "] unloaded"; return true; } } sRetMsg = "Fake module [" + sMod + "] not loaded."; return false; } ModHandle p = pModule->GetDLL(); if (p) { typedef void (*fp)(CModule*); fp Unload = (fp)dlsym(p, "ZNCModUnload"); if (Unload) { Unload(pModule); for (iterator it = begin(); it != end(); it++) { if (*it == pModule) { erase(it); break; } } dlclose(p); sRetMsg = "Module [" + sMod + "] unloaded"; return true; } else { sRetMsg = "Unable to unload module [" + sMod + "] could not find ZNCModUnload()"; return false; } } sRetMsg = "Unable to unload module [" + sMod + "]"; return false; }
bool Cx_PluginLoader::LoadPlugin(const wchar_t* filename) { if (!x3InMainThread()) { X3LOG_WARNING2(L"Can't load plugin in sub thread.", filename); return false; } CLockCount locker(&m_loading); int existIndex = GetPluginIndex(filename); if (existIndex >= 0 && m_modules[existIndex]->hdll) { if (_wcsicmp(filename, m_modules[existIndex]->filename) != 0) { X3LOG_DEBUG2(L"The plugin is already loaded.", filename << L", " << (m_modules[existIndex]->filename)); } return false; } HMODULE hdll = x3LoadLibrary(filename); DWORD errcode = GetLastError(); if (hdll) { if (RegisterPlugin(hdll)) { int moduleIndex = FindModule(hdll); ASSERT(moduleIndex >= 0); ASSERT(existIndex < 0 || existIndex == moduleIndex); m_modules[moduleIndex]->owned = true; #ifdef _WIN32 DisableThreadLibraryCalls(hdll); #endif } else { FreeLibrary(hdll); hdll = NULL; } } else if (PathFileExistsW(filename)) { X3LOG_WARNING2(L"Fail to load plugin.", x3::GetSystemErrorString(errcode) << L", " << filename); } return hdll != NULL; }
XnStatus XnDeviceBase::GetProperty(const XnChar* ModuleName, const XnChar* PropertyName, const XnGeneralBuffer& gbValue) { XnStatus nRetVal = XN_STATUS_OK; XnDeviceModule* pModule; nRetVal = FindModule(ModuleName, &pModule); XN_IS_STATUS_OK(nRetVal); nRetVal = pModule->GetProperty(PropertyName, gbValue); XN_IS_STATUS_OK(nRetVal); return XN_STATUS_OK; }
void CGameAISystem::ResumeModule(EntityId entityID, const char* moduleName) { AssertEntityManipulationIsAllowed(); IGameAIModule* module = FindModule(moduleName); if (!module) { gEnv->pLog->LogError("GameAISystem: Could not resume entity [%d] with module '%s' - the module doesn't exist.", entityID, moduleName); return; } module->EntityResume(entityID); }
XnStatus XnSensor::ConfigureModuleFromGlobalFile(const XnChar* strModule, const XnChar* strSection /* = NULL */) { XnStatus nRetVal = XN_STATUS_OK; XnDeviceModule* pModule; nRetVal = FindModule(strModule, &pModule); XN_IS_STATUS_OK(nRetVal); nRetVal = pModule->LoadConfigFromFile(m_strGlobalConfigFile, strSection); XN_IS_STATUS_OK(nRetVal); return (XN_STATUS_OK); }