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