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