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