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