1use 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};
28use um::processthreadsapi::{
29 LPPROCESS_INFORMATION, LPPROC_THREAD_ATTRIBUTE_LIST, LPSTARTUPINFOA, LPSTARTUPINFOW,
30 STARTUPINFOA, STARTUPINFOW,
31};
32use 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")]
46use um::winnt::PLDT_ENTRY;
47use vc::vadefs::va_list;
48pub const FILE_BEGIN: DWORD = 0;
49pub const FILE_CURRENT: DWORD = 1;
50pub const FILE_END: DWORD = 2;
51pub const WAIT_FAILED: DWORD = 0xFFFFFFFF;
52pub const WAIT_OBJECT_0: DWORD = STATUS_WAIT_0 as u32;
53pub const WAIT_ABANDONED: DWORD = STATUS_ABANDONED_WAIT_0 as u32;
54pub const WAIT_ABANDONED_0: DWORD = STATUS_ABANDONED_WAIT_0 as u32;
55pub const WAIT_IO_COMPLETION: DWORD = STATUS_USER_APC as u32;
56pub const FILE_FLAG_WRITE_THROUGH: DWORD = 0x80000000;
57pub const FILE_FLAG_OVERLAPPED: DWORD = 0x40000000;
58pub const FILE_FLAG_NO_BUFFERING: DWORD = 0x20000000;
59pub const FILE_FLAG_RANDOM_ACCESS: DWORD = 0x10000000;
60pub const FILE_FLAG_SEQUENTIAL_SCAN: DWORD = 0x08000000;
61pub const FILE_FLAG_DELETE_ON_CLOSE: DWORD = 0x04000000;
62pub const FILE_FLAG_BACKUP_SEMANTICS: DWORD = 0x02000000;
63pub const FILE_FLAG_POSIX_SEMANTICS: DWORD = 0x01000000;
64pub const FILE_FLAG_SESSION_AWARE: DWORD = 0x00800000;
65pub const FILE_FLAG_OPEN_REPARSE_POINT: DWORD = 0x00200000;
66pub const FILE_FLAG_OPEN_NO_RECALL: DWORD = 0x00100000;
67pub const FILE_FLAG_FIRST_PIPE_INSTANCE: DWORD = 0x00080000;
68pub const FILE_FLAG_OPEN_REQUIRING_OPLOCK: DWORD = 0x00040000;
69pub const PROGRESS_CONTINUE: DWORD = 0;
70pub const PROGRESS_CANCEL: DWORD = 1;
71pub const PROGRESS_STOP: DWORD = 2;
72pub const PROGRESS_QUIET: DWORD = 3;
73pub const CALLBACK_CHUNK_FINISHED: DWORD = 0x00000000;
74pub const CALLBACK_STREAM_SWITCH: DWORD = 0x00000001;
75pub const COPY_FILE_FAIL_IF_EXISTS: DWORD = 0x00000001;
76pub const COPY_FILE_RESTARTABLE: DWORD = 0x00000002;
77pub const COPY_FILE_OPEN_SOURCE_FOR_WRITE: DWORD = 0x00000004;
78pub const COPY_FILE_ALLOW_DECRYPTED_DESTINATION: DWORD = 0x00000008;
79pub const COPY_FILE_COPY_SYMLINK: DWORD = 0x00000800;
80pub const COPY_FILE_NO_BUFFERING: DWORD = 0x00001000;
81pub const COPY_FILE_REQUEST_SECURITY_PRIVILEGES: DWORD = 0x00002000;
82pub const COPY_FILE_RESUME_FROM_PAUSE: DWORD = 0x00004000;
83pub const COPY_FILE_NO_OFFLOAD: DWORD = 0x00040000;
84pub const COPY_FILE_IGNORE_EDP_BLOCK: DWORD = 0x00400000;
85pub const COPY_FILE_IGNORE_SOURCE_ENCRYPTION: DWORD = 0x00800000;
86pub const REPLACEFILE_WRITE_THROUGH: DWORD = 0x00000001;
87pub const REPLACEFILE_IGNORE_MERGE_ERRORS: DWORD = 0x00000002;
88pub const REPLACEFILE_IGNORE_ACL_ERRORS: DWORD = 0x00000004;
89pub const PIPE_ACCESS_INBOUND: DWORD = 0x00000001;
90pub const PIPE_ACCESS_OUTBOUND: DWORD = 0x00000002;
91pub const PIPE_ACCESS_DUPLEX: DWORD = 0x00000003;
92pub const PIPE_CLIENT_END: DWORD = 0x00000000;
93pub const PIPE_SERVER_END: DWORD = 0x00000001;
94pub const PIPE_WAIT: DWORD = 0x00000000;
95pub const PIPE_NOWAIT: DWORD = 0x00000001;
96pub const PIPE_READMODE_BYTE: DWORD = 0x00000000;
97pub const PIPE_READMODE_MESSAGE: DWORD = 0x00000002;
98pub const PIPE_TYPE_BYTE: DWORD = 0x00000000;
99pub const PIPE_TYPE_MESSAGE: DWORD = 0x00000004;
100pub const PIPE_ACCEPT_REMOTE_CLIENTS: DWORD = 0x00000000;
101pub const PIPE_REJECT_REMOTE_CLIENTS: DWORD = 0x00000008;
102pub const PIPE_UNLIMITED_INSTANCES: DWORD = 255;
103pub const SECURITY_ANONYMOUS: DWORD = SecurityAnonymous << 16;
104pub const SECURITY_IDENTIFICATION: DWORD = SecurityIdentification << 16;
105pub const SECURITY_IMPERSONATION: DWORD = SecurityImpersonation << 16;
106pub const SECURITY_DELEGATION: DWORD = SecurityDelegation << 16;
107pub const SECURITY_CONTEXT_TRACKING: DWORD = 0x00040000;
108pub const SECURITY_EFFECTIVE_ONLY: DWORD = 0x00080000;
109pub const SECURITY_SQOS_PRESENT: DWORD = 0x00100000;
110pub const SECURITY_VALID_SQOS_FLAGS: DWORD = 0x001F0000;
111FN!{stdcall PFIBER_START_ROUTINE(
112 lpFiberParameter: LPVOID,
113) -> ()}
114pub type LPFIBER_START_ROUTINE = PFIBER_START_ROUTINE;
115FN!{stdcall PFIBER_CALLOUT_ROUTINE(
116 lpParameter: LPVOID,
117) -> LPVOID}
118#[cfg(target_arch = "x86")]
120pub type LPLDT_ENTRY = PLDT_ENTRY;
121#[cfg(not(target_arch = "x86"))]
122pub type LPLDT_ENTRY = LPVOID; 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}}
151pub type LPCOMMPROP = *mut COMMPROP;
152STRUCT!{struct COMSTAT {
153 BitFields: DWORD,
154 cbInQue: DWORD,
155 cbOutQue: DWORD,
156}}
157BITFIELD!{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]}
167pub type LPCOMSTAT = *mut COMSTAT;
168pub const DTR_CONTROL_DISABLE: DWORD = 0x00;
169pub const DTR_CONTROL_ENABLE: DWORD = 0x01;
170pub const DTR_CONTROL_HANDSHAKE: DWORD = 0x02;
171pub const RTS_CONTROL_DISABLE: DWORD = 0x00;
172pub const RTS_CONTROL_ENABLE: DWORD = 0x01;
173pub const RTS_CONTROL_HANDSHAKE: DWORD = 0x02;
174pub const RTS_CONTROL_TOGGLE: DWORD = 0x03;
175STRUCT!{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}}
192BITFIELD!{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]}
208pub type LPDCB = *mut DCB;
209STRUCT!{struct COMMTIMEOUTS {
210 ReadIntervalTimeout: DWORD,
211 ReadTotalTimeoutMultiplier: DWORD,
212 ReadTotalTimeoutConstant: DWORD,
213 WriteTotalTimeoutMultiplier: DWORD,
214 WriteTotalTimeoutConstant: DWORD,
215}}
216pub type LPCOMMTIMEOUTS = *mut COMMTIMEOUTS;
217STRUCT!{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}}
227pub type LPCOMMCONFIG = *mut COMMCONFIG;
228pub const GMEM_FIXED: UINT = 0x0000;
229pub const GMEM_MOVEABLE: UINT = 0x0002;
230pub const GMEM_NOCOMPACT: UINT = 0x0010;
231pub const GMEM_NODISCARD: UINT = 0x0020;
232pub const GMEM_ZEROINIT: UINT = 0x0040;
233pub const GMEM_MODIFY: UINT = 0x0080;
234pub const GMEM_DISCARDABLE: UINT = 0x0100;
235pub const GMEM_NOT_BANKED: UINT = 0x1000;
236pub const GMEM_SHARE: UINT = 0x2000;
237pub const GMEM_DDESHARE: UINT = 0x2000;
238pub const GMEM_NOTIFY: UINT = 0x4000;
239pub const GMEM_LOWER: UINT = GMEM_NOT_BANKED;
240pub const GMEM_VALID_FLAGS: UINT = 0x7F72;
241pub const GMEM_INVALID_HANDLE: UINT = 0x8000;
242pub const GHND: UINT = GMEM_MOVEABLE | GMEM_ZEROINIT;
243pub const GPTR: UINT = GMEM_FIXED | GMEM_ZEROINIT;
244pub const GMEM_DISCARDED: UINT = 0x4000;
245pub const GMEM_LOCKCOUNT: UINT = 0x00FF;
246STRUCT!{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}}
256pub type LPMEMORYSTATUS = *mut MEMORYSTATUS;
257pub const DEBUG_PROCESS: DWORD = 0x00000001;
259pub const DEBUG_ONLY_THIS_PROCESS: DWORD = 0x00000002;
260pub const CREATE_SUSPENDED: DWORD = 0x00000004;
261pub const DETACHED_PROCESS: DWORD = 0x00000008;
262pub const CREATE_NEW_CONSOLE: DWORD = 0x00000010;
263pub const NORMAL_PRIORITY_CLASS: DWORD = 0x00000020;
264pub const IDLE_PRIORITY_CLASS: DWORD = 0x00000040;
265pub const HIGH_PRIORITY_CLASS: DWORD = 0x00000080;
266pub const REALTIME_PRIORITY_CLASS: DWORD = 0x00000100;
267pub const CREATE_NEW_PROCESS_GROUP: DWORD = 0x00000200;
268pub const CREATE_UNICODE_ENVIRONMENT: DWORD = 0x00000400;
269pub const CREATE_SEPARATE_WOW_VDM: DWORD = 0x00000800;
270pub const CREATE_SHARED_WOW_VDM: DWORD = 0x00001000;
271pub const CREATE_FORCEDOS: DWORD = 0x00002000;
272pub const BELOW_NORMAL_PRIORITY_CLASS: DWORD = 0x00004000;
273pub const ABOVE_NORMAL_PRIORITY_CLASS: DWORD = 0x00008000;
274pub const INHERIT_PARENT_AFFINITY: DWORD = 0x00010000;
275pub const INHERIT_CALLER_PRIORITY: DWORD = 0x00020000;
276pub const CREATE_PROTECTED_PROCESS: DWORD = 0x00040000;
277pub const EXTENDED_STARTUPINFO_PRESENT: DWORD = 0x00080000;
278pub const PROCESS_MODE_BACKGROUND_BEGIN: DWORD = 0x00100000;
279pub const PROCESS_MODE_BACKGROUND_END: DWORD = 0x00200000;
280pub const CREATE_BREAKAWAY_FROM_JOB: DWORD = 0x01000000;
281pub const CREATE_PRESERVE_CODE_AUTHZ_LEVEL: DWORD = 0x02000000;
282pub const CREATE_DEFAULT_ERROR_MODE: DWORD = 0x04000000;
283pub const CREATE_NO_WINDOW: DWORD = 0x08000000;
284pub const PROFILE_USER: DWORD = 0x10000000;
285pub const PROFILE_KERNEL: DWORD = 0x20000000;
286pub const PROFILE_SERVER: DWORD = 0x40000000;
287pub const CREATE_IGNORE_SYSTEM_DEFAULT: DWORD = 0x80000000;
288pub const THREAD_PRIORITY_LOWEST: DWORD = THREAD_BASE_PRIORITY_MIN;
290pub const THREAD_PRIORITY_BELOW_NORMAL: DWORD = THREAD_PRIORITY_LOWEST + 1;
291pub const THREAD_PRIORITY_NORMAL: DWORD = 0;
292pub const THREAD_PRIORITY_HIGHEST: DWORD = THREAD_BASE_PRIORITY_MAX;
293pub const THREAD_PRIORITY_ABOVE_NORMAL: DWORD = THREAD_PRIORITY_HIGHEST - 1;
294pub const THREAD_PRIORITY_ERROR_RETURN: DWORD = MAXLONG as u32;
295pub const THREAD_PRIORITY_TIME_CRITICAL: DWORD = THREAD_BASE_PRIORITY_LOWRT;
296pub const THREAD_PRIORITY_IDLE: DWORD = THREAD_BASE_PRIORITY_IDLE;
297pub const THREAD_MODE_BACKGROUND_BEGIN: DWORD = 0x00010000;
298pub const THREAD_MODE_BACKGROUND_END: DWORD = 0x00020000;
299pub const VOLUME_NAME_DOS: DWORD = 0x0;
300pub const DRIVE_UNKNOWN: DWORD = 0;
304pub const DRIVE_NO_ROOT_DIR: DWORD = 1;
305pub const DRIVE_REMOVABLE: DWORD = 2;
306pub const DRIVE_FIXED: DWORD = 3;
307pub const DRIVE_REMOTE: DWORD = 4;
308pub const DRIVE_CDROM: DWORD = 5;
309pub const DRIVE_RAMDISK: DWORD = 6;
310pub const FILE_TYPE_UNKNOWN: DWORD = 0x0000;
312pub const FILE_TYPE_DISK: DWORD = 0x0001;
313pub const FILE_TYPE_CHAR: DWORD = 0x0002;
314pub const FILE_TYPE_PIPE: DWORD = 0x0003;
315pub const FILE_TYPE_REMOTE: DWORD = 0x8000;
316pub const STD_INPUT_HANDLE: DWORD = -10i32 as u32;
317pub const STD_OUTPUT_HANDLE: DWORD = -11i32 as u32;
318pub const STD_ERROR_HANDLE: DWORD = -12i32 as u32;
319pub const NOPARITY: BYTE = 0;
320pub const ODDPARITY: BYTE = 1;
321pub const EVENPARITY: BYTE = 2;
322pub const MARKPARITY: BYTE = 3;
323pub const SPACEPARITY: BYTE = 4;
324pub const ONESTOPBIT: BYTE = 0;
325pub const ONE5STOPBITS: BYTE = 1;
326pub const TWOSTOPBITS: BYTE = 2;
327pub const IGNORE: DWORD = 0;
328pub const INFINITE: DWORD = 0xFFFFFFFF;
329pub const CBR_110: DWORD = 110;
330pub const CBR_300: DWORD = 300;
331pub const CBR_600: DWORD = 600;
332pub const CBR_1200: DWORD = 1200;
333pub const CBR_2400: DWORD = 2400;
334pub const CBR_4800: DWORD = 4800;
335pub const CBR_9600: DWORD = 9600;
336pub const CBR_14400: DWORD = 14400;
337pub const CBR_19200: DWORD = 19200;
338pub const CBR_38400: DWORD = 38400;
339pub const CBR_56000: DWORD = 56000;
340pub const CBR_57600: DWORD = 57600;
341pub const CBR_115200: DWORD = 115200;
342pub const CBR_128000: DWORD = 128000;
343pub const CBR_256000: DWORD = 256000;
344pub const SETXOFF: DWORD = 1;
348pub const SETXON: DWORD = 2;
349pub const SETRTS: DWORD = 3;
350pub const CLRRTS: DWORD = 4;
351pub const SETDTR: DWORD = 5;
352pub const CLRDTR: DWORD = 6;
353pub const RESETDEV: DWORD = 7;
354pub const SETBREAK: DWORD = 8;
355pub const CLRBREAK: DWORD = 9;
356pub const PURGE_TXABORT: DWORD = 0x0001;
357pub const PURGE_RXABORT: DWORD = 0x0002;
358pub const PURGE_TXCLEAR: DWORD = 0x0004;
359pub const PURGE_RXCLEAR: DWORD = 0x0008;
360pub const MS_CTS_ON: DWORD = 0x0010;
361pub const MS_DSR_ON: DWORD = 0x0020;
362pub const MS_RING_ON: DWORD = 0x0040;
363pub const MS_RLSD_ON: DWORD = 0x0080;
364pub const OFS_MAXPATHNAME: usize = 128;
369STRUCT!{struct OFSTRUCT {
370 cBytes: BYTE,
371 fFixedDisk: BYTE,
372 nErrCode: WORD,
373 Reserved1: WORD,
374 Reserved2: WORD,
375 szPathName: [CHAR; OFS_MAXPATHNAME],
376}}
377pub type POFSTRUCT = *mut OFSTRUCT;
378pub type LPOFSTRUCT = *mut OFSTRUCT;
379extern "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}
460extern "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}
543pub type PUMS_CONTEXT = *mut c_void;
544pub type PUMS_COMPLETION_LIST = *mut c_void;
545pub type UMS_THREAD_INFO_CLASS = RTL_UMS_THREAD_INFO_CLASS;
546pub type PUMS_THREAD_INFO_CLASS = *mut UMS_THREAD_INFO_CLASS;
547pub type PUMS_SCHEDULER_ENTRY_POINT = PRTL_UMS_SCHEDULER_ENTRY_POINT;
548STRUCT!{struct UMS_SCHEDULER_STARTUP_INFO {
549 UmsVersion: ULONG,
550 CompletionList: PUMS_COMPLETION_LIST,
551 SchedulerProc: PUMS_SCHEDULER_ENTRY_POINT,
552 SchedulerParam: PVOID,
553}}
554pub type PUMS_SCHEDULER_STARTUP_INFO = *mut UMS_SCHEDULER_STARTUP_INFO;
555STRUCT!{struct UMS_SYSTEM_THREAD_INFORMATION {
556 UmsVersion: ULONG,
557 ThreadUmsFlags: ULONG,
558}}
559BITFIELD!{UMS_SYSTEM_THREAD_INFORMATION ThreadUmsFlags: ULONG [
560 IsUmsSchedulerThread set_IsUmsSchedulerThread[0..1],
561 IsUmsWorkerThread set_IsUmsWorkerThread[1..2],
562]}
563pub type PUMS_SYSTEM_THREAD_INFORMATION = *mut UMS_SYSTEM_THREAD_INFORMATION;
564extern "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}
669pub const FILE_SKIP_COMPLETION_PORT_ON_SUCCESS: UCHAR = 0x1;
670pub const FILE_SKIP_SET_EVENT_ON_HANDLE: UCHAR = 0x2;
671extern "system" {
672 pub fn SetFileCompletionNotificationModes(
673 FileHandle: HANDLE,
674 Flags: UCHAR,
675 ) -> BOOL;
676}
677pub const SEM_FAILCRITICALERRORS: UINT = 0x0001;
678pub const SEM_NOGPFAULTERRORBOX: UINT = 0x0002;
679pub const SEM_NOALIGNMENTFAULTEXCEPT: UINT = 0x0004;
680pub const SEM_NOOPENFILEERRORBOX: UINT = 0x8000;
681extern "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}
742pub const HANDLE_FLAG_INHERIT: DWORD = 0x00000001;
743pub const HANDLE_FLAG_PROTECT_FROM_CLOSE: DWORD = 0x00000002;
744extern "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 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}
828ENUM!{enum DEP_SYSTEM_POLICY_TYPE {
829 DEPPolicyAlwaysOff = 0,
830 DEPPolicyAlwaysOn,
831 DEPPolicyOptIn,
832 DEPPolicyOptOut,
833 DEPTotalPolicyCount,
834}}
835extern "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}
870pub const FORMAT_MESSAGE_IGNORE_INSERTS: DWORD = 0x00000200;
871pub const FORMAT_MESSAGE_FROM_STRING: DWORD = 0x00000400;
872pub const FORMAT_MESSAGE_FROM_HMODULE: DWORD = 0x00000800;
873pub const FORMAT_MESSAGE_FROM_SYSTEM: DWORD = 0x00001000;
874pub const FORMAT_MESSAGE_ARGUMENT_ARRAY: DWORD = 0x00002000;
875pub const FORMAT_MESSAGE_MAX_WIDTH_MASK: DWORD = 0x000000FF;
876pub const FORMAT_MESSAGE_ALLOCATE_BUFFER: DWORD = 0x00000100;
877extern "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 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 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}
1030pub const STARTF_USESHOWWINDOW: DWORD = 0x00000001;
1032pub const STARTF_USESIZE: DWORD = 0x00000002;
1033pub const STARTF_USEPOSITION: DWORD = 0x00000004;
1034pub const STARTF_USECOUNTCHARS: DWORD = 0x00000008;
1035pub const STARTF_USEFILLATTRIBUTE: DWORD = 0x00000010;
1036pub const STARTF_RUNFULLSCREEN: DWORD = 0x00000020;
1037pub const STARTF_FORCEONFEEDBACK: DWORD = 0x00000040;
1038pub const STARTF_FORCEOFFFEEDBACK: DWORD = 0x00000080;
1039pub const STARTF_USESTDHANDLES: DWORD = 0x00000100;
1040pub const STARTF_USEHOTKEY: DWORD = 0x00000200;
1041pub const STARTF_TITLEISLINKNAME: DWORD = 0x00000800;
1042pub const STARTF_TITLEISAPPID: DWORD = 0x00001000;
1043pub const STARTF_PREVENTPINNING: DWORD = 0x00002000;
1044pub const STARTF_UNTRUSTEDSOURCE: DWORD = 0x00008000;
1045STRUCT!{struct STARTUPINFOEXA {
1046 StartupInfo: STARTUPINFOA,
1047 lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST,
1048}}
1049pub type LPSTARTUPINFOEXA = *mut STARTUPINFOEXA;
1050STRUCT!{struct STARTUPINFOEXW {
1051 StartupInfo: STARTUPINFOW,
1052 lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST,
1053}}
1054pub type LPSTARTUPINFOEXW = *mut STARTUPINFOEXW;
1055extern "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}
1139extern "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}
1666FN!{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}
1677extern "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}
1713ENUM!{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}}
1723ENUM!{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}}
1730ENUM!{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}}
1740STRUCT!{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}}
1750STRUCT!{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}}
1762STRUCT!{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}}
1770STRUCT!{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}}
1780STRUCT!{struct COPYFILE2_MESSAGE_PollContinue {
1781 dwReserved: DWORD,
1782}}
1783STRUCT!{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}}
1794UNION!{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}}
1803STRUCT!{struct COPYFILE2_MESSAGE {
1804 Type: COPYFILE2_MESSAGE_TYPE,
1805 dwPadding: DWORD,
1806 Info: COPYFILE2_MESSAGE_Info,
1807}}
1808FN!{stdcall PCOPYFILE2_PROGRESS_ROUTINE(
1809 pMessage: *const COPYFILE2_MESSAGE,
1810 pvCallbackContext: PVOID,
1811) -> COPYFILE2_MESSAGE_ACTION}
1812STRUCT!{struct COPYFILE2_EXTENDED_PARAMETERS {
1813 dwSize: DWORD,
1814 dwCopyFlags: DWORD,
1815 pfCancel: *mut BOOL,
1816 pProgressRoutine: PCOPYFILE2_PROGRESS_ROUTINE,
1817 pvCallbackContext: PVOID,
1818}}
1819extern "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}
1874pub const MOVEFILE_REPLACE_EXISTING: DWORD = 0x00000001;
1875pub const MOVEFILE_COPY_ALLOWED: DWORD = 0x00000002;
1876pub const MOVEFILE_DELAY_UNTIL_REBOOT: DWORD = 0x00000004;
1877pub const MOVEFILE_WRITE_THROUGH: DWORD = 0x00000008;
1878pub const MOVEFILE_CREATE_HARDLINK: DWORD = 0x00000010;
1879pub const MOVEFILE_FAIL_IF_NOT_TRACKABLE: DWORD = 0x00000020;
1880extern "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 DeregisterEventSource(
2016 hEventLog: HANDLE,
2017 ) -> BOOL;
2018 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 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 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 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 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}
2257pub const LOGON32_LOGON_INTERACTIVE: DWORD = 2;
2258pub const LOGON32_LOGON_NETWORK: DWORD = 3;
2259pub const LOGON32_LOGON_BATCH: DWORD = 4;
2260pub const LOGON32_LOGON_SERVICE: DWORD = 5;
2261pub const LOGON32_LOGON_UNLOCK: DWORD = 7;
2262pub const LOGON32_LOGON_NETWORK_CLEARTEXT: DWORD = 8;
2263pub const LOGON32_LOGON_NEW_CREDENTIALS: DWORD = 9;
2264pub const LOGON32_PROVIDER_DEFAULT: DWORD = 0;
2265pub const LOGON32_PROVIDER_WINNT35: DWORD = 1;
2266pub const LOGON32_PROVIDER_WINNT40: DWORD = 2;
2267pub const LOGON32_PROVIDER_WINNT50: DWORD = 3;
2268pub const LOGON32_PROVIDER_VIRTUAL: DWORD = 4;
2269extern "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}
2311pub const LOGON_WITH_PROFILE: DWORD = 0x00000001;
2312pub const LOGON_NETCREDENTIALS_ONLY: DWORD = 0x00000002;
2313extern "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 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}
2398pub const HW_PROFILE_GUIDLEN: usize = 39;
2399pub const DOCKINFO_UNDOCKED: DWORD = 0x1;
2401pub const DOCKINFO_DOCKED: DWORD = 0x2;
2402pub const DOCKINFO_USER_SUPPLIED: DWORD = 0x4;
2403pub const DOCKINFO_USER_UNDOCKED: DWORD = DOCKINFO_USER_SUPPLIED | DOCKINFO_UNDOCKED;
2404pub const DOCKINFO_USER_DOCKED: DWORD = DOCKINFO_USER_SUPPLIED | DOCKINFO_DOCKED;
2405STRUCT!{struct HW_PROFILE_INFOA {
2406 dwDockInfo: DWORD,
2407 szHwProfileGuid: [CHAR; HW_PROFILE_GUIDLEN],
2408 szHwProfileName: [CHAR; MAX_PROFILE_LEN],
2409}}
2410pub type LPHW_PROFILE_INFOA = *mut HW_PROFILE_INFOA;
2411STRUCT!{struct HW_PROFILE_INFOW {
2412 dwDockInfo: DWORD,
2413 szHwProfileGuid: [WCHAR; HW_PROFILE_GUIDLEN],
2414 szHwProfileName: [WCHAR; MAX_PROFILE_LEN],
2415}}
2416pub type LPHW_PROFILE_INFOW = *mut HW_PROFILE_INFOW;
2417extern "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}
2435STRUCT!{struct SYSTEM_POWER_STATUS {
2436 ACLineStatus: BYTE,
2437 BatteryFlag: BYTE,
2438 BatteryLifePercent: BYTE,
2439 Reserved1: BYTE,
2440 BatteryLifeTime: DWORD,
2441 BatteryFullLifeTime: DWORD,
2442}}
2443pub type LPSYSTEM_POWER_STATUS = *mut SYSTEM_POWER_STATUS;
2444extern "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}
2531STRUCT!{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}}
2543pub type PACTCTXA = *mut ACTCTXA;
2544STRUCT!{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}}
2555pub type PACTCTXW = *mut ACTCTXW;
2556pub type PCACTCTXA = *const ACTCTXA;
2557pub type PCACTCTXW = *const ACTCTXW;
2558extern "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}
2586STRUCT!{struct ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA {
2587 lpInformation: PVOID,
2588 lpSectionBase: PVOID,
2589 ulSectionLength: ULONG,
2590 lpSectionGlobalDataBase: PVOID,
2591 ulSectionGlobalDataLength: ULONG,
2592}}
2593pub type PACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA =
2594 *mut ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA;
2595pub type PCACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA =
2596 *const ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA;
2597STRUCT!{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}}
2611pub type PACTCTX_SECTION_KEYED_DATA = *mut ACTCTX_SECTION_KEYED_DATA;
2612pub type PCACTCTX_SECTION_KEYED_DATA = *const ACTCTX_SECTION_KEYED_DATA;
2613extern "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 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}
2684FN!{stdcall APPLICATION_RECOVERY_CALLBACK(
2685 pvParameter: PVOID,
2686) -> DWORD}
2687extern "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}
2722extern "system" {
2724 pub fn GetFileInformationByHandleEx(
2725 hFile: HANDLE,
2726 FileInformationClass: FILE_INFO_BY_HANDLE_CLASS,
2727 lpFileInformation: LPVOID,
2728 dwBufferSize: DWORD,
2729 ) -> BOOL;
2730}
2731ENUM!{enum FILE_ID_TYPE {
2732 FileIdType,
2733 ObjectIdType,
2734 ExtendedFileIdType,
2735 MaximumFileIdType,
2736}}
2737UNION!{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}}
2743STRUCT!{struct FILE_ID_DESCRIPTOR {
2744 dwSize: DWORD,
2745 Type: FILE_ID_TYPE,
2746 u: FILE_ID_DESCRIPTOR_u,
2747}}
2748pub type LPFILE_ID_DESCRIPTOR = *mut FILE_ID_DESCRIPTOR;
2749extern "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 }