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 //! This module defines the 32-Bit Windows Base APIs
7 use ctypes::{c_char, c_int, c_long, c_void};
8 use shared::basetsd::{
9     DWORD64, DWORD_PTR, LONG_PTR, PDWORD64, PDWORD_PTR, PSIZE_T, PULONG_PTR, SIZE_T, UINT_PTR,
10     ULONG_PTR,
11 };
12 use shared::guiddef::GUID;
13 use shared::minwindef::{
14     ATOM, BOOL, BYTE, DWORD, FARPROC, FILETIME, HFILE, HGLOBAL, HLOCAL, HMODULE, HRSRC, LPBOOL,
15     LPBYTE, LPCVOID, LPDWORD, LPFILETIME, LPVOID, LPWORD, PBOOL, PDWORD, PUCHAR, PULONG, PUSHORT,
16     UCHAR, UINT, ULONG, USHORT, WORD,
17 };
18 use shared::windef::HWND;
19 use um::cfgmgr32::MAX_PROFILE_LEN;
20 use um::fileapi::STREAM_INFO_LEVELS;
21 use um::libloaderapi::{
22     ENUMRESLANGPROCA, ENUMRESLANGPROCW, ENUMRESNAMEPROCA, ENUMRESTYPEPROCA, ENUMRESTYPEPROCW,
23 };
24 use um::minwinbase::{
25     FILE_INFO_BY_HANDLE_CLASS, FINDEX_INFO_LEVELS, FINDEX_SEARCH_OPS, GET_FILEEX_INFO_LEVELS,
26     LPOVERLAPPED, LPOVERLAPPED_COMPLETION_ROUTINE, LPSECURITY_ATTRIBUTES, PREASON_CONTEXT,
27 };
28 use um::processthreadsapi::{
29     LPPROC_THREAD_ATTRIBUTE_LIST, LPSTARTUPINFOA, STARTUPINFOA, STARTUPINFOW,
30 };
31 use um::winnt::{
32     BOOLEAN, CHAR, DWORDLONG, EXECUTION_STATE, FILE_ID_128, HANDLE, HRESULT, INT, LANGID,
33     LARGE_INTEGER, LATENCY_TIME, LONG, LPCCH, LPCH, LPCSTR, LPCWSTR, LPOSVERSIONINFOEXA,
34     LPOSVERSIONINFOEXW, LPSTR, LPWSTR, MAXLONG, PBOOLEAN, PCONTEXT, PCWSTR, PFIRMWARE_TYPE,
35     PHANDLE, PIO_COUNTERS, PJOB_SET_ARRAY, PLUID, POWER_REQUEST_TYPE, PPERFORMANCE_DATA,
36     PPROCESSOR_NUMBER, PQUOTA_LIMITS, PRTL_UMS_SCHEDULER_ENTRY_POINT,
37     PSECURE_MEMORY_CACHE_CALLBACK, PSID, PSID_NAME_USE, PULONGLONG, PVOID, PWOW64_CONTEXT,
38     PWOW64_LDT_ENTRY, PWSTR, RTL_UMS_THREAD_INFO_CLASS, STATUS_ABANDONED_WAIT_0, STATUS_USER_APC,
39     STATUS_WAIT_0, SecurityAnonymous, SecurityDelegation, SecurityIdentification,
40     SecurityImpersonation, THREAD_BASE_PRIORITY_IDLE, THREAD_BASE_PRIORITY_LOWRT,
41     THREAD_BASE_PRIORITY_MAX, THREAD_BASE_PRIORITY_MIN, ULARGE_INTEGER, VOID, WAITORTIMERCALLBACK,
42     WCHAR, WOW64_CONTEXT,
43 };
44 #[cfg(target_arch = "x86")]
45 use um::winnt::PLDT_ENTRY;
46 use vc::vadefs::va_list;
47 pub const FILE_BEGIN: DWORD = 0;
48 pub const FILE_CURRENT: DWORD = 1;
49 pub const FILE_END: DWORD = 2;
50 pub const WAIT_FAILED: DWORD = 0xFFFFFFFF;
51 pub const WAIT_OBJECT_0: DWORD = STATUS_WAIT_0 as u32;
52 pub const WAIT_ABANDONED: DWORD = STATUS_ABANDONED_WAIT_0 as u32;
53 pub const WAIT_ABANDONED_0: DWORD = STATUS_ABANDONED_WAIT_0 as u32;
54 pub const WAIT_IO_COMPLETION: DWORD = STATUS_USER_APC as u32;
55 pub const FILE_FLAG_WRITE_THROUGH: DWORD = 0x80000000;
56 pub const FILE_FLAG_OVERLAPPED: DWORD = 0x40000000;
57 pub const FILE_FLAG_NO_BUFFERING: DWORD = 0x20000000;
58 pub const FILE_FLAG_RANDOM_ACCESS: DWORD = 0x10000000;
59 pub const FILE_FLAG_SEQUENTIAL_SCAN: DWORD = 0x08000000;
60 pub const FILE_FLAG_DELETE_ON_CLOSE: DWORD = 0x04000000;
61 pub const FILE_FLAG_BACKUP_SEMANTICS: DWORD = 0x02000000;
62 pub const FILE_FLAG_POSIX_SEMANTICS: DWORD = 0x01000000;
63 pub const FILE_FLAG_SESSION_AWARE: DWORD = 0x00800000;
64 pub const FILE_FLAG_OPEN_REPARSE_POINT: DWORD = 0x00200000;
65 pub const FILE_FLAG_OPEN_NO_RECALL: DWORD = 0x00100000;
66 pub const FILE_FLAG_FIRST_PIPE_INSTANCE: DWORD = 0x00080000;
67 pub const FILE_FLAG_OPEN_REQUIRING_OPLOCK: DWORD = 0x00040000;
68 pub const PROGRESS_CONTINUE: DWORD = 0;
69 pub const PROGRESS_CANCEL: DWORD = 1;
70 pub const PROGRESS_STOP: DWORD = 2;
71 pub const PROGRESS_QUIET: DWORD = 3;
72 pub const CALLBACK_CHUNK_FINISHED: DWORD = 0x00000000;
73 pub const CALLBACK_STREAM_SWITCH: DWORD = 0x00000001;
74 pub const COPY_FILE_FAIL_IF_EXISTS: DWORD = 0x00000001;
75 pub const COPY_FILE_RESTARTABLE: DWORD = 0x00000002;
76 pub const COPY_FILE_OPEN_SOURCE_FOR_WRITE: DWORD = 0x00000004;
77 pub const COPY_FILE_ALLOW_DECRYPTED_DESTINATION: DWORD = 0x00000008;
78 pub const COPY_FILE_COPY_SYMLINK: DWORD = 0x00000800;
79 pub const COPY_FILE_NO_BUFFERING: DWORD = 0x00001000;
80 pub const COPY_FILE_REQUEST_SECURITY_PRIVILEGES: DWORD = 0x00002000;
81 pub const COPY_FILE_RESUME_FROM_PAUSE: DWORD = 0x00004000;
82 pub const COPY_FILE_NO_OFFLOAD: DWORD = 0x00040000;
83 pub const COPY_FILE_IGNORE_EDP_BLOCK: DWORD = 0x00400000;
84 pub const COPY_FILE_IGNORE_SOURCE_ENCRYPTION: DWORD = 0x00800000;
85 pub const REPLACEFILE_WRITE_THROUGH: DWORD = 0x00000001;
86 pub const REPLACEFILE_IGNORE_MERGE_ERRORS: DWORD = 0x00000002;
87 pub const REPLACEFILE_IGNORE_ACL_ERRORS: DWORD = 0x00000004;
88 pub const PIPE_ACCESS_INBOUND: DWORD = 0x00000001;
89 pub const PIPE_ACCESS_OUTBOUND: DWORD = 0x00000002;
90 pub const PIPE_ACCESS_DUPLEX: DWORD = 0x00000003;
91 pub const PIPE_CLIENT_END: DWORD = 0x00000000;
92 pub const PIPE_SERVER_END: DWORD = 0x00000001;
93 pub const PIPE_WAIT: DWORD = 0x00000000;
94 pub const PIPE_NOWAIT: DWORD = 0x00000001;
95 pub const PIPE_READMODE_BYTE: DWORD = 0x00000000;
96 pub const PIPE_READMODE_MESSAGE: DWORD = 0x00000002;
97 pub const PIPE_TYPE_BYTE: DWORD = 0x00000000;
98 pub const PIPE_TYPE_MESSAGE: DWORD = 0x00000004;
99 pub const PIPE_ACCEPT_REMOTE_CLIENTS: DWORD = 0x00000000;
100 pub const PIPE_REJECT_REMOTE_CLIENTS: DWORD = 0x00000008;
101 pub const PIPE_UNLIMITED_INSTANCES: DWORD = 255;
102 pub const SECURITY_ANONYMOUS: DWORD = SecurityAnonymous << 16;
103 pub const SECURITY_IDENTIFICATION: DWORD = SecurityIdentification << 16;
104 pub const SECURITY_IMPERSONATION: DWORD = SecurityImpersonation << 16;
105 pub const SECURITY_DELEGATION: DWORD = SecurityDelegation << 16;
106 pub const SECURITY_CONTEXT_TRACKING: DWORD = 0x00040000;
107 pub const SECURITY_EFFECTIVE_ONLY: DWORD = 0x00080000;
108 pub const SECURITY_SQOS_PRESENT: DWORD = 0x00100000;
109 pub const SECURITY_VALID_SQOS_FLAGS: DWORD = 0x001F0000;
110 FN!{stdcall PFIBER_START_ROUTINE(
111     lpFiberParameter: LPVOID,
112 ) -> ()}
113 pub type LPFIBER_START_ROUTINE = PFIBER_START_ROUTINE;
114 FN!{stdcall PFIBER_CALLOUT_ROUTINE(
115     lpParameter: LPVOID,
116 ) -> LPVOID}
117 // FAIL_FAST_*
118 #[cfg(target_arch = "x86")]
119 pub type LPLDT_ENTRY = PLDT_ENTRY;
120 #[cfg(not(target_arch = "x86"))]
121 pub type LPLDT_ENTRY = LPVOID; // TODO - fix this for 32-bit
122 //SP_SERIALCOMM
123 //PST_*
124 // PCF_*
125 // SP_*
126 // BAUD_*
127 // DATABITS_*
128 // STOPBITS_*
129 // PARITY_*
130 STRUCT!{struct COMMPROP {
131     wPacketLength: WORD,
132     wPacketVersion: WORD,
133     dwServiceMask: DWORD,
134     dwReserved1: DWORD,
135     dwMaxTxQueue: DWORD,
136     dwMaxRxQueue: DWORD,
137     dwMaxBaud: DWORD,
138     dwProvSubType: DWORD,
139     dwProvCapabilities: DWORD,
140     dwSettableParams: DWORD,
141     dwSettableBaud: DWORD,
142     wSettableData: WORD,
143     wSettableStopParity: WORD,
144     dwCurrentTxQueue: DWORD,
145     dwCurrentRxQueue: DWORD,
146     dwProvSpec1: DWORD,
147     dwProvSpec2: DWORD,
148     wcProvChar: [WCHAR; 1],
149 }}
150 pub type LPCOMMPROP = *mut COMMPROP;
151 STRUCT!{struct COMSTAT {
152     BitFields: DWORD,
153     cbInQue: DWORD,
154     cbOutQue: DWORD,
155 }}
156 BITFIELD!{COMSTAT BitFields: DWORD [
157     fCtsHold set_fCtsHold[0..1],
158     fDsrHold set_fDsrHold[1..2],
159     fRlsdHold set_fRlsdHold[2..3],
160     fXoffHold set_fXoffHold[3..4],
161     fXoffSent set_fXoffSent[4..5],
162     fEof set_fEof[5..6],
163     fTxim set_fTxim[6..7],
164     fReserved set_fReserved[7..32],
165 ]}
166 pub type LPCOMSTAT = *mut COMSTAT;
167 pub const DTR_CONTROL_DISABLE: DWORD = 0x00;
168 pub const DTR_CONTROL_ENABLE: DWORD = 0x01;
169 pub const DTR_CONTROL_HANDSHAKE: DWORD = 0x02;
170 pub const RTS_CONTROL_DISABLE: DWORD = 0x00;
171 pub const RTS_CONTROL_ENABLE: DWORD = 0x01;
172 pub const RTS_CONTROL_HANDSHAKE: DWORD = 0x02;
173 pub const RTS_CONTROL_TOGGLE: DWORD = 0x03;
174 STRUCT!{struct DCB {
175     DCBlength: DWORD,
176     BaudRate: DWORD,
177     BitFields: DWORD,
178     wReserved: WORD,
179     XonLim: WORD,
180     XoffLim: WORD,
181     ByteSize: BYTE,
182     Parity: BYTE,
183     StopBits: BYTE,
184     XonChar: c_char,
185     XoffChar: c_char,
186     ErrorChar: c_char,
187     EofChar: c_char,
188     EvtChar: c_char,
189     wReserved1: WORD,
190 }}
191 BITFIELD!{DCB BitFields: DWORD [
192     fBinary set_fBinary[0..1],
193     fParity set_fParity[1..2],
194     fOutxCtsFlow set_fOutxCtsFlow[2..3],
195     fOutxDsrFlow set_fOutxDsrFlow[3..4],
196     fDtrControl set_fDtrControl[4..6],
197     fDsrSensitivity set_fDsrSensitivity[6..7],
198     fTXContinueOnXoff set_fTXContinueOnXoff[7..8],
199     fOutX set_fOutX[8..9],
200     fInX set_fInX[9..10],
201     fErrorChar set_fErrorChar[10..11],
202     fNull set_fNull[11..12],
203     fRtsControl set_fRtsControl[12..14],
204     fAbortOnError set_fAbortOnError[14..15],
205     fDummy2 set_fDummy2[15..32],
206 ]}
207 pub type LPDCB = *mut DCB;
208 STRUCT!{struct COMMTIMEOUTS {
209     ReadIntervalTimeout: DWORD,
210     ReadTotalTimeoutMultiplier: DWORD,
211     ReadTotalTimeoutConstant: DWORD,
212     WriteTotalTimeoutMultiplier: DWORD,
213     WriteTotalTimeoutConstant: DWORD,
214 }}
215 pub type LPCOMMTIMEOUTS = *mut COMMTIMEOUTS;
216 STRUCT!{struct COMMCONFIG {
217     dwSize: DWORD,
218     wVersion: WORD,
219     wReserved: WORD,
220     dcb: DCB,
221     dwProviderSubType: DWORD,
222     dwProviderOffset: DWORD,
223     dwProviderSize: DWORD,
224     wcProviderData: [WCHAR; 1],
225 }}
226 pub type LPCOMMCONFIG = *mut COMMCONFIG;
227 pub const GMEM_FIXED: UINT = 0x0000;
228 pub const GMEM_MOVEABLE: UINT = 0x0002;
229 pub const GMEM_NOCOMPACT: UINT = 0x0010;
230 pub const GMEM_NODISCARD: UINT = 0x0020;
231 pub const GMEM_ZEROINIT: UINT = 0x0040;
232 pub const GMEM_MODIFY: UINT = 0x0080;
233 pub const GMEM_DISCARDABLE: UINT = 0x0100;
234 pub const GMEM_NOT_BANKED: UINT = 0x1000;
235 pub const GMEM_SHARE: UINT = 0x2000;
236 pub const GMEM_DDESHARE: UINT = 0x2000;
237 pub const GMEM_NOTIFY: UINT = 0x4000;
238 pub const GMEM_LOWER: UINT = GMEM_NOT_BANKED;
239 pub const GMEM_VALID_FLAGS: UINT = 0x7F72;
240 pub const GMEM_INVALID_HANDLE: UINT = 0x8000;
241 pub const GHND: UINT = GMEM_MOVEABLE | GMEM_ZEROINIT;
242 pub const GPTR: UINT = GMEM_FIXED | GMEM_ZEROINIT;
243 pub const GMEM_DISCARDED: UINT = 0x4000;
244 pub const GMEM_LOCKCOUNT: UINT = 0x00FF;
245 STRUCT!{struct MEMORYSTATUS {
246     dwLength: DWORD,
247     dwMemoryLoad: DWORD,
248     dwTotalPhys: SIZE_T,
249     dwAvailPhys: SIZE_T,
250     dwTotalPageFile: SIZE_T,
251     dwAvailPageFile: SIZE_T,
252     dwTotalVirtual: SIZE_T,
253     dwAvailVirtual: SIZE_T,
254 }}
255 pub type LPMEMORYSTATUS = *mut MEMORYSTATUS;
256 // NUMA_NO_PREFERRED_NODE
257 pub const DEBUG_PROCESS: DWORD = 0x00000001;
258 pub const DEBUG_ONLY_THIS_PROCESS: DWORD = 0x00000002;
259 pub const CREATE_SUSPENDED: DWORD = 0x00000004;
260 pub const DETACHED_PROCESS: DWORD = 0x00000008;
261 pub const CREATE_NEW_CONSOLE: DWORD = 0x00000010;
262 pub const NORMAL_PRIORITY_CLASS: DWORD = 0x00000020;
263 pub const IDLE_PRIORITY_CLASS: DWORD = 0x00000040;
264 pub const HIGH_PRIORITY_CLASS: DWORD = 0x00000080;
265 pub const REALTIME_PRIORITY_CLASS: DWORD = 0x00000100;
266 pub const CREATE_NEW_PROCESS_GROUP: DWORD = 0x00000200;
267 pub const CREATE_UNICODE_ENVIRONMENT: DWORD = 0x00000400;
268 pub const CREATE_SEPARATE_WOW_VDM: DWORD = 0x00000800;
269 pub const CREATE_SHARED_WOW_VDM: DWORD = 0x00001000;
270 pub const CREATE_FORCEDOS: DWORD = 0x00002000;
271 pub const BELOW_NORMAL_PRIORITY_CLASS: DWORD = 0x00004000;
272 pub const ABOVE_NORMAL_PRIORITY_CLASS: DWORD = 0x00008000;
273 pub const INHERIT_PARENT_AFFINITY: DWORD = 0x00010000;
274 pub const INHERIT_CALLER_PRIORITY: DWORD = 0x00020000;
275 pub const CREATE_PROTECTED_PROCESS: DWORD = 0x00040000;
276 pub const EXTENDED_STARTUPINFO_PRESENT: DWORD = 0x00080000;
277 pub const PROCESS_MODE_BACKGROUND_BEGIN: DWORD = 0x00100000;
278 pub const PROCESS_MODE_BACKGROUND_END: DWORD = 0x00200000;
279 pub const CREATE_BREAKAWAY_FROM_JOB: DWORD = 0x01000000;
280 pub const CREATE_PRESERVE_CODE_AUTHZ_LEVEL: DWORD = 0x02000000;
281 pub const CREATE_DEFAULT_ERROR_MODE: DWORD = 0x04000000;
282 pub const CREATE_NO_WINDOW: DWORD = 0x08000000;
283 pub const PROFILE_USER: DWORD = 0x10000000;
284 pub const PROFILE_KERNEL: DWORD = 0x20000000;
285 pub const PROFILE_SERVER: DWORD = 0x40000000;
286 pub const CREATE_IGNORE_SYSTEM_DEFAULT: DWORD = 0x80000000;
287 // STACK_SIZE_PARAM_IS_A_RESERVATION
288 pub const THREAD_PRIORITY_LOWEST: DWORD = THREAD_BASE_PRIORITY_MIN;
289 pub const THREAD_PRIORITY_BELOW_NORMAL: DWORD = THREAD_PRIORITY_LOWEST + 1;
290 pub const THREAD_PRIORITY_NORMAL: DWORD = 0;
291 pub const THREAD_PRIORITY_HIGHEST: DWORD = THREAD_BASE_PRIORITY_MAX;
292 pub const THREAD_PRIORITY_ABOVE_NORMAL: DWORD = THREAD_PRIORITY_HIGHEST - 1;
293 pub const THREAD_PRIORITY_ERROR_RETURN: DWORD = MAXLONG as u32;
294 pub const THREAD_PRIORITY_TIME_CRITICAL: DWORD = THREAD_BASE_PRIORITY_LOWRT;
295 pub const THREAD_PRIORITY_IDLE: DWORD = THREAD_BASE_PRIORITY_IDLE;
296 pub const THREAD_MODE_BACKGROUND_BEGIN: DWORD = 0x00010000;
297 pub const THREAD_MODE_BACKGROUND_END: DWORD = 0x00020000;
298 pub const VOLUME_NAME_DOS: DWORD = 0x0;
299 // VOLUME_NAME_*
300 // FILE_NAME_*
301 // JIT_DEBUG_*
302 pub const DRIVE_UNKNOWN: DWORD = 0;
303 pub const DRIVE_NO_ROOT_DIR: DWORD = 1;
304 pub const DRIVE_REMOVABLE: DWORD = 2;
305 pub const DRIVE_FIXED: DWORD = 3;
306 pub const DRIVE_REMOTE: DWORD = 4;
307 pub const DRIVE_CDROM: DWORD = 5;
308 pub const DRIVE_RAMDISK: DWORD = 6;
309 // pub fn GetFreeSpace();
310 pub const FILE_TYPE_UNKNOWN: DWORD = 0x0000;
311 pub const FILE_TYPE_DISK: DWORD = 0x0001;
312 pub const FILE_TYPE_CHAR: DWORD = 0x0002;
313 pub const FILE_TYPE_PIPE: DWORD = 0x0003;
314 pub const FILE_TYPE_REMOTE: DWORD = 0x8000;
315 pub const STD_INPUT_HANDLE: DWORD = -10i32 as u32;
316 pub const STD_OUTPUT_HANDLE: DWORD = -11i32 as u32;
317 pub const STD_ERROR_HANDLE: DWORD = -12i32 as u32;
318 pub const NOPARITY: BYTE = 0;
319 pub const ODDPARITY: BYTE = 1;
320 pub const EVENPARITY: BYTE = 2;
321 pub const MARKPARITY: BYTE = 3;
322 pub const SPACEPARITY: BYTE = 4;
323 pub const ONESTOPBIT: BYTE = 0;
324 pub const ONE5STOPBITS: BYTE = 1;
325 pub const TWOSTOPBITS: BYTE = 2;
326 pub const IGNORE: DWORD = 0;
327 pub const INFINITE: DWORD = 0xFFFFFFFF;
328 pub const CBR_110: DWORD = 110;
329 pub const CBR_300: DWORD = 300;
330 pub const CBR_600: DWORD = 600;
331 pub const CBR_1200: DWORD = 1200;
332 pub const CBR_2400: DWORD = 2400;
333 pub const CBR_4800: DWORD = 4800;
334 pub const CBR_9600: DWORD = 9600;
335 pub const CBR_14400: DWORD = 14400;
336 pub const CBR_19200: DWORD = 19200;
337 pub const CBR_38400: DWORD = 38400;
338 pub const CBR_56000: DWORD = 56000;
339 pub const CBR_57600: DWORD = 57600;
340 pub const CBR_115200: DWORD = 115200;
341 pub const CBR_128000: DWORD = 128000;
342 pub const CBR_256000: DWORD = 256000;
343 // CE_*
344 // IE_*
345 // EV_*
346 pub const SETXOFF: DWORD = 1;
347 pub const SETXON: DWORD = 2;
348 pub const SETRTS: DWORD = 3;
349 pub const CLRRTS: DWORD = 4;
350 pub const SETDTR: DWORD = 5;
351 pub const CLRDTR: DWORD = 6;
352 pub const RESETDEV: DWORD = 7;
353 pub const SETBREAK: DWORD = 8;
354 pub const CLRBREAK: DWORD = 9;
355 pub const PURGE_TXABORT: DWORD = 0x0001;
356 pub const PURGE_RXABORT: DWORD = 0x0002;
357 pub const PURGE_TXCLEAR: DWORD = 0x0004;
358 pub const PURGE_RXCLEAR: DWORD = 0x0008;
359 pub const MS_CTS_ON: DWORD = 0x0010;
360 pub const MS_DSR_ON: DWORD = 0x0020;
361 pub const MS_RING_ON: DWORD = 0x0040;
362 pub const MS_RLSD_ON: DWORD = 0x0080;
363 // S_*
364 // NMPWAIT_*
365 // FS_*
366 // OF_*
367 pub const OFS_MAXPATHNAME: usize = 128;
368 STRUCT!{struct OFSTRUCT {
369     cBytes: BYTE,
370     fFixedDisk: BYTE,
371     nErrCode: WORD,
372     Reserved1: WORD,
373     Reserved2: WORD,
374     szPathName: [CHAR; OFS_MAXPATHNAME],
375 }}
376 pub type POFSTRUCT = *mut OFSTRUCT;
377 pub type LPOFSTRUCT = *mut OFSTRUCT;
378 extern "system" {
GlobalAlloc( uFlags: UINT, dwBytes: SIZE_T, ) -> HGLOBAL379     pub fn GlobalAlloc(
380         uFlags: UINT,
381         dwBytes: SIZE_T,
382     ) -> HGLOBAL;
GlobalReAlloc( hMem: HGLOBAL, dwBytes: SIZE_T, uFlags: UINT, ) -> HGLOBAL383     pub fn GlobalReAlloc(
384         hMem: HGLOBAL,
385         dwBytes: SIZE_T,
386         uFlags: UINT,
387     ) -> HGLOBAL;
GlobalSize( hMem: HGLOBAL, ) -> SIZE_T388     pub fn GlobalSize(
389         hMem: HGLOBAL,
390     ) -> SIZE_T;
GlobalFlags( hMem: HGLOBAL, ) -> UINT391     pub fn GlobalFlags(
392         hMem: HGLOBAL,
393     ) -> UINT;
GlobalLock( hMem: HGLOBAL, ) -> LPVOID394     pub fn GlobalLock(
395         hMem: HGLOBAL,
396     ) -> LPVOID;
GlobalHandle( pMem: LPCVOID, ) -> HGLOBAL397     pub fn GlobalHandle(
398         pMem: LPCVOID,
399     ) -> HGLOBAL;
GlobalUnlock( hMem: HGLOBAL, ) -> BOOL400     pub fn GlobalUnlock(
401         hMem: HGLOBAL,
402     ) -> BOOL;
GlobalFree( hMem: HGLOBAL, ) -> HGLOBAL403     pub fn GlobalFree(
404         hMem: HGLOBAL,
405     ) -> HGLOBAL;
GlobalCompact( dwMinFree: DWORD, ) -> SIZE_T406     pub fn GlobalCompact(
407         dwMinFree: DWORD,
408     ) -> SIZE_T;
GlobalFix( hMem: HGLOBAL, )409     pub fn GlobalFix(
410         hMem: HGLOBAL,
411     );
GlobalUnfix( hMem: HGLOBAL, )412     pub fn GlobalUnfix(
413         hMem: HGLOBAL,
414     );
GlobalWire( hMem: HGLOBAL, ) -> LPVOID415     pub fn GlobalWire(
416         hMem: HGLOBAL,
417     ) -> LPVOID;
GlobalUnWire( hMem: HGLOBAL, ) -> BOOL418     pub fn GlobalUnWire(
419         hMem: HGLOBAL,
420     ) -> BOOL;
GlobalMemoryStatus( lpBuffer: LPMEMORYSTATUS, )421     pub fn GlobalMemoryStatus(
422         lpBuffer: LPMEMORYSTATUS,
423     );
LocalAlloc( uFlags: UINT, uBytes: SIZE_T, ) -> HLOCAL424     pub fn LocalAlloc(
425         uFlags: UINT,
426         uBytes: SIZE_T,
427     ) -> HLOCAL;
LocalReAlloc( hMem: HLOCAL, uBytes: SIZE_T, uFlags: UINT, ) -> HLOCAL428     pub fn LocalReAlloc(
429         hMem: HLOCAL,
430         uBytes: SIZE_T,
431         uFlags: UINT,
432     ) -> HLOCAL;
LocalLock( hMem: HLOCAL, ) -> LPVOID433     pub fn LocalLock(
434         hMem: HLOCAL,
435     ) -> LPVOID;
LocalHandle( pMem: LPCVOID, ) -> HLOCAL436     pub fn LocalHandle(
437         pMem: LPCVOID,
438     ) -> HLOCAL;
LocalUnlock( hMem: HLOCAL, ) -> BOOL439     pub fn LocalUnlock(
440         hMem: HLOCAL,
441     ) -> BOOL;
LocalSize( hMem: HLOCAL, ) -> SIZE_T442     pub fn LocalSize(
443         hMem: HLOCAL,
444     ) -> SIZE_T;
LocalFlags( hMem: HLOCAL, ) -> UINT445     pub fn LocalFlags(
446         hMem: HLOCAL,
447     ) -> UINT;
LocalFree( hMem: HLOCAL, ) -> HLOCAL448     pub fn LocalFree(
449         hMem: HLOCAL,
450     ) -> HLOCAL;
LocalShrink( hMem: HLOCAL, cbNewSize: UINT, ) -> SIZE_T451     pub fn LocalShrink(
452         hMem: HLOCAL,
453         cbNewSize: UINT,
454     ) -> SIZE_T;
LocalCompact( uMinFree: UINT, ) -> SIZE_T455     pub fn LocalCompact(
456         uMinFree: UINT,
457     ) -> SIZE_T;
458 }
459 // SCS_*
460 extern "system" {
GetBinaryTypeA( lpApplicationName: LPCSTR, lpBinaryType: LPDWORD, ) -> BOOL461     pub fn GetBinaryTypeA(
462         lpApplicationName: LPCSTR,
463         lpBinaryType: LPDWORD,
464     ) -> BOOL;
GetBinaryTypeW( lpApplicationName: LPCWSTR, lpBinaryType: LPDWORD, ) -> BOOL465     pub fn GetBinaryTypeW(
466         lpApplicationName: LPCWSTR,
467         lpBinaryType: LPDWORD,
468     ) -> BOOL;
GetShortPathNameA( lpszLongPath: LPCSTR, lpszShortPath: LPSTR, cchBuffer: DWORD, ) -> DWORD469     pub fn GetShortPathNameA(
470         lpszLongPath: LPCSTR,
471         lpszShortPath: LPSTR,
472         cchBuffer: DWORD,
473     ) -> DWORD;
GetLongPathNameTransactedA( lpszShortPath: LPCSTR, lpszLongPath: LPSTR, cchBuffer: DWORD, hTransaction: HANDLE, ) -> DWORD474     pub fn GetLongPathNameTransactedA(
475         lpszShortPath: LPCSTR,
476         lpszLongPath: LPSTR,
477         cchBuffer: DWORD,
478         hTransaction: HANDLE,
479     ) -> DWORD;
GetLongPathNameTransactedW( lpszShortPath: LPCWSTR, lpszLongPath: LPWSTR, cchBuffer: DWORD, hTransaction: HANDLE, ) -> DWORD480     pub fn GetLongPathNameTransactedW(
481         lpszShortPath: LPCWSTR,
482         lpszLongPath: LPWSTR,
483         cchBuffer: DWORD,
484         hTransaction: HANDLE,
485     ) -> DWORD;
GetProcessAffinityMask( hProcess: HANDLE, lpProcessAffinityMask: PDWORD_PTR, lpSystemAffinityMask: PDWORD_PTR, ) -> BOOL486     pub fn GetProcessAffinityMask(
487         hProcess: HANDLE,
488         lpProcessAffinityMask: PDWORD_PTR,
489         lpSystemAffinityMask: PDWORD_PTR,
490     ) -> BOOL;
SetProcessAffinityMask( hProcess: HANDLE, dwProcessAffinityMask: DWORD, ) -> BOOL491     pub fn SetProcessAffinityMask(
492         hProcess: HANDLE,
493         dwProcessAffinityMask: DWORD,
494     ) -> BOOL;
GetProcessIoCounters( hProcess: HANDLE, lpIoCounters: PIO_COUNTERS, ) -> BOOL495     pub fn GetProcessIoCounters(
496         hProcess: HANDLE,
497         lpIoCounters: PIO_COUNTERS,
498     ) -> BOOL;
GetProcessWorkingSetSize( hProcess: HANDLE, lpMinimumWorkingSetSize: PSIZE_T, lpMaximumWorkingSetSize: PSIZE_T, ) -> BOOL499     pub fn GetProcessWorkingSetSize(
500         hProcess: HANDLE,
501         lpMinimumWorkingSetSize: PSIZE_T,
502         lpMaximumWorkingSetSize: PSIZE_T,
503     ) -> BOOL;
SetProcessWorkingSetSize( hProcess: HANDLE, dwMinimumWorkingSetSize: SIZE_T, dwMaximumWorkingSetSize: SIZE_T, ) -> BOOL504     pub fn SetProcessWorkingSetSize(
505         hProcess: HANDLE,
506         dwMinimumWorkingSetSize: SIZE_T,
507         dwMaximumWorkingSetSize: SIZE_T,
508     ) -> BOOL;
FatalExit( ExitCode: c_int, )509     pub fn FatalExit(
510         ExitCode: c_int,
511     );
SetEnvironmentStringsA( NewEnvironment: LPCH, ) -> BOOL512     pub fn SetEnvironmentStringsA(
513         NewEnvironment: LPCH,
514     ) -> BOOL;
SwitchToFiber( lpFiber: LPVOID, )515     pub fn SwitchToFiber(
516         lpFiber: LPVOID,
517     );
DeleteFiber( lpFiber: LPVOID, )518     pub fn DeleteFiber(
519         lpFiber: LPVOID,
520     );
ConvertFiberToThread() -> BOOL521     pub fn ConvertFiberToThread() -> BOOL;
CreateFiberEx( dwStackCommitSize: SIZE_T, dwStackReserveSize: SIZE_T, dwFlags: DWORD, lpStartAddress: LPFIBER_START_ROUTINE, lpParameter: LPVOID, ) -> LPVOID522     pub fn CreateFiberEx(
523         dwStackCommitSize: SIZE_T,
524         dwStackReserveSize: SIZE_T,
525         dwFlags: DWORD,
526         lpStartAddress: LPFIBER_START_ROUTINE,
527         lpParameter: LPVOID,
528     ) -> LPVOID;
ConvertThreadToFiberEx( lpParameter: LPVOID, dwFlags: DWORD, ) -> LPVOID529     pub fn ConvertThreadToFiberEx(
530         lpParameter: LPVOID,
531         dwFlags: DWORD,
532     ) -> LPVOID;
CreateFiber( dwStackSize: SIZE_T, lpStartAddress: LPFIBER_START_ROUTINE, lpParameter: LPVOID, ) -> LPVOID533     pub fn CreateFiber(
534         dwStackSize: SIZE_T,
535         lpStartAddress: LPFIBER_START_ROUTINE,
536         lpParameter: LPVOID,
537     ) -> LPVOID;
ConvertThreadToFiber( lpParameter: LPVOID, ) -> LPVOID538     pub fn ConvertThreadToFiber(
539         lpParameter: LPVOID,
540     ) -> LPVOID;
541 }
542 pub type PUMS_CONTEXT = *mut c_void;
543 pub type PUMS_COMPLETION_LIST = *mut c_void;
544 pub type UMS_THREAD_INFO_CLASS = RTL_UMS_THREAD_INFO_CLASS;
545 pub type PUMS_THREAD_INFO_CLASS = *mut UMS_THREAD_INFO_CLASS;
546 pub type PUMS_SCHEDULER_ENTRY_POINT = PRTL_UMS_SCHEDULER_ENTRY_POINT;
547 STRUCT!{struct UMS_SCHEDULER_STARTUP_INFO {
548     UmsVersion: ULONG,
549     CompletionList: PUMS_COMPLETION_LIST,
550     SchedulerProc: PUMS_SCHEDULER_ENTRY_POINT,
551     SchedulerParam: PVOID,
552 }}
553 pub type PUMS_SCHEDULER_STARTUP_INFO = *mut UMS_SCHEDULER_STARTUP_INFO;
554 STRUCT!{struct UMS_SYSTEM_THREAD_INFORMATION {
555     UmsVersion: ULONG,
556     ThreadUmsFlags: ULONG,
557 }}
558 BITFIELD!{UMS_SYSTEM_THREAD_INFORMATION ThreadUmsFlags: ULONG [
559     IsUmsSchedulerThread set_IsUmsSchedulerThread[0..1],
560     IsUmsWorkerThread set_IsUmsWorkerThread[1..2],
561 ]}
562 pub type PUMS_SYSTEM_THREAD_INFORMATION = *mut UMS_SYSTEM_THREAD_INFORMATION;
563 extern "system" {
564     #[cfg(target_pointer_width = "64")]
CreateUmsCompletionList( UmsCompletionList: *mut PUMS_COMPLETION_LIST, ) -> BOOL565     pub fn CreateUmsCompletionList(
566         UmsCompletionList: *mut PUMS_COMPLETION_LIST,
567     ) -> BOOL;
568     #[cfg(target_pointer_width = "64")]
DequeueUmsCompletionListItems( UmsCompletionList: PUMS_COMPLETION_LIST, WaitTimeOut: DWORD, UmsThreadList: *mut PUMS_CONTEXT, ) -> BOOL569     pub fn DequeueUmsCompletionListItems(
570         UmsCompletionList: PUMS_COMPLETION_LIST,
571         WaitTimeOut: DWORD,
572         UmsThreadList: *mut PUMS_CONTEXT,
573     ) -> BOOL;
574     #[cfg(target_pointer_width = "64")]
GetUmsCompletionListEvent( UmsCompletionList: PUMS_COMPLETION_LIST, UmsCompletionEvent: PHANDLE, ) -> BOOL575     pub fn GetUmsCompletionListEvent(
576         UmsCompletionList: PUMS_COMPLETION_LIST,
577         UmsCompletionEvent: PHANDLE,
578     ) -> BOOL;
579     #[cfg(target_pointer_width = "64")]
ExecuteUmsThread( UmsThread: PUMS_CONTEXT, ) -> BOOL580     pub fn ExecuteUmsThread(
581         UmsThread: PUMS_CONTEXT,
582     ) -> BOOL;
583     #[cfg(target_pointer_width = "64")]
UmsThreadYield( SchedulerParam: PVOID, ) -> BOOL584     pub fn UmsThreadYield(
585         SchedulerParam: PVOID,
586     ) -> BOOL;
587     #[cfg(target_pointer_width = "64")]
DeleteUmsCompletionList( UmsCompletionList: PUMS_COMPLETION_LIST, ) -> BOOL588     pub fn DeleteUmsCompletionList(
589         UmsCompletionList: PUMS_COMPLETION_LIST,
590     ) -> BOOL;
591     #[cfg(target_pointer_width = "64")]
GetCurrentUmsThread() -> PUMS_CONTEXT592     pub fn GetCurrentUmsThread() -> PUMS_CONTEXT;
593     #[cfg(target_pointer_width = "64")]
GetNextUmsListItem( UmsContext: PUMS_CONTEXT, ) -> PUMS_CONTEXT594     pub fn GetNextUmsListItem(
595         UmsContext: PUMS_CONTEXT,
596     ) -> PUMS_CONTEXT;
597     #[cfg(target_pointer_width = "64")]
QueryUmsThreadInformation( UmsThread: PUMS_CONTEXT, UmsThreadInfoClass: UMS_THREAD_INFO_CLASS, UmsThreadInformation: PVOID, UmsThreadInformationLength: ULONG, ReturnLength: PULONG, ) -> BOOL598     pub fn QueryUmsThreadInformation(
599         UmsThread: PUMS_CONTEXT,
600         UmsThreadInfoClass: UMS_THREAD_INFO_CLASS,
601         UmsThreadInformation: PVOID,
602         UmsThreadInformationLength: ULONG,
603         ReturnLength: PULONG,
604     ) -> BOOL;
605     #[cfg(target_pointer_width = "64")]
SetUmsThreadInformation( UmsThread: PUMS_CONTEXT, UmsThreadInfoClass: UMS_THREAD_INFO_CLASS, UmsThreadInformation: PVOID, UmsThreadInformationLength: ULONG, ) -> BOOL606     pub fn SetUmsThreadInformation(
607         UmsThread: PUMS_CONTEXT,
608         UmsThreadInfoClass: UMS_THREAD_INFO_CLASS,
609         UmsThreadInformation: PVOID,
610         UmsThreadInformationLength: ULONG,
611     ) -> BOOL;
612     #[cfg(target_pointer_width = "64")]
DeleteUmsThreadContext( UmsThread: PUMS_CONTEXT, ) -> BOOL613     pub fn DeleteUmsThreadContext(
614         UmsThread: PUMS_CONTEXT,
615     ) -> BOOL;
616     #[cfg(target_pointer_width = "64")]
CreateUmsThreadContext( lpUmsThread: *mut PUMS_CONTEXT, ) -> BOOL617     pub fn CreateUmsThreadContext(
618         lpUmsThread: *mut PUMS_CONTEXT,
619     ) -> BOOL;
620     #[cfg(target_pointer_width = "64")]
EnterUmsSchedulingMode( SchedulerStartupInfo: PUMS_SCHEDULER_STARTUP_INFO, ) -> BOOL621     pub fn EnterUmsSchedulingMode(
622         SchedulerStartupInfo: PUMS_SCHEDULER_STARTUP_INFO,
623     ) -> BOOL;
624     #[cfg(target_pointer_width = "64")]
GetUmsSystemThreadInformation( ThreadHandle: HANDLE, SystemThreadInfo: PUMS_SYSTEM_THREAD_INFORMATION, ) -> BOOL625     pub fn GetUmsSystemThreadInformation(
626         ThreadHandle: HANDLE,
627         SystemThreadInfo: PUMS_SYSTEM_THREAD_INFORMATION,
628     ) -> BOOL;
SetThreadAffinityMask( hThread: HANDLE, dwThreadAffinityMask: DWORD_PTR, ) -> DWORD_PTR629     pub fn SetThreadAffinityMask(
630         hThread: HANDLE,
631         dwThreadAffinityMask: DWORD_PTR,
632     ) -> DWORD_PTR;
SetProcessDEPPolicy( dwFlags: DWORD, ) -> BOOL633     pub fn SetProcessDEPPolicy(
634         dwFlags: DWORD,
635     ) -> BOOL;
GetProcessDEPPolicy( hProcess: HANDLE, lpFlags: LPDWORD, lpPermanent: PBOOL, ) -> BOOL636     pub fn GetProcessDEPPolicy(
637         hProcess: HANDLE,
638         lpFlags: LPDWORD,
639         lpPermanent: PBOOL,
640     ) -> BOOL;
RequestWakeupLatency( latency: LATENCY_TIME, ) -> BOOL641     pub fn RequestWakeupLatency(
642         latency: LATENCY_TIME,
643     ) -> BOOL;
IsSystemResumeAutomatic() -> BOOL644     pub fn IsSystemResumeAutomatic() -> BOOL;
GetThreadSelectorEntry( hThread: HANDLE, dwSelector: DWORD, lpSelectorEntry: LPLDT_ENTRY, ) -> BOOL645     pub fn GetThreadSelectorEntry(
646         hThread: HANDLE,
647         dwSelector: DWORD,
648         lpSelectorEntry: LPLDT_ENTRY,
649     ) -> BOOL;
SetThreadExecutionState( esFlags: EXECUTION_STATE, ) -> EXECUTION_STATE650     pub fn SetThreadExecutionState(
651         esFlags: EXECUTION_STATE,
652     ) -> EXECUTION_STATE;
PowerCreateRequest( Context: PREASON_CONTEXT, ) -> HANDLE653     pub fn PowerCreateRequest(
654         Context: PREASON_CONTEXT,
655     ) -> HANDLE;
PowerSetRequest( PowerRequest: HANDLE, RequestType: POWER_REQUEST_TYPE, ) -> BOOL656     pub fn PowerSetRequest(
657         PowerRequest: HANDLE,
658         RequestType: POWER_REQUEST_TYPE,
659     ) -> BOOL;
PowerClearRequest( PowerRequest: HANDLE, RequestType: POWER_REQUEST_TYPE, ) -> BOOL660     pub fn PowerClearRequest(
661         PowerRequest: HANDLE,
662         RequestType: POWER_REQUEST_TYPE,
663     ) -> BOOL;
RestoreLastError( dwErrCode: DWORD, )664     pub fn RestoreLastError(
665         dwErrCode: DWORD,
666     );
667 }
668 pub const FILE_SKIP_COMPLETION_PORT_ON_SUCCESS: UCHAR = 0x1;
669 pub const FILE_SKIP_SET_EVENT_ON_HANDLE: UCHAR = 0x2;
670 extern "system" {
SetFileCompletionNotificationModes( FileHandle: HANDLE, Flags: UCHAR, ) -> BOOL671     pub fn SetFileCompletionNotificationModes(
672         FileHandle: HANDLE,
673         Flags: UCHAR,
674     ) -> BOOL;
675 }
676 pub const SEM_FAILCRITICALERRORS: UINT = 0x0001;
677 pub const SEM_NOGPFAULTERRORBOX: UINT = 0x0002;
678 pub const SEM_NOALIGNMENTFAULTEXCEPT: UINT = 0x0004;
679 pub const SEM_NOOPENFILEERRORBOX: UINT = 0x8000;
680 extern "system" {
Wow64GetThreadContext( hThread: HANDLE, lpContext: PWOW64_CONTEXT, ) -> BOOL681     pub fn Wow64GetThreadContext(
682         hThread: HANDLE,
683         lpContext: PWOW64_CONTEXT,
684     ) -> BOOL;
Wow64SetThreadContext( hThread: HANDLE, lpContext: *const WOW64_CONTEXT, ) -> BOOL685     pub fn Wow64SetThreadContext(
686         hThread: HANDLE,
687         lpContext: *const WOW64_CONTEXT,
688     ) -> BOOL;
Wow64GetThreadSelectorEntry( hThread: HANDLE, dwSelector: DWORD, lpSelectorEntry: PWOW64_LDT_ENTRY, ) -> BOOL689     pub fn Wow64GetThreadSelectorEntry(
690         hThread: HANDLE,
691         dwSelector: DWORD,
692         lpSelectorEntry: PWOW64_LDT_ENTRY,
693     ) -> BOOL;
Wow64SuspendThread( hThread: HANDLE, ) -> DWORD694     pub fn Wow64SuspendThread(
695         hThread: HANDLE,
696     ) -> DWORD;
DebugSetProcessKillOnExit( KillOnExit: BOOL, ) -> BOOL697     pub fn DebugSetProcessKillOnExit(
698         KillOnExit: BOOL,
699     ) -> BOOL;
DebugBreakProcess( Process: HANDLE, ) -> BOOL700     pub fn DebugBreakProcess(
701         Process: HANDLE,
702     ) -> BOOL;
PulseEvent( hEvent: HANDLE, ) -> BOOL703     pub fn PulseEvent(
704         hEvent: HANDLE,
705     ) -> BOOL;
GlobalDeleteAtom( nAtom: ATOM, ) -> ATOM706     pub fn GlobalDeleteAtom(
707         nAtom: ATOM,
708     ) -> ATOM;
InitAtomTable( nSize: DWORD, ) -> BOOL709     pub fn InitAtomTable(
710         nSize: DWORD,
711     ) -> BOOL;
DeleteAtom( nAtom: ATOM, ) -> ATOM712     pub fn DeleteAtom(
713         nAtom: ATOM,
714     ) -> ATOM;
SetHandleCount( uNumber: UINT, ) -> UINT715     pub fn SetHandleCount(
716         uNumber: UINT,
717     ) -> UINT;
RequestDeviceWakeup( hDevice: HANDLE, ) -> BOOL718     pub fn RequestDeviceWakeup(
719         hDevice: HANDLE,
720     ) -> BOOL;
CancelDeviceWakeupRequest( hDevice: HANDLE, ) -> BOOL721     pub fn CancelDeviceWakeupRequest(
722         hDevice: HANDLE,
723     ) -> BOOL;
GetDevicePowerState( hDevice: HANDLE, pfOn: *mut BOOL, ) -> BOOL724     pub fn GetDevicePowerState(
725         hDevice: HANDLE,
726         pfOn: *mut BOOL,
727     ) -> BOOL;
SetMessageWaitingIndicator( hMsgIndicator: HANDLE, ulMsgCount: ULONG, ) -> BOOL728     pub fn SetMessageWaitingIndicator(
729         hMsgIndicator: HANDLE,
730         ulMsgCount: ULONG,
731     ) -> BOOL;
SetFileShortNameA( hFile: HANDLE, lpShortName: LPCSTR, ) -> BOOL732     pub fn SetFileShortNameA(
733         hFile: HANDLE,
734         lpShortName: LPCSTR,
735     ) -> BOOL;
SetFileShortNameW( hFile: HANDLE, lpShortName: LPCWSTR, ) -> BOOL736     pub fn SetFileShortNameW(
737         hFile: HANDLE,
738         lpShortName: LPCWSTR,
739     ) -> BOOL;
740 }
741 pub const HANDLE_FLAG_INHERIT: DWORD = 0x00000001;
742 pub const HANDLE_FLAG_PROTECT_FROM_CLOSE: DWORD = 0x00000002;
743 extern "system" {
LoadModule( lpModuleName: LPCSTR, lpParameterBlock: LPVOID, ) -> DWORD744     pub fn LoadModule(
745         lpModuleName: LPCSTR,
746         lpParameterBlock: LPVOID,
747     ) -> DWORD;
WinExec( lpCmdLine: LPCSTR, uCmdShow: UINT, ) -> UINT748     pub fn WinExec(
749         lpCmdLine: LPCSTR,
750         uCmdShow: UINT,
751     ) -> UINT;
752     // ClearCommBreak
753     // ClearCommError
754     // SetupComm
755     // EscapeCommFunction
756     // GetCommConfig
757     // GetCommMask
758     // GetCommProperties
759     // GetCommModemStatus
760     // GetCommState
761     // GetCommTimeouts
762     // PurgeComm
763     // SetCommBreak
764     // SetCommConfig
765     // SetCommMask
766     // SetCommState
767     // SetCommTimeouts
768     // TransmitCommChar
769     // WaitCommEvent
SetTapePosition( hDevice: HANDLE, dwPositionMethod: DWORD, dwPartition: DWORD, dwOffsetLow: DWORD, dwOffsetHigh: DWORD, bImmediate: BOOL, ) -> DWORD770     pub fn SetTapePosition(
771         hDevice: HANDLE,
772         dwPositionMethod: DWORD,
773         dwPartition: DWORD,
774         dwOffsetLow: DWORD,
775         dwOffsetHigh: DWORD,
776         bImmediate: BOOL,
777     ) -> DWORD;
GetTapePosition( hDevice: HANDLE, dwPositionType: DWORD, lpdwPartition: LPDWORD, lpdwOffsetLow: LPDWORD, lpdwOffsetHigh: LPDWORD, ) -> DWORD778     pub fn GetTapePosition(
779         hDevice: HANDLE,
780         dwPositionType: DWORD,
781         lpdwPartition: LPDWORD,
782         lpdwOffsetLow: LPDWORD,
783         lpdwOffsetHigh: LPDWORD,
784     ) -> DWORD;
PrepareTape( hDevice: HANDLE, dwOperation: DWORD, bImmediate: BOOL, ) -> DWORD785     pub fn PrepareTape(
786         hDevice: HANDLE,
787         dwOperation: DWORD,
788         bImmediate: BOOL,
789     ) -> DWORD;
EraseTape( hDevice: HANDLE, dwEraseType: DWORD, bImmediate: BOOL, ) -> DWORD790     pub fn EraseTape(
791         hDevice: HANDLE,
792         dwEraseType: DWORD,
793         bImmediate: BOOL,
794     ) -> DWORD;
CreateTapePartition( hDevice: HANDLE, dwPartitionMethod: DWORD, dwCount: DWORD, dwSize: DWORD, ) -> DWORD795     pub fn CreateTapePartition(
796         hDevice: HANDLE,
797         dwPartitionMethod: DWORD,
798         dwCount: DWORD,
799         dwSize: DWORD,
800     ) -> DWORD;
WriteTapemark( hDevice: HANDLE, dwTapemarkType: DWORD, dwTapemarkCount: DWORD, bImmediate: BOOL, ) -> DWORD801     pub fn WriteTapemark(
802         hDevice: HANDLE,
803         dwTapemarkType: DWORD,
804         dwTapemarkCount: DWORD,
805         bImmediate: BOOL,
806     ) -> DWORD;
GetTapeStatus( hDevice: HANDLE, ) -> DWORD807     pub fn GetTapeStatus(
808         hDevice: HANDLE,
809     ) -> DWORD;
GetTapeParameters( hDevice: HANDLE, dwOperation: DWORD, lpdwSize: LPDWORD, lpTapeInformation: LPVOID, ) -> DWORD810     pub fn GetTapeParameters(
811         hDevice: HANDLE,
812         dwOperation: DWORD,
813         lpdwSize: LPDWORD,
814         lpTapeInformation: LPVOID,
815     ) -> DWORD;
SetTapeParameters( hDevice: HANDLE, dwOperation: DWORD, lpTapeInformation: LPVOID, ) -> DWORD816     pub fn SetTapeParameters(
817         hDevice: HANDLE,
818         dwOperation: DWORD,
819         lpTapeInformation: LPVOID,
820     ) -> DWORD;
MulDiv( nNumber: c_int, nNumerator: c_int, nDenominator: c_int, ) -> c_int821     pub fn MulDiv(
822         nNumber: c_int,
823         nNumerator: c_int,
824         nDenominator: c_int,
825     ) -> c_int;
826 }
827 ENUM!{enum DEP_SYSTEM_POLICY_TYPE {
828     DEPPolicyAlwaysOff = 0,
829     DEPPolicyAlwaysOn,
830     DEPPolicyOptIn,
831     DEPPolicyOptOut,
832     DEPTotalPolicyCount,
833 }}
834 extern "system" {
GetSystemDEPPolicy() -> DEP_SYSTEM_POLICY_TYPE835     pub fn GetSystemDEPPolicy() -> DEP_SYSTEM_POLICY_TYPE;
GetSystemRegistryQuota( pdwQuotaAllowed: PDWORD, pdwQuotaUsed: PDWORD, ) -> BOOL836     pub fn GetSystemRegistryQuota(
837         pdwQuotaAllowed: PDWORD,
838         pdwQuotaUsed: PDWORD,
839     ) -> BOOL;
FileTimeToDosDateTime( lpFileTime: *const FILETIME, lpFatDate: LPWORD, lpFatTime: LPWORD, ) -> BOOL840     pub fn FileTimeToDosDateTime(
841         lpFileTime: *const FILETIME,
842         lpFatDate: LPWORD,
843         lpFatTime: LPWORD,
844     ) -> BOOL;
DosDateTimeToFileTime( wFatDate: WORD, wFatTime: WORD, lpFileTime: LPFILETIME, ) -> BOOL845     pub fn DosDateTimeToFileTime(
846         wFatDate: WORD,
847         wFatTime: WORD,
848         lpFileTime: LPFILETIME,
849     ) -> BOOL;
FormatMessageA( dwFlags: DWORD, lpSource: LPCVOID, dwMessageId: DWORD, dwLanguageId: DWORD, lpBuffer: LPSTR, nSize: DWORD, Arguments: *mut va_list, ) -> DWORD850     pub fn FormatMessageA(
851         dwFlags: DWORD,
852         lpSource: LPCVOID,
853         dwMessageId: DWORD,
854         dwLanguageId: DWORD,
855         lpBuffer: LPSTR,
856         nSize: DWORD,
857         Arguments: *mut va_list,
858     ) -> DWORD;
FormatMessageW( dwFlags: DWORD, lpSource: LPCVOID, dwMessageId: DWORD, dwLanguageId: DWORD, lpBuffer: LPWSTR, nSize: DWORD, Arguments: *mut va_list, ) -> DWORD859     pub fn FormatMessageW(
860         dwFlags: DWORD,
861         lpSource: LPCVOID,
862         dwMessageId: DWORD,
863         dwLanguageId: DWORD,
864         lpBuffer: LPWSTR,
865         nSize: DWORD,
866         Arguments: *mut va_list,
867     ) -> DWORD;
868 }
869 pub const FORMAT_MESSAGE_IGNORE_INSERTS: DWORD = 0x00000200;
870 pub const FORMAT_MESSAGE_FROM_STRING: DWORD = 0x00000400;
871 pub const FORMAT_MESSAGE_FROM_HMODULE: DWORD = 0x00000800;
872 pub const FORMAT_MESSAGE_FROM_SYSTEM: DWORD = 0x00001000;
873 pub const FORMAT_MESSAGE_ARGUMENT_ARRAY: DWORD = 0x00002000;
874 pub const FORMAT_MESSAGE_MAX_WIDTH_MASK: DWORD = 0x000000FF;
875 pub const FORMAT_MESSAGE_ALLOCATE_BUFFER: DWORD = 0x00000100;
876 extern "system" {
CreateMailslotA( lpName: LPCSTR, nMaxMessageSize: DWORD, lReadTimeout: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> HANDLE877     pub fn CreateMailslotA(
878         lpName: LPCSTR,
879         nMaxMessageSize: DWORD,
880         lReadTimeout: DWORD,
881         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
882     ) -> HANDLE;
CreateMailslotW( lpName: LPCWSTR, nMaxMessageSize: DWORD, lReadTimeout: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> HANDLE883     pub fn CreateMailslotW(
884         lpName: LPCWSTR,
885         nMaxMessageSize: DWORD,
886         lReadTimeout: DWORD,
887         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
888     ) -> HANDLE;
GetMailslotInfo( hMailslot: HANDLE, lpMaxMessageSize: LPDWORD, lpNextSize: LPDWORD, lpMessageCount: LPDWORD, lpReadTimeout: LPDWORD, ) -> BOOL889     pub fn GetMailslotInfo(
890         hMailslot: HANDLE,
891         lpMaxMessageSize: LPDWORD,
892         lpNextSize: LPDWORD,
893         lpMessageCount: LPDWORD,
894         lpReadTimeout: LPDWORD,
895     ) -> BOOL;
SetMailslotInfo( hMailslot: HANDLE, lReadTimeout: DWORD, ) -> BOOL896     pub fn SetMailslotInfo(
897         hMailslot: HANDLE,
898         lReadTimeout: DWORD,
899     ) -> BOOL;
900     // pub fn EncryptFileA();
901     // pub fn EncryptFileW();
902     // pub fn DecryptFileA();
903     // pub fn DecryptFileW();
904     // pub fn FileEncryptionStatusA();
905     // pub fn FileEncryptionStatusW();
906     // pub fn OpenEncryptedFileRawA();
907     // pub fn OpenEncryptedFileRawW();
908     // pub fn ReadEncryptedFileRaw();
909     // pub fn WriteEncryptedFileRaw();
910     // pub fn CloseEncryptedFileRaw();
lstrcmpA( lpString1: LPCSTR, lpString2: LPCSTR, ) -> c_int911     pub fn lstrcmpA(
912         lpString1: LPCSTR,
913         lpString2: LPCSTR,
914     ) -> c_int;
lstrcmpW( lpString1: LPCWSTR, lpString2: LPCWSTR, ) -> c_int915     pub fn lstrcmpW(
916         lpString1: LPCWSTR,
917         lpString2: LPCWSTR,
918     ) -> c_int;
lstrcmpiA( lpString1: LPCSTR, lpString2: LPCSTR, ) -> c_int919     pub fn lstrcmpiA(
920         lpString1: LPCSTR,
921         lpString2: LPCSTR,
922     ) -> c_int;
lstrcmpiW( lpString1: LPCWSTR, lpString2: LPCWSTR, ) -> c_int923     pub fn lstrcmpiW(
924         lpString1: LPCWSTR,
925         lpString2: LPCWSTR,
926     ) -> c_int;
lstrcpynA( lpString1: LPSTR, lpString2: LPCSTR, iMaxLength: c_int, ) -> LPSTR927     pub fn lstrcpynA(
928         lpString1: LPSTR,
929         lpString2: LPCSTR,
930         iMaxLength: c_int,
931     ) -> LPSTR;
lstrcpynW( lpString1: LPWSTR, lpString2: LPCWSTR, iMaxLength: c_int, ) -> LPWSTR932     pub fn lstrcpynW(
933         lpString1: LPWSTR,
934         lpString2: LPCWSTR,
935         iMaxLength: c_int,
936     ) -> LPWSTR;
lstrcpyA( lpString1: LPSTR, lpString2: LPCSTR, ) -> LPSTR937     pub fn lstrcpyA(
938         lpString1: LPSTR,
939         lpString2: LPCSTR,
940     ) -> LPSTR;
lstrcpyW( lpString1: LPWSTR, lpString2: LPCWSTR, ) -> LPWSTR941     pub fn lstrcpyW(
942         lpString1: LPWSTR,
943         lpString2: LPCWSTR,
944     ) -> LPWSTR;
lstrcatA( lpString1: LPSTR, lpString2: LPCSTR, ) -> LPSTR945     pub fn lstrcatA(
946         lpString1: LPSTR,
947         lpString2: LPCSTR,
948     ) -> LPSTR;
lstrcatW( lpString1: LPWSTR, lpString2: LPCWSTR, ) -> LPWSTR949     pub fn lstrcatW(
950         lpString1: LPWSTR,
951         lpString2: LPCWSTR,
952     ) -> LPWSTR;
lstrlenA( lpString: LPCSTR, ) -> c_int953     pub fn lstrlenA(
954         lpString: LPCSTR,
955     ) -> c_int;
lstrlenW( lpString: LPCWSTR, ) -> c_int956     pub fn lstrlenW(
957         lpString: LPCWSTR,
958     ) -> c_int;
OpenFile( lpFileName: LPCSTR, lpReOpenBuff: LPOFSTRUCT, uStyle: UINT, ) -> HFILE959     pub fn OpenFile(
960         lpFileName: LPCSTR,
961         lpReOpenBuff: LPOFSTRUCT,
962         uStyle: UINT,
963     ) -> HFILE;
_lopen( lpPathName: LPCSTR, iReadWrite: c_int, ) -> HFILE964     pub fn _lopen(
965         lpPathName: LPCSTR,
966         iReadWrite: c_int,
967     ) -> HFILE;
_lcreat( lpPathName: LPCSTR, iAttrubute: c_int, ) -> HFILE968     pub fn _lcreat(
969         lpPathName: LPCSTR,
970         iAttrubute: c_int,
971     ) -> HFILE;
_lread( hFile: HFILE, lpBuffer: LPVOID, uBytes: UINT, ) -> UINT972     pub fn _lread(
973         hFile: HFILE,
974         lpBuffer: LPVOID,
975         uBytes: UINT,
976     ) -> UINT;
_lwrite( hFile: HFILE, lpBuffer: LPCCH, uBytes: UINT, ) -> UINT977     pub fn _lwrite(
978         hFile: HFILE,
979         lpBuffer: LPCCH,
980         uBytes: UINT,
981     ) -> UINT;
_hread( hFile: HFILE, lpBuffer: LPVOID, lBytes: c_long, ) -> c_long982     pub fn _hread(
983         hFile: HFILE,
984         lpBuffer: LPVOID,
985         lBytes: c_long,
986     ) -> c_long;
_hwrite( hFile: HFILE, lpBuffer: LPCCH, lBytes: c_long, ) -> c_long987     pub fn _hwrite(
988         hFile: HFILE,
989         lpBuffer: LPCCH,
990         lBytes: c_long,
991     ) -> c_long;
_lclose( hFile: HFILE, ) -> HFILE992     pub fn _lclose(
993         hFile: HFILE,
994     ) -> HFILE;
_llseek( hFile: HFILE, lOffset: LONG, iOrigin: c_int, ) -> LONG995     pub fn _llseek(
996         hFile: HFILE,
997         lOffset: LONG,
998         iOrigin: c_int,
999     ) -> LONG;
1000     // pub fn IsTextUnicode();
1001     // pub fn SignalObjectAndWait();
BackupRead( hFile: HANDLE, lpBuffer: LPBYTE, nNumberOfBytesToRead: DWORD, lpNumberOfBytesRead: LPDWORD, bAbort: BOOL, bProcessSecurity: BOOL, lpContext: *mut LPVOID, ) -> BOOL1002     pub fn BackupRead(
1003         hFile: HANDLE,
1004         lpBuffer: LPBYTE,
1005         nNumberOfBytesToRead: DWORD,
1006         lpNumberOfBytesRead: LPDWORD,
1007         bAbort: BOOL,
1008         bProcessSecurity: BOOL,
1009         lpContext: *mut LPVOID,
1010     ) -> BOOL;
BackupSeek( hFile: HANDLE, dwLowBytesToSeek: DWORD, dwHighBytesToSeek: DWORD, lpdwLowByteSeeked: LPDWORD, lpdwHighByteSeeked: LPDWORD, lpContext: *mut LPVOID, ) -> BOOL1011     pub fn BackupSeek(
1012         hFile: HANDLE,
1013         dwLowBytesToSeek: DWORD,
1014         dwHighBytesToSeek: DWORD,
1015         lpdwLowByteSeeked: LPDWORD,
1016         lpdwHighByteSeeked: LPDWORD,
1017         lpContext: *mut LPVOID,
1018     ) -> BOOL;
BackupWrite( hFile: HANDLE, lpBuffer: LPBYTE, nNumberOfBytesToWrite: DWORD, lpNumberOfBytesWritten: LPDWORD, bAbort: BOOL, bProcessSecurity: BOOL, lpContext: *mut LPVOID, ) -> BOOL1019     pub fn BackupWrite(
1020         hFile: HANDLE,
1021         lpBuffer: LPBYTE,
1022         nNumberOfBytesToWrite: DWORD,
1023         lpNumberOfBytesWritten: LPDWORD,
1024         bAbort: BOOL,
1025         bProcessSecurity: BOOL,
1026         lpContext: *mut LPVOID,
1027     ) -> BOOL;
1028 }
1029 //2886
1030 pub const STARTF_USESHOWWINDOW: DWORD = 0x00000001;
1031 pub const STARTF_USESIZE: DWORD = 0x00000002;
1032 pub const STARTF_USEPOSITION: DWORD = 0x00000004;
1033 pub const STARTF_USECOUNTCHARS: DWORD = 0x00000008;
1034 pub const STARTF_USEFILLATTRIBUTE: DWORD = 0x00000010;
1035 pub const STARTF_RUNFULLSCREEN: DWORD = 0x00000020;
1036 pub const STARTF_FORCEONFEEDBACK: DWORD = 0x00000040;
1037 pub const STARTF_FORCEOFFFEEDBACK: DWORD = 0x00000080;
1038 pub const STARTF_USESTDHANDLES: DWORD = 0x00000100;
1039 pub const STARTF_USEHOTKEY: DWORD = 0x00000200;
1040 pub const STARTF_TITLEISLINKNAME: DWORD = 0x00000800;
1041 pub const STARTF_TITLEISAPPID: DWORD = 0x00001000;
1042 pub const STARTF_PREVENTPINNING: DWORD = 0x00002000;
1043 pub const STARTF_UNTRUSTEDSOURCE: DWORD = 0x00008000;
1044 STRUCT!{struct STARTUPINFOEXA {
1045     StartupInfo: STARTUPINFOA,
1046     lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST,
1047 }}
1048 pub type LPSTARTUPINFOEXA = *mut STARTUPINFOEXA;
1049 STRUCT!{struct STARTUPINFOEXW {
1050     StartupInfo: STARTUPINFOW,
1051     lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST,
1052 }}
1053 pub type LPSTARTUPINFOEXW = *mut STARTUPINFOEXW;
1054 extern "system" {
OpenMutexA( dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR, ) -> HANDLE1055     pub fn OpenMutexA(
1056         dwDesiredAccess: DWORD,
1057         bInheritHandle: BOOL,
1058         lpName: LPCSTR,
1059     ) -> HANDLE;
CreateSemaphoreA( lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCSTR, ) -> HANDLE1060     pub fn CreateSemaphoreA(
1061         lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES,
1062         lInitialCount: LONG,
1063         lMaximumCount: LONG,
1064         lpName: LPCSTR,
1065     ) -> HANDLE;
OpenSemaphoreA( dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR, ) -> HANDLE1066     pub fn OpenSemaphoreA(
1067         dwDesiredAccess: DWORD,
1068         bInheritHandle: BOOL,
1069         lpName: LPCSTR,
1070     ) -> HANDLE;
CreateWaitableTimerA( lpTimerAttributes: LPSECURITY_ATTRIBUTES, bManualReset: BOOL, lpTimerName: LPCSTR, ) -> HANDLE1071     pub fn CreateWaitableTimerA(
1072         lpTimerAttributes: LPSECURITY_ATTRIBUTES,
1073         bManualReset: BOOL,
1074         lpTimerName: LPCSTR,
1075     ) -> HANDLE;
OpenWaitableTimerA( dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpTimerName: LPCSTR, ) -> HANDLE1076     pub fn OpenWaitableTimerA(
1077         dwDesiredAccess: DWORD,
1078         bInheritHandle: BOOL,
1079         lpTimerName: LPCSTR,
1080     ) -> HANDLE;
CreateSemaphoreExA( lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCSTR, dwFlags: DWORD, dwDesiredAccess: DWORD, ) -> HANDLE1081     pub fn CreateSemaphoreExA(
1082         lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES,
1083         lInitialCount: LONG,
1084         lMaximumCount: LONG,
1085         lpName: LPCSTR,
1086         dwFlags: DWORD,
1087         dwDesiredAccess: DWORD,
1088     ) -> HANDLE;
CreateWaitableTimerExA( lpTimerAttributes: LPSECURITY_ATTRIBUTES, lpTimerName: LPCSTR, dwFlags: DWORD, dwDesiredAccess: DWORD, ) -> HANDLE1089     pub fn CreateWaitableTimerExA(
1090         lpTimerAttributes: LPSECURITY_ATTRIBUTES,
1091         lpTimerName: LPCSTR,
1092         dwFlags: DWORD,
1093         dwDesiredAccess: DWORD,
1094     ) -> HANDLE;
CreateFileMappingA( hFile: HANDLE, lpAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCSTR, ) -> HANDLE1095     pub fn CreateFileMappingA(
1096         hFile: HANDLE,
1097         lpAttributes: LPSECURITY_ATTRIBUTES,
1098         flProtect: DWORD,
1099         dwMaximumSizeHigh: DWORD,
1100         dwMaximumSizeLow: DWORD,
1101         lpName: LPCSTR,
1102     ) -> HANDLE;
CreateFileMappingNumaA( hFile: HANDLE, lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCSTR, nndPreferred: DWORD, ) -> HANDLE1103     pub fn CreateFileMappingNumaA(
1104         hFile: HANDLE,
1105         lpFileMappingAttributes: LPSECURITY_ATTRIBUTES,
1106         flProtect: DWORD,
1107         dwMaximumSizeHigh: DWORD,
1108         dwMaximumSizeLow: DWORD,
1109         lpName: LPCSTR,
1110         nndPreferred: DWORD,
1111     ) -> HANDLE;
OpenFileMappingA( dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR, ) -> HANDLE1112     pub fn OpenFileMappingA(
1113         dwDesiredAccess: DWORD,
1114         bInheritHandle: BOOL,
1115         lpName: LPCSTR,
1116     ) -> HANDLE;
GetLogicalDriveStringsA( nBufferLength: DWORD, lpBuffer: LPSTR, ) -> DWORD1117     pub fn GetLogicalDriveStringsA(
1118         nBufferLength: DWORD,
1119         lpBuffer: LPSTR,
1120     ) -> DWORD;
LoadPackagedLibrary( lpwLibFileName: LPCWSTR, Reserved: DWORD, ) -> HMODULE1121     pub fn LoadPackagedLibrary(
1122         lpwLibFileName: LPCWSTR,
1123         Reserved: DWORD,
1124     ) -> HMODULE;
QueryFullProcessImageNameA( hProcess: HANDLE, dwFlags: DWORD, lpExeName: LPSTR, lpdwSize: PDWORD, ) -> BOOL1125     pub fn QueryFullProcessImageNameA(
1126         hProcess: HANDLE,
1127         dwFlags: DWORD,
1128         lpExeName: LPSTR,
1129         lpdwSize: PDWORD,
1130     ) -> BOOL;
QueryFullProcessImageNameW( hProcess: HANDLE, dwFlags: DWORD, lpExeName: LPWSTR, lpdwSize: PDWORD, ) -> BOOL1131     pub fn QueryFullProcessImageNameW(
1132         hProcess: HANDLE,
1133         dwFlags: DWORD,
1134         lpExeName: LPWSTR,
1135         lpdwSize: PDWORD,
1136     ) -> BOOL;
1137 }
1138 //3233
1139 extern "system" {
GetStartupInfoA( lpStartupInfo: LPSTARTUPINFOA, )1140     pub fn GetStartupInfoA(
1141         lpStartupInfo: LPSTARTUPINFOA,
1142     );
GetFirmwareEnvironmentVariableA( lpName: LPCSTR, lpGuid: LPCSTR, pBuffer: PVOID, nSize: DWORD, ) -> DWORD1143     pub fn GetFirmwareEnvironmentVariableA(
1144         lpName: LPCSTR,
1145         lpGuid: LPCSTR,
1146         pBuffer: PVOID,
1147         nSize: DWORD,
1148     ) -> DWORD;
GetFirmwareEnvironmentVariableW( lpName: LPCWSTR, lpGuid: LPCWSTR, pBuffer: PVOID, nSize: DWORD, ) -> DWORD1149     pub fn GetFirmwareEnvironmentVariableW(
1150         lpName: LPCWSTR,
1151         lpGuid: LPCWSTR,
1152         pBuffer: PVOID,
1153         nSize: DWORD,
1154     ) -> DWORD;
GetFirmwareEnvironmentVariableExA( lpName: LPCSTR, lpGuid: LPCSTR, pBuffer: PVOID, nSize: DWORD, pdwAttribubutes: PDWORD, ) -> DWORD1155     pub fn GetFirmwareEnvironmentVariableExA(
1156         lpName: LPCSTR,
1157         lpGuid: LPCSTR,
1158         pBuffer: PVOID,
1159         nSize: DWORD,
1160         pdwAttribubutes: PDWORD,
1161     ) -> DWORD;
GetFirmwareEnvironmentVariableExW( lpName: LPCWSTR, lpGuid: LPCWSTR, pBuffer: PVOID, nSize: DWORD, pdwAttribubutes: PDWORD, ) -> DWORD1162     pub fn GetFirmwareEnvironmentVariableExW(
1163         lpName: LPCWSTR,
1164         lpGuid: LPCWSTR,
1165         pBuffer: PVOID,
1166         nSize: DWORD,
1167         pdwAttribubutes: PDWORD,
1168     ) -> DWORD;
SetFirmwareEnvironmentVariableA( lpName: LPCSTR, lpGuid: LPCSTR, pValue: PVOID, nSize: DWORD, ) -> BOOL1169     pub fn SetFirmwareEnvironmentVariableA(
1170         lpName: LPCSTR,
1171         lpGuid: LPCSTR,
1172         pValue: PVOID,
1173         nSize: DWORD,
1174     ) -> BOOL;
SetFirmwareEnvironmentVariableW( lpName: LPCWSTR, lpGuid: LPCWSTR, pValue: PVOID, nSize: DWORD, ) -> BOOL1175     pub fn SetFirmwareEnvironmentVariableW(
1176         lpName: LPCWSTR,
1177         lpGuid: LPCWSTR,
1178         pValue: PVOID,
1179         nSize: DWORD,
1180     ) -> BOOL;
SetFirmwareEnvironmentVariableExA( lpName: LPCSTR, lpGuid: LPCSTR, pValue: PVOID, nSize: DWORD, dwAttributes: DWORD, ) -> BOOL1181     pub fn SetFirmwareEnvironmentVariableExA(
1182         lpName: LPCSTR,
1183         lpGuid: LPCSTR,
1184         pValue: PVOID,
1185         nSize: DWORD,
1186         dwAttributes: DWORD,
1187     ) -> BOOL;
SetFirmwareEnvironmentVariableExW( lpName: LPCWSTR, lpGuid: LPCWSTR, pValue: PVOID, nSize: DWORD, dwAttributes: DWORD, ) -> BOOL1188     pub fn SetFirmwareEnvironmentVariableExW(
1189         lpName: LPCWSTR,
1190         lpGuid: LPCWSTR,
1191         pValue: PVOID,
1192         nSize: DWORD,
1193         dwAttributes: DWORD,
1194     ) -> BOOL;
GetFirmwareType( FirmwareType: PFIRMWARE_TYPE, ) -> BOOL1195     pub fn GetFirmwareType(
1196         FirmwareType: PFIRMWARE_TYPE,
1197     ) -> BOOL;
IsNativeVhdBoot( NativeVhdBoot: PBOOL, ) -> BOOL1198     pub fn IsNativeVhdBoot(
1199         NativeVhdBoot: PBOOL,
1200     ) -> BOOL;
FindResourceA( hModule: HMODULE, lpName: LPCSTR, lpType: LPCSTR, ) -> HRSRC1201     pub fn FindResourceA(
1202         hModule: HMODULE,
1203         lpName: LPCSTR,
1204         lpType: LPCSTR,
1205     ) -> HRSRC;
FindResourceExA( hModule: HMODULE, lpName: LPCSTR, lpType: LPCSTR, wLanguage: WORD, ) -> HRSRC1206     pub fn FindResourceExA(
1207         hModule: HMODULE,
1208         lpName: LPCSTR,
1209         lpType: LPCSTR,
1210         wLanguage: WORD,
1211     ) -> HRSRC;
EnumResourceTypesA( hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCA, lParam: LONG_PTR, ) -> BOOL1212     pub fn EnumResourceTypesA(
1213         hModule: HMODULE,
1214         lpEnumFunc: ENUMRESTYPEPROCA,
1215         lParam: LONG_PTR,
1216     ) -> BOOL;
EnumResourceTypesW( hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCW, lParam: LONG_PTR, ) -> BOOL1217     pub fn EnumResourceTypesW(
1218         hModule: HMODULE,
1219         lpEnumFunc: ENUMRESTYPEPROCW,
1220         lParam: LONG_PTR,
1221     ) -> BOOL;
EnumResourceNamesA( hModule: HMODULE, lpType: LPCSTR, lpEnumFunc: ENUMRESNAMEPROCA, lParam: LONG_PTR, ) -> BOOL1222     pub fn EnumResourceNamesA(
1223         hModule: HMODULE,
1224         lpType: LPCSTR,
1225         lpEnumFunc: ENUMRESNAMEPROCA,
1226         lParam: LONG_PTR,
1227     ) -> BOOL;
EnumResourceLanguagesA( hModule: HMODULE, lpType: LPCSTR, lpName: LPCSTR, lpEnumFunc: ENUMRESLANGPROCA, lParam: LONG_PTR, ) -> BOOL1228     pub fn EnumResourceLanguagesA(
1229         hModule: HMODULE,
1230         lpType: LPCSTR,
1231         lpName: LPCSTR,
1232         lpEnumFunc: ENUMRESLANGPROCA,
1233         lParam: LONG_PTR,
1234     ) -> BOOL;
EnumResourceLanguagesW( hModule: HMODULE, lpType: LPCWSTR, lpName: LPCWSTR, lpEnumFunc: ENUMRESLANGPROCW, lParam: LONG_PTR, ) -> BOOL1235     pub fn EnumResourceLanguagesW(
1236         hModule: HMODULE,
1237         lpType: LPCWSTR,
1238         lpName: LPCWSTR,
1239         lpEnumFunc: ENUMRESLANGPROCW,
1240         lParam: LONG_PTR,
1241     ) -> BOOL;
BeginUpdateResourceA( pFileName: LPCSTR, bDeleteExistingResources: BOOL, ) -> HANDLE1242     pub fn BeginUpdateResourceA(
1243         pFileName: LPCSTR,
1244         bDeleteExistingResources: BOOL,
1245     ) -> HANDLE;
BeginUpdateResourceW( pFileName: LPCWSTR, bDeleteExistingResources: BOOL, ) -> HANDLE1246     pub fn BeginUpdateResourceW(
1247         pFileName: LPCWSTR,
1248         bDeleteExistingResources: BOOL,
1249     ) -> HANDLE;
UpdateResourceA( hUpdate: HANDLE, lpType: LPCSTR, lpName: LPCSTR, wLanguage: WORD, lpData: LPVOID, cb: DWORD, ) -> BOOL1250     pub fn UpdateResourceA(
1251         hUpdate: HANDLE,
1252         lpType: LPCSTR,
1253         lpName: LPCSTR,
1254         wLanguage: WORD,
1255         lpData: LPVOID,
1256         cb: DWORD,
1257     ) -> BOOL;
UpdateResourceW( hUpdate: HANDLE, lpType: LPCWSTR, lpName: LPCWSTR, wLanguage: WORD, lpData: LPVOID, cb: DWORD, ) -> BOOL1258     pub fn UpdateResourceW(
1259         hUpdate: HANDLE,
1260         lpType: LPCWSTR,
1261         lpName: LPCWSTR,
1262         wLanguage: WORD,
1263         lpData: LPVOID,
1264         cb: DWORD,
1265     ) -> BOOL;
EndUpdateResourceA( hUpdate: HANDLE, fDiscard: BOOL, ) -> BOOL1266     pub fn EndUpdateResourceA(
1267         hUpdate: HANDLE,
1268         fDiscard: BOOL,
1269     ) -> BOOL;
EndUpdateResourceW( hUpdate: HANDLE, fDiscard: BOOL, ) -> BOOL1270     pub fn EndUpdateResourceW(
1271         hUpdate: HANDLE,
1272         fDiscard: BOOL,
1273     ) -> BOOL;
GlobalAddAtomA( lpString: LPCSTR, ) -> ATOM1274     pub fn GlobalAddAtomA(
1275         lpString: LPCSTR,
1276     ) -> ATOM;
GlobalAddAtomW( lpString: LPCWSTR, ) -> ATOM1277     pub fn GlobalAddAtomW(
1278         lpString: LPCWSTR,
1279     ) -> ATOM;
GlobalAddAtomExA( lpString: LPCSTR, Flags: DWORD, ) -> ATOM1280     pub fn GlobalAddAtomExA(
1281         lpString: LPCSTR,
1282         Flags: DWORD,
1283     ) -> ATOM;
GlobalAddAtomExW( lpString: LPCWSTR, Flags: DWORD, ) -> ATOM1284     pub fn GlobalAddAtomExW(
1285         lpString: LPCWSTR,
1286         Flags: DWORD,
1287     ) -> ATOM;
GlobalFindAtomA( lpString: LPCSTR, ) -> ATOM1288     pub fn GlobalFindAtomA(
1289         lpString: LPCSTR,
1290     ) -> ATOM;
GlobalFindAtomW( lpString: LPCWSTR, ) -> ATOM1291     pub fn GlobalFindAtomW(
1292         lpString: LPCWSTR,
1293     ) -> ATOM;
GlobalGetAtomNameA( nAtom: ATOM, lpBuffer: LPSTR, nSize: c_int, ) -> UINT1294     pub fn GlobalGetAtomNameA(
1295         nAtom: ATOM,
1296         lpBuffer: LPSTR,
1297         nSize: c_int,
1298     ) -> UINT;
GlobalGetAtomNameW( nAtom: ATOM, lpBuffer: LPWSTR, nSize: c_int, ) -> UINT1299     pub fn GlobalGetAtomNameW(
1300         nAtom: ATOM,
1301         lpBuffer: LPWSTR,
1302         nSize: c_int,
1303     ) -> UINT;
AddAtomA( lpString: LPCSTR, ) -> ATOM1304     pub fn AddAtomA(
1305         lpString: LPCSTR,
1306     ) -> ATOM;
AddAtomW( lpString: LPCWSTR, ) -> ATOM1307     pub fn AddAtomW(
1308         lpString: LPCWSTR,
1309     ) -> ATOM;
FindAtomA( lpString: LPCSTR, ) -> ATOM1310     pub fn FindAtomA(
1311         lpString: LPCSTR,
1312     ) -> ATOM;
FindAtomW( lpString: LPCWSTR, ) -> ATOM1313     pub fn FindAtomW(
1314         lpString: LPCWSTR,
1315     ) -> ATOM;
GetAtomNameA( nAtom: ATOM, lpBuffer: LPSTR, nSize: c_int, ) -> UINT1316     pub fn GetAtomNameA(
1317         nAtom: ATOM,
1318         lpBuffer: LPSTR,
1319         nSize: c_int,
1320     ) -> UINT;
GetAtomNameW( nAtom: ATOM, lpBuffer: LPWSTR, nSize: c_int, ) -> UINT1321     pub fn GetAtomNameW(
1322         nAtom: ATOM,
1323         lpBuffer: LPWSTR,
1324         nSize: c_int,
1325     ) -> UINT;
GetProfileIntA( lpAppName: LPCSTR, lpKeyName: LPCSTR, nDefault: INT, ) -> UINT1326     pub fn GetProfileIntA(
1327         lpAppName: LPCSTR,
1328         lpKeyName: LPCSTR,
1329         nDefault: INT,
1330     ) -> UINT;
GetProfileIntW( lpAppName: LPCWSTR, lpKeyName: LPCWSTR, nDefault: INT, ) -> UINT1331     pub fn GetProfileIntW(
1332         lpAppName: LPCWSTR,
1333         lpKeyName: LPCWSTR,
1334         nDefault: INT,
1335     ) -> UINT;
GetProfileStringA( lpAppName: LPCSTR, lpKeyName: LPCSTR, lpDefault: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD, ) -> DWORD1336     pub fn GetProfileStringA(
1337         lpAppName: LPCSTR,
1338         lpKeyName: LPCSTR,
1339         lpDefault: LPCSTR,
1340         lpReturnedString: LPSTR,
1341         nSize: DWORD,
1342     ) -> DWORD;
GetProfileStringW( lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpDefault: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD, ) -> DWORD1343     pub fn GetProfileStringW(
1344         lpAppName: LPCWSTR,
1345         lpKeyName: LPCWSTR,
1346         lpDefault: LPCWSTR,
1347         lpReturnedString: LPWSTR,
1348         nSize: DWORD,
1349     ) -> DWORD;
WriteProfileStringA( lpAppName: LPCSTR, lpKeyName: LPCSTR, lpString: LPCSTR, ) -> BOOL1350     pub fn WriteProfileStringA(
1351         lpAppName: LPCSTR,
1352         lpKeyName: LPCSTR,
1353         lpString: LPCSTR,
1354     ) -> BOOL;
WriteProfileStringW( lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpString: LPCWSTR, ) -> BOOL1355     pub fn WriteProfileStringW(
1356         lpAppName: LPCWSTR,
1357         lpKeyName: LPCWSTR,
1358         lpString: LPCWSTR,
1359     ) -> BOOL;
GetProfileSectionA( lpAppName: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD, ) -> DWORD1360     pub fn GetProfileSectionA(
1361         lpAppName: LPCSTR,
1362         lpReturnedString: LPSTR,
1363         nSize: DWORD,
1364     ) -> DWORD;
GetProfileSectionW( lpAppName: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD, ) -> DWORD1365     pub fn GetProfileSectionW(
1366         lpAppName: LPCWSTR,
1367         lpReturnedString: LPWSTR,
1368         nSize: DWORD,
1369     ) -> DWORD;
WriteProfileSectionA( lpAppName: LPCSTR, lpString: LPCSTR, ) -> BOOL1370     pub fn WriteProfileSectionA(
1371         lpAppName: LPCSTR,
1372         lpString: LPCSTR,
1373     ) -> BOOL;
WriteProfileSectionW( lpAppName: LPCWSTR, lpString: LPCWSTR, ) -> BOOL1374     pub fn WriteProfileSectionW(
1375         lpAppName: LPCWSTR,
1376         lpString: LPCWSTR,
1377     ) -> BOOL;
GetPrivateProfileIntA( lpAppName: LPCSTR, lpKeyName: LPCSTR, nDefault: INT, lpFileName: LPCSTR, ) -> UINT1378     pub fn GetPrivateProfileIntA(
1379         lpAppName: LPCSTR,
1380         lpKeyName: LPCSTR,
1381         nDefault: INT,
1382         lpFileName: LPCSTR,
1383     ) -> UINT;
GetPrivateProfileIntW( lpAppName: LPCWSTR, lpKeyName: LPCWSTR, nDefault: INT, lpFileName: LPCWSTR, ) -> UINT1384     pub fn GetPrivateProfileIntW(
1385         lpAppName: LPCWSTR,
1386         lpKeyName: LPCWSTR,
1387         nDefault: INT,
1388         lpFileName: LPCWSTR,
1389     ) -> UINT;
GetPrivateProfileStringA( lpAppName: LPCSTR, lpKeyName: LPCSTR, lpDefault: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD, lpFileName: LPCSTR, ) -> DWORD1390     pub fn GetPrivateProfileStringA(
1391         lpAppName: LPCSTR,
1392         lpKeyName: LPCSTR,
1393         lpDefault: LPCSTR,
1394         lpReturnedString: LPSTR,
1395         nSize: DWORD,
1396         lpFileName: LPCSTR,
1397     ) -> DWORD;
GetPrivateProfileStringW( lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpDefault: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD, lpFileName: LPCWSTR, ) -> DWORD1398     pub fn GetPrivateProfileStringW(
1399         lpAppName: LPCWSTR,
1400         lpKeyName: LPCWSTR,
1401         lpDefault: LPCWSTR,
1402         lpReturnedString: LPWSTR,
1403         nSize: DWORD,
1404         lpFileName: LPCWSTR,
1405     ) -> DWORD;
WritePrivateProfileStringA( lpAppName: LPCSTR, lpKeyName: LPCSTR, lpString: LPCSTR, lpFileName: LPCSTR, ) -> BOOL1406     pub fn WritePrivateProfileStringA(
1407         lpAppName: LPCSTR,
1408         lpKeyName: LPCSTR,
1409         lpString: LPCSTR,
1410         lpFileName: LPCSTR,
1411     ) -> BOOL;
WritePrivateProfileStringW( lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpString: LPCWSTR, lpFileName: LPCWSTR, ) -> BOOL1412     pub fn WritePrivateProfileStringW(
1413         lpAppName: LPCWSTR,
1414         lpKeyName: LPCWSTR,
1415         lpString: LPCWSTR,
1416         lpFileName: LPCWSTR,
1417     ) -> BOOL;
GetPrivateProfileSectionA( lpAppName: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD, lpFileName: LPCSTR, ) -> DWORD1418     pub fn GetPrivateProfileSectionA(
1419         lpAppName: LPCSTR,
1420         lpReturnedString: LPSTR,
1421         nSize: DWORD,
1422         lpFileName: LPCSTR,
1423     ) -> DWORD;
GetPrivateProfileSectionW( lpAppName: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD, lpFileName: LPCWSTR, ) -> DWORD1424     pub fn GetPrivateProfileSectionW(
1425         lpAppName: LPCWSTR,
1426         lpReturnedString: LPWSTR,
1427         nSize: DWORD,
1428         lpFileName: LPCWSTR,
1429     ) -> DWORD;
WritePrivateProfileSectionA( lpAppName: LPCSTR, lpString: LPCSTR, lpFileName: LPCSTR, ) -> BOOL1430     pub fn WritePrivateProfileSectionA(
1431         lpAppName: LPCSTR,
1432         lpString: LPCSTR,
1433         lpFileName: LPCSTR,
1434     ) -> BOOL;
WritePrivateProfileSectionW( lpAppName: LPCWSTR, lpString: LPCWSTR, lpFileName: LPCWSTR, ) -> BOOL1435     pub fn WritePrivateProfileSectionW(
1436         lpAppName: LPCWSTR,
1437         lpString: LPCWSTR,
1438         lpFileName: LPCWSTR,
1439     ) -> BOOL;
GetPrivateProfileSectionNamesA( lpszReturnBuffer: LPSTR, nSize: DWORD, lpFileName: LPCSTR, ) -> DWORD1440     pub fn GetPrivateProfileSectionNamesA(
1441         lpszReturnBuffer: LPSTR,
1442         nSize: DWORD,
1443         lpFileName: LPCSTR,
1444     ) -> DWORD;
GetPrivateProfileSectionNamesW( lpszReturnBuffer: LPWSTR, nSize: DWORD, lpFileName: LPCWSTR, ) -> DWORD1445     pub fn GetPrivateProfileSectionNamesW(
1446         lpszReturnBuffer: LPWSTR,
1447         nSize: DWORD,
1448         lpFileName: LPCWSTR,
1449     ) -> DWORD;
GetPrivateProfileStructA( lpszSection: LPCSTR, lpszKey: LPCSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCSTR, ) -> BOOL1450     pub fn GetPrivateProfileStructA(
1451         lpszSection: LPCSTR,
1452         lpszKey: LPCSTR,
1453         lpStruct: LPVOID,
1454         uSizeStruct: UINT,
1455         szFile: LPCSTR,
1456     ) -> BOOL;
GetPrivateProfileStructW( lpszSection: LPCWSTR, lpszKey: LPCWSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCWSTR, ) -> BOOL1457     pub fn GetPrivateProfileStructW(
1458         lpszSection: LPCWSTR,
1459         lpszKey: LPCWSTR,
1460         lpStruct: LPVOID,
1461         uSizeStruct: UINT,
1462         szFile: LPCWSTR,
1463     ) -> BOOL;
WritePrivateProfileStructA( lpszSection: LPCSTR, lpszKey: LPCSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCSTR, ) -> BOOL1464     pub fn WritePrivateProfileStructA(
1465         lpszSection: LPCSTR,
1466         lpszKey: LPCSTR,
1467         lpStruct: LPVOID,
1468         uSizeStruct: UINT,
1469         szFile: LPCSTR,
1470     ) -> BOOL;
WritePrivateProfileStructW( lpszSection: LPCWSTR, lpszKey: LPCWSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCWSTR, ) -> BOOL1471     pub fn WritePrivateProfileStructW(
1472         lpszSection: LPCWSTR,
1473         lpszKey: LPCWSTR,
1474         lpStruct: LPVOID,
1475         uSizeStruct: UINT,
1476         szFile: LPCWSTR,
1477     ) -> BOOL;
Wow64EnableWow64FsRedirection( Wow64FsEnableRedirection: BOOLEAN, ) -> BOOLEAN1478     pub fn Wow64EnableWow64FsRedirection(
1479         Wow64FsEnableRedirection: BOOLEAN,
1480     ) -> BOOLEAN;
SetDllDirectoryA( lpPathName: LPCSTR, ) -> BOOL1481     pub fn SetDllDirectoryA(
1482         lpPathName: LPCSTR,
1483     ) -> BOOL;
SetDllDirectoryW( lpPathName: LPCWSTR, ) -> BOOL1484     pub fn SetDllDirectoryW(
1485         lpPathName: LPCWSTR,
1486     ) -> BOOL;
GetDllDirectoryA( nBufferLength: DWORD, lpBuffer: LPSTR, ) -> DWORD1487     pub fn GetDllDirectoryA(
1488         nBufferLength: DWORD,
1489         lpBuffer: LPSTR,
1490     ) -> DWORD;
GetDllDirectoryW( nBufferLength: DWORD, lpBuffer: LPWSTR, ) -> DWORD1491     pub fn GetDllDirectoryW(
1492         nBufferLength: DWORD,
1493         lpBuffer: LPWSTR,
1494     ) -> DWORD;
SetSearchPathMode( Flags: DWORD, ) -> BOOL1495     pub fn SetSearchPathMode(
1496         Flags: DWORD,
1497     ) -> BOOL;
CreateDirectoryExA( lpTemplateDirectory: LPCSTR, lpNewDirectory: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> BOOL1498     pub fn CreateDirectoryExA(
1499         lpTemplateDirectory: LPCSTR,
1500         lpNewDirectory: LPCSTR,
1501         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
1502     ) -> BOOL;
CreateDirectoryExW( lpTemplateDirectory: LPCWSTR, lpNewDirectory: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> BOOL1503     pub fn CreateDirectoryExW(
1504         lpTemplateDirectory: LPCWSTR,
1505         lpNewDirectory: LPCWSTR,
1506         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
1507     ) -> BOOL;
CreateDirectoryTransactedA( lpTemplateDirectory: LPCSTR, lpNewDirectory: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE, ) -> BOOL1508     pub fn CreateDirectoryTransactedA(
1509         lpTemplateDirectory: LPCSTR,
1510         lpNewDirectory: LPCSTR,
1511         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
1512         hTransaction: HANDLE,
1513     ) -> BOOL;
CreateDirectoryTransactedW( lpTemplateDirectory: LPCWSTR, lpNewDirectory: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE, ) -> BOOL1514     pub fn CreateDirectoryTransactedW(
1515         lpTemplateDirectory: LPCWSTR,
1516         lpNewDirectory: LPCWSTR,
1517         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
1518         hTransaction: HANDLE,
1519     ) -> BOOL;
RemoveDirectoryTransactedA( lpPathName: LPCSTR, hTransaction: HANDLE, ) -> BOOL1520     pub fn RemoveDirectoryTransactedA(
1521         lpPathName: LPCSTR,
1522         hTransaction: HANDLE,
1523     ) -> BOOL;
RemoveDirectoryTransactedW( lpPathName: LPCWSTR, hTransaction: HANDLE, ) -> BOOL1524     pub fn RemoveDirectoryTransactedW(
1525         lpPathName: LPCWSTR,
1526         hTransaction: HANDLE,
1527     ) -> BOOL;
GetFullPathNameTransactedA( lpFileName: LPCSTR, nBufferLength: DWORD, lpBuffer: LPSTR, lpFilePart: *mut LPSTR, hTransaction: HANDLE, ) -> DWORD1528     pub fn GetFullPathNameTransactedA(
1529         lpFileName: LPCSTR,
1530         nBufferLength: DWORD,
1531         lpBuffer: LPSTR,
1532         lpFilePart: *mut LPSTR,
1533         hTransaction: HANDLE,
1534     ) -> DWORD;
GetFullPathNameTransactedW( lpFileName: LPCWSTR, nBufferLength: DWORD, lpBuffer: LPWSTR, lpFilePart: *mut LPWSTR, hTransaction: HANDLE, )1535     pub fn GetFullPathNameTransactedW(
1536         lpFileName: LPCWSTR,
1537         nBufferLength: DWORD,
1538         lpBuffer: LPWSTR,
1539         lpFilePart: *mut LPWSTR,
1540         hTransaction: HANDLE,
1541     );
DefineDosDeviceA( dwFlags: DWORD, lpDeviceName: LPCSTR, lpTargetPath: LPCSTR, ) -> BOOL1542     pub fn DefineDosDeviceA(
1543         dwFlags: DWORD,
1544         lpDeviceName: LPCSTR,
1545         lpTargetPath: LPCSTR,
1546     ) -> BOOL;
QueryDosDeviceA( lpDeviceName: LPCSTR, lpTargetPath: LPSTR, ucchMax: DWORD, ) -> DWORD1547     pub fn QueryDosDeviceA(
1548         lpDeviceName: LPCSTR,
1549         lpTargetPath: LPSTR,
1550         ucchMax: DWORD,
1551     ) -> DWORD;
CreateFileTransactedA( lpFileName: LPCSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE, hTransaction: HANDLE, pusMiniVersion: PUSHORT, lpExtendedParameter: PVOID, ) -> HANDLE1552     pub fn CreateFileTransactedA(
1553         lpFileName: LPCSTR,
1554         dwDesiredAccess: DWORD,
1555         dwShareMode: DWORD,
1556         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
1557         dwCreationDisposition: DWORD,
1558         dwFlagsAndAttributes: DWORD,
1559         hTemplateFile: HANDLE,
1560         hTransaction: HANDLE,
1561         pusMiniVersion: PUSHORT,
1562         lpExtendedParameter: PVOID,
1563     ) -> HANDLE;
CreateFileTransactedW( lpFileName: LPCWSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE, hTransaction: HANDLE, pusMiniVersion: PUSHORT, lpExtendedParameter: PVOID, ) -> HANDLE1564     pub fn CreateFileTransactedW(
1565         lpFileName: LPCWSTR,
1566         dwDesiredAccess: DWORD,
1567         dwShareMode: DWORD,
1568         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
1569         dwCreationDisposition: DWORD,
1570         dwFlagsAndAttributes: DWORD,
1571         hTemplateFile: HANDLE,
1572         hTransaction: HANDLE,
1573         pusMiniVersion: PUSHORT,
1574         lpExtendedParameter: PVOID,
1575     ) -> HANDLE;
ReOpenFile( hOriginalFile: HANDLE, dwDesiredAccess: DWORD, dwShareMode: DWORD, dwFlags: DWORD, ) -> HANDLE1576     pub fn ReOpenFile(
1577         hOriginalFile: HANDLE,
1578         dwDesiredAccess: DWORD,
1579         dwShareMode: DWORD,
1580         dwFlags: DWORD,
1581     ) -> HANDLE;
SetFileAttributesTransactedA( lpFileName: LPCSTR, dwFileAttributes: DWORD, hTransaction: HANDLE, ) -> BOOL1582     pub fn SetFileAttributesTransactedA(
1583         lpFileName: LPCSTR,
1584         dwFileAttributes: DWORD,
1585         hTransaction: HANDLE,
1586     ) -> BOOL;
SetFileAttributesTransactedW( lpFileName: LPCWSTR, dwFileAttributes: DWORD, hTransaction: HANDLE, ) -> BOOL1587     pub fn SetFileAttributesTransactedW(
1588         lpFileName: LPCWSTR,
1589         dwFileAttributes: DWORD,
1590         hTransaction: HANDLE,
1591     ) -> BOOL;
GetFileAttributesTransactedA( lpFileName: LPCSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID, hTransaction: HANDLE, ) -> BOOL1592     pub fn GetFileAttributesTransactedA(
1593         lpFileName: LPCSTR,
1594         fInfoLevelId: GET_FILEEX_INFO_LEVELS,
1595         lpFileInformation: LPVOID,
1596         hTransaction: HANDLE,
1597     ) -> BOOL;
GetFileAttributesTransactedW( lpFileName: LPCWSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID, hTransaction: HANDLE, ) -> BOOL1598     pub fn GetFileAttributesTransactedW(
1599         lpFileName: LPCWSTR,
1600         fInfoLevelId: GET_FILEEX_INFO_LEVELS,
1601         lpFileInformation: LPVOID,
1602         hTransaction: HANDLE,
1603     ) -> BOOL;
GetCompressedFileSizeTransactedA( lpFileName: LPCSTR, lpFileSizeHigh: LPDWORD, hTransaction: HANDLE, ) -> DWORD1604     pub fn GetCompressedFileSizeTransactedA(
1605         lpFileName: LPCSTR,
1606         lpFileSizeHigh: LPDWORD,
1607         hTransaction: HANDLE,
1608     ) -> DWORD;
GetCompressedFileSizeTransactedW( lpFileName: LPCWSTR, lpFileSizeHigh: LPDWORD, hTransaction: HANDLE, )1609     pub fn GetCompressedFileSizeTransactedW(
1610         lpFileName: LPCWSTR,
1611         lpFileSizeHigh: LPDWORD,
1612         hTransaction: HANDLE,
1613     );
DeleteFileTransactedA( lpFileName: LPCSTR, hTransaction: HANDLE, ) -> BOOL1614     pub fn DeleteFileTransactedA(
1615         lpFileName: LPCSTR,
1616         hTransaction: HANDLE,
1617     ) -> BOOL;
DeleteFileTransactedW( lpFileName: LPCWSTR, hTransaction: HANDLE, ) -> BOOL1618     pub fn DeleteFileTransactedW(
1619         lpFileName: LPCWSTR,
1620         hTransaction: HANDLE,
1621     ) -> BOOL;
CheckNameLegalDOS8Dot3A( lpName: LPCSTR, lpOemName: LPSTR, OemNameSize: DWORD, pbNameContainsSpaces: PBOOL, pbNameLegal: PBOOL, ) -> BOOL1622     pub fn CheckNameLegalDOS8Dot3A(
1623         lpName: LPCSTR,
1624         lpOemName: LPSTR,
1625         OemNameSize: DWORD,
1626         pbNameContainsSpaces: PBOOL,
1627         pbNameLegal: PBOOL,
1628     ) -> BOOL;
CheckNameLegalDOS8Dot3W( lpName: LPCWSTR, lpOemName: LPSTR, OemNameSize: DWORD, pbNameContainsSpaces: PBOOL, pbNameLegal: PBOOL, ) -> BOOL1629     pub fn CheckNameLegalDOS8Dot3W(
1630         lpName: LPCWSTR,
1631         lpOemName: LPSTR,
1632         OemNameSize: DWORD,
1633         pbNameContainsSpaces: PBOOL,
1634         pbNameLegal: PBOOL,
1635     ) -> BOOL;
FindFirstFileTransactedA( lpFileName: LPCSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID, fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD, hTransaction: HANDLE, ) -> HANDLE1636     pub fn FindFirstFileTransactedA(
1637         lpFileName: LPCSTR,
1638         fInfoLevelId: FINDEX_INFO_LEVELS,
1639         lpFindFileData: LPVOID,
1640         fSearchOp: FINDEX_SEARCH_OPS,
1641         lpSearchFilter: LPVOID,
1642         dwAdditionalFlags: DWORD,
1643         hTransaction: HANDLE,
1644     ) -> HANDLE;
FindFirstFileTransactedW( lpFileName: LPCWSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID, fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD, hTransaction: HANDLE, ) -> HANDLE1645     pub fn FindFirstFileTransactedW(
1646         lpFileName: LPCWSTR,
1647         fInfoLevelId: FINDEX_INFO_LEVELS,
1648         lpFindFileData: LPVOID,
1649         fSearchOp: FINDEX_SEARCH_OPS,
1650         lpSearchFilter: LPVOID,
1651         dwAdditionalFlags: DWORD,
1652         hTransaction: HANDLE,
1653     ) -> HANDLE;
CopyFileA( lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, bFailIfExists: BOOL, ) -> BOOL1654     pub fn CopyFileA(
1655         lpExistingFileName: LPCSTR,
1656         lpNewFileName: LPCSTR,
1657         bFailIfExists: BOOL,
1658     ) -> BOOL;
CopyFileW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, bFailIfExists: BOOL, ) -> BOOL1659     pub fn CopyFileW(
1660         lpExistingFileName: LPCWSTR,
1661         lpNewFileName: LPCWSTR,
1662         bFailIfExists: BOOL,
1663     ) -> BOOL;
1664 }
1665 FN!{stdcall LPPROGRESS_ROUTINE(
1666     TotalFileSize: LARGE_INTEGER,
1667     TotalBytesTransferred: LARGE_INTEGER,
1668     StreamSize: LARGE_INTEGER,
1669     StreamBytesTransferred: LARGE_INTEGER,
1670     dwStreamNumber: DWORD,
1671     dwCallbackReason: DWORD,
1672     hSourceFile: HANDLE,
1673     hDestinationFile: HANDLE,
1674     lpData: LPVOID,
1675 ) -> DWORD}
1676 extern "system" {
CopyFileExA( lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD, ) -> BOOL1677     pub fn CopyFileExA(
1678         lpExistingFileName: LPCSTR,
1679         lpNewFileName: LPCSTR,
1680         lpProgressRoutine: LPPROGRESS_ROUTINE,
1681         lpData: LPVOID,
1682         pbCancel: LPBOOL,
1683         dwCopyFlags: DWORD,
1684     ) -> BOOL;
CopyFileExW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD, ) -> BOOL1685     pub fn CopyFileExW(
1686         lpExistingFileName: LPCWSTR,
1687         lpNewFileName: LPCWSTR,
1688         lpProgressRoutine: LPPROGRESS_ROUTINE,
1689         lpData: LPVOID,
1690         pbCancel: LPBOOL,
1691         dwCopyFlags: DWORD,
1692     ) -> BOOL;
CopyFileTransactedA( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD, hTransaction: HANDLE, ) -> BOOL1693     pub fn CopyFileTransactedA(
1694         lpExistingFileName: LPCWSTR,
1695         lpNewFileName: LPCWSTR,
1696         lpProgressRoutine: LPPROGRESS_ROUTINE,
1697         lpData: LPVOID,
1698         pbCancel: LPBOOL,
1699         dwCopyFlags: DWORD,
1700         hTransaction: HANDLE,
1701     ) -> BOOL;
CopyFileTransactedW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD, hTransaction: HANDLE, ) -> BOOL1702     pub fn CopyFileTransactedW(
1703         lpExistingFileName: LPCWSTR,
1704         lpNewFileName: LPCWSTR,
1705         lpProgressRoutine: LPPROGRESS_ROUTINE,
1706         lpData: LPVOID,
1707         pbCancel: LPBOOL,
1708         dwCopyFlags: DWORD,
1709         hTransaction: HANDLE,
1710     ) -> BOOL;
1711 }
1712 ENUM!{enum COPYFILE2_MESSAGE_TYPE {
1713     COPYFILE2_CALLBACK_NONE = 0,
1714     COPYFILE2_CALLBACK_CHUNK_STARTED,
1715     COPYFILE2_CALLBACK_CHUNK_FINISHED,
1716     COPYFILE2_CALLBACK_STREAM_STARTED,
1717     COPYFILE2_CALLBACK_STREAM_FINISHED,
1718     COPYFILE2_CALLBACK_POLL_CONTINUE,
1719     COPYFILE2_CALLBACK_ERROR,
1720     COPYFILE2_CALLBACK_MAX,
1721 }}
1722 ENUM!{enum COPYFILE2_MESSAGE_ACTION {
1723     COPYFILE2_PROGRESS_CONTINUE = 0,
1724     COPYFILE2_PROGRESS_CANCEL,
1725     COPYFILE2_PROGRESS_STOP,
1726     COPYFILE2_PROGRESS_QUIET,
1727     COPYFILE2_PROGRESS_PAUSE,
1728 }}
1729 ENUM!{enum COPYFILE2_COPY_PHASE {
1730     COPYFILE2_PHASE_NONE = 0,
1731     COPYFILE2_PHASE_PREPARE_SOURCE,
1732     COPYFILE2_PHASE_PREPARE_DEST,
1733     COPYFILE2_PHASE_READ_SOURCE,
1734     COPYFILE2_PHASE_WRITE_DESTINATION,
1735     COPYFILE2_PHASE_SERVER_COPY,
1736     COPYFILE2_PHASE_NAMEGRAFT_COPY,
1737     COPYFILE2_PHASE_MAX,
1738 }}
1739 STRUCT!{struct COPYFILE2_MESSAGE_ChunkStarted {
1740     dwStreamNumber: DWORD,
1741     dwReserved: DWORD,
1742     hSourceFile: HANDLE,
1743     hDestinationFile: HANDLE,
1744     uliChunkNumber: ULARGE_INTEGER,
1745     uliChunkSize: ULARGE_INTEGER,
1746     uliStreamSize: ULARGE_INTEGER,
1747     uliTotalFileSize: ULARGE_INTEGER,
1748 }}
1749 STRUCT!{struct COPYFILE2_MESSAGE_ChunkFinished {
1750     dwStreamNumber: DWORD,
1751     dwFlags: DWORD,
1752     hSourceFile: HANDLE,
1753     hDestinationFile: HANDLE,
1754     uliChunkNumber: ULARGE_INTEGER,
1755     uliChunkSize: ULARGE_INTEGER,
1756     uliStreamSize: ULARGE_INTEGER,
1757     uliStreamBytesTransferred: ULARGE_INTEGER,
1758     uliTotalFileSize: ULARGE_INTEGER,
1759     uliTotalBytesTransferred: ULARGE_INTEGER,
1760 }}
1761 STRUCT!{struct COPYFILE2_MESSAGE_StreamStarted {
1762     dwStreamNumber: DWORD,
1763     dwReserved: DWORD,
1764     hSourceFile: HANDLE,
1765     hDestinationFile: HANDLE,
1766     uliStreamSize: ULARGE_INTEGER,
1767     uliTotalFileSize: ULARGE_INTEGER,
1768 }}
1769 STRUCT!{struct COPYFILE2_MESSAGE_StreamFinished {
1770     dwStreamNumber: DWORD,
1771     dwReserved: DWORD,
1772     hSourceFile: HANDLE,
1773     hDestinationFile: HANDLE,
1774     uliStreamSize: ULARGE_INTEGER,
1775     uliStreamBytesTransferred: ULARGE_INTEGER,
1776     uliTotalFileSize: ULARGE_INTEGER,
1777     uliTotalBytesTransferred: ULARGE_INTEGER,
1778 }}
1779 STRUCT!{struct COPYFILE2_MESSAGE_PollContinue {
1780     dwReserved: DWORD,
1781 }}
1782 STRUCT!{struct COPYFILE2_MESSAGE_Error {
1783     CopyPhase: COPYFILE2_COPY_PHASE,
1784     dwStreamNumber: DWORD,
1785     hrFailure: HRESULT,
1786     dwReserved: DWORD,
1787     uliChunkNumber: ULARGE_INTEGER,
1788     uliStreamSize: ULARGE_INTEGER,
1789     uliStreamBytesTransferred: ULARGE_INTEGER,
1790     uliTotalFileSize: ULARGE_INTEGER,
1791     uliTotalBytesTransferred: ULARGE_INTEGER,
1792 }}
1793 UNION!{union COPYFILE2_MESSAGE_Info {
1794     [u64; 8] [u64; 9],
1795     ChunkStarted ChunkStarted_mut: COPYFILE2_MESSAGE_ChunkStarted,
1796     ChunkFinished ChunkFinished_mut: COPYFILE2_MESSAGE_ChunkFinished,
1797     StreamStarted StreamStarted_mut: COPYFILE2_MESSAGE_StreamStarted,
1798     StreamFinished StreamFinished_mut: COPYFILE2_MESSAGE_StreamFinished,
1799     PollContinue PollContinue_mut: COPYFILE2_MESSAGE_PollContinue,
1800     Error Error_mut: COPYFILE2_MESSAGE_Error,
1801 }}
1802 STRUCT!{struct COPYFILE2_MESSAGE {
1803     Type: COPYFILE2_MESSAGE_TYPE,
1804     dwPadding: DWORD,
1805     Info: COPYFILE2_MESSAGE_Info,
1806 }}
1807 FN!{stdcall PCOPYFILE2_PROGRESS_ROUTINE(
1808     pMessage: *const COPYFILE2_MESSAGE,
1809     pvCallbackContext: PVOID,
1810 ) -> COPYFILE2_MESSAGE_ACTION}
1811 STRUCT!{struct COPYFILE2_EXTENDED_PARAMETERS {
1812     dwSize: DWORD,
1813     dwCopyFlags: DWORD,
1814     pfCancel: *mut BOOL,
1815     pProgressRoutine: PCOPYFILE2_PROGRESS_ROUTINE,
1816     pvCallbackContext: PVOID,
1817 }}
1818 extern "system" {
CopyFile2( pwszExistingFileName: PCWSTR, pwszNewFileName: PCWSTR, pExtendedParameters: *mut COPYFILE2_EXTENDED_PARAMETERS, ) -> HRESULT1819     pub fn CopyFile2(
1820         pwszExistingFileName: PCWSTR,
1821         pwszNewFileName: PCWSTR,
1822         pExtendedParameters: *mut COPYFILE2_EXTENDED_PARAMETERS,
1823     ) -> HRESULT;
MoveFileA( lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, ) -> BOOL1824     pub fn MoveFileA(
1825         lpExistingFileName: LPCSTR,
1826         lpNewFileName: LPCSTR,
1827     ) -> BOOL;
MoveFileW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, ) -> BOOL1828     pub fn MoveFileW(
1829         lpExistingFileName: LPCWSTR,
1830         lpNewFileName: LPCWSTR,
1831     ) -> BOOL;
MoveFileExA( lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, dwFlags: DWORD, ) -> BOOL1832     pub fn MoveFileExA(
1833         lpExistingFileName: LPCSTR,
1834         lpNewFileName: LPCSTR,
1835         dwFlags: DWORD,
1836     ) -> BOOL;
MoveFileExW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, dwFlags: DWORD, ) -> BOOL1837     pub fn MoveFileExW(
1838         lpExistingFileName: LPCWSTR,
1839         lpNewFileName: LPCWSTR,
1840         dwFlags: DWORD,
1841     ) -> BOOL;
MoveFileWithProgressA( lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD, ) -> BOOL1842     pub fn MoveFileWithProgressA(
1843         lpExistingFileName: LPCSTR,
1844         lpNewFileName: LPCSTR,
1845         lpProgressRoutine: LPPROGRESS_ROUTINE,
1846         lpData: LPVOID,
1847         dwFlags: DWORD,
1848     ) -> BOOL;
MoveFileWithProgressW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD, ) -> BOOL1849     pub fn MoveFileWithProgressW(
1850         lpExistingFileName: LPCWSTR,
1851         lpNewFileName: LPCWSTR,
1852         lpProgressRoutine: LPPROGRESS_ROUTINE,
1853         lpData: LPVOID,
1854         dwFlags: DWORD,
1855     ) -> BOOL;
MoveFileTransactedA( lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD, hTransaction: HANDLE, ) -> BOOL1856     pub fn MoveFileTransactedA(
1857         lpExistingFileName: LPCSTR,
1858         lpNewFileName: LPCSTR,
1859         lpProgressRoutine: LPPROGRESS_ROUTINE,
1860         lpData: LPVOID,
1861         dwFlags: DWORD,
1862         hTransaction: HANDLE,
1863     ) -> BOOL;
MoveFileTransactedW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD, hTransaction: HANDLE, ) -> BOOL1864     pub fn MoveFileTransactedW(
1865         lpExistingFileName: LPCWSTR,
1866         lpNewFileName: LPCWSTR,
1867         lpProgressRoutine: LPPROGRESS_ROUTINE,
1868         lpData: LPVOID,
1869         dwFlags: DWORD,
1870         hTransaction: HANDLE,
1871     ) -> BOOL;
1872 }
1873 pub const MOVEFILE_REPLACE_EXISTING: DWORD = 0x00000001;
1874 pub const MOVEFILE_COPY_ALLOWED: DWORD = 0x00000002;
1875 pub const MOVEFILE_DELAY_UNTIL_REBOOT: DWORD = 0x00000004;
1876 pub const MOVEFILE_WRITE_THROUGH: DWORD = 0x00000008;
1877 pub const MOVEFILE_CREATE_HARDLINK: DWORD = 0x00000010;
1878 pub const MOVEFILE_FAIL_IF_NOT_TRACKABLE: DWORD = 0x00000020;
1879 extern "system" {
ReplaceFileA( lpReplacedFileName: LPCSTR, lpReplacementFileName: LPCSTR, lpBackupFileName: LPCSTR, dwReplaceFlags: DWORD, lpExclude: LPVOID, lpReserved: LPVOID, )1880     pub fn ReplaceFileA(
1881         lpReplacedFileName: LPCSTR,
1882         lpReplacementFileName: LPCSTR,
1883         lpBackupFileName: LPCSTR,
1884         dwReplaceFlags: DWORD,
1885         lpExclude: LPVOID,
1886         lpReserved: LPVOID,
1887     );
ReplaceFileW( lpReplacedFileName: LPCWSTR, lpReplacementFileName: LPCWSTR, lpBackupFileName: LPCWSTR, dwReplaceFlags: DWORD, lpExclude: LPVOID, lpReserved: LPVOID, )1888     pub fn ReplaceFileW(
1889         lpReplacedFileName: LPCWSTR,
1890         lpReplacementFileName: LPCWSTR,
1891         lpBackupFileName: LPCWSTR,
1892         dwReplaceFlags: DWORD,
1893         lpExclude: LPVOID,
1894         lpReserved: LPVOID,
1895     );
CreateHardLinkA( lpFileName: LPCSTR, lpExistingFileName: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> BOOL1896     pub fn CreateHardLinkA(
1897         lpFileName: LPCSTR,
1898         lpExistingFileName: LPCSTR,
1899         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
1900     ) -> BOOL;
CreateHardLinkW( lpFileName: LPCWSTR, lpExistingFileName: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> BOOL1901     pub fn CreateHardLinkW(
1902         lpFileName: LPCWSTR,
1903         lpExistingFileName: LPCWSTR,
1904         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
1905     ) -> BOOL;
CreateHardLinkTransactedA( lpFileName: LPCSTR, lpExistingFileName: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE, ) -> BOOL1906     pub fn CreateHardLinkTransactedA(
1907         lpFileName: LPCSTR,
1908         lpExistingFileName: LPCSTR,
1909         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
1910         hTransaction: HANDLE,
1911     ) -> BOOL;
CreateHardLinkTransactedW( lpFileName: LPCWSTR, lpExistingFileName: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE, )1912     pub fn CreateHardLinkTransactedW(
1913         lpFileName: LPCWSTR,
1914         lpExistingFileName: LPCWSTR,
1915         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
1916         hTransaction: HANDLE,
1917     );
FindFirstStreamTransactedW( lpFileName: LPCWSTR, InfoLevel: STREAM_INFO_LEVELS, lpFindStreamData: LPVOID, dwFlags: DWORD, hTransaction: HANDLE, ) -> HANDLE1918     pub fn FindFirstStreamTransactedW(
1919         lpFileName: LPCWSTR,
1920         InfoLevel: STREAM_INFO_LEVELS,
1921         lpFindStreamData: LPVOID,
1922         dwFlags: DWORD,
1923         hTransaction: HANDLE,
1924     ) -> HANDLE;
FindFirstFileNameTransactedW( lpFileName: LPCWSTR, dwFlags: DWORD, StringLength: LPDWORD, LinkName: PWSTR, hTransaction: HANDLE, ) -> HANDLE1925     pub fn FindFirstFileNameTransactedW(
1926         lpFileName: LPCWSTR,
1927         dwFlags: DWORD,
1928         StringLength: LPDWORD,
1929         LinkName: PWSTR,
1930         hTransaction: HANDLE,
1931     ) -> HANDLE;
CreateNamedPipeA( lpName: LPCSTR, dwOpenMode: DWORD, dwPipeMode: DWORD, nMaxInstances: DWORD, nOutBufferSize: DWORD, nInBufferSize: DWORD, nDefaultTimeOut: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> HANDLE1932     pub fn CreateNamedPipeA(
1933         lpName: LPCSTR,
1934         dwOpenMode: DWORD,
1935         dwPipeMode: DWORD,
1936         nMaxInstances: DWORD,
1937         nOutBufferSize: DWORD,
1938         nInBufferSize: DWORD,
1939         nDefaultTimeOut: DWORD,
1940         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
1941     ) -> HANDLE;
GetNamedPipeHandleStateA( hNamedPipe: HANDLE, lpState: LPDWORD, lpCurInstances: LPDWORD, lpMaxCollectionCount: LPDWORD, lpCollectDataTimeout: LPDWORD, lpUserName: LPSTR, nMaxUserNameSize: DWORD, ) -> BOOL1942     pub fn GetNamedPipeHandleStateA(
1943         hNamedPipe: HANDLE,
1944         lpState: LPDWORD,
1945         lpCurInstances: LPDWORD,
1946         lpMaxCollectionCount: LPDWORD,
1947         lpCollectDataTimeout: LPDWORD,
1948         lpUserName: LPSTR,
1949         nMaxUserNameSize: DWORD,
1950     ) -> BOOL;
CallNamedPipeA( lpNamedPipeName: LPCSTR, lpInBuffer: LPVOID, nInBufferSize: DWORD, lpOutBuffer: LPVOID, nOutBufferSize: DWORD, lpBytesRead: LPDWORD, nTimeOut: DWORD, ) -> BOOL1951     pub fn CallNamedPipeA(
1952         lpNamedPipeName: LPCSTR,
1953         lpInBuffer: LPVOID,
1954         nInBufferSize: DWORD,
1955         lpOutBuffer: LPVOID,
1956         nOutBufferSize: DWORD,
1957         lpBytesRead: LPDWORD,
1958         nTimeOut: DWORD,
1959     ) -> BOOL;
WaitNamedPipeA( lpNamedPipeName: LPCSTR, nTimeOut: DWORD, ) -> BOOL1960     pub fn WaitNamedPipeA(
1961         lpNamedPipeName: LPCSTR,
1962         nTimeOut: DWORD,
1963     ) -> BOOL;
GetNamedPipeClientComputerNameA( Pipe: HANDLE, ClientComputerName: LPSTR, ClientComputerNameLength: ULONG, ) -> BOOL1964     pub fn GetNamedPipeClientComputerNameA(
1965         Pipe: HANDLE,
1966         ClientComputerName: LPSTR,
1967         ClientComputerNameLength: ULONG,
1968     ) -> BOOL;
GetNamedPipeClientProcessId( Pipe: HANDLE, ClientProcessId: PULONG, ) -> BOOL1969     pub fn GetNamedPipeClientProcessId(
1970         Pipe: HANDLE,
1971         ClientProcessId: PULONG,
1972     ) -> BOOL;
GetNamedPipeClientSessionId( Pipe: HANDLE, ClientSessionId: PULONG, ) -> BOOL1973     pub fn GetNamedPipeClientSessionId(
1974         Pipe: HANDLE,
1975         ClientSessionId: PULONG,
1976     ) -> BOOL;
GetNamedPipeServerProcessId( Pipe: HANDLE, ServerProcessId: PULONG, ) -> BOOL1977     pub fn GetNamedPipeServerProcessId(
1978         Pipe: HANDLE,
1979         ServerProcessId: PULONG,
1980     ) -> BOOL;
GetNamedPipeServerSessionId( Pipe: HANDLE, ServerSessionId: PULONG, ) -> BOOL1981     pub fn GetNamedPipeServerSessionId(
1982         Pipe: HANDLE,
1983         ServerSessionId: PULONG,
1984     ) -> BOOL;
SetVolumeLabelA( lpRootPathName: LPCSTR, lpVolumeName: LPCSTR, ) -> BOOL1985     pub fn SetVolumeLabelA(
1986         lpRootPathName: LPCSTR,
1987         lpVolumeName: LPCSTR,
1988     ) -> BOOL;
SetVolumeLabelW( lpRootPathName: LPCWSTR, lpVolumeName: LPCWSTR, ) -> BOOL1989     pub fn SetVolumeLabelW(
1990         lpRootPathName: LPCWSTR,
1991         lpVolumeName: LPCWSTR,
1992     ) -> BOOL;
SetFileBandwidthReservation( hFile: HANDLE, nPeriodMilliseconds: DWORD, nBytesPerPeriod: DWORD, bDiscardable: BOOL, lpTransferSize: LPDWORD, lpNumOutstandingRequests: LPDWORD, ) -> BOOL1993     pub fn SetFileBandwidthReservation(
1994         hFile: HANDLE,
1995         nPeriodMilliseconds: DWORD,
1996         nBytesPerPeriod: DWORD,
1997         bDiscardable: BOOL,
1998         lpTransferSize: LPDWORD,
1999         lpNumOutstandingRequests: LPDWORD,
2000     ) -> BOOL;
GetFileBandwidthReservation( hFile: HANDLE, lpPeriodMilliseconds: LPDWORD, lpBytesPerPeriod: LPDWORD, pDiscardable: LPBOOL, lpTransferSize: LPDWORD, lpNumOutstandingRequests: LPDWORD, ) -> BOOL2001     pub fn GetFileBandwidthReservation(
2002         hFile: HANDLE,
2003         lpPeriodMilliseconds: LPDWORD,
2004         lpBytesPerPeriod: LPDWORD,
2005         pDiscardable: LPBOOL,
2006         lpTransferSize: LPDWORD,
2007         lpNumOutstandingRequests: LPDWORD,
2008     ) -> BOOL;
2009     // pub fn ClearEventLogA();
2010     // pub fn ClearEventLogW();
2011     // pub fn BackupEventLogA();
2012     // pub fn BackupEventLogW();
2013     // pub fn CloseEventLog();
DeregisterEventSource( hEventLog: HANDLE, ) -> BOOL2014     pub fn DeregisterEventSource(
2015         hEventLog: HANDLE,
2016     ) -> BOOL;
2017     // pub fn NotifyChangeEventLog();
2018     // pub fn GetNumberOfEventLogRecords();
2019     // pub fn GetOldestEventLogRecord();
2020     // pub fn OpenEventLogA();
2021     // pub fn OpenEventLogW();
RegisterEventSourceA( lpUNCServerName: LPCSTR, lpSourceName: LPCSTR, ) -> HANDLE2022     pub fn RegisterEventSourceA(
2023         lpUNCServerName: LPCSTR,
2024         lpSourceName: LPCSTR,
2025     ) -> HANDLE;
RegisterEventSourceW( lpUNCServerName: LPCWSTR, lpSourceName: LPCWSTR, ) -> HANDLE2026     pub fn RegisterEventSourceW(
2027         lpUNCServerName: LPCWSTR,
2028         lpSourceName: LPCWSTR,
2029     ) -> HANDLE;
2030     // pub fn OpenBackupEventLogA();
2031     // pub fn OpenBackupEventLogW();
2032     // pub fn ReadEventLogA();
2033     // pub fn ReadEventLogW();
ReportEventA( hEventLog: HANDLE, wType: WORD, wCategory: WORD, dwEventID: DWORD, lpUserSid: PSID, wNumStrings: WORD, dwDataSize: DWORD, lpStrings: *mut LPCSTR, lpRawData: LPVOID, ) -> BOOL2034     pub fn ReportEventA(
2035         hEventLog: HANDLE,
2036         wType: WORD,
2037         wCategory: WORD,
2038         dwEventID: DWORD,
2039         lpUserSid: PSID,
2040         wNumStrings: WORD,
2041         dwDataSize: DWORD,
2042         lpStrings: *mut LPCSTR,
2043         lpRawData: LPVOID,
2044     ) -> BOOL;
ReportEventW( hEventLog: HANDLE, wType: WORD, wCategory: WORD, dwEventID: DWORD, lpUserSid: PSID, wNumStrings: WORD, dwDataSize: DWORD, lpStrings: *mut LPCWSTR, lpRawData: LPVOID, ) -> BOOL2045     pub fn ReportEventW(
2046         hEventLog: HANDLE,
2047         wType: WORD,
2048         wCategory: WORD,
2049         dwEventID: DWORD,
2050         lpUserSid: PSID,
2051         wNumStrings: WORD,
2052         dwDataSize: DWORD,
2053         lpStrings: *mut LPCWSTR,
2054         lpRawData: LPVOID,
2055     ) -> BOOL;
2056     // pub fn GetEventLogInformation();
2057     // pub fn OperationStart();
2058     // pub fn OperationEnd();
2059     // pub fn AccessCheckAndAuditAlarmA();
2060     // pub fn AccessCheckByTypeAndAuditAlarmA();
2061     // pub fn AccessCheckByTypeResultListAndAuditAlarmA();
2062     // pub fn AccessCheckByTypeResultListAndAuditAlarmByHandleA();
2063     // pub fn ObjectOpenAuditAlarmA();
2064     // pub fn ObjectPrivilegeAuditAlarmA();
2065     // pub fn ObjectCloseAuditAlarmA();
2066     // pub fn ObjectDeleteAuditAlarmA();
2067     // pub fn PrivilegedServiceAuditAlarmA();
2068     // pub fn AddConditionalAce();
2069     // pub fn SetFileSecurityA();
2070     // pub fn GetFileSecurityA();
ReadDirectoryChangesW( hDirectory: HANDLE, lpBuffer: LPVOID, nBufferLength: DWORD, bWatchSubtree: BOOL, dwNotifyFilter: DWORD, lpBytesReturned: LPDWORD, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE, ) -> BOOL2071     pub fn ReadDirectoryChangesW(
2072         hDirectory: HANDLE,
2073         lpBuffer: LPVOID,
2074         nBufferLength: DWORD,
2075         bWatchSubtree: BOOL,
2076         dwNotifyFilter: DWORD,
2077         lpBytesReturned: LPDWORD,
2078         lpOverlapped: LPOVERLAPPED,
2079         lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE,
2080     ) -> BOOL;
MapViewOfFileExNuma( hFileMappingObject: HANDLE, dwDesiredAccess: DWORD, dwFileOffsetHigh: DWORD, dwFileOffsetLow: DWORD, dwNumberOfBytesToMap: SIZE_T, lpBaseAddress: LPVOID, nndPreferred: DWORD, ) -> LPVOID2081     pub fn MapViewOfFileExNuma(
2082         hFileMappingObject: HANDLE,
2083         dwDesiredAccess: DWORD,
2084         dwFileOffsetHigh: DWORD,
2085         dwFileOffsetLow: DWORD,
2086         dwNumberOfBytesToMap: SIZE_T,
2087         lpBaseAddress: LPVOID,
2088         nndPreferred: DWORD,
2089     ) -> LPVOID;
IsBadReadPtr( lp: *const VOID, ucb: UINT_PTR, ) -> BOOL2090     pub fn IsBadReadPtr(
2091         lp: *const VOID,
2092         ucb: UINT_PTR,
2093     ) -> BOOL;
IsBadWritePtr( lp: LPVOID, ucb: UINT_PTR, ) -> BOOL2094     pub fn IsBadWritePtr(
2095         lp: LPVOID,
2096         ucb: UINT_PTR,
2097     ) -> BOOL;
IsBadHugeReadPtr( lp: *const VOID, ucb: UINT_PTR, ) -> BOOL2098     pub fn IsBadHugeReadPtr(
2099         lp: *const VOID,
2100         ucb: UINT_PTR,
2101     ) -> BOOL;
IsBadHugeWritePtr( lp: LPVOID, ucb: UINT_PTR, ) -> BOOL2102     pub fn IsBadHugeWritePtr(
2103         lp: LPVOID,
2104         ucb: UINT_PTR,
2105     ) -> BOOL;
IsBadCodePtr( lpfn: FARPROC, ) -> BOOL2106     pub fn IsBadCodePtr(
2107         lpfn: FARPROC,
2108     ) -> BOOL;
IsBadStringPtrA( lpsz: LPCSTR, ucchMax: UINT_PTR, ) -> BOOL2109     pub fn IsBadStringPtrA(
2110         lpsz: LPCSTR,
2111         ucchMax: UINT_PTR,
2112     ) -> BOOL;
IsBadStringPtrW( lpsz: LPCWSTR, ucchMax: UINT_PTR, ) -> BOOL2113     pub fn IsBadStringPtrW(
2114         lpsz: LPCWSTR,
2115         ucchMax: UINT_PTR,
2116     ) -> BOOL;
LookupAccountSidA( lpSystemName: LPCSTR, Sid: PSID, Name: LPSTR, cchName: LPDWORD, ReferencedDomainName: LPSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE, ) -> BOOL2117     pub fn LookupAccountSidA(
2118         lpSystemName: LPCSTR,
2119         Sid: PSID,
2120         Name: LPSTR,
2121         cchName: LPDWORD,
2122         ReferencedDomainName: LPSTR,
2123         cchReferencedDomainName: LPDWORD,
2124         peUse: PSID_NAME_USE,
2125     ) -> BOOL;
LookupAccountSidW( lpSystemName: LPCWSTR, Sid: PSID, Name: LPWSTR, cchName: LPDWORD, ReferencedDomainName: LPWSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE, ) -> BOOL2126     pub fn LookupAccountSidW(
2127         lpSystemName: LPCWSTR,
2128         Sid: PSID,
2129         Name: LPWSTR,
2130         cchName: LPDWORD,
2131         ReferencedDomainName: LPWSTR,
2132         cchReferencedDomainName: LPDWORD,
2133         peUse: PSID_NAME_USE,
2134     ) -> BOOL;
LookupAccountNameA( lpSystemName: LPCSTR, lpAccountName: LPCSTR, Sid: PSID, cbSid: LPDWORD, ReferencedDomainName: LPCSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE, ) -> BOOL2135     pub fn LookupAccountNameA(
2136         lpSystemName: LPCSTR,
2137         lpAccountName: LPCSTR,
2138         Sid: PSID,
2139         cbSid: LPDWORD,
2140         ReferencedDomainName: LPCSTR,
2141         cchReferencedDomainName: LPDWORD,
2142         peUse: PSID_NAME_USE,
2143     ) -> BOOL;
LookupAccountNameW( lpSystemName: LPCWSTR, lpAccountName: LPCWSTR, Sid: PSID, cbSid: LPDWORD, ReferencedDomainName: LPCWSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE, ) -> BOOL2144     pub fn LookupAccountNameW(
2145         lpSystemName: LPCWSTR,
2146         lpAccountName: LPCWSTR,
2147         Sid: PSID,
2148         cbSid: LPDWORD,
2149         ReferencedDomainName: LPCWSTR,
2150         cchReferencedDomainName: LPDWORD,
2151         peUse: PSID_NAME_USE,
2152     ) -> BOOL;
2153     // pub fn LookupAccountNameLocalA();
2154     // pub fn LookupAccountNameLocalW();
2155     // pub fn LookupAccountSidLocalA();
2156     // pub fn LookupAccountSidLocalW();
LookupPrivilegeValueA( lpSystemName: LPCSTR, lpName: LPCSTR, lpLuid: PLUID, ) -> BOOL2157     pub fn LookupPrivilegeValueA(
2158         lpSystemName: LPCSTR,
2159         lpName: LPCSTR,
2160         lpLuid: PLUID,
2161     ) -> BOOL;
LookupPrivilegeValueW( lpSystemName: LPCWSTR, lpName: LPCWSTR, lpLuid: PLUID, ) -> BOOL2162     pub fn LookupPrivilegeValueW(
2163         lpSystemName: LPCWSTR,
2164         lpName: LPCWSTR,
2165         lpLuid: PLUID,
2166     ) -> BOOL;
LookupPrivilegeNameA( lpSystemName: LPCSTR, lpLuid: PLUID, lpName: LPSTR, cchName: LPDWORD, ) -> BOOL2167     pub fn LookupPrivilegeNameA(
2168         lpSystemName: LPCSTR,
2169         lpLuid: PLUID,
2170         lpName: LPSTR,
2171         cchName: LPDWORD,
2172     ) -> BOOL;
LookupPrivilegeNameW( lpSystemName: LPCWSTR, lpLuid: PLUID, lpName: LPWSTR, cchName: LPDWORD, ) -> BOOL2173     pub fn LookupPrivilegeNameW(
2174         lpSystemName: LPCWSTR,
2175         lpLuid: PLUID,
2176         lpName: LPWSTR,
2177         cchName: LPDWORD,
2178     ) -> BOOL;
2179     // pub fn LookupPrivilegeDisplayNameA();
2180     // pub fn LookupPrivilegeDisplayNameW();
BuildCommDCBA( lpDef: LPCSTR, lpDCB: LPDCB, ) -> BOOL2181     pub fn BuildCommDCBA(
2182         lpDef: LPCSTR,
2183         lpDCB: LPDCB,
2184     ) -> BOOL;
BuildCommDCBW( lpDef: LPCWSTR, lpDCB: LPDCB, ) -> BOOL2185     pub fn BuildCommDCBW(
2186         lpDef: LPCWSTR,
2187         lpDCB: LPDCB,
2188     ) -> BOOL;
BuildCommDCBAndTimeoutsA( lpDef: LPCSTR, lpDCB: LPDCB, lpCommTimeouts: LPCOMMTIMEOUTS, ) -> BOOL2189     pub fn BuildCommDCBAndTimeoutsA(
2190         lpDef: LPCSTR,
2191         lpDCB: LPDCB,
2192         lpCommTimeouts: LPCOMMTIMEOUTS,
2193     ) -> BOOL;
BuildCommDCBAndTimeoutsW( lpDef: LPCWSTR, lpDCB: LPDCB, lpCommTimeouts: LPCOMMTIMEOUTS, ) -> BOOL2194     pub fn BuildCommDCBAndTimeoutsW(
2195         lpDef: LPCWSTR,
2196         lpDCB: LPDCB,
2197         lpCommTimeouts: LPCOMMTIMEOUTS,
2198     ) -> BOOL;
CommConfigDialogA( lpszName: LPCSTR, hWnd: HWND, lpCC: LPCOMMCONFIG, ) -> BOOL2199     pub fn CommConfigDialogA(
2200         lpszName: LPCSTR,
2201         hWnd: HWND,
2202         lpCC: LPCOMMCONFIG,
2203     ) -> BOOL;
CommConfigDialogW( lpszName: LPCWSTR, hWnd: HWND, lpCC: LPCOMMCONFIG, ) -> BOOL2204     pub fn CommConfigDialogW(
2205         lpszName: LPCWSTR,
2206         hWnd: HWND,
2207         lpCC: LPCOMMCONFIG,
2208     ) -> BOOL;
GetDefaultCommConfigA( lpszName: LPCSTR, lpCC: LPCOMMCONFIG, lpdwSize: LPDWORD, ) -> BOOL2209     pub fn GetDefaultCommConfigA(
2210         lpszName: LPCSTR,
2211         lpCC: LPCOMMCONFIG,
2212         lpdwSize: LPDWORD,
2213     ) -> BOOL;
GetDefaultCommConfigW( lpszName: LPCWSTR, lpCC: LPCOMMCONFIG, lpdwSize: LPDWORD, ) -> BOOL2214     pub fn GetDefaultCommConfigW(
2215         lpszName: LPCWSTR,
2216         lpCC: LPCOMMCONFIG,
2217         lpdwSize: LPDWORD,
2218     ) -> BOOL;
SetDefaultCommConfigA( lpszName: LPCSTR, lpCC: LPCOMMCONFIG, dwSize: DWORD, ) -> BOOL2219     pub fn SetDefaultCommConfigA(
2220         lpszName: LPCSTR,
2221         lpCC: LPCOMMCONFIG,
2222         dwSize: DWORD,
2223     ) -> BOOL;
SetDefaultCommConfigW( lpszName: LPCWSTR, lpCC: LPCOMMCONFIG, dwSize: DWORD, ) -> BOOL2224     pub fn SetDefaultCommConfigW(
2225         lpszName: LPCWSTR,
2226         lpCC: LPCOMMCONFIG,
2227         dwSize: DWORD,
2228     ) -> BOOL;
GetComputerNameA( lpBuffer: LPSTR, nSize: LPDWORD, ) -> BOOL2229     pub fn GetComputerNameA(
2230         lpBuffer: LPSTR,
2231         nSize: LPDWORD,
2232     ) -> BOOL;
GetComputerNameW( lpBuffer: LPWSTR, nSize: LPDWORD, ) -> BOOL2233     pub fn GetComputerNameW(
2234         lpBuffer: LPWSTR,
2235         nSize: LPDWORD,
2236     ) -> BOOL;
DnsHostnameToComputerNameA( Hostname: LPCSTR, ComputerName: LPCSTR, nSize: LPDWORD, ) -> BOOL2237     pub fn DnsHostnameToComputerNameA(
2238         Hostname: LPCSTR,
2239         ComputerName: LPCSTR,
2240         nSize: LPDWORD,
2241     ) -> BOOL;
DnsHostnameToComputerNameW( Hostname: LPCWSTR, ComputerName: LPWSTR, nSize: LPDWORD, ) -> BOOL2242     pub fn DnsHostnameToComputerNameW(
2243         Hostname: LPCWSTR,
2244         ComputerName: LPWSTR,
2245         nSize: LPDWORD,
2246     ) -> BOOL;
GetUserNameA( lpBuffer: LPSTR, pcbBuffer: LPDWORD, ) -> BOOL2247     pub fn GetUserNameA(
2248         lpBuffer: LPSTR,
2249         pcbBuffer: LPDWORD,
2250     ) -> BOOL;
GetUserNameW( lpBuffer: LPWSTR, pcbBuffer: LPDWORD, ) -> BOOL2251     pub fn GetUserNameW(
2252         lpBuffer: LPWSTR,
2253         pcbBuffer: LPDWORD,
2254     ) -> BOOL;
2255 }
2256 pub const LOGON32_LOGON_INTERACTIVE: DWORD = 2;
2257 pub const LOGON32_LOGON_NETWORK: DWORD = 3;
2258 pub const LOGON32_LOGON_BATCH: DWORD = 4;
2259 pub const LOGON32_LOGON_SERVICE: DWORD = 5;
2260 pub const LOGON32_LOGON_UNLOCK: DWORD = 7;
2261 pub const LOGON32_LOGON_NETWORK_CLEARTEXT: DWORD = 8;
2262 pub const LOGON32_LOGON_NEW_CREDENTIALS: DWORD = 9;
2263 pub const LOGON32_PROVIDER_DEFAULT: DWORD = 0;
2264 pub const LOGON32_PROVIDER_WINNT35: DWORD = 1;
2265 pub const LOGON32_PROVIDER_WINNT40: DWORD = 2;
2266 pub const LOGON32_PROVIDER_WINNT50: DWORD = 3;
2267 pub const LOGON32_PROVIDER_VIRTUAL: DWORD = 4;
2268 extern "system" {
LogonUserA( lpUsername: LPCSTR, lpDomain: LPCSTR, lpPassword: LPCSTR, dwLogonType: DWORD, dwLogonProvider: DWORD, phToken: PHANDLE, ) -> BOOL2269     pub fn LogonUserA(
2270         lpUsername: LPCSTR,
2271         lpDomain: LPCSTR,
2272         lpPassword: LPCSTR,
2273         dwLogonType: DWORD,
2274         dwLogonProvider: DWORD,
2275         phToken: PHANDLE,
2276     ) -> BOOL;
LogonUserW( lpUsername: LPCWSTR, lpDomain: LPCWSTR, lpPassword: LPCWSTR, dwLogonType: DWORD, dwLogonProvider: DWORD, phToken: PHANDLE, ) -> BOOL2277     pub fn LogonUserW(
2278         lpUsername: LPCWSTR,
2279         lpDomain: LPCWSTR,
2280         lpPassword: LPCWSTR,
2281         dwLogonType: DWORD,
2282         dwLogonProvider: DWORD,
2283         phToken: PHANDLE,
2284     ) -> BOOL;
LogonUserExA( lpUsername: LPCSTR, lpDomain: LPCSTR, lpPassword: LPCSTR, dwLogonType: DWORD, dwLogonProvider: DWORD, phToken: PHANDLE, ppLogonSid: *mut PSID, ppProfileBuffer: *mut PVOID, pdwProfileLength: LPDWORD, pQuotaLimits: PQUOTA_LIMITS, ) -> BOOL2285     pub fn LogonUserExA(
2286         lpUsername: LPCSTR,
2287         lpDomain: LPCSTR,
2288         lpPassword: LPCSTR,
2289         dwLogonType: DWORD,
2290         dwLogonProvider: DWORD,
2291         phToken: PHANDLE,
2292         ppLogonSid: *mut PSID,
2293         ppProfileBuffer: *mut PVOID,
2294         pdwProfileLength: LPDWORD,
2295         pQuotaLimits: PQUOTA_LIMITS,
2296     ) -> BOOL;
LogonUserExW( lpUsername: LPCWSTR, lpDomain: LPCWSTR, lpPassword: LPCWSTR, dwLogonType: DWORD, dwLogonProvider: DWORD, phToken: PHANDLE, ppLogonSid: *mut PSID, ppProfileBuffer: *mut PVOID, pdwProfileLength: LPDWORD, pQuotaLimits: PQUOTA_LIMITS, ) -> BOOL2297     pub fn LogonUserExW(
2298         lpUsername: LPCWSTR,
2299         lpDomain: LPCWSTR,
2300         lpPassword: LPCWSTR,
2301         dwLogonType: DWORD,
2302         dwLogonProvider: DWORD,
2303         phToken: PHANDLE,
2304         ppLogonSid: *mut PSID,
2305         ppProfileBuffer: *mut PVOID,
2306         pdwProfileLength: LPDWORD,
2307         pQuotaLimits: PQUOTA_LIMITS,
2308     ) -> BOOL;
2309     // pub fn CreateProcessWithLogonW();
2310     // pub fn CreateProcessWithTokenW();
2311     // pub fn IsTokenUntrusted();
RegisterWaitForSingleObject( phNewWaitObject: PHANDLE, hObject: HANDLE, Callback: WAITORTIMERCALLBACK, Context: PVOID, dwMilliseconds: ULONG, dwFlags: ULONG, ) -> BOOL2312     pub fn RegisterWaitForSingleObject(
2313         phNewWaitObject: PHANDLE,
2314         hObject: HANDLE,
2315         Callback: WAITORTIMERCALLBACK,
2316         Context: PVOID,
2317         dwMilliseconds: ULONG,
2318         dwFlags: ULONG,
2319     ) -> BOOL;
UnregisterWait( WaitHandle: HANDLE, ) -> BOOL2320     pub fn UnregisterWait(
2321         WaitHandle: HANDLE,
2322     ) -> BOOL;
BindIoCompletionCallback( FileHandle: HANDLE, Function: LPOVERLAPPED_COMPLETION_ROUTINE, Flags: ULONG, ) -> BOOL2323     pub fn BindIoCompletionCallback(
2324         FileHandle: HANDLE,
2325         Function: LPOVERLAPPED_COMPLETION_ROUTINE,
2326         Flags: ULONG,
2327     ) -> BOOL;
SetTimerQueueTimer( TimerQueue: HANDLE, Callback: WAITORTIMERCALLBACK, Parameter: PVOID, DueTime: DWORD, Period: DWORD, PreferIo: BOOL, ) -> HANDLE2328     pub fn SetTimerQueueTimer(
2329         TimerQueue: HANDLE,
2330         Callback: WAITORTIMERCALLBACK,
2331         Parameter: PVOID,
2332         DueTime: DWORD,
2333         Period: DWORD,
2334         PreferIo: BOOL,
2335     ) -> HANDLE;
CancelTimerQueueTimer( TimerQueue: HANDLE, Timer: HANDLE, ) -> BOOL2336     pub fn CancelTimerQueueTimer(
2337         TimerQueue: HANDLE,
2338         Timer: HANDLE,
2339     ) -> BOOL;
DeleteTimerQueue( TimerQueue: HANDLE, ) -> BOOL2340     pub fn DeleteTimerQueue(
2341         TimerQueue: HANDLE,
2342     ) -> BOOL;
2343     // pub fn InitializeThreadpoolEnvironment();
2344     // pub fn SetThreadpoolCallbackPool();
2345     // pub fn SetThreadpoolCallbackCleanupGroup();
2346     // pub fn SetThreadpoolCallbackRunsLong();
2347     // pub fn SetThreadpoolCallbackLibrary();
2348     // pub fn SetThreadpoolCallbackPriority();
2349     // pub fn DestroyThreadpoolEnvironment();
2350     // pub fn SetThreadpoolCallbackPersistent();
CreatePrivateNamespaceA( lpPrivateNamespaceAttributes: LPSECURITY_ATTRIBUTES, lpBoundaryDescriptor: LPVOID, lpAliasPrefix: LPCSTR, ) -> HANDLE2351     pub fn CreatePrivateNamespaceA(
2352         lpPrivateNamespaceAttributes: LPSECURITY_ATTRIBUTES,
2353         lpBoundaryDescriptor: LPVOID,
2354         lpAliasPrefix: LPCSTR,
2355     ) -> HANDLE;
OpenPrivateNamespaceA( lpBoundaryDescriptor: LPVOID, lpAliasPrefix: LPCSTR, ) -> HANDLE2356     pub fn OpenPrivateNamespaceA(
2357         lpBoundaryDescriptor: LPVOID,
2358         lpAliasPrefix: LPCSTR,
2359     ) -> HANDLE;
CreateBoundaryDescriptorA( Name: LPCSTR, Flags: ULONG, ) -> HANDLE2360     pub fn CreateBoundaryDescriptorA(
2361         Name: LPCSTR,
2362         Flags: ULONG,
2363     ) -> HANDLE;
AddIntegrityLabelToBoundaryDescriptor( BoundaryDescriptor: *mut HANDLE, IntegrityLabel: PSID, ) -> BOOL2364     pub fn AddIntegrityLabelToBoundaryDescriptor(
2365         BoundaryDescriptor: *mut HANDLE,
2366         IntegrityLabel: PSID,
2367     ) -> BOOL;
2368 }
2369 pub const HW_PROFILE_GUIDLEN: usize = 39;
2370 // MAX_PROFILE_LEN
2371 pub const DOCKINFO_UNDOCKED: DWORD = 0x1;
2372 pub const DOCKINFO_DOCKED: DWORD = 0x2;
2373 pub const DOCKINFO_USER_SUPPLIED: DWORD = 0x4;
2374 pub const DOCKINFO_USER_UNDOCKED: DWORD = DOCKINFO_USER_SUPPLIED | DOCKINFO_UNDOCKED;
2375 pub const DOCKINFO_USER_DOCKED: DWORD = DOCKINFO_USER_SUPPLIED | DOCKINFO_DOCKED;
2376 STRUCT!{struct HW_PROFILE_INFOA {
2377     dwDockInfo: DWORD,
2378     szHwProfileGuid: [CHAR; HW_PROFILE_GUIDLEN],
2379     szHwProfileName: [CHAR; MAX_PROFILE_LEN],
2380 }}
2381 pub type LPHW_PROFILE_INFOA = *mut HW_PROFILE_INFOA;
2382 STRUCT!{struct HW_PROFILE_INFOW {
2383     dwDockInfo: DWORD,
2384     szHwProfileGuid: [WCHAR; HW_PROFILE_GUIDLEN],
2385     szHwProfileName: [WCHAR; MAX_PROFILE_LEN],
2386 }}
2387 pub type LPHW_PROFILE_INFOW = *mut HW_PROFILE_INFOW;
2388 extern "system" {
GetCurrentHwProfileA( lpHwProfileInfo: LPHW_PROFILE_INFOA, ) -> BOOL2389     pub fn GetCurrentHwProfileA(
2390         lpHwProfileInfo: LPHW_PROFILE_INFOA,
2391     ) -> BOOL;
GetCurrentHwProfileW( lpHwProfileInfo: LPHW_PROFILE_INFOW, ) -> BOOL2392     pub fn GetCurrentHwProfileW(
2393         lpHwProfileInfo: LPHW_PROFILE_INFOW,
2394     ) -> BOOL;
VerifyVersionInfoA( lpVersionInformation: LPOSVERSIONINFOEXA, dwTypeMask: DWORD, dwlConditionMask: DWORDLONG, ) -> BOOL2395     pub fn VerifyVersionInfoA(
2396         lpVersionInformation: LPOSVERSIONINFOEXA,
2397         dwTypeMask: DWORD,
2398         dwlConditionMask: DWORDLONG,
2399     ) -> BOOL;
VerifyVersionInfoW( lpVersionInformation: LPOSVERSIONINFOEXW, dwTypeMask: DWORD, dwlConditionMask: DWORDLONG, ) -> BOOL2400     pub fn VerifyVersionInfoW(
2401         lpVersionInformation: LPOSVERSIONINFOEXW,
2402         dwTypeMask: DWORD,
2403         dwlConditionMask: DWORDLONG,
2404     ) -> BOOL;
2405 }
2406 STRUCT!{struct SYSTEM_POWER_STATUS {
2407     ACLineStatus: BYTE,
2408     BatteryFlag: BYTE,
2409     BatteryLifePercent: BYTE,
2410     Reserved1: BYTE,
2411     BatteryLifeTime: DWORD,
2412     BatteryFullLifeTime: DWORD,
2413 }}
2414 pub type LPSYSTEM_POWER_STATUS = *mut SYSTEM_POWER_STATUS;
2415 extern "system" {
GetSystemPowerStatus( lpSystemPowerStatus: LPSYSTEM_POWER_STATUS, ) -> BOOL2416     pub fn GetSystemPowerStatus(
2417         lpSystemPowerStatus: LPSYSTEM_POWER_STATUS,
2418     ) -> BOOL;
SetSystemPowerState( fSuspend: BOOL, fForce: BOOL, ) -> BOOL2419     pub fn SetSystemPowerState(
2420         fSuspend: BOOL,
2421         fForce: BOOL,
2422     ) -> BOOL;
MapUserPhysicalPagesScatter( VirtualAddresses: *mut PVOID, NumberOfPages: ULONG_PTR, PageArray: PULONG_PTR, ) -> BOOL2423     pub fn MapUserPhysicalPagesScatter(
2424         VirtualAddresses: *mut PVOID,
2425         NumberOfPages: ULONG_PTR,
2426         PageArray: PULONG_PTR,
2427     ) -> BOOL;
CreateJobObjectA( lpJobAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCSTR, ) -> HANDLE2428     pub fn CreateJobObjectA(
2429         lpJobAttributes: LPSECURITY_ATTRIBUTES,
2430         lpName: LPCSTR,
2431     ) -> HANDLE;
OpenJobObjectA( dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR, ) -> HANDLE2432     pub fn OpenJobObjectA(
2433         dwDesiredAccess: DWORD,
2434         bInheritHandle: BOOL,
2435         lpName: LPCSTR,
2436     ) -> HANDLE;
CreateJobSet( NumJob: ULONG, UserJobSet: PJOB_SET_ARRAY, Flags: ULONG, ) -> BOOL2437     pub fn CreateJobSet(
2438         NumJob: ULONG,
2439         UserJobSet: PJOB_SET_ARRAY,
2440         Flags: ULONG,
2441     ) -> BOOL;
FindFirstVolumeA( lpszVolumeName: LPSTR, cchBufferLength: DWORD, ) -> HANDLE2442     pub fn FindFirstVolumeA(
2443         lpszVolumeName: LPSTR,
2444         cchBufferLength: DWORD,
2445     ) -> HANDLE;
FindNextVolumeA( hFindVolume: HANDLE, lpszVolumeName: LPSTR, cchBufferLength: DWORD, ) -> BOOL2446     pub fn FindNextVolumeA(
2447         hFindVolume: HANDLE,
2448         lpszVolumeName: LPSTR,
2449         cchBufferLength: DWORD,
2450     ) -> BOOL;
FindFirstVolumeMountPointA( lpszRootPathName: LPCSTR, lpszVolumeMountPoint: LPSTR, cchBufferLength: DWORD, ) -> HANDLE2451     pub fn FindFirstVolumeMountPointA(
2452         lpszRootPathName: LPCSTR,
2453         lpszVolumeMountPoint: LPSTR,
2454         cchBufferLength: DWORD,
2455     ) -> HANDLE;
FindFirstVolumeMountPointW( lpszRootPathName: LPCWSTR, lpszVolumeMountPoint: LPWSTR, cchBufferLength: DWORD, ) -> HANDLE2456     pub fn FindFirstVolumeMountPointW(
2457         lpszRootPathName: LPCWSTR,
2458         lpszVolumeMountPoint: LPWSTR,
2459         cchBufferLength: DWORD,
2460     ) -> HANDLE;
FindNextVolumeMountPointA( hFindVolumeMountPoint: HANDLE, lpszVolumeMountPoint: LPSTR, cchBufferLength: DWORD, ) -> BOOL2461     pub fn FindNextVolumeMountPointA(
2462         hFindVolumeMountPoint: HANDLE,
2463         lpszVolumeMountPoint: LPSTR,
2464         cchBufferLength: DWORD,
2465     ) -> BOOL;
FindNextVolumeMountPointW( hFindVolumeMountPoint: HANDLE, lpszVolumeMountPoint: LPWSTR, cchBufferLength: DWORD, ) -> BOOL2466     pub fn FindNextVolumeMountPointW(
2467         hFindVolumeMountPoint: HANDLE,
2468         lpszVolumeMountPoint: LPWSTR,
2469         cchBufferLength: DWORD,
2470     ) -> BOOL;
FindVolumeMountPointClose( hFindVolumeMountPoint: HANDLE, ) -> BOOL2471     pub fn FindVolumeMountPointClose(
2472         hFindVolumeMountPoint: HANDLE,
2473     ) -> BOOL;
SetVolumeMountPointA( lpszVolumeMountPoint: LPCSTR, lpszVolumeName: LPCSTR, ) -> BOOL2474     pub fn SetVolumeMountPointA(
2475         lpszVolumeMountPoint: LPCSTR,
2476         lpszVolumeName: LPCSTR,
2477     ) -> BOOL;
SetVolumeMountPointW( lpszVolumeMountPoint: LPCWSTR, lpszVolumeName: LPCWSTR, ) -> BOOL2478     pub fn SetVolumeMountPointW(
2479         lpszVolumeMountPoint: LPCWSTR,
2480         lpszVolumeName: LPCWSTR,
2481     ) -> BOOL;
DeleteVolumeMountPointA( lpszVolumeMountPoint: LPCSTR, ) -> BOOL2482     pub fn DeleteVolumeMountPointA(
2483         lpszVolumeMountPoint: LPCSTR,
2484     ) -> BOOL;
GetVolumeNameForVolumeMountPointA( lpszVolumeMountPoint: LPCSTR, lpszVolumeName: LPSTR, cchBufferLength: DWORD, ) -> BOOL2485     pub fn GetVolumeNameForVolumeMountPointA(
2486         lpszVolumeMountPoint: LPCSTR,
2487         lpszVolumeName: LPSTR,
2488         cchBufferLength: DWORD,
2489     ) -> BOOL;
GetVolumePathNameA( lpszFileName: LPCSTR, lpszVolumePathName: LPSTR, cchBufferLength: DWORD, ) -> BOOL2490     pub fn GetVolumePathNameA(
2491         lpszFileName: LPCSTR,
2492         lpszVolumePathName: LPSTR,
2493         cchBufferLength: DWORD,
2494     ) -> BOOL;
GetVolumePathNamesForVolumeNameA( lpszVolumeName: LPCSTR, lpszVolumePathNames: LPCH, cchBufferLength: DWORD, lpcchReturnLength: PDWORD, ) -> BOOL2495     pub fn GetVolumePathNamesForVolumeNameA(
2496         lpszVolumeName: LPCSTR,
2497         lpszVolumePathNames: LPCH,
2498         cchBufferLength: DWORD,
2499         lpcchReturnLength: PDWORD,
2500     ) -> BOOL;
2501 }
2502 // ACTCTX_FLAG_*
2503 STRUCT!{struct ACTCTXA {
2504     cbSize: ULONG,
2505     dwFlags: DWORD,
2506     lpSource: LPCSTR,
2507     wProcessorArchitecture: USHORT,
2508     wLangId: LANGID,
2509     lpAssemblyDirectory: LPCSTR,
2510     lpResourceName: LPCSTR,
2511     lpApplicationName: LPCSTR,
2512     hModule: HMODULE,
2513 }}
2514 pub type PACTCTXA = *mut ACTCTXA;
2515 STRUCT!{struct ACTCTXW {
2516     cbSize: ULONG,
2517     dwFlags: DWORD,
2518     lpSource: LPCWSTR,
2519     wProcessorArchitecture: USHORT,
2520     wLangId: LANGID,
2521     lpAssemblyDirectory: LPCWSTR,
2522     lpResourceName: LPCWSTR,
2523     lpApplicationName: LPCWSTR,
2524     hModule: HMODULE,
2525 }}
2526 pub type PACTCTXW = *mut ACTCTXW;
2527 pub type PCACTCTXA = *const ACTCTXA;
2528 pub type PCACTCTXW = *const ACTCTXW;
2529 extern "system" {
CreateActCtxA( pActCtx: PCACTCTXA, ) -> HANDLE2530     pub fn CreateActCtxA(
2531         pActCtx: PCACTCTXA,
2532     ) -> HANDLE;
CreateActCtxW( pActCtx: PCACTCTXW, ) -> HANDLE2533     pub fn CreateActCtxW(
2534         pActCtx: PCACTCTXW,
2535     ) -> HANDLE;
AddRefActCtx( hActCtx: HANDLE, )2536     pub fn AddRefActCtx(
2537         hActCtx: HANDLE,
2538     );
ReleaseActCtx( hActCtx: HANDLE, )2539     pub fn ReleaseActCtx(
2540         hActCtx: HANDLE,
2541     );
ZombifyActCtx( hActCtx: HANDLE, ) -> BOOL2542     pub fn ZombifyActCtx(
2543         hActCtx: HANDLE,
2544     ) -> BOOL;
ActivateActCtx( hActCtx: HANDLE, lpCookie: *mut ULONG_PTR, ) -> BOOL2545     pub fn ActivateActCtx(
2546         hActCtx: HANDLE,
2547         lpCookie: *mut ULONG_PTR,
2548     ) -> BOOL;
DeactivateActCtx( dwFlags: DWORD, ulCookie: ULONG_PTR, ) -> BOOL2549     pub fn DeactivateActCtx(
2550         dwFlags: DWORD,
2551         ulCookie: ULONG_PTR,
2552     ) -> BOOL;
GetCurrentActCtx( lphActCtx: *mut HANDLE, ) -> BOOL2553     pub fn GetCurrentActCtx(
2554         lphActCtx: *mut HANDLE,
2555     ) -> BOOL;
2556 }
2557 STRUCT!{struct ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA {
2558     lpInformation: PVOID,
2559     lpSectionBase: PVOID,
2560     ulSectionLength: ULONG,
2561     lpSectionGlobalDataBase: PVOID,
2562     ulSectionGlobalDataLength: ULONG,
2563 }}
2564 pub type PACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA =
2565     *mut ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA;
2566 pub type PCACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA =
2567     *const ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA;
2568 STRUCT!{struct ACTCTX_SECTION_KEYED_DATA {
2569     cbSize: ULONG,
2570     ulDataFormatVersion: ULONG,
2571     lpData: PVOID,
2572     ulLength: ULONG,
2573     lpSectionGlobalData: PVOID,
2574     ulSectionGlobalDataLength: ULONG,
2575     lpSectionBase: PVOID,
2576     ulSectionTotalLength: ULONG,
2577     hActCtx: HANDLE,
2578     ulAssemblyRosterIndex: ULONG,
2579     ulFlags: ULONG,
2580     AssemblyMetadata: ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA,
2581 }}
2582 pub type PACTCTX_SECTION_KEYED_DATA = *mut ACTCTX_SECTION_KEYED_DATA;
2583 pub type PCACTCTX_SECTION_KEYED_DATA = *const ACTCTX_SECTION_KEYED_DATA;
2584 extern "system" {
FindActCtxSectionStringA( dwFlags: DWORD, lpExtensionGuid: *const GUID, ulSectionId: ULONG, lpStringToFind: LPCSTR, ReturnedData: PACTCTX_SECTION_KEYED_DATA, ) -> BOOL2585     pub fn FindActCtxSectionStringA(
2586         dwFlags: DWORD,
2587         lpExtensionGuid: *const GUID,
2588         ulSectionId: ULONG,
2589         lpStringToFind: LPCSTR,
2590         ReturnedData: PACTCTX_SECTION_KEYED_DATA,
2591     ) -> BOOL;
FindActCtxSectionStringW( dwFlags: DWORD, lpExtensionGuid: *const GUID, ulSectionId: ULONG, lpStringToFind: LPCWSTR, ReturnedData: PACTCTX_SECTION_KEYED_DATA, ) -> BOOL2592     pub fn FindActCtxSectionStringW(
2593         dwFlags: DWORD,
2594         lpExtensionGuid: *const GUID,
2595         ulSectionId: ULONG,
2596         lpStringToFind: LPCWSTR,
2597         ReturnedData: PACTCTX_SECTION_KEYED_DATA,
2598     ) -> BOOL;
FindActCtxSectionGuid( dwFlags: DWORD, lpExtensionGuid: *const GUID, ulSectionId: ULONG, lpGuidToFind: *const GUID, ReturnedData: PACTCTX_SECTION_KEYED_DATA, ) -> BOOL2599     pub fn FindActCtxSectionGuid(
2600         dwFlags: DWORD,
2601         lpExtensionGuid: *const GUID,
2602         ulSectionId: ULONG,
2603         lpGuidToFind: *const GUID,
2604         ReturnedData: PACTCTX_SECTION_KEYED_DATA,
2605     ) -> BOOL;
QueryActCtxW( dwFlags: DWORD, hActCtx: HANDLE, pvSubInstance: PVOID, ulInfoClass: ULONG, pvBuffer: PVOID, cbBuffer: SIZE_T, pcbWrittenOrRequired: *mut SIZE_T, ) -> BOOL2606     pub fn QueryActCtxW(
2607         dwFlags: DWORD,
2608         hActCtx: HANDLE,
2609         pvSubInstance: PVOID,
2610         ulInfoClass: ULONG,
2611         pvBuffer: PVOID,
2612         cbBuffer: SIZE_T,
2613         pcbWrittenOrRequired: *mut SIZE_T,
2614     ) -> BOOL;
WTSGetActiveConsoleSessionId() -> DWORD2615     pub fn WTSGetActiveConsoleSessionId() -> DWORD;
2616     // pub fn WTSGetServiceSessionId();
2617     // pub fn WTSIsServerContainer();
GetActiveProcessorGroupCount() -> WORD2618     pub fn GetActiveProcessorGroupCount() -> WORD;
GetMaximumProcessorGroupCount() -> WORD2619     pub fn GetMaximumProcessorGroupCount() -> WORD;
GetActiveProcessorCount( GroupNumber: WORD, ) -> DWORD2620     pub fn GetActiveProcessorCount(
2621         GroupNumber: WORD,
2622     ) -> DWORD;
GetMaximumProcessorCount( GroupNumber: WORD, ) -> DWORD2623     pub fn GetMaximumProcessorCount(
2624         GroupNumber: WORD,
2625     ) -> DWORD;
GetNumaProcessorNode( Processor: UCHAR, NodeNumber: PUCHAR, ) -> BOOL2626     pub fn GetNumaProcessorNode(
2627         Processor: UCHAR,
2628         NodeNumber: PUCHAR,
2629     ) -> BOOL;
GetNumaNodeNumberFromHandle( hFile: HANDLE, NodeNumber: PUSHORT, ) -> BOOL2630     pub fn GetNumaNodeNumberFromHandle(
2631         hFile: HANDLE,
2632         NodeNumber: PUSHORT,
2633     ) -> BOOL;
GetNumaProcessorNodeEx( Processor: PPROCESSOR_NUMBER, NodeNumber: PUSHORT, ) -> BOOL2634     pub fn GetNumaProcessorNodeEx(
2635         Processor: PPROCESSOR_NUMBER,
2636         NodeNumber: PUSHORT,
2637     ) -> BOOL;
GetNumaNodeProcessorMask( Node: UCHAR, ProcessorMask: PULONGLONG, ) -> BOOL2638     pub fn GetNumaNodeProcessorMask(
2639         Node: UCHAR,
2640         ProcessorMask: PULONGLONG,
2641     ) -> BOOL;
GetNumaAvailableMemoryNode( Node: UCHAR, AvailableBytes: PULONGLONG, ) -> BOOL2642     pub fn GetNumaAvailableMemoryNode(
2643         Node: UCHAR,
2644         AvailableBytes: PULONGLONG,
2645     ) -> BOOL;
GetNumaAvailableMemoryNodeEx( Node: USHORT, AvailableBytes: PULONGLONG, ) -> BOOL2646     pub fn GetNumaAvailableMemoryNodeEx(
2647         Node: USHORT,
2648         AvailableBytes: PULONGLONG,
2649     ) -> BOOL;
GetNumaProximityNode( ProximityId: ULONG, NodeNumber: PUCHAR, ) -> BOOL2650     pub fn GetNumaProximityNode(
2651         ProximityId: ULONG,
2652         NodeNumber: PUCHAR,
2653     ) -> BOOL;
2654 }
2655 FN!{stdcall APPLICATION_RECOVERY_CALLBACK(
2656     pvParameter: PVOID,
2657 ) -> DWORD}
2658 // RESTART_*
2659 // RECOVERY_*
2660 extern "system" {
RegisterApplicationRecoveryCallback( pRecoveyCallback: APPLICATION_RECOVERY_CALLBACK, pvParameter: PVOID, dwPingInterval: DWORD, dwFlags: DWORD, ) -> HRESULT2661     pub fn RegisterApplicationRecoveryCallback(
2662         pRecoveyCallback: APPLICATION_RECOVERY_CALLBACK,
2663         pvParameter: PVOID,
2664         dwPingInterval: DWORD,
2665         dwFlags: DWORD,
2666     ) -> HRESULT;
UnregisterApplicationRecoveryCallback() -> HRESULT2667     pub fn UnregisterApplicationRecoveryCallback() -> HRESULT;
RegisterApplicationRestart( pwzCommandline: PCWSTR, dwFlags: DWORD, ) -> HRESULT2668     pub fn RegisterApplicationRestart(
2669         pwzCommandline: PCWSTR,
2670         dwFlags: DWORD,
2671     ) -> HRESULT;
UnregisterApplicationRestart() -> HRESULT2672     pub fn UnregisterApplicationRestart() -> HRESULT;
GetApplicationRecoveryCallback( hProcess: HANDLE, pRecoveryCallback: *mut APPLICATION_RECOVERY_CALLBACK, ppvParameter: *mut PVOID, pdwPingInterval: PDWORD, pdwFlags: PDWORD, ) -> HRESULT2673     pub fn GetApplicationRecoveryCallback(
2674         hProcess: HANDLE,
2675         pRecoveryCallback: *mut APPLICATION_RECOVERY_CALLBACK,
2676         ppvParameter: *mut PVOID,
2677         pdwPingInterval: PDWORD,
2678         pdwFlags: PDWORD,
2679     ) -> HRESULT;
GetApplicationRestartSettings( hProcess: HANDLE, pwzCommandline: PWSTR, pcchSize: PDWORD, pdwFlags: PDWORD, ) -> HRESULT2680     pub fn GetApplicationRestartSettings(
2681         hProcess: HANDLE,
2682         pwzCommandline: PWSTR,
2683         pcchSize: PDWORD,
2684         pdwFlags: PDWORD,
2685     ) -> HRESULT;
ApplicationRecoveryInProgress( pbCancelled: PBOOL, ) -> HRESULT2686     pub fn ApplicationRecoveryInProgress(
2687         pbCancelled: PBOOL,
2688     ) -> HRESULT;
ApplicationRecoveryFinished( bSuccess: BOOL, )2689     pub fn ApplicationRecoveryFinished(
2690         bSuccess: BOOL,
2691     );
2692 }
2693 // FILE_BASIC_INFO, etc.
2694 extern "system" {
GetFileInformationByHandleEx( hFile: HANDLE, FileInformationClass: FILE_INFO_BY_HANDLE_CLASS, lpFileInformation: LPVOID, dwBufferSize: DWORD, ) -> BOOL2695     pub fn GetFileInformationByHandleEx(
2696         hFile: HANDLE,
2697         FileInformationClass: FILE_INFO_BY_HANDLE_CLASS,
2698         lpFileInformation: LPVOID,
2699         dwBufferSize: DWORD,
2700     ) -> BOOL;
2701 }
2702 ENUM!{enum FILE_ID_TYPE {
2703     FileIdType,
2704     ObjectIdType,
2705     ExtendedFileIdType,
2706     MaximumFileIdType,
2707 }}
2708 UNION!{union FILE_ID_DESCRIPTOR_u {
2709     [u64; 2],
2710     FileId FileId_mut: LARGE_INTEGER,
2711     ObjectId ObjectId_mut: GUID,
2712     ExtendedFileId ExtendedFileId_mut: FILE_ID_128,
2713 }}
2714 STRUCT!{struct FILE_ID_DESCRIPTOR {
2715     dwSize: DWORD,
2716     Type: FILE_ID_TYPE,
2717     u: FILE_ID_DESCRIPTOR_u,
2718 }}
2719 pub type LPFILE_ID_DESCRIPTOR = *mut FILE_ID_DESCRIPTOR;
2720 extern "system" {
OpenFileById( hVolumeHint: HANDLE, lpFileId: LPFILE_ID_DESCRIPTOR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwFlagsAndAttributes: DWORD, ) -> HANDLE2721     pub fn OpenFileById(
2722         hVolumeHint: HANDLE,
2723         lpFileId: LPFILE_ID_DESCRIPTOR,
2724         dwDesiredAccess: DWORD,
2725         dwShareMode: DWORD,
2726         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
2727         dwFlagsAndAttributes: DWORD,
2728     ) -> HANDLE;
CreateSymbolicLinkA( lpSymlinkFileName: LPCSTR, lpTargetFileName: LPCSTR, dwFlags: DWORD, ) -> BOOLEAN2729     pub fn CreateSymbolicLinkA(
2730         lpSymlinkFileName: LPCSTR,
2731         lpTargetFileName: LPCSTR,
2732         dwFlags: DWORD,
2733     ) -> BOOLEAN;
CreateSymbolicLinkW( lpSymlinkFileName: LPCWSTR, lpTargetFileName: LPCWSTR, dwFlags: DWORD, ) -> BOOLEAN2734     pub fn CreateSymbolicLinkW(
2735         lpSymlinkFileName: LPCWSTR,
2736         lpTargetFileName: LPCWSTR,
2737         dwFlags: DWORD,
2738     ) -> BOOLEAN;
QueryActCtxSettingsW( dwFlags: DWORD, hActCtx: HANDLE, settingsNameSpace: PCWSTR, settingName: PCWSTR, pvBuffer: PWSTR, dwBuffer: SIZE_T, pdwWrittenOrRequired: *mut SIZE_T, ) -> BOOL2739     pub fn QueryActCtxSettingsW(
2740         dwFlags: DWORD,
2741         hActCtx: HANDLE,
2742         settingsNameSpace: PCWSTR,
2743         settingName: PCWSTR,
2744         pvBuffer: PWSTR,
2745         dwBuffer: SIZE_T,
2746         pdwWrittenOrRequired: *mut SIZE_T,
2747     ) -> BOOL;
CreateSymbolicLinkTransactedA( lpSymlinkFileName: LPCSTR, lpTargetFileName: LPCSTR, dwFlags: DWORD, hTransaction: HANDLE, ) -> BOOLEAN2748     pub fn CreateSymbolicLinkTransactedA(
2749         lpSymlinkFileName: LPCSTR,
2750         lpTargetFileName: LPCSTR,
2751         dwFlags: DWORD,
2752         hTransaction: HANDLE,
2753     ) -> BOOLEAN;
CreateSymbolicLinkTransactedW( lpSymlinkFileName: LPCWSTR, lpTargetFileName: LPCWSTR, dwFlags: DWORD, hTransaction: HANDLE, ) -> BOOLEAN2754     pub fn CreateSymbolicLinkTransactedW(
2755         lpSymlinkFileName: LPCWSTR,
2756         lpTargetFileName: LPCWSTR,
2757         dwFlags: DWORD,
2758         hTransaction: HANDLE,
2759     ) -> BOOLEAN;
ReplacePartitionUnit( TargetPartition: PWSTR, SparePartition: PWSTR, Flags: ULONG, ) -> BOOL2760     pub fn ReplacePartitionUnit(
2761         TargetPartition: PWSTR,
2762         SparePartition: PWSTR,
2763         Flags: ULONG,
2764     ) -> BOOL;
AddSecureMemoryCacheCallback( pfnCallBack: PSECURE_MEMORY_CACHE_CALLBACK, ) -> BOOL2765     pub fn AddSecureMemoryCacheCallback(
2766         pfnCallBack: PSECURE_MEMORY_CACHE_CALLBACK,
2767     ) -> BOOL;
RemoveSecureMemoryCacheCallback( pfnCallBack: PSECURE_MEMORY_CACHE_CALLBACK, ) -> BOOL2768     pub fn RemoveSecureMemoryCacheCallback(
2769         pfnCallBack: PSECURE_MEMORY_CACHE_CALLBACK,
2770     ) -> BOOL;
CopyContext( Destination: PCONTEXT, ContextFlags: DWORD, Source: PCONTEXT, ) -> BOOL2771     pub fn CopyContext(
2772         Destination: PCONTEXT,
2773         ContextFlags: DWORD,
2774         Source: PCONTEXT,
2775     ) -> BOOL;
InitializeContext( Buffer: PVOID, ContextFlags: DWORD, Context: *mut PCONTEXT, ContextLength: PDWORD, ) -> BOOL2776     pub fn InitializeContext(
2777         Buffer: PVOID,
2778         ContextFlags: DWORD,
2779         Context: *mut PCONTEXT,
2780         ContextLength: PDWORD,
2781     ) -> BOOL;
GetEnabledXStateFeatures() -> DWORD642782     pub fn GetEnabledXStateFeatures() -> DWORD64;
GetXStateFeaturesMask( Context: PCONTEXT, FeatureMask: PDWORD64, ) -> BOOL2783     pub fn GetXStateFeaturesMask(
2784         Context: PCONTEXT,
2785         FeatureMask: PDWORD64,
2786     ) -> BOOL;
2787     #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
LocateXStateFeature( Context: PCONTEXT, FeatureId: DWORD, Length: PDWORD, ) -> PVOID2788     pub fn LocateXStateFeature(
2789         Context: PCONTEXT,
2790         FeatureId: DWORD,
2791         Length: PDWORD,
2792     ) -> PVOID;
2793     #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
SetXStateFeaturesMask( Context: PCONTEXT, FeatureMask: DWORD64, ) -> BOOL2794     pub fn SetXStateFeaturesMask(
2795         Context: PCONTEXT,
2796         FeatureMask: DWORD64,
2797     ) -> BOOL;
EnableThreadProfiling( ThreadHandle: HANDLE, Flags: DWORD, HardwareCounters: DWORD64, PerformanceDataHandle: *mut HANDLE, ) -> BOOL2798     pub fn EnableThreadProfiling(
2799         ThreadHandle: HANDLE,
2800         Flags: DWORD,
2801         HardwareCounters: DWORD64,
2802         PerformanceDataHandle: *mut HANDLE,
2803     ) -> BOOL;
DisableThreadProfiling( PerformanceDataHandle: HANDLE, ) -> DWORD2804     pub fn DisableThreadProfiling(
2805         PerformanceDataHandle: HANDLE,
2806     ) -> DWORD;
QueryThreadProfiling( ThreadHandle: HANDLE, Enabled: PBOOLEAN, ) -> DWORD2807     pub fn QueryThreadProfiling(
2808         ThreadHandle: HANDLE,
2809         Enabled: PBOOLEAN,
2810     ) -> DWORD;
ReadThreadProfilingData( PerformanceDataHandle: HANDLE, Flags: DWORD, PerformanceData: PPERFORMANCE_DATA, ) -> DWORD2811     pub fn ReadThreadProfilingData(
2812         PerformanceDataHandle: HANDLE,
2813         Flags: DWORD,
2814         PerformanceData: PPERFORMANCE_DATA,
2815     ) -> DWORD;
2816     // intrinsic InterlockedIncrement
2817     // intrinsic InterlockedDecrement
2818     // intrinsic InterlockedExchange
2819     // intrinsic InterlockedExchangeAdd
2820     // intrinsic InterlockedExchangeSubtract
2821     // intrinsic InterlockedCompareExchange
2822     // intrinsic InterlockedAnd
2823     // intrinsic InterlockedOr
2824     // intrinsic InterlockedXor
2825 }
2826