home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 September / Chip_2001-09_cd1.bin / zkuste / delphi / kompon / d2345 / MSYSINFO.ZIP / Source / MiTeC_ToolHelp32.pas < prev    next >
Pascal/Delphi Source File  |  2001-04-18  |  13KB  |  441 lines
  1.  
  2. {*******************************************************}
  3. {                                                       }
  4. {             MiTeC Delphi Runtime Library              }
  5. {      Tool Help Functions, Types, and Definitions      }
  6. {           version 1.0 for Delphi 3,4,5                }
  7. {                                                       }
  8. {            Copyright ⌐ 1998 Michal Mutl               }
  9. {                                                       }
  10. {*******************************************************}
  11.  
  12. unit MiTeC_ToolHelp32;
  13.  
  14. {$WEAKPACKAGEUNIT}
  15.  
  16. interface
  17.  
  18. uses Windows;
  19.  
  20. {$HPPEMIT '#include <tlhelp32.h>'}
  21.  
  22. const
  23. {$EXTERNALSYM MAX_MODULE_NAME32}
  24.   MAX_MODULE_NAME32 = 255;
  25.  
  26. (****** Shapshot function **********************************************)
  27.  
  28. {$EXTERNALSYM CreateToolhelp32Snapshot}
  29. function CreateToolhelp32Snapshot(dwFlags, th32ProcessID: DWORD): THandle;
  30.  
  31. type
  32.   TCreateToolhelp32Snapshot = function (dwFlags, th32ProcessID: DWORD): THandle stdcall;
  33. const
  34. {$EXTERNALSYM TH32CS_SNAPHEAPLIST}
  35.   TH32CS_SNAPHEAPLIST = $00000001;
  36. {$EXTERNALSYM TH32CS_SNAPPROCESS}
  37.   TH32CS_SNAPPROCESS  = $00000002;
  38. {$EXTERNALSYM TH32CS_SNAPTHREAD}
  39.   TH32CS_SNAPTHREAD   = $00000004;
  40. {$EXTERNALSYM TH32CS_SNAPMODULE}
  41.   TH32CS_SNAPMODULE   = $00000008;
  42. {$EXTERNALSYM TH32CS_SNAPALL}
  43.   TH32CS_SNAPALL      = TH32CS_SNAPHEAPLIST or TH32CS_SNAPPROCESS or
  44.     TH32CS_SNAPTHREAD or TH32CS_SNAPMODULE;
  45. {$EXTERNALSYM TH32CS_INHERIT}
  46.   TH32CS_INHERIT      = $80000000;
  47.  
  48. type
  49. {$EXTERNALSYM tagHEAPLIST32}
  50.   tagHEAPLIST32 = record
  51.     dwSize: DWORD;
  52.     th32ProcessID: DWORD;
  53.     th32HeapID: DWORD;
  54.     dwFlags: DWORD;
  55.   end;
  56. {$EXTERNALSYM HEAPLIST32}
  57.   HEAPLIST32 = tagHEAPLIST32;
  58. {$EXTERNALSYM PHEAPLIST32}
  59.   PHEAPLIST32 = ^tagHEAPLIST32;
  60. {$EXTERNALSYM LPHEAPLIST32}
  61.   LPHEAPLIST32 = ^tagHEAPLIST32;
  62.   THeapList32 = tagHEAPLIST32;
  63.  
  64. const
  65. {$EXTERNALSYM HF32_DEFAULT}
  66.   HF32_DEFAULT = 1;
  67. {$EXTERNALSYM HF32_SHARED}
  68.   HF32_SHARED  = 2;
  69.  
  70. {$EXTERNALSYM Heap32ListFirst}
  71. function Heap32ListFirst(hSnapshot: THandle; var lphl: THeapList32): BOOL;
  72. {$EXTERNALSYM Heap32ListNext}
  73. function Heap32ListNext(hSnapshot: THandle; var lphl: THeapList32): BOOL;
  74.  
  75. type
  76.   THeap32ListFirst = function (hSnapshot: THandle; var lphl: THeapList32): BOOL stdcall;
  77.   THeap32ListNext = function (hSnapshot: THandle; var lphl: THeapList32): BOOL stdcall;
  78.  
  79. type
  80. {$EXTERNALSYM tagHEAPENTRY32}
  81.   tagHEAPENTRY32 = record
  82.     dwSize: DWORD;
  83.     hHandle: THandle;
  84.     dwAddress: DWORD;
  85.     dwBlockSize: DWORD;
  86.     dwFlags: DWORD;
  87.     dwLockCount: DWORD;
  88.     dwResvd: DWORD;
  89.     th32ProcessID: DWORD;
  90.     th32HeapID: DWORD;
  91.   end;
  92. {$EXTERNALSYM HEAPENTRY32}
  93.   HEAPENTRY32 = tagHEAPENTRY32;
  94. {$EXTERNALSYM PHEAPENTRY32}
  95.   PHEAPENTRY32 = ^tagHEAPENTRY32;
  96. {$EXTERNALSYM LPHEAPENTRY32}
  97.   LPHEAPENTRY32 = ^tagHEAPENTRY32;
  98.   THeapEntry32 = tagHEAPENTRY32;
  99.  
  100. const
  101. {$EXTERNALSYM LF32_FIXED}
  102.   LF32_FIXED    = $00000001;
  103. {$EXTERNALSYM LF32_FREE}
  104.   LF32_FREE     = $00000002;
  105. {$EXTERNALSYM LF32_MOVEABLE}
  106.   LF32_MOVEABLE = $00000004;
  107.  
  108. {$EXTERNALSYM Heap32First}
  109. function Heap32First(var lphe: THeapEntry32; th32ProcessID, th32HeapID: DWORD): BOOL;
  110. {$EXTERNALSYM Heap32Next}
  111. function Heap32Next(var lphe: THeapEntry32): BOOL;
  112. {$EXTERNALSYM Toolhelp32ReadProcessMemory}
  113. function Toolhelp32ReadProcessMemory(th32ProcessID: DWORD; lpBaseAddress: Pointer;
  114.   var lpBuffer; cbRead: DWORD; var lpNumberOfBytesRead: DWORD): BOOL;
  115.  
  116. type
  117.   THeap32First = function (var lphe: THeapEntry32; th32ProcessID,
  118.     th32HeapID: DWORD): BOOL stdcall;
  119.   THeap32Next = function (var lphe: THeapEntry32): BOOL stdcall;
  120.   TToolhelp32ReadProcessMemory = function (th32ProcessID: DWORD;
  121.     lpBaseAddress: Pointer; var lpBuffer; cbRead: DWORD;
  122.     var lpNumberOfBytesRead: DWORD): BOOL stdcall;
  123.  
  124. type
  125. {$EXTERNALSYM tagPROCESSENTRY32W}
  126.   tagPROCESSENTRY32W = packed record
  127.     dwSize: DWORD;
  128.     cntUsage: DWORD;
  129.     th32ProcessID: DWORD;
  130.     th32DefaultHeapID: DWORD;
  131.     th32ModuleID: DWORD;
  132.     cntThreads: DWORD;
  133.     th32ParentProcessID: DWORD;
  134.     pcPriClassBase: Longint;
  135.     dwFlags: DWORD;
  136.     szExeFile: array[0..MAX_PATH - 1] of WChar;
  137.   end;
  138. {$EXTERNALSYM PROCESSENTRY32W}
  139.   PROCESSENTRY32W = tagPROCESSENTRY32W;
  140. {$EXTERNALSYM PPROCESSENTRY32W}
  141.   PPROCESSENTRY32W = ^tagPROCESSENTRY32W;
  142. {$EXTERNALSYM LPPROCESSENTRY32W}
  143.   LPPROCESSENTRY32W = ^tagPROCESSENTRY32W;
  144.   TProcessEntry32W = tagPROCESSENTRY32W;
  145.  
  146. {$EXTERNALSYM Process32FirstW}
  147. function Process32FirstW(hSnapshot: THandle; var lppe: TProcessEntry32W): BOOL;
  148. {$EXTERNALSYM Process32NextW}
  149. function Process32NextW(hSnapshot: THandle; var lppe: TProcessEntry32W): BOOL;
  150.  
  151. type
  152.   TProcess32FirstW = function (hSnapshot: THandle; var lppe: TProcessEntry32W): BOOL stdcall;
  153.   TProcess32NextW = function (hSnapshot: THandle; var lppe: TProcessEntry32W): BOOL stdcall;
  154.  
  155. {$EXTERNALSYM tagPROCESSENTRY32}
  156.   tagPROCESSENTRY32 = packed record
  157.     dwSize: DWORD;
  158.     cntUsage: DWORD;
  159.     th32ProcessID: DWORD;
  160.     th32DefaultHeapID: DWORD;
  161.     th32ModuleID: DWORD;
  162.     cntThreads: DWORD;
  163.     th32ParentProcessID: DWORD;
  164.     pcPriClassBase: Longint;
  165.     dwFlags: DWORD;
  166.     szExeFile: array[0..MAX_PATH - 1] of Char;
  167.   end;
  168. {$EXTERNALSYM PROCESSENTRY32}
  169.   PROCESSENTRY32 = tagPROCESSENTRY32;
  170. {$EXTERNALSYM PPROCESSENTRY32}
  171.   PPROCESSENTRY32 = ^tagPROCESSENTRY32;
  172. {$EXTERNALSYM LPPROCESSENTRY32}
  173.   LPPROCESSENTRY32 = ^tagPROCESSENTRY32;
  174.   TProcessEntry32 = tagPROCESSENTRY32;
  175.  
  176. {$EXTERNALSYM Process32First}
  177. function Process32First(hSnapshot: THandle; var lppe: TProcessEntry32): BOOL;
  178. {$EXTERNALSYM Process32Next}
  179. function Process32Next(hSnapshot: THandle; var lppe: TProcessEntry32): BOOL;
  180.  
  181. type
  182.   TProcess32First = function (hSnapshot: THandle; var lppe: TProcessEntry32): BOOL stdcall;
  183.   TProcess32Next = function (hSnapshot: THandle; var lppe: TProcessEntry32): BOOL stdcall;
  184.  
  185. type
  186. {$EXTERNALSYM tagTHREADENTRY32}
  187.   tagTHREADENTRY32 = record
  188.     dwSize: DWORD;
  189.     cntUsage: DWORD;
  190.     th32ThreadID: DWORD;
  191.     th32OwnerProcessID: DWORD;
  192.     tpBasePri: Longint;
  193.     tpDeltaPri: Longint;
  194.     dwFlags: DWORD;
  195.   end;
  196. {$EXTERNALSYM THREADENTRY32}
  197.   THREADENTRY32 = tagTHREADENTRY32;
  198. {$EXTERNALSYM PTHREADENTRY32}
  199.   PTHREADENTRY32 = ^tagTHREADENTRY32;
  200. {$EXTERNALSYM LPTHREADENTRY32}
  201.   LPTHREADENTRY32 = ^tagTHREADENTRY32;
  202.   TThreadEntry32 = tagTHREADENTRY32;
  203.  
  204. {$EXTERNALSYM Thread32First}
  205. function Thread32First(hSnapshot: THandle; var lpte: TThreadEntry32): BOOL; stdcall;
  206. {$EXTERNALSYM Thread32Next}
  207. function Thread32Next(hSnapshot: THandle; var lpte: TThreadENtry32): BOOL; stdcall;
  208.  
  209. type
  210.   TThread32First = function (hSnapshot: THandle; var lpte: TThreadEntry32): BOOL stdcall;
  211.   TThread32Next = function (hSnapshot: THandle; var lpte: TThreadENtry32): BOOL stdcall;
  212.  
  213. type
  214. {$EXTERNALSYM tagMODULEENTRY32}
  215.   tagMODULEENTRY32 = record
  216.     dwSize: DWORD;
  217.     th32ModuleID: DWORD;
  218.     th32ProcessID: DWORD;
  219.     GlblcntUsage: DWORD;
  220.     ProccntUsage: DWORD;
  221.     modBaseAddr: PBYTE;
  222.     modBaseSize: DWORD;
  223.     hModule: HMODULE;
  224.     szModule: array[0..MAX_MODULE_NAME32] of Char;
  225.     szExePath: array[0..MAX_PATH - 1] of Char;
  226.   end;
  227. {$EXTERNALSYM MODULEENTRY32}
  228.   MODULEENTRY32 = tagMODULEENTRY32;
  229. {$EXTERNALSYM PMODULEENTRY32}
  230.   PMODULEENTRY32 = ^tagMODULEENTRY32;
  231. {$EXTERNALSYM LPMODULEENTRY32}
  232.   LPMODULEENTRY32 = ^tagMODULEENTRY32;
  233.   TModuleEntry32 = tagMODULEENTRY32;
  234.  
  235. {$EXTERNALSYM Module32First}
  236. function Module32First(hSnapshot: THandle; var lpme: TModuleEntry32): BOOL;
  237. {$EXTERNALSYM Module32Next}
  238. function Module32Next(hSnapshot: THandle; var lpme: TModuleEntry32): BOOL;
  239.  
  240. type
  241.   TModule32First = function (hSnapshot: THandle; var lpme: TModuleEntry32): BOOL stdcall;
  242.   TModule32Next = function (hSnapshot: THandle; var lpme: TModuleEntry32): BOOL stdcall;
  243.  
  244. {$EXTERNALSYM tagMODULEENTRY32W}
  245.   tagMODULEENTRY32W = record
  246.     dwSize: DWORD;
  247.     th32ModuleID: DWORD;
  248.     th32ProcessID: DWORD;
  249.     GlblcntUsage: DWORD;
  250.     ProccntUsage: DWORD;
  251.     modBaseAddr: PBYTE;
  252.     modBaseSize: DWORD;
  253.     hModule: HMODULE;
  254.     szModule: array[0..MAX_MODULE_NAME32] of WChar;
  255.     szExePath: array[0..MAX_PATH - 1] of WChar;
  256.   end;
  257. {$EXTERNALSYM MODULEENTRY32}
  258.   MODULEENTRY32W = tagMODULEENTRY32W;
  259. {$EXTERNALSYM PMODULEENTRY32}
  260.   PMODULEENTRY32W = ^tagMODULEENTRY32W;
  261. {$EXTERNALSYM LPMODULEENTRY32}
  262.   LPMODULEENTRY32W = ^tagMODULEENTRY32W;
  263.   TModuleEntry32W = tagMODULEENTRY32W;
  264.  
  265. {$EXTERNALSYM Module32First}
  266. function Module32FirstW(hSnapshot: THandle; var lpme: TModuleEntry32W): BOOL;
  267. {$EXTERNALSYM Module32Next}
  268. function Module32NextW(hSnapshot: THandle; var lpme: TModuleEntry32W): BOOL;
  269.  
  270. type
  271.   TModule32FirstW = function (hSnapshot: THandle; var lpme: TModuleEntry32W): BOOL stdcall;
  272.   TModule32NextW = function (hSnapshot: THandle; var lpme: TModuleEntry32W): BOOL stdcall;
  273.  
  274.  
  275. implementation
  276.  
  277. const
  278.   kernel32 = 'kernel32.dll';
  279.  
  280. var
  281.   KernelHandle: THandle;
  282.   _CreateToolhelp32Snapshot: TCreateToolhelp32Snapshot;
  283.   _Heap32ListFirst: THeap32ListFirst;
  284.   _Heap32ListNext: THeap32ListNext;
  285.   _Heap32First: THeap32First;
  286.   _Heap32Next: THeap32Next;
  287.   _Toolhelp32ReadProcessMemory: TToolhelp32ReadProcessMemory;
  288.   _Process32First: TProcess32First;
  289.   _Process32Next: TProcess32Next;
  290.   _Process32FirstW: TProcess32FirstW;
  291.   _Process32NextW: TProcess32NextW;
  292.   _Thread32First: TThread32First;
  293.   _Thread32Next: TThread32Next;
  294.   _Module32First: TModule32First;
  295.   _Module32Next: TModule32Next;
  296.   _Module32FirstW: TModule32FirstW;
  297.   _Module32NextW: TModule32NextW;
  298.  
  299. function InitToolHelp: Boolean;
  300. begin
  301.   if KernelHandle=0 then begin
  302.     KernelHandle:=GetModuleHandle(kernel32);
  303.     if KernelHandle<>0 then begin
  304.       @_CreateToolhelp32Snapshot := GetProcAddress(KernelHandle, 'CreateToolhelp32Snapshot');
  305.       @_Heap32ListFirst := GetProcAddress(KernelHandle, 'Heap32ListFirst');
  306.       @_Heap32ListNext := GetProcAddress(KernelHandle, 'Heap32ListNext');
  307.       @_Heap32First := GetProcAddress(KernelHandle, 'Heap32First');
  308.       @_Heap32Next := GetProcAddress(KernelHandle, 'Heap32Next');
  309.       @_Toolhelp32ReadProcessMemory := GetProcAddress(KernelHandle, 'Toolhelp32ReadProcessMemory');
  310.       @_Process32First := GetProcAddress(KernelHandle, 'Process32First');
  311.       @_Process32Next := GetProcAddress(KernelHandle, 'Process32Next');
  312.       @_Process32FirstW := GetProcAddress(KernelHandle, 'Process32FirstW');
  313.       @_Process32NextW := GetProcAddress(KernelHandle, 'Process32NextW');
  314.       @_Thread32First := GetProcAddress(KernelHandle, 'Thread32First');
  315.       @_Thread32Next := GetProcAddress(KernelHandle, 'Thread32Next');
  316.       @_Module32First := GetProcAddress(KernelHandle, 'Module32First');
  317.       @_Module32Next := GetProcAddress(KernelHandle, 'Module32Next');
  318.       @_Module32FirstW := GetProcAddress(KernelHandle, 'Module32FirstW');
  319.       @_Module32NextW := GetProcAddress(KernelHandle, 'Module32NextW');
  320.     end;
  321.   end;
  322.   result:=(KernelHandle<>0) and assigned(_CreateToolhelp32Snapshot);
  323. end;
  324.  
  325. function CreateToolhelp32Snapshot;
  326. begin
  327.   if InitToolHelp then
  328.     Result := _CreateToolhelp32Snapshot(dwFlags, th32ProcessID)
  329.   else Result := 0;
  330. end;
  331.  
  332. function Heap32ListFirst;
  333. begin
  334.   if InitToolHelp then
  335.     Result := _Heap32ListFirst(hSnapshot, lphl)
  336.   else Result := False;
  337. end;
  338.  
  339. function Heap32ListNext;
  340. begin
  341.   if InitToolHelp then
  342.     Result := _Heap32ListNext(hSnapshot, lphl)
  343.   else Result := False;
  344. end;
  345.  
  346. function Heap32First;
  347. begin
  348.   if InitToolHelp then
  349.     Result := _Heap32First(lphe, th32ProcessID, th32HeapID)
  350.   else Result := False;
  351. end;
  352.  
  353. function Heap32Next;
  354. begin
  355.   if InitToolHelp then
  356.     Result := _Heap32Next(lphe)
  357.   else Result := False;
  358. end;
  359.  
  360. function Toolhelp32ReadProcessMemory;
  361. begin
  362.   if InitToolHelp then
  363.     Result := _Toolhelp32ReadProcessMemory(th32ProcessID, lpBaseAddress,
  364.       lpBuffer, cbRead, lpNumberOfBytesRead)
  365.   else Result := False;
  366. end;
  367.  
  368. function Process32First;
  369. begin
  370.   if InitToolHelp then
  371.     Result := _Process32First(hSnapshot, lppe)
  372.   else Result := False;
  373. end;
  374.  
  375. function Process32Next;
  376. begin
  377.   if InitToolHelp then
  378.     Result := _Process32Next(hSnapshot, lppe)
  379.   else Result := False;
  380. end;
  381.  
  382. function Process32FirstW;
  383. begin
  384.   if InitToolHelp then
  385.     Result := _Process32FirstW(hSnapshot, lppe)
  386.   else Result := False;
  387. end;
  388.  
  389. function Process32NextW;
  390. begin
  391.   if InitToolHelp then
  392.     Result := _Process32NextW(hSnapshot, lppe)
  393.   else Result := False;
  394. end;
  395.  
  396. function Thread32First;
  397. begin
  398.   if InitToolHelp then
  399.     Result := _Thread32First(hSnapshot, lpte)
  400.   else Result := False;
  401. end;
  402.  
  403. function Thread32Next;
  404. begin
  405.   if InitToolHelp then
  406.     Result := _Thread32Next(hSnapshot, lpte)
  407.   else Result := False;
  408. end;
  409.  
  410. function Module32First;
  411. begin
  412.   if InitToolHelp then
  413.     Result := _Module32First(hSnapshot, lpme)
  414.   else Result := False;
  415. end;
  416.  
  417. function Module32Next;
  418. begin
  419.   if InitToolHelp then
  420.     Result := _Module32Next(hSnapshot, lpme)
  421.   else Result := False;
  422. end;
  423.  
  424. function Module32FirstW;
  425. begin
  426.   if InitToolHelp then
  427.     Result := _Module32FirstW(hSnapshot, lpme)
  428.   else Result := False;
  429. end;
  430.  
  431. function Module32NextW;
  432. begin
  433.   if InitToolHelp then
  434.     Result := _Module32NextW(hSnapshot, lpme)
  435.   else Result := False;
  436. end;
  437.  
  438. end.
  439.  
  440.  
  441.