src/vendor/winapi/src/um/tlhelp32.rs

   1 // Copyright © 2015-2017 winapi-rs developers
   2 // Licensed under the Apache License, Version 2.0
   3 // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   4 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
   5 // All files in the project carrying such notice may not be copied, modified, or distributed
   6 // except according to those terms.
   7 //! WIN32 tool help functions, types, and definitions
   8 use shared::basetsd::{SIZE_T, ULONG_PTR};
   9 use shared::minwindef::{BOOL, BYTE, DWORD, HMODULE, LPCVOID, LPVOID, MAX_PATH};
  10 use um::winnt::{CHAR, HANDLE, LONG, WCHAR};
  11 pub const MAX_MODULE_NAME32: usize = 255;
  12 extern "system" {
  13     pub fn CreateToolhelp32Snapshot(
  14         dwFlags: DWORD,
  15         th32ProcessID: DWORD,
  16     ) -> HANDLE;
  17 }
  18 pub const TH32CS_SNAPHEAPLIST: DWORD = 0x00000001;
  19 pub const TH32CS_SNAPPROCESS: DWORD = 0x00000002;
  20 pub const TH32CS_SNAPTHREAD: DWORD = 0x00000004;
  21 pub const TH32CS_SNAPMODULE: DWORD = 0x00000008;
  22 pub const TH32CS_SNAPMODULE32: DWORD = 0x00000010;
  23 pub const TH32CS_SNAPALL: DWORD =
  24     (TH32CS_SNAPHEAPLIST | TH32CS_SNAPPROCESS | TH32CS_SNAPTHREAD | TH32CS_SNAPMODULE);
  25 pub const TH32CS_INHERIT: DWORD = 0x80000000;
  26 STRUCT!{struct HEAPLIST32 {
  27     dwSize: SIZE_T,
  28     th32ProcessID: DWORD,
  29     th32HeapID:  ULONG_PTR,
  30     dwFlags: DWORD,
  31 }}
  32 pub type PHEAPLIST32 = *mut HEAPLIST32;
  33 pub type LPHEAPLIST32 = *mut HEAPLIST32;
  34 pub const HF32_DEFAULT: DWORD = 1;
  35 pub const HF32_SHARED: DWORD = 2;
  36 extern "system" {
  37     pub fn Heap32ListFirst(
  38         hSnapshot: HANDLE,
  39         lphl: LPHEAPLIST32,
  40     ) -> BOOL;
  41     pub fn Heap32ListNext(
  42         hSnapshot: HANDLE,
  43         lphl: LPHEAPLIST32,
  44     ) -> BOOL;
  45 }
  46 STRUCT!{struct HEAPENTRY32 {
  47     dwSize: SIZE_T,
  48     hHandle: HANDLE,
  49     dwAddress: ULONG_PTR,
  50     dwBlockSize: SIZE_T,
  51     dwFlags: DWORD,
  52     dwLockCount: DWORD,
  53     dwResvd: DWORD,
  54     th32ProcessID: DWORD,
  55     th32HeapID: ULONG_PTR,
  56 }}
  57 pub type PHEAPENTRY32 = *mut HEAPENTRY32;
  58 pub type LPHEAPENTRY32 = *mut HEAPENTRY32;
  59 pub const LF32_FIXED: DWORD = 0x00000001;
  60 pub const LF32_FREE: DWORD = 0x00000002;
  61 pub const LF32_MOVEABLE: DWORD = 0x00000004;
  62 extern "system" {
  63     pub fn Heap32First(
  64         lphe: LPHEAPENTRY32,
  65         th32ProcessID: DWORD,
  66         th32HeapID: ULONG_PTR,
  67     ) -> BOOL;
  68     pub fn Heap32Next(
  69         lphe: LPHEAPENTRY32,
  70     ) -> BOOL;
  71     pub fn Toolhelp32ReadProcessMemory(
  72         th32ProcessID: DWORD,
  73         lpBaseAddress: LPCVOID,
  74         lpBuffer: LPVOID,
  75         cbRead: SIZE_T,
  76         lpNumberOfBytesRead: *mut SIZE_T,
  77     ) -> BOOL;
  78 }
  79 STRUCT!{struct PROCESSENTRY32W {
  80     dwSize: DWORD,
  81     cntUsage: DWORD,
  82     th32ProcessID: DWORD,
  83     th32DefaultHeapID: ULONG_PTR,
  84     th32ModuleID: DWORD,
  85     cntThreads: DWORD,
  86     th32ParentProcessID: DWORD,
  87     pcPriClassBase: LONG,
  88     dwFlags: DWORD,
  89     szExeFile: [WCHAR; MAX_PATH],
  90 }}
  91 pub type PPROCESSENTRY32W = *mut PROCESSENTRY32W;
  92 pub type LPPROCESSENTRY32W = *mut PROCESSENTRY32W;
  93 extern "system" {
  94     pub fn Process32FirstW(
  95         hSnapshot: HANDLE,
  96         lppe: LPPROCESSENTRY32W,
  97     ) -> BOOL;
  98     pub fn Process32NextW(
  99         hSnapshot: HANDLE,
 100         lppe: LPPROCESSENTRY32W,
 101     ) -> BOOL;
 102 }
 103 STRUCT!{struct PROCESSENTRY32 {
 104     dwSize: DWORD,
 105     cntUsage: DWORD,
 106     th32ProcessID: DWORD,
 107     th32DefaultHeapID: ULONG_PTR,
 108     th32ModuleID: DWORD,
 109     cntThreads: DWORD,
 110     th32ParentProcessID: DWORD,
 111     pcPriClassBase: LONG,
 112     dwFlags: DWORD,
 113     szExeFile: [CHAR; MAX_PATH],
 114 }}
 115 pub type PPROCESSENTRY32 = *mut PROCESSENTRY32;
 116 pub type LPPROCESSENTRY32 = *mut PROCESSENTRY32;
 117 extern "system" {
 118     pub fn Process32First(
 119         hSnapshot: HANDLE,
 120         lppe: LPPROCESSENTRY32,
 121     ) -> BOOL;
 122     pub fn Process32Next(
 123         hSnapshot: HANDLE,
 124         lppe: LPPROCESSENTRY32,
 125     ) -> BOOL;
 126 }
 127 STRUCT!{struct THREADENTRY32 {
 128     dwSize: DWORD,
 129     cntUsage: DWORD,
 130     th32ThreadID: DWORD,
 131     th32OwnerProcessID: DWORD,
 132     tpBasePri: LONG,
 133     tpDeltaPri: LONG,
 134     dwFlags: DWORD,
 135 }}
 136 pub type PTHREADENTRY32 = *mut THREADENTRY32;
 137 pub type LPTHREADENTRY32 = *mut THREADENTRY32;
 138 extern "system" {
 139     pub fn Thread32First(
 140         hSnapshot: HANDLE,
 141         lpte: LPTHREADENTRY32,
 142     ) -> BOOL;
 143     pub fn Thread32Next(
 144         hSnapshot: HANDLE,
 145         lpte: LPTHREADENTRY32,
 146     ) -> BOOL;
 147 }
 148 STRUCT!{struct MODULEENTRY32W {
 149     dwSize: DWORD,
 150     th32ModuleID: DWORD,
 151     th32ProcessID: DWORD,
 152     GlblcntUsage: DWORD,
 153     ProccntUsage: DWORD,
 154     modBaseAddr: *mut BYTE,
 155     modBaseSize: DWORD,
 156     hModule: HMODULE,
 157     szModule: [WCHAR; MAX_MODULE_NAME32 + 1],
 158     szExePath: [WCHAR; MAX_PATH],
 159 }}
 160 pub type PMODULEENTRY32W = *mut MODULEENTRY32W;
 161 pub type LPMODULEENTRY32W = *mut MODULEENTRY32W;
 162 extern "system" {
 163     pub fn Module32FirstW(
 164         hSnapshot: HANDLE,
 165         lpme: LPMODULEENTRY32W,
 166     ) -> BOOL;
 167     pub fn Module32NextW(
 168         hSnapshot: HANDLE,
 169         lpme: LPMODULEENTRY32W,
 170     ) -> BOOL;
 171 }
 172 STRUCT!{struct MODULEENTRY32 {
 173     dwSize: DWORD,
 174     th32ModuleID: DWORD,
 175     th32ProcessID: DWORD,
 176     GlblcntUsage: DWORD,
 177     ProccntUsage: DWORD,
 178     modBaseAddr: *mut BYTE,
 179     modBaseSize: DWORD,
 180     hModule: HMODULE,
 181     szModule: [CHAR; MAX_MODULE_NAME32 + 1],
 182     szExePath: [CHAR; MAX_PATH],
 183 }}
 184 pub type PMODULEENTRY32 = *mut MODULEENTRY32;
 185 pub type LPMODULEENTRY32 = *mut MODULEENTRY32;
 186 extern "system" {
 187     pub fn Module32First(
 188         hSnapshot: HANDLE,
 189         lpme: LPMODULEENTRY32,
 190     ) -> BOOL;
 191     pub fn Module32Next(
 192         hSnapshot: HANDLE,
 193         lpme: LPMODULEENTRY32,
 194     ) -> BOOL;
 195 }