1 // Copyright © 2015-2017 winapi-rs developers
2 // Licensed under the Apache License, Version 2.0
3 // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
4 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
5 // All files in the project carrying such notice may not be copied, modified, or distributed
6 // except according to those terms.
7 //! This module defines the 32-Bit Windows Base APIs
8 use ctypes::{c_char, c_int, c_long, c_void};
9 use shared::basetsd::{
10     DWORD64, DWORD_PTR, LONG_PTR, PDWORD64, PDWORD_PTR, PSIZE_T, PULONG_PTR, SIZE_T, UINT_PTR,
11     ULONG_PTR,
12 };
13 use shared::guiddef::GUID;
14 use shared::minwindef::{
15     ATOM, BOOL, BYTE, DWORD, FARPROC, FILETIME, HFILE, HGLOBAL, HLOCAL, HMODULE, HRSRC, LPBOOL,
16     LPBYTE, LPCVOID, LPDWORD, LPFILETIME, LPVOID, LPWORD, PBOOL, PDWORD, PUCHAR, PULONG, PUSHORT,
17     UCHAR, UINT, ULONG, USHORT, WORD,
18 };
19 use shared::windef::HWND;
20 use um::cfgmgr32::MAX_PROFILE_LEN;
21 use um::fileapi::STREAM_INFO_LEVELS;
22 use um::libloaderapi::{
23     ENUMRESLANGPROCA, ENUMRESLANGPROCW, ENUMRESNAMEPROCA, ENUMRESTYPEPROCA, ENUMRESTYPEPROCW,
24 };
25 use um::minwinbase::{
26     FILE_INFO_BY_HANDLE_CLASS, FINDEX_INFO_LEVELS, FINDEX_SEARCH_OPS, GET_FILEEX_INFO_LEVELS,
27     LPOVERLAPPED, LPOVERLAPPED_COMPLETION_ROUTINE, LPSECURITY_ATTRIBUTES, PREASON_CONTEXT,
28 };
29 use um::processthreadsapi::{LPPROC_THREAD_ATTRIBUTE_LIST, LPSTARTUPINFOA, STARTUPINFOA, STARTUPINFOW};
30 use um::winnt::{
31     BOOLEAN, CHAR, DWORDLONG, EXECUTION_STATE, FILE_ID_128, HANDLE, HRESULT, INT, LANGID,
32     LARGE_INTEGER, LATENCY_TIME, LONG, LPCCH, LPCH, LPCSTR, LPCWSTR, LPOSVERSIONINFOEXA,
33     LPOSVERSIONINFOEXW, LPSTR, LPWSTR, MAXLONG, PBOOLEAN, PCONTEXT, PCWSTR, PFIRMWARE_TYPE,
34     PHANDLE, PIO_COUNTERS, PJOB_SET_ARRAY, PLUID, POWER_REQUEST_TYPE, PPERFORMANCE_DATA,
35     PPROCESSOR_NUMBER, PQUOTA_LIMITS, PRTL_UMS_SCHEDULER_ENTRY_POINT,
36     PSECURE_MEMORY_CACHE_CALLBACK, PSID, PSID_NAME_USE, PULONGLONG, PVOID, PWOW64_CONTEXT,
37     PWOW64_LDT_ENTRY, PWSTR, RTL_UMS_THREAD_INFO_CLASS, STATUS_ABANDONED_WAIT_0, STATUS_USER_APC,
38     STATUS_WAIT_0, SecurityAnonymous, SecurityDelegation, SecurityIdentification,
39     SecurityImpersonation, THREAD_BASE_PRIORITY_IDLE, THREAD_BASE_PRIORITY_LOWRT,
40     THREAD_BASE_PRIORITY_MAX, THREAD_BASE_PRIORITY_MIN, ULARGE_INTEGER, VOID, WAITORTIMERCALLBACK,
41     WCHAR, WOW64_CONTEXT,
42 };
43 #[cfg(target_arch = "x86")]
44 use um::winnt::PLDT_ENTRY;
45 use vc::vadefs::va_list;
46 pub const FILE_BEGIN: DWORD = 0;
47 pub const FILE_CURRENT: DWORD = 1;
48 pub const FILE_END: DWORD = 2;
49 pub const WAIT_FAILED: DWORD = 0xFFFFFFFF;
50 pub const WAIT_OBJECT_0: DWORD = STATUS_WAIT_0 as u32;
51 pub const WAIT_ABANDONED: DWORD = STATUS_ABANDONED_WAIT_0 as u32;
52 pub const WAIT_ABANDONED_0: DWORD = STATUS_ABANDONED_WAIT_0 as u32;
53 pub const WAIT_IO_COMPLETION: DWORD = STATUS_USER_APC as u32;
54 pub const FILE_FLAG_WRITE_THROUGH: DWORD = 0x80000000;
55 pub const FILE_FLAG_OVERLAPPED: DWORD = 0x40000000;
56 pub const FILE_FLAG_NO_BUFFERING: DWORD = 0x20000000;
57 pub const FILE_FLAG_RANDOM_ACCESS: DWORD = 0x10000000;
58 pub const FILE_FLAG_SEQUENTIAL_SCAN: DWORD = 0x08000000;
59 pub const FILE_FLAG_DELETE_ON_CLOSE: DWORD = 0x04000000;
60 pub const FILE_FLAG_BACKUP_SEMANTICS: DWORD = 0x02000000;
61 pub const FILE_FLAG_POSIX_SEMANTICS: DWORD = 0x01000000;
62 pub const FILE_FLAG_SESSION_AWARE: DWORD = 0x00800000;
63 pub const FILE_FLAG_OPEN_REPARSE_POINT: DWORD = 0x00200000;
64 pub const FILE_FLAG_OPEN_NO_RECALL: DWORD = 0x00100000;
65 pub const FILE_FLAG_FIRST_PIPE_INSTANCE: DWORD = 0x00080000;
66 pub const FILE_FLAG_OPEN_REQUIRING_OPLOCK: DWORD = 0x00040000;
67 pub const PROGRESS_CONTINUE: DWORD = 0;
68 pub const PROGRESS_CANCEL: DWORD = 1;
69 pub const PROGRESS_STOP: DWORD = 2;
70 pub const PROGRESS_QUIET: DWORD = 3;
71 pub const CALLBACK_CHUNK_FINISHED: DWORD = 0x00000000;
72 pub const CALLBACK_STREAM_SWITCH: DWORD = 0x00000001;
73 pub const COPY_FILE_FAIL_IF_EXISTS: DWORD = 0x00000001;
74 pub const COPY_FILE_RESTARTABLE: DWORD = 0x00000002;
75 pub const COPY_FILE_OPEN_SOURCE_FOR_WRITE: DWORD = 0x00000004;
76 pub const COPY_FILE_ALLOW_DECRYPTED_DESTINATION: DWORD = 0x00000008;
77 pub const COPY_FILE_COPY_SYMLINK: DWORD = 0x00000800;
78 pub const COPY_FILE_NO_BUFFERING: DWORD = 0x00001000;
79 pub const COPY_FILE_REQUEST_SECURITY_PRIVILEGES: DWORD = 0x00002000;
80 pub const COPY_FILE_RESUME_FROM_PAUSE: DWORD = 0x00004000;
81 pub const COPY_FILE_NO_OFFLOAD: DWORD = 0x00040000;
82 pub const COPY_FILE_IGNORE_EDP_BLOCK: DWORD = 0x00400000;
83 pub const COPY_FILE_IGNORE_SOURCE_ENCRYPTION: DWORD = 0x00800000;
84 pub const REPLACEFILE_WRITE_THROUGH: DWORD = 0x00000001;
85 pub const REPLACEFILE_IGNORE_MERGE_ERRORS: DWORD = 0x00000002;
86 pub const REPLACEFILE_IGNORE_ACL_ERRORS: DWORD = 0x00000004;
87 pub const PIPE_ACCESS_INBOUND: DWORD = 0x00000001;
88 pub const PIPE_ACCESS_OUTBOUND: DWORD = 0x00000002;
89 pub const PIPE_ACCESS_DUPLEX: DWORD = 0x00000003;
90 pub const PIPE_CLIENT_END: DWORD = 0x00000000;
91 pub const PIPE_SERVER_END: DWORD = 0x00000001;
92 pub const PIPE_WAIT: DWORD = 0x00000000;
93 pub const PIPE_NOWAIT: DWORD = 0x00000001;
94 pub const PIPE_READMODE_BYTE: DWORD = 0x00000000;
95 pub const PIPE_READMODE_MESSAGE: DWORD = 0x00000002;
96 pub const PIPE_TYPE_BYTE: DWORD = 0x00000000;
97 pub const PIPE_TYPE_MESSAGE: DWORD = 0x00000004;
98 pub const PIPE_ACCEPT_REMOTE_CLIENTS: DWORD = 0x00000000;
99 pub const PIPE_REJECT_REMOTE_CLIENTS: DWORD = 0x00000008;
100 pub const PIPE_UNLIMITED_INSTANCES: DWORD = 255;
101 pub const SECURITY_ANONYMOUS: DWORD = SecurityAnonymous << 16;
102 pub const SECURITY_IDENTIFICATION: DWORD = SecurityIdentification << 16;
103 pub const SECURITY_IMPERSONATION: DWORD = SecurityImpersonation << 16;
104 pub const SECURITY_DELEGATION: DWORD = SecurityDelegation << 16;
105 pub const SECURITY_CONTEXT_TRACKING: DWORD = 0x00040000;
106 pub const SECURITY_EFFECTIVE_ONLY: DWORD = 0x00080000;
107 pub const SECURITY_SQOS_PRESENT: DWORD = 0x00100000;
108 pub const SECURITY_VALID_SQOS_FLAGS: DWORD = 0x001F0000;
109 FN!{stdcall PFIBER_START_ROUTINE(
110     lpFiberParameter: LPVOID,
111 ) -> ()}
112 pub type LPFIBER_START_ROUTINE = PFIBER_START_ROUTINE;
113 FN!{stdcall PFIBER_CALLOUT_ROUTINE(
114     lpParameter: LPVOID,
115 ) -> LPVOID}
116 // FAIL_FAST_*
117 #[cfg(target_arch = "x86")]
118 pub type LPLDT_ENTRY = PLDT_ENTRY;
119 #[cfg(target_arch = "x86_64")]
120 pub type LPLDT_ENTRY = LPVOID; // TODO - fix this for 32-bit
121 //SP_SERIALCOMM
122 //PST_*
123 // PCF_*
124 // SP_*
125 // BAUD_*
126 // DATABITS_*
127 // STOPBITS_*
128 // PARITY_*
129 STRUCT!{struct COMMPROP {
130     wPacketLength: WORD,
131     wPacketVersion: WORD,
132     dwServiceMask: DWORD,
133     dwReserved1: DWORD,
134     dwMaxTxQueue: DWORD,
135     dwMaxRxQueue: DWORD,
136     dwMaxBaud: DWORD,
137     dwProvSubType: DWORD,
138     dwProvCapabilities: DWORD,
139     dwSettableParams: DWORD,
140     dwSettableBaud: DWORD,
141     wSettableData: WORD,
142     wSettableStopParity: WORD,
143     dwCurrentTxQueue: DWORD,
144     dwCurrentRxQueue: DWORD,
145     dwProvSpec1: DWORD,
146     dwProvSpec2: DWORD,
147     wcProvChar: [WCHAR; 1],
148 }}
149 pub type LPCOMMPROP = *mut COMMPROP;
150 STRUCT!{struct COMSTAT {
151     BitFields: DWORD,
152     cbInQue: DWORD,
153     cbOutQue: DWORD,
154 }}
155 BITFIELD!{COMSTAT BitFields: DWORD [
156     fCtsHold set_fCtsHold[0..1],
157     fDsrHold set_fDsrHold[1..2],
158     fRlsdHold set_fRlsdHold[2..3],
159     fXoffHold set_fXoffHold[3..4],
160     fXoffSent set_fXoffSent[4..5],
161     fEof set_fEof[5..6],
162     fTxim set_fTxim[6..7],
163     fReserved set_fReserved[7..32],
164 ]}
165 pub type LPCOMSTAT = *mut COMSTAT;
166 pub const DTR_CONTROL_DISABLE: DWORD = 0x00;
167 pub const DTR_CONTROL_ENABLE: DWORD = 0x01;
168 pub const DTR_CONTROL_HANDSHAKE: DWORD = 0x02;
169 pub const RTS_CONTROL_DISABLE: DWORD = 0x00;
170 pub const RTS_CONTROL_ENABLE: DWORD = 0x01;
171 pub const RTS_CONTROL_HANDSHAKE: DWORD = 0x02;
172 pub const RTS_CONTROL_TOGGLE: DWORD = 0x03;
173 STRUCT!{struct DCB {
174     DCBlength: DWORD,
175     BaudRate: DWORD,
176     BitFields: DWORD,
177     wReserved: WORD,
178     XonLim: WORD,
179     XoffLim: WORD,
180     ByteSize: BYTE,
181     Parity: BYTE,
182     StopBits: BYTE,
183     XonChar: c_char,
184     XoffChar: c_char,
185     ErrorChar: c_char,
186     EofChar: c_char,
187     EvtChar: c_char,
188     wReserved1: WORD,
189 }}
190 BITFIELD!{DCB BitFields: DWORD [
191     fBinary set_fBinary[0..1],
192     fParity set_fParity[1..2],
193     fOutxCtsFlow set_fOutxCtsFlow[2..3],
194     fOutxDsrFlow set_fOutxDsrFlow[3..4],
195     fDtrControl set_fDtrControl[4..6],
196     fDsrSensitivity set_fDsrSensitivity[6..7],
197     fTXContinueOnXoff set_fTXContinueOnXoff[7..8],
198     fOutX set_fOutX[8..9],
199     fInX set_fInX[9..10],
200     fErrorChar set_fErrorChar[10..11],
201     fNull set_fNull[11..12],
202     fRtsControl set_fRtsControl[12..14],
203     fAbortOnError set_fAbortOnError[14..15],
204     fDummy2 set_fDummy2[15..32],
205 ]}
206 pub type LPDCB = *mut DCB;
207 STRUCT!{struct COMMTIMEOUTS {
208     ReadIntervalTimeout: DWORD,
209     ReadTotalTimeoutMultiplier: DWORD,
210     ReadTotalTimeoutConstant: DWORD,
211     WriteTotalTimeoutMultiplier: DWORD,
212     WriteTotalTimeoutConstant: DWORD,
213 }}
214 pub type LPCOMMTIMEOUTS = *mut COMMTIMEOUTS;
215 STRUCT!{struct COMMCONFIG {
216     dwSize: DWORD,
217     wVersion: WORD,
218     wReserved: WORD,
219     dcb: DCB,
220     dwProviderSubType: DWORD,
221     dwProviderOffset: DWORD,
222     dwProviderSize: DWORD,
223     wcProviderData: [WCHAR; 1],
224 }}
225 pub type LPCOMMCONFIG = *mut COMMCONFIG;
226 // GMEM_*
227 STRUCT!{struct MEMORYSTATUS {
228     dwLength: DWORD,
229     dwMemoryLoad: DWORD,
230     dwTotalPhys: SIZE_T,
231     dwAvailPhys: SIZE_T,
232     dwTotalPageFile: SIZE_T,
233     dwAvailPageFile: SIZE_T,
234     dwTotalVirtual: SIZE_T,
235     dwAvailVirtual: SIZE_T,
236 }}
237 pub type LPMEMORYSTATUS = *mut MEMORYSTATUS;
238 // NUMA_NO_PREFERRED_NODE
239 pub const DEBUG_PROCESS: DWORD = 0x00000001;
240 pub const DEBUG_ONLY_THIS_PROCESS: DWORD = 0x00000002;
241 pub const CREATE_SUSPENDED: DWORD = 0x00000004;
242 pub const DETACHED_PROCESS: DWORD = 0x00000008;
243 pub const CREATE_NEW_CONSOLE: DWORD = 0x00000010;
244 pub const NORMAL_PRIORITY_CLASS: DWORD = 0x00000020;
245 pub const IDLE_PRIORITY_CLASS: DWORD = 0x00000040;
246 pub const HIGH_PRIORITY_CLASS: DWORD = 0x00000080;
247 pub const REALTIME_PRIORITY_CLASS: DWORD = 0x00000100;
248 pub const CREATE_NEW_PROCESS_GROUP: DWORD = 0x00000200;
249 pub const CREATE_UNICODE_ENVIRONMENT: DWORD = 0x00000400;
250 pub const CREATE_SEPARATE_WOW_VDM: DWORD = 0x00000800;
251 pub const CREATE_SHARED_WOW_VDM: DWORD = 0x00001000;
252 pub const CREATE_FORCEDOS: DWORD = 0x00002000;
253 pub const BELOW_NORMAL_PRIORITY_CLASS: DWORD = 0x00004000;
254 pub const ABOVE_NORMAL_PRIORITY_CLASS: DWORD = 0x00008000;
255 pub const INHERIT_PARENT_AFFINITY: DWORD = 0x00010000;
256 pub const INHERIT_CALLER_PRIORITY: DWORD = 0x00020000;
257 pub const CREATE_PROTECTED_PROCESS: DWORD = 0x00040000;
258 pub const EXTENDED_STARTUPINFO_PRESENT: DWORD = 0x00080000;
259 pub const PROCESS_MODE_BACKGROUND_BEGIN: DWORD = 0x00100000;
260 pub const PROCESS_MODE_BACKGROUND_END: DWORD = 0x00200000;
261 pub const CREATE_BREAKAWAY_FROM_JOB: DWORD = 0x01000000;
262 pub const CREATE_PRESERVE_CODE_AUTHZ_LEVEL: DWORD = 0x02000000;
263 pub const CREATE_DEFAULT_ERROR_MODE: DWORD = 0x04000000;
264 pub const CREATE_NO_WINDOW: DWORD = 0x08000000;
265 pub const PROFILE_USER: DWORD = 0x10000000;
266 pub const PROFILE_KERNEL: DWORD = 0x20000000;
267 pub const PROFILE_SERVER: DWORD = 0x40000000;
268 pub const CREATE_IGNORE_SYSTEM_DEFAULT: DWORD = 0x80000000;
269 // STACK_SIZE_PARAM_IS_A_RESERVATION
270 pub const THREAD_PRIORITY_LOWEST: DWORD = THREAD_BASE_PRIORITY_MIN;
271 pub const THREAD_PRIORITY_BELOW_NORMAL: DWORD = THREAD_PRIORITY_LOWEST + 1;
272 pub const THREAD_PRIORITY_NORMAL: DWORD = 0;
273 pub const THREAD_PRIORITY_HIGHEST: DWORD = THREAD_BASE_PRIORITY_MAX;
274 pub const THREAD_PRIORITY_ABOVE_NORMAL: DWORD = THREAD_PRIORITY_HIGHEST - 1;
275 pub const THREAD_PRIORITY_ERROR_RETURN: DWORD = MAXLONG as u32;
276 pub const THREAD_PRIORITY_TIME_CRITICAL: DWORD = THREAD_BASE_PRIORITY_LOWRT;
277 pub const THREAD_PRIORITY_IDLE: DWORD = THREAD_BASE_PRIORITY_IDLE;
278 pub const THREAD_MODE_BACKGROUND_BEGIN: DWORD = 0x00010000;
279 pub const THREAD_MODE_BACKGROUND_END: DWORD = 0x00020000;
280 pub const VOLUME_NAME_DOS: DWORD = 0x0;
281 // VOLUME_NAME_*
282 // FILE_NAME_*
283 // JIT_DEBUG_*
284 pub const DRIVE_UNKNOWN: DWORD = 0;
285 pub const DRIVE_NO_ROOT_DIR: DWORD = 1;
286 pub const DRIVE_REMOVABLE: DWORD = 2;
287 pub const DRIVE_FIXED: DWORD = 3;
288 pub const DRIVE_REMOTE: DWORD = 4;
289 pub const DRIVE_CDROM: DWORD = 5;
290 pub const DRIVE_RAMDISK: DWORD = 6;
291 // pub fn GetFreeSpace();
292 pub const FILE_TYPE_UNKNOWN: DWORD = 0x0000;
293 pub const FILE_TYPE_DISK: DWORD = 0x0001;
294 pub const FILE_TYPE_CHAR: DWORD = 0x0002;
295 pub const FILE_TYPE_PIPE: DWORD = 0x0003;
296 pub const FILE_TYPE_REMOTE: DWORD = 0x8000;
297 pub const STD_INPUT_HANDLE: DWORD = -10i32 as u32;
298 pub const STD_OUTPUT_HANDLE: DWORD = -11i32 as u32;
299 pub const STD_ERROR_HANDLE: DWORD = -12i32 as u32;
300 pub const NOPARITY: BYTE = 0;
301 pub const ODDPARITY: BYTE = 1;
302 pub const EVENPARITY: BYTE = 2;
303 pub const MARKPARITY: BYTE = 3;
304 pub const SPACEPARITY: BYTE = 4;
305 pub const ONESTOPBIT: BYTE = 0;
306 pub const ONE5STOPBITS: BYTE = 1;
307 pub const TWOSTOPBITS: BYTE = 2;
308 pub const IGNORE: DWORD = 0;
309 pub const INFINITE: DWORD = 0xFFFFFFFF;
310 pub const CBR_110: DWORD = 110;
311 pub const CBR_300: DWORD = 300;
312 pub const CBR_600: DWORD = 600;
313 pub const CBR_1200: DWORD = 1200;
314 pub const CBR_2400: DWORD = 2400;
315 pub const CBR_4800: DWORD = 4800;
316 pub const CBR_9600: DWORD = 9600;
317 pub const CBR_14400: DWORD = 14400;
318 pub const CBR_19200: DWORD = 19200;
319 pub const CBR_38400: DWORD = 38400;
320 pub const CBR_56000: DWORD = 56000;
321 pub const CBR_57600: DWORD = 57600;
322 pub const CBR_115200: DWORD = 115200;
323 pub const CBR_128000: DWORD = 128000;
324 pub const CBR_256000: DWORD = 256000;
325 // CE_*
326 // IE_*
327 // EV_*
328 pub const SETXOFF: DWORD = 1;
329 pub const SETXON: DWORD = 2;
330 pub const SETRTS: DWORD = 3;
331 pub const CLRRTS: DWORD = 4;
332 pub const SETDTR: DWORD = 5;
333 pub const CLRDTR: DWORD = 6;
334 pub const RESETDEV: DWORD = 7;
335 pub const SETBREAK: DWORD = 8;
336 pub const CLRBREAK: DWORD = 9;
337 pub const PURGE_TXABORT: DWORD = 0x0001;
338 pub const PURGE_RXABORT: DWORD = 0x0002;
339 pub const PURGE_TXCLEAR: DWORD = 0x0004;
340 pub const PURGE_RXCLEAR: DWORD = 0x0008;
341 pub const MS_CTS_ON: DWORD = 0x0010;
342 pub const MS_DSR_ON: DWORD = 0x0020;
343 pub const MS_RING_ON: DWORD = 0x0040;
344 pub const MS_RLSD_ON: DWORD = 0x0080;
345 // S_*
346 // NMPWAIT_*
347 // FS_*
348 // OF_*
349 pub const OFS_MAXPATHNAME: usize = 128;
350 STRUCT!{struct OFSTRUCT {
351     cBytes: BYTE,
352     fFixedDisk: BYTE,
353     nErrCode: WORD,
354     Reserved1: WORD,
355     Reserved2: WORD,
356     szPathName: [CHAR; OFS_MAXPATHNAME],
357 }}
358 pub type POFSTRUCT = *mut OFSTRUCT;
359 pub type LPOFSTRUCT = *mut OFSTRUCT;
360 extern "system" {
GlobalAlloc( uFlags: UINT, dwBytes: SIZE_T ) -> HGLOBAL361     pub fn GlobalAlloc(
362         uFlags: UINT,
363         dwBytes: SIZE_T
364     ) -> HGLOBAL;
GlobalReAlloc( hMem: HGLOBAL, dwBytes: SIZE_T, uFlags: UINT ) -> HGLOBAL365     pub fn GlobalReAlloc(
366         hMem: HGLOBAL,
367         dwBytes: SIZE_T,
368         uFlags: UINT
369     ) -> HGLOBAL;
GlobalSize( hMem: HGLOBAL ) -> SIZE_T370     pub fn GlobalSize(
371         hMem: HGLOBAL
372     ) -> SIZE_T;
GlobalFlags( hMem: HGLOBAL ) -> UINT373     pub fn GlobalFlags(
374         hMem: HGLOBAL
375     ) -> UINT;
GlobalLock( hMem: HGLOBAL ) -> LPVOID376     pub fn GlobalLock(
377         hMem: HGLOBAL
378     ) -> LPVOID;
GlobalHandle( pMem: LPCVOID ) -> HGLOBAL379     pub fn GlobalHandle(
380         pMem: LPCVOID
381     ) -> HGLOBAL;
GlobalUnlock( hMem: HGLOBAL ) -> BOOL382     pub fn GlobalUnlock(
383         hMem: HGLOBAL
384     ) -> BOOL;
GlobalFree( hMem: HGLOBAL ) -> HGLOBAL385     pub fn GlobalFree(
386         hMem: HGLOBAL
387     ) -> HGLOBAL;
GlobalCompact( dwMinFree: DWORD ) -> SIZE_T388     pub fn GlobalCompact(
389         dwMinFree: DWORD
390     ) -> SIZE_T;
GlobalFix( hMem: HGLOBAL )391     pub fn GlobalFix(
392         hMem: HGLOBAL
393     );
GlobalUnfix( hMem: HGLOBAL )394     pub fn GlobalUnfix(
395         hMem: HGLOBAL
396     );
GlobalWire( hMem: HGLOBAL ) -> LPVOID397     pub fn GlobalWire(
398         hMem: HGLOBAL
399     ) -> LPVOID;
GlobalUnWire( hMem: HGLOBAL ) -> BOOL400     pub fn GlobalUnWire(
401         hMem: HGLOBAL
402     ) -> BOOL;
GlobalMemoryStatus( lpBuffer: LPMEMORYSTATUS )403     pub fn GlobalMemoryStatus(
404         lpBuffer: LPMEMORYSTATUS
405     );
LocalAlloc( uFlags: UINT, uBytes: SIZE_T ) -> HLOCAL406     pub fn LocalAlloc(
407         uFlags: UINT,
408         uBytes: SIZE_T
409     ) -> HLOCAL;
LocalReAlloc( hMem: HLOCAL, uBytes: SIZE_T, uFlags: UINT ) -> HLOCAL410     pub fn LocalReAlloc(
411         hMem: HLOCAL,
412         uBytes: SIZE_T,
413         uFlags: UINT
414     ) -> HLOCAL;
LocalLock( hMem: HLOCAL ) -> LPVOID415     pub fn LocalLock(
416         hMem: HLOCAL
417     ) -> LPVOID;
LocalHandle( pMem: LPCVOID ) -> HLOCAL418     pub fn LocalHandle(
419         pMem: LPCVOID
420     ) -> HLOCAL;
LocalUnlock( hMem: HLOCAL ) -> BOOL421     pub fn LocalUnlock(
422         hMem: HLOCAL
423     ) -> BOOL;
LocalSize( hMem: HLOCAL ) -> SIZE_T424     pub fn LocalSize(
425         hMem: HLOCAL
426     ) -> SIZE_T;
LocalFlags( hMem: HLOCAL, ) -> UINT427     pub fn LocalFlags(
428         hMem: HLOCAL,
429     ) -> UINT;
LocalFree( hMem: HLOCAL ) -> HLOCAL430     pub fn LocalFree(
431         hMem: HLOCAL
432     ) -> HLOCAL;
LocalShrink( hMem: HLOCAL, cbNewSize: UINT ) -> SIZE_T433     pub fn LocalShrink(
434         hMem: HLOCAL,
435         cbNewSize: UINT
436     ) -> SIZE_T;
LocalCompact( uMinFree: UINT ) -> SIZE_T437     pub fn LocalCompact(
438         uMinFree: UINT
439     ) -> SIZE_T;
440 }
441 // SCS_*
442 extern "system" {
GetBinaryTypeA( lpApplicationName: LPCSTR, lpBinaryType: LPDWORD ) -> BOOL443     pub fn GetBinaryTypeA(
444         lpApplicationName: LPCSTR,
445         lpBinaryType: LPDWORD
446     ) -> BOOL;
GetBinaryTypeW( lpApplicationName: LPCWSTR, lpBinaryType: LPDWORD ) -> BOOL447     pub fn GetBinaryTypeW(
448         lpApplicationName: LPCWSTR,
449         lpBinaryType: LPDWORD
450     ) -> BOOL;
GetShortPathNameA( lpszLongPath: LPCSTR, lpszShortPath: LPSTR, cchBuffer: DWORD, ) -> DWORD451     pub fn GetShortPathNameA(
452         lpszLongPath: LPCSTR,
453         lpszShortPath: LPSTR,
454         cchBuffer: DWORD,
455     ) -> DWORD;
GetLongPathNameTransactedA( lpszShortPath: LPCSTR, lpszLongPath: LPSTR, cchBuffer: DWORD, hTransaction: HANDLE, ) -> DWORD456     pub fn GetLongPathNameTransactedA(
457         lpszShortPath: LPCSTR,
458         lpszLongPath: LPSTR,
459         cchBuffer: DWORD,
460         hTransaction: HANDLE,
461     ) -> DWORD;
GetLongPathNameTransactedW( lpszShortPath: LPCWSTR, lpszLongPath: LPWSTR, cchBuffer: DWORD, hTransaction: HANDLE, ) -> DWORD462     pub fn GetLongPathNameTransactedW(
463         lpszShortPath: LPCWSTR,
464         lpszLongPath: LPWSTR,
465         cchBuffer: DWORD,
466         hTransaction: HANDLE,
467     ) -> DWORD;
GetProcessAffinityMask( hProcess: HANDLE, lpProcessAffinityMask: PDWORD_PTR, lpSystemAffinityMask: PDWORD_PTR, ) -> BOOL468     pub fn GetProcessAffinityMask(
469         hProcess: HANDLE,
470         lpProcessAffinityMask: PDWORD_PTR,
471         lpSystemAffinityMask: PDWORD_PTR,
472     ) -> BOOL;
SetProcessAffinityMask( hProcess: HANDLE, dwProcessAffinityMask: DWORD ) -> BOOL473     pub fn SetProcessAffinityMask(
474         hProcess: HANDLE,
475         dwProcessAffinityMask: DWORD
476     ) -> BOOL;
GetProcessIoCounters( hProcess: HANDLE, lpIoCounters: PIO_COUNTERS ) -> BOOL477     pub fn GetProcessIoCounters(
478         hProcess: HANDLE,
479         lpIoCounters: PIO_COUNTERS
480     ) -> BOOL;
GetProcessWorkingSetSize( hProcess: HANDLE, lpMinimumWorkingSetSize: PSIZE_T, lpMaximumWorkingSetSize: PSIZE_T, ) -> BOOL481     pub fn GetProcessWorkingSetSize(
482         hProcess: HANDLE,
483         lpMinimumWorkingSetSize: PSIZE_T,
484         lpMaximumWorkingSetSize: PSIZE_T,
485     ) -> BOOL;
SetProcessWorkingSetSize( hProcess: HANDLE, dwMinimumWorkingSetSize: SIZE_T, dwMaximumWorkingSetSize: SIZE_T, ) -> BOOL486     pub fn SetProcessWorkingSetSize(
487         hProcess: HANDLE,
488         dwMinimumWorkingSetSize: SIZE_T,
489         dwMaximumWorkingSetSize: SIZE_T,
490     ) -> BOOL;
FatalExit( ExitCode: c_int )491     pub fn FatalExit(
492         ExitCode: c_int
493     );
SetEnvironmentStringsA( NewEnvironment: LPCH ) -> BOOL494     pub fn SetEnvironmentStringsA(
495         NewEnvironment: LPCH
496     ) -> BOOL;
SwitchToFiber( lpFiber: LPVOID )497     pub fn SwitchToFiber(
498         lpFiber: LPVOID
499     );
DeleteFiber( lpFiber: LPVOID )500     pub fn DeleteFiber(
501         lpFiber: LPVOID
502     );
ConvertFiberToThread() -> BOOL503     pub fn ConvertFiberToThread() -> BOOL;
CreateFiberEx( dwStackCommitSize: SIZE_T, dwStackReserveSize: SIZE_T, dwFlags: DWORD, lpStartAddress: LPFIBER_START_ROUTINE, lpParameter: LPVOID, ) -> LPVOID504     pub fn CreateFiberEx(
505         dwStackCommitSize: SIZE_T,
506         dwStackReserveSize: SIZE_T,
507         dwFlags: DWORD,
508         lpStartAddress: LPFIBER_START_ROUTINE,
509         lpParameter: LPVOID,
510     ) -> LPVOID;
ConvertThreadToFiberEx( lpParameter: LPVOID, dwFlags: DWORD ) -> LPVOID511     pub fn ConvertThreadToFiberEx(
512         lpParameter: LPVOID,
513         dwFlags: DWORD
514     ) -> LPVOID;
CreateFiber( dwStackSize: SIZE_T, lpStartAddress: LPFIBER_START_ROUTINE, lpParameter: LPVOID, ) -> LPVOID515     pub fn CreateFiber(
516         dwStackSize: SIZE_T,
517         lpStartAddress: LPFIBER_START_ROUTINE,
518         lpParameter: LPVOID,
519     ) -> LPVOID;
ConvertThreadToFiber( lpParameter: LPVOID ) -> LPVOID520     pub fn ConvertThreadToFiber(
521         lpParameter: LPVOID
522     ) -> LPVOID;
523 }
524 pub type PUMS_CONTEXT = *mut c_void;
525 pub type PUMS_COMPLETION_LIST = *mut c_void;
526 pub type UMS_THREAD_INFO_CLASS = RTL_UMS_THREAD_INFO_CLASS;
527 pub type PUMS_THREAD_INFO_CLASS = *mut UMS_THREAD_INFO_CLASS;
528 pub type PUMS_SCHEDULER_ENTRY_POINT = PRTL_UMS_SCHEDULER_ENTRY_POINT;
529 STRUCT!{struct UMS_SCHEDULER_STARTUP_INFO {
530     UmsVersion: ULONG,
531     CompletionList: PUMS_COMPLETION_LIST,
532     SchedulerProc: PUMS_SCHEDULER_ENTRY_POINT,
533     SchedulerParam: PVOID,
534 }}
535 pub type PUMS_SCHEDULER_STARTUP_INFO = *mut UMS_SCHEDULER_STARTUP_INFO;
536 STRUCT!{struct UMS_SYSTEM_THREAD_INFORMATION {
537     UmsVersion: ULONG,
538     ThreadUmsFlags: ULONG,
539 }}
540 BITFIELD!{UMS_SYSTEM_THREAD_INFORMATION ThreadUmsFlags: ULONG [
541     IsUmsSchedulerThread set_IsUmsSchedulerThread[0..1],
542     IsUmsWorkerThread set_IsUmsWorkerThread[1..2],
543 ]}
544 pub type PUMS_SYSTEM_THREAD_INFORMATION = *mut UMS_SYSTEM_THREAD_INFORMATION;
545 extern "system" {
546     #[cfg(target_arch = "x86_64")]
CreateUmsCompletionList( UmsCompletionList: *mut PUMS_COMPLETION_LIST ) -> BOOL547     pub fn CreateUmsCompletionList(
548         UmsCompletionList: *mut PUMS_COMPLETION_LIST
549     ) -> BOOL;
550     #[cfg(target_arch = "x86_64")]
DequeueUmsCompletionListItems( UmsCompletionList: PUMS_COMPLETION_LIST, WaitTimeOut: DWORD, UmsThreadList: *mut PUMS_CONTEXT, ) -> BOOL551     pub fn DequeueUmsCompletionListItems(
552         UmsCompletionList: PUMS_COMPLETION_LIST,
553         WaitTimeOut: DWORD,
554         UmsThreadList: *mut PUMS_CONTEXT,
555     ) -> BOOL;
556     #[cfg(target_arch = "x86_64")]
GetUmsCompletionListEvent( UmsCompletionList: PUMS_COMPLETION_LIST, UmsCompletionEvent: PHANDLE, ) -> BOOL557     pub fn GetUmsCompletionListEvent(
558         UmsCompletionList: PUMS_COMPLETION_LIST,
559         UmsCompletionEvent: PHANDLE,
560     ) -> BOOL;
561     #[cfg(target_arch = "x86_64")]
ExecuteUmsThread( UmsThread: PUMS_CONTEXT ) -> BOOL562     pub fn ExecuteUmsThread(
563         UmsThread: PUMS_CONTEXT
564     ) -> BOOL;
565     #[cfg(target_arch = "x86_64")]
UmsThreadYield( SchedulerParam: PVOID ) -> BOOL566     pub fn UmsThreadYield(
567         SchedulerParam: PVOID
568     ) -> BOOL;
569     #[cfg(target_arch = "x86_64")]
DeleteUmsCompletionList( UmsCompletionList: PUMS_COMPLETION_LIST ) -> BOOL570     pub fn DeleteUmsCompletionList(
571         UmsCompletionList: PUMS_COMPLETION_LIST
572     ) -> BOOL;
573     #[cfg(target_arch = "x86_64")]
GetCurrentUmsThread() -> PUMS_CONTEXT574     pub fn GetCurrentUmsThread() -> PUMS_CONTEXT;
575     #[cfg(target_arch = "x86_64")]
GetNextUmsListItem( UmsContext: PUMS_CONTEXT ) -> PUMS_CONTEXT576     pub fn GetNextUmsListItem(
577         UmsContext: PUMS_CONTEXT
578     ) -> PUMS_CONTEXT;
579     #[cfg(target_arch = "x86_64")]
QueryUmsThreadInformation( UmsThread: PUMS_CONTEXT, UmsThreadInfoClass: UMS_THREAD_INFO_CLASS, UmsThreadInformation: PVOID, UmsThreadInformationLength: ULONG, ReturnLength: PULONG, ) -> BOOL580     pub fn QueryUmsThreadInformation(
581         UmsThread: PUMS_CONTEXT,
582         UmsThreadInfoClass: UMS_THREAD_INFO_CLASS,
583         UmsThreadInformation: PVOID,
584         UmsThreadInformationLength: ULONG,
585         ReturnLength: PULONG,
586     ) -> BOOL;
587     #[cfg(target_arch = "x86_64")]
SetUmsThreadInformation( UmsThread: PUMS_CONTEXT, UmsThreadInfoClass: UMS_THREAD_INFO_CLASS, UmsThreadInformation: PVOID, UmsThreadInformationLength: ULONG, ) -> BOOL588     pub fn SetUmsThreadInformation(
589         UmsThread: PUMS_CONTEXT,
590         UmsThreadInfoClass: UMS_THREAD_INFO_CLASS,
591         UmsThreadInformation: PVOID,
592         UmsThreadInformationLength: ULONG,
593     ) -> BOOL;
594     #[cfg(target_arch = "x86_64")]
DeleteUmsThreadContext( UmsThread: PUMS_CONTEXT ) -> BOOL595     pub fn DeleteUmsThreadContext(
596         UmsThread: PUMS_CONTEXT
597     ) -> BOOL;
598     #[cfg(target_arch = "x86_64")]
CreateUmsThreadContext( lpUmsThread: *mut PUMS_CONTEXT ) -> BOOL599     pub fn CreateUmsThreadContext(
600         lpUmsThread: *mut PUMS_CONTEXT
601     ) -> BOOL;
602     #[cfg(target_arch = "x86_64")]
EnterUmsSchedulingMode( SchedulerStartupInfo: PUMS_SCHEDULER_STARTUP_INFO ) -> BOOL603     pub fn EnterUmsSchedulingMode(
604         SchedulerStartupInfo: PUMS_SCHEDULER_STARTUP_INFO
605     ) -> BOOL;
606     #[cfg(target_arch = "x86_64")]
GetUmsSystemThreadInformation( ThreadHandle: HANDLE, SystemThreadInfo: PUMS_SYSTEM_THREAD_INFORMATION, ) -> BOOL607     pub fn GetUmsSystemThreadInformation(
608         ThreadHandle: HANDLE,
609         SystemThreadInfo: PUMS_SYSTEM_THREAD_INFORMATION,
610     ) -> BOOL;
SetThreadAffinityMask( hThread: HANDLE, dwThreadAffinityMask: DWORD_PTR ) -> DWORD_PTR611     pub fn SetThreadAffinityMask(
612         hThread: HANDLE,
613         dwThreadAffinityMask: DWORD_PTR
614     ) -> DWORD_PTR;
SetProcessDEPPolicy( dwFlags: DWORD ) -> BOOL615     pub fn SetProcessDEPPolicy(
616         dwFlags: DWORD
617     ) -> BOOL;
GetProcessDEPPolicy( hProcess: HANDLE, lpFlags: LPDWORD, lpPermanent: PBOOL ) -> BOOL618     pub fn GetProcessDEPPolicy(
619         hProcess: HANDLE,
620         lpFlags: LPDWORD,
621         lpPermanent: PBOOL
622     ) -> BOOL;
RequestWakeupLatency( latency: LATENCY_TIME ) -> BOOL623     pub fn RequestWakeupLatency(
624         latency: LATENCY_TIME
625     ) -> BOOL;
IsSystemResumeAutomatic() -> BOOL626     pub fn IsSystemResumeAutomatic() -> BOOL;
GetThreadSelectorEntry( hThread: HANDLE, dwSelector: DWORD, lpSelectorEntry: LPLDT_ENTRY, ) -> BOOL627     pub fn GetThreadSelectorEntry(
628         hThread: HANDLE,
629         dwSelector: DWORD,
630         lpSelectorEntry: LPLDT_ENTRY,
631     ) -> BOOL;
SetThreadExecutionState( esFlags: EXECUTION_STATE ) -> EXECUTION_STATE632     pub fn SetThreadExecutionState(
633         esFlags: EXECUTION_STATE
634     ) -> EXECUTION_STATE;
PowerCreateRequest( Context: PREASON_CONTEXT ) -> HANDLE635     pub fn PowerCreateRequest(
636         Context: PREASON_CONTEXT
637     ) -> HANDLE;
PowerSetRequest( PowerRequest: HANDLE, RequestType: POWER_REQUEST_TYPE ) -> BOOL638     pub fn PowerSetRequest(
639         PowerRequest: HANDLE,
640         RequestType: POWER_REQUEST_TYPE
641     ) -> BOOL;
PowerClearRequest( PowerRequest: HANDLE, RequestType: POWER_REQUEST_TYPE ) -> BOOL642     pub fn PowerClearRequest(
643         PowerRequest: HANDLE,
644         RequestType: POWER_REQUEST_TYPE
645     ) -> BOOL;
RestoreLastError( dwErrCode: DWORD )646     pub fn RestoreLastError(
647         dwErrCode: DWORD
648     );
SetFileCompletionNotificationModes( FileHandle: HANDLE, Flags: UCHAR ) -> BOOL649     pub fn SetFileCompletionNotificationModes(
650         FileHandle: HANDLE,
651         Flags: UCHAR
652     ) -> BOOL;
653 }
654 pub const SEM_FAILCRITICALERRORS: UINT = 0x0001;
655 pub const SEM_NOGPFAULTERRORBOX: UINT = 0x0002;
656 pub const SEM_NOALIGNMENTFAULTEXCEPT: UINT = 0x0004;
657 pub const SEM_NOOPENFILEERRORBOX: UINT = 0x8000;
658 extern "system" {
Wow64GetThreadContext( hThread: HANDLE, lpContext: PWOW64_CONTEXT ) -> BOOL659     pub fn Wow64GetThreadContext(
660         hThread: HANDLE,
661         lpContext: PWOW64_CONTEXT
662     ) -> BOOL;
Wow64SetThreadContext( hThread: HANDLE, lpContext: *const WOW64_CONTEXT ) -> BOOL663     pub fn Wow64SetThreadContext(
664         hThread: HANDLE,
665         lpContext: *const WOW64_CONTEXT
666     ) -> BOOL;
Wow64GetThreadSelectorEntry( hThread: HANDLE, dwSelector: DWORD, lpSelectorEntry: PWOW64_LDT_ENTRY, ) -> BOOL667     pub fn Wow64GetThreadSelectorEntry(
668         hThread: HANDLE,
669         dwSelector: DWORD,
670         lpSelectorEntry: PWOW64_LDT_ENTRY,
671     ) -> BOOL;
Wow64SuspendThread( hThread: HANDLE ) -> DWORD672     pub fn Wow64SuspendThread(
673         hThread: HANDLE
674     ) -> DWORD;
DebugSetProcessKillOnExit( KillOnExit: BOOL ) -> BOOL675     pub fn DebugSetProcessKillOnExit(
676         KillOnExit: BOOL
677     ) -> BOOL;
DebugBreakProcess( Process: HANDLE ) -> BOOL678     pub fn DebugBreakProcess(
679         Process: HANDLE
680     ) -> BOOL;
PulseEvent( hEvent: HANDLE ) -> BOOL681     pub fn PulseEvent(
682         hEvent: HANDLE
683     ) -> BOOL;
GlobalDeleteAtom( nAtom: ATOM ) -> ATOM684     pub fn GlobalDeleteAtom(
685         nAtom: ATOM
686     ) -> ATOM;
InitAtomTable( nSize: DWORD ) -> BOOL687     pub fn InitAtomTable(
688         nSize: DWORD
689     ) -> BOOL;
DeleteAtom( nAtom: ATOM ) -> ATOM690     pub fn DeleteAtom(
691         nAtom: ATOM
692     ) -> ATOM;
SetHandleCount( uNumber: UINT ) -> UINT693     pub fn SetHandleCount(
694         uNumber: UINT
695     ) -> UINT;
RequestDeviceWakeup( hDevice: HANDLE ) -> BOOL696     pub fn RequestDeviceWakeup(
697         hDevice: HANDLE
698     ) -> BOOL;
CancelDeviceWakeupRequest( hDevice: HANDLE ) -> BOOL699     pub fn CancelDeviceWakeupRequest(
700         hDevice: HANDLE
701     ) -> BOOL;
GetDevicePowerState( hDevice: HANDLE, pfOn: *mut BOOL ) -> BOOL702     pub fn GetDevicePowerState(
703         hDevice: HANDLE,
704         pfOn: *mut BOOL
705     ) -> BOOL;
SetMessageWaitingIndicator( hMsgIndicator: HANDLE, ulMsgCount: ULONG ) -> BOOL706     pub fn SetMessageWaitingIndicator(
707         hMsgIndicator: HANDLE,
708         ulMsgCount: ULONG
709     ) -> BOOL;
SetFileShortNameA( hFile: HANDLE, lpShortName: LPCSTR ) -> BOOL710     pub fn SetFileShortNameA(
711         hFile: HANDLE,
712         lpShortName: LPCSTR
713     ) -> BOOL;
SetFileShortNameW( hFile: HANDLE, lpShortName: LPCWSTR ) -> BOOL714     pub fn SetFileShortNameW(
715         hFile: HANDLE,
716         lpShortName: LPCWSTR
717     ) -> BOOL;
718 }
719 pub const HANDLE_FLAG_INHERIT: DWORD = 0x00000001;
720 pub const HANDLE_FLAG_PROTECT_FROM_CLOSE: DWORD = 0x00000002;
721 extern "system" {
LoadModule( lpModuleName: LPCSTR, lpParameterBlock: LPVOID ) -> DWORD722     pub fn LoadModule(
723         lpModuleName: LPCSTR,
724         lpParameterBlock: LPVOID
725     ) -> DWORD;
WinExec( lpCmdLine: LPCSTR, uCmdShow: UINT ) -> UINT726     pub fn WinExec(
727         lpCmdLine: LPCSTR,
728         uCmdShow: UINT
729     ) -> UINT;
730     // ClearCommBreak
731     // ClearCommError
732     // SetupComm
733     // EscapeCommFunction
734     // GetCommConfig
735     // GetCommMask
736     // GetCommProperties
737     // GetCommModemStatus
738     // GetCommState
739     // GetCommTimeouts
740     // PurgeComm
741     // SetCommBreak
742     // SetCommConfig
743     // SetCommMask
744     // SetCommState
745     // SetCommTimeouts
746     // TransmitCommChar
747     // WaitCommEvent
SetTapePosition( hDevice: HANDLE, dwPositionMethod: DWORD, dwPartition: DWORD, dwOffsetLow: DWORD, dwOffsetHigh: DWORD, bImmediate: BOOL ) -> DWORD748     pub fn SetTapePosition(
749         hDevice: HANDLE,
750         dwPositionMethod: DWORD,
751         dwPartition: DWORD,
752         dwOffsetLow: DWORD,
753         dwOffsetHigh: DWORD,
754         bImmediate: BOOL
755     ) -> DWORD;
GetTapePosition( hDevice: HANDLE, dwPositionType: DWORD, lpdwPartition: LPDWORD, lpdwOffsetLow: LPDWORD, lpdwOffsetHigh: LPDWORD ) -> DWORD756     pub fn GetTapePosition(
757         hDevice: HANDLE,
758         dwPositionType: DWORD,
759         lpdwPartition: LPDWORD,
760         lpdwOffsetLow: LPDWORD,
761         lpdwOffsetHigh: LPDWORD
762     ) -> DWORD;
PrepareTape( hDevice: HANDLE, dwOperation: DWORD, bImmediate: BOOL ) -> DWORD763     pub fn PrepareTape(
764         hDevice: HANDLE,
765         dwOperation: DWORD,
766         bImmediate: BOOL
767     ) -> DWORD;
EraseTape( hDevice: HANDLE, dwEraseType: DWORD, bImmediate: BOOL ) -> DWORD768     pub fn EraseTape(
769         hDevice: HANDLE,
770         dwEraseType: DWORD,
771         bImmediate: BOOL
772     ) -> DWORD;
CreateTapePartition( hDevice: HANDLE, dwPartitionMethod: DWORD, dwCount: DWORD, dwSize: DWORD, ) -> DWORD773     pub fn CreateTapePartition(
774         hDevice: HANDLE,
775         dwPartitionMethod: DWORD,
776         dwCount: DWORD,
777         dwSize: DWORD,
778     ) -> DWORD;
WriteTapemark( hDevice: HANDLE, dwTapemarkType: DWORD, dwTapemarkCount: DWORD, bImmediate: BOOL, ) -> DWORD779     pub fn WriteTapemark(
780         hDevice: HANDLE,
781         dwTapemarkType: DWORD,
782         dwTapemarkCount: DWORD,
783         bImmediate: BOOL,
784     ) -> DWORD;
GetTapeStatus( hDevice: HANDLE ) -> DWORD785     pub fn GetTapeStatus(
786         hDevice: HANDLE
787     ) -> DWORD;
GetTapeParameters( hDevice: HANDLE, dwOperation: DWORD, lpdwSize: LPDWORD, lpTapeInformation: LPVOID ) -> DWORD788     pub fn GetTapeParameters(
789         hDevice: HANDLE,
790         dwOperation: DWORD,
791         lpdwSize: LPDWORD,
792         lpTapeInformation: LPVOID
793     ) -> DWORD;
SetTapeParameters( hDevice: HANDLE, dwOperation: DWORD, lpTapeInformation: LPVOID, ) -> DWORD794     pub fn SetTapeParameters(
795         hDevice: HANDLE,
796         dwOperation: DWORD,
797         lpTapeInformation: LPVOID,
798     ) -> DWORD;
MulDiv( nNumber: c_int, nNumerator: c_int, nDenominator: c_int ) -> c_int799     pub fn MulDiv(
800         nNumber: c_int,
801         nNumerator: c_int,
802         nDenominator: c_int
803     ) -> c_int;
804 }
805 ENUM!{enum DEP_SYSTEM_POLICY_TYPE {
806     DEPPolicyAlwaysOff = 0,
807     DEPPolicyAlwaysOn,
808     DEPPolicyOptIn,
809     DEPPolicyOptOut,
810     DEPTotalPolicyCount,
811 }}
812 extern "system" {
GetSystemDEPPolicy() -> DEP_SYSTEM_POLICY_TYPE813     pub fn GetSystemDEPPolicy() -> DEP_SYSTEM_POLICY_TYPE;
GetSystemRegistryQuota( pdwQuotaAllowed: PDWORD, pdwQuotaUsed: PDWORD ) -> BOOL814     pub fn GetSystemRegistryQuota(
815         pdwQuotaAllowed: PDWORD,
816         pdwQuotaUsed: PDWORD
817     ) -> BOOL;
FileTimeToDosDateTime( lpFileTime: *const FILETIME, lpFatDate: LPWORD, lpFatTime: LPWORD, ) -> BOOL818     pub fn FileTimeToDosDateTime(
819         lpFileTime: *const FILETIME,
820         lpFatDate: LPWORD,
821         lpFatTime: LPWORD,
822     ) -> BOOL;
DosDateTimeToFileTime( wFatDate: WORD, wFatTime: WORD, lpFileTime: LPFILETIME ) -> BOOL823     pub fn DosDateTimeToFileTime(
824         wFatDate: WORD,
825         wFatTime: WORD,
826         lpFileTime: LPFILETIME
827     ) -> BOOL;
FormatMessageA( dwFlags: DWORD, lpSource: LPCVOID, dwMessageId: DWORD, dwLanguageId: DWORD, lpBuffer: LPSTR, nSize: DWORD, Arguments: *mut va_list, ) -> DWORD828     pub fn FormatMessageA(
829         dwFlags: DWORD,
830         lpSource: LPCVOID,
831         dwMessageId: DWORD,
832         dwLanguageId: DWORD,
833         lpBuffer: LPSTR,
834         nSize: DWORD,
835         Arguments: *mut va_list,
836     ) -> DWORD;
FormatMessageW( dwFlags: DWORD, lpSource: LPCVOID, dwMessageId: DWORD, dwLanguageId: DWORD, lpBuffer: LPWSTR, nSize: DWORD, Arguments: *mut va_list, ) -> DWORD837     pub fn FormatMessageW(
838         dwFlags: DWORD,
839         lpSource: LPCVOID,
840         dwMessageId: DWORD,
841         dwLanguageId: DWORD,
842         lpBuffer: LPWSTR,
843         nSize: DWORD,
844         Arguments: *mut va_list,
845     ) -> DWORD;
846 }
847 pub const FORMAT_MESSAGE_IGNORE_INSERTS: DWORD = 0x00000200;
848 pub const FORMAT_MESSAGE_FROM_STRING: DWORD = 0x00000400;
849 pub const FORMAT_MESSAGE_FROM_HMODULE: DWORD = 0x00000800;
850 pub const FORMAT_MESSAGE_FROM_SYSTEM: DWORD = 0x00001000;
851 pub const FORMAT_MESSAGE_ARGUMENT_ARRAY: DWORD = 0x00002000;
852 pub const FORMAT_MESSAGE_MAX_WIDTH_MASK: DWORD = 0x000000FF;
853 pub const FORMAT_MESSAGE_ALLOCATE_BUFFER: DWORD = 0x00000100;
854 extern "system" {
CreateMailslotA( lpName: LPCSTR, nMaxMessageSize: DWORD, lReadTimeout: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> HANDLE855     pub fn CreateMailslotA(
856         lpName: LPCSTR,
857         nMaxMessageSize: DWORD,
858         lReadTimeout: DWORD,
859         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
860     ) -> HANDLE;
CreateMailslotW( lpName: LPCWSTR, nMaxMessageSize: DWORD, lReadTimeout: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> HANDLE861     pub fn CreateMailslotW(
862         lpName: LPCWSTR,
863         nMaxMessageSize: DWORD,
864         lReadTimeout: DWORD,
865         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
866     ) -> HANDLE;
GetMailslotInfo( hMailslot: HANDLE, lpMaxMessageSize: LPDWORD, lpNextSize: LPDWORD, lpMessageCount: LPDWORD, lpReadTimeout: LPDWORD, ) -> BOOL867     pub fn GetMailslotInfo(
868         hMailslot: HANDLE,
869         lpMaxMessageSize: LPDWORD,
870         lpNextSize: LPDWORD,
871         lpMessageCount: LPDWORD,
872         lpReadTimeout: LPDWORD,
873     ) -> BOOL;
SetMailslotInfo( hMailslot: HANDLE, lReadTimeout: DWORD ) -> BOOL874     pub fn SetMailslotInfo(
875         hMailslot: HANDLE,
876         lReadTimeout: DWORD
877     ) -> BOOL;
878     // pub fn EncryptFileA();
879     // pub fn EncryptFileW();
880     // pub fn DecryptFileA();
881     // pub fn DecryptFileW();
882     // pub fn FileEncryptionStatusA();
883     // pub fn FileEncryptionStatusW();
884     // pub fn OpenEncryptedFileRawA();
885     // pub fn OpenEncryptedFileRawW();
886     // pub fn ReadEncryptedFileRaw();
887     // pub fn WriteEncryptedFileRaw();
888     // pub fn CloseEncryptedFileRaw();
lstrcmpA( lpString1: LPCSTR, lpString2: LPCSTR ) -> c_int889     pub fn lstrcmpA(
890         lpString1: LPCSTR,
891         lpString2: LPCSTR
892     ) -> c_int;
lstrcmpW( lpString1: LPCWSTR, lpString2: LPCWSTR ) -> c_int893     pub fn lstrcmpW(
894         lpString1: LPCWSTR,
895         lpString2: LPCWSTR
896     ) -> c_int;
lstrcmpiA( lpString1: LPCSTR, lpString2: LPCSTR ) -> c_int897     pub fn lstrcmpiA(
898         lpString1: LPCSTR,
899         lpString2: LPCSTR
900     ) -> c_int;
lstrcmpiW( lpString1: LPCWSTR, lpString2: LPCWSTR ) -> c_int901     pub fn lstrcmpiW(
902         lpString1: LPCWSTR,
903         lpString2: LPCWSTR
904     ) -> c_int;
lstrcpynA( lpString1: LPSTR, lpString2: LPCSTR, iMaxLength: c_int ) -> LPSTR905     pub fn lstrcpynA(
906         lpString1: LPSTR,
907         lpString2: LPCSTR,
908         iMaxLength: c_int
909     ) -> LPSTR;
lstrcpynW( lpString1: LPWSTR, lpString2: LPCWSTR, iMaxLength: c_int ) -> LPWSTR910     pub fn lstrcpynW(
911         lpString1: LPWSTR,
912         lpString2: LPCWSTR,
913         iMaxLength: c_int
914     ) -> LPWSTR;
lstrcpyA( lpString1: LPSTR, lpString2: LPCSTR ) -> LPSTR915     pub fn lstrcpyA(
916         lpString1: LPSTR,
917         lpString2: LPCSTR
918     ) -> LPSTR;
lstrcpyW( lpString1: LPWSTR, lpString2: LPCWSTR ) -> LPWSTR919     pub fn lstrcpyW(
920         lpString1: LPWSTR,
921         lpString2: LPCWSTR
922     ) -> LPWSTR;
lstrcatA( lpString1: LPSTR, lpString2: LPCSTR ) -> LPSTR923     pub fn lstrcatA(
924         lpString1: LPSTR,
925         lpString2: LPCSTR
926     ) -> LPSTR;
lstrcatW( lpString1: LPWSTR, lpString2: LPCWSTR ) -> LPWSTR927     pub fn lstrcatW(
928         lpString1: LPWSTR,
929         lpString2: LPCWSTR
930     ) -> LPWSTR;
lstrlenA( lpString: LPCSTR ) -> c_int931     pub fn lstrlenA(
932         lpString: LPCSTR
933     ) -> c_int;
lstrlenW( lpString: LPCWSTR ) -> c_int934     pub fn lstrlenW(
935         lpString: LPCWSTR
936     ) -> c_int;
OpenFile( lpFileName: LPCSTR, lpReOpenBuff: LPOFSTRUCT, uStyle: UINT ) -> HFILE937     pub fn OpenFile(
938         lpFileName: LPCSTR,
939         lpReOpenBuff: LPOFSTRUCT,
940         uStyle: UINT
941     ) -> HFILE;
_lopen( lpPathName: LPCSTR, iReadWrite: c_int ) -> HFILE942     pub fn _lopen(
943         lpPathName: LPCSTR,
944         iReadWrite: c_int
945     ) -> HFILE;
_lcreat( lpPathName: LPCSTR, iAttrubute: c_int ) -> HFILE946     pub fn _lcreat(
947         lpPathName: LPCSTR,
948         iAttrubute: c_int
949     ) -> HFILE;
_lread( hFile: HFILE, lpBuffer: LPVOID, uBytes: UINT ) -> UINT950     pub fn _lread(
951         hFile: HFILE,
952         lpBuffer: LPVOID,
953         uBytes: UINT
954     ) -> UINT;
_lwrite( hFile: HFILE, lpBuffer: LPCCH, uBytes: UINT ) -> UINT955     pub fn _lwrite(
956         hFile: HFILE,
957         lpBuffer: LPCCH,
958         uBytes: UINT
959     ) -> UINT;
_hread( hFile: HFILE, lpBuffer: LPVOID, lBytes: c_long ) -> c_long960     pub fn _hread(
961         hFile: HFILE,
962         lpBuffer: LPVOID,
963         lBytes: c_long
964     ) -> c_long;
_hwrite( hFile: HFILE, lpBuffer: LPCCH, lBytes: c_long ) -> c_long965     pub fn _hwrite(
966         hFile: HFILE,
967         lpBuffer: LPCCH,
968         lBytes: c_long
969     ) -> c_long;
_lclose( hFile: HFILE ) -> HFILE970     pub fn _lclose(
971         hFile: HFILE
972     ) -> HFILE;
_llseek( hFile: HFILE, lOffset: LONG, iOrigin: c_int ) -> LONG973     pub fn _llseek(
974         hFile: HFILE,
975         lOffset: LONG,
976         iOrigin: c_int
977     ) -> LONG;
978     // pub fn IsTextUnicode();
979     // pub fn SignalObjectAndWait();
BackupRead( hFile: HANDLE, lpBuffer: LPBYTE, nNumberOfBytesToRead: DWORD, lpNumberOfBytesRead: LPDWORD, bAbort: BOOL, bProcessSecurity: BOOL, lpContext: *mut LPVOID, ) -> BOOL980     pub fn BackupRead(
981         hFile: HANDLE,
982         lpBuffer: LPBYTE,
983         nNumberOfBytesToRead: DWORD,
984         lpNumberOfBytesRead: LPDWORD,
985         bAbort: BOOL,
986         bProcessSecurity: BOOL,
987         lpContext: *mut LPVOID,
988     ) -> BOOL;
BackupSeek( hFile: HANDLE, dwLowBytesToSeek: DWORD, dwHighBytesToSeek: DWORD, lpdwLowByteSeeked: LPDWORD, lpdwHighByteSeeked: LPDWORD, lpContext: *mut LPVOID, ) -> BOOL989     pub fn BackupSeek(
990         hFile: HANDLE,
991         dwLowBytesToSeek: DWORD,
992         dwHighBytesToSeek: DWORD,
993         lpdwLowByteSeeked: LPDWORD,
994         lpdwHighByteSeeked: LPDWORD,
995         lpContext: *mut LPVOID,
996     ) -> BOOL;
BackupWrite( hFile: HANDLE, lpBuffer: LPBYTE, nNumberOfBytesToWrite: DWORD, lpNumberOfBytesWritten: LPDWORD, bAbort: BOOL, bProcessSecurity: BOOL, lpContext: *mut LPVOID, ) -> BOOL997     pub fn BackupWrite(
998         hFile: HANDLE,
999         lpBuffer: LPBYTE,
1000         nNumberOfBytesToWrite: DWORD,
1001         lpNumberOfBytesWritten: LPDWORD,
1002         bAbort: BOOL,
1003         bProcessSecurity: BOOL,
1004         lpContext: *mut LPVOID,
1005     ) -> BOOL;
1006 }
1007 //2886
1008 pub const STARTF_USESHOWWINDOW: DWORD = 0x00000001;
1009 pub const STARTF_USESIZE: DWORD = 0x00000002;
1010 pub const STARTF_USEPOSITION: DWORD = 0x00000004;
1011 pub const STARTF_USECOUNTCHARS: DWORD = 0x00000008;
1012 pub const STARTF_USEFILLATTRIBUTE: DWORD = 0x00000010;
1013 pub const STARTF_RUNFULLSCREEN: DWORD = 0x00000020;
1014 pub const STARTF_FORCEONFEEDBACK: DWORD = 0x00000040;
1015 pub const STARTF_FORCEOFFFEEDBACK: DWORD = 0x00000080;
1016 pub const STARTF_USESTDHANDLES: DWORD = 0x00000100;
1017 pub const STARTF_USEHOTKEY: DWORD = 0x00000200;
1018 pub const STARTF_TITLEISLINKNAME: DWORD = 0x00000800;
1019 pub const STARTF_TITLEISAPPID: DWORD = 0x00001000;
1020 pub const STARTF_PREVENTPINNING: DWORD = 0x00002000;
1021 pub const STARTF_UNTRUSTEDSOURCE: DWORD = 0x00008000;
1022 STRUCT!{struct STARTUPINFOEXA {
1023     StartupInfo: STARTUPINFOA,
1024     lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST,
1025 }}
1026 pub type LPSTARTUPINFOEXA = *mut STARTUPINFOEXA;
1027 STRUCT!{struct STARTUPINFOEXW {
1028     StartupInfo: STARTUPINFOW,
1029     lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST,
1030 }}
1031 pub type LPSTARTUPINFOEXW = *mut STARTUPINFOEXW;
1032 extern "system" {
OpenMutexA( dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR ) -> HANDLE1033     pub fn OpenMutexA(
1034         dwDesiredAccess: DWORD,
1035         bInheritHandle: BOOL,
1036         lpName: LPCSTR
1037     ) -> HANDLE;
CreateSemaphoreA( lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCSTR, ) -> HANDLE1038     pub fn CreateSemaphoreA(
1039         lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES,
1040         lInitialCount: LONG,
1041         lMaximumCount: LONG,
1042         lpName: LPCSTR,
1043     ) -> HANDLE;
OpenSemaphoreA( dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR ) -> HANDLE1044     pub fn OpenSemaphoreA(
1045         dwDesiredAccess: DWORD,
1046         bInheritHandle: BOOL,
1047         lpName: LPCSTR
1048     ) -> HANDLE;
CreateWaitableTimerA( lpTimerAttributes: LPSECURITY_ATTRIBUTES, bManualReset: BOOL, lpTimerName: LPCSTR, ) -> HANDLE1049     pub fn CreateWaitableTimerA(
1050         lpTimerAttributes: LPSECURITY_ATTRIBUTES,
1051         bManualReset: BOOL,
1052         lpTimerName: LPCSTR,
1053     ) -> HANDLE;
OpenWaitableTimerA( dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpTimerName: LPCSTR, ) -> HANDLE1054     pub fn OpenWaitableTimerA(
1055         dwDesiredAccess: DWORD,
1056         bInheritHandle: BOOL,
1057         lpTimerName: LPCSTR,
1058     ) -> HANDLE;
CreateSemaphoreExA( lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCSTR, dwFlags: DWORD, dwDesiredAccess: DWORD, ) -> HANDLE1059     pub fn CreateSemaphoreExA(
1060         lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES,
1061         lInitialCount: LONG,
1062         lMaximumCount: LONG,
1063         lpName: LPCSTR,
1064         dwFlags: DWORD,
1065         dwDesiredAccess: DWORD,
1066     ) -> HANDLE;
CreateWaitableTimerExA( lpTimerAttributes: LPSECURITY_ATTRIBUTES, lpTimerName: LPCSTR, dwFlags: DWORD, dwDesiredAccess: DWORD, ) -> HANDLE1067     pub fn CreateWaitableTimerExA(
1068         lpTimerAttributes: LPSECURITY_ATTRIBUTES,
1069         lpTimerName: LPCSTR,
1070         dwFlags: DWORD,
1071         dwDesiredAccess: DWORD,
1072     ) -> HANDLE;
CreateFileMappingA( hFile: HANDLE, lpAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCSTR, ) -> HANDLE1073     pub fn CreateFileMappingA(
1074         hFile: HANDLE,
1075         lpAttributes: LPSECURITY_ATTRIBUTES,
1076         flProtect: DWORD,
1077         dwMaximumSizeHigh: DWORD,
1078         dwMaximumSizeLow: DWORD,
1079         lpName: LPCSTR,
1080     ) -> HANDLE;
CreateFileMappingNumaA( hFile: HANDLE, lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCSTR, nndPreferred: DWORD, ) -> HANDLE1081     pub fn CreateFileMappingNumaA(
1082         hFile: HANDLE,
1083         lpFileMappingAttributes: LPSECURITY_ATTRIBUTES,
1084         flProtect: DWORD,
1085         dwMaximumSizeHigh: DWORD,
1086         dwMaximumSizeLow: DWORD,
1087         lpName: LPCSTR,
1088         nndPreferred: DWORD,
1089     ) -> HANDLE;
OpenFileMappingA( dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR, ) -> HANDLE1090     pub fn OpenFileMappingA(
1091         dwDesiredAccess: DWORD,
1092         bInheritHandle: BOOL,
1093         lpName: LPCSTR,
1094     ) -> HANDLE;
GetLogicalDriveStringsA( nBufferLength: DWORD, lpBuffer: LPSTR ) -> DWORD1095     pub fn GetLogicalDriveStringsA(
1096         nBufferLength: DWORD,
1097         lpBuffer: LPSTR
1098     ) -> DWORD;
LoadPackagedLibrary( lpwLibFileName: LPCWSTR, Reserved: DWORD ) -> HMODULE1099     pub fn LoadPackagedLibrary(
1100         lpwLibFileName: LPCWSTR,
1101         Reserved: DWORD
1102     ) -> HMODULE;
QueryFullProcessImageNameA( hProcess: HANDLE, dwFlags: DWORD, lpExeName: LPSTR, lpdwSize: PDWORD, ) -> BOOL1103     pub fn QueryFullProcessImageNameA(
1104         hProcess: HANDLE,
1105         dwFlags: DWORD,
1106         lpExeName: LPSTR,
1107         lpdwSize: PDWORD,
1108     ) -> BOOL;
QueryFullProcessImageNameW( hProcess: HANDLE, dwFlags: DWORD, lpExeName: LPWSTR, lpdwSize: PDWORD, ) -> BOOL1109     pub fn QueryFullProcessImageNameW(
1110         hProcess: HANDLE,
1111         dwFlags: DWORD,
1112         lpExeName: LPWSTR,
1113         lpdwSize: PDWORD,
1114     ) -> BOOL;
1115 }
1116 //3233
1117 extern "system" {
GetStartupInfoA( lpStartupInfo: LPSTARTUPINFOA )1118     pub fn GetStartupInfoA(
1119         lpStartupInfo: LPSTARTUPINFOA
1120     );
GetFirmwareEnvironmentVariableA( lpName: LPCSTR, lpGuid: LPCSTR, pBuffer: PVOID, nSize: DWORD, ) -> DWORD1121     pub fn GetFirmwareEnvironmentVariableA(
1122         lpName: LPCSTR,
1123         lpGuid: LPCSTR,
1124         pBuffer: PVOID,
1125         nSize: DWORD,
1126     ) -> DWORD;
GetFirmwareEnvironmentVariableW( lpName: LPCWSTR, lpGuid: LPCWSTR, pBuffer: PVOID, nSize: DWORD, ) -> DWORD1127     pub fn GetFirmwareEnvironmentVariableW(
1128         lpName: LPCWSTR,
1129         lpGuid: LPCWSTR,
1130         pBuffer: PVOID,
1131         nSize: DWORD,
1132     ) -> DWORD;
GetFirmwareEnvironmentVariableExA( lpName: LPCSTR, lpGuid: LPCSTR, pBuffer: PVOID, nSize: DWORD, pdwAttribubutes: PDWORD, ) -> DWORD1133     pub fn GetFirmwareEnvironmentVariableExA(
1134         lpName: LPCSTR,
1135         lpGuid: LPCSTR,
1136         pBuffer: PVOID,
1137         nSize: DWORD,
1138         pdwAttribubutes: PDWORD,
1139     ) -> DWORD;
GetFirmwareEnvironmentVariableExW( lpName: LPCWSTR, lpGuid: LPCWSTR, pBuffer: PVOID, nSize: DWORD, pdwAttribubutes: PDWORD, ) -> DWORD1140     pub fn GetFirmwareEnvironmentVariableExW(
1141         lpName: LPCWSTR,
1142         lpGuid: LPCWSTR,
1143         pBuffer: PVOID,
1144         nSize: DWORD,
1145         pdwAttribubutes: PDWORD,
1146     ) -> DWORD;
SetFirmwareEnvironmentVariableA( lpName: LPCSTR, lpGuid: LPCSTR, pValue: PVOID, nSize: DWORD, ) -> BOOL1147     pub fn SetFirmwareEnvironmentVariableA(
1148         lpName: LPCSTR,
1149         lpGuid: LPCSTR,
1150         pValue: PVOID,
1151         nSize: DWORD,
1152     ) -> BOOL;
SetFirmwareEnvironmentVariableW( lpName: LPCWSTR, lpGuid: LPCWSTR, pValue: PVOID, nSize: DWORD, ) -> BOOL1153     pub fn SetFirmwareEnvironmentVariableW(
1154         lpName: LPCWSTR,
1155         lpGuid: LPCWSTR,
1156         pValue: PVOID,
1157         nSize: DWORD,
1158     ) -> BOOL;
SetFirmwareEnvironmentVariableExA( lpName: LPCSTR, lpGuid: LPCSTR, pValue: PVOID, nSize: DWORD, dwAttributes: DWORD, ) -> BOOL1159     pub fn SetFirmwareEnvironmentVariableExA(
1160         lpName: LPCSTR,
1161         lpGuid: LPCSTR,
1162         pValue: PVOID,
1163         nSize: DWORD,
1164         dwAttributes: DWORD,
1165     ) -> BOOL;
SetFirmwareEnvironmentVariableExW( lpName: LPCWSTR, lpGuid: LPCWSTR, pValue: PVOID, nSize: DWORD, dwAttributes: DWORD, ) -> BOOL1166     pub fn SetFirmwareEnvironmentVariableExW(
1167         lpName: LPCWSTR,
1168         lpGuid: LPCWSTR,
1169         pValue: PVOID,
1170         nSize: DWORD,
1171         dwAttributes: DWORD,
1172     ) -> BOOL;
GetFirmwareType( FirmwareType: PFIRMWARE_TYPE ) -> BOOL1173     pub fn GetFirmwareType(
1174         FirmwareType: PFIRMWARE_TYPE
1175     ) -> BOOL;
IsNativeVhdBoot( NativeVhdBoot: PBOOL ) -> BOOL1176     pub fn IsNativeVhdBoot(
1177         NativeVhdBoot: PBOOL
1178     ) -> BOOL;
FindResourceA( hModule: HMODULE, lpName: LPCSTR, lpType: LPCSTR ) -> HRSRC1179     pub fn FindResourceA(
1180         hModule: HMODULE,
1181         lpName: LPCSTR,
1182         lpType: LPCSTR
1183     ) -> HRSRC;
FindResourceExA( hModule: HMODULE, lpName: LPCSTR, lpType: LPCSTR, wLanguage: WORD, ) -> HRSRC1184     pub fn FindResourceExA(
1185         hModule: HMODULE,
1186         lpName: LPCSTR,
1187         lpType: LPCSTR,
1188         wLanguage: WORD,
1189     ) -> HRSRC;
EnumResourceTypesA( hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCA, lParam: LONG_PTR, ) -> BOOL1190     pub fn EnumResourceTypesA(
1191         hModule: HMODULE,
1192         lpEnumFunc: ENUMRESTYPEPROCA,
1193         lParam: LONG_PTR,
1194     ) -> BOOL;
EnumResourceTypesW( hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCW, lParam: LONG_PTR, ) -> BOOL1195     pub fn EnumResourceTypesW(
1196         hModule: HMODULE,
1197         lpEnumFunc: ENUMRESTYPEPROCW,
1198         lParam: LONG_PTR,
1199     ) -> BOOL;
EnumResourceNamesA( hModule: HMODULE, lpType: LPCSTR, lpEnumFunc: ENUMRESNAMEPROCA, lParam: LONG_PTR, ) -> BOOL1200     pub fn EnumResourceNamesA(
1201         hModule: HMODULE,
1202         lpType: LPCSTR,
1203         lpEnumFunc: ENUMRESNAMEPROCA,
1204         lParam: LONG_PTR,
1205     ) -> BOOL;
EnumResourceLanguagesA( hModule: HMODULE, lpType: LPCSTR, lpName: LPCSTR, lpEnumFunc: ENUMRESLANGPROCA, lParam: LONG_PTR, ) -> BOOL1206     pub fn EnumResourceLanguagesA(
1207         hModule: HMODULE,
1208         lpType: LPCSTR,
1209         lpName: LPCSTR,
1210         lpEnumFunc: ENUMRESLANGPROCA,
1211         lParam: LONG_PTR,
1212     ) -> BOOL;
EnumResourceLanguagesW( hModule: HMODULE, lpType: LPCWSTR, lpName: LPCWSTR, lpEnumFunc: ENUMRESLANGPROCW, lParam: LONG_PTR, ) -> BOOL1213     pub fn EnumResourceLanguagesW(
1214         hModule: HMODULE,
1215         lpType: LPCWSTR,
1216         lpName: LPCWSTR,
1217         lpEnumFunc: ENUMRESLANGPROCW,
1218         lParam: LONG_PTR,
1219     ) -> BOOL;
BeginUpdateResourceA( pFileName: LPCSTR, bDeleteExistingResources: BOOL ) -> HANDLE1220     pub fn BeginUpdateResourceA(
1221         pFileName: LPCSTR,
1222         bDeleteExistingResources: BOOL
1223     ) -> HANDLE;
BeginUpdateResourceW( pFileName: LPCWSTR, bDeleteExistingResources: BOOL ) -> HANDLE1224     pub fn BeginUpdateResourceW(
1225         pFileName: LPCWSTR,
1226         bDeleteExistingResources: BOOL
1227     ) -> HANDLE;
UpdateResourceA( hUpdate: HANDLE, lpType: LPCSTR, lpName: LPCSTR, wLanguage: WORD, lpData: LPVOID, cb: DWORD, ) -> BOOL1228     pub fn UpdateResourceA(
1229         hUpdate: HANDLE,
1230         lpType: LPCSTR,
1231         lpName: LPCSTR,
1232         wLanguage: WORD,
1233         lpData: LPVOID,
1234         cb: DWORD,
1235     ) -> BOOL;
UpdateResourceW( hUpdate: HANDLE, lpType: LPCWSTR, lpName: LPCWSTR, wLanguage: WORD, lpData: LPVOID, cb: DWORD, ) -> BOOL1236     pub fn UpdateResourceW(
1237         hUpdate: HANDLE,
1238         lpType: LPCWSTR,
1239         lpName: LPCWSTR,
1240         wLanguage: WORD,
1241         lpData: LPVOID,
1242         cb: DWORD,
1243     ) -> BOOL;
EndUpdateResourceA( hUpdate: HANDLE, fDiscard: BOOL ) -> BOOL1244     pub fn EndUpdateResourceA(
1245         hUpdate: HANDLE,
1246         fDiscard: BOOL
1247     ) -> BOOL;
EndUpdateResourceW( hUpdate: HANDLE, fDiscard: BOOL ) -> BOOL1248     pub fn EndUpdateResourceW(
1249         hUpdate: HANDLE,
1250         fDiscard: BOOL
1251     ) -> BOOL;
1252     #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
GlobalAddAtomA( lpString: LPCSTR ) -> ATOM1253     pub fn GlobalAddAtomA(
1254         lpString: LPCSTR
1255     ) -> ATOM;
GlobalAddAtomW( lpString: LPCWSTR ) -> ATOM1256     pub fn GlobalAddAtomW(
1257         lpString: LPCWSTR
1258     ) -> ATOM;
GlobalAddAtomExA( lpString: LPCSTR, Flags: DWORD ) -> ATOM1259     pub fn GlobalAddAtomExA(
1260         lpString: LPCSTR,
1261         Flags: DWORD
1262     ) -> ATOM;
GlobalAddAtomExW( lpString: LPCWSTR, Flags: DWORD ) -> ATOM1263     pub fn GlobalAddAtomExW(
1264         lpString: LPCWSTR,
1265         Flags: DWORD
1266     ) -> ATOM;
GlobalFindAtomA( lpString: LPCSTR ) -> ATOM1267     pub fn GlobalFindAtomA(
1268         lpString: LPCSTR
1269     ) -> ATOM;
GlobalFindAtomW( lpString: LPCWSTR ) -> ATOM1270     pub fn GlobalFindAtomW(
1271         lpString: LPCWSTR
1272     ) -> ATOM;
GlobalGetAtomNameA( nAtom: ATOM, lpBuffer: LPSTR, nSize: c_int ) -> UINT1273     pub fn GlobalGetAtomNameA(
1274         nAtom: ATOM,
1275         lpBuffer: LPSTR,
1276         nSize: c_int
1277     ) -> UINT;
GlobalGetAtomNameW( nAtom: ATOM, lpBuffer: LPWSTR, nSize: c_int ) -> UINT1278     pub fn GlobalGetAtomNameW(
1279         nAtom: ATOM,
1280         lpBuffer: LPWSTR,
1281         nSize: c_int
1282     ) -> UINT;
AddAtomA( lpString: LPCSTR ) -> ATOM1283     pub fn AddAtomA(
1284         lpString: LPCSTR
1285     ) -> ATOM;
AddAtomW( lpString: LPCWSTR ) -> ATOM1286     pub fn AddAtomW(
1287         lpString: LPCWSTR
1288     ) -> ATOM;
FindAtomA( lpString: LPCSTR ) -> ATOM1289     pub fn FindAtomA(
1290         lpString: LPCSTR
1291     ) -> ATOM;
FindAtomW( lpString: LPCWSTR ) -> ATOM1292     pub fn FindAtomW(
1293         lpString: LPCWSTR
1294     ) -> ATOM;
GetAtomNameA( nAtom: ATOM, lpBuffer: LPSTR, nSize: c_int ) -> UINT1295     pub fn GetAtomNameA(
1296         nAtom: ATOM,
1297         lpBuffer: LPSTR,
1298         nSize: c_int
1299     ) -> UINT;
GetAtomNameW( nAtom: ATOM, lpBuffer: LPWSTR, nSize: c_int ) -> UINT1300     pub fn GetAtomNameW(
1301         nAtom: ATOM,
1302         lpBuffer: LPWSTR,
1303         nSize: c_int
1304     ) -> UINT;
GetProfileIntA( lpAppName: LPCSTR, lpKeyName: LPCSTR, nDefault: INT ) -> UINT1305     pub fn GetProfileIntA(
1306         lpAppName: LPCSTR,
1307         lpKeyName: LPCSTR,
1308         nDefault: INT
1309     ) -> UINT;
GetProfileIntW( lpAppName: LPCWSTR, lpKeyName: LPCWSTR, nDefault: INT ) -> UINT1310     pub fn GetProfileIntW(
1311         lpAppName: LPCWSTR,
1312         lpKeyName: LPCWSTR,
1313         nDefault: INT
1314     ) -> UINT;
GetProfileStringA( lpAppName: LPCSTR, lpKeyName: LPCSTR, lpDefault: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD, ) -> DWORD1315     pub fn GetProfileStringA(
1316         lpAppName: LPCSTR,
1317         lpKeyName: LPCSTR,
1318         lpDefault: LPCSTR,
1319         lpReturnedString: LPSTR,
1320         nSize: DWORD,
1321     ) -> DWORD;
GetProfileStringW( lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpDefault: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD, ) -> DWORD1322     pub fn GetProfileStringW(
1323         lpAppName: LPCWSTR,
1324         lpKeyName: LPCWSTR,
1325         lpDefault: LPCWSTR,
1326         lpReturnedString: LPWSTR,
1327         nSize: DWORD,
1328     ) -> DWORD;
WriteProfileStringA( lpAppName: LPCSTR, lpKeyName: LPCSTR, lpString: LPCSTR ) -> BOOL1329     pub fn WriteProfileStringA(
1330         lpAppName: LPCSTR,
1331         lpKeyName: LPCSTR,
1332         lpString: LPCSTR
1333     ) -> BOOL;
WriteProfileStringW( lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpString: LPCWSTR ) -> BOOL1334     pub fn WriteProfileStringW(
1335         lpAppName: LPCWSTR,
1336         lpKeyName: LPCWSTR,
1337         lpString: LPCWSTR
1338     ) -> BOOL;
GetProfileSectionA( lpAppName: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD ) -> DWORD1339     pub fn GetProfileSectionA(
1340         lpAppName: LPCSTR,
1341         lpReturnedString: LPSTR,
1342         nSize: DWORD
1343     ) -> DWORD;
GetProfileSectionW( lpAppName: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD ) -> DWORD1344     pub fn GetProfileSectionW(
1345         lpAppName: LPCWSTR,
1346         lpReturnedString: LPWSTR,
1347         nSize: DWORD
1348     ) -> DWORD;
WriteProfileSectionA( lpAppName: LPCSTR, lpString: LPCSTR ) -> BOOL1349     pub fn WriteProfileSectionA(
1350         lpAppName: LPCSTR,
1351         lpString: LPCSTR
1352     ) -> BOOL;
WriteProfileSectionW( lpAppName: LPCWSTR, lpString: LPCWSTR ) -> BOOL1353     pub fn WriteProfileSectionW(
1354         lpAppName: LPCWSTR,
1355         lpString: LPCWSTR
1356     ) -> BOOL;
GetPrivateProfileIntA( lpAppName: LPCSTR, lpKeyName: LPCSTR, nDefault: INT, lpFileName: LPCSTR, ) -> UINT1357     pub fn GetPrivateProfileIntA(
1358         lpAppName: LPCSTR,
1359         lpKeyName: LPCSTR,
1360         nDefault: INT,
1361         lpFileName: LPCSTR,
1362     ) -> UINT;
GetPrivateProfileIntW( lpAppName: LPCWSTR, lpKeyName: LPCWSTR, nDefault: INT, lpFileName: LPCWSTR, ) -> UINT1363     pub fn GetPrivateProfileIntW(
1364         lpAppName: LPCWSTR,
1365         lpKeyName: LPCWSTR,
1366         nDefault: INT,
1367         lpFileName: LPCWSTR,
1368     ) -> UINT;
GetPrivateProfileStringA( lpAppName: LPCSTR, lpKeyName: LPCSTR, lpDefault: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD, lpFileName: LPCSTR, ) -> DWORD1369     pub fn GetPrivateProfileStringA(
1370         lpAppName: LPCSTR,
1371         lpKeyName: LPCSTR,
1372         lpDefault: LPCSTR,
1373         lpReturnedString: LPSTR,
1374         nSize: DWORD,
1375         lpFileName: LPCSTR,
1376     ) -> DWORD;
GetPrivateProfileStringW( lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpDefault: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD, lpFileName: LPCWSTR, ) -> DWORD1377     pub fn GetPrivateProfileStringW(
1378         lpAppName: LPCWSTR,
1379         lpKeyName: LPCWSTR,
1380         lpDefault: LPCWSTR,
1381         lpReturnedString: LPWSTR,
1382         nSize: DWORD,
1383         lpFileName: LPCWSTR,
1384     ) -> DWORD;
WritePrivateProfileStringA( lpAppName: LPCSTR, lpKeyName: LPCSTR, lpString: LPCSTR, lpFileName: LPCSTR, ) -> BOOL1385     pub fn WritePrivateProfileStringA(
1386         lpAppName: LPCSTR,
1387         lpKeyName: LPCSTR,
1388         lpString: LPCSTR,
1389         lpFileName: LPCSTR,
1390     ) -> BOOL;
WritePrivateProfileStringW( lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpString: LPCWSTR, lpFileName: LPCWSTR, ) -> BOOL1391     pub fn WritePrivateProfileStringW(
1392         lpAppName: LPCWSTR,
1393         lpKeyName: LPCWSTR,
1394         lpString: LPCWSTR,
1395         lpFileName: LPCWSTR,
1396     ) -> BOOL;
GetPrivateProfileSectionA( lpAppName: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD, lpFileName: LPCSTR, ) -> DWORD1397     pub fn GetPrivateProfileSectionA(
1398         lpAppName: LPCSTR,
1399         lpReturnedString: LPSTR,
1400         nSize: DWORD,
1401         lpFileName: LPCSTR,
1402     ) -> DWORD;
GetPrivateProfileSectionW( lpAppName: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD, lpFileName: LPCWSTR, ) -> DWORD1403     pub fn GetPrivateProfileSectionW(
1404         lpAppName: LPCWSTR,
1405         lpReturnedString: LPWSTR,
1406         nSize: DWORD,
1407         lpFileName: LPCWSTR,
1408     ) -> DWORD;
WritePrivateProfileSectionA( lpAppName: LPCSTR, lpString: LPCSTR, lpFileName: LPCSTR, ) -> BOOL1409     pub fn WritePrivateProfileSectionA(
1410         lpAppName: LPCSTR,
1411         lpString: LPCSTR,
1412         lpFileName: LPCSTR,
1413     ) -> BOOL;
WritePrivateProfileSectionW( lpAppName: LPCWSTR, lpString: LPCWSTR, lpFileName: LPCWSTR, ) -> BOOL1414     pub fn WritePrivateProfileSectionW(
1415         lpAppName: LPCWSTR,
1416         lpString: LPCWSTR,
1417         lpFileName: LPCWSTR,
1418     ) -> BOOL;
GetPrivateProfileSectionNamesA( lpszReturnBuffer: LPSTR, nSize: DWORD, lpFileName: LPCSTR, ) -> DWORD1419     pub fn GetPrivateProfileSectionNamesA(
1420         lpszReturnBuffer: LPSTR,
1421         nSize: DWORD,
1422         lpFileName: LPCSTR,
1423     ) -> DWORD;
GetPrivateProfileSectionNamesW( lpszReturnBuffer: LPWSTR, nSize: DWORD, lpFileName: LPCWSTR, ) -> DWORD1424     pub fn GetPrivateProfileSectionNamesW(
1425         lpszReturnBuffer: LPWSTR,
1426         nSize: DWORD,
1427         lpFileName: LPCWSTR,
1428     ) -> DWORD;
GetPrivateProfileStructA( lpszSection: LPCSTR, lpszKey: LPCSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCSTR, ) -> BOOL1429     pub fn GetPrivateProfileStructA(
1430         lpszSection: LPCSTR,
1431         lpszKey: LPCSTR,
1432         lpStruct: LPVOID,
1433         uSizeStruct: UINT,
1434         szFile: LPCSTR,
1435     ) -> BOOL;
GetPrivateProfileStructW( lpszSection: LPCWSTR, lpszKey: LPCWSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCWSTR, ) -> BOOL1436     pub fn GetPrivateProfileStructW(
1437         lpszSection: LPCWSTR,
1438         lpszKey: LPCWSTR,
1439         lpStruct: LPVOID,
1440         uSizeStruct: UINT,
1441         szFile: LPCWSTR,
1442     ) -> BOOL;
WritePrivateProfileStructA( lpszSection: LPCSTR, lpszKey: LPCSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCSTR, ) -> BOOL1443     pub fn WritePrivateProfileStructA(
1444         lpszSection: LPCSTR,
1445         lpszKey: LPCSTR,
1446         lpStruct: LPVOID,
1447         uSizeStruct: UINT,
1448         szFile: LPCSTR,
1449     ) -> BOOL;
WritePrivateProfileStructW( lpszSection: LPCWSTR, lpszKey: LPCWSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCWSTR, ) -> BOOL1450     pub fn WritePrivateProfileStructW(
1451         lpszSection: LPCWSTR,
1452         lpszKey: LPCWSTR,
1453         lpStruct: LPVOID,
1454         uSizeStruct: UINT,
1455         szFile: LPCWSTR,
1456     ) -> BOOL;
Wow64EnableWow64FsRedirection( Wow64FsEnableRedirection: BOOLEAN ) -> BOOLEAN1457     pub fn Wow64EnableWow64FsRedirection(
1458         Wow64FsEnableRedirection: BOOLEAN
1459     ) -> BOOLEAN;
SetDllDirectoryA( lpPathName: LPCSTR ) -> BOOL1460     pub fn SetDllDirectoryA(
1461         lpPathName: LPCSTR
1462     ) -> BOOL;
SetDllDirectoryW( lpPathName: LPCWSTR ) -> BOOL1463     pub fn SetDllDirectoryW(
1464         lpPathName: LPCWSTR
1465     ) -> BOOL;
GetDllDirectoryA( nBufferLength: DWORD, lpBuffer: LPSTR ) -> DWORD1466     pub fn GetDllDirectoryA(
1467         nBufferLength: DWORD,
1468         lpBuffer: LPSTR
1469     ) -> DWORD;
GetDllDirectoryW( nBufferLength: DWORD, lpBuffer: LPWSTR ) -> DWORD1470     pub fn GetDllDirectoryW(
1471         nBufferLength: DWORD,
1472         lpBuffer: LPWSTR
1473     ) -> DWORD;
SetSearchPathMode( Flags: DWORD ) -> BOOL1474     pub fn SetSearchPathMode(
1475         Flags: DWORD
1476     ) -> BOOL;
CreateDirectoryExA( lpTemplateDirectory: LPCSTR, lpNewDirectory: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> BOOL1477     pub fn CreateDirectoryExA(
1478         lpTemplateDirectory: LPCSTR,
1479         lpNewDirectory: LPCSTR,
1480         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
1481     ) -> BOOL;
CreateDirectoryExW( lpTemplateDirectory: LPCWSTR, lpNewDirectory: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> BOOL1482     pub fn CreateDirectoryExW(
1483         lpTemplateDirectory: LPCWSTR,
1484         lpNewDirectory: LPCWSTR,
1485         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
1486     ) -> BOOL;
CreateDirectoryTransactedA( lpTemplateDirectory: LPCSTR, lpNewDirectory: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE, ) -> BOOL1487     pub fn CreateDirectoryTransactedA(
1488         lpTemplateDirectory: LPCSTR,
1489         lpNewDirectory: LPCSTR,
1490         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
1491         hTransaction: HANDLE,
1492     ) -> BOOL;
CreateDirectoryTransactedW( lpTemplateDirectory: LPCWSTR, lpNewDirectory: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE, ) -> BOOL1493     pub fn CreateDirectoryTransactedW(
1494         lpTemplateDirectory: LPCWSTR,
1495         lpNewDirectory: LPCWSTR,
1496         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
1497         hTransaction: HANDLE,
1498     ) -> BOOL;
RemoveDirectoryTransactedA( lpPathName: LPCSTR, hTransaction: HANDLE ) -> BOOL1499     pub fn RemoveDirectoryTransactedA(
1500         lpPathName: LPCSTR,
1501         hTransaction: HANDLE
1502     ) -> BOOL;
RemoveDirectoryTransactedW( lpPathName: LPCWSTR, hTransaction: HANDLE ) -> BOOL1503     pub fn RemoveDirectoryTransactedW(
1504         lpPathName: LPCWSTR,
1505         hTransaction: HANDLE
1506     ) -> BOOL;
GetFullPathNameTransactedA( lpFileName: LPCSTR, nBufferLength: DWORD, lpBuffer: LPSTR, lpFilePart: *mut LPSTR, hTransaction: HANDLE, ) -> DWORD1507     pub fn GetFullPathNameTransactedA(
1508         lpFileName: LPCSTR,
1509         nBufferLength: DWORD,
1510         lpBuffer: LPSTR,
1511         lpFilePart: *mut LPSTR,
1512         hTransaction: HANDLE,
1513     ) -> DWORD;
GetFullPathNameTransactedW( lpFileName: LPCWSTR, nBufferLength: DWORD, lpBuffer: LPWSTR, lpFilePart: *mut LPWSTR, hTransaction: HANDLE, )1514     pub fn GetFullPathNameTransactedW(
1515         lpFileName: LPCWSTR,
1516         nBufferLength: DWORD,
1517         lpBuffer: LPWSTR,
1518         lpFilePart: *mut LPWSTR,
1519         hTransaction: HANDLE,
1520     );
DefineDosDeviceA( dwFlags: DWORD, lpDeviceName: LPCSTR, lpTargetPath: LPCSTR ) -> BOOL1521     pub fn DefineDosDeviceA(
1522         dwFlags: DWORD,
1523         lpDeviceName: LPCSTR,
1524         lpTargetPath: LPCSTR
1525     ) -> BOOL;
QueryDosDeviceA( lpDeviceName: LPCSTR, lpTargetPath: LPSTR, ucchMax: DWORD ) -> DWORD1526     pub fn QueryDosDeviceA(
1527         lpDeviceName: LPCSTR,
1528         lpTargetPath: LPSTR,
1529         ucchMax: DWORD
1530     ) -> DWORD;
CreateFileTransactedA( lpFileName: LPCSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE, hTransaction: HANDLE, pusMiniVersion: PUSHORT, lpExtendedParameter: PVOID, ) -> HANDLE1531     pub fn CreateFileTransactedA(
1532         lpFileName: LPCSTR,
1533         dwDesiredAccess: DWORD,
1534         dwShareMode: DWORD,
1535         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
1536         dwCreationDisposition: DWORD,
1537         dwFlagsAndAttributes: DWORD,
1538         hTemplateFile: HANDLE,
1539         hTransaction: HANDLE,
1540         pusMiniVersion: PUSHORT,
1541         lpExtendedParameter: PVOID,
1542     ) -> HANDLE;
CreateFileTransactedW( lpFileName: LPCWSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE, hTransaction: HANDLE, pusMiniVersion: PUSHORT, lpExtendedParameter: PVOID, ) -> HANDLE1543     pub fn CreateFileTransactedW(
1544         lpFileName: LPCWSTR,
1545         dwDesiredAccess: DWORD,
1546         dwShareMode: DWORD,
1547         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
1548         dwCreationDisposition: DWORD,
1549         dwFlagsAndAttributes: DWORD,
1550         hTemplateFile: HANDLE,
1551         hTransaction: HANDLE,
1552         pusMiniVersion: PUSHORT,
1553         lpExtendedParameter: PVOID,
1554     ) -> HANDLE;
ReOpenFile( hOriginalFile: HANDLE, dwDesiredAccess: DWORD, dwShareMode: DWORD, dwFlags: DWORD, ) -> HANDLE1555     pub fn ReOpenFile(
1556         hOriginalFile: HANDLE,
1557         dwDesiredAccess: DWORD,
1558         dwShareMode: DWORD,
1559         dwFlags: DWORD,
1560     ) -> HANDLE;
SetFileAttributesTransactedA( lpFileName: LPCSTR, dwFileAttributes: DWORD, hTransaction: HANDLE, ) -> BOOL1561     pub fn SetFileAttributesTransactedA(
1562         lpFileName: LPCSTR,
1563         dwFileAttributes: DWORD,
1564         hTransaction: HANDLE,
1565     ) -> BOOL;
SetFileAttributesTransactedW( lpFileName: LPCWSTR, dwFileAttributes: DWORD, hTransaction: HANDLE, ) -> BOOL1566     pub fn SetFileAttributesTransactedW(
1567         lpFileName: LPCWSTR,
1568         dwFileAttributes: DWORD,
1569         hTransaction: HANDLE,
1570     ) -> BOOL;
GetFileAttributesTransactedA( lpFileName: LPCSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID, hTransaction: HANDLE, ) -> BOOL1571     pub fn GetFileAttributesTransactedA(
1572         lpFileName: LPCSTR,
1573         fInfoLevelId: GET_FILEEX_INFO_LEVELS,
1574         lpFileInformation: LPVOID,
1575         hTransaction: HANDLE,
1576     ) -> BOOL;
GetFileAttributesTransactedW( lpFileName: LPCWSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID, hTransaction: HANDLE, ) -> BOOL1577     pub fn GetFileAttributesTransactedW(
1578         lpFileName: LPCWSTR,
1579         fInfoLevelId: GET_FILEEX_INFO_LEVELS,
1580         lpFileInformation: LPVOID,
1581         hTransaction: HANDLE,
1582     ) -> BOOL;
GetCompressedFileSizeTransactedA( lpFileName: LPCSTR, lpFileSizeHigh: LPDWORD, hTransaction: HANDLE, ) -> DWORD1583     pub fn GetCompressedFileSizeTransactedA(
1584         lpFileName: LPCSTR,
1585         lpFileSizeHigh: LPDWORD,
1586         hTransaction: HANDLE,
1587     ) -> DWORD;
GetCompressedFileSizeTransactedW( lpFileName: LPCWSTR, lpFileSizeHigh: LPDWORD, hTransaction: HANDLE, )1588     pub fn GetCompressedFileSizeTransactedW(
1589         lpFileName: LPCWSTR,
1590         lpFileSizeHigh: LPDWORD,
1591         hTransaction: HANDLE,
1592     );
DeleteFileTransactedA( lpFileName: LPCSTR, hTransaction: HANDLE ) -> BOOL1593     pub fn DeleteFileTransactedA(
1594         lpFileName: LPCSTR,
1595         hTransaction: HANDLE
1596     ) -> BOOL;
DeleteFileTransactedW( lpFileName: LPCWSTR, hTransaction: HANDLE ) -> BOOL1597     pub fn DeleteFileTransactedW(
1598         lpFileName: LPCWSTR,
1599         hTransaction: HANDLE
1600     ) -> BOOL;
CheckNameLegalDOS8Dot3A( lpName: LPCSTR, lpOemName: LPSTR, OemNameSize: DWORD, pbNameContainsSpaces: PBOOL, pbNameLegal: PBOOL, ) -> BOOL1601     pub fn CheckNameLegalDOS8Dot3A(
1602         lpName: LPCSTR,
1603         lpOemName: LPSTR,
1604         OemNameSize: DWORD,
1605         pbNameContainsSpaces: PBOOL,
1606         pbNameLegal: PBOOL,
1607     ) -> BOOL;
CheckNameLegalDOS8Dot3W( lpName: LPCWSTR, lpOemName: LPSTR, OemNameSize: DWORD, pbNameContainsSpaces: PBOOL, pbNameLegal: PBOOL, ) -> BOOL1608     pub fn CheckNameLegalDOS8Dot3W(
1609         lpName: LPCWSTR,
1610         lpOemName: LPSTR,
1611         OemNameSize: DWORD,
1612         pbNameContainsSpaces: PBOOL,
1613         pbNameLegal: PBOOL,
1614     ) -> BOOL;
FindFirstFileTransactedA( lpFileName: LPCSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID, fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD, hTransaction: HANDLE, ) -> HANDLE1615     pub fn FindFirstFileTransactedA(
1616         lpFileName: LPCSTR,
1617         fInfoLevelId: FINDEX_INFO_LEVELS,
1618         lpFindFileData: LPVOID,
1619         fSearchOp: FINDEX_SEARCH_OPS,
1620         lpSearchFilter: LPVOID,
1621         dwAdditionalFlags: DWORD,
1622         hTransaction: HANDLE,
1623     ) -> HANDLE;
FindFirstFileTransactedW( lpFileName: LPCWSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID, fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD, hTransaction: HANDLE, ) -> HANDLE1624     pub fn FindFirstFileTransactedW(
1625         lpFileName: LPCWSTR,
1626         fInfoLevelId: FINDEX_INFO_LEVELS,
1627         lpFindFileData: LPVOID,
1628         fSearchOp: FINDEX_SEARCH_OPS,
1629         lpSearchFilter: LPVOID,
1630         dwAdditionalFlags: DWORD,
1631         hTransaction: HANDLE,
1632     ) -> HANDLE;
CopyFileA( lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, bFailIfExists: BOOL ) -> BOOL1633     pub fn CopyFileA(
1634         lpExistingFileName: LPCSTR,
1635         lpNewFileName: LPCSTR,
1636         bFailIfExists: BOOL
1637     ) -> BOOL;
CopyFileW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, bFailIfExists: BOOL ) -> BOOL1638     pub fn CopyFileW(
1639         lpExistingFileName: LPCWSTR,
1640         lpNewFileName: LPCWSTR,
1641         bFailIfExists: BOOL
1642     ) -> BOOL;
1643 }
1644 FN!{stdcall LPPROGRESS_ROUTINE(
1645     TotalFileSize: LARGE_INTEGER,
1646     TotalBytesTransferred: LARGE_INTEGER,
1647     StreamSize: LARGE_INTEGER,
1648     StreamBytesTransferred: LARGE_INTEGER,
1649     dwStreamNumber: DWORD,
1650     dwCallbackReason: DWORD,
1651     hSourceFile: HANDLE,
1652     hDestinationFile: HANDLE,
1653     lpData: LPVOID,
1654 ) -> DWORD}
1655 extern "system" {
CopyFileExA( lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD, ) -> BOOL1656     pub fn CopyFileExA(
1657         lpExistingFileName: LPCSTR,
1658         lpNewFileName: LPCSTR,
1659         lpProgressRoutine: LPPROGRESS_ROUTINE,
1660         lpData: LPVOID,
1661         pbCancel: LPBOOL,
1662         dwCopyFlags: DWORD,
1663     ) -> BOOL;
CopyFileExW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD, ) -> BOOL1664     pub fn CopyFileExW(
1665         lpExistingFileName: LPCWSTR,
1666         lpNewFileName: LPCWSTR,
1667         lpProgressRoutine: LPPROGRESS_ROUTINE,
1668         lpData: LPVOID,
1669         pbCancel: LPBOOL,
1670         dwCopyFlags: DWORD,
1671     ) -> BOOL;
CopyFileTransactedA( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD, hTransaction: HANDLE, ) -> BOOL1672     pub fn CopyFileTransactedA(
1673         lpExistingFileName: LPCWSTR,
1674         lpNewFileName: LPCWSTR,
1675         lpProgressRoutine: LPPROGRESS_ROUTINE,
1676         lpData: LPVOID,
1677         pbCancel: LPBOOL,
1678         dwCopyFlags: DWORD,
1679         hTransaction: HANDLE,
1680     ) -> BOOL;
CopyFileTransactedW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD, hTransaction: HANDLE, ) -> BOOL1681     pub fn CopyFileTransactedW(
1682         lpExistingFileName: LPCWSTR,
1683         lpNewFileName: LPCWSTR,
1684         lpProgressRoutine: LPPROGRESS_ROUTINE,
1685         lpData: LPVOID,
1686         pbCancel: LPBOOL,
1687         dwCopyFlags: DWORD,
1688         hTransaction: HANDLE,
1689     ) -> BOOL;
1690 }
1691 ENUM!{enum COPYFILE2_MESSAGE_TYPE {
1692     COPYFILE2_CALLBACK_NONE = 0,
1693     COPYFILE2_CALLBACK_CHUNK_STARTED,
1694     COPYFILE2_CALLBACK_CHUNK_FINISHED,
1695     COPYFILE2_CALLBACK_STREAM_STARTED,
1696     COPYFILE2_CALLBACK_STREAM_FINISHED,
1697     COPYFILE2_CALLBACK_POLL_CONTINUE,
1698     COPYFILE2_CALLBACK_ERROR,
1699     COPYFILE2_CALLBACK_MAX,
1700 }}
1701 ENUM!{enum COPYFILE2_MESSAGE_ACTION {
1702     COPYFILE2_PROGRESS_CONTINUE = 0,
1703     COPYFILE2_PROGRESS_CANCEL,
1704     COPYFILE2_PROGRESS_STOP,
1705     COPYFILE2_PROGRESS_QUIET,
1706     COPYFILE2_PROGRESS_PAUSE,
1707 }}
1708 ENUM!{enum COPYFILE2_COPY_PHASE {
1709     COPYFILE2_PHASE_NONE = 0,
1710     COPYFILE2_PHASE_PREPARE_SOURCE,
1711     COPYFILE2_PHASE_PREPARE_DEST,
1712     COPYFILE2_PHASE_READ_SOURCE,
1713     COPYFILE2_PHASE_WRITE_DESTINATION,
1714     COPYFILE2_PHASE_SERVER_COPY,
1715     COPYFILE2_PHASE_NAMEGRAFT_COPY,
1716     COPYFILE2_PHASE_MAX,
1717 }}
1718 STRUCT!{struct COPYFILE2_MESSAGE_ChunkStarted {
1719     dwStreamNumber: DWORD,
1720     dwReserved: DWORD,
1721     hSourceFile: HANDLE,
1722     hDestinationFile: HANDLE,
1723     uliChunkNumber: ULARGE_INTEGER,
1724     uliChunkSize: ULARGE_INTEGER,
1725     uliStreamSize: ULARGE_INTEGER,
1726     uliTotalFileSize: ULARGE_INTEGER,
1727 }}
1728 STRUCT!{struct COPYFILE2_MESSAGE_ChunkFinished {
1729     dwStreamNumber: DWORD,
1730     dwFlags: DWORD,
1731     hSourceFile: HANDLE,
1732     hDestinationFile: HANDLE,
1733     uliChunkNumber: ULARGE_INTEGER,
1734     uliChunkSize: ULARGE_INTEGER,
1735     uliStreamSize: ULARGE_INTEGER,
1736     uliStreamBytesTransferred: ULARGE_INTEGER,
1737     uliTotalFileSize: ULARGE_INTEGER,
1738     uliTotalBytesTransferred: ULARGE_INTEGER,
1739 }}
1740 STRUCT!{struct COPYFILE2_MESSAGE_StreamStarted {
1741     dwStreamNumber: DWORD,
1742     dwReserved: DWORD,
1743     hSourceFile: HANDLE,
1744     hDestinationFile: HANDLE,
1745     uliStreamSize: ULARGE_INTEGER,
1746     uliTotalFileSize: ULARGE_INTEGER,
1747 }}
1748 STRUCT!{struct COPYFILE2_MESSAGE_StreamFinished {
1749     dwStreamNumber: DWORD,
1750     dwReserved: DWORD,
1751     hSourceFile: HANDLE,
1752     hDestinationFile: HANDLE,
1753     uliStreamSize: ULARGE_INTEGER,
1754     uliStreamBytesTransferred: ULARGE_INTEGER,
1755     uliTotalFileSize: ULARGE_INTEGER,
1756     uliTotalBytesTransferred: ULARGE_INTEGER,
1757 }}
1758 STRUCT!{struct COPYFILE2_MESSAGE_PollContinue {
1759     dwReserved: DWORD,
1760 }}
1761 STRUCT!{struct COPYFILE2_MESSAGE_Error {
1762     CopyPhase: COPYFILE2_COPY_PHASE,
1763     dwStreamNumber: DWORD,
1764     hrFailure: HRESULT,
1765     dwReserved: DWORD,
1766     uliChunkNumber: ULARGE_INTEGER,
1767     uliStreamSize: ULARGE_INTEGER,
1768     uliStreamBytesTransferred: ULARGE_INTEGER,
1769     uliTotalFileSize: ULARGE_INTEGER,
1770     uliTotalBytesTransferred: ULARGE_INTEGER,
1771 }}
1772 UNION!{union COPYFILE2_MESSAGE_Info {
1773     [u64; 8] [u64; 9],
1774     ChunkStarted ChunkStarted_mut: COPYFILE2_MESSAGE_ChunkStarted,
1775     ChunkFinished ChunkFinished_mut: COPYFILE2_MESSAGE_ChunkFinished,
1776     StreamStarted StreamStarted_mut: COPYFILE2_MESSAGE_StreamStarted,
1777     StreamFinished StreamFinished_mut: COPYFILE2_MESSAGE_StreamFinished,
1778     PollContinue PollContinue_mut: COPYFILE2_MESSAGE_PollContinue,
1779     Error Error_mut: COPYFILE2_MESSAGE_Error,
1780 }}
1781 STRUCT!{struct COPYFILE2_MESSAGE {
1782     Type: COPYFILE2_MESSAGE_TYPE,
1783     dwPadding: DWORD,
1784     Info: COPYFILE2_MESSAGE_Info,
1785 }}
1786 FN!{stdcall PCOPYFILE2_PROGRESS_ROUTINE(
1787     pMessage: *const COPYFILE2_MESSAGE,
1788     pvCallbackContext: PVOID,
1789 ) -> COPYFILE2_MESSAGE_ACTION}
1790 STRUCT!{struct COPYFILE2_EXTENDED_PARAMETERS {
1791     dwSize: DWORD,
1792     dwCopyFlags: DWORD,
1793     pfCancel: *mut BOOL,
1794     pProgressRoutine: PCOPYFILE2_PROGRESS_ROUTINE,
1795     pvCallbackContext: PVOID,
1796 }}
1797 extern "system" {
CopyFile2( pwszExistingFileName: PCWSTR, pwszNewFileName: PCWSTR, pExtendedParameters: *mut COPYFILE2_EXTENDED_PARAMETERS, ) -> HRESULT1798     pub fn CopyFile2(
1799         pwszExistingFileName: PCWSTR,
1800         pwszNewFileName: PCWSTR,
1801         pExtendedParameters: *mut COPYFILE2_EXTENDED_PARAMETERS,
1802     ) -> HRESULT;
MoveFileA( lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR ) -> BOOL1803     pub fn MoveFileA(
1804         lpExistingFileName: LPCSTR,
1805         lpNewFileName: LPCSTR
1806     ) -> BOOL;
MoveFileW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR ) -> BOOL1807     pub fn MoveFileW(
1808         lpExistingFileName: LPCWSTR,
1809         lpNewFileName: LPCWSTR
1810     ) -> BOOL;
MoveFileExA( lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, dwFlags: DWORD ) -> BOOL1811     pub fn MoveFileExA(
1812         lpExistingFileName: LPCSTR,
1813         lpNewFileName: LPCSTR,
1814         dwFlags: DWORD
1815     ) -> BOOL;
MoveFileExW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, dwFlags: DWORD ) -> BOOL1816     pub fn MoveFileExW(
1817         lpExistingFileName: LPCWSTR,
1818         lpNewFileName: LPCWSTR,
1819         dwFlags: DWORD
1820     ) -> BOOL;
MoveFileWithProgressA( lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD, ) -> BOOL1821     pub fn MoveFileWithProgressA(
1822         lpExistingFileName: LPCSTR,
1823         lpNewFileName: LPCSTR,
1824         lpProgressRoutine: LPPROGRESS_ROUTINE,
1825         lpData: LPVOID,
1826         dwFlags: DWORD,
1827     ) -> BOOL;
MoveFileWithProgressW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD, ) -> BOOL1828     pub fn MoveFileWithProgressW(
1829         lpExistingFileName: LPCWSTR,
1830         lpNewFileName: LPCWSTR,
1831         lpProgressRoutine: LPPROGRESS_ROUTINE,
1832         lpData: LPVOID,
1833         dwFlags: DWORD,
1834     ) -> BOOL;
MoveFileTransactedA( lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD, hTransaction: HANDLE, ) -> BOOL1835     pub fn MoveFileTransactedA(
1836         lpExistingFileName: LPCSTR,
1837         lpNewFileName: LPCSTR,
1838         lpProgressRoutine: LPPROGRESS_ROUTINE,
1839         lpData: LPVOID,
1840         dwFlags: DWORD,
1841         hTransaction: HANDLE,
1842     ) -> BOOL;
MoveFileTransactedW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD, hTransaction: HANDLE, ) -> BOOL1843     pub fn MoveFileTransactedW(
1844         lpExistingFileName: LPCWSTR,
1845         lpNewFileName: LPCWSTR,
1846         lpProgressRoutine: LPPROGRESS_ROUTINE,
1847         lpData: LPVOID,
1848         dwFlags: DWORD,
1849         hTransaction: HANDLE,
1850     ) -> BOOL;
1851 }
1852 pub const MOVEFILE_REPLACE_EXISTING: DWORD = 0x00000001;
1853 pub const MOVEFILE_COPY_ALLOWED: DWORD = 0x00000002;
1854 pub const MOVEFILE_DELAY_UNTIL_REBOOT: DWORD = 0x00000004;
1855 pub const MOVEFILE_WRITE_THROUGH: DWORD = 0x00000008;
1856 pub const MOVEFILE_CREATE_HARDLINK: DWORD = 0x00000010;
1857 pub const MOVEFILE_FAIL_IF_NOT_TRACKABLE: DWORD = 0x00000020;
1858 extern "system" {
ReplaceFileA( lpReplacedFileName: LPCSTR, lpReplacementFileName: LPCSTR, lpBackupFileName: LPCSTR, dwReplaceFlags: DWORD, lpExclude: LPVOID, lpReserved: LPVOID, )1859     pub fn ReplaceFileA(
1860         lpReplacedFileName: LPCSTR,
1861         lpReplacementFileName: LPCSTR,
1862         lpBackupFileName: LPCSTR,
1863         dwReplaceFlags: DWORD,
1864         lpExclude: LPVOID,
1865         lpReserved: LPVOID,
1866     );
ReplaceFileW( lpReplacedFileName: LPCWSTR, lpReplacementFileName: LPCWSTR, lpBackupFileName: LPCWSTR, dwReplaceFlags: DWORD, lpExclude: LPVOID, lpReserved: LPVOID, )1867     pub fn ReplaceFileW(
1868         lpReplacedFileName: LPCWSTR,
1869         lpReplacementFileName: LPCWSTR,
1870         lpBackupFileName: LPCWSTR,
1871         dwReplaceFlags: DWORD,
1872         lpExclude: LPVOID,
1873         lpReserved: LPVOID,
1874     );
CreateHardLinkA( lpFileName: LPCSTR, lpExistingFileName: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> BOOL1875     pub fn CreateHardLinkA(
1876         lpFileName: LPCSTR,
1877         lpExistingFileName: LPCSTR,
1878         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
1879     ) -> BOOL;
CreateHardLinkW( lpFileName: LPCWSTR, lpExistingFileName: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> BOOL1880     pub fn CreateHardLinkW(
1881         lpFileName: LPCWSTR,
1882         lpExistingFileName: LPCWSTR,
1883         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
1884     ) -> BOOL;
CreateHardLinkTransactedA( lpFileName: LPCSTR, lpExistingFileName: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE, ) -> BOOL1885     pub fn CreateHardLinkTransactedA(
1886         lpFileName: LPCSTR,
1887         lpExistingFileName: LPCSTR,
1888         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
1889         hTransaction: HANDLE,
1890     ) -> BOOL;
CreateHardLinkTransactedW( lpFileName: LPCWSTR, lpExistingFileName: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE, )1891     pub fn CreateHardLinkTransactedW(
1892         lpFileName: LPCWSTR,
1893         lpExistingFileName: LPCWSTR,
1894         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
1895         hTransaction: HANDLE,
1896     );
FindFirstStreamTransactedW( lpFileName: LPCWSTR, InfoLevel: STREAM_INFO_LEVELS, lpFindStreamData: LPVOID, dwFlags: DWORD, hTransaction: HANDLE, ) -> HANDLE1897     pub fn FindFirstStreamTransactedW(
1898         lpFileName: LPCWSTR,
1899         InfoLevel: STREAM_INFO_LEVELS,
1900         lpFindStreamData: LPVOID,
1901         dwFlags: DWORD,
1902         hTransaction: HANDLE,
1903     ) -> HANDLE;
FindFirstFileNameTransactedW( lpFileName: LPCWSTR, dwFlags: DWORD, StringLength: LPDWORD, LinkName: PWSTR, hTransaction: HANDLE, ) -> HANDLE1904     pub fn FindFirstFileNameTransactedW(
1905         lpFileName: LPCWSTR,
1906         dwFlags: DWORD,
1907         StringLength: LPDWORD,
1908         LinkName: PWSTR,
1909         hTransaction: HANDLE,
1910     ) -> HANDLE;
CreateNamedPipeA( lpName: LPCSTR, dwOpenMode: DWORD, dwPipeMode: DWORD, nMaxInstances: DWORD, nOutBufferSize: DWORD, nInBufferSize: DWORD, nDefaultTimeOut: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> HANDLE1911     pub fn CreateNamedPipeA(
1912         lpName: LPCSTR,
1913         dwOpenMode: DWORD,
1914         dwPipeMode: DWORD,
1915         nMaxInstances: DWORD,
1916         nOutBufferSize: DWORD,
1917         nInBufferSize: DWORD,
1918         nDefaultTimeOut: DWORD,
1919         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
1920     ) -> HANDLE;
GetNamedPipeHandleStateA( hNamedPipe: HANDLE, lpState: LPDWORD, lpCurInstances: LPDWORD, lpMaxCollectionCount: LPDWORD, lpCollectDataTimeout: LPDWORD, lpUserName: LPSTR, nMaxUserNameSize: DWORD, ) -> BOOL1921     pub fn GetNamedPipeHandleStateA(
1922         hNamedPipe: HANDLE,
1923         lpState: LPDWORD,
1924         lpCurInstances: LPDWORD,
1925         lpMaxCollectionCount: LPDWORD,
1926         lpCollectDataTimeout: LPDWORD,
1927         lpUserName: LPSTR,
1928         nMaxUserNameSize: DWORD,
1929     ) -> BOOL;
CallNamedPipeA( lpNamedPipeName: LPCSTR, lpInBuffer: LPVOID, nInBufferSize: DWORD, lpOutBuffer: LPVOID, nOutBufferSize: DWORD, lpBytesRead: LPDWORD, nTimeOut: DWORD, ) -> BOOL1930     pub fn CallNamedPipeA(
1931         lpNamedPipeName: LPCSTR,
1932         lpInBuffer: LPVOID,
1933         nInBufferSize: DWORD,
1934         lpOutBuffer: LPVOID,
1935         nOutBufferSize: DWORD,
1936         lpBytesRead: LPDWORD,
1937         nTimeOut: DWORD,
1938     ) -> BOOL;
WaitNamedPipeA( lpNamedPipeName: LPCSTR, nTimeOut: DWORD ) -> BOOL1939     pub fn WaitNamedPipeA(
1940         lpNamedPipeName: LPCSTR,
1941         nTimeOut: DWORD
1942     ) -> BOOL;
GetNamedPipeClientComputerNameA( Pipe: HANDLE, ClientComputerName: LPSTR, ClientComputerNameLength: ULONG, ) -> BOOL1943     pub fn GetNamedPipeClientComputerNameA(
1944         Pipe: HANDLE,
1945         ClientComputerName: LPSTR,
1946         ClientComputerNameLength: ULONG,
1947     ) -> BOOL;
GetNamedPipeClientProcessId( Pipe: HANDLE, ClientProcessId: PULONG ) -> BOOL1948     pub fn GetNamedPipeClientProcessId(
1949         Pipe: HANDLE,
1950         ClientProcessId: PULONG
1951     ) -> BOOL;
GetNamedPipeClientSessionId( Pipe: HANDLE, ClientSessionId: PULONG ) -> BOOL1952     pub fn GetNamedPipeClientSessionId(
1953         Pipe: HANDLE,
1954         ClientSessionId: PULONG
1955     ) -> BOOL;
GetNamedPipeServerProcessId( Pipe: HANDLE, ServerProcessId: PULONG ) -> BOOL1956     pub fn GetNamedPipeServerProcessId(
1957         Pipe: HANDLE,
1958         ServerProcessId: PULONG
1959     ) -> BOOL;
GetNamedPipeServerSessionId( Pipe: HANDLE, ServerSessionId: PULONG ) -> BOOL1960     pub fn GetNamedPipeServerSessionId(
1961         Pipe: HANDLE,
1962         ServerSessionId: PULONG
1963     ) -> BOOL;
SetVolumeLabelA( lpRootPathName: LPCSTR, lpVolumeName: LPCSTR ) -> BOOL1964     pub fn SetVolumeLabelA(
1965         lpRootPathName: LPCSTR,
1966         lpVolumeName: LPCSTR
1967     ) -> BOOL;
SetVolumeLabelW( lpRootPathName: LPCWSTR, lpVolumeName: LPCWSTR ) -> BOOL1968     pub fn SetVolumeLabelW(
1969         lpRootPathName: LPCWSTR,
1970         lpVolumeName: LPCWSTR
1971     ) -> BOOL;
SetFileBandwidthReservation( hFile: HANDLE, nPeriodMilliseconds: DWORD, nBytesPerPeriod: DWORD, bDiscardable: BOOL, lpTransferSize: LPDWORD, lpNumOutstandingRequests: LPDWORD, ) -> BOOL1972     pub fn SetFileBandwidthReservation(
1973         hFile: HANDLE,
1974         nPeriodMilliseconds: DWORD,
1975         nBytesPerPeriod: DWORD,
1976         bDiscardable: BOOL,
1977         lpTransferSize: LPDWORD,
1978         lpNumOutstandingRequests: LPDWORD,
1979     ) -> BOOL;
GetFileBandwidthReservation( hFile: HANDLE, lpPeriodMilliseconds: LPDWORD, lpBytesPerPeriod: LPDWORD, pDiscardable: LPBOOL, lpTransferSize: LPDWORD, lpNumOutstandingRequests: LPDWORD, ) -> BOOL1980     pub fn GetFileBandwidthReservation(
1981         hFile: HANDLE,
1982         lpPeriodMilliseconds: LPDWORD,
1983         lpBytesPerPeriod: LPDWORD,
1984         pDiscardable: LPBOOL,
1985         lpTransferSize: LPDWORD,
1986         lpNumOutstandingRequests: LPDWORD,
1987     ) -> BOOL;
1988     // pub fn ClearEventLogA();
1989     // pub fn ClearEventLogW();
1990     // pub fn BackupEventLogA();
1991     // pub fn BackupEventLogW();
1992     // pub fn CloseEventLog();
DeregisterEventSource( hEventLog: HANDLE, ) -> BOOL1993     pub fn DeregisterEventSource(
1994         hEventLog: HANDLE,
1995     ) -> BOOL;
1996     // pub fn NotifyChangeEventLog();
1997     // pub fn GetNumberOfEventLogRecords();
1998     // pub fn GetOldestEventLogRecord();
1999     // pub fn OpenEventLogA();
2000     // pub fn OpenEventLogW();
RegisterEventSourceA( lpUNCServerName: LPCSTR, lpSourceName: LPCSTR, ) -> HANDLE2001     pub fn RegisterEventSourceA(
2002         lpUNCServerName: LPCSTR,
2003         lpSourceName: LPCSTR,
2004     ) -> HANDLE;
RegisterEventSourceW( lpUNCServerName: LPCWSTR, lpSourceName: LPCWSTR, ) -> HANDLE2005     pub fn RegisterEventSourceW(
2006         lpUNCServerName: LPCWSTR,
2007         lpSourceName: LPCWSTR,
2008     ) -> HANDLE;
2009     // pub fn OpenBackupEventLogA();
2010     // pub fn OpenBackupEventLogW();
2011     // pub fn ReadEventLogA();
2012     // pub fn ReadEventLogW();
ReportEventA( hEventLog: HANDLE, wType: WORD, wCategory: WORD, dwEventID: DWORD, lpUserSid: PSID, wNumStrings: WORD, dwDataSize: DWORD, lpStrings: *mut LPCSTR, lpRawData: LPVOID, ) -> BOOL2013     pub fn ReportEventA(
2014         hEventLog: HANDLE,
2015         wType: WORD,
2016         wCategory: WORD,
2017         dwEventID: DWORD,
2018         lpUserSid: PSID,
2019         wNumStrings: WORD,
2020         dwDataSize: DWORD,
2021         lpStrings: *mut LPCSTR,
2022         lpRawData: LPVOID,
2023     ) -> BOOL;
ReportEventW( hEventLog: HANDLE, wType: WORD, wCategory: WORD, dwEventID: DWORD, lpUserSid: PSID, wNumStrings: WORD, dwDataSize: DWORD, lpStrings: *mut LPCWSTR, lpRawData: LPVOID, ) -> BOOL2024     pub fn ReportEventW(
2025         hEventLog: HANDLE,
2026         wType: WORD,
2027         wCategory: WORD,
2028         dwEventID: DWORD,
2029         lpUserSid: PSID,
2030         wNumStrings: WORD,
2031         dwDataSize: DWORD,
2032         lpStrings: *mut LPCWSTR,
2033         lpRawData: LPVOID,
2034     ) -> BOOL;
2035     // pub fn GetEventLogInformation();
2036     // pub fn OperationStart();
2037     // pub fn OperationEnd();
2038     // pub fn AccessCheckAndAuditAlarmA();
2039     // pub fn AccessCheckByTypeAndAuditAlarmA();
2040     // pub fn AccessCheckByTypeResultListAndAuditAlarmA();
2041     // pub fn AccessCheckByTypeResultListAndAuditAlarmByHandleA();
2042     // pub fn ObjectOpenAuditAlarmA();
2043     // pub fn ObjectPrivilegeAuditAlarmA();
2044     // pub fn ObjectCloseAuditAlarmA();
2045     // pub fn ObjectDeleteAuditAlarmA();
2046     // pub fn PrivilegedServiceAuditAlarmA();
2047     // pub fn AddConditionalAce();
2048     // pub fn SetFileSecurityA();
2049     // pub fn GetFileSecurityA();
ReadDirectoryChangesW( hDirectory: HANDLE, lpBuffer: LPVOID, nBufferLength: DWORD, bWatchSubtree: BOOL, dwNotifyFilter: DWORD, lpBytesReturned: LPDWORD, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE, ) -> BOOL2050     pub fn ReadDirectoryChangesW(
2051         hDirectory: HANDLE,
2052         lpBuffer: LPVOID,
2053         nBufferLength: DWORD,
2054         bWatchSubtree: BOOL,
2055         dwNotifyFilter: DWORD,
2056         lpBytesReturned: LPDWORD,
2057         lpOverlapped: LPOVERLAPPED,
2058         lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE,
2059     ) -> BOOL;
MapViewOfFileExNuma( hFileMappingObject: HANDLE, dwDesiredAccess: DWORD, dwFileOffsetHigh: DWORD, dwFileOffsetLow: DWORD, dwNumberOfBytesToMap: SIZE_T, lpBaseAddress: LPVOID, nndPreferred: DWORD, ) -> LPVOID2060     pub fn MapViewOfFileExNuma(
2061         hFileMappingObject: HANDLE,
2062         dwDesiredAccess: DWORD,
2063         dwFileOffsetHigh: DWORD,
2064         dwFileOffsetLow: DWORD,
2065         dwNumberOfBytesToMap: SIZE_T,
2066         lpBaseAddress: LPVOID,
2067         nndPreferred: DWORD,
2068     ) -> LPVOID;
IsBadReadPtr( lp: *const VOID, ucb: UINT_PTR ) -> BOOL2069     pub fn IsBadReadPtr(
2070         lp: *const VOID,
2071         ucb: UINT_PTR
2072     ) -> BOOL;
IsBadWritePtr( lp: LPVOID, ucb: UINT_PTR ) -> BOOL2073     pub fn IsBadWritePtr(
2074         lp: LPVOID,
2075         ucb: UINT_PTR
2076     ) -> BOOL;
IsBadHugeReadPtr( lp: *const VOID, ucb: UINT_PTR ) -> BOOL2077     pub fn IsBadHugeReadPtr(
2078         lp: *const VOID,
2079         ucb: UINT_PTR
2080     ) -> BOOL;
IsBadHugeWritePtr( lp: LPVOID, ucb: UINT_PTR ) -> BOOL2081     pub fn IsBadHugeWritePtr(
2082         lp: LPVOID,
2083         ucb: UINT_PTR
2084     ) -> BOOL;
IsBadCodePtr( lpfn: FARPROC ) -> BOOL2085     pub fn IsBadCodePtr(
2086         lpfn: FARPROC
2087     ) -> BOOL;
IsBadStringPtrA( lpsz: LPCSTR, ucchMax: UINT_PTR ) -> BOOL2088     pub fn IsBadStringPtrA(
2089         lpsz: LPCSTR,
2090         ucchMax: UINT_PTR
2091     ) -> BOOL;
IsBadStringPtrW( lpsz: LPCWSTR, ucchMax: UINT_PTR ) -> BOOL2092     pub fn IsBadStringPtrW(
2093         lpsz: LPCWSTR,
2094         ucchMax: UINT_PTR
2095     ) -> BOOL;
LookupAccountSidA( lpSystemName: LPCSTR, Sid: PSID, Name: LPSTR, cchName: LPDWORD, ReferencedDomainName: LPSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE, ) -> BOOL2096     pub fn LookupAccountSidA(
2097         lpSystemName: LPCSTR,
2098         Sid: PSID,
2099         Name: LPSTR,
2100         cchName: LPDWORD,
2101         ReferencedDomainName: LPSTR,
2102         cchReferencedDomainName: LPDWORD,
2103         peUse: PSID_NAME_USE,
2104     ) -> BOOL;
LookupAccountSidW( lpSystemName: LPCWSTR, Sid: PSID, Name: LPWSTR, cchName: LPDWORD, ReferencedDomainName: LPWSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE, ) -> BOOL2105     pub fn LookupAccountSidW(
2106         lpSystemName: LPCWSTR,
2107         Sid: PSID,
2108         Name: LPWSTR,
2109         cchName: LPDWORD,
2110         ReferencedDomainName: LPWSTR,
2111         cchReferencedDomainName: LPDWORD,
2112         peUse: PSID_NAME_USE,
2113     ) -> BOOL;
LookupAccountNameA( lpSystemName: LPCSTR, lpAccountName: LPCSTR, Sid: PSID, cbSid: LPDWORD, ReferencedDomainName: LPCSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE, ) -> BOOL2114     pub fn LookupAccountNameA(
2115         lpSystemName: LPCSTR,
2116         lpAccountName: LPCSTR,
2117         Sid: PSID,
2118         cbSid: LPDWORD,
2119         ReferencedDomainName: LPCSTR,
2120         cchReferencedDomainName: LPDWORD,
2121         peUse: PSID_NAME_USE,
2122     ) -> BOOL;
LookupAccountNameW( lpSystemName: LPCWSTR, lpAccountName: LPCWSTR, Sid: PSID, cbSid: LPDWORD, ReferencedDomainName: LPCWSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE, ) -> BOOL2123     pub fn LookupAccountNameW(
2124         lpSystemName: LPCWSTR,
2125         lpAccountName: LPCWSTR,
2126         Sid: PSID,
2127         cbSid: LPDWORD,
2128         ReferencedDomainName: LPCWSTR,
2129         cchReferencedDomainName: LPDWORD,
2130         peUse: PSID_NAME_USE,
2131     ) -> BOOL;
2132     // pub fn LookupAccountNameLocalA();
2133     // pub fn LookupAccountNameLocalW();
2134     // pub fn LookupAccountSidLocalA();
2135     // pub fn LookupAccountSidLocalW();
LookupPrivilegeValueA( lpSystemName: LPCSTR, lpName: LPCSTR, lpLuid: PLUID, ) -> BOOL2136     pub fn LookupPrivilegeValueA(
2137         lpSystemName: LPCSTR,
2138         lpName: LPCSTR,
2139         lpLuid: PLUID,
2140     ) -> BOOL;
LookupPrivilegeValueW( lpSystemName: LPCWSTR, lpName: LPCWSTR, lpLuid: PLUID, ) -> BOOL2141     pub fn LookupPrivilegeValueW(
2142         lpSystemName: LPCWSTR,
2143         lpName: LPCWSTR,
2144         lpLuid: PLUID,
2145     ) -> BOOL;
LookupPrivilegeNameA( lpSystemName: LPCSTR, lpLuid: PLUID, lpName: LPSTR, cchName: LPDWORD, ) -> BOOL2146     pub fn LookupPrivilegeNameA(
2147         lpSystemName: LPCSTR,
2148         lpLuid: PLUID,
2149         lpName: LPSTR,
2150         cchName: LPDWORD,
2151     ) -> BOOL;
LookupPrivilegeNameW( lpSystemName: LPCWSTR, lpLuid: PLUID, lpName: LPWSTR, cchName: LPDWORD, ) -> BOOL2152     pub fn LookupPrivilegeNameW(
2153         lpSystemName: LPCWSTR,
2154         lpLuid: PLUID,
2155         lpName: LPWSTR,
2156         cchName: LPDWORD,
2157     ) -> BOOL;
2158     // pub fn LookupPrivilegeDisplayNameA();
2159     // pub fn LookupPrivilegeDisplayNameW();
BuildCommDCBA( lpDef: LPCSTR, lpDCB: LPDCB ) -> BOOL2160     pub fn BuildCommDCBA(
2161         lpDef: LPCSTR,
2162         lpDCB: LPDCB
2163     ) -> BOOL;
BuildCommDCBW( lpDef: LPCWSTR, lpDCB: LPDCB ) -> BOOL2164     pub fn BuildCommDCBW(
2165         lpDef: LPCWSTR,
2166         lpDCB: LPDCB
2167     ) -> BOOL;
BuildCommDCBAndTimeoutsA( lpDef: LPCSTR, lpDCB: LPDCB, lpCommTimeouts: LPCOMMTIMEOUTS, ) -> BOOL2168     pub fn BuildCommDCBAndTimeoutsA(
2169         lpDef: LPCSTR,
2170         lpDCB: LPDCB,
2171         lpCommTimeouts: LPCOMMTIMEOUTS,
2172     ) -> BOOL;
BuildCommDCBAndTimeoutsW( lpDef: LPCWSTR, lpDCB: LPDCB, lpCommTimeouts: LPCOMMTIMEOUTS, ) -> BOOL2173     pub fn BuildCommDCBAndTimeoutsW(
2174         lpDef: LPCWSTR,
2175         lpDCB: LPDCB,
2176         lpCommTimeouts: LPCOMMTIMEOUTS,
2177     ) -> BOOL;
CommConfigDialogA( lpszName: LPCSTR, hWnd: HWND, lpCC: LPCOMMCONFIG ) -> BOOL2178     pub fn CommConfigDialogA(
2179         lpszName: LPCSTR,
2180         hWnd: HWND,
2181         lpCC: LPCOMMCONFIG
2182     ) -> BOOL;
CommConfigDialogW( lpszName: LPCWSTR, hWnd: HWND, lpCC: LPCOMMCONFIG ) -> BOOL2183     pub fn CommConfigDialogW(
2184         lpszName: LPCWSTR,
2185         hWnd: HWND,
2186         lpCC: LPCOMMCONFIG
2187     ) -> BOOL;
GetDefaultCommConfigA( lpszName: LPCSTR, lpCC: LPCOMMCONFIG, lpdwSize: LPDWORD ) -> BOOL2188     pub fn GetDefaultCommConfigA(
2189         lpszName: LPCSTR,
2190         lpCC: LPCOMMCONFIG,
2191         lpdwSize: LPDWORD
2192     ) -> BOOL;
GetDefaultCommConfigW( lpszName: LPCWSTR, lpCC: LPCOMMCONFIG, lpdwSize: LPDWORD ) -> BOOL2193     pub fn GetDefaultCommConfigW(
2194         lpszName: LPCWSTR,
2195         lpCC: LPCOMMCONFIG,
2196         lpdwSize: LPDWORD
2197     ) -> BOOL;
SetDefaultCommConfigA( lpszName: LPCSTR, lpCC: LPCOMMCONFIG, dwSize: DWORD ) -> BOOL2198     pub fn SetDefaultCommConfigA(
2199         lpszName: LPCSTR,
2200         lpCC: LPCOMMCONFIG,
2201         dwSize: DWORD
2202     ) -> BOOL;
SetDefaultCommConfigW( lpszName: LPCWSTR, lpCC: LPCOMMCONFIG, dwSize: DWORD ) -> BOOL2203     pub fn SetDefaultCommConfigW(
2204         lpszName: LPCWSTR,
2205         lpCC: LPCOMMCONFIG,
2206         dwSize: DWORD
2207     ) -> BOOL;
GetComputerNameA( lpBuffer: LPSTR, nSize: LPDWORD ) -> BOOL2208     pub fn GetComputerNameA(
2209         lpBuffer: LPSTR,
2210         nSize: LPDWORD
2211     ) -> BOOL;
GetComputerNameW( lpBuffer: LPWSTR, nSize: LPDWORD ) -> BOOL2212     pub fn GetComputerNameW(
2213         lpBuffer: LPWSTR,
2214         nSize: LPDWORD
2215     ) -> BOOL;
DnsHostnameToComputerNameA( Hostname: LPCSTR, ComputerName: LPCSTR, nSize: LPDWORD, ) -> BOOL2216     pub fn DnsHostnameToComputerNameA(
2217         Hostname: LPCSTR,
2218         ComputerName: LPCSTR,
2219         nSize: LPDWORD,
2220     ) -> BOOL;
DnsHostnameToComputerNameW( Hostname: LPCWSTR, ComputerName: LPWSTR, nSize: LPDWORD, ) -> BOOL2221     pub fn DnsHostnameToComputerNameW(
2222         Hostname: LPCWSTR,
2223         ComputerName: LPWSTR,
2224         nSize: LPDWORD,
2225     ) -> BOOL;
GetUserNameA( lpBuffer: LPSTR, pcbBuffer: LPDWORD ) -> BOOL2226     pub fn GetUserNameA(
2227         lpBuffer: LPSTR,
2228         pcbBuffer: LPDWORD
2229     ) -> BOOL;
GetUserNameW( lpBuffer: LPWSTR, pcbBuffer: LPDWORD ) -> BOOL2230     pub fn GetUserNameW(
2231         lpBuffer: LPWSTR,
2232         pcbBuffer: LPDWORD
2233     ) -> BOOL;
2234 }
2235 pub const LOGON32_LOGON_INTERACTIVE: DWORD = 2;
2236 pub const LOGON32_LOGON_NETWORK: DWORD = 3;
2237 pub const LOGON32_LOGON_BATCH: DWORD = 4;
2238 pub const LOGON32_LOGON_SERVICE: DWORD = 5;
2239 pub const LOGON32_LOGON_UNLOCK: DWORD = 7;
2240 pub const LOGON32_LOGON_NETWORK_CLEARTEXT: DWORD = 8;
2241 pub const LOGON32_LOGON_NEW_CREDENTIALS: DWORD = 9;
2242 pub const LOGON32_PROVIDER_DEFAULT: DWORD = 0;
2243 pub const LOGON32_PROVIDER_WINNT35: DWORD = 1;
2244 pub const LOGON32_PROVIDER_WINNT40: DWORD = 2;
2245 pub const LOGON32_PROVIDER_WINNT50: DWORD = 3;
2246 pub const LOGON32_PROVIDER_VIRTUAL: DWORD = 4;
2247 extern "system" {
LogonUserA( lpUsername: LPCSTR, lpDomain: LPCSTR, lpPassword: LPCSTR, dwLogonType: DWORD, dwLogonProvider: DWORD, phToken: PHANDLE ) -> BOOL2248     pub fn LogonUserA(
2249         lpUsername: LPCSTR,
2250         lpDomain: LPCSTR,
2251         lpPassword: LPCSTR,
2252         dwLogonType: DWORD,
2253         dwLogonProvider: DWORD,
2254         phToken: PHANDLE
2255     ) -> BOOL;
LogonUserW( lpUsername: LPCWSTR, lpDomain: LPCWSTR, lpPassword: LPCWSTR, dwLogonType: DWORD, dwLogonProvider: DWORD, phToken: PHANDLE ) -> BOOL2256     pub fn LogonUserW(
2257         lpUsername: LPCWSTR,
2258         lpDomain: LPCWSTR,
2259         lpPassword: LPCWSTR,
2260         dwLogonType: DWORD,
2261         dwLogonProvider: DWORD,
2262         phToken: PHANDLE
2263     ) -> 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, ) -> BOOL2264     pub fn LogonUserExA(
2265         lpUsername: LPCSTR,
2266         lpDomain: LPCSTR,
2267         lpPassword: LPCSTR,
2268         dwLogonType: DWORD,
2269         dwLogonProvider: DWORD,
2270         phToken: PHANDLE,
2271         ppLogonSid: *mut PSID,
2272         ppProfileBuffer: *mut PVOID,
2273         pdwProfileLength: LPDWORD,
2274         pQuotaLimits: PQUOTA_LIMITS,
2275     ) -> 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, ) -> BOOL2276     pub fn LogonUserExW(
2277         lpUsername: LPCWSTR,
2278         lpDomain: LPCWSTR,
2279         lpPassword: LPCWSTR,
2280         dwLogonType: DWORD,
2281         dwLogonProvider: DWORD,
2282         phToken: PHANDLE,
2283         ppLogonSid: *mut PSID,
2284         ppProfileBuffer: *mut PVOID,
2285         pdwProfileLength: LPDWORD,
2286         pQuotaLimits: PQUOTA_LIMITS,
2287     ) -> BOOL;
2288     // pub fn CreateProcessWithLogonW();
2289     // pub fn CreateProcessWithTokenW();
2290     // pub fn IsTokenUntrusted();
RegisterWaitForSingleObject( phNewWaitObject: PHANDLE, hObject: HANDLE, Callback: WAITORTIMERCALLBACK, Context: PVOID, dwMilliseconds: ULONG, dwFlags: ULONG, ) -> BOOL2291     pub fn RegisterWaitForSingleObject(
2292         phNewWaitObject: PHANDLE,
2293         hObject: HANDLE,
2294         Callback: WAITORTIMERCALLBACK,
2295         Context: PVOID,
2296         dwMilliseconds: ULONG,
2297         dwFlags: ULONG,
2298     ) -> BOOL;
UnregisterWait( WaitHandle: HANDLE ) -> BOOL2299     pub fn UnregisterWait(
2300         WaitHandle: HANDLE
2301     ) -> BOOL;
BindIoCompletionCallback( FileHandle: HANDLE, Function: LPOVERLAPPED_COMPLETION_ROUTINE, Flags: ULONG, ) -> BOOL2302     pub fn BindIoCompletionCallback(
2303         FileHandle: HANDLE,
2304         Function: LPOVERLAPPED_COMPLETION_ROUTINE,
2305         Flags: ULONG,
2306     ) -> BOOL;
SetTimerQueueTimer( TimerQueue: HANDLE, Callback: WAITORTIMERCALLBACK, Parameter: PVOID, DueTime: DWORD, Period: DWORD, PreferIo: BOOL, ) -> HANDLE2307     pub fn SetTimerQueueTimer(
2308         TimerQueue: HANDLE,
2309         Callback: WAITORTIMERCALLBACK,
2310         Parameter: PVOID,
2311         DueTime: DWORD,
2312         Period: DWORD,
2313         PreferIo: BOOL,
2314     ) -> HANDLE;
CancelTimerQueueTimer( TimerQueue: HANDLE, Timer: HANDLE ) -> BOOL2315     pub fn CancelTimerQueueTimer(
2316         TimerQueue: HANDLE,
2317         Timer: HANDLE
2318     ) -> BOOL;
DeleteTimerQueue( TimerQueue: HANDLE ) -> BOOL2319     pub fn DeleteTimerQueue(
2320         TimerQueue: HANDLE
2321     ) -> BOOL;
2322     // pub fn InitializeThreadpoolEnvironment();
2323     // pub fn SetThreadpoolCallbackPool();
2324     // pub fn SetThreadpoolCallbackCleanupGroup();
2325     // pub fn SetThreadpoolCallbackRunsLong();
2326     // pub fn SetThreadpoolCallbackLibrary();
2327     // pub fn SetThreadpoolCallbackPriority();
2328     // pub fn DestroyThreadpoolEnvironment();
2329     // pub fn SetThreadpoolCallbackPersistent();
CreatePrivateNamespaceA( lpPrivateNamespaceAttributes: LPSECURITY_ATTRIBUTES, lpBoundaryDescriptor: LPVOID, lpAliasPrefix: LPCSTR, ) -> HANDLE2330     pub fn CreatePrivateNamespaceA(
2331         lpPrivateNamespaceAttributes: LPSECURITY_ATTRIBUTES,
2332         lpBoundaryDescriptor: LPVOID,
2333         lpAliasPrefix: LPCSTR,
2334     ) -> HANDLE;
OpenPrivateNamespaceA( lpBoundaryDescriptor: LPVOID, lpAliasPrefix: LPCSTR ) -> HANDLE2335     pub fn OpenPrivateNamespaceA(
2336         lpBoundaryDescriptor: LPVOID,
2337         lpAliasPrefix: LPCSTR
2338     ) -> HANDLE;
CreateBoundaryDescriptorA( Name: LPCSTR, Flags: ULONG ) -> HANDLE2339     pub fn CreateBoundaryDescriptorA(
2340         Name: LPCSTR,
2341         Flags: ULONG
2342     ) -> HANDLE;
AddIntegrityLabelToBoundaryDescriptor( BoundaryDescriptor: *mut HANDLE, IntegrityLabel: PSID, ) -> BOOL2343     pub fn AddIntegrityLabelToBoundaryDescriptor(
2344         BoundaryDescriptor: *mut HANDLE,
2345         IntegrityLabel: PSID,
2346     ) -> BOOL;
2347 }
2348 pub const HW_PROFILE_GUIDLEN: usize = 39;
2349 // MAX_PROFILE_LEN
2350 pub const DOCKINFO_UNDOCKED: DWORD = 0x1;
2351 pub const DOCKINFO_DOCKED: DWORD = 0x2;
2352 pub const DOCKINFO_USER_SUPPLIED: DWORD = 0x4;
2353 pub const DOCKINFO_USER_UNDOCKED: DWORD = DOCKINFO_USER_SUPPLIED | DOCKINFO_UNDOCKED;
2354 pub const DOCKINFO_USER_DOCKED: DWORD = DOCKINFO_USER_SUPPLIED | DOCKINFO_DOCKED;
2355 STRUCT!{struct HW_PROFILE_INFOA {
2356     dwDockInfo: DWORD,
2357     szHwProfileGuid: [CHAR; HW_PROFILE_GUIDLEN],
2358     szHwProfileName: [CHAR; MAX_PROFILE_LEN],
2359 }}
2360 pub type LPHW_PROFILE_INFOA = *mut HW_PROFILE_INFOA;
2361 STRUCT!{struct HW_PROFILE_INFOW {
2362     dwDockInfo: DWORD,
2363     szHwProfileGuid: [WCHAR; HW_PROFILE_GUIDLEN],
2364     szHwProfileName: [WCHAR; MAX_PROFILE_LEN],
2365 }}
2366 pub type LPHW_PROFILE_INFOW = *mut HW_PROFILE_INFOW;
2367 extern "system" {
GetCurrentHwProfileA( lpHwProfileInfo: LPHW_PROFILE_INFOA ) -> BOOL2368     pub fn GetCurrentHwProfileA(
2369         lpHwProfileInfo: LPHW_PROFILE_INFOA
2370     ) -> BOOL;
GetCurrentHwProfileW( lpHwProfileInfo: LPHW_PROFILE_INFOW ) -> BOOL2371     pub fn GetCurrentHwProfileW(
2372         lpHwProfileInfo: LPHW_PROFILE_INFOW
2373     ) -> BOOL;
VerifyVersionInfoA( lpVersionInformation: LPOSVERSIONINFOEXA, dwTypeMask: DWORD, dwlConditionMask: DWORDLONG, ) -> BOOL2374     pub fn VerifyVersionInfoA(
2375         lpVersionInformation: LPOSVERSIONINFOEXA,
2376         dwTypeMask: DWORD,
2377         dwlConditionMask: DWORDLONG,
2378     ) -> BOOL;
VerifyVersionInfoW( lpVersionInformation: LPOSVERSIONINFOEXW, dwTypeMask: DWORD, dwlConditionMask: DWORDLONG, ) -> BOOL2379     pub fn VerifyVersionInfoW(
2380         lpVersionInformation: LPOSVERSIONINFOEXW,
2381         dwTypeMask: DWORD,
2382         dwlConditionMask: DWORDLONG,
2383     ) -> BOOL;
2384 }
2385 STRUCT!{struct SYSTEM_POWER_STATUS {
2386     ACLineStatus: BYTE,
2387     BatteryFlag: BYTE,
2388     BatteryLifePercent: BYTE,
2389     Reserved1: BYTE,
2390     BatteryLifeTime: DWORD,
2391     BatteryFullLifeTime: DWORD,
2392 }}
2393 pub type LPSYSTEM_POWER_STATUS = *mut SYSTEM_POWER_STATUS;
2394 extern "system" {
GetSystemPowerStatus( lpSystemPowerStatus: LPSYSTEM_POWER_STATUS ) -> BOOL2395     pub fn GetSystemPowerStatus(
2396         lpSystemPowerStatus: LPSYSTEM_POWER_STATUS
2397     ) -> BOOL;
SetSystemPowerState( fSuspend: BOOL, fForce: BOOL ) -> BOOL2398     pub fn SetSystemPowerState(
2399         fSuspend: BOOL,
2400         fForce: BOOL
2401     ) -> BOOL;
MapUserPhysicalPagesScatter( VirtualAddresses: *mut PVOID, NumberOfPages: ULONG_PTR, PageArray: PULONG_PTR, ) -> BOOL2402     pub fn MapUserPhysicalPagesScatter(
2403         VirtualAddresses: *mut PVOID,
2404         NumberOfPages: ULONG_PTR,
2405         PageArray: PULONG_PTR,
2406     ) -> BOOL;
CreateJobObjectA( lpJobAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCSTR ) -> HANDLE2407     pub fn CreateJobObjectA(
2408         lpJobAttributes: LPSECURITY_ATTRIBUTES,
2409         lpName: LPCSTR
2410     ) -> HANDLE;
OpenJobObjectA( dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR ) -> HANDLE2411     pub fn OpenJobObjectA(
2412         dwDesiredAccess: DWORD,
2413         bInheritHandle: BOOL,
2414         lpName: LPCSTR
2415     ) -> HANDLE;
CreateJobSet( NumJob: ULONG, UserJobSet: PJOB_SET_ARRAY, Flags: ULONG ) -> BOOL2416     pub fn CreateJobSet(
2417         NumJob: ULONG,
2418         UserJobSet: PJOB_SET_ARRAY,
2419         Flags: ULONG
2420     ) -> BOOL;
FindFirstVolumeA( lpszVolumeName: LPSTR, cchBufferLength: DWORD ) -> HANDLE2421     pub fn FindFirstVolumeA(
2422         lpszVolumeName: LPSTR,
2423         cchBufferLength: DWORD
2424     ) -> HANDLE;
FindNextVolumeA( hFindVolume: HANDLE, lpszVolumeName: LPSTR, cchBufferLength: DWORD, ) -> BOOL2425     pub fn FindNextVolumeA(
2426         hFindVolume: HANDLE,
2427         lpszVolumeName: LPSTR,
2428         cchBufferLength: DWORD,
2429     ) -> BOOL;
FindFirstVolumeMountPointA( lpszRootPathName: LPCSTR, lpszVolumeMountPoint: LPSTR, cchBufferLength: DWORD, ) -> HANDLE2430     pub fn FindFirstVolumeMountPointA(
2431         lpszRootPathName: LPCSTR,
2432         lpszVolumeMountPoint: LPSTR,
2433         cchBufferLength: DWORD,
2434     ) -> HANDLE;
FindFirstVolumeMountPointW( lpszRootPathName: LPCWSTR, lpszVolumeMountPoint: LPWSTR, cchBufferLength: DWORD, ) -> HANDLE2435     pub fn FindFirstVolumeMountPointW(
2436         lpszRootPathName: LPCWSTR,
2437         lpszVolumeMountPoint: LPWSTR,
2438         cchBufferLength: DWORD,
2439     ) -> HANDLE;
FindNextVolumeMountPointA( hFindVolumeMountPoint: HANDLE, lpszVolumeMountPoint: LPSTR, cchBufferLength: DWORD, ) -> BOOL2440     pub fn FindNextVolumeMountPointA(
2441         hFindVolumeMountPoint: HANDLE,
2442         lpszVolumeMountPoint: LPSTR,
2443         cchBufferLength: DWORD,
2444     ) -> BOOL;
FindNextVolumeMountPointW( hFindVolumeMountPoint: HANDLE, lpszVolumeMountPoint: LPWSTR, cchBufferLength: DWORD, ) -> BOOL2445     pub fn FindNextVolumeMountPointW(
2446         hFindVolumeMountPoint: HANDLE,
2447         lpszVolumeMountPoint: LPWSTR,
2448         cchBufferLength: DWORD,
2449     ) -> BOOL;
FindVolumeMountPointClose( hFindVolumeMountPoint: HANDLE ) -> BOOL2450     pub fn FindVolumeMountPointClose(
2451         hFindVolumeMountPoint: HANDLE
2452     ) -> BOOL;
SetVolumeMountPointA( lpszVolumeMountPoint: LPCSTR, lpszVolumeName: LPCSTR ) -> BOOL2453     pub fn SetVolumeMountPointA(
2454         lpszVolumeMountPoint: LPCSTR,
2455         lpszVolumeName: LPCSTR
2456     ) -> BOOL;
SetVolumeMountPointW( lpszVolumeMountPoint: LPCWSTR, lpszVolumeName: LPCWSTR ) -> BOOL2457     pub fn SetVolumeMountPointW(
2458         lpszVolumeMountPoint: LPCWSTR,
2459         lpszVolumeName: LPCWSTR
2460     ) -> BOOL;
DeleteVolumeMountPointA( lpszVolumeMountPoint: LPCSTR ) -> BOOL2461     pub fn DeleteVolumeMountPointA(
2462         lpszVolumeMountPoint: LPCSTR
2463     ) -> BOOL;
GetVolumeNameForVolumeMountPointA( lpszVolumeMountPoint: LPCSTR, lpszVolumeName: LPSTR, cchBufferLength: DWORD, ) -> BOOL2464     pub fn GetVolumeNameForVolumeMountPointA(
2465         lpszVolumeMountPoint: LPCSTR,
2466         lpszVolumeName: LPSTR,
2467         cchBufferLength: DWORD,
2468     ) -> BOOL;
GetVolumePathNameA( lpszFileName: LPCSTR, lpszVolumePathName: LPSTR, cchBufferLength: DWORD, ) -> BOOL2469     pub fn GetVolumePathNameA(
2470         lpszFileName: LPCSTR,
2471         lpszVolumePathName: LPSTR,
2472         cchBufferLength: DWORD,
2473     ) -> BOOL;
GetVolumePathNamesForVolumeNameA( lpszVolumeName: LPCSTR, lpszVolumePathNames: LPCH, cchBufferLength: DWORD, lpcchReturnLength: PDWORD, ) -> BOOL2474     pub fn GetVolumePathNamesForVolumeNameA(
2475         lpszVolumeName: LPCSTR,
2476         lpszVolumePathNames: LPCH,
2477         cchBufferLength: DWORD,
2478         lpcchReturnLength: PDWORD,
2479     ) -> BOOL;
2480 }
2481 // ACTCTX_FLAG_*
2482 STRUCT!{struct ACTCTXA {
2483     cbSize: ULONG,
2484     dwFlags: DWORD,
2485     lpSource: LPCSTR,
2486     wProcessorArchitecture: USHORT,
2487     wLangId: LANGID,
2488     lpAssemblyDirectory: LPCSTR,
2489     lpResourceName: LPCSTR,
2490     lpApplicationName: LPCSTR,
2491     hModule: HMODULE,
2492 }}
2493 pub type PACTCTXA = *mut ACTCTXA;
2494 STRUCT!{struct ACTCTXW {
2495     cbSize: ULONG,
2496     dwFlags: DWORD,
2497     lpSource: LPCWSTR,
2498     wProcessorArchitecture: USHORT,
2499     wLangId: LANGID,
2500     lpAssemblyDirectory: LPCWSTR,
2501     lpResourceName: LPCWSTR,
2502     lpApplicationName: LPCWSTR,
2503     hModule: HMODULE,
2504 }}
2505 pub type PACTCTXW = *mut ACTCTXW;
2506 pub type PCACTCTXA = *const ACTCTXA;
2507 pub type PCACTCTXW = *const ACTCTXW;
2508 extern "system" {
CreateActCtxA( pActCtx: PCACTCTXA ) -> HANDLE2509     pub fn CreateActCtxA(
2510         pActCtx: PCACTCTXA
2511     ) -> HANDLE;
CreateActCtxW( pActCtx: PCACTCTXW ) -> HANDLE2512     pub fn CreateActCtxW(
2513         pActCtx: PCACTCTXW
2514     ) -> HANDLE;
AddRefActCtx( hActCtx: HANDLE )2515     pub fn AddRefActCtx(
2516         hActCtx: HANDLE
2517     );
ReleaseActCtx( hActCtx: HANDLE )2518     pub fn ReleaseActCtx(
2519         hActCtx: HANDLE
2520     );
ZombifyActCtx( hActCtx: HANDLE ) -> BOOL2521     pub fn ZombifyActCtx(
2522         hActCtx: HANDLE
2523     ) -> BOOL;
ActivateActCtx( hActCtx: HANDLE, lpCookie: *mut ULONG_PTR ) -> BOOL2524     pub fn ActivateActCtx(
2525         hActCtx: HANDLE,
2526         lpCookie: *mut ULONG_PTR
2527     ) -> BOOL;
DeactivateActCtx( dwFlags: DWORD, ulCookie: ULONG_PTR ) -> BOOL2528     pub fn DeactivateActCtx(
2529         dwFlags: DWORD,
2530         ulCookie: ULONG_PTR
2531     ) -> BOOL;
GetCurrentActCtx( lphActCtx: *mut HANDLE ) -> BOOL2532     pub fn GetCurrentActCtx(
2533         lphActCtx: *mut HANDLE
2534     ) -> BOOL;
2535 }
2536 STRUCT!{struct ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA {
2537     lpInformation: PVOID,
2538     lpSectionBase: PVOID,
2539     ulSectionLength: ULONG,
2540     lpSectionGlobalDataBase: PVOID,
2541     ulSectionGlobalDataLength: ULONG,
2542 }}
2543 pub type PACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA =
2544     *mut ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA;
2545 pub type PCACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA =
2546     *const ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA;
2547 STRUCT!{struct ACTCTX_SECTION_KEYED_DATA {
2548     cbSize: ULONG,
2549     ulDataFormatVersion: ULONG,
2550     lpData: PVOID,
2551     ulLength: ULONG,
2552     lpSectionGlobalData: PVOID,
2553     ulSectionGlobalDataLength: ULONG,
2554     lpSectionBase: PVOID,
2555     ulSectionTotalLength: ULONG,
2556     hActCtx: HANDLE,
2557     ulAssemblyRosterIndex: ULONG,
2558     ulFlags: ULONG,
2559     AssemblyMetadata: ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA,
2560 }}
2561 pub type PACTCTX_SECTION_KEYED_DATA = *mut ACTCTX_SECTION_KEYED_DATA;
2562 pub type PCACTCTX_SECTION_KEYED_DATA = *const ACTCTX_SECTION_KEYED_DATA;
2563 extern "system" {
FindActCtxSectionStringA( dwFlags: DWORD, lpExtensionGuid: *const GUID, ulSectionId: ULONG, lpStringToFind: LPCSTR, ReturnedData: PACTCTX_SECTION_KEYED_DATA, ) -> BOOL2564     pub fn FindActCtxSectionStringA(
2565         dwFlags: DWORD,
2566         lpExtensionGuid: *const GUID,
2567         ulSectionId: ULONG,
2568         lpStringToFind: LPCSTR,
2569         ReturnedData: PACTCTX_SECTION_KEYED_DATA,
2570     ) -> BOOL;
FindActCtxSectionStringW( dwFlags: DWORD, lpExtensionGuid: *const GUID, ulSectionId: ULONG, lpStringToFind: LPCWSTR, ReturnedData: PACTCTX_SECTION_KEYED_DATA, ) -> BOOL2571     pub fn FindActCtxSectionStringW(
2572         dwFlags: DWORD,
2573         lpExtensionGuid: *const GUID,
2574         ulSectionId: ULONG,
2575         lpStringToFind: LPCWSTR,
2576         ReturnedData: PACTCTX_SECTION_KEYED_DATA,
2577     ) -> BOOL;
FindActCtxSectionGuid( dwFlags: DWORD, lpExtensionGuid: *const GUID, ulSectionId: ULONG, lpGuidToFind: *const GUID, ReturnedData: PACTCTX_SECTION_KEYED_DATA, ) -> BOOL2578     pub fn FindActCtxSectionGuid(
2579         dwFlags: DWORD,
2580         lpExtensionGuid: *const GUID,
2581         ulSectionId: ULONG,
2582         lpGuidToFind: *const GUID,
2583         ReturnedData: PACTCTX_SECTION_KEYED_DATA,
2584     ) -> BOOL;
QueryActCtxW( dwFlags: DWORD, hActCtx: HANDLE, pvSubInstance: PVOID, ulInfoClass: ULONG, pvBuffer: PVOID, cbBuffer: SIZE_T, pcbWrittenOrRequired: *mut SIZE_T, ) -> BOOL2585     pub fn QueryActCtxW(
2586         dwFlags: DWORD,
2587         hActCtx: HANDLE,
2588         pvSubInstance: PVOID,
2589         ulInfoClass: ULONG,
2590         pvBuffer: PVOID,
2591         cbBuffer: SIZE_T,
2592         pcbWrittenOrRequired: *mut SIZE_T,
2593     ) -> BOOL;
WTSGetActiveConsoleSessionId() -> DWORD2594     pub fn WTSGetActiveConsoleSessionId() -> DWORD;
2595     // pub fn WTSGetServiceSessionId();
2596     // pub fn WTSIsServerContainer();
GetActiveProcessorGroupCount() -> WORD2597     pub fn GetActiveProcessorGroupCount() -> WORD;
GetMaximumProcessorGroupCount() -> WORD2598     pub fn GetMaximumProcessorGroupCount() -> WORD;
GetActiveProcessorCount( GroupNumber: WORD ) -> DWORD2599     pub fn GetActiveProcessorCount(
2600         GroupNumber: WORD
2601     ) -> DWORD;
GetMaximumProcessorCount( GroupNumber: WORD ) -> DWORD2602     pub fn GetMaximumProcessorCount(
2603         GroupNumber: WORD
2604     ) -> DWORD;
GetNumaProcessorNode( Processor: UCHAR, NodeNumber: PUCHAR ) -> BOOL2605     pub fn GetNumaProcessorNode(
2606         Processor: UCHAR,
2607         NodeNumber: PUCHAR
2608     ) -> BOOL;
GetNumaNodeNumberFromHandle( hFile: HANDLE, NodeNumber: PUSHORT ) -> BOOL2609     pub fn GetNumaNodeNumberFromHandle(
2610         hFile: HANDLE,
2611         NodeNumber: PUSHORT
2612     ) -> BOOL;
GetNumaProcessorNodeEx( Processor: PPROCESSOR_NUMBER, NodeNumber: PUSHORT ) -> BOOL2613     pub fn GetNumaProcessorNodeEx(
2614         Processor: PPROCESSOR_NUMBER,
2615         NodeNumber: PUSHORT
2616     ) -> BOOL;
GetNumaNodeProcessorMask( Node: UCHAR, ProcessorMask: PULONGLONG ) -> BOOL2617     pub fn GetNumaNodeProcessorMask(
2618         Node: UCHAR,
2619         ProcessorMask: PULONGLONG
2620     ) -> BOOL;
GetNumaAvailableMemoryNode( Node: UCHAR, AvailableBytes: PULONGLONG ) -> BOOL2621     pub fn GetNumaAvailableMemoryNode(
2622         Node: UCHAR,
2623         AvailableBytes: PULONGLONG
2624     ) -> BOOL;
GetNumaAvailableMemoryNodeEx( Node: USHORT, AvailableBytes: PULONGLONG, ) -> BOOL2625     pub fn GetNumaAvailableMemoryNodeEx(
2626         Node: USHORT,
2627         AvailableBytes: PULONGLONG,
2628     ) -> BOOL;
GetNumaProximityNode( ProximityId: ULONG, NodeNumber: PUCHAR ) -> BOOL2629     pub fn GetNumaProximityNode(
2630         ProximityId: ULONG,
2631         NodeNumber: PUCHAR
2632     ) -> BOOL;
2633 }
2634 FN!{stdcall APPLICATION_RECOVERY_CALLBACK(
2635     pvParameter: PVOID,
2636 ) -> DWORD}
2637 // RESTART_*
2638 // RECOVERY_*
2639 extern "system" {
RegisterApplicationRecoveryCallback( pRecoveyCallback: APPLICATION_RECOVERY_CALLBACK, pvParameter: PVOID, dwPingInterval: DWORD, dwFlags: DWORD, ) -> HRESULT2640     pub fn RegisterApplicationRecoveryCallback(
2641         pRecoveyCallback: APPLICATION_RECOVERY_CALLBACK,
2642         pvParameter: PVOID,
2643         dwPingInterval: DWORD,
2644         dwFlags: DWORD,
2645     ) -> HRESULT;
UnregisterApplicationRecoveryCallback() -> HRESULT2646     pub fn UnregisterApplicationRecoveryCallback() -> HRESULT;
RegisterApplicationRestart( pwzCommandline: PCWSTR, dwFlags: DWORD, ) -> HRESULT2647     pub fn RegisterApplicationRestart(
2648         pwzCommandline: PCWSTR,
2649         dwFlags: DWORD,
2650     ) -> HRESULT;
UnregisterApplicationRestart() -> HRESULT2651     pub fn UnregisterApplicationRestart() -> HRESULT;
GetApplicationRecoveryCallback( hProcess: HANDLE, pRecoveryCallback: *mut APPLICATION_RECOVERY_CALLBACK, ppvParameter: *mut PVOID, pdwPingInterval: PDWORD, pdwFlags: PDWORD, ) -> HRESULT2652     pub fn GetApplicationRecoveryCallback(
2653         hProcess: HANDLE,
2654         pRecoveryCallback: *mut APPLICATION_RECOVERY_CALLBACK,
2655         ppvParameter: *mut PVOID,
2656         pdwPingInterval: PDWORD,
2657         pdwFlags: PDWORD,
2658     ) -> HRESULT;
GetApplicationRestartSettings( hProcess: HANDLE, pwzCommandline: PWSTR, pcchSize: PDWORD, pdwFlags: PDWORD, ) -> HRESULT2659     pub fn GetApplicationRestartSettings(
2660         hProcess: HANDLE,
2661         pwzCommandline: PWSTR,
2662         pcchSize: PDWORD,
2663         pdwFlags: PDWORD,
2664     ) -> HRESULT;
ApplicationRecoveryInProgress( pbCancelled: PBOOL ) -> HRESULT2665     pub fn ApplicationRecoveryInProgress(
2666         pbCancelled: PBOOL
2667     ) -> HRESULT;
ApplicationRecoveryFinished( bSuccess: BOOL )2668     pub fn ApplicationRecoveryFinished(
2669         bSuccess: BOOL
2670     );
2671 }
2672 // FILE_BASIC_INFO, etc.
2673 extern "system" {
GetFileInformationByHandleEx( hFile: HANDLE, FileInformationClass: FILE_INFO_BY_HANDLE_CLASS, lpFileInformation: LPVOID, dwBufferSize: DWORD, ) -> BOOL2674     pub fn GetFileInformationByHandleEx(
2675         hFile: HANDLE,
2676         FileInformationClass: FILE_INFO_BY_HANDLE_CLASS,
2677         lpFileInformation: LPVOID,
2678         dwBufferSize: DWORD,
2679     ) -> BOOL;
2680 }
2681 ENUM!{enum FILE_ID_TYPE {
2682     FileIdType,
2683     ObjectIdType,
2684     ExtendedFileIdType,
2685     MaximumFileIdType,
2686 }}
2687 UNION!{union FILE_ID_DESCRIPTOR_u {
2688     [u64; 2],
2689     FileId FileId_mut: LARGE_INTEGER,
2690     ObjectId ObjectId_mut: GUID,
2691     ExtendedFileId ExtendedFileId_mut: FILE_ID_128,
2692 }}
2693 STRUCT!{struct FILE_ID_DESCRIPTOR {
2694     dwSize: DWORD,
2695     Type: FILE_ID_TYPE,
2696     u: FILE_ID_DESCRIPTOR_u,
2697 }}
2698 pub type LPFILE_ID_DESCRIPTOR = *mut FILE_ID_DESCRIPTOR;
2699 extern "system" {
OpenFileById( hVolumeHint: HANDLE, lpFileId: LPFILE_ID_DESCRIPTOR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwFlagsAndAttributes: DWORD, ) -> HANDLE2700     pub fn OpenFileById(
2701         hVolumeHint: HANDLE,
2702         lpFileId: LPFILE_ID_DESCRIPTOR,
2703         dwDesiredAccess: DWORD,
2704         dwShareMode: DWORD,
2705         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
2706         dwFlagsAndAttributes: DWORD,
2707     ) -> HANDLE;
CreateSymbolicLinkA( lpSymlinkFileName: LPCSTR, lpTargetFileName: LPCSTR, dwFlags: DWORD, ) -> BOOLEAN2708     pub fn CreateSymbolicLinkA(
2709         lpSymlinkFileName: LPCSTR,
2710         lpTargetFileName: LPCSTR,
2711         dwFlags: DWORD,
2712     ) -> BOOLEAN;
CreateSymbolicLinkW( lpSymlinkFileName: LPCWSTR, lpTargetFileName: LPCWSTR, dwFlags: DWORD, ) -> BOOLEAN2713     pub fn CreateSymbolicLinkW(
2714         lpSymlinkFileName: LPCWSTR,
2715         lpTargetFileName: LPCWSTR,
2716         dwFlags: DWORD,
2717     ) -> BOOLEAN;
QueryActCtxSettingsW( dwFlags: DWORD, hActCtx: HANDLE, settingsNameSpace: PCWSTR, settingName: PCWSTR, pvBuffer: PWSTR, dwBuffer: SIZE_T, pdwWrittenOrRequired: *mut SIZE_T, ) -> BOOL2718     pub fn QueryActCtxSettingsW(
2719         dwFlags: DWORD,
2720         hActCtx: HANDLE,
2721         settingsNameSpace: PCWSTR,
2722         settingName: PCWSTR,
2723         pvBuffer: PWSTR,
2724         dwBuffer: SIZE_T,
2725         pdwWrittenOrRequired: *mut SIZE_T,
2726     ) -> BOOL;
CreateSymbolicLinkTransactedA( lpSymlinkFileName: LPCSTR, lpTargetFileName: LPCSTR, dwFlags: DWORD, hTransaction: HANDLE, ) -> BOOLEAN2727     pub fn CreateSymbolicLinkTransactedA(
2728         lpSymlinkFileName: LPCSTR,
2729         lpTargetFileName: LPCSTR,
2730         dwFlags: DWORD,
2731         hTransaction: HANDLE,
2732     ) -> BOOLEAN;
CreateSymbolicLinkTransactedW( lpSymlinkFileName: LPCWSTR, lpTargetFileName: LPCWSTR, dwFlags: DWORD, hTransaction: HANDLE, ) -> BOOLEAN2733     pub fn CreateSymbolicLinkTransactedW(
2734         lpSymlinkFileName: LPCWSTR,
2735         lpTargetFileName: LPCWSTR,
2736         dwFlags: DWORD,
2737         hTransaction: HANDLE,
2738     ) -> BOOLEAN;
ReplacePartitionUnit( TargetPartition: PWSTR, SparePartition: PWSTR, Flags: ULONG, ) -> BOOL2739     pub fn ReplacePartitionUnit(
2740         TargetPartition: PWSTR,
2741         SparePartition: PWSTR,
2742         Flags: ULONG,
2743     ) -> BOOL;
AddSecureMemoryCacheCallback( pfnCallBack: PSECURE_MEMORY_CACHE_CALLBACK ) -> BOOL2744     pub fn AddSecureMemoryCacheCallback(
2745         pfnCallBack: PSECURE_MEMORY_CACHE_CALLBACK
2746     ) -> BOOL;
RemoveSecureMemoryCacheCallback( pfnCallBack: PSECURE_MEMORY_CACHE_CALLBACK ) -> BOOL2747     pub fn RemoveSecureMemoryCacheCallback(
2748         pfnCallBack: PSECURE_MEMORY_CACHE_CALLBACK
2749     ) -> BOOL;
CopyContext( Destination: PCONTEXT, ContextFlags: DWORD, Source: PCONTEXT ) -> BOOL2750     pub fn CopyContext(
2751         Destination: PCONTEXT,
2752         ContextFlags: DWORD,
2753         Source: PCONTEXT
2754     ) -> BOOL;
InitializeContext( Buffer: PVOID, ContextFlags: DWORD, Context: *mut PCONTEXT, ContextLength: PDWORD, ) -> BOOL2755     pub fn InitializeContext(
2756         Buffer: PVOID,
2757         ContextFlags: DWORD,
2758         Context: *mut PCONTEXT,
2759         ContextLength: PDWORD,
2760     ) -> BOOL;
GetEnabledXStateFeatures() -> DWORD642761     pub fn GetEnabledXStateFeatures() -> DWORD64;
GetXStateFeaturesMask( Context: PCONTEXT, FeatureMask: PDWORD64 ) -> BOOL2762     pub fn GetXStateFeaturesMask(
2763         Context: PCONTEXT,
2764         FeatureMask: PDWORD64
2765     ) -> BOOL;
2766     #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
LocateXStateFeature( Context: PCONTEXT, FeatureId: DWORD, Length: PDWORD ) -> PVOID2767     pub fn LocateXStateFeature(
2768         Context: PCONTEXT,
2769         FeatureId: DWORD,
2770         Length: PDWORD
2771     ) -> PVOID;
2772     #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
SetXStateFeaturesMask( Context: PCONTEXT, FeatureMask: DWORD64 ) -> BOOL2773     pub fn SetXStateFeaturesMask(
2774         Context: PCONTEXT,
2775         FeatureMask: DWORD64
2776     ) -> BOOL;
EnableThreadProfiling( ThreadHandle: HANDLE, Flags: DWORD, HardwareCounters: DWORD64, PerformanceDataHandle: *mut HANDLE, ) -> BOOL2777     pub fn EnableThreadProfiling(
2778         ThreadHandle: HANDLE,
2779         Flags: DWORD,
2780         HardwareCounters: DWORD64,
2781         PerformanceDataHandle: *mut HANDLE,
2782     ) -> BOOL;
DisableThreadProfiling( PerformanceDataHandle: HANDLE ) -> DWORD2783     pub fn DisableThreadProfiling(
2784         PerformanceDataHandle: HANDLE
2785     ) -> DWORD;
QueryThreadProfiling( ThreadHandle: HANDLE, Enabled: PBOOLEAN ) -> DWORD2786     pub fn QueryThreadProfiling(
2787         ThreadHandle: HANDLE,
2788         Enabled: PBOOLEAN
2789     ) -> DWORD;
ReadThreadProfilingData( PerformanceDataHandle: HANDLE, Flags: DWORD, PerformanceData: PPERFORMANCE_DATA, ) -> DWORD2790     pub fn ReadThreadProfilingData(
2791         PerformanceDataHandle: HANDLE,
2792         Flags: DWORD,
2793         PerformanceData: PPERFORMANCE_DATA,
2794     ) -> DWORD;
2795     // intrinsic InterlockedIncrement
2796     // intrinsic InterlockedDecrement
2797     // intrinsic InterlockedExchange
2798     // intrinsic InterlockedExchangeAdd
2799     // intrinsic InterlockedExchangeSubtract
2800     // intrinsic InterlockedCompareExchange
2801     // intrinsic InterlockedAnd
2802     // intrinsic InterlockedOr
2803     // intrinsic InterlockedXor
2804 }
2805