home *** CD-ROM | disk | FTP | other *** search
/ QBasic & Borland Pascal & C / Delphi5.iso / C / BC_502 / RTLWIN32.PAK / TLHELP32.H < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-06  |  6.2 KB  |  185 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-1995, Microsoft Corp.   All rights reserved.           *
  10. *                                                                             *
  11. \*****************************************************************************/
  12.  
  13. /* $Copyright: 1997$ */
  14.  
  15. #ifndef _INC_TOOLHELP32
  16. #define _INC_TOOLHELP32
  17. #pragma option -b
  18.  
  19. #ifdef __BORLANDC__
  20. #pragma option -b.
  21.   #include <pshpack8.h>
  22. #pragma option -b
  23. #endif
  24.  
  25. #ifdef __cplusplus
  26. extern "C" {            /* Assume C declarations for C++ */
  27. #endif    /* __cplusplus */
  28.  
  29. #define MAX_MODULE_NAME32 255
  30.  
  31. /****** Shapshot function **********************************************/
  32.  
  33. HANDLE WINAPI CreateToolhelp32Snapshot(DWORD dwFlags, DWORD th32ProcessID);
  34. //
  35. // The th32ProcessID argument is only used if TH32CS_SNAPHEAPLIST or
  36. // TH32CS_SNAPMODULE is specified. th32ProcessID == 0 means the current
  37. // process.
  38. //
  39. // NOTE that all of the snapshots are global except for the heap and module
  40. //    lists which are process specific. To enumerate the heap or module
  41. //    state for all WIN32 processes call with TH32CS_SNAPALL and the
  42. //    current process. Then for each process in the TH32CS_SNAPPROCESS
  43. //    list that isn't the current process, do a call with just
  44. //    TH32CS_SNAPHEAPLIST and/or TH32CS_SNAPMODULE.
  45. //
  46. // dwFlags
  47. //
  48. #define TH32CS_SNAPHEAPLIST 0x00000001
  49. #define TH32CS_SNAPPROCESS  0x00000002
  50. #define TH32CS_SNAPTHREAD   0x00000004
  51. #define TH32CS_SNAPMODULE   0x00000008
  52. #define TH32CS_SNAPALL        (TH32CS_SNAPHEAPLIST | TH32CS_SNAPPROCESS | TH32CS_SNAPTHREAD | TH32CS_SNAPMODULE)
  53. #define TH32CS_INHERIT        0x80000000
  54. //
  55. // Use CloseHandle to destroy the snapshot
  56. //
  57.  
  58. /****** heap walking ***************************************************/
  59.  
  60. typedef struct tagHEAPLIST32
  61. {
  62.     DWORD  dwSize;
  63.     DWORD  th32ProcessID;   // owning process
  64.     DWORD  th32HeapID;        // heap (in owning process's context!)
  65.     DWORD  dwFlags;
  66. } HEAPLIST32;
  67. typedef HEAPLIST32 *  PHEAPLIST32;
  68. typedef HEAPLIST32 *  LPHEAPLIST32;
  69. //
  70. // dwFlags
  71. //
  72. #define HF32_DEFAULT      1  // process's default heap
  73. #define HF32_SHARED      2  // is shared heap
  74.  
  75. BOOL WINAPI Heap32ListFirst(HANDLE hSnapshot, LPHEAPLIST32 lphl);
  76. BOOL WINAPI Heap32ListNext(HANDLE hSnapshot, LPHEAPLIST32 lphl);
  77.  
  78. typedef struct tagHEAPENTRY32
  79. {
  80.     DWORD  dwSize;
  81.     HANDLE hHandle;    // Handle of this heap block
  82.     DWORD  dwAddress;    // Linear address of start of block
  83.     DWORD  dwBlockSize; // Size of block in bytes
  84.     DWORD  dwFlags;
  85.     DWORD  dwLockCount;
  86.     DWORD  dwResvd;
  87.     DWORD  th32ProcessID;   // owning process
  88.     DWORD  th32HeapID;        // heap block is in
  89. } HEAPENTRY32;
  90. typedef HEAPENTRY32 *  PHEAPENTRY32;
  91. typedef HEAPENTRY32 *  LPHEAPENTRY32;
  92. //
  93. // dwFlags
  94. //
  95. #define LF32_FIXED    0x00000001
  96. #define LF32_FREE     0x00000002
  97. #define LF32_MOVEABLE 0x00000004
  98.  
  99. BOOL WINAPI Heap32First(LPHEAPENTRY32 lphe, DWORD th32ProcessID,
  100.             DWORD th32HeapID);
  101. BOOL WINAPI Heap32Next(LPHEAPENTRY32 lphe);
  102. BOOL WINAPI Toolhelp32ReadProcessMemory(DWORD    th32ProcessID,
  103.                     LPCVOID lpBaseAddress,
  104.                     LPVOID    lpBuffer,
  105.                     DWORD    cbRead,
  106.                     LPDWORD lpNumberOfBytesRead);
  107.  
  108. /***** Process walking *************************************************/
  109.  
  110. typedef struct tagPROCESSENTRY32
  111. {
  112.     DWORD   dwSize;
  113.     DWORD   cntUsage;
  114.     DWORD   th32ProcessID;        // this process
  115.     DWORD   th32DefaultHeapID;
  116.     DWORD   th32ModuleID;        // associated exe
  117.     DWORD   cntThreads;
  118.     DWORD   th32ParentProcessID;    // this process's parent process
  119.     LONG    pcPriClassBase;        // Base priority of process's threads
  120.     DWORD   dwFlags;
  121.     char    szExeFile[MAX_PATH];    // Path
  122. } PROCESSENTRY32;
  123. typedef PROCESSENTRY32 *  PPROCESSENTRY32;
  124. typedef PROCESSENTRY32 *  LPPROCESSENTRY32;
  125.  
  126. BOOL WINAPI Process32First(HANDLE hSnapshot, LPPROCESSENTRY32 lppe);
  127. BOOL WINAPI Process32Next(HANDLE hSnapshot, LPPROCESSENTRY32 lppe);
  128.  
  129. /***** Thread walking **************************************************/
  130.  
  131. typedef struct tagTHREADENTRY32
  132. {
  133.     DWORD   dwSize;
  134.     DWORD   cntUsage;
  135.     DWORD   th32ThreadID;    // this thread
  136.     DWORD   th32OwnerProcessID; // Process this thread is associated with
  137.     LONG    tpBasePri;
  138.     LONG    tpDeltaPri;
  139.     DWORD   dwFlags;
  140. } THREADENTRY32;
  141. typedef THREADENTRY32 *  PTHREADENTRY32;
  142. typedef THREADENTRY32 *  LPTHREADENTRY32;
  143.  
  144. BOOL WINAPI Thread32First(HANDLE hSnapshot, LPTHREADENTRY32 lpte);
  145. BOOL WINAPI Thread32Next(HANDLE hSnapshot, LPTHREADENTRY32 lpte);
  146.  
  147. /***** Module walking *************************************************/
  148.  
  149. typedef struct tagMODULEENTRY32
  150. {
  151.     DWORD   dwSize;
  152.     DWORD   th32ModuleID;    // This module
  153.     DWORD   th32ProcessID;    // owning process
  154.     DWORD   GlblcntUsage;    // Global usage count on the module
  155.     DWORD   ProccntUsage;    // Module usage count in th32ProcessID's context
  156.     BYTE  * modBaseAddr;    // Base address of module in th32ProcessID's context
  157.     DWORD   modBaseSize;    // Size in bytes of module starting at modBaseAddr
  158.     HMODULE hModule;        // The hModule of this module in th32ProcessID's context
  159.     char    szModule[MAX_MODULE_NAME32 + 1];
  160.     char    szExePath[MAX_PATH];
  161. } MODULEENTRY32;
  162. typedef MODULEENTRY32 *  PMODULEENTRY32;
  163. typedef MODULEENTRY32 *  LPMODULEENTRY32;
  164.  
  165. //
  166. // NOTE CAREFULLY that the modBaseAddr and hModule fields are valid ONLY
  167. // in th32ProcessID's process context.
  168. //
  169.  
  170. BOOL WINAPI Module32First(HANDLE hSnapshot, LPMODULEENTRY32 lpme);
  171. BOOL WINAPI Module32Next(HANDLE hSnapshot, LPMODULEENTRY32 lpme);
  172.  
  173. #ifdef __cplusplus
  174. }
  175. #endif
  176.  
  177. #ifdef __BORLANDC__
  178. #pragma option -b.
  179.   #include <poppack.h>
  180. #pragma option -b
  181. #endif
  182.  
  183. #pragma option -b.
  184. #endif // _INC_TOOLHELP32
  185.