开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 钩子与API截获 > 查看源码
ModuleInstance.cpp
资源名称：apihook_Code.zip　[点击查看]
上传用户：jstlsd
上传日期：2007-01-13
资源大小：186k
文件大小：21k
源码类别：

钩子与API截获

开发平台：

Visual C++

ModuleInstance.cpp：源码内容
  1. //---------------------------------------------------------------------------
  2. // ModuleInstance.cpp
  3. //
  4. // AUTHOR: Ivo Ivanov (ivopi@hotmail.com)
  5. // ver 1.02 
  6. // 05 September 2001
  7. //---------------------------------------------------------------------------
  8. #include "Common.h"
  9. #include "ModuleInstance.h"
  10. #include "SysUtils.h"
  12. //---------------------------------------------------------------------------
  13. //
  14. // class CElements
  15. //
  16. //---------------------------------------------------------------------------
  17. CElements::CElements():
  18. CModuleList()
  19. {
  21. }
  23. CElements::~CElements()
  24. {
  26. }
  27. //---------------------------------------------------------------------------
  28. //
  29. // class CLibHandler
  30. //
  31. //---------------------------------------------------------------------------
  32. CLibHandler::CLibHandler(CRunningProcesses* pProcesses):
  33. m_pProcesses(pProcesses)
  34. {
  36. }
  38. CLibHandler::~CLibHandler()
  39. {
  41. }
  44. //---------------------------------------------------------------------------
  45. //
  46. // class CTaskManager
  47. //
  48. //---------------------------------------------------------------------------
  49. CTaskManager::CTaskManager():
  50. m_pLibHandler(NULL)
  51. {
  52. m_pProcesses = new CRunningProcesses();
  54. if (IsPsapiSupported())
  55. m_pLibHandler = new CPsapiHandler(m_pProcesses);
  56. else
  57. if (IsToolHelpSupported())
  58. m_pLibHandler = new CToolhelpHandler(m_pProcesses);
  59. }
  61. CTaskManager::~CTaskManager()
  62. {
  63. delete m_pLibHandler;
  64. delete m_pProcesses;
  65. }
  67. //---------------------------------------------------------------------------
  68. // Populate
  69. //
  70. // Populate the process and modules list using PSAPI or ToolHlp32
  71. //---------------------------------------------------------------------------
  72. BOOL CTaskManager::Populate(BOOL bPopulateModules)
  73. {
  74. m_pProcesses->ReleaseAll();
  75. return m_pLibHandler->PopulateProcesses(bPopulateModules); 
  76. }
  79. //---------------------------------------------------------------------------
  80. // PopulateProcess
  81. //
  82. // Populate the module list using PSAPI or ToolHlp32
  83. //---------------------------------------------------------------------------
  84. BOOL CTaskManager::PopulateProcess(DWORD dwProcessId, BOOL bPopulateModules)
  85. {
  86. m_pProcesses->ReleaseAll();
  87. return m_pLibHandler->PopulateProcess(dwProcessId, bPopulateModules); 
  88. }
  91. //---------------------------------------------------------------------------
  92. // GetProcessCount
  93. //
  94. // Returns a number of currently loaded processes
  95. //---------------------------------------------------------------------------
  96. DWORD CTaskManager::GetProcessCount() const
  97. {
  98. return m_pProcesses->GetCount();
  99. }
  102. //---------------------------------------------------------------------------
  103. // GetProcessByIndex
  104. //
  105. // Returns a process from the container
  106. //---------------------------------------------------------------------------
  107. CExeModuleInstance* CTaskManager::GetProcessByIndex(DWORD dwIndex)
  108. {
  109. return static_cast<CExeModuleInstance*>(m_pProcesses->GetModule(dwIndex));
  110. }
  112. //---------------------------------------------------------------------------
  113. // GetProcessById
  114. //
  115. // Returns a process by its ID
  116. //---------------------------------------------------------------------------
  117. CExeModuleInstance* CTaskManager::GetProcessById(DWORD dwProcessId)
  118. {
  119. return static_cast<CExeModuleInstance*>
  120. (m_pProcesses->GetProcessById(dwProcessId));
  121. }
  123. //---------------------------------------------------------------------------
  124. //
  125. // class CLoadedModules
  126. //
  127. //---------------------------------------------------------------------------
  128. CLoadedModules::CLoadedModules(DWORD dwProcessId):
  129. CElements(),
  130. m_dwProcessId(dwProcessId)
  131. {
  133. }
  135. CLoadedModules::~CLoadedModules()
  136. {
  138. }
  140. //---------------------------------------------------------------------------
  141. //
  142. // class CRunningProcesses
  143. //
  144. //---------------------------------------------------------------------------
  145. CRunningProcesses::CRunningProcesses():
  146. CElements()
  147. {
  149. }
  151. CRunningProcesses::~CRunningProcesses()
  152. {
  154. }
  156. CExeModuleInstance* CRunningProcesses::GetProcessById(DWORD dwProcessId)
  157. {
  158. CExeModuleInstance* pResult = NULL;
  159. CExeModuleInstance* pProcess;
  161. for (long i = 0; i < GetCount(); i++)
  162. {
  163. pProcess = static_cast<CExeModuleInstance*>( GetModule(i) );
  164. if (pProcess->Get_ProcessId() == dwProcessId)
  165. {
  166. pResult = pProcess;
  167. break;
  168. } // if
  169. } // for
  170. return pResult;
  171. }
  173. //---------------------------------------------------------------------------
  174. //
  175. // class CPsapiHandler
  176. //
  177. //---------------------------------------------------------------------------
  178. CPsapiHandler::CPsapiHandler(CRunningProcesses* pProcesses):
  179. CLibHandler(pProcesses),
  180. m_hModPSAPI(NULL),
  181.     m_pfnEnumProcesses(NULL),
  182.     m_pfnEnumProcessModules(NULL),
  183.     m_pfnGetModuleFileNameExA(NULL)
  184. {
  186. }
  188. CPsapiHandler::~CPsapiHandler()
  189. {
  190. Finalize();
  191. }
  193. //---------------------------------------------------------------------------
  194. // Initialize
  195. //
  196. //---------------------------------------------------------------------------
  197. BOOL CPsapiHandler::Initialize()
  198. {
  199. BOOL bResult = FALSE;
  200.     //
  201.     // Get to the 3 functions in PSAPI.DLL dynamically.  We can't
  202.     // be sure that PSAPI.DLL has been installed
  203.     //
  204.     if (NULL == m_hModPSAPI)
  205.         m_hModPSAPI = ::LoadLibraryA("PSAPI.DLL");
  207.     if (NULL != m_hModPSAPI)
  208. {
  209. m_pfnEnumProcesses = (PFNENUMPROCESSES)
  210. ::GetProcAddress(m_hModPSAPI,"EnumProcesses");
  212. m_pfnEnumProcessModules = (PFNENUMPROCESSMODULES)
  213. ::GetProcAddress(m_hModPSAPI, "EnumProcessModules");
  215. m_pfnGetModuleFileNameExA = (PFNGETMODULEFILENAMEEXA)
  216. ::GetProcAddress(m_hModPSAPI, "GetModuleFileNameExA");
  218. }
  219. bResult = 
  220. m_pfnEnumProcesses
  221. &&  m_pfnEnumProcessModules
  222. &&  m_pfnGetModuleFileNameExA;
  224. return bResult;
  225. }
  227. //---------------------------------------------------------------------------
  228. // Finalize
  229. //
  230. //---------------------------------------------------------------------------
  231. void CPsapiHandler::Finalize()
  232. {
  233. if (NULL != m_hModPSAPI)
  234. ::FreeLibrary(m_hModPSAPI);
  235. }
  237. //---------------------------------------------------------------------------
  238. // PopulateModules
  239. //
  240. // Populate the module list using PSAPI
  241. //---------------------------------------------------------------------------
  242. BOOL CPsapiHandler::PopulateModules(CModuleInstance* pProcess)
  243. {
  244. BOOL   bResult = TRUE;
  245. CModuleInstance  *pDllModuleInstance = NULL;
  247.     if (TRUE == Initialize())
  248. {
  249. DWORD pidArray[1024];
  250. DWORD cbNeeded;
  251. DWORD nProcesses;
  252. // EnumProcesses returns an array with process IDs
  253. if (m_pfnEnumProcesses(pidArray, sizeof(pidArray), &cbNeeded))
  254. {
  255. // Determine number of processes
  256. nProcesses = cbNeeded / sizeof(DWORD);  
  257. // Release the container
  258. pProcess->ReleaseModules();
  260. for (DWORD i = 0; i < nProcesses; i++)
  261. {
  262. HMODULE hModuleArray[1024];
  263. HANDLE  hProcess;
  264. DWORD   pid = pidArray[i];
  265. DWORD   nModules;
  266. // Let's open the process
  267. hProcess = ::OpenProcess(
  268. PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
  269. FALSE, pid);
  271. if (!hProcess)
  272. continue;
  274. if (static_cast<CExeModuleInstance*>(pProcess)->Get_ProcessId() != pid)
  275. {
  276. ::CloseHandle(hProcess);
  277. continue;
  278. }
  280. // EnumProcessModules function retrieves a handle for 
  281. // each module in the specified process. 
  282. if (!m_pfnEnumProcessModules(
  283. hProcess, hModuleArray,
  284. sizeof(hModuleArray), &cbNeeded))
  285. {
  286. ::CloseHandle(hProcess);
  287. continue;
  288. }
  290. // Calculate number of modules in the process                                   
  291. nModules = cbNeeded / sizeof(hModuleArray[0]);
  292. for (DWORD j = 0; j < nModules; j++)
  293. {
  294. HMODULE hModule = hModuleArray[j];
  295. char    szModuleName[MAX_PATH];
  296. m_pfnGetModuleFileNameExA(
  297. hProcess, 
  298. hModule,
  299. szModuleName, 
  300. sizeof(szModuleName)
  301. );
  303. if (0 == j)   // First module is the EXE.  
  304. {
  305. // Do nothing.
  306. } // if
  307. else    // Not the first module.  It's a DLL
  308. {
  309. pDllModuleInstance = new CModuleInstance(
  310. szModuleName, 
  311. hModule
  312. );
  313. pProcess->AddModule(pDllModuleInstance);
  314. } // else
  315. } // for
  316. ::CloseHandle(hProcess);    // We're done with this process handle
  317. } // for
  318. bResult = TRUE;
  319. } // if
  320. else
  321. {
  322. bResult = FALSE;
  323. }
  324. } // if 
  325. else
  326. {
  327. bResult = FALSE;
  328. }
  329.     return bResult;
  330. }
  333. //---------------------------------------------------------------------------
  334. // PopulateProcesses
  335. //
  336. // Populate the process list using PSAPI
  337. //---------------------------------------------------------------------------
  339. BOOL CPsapiHandler::PopulateProcesses(BOOL bPopulateModules)
  340. {
  341. BOOL   bResult = TRUE;
  342. CExeModuleInstance* pProcessInfo;
  343. char    szModuleName[MAX_PATH];
  344.     
  345.     if (TRUE == Initialize())
  346. {
  347. DWORD pidArray[1024];
  348. DWORD cbNeeded;
  349. DWORD nProcesses;
  350.       
  351. if (m_pfnEnumProcesses(pidArray, sizeof(pidArray), &cbNeeded))
  352. {
  353. // Determine number of processes
  354. nProcesses = cbNeeded / sizeof(DWORD);  
  355. m_pProcesses->ReleaseAll();
  356. for (DWORD i = 0; i < nProcesses; i++)
  357. {
  358. HMODULE hModuleArray[1024];
  359. HANDLE hProcess;
  360. DWORD pid = pidArray[i];
  361. DWORD nModules;
  362. hProcess = ::OpenProcess(
  363. PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
  364. FALSE, 
  365. pid
  366. );
  367. if (!hProcess)
  368. continue;
  370. if (!m_pfnEnumProcessModules(hProcess, hModuleArray,
  371. sizeof(hModuleArray), &cbNeeded))
  372. {
  373. ::CloseHandle(hProcess);
  374. continue;
  375. }
  376. // Calculate number of modules in the process                                   
  377. nModules = cbNeeded / sizeof(hModuleArray[0]);
  379. for (DWORD j = 0; j < nModules; j++)
  380. {
  381. HMODULE hModule = hModuleArray[j];
  383. m_pfnGetModuleFileNameExA(
  384. hProcess, 
  385. hModule,
  386. szModuleName, 
  387. sizeof(szModuleName)
  388. );
  390. if (0 == j)   // First module is the EXE.  Just add it to the map
  391. {
  392. pProcessInfo = new CExeModuleInstance(
  393. this,
  394. szModuleName, 
  395. hModule, 
  396. pid
  397. );
  398. m_pProcesses->Add(*pProcessInfo);
  399. if (bPopulateModules)
  400. pProcessInfo->PopulateModules();
  401. break;
  402. } // if
  403. } // for
  404. ::CloseHandle(hProcess);    
  405. } // for
  406.    
  407. bResult = TRUE;
  408. } // if
  409. else
  410. {
  411. bResult = FALSE;
  412. }
  413. } // if 
  414. else
  415. {
  416. bResult = FALSE;
  417. }
  418.    
  419.     return bResult;
  420. }
  422. //---------------------------------------------------------------------------
  423. // PopulateProcess
  424. //
  425. // Populate all modules of a single process
  426. //
  427. //---------------------------------------------------------------------------
  428. BOOL CPsapiHandler::PopulateProcess(DWORD dwProcessId, BOOL bPopulateModules)
  429. {
  430. BOOL   bResult = TRUE;
  431. CExeModuleInstance* pProcessInfo;
  432.     
  433.     if (TRUE == Initialize())
  434. {
  435. m_pProcesses->ReleaseAll();
  436. HMODULE hModuleArray[1024];
  437. HANDLE  hProcess;
  438. DWORD   nModules;
  439. DWORD   cbNeeded;
  440. hProcess = ::OpenProcess(
  441. PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
  442. FALSE, 
  443. dwProcessId
  444. );
  445. if (hProcess) 
  446. {
  447. if (!m_pfnEnumProcessModules(
  448. hProcess, 
  449. hModuleArray,
  450. sizeof(hModuleArray), 
  451. &cbNeeded
  452. ))
  453. ::CloseHandle(hProcess);
  454. else
  455. {
  456. // Calculate number of modules in the process                                   
  457. nModules = cbNeeded / sizeof(hModuleArray[0]);
  459. for (DWORD j = 0; j < nModules; j++)
  460. {
  461. HMODULE hModule = hModuleArray[j];
  462. char    szModuleName[MAX_PATH];
  464. m_pfnGetModuleFileNameExA(
  465. hProcess, 
  466. hModule,
  467. szModuleName, 
  468. sizeof(szModuleName)
  469. );
  471. if (0 == j)   // First module is the EXE.  Just add it to the map
  472. {
  473. pProcessInfo = new CExeModuleInstance(
  474. this,
  475. szModuleName, 
  476. hModule, 
  477. dwProcessId
  478. );
  479. m_pProcesses->Add(*pProcessInfo);
  480. if (bPopulateModules)
  481. pProcessInfo->PopulateModules();
  482. break;
  483. } // if
  484. } // for
  485. ::CloseHandle(hProcess);    
  486. } // if
  487. } // if
  488. } // if 
  489. else
  490. {
  491. bResult = FALSE;
  492. }
  493.     return bResult;
  494. }
  496. //---------------------------------------------------------------------------
  497. //
  498. // class CToolhelpHandler
  499. //
  500. //---------------------------------------------------------------------------
  501. CToolhelpHandler::CToolhelpHandler(CRunningProcesses* pProcesses):
  502. CLibHandler(pProcesses)
  503. {
  505. }
  507. CToolhelpHandler::~CToolhelpHandler()
  508. {
  510. }
  513. //---------------------------------------------------------------------------
  514. // Initialize
  515. //
  516. //---------------------------------------------------------------------------
  517. BOOL CToolhelpHandler::Initialize()
  518. {
  519. BOOL           bResult = FALSE;
  520. HINSTANCE      hInstLib;
  522. hInstLib = ::LoadLibraryA("Kernel32.DLL");
  523. if (NULL != hInstLib)
  524. {
  525. //
  526. // We must link to these functions of Kernel32.DLL explicitly. Otherwise 
  527. // a module using this code would fail to load under Windows NT, which does not 
  528. // have the Toolhelp32 functions in the Kernel32.
  529. //
  530. m_pfnCreateToolhelp32Snapshot = (PFNCREATETOOLHELP32SNAPSHOT) 
  531. ::GetProcAddress(hInstLib, "CreateToolhelp32Snapshot");
  532. m_pfnProcess32First = (PFNPROCESS32FIRST)
  533. ::GetProcAddress(hInstLib, "Process32First");
  534. m_pfnProcess32Next = (PFNPROCESS32NEXT)
  535. ::GetProcAddress(hInstLib, "Process32Next");
  536. m_pfnModule32First = (PFNMODULE32FIRST)
  537. ::GetProcAddress(hInstLib, "Module32First");
  538. m_pfnModule32Next = (PFNMODULE32NEXT)
  539. ::GetProcAddress(hInstLib, "Module32Next");
  541. ::FreeLibrary( hInstLib );
  543. bResult = m_pfnCreateToolhelp32Snapshot &&
  544.       m_pfnProcess32First &&
  545.   m_pfnProcess32Next &&
  546.   m_pfnModule32First &&
  547.   m_pfnModule32Next;
  548. } // if
  551. return bResult;
  552. }
  554. //---------------------------------------------------------------------------
  555. // PopulateModules
  556. //
  557. // Populate the module list using ToolHelp32
  558. //---------------------------------------------------------------------------
  559. BOOL CToolhelpHandler::PopulateModules(CModuleInstance* pProcess)
  560. {
  561. BOOL   bResult = TRUE;
  562. CModuleInstance  *pDllModuleInstance = NULL;
  563. HANDLE hSnapshot = INVALID_HANDLE_VALUE;
  565. hSnapshot = m_pfnCreateToolhelp32Snapshot(
  566. TH32CS_SNAPMODULE, 
  567. static_cast<CExeModuleInstance*>(pProcess)->Get_ProcessId());
  569. MODULEENTRY32 me = { sizeof(me) };
  571. for (BOOL bOk = ModuleFirst(hSnapshot, &me); bOk; bOk = ModuleNext(hSnapshot, &me)) 
  572. {
  573. // We don't need to add to the list the process itself.
  574. // The module list should keep references to DLLs only
  575. if (0 != stricmp(pProcess->GetBaseName(), me.szModule))  
  576. {
  577. pDllModuleInstance = new CModuleInstance(me.szExePath, me.hModule);
  578. pProcess->AddModule(pDllModuleInstance);
  579. }
  580. else
  581. //
  582. // However, we should fix up the module of the EXE, because
  583. // th32ModuleID member has meaning only to the tool help functions
  584. // and it is not usable by Win32 API elements. 
  585. //
  586. {
  587. pProcess->Set_Module( me.hModule );
  588. }
  589. } // for
  591. if (hSnapshot != INVALID_HANDLE_VALUE)
  592. ::CloseHandle(hSnapshot);
  594. return bResult;
  595. }
  597. BOOL CToolhelpHandler::ModuleFirst(HANDLE hSnapshot, PMODULEENTRY32 pme) const
  598. {
  599. return m_pfnModule32First(hSnapshot, pme);
  600. }
  602. BOOL CToolhelpHandler::ModuleNext(HANDLE hSnapshot, PMODULEENTRY32 pme) const
  603. {
  604. return m_pfnModule32Next(hSnapshot, pme);
  605. }
  608. BOOL CToolhelpHandler::ProcessFirst(HANDLE hSnapshot, PROCESSENTRY32* pe32) const
  609. {
  610. return m_pfnProcess32First(hSnapshot, pe32);
  611. }
  613. BOOL CToolhelpHandler::ProcessNext(HANDLE hSnapshot, PROCESSENTRY32* pe32) const
  614. {
  615. return m_pfnProcess32Next(hSnapshot, pe32);
  616. }
  618. //---------------------------------------------------------------------------
  619. // PopulateProcesses
  620. //
  621. // Populate the process list using Toolhelp
  622. //---------------------------------------------------------------------------
  624. BOOL CToolhelpHandler::PopulateProcesses(BOOL bPopulateModules)
  625. {
  626. return PopulateProcess(NULL, bPopulateModules);
  627. }
  629. //---------------------------------------------------------------------------
  630. // PopulateProcess
  631. //
  632. // Populate all modules of a single process
  633. //
  634. //---------------------------------------------------------------------------
  635. BOOL CToolhelpHandler::PopulateProcess(DWORD dwProcessId, BOOL bPopulateModules)
  636. {
  637. BOOL   bResult    = FALSE;
  638. CExeModuleInstance* pProcessInfo;
  639. HANDLE hSnapshot  = INVALID_HANDLE_VALUE;
  641. if (TRUE == Initialize())
  642. {
  643. hSnapshot = m_pfnCreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, dwProcessId);
  645. PROCESSENTRY32 pe32 = { sizeof(pe32) };
  647. for (BOOL bOk = ProcessFirst(hSnapshot, &pe32); bOk; bOk = ProcessNext(hSnapshot, &pe32)) 
  648. {
  649. if ( (dwProcessId != NULL) && (dwProcessId != pe32.th32ProcessID) )
  650. continue;
  652. pProcessInfo = new CExeModuleInstance(
  653. this,
  654. pe32.szExeFile, 
  655. NULL,                // We will fix up later this value
  656. pe32.th32ProcessID
  657. );
  658. m_pProcesses->Add(*pProcessInfo);
  659. if (bPopulateModules)
  660. pProcessInfo->PopulateModules();
  662. if (dwProcessId != NULL)
  663. break;
  664. } // for
  666. if (hSnapshot != INVALID_HANDLE_VALUE)
  667. ::CloseHandle(hSnapshot);
  669. bResult = TRUE;
  670. }
  672. return bResult;
  673. }
  676. //---------------------------------------------------------------------------
  677. //
  678. // class CModuleList
  679. //
  680. //---------------------------------------------------------------------------
  682. CModuleList::CModuleList()
  683. {
  685. }
  687. CModuleList::~CModuleList()
  688. {
  689. ReleaseAll();
  690. }
  692. //---------------------------------------------------------------------------
  693. // Add
  694. //
  695. // Add new object to the container
  696. //---------------------------------------------------------------------------
  697. void CModuleList::Add(CModuleInstance &moduleInstance)
  698. {
  699. push_back(&moduleInstance);
  700. }
  702. //---------------------------------------------------------------------------
  703. // ReleaseAll
  704. //
  705. // Release all objects and clear the list
  706. //---------------------------------------------------------------------------
  707. void CModuleList::ReleaseAll()
  708. {
  709. CModuleList::iterator itr;
  710. CModuleInstance *pModuleInstance;
  712. for (itr = begin(); itr != end(); ++itr)
  713. {
  714. pModuleInstance = *itr;
  715. delete pModuleInstance;
  716. } // for
  717. clear();
  718. }
  720. //---------------------------------------------------------------------------
  721. // GetModule
  722. //
  723. // Return a module object by its index (Pascal-like style)
  724. //---------------------------------------------------------------------------
  725. CModuleInstance* CModuleList::GetModule(DWORD dwIndex) const
  726. {
  727. return at(dwIndex);
  728. }
  730. //---------------------------------------------------------------------------
  731. // GetCount
  732. //
  733. // Return number of items in the container
  734. //---------------------------------------------------------------------------
  735. DWORD CModuleList::GetCount() const
  736. {
  737. return size();
  738. }
  740. //---------------------------------------------------------------------------
  741. //
  742. // class CModuleInstance
  743. //
  744. //---------------------------------------------------------------------------
  745. CModuleInstance::CModuleInstance(char *pszName, HMODULE hModule):
  746. m_pszName(NULL),
  747.     m_hModule(NULL),
  748. m_pInternalList(NULL)
  749. {
  750. Set_Name(pszName);
  751. Set_Module(hModule);
  753. }
  755. CModuleInstance::~CModuleInstance()
  756. {
  757. delete m_pInternalList;
  759. if (NULL != m_pszName)
  760. delete [] m_pszName;
  761. }
  764. void CModuleInstance::AddModule(CModuleInstance* pModuleInstance)
  765. {
  766. if (NULL == m_pInternalList)
  767. m_pInternalList = new CModuleList();
  768. m_pInternalList->Add(*pModuleInstance);
  769. }
  771. void CModuleInstance::ReleaseModules()
  772. {
  773. if (NULL != m_pInternalList)
  774. m_pInternalList->ReleaseAll();
  775. }
  777. char* CModuleInstance::Get_Name() const
  778. {
  779. return m_pszName;
  780. }
  782. char* CModuleInstance::GetBaseName() const
  783. {
  784. char *pdest;
  785. int  ch = '\';
  786. // Search backward 
  787. pdest = strrchr(m_pszName, ch);
  788. if(pdest != NULL)
  789. return &pdest[1];
  790. else
  791. return m_pszName;
  792. }
  794. void CModuleInstance::Set_Name(char *pszName)
  795. {
  796. if (NULL != m_pszName)
  797. delete [] m_pszName;
  798. if ((NULL != pszName) && (strlen(pszName)))
  799. {
  800. m_pszName = new char[strlen(pszName) + 1];
  801. strcpy(m_pszName, pszName);
  802. }
  803. else
  804. {
  805. m_pszName = new char[strlen("") + 1];
  806. strcpy(m_pszName, "");
  807. }
  809. }
  811. HMODULE CModuleInstance::Get_Module() const
  812. {
  813. return m_hModule;
  814. }
  816. void CModuleInstance::Set_Module(HMODULE module)
  817. {
  818. m_hModule = module;
  819. }
  822. //---------------------------------------------------------------------------
  823. //
  824. // class CExeModuleInstance
  825. //
  826. //---------------------------------------------------------------------------
  828. CExeModuleInstance::CExeModuleInstance(
  829. CLibHandler* pLibHandler,
  830. char*        pszName, 
  831. HMODULE      hModule, 
  832. DWORD        dwProcessId
  833. ):
  834. CModuleInstance(pszName, hModule),
  835. m_pLibHandler(pLibHandler),
  836. m_dwProcessId(dwProcessId)
  837. {
  839. }
  841. CExeModuleInstance::~CExeModuleInstance()
  842. {
  844. }
  846. DWORD CExeModuleInstance::Get_ProcessId() const
  847. {
  848. return m_dwProcessId;
  849. }
  851. BOOL CExeModuleInstance::PopulateModules()
  852. {
  853. return m_pLibHandler->PopulateModules(this);
  854. }
  857. DWORD CExeModuleInstance::GetModuleCount()
  858. {
  859. return m_pInternalList ? m_pInternalList->GetCount() : 0;
  860. }
  862. CModuleInstance* CExeModuleInstance::GetModuleByIndex(DWORD dwIndex)
  863. {
  864. return m_pInternalList ? m_pInternalList->GetModule(dwIndex) : NULL;
  865. }
  867. //----------------------------End of the file -------------------------------