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