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