// Licensed under the Apache License, Version 2.0 // or the MIT license // , at your option. // All files in the project carrying such notice may not be copied, modified, or distributed // except according to those terms. //! This module defines the 32-Bit Windows Base APIs use ctypes::{c_char, c_int, c_long, c_void}; use shared::basetsd::{ DWORD64, DWORD_PTR, LONG_PTR, PDWORD64, PDWORD_PTR, PSIZE_T, PULONG_PTR, SIZE_T, UINT_PTR, ULONG_PTR, }; use shared::guiddef::GUID; use shared::minwindef::{ ATOM, BOOL, BYTE, DWORD, FARPROC, FILETIME, HFILE, HGLOBAL, HLOCAL, HMODULE, HRSRC, LPBOOL, LPBYTE, LPCVOID, LPDWORD, LPFILETIME, LPVOID, LPWORD, PBOOL, PDWORD, PUCHAR, PULONG, PUSHORT, UCHAR, UINT, ULONG, USHORT, WORD, }; use shared::windef::HWND; use um::cfgmgr32::MAX_PROFILE_LEN; use um::fileapi::STREAM_INFO_LEVELS; use um::libloaderapi::{ ENUMRESLANGPROCA, ENUMRESLANGPROCW, ENUMRESNAMEPROCA, ENUMRESTYPEPROCA, ENUMRESTYPEPROCW, }; use um::minwinbase::{ FILE_INFO_BY_HANDLE_CLASS, FINDEX_INFO_LEVELS, FINDEX_SEARCH_OPS, GET_FILEEX_INFO_LEVELS, LPOVERLAPPED, LPOVERLAPPED_COMPLETION_ROUTINE, LPSECURITY_ATTRIBUTES, PREASON_CONTEXT, }; use um::processthreadsapi::{ LPPROCESS_INFORMATION, LPPROC_THREAD_ATTRIBUTE_LIST, LPSTARTUPINFOA, LPSTARTUPINFOW, STARTUPINFOA, STARTUPINFOW, }; use um::winnt::{ BOOLEAN, CHAR, DWORDLONG, EXECUTION_STATE, FILE_ID_128, HANDLE, HRESULT, INT, LANGID, LARGE_INTEGER, LATENCY_TIME, LONG, LPCCH, LPCH, LPCSTR, LPCWSTR, LPOSVERSIONINFOEXA, LPOSVERSIONINFOEXW, LPSTR, LPWSTR, MAXLONG, PBOOLEAN, PCONTEXT, PCWSTR, PFIRMWARE_TYPE, PHANDLE, PIO_COUNTERS, PJOB_SET_ARRAY, PLUID, POWER_REQUEST_TYPE, PPERFORMANCE_DATA, PPROCESSOR_NUMBER, PQUOTA_LIMITS, PRTL_UMS_SCHEDULER_ENTRY_POINT, PSECURE_MEMORY_CACHE_CALLBACK, PSID, PSID_NAME_USE, PULONGLONG, PVOID, PWOW64_CONTEXT, PWOW64_LDT_ENTRY, PWSTR, RTL_UMS_THREAD_INFO_CLASS, STATUS_ABANDONED_WAIT_0, STATUS_USER_APC, STATUS_WAIT_0, SecurityAnonymous, SecurityDelegation, SecurityIdentification, SecurityImpersonation, THREAD_BASE_PRIORITY_IDLE, THREAD_BASE_PRIORITY_LOWRT, THREAD_BASE_PRIORITY_MAX, THREAD_BASE_PRIORITY_MIN, ULARGE_INTEGER, VOID, WAITORTIMERCALLBACK, WCHAR, WOW64_CONTEXT, }; #[cfg(target_arch = "x86")] use um::winnt::PLDT_ENTRY; use vc::vadefs::va_list; pub const FILE_BEGIN: DWORD = 0; pub const FILE_CURRENT: DWORD = 1; pub const FILE_END: DWORD = 2; pub const WAIT_FAILED: DWORD = 0xFFFFFFFF; pub const WAIT_OBJECT_0: DWORD = STATUS_WAIT_0 as u32; pub const WAIT_ABANDONED: DWORD = STATUS_ABANDONED_WAIT_0 as u32; pub const WAIT_ABANDONED_0: DWORD = STATUS_ABANDONED_WAIT_0 as u32; pub const WAIT_IO_COMPLETION: DWORD = STATUS_USER_APC as u32; pub const FILE_FLAG_WRITE_THROUGH: DWORD = 0x80000000; pub const FILE_FLAG_OVERLAPPED: DWORD = 0x40000000; pub const FILE_FLAG_NO_BUFFERING: DWORD = 0x20000000; pub const FILE_FLAG_RANDOM_ACCESS: DWORD = 0x10000000; pub const FILE_FLAG_SEQUENTIAL_SCAN: DWORD = 0x08000000; pub const FILE_FLAG_DELETE_ON_CLOSE: DWORD = 0x04000000; pub const FILE_FLAG_BACKUP_SEMANTICS: DWORD = 0x02000000; pub const FILE_FLAG_POSIX_SEMANTICS: DWORD = 0x01000000; pub const FILE_FLAG_SESSION_AWARE: DWORD = 0x00800000; pub const FILE_FLAG_OPEN_REPARSE_POINT: DWORD = 0x00200000; pub const FILE_FLAG_OPEN_NO_RECALL: DWORD = 0x00100000; pub const FILE_FLAG_FIRST_PIPE_INSTANCE: DWORD = 0x00080000; pub const FILE_FLAG_OPEN_REQUIRING_OPLOCK: DWORD = 0x00040000; pub const PROGRESS_CONTINUE: DWORD = 0; pub const PROGRESS_CANCEL: DWORD = 1; pub const PROGRESS_STOP: DWORD = 2; pub const PROGRESS_QUIET: DWORD = 3; pub const CALLBACK_CHUNK_FINISHED: DWORD = 0x00000000; pub const CALLBACK_STREAM_SWITCH: DWORD = 0x00000001; pub const COPY_FILE_FAIL_IF_EXISTS: DWORD = 0x00000001; pub const COPY_FILE_RESTARTABLE: DWORD = 0x00000002; pub const COPY_FILE_OPEN_SOURCE_FOR_WRITE: DWORD = 0x00000004; pub const COPY_FILE_ALLOW_DECRYPTED_DESTINATION: DWORD = 0x00000008; pub const COPY_FILE_COPY_SYMLINK: DWORD = 0x00000800; pub const COPY_FILE_NO_BUFFERING: DWORD = 0x00001000; pub const COPY_FILE_REQUEST_SECURITY_PRIVILEGES: DWORD = 0x00002000; pub const COPY_FILE_RESUME_FROM_PAUSE: DWORD = 0x00004000; pub const COPY_FILE_NO_OFFLOAD: DWORD = 0x00040000; pub const COPY_FILE_IGNORE_EDP_BLOCK: DWORD = 0x00400000; pub const COPY_FILE_IGNORE_SOURCE_ENCRYPTION: DWORD = 0x00800000; pub const REPLACEFILE_WRITE_THROUGH: DWORD = 0x00000001; pub const REPLACEFILE_IGNORE_MERGE_ERRORS: DWORD = 0x00000002; pub const REPLACEFILE_IGNORE_ACL_ERRORS: DWORD = 0x00000004; pub const PIPE_ACCESS_INBOUND: DWORD = 0x00000001; pub const PIPE_ACCESS_OUTBOUND: DWORD = 0x00000002; pub const PIPE_ACCESS_DUPLEX: DWORD = 0x00000003; pub const PIPE_CLIENT_END: DWORD = 0x00000000; pub const PIPE_SERVER_END: DWORD = 0x00000001; pub const PIPE_WAIT: DWORD = 0x00000000; pub const PIPE_NOWAIT: DWORD = 0x00000001; pub const PIPE_READMODE_BYTE: DWORD = 0x00000000; pub const PIPE_READMODE_MESSAGE: DWORD = 0x00000002; pub const PIPE_TYPE_BYTE: DWORD = 0x00000000; pub const PIPE_TYPE_MESSAGE: DWORD = 0x00000004; pub const PIPE_ACCEPT_REMOTE_CLIENTS: DWORD = 0x00000000; pub const PIPE_REJECT_REMOTE_CLIENTS: DWORD = 0x00000008; pub const PIPE_UNLIMITED_INSTANCES: DWORD = 255; pub const SECURITY_ANONYMOUS: DWORD = SecurityAnonymous << 16; pub const SECURITY_IDENTIFICATION: DWORD = SecurityIdentification << 16; pub const SECURITY_IMPERSONATION: DWORD = SecurityImpersonation << 16; pub const SECURITY_DELEGATION: DWORD = SecurityDelegation << 16; pub const SECURITY_CONTEXT_TRACKING: DWORD = 0x00040000; pub const SECURITY_EFFECTIVE_ONLY: DWORD = 0x00080000; pub const SECURITY_SQOS_PRESENT: DWORD = 0x00100000; pub const SECURITY_VALID_SQOS_FLAGS: DWORD = 0x001F0000; FN!{stdcall PFIBER_START_ROUTINE( lpFiberParameter: LPVOID, ) -> ()} pub type LPFIBER_START_ROUTINE = PFIBER_START_ROUTINE; FN!{stdcall PFIBER_CALLOUT_ROUTINE( lpParameter: LPVOID, ) -> LPVOID} // FAIL_FAST_* #[cfg(target_arch = "x86")] pub type LPLDT_ENTRY = PLDT_ENTRY; #[cfg(not(target_arch = "x86"))] pub type LPLDT_ENTRY = LPVOID; // TODO - fix this for 32-bit //SP_SERIALCOMM //PST_* // PCF_* // SP_* // BAUD_* // DATABITS_* // STOPBITS_* // PARITY_* STRUCT!{struct COMMPROP { wPacketLength: WORD, wPacketVersion: WORD, dwServiceMask: DWORD, dwReserved1: DWORD, dwMaxTxQueue: DWORD, dwMaxRxQueue: DWORD, dwMaxBaud: DWORD, dwProvSubType: DWORD, dwProvCapabilities: DWORD, dwSettableParams: DWORD, dwSettableBaud: DWORD, wSettableData: WORD, wSettableStopParity: WORD, dwCurrentTxQueue: DWORD, dwCurrentRxQueue: DWORD, dwProvSpec1: DWORD, dwProvSpec2: DWORD, wcProvChar: [WCHAR; 1], }} pub type LPCOMMPROP = *mut COMMPROP; STRUCT!{struct COMSTAT { BitFields: DWORD, cbInQue: DWORD, cbOutQue: DWORD, }} BITFIELD!{COMSTAT BitFields: DWORD [ fCtsHold set_fCtsHold[0..1], fDsrHold set_fDsrHold[1..2], fRlsdHold set_fRlsdHold[2..3], fXoffHold set_fXoffHold[3..4], fXoffSent set_fXoffSent[4..5], fEof set_fEof[5..6], fTxim set_fTxim[6..7], fReserved set_fReserved[7..32], ]} pub type LPCOMSTAT = *mut COMSTAT; pub const DTR_CONTROL_DISABLE: DWORD = 0x00; pub const DTR_CONTROL_ENABLE: DWORD = 0x01; pub const DTR_CONTROL_HANDSHAKE: DWORD = 0x02; pub const RTS_CONTROL_DISABLE: DWORD = 0x00; pub const RTS_CONTROL_ENABLE: DWORD = 0x01; pub const RTS_CONTROL_HANDSHAKE: DWORD = 0x02; pub const RTS_CONTROL_TOGGLE: DWORD = 0x03; STRUCT!{struct DCB { DCBlength: DWORD, BaudRate: DWORD, BitFields: DWORD, wReserved: WORD, XonLim: WORD, XoffLim: WORD, ByteSize: BYTE, Parity: BYTE, StopBits: BYTE, XonChar: c_char, XoffChar: c_char, ErrorChar: c_char, EofChar: c_char, EvtChar: c_char, wReserved1: WORD, }} BITFIELD!{DCB BitFields: DWORD [ fBinary set_fBinary[0..1], fParity set_fParity[1..2], fOutxCtsFlow set_fOutxCtsFlow[2..3], fOutxDsrFlow set_fOutxDsrFlow[3..4], fDtrControl set_fDtrControl[4..6], fDsrSensitivity set_fDsrSensitivity[6..7], fTXContinueOnXoff set_fTXContinueOnXoff[7..8], fOutX set_fOutX[8..9], fInX set_fInX[9..10], fErrorChar set_fErrorChar[10..11], fNull set_fNull[11..12], fRtsControl set_fRtsControl[12..14], fAbortOnError set_fAbortOnError[14..15], fDummy2 set_fDummy2[15..32], ]} pub type LPDCB = *mut DCB; STRUCT!{struct COMMTIMEOUTS { ReadIntervalTimeout: DWORD, ReadTotalTimeoutMultiplier: DWORD, ReadTotalTimeoutConstant: DWORD, WriteTotalTimeoutMultiplier: DWORD, WriteTotalTimeoutConstant: DWORD, }} pub type LPCOMMTIMEOUTS = *mut COMMTIMEOUTS; STRUCT!{struct COMMCONFIG { dwSize: DWORD, wVersion: WORD, wReserved: WORD, dcb: DCB, dwProviderSubType: DWORD, dwProviderOffset: DWORD, dwProviderSize: DWORD, wcProviderData: [WCHAR; 1], }} pub type LPCOMMCONFIG = *mut COMMCONFIG; pub const GMEM_FIXED: UINT = 0x0000; pub const GMEM_MOVEABLE: UINT = 0x0002; pub const GMEM_NOCOMPACT: UINT = 0x0010; pub const GMEM_NODISCARD: UINT = 0x0020; pub const GMEM_ZEROINIT: UINT = 0x0040; pub const GMEM_MODIFY: UINT = 0x0080; pub const GMEM_DISCARDABLE: UINT = 0x0100; pub const GMEM_NOT_BANKED: UINT = 0x1000; pub const GMEM_SHARE: UINT = 0x2000; pub const GMEM_DDESHARE: UINT = 0x2000; pub const GMEM_NOTIFY: UINT = 0x4000; pub const GMEM_LOWER: UINT = GMEM_NOT_BANKED; pub const GMEM_VALID_FLAGS: UINT = 0x7F72; pub const GMEM_INVALID_HANDLE: UINT = 0x8000; pub const GHND: UINT = GMEM_MOVEABLE | GMEM_ZEROINIT; pub const GPTR: UINT = GMEM_FIXED | GMEM_ZEROINIT; pub const GMEM_DISCARDED: UINT = 0x4000; pub const GMEM_LOCKCOUNT: UINT = 0x00FF; STRUCT!{struct MEMORYSTATUS { dwLength: DWORD, dwMemoryLoad: DWORD, dwTotalPhys: SIZE_T, dwAvailPhys: SIZE_T, dwTotalPageFile: SIZE_T, dwAvailPageFile: SIZE_T, dwTotalVirtual: SIZE_T, dwAvailVirtual: SIZE_T, }} pub type LPMEMORYSTATUS = *mut MEMORYSTATUS; // NUMA_NO_PREFERRED_NODE pub const DEBUG_PROCESS: DWORD = 0x00000001; pub const DEBUG_ONLY_THIS_PROCESS: DWORD = 0x00000002; pub const CREATE_SUSPENDED: DWORD = 0x00000004; pub const DETACHED_PROCESS: DWORD = 0x00000008; pub const CREATE_NEW_CONSOLE: DWORD = 0x00000010; pub const NORMAL_PRIORITY_CLASS: DWORD = 0x00000020; pub const IDLE_PRIORITY_CLASS: DWORD = 0x00000040; pub const HIGH_PRIORITY_CLASS: DWORD = 0x00000080; pub const REALTIME_PRIORITY_CLASS: DWORD = 0x00000100; pub const CREATE_NEW_PROCESS_GROUP: DWORD = 0x00000200; pub const CREATE_UNICODE_ENVIRONMENT: DWORD = 0x00000400; pub const CREATE_SEPARATE_WOW_VDM: DWORD = 0x00000800; pub const CREATE_SHARED_WOW_VDM: DWORD = 0x00001000; pub const CREATE_FORCEDOS: DWORD = 0x00002000; pub const BELOW_NORMAL_PRIORITY_CLASS: DWORD = 0x00004000; pub const ABOVE_NORMAL_PRIORITY_CLASS: DWORD = 0x00008000; pub const INHERIT_PARENT_AFFINITY: DWORD = 0x00010000; pub const INHERIT_CALLER_PRIORITY: DWORD = 0x00020000; pub const CREATE_PROTECTED_PROCESS: DWORD = 0x00040000; pub const EXTENDED_STARTUPINFO_PRESENT: DWORD = 0x00080000; pub const PROCESS_MODE_BACKGROUND_BEGIN: DWORD = 0x00100000; pub const PROCESS_MODE_BACKGROUND_END: DWORD = 0x00200000; pub const CREATE_BREAKAWAY_FROM_JOB: DWORD = 0x01000000; pub const CREATE_PRESERVE_CODE_AUTHZ_LEVEL: DWORD = 0x02000000; pub const CREATE_DEFAULT_ERROR_MODE: DWORD = 0x04000000; pub const CREATE_NO_WINDOW: DWORD = 0x08000000; pub const PROFILE_USER: DWORD = 0x10000000; pub const PROFILE_KERNEL: DWORD = 0x20000000; pub const PROFILE_SERVER: DWORD = 0x40000000; pub const CREATE_IGNORE_SYSTEM_DEFAULT: DWORD = 0x80000000; // STACK_SIZE_PARAM_IS_A_RESERVATION pub const THREAD_PRIORITY_LOWEST: DWORD = THREAD_BASE_PRIORITY_MIN; pub const THREAD_PRIORITY_BELOW_NORMAL: DWORD = THREAD_PRIORITY_LOWEST + 1; pub const THREAD_PRIORITY_NORMAL: DWORD = 0; pub const THREAD_PRIORITY_HIGHEST: DWORD = THREAD_BASE_PRIORITY_MAX; pub const THREAD_PRIORITY_ABOVE_NORMAL: DWORD = THREAD_PRIORITY_HIGHEST - 1; pub const THREAD_PRIORITY_ERROR_RETURN: DWORD = MAXLONG as u32; pub const THREAD_PRIORITY_TIME_CRITICAL: DWORD = THREAD_BASE_PRIORITY_LOWRT; pub const THREAD_PRIORITY_IDLE: DWORD = THREAD_BASE_PRIORITY_IDLE; pub const THREAD_MODE_BACKGROUND_BEGIN: DWORD = 0x00010000; pub const THREAD_MODE_BACKGROUND_END: DWORD = 0x00020000; pub const VOLUME_NAME_DOS: DWORD = 0x0; // VOLUME_NAME_* // FILE_NAME_* // JIT_DEBUG_* pub const DRIVE_UNKNOWN: DWORD = 0; pub const DRIVE_NO_ROOT_DIR: DWORD = 1; pub const DRIVE_REMOVABLE: DWORD = 2; pub const DRIVE_FIXED: DWORD = 3; pub const DRIVE_REMOTE: DWORD = 4; pub const DRIVE_CDROM: DWORD = 5; pub const DRIVE_RAMDISK: DWORD = 6; // pub fn GetFreeSpace(); pub const FILE_TYPE_UNKNOWN: DWORD = 0x0000; pub const FILE_TYPE_DISK: DWORD = 0x0001; pub const FILE_TYPE_CHAR: DWORD = 0x0002; pub const FILE_TYPE_PIPE: DWORD = 0x0003; pub const FILE_TYPE_REMOTE: DWORD = 0x8000; pub const STD_INPUT_HANDLE: DWORD = -10i32 as u32; pub const STD_OUTPUT_HANDLE: DWORD = -11i32 as u32; pub const STD_ERROR_HANDLE: DWORD = -12i32 as u32; pub const NOPARITY: BYTE = 0; pub const ODDPARITY: BYTE = 1; pub const EVENPARITY: BYTE = 2; pub const MARKPARITY: BYTE = 3; pub const SPACEPARITY: BYTE = 4; pub const ONESTOPBIT: BYTE = 0; pub const ONE5STOPBITS: BYTE = 1; pub const TWOSTOPBITS: BYTE = 2; pub const IGNORE: DWORD = 0; pub const INFINITE: DWORD = 0xFFFFFFFF; pub const CBR_110: DWORD = 110; pub const CBR_300: DWORD = 300; pub const CBR_600: DWORD = 600; pub const CBR_1200: DWORD = 1200; pub const CBR_2400: DWORD = 2400; pub const CBR_4800: DWORD = 4800; pub const CBR_9600: DWORD = 9600; pub const CBR_14400: DWORD = 14400; pub const CBR_19200: DWORD = 19200; pub const CBR_38400: DWORD = 38400; pub const CBR_56000: DWORD = 56000; pub const CBR_57600: DWORD = 57600; pub const CBR_115200: DWORD = 115200; pub const CBR_128000: DWORD = 128000; pub const CBR_256000: DWORD = 256000; // CE_* // IE_* // EV_* pub const SETXOFF: DWORD = 1; pub const SETXON: DWORD = 2; pub const SETRTS: DWORD = 3; pub const CLRRTS: DWORD = 4; pub const SETDTR: DWORD = 5; pub const CLRDTR: DWORD = 6; pub const RESETDEV: DWORD = 7; pub const SETBREAK: DWORD = 8; pub const CLRBREAK: DWORD = 9; pub const PURGE_TXABORT: DWORD = 0x0001; pub const PURGE_RXABORT: DWORD = 0x0002; pub const PURGE_TXCLEAR: DWORD = 0x0004; pub const PURGE_RXCLEAR: DWORD = 0x0008; pub const MS_CTS_ON: DWORD = 0x0010; pub const MS_DSR_ON: DWORD = 0x0020; pub const MS_RING_ON: DWORD = 0x0040; pub const MS_RLSD_ON: DWORD = 0x0080; // S_* // NMPWAIT_* // FS_* // OF_* pub const OFS_MAXPATHNAME: usize = 128; STRUCT!{struct OFSTRUCT { cBytes: BYTE, fFixedDisk: BYTE, nErrCode: WORD, Reserved1: WORD, Reserved2: WORD, szPathName: [CHAR; OFS_MAXPATHNAME], }} pub type POFSTRUCT = *mut OFSTRUCT; pub type LPOFSTRUCT = *mut OFSTRUCT; extern "system" { pub fn GlobalAlloc( uFlags: UINT, dwBytes: SIZE_T, ) -> HGLOBAL; pub fn GlobalReAlloc( hMem: HGLOBAL, dwBytes: SIZE_T, uFlags: UINT, ) -> HGLOBAL; pub fn GlobalSize( hMem: HGLOBAL, ) -> SIZE_T; pub fn GlobalFlags( hMem: HGLOBAL, ) -> UINT; pub fn GlobalLock( hMem: HGLOBAL, ) -> LPVOID; pub fn GlobalHandle( pMem: LPCVOID, ) -> HGLOBAL; pub fn GlobalUnlock( hMem: HGLOBAL, ) -> BOOL; pub fn GlobalFree( hMem: HGLOBAL, ) -> HGLOBAL; pub fn GlobalCompact( dwMinFree: DWORD, ) -> SIZE_T; pub fn GlobalFix( hMem: HGLOBAL, ); pub fn GlobalUnfix( hMem: HGLOBAL, ); pub fn GlobalWire( hMem: HGLOBAL, ) -> LPVOID; pub fn GlobalUnWire( hMem: HGLOBAL, ) -> BOOL; pub fn GlobalMemoryStatus( lpBuffer: LPMEMORYSTATUS, ); pub fn LocalAlloc( uFlags: UINT, uBytes: SIZE_T, ) -> HLOCAL; pub fn LocalReAlloc( hMem: HLOCAL, uBytes: SIZE_T, uFlags: UINT, ) -> HLOCAL; pub fn LocalLock( hMem: HLOCAL, ) -> LPVOID; pub fn LocalHandle( pMem: LPCVOID, ) -> HLOCAL; pub fn LocalUnlock( hMem: HLOCAL, ) -> BOOL; pub fn LocalSize( hMem: HLOCAL, ) -> SIZE_T; pub fn LocalFlags( hMem: HLOCAL, ) -> UINT; pub fn LocalFree( hMem: HLOCAL, ) -> HLOCAL; pub fn LocalShrink( hMem: HLOCAL, cbNewSize: UINT, ) -> SIZE_T; pub fn LocalCompact( uMinFree: UINT, ) -> SIZE_T; } // SCS_* extern "system" { pub fn GetBinaryTypeA( lpApplicationName: LPCSTR, lpBinaryType: LPDWORD, ) -> BOOL; pub fn GetBinaryTypeW( lpApplicationName: LPCWSTR, lpBinaryType: LPDWORD, ) -> BOOL; pub fn GetShortPathNameA( lpszLongPath: LPCSTR, lpszShortPath: LPSTR, cchBuffer: DWORD, ) -> DWORD; pub fn GetLongPathNameTransactedA( lpszShortPath: LPCSTR, lpszLongPath: LPSTR, cchBuffer: DWORD, hTransaction: HANDLE, ) -> DWORD; pub fn GetLongPathNameTransactedW( lpszShortPath: LPCWSTR, lpszLongPath: LPWSTR, cchBuffer: DWORD, hTransaction: HANDLE, ) -> DWORD; pub fn GetProcessAffinityMask( hProcess: HANDLE, lpProcessAffinityMask: PDWORD_PTR, lpSystemAffinityMask: PDWORD_PTR, ) -> BOOL; pub fn SetProcessAffinityMask( hProcess: HANDLE, dwProcessAffinityMask: DWORD, ) -> BOOL; pub fn GetProcessIoCounters( hProcess: HANDLE, lpIoCounters: PIO_COUNTERS, ) -> BOOL; pub fn GetProcessWorkingSetSize( hProcess: HANDLE, lpMinimumWorkingSetSize: PSIZE_T, lpMaximumWorkingSetSize: PSIZE_T, ) -> BOOL; pub fn SetProcessWorkingSetSize( hProcess: HANDLE, dwMinimumWorkingSetSize: SIZE_T, dwMaximumWorkingSetSize: SIZE_T, ) -> BOOL; pub fn FatalExit( ExitCode: c_int, ); pub fn SetEnvironmentStringsA( NewEnvironment: LPCH, ) -> BOOL; pub fn SwitchToFiber( lpFiber: LPVOID, ); pub fn DeleteFiber( lpFiber: LPVOID, ); pub fn ConvertFiberToThread() -> BOOL; pub fn CreateFiberEx( dwStackCommitSize: SIZE_T, dwStackReserveSize: SIZE_T, dwFlags: DWORD, lpStartAddress: LPFIBER_START_ROUTINE, lpParameter: LPVOID, ) -> LPVOID; pub fn ConvertThreadToFiberEx( lpParameter: LPVOID, dwFlags: DWORD, ) -> LPVOID; pub fn CreateFiber( dwStackSize: SIZE_T, lpStartAddress: LPFIBER_START_ROUTINE, lpParameter: LPVOID, ) -> LPVOID; pub fn ConvertThreadToFiber( lpParameter: LPVOID, ) -> LPVOID; } pub type PUMS_CONTEXT = *mut c_void; pub type PUMS_COMPLETION_LIST = *mut c_void; pub type UMS_THREAD_INFO_CLASS = RTL_UMS_THREAD_INFO_CLASS; pub type PUMS_THREAD_INFO_CLASS = *mut UMS_THREAD_INFO_CLASS; pub type PUMS_SCHEDULER_ENTRY_POINT = PRTL_UMS_SCHEDULER_ENTRY_POINT; STRUCT!{struct UMS_SCHEDULER_STARTUP_INFO { UmsVersion: ULONG, CompletionList: PUMS_COMPLETION_LIST, SchedulerProc: PUMS_SCHEDULER_ENTRY_POINT, SchedulerParam: PVOID, }} pub type PUMS_SCHEDULER_STARTUP_INFO = *mut UMS_SCHEDULER_STARTUP_INFO; STRUCT!{struct UMS_SYSTEM_THREAD_INFORMATION { UmsVersion: ULONG, ThreadUmsFlags: ULONG, }} BITFIELD!{UMS_SYSTEM_THREAD_INFORMATION ThreadUmsFlags: ULONG [ IsUmsSchedulerThread set_IsUmsSchedulerThread[0..1], IsUmsWorkerThread set_IsUmsWorkerThread[1..2], ]} pub type PUMS_SYSTEM_THREAD_INFORMATION = *mut UMS_SYSTEM_THREAD_INFORMATION; extern "system" { #[cfg(target_pointer_width = "64")] pub fn CreateUmsCompletionList( UmsCompletionList: *mut PUMS_COMPLETION_LIST, ) -> BOOL; #[cfg(target_pointer_width = "64")] pub fn DequeueUmsCompletionListItems( UmsCompletionList: PUMS_COMPLETION_LIST, WaitTimeOut: DWORD, UmsThreadList: *mut PUMS_CONTEXT, ) -> BOOL; #[cfg(target_pointer_width = "64")] pub fn GetUmsCompletionListEvent( UmsCompletionList: PUMS_COMPLETION_LIST, UmsCompletionEvent: PHANDLE, ) -> BOOL; #[cfg(target_pointer_width = "64")] pub fn ExecuteUmsThread( UmsThread: PUMS_CONTEXT, ) -> BOOL; #[cfg(target_pointer_width = "64")] pub fn UmsThreadYield( SchedulerParam: PVOID, ) -> BOOL; #[cfg(target_pointer_width = "64")] pub fn DeleteUmsCompletionList( UmsCompletionList: PUMS_COMPLETION_LIST, ) -> BOOL; #[cfg(target_pointer_width = "64")] pub fn GetCurrentUmsThread() -> PUMS_CONTEXT; #[cfg(target_pointer_width = "64")] pub fn GetNextUmsListItem( UmsContext: PUMS_CONTEXT, ) -> PUMS_CONTEXT; #[cfg(target_pointer_width = "64")] pub fn QueryUmsThreadInformation( UmsThread: PUMS_CONTEXT, UmsThreadInfoClass: UMS_THREAD_INFO_CLASS, UmsThreadInformation: PVOID, UmsThreadInformationLength: ULONG, ReturnLength: PULONG, ) -> BOOL; #[cfg(target_pointer_width = "64")] pub fn SetUmsThreadInformation( UmsThread: PUMS_CONTEXT, UmsThreadInfoClass: UMS_THREAD_INFO_CLASS, UmsThreadInformation: PVOID, UmsThreadInformationLength: ULONG, ) -> BOOL; #[cfg(target_pointer_width = "64")] pub fn DeleteUmsThreadContext( UmsThread: PUMS_CONTEXT, ) -> BOOL; #[cfg(target_pointer_width = "64")] pub fn CreateUmsThreadContext( lpUmsThread: *mut PUMS_CONTEXT, ) -> BOOL; #[cfg(target_pointer_width = "64")] pub fn EnterUmsSchedulingMode( SchedulerStartupInfo: PUMS_SCHEDULER_STARTUP_INFO, ) -> BOOL; #[cfg(target_pointer_width = "64")] pub fn GetUmsSystemThreadInformation( ThreadHandle: HANDLE, SystemThreadInfo: PUMS_SYSTEM_THREAD_INFORMATION, ) -> BOOL; pub fn SetThreadAffinityMask( hThread: HANDLE, dwThreadAffinityMask: DWORD_PTR, ) -> DWORD_PTR; pub fn SetProcessDEPPolicy( dwFlags: DWORD, ) -> BOOL; pub fn GetProcessDEPPolicy( hProcess: HANDLE, lpFlags: LPDWORD, lpPermanent: PBOOL, ) -> BOOL; pub fn RequestWakeupLatency( latency: LATENCY_TIME, ) -> BOOL; pub fn IsSystemResumeAutomatic() -> BOOL; pub fn GetThreadSelectorEntry( hThread: HANDLE, dwSelector: DWORD, lpSelectorEntry: LPLDT_ENTRY, ) -> BOOL; pub fn SetThreadExecutionState( esFlags: EXECUTION_STATE, ) -> EXECUTION_STATE; pub fn PowerCreateRequest( Context: PREASON_CONTEXT, ) -> HANDLE; pub fn PowerSetRequest( PowerRequest: HANDLE, RequestType: POWER_REQUEST_TYPE, ) -> BOOL; pub fn PowerClearRequest( PowerRequest: HANDLE, RequestType: POWER_REQUEST_TYPE, ) -> BOOL; pub fn RestoreLastError( dwErrCode: DWORD, ); } pub const FILE_SKIP_COMPLETION_PORT_ON_SUCCESS: UCHAR = 0x1; pub const FILE_SKIP_SET_EVENT_ON_HANDLE: UCHAR = 0x2; extern "system" { pub fn SetFileCompletionNotificationModes( FileHandle: HANDLE, Flags: UCHAR, ) -> BOOL; } pub const SEM_FAILCRITICALERRORS: UINT = 0x0001; pub const SEM_NOGPFAULTERRORBOX: UINT = 0x0002; pub const SEM_NOALIGNMENTFAULTEXCEPT: UINT = 0x0004; pub const SEM_NOOPENFILEERRORBOX: UINT = 0x8000; extern "system" { pub fn Wow64GetThreadContext( hThread: HANDLE, lpContext: PWOW64_CONTEXT, ) -> BOOL; pub fn Wow64SetThreadContext( hThread: HANDLE, lpContext: *const WOW64_CONTEXT, ) -> BOOL; pub fn Wow64GetThreadSelectorEntry( hThread: HANDLE, dwSelector: DWORD, lpSelectorEntry: PWOW64_LDT_ENTRY, ) -> BOOL; pub fn Wow64SuspendThread( hThread: HANDLE, ) -> DWORD; pub fn DebugSetProcessKillOnExit( KillOnExit: BOOL, ) -> BOOL; pub fn DebugBreakProcess( Process: HANDLE, ) -> BOOL; pub fn PulseEvent( hEvent: HANDLE, ) -> BOOL; pub fn GlobalDeleteAtom( nAtom: ATOM, ) -> ATOM; pub fn InitAtomTable( nSize: DWORD, ) -> BOOL; pub fn DeleteAtom( nAtom: ATOM, ) -> ATOM; pub fn SetHandleCount( uNumber: UINT, ) -> UINT; pub fn RequestDeviceWakeup( hDevice: HANDLE, ) -> BOOL; pub fn CancelDeviceWakeupRequest( hDevice: HANDLE, ) -> BOOL; pub fn GetDevicePowerState( hDevice: HANDLE, pfOn: *mut BOOL, ) -> BOOL; pub fn SetMessageWaitingIndicator( hMsgIndicator: HANDLE, ulMsgCount: ULONG, ) -> BOOL; pub fn SetFileShortNameA( hFile: HANDLE, lpShortName: LPCSTR, ) -> BOOL; pub fn SetFileShortNameW( hFile: HANDLE, lpShortName: LPCWSTR, ) -> BOOL; } pub const HANDLE_FLAG_INHERIT: DWORD = 0x00000001; pub const HANDLE_FLAG_PROTECT_FROM_CLOSE: DWORD = 0x00000002; extern "system" { pub fn LoadModule( lpModuleName: LPCSTR, lpParameterBlock: LPVOID, ) -> DWORD; pub fn WinExec( lpCmdLine: LPCSTR, uCmdShow: UINT, ) -> UINT; // ClearCommBreak // ClearCommError // SetupComm // EscapeCommFunction // GetCommConfig // GetCommMask // GetCommProperties // GetCommModemStatus // GetCommState // GetCommTimeouts // PurgeComm // SetCommBreak // SetCommConfig // SetCommMask // SetCommState // SetCommTimeouts // TransmitCommChar // WaitCommEvent pub fn SetTapePosition( hDevice: HANDLE, dwPositionMethod: DWORD, dwPartition: DWORD, dwOffsetLow: DWORD, dwOffsetHigh: DWORD, bImmediate: BOOL, ) -> DWORD; pub fn GetTapePosition( hDevice: HANDLE, dwPositionType: DWORD, lpdwPartition: LPDWORD, lpdwOffsetLow: LPDWORD, lpdwOffsetHigh: LPDWORD, ) -> DWORD; pub fn PrepareTape( hDevice: HANDLE, dwOperation: DWORD, bImmediate: BOOL, ) -> DWORD; pub fn EraseTape( hDevice: HANDLE, dwEraseType: DWORD, bImmediate: BOOL, ) -> DWORD; pub fn CreateTapePartition( hDevice: HANDLE, dwPartitionMethod: DWORD, dwCount: DWORD, dwSize: DWORD, ) -> DWORD; pub fn WriteTapemark( hDevice: HANDLE, dwTapemarkType: DWORD, dwTapemarkCount: DWORD, bImmediate: BOOL, ) -> DWORD; pub fn GetTapeStatus( hDevice: HANDLE, ) -> DWORD; pub fn GetTapeParameters( hDevice: HANDLE, dwOperation: DWORD, lpdwSize: LPDWORD, lpTapeInformation: LPVOID, ) -> DWORD; pub fn SetTapeParameters( hDevice: HANDLE, dwOperation: DWORD, lpTapeInformation: LPVOID, ) -> DWORD; pub fn MulDiv( nNumber: c_int, nNumerator: c_int, nDenominator: c_int, ) -> c_int; } ENUM!{enum DEP_SYSTEM_POLICY_TYPE { DEPPolicyAlwaysOff = 0, DEPPolicyAlwaysOn, DEPPolicyOptIn, DEPPolicyOptOut, DEPTotalPolicyCount, }} extern "system" { pub fn GetSystemDEPPolicy() -> DEP_SYSTEM_POLICY_TYPE; pub fn GetSystemRegistryQuota( pdwQuotaAllowed: PDWORD, pdwQuotaUsed: PDWORD, ) -> BOOL; pub fn FileTimeToDosDateTime( lpFileTime: *const FILETIME, lpFatDate: LPWORD, lpFatTime: LPWORD, ) -> BOOL; pub fn DosDateTimeToFileTime( wFatDate: WORD, wFatTime: WORD, lpFileTime: LPFILETIME, ) -> BOOL; pub fn FormatMessageA( dwFlags: DWORD, lpSource: LPCVOID, dwMessageId: DWORD, dwLanguageId: DWORD, lpBuffer: LPSTR, nSize: DWORD, Arguments: *mut va_list, ) -> DWORD; pub fn FormatMessageW( dwFlags: DWORD, lpSource: LPCVOID, dwMessageId: DWORD, dwLanguageId: DWORD, lpBuffer: LPWSTR, nSize: DWORD, Arguments: *mut va_list, ) -> DWORD; } pub const FORMAT_MESSAGE_IGNORE_INSERTS: DWORD = 0x00000200; pub const FORMAT_MESSAGE_FROM_STRING: DWORD = 0x00000400; pub const FORMAT_MESSAGE_FROM_HMODULE: DWORD = 0x00000800; pub const FORMAT_MESSAGE_FROM_SYSTEM: DWORD = 0x00001000; pub const FORMAT_MESSAGE_ARGUMENT_ARRAY: DWORD = 0x00002000; pub const FORMAT_MESSAGE_MAX_WIDTH_MASK: DWORD = 0x000000FF; pub const FORMAT_MESSAGE_ALLOCATE_BUFFER: DWORD = 0x00000100; extern "system" { pub fn CreateMailslotA( lpName: LPCSTR, nMaxMessageSize: DWORD, lReadTimeout: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> HANDLE; pub fn CreateMailslotW( lpName: LPCWSTR, nMaxMessageSize: DWORD, lReadTimeout: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> HANDLE; pub fn GetMailslotInfo( hMailslot: HANDLE, lpMaxMessageSize: LPDWORD, lpNextSize: LPDWORD, lpMessageCount: LPDWORD, lpReadTimeout: LPDWORD, ) -> BOOL; pub fn SetMailslotInfo( hMailslot: HANDLE, lReadTimeout: DWORD, ) -> BOOL; // pub fn EncryptFileA(); // pub fn EncryptFileW(); // pub fn DecryptFileA(); // pub fn DecryptFileW(); // pub fn FileEncryptionStatusA(); // pub fn FileEncryptionStatusW(); // pub fn OpenEncryptedFileRawA(); // pub fn OpenEncryptedFileRawW(); // pub fn ReadEncryptedFileRaw(); // pub fn WriteEncryptedFileRaw(); // pub fn CloseEncryptedFileRaw(); pub fn lstrcmpA( lpString1: LPCSTR, lpString2: LPCSTR, ) -> c_int; pub fn lstrcmpW( lpString1: LPCWSTR, lpString2: LPCWSTR, ) -> c_int; pub fn lstrcmpiA( lpString1: LPCSTR, lpString2: LPCSTR, ) -> c_int; pub fn lstrcmpiW( lpString1: LPCWSTR, lpString2: LPCWSTR, ) -> c_int; pub fn lstrcpynA( lpString1: LPSTR, lpString2: LPCSTR, iMaxLength: c_int, ) -> LPSTR; pub fn lstrcpynW( lpString1: LPWSTR, lpString2: LPCWSTR, iMaxLength: c_int, ) -> LPWSTR; pub fn lstrcpyA( lpString1: LPSTR, lpString2: LPCSTR, ) -> LPSTR; pub fn lstrcpyW( lpString1: LPWSTR, lpString2: LPCWSTR, ) -> LPWSTR; pub fn lstrcatA( lpString1: LPSTR, lpString2: LPCSTR, ) -> LPSTR; pub fn lstrcatW( lpString1: LPWSTR, lpString2: LPCWSTR, ) -> LPWSTR; pub fn lstrlenA( lpString: LPCSTR, ) -> c_int; pub fn lstrlenW( lpString: LPCWSTR, ) -> c_int; pub fn OpenFile( lpFileName: LPCSTR, lpReOpenBuff: LPOFSTRUCT, uStyle: UINT, ) -> HFILE; pub fn _lopen( lpPathName: LPCSTR, iReadWrite: c_int, ) -> HFILE; pub fn _lcreat( lpPathName: LPCSTR, iAttrubute: c_int, ) -> HFILE; pub fn _lread( hFile: HFILE, lpBuffer: LPVOID, uBytes: UINT, ) -> UINT; pub fn _lwrite( hFile: HFILE, lpBuffer: LPCCH, uBytes: UINT, ) -> UINT; pub fn _hread( hFile: HFILE, lpBuffer: LPVOID, lBytes: c_long, ) -> c_long; pub fn _hwrite( hFile: HFILE, lpBuffer: LPCCH, lBytes: c_long, ) -> c_long; pub fn _lclose( hFile: HFILE, ) -> HFILE; pub fn _llseek( hFile: HFILE, lOffset: LONG, iOrigin: c_int, ) -> LONG; // pub fn IsTextUnicode(); // pub fn SignalObjectAndWait(); pub fn BackupRead( hFile: HANDLE, lpBuffer: LPBYTE, nNumberOfBytesToRead: DWORD, lpNumberOfBytesRead: LPDWORD, bAbort: BOOL, bProcessSecurity: BOOL, lpContext: *mut LPVOID, ) -> BOOL; pub fn BackupSeek( hFile: HANDLE, dwLowBytesToSeek: DWORD, dwHighBytesToSeek: DWORD, lpdwLowByteSeeked: LPDWORD, lpdwHighByteSeeked: LPDWORD, lpContext: *mut LPVOID, ) -> BOOL; pub fn BackupWrite( hFile: HANDLE, lpBuffer: LPBYTE, nNumberOfBytesToWrite: DWORD, lpNumberOfBytesWritten: LPDWORD, bAbort: BOOL, bProcessSecurity: BOOL, lpContext: *mut LPVOID, ) -> BOOL; } //2886 pub const STARTF_USESHOWWINDOW: DWORD = 0x00000001; pub const STARTF_USESIZE: DWORD = 0x00000002; pub const STARTF_USEPOSITION: DWORD = 0x00000004; pub const STARTF_USECOUNTCHARS: DWORD = 0x00000008; pub const STARTF_USEFILLATTRIBUTE: DWORD = 0x00000010; pub const STARTF_RUNFULLSCREEN: DWORD = 0x00000020; pub const STARTF_FORCEONFEEDBACK: DWORD = 0x00000040; pub const STARTF_FORCEOFFFEEDBACK: DWORD = 0x00000080; pub const STARTF_USESTDHANDLES: DWORD = 0x00000100; pub const STARTF_USEHOTKEY: DWORD = 0x00000200; pub const STARTF_TITLEISLINKNAME: DWORD = 0x00000800; pub const STARTF_TITLEISAPPID: DWORD = 0x00001000; pub const STARTF_PREVENTPINNING: DWORD = 0x00002000; pub const STARTF_UNTRUSTEDSOURCE: DWORD = 0x00008000; STRUCT!{struct STARTUPINFOEXA { StartupInfo: STARTUPINFOA, lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST, }} pub type LPSTARTUPINFOEXA = *mut STARTUPINFOEXA; STRUCT!{struct STARTUPINFOEXW { StartupInfo: STARTUPINFOW, lpAttributeList: LPPROC_THREAD_ATTRIBUTE_LIST, }} pub type LPSTARTUPINFOEXW = *mut STARTUPINFOEXW; extern "system" { pub fn OpenMutexA( dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR, ) -> HANDLE; pub fn CreateSemaphoreA( lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCSTR, ) -> HANDLE; pub fn OpenSemaphoreA( dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR, ) -> HANDLE; pub fn CreateWaitableTimerA( lpTimerAttributes: LPSECURITY_ATTRIBUTES, bManualReset: BOOL, lpTimerName: LPCSTR, ) -> HANDLE; pub fn OpenWaitableTimerA( dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpTimerName: LPCSTR, ) -> HANDLE; pub fn CreateSemaphoreExA( lpSemaphoreAttributes: LPSECURITY_ATTRIBUTES, lInitialCount: LONG, lMaximumCount: LONG, lpName: LPCSTR, dwFlags: DWORD, dwDesiredAccess: DWORD, ) -> HANDLE; pub fn CreateWaitableTimerExA( lpTimerAttributes: LPSECURITY_ATTRIBUTES, lpTimerName: LPCSTR, dwFlags: DWORD, dwDesiredAccess: DWORD, ) -> HANDLE; pub fn CreateFileMappingA( hFile: HANDLE, lpAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCSTR, ) -> HANDLE; pub fn CreateFileMappingNumaA( hFile: HANDLE, lpFileMappingAttributes: LPSECURITY_ATTRIBUTES, flProtect: DWORD, dwMaximumSizeHigh: DWORD, dwMaximumSizeLow: DWORD, lpName: LPCSTR, nndPreferred: DWORD, ) -> HANDLE; pub fn OpenFileMappingA( dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR, ) -> HANDLE; pub fn GetLogicalDriveStringsA( nBufferLength: DWORD, lpBuffer: LPSTR, ) -> DWORD; pub fn LoadPackagedLibrary( lpwLibFileName: LPCWSTR, Reserved: DWORD, ) -> HMODULE; pub fn QueryFullProcessImageNameA( hProcess: HANDLE, dwFlags: DWORD, lpExeName: LPSTR, lpdwSize: PDWORD, ) -> BOOL; pub fn QueryFullProcessImageNameW( hProcess: HANDLE, dwFlags: DWORD, lpExeName: LPWSTR, lpdwSize: PDWORD, ) -> BOOL; } //3233 extern "system" { pub fn GetStartupInfoA( lpStartupInfo: LPSTARTUPINFOA, ); pub fn GetFirmwareEnvironmentVariableA( lpName: LPCSTR, lpGuid: LPCSTR, pBuffer: PVOID, nSize: DWORD, ) -> DWORD; pub fn GetFirmwareEnvironmentVariableW( lpName: LPCWSTR, lpGuid: LPCWSTR, pBuffer: PVOID, nSize: DWORD, ) -> DWORD; pub fn GetFirmwareEnvironmentVariableExA( lpName: LPCSTR, lpGuid: LPCSTR, pBuffer: PVOID, nSize: DWORD, pdwAttribubutes: PDWORD, ) -> DWORD; pub fn GetFirmwareEnvironmentVariableExW( lpName: LPCWSTR, lpGuid: LPCWSTR, pBuffer: PVOID, nSize: DWORD, pdwAttribubutes: PDWORD, ) -> DWORD; pub fn SetFirmwareEnvironmentVariableA( lpName: LPCSTR, lpGuid: LPCSTR, pValue: PVOID, nSize: DWORD, ) -> BOOL; pub fn SetFirmwareEnvironmentVariableW( lpName: LPCWSTR, lpGuid: LPCWSTR, pValue: PVOID, nSize: DWORD, ) -> BOOL; pub fn SetFirmwareEnvironmentVariableExA( lpName: LPCSTR, lpGuid: LPCSTR, pValue: PVOID, nSize: DWORD, dwAttributes: DWORD, ) -> BOOL; pub fn SetFirmwareEnvironmentVariableExW( lpName: LPCWSTR, lpGuid: LPCWSTR, pValue: PVOID, nSize: DWORD, dwAttributes: DWORD, ) -> BOOL; pub fn GetFirmwareType( FirmwareType: PFIRMWARE_TYPE, ) -> BOOL; pub fn IsNativeVhdBoot( NativeVhdBoot: PBOOL, ) -> BOOL; pub fn FindResourceA( hModule: HMODULE, lpName: LPCSTR, lpType: LPCSTR, ) -> HRSRC; pub fn FindResourceExA( hModule: HMODULE, lpName: LPCSTR, lpType: LPCSTR, wLanguage: WORD, ) -> HRSRC; pub fn EnumResourceTypesA( hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCA, lParam: LONG_PTR, ) -> BOOL; pub fn EnumResourceTypesW( hModule: HMODULE, lpEnumFunc: ENUMRESTYPEPROCW, lParam: LONG_PTR, ) -> BOOL; pub fn EnumResourceNamesA( hModule: HMODULE, lpType: LPCSTR, lpEnumFunc: ENUMRESNAMEPROCA, lParam: LONG_PTR, ) -> BOOL; pub fn EnumResourceLanguagesA( hModule: HMODULE, lpType: LPCSTR, lpName: LPCSTR, lpEnumFunc: ENUMRESLANGPROCA, lParam: LONG_PTR, ) -> BOOL; pub fn EnumResourceLanguagesW( hModule: HMODULE, lpType: LPCWSTR, lpName: LPCWSTR, lpEnumFunc: ENUMRESLANGPROCW, lParam: LONG_PTR, ) -> BOOL; pub fn BeginUpdateResourceA( pFileName: LPCSTR, bDeleteExistingResources: BOOL, ) -> HANDLE; pub fn BeginUpdateResourceW( pFileName: LPCWSTR, bDeleteExistingResources: BOOL, ) -> HANDLE; pub fn UpdateResourceA( hUpdate: HANDLE, lpType: LPCSTR, lpName: LPCSTR, wLanguage: WORD, lpData: LPVOID, cb: DWORD, ) -> BOOL; pub fn UpdateResourceW( hUpdate: HANDLE, lpType: LPCWSTR, lpName: LPCWSTR, wLanguage: WORD, lpData: LPVOID, cb: DWORD, ) -> BOOL; pub fn EndUpdateResourceA( hUpdate: HANDLE, fDiscard: BOOL, ) -> BOOL; pub fn EndUpdateResourceW( hUpdate: HANDLE, fDiscard: BOOL, ) -> BOOL; pub fn GlobalAddAtomA( lpString: LPCSTR, ) -> ATOM; pub fn GlobalAddAtomW( lpString: LPCWSTR, ) -> ATOM; pub fn GlobalAddAtomExA( lpString: LPCSTR, Flags: DWORD, ) -> ATOM; pub fn GlobalAddAtomExW( lpString: LPCWSTR, Flags: DWORD, ) -> ATOM; pub fn GlobalFindAtomA( lpString: LPCSTR, ) -> ATOM; pub fn GlobalFindAtomW( lpString: LPCWSTR, ) -> ATOM; pub fn GlobalGetAtomNameA( nAtom: ATOM, lpBuffer: LPSTR, nSize: c_int, ) -> UINT; pub fn GlobalGetAtomNameW( nAtom: ATOM, lpBuffer: LPWSTR, nSize: c_int, ) -> UINT; pub fn AddAtomA( lpString: LPCSTR, ) -> ATOM; pub fn AddAtomW( lpString: LPCWSTR, ) -> ATOM; pub fn FindAtomA( lpString: LPCSTR, ) -> ATOM; pub fn FindAtomW( lpString: LPCWSTR, ) -> ATOM; pub fn GetAtomNameA( nAtom: ATOM, lpBuffer: LPSTR, nSize: c_int, ) -> UINT; pub fn GetAtomNameW( nAtom: ATOM, lpBuffer: LPWSTR, nSize: c_int, ) -> UINT; pub fn GetProfileIntA( lpAppName: LPCSTR, lpKeyName: LPCSTR, nDefault: INT, ) -> UINT; pub fn GetProfileIntW( lpAppName: LPCWSTR, lpKeyName: LPCWSTR, nDefault: INT, ) -> UINT; pub fn GetProfileStringA( lpAppName: LPCSTR, lpKeyName: LPCSTR, lpDefault: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD, ) -> DWORD; pub fn GetProfileStringW( lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpDefault: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD, ) -> DWORD; pub fn WriteProfileStringA( lpAppName: LPCSTR, lpKeyName: LPCSTR, lpString: LPCSTR, ) -> BOOL; pub fn WriteProfileStringW( lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpString: LPCWSTR, ) -> BOOL; pub fn GetProfileSectionA( lpAppName: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD, ) -> DWORD; pub fn GetProfileSectionW( lpAppName: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD, ) -> DWORD; pub fn WriteProfileSectionA( lpAppName: LPCSTR, lpString: LPCSTR, ) -> BOOL; pub fn WriteProfileSectionW( lpAppName: LPCWSTR, lpString: LPCWSTR, ) -> BOOL; pub fn GetPrivateProfileIntA( lpAppName: LPCSTR, lpKeyName: LPCSTR, nDefault: INT, lpFileName: LPCSTR, ) -> UINT; pub fn GetPrivateProfileIntW( lpAppName: LPCWSTR, lpKeyName: LPCWSTR, nDefault: INT, lpFileName: LPCWSTR, ) -> UINT; pub fn GetPrivateProfileStringA( lpAppName: LPCSTR, lpKeyName: LPCSTR, lpDefault: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD, lpFileName: LPCSTR, ) -> DWORD; pub fn GetPrivateProfileStringW( lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpDefault: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD, lpFileName: LPCWSTR, ) -> DWORD; pub fn WritePrivateProfileStringA( lpAppName: LPCSTR, lpKeyName: LPCSTR, lpString: LPCSTR, lpFileName: LPCSTR, ) -> BOOL; pub fn WritePrivateProfileStringW( lpAppName: LPCWSTR, lpKeyName: LPCWSTR, lpString: LPCWSTR, lpFileName: LPCWSTR, ) -> BOOL; pub fn GetPrivateProfileSectionA( lpAppName: LPCSTR, lpReturnedString: LPSTR, nSize: DWORD, lpFileName: LPCSTR, ) -> DWORD; pub fn GetPrivateProfileSectionW( lpAppName: LPCWSTR, lpReturnedString: LPWSTR, nSize: DWORD, lpFileName: LPCWSTR, ) -> DWORD; pub fn WritePrivateProfileSectionA( lpAppName: LPCSTR, lpString: LPCSTR, lpFileName: LPCSTR, ) -> BOOL; pub fn WritePrivateProfileSectionW( lpAppName: LPCWSTR, lpString: LPCWSTR, lpFileName: LPCWSTR, ) -> BOOL; pub fn GetPrivateProfileSectionNamesA( lpszReturnBuffer: LPSTR, nSize: DWORD, lpFileName: LPCSTR, ) -> DWORD; pub fn GetPrivateProfileSectionNamesW( lpszReturnBuffer: LPWSTR, nSize: DWORD, lpFileName: LPCWSTR, ) -> DWORD; pub fn GetPrivateProfileStructA( lpszSection: LPCSTR, lpszKey: LPCSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCSTR, ) -> BOOL; pub fn GetPrivateProfileStructW( lpszSection: LPCWSTR, lpszKey: LPCWSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCWSTR, ) -> BOOL; pub fn WritePrivateProfileStructA( lpszSection: LPCSTR, lpszKey: LPCSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCSTR, ) -> BOOL; pub fn WritePrivateProfileStructW( lpszSection: LPCWSTR, lpszKey: LPCWSTR, lpStruct: LPVOID, uSizeStruct: UINT, szFile: LPCWSTR, ) -> BOOL; pub fn Wow64EnableWow64FsRedirection( Wow64FsEnableRedirection: BOOLEAN, ) -> BOOLEAN; pub fn SetDllDirectoryA( lpPathName: LPCSTR, ) -> BOOL; pub fn SetDllDirectoryW( lpPathName: LPCWSTR, ) -> BOOL; pub fn GetDllDirectoryA( nBufferLength: DWORD, lpBuffer: LPSTR, ) -> DWORD; pub fn GetDllDirectoryW( nBufferLength: DWORD, lpBuffer: LPWSTR, ) -> DWORD; pub fn SetSearchPathMode( Flags: DWORD, ) -> BOOL; pub fn CreateDirectoryExA( lpTemplateDirectory: LPCSTR, lpNewDirectory: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> BOOL; pub fn CreateDirectoryExW( lpTemplateDirectory: LPCWSTR, lpNewDirectory: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> BOOL; pub fn CreateDirectoryTransactedA( lpTemplateDirectory: LPCSTR, lpNewDirectory: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE, ) -> BOOL; pub fn CreateDirectoryTransactedW( lpTemplateDirectory: LPCWSTR, lpNewDirectory: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE, ) -> BOOL; pub fn RemoveDirectoryTransactedA( lpPathName: LPCSTR, hTransaction: HANDLE, ) -> BOOL; pub fn RemoveDirectoryTransactedW( lpPathName: LPCWSTR, hTransaction: HANDLE, ) -> BOOL; pub fn GetFullPathNameTransactedA( lpFileName: LPCSTR, nBufferLength: DWORD, lpBuffer: LPSTR, lpFilePart: *mut LPSTR, hTransaction: HANDLE, ) -> DWORD; pub fn GetFullPathNameTransactedW( lpFileName: LPCWSTR, nBufferLength: DWORD, lpBuffer: LPWSTR, lpFilePart: *mut LPWSTR, hTransaction: HANDLE, ); pub fn DefineDosDeviceA( dwFlags: DWORD, lpDeviceName: LPCSTR, lpTargetPath: LPCSTR, ) -> BOOL; pub fn QueryDosDeviceA( lpDeviceName: LPCSTR, lpTargetPath: LPSTR, ucchMax: DWORD, ) -> DWORD; pub fn CreateFileTransactedA( lpFileName: LPCSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE, hTransaction: HANDLE, pusMiniVersion: PUSHORT, lpExtendedParameter: PVOID, ) -> HANDLE; pub fn CreateFileTransactedW( lpFileName: LPCWSTR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwCreationDisposition: DWORD, dwFlagsAndAttributes: DWORD, hTemplateFile: HANDLE, hTransaction: HANDLE, pusMiniVersion: PUSHORT, lpExtendedParameter: PVOID, ) -> HANDLE; pub fn ReOpenFile( hOriginalFile: HANDLE, dwDesiredAccess: DWORD, dwShareMode: DWORD, dwFlags: DWORD, ) -> HANDLE; pub fn SetFileAttributesTransactedA( lpFileName: LPCSTR, dwFileAttributes: DWORD, hTransaction: HANDLE, ) -> BOOL; pub fn SetFileAttributesTransactedW( lpFileName: LPCWSTR, dwFileAttributes: DWORD, hTransaction: HANDLE, ) -> BOOL; pub fn GetFileAttributesTransactedA( lpFileName: LPCSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID, hTransaction: HANDLE, ) -> BOOL; pub fn GetFileAttributesTransactedW( lpFileName: LPCWSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: LPVOID, hTransaction: HANDLE, ) -> BOOL; pub fn GetCompressedFileSizeTransactedA( lpFileName: LPCSTR, lpFileSizeHigh: LPDWORD, hTransaction: HANDLE, ) -> DWORD; pub fn GetCompressedFileSizeTransactedW( lpFileName: LPCWSTR, lpFileSizeHigh: LPDWORD, hTransaction: HANDLE, ); pub fn DeleteFileTransactedA( lpFileName: LPCSTR, hTransaction: HANDLE, ) -> BOOL; pub fn DeleteFileTransactedW( lpFileName: LPCWSTR, hTransaction: HANDLE, ) -> BOOL; pub fn CheckNameLegalDOS8Dot3A( lpName: LPCSTR, lpOemName: LPSTR, OemNameSize: DWORD, pbNameContainsSpaces: PBOOL, pbNameLegal: PBOOL, ) -> BOOL; pub fn CheckNameLegalDOS8Dot3W( lpName: LPCWSTR, lpOemName: LPSTR, OemNameSize: DWORD, pbNameContainsSpaces: PBOOL, pbNameLegal: PBOOL, ) -> BOOL; pub fn FindFirstFileTransactedA( lpFileName: LPCSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID, fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD, hTransaction: HANDLE, ) -> HANDLE; pub fn FindFirstFileTransactedW( lpFileName: LPCWSTR, fInfoLevelId: FINDEX_INFO_LEVELS, lpFindFileData: LPVOID, fSearchOp: FINDEX_SEARCH_OPS, lpSearchFilter: LPVOID, dwAdditionalFlags: DWORD, hTransaction: HANDLE, ) -> HANDLE; pub fn CopyFileA( lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, bFailIfExists: BOOL, ) -> BOOL; pub fn CopyFileW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, bFailIfExists: BOOL, ) -> BOOL; } FN!{stdcall LPPROGRESS_ROUTINE( TotalFileSize: LARGE_INTEGER, TotalBytesTransferred: LARGE_INTEGER, StreamSize: LARGE_INTEGER, StreamBytesTransferred: LARGE_INTEGER, dwStreamNumber: DWORD, dwCallbackReason: DWORD, hSourceFile: HANDLE, hDestinationFile: HANDLE, lpData: LPVOID, ) -> DWORD} extern "system" { pub fn CopyFileExA( lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD, ) -> BOOL; pub fn CopyFileExW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD, ) -> BOOL; pub fn CopyFileTransactedA( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD, hTransaction: HANDLE, ) -> BOOL; pub fn CopyFileTransactedW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, pbCancel: LPBOOL, dwCopyFlags: DWORD, hTransaction: HANDLE, ) -> BOOL; } ENUM!{enum COPYFILE2_MESSAGE_TYPE { COPYFILE2_CALLBACK_NONE = 0, COPYFILE2_CALLBACK_CHUNK_STARTED, COPYFILE2_CALLBACK_CHUNK_FINISHED, COPYFILE2_CALLBACK_STREAM_STARTED, COPYFILE2_CALLBACK_STREAM_FINISHED, COPYFILE2_CALLBACK_POLL_CONTINUE, COPYFILE2_CALLBACK_ERROR, COPYFILE2_CALLBACK_MAX, }} ENUM!{enum COPYFILE2_MESSAGE_ACTION { COPYFILE2_PROGRESS_CONTINUE = 0, COPYFILE2_PROGRESS_CANCEL, COPYFILE2_PROGRESS_STOP, COPYFILE2_PROGRESS_QUIET, COPYFILE2_PROGRESS_PAUSE, }} ENUM!{enum COPYFILE2_COPY_PHASE { COPYFILE2_PHASE_NONE = 0, COPYFILE2_PHASE_PREPARE_SOURCE, COPYFILE2_PHASE_PREPARE_DEST, COPYFILE2_PHASE_READ_SOURCE, COPYFILE2_PHASE_WRITE_DESTINATION, COPYFILE2_PHASE_SERVER_COPY, COPYFILE2_PHASE_NAMEGRAFT_COPY, COPYFILE2_PHASE_MAX, }} STRUCT!{struct COPYFILE2_MESSAGE_ChunkStarted { dwStreamNumber: DWORD, dwReserved: DWORD, hSourceFile: HANDLE, hDestinationFile: HANDLE, uliChunkNumber: ULARGE_INTEGER, uliChunkSize: ULARGE_INTEGER, uliStreamSize: ULARGE_INTEGER, uliTotalFileSize: ULARGE_INTEGER, }} STRUCT!{struct COPYFILE2_MESSAGE_ChunkFinished { dwStreamNumber: DWORD, dwFlags: DWORD, hSourceFile: HANDLE, hDestinationFile: HANDLE, uliChunkNumber: ULARGE_INTEGER, uliChunkSize: ULARGE_INTEGER, uliStreamSize: ULARGE_INTEGER, uliStreamBytesTransferred: ULARGE_INTEGER, uliTotalFileSize: ULARGE_INTEGER, uliTotalBytesTransferred: ULARGE_INTEGER, }} STRUCT!{struct COPYFILE2_MESSAGE_StreamStarted { dwStreamNumber: DWORD, dwReserved: DWORD, hSourceFile: HANDLE, hDestinationFile: HANDLE, uliStreamSize: ULARGE_INTEGER, uliTotalFileSize: ULARGE_INTEGER, }} STRUCT!{struct COPYFILE2_MESSAGE_StreamFinished { dwStreamNumber: DWORD, dwReserved: DWORD, hSourceFile: HANDLE, hDestinationFile: HANDLE, uliStreamSize: ULARGE_INTEGER, uliStreamBytesTransferred: ULARGE_INTEGER, uliTotalFileSize: ULARGE_INTEGER, uliTotalBytesTransferred: ULARGE_INTEGER, }} STRUCT!{struct COPYFILE2_MESSAGE_PollContinue { dwReserved: DWORD, }} STRUCT!{struct COPYFILE2_MESSAGE_Error { CopyPhase: COPYFILE2_COPY_PHASE, dwStreamNumber: DWORD, hrFailure: HRESULT, dwReserved: DWORD, uliChunkNumber: ULARGE_INTEGER, uliStreamSize: ULARGE_INTEGER, uliStreamBytesTransferred: ULARGE_INTEGER, uliTotalFileSize: ULARGE_INTEGER, uliTotalBytesTransferred: ULARGE_INTEGER, }} UNION!{union COPYFILE2_MESSAGE_Info { [u64; 8] [u64; 9], ChunkStarted ChunkStarted_mut: COPYFILE2_MESSAGE_ChunkStarted, ChunkFinished ChunkFinished_mut: COPYFILE2_MESSAGE_ChunkFinished, StreamStarted StreamStarted_mut: COPYFILE2_MESSAGE_StreamStarted, StreamFinished StreamFinished_mut: COPYFILE2_MESSAGE_StreamFinished, PollContinue PollContinue_mut: COPYFILE2_MESSAGE_PollContinue, Error Error_mut: COPYFILE2_MESSAGE_Error, }} STRUCT!{struct COPYFILE2_MESSAGE { Type: COPYFILE2_MESSAGE_TYPE, dwPadding: DWORD, Info: COPYFILE2_MESSAGE_Info, }} FN!{stdcall PCOPYFILE2_PROGRESS_ROUTINE( pMessage: *const COPYFILE2_MESSAGE, pvCallbackContext: PVOID, ) -> COPYFILE2_MESSAGE_ACTION} STRUCT!{struct COPYFILE2_EXTENDED_PARAMETERS { dwSize: DWORD, dwCopyFlags: DWORD, pfCancel: *mut BOOL, pProgressRoutine: PCOPYFILE2_PROGRESS_ROUTINE, pvCallbackContext: PVOID, }} extern "system" { pub fn CopyFile2( pwszExistingFileName: PCWSTR, pwszNewFileName: PCWSTR, pExtendedParameters: *mut COPYFILE2_EXTENDED_PARAMETERS, ) -> HRESULT; pub fn MoveFileA( lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, ) -> BOOL; pub fn MoveFileW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, ) -> BOOL; pub fn MoveFileExA( lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, dwFlags: DWORD, ) -> BOOL; pub fn MoveFileExW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, dwFlags: DWORD, ) -> BOOL; pub fn MoveFileWithProgressA( lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD, ) -> BOOL; pub fn MoveFileWithProgressW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD, ) -> BOOL; pub fn MoveFileTransactedA( lpExistingFileName: LPCSTR, lpNewFileName: LPCSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD, hTransaction: HANDLE, ) -> BOOL; pub fn MoveFileTransactedW( lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, lpData: LPVOID, dwFlags: DWORD, hTransaction: HANDLE, ) -> BOOL; } pub const MOVEFILE_REPLACE_EXISTING: DWORD = 0x00000001; pub const MOVEFILE_COPY_ALLOWED: DWORD = 0x00000002; pub const MOVEFILE_DELAY_UNTIL_REBOOT: DWORD = 0x00000004; pub const MOVEFILE_WRITE_THROUGH: DWORD = 0x00000008; pub const MOVEFILE_CREATE_HARDLINK: DWORD = 0x00000010; pub const MOVEFILE_FAIL_IF_NOT_TRACKABLE: DWORD = 0x00000020; extern "system" { pub fn ReplaceFileA( lpReplacedFileName: LPCSTR, lpReplacementFileName: LPCSTR, lpBackupFileName: LPCSTR, dwReplaceFlags: DWORD, lpExclude: LPVOID, lpReserved: LPVOID, ); pub fn ReplaceFileW( lpReplacedFileName: LPCWSTR, lpReplacementFileName: LPCWSTR, lpBackupFileName: LPCWSTR, dwReplaceFlags: DWORD, lpExclude: LPVOID, lpReserved: LPVOID, ); pub fn CreateHardLinkA( lpFileName: LPCSTR, lpExistingFileName: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> BOOL; pub fn CreateHardLinkW( lpFileName: LPCWSTR, lpExistingFileName: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> BOOL; pub fn CreateHardLinkTransactedA( lpFileName: LPCSTR, lpExistingFileName: LPCSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE, ) -> BOOL; pub fn CreateHardLinkTransactedW( lpFileName: LPCWSTR, lpExistingFileName: LPCWSTR, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, hTransaction: HANDLE, ); pub fn FindFirstStreamTransactedW( lpFileName: LPCWSTR, InfoLevel: STREAM_INFO_LEVELS, lpFindStreamData: LPVOID, dwFlags: DWORD, hTransaction: HANDLE, ) -> HANDLE; pub fn FindFirstFileNameTransactedW( lpFileName: LPCWSTR, dwFlags: DWORD, StringLength: LPDWORD, LinkName: PWSTR, hTransaction: HANDLE, ) -> HANDLE; pub fn CreateNamedPipeA( lpName: LPCSTR, dwOpenMode: DWORD, dwPipeMode: DWORD, nMaxInstances: DWORD, nOutBufferSize: DWORD, nInBufferSize: DWORD, nDefaultTimeOut: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, ) -> HANDLE; pub fn GetNamedPipeHandleStateA( hNamedPipe: HANDLE, lpState: LPDWORD, lpCurInstances: LPDWORD, lpMaxCollectionCount: LPDWORD, lpCollectDataTimeout: LPDWORD, lpUserName: LPSTR, nMaxUserNameSize: DWORD, ) -> BOOL; pub fn CallNamedPipeA( lpNamedPipeName: LPCSTR, lpInBuffer: LPVOID, nInBufferSize: DWORD, lpOutBuffer: LPVOID, nOutBufferSize: DWORD, lpBytesRead: LPDWORD, nTimeOut: DWORD, ) -> BOOL; pub fn WaitNamedPipeA( lpNamedPipeName: LPCSTR, nTimeOut: DWORD, ) -> BOOL; pub fn GetNamedPipeClientComputerNameA( Pipe: HANDLE, ClientComputerName: LPSTR, ClientComputerNameLength: ULONG, ) -> BOOL; pub fn GetNamedPipeClientProcessId( Pipe: HANDLE, ClientProcessId: PULONG, ) -> BOOL; pub fn GetNamedPipeClientSessionId( Pipe: HANDLE, ClientSessionId: PULONG, ) -> BOOL; pub fn GetNamedPipeServerProcessId( Pipe: HANDLE, ServerProcessId: PULONG, ) -> BOOL; pub fn GetNamedPipeServerSessionId( Pipe: HANDLE, ServerSessionId: PULONG, ) -> BOOL; pub fn SetVolumeLabelA( lpRootPathName: LPCSTR, lpVolumeName: LPCSTR, ) -> BOOL; pub fn SetVolumeLabelW( lpRootPathName: LPCWSTR, lpVolumeName: LPCWSTR, ) -> BOOL; pub fn SetFileBandwidthReservation( hFile: HANDLE, nPeriodMilliseconds: DWORD, nBytesPerPeriod: DWORD, bDiscardable: BOOL, lpTransferSize: LPDWORD, lpNumOutstandingRequests: LPDWORD, ) -> BOOL; pub fn GetFileBandwidthReservation( hFile: HANDLE, lpPeriodMilliseconds: LPDWORD, lpBytesPerPeriod: LPDWORD, pDiscardable: LPBOOL, lpTransferSize: LPDWORD, lpNumOutstandingRequests: LPDWORD, ) -> BOOL; // pub fn ClearEventLogA(); // pub fn ClearEventLogW(); // pub fn BackupEventLogA(); // pub fn BackupEventLogW(); // pub fn CloseEventLog(); pub fn DeregisterEventSource( hEventLog: HANDLE, ) -> BOOL; // pub fn NotifyChangeEventLog(); // pub fn GetNumberOfEventLogRecords(); // pub fn GetOldestEventLogRecord(); // pub fn OpenEventLogA(); // pub fn OpenEventLogW(); pub fn RegisterEventSourceA( lpUNCServerName: LPCSTR, lpSourceName: LPCSTR, ) -> HANDLE; pub fn RegisterEventSourceW( lpUNCServerName: LPCWSTR, lpSourceName: LPCWSTR, ) -> HANDLE; // pub fn OpenBackupEventLogA(); // pub fn OpenBackupEventLogW(); // pub fn ReadEventLogA(); // pub fn ReadEventLogW(); pub fn ReportEventA( hEventLog: HANDLE, wType: WORD, wCategory: WORD, dwEventID: DWORD, lpUserSid: PSID, wNumStrings: WORD, dwDataSize: DWORD, lpStrings: *mut LPCSTR, lpRawData: LPVOID, ) -> BOOL; pub fn ReportEventW( hEventLog: HANDLE, wType: WORD, wCategory: WORD, dwEventID: DWORD, lpUserSid: PSID, wNumStrings: WORD, dwDataSize: DWORD, lpStrings: *mut LPCWSTR, lpRawData: LPVOID, ) -> BOOL; // pub fn GetEventLogInformation(); // pub fn OperationStart(); // pub fn OperationEnd(); // pub fn AccessCheckAndAuditAlarmA(); // pub fn AccessCheckByTypeAndAuditAlarmA(); // pub fn AccessCheckByTypeResultListAndAuditAlarmA(); // pub fn AccessCheckByTypeResultListAndAuditAlarmByHandleA(); // pub fn ObjectOpenAuditAlarmA(); // pub fn ObjectPrivilegeAuditAlarmA(); // pub fn ObjectCloseAuditAlarmA(); // pub fn ObjectDeleteAuditAlarmA(); // pub fn PrivilegedServiceAuditAlarmA(); // pub fn AddConditionalAce(); // pub fn SetFileSecurityA(); // pub fn GetFileSecurityA(); pub fn ReadDirectoryChangesW( hDirectory: HANDLE, lpBuffer: LPVOID, nBufferLength: DWORD, bWatchSubtree: BOOL, dwNotifyFilter: DWORD, lpBytesReturned: LPDWORD, lpOverlapped: LPOVERLAPPED, lpCompletionRoutine: LPOVERLAPPED_COMPLETION_ROUTINE, ) -> BOOL; pub fn MapViewOfFileExNuma( hFileMappingObject: HANDLE, dwDesiredAccess: DWORD, dwFileOffsetHigh: DWORD, dwFileOffsetLow: DWORD, dwNumberOfBytesToMap: SIZE_T, lpBaseAddress: LPVOID, nndPreferred: DWORD, ) -> LPVOID; pub fn IsBadReadPtr( lp: *const VOID, ucb: UINT_PTR, ) -> BOOL; pub fn IsBadWritePtr( lp: LPVOID, ucb: UINT_PTR, ) -> BOOL; pub fn IsBadHugeReadPtr( lp: *const VOID, ucb: UINT_PTR, ) -> BOOL; pub fn IsBadHugeWritePtr( lp: LPVOID, ucb: UINT_PTR, ) -> BOOL; pub fn IsBadCodePtr( lpfn: FARPROC, ) -> BOOL; pub fn IsBadStringPtrA( lpsz: LPCSTR, ucchMax: UINT_PTR, ) -> BOOL; pub fn IsBadStringPtrW( lpsz: LPCWSTR, ucchMax: UINT_PTR, ) -> BOOL; pub fn LookupAccountSidA( lpSystemName: LPCSTR, Sid: PSID, Name: LPSTR, cchName: LPDWORD, ReferencedDomainName: LPSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE, ) -> BOOL; pub fn LookupAccountSidW( lpSystemName: LPCWSTR, Sid: PSID, Name: LPWSTR, cchName: LPDWORD, ReferencedDomainName: LPWSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE, ) -> BOOL; pub fn LookupAccountNameA( lpSystemName: LPCSTR, lpAccountName: LPCSTR, Sid: PSID, cbSid: LPDWORD, ReferencedDomainName: LPCSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE, ) -> BOOL; pub fn LookupAccountNameW( lpSystemName: LPCWSTR, lpAccountName: LPCWSTR, Sid: PSID, cbSid: LPDWORD, ReferencedDomainName: LPCWSTR, cchReferencedDomainName: LPDWORD, peUse: PSID_NAME_USE, ) -> BOOL; // pub fn LookupAccountNameLocalA(); // pub fn LookupAccountNameLocalW(); // pub fn LookupAccountSidLocalA(); // pub fn LookupAccountSidLocalW(); pub fn LookupPrivilegeValueA( lpSystemName: LPCSTR, lpName: LPCSTR, lpLuid: PLUID, ) -> BOOL; pub fn LookupPrivilegeValueW( lpSystemName: LPCWSTR, lpName: LPCWSTR, lpLuid: PLUID, ) -> BOOL; pub fn LookupPrivilegeNameA( lpSystemName: LPCSTR, lpLuid: PLUID, lpName: LPSTR, cchName: LPDWORD, ) -> BOOL; pub fn LookupPrivilegeNameW( lpSystemName: LPCWSTR, lpLuid: PLUID, lpName: LPWSTR, cchName: LPDWORD, ) -> BOOL; // pub fn LookupPrivilegeDisplayNameA(); // pub fn LookupPrivilegeDisplayNameW(); pub fn BuildCommDCBA( lpDef: LPCSTR, lpDCB: LPDCB, ) -> BOOL; pub fn BuildCommDCBW( lpDef: LPCWSTR, lpDCB: LPDCB, ) -> BOOL; pub fn BuildCommDCBAndTimeoutsA( lpDef: LPCSTR, lpDCB: LPDCB, lpCommTimeouts: LPCOMMTIMEOUTS, ) -> BOOL; pub fn BuildCommDCBAndTimeoutsW( lpDef: LPCWSTR, lpDCB: LPDCB, lpCommTimeouts: LPCOMMTIMEOUTS, ) -> BOOL; pub fn CommConfigDialogA( lpszName: LPCSTR, hWnd: HWND, lpCC: LPCOMMCONFIG, ) -> BOOL; pub fn CommConfigDialogW( lpszName: LPCWSTR, hWnd: HWND, lpCC: LPCOMMCONFIG, ) -> BOOL; pub fn GetDefaultCommConfigA( lpszName: LPCSTR, lpCC: LPCOMMCONFIG, lpdwSize: LPDWORD, ) -> BOOL; pub fn GetDefaultCommConfigW( lpszName: LPCWSTR, lpCC: LPCOMMCONFIG, lpdwSize: LPDWORD, ) -> BOOL; pub fn SetDefaultCommConfigA( lpszName: LPCSTR, lpCC: LPCOMMCONFIG, dwSize: DWORD, ) -> BOOL; pub fn SetDefaultCommConfigW( lpszName: LPCWSTR, lpCC: LPCOMMCONFIG, dwSize: DWORD, ) -> BOOL; pub fn GetComputerNameA( lpBuffer: LPSTR, nSize: LPDWORD, ) -> BOOL; pub fn GetComputerNameW( lpBuffer: LPWSTR, nSize: LPDWORD, ) -> BOOL; pub fn DnsHostnameToComputerNameA( Hostname: LPCSTR, ComputerName: LPCSTR, nSize: LPDWORD, ) -> BOOL; pub fn DnsHostnameToComputerNameW( Hostname: LPCWSTR, ComputerName: LPWSTR, nSize: LPDWORD, ) -> BOOL; pub fn GetUserNameA( lpBuffer: LPSTR, pcbBuffer: LPDWORD, ) -> BOOL; pub fn GetUserNameW( lpBuffer: LPWSTR, pcbBuffer: LPDWORD, ) -> BOOL; } pub const LOGON32_LOGON_INTERACTIVE: DWORD = 2; pub const LOGON32_LOGON_NETWORK: DWORD = 3; pub const LOGON32_LOGON_BATCH: DWORD = 4; pub const LOGON32_LOGON_SERVICE: DWORD = 5; pub const LOGON32_LOGON_UNLOCK: DWORD = 7; pub const LOGON32_LOGON_NETWORK_CLEARTEXT: DWORD = 8; pub const LOGON32_LOGON_NEW_CREDENTIALS: DWORD = 9; pub const LOGON32_PROVIDER_DEFAULT: DWORD = 0; pub const LOGON32_PROVIDER_WINNT35: DWORD = 1; pub const LOGON32_PROVIDER_WINNT40: DWORD = 2; pub const LOGON32_PROVIDER_WINNT50: DWORD = 3; pub const LOGON32_PROVIDER_VIRTUAL: DWORD = 4; extern "system" { pub fn LogonUserA( lpUsername: LPCSTR, lpDomain: LPCSTR, lpPassword: LPCSTR, dwLogonType: DWORD, dwLogonProvider: DWORD, phToken: PHANDLE, ) -> BOOL; pub fn LogonUserW( lpUsername: LPCWSTR, lpDomain: LPCWSTR, lpPassword: LPCWSTR, dwLogonType: DWORD, dwLogonProvider: DWORD, phToken: PHANDLE, ) -> BOOL; pub fn LogonUserExA( lpUsername: LPCSTR, lpDomain: LPCSTR, lpPassword: LPCSTR, dwLogonType: DWORD, dwLogonProvider: DWORD, phToken: PHANDLE, ppLogonSid: *mut PSID, ppProfileBuffer: *mut PVOID, pdwProfileLength: LPDWORD, pQuotaLimits: PQUOTA_LIMITS, ) -> BOOL; pub fn LogonUserExW( lpUsername: LPCWSTR, lpDomain: LPCWSTR, lpPassword: LPCWSTR, dwLogonType: DWORD, dwLogonProvider: DWORD, phToken: PHANDLE, ppLogonSid: *mut PSID, ppProfileBuffer: *mut PVOID, pdwProfileLength: LPDWORD, pQuotaLimits: PQUOTA_LIMITS, ) -> BOOL; } pub const LOGON_WITH_PROFILE: DWORD = 0x00000001; pub const LOGON_NETCREDENTIALS_ONLY: DWORD = 0x00000002; extern "system" { pub fn CreateProcessWithLogonW( lpUsername: LPCWSTR, lpDomain: LPCWSTR, lpPassword: LPCWSTR, dwLogonFlags: DWORD, lpApplicationName: LPCWSTR, lpCommandLine: LPWSTR, dwCreationFlags: DWORD, lpEnvironment: LPVOID, lpCurrentDirectory: LPCWSTR, lpStartupInfo: LPSTARTUPINFOW, lpProcessInformation: LPPROCESS_INFORMATION, ) -> BOOL; pub fn CreateProcessWithTokenW( hToken: HANDLE, dwLogonFlags: DWORD, lpApplicationName: LPCWSTR, lpCommandLine: LPWSTR, dwCreationFlags: DWORD, lpEnvironment: LPVOID, lpCurrentDirectory: LPCWSTR, lpStartupInfo: LPSTARTUPINFOW, lpProcessInformation: LPPROCESS_INFORMATION, ) -> BOOL; pub fn IsTokenUntrusted( TokenHandle: HANDLE, ) -> BOOL; pub fn RegisterWaitForSingleObject( phNewWaitObject: PHANDLE, hObject: HANDLE, Callback: WAITORTIMERCALLBACK, Context: PVOID, dwMilliseconds: ULONG, dwFlags: ULONG, ) -> BOOL; pub fn UnregisterWait( WaitHandle: HANDLE, ) -> BOOL; pub fn BindIoCompletionCallback( FileHandle: HANDLE, Function: LPOVERLAPPED_COMPLETION_ROUTINE, Flags: ULONG, ) -> BOOL; pub fn SetTimerQueueTimer( TimerQueue: HANDLE, Callback: WAITORTIMERCALLBACK, Parameter: PVOID, DueTime: DWORD, Period: DWORD, PreferIo: BOOL, ) -> HANDLE; pub fn CancelTimerQueueTimer( TimerQueue: HANDLE, Timer: HANDLE, ) -> BOOL; pub fn DeleteTimerQueue( TimerQueue: HANDLE, ) -> BOOL; // pub fn InitializeThreadpoolEnvironment(); // pub fn SetThreadpoolCallbackPool(); // pub fn SetThreadpoolCallbackCleanupGroup(); // pub fn SetThreadpoolCallbackRunsLong(); // pub fn SetThreadpoolCallbackLibrary(); // pub fn SetThreadpoolCallbackPriority(); // pub fn DestroyThreadpoolEnvironment(); // pub fn SetThreadpoolCallbackPersistent(); pub fn CreatePrivateNamespaceA( lpPrivateNamespaceAttributes: LPSECURITY_ATTRIBUTES, lpBoundaryDescriptor: LPVOID, lpAliasPrefix: LPCSTR, ) -> HANDLE; pub fn OpenPrivateNamespaceA( lpBoundaryDescriptor: LPVOID, lpAliasPrefix: LPCSTR, ) -> HANDLE; pub fn CreateBoundaryDescriptorA( Name: LPCSTR, Flags: ULONG, ) -> HANDLE; pub fn AddIntegrityLabelToBoundaryDescriptor( BoundaryDescriptor: *mut HANDLE, IntegrityLabel: PSID, ) -> BOOL; } pub const HW_PROFILE_GUIDLEN: usize = 39; // MAX_PROFILE_LEN pub const DOCKINFO_UNDOCKED: DWORD = 0x1; pub const DOCKINFO_DOCKED: DWORD = 0x2; pub const DOCKINFO_USER_SUPPLIED: DWORD = 0x4; pub const DOCKINFO_USER_UNDOCKED: DWORD = DOCKINFO_USER_SUPPLIED | DOCKINFO_UNDOCKED; pub const DOCKINFO_USER_DOCKED: DWORD = DOCKINFO_USER_SUPPLIED | DOCKINFO_DOCKED; STRUCT!{struct HW_PROFILE_INFOA { dwDockInfo: DWORD, szHwProfileGuid: [CHAR; HW_PROFILE_GUIDLEN], szHwProfileName: [CHAR; MAX_PROFILE_LEN], }} pub type LPHW_PROFILE_INFOA = *mut HW_PROFILE_INFOA; STRUCT!{struct HW_PROFILE_INFOW { dwDockInfo: DWORD, szHwProfileGuid: [WCHAR; HW_PROFILE_GUIDLEN], szHwProfileName: [WCHAR; MAX_PROFILE_LEN], }} pub type LPHW_PROFILE_INFOW = *mut HW_PROFILE_INFOW; extern "system" { pub fn GetCurrentHwProfileA( lpHwProfileInfo: LPHW_PROFILE_INFOA, ) -> BOOL; pub fn GetCurrentHwProfileW( lpHwProfileInfo: LPHW_PROFILE_INFOW, ) -> BOOL; pub fn VerifyVersionInfoA( lpVersionInformation: LPOSVERSIONINFOEXA, dwTypeMask: DWORD, dwlConditionMask: DWORDLONG, ) -> BOOL; pub fn VerifyVersionInfoW( lpVersionInformation: LPOSVERSIONINFOEXW, dwTypeMask: DWORD, dwlConditionMask: DWORDLONG, ) -> BOOL; } STRUCT!{struct SYSTEM_POWER_STATUS { ACLineStatus: BYTE, BatteryFlag: BYTE, BatteryLifePercent: BYTE, Reserved1: BYTE, BatteryLifeTime: DWORD, BatteryFullLifeTime: DWORD, }} pub type LPSYSTEM_POWER_STATUS = *mut SYSTEM_POWER_STATUS; extern "system" { pub fn GetSystemPowerStatus( lpSystemPowerStatus: LPSYSTEM_POWER_STATUS, ) -> BOOL; pub fn SetSystemPowerState( fSuspend: BOOL, fForce: BOOL, ) -> BOOL; pub fn MapUserPhysicalPagesScatter( VirtualAddresses: *mut PVOID, NumberOfPages: ULONG_PTR, PageArray: PULONG_PTR, ) -> BOOL; pub fn CreateJobObjectA( lpJobAttributes: LPSECURITY_ATTRIBUTES, lpName: LPCSTR, ) -> HANDLE; pub fn OpenJobObjectA( dwDesiredAccess: DWORD, bInheritHandle: BOOL, lpName: LPCSTR, ) -> HANDLE; pub fn CreateJobSet( NumJob: ULONG, UserJobSet: PJOB_SET_ARRAY, Flags: ULONG, ) -> BOOL; pub fn FindFirstVolumeA( lpszVolumeName: LPSTR, cchBufferLength: DWORD, ) -> HANDLE; pub fn FindNextVolumeA( hFindVolume: HANDLE, lpszVolumeName: LPSTR, cchBufferLength: DWORD, ) -> BOOL; pub fn FindFirstVolumeMountPointA( lpszRootPathName: LPCSTR, lpszVolumeMountPoint: LPSTR, cchBufferLength: DWORD, ) -> HANDLE; pub fn FindFirstVolumeMountPointW( lpszRootPathName: LPCWSTR, lpszVolumeMountPoint: LPWSTR, cchBufferLength: DWORD, ) -> HANDLE; pub fn FindNextVolumeMountPointA( hFindVolumeMountPoint: HANDLE, lpszVolumeMountPoint: LPSTR, cchBufferLength: DWORD, ) -> BOOL; pub fn FindNextVolumeMountPointW( hFindVolumeMountPoint: HANDLE, lpszVolumeMountPoint: LPWSTR, cchBufferLength: DWORD, ) -> BOOL; pub fn FindVolumeMountPointClose( hFindVolumeMountPoint: HANDLE, ) -> BOOL; pub fn SetVolumeMountPointA( lpszVolumeMountPoint: LPCSTR, lpszVolumeName: LPCSTR, ) -> BOOL; pub fn SetVolumeMountPointW( lpszVolumeMountPoint: LPCWSTR, lpszVolumeName: LPCWSTR, ) -> BOOL; pub fn DeleteVolumeMountPointA( lpszVolumeMountPoint: LPCSTR, ) -> BOOL; pub fn GetVolumeNameForVolumeMountPointA( lpszVolumeMountPoint: LPCSTR, lpszVolumeName: LPSTR, cchBufferLength: DWORD, ) -> BOOL; pub fn GetVolumePathNameA( lpszFileName: LPCSTR, lpszVolumePathName: LPSTR, cchBufferLength: DWORD, ) -> BOOL; pub fn GetVolumePathNamesForVolumeNameA( lpszVolumeName: LPCSTR, lpszVolumePathNames: LPCH, cchBufferLength: DWORD, lpcchReturnLength: PDWORD, ) -> BOOL; } // ACTCTX_FLAG_* STRUCT!{struct ACTCTXA { cbSize: ULONG, dwFlags: DWORD, lpSource: LPCSTR, wProcessorArchitecture: USHORT, wLangId: LANGID, lpAssemblyDirectory: LPCSTR, lpResourceName: LPCSTR, lpApplicationName: LPCSTR, hModule: HMODULE, }} pub type PACTCTXA = *mut ACTCTXA; STRUCT!{struct ACTCTXW { cbSize: ULONG, dwFlags: DWORD, lpSource: LPCWSTR, wProcessorArchitecture: USHORT, wLangId: LANGID, lpAssemblyDirectory: LPCWSTR, lpResourceName: LPCWSTR, lpApplicationName: LPCWSTR, hModule: HMODULE, }} pub type PACTCTXW = *mut ACTCTXW; pub type PCACTCTXA = *const ACTCTXA; pub type PCACTCTXW = *const ACTCTXW; extern "system" { pub fn CreateActCtxA( pActCtx: PCACTCTXA, ) -> HANDLE; pub fn CreateActCtxW( pActCtx: PCACTCTXW, ) -> HANDLE; pub fn AddRefActCtx( hActCtx: HANDLE, ); pub fn ReleaseActCtx( hActCtx: HANDLE, ); pub fn ZombifyActCtx( hActCtx: HANDLE, ) -> BOOL; pub fn ActivateActCtx( hActCtx: HANDLE, lpCookie: *mut ULONG_PTR, ) -> BOOL; pub fn DeactivateActCtx( dwFlags: DWORD, ulCookie: ULONG_PTR, ) -> BOOL; pub fn GetCurrentActCtx( lphActCtx: *mut HANDLE, ) -> BOOL; } STRUCT!{struct ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA { lpInformation: PVOID, lpSectionBase: PVOID, ulSectionLength: ULONG, lpSectionGlobalDataBase: PVOID, ulSectionGlobalDataLength: ULONG, }} pub type PACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA = *mut ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA; pub type PCACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA = *const ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA; STRUCT!{struct ACTCTX_SECTION_KEYED_DATA { cbSize: ULONG, ulDataFormatVersion: ULONG, lpData: PVOID, ulLength: ULONG, lpSectionGlobalData: PVOID, ulSectionGlobalDataLength: ULONG, lpSectionBase: PVOID, ulSectionTotalLength: ULONG, hActCtx: HANDLE, ulAssemblyRosterIndex: ULONG, ulFlags: ULONG, AssemblyMetadata: ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, }} pub type PACTCTX_SECTION_KEYED_DATA = *mut ACTCTX_SECTION_KEYED_DATA; pub type PCACTCTX_SECTION_KEYED_DATA = *const ACTCTX_SECTION_KEYED_DATA; extern "system" { pub fn FindActCtxSectionStringA( dwFlags: DWORD, lpExtensionGuid: *const GUID, ulSectionId: ULONG, lpStringToFind: LPCSTR, ReturnedData: PACTCTX_SECTION_KEYED_DATA, ) -> BOOL; pub fn FindActCtxSectionStringW( dwFlags: DWORD, lpExtensionGuid: *const GUID, ulSectionId: ULONG, lpStringToFind: LPCWSTR, ReturnedData: PACTCTX_SECTION_KEYED_DATA, ) -> BOOL; pub fn FindActCtxSectionGuid( dwFlags: DWORD, lpExtensionGuid: *const GUID, ulSectionId: ULONG, lpGuidToFind: *const GUID, ReturnedData: PACTCTX_SECTION_KEYED_DATA, ) -> BOOL; pub fn QueryActCtxW( dwFlags: DWORD, hActCtx: HANDLE, pvSubInstance: PVOID, ulInfoClass: ULONG, pvBuffer: PVOID, cbBuffer: SIZE_T, pcbWrittenOrRequired: *mut SIZE_T, ) -> BOOL; pub fn WTSGetActiveConsoleSessionId() -> DWORD; // pub fn WTSGetServiceSessionId(); // pub fn WTSIsServerContainer(); pub fn GetActiveProcessorGroupCount() -> WORD; pub fn GetMaximumProcessorGroupCount() -> WORD; pub fn GetActiveProcessorCount( GroupNumber: WORD, ) -> DWORD; pub fn GetMaximumProcessorCount( GroupNumber: WORD, ) -> DWORD; pub fn GetNumaProcessorNode( Processor: UCHAR, NodeNumber: PUCHAR, ) -> BOOL; pub fn GetNumaNodeNumberFromHandle( hFile: HANDLE, NodeNumber: PUSHORT, ) -> BOOL; pub fn GetNumaProcessorNodeEx( Processor: PPROCESSOR_NUMBER, NodeNumber: PUSHORT, ) -> BOOL; pub fn GetNumaNodeProcessorMask( Node: UCHAR, ProcessorMask: PULONGLONG, ) -> BOOL; pub fn GetNumaAvailableMemoryNode( Node: UCHAR, AvailableBytes: PULONGLONG, ) -> BOOL; pub fn GetNumaAvailableMemoryNodeEx( Node: USHORT, AvailableBytes: PULONGLONG, ) -> BOOL; pub fn GetNumaProximityNode( ProximityId: ULONG, NodeNumber: PUCHAR, ) -> BOOL; } FN!{stdcall APPLICATION_RECOVERY_CALLBACK( pvParameter: PVOID, ) -> DWORD} // RESTART_* // RECOVERY_* extern "system" { pub fn RegisterApplicationRecoveryCallback( pRecoveyCallback: APPLICATION_RECOVERY_CALLBACK, pvParameter: PVOID, dwPingInterval: DWORD, dwFlags: DWORD, ) -> HRESULT; pub fn UnregisterApplicationRecoveryCallback() -> HRESULT; pub fn RegisterApplicationRestart( pwzCommandline: PCWSTR, dwFlags: DWORD, ) -> HRESULT; pub fn UnregisterApplicationRestart() -> HRESULT; pub fn GetApplicationRecoveryCallback( hProcess: HANDLE, pRecoveryCallback: *mut APPLICATION_RECOVERY_CALLBACK, ppvParameter: *mut PVOID, pdwPingInterval: PDWORD, pdwFlags: PDWORD, ) -> HRESULT; pub fn GetApplicationRestartSettings( hProcess: HANDLE, pwzCommandline: PWSTR, pcchSize: PDWORD, pdwFlags: PDWORD, ) -> HRESULT; pub fn ApplicationRecoveryInProgress( pbCancelled: PBOOL, ) -> HRESULT; pub fn ApplicationRecoveryFinished( bSuccess: BOOL, ); } // FILE_BASIC_INFO, etc. extern "system" { pub fn GetFileInformationByHandleEx( hFile: HANDLE, FileInformationClass: FILE_INFO_BY_HANDLE_CLASS, lpFileInformation: LPVOID, dwBufferSize: DWORD, ) -> BOOL; } ENUM!{enum FILE_ID_TYPE { FileIdType, ObjectIdType, ExtendedFileIdType, MaximumFileIdType, }} UNION!{union FILE_ID_DESCRIPTOR_u { [u64; 2], FileId FileId_mut: LARGE_INTEGER, ObjectId ObjectId_mut: GUID, ExtendedFileId ExtendedFileId_mut: FILE_ID_128, }} STRUCT!{struct FILE_ID_DESCRIPTOR { dwSize: DWORD, Type: FILE_ID_TYPE, u: FILE_ID_DESCRIPTOR_u, }} pub type LPFILE_ID_DESCRIPTOR = *mut FILE_ID_DESCRIPTOR; extern "system" { pub fn OpenFileById( hVolumeHint: HANDLE, lpFileId: LPFILE_ID_DESCRIPTOR, dwDesiredAccess: DWORD, dwShareMode: DWORD, lpSecurityAttributes: LPSECURITY_ATTRIBUTES, dwFlagsAndAttributes: DWORD, ) -> HANDLE; pub fn CreateSymbolicLinkA( lpSymlinkFileName: LPCSTR, lpTargetFileName: LPCSTR, dwFlags: DWORD, ) -> BOOLEAN; pub fn CreateSymbolicLinkW( lpSymlinkFileName: LPCWSTR, lpTargetFileName: LPCWSTR, dwFlags: DWORD, ) -> BOOLEAN; pub fn QueryActCtxSettingsW( dwFlags: DWORD, hActCtx: HANDLE, settingsNameSpace: PCWSTR, settingName: PCWSTR, pvBuffer: PWSTR, dwBuffer: SIZE_T, pdwWrittenOrRequired: *mut SIZE_T, ) -> BOOL; pub fn CreateSymbolicLinkTransactedA( lpSymlinkFileName: LPCSTR, lpTargetFileName: LPCSTR, dwFlags: DWORD, hTransaction: HANDLE, ) -> BOOLEAN; pub fn CreateSymbolicLinkTransactedW( lpSymlinkFileName: LPCWSTR, lpTargetFileName: LPCWSTR, dwFlags: DWORD, hTransaction: HANDLE, ) -> BOOLEAN; pub fn ReplacePartitionUnit( TargetPartition: PWSTR, SparePartition: PWSTR, Flags: ULONG, ) -> BOOL; pub fn AddSecureMemoryCacheCallback( pfnCallBack: PSECURE_MEMORY_CACHE_CALLBACK, ) -> BOOL; pub fn RemoveSecureMemoryCacheCallback( pfnCallBack: PSECURE_MEMORY_CACHE_CALLBACK, ) -> BOOL; pub fn CopyContext( Destination: PCONTEXT, ContextFlags: DWORD, Source: PCONTEXT, ) -> BOOL; pub fn InitializeContext( Buffer: PVOID, ContextFlags: DWORD, Context: *mut PCONTEXT, ContextLength: PDWORD, ) -> BOOL; pub fn GetEnabledXStateFeatures() -> DWORD64; pub fn GetXStateFeaturesMask( Context: PCONTEXT, FeatureMask: PDWORD64, ) -> BOOL; #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] pub fn LocateXStateFeature( Context: PCONTEXT, FeatureId: DWORD, Length: PDWORD, ) -> PVOID; #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] pub fn SetXStateFeaturesMask( Context: PCONTEXT, FeatureMask: DWORD64, ) -> BOOL; pub fn EnableThreadProfiling( ThreadHandle: HANDLE, Flags: DWORD, HardwareCounters: DWORD64, PerformanceDataHandle: *mut HANDLE, ) -> BOOL; pub fn DisableThreadProfiling( PerformanceDataHandle: HANDLE, ) -> DWORD; pub fn QueryThreadProfiling( ThreadHandle: HANDLE, Enabled: PBOOLEAN, ) -> DWORD; pub fn ReadThreadProfilingData( PerformanceDataHandle: HANDLE, Flags: DWORD, PerformanceData: PPERFORMANCE_DATA, ) -> DWORD; // intrinsic InterlockedIncrement // intrinsic InterlockedDecrement // intrinsic InterlockedExchange // intrinsic InterlockedExchangeAdd // intrinsic InterlockedExchangeSubtract // intrinsic InterlockedCompareExchange // intrinsic InterlockedAnd // intrinsic InterlockedOr // intrinsic InterlockedXor }