1 // Licensed under the Apache License, Version 2.0 2 // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license 3 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option. 4 // All files in the project carrying such notice may not be copied, modified, or distributed 5 // except according to those terms. 6 //! This module defines the 32-Bit Windows Base APIs 7 use ctypes::{c_char, c_int, c_long, c_void}; 8 use shared::basetsd::{ 9 DWORD64, DWORD_PTR, LONG_PTR, PDWORD64, PDWORD_PTR, PSIZE_T, PULONG_PTR, SIZE_T, UINT_PTR, 10 ULONG_PTR, 11 }; 12 use shared::guiddef::GUID; 13 use shared::minwindef::{ 14 ATOM, BOOL, BYTE, DWORD, FARPROC, FILETIME, HFILE, HGLOBAL, HLOCAL, HMODULE, HRSRC, LPBOOL, 15 LPBYTE, LPCVOID, LPDWORD, LPFILETIME, LPVOID, LPWORD, PBOOL, PDWORD, PUCHAR, PULONG, PUSHORT, 16 UCHAR, UINT, ULONG, USHORT, WORD, 17 }; 18 use shared::windef::HWND; 19 use um::cfgmgr32::MAX_PROFILE_LEN; 20 use um::fileapi::STREAM_INFO_LEVELS; 21 use um::libloaderapi::{ 22 ENUMRESLANGPROCA, ENUMRESLANGPROCW, ENUMRESNAMEPROCA, ENUMRESTYPEPROCA, ENUMRESTYPEPROCW, 23 }; 24 use um::minwinbase::{ 25 FILE_INFO_BY_HANDLE_CLASS, FINDEX_INFO_LEVELS, FINDEX_SEARCH_OPS, GET_FILEEX_INFO_LEVELS, 26 LPOVERLAPPED, LPOVERLAPPED_COMPLETION_ROUTINE, LPSECURITY_ATTRIBUTES, PREASON_CONTEXT, 27 }; 28 use um::processthreadsapi::{ 29 LPPROC_THREAD_ATTRIBUTE_LIST, LPSTARTUPINFOA, STARTUPINFOA, STARTUPINFOW, 30 }; 31 use um::winnt::{ 32 BOOLEAN, CHAR, DWORDLONG, EXECUTION_STATE, FILE_ID_128, HANDLE, HRESULT, INT, LANGID, 33 LARGE_INTEGER, LATENCY_TIME, LONG, LPCCH, LPCH, LPCSTR, LPCWSTR, LPOSVERSIONINFOEXA, 34 LPOSVERSIONINFOEXW, LPSTR, LPWSTR, MAXLONG, PBOOLEAN, PCONTEXT, PCWSTR, PFIRMWARE_TYPE, 35 PHANDLE, PIO_COUNTERS, PJOB_SET_ARRAY, PLUID, POWER_REQUEST_TYPE, PPERFORMANCE_DATA, 36 PPROCESSOR_NUMBER, PQUOTA_LIMITS, PRTL_UMS_SCHEDULER_ENTRY_POINT, 37 PSECURE_MEMORY_CACHE_CALLBACK, PSID, PSID_NAME_USE, PULONGLONG, PVOID, PWOW64_CONTEXT, 38 PWOW64_LDT_ENTRY, PWSTR, RTL_UMS_THREAD_INFO_CLASS, STATUS_ABANDONED_WAIT_0, STATUS_USER_APC, 39 STATUS_WAIT_0, SecurityAnonymous, SecurityDelegation, SecurityIdentification, 40 SecurityImpersonation, THREAD_BASE_PRIORITY_IDLE, THREAD_BASE_PRIORITY_LOWRT, 41 THREAD_BASE_PRIORITY_MAX, THREAD_BASE_PRIORITY_MIN, ULARGE_INTEGER, VOID, WAITORTIMERCALLBACK, 42 WCHAR, WOW64_CONTEXT, 43 }; 44 #[cfg(target_arch = "x86")] 45 use um::winnt::PLDT_ENTRY; 46 use vc::vadefs::va_list; 47 pub const FILE_BEGIN: DWORD = 0; 48 pub const FILE_CURRENT: DWORD = 1; 49 pub const FILE_END: DWORD = 2; 50 pub const WAIT_FAILED: DWORD = 0xFFFFFFFF; 51 pub const WAIT_OBJECT_0: DWORD = STATUS_WAIT_0 as u32; 52 pub const WAIT_ABANDONED: DWORD = STATUS_ABANDONED_WAIT_0 as u32; 53 pub const WAIT_ABANDONED_0: DWORD = STATUS_ABANDONED_WAIT_0 as u32; 54 pub const WAIT_IO_COMPLETION: DWORD = STATUS_USER_APC as u32; 55 pub const FILE_FLAG_WRITE_THROUGH: DWORD = 0x80000000; 56 pub const FILE_FLAG_OVERLAPPED: DWORD = 0x40000000; 57 pub const FILE_FLAG_NO_BUFFERING: DWORD = 0x20000000; 58 pub const FILE_FLAG_RANDOM_ACCESS: DWORD = 0x10000000; 59 pub const FILE_FLAG_SEQUENTIAL_SCAN: DWORD = 0x08000000; 60 pub const FILE_FLAG_DELETE_ON_CLOSE: DWORD = 0x04000000; 61 pub const FILE_FLAG_BACKUP_SEMANTICS: DWORD = 0x02000000; 62 pub const FILE_FLAG_POSIX_SEMANTICS: DWORD = 0x01000000; 63 pub const FILE_FLAG_SESSION_AWARE: DWORD = 0x00800000; 64 pub const FILE_FLAG_OPEN_REPARSE_POINT: DWORD = 0x00200000; 65 pub const FILE_FLAG_OPEN_NO_RECALL: DWORD = 0x00100000; 66 pub const FILE_FLAG_FIRST_PIPE_INSTANCE: DWORD = 0x00080000; 67 pub const FILE_FLAG_OPEN_REQUIRING_OPLOCK: DWORD = 0x00040000; 68 pub const PROGRESS_CONTINUE: DWORD = 0; 69 pub const PROGRESS_CANCEL: DWORD = 1; 70 pub const PROGRESS_STOP: DWORD = 2; 71 pub const PROGRESS_QUIET: DWORD = 3; 72 pub const CALLBACK_CHUNK_FINISHED: DWORD = 0x00000000; 73 pub const CALLBACK_STREAM_SWITCH: DWORD = 0x00000001; 74 pub const COPY_FILE_FAIL_IF_EXISTS: DWORD = 0x00000001; 75 pub const COPY_FILE_RESTARTABLE: DWORD = 0x00000002; 76 pub const COPY_FILE_OPEN_SOURCE_FOR_WRITE: DWORD = 0x00000004; 77 pub const COPY_FILE_ALLOW_DECRYPTED_DESTINATION: DWORD = 0x00000008; 78 pub const COPY_FILE_COPY_SYMLINK: DWORD = 0x00000800; 79 pub const COPY_FILE_NO_BUFFERING: DWORD = 0x00001000; 80 pub const COPY_FILE_REQUEST_SECURITY_PRIVILEGES: DWORD = 0x00002000; 81 pub const COPY_FILE_RESUME_FROM_PAUSE: DWORD = 0x00004000; 82 pub const COPY_FILE_NO_OFFLOAD: DWORD = 0x00040000; 83 pub const COPY_FILE_IGNORE_EDP_BLOCK: DWORD = 0x00400000; 84 pub const COPY_FILE_IGNORE_SOURCE_ENCRYPTION: DWORD = 0x00800000; 85 pub const REPLACEFILE_WRITE_THROUGH: DWORD = 0x00000001; 86 pub const REPLACEFILE_IGNORE_MERGE_ERRORS: DWORD = 0x00000002; 87 pub const REPLACEFILE_IGNORE_ACL_ERRORS: DWORD = 0x00000004; 88 pub const PIPE_ACCESS_INBOUND: DWORD = 0x00000001; 89 pub const PIPE_ACCESS_OUTBOUND: DWORD = 0x00000002; 90 pub const PIPE_ACCESS_DUPLEX: DWORD = 0x00000003; 91 pub const PIPE_CLIENT_END: DWORD = 0x00000000; 92 pub const PIPE_SERVER_END: DWORD = 0x00000001; 93 pub const PIPE_WAIT: DWORD = 0x00000000; 94 pub const PIPE_NOWAIT: DWORD = 0x00000001; 95 pub const PIPE_READMODE_BYTE: DWORD = 0x00000000; 96 pub const PIPE_READMODE_MESSAGE: DWORD = 0x00000002; 97 pub const PIPE_TYPE_BYTE: DWORD = 0x00000000; 98 pub const PIPE_TYPE_MESSAGE: DWORD = 0x00000004; 99 pub const PIPE_ACCEPT_REMOTE_CLIENTS: DWORD = 0x00000000; 100 pub const PIPE_REJECT_REMOTE_CLIENTS: DWORD = 0x00000008; 101 pub const PIPE_UNLIMITED_INSTANCES: DWORD = 255; 102 pub const SECURITY_ANONYMOUS: DWORD = SecurityAnonymous << 16; 103 pub const SECURITY_IDENTIFICATION: DWORD = SecurityIdentification << 16; 104 pub const SECURITY_IMPERSONATION: DWORD = SecurityImpersonation << 16; 105 pub const SECURITY_DELEGATION: DWORD = SecurityDelegation << 16; 106 pub const SECURITY_CONTEXT_TRACKING: DWORD = 0x00040000; 107 pub const SECURITY_EFFECTIVE_ONLY: DWORD = 0x00080000; 108 pub const SECURITY_SQOS_PRESENT: DWORD = 0x00100000; 109 pub const SECURITY_VALID_SQOS_FLAGS: DWORD = 0x001F0000; 110 FN!{stdcall PFIBER_START_ROUTINE( 111 lpFiberParameter: LPVOID, 112 ) -> ()} 113 pub type LPFIBER_START_ROUTINE = PFIBER_START_ROUTINE; 114 FN!{stdcall PFIBER_CALLOUT_ROUTINE( 115 lpParameter: LPVOID, 116 ) -> LPVOID} 117 // FAIL_FAST_* 118 #[cfg(target_arch = "x86")] 119 pub type LPLDT_ENTRY = PLDT_ENTRY; 120 #[cfg(not(target_arch = "x86"))] 121 pub type LPLDT_ENTRY = LPVOID; // TODO - fix this for 32-bit 122 //SP_SERIALCOMM 123 //PST_* 124 // PCF_* 125 // SP_* 126 // BAUD_* 127 // DATABITS_* 128 // STOPBITS_* 129 // PARITY_* 130 STRUCT!{struct COMMPROP { 131 wPacketLength: WORD, 132 wPacketVersion: WORD, 133 dwServiceMask: DWORD, 134 dwReserved1: DWORD, 135 dwMaxTxQueue: DWORD, 136 dwMaxRxQueue: DWORD, 137 dwMaxBaud: DWORD, 138 dwProvSubType: DWORD, 139 dwProvCapabilities: DWORD, 140 dwSettableParams: DWORD, 141 dwSettableBaud: DWORD, 142 wSettableData: WORD, 143 wSettableStopParity: WORD, 144 dwCurrentTxQueue: DWORD, 145 dwCurrentRxQueue: DWORD, 146 dwProvSpec1: DWORD, 147 dwProvSpec2: DWORD, 148 wcProvChar: [WCHAR; 1], 149 }} 150 pub type LPCOMMPROP = *mut COMMPROP; 151 STRUCT!{struct COMSTAT { 152 BitFields: DWORD, 153 cbInQue: DWORD, 154 cbOutQue: DWORD, 155 }} 156 BITFIELD!{COMSTAT BitFields: DWORD [ 157 fCtsHold set_fCtsHold[0..1], 158 fDsrHold set_fDsrHold[1..2], 159 fRlsdHold set_fRlsdHold[2..3], 160 fXoffHold set_fXoffHold[3..4], 161 fXoffSent set_fXoffSent[4..5], 162 fEof set_fEof[5..6], 163 fTxim set_fTxim[6..7], 164 fReserved set_fReserved[7..32], 165 ]} 166 pub type LPCOMSTAT = *mut COMSTAT; 167 pub const DTR_CONTROL_DISABLE: DWORD = 0x00; 168 pub const DTR_CONTROL_ENABLE: DWORD = 0x01; 169 pub const DTR_CONTROL_HANDSHAKE: DWORD = 0x02; 170 pub const RTS_CONTROL_DISABLE: DWORD = 0x00; 171 pub const RTS_CONTROL_ENABLE: DWORD = 0x01; 172 pub const RTS_CONTROL_HANDSHAKE: DWORD = 0x02; 173 pub const RTS_CONTROL_TOGGLE: DWORD = 0x03; 174 STRUCT!{struct DCB { 175 DCBlength: DWORD, 176 BaudRate: DWORD, 177 BitFields: DWORD, 178 wReserved: WORD, 179 XonLim: WORD, 180 XoffLim: WORD, 181 ByteSize: BYTE, 182 Parity: BYTE, 183 StopBits: BYTE, 184 XonChar: c_char, 185 XoffChar: c_char, 186 ErrorChar: c_char, 187 EofChar: c_char, 188 EvtChar: c_char, 189 wReserved1: WORD, 190 }} 191 BITFIELD!{DCB BitFields: DWORD [ 192 fBinary set_fBinary[0..1], 193 fParity set_fParity[1..2], 194 fOutxCtsFlow set_fOutxCtsFlow[2..3], 195 fOutxDsrFlow set_fOutxDsrFlow[3..4], 196 fDtrControl set_fDtrControl[4..6], 197 fDsrSensitivity set_fDsrSensitivity[6..7], 198 fTXContinueOnXoff set_fTXContinueOnXoff[7..8], 199 fOutX set_fOutX[8..9], 200 fInX set_fInX[9..10], 201 fErrorChar set_fErrorChar[10..11], 202 fNull set_fNull[11..12], 203 fRtsControl set_fRtsControl[12..14], 204 fAbortOnError set_fAbortOnError[14..15], 205 fDummy2 set_fDummy2[15..32], 206 ]} 207 pub type LPDCB = *mut DCB; 208 STRUCT!{struct COMMTIMEOUTS { 209 ReadIntervalTimeout: DWORD, 210 ReadTotalTimeoutMultiplier: DWORD, 211 ReadTotalTimeoutConstant: DWORD, 212 WriteTotalTimeoutMultiplier: DWORD, 213 WriteTotalTimeoutConstant: DWORD, 214 }} 215 pub type LPCOMMTIMEOUTS = *mut COMMTIMEOUTS; 216 STRUCT!{struct COMMCONFIG { 217 dwSize: DWORD, 218 wVersion: WORD, 219 wReserved: WORD, 220 dcb: DCB, 221 dwProviderSubType: DWORD, 222 dwProviderOffset: DWORD, 223 dwProviderSize: DWORD, 224 wcProviderData: [WCHAR; 1], 225 }} 226 pub type LPCOMMCONFIG = *mut COMMCONFIG; 227 pub const GMEM_FIXED: UINT = 0x0000; 228 pub const GMEM_MOVEABLE: UINT = 0x0002; 229 pub const GMEM_NOCOMPACT: UINT = 0x0010; 230 pub const GMEM_NODISCARD: UINT = 0x0020; 231 pub const GMEM_ZEROINIT: UINT = 0x0040; 232 pub const GMEM_MODIFY: UINT = 0x0080; 233 pub const GMEM_DISCARDABLE: UINT = 0x0100; 234 pub const GMEM_NOT_BANKED: UINT = 0x1000; 235 pub const GMEM_SHARE: UINT = 0x2000; 236 pub const GMEM_DDESHARE: UINT = 0x2000; 237 pub const GMEM_NOTIFY: UINT = 0x4000; 238 pub const GMEM_LOWER: UINT = GMEM_NOT_BANKED; 239 pub const GMEM_VALID_FLAGS: UINT = 0x7F72; 240 pub const GMEM_INVALID_HANDLE: UINT = 0x8000; 241 pub const GHND: UINT = GMEM_MOVEABLE | GMEM_ZEROINIT; 242 pub const GPTR: UINT = GMEM_FIXED | GMEM_ZEROINIT; 243 pub const GMEM_DISCARDED: UINT = 0x4000; 244 pub const GMEM_LOCKCOUNT: UINT = 0x00FF; 245 STRUCT!{struct MEMORYSTATUS { 246 dwLength: DWORD, 247 dwMemoryLoad: DWORD, 248 dwTotalPhys: SIZE_T, 249 dwAvailPhys: SIZE_T, 250 dwTotalPageFile: SIZE_T, 251 dwAvailPageFile: SIZE_T, 252 dwTotalVirtual: SIZE_T, 253 dwAvailVirtual: SIZE_T, 254 }} 255 pub type LPMEMORYSTATUS = *mut MEMORYSTATUS; 256 // NUMA_NO_PREFERRED_NODE 257 pub const DEBUG_PROCESS: DWORD = 0x00000001; 258 pub const DEBUG_ONLY_THIS_PROCESS: DWORD = 0x00000002; 259 pub const CREATE_SUSPENDED: DWORD = 0x00000004; 260 pub const DETACHED_PROCESS: DWORD = 0x00000008; 261 pub const CREATE_NEW_CONSOLE: DWORD = 0x00000010; 262 pub const NORMAL_PRIORITY_CLASS: DWORD = 0x00000020; 263 pub const IDLE_PRIORITY_CLASS: DWORD = 0x00000040; 264 pub const HIGH_PRIORITY_CLASS: DWORD = 0x00000080; 265 pub const REALTIME_PRIORITY_CLASS: DWORD = 0x00000100; 266 pub const CREATE_NEW_PROCESS_GROUP: DWORD = 0x00000200; 267 pub const CREATE_UNICODE_ENVIRONMENT: DWORD = 0x00000400; 268 pub const CREATE_SEPARATE_WOW_VDM: DWORD = 0x00000800; 269 pub const CREATE_SHARED_WOW_VDM: DWORD = 0x00001000; 270 pub const CREATE_FORCEDOS: DWORD = 0x00002000; 271 pub const BELOW_NORMAL_PRIORITY_CLASS: DWORD = 0x00004000; 272 pub const ABOVE_NORMAL_PRIORITY_CLASS: DWORD = 0x00008000; 273 pub const INHERIT_PARENT_AFFINITY: DWORD = 0x00010000; 274 pub const INHERIT_CALLER_PRIORITY: DWORD = 0x00020000; 275 pub const CREATE_PROTECTED_PROCESS: DWORD = 0x00040000; 276 pub const EXTENDED_STARTUPINFO_PRESENT: DWORD = 0x00080000; 277 pub const PROCESS_MODE_BACKGROUND_BEGIN: DWORD = 0x00100000; 278 pub const PROCESS_MODE_BACKGROUND_END: DWORD = 0x00200000; 279 pub const CREATE_BREAKAWAY_FROM_JOB: DWORD = 0x01000000; 280 pub const CREATE_PRESERVE_CODE_AUTHZ_LEVEL: DWORD = 0x02000000; 281 pub const CREATE_DEFAULT_ERROR_MODE: DWORD = 0x04000000; 282 pub const CREATE_NO_WINDOW: DWORD = 0x08000000; 283 pub const PROFILE_USER: DWORD = 0x10000000; 284 pub const PROFILE_KERNEL: DWORD = 0x20000000; 285 pub const PROFILE_SERVER: DWORD = 0x40000000; 286 pub const CREATE_IGNORE_SYSTEM_DEFAULT: DWORD = 0x80000000; 287 // STACK_SIZE_PARAM_IS_A_RESERVATION 288 pub const THREAD_PRIORITY_LOWEST: DWORD = THREAD_BASE_PRIORITY_MIN; 289 pub const THREAD_PRIORITY_BELOW_NORMAL: DWORD = THREAD_PRIORITY_LOWEST + 1; 290 pub const THREAD_PRIORITY_NORMAL: DWORD = 0; 291 pub const THREAD_PRIORITY_HIGHEST: DWORD = THREAD_BASE_PRIORITY_MAX; 292 pub const THREAD_PRIORITY_ABOVE_NORMAL: DWORD = THREAD_PRIORITY_HIGHEST - 1; 293 pub const THREAD_PRIORITY_ERROR_RETURN: DWORD = MAXLONG as u32; 294 pub const THREAD_PRIORITY_TIME_CRITICAL: DWORD = THREAD_BASE_PRIORITY_LOWRT; 295 pub const THREAD_PRIORITY_IDLE: DWORD = THREAD_BASE_PRIORITY_IDLE; 296 pub const THREAD_MODE_BACKGROUND_BEGIN: DWORD = 0x00010000; 297 pub const THREAD_MODE_BACKGROUND_END: DWORD = 0x00020000; 298 pub const VOLUME_NAME_DOS: DWORD = 0x0; 299 // VOLUME_NAME_* 300 // FILE_NAME_* 301 // JIT_DEBUG_* 302 pub const DRIVE_UNKNOWN: DWORD = 0; 303 pub const DRIVE_NO_ROOT_DIR: DWORD = 1; 304 pub const DRIVE_REMOVABLE: DWORD = 2; 305 pub const DRIVE_FIXED: DWORD = 3; 306 pub const DRIVE_REMOTE: DWORD = 4; 307 pub const DRIVE_CDROM: DWORD = 5; 308 pub const DRIVE_RAMDISK: DWORD = 6; 309 // pub fn GetFreeSpace(); 310 pub const FILE_TYPE_UNKNOWN: DWORD = 0x0000; 311 pub const FILE_TYPE_DISK: DWORD = 0x0001; 312 pub const FILE_TYPE_CHAR: DWORD = 0x0002; 313 pub const FILE_TYPE_PIPE: DWORD = 0x0003; 314 pub const FILE_TYPE_REMOTE: DWORD = 0x8000; 315 pub const STD_INPUT_HANDLE: DWORD = -10i32 as u32; 316 pub const STD_OUTPUT_HANDLE: DWORD = -11i32 as u32; 317 pub const STD_ERROR_HANDLE: DWORD = -12i32 as u32; 318 pub const NOPARITY: BYTE = 0; 319 pub const ODDPARITY: BYTE = 1; 320 pub const EVENPARITY: BYTE = 2; 321 pub const MARKPARITY: BYTE = 3; 322 pub const SPACEPARITY: BYTE = 4; 323 pub const ONESTOPBIT: BYTE = 0; 324 pub const ONE5STOPBITS: BYTE = 1; 325 pub const TWOSTOPBITS: BYTE = 2; 326 pub const IGNORE: DWORD = 0; 327 pub const INFINITE: DWORD = 0xFFFFFFFF; 328 pub const CBR_110: DWORD = 110; 329 pub const CBR_300: DWORD = 300; 330 pub const CBR_600: DWORD = 600; 331 pub const CBR_1200: DWORD = 1200; 332 pub const CBR_2400: DWORD = 2400; 333 pub const CBR_4800: DWORD = 4800; 334 pub const CBR_9600: DWORD = 9600; 335 pub const CBR_14400: DWORD = 14400; 336 pub const CBR_19200: DWORD = 19200; 337 pub const CBR_38400: DWORD = 38400; 338 pub const CBR_56000: DWORD = 56000; 339 pub const CBR_57600: DWORD = 57600; 340 pub const CBR_115200: DWORD = 115200; 341 pub const CBR_128000: DWORD = 128000; 342 pub const CBR_256000: DWORD = 256000; 343 // CE_* 344 // IE_* 345 // EV_* 346 pub const SETXOFF: DWORD = 1; 347 pub const SETXON: DWORD = 2; 348 pub const SETRTS: DWORD = 3; 349 pub const CLRRTS: DWORD = 4; 350 pub const SETDTR: DWORD = 5; 351 pub const CLRDTR: DWORD = 6; 352 pub const RESETDEV: DWORD = 7; 353 pub const SETBREAK: DWORD = 8; 354 pub const CLRBREAK: DWORD = 9; 355 pub const PURGE_TXABORT: DWORD = 0x0001; 356 pub const PURGE_RXABORT: DWORD = 0x0002; 357 pub const PURGE_TXCLEAR: DWORD = 0x0004; 358 pub const PURGE_RXCLEAR: DWORD = 0x0008; 359 pub const MS_CTS_ON: DWORD = 0x0010; 360 pub const MS_DSR_ON: DWORD = 0x0020; 361 pub const MS_RING_ON: DWORD = 0x0040; 362 pub const MS_RLSD_ON: DWORD = 0x0080; 363 // S_* 364 // NMPWAIT_* 365 // FS_* 366 // OF_* 367 pub const OFS_MAXPATHNAME: usize = 128; 368 STRUCT!{struct OFSTRUCT { 369 cBytes: BYTE, 370 fFixedDisk: BYTE, 371 nErrCode: WORD, 372 Reserved1: WORD, 373 Reserved2: WORD, 374 szPathName: [CHAR; OFS_MAXPATHNAME], 375 }} 376 pub type POFSTRUCT = *mut OFSTRUCT; 377 pub type LPOFSTRUCT = *mut OFSTRUCT; 378 extern "system" { GlobalAlloc( uFlags: UINT, dwBytes: SIZE_T, ) -> HGLOBAL379 pub fn GlobalAlloc( 380 uFlags: UINT, 381 dwBytes: SIZE_T, 382 ) -> HGLOBAL; GlobalReAlloc( hMem: HGLOBAL, dwBytes: SIZE_T, uFlags: UINT, ) -> HGLOBAL383 pub fn GlobalReAlloc( 384 hMem: HGLOBAL, 385 dwBytes: SIZE_T, 386 uFlags: UINT, 387 ) -> HGLOBAL; GlobalSize( hMem: HGLOBAL, ) -> SIZE_T388 pub fn GlobalSize( 389 hMem: HGLOBAL, 390 ) -> SIZE_T; GlobalFlags( hMem: HGLOBAL, ) -> UINT391 pub fn GlobalFlags( 392 hMem: HGLOBAL, 393 ) -> UINT; GlobalLock( hMem: HGLOBAL, ) -> LPVOID394 pub fn GlobalLock( 395 hMem: HGLOBAL, 396 ) -> LPVOID; GlobalHandle( pMem: LPCVOID, ) -> HGLOBAL397 pub fn GlobalHandle( 398 pMem: LPCVOID, 399 ) -> HGLOBAL; GlobalUnlock( hMem: HGLOBAL, ) -> BOOL400 pub fn GlobalUnlock( 401 hMem: HGLOBAL, 402 ) -> BOOL; GlobalFree( hMem: HGLOBAL, ) -> HGLOBAL403 pub fn GlobalFree( 404 hMem: HGLOBAL, 405 ) -> HGLOBAL; GlobalCompact( dwMinFree: DWORD, ) -> SIZE_T406 pub fn GlobalCompact( 407 dwMinFree: DWORD, 408 ) -> SIZE_T; GlobalFix( hMem: HGLOBAL, )409 pub fn GlobalFix( 410 hMem: HGLOBAL, 411 ); GlobalUnfix( hMem: HGLOBAL, )412 pub fn GlobalUnfix( 413 hMem: HGLOBAL, 414 ); GlobalWire( hMem: HGLOBAL, ) -> LPVOID415 pub fn GlobalWire( 416 hMem: HGLOBAL, 417 ) -> LPVOID; GlobalUnWire( hMem: HGLOBAL, ) -> BOOL418 pub fn GlobalUnWire( 419 hMem: HGLOBAL, 420 ) -> BOOL; GlobalMemoryStatus( lpBuffer: LPMEMORYSTATUS, )421 pub fn GlobalMemoryStatus( 422 lpBuffer: LPMEMORYSTATUS, 423 ); LocalAlloc( uFlags: UINT, uBytes: SIZE_T, ) -> HLOCAL424 pub fn LocalAlloc( 425 uFlags: UINT, 426 uBytes: SIZE_T, 427 ) -> HLOCAL; LocalReAlloc( hMem: HLOCAL, uBytes: SIZE_T, uFlags: UINT, ) -> HLOCAL428 pub fn LocalReAlloc( 429 hMem: HLOCAL, 430 uBytes: SIZE_T, 431 uFlags: UINT, 432 ) -> HLOCAL; LocalLock( hMem: HLOCAL, ) -> LPVOID433 pub fn LocalLock( 434 hMem: HLOCAL, 435 ) -> LPVOID; LocalHandle( pMem: LPCVOID, ) -> HLOCAL436 pub fn LocalHandle( 437 pMem: LPCVOID, 438 ) -> HLOCAL; LocalUnlock( hMem: HLOCAL, ) -> BOOL439 pub fn LocalUnlock( 440 hMem: HLOCAL, 441 ) -> BOOL; LocalSize( hMem: HLOCAL, ) -> SIZE_T442 pub fn LocalSize( 443 hMem: HLOCAL, 444 ) -> SIZE_T; LocalFlags( hMem: HLOCAL, ) -> UINT445 pub fn LocalFlags( 446 hMem: HLOCAL, 447 ) -> UINT; LocalFree( hMem: HLOCAL, ) -> HLOCAL448 pub fn LocalFree( 449 hMem: HLOCAL, 450 ) -> HLOCAL; LocalShrink( hMem: HLOCAL, cbNewSize: UINT, ) -> SIZE_T451 pub fn LocalShrink( 452 hMem: HLOCAL, 453 cbNewSize: UINT, 454 ) -> SIZE_T; LocalCompact( uMinFree: UINT, ) -> SIZE_T455 pub fn LocalCompact( 456 uMinFree: UINT, 457 ) -> SIZE_T; 458 } 459 // SCS_* 460 extern "system" { GetBinaryTypeA( lpApplicationName: LPCSTR, lpBinaryType: LPDWORD, ) -> BOOL461 pub fn GetBinaryTypeA( 462 lpApplicationName: LPCSTR, 463 lpBinaryType: LPDWORD, 464 ) -> BOOL; GetBinaryTypeW( lpApplicationName: LPCWSTR, lpBinaryType: LPDWORD, ) -> BOOL465 pub fn GetBinaryTypeW( 466 lpApplicationName: LPCWSTR, 467 lpBinaryType: LPDWORD, 468 ) -> BOOL; GetShortPathNameA( lpszLongPath: LPCSTR, lpszShortPath: LPSTR, cchBuffer: DWORD, ) -> DWORD469 pub fn GetShortPathNameA( 470 lpszLongPath: LPCSTR, 471 lpszShortPath: LPSTR, 472 cchBuffer: DWORD, 473 ) -> DWORD; GetLongPathNameTransactedA( lpszShortPath: LPCSTR, lpszLongPath: LPSTR, cchBuffer: DWORD, hTransaction: HANDLE, ) -> DWORD474 pub fn GetLongPathNameTransactedA( 475 lpszShortPath: LPCSTR, 476 lpszLongPath: LPSTR, 477 cchBuffer: DWORD, 478 hTransaction: HANDLE, 479 ) -> DWORD; GetLongPathNameTransactedW( lpszShortPath: LPCWSTR, lpszLongPath: LPWSTR, cchBuffer: DWORD, hTransaction: HANDLE, ) -> DWORD480 pub fn GetLongPathNameTransactedW( 481 lpszShortPath: LPCWSTR, 482 lpszLongPath: LPWSTR, 483 cchBuffer: DWORD, 484 hTransaction: HANDLE, 485 ) -> DWORD; GetProcessAffinityMask( hProcess: HANDLE, lpProcessAffinityMask: PDWORD_PTR, lpSystemAffinityMask: PDWORD_PTR, ) -> BOOL486 pub fn GetProcessAffinityMask( 487 hProcess: HANDLE, 488 lpProcessAffinityMask: PDWORD_PTR, 489 lpSystemAffinityMask: PDWORD_PTR, 490 ) -> BOOL; SetProcessAffinityMask( hProcess: HANDLE, dwProcessAffinityMask: DWORD, ) -> BOOL491 pub fn SetProcessAffinityMask( 492 hProcess: HANDLE, 493 dwProcessAffinityMask: DWORD, 494 ) -> BOOL; GetProcessIoCounters( hProcess: HANDLE, lpIoCounters: PIO_COUNTERS, ) -> BOOL495 pub fn GetProcessIoCounters( 496 hProcess: HANDLE, 497 lpIoCounters: PIO_COUNTERS, 498 ) -> BOOL; GetProcessWorkingSetSize( hProcess: HANDLE, lpMinimumWorkingSetSize: PSIZE_T, lpMaximumWorkingSetSize: PSIZE_T, ) -> BOOL499 pub fn GetProcessWorkingSetSize( 500 hProcess: HANDLE, 501 lpMinimumWorkingSetSize: PSIZE_T, 502 lpMaximumWorkingSetSize: PSIZE_T, 503 ) -> BOOL; SetProcessWorkingSetSize( hProcess: HANDLE, dwMinimumWorkingSetSize: SIZE_T, dwMaximumWorkingSetSize: SIZE_T, ) -> BOOL504 pub fn SetProcessWorkingSetSize( 505 hProcess: HANDLE, 506 dwMinimumWorkingSetSize: SIZE_T, 507 dwMaximumWorkingSetSize: SIZE_T, 508 ) -> BOOL; FatalExit( ExitCode: c_int, )509 pub fn FatalExit( 510 ExitCode: c_int, 511 ); SetEnvironmentStringsA( NewEnvironment: LPCH, ) -> BOOL512 pub fn SetEnvironmentStringsA( 513 NewEnvironment: LPCH, 514 ) -> BOOL; SwitchToFiber( lpFiber: LPVOID, )515 pub fn SwitchToFiber( 516 lpFiber: LPVOID, 517 ); DeleteFiber( lpFiber: LPVOID, )518 pub fn DeleteFiber( 519 lpFiber: LPVOID, 520 ); ConvertFiberToThread() -> BOOL521 pub fn ConvertFiberToThread() -> BOOL; CreateFiberEx( dwStackCommitSize: SIZE_T, dwStackReserveSize: SIZE_T, dwFlags: DWORD, lpStartAddress: LPFIBER_START_ROUTINE, lpParameter: LPVOID, ) -> LPVOID522 pub fn CreateFiberEx( 523 dwStackCommitSize: SIZE_T, 524 dwStackReserveSize: SIZE_T, 525 dwFlags: DWORD, 526 lpStartAddress: LPFIBER_START_ROUTINE, 527 lpParameter: LPVOID, 528 ) -> LPVOID; ConvertThreadToFiberEx( lpParameter: LPVOID, dwFlags: DWORD, ) -> LPVOID529 pub fn ConvertThreadToFiberEx( 530 lpParameter: LPVOID, 531 dwFlags: DWORD, 532 ) -> LPVOID; CreateFiber( dwStackSize: SIZE_T, lpStartAddress: LPFIBER_START_ROUTINE, lpParameter: LPVOID, ) -> LPVOID533 pub fn CreateFiber( 534 dwStackSize: SIZE_T, 535 lpStartAddress: LPFIBER_START_ROUTINE, 536 lpParameter: LPVOID, 537 ) -> LPVOID; ConvertThreadToFiber( lpParameter: LPVOID, ) -> LPVOID538 pub fn ConvertThreadToFiber( 539 lpParameter: LPVOID, 540 ) -> LPVOID; 541 } 542 pub type PUMS_CONTEXT = *mut c_void; 543 pub type PUMS_COMPLETION_LIST = *mut c_void; 544 pub type UMS_THREAD_INFO_CLASS = RTL_UMS_THREAD_INFO_CLASS; 545 pub type PUMS_THREAD_INFO_CLASS = *mut UMS_THREAD_INFO_CLASS; 546 pub type PUMS_SCHEDULER_ENTRY_POINT = PRTL_UMS_SCHEDULER_ENTRY_POINT; 547 STRUCT!{struct UMS_SCHEDULER_STARTUP_INFO { 548 UmsVersion: ULONG, 549 CompletionList: PUMS_COMPLETION_LIST, 550 SchedulerProc: PUMS_SCHEDULER_ENTRY_POINT, 551 SchedulerParam: PVOID, 552 }} 553 pub type PUMS_SCHEDULER_STARTUP_INFO = *mut UMS_SCHEDULER_STARTUP_INFO; 554 STRUCT!{struct UMS_SYSTEM_THREAD_INFORMATION { 555 UmsVersion: ULONG, 556 ThreadUmsFlags: ULONG, 557 }} 558 BITFIELD!{UMS_SYSTEM_THREAD_INFORMATION ThreadUmsFlags: ULONG [ 559 IsUmsSchedulerThread set_IsUmsSchedulerThread[0..1], 560 IsUmsWorkerThread set_IsUmsWorkerThread[1..2], 561 ]} 562 pub type PUMS_SYSTEM_THREAD_INFORMATION = *mut UMS_SYSTEM_THREAD_INFORMATION; 563 extern "system" { 564 #[cfg(target_pointer_width = "64")] CreateUmsCompletionList( UmsCompletionList: *mut PUMS_COMPLETION_LIST, ) -> BOOL565 pub fn CreateUmsCompletionList( 566 UmsCompletionList: *mut PUMS_COMPLETION_LIST, 567 ) -> BOOL; 568 #[cfg(target_pointer_width = "64")] DequeueUmsCompletionListItems( UmsCompletionList: PUMS_COMPLETION_LIST, WaitTimeOut: DWORD, UmsThreadList: *mut PUMS_CONTEXT, ) -> BOOL569 pub fn DequeueUmsCompletionListItems( 570 UmsCompletionList: PUMS_COMPLETION_LIST, 571 WaitTimeOut: DWORD, 572 UmsThreadList: *mut PUMS_CONTEXT, 573 ) -> BOOL; 574 #[cfg(target_pointer_width = "64")] GetUmsCompletionListEvent( UmsCompletionList: PUMS_COMPLETION_LIST, UmsCompletionEvent: PHANDLE, ) -> BOOL575 pub fn GetUmsCompletionListEvent( 576 UmsCompletionList: PUMS_COMPLETION_LIST, 577 UmsCompletionEvent: PHANDLE, 578 ) -> BOOL; 579 #[cfg(target_pointer_width = "64")] ExecuteUmsThread( UmsThread: PUMS_CONTEXT, ) -> BOOL580 pub fn ExecuteUmsThread( 581 UmsThread: PUMS_CONTEXT, 582 ) -> BOOL; 583 #[cfg(target_pointer_width = "64")] UmsThreadYield( SchedulerParam: PVOID, ) -> BOOL584 pub fn UmsThreadYield( 585 SchedulerParam: PVOID, 586 ) -> BOOL; 587 #[cfg(target_pointer_width = "64")] DeleteUmsCompletionList( UmsCompletionList: PUMS_COMPLETION_LIST, ) -> BOOL588 pub fn DeleteUmsCompletionList( 589 UmsCompletionList: PUMS_COMPLETION_LIST, 590 ) -> BOOL; 591 #[cfg(target_pointer_width = "64")] GetCurrentUmsThread() -> PUMS_CONTEXT592 pub fn GetCurrentUmsThread() -> PUMS_CONTEXT; 593 #[cfg(target_pointer_width = "64")] GetNextUmsListItem( UmsContext: PUMS_CONTEXT, ) -> PUMS_CONTEXT594 pub fn GetNextUmsListItem( 595 UmsContext: PUMS_CONTEXT, 596 ) -> PUMS_CONTEXT; 597 #[cfg(target_pointer_width = "64")] QueryUmsThreadInformation( UmsThread: PUMS_CONTEXT, UmsThreadInfoClass: UMS_THREAD_INFO_CLASS, UmsThreadInformation: PVOID, UmsThreadInformationLength: ULONG, ReturnLength: PULONG, ) -> BOOL598 pub fn QueryUmsThreadInformation( 599 UmsThread: PUMS_CONTEXT, 600 UmsThreadInfoClass: UMS_THREAD_INFO_CLASS, 601 UmsThreadInformation: PVOID, 602 UmsThreadInformationLength: ULONG, 603 ReturnLength: PULONG, 604 ) -> BOOL; 605 #[cfg(target_pointer_width = "64")] SetUmsThreadInformation( UmsThread: PUMS_CONTEXT, UmsThreadInfoClass: UMS_THREAD_INFO_CLASS, UmsThreadInformation: PVOID, UmsThreadInformationLength: ULONG, ) -> BOOL606 pub fn SetUmsThreadInformation( 607 UmsThread: PUMS_CONTEXT, 608 UmsThreadInfoClass: UMS_THREAD_INFO_CLASS, 609 UmsThreadInformation: PVOID, 610 UmsThreadInformationLength: ULONG, 611 ) -> BOOL; 612 #[cfg(target_pointer_width = "64")] DeleteUmsThreadContext( UmsThread: PUMS_CONTEXT, ) -> BOOL613 pub fn DeleteUmsThreadContext( 614 UmsThread: PUMS_CONTEXT, 615 ) -> BOOL; 616 #[cfg(target_pointer_width = "64")] CreateUmsThreadContext( lpUmsThread: *mut PUMS_CONTEXT, ) -> BOOL617 pub fn CreateUmsThreadContext( 618 lpUmsThread: *mut PUMS_CONTEXT, 619 ) -> BOOL; 620 #[cfg(target_pointer_width = "64")] EnterUmsSchedulingMode( SchedulerStartupInfo: PUMS_SCHEDULER_STARTUP_INFO, ) -> BOOL621 pub fn EnterUmsSchedulingMode( 622 SchedulerStartupInfo: PUMS_SCHEDULER_STARTUP_INFO, 623 ) -> BOOL; 624 #[cfg(target_pointer_width = "64")] GetUmsSystemThreadInformation( ThreadHandle: HANDLE, SystemThreadInfo: PUMS_SYSTEM_THREAD_INFORMATION, ) -> BOOL625 pub fn GetUmsSystemThreadInformation( 626 ThreadHandle: HANDLE, 627 SystemThreadInfo: PUMS_SYSTEM_THREAD_INFORMATION, 628 ) -> BOOL; SetThreadAffinityMask( hThread: HANDLE, dwThreadAffinityMask: DWORD_PTR, ) -> DWORD_PTR629 pub fn SetThreadAffinityMask( 630 hThread: HANDLE, 631 dwThreadAffinityMask: DWORD_PTR, 632 ) -> DWORD_PTR; SetProcessDEPPolicy( dwFlags: DWORD, ) -> BOOL633 pub fn SetProcessDEPPolicy( 634 dwFlags: DWORD, 635 ) -> BOOL; GetProcessDEPPolicy( hProcess: HANDLE, lpFlags: LPDWORD, lpPermanent: PBOOL, ) -> BOOL636 pub fn GetProcessDEPPolicy( 637 hProcess: HANDLE, 638 lpFlags: LPDWORD, 639 lpPermanent: PBOOL, 640 ) -> BOOL; RequestWakeupLatency( latency: LATENCY_TIME, ) -> BOOL641 pub fn RequestWakeupLatency( 642 latency: LATENCY_TIME, 643 ) -> BOOL; IsSystemResumeAutomatic() -> BOOL644 pub fn IsSystemResumeAutomatic() -> BOOL; GetThreadSelectorEntry( hThread: HANDLE, dwSelector: DWORD, lpSelectorEntry: LPLDT_ENTRY, ) -> BOOL645 pub fn GetThreadSelectorEntry( 646 hThread: HANDLE, 647 dwSelector: DWORD, 648 lpSelectorEntry: LPLDT_ENTRY, 649 ) -> BOOL; SetThreadExecutionState( esFlags: EXECUTION_STATE, ) -> EXECUTION_STATE650 pub fn SetThreadExecutionState( 651 esFlags: EXECUTION_STATE, 652 ) -> EXECUTION_STATE; PowerCreateRequest( Context: PREASON_CONTEXT, ) -> HANDLE653 pub fn PowerCreateRequest( 654 Context: PREASON_CONTEXT, 655 ) -> HANDLE; PowerSetRequest( PowerRequest: HANDLE, RequestType: POWER_REQUEST_TYPE, ) -> BOOL656 pub fn PowerSetRequest( 657 PowerRequest: HANDLE, 658 RequestType: POWER_REQUEST_TYPE, 659 ) -> BOOL; PowerClearRequest( PowerRequest: HANDLE, RequestType: POWER_REQUEST_TYPE, ) -> BOOL660 pub fn PowerClearRequest( 661 PowerRequest: HANDLE, 662 RequestType: POWER_REQUEST_TYPE, 663 ) -> BOOL; RestoreLastError( dwErrCode: DWORD, )664 pub fn RestoreLastError( 665 dwErrCode: DWORD, 666 ); 667 } 668 pub const FILE_SKIP_COMPLETION_PORT_ON_SUCCESS: UCHAR = 0x1; 669 pub const FILE_SKIP_SET_EVENT_ON_HANDLE: UCHAR = 0x2; 670 extern "system" { SetFileCompletionNotificationModes( FileHandle: HANDLE, Flags: UCHAR, ) -> BOOL671 pub fn SetFileCompletionNotificationModes( 672 FileHandle: HANDLE, 673 Flags: UCHAR, 674 ) -> BOOL; 675 } 676 pub const SEM_FAILCRITICALERRORS: UINT = 0x0001; 677 pub const SEM_NOGPFAULTERRORBOX: UINT = 0x0002; 678 pub const SEM_NOALIGNMENTFAULTEXCEPT: UINT = 0x0004; 679 pub const SEM_NOOPENFILEERRORBOX: UINT = 0x8000; 680 extern "system" { Wow64GetThreadContext( hThread: HANDLE, lpContext: PWOW64_CONTEXT, ) -> BOOL681 pub fn Wow64GetThreadContext( 682 hThread: HANDLE, 683 lpContext: PWOW64_CONTEXT, 684 ) -> BOOL; Wow64SetThreadContext( hThread: HANDLE, lpContext: *const WOW64_CONTEXT, ) -> BOOL685 pub fn Wow64SetThreadContext( 686 hThread: HANDLE, 687 lpContext: *const WOW64_CONTEXT, 688 ) -> BOOL; Wow64GetThreadSelectorEntry( hThread: HANDLE, dwSelector: DWORD, lpSelectorEntry: PWOW64_LDT_ENTRY, ) -> BOOL689 pub fn Wow64GetThreadSelectorEntry( 690 hThread: HANDLE, 691 dwSelector: DWORD, 692 lpSelectorEntry: PWOW64_LDT_ENTRY, 693 ) -> BOOL; Wow64SuspendThread( hThread: HANDLE, ) -> DWORD694 pub fn Wow64SuspendThread( 695 hThread: HANDLE, 696 ) -> DWORD; DebugSetProcessKillOnExit( KillOnExit: BOOL, ) -> BOOL697 pub fn DebugSetProcessKillOnExit( 698 KillOnExit: BOOL, 699 ) -> BOOL; DebugBreakProcess( Process: HANDLE, ) -> BOOL700 pub fn DebugBreakProcess( 701 Process: HANDLE, 702 ) -> BOOL; PulseEvent( hEvent: HANDLE, ) -> BOOL703 pub fn PulseEvent( 704 hEvent: HANDLE, 705 ) -> BOOL; GlobalDeleteAtom( nAtom: ATOM, ) -> ATOM706 pub fn GlobalDeleteAtom( 707 nAtom: ATOM, 708 ) -> ATOM; InitAtomTable( nSize: DWORD, ) -> BOOL709 pub fn InitAtomTable( 710 nSize: DWORD, 711 ) -> BOOL; DeleteAtom( nAtom: ATOM, ) -> ATOM712 pub fn DeleteAtom( 713 nAtom: ATOM, 714 ) -> ATOM; SetHandleCount( uNumber: UINT, ) -> UINT715 pub fn SetHandleCount( 716 uNumber: UINT, 717 ) -> UINT; RequestDeviceWakeup( hDevice: HANDLE, ) -> BOOL718 pub fn RequestDeviceWakeup( 719 hDevice: HANDLE, 720 ) -> BOOL; CancelDeviceWakeupRequest( hDevice: HANDLE, ) -> BOOL721 pub fn CancelDeviceWakeupRequest( 722 hDevice: HANDLE, 723 ) -> BOOL; GetDevicePowerState( hDevice: HANDLE, pfOn: *mut BOOL, ) -> BOOL724 pub fn GetDevicePowerState( 725 hDevice: HANDLE, 726 pfOn: *mut BOOL, 727 ) -> BOOL; SetMessageWaitingIndicator( hMsgIndicator: HANDLE, ulMsgCount: ULONG, ) -> BOOL728 pub fn SetMessageWaitingIndicator( 729 hMsgIndicator: HANDLE, 730 ulMsgCount: ULONG, 731 ) -> BOOL; SetFileShortNameA( hFile: HANDLE, lpShortName: LPCSTR, ) -> BOOL732 pub fn SetFileShortNameA( 733 hFile: HANDLE, 734 lpShortName: LPCSTR, 735 ) -> BOOL; SetFileShortNameW( hFile: HANDLE, lpShortName: LPCWSTR, ) -> BOOL736 pub fn SetFileShortNameW( 737 hFile: HANDLE, 738 lpShortName: LPCWSTR, 739 ) -> BOOL; 740 } 741 pub const HANDLE_FLAG_INHERIT: DWORD = 0x00000001; 742 pub const HANDLE_FLAG_PROTECT_FROM_CLOSE: DWORD = 0x00000002; 743 extern "system" { LoadModule( lpModuleName: LPCSTR, lpParameterBlock: LPVOID, ) -> DWORD744 pub fn LoadModule( 745 lpModuleName: LPCSTR, 746 lpParameterBlock: LPVOID, 747 ) -> DWORD; WinExec( lpCmdLine: LPCSTR, uCmdShow: UINT, ) -> UINT748 pub fn WinExec( 749 lpCmdLine: LPCSTR, 750 uCmdShow: UINT, 751 ) -> UINT; 752 // ClearCommBreak 753 // ClearCommError 754 // SetupComm 755 // EscapeCommFunction 756 // GetCommConfig 757 // GetCommMask 758 // GetCommProperties 759 // GetCommModemStatus 760 // GetCommState 761 // GetCommTimeouts 762 // PurgeComm 763 // SetCommBreak 764 // SetCommConfig 765 // SetCommMask 766 // SetCommState 767 // SetCommTimeouts 768 // TransmitCommChar 769 // WaitCommEvent SetTapePosition( hDevice: HANDLE, dwPositionMethod: DWORD, dwPartition: DWORD, dwOffsetLow: DWORD, dwOffsetHigh: DWORD, bImmediate: BOOL, ) -> DWORD770 pub fn SetTapePosition( 771 hDevice: HANDLE, 772 dwPositionMethod: DWORD, 773 dwPartition: DWORD, 774 dwOffsetLow: DWORD, 775 dwOffsetHigh: DWORD, 776 bImmediate: BOOL, 777 ) -> DWORD; GetTapePosition( hDevice: HANDLE, dwPositionType: DWORD, lpdwPartition: LPDWORD, lpdwOffsetLow: LPDWORD, lpdwOffsetHigh: LPDWORD, ) -> DWORD778 pub fn GetTapePosition( 779 hDevice: HANDLE, 780 dwPositionType: DWORD, 781 lpdwPartition: LPDWORD, 782 lpdwOffsetLow: LPDWORD, 783 lpdwOffsetHigh: LPDWORD, 784 ) -> DWORD; PrepareTape( hDevice: HANDLE, dwOperation: DWORD, bImmediate: BOOL, ) -> DWORD785 pub fn PrepareTape( 786 hDevice: HANDLE, 787 dwOperation: DWORD, 788 bImmediate: BOOL, 789 ) -> DWORD; EraseTape( hDevice: HANDLE, dwEraseType: DWORD, bImmediate: BOOL, ) -> DWORD790 pub fn EraseTape( 791 hDevice: HANDLE, 792 dwEraseType: DWORD, 793 bImmediate: BOOL, 794 ) -> DWORD; CreateTapePartition( hDevice: HANDLE, dwPartitionMethod: DWORD, dwCount: DWORD, dwSize: DWORD, ) -> DWORD795 pub fn CreateTapePartition( 796 hDevice: HANDLE, 797 dwPartitionMethod: DWORD, 798 dwCount: DWORD, 799 dwSize: DWORD, 800 ) -> DWORD; WriteTapemark( hDevice: HANDLE, dwTapemarkType: DWORD, dwTapemarkCount: DWORD, bImmediate: BOOL, ) -> DWORD801 pub fn WriteTapemark( 802 hDevice: HANDLE, 803 dwTapemarkType: DWORD, 804 dwTapemarkCount: DWORD, 805 bImmediate: BOOL, 806 ) -> DWORD; GetTapeStatus( hDevice: HANDLE, ) -> DWORD807 pub fn GetTapeStatus( 808 hDevice: HANDLE, 809 ) -> DWORD; GetTapeParameters( hDevice: HANDLE, dwOperation: DWORD, lpdwSize: LPDWORD, lpTapeInformation: LPVOID, ) -> DWORD810 pub fn GetTapeParameters( 811 hDevice: HANDLE, 812 dwOperation: DWORD, 813 lpdwSize: LPDWORD, 814 lpTapeInformation: LPVOID, 815 ) -> DWORD; SetTapeParameters( hDevice: HANDLE, dwOperation: DWORD, lpTapeInformation: LPVOID, ) -> DWORD816 pub fn SetTapeParameters( 817 hDevice: HANDLE, 818 dwOperation: DWORD, 819 lpTapeInformation: LPVOID, 820 ) -> DWORD; MulDiv( nNumber: c_int, nNumerator: c_int, nDenominator: c_int, ) -> c_int821 pub fn MulDiv( 822 nNumber: c_int, 823 nNumerator: c_int, 824 nDenominator: c_int, 825 ) -> c_int; 826 } 827 ENUM!{enum DEP_SYSTEM_POLICY_TYPE { 828 DEPPolicyAlwaysOff = 0, 829 DEPPolicyAlwaysOn, 830 DEPPolicyOptIn, 831 DEPPolicyOptOut, 832 DEPTotalPolicyCount, 833 }} 834 extern "system" { GetSystemDEPPolicy() -> DEP_SYSTEM_POLICY_TYPE835 pub fn GetSystemDEPPolicy() -> DEP_SYSTEM_POLICY_TYPE; GetSystemRegistryQuota( pdwQuotaAllowed: PDWORD, pdwQuotaUsed: PDWORD, ) -> BOOL836 pub fn GetSystemRegistryQuota( 837 pdwQuotaAllowed: PDWORD, 838 pdwQuotaUsed: PDWORD, 839 ) -> BOOL; FileTimeToDosDateTime( lpFileTime: *const FILETIME, lpFatDate: LPWORD, lpFatTime: LPWORD, ) -> BOOL840 pub fn FileTimeToDosDateTime( 841 lpFileTime: *const FILETIME, 842 lpFatDate: LPWORD, 843 lpFatTime: LPWORD, 844 ) -> BOOL; DosDateTimeToFileTime( wFatDate: WORD, wFatTime: WORD, lpFileTime: LPFILETIME, ) -> BOOL845 pub fn DosDateTimeToFileTime( 846 wFatDate: WORD, 847 wFatTime: WORD, 848 lpFileTime: LPFILETIME, 849 ) -> BOOL; FormatMessageA( dwFlags: DWORD, lpSource: LPCVOID, dwMessageId: DWORD, dwLanguageId: DWORD, lpBuffer: LPSTR, nSize: DWORD, Arguments: *mut va_list, ) -> DWORD850 pub fn FormatMessageA( 851 dwFlags: DWORD, 852 lpSource: LPCVOID, 853 dwMessageId: DWORD, 854 dwLanguageId: DWORD, 855 lpBuffer: LPSTR, 856 nSize: DWORD, 857 Arguments: *mut va_list, 858 ) -> DWORD; FormatMessageW( dwFlags: DWORD, lpSource: LPCVOID, dwMessageId: DWORD, dwLanguageId: DWORD, lpBuffer: LPWSTR, nSize: DWORD, Arguments: *mut va_list, ) -> DWORD859 pub fn FormatMessageW( 860 dwFlags: DWORD, 861 lpSource: LPCVOID, 862 dwMessageId: DWORD, 863 dwLanguageId: DWORD, 864 lpBuffer: LPWSTR, 865 nSize: DWORD, 866 Arguments: *mut va_list, 867 ) -> DWORD; 868 } 869 pub const FORMAT_MESSAGE_IGNORE_INSERTS: DWORD = 0x00000200; 870 pub const FORMAT_MESSAGE_FROM_STRING: DWORD = 0x00000400; 871 pub const FORMAT_MESSAGE_FROM_HMODULE: DWORD = 0x00000800; 872 pub const FORMAT_MESSAGE_FROM_SYSTEM: DWORD = 0x00001000; 873 pub const FORMAT_MESSAGE_ARGUMENT_ARRAY: DWORD = 0x00002000; 874 pub const FORMAT_MESSAGE_MAX_WIDTH_MASK: DWORD = 0x000000FF; 875 pub const FORMAT_MESSAGE_ALLOCATE_BUFFER: DWORD = 0x00000100; 876 extern "system" { CreateMailslotA( lpName: LPCSTR, nMaxMessageSize: DWORD, lReadTimeout: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> HANDLE877 pub fn CreateMailslotA( 878 lpName: LPCSTR, 879 nMaxMessageSize: DWORD, 880 lReadTimeout: DWORD, 881 lpSecurityAttributes: LPSECURITY_ATTRIBUTES, 882 ) -> HANDLE; CreateMailslotW( lpName: LPCWSTR, nMaxMessageSize: DWORD, lReadTimeout: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> HANDLE883 pub fn CreateMailslotW( 884 lpName: LPCWSTR, 885 nMaxMessageSize: DWORD, 886 lReadTimeout: DWORD, 887 lpSecurityAttributes: LPSECURITY_ATTRIBUTES, 888 ) -> HANDLE; GetMailslotInfo( hMailslot: HANDLE, lpMaxMessageSize: LPDWORD, lpNextSize: LPDWORD, lpMessageCount: LPDWORD, lpReadTimeout: LPDWORD, ) -> BOOL889 pub fn GetMailslotInfo( 890 hMailslot: HANDLE, 891 lpMaxMessageSize: LPDWORD, 892 lpNextSize: LPDWORD, 893 lpMessageCount: LPDWORD, 894 lpReadTimeout: LPDWORD, 895 ) -> BOOL; SetMailslotInfo( hMailslot: HANDLE, lReadTimeout: DWORD, ) -> BOOL896 pub fn SetMailslotInfo( 897 hMailslot: HANDLE, 898 lReadTimeout: DWORD, 899 ) -> BOOL; 900 // pub fn EncryptFileA(); 901 // pub fn EncryptFileW(); 902 // pub fn DecryptFileA(); 903 // pub fn DecryptFileW(); 904 // pub fn FileEncryptionStatusA(); 905 // pub fn FileEncryptionStatusW(); 906 // pub fn OpenEncryptedFileRawA(); 907 // pub fn OpenEncryptedFileRawW(); 908 // pub fn ReadEncryptedFileRaw(); 909 // pub fn WriteEncryptedFileRaw(); 910 // pub fn CloseEncryptedFileRaw(); lstrcmpA( lpString1: LPCSTR, lpString2: LPCSTR, ) -> c_int911 pub fn lstrcmpA( 912 lpString1: LPCSTR, 913 lpString2: LPCSTR, 914 ) -> c_int; lstrcmpW( lpString1: LPCWSTR, lpString2: LPCWSTR, ) -> c_int915 pub fn lstrcmpW( 916 lpString1: LPCWSTR, 917 lpString2: LPCWSTR, 918 ) -> c_int; lstrcmpiA( lpString1: LPCSTR, lpString2: LPCSTR, ) -> c_int919 pub fn lstrcmpiA( 920 lpString1: LPCSTR, 921 lpString2: LPCSTR, 922 ) -> c_int; lstrcmpiW( lpString1: LPCWSTR, lpString2: LPCWSTR, ) -> c_int923 pub fn lstrcmpiW( 924 lpString1: LPCWSTR, 925 lpString2: LPCWSTR, 926 ) -> c_int; lstrcpynA( lpString1: LPSTR, lpString2: LPCSTR, iMaxLength: c_int, ) -> LPSTR927 pub fn lstrcpynA( 928 lpString1: LPSTR, 929 lpString2: LPCSTR, 930 iMaxLength: c_int, 931 ) -> LPSTR; lstrcpynW( lpString1: LPWSTR, lpString2: LPCWSTR, iMaxLength: c_int, ) -> LPWSTR932 pub fn lstrcpynW( 933 lpString1: LPWSTR, 934 lpString2: LPCWSTR, 935 iMaxLength: c_int, 936 ) -> LPWSTR; lstrcpyA( lpString1: LPSTR, lpString2: LPCSTR, ) -> LPSTR937 pub fn lstrcpyA( 938 lpString1: LPSTR, 939 lpString2: LPCSTR, 940 ) -> LPSTR; lstrcpyW( lpString1: LPWSTR, lpString2: LPCWSTR, ) -> LPWSTR941 pub fn lstrcpyW( 942 lpString1: LPWSTR, 943 lpString2: LPCWSTR, 944 ) -> LPWSTR; lstrcatA( lpString1: LPSTR, lpString2: LPCSTR, ) -> LPSTR945 pub fn lstrcatA( 946 lpString1: LPSTR, 947 lpString2: LPCSTR, 948 ) -> LPSTR; lstrcatW( lpString1: LPWSTR, lpString2: LPCWSTR, ) -> LPWSTR949 pub fn lstrcatW( 950 lpString1: LPWSTR, 951 lpString2: LPCWSTR, 952 ) -> LPWSTR; lstrlenA( lpString: LPCSTR, ) -> c_int953 pub fn lstrlenA( 954 lpString: LPCSTR, 955 ) -> c_int; lstrlenW( lpString: LPCWSTR, ) -> c_int956 pub fn lstrlenW( 957 lpString: LPCWSTR, 958 ) -> c_int; OpenFile( lpFileName: LPCSTR, lpReOpenBuff: LPOFSTRUCT, uStyle: UINT, ) -> HFILE959 pub fn OpenFile( 960 lpFileName: LPCSTR, 961 lpReOpenBuff: LPOFSTRUCT, 962 uStyle: UINT, 963 ) -> HFILE; _lopen( lpPathName: LPCSTR, iReadWrite: c_int, ) -> HFILE964 pub fn _lopen( 965 lpPathName: LPCSTR, 966 iReadWrite: c_int, 967 ) -> HFILE; _lcreat( lpPathName: LPCSTR, iAttrubute: c_int, ) -> HFILE968 pub fn _lcreat( 969 lpPathName: LPCSTR, 970 iAttrubute: c_int, 971 ) -> HFILE; _lread( hFile: HFILE, lpBuffer: LPVOID, uBytes: UINT, ) -> UINT972 pub fn _lread( 973 hFile: HFILE, 974 lpBuffer: LPVOID, 975 uBytes: UINT, 976 ) -> UINT; _lwrite( hFile: HFILE, lpBuffer: LPCCH, uBytes: UINT, ) -> UINT977 pub fn _lwrite( 978 hFile: HFILE, 979 lpBuffer: LPCCH, 980 uBytes: UINT, 981 ) -> UINT; _hread( hFile: HFILE, lpBuffer: LPVOID, lBytes: c_long, ) -> c_long982 pub fn _hread( 983 hFile: HFILE, 984 lpBuffer: LPVOID, 985 lBytes: c_long, 986 ) -> c_long; _hwrite( hFile: HFILE, lpBuffer: LPCCH, lBytes: c_long, ) -> c_long987 pub fn _hwrite( 988 hFile: HFILE, 989 lpBuffer: LPCCH, 990 lBytes: c_long, 991 ) -> c_long; _lclose( hFile: HFILE, ) -> HFILE992 pub fn _lclose( 993 hFile: HFILE, 994 ) -> HFILE; _llseek( hFile: HFILE, lOffset: LONG, iOrigin: c_int, ) -> LONG995 pub fn _llseek( 996 hFile: HFILE, 997 lOffset: LONG, 998 iOrigin: c_int, 999 ) -> LONG; 1000 // pub fn IsTextUnicode(); 1001 // pub fn SignalObjectAndWait(); BackupRead( hFile: HANDLE, lpBuffer: LPBYTE, nNumberOfBytesToRead: DWORD, lpNumberOfBytesRead: LPDWORD, bAbort: BOOL, bProcessSecurity: BOOL, lpContext: *mut LPVOID, ) -> BOOL1002 pub fn BackupRead( 1003 hFile: HANDLE, 1004 lpBuffer: LPBYTE, 1005 nNumberOfBytesToRead: DWORD, 1006 lpNumberOfBytesRead: LPDWORD, 1007 bAbort: BOOL, 1008 bProcessSecurity: BOOL, 1009 lpContext: *mut LPVOID, 1010 ) -> BOOL; BackupSeek( hFile: HANDLE, dwLowBytesToSeek: DWORD, dwHighBytesToSeek: DWORD, lpdwLowByteSeeked: LPDWORD, lpdwHighByteSeeked: LPDWORD, lpContext: *mut LPVOID, ) -> BOOL1011 pub fn BackupSeek( 1012 hFile: HANDLE, 1013 dwLowBytesToSeek: DWORD, 1014 dwHighBytesToSeek: DWORD, 1015 lpdwLowByteSeeked: LPDWORD, 1016 lpdwHighByteSeeked: LPDWORD, 1017 lpContext: *mut LPVOID, 1018 ) -> BOOL; BackupWrite( hFile: HANDLE, lpBuffer: LPBYTE, nNumberOfBytesToWrite: DWORD, lpNumberOfBytesWritten: LPDWORD, bAbort: BOOL, bProcessSecurity: BOOL, lpContext: *mut LPVOID, ) -> BOOL1019 pub fn BackupWrite( 1020 hFile: HANDLE, 1021 lpBuffer: LPBYTE, 1022 nNumberOfBytesToWrite: DWORD, 1023 lpNumberOfBytesWritten: LPDWORD, 1024 bAbort: BOOL, 1025 bProcessSecurity: BOOL, 1026 lpContext: *mut LPVOID, 1027 ) -> BOOL; 1028 } 1029 //2886 1030 pub const STARTF_USESHOWWINDOW: DWORD = 0x00000001; 1031 pub const STARTF_USESIZE: DWORD = 0x00000002; 1032 pub const STARTF_USEPOSITION: DWORD = 0x00000004; 1033 pub const STARTF_USECOUNTCHARS: DWORD = 0x00000008; 1034 pub const STARTF_USEFILLATTRIBUTE: DWORD = 0x00000010; 1035 pub const STARTF_RUNFULLSCREEN: DWORD = 0x00000020; 1036 pub const STARTF_FORCEONFEEDBACK: DWORD = 0x00000040; 1037 pub const STARTF_FORCEOFFFEEDBACK: DWORD = 0x00000080; 1038 pub const STARTF_USESTDHANDLES: DWORD = 0x00000100; 1039 pub const STARTF_USEHOTKEY: DWORD = 0x00000200; 1040 pub const STARTF_TITLEISLINKNAME: DWORD = 0x00000800; 1041 pub const STARTF_TITLEISAPPID: DWORD = 0x00001000; 1042 pub const STARTF_PREVENTPINNING: DWORD = 0x00002000; 1043 pub const STARTF_UNTRUSTEDSOURCE: DWORD = 0x00008000; 1044 STRUCT!{struct STARTUPINFOEXA { 1045 StartupInfo: STARTUPINFOA, 1046 lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST, 1047 }} 1048 pub type LPSTARTUPINFOEXA = *mut STARTUPINFOEXA; 1049 STRUCT!{struct STARTUPINFOEXW { 1050 StartupInfo: STARTUPINFOW, 1051 lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST, 1052 }} 1053 pub type LPSTARTUPINFOEXW = *mut STARTUPINFOEXW; 1054 extern "system" { OpenMutexA( dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR, ) -> HANDLE1055 pub fn OpenMutexA( 1056 dwDesiredAccess: DWORD, 1057 bInheritHandle: BOOL, 1058 lpName: LPCSTR, 1059 ) -> HANDLE; CreateSemaphoreA( lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCSTR, ) -> HANDLE1060 pub fn CreateSemaphoreA( 1061 lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, 1062 lInitialCount: LONG, 1063 lMaximumCount: LONG, 1064 lpName: LPCSTR, 1065 ) -> HANDLE; OpenSemaphoreA( dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR, ) -> HANDLE1066 pub fn OpenSemaphoreA( 1067 dwDesiredAccess: DWORD, 1068 bInheritHandle: BOOL, 1069 lpName: LPCSTR, 1070 ) -> HANDLE; CreateWaitableTimerA( lpTimerAttributes: LPSECURITY_ATTRIBUTES, bManualReset: BOOL, lpTimerName: LPCSTR, ) -> HANDLE1071 pub fn CreateWaitableTimerA( 1072 lpTimerAttributes: LPSECURITY_ATTRIBUTES, 1073 bManualReset: BOOL, 1074 lpTimerName: LPCSTR, 1075 ) -> HANDLE; OpenWaitableTimerA( dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpTimerName: LPCSTR, ) -> HANDLE1076 pub fn OpenWaitableTimerA( 1077 dwDesiredAccess: DWORD, 1078 bInheritHandle: BOOL, 1079 lpTimerName: LPCSTR, 1080 ) -> HANDLE; CreateSemaphoreExA( lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCSTR, dwFlags: DWORD, dwDesiredAccess: DWORD, ) -> HANDLE1081 pub fn CreateSemaphoreExA( 1082 lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, 1083 lInitialCount: LONG, 1084 lMaximumCount: LONG, 1085 lpName: LPCSTR, 1086 dwFlags: DWORD, 1087 dwDesiredAccess: DWORD, 1088 ) -> HANDLE; CreateWaitableTimerExA( lpTimerAttributes: LPSECURITY_ATTRIBUTES, lpTimerName: LPCSTR, dwFlags: DWORD, dwDesiredAccess: DWORD, ) -> HANDLE1089 pub fn CreateWaitableTimerExA( 1090 lpTimerAttributes: LPSECURITY_ATTRIBUTES, 1091 lpTimerName: LPCSTR, 1092 dwFlags: DWORD, 1093 dwDesiredAccess: DWORD, 1094 ) -> HANDLE; CreateFileMappingA( hFile: HANDLE, lpAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCSTR, ) -> HANDLE1095 pub fn CreateFileMappingA( 1096 hFile: HANDLE, 1097 lpAttributes: LPSECURITY_ATTRIBUTES, 1098 flProtect: DWORD, 1099 dwMaximumSizeHigh: DWORD, 1100 dwMaximumSizeLow: DWORD, 1101 lpName: LPCSTR, 1102 ) -> HANDLE; CreateFileMappingNumaA( hFile: HANDLE, lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCSTR, nndPreferred: DWORD, ) -> HANDLE1103 pub fn CreateFileMappingNumaA( 1104 hFile: HANDLE, 1105 lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, 1106 flProtect: DWORD, 1107 dwMaximumSizeHigh: DWORD, 1108 dwMaximumSizeLow: DWORD, 1109 lpName: LPCSTR, 1110 nndPreferred: DWORD, 1111 ) -> HANDLE; OpenFileMappingA( dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR, ) -> HANDLE1112 pub fn OpenFileMappingA( 1113 dwDesiredAccess: DWORD, 1114 bInheritHandle: BOOL, 1115 lpName: LPCSTR, 1116 ) -> HANDLE; GetLogicalDriveStringsA( nBufferLength: DWORD, lpBuffer: LPSTR, ) -> DWORD1117 pub fn GetLogicalDriveStringsA( 1118 nBufferLength: DWORD, 1119 lpBuffer: LPSTR, 1120 ) -> DWORD; LoadPackagedLibrary( lpwLibFileName: LPCWSTR, Reserved: DWORD, ) -> HMODULE1121 pub fn LoadPackagedLibrary( 1122 lpwLibFileName: LPCWSTR, 1123 Reserved: DWORD, 1124 ) -> HMODULE; QueryFullProcessImageNameA( hProcess: HANDLE, dwFlags: DWORD, lpExeName: LPSTR, lpdwSize: PDWORD, ) -> BOOL1125 pub fn QueryFullProcessImageNameA( 1126 hProcess: HANDLE, 1127 dwFlags: DWORD, 1128 lpExeName: LPSTR, 1129 lpdwSize: PDWORD, 1130 ) -> BOOL; QueryFullProcessImageNameW( hProcess: HANDLE, dwFlags: DWORD, lpExeName: LPWSTR, lpdwSize: PDWORD, ) -> BOOL1131 pub fn QueryFullProcessImageNameW( 1132 hProcess: HANDLE, 1133 dwFlags: DWORD, 1134 lpExeName: LPWSTR, 1135 lpdwSize: PDWORD, 1136 ) -> BOOL; 1137 } 1138 //3233 1139 extern "system" { GetStartupInfoA( lpStartupInfo: LPSTARTUPINFOA, )1140 pub fn GetStartupInfoA( 1141 lpStartupInfo: LPSTARTUPINFOA, 1142 ); GetFirmwareEnvironmentVariableA( lpName: LPCSTR, lpGuid: LPCSTR, pBuffer: PVOID, nSize: DWORD, ) -> DWORD1143 pub fn GetFirmwareEnvironmentVariableA( 1144 lpName: LPCSTR, 1145 lpGuid: LPCSTR, 1146 pBuffer: PVOID, 1147 nSize: DWORD, 1148 ) -> DWORD; GetFirmwareEnvironmentVariableW( lpName: LPCWSTR, lpGuid: LPCWSTR, pBuffer: PVOID, nSize: DWORD, ) -> DWORD1149 pub fn GetFirmwareEnvironmentVariableW( 1150 lpName: LPCWSTR, 1151 lpGuid: LPCWSTR, 1152 pBuffer: PVOID, 1153 nSize: DWORD, 1154 ) -> DWORD; GetFirmwareEnvironmentVariableExA( lpName: LPCSTR, lpGuid: LPCSTR, pBuffer: PVOID, nSize: DWORD, pdwAttribubutes: PDWORD, ) -> DWORD1155 pub fn GetFirmwareEnvironmentVariableExA( 1156 lpName: LPCSTR, 1157 lpGuid: LPCSTR, 1158 pBuffer: PVOID, 1159 nSize: DWORD, 1160 pdwAttribubutes: PDWORD, 1161 ) -> DWORD; GetFirmwareEnvironmentVariableExW( lpName: LPCWSTR, lpGuid: LPCWSTR, pBuffer: PVOID, nSize: DWORD, pdwAttribubutes: PDWORD, ) -> DWORD1162 pub fn GetFirmwareEnvironmentVariableExW( 1163 lpName: LPCWSTR, 1164 lpGuid: LPCWSTR, 1165 pBuffer: PVOID, 1166 nSize: DWORD, 1167 pdwAttribubutes: PDWORD, 1168 ) -> DWORD; SetFirmwareEnvironmentVariableA( lpName: LPCSTR, lpGuid: LPCSTR, pValue: PVOID, nSize: DWORD, ) -> BOOL1169 pub fn SetFirmwareEnvironmentVariableA( 1170 lpName: LPCSTR, 1171 lpGuid: LPCSTR, 1172 pValue: PVOID, 1173 nSize: DWORD, 1174 ) -> BOOL; SetFirmwareEnvironmentVariableW( lpName: LPCWSTR, lpGuid: LPCWSTR, pValue: PVOID, nSize: DWORD, ) -> BOOL1175 pub fn SetFirmwareEnvironmentVariableW( 1176 lpName: LPCWSTR, 1177 lpGuid: LPCWSTR, 1178 pValue: PVOID, 1179 nSize: DWORD, 1180 ) -> BOOL; SetFirmwareEnvironmentVariableExA( lpName: LPCSTR, lpGuid: LPCSTR, pValue: PVOID, nSize: DWORD, dwAttributes: DWORD, ) -> BOOL1181 pub fn SetFirmwareEnvironmentVariableExA( 1182 lpName: LPCSTR, 1183 lpGuid: LPCSTR, 1184 pValue: PVOID, 1185 nSize: DWORD, 1186 dwAttributes: DWORD, 1187 ) -> BOOL; SetFirmwareEnvironmentVariableExW( lpName: LPCWSTR, lpGuid: LPCWSTR, pValue: PVOID, nSize: DWORD, dwAttributes: DWORD, ) -> BOOL1188 pub fn SetFirmwareEnvironmentVariableExW( 1189 lpName: LPCWSTR, 1190 lpGuid: LPCWSTR, 1191 pValue: PVOID, 1192 nSize: DWORD, 1193 dwAttributes: DWORD, 1194 ) -> BOOL; GetFirmwareType( FirmwareType: PFIRMWARE_TYPE, ) -> BOOL1195 pub fn GetFirmwareType( 1196 FirmwareType: PFIRMWARE_TYPE, 1197 ) -> BOOL; IsNativeVhdBoot( NativeVhdBoot: PBOOL, ) -> BOOL1198 pub fn IsNativeVhdBoot( 1199 NativeVhdBoot: PBOOL, 1200 ) -> BOOL; FindResourceA( hModule: HMODULE, lpName: LPCSTR, lpType: LPCSTR, ) -> HRSRC1201 pub fn FindResourceA( 1202 hModule: HMODULE, 1203 lpName: LPCSTR, 1204 lpType: LPCSTR, 1205 ) -> HRSRC; FindResourceExA( hModule: HMODULE, lpName: LPCSTR, lpType: LPCSTR, wLanguage: WORD, ) -> HRSRC1206 pub fn FindResourceExA( 1207 hModule: HMODULE, 1208 lpName: LPCSTR, 1209 lpType: LPCSTR, 1210 wLanguage: WORD, 1211 ) -> HRSRC; EnumResourceTypesA( hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCA, lParam: LONG_PTR, ) -> BOOL1212 pub fn EnumResourceTypesA( 1213 hModule: HMODULE, 1214 lpEnumFunc: ENUMRESTYPEPROCA, 1215 lParam: LONG_PTR, 1216 ) -> BOOL; EnumResourceTypesW( hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCW, lParam: LONG_PTR, ) -> BOOL1217 pub fn EnumResourceTypesW( 1218 hModule: HMODULE, 1219 lpEnumFunc: ENUMRESTYPEPROCW, 1220 lParam: LONG_PTR, 1221 ) -> BOOL; EnumResourceNamesA( hModule: HMODULE, lpType: LPCSTR, lpEnumFunc: ENUMRESNAMEPROCA, lParam: LONG_PTR, ) -> BOOL1222 pub fn EnumResourceNamesA( 1223 hModule: HMODULE, 1224 lpType: LPCSTR, 1225 lpEnumFunc: ENUMRESNAMEPROCA, 1226 lParam: LONG_PTR, 1227 ) -> BOOL; EnumResourceLanguagesA( hModule: HMODULE, lpType: LPCSTR, lpName: LPCSTR, lpEnumFunc: ENUMRESLANGPROCA, lParam: LONG_PTR, ) -> BOOL1228 pub fn EnumResourceLanguagesA( 1229 hModule: HMODULE, 1230 lpType: LPCSTR, 1231 lpName: LPCSTR, 1232 lpEnumFunc: ENUMRESLANGPROCA, 1233 lParam: LONG_PTR, 1234 ) -> BOOL; EnumResourceLanguagesW( hModule: HMODULE, lpType: LPCWSTR, lpName: LPCWSTR, lpEnumFunc: ENUMRESLANGPROCW, lParam: LONG_PTR, ) -> BOOL1235 pub fn EnumResourceLanguagesW( 1236 hModule: HMODULE, 1237 lpType: LPCWSTR, 1238 lpName: LPCWSTR, 1239 lpEnumFunc: ENUMRESLANGPROCW, 1240 lParam: LONG_PTR, 1241 ) -> BOOL; BeginUpdateResourceA( pFileName: LPCSTR, bDeleteExistingResources: BOOL, ) -> HANDLE1242 pub fn BeginUpdateResourceA( 1243 pFileName: LPCSTR, 1244 bDeleteExistingResources: BOOL, 1245 ) -> HANDLE; BeginUpdateResourceW( pFileName: LPCWSTR, bDeleteExistingResources: BOOL, ) -> HANDLE1246 pub fn BeginUpdateResourceW( 1247 pFileName: LPCWSTR, 1248 bDeleteExistingResources: BOOL, 1249 ) -> HANDLE; UpdateResourceA( hUpdate: HANDLE, lpType: LPCSTR, lpName: LPCSTR, wLanguage: WORD, lpData: LPVOID, cb: DWORD, ) -> BOOL1250 pub fn UpdateResourceA( 1251 hUpdate: HANDLE, 1252 lpType: LPCSTR, 1253 lpName: LPCSTR, 1254 wLanguage: WORD, 1255 lpData: LPVOID, 1256 cb: DWORD, 1257 ) -> BOOL; UpdateResourceW( hUpdate: HANDLE, lpType: LPCWSTR, lpName: LPCWSTR, wLanguage: WORD, lpData: LPVOID, cb: DWORD, ) -> BOOL1258 pub fn UpdateResourceW( 1259 hUpdate: HANDLE, 1260 lpType: LPCWSTR, 1261 lpName: LPCWSTR, 1262 wLanguage: WORD, 1263 lpData: LPVOID, 1264 cb: DWORD, 1265 ) -> BOOL; EndUpdateResourceA( hUpdate: HANDLE, fDiscard: BOOL, ) -> BOOL1266 pub fn EndUpdateResourceA( 1267 hUpdate: HANDLE, 1268 fDiscard: BOOL, 1269 ) -> BOOL; EndUpdateResourceW( hUpdate: HANDLE, fDiscard: BOOL, ) -> BOOL1270 pub fn EndUpdateResourceW( 1271 hUpdate: HANDLE, 1272 fDiscard: BOOL, 1273 ) -> BOOL; GlobalAddAtomA( lpString: LPCSTR, ) -> ATOM1274 pub fn GlobalAddAtomA( 1275 lpString: LPCSTR, 1276 ) -> ATOM; GlobalAddAtomW( lpString: LPCWSTR, ) -> ATOM1277 pub fn GlobalAddAtomW( 1278 lpString: LPCWSTR, 1279 ) -> ATOM; GlobalAddAtomExA( lpString: LPCSTR, Flags: DWORD, ) -> ATOM1280 pub fn GlobalAddAtomExA( 1281 lpString: LPCSTR, 1282 Flags: DWORD, 1283 ) -> ATOM; GlobalAddAtomExW( lpString: LPCWSTR, Flags: DWORD, ) -> ATOM1284 pub fn GlobalAddAtomExW( 1285 lpString: LPCWSTR, 1286 Flags: DWORD, 1287 ) -> ATOM; GlobalFindAtomA( lpString: LPCSTR, ) -> ATOM1288 pub fn GlobalFindAtomA( 1289 lpString: LPCSTR, 1290 ) -> ATOM; GlobalFindAtomW( lpString: LPCWSTR, ) -> ATOM1291 pub fn GlobalFindAtomW( 1292 lpString: LPCWSTR, 1293 ) -> ATOM; GlobalGetAtomNameA( nAtom: ATOM, lpBuffer: LPSTR, nSize: c_int, ) -> UINT1294 pub fn GlobalGetAtomNameA( 1295 nAtom: ATOM, 1296 lpBuffer: LPSTR, 1297 nSize: c_int, 1298 ) -> UINT; GlobalGetAtomNameW( nAtom: ATOM, lpBuffer: LPWSTR, nSize: c_int, ) -> UINT1299 pub fn GlobalGetAtomNameW( 1300 nAtom: ATOM, 1301 lpBuffer: LPWSTR, 1302 nSize: c_int, 1303 ) -> UINT; AddAtomA( lpString: LPCSTR, ) -> ATOM1304 pub fn AddAtomA( 1305 lpString: LPCSTR, 1306 ) -> ATOM; AddAtomW( lpString: LPCWSTR, ) -> ATOM1307 pub fn AddAtomW( 1308 lpString: LPCWSTR, 1309 ) -> ATOM; FindAtomA( lpString: LPCSTR, ) -> ATOM1310 pub fn FindAtomA( 1311 lpString: LPCSTR, 1312 ) -> ATOM; FindAtomW( lpString: LPCWSTR, ) -> ATOM1313 pub fn FindAtomW( 1314 lpString: LPCWSTR, 1315 ) -> ATOM; GetAtomNameA( nAtom: ATOM, lpBuffer: LPSTR, nSize: c_int, ) -> UINT1316 pub fn GetAtomNameA( 1317 nAtom: ATOM, 1318 lpBuffer: LPSTR, 1319 nSize: c_int, 1320 ) -> UINT; GetAtomNameW( nAtom: ATOM, lpBuffer: LPWSTR, nSize: c_int, ) -> UINT1321 pub fn GetAtomNameW( 1322 nAtom: ATOM, 1323 lpBuffer: LPWSTR, 1324 nSize: c_int, 1325 ) -> UINT; GetProfileIntA( lpAppName: LPCSTR, lpKeyName: LPCSTR, nDefault: INT, ) -> UINT1326 pub fn GetProfileIntA( 1327 lpAppName: LPCSTR, 1328 lpKeyName: LPCSTR, 1329 nDefault: INT, 1330 ) -> UINT; GetProfileIntW( lpAppName: LPCWSTR, lpKeyName: LPCWSTR, nDefault: INT, ) -> UINT1331 pub fn GetProfileIntW( 1332 lpAppName: LPCWSTR, 1333 lpKeyName: LPCWSTR, 1334 nDefault: INT, 1335 ) -> UINT; GetProfileStringA( lpAppName: LPCSTR, lpKeyName: LPCSTR, lpDefault: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD, ) -> DWORD1336 pub fn GetProfileStringA( 1337 lpAppName: LPCSTR, 1338 lpKeyName: LPCSTR, 1339 lpDefault: LPCSTR, 1340 lpReturnedString: LPSTR, 1341 nSize: DWORD, 1342 ) -> DWORD; GetProfileStringW( lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpDefault: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD, ) -> DWORD1343 pub fn GetProfileStringW( 1344 lpAppName: LPCWSTR, 1345 lpKeyName: LPCWSTR, 1346 lpDefault: LPCWSTR, 1347 lpReturnedString: LPWSTR, 1348 nSize: DWORD, 1349 ) -> DWORD; WriteProfileStringA( lpAppName: LPCSTR, lpKeyName: LPCSTR, lpString: LPCSTR, ) -> BOOL1350 pub fn WriteProfileStringA( 1351 lpAppName: LPCSTR, 1352 lpKeyName: LPCSTR, 1353 lpString: LPCSTR, 1354 ) -> BOOL; WriteProfileStringW( lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpString: LPCWSTR, ) -> BOOL1355 pub fn WriteProfileStringW( 1356 lpAppName: LPCWSTR, 1357 lpKeyName: LPCWSTR, 1358 lpString: LPCWSTR, 1359 ) -> BOOL; GetProfileSectionA( lpAppName: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD, ) -> DWORD1360 pub fn GetProfileSectionA( 1361 lpAppName: LPCSTR, 1362 lpReturnedString: LPSTR, 1363 nSize: DWORD, 1364 ) -> DWORD; GetProfileSectionW( lpAppName: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD, ) -> DWORD1365 pub fn GetProfileSectionW( 1366 lpAppName: LPCWSTR, 1367 lpReturnedString: LPWSTR, 1368 nSize: DWORD, 1369 ) -> DWORD; WriteProfileSectionA( lpAppName: LPCSTR, lpString: LPCSTR, ) -> BOOL1370 pub fn WriteProfileSectionA( 1371 lpAppName: LPCSTR, 1372 lpString: LPCSTR, 1373 ) -> BOOL; WriteProfileSectionW( lpAppName: LPCWSTR, lpString: LPCWSTR, ) -> BOOL1374 pub fn WriteProfileSectionW( 1375 lpAppName: LPCWSTR, 1376 lpString: LPCWSTR, 1377 ) -> BOOL; GetPrivateProfileIntA( lpAppName: LPCSTR, lpKeyName: LPCSTR, nDefault: INT, lpFileName: LPCSTR, ) -> UINT1378 pub fn GetPrivateProfileIntA( 1379 lpAppName: LPCSTR, 1380 lpKeyName: LPCSTR, 1381 nDefault: INT, 1382 lpFileName: LPCSTR, 1383 ) -> UINT; GetPrivateProfileIntW( lpAppName: LPCWSTR, lpKeyName: LPCWSTR, nDefault: INT, lpFileName: LPCWSTR, ) -> UINT1384 pub fn GetPrivateProfileIntW( 1385 lpAppName: LPCWSTR, 1386 lpKeyName: LPCWSTR, 1387 nDefault: INT, 1388 lpFileName: LPCWSTR, 1389 ) -> UINT; GetPrivateProfileStringA( lpAppName: LPCSTR, lpKeyName: LPCSTR, lpDefault: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD, lpFileName: LPCSTR, ) -> DWORD1390 pub fn GetPrivateProfileStringA( 1391 lpAppName: LPCSTR, 1392 lpKeyName: LPCSTR, 1393 lpDefault: LPCSTR, 1394 lpReturnedString: LPSTR, 1395 nSize: DWORD, 1396 lpFileName: LPCSTR, 1397 ) -> DWORD; GetPrivateProfileStringW( lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpDefault: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD, lpFileName: LPCWSTR, ) -> DWORD1398 pub fn GetPrivateProfileStringW( 1399 lpAppName: LPCWSTR, 1400 lpKeyName: LPCWSTR, 1401 lpDefault: LPCWSTR, 1402 lpReturnedString: LPWSTR, 1403 nSize: DWORD, 1404 lpFileName: LPCWSTR, 1405 ) -> DWORD; WritePrivateProfileStringA( lpAppName: LPCSTR, lpKeyName: LPCSTR, lpString: LPCSTR, lpFileName: LPCSTR, ) -> BOOL1406 pub fn WritePrivateProfileStringA( 1407 lpAppName: LPCSTR, 1408 lpKeyName: LPCSTR, 1409 lpString: LPCSTR, 1410 lpFileName: LPCSTR, 1411 ) -> BOOL; WritePrivateProfileStringW( lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpString: LPCWSTR, lpFileName: LPCWSTR, ) -> BOOL1412 pub fn WritePrivateProfileStringW( 1413 lpAppName: LPCWSTR, 1414 lpKeyName: LPCWSTR, 1415 lpString: LPCWSTR, 1416 lpFileName: LPCWSTR, 1417 ) -> BOOL; GetPrivateProfileSectionA( lpAppName: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD, lpFileName: LPCSTR, ) -> DWORD1418 pub fn GetPrivateProfileSectionA( 1419 lpAppName: LPCSTR, 1420 lpReturnedString: LPSTR, 1421 nSize: DWORD, 1422 lpFileName: LPCSTR, 1423 ) -> DWORD; GetPrivateProfileSectionW( lpAppName: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD, lpFileName: LPCWSTR, ) -> DWORD1424 pub fn GetPrivateProfileSectionW( 1425 lpAppName: LPCWSTR, 1426 lpReturnedString: LPWSTR, 1427 nSize: DWORD, 1428 lpFileName: LPCWSTR, 1429 ) -> DWORD; WritePrivateProfileSectionA( lpAppName: LPCSTR, lpString: LPCSTR, lpFileName: LPCSTR, ) -> BOOL1430 pub fn WritePrivateProfileSectionA( 1431 lpAppName: LPCSTR, 1432 lpString: LPCSTR, 1433 lpFileName: LPCSTR, 1434 ) -> BOOL; WritePrivateProfileSectionW( lpAppName: LPCWSTR, lpString: LPCWSTR, lpFileName: LPCWSTR, ) -> BOOL1435 pub fn WritePrivateProfileSectionW( 1436 lpAppName: LPCWSTR, 1437 lpString: LPCWSTR, 1438 lpFileName: LPCWSTR, 1439 ) -> BOOL; GetPrivateProfileSectionNamesA( lpszReturnBuffer: LPSTR, nSize: DWORD, lpFileName: LPCSTR, ) -> DWORD1440 pub fn GetPrivateProfileSectionNamesA( 1441 lpszReturnBuffer: LPSTR, 1442 nSize: DWORD, 1443 lpFileName: LPCSTR, 1444 ) -> DWORD; GetPrivateProfileSectionNamesW( lpszReturnBuffer: LPWSTR, nSize: DWORD, lpFileName: LPCWSTR, ) -> DWORD1445 pub fn GetPrivateProfileSectionNamesW( 1446 lpszReturnBuffer: LPWSTR, 1447 nSize: DWORD, 1448 lpFileName: LPCWSTR, 1449 ) -> DWORD; GetPrivateProfileStructA( lpszSection: LPCSTR, lpszKey: LPCSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCSTR, ) -> BOOL1450 pub fn GetPrivateProfileStructA( 1451 lpszSection: LPCSTR, 1452 lpszKey: LPCSTR, 1453 lpStruct: LPVOID, 1454 uSizeStruct: UINT, 1455 szFile: LPCSTR, 1456 ) -> BOOL; GetPrivateProfileStructW( lpszSection: LPCWSTR, lpszKey: LPCWSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCWSTR, ) -> BOOL1457 pub fn GetPrivateProfileStructW( 1458 lpszSection: LPCWSTR, 1459 lpszKey: LPCWSTR, 1460 lpStruct: LPVOID, 1461 uSizeStruct: UINT, 1462 szFile: LPCWSTR, 1463 ) -> BOOL; WritePrivateProfileStructA( lpszSection: LPCSTR, lpszKey: LPCSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCSTR, ) -> BOOL1464 pub fn WritePrivateProfileStructA( 1465 lpszSection: LPCSTR, 1466 lpszKey: LPCSTR, 1467 lpStruct: LPVOID, 1468 uSizeStruct: UINT, 1469 szFile: LPCSTR, 1470 ) -> BOOL; WritePrivateProfileStructW( lpszSection: LPCWSTR, lpszKey: LPCWSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCWSTR, ) -> BOOL1471 pub fn WritePrivateProfileStructW( 1472 lpszSection: LPCWSTR, 1473 lpszKey: LPCWSTR, 1474 lpStruct: LPVOID, 1475 uSizeStruct: UINT, 1476 szFile: LPCWSTR, 1477 ) -> BOOL; Wow64EnableWow64FsRedirection( Wow64FsEnableRedirection: BOOLEAN, ) -> BOOLEAN1478 pub fn Wow64EnableWow64FsRedirection( 1479 Wow64FsEnableRedirection: BOOLEAN, 1480 ) -> BOOLEAN; SetDllDirectoryA( lpPathName: LPCSTR, ) -> BOOL1481 pub fn SetDllDirectoryA( 1482 lpPathName: LPCSTR, 1483 ) -> BOOL; SetDllDirectoryW( lpPathName: LPCWSTR, ) -> BOOL1484 pub fn SetDllDirectoryW( 1485 lpPathName: LPCWSTR, 1486 ) -> BOOL; GetDllDirectoryA( nBufferLength: DWORD, lpBuffer: LPSTR, ) -> DWORD1487 pub fn GetDllDirectoryA( 1488 nBufferLength: DWORD, 1489 lpBuffer: LPSTR, 1490 ) -> DWORD; GetDllDirectoryW( nBufferLength: DWORD, lpBuffer: LPWSTR, ) -> DWORD1491 pub fn GetDllDirectoryW( 1492 nBufferLength: DWORD, 1493 lpBuffer: LPWSTR, 1494 ) -> DWORD; SetSearchPathMode( Flags: DWORD, ) -> BOOL1495 pub fn SetSearchPathMode( 1496 Flags: DWORD, 1497 ) -> BOOL; CreateDirectoryExA( lpTemplateDirectory: LPCSTR, lpNewDirectory: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> BOOL1498 pub fn CreateDirectoryExA( 1499 lpTemplateDirectory: LPCSTR, 1500 lpNewDirectory: LPCSTR, 1501 lpSecurityAttributes: LPSECURITY_ATTRIBUTES, 1502 ) -> BOOL; CreateDirectoryExW( lpTemplateDirectory: LPCWSTR, lpNewDirectory: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> BOOL1503 pub fn CreateDirectoryExW( 1504 lpTemplateDirectory: LPCWSTR, 1505 lpNewDirectory: LPCWSTR, 1506 lpSecurityAttributes: LPSECURITY_ATTRIBUTES, 1507 ) -> BOOL; CreateDirectoryTransactedA( lpTemplateDirectory: LPCSTR, lpNewDirectory: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE, ) -> BOOL1508 pub fn CreateDirectoryTransactedA( 1509 lpTemplateDirectory: LPCSTR, 1510 lpNewDirectory: LPCSTR, 1511 lpSecurityAttributes: LPSECURITY_ATTRIBUTES, 1512 hTransaction: HANDLE, 1513 ) -> BOOL; CreateDirectoryTransactedW( lpTemplateDirectory: LPCWSTR, lpNewDirectory: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE, ) -> BOOL1514 pub fn CreateDirectoryTransactedW( 1515 lpTemplateDirectory: LPCWSTR, 1516 lpNewDirectory: LPCWSTR, 1517 lpSecurityAttributes: LPSECURITY_ATTRIBUTES, 1518 hTransaction: HANDLE, 1519 ) -> BOOL; RemoveDirectoryTransactedA( lpPathName: LPCSTR, hTransaction: HANDLE, ) -> BOOL1520 pub fn RemoveDirectoryTransactedA( 1521 lpPathName: LPCSTR, 1522 hTransaction: HANDLE, 1523 ) -> BOOL; RemoveDirectoryTransactedW( lpPathName: LPCWSTR, hTransaction: HANDLE, ) -> BOOL1524 pub fn RemoveDirectoryTransactedW( 1525 lpPathName: LPCWSTR, 1526 hTransaction: HANDLE, 1527 ) -> BOOL; GetFullPathNameTransactedA( lpFileName: LPCSTR, nBufferLength: DWORD, lpBuffer: LPSTR, lpFilePart: *mut LPSTR, hTransaction: HANDLE, ) -> DWORD1528 pub fn GetFullPathNameTransactedA( 1529 lpFileName: LPCSTR, 1530 nBufferLength: DWORD, 1531 lpBuffer: LPSTR, 1532 lpFilePart: *mut LPSTR, 1533 hTransaction: HANDLE, 1534 ) -> DWORD; GetFullPathNameTransactedW( lpFileName: LPCWSTR, nBufferLength: DWORD, lpBuffer: LPWSTR, lpFilePart: *mut LPWSTR, hTransaction: HANDLE, )1535 pub fn GetFullPathNameTransactedW( 1536 lpFileName: LPCWSTR, 1537 nBufferLength: DWORD, 1538 lpBuffer: LPWSTR, 1539 lpFilePart: *mut LPWSTR, 1540 hTransaction: HANDLE, 1541 ); DefineDosDeviceA( dwFlags: DWORD, lpDeviceName: LPCSTR, lpTargetPath: LPCSTR, ) -> BOOL1542 pub fn DefineDosDeviceA( 1543 dwFlags: DWORD, 1544 lpDeviceName: LPCSTR, 1545 lpTargetPath: LPCSTR, 1546 ) -> BOOL; QueryDosDeviceA( lpDeviceName: LPCSTR, lpTargetPath: LPSTR, ucchMax: DWORD, ) -> DWORD1547 pub fn QueryDosDeviceA( 1548 lpDeviceName: LPCSTR, 1549 lpTargetPath: LPSTR, 1550 ucchMax: DWORD, 1551 ) -> DWORD; CreateFileTransactedA( lpFileName: LPCSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE, hTransaction: HANDLE, pusMiniVersion: PUSHORT, lpExtendedParameter: PVOID, ) -> HANDLE1552 pub fn CreateFileTransactedA( 1553 lpFileName: LPCSTR, 1554 dwDesiredAccess: DWORD, 1555 dwShareMode: DWORD, 1556 lpSecurityAttributes: LPSECURITY_ATTRIBUTES, 1557 dwCreationDisposition: DWORD, 1558 dwFlagsAndAttributes: DWORD, 1559 hTemplateFile: HANDLE, 1560 hTransaction: HANDLE, 1561 pusMiniVersion: PUSHORT, 1562 lpExtendedParameter: PVOID, 1563 ) -> HANDLE; CreateFileTransactedW( lpFileName: LPCWSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE, hTransaction: HANDLE, pusMiniVersion: PUSHORT, lpExtendedParameter: PVOID, ) -> HANDLE1564 pub fn CreateFileTransactedW( 1565 lpFileName: LPCWSTR, 1566 dwDesiredAccess: DWORD, 1567 dwShareMode: DWORD, 1568 lpSecurityAttributes: LPSECURITY_ATTRIBUTES, 1569 dwCreationDisposition: DWORD, 1570 dwFlagsAndAttributes: DWORD, 1571 hTemplateFile: HANDLE, 1572 hTransaction: HANDLE, 1573 pusMiniVersion: PUSHORT, 1574 lpExtendedParameter: PVOID, 1575 ) -> HANDLE; ReOpenFile( hOriginalFile: HANDLE, dwDesiredAccess: DWORD, dwShareMode: DWORD, dwFlags: DWORD, ) -> HANDLE1576 pub fn ReOpenFile( 1577 hOriginalFile: HANDLE, 1578 dwDesiredAccess: DWORD, 1579 dwShareMode: DWORD, 1580 dwFlags: DWORD, 1581 ) -> HANDLE; SetFileAttributesTransactedA( lpFileName: LPCSTR, dwFileAttributes: DWORD, hTransaction: HANDLE, ) -> BOOL1582 pub fn SetFileAttributesTransactedA( 1583 lpFileName: LPCSTR, 1584 dwFileAttributes: DWORD, 1585 hTransaction: HANDLE, 1586 ) -> BOOL; SetFileAttributesTransactedW( lpFileName: LPCWSTR, dwFileAttributes: DWORD, hTransaction: HANDLE, ) -> BOOL1587 pub fn SetFileAttributesTransactedW( 1588 lpFileName: LPCWSTR, 1589 dwFileAttributes: DWORD, 1590 hTransaction: HANDLE, 1591 ) -> BOOL; GetFileAttributesTransactedA( lpFileName: LPCSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID, hTransaction: HANDLE, ) -> BOOL1592 pub fn GetFileAttributesTransactedA( 1593 lpFileName: LPCSTR, 1594 fInfoLevelId: GET_FILEEX_INFO_LEVELS, 1595 lpFileInformation: LPVOID, 1596 hTransaction: HANDLE, 1597 ) -> BOOL; GetFileAttributesTransactedW( lpFileName: LPCWSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID, hTransaction: HANDLE, ) -> BOOL1598 pub fn GetFileAttributesTransactedW( 1599 lpFileName: LPCWSTR, 1600 fInfoLevelId: GET_FILEEX_INFO_LEVELS, 1601 lpFileInformation: LPVOID, 1602 hTransaction: HANDLE, 1603 ) -> BOOL; GetCompressedFileSizeTransactedA( lpFileName: LPCSTR, lpFileSizeHigh: LPDWORD, hTransaction: HANDLE, ) -> DWORD1604 pub fn GetCompressedFileSizeTransactedA( 1605 lpFileName: LPCSTR, 1606 lpFileSizeHigh: LPDWORD, 1607 hTransaction: HANDLE, 1608 ) -> DWORD; GetCompressedFileSizeTransactedW( lpFileName: LPCWSTR, lpFileSizeHigh: LPDWORD, hTransaction: HANDLE, )1609 pub fn GetCompressedFileSizeTransactedW( 1610 lpFileName: LPCWSTR, 1611 lpFileSizeHigh: LPDWORD, 1612 hTransaction: HANDLE, 1613 ); DeleteFileTransactedA( lpFileName: LPCSTR, hTransaction: HANDLE, ) -> BOOL1614 pub fn DeleteFileTransactedA( 1615 lpFileName: LPCSTR, 1616 hTransaction: HANDLE, 1617 ) -> BOOL; DeleteFileTransactedW( lpFileName: LPCWSTR, hTransaction: HANDLE, ) -> BOOL1618 pub fn DeleteFileTransactedW( 1619 lpFileName: LPCWSTR, 1620 hTransaction: HANDLE, 1621 ) -> BOOL; CheckNameLegalDOS8Dot3A( lpName: LPCSTR, lpOemName: LPSTR, OemNameSize: DWORD, pbNameContainsSpaces: PBOOL, pbNameLegal: PBOOL, ) -> BOOL1622 pub fn CheckNameLegalDOS8Dot3A( 1623 lpName: LPCSTR, 1624 lpOemName: LPSTR, 1625 OemNameSize: DWORD, 1626 pbNameContainsSpaces: PBOOL, 1627 pbNameLegal: PBOOL, 1628 ) -> BOOL; CheckNameLegalDOS8Dot3W( lpName: LPCWSTR, lpOemName: LPSTR, OemNameSize: DWORD, pbNameContainsSpaces: PBOOL, pbNameLegal: PBOOL, ) -> BOOL1629 pub fn CheckNameLegalDOS8Dot3W( 1630 lpName: LPCWSTR, 1631 lpOemName: LPSTR, 1632 OemNameSize: DWORD, 1633 pbNameContainsSpaces: PBOOL, 1634 pbNameLegal: PBOOL, 1635 ) -> BOOL; FindFirstFileTransactedA( lpFileName: LPCSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID, fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD, hTransaction: HANDLE, ) -> HANDLE1636 pub fn FindFirstFileTransactedA( 1637 lpFileName: LPCSTR, 1638 fInfoLevelId: FINDEX_INFO_LEVELS, 1639 lpFindFileData: LPVOID, 1640 fSearchOp: FINDEX_SEARCH_OPS, 1641 lpSearchFilter: LPVOID, 1642 dwAdditionalFlags: DWORD, 1643 hTransaction: HANDLE, 1644 ) -> HANDLE; FindFirstFileTransactedW( lpFileName: LPCWSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID, fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD, hTransaction: HANDLE, ) -> HANDLE1645 pub fn FindFirstFileTransactedW( 1646 lpFileName: LPCWSTR, 1647 fInfoLevelId: FINDEX_INFO_LEVELS, 1648 lpFindFileData: LPVOID, 1649 fSearchOp: FINDEX_SEARCH_OPS, 1650 lpSearchFilter: LPVOID, 1651 dwAdditionalFlags: DWORD, 1652 hTransaction: HANDLE, 1653 ) -> HANDLE; CopyFileA( lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, bFailIfExists: BOOL, ) -> BOOL1654 pub fn CopyFileA( 1655 lpExistingFileName: LPCSTR, 1656 lpNewFileName: LPCSTR, 1657 bFailIfExists: BOOL, 1658 ) -> BOOL; CopyFileW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, bFailIfExists: BOOL, ) -> BOOL1659 pub fn CopyFileW( 1660 lpExistingFileName: LPCWSTR, 1661 lpNewFileName: LPCWSTR, 1662 bFailIfExists: BOOL, 1663 ) -> BOOL; 1664 } 1665 FN!{stdcall LPPROGRESS_ROUTINE( 1666 TotalFileSize: LARGE_INTEGER, 1667 TotalBytesTransferred: LARGE_INTEGER, 1668 StreamSize: LARGE_INTEGER, 1669 StreamBytesTransferred: LARGE_INTEGER, 1670 dwStreamNumber: DWORD, 1671 dwCallbackReason: DWORD, 1672 hSourceFile: HANDLE, 1673 hDestinationFile: HANDLE, 1674 lpData: LPVOID, 1675 ) -> DWORD} 1676 extern "system" { CopyFileExA( lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD, ) -> BOOL1677 pub fn CopyFileExA( 1678 lpExistingFileName: LPCSTR, 1679 lpNewFileName: LPCSTR, 1680 lpProgressRoutine: LPPROGRESS_ROUTINE, 1681 lpData: LPVOID, 1682 pbCancel: LPBOOL, 1683 dwCopyFlags: DWORD, 1684 ) -> BOOL; CopyFileExW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD, ) -> BOOL1685 pub fn CopyFileExW( 1686 lpExistingFileName: LPCWSTR, 1687 lpNewFileName: LPCWSTR, 1688 lpProgressRoutine: LPPROGRESS_ROUTINE, 1689 lpData: LPVOID, 1690 pbCancel: LPBOOL, 1691 dwCopyFlags: DWORD, 1692 ) -> BOOL; CopyFileTransactedA( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD, hTransaction: HANDLE, ) -> BOOL1693 pub fn CopyFileTransactedA( 1694 lpExistingFileName: LPCWSTR, 1695 lpNewFileName: LPCWSTR, 1696 lpProgressRoutine: LPPROGRESS_ROUTINE, 1697 lpData: LPVOID, 1698 pbCancel: LPBOOL, 1699 dwCopyFlags: DWORD, 1700 hTransaction: HANDLE, 1701 ) -> BOOL; CopyFileTransactedW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD, hTransaction: HANDLE, ) -> BOOL1702 pub fn CopyFileTransactedW( 1703 lpExistingFileName: LPCWSTR, 1704 lpNewFileName: LPCWSTR, 1705 lpProgressRoutine: LPPROGRESS_ROUTINE, 1706 lpData: LPVOID, 1707 pbCancel: LPBOOL, 1708 dwCopyFlags: DWORD, 1709 hTransaction: HANDLE, 1710 ) -> BOOL; 1711 } 1712 ENUM!{enum COPYFILE2_MESSAGE_TYPE { 1713 COPYFILE2_CALLBACK_NONE = 0, 1714 COPYFILE2_CALLBACK_CHUNK_STARTED, 1715 COPYFILE2_CALLBACK_CHUNK_FINISHED, 1716 COPYFILE2_CALLBACK_STREAM_STARTED, 1717 COPYFILE2_CALLBACK_STREAM_FINISHED, 1718 COPYFILE2_CALLBACK_POLL_CONTINUE, 1719 COPYFILE2_CALLBACK_ERROR, 1720 COPYFILE2_CALLBACK_MAX, 1721 }} 1722 ENUM!{enum COPYFILE2_MESSAGE_ACTION { 1723 COPYFILE2_PROGRESS_CONTINUE = 0, 1724 COPYFILE2_PROGRESS_CANCEL, 1725 COPYFILE2_PROGRESS_STOP, 1726 COPYFILE2_PROGRESS_QUIET, 1727 COPYFILE2_PROGRESS_PAUSE, 1728 }} 1729 ENUM!{enum COPYFILE2_COPY_PHASE { 1730 COPYFILE2_PHASE_NONE = 0, 1731 COPYFILE2_PHASE_PREPARE_SOURCE, 1732 COPYFILE2_PHASE_PREPARE_DEST, 1733 COPYFILE2_PHASE_READ_SOURCE, 1734 COPYFILE2_PHASE_WRITE_DESTINATION, 1735 COPYFILE2_PHASE_SERVER_COPY, 1736 COPYFILE2_PHASE_NAMEGRAFT_COPY, 1737 COPYFILE2_PHASE_MAX, 1738 }} 1739 STRUCT!{struct COPYFILE2_MESSAGE_ChunkStarted { 1740 dwStreamNumber: DWORD, 1741 dwReserved: DWORD, 1742 hSourceFile: HANDLE, 1743 hDestinationFile: HANDLE, 1744 uliChunkNumber: ULARGE_INTEGER, 1745 uliChunkSize: ULARGE_INTEGER, 1746 uliStreamSize: ULARGE_INTEGER, 1747 uliTotalFileSize: ULARGE_INTEGER, 1748 }} 1749 STRUCT!{struct COPYFILE2_MESSAGE_ChunkFinished { 1750 dwStreamNumber: DWORD, 1751 dwFlags: DWORD, 1752 hSourceFile: HANDLE, 1753 hDestinationFile: HANDLE, 1754 uliChunkNumber: ULARGE_INTEGER, 1755 uliChunkSize: ULARGE_INTEGER, 1756 uliStreamSize: ULARGE_INTEGER, 1757 uliStreamBytesTransferred: ULARGE_INTEGER, 1758 uliTotalFileSize: ULARGE_INTEGER, 1759 uliTotalBytesTransferred: ULARGE_INTEGER, 1760 }} 1761 STRUCT!{struct COPYFILE2_MESSAGE_StreamStarted { 1762 dwStreamNumber: DWORD, 1763 dwReserved: DWORD, 1764 hSourceFile: HANDLE, 1765 hDestinationFile: HANDLE, 1766 uliStreamSize: ULARGE_INTEGER, 1767 uliTotalFileSize: ULARGE_INTEGER, 1768 }} 1769 STRUCT!{struct COPYFILE2_MESSAGE_StreamFinished { 1770 dwStreamNumber: DWORD, 1771 dwReserved: DWORD, 1772 hSourceFile: HANDLE, 1773 hDestinationFile: HANDLE, 1774 uliStreamSize: ULARGE_INTEGER, 1775 uliStreamBytesTransferred: ULARGE_INTEGER, 1776 uliTotalFileSize: ULARGE_INTEGER, 1777 uliTotalBytesTransferred: ULARGE_INTEGER, 1778 }} 1779 STRUCT!{struct COPYFILE2_MESSAGE_PollContinue { 1780 dwReserved: DWORD, 1781 }} 1782 STRUCT!{struct COPYFILE2_MESSAGE_Error { 1783 CopyPhase: COPYFILE2_COPY_PHASE, 1784 dwStreamNumber: DWORD, 1785 hrFailure: HRESULT, 1786 dwReserved: DWORD, 1787 uliChunkNumber: ULARGE_INTEGER, 1788 uliStreamSize: ULARGE_INTEGER, 1789 uliStreamBytesTransferred: ULARGE_INTEGER, 1790 uliTotalFileSize: ULARGE_INTEGER, 1791 uliTotalBytesTransferred: ULARGE_INTEGER, 1792 }} 1793 UNION!{union COPYFILE2_MESSAGE_Info { 1794 [u64; 8] [u64; 9], 1795 ChunkStarted ChunkStarted_mut: COPYFILE2_MESSAGE_ChunkStarted, 1796 ChunkFinished ChunkFinished_mut: COPYFILE2_MESSAGE_ChunkFinished, 1797 StreamStarted StreamStarted_mut: COPYFILE2_MESSAGE_StreamStarted, 1798 StreamFinished StreamFinished_mut: COPYFILE2_MESSAGE_StreamFinished, 1799 PollContinue PollContinue_mut: COPYFILE2_MESSAGE_PollContinue, 1800 Error Error_mut: COPYFILE2_MESSAGE_Error, 1801 }} 1802 STRUCT!{struct COPYFILE2_MESSAGE { 1803 Type: COPYFILE2_MESSAGE_TYPE, 1804 dwPadding: DWORD, 1805 Info: COPYFILE2_MESSAGE_Info, 1806 }} 1807 FN!{stdcall PCOPYFILE2_PROGRESS_ROUTINE( 1808 pMessage: *const COPYFILE2_MESSAGE, 1809 pvCallbackContext: PVOID, 1810 ) -> COPYFILE2_MESSAGE_ACTION} 1811 STRUCT!{struct COPYFILE2_EXTENDED_PARAMETERS { 1812 dwSize: DWORD, 1813 dwCopyFlags: DWORD, 1814 pfCancel: *mut BOOL, 1815 pProgressRoutine: PCOPYFILE2_PROGRESS_ROUTINE, 1816 pvCallbackContext: PVOID, 1817 }} 1818 extern "system" { CopyFile2( pwszExistingFileName: PCWSTR, pwszNewFileName: PCWSTR, pExtendedParameters: *mut COPYFILE2_EXTENDED_PARAMETERS, ) -> HRESULT1819 pub fn CopyFile2( 1820 pwszExistingFileName: PCWSTR, 1821 pwszNewFileName: PCWSTR, 1822 pExtendedParameters: *mut COPYFILE2_EXTENDED_PARAMETERS, 1823 ) -> HRESULT; MoveFileA( lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, ) -> BOOL1824 pub fn MoveFileA( 1825 lpExistingFileName: LPCSTR, 1826 lpNewFileName: LPCSTR, 1827 ) -> BOOL; MoveFileW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, ) -> BOOL1828 pub fn MoveFileW( 1829 lpExistingFileName: LPCWSTR, 1830 lpNewFileName: LPCWSTR, 1831 ) -> BOOL; MoveFileExA( lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, dwFlags: DWORD, ) -> BOOL1832 pub fn MoveFileExA( 1833 lpExistingFileName: LPCSTR, 1834 lpNewFileName: LPCSTR, 1835 dwFlags: DWORD, 1836 ) -> BOOL; MoveFileExW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, dwFlags: DWORD, ) -> BOOL1837 pub fn MoveFileExW( 1838 lpExistingFileName: LPCWSTR, 1839 lpNewFileName: LPCWSTR, 1840 dwFlags: DWORD, 1841 ) -> BOOL; MoveFileWithProgressA( lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD, ) -> BOOL1842 pub fn MoveFileWithProgressA( 1843 lpExistingFileName: LPCSTR, 1844 lpNewFileName: LPCSTR, 1845 lpProgressRoutine: LPPROGRESS_ROUTINE, 1846 lpData: LPVOID, 1847 dwFlags: DWORD, 1848 ) -> BOOL; MoveFileWithProgressW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD, ) -> BOOL1849 pub fn MoveFileWithProgressW( 1850 lpExistingFileName: LPCWSTR, 1851 lpNewFileName: LPCWSTR, 1852 lpProgressRoutine: LPPROGRESS_ROUTINE, 1853 lpData: LPVOID, 1854 dwFlags: DWORD, 1855 ) -> BOOL; MoveFileTransactedA( lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD, hTransaction: HANDLE, ) -> BOOL1856 pub fn MoveFileTransactedA( 1857 lpExistingFileName: LPCSTR, 1858 lpNewFileName: LPCSTR, 1859 lpProgressRoutine: LPPROGRESS_ROUTINE, 1860 lpData: LPVOID, 1861 dwFlags: DWORD, 1862 hTransaction: HANDLE, 1863 ) -> BOOL; MoveFileTransactedW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD, hTransaction: HANDLE, ) -> BOOL1864 pub fn MoveFileTransactedW( 1865 lpExistingFileName: LPCWSTR, 1866 lpNewFileName: LPCWSTR, 1867 lpProgressRoutine: LPPROGRESS_ROUTINE, 1868 lpData: LPVOID, 1869 dwFlags: DWORD, 1870 hTransaction: HANDLE, 1871 ) -> BOOL; 1872 } 1873 pub const MOVEFILE_REPLACE_EXISTING: DWORD = 0x00000001; 1874 pub const MOVEFILE_COPY_ALLOWED: DWORD = 0x00000002; 1875 pub const MOVEFILE_DELAY_UNTIL_REBOOT: DWORD = 0x00000004; 1876 pub const MOVEFILE_WRITE_THROUGH: DWORD = 0x00000008; 1877 pub const MOVEFILE_CREATE_HARDLINK: DWORD = 0x00000010; 1878 pub const MOVEFILE_FAIL_IF_NOT_TRACKABLE: DWORD = 0x00000020; 1879 extern "system" { ReplaceFileA( lpReplacedFileName: LPCSTR, lpReplacementFileName: LPCSTR, lpBackupFileName: LPCSTR, dwReplaceFlags: DWORD, lpExclude: LPVOID, lpReserved: LPVOID, )1880 pub fn ReplaceFileA( 1881 lpReplacedFileName: LPCSTR, 1882 lpReplacementFileName: LPCSTR, 1883 lpBackupFileName: LPCSTR, 1884 dwReplaceFlags: DWORD, 1885 lpExclude: LPVOID, 1886 lpReserved: LPVOID, 1887 ); ReplaceFileW( lpReplacedFileName: LPCWSTR, lpReplacementFileName: LPCWSTR, lpBackupFileName: LPCWSTR, dwReplaceFlags: DWORD, lpExclude: LPVOID, lpReserved: LPVOID, )1888 pub fn ReplaceFileW( 1889 lpReplacedFileName: LPCWSTR, 1890 lpReplacementFileName: LPCWSTR, 1891 lpBackupFileName: LPCWSTR, 1892 dwReplaceFlags: DWORD, 1893 lpExclude: LPVOID, 1894 lpReserved: LPVOID, 1895 ); CreateHardLinkA( lpFileName: LPCSTR, lpExistingFileName: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> BOOL1896 pub fn CreateHardLinkA( 1897 lpFileName: LPCSTR, 1898 lpExistingFileName: LPCSTR, 1899 lpSecurityAttributes: LPSECURITY_ATTRIBUTES, 1900 ) -> BOOL; CreateHardLinkW( lpFileName: LPCWSTR, lpExistingFileName: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> BOOL1901 pub fn CreateHardLinkW( 1902 lpFileName: LPCWSTR, 1903 lpExistingFileName: LPCWSTR, 1904 lpSecurityAttributes: LPSECURITY_ATTRIBUTES, 1905 ) -> BOOL; CreateHardLinkTransactedA( lpFileName: LPCSTR, lpExistingFileName: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE, ) -> BOOL1906 pub fn CreateHardLinkTransactedA( 1907 lpFileName: LPCSTR, 1908 lpExistingFileName: LPCSTR, 1909 lpSecurityAttributes: LPSECURITY_ATTRIBUTES, 1910 hTransaction: HANDLE, 1911 ) -> BOOL; CreateHardLinkTransactedW( lpFileName: LPCWSTR, lpExistingFileName: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE, )1912 pub fn CreateHardLinkTransactedW( 1913 lpFileName: LPCWSTR, 1914 lpExistingFileName: LPCWSTR, 1915 lpSecurityAttributes: LPSECURITY_ATTRIBUTES, 1916 hTransaction: HANDLE, 1917 ); FindFirstStreamTransactedW( lpFileName: LPCWSTR, InfoLevel: STREAM_INFO_LEVELS, lpFindStreamData: LPVOID, dwFlags: DWORD, hTransaction: HANDLE, ) -> HANDLE1918 pub fn FindFirstStreamTransactedW( 1919 lpFileName: LPCWSTR, 1920 InfoLevel: STREAM_INFO_LEVELS, 1921 lpFindStreamData: LPVOID, 1922 dwFlags: DWORD, 1923 hTransaction: HANDLE, 1924 ) -> HANDLE; FindFirstFileNameTransactedW( lpFileName: LPCWSTR, dwFlags: DWORD, StringLength: LPDWORD, LinkName: PWSTR, hTransaction: HANDLE, ) -> HANDLE1925 pub fn FindFirstFileNameTransactedW( 1926 lpFileName: LPCWSTR, 1927 dwFlags: DWORD, 1928 StringLength: LPDWORD, 1929 LinkName: PWSTR, 1930 hTransaction: HANDLE, 1931 ) -> HANDLE; CreateNamedPipeA( lpName: LPCSTR, dwOpenMode: DWORD, dwPipeMode: DWORD, nMaxInstances: DWORD, nOutBufferSize: DWORD, nInBufferSize: DWORD, nDefaultTimeOut: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> HANDLE1932 pub fn CreateNamedPipeA( 1933 lpName: LPCSTR, 1934 dwOpenMode: DWORD, 1935 dwPipeMode: DWORD, 1936 nMaxInstances: DWORD, 1937 nOutBufferSize: DWORD, 1938 nInBufferSize: DWORD, 1939 nDefaultTimeOut: DWORD, 1940 lpSecurityAttributes: LPSECURITY_ATTRIBUTES, 1941 ) -> HANDLE; GetNamedPipeHandleStateA( hNamedPipe: HANDLE, lpState: LPDWORD, lpCurInstances: LPDWORD, lpMaxCollectionCount: LPDWORD, lpCollectDataTimeout: LPDWORD, lpUserName: LPSTR, nMaxUserNameSize: DWORD, ) -> BOOL1942 pub fn GetNamedPipeHandleStateA( 1943 hNamedPipe: HANDLE, 1944 lpState: LPDWORD, 1945 lpCurInstances: LPDWORD, 1946 lpMaxCollectionCount: LPDWORD, 1947 lpCollectDataTimeout: LPDWORD, 1948 lpUserName: LPSTR, 1949 nMaxUserNameSize: DWORD, 1950 ) -> BOOL; CallNamedPipeA( lpNamedPipeName: LPCSTR, lpInBuffer: LPVOID, nInBufferSize: DWORD, lpOutBuffer: LPVOID, nOutBufferSize: DWORD, lpBytesRead: LPDWORD, nTimeOut: DWORD, ) -> BOOL1951 pub fn CallNamedPipeA( 1952 lpNamedPipeName: LPCSTR, 1953 lpInBuffer: LPVOID, 1954 nInBufferSize: DWORD, 1955 lpOutBuffer: LPVOID, 1956 nOutBufferSize: DWORD, 1957 lpBytesRead: LPDWORD, 1958 nTimeOut: DWORD, 1959 ) -> BOOL; WaitNamedPipeA( lpNamedPipeName: LPCSTR, nTimeOut: DWORD, ) -> BOOL1960 pub fn WaitNamedPipeA( 1961 lpNamedPipeName: LPCSTR, 1962 nTimeOut: DWORD, 1963 ) -> BOOL; GetNamedPipeClientComputerNameA( Pipe: HANDLE, ClientComputerName: LPSTR, ClientComputerNameLength: ULONG, ) -> BOOL1964 pub fn GetNamedPipeClientComputerNameA( 1965 Pipe: HANDLE, 1966 ClientComputerName: LPSTR, 1967 ClientComputerNameLength: ULONG, 1968 ) -> BOOL; GetNamedPipeClientProcessId( Pipe: HANDLE, ClientProcessId: PULONG, ) -> BOOL1969 pub fn GetNamedPipeClientProcessId( 1970 Pipe: HANDLE, 1971 ClientProcessId: PULONG, 1972 ) -> BOOL; GetNamedPipeClientSessionId( Pipe: HANDLE, ClientSessionId: PULONG, ) -> BOOL1973 pub fn GetNamedPipeClientSessionId( 1974 Pipe: HANDLE, 1975 ClientSessionId: PULONG, 1976 ) -> BOOL; GetNamedPipeServerProcessId( Pipe: HANDLE, ServerProcessId: PULONG, ) -> BOOL1977 pub fn GetNamedPipeServerProcessId( 1978 Pipe: HANDLE, 1979 ServerProcessId: PULONG, 1980 ) -> BOOL; GetNamedPipeServerSessionId( Pipe: HANDLE, ServerSessionId: PULONG, ) -> BOOL1981 pub fn GetNamedPipeServerSessionId( 1982 Pipe: HANDLE, 1983 ServerSessionId: PULONG, 1984 ) -> BOOL; SetVolumeLabelA( lpRootPathName: LPCSTR, lpVolumeName: LPCSTR, ) -> BOOL1985 pub fn SetVolumeLabelA( 1986 lpRootPathName: LPCSTR, 1987 lpVolumeName: LPCSTR, 1988 ) -> BOOL; SetVolumeLabelW( lpRootPathName: LPCWSTR, lpVolumeName: LPCWSTR, ) -> BOOL1989 pub fn SetVolumeLabelW( 1990 lpRootPathName: LPCWSTR, 1991 lpVolumeName: LPCWSTR, 1992 ) -> BOOL; SetFileBandwidthReservation( hFile: HANDLE, nPeriodMilliseconds: DWORD, nBytesPerPeriod: DWORD, bDiscardable: BOOL, lpTransferSize: LPDWORD, lpNumOutstandingRequests: LPDWORD, ) -> BOOL1993 pub fn SetFileBandwidthReservation( 1994 hFile: HANDLE, 1995 nPeriodMilliseconds: DWORD, 1996 nBytesPerPeriod: DWORD, 1997 bDiscardable: BOOL, 1998 lpTransferSize: LPDWORD, 1999 lpNumOutstandingRequests: LPDWORD, 2000 ) -> BOOL; GetFileBandwidthReservation( hFile: HANDLE, lpPeriodMilliseconds: LPDWORD, lpBytesPerPeriod: LPDWORD, pDiscardable: LPBOOL, lpTransferSize: LPDWORD, lpNumOutstandingRequests: LPDWORD, ) -> BOOL2001 pub fn GetFileBandwidthReservation( 2002 hFile: HANDLE, 2003 lpPeriodMilliseconds: LPDWORD, 2004 lpBytesPerPeriod: LPDWORD, 2005 pDiscardable: LPBOOL, 2006 lpTransferSize: LPDWORD, 2007 lpNumOutstandingRequests: LPDWORD, 2008 ) -> BOOL; 2009 // pub fn ClearEventLogA(); 2010 // pub fn ClearEventLogW(); 2011 // pub fn BackupEventLogA(); 2012 // pub fn BackupEventLogW(); 2013 // pub fn CloseEventLog(); DeregisterEventSource( hEventLog: HANDLE, ) -> BOOL2014 pub fn DeregisterEventSource( 2015 hEventLog: HANDLE, 2016 ) -> BOOL; 2017 // pub fn NotifyChangeEventLog(); 2018 // pub fn GetNumberOfEventLogRecords(); 2019 // pub fn GetOldestEventLogRecord(); 2020 // pub fn OpenEventLogA(); 2021 // pub fn OpenEventLogW(); RegisterEventSourceA( lpUNCServerName: LPCSTR, lpSourceName: LPCSTR, ) -> HANDLE2022 pub fn RegisterEventSourceA( 2023 lpUNCServerName: LPCSTR, 2024 lpSourceName: LPCSTR, 2025 ) -> HANDLE; RegisterEventSourceW( lpUNCServerName: LPCWSTR, lpSourceName: LPCWSTR, ) -> HANDLE2026