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