1 // Copyright © 2015-2017 winapi-rs developers 2 // Licensed under the Apache License, Version 2.0 3 // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license 4 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option. 5 // All files in the project carrying such notice may not be copied, modified, or distributed 6 // except according to those terms. 7 //! This module defines the 32-Bit Windows Base APIs 8 use ctypes::{c_char, c_int, c_long, c_void}; 9 use shared::basetsd::{ 10 DWORD64, DWORD_PTR, LONG_PTR, PDWORD64, PDWORD_PTR, PSIZE_T, PULONG_PTR, SIZE_T, UINT_PTR, 11 ULONG_PTR, 12 }; 13 use shared::guiddef::GUID; 14 use shared::minwindef::{ 15 ATOM, BOOL, BYTE, DWORD, FARPROC, FILETIME, HFILE, HGLOBAL, HLOCAL, HMODULE, HRSRC, LPBOOL, 16 LPBYTE, LPCVOID, LPDWORD, LPFILETIME, LPVOID, LPWORD, PBOOL, PDWORD, PUCHAR, PULONG, PUSHORT, 17 UCHAR, UINT, ULONG, USHORT, WORD, 18 }; 19 use shared::windef::HWND; 20 use um::cfgmgr32::MAX_PROFILE_LEN; 21 use um::fileapi::STREAM_INFO_LEVELS; 22 use um::libloaderapi::{ 23 ENUMRESLANGPROCA, ENUMRESLANGPROCW, ENUMRESNAMEPROCA, ENUMRESTYPEPROCA, ENUMRESTYPEPROCW, 24 }; 25 use um::minwinbase::{ 26 FILE_INFO_BY_HANDLE_CLASS, FINDEX_INFO_LEVELS, FINDEX_SEARCH_OPS, GET_FILEEX_INFO_LEVELS, 27 LPOVERLAPPED, LPOVERLAPPED_COMPLETION_ROUTINE, LPSECURITY_ATTRIBUTES, PREASON_CONTEXT, 28 }; 29 use um::processthreadsapi::{LPPROC_THREAD_ATTRIBUTE_LIST, LPSTARTUPINFOA, STARTUPINFOA, STARTUPINFOW}; 30 use um::winnt::{ 31 BOOLEAN, CHAR, DWORDLONG, EXECUTION_STATE, FILE_ID_128, HANDLE, HRESULT, INT, LANGID, 32 LARGE_INTEGER, LATENCY_TIME, LONG, LPCCH, LPCH, LPCSTR, LPCWSTR, LPOSVERSIONINFOEXA, 33 LPOSVERSIONINFOEXW, LPSTR, LPWSTR, MAXLONG, PBOOLEAN, PCONTEXT, PCWSTR, PFIRMWARE_TYPE, 34 PHANDLE, PIO_COUNTERS, PJOB_SET_ARRAY, PLUID, POWER_REQUEST_TYPE, PPERFORMANCE_DATA, 35 PPROCESSOR_NUMBER, PQUOTA_LIMITS, PRTL_UMS_SCHEDULER_ENTRY_POINT, 36 PSECURE_MEMORY_CACHE_CALLBACK, PSID, PSID_NAME_USE, PULONGLONG, PVOID, PWOW64_CONTEXT, 37 PWOW64_LDT_ENTRY, PWSTR, RTL_UMS_THREAD_INFO_CLASS, STATUS_ABANDONED_WAIT_0, STATUS_USER_APC, 38 STATUS_WAIT_0, SecurityAnonymous, SecurityDelegation, SecurityIdentification, 39 SecurityImpersonation, THREAD_BASE_PRIORITY_IDLE, THREAD_BASE_PRIORITY_LOWRT, 40 THREAD_BASE_PRIORITY_MAX, THREAD_BASE_PRIORITY_MIN, ULARGE_INTEGER, VOID, WAITORTIMERCALLBACK, 41 WCHAR, WOW64_CONTEXT, 42 }; 43 #[cfg(target_arch = "x86")] 44 use um::winnt::PLDT_ENTRY; 45 use vc::vadefs::va_list; 46 pub const FILE_BEGIN: DWORD = 0; 47 pub const FILE_CURRENT: DWORD = 1; 48 pub const FILE_END: DWORD = 2; 49 pub const WAIT_FAILED: DWORD = 0xFFFFFFFF; 50 pub const WAIT_OBJECT_0: DWORD = STATUS_WAIT_0 as u32; 51 pub const WAIT_ABANDONED: DWORD = STATUS_ABANDONED_WAIT_0 as u32; 52 pub const WAIT_ABANDONED_0: DWORD = STATUS_ABANDONED_WAIT_0 as u32; 53 pub const WAIT_IO_COMPLETION: DWORD = STATUS_USER_APC as u32; 54 pub const FILE_FLAG_WRITE_THROUGH: DWORD = 0x80000000; 55 pub const FILE_FLAG_OVERLAPPED: DWORD = 0x40000000; 56 pub const FILE_FLAG_NO_BUFFERING: DWORD = 0x20000000; 57 pub const FILE_FLAG_RANDOM_ACCESS: DWORD = 0x10000000; 58 pub const FILE_FLAG_SEQUENTIAL_SCAN: DWORD = 0x08000000; 59 pub const FILE_FLAG_DELETE_ON_CLOSE: DWORD = 0x04000000; 60 pub const FILE_FLAG_BACKUP_SEMANTICS: DWORD = 0x02000000; 61 pub const FILE_FLAG_POSIX_SEMANTICS: DWORD = 0x01000000; 62 pub const FILE_FLAG_SESSION_AWARE: DWORD = 0x00800000; 63 pub const FILE_FLAG_OPEN_REPARSE_POINT: DWORD = 0x00200000; 64 pub const FILE_FLAG_OPEN_NO_RECALL: DWORD = 0x00100000; 65 pub const FILE_FLAG_FIRST_PIPE_INSTANCE: DWORD = 0x00080000; 66 pub const FILE_FLAG_OPEN_REQUIRING_OPLOCK: DWORD = 0x00040000; 67 pub const PROGRESS_CONTINUE: DWORD = 0; 68 pub const PROGRESS_CANCEL: DWORD = 1; 69 pub const PROGRESS_STOP: DWORD = 2; 70 pub const PROGRESS_QUIET: DWORD = 3; 71 pub const CALLBACK_CHUNK_FINISHED: DWORD = 0x00000000; 72 pub const CALLBACK_STREAM_SWITCH: DWORD = 0x00000001; 73 pub const COPY_FILE_FAIL_IF_EXISTS: DWORD = 0x00000001; 74 pub const COPY_FILE_RESTARTABLE: DWORD = 0x00000002; 75 pub const COPY_FILE_OPEN_SOURCE_FOR_WRITE: DWORD = 0x00000004; 76 pub const COPY_FILE_ALLOW_DECRYPTED_DESTINATION: DWORD = 0x00000008; 77 pub const COPY_FILE_COPY_SYMLINK: DWORD = 0x00000800; 78 pub const COPY_FILE_NO_BUFFERING: DWORD = 0x00001000; 79 pub const COPY_FILE_REQUEST_SECURITY_PRIVILEGES: DWORD = 0x00002000; 80 pub const COPY_FILE_RESUME_FROM_PAUSE: DWORD = 0x00004000; 81 pub const COPY_FILE_NO_OFFLOAD: DWORD = 0x00040000; 82 pub const COPY_FILE_IGNORE_EDP_BLOCK: DWORD = 0x00400000; 83 pub const COPY_FILE_IGNORE_SOURCE_ENCRYPTION: DWORD = 0x00800000; 84 pub const REPLACEFILE_WRITE_THROUGH: DWORD = 0x00000001; 85 pub const REPLACEFILE_IGNORE_MERGE_ERRORS: DWORD = 0x00000002; 86 pub const REPLACEFILE_IGNORE_ACL_ERRORS: DWORD = 0x00000004; 87 pub const PIPE_ACCESS_INBOUND: DWORD = 0x00000001; 88 pub const PIPE_ACCESS_OUTBOUND: DWORD = 0x00000002; 89 pub const PIPE_ACCESS_DUPLEX: DWORD = 0x00000003; 90 pub const PIPE_CLIENT_END: DWORD = 0x00000000; 91 pub const PIPE_SERVER_END: DWORD = 0x00000001; 92 pub const PIPE_WAIT: DWORD = 0x00000000; 93 pub const PIPE_NOWAIT: DWORD = 0x00000001; 94 pub const PIPE_READMODE_BYTE: DWORD = 0x00000000; 95 pub const PIPE_READMODE_MESSAGE: DWORD = 0x00000002; 96 pub const PIPE_TYPE_BYTE: DWORD = 0x00000000; 97 pub const PIPE_TYPE_MESSAGE: DWORD = 0x00000004; 98 pub const PIPE_ACCEPT_REMOTE_CLIENTS: DWORD = 0x00000000; 99 pub const PIPE_REJECT_REMOTE_CLIENTS: DWORD = 0x00000008; 100 pub const PIPE_UNLIMITED_INSTANCES: DWORD = 255; 101 pub const SECURITY_ANONYMOUS: DWORD = SecurityAnonymous << 16; 102 pub const SECURITY_IDENTIFICATION: DWORD = SecurityIdentification << 16; 103 pub const SECURITY_IMPERSONATION: DWORD = SecurityImpersonation << 16; 104 pub const SECURITY_DELEGATION: DWORD = SecurityDelegation << 16; 105 pub const SECURITY_CONTEXT_TRACKING: DWORD = 0x00040000; 106 pub const SECURITY_EFFECTIVE_ONLY: DWORD = 0x00080000; 107 pub const SECURITY_SQOS_PRESENT: DWORD = 0x00100000; 108 pub const SECURITY_VALID_SQOS_FLAGS: DWORD = 0x001F0000; 109 FN!{stdcall PFIBER_START_ROUTINE( 110 lpFiberParameter: LPVOID, 111 ) -> ()} 112 pub type LPFIBER_START_ROUTINE = PFIBER_START_ROUTINE; 113 FN!{stdcall PFIBER_CALLOUT_ROUTINE( 114 lpParameter: LPVOID, 115 ) -> LPVOID} 116 // FAIL_FAST_* 117 #[cfg(target_arch = "x86")] 118 pub type LPLDT_ENTRY = PLDT_ENTRY; 119 #[cfg(target_arch = "x86_64")] 120 pub type LPLDT_ENTRY = LPVOID; // TODO - fix this for 32-bit 121 //SP_SERIALCOMM 122 //PST_* 123 // PCF_* 124 // SP_* 125 // BAUD_* 126 // DATABITS_* 127 // STOPBITS_* 128 // PARITY_* 129 STRUCT!{struct COMMPROP { 130 wPacketLength: WORD, 131 wPacketVersion: WORD, 132 dwServiceMask: DWORD, 133 dwReserved1: DWORD, 134 dwMaxTxQueue: DWORD, 135 dwMaxRxQueue: DWORD, 136 dwMaxBaud: DWORD, 137 dwProvSubType: DWORD, 138 dwProvCapabilities: DWORD, 139 dwSettableParams: DWORD, 140 dwSettableBaud: DWORD, 141 wSettableData: WORD, 142 wSettableStopParity: WORD, 143 dwCurrentTxQueue: DWORD, 144 dwCurrentRxQueue: DWORD, 145 dwProvSpec1: DWORD, 146 dwProvSpec2: DWORD, 147 wcProvChar: [WCHAR; 1], 148 }} 149 pub type LPCOMMPROP = *mut COMMPROP; 150 STRUCT!{struct COMSTAT { 151 BitFields: DWORD, 152 cbInQue: DWORD, 153 cbOutQue: DWORD, 154 }} 155 BITFIELD!{COMSTAT BitFields: DWORD [ 156 fCtsHold set_fCtsHold[0..1], 157 fDsrHold set_fDsrHold[1..2], 158 fRlsdHold set_fRlsdHold[2..3], 159 fXoffHold set_fXoffHold[3..4], 160 fXoffSent set_fXoffSent[4..5], 161 fEof set_fEof[5..6], 162 fTxim set_fTxim[6..7], 163 fReserved set_fReserved[7..32], 164 ]} 165 pub type LPCOMSTAT = *mut COMSTAT; 166 pub const DTR_CONTROL_DISABLE: DWORD = 0x00; 167 pub const DTR_CONTROL_ENABLE: DWORD = 0x01; 168 pub const DTR_CONTROL_HANDSHAKE: DWORD = 0x02; 169 pub const RTS_CONTROL_DISABLE: DWORD = 0x00; 170 pub const RTS_CONTROL_ENABLE: DWORD = 0x01; 171 pub const RTS_CONTROL_HANDSHAKE: DWORD = 0x02; 172 pub const RTS_CONTROL_TOGGLE: DWORD = 0x03; 173 STRUCT!{struct DCB { 174 DCBlength: DWORD, 175 BaudRate: DWORD, 176 BitFields: DWORD, 177 wReserved: WORD, 178 XonLim: WORD, 179 XoffLim: WORD, 180 ByteSize: BYTE, 181 Parity: BYTE, 182 StopBits: BYTE, 183 XonChar: c_char, 184 XoffChar: c_char, 185 ErrorChar: c_char, 186 EofChar: c_char, 187 EvtChar: c_char, 188 wReserved1: WORD, 189 }} 190 BITFIELD!{DCB BitFields: DWORD [ 191 fBinary set_fBinary[0..1], 192 fParity set_fParity[1..2], 193 fOutxCtsFlow set_fOutxCtsFlow[2..3], 194 fOutxDsrFlow set_fOutxDsrFlow[3..4], 195 fDtrControl set_fDtrControl[4..6], 196 fDsrSensitivity set_fDsrSensitivity[6..7], 197 fTXContinueOnXoff set_fTXContinueOnXoff[7..8], 198 fOutX set_fOutX[8..9], 199 fInX set_fInX[9..10], 200 fErrorChar set_fErrorChar[10..11], 201 fNull set_fNull[11..12], 202 fRtsControl set_fRtsControl[12..14], 203 fAbortOnError set_fAbortOnError[14..15], 204 fDummy2 set_fDummy2[15..32], 205 ]} 206 pub type LPDCB = *mut DCB; 207 STRUCT!{struct COMMTIMEOUTS { 208 ReadIntervalTimeout: DWORD, 209 ReadTotalTimeoutMultiplier: DWORD, 210 ReadTotalTimeoutConstant: DWORD, 211 WriteTotalTimeoutMultiplier: DWORD, 212 WriteTotalTimeoutConstant: DWORD, 213 }} 214 pub type LPCOMMTIMEOUTS = *mut COMMTIMEOUTS; 215 STRUCT!{struct COMMCONFIG { 216 dwSize: DWORD, 217 wVersion: WORD, 218 wReserved: WORD, 219 dcb: DCB, 220 dwProviderSubType: DWORD, 221 dwProviderOffset: DWORD, 222 dwProviderSize: DWORD, 223 wcProviderData: [WCHAR; 1], 224 }} 225 pub type LPCOMMCONFIG = *mut COMMCONFIG; 226 // GMEM_* 227 STRUCT!{struct MEMORYSTATUS { 228 dwLength: DWORD, 229 dwMemoryLoad: DWORD, 230 dwTotalPhys: SIZE_T, 231 dwAvailPhys: SIZE_T, 232 dwTotalPageFile: SIZE_T, 233 dwAvailPageFile: SIZE_T, 234 dwTotalVirtual: SIZE_T, 235 dwAvailVirtual: SIZE_T, 236 }} 237 pub type LPMEMORYSTATUS = *mut MEMORYSTATUS; 238 // NUMA_NO_PREFERRED_NODE 239 pub const DEBUG_PROCESS: DWORD = 0x00000001; 240 pub const DEBUG_ONLY_THIS_PROCESS: DWORD = 0x00000002; 241 pub const CREATE_SUSPENDED: DWORD = 0x00000004; 242 pub const DETACHED_PROCESS: DWORD = 0x00000008; 243 pub const CREATE_NEW_CONSOLE: DWORD = 0x00000010; 244 pub const NORMAL_PRIORITY_CLASS: DWORD = 0x00000020; 245 pub const IDLE_PRIORITY_CLASS: DWORD = 0x00000040; 246 pub const HIGH_PRIORITY_CLASS: DWORD = 0x00000080; 247 pub const REALTIME_PRIORITY_CLASS: DWORD = 0x00000100; 248 pub const CREATE_NEW_PROCESS_GROUP: DWORD = 0x00000200; 249 pub const CREATE_UNICODE_ENVIRONMENT: DWORD = 0x00000400; 250 pub const CREATE_SEPARATE_WOW_VDM: DWORD = 0x00000800; 251 pub const CREATE_SHARED_WOW_VDM: DWORD = 0x00001000; 252 pub const CREATE_FORCEDOS: DWORD = 0x00002000; 253 pub const BELOW_NORMAL_PRIORITY_CLASS: DWORD = 0x00004000; 254 pub const ABOVE_NORMAL_PRIORITY_CLASS: DWORD = 0x00008000; 255 pub const INHERIT_PARENT_AFFINITY: DWORD = 0x00010000; 256 pub const INHERIT_CALLER_PRIORITY: DWORD = 0x00020000; 257 pub const CREATE_PROTECTED_PROCESS: DWORD = 0x00040000; 258 pub const EXTENDED_STARTUPINFO_PRESENT: DWORD = 0x00080000; 259 pub const PROCESS_MODE_BACKGROUND_BEGIN: DWORD = 0x00100000; 260 pub const PROCESS_MODE_BACKGROUND_END: DWORD = 0x00200000; 261 pub const CREATE_BREAKAWAY_FROM_JOB: DWORD = 0x01000000; 262 pub const CREATE_PRESERVE_CODE_AUTHZ_LEVEL: DWORD = 0x02000000; 263 pub const CREATE_DEFAULT_ERROR_MODE: DWORD = 0x04000000; 264 pub const CREATE_NO_WINDOW: DWORD = 0x08000000; 265 pub const PROFILE_USER: DWORD = 0x10000000; 266 pub const PROFILE_KERNEL: DWORD = 0x20000000; 267 pub const PROFILE_SERVER: DWORD = 0x40000000; 268 pub const CREATE_IGNORE_SYSTEM_DEFAULT: DWORD = 0x80000000; 269 // STACK_SIZE_PARAM_IS_A_RESERVATION 270 pub const THREAD_PRIORITY_LOWEST: DWORD = THREAD_BASE_PRIORITY_MIN; 271 pub const THREAD_PRIORITY_BELOW_NORMAL: DWORD = THREAD_PRIORITY_LOWEST + 1; 272 pub const THREAD_PRIORITY_NORMAL: DWORD = 0; 273 pub const THREAD_PRIORITY_HIGHEST: DWORD = THREAD_BASE_PRIORITY_MAX; 274 pub const THREAD_PRIORITY_ABOVE_NORMAL: DWORD = THREAD_PRIORITY_HIGHEST - 1; 275 pub const THREAD_PRIORITY_ERROR_RETURN: DWORD = MAXLONG as u32; 276 pub const THREAD_PRIORITY_TIME_CRITICAL: DWORD = THREAD_BASE_PRIORITY_LOWRT; 277 pub const THREAD_PRIORITY_IDLE: DWORD = THREAD_BASE_PRIORITY_IDLE; 278 pub const THREAD_MODE_BACKGROUND_BEGIN: DWORD = 0x00010000; 279 pub const THREAD_MODE_BACKGROUND_END: DWORD = 0x00020000; 280 pub const VOLUME_NAME_DOS: DWORD = 0x0; 281 // VOLUME_NAME_* 282 // FILE_NAME_* 283 // JIT_DEBUG_* 284 pub const DRIVE_UNKNOWN: DWORD = 0; 285 pub const DRIVE_NO_ROOT_DIR: DWORD = 1; 286 pub const DRIVE_REMOVABLE: DWORD = 2; 287 pub const DRIVE_FIXED: DWORD = 3; 288 pub const DRIVE_REMOTE: DWORD = 4; 289 pub const DRIVE_CDROM: DWORD = 5; 290 pub const DRIVE_RAMDISK: DWORD = 6; 291 // pub fn GetFreeSpace(); 292 pub const FILE_TYPE_UNKNOWN: DWORD = 0x0000; 293 pub const FILE_TYPE_DISK: DWORD = 0x0001; 294 pub const FILE_TYPE_CHAR: DWORD = 0x0002; 295 pub const FILE_TYPE_PIPE: DWORD = 0x0003; 296 pub const FILE_TYPE_REMOTE: DWORD = 0x8000; 297 pub const STD_INPUT_HANDLE: DWORD = -10i32 as u32; 298 pub const STD_OUTPUT_HANDLE: DWORD = -11i32 as u32; 299 pub const STD_ERROR_HANDLE: DWORD = -12i32 as u32; 300 pub const NOPARITY: BYTE = 0; 301 pub const ODDPARITY: BYTE = 1; 302 pub const EVENPARITY: BYTE = 2; 303 pub const MARKPARITY: BYTE = 3; 304 pub const SPACEPARITY: BYTE = 4; 305 pub const ONESTOPBIT: BYTE = 0; 306 pub const ONE5STOPBITS: BYTE = 1; 307 pub const TWOSTOPBITS: BYTE = 2; 308 pub const IGNORE: DWORD = 0; 309 pub const INFINITE: DWORD = 0xFFFFFFFF; 310 pub const CBR_110: DWORD = 110; 311 pub const CBR_300: DWORD = 300; 312 pub const CBR_600: DWORD = 600; 313 pub const CBR_1200: DWORD = 1200; 314 pub const CBR_2400: DWORD = 2400; 315 pub const CBR_4800: DWORD = 4800; 316 pub const CBR_9600: DWORD = 9600; 317 pub const CBR_14400: DWORD = 14400; 318 pub const CBR_19200: DWORD = 19200; 319 pub const CBR_38400: DWORD = 38400; 320 pub const CBR_56000: DWORD = 56000; 321 pub const CBR_57600: DWORD = 57600; 322 pub const CBR_115200: DWORD = 115200; 323 pub const CBR_128000: DWORD = 128000; 324 pub const CBR_256000: DWORD = 256000; 325 // CE_* 326 // IE_* 327 // EV_* 328 pub const SETXOFF: DWORD = 1; 329 pub const SETXON: DWORD = 2; 330 pub const SETRTS: DWORD = 3; 331 pub const CLRRTS: DWORD = 4; 332 pub const SETDTR: DWORD = 5; 333 pub const CLRDTR: DWORD = 6; 334 pub const RESETDEV: DWORD = 7; 335 pub const SETBREAK: DWORD = 8; 336 pub const CLRBREAK: DWORD = 9; 337 pub const PURGE_TXABORT: DWORD = 0x0001; 338 pub const PURGE_RXABORT: DWORD = 0x0002; 339 pub const PURGE_TXCLEAR: DWORD = 0x0004; 340 pub const PURGE_RXCLEAR: DWORD = 0x0008; 341 pub const MS_CTS_ON: DWORD = 0x0010; 342 pub const MS_DSR_ON: DWORD = 0x0020; 343 pub const MS_RING_ON: DWORD = 0x0040; 344 pub const MS_RLSD_ON: DWORD = 0x0080; 345 // S_* 346 // NMPWAIT_* 347 // FS_* 348 // OF_* 349 pub const OFS_MAXPATHNAME: usize = 128; 350 STRUCT!{struct OFSTRUCT { 351 cBytes: BYTE, 352 fFixedDisk: BYTE, 353 nErrCode: WORD, 354 Reserved1: WORD, 355 Reserved2: WORD, 356 szPathName: [CHAR; OFS_MAXPATHNAME], 357 }} 358 pub type POFSTRUCT = *mut OFSTRUCT; 359 pub type LPOFSTRUCT = *mut OFSTRUCT; 360 extern "system" { GlobalAlloc( uFlags: UINT, dwBytes: SIZE_T ) -> HGLOBAL361 pub fn GlobalAlloc( 362 uFlags: UINT, 363 dwBytes: SIZE_T 364 ) -> HGLOBAL; GlobalReAlloc( hMem: HGLOBAL, dwBytes: SIZE_T, uFlags: UINT ) -> HGLOBAL365 pub fn GlobalReAlloc( 366 hMem: HGLOBAL, 367 dwBytes: SIZE_T, 368 uFlags: UINT 369 ) -> HGLOBAL; GlobalSize( hMem: HGLOBAL ) -> SIZE_T370 pub fn GlobalSize( 371 hMem: HGLOBAL 372 ) -> SIZE_T; GlobalFlags( hMem: HGLOBAL ) -> UINT373 pub fn GlobalFlags( 374 hMem: HGLOBAL 375 ) -> UINT; GlobalLock( hMem: HGLOBAL ) -> LPVOID376 pub fn GlobalLock( 377 hMem: HGLOBAL 378 ) -> LPVOID; GlobalHandle( pMem: LPCVOID ) -> HGLOBAL379 pub fn GlobalHandle( 380 pMem: LPCVOID 381 ) -> HGLOBAL; GlobalUnlock( hMem: HGLOBAL ) -> BOOL382 pub fn GlobalUnlock( 383 hMem: HGLOBAL 384 ) -> BOOL; GlobalFree( hMem: HGLOBAL ) -> HGLOBAL385 pub fn GlobalFree( 386 hMem: HGLOBAL 387 ) -> HGLOBAL; GlobalCompact( dwMinFree: DWORD ) -> SIZE_T388 pub fn GlobalCompact( 389 dwMinFree: DWORD 390 ) -> SIZE_T; GlobalFix( hMem: HGLOBAL )391 pub fn GlobalFix( 392 hMem: HGLOBAL 393 ); GlobalUnfix( hMem: HGLOBAL )394 pub fn GlobalUnfix( 395 hMem: HGLOBAL 396 ); GlobalWire( hMem: HGLOBAL ) -> LPVOID397 pub fn GlobalWire( 398 hMem: HGLOBAL 399 ) -> LPVOID; GlobalUnWire( hMem: HGLOBAL ) -> BOOL400 pub fn GlobalUnWire( 401 hMem: HGLOBAL 402 ) -> BOOL; GlobalMemoryStatus( lpBuffer: LPMEMORYSTATUS )403 pub fn GlobalMemoryStatus( 404 lpBuffer: LPMEMORYSTATUS 405 ); LocalAlloc( uFlags: UINT, uBytes: SIZE_T ) -> HLOCAL406 pub fn LocalAlloc( 407 uFlags: UINT, 408 uBytes: SIZE_T 409 ) -> HLOCAL; LocalReAlloc( hMem: HLOCAL, uBytes: SIZE_T, uFlags: UINT ) -> HLOCAL410 pub fn LocalReAlloc( 411 hMem: HLOCAL, 412 uBytes: SIZE_T, 413 uFlags: UINT 414 ) -> HLOCAL; LocalLock( hMem: HLOCAL ) -> LPVOID415 pub fn LocalLock( 416 hMem: HLOCAL 417 ) -> LPVOID; LocalHandle( pMem: LPCVOID ) -> HLOCAL418 pub fn LocalHandle( 419 pMem: LPCVOID 420 ) -> HLOCAL; LocalUnlock( hMem: HLOCAL ) -> BOOL421 pub fn LocalUnlock( 422 hMem: HLOCAL 423 ) -> BOOL; LocalSize( hMem: HLOCAL ) -> SIZE_T424 pub fn LocalSize( 425 hMem: HLOCAL 426 ) -> SIZE_T; LocalFlags( hMem: HLOCAL, ) -> UINT427 pub fn LocalFlags( 428 hMem: HLOCAL, 429 ) -> UINT; LocalFree( hMem: HLOCAL ) -> HLOCAL430 pub fn LocalFree( 431 hMem: HLOCAL 432 ) -> HLOCAL; LocalShrink( hMem: HLOCAL, cbNewSize: UINT ) -> SIZE_T433 pub fn LocalShrink( 434 hMem: HLOCAL, 435 cbNewSize: UINT 436 ) -> SIZE_T; LocalCompact( uMinFree: UINT ) -> SIZE_T437 pub fn LocalCompact( 438 uMinFree: UINT 439 ) -> SIZE_T; 440 } 441 // SCS_* 442 extern "system" { GetBinaryTypeA( lpApplicationName: LPCSTR, lpBinaryType: LPDWORD ) -> BOOL443 pub fn GetBinaryTypeA( 444 lpApplicationName: LPCSTR, 445 lpBinaryType: LPDWORD 446 ) -> BOOL; GetBinaryTypeW( lpApplicationName: LPCWSTR, lpBinaryType: LPDWORD ) -> BOOL447 pub fn GetBinaryTypeW( 448 lpApplicationName: LPCWSTR, 449 lpBinaryType: LPDWORD 450 ) -> BOOL; GetShortPathNameA( lpszLongPath: LPCSTR, lpszShortPath: LPSTR, cchBuffer: DWORD, ) -> DWORD451 pub fn GetShortPathNameA( 452 lpszLongPath: LPCSTR, 453 lpszShortPath: LPSTR, 454 cchBuffer: DWORD, 455 ) -> DWORD; GetLongPathNameTransactedA( lpszShortPath: LPCSTR, lpszLongPath: LPSTR, cchBuffer: DWORD, hTransaction: HANDLE, ) -> DWORD456 pub fn GetLongPathNameTransactedA( 457 lpszShortPath: LPCSTR, 458 lpszLongPath: LPSTR, 459 cchBuffer: DWORD, 460 hTransaction: HANDLE, 461 ) -> DWORD; GetLongPathNameTransactedW( lpszShortPath: LPCWSTR, lpszLongPath: LPWSTR, cchBuffer: DWORD, hTransaction: HANDLE, ) -> DWORD462 pub fn GetLongPathNameTransactedW( 463 lpszShortPath: LPCWSTR, 464 lpszLongPath: LPWSTR, 465 cchBuffer: DWORD, 466 hTransaction: HANDLE, 467 ) -> DWORD; GetProcessAffinityMask( hProcess: HANDLE, lpProcessAffinityMask: PDWORD_PTR, lpSystemAffinityMask: PDWORD_PTR, ) -> BOOL468 pub fn GetProcessAffinityMask( 469 hProcess: HANDLE, 470 lpProcessAffinityMask: PDWORD_PTR, 471 lpSystemAffinityMask: PDWORD_PTR, 472 ) -> BOOL; SetProcessAffinityMask( hProcess: HANDLE, dwProcessAffinityMask: DWORD ) -> BOOL473 pub fn SetProcessAffinityMask( 474 hProcess: HANDLE, 475 dwProcessAffinityMask: DWORD 476 ) -> BOOL; GetProcessIoCounters( hProcess: HANDLE, lpIoCounters: PIO_COUNTERS ) -> BOOL477 pub fn GetProcessIoCounters( 478 hProcess: HANDLE, 479 lpIoCounters: PIO_COUNTERS 480 ) -> BOOL; GetProcessWorkingSetSize( hProcess: HANDLE, lpMinimumWorkingSetSize: PSIZE_T, lpMaximumWorkingSetSize: PSIZE_T, ) -> BOOL481 pub fn GetProcessWorkingSetSize( 482 hProcess: HANDLE, 483 lpMinimumWorkingSetSize: PSIZE_T, 484 lpMaximumWorkingSetSize: PSIZE_T, 485 ) -> BOOL; SetProcessWorkingSetSize( hProcess: HANDLE, dwMinimumWorkingSetSize: SIZE_T, dwMaximumWorkingSetSize: SIZE_T, ) -> BOOL486 pub fn SetProcessWorkingSetSize( 487 hProcess: HANDLE, 488 dwMinimumWorkingSetSize: SIZE_T, 489 dwMaximumWorkingSetSize: SIZE_T, 490 ) -> BOOL; FatalExit( ExitCode: c_int )491 pub fn FatalExit( 492 ExitCode: c_int 493 ); SetEnvironmentStringsA( NewEnvironment: LPCH ) -> BOOL494 pub fn SetEnvironmentStringsA( 495 NewEnvironment: LPCH 496 ) -> BOOL; SwitchToFiber( lpFiber: LPVOID )497 pub fn SwitchToFiber( 498 lpFiber: LPVOID 499 ); DeleteFiber( lpFiber: LPVOID )500 pub fn DeleteFiber( 501 lpFiber: LPVOID 502 ); ConvertFiberToThread() -> BOOL503 pub fn ConvertFiberToThread() -> BOOL; CreateFiberEx( dwStackCommitSize: SIZE_T, dwStackReserveSize: SIZE_T, dwFlags: DWORD, lpStartAddress: LPFIBER_START_ROUTINE, lpParameter: LPVOID, ) -> LPVOID504 pub fn CreateFiberEx( 505 dwStackCommitSize: SIZE_T, 506 dwStackReserveSize: SIZE_T, 507 dwFlags: DWORD, 508 lpStartAddress: LPFIBER_START_ROUTINE, 509 lpParameter: LPVOID, 510 ) -> LPVOID; ConvertThreadToFiberEx( lpParameter: LPVOID, dwFlags: DWORD ) -> LPVOID511 pub fn ConvertThreadToFiberEx( 512 lpParameter: LPVOID, 513 dwFlags: DWORD 514 ) -> LPVOID; CreateFiber( dwStackSize: SIZE_T, lpStartAddress: LPFIBER_START_ROUTINE, lpParameter: LPVOID, ) -> LPVOID515 pub fn CreateFiber( 516 dwStackSize: SIZE_T, 517 lpStartAddress: LPFIBER_START_ROUTINE, 518 lpParameter: LPVOID, 519 ) -> LPVOID; ConvertThreadToFiber( lpParameter: LPVOID ) -> LPVOID520 pub fn ConvertThreadToFiber( 521 lpParameter: LPVOID 522 ) -> LPVOID; 523 } 524 pub type PUMS_CONTEXT = *mut c_void; 525 pub type PUMS_COMPLETION_LIST = *mut c_void; 526 pub type UMS_THREAD_INFO_CLASS = RTL_UMS_THREAD_INFO_CLASS; 527 pub type PUMS_THREAD_INFO_CLASS = *mut UMS_THREAD_INFO_CLASS; 528 pub type PUMS_SCHEDULER_ENTRY_POINT = PRTL_UMS_SCHEDULER_ENTRY_POINT; 529 STRUCT!{struct UMS_SCHEDULER_STARTUP_INFO { 530 UmsVersion: ULONG, 531 CompletionList: PUMS_COMPLETION_LIST, 532 SchedulerProc: PUMS_SCHEDULER_ENTRY_POINT, 533 SchedulerParam: PVOID, 534 }} 535 pub type PUMS_SCHEDULER_STARTUP_INFO = *mut UMS_SCHEDULER_STARTUP_INFO; 536 STRUCT!{struct UMS_SYSTEM_THREAD_INFORMATION { 537 UmsVersion: ULONG, 538 ThreadUmsFlags: ULONG, 539 }} 540 BITFIELD!{UMS_SYSTEM_THREAD_INFORMATION ThreadUmsFlags: ULONG [ 541 IsUmsSchedulerThread set_IsUmsSchedulerThread[0..1], 542 IsUmsWorkerThread set_IsUmsWorkerThread[1..2], 543 ]} 544 pub type PUMS_SYSTEM_THREAD_INFORMATION = *mut UMS_SYSTEM_THREAD_INFORMATION; 545 extern "system" { 546 #[cfg(target_arch = "x86_64")] CreateUmsCompletionList( UmsCompletionList: *mut PUMS_COMPLETION_LIST ) -> BOOL547 pub fn CreateUmsCompletionList( 548 UmsCompletionList: *mut PUMS_COMPLETION_LIST 549 ) -> BOOL; 550 #[cfg(target_arch = "x86_64")] DequeueUmsCompletionListItems( UmsCompletionList: PUMS_COMPLETION_LIST, WaitTimeOut: DWORD, UmsThreadList: *mut PUMS_CONTEXT, ) -> BOOL551 pub fn DequeueUmsCompletionListItems( 552 UmsCompletionList: PUMS_COMPLETION_LIST, 553 WaitTimeOut: DWORD, 554 UmsThreadList: *mut PUMS_CONTEXT, 555 ) -> BOOL; 556 #[cfg(target_arch = "x86_64")] GetUmsCompletionListEvent( UmsCompletionList: PUMS_COMPLETION_LIST, UmsCompletionEvent: PHANDLE, ) -> BOOL557 pub fn GetUmsCompletionListEvent( 558 UmsCompletionList: PUMS_COMPLETION_LIST, 559 UmsCompletionEvent: PHANDLE, 560 ) -> BOOL; 561 #[cfg(target_arch = "x86_64")] ExecuteUmsThread( UmsThread: PUMS_CONTEXT ) -> BOOL562 pub fn ExecuteUmsThread( 563 UmsThread: PUMS_CONTEXT 564 ) -> BOOL; 565 #[cfg(target_arch = "x86_64")] UmsThreadYield( SchedulerParam: PVOID ) -> BOOL566 pub fn UmsThreadYield( 567 SchedulerParam: PVOID 568 ) -> BOOL; 569 #[cfg(target_arch = "x86_64")] DeleteUmsCompletionList( UmsCompletionList: PUMS_COMPLETION_LIST ) -> BOOL570 pub fn DeleteUmsCompletionList( 571 UmsCompletionList: PUMS_COMPLETION_LIST 572 ) -> BOOL; 573 #[cfg(target_arch = "x86_64")] GetCurrentUmsThread() -> PUMS_CONTEXT574 pub fn GetCurrentUmsThread() -> PUMS_CONTEXT; 575 #[cfg(target_arch = "x86_64")] GetNextUmsListItem( UmsContext: PUMS_CONTEXT ) -> PUMS_CONTEXT576 pub fn GetNextUmsListItem( 577 UmsContext: PUMS_CONTEXT 578 ) -> PUMS_CONTEXT; 579 #[cfg(target_arch = "x86_64")] QueryUmsThreadInformation( UmsThread: PUMS_CONTEXT, UmsThreadInfoClass: UMS_THREAD_INFO_CLASS, UmsThreadInformation: PVOID, UmsThreadInformationLength: ULONG, ReturnLength: PULONG, ) -> BOOL580 pub fn QueryUmsThreadInformation( 581 UmsThread: PUMS_CONTEXT, 582 UmsThreadInfoClass: UMS_THREAD_INFO_CLASS, 583 UmsThreadInformation: PVOID, 584 UmsThreadInformationLength: ULONG, 585 ReturnLength: PULONG, 586 ) -> BOOL; 587 #[cfg(target_arch = "x86_64")] SetUmsThreadInformation( UmsThread: PUMS_CONTEXT, UmsThreadInfoClass: UMS_THREAD_INFO_CLASS, UmsThreadInformation: PVOID, UmsThreadInformationLength: ULONG, ) -> BOOL588 pub fn SetUmsThreadInformation( 589 UmsThread: PUMS_CONTEXT, 590 UmsThreadInfoClass: UMS_THREAD_INFO_CLASS, 591 UmsThreadInformation: PVOID, 592 UmsThreadInformationLength: ULONG, 593 ) -> BOOL; 594 #[cfg(target_arch = "x86_64")] DeleteUmsThreadContext( UmsThread: PUMS_CONTEXT ) -> BOOL595 pub fn DeleteUmsThreadContext( 596 UmsThread: PUMS_CONTEXT 597 ) -> BOOL; 598 #[cfg(target_arch = "x86_64")] CreateUmsThreadContext( lpUmsThread: *mut PUMS_CONTEXT ) -> BOOL599 pub fn CreateUmsThreadContext( 600 lpUmsThread: *mut PUMS_CONTEXT 601 ) -> BOOL; 602 #[cfg(target_arch = "x86_64")] EnterUmsSchedulingMode( SchedulerStartupInfo: PUMS_SCHEDULER_STARTUP_INFO ) -> BOOL603 pub fn EnterUmsSchedulingMode( 604 SchedulerStartupInfo: PUMS_SCHEDULER_STARTUP_INFO 605 ) -> BOOL; 606 #[cfg(target_arch = "x86_64")] GetUmsSystemThreadInformation( ThreadHandle: HANDLE, SystemThreadInfo: PUMS_SYSTEM_THREAD_INFORMATION, ) -> BOOL607 pub fn GetUmsSystemThreadInformation( 608 ThreadHandle: HANDLE, 609 SystemThreadInfo: PUMS_SYSTEM_THREAD_INFORMATION, 610 ) -> BOOL; SetThreadAffinityMask( hThread: HANDLE, dwThreadAffinityMask: DWORD_PTR ) -> DWORD_PTR611 pub fn SetThreadAffinityMask( 612 hThread: HANDLE, 613 dwThreadAffinityMask: DWORD_PTR 614 ) -> DWORD_PTR; SetProcessDEPPolicy( dwFlags: DWORD ) -> BOOL615 pub fn SetProcessDEPPolicy( 616 dwFlags: DWORD 617 ) -> BOOL; GetProcessDEPPolicy( hProcess: HANDLE, lpFlags: LPDWORD, lpPermanent: PBOOL ) -> BOOL618 pub fn GetProcessDEPPolicy( 619 hProcess: HANDLE, 620 lpFlags: LPDWORD, 621 lpPermanent: PBOOL 622 ) -> BOOL; RequestWakeupLatency( latency: LATENCY_TIME ) -> BOOL623 pub fn RequestWakeupLatency( 624 latency: LATENCY_TIME 625 ) -> BOOL; IsSystemResumeAutomatic() -> BOOL626 pub fn IsSystemResumeAutomatic() -> BOOL; GetThreadSelectorEntry( hThread: HANDLE, dwSelector: DWORD, lpSelectorEntry: LPLDT_ENTRY, ) -> BOOL627 pub fn GetThreadSelectorEntry( 628 hThread: HANDLE, 629 dwSelector: DWORD, 630 lpSelectorEntry: LPLDT_ENTRY, 631 ) -> BOOL; SetThreadExecutionState( esFlags: EXECUTION_STATE ) -> EXECUTION_STATE632 pub fn SetThreadExecutionState( 633 esFlags: EXECUTION_STATE 634 ) -> EXECUTION_STATE; PowerCreateRequest( Context: PREASON_CONTEXT ) -> HANDLE635 pub fn PowerCreateRequest( 636 Context: PREASON_CONTEXT 637 ) -> HANDLE; PowerSetRequest( PowerRequest: HANDLE, RequestType: POWER_REQUEST_TYPE ) -> BOOL638 pub fn PowerSetRequest( 639 PowerRequest: HANDLE, 640 RequestType: POWER_REQUEST_TYPE 641 ) -> BOOL; PowerClearRequest( PowerRequest: HANDLE, RequestType: POWER_REQUEST_TYPE ) -> BOOL642 pub fn PowerClearRequest( 643 PowerRequest: HANDLE, 644 RequestType: POWER_REQUEST_TYPE 645 ) -> BOOL; RestoreLastError( dwErrCode: DWORD )646 pub fn RestoreLastError( 647 dwErrCode: DWORD 648 ); SetFileCompletionNotificationModes( FileHandle: HANDLE, Flags: UCHAR ) -> BOOL649 pub fn SetFileCompletionNotificationModes( 650 FileHandle: HANDLE, 651 Flags: UCHAR 652 ) -> BOOL; 653 } 654 pub const SEM_FAILCRITICALERRORS: UINT = 0x0001; 655 pub const SEM_NOGPFAULTERRORBOX: UINT = 0x0002; 656 pub const SEM_NOALIGNMENTFAULTEXCEPT: UINT = 0x0004; 657 pub const SEM_NOOPENFILEERRORBOX: UINT = 0x8000; 658 extern "system" { Wow64GetThreadContext( hThread: HANDLE, lpContext: PWOW64_CONTEXT ) -> BOOL659 pub fn Wow64GetThreadContext( 660 hThread: HANDLE, 661 lpContext: PWOW64_CONTEXT 662 ) -> BOOL; Wow64SetThreadContext( hThread: HANDLE, lpContext: *const WOW64_CONTEXT ) -> BOOL663 pub fn Wow64SetThreadContext( 664 hThread: HANDLE, 665 lpContext: *const WOW64_CONTEXT 666 ) -> BOOL; Wow64GetThreadSelectorEntry( hThread: HANDLE, dwSelector: DWORD, lpSelectorEntry: PWOW64_LDT_ENTRY, ) -> BOOL667 pub fn Wow64GetThreadSelectorEntry( 668 hThread: HANDLE, 669 dwSelector: DWORD, 670 lpSelectorEntry: PWOW64_LDT_ENTRY, 671 ) -> BOOL; Wow64SuspendThread( hThread: HANDLE ) -> DWORD672 pub fn Wow64SuspendThread( 673 hThread: HANDLE 674 ) -> DWORD; DebugSetProcessKillOnExit( KillOnExit: BOOL ) -> BOOL675 pub fn DebugSetProcessKillOnExit( 676 KillOnExit: BOOL 677 ) -> BOOL; DebugBreakProcess( Process: HANDLE ) -> BOOL678 pub fn DebugBreakProcess( 679 Process: HANDLE 680 ) -> BOOL; PulseEvent( hEvent: HANDLE ) -> BOOL681 pub fn PulseEvent( 682 hEvent: HANDLE 683 ) -> BOOL; GlobalDeleteAtom( nAtom: ATOM ) -> ATOM684 pub fn GlobalDeleteAtom( 685 nAtom: ATOM 686 ) -> ATOM; InitAtomTable( nSize: DWORD ) -> BOOL687 pub fn InitAtomTable( 688 nSize: DWORD 689 ) -> BOOL; DeleteAtom( nAtom: ATOM ) -> ATOM690 pub fn DeleteAtom( 691 nAtom: ATOM 692 ) -> ATOM; SetHandleCount( uNumber: UINT ) -> UINT693 pub fn SetHandleCount( 694 uNumber: UINT 695 ) -> UINT; RequestDeviceWakeup( hDevice: HANDLE ) -> BOOL696 pub fn RequestDeviceWakeup( 697 hDevice: HANDLE 698 ) -> BOOL; CancelDeviceWakeupRequest( hDevice: HANDLE ) -> BOOL699 pub fn CancelDeviceWakeupRequest( 700 hDevice: HANDLE 701 ) -> BOOL; GetDevicePowerState( hDevice: HANDLE, pfOn: *mut BOOL ) -> BOOL702 pub fn GetDevicePowerState( 703 hDevice: HANDLE, 704 pfOn: *mut BOOL 705 ) -> BOOL; SetMessageWaitingIndicator( hMsgIndicator: HANDLE, ulMsgCount: ULONG ) -> BOOL706 pub fn SetMessageWaitingIndicator( 707 hMsgIndicator: HANDLE, 708 ulMsgCount: ULONG 709 ) -> BOOL; SetFileShortNameA( hFile: HANDLE, lpShortName: LPCSTR ) -> BOOL710 pub fn SetFileShortNameA( 711 hFile: HANDLE, 712 lpShortName: LPCSTR 713 ) -> BOOL; SetFileShortNameW( hFile: HANDLE, lpShortName: LPCWSTR ) -> BOOL714 pub fn SetFileShortNameW( 715 hFile: HANDLE, 716 lpShortName: LPCWSTR 717 ) -> BOOL; 718 } 719 pub const HANDLE_FLAG_INHERIT: DWORD = 0x00000001; 720 pub const HANDLE_FLAG_PROTECT_FROM_CLOSE: DWORD = 0x00000002; 721 extern "system" { LoadModule( lpModuleName: LPCSTR, lpParameterBlock: LPVOID ) -> DWORD722 pub fn LoadModule( 723 lpModuleName: LPCSTR, 724 lpParameterBlock: LPVOID 725 ) -> DWORD; WinExec( lpCmdLine: LPCSTR, uCmdShow: UINT ) -> UINT726 pub fn WinExec( 727 lpCmdLine: LPCSTR, 728 uCmdShow: UINT 729 ) -> UINT; 730 // ClearCommBreak 731 // ClearCommError 732 // SetupComm 733 // EscapeCommFunction 734 // GetCommConfig 735 // GetCommMask 736 // GetCommProperties 737 // GetCommModemStatus 738 // GetCommState 739 // GetCommTimeouts 740 // PurgeComm 741 // SetCommBreak 742 // SetCommConfig 743 // SetCommMask 744 // SetCommState 745 // SetCommTimeouts 746 // TransmitCommChar 747 // WaitCommEvent SetTapePosition( hDevice: HANDLE, dwPositionMethod: DWORD, dwPartition: DWORD, dwOffsetLow: DWORD, dwOffsetHigh: DWORD, bImmediate: BOOL ) -> DWORD748 pub fn SetTapePosition( 749 hDevice: HANDLE, 750 dwPositionMethod: DWORD, 751 dwPartition: DWORD, 752 dwOffsetLow: DWORD, 753 dwOffsetHigh: DWORD, 754 bImmediate: BOOL 755 ) -> DWORD; GetTapePosition( hDevice: HANDLE, dwPositionType: DWORD, lpdwPartition: LPDWORD, lpdwOffsetLow: LPDWORD, lpdwOffsetHigh: LPDWORD ) -> DWORD756 pub fn GetTapePosition( 757 hDevice: HANDLE, 758 dwPositionType: DWORD, 759 lpdwPartition: LPDWORD, 760 lpdwOffsetLow: LPDWORD, 761 lpdwOffsetHigh: LPDWORD 762 ) -> DWORD; PrepareTape( hDevice: HANDLE, dwOperation: DWORD, bImmediate: BOOL ) -> DWORD763 pub fn PrepareTape( 764 hDevice: HANDLE, 765 dwOperation: DWORD, 766 bImmediate: BOOL 767 ) -> DWORD; EraseTape( hDevice: HANDLE, dwEraseType: DWORD, bImmediate: BOOL ) -> DWORD768 pub fn EraseTape( 769 hDevice: HANDLE, 770 dwEraseType: DWORD, 771 bImmediate: BOOL 772 ) -> DWORD; CreateTapePartition( hDevice: HANDLE, dwPartitionMethod: DWORD, dwCount: DWORD, dwSize: DWORD, ) -> DWORD773 pub fn CreateTapePartition( 774 hDevice: HANDLE, 775 dwPartitionMethod: DWORD, 776 dwCount: DWORD, 777 dwSize: DWORD, 778 ) -> DWORD; WriteTapemark( hDevice: HANDLE, dwTapemarkType: DWORD, dwTapemarkCount: DWORD, bImmediate: BOOL, ) -> DWORD779 pub fn WriteTapemark( 780 hDevice: HANDLE, 781 dwTapemarkType: DWORD, 782 dwTapemarkCount: DWORD, 783 bImmediate: BOOL, 784 ) -> DWORD; GetTapeStatus( hDevice: HANDLE ) -> DWORD785 pub fn GetTapeStatus( 786 hDevice: HANDLE 787 ) -> DWORD; GetTapeParameters( hDevice: HANDLE, dwOperation: DWORD, lpdwSize: LPDWORD, lpTapeInformation: LPVOID ) -> DWORD788 pub fn GetTapeParameters( 789 hDevice: HANDLE, 790 dwOperation: DWORD, 791 lpdwSize: LPDWORD, 792 lpTapeInformation: LPVOID 793 ) -> DWORD; SetTapeParameters( hDevice: HANDLE, dwOperation: DWORD, lpTapeInformation: LPVOID, ) -> DWORD794 pub fn SetTapeParameters( 795 hDevice: HANDLE, 796 dwOperation: DWORD, 797 lpTapeInformation: LPVOID, 798 ) -> DWORD; MulDiv( nNumber: c_int, nNumerator: c_int, nDenominator: c_int ) -> c_int799 pub fn MulDiv( 800 nNumber: c_int, 801 nNumerator: c_int, 802 nDenominator: c_int 803 ) -> c_int; 804 } 805 ENUM!{enum DEP_SYSTEM_POLICY_TYPE { 806 DEPPolicyAlwaysOff = 0, 807 DEPPolicyAlwaysOn, 808 DEPPolicyOptIn, 809 DEPPolicyOptOut, 810 DEPTotalPolicyCount, 811 }} 812 extern "system" { GetSystemDEPPolicy() -> DEP_SYSTEM_POLICY_TYPE813 pub fn GetSystemDEPPolicy() -> DEP_SYSTEM_POLICY_TYPE; GetSystemRegistryQuota( pdwQuotaAllowed: PDWORD, pdwQuotaUsed: PDWORD ) -> BOOL814 pub fn GetSystemRegistryQuota( 815 pdwQuotaAllowed: PDWORD, 816 pdwQuotaUsed: PDWORD 817 ) -> BOOL; FileTimeToDosDateTime( lpFileTime: *const FILETIME, lpFatDate: LPWORD, lpFatTime: LPWORD, ) -> BOOL818 pub fn FileTimeToDosDateTime( 819 lpFileTime: *const FILETIME, 820 lpFatDate: LPWORD, 821 lpFatTime: LPWORD, 822 ) -> BOOL; DosDateTimeToFileTime( wFatDate: WORD, wFatTime: WORD, lpFileTime: LPFILETIME ) -> BOOL823 pub fn DosDateTimeToFileTime( 824 wFatDate: WORD, 825 wFatTime: WORD, 826 lpFileTime: LPFILETIME 827 ) -> BOOL; FormatMessageA( dwFlags: DWORD, lpSource: LPCVOID, dwMessageId: DWORD, dwLanguageId: DWORD, lpBuffer: LPSTR, nSize: DWORD, Arguments: *mut va_list, ) -> DWORD828 pub fn FormatMessageA( 829 dwFlags: DWORD, 830 lpSource: LPCVOID, 831 dwMessageId: DWORD, 832 dwLanguageId: DWORD, 833 lpBuffer: LPSTR, 834 nSize: DWORD, 835 Arguments: *mut va_list, 836 ) -> DWORD; FormatMessageW( dwFlags: DWORD, lpSource: LPCVOID, dwMessageId: DWORD, dwLanguageId: DWORD, lpBuffer: LPWSTR, nSize: DWORD, Arguments: *mut va_list, ) -> DWORD837 pub fn FormatMessageW( 838 dwFlags: DWORD, 839 lpSource: LPCVOID, 840 dwMessageId: DWORD, 841 dwLanguageId: DWORD, 842 lpBuffer: LPWSTR, 843 nSize: DWORD, 844 Arguments: *mut va_list, 845 ) -> DWORD; 846 } 847 pub const FORMAT_MESSAGE_IGNORE_INSERTS: DWORD = 0x00000200; 848 pub const FORMAT_MESSAGE_FROM_STRING: DWORD = 0x00000400; 849 pub const FORMAT_MESSAGE_FROM_HMODULE: DWORD = 0x00000800; 850 pub const FORMAT_MESSAGE_FROM_SYSTEM: DWORD = 0x00001000; 851 pub const FORMAT_MESSAGE_ARGUMENT_ARRAY: DWORD = 0x00002000; 852 pub const FORMAT_MESSAGE_MAX_WIDTH_MASK: DWORD = 0x000000FF; 853 pub const FORMAT_MESSAGE_ALLOCATE_BUFFER: DWORD = 0x00000100; 854 extern "system" { CreateMailslotA( lpName: LPCSTR, nMaxMessageSize: DWORD, lReadTimeout: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> HANDLE855 pub fn CreateMailslotA( 856 lpName: LPCSTR, 857 nMaxMessageSize: DWORD, 858 lReadTimeout: DWORD, 859 lpSecurityAttributes: LPSECURITY_ATTRIBUTES, 860 ) -> HANDLE; CreateMailslotW( lpName: LPCWSTR, nMaxMessageSize: DWORD, lReadTimeout: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> HANDLE861 pub fn CreateMailslotW( 862 lpName: LPCWSTR, 863 nMaxMessageSize: DWORD, 864 lReadTimeout: DWORD, 865 lpSecurityAttributes: LPSECURITY_ATTRIBUTES, 866 ) -> HANDLE; GetMailslotInfo( hMailslot: HANDLE, lpMaxMessageSize: LPDWORD, lpNextSize: LPDWORD, lpMessageCount: LPDWORD, lpReadTimeout: LPDWORD, ) -> BOOL867 pub fn GetMailslotInfo( 868 hMailslot: HANDLE, 869 lpMaxMessageSize: LPDWORD, 870 lpNextSize: LPDWORD, 871 lpMessageCount: LPDWORD, 872 lpReadTimeout: LPDWORD, 873 ) -> BOOL; SetMailslotInfo( hMailslot: HANDLE, lReadTimeout: DWORD ) -> BOOL874 pub fn SetMailslotInfo( 875 hMailslot: HANDLE, 876 lReadTimeout: DWORD 877 ) -> BOOL; 878 // pub fn EncryptFileA(); 879 // pub fn EncryptFileW(); 880 // pub fn DecryptFileA(); 881 // pub fn DecryptFileW(); 882 // pub fn FileEncryptionStatusA(); 883 // pub fn FileEncryptionStatusW(); 884 // pub fn OpenEncryptedFileRawA(); 885 // pub fn OpenEncryptedFileRawW(); 886 // pub fn ReadEncryptedFileRaw(); 887 // pub fn WriteEncryptedFileRaw(); 888 // pub fn CloseEncryptedFileRaw(); lstrcmpA( lpString1: LPCSTR, lpString2: LPCSTR ) -> c_int889 pub fn lstrcmpA( 890 lpString1: LPCSTR, 891 lpString2: LPCSTR 892 ) -> c_int; lstrcmpW( lpString1: LPCWSTR, lpString2: LPCWSTR ) -> c_int893 pub fn lstrcmpW( 894 lpString1: LPCWSTR, 895 lpString2: LPCWSTR 896 ) -> c_int; lstrcmpiA( lpString1: LPCSTR, lpString2: LPCSTR ) -> c_int897 pub fn lstrcmpiA( 898 lpString1: LPCSTR, 899 lpString2: LPCSTR 900 ) -> c_int; lstrcmpiW( lpString1: LPCWSTR, lpString2: LPCWSTR ) -> c_int901 pub fn lstrcmpiW( 902 lpString1: LPCWSTR, 903 lpString2: LPCWSTR 904 ) -> c_int; lstrcpynA( lpString1: LPSTR, lpString2: LPCSTR, iMaxLength: c_int ) -> LPSTR905 pub fn lstrcpynA( 906 lpString1: LPSTR, 907 lpString2: LPCSTR, 908 iMaxLength: c_int 909 ) -> LPSTR; lstrcpynW( lpString1: LPWSTR, lpString2: LPCWSTR, iMaxLength: c_int ) -> LPWSTR910 pub fn lstrcpynW( 911 lpString1: LPWSTR, 912 lpString2: LPCWSTR, 913 iMaxLength: c_int 914 ) -> LPWSTR; lstrcpyA( lpString1: LPSTR, lpString2: LPCSTR ) -> LPSTR915 pub fn lstrcpyA( 916 lpString1: LPSTR, 917 lpString2: LPCSTR 918 ) -> LPSTR; lstrcpyW( lpString1: LPWSTR, lpString2: LPCWSTR ) -> LPWSTR919 pub fn lstrcpyW( 920 lpString1: LPWSTR, 921 lpString2: LPCWSTR 922 ) -> LPWSTR; lstrcatA( lpString1: LPSTR, lpString2: LPCSTR ) -> LPSTR923 pub fn lstrcatA( 924 lpString1: LPSTR, 925 lpString2: LPCSTR 926 ) -> LPSTR; lstrcatW( lpString1: LPWSTR, lpString2: LPCWSTR ) -> LPWSTR927 pub fn lstrcatW( 928 lpString1: LPWSTR, 929 lpString2: LPCWSTR 930 ) -> LPWSTR; lstrlenA( lpString: LPCSTR ) -> c_int931 pub fn lstrlenA( 932 lpString: LPCSTR 933 ) -> c_int; lstrlenW( lpString: LPCWSTR ) -> c_int934 pub fn lstrlenW( 935 lpString: LPCWSTR 936 ) -> c_int; OpenFile( lpFileName: LPCSTR, lpReOpenBuff: LPOFSTRUCT, uStyle: UINT ) -> HFILE937 pub fn OpenFile( 938 lpFileName: LPCSTR, 939 lpReOpenBuff: LPOFSTRUCT, 940 uStyle: UINT 941 ) -> HFILE; _lopen( lpPathName: LPCSTR, iReadWrite: c_int ) -> HFILE942 pub fn _lopen( 943 lpPathName: LPCSTR, 944 iReadWrite: c_int 945 ) -> HFILE; _lcreat( lpPathName: LPCSTR, iAttrubute: c_int ) -> HFILE946 pub fn _lcreat( 947 lpPathName: LPCSTR, 948 iAttrubute: c_int 949 ) -> HFILE; _lread( hFile: HFILE, lpBuffer: LPVOID, uBytes: UINT ) -> UINT950 pub fn _lread( 951 hFile: HFILE, 952 lpBuffer: LPVOID, 953 uBytes: UINT 954 ) -> UINT; _lwrite( hFile: HFILE, lpBuffer: LPCCH, uBytes: UINT ) -> UINT955 pub fn _lwrite( 956 hFile: HFILE, 957 lpBuffer: LPCCH, 958 uBytes: UINT 959 ) -> UINT; _hread( hFile: HFILE, lpBuffer: LPVOID, lBytes: c_long ) -> c_long960 pub fn _hread( 961 hFile: HFILE, 962 lpBuffer: LPVOID, 963 lBytes: c_long 964 ) -> c_long; _hwrite( hFile: HFILE, lpBuffer: LPCCH, lBytes: c_long ) -> c_long965 pub fn _hwrite( 966 hFile: HFILE, 967 lpBuffer: LPCCH, 968 lBytes: c_long 969 ) -> c_long; _lclose( hFile: HFILE ) -> HFILE970 pub fn _lclose( 971 hFile: HFILE 972 ) -> HFILE; _llseek( hFile: HFILE, lOffset: LONG, iOrigin: c_int ) -> LONG973 pub fn _llseek( 974 hFile: HFILE, 975 lOffset: LONG, 976 iOrigin: c_int 977 ) -> LONG; 978 // pub fn IsTextUnicode(); 979 // pub fn SignalObjectAndWait(); BackupRead( hFile: HANDLE, lpBuffer: LPBYTE, nNumberOfBytesToRead: DWORD, lpNumberOfBytesRead: LPDWORD, bAbort: BOOL, bProcessSecurity: BOOL, lpContext: *mut LPVOID, ) -> BOOL980 pub fn BackupRead( 981 hFile: HANDLE, 982 lpBuffer: LPBYTE, 983 nNumberOfBytesToRead: DWORD, 984 lpNumberOfBytesRead: LPDWORD, 985 bAbort: BOOL, 986 bProcessSecurity: BOOL, 987 lpContext: *mut LPVOID, 988 ) -> BOOL; BackupSeek( hFile: HANDLE, dwLowBytesToSeek: DWORD, dwHighBytesToSeek: DWORD, lpdwLowByteSeeked: LPDWORD, lpdwHighByteSeeked: LPDWORD, lpContext: *mut LPVOID, ) -> BOOL989 pub fn BackupSeek( 990 hFile: HANDLE, 991 dwLowBytesToSeek: DWORD, 992 dwHighBytesToSeek: DWORD, 993 lpdwLowByteSeeked: LPDWORD, 994 lpdwHighByteSeeked: LPDWORD, 995 lpContext: *mut LPVOID, 996 ) -> BOOL; BackupWrite( hFile: HANDLE, lpBuffer: LPBYTE, nNumberOfBytesToWrite: DWORD, lpNumberOfBytesWritten: LPDWORD, bAbort: BOOL, bProcessSecurity: BOOL, lpContext: *mut LPVOID, ) -> BOOL997 pub fn BackupWrite( 998 hFile: HANDLE, 999 lpBuffer: LPBYTE, 1000 nNumberOfBytesToWrite: DWORD, 1001 lpNumberOfBytesWritten: LPDWORD, 1002 bAbort: BOOL, 1003 bProcessSecurity: BOOL, 1004 lpContext: *mut LPVOID, 1005 ) -> BOOL; 1006 } 1007 //2886 1008 pub const STARTF_USESHOWWINDOW: DWORD = 0x00000001; 1009 pub const STARTF_USESIZE: DWORD = 0x00000002; 1010 pub const STARTF_USEPOSITION: DWORD = 0x00000004; 1011 pub const STARTF_USECOUNTCHARS: DWORD = 0x00000008; 1012 pub const STARTF_USEFILLATTRIBUTE: DWORD = 0x00000010; 1013 pub const STARTF_RUNFULLSCREEN: DWORD = 0x00000020; 1014 pub const STARTF_FORCEONFEEDBACK: DWORD = 0x00000040; 1015 pub const STARTF_FORCEOFFFEEDBACK: DWORD = 0x00000080; 1016 pub const STARTF_USESTDHANDLES: DWORD = 0x00000100; 1017 pub const STARTF_USEHOTKEY: DWORD = 0x00000200; 1018 pub const STARTF_TITLEISLINKNAME: DWORD = 0x00000800; 1019 pub const STARTF_TITLEISAPPID: DWORD = 0x00001000; 1020 pub const STARTF_PREVENTPINNING: DWORD = 0x00002000; 1021 pub const STARTF_UNTRUSTEDSOURCE: DWORD = 0x00008000; 1022 STRUCT!{struct STARTUPINFOEXA { 1023 StartupInfo: STARTUPINFOA, 1024 lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST, 1025 }} 1026 pub type LPSTARTUPINFOEXA = *mut STARTUPINFOEXA; 1027 STRUCT!{struct STARTUPINFOEXW { 1028 StartupInfo: STARTUPINFOW, 1029 lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST, 1030 }} 1031 pub type LPSTARTUPINFOEXW = *mut STARTUPINFOEXW; 1032 extern "system" { OpenMutexA( dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR ) -> HANDLE1033 pub fn OpenMutexA( 1034 dwDesiredAccess: DWORD, 1035 bInheritHandle: BOOL, 1036 lpName: LPCSTR 1037 ) -> HANDLE; CreateSemaphoreA( lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCSTR, ) -> HANDLE1038 pub fn CreateSemaphoreA( 1039 lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, 1040 lInitialCount: LONG, 1041 lMaximumCount: LONG, 1042 lpName: LPCSTR, 1043 ) -> HANDLE; OpenSemaphoreA( dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR ) -> HANDLE1044 pub fn OpenSemaphoreA( 1045 dwDesiredAccess: DWORD, 1046 bInheritHandle: BOOL, 1047 lpName: LPCSTR 1048 ) -> HANDLE; CreateWaitableTimerA( lpTimerAttributes: LPSECURITY_ATTRIBUTES, bManualReset: BOOL, lpTimerName: LPCSTR, ) -> HANDLE1049 pub fn CreateWaitableTimerA( 1050 lpTimerAttributes: LPSECURITY_ATTRIBUTES, 1051 bManualReset: BOOL, 1052 lpTimerName: LPCSTR, 1053 ) -> HANDLE; OpenWaitableTimerA( dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpTimerName: LPCSTR, ) -> HANDLE1054 pub fn OpenWaitableTimerA( 1055 dwDesiredAccess: DWORD, 1056 bInheritHandle: BOOL, 1057 lpTimerName: LPCSTR, 1058 ) -> HANDLE; CreateSemaphoreExA( lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCSTR, dwFlags: DWORD, dwDesiredAccess: DWORD, ) -> HANDLE1059 pub fn CreateSemaphoreExA( 1060 lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, 1061 lInitialCount: LONG, 1062 lMaximumCount: LONG, 1063 lpName: LPCSTR, 1064 dwFlags: DWORD, 1065 dwDesiredAccess: DWORD, 1066 ) -> HANDLE; CreateWaitableTimerExA( lpTimerAttributes: LPSECURITY_ATTRIBUTES, lpTimerName: LPCSTR, dwFlags: DWORD, dwDesiredAccess: DWORD, ) -> HANDLE1067 pub fn CreateWaitableTimerExA( 1068 lpTimerAttributes: LPSECURITY_ATTRIBUTES, 1069 lpTimerName: LPCSTR, 1070 dwFlags: DWORD, 1071 dwDesiredAccess: DWORD, 1072 ) -> HANDLE; CreateFileMappingA( hFile: HANDLE, lpAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCSTR, ) -> HANDLE1073 pub fn CreateFileMappingA( 1074 hFile: HANDLE, 1075 lpAttributes: LPSECURITY_ATTRIBUTES, 1076 flProtect: DWORD, 1077 dwMaximumSizeHigh: DWORD, 1078 dwMaximumSizeLow: DWORD, 1079 lpName: LPCSTR, 1080 ) -> HANDLE; CreateFileMappingNumaA( hFile: HANDLE, lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCSTR, nndPreferred: DWORD, ) -> HANDLE1081 pub fn CreateFileMappingNumaA( 1082 hFile: HANDLE, 1083 lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, 1084 flProtect: DWORD, 1085 dwMaximumSizeHigh: DWORD, 1086 dwMaximumSizeLow: DWORD, 1087 lpName: LPCSTR, 1088 nndPreferred: DWORD, 1089 ) -> HANDLE; OpenFileMappingA( dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR, ) -> HANDLE1090 pub fn OpenFileMappingA( 1091 dwDesiredAccess: DWORD, 1092 bInheritHandle: BOOL, 1093 lpName: LPCSTR, 1094 ) -> HANDLE; GetLogicalDriveStringsA( nBufferLength: DWORD, lpBuffer: LPSTR ) -> DWORD1095 pub fn GetLogicalDriveStringsA( 1096 nBufferLength: DWORD, 1097 lpBuffer: LPSTR 1098 ) -> DWORD; LoadPackagedLibrary( lpwLibFileName: LPCWSTR, Reserved: DWORD ) -> HMODULE1099 pub fn LoadPackagedLibrary( 1100 lpwLibFileName: LPCWSTR, 1101 Reserved: DWORD 1102 ) -> HMODULE; QueryFullProcessImageNameA( hProcess: HANDLE, dwFlags: DWORD, lpExeName: LPSTR, lpdwSize: PDWORD, ) -> BOOL1103 pub fn QueryFullProcessImageNameA( 1104 hProcess: HANDLE, 1105 dwFlags: DWORD, 1106 lpExeName: LPSTR, 1107 lpdwSize: PDWORD, 1108 ) -> BOOL; QueryFullProcessImageNameW( hProcess: HANDLE, dwFlags: DWORD, lpExeName: LPWSTR, lpdwSize: PDWORD, ) -> BOOL1109 pub fn QueryFullProcessImageNameW( 1110 hProcess: HANDLE, 1111 dwFlags: DWORD, 1112 lpExeName: LPWSTR, 1113 lpdwSize: PDWORD, 1114 ) -> BOOL; 1115 } 1116 //3233 1117 extern "system" { GetStartupInfoA( lpStartupInfo: LPSTARTUPINFOA )1118 pub fn GetStartupInfoA( 1119 lpStartupInfo: LPSTARTUPINFOA 1120 ); GetFirmwareEnvironmentVariableA( lpName: LPCSTR, lpGuid: LPCSTR, pBuffer: PVOID, nSize: DWORD, ) -> DWORD1121 pub fn GetFirmwareEnvironmentVariableA( 1122 lpName: LPCSTR, 1123 lpGuid: LPCSTR, 1124 pBuffer: PVOID, 1125 nSize: DWORD, 1126 ) -> DWORD; GetFirmwareEnvironmentVariableW( lpName: LPCWSTR, lpGuid: LPCWSTR, pBuffer: PVOID, nSize: DWORD, ) -> DWORD1127 pub fn GetFirmwareEnvironmentVariableW( 1128 lpName: LPCWSTR, 1129 lpGuid: LPCWSTR, 1130 pBuffer: PVOID, 1131 nSize: DWORD, 1132 ) -> DWORD; GetFirmwareEnvironmentVariableExA( lpName: LPCSTR, lpGuid: LPCSTR, pBuffer: PVOID, nSize: DWORD, pdwAttribubutes: PDWORD, ) -> DWORD1133 pub fn GetFirmwareEnvironmentVariableExA( 1134 lpName: LPCSTR, 1135 lpGuid: LPCSTR, 1136 pBuffer: PVOID, 1137 nSize: DWORD, 1138 pdwAttribubutes: PDWORD, 1139 ) -> DWORD; GetFirmwareEnvironmentVariableExW( lpName: LPCWSTR, lpGuid: LPCWSTR, pBuffer: PVOID, nSize: DWORD, pdwAttribubutes: PDWORD, ) -> DWORD1140 pub fn GetFirmwareEnvironmentVariableExW( 1141 lpName: LPCWSTR, 1142 lpGuid: LPCWSTR, 1143 pBuffer: PVOID, 1144 nSize: DWORD, 1145 pdwAttribubutes: PDWORD, 1146 ) -> DWORD; SetFirmwareEnvironmentVariableA( lpName: LPCSTR, lpGuid: LPCSTR, pValue: PVOID, nSize: DWORD, ) -> BOOL1147 pub fn SetFirmwareEnvironmentVariableA( 1148 lpName: LPCSTR, 1149 lpGuid: LPCSTR, 1150 pValue: PVOID, 1151 nSize: DWORD, 1152 ) -> BOOL; SetFirmwareEnvironmentVariableW( lpName: LPCWSTR, lpGuid: LPCWSTR, pValue: PVOID, nSize: DWORD, ) -> BOOL1153 pub fn SetFirmwareEnvironmentVariableW( 1154 lpName: LPCWSTR, 1155 lpGuid: LPCWSTR, 1156 pValue: PVOID, 1157 nSize: DWORD, 1158 ) -> BOOL; SetFirmwareEnvironmentVariableExA( lpName: LPCSTR, lpGuid: LPCSTR, pValue: PVOID, nSize: DWORD, dwAttributes: DWORD, ) -> BOOL1159 pub fn SetFirmwareEnvironmentVariableExA( 1160 lpName: LPCSTR, 1161 lpGuid: LPCSTR, 1162 pValue: PVOID, 1163 nSize: DWORD, 1164 dwAttributes: DWORD, 1165 ) -> BOOL; SetFirmwareEnvironmentVariableExW( lpName: LPCWSTR, lpGuid: LPCWSTR, pValue: PVOID, nSize: DWORD, dwAttributes: DWORD, ) -> BOOL1166 pub fn SetFirmwareEnvironmentVariableExW( 1167 lpName: LPCWSTR, 1168 lpGuid: LPCWSTR, 1169 pValue: PVOID, 1170 nSize: DWORD, 1171 dwAttributes: DWORD, 1172 ) -> BOOL; GetFirmwareType( FirmwareType: PFIRMWARE_TYPE ) -> BOOL1173 pub fn GetFirmwareType( 1174 FirmwareType: PFIRMWARE_TYPE 1175 ) -> BOOL; IsNativeVhdBoot( NativeVhdBoot: PBOOL ) -> BOOL1176 pub fn IsNativeVhdBoot( 1177 NativeVhdBoot: PBOOL 1178 ) -> BOOL; FindResourceA( hModule: HMODULE, lpName: LPCSTR, lpType: LPCSTR ) -> HRSRC1179 pub fn FindResourceA( 1180 hModule: HMODULE, 1181 lpName: LPCSTR, 1182 lpType: LPCSTR 1183 ) -> HRSRC; FindResourceExA( hModule: HMODULE, lpName: LPCSTR, lpType: LPCSTR, wLanguage: WORD, ) -> HRSRC1184 pub fn FindResourceExA( 1185 hModule: HMODULE, 1186 lpName: LPCSTR, 1187 lpType: LPCSTR, 1188 wLanguage: WORD, 1189 ) -> HRSRC; EnumResourceTypesA( hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCA, lParam: LONG_PTR, ) -> BOOL1190 pub fn EnumResourceTypesA( 1191 hModule: HMODULE, 1192 lpEnumFunc: ENUMRESTYPEPROCA, 1193 lParam: LONG_PTR, 1194 ) -> BOOL; EnumResourceTypesW( hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCW, lParam: LONG_PTR, ) -> BOOL1195 pub fn EnumResourceTypesW( 1196 hModule: HMODULE, 1197 lpEnumFunc: ENUMRESTYPEPROCW, 1198 lParam: LONG_PTR, 1199 ) -> BOOL; EnumResourceNamesA( hModule: HMODULE, lpType: LPCSTR, lpEnumFunc: ENUMRESNAMEPROCA, lParam: LONG_PTR, ) -> BOOL1200 pub fn EnumResourceNamesA( 1201 hModule: HMODULE, 1202 lpType: LPCSTR, 1203 lpEnumFunc: ENUMRESNAMEPROCA, 1204 lParam: LONG_PTR, 1205 ) -> BOOL; EnumResourceLanguagesA( hModule: HMODULE, lpType: LPCSTR, lpName: LPCSTR, lpEnumFunc: ENUMRESLANGPROCA, lParam: LONG_PTR, ) -> BOOL1206 pub fn EnumResourceLanguagesA( 1207 hModule: HMODULE, 1208 lpType: LPCSTR, 1209 lpName: LPCSTR, 1210 lpEnumFunc: ENUMRESLANGPROCA, 1211 lParam: LONG_PTR, 1212 ) -> BOOL; EnumResourceLanguagesW( hModule: HMODULE, lpType: LPCWSTR, lpName: LPCWSTR, lpEnumFunc: ENUMRESLANGPROCW, lParam: LONG_PTR, ) -> BOOL1213 pub fn EnumResourceLanguagesW( 1214 hModule: HMODULE, 1215 lpType: LPCWSTR, 1216 lpName: LPCWSTR, 1217 lpEnumFunc: ENUMRESLANGPROCW, 1218 lParam: LONG_PTR, 1219 ) -> BOOL; BeginUpdateResourceA( pFileName: LPCSTR, bDeleteExistingResources: BOOL ) -> HANDLE1220 pub fn BeginUpdateResourceA( 1221 pFileName: LPCSTR, 1222 bDeleteExistingResources: BOOL 1223 ) -> HANDLE; BeginUpdateResourceW( pFileName: LPCWSTR, bDeleteExistingResources: BOOL ) -> HANDLE1224 pub fn BeginUpdateResourceW( 1225 pFileName: LPCWSTR, 1226 bDeleteExistingResources: BOOL 1227 ) -> HANDLE; UpdateResourceA( hUpdate: HANDLE, lpType: LPCSTR, lpName: LPCSTR, wLanguage: WORD, lpData: LPVOID, cb: DWORD, ) -> BOOL1228 pub fn UpdateResourceA( 1229 hUpdate: HANDLE, 1230 lpType: LPCSTR, 1231 lpName: LPCSTR, 1232 wLanguage: WORD, 1233 lpData: LPVOID, 1234 cb: DWORD, 1235 ) -> BOOL; UpdateResourceW( hUpdate: HANDLE, lpType: LPCWSTR, lpName: LPCWSTR, wLanguage: WORD, lpData: LPVOID, cb: DWORD, ) -> BOOL1236 pub fn UpdateResourceW( 1237 hUpdate: HANDLE, 1238 lpType: LPCWSTR, 1239 lpName: LPCWSTR, 1240 wLanguage: WORD, 1241 lpData: LPVOID, 1242 cb: DWORD, 1243 ) -> BOOL; EndUpdateResourceA( hUpdate: HANDLE, fDiscard: BOOL ) -> BOOL1244 pub fn EndUpdateResourceA( 1245 hUpdate: HANDLE, 1246 fDiscard: BOOL 1247 ) -> BOOL; EndUpdateResourceW( hUpdate: HANDLE, fDiscard: BOOL ) -> BOOL1248 pub fn EndUpdateResourceW( 1249 hUpdate: HANDLE, 1250 fDiscard: BOOL 1251 ) -> BOOL; 1252 #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] GlobalAddAtomA( lpString: LPCSTR ) -> ATOM1253 pub fn GlobalAddAtomA( 1254 lpString: LPCSTR 1255 ) -> ATOM; GlobalAddAtomW( lpString: LPCWSTR ) -> ATOM1256 pub fn GlobalAddAtomW( 1257 lpString: LPCWSTR 1258 ) -> ATOM; GlobalAddAtomExA( lpString: LPCSTR, Flags: DWORD ) -> ATOM1259 pub fn GlobalAddAtomExA( 1260 lpString: LPCSTR, 1261 Flags: DWORD 1262 ) -> ATOM; GlobalAddAtomExW( lpString: LPCWSTR, Flags: DWORD ) -> ATOM1263 pub fn GlobalAddAtomExW( 1264 lpString: LPCWSTR, 1265 Flags: DWORD 1266 ) -> ATOM; GlobalFindAtomA( lpString: LPCSTR ) -> ATOM1267 pub fn GlobalFindAtomA( 1268 lpString: LPCSTR 1269 ) -> ATOM; GlobalFindAtomW( lpString: LPCWSTR ) -> ATOM1270 pub fn GlobalFindAtomW( 1271 lpString: LPCWSTR 1272 ) -> ATOM; GlobalGetAtomNameA( nAtom: ATOM, lpBuffer: LPSTR, nSize: c_int ) -> UINT1273 pub fn GlobalGetAtomNameA( 1274 nAtom: ATOM, 1275 lpBuffer: LPSTR, 1276 nSize: c_int 1277 ) -> UINT; GlobalGetAtomNameW( nAtom: ATOM, lpBuffer: LPWSTR, nSize: c_int ) -> UINT1278 pub fn GlobalGetAtomNameW( 1279 nAtom: ATOM, 1280 lpBuffer: LPWSTR, 1281 nSize: c_int 1282 ) -> UINT; AddAtomA( lpString: LPCSTR ) -> ATOM1283 pub fn AddAtomA( 1284 lpString: LPCSTR 1285 ) -> ATOM; AddAtomW( lpString: LPCWSTR ) -> ATOM1286 pub fn AddAtomW( 1287 lpString: LPCWSTR 1288 ) -> ATOM; FindAtomA( lpString: LPCSTR ) -> ATOM1289 pub fn FindAtomA( 1290 lpString: LPCSTR 1291 ) -> ATOM; FindAtomW( lpString: LPCWSTR ) -> ATOM1292 pub fn FindAtomW( 1293 lpString: LPCWSTR 1294 ) -> ATOM; GetAtomNameA( nAtom: ATOM, lpBuffer: LPSTR, nSize: c_int ) -> UINT1295 pub fn GetAtomNameA( 1296 nAtom: ATOM, 1297 lpBuffer: LPSTR, 1298 nSize: c_int 1299 ) -> UINT; GetAtomNameW( nAtom: ATOM, lpBuffer: LPWSTR, nSize: c_int ) -> UINT1300 pub fn GetAtomNameW( 1301 nAtom: ATOM, 1302 lpBuffer: LPWSTR, 1303 nSize: c_int 1304 ) -> UINT; GetProfileIntA( lpAppName: LPCSTR, lpKeyName: LPCSTR, nDefault: INT ) -> UINT1305 pub fn GetProfileIntA( 1306 lpAppName: LPCSTR, 1307 lpKeyName: LPCSTR, 1308 nDefault: INT 1309 ) -> UINT; GetProfileIntW( lpAppName: LPCWSTR, lpKeyName: LPCWSTR, nDefault: INT ) -> UINT1310 pub fn GetProfileIntW( 1311 lpAppName: LPCWSTR, 1312 lpKeyName: LPCWSTR, 1313 nDefault: INT 1314 ) -> UINT; GetProfileStringA( lpAppName: LPCSTR, lpKeyName: LPCSTR, lpDefault: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD, ) -> DWORD1315 pub fn GetProfileStringA( 1316 lpAppName: LPCSTR, 1317 lpKeyName: LPCSTR, 1318 lpDefault: LPCSTR, 1319 lpReturnedString: LPSTR, 1320 nSize: DWORD, 1321 ) -> DWORD; GetProfileStringW( lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpDefault: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD, ) -> DWORD1322 pub fn GetProfileStringW( 1323 lpAppName: LPCWSTR, 1324 lpKeyName: LPCWSTR, 1325 lpDefault: LPCWSTR, 1326 lpReturnedString: LPWSTR, 1327 nSize: DWORD, 1328 ) -> DWORD; WriteProfileStringA( lpAppName: LPCSTR, lpKeyName: LPCSTR, lpString: LPCSTR ) -> BOOL1329 pub fn WriteProfileStringA( 1330 lpAppName: LPCSTR, 1331 lpKeyName: LPCSTR, 1332 lpString: LPCSTR 1333 ) -> BOOL; WriteProfileStringW( lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpString: LPCWSTR ) -> BOOL1334 pub fn WriteProfileStringW( 1335 lpAppName: LPCWSTR, 1336 lpKeyName: LPCWSTR, 1337 lpString: LPCWSTR 1338 ) -> BOOL; GetProfileSectionA( lpAppName: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD ) -> DWORD1339 pub fn GetProfileSectionA( 1340 lpAppName: LPCSTR, 1341 lpReturnedString: LPSTR, 1342 nSize: DWORD 1343 ) -> DWORD; GetProfileSectionW( lpAppName: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD ) -> DWORD1344 pub fn GetProfileSectionW( 1345 lpAppName: LPCWSTR, 1346 lpReturnedString: LPWSTR, 1347 nSize: DWORD 1348 ) -> DWORD; WriteProfileSectionA( lpAppName: LPCSTR, lpString: LPCSTR ) -> BOOL1349 pub fn WriteProfileSectionA( 1350 lpAppName: LPCSTR, 1351 lpString: LPCSTR 1352 ) -> BOOL; WriteProfileSectionW( lpAppName: LPCWSTR, lpString: LPCWSTR ) -> BOOL1353 pub fn WriteProfileSectionW( 1354 lpAppName: LPCWSTR, 1355 lpString: LPCWSTR 1356 ) -> BOOL; GetPrivateProfileIntA( lpAppName: LPCSTR, lpKeyName: LPCSTR, nDefault: INT, lpFileName: LPCSTR, ) -> UINT1357 pub fn GetPrivateProfileIntA( 1358 lpAppName: LPCSTR, 1359 lpKeyName: LPCSTR, 1360 nDefault: INT, 1361 lpFileName: LPCSTR, 1362 ) -> UINT; GetPrivateProfileIntW( lpAppName: LPCWSTR, lpKeyName: LPCWSTR, nDefault: INT, lpFileName: LPCWSTR, ) -> UINT1363 pub fn GetPrivateProfileIntW( 1364 lpAppName: LPCWSTR, 1365 lpKeyName: LPCWSTR, 1366 nDefault: INT, 1367 lpFileName: LPCWSTR, 1368 ) -> UINT; GetPrivateProfileStringA( lpAppName: LPCSTR, lpKeyName: LPCSTR, lpDefault: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD, lpFileName: LPCSTR, ) -> DWORD1369 pub fn GetPrivateProfileStringA( 1370 lpAppName: LPCSTR, 1371 lpKeyName: LPCSTR, 1372 lpDefault: LPCSTR, 1373 lpReturnedString: LPSTR, 1374 nSize: DWORD, 1375 lpFileName: LPCSTR, 1376 ) -> DWORD; GetPrivateProfileStringW( lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpDefault: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD, lpFileName: LPCWSTR, ) -> DWORD1377 pub fn GetPrivateProfileStringW( 1378 lpAppName: LPCWSTR, 1379 lpKeyName: LPCWSTR, 1380 lpDefault: LPCWSTR, 1381 lpReturnedString: LPWSTR, 1382 nSize: DWORD, 1383 lpFileName: LPCWSTR, 1384 ) -> DWORD; WritePrivateProfileStringA( lpAppName: LPCSTR, lpKeyName: LPCSTR, lpString: LPCSTR, lpFileName: LPCSTR, ) -> BOOL1385 pub fn WritePrivateProfileStringA( 1386 lpAppName: LPCSTR, 1387 lpKeyName: LPCSTR, 1388 lpString: LPCSTR, 1389 lpFileName: LPCSTR, 1390 ) -> BOOL; WritePrivateProfileStringW( lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpString: LPCWSTR, lpFileName: LPCWSTR, ) -> BOOL1391 pub fn WritePrivateProfileStringW( 1392 lpAppName: LPCWSTR, 1393 lpKeyName: LPCWSTR, 1394 lpString: LPCWSTR, 1395 lpFileName: LPCWSTR, 1396 ) -> BOOL; GetPrivateProfileSectionA( lpAppName: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD, lpFileName: LPCSTR, ) -> DWORD1397 pub fn GetPrivateProfileSectionA( 1398 lpAppName: LPCSTR, 1399 lpReturnedString: LPSTR, 1400 nSize: DWORD, 1401 lpFileName: LPCSTR, 1402 ) -> DWORD; GetPrivateProfileSectionW( lpAppName: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD, lpFileName: LPCWSTR, ) -> DWORD1403 pub fn GetPrivateProfileSectionW( 1404 lpAppName: LPCWSTR, 1405 lpReturnedString: LPWSTR, 1406 nSize: DWORD, 1407 lpFileName: LPCWSTR, 1408 ) -> DWORD; WritePrivateProfileSectionA( lpAppName: LPCSTR, lpString: LPCSTR, lpFileName: LPCSTR, ) -> BOOL1409 pub fn WritePrivateProfileSectionA( 1410 lpAppName: LPCSTR, 1411 lpString: LPCSTR, 1412 lpFileName: LPCSTR, 1413 ) -> BOOL; WritePrivateProfileSectionW( lpAppName: LPCWSTR, lpString: LPCWSTR, lpFileName: LPCWSTR, ) -> BOOL1414 pub fn WritePrivateProfileSectionW( 1415 lpAppName: LPCWSTR, 1416 lpString: LPCWSTR, 1417 lpFileName: LPCWSTR, 1418 ) -> BOOL; GetPrivateProfileSectionNamesA( lpszReturnBuffer: LPSTR, nSize: DWORD, lpFileName: LPCSTR, ) -> DWORD1419 pub fn GetPrivateProfileSectionNamesA( 1420 lpszReturnBuffer: LPSTR, 1421 nSize: DWORD, 1422 lpFileName: LPCSTR, 1423 ) -> DWORD; GetPrivateProfileSectionNamesW( lpszReturnBuffer: LPWSTR, nSize: DWORD, lpFileName: LPCWSTR, ) -> DWORD1424 pub fn GetPrivateProfileSectionNamesW( 1425 lpszReturnBuffer: LPWSTR, 1426 nSize: DWORD, 1427 lpFileName: LPCWSTR, 1428 ) -> DWORD; GetPrivateProfileStructA( lpszSection: LPCSTR, lpszKey: LPCSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCSTR, ) -> BOOL1429 pub fn GetPrivateProfileStructA( 1430 lpszSection: LPCSTR, 1431 lpszKey: LPCSTR, 1432 lpStruct: LPVOID, 1433 uSizeStruct: UINT, 1434 szFile: LPCSTR, 1435 ) -> BOOL; GetPrivateProfileStructW( lpszSection: LPCWSTR, lpszKey: LPCWSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCWSTR, ) -> BOOL1436 pub fn GetPrivateProfileStructW( 1437 lpszSection: LPCWSTR, 1438 lpszKey: LPCWSTR, 1439 lpStruct: LPVOID, 1440 uSizeStruct: UINT, 1441 szFile: LPCWSTR, 1442 ) -> BOOL; WritePrivateProfileStructA( lpszSection: LPCSTR, lpszKey: LPCSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCSTR, ) -> BOOL1443 pub fn WritePrivateProfileStructA( 1444 lpszSection: LPCSTR, 1445 lpszKey: LPCSTR, 1446 lpStruct: LPVOID, 1447 uSizeStruct: UINT, 1448 szFile: LPCSTR, 1449 ) -> BOOL; WritePrivateProfileStructW( lpszSection: LPCWSTR, lpszKey: LPCWSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCWSTR, ) -> BOOL1450 pub fn WritePrivateProfileStructW( 1451 lpszSection: LPCWSTR, 1452 lpszKey: LPCWSTR, 1453 lpStruct: LPVOID, 1454 uSizeStruct: UINT, 1455 szFile: LPCWSTR, 1456 ) -> BOOL; Wow64EnableWow64FsRedirection( Wow64FsEnableRedirection: BOOLEAN ) -> BOOLEAN1457 pub fn Wow64EnableWow64FsRedirection( 1458 Wow64FsEnableRedirection: BOOLEAN 1459 ) -> BOOLEAN; SetDllDirectoryA( lpPathName: LPCSTR ) -> BOOL1460 pub fn SetDllDirectoryA( 1461 lpPathName: LPCSTR 1462 ) -> BOOL; SetDllDirectoryW( lpPathName: LPCWSTR ) -> BOOL1463 pub fn SetDllDirectoryW( 1464 lpPathName: LPCWSTR 1465 ) -> BOOL; GetDllDirectoryA( nBufferLength: DWORD, lpBuffer: LPSTR ) -> DWORD1466 pub fn GetDllDirectoryA( 1467 nBufferLength: DWORD, 1468 lpBuffer: LPSTR 1469 ) -> DWORD; GetDllDirectoryW( nBufferLength: DWORD, lpBuffer: LPWSTR ) -> DWORD1470 pub fn GetDllDirectoryW( 1471 nBufferLength: DWORD, 1472 lpBuffer: LPWSTR 1473 ) -> DWORD; SetSearchPathMode( Flags: DWORD ) -> BOOL1474 pub fn SetSearchPathMode( 1475 Flags: DWORD 1476 ) -> BOOL; CreateDirectoryExA( lpTemplateDirectory: LPCSTR, lpNewDirectory: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> BOOL1477 pub fn CreateDirectoryExA( 1478 lpTemplateDirectory: LPCSTR, 1479 lpNewDirectory: LPCSTR, 1480 lpSecurityAttributes: LPSECURITY_ATTRIBUTES, 1481 ) -> BOOL; CreateDirectoryExW( lpTemplateDirectory: LPCWSTR, lpNewDirectory: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> BOOL1482 pub fn CreateDirectoryExW( 1483 lpTemplateDirectory: LPCWSTR, 1484 lpNewDirectory: LPCWSTR, 1485 lpSecurityAttributes: LPSECURITY_ATTRIBUTES, 1486 ) -> BOOL; CreateDirectoryTransactedA( lpTemplateDirectory: LPCSTR, lpNewDirectory: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE, ) -> BOOL1487 pub fn CreateDirectoryTransactedA( 1488 lpTemplateDirectory: LPCSTR, 1489 lpNewDirectory: LPCSTR, 1490 lpSecurityAttributes: LPSECURITY_ATTRIBUTES, 1491 hTransaction: HANDLE, 1492 ) -> BOOL; CreateDirectoryTransactedW( lpTemplateDirectory: LPCWSTR, lpNewDirectory: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE, ) -> BOOL1493 pub fn CreateDirectoryTransactedW( 1494 lpTemplateDirectory: LPCWSTR, 1495 lpNewDirectory: LPCWSTR, 1496 lpSecurityAttributes: LPSECURITY_ATTRIBUTES, 1497 hTransaction: HANDLE, 1498 ) -> BOOL; RemoveDirectoryTransactedA( lpPathName: LPCSTR, hTransaction: HANDLE ) -> BOOL1499 pub fn RemoveDirectoryTransactedA( 1500 lpPathName: LPCSTR, 1501 hTransaction: HANDLE 1502 ) -> BOOL; RemoveDirectoryTransactedW( lpPathName: LPCWSTR, hTransaction: HANDLE ) -> BOOL1503 pub fn RemoveDirectoryTransactedW( 1504 lpPathName: LPCWSTR, 1505 hTransaction: HANDLE 1506 ) -> BOOL; GetFullPathNameTransactedA( lpFileName: LPCSTR, nBufferLength: DWORD, lpBuffer: LPSTR, lpFilePart: *mut LPSTR, hTransaction: HANDLE, ) -> DWORD1507 pub fn GetFullPathNameTransactedA( 1508 lpFileName: LPCSTR, 1509 nBufferLength: DWORD, 1510 lpBuffer: LPSTR, 1511 lpFilePart: *mut LPSTR, 1512 hTransaction: HANDLE, 1513 ) -> DWORD; GetFullPathNameTransactedW( lpFileName: LPCWSTR, nBufferLength: DWORD, lpBuffer: LPWSTR, lpFilePart: *mut LPWSTR, hTransaction: HANDLE, )1514 pub fn GetFullPathNameTransactedW( 1515 lpFileName: LPCWSTR, 1516 nBufferLength: DWORD, 1517 lpBuffer: LPWSTR, 1518 lpFilePart: *mut LPWSTR, 1519 hTransaction: HANDLE, 1520 ); DefineDosDeviceA( dwFlags: DWORD, lpDeviceName: LPCSTR, lpTargetPath: LPCSTR ) -> BOOL1521 pub fn DefineDosDeviceA( 1522 dwFlags: DWORD, 1523 lpDeviceName: LPCSTR, 1524 lpTargetPath: LPCSTR 1525 ) -> BOOL; QueryDosDeviceA( lpDeviceName: LPCSTR, lpTargetPath: LPSTR, ucchMax: DWORD ) -> DWORD1526 pub fn QueryDosDeviceA( 1527 lpDeviceName: LPCSTR, 1528 lpTargetPath: LPSTR, 1529 ucchMax: DWORD 1530 ) -> DWORD; CreateFileTransactedA( lpFileName: LPCSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE, hTransaction: HANDLE, pusMiniVersion: PUSHORT, lpExtendedParameter: PVOID, ) -> HANDLE1531 pub fn CreateFileTransactedA( 1532 lpFileName: LPCSTR, 1533 dwDesiredAccess: DWORD, 1534 dwShareMode: DWORD, 1535 lpSecurityAttributes: LPSECURITY_ATTRIBUTES, 1536 dwCreationDisposition: DWORD, 1537 dwFlagsAndAttributes: DWORD, 1538 hTemplateFile: HANDLE, 1539 hTransaction: HANDLE, 1540 pusMiniVersion: PUSHORT, 1541 lpExtendedParameter: PVOID, 1542 ) -> HANDLE; CreateFileTransactedW( lpFileName: LPCWSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE, hTransaction: HANDLE, pusMiniVersion: PUSHORT, lpExtendedParameter: PVOID, ) -> HANDLE1543 pub fn CreateFileTransactedW( 1544 lpFileName: LPCWSTR, 1545 dwDesiredAccess: DWORD, 1546 dwShareMode: DWORD, 1547 lpSecurityAttributes: LPSECURITY_ATTRIBUTES, 1548 dwCreationDisposition: DWORD, 1549 dwFlagsAndAttributes: DWORD, 1550 hTemplateFile: HANDLE, 1551 hTransaction: HANDLE, 1552 pusMiniVersion: PUSHORT, 1553 lpExtendedParameter: PVOID, 1554 ) -> HANDLE; ReOpenFile( hOriginalFile: HANDLE, dwDesiredAccess: DWORD, dwShareMode: DWORD, dwFlags: DWORD, ) -> HANDLE1555 pub fn ReOpenFile( 1556 hOriginalFile: HANDLE, 1557 dwDesiredAccess: DWORD, 1558 dwShareMode: DWORD, 1559 dwFlags: DWORD, 1560 ) -> HANDLE; SetFileAttributesTransactedA( lpFileName: LPCSTR, dwFileAttributes: DWORD, hTransaction: HANDLE, ) -> BOOL1561 pub fn SetFileAttributesTransactedA( 1562 lpFileName: LPCSTR, 1563 dwFileAttributes: DWORD, 1564 hTransaction: HANDLE, 1565 ) -> BOOL; SetFileAttributesTransactedW( lpFileName: LPCWSTR, dwFileAttributes: DWORD, hTransaction: HANDLE, ) -> BOOL1566 pub fn SetFileAttributesTransactedW( 1567 lpFileName: LPCWSTR, 1568 dwFileAttributes: DWORD, 1569 hTransaction: HANDLE, 1570 ) -> BOOL; GetFileAttributesTransactedA( lpFileName: LPCSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID, hTransaction: HANDLE, ) -> BOOL1571 pub fn GetFileAttributesTransactedA( 1572 lpFileName: LPCSTR, 1573 fInfoLevelId: GET_FILEEX_INFO_LEVELS, 1574 lpFileInformation: LPVOID, 1575 hTransaction: HANDLE, 1576 ) -> BOOL; GetFileAttributesTransactedW( lpFileName: LPCWSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID, hTransaction: HANDLE, ) -> BOOL1577 pub fn GetFileAttributesTransactedW( 1578 lpFileName: LPCWSTR, 1579 fInfoLevelId: GET_FILEEX_INFO_LEVELS, 1580 lpFileInformation: LPVOID, 1581 hTransaction: HANDLE, 1582 ) -> BOOL; GetCompressedFileSizeTransactedA( lpFileName: LPCSTR, lpFileSizeHigh: LPDWORD, hTransaction: HANDLE, ) -> DWORD1583 pub fn GetCompressedFileSizeTransactedA( 1584 lpFileName: LPCSTR, 1585 lpFileSizeHigh: LPDWORD, 1586 hTransaction: HANDLE, 1587 ) -> DWORD; GetCompressedFileSizeTransactedW( lpFileName: LPCWSTR, lpFileSizeHigh: LPDWORD, hTransaction: HANDLE, )1588 pub fn GetCompressedFileSizeTransactedW( 1589 lpFileName: LPCWSTR, 1590 lpFileSizeHigh: LPDWORD, 1591 hTransaction: HANDLE, 1592 ); DeleteFileTransactedA( lpFileName: LPCSTR, hTransaction: HANDLE ) -> BOOL1593 pub fn DeleteFileTransactedA( 1594 lpFileName: LPCSTR, 1595 hTransaction: HANDLE 1596 ) -> BOOL; DeleteFileTransactedW( lpFileName: LPCWSTR, hTransaction: HANDLE ) -> BOOL1597 pub fn DeleteFileTransactedW( 1598 lpFileName: LPCWSTR, 1599 hTransaction: HANDLE 1600 ) -> BOOL; CheckNameLegalDOS8Dot3A( lpName: LPCSTR, lpOemName: LPSTR, OemNameSize: DWORD, pbNameContainsSpaces: PBOOL, pbNameLegal: PBOOL, ) -> BOOL1601 pub fn CheckNameLegalDOS8Dot3A( 1602 lpName: LPCSTR, 1603 lpOemName: LPSTR, 1604 OemNameSize: DWORD, 1605 pbNameContainsSpaces: PBOOL, 1606 pbNameLegal: PBOOL, 1607 ) -> BOOL; CheckNameLegalDOS8Dot3W( lpName: LPCWSTR, lpOemName: LPSTR, OemNameSize: DWORD, pbNameContainsSpaces: PBOOL, pbNameLegal: PBOOL, ) -> BOOL1608 pub fn CheckNameLegalDOS8Dot3W( 1609 lpName: LPCWSTR, 1610 lpOemName: LPSTR, 1611 OemNameSize: DWORD, 1612 pbNameContainsSpaces: PBOOL, 1613 pbNameLegal: PBOOL, 1614 ) -> BOOL; FindFirstFileTransactedA( lpFileName: LPCSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID, fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD, hTransaction: HANDLE, ) -> HANDLE1615 pub fn FindFirstFileTransactedA( 1616 lpFileName: LPCSTR, 1617 fInfoLevelId: FINDEX_INFO_LEVELS, 1618 lpFindFileData: LPVOID, 1619 fSearchOp: FINDEX_SEARCH_OPS, 1620 lpSearchFilter: LPVOID, 1621 dwAdditionalFlags: DWORD, 1622 hTransaction: HANDLE, 1623 ) -> HANDLE; FindFirstFileTransactedW( lpFileName: LPCWSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID, fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD, hTransaction: HANDLE, ) -> HANDLE1624 pub fn FindFirstFileTransactedW( 1625 lpFileName: LPCWSTR, 1626 fInfoLevelId: FINDEX_INFO_LEVELS, 1627 lpFindFileData: LPVOID, 1628 fSearchOp: FINDEX_SEARCH_OPS, 1629 lpSearchFilter: LPVOID, 1630 dwAdditionalFlags: DWORD, 1631 hTransaction: HANDLE, 1632 ) -> HANDLE; CopyFileA( lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, bFailIfExists: BOOL ) -> BOOL1633 pub fn CopyFileA( 1634 lpExistingFileName: LPCSTR, 1635 lpNewFileName: LPCSTR, 1636 bFailIfExists: BOOL 1637 ) -> BOOL; CopyFileW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, bFailIfExists: BOOL ) -> BOOL1638 pub fn CopyFileW( 1639 lpExistingFileName: LPCWSTR, 1640 lpNewFileName: LPCWSTR, 1641 bFailIfExists: BOOL 1642 ) -> BOOL; 1643 } 1644 FN!{stdcall LPPROGRESS_ROUTINE( 1645 TotalFileSize: LARGE_INTEGER, 1646 TotalBytesTransferred: LARGE_INTEGER, 1647 StreamSize: LARGE_INTEGER, 1648 StreamBytesTransferred: LARGE_INTEGER, 1649 dwStreamNumber: DWORD, 1650 dwCallbackReason: DWORD, 1651 hSourceFile: HANDLE, 1652 hDestinationFile: HANDLE, 1653 lpData: LPVOID, 1654 ) -> DWORD} 1655 extern "system" { CopyFileExA( lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD, ) -> BOOL1656 pub fn CopyFileExA( 1657 lpExistingFileName: LPCSTR, 1658 lpNewFileName: LPCSTR, 1659 lpProgressRoutine: LPPROGRESS_ROUTINE, 1660 lpData: LPVOID, 1661 pbCancel: LPBOOL, 1662 dwCopyFlags: DWORD, 1663 ) -> BOOL; CopyFileExW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD, ) -> BOOL1664 pub fn CopyFileExW( 1665 lpExistingFileName: LPCWSTR, 1666 lpNewFileName: LPCWSTR, 1667 lpProgressRoutine: LPPROGRESS_ROUTINE, 1668 lpData: LPVOID, 1669 pbCancel: LPBOOL, 1670 dwCopyFlags: DWORD, 1671 ) -> BOOL; CopyFileTransactedA( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD, hTransaction: HANDLE, ) -> BOOL1672 pub fn CopyFileTransactedA( 1673 lpExistingFileName: LPCWSTR, 1674 lpNewFileName: LPCWSTR, 1675 lpProgressRoutine: LPPROGRESS_ROUTINE, 1676 lpData: LPVOID, 1677 pbCancel: LPBOOL, 1678 dwCopyFlags: DWORD, 1679 hTransaction: HANDLE, 1680 ) -> BOOL; CopyFileTransactedW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD, hTransaction: HANDLE, ) -> BOOL1681 pub fn CopyFileTransactedW( 1682 lpExistingFileName: LPCWSTR, 1683 lpNewFileName: LPCWSTR, 1684 lpProgressRoutine: LPPROGRESS_ROUTINE, 1685 lpData: LPVOID, 1686 pbCancel: LPBOOL, 1687 dwCopyFlags: DWORD, 1688 hTransaction: HANDLE, 1689 ) -> BOOL; 1690 } 1691 ENUM!{enum COPYFILE2_MESSAGE_TYPE { 1692 COPYFILE2_CALLBACK_NONE = 0, 1693 COPYFILE2_CALLBACK_CHUNK_STARTED, 1694 COPYFILE2_CALLBACK_CHUNK_FINISHED, 1695 COPYFILE2_CALLBACK_STREAM_STARTED, 1696 COPYFILE2_CALLBACK_STREAM_FINISHED, 1697 COPYFILE2_CALLBACK_POLL_CONTINUE, 1698 COPYFILE2_CALLBACK_ERROR, 1699 COPYFILE2_CALLBACK_MAX, 1700 }} 1701 ENUM!{enum COPYFILE2_MESSAGE_ACTION { 1702 COPYFILE2_PROGRESS_CONTINUE = 0, 1703 COPYFILE2_PROGRESS_CANCEL, 1704 COPYFILE2_PROGRESS_STOP, 1705 COPYFILE2_PROGRESS_QUIET, 1706 COPYFILE2_PROGRESS_PAUSE, 1707 }} 1708 ENUM!{enum COPYFILE2_COPY_PHASE { 1709 COPYFILE2_PHASE_NONE = 0, 1710 COPYFILE2_PHASE_PREPARE_SOURCE, 1711 COPYFILE2_PHASE_PREPARE_DEST, 1712 COPYFILE2_PHASE_READ_SOURCE, 1713 COPYFILE2_PHASE_WRITE_DESTINATION, 1714 COPYFILE2_PHASE_SERVER_COPY, 1715 COPYFILE2_PHASE_NAMEGRAFT_COPY, 1716 COPYFILE2_PHASE_MAX, 1717 }} 1718 STRUCT!{struct COPYFILE2_MESSAGE_ChunkStarted { 1719 dwStreamNumber: DWORD, 1720 dwReserved: DWORD, 1721 hSourceFile: HANDLE, 1722 hDestinationFile: HANDLE, 1723 uliChunkNumber: ULARGE_INTEGER, 1724 uliChunkSize: ULARGE_INTEGER, 1725 uliStreamSize: ULARGE_INTEGER, 1726 uliTotalFileSize: ULARGE_INTEGER, 1727 }} 1728 STRUCT!{struct COPYFILE2_MESSAGE_ChunkFinished { 1729 dwStreamNumber: DWORD, 1730 dwFlags: DWORD, 1731 hSourceFile: HANDLE, 1732 hDestinationFile: HANDLE, 1733 uliChunkNumber: ULARGE_INTEGER, 1734 uliChunkSize: ULARGE_INTEGER, 1735 uliStreamSize: ULARGE_INTEGER, 1736 uliStreamBytesTransferred: ULARGE_INTEGER, 1737 uliTotalFileSize: ULARGE_INTEGER, 1738 uliTotalBytesTransferred: ULARGE_INTEGER, 1739 }} 1740 STRUCT!{struct COPYFILE2_MESSAGE_StreamStarted { 1741 dwStreamNumber: DWORD, 1742 dwReserved: DWORD, 1743 hSourceFile: HANDLE, 1744 hDestinationFile: HANDLE, 1745 uliStreamSize: ULARGE_INTEGER, 1746 uliTotalFileSize: ULARGE_INTEGER, 1747 }} 1748 STRUCT!{struct COPYFILE2_MESSAGE_StreamFinished { 1749 dwStreamNumber: DWORD, 1750 dwReserved: DWORD, 1751 hSourceFile: HANDLE, 1752 hDestinationFile: HANDLE, 1753 uliStreamSize: ULARGE_INTEGER, 1754 uliStreamBytesTransferred: ULARGE_INTEGER, 1755 uliTotalFileSize: ULARGE_INTEGER, 1756 uliTotalBytesTransferred: ULARGE_INTEGER, 1757 }} 1758 STRUCT!{struct COPYFILE2_MESSAGE_PollContinue { 1759 dwReserved: DWORD, 1760 }} 1761 STRUCT!{struct COPYFILE2_MESSAGE_Error { 1762 CopyPhase: COPYFILE2_COPY_PHASE, 1763 dwStreamNumber: DWORD, 1764 hrFailure: HRESULT, 1765 dwReserved: DWORD, 1766 uliChunkNumber: ULARGE_INTEGER, 1767 uliStreamSize: ULARGE_INTEGER, 1768 uliStreamBytesTransferred: ULARGE_INTEGER, 1769 uliTotalFileSize: ULARGE_INTEGER, 1770 uliTotalBytesTransferred: ULARGE_INTEGER, 1771 }} 1772 UNION!{union COPYFILE2_MESSAGE_Info { 1773 [u64; 8] [u64; 9], 1774 ChunkStarted ChunkStarted_mut: COPYFILE2_MESSAGE_ChunkStarted, 1775 ChunkFinished ChunkFinished_mut: COPYFILE2_MESSAGE_ChunkFinished, 1776 StreamStarted StreamStarted_mut: COPYFILE2_MESSAGE_StreamStarted, 1777 StreamFinished StreamFinished_mut: COPYFILE2_MESSAGE_StreamFinished, 1778 PollContinue PollContinue_mut: COPYFILE2_MESSAGE_PollContinue, 1779 Error Error_mut: COPYFILE2_MESSAGE_Error, 1780 }} 1781 STRUCT!{struct COPYFILE2_MESSAGE { 1782 Type: COPYFILE2_MESSAGE_TYPE, 1783 dwPadding: DWORD, 1784 Info: COPYFILE2_MESSAGE_Info, 1785 }} 1786 FN!{stdcall PCOPYFILE2_PROGRESS_ROUTINE( 1787 pMessage: *const COPYFILE2_MESSAGE, 1788 pvCallbackContext: PVOID, 1789 ) -> COPYFILE2_MESSAGE_ACTION} 1790 STRUCT!{struct COPYFILE2_EXTENDED_PARAMETERS { 1791 dwSize: DWORD, 1792 dwCopyFlags: DWORD, 1793 pfCancel: *mut BOOL, 1794 pProgressRoutine: PCOPYFILE2_PROGRESS_ROUTINE, 1795 pvCallbackContext: PVOID, 1796 }} 1797 extern "system" { CopyFile2( pwszExistingFileName: PCWSTR, pwszNewFileName: PCWSTR, pExtendedParameters: *mut COPYFILE2_EXTENDED_PARAMETERS, ) -> HRESULT1798 pub fn CopyFile2( 1799 pwszExistingFileName: PCWSTR, 1800 pwszNewFileName: PCWSTR, 1801 pExtendedParameters: *mut COPYFILE2_EXTENDED_PARAMETERS, 1802 ) -> HRESULT; MoveFileA( lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR ) -> BOOL1803 pub fn MoveFileA( 1804 lpExistingFileName: LPCSTR, 1805 lpNewFileName: LPCSTR 1806 ) -> BOOL; MoveFileW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR ) -> BOOL1807 pub fn MoveFileW( 1808 lpExistingFileName: LPCWSTR, 1809 lpNewFileName: LPCWSTR 1810 ) -> BOOL; MoveFileExA( lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, dwFlags: DWORD ) -> BOOL1811 pub fn MoveFileExA( 1812 lpExistingFileName: LPCSTR, 1813 lpNewFileName: LPCSTR, 1814 dwFlags: DWORD 1815 ) -> BOOL; MoveFileExW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, dwFlags: DWORD ) -> BOOL1816 pub fn MoveFileExW( 1817 lpExistingFileName: LPCWSTR, 1818 lpNewFileName: LPCWSTR, 1819 dwFlags: DWORD 1820 ) -> BOOL; MoveFileWithProgressA( lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD, ) -> BOOL1821 pub fn MoveFileWithProgressA( 1822 lpExistingFileName: LPCSTR, 1823 lpNewFileName: LPCSTR, 1824 lpProgressRoutine: LPPROGRESS_ROUTINE, 1825 lpData: LPVOID, 1826 dwFlags: DWORD, 1827 ) -> BOOL; MoveFileWithProgressW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD, ) -> BOOL1828 pub fn MoveFileWithProgressW( 1829 lpExistingFileName: LPCWSTR, 1830 lpNewFileName: LPCWSTR, 1831 lpProgressRoutine: LPPROGRESS_ROUTINE, 1832 lpData: LPVOID, 1833 dwFlags: DWORD, 1834 ) -> BOOL; MoveFileTransactedA( lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD, hTransaction: HANDLE, ) -> BOOL1835 pub fn MoveFileTransactedA( 1836 lpExistingFileName: LPCSTR, 1837 lpNewFileName: LPCSTR, 1838 lpProgressRoutine: LPPROGRESS_ROUTINE, 1839 lpData: LPVOID, 1840 dwFlags: DWORD, 1841 hTransaction: HANDLE, 1842 ) -> BOOL; MoveFileTransactedW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD, hTransaction: HANDLE, ) -> BOOL1843 pub fn MoveFileTransactedW( 1844 lpExistingFileName: LPCWSTR, 1845 lpNewFileName: LPCWSTR, 1846 lpProgressRoutine: LPPROGRESS_ROUTINE, 1847 lpData: LPVOID, 1848 dwFlags: DWORD, 1849 hTransaction: HANDLE, 1850 ) -> BOOL; 1851 } 1852 pub const MOVEFILE_REPLACE_EXISTING: DWORD = 0x00000001; 1853 pub const MOVEFILE_COPY_ALLOWED: DWORD = 0x00000002; 1854 pub const MOVEFILE_DELAY_UNTIL_REBOOT: DWORD = 0x00000004; 1855 pub const MOVEFILE_WRITE_THROUGH: DWORD = 0x00000008; 1856 pub const MOVEFILE_CREATE_HARDLINK: DWORD = 0x00000010; 1857 pub const MOVEFILE_FAIL_IF_NOT_TRACKABLE: DWORD = 0x00000020; 1858 extern "system" { ReplaceFileA( lpReplacedFileName: LPCSTR, lpReplacementFileName: LPCSTR, lpBackupFileName: LPCSTR, dwReplaceFlags: DWORD, lpExclude: LPVOID, lpReserved: LPVOID, )1859 pub fn ReplaceFileA( 1860 lpReplacedFileName: LPCSTR, 1861 lpReplacementFileName: LPCSTR, 1862 lpBackupFileName: LPCSTR, 1863 dwReplaceFlags: DWORD, 1864 lpExclude: LPVOID, 1865 lpReserved: LPVOID, 1866 ); ReplaceFileW( lpReplacedFileName: LPCWSTR, lpReplacementFileName: LPCWSTR, lpBackupFileName: LPCWSTR, dwReplaceFlags: DWORD, lpExclude: LPVOID, lpReserved: LPVOID, )1867 pub fn ReplaceFileW( 1868 lpReplacedFileName: LPCWSTR, 1869 lpReplacementFileName: LPCWSTR, 1870 lpBackupFileName: LPCWSTR, 1871 dwReplaceFlags: DWORD, 1872 lpExclude: LPVOID, 1873 lpReserved: LPVOID, 1874 ); CreateHardLinkA( lpFileName: LPCSTR, lpExistingFileName: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> BOOL1875 pub fn CreateHardLinkA( 1876 lpFileName: LPCSTR, 1877 lpExistingFileName: LPCSTR, 1878 lpSecurityAttributes: LPSECURITY_ATTRIBUTES, 1879 ) -> BOOL; CreateHardLinkW( lpFileName: LPCWSTR, lpExistingFileName: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> BOOL1880 pub fn CreateHardLinkW( 1881 lpFileName: LPCWSTR, 1882 lpExistingFileName: LPCWSTR, 1883 lpSecurityAttributes: LPSECURITY_ATTRIBUTES, 1884 ) -> BOOL; CreateHardLinkTransactedA( lpFileName: LPCSTR, lpExistingFileName: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE, ) -> BOOL1885 pub fn CreateHardLinkTransactedA( 1886 lpFileName: LPCSTR, 1887 lpExistingFileName: LPCSTR, 1888 lpSecurityAttributes: LPSECURITY_ATTRIBUTES, 1889 hTransaction: HANDLE, 1890 ) -> BOOL; CreateHardLinkTransactedW( lpFileName: LPCWSTR, lpExistingFileName: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE, )1891 pub fn CreateHardLinkTransactedW( 1892 lpFileName: LPCWSTR, 1893 lpExistingFileName: LPCWSTR, 1894 lpSecurityAttributes: LPSECURITY_ATTRIBUTES, 1895 hTransaction: HANDLE, 1896 ); FindFirstStreamTransactedW( lpFileName: LPCWSTR, InfoLevel: STREAM_INFO_LEVELS, lpFindStreamData: LPVOID, dwFlags: DWORD, hTransaction: HANDLE, ) -> HANDLE1897 pub fn FindFirstStreamTransactedW( 1898 lpFileName: LPCWSTR, 1899 InfoLevel: STREAM_INFO_LEVELS, 1900 lpFindStreamData: LPVOID, 1901 dwFlags: DWORD, 1902 hTransaction: HANDLE, 1903 ) -> HANDLE; FindFirstFileNameTransactedW( lpFileName: LPCWSTR, dwFlags: DWORD, StringLength: LPDWORD, LinkName: PWSTR, hTransaction: HANDLE, ) -> HANDLE1904 pub fn FindFirstFileNameTransactedW( 1905 lpFileName: LPCWSTR, 1906 dwFlags: DWORD, 1907 StringLength: LPDWORD, 1908 LinkName: PWSTR, 1909 hTransaction: HANDLE, 1910 ) -> HANDLE; CreateNamedPipeA( lpName: LPCSTR, dwOpenMode: DWORD, dwPipeMode: DWORD, nMaxInstances: DWORD, nOutBufferSize: DWORD, nInBufferSize: DWORD, nDefaultTimeOut: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> HANDLE1911 pub fn CreateNamedPipeA( 1912 lpName: LPCSTR, 1913 dwOpenMode: DWORD, 1914 dwPipeMode: DWORD, 1915 nMaxInstances: DWORD, 1916 nOutBufferSize: DWORD, 1917 nInBufferSize: DWORD, 1918 nDefaultTimeOut: DWORD, 1919 lpSecurityAttributes: LPSECURITY_ATTRIBUTES, 1920 ) -> HANDLE; GetNamedPipeHandleStateA( hNamedPipe: HANDLE, lpState: LPDWORD, lpCurInstances: LPDWORD, lpMaxCollectionCount: LPDWORD, lpCollectDataTimeout: LPDWORD, lpUserName: LPSTR, nMaxUserNameSize: DWORD, ) -> BOOL1921 pub fn GetNamedPipeHandleStateA( 1922 hNamedPipe: HANDLE, 1923 lpState: LPDWORD, 1924 lpCurInstances: LPDWORD, 1925 lpMaxCollectionCount: LPDWORD, 1926 lpCollectDataTimeout: LPDWORD, 1927 lpUserName: LPSTR, 1928 nMaxUserNameSize: DWORD, 1929 ) -> BOOL; CallNamedPipeA( lpNamedPipeName: LPCSTR, lpInBuffer: LPVOID, nInBufferSize: DWORD, lpOutBuffer: LPVOID, nOutBufferSize: DWORD, lpBytesRead: LPDWORD, nTimeOut: DWORD, ) -> BOOL1930 pub fn CallNamedPipeA( 1931 lpNamedPipeName: LPCSTR, 1932 lpInBuffer: LPVOID, 1933 nInBufferSize: DWORD, 1934 lpOutBuffer: LPVOID, 1935 nOutBufferSize: DWORD, 1936 lpBytesRead: LPDWORD, 1937 nTimeOut: DWORD, 1938 ) -> BOOL; WaitNamedPipeA( lpNamedPipeName: LPCSTR, nTimeOut: DWORD ) -> BOOL1939 pub fn WaitNamedPipeA( 1940 lpNamedPipeName: LPCSTR, 1941 nTimeOut: DWORD 1942 ) -> BOOL; GetNamedPipeClientComputerNameA( Pipe: HANDLE, ClientComputerName: LPSTR, ClientComputerNameLength: ULONG, ) -> BOOL1943 pub fn GetNamedPipeClientComputerNameA( 1944 Pipe: HANDLE, 1945 ClientComputerName: LPSTR, 1946 ClientComputerNameLength: ULONG, 1947 ) -> BOOL; GetNamedPipeClientProcessId( Pipe: HANDLE, ClientProcessId: PULONG ) -> BOOL1948 pub fn GetNamedPipeClientProcessId( 1949 Pipe: HANDLE, 1950 ClientProcessId: PULONG 1951 ) -> BOOL; GetNamedPipeClientSessionId( Pipe: HANDLE, ClientSessionId: PULONG ) -> BOOL1952 pub fn GetNamedPipeClientSessionId( 1953 Pipe: HANDLE, 1954 ClientSessionId: PULONG 1955 ) -> BOOL; GetNamedPipeServerProcessId( Pipe: HANDLE, ServerProcessId: PULONG ) -> BOOL1956 pub fn GetNamedPipeServerProcessId( 1957 Pipe: HANDLE, 1958 ServerProcessId: PULONG 1959 ) -> BOOL; GetNamedPipeServerSessionId( Pipe: HANDLE, ServerSessionId: PULONG ) -> BOOL1960 pub fn GetNamedPipeServerSessionId( 1961 Pipe: HANDLE, 1962 ServerSessionId: PULONG 1963 ) -> BOOL; SetVolumeLabelA( lpRootPathName: LPCSTR, lpVolumeName: LPCSTR ) -> BOOL1964 pub fn SetVolumeLabelA( 1965 lpRootPathName: LPCSTR, 1966 lpVolumeName: LPCSTR 1967 ) -> BOOL; SetVolumeLabelW( lpRootPathName: LPCWSTR, lpVolumeName: LPCWSTR ) -> BOOL1968 pub fn SetVolumeLabelW( 1969 lpRootPathName: LPCWSTR, 1970 lpVolumeName: LPCWSTR 1971 ) -> BOOL; SetFileBandwidthReservation( hFile: HANDLE, nPeriodMilliseconds: DWORD, nBytesPerPeriod: DWORD, bDiscardable: BOOL, lpTransferSize: LPDWORD, lpNumOutstandingRequests: LPDWORD, ) -> BOOL1972 pub fn SetFileBandwidthReservation( 1973 hFile: HANDLE, 1974 nPeriodMilliseconds: DWORD, 1975 nBytesPerPeriod: DWORD, 1976 bDiscardable: BOOL, 1977 lpTransferSize: LPDWORD, 1978 lpNumOutstandingRequests: LPDWORD, 1979 ) -> BOOL; GetFileBandwidthReservation( hFile: HANDLE, lpPeriodMilliseconds: LPDWORD, lpBytesPerPeriod: LPDWORD, pDiscardable: LPBOOL, lpTransferSize: LPDWORD, lpNumOutstandingRequests: LPDWORD, ) -> BOOL1980 pub fn GetFileBandwidthReservation( 1981 hFile: HANDLE, 1982 lpPeriodMilliseconds: LPDWORD, 1983 lpBytesPerPeriod: LPDWORD, 1984 pDiscardable: LPBOOL, 1985 lpTransferSize: LPDWORD, 1986 lpNumOutstandingRequests: LPDWORD, 1987 ) -> BOOL; 1988 // pub fn ClearEventLogA(); 1989 // pub fn ClearEventLogW(); 1990 // pub fn BackupEventLogA(); 1991 // pub fn BackupEventLogW(); 1992 // pub fn CloseEventLog(); DeregisterEventSource( hEventLog: HANDLE, ) -> BOOL1993 pub fn DeregisterEventSource( 1994 hEventLog: HANDLE, 1995 ) -> BOOL; 1996 // pub fn NotifyChangeEventLog(); 1997 // pub fn GetNumberOfEventLogRecords(); 1998 // pub fn GetOldestEventLogRecord(); 1999 // pub fn OpenEventLogA(); 2000 // pub fn OpenEventLogW(); RegisterEventSourceA( lpUNCServerName: LPCSTR, lpSourceName: LPCSTR, ) -> HANDLE2001 pub fn RegisterEventSourceA( 2002 lpUNCServerName: LPCSTR, 2003 lpSourceName: LPCSTR, 2004 ) -> HANDLE; RegisterEventSourceW( lpUNCServerName: LPCWSTR, lpSourceName: LPCWSTR, ) -> HANDLE2005