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