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