home *** CD-ROM | disk | FTP | other *** search
/ PC Plus SuperCD (UK) 2000 May / PCP163A.iso / Runimage / Cbuilder4 / Include / TLHELP32.H < prev    next >
Encoding:
C/C++ Source or Header  |  1999-01-26  |  8.5 KB  |  314 lines
  1. /*****************************************************************************\
  2. *                                                                             *
  3. * tlhelp32.h -  WIN32 tool help functions, types, and definitions             *
  4. *                                                                             *
  5. * Version 1.0                                                                 *
  6. *                                                                             *
  7. * NOTE: windows.h/winbase.h must be #included first                           *
  8. *                                                                             *
  9. * Copyright 1994 - 1998 Microsoft Corp.   All rights reserved.             *
  10. *                                                                             *
  11. \*****************************************************************************/
  12.  
  13. #ifndef _INC_TOOLHELP32
  14. #pragma option push -b -a8 -pc -A- /*P_O_Push_S*/
  15. #define _INC_TOOLHELP32
  16.  
  17. #ifdef __cplusplus
  18. extern "C" {            /* Assume C declarations for C++ */
  19. #endif  /* __cplusplus */
  20.  
  21. #define MAX_MODULE_NAME32 255
  22.  
  23. /****** Shapshot function **********************************************/
  24.  
  25. HANDLE
  26. WINAPI
  27. CreateToolhelp32Snapshot(
  28.     DWORD dwFlags,
  29.     DWORD th32ProcessID
  30.     );
  31.  
  32. //
  33. // The th32ProcessID argument is only used if TH32CS_SNAPHEAPLIST or
  34. // TH32CS_SNAPMODULE is specified. th32ProcessID == 0 means the current
  35. // process.
  36. //
  37. // NOTE that all of the snapshots are global except for the heap and module
  38. //      lists which are process specific. To enumerate the heap or module
  39. //      state for all WIN32 processes call with TH32CS_SNAPALL and the
  40. //      current process. Then for each process in the TH32CS_SNAPPROCESS
  41. //      list that isn't the current process, do a call with just
  42. //      TH32CS_SNAPHEAPLIST and/or TH32CS_SNAPMODULE.
  43. //
  44. // dwFlags
  45. //
  46. #define TH32CS_SNAPHEAPLIST 0x00000001
  47. #define TH32CS_SNAPPROCESS  0x00000002
  48. #define TH32CS_SNAPTHREAD   0x00000004
  49. #define TH32CS_SNAPMODULE   0x00000008
  50. #define TH32CS_SNAPALL      (TH32CS_SNAPHEAPLIST | TH32CS_SNAPPROCESS | TH32CS_SNAPTHREAD | TH32CS_SNAPMODULE)
  51. #define TH32CS_INHERIT      0x80000000
  52. //
  53. // Use CloseHandle to destroy the snapshot
  54. //
  55.  
  56. /****** heap walking ***************************************************/
  57.  
  58. typedef struct tagHEAPLIST32
  59. {
  60.     DWORD  dwSize;
  61.     DWORD  th32ProcessID;   // owning process
  62.     DWORD  th32HeapID;      // heap (in owning process's context!)
  63.     DWORD  dwFlags;
  64. } HEAPLIST32;
  65. typedef HEAPLIST32 *  PHEAPLIST32;
  66. typedef HEAPLIST32 *  LPHEAPLIST32;
  67. //
  68. // dwFlags
  69. //
  70. #define HF32_DEFAULT      1  // process's default heap
  71. #define HF32_SHARED       2  // is shared heap
  72.  
  73. BOOL
  74. WINAPI
  75. Heap32ListFirst(
  76.     HANDLE hSnapshot,
  77.     LPHEAPLIST32 lphl
  78.     );
  79.  
  80. BOOL
  81. WINAPI
  82. Heap32ListNext(
  83.     HANDLE hSnapshot,
  84.     LPHEAPLIST32 lphl
  85.     );
  86.  
  87. typedef struct tagHEAPENTRY32
  88. {
  89.     DWORD  dwSize;
  90.     HANDLE hHandle;     // Handle of this heap block
  91.     DWORD  dwAddress;   // Linear address of start of block
  92.     DWORD  dwBlockSize; // Size of block in bytes
  93.     DWORD  dwFlags;
  94.     DWORD  dwLockCount;
  95.     DWORD  dwResvd;
  96.     DWORD  th32ProcessID;   // owning process
  97.     DWORD  th32HeapID;      // heap block is in
  98. } HEAPENTRY32;
  99. typedef HEAPENTRY32 *  PHEAPENTRY32;
  100. typedef HEAPENTRY32 *  LPHEAPENTRY32;
  101. //
  102. // dwFlags
  103. //
  104. #define LF32_FIXED    0x00000001
  105. #define LF32_FREE     0x00000002
  106. #define LF32_MOVEABLE 0x00000004
  107.  
  108. BOOL
  109. WINAPI
  110. Heap32First(
  111.     LPHEAPENTRY32 lphe,
  112.     DWORD th32ProcessID,
  113.     DWORD th32HeapID
  114.     );
  115.  
  116. BOOL
  117. WINAPI
  118. Heap32Next(
  119.     LPHEAPENTRY32 lphe
  120.     );
  121.  
  122. BOOL
  123. WINAPI
  124. Toolhelp32ReadProcessMemory(
  125.     DWORD   th32ProcessID,
  126.     LPCVOID lpBaseAddress,
  127.     LPVOID  lpBuffer,
  128.     DWORD   cbRead,
  129.     LPDWORD lpNumberOfBytesRead
  130.     );
  131.  
  132. /***** Process walking *************************************************/
  133.  
  134. typedef struct tagPROCESSENTRY32W
  135. {
  136.     DWORD   dwSize;
  137.     DWORD   cntUsage;
  138.     DWORD   th32ProcessID;          // this process
  139.     DWORD   th32DefaultHeapID;
  140.     DWORD   th32ModuleID;           // associated exe
  141.     DWORD   cntThreads;
  142.     DWORD   th32ParentProcessID;    // this process's parent process
  143.     LONG    pcPriClassBase;         // Base priority of process's threads
  144.     DWORD   dwFlags;
  145.     WCHAR   szExeFile[MAX_PATH];    // Path
  146. } PROCESSENTRY32W;
  147. typedef PROCESSENTRY32W *  PPROCESSENTRY32W;
  148. typedef PROCESSENTRY32W *  LPPROCESSENTRY32W;
  149.  
  150. BOOL
  151. WINAPI
  152. Process32FirstW(
  153.     HANDLE hSnapshot,
  154.     LPPROCESSENTRY32W lppe
  155.     );
  156.  
  157. BOOL
  158. WINAPI
  159. Process32NextW(
  160.     HANDLE hSnapshot,
  161.     LPPROCESSENTRY32W lppe
  162.     );
  163.  
  164. typedef struct tagPROCESSENTRY32
  165. {
  166.     DWORD   dwSize;
  167.     DWORD   cntUsage;
  168.     DWORD   th32ProcessID;          // this process
  169.     DWORD   th32DefaultHeapID;
  170.     DWORD   th32ModuleID;           // associated exe
  171.     DWORD   cntThreads;
  172.     DWORD   th32ParentProcessID;    // this process's parent process
  173.     LONG    pcPriClassBase;         // Base priority of process's threads
  174.     DWORD   dwFlags;
  175.     CHAR    szExeFile[MAX_PATH];    // Path
  176. } PROCESSENTRY32;
  177. typedef PROCESSENTRY32 *  PPROCESSENTRY32;
  178. typedef PROCESSENTRY32 *  LPPROCESSENTRY32;
  179.  
  180. BOOL
  181. WINAPI
  182. Process32First(
  183.     HANDLE hSnapshot,
  184.     LPPROCESSENTRY32 lppe
  185.     );
  186.  
  187. BOOL
  188. WINAPI
  189. Process32Next(
  190.     HANDLE hSnapshot,
  191.     LPPROCESSENTRY32 lppe
  192.     );
  193.  
  194. #ifdef UNICODE
  195. #define Process32First Process32FirstW
  196. #define Process32Next Process32NextW
  197. #define PROCESSENTRY32 PROCESSENTRY32W
  198. #define PPROCESSENTRY32 PPROCESSENTRY32W
  199. #define LPPROCESSENTRY32 LPPROCESSENTRY32W
  200. #endif  // !UNICODE
  201.  
  202. /***** Thread walking **************************************************/
  203.  
  204. typedef struct tagTHREADENTRY32
  205. {
  206.     DWORD   dwSize;
  207.     DWORD   cntUsage;
  208.     DWORD   th32ThreadID;       // this thread
  209.     DWORD   th32OwnerProcessID; // Process this thread is associated with
  210.     LONG    tpBasePri;
  211.     LONG    tpDeltaPri;
  212.     DWORD   dwFlags;
  213. } THREADENTRY32;
  214. typedef THREADENTRY32 *  PTHREADENTRY32;
  215. typedef THREADENTRY32 *  LPTHREADENTRY32;
  216.  
  217. BOOL
  218. WINAPI
  219. Thread32First(
  220.     HANDLE hSnapshot,
  221.     LPTHREADENTRY32 lpte
  222.     );
  223.  
  224. BOOL
  225. WINAPI
  226. Thread32Next(
  227.     HANDLE hSnapshot,
  228.     LPTHREADENTRY32 lpte
  229.     );
  230.  
  231. /***** Module walking *************************************************/
  232.  
  233. typedef struct tagMODULEENTRY32W
  234. {
  235.     DWORD   dwSize;
  236.     DWORD   th32ModuleID;       // This module
  237.     DWORD   th32ProcessID;      // owning process
  238.     DWORD   GlblcntUsage;       // Global usage count on the module
  239.     DWORD   ProccntUsage;       // Module usage count in th32ProcessID's context
  240.     BYTE  * modBaseAddr;        // Base address of module in th32ProcessID's context
  241.     DWORD   modBaseSize;        // Size in bytes of module starting at modBaseAddr
  242.     HMODULE hModule;            // The hModule of this module in th32ProcessID's context
  243.     WCHAR   szModule[MAX_MODULE_NAME32 + 1];
  244.     WCHAR   szExePath[MAX_PATH];
  245. } MODULEENTRY32W;
  246. typedef MODULEENTRY32W *  PMODULEENTRY32W;
  247. typedef MODULEENTRY32W *  LPMODULEENTRY32W;
  248.  
  249. BOOL
  250. WINAPI
  251. Module32FirstW(
  252.     HANDLE hSnapshot,
  253.     LPMODULEENTRY32W lpme
  254.     );
  255.  
  256. BOOL
  257. WINAPI
  258. Module32NextW(
  259.     HANDLE hSnapshot,
  260.     LPMODULEENTRY32W lpme
  261.     );
  262.  
  263.  
  264. typedef struct tagMODULEENTRY32
  265. {
  266.     DWORD   dwSize;
  267.     DWORD   th32ModuleID;       // This module
  268.     DWORD   th32ProcessID;      // owning process
  269.     DWORD   GlblcntUsage;       // Global usage count on the module
  270.     DWORD   ProccntUsage;       // Module usage count in th32ProcessID's context
  271.     BYTE  * modBaseAddr;        // Base address of module in th32ProcessID's context
  272.     DWORD   modBaseSize;        // Size in bytes of module starting at modBaseAddr
  273.     HMODULE hModule;            // The hModule of this module in th32ProcessID's context
  274.     char    szModule[MAX_MODULE_NAME32 + 1];
  275.     char    szExePath[MAX_PATH];
  276. } MODULEENTRY32;
  277. typedef MODULEENTRY32 *  PMODULEENTRY32;
  278. typedef MODULEENTRY32 *  LPMODULEENTRY32;
  279.  
  280. //
  281. // NOTE CAREFULLY that the modBaseAddr and hModule fields are valid ONLY
  282. // in th32ProcessID's process context.
  283. //
  284.  
  285. BOOL
  286. WINAPI
  287. Module32First(
  288.     HANDLE hSnapshot,
  289.     LPMODULEENTRY32 lpme
  290.     );
  291.  
  292. BOOL
  293. WINAPI
  294. Module32Next(
  295.     HANDLE hSnapshot,
  296.     LPMODULEENTRY32 lpme
  297.     );
  298.  
  299. #ifdef UNICODE
  300. #define Module32First Module32FirstW
  301. #define Module32Next Module32NextW
  302. #define MODULEENTRY32 MODULEENTRY32W
  303. #define PMODULEENTRY32 PMODULEENTRY32W
  304. #define LPMODULEENTRY32 LPMODULEENTRY32W
  305. #endif  // !UNICODE
  306.  
  307.  
  308. #ifdef __cplusplus
  309. }
  310. #endif
  311.  
  312. #pragma option pop /*P_O_Pop*/
  313. #endif // _INC_TOOLHELP32
  314.