From e2b87dd58ccc7bd98c50473e8b53631bc32a1424 Mon Sep 17 00:00:00 2001 From: Arghyadip Chakraborty Date: Wed, 31 May 2023 14:34:55 +0530 Subject: [PATCH 1/3] Migrate to windows-sys --- .rustfmt.toml | 2 + Cargo.toml | 43 +- build.rs | 16 +- src/ctypes.rs | 23 + src/lib.rs | 23 +- src/macros.rs | 52 + src/ntapi_base.rs | 42 +- src/ntdbg.rs | 207 +- src/ntexapi.rs | 3240 +++++++++++---------- src/ntgdi.rs | 189 +- src/ntioapi.rs | 1517 +++++----- src/ntkeapi.rs | 29 +- src/ntldr.rs | 751 ++--- src/ntlpcapi.rs | 700 ++--- src/ntmisc.rs | 33 +- src/ntmmapi.rs | 560 ++-- src/ntnls.rs | 43 +- src/ntobapi.rs | 224 +- src/ntpebteb.rs | 612 ++-- src/ntpfapi.rs | 205 +- src/ntpnpapi.rs | 83 +- src/ntpoapi.rs | 122 +- src/ntpsapi.rs | 1353 ++++----- src/ntregapi.rs | 433 +-- src/ntrtl.rs | 4393 +++++++++++++++-------------- src/ntsam.rs | 938 +++--- src/ntseapi.rs | 597 ++-- src/ntsmss.rs | 15 +- src/nttmapi.rs | 232 +- src/nttp.rs | 120 +- src/ntwow64.rs | 595 ++-- src/ntxcapi.rs | 37 +- src/ntzwapi.rs | 2563 ++++++++--------- src/string.rs | 11 +- src/subprocesstag.rs | 90 +- src/winapi_local.rs | 1 - src/winapi_local/um.rs | 2 - src/winapi_local/um/winioctl.rs | 4 - src/winapi_local/um/winnt.rs | 71 - src/windows_local/mod.rs | 8 + src/windows_local/shared/ntdef.rs | 30 + src/windows_local/um/winioctl.rs | 9 + src/windows_local/um/winnt.rs | 77 + src/winsta.rs | 762 ++--- tests/layout_aarch64.rs | 795 ++++-- tests/layout_x86.rs | 780 ++++- tests/layout_x86_64.rs | 800 ++++-- 47 files changed, 12830 insertions(+), 10602 deletions(-) create mode 100755 .rustfmt.toml create mode 100644 src/ctypes.rs delete mode 100644 src/winapi_local.rs delete mode 100644 src/winapi_local/um.rs delete mode 100644 src/winapi_local/um/winioctl.rs delete mode 100644 src/winapi_local/um/winnt.rs create mode 100644 src/windows_local/mod.rs create mode 100644 src/windows_local/shared/ntdef.rs create mode 100644 src/windows_local/um/winioctl.rs create mode 100644 src/windows_local/um/winnt.rs diff --git a/.rustfmt.toml b/.rustfmt.toml new file mode 100755 index 0000000..ccfdc1e --- /dev/null +++ b/.rustfmt.toml @@ -0,0 +1,2 @@ +max_width = 80 +tab_spaces = 4 diff --git a/Cargo.toml b/Cargo.toml index cc34a4b..e2d11a7 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -9,20 +9,51 @@ repository = "https://github.com/MSxDOS/ntapi" readme = "README.md" categories = ["external-ffi-bindings", "no-std", "os::windows-apis"] keywords = ["windows", "ffi", "ntapi", "native", "win32"] -include = ["src/**/*", "Cargo.toml", "build.rs", "README.md", "LICENSE-APACHE", "LICENSE-MIT"] +include = [ + "src/**/*", + "Cargo.toml", + "build.rs", + "README.md", + "LICENSE-APACHE", + "LICENSE-MIT", +] edition = "2018" [package.metadata.docs.rs] default-target = "x86_64-pc-windows-msvc" -targets = ["aarch64-pc-windows-msvc", "i686-pc-windows-msvc", "x86_64-pc-windows-msvc"] +targets = [ + "aarch64-pc-windows-msvc", + "i686-pc-windows-msvc", + "x86_64-pc-windows-msvc", +] -[dependencies.winapi] -version = "0.3.9" -features = ["cfg", "evntrace", "in6addr", "inaddr", "minwinbase", "ntsecapi", "windef", "winioctl"] +[dependencies.windows-sys] +version = "0.48.0" +features = [ + 'Win32_Devices_DeviceAndDriverInstallation', + 'Win32_Foundation', + 'Win32_Networking_WinSock', + 'Win32_Security_Authentication_Identity', + 'Win32_Security', + 'Win32_Storage_FileSystem', + 'Win32_System_Diagnostics_Debug', + 'Win32_System_Diagnostics_Etw', + 'Win32_System_Ioctl', + 'Win32_System_JobObjects', + 'Win32_System_Kernel', + 'Win32_System_Memory', + 'Win32_System_Performance_HardwareCounterProfiling', + 'Win32_System_Power', + 'Win32_System_SystemInformation', + 'Win32_System_SystemServices', + 'Win32_System_Threading', + 'Win32_System_WindowsProgramming', + 'Win32_UI_WindowsAndMessaging', +] [features] default = ["user"] func-types = [] -impl-default = ["winapi/impl-default"] +impl-default = [] user = [] kernel = [] diff --git a/build.rs b/build.rs index bbd46f5..0ef7a9b 100644 --- a/build.rs +++ b/build.rs @@ -1,15 +1,13 @@ use std::env::var; fn main() { - #[cfg(feature = "user")] { - if var("TARGET").map( - |t| t == "x86_64-pc-windows-gnu" || t == "i686-pc-windows-gnu" - ).unwrap_or(false) { - if var("WINAPI_NO_BUNDLED_LIBRARIES").is_ok() { - println!("cargo:rustc-link-lib=ntdll"); - } else { - println!("cargo:rustc-link-lib=winapi_ntdll"); - } + #[cfg(feature = "user")] + { + if var("TARGET") + .map(|t| t == "x86_64-pc-windows-gnu" || t == "i686-pc-windows-gnu") + .unwrap_or(false) + { + println!("cargo:rustc-link-lib=ntdll"); } } } diff --git a/src/ctypes.rs b/src/ctypes.rs new file mode 100644 index 0000000..6a732bf --- /dev/null +++ b/src/ctypes.rs @@ -0,0 +1,23 @@ +pub use core::ffi::c_void; +pub type c_char = i8; +pub type c_schar = i8; +pub type c_uchar = u8; +pub type c_short = i16; +pub type c_ushort = u16; +pub type c_int = i32; +pub type c_uint = u32; +pub type c_long = i32; +pub type c_ulong = u32; +pub type c_longlong = i64; +pub type c_ulonglong = u64; +pub type c_float = f32; +pub type c_double = f64; +pub type __int8 = i8; +pub type __uint8 = u8; +pub type __int16 = i16; +pub type __uint16 = u16; +pub type __int32 = i32; +pub type __uint32 = u32; +pub type __int64 = i64; +pub type __uint64 = u64; +pub type wchar_t = u16; diff --git a/src/lib.rs b/src/lib.rs index 0f7708c..74d13c4 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -6,18 +6,29 @@ //! //! [fn_ptr]: https://doc.rust-lang.org/reference/types.html#function-pointer-types //! [`Default`]: https://doc.rust-lang.org/std/default/trait.Default.html#tymethod.default -#![cfg(all(windows, any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64")))] +#![cfg(all( + windows, + any(target_arch = "x86", target_arch = "x86_64", target_arch = "aarch64") +))] #![no_std] #![deny(unused, unused_qualifications)] #![warn(unused_attributes)] -#![allow(bad_style, deprecated, overflowing_literals, unused_macros, clippy::cast_lossless, clippy::cast_ptr_alignment, clippy::len_without_is_empty, clippy::trivially_copy_pass_by_ref, clippy::unreadable_literal)] +#![allow( + bad_style, + deprecated, + overflowing_literals, + unused_macros, + clippy::cast_lossless, + clippy::cast_ptr_alignment, + clippy::len_without_is_empty, + clippy::trivially_copy_pass_by_ref, + clippy::unreadable_literal +)] #[doc(hidden)] pub extern crate core as _core; #[macro_use] -#[doc(hidden)] -pub extern crate winapi; -#[macro_use] mod macros; +pub mod ctypes; pub mod ntapi_base; pub mod ntdbg; pub mod ntexapi; @@ -47,5 +58,5 @@ pub mod ntxcapi; pub mod ntzwapi; pub mod string; pub mod subprocesstag; -pub mod winapi_local; +pub mod windows_local; pub mod winsta; diff --git a/src/macros.rs b/src/macros.rs index 19ecc4d..02a56f3 100644 --- a/src/macros.rs +++ b/src/macros.rs @@ -88,6 +88,58 @@ macro_rules! UNION { fn default() -> $name { unsafe { $crate::_core::mem::zeroed() } } } ); + ($(#[$attrs:meta])* union $name:ident { + [$stype:ty; $ssize:expr], + $($variant:ident $variant_mut:ident: $ftype:ty,)+ + }) => ( + #[repr(C)] $(#[$attrs])* + pub struct $name([$stype; $ssize]); + impl Copy for $name {} + impl Clone for $name { + #[inline] + fn clone(&self) -> $name { *self } + } + #[cfg(feature = "impl-default")] + impl Default for $name { + #[inline] + fn default() -> $name { unsafe { $crate::_core::mem::zeroed() } } + } + impl $name {$( + #[inline] + pub unsafe fn $variant(&self) -> &$ftype { + &*(self as *const _ as *const $ftype) + } + #[inline] + pub unsafe fn $variant_mut(&mut self) -> &mut $ftype { + &mut *(self as *mut _ as *mut $ftype) + } + )+} + ); +} +macro_rules! ENUM { + {enum $name:ident { $($variant:ident = $value:expr,)+ }} => { + pub type $name = u32; + $(pub const $variant: $name = $value;)+ + }; +} +macro_rules! STRUCT { + ($(#[$attrs:meta])* struct $name:ident { + $($field:ident: $ftype:ty,)+ + }) => ( + #[repr(C)] #[derive(Copy, Clone)] $(#[$attrs])* + pub struct $name { + $(pub $field: $ftype,)+ + } + // impl Clone for $name { + // #[inline] + // fn clone(&self) -> $name { *self } + // } + #[cfg(feature = "impl-default")] + impl Default for $name { + #[inline] + fn default() -> $name { unsafe { $crate::_core::mem::zeroed() } } + } + ); } macro_rules! FN { (stdcall $func:ident($($p:ident: $t:ty,)*) -> $ret:ty) => ( diff --git a/src/ntapi_base.rs b/src/ntapi_base.rs index aa341af..1e69c52 100644 --- a/src/ntapi_base.rs +++ b/src/ntapi_base.rs @@ -1,40 +1,42 @@ -use winapi::shared::ntdef::{HANDLE, LONG, NTSTATUS, ULONG, ULONGLONG, USHORT}; -use winapi::shared::ntstatus::FACILITY_NTWIN32; -pub type KPRIORITY = LONG; -pub type RTL_ATOM = USHORT; +use windows_sys::Win32::Foundation::{FACILITY_NTWIN32, HANDLE, NTSTATUS}; + +use crate::ctypes::{__uint64, c_long, c_ulong, c_ushort}; + +pub type KPRIORITY = c_long; +pub type RTL_ATOM = c_ushort; pub type PRTL_ATOM = *mut RTL_ATOM; -pub const NT_FACILITY_MASK: ULONG = 0xfff; -pub const NT_FACILITY_SHIFT: ULONG = 16; +pub const NT_FACILITY_MASK: c_ulong = 0xfff; +pub const NT_FACILITY_SHIFT: c_ulong = 16; #[inline] -pub const fn NT_FACILITY(Status: NTSTATUS) -> ULONG { +pub const fn NT_FACILITY(Status: NTSTATUS) -> c_ulong { (Status as u32) >> NT_FACILITY_SHIFT & NT_FACILITY_MASK } #[inline] pub const fn NT_NTWIN32(Status: NTSTATUS) -> bool { - NT_FACILITY(Status) == FACILITY_NTWIN32 as u32 + NT_FACILITY(Status) == FACILITY_NTWIN32 } #[inline] -pub const fn WIN32_FROM_NTSTATUS(Status: NTSTATUS) -> ULONG { +pub const fn WIN32_FROM_NTSTATUS(Status: NTSTATUS) -> c_ulong { (Status as u32) & 0xffff } -STRUCT!{struct CLIENT_ID { +STRUCT! {struct CLIENT_ID { UniqueProcess: HANDLE, UniqueThread: HANDLE, }} pub type PCLIENT_ID = *mut CLIENT_ID; -STRUCT!{struct CLIENT_ID32 { - UniqueProcess: ULONG, - UniqueThread: ULONG, +STRUCT! {struct CLIENT_ID32 { + UniqueProcess: c_ulong, + UniqueThread: c_ulong, }} pub type PCLIENT_ID32 = *mut CLIENT_ID32; -STRUCT!{struct CLIENT_ID64 { - UniqueProcess: ULONGLONG, - UniqueThread: ULONGLONG, +STRUCT! {struct CLIENT_ID64 { + UniqueProcess: __uint64, + UniqueThread: __uint64, }} pub type PCLIENT_ID64 = *mut CLIENT_ID64; -STRUCT!{struct KSYSTEM_TIME { - LowPart: ULONG, - High1Time: LONG, - High2Time: LONG, +STRUCT! {struct KSYSTEM_TIME { + LowPart: c_ulong, + High1Time: c_long, + High2Time: c_long, }} pub type PKSYSTEM_TIME = *mut KSYSTEM_TIME; diff --git a/src/ntdbg.rs b/src/ntdbg.rs index 991e8f9..12e50b7 100644 --- a/src/ntdbg.rs +++ b/src/ntdbg.rs @@ -1,18 +1,29 @@ -use crate::ntapi_base::{CLIENT_ID, PCLIENT_ID}; -use winapi::shared::evntprov::EVENT_FILTER_DESCRIPTOR; -use winapi::shared::guiddef::LPCGUID; -use winapi::shared::ntdef::{ - BOOLEAN, HANDLE, NTSTATUS, PCCH, PCH, PCSTR, PHANDLE, PLARGE_INTEGER, POBJECT_ATTRIBUTES, - PULONG, PVOID, UCHAR, ULONG, ULONGLONG, +use windows_sys::{ + core::GUID, + Win32::{ + Foundation::{HANDLE, NTSTATUS}, + Storage::FileSystem::{STANDARD_RIGHTS_REQUIRED, SYNCHRONIZE}, + System::{ + Diagnostics::{ + Debug::{DEBUG_EVENT, EXCEPTION_RECORD}, + Etw::EVENT_FILTER_DESCRIPTOR, + }, + WindowsProgramming::OBJECT_ATTRIBUTES, + }, + }, }; -use winapi::um::minwinbase::LPDEBUG_EVENT; -use winapi::um::winnt::{ACCESS_MASK, EXCEPTION_RECORD, STANDARD_RIGHTS_REQUIRED, SYNCHRONIZE}; -use winapi::vc::vadefs::va_list; -EXTERN!{extern "system" { + +use crate::{ + ctypes::{__uint64, c_char, c_uchar, c_ulong, c_void}, + ntapi_base::{CLIENT_ID, PCLIENT_ID}, + windows_local::shared::ntdef::LARGE_INTEGER, +}; + +EXTERN! {extern "system" { fn DbgUserBreakPoint(); fn DbgBreakPoint(); fn DbgBreakPointWithStatus( - Status: ULONG, + Status: c_ulong, ); }} pub const DBG_STATUS_CONTROL_C: u32 = 1; @@ -22,87 +33,87 @@ pub const DBG_STATUS_BUGCHECK_SECOND: u32 = 4; pub const DBG_STATUS_FATAL: u32 = 5; pub const DBG_STATUS_DEBUG_CONTROL: u32 = 6; pub const DBG_STATUS_WORKER: u32 = 7; -EXTERN!{extern "C" { +EXTERN! {extern "C" { fn DbgPrint( - Format: PCSTR, + Format: *const c_char, ... - ) -> ULONG; + ) -> c_ulong; fn DbgPrintEx( - ComponentId: ULONG, - Level: ULONG, - Format: PCSTR, + ComponentId: c_ulong, + Level: c_ulong, + Format: *const c_char, ... - ) -> ULONG; + ) -> c_ulong; }} -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn vDbgPrintEx( - ComponentId: ULONG, - Level: ULONG, - Format: PCCH, - arglist: va_list, - ) -> ULONG; + ComponentId: c_ulong, + Level: c_ulong, + Format: *const c_char, + arglist: *mut c_char, + ) -> c_ulong; fn vDbgPrintExWithPrefix( - Prefix: PCH, - ComponentId: ULONG, - Level: ULONG, - Format: PCCH, - arglist: va_list, - ) -> ULONG; + Prefix: *mut c_char, + ComponentId: c_ulong, + Level: c_ulong, + Format: *const c_char, + arglist: *mut c_char, + ) -> c_ulong; fn DbgQueryDebugFilterState( - ComponentId: ULONG, - Level: ULONG, + ComponentId: c_ulong, + Level: c_ulong, ) -> NTSTATUS; fn DbgSetDebugFilterState( - ComponentId: ULONG, - Level: ULONG, - State: BOOLEAN, + ComponentId: c_ulong, + Level: c_ulong, + State: c_uchar, ) -> NTSTATUS; fn DbgPrompt( - Prompt: PCCH, - Response: PCH, - Length: ULONG, - ) -> ULONG; + Prompt: *const c_char, + Response: *mut c_char, + Length: c_ulong, + ) -> c_ulong; }} -STRUCT!{struct DBGKM_EXCEPTION { +STRUCT! {struct DBGKM_EXCEPTION { ExceptionRecord: EXCEPTION_RECORD, - FirstChance: ULONG, + FirstChance: c_ulong, }} pub type PDBGKM_EXCEPTION = *mut DBGKM_EXCEPTION; -STRUCT!{struct DBGKM_CREATE_THREAD { - SubSystemKey: ULONG, - StartAddress: PVOID, +STRUCT! {struct DBGKM_CREATE_THREAD { + SubSystemKey: c_ulong, + StartAddress: *mut c_void, }} pub type PDBGKM_CREATE_THREAD = *mut DBGKM_CREATE_THREAD; -STRUCT!{struct DBGKM_CREATE_PROCESS { - SubSystemKey: ULONG, +STRUCT! {struct DBGKM_CREATE_PROCESS { + SubSystemKey: c_ulong, FileHandle: HANDLE, - BaseOfImage: PVOID, - DebugInfoFileOffset: ULONG, - DebugInfoSize: ULONG, + BaseOfImage: *mut c_void, + DebugInfoFileOffset: c_ulong, + DebugInfoSize: c_ulong, InitialThread: DBGKM_CREATE_THREAD, }} pub type PDBGKM_CREATE_PROCESS = *mut DBGKM_CREATE_PROCESS; -STRUCT!{struct DBGKM_EXIT_THREAD { +STRUCT! {struct DBGKM_EXIT_THREAD { ExitStatus: NTSTATUS, }} pub type PDBGKM_EXIT_THREAD = *mut DBGKM_EXIT_THREAD; -STRUCT!{struct DBGKM_EXIT_PROCESS { +STRUCT! {struct DBGKM_EXIT_PROCESS { ExitStatus: NTSTATUS, }} pub type PDBGKM_EXIT_PROCESS = *mut DBGKM_EXIT_PROCESS; -STRUCT!{struct DBGKM_LOAD_DLL { +STRUCT! {struct DBGKM_LOAD_DLL { FileHandle: HANDLE, - BaseOfDll: PVOID, - DebugInfoFileOffset: ULONG, - DebugInfoSize: ULONG, - NamePointer: PVOID, + BaseOfDll: *mut c_void, + DebugInfoFileOffset: c_ulong, + DebugInfoSize: c_ulong, + NamePointer: *mut c_void, }} pub type PDBGKM_LOAD_DLL = *mut DBGKM_LOAD_DLL; -STRUCT!{struct DBGKM_UNLOAD_DLL { - BaseAddress: PVOID, +STRUCT! {struct DBGKM_UNLOAD_DLL { + BaseAddress: *mut c_void, }} pub type PDBGKM_UNLOAD_DLL = *mut DBGKM_UNLOAD_DLL; -ENUM!{enum DBG_STATE { +ENUM! {enum DBG_STATE { DbgIdle = 0, DbgReplyPending = 1, DbgCreateThreadStateChange = 2, @@ -116,17 +127,17 @@ ENUM!{enum DBG_STATE { DbgUnloadDllStateChange = 10, }} pub type PDBG_STATE = *mut DBG_STATE; -STRUCT!{struct DBGUI_CREATE_THREAD { +STRUCT! {struct DBGUI_CREATE_THREAD { HandleToThread: HANDLE, NewThread: DBGKM_CREATE_THREAD, }} pub type PDBGUI_CREATE_THREAD = *mut DBGUI_CREATE_THREAD; -STRUCT!{struct DBGUI_CREATE_PROCESS { +STRUCT! {struct DBGUI_CREATE_PROCESS { HandleToProcess: HANDLE, HandleToThread: HANDLE, NewProcess: DBGKM_CREATE_PROCESS, }} -UNION!{union DBGUI_WAIT_STATE_CHANGE_StateInfo { +UNION! {union DBGUI_WAIT_STATE_CHANGE_StateInfo { Exception: DBGKM_EXCEPTION, CreateThread: DBGUI_CREATE_THREAD, CreateProcessInfo: DBGUI_CREATE_PROCESS, @@ -136,31 +147,35 @@ UNION!{union DBGUI_WAIT_STATE_CHANGE_StateInfo { UnloadDll: DBGKM_UNLOAD_DLL, }} pub type PDBGUI_CREATE_PROCESS = *mut DBGUI_CREATE_PROCESS; -STRUCT!{struct DBGUI_WAIT_STATE_CHANGE { +STRUCT! {struct DBGUI_WAIT_STATE_CHANGE { NewState: DBG_STATE, AppClientId: CLIENT_ID, StateInfo: DBGUI_WAIT_STATE_CHANGE_StateInfo, }} pub type PDBGUI_WAIT_STATE_CHANGE = *mut DBGUI_WAIT_STATE_CHANGE; -pub const DEBUG_READ_EVENT: ULONG = 0x0001; -pub const DEBUG_PROCESS_ASSIGN: ULONG = 0x0002; -pub const DEBUG_SET_INFORMATION: ULONG = 0x0004; -pub const DEBUG_QUERY_INFORMATION: ULONG = 0x0008; -pub const DEBUG_ALL_ACCESS: ACCESS_MASK = STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | DEBUG_READ_EVENT - | DEBUG_PROCESS_ASSIGN | DEBUG_SET_INFORMATION | DEBUG_QUERY_INFORMATION; +pub const DEBUG_READ_EVENT: c_ulong = 0x0001; +pub const DEBUG_PROCESS_ASSIGN: c_ulong = 0x0002; +pub const DEBUG_SET_INFORMATION: c_ulong = 0x0004; +pub const DEBUG_QUERY_INFORMATION: c_ulong = 0x0008; +pub const DEBUG_ALL_ACCESS: c_ulong = STANDARD_RIGHTS_REQUIRED + | SYNCHRONIZE + | DEBUG_READ_EVENT + | DEBUG_PROCESS_ASSIGN + | DEBUG_SET_INFORMATION + | DEBUG_QUERY_INFORMATION; pub const DEBUG_KILL_ON_CLOSE: u32 = 0x1; -ENUM!{enum DEBUGOBJECTINFOCLASS { +ENUM! {enum DEBUGOBJECTINFOCLASS { DebugObjectUnusedInformation = 0, DebugObjectKillProcessOnExitInformation = 1, MaxDebugObjectInfoClass = 2, }} pub type PDEBUGOBJECTINFOCLASS = *mut DEBUGOBJECTINFOCLASS; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtCreateDebugObject( - DebugObjectHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - Flags: ULONG, + DebugObjectHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + Flags: c_ulong, ) -> NTSTATUS; fn NtDebugActiveProcess( ProcessHandle: HANDLE, @@ -178,15 +193,15 @@ EXTERN!{extern "system" { fn NtSetInformationDebugObject( DebugObjectHandle: HANDLE, DebugObjectInformationClass: DEBUGOBJECTINFOCLASS, - DebugInformation: PVOID, - DebugInformationLength: ULONG, - ReturnLength: PULONG, + DebugInformation: *mut c_void, + DebugInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn NtWaitForDebugEvent( DebugObjectHandle: HANDLE, - Alertable: BOOLEAN, - Timeout: PLARGE_INTEGER, - WaitStateChange: PVOID, + Alertable: c_uchar, + Timeout: *mut LARGE_INTEGER, + WaitStateChange: *mut c_void, ) -> NTSTATUS; fn DbgUiConnectToDbg() -> NTSTATUS; fn DbgUiGetThreadDebugObject() -> HANDLE; @@ -195,7 +210,7 @@ EXTERN!{extern "system" { ); fn DbgUiWaitStateChange( StateChange: PDBGUI_WAIT_STATE_CHANGE, - Timeout: PLARGE_INTEGER, + Timeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn DbgUiContinue( AppClientId: PCLIENT_ID, @@ -208,32 +223,32 @@ EXTERN!{extern "system" { Process: HANDLE, ) -> NTSTATUS; fn DbgUiRemoteBreakin( - Context: PVOID, + Context: *mut c_void, ); fn DbgUiIssueRemoteBreakin( Process: HANDLE, ) -> NTSTATUS; fn DbgUiConvertStateChangeStructure( StateChange: PDBGUI_WAIT_STATE_CHANGE, - DebugEvent: LPDEBUG_EVENT, + DebugEvent: *mut DEBUG_EVENT, ) -> NTSTATUS; }} -FN!{stdcall PENABLECALLBACK( - SourceId: LPCGUID, - IsEnabled: ULONG, - Level: UCHAR, - MatchAnyKeyword: ULONGLONG, - MatchAllKeyword: ULONGLONG, +FN! {stdcall PENABLECALLBACK( + SourceId: *const GUID, + IsEnabled: c_ulong, + Level: c_uchar, + MatchAnyKeyword: __uint64, + MatchAllKeyword: __uint64, FilterData: *mut EVENT_FILTER_DESCRIPTOR, - CallbackContext: PVOID, + CallbackContext: *mut c_void, ) -> ()} -pub type REGHANDLE = ULONGLONG; -pub type PREGHANDLE = *mut ULONGLONG; -EXTERN!{extern "system" { +pub type REGHANDLE = __uint64; +pub type PREGHANDLE = *mut __uint64; +EXTERN! {extern "system" { fn EtwEventRegister( - ProviderId: LPCGUID, + ProviderId: *const GUID, EnableCallback: PENABLECALLBACK, - CallbackContext: PVOID, + CallbackContext: *mut c_void, RegHandle: PREGHANDLE, ) -> NTSTATUS; }} diff --git a/src/ntexapi.rs b/src/ntexapi.rs index 7bc73a0..2657454 100644 --- a/src/ntexapi.rs +++ b/src/ntexapi.rs @@ -1,210 +1,224 @@ -use core::mem::MaybeUninit; -#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] -use core::ptr::addr_of; -use core::ptr::read_volatile; #[cfg(target_arch = "x86")] use core::hint::spin_loop; -use crate::ntapi_base::{CLIENT_ID, KPRIORITY, KSYSTEM_TIME, PRTL_ATOM, RTL_ATOM}; -use crate::ntioapi::{BUS_DATA_TYPE, FILE_IO_COMPLETION_INFORMATION, INTERFACE_TYPE}; -use crate::ntkeapi::{KPROFILE_SOURCE, KTHREAD_STATE, KWAIT_REASON}; -use crate::ntldr::RTL_PROCESS_MODULE_INFORMATION_EX; -use crate::ntpebteb::PTEB; -use crate::ntpoapi::COUNTED_REASON_CONTEXT; -use winapi::shared::basetsd::{KAFFINITY, PULONG64, PULONG_PTR, SIZE_T, ULONG64, ULONG_PTR}; -use winapi::shared::evntrace::PROFILE_SOURCE_INFO; -use winapi::shared::guiddef::{GUID, LPGUID}; -use winapi::shared::ntdef::{ - BOOLEAN, CCHAR, EVENT_TYPE, HANDLE, LANGID, LARGE_INTEGER, LCID, LOGICAL, LONG, LONGLONG, - NTSTATUS, NT_PRODUCT_TYPE, PBOOLEAN, PCHAR, PCWNF_STATE_NAME, PGROUP_AFFINITY, PHANDLE, - PHYSICAL_ADDRESS, PLARGE_INTEGER, PLCID, PLONG, PLUID, POBJECT_ATTRIBUTES, PUCHAR, - PULARGE_INTEGER, PULONG, PUNICODE_STRING, PUSHORT, PVOID, PWNF_STATE_NAME, PWSTR, TIMER_TYPE, - UCHAR, ULARGE_INTEGER, ULONG, ULONGLONG, UNICODE_STRING, USHORT, VOID, WCHAR, WNF_STATE_NAME, +#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] +use core::ptr::addr_of; +use core::{mem::MaybeUninit, ptr::read_volatile}; + +use windows_sys::{ + core::GUID, + Win32::{ + Foundation::{HANDLE, LUID, NTSTATUS, UNICODE_STRING}, + Security::{GENERIC_MAPPING, PSECURITY_DESCRIPTOR}, + Storage::FileSystem::{STANDARD_RIGHTS_REQUIRED, SYNCHRONIZE}, + System::{ + Diagnostics::{ + Debug::XSTATE_CONFIGURATION, Etw::PROFILE_SOURCE_INFO, + }, + Kernel::{EVENT_TYPE, NT_PRODUCT_TYPE, TIMER_TYPE, WNF_STATE_NAME}, + SystemInformation::{FIRMWARE_TYPE, GROUP_AFFINITY}, + SystemServices::ANYSIZE_ARRAY, + WindowsProgramming::OBJECT_ATTRIBUTES, + }, + }, }; -use winapi::um::winnt::{ - ACCESS_MASK, ANYSIZE_ARRAY, FIRMWARE_TYPE, GENERIC_MAPPING, PSECURITY_DESCRIPTOR, - STANDARD_RIGHTS_REQUIRED, SYNCHRONIZE, XSTATE_CONFIGURATION, + +use crate::{ + ctypes::{ + __int64, __uint64, c_char, c_long, c_uchar, c_ulong, c_ushort, c_void, + wchar_t, + }, + ntapi_base::{CLIENT_ID, KPRIORITY, KSYSTEM_TIME, PRTL_ATOM, RTL_ATOM}, + ntioapi::{BUS_DATA_TYPE, FILE_IO_COMPLETION_INFORMATION, INTERFACE_TYPE}, + ntkeapi::{KPROFILE_SOURCE, KTHREAD_STATE, KWAIT_REASON}, + ntldr::RTL_PROCESS_MODULE_INFORMATION_EX, + ntpebteb::PTEB, + ntpoapi::COUNTED_REASON_CONTEXT, + windows_local::{ + shared::ntdef::{LARGE_INTEGER, ULARGE_INTEGER}, + um::winnt::UInt32x32To64, + }, }; -use crate::winapi_local::um::winnt::UInt32x32To64; -EXTERN!{extern "system" { + +EXTERN! {extern "system" { fn NtDelayExecution( - Alertable: BOOLEAN, - DelayInterval: PLARGE_INTEGER, + Alertable: c_uchar, + DelayInterval: *mut LARGE_INTEGER, ) -> NTSTATUS; fn NtQuerySystemEnvironmentValue( - VariableName: PUNICODE_STRING, - VariableValue: PWSTR, - ValueLength: USHORT, - ReturnLength: PUSHORT, + VariableName: *mut UNICODE_STRING, + VariableValue: *mut wchar_t, + ValueLength: c_ushort, + ReturnLength: *mut c_ushort, ) -> NTSTATUS; fn NtSetSystemEnvironmentValue( - VariableName: PUNICODE_STRING, - VariableValue: PUNICODE_STRING, + VariableName: *mut UNICODE_STRING, + VariableValue: *mut UNICODE_STRING, ) -> NTSTATUS; fn NtQuerySystemEnvironmentValueEx( - VariableName: PUNICODE_STRING, - VendorGuid: LPGUID, - Value: PVOID, - ValueLength: PULONG, - Attributes: PULONG, + VariableName: *mut UNICODE_STRING, + VendorGuid: *mut GUID, + Value: *mut c_void, + ValueLength: *mut c_ulong, + Attributes: *mut c_ulong, ) -> NTSTATUS; fn NtSetSystemEnvironmentValueEx( - VariableName: PUNICODE_STRING, - VendorGuid: LPGUID, - Value: PVOID, - ValueLength: ULONG, - Attributes: ULONG, + VariableName: *mut UNICODE_STRING, + VendorGuid: *mut GUID, + Value: *mut c_void, + ValueLength: c_ulong, + Attributes: c_ulong, ) -> NTSTATUS; fn NtEnumerateSystemEnvironmentValuesEx( - InformationClass: ULONG, - Buffer: PVOID, - BufferLength: PULONG, + InformationClass: c_ulong, + Buffer: *mut c_void, + BufferLength: *mut c_ulong, ) -> NTSTATUS; }} -STRUCT!{struct BOOT_ENTRY { - Version: ULONG, - Length: ULONG, - Id: ULONG, - Attributes: ULONG, - FriendlyNameOffset: ULONG, - BootFilePathOffset: ULONG, - OsOptionsLength: ULONG, - OsOptions: [UCHAR; 1], +STRUCT! {struct BOOT_ENTRY { + Version: c_ulong, + Length: c_ulong, + Id: c_ulong, + Attributes: c_ulong, + FriendlyNameOffset: c_ulong, + BootFilePathOffset: c_ulong, + OsOptionsLength: c_ulong, + OsOptions: [c_uchar; 1], }} pub type PBOOT_ENTRY = *mut BOOT_ENTRY; -STRUCT!{struct BOOT_ENTRY_LIST { - NextEntryOffset: ULONG, +STRUCT! {struct BOOT_ENTRY_LIST { + NextEntryOffset: c_ulong, BootEntry: BOOT_ENTRY, }} pub type PBOOT_ENTRY_LIST = *mut BOOT_ENTRY_LIST; -STRUCT!{struct BOOT_OPTIONS { - Version: ULONG, - Length: ULONG, - Timeout: ULONG, - CurrentBootEntryId: ULONG, - NextBootEntryId: ULONG, - HeadlessRedirection: [WCHAR; 1], +STRUCT! {struct BOOT_OPTIONS { + Version: c_ulong, + Length: c_ulong, + Timeout: c_ulong, + CurrentBootEntryId: c_ulong, + NextBootEntryId: c_ulong, + HeadlessRedirection: [wchar_t; 1], }} pub type PBOOT_OPTIONS = *mut BOOT_OPTIONS; -STRUCT!{struct FILE_PATH { - Version: ULONG, - Length: ULONG, - Type: ULONG, - FilePath: [UCHAR; 1], +STRUCT! {struct FILE_PATH { + Version: c_ulong, + Length: c_ulong, + Type: c_ulong, + FilePath: [c_uchar; 1], }} pub type PFILE_PATH = *mut FILE_PATH; -STRUCT!{struct EFI_DRIVER_ENTRY { - Version: ULONG, - Length: ULONG, - Id: ULONG, - FriendlyNameOffset: ULONG, - DriverFilePathOffset: ULONG, +STRUCT! {struct EFI_DRIVER_ENTRY { + Version: c_ulong, + Length: c_ulong, + Id: c_ulong, + FriendlyNameOffset: c_ulong, + DriverFilePathOffset: c_ulong, }} pub type PEFI_DRIVER_ENTRY = *mut EFI_DRIVER_ENTRY; -STRUCT!{struct EFI_DRIVER_ENTRY_LIST { - NextEntryOffset: ULONG, +STRUCT! {struct EFI_DRIVER_ENTRY_LIST { + NextEntryOffset: c_ulong, DriverEntry: EFI_DRIVER_ENTRY, }} pub type PEFI_DRIVER_ENTRY_LIST = *mut EFI_DRIVER_ENTRY_LIST; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtAddBootEntry( BootEntry: PBOOT_ENTRY, - Id: PULONG, + Id: *mut c_ulong, ) -> NTSTATUS; fn NtDeleteBootEntry( - Id: ULONG, + Id: c_ulong, ) -> NTSTATUS; fn NtModifyBootEntry( BootEntry: PBOOT_ENTRY, ) -> NTSTATUS; fn NtEnumerateBootEntries( - Buffer: PVOID, - BufferLength: PULONG, + Buffer: *mut c_void, + BufferLength: *mut c_ulong, ) -> NTSTATUS; fn NtQueryBootEntryOrder( - Ids: PULONG, - Count: PULONG, + Ids: *mut c_ulong, + Count: *mut c_ulong, ) -> NTSTATUS; fn NtSetBootEntryOrder( - Ids: PULONG, - Count: ULONG, + Ids: *mut c_ulong, + Count: c_ulong, ) -> NTSTATUS; fn NtQueryBootOptions( BootOptions: PBOOT_OPTIONS, - BootOptionsLength: PULONG, + BootOptionsLength: *mut c_ulong, ) -> NTSTATUS; fn NtSetBootOptions( BootOptions: PBOOT_OPTIONS, - FieldsToChange: ULONG, + FieldsToChange: c_ulong, ) -> NTSTATUS; fn NtTranslateFilePath( InputFilePath: PFILE_PATH, - OutputType: ULONG, + OutputType: c_ulong, OutputFilePath: PFILE_PATH, - OutputFilePathLength: PULONG, + OutputFilePathLength: *mut c_ulong, ) -> NTSTATUS; fn NtAddDriverEntry( DriverEntry: PEFI_DRIVER_ENTRY, - Id: PULONG, + Id: *mut c_ulong, ) -> NTSTATUS; fn NtDeleteDriverEntry( - Id: ULONG, + Id: c_ulong, ) -> NTSTATUS; fn NtModifyDriverEntry( DriverEntry: PEFI_DRIVER_ENTRY, ) -> NTSTATUS; fn NtEnumerateDriverEntries( - Buffer: PVOID, - BufferLength: PULONG, + Buffer: *mut c_void, + BufferLength: *mut c_ulong, ) -> NTSTATUS; fn NtQueryDriverEntryOrder( - Ids: PULONG, - Count: PULONG, + Ids: *mut c_ulong, + Count: *mut c_ulong, ) -> NTSTATUS; fn NtSetDriverEntryOrder( - Ids: PULONG, - Count: ULONG, + Ids: *mut c_ulong, + Count: c_ulong, ) -> NTSTATUS; }} -ENUM!{enum FILTER_BOOT_OPTION_OPERATION { +ENUM! {enum FILTER_BOOT_OPTION_OPERATION { FilterBootOptionOperationOpenSystemStore = 0, FilterBootOptionOperationSetElement = 1, FilterBootOptionOperationDeleteElement = 2, FilterBootOptionOperationMax = 3, }} -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtFilterBootOption( FilterOperation: FILTER_BOOT_OPTION_OPERATION, - ObjectType: ULONG, - ElementType: ULONG, - Data: PVOID, - DataSize: ULONG, + ObjectType: c_ulong, + ElementType: c_ulong, + Data: *mut c_void, + DataSize: c_ulong, ) -> NTSTATUS; }} pub const EVENT_QUERY_STATE: u32 = 0x0001; -ENUM!{enum EVENT_INFORMATION_CLASS { +ENUM! {enum EVENT_INFORMATION_CLASS { EventBasicInformation = 0, }} -STRUCT!{struct EVENT_BASIC_INFORMATION { +STRUCT! {struct EVENT_BASIC_INFORMATION { EventType: EVENT_TYPE, - EventState: LONG, + EventState: c_long, }} pub type PEVENT_BASIC_INFORMATION = *mut EVENT_BASIC_INFORMATION; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtCreateEvent( - EventHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + EventHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, EventType: EVENT_TYPE, - InitialState: BOOLEAN, + InitialState: c_uchar, ) -> NTSTATUS; fn NtOpenEvent( - EventHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + EventHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn NtSetEvent( EventHandle: HANDLE, - PreviousState: PLONG, + PreviousState: *mut c_long, ) -> NTSTATUS; fn NtSetEventBoostPriority( EventHandle: HANDLE, @@ -214,31 +228,32 @@ EXTERN!{extern "system" { ) -> NTSTATUS; fn NtResetEvent( EventHandle: HANDLE, - PreviousState: PLONG, + PreviousState: *mut c_long, ) -> NTSTATUS; fn NtPulseEvent( EventHandle: HANDLE, - PreviousState: PLONG, + PreviousState: *mut c_long, ) -> NTSTATUS; fn NtQueryEvent( EventHandle: HANDLE, EventInformationClass: EVENT_INFORMATION_CLASS, - EventInformation: PVOID, - EventInformationLength: ULONG, - ReturnLength: PULONG, + EventInformation: *mut c_void, + EventInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; }} -pub const EVENT_PAIR_ALL_ACCESS: ACCESS_MASK = STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE; -EXTERN!{extern "system" { +pub const EVENT_PAIR_ALL_ACCESS: c_ulong = + STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE; +EXTERN! {extern "system" { fn NtCreateEventPair( - EventPairHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + EventPairHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn NtOpenEventPair( - EventPairHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + EventPairHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn NtSetLowEventPair( EventPairHandle: HANDLE, @@ -259,172 +274,173 @@ EXTERN!{extern "system" { EventPairHandle: HANDLE, ) -> NTSTATUS; }} -ENUM!{enum MUTANT_INFORMATION_CLASS { +ENUM! {enum MUTANT_INFORMATION_CLASS { MutantBasicInformation = 0, MutantOwnerInformation = 1, }} -STRUCT!{struct MUTANT_BASIC_INFORMATION { - CurrentCount: LONG, - OwnedByCaller: BOOLEAN, - AbandonedState: BOOLEAN, +STRUCT! {struct MUTANT_BASIC_INFORMATION { + CurrentCount: c_long, + OwnedByCaller: c_uchar, + AbandonedState: c_uchar, }} pub type PMUTANT_BASIC_INFORMATION = *mut MUTANT_BASIC_INFORMATION; -STRUCT!{struct MUTANT_OWNER_INFORMATION { +STRUCT! {struct MUTANT_OWNER_INFORMATION { ClientId: CLIENT_ID, }} pub type PMUTANT_OWNER_INFORMATION = *mut MUTANT_OWNER_INFORMATION; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtCreateMutant( - MutantHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - InitialOwner: BOOLEAN, + MutantHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + InitialOwner: c_uchar, ) -> NTSTATUS; fn NtOpenMutant( - MutantHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + MutantHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn NtReleaseMutant( MutantHandle: HANDLE, - PreviousCount: PLONG, + PreviousCount: *mut c_long, ) -> NTSTATUS; fn NtQueryMutant( MutantHandle: HANDLE, MutantInformationClass: MUTANT_INFORMATION_CLASS, - MutantInformation: PVOID, - MutantInformationLength: ULONG, - ReturnLength: PULONG, + MutantInformation: *mut c_void, + MutantInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; }} pub const SEMAPHORE_QUERY_STATE: u32 = 0x0001; -ENUM!{enum SEMAPHORE_INFORMATION_CLASS { +ENUM! {enum SEMAPHORE_INFORMATION_CLASS { SemaphoreBasicInformation = 0, }} -STRUCT!{struct SEMAPHORE_BASIC_INFORMATION { - CurrentCount: LONG, - MaximumCount: LONG, +STRUCT! {struct SEMAPHORE_BASIC_INFORMATION { + CurrentCount: c_long, + MaximumCount: c_long, }} pub type PSEMAPHORE_BASIC_INFORMATION = *mut SEMAPHORE_BASIC_INFORMATION; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtCreateSemaphore( - SemaphoreHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - InitialCount: LONG, - MaximumCount: LONG, + SemaphoreHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + InitialCount: c_long, + MaximumCount: c_long, ) -> NTSTATUS; fn NtOpenSemaphore( - SemaphoreHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + SemaphoreHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn NtReleaseSemaphore( SemaphoreHandle: HANDLE, - ReleaseCount: LONG, - PreviousCount: PLONG, + ReleaseCount: c_long, + PreviousCount: *mut c_long, ) -> NTSTATUS; fn NtQuerySemaphore( SemaphoreHandle: HANDLE, SemaphoreInformationClass: SEMAPHORE_INFORMATION_CLASS, - SemaphoreInformation: PVOID, - SemaphoreInformationLength: ULONG, - ReturnLength: PULONG, + SemaphoreInformation: *mut c_void, + SemaphoreInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; }} -ENUM!{enum TIMER_INFORMATION_CLASS { +ENUM! {enum TIMER_INFORMATION_CLASS { TimerBasicInformation = 0, }} -STRUCT!{struct TIMER_BASIC_INFORMATION { +STRUCT! {struct TIMER_BASIC_INFORMATION { RemainingTime: LARGE_INTEGER, - TimerState: BOOLEAN, + TimerState: c_uchar, }} pub type PTIMER_BASIC_INFORMATION = *mut TIMER_BASIC_INFORMATION; -FN!{stdcall PTIMER_APC_ROUTINE( - TimerContext: PVOID, - TimerLowValue: ULONG, - TimerHighValue: LONG, +FN! {stdcall PTIMER_APC_ROUTINE( + TimerContext: *mut c_void, + TimerLowValue: c_ulong, + TimerHighValue: c_long, ) -> ()} -ENUM!{enum TIMER_SET_INFORMATION_CLASS { +ENUM! {enum TIMER_SET_INFORMATION_CLASS { TimerSetCoalescableTimer = 0, MaxTimerInfoClass = 1, }} -STRUCT!{struct TIMER_SET_COALESCABLE_TIMER_INFO { +STRUCT! {struct TIMER_SET_COALESCABLE_TIMER_INFO { DueTime: LARGE_INTEGER, TimerApcRoutine: PTIMER_APC_ROUTINE, - TimerContext: PVOID, + TimerContext: *mut c_void, WakeContext: *mut COUNTED_REASON_CONTEXT, - Period: ULONG, - TolerableDelay: ULONG, - PreviousState: PBOOLEAN, + Period: c_ulong, + TolerableDelay: c_ulong, + PreviousState: *mut c_uchar, }} -pub type PTIMER_SET_COALESCABLE_TIMER_INFO = *mut TIMER_SET_COALESCABLE_TIMER_INFO; -EXTERN!{extern "system" { +pub type PTIMER_SET_COALESCABLE_TIMER_INFO = + *mut TIMER_SET_COALESCABLE_TIMER_INFO; +EXTERN! {extern "system" { fn NtCreateTimer( - TimerHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + TimerHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, TimerType: TIMER_TYPE, ) -> NTSTATUS; fn NtOpenTimer( - TimerHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + TimerHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn NtSetTimer( TimerHandle: HANDLE, - DueTime: PLARGE_INTEGER, + DueTime: *mut LARGE_INTEGER, TimerApcRoutine: PTIMER_APC_ROUTINE, - TimerContext: PVOID, - ResumeTimer: BOOLEAN, - Period: LONG, - PreviousState: PBOOLEAN, + TimerContext: *mut c_void, + ResumeTimer: c_uchar, + Period: c_long, + PreviousState: *mut c_uchar, ) -> NTSTATUS; fn NtSetTimerEx( TimerHandle: HANDLE, TimerSetInformationClass: TIMER_SET_INFORMATION_CLASS, - TimerSetInformation: PVOID, - TimerSetInformationLength: ULONG, + TimerSetInformation: *mut c_void, + TimerSetInformationLength: c_ulong, ) -> NTSTATUS; fn NtCancelTimer( TimerHandle: HANDLE, - CurrentState: PBOOLEAN, + CurrentState: *mut c_uchar, ) -> NTSTATUS; fn NtQueryTimer( TimerHandle: HANDLE, TimerInformationClass: TIMER_INFORMATION_CLASS, - TimerInformation: PVOID, - TimerInformationLength: ULONG, - ReturnLength: PULONG, + TimerInformation: *mut c_void, + TimerInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn NtCreateIRTimer( - TimerHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, + TimerHandle: *mut HANDLE, + DesiredAccess: c_ulong, ) -> NTSTATUS; fn NtSetIRTimer( TimerHandle: HANDLE, - DueTime: PLARGE_INTEGER, + DueTime: *mut LARGE_INTEGER, ) -> NTSTATUS; }} -STRUCT!{struct T2_SET_PARAMETERS { - Version: ULONG, - Reserved: ULONG, - NoWakeTolerance: LONGLONG, +STRUCT! {struct T2_SET_PARAMETERS { + Version: c_ulong, + Reserved: c_ulong, + NoWakeTolerance: __int64, }} pub type PT2_SET_PARAMETERS = *mut T2_SET_PARAMETERS; -pub type PT2_CANCEL_PARAMETERS = PVOID; -EXTERN!{extern "system" { +pub type PT2_CANCEL_PARAMETERS = *mut c_void; +EXTERN! {extern "system" { fn NtCreateTimer2( - TimerHandle: PHANDLE, - Reserved1: PVOID, - Reserved2: PVOID, - Attributes: ULONG, - DesiredAccess: ACCESS_MASK, + TimerHandle: *mut HANDLE, + Reserved1: *mut c_void, + Reserved2: *mut c_void, + Attributes: c_ulong, + DesiredAccess: c_ulong, ) -> NTSTATUS; fn NtSetTimer2( TimerHandle: HANDLE, - DueTime: PLARGE_INTEGER, - Period: PLARGE_INTEGER, + DueTime: *mut LARGE_INTEGER, + Period: *mut LARGE_INTEGER, Parameters: PT2_SET_PARAMETERS, ) -> NTSTATUS; fn NtCancelTimer2( @@ -434,29 +450,29 @@ EXTERN!{extern "system" { }} pub const PROFILE_CONTROL: u32 = 0x0001; pub const PROFILE_ALL_ACCESS: u32 = STANDARD_RIGHTS_REQUIRED | PROFILE_CONTROL; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtCreateProfile( - ProfileHandle: PHANDLE, + ProfileHandle: *mut HANDLE, Process: HANDLE, - ProfileBase: PVOID, - ProfileSize: SIZE_T, - BucketSize: ULONG, - Buffer: PULONG, - BufferSize: ULONG, + ProfileBase: *mut c_void, + ProfileSize: usize, + BucketSize: c_ulong, + Buffer: *mut c_ulong, + BufferSize: c_ulong, ProfileSource: KPROFILE_SOURCE, - Affinity: KAFFINITY, + Affinity: usize, ) -> NTSTATUS; fn NtCreateProfileEx( - ProfileHandle: PHANDLE, + ProfileHandle: *mut HANDLE, Process: HANDLE, - ProfileBase: PVOID, - ProfileSize: SIZE_T, - BucketSize: ULONG, - Buffer: PULONG, - BufferSize: ULONG, + ProfileBase: *mut c_void, + ProfileSize: usize, + BucketSize: c_ulong, + Buffer: *mut c_ulong, + BufferSize: c_ulong, ProfileSource: KPROFILE_SOURCE, - GroupCount: USHORT, - GroupAffinity: PGROUP_AFFINITY, + GroupCount: c_ushort, + GroupAffinity: *mut GROUP_AFFINITY, ) -> NTSTATUS; fn NtStartProfile( ProfileHandle: HANDLE, @@ -466,137 +482,137 @@ EXTERN!{extern "system" { ) -> NTSTATUS; fn NtQueryIntervalProfile( ProfileSource: KPROFILE_SOURCE, - Interval: PULONG, + Interval: *mut c_ulong, ) -> NTSTATUS; fn NtSetIntervalProfile( - Interval: ULONG, + Interval: c_ulong, Source: KPROFILE_SOURCE, ) -> NTSTATUS; }} -pub const KEYEDEVENT_WAIT: ULONG = 0x0001; -pub const KEYEDEVENT_WAKE: ULONG = 0x0002; -pub const KEYEDEVENT_ALL_ACCESS: ACCESS_MASK = +pub const KEYEDEVENT_WAIT: c_ulong = 0x0001; +pub const KEYEDEVENT_WAKE: c_ulong = 0x0002; +pub const KEYEDEVENT_ALL_ACCESS: c_ulong = STANDARD_RIGHTS_REQUIRED | KEYEDEVENT_WAIT | KEYEDEVENT_WAKE; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtCreateKeyedEvent( - KeyedEventHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - Flags: ULONG, + KeyedEventHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + Flags: c_ulong, ) -> NTSTATUS; fn NtOpenKeyedEvent( - KeyedEventHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + KeyedEventHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn NtReleaseKeyedEvent( KeyedEventHandle: HANDLE, - KeyValue: PVOID, - Alertable: BOOLEAN, - Timeout: PLARGE_INTEGER, + KeyValue: *mut c_void, + Alertable: c_uchar, + Timeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn NtWaitForKeyedEvent( KeyedEventHandle: HANDLE, - KeyValue: PVOID, - Alertable: BOOLEAN, - Timeout: PLARGE_INTEGER, + KeyValue: *mut c_void, + Alertable: c_uchar, + Timeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn NtUmsThreadYield( - SchedulerParam: PVOID, + SchedulerParam: *mut c_void, ) -> NTSTATUS; }} -ENUM!{enum WNF_STATE_NAME_LIFETIME { +ENUM! {enum WNF_STATE_NAME_LIFETIME { WnfWellKnownStateName = 0, WnfPermanentStateName = 1, WnfPersistentStateName = 2, WnfTemporaryStateName = 3, }} -ENUM!{enum WNF_STATE_NAME_INFORMATION { +ENUM! {enum WNF_STATE_NAME_INFORMATION { WnfInfoStateNameExist = 0, WnfInfoSubscribersPresent = 1, WnfInfoIsQuiescent = 2, }} -ENUM!{enum WNF_DATA_SCOPE { +ENUM! {enum WNF_DATA_SCOPE { WnfDataScopeSystem = 0, WnfDataScopeSession = 1, WnfDataScopeUser = 2, WnfDataScopeProcess = 3, WnfDataScopeMachine = 4, }} -STRUCT!{struct WNF_TYPE_ID { +STRUCT! {struct WNF_TYPE_ID { TypeId: GUID, }} pub type PWNF_TYPE_ID = *mut WNF_TYPE_ID; pub type PCWNF_TYPE_ID = *const WNF_TYPE_ID; -pub type PWNF_CHANGE_STAMP = *mut ULONG; -pub type WNF_CHANGE_STAMP = ULONG; -STRUCT!{struct WNF_DELIVERY_DESCRIPTOR { - SubscriptionId: ULONGLONG, +pub type PWNF_CHANGE_STAMP = *mut c_ulong; +pub type WNF_CHANGE_STAMP = c_ulong; +STRUCT! {struct WNF_DELIVERY_DESCRIPTOR { + SubscriptionId: __uint64, StateName: WNF_STATE_NAME, ChangeStamp: WNF_CHANGE_STAMP, - StateDataSize: ULONG, - EventMask: ULONG, + StateDataSize: c_ulong, + EventMask: c_ulong, TypeId: WNF_TYPE_ID, - StateDataOffset: ULONG, + StateDataOffset: c_ulong, }} pub type PWNF_DELIVERY_DESCRIPTOR = *mut WNF_DELIVERY_DESCRIPTOR; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtCreateWnfStateName( - StateName: PWNF_STATE_NAME, + StateName: *mut WNF_STATE_NAME, NameLifetime: WNF_STATE_NAME_LIFETIME, DataScope: WNF_DATA_SCOPE, - PersistData: BOOLEAN, + PersistData: c_uchar, TypeId: PCWNF_TYPE_ID, - MaximumStateSize: ULONG, + MaximumStateSize: c_ulong, SecurityDescriptor: PSECURITY_DESCRIPTOR, ) -> NTSTATUS; fn NtDeleteWnfStateName( - StateName: PCWNF_STATE_NAME, + StateName: *const WNF_STATE_NAME, ) -> NTSTATUS; fn NtUpdateWnfStateData( - StateName: PCWNF_STATE_NAME, - Buffer: *const VOID, - Length: ULONG, + StateName: *const WNF_STATE_NAME, + Buffer: *const c_void, + Length: c_ulong, TypeId: PCWNF_TYPE_ID, - ExplicitScope: *const VOID, + ExplicitScope: *const c_void, MatchingChangeStamp: WNF_CHANGE_STAMP, - CheckStamp: LOGICAL, + CheckStamp: c_ulong, ) -> NTSTATUS; fn NtDeleteWnfStateData( - StateName: PCWNF_STATE_NAME, - ExplicitScope: *const VOID, + StateName: *const WNF_STATE_NAME, + ExplicitScope: *const c_void, ) -> NTSTATUS; fn NtQueryWnfStateData( - StateName: PCWNF_STATE_NAME, + StateName: *const WNF_STATE_NAME, TypeId: PCWNF_TYPE_ID, - ExplicitScope: *const VOID, + ExplicitScope: *const c_void, ChangeStamp: PWNF_CHANGE_STAMP, - Buffer: PVOID, - BufferSize: PULONG, + Buffer: *mut c_void, + BufferSize: *mut c_ulong, ) -> NTSTATUS; fn NtQueryWnfStateNameInformation( - StateName: PCWNF_STATE_NAME, + StateName: *const WNF_STATE_NAME, NameInfoClass: WNF_STATE_NAME_INFORMATION, - ExplicitScope: *const VOID, - InfoBuffer: PVOID, - InfoBufferSize: ULONG, + ExplicitScope: *const c_void, + InfoBuffer: *mut c_void, + InfoBufferSize: c_ulong, ) -> NTSTATUS; fn NtSubscribeWnfStateChange( - StateName: PCWNF_STATE_NAME, + StateName: *const WNF_STATE_NAME, ChangeStamp: WNF_CHANGE_STAMP, - EventMask: ULONG, - SubscriptionId: PULONG64, + EventMask: c_ulong, + SubscriptionId: *mut __uint64, ) -> NTSTATUS; fn NtUnsubscribeWnfStateChange( - StateName: PCWNF_STATE_NAME, + StateName: *const WNF_STATE_NAME, ) -> NTSTATUS; fn NtGetCompleteWnfStateSubscription( - OldDescriptorStateName: PWNF_STATE_NAME, - OldSubscriptionId: *mut ULONG64, - OldDescriptorEventMask: ULONG, - OldDescriptorStatus: ULONG, + OldDescriptorStateName: *mut WNF_STATE_NAME, + OldSubscriptionId: *mut __uint64, + OldDescriptorEventMask: c_ulong, + OldDescriptorStatus: c_ulong, NewDeliveryDescriptor: PWNF_DELIVERY_DESCRIPTOR, - DescriptorSize: ULONG, + DescriptorSize: c_ulong, ) -> NTSTATUS; fn NtSetWnfProcessNotificationEvent( NotificationEvent: HANDLE, @@ -608,10 +624,14 @@ pub const WORKER_FACTORY_SET_INFORMATION: u32 = 0x0004; pub const WORKER_FACTORY_QUERY_INFORMATION: u32 = 0x0008; pub const WORKER_FACTORY_READY_WORKER: u32 = 0x0010; pub const WORKER_FACTORY_SHUTDOWN: u32 = 0x0020; -pub const WORKER_FACTORY_ALL_ACCESS: ACCESS_MASK = STANDARD_RIGHTS_REQUIRED - | WORKER_FACTORY_RELEASE_WORKER | WORKER_FACTORY_WAIT | WORKER_FACTORY_SET_INFORMATION - | WORKER_FACTORY_QUERY_INFORMATION | WORKER_FACTORY_READY_WORKER | WORKER_FACTORY_SHUTDOWN; -ENUM!{enum WORKERFACTORYINFOCLASS { +pub const WORKER_FACTORY_ALL_ACCESS: c_ulong = STANDARD_RIGHTS_REQUIRED + | WORKER_FACTORY_RELEASE_WORKER + | WORKER_FACTORY_WAIT + | WORKER_FACTORY_SET_INFORMATION + | WORKER_FACTORY_QUERY_INFORMATION + | WORKER_FACTORY_READY_WORKER + | WORKER_FACTORY_SHUTDOWN; +ENUM! {enum WORKERFACTORYINFOCLASS { WorkerFactoryTimeout = 0, WorkerFactoryRetryTimeout = 1, WorkerFactoryIdleTimeout = 2, @@ -630,62 +650,63 @@ ENUM!{enum WORKERFACTORYINFOCLASS { MaxWorkerFactoryInfoClass = 15, }} pub type PWORKERFACTORYINFOCLASS = *mut WORKERFACTORYINFOCLASS; -STRUCT!{struct WORKER_FACTORY_BASIC_INFORMATION { +STRUCT! {struct WORKER_FACTORY_BASIC_INFORMATION { Timeout: LARGE_INTEGER, RetryTimeout: LARGE_INTEGER, IdleTimeout: LARGE_INTEGER, - Paused: BOOLEAN, - TimerSet: BOOLEAN, - QueuedToExWorker: BOOLEAN, - MayCreate: BOOLEAN, - CreateInProgress: BOOLEAN, - InsertedIntoQueue: BOOLEAN, - Shutdown: BOOLEAN, - BindingCount: ULONG, - ThreadMinimum: ULONG, - ThreadMaximum: ULONG, - PendingWorkerCount: ULONG, - WaitingWorkerCount: ULONG, - TotalWorkerCount: ULONG, - ReleaseCount: ULONG, - InfiniteWaitGoal: LONGLONG, - StartRoutine: PVOID, - StartParameter: PVOID, + Paused: c_uchar, + TimerSet: c_uchar, + QueuedToExWorker: c_uchar, + MayCreate: c_uchar, + CreateInProgress: c_uchar, + InsertedIntoQueue: c_uchar, + Shutdown: c_uchar, + BindingCount: c_ulong, + ThreadMinimum: c_ulong, + ThreadMaximum: c_ulong, + PendingWorkerCount: c_ulong, + WaitingWorkerCount: c_ulong, + TotalWorkerCount: c_ulong, + ReleaseCount: c_ulong, + InfiniteWaitGoal: __int64, + StartRoutine: *mut c_void, + StartParameter: *mut c_void, ProcessId: HANDLE, - StackReserve: SIZE_T, - StackCommit: SIZE_T, + StackReserve: usize, + StackCommit: usize, LastThreadCreationStatus: NTSTATUS, }} -pub type PWORKER_FACTORY_BASIC_INFORMATION = *mut WORKER_FACTORY_BASIC_INFORMATION; -EXTERN!{extern "system" { +pub type PWORKER_FACTORY_BASIC_INFORMATION = + *mut WORKER_FACTORY_BASIC_INFORMATION; +EXTERN! {extern "system" { fn NtCreateWorkerFactory( - WorkerFactoryHandleReturn: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + WorkerFactoryHandleReturn: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, CompletionPortHandle: HANDLE, WorkerProcessHandle: HANDLE, - StartRoutine: PVOID, - StartParameter: PVOID, - MaxThreadCount: ULONG, - StackReserve: SIZE_T, - StackCommit: SIZE_T, + StartRoutine: *mut c_void, + StartParameter: *mut c_void, + MaxThreadCount: c_ulong, + StackReserve: usize, + StackCommit: usize, ) -> NTSTATUS; fn NtQueryInformationWorkerFactory( WorkerFactoryHandle: HANDLE, WorkerFactoryInformationClass: WORKERFACTORYINFOCLASS, - WorkerFactoryInformation: PVOID, - WorkerFactoryInformationLength: ULONG, - ReturnLength: PULONG, + WorkerFactoryInformation: *mut c_void, + WorkerFactoryInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn NtSetInformationWorkerFactory( WorkerFactoryHandle: HANDLE, WorkerFactoryInformationClass: WORKERFACTORYINFOCLASS, - WorkerFactoryInformation: PVOID, - WorkerFactoryInformationLength: ULONG, + WorkerFactoryInformation: *mut c_void, + WorkerFactoryInformationLength: c_ulong, ) -> NTSTATUS; fn NtShutdownWorkerFactory( WorkerFactoryHandle: HANDLE, - PendingWorkerCount: *mut LONG, + PendingWorkerCount: *mut c_long, ) -> NTSTATUS; fn NtReleaseWorkerFactoryWorker( WorkerFactoryHandle: HANDLE, @@ -698,40 +719,40 @@ EXTERN!{extern "system" { MiniPacket: *mut FILE_IO_COMPLETION_INFORMATION, ) -> NTSTATUS; fn NtQuerySystemTime( - SystemTime: PLARGE_INTEGER, + SystemTime: *mut LARGE_INTEGER, ) -> NTSTATUS; fn NtSetSystemTime( - SystemTime: PLARGE_INTEGER, - PreviousTime: PLARGE_INTEGER, + SystemTime: *mut LARGE_INTEGER, + PreviousTime: *mut LARGE_INTEGER, ) -> NTSTATUS; fn NtQueryTimerResolution( - MaximumTime: PULONG, - MinimumTime: PULONG, - CurrentTime: PULONG, + MaximumTime: *mut c_ulong, + MinimumTime: *mut c_ulong, + CurrentTime: *mut c_ulong, ) -> NTSTATUS; fn NtSetTimerResolution( - DesiredTime: ULONG, - SetResolution: BOOLEAN, - ActualTime: PULONG, + DesiredTime: c_ulong, + SetResolution: c_uchar, + ActualTime: *mut c_ulong, ) -> NTSTATUS; fn NtQueryPerformanceCounter( - PerformanceCounter: PLARGE_INTEGER, - PerformanceFrequency: PLARGE_INTEGER, + PerformanceCounter: *mut LARGE_INTEGER, + PerformanceFrequency: *mut LARGE_INTEGER, ) -> NTSTATUS; fn NtAllocateLocallyUniqueId( - Luid: PLUID, + Luid: *mut LUID, ) -> NTSTATUS; fn NtSetUuidSeed( - Seed: PCHAR, + Seed: *mut c_char, ) -> NTSTATUS; fn NtAllocateUuids( - Time: PULARGE_INTEGER, - Range: PULONG, - Sequence: PULONG, - Seed: PCHAR, + Time: *mut ULARGE_INTEGER, + Range: *mut c_ulong, + Sequence: *mut c_ulong, + Seed: *mut c_char, ) -> NTSTATUS; }} -ENUM!{enum SYSTEM_INFORMATION_CLASS { +ENUM! {enum SYSTEM_INFORMATION_CLASS { SystemBasicInformation = 0, SystemProcessorInformation = 1, SystemPerformanceInformation = 2, @@ -942,151 +963,152 @@ ENUM!{enum SYSTEM_INFORMATION_CLASS { SystemFlags2Information = 207, MaxSystemInfoClass = 208, }} -STRUCT!{struct SYSTEM_BASIC_INFORMATION { - Reserved: ULONG, - TimerResolution: ULONG, - PageSize: ULONG, - NumberOfPhysicalPages: ULONG, - LowestPhysicalPageNumber: ULONG, - HighestPhysicalPageNumber: ULONG, - AllocationGranularity: ULONG, - MinimumUserModeAddress: ULONG_PTR, - MaximumUserModeAddress: ULONG_PTR, - ActiveProcessorsAffinityMask: ULONG_PTR, - NumberOfProcessors: CCHAR, +STRUCT! {struct SYSTEM_BASIC_INFORMATION { + Reserved: c_ulong, + TimerResolution: c_ulong, + PageSize: c_ulong, + NumberOfPhysicalPages: c_ulong, + LowestPhysicalPageNumber: c_ulong, + HighestPhysicalPageNumber: c_ulong, + AllocationGranularity: c_ulong, + MinimumUserModeAddress: usize, + MaximumUserModeAddress: usize, + ActiveProcessorsAffinityMask: usize, + NumberOfProcessors: c_char, }} pub type PSYSTEM_BASIC_INFORMATION = *mut SYSTEM_BASIC_INFORMATION; -STRUCT!{struct SYSTEM_PROCESSOR_INFORMATION { - ProcessorArchitecture: USHORT, - ProcessorLevel: USHORT, - ProcessorRevision: USHORT, - MaximumProcessors: USHORT, - ProcessorFeatureBits: ULONG, +STRUCT! {struct SYSTEM_PROCESSOR_INFORMATION { + ProcessorArchitecture: c_ushort, + ProcessorLevel: c_ushort, + ProcessorRevision: c_ushort, + MaximumProcessors: c_ushort, + ProcessorFeatureBits: c_ulong, }} pub type PSYSTEM_PROCESSOR_INFORMATION = *mut SYSTEM_PROCESSOR_INFORMATION; -STRUCT!{struct SYSTEM_PERFORMANCE_INFORMATION { +STRUCT! {struct SYSTEM_PERFORMANCE_INFORMATION { IdleProcessTime: LARGE_INTEGER, IoReadTransferCount: LARGE_INTEGER, IoWriteTransferCount: LARGE_INTEGER, IoOtherTransferCount: LARGE_INTEGER, - IoReadOperationCount: ULONG, - IoWriteOperationCount: ULONG, - IoOtherOperationCount: ULONG, - AvailablePages: ULONG, - CommittedPages: ULONG, - CommitLimit: ULONG, - PeakCommitment: ULONG, - PageFaultCount: ULONG, - CopyOnWriteCount: ULONG, - TransitionCount: ULONG, - CacheTransitionCount: ULONG, - DemandZeroCount: ULONG, - PageReadCount: ULONG, - PageReadIoCount: ULONG, - CacheReadCount: ULONG, - CacheIoCount: ULONG, - DirtyPagesWriteCount: ULONG, - DirtyWriteIoCount: ULONG, - MappedPagesWriteCount: ULONG, - MappedWriteIoCount: ULONG, - PagedPoolPages: ULONG, - NonPagedPoolPages: ULONG, - PagedPoolAllocs: ULONG, - PagedPoolFrees: ULONG, - NonPagedPoolAllocs: ULONG, - NonPagedPoolFrees: ULONG, - FreeSystemPtes: ULONG, - ResidentSystemCodePage: ULONG, - TotalSystemDriverPages: ULONG, - TotalSystemCodePages: ULONG, - NonPagedPoolLookasideHits: ULONG, - PagedPoolLookasideHits: ULONG, - AvailablePagedPoolPages: ULONG, - ResidentSystemCachePage: ULONG, - ResidentPagedPoolPage: ULONG, - ResidentSystemDriverPage: ULONG, - CcFastReadNoWait: ULONG, - CcFastReadWait: ULONG, - CcFastReadResourceMiss: ULONG, - CcFastReadNotPossible: ULONG, - CcFastMdlReadNoWait: ULONG, - CcFastMdlReadWait: ULONG, - CcFastMdlReadResourceMiss: ULONG, - CcFastMdlReadNotPossible: ULONG, - CcMapDataNoWait: ULONG, - CcMapDataWait: ULONG, - CcMapDataNoWaitMiss: ULONG, - CcMapDataWaitMiss: ULONG, - CcPinMappedDataCount: ULONG, - CcPinReadNoWait: ULONG, - CcPinReadWait: ULONG, - CcPinReadNoWaitMiss: ULONG, - CcPinReadWaitMiss: ULONG, - CcCopyReadNoWait: ULONG, - CcCopyReadWait: ULONG, - CcCopyReadNoWaitMiss: ULONG, - CcCopyReadWaitMiss: ULONG, - CcMdlReadNoWait: ULONG, - CcMdlReadWait: ULONG, - CcMdlReadNoWaitMiss: ULONG, - CcMdlReadWaitMiss: ULONG, - CcReadAheadIos: ULONG, - CcLazyWriteIos: ULONG, - CcLazyWritePages: ULONG, - CcDataFlushes: ULONG, - CcDataPages: ULONG, - ContextSwitches: ULONG, - FirstLevelTbFills: ULONG, - SecondLevelTbFills: ULONG, - SystemCalls: ULONG, - CcTotalDirtyPages: ULONGLONG, - CcDirtyPageThreshold: ULONGLONG, - ResidentAvailablePages: LONGLONG, - SharedCommittedPages: ULONGLONG, + IoReadOperationCount: c_ulong, + IoWriteOperationCount: c_ulong, + IoOtherOperationCount: c_ulong, + AvailablePages: c_ulong, + CommittedPages: c_ulong, + CommitLimit: c_ulong, + PeakCommitment: c_ulong, + PageFaultCount: c_ulong, + CopyOnWriteCount: c_ulong, + TransitionCount: c_ulong, + CacheTransitionCount: c_ulong, + DemandZeroCount: c_ulong, + PageReadCount: c_ulong, + PageReadIoCount: c_ulong, + CacheReadCount: c_ulong, + CacheIoCount: c_ulong, + DirtyPagesWriteCount: c_ulong, + DirtyWriteIoCount: c_ulong, + MappedPagesWriteCount: c_ulong, + MappedWriteIoCount: c_ulong, + PagedPoolPages: c_ulong, + NonPagedPoolPages: c_ulong, + PagedPoolAllocs: c_ulong, + PagedPoolFrees: c_ulong, + NonPagedPoolAllocs: c_ulong, + NonPagedPoolFrees: c_ulong, + FreeSystemPtes: c_ulong, + ResidentSystemCodePage: c_ulong, + TotalSystemDriverPages: c_ulong, + TotalSystemCodePages: c_ulong, + NonPagedPoolLookasideHits: c_ulong, + PagedPoolLookasideHits: c_ulong, + AvailablePagedPoolPages: c_ulong, + ResidentSystemCachePage: c_ulong, + ResidentPagedPoolPage: c_ulong, + ResidentSystemDriverPage: c_ulong, + CcFastReadNoWait: c_ulong, + CcFastReadWait: c_ulong, + CcFastReadResourceMiss: c_ulong, + CcFastReadNotPossible: c_ulong, + CcFastMdlReadNoWait: c_ulong, + CcFastMdlReadWait: c_ulong, + CcFastMdlReadResourceMiss: c_ulong, + CcFastMdlReadNotPossible: c_ulong, + CcMapDataNoWait: c_ulong, + CcMapDataWait: c_ulong, + CcMapDataNoWaitMiss: c_ulong, + CcMapDataWaitMiss: c_ulong, + CcPinMappedDataCount: c_ulong, + CcPinReadNoWait: c_ulong, + CcPinReadWait: c_ulong, + CcPinReadNoWaitMiss: c_ulong, + CcPinReadWaitMiss: c_ulong, + CcCopyReadNoWait: c_ulong, + CcCopyReadWait: c_ulong, + CcCopyReadNoWaitMiss: c_ulong, + CcCopyReadWaitMiss: c_ulong, + CcMdlReadNoWait: c_ulong, + CcMdlReadWait: c_ulong, + CcMdlReadNoWaitMiss: c_ulong, + CcMdlReadWaitMiss: c_ulong, + CcReadAheadIos: c_ulong, + CcLazyWriteIos: c_ulong, + CcLazyWritePages: c_ulong, + CcDataFlushes: c_ulong, + CcDataPages: c_ulong, + ContextSwitches: c_ulong, + FirstLevelTbFills: c_ulong, + SecondLevelTbFills: c_ulong, + SystemCalls: c_ulong, + CcTotalDirtyPages: __uint64, + CcDirtyPageThreshold: __uint64, + ResidentAvailablePages: __int64, + SharedCommittedPages: __uint64, }} pub type PSYSTEM_PERFORMANCE_INFORMATION = *mut SYSTEM_PERFORMANCE_INFORMATION; -STRUCT!{struct SYSTEM_TIMEOFDAY_INFORMATION { +STRUCT! {struct SYSTEM_TIMEOFDAY_INFORMATION { BootTime: LARGE_INTEGER, CurrentTime: LARGE_INTEGER, TimeZoneBias: LARGE_INTEGER, - TimeZoneId: ULONG, - Reserved: ULONG, - BootTimeBias: ULONGLONG, - SleepTimeBias: ULONGLONG, + TimeZoneId: c_ulong, + Reserved: c_ulong, + BootTimeBias: __uint64, + SleepTimeBias: __uint64, }} pub type PSYSTEM_TIMEOFDAY_INFORMATION = *mut SYSTEM_TIMEOFDAY_INFORMATION; -STRUCT!{struct SYSTEM_THREAD_INFORMATION { +STRUCT! {struct SYSTEM_THREAD_INFORMATION { KernelTime: LARGE_INTEGER, UserTime: LARGE_INTEGER, CreateTime: LARGE_INTEGER, - WaitTime: ULONG, - StartAddress: PVOID, + WaitTime: c_ulong, + StartAddress: *mut c_void, ClientId: CLIENT_ID, Priority: KPRIORITY, - BasePriority: LONG, - ContextSwitches: ULONG, + BasePriority: c_long, + ContextSwitches: c_ulong, ThreadState: KTHREAD_STATE, WaitReason: KWAIT_REASON, }} pub type PSYSTEM_THREAD_INFORMATION = *mut SYSTEM_THREAD_INFORMATION; -STRUCT!{struct SYSTEM_EXTENDED_THREAD_INFORMATION { +STRUCT! {struct SYSTEM_EXTENDED_THREAD_INFORMATION { ThreadInfo: SYSTEM_THREAD_INFORMATION, - StackBase: PVOID, - StackLimit: PVOID, - Win32StartAddress: PVOID, + StackBase: *mut c_void, + StackLimit: *mut c_void, + Win32StartAddress: *mut c_void, TebBase: PTEB, - Reserved2: ULONG_PTR, - Reserved3: ULONG_PTR, - Reserved4: ULONG_PTR, -}} -pub type PSYSTEM_EXTENDED_THREAD_INFORMATION = *mut SYSTEM_EXTENDED_THREAD_INFORMATION; -STRUCT!{struct SYSTEM_PROCESS_INFORMATION { - NextEntryOffset: ULONG, - NumberOfThreads: ULONG, + Reserved2: usize, + Reserved3: usize, + Reserved4: usize, +}} +pub type PSYSTEM_EXTENDED_THREAD_INFORMATION = + *mut SYSTEM_EXTENDED_THREAD_INFORMATION; +STRUCT! {struct SYSTEM_PROCESS_INFORMATION { + NextEntryOffset: c_ulong, + NumberOfThreads: c_ulong, WorkingSetPrivateSize: LARGE_INTEGER, - HardFaultCount: ULONG, - NumberOfThreadsHighWatermark: ULONG, - CycleTime: ULONGLONG, + HardFaultCount: c_ulong, + NumberOfThreadsHighWatermark: c_ulong, + CycleTime: __uint64, CreateTime: LARGE_INTEGER, UserTime: LARGE_INTEGER, KernelTime: LARGE_INTEGER, @@ -1094,21 +1116,21 @@ STRUCT!{struct SYSTEM_PROCESS_INFORMATION { BasePriority: KPRIORITY, UniqueProcessId: HANDLE, InheritedFromUniqueProcessId: HANDLE, - HandleCount: ULONG, - SessionId: ULONG, - UniqueProcessKey: ULONG_PTR, - PeakVirtualSize: SIZE_T, - VirtualSize: SIZE_T, - PageFaultCount: ULONG, - PeakWorkingSetSize: SIZE_T, - WorkingSetSize: SIZE_T, - QuotaPeakPagedPoolUsage: SIZE_T, - QuotaPagedPoolUsage: SIZE_T, - QuotaPeakNonPagedPoolUsage: SIZE_T, - QuotaNonPagedPoolUsage: SIZE_T, - PagefileUsage: SIZE_T, - PeakPagefileUsage: SIZE_T, - PrivatePageCount: SIZE_T, + HandleCount: c_ulong, + SessionId: c_ulong, + UniqueProcessKey: usize, + PeakVirtualSize: usize, + VirtualSize: usize, + PageFaultCount: c_ulong, + PeakWorkingSetSize: usize, + WorkingSetSize: usize, + QuotaPeakPagedPoolUsage: usize, + QuotaPagedPoolUsage: usize, + QuotaPeakNonPagedPoolUsage: usize, + QuotaNonPagedPoolUsage: usize, + PagefileUsage: usize, + PeakPagefileUsage: usize, + PrivatePageCount: usize, ReadOperationCount: LARGE_INTEGER, WriteOperationCount: LARGE_INTEGER, OtherOperationCount: LARGE_INTEGER, @@ -1118,208 +1140,214 @@ STRUCT!{struct SYSTEM_PROCESS_INFORMATION { Threads: [SYSTEM_THREAD_INFORMATION; 1], }} pub type PSYSTEM_PROCESS_INFORMATION = *mut SYSTEM_PROCESS_INFORMATION; -STRUCT!{struct SYSTEM_CALL_COUNT_INFORMATION { - Length: ULONG, - NumberOfTables: ULONG, +STRUCT! {struct SYSTEM_CALL_COUNT_INFORMATION { + Length: c_ulong, + NumberOfTables: c_ulong, }} pub type PSYSTEM_CALL_COUNT_INFORMATION = *mut SYSTEM_CALL_COUNT_INFORMATION; -STRUCT!{struct SYSTEM_DEVICE_INFORMATION { - NumberOfDisks: ULONG, - NumberOfFloppies: ULONG, - NumberOfCdRoms: ULONG, - NumberOfTapes: ULONG, - NumberOfSerialPorts: ULONG, - NumberOfParallelPorts: ULONG, +STRUCT! {struct SYSTEM_DEVICE_INFORMATION { + NumberOfDisks: c_ulong, + NumberOfFloppies: c_ulong, + NumberOfCdRoms: c_ulong, + NumberOfTapes: c_ulong, + NumberOfSerialPorts: c_ulong, + NumberOfParallelPorts: c_ulong, }} pub type PSYSTEM_DEVICE_INFORMATION = *mut SYSTEM_DEVICE_INFORMATION; -STRUCT!{struct SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION { +STRUCT! {struct SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION { IdleTime: LARGE_INTEGER, KernelTime: LARGE_INTEGER, UserTime: LARGE_INTEGER, DpcTime: LARGE_INTEGER, InterruptTime: LARGE_INTEGER, - InterruptCount: ULONG, + InterruptCount: c_ulong, }} -pub type PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION = *mut SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION; -STRUCT!{struct SYSTEM_FLAGS_INFORMATION { - Flags: ULONG, +pub type PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION = + *mut SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION; +STRUCT! {struct SYSTEM_FLAGS_INFORMATION { + Flags: c_ulong, }} pub type PSYSTEM_FLAGS_INFORMATION = *mut SYSTEM_FLAGS_INFORMATION; -STRUCT!{struct SYSTEM_CALL_TIME_INFORMATION { - Length: ULONG, - TotalCalls: ULONG, +STRUCT! {struct SYSTEM_CALL_TIME_INFORMATION { + Length: c_ulong, + TotalCalls: c_ulong, TimeOfCalls: [LARGE_INTEGER; 1], }} pub type PSYSTEM_CALL_TIME_INFORMATION = *mut SYSTEM_CALL_TIME_INFORMATION; -STRUCT!{struct RTL_PROCESS_LOCK_INFORMATION { - Address: PVOID, - Type: USHORT, - CreatorBackTraceIndex: USHORT, +STRUCT! {struct RTL_PROCESS_LOCK_INFORMATION { + Address: *mut c_void, + Type: c_ushort, + CreatorBackTraceIndex: c_ushort, OwningThread: HANDLE, - LockCount: LONG, - ContentionCount: ULONG, - EntryCount: ULONG, - RecursionCount: LONG, - NumberOfWaitingShared: ULONG, - NumberOfWaitingExclusive: ULONG, + LockCount: c_long, + ContentionCount: c_ulong, + EntryCount: c_ulong, + RecursionCount: c_long, + NumberOfWaitingShared: c_ulong, + NumberOfWaitingExclusive: c_ulong, }} pub type PRTL_PROCESS_LOCK_INFORMATION = *mut RTL_PROCESS_LOCK_INFORMATION; -STRUCT!{struct RTL_PROCESS_LOCKS { - NumberOfLocks: ULONG, +STRUCT! {struct RTL_PROCESS_LOCKS { + NumberOfLocks: c_ulong, Locks: [RTL_PROCESS_LOCK_INFORMATION; 1], }} pub type PRTL_PROCESS_LOCKS = *mut RTL_PROCESS_LOCKS; -STRUCT!{struct RTL_PROCESS_BACKTRACE_INFORMATION { - SymbolicBackTrace: PCHAR, - TraceCount: ULONG, - Index: USHORT, - Depth: USHORT, - BackTrace: [PVOID; 32], -}} -pub type PRTL_PROCESS_BACKTRACE_INFORMATION = *mut RTL_PROCESS_BACKTRACE_INFORMATION; -STRUCT!{struct RTL_PROCESS_BACKTRACES { - CommittedMemory: ULONG, - ReservedMemory: ULONG, - NumberOfBackTraceLookups: ULONG, - NumberOfBackTraces: ULONG, +STRUCT! {struct RTL_PROCESS_BACKTRACE_INFORMATION { + SymbolicBackTrace: *mut c_char, + TraceCount: c_ulong, + Index: c_ushort, + Depth: c_ushort, + BackTrace: [*mut c_void; 32], +}} +pub type PRTL_PROCESS_BACKTRACE_INFORMATION = + *mut RTL_PROCESS_BACKTRACE_INFORMATION; +STRUCT! {struct RTL_PROCESS_BACKTRACES { + CommittedMemory: c_ulong, + ReservedMemory: c_ulong, + NumberOfBackTraceLookups: c_ulong, + NumberOfBackTraces: c_ulong, BackTraces: [RTL_PROCESS_BACKTRACE_INFORMATION; 1], }} pub type PRTL_PROCESS_BACKTRACES = *mut RTL_PROCESS_BACKTRACES; -STRUCT!{struct SYSTEM_HANDLE_TABLE_ENTRY_INFO { - UniqueProcessId: USHORT, - CreatorBackTraceIndex: USHORT, - ObjectTypeIndex: UCHAR, - HandleAttributes: UCHAR, - HandleValue: USHORT, - Object: PVOID, - GrantedAccess: ULONG, +STRUCT! {struct SYSTEM_HANDLE_TABLE_ENTRY_INFO { + UniqueProcessId: c_ushort, + CreatorBackTraceIndex: c_ushort, + ObjectTypeIndex: c_uchar, + HandleAttributes: c_uchar, + HandleValue: c_ushort, + Object: *mut c_void, + GrantedAccess: c_ulong, }} pub type PSYSTEM_HANDLE_TABLE_ENTRY_INFO = *mut SYSTEM_HANDLE_TABLE_ENTRY_INFO; -STRUCT!{struct SYSTEM_HANDLE_INFORMATION { - NumberOfHandles: ULONG, +STRUCT! {struct SYSTEM_HANDLE_INFORMATION { + NumberOfHandles: c_ulong, Handles: [SYSTEM_HANDLE_TABLE_ENTRY_INFO; 1], }} pub type PSYSTEM_HANDLE_INFORMATION = *mut SYSTEM_HANDLE_INFORMATION; -STRUCT!{struct SYSTEM_OBJECTTYPE_INFORMATION { - NextEntryOffset: ULONG, - NumberOfObjects: ULONG, - NumberOfHandles: ULONG, - TypeIndex: ULONG, - InvalidAttributes: ULONG, +STRUCT! {struct SYSTEM_OBJECTTYPE_INFORMATION { + NextEntryOffset: c_ulong, + NumberOfObjects: c_ulong, + NumberOfHandles: c_ulong, + TypeIndex: c_ulong, + InvalidAttributes: c_ulong, GenericMapping: GENERIC_MAPPING, - ValidAccessMask: ULONG, - PoolType: ULONG, - SecurityRequired: BOOLEAN, - WaitableObject: BOOLEAN, + ValidAccessMask: c_ulong, + PoolType: c_ulong, + SecurityRequired: c_uchar, + WaitableObject: c_uchar, TypeName: UNICODE_STRING, }} pub type PSYSTEM_OBJECTTYPE_INFORMATION = *mut SYSTEM_OBJECTTYPE_INFORMATION; -STRUCT!{struct SYSTEM_OBJECT_INFORMATION { - NextEntryOffset: ULONG, - Object: PVOID, +STRUCT! {struct SYSTEM_OBJECT_INFORMATION { + NextEntryOffset: c_ulong, + Object: *mut c_void, CreatorUniqueProcess: HANDLE, - CreatorBackTraceIndex: USHORT, - Flags: USHORT, - PointerCount: LONG, - HandleCount: LONG, - PagedPoolCharge: ULONG, - NonPagedPoolCharge: ULONG, + CreatorBackTraceIndex: c_ushort, + Flags: c_ushort, + PointerCount: c_long, + HandleCount: c_long, + PagedPoolCharge: c_ulong, + NonPagedPoolCharge: c_ulong, ExclusiveProcessId: HANDLE, - SecurityDescriptor: PVOID, + SecurityDescriptor: *mut c_void, NameInfo: UNICODE_STRING, }} pub type PSYSTEM_OBJECT_INFORMATION = *mut SYSTEM_OBJECT_INFORMATION; -STRUCT!{struct SYSTEM_PAGEFILE_INFORMATION { - NextEntryOffset: ULONG, - TotalSize: ULONG, - TotalInUse: ULONG, - PeakUsage: ULONG, +STRUCT! {struct SYSTEM_PAGEFILE_INFORMATION { + NextEntryOffset: c_ulong, + TotalSize: c_ulong, + TotalInUse: c_ulong, + PeakUsage: c_ulong, PageFileName: UNICODE_STRING, }} pub type PSYSTEM_PAGEFILE_INFORMATION = *mut SYSTEM_PAGEFILE_INFORMATION; -pub const MM_WORKING_SET_MAX_HARD_ENABLE: ULONG = 0x1; -pub const MM_WORKING_SET_MAX_HARD_DISABLE: ULONG = 0x2; -pub const MM_WORKING_SET_MIN_HARD_ENABLE: ULONG = 0x4; -pub const MM_WORKING_SET_MIN_HARD_DISABLE: ULONG = 0x8; -STRUCT!{struct SYSTEM_FILECACHE_INFORMATION { - CurrentSize: SIZE_T, - PeakSize: SIZE_T, - PageFaultCount: ULONG, - MinimumWorkingSet: SIZE_T, - MaximumWorkingSet: SIZE_T, - CurrentSizeIncludingTransitionInPages: SIZE_T, - PeakSizeIncludingTransitionInPages: SIZE_T, - TransitionRePurposeCount: ULONG, - Flags: ULONG, +pub const MM_WORKING_SET_MAX_HARD_ENABLE: c_ulong = 0x1; +pub const MM_WORKING_SET_MAX_HARD_DISABLE: c_ulong = 0x2; +pub const MM_WORKING_SET_MIN_HARD_ENABLE: c_ulong = 0x4; +pub const MM_WORKING_SET_MIN_HARD_DISABLE: c_ulong = 0x8; +STRUCT! {struct SYSTEM_FILECACHE_INFORMATION { + CurrentSize: usize, + PeakSize: usize, + PageFaultCount: c_ulong, + MinimumWorkingSet: usize, + MaximumWorkingSet: usize, + CurrentSizeIncludingTransitionInPages: usize, + PeakSizeIncludingTransitionInPages: usize, + TransitionRePurposeCount: c_ulong, + Flags: c_ulong, }} pub type PSYSTEM_FILECACHE_INFORMATION = *mut SYSTEM_FILECACHE_INFORMATION; -STRUCT!{struct SYSTEM_BASIC_WORKING_SET_INFORMATION { - CurrentSize: SIZE_T, - PeakSize: SIZE_T, - PageFaultCount: ULONG, -}} -pub type PSYSTEM_BASIC_WORKING_SET_INFORMATION = *mut SYSTEM_BASIC_WORKING_SET_INFORMATION; -UNION!{union SYSTEM_POOLTAG_u { - Tag: [UCHAR; 4], - TagUlong: ULONG, -}} -STRUCT!{struct SYSTEM_POOLTAG { +STRUCT! {struct SYSTEM_BASIC_WORKING_SET_INFORMATION { + CurrentSize: usize, + PeakSize: usize, + PageFaultCount: c_ulong, +}} +pub type PSYSTEM_BASIC_WORKING_SET_INFORMATION = + *mut SYSTEM_BASIC_WORKING_SET_INFORMATION; +UNION! {union SYSTEM_POOLTAG_u { + Tag: [c_uchar; 4], + TagUlong: c_ulong, +}} +STRUCT! {struct SYSTEM_POOLTAG { u: SYSTEM_POOLTAG_u, - PagedAllocs: ULONG, - PagedFrees: ULONG, - PagedUsed: SIZE_T, - NonPagedAllocs: ULONG, - NonPagedFrees: ULONG, - NonPagedUsed: SIZE_T, + PagedAllocs: c_ulong, + PagedFrees: c_ulong, + PagedUsed: usize, + NonPagedAllocs: c_ulong, + NonPagedFrees: c_ulong, + NonPagedUsed: usize, }} pub type PSYSTEM_POOLTAG = *mut SYSTEM_POOLTAG; -STRUCT!{struct SYSTEM_POOLTAG_INFORMATION { - Count: ULONG, +STRUCT! {struct SYSTEM_POOLTAG_INFORMATION { + Count: c_ulong, TagInfo: [SYSTEM_POOLTAG; 1], }} pub type PSYSTEM_POOLTAG_INFORMATION = *mut SYSTEM_POOLTAG_INFORMATION; -STRUCT!{struct SYSTEM_INTERRUPT_INFORMATION { - ContextSwitches: ULONG, - DpcCount: ULONG, - DpcRate: ULONG, - TimeIncrement: ULONG, - DpcBypassCount: ULONG, - ApcBypassCount: ULONG, +STRUCT! {struct SYSTEM_INTERRUPT_INFORMATION { + ContextSwitches: c_ulong, + DpcCount: c_ulong, + DpcRate: c_ulong, + TimeIncrement: c_ulong, + DpcBypassCount: c_ulong, + ApcBypassCount: c_ulong, }} pub type PSYSTEM_INTERRUPT_INFORMATION = *mut SYSTEM_INTERRUPT_INFORMATION; -STRUCT!{struct SYSTEM_DPC_BEHAVIOR_INFORMATION { - Spare: ULONG, - DpcQueueDepth: ULONG, - MinimumDpcRate: ULONG, - AdjustDpcThreshold: ULONG, - IdealDpcRate: ULONG, -}} -pub type PSYSTEM_DPC_BEHAVIOR_INFORMATION = *mut SYSTEM_DPC_BEHAVIOR_INFORMATION; -STRUCT!{struct SYSTEM_QUERY_TIME_ADJUST_INFORMATION { - TimeAdjustment: ULONG, - TimeIncrement: ULONG, - Enable: BOOLEAN, -}} -pub type PSYSTEM_QUERY_TIME_ADJUST_INFORMATION = *mut SYSTEM_QUERY_TIME_ADJUST_INFORMATION; -STRUCT!{struct SYSTEM_QUERY_TIME_ADJUST_INFORMATION_PRECISE { - TimeAdjustment: ULONGLONG, - TimeIncrement: ULONGLONG, - Enable: BOOLEAN, +STRUCT! {struct SYSTEM_DPC_BEHAVIOR_INFORMATION { + Spare: c_ulong, + DpcQueueDepth: c_ulong, + MinimumDpcRate: c_ulong, + AdjustDpcThreshold: c_ulong, + IdealDpcRate: c_ulong, +}} +pub type PSYSTEM_DPC_BEHAVIOR_INFORMATION = + *mut SYSTEM_DPC_BEHAVIOR_INFORMATION; +STRUCT! {struct SYSTEM_QUERY_TIME_ADJUST_INFORMATION { + TimeAdjustment: c_ulong, + TimeIncrement: c_ulong, + Enable: c_uchar, +}} +pub type PSYSTEM_QUERY_TIME_ADJUST_INFORMATION = + *mut SYSTEM_QUERY_TIME_ADJUST_INFORMATION; +STRUCT! {struct SYSTEM_QUERY_TIME_ADJUST_INFORMATION_PRECISE { + TimeAdjustment: __uint64, + TimeIncrement: __uint64, + Enable: c_uchar, }} pub type PSYSTEM_QUERY_TIME_ADJUST_INFORMATION_PRECISE = *mut SYSTEM_QUERY_TIME_ADJUST_INFORMATION_PRECISE; -STRUCT!{struct SYSTEM_SET_TIME_ADJUST_INFORMATION { - TimeAdjustment: ULONG, - Enable: BOOLEAN, +STRUCT! {struct SYSTEM_SET_TIME_ADJUST_INFORMATION { + TimeAdjustment: c_ulong, + Enable: c_uchar, }} -pub type PSYSTEM_SET_TIME_ADJUST_INFORMATION = *mut SYSTEM_SET_TIME_ADJUST_INFORMATION; -STRUCT!{struct SYSTEM_SET_TIME_ADJUST_INFORMATION_PRECISE { - TimeAdjustment: ULONGLONG, - Enable: BOOLEAN, +pub type PSYSTEM_SET_TIME_ADJUST_INFORMATION = + *mut SYSTEM_SET_TIME_ADJUST_INFORMATION; +STRUCT! {struct SYSTEM_SET_TIME_ADJUST_INFORMATION_PRECISE { + TimeAdjustment: __uint64, + Enable: c_uchar, }} pub type PSYSTEM_SET_TIME_ADJUST_INFORMATION_PRECISE = *mut SYSTEM_SET_TIME_ADJUST_INFORMATION_PRECISE; -ENUM!{enum EVENT_TRACE_INFORMATION_CLASS { +ENUM! {enum EVENT_TRACE_INFORMATION_CLASS { EventTraceKernelVersionInformation = 0, EventTraceGroupMaskInformation = 1, EventTracePerformanceInformation = 2, @@ -1348,350 +1376,377 @@ ENUM!{enum EVENT_TRACE_INFORMATION_CLASS { EventTraceCoverageSamplerInformation = 25, MaxEventTraceInfoClass = 26, }} -STRUCT!{struct EVENT_TRACE_VERSION_INFORMATION { +STRUCT! {struct EVENT_TRACE_VERSION_INFORMATION { EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, - EventTraceKernelVersion: ULONG, + EventTraceKernelVersion: c_ulong, }} -pub type PEVENT_TRACE_VERSION_INFORMATION = *mut EVENT_TRACE_VERSION_INFORMATION; -STRUCT!{struct PERFINFO_GROUPMASK { - Masks: [ULONG; 8], +pub type PEVENT_TRACE_VERSION_INFORMATION = + *mut EVENT_TRACE_VERSION_INFORMATION; +STRUCT! {struct PERFINFO_GROUPMASK { + Masks: [c_ulong; 8], }} pub type PPERFINFO_GROUPMASK = *mut PERFINFO_GROUPMASK; -STRUCT!{struct EVENT_TRACE_GROUPMASK_INFORMATION { +STRUCT! {struct EVENT_TRACE_GROUPMASK_INFORMATION { EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, TraceHandle: HANDLE, EventTraceGroupMasks: PERFINFO_GROUPMASK, }} -pub type PEVENT_TRACE_GROUPMASK_INFORMATION = *mut EVENT_TRACE_GROUPMASK_INFORMATION; -STRUCT!{struct EVENT_TRACE_PERFORMANCE_INFORMATION { +pub type PEVENT_TRACE_GROUPMASK_INFORMATION = + *mut EVENT_TRACE_GROUPMASK_INFORMATION; +STRUCT! {struct EVENT_TRACE_PERFORMANCE_INFORMATION { EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, LogfileBytesWritten: LARGE_INTEGER, }} -pub type PEVENT_TRACE_PERFORMANCE_INFORMATION = *mut EVENT_TRACE_PERFORMANCE_INFORMATION; -STRUCT!{struct EVENT_TRACE_TIME_PROFILE_INFORMATION { +pub type PEVENT_TRACE_PERFORMANCE_INFORMATION = + *mut EVENT_TRACE_PERFORMANCE_INFORMATION; +STRUCT! {struct EVENT_TRACE_TIME_PROFILE_INFORMATION { EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, - ProfileInterval: ULONG, + ProfileInterval: c_ulong, }} -pub type PEVENT_TRACE_TIME_PROFILE_INFORMATION = *mut EVENT_TRACE_TIME_PROFILE_INFORMATION; -STRUCT!{struct EVENT_TRACE_SESSION_SECURITY_INFORMATION { +pub type PEVENT_TRACE_TIME_PROFILE_INFORMATION = + *mut EVENT_TRACE_TIME_PROFILE_INFORMATION; +STRUCT! {struct EVENT_TRACE_SESSION_SECURITY_INFORMATION { EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, - SecurityInformation: ULONG, + SecurityInformation: c_ulong, TraceHandle: HANDLE, - SecurityDescriptor: [UCHAR; 1], + SecurityDescriptor: [c_uchar; 1], }} -pub type PEVENT_TRACE_SESSION_SECURITY_INFORMATION = *mut EVENT_TRACE_SESSION_SECURITY_INFORMATION; -STRUCT!{struct EVENT_TRACE_SPINLOCK_INFORMATION { +pub type PEVENT_TRACE_SESSION_SECURITY_INFORMATION = + *mut EVENT_TRACE_SESSION_SECURITY_INFORMATION; +STRUCT! {struct EVENT_TRACE_SPINLOCK_INFORMATION { EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, - SpinLockSpinThreshold: ULONG, - SpinLockAcquireSampleRate: ULONG, - SpinLockContentionSampleRate: ULONG, - SpinLockHoldThreshold: ULONG, -}} -pub type PEVENT_TRACE_SPINLOCK_INFORMATION = *mut EVENT_TRACE_SPINLOCK_INFORMATION; -STRUCT!{struct EVENT_TRACE_SYSTEM_EVENT_INFORMATION { + SpinLockSpinThreshold: c_ulong, + SpinLockAcquireSampleRate: c_ulong, + SpinLockContentionSampleRate: c_ulong, + SpinLockHoldThreshold: c_ulong, +}} +pub type PEVENT_TRACE_SPINLOCK_INFORMATION = + *mut EVENT_TRACE_SPINLOCK_INFORMATION; +STRUCT! {struct EVENT_TRACE_SYSTEM_EVENT_INFORMATION { EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, TraceHandle: HANDLE, - HookId: [ULONG; 1], + HookId: [c_ulong; 1], }} -pub type PEVENT_TRACE_SYSTEM_EVENT_INFORMATION = *mut EVENT_TRACE_SYSTEM_EVENT_INFORMATION; -STRUCT!{struct EVENT_TRACE_EXECUTIVE_RESOURCE_INFORMATION { +pub type PEVENT_TRACE_SYSTEM_EVENT_INFORMATION = + *mut EVENT_TRACE_SYSTEM_EVENT_INFORMATION; +STRUCT! {struct EVENT_TRACE_EXECUTIVE_RESOURCE_INFORMATION { EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, - ReleaseSamplingRate: ULONG, - ContentionSamplingRate: ULONG, - NumberOfExcessiveTimeouts: ULONG, + ReleaseSamplingRate: c_ulong, + ContentionSamplingRate: c_ulong, + NumberOfExcessiveTimeouts: c_ulong, }} pub type PEVENT_TRACE_EXECUTIVE_RESOURCE_INFORMATION = *mut EVENT_TRACE_EXECUTIVE_RESOURCE_INFORMATION; -STRUCT!{struct EVENT_TRACE_HEAP_TRACING_INFORMATION { +STRUCT! {struct EVENT_TRACE_HEAP_TRACING_INFORMATION { EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, - ProcessId: ULONG, + ProcessId: c_ulong, }} -pub type PEVENT_TRACE_HEAP_TRACING_INFORMATION = *mut EVENT_TRACE_HEAP_TRACING_INFORMATION; -STRUCT!{struct EVENT_TRACE_TAG_FILTER_INFORMATION { +pub type PEVENT_TRACE_HEAP_TRACING_INFORMATION = + *mut EVENT_TRACE_HEAP_TRACING_INFORMATION; +STRUCT! {struct EVENT_TRACE_TAG_FILTER_INFORMATION { EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, TraceHandle: HANDLE, - Filter: [ULONG; 1], + Filter: [c_ulong; 1], }} -pub type PEVENT_TRACE_TAG_FILTER_INFORMATION = *mut EVENT_TRACE_TAG_FILTER_INFORMATION; -STRUCT!{struct EVENT_TRACE_PROFILE_COUNTER_INFORMATION { +pub type PEVENT_TRACE_TAG_FILTER_INFORMATION = + *mut EVENT_TRACE_TAG_FILTER_INFORMATION; +STRUCT! {struct EVENT_TRACE_PROFILE_COUNTER_INFORMATION { EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, TraceHandle: HANDLE, - ProfileSource: [ULONG; 1], + ProfileSource: [c_ulong; 1], }} -pub type PEVENT_TRACE_PROFILE_COUNTER_INFORMATION = *mut EVENT_TRACE_PROFILE_COUNTER_INFORMATION; -STRUCT!{struct EVENT_TRACE_PROFILE_LIST_INFORMATION { +pub type PEVENT_TRACE_PROFILE_COUNTER_INFORMATION = + *mut EVENT_TRACE_PROFILE_COUNTER_INFORMATION; +STRUCT! {struct EVENT_TRACE_PROFILE_LIST_INFORMATION { EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, - Spare: ULONG, + Spare: c_ulong, Profile: [*mut PROFILE_SOURCE_INFO; 1], }} -pub type PEVENT_TRACE_PROFILE_LIST_INFORMATION = *mut EVENT_TRACE_PROFILE_LIST_INFORMATION; -STRUCT!{struct EVENT_TRACE_STACK_CACHING_INFORMATION { +pub type PEVENT_TRACE_PROFILE_LIST_INFORMATION = + *mut EVENT_TRACE_PROFILE_LIST_INFORMATION; +STRUCT! {struct EVENT_TRACE_STACK_CACHING_INFORMATION { EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, TraceHandle: HANDLE, - Enabled: BOOLEAN, - Reserved: [UCHAR; 3], - CacheSize: ULONG, - BucketCount: ULONG, -}} -pub type PEVENT_TRACE_STACK_CACHING_INFORMATION = *mut EVENT_TRACE_STACK_CACHING_INFORMATION; -STRUCT!{struct EVENT_TRACE_SOFT_RESTART_INFORMATION { + Enabled: c_uchar, + Reserved: [c_uchar; 3], + CacheSize: c_ulong, + BucketCount: c_ulong, +}} +pub type PEVENT_TRACE_STACK_CACHING_INFORMATION = + *mut EVENT_TRACE_STACK_CACHING_INFORMATION; +STRUCT! {struct EVENT_TRACE_SOFT_RESTART_INFORMATION { EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, TraceHandle: HANDLE, - PersistTraceBuffers: BOOLEAN, - FileName: [WCHAR; 1], + PersistTraceBuffers: c_uchar, + FileName: [wchar_t; 1], }} -pub type PEVENT_TRACE_SOFT_RESTART_INFORMATION = *mut EVENT_TRACE_SOFT_RESTART_INFORMATION; -STRUCT!{struct EVENT_TRACE_PROFILE_ADD_INFORMATION { +pub type PEVENT_TRACE_SOFT_RESTART_INFORMATION = + *mut EVENT_TRACE_SOFT_RESTART_INFORMATION; +STRUCT! {struct EVENT_TRACE_PROFILE_ADD_INFORMATION { EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, - PerfEvtEventSelect: BOOLEAN, - PerfEvtUnitSelect: BOOLEAN, - PerfEvtType: ULONG, - CpuInfoHierarchy: [ULONG; 3], - InitialInterval: ULONG, - AllowsHalt: BOOLEAN, - Persist: BOOLEAN, - ProfileSourceDescription: [WCHAR; 1], -}} -pub type PEVENT_TRACE_PROFILE_ADD_INFORMATION = *mut EVENT_TRACE_PROFILE_ADD_INFORMATION; -STRUCT!{struct EVENT_TRACE_PROFILE_REMOVE_INFORMATION { + PerfEvtEventSelect: c_uchar, + PerfEvtUnitSelect: c_uchar, + PerfEvtType: c_ulong, + CpuInfoHierarchy: [c_ulong; 3], + InitialInterval: c_ulong, + AllowsHalt: c_uchar, + Persist: c_uchar, + ProfileSourceDescription: [wchar_t; 1], +}} +pub type PEVENT_TRACE_PROFILE_ADD_INFORMATION = + *mut EVENT_TRACE_PROFILE_ADD_INFORMATION; +STRUCT! {struct EVENT_TRACE_PROFILE_REMOVE_INFORMATION { EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, ProfileSource: KPROFILE_SOURCE, - CpuInfoHierarchy: [ULONG; 3], + CpuInfoHierarchy: [c_ulong; 3], }} -pub type PEVENT_TRACE_PROFILE_REMOVE_INFORMATION = *mut EVENT_TRACE_PROFILE_REMOVE_INFORMATION; -STRUCT!{struct EVENT_TRACE_COVERAGE_SAMPLER_INFORMATION { +pub type PEVENT_TRACE_PROFILE_REMOVE_INFORMATION = + *mut EVENT_TRACE_PROFILE_REMOVE_INFORMATION; +STRUCT! {struct EVENT_TRACE_COVERAGE_SAMPLER_INFORMATION { EventTraceInformationClass: EVENT_TRACE_INFORMATION_CLASS, - CoverageSamplerInformationClass: BOOLEAN, - MajorVersion: UCHAR, - MinorVersion: UCHAR, - Reserved: UCHAR, + CoverageSamplerInformationClass: c_uchar, + MajorVersion: c_uchar, + MinorVersion: c_uchar, + Reserved: c_uchar, SamplerHandle: HANDLE, }} -pub type PEVENT_TRACE_COVERAGE_SAMPLER_INFORMATION = *mut EVENT_TRACE_COVERAGE_SAMPLER_INFORMATION; -STRUCT!{struct SYSTEM_EXCEPTION_INFORMATION { - AlignmentFixupCount: ULONG, - ExceptionDispatchCount: ULONG, - FloatingEmulationCount: ULONG, - ByteWordEmulationCount: ULONG, +pub type PEVENT_TRACE_COVERAGE_SAMPLER_INFORMATION = + *mut EVENT_TRACE_COVERAGE_SAMPLER_INFORMATION; +STRUCT! {struct SYSTEM_EXCEPTION_INFORMATION { + AlignmentFixupCount: c_ulong, + ExceptionDispatchCount: c_ulong, + FloatingEmulationCount: c_ulong, + ByteWordEmulationCount: c_ulong, }} pub type PSYSTEM_EXCEPTION_INFORMATION = *mut SYSTEM_EXCEPTION_INFORMATION; -STRUCT!{struct SYSTEM_KERNEL_DEBUGGER_INFORMATION { - KernelDebuggerEnabled: BOOLEAN, - KernelDebuggerNotPresent: BOOLEAN, -}} -pub type PSYSTEM_KERNEL_DEBUGGER_INFORMATION = *mut SYSTEM_KERNEL_DEBUGGER_INFORMATION; -STRUCT!{struct SYSTEM_CONTEXT_SWITCH_INFORMATION { - ContextSwitches: ULONG, - FindAny: ULONG, - FindLast: ULONG, - FindIdeal: ULONG, - IdleAny: ULONG, - IdleCurrent: ULONG, - IdleLast: ULONG, - IdleIdeal: ULONG, - PreemptAny: ULONG, - PreemptCurrent: ULONG, - PreemptLast: ULONG, - SwitchToIdle: ULONG, -}} -pub type PSYSTEM_CONTEXT_SWITCH_INFORMATION = *mut SYSTEM_CONTEXT_SWITCH_INFORMATION; -STRUCT!{struct SYSTEM_REGISTRY_QUOTA_INFORMATION { - RegistryQuotaAllowed: ULONG, - RegistryQuotaUsed: ULONG, - PagedPoolSize: SIZE_T, -}} -pub type PSYSTEM_REGISTRY_QUOTA_INFORMATION = *mut SYSTEM_REGISTRY_QUOTA_INFORMATION; -STRUCT!{struct SYSTEM_PROCESSOR_IDLE_INFORMATION { - IdleTime: ULONGLONG, - C1Time: ULONGLONG, - C2Time: ULONGLONG, - C3Time: ULONGLONG, - C1Transitions: ULONG, - C2Transitions: ULONG, - C3Transitions: ULONG, - Padding: ULONG, -}} -pub type PSYSTEM_PROCESSOR_IDLE_INFORMATION = *mut SYSTEM_PROCESSOR_IDLE_INFORMATION; -STRUCT!{struct SYSTEM_LEGACY_DRIVER_INFORMATION { - VetoType: ULONG, +STRUCT! {struct SYSTEM_KERNEL_DEBUGGER_INFORMATION { + KernelDebuggerEnabled: c_uchar, + KernelDebuggerNotPresent: c_uchar, +}} +pub type PSYSTEM_KERNEL_DEBUGGER_INFORMATION = + *mut SYSTEM_KERNEL_DEBUGGER_INFORMATION; +STRUCT! {struct SYSTEM_CONTEXT_SWITCH_INFORMATION { + ContextSwitches: c_ulong, + FindAny: c_ulong, + FindLast: c_ulong, + FindIdeal: c_ulong, + IdleAny: c_ulong, + IdleCurrent: c_ulong, + IdleLast: c_ulong, + IdleIdeal: c_ulong, + PreemptAny: c_ulong, + PreemptCurrent: c_ulong, + PreemptLast: c_ulong, + SwitchToIdle: c_ulong, +}} +pub type PSYSTEM_CONTEXT_SWITCH_INFORMATION = + *mut SYSTEM_CONTEXT_SWITCH_INFORMATION; +STRUCT! {struct SYSTEM_REGISTRY_QUOTA_INFORMATION { + RegistryQuotaAllowed: c_ulong, + RegistryQuotaUsed: c_ulong, + PagedPoolSize: usize, +}} +pub type PSYSTEM_REGISTRY_QUOTA_INFORMATION = + *mut SYSTEM_REGISTRY_QUOTA_INFORMATION; +STRUCT! {struct SYSTEM_PROCESSOR_IDLE_INFORMATION { + IdleTime: __uint64, + C1Time: __uint64, + C2Time: __uint64, + C3Time: __uint64, + C1Transitions: c_ulong, + C2Transitions: c_ulong, + C3Transitions: c_ulong, + Padding: c_ulong, +}} +pub type PSYSTEM_PROCESSOR_IDLE_INFORMATION = + *mut SYSTEM_PROCESSOR_IDLE_INFORMATION; +STRUCT! {struct SYSTEM_LEGACY_DRIVER_INFORMATION { + VetoType: c_ulong, VetoList: UNICODE_STRING, }} -pub type PSYSTEM_LEGACY_DRIVER_INFORMATION = *mut SYSTEM_LEGACY_DRIVER_INFORMATION; -STRUCT!{struct SYSTEM_LOOKASIDE_INFORMATION { - CurrentDepth: USHORT, - MaximumDepth: USHORT, - TotalAllocates: ULONG, - AllocateMisses: ULONG, - TotalFrees: ULONG, - FreeMisses: ULONG, - Type: ULONG, - Tag: ULONG, - Size: ULONG, +pub type PSYSTEM_LEGACY_DRIVER_INFORMATION = + *mut SYSTEM_LEGACY_DRIVER_INFORMATION; +STRUCT! {struct SYSTEM_LOOKASIDE_INFORMATION { + CurrentDepth: c_ushort, + MaximumDepth: c_ushort, + TotalAllocates: c_ulong, + AllocateMisses: c_ulong, + TotalFrees: c_ulong, + FreeMisses: c_ulong, + Type: c_ulong, + Tag: c_ulong, + Size: c_ulong, }} pub type PSYSTEM_LOOKASIDE_INFORMATION = *mut SYSTEM_LOOKASIDE_INFORMATION; -STRUCT!{struct SYSTEM_RANGE_START_INFORMATION { - SystemRangeStart: PVOID, +STRUCT! {struct SYSTEM_RANGE_START_INFORMATION { + SystemRangeStart: *mut c_void, }} pub type PSYSTEM_RANGE_START_INFORMATION = *mut SYSTEM_RANGE_START_INFORMATION; -STRUCT!{struct SYSTEM_VERIFIER_INFORMATION { - NextEntryOffset: ULONG, - Level: ULONG, +STRUCT! {struct SYSTEM_VERIFIER_INFORMATION { + NextEntryOffset: c_ulong, + Level: c_ulong, DriverName: UNICODE_STRING, - RaiseIrqls: ULONG, - AcquireSpinLocks: ULONG, - SynchronizeExecutions: ULONG, - AllocationsAttempted: ULONG, - AllocationsSucceeded: ULONG, - AllocationsSucceededSpecialPool: ULONG, - AllocationsWithNoTag: ULONG, - TrimRequests: ULONG, - Trims: ULONG, - AllocationsFailed: ULONG, - AllocationsFailedDeliberately: ULONG, - Loads: ULONG, - Unloads: ULONG, - UnTrackedPool: ULONG, - CurrentPagedPoolAllocations: ULONG, - CurrentNonPagedPoolAllocations: ULONG, - PeakPagedPoolAllocations: ULONG, - PeakNonPagedPoolAllocations: ULONG, - PagedPoolUsageInBytes: SIZE_T, - NonPagedPoolUsageInBytes: SIZE_T, - PeakPagedPoolUsageInBytes: SIZE_T, - PeakNonPagedPoolUsageInBytes: SIZE_T, + RaiseIrqls: c_ulong, + AcquireSpinLocks: c_ulong, + SynchronizeExecutions: c_ulong, + AllocationsAttempted: c_ulong, + AllocationsSucceeded: c_ulong, + AllocationsSucceededSpecialPool: c_ulong, + AllocationsWithNoTag: c_ulong, + TrimRequests: c_ulong, + Trims: c_ulong, + AllocationsFailed: c_ulong, + AllocationsFailedDeliberately: c_ulong, + Loads: c_ulong, + Unloads: c_ulong, + UnTrackedPool: c_ulong, + CurrentPagedPoolAllocations: c_ulong, + CurrentNonPagedPoolAllocations: c_ulong, + PeakPagedPoolAllocations: c_ulong, + PeakNonPagedPoolAllocations: c_ulong, + PagedPoolUsageInBytes: usize, + NonPagedPoolUsageInBytes: usize, + PeakPagedPoolUsageInBytes: usize, + PeakNonPagedPoolUsageInBytes: usize, }} pub type PSYSTEM_VERIFIER_INFORMATION = *mut SYSTEM_VERIFIER_INFORMATION; -STRUCT!{struct SYSTEM_SESSION_PROCESS_INFORMATION { - SessionId: ULONG, - SizeOfBuf: ULONG, - Buffer: PVOID, -}} -pub type PSYSTEM_SESSION_PROCESS_INFORMATION = *mut SYSTEM_SESSION_PROCESS_INFORMATION; -STRUCT!{struct SYSTEM_PROCESSOR_POWER_INFORMATION { - CurrentFrequency: UCHAR, - ThermalLimitFrequency: UCHAR, - ConstantThrottleFrequency: UCHAR, - DegradedThrottleFrequency: UCHAR, - LastBusyFrequency: UCHAR, - LastC3Frequency: UCHAR, - LastAdjustedBusyFrequency: UCHAR, - ProcessorMinThrottle: UCHAR, - ProcessorMaxThrottle: UCHAR, - NumberOfFrequencies: ULONG, - PromotionCount: ULONG, - DemotionCount: ULONG, - ErrorCount: ULONG, - RetryCount: ULONG, - CurrentFrequencyTime: ULONGLONG, - CurrentProcessorTime: ULONGLONG, - CurrentProcessorIdleTime: ULONGLONG, - LastProcessorTime: ULONGLONG, - LastProcessorIdleTime: ULONGLONG, - Energy: ULONGLONG, -}} -pub type PSYSTEM_PROCESSOR_POWER_INFORMATION = *mut SYSTEM_PROCESSOR_POWER_INFORMATION; -STRUCT!{struct SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX { - Object: PVOID, - UniqueProcessId: ULONG_PTR, - HandleValue: ULONG_PTR, - GrantedAccess: ULONG, - CreatorBackTraceIndex: USHORT, - ObjectTypeIndex: USHORT, - HandleAttributes: ULONG, - Reserved: ULONG, -}} -pub type PSYSTEM_HANDLE_TABLE_ENTRY_INFO_EX = *mut SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX; -STRUCT!{struct SYSTEM_HANDLE_INFORMATION_EX { - NumberOfHandles: ULONG_PTR, - Reserved: ULONG_PTR, +STRUCT! {struct SYSTEM_SESSION_PROCESS_INFORMATION { + SessionId: c_ulong, + SizeOfBuf: c_ulong, + Buffer: *mut c_void, +}} +pub type PSYSTEM_SESSION_PROCESS_INFORMATION = + *mut SYSTEM_SESSION_PROCESS_INFORMATION; +STRUCT! {struct SYSTEM_PROCESSOR_POWER_INFORMATION { + CurrentFrequency: c_uchar, + ThermalLimitFrequency: c_uchar, + ConstantThrottleFrequency: c_uchar, + DegradedThrottleFrequency: c_uchar, + LastBusyFrequency: c_uchar, + LastC3Frequency: c_uchar, + LastAdjustedBusyFrequency: c_uchar, + ProcessorMinThrottle: c_uchar, + ProcessorMaxThrottle: c_uchar, + NumberOfFrequencies: c_ulong, + PromotionCount: c_ulong, + DemotionCount: c_ulong, + ErrorCount: c_ulong, + RetryCount: c_ulong, + CurrentFrequencyTime: __uint64, + CurrentProcessorTime: __uint64, + CurrentProcessorIdleTime: __uint64, + LastProcessorTime: __uint64, + LastProcessorIdleTime: __uint64, + Energy: __uint64, +}} +pub type PSYSTEM_PROCESSOR_POWER_INFORMATION = + *mut SYSTEM_PROCESSOR_POWER_INFORMATION; +STRUCT! {struct SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX { + Object: *mut c_void, + UniqueProcessId: usize, + HandleValue: usize, + GrantedAccess: c_ulong, + CreatorBackTraceIndex: c_ushort, + ObjectTypeIndex: c_ushort, + HandleAttributes: c_ulong, + Reserved: c_ulong, +}} +pub type PSYSTEM_HANDLE_TABLE_ENTRY_INFO_EX = + *mut SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX; +STRUCT! {struct SYSTEM_HANDLE_INFORMATION_EX { + NumberOfHandles: usize, + Reserved: usize, Handles: [SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX; 1], }} pub type PSYSTEM_HANDLE_INFORMATION_EX = *mut SYSTEM_HANDLE_INFORMATION_EX; -UNION!{union SYSTEM_BIGPOOL_ENTRY_u1 { - VirtualAddress: PVOID, - Bitfields: ULONG_PTR, +UNION! {union SYSTEM_BIGPOOL_ENTRY_u1 { + VirtualAddress: *mut c_void, + Bitfields: usize, }} -UNION!{union SYSTEM_BIGPOOL_ENTRY_u2 { - Tag: [UCHAR; 4], - TagUlong: ULONG, +UNION! {union SYSTEM_BIGPOOL_ENTRY_u2 { + Tag: [c_uchar; 4], + TagUlong: c_ulong, }} -BITFIELD!{unsafe SYSTEM_BIGPOOL_ENTRY_u1 Bitfields: ULONG_PTR [ +BITFIELD! {unsafe SYSTEM_BIGPOOL_ENTRY_u1 Bitfields: usize [ NonPaged set_NonPaged[0..1], ]} -STRUCT!{struct SYSTEM_BIGPOOL_ENTRY { +STRUCT! {struct SYSTEM_BIGPOOL_ENTRY { u1: SYSTEM_BIGPOOL_ENTRY_u1, - SizeInBytes: SIZE_T, + SizeInBytes: usize, u2: SYSTEM_BIGPOOL_ENTRY_u2, }} pub type PSYSTEM_BIGPOOL_ENTRY = *mut SYSTEM_BIGPOOL_ENTRY; -STRUCT!{struct SYSTEM_BIGPOOL_INFORMATION { - Count: ULONG, +STRUCT! {struct SYSTEM_BIGPOOL_INFORMATION { + Count: c_ulong, AllocatedInfo: [SYSTEM_BIGPOOL_ENTRY; 1], }} pub type PSYSTEM_BIGPOOL_INFORMATION = *mut SYSTEM_BIGPOOL_INFORMATION; -UNION!{union SYSTEM_POOL_ENTRY_u { - Tag: [UCHAR; 4], - TagUlong: ULONG, - ProcessChargedQuota: PVOID, -}} -STRUCT!{struct SYSTEM_POOL_ENTRY { - Allocated: BOOLEAN, - Spare0: BOOLEAN, - AllocatorBackTraceIndex: USHORT, - Size: ULONG, +UNION! {union SYSTEM_POOL_ENTRY_u { + Tag: [c_uchar; 4], + TagUlong: c_ulong, + ProcessChargedQuota: *mut c_void, +}} +STRUCT! {struct SYSTEM_POOL_ENTRY { + Allocated: c_uchar, + Spare0: c_uchar, + AllocatorBackTraceIndex: c_ushort, + Size: c_ulong, u: SYSTEM_POOL_ENTRY_u, }} pub type PSYSTEM_POOL_ENTRY = *mut SYSTEM_POOL_ENTRY; -STRUCT!{struct SYSTEM_POOL_INFORMATION { - TotalSize: SIZE_T, - FirstEntry: PVOID, - EntryOverhead: USHORT, - PoolTagPresent: BOOLEAN, - Spare0: BOOLEAN, - NumberOfEntries: ULONG, +STRUCT! {struct SYSTEM_POOL_INFORMATION { + TotalSize: usize, + FirstEntry: *mut c_void, + EntryOverhead: c_ushort, + PoolTagPresent: c_uchar, + Spare0: c_uchar, + NumberOfEntries: c_ulong, Entries: [SYSTEM_POOL_ENTRY; 1], }} pub type PSYSTEM_POOL_INFORMATION = *mut SYSTEM_POOL_INFORMATION; -STRUCT!{struct SYSTEM_SESSION_POOLTAG_INFORMATION { - NextEntryOffset: SIZE_T, - SessionId: ULONG, - Count: ULONG, +STRUCT! {struct SYSTEM_SESSION_POOLTAG_INFORMATION { + NextEntryOffset: usize, + SessionId: c_ulong, + Count: c_ulong, TagInfo: [SYSTEM_POOLTAG; 1], }} -pub type PSYSTEM_SESSION_POOLTAG_INFORMATION = *mut SYSTEM_SESSION_POOLTAG_INFORMATION; -STRUCT!{struct SYSTEM_SESSION_MAPPED_VIEW_INFORMATION { - NextEntryOffset: SIZE_T, - SessionId: ULONG, - ViewFailures: ULONG, - NumberOfBytesAvailable: SIZE_T, - NumberOfBytesAvailableContiguous: SIZE_T, -}} -pub type PSYSTEM_SESSION_MAPPED_VIEW_INFORMATION = *mut SYSTEM_SESSION_MAPPED_VIEW_INFORMATION; -ENUM!{enum SYSTEM_FIRMWARE_TABLE_ACTION { +pub type PSYSTEM_SESSION_POOLTAG_INFORMATION = + *mut SYSTEM_SESSION_POOLTAG_INFORMATION; +STRUCT! {struct SYSTEM_SESSION_MAPPED_VIEW_INFORMATION { + NextEntryOffset: usize, + SessionId: c_ulong, + ViewFailures: c_ulong, + NumberOfBytesAvailable: usize, + NumberOfBytesAvailableContiguous: usize, +}} +pub type PSYSTEM_SESSION_MAPPED_VIEW_INFORMATION = + *mut SYSTEM_SESSION_MAPPED_VIEW_INFORMATION; +ENUM! {enum SYSTEM_FIRMWARE_TABLE_ACTION { SystemFirmwareTableEnumerate = 0, SystemFirmwareTableGet = 1, SystemFirmwareTableMax = 2, }} -STRUCT!{struct SYSTEM_FIRMWARE_TABLE_INFORMATION { - ProviderSignature: ULONG, +STRUCT! {struct SYSTEM_FIRMWARE_TABLE_INFORMATION { + ProviderSignature: c_ulong, Action: SYSTEM_FIRMWARE_TABLE_ACTION, - TableID: ULONG, - TableBufferLength: ULONG, - TableBuffer: [UCHAR; 1], -}} -pub type PSYSTEM_FIRMWARE_TABLE_INFORMATION = *mut SYSTEM_FIRMWARE_TABLE_INFORMATION; -STRUCT!{struct SYSTEM_MEMORY_LIST_INFORMATION { - ZeroPageCount: ULONG_PTR, - FreePageCount: ULONG_PTR, - ModifiedPageCount: ULONG_PTR, - ModifiedNoWritePageCount: ULONG_PTR, - BadPageCount: ULONG_PTR, - PageCountByPriority: [ULONG_PTR; 8], - RepurposedPagesByPriority: [ULONG_PTR; 8], - ModifiedPageCountPageFile: ULONG_PTR, + TableID: c_ulong, + TableBufferLength: c_ulong, + TableBuffer: [c_uchar; 1], +}} +pub type PSYSTEM_FIRMWARE_TABLE_INFORMATION = + *mut SYSTEM_FIRMWARE_TABLE_INFORMATION; +STRUCT! {struct SYSTEM_MEMORY_LIST_INFORMATION { + ZeroPageCount: usize, + FreePageCount: usize, + ModifiedPageCount: usize, + ModifiedNoWritePageCount: usize, + BadPageCount: usize, + PageCountByPriority: [usize; 8], + RepurposedPagesByPriority: [usize; 8], + ModifiedPageCountPageFile: usize, }} pub type PSYSTEM_MEMORY_LIST_INFORMATION = *mut SYSTEM_MEMORY_LIST_INFORMATION; -ENUM!{enum SYSTEM_MEMORY_LIST_COMMAND { +ENUM! {enum SYSTEM_MEMORY_LIST_COMMAND { MemoryCaptureAccessedBits = 0, MemoryCaptureAndResetAccessedBits = 1, MemoryEmptyWorkingSets = 2, @@ -1700,103 +1755,108 @@ ENUM!{enum SYSTEM_MEMORY_LIST_COMMAND { MemoryPurgeLowPriorityStandbyList = 5, MemoryCommandMax = 6, }} -STRUCT!{struct SYSTEM_THREAD_CID_PRIORITY_INFORMATION { +STRUCT! {struct SYSTEM_THREAD_CID_PRIORITY_INFORMATION { ClientId: CLIENT_ID, Priority: KPRIORITY, }} -pub type PSYSTEM_THREAD_CID_PRIORITY_INFORMATION = *mut SYSTEM_THREAD_CID_PRIORITY_INFORMATION; -STRUCT!{struct SYSTEM_PROCESSOR_IDLE_CYCLE_TIME_INFORMATION { - CycleTime: ULONGLONG, +pub type PSYSTEM_THREAD_CID_PRIORITY_INFORMATION = + *mut SYSTEM_THREAD_CID_PRIORITY_INFORMATION; +STRUCT! {struct SYSTEM_PROCESSOR_IDLE_CYCLE_TIME_INFORMATION { + CycleTime: __uint64, }} pub type PSYSTEM_PROCESSOR_IDLE_CYCLE_TIME_INFORMATION = *mut SYSTEM_PROCESSOR_IDLE_CYCLE_TIME_INFORMATION; -STRUCT!{struct SYSTEM_REF_TRACE_INFORMATION { - TraceEnable: BOOLEAN, - TracePermanent: BOOLEAN, +STRUCT! {struct SYSTEM_REF_TRACE_INFORMATION { + TraceEnable: c_uchar, + TracePermanent: c_uchar, TraceProcessName: UNICODE_STRING, TracePoolTags: UNICODE_STRING, }} pub type PSYSTEM_REF_TRACE_INFORMATION = *mut SYSTEM_REF_TRACE_INFORMATION; -STRUCT!{struct SYSTEM_PROCESS_ID_INFORMATION { +STRUCT! {struct SYSTEM_PROCESS_ID_INFORMATION { ProcessId: HANDLE, ImageName: UNICODE_STRING, }} pub type PSYSTEM_PROCESS_ID_INFORMATION = *mut SYSTEM_PROCESS_ID_INFORMATION; -STRUCT!{struct SYSTEM_BOOT_ENVIRONMENT_INFORMATION { +STRUCT! {struct SYSTEM_BOOT_ENVIRONMENT_INFORMATION { BootIdentifier: GUID, FirmwareType: FIRMWARE_TYPE, - BootFlags: ULONGLONG, + BootFlags: __uint64, }} -BITFIELD!{SYSTEM_BOOT_ENVIRONMENT_INFORMATION BootFlags: ULONGLONG [ +BITFIELD! {SYSTEM_BOOT_ENVIRONMENT_INFORMATION BootFlags: __uint64 [ DbgMenuOsSelection set_DbgMenuOsSelection[0..1], DbgHiberBoot set_DbgHiberBoot[1..2], DbgSoftBoot set_DbgSoftBoot[2..3], DbgMeasuredLaunch set_DbgMeasuredLaunch[3..4], ]} -pub type PSYSTEM_BOOT_ENVIRONMENT_INFORMATION = *mut SYSTEM_BOOT_ENVIRONMENT_INFORMATION; -STRUCT!{struct SYSTEM_IMAGE_FILE_EXECUTION_OPTIONS_INFORMATION { - FlagsToEnable: ULONG, - FlagsToDisable: ULONG, +pub type PSYSTEM_BOOT_ENVIRONMENT_INFORMATION = + *mut SYSTEM_BOOT_ENVIRONMENT_INFORMATION; +STRUCT! {struct SYSTEM_IMAGE_FILE_EXECUTION_OPTIONS_INFORMATION { + FlagsToEnable: c_ulong, + FlagsToDisable: c_ulong, }} pub type PSYSTEM_IMAGE_FILE_EXECUTION_OPTIONS_INFORMATION = *mut SYSTEM_IMAGE_FILE_EXECUTION_OPTIONS_INFORMATION; #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] -STRUCT!{struct SYSTEM_VERIFIER_INFORMATION_EX { - VerifyMode: ULONG, - OptionChanges: ULONG, +STRUCT! {struct SYSTEM_VERIFIER_INFORMATION_EX { + VerifyMode: c_ulong, + OptionChanges: c_ulong, PreviousBucketName: UNICODE_STRING, - IrpCancelTimeoutMsec: ULONG, - VerifierExtensionEnabled: ULONG, - Reserved: [ULONG; 1], + IrpCancelTimeoutMsec: c_ulong, + VerifierExtensionEnabled: c_ulong, + Reserved: [c_ulong; 1], }} #[cfg(target_arch = "x86")] -STRUCT!{struct SYSTEM_VERIFIER_INFORMATION_EX { - VerifyMode: ULONG, - OptionChanges: ULONG, +STRUCT! {struct SYSTEM_VERIFIER_INFORMATION_EX { + VerifyMode: c_ulong, + OptionChanges: c_ulong, PreviousBucketName: UNICODE_STRING, - IrpCancelTimeoutMsec: ULONG, - VerifierExtensionEnabled: ULONG, - Reserved: [ULONG; 3], + IrpCancelTimeoutMsec: c_ulong, + VerifierExtensionEnabled: c_ulong, + Reserved: [c_ulong; 3], }} pub type PSYSTEM_VERIFIER_INFORMATION_EX = *mut SYSTEM_VERIFIER_INFORMATION_EX; -STRUCT!{struct SYSTEM_SYSTEM_PARTITION_INFORMATION { +STRUCT! {struct SYSTEM_SYSTEM_PARTITION_INFORMATION { SystemPartition: UNICODE_STRING, }} -pub type PSYSTEM_SYSTEM_PARTITION_INFORMATION = *mut SYSTEM_SYSTEM_PARTITION_INFORMATION; -STRUCT!{struct SYSTEM_SYSTEM_DISK_INFORMATION { +pub type PSYSTEM_SYSTEM_PARTITION_INFORMATION = + *mut SYSTEM_SYSTEM_PARTITION_INFORMATION; +STRUCT! {struct SYSTEM_SYSTEM_DISK_INFORMATION { SystemDisk: UNICODE_STRING, }} pub type PSYSTEM_SYSTEM_DISK_INFORMATION = *mut SYSTEM_SYSTEM_DISK_INFORMATION; -STRUCT!{struct SYSTEM_PROCESSOR_PERFORMANCE_HITCOUNT { - Hits: ULONGLONG, - PercentFrequency: UCHAR, +STRUCT! {struct SYSTEM_PROCESSOR_PERFORMANCE_HITCOUNT { + Hits: __uint64, + PercentFrequency: c_uchar, }} -pub type PSYSTEM_PROCESSOR_PERFORMANCE_HITCOUNT = *mut SYSTEM_PROCESSOR_PERFORMANCE_HITCOUNT; -STRUCT!{struct SYSTEM_PROCESSOR_PERFORMANCE_HITCOUNT_WIN8 { - Hits: ULONG, - PercentFrequency: UCHAR, +pub type PSYSTEM_PROCESSOR_PERFORMANCE_HITCOUNT = + *mut SYSTEM_PROCESSOR_PERFORMANCE_HITCOUNT; +STRUCT! {struct SYSTEM_PROCESSOR_PERFORMANCE_HITCOUNT_WIN8 { + Hits: c_ulong, + PercentFrequency: c_uchar, }} pub type PSYSTEM_PROCESSOR_PERFORMANCE_HITCOUNT_WIN8 = *mut SYSTEM_PROCESSOR_PERFORMANCE_HITCOUNT_WIN8; -STRUCT!{struct SYSTEM_PROCESSOR_PERFORMANCE_STATE_DISTRIBUTION { - ProcessorNumber: ULONG, - StateCount: ULONG, +STRUCT! {struct SYSTEM_PROCESSOR_PERFORMANCE_STATE_DISTRIBUTION { + ProcessorNumber: c_ulong, + StateCount: c_ulong, States: [SYSTEM_PROCESSOR_PERFORMANCE_HITCOUNT; 1], }} pub type PSYSTEM_PROCESSOR_PERFORMANCE_STATE_DISTRIBUTION = *mut SYSTEM_PROCESSOR_PERFORMANCE_STATE_DISTRIBUTION; -STRUCT!{struct SYSTEM_PROCESSOR_PERFORMANCE_DISTRIBUTION { - ProcessorCount: ULONG, - Offsets: [ULONG; 1], +STRUCT! {struct SYSTEM_PROCESSOR_PERFORMANCE_DISTRIBUTION { + ProcessorCount: c_ulong, + Offsets: [c_ulong; 1], }} pub type PSYSTEM_PROCESSOR_PERFORMANCE_DISTRIBUTION = *mut SYSTEM_PROCESSOR_PERFORMANCE_DISTRIBUTION; -STRUCT!{struct SYSTEM_CODEINTEGRITY_INFORMATION { - Length: ULONG, - CodeIntegrityOptions: ULONG, +STRUCT! {struct SYSTEM_CODEINTEGRITY_INFORMATION { + Length: c_ulong, + CodeIntegrityOptions: c_ulong, }} -pub type PSYSTEM_CODEINTEGRITY_INFORMATION = *mut SYSTEM_CODEINTEGRITY_INFORMATION; -ENUM!{enum SYSTEM_VA_TYPE { +pub type PSYSTEM_CODEINTEGRITY_INFORMATION = + *mut SYSTEM_CODEINTEGRITY_INFORMATION; +ENUM! {enum SYSTEM_VA_TYPE { SystemVaTypeAll = 0, SystemVaTypeNonPagedPool = 1, SystemVaTypePagedPool = 2, @@ -1806,320 +1866,330 @@ ENUM!{enum SYSTEM_VA_TYPE { SystemVaTypeMax = 6, }} pub type PSYSTEM_VA_TYPE = *mut SYSTEM_VA_TYPE; -STRUCT!{struct SYSTEM_VA_LIST_INFORMATION { - VirtualSize: SIZE_T, - VirtualPeak: SIZE_T, - VirtualLimit: SIZE_T, - AllocationFailures: SIZE_T, +STRUCT! {struct SYSTEM_VA_LIST_INFORMATION { + VirtualSize: usize, + VirtualPeak: usize, + VirtualLimit: usize, + AllocationFailures: usize, }} pub type PSYSTEM_VA_LIST_INFORMATION = *mut SYSTEM_VA_LIST_INFORMATION; -STRUCT!{struct SYSTEM_REGISTRY_APPEND_STRING_PARAMETERS { +STRUCT! {struct SYSTEM_REGISTRY_APPEND_STRING_PARAMETERS { KeyHandle: HANDLE, - ValueNamePointer: PUNICODE_STRING, - RequiredLengthPointer: PULONG, - Buffer: PUCHAR, - BufferLength: ULONG, - Type: ULONG, - AppendBuffer: PUCHAR, - AppendBufferLength: ULONG, - CreateIfDoesntExist: BOOLEAN, - TruncateExistingValue: BOOLEAN, -}} -pub type PSYSTEM_REGISTRY_APPEND_STRING_PARAMETERS = *mut SYSTEM_REGISTRY_APPEND_STRING_PARAMETERS; -STRUCT!{struct SYSTEM_VHD_BOOT_INFORMATION { - OsDiskIsVhd: BOOLEAN, - OsVhdFilePathOffset: ULONG, - OsVhdParentVolume: [WCHAR; ANYSIZE_ARRAY], + ValueNamePointer: *mut UNICODE_STRING, + RequiredLengthPointer: *mut c_ulong, + Buffer: *mut c_uchar, + BufferLength: c_ulong, + Type: c_ulong, + AppendBuffer: *mut c_uchar, + AppendBufferLength: c_ulong, + CreateIfDoesntExist: c_uchar, + TruncateExistingValue: c_uchar, +}} +pub type PSYSTEM_REGISTRY_APPEND_STRING_PARAMETERS = + *mut SYSTEM_REGISTRY_APPEND_STRING_PARAMETERS; +STRUCT! {struct SYSTEM_VHD_BOOT_INFORMATION { + OsDiskIsVhd: c_uchar, + OsVhdFilePathOffset: c_ulong, + OsVhdParentVolume: [wchar_t; ANYSIZE_ARRAY as usize], }} pub type PSYSTEM_VHD_BOOT_INFORMATION = *mut SYSTEM_VHD_BOOT_INFORMATION; -STRUCT!{struct SYSTEM_LOW_PRIORITY_IO_INFORMATION { - LowPriReadOperations: ULONG, - LowPriWriteOperations: ULONG, - KernelBumpedToNormalOperations: ULONG, - LowPriPagingReadOperations: ULONG, - KernelPagingReadsBumpedToNormal: ULONG, - LowPriPagingWriteOperations: ULONG, - KernelPagingWritesBumpedToNormal: ULONG, - BoostedIrpCount: ULONG, - BoostedPagingIrpCount: ULONG, - BlanketBoostCount: ULONG, -}} -pub type PSYSTEM_LOW_PRIORITY_IO_INFORMATION = *mut SYSTEM_LOW_PRIORITY_IO_INFORMATION; -ENUM!{enum TPM_BOOT_ENTROPY_RESULT_CODE { +STRUCT! {struct SYSTEM_LOW_PRIORITY_IO_INFORMATION { + LowPriReadOperations: c_ulong, + LowPriWriteOperations: c_ulong, + KernelBumpedToNormalOperations: c_ulong, + LowPriPagingReadOperations: c_ulong, + KernelPagingReadsBumpedToNormal: c_ulong, + LowPriPagingWriteOperations: c_ulong, + KernelPagingWritesBumpedToNormal: c_ulong, + BoostedIrpCount: c_ulong, + BoostedPagingIrpCount: c_ulong, + BlanketBoostCount: c_ulong, +}} +pub type PSYSTEM_LOW_PRIORITY_IO_INFORMATION = + *mut SYSTEM_LOW_PRIORITY_IO_INFORMATION; +ENUM! {enum TPM_BOOT_ENTROPY_RESULT_CODE { TpmBootEntropyStructureUninitialized = 0, TpmBootEntropyDisabledByPolicy = 1, TpmBootEntropyNoTpmFound = 2, TpmBootEntropyTpmError = 3, TpmBootEntropySuccess = 4, }} -STRUCT!{struct TPM_BOOT_ENTROPY_NT_RESULT { - Policy: ULONGLONG, +STRUCT! {struct TPM_BOOT_ENTROPY_NT_RESULT { + Policy: __uint64, ResultCode: TPM_BOOT_ENTROPY_RESULT_CODE, ResultStatus: NTSTATUS, - Time: ULONGLONG, - EntropyLength: ULONG, - EntropyData: [UCHAR; 40], + Time: __uint64, + EntropyLength: c_ulong, + EntropyData: [c_uchar; 40], }} pub type PTPM_BOOT_ENTROPY_NT_RESULT = *mut TPM_BOOT_ENTROPY_NT_RESULT; -STRUCT!{struct SYSTEM_VERIFIER_COUNTERS_INFORMATION { +STRUCT! {struct SYSTEM_VERIFIER_COUNTERS_INFORMATION { Legacy: SYSTEM_VERIFIER_INFORMATION, - RaiseIrqls: ULONG, - AcquireSpinLocks: ULONG, - SynchronizeExecutions: ULONG, - AllocationsWithNoTag: ULONG, - AllocationsFailed: ULONG, - AllocationsFailedDeliberately: ULONG, - LockedBytes: SIZE_T, - PeakLockedBytes: SIZE_T, - MappedLockedBytes: SIZE_T, - PeakMappedLockedBytes: SIZE_T, - MappedIoSpaceBytes: SIZE_T, - PeakMappedIoSpaceBytes: SIZE_T, - PagesForMdlBytes: SIZE_T, - PeakPagesForMdlBytes: SIZE_T, - ContiguousMemoryBytes: SIZE_T, - PeakContiguousMemoryBytes: SIZE_T, - ExecutePoolTypes: ULONG, - ExecutePageProtections: ULONG, - ExecutePageMappings: ULONG, - ExecuteWriteSections: ULONG, - SectionAlignmentFailures: ULONG, - UnsupportedRelocs: ULONG, - IATInExecutableSection: ULONG, -}} -pub type PSYSTEM_VERIFIER_COUNTERS_INFORMATION = *mut SYSTEM_VERIFIER_COUNTERS_INFORMATION; -STRUCT!{struct SYSTEM_ACPI_AUDIT_INFORMATION { - RsdpCount: ULONG, - Bitfields: ULONG, -}} -BITFIELD!{SYSTEM_ACPI_AUDIT_INFORMATION Bitfields: ULONG [ + RaiseIrqls: c_ulong, + AcquireSpinLocks: c_ulong, + SynchronizeExecutions: c_ulong, + AllocationsWithNoTag: c_ulong, + AllocationsFailed: c_ulong, + AllocationsFailedDeliberately: c_ulong, + LockedBytes: usize, + PeakLockedBytes: usize, + MappedLockedBytes: usize, + PeakMappedLockedBytes: usize, + MappedIoSpaceBytes: usize, + PeakMappedIoSpaceBytes: usize, + PagesForMdlBytes: usize, + PeakPagesForMdlBytes: usize, + ContiguousMemoryBytes: usize, + PeakContiguousMemoryBytes: usize, + ExecutePoolTypes: c_ulong, + ExecutePageProtections: c_ulong, + ExecutePageMappings: c_ulong, + ExecuteWriteSections: c_ulong, + SectionAlignmentFailures: c_ulong, + UnsupportedRelocs: c_ulong, + IATInExecutableSection: c_ulong, +}} +pub type PSYSTEM_VERIFIER_COUNTERS_INFORMATION = + *mut SYSTEM_VERIFIER_COUNTERS_INFORMATION; +STRUCT! {struct SYSTEM_ACPI_AUDIT_INFORMATION { + RsdpCount: c_ulong, + Bitfields: c_ulong, +}} +BITFIELD! {SYSTEM_ACPI_AUDIT_INFORMATION Bitfields: c_ulong [ SameRsdt set_SameRsdt[0..1], SlicPresent set_SlicPresent[1..2], SlicDifferent set_SlicDifferent[2..3], ]} pub type PSYSTEM_ACPI_AUDIT_INFORMATION = *mut SYSTEM_ACPI_AUDIT_INFORMATION; -STRUCT!{struct SYSTEM_BASIC_PERFORMANCE_INFORMATION { - AvailablePages: SIZE_T, - CommittedPages: SIZE_T, - CommitLimit: SIZE_T, - PeakCommitment: SIZE_T, -}} -pub type PSYSTEM_BASIC_PERFORMANCE_INFORMATION = *mut SYSTEM_BASIC_PERFORMANCE_INFORMATION; -STRUCT!{struct QUERY_PERFORMANCE_COUNTER_FLAGS { - ul: ULONG, -}} -BITFIELD!{QUERY_PERFORMANCE_COUNTER_FLAGS ul: ULONG [ +STRUCT! {struct SYSTEM_BASIC_PERFORMANCE_INFORMATION { + AvailablePages: usize, + CommittedPages: usize, + CommitLimit: usize, + PeakCommitment: usize, +}} +pub type PSYSTEM_BASIC_PERFORMANCE_INFORMATION = + *mut SYSTEM_BASIC_PERFORMANCE_INFORMATION; +STRUCT! {struct QUERY_PERFORMANCE_COUNTER_FLAGS { + ul: c_ulong, +}} +BITFIELD! {QUERY_PERFORMANCE_COUNTER_FLAGS ul: c_ulong [ KernelTransition set_KernelTransition[0..1], Reserved set_Reserved[1..32], ]} -STRUCT!{struct SYSTEM_QUERY_PERFORMANCE_COUNTER_INFORMATION { - Version: ULONG, +STRUCT! {struct SYSTEM_QUERY_PERFORMANCE_COUNTER_INFORMATION { + Version: c_ulong, Flags: QUERY_PERFORMANCE_COUNTER_FLAGS, ValidFlags: QUERY_PERFORMANCE_COUNTER_FLAGS, }} pub type PSYSTEM_QUERY_PERFORMANCE_COUNTER_INFORMATION = *mut SYSTEM_QUERY_PERFORMANCE_COUNTER_INFORMATION; -ENUM!{enum SYSTEM_PIXEL_FORMAT { +ENUM! {enum SYSTEM_PIXEL_FORMAT { SystemPixelFormatUnknown = 0, SystemPixelFormatR8G8B8 = 1, SystemPixelFormatR8G8B8X8 = 2, SystemPixelFormatB8G8R8 = 3, SystemPixelFormatB8G8R8X8 = 4, }} -STRUCT!{struct SYSTEM_BOOT_GRAPHICS_INFORMATION { +STRUCT! {struct SYSTEM_BOOT_GRAPHICS_INFORMATION { FrameBuffer: LARGE_INTEGER, - Width: ULONG, - Height: ULONG, - PixelStride: ULONG, - Flags: ULONG, + Width: c_ulong, + Height: c_ulong, + PixelStride: c_ulong, + Flags: c_ulong, Format: SYSTEM_PIXEL_FORMAT, - DisplayRotation: ULONG, + DisplayRotation: c_ulong, }} -pub type PSYSTEM_BOOT_GRAPHICS_INFORMATION = *mut SYSTEM_BOOT_GRAPHICS_INFORMATION; -STRUCT!{struct MEMORY_SCRUB_INFORMATION { +pub type PSYSTEM_BOOT_GRAPHICS_INFORMATION = + *mut SYSTEM_BOOT_GRAPHICS_INFORMATION; +STRUCT! {struct MEMORY_SCRUB_INFORMATION { Handle: HANDLE, - PagesScrubbed: ULONG, + PagesScrubbed: c_ulong, }} pub type PMEMORY_SCRUB_INFORMATION = *mut MEMORY_SCRUB_INFORMATION; -STRUCT!{struct PEBS_DS_SAVE_AREA { - BtsBufferBase: ULONGLONG, - BtsIndex: ULONGLONG, - BtsAbsoluteMaximum: ULONGLONG, - BtsInterruptThreshold: ULONGLONG, - PebsBufferBase: ULONGLONG, - PebsIndex: ULONGLONG, - PebsAbsoluteMaximum: ULONGLONG, - PebsInterruptThreshold: ULONGLONG, - PebsCounterReset0: ULONGLONG, - PebsCounterReset1: ULONGLONG, - PebsCounterReset2: ULONGLONG, - PebsCounterReset3: ULONGLONG, +STRUCT! {struct PEBS_DS_SAVE_AREA { + BtsBufferBase: __uint64, + BtsIndex: __uint64, + BtsAbsoluteMaximum: __uint64, + BtsInterruptThreshold: __uint64, + PebsBufferBase: __uint64, + PebsIndex: __uint64, + PebsAbsoluteMaximum: __uint64, + PebsInterruptThreshold: __uint64, + PebsCounterReset0: __uint64, + PebsCounterReset1: __uint64, + PebsCounterReset2: __uint64, + PebsCounterReset3: __uint64, }} pub type PPEBS_DS_SAVE_AREA = *mut PEBS_DS_SAVE_AREA; -STRUCT!{struct PROCESSOR_PROFILE_CONTROL_AREA { +STRUCT! {struct PROCESSOR_PROFILE_CONTROL_AREA { PebsDsSaveArea: PEBS_DS_SAVE_AREA, }} pub type PPROCESSOR_PROFILE_CONTROL_AREA = *mut PROCESSOR_PROFILE_CONTROL_AREA; -STRUCT!{struct SYSTEM_PROCESSOR_PROFILE_CONTROL_AREA { +STRUCT! {struct SYSTEM_PROCESSOR_PROFILE_CONTROL_AREA { ProcessorProfileControlArea: PROCESSOR_PROFILE_CONTROL_AREA, - Allocate: BOOLEAN, + Allocate: c_uchar, }} -pub type PSYSTEM_PROCESSOR_PROFILE_CONTROL_AREA = *mut SYSTEM_PROCESSOR_PROFILE_CONTROL_AREA; -STRUCT!{struct MEMORY_COMBINE_INFORMATION { +pub type PSYSTEM_PROCESSOR_PROFILE_CONTROL_AREA = + *mut SYSTEM_PROCESSOR_PROFILE_CONTROL_AREA; +STRUCT! {struct MEMORY_COMBINE_INFORMATION { Handle: HANDLE, - PagesCombined: ULONG_PTR, + PagesCombined: usize, }} pub type PMEMORY_COMBINE_INFORMATION = *mut MEMORY_COMBINE_INFORMATION; -pub const MEMORY_COMBINE_FLAGS_COMMON_PAGES_ONLY: ULONG = 0x4; -STRUCT!{struct MEMORY_COMBINE_INFORMATION_EX { +pub const MEMORY_COMBINE_FLAGS_COMMON_PAGES_ONLY: c_ulong = 0x4; +STRUCT! {struct MEMORY_COMBINE_INFORMATION_EX { Handle: HANDLE, - PagesCombined: ULONG_PTR, - Flags: ULONG, + PagesCombined: usize, + Flags: c_ulong, }} pub type PMEMORY_COMBINE_INFORMATION_EX = *mut MEMORY_COMBINE_INFORMATION_EX; -STRUCT!{struct MEMORY_COMBINE_INFORMATION_EX2 { +STRUCT! {struct MEMORY_COMBINE_INFORMATION_EX2 { Handle: HANDLE, - PagesCombined: ULONG_PTR, - Flags: ULONG, + PagesCombined: usize, + Flags: c_ulong, ProcessHandle: HANDLE, }} pub type PMEMORY_COMBINE_INFORMATION_EX2 = *mut MEMORY_COMBINE_INFORMATION_EX2; -STRUCT!{struct SYSTEM_CONSOLE_INFORMATION { - Bitfields: ULONG, +STRUCT! {struct SYSTEM_CONSOLE_INFORMATION { + Bitfields: c_ulong, }} -BITFIELD!{SYSTEM_CONSOLE_INFORMATION Bitfields: ULONG [ +BITFIELD! {SYSTEM_CONSOLE_INFORMATION Bitfields: c_ulong [ DriverLoaded set_DriverLoaded[0..1], Spare set_Spare[1..32], ]} pub type PSYSTEM_CONSOLE_INFORMATION = *mut SYSTEM_CONSOLE_INFORMATION; -STRUCT!{struct SYSTEM_PLATFORM_BINARY_INFORMATION { - PhysicalAddress: ULONG64, - HandoffBuffer: PVOID, - CommandLineBuffer: PVOID, - HandoffBufferSize: ULONG, - CommandLineBufferSize: ULONG, -}} -pub type PSYSTEM_PLATFORM_BINARY_INFORMATION = *mut SYSTEM_PLATFORM_BINARY_INFORMATION; -STRUCT!{struct SYSTEM_HYPERVISOR_PROCESSOR_COUNT_INFORMATION { - NumberOfLogicalProcessors: ULONG, - NumberOfCores: ULONG, +STRUCT! {struct SYSTEM_PLATFORM_BINARY_INFORMATION { + PhysicalAddress: __uint64, + HandoffBuffer: *mut c_void, + CommandLineBuffer: *mut c_void, + HandoffBufferSize: c_ulong, + CommandLineBufferSize: c_ulong, +}} +pub type PSYSTEM_PLATFORM_BINARY_INFORMATION = + *mut SYSTEM_PLATFORM_BINARY_INFORMATION; +STRUCT! {struct SYSTEM_HYPERVISOR_PROCESSOR_COUNT_INFORMATION { + NumberOfLogicalProcessors: c_ulong, + NumberOfCores: c_ulong, }} pub type PSYSTEM_HYPERVISOR_PROCESSOR_COUNT_INFORMATION = *mut SYSTEM_HYPERVISOR_PROCESSOR_COUNT_INFORMATION; -STRUCT!{struct SYSTEM_DEVICE_DATA_INFORMATION { +STRUCT! {struct SYSTEM_DEVICE_DATA_INFORMATION { DeviceId: UNICODE_STRING, DataName: UNICODE_STRING, - DataType: ULONG, - DataBufferLength: ULONG, - DataBuffer: PVOID, + DataType: c_ulong, + DataBufferLength: c_ulong, + DataBuffer: *mut c_void, }} pub type PSYSTEM_DEVICE_DATA_INFORMATION = *mut SYSTEM_DEVICE_DATA_INFORMATION; -STRUCT!{struct PHYSICAL_CHANNEL_RUN { - NodeNumber: ULONG, - ChannelNumber: ULONG, - BasePage: ULONGLONG, - PageCount: ULONGLONG, - Flags: ULONG, +STRUCT! {struct PHYSICAL_CHANNEL_RUN { + NodeNumber: c_ulong, + ChannelNumber: c_ulong, + BasePage: __uint64, + PageCount: __uint64, + Flags: c_ulong, }} pub type PPHYSICAL_CHANNEL_RUN = *mut PHYSICAL_CHANNEL_RUN; -STRUCT!{struct SYSTEM_MEMORY_TOPOLOGY_INFORMATION { - NumberOfRuns: ULONGLONG, - NumberOfNodes: ULONG, - NumberOfChannels: ULONG, +STRUCT! {struct SYSTEM_MEMORY_TOPOLOGY_INFORMATION { + NumberOfRuns: __uint64, + NumberOfNodes: c_ulong, + NumberOfChannels: c_ulong, Run: [PHYSICAL_CHANNEL_RUN; 1], }} -pub type PSYSTEM_MEMORY_TOPOLOGY_INFORMATION = *mut SYSTEM_MEMORY_TOPOLOGY_INFORMATION; -STRUCT!{struct SYSTEM_MEMORY_CHANNEL_INFORMATION { - ChannelNumber: ULONG, - ChannelHeatIndex: ULONG, - TotalPageCount: ULONGLONG, - ZeroPageCount: ULONGLONG, - FreePageCount: ULONGLONG, - StandbyPageCount: ULONGLONG, -}} -pub type PSYSTEM_MEMORY_CHANNEL_INFORMATION = *mut SYSTEM_MEMORY_CHANNEL_INFORMATION; -STRUCT!{struct SYSTEM_BOOT_LOGO_INFORMATION { - Flags: ULONG, - BitmapOffset: ULONG, +pub type PSYSTEM_MEMORY_TOPOLOGY_INFORMATION = + *mut SYSTEM_MEMORY_TOPOLOGY_INFORMATION; +STRUCT! {struct SYSTEM_MEMORY_CHANNEL_INFORMATION { + ChannelNumber: c_ulong, + ChannelHeatIndex: c_ulong, + TotalPageCount: __uint64, + ZeroPageCount: __uint64, + FreePageCount: __uint64, + StandbyPageCount: __uint64, +}} +pub type PSYSTEM_MEMORY_CHANNEL_INFORMATION = + *mut SYSTEM_MEMORY_CHANNEL_INFORMATION; +STRUCT! {struct SYSTEM_BOOT_LOGO_INFORMATION { + Flags: c_ulong, + BitmapOffset: c_ulong, }} pub type PSYSTEM_BOOT_LOGO_INFORMATION = *mut SYSTEM_BOOT_LOGO_INFORMATION; -STRUCT!{struct SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION_EX { +STRUCT! {struct SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION_EX { IdleTime: LARGE_INTEGER, KernelTime: LARGE_INTEGER, UserTime: LARGE_INTEGER, DpcTime: LARGE_INTEGER, InterruptTime: LARGE_INTEGER, - InterruptCount: ULONG, - Spare0: ULONG, + InterruptCount: c_ulong, + Spare0: c_ulong, AvailableTime: LARGE_INTEGER, Spare1: LARGE_INTEGER, Spare2: LARGE_INTEGER, }} pub type PSYSTEM_PROCESSOR_PERFORMANCE_INFORMATION_EX = *mut SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION_EX; -STRUCT!{struct SYSTEM_SECUREBOOT_POLICY_INFORMATION { +STRUCT! {struct SYSTEM_SECUREBOOT_POLICY_INFORMATION { PolicyPublisher: GUID, - PolicyVersion: ULONG, - PolicyOptions: ULONG, + PolicyVersion: c_ulong, + PolicyOptions: c_ulong, }} -pub type PSYSTEM_SECUREBOOT_POLICY_INFORMATION = *mut SYSTEM_SECUREBOOT_POLICY_INFORMATION; -STRUCT!{struct SYSTEM_PAGEFILE_INFORMATION_EX { +pub type PSYSTEM_SECUREBOOT_POLICY_INFORMATION = + *mut SYSTEM_SECUREBOOT_POLICY_INFORMATION; +STRUCT! {struct SYSTEM_PAGEFILE_INFORMATION_EX { Info: SYSTEM_PAGEFILE_INFORMATION, - MinimumSize: ULONG, - MaximumSize: ULONG, + MinimumSize: c_ulong, + MaximumSize: c_ulong, }} pub type PSYSTEM_PAGEFILE_INFORMATION_EX = *mut SYSTEM_PAGEFILE_INFORMATION_EX; -STRUCT!{struct SYSTEM_SECUREBOOT_INFORMATION { - SecureBootEnabled: BOOLEAN, - SecureBootCapable: BOOLEAN, +STRUCT! {struct SYSTEM_SECUREBOOT_INFORMATION { + SecureBootEnabled: c_uchar, + SecureBootCapable: c_uchar, }} pub type PSYSTEM_SECUREBOOT_INFORMATION = *mut SYSTEM_SECUREBOOT_INFORMATION; -STRUCT!{struct PROCESS_DISK_COUNTERS { - BytesRead: ULONGLONG, - BytesWritten: ULONGLONG, - ReadOperationCount: ULONGLONG, - WriteOperationCount: ULONGLONG, - FlushOperationCount: ULONGLONG, +STRUCT! {struct PROCESS_DISK_COUNTERS { + BytesRead: __uint64, + BytesWritten: __uint64, + ReadOperationCount: __uint64, + WriteOperationCount: __uint64, + FlushOperationCount: __uint64, }} pub type PPROCESS_DISK_COUNTERS = *mut PROCESS_DISK_COUNTERS; -UNION!{union ENERGY_STATE_DURATION_u { - Value: ULONGLONG, - LastChangeTime: ULONG, +UNION! {union ENERGY_STATE_DURATION_u { + Value: __uint64, + LastChangeTime: c_ulong, }} -UNION!{union ENERGY_STATE_DURATION { +UNION! {union ENERGY_STATE_DURATION { u: ENERGY_STATE_DURATION_u, - BitFields: ULONG, + BitFields: c_ulong, }} pub type PENERGY_STATE_DURATION = *mut ENERGY_STATE_DURATION; -BITFIELD!{unsafe ENERGY_STATE_DURATION BitFields: ULONG [ +BITFIELD! {unsafe ENERGY_STATE_DURATION BitFields: c_ulong [ Duration set_Duration[0..31], IsInState set_IsInState[31..32], ]} -STRUCT!{struct PROCESS_ENERGY_VALUES { - Cycles: [[ULONGLONG; 4]; 2], - DiskEnergy: ULONGLONG, - NetworkTailEnergy: ULONGLONG, - MBBTailEnergy: ULONGLONG, - NetworkTxRxBytes: ULONGLONG, - MBBTxRxBytes: ULONGLONG, +STRUCT! {struct PROCESS_ENERGY_VALUES { + Cycles: [[__uint64; 4]; 2], + DiskEnergy: __uint64, + NetworkTailEnergy: __uint64, + MBBTailEnergy: __uint64, + NetworkTxRxBytes: __uint64, + MBBTxRxBytes: __uint64, ForegroundDuration: ENERGY_STATE_DURATION, DesktopVisibleDuration: ENERGY_STATE_DURATION, PSMForegroundDuration: ENERGY_STATE_DURATION, - CompositionRendered: ULONG, - CompositionDirtyGenerated: ULONG, - CompositionDirtyPropagated: ULONG, - Reserved1: ULONG, - AttributedCycles: [[ULONGLONG; 2]; 4], - WorkOnBehalfCycles: [[ULONGLONG; 2]; 4], + CompositionRendered: c_ulong, + CompositionDirtyGenerated: c_ulong, + CompositionDirtyPropagated: c_ulong, + Reserved1: c_ulong, + AttributedCycles: [[__uint64; 2]; 4], + WorkOnBehalfCycles: [[__uint64; 2]; 4], }} pub type PPROCESS_ENERGY_VALUES = *mut PROCESS_ENERGY_VALUES; -STRUCT!{struct TIMELINE_BITMAP { - Value: ULONGLONG, - EndTime: ULONG, - Bitmap: ULONG, +STRUCT! {struct TIMELINE_BITMAP { + Value: __uint64, + EndTime: c_ulong, + Bitmap: c_ulong, }} pub type PTIMELINE_BITMAP = *mut TIMELINE_BITMAP; -STRUCT!{struct PROCESS_ENERGY_VALUES_EXTENSION_Timelines { +STRUCT! {struct PROCESS_ENERGY_VALUES_EXTENSION_Timelines { CpuTimeline: TIMELINE_BITMAP, DiskTimeline: TIMELINE_BITMAP, NetworkTimeline: TIMELINE_BITMAP, @@ -2135,26 +2205,27 @@ STRUCT!{struct PROCESS_ENERGY_VALUES_EXTENSION_Timelines { DisplayRequiredTimeline: TIMELINE_BITMAP, KeyboardInputTimeline: TIMELINE_BITMAP, }} -STRUCT!{struct PROCESS_ENERGY_VALUES_EXTENSION_Durations { +STRUCT! {struct PROCESS_ENERGY_VALUES_EXTENSION_Durations { InputDuration: ENERGY_STATE_DURATION, AudioInDuration: ENERGY_STATE_DURATION, AudioOutDuration: ENERGY_STATE_DURATION, DisplayRequiredDuration: ENERGY_STATE_DURATION, PSMBackgroundDuration: ENERGY_STATE_DURATION, }} -STRUCT!{struct PROCESS_ENERGY_VALUES_EXTENSION { +STRUCT! {struct PROCESS_ENERGY_VALUES_EXTENSION { Timelines: PROCESS_ENERGY_VALUES_EXTENSION_Timelines, Durations: PROCESS_ENERGY_VALUES_EXTENSION_Durations, - KeyboardInput: ULONG, - MouseInput: ULONG, + KeyboardInput: c_ulong, + MouseInput: c_ulong, }} -pub type PPROCESS_ENERGY_VALUES_EXTENSION = *mut PROCESS_ENERGY_VALUES_EXTENSION; -STRUCT!{struct PROCESS_EXTENDED_ENERGY_VALUES { +pub type PPROCESS_ENERGY_VALUES_EXTENSION = + *mut PROCESS_ENERGY_VALUES_EXTENSION; +STRUCT! {struct PROCESS_EXTENDED_ENERGY_VALUES { Base: PROCESS_ENERGY_VALUES, Extension: PROCESS_ENERGY_VALUES_EXTENSION, }} pub type PPROCESS_EXTENDED_ENERGY_VALUES = *mut PROCESS_EXTENDED_ENERGY_VALUES; -ENUM!{enum SYSTEM_PROCESS_CLASSIFICATION { +ENUM! {enum SYSTEM_PROCESS_CLASSIFICATION { SystemProcessClassificationNormal = 0, SystemProcessClassificationSystem = 1, SystemProcessClassificationSecureSystem = 2, @@ -2162,61 +2233,66 @@ ENUM!{enum SYSTEM_PROCESS_CLASSIFICATION { SystemProcessClassificationRegistry = 4, SystemProcessClassificationMaximum = 5, }} -STRUCT!{struct SYSTEM_PROCESS_INFORMATION_EXTENSION { +STRUCT! {struct SYSTEM_PROCESS_INFORMATION_EXTENSION { DiskCounters: PROCESS_DISK_COUNTERS, - ContextSwitches: ULONGLONG, - Flags: ULONG, - UserSidOffset: ULONG, - PackageFullNameOffset: ULONG, + ContextSwitches: __uint64, + Flags: c_ulong, + UserSidOffset: c_ulong, + PackageFullNameOffset: c_ulong, EnergyValues: PROCESS_ENERGY_VALUES, - AppIdOffset: ULONG, - SharedCommitCharge: SIZE_T, - JobObjectId: ULONG, - SpareUlong: ULONG, - ProcessSequenceNumber: ULONGLONG, + AppIdOffset: c_ulong, + SharedCommitCharge: usize, + JobObjectId: c_ulong, + SpareUlong: c_ulong, + ProcessSequenceNumber: __uint64, }} -BITFIELD!{SYSTEM_PROCESS_INFORMATION_EXTENSION Flags: ULONG [ +BITFIELD! {SYSTEM_PROCESS_INFORMATION_EXTENSION Flags: c_ulong [ HasStrongId set_HasStrongId[0..1], Classification set_Classification[1..5], BackgroundActivityModerated set_BackgroundActivityModerated[5..6], Spare set_Spare[6..32], ]} -pub type PSYSTEM_PROCESS_INFORMATION_EXTENSION = *mut SYSTEM_PROCESS_INFORMATION_EXTENSION; -STRUCT!{struct SYSTEM_PORTABLE_WORKSPACE_EFI_LAUNCHER_INFORMATION { - EfiLauncherEnabled: BOOLEAN, +pub type PSYSTEM_PROCESS_INFORMATION_EXTENSION = + *mut SYSTEM_PROCESS_INFORMATION_EXTENSION; +STRUCT! {struct SYSTEM_PORTABLE_WORKSPACE_EFI_LAUNCHER_INFORMATION { + EfiLauncherEnabled: c_uchar, }} pub type PSYSTEM_PORTABLE_WORKSPACE_EFI_LAUNCHER_INFORMATION = *mut SYSTEM_PORTABLE_WORKSPACE_EFI_LAUNCHER_INFORMATION; -STRUCT!{struct SYSTEM_KERNEL_DEBUGGER_INFORMATION_EX { - DebuggerAllowed: BOOLEAN, - DebuggerEnabled: BOOLEAN, - DebuggerPresent: BOOLEAN, -}} -pub type PSYSTEM_KERNEL_DEBUGGER_INFORMATION_EX = *mut SYSTEM_KERNEL_DEBUGGER_INFORMATION_EX; -STRUCT!{struct SYSTEM_ELAM_CERTIFICATE_INFORMATION { +STRUCT! {struct SYSTEM_KERNEL_DEBUGGER_INFORMATION_EX { + DebuggerAllowed: c_uchar, + DebuggerEnabled: c_uchar, + DebuggerPresent: c_uchar, +}} +pub type PSYSTEM_KERNEL_DEBUGGER_INFORMATION_EX = + *mut SYSTEM_KERNEL_DEBUGGER_INFORMATION_EX; +STRUCT! {struct SYSTEM_ELAM_CERTIFICATE_INFORMATION { ElamDriverFile: HANDLE, }} -pub type PSYSTEM_ELAM_CERTIFICATE_INFORMATION = *mut SYSTEM_ELAM_CERTIFICATE_INFORMATION; -STRUCT!{struct SYSTEM_PROCESSOR_FEATURES_INFORMATION { - ProcessorFeatureBits: ULONGLONG, - Reserved: [ULONGLONG; 3], +pub type PSYSTEM_ELAM_CERTIFICATE_INFORMATION = + *mut SYSTEM_ELAM_CERTIFICATE_INFORMATION; +STRUCT! {struct SYSTEM_PROCESSOR_FEATURES_INFORMATION { + ProcessorFeatureBits: __uint64, + Reserved: [__uint64; 3], }} -pub type PSYSTEM_PROCESSOR_FEATURES_INFORMATION = *mut SYSTEM_PROCESSOR_FEATURES_INFORMATION; -STRUCT!{struct SYSTEM_MANUFACTURING_INFORMATION { - Options: ULONG, +pub type PSYSTEM_PROCESSOR_FEATURES_INFORMATION = + *mut SYSTEM_PROCESSOR_FEATURES_INFORMATION; +STRUCT! {struct SYSTEM_MANUFACTURING_INFORMATION { + Options: c_ulong, ProfileName: UNICODE_STRING, }} -pub type PSYSTEM_MANUFACTURING_INFORMATION = *mut SYSTEM_MANUFACTURING_INFORMATION; -STRUCT!{struct SYSTEM_ENERGY_ESTIMATION_CONFIG_INFORMATION { - Enabled: BOOLEAN, +pub type PSYSTEM_MANUFACTURING_INFORMATION = + *mut SYSTEM_MANUFACTURING_INFORMATION; +STRUCT! {struct SYSTEM_ENERGY_ESTIMATION_CONFIG_INFORMATION { + Enabled: c_uchar, }} pub type PSYSTEM_ENERGY_ESTIMATION_CONFIG_INFORMATION = *mut SYSTEM_ENERGY_ESTIMATION_CONFIG_INFORMATION; -STRUCT!{struct HV_DETAILS { - Data: [ULONG; 4], +STRUCT! {struct HV_DETAILS { + Data: [c_ulong; 4], }} pub type PHV_DETAILS = *mut HV_DETAILS; -STRUCT!{struct SYSTEM_HYPERVISOR_DETAIL_INFORMATION { +STRUCT! {struct SYSTEM_HYPERVISOR_DETAIL_INFORMATION { HvVendorAndMaxFunction: HV_DETAILS, HypervisorInterface: HV_DETAILS, HypervisorVersion: HV_DETAILS, @@ -2225,35 +2301,39 @@ STRUCT!{struct SYSTEM_HYPERVISOR_DETAIL_INFORMATION { EnlightenmentInfo: HV_DETAILS, ImplementationLimits: HV_DETAILS, }} -pub type PSYSTEM_HYPERVISOR_DETAIL_INFORMATION = *mut SYSTEM_HYPERVISOR_DETAIL_INFORMATION; -STRUCT!{struct SYSTEM_PROCESSOR_CYCLE_STATS_INFORMATION { - Cycles: [[ULONGLONG; 4]; 2], +pub type PSYSTEM_HYPERVISOR_DETAIL_INFORMATION = + *mut SYSTEM_HYPERVISOR_DETAIL_INFORMATION; +STRUCT! {struct SYSTEM_PROCESSOR_CYCLE_STATS_INFORMATION { + Cycles: [[__uint64; 4]; 2], }} -pub type PSYSTEM_PROCESSOR_CYCLE_STATS_INFORMATION = *mut SYSTEM_PROCESSOR_CYCLE_STATS_INFORMATION; -STRUCT!{struct SYSTEM_TPM_INFORMATION { - Flags: ULONG, +pub type PSYSTEM_PROCESSOR_CYCLE_STATS_INFORMATION = + *mut SYSTEM_PROCESSOR_CYCLE_STATS_INFORMATION; +STRUCT! {struct SYSTEM_TPM_INFORMATION { + Flags: c_ulong, }} pub type PSYSTEM_TPM_INFORMATION = *mut SYSTEM_TPM_INFORMATION; -STRUCT!{struct SYSTEM_VSM_PROTECTION_INFORMATION { - DmaProtectionsAvailable: BOOLEAN, - DmaProtectionsInUse: BOOLEAN, - HardwareMbecAvailable: BOOLEAN, -}} -pub type PSYSTEM_VSM_PROTECTION_INFORMATION = *mut SYSTEM_VSM_PROTECTION_INFORMATION; -STRUCT!{struct SYSTEM_CODEINTEGRITYPOLICY_INFORMATION { - Options: ULONG, - HVCIOptions: ULONG, - Version: ULONGLONG, +STRUCT! {struct SYSTEM_VSM_PROTECTION_INFORMATION { + DmaProtectionsAvailable: c_uchar, + DmaProtectionsInUse: c_uchar, + HardwareMbecAvailable: c_uchar, +}} +pub type PSYSTEM_VSM_PROTECTION_INFORMATION = + *mut SYSTEM_VSM_PROTECTION_INFORMATION; +STRUCT! {struct SYSTEM_CODEINTEGRITYPOLICY_INFORMATION { + Options: c_ulong, + HVCIOptions: c_ulong, + Version: __uint64, PolicyGuid: GUID, }} -pub type PSYSTEM_CODEINTEGRITYPOLICY_INFORMATION = *mut SYSTEM_CODEINTEGRITYPOLICY_INFORMATION; -STRUCT!{struct SYSTEM_ISOLATED_USER_MODE_INFORMATION { - Bitfields1: BOOLEAN, - Bitfields2: BOOLEAN, - Spare0: [BOOLEAN; 6], - Spare1: ULONGLONG, +pub type PSYSTEM_CODEINTEGRITYPOLICY_INFORMATION = + *mut SYSTEM_CODEINTEGRITYPOLICY_INFORMATION; +STRUCT! {struct SYSTEM_ISOLATED_USER_MODE_INFORMATION { + Bitfields1: c_uchar, + Bitfields2: c_uchar, + Spare0: [c_uchar; 6], + Spare1: __uint64, }} -BITFIELD!{SYSTEM_ISOLATED_USER_MODE_INFORMATION Bitfields1: BOOLEAN [ +BITFIELD! {SYSTEM_ISOLATED_USER_MODE_INFORMATION Bitfields1: c_uchar [ SecureKernelRunning set_SecureKernelRunning[0..1], HvciEnabled set_HvciEnabled[1..2], HvciStrictMode set_HvciStrictMode[2..3], @@ -2263,143 +2343,152 @@ BITFIELD!{SYSTEM_ISOLATED_USER_MODE_INFORMATION Bitfields1: BOOLEAN [ SpareFlags set_SpareFlags[6..7], TrustletRunning set_TrustletRunning[7..8], ]} -BITFIELD!{SYSTEM_ISOLATED_USER_MODE_INFORMATION Bitfields2: BOOLEAN [ +BITFIELD! {SYSTEM_ISOLATED_USER_MODE_INFORMATION Bitfields2: c_uchar [ SpareFlags2 set_SpareFlags2[0..1], ]} -pub type PSYSTEM_ISOLATED_USER_MODE_INFORMATION = *mut SYSTEM_ISOLATED_USER_MODE_INFORMATION; -STRUCT!{struct SYSTEM_SINGLE_MODULE_INFORMATION { - TargetModuleAddress: PVOID, +pub type PSYSTEM_ISOLATED_USER_MODE_INFORMATION = + *mut SYSTEM_ISOLATED_USER_MODE_INFORMATION; +STRUCT! {struct SYSTEM_SINGLE_MODULE_INFORMATION { + TargetModuleAddress: *mut c_void, ExInfo: RTL_PROCESS_MODULE_INFORMATION_EX, }} -pub type PSYSTEM_SINGLE_MODULE_INFORMATION = *mut SYSTEM_SINGLE_MODULE_INFORMATION; -STRUCT!{struct SYSTEM_INTERRUPT_CPU_SET_INFORMATION { - Gsiv: ULONG, - Group: USHORT, - CpuSets: ULONGLONG, +pub type PSYSTEM_SINGLE_MODULE_INFORMATION = + *mut SYSTEM_SINGLE_MODULE_INFORMATION; +STRUCT! {struct SYSTEM_INTERRUPT_CPU_SET_INFORMATION { + Gsiv: c_ulong, + Group: c_ushort, + CpuSets: __uint64, }} -pub type PSYSTEM_INTERRUPT_CPU_SET_INFORMATION = *mut SYSTEM_INTERRUPT_CPU_SET_INFORMATION; -STRUCT!{struct SYSTEM_SECUREBOOT_POLICY_FULL_INFORMATION { +pub type PSYSTEM_INTERRUPT_CPU_SET_INFORMATION = + *mut SYSTEM_INTERRUPT_CPU_SET_INFORMATION; +STRUCT! {struct SYSTEM_SECUREBOOT_POLICY_FULL_INFORMATION { PolicyInformation: SYSTEM_SECUREBOOT_POLICY_INFORMATION, - PolicySize: ULONG, - Policy: [UCHAR; 1], + PolicySize: c_ulong, + Policy: [c_uchar; 1], }} pub type PSYSTEM_SECUREBOOT_POLICY_FULL_INFORMATION = *mut SYSTEM_SECUREBOOT_POLICY_FULL_INFORMATION; -STRUCT!{struct SYSTEM_ROOT_SILO_INFORMATION { - NumberOfSilos: ULONG, - SiloIdList: [ULONG; 1], +STRUCT! {struct SYSTEM_ROOT_SILO_INFORMATION { + NumberOfSilos: c_ulong, + SiloIdList: [c_ulong; 1], }} pub type PSYSTEM_ROOT_SILO_INFORMATION = *mut SYSTEM_ROOT_SILO_INFORMATION; -STRUCT!{struct SYSTEM_CPU_SET_TAG_INFORMATION { - Tag: ULONGLONG, - CpuSets: [ULONGLONG; 1], +STRUCT! {struct SYSTEM_CPU_SET_TAG_INFORMATION { + Tag: __uint64, + CpuSets: [__uint64; 1], }} pub type PSYSTEM_CPU_SET_TAG_INFORMATION = *mut SYSTEM_CPU_SET_TAG_INFORMATION; -STRUCT!{struct SYSTEM_SECURE_KERNEL_HYPERGUARD_PROFILE_INFORMATION { - ExtentCount: ULONG, - ValidStructureSize: ULONG, - NextExtentIndex: ULONG, - ExtentRestart: ULONG, - CycleCount: ULONG, - TimeoutCount: ULONG, - CycleTime: ULONGLONG, - CycleTimeMax: ULONGLONG, - ExtentTime: ULONGLONG, - ExtentTimeIndex: ULONG, - ExtentTimeMaxIndex: ULONG, - ExtentTimeMax: ULONGLONG, - HyperFlushTimeMax: ULONGLONG, - TranslateVaTimeMax: ULONGLONG, - DebugExemptionCount: ULONGLONG, - TbHitCount: ULONGLONG, - TbMissCount: ULONGLONG, - VinaPendingYield: ULONGLONG, - HashCycles: ULONGLONG, - HistogramOffset: ULONG, - HistogramBuckets: ULONG, - HistogramShift: ULONG, - Reserved1: ULONG, - PageNotPresentCount: ULONGLONG, +STRUCT! {struct SYSTEM_SECURE_KERNEL_HYPERGUARD_PROFILE_INFORMATION { + ExtentCount: c_ulong, + ValidStructureSize: c_ulong, + NextExtentIndex: c_ulong, + ExtentRestart: c_ulong, + CycleCount: c_ulong, + TimeoutCount: c_ulong, + CycleTime: __uint64, + CycleTimeMax: __uint64, + ExtentTime: __uint64, + ExtentTimeIndex: c_ulong, + ExtentTimeMaxIndex: c_ulong, + ExtentTimeMax: __uint64, + HyperFlushTimeMax: __uint64, + TranslateVaTimeMax: __uint64, + DebugExemptionCount: __uint64, + TbHitCount: __uint64, + TbMissCount: __uint64, + VinaPendingYield: __uint64, + HashCycles: __uint64, + HistogramOffset: c_ulong, + HistogramBuckets: c_ulong, + HistogramShift: c_ulong, + Reserved1: c_ulong, + PageNotPresentCount: __uint64, }} pub type PSYSTEM_SECURE_KERNEL_HYPERGUARD_PROFILE_INFORMATION = *mut SYSTEM_SECURE_KERNEL_HYPERGUARD_PROFILE_INFORMATION; -STRUCT!{struct SYSTEM_SECUREBOOT_PLATFORM_MANIFEST_INFORMATION { - PlatformManifestSize: ULONG, - PlatformManifest: [UCHAR; 1], +STRUCT! {struct SYSTEM_SECUREBOOT_PLATFORM_MANIFEST_INFORMATION { + PlatformManifestSize: c_ulong, + PlatformManifest: [c_uchar; 1], }} pub type PSYSTEM_SECUREBOOT_PLATFORM_MANIFEST_INFORMATION = *mut SYSTEM_SECUREBOOT_PLATFORM_MANIFEST_INFORMATION; -STRUCT!{struct SYSTEM_MEMORY_USAGE_INFORMATION { - TotalPhysicalBytes: ULONGLONG, - AvailableBytes: ULONGLONG, - ResidentAvailableBytes: LONGLONG, - CommittedBytes: ULONGLONG, - SharedCommittedBytes: ULONGLONG, - CommitLimitBytes: ULONGLONG, - PeakCommitmentBytes: ULONGLONG, -}} -pub type PSYSTEM_MEMORY_USAGE_INFORMATION = *mut SYSTEM_MEMORY_USAGE_INFORMATION; -STRUCT!{struct SYSTEM_CODEINTEGRITY_CERTIFICATE_INFORMATION { +STRUCT! {struct SYSTEM_MEMORY_USAGE_INFORMATION { + TotalPhysicalBytes: __uint64, + AvailableBytes: __uint64, + ResidentAvailableBytes: __int64, + CommittedBytes: __uint64, + SharedCommittedBytes: __uint64, + CommitLimitBytes: __uint64, + PeakCommitmentBytes: __uint64, +}} +pub type PSYSTEM_MEMORY_USAGE_INFORMATION = + *mut SYSTEM_MEMORY_USAGE_INFORMATION; +STRUCT! {struct SYSTEM_CODEINTEGRITY_CERTIFICATE_INFORMATION { ImageFile: HANDLE, - Type: ULONG, + Type: c_ulong, }} pub type PSYSTEM_CODEINTEGRITY_CERTIFICATE_INFORMATION = *mut SYSTEM_CODEINTEGRITY_CERTIFICATE_INFORMATION; -STRUCT!{struct SYSTEM_PHYSICAL_MEMORY_INFORMATION { - TotalPhysicalBytes: ULONGLONG, - LowestPhysicalAddress: ULONGLONG, - HighestPhysicalAddress: ULONGLONG, -}} -pub type PSYSTEM_PHYSICAL_MEMORY_INFORMATION = *mut SYSTEM_PHYSICAL_MEMORY_INFORMATION; -ENUM!{enum SYSTEM_ACTIVITY_MODERATION_STATE { +STRUCT! {struct SYSTEM_PHYSICAL_MEMORY_INFORMATION { + TotalPhysicalBytes: __uint64, + LowestPhysicalAddress: __uint64, + HighestPhysicalAddress: __uint64, +}} +pub type PSYSTEM_PHYSICAL_MEMORY_INFORMATION = + *mut SYSTEM_PHYSICAL_MEMORY_INFORMATION; +ENUM! {enum SYSTEM_ACTIVITY_MODERATION_STATE { SystemActivityModerationStateSystemManaged = 0, SystemActivityModerationStateUserManagedAllowThrottling = 1, SystemActivityModerationStateUserManagedDisableThrottling = 2, MaxSystemActivityModerationState = 3, }} -ENUM!{enum SYSTEM_ACTIVITY_MODERATION_APP_TYPE { +ENUM! {enum SYSTEM_ACTIVITY_MODERATION_APP_TYPE { SystemActivityModerationAppTypeClassic = 0, SystemActivityModerationAppTypePackaged = 1, MaxSystemActivityModerationAppType = 2, }} -STRUCT!{struct SYSTEM_ACTIVITY_MODERATION_INFO { +STRUCT! {struct SYSTEM_ACTIVITY_MODERATION_INFO { Identifier: UNICODE_STRING, ModerationState: SYSTEM_ACTIVITY_MODERATION_STATE, AppType: SYSTEM_ACTIVITY_MODERATION_APP_TYPE, }} -pub type PSYSTEM_ACTIVITY_MODERATION_INFO = *mut SYSTEM_ACTIVITY_MODERATION_INFO; -STRUCT!{struct SYSTEM_ACTIVITY_MODERATION_USER_SETTINGS { +pub type PSYSTEM_ACTIVITY_MODERATION_INFO = + *mut SYSTEM_ACTIVITY_MODERATION_INFO; +STRUCT! {struct SYSTEM_ACTIVITY_MODERATION_USER_SETTINGS { UserKeyHandle: HANDLE, }} -pub type PSYSTEM_ACTIVITY_MODERATION_USER_SETTINGS = *mut SYSTEM_ACTIVITY_MODERATION_USER_SETTINGS; -STRUCT!{struct SYSTEM_CODEINTEGRITY_UNLOCK_INFORMATION { - Flags: ULONG, - UnlockId: [UCHAR; 32], +pub type PSYSTEM_ACTIVITY_MODERATION_USER_SETTINGS = + *mut SYSTEM_ACTIVITY_MODERATION_USER_SETTINGS; +STRUCT! {struct SYSTEM_CODEINTEGRITY_UNLOCK_INFORMATION { + Flags: c_ulong, + UnlockId: [c_uchar; 32], }} -BITFIELD!{SYSTEM_CODEINTEGRITY_UNLOCK_INFORMATION Flags: ULONG [ +BITFIELD! {SYSTEM_CODEINTEGRITY_UNLOCK_INFORMATION Flags: c_ulong [ Locked set_Locked[0..1], Unlockable set_Unlockable[1..2], UnlockApplied set_UnlockApplied[2..3], UnlockIdValid set_UnlockIdValid[3..4], Reserved set_Reserved[4..32], ]} -pub type PSYSTEM_CODEINTEGRITY_UNLOCK_INFORMATION = *mut SYSTEM_CODEINTEGRITY_UNLOCK_INFORMATION; -STRUCT!{struct SYSTEM_FLUSH_INFORMATION { - SupportedFlushMethods: ULONG, - ProcessorCacheFlushSize: ULONG, - SystemFlushCapabilities: ULONGLONG, - Reserved: [ULONGLONG; 2], +pub type PSYSTEM_CODEINTEGRITY_UNLOCK_INFORMATION = + *mut SYSTEM_CODEINTEGRITY_UNLOCK_INFORMATION; +STRUCT! {struct SYSTEM_FLUSH_INFORMATION { + SupportedFlushMethods: c_ulong, + ProcessorCacheFlushSize: c_ulong, + SystemFlushCapabilities: __uint64, + Reserved: [__uint64; 2], }} pub type PSYSTEM_FLUSH_INFORMATION = *mut SYSTEM_FLUSH_INFORMATION; -STRUCT!{struct SYSTEM_WRITE_CONSTRAINT_INFORMATION { - WriteConstraintPolicy: ULONG, - Reserved: ULONG, +STRUCT! {struct SYSTEM_WRITE_CONSTRAINT_INFORMATION { + WriteConstraintPolicy: c_ulong, + Reserved: c_ulong, }} -pub type PSYSTEM_WRITE_CONSTRAINT_INFORMATION = *mut SYSTEM_WRITE_CONSTRAINT_INFORMATION; -STRUCT!{struct SYSTEM_KERNEL_VA_SHADOW_INFORMATION { - Flags: ULONG, +pub type PSYSTEM_WRITE_CONSTRAINT_INFORMATION = + *mut SYSTEM_WRITE_CONSTRAINT_INFORMATION; +STRUCT! {struct SYSTEM_KERNEL_VA_SHADOW_INFORMATION { + Flags: c_ulong, }} -BITFIELD!{SYSTEM_KERNEL_VA_SHADOW_INFORMATION Flags: ULONG [ +BITFIELD! {SYSTEM_KERNEL_VA_SHADOW_INFORMATION Flags: c_ulong [ KvaShadowEnabled set_KvaShadowEnabled[0..1], KvaShadowUserGlobal set_KvaShadowUserGlobal[1..2], KvaShadowPcid set_KvaShadowPcid[2..3], @@ -2411,23 +2500,24 @@ BITFIELD!{SYSTEM_KERNEL_VA_SHADOW_INFORMATION Flags: ULONG [ L1TerminalFaultMitigationPresent set_L1TerminalFaultMitigationPresent[13..14], Reserved set_Reserved[14..32], ]} -pub type PSYSTEM_KERNEL_VA_SHADOW_INFORMATION = *mut SYSTEM_KERNEL_VA_SHADOW_INFORMATION; -STRUCT!{struct SYSTEM_CODEINTEGRITYVERIFICATION_INFORMATION { +pub type PSYSTEM_KERNEL_VA_SHADOW_INFORMATION = + *mut SYSTEM_KERNEL_VA_SHADOW_INFORMATION; +STRUCT! {struct SYSTEM_CODEINTEGRITYVERIFICATION_INFORMATION { FileHandle: HANDLE, - ImageSize: ULONG, - Image: PVOID, + ImageSize: c_ulong, + Image: *mut c_void, }} pub type PSYSTEM_CODEINTEGRITYVERIFICATION_INFORMATION = *mut SYSTEM_CODEINTEGRITYVERIFICATION_INFORMATION; -STRUCT!{struct SYSTEM_HYPERVISOR_SHARED_PAGE_INFORMATION { - HypervisorSharedUserVa: PVOID, +STRUCT! {struct SYSTEM_HYPERVISOR_SHARED_PAGE_INFORMATION { + HypervisorSharedUserVa: *mut c_void, }} pub type PSYSTEM_HYPERVISOR_SHARED_PAGE_INFORMATION = *mut SYSTEM_HYPERVISOR_SHARED_PAGE_INFORMATION; -STRUCT!{struct SYSTEM_SPECULATION_CONTROL_INFORMATION { - Flags: ULONG, +STRUCT! {struct SYSTEM_SPECULATION_CONTROL_INFORMATION { + Flags: c_ulong, }} -BITFIELD!{SYSTEM_SPECULATION_CONTROL_INFORMATION Flags: ULONG [ +BITFIELD! {SYSTEM_SPECULATION_CONTROL_INFORMATION Flags: c_ulong [ BpbEnabled set_BpbEnabled[0..1], BpbDisabledSystemPolicy set_BpbDisabledSystemPolicy[1..2], BpbDisabledNoHardwareSupport set_BpbDisabledNoHardwareSupport[2..3], @@ -2446,44 +2536,46 @@ BITFIELD!{SYSTEM_SPECULATION_CONTROL_INFORMATION Flags: ULONG [ SpecCtrlImportOptimizationEnabled set_SpecCtrlImportOptimizationEnabled[15..16], Reserved set_Reserved[16..32], ]} -pub type PSYSTEM_SPECULATION_CONTROL_INFORMATION = *mut SYSTEM_SPECULATION_CONTROL_INFORMATION; -STRUCT!{struct SYSTEM_DMA_GUARD_POLICY_INFORMATION { - DmaGuardPolicyEnabled: BOOLEAN, +pub type PSYSTEM_SPECULATION_CONTROL_INFORMATION = + *mut SYSTEM_SPECULATION_CONTROL_INFORMATION; +STRUCT! {struct SYSTEM_DMA_GUARD_POLICY_INFORMATION { + DmaGuardPolicyEnabled: c_uchar, }} -pub type PSYSTEM_DMA_GUARD_POLICY_INFORMATION = *mut SYSTEM_DMA_GUARD_POLICY_INFORMATION; -STRUCT!{struct SYSTEM_ENCLAVE_LAUNCH_CONTROL_INFORMATION { - EnclaveLaunchSigner: [UCHAR; 32], +pub type PSYSTEM_DMA_GUARD_POLICY_INFORMATION = + *mut SYSTEM_DMA_GUARD_POLICY_INFORMATION; +STRUCT! {struct SYSTEM_ENCLAVE_LAUNCH_CONTROL_INFORMATION { + EnclaveLaunchSigner: [c_uchar; 32], }} pub type PSYSTEM_ENCLAVE_LAUNCH_CONTROL_INFORMATION = *mut SYSTEM_ENCLAVE_LAUNCH_CONTROL_INFORMATION; -STRUCT!{struct SYSTEM_WORKLOAD_ALLOWED_CPU_SET_INFORMATION { - WorkloadClass: ULONGLONG, - CpuSets: [ULONGLONG; 1], +STRUCT! {struct SYSTEM_WORKLOAD_ALLOWED_CPU_SET_INFORMATION { + WorkloadClass: __uint64, + CpuSets: [__uint64; 1], }} pub type PSYSTEM_WORKLOAD_ALLOWED_CPU_SET_INFORMATION = *mut SYSTEM_WORKLOAD_ALLOWED_CPU_SET_INFORMATION; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtQuerySystemInformation( SystemInformationClass: SYSTEM_INFORMATION_CLASS, - SystemInformation: PVOID, - SystemInformationLength: ULONG, - ReturnLength: PULONG, + SystemInformation: *mut c_void, + SystemInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn NtQuerySystemInformationEx( SystemInformationClass: SYSTEM_INFORMATION_CLASS, - InputBuffer: PVOID, - InputBufferLength: ULONG, - SystemInformation: PVOID, - SystemInformationLength: ULONG, - ReturnLength: PULONG, + InputBuffer: *mut c_void, + InputBufferLength: c_ulong, + SystemInformation: *mut c_void, + SystemInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn NtSetSystemInformation( SystemInformationClass: SYSTEM_INFORMATION_CLASS, - SystemInformation: PVOID, - SystemInformationLength: ULONG, + SystemInformation: *mut c_void, + SystemInformationLength: c_ulong, ) -> NTSTATUS; }} -ENUM!{enum SYSDBG_COMMAND { +ENUM! {enum SYSDBG_COMMAND { SysDbgQueryModuleInformation = 0, SysDbgQueryTraceInformation = 1, SysDbgSetTracepoint = 2, @@ -2524,64 +2616,64 @@ ENUM!{enum SYSDBG_COMMAND { SysDbgGetLiveKernelDump = 37, }} pub type PSYSDBG_COMMAND = *mut SYSDBG_COMMAND; -STRUCT!{struct SYSDBG_VIRTUAL { - Address: PVOID, - Buffer: PVOID, - Request: ULONG, +STRUCT! {struct SYSDBG_VIRTUAL { + Address: *mut c_void, + Buffer: *mut c_void, + Request: c_ulong, }} pub type PSYSDBG_VIRTUAL = *mut SYSDBG_VIRTUAL; -STRUCT!{struct SYSDBG_PHYSICAL { - Address: PHYSICAL_ADDRESS, - Buffer: PVOID, - Request: ULONG, +STRUCT! {struct SYSDBG_PHYSICAL { + Address: LARGE_INTEGER, + Buffer: *mut c_void, + Request: c_ulong, }} pub type PSYSDBG_PHYSICAL = *mut SYSDBG_PHYSICAL; -STRUCT!{struct SYSDBG_CONTROL_SPACE { - Address: ULONG64, - Buffer: PVOID, - Request: ULONG, - Processor: ULONG, +STRUCT! {struct SYSDBG_CONTROL_SPACE { + Address: __uint64, + Buffer: *mut c_void, + Request: c_ulong, + Processor: c_ulong, }} pub type PSYSDBG_CONTROL_SPACE = *mut SYSDBG_CONTROL_SPACE; -STRUCT!{struct SYSDBG_IO_SPACE { - Address: ULONG64, - Buffer: PVOID, - Request: ULONG, +STRUCT! {struct SYSDBG_IO_SPACE { + Address: __uint64, + Buffer: *mut c_void, + Request: c_ulong, InterfaceType: INTERFACE_TYPE, - BusNumber: ULONG, - AddressSpace: ULONG, + BusNumber: c_ulong, + AddressSpace: c_ulong, }} pub type PSYSDBG_IO_SPACE = *mut SYSDBG_IO_SPACE; -STRUCT!{struct SYSDBG_MSR { - Msr: ULONG, - Data: ULONG64, +STRUCT! {struct SYSDBG_MSR { + Msr: c_ulong, + Data: __uint64, }} pub type PSYSDBG_MSR = *mut SYSDBG_MSR; -STRUCT!{struct SYSDBG_BUS_DATA { - Address: ULONG, - Buffer: PVOID, - Request: ULONG, +STRUCT! {struct SYSDBG_BUS_DATA { + Address: c_ulong, + Buffer: *mut c_void, + Request: c_ulong, BusDataType: BUS_DATA_TYPE, - BusNumber: ULONG, - SlotNumber: ULONG, + BusNumber: c_ulong, + SlotNumber: c_ulong, }} pub type PSYSDBG_BUS_DATA = *mut SYSDBG_BUS_DATA; -STRUCT!{struct SYSDBG_TRIAGE_DUMP { - Flags: ULONG, - BugCheckCode: ULONG, - BugCheckParam1: ULONG_PTR, - BugCheckParam2: ULONG_PTR, - BugCheckParam3: ULONG_PTR, - BugCheckParam4: ULONG_PTR, - ProcessHandles: ULONG, - ThreadHandles: ULONG, - Handles: PHANDLE, +STRUCT! {struct SYSDBG_TRIAGE_DUMP { + Flags: c_ulong, + BugCheckCode: c_ulong, + BugCheckParam1: usize, + BugCheckParam2: usize, + BugCheckParam3: usize, + BugCheckParam4: usize, + ProcessHandles: c_ulong, + ThreadHandles: c_ulong, + Handles: *mut HANDLE, }} pub type PSYSDBG_TRIAGE_DUMP = *mut SYSDBG_TRIAGE_DUMP; -STRUCT!{struct SYSDBG_LIVEDUMP_CONTROL_FLAGS { - AsUlong: ULONG, +STRUCT! {struct SYSDBG_LIVEDUMP_CONTROL_FLAGS { + AsUlong: c_ulong, }} -BITFIELD!{SYSDBG_LIVEDUMP_CONTROL_FLAGS AsUlong: ULONG [ +BITFIELD! {SYSDBG_LIVEDUMP_CONTROL_FLAGS AsUlong: c_ulong [ UseDumpStorageStack set_UseDumpStorageStack[0..1], CompressMemoryPagesData set_CompressMemoryPagesData[1..2], IncludeUserSpaceMemoryPages set_IncludeUserSpaceMemoryPages[2..3], @@ -2589,39 +2681,40 @@ BITFIELD!{SYSDBG_LIVEDUMP_CONTROL_FLAGS AsUlong: ULONG [ Reserved set_Reserved[4..32], ]} pub type PSYSDBG_LIVEDUMP_CONTROL_FLAGS = *mut SYSDBG_LIVEDUMP_CONTROL_FLAGS; -STRUCT!{struct SYSDBG_LIVEDUMP_CONTROL_ADDPAGES { - AsUlong: ULONG, +STRUCT! {struct SYSDBG_LIVEDUMP_CONTROL_ADDPAGES { + AsUlong: c_ulong, }} -BITFIELD!{SYSDBG_LIVEDUMP_CONTROL_ADDPAGES AsUlong: ULONG [ +BITFIELD! {SYSDBG_LIVEDUMP_CONTROL_ADDPAGES AsUlong: c_ulong [ HypervisorPages set_HypervisorPages[0..1], Reserved set_Reserved[1..32], ]} -pub type PSYSDBG_LIVEDUMP_CONTROL_ADDPAGES = *mut SYSDBG_LIVEDUMP_CONTROL_ADDPAGES; -pub const SYSDBG_LIVEDUMP_CONTROL_VERSION: ULONG = 1; -STRUCT!{struct SYSDBG_LIVEDUMP_CONTROL { - Version: ULONG, - BugCheckCode: ULONG, - BugCheckParam1: ULONG_PTR, - BugCheckParam2: ULONG_PTR, - BugCheckParam3: ULONG_PTR, - BugCheckParam4: ULONG_PTR, +pub type PSYSDBG_LIVEDUMP_CONTROL_ADDPAGES = + *mut SYSDBG_LIVEDUMP_CONTROL_ADDPAGES; +pub const SYSDBG_LIVEDUMP_CONTROL_VERSION: c_ulong = 1; +STRUCT! {struct SYSDBG_LIVEDUMP_CONTROL { + Version: c_ulong, + BugCheckCode: c_ulong, + BugCheckParam1: usize, + BugCheckParam2: usize, + BugCheckParam3: usize, + BugCheckParam4: usize, DumpFileHandle: HANDLE, CancelEventHandle: HANDLE, Flags: SYSDBG_LIVEDUMP_CONTROL_FLAGS, AddPagesControl: SYSDBG_LIVEDUMP_CONTROL_ADDPAGES, }} pub type PSYSDBG_LIVEDUMP_CONTROL = *mut SYSDBG_LIVEDUMP_CONTROL; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtSystemDebugControl( Command: SYSDBG_COMMAND, - InputBuffer: PVOID, - InputBufferLength: ULONG, - OutputBuffer: PVOID, - OutputBufferLength: ULONG, - ReturnLength: PULONG, + InputBuffer: *mut c_void, + InputBufferLength: c_ulong, + OutputBuffer: *mut c_void, + OutputBufferLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; }} -ENUM!{enum HARDERROR_RESPONSE_OPTION { +ENUM! {enum HARDERROR_RESPONSE_OPTION { OptionAbortRetryIgnore = 0, OptionOk = 1, OptionOkCancel = 2, @@ -2632,7 +2725,7 @@ ENUM!{enum HARDERROR_RESPONSE_OPTION { OptionOkNoWait = 7, OptionCancelTryContinue = 8, }} -ENUM!{enum HARDERROR_RESPONSE { +ENUM! {enum HARDERROR_RESPONSE { ResponseReturnToCaller = 0, ResponseNotHandled = 1, ResponseAbort = 2, @@ -2645,18 +2738,18 @@ ENUM!{enum HARDERROR_RESPONSE { ResponseTryAgain = 9, ResponseContinue = 10, }} -pub const HARDERROR_OVERRIDE_ERRORMODE: ULONG = 0x10000000; -EXTERN!{extern "system" { +pub const HARDERROR_OVERRIDE_ERRORMODE: c_ulong = 0x10000000; +EXTERN! {extern "system" { fn NtRaiseHardError( ErrorStatus: NTSTATUS, - NumberOfParameters: ULONG, - UnicodeStringParameterMask: ULONG, - Parameters: PULONG_PTR, - ValidResponseOptions: ULONG, - Response: PULONG, + NumberOfParameters: c_ulong, + UnicodeStringParameterMask: c_ulong, + Parameters: *mut usize, + ValidResponseOptions: c_ulong, + Response: *mut c_ulong, ) -> NTSTATUS; }} -ENUM!{enum ALTERNATIVE_ARCHITECTURE_TYPE { +ENUM! {enum ALTERNATIVE_ARCHITECTURE_TYPE { StandardDesign = 0, NEC98x86 = 1, EndAlternatives = 2, @@ -2667,98 +2760,98 @@ pub const NX_SUPPORT_POLICY_ALWAYSOFF: u32 = 0; pub const NX_SUPPORT_POLICY_ALWAYSON: u32 = 1; pub const NX_SUPPORT_POLICY_OPTIN: u32 = 2; pub const NX_SUPPORT_POLICY_OPTOUT: u32 = 3; -UNION!{union KUSER_SHARED_DATA_u { +UNION! {union KUSER_SHARED_DATA_u { TickCount: KSYSTEM_TIME, - TickCountQuad: ULONG64, - ReservedTickCountOverlay: [ULONG; 3], + TickCountQuad: __uint64, + ReservedTickCountOverlay: [c_ulong; 3], }} -STRUCT!{#[repr(packed(4))] struct KUSER_SHARED_DATA { - TickCountLowDeprecated: ULONG, - TickCountMultiplier: ULONG, +STRUCT! {#[repr(packed(4))] struct KUSER_SHARED_DATA { + TickCountLowDeprecated: c_ulong, + TickCountMultiplier: c_ulong, InterruptTime: KSYSTEM_TIME, SystemTime: KSYSTEM_TIME, TimeZoneBias: KSYSTEM_TIME, - ImageNumberLow: USHORT, - ImageNumberHigh: USHORT, - NtSystemRoot: [WCHAR; 260], - MaxStackTraceDepth: ULONG, - CryptoExponent: ULONG, - TimeZoneId: ULONG, - LargePageMinimum: ULONG, - AitSamplingValue: ULONG, - AppCompatFlag: ULONG, - RNGSeedVersion: ULONGLONG, - GlobalValidationRunlevel: ULONG, - TimeZoneBiasStamp: LONG, - NtBuildNumber: ULONG, + ImageNumberLow: c_ushort, + ImageNumberHigh: c_ushort, + NtSystemRoot: [wchar_t; 260], + MaxStackTraceDepth: c_ulong, + CryptoExponent: c_ulong, + TimeZoneId: c_ulong, + LargePageMinimum: c_ulong, + AitSamplingValue: c_ulong, + AppCompatFlag: c_ulong, + RNGSeedVersion: __uint64, + GlobalValidationRunlevel: c_ulong, + TimeZoneBiasStamp: c_long, + NtBuildNumber: c_ulong, NtProductType: NT_PRODUCT_TYPE, - ProductTypeIsValid: BOOLEAN, - Reserved0: [UCHAR; 1], - NativeProcessorArchitecture: USHORT, - NtMajorVersion: ULONG, - NtMinorVersion: ULONG, - ProcessorFeatures: [BOOLEAN; PROCESSOR_FEATURE_MAX], - Reserved1: ULONG, - Reserved3: ULONG, - TimeSlip: ULONG, + ProductTypeIsValid: c_uchar, + Reserved0: [c_uchar; 1], + NativeProcessorArchitecture: c_ushort, + NtMajorVersion: c_ulong, + NtMinorVersion: c_ulong, + ProcessorFeatures: [c_uchar; PROCESSOR_FEATURE_MAX], + Reserved1: c_ulong, + Reserved3: c_ulong, + TimeSlip: c_ulong, AlternativeArchitecture: ALTERNATIVE_ARCHITECTURE_TYPE, - BootId: ULONG, + BootId: c_ulong, SystemExpirationDate: LARGE_INTEGER, - SuiteMask: ULONG, - KdDebuggerEnabled: BOOLEAN, - MitigationPolicies: UCHAR, - Reserved6: [UCHAR; 2], - ActiveConsoleId: ULONG, - DismountCount: ULONG, - ComPlusPackage: ULONG, - LastSystemRITEventTickCount: ULONG, - NumberOfPhysicalPages: ULONG, - SafeBootMode: BOOLEAN, - VirtualizationFlags: UCHAR, - Reserved12: [UCHAR; 2], - SharedDataFlags: ULONG, - DataFlagsPad: [ULONG; 1], - TestRetInstruction: ULONGLONG, - QpcFrequency: LONGLONG, - SystemCall: ULONG, - SystemCallPad0: ULONG, - SystemCallPad: [ULONGLONG; 2], + SuiteMask: c_ulong, + KdDebuggerEnabled: c_uchar, + MitigationPolicies: c_uchar, + Reserved6: [c_uchar; 2], + ActiveConsoleId: c_ulong, + DismountCount: c_ulong, + ComPlusPackage: c_ulong, + LastSystemRITEventTickCount: c_ulong, + NumberOfPhysicalPages: c_ulong, + SafeBootMode: c_uchar, + VirtualizationFlags: c_uchar, + Reserved12: [c_uchar; 2], + SharedDataFlags: c_ulong, + DataFlagsPad: [c_ulong; 1], + TestRetInstruction: __uint64, + QpcFrequency: __int64, + SystemCall: c_ulong, + SystemCallPad0: c_ulong, + SystemCallPad: [__uint64; 2], u: KUSER_SHARED_DATA_u, - //TickCountPad: [ULONG; 1], - Cookie: ULONG, - CookiePad: [ULONG; 1], - ConsoleSessionForegroundProcessId: LONGLONG, - TimeUpdateLock: ULONGLONG, - BaselineSystemTimeQpc: ULONGLONG, - BaselineInterruptTimeQpc: ULONGLONG, - QpcSystemTimeIncrement: ULONGLONG, - QpcInterruptTimeIncrement: ULONGLONG, - QpcSystemTimeIncrementShift: UCHAR, - QpcInterruptTimeIncrementShift: UCHAR, - UnparkedProcessorCount: USHORT, - EnclaveFeatureMask: [ULONG; 4], - TelemetryCoverageRound: ULONG, - UserModeGlobalLogger: [USHORT; 16], - ImageFileExecutionOptions: ULONG, - LangGenerationCount: ULONG, - Reserved4: ULONGLONG, - InterruptTimeBias: ULONG64, - QpcBias: ULONG64, - ActiveProcessorCount: ULONG, - ActiveGroupCount: UCHAR, - Reserved9: UCHAR, - QpcData: UCHAR, + //TickCountPad: [c_ulong; 1], + Cookie: c_ulong, + CookiePad: [c_ulong; 1], + ConsoleSessionForegroundProcessId: __int64, + TimeUpdateLock: __uint64, + BaselineSystemTimeQpc: __uint64, + BaselineInterruptTimeQpc: __uint64, + QpcSystemTimeIncrement: __uint64, + QpcInterruptTimeIncrement: __uint64, + QpcSystemTimeIncrementShift: c_uchar, + QpcInterruptTimeIncrementShift: c_uchar, + UnparkedProcessorCount: c_ushort, + EnclaveFeatureMask: [c_ulong; 4], + TelemetryCoverageRound: c_ulong, + UserModeGlobalLogger: [c_ushort; 16], + ImageFileExecutionOptions: c_ulong, + LangGenerationCount: c_ulong, + Reserved4: __uint64, + InterruptTimeBias: __uint64, + QpcBias: __uint64, + ActiveProcessorCount: c_ulong, + ActiveGroupCount: c_uchar, + Reserved9: c_uchar, + QpcData: c_uchar, TimeZoneBiasEffectiveStart: LARGE_INTEGER, TimeZoneBiasEffectiveEnd: LARGE_INTEGER, XState: XSTATE_CONFIGURATION, }} -BITFIELD!{KUSER_SHARED_DATA MitigationPolicies: UCHAR [ +BITFIELD! {KUSER_SHARED_DATA MitigationPolicies: c_uchar [ NXSupportPolicy set_NXSupportPolicy[0..2], SEHValidationPolicy set_SEHValidationPolicy[2..4], CurDirDevicesSkippedForDlls set_CurDirDevicesSkippedForDlls[4..6], Reserved set_Reserved[6..8], ]} -BITFIELD!{KUSER_SHARED_DATA SharedDataFlags: ULONG [ +BITFIELD! {KUSER_SHARED_DATA SharedDataFlags: c_ulong [ DbgErrorPortPresent set_DbgErrorPortPresent[0..1], DbgElevationEnabled set_DbgElevationEnabled[1..2], DbgVirtEnabled set_DbgVirtEnabled[2..3], @@ -2772,157 +2865,176 @@ BITFIELD!{KUSER_SHARED_DATA SharedDataFlags: ULONG [ DbgStateSeparationEnabled set_DbgStateSeparationEnabled[10..11], SpareBits set_SpareBits[11..32], ]} -BITFIELD!{KUSER_SHARED_DATA QpcData: UCHAR [ +BITFIELD! {KUSER_SHARED_DATA QpcData: c_uchar [ QpcBypassEnabled set_QpcBypassEnabled[0..1], QpcShift set_QpcShift[1..2], ]} pub type PKUSER_SHARED_DATA = *mut KUSER_SHARED_DATA; pub const USER_SHARED_DATA: *const KUSER_SHARED_DATA = 0x7ffe0000 as *const _; #[inline] -pub unsafe fn NtGetTickCount64() -> ULONGLONG { +pub unsafe fn NtGetTickCount64() -> __uint64 { let mut tick_count: ULARGE_INTEGER = MaybeUninit::zeroed().assume_init(); - #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] { - *tick_count.QuadPart_mut() = read_volatile(addr_of!((*USER_SHARED_DATA).u.TickCountQuad)); + #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] + { + *tick_count.QuadPart_mut() = + read_volatile(addr_of!((*USER_SHARED_DATA).u.TickCountQuad)); } - #[cfg(target_arch = "x86")] { + #[cfg(target_arch = "x86")] + { loop { tick_count.s_mut().HighPart = - read_volatile(&(*USER_SHARED_DATA).u.TickCount.High1Time) as u32; - tick_count.s_mut().LowPart = read_volatile(&(*USER_SHARED_DATA).u.TickCount.LowPart); - if tick_count.s().HighPart == read_volatile(&(*USER_SHARED_DATA).u.TickCount.High2Time) - as u32 + read_volatile(&(*USER_SHARED_DATA).u.TickCount.High1Time) + as u32; + tick_count.s_mut().LowPart = + read_volatile(&(*USER_SHARED_DATA).u.TickCount.LowPart); + if tick_count.s().HighPart + == read_volatile(&(*USER_SHARED_DATA).u.TickCount.High2Time) + as u32 { break; } spin_loop(); } } - (UInt32x32To64(tick_count.s().LowPart, (*USER_SHARED_DATA).TickCountMultiplier) >> 24) - + (UInt32x32To64( - tick_count.s().HighPart as u32, + (UInt32x32To64( + tick_count.s().LowPart, (*USER_SHARED_DATA).TickCountMultiplier, - ) << 8) + ) >> 24) + + (UInt32x32To64( + tick_count.s().HighPart, + (*USER_SHARED_DATA).TickCountMultiplier, + ) << 8) } #[inline] -pub unsafe fn NtGetTickCount() -> ULONG { - #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] { +pub unsafe fn NtGetTickCount() -> c_ulong { + #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] + { ((read_volatile(addr_of!((*USER_SHARED_DATA).u.TickCountQuad)) - * (*USER_SHARED_DATA).TickCountMultiplier as u64) >> 24) as u32 + * (*USER_SHARED_DATA).TickCountMultiplier as u64) + >> 24) as u32 } - #[cfg(target_arch = "x86")] { - let mut tick_count: ULARGE_INTEGER = MaybeUninit::zeroed().assume_init(); + #[cfg(target_arch = "x86")] + { + let mut tick_count: ULARGE_INTEGER = + MaybeUninit::zeroed().assume_init(); loop { - tick_count.s_mut().HighPart = read_volatile(&(*USER_SHARED_DATA).u.TickCount.High1Time) - as u32; - tick_count.s_mut().LowPart = read_volatile(&(*USER_SHARED_DATA).u.TickCount.LowPart); - if tick_count.s().HighPart == read_volatile(&(*USER_SHARED_DATA).u.TickCount.High2Time) - as u32 + tick_count.s_mut().HighPart = + read_volatile(&(*USER_SHARED_DATA).u.TickCount.High1Time) + as u32; + tick_count.s_mut().LowPart = + read_volatile(&(*USER_SHARED_DATA).u.TickCount.LowPart); + if tick_count.s().HighPart + == read_volatile(&(*USER_SHARED_DATA).u.TickCount.High2Time) + as u32 { break; } spin_loop(); } - ((UInt32x32To64(tick_count.s().LowPart, (*USER_SHARED_DATA).TickCountMultiplier) >> 24) - + UInt32x32To64( - (tick_count.s().HighPart as u32) << 8, + ((UInt32x32To64( + tick_count.s().LowPart, (*USER_SHARED_DATA).TickCountMultiplier, - )) as u32 + ) >> 24) + + UInt32x32To64( + (tick_count.s().HighPart as u32) << 8, + (*USER_SHARED_DATA).TickCountMultiplier, + )) as u32 } } -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtQueryDefaultLocale( - UserProfile: BOOLEAN, - DefaultLocaleId: PLCID, + UserProfile: c_uchar, + DefaultLocaleId: *mut c_ulong, ) -> NTSTATUS; fn NtSetDefaultLocale( - UserProfile: BOOLEAN, - DefaultLocaleId: LCID, + UserProfile: c_uchar, + DefaultLocaleId: c_ulong, ) -> NTSTATUS; fn NtQueryInstallUILanguage( - InstallUILanguageId: *mut LANGID, + InstallUILanguageId: *mut c_ushort, ) -> NTSTATUS; fn NtFlushInstallUILanguage( - InstallUILanguage: LANGID, - SetComittedFlag: ULONG, + InstallUILanguage: c_ushort, + SetComittedFlag: c_ulong, ) -> NTSTATUS; fn NtQueryDefaultUILanguage( - DefaultUILanguageId: *mut LANGID, + DefaultUILanguageId: *mut c_ushort, ) -> NTSTATUS; fn NtSetDefaultUILanguage( - DefaultUILanguageId: LANGID, + DefaultUILanguageId: c_ushort, ) -> NTSTATUS; fn NtIsUILanguageComitted() -> NTSTATUS; fn NtInitializeNlsFiles( - BaseAddress: *mut PVOID, - DefaultLocaleId: PLCID, - DefaultCasingTableSize: PLARGE_INTEGER, + BaseAddress: *mut *mut c_void, + DefaultLocaleId: *mut c_ulong, + DefaultCasingTableSize: *mut LARGE_INTEGER, ) -> NTSTATUS; fn NtGetNlsSectionPtr( - SectionType: ULONG, - SectionData: ULONG, - ContextData: PVOID, - SectionPointer: *mut PVOID, - SectionSize: PULONG, + SectionType: c_ulong, + SectionData: c_ulong, + ContextData: *mut c_void, + SectionPointer: *mut *mut c_void, + SectionSize: *mut c_ulong, ) -> NTSTATUS; fn NtMapCMFModule( - What: ULONG, - Index: ULONG, - CacheIndexOut: PULONG, - CacheFlagsOut: PULONG, - ViewSizeOut: PULONG, - BaseAddress: *mut PVOID, + What: c_ulong, + Index: c_ulong, + CacheIndexOut: *mut c_ulong, + CacheFlagsOut: *mut c_ulong, + ViewSizeOut: *mut c_ulong, + BaseAddress: *mut *mut c_void, ) -> NTSTATUS; fn NtGetMUIRegistryInfo( - Flags: ULONG, - DataSize: PULONG, - Data: PVOID, + Flags: c_ulong, + DataSize: *mut c_ulong, + Data: *mut c_void, ) -> NTSTATUS; fn NtAddAtom( - AtomName: PWSTR, - Length: ULONG, + AtomName: *mut wchar_t, + Length: c_ulong, Atom: PRTL_ATOM, ) -> NTSTATUS; }} -pub const ATOM_FLAG_GLOBAL: ULONG = 0x2; -EXTERN!{extern "system" { +pub const ATOM_FLAG_GLOBAL: c_ulong = 0x2; +EXTERN! {extern "system" { fn NtAddAtomEx( - AtomName: PWSTR, - Length: ULONG, + AtomName: *mut wchar_t, + Length: c_ulong, Atom: PRTL_ATOM, - Flags: ULONG, + Flags: c_ulong, ) -> NTSTATUS; fn NtFindAtom( - AtomName: PWSTR, - Length: ULONG, + AtomName: *mut wchar_t, + Length: c_ulong, Atom: PRTL_ATOM, ) -> NTSTATUS; fn NtDeleteAtom( Atom: RTL_ATOM, ) -> NTSTATUS; }} -ENUM!{enum ATOM_INFORMATION_CLASS { +ENUM! {enum ATOM_INFORMATION_CLASS { AtomBasicInformation = 0, AtomTableInformation = 1, }} -STRUCT!{struct ATOM_BASIC_INFORMATION { - UsageCount: USHORT, - Flags: USHORT, - NameLength: USHORT, - Name: [WCHAR; 1], +STRUCT! {struct ATOM_BASIC_INFORMATION { + UsageCount: c_ushort, + Flags: c_ushort, + NameLength: c_ushort, + Name: [wchar_t; 1], }} pub type PATOM_BASIC_INFORMATION = *mut ATOM_BASIC_INFORMATION; -STRUCT!{struct ATOM_TABLE_INFORMATION { - NumberOfAtoms: ULONG, +STRUCT! {struct ATOM_TABLE_INFORMATION { + NumberOfAtoms: c_ulong, Atoms: [RTL_ATOM; 1], }} pub type PATOM_TABLE_INFORMATION = *mut ATOM_TABLE_INFORMATION; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtQueryInformationAtom( Atom: RTL_ATOM, AtomInformationClass: ATOM_INFORMATION_CLASS, - AtomInformation: PVOID, - AtomInformationLength: ULONG, - ReturnLength: PULONG, + AtomInformation: *mut c_void, + AtomInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; }} pub const FLG_STOP_ON_EXCEPTION: u32 = 0x00000001; @@ -2957,44 +3069,64 @@ pub const FLG_LDR_TOP_DOWN: u32 = 0x20000000; pub const FLG_ENABLE_HANDLE_EXCEPTIONS: u32 = 0x40000000; pub const FLG_DISABLE_PROTDLLS: u32 = 0x80000000; pub const FLG_VALID_BITS: u32 = 0xfffffdff; -pub const FLG_USERMODE_VALID_BITS: u32 = FLG_STOP_ON_EXCEPTION | FLG_SHOW_LDR_SNAPS - | FLG_HEAP_ENABLE_TAIL_CHECK | FLG_HEAP_ENABLE_FREE_CHECK | FLG_HEAP_VALIDATE_PARAMETERS - | FLG_HEAP_VALIDATE_ALL | FLG_APPLICATION_VERIFIER | FLG_HEAP_ENABLE_TAGGING - | FLG_USER_STACK_TRACE_DB | FLG_HEAP_ENABLE_TAG_BY_DLL | FLG_DISABLE_STACK_EXTENSION - | FLG_ENABLE_SYSTEM_CRIT_BREAKS | FLG_HEAP_DISABLE_COALESCING | FLG_DISABLE_PROTDLLS - | FLG_HEAP_PAGE_ALLOCS | FLG_CRITSEC_EVENT_CREATION | FLG_LDR_TOP_DOWN; -pub const FLG_BOOTONLY_VALID_BITS: u32 = FLG_KERNEL_STACK_TRACE_DB | FLG_MAINTAIN_OBJECT_TYPELIST - | FLG_ENABLE_CSRDEBUG | FLG_DEBUG_INITIAL_COMMAND | FLG_DEBUG_INITIAL_COMMAND_EX +pub const FLG_USERMODE_VALID_BITS: u32 = FLG_STOP_ON_EXCEPTION + | FLG_SHOW_LDR_SNAPS + | FLG_HEAP_ENABLE_TAIL_CHECK + | FLG_HEAP_ENABLE_FREE_CHECK + | FLG_HEAP_VALIDATE_PARAMETERS + | FLG_HEAP_VALIDATE_ALL + | FLG_APPLICATION_VERIFIER + | FLG_HEAP_ENABLE_TAGGING + | FLG_USER_STACK_TRACE_DB + | FLG_HEAP_ENABLE_TAG_BY_DLL + | FLG_DISABLE_STACK_EXTENSION + | FLG_ENABLE_SYSTEM_CRIT_BREAKS + | FLG_HEAP_DISABLE_COALESCING + | FLG_DISABLE_PROTDLLS + | FLG_HEAP_PAGE_ALLOCS + | FLG_CRITSEC_EVENT_CREATION + | FLG_LDR_TOP_DOWN; +pub const FLG_BOOTONLY_VALID_BITS: u32 = FLG_KERNEL_STACK_TRACE_DB + | FLG_MAINTAIN_OBJECT_TYPELIST + | FLG_ENABLE_CSRDEBUG + | FLG_DEBUG_INITIAL_COMMAND + | FLG_DEBUG_INITIAL_COMMAND_EX | FLG_DISABLE_PAGE_KERNEL_STACKS; -pub const FLG_KERNELMODE_VALID_BITS: u32 = FLG_STOP_ON_EXCEPTION | FLG_SHOW_LDR_SNAPS - | FLG_STOP_ON_HUNG_GUI | FLG_POOL_ENABLE_TAGGING | FLG_ENABLE_KDEBUG_SYMBOL_LOAD - | FLG_ENABLE_CLOSE_EXCEPTIONS | FLG_ENABLE_EXCEPTION_LOGGING | FLG_ENABLE_HANDLE_TYPE_TAGGING - | FLG_DISABLE_DBGPRINT | FLG_ENABLE_HANDLE_EXCEPTIONS; -EXTERN!{extern "system" { +pub const FLG_KERNELMODE_VALID_BITS: u32 = FLG_STOP_ON_EXCEPTION + | FLG_SHOW_LDR_SNAPS + | FLG_STOP_ON_HUNG_GUI + | FLG_POOL_ENABLE_TAGGING + | FLG_ENABLE_KDEBUG_SYMBOL_LOAD + | FLG_ENABLE_CLOSE_EXCEPTIONS + | FLG_ENABLE_EXCEPTION_LOGGING + | FLG_ENABLE_HANDLE_TYPE_TAGGING + | FLG_DISABLE_DBGPRINT + | FLG_ENABLE_HANDLE_EXCEPTIONS; +EXTERN! {extern "system" { fn NtQueryLicenseValue( - ValueName: PUNICODE_STRING, - Type: PULONG, - Data: PVOID, - DataSize: ULONG, - ResultDataSize: PULONG, + ValueName: *mut UNICODE_STRING, + Type: *mut c_ulong, + Data: *mut c_void, + DataSize: c_ulong, + ResultDataSize: *mut c_ulong, ) -> NTSTATUS; fn NtSetDefaultHardErrorPort( DefaultHardErrorPort: HANDLE, ) -> NTSTATUS; }} -ENUM!{enum SHUTDOWN_ACTION { +ENUM! {enum SHUTDOWN_ACTION { ShutdownNoReboot = 0, ShutdownReboot = 1, ShutdownPowerOff = 2, }} -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtShutdownSystem( Action: SHUTDOWN_ACTION, ) -> NTSTATUS; fn NtDisplayString( - String: PUNICODE_STRING, + String: *mut UNICODE_STRING, ) -> NTSTATUS; fn NtDrawText( - Text: PUNICODE_STRING, + Text: *mut UNICODE_STRING, ) -> NTSTATUS; }} diff --git a/src/ntgdi.rs b/src/ntgdi.rs index ac6e387..1b2cc9c 100644 --- a/src/ntgdi.rs +++ b/src/ntgdi.rs @@ -1,123 +1,136 @@ -use winapi::shared::ntdef::{PVOID, UCHAR, ULONG, USHORT}; +use crate::ctypes::{c_uchar, c_ulong, c_ushort, c_void}; + pub const GDI_MAX_HANDLE_COUNT: usize = 0x4000; -pub const GDI_HANDLE_INDEX_SHIFT: ULONG = 0; -pub const GDI_HANDLE_INDEX_BITS: ULONG = 16; -pub const GDI_HANDLE_INDEX_MASK: ULONG = 0xffff; -pub const GDI_HANDLE_TYPE_SHIFT: ULONG = 16; -pub const GDI_HANDLE_TYPE_BITS: ULONG = 5; -pub const GDI_HANDLE_TYPE_MASK: ULONG = 0x1f; -pub const GDI_HANDLE_ALTTYPE_SHIFT: ULONG = 21; -pub const GDI_HANDLE_ALTTYPE_BITS: ULONG = 2; -pub const GDI_HANDLE_ALTTYPE_MASK: ULONG = 0x3; -pub const GDI_HANDLE_STOCK_SHIFT: ULONG = 23; -pub const GDI_HANDLE_STOCK_BITS: ULONG = 1; -pub const GDI_HANDLE_STOCK_MASK: ULONG = 0x1; -pub const GDI_HANDLE_UNIQUE_SHIFT: ULONG = 24; -pub const GDI_HANDLE_UNIQUE_BITS: ULONG = 8; -pub const GDI_HANDLE_UNIQUE_MASK: ULONG = 0xff; +pub const GDI_HANDLE_INDEX_SHIFT: c_ulong = 0; +pub const GDI_HANDLE_INDEX_BITS: c_ulong = 16; +pub const GDI_HANDLE_INDEX_MASK: c_ulong = 0xffff; +pub const GDI_HANDLE_TYPE_SHIFT: c_ulong = 16; +pub const GDI_HANDLE_TYPE_BITS: c_ulong = 5; +pub const GDI_HANDLE_TYPE_MASK: c_ulong = 0x1f; +pub const GDI_HANDLE_ALTTYPE_SHIFT: c_ulong = 21; +pub const GDI_HANDLE_ALTTYPE_BITS: c_ulong = 2; +pub const GDI_HANDLE_ALTTYPE_MASK: c_ulong = 0x3; +pub const GDI_HANDLE_STOCK_SHIFT: c_ulong = 23; +pub const GDI_HANDLE_STOCK_BITS: c_ulong = 1; +pub const GDI_HANDLE_STOCK_MASK: c_ulong = 0x1; +pub const GDI_HANDLE_UNIQUE_SHIFT: c_ulong = 24; +pub const GDI_HANDLE_UNIQUE_BITS: c_ulong = 8; +pub const GDI_HANDLE_UNIQUE_MASK: c_ulong = 0xff; #[inline] -pub const fn GDI_HANDLE_INDEX(Handle: ULONG) -> ULONG { +pub const fn GDI_HANDLE_INDEX(Handle: c_ulong) -> c_ulong { Handle & GDI_HANDLE_INDEX_MASK } #[inline] -pub const fn GDI_HANDLE_TYPE(Handle: ULONG) -> ULONG { +pub const fn GDI_HANDLE_TYPE(Handle: c_ulong) -> c_ulong { Handle >> GDI_HANDLE_TYPE_SHIFT & GDI_HANDLE_TYPE_MASK } #[inline] -pub const fn GDI_HANDLE_ALTTYPE(Handle: ULONG) -> ULONG { +pub const fn GDI_HANDLE_ALTTYPE(Handle: c_ulong) -> c_ulong { Handle >> GDI_HANDLE_ALTTYPE_SHIFT & GDI_HANDLE_ALTTYPE_MASK } #[inline] -pub const fn GDI_HANDLE_STOCK(Handle: ULONG) -> ULONG { +pub const fn GDI_HANDLE_STOCK(Handle: c_ulong) -> c_ulong { Handle >> GDI_HANDLE_STOCK_SHIFT & GDI_HANDLE_STOCK_MASK } #[inline] -pub const fn GDI_MAKE_HANDLE(Index: ULONG, Unique: ULONG) -> ULONG { +pub const fn GDI_MAKE_HANDLE(Index: c_ulong, Unique: c_ulong) -> c_ulong { Unique << GDI_HANDLE_INDEX_BITS | Index } -pub const GDI_DEF_TYPE: ULONG = 0; -pub const GDI_DC_TYPE: ULONG = 1; -pub const GDI_DD_DIRECTDRAW_TYPE: ULONG = 2; -pub const GDI_DD_SURFACE_TYPE: ULONG = 3; -pub const GDI_RGN_TYPE: ULONG = 4; -pub const GDI_SURF_TYPE: ULONG = 5; -pub const GDI_CLIENTOBJ_TYPE: ULONG = 6; -pub const GDI_PATH_TYPE: ULONG = 7; -pub const GDI_PAL_TYPE: ULONG = 8; -pub const GDI_ICMLCS_TYPE: ULONG = 9; -pub const GDI_LFONT_TYPE: ULONG = 10; -pub const GDI_RFONT_TYPE: ULONG = 11; -pub const GDI_PFE_TYPE: ULONG = 12; -pub const GDI_PFT_TYPE: ULONG = 13; -pub const GDI_ICMCXF_TYPE: ULONG = 14; -pub const GDI_ICMDLL_TYPE: ULONG = 15; -pub const GDI_BRUSH_TYPE: ULONG = 16; -pub const GDI_PFF_TYPE: ULONG = 17; -pub const GDI_CACHE_TYPE: ULONG = 18; -pub const GDI_SPACE_TYPE: ULONG = 19; -pub const GDI_DBRUSH_TYPE: ULONG = 20; -pub const GDI_META_TYPE: ULONG = 21; -pub const GDI_EFSTATE_TYPE: ULONG = 22; -pub const GDI_BMFD_TYPE: ULONG = 23; -pub const GDI_VTFD_TYPE: ULONG = 24; -pub const GDI_TTFD_TYPE: ULONG = 25; -pub const GDI_RC_TYPE: ULONG = 26; -pub const GDI_TEMP_TYPE: ULONG = 27; -pub const GDI_DRVOBJ_TYPE: ULONG = 28; -pub const GDI_DCIOBJ_TYPE: ULONG = 29; -pub const GDI_SPOOL_TYPE: ULONG = 30; +pub const GDI_DEF_TYPE: c_ulong = 0; +pub const GDI_DC_TYPE: c_ulong = 1; +pub const GDI_DD_DIRECTDRAW_TYPE: c_ulong = 2; +pub const GDI_DD_SURFACE_TYPE: c_ulong = 3; +pub const GDI_RGN_TYPE: c_ulong = 4; +pub const GDI_SURF_TYPE: c_ulong = 5; +pub const GDI_CLIENTOBJ_TYPE: c_ulong = 6; +pub const GDI_PATH_TYPE: c_ulong = 7; +pub const GDI_PAL_TYPE: c_ulong = 8; +pub const GDI_ICMLCS_TYPE: c_ulong = 9; +pub const GDI_LFONT_TYPE: c_ulong = 10; +pub const GDI_RFONT_TYPE: c_ulong = 11; +pub const GDI_PFE_TYPE: c_ulong = 12; +pub const GDI_PFT_TYPE: c_ulong = 13; +pub const GDI_ICMCXF_TYPE: c_ulong = 14; +pub const GDI_ICMDLL_TYPE: c_ulong = 15; +pub const GDI_BRUSH_TYPE: c_ulong = 16; +pub const GDI_PFF_TYPE: c_ulong = 17; +pub const GDI_CACHE_TYPE: c_ulong = 18; +pub const GDI_SPACE_TYPE: c_ulong = 19; +pub const GDI_DBRUSH_TYPE: c_ulong = 20; +pub const GDI_META_TYPE: c_ulong = 21; +pub const GDI_EFSTATE_TYPE: c_ulong = 22; +pub const GDI_BMFD_TYPE: c_ulong = 23; +pub const GDI_VTFD_TYPE: c_ulong = 24; +pub const GDI_TTFD_TYPE: c_ulong = 25; +pub const GDI_RC_TYPE: c_ulong = 26; +pub const GDI_TEMP_TYPE: c_ulong = 27; +pub const GDI_DRVOBJ_TYPE: c_ulong = 28; +pub const GDI_DCIOBJ_TYPE: c_ulong = 29; +pub const GDI_SPOOL_TYPE: c_ulong = 30; #[inline] -pub const fn GDI_CLIENT_TYPE_FROM_HANDLE(Handle: ULONG) -> ULONG { - Handle & (GDI_HANDLE_ALTTYPE_MASK << GDI_HANDLE_ALTTYPE_SHIFT | GDI_HANDLE_TYPE_MASK - << GDI_HANDLE_TYPE_SHIFT) +pub const fn GDI_CLIENT_TYPE_FROM_HANDLE(Handle: c_ulong) -> c_ulong { + Handle + & (GDI_HANDLE_ALTTYPE_MASK << GDI_HANDLE_ALTTYPE_SHIFT + | GDI_HANDLE_TYPE_MASK << GDI_HANDLE_TYPE_SHIFT) } #[inline] -pub const fn GDI_CLIENT_TYPE_FROM_UNIQUE(Unique: ULONG) -> ULONG { +pub const fn GDI_CLIENT_TYPE_FROM_UNIQUE(Unique: c_ulong) -> c_ulong { GDI_CLIENT_TYPE_FROM_HANDLE(Unique << 16) } -pub const GDI_ALTTYPE_1: ULONG = 1 << GDI_HANDLE_ALTTYPE_SHIFT; -pub const GDI_ALTTYPE_2: ULONG = 2 << GDI_HANDLE_ALTTYPE_SHIFT; -pub const GDI_ALTTYPE_3: ULONG = 3 << GDI_HANDLE_ALTTYPE_SHIFT; -pub const GDI_CLIENT_BITMAP_TYPE: ULONG = GDI_SURF_TYPE << GDI_HANDLE_TYPE_SHIFT; -pub const GDI_CLIENT_BRUSH_TYPE: ULONG = GDI_BRUSH_TYPE << GDI_HANDLE_TYPE_SHIFT; -pub const GDI_CLIENT_CLIENTOBJ_TYPE: ULONG = GDI_CLIENTOBJ_TYPE << GDI_HANDLE_TYPE_SHIFT; -pub const GDI_CLIENT_DC_TYPE: ULONG = GDI_DC_TYPE << GDI_HANDLE_TYPE_SHIFT; -pub const GDI_CLIENT_FONT_TYPE: ULONG = GDI_LFONT_TYPE << GDI_HANDLE_TYPE_SHIFT; -pub const GDI_CLIENT_PALETTE_TYPE: ULONG = GDI_PAL_TYPE << GDI_HANDLE_TYPE_SHIFT; -pub const GDI_CLIENT_REGION_TYPE: ULONG = GDI_RGN_TYPE << GDI_HANDLE_TYPE_SHIFT; -pub const GDI_CLIENT_ALTDC_TYPE: ULONG = GDI_CLIENT_DC_TYPE | GDI_ALTTYPE_1; -pub const GDI_CLIENT_DIBSECTION_TYPE: ULONG = GDI_CLIENT_BITMAP_TYPE | GDI_ALTTYPE_1; -pub const GDI_CLIENT_EXTPEN_TYPE: ULONG = GDI_CLIENT_BRUSH_TYPE | GDI_ALTTYPE_2; -pub const GDI_CLIENT_METADC16_TYPE: ULONG = GDI_CLIENT_CLIENTOBJ_TYPE | GDI_ALTTYPE_3; -pub const GDI_CLIENT_METAFILE_TYPE: ULONG = GDI_CLIENT_CLIENTOBJ_TYPE | GDI_ALTTYPE_2; -pub const GDI_CLIENT_METAFILE16_TYPE: ULONG = GDI_CLIENT_CLIENTOBJ_TYPE | GDI_ALTTYPE_1; -pub const GDI_CLIENT_PEN_TYPE: ULONG = GDI_CLIENT_BRUSH_TYPE | GDI_ALTTYPE_1; -UNION!{union GDI_HANDLE_ENTRY_u { - Object: PVOID, - NextFree: PVOID, +pub const GDI_ALTTYPE_1: c_ulong = 1 << GDI_HANDLE_ALTTYPE_SHIFT; +pub const GDI_ALTTYPE_2: c_ulong = 2 << GDI_HANDLE_ALTTYPE_SHIFT; +pub const GDI_ALTTYPE_3: c_ulong = 3 << GDI_HANDLE_ALTTYPE_SHIFT; +pub const GDI_CLIENT_BITMAP_TYPE: c_ulong = + GDI_SURF_TYPE << GDI_HANDLE_TYPE_SHIFT; +pub const GDI_CLIENT_BRUSH_TYPE: c_ulong = + GDI_BRUSH_TYPE << GDI_HANDLE_TYPE_SHIFT; +pub const GDI_CLIENT_CLIENTOBJ_TYPE: c_ulong = + GDI_CLIENTOBJ_TYPE << GDI_HANDLE_TYPE_SHIFT; +pub const GDI_CLIENT_DC_TYPE: c_ulong = GDI_DC_TYPE << GDI_HANDLE_TYPE_SHIFT; +pub const GDI_CLIENT_FONT_TYPE: c_ulong = + GDI_LFONT_TYPE << GDI_HANDLE_TYPE_SHIFT; +pub const GDI_CLIENT_PALETTE_TYPE: c_ulong = + GDI_PAL_TYPE << GDI_HANDLE_TYPE_SHIFT; +pub const GDI_CLIENT_REGION_TYPE: c_ulong = + GDI_RGN_TYPE << GDI_HANDLE_TYPE_SHIFT; +pub const GDI_CLIENT_ALTDC_TYPE: c_ulong = GDI_CLIENT_DC_TYPE | GDI_ALTTYPE_1; +pub const GDI_CLIENT_DIBSECTION_TYPE: c_ulong = + GDI_CLIENT_BITMAP_TYPE | GDI_ALTTYPE_1; +pub const GDI_CLIENT_EXTPEN_TYPE: c_ulong = + GDI_CLIENT_BRUSH_TYPE | GDI_ALTTYPE_2; +pub const GDI_CLIENT_METADC16_TYPE: c_ulong = + GDI_CLIENT_CLIENTOBJ_TYPE | GDI_ALTTYPE_3; +pub const GDI_CLIENT_METAFILE_TYPE: c_ulong = + GDI_CLIENT_CLIENTOBJ_TYPE | GDI_ALTTYPE_2; +pub const GDI_CLIENT_METAFILE16_TYPE: c_ulong = + GDI_CLIENT_CLIENTOBJ_TYPE | GDI_ALTTYPE_1; +pub const GDI_CLIENT_PEN_TYPE: c_ulong = GDI_CLIENT_BRUSH_TYPE | GDI_ALTTYPE_1; +UNION! {union GDI_HANDLE_ENTRY_u { + Object: *mut c_void, + NextFree: *mut c_void, }} -STRUCT!{struct GDI_HANDLE_ENTRY_Owner_s { - ProcessId: USHORT, - Bitfields: USHORT, +STRUCT! {struct GDI_HANDLE_ENTRY_Owner_s { + ProcessId: c_ushort, + Bitfields: c_ushort, }} -BITFIELD!{GDI_HANDLE_ENTRY_Owner_s Bitfields: USHORT [ +BITFIELD! {GDI_HANDLE_ENTRY_Owner_s Bitfields: c_ushort [ Lock set_Lock[0..1], Count set_Count[1..16], ]} -UNION!{union GDI_HANDLE_ENTRY_Owner { +UNION! {union GDI_HANDLE_ENTRY_Owner { s: GDI_HANDLE_ENTRY_Owner_s, - Value: ULONG, + Value: c_ulong, }} -STRUCT!{struct GDI_HANDLE_ENTRY { +STRUCT! {struct GDI_HANDLE_ENTRY { u: GDI_HANDLE_ENTRY_u, Owner: GDI_HANDLE_ENTRY_Owner, - Unique: USHORT, - Type: UCHAR, - Flags: UCHAR, - UserPointer: PVOID, + Unique: c_ushort, + Type: c_uchar, + Flags: c_uchar, + UserPointer: *mut c_void, }} pub type PGDI_HANDLE_ENTRY = *mut GDI_HANDLE_ENTRY; -STRUCT!{struct GDI_SHARED_MEMORY { +STRUCT! {struct GDI_SHARED_MEMORY { Handles: [GDI_HANDLE_ENTRY; GDI_MAX_HANDLE_COUNT], }} pub type PGDI_SHARED_MEMORY = *mut GDI_SHARED_MEMORY; diff --git a/src/ntioapi.rs b/src/ntioapi.rs index 48c416b..7043a8b 100644 --- a/src/ntioapi.rs +++ b/src/ntioapi.rs @@ -1,136 +1,147 @@ -use crate::string::UTF16Const; -use crate::winapi_local::um::winioctl::CTL_CODE; -use winapi::shared::basetsd::ULONG_PTR; -use winapi::shared::guiddef::GUID; -use winapi::shared::minwindef::DWORD; -use winapi::shared::ntdef::{ - BOOLEAN, CCHAR, CHAR, HANDLE, LARGE_INTEGER, LONG, LONGLONG, NTSTATUS, PBOOLEAN, PHANDLE, - PLARGE_INTEGER, POBJECT_ATTRIBUTES, PUCHAR, PULONG, PUNICODE_STRING, PVOID, UCHAR, ULONG, - ULONGLONG, USHORT, WCHAR, +use windows_sys::{ + core::GUID, + Win32::{ + Foundation::{HANDLE, NTSTATUS, PSID, UNICODE_STRING}, + Security::SID, + Storage::FileSystem::{ + FILE_ID_128, FILE_READ_DATA, FILE_SEGMENT_ELEMENT, FILE_WRITE_DATA, + }, + System::{ + Ioctl::{ + FILE_ANY_ACCESS, FILE_DEVICE_MAILSLOT, FILE_DEVICE_NAMED_PIPE, + METHOD_BUFFERED, METHOD_NEITHER, + }, + WindowsProgramming::OBJECT_ATTRIBUTES, + }, + }, }; -use winapi::um::winioctl::{ - FILE_ANY_ACCESS, FILE_DEVICE_MAILSLOT, FILE_DEVICE_NAMED_PIPE, METHOD_BUFFERED, METHOD_NEITHER, + +use crate::{ + ctypes::{ + __int64, __uint64, c_char, c_long, c_uchar, c_ulong, c_ushort, c_void, + wchar_t, + }, + string::UTF16Const, + windows_local::{shared::ntdef::LARGE_INTEGER, um::winioctl::CTL_CODE}, }; -use winapi::um::winnt::{ - ACCESS_MASK, FILE_ID_128, FILE_READ_DATA, FILE_WRITE_DATA, PFILE_SEGMENT_ELEMENT, PSID, SID, -}; -pub const FILE_SUPERSEDE: ULONG = 0x00000000; -pub const FILE_OPEN: ULONG = 0x00000001; -pub const FILE_CREATE: ULONG = 0x00000002; -pub const FILE_OPEN_IF: ULONG = 0x00000003; -pub const FILE_OVERWRITE: ULONG = 0x00000004; -pub const FILE_OVERWRITE_IF: ULONG = 0x00000005; -pub const FILE_MAXIMUM_DISPOSITION: ULONG = 0x00000005; -pub const FILE_DIRECTORY_FILE: ULONG = 0x00000001; -pub const FILE_WRITE_THROUGH: ULONG = 0x00000002; -pub const FILE_SEQUENTIAL_ONLY: ULONG = 0x00000004; -pub const FILE_NO_INTERMEDIATE_BUFFERING: ULONG = 0x00000008; -pub const FILE_SYNCHRONOUS_IO_ALERT: ULONG = 0x00000010; -pub const FILE_SYNCHRONOUS_IO_NONALERT: ULONG = 0x00000020; -pub const FILE_NON_DIRECTORY_FILE: ULONG = 0x00000040; -pub const FILE_CREATE_TREE_CONNECTION: ULONG = 0x00000080; -pub const FILE_COMPLETE_IF_OPLOCKED: ULONG = 0x00000100; -pub const FILE_NO_EA_KNOWLEDGE: ULONG = 0x00000200; -pub const FILE_OPEN_FOR_RECOVERY: ULONG = 0x00000400; -pub const FILE_RANDOM_ACCESS: ULONG = 0x00000800; -pub const FILE_DELETE_ON_CLOSE: ULONG = 0x00001000; -pub const FILE_OPEN_BY_FILE_ID: ULONG = 0x00002000; -pub const FILE_OPEN_FOR_BACKUP_INTENT: ULONG = 0x00004000; -pub const FILE_NO_COMPRESSION: ULONG = 0x00008000; -pub const FILE_OPEN_REQUIRING_OPLOCK: ULONG = 0x00010000; -pub const FILE_DISALLOW_EXCLUSIVE: ULONG = 0x00020000; -pub const FILE_SESSION_AWARE: ULONG = 0x00040000; -pub const FILE_RESERVE_OPFILTER: ULONG = 0x00100000; -pub const FILE_OPEN_REPARSE_POINT: ULONG = 0x00200000; -pub const FILE_OPEN_NO_RECALL: ULONG = 0x00400000; -pub const FILE_OPEN_FOR_FREE_SPACE_QUERY: ULONG = 0x00800000; -pub const FILE_COPY_STRUCTURED_STORAGE: ULONG = 0x00000041; -pub const FILE_STRUCTURED_STORAGE: ULONG = 0x00000441; -pub const FILE_SUPERSEDED: ULONG = 0x00000000; -pub const FILE_OPENED: ULONG = 0x00000001; -pub const FILE_CREATED: ULONG = 0x00000002; -pub const FILE_OVERWRITTEN: ULONG = 0x00000003; -pub const FILE_EXISTS: ULONG = 0x00000004; -pub const FILE_DOES_NOT_EXIST: ULONG = 0x00000005; -pub const FILE_WRITE_TO_END_OF_FILE: ULONG = 0xffffffff; -pub const FILE_USE_FILE_POINTER_POSITION: ULONG = 0xfffffffe; -pub const FILE_BYTE_ALIGNMENT: ULONG = 0x00000000; -pub const FILE_WORD_ALIGNMENT: ULONG = 0x00000001; -pub const FILE_LONG_ALIGNMENT: ULONG = 0x00000003; -pub const FILE_QUAD_ALIGNMENT: ULONG = 0x00000007; -pub const FILE_OCTA_ALIGNMENT: ULONG = 0x0000000f; -pub const FILE_32_BYTE_ALIGNMENT: ULONG = 0x0000001f; -pub const FILE_64_BYTE_ALIGNMENT: ULONG = 0x0000003f; -pub const FILE_128_BYTE_ALIGNMENT: ULONG = 0x0000007f; -pub const FILE_256_BYTE_ALIGNMENT: ULONG = 0x000000ff; -pub const FILE_512_BYTE_ALIGNMENT: ULONG = 0x000001ff; + +pub const FILE_SUPERSEDE: c_ulong = 0x00000000; +pub const FILE_OPEN: c_ulong = 0x00000001; +pub const FILE_CREATE: c_ulong = 0x00000002; +pub const FILE_OPEN_IF: c_ulong = 0x00000003; +pub const FILE_OVERWRITE: c_ulong = 0x00000004; +pub const FILE_OVERWRITE_IF: c_ulong = 0x00000005; +pub const FILE_MAXIMUM_DISPOSITION: c_ulong = 0x00000005; +pub const FILE_DIRECTORY_FILE: c_ulong = 0x00000001; +pub const FILE_WRITE_THROUGH: c_ulong = 0x00000002; +pub const FILE_SEQUENTIAL_ONLY: c_ulong = 0x00000004; +pub const FILE_NO_INTERMEDIATE_BUFFERING: c_ulong = 0x00000008; +pub const FILE_SYNCHRONOUS_IO_ALERT: c_ulong = 0x00000010; +pub const FILE_SYNCHRONOUS_IO_NONALERT: c_ulong = 0x00000020; +pub const FILE_NON_DIRECTORY_FILE: c_ulong = 0x00000040; +pub const FILE_CREATE_TREE_CONNECTION: c_ulong = 0x00000080; +pub const FILE_COMPLETE_IF_OPLOCKED: c_ulong = 0x00000100; +pub const FILE_NO_EA_KNOWLEDGE: c_ulong = 0x00000200; +pub const FILE_OPEN_FOR_RECOVERY: c_ulong = 0x00000400; +pub const FILE_RANDOM_ACCESS: c_ulong = 0x00000800; +pub const FILE_DELETE_ON_CLOSE: c_ulong = 0x00001000; +pub const FILE_OPEN_BY_FILE_ID: c_ulong = 0x00002000; +pub const FILE_OPEN_FOR_BACKUP_INTENT: c_ulong = 0x00004000; +pub const FILE_NO_COMPRESSION: c_ulong = 0x00008000; +pub const FILE_OPEN_REQUIRING_OPLOCK: c_ulong = 0x00010000; +pub const FILE_DISALLOW_EXCLUSIVE: c_ulong = 0x00020000; +pub const FILE_SESSION_AWARE: c_ulong = 0x00040000; +pub const FILE_RESERVE_OPFILTER: c_ulong = 0x00100000; +pub const FILE_OPEN_REPARSE_POINT: c_ulong = 0x00200000; +pub const FILE_OPEN_NO_RECALL: c_ulong = 0x00400000; +pub const FILE_OPEN_FOR_FREE_SPACE_QUERY: c_ulong = 0x00800000; +pub const FILE_COPY_STRUCTURED_STORAGE: c_ulong = 0x00000041; +pub const FILE_STRUCTURED_STORAGE: c_ulong = 0x00000441; +pub const FILE_SUPERSEDED: c_ulong = 0x00000000; +pub const FILE_OPENED: c_ulong = 0x00000001; +pub const FILE_CREATED: c_ulong = 0x00000002; +pub const FILE_OVERWRITTEN: c_ulong = 0x00000003; +pub const FILE_EXISTS: c_ulong = 0x00000004; +pub const FILE_DOES_NOT_EXIST: c_ulong = 0x00000005; +pub const FILE_WRITE_TO_END_OF_FILE: c_ulong = 0xffffffff; +pub const FILE_USE_FILE_POINTER_POSITION: c_ulong = 0xfffffffe; +pub const FILE_BYTE_ALIGNMENT: c_ulong = 0x00000000; +pub const FILE_WORD_ALIGNMENT: c_ulong = 0x00000001; +pub const FILE_LONG_ALIGNMENT: c_ulong = 0x00000003; +pub const FILE_QUAD_ALIGNMENT: c_ulong = 0x00000007; +pub const FILE_OCTA_ALIGNMENT: c_ulong = 0x0000000f; +pub const FILE_32_BYTE_ALIGNMENT: c_ulong = 0x0000001f; +pub const FILE_64_BYTE_ALIGNMENT: c_ulong = 0x0000003f; +pub const FILE_128_BYTE_ALIGNMENT: c_ulong = 0x0000007f; +pub const FILE_256_BYTE_ALIGNMENT: c_ulong = 0x000000ff; +pub const FILE_512_BYTE_ALIGNMENT: c_ulong = 0x000001ff; pub const MAXIMUM_FILENAME_LENGTH: u32 = 256; -pub const FILE_NEED_EA: ULONG = 0x00000080; -pub const FILE_EA_TYPE_BINARY: ULONG = 0xfffe; -pub const FILE_EA_TYPE_ASCII: ULONG = 0xfffd; -pub const FILE_EA_TYPE_BITMAP: ULONG = 0xfffb; -pub const FILE_EA_TYPE_METAFILE: ULONG = 0xfffa; -pub const FILE_EA_TYPE_ICON: ULONG = 0xfff9; -pub const FILE_EA_TYPE_EA: ULONG = 0xffee; -pub const FILE_EA_TYPE_MVMT: ULONG = 0xffdf; -pub const FILE_EA_TYPE_MVST: ULONG = 0xffde; -pub const FILE_EA_TYPE_ASN1: ULONG = 0xffdd; -pub const FILE_EA_TYPE_FAMILY_IDS: ULONG = 0xff01; -pub const FILE_REMOVABLE_MEDIA: ULONG = 0x00000001; -pub const FILE_READ_ONLY_DEVICE: ULONG = 0x00000002; -pub const FILE_FLOPPY_DISKETTE: ULONG = 0x00000004; -pub const FILE_WRITE_ONCE_MEDIA: ULONG = 0x00000008; -pub const FILE_REMOTE_DEVICE: ULONG = 0x00000010; -pub const FILE_DEVICE_IS_MOUNTED: ULONG = 0x00000020; -pub const FILE_VIRTUAL_VOLUME: ULONG = 0x00000040; -pub const FILE_AUTOGENERATED_DEVICE_NAME: ULONG = 0x00000080; -pub const FILE_DEVICE_SECURE_OPEN: ULONG = 0x00000100; -pub const FILE_CHARACTERISTIC_PNP_DEVICE: ULONG = 0x00000800; -pub const FILE_CHARACTERISTIC_TS_DEVICE: ULONG = 0x00001000; -pub const FILE_CHARACTERISTIC_WEBDAV_DEVICE: ULONG = 0x00002000; -pub const FILE_CHARACTERISTIC_CSV: ULONG = 0x00010000; -pub const FILE_DEVICE_ALLOW_APPCONTAINER_TRAVERSAL: ULONG = 0x00020000; -pub const FILE_PORTABLE_DEVICE: ULONG = 0x00040000; -pub const FILE_PIPE_BYTE_STREAM_TYPE: ULONG = 0x00000000; -pub const FILE_PIPE_MESSAGE_TYPE: ULONG = 0x00000001; -pub const FILE_PIPE_ACCEPT_REMOTE_CLIENTS: ULONG = 0x00000000; -pub const FILE_PIPE_REJECT_REMOTE_CLIENTS: ULONG = 0x00000002; -pub const FILE_PIPE_TYPE_VALID_MASK: ULONG = 0x00000003; -pub const FILE_PIPE_QUEUE_OPERATION: ULONG = 0x00000000; -pub const FILE_PIPE_COMPLETE_OPERATION: ULONG = 0x00000001; -pub const FILE_PIPE_BYTE_STREAM_MODE: ULONG = 0x00000000; -pub const FILE_PIPE_MESSAGE_MODE: ULONG = 0x00000001; -pub const FILE_PIPE_INBOUND: ULONG = 0x00000000; -pub const FILE_PIPE_OUTBOUND: ULONG = 0x00000001; -pub const FILE_PIPE_FULL_DUPLEX: ULONG = 0x00000002; -pub const FILE_PIPE_DISCONNECTED_STATE: ULONG = 0x00000001; -pub const FILE_PIPE_LISTENING_STATE: ULONG = 0x00000002; -pub const FILE_PIPE_CONNECTED_STATE: ULONG = 0x00000003; -pub const FILE_PIPE_CLOSING_STATE: ULONG = 0x00000004; -pub const FILE_PIPE_CLIENT_END: ULONG = 0x00000000; -pub const FILE_PIPE_SERVER_END: ULONG = 0x00000001; +pub const FILE_NEED_EA: c_ulong = 0x00000080; +pub const FILE_EA_TYPE_BINARY: c_ulong = 0xfffe; +pub const FILE_EA_TYPE_ASCII: c_ulong = 0xfffd; +pub const FILE_EA_TYPE_BITMAP: c_ulong = 0xfffb; +pub const FILE_EA_TYPE_METAFILE: c_ulong = 0xfffa; +pub const FILE_EA_TYPE_ICON: c_ulong = 0xfff9; +pub const FILE_EA_TYPE_EA: c_ulong = 0xffee; +pub const FILE_EA_TYPE_MVMT: c_ulong = 0xffdf; +pub const FILE_EA_TYPE_MVST: c_ulong = 0xffde; +pub const FILE_EA_TYPE_ASN1: c_ulong = 0xffdd; +pub const FILE_EA_TYPE_FAMILY_IDS: c_ulong = 0xff01; +pub const FILE_REMOVABLE_MEDIA: c_ulong = 0x00000001; +pub const FILE_READ_ONLY_DEVICE: c_ulong = 0x00000002; +pub const FILE_FLOPPY_DISKETTE: c_ulong = 0x00000004; +pub const FILE_WRITE_ONCE_MEDIA: c_ulong = 0x00000008; +pub const FILE_REMOTE_DEVICE: c_ulong = 0x00000010; +pub const FILE_DEVICE_IS_MOUNTED: c_ulong = 0x00000020; +pub const FILE_VIRTUAL_VOLUME: c_ulong = 0x00000040; +pub const FILE_AUTOGENERATED_DEVICE_NAME: c_ulong = 0x00000080; +pub const FILE_DEVICE_SECURE_OPEN: c_ulong = 0x00000100; +pub const FILE_CHARACTERISTIC_PNP_DEVICE: c_ulong = 0x00000800; +pub const FILE_CHARACTERISTIC_TS_DEVICE: c_ulong = 0x00001000; +pub const FILE_CHARACTERISTIC_WEBDAV_DEVICE: c_ulong = 0x00002000; +pub const FILE_CHARACTERISTIC_CSV: c_ulong = 0x00010000; +pub const FILE_DEVICE_ALLOW_APPCONTAINER_TRAVERSAL: c_ulong = 0x00020000; +pub const FILE_PORTABLE_DEVICE: c_ulong = 0x00040000; +pub const FILE_PIPE_BYTE_STREAM_TYPE: c_ulong = 0x00000000; +pub const FILE_PIPE_MESSAGE_TYPE: c_ulong = 0x00000001; +pub const FILE_PIPE_ACCEPT_REMOTE_CLIENTS: c_ulong = 0x00000000; +pub const FILE_PIPE_REJECT_REMOTE_CLIENTS: c_ulong = 0x00000002; +pub const FILE_PIPE_TYPE_VALID_MASK: c_ulong = 0x00000003; +pub const FILE_PIPE_QUEUE_OPERATION: c_ulong = 0x00000000; +pub const FILE_PIPE_COMPLETE_OPERATION: c_ulong = 0x00000001; +pub const FILE_PIPE_BYTE_STREAM_MODE: c_ulong = 0x00000000; +pub const FILE_PIPE_MESSAGE_MODE: c_ulong = 0x00000001; +pub const FILE_PIPE_INBOUND: c_ulong = 0x00000000; +pub const FILE_PIPE_OUTBOUND: c_ulong = 0x00000001; +pub const FILE_PIPE_FULL_DUPLEX: c_ulong = 0x00000002; +pub const FILE_PIPE_DISCONNECTED_STATE: c_ulong = 0x00000001; +pub const FILE_PIPE_LISTENING_STATE: c_ulong = 0x00000002; +pub const FILE_PIPE_CONNECTED_STATE: c_ulong = 0x00000003; +pub const FILE_PIPE_CLOSING_STATE: c_ulong = 0x00000004; +pub const FILE_PIPE_CLIENT_END: c_ulong = 0x00000000; +pub const FILE_PIPE_SERVER_END: c_ulong = 0x00000001; pub const MAILSLOT_SIZE_AUTO: u32 = 0; -UNION!{union IO_STATUS_BLOCK_u { +UNION! {union IO_STATUS_BLOCK_u { Status: NTSTATUS, - Pointer: PVOID, + Pointer: *mut c_void, }} -STRUCT!{struct IO_STATUS_BLOCK { +STRUCT! {struct IO_STATUS_BLOCK { u: IO_STATUS_BLOCK_u, - Information: ULONG_PTR, + Information: usize, }} pub type PIO_STATUS_BLOCK = *mut IO_STATUS_BLOCK; -FN!{stdcall PIO_APC_ROUTINE( - ApcContext: PVOID, +FN! {stdcall PIO_APC_ROUTINE( + ApcContext: *mut c_void, IoStatusBlock: PIO_STATUS_BLOCK, - Reserved: ULONG, + Reserved: c_ulong, ) -> ()} -STRUCT!{struct FILE_IO_COMPLETION_INFORMATION { - KeyContext: PVOID, - ApcContext: PVOID, +STRUCT! {struct FILE_IO_COMPLETION_INFORMATION { + KeyContext: *mut c_void, + ApcContext: *mut c_void, IoStatusBlock: IO_STATUS_BLOCK, }} pub type PFILE_IO_COMPLETION_INFORMATION = *mut FILE_IO_COMPLETION_INFORMATION; -ENUM!{enum FILE_INFORMATION_CLASS { +ENUM! {enum FILE_INFORMATION_CLASS { FileDirectoryInformation = 1, FileFullDirectoryInformation = 2, FileBothDirectoryInformation = 3, @@ -209,62 +220,62 @@ ENUM!{enum FILE_INFORMATION_CLASS { FileMaximumInformation = 76, }} pub type PFILE_INFORMATION_CLASS = *mut FILE_INFORMATION_CLASS; -STRUCT!{struct FILE_BASIC_INFORMATION { +STRUCT! {struct FILE_BASIC_INFORMATION { CreationTime: LARGE_INTEGER, LastAccessTime: LARGE_INTEGER, LastWriteTime: LARGE_INTEGER, ChangeTime: LARGE_INTEGER, - FileAttributes: ULONG, + FileAttributes: c_ulong, }} pub type PFILE_BASIC_INFORMATION = *mut FILE_BASIC_INFORMATION; -STRUCT!{struct FILE_STANDARD_INFORMATION { +STRUCT! {struct FILE_STANDARD_INFORMATION { AllocationSize: LARGE_INTEGER, EndOfFile: LARGE_INTEGER, - NumberOfLinks: ULONG, - DeletePending: BOOLEAN, - Directory: BOOLEAN, + NumberOfLinks: c_ulong, + DeletePending: c_uchar, + Directory: c_uchar, }} pub type PFILE_STANDARD_INFORMATION = *mut FILE_STANDARD_INFORMATION; -STRUCT!{struct FILE_STANDARD_INFORMATION_EX { +STRUCT! {struct FILE_STANDARD_INFORMATION_EX { AllocationSize: LARGE_INTEGER, EndOfFile: LARGE_INTEGER, - NumberOfLinks: ULONG, - DeletePending: BOOLEAN, - Directory: BOOLEAN, - AlternateStream: BOOLEAN, - MetadataAttribute: BOOLEAN, + NumberOfLinks: c_ulong, + DeletePending: c_uchar, + Directory: c_uchar, + AlternateStream: c_uchar, + MetadataAttribute: c_uchar, }} pub type PFILE_STANDARD_INFORMATION_EX = *mut FILE_STANDARD_INFORMATION_EX; -STRUCT!{struct FILE_INTERNAL_INFORMATION { +STRUCT! {struct FILE_INTERNAL_INFORMATION { IndexNumber: LARGE_INTEGER, }} pub type PFILE_INTERNAL_INFORMATION = *mut FILE_INTERNAL_INFORMATION; -STRUCT!{struct FILE_EA_INFORMATION { - EaSize: ULONG, +STRUCT! {struct FILE_EA_INFORMATION { + EaSize: c_ulong, }} pub type PFILE_EA_INFORMATION = *mut FILE_EA_INFORMATION; -STRUCT!{struct FILE_ACCESS_INFORMATION { - AccessFlags: ACCESS_MASK, +STRUCT! {struct FILE_ACCESS_INFORMATION { + AccessFlags: c_ulong, }} pub type PFILE_ACCESS_INFORMATION = *mut FILE_ACCESS_INFORMATION; -STRUCT!{struct FILE_POSITION_INFORMATION { +STRUCT! {struct FILE_POSITION_INFORMATION { CurrentByteOffset: LARGE_INTEGER, }} pub type PFILE_POSITION_INFORMATION = *mut FILE_POSITION_INFORMATION; -STRUCT!{struct FILE_MODE_INFORMATION { - Mode: ULONG, +STRUCT! {struct FILE_MODE_INFORMATION { + Mode: c_ulong, }} pub type PFILE_MODE_INFORMATION = *mut FILE_MODE_INFORMATION; -STRUCT!{struct FILE_ALIGNMENT_INFORMATION { - AlignmentRequirement: ULONG, +STRUCT! {struct FILE_ALIGNMENT_INFORMATION { + AlignmentRequirement: c_ulong, }} pub type PFILE_ALIGNMENT_INFORMATION = *mut FILE_ALIGNMENT_INFORMATION; -STRUCT!{struct FILE_NAME_INFORMATION { - FileNameLength: ULONG, - FileName: [WCHAR; 1], +STRUCT! {struct FILE_NAME_INFORMATION { + FileNameLength: c_ulong, + FileName: [wchar_t; 1], }} pub type PFILE_NAME_INFORMATION = *mut FILE_NAME_INFORMATION; -STRUCT!{struct FILE_ALL_INFORMATION { +STRUCT! {struct FILE_ALL_INFORMATION { BasicInformation: FILE_BASIC_INFORMATION, StandardInformation: FILE_STANDARD_INFORMATION, InternalInformation: FILE_INTERNAL_INFORMATION, @@ -276,167 +287,170 @@ STRUCT!{struct FILE_ALL_INFORMATION { NameInformation: FILE_NAME_INFORMATION, }} pub type PFILE_ALL_INFORMATION = *mut FILE_ALL_INFORMATION; -STRUCT!{struct FILE_NETWORK_OPEN_INFORMATION { +STRUCT! {struct FILE_NETWORK_OPEN_INFORMATION { CreationTime: LARGE_INTEGER, LastAccessTime: LARGE_INTEGER, LastWriteTime: LARGE_INTEGER, ChangeTime: LARGE_INTEGER, AllocationSize: LARGE_INTEGER, EndOfFile: LARGE_INTEGER, - FileAttributes: ULONG, + FileAttributes: c_ulong, }} pub type PFILE_NETWORK_OPEN_INFORMATION = *mut FILE_NETWORK_OPEN_INFORMATION; -STRUCT!{struct FILE_ATTRIBUTE_TAG_INFORMATION { - FileAttributes: ULONG, - ReparseTag: ULONG, +STRUCT! {struct FILE_ATTRIBUTE_TAG_INFORMATION { + FileAttributes: c_ulong, + ReparseTag: c_ulong, }} pub type PFILE_ATTRIBUTE_TAG_INFORMATION = *mut FILE_ATTRIBUTE_TAG_INFORMATION; -STRUCT!{struct FILE_ALLOCATION_INFORMATION { +STRUCT! {struct FILE_ALLOCATION_INFORMATION { AllocationSize: LARGE_INTEGER, }} pub type PFILE_ALLOCATION_INFORMATION = *mut FILE_ALLOCATION_INFORMATION; -STRUCT!{struct FILE_COMPRESSION_INFORMATION { +STRUCT! {struct FILE_COMPRESSION_INFORMATION { CompressedFileSize: LARGE_INTEGER, - CompressionFormat: USHORT, - CompressionUnitShift: UCHAR, - ChunkShift: UCHAR, - ClusterShift: UCHAR, - Reserved: [UCHAR; 3], + CompressionFormat: c_ushort, + CompressionUnitShift: c_uchar, + ChunkShift: c_uchar, + ClusterShift: c_uchar, + Reserved: [c_uchar; 3], }} pub type PFILE_COMPRESSION_INFORMATION = *mut FILE_COMPRESSION_INFORMATION; -STRUCT!{struct FILE_DISPOSITION_INFORMATION { - DeleteFileA: BOOLEAN, +STRUCT! {struct FILE_DISPOSITION_INFORMATION { + DeleteFileA: c_uchar, }} pub type PFILE_DISPOSITION_INFORMATION = *mut FILE_DISPOSITION_INFORMATION; -STRUCT!{struct FILE_END_OF_FILE_INFORMATION { +STRUCT! {struct FILE_END_OF_FILE_INFORMATION { EndOfFile: LARGE_INTEGER, }} pub type PFILE_END_OF_FILE_INFORMATION = *mut FILE_END_OF_FILE_INFORMATION; -STRUCT!{struct FILE_VALID_DATA_LENGTH_INFORMATION { +STRUCT! {struct FILE_VALID_DATA_LENGTH_INFORMATION { ValidDataLength: LARGE_INTEGER, }} -pub type PFILE_VALID_DATA_LENGTH_INFORMATION = *mut FILE_VALID_DATA_LENGTH_INFORMATION; -STRUCT!{struct FILE_LINK_INFORMATION { - ReplaceIfExists: BOOLEAN, +pub type PFILE_VALID_DATA_LENGTH_INFORMATION = + *mut FILE_VALID_DATA_LENGTH_INFORMATION; +STRUCT! {struct FILE_LINK_INFORMATION { + ReplaceIfExists: c_uchar, RootDirectory: HANDLE, - FileNameLength: ULONG, - FileName: [WCHAR; 1], + FileNameLength: c_ulong, + FileName: [wchar_t; 1], }} pub type PFILE_LINK_INFORMATION = *mut FILE_LINK_INFORMATION; -STRUCT!{struct FILE_MOVE_CLUSTER_INFORMATION { - ClusterCount: ULONG, +STRUCT! {struct FILE_MOVE_CLUSTER_INFORMATION { + ClusterCount: c_ulong, RootDirectory: HANDLE, - FileNameLength: ULONG, - FileName: [WCHAR; 1], + FileNameLength: c_ulong, + FileName: [wchar_t; 1], }} pub type PFILE_MOVE_CLUSTER_INFORMATION = *mut FILE_MOVE_CLUSTER_INFORMATION; -STRUCT!{struct FILE_RENAME_INFORMATION { - ReplaceIfExists: BOOLEAN, +STRUCT! {struct FILE_RENAME_INFORMATION { + ReplaceIfExists: c_uchar, RootDirectory: HANDLE, - FileNameLength: ULONG, - FileName: [WCHAR; 1], + FileNameLength: c_ulong, + FileName: [wchar_t; 1], }} pub type PFILE_RENAME_INFORMATION = *mut FILE_RENAME_INFORMATION; -STRUCT!{struct FILE_STREAM_INFORMATION { - NextEntryOffset: ULONG, - StreamNameLength: ULONG, +STRUCT! {struct FILE_STREAM_INFORMATION { + NextEntryOffset: c_ulong, + StreamNameLength: c_ulong, StreamSize: LARGE_INTEGER, StreamAllocationSize: LARGE_INTEGER, - StreamName: [WCHAR; 1], + StreamName: [wchar_t; 1], }} pub type PFILE_STREAM_INFORMATION = *mut FILE_STREAM_INFORMATION; -STRUCT!{struct FILE_TRACKING_INFORMATION { +STRUCT! {struct FILE_TRACKING_INFORMATION { DestinationFile: HANDLE, - ObjectInformationLength: ULONG, - ObjectInformation: [CHAR; 1], + ObjectInformationLength: c_ulong, + ObjectInformation: [c_char; 1], }} pub type PFILE_TRACKING_INFORMATION = *mut FILE_TRACKING_INFORMATION; -STRUCT!{struct FILE_COMPLETION_INFORMATION { +STRUCT! {struct FILE_COMPLETION_INFORMATION { Port: HANDLE, - Key: PVOID, + Key: *mut c_void, }} pub type PFILE_COMPLETION_INFORMATION = *mut FILE_COMPLETION_INFORMATION; -STRUCT!{struct FILE_PIPE_INFORMATION { - ReadMode: ULONG, - CompletionMode: ULONG, +STRUCT! {struct FILE_PIPE_INFORMATION { + ReadMode: c_ulong, + CompletionMode: c_ulong, }} pub type PFILE_PIPE_INFORMATION = *mut FILE_PIPE_INFORMATION; -STRUCT!{struct FILE_PIPE_LOCAL_INFORMATION { - NamedPipeType: ULONG, - NamedPipeConfiguration: ULONG, - MaximumInstances: ULONG, - CurrentInstances: ULONG, - InboundQuota: ULONG, - ReadDataAvailable: ULONG, - OutboundQuota: ULONG, - WriteQuotaAvailable: ULONG, - NamedPipeState: ULONG, - NamedPipeEnd: ULONG, +STRUCT! {struct FILE_PIPE_LOCAL_INFORMATION { + NamedPipeType: c_ulong, + NamedPipeConfiguration: c_ulong, + MaximumInstances: c_ulong, + CurrentInstances: c_ulong, + InboundQuota: c_ulong, + ReadDataAvailable: c_ulong, + OutboundQuota: c_ulong, + WriteQuotaAvailable: c_ulong, + NamedPipeState: c_ulong, + NamedPipeEnd: c_ulong, }} pub type PFILE_PIPE_LOCAL_INFORMATION = *mut FILE_PIPE_LOCAL_INFORMATION; -STRUCT!{struct FILE_PIPE_REMOTE_INFORMATION { +STRUCT! {struct FILE_PIPE_REMOTE_INFORMATION { CollectDataTime: LARGE_INTEGER, - MaximumCollectionCount: ULONG, + MaximumCollectionCount: c_ulong, }} pub type PFILE_PIPE_REMOTE_INFORMATION = *mut FILE_PIPE_REMOTE_INFORMATION; -STRUCT!{struct FILE_MAILSLOT_QUERY_INFORMATION { - MaximumMessageSize: ULONG, - MailslotQuota: ULONG, - NextMessageSize: ULONG, - MessagesAvailable: ULONG, +STRUCT! {struct FILE_MAILSLOT_QUERY_INFORMATION { + MaximumMessageSize: c_ulong, + MailslotQuota: c_ulong, + NextMessageSize: c_ulong, + MessagesAvailable: c_ulong, ReadTimeout: LARGE_INTEGER, }} -pub type PFILE_MAILSLOT_QUERY_INFORMATION = *mut FILE_MAILSLOT_QUERY_INFORMATION; -STRUCT!{struct FILE_MAILSLOT_SET_INFORMATION { - ReadTimeout: PLARGE_INTEGER, +pub type PFILE_MAILSLOT_QUERY_INFORMATION = + *mut FILE_MAILSLOT_QUERY_INFORMATION; +STRUCT! {struct FILE_MAILSLOT_SET_INFORMATION { + ReadTimeout: *mut LARGE_INTEGER, }} pub type PFILE_MAILSLOT_SET_INFORMATION = *mut FILE_MAILSLOT_SET_INFORMATION; -STRUCT!{struct FILE_REPARSE_POINT_INFORMATION { - FileReference: LONGLONG, - Tag: ULONG, +STRUCT! {struct FILE_REPARSE_POINT_INFORMATION { + FileReference: __int64, + Tag: c_ulong, }} pub type PFILE_REPARSE_POINT_INFORMATION = *mut FILE_REPARSE_POINT_INFORMATION; -STRUCT!{struct FILE_LINK_ENTRY_INFORMATION { - NextEntryOffset: ULONG, - ParentFileId: LONGLONG, - FileNameLength: ULONG, - FileName: [WCHAR; 1], +STRUCT! {struct FILE_LINK_ENTRY_INFORMATION { + NextEntryOffset: c_ulong, + ParentFileId: __int64, + FileNameLength: c_ulong, + FileName: [wchar_t; 1], }} pub type PFILE_LINK_ENTRY_INFORMATION = *mut FILE_LINK_ENTRY_INFORMATION; -STRUCT!{struct FILE_LINKS_INFORMATION { - BytesNeeded: ULONG, - EntriesReturned: ULONG, +STRUCT! {struct FILE_LINKS_INFORMATION { + BytesNeeded: c_ulong, + EntriesReturned: c_ulong, Entry: FILE_LINK_ENTRY_INFORMATION, }} pub type PFILE_LINKS_INFORMATION = *mut FILE_LINKS_INFORMATION; -STRUCT!{struct FILE_NETWORK_PHYSICAL_NAME_INFORMATION { - FileNameLength: ULONG, - FileName: [WCHAR; 1], -}} -pub type PFILE_NETWORK_PHYSICAL_NAME_INFORMATION = *mut FILE_NETWORK_PHYSICAL_NAME_INFORMATION; -STRUCT!{struct FILE_STANDARD_LINK_INFORMATION { - NumberOfAccessibleLinks: ULONG, - TotalNumberOfLinks: ULONG, - DeletePending: BOOLEAN, - Directory: BOOLEAN, +STRUCT! {struct FILE_NETWORK_PHYSICAL_NAME_INFORMATION { + FileNameLength: c_ulong, + FileName: [wchar_t; 1], +}} +pub type PFILE_NETWORK_PHYSICAL_NAME_INFORMATION = + *mut FILE_NETWORK_PHYSICAL_NAME_INFORMATION; +STRUCT! {struct FILE_STANDARD_LINK_INFORMATION { + NumberOfAccessibleLinks: c_ulong, + TotalNumberOfLinks: c_ulong, + DeletePending: c_uchar, + Directory: c_uchar, }} pub type PFILE_STANDARD_LINK_INFORMATION = *mut FILE_STANDARD_LINK_INFORMATION; -STRUCT!{struct FILE_SFIO_RESERVE_INFORMATION { - RequestsPerPeriod: ULONG, - Period: ULONG, - RetryFailures: BOOLEAN, - Discardable: BOOLEAN, - RequestSize: ULONG, - NumOutstandingRequests: ULONG, +STRUCT! {struct FILE_SFIO_RESERVE_INFORMATION { + RequestsPerPeriod: c_ulong, + Period: c_ulong, + RetryFailures: c_uchar, + Discardable: c_uchar, + RequestSize: c_ulong, + NumOutstandingRequests: c_ulong, }} pub type PFILE_SFIO_RESERVE_INFORMATION = *mut FILE_SFIO_RESERVE_INFORMATION; -STRUCT!{struct FILE_SFIO_VOLUME_INFORMATION { - MaximumRequestsPerPeriod: ULONG, - MinimumPeriod: ULONG, - MinimumTransferSize: ULONG, +STRUCT! {struct FILE_SFIO_VOLUME_INFORMATION { + MaximumRequestsPerPeriod: c_ulong, + MinimumPeriod: c_ulong, + MinimumTransferSize: c_ulong, }} pub type PFILE_SFIO_VOLUME_INFORMATION = *mut FILE_SFIO_VOLUME_INFORMATION; -ENUM!{enum IO_PRIORITY_HINT { +ENUM! {enum IO_PRIORITY_HINT { IoPriorityVeryLow = 0, IoPriorityLow = 1, IoPriorityNormal = 2, @@ -444,134 +458,143 @@ ENUM!{enum IO_PRIORITY_HINT { IoPriorityCritical = 4, MaxIoPriorityTypes = 5, }} -STRUCT!{struct FILE_IO_PRIORITY_HINT_INFORMATION { +STRUCT! {struct FILE_IO_PRIORITY_HINT_INFORMATION { PriorityHint: IO_PRIORITY_HINT, }} -pub type PFILE_IO_PRIORITY_HINT_INFORMATION = *mut FILE_IO_PRIORITY_HINT_INFORMATION; -STRUCT!{struct FILE_IO_PRIORITY_HINT_INFORMATION_EX { +pub type PFILE_IO_PRIORITY_HINT_INFORMATION = + *mut FILE_IO_PRIORITY_HINT_INFORMATION; +STRUCT! {struct FILE_IO_PRIORITY_HINT_INFORMATION_EX { PriorityHint: IO_PRIORITY_HINT, - BoostOutstanding: BOOLEAN, + BoostOutstanding: c_uchar, }} -pub type PFILE_IO_PRIORITY_HINT_INFORMATION_EX = *mut FILE_IO_PRIORITY_HINT_INFORMATION_EX; +pub type PFILE_IO_PRIORITY_HINT_INFORMATION_EX = + *mut FILE_IO_PRIORITY_HINT_INFORMATION_EX; pub const FILE_SKIP_COMPLETION_PORT_ON_SUCCESS: u32 = 0x1; pub const FILE_SKIP_SET_EVENT_ON_HANDLE: u32 = 0x2; pub const FILE_SKIP_SET_USER_EVENT_ON_FAST_IO: u32 = 0x4; -STRUCT!{struct FILE_IO_COMPLETION_NOTIFICATION_INFORMATION { - Flags: ULONG, +STRUCT! {struct FILE_IO_COMPLETION_NOTIFICATION_INFORMATION { + Flags: c_ulong, }} pub type PFILE_IO_COMPLETION_NOTIFICATION_INFORMATION = *mut FILE_IO_COMPLETION_NOTIFICATION_INFORMATION; -STRUCT!{struct FILE_PROCESS_IDS_USING_FILE_INFORMATION { - NumberOfProcessIdsInList: ULONG, - ProcessIdList: [ULONG_PTR; 1], +STRUCT! {struct FILE_PROCESS_IDS_USING_FILE_INFORMATION { + NumberOfProcessIdsInList: c_ulong, + ProcessIdList: [usize; 1], }} -pub type PFILE_PROCESS_IDS_USING_FILE_INFORMATION = *mut FILE_PROCESS_IDS_USING_FILE_INFORMATION; -STRUCT!{struct FILE_IS_REMOTE_DEVICE_INFORMATION { - IsRemote: BOOLEAN, +pub type PFILE_PROCESS_IDS_USING_FILE_INFORMATION = + *mut FILE_PROCESS_IDS_USING_FILE_INFORMATION; +STRUCT! {struct FILE_IS_REMOTE_DEVICE_INFORMATION { + IsRemote: c_uchar, }} -pub type PFILE_IS_REMOTE_DEVICE_INFORMATION = *mut FILE_IS_REMOTE_DEVICE_INFORMATION; -STRUCT!{struct FILE_NUMA_NODE_INFORMATION { - NodeNumber: USHORT, +pub type PFILE_IS_REMOTE_DEVICE_INFORMATION = + *mut FILE_IS_REMOTE_DEVICE_INFORMATION; +STRUCT! {struct FILE_NUMA_NODE_INFORMATION { + NodeNumber: c_ushort, }} pub type PFILE_NUMA_NODE_INFORMATION = *mut FILE_NUMA_NODE_INFORMATION; -STRUCT!{struct FILE_IOSTATUSBLOCK_RANGE_INFORMATION { - IoStatusBlockRange: PUCHAR, - Length: ULONG, +STRUCT! {struct FILE_IOSTATUSBLOCK_RANGE_INFORMATION { + IoStatusBlockRange: *mut c_uchar, + Length: c_ulong, }} -pub type PFILE_IOSTATUSBLOCK_RANGE_INFORMATION = *mut FILE_IOSTATUSBLOCK_RANGE_INFORMATION; -STRUCT!{struct FILE_REMOTE_PROTOCOL_INFORMATION_GenericReserved { - Reserved: [ULONG; 8], +pub type PFILE_IOSTATUSBLOCK_RANGE_INFORMATION = + *mut FILE_IOSTATUSBLOCK_RANGE_INFORMATION; +STRUCT! {struct FILE_REMOTE_PROTOCOL_INFORMATION_GenericReserved { + Reserved: [c_ulong; 8], }} -STRUCT!{struct FILE_REMOTE_PROTOCOL_INFORMATION_ProtocolSpecific_Smb2_Server { - Capabilities: ULONG, +STRUCT! {struct FILE_REMOTE_PROTOCOL_INFORMATION_ProtocolSpecific_Smb2_Server { + Capabilities: c_ulong, }} -STRUCT!{struct FILE_REMOTE_PROTOCOL_INFORMATION_ProtocolSpecific_Smb2_Share { - Capabilities: ULONG, - CachingFlags: ULONG, +STRUCT! {struct FILE_REMOTE_PROTOCOL_INFORMATION_ProtocolSpecific_Smb2_Share { + Capabilities: c_ulong, + CachingFlags: c_ulong, }} -STRUCT!{struct FILE_REMOTE_PROTOCOL_INFORMATION_ProtocolSpecific_Smb2 { +STRUCT! {struct FILE_REMOTE_PROTOCOL_INFORMATION_ProtocolSpecific_Smb2 { Server: FILE_REMOTE_PROTOCOL_INFORMATION_ProtocolSpecific_Smb2_Server, Share: FILE_REMOTE_PROTOCOL_INFORMATION_ProtocolSpecific_Smb2_Share, }} -UNION!{union FILE_REMOTE_PROTOCOL_INFORMATION_ProtocolSpecific { +UNION! {union FILE_REMOTE_PROTOCOL_INFORMATION_ProtocolSpecific { Smb2: FILE_REMOTE_PROTOCOL_INFORMATION_ProtocolSpecific_Smb2, - Reserved: [ULONG; 16], -}} -STRUCT!{struct FILE_REMOTE_PROTOCOL_INFORMATION { - StructureVersion: USHORT, - StructureSize: USHORT, - Protocol: ULONG, - ProtocolMajorVersion: USHORT, - ProtocolMinorVersion: USHORT, - ProtocolRevision: USHORT, - Reserved: USHORT, - Flags: ULONG, + Reserved: [c_ulong; 16], +}} +STRUCT! {struct FILE_REMOTE_PROTOCOL_INFORMATION { + StructureVersion: c_ushort, + StructureSize: c_ushort, + Protocol: c_ulong, + ProtocolMajorVersion: c_ushort, + ProtocolMinorVersion: c_ushort, + ProtocolRevision: c_ushort, + Reserved: c_ushort, + Flags: c_ulong, GenericReserved: FILE_REMOTE_PROTOCOL_INFORMATION_GenericReserved, ProtocolSpecific: FILE_REMOTE_PROTOCOL_INFORMATION_ProtocolSpecific, }} -pub type PFILE_REMOTE_PROTOCOL_INFORMATION = *mut FILE_REMOTE_PROTOCOL_INFORMATION; +pub type PFILE_REMOTE_PROTOCOL_INFORMATION = + *mut FILE_REMOTE_PROTOCOL_INFORMATION; pub const CHECKSUM_ENFORCEMENT_OFF: u32 = 0x00000001; -STRUCT!{struct FILE_INTEGRITY_STREAM_INFORMATION { - ChecksumAlgorithm: USHORT, - ChecksumChunkShift: UCHAR, - ClusterShift: UCHAR, - Flags: ULONG, -}} -pub type PFILE_INTEGRITY_STREAM_INFORMATION = *mut FILE_INTEGRITY_STREAM_INFORMATION; -STRUCT!{struct FILE_VOLUME_NAME_INFORMATION { - DeviceNameLength: ULONG, - DeviceName: [WCHAR; 1], +STRUCT! {struct FILE_INTEGRITY_STREAM_INFORMATION { + ChecksumAlgorithm: c_ushort, + ChecksumChunkShift: c_uchar, + ClusterShift: c_uchar, + Flags: c_ulong, +}} +pub type PFILE_INTEGRITY_STREAM_INFORMATION = + *mut FILE_INTEGRITY_STREAM_INFORMATION; +STRUCT! {struct FILE_VOLUME_NAME_INFORMATION { + DeviceNameLength: c_ulong, + DeviceName: [wchar_t; 1], }} pub type PFILE_VOLUME_NAME_INFORMATION = *mut FILE_VOLUME_NAME_INFORMATION; -STRUCT!{struct FILE_ID_INFORMATION { - VolumeSerialNumber: ULONGLONG, +STRUCT! {struct FILE_ID_INFORMATION { + VolumeSerialNumber: __uint64, FileId: FILE_ID_128, }} pub type PFILE_ID_INFORMATION = *mut FILE_ID_INFORMATION; -STRUCT!{struct FILE_ID_EXTD_DIR_INFORMATION { - NextEntryOffset: ULONG, - FileIndex: ULONG, +STRUCT! {struct FILE_ID_EXTD_DIR_INFORMATION { + NextEntryOffset: c_ulong, + FileIndex: c_ulong, CreationTime: LARGE_INTEGER, LastAccessTime: LARGE_INTEGER, LastWriteTime: LARGE_INTEGER, ChangeTime: LARGE_INTEGER, EndOfFile: LARGE_INTEGER, AllocationSize: LARGE_INTEGER, - FileAttributes: ULONG, - FileNameLength: ULONG, - EaSize: ULONG, - ReparsePointTag: ULONG, + FileAttributes: c_ulong, + FileNameLength: c_ulong, + EaSize: c_ulong, + ReparsePointTag: c_ulong, FileId: FILE_ID_128, - FileName: [WCHAR; 1], + FileName: [wchar_t; 1], }} pub type PFILE_ID_EXTD_DIR_INFORMATION = *mut FILE_ID_EXTD_DIR_INFORMATION; -STRUCT!{struct FILE_LINK_ENTRY_FULL_ID_INFORMATION { - NextEntryOffset: ULONG, +STRUCT! {struct FILE_LINK_ENTRY_FULL_ID_INFORMATION { + NextEntryOffset: c_ulong, ParentFileId: FILE_ID_128, - FileNameLength: ULONG, - FileName: [WCHAR; 1], -}} -pub type PFILE_LINK_ENTRY_FULL_ID_INFORMATION = *mut FILE_LINK_ENTRY_FULL_ID_INFORMATION; -STRUCT!{struct FILE_ID_EXTD_BOTH_DIR_INFORMATION { - NextEntryOffset: ULONG, - FileIndex: ULONG, + FileNameLength: c_ulong, + FileName: [wchar_t; 1], +}} +pub type PFILE_LINK_ENTRY_FULL_ID_INFORMATION = + *mut FILE_LINK_ENTRY_FULL_ID_INFORMATION; +STRUCT! {struct FILE_ID_EXTD_BOTH_DIR_INFORMATION { + NextEntryOffset: c_ulong, + FileIndex: c_ulong, CreationTime: LARGE_INTEGER, LastAccessTime: LARGE_INTEGER, LastWriteTime: LARGE_INTEGER, ChangeTime: LARGE_INTEGER, EndOfFile: LARGE_INTEGER, AllocationSize: LARGE_INTEGER, - FileAttributes: ULONG, - FileNameLength: ULONG, - EaSize: ULONG, - ReparsePointTag: ULONG, + FileAttributes: c_ulong, + FileNameLength: c_ulong, + EaSize: c_ulong, + ReparsePointTag: c_ulong, FileId: FILE_ID_128, - ShortNameLength: CCHAR, - ShortName: [WCHAR; 12], - FileName: [WCHAR; 1], + ShortNameLength: c_char, + ShortName: [wchar_t; 12], + FileName: [wchar_t; 1], }} -pub type PFILE_ID_EXTD_BOTH_DIR_INFORMATION = *mut FILE_ID_EXTD_BOTH_DIR_INFORMATION; -STRUCT!{struct FILE_STAT_INFORMATION { +pub type PFILE_ID_EXTD_BOTH_DIR_INFORMATION = + *mut FILE_ID_EXTD_BOTH_DIR_INFORMATION; +STRUCT! {struct FILE_STAT_INFORMATION { FileId: LARGE_INTEGER, CreationTime: LARGE_INTEGER, LastAccessTime: LARGE_INTEGER, @@ -579,26 +602,27 @@ STRUCT!{struct FILE_STAT_INFORMATION { ChangeTime: LARGE_INTEGER, AllocationSize: LARGE_INTEGER, EndOfFile: LARGE_INTEGER, - FileAttributes: ULONG, - ReparseTag: ULONG, - NumberOfLinks: ULONG, - EffectiveAccess: ULONG, + FileAttributes: c_ulong, + ReparseTag: c_ulong, + NumberOfLinks: c_ulong, + EffectiveAccess: c_ulong, }} pub type PFILE_STAT_INFORMATION = *mut FILE_STAT_INFORMATION; -STRUCT!{struct FILE_MEMORY_PARTITION_INFORMATION_Flags_s { - NoCrossPartitionAccess: UCHAR, - Spare: [UCHAR; 3], +STRUCT! {struct FILE_MEMORY_PARTITION_INFORMATION_Flags_s { + NoCrossPartitionAccess: c_uchar, + Spare: [c_uchar; 3], }} -UNION!{union FILE_MEMORY_PARTITION_INFORMATION_Flags { +UNION! {union FILE_MEMORY_PARTITION_INFORMATION_Flags { s: FILE_MEMORY_PARTITION_INFORMATION_Flags_s, - AllFlags: ULONG, + AllFlags: c_ulong, }} -STRUCT!{struct FILE_MEMORY_PARTITION_INFORMATION { +STRUCT! {struct FILE_MEMORY_PARTITION_INFORMATION { OwnerPartitionHandle: HANDLE, Flags: FILE_MEMORY_PARTITION_INFORMATION_Flags, }} -pub type PFILE_MEMORY_PARTITION_INFORMATION = *mut FILE_MEMORY_PARTITION_INFORMATION; -STRUCT!{struct FILE_STAT_LX_INFORMATION { +pub type PFILE_MEMORY_PARTITION_INFORMATION = + *mut FILE_MEMORY_PARTITION_INFORMATION; +STRUCT! {struct FILE_STAT_LX_INFORMATION { FileId: LARGE_INTEGER, CreationTime: LARGE_INTEGER, LastAccessTime: LARGE_INTEGER, @@ -606,167 +630,169 @@ STRUCT!{struct FILE_STAT_LX_INFORMATION { ChangeTime: LARGE_INTEGER, AllocationSize: LARGE_INTEGER, EndOfFile: LARGE_INTEGER, - FileAttributes: ULONG, - ReparseTag: ULONG, - NumberOfLinks: ULONG, - EffectiveAccess: ULONG, - LxFlags: ULONG, - LxUid: ULONG, - LxGid: ULONG, - LxMode: ULONG, - LxDeviceIdMajor: ULONG, - LxDeviceIdMinor: ULONG, + FileAttributes: c_ulong, + ReparseTag: c_ulong, + NumberOfLinks: c_ulong, + EffectiveAccess: c_ulong, + LxFlags: c_ulong, + LxUid: c_ulong, + LxGid: c_ulong, + LxMode: c_ulong, + LxDeviceIdMajor: c_ulong, + LxDeviceIdMinor: c_ulong, }} pub type PFILE_STAT_LX_INFORMATION = *mut FILE_STAT_LX_INFORMATION; -STRUCT!{struct FILE_CASE_SENSITIVE_INFORMATION { - Flags: ULONG, -}} -pub type PFILE_CASE_SENSITIVE_INFORMATION = *mut FILE_CASE_SENSITIVE_INFORMATION; -STRUCT!{struct FILE_DIRECTORY_INFORMATION { - NextEntryOffset: ULONG, - FileIndex: ULONG, +STRUCT! {struct FILE_CASE_SENSITIVE_INFORMATION { + Flags: c_ulong, +}} +pub type PFILE_CASE_SENSITIVE_INFORMATION = + *mut FILE_CASE_SENSITIVE_INFORMATION; +STRUCT! {struct FILE_DIRECTORY_INFORMATION { + NextEntryOffset: c_ulong, + FileIndex: c_ulong, CreationTime: LARGE_INTEGER, LastAccessTime: LARGE_INTEGER, LastWriteTime: LARGE_INTEGER, ChangeTime: LARGE_INTEGER, EndOfFile: LARGE_INTEGER, AllocationSize: LARGE_INTEGER, - FileAttributes: ULONG, - FileNameLength: ULONG, - FileName: [WCHAR; 1], + FileAttributes: c_ulong, + FileNameLength: c_ulong, + FileName: [wchar_t; 1], }} pub type PFILE_DIRECTORY_INFORMATION = *mut FILE_DIRECTORY_INFORMATION; -STRUCT!{struct FILE_FULL_DIR_INFORMATION { - NextEntryOffset: ULONG, - FileIndex: ULONG, +STRUCT! {struct FILE_FULL_DIR_INFORMATION { + NextEntryOffset: c_ulong, + FileIndex: c_ulong, CreationTime: LARGE_INTEGER, LastAccessTime: LARGE_INTEGER, LastWriteTime: LARGE_INTEGER, ChangeTime: LARGE_INTEGER, EndOfFile: LARGE_INTEGER, AllocationSize: LARGE_INTEGER, - FileAttributes: ULONG, - FileNameLength: ULONG, - EaSize: ULONG, - FileName: [WCHAR; 1], + FileAttributes: c_ulong, + FileNameLength: c_ulong, + EaSize: c_ulong, + FileName: [wchar_t; 1], }} pub type PFILE_FULL_DIR_INFORMATION = *mut FILE_FULL_DIR_INFORMATION; -STRUCT!{struct FILE_ID_FULL_DIR_INFORMATION { - NextEntryOffset: ULONG, - FileIndex: ULONG, +STRUCT! {struct FILE_ID_FULL_DIR_INFORMATION { + NextEntryOffset: c_ulong, + FileIndex: c_ulong, CreationTime: LARGE_INTEGER, LastAccessTime: LARGE_INTEGER, LastWriteTime: LARGE_INTEGER, ChangeTime: LARGE_INTEGER, EndOfFile: LARGE_INTEGER, AllocationSize: LARGE_INTEGER, - FileAttributes: ULONG, - FileNameLength: ULONG, - EaSize: ULONG, + FileAttributes: c_ulong, + FileNameLength: c_ulong, + EaSize: c_ulong, FileId: LARGE_INTEGER, - FileName: [WCHAR; 1], + FileName: [wchar_t; 1], }} pub type PFILE_ID_FULL_DIR_INFORMATION = *mut FILE_ID_FULL_DIR_INFORMATION; -STRUCT!{struct FILE_BOTH_DIR_INFORMATION { - NextEntryOffset: ULONG, - FileIndex: ULONG, +STRUCT! {struct FILE_BOTH_DIR_INFORMATION { + NextEntryOffset: c_ulong, + FileIndex: c_ulong, CreationTime: LARGE_INTEGER, LastAccessTime: LARGE_INTEGER, LastWriteTime: LARGE_INTEGER, ChangeTime: LARGE_INTEGER, EndOfFile: LARGE_INTEGER, AllocationSize: LARGE_INTEGER, - FileAttributes: ULONG, - FileNameLength: ULONG, - EaSize: ULONG, - ShortNameLength: CCHAR, - ShortName: [WCHAR; 12], - FileName: [WCHAR; 1], + FileAttributes: c_ulong, + FileNameLength: c_ulong, + EaSize: c_ulong, + ShortNameLength: c_char, + ShortName: [wchar_t; 12], + FileName: [wchar_t; 1], }} pub type PFILE_BOTH_DIR_INFORMATION = *mut FILE_BOTH_DIR_INFORMATION; -STRUCT!{struct FILE_ID_BOTH_DIR_INFORMATION { - NextEntryOffset: ULONG, - FileIndex: ULONG, +STRUCT! {struct FILE_ID_BOTH_DIR_INFORMATION { + NextEntryOffset: c_ulong, + FileIndex: c_ulong, CreationTime: LARGE_INTEGER, LastAccessTime: LARGE_INTEGER, LastWriteTime: LARGE_INTEGER, ChangeTime: LARGE_INTEGER, EndOfFile: LARGE_INTEGER, AllocationSize: LARGE_INTEGER, - FileAttributes: ULONG, - FileNameLength: ULONG, - EaSize: ULONG, - ShortNameLength: CCHAR, - ShortName: [WCHAR; 12], + FileAttributes: c_ulong, + FileNameLength: c_ulong, + EaSize: c_ulong, + ShortNameLength: c_char, + ShortName: [wchar_t; 12], FileId: LARGE_INTEGER, - FileName: [WCHAR; 1], + FileName: [wchar_t; 1], }} pub type PFILE_ID_BOTH_DIR_INFORMATION = *mut FILE_ID_BOTH_DIR_INFORMATION; -STRUCT!{struct FILE_NAMES_INFORMATION { - NextEntryOffset: ULONG, - FileIndex: ULONG, - FileNameLength: ULONG, - FileName: [WCHAR; 1], +STRUCT! {struct FILE_NAMES_INFORMATION { + NextEntryOffset: c_ulong, + FileIndex: c_ulong, + FileNameLength: c_ulong, + FileName: [wchar_t; 1], }} pub type PFILE_NAMES_INFORMATION = *mut FILE_NAMES_INFORMATION; -STRUCT!{struct FILE_ID_GLOBAL_TX_DIR_INFORMATION { - NextEntryOffset: ULONG, - FileIndex: ULONG, +STRUCT! {struct FILE_ID_GLOBAL_TX_DIR_INFORMATION { + NextEntryOffset: c_ulong, + FileIndex: c_ulong, CreationTime: LARGE_INTEGER, LastAccessTime: LARGE_INTEGER, LastWriteTime: LARGE_INTEGER, ChangeTime: LARGE_INTEGER, EndOfFile: LARGE_INTEGER, AllocationSize: LARGE_INTEGER, - FileAttributes: ULONG, - FileNameLength: ULONG, + FileAttributes: c_ulong, + FileNameLength: c_ulong, FileId: LARGE_INTEGER, LockingTransactionId: GUID, - TxInfoFlags: ULONG, - FileName: [WCHAR; 1], + TxInfoFlags: c_ulong, + FileName: [wchar_t; 1], }} -pub type PFILE_ID_GLOBAL_TX_DIR_INFORMATION = *mut FILE_ID_GLOBAL_TX_DIR_INFORMATION; +pub type PFILE_ID_GLOBAL_TX_DIR_INFORMATION = + *mut FILE_ID_GLOBAL_TX_DIR_INFORMATION; pub const FILE_ID_GLOBAL_TX_DIR_INFO_FLAG_WRITELOCKED: u32 = 0x00000001; pub const FILE_ID_GLOBAL_TX_DIR_INFO_FLAG_VISIBLE_TO_TX: u32 = 0x00000002; pub const FILE_ID_GLOBAL_TX_DIR_INFO_FLAG_VISIBLE_OUTSIDE_TX: u32 = 0x00000004; -STRUCT!{struct FILE_OBJECTID_INFORMATION_u_s { - BirthVolumeId: [UCHAR; 16], - BirthObjectId: [UCHAR; 16], - DomainId: [UCHAR; 16], +STRUCT! {struct FILE_OBJECTID_INFORMATION_u_s { + BirthVolumeId: [c_uchar; 16], + BirthObjectId: [c_uchar; 16], + DomainId: [c_uchar; 16], }} -UNION!{union FILE_OBJECTID_INFORMATION_u { +UNION! {union FILE_OBJECTID_INFORMATION_u { s: FILE_OBJECTID_INFORMATION_u_s, - ExtendedInfo: [UCHAR; 48], + ExtendedInfo: [c_uchar; 48], }} -STRUCT!{struct FILE_OBJECTID_INFORMATION { - FileReference: LONGLONG, - ObjectId: [UCHAR; 16], +STRUCT! {struct FILE_OBJECTID_INFORMATION { + FileReference: __int64, + ObjectId: [c_uchar; 16], u: FILE_OBJECTID_INFORMATION_u, }} pub type PFILE_OBJECTID_INFORMATION = *mut FILE_OBJECTID_INFORMATION; -STRUCT!{struct FILE_FULL_EA_INFORMATION { - NextEntryOffset: ULONG, - Flags: UCHAR, - EaNameLength: UCHAR, - EaValueLength: USHORT, - EaName: [CHAR; 1], +STRUCT! {struct FILE_FULL_EA_INFORMATION { + NextEntryOffset: c_ulong, + Flags: c_uchar, + EaNameLength: c_uchar, + EaValueLength: c_ushort, + EaName: [c_char; 1], }} pub type PFILE_FULL_EA_INFORMATION = *mut FILE_FULL_EA_INFORMATION; -STRUCT!{struct FILE_GET_EA_INFORMATION { - NextEntryOffset: ULONG, - EaNameLength: UCHAR, - EaName: [CHAR; 1], +STRUCT! {struct FILE_GET_EA_INFORMATION { + NextEntryOffset: c_ulong, + EaNameLength: c_uchar, + EaName: [c_char; 1], }} pub type PFILE_GET_EA_INFORMATION = *mut FILE_GET_EA_INFORMATION; -STRUCT!{struct FILE_GET_QUOTA_INFORMATION { - NextEntryOffset: ULONG, - SidLength: ULONG, +STRUCT! {struct FILE_GET_QUOTA_INFORMATION { + NextEntryOffset: c_ulong, + SidLength: c_ulong, Sid: SID, }} pub type PFILE_GET_QUOTA_INFORMATION = *mut FILE_GET_QUOTA_INFORMATION; -STRUCT!{struct FILE_QUOTA_INFORMATION { - NextEntryOffset: ULONG, - SidLength: ULONG, +STRUCT! {struct FILE_QUOTA_INFORMATION { + NextEntryOffset: c_ulong, + SidLength: c_ulong, ChangeTime: LARGE_INTEGER, QuotaUsed: LARGE_INTEGER, QuotaThreshold: LARGE_INTEGER, @@ -774,7 +800,7 @@ STRUCT!{struct FILE_QUOTA_INFORMATION { Sid: SID, }} pub type PFILE_QUOTA_INFORMATION = *mut FILE_QUOTA_INFORMATION; -ENUM!{enum FS_INFORMATION_CLASS { +ENUM! {enum FS_INFORMATION_CLASS { FileFsVolumeInformation = 1, FileFsLabelInformation = 2, FileFsSizeInformation = 3, @@ -792,159 +818,164 @@ ENUM!{enum FS_INFORMATION_CLASS { FileFsMaximumInformation = 15, }} pub type PFS_INFORMATION_CLASS = *mut FS_INFORMATION_CLASS; -STRUCT!{struct FILE_FS_LABEL_INFORMATION { - VolumeLabelLength: ULONG, - VolumeLabel: [WCHAR; 1], +STRUCT! {struct FILE_FS_LABEL_INFORMATION { + VolumeLabelLength: c_ulong, + VolumeLabel: [wchar_t; 1], }} pub type PFILE_FS_LABEL_INFORMATION = *mut FILE_FS_LABEL_INFORMATION; -STRUCT!{struct FILE_FS_VOLUME_INFORMATION { +STRUCT! {struct FILE_FS_VOLUME_INFORMATION { VolumeCreationTime: LARGE_INTEGER, - VolumeSerialNumber: ULONG, - VolumeLabelLength: ULONG, - SupportsObjects: BOOLEAN, - VolumeLabel: [WCHAR; 1], + VolumeSerialNumber: c_ulong, + VolumeLabelLength: c_ulong, + SupportsObjects: c_uchar, + VolumeLabel: [wchar_t; 1], }} pub type PFILE_FS_VOLUME_INFORMATION = *mut FILE_FS_VOLUME_INFORMATION; -STRUCT!{struct FILE_FS_SIZE_INFORMATION { +STRUCT! {struct FILE_FS_SIZE_INFORMATION { TotalAllocationUnits: LARGE_INTEGER, AvailableAllocationUnits: LARGE_INTEGER, - SectorsPerAllocationUnit: ULONG, - BytesPerSector: ULONG, + SectorsPerAllocationUnit: c_ulong, + BytesPerSector: c_ulong, }} pub type PFILE_FS_SIZE_INFORMATION = *mut FILE_FS_SIZE_INFORMATION; -STRUCT!{struct FILE_FS_CONTROL_INFORMATION { +STRUCT! {struct FILE_FS_CONTROL_INFORMATION { FreeSpaceStartFiltering: LARGE_INTEGER, FreeSpaceThreshold: LARGE_INTEGER, FreeSpaceStopFiltering: LARGE_INTEGER, DefaultQuotaThreshold: LARGE_INTEGER, DefaultQuotaLimit: LARGE_INTEGER, - FileSystemControlFlags: ULONG, + FileSystemControlFlags: c_ulong, }} pub type PFILE_FS_CONTROL_INFORMATION = *mut FILE_FS_CONTROL_INFORMATION; -STRUCT!{struct FILE_FS_FULL_SIZE_INFORMATION { +STRUCT! {struct FILE_FS_FULL_SIZE_INFORMATION { TotalAllocationUnits: LARGE_INTEGER, CallerAvailableAllocationUnits: LARGE_INTEGER, ActualAvailableAllocationUnits: LARGE_INTEGER, - SectorsPerAllocationUnit: ULONG, - BytesPerSector: ULONG, + SectorsPerAllocationUnit: c_ulong, + BytesPerSector: c_ulong, }} pub type PFILE_FS_FULL_SIZE_INFORMATION = *mut FILE_FS_FULL_SIZE_INFORMATION; -STRUCT!{struct FILE_FS_OBJECTID_INFORMATION { - ObjectId: [UCHAR; 16], - ExtendedInfo: [UCHAR; 48], +STRUCT! {struct FILE_FS_OBJECTID_INFORMATION { + ObjectId: [c_uchar; 16], + ExtendedInfo: [c_uchar; 48], }} pub type PFILE_FS_OBJECTID_INFORMATION = *mut FILE_FS_OBJECTID_INFORMATION; -STRUCT!{struct FILE_FS_DEVICE_INFORMATION { - DeviceType: DWORD, - Characteristics: ULONG, +STRUCT! {struct FILE_FS_DEVICE_INFORMATION { + DeviceType: c_ulong, + Characteristics: c_ulong, }} pub type PFILE_FS_DEVICE_INFORMATION = *mut FILE_FS_DEVICE_INFORMATION; -STRUCT!{struct FILE_FS_ATTRIBUTE_INFORMATION { - FileSystemAttributes: ULONG, - MaximumComponentNameLength: LONG, - FileSystemNameLength: ULONG, - FileSystemName: [WCHAR; 1], +STRUCT! {struct FILE_FS_ATTRIBUTE_INFORMATION { + FileSystemAttributes: c_ulong, + MaximumComponentNameLength: c_long, + FileSystemNameLength: c_ulong, + FileSystemName: [wchar_t; 1], }} pub type PFILE_FS_ATTRIBUTE_INFORMATION = *mut FILE_FS_ATTRIBUTE_INFORMATION; -STRUCT!{struct FILE_FS_DRIVER_PATH_INFORMATION { - DriverInPath: BOOLEAN, - DriverNameLength: ULONG, - DriverName: [WCHAR; 1], -}} -pub type PFILE_FS_DRIVER_PATH_INFORMATION = *mut FILE_FS_DRIVER_PATH_INFORMATION; -STRUCT!{struct FILE_FS_VOLUME_FLAGS_INFORMATION { - Flags: ULONG, -}} -pub type PFILE_FS_VOLUME_FLAGS_INFORMATION = *mut FILE_FS_VOLUME_FLAGS_INFORMATION; +STRUCT! {struct FILE_FS_DRIVER_PATH_INFORMATION { + DriverInPath: c_uchar, + DriverNameLength: c_ulong, + DriverName: [wchar_t; 1], +}} +pub type PFILE_FS_DRIVER_PATH_INFORMATION = + *mut FILE_FS_DRIVER_PATH_INFORMATION; +STRUCT! {struct FILE_FS_VOLUME_FLAGS_INFORMATION { + Flags: c_ulong, +}} +pub type PFILE_FS_VOLUME_FLAGS_INFORMATION = + *mut FILE_FS_VOLUME_FLAGS_INFORMATION; pub const SSINFO_FLAGS_ALIGNED_DEVICE: u32 = 0x00000001; pub const SSINFO_FLAGS_PARTITION_ALIGNED_ON_DEVICE: u32 = 0x00000002; pub const SSINFO_OFFSET_UNKNOWN: u32 = 0xffffffff; -STRUCT!{struct FILE_FS_SECTOR_SIZE_INFORMATION { - LogicalBytesPerSector: ULONG, - PhysicalBytesPerSectorForAtomicity: ULONG, - PhysicalBytesPerSectorForPerformance: ULONG, - FileSystemEffectivePhysicalBytesPerSectorForAtomicity: ULONG, - Flags: ULONG, - ByteOffsetForSectorAlignment: ULONG, - ByteOffsetForPartitionAlignment: ULONG, -}} -pub type PFILE_FS_SECTOR_SIZE_INFORMATION = *mut FILE_FS_SECTOR_SIZE_INFORMATION; -STRUCT!{struct FILE_FS_DATA_COPY_INFORMATION { - NumberOfCopies: ULONG, +STRUCT! {struct FILE_FS_SECTOR_SIZE_INFORMATION { + LogicalBytesPerSector: c_ulong, + PhysicalBytesPerSectorForAtomicity: c_ulong, + PhysicalBytesPerSectorForPerformance: c_ulong, + FileSystemEffectivePhysicalBytesPerSectorForAtomicity: c_ulong, + Flags: c_ulong, + ByteOffsetForSectorAlignment: c_ulong, + ByteOffsetForPartitionAlignment: c_ulong, +}} +pub type PFILE_FS_SECTOR_SIZE_INFORMATION = + *mut FILE_FS_SECTOR_SIZE_INFORMATION; +STRUCT! {struct FILE_FS_DATA_COPY_INFORMATION { + NumberOfCopies: c_ulong, }} pub type PFILE_FS_DATA_COPY_INFORMATION = *mut FILE_FS_DATA_COPY_INFORMATION; -STRUCT!{struct FILE_FS_METADATA_SIZE_INFORMATION { +STRUCT! {struct FILE_FS_METADATA_SIZE_INFORMATION { TotalMetadataAllocationUnits: LARGE_INTEGER, - SectorsPerAllocationUnit: ULONG, - BytesPerSector: ULONG, -}} -pub type PFILE_FS_METADATA_SIZE_INFORMATION = *mut FILE_FS_METADATA_SIZE_INFORMATION; -STRUCT!{struct FILE_FS_FULL_SIZE_INFORMATION_EX { - ActualTotalAllocationUnits: ULONGLONG, - ActualAvailableAllocationUnits: ULONGLONG, - ActualPoolUnavailableAllocationUnits: ULONGLONG, - CallerTotalAllocationUnits: ULONGLONG, - CallerAvailableAllocationUnits: ULONGLONG, - CallerPoolUnavailableAllocationUnits: ULONGLONG, - UsedAllocationUnits: ULONGLONG, - TotalReservedAllocationUnits: ULONGLONG, - VolumeStorageReserveAllocationUnits: ULONGLONG, - AvailableCommittedAllocationUnits: ULONGLONG, - PoolAvailableAllocationUnits: ULONGLONG, - SectorsPerAllocationUnit: ULONG, - BytesPerSector: ULONG, -}} -pub type PFILE_FS_FULL_SIZE_INFORMATION_EX = *mut FILE_FS_FULL_SIZE_INFORMATION_EX; -EXTERN!{extern "system" { + SectorsPerAllocationUnit: c_ulong, + BytesPerSector: c_ulong, +}} +pub type PFILE_FS_METADATA_SIZE_INFORMATION = + *mut FILE_FS_METADATA_SIZE_INFORMATION; +STRUCT! {struct FILE_FS_FULL_SIZE_INFORMATION_EX { + ActualTotalAllocationUnits: __uint64, + ActualAvailableAllocationUnits: __uint64, + ActualPoolUnavailableAllocationUnits: __uint64, + CallerTotalAllocationUnits: __uint64, + CallerAvailableAllocationUnits: __uint64, + CallerPoolUnavailableAllocationUnits: __uint64, + UsedAllocationUnits: __uint64, + TotalReservedAllocationUnits: __uint64, + VolumeStorageReserveAllocationUnits: __uint64, + AvailableCommittedAllocationUnits: __uint64, + PoolAvailableAllocationUnits: __uint64, + SectorsPerAllocationUnit: c_ulong, + BytesPerSector: c_ulong, +}} +pub type PFILE_FS_FULL_SIZE_INFORMATION_EX = + *mut FILE_FS_FULL_SIZE_INFORMATION_EX; +EXTERN! {extern "system" { fn NtCreateFile( - FileHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + FileHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, IoStatusBlock: PIO_STATUS_BLOCK, - AllocationSize: PLARGE_INTEGER, - FileAttributes: ULONG, - ShareAccess: ULONG, - CreateDisposition: ULONG, - CreateOptions: ULONG, - EaBuffer: PVOID, - EaLength: ULONG, + AllocationSize: *mut LARGE_INTEGER, + FileAttributes: c_ulong, + ShareAccess: c_ulong, + CreateDisposition: c_ulong, + CreateOptions: c_ulong, + EaBuffer: *mut c_void, + EaLength: c_ulong, ) -> NTSTATUS; fn NtCreateNamedPipeFile( - FileHandle: PHANDLE, - DesiredAccess: ULONG, - ObjectAttributes: POBJECT_ATTRIBUTES, + FileHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, IoStatusBlock: PIO_STATUS_BLOCK, - ShareAccess: ULONG, - CreateDisposition: ULONG, - CreateOptions: ULONG, - NamedPipeType: ULONG, - ReadMode: ULONG, - CompletionMode: ULONG, - MaximumInstances: ULONG, - InboundQuota: ULONG, - OutboundQuota: ULONG, - DefaultTimeout: PLARGE_INTEGER, + ShareAccess: c_ulong, + CreateDisposition: c_ulong, + CreateOptions: c_ulong, + NamedPipeType: c_ulong, + ReadMode: c_ulong, + CompletionMode: c_ulong, + MaximumInstances: c_ulong, + InboundQuota: c_ulong, + OutboundQuota: c_ulong, + DefaultTimeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn NtCreateMailslotFile( - FileHandle: PHANDLE, - DesiredAccess: ULONG, - ObjectAttributes: POBJECT_ATTRIBUTES, + FileHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, IoStatusBlock: PIO_STATUS_BLOCK, - CreateOptions: ULONG, - MailslotQuota: ULONG, - MaximumMessageSize: ULONG, - ReadTimeout: PLARGE_INTEGER, + CreateOptions: c_ulong, + MailslotQuota: c_ulong, + MaximumMessageSize: c_ulong, + ReadTimeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn NtOpenFile( - FileHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + FileHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, IoStatusBlock: PIO_STATUS_BLOCK, - ShareAccess: ULONG, - OpenOptions: ULONG, + ShareAccess: c_ulong, + OpenOptions: c_ulong, ) -> NTSTATUS; fn NtDeleteFile( - ObjectAttributes: POBJECT_ATTRIBUTES, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn NtFlushBuffersFile( FileHandle: HANDLE, @@ -952,91 +983,91 @@ EXTERN!{extern "system" { ) -> NTSTATUS; fn NtFlushBuffersFileEx( FileHandle: HANDLE, - Flags: ULONG, - Parameters: PVOID, - ParametersSize: ULONG, + Flags: c_ulong, + Parameters: *mut c_void, + ParametersSize: c_ulong, IoStatusBlock: PIO_STATUS_BLOCK, ) -> NTSTATUS; fn NtQueryInformationFile( FileHandle: HANDLE, IoStatusBlock: PIO_STATUS_BLOCK, - FileInformation: PVOID, - Length: ULONG, + FileInformation: *mut c_void, + Length: c_ulong, FileInformationClass: FILE_INFORMATION_CLASS, ) -> NTSTATUS; fn NtQueryInformationByName( - ObjectAttributes: POBJECT_ATTRIBUTES, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, IoStatusBlock: PIO_STATUS_BLOCK, - FileInformation: PVOID, - Length: ULONG, + FileInformation: *mut c_void, + Length: c_ulong, FileInformationClass: FILE_INFORMATION_CLASS, ) -> NTSTATUS; fn NtSetInformationFile( FileHandle: HANDLE, IoStatusBlock: PIO_STATUS_BLOCK, - FileInformation: PVOID, - Length: ULONG, + FileInformation: *mut c_void, + Length: c_ulong, FileInformationClass: FILE_INFORMATION_CLASS, ) -> NTSTATUS; fn NtQueryDirectoryFile( FileHandle: HANDLE, Event: HANDLE, ApcRoutine: PIO_APC_ROUTINE, - ApcContext: PVOID, + ApcContext: *mut c_void, IoStatusBlock: PIO_STATUS_BLOCK, - FileInformation: PVOID, - Length: ULONG, + FileInformation: *mut c_void, + Length: c_ulong, FileInformationClass: FILE_INFORMATION_CLASS, - ReturnSingleEntry: BOOLEAN, - FileName: PUNICODE_STRING, - RestartScan: BOOLEAN, + ReturnSingleEntry: c_uchar, + FileName: *mut UNICODE_STRING, + RestartScan: c_uchar, ) -> NTSTATUS; fn NtQueryEaFile( FileHandle: HANDLE, IoStatusBlock: PIO_STATUS_BLOCK, - Buffer: PVOID, - Length: ULONG, - ReturnSingleEntry: BOOLEAN, - EaList: PVOID, - EaListLength: ULONG, - EaIndex: PULONG, - RestartScan: BOOLEAN, + Buffer: *mut c_void, + Length: c_ulong, + ReturnSingleEntry: c_uchar, + EaList: *mut c_void, + EaListLength: c_ulong, + EaIndex: *mut c_ulong, + RestartScan: c_uchar, ) -> NTSTATUS; fn NtSetEaFile( FileHandle: HANDLE, IoStatusBlock: PIO_STATUS_BLOCK, - Buffer: PVOID, - Length: ULONG, + Buffer: *mut c_void, + Length: c_ulong, ) -> NTSTATUS; fn NtQueryQuotaInformationFile( FileHandle: HANDLE, IoStatusBlock: PIO_STATUS_BLOCK, - Buffer: PVOID, - Length: ULONG, - ReturnSingleEntry: BOOLEAN, - SidList: PVOID, - SidListLength: ULONG, + Buffer: *mut c_void, + Length: c_ulong, + ReturnSingleEntry: c_uchar, + SidList: *mut c_void, + SidListLength: c_ulong, StartSid: PSID, - RestartScan: BOOLEAN, + RestartScan: c_uchar, ) -> NTSTATUS; fn NtSetQuotaInformationFile( FileHandle: HANDLE, IoStatusBlock: PIO_STATUS_BLOCK, - Buffer: PVOID, - Length: ULONG, + Buffer: *mut c_void, + Length: c_ulong, ) -> NTSTATUS; fn NtQueryVolumeInformationFile( FileHandle: HANDLE, IoStatusBlock: PIO_STATUS_BLOCK, - FsInformation: PVOID, - Length: ULONG, + FsInformation: *mut c_void, + Length: c_ulong, FsInformationClass: FS_INFORMATION_CLASS, ) -> NTSTATUS; fn NtSetVolumeInformationFile( FileHandle: HANDLE, IoStatusBlock: PIO_STATUS_BLOCK, - FsInformation: PVOID, - Length: ULONG, + FsInformation: *mut c_void, + Length: c_ulong, FsInformationClass: FS_INFORMATION_CLASS, ) -> NTSTATUS; fn NtCancelIoFile( @@ -1057,193 +1088,194 @@ EXTERN!{extern "system" { FileHandle: HANDLE, Event: HANDLE, ApcRoutine: PIO_APC_ROUTINE, - ApcContext: PVOID, + ApcContext: *mut c_void, IoStatusBlock: PIO_STATUS_BLOCK, - IoControlCode: ULONG, - InputBuffer: PVOID, - InputBufferLength: ULONG, - OutputBuffer: PVOID, - OutputBufferLength: ULONG, + IoControlCode: c_ulong, + InputBuffer: *mut c_void, + InputBufferLength: c_ulong, + OutputBuffer: *mut c_void, + OutputBufferLength: c_ulong, ) -> NTSTATUS; fn NtFsControlFile( FileHandle: HANDLE, Event: HANDLE, ApcRoutine: PIO_APC_ROUTINE, - ApcContext: PVOID, + ApcContext: *mut c_void, IoStatusBlock: PIO_STATUS_BLOCK, - FsControlCode: ULONG, - InputBuffer: PVOID, - InputBufferLength: ULONG, - OutputBuffer: PVOID, - OutputBufferLength: ULONG, + FsControlCode: c_ulong, + InputBuffer: *mut c_void, + InputBufferLength: c_ulong, + OutputBuffer: *mut c_void, + OutputBufferLength: c_ulong, ) -> NTSTATUS; fn NtReadFile( FileHandle: HANDLE, Event: HANDLE, ApcRoutine: PIO_APC_ROUTINE, - ApcContext: PVOID, + ApcContext: *mut c_void, IoStatusBlock: PIO_STATUS_BLOCK, - Buffer: PVOID, - Length: ULONG, - ByteOffset: PLARGE_INTEGER, - Key: PULONG, + Buffer: *mut c_void, + Length: c_ulong, + ByteOffset: *mut LARGE_INTEGER, + Key: *mut c_ulong, ) -> NTSTATUS; fn NtWriteFile( FileHandle: HANDLE, Event: HANDLE, ApcRoutine: PIO_APC_ROUTINE, - ApcContext: PVOID, + ApcContext: *mut c_void, IoStatusBlock: PIO_STATUS_BLOCK, - Buffer: PVOID, - Length: ULONG, - ByteOffset: PLARGE_INTEGER, - Key: PULONG, + Buffer: *mut c_void, + Length: c_ulong, + ByteOffset: *mut LARGE_INTEGER, + Key: *mut c_ulong, ) -> NTSTATUS; fn NtReadFileScatter( FileHandle: HANDLE, Event: HANDLE, ApcRoutine: PIO_APC_ROUTINE, - ApcContext: PVOID, + ApcContext: *mut c_void, IoStatusBlock: PIO_STATUS_BLOCK, - SegmentArray: PFILE_SEGMENT_ELEMENT, - Length: ULONG, - ByteOffset: PLARGE_INTEGER, - Key: PULONG, + SegmentArray: *mut FILE_SEGMENT_ELEMENT, + Length: c_ulong, + ByteOffset: *mut LARGE_INTEGER, + Key: *mut c_ulong, ) -> NTSTATUS; fn NtWriteFileGather( FileHandle: HANDLE, Event: HANDLE, ApcRoutine: PIO_APC_ROUTINE, - ApcContext: PVOID, + ApcContext: *mut c_void, IoStatusBlock: PIO_STATUS_BLOCK, - SegmentArray: PFILE_SEGMENT_ELEMENT, - Length: ULONG, - ByteOffset: PLARGE_INTEGER, - Key: PULONG, + SegmentArray: *mut FILE_SEGMENT_ELEMENT, + Length: c_ulong, + ByteOffset: *mut LARGE_INTEGER, + Key: *mut c_ulong, ) -> NTSTATUS; fn NtLockFile( FileHandle: HANDLE, Event: HANDLE, ApcRoutine: PIO_APC_ROUTINE, - ApcContext: PVOID, + ApcContext: *mut c_void, IoStatusBlock: PIO_STATUS_BLOCK, - ByteOffset: PLARGE_INTEGER, - Length: PLARGE_INTEGER, - Key: ULONG, - FailImmediately: BOOLEAN, - ExclusiveLock: BOOLEAN, + ByteOffset: *mut LARGE_INTEGER, + Length: *mut LARGE_INTEGER, + Key: c_ulong, + FailImmediately: c_uchar, + ExclusiveLock: c_uchar, ) -> NTSTATUS; fn NtUnlockFile( FileHandle: HANDLE, IoStatusBlock: PIO_STATUS_BLOCK, - ByteOffset: PLARGE_INTEGER, - Length: PLARGE_INTEGER, - Key: ULONG, + ByteOffset: *mut LARGE_INTEGER, + Length: *mut LARGE_INTEGER, + Key: c_ulong, ) -> NTSTATUS; fn NtQueryAttributesFile( - ObjectAttributes: POBJECT_ATTRIBUTES, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, FileInformation: PFILE_BASIC_INFORMATION, ) -> NTSTATUS; fn NtQueryFullAttributesFile( - ObjectAttributes: POBJECT_ATTRIBUTES, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, FileInformation: PFILE_NETWORK_OPEN_INFORMATION, ) -> NTSTATUS; fn NtNotifyChangeDirectoryFile( FileHandle: HANDLE, Event: HANDLE, ApcRoutine: PIO_APC_ROUTINE, - ApcContext: PVOID, + ApcContext: *mut c_void, IoStatusBlock: PIO_STATUS_BLOCK, - Buffer: PVOID, - Length: ULONG, - CompletionFilter: ULONG, - WatchTree: BOOLEAN, + Buffer: *mut c_void, + Length: c_ulong, + CompletionFilter: c_ulong, + WatchTree: c_uchar, ) -> NTSTATUS; fn NtLoadDriver( - DriverServiceName: PUNICODE_STRING, + DriverServiceName: *mut UNICODE_STRING, ) -> NTSTATUS; fn NtUnloadDriver( - DriverServiceName: PUNICODE_STRING, + DriverServiceName: *mut UNICODE_STRING, ) -> NTSTATUS; }} pub const IO_COMPLETION_QUERY_STATE: u32 = 0x0001; -ENUM!{enum IO_COMPLETION_INFORMATION_CLASS { +ENUM! {enum IO_COMPLETION_INFORMATION_CLASS { IoCompletionBasicInformation = 0, }} -STRUCT!{struct IO_COMPLETION_BASIC_INFORMATION { - Depth: LONG, +STRUCT! {struct IO_COMPLETION_BASIC_INFORMATION { + Depth: c_long, }} -pub type PIO_COMPLETION_BASIC_INFORMATION = *mut IO_COMPLETION_BASIC_INFORMATION; -EXTERN!{extern "system" { +pub type PIO_COMPLETION_BASIC_INFORMATION = + *mut IO_COMPLETION_BASIC_INFORMATION; +EXTERN! {extern "system" { fn NtCreateIoCompletion( - IoCompletionHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - Count: ULONG, + IoCompletionHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + Count: c_ulong, ) -> NTSTATUS; fn NtOpenIoCompletion( - IoCompletionHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + IoCompletionHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn NtQueryIoCompletion( IoCompletionHandle: HANDLE, IoCompletionInformationClass: IO_COMPLETION_INFORMATION_CLASS, - IoCompletionInformation: PVOID, - IoCompletionInformationLength: ULONG, - ReturnLength: PULONG, + IoCompletionInformation: *mut c_void, + IoCompletionInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn NtSetIoCompletion( IoCompletionHandle: HANDLE, - KeyContext: PVOID, - ApcContext: PVOID, + KeyContext: *mut c_void, + ApcContext: *mut c_void, IoStatus: NTSTATUS, - IoStatusInformation: ULONG_PTR, + IoStatusInformation: usize, ) -> NTSTATUS; fn NtSetIoCompletionEx( IoCompletionHandle: HANDLE, IoCompletionPacketHandle: HANDLE, - KeyContext: PVOID, - ApcContext: PVOID, + KeyContext: *mut c_void, + ApcContext: *mut c_void, IoStatus: NTSTATUS, - IoStatusInformation: ULONG_PTR, + IoStatusInformation: usize, ) -> NTSTATUS; fn NtRemoveIoCompletion( IoCompletionHandle: HANDLE, - KeyContext: *mut PVOID, - ApcContext: *mut PVOID, + KeyContext: *mut *mut c_void, + ApcContext: *mut *mut c_void, IoStatusBlock: PIO_STATUS_BLOCK, - Timeout: PLARGE_INTEGER, + Timeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn NtRemoveIoCompletionEx( IoCompletionHandle: HANDLE, IoCompletionInformation: PFILE_IO_COMPLETION_INFORMATION, - Count: ULONG, - NumEntriesRemoved: PULONG, - Timeout: PLARGE_INTEGER, - Alertable: BOOLEAN, + Count: c_ulong, + NumEntriesRemoved: *mut c_ulong, + Timeout: *mut LARGE_INTEGER, + Alertable: c_uchar, ) -> NTSTATUS; fn NtCreateWaitCompletionPacket( - WaitCompletionPacketHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + WaitCompletionPacketHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn NtAssociateWaitCompletionPacket( WaitCompletionPacketHandle: HANDLE, IoCompletionHandle: HANDLE, TargetObjectHandle: HANDLE, - KeyContext: PVOID, - ApcContext: PVOID, + KeyContext: *mut c_void, + ApcContext: *mut c_void, IoStatus: NTSTATUS, - IoStatusInformation: ULONG_PTR, - AlreadySignaled: PBOOLEAN, + IoStatusInformation: usize, + AlreadySignaled: *mut c_uchar, ) -> NTSTATUS; fn NtCancelWaitCompletionPacket( WaitCompletionPacketHandle: HANDLE, - RemoveSignaledPacket: BOOLEAN, + RemoveSignaledPacket: c_uchar, ) -> NTSTATUS; }} -ENUM!{enum IO_SESSION_EVENT { +ENUM! {enum IO_SESSION_EVENT { IoSessionEventIgnore = 0, IoSessionEventCreated = 1, IoSessionEventTerminated = 2, @@ -1253,7 +1285,7 @@ ENUM!{enum IO_SESSION_EVENT { IoSessionEventLogoff = 6, IoSessionEventMax = 7, }} -ENUM!{enum IO_SESSION_STATE { +ENUM! {enum IO_SESSION_STATE { IoSessionStateCreated = 0, IoSessionStateInitialized = 1, IoSessionStateConnected = 2, @@ -1264,19 +1296,19 @@ ENUM!{enum IO_SESSION_STATE { IoSessionStateTerminated = 7, IoSessionStateMax = 8, }} -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtNotifyChangeSession( SessionHandle: HANDLE, - ChangeSequenceNumber: ULONG, - ChangeTimeStamp: PLARGE_INTEGER, + ChangeSequenceNumber: c_ulong, + ChangeTimeStamp: *mut LARGE_INTEGER, Event: IO_SESSION_EVENT, NewState: IO_SESSION_STATE, PreviousState: IO_SESSION_STATE, - Payload: PVOID, - PayloadSize: ULONG, + Payload: *mut c_void, + PayloadSize: c_ulong, ) -> NTSTATUS; }} -ENUM!{enum INTERFACE_TYPE { +ENUM! {enum INTERFACE_TYPE { InterfaceTypeUndefined = -1i32 as u32, Internal = 0, Isa = 1, @@ -1298,14 +1330,14 @@ ENUM!{enum INTERFACE_TYPE { MaximumInterfaceType = 17, }} pub type PINTERFACE_TYPE = *mut INTERFACE_TYPE; -ENUM!{enum DMA_WIDTH { +ENUM! {enum DMA_WIDTH { Width8Bits = 0, Width16Bits = 1, Width32Bits = 2, MaximumDmaWidth = 3, }} pub type PDMA_WIDTH = *mut DMA_WIDTH; -ENUM!{enum DMA_SPEED { +ENUM! {enum DMA_SPEED { Compatible = 0, TypeA = 1, TypeB = 2, @@ -1314,7 +1346,7 @@ ENUM!{enum DMA_SPEED { MaximumDmaSpeed = 5, }} pub type PDMA_SPEED = *mut DMA_SPEED; -ENUM!{enum BUS_DATA_TYPE { +ENUM! {enum BUS_DATA_TYPE { ConfigurationSpaceUndefined = -1i32 as u32, Cmos = 0, EisaConfiguration = 1, @@ -1332,40 +1364,41 @@ ENUM!{enum BUS_DATA_TYPE { }} pub type PBUS_DATA_TYPE = *mut BUS_DATA_TYPE; pub const SYMLINK_FLAG_RELATIVE: u32 = 1; -STRUCT!{struct REPARSE_DATA_BUFFER_u_SymbolicLinkReparseBuffer { - SubstituteNameOffset: USHORT, - SubstituteNameLength: USHORT, - PrintNameOffset: USHORT, - PrintNameLength: USHORT, - Flags: ULONG, - PathBuffer: [WCHAR; 1], -}} -STRUCT!{struct REPARSE_DATA_BUFFER_u_MountPointReparseBuffer { - SubstituteNameOffset: USHORT, - SubstituteNameLength: USHORT, - PrintNameOffset: USHORT, - PrintNameLength: USHORT, - PathBuffer: [WCHAR; 1], -}} -STRUCT!{struct REPARSE_DATA_BUFFER_u_GenericReparseBuffer { - DataBuffer: [UCHAR; 1], -}} -UNION!{union REPARSE_DATA_BUFFER_u { +STRUCT! {struct REPARSE_DATA_BUFFER_u_SymbolicLinkReparseBuffer { + SubstituteNameOffset: c_ushort, + SubstituteNameLength: c_ushort, + PrintNameOffset: c_ushort, + PrintNameLength: c_ushort, + Flags: c_ulong, + PathBuffer: [wchar_t; 1], +}} +STRUCT! {struct REPARSE_DATA_BUFFER_u_MountPointReparseBuffer { + SubstituteNameOffset: c_ushort, + SubstituteNameLength: c_ushort, + PrintNameOffset: c_ushort, + PrintNameLength: c_ushort, + PathBuffer: [wchar_t; 1], +}} +STRUCT! {struct REPARSE_DATA_BUFFER_u_GenericReparseBuffer { + DataBuffer: [c_uchar; 1], +}} +UNION! {union REPARSE_DATA_BUFFER_u { SymbolicLinkReparseBuffer: REPARSE_DATA_BUFFER_u_SymbolicLinkReparseBuffer, MountPointReparseBuffer: REPARSE_DATA_BUFFER_u_MountPointReparseBuffer, GenericReparseBuffer: REPARSE_DATA_BUFFER_u_GenericReparseBuffer, }} -STRUCT!{struct REPARSE_DATA_BUFFER { - ReparseTag: ULONG, - ReparseDataLength: USHORT, - Reserved: USHORT, +STRUCT! {struct REPARSE_DATA_BUFFER { + ReparseTag: c_ulong, + ReparseDataLength: c_ushort, + Reserved: c_ushort, u: REPARSE_DATA_BUFFER_u, }} pub type PREPARSE_DATA_BUFFER = *mut REPARSE_DATA_BUFFER; /// "\Device\NamedPipe\" pub const DEVICE_NAMED_PIPE: UTF16Const = UTF16Const(&[ - 0x005C, 0x0044, 0x0065, 0x0076, 0x0069, 0x0063, 0x0065, 0x005C, 0x004E, 0x0061, 0x006D, 0x0065, - 0x0064, 0x0050, 0x0069, 0x0070, 0x0065, 0x005C, 0u16, + 0x005C, 0x0044, 0x0065, 0x0076, 0x0069, 0x0063, 0x0065, 0x005C, 0x004E, + 0x0061, 0x006D, 0x0065, 0x0064, 0x0050, 0x0069, 0x0070, 0x0065, 0x005C, + 0u16, ]); pub const FSCTL_PIPE_ASSIGN_EVENT: u32 = CTL_CODE(FILE_DEVICE_NAMED_PIPE, 0, METHOD_BUFFERED, FILE_ANY_ACCESS); @@ -1377,8 +1410,12 @@ pub const FSTL_PIPE_PEEK: u32 = CTL_CODE(FILE_DEVICE_NAMED_PIPE, 3, METHOD_BUFFERED, FILE_READ_DATA); pub const FSTL_PIPE_QUERY_EVENT: u32 = CTL_CODE(FILE_DEVICE_NAMED_PIPE, 4, METHOD_BUFFERED, FILE_ANY_ACCESS); -pub const FSTL_PIPE_TRANSCEIVE: u32 = - CTL_CODE(FILE_DEVICE_NAMED_PIPE, 5, METHOD_NEITHER, FILE_READ_DATA | FILE_WRITE_DATA); +pub const FSTL_PIPE_TRANSCEIVE: u32 = CTL_CODE( + FILE_DEVICE_NAMED_PIPE, + 5, + METHOD_NEITHER, + FILE_READ_DATA | FILE_WRITE_DATA, +); pub const FSTL_PIPE_WAIT: u32 = CTL_CODE(FILE_DEVICE_NAMED_PIPE, 6, METHOD_BUFFERED, FILE_ANY_ACCESS); pub const FSTL_PIPE_IMPERSONATE: u32 = @@ -1401,64 +1438,82 @@ pub const FSTL_PIPE_SET_HANDLE_ATTRIBUTE: u32 = CTL_CODE(FILE_DEVICE_NAMED_PIPE, 15, METHOD_BUFFERED, FILE_ANY_ACCESS); pub const FSTL_PIPE_FLUSH: u32 = CTL_CODE(FILE_DEVICE_NAMED_PIPE, 16, METHOD_BUFFERED, FILE_WRITE_DATA); -pub const FSTL_PIPE_INTERNAL_READ: u32 = - CTL_CODE(FILE_DEVICE_NAMED_PIPE, 2045, METHOD_BUFFERED, FILE_READ_DATA); -pub const FSTL_PIPE_INTERNAL_WRITE: u32 = - CTL_CODE(FILE_DEVICE_NAMED_PIPE, 2046, METHOD_BUFFERED, FILE_WRITE_DATA); -pub const FSTL_PIPE_INTERNAL_TRANSCEIVE: u32 = - CTL_CODE(FILE_DEVICE_NAMED_PIPE, 2047, METHOD_NEITHER, FILE_READ_DATA | FILE_WRITE_DATA); -pub const FSTL_PIPE_INTERNAL_READ_OVFLOW: u32 = - CTL_CODE(FILE_DEVICE_NAMED_PIPE, 2048, METHOD_BUFFERED, FILE_READ_DATA); +pub const FSTL_PIPE_INTERNAL_READ: u32 = CTL_CODE( + FILE_DEVICE_NAMED_PIPE, + 2045, + METHOD_BUFFERED, + FILE_READ_DATA, +); +pub const FSTL_PIPE_INTERNAL_WRITE: u32 = CTL_CODE( + FILE_DEVICE_NAMED_PIPE, + 2046, + METHOD_BUFFERED, + FILE_WRITE_DATA, +); +pub const FSTL_PIPE_INTERNAL_TRANSCEIVE: u32 = CTL_CODE( + FILE_DEVICE_NAMED_PIPE, + 2047, + METHOD_NEITHER, + FILE_READ_DATA | FILE_WRITE_DATA, +); +pub const FSTL_PIPE_INTERNAL_READ_OVFLOW: u32 = CTL_CODE( + FILE_DEVICE_NAMED_PIPE, + 2048, + METHOD_BUFFERED, + FILE_READ_DATA, +); pub const FILE_PIPE_READ_DATA: u32 = 0x00000000; pub const FILE_PIPE_WRITE_SPACE: u32 = 0x00000001; -STRUCT!{struct FILE_PIPE_ASSIGN_EVENT_BUFFER { +STRUCT! {struct FILE_PIPE_ASSIGN_EVENT_BUFFER { EventHandle: HANDLE, - KeyValue: ULONG, + KeyValue: c_ulong, }} pub type PFILE_PIPE_ASSIGN_EVENT_BUFFER = *mut FILE_PIPE_ASSIGN_EVENT_BUFFER; -STRUCT!{struct FILE_PIPE_PEEK_BUFFER { - NamedPipeState: ULONG, - ReadDataAvailable: ULONG, - NumberOfMessages: ULONG, - MessageLength: ULONG, - Data: [CHAR; 1], +STRUCT! {struct FILE_PIPE_PEEK_BUFFER { + NamedPipeState: c_ulong, + ReadDataAvailable: c_ulong, + NumberOfMessages: c_ulong, + MessageLength: c_ulong, + Data: [c_char; 1], }} pub type PFILE_PIPE_PEEK_BUFFER = *mut FILE_PIPE_PEEK_BUFFER; -STRUCT!{struct FILE_PIPE_EVENT_BUFFER { - NamedPipeState: ULONG, - EntryType: ULONG, - ByteCount: ULONG, - KeyValue: ULONG, - NumberRequests: ULONG, +STRUCT! {struct FILE_PIPE_EVENT_BUFFER { + NamedPipeState: c_ulong, + EntryType: c_ulong, + ByteCount: c_ulong, + KeyValue: c_ulong, + NumberRequests: c_ulong, }} pub type PFILE_PIPE_EVENT_BUFFER = *mut FILE_PIPE_EVENT_BUFFER; -STRUCT!{struct FILE_PIPE_WAIT_FOR_BUFFER { +STRUCT! {struct FILE_PIPE_WAIT_FOR_BUFFER { Timeout: LARGE_INTEGER, - NameLength: ULONG, - TimeoutSpecified: BOOLEAN, - Name: [WCHAR; 1], + NameLength: c_ulong, + TimeoutSpecified: c_uchar, + Name: [wchar_t; 1], }} pub type PFILE_PIPE_WAIT_FOR_BUFFER = *mut FILE_PIPE_WAIT_FOR_BUFFER; -STRUCT!{struct FILE_PIPE_CLIENT_PROCESS_BUFFER { - ClientSession: PVOID, - ClientProcess: PVOID, +STRUCT! {struct FILE_PIPE_CLIENT_PROCESS_BUFFER { + ClientSession: *mut c_void, + ClientProcess: *mut c_void, }} -pub type PFILE_PIPE_CLIENT_PROCESS_BUFFER = *mut FILE_PIPE_CLIENT_PROCESS_BUFFER; +pub type PFILE_PIPE_CLIENT_PROCESS_BUFFER = + *mut FILE_PIPE_CLIENT_PROCESS_BUFFER; pub const FILE_PIPE_COMPUTER_NAME_LENGTH: usize = 15; -STRUCT!{struct FILE_PIPE_CLIENT_PROCESS_BUFFER_EX { - ClientSession: PVOID, - ClientProcess: PVOID, - ClientComputerNameLength: USHORT, - ClientComputerBuffer: [WCHAR; FILE_PIPE_COMPUTER_NAME_LENGTH + 1], -}} -pub type PFILE_PIPE_CLIENT_PROCESS_BUFFER_EX = *mut FILE_PIPE_CLIENT_PROCESS_BUFFER_EX; +STRUCT! {struct FILE_PIPE_CLIENT_PROCESS_BUFFER_EX { + ClientSession: *mut c_void, + ClientProcess: *mut c_void, + ClientComputerNameLength: c_ushort, + ClientComputerBuffer: [wchar_t; FILE_PIPE_COMPUTER_NAME_LENGTH + 1], +}} +pub type PFILE_PIPE_CLIENT_PROCESS_BUFFER_EX = + *mut FILE_PIPE_CLIENT_PROCESS_BUFFER_EX; pub const MAILSLOT_CLASS_FIRSTCLASS: u32 = 1; pub const MAILSLOT_CLASS_SECONDCLASS: u32 = 2; pub const FSCTL_MAILSLOT_PEEK: u32 = CTL_CODE(FILE_DEVICE_MAILSLOT, 0, METHOD_NEITHER, FILE_READ_DATA); -STRUCT!{struct FILE_MAILSLOT_PEEK_BUFFER { - ReadDataAvailable: ULONG, - NumberOfMessages: ULONG, - MessageLength: ULONG, +STRUCT! {struct FILE_MAILSLOT_PEEK_BUFFER { + ReadDataAvailable: c_ulong, + NumberOfMessages: c_ulong, + MessageLength: c_ulong, }} pub type PFILE_MAILSLOT_PEEK_BUFFER = *mut FILE_MAILSLOT_PEEK_BUFFER; diff --git a/src/ntkeapi.rs b/src/ntkeapi.rs index a26f39b..ad480c0 100644 --- a/src/ntkeapi.rs +++ b/src/ntkeapi.rs @@ -1,9 +1,12 @@ -use winapi::shared::ntdef::{BOOLEAN, NTSTATUS, PVOID, ULONG}; +use windows_sys::Win32::Foundation::NTSTATUS; + +use crate::ctypes::{c_uchar, c_ulong, c_void}; + pub const LOW_PRIORITY: u32 = 0; pub const LOW_REALTIME_PRIORITY: u32 = 16; pub const HIGH_PRIORITY: u32 = 31; pub const MAXIMUM_PRIORITY: u32 = 32; -ENUM!{enum KTHREAD_STATE { +ENUM! {enum KTHREAD_STATE { Initialized = 0, Ready = 1, Running = 2, @@ -17,7 +20,7 @@ ENUM!{enum KTHREAD_STATE { MaximumThreadState = 10, }} pub type PKTHREAD_STATE = *mut KTHREAD_STATE; -ENUM!{enum KHETERO_CPU_POLICY { +ENUM! {enum KHETERO_CPU_POLICY { KHeteroCpuPolicyAll = 0, KHeteroCpuPolicyLarge = 1, KHeteroCpuPolicyLargeOrIdle = 2, @@ -31,7 +34,7 @@ ENUM!{enum KHETERO_CPU_POLICY { KHeteroCpuPolicyMax = 10, }} pub type PKHETERO_CPU_POLICY = *mut KHETERO_CPU_POLICY; -ENUM!{enum KWAIT_REASON { +ENUM! {enum KWAIT_REASON { Executive = 0, FreePage = 1, PageIn = 2, @@ -74,7 +77,7 @@ ENUM!{enum KWAIT_REASON { MaximumWaitReason = 39, }} pub type PKWAIT_REASON = *mut KWAIT_REASON; -ENUM!{enum KPROFILE_SOURCE { +ENUM! {enum KPROFILE_SOURCE { ProfileTime = 0, ProfileAlignmentFixup = 1, ProfileTotalIssues = 2, @@ -101,21 +104,21 @@ ENUM!{enum KPROFILE_SOURCE { ProfileLoadLinkedIssues = 23, ProfileMaximum = 24, }} -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtCallbackReturn( - OutputBuffer: PVOID, - OutputLength: ULONG, + OutputBuffer: *mut c_void, + OutputLength: c_ulong, Status: NTSTATUS, ) -> NTSTATUS; fn NtFlushProcessWriteBuffers(); fn NtQueryDebugFilterState( - ComponentId: ULONG, - Level: ULONG, + ComponentId: c_ulong, + Level: c_ulong, ) -> NTSTATUS; fn NtSetDebugFilterState( - ComponentId: ULONG, - Level: ULONG, - State: BOOLEAN, + ComponentId: c_ulong, + Level: c_ulong, + State: c_uchar, ) -> NTSTATUS; fn NtYieldExecution() -> NTSTATUS; }} diff --git a/src/ntldr.rs b/src/ntldr.rs index 4b4bcb6..7745843 100644 --- a/src/ntldr.rs +++ b/src/ntldr.rs @@ -1,30 +1,42 @@ -use winapi::shared::basetsd::{LONG_PTR, PSIZE_T, SIZE_T, ULONG_PTR}; -use winapi::shared::ntdef::{ - BOOLEAN, HANDLE, LARGE_INTEGER, LIST_ENTRY, LONG, LONGLONG, NTSTATUS, PANSI_STRING, PCSTR, - PCUNICODE_STRING, PCWSTR, PHANDLE, POBJECT_ATTRIBUTES, PSINGLE_LIST_ENTRY, PSTR, PULONG, - PUNICODE_STRING, PUSHORT, PVOID, PWSTR, RTL_BALANCED_NODE, SINGLE_LIST_ENTRY, UCHAR, ULONG, - UNICODE_STRING, USHORT, +use windows_sys::Win32::{ + Foundation::{HANDLE, NTSTATUS, UNICODE_STRING}, + System::{ + Kernel::{LIST_ENTRY, RTL_BALANCED_NODE, SINGLE_LIST_ENTRY, STRING}, + SystemServices::{ + IMAGE_BASE_RELOCATION, IMAGE_IMPORT_DESCRIPTOR, + IMAGE_RESOURCE_DATA_ENTRY, IMAGE_RESOURCE_DIRECTORY, + IMAGE_RESOURCE_DIRECTORY_ENTRY, IMAGE_RESOURCE_DIRECTORY_STRING, + }, + WindowsProgramming::{ + IMAGE_DELAYLOAD_DESCRIPTOR, IMAGE_THUNK_DATA64, OBJECT_ATTRIBUTES, + }, + }, }; -use winapi::um::winnt::{ - ACCESS_MASK, ACTIVATION_CONTEXT, IMAGE_RESOURCE_DIRECTORY_ENTRY, PCIMAGE_DELAYLOAD_DESCRIPTOR, - PIMAGE_BASE_RELOCATION, PIMAGE_IMPORT_DESCRIPTOR, PIMAGE_RESOURCE_DATA_ENTRY, - PIMAGE_RESOURCE_DIRECTORY, PIMAGE_RESOURCE_DIRECTORY_STRING, PIMAGE_THUNK_DATA, + +use crate::{ + ctypes::{ + __int64, c_char, c_long, c_uchar, c_ulong, c_ushort, c_void, wchar_t, + }, + windows_local::{ + shared::ntdef::LARGE_INTEGER, um::winnt::ACTIVATION_CONTEXT, + }, }; -FN!{stdcall PLDR_INIT_ROUTINE( - DllHandle: PVOID, - Reason: ULONG, - Context: PVOID, -) -> BOOLEAN} -STRUCT!{struct LDR_SERVICE_TAG_RECORD { + +FN! {stdcall PLDR_INIT_ROUTINE( + DllHandle: *mut c_void, + Reason: c_ulong, + Context: *mut c_void, +) -> c_uchar} +STRUCT! {struct LDR_SERVICE_TAG_RECORD { Next: *mut LDR_SERVICE_TAG_RECORD, - ServiceTag: ULONG, + ServiceTag: c_ulong, }} pub type PLDR_SERVICE_TAG_RECORD = *mut LDR_SERVICE_TAG_RECORD; -STRUCT!{struct LDRP_CSLIST { - Tail: PSINGLE_LIST_ENTRY, +STRUCT! {struct LDRP_CSLIST { + Tail: *mut SINGLE_LIST_ENTRY, }} pub type PLDRP_CSLIST = *mut LDRP_CSLIST; -ENUM!{enum LDR_DDAG_STATE { +ENUM! {enum LDR_DDAG_STATE { LdrModulesMerged = -5i32 as u32, LdrModulesInitError = -4i32 as u32, LdrModulesSnapError = -3i32 as u32, @@ -41,31 +53,31 @@ ENUM!{enum LDR_DDAG_STATE { LdrModulesInitializing = 8, LdrModulesReadyToRun = 9, }} -UNION!{union LDR_DDAG_NODE_u { +UNION! {union LDR_DDAG_NODE_u { Dependencies: LDRP_CSLIST, RemovalLink: SINGLE_LIST_ENTRY, }} -STRUCT!{struct LDR_DDAG_NODE { +STRUCT! {struct LDR_DDAG_NODE { Modules: LIST_ENTRY, ServiceTagList: PLDR_SERVICE_TAG_RECORD, - LoadCount: ULONG, - LoadWhileUnloadingCount: ULONG, - LowestLink: ULONG, + LoadCount: c_ulong, + LoadWhileUnloadingCount: c_ulong, + LowestLink: c_ulong, u: LDR_DDAG_NODE_u, IncomingDependencies: LDRP_CSLIST, State: LDR_DDAG_STATE, CondenseLink: SINGLE_LIST_ENTRY, - PreorderNumber: ULONG, + PreorderNumber: c_ulong, }} pub type PLDR_DDAG_NODE = *mut LDR_DDAG_NODE; -STRUCT!{struct LDR_DEPENDENCY_RECORD { +STRUCT! {struct LDR_DEPENDENCY_RECORD { DependencyLink: SINGLE_LIST_ENTRY, DependencyNode: PLDR_DDAG_NODE, IncomingDependencyLink: SINGLE_LIST_ENTRY, IncomingDependencyNode: PLDR_DDAG_NODE, }} pub type PLDR_DEPENDENCY_RECORD = *mut LDR_DEPENDENCY_RECORD; -ENUM!{enum LDR_DLL_LOAD_REASON { +ENUM! {enum LDR_DLL_LOAD_REASON { LoadReasonStaticDependency = 0, LoadReasonStaticForwarderDependency = 1, LoadReasonDynamicForwarderDependency = 2, @@ -78,90 +90,90 @@ ENUM!{enum LDR_DLL_LOAD_REASON { LoadReasonUnknown = -1i32 as u32, }} pub type PLDR_DLL_LOAD_REASON = *mut LDR_DLL_LOAD_REASON; -pub const LDRP_PACKAGED_BINARY: ULONG = 0x00000001; -pub const LDRP_STATIC_LINK: ULONG = 0x00000002; -pub const LDRP_IMAGE_DLL: ULONG = 0x00000004; -pub const LDRP_LOAD_IN_PROGRESS: ULONG = 0x00001000; -pub const LDRP_UNLOAD_IN_PROGRESS: ULONG = 0x00002000; -pub const LDRP_ENTRY_PROCESSED: ULONG = 0x00004000; -pub const LDRP_ENTRY_INSERTED: ULONG = 0x00008000; -pub const LDRP_CURRENT_LOAD: ULONG = 0x00010000; -pub const LDRP_FAILED_BUILTIN_LOAD: ULONG = 0x00020000; -pub const LDRP_DONT_CALL_FOR_THREADS: ULONG = 0x00040000; -pub const LDRP_PROCESS_ATTACH_CALLED: ULONG = 0x00080000; -pub const LDRP_DEBUG_SYMBOLS_LOADED: ULONG = 0x00100000; -pub const LDRP_IMAGE_NOT_AT_BASE: ULONG = 0x00200000; -pub const LDRP_COR_IMAGE: ULONG = 0x00400000; -pub const LDRP_DONT_RELOCATE: ULONG = 0x00800000; -pub const LDRP_SYSTEM_MAPPED: ULONG = 0x01000000; -pub const LDRP_IMAGE_VERIFYING: ULONG = 0x02000000; -pub const LDRP_DRIVER_DEPENDENT_DLL: ULONG = 0x04000000; -pub const LDRP_ENTRY_NATIVE: ULONG = 0x08000000; -pub const LDRP_REDIRECTED: ULONG = 0x10000000; -pub const LDRP_NON_PAGED_DEBUG_INFO: ULONG = 0x20000000; -pub const LDRP_MM_LOADED: ULONG = 0x40000000; -pub const LDRP_COMPAT_DATABASE_PROCESSED: ULONG = 0x80000000; -STRUCT!{struct LDRP_LOAD_CONTEXT { +pub const LDRP_PACKAGED_BINARY: c_ulong = 0x00000001; +pub const LDRP_STATIC_LINK: c_ulong = 0x00000002; +pub const LDRP_IMAGE_DLL: c_ulong = 0x00000004; +pub const LDRP_LOAD_IN_PROGRESS: c_ulong = 0x00001000; +pub const LDRP_UNLOAD_IN_PROGRESS: c_ulong = 0x00002000; +pub const LDRP_ENTRY_PROCESSED: c_ulong = 0x00004000; +pub const LDRP_ENTRY_INSERTED: c_ulong = 0x00008000; +pub const LDRP_CURRENT_LOAD: c_ulong = 0x00010000; +pub const LDRP_FAILED_BUILTIN_LOAD: c_ulong = 0x00020000; +pub const LDRP_DONT_CALL_FOR_THREADS: c_ulong = 0x00040000; +pub const LDRP_PROCESS_ATTACH_CALLED: c_ulong = 0x00080000; +pub const LDRP_DEBUG_SYMBOLS_LOADED: c_ulong = 0x00100000; +pub const LDRP_IMAGE_NOT_AT_BASE: c_ulong = 0x00200000; +pub const LDRP_COR_IMAGE: c_ulong = 0x00400000; +pub const LDRP_DONT_RELOCATE: c_ulong = 0x00800000; +pub const LDRP_SYSTEM_MAPPED: c_ulong = 0x01000000; +pub const LDRP_IMAGE_VERIFYING: c_ulong = 0x02000000; +pub const LDRP_DRIVER_DEPENDENT_DLL: c_ulong = 0x04000000; +pub const LDRP_ENTRY_NATIVE: c_ulong = 0x08000000; +pub const LDRP_REDIRECTED: c_ulong = 0x10000000; +pub const LDRP_NON_PAGED_DEBUG_INFO: c_ulong = 0x20000000; +pub const LDRP_MM_LOADED: c_ulong = 0x40000000; +pub const LDRP_COMPAT_DATABASE_PROCESSED: c_ulong = 0x80000000; +STRUCT! {struct LDRP_LOAD_CONTEXT { BaseDllName: UNICODE_STRING, - somestruct: PVOID, - Flags: ULONG, + somestruct: *mut c_void, + Flags: c_ulong, pstatus: *mut NTSTATUS, ParentEntry: *mut LDR_DATA_TABLE_ENTRY, Entry: *mut LDR_DATA_TABLE_ENTRY, WorkQueueListEntry: LIST_ENTRY, ReplacedEntry: *mut LDR_DATA_TABLE_ENTRY, pvImports: *mut *mut LDR_DATA_TABLE_ENTRY, - ImportDllCount: ULONG, - TaskCount: LONG, - pvIAT: PVOID, - SizeOfIAT: ULONG, - CurrentDll: ULONG, - piid: PIMAGE_IMPORT_DESCRIPTOR, - OriginalIATProtect: ULONG, - GuardCFCheckFunctionPointer: PVOID, - pGuardCFCheckFunctionPointer: *mut PVOID, -}} -UNION!{union LDR_DATA_TABLE_ENTRY_u1 { + ImportDllCount: c_ulong, + TaskCount: c_long, + pvIAT: *mut c_void, + SizeOfIAT: c_ulong, + CurrentDll: c_ulong, + piid: *mut IMAGE_IMPORT_DESCRIPTOR, + OriginalIATProtect: c_ulong, + GuardCFCheckFunctionPointer: *mut c_void, + pGuardCFCheckFunctionPointer: *mut *mut c_void, +}} +UNION! {union LDR_DATA_TABLE_ENTRY_u1 { InInitializationOrderLinks: LIST_ENTRY, InProgressLinks: LIST_ENTRY, }} -UNION!{union LDR_DATA_TABLE_ENTRY_u2 { - FlagGroup: [UCHAR; 4], - Flags: ULONG, +UNION! {union LDR_DATA_TABLE_ENTRY_u2 { + FlagGroup: [c_uchar; 4], + Flags: c_ulong, }} -STRUCT!{struct LDR_DATA_TABLE_ENTRY { +STRUCT! {struct LDR_DATA_TABLE_ENTRY { InLoadOrderLinks: LIST_ENTRY, InMemoryOrderLinks: LIST_ENTRY, u1: LDR_DATA_TABLE_ENTRY_u1, - DllBase: PVOID, + DllBase: *mut c_void, EntryPoint: PLDR_INIT_ROUTINE, - SizeOfImage: ULONG, + SizeOfImage: c_ulong, FullDllName: UNICODE_STRING, BaseDllName: UNICODE_STRING, u2: LDR_DATA_TABLE_ENTRY_u2, - ObsoleteLoadCount: USHORT, - TlsIndex: USHORT, + ObsoleteLoadCount: c_ushort, + TlsIndex: c_ushort, HashLinks: LIST_ENTRY, - TimeDateStamp: ULONG, + TimeDateStamp: c_ulong, EntryPointActivationContext: *mut ACTIVATION_CONTEXT, - Lock: PVOID, + Lock: *mut c_void, DdagNode: PLDR_DDAG_NODE, NodeModuleLink: LIST_ENTRY, LoadContext: *mut LDRP_LOAD_CONTEXT, - ParentDllBase: PVOID, - SwitchBackContext: PVOID, + ParentDllBase: *mut c_void, + SwitchBackContext: *mut c_void, BaseAddressIndexNode: RTL_BALANCED_NODE, MappingInfoIndexNode: RTL_BALANCED_NODE, - OriginalBase: ULONG_PTR, + OriginalBase: usize, LoadTime: LARGE_INTEGER, - BaseNameHashValue: ULONG, + BaseNameHashValue: c_ulong, LoadReason: LDR_DLL_LOAD_REASON, - ImplicitPathOptions: ULONG, - ReferenceCount: ULONG, - DependentLoadFlags: ULONG, - SigningLevel: UCHAR, + ImplicitPathOptions: c_ulong, + ReferenceCount: c_ulong, + DependentLoadFlags: c_ulong, + SigningLevel: c_uchar, }} -BITFIELD!{unsafe LDR_DATA_TABLE_ENTRY_u2 Flags: ULONG [ +BITFIELD! {unsafe LDR_DATA_TABLE_ENTRY_u2 Flags: c_ulong [ PackagedBinary set_PackagedBinary[0..1], MarkedForRemoval set_MarkedForRemoval[1..2], ImageDll set_ImageDll[2..3], @@ -192,470 +204,479 @@ BITFIELD!{unsafe LDR_DATA_TABLE_ENTRY_u2 Flags: ULONG [ ]} pub type PLDR_DATA_TABLE_ENTRY = *mut LDR_DATA_TABLE_ENTRY; #[inline] -pub const fn LDR_IS_DATAFILE(DllHandle: ULONG_PTR) -> bool { +pub const fn LDR_IS_DATAFILE(DllHandle: usize) -> bool { DllHandle & 1 != 0 } #[inline] -pub const fn LDR_IS_IMAGEMAPPING(DllHandle: ULONG_PTR) -> bool { +pub const fn LDR_IS_IMAGEMAPPING(DllHandle: usize) -> bool { DllHandle & 2 != 0 } #[inline] -pub const fn LDR_IS_RESOURCE(DllHandle: ULONG_PTR) -> bool { +pub const fn LDR_IS_RESOURCE(DllHandle: usize) -> bool { LDR_IS_IMAGEMAPPING(DllHandle) || LDR_IS_DATAFILE(DllHandle) } -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn LdrLoadDll( - DllPath: PWSTR, - DllCharacteristics: PULONG, - DllName: PUNICODE_STRING, - DllHandle: *mut PVOID, + DllPath: *mut wchar_t, + DllCharacteristics: *mut c_ulong, + DllName: *mut UNICODE_STRING, + DllHandle: *mut *mut c_void, ) -> NTSTATUS; fn LdrUnloadDll( - DllHandle: PVOID, + DllHandle: *mut c_void, ) -> NTSTATUS; fn LdrGetDllHandle( - DllPath: PWSTR, - DllCharacteristics: PULONG, - DllName: PUNICODE_STRING, - DllHandle: *mut PVOID, + DllPath: *mut wchar_t, + DllCharacteristics: *mut c_ulong, + DllName: *mut UNICODE_STRING, + DllHandle: *mut *mut c_void, ) -> NTSTATUS; }} -pub const LDR_GET_DLL_HANDLE_EX_UNCHANGED_REFCOUNT: ULONG = 0x00000001; -pub const LDR_GET_DLL_HANDLE_EX_PIN: ULONG = 0x00000002; -EXTERN!{extern "system" { +pub const LDR_GET_DLL_HANDLE_EX_UNCHANGED_REFCOUNT: c_ulong = 0x00000001; +pub const LDR_GET_DLL_HANDLE_EX_PIN: c_ulong = 0x00000002; +EXTERN! {extern "system" { fn LdrGetDllHandleEx( - Flags: ULONG, - DllPath: PWSTR, - DllCharacteristics: PULONG, - DllName: PUNICODE_STRING, - DllHandle: *mut PVOID, + Flags: c_ulong, + DllPath: *mut wchar_t, + DllCharacteristics: *mut c_ulong, + DllName: *mut UNICODE_STRING, + DllHandle: *mut *mut c_void, ) -> NTSTATUS; fn LdrGetDllHandleByMapping( - BaseAddress: PVOID, - DllHandle: *mut PVOID, + BaseAddress: *mut c_void, + DllHandle: *mut *mut c_void, ) -> NTSTATUS; fn LdrGetDllHandleByName( - BaseDllName: PUNICODE_STRING, - FullDllName: PUNICODE_STRING, - DllHandle: *mut PVOID, + BaseDllName: *mut UNICODE_STRING, + FullDllName: *mut UNICODE_STRING, + DllHandle: *mut *mut c_void, ) -> NTSTATUS; fn LdrGetDllFullName( - DllHandle: PVOID, - FullDllName: PUNICODE_STRING, + DllHandle: *mut c_void, + FullDllName: *mut UNICODE_STRING, ) -> NTSTATUS; fn LdrGetDllDirectory( - DllDirectory: PUNICODE_STRING, + DllDirectory: *mut UNICODE_STRING, ) -> NTSTATUS; fn LdrSetDllDirectory( - DllDirectory: PUNICODE_STRING, + DllDirectory: *mut UNICODE_STRING, ) -> NTSTATUS; }} -pub const LDR_ADDREF_DLL_PIN: ULONG = 0x00000001; -EXTERN!{extern "system" { +pub const LDR_ADDREF_DLL_PIN: c_ulong = 0x00000001; +EXTERN! {extern "system" { fn LdrAddRefDll( - Flags: ULONG, - DllHandle: PVOID, + Flags: c_ulong, + DllHandle: *mut c_void, ) -> NTSTATUS; fn LdrGetProcedureAddress( - DllHandle: PVOID, - ProcedureName: PANSI_STRING, - ProcedureNumber: ULONG, - ProcedureAddress: *mut PVOID, + DllHandle: *mut c_void, + ProcedureName: *mut STRING, + ProcedureNumber: c_ulong, + ProcedureAddress: *mut *mut c_void, ) -> NTSTATUS; }} -pub const LDR_GET_PROCEDURE_ADDRESS_DONT_RECORD_FORWARDER: ULONG = 0x00000001; -EXTERN!{extern "system" { +pub const LDR_GET_PROCEDURE_ADDRESS_DONT_RECORD_FORWARDER: c_ulong = 0x00000001; +EXTERN! {extern "system" { fn LdrGetProcedureAddressEx( - DllHandle: PVOID, - ProcedureName: PANSI_STRING, - ProcedureNumber: ULONG, - ProcedureAddress: *mut PVOID, - Flags: ULONG, + DllHandle: *mut c_void, + ProcedureName: *mut STRING, + ProcedureNumber: c_ulong, + ProcedureAddress: *mut *mut c_void, + Flags: c_ulong, ) -> NTSTATUS; fn LdrGetKnownDllSectionHandle( - DllName: PCWSTR, - KnownDlls32: BOOLEAN, - Section: PHANDLE, + DllName: *const wchar_t, + KnownDlls32: c_uchar, + Section: *mut HANDLE, ) -> NTSTATUS; fn LdrGetProcedureAddressForCaller( - DllHandle: PVOID, - ProcedureName: PANSI_STRING, - ProcedureNumber: ULONG, - ProcedureAddress: *mut PVOID, - Flags: ULONG, - Callback: *mut PVOID, - ) -> NTSTATUS; -}} -pub const LDR_LOCK_LOADER_LOCK_FLAG_RAISE_ON_ERRORS: ULONG = 0x00000001; -pub const LDR_LOCK_LOADER_LOCK_FLAG_TRY_ONLY: ULONG = 0x00000002; -pub const LDR_LOCK_LOADER_LOCK_DISPOSITION_INVALID: ULONG = 0; -pub const LDR_LOCK_LOADER_LOCK_DISPOSITION_LOCK_ACQUIRED: ULONG = 1; -pub const LDR_LOCK_LOADER_LOCK_DISPOSITION_LOCK_NOT_ACQUIRED: ULONG = 2; -EXTERN!{extern "system" { + DllHandle: *mut c_void, + ProcedureName: *mut STRING, + ProcedureNumber: c_ulong, + ProcedureAddress: *mut *mut c_void, + Flags: c_ulong, + Callback: *mut *mut c_void, + ) -> NTSTATUS; +}} +pub const LDR_LOCK_LOADER_LOCK_FLAG_RAISE_ON_ERRORS: c_ulong = 0x00000001; +pub const LDR_LOCK_LOADER_LOCK_FLAG_TRY_ONLY: c_ulong = 0x00000002; +pub const LDR_LOCK_LOADER_LOCK_DISPOSITION_INVALID: c_ulong = 0; +pub const LDR_LOCK_LOADER_LOCK_DISPOSITION_LOCK_ACQUIRED: c_ulong = 1; +pub const LDR_LOCK_LOADER_LOCK_DISPOSITION_LOCK_NOT_ACQUIRED: c_ulong = 2; +EXTERN! {extern "system" { fn LdrLockLoaderLock( - Flags: ULONG, - Disposition: *mut ULONG, - Cookie: *mut PVOID, + Flags: c_ulong, + Disposition: *mut c_ulong, + Cookie: *mut *mut c_void, ) -> NTSTATUS; }} -pub const LDR_UNLOCK_LOADER_LOCK_FLAG_RAISE_ON_ERRORS: ULONG = 0x00000001; -EXTERN!{extern "system" { +pub const LDR_UNLOCK_LOADER_LOCK_FLAG_RAISE_ON_ERRORS: c_ulong = 0x00000001; +EXTERN! {extern "system" { fn LdrUnlockLoaderLock( - Flags: ULONG, - Cookie: PVOID, + Flags: c_ulong, + Cookie: *mut c_void, ) -> NTSTATUS; fn LdrRelocateImage( - NewBase: PVOID, - LoaderName: PSTR, + NewBase: *mut c_void, + LoaderName: *mut c_char, Success: NTSTATUS, Conflict: NTSTATUS, Invalid: NTSTATUS, ) -> NTSTATUS; fn LdrRelocateImageWithBias( - NewBase: PVOID, - Bias: LONGLONG, - LoaderName: PSTR, + NewBase: *mut c_void, + Bias: __int64, + LoaderName: *mut c_char, Success: NTSTATUS, Conflict: NTSTATUS, Invalid: NTSTATUS, ) -> NTSTATUS; fn LdrProcessRelocationBlock( - VA: ULONG_PTR, - SizeOfBlock: ULONG, - NextOffset: PUSHORT, - Diff: LONG_PTR, - ) -> PIMAGE_BASE_RELOCATION; + VA: usize, + SizeOfBlock: c_ulong, + NextOffset: *mut c_ushort, + Diff: isize, + ) -> *mut IMAGE_BASE_RELOCATION; fn LdrVerifyMappedImageMatchesChecksum( - BaseAddress: PVOID, - NumberOfBytes: SIZE_T, - FileLength: ULONG, - ) -> BOOLEAN; -}} -FN!{stdcall PLDR_IMPORT_MODULE_CALLBACK( - Parameter: PVOID, - ModuleName: PSTR, + BaseAddress: *mut c_void, + NumberOfBytes: usize, + FileLength: c_ulong, + ) -> c_uchar; +}} +FN! {stdcall PLDR_IMPORT_MODULE_CALLBACK( + Parameter: *mut c_void, + ModuleName: *mut c_char, ) -> ()} -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn LdrVerifyImageMatchesChecksum( ImageFileHandle: HANDLE, ImportCallbackRoutine: PLDR_IMPORT_MODULE_CALLBACK, - ImportCallbackParameter: PVOID, - ImageCharacteristics: PUSHORT, + ImportCallbackParameter: *mut c_void, + ImageCharacteristics: *mut c_ushort, ) -> NTSTATUS; }} -STRUCT!{struct LDR_IMPORT_CALLBACK_INFO { +STRUCT! {struct LDR_IMPORT_CALLBACK_INFO { ImportCallbackRoutine: PLDR_IMPORT_MODULE_CALLBACK, - ImportCallbackParameter: PVOID, + ImportCallbackParameter: *mut c_void, }} pub type PLDR_IMPORT_CALLBACK_INFO = *mut LDR_IMPORT_CALLBACK_INFO; -STRUCT!{struct LDR_SECTION_INFO { +STRUCT! {struct LDR_SECTION_INFO { SectionHandle: HANDLE, - DesiredAccess: ACCESS_MASK, - ObjA: POBJECT_ATTRIBUTES, - SectionPageProtection: ULONG, - AllocationAttributes: ULONG, + DesiredAccess: c_ulong, + ObjA: *mut OBJECT_ATTRIBUTES, + SectionPageProtection: c_ulong, + AllocationAttributes: c_ulong, }} pub type PLDR_SECTION_INFO = *mut LDR_SECTION_INFO; -STRUCT!{struct LDR_VERIFY_IMAGE_INFO { - Size: ULONG, - Flags: ULONG, +STRUCT! {struct LDR_VERIFY_IMAGE_INFO { + Size: c_ulong, + Flags: c_ulong, CallbackInfo: LDR_IMPORT_CALLBACK_INFO, SectionInfo: LDR_SECTION_INFO, - ImageCharacteristics: USHORT, + ImageCharacteristics: c_ushort, }} pub type PLDR_VERIFY_IMAGE_INFO = *mut LDR_VERIFY_IMAGE_INFO; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn LdrVerifyImageMatchesChecksumEx( ImageFileHandle: HANDLE, VerifyInfo: PLDR_VERIFY_IMAGE_INFO, ) -> NTSTATUS; fn LdrQueryModuleServiceTags( - DllHandle: PVOID, - ServiceTagBuffer: PULONG, - BufferSize: PULONG, - ) -> NTSTATUS; -}} -pub const LDR_DLL_NOTIFICATION_REASON_LOADED: ULONG = 1; -pub const LDR_DLL_NOTIFICATION_REASON_UNLOADED: ULONG = 2; -STRUCT!{struct LDR_DLL_LOADED_NOTIFICATION_DATA { - Flags: ULONG, - FullDllName: PUNICODE_STRING, - BaseDllName: PUNICODE_STRING, - DllBase: PVOID, - SizeOfImage: ULONG, -}} -pub type PLDR_DLL_LOADED_NOTIFICATION_DATA = *mut LDR_DLL_LOADED_NOTIFICATION_DATA; -STRUCT!{struct LDR_DLL_UNLOADED_NOTIFICATION_DATA { - Flags: ULONG, - FullDllName: PCUNICODE_STRING, - BaseDllName: PCUNICODE_STRING, - DllBase: PVOID, - SizeOfImage: ULONG, -}} -pub type PLDR_DLL_UNLOADED_NOTIFICATION_DATA = *mut LDR_DLL_UNLOADED_NOTIFICATION_DATA; -UNION!{union LDR_DLL_NOTIFICATION_DATA { + DllHandle: *mut c_void, + ServiceTagBuffer: *mut c_ulong, + BufferSize: *mut c_ulong, + ) -> NTSTATUS; +}} +pub const LDR_DLL_NOTIFICATION_REASON_LOADED: c_ulong = 1; +pub const LDR_DLL_NOTIFICATION_REASON_UNLOADED: c_ulong = 2; +STRUCT! {struct LDR_DLL_LOADED_NOTIFICATION_DATA { + Flags: c_ulong, + FullDllName: *mut UNICODE_STRING, + BaseDllName: *mut UNICODE_STRING, + DllBase: *mut c_void, + SizeOfImage: c_ulong, +}} +pub type PLDR_DLL_LOADED_NOTIFICATION_DATA = + *mut LDR_DLL_LOADED_NOTIFICATION_DATA; +STRUCT! {struct LDR_DLL_UNLOADED_NOTIFICATION_DATA { + Flags: c_ulong, + FullDllName: *const UNICODE_STRING, + BaseDllName: *const UNICODE_STRING, + DllBase: *mut c_void, + SizeOfImage: c_ulong, +}} +pub type PLDR_DLL_UNLOADED_NOTIFICATION_DATA = + *mut LDR_DLL_UNLOADED_NOTIFICATION_DATA; +UNION! {union LDR_DLL_NOTIFICATION_DATA { Loaded: LDR_DLL_LOADED_NOTIFICATION_DATA, Unloaded: LDR_DLL_UNLOADED_NOTIFICATION_DATA, }} pub type PLDR_DLL_NOTIFICATION_DATA = *mut LDR_DLL_NOTIFICATION_DATA; -FN!{stdcall PLDR_DLL_NOTIFICATION_FUNCTION( - NotificationReason: ULONG, +FN! {stdcall PLDR_DLL_NOTIFICATION_FUNCTION( + NotificationReason: c_ulong, NotificationData: PLDR_DLL_NOTIFICATION_DATA, - Context: PVOID, + Context: *mut c_void, ) -> ()} -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn LdrRegisterDllNotification( - Flags: ULONG, + Flags: c_ulong, NotificationFunction: PLDR_DLL_NOTIFICATION_FUNCTION, - Context: PVOID, - Cookie: *mut PVOID, + Context: *mut c_void, + Cookie: *mut *mut c_void, ) -> NTSTATUS; fn LdrUnregisterDllNotification( - Cookie: PVOID, + Cookie: *mut c_void, ) -> NTSTATUS; }} -STRUCT!{struct PS_MITIGATION_OPTIONS_MAP { - Map: [ULONG_PTR; 2], +STRUCT! {struct PS_MITIGATION_OPTIONS_MAP { + Map: [usize; 2], }} pub type PPS_MITIGATION_OPTIONS_MAP = *mut PS_MITIGATION_OPTIONS_MAP; -STRUCT!{struct PS_MITIGATION_AUDIT_OPTIONS_MAP { - Map: [ULONG_PTR; 2], -}} -pub type PPS_MITIGATION_AUDIT_OPTIONS_MAP = *mut PS_MITIGATION_AUDIT_OPTIONS_MAP; -STRUCT!{struct PS_SYSTEM_DLL_INIT_BLOCK { - Size: ULONG, - SystemDllWowRelocation: ULONG_PTR, - SystemDllNativeRelocation: ULONG_PTR, - Wow64SharedInformation: [ULONG_PTR; 16], - RngData: ULONG, - Flags: ULONG, +STRUCT! {struct PS_MITIGATION_AUDIT_OPTIONS_MAP { + Map: [usize; 2], +}} +pub type PPS_MITIGATION_AUDIT_OPTIONS_MAP = + *mut PS_MITIGATION_AUDIT_OPTIONS_MAP; +STRUCT! {struct PS_SYSTEM_DLL_INIT_BLOCK { + Size: c_ulong, + SystemDllWowRelocation: usize, + SystemDllNativeRelocation: usize, + Wow64SharedInformation: [usize; 16], + RngData: c_ulong, + Flags: c_ulong, MitigationOptionsMap: PS_MITIGATION_OPTIONS_MAP, - CfgBitMap: ULONG_PTR, - CfgBitMapSize: ULONG_PTR, - Wow64CfgBitMap: ULONG_PTR, - Wow64CfgBitMapSize: ULONG_PTR, + CfgBitMap: usize, + CfgBitMapSize: usize, + Wow64CfgBitMap: usize, + Wow64CfgBitMapSize: usize, MitigationAuditOptionsMap: PS_MITIGATION_AUDIT_OPTIONS_MAP, }} -BITFIELD!{PS_SYSTEM_DLL_INIT_BLOCK Flags: ULONG [ +BITFIELD! {PS_SYSTEM_DLL_INIT_BLOCK Flags: c_ulong [ CfgOverride set_CfgOverride[0..1], Reserved set_Reserved[1..32], ]} pub type PPS_SYSTEM_DLL_INIT_BLOCK = *mut PS_SYSTEM_DLL_INIT_BLOCK; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn LdrSystemDllInitBlock() -> PPS_SYSTEM_DLL_INIT_BLOCK; fn LdrAddLoadAsDataTable( - Module: PVOID, - FilePath: PWSTR, - Size: SIZE_T, + Module: *mut c_void, + FilePath: *mut wchar_t, + Size: usize, Handle: HANDLE, ) -> NTSTATUS; fn LdrRemoveLoadAsDataTable( - InitModule: PVOID, - BaseModule: *mut PVOID, - Size: PSIZE_T, - Flags: ULONG, + InitModule: *mut c_void, + BaseModule: *mut *mut c_void, + Size: *mut usize, + Flags: c_ulong, ) -> NTSTATUS; fn LdrGetFileNameFromLoadAsDataTable( - Module: PVOID, - pFileNamePrt: *mut PVOID, + Module: *mut c_void, + pFileNamePrt: *mut *mut c_void, ) -> NTSTATUS; fn LdrDisableThreadCalloutsForDll( - DllImageBase: PVOID, + DllImageBase: *mut c_void, ) -> NTSTATUS; fn LdrAccessResource( - DllHandle: PVOID, - ResourceDataEntry: PIMAGE_RESOURCE_DATA_ENTRY, - ResourceBuffer: *mut PVOID, - ResourceLength: *mut ULONG, + DllHandle: *mut c_void, + ResourceDataEntry: *mut IMAGE_RESOURCE_DATA_ENTRY, + ResourceBuffer: *mut *mut c_void, + ResourceLength: *mut c_ulong, ) -> NTSTATUS; }} -STRUCT!{struct LDR_RESOURCE_INFO { - Type: ULONG_PTR, - Name: ULONG_PTR, - Language: ULONG_PTR, +STRUCT! {struct LDR_RESOURCE_INFO { + Type: usize, + Name: usize, + Language: usize, }} pub type PLDR_RESOURCE_INFO = *mut LDR_RESOURCE_INFO; -pub const RESOURCE_TYPE_LEVEL: ULONG = 0; -pub const RESOURCE_NAME_LEVEL: ULONG = 1; -pub const RESOURCE_LANGUAGE_LEVEL: ULONG = 2; -pub const RESOURCE_DATA_LEVEL: ULONG = 3; -EXTERN!{extern "system" { +pub const RESOURCE_TYPE_LEVEL: c_ulong = 0; +pub const RESOURCE_NAME_LEVEL: c_ulong = 1; +pub const RESOURCE_LANGUAGE_LEVEL: c_ulong = 2; +pub const RESOURCE_DATA_LEVEL: c_ulong = 3; +EXTERN! {extern "system" { fn LdrFindResource_U( - DllHandle: PVOID, + DllHandle: *mut c_void, ResourceInfo: PLDR_RESOURCE_INFO, - Level: ULONG, - ResourceDataEntry: *mut PIMAGE_RESOURCE_DATA_ENTRY, + Level: c_ulong, + ResourceDataEntry: *mut *mut IMAGE_RESOURCE_DATA_ENTRY, ) -> NTSTATUS; fn LdrFindResourceDirectory_U( - DllHandle: PVOID, + DllHandle: *mut c_void, ResourceInfo: PLDR_RESOURCE_INFO, - Level: ULONG, - ResourceDirectory: *mut PIMAGE_RESOURCE_DIRECTORY, + Level: c_ulong, + ResourceDirectory: *mut *mut IMAGE_RESOURCE_DIRECTORY, ) -> NTSTATUS; }} -STRUCT!{struct LDR_ENUM_RESOURCE_ENTRY_Path_s { - Id: USHORT, - NameIsPresent: USHORT, +STRUCT! {struct LDR_ENUM_RESOURCE_ENTRY_Path_s { + Id: c_ushort, + NameIsPresent: c_ushort, }} -UNION!{union LDR_ENUM_RESOURCE_ENTRY_Path { - NameOrId: ULONG_PTR, - Name: PIMAGE_RESOURCE_DIRECTORY_STRING, +UNION! {union LDR_ENUM_RESOURCE_ENTRY_Path { + NameOrId: usize, + Name: *mut IMAGE_RESOURCE_DIRECTORY_STRING, s: LDR_ENUM_RESOURCE_ENTRY_Path_s, }} -STRUCT!{struct LDR_ENUM_RESOURCE_ENTRY { +STRUCT! {struct LDR_ENUM_RESOURCE_ENTRY { Path: [LDR_ENUM_RESOURCE_ENTRY_Path; 3], - Data: PVOID, - Size: ULONG, - Reserved: ULONG, + Data: *mut c_void, + Size: c_ulong, + Reserved: c_ulong, }} pub type PLDR_ENUM_RESOURCE_ENTRY = *mut LDR_ENUM_RESOURCE_ENTRY; #[inline] pub unsafe fn NAME_FROM_RESOURCE_ENTRY( - RootDirectory: PIMAGE_RESOURCE_DIRECTORY, + RootDirectory: *mut IMAGE_RESOURCE_DIRECTORY, Entry: &IMAGE_RESOURCE_DIRECTORY_ENTRY, ) -> usize { - if Entry.u.s().NameIsString() != 0 { - return RootDirectory as usize + Entry.u.s().NameOffset() as usize; + // if Entry.u.s().NameIsString() != 0 { + // return RootDirectory as usize + Entry.u.s().NameOffset() as usize; + // } + // *Entry.u.Id() as usize + if Entry.Anonymous1.Name == 0 { + Entry.Anonymous1.Id as usize + } else { + RootDirectory as usize + Entry.Anonymous2.OffsetToData as usize } - *Entry.u.Id() as usize } -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn LdrEnumResources( - DllHandle: PVOID, + DllHandle: *mut c_void, ResourceInfo: PLDR_RESOURCE_INFO, - Level: ULONG, - ResourceCount: *mut ULONG, + Level: c_ulong, + ResourceCount: *mut c_ulong, Resources: PLDR_ENUM_RESOURCE_ENTRY, ) -> NTSTATUS; fn LdrFindEntryForAddress( - DllHandle: PVOID, + DllHandle: *mut c_void, Entry: *mut PLDR_DATA_TABLE_ENTRY, ) -> NTSTATUS; }} -STRUCT!{struct RTL_PROCESS_MODULE_INFORMATION { +STRUCT! {struct RTL_PROCESS_MODULE_INFORMATION { Section: HANDLE, - MappedBase: PVOID, - ImageBase: PVOID, - ImageSize: ULONG, - Flags: ULONG, - LoadOrderIndex: USHORT, - InitOrderIndex: USHORT, - LoadCount: USHORT, - OffsetToFileName: USHORT, - FullPathName: [UCHAR; 256], + MappedBase: *mut c_void, + ImageBase: *mut c_void, + ImageSize: c_ulong, + Flags: c_ulong, + LoadOrderIndex: c_ushort, + InitOrderIndex: c_ushort, + LoadCount: c_ushort, + OffsetToFileName: c_ushort, + FullPathName: [c_uchar; 256], }} pub type PRTL_PROCESS_MODULE_INFORMATION = *mut RTL_PROCESS_MODULE_INFORMATION; -STRUCT!{struct RTL_PROCESS_MODULES { - NumberOfModules: ULONG, +STRUCT! {struct RTL_PROCESS_MODULES { + NumberOfModules: c_ulong, Modules: [RTL_PROCESS_MODULE_INFORMATION; 1], }} pub type PRTL_PROCESS_MODULES = *mut RTL_PROCESS_MODULES; -STRUCT!{struct RTL_PROCESS_MODULE_INFORMATION_EX { - NextOffset: USHORT, +STRUCT! {struct RTL_PROCESS_MODULE_INFORMATION_EX { + NextOffset: c_ushort, BaseInfo: RTL_PROCESS_MODULE_INFORMATION, - ImageChecksum: ULONG, - TimeDateStamp: ULONG, - DefaultBase: PVOID, + ImageChecksum: c_ulong, + TimeDateStamp: c_ulong, + DefaultBase: *mut c_void, }} -pub type PRTL_PROCESS_MODULE_INFORMATION_EX = *mut RTL_PROCESS_MODULE_INFORMATION_EX; -EXTERN!{extern "system" { +pub type PRTL_PROCESS_MODULE_INFORMATION_EX = + *mut RTL_PROCESS_MODULE_INFORMATION_EX; +EXTERN! {extern "system" { fn LdrQueryProcessModuleInformation( ModuleInformation: PRTL_PROCESS_MODULES, - Size: ULONG, - ReturnedSize: PULONG, + Size: c_ulong, + ReturnedSize: *mut c_ulong, ) -> NTSTATUS; }} -FN!{stdcall PLDR_ENUM_CALLBACK( +FN! {stdcall PLDR_ENUM_CALLBACK( ModuleInformation: PLDR_DATA_TABLE_ENTRY, - Parameter: PVOID, - Stop: *mut BOOLEAN, + Parameter: *mut c_void, + Stop: *mut c_uchar, ) -> ()} -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn LdrEnumerateLoadedModules( - ReservedFlag: BOOLEAN, + ReservedFlag: c_uchar, EnumProc: PLDR_ENUM_CALLBACK, - Context: PVOID, + Context: *mut c_void, ) -> NTSTATUS; fn LdrOpenImageFileOptionsKey( - SubKey: PUNICODE_STRING, - Wow64: BOOLEAN, - NewKeyHandle: PHANDLE, + SubKey: *mut UNICODE_STRING, + Wow64: c_uchar, + NewKeyHandle: *mut HANDLE, ) -> NTSTATUS; fn LdrQueryImageFileKeyOption( KeyHandle: HANDLE, - ValueName: PCWSTR, - Type: ULONG, - Buffer: PVOID, - BufferSize: ULONG, - ReturnedLength: PULONG, + ValueName: *const wchar_t, + Type: c_ulong, + Buffer: *mut c_void, + BufferSize: c_ulong, + ReturnedLength: *mut c_ulong, ) -> NTSTATUS; fn LdrQueryImageFileExecutionOptions( - SubKey: PUNICODE_STRING, - ValueName: PCWSTR, - ValueSize: ULONG, - Buffer: PVOID, - BufferSize: ULONG, - ReturnedLength: PULONG, + SubKey: *mut UNICODE_STRING, + ValueName: *const wchar_t, + ValueSize: c_ulong, + Buffer: *mut c_void, + BufferSize: c_ulong, + ReturnedLength: *mut c_ulong, ) -> NTSTATUS; fn LdrQueryImageFileExecutionOptionsEx( - SubKey: PUNICODE_STRING, - ValueName: PCWSTR, - Type: ULONG, - Buffer: PVOID, - BufferSize: ULONG, - ReturnedLength: PULONG, - Wow64: BOOLEAN, + SubKey: *mut UNICODE_STRING, + ValueName: *const wchar_t, + Type: c_ulong, + Buffer: *mut c_void, + BufferSize: c_ulong, + ReturnedLength: *mut c_ulong, + Wow64: c_uchar, ) -> NTSTATUS; }} -UNION!{union DELAYLOAD_PROC_DESCRIPTOR_Description { - Name: PCSTR, - Ordinal: ULONG, +UNION! {union DELAYLOAD_PROC_DESCRIPTOR_Description { + Name: *const c_char, + Ordinal: c_ulong, }} -STRUCT!{struct DELAYLOAD_PROC_DESCRIPTOR { - ImportDescribedByName: ULONG, +STRUCT! {struct DELAYLOAD_PROC_DESCRIPTOR { + ImportDescribedByName: c_ulong, Description: DELAYLOAD_PROC_DESCRIPTOR_Description, }} pub type PDELAYLOAD_PROC_DESCRIPTOR = *mut DELAYLOAD_PROC_DESCRIPTOR; -STRUCT!{struct DELAYLOAD_INFO { - Size: ULONG, - DelayloadDescriptor: PCIMAGE_DELAYLOAD_DESCRIPTOR, - ThunkAddress: PIMAGE_THUNK_DATA, - TargetDllName: PCSTR, +STRUCT! {struct DELAYLOAD_INFO { + Size: c_ulong, + DelayloadDescriptor: *const IMAGE_DELAYLOAD_DESCRIPTOR, + ThunkAddress: *mut IMAGE_THUNK_DATA64, + TargetDllName: *const c_char, TargetApiDescriptor: DELAYLOAD_PROC_DESCRIPTOR, - TargetModuleBase: PVOID, - Unused: PVOID, - LastError: ULONG, + TargetModuleBase: *mut c_void, + Unused: *mut c_void, + LastError: c_ulong, }} pub type PDELAYLOAD_INFO = *mut DELAYLOAD_INFO; -FN!{stdcall PDELAYLOAD_FAILURE_DLL_CALLBACK( - NotificationReason: ULONG, +FN! {stdcall PDELAYLOAD_FAILURE_DLL_CALLBACK( + NotificationReason: c_ulong, DelayloadInfo: PDELAYLOAD_INFO, -) -> PVOID} -FN!{stdcall PDELAYLOAD_FAILURE_SYSTEM_ROUTINE( - DllName: PCSTR, - ProcName: PCSTR, -) -> PVOID} -EXTERN!{extern "system" { +) -> *mut c_void} +FN! {stdcall PDELAYLOAD_FAILURE_SYSTEM_ROUTINE( + DllName: *const c_char, + ProcName: *const c_char, +) -> *mut c_void} +EXTERN! {extern "system" { fn LdrResolveDelayLoadedAPI( - ParentModuleBase: PVOID, - DelayloadDescriptor: PCIMAGE_DELAYLOAD_DESCRIPTOR, + ParentModuleBase: *mut c_void, + DelayloadDescriptor: *const IMAGE_DELAYLOAD_DESCRIPTOR, FailureDllHook: PDELAYLOAD_FAILURE_DLL_CALLBACK, FailureSystemHook: PDELAYLOAD_FAILURE_SYSTEM_ROUTINE, - ThunkAddress: PIMAGE_THUNK_DATA, - Flags: ULONG, - ) -> PVOID; + ThunkAddress: *mut IMAGE_THUNK_DATA64, + Flags: c_ulong, + ) -> *mut c_void; fn LdrResolveDelayLoadsFromDll( - ParentBase: PVOID, - TargetDllName: PCSTR, - Flags: ULONG, + ParentBase: *mut c_void, + TargetDllName: *const c_char, + Flags: c_ulong, ) -> NTSTATUS; fn LdrSetDefaultDllDirectories( - DirectoryFlags: ULONG, + DirectoryFlags: c_ulong, ) -> NTSTATUS; fn LdrShutdownProcess() -> NTSTATUS; fn LdrShutdownThread() -> NTSTATUS; fn LdrSetImplicitPathOptions( - ImplicitPathOptions: ULONG, + ImplicitPathOptions: c_ulong, ) -> NTSTATUS; - fn LdrControlFlowGuardEnforced() -> BOOLEAN; + fn LdrControlFlowGuardEnforced() -> c_uchar; }} diff --git a/src/ntlpcapi.rs b/src/ntlpcapi.rs index 012c905..a5c9f41 100644 --- a/src/ntlpcapi.rs +++ b/src/ntlpcapi.rs @@ -1,199 +1,205 @@ use core::mem::size_of; -use crate::ntapi_base::{CLIENT_ID, CLIENT_ID64}; -use winapi::ctypes::c_double; -use winapi::shared::basetsd::{PSIZE_T, SIZE_T, ULONG64, ULONG_PTR}; -use winapi::shared::ntdef::{ - BOOLEAN, CSHORT, HANDLE, LARGE_INTEGER, NTSTATUS, OBJ_CASE_INSENSITIVE, PHANDLE, - PLARGE_INTEGER, POBJECT_ATTRIBUTES, PULONG, PUNICODE_STRING, PVOID, ULONG, ULONGLONG, - UNICODE_STRING, + +use windows_sys::Win32::{ + Foundation::{HANDLE, NTSTATUS, PSID, UNICODE_STRING}, + Security::{PSECURITY_DESCRIPTOR, SECURITY_QUALITY_OF_SERVICE}, + Storage::FileSystem::{STANDARD_RIGHTS_REQUIRED, SYNCHRONIZE}, + System::{ + Kernel::OBJ_CASE_INSENSITIVE, Threading::RTL_SRWLOCK, + WindowsProgramming::OBJECT_ATTRIBUTES, + }, }; -use winapi::um::winnt::{ - ACCESS_MASK, PSECURITY_DESCRIPTOR, PSECURITY_QUALITY_OF_SERVICE, PSID, RTL_SRWLOCK, - SECURITY_QUALITY_OF_SERVICE, STANDARD_RIGHTS_REQUIRED, SYNCHRONIZE, + +use crate::{ + ctypes::{__uint64, c_double, c_short, c_uchar, c_ulong, c_void}, + ntapi_base::{CLIENT_ID, CLIENT_ID64}, + windows_local::shared::ntdef::LARGE_INTEGER, }; + pub const PORT_CONNECT: u32 = 0x0001; pub const PORT_ALL_ACCESS: u32 = STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x1; -STRUCT!{struct PORT_MESSAGE_u1_s { - DataLength: CSHORT, - TotalLength: CSHORT, +STRUCT! {struct PORT_MESSAGE_u1_s { + DataLength: c_short, + TotalLength: c_short, }} -STRUCT!{struct PORT_MESSAGE_u2_s { - Type: CSHORT, - DataInfoOffset: CSHORT, +STRUCT! {struct PORT_MESSAGE_u2_s { + Type: c_short, + DataInfoOffset: c_short, }} -UNION!{union PORT_MESSAGE_u1 { +UNION! {union PORT_MESSAGE_u1 { s: PORT_MESSAGE_u1_s, - Length: ULONG, + Length: c_ulong, }} -UNION!{union PORT_MESSAGE_u2 { +UNION! {union PORT_MESSAGE_u2 { s: PORT_MESSAGE_u2_s, - ZeroInit: ULONG, + ZeroInit: c_ulong, }} -UNION!{union PORT_MESSAGE_u3 { +UNION! {union PORT_MESSAGE_u3 { ClientId: CLIENT_ID, DoNotUseThisField: c_double, }} -UNION!{union PORT_MESSAGE_u4 { - ClientViewSize: SIZE_T, - CallbackId: ULONG, +UNION! {union PORT_MESSAGE_u4 { + ClientViewSize: usize, + CallbackId: c_ulong, }} -STRUCT!{struct PORT_MESSAGE { +STRUCT! {struct PORT_MESSAGE { u1: PORT_MESSAGE_u1, u2: PORT_MESSAGE_u2, u3: PORT_MESSAGE_u3, - MessageId: ULONG, + MessageId: c_ulong, u4: PORT_MESSAGE_u4, }} pub type PPORT_MESSAGE = *mut PORT_MESSAGE; -STRUCT!{struct PORT_DATA_ENTRY { - Base: PVOID, - Size: ULONG, +STRUCT! {struct PORT_DATA_ENTRY { + Base: *mut c_void, + Size: c_ulong, }} pub type PPORT_DATA_ENTRY = *mut PORT_DATA_ENTRY; -STRUCT!{struct PORT_DATA_INFORMATION { - CountDataEntries: ULONG, +STRUCT! {struct PORT_DATA_INFORMATION { + CountDataEntries: c_ulong, DataEntries: [PORT_DATA_ENTRY; 1], }} pub type PPORT_DATA_INFORMATION = *mut PORT_DATA_INFORMATION; -pub const LPC_REQUEST: ULONG = 1; -pub const LPC_REPLY: ULONG = 2; -pub const LPC_DATAGRAM: ULONG = 3; -pub const LPC_LOST_REPLY: ULONG = 4; -pub const LPC_PORT_CLOSED: ULONG = 5; -pub const LPC_CLIENT_DIED: ULONG = 6; -pub const LPC_EXCEPTION: ULONG = 7; -pub const LPC_DEBUG_EVENT: ULONG = 8; -pub const LPC_ERROR_EVENT: ULONG = 9; -pub const LPC_CONNECTION_REQUEST: ULONG = 10; -pub const LPC_KERNELMODE_MESSAGE: CSHORT = 0x8000; -pub const LPC_NO_IMPERSONATE: CSHORT = 0x4000; -pub const PORT_VALID_OBJECT_ATTRIBUTES: u32 = OBJ_CASE_INSENSITIVE; +pub const LPC_REQUEST: c_ulong = 1; +pub const LPC_REPLY: c_ulong = 2; +pub const LPC_DATAGRAM: c_ulong = 3; +pub const LPC_LOST_REPLY: c_ulong = 4; +pub const LPC_PORT_CLOSED: c_ulong = 5; +pub const LPC_CLIENT_DIED: c_ulong = 6; +pub const LPC_EXCEPTION: c_ulong = 7; +pub const LPC_DEBUG_EVENT: c_ulong = 8; +pub const LPC_ERROR_EVENT: c_ulong = 9; +pub const LPC_CONNECTION_REQUEST: c_ulong = 10; +pub const LPC_KERNELMODE_MESSAGE: c_short = 0x8000; +pub const LPC_NO_IMPERSONATE: c_short = 0x4000; +pub const PORT_VALID_OBJECT_ATTRIBUTES: u32 = OBJ_CASE_INSENSITIVE as u32; #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] pub const PORT_MAXIMUM_MESSAGE_LENGTH: u32 = 512; #[cfg(target_arch = "x86")] pub const PORT_MAXIMUM_MESSAGE_LENGTH: u32 = 256; -pub const LPC_MAX_CONNECTION_INFO_SIZE: u32 = 16 * size_of::() as u32; +pub const LPC_MAX_CONNECTION_INFO_SIZE: u32 = 16 * size_of::() as u32; pub const PORT_TOTAL_MAXIMUM_MESSAGE_LENGTH: u32 = (PORT_MAXIMUM_MESSAGE_LENGTH + size_of::() as u32 + LPC_MAX_CONNECTION_INFO_SIZE - + 0xf) & !0xf; -STRUCT!{struct LPC_CLIENT_DIED_MSG { + + 0xf) + & !0xf; +STRUCT! {struct LPC_CLIENT_DIED_MSG { PortMsg: PORT_MESSAGE, CreateTime: LARGE_INTEGER, }} pub type PLPC_CLIENT_DIED_MSG = *mut LPC_CLIENT_DIED_MSG; -STRUCT!{struct PORT_VIEW { - Length: ULONG, +STRUCT! {struct PORT_VIEW { + Length: c_ulong, SectionHandle: HANDLE, - SectionOffset: ULONG, - ViewSize: SIZE_T, - ViewBase: PVOID, - ViewRemoteBase: PVOID, + SectionOffset: c_ulong, + ViewSize: usize, + ViewBase: *mut c_void, + ViewRemoteBase: *mut c_void, }} pub type PPORT_VIEW = *mut PORT_VIEW; -STRUCT!{struct REMOTE_PORT_VIEW { - Length: ULONG, - ViewSize: SIZE_T, - ViewBase: PVOID, +STRUCT! {struct REMOTE_PORT_VIEW { + Length: c_ulong, + ViewSize: usize, + ViewBase: *mut c_void, }} pub type PREMOTE_PORT_VIEW = *mut REMOTE_PORT_VIEW; -STRUCT!{struct PORT_MESSAGE64_u1_s { - DataLength: CSHORT, - TotalLength: CSHORT, +STRUCT! {struct PORT_MESSAGE64_u1_s { + DataLength: c_short, + TotalLength: c_short, }} -STRUCT!{struct PORT_MESSAGE64_u2_s { - Type: CSHORT, - DataInfoOffset: CSHORT, +STRUCT! {struct PORT_MESSAGE64_u2_s { + Type: c_short, + DataInfoOffset: c_short, }} -UNION!{union PORT_MESSAGE64_u1 { +UNION! {union PORT_MESSAGE64_u1 { s: PORT_MESSAGE64_u1_s, - Length: ULONG, + Length: c_ulong, }} -UNION!{union PORT_MESSAGE64_u2 { +UNION! {union PORT_MESSAGE64_u2 { s: PORT_MESSAGE64_u2_s, - ZeroInit: ULONG, + ZeroInit: c_ulong, }} -UNION!{union PORT_MESSAGE64_u3 { +UNION! {union PORT_MESSAGE64_u3 { ClientId: CLIENT_ID64, DoNotUseThisField: c_double, }} -UNION!{union PORT_MESSAGE64_u4 { - ClientViewSize: ULONGLONG, - CallbackId: ULONG, +UNION! {union PORT_MESSAGE64_u4 { + ClientViewSize: __uint64, + CallbackId: c_ulong, }} -STRUCT!{struct PORT_MESSAGE64 { +STRUCT! {struct PORT_MESSAGE64 { u1: PORT_MESSAGE64_u1, u2: PORT_MESSAGE64_u2, u3: PORT_MESSAGE64_u3, - MessageId: ULONG, + MessageId: c_ulong, u4: PORT_MESSAGE64_u4, }} pub type PPORT_MESSAGE64 = *mut PORT_MESSAGE64; -STRUCT!{struct LPC_CLIENT_DIED_MSG64 { +STRUCT! {struct LPC_CLIENT_DIED_MSG64 { PortMsg: PORT_MESSAGE64, CreateTime: LARGE_INTEGER, }} pub type PLPC_CLIENT_DIED_MSG64 = *mut LPC_CLIENT_DIED_MSG64; -STRUCT!{struct PORT_VIEW64 { - Length: ULONG, - SectionHandle: ULONGLONG, - SectionOffset: ULONG, - ViewSize: ULONGLONG, - ViewBase: ULONGLONG, - ViewRemoteBase: ULONGLONG, +STRUCT! {struct PORT_VIEW64 { + Length: c_ulong, + SectionHandle: __uint64, + SectionOffset: c_ulong, + ViewSize: __uint64, + ViewBase: __uint64, + ViewRemoteBase: __uint64, }} pub type PPORT_VIEW64 = *mut PORT_VIEW64; -STRUCT!{struct REMOTE_PORT_VIEW64 { - Length: ULONG, - ViewSize: ULONGLONG, - ViewBase: ULONGLONG, +STRUCT! {struct REMOTE_PORT_VIEW64 { + Length: c_ulong, + ViewSize: __uint64, + ViewBase: __uint64, }} pub type PREMOTE_PORT_VIEW64 = *mut REMOTE_PORT_VIEW64; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtCreatePort( - PortHandle: PHANDLE, - ObjectAttributes: POBJECT_ATTRIBUTES, - MaxConnectionInfoLength: ULONG, - MaxMessageLength: ULONG, - MaxPoolUsage: ULONG, + PortHandle: *mut HANDLE, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + MaxConnectionInfoLength: c_ulong, + MaxMessageLength: c_ulong, + MaxPoolUsage: c_ulong, ) -> NTSTATUS; fn NtCreateWaitablePort( - PortHandle: PHANDLE, - ObjectAttributes: POBJECT_ATTRIBUTES, - MaxConnectionInfoLength: ULONG, - MaxMessageLength: ULONG, - MaxPoolUsage: ULONG, + PortHandle: *mut HANDLE, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + MaxConnectionInfoLength: c_ulong, + MaxMessageLength: c_ulong, + MaxPoolUsage: c_ulong, ) -> NTSTATUS; fn NtConnectPort( - PortHandle: PHANDLE, - PortName: PUNICODE_STRING, - SecurityQos: PSECURITY_QUALITY_OF_SERVICE, + PortHandle: *mut HANDLE, + PortName: *mut UNICODE_STRING, + SecurityQos: *mut SECURITY_QUALITY_OF_SERVICE, ClientView: PPORT_VIEW, ServerView: PREMOTE_PORT_VIEW, - MaxMessageLength: PULONG, - ConnectionInformation: PVOID, - ConnectionInformationLength: PULONG, + MaxMessageLength: *mut c_ulong, + ConnectionInformation: *mut c_void, + ConnectionInformationLength: *mut c_ulong, ) -> NTSTATUS; fn NtSecureConnectPort( - PortHandle: PHANDLE, - PortName: PUNICODE_STRING, - SecurityQos: PSECURITY_QUALITY_OF_SERVICE, + PortHandle: *mut HANDLE, + PortName: *mut UNICODE_STRING, + SecurityQos: *mut SECURITY_QUALITY_OF_SERVICE, ClientView: PPORT_VIEW, RequiredServerSid: PSID, ServerView: PREMOTE_PORT_VIEW, - MaxMessageLength: PULONG, - ConnectionInformation: PVOID, - ConnectionInformationLength: PULONG, + MaxMessageLength: *mut c_ulong, + ConnectionInformation: *mut c_void, + ConnectionInformationLength: *mut c_ulong, ) -> NTSTATUS; fn NtListenPort( PortHandle: HANDLE, ConnectionRequest: PPORT_MESSAGE, ) -> NTSTATUS; fn NtAcceptConnectPort( - PortHandle: PHANDLE, - PortContext: PVOID, + PortHandle: *mut HANDLE, + PortContext: *mut c_void, ConnectionRequest: PPORT_MESSAGE, - AcceptConnection: BOOLEAN, + AcceptConnection: c_uchar, ServerView: PPORT_VIEW, ClientView: PREMOTE_PORT_VIEW, ) -> NTSTATUS; @@ -219,16 +225,16 @@ EXTERN!{extern "system" { ) -> NTSTATUS; fn NtReplyWaitReceivePort( PortHandle: HANDLE, - PortContext: *mut PVOID, + PortContext: *mut *mut c_void, ReplyMessage: PPORT_MESSAGE, ReceiveMessage: PPORT_MESSAGE, ) -> NTSTATUS; fn NtReplyWaitReceivePortEx( PortHandle: HANDLE, - PortContext: *mut PVOID, + PortContext: *mut *mut c_void, ReplyMessage: PPORT_MESSAGE, ReceiveMessage: PPORT_MESSAGE, - Timeout: PLARGE_INTEGER, + Timeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn NtImpersonateClientOfPort( PortHandle: HANDLE, @@ -237,167 +243,167 @@ EXTERN!{extern "system" { fn NtReadRequestData( PortHandle: HANDLE, Message: PPORT_MESSAGE, - DataEntryIndex: ULONG, - Buffer: PVOID, - BufferSize: SIZE_T, - NumberOfBytesRead: PSIZE_T, + DataEntryIndex: c_ulong, + Buffer: *mut c_void, + BufferSize: usize, + NumberOfBytesRead: *mut usize, ) -> NTSTATUS; fn NtWriteRequestData( PortHandle: HANDLE, Message: PPORT_MESSAGE, - DataEntryIndex: ULONG, - Buffer: PVOID, - BufferSize: SIZE_T, - NumberOfBytesWritten: PSIZE_T, + DataEntryIndex: c_ulong, + Buffer: *mut c_void, + BufferSize: usize, + NumberOfBytesWritten: *mut usize, ) -> NTSTATUS; }} -ENUM!{enum PORT_INFORMATION_CLASS { +ENUM! {enum PORT_INFORMATION_CLASS { PortBasicInformation = 0, PortDumpInformation = 1, }} -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtQueryInformationPort( PortHandle: HANDLE, PortInformationClass: PORT_INFORMATION_CLASS, - PortInformation: PVOID, - Length: ULONG, - ReturnLength: PULONG, + PortInformation: *mut c_void, + Length: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; }} pub type PALPC_HANDLE = *mut HANDLE; pub type ALPC_HANDLE = HANDLE; -pub const ALPC_PORFLG_ALLOW_LPC_REQUESTS: ULONG = 0x20000; -pub const ALPC_PORFLG_WAITABLE_PORT: ULONG = 0x40000; -pub const ALPC_PORFLG_SYSTEM_PROCESS: ULONG = 0x100000; +pub const ALPC_PORFLG_ALLOW_LPC_REQUESTS: c_ulong = 0x20000; +pub const ALPC_PORFLG_WAITABLE_PORT: c_ulong = 0x40000; +pub const ALPC_PORFLG_SYSTEM_PROCESS: c_ulong = 0x100000; #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] -STRUCT!{struct ALPC_PORT_ATTRIBUTES { - Flags: ULONG, +STRUCT! {struct ALPC_PORT_ATTRIBUTES { + Flags: c_ulong, SecurityQos: SECURITY_QUALITY_OF_SERVICE, - MaxMessageLength: SIZE_T, - MemoryBandwidth: SIZE_T, - MaxPoolUsage: SIZE_T, - MaxSectionSize: SIZE_T, - MaxViewSize: SIZE_T, - MaxTotalSectionSize: SIZE_T, - DupObjectTypes: ULONG, - Reserved: ULONG, + MaxMessageLength: usize, + MemoryBandwidth: usize, + MaxPoolUsage: usize, + MaxSectionSize: usize, + MaxViewSize: usize, + MaxTotalSectionSize: usize, + DupObjectTypes: c_ulong, + Reserved: c_ulong, }} #[cfg(target_arch = "x86")] -STRUCT!{struct ALPC_PORT_ATTRIBUTES { - Flags: ULONG, +STRUCT! {struct ALPC_PORT_ATTRIBUTES { + Flags: c_ulong, SecurityQos: SECURITY_QUALITY_OF_SERVICE, - MaxMessageLength: SIZE_T, - MemoryBandwidth: SIZE_T, - MaxPoolUsage: SIZE_T, - MaxSectionSize: SIZE_T, - MaxViewSize: SIZE_T, - MaxTotalSectionSize: SIZE_T, - DupObjectTypes: ULONG, + MaxMessageLength: usize, + MemoryBandwidth: usize, + MaxPoolUsage: usize, + MaxSectionSize: usize, + MaxViewSize: usize, + MaxTotalSectionSize: usize, + DupObjectTypes: c_ulong, }} pub type PALPC_PORT_ATTRIBUTES = *mut ALPC_PORT_ATTRIBUTES; -pub const ALPC_MESSAGE_SECURITY_ATTRIBUTE: ULONG = 0x80000000; -pub const ALPC_MESSAGE_VIEW_ATTRIBUTE: ULONG = 0x40000000; -pub const ALPC_MESSAGE_CONTEXT_ATTRIBUTE: ULONG = 0x20000000; -pub const ALPC_MESSAGE_HANDLE_ATTRIBUTE: ULONG = 0x10000000; -STRUCT!{struct ALPC_MESSAGE_ATTRIBUTES { - AllocatedAttributes: ULONG, - ValidAttributes: ULONG, +pub const ALPC_MESSAGE_SECURITY_ATTRIBUTE: c_ulong = 0x80000000; +pub const ALPC_MESSAGE_VIEW_ATTRIBUTE: c_ulong = 0x40000000; +pub const ALPC_MESSAGE_CONTEXT_ATTRIBUTE: c_ulong = 0x20000000; +pub const ALPC_MESSAGE_HANDLE_ATTRIBUTE: c_ulong = 0x10000000; +STRUCT! {struct ALPC_MESSAGE_ATTRIBUTES { + AllocatedAttributes: c_ulong, + ValidAttributes: c_ulong, }} pub type PALPC_MESSAGE_ATTRIBUTES = *mut ALPC_MESSAGE_ATTRIBUTES; -STRUCT!{struct ALPC_COMPLETION_LIST_STATE { - Value: ULONG64, +STRUCT! {struct ALPC_COMPLETION_LIST_STATE { + Value: __uint64, }} -BITFIELD!{ALPC_COMPLETION_LIST_STATE Value: ULONG64 [ +BITFIELD! {ALPC_COMPLETION_LIST_STATE Value: __uint64 [ Head set_Head[0..24], Tail set_Tail[24..48], ActiveThreadCount set_ActiveThreadCount[48..64], ]} pub type PALPC_COMPLETION_LIST_STATE = *mut ALPC_COMPLETION_LIST_STATE; -pub const ALPC_COMPLETION_LIST_BUFFER_GRANULARITY_MASK: ULONG = 0x3f; -STRUCT!{#[repr(align(128))] struct ALPC_COMPLETION_LIST_HEADER { - StartMagic: ULONG64, - TotalSize: ULONG, - ListOffset: ULONG, - ListSize: ULONG, - BitmapOffset: ULONG, - BitmapSize: ULONG, - DataOffset: ULONG, - DataSize: ULONG, - AttributeFlags: ULONG, - AttributeSize: ULONG, +pub const ALPC_COMPLETION_LIST_BUFFER_GRANULARITY_MASK: c_ulong = 0x3f; +STRUCT! {#[repr(align(128))] struct ALPC_COMPLETION_LIST_HEADER { + StartMagic: __uint64, + TotalSize: c_ulong, + ListOffset: c_ulong, + ListSize: c_ulong, + BitmapOffset: c_ulong, + BitmapSize: c_ulong, + DataOffset: c_ulong, + DataSize: c_ulong, + AttributeFlags: c_ulong, + AttributeSize: c_ulong, __padding0: [u64; 10], State: ALPC_COMPLETION_LIST_STATE, - LastMessageId: ULONG, - LastCallbackId: ULONG, + LastMessageId: c_ulong, + LastCallbackId: c_ulong, __padding1: [u32; 28], - PostCount: ULONG, + PostCount: c_ulong, __padding2: [u32; 31], - ReturnCount: ULONG, + ReturnCount: c_ulong, __padding3: [u32; 31], - LogSequenceNumber: ULONG, + LogSequenceNumber: c_ulong, __padding4: [u64; 15], UserLock: RTL_SRWLOCK, - EndMagic: ULONG64, + EndMagic: __uint64, __padding5: [u64; 14], }} pub type PALPC_COMPLETION_LIST_HEADER = *mut ALPC_COMPLETION_LIST_HEADER; -STRUCT!{struct ALPC_CONTEXT_ATTR { - PortContext: PVOID, - MessageContext: PVOID, - Sequence: ULONG, - MessageId: ULONG, - CallbackId: ULONG, +STRUCT! {struct ALPC_CONTEXT_ATTR { + PortContext: *mut c_void, + MessageContext: *mut c_void, + Sequence: c_ulong, + MessageId: c_ulong, + CallbackId: c_ulong, }} pub type PALPC_CONTEXT_ATTR = *mut ALPC_CONTEXT_ATTR; -pub const ALPC_HANDLEFLG_DUPLICATE_SAME_ACCESS: ULONG = 0x10000; -pub const ALPC_HANDLEFLG_DUPLICATE_SAME_ATTRIBUTES: ULONG = 0x20000; -pub const ALPC_HANDLEFLG_DUPLICATE_INHERIT: ULONG = 0x80000; -STRUCT!{struct ALPC_HANDLE_ATTR32 { - Flags: ULONG, - Reserved0: ULONG, - SameAccess: ULONG, - SameAttributes: ULONG, - Indirect: ULONG, - Inherit: ULONG, - Reserved1: ULONG, - Handle: ULONG, - ObjectType: ULONG, - DesiredAccess: ULONG, - GrantedAccess: ULONG, +pub const ALPC_HANDLEFLG_DUPLICATE_SAME_ACCESS: c_ulong = 0x10000; +pub const ALPC_HANDLEFLG_DUPLICATE_SAME_ATTRIBUTES: c_ulong = 0x20000; +pub const ALPC_HANDLEFLG_DUPLICATE_INHERIT: c_ulong = 0x80000; +STRUCT! {struct ALPC_HANDLE_ATTR32 { + Flags: c_ulong, + Reserved0: c_ulong, + SameAccess: c_ulong, + SameAttributes: c_ulong, + Indirect: c_ulong, + Inherit: c_ulong, + Reserved1: c_ulong, + Handle: c_ulong, + ObjectType: c_ulong, + DesiredAccess: c_ulong, + GrantedAccess: c_ulong, }} pub type PALPC_HANDLE_ATTR32 = *mut ALPC_HANDLE_ATTR32; -STRUCT!{struct ALPC_HANDLE_ATTR { - Flags: ULONG, - Reserved0: ULONG, - SameAccess: ULONG, - SameAttributes: ULONG, - Indirect: ULONG, - Inherit: ULONG, - Reserved1: ULONG, +STRUCT! {struct ALPC_HANDLE_ATTR { + Flags: c_ulong, + Reserved0: c_ulong, + SameAccess: c_ulong, + SameAttributes: c_ulong, + Indirect: c_ulong, + Inherit: c_ulong, + Reserved1: c_ulong, Handle: HANDLE, HandleAttrArray: PALPC_HANDLE_ATTR32, - ObjectType: ULONG, - HandleCount: ULONG, - DesiredAccess: ACCESS_MASK, - GrantedAccess: ACCESS_MASK, + ObjectType: c_ulong, + HandleCount: c_ulong, + DesiredAccess: c_ulong, + GrantedAccess: c_ulong, }} pub type PALPC_HANDLE_ATTR = *mut ALPC_HANDLE_ATTR; -pub const ALPC_SECFLG_CREATE_HANDLE: ULONG = 0x20000; -STRUCT!{struct ALPC_SECURITY_ATTR { - Flags: ULONG, - QoS: PSECURITY_QUALITY_OF_SERVICE, +pub const ALPC_SECFLG_CREATE_HANDLE: c_ulong = 0x20000; +STRUCT! {struct ALPC_SECURITY_ATTR { + Flags: c_ulong, + QoS: *mut SECURITY_QUALITY_OF_SERVICE, ContextHandle: ALPC_HANDLE, }} pub type PALPC_SECURITY_ATTR = *mut ALPC_SECURITY_ATTR; -pub const ALPC_VIEWFLG_NOT_SECURE: ULONG = 0x40000; -STRUCT!{struct ALPC_DATA_VIEW_ATTR { - Flags: ULONG, +pub const ALPC_VIEWFLG_NOT_SECURE: c_ulong = 0x40000; +STRUCT! {struct ALPC_DATA_VIEW_ATTR { + Flags: c_ulong, SectionHandle: ALPC_HANDLE, - ViewBase: PVOID, - ViewSize: SIZE_T, + ViewBase: *mut c_void, + ViewSize: usize, }} pub type PALPC_DATA_VIEW_ATTR = *mut ALPC_DATA_VIEW_ATTR; -ENUM!{enum ALPC_PORT_INFORMATION_CLASS { +ENUM! {enum ALPC_PORT_INFORMATION_CLASS { AlpcBasicInformation = 0, AlpcPortInformation = 1, AlpcAssociateCompletionPortInformation = 2, @@ -411,40 +417,43 @@ ENUM!{enum ALPC_PORT_INFORMATION_CLASS { AlpcCompletionListRundownInformation = 10, AlpcWaitForPortReferences = 11, }} -STRUCT!{struct ALPC_BASIC_INFORMATION { - Flags: ULONG, - SequenceNo: ULONG, - PortContext: PVOID, +STRUCT! {struct ALPC_BASIC_INFORMATION { + Flags: c_ulong, + SequenceNo: c_ulong, + PortContext: *mut c_void, }} pub type PALPC_BASIC_INFORMATION = *mut ALPC_BASIC_INFORMATION; -STRUCT!{struct ALPC_PORT_ASSOCIATE_COMPLETION_PORT { - CompletionKey: PVOID, +STRUCT! {struct ALPC_PORT_ASSOCIATE_COMPLETION_PORT { + CompletionKey: *mut c_void, CompletionPort: HANDLE, }} -pub type PALPC_PORT_ASSOCIATE_COMPLETION_PORT = *mut ALPC_PORT_ASSOCIATE_COMPLETION_PORT; -STRUCT!{struct ALPC_SERVER_INFORMATION_Out { - ThreadBlocked: BOOLEAN, +pub type PALPC_PORT_ASSOCIATE_COMPLETION_PORT = + *mut ALPC_PORT_ASSOCIATE_COMPLETION_PORT; +STRUCT! {struct ALPC_SERVER_INFORMATION_Out { + ThreadBlocked: c_uchar, ConnectedProcessId: HANDLE, ConnectionPortName: UNICODE_STRING, }} -UNION!{union ALPC_SERVER_INFORMATION { +UNION! {union ALPC_SERVER_INFORMATION { ThreadHandle: HANDLE, Out: ALPC_SERVER_INFORMATION_Out, }} pub type PALPC_SERVER_INFORMATION = *mut ALPC_SERVER_INFORMATION; -STRUCT!{struct ALPC_PORT_MESSAGE_ZONE_INFORMATION { - Buffer: PVOID, - Size: ULONG, -}} -pub type PALPC_PORT_MESSAGE_ZONE_INFORMATION = *mut ALPC_PORT_MESSAGE_ZONE_INFORMATION; -STRUCT!{struct ALPC_PORT_COMPLETION_LIST_INFORMATION { - Buffer: PVOID, - Size: ULONG, - ConcurrencyCount: ULONG, - AttributeFlags: ULONG, -}} -pub type PALPC_PORT_COMPLETION_LIST_INFORMATION = *mut ALPC_PORT_COMPLETION_LIST_INFORMATION; -ENUM!{enum ALPC_MESSAGE_INFORMATION_CLASS { +STRUCT! {struct ALPC_PORT_MESSAGE_ZONE_INFORMATION { + Buffer: *mut c_void, + Size: c_ulong, +}} +pub type PALPC_PORT_MESSAGE_ZONE_INFORMATION = + *mut ALPC_PORT_MESSAGE_ZONE_INFORMATION; +STRUCT! {struct ALPC_PORT_COMPLETION_LIST_INFORMATION { + Buffer: *mut c_void, + Size: c_ulong, + ConcurrencyCount: c_ulong, + AttributeFlags: c_ulong, +}} +pub type PALPC_PORT_COMPLETION_LIST_INFORMATION = + *mut ALPC_PORT_COMPLETION_LIST_INFORMATION; +ENUM! {enum ALPC_MESSAGE_INFORMATION_CLASS { AlpcMessageSidInformation = 0, AlpcMessageTokenModifiedIdInformation = 1, AlpcMessageDirectStatusInformation = 2, @@ -452,206 +461,207 @@ ENUM!{enum ALPC_MESSAGE_INFORMATION_CLASS { MaxAlpcMessageInfoClass = 4, }} pub type PALPC_MESSAGE_INFORMATION_CLASS = *mut ALPC_MESSAGE_INFORMATION_CLASS; -STRUCT!{struct ALPC_MESSAGE_HANDLE_INFORMATION { - Index: ULONG, - Flags: ULONG, - Handle: ULONG, - ObjectType: ULONG, - GrantedAccess: ACCESS_MASK, -}} -pub type PALPC_MESSAGE_HANDLE_INFORMATION = *mut ALPC_MESSAGE_HANDLE_INFORMATION; -EXTERN!{extern "system" { +STRUCT! {struct ALPC_MESSAGE_HANDLE_INFORMATION { + Index: c_ulong, + Flags: c_ulong, + Handle: c_ulong, + ObjectType: c_ulong, + GrantedAccess: c_ulong, +}} +pub type PALPC_MESSAGE_HANDLE_INFORMATION = + *mut ALPC_MESSAGE_HANDLE_INFORMATION; +EXTERN! {extern "system" { fn NtAlpcCreatePort( - PortHandle: PHANDLE, - ObjectAttributes: POBJECT_ATTRIBUTES, + PortHandle: *mut HANDLE, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, PortAttributes: PALPC_PORT_ATTRIBUTES, ) -> NTSTATUS; fn NtAlpcDisconnectPort( PortHandle: HANDLE, - Flags: ULONG, + Flags: c_ulong, ) -> NTSTATUS; fn NtAlpcQueryInformation( PortHandle: HANDLE, PortInformationClass: ALPC_PORT_INFORMATION_CLASS, - PortInformation: PVOID, - Length: ULONG, - ReturnLength: PULONG, + PortInformation: *mut c_void, + Length: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn NtAlpcSetInformation( PortHandle: HANDLE, PortInformationClass: ALPC_PORT_INFORMATION_CLASS, - PortInformation: PVOID, - Length: ULONG, + PortInformation: *mut c_void, + Length: c_ulong, ) -> NTSTATUS; fn NtAlpcCreatePortSection( PortHandle: HANDLE, - Flags: ULONG, + Flags: c_ulong, SectionHandle: HANDLE, - SectionSize: SIZE_T, + SectionSize: usize, AlpcSectionHandle: PALPC_HANDLE, - ActualSectionSize: PSIZE_T, + ActualSectionSize: *mut usize, ) -> NTSTATUS; fn NtAlpcDeletePortSection( PortHandle: HANDLE, - Flags: ULONG, + Flags: c_ulong, SectionHandle: ALPC_HANDLE, ) -> NTSTATUS; fn NtAlpcCreateResourceReserve( PortHandle: HANDLE, - Flags: ULONG, - MessageSize: SIZE_T, + Flags: c_ulong, + MessageSize: usize, ResourceId: PALPC_HANDLE, ) -> NTSTATUS; fn NtAlpcDeleteResourceReserve( PortHandle: HANDLE, - Flags: ULONG, + Flags: c_ulong, ResourceId: ALPC_HANDLE, ) -> NTSTATUS; fn NtAlpcCreateSectionView( PortHandle: HANDLE, - Flags: ULONG, + Flags: c_ulong, ViewAttributes: PALPC_DATA_VIEW_ATTR, ) -> NTSTATUS; fn NtAlpcDeleteSectionView( PortHandle: HANDLE, - Flags: ULONG, - ViewBase: PVOID, + Flags: c_ulong, + ViewBase: *mut c_void, ) -> NTSTATUS; fn NtAlpcCreateSecurityContext( PortHandle: HANDLE, - Flags: ULONG, + Flags: c_ulong, SecurityAttribute: PALPC_SECURITY_ATTR, ) -> NTSTATUS; fn NtAlpcDeleteSecurityContext( PortHandle: HANDLE, - Flags: ULONG, + Flags: c_ulong, ContextHandle: ALPC_HANDLE, ) -> NTSTATUS; fn NtAlpcRevokeSecurityContext( PortHandle: HANDLE, - Flags: ULONG, + Flags: c_ulong, ContextHandle: ALPC_HANDLE, ) -> NTSTATUS; fn NtAlpcQueryInformationMessage( PortHandle: HANDLE, PortMessage: PPORT_MESSAGE, MessageInformationClass: ALPC_MESSAGE_INFORMATION_CLASS, - MessageInformation: PVOID, - Length: ULONG, - ReturnLength: PULONG, - ) -> NTSTATUS; -}} -pub const ALPC_MSGFLG_REPLY_MESSAGE: ULONG = 0x1; -pub const ALPC_MSGFLG_LPC_MODE: ULONG = 0x2; -pub const ALPC_MSGFLG_RELEASE_MESSAGE: ULONG = 0x10000; -pub const ALPC_MSGFLG_SYNC_REQUEST: ULONG = 0x20000; -pub const ALPC_MSGFLG_WAIT_USER_MODE: ULONG = 0x100000; -pub const ALPC_MSGFLG_WAIT_ALERTABLE: ULONG = 0x200000; -pub const ALPC_MSGFLG_WOW64_CALL: ULONG = 0x80000000; -EXTERN!{extern "system" { + MessageInformation: *mut c_void, + Length: c_ulong, + ReturnLength: *mut c_ulong, + ) -> NTSTATUS; +}} +pub const ALPC_MSGFLG_REPLY_MESSAGE: c_ulong = 0x1; +pub const ALPC_MSGFLG_LPC_MODE: c_ulong = 0x2; +pub const ALPC_MSGFLG_RELEASE_MESSAGE: c_ulong = 0x10000; +pub const ALPC_MSGFLG_SYNC_REQUEST: c_ulong = 0x20000; +pub const ALPC_MSGFLG_WAIT_USER_MODE: c_ulong = 0x100000; +pub const ALPC_MSGFLG_WAIT_ALERTABLE: c_ulong = 0x200000; +pub const ALPC_MSGFLG_WOW64_CALL: c_ulong = 0x80000000; +EXTERN! {extern "system" { fn NtAlpcConnectPort( - PortHandle: PHANDLE, - PortName: PUNICODE_STRING, - ObjectAttributes: POBJECT_ATTRIBUTES, + PortHandle: *mut HANDLE, + PortName: *mut UNICODE_STRING, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, PortAttributes: PALPC_PORT_ATTRIBUTES, - Flags: ULONG, + Flags: c_ulong, RequiredServerSid: PSID, ConnectionMessage: PPORT_MESSAGE, - BufferLength: PULONG, + BufferLength: *mut c_ulong, OutMessageAttributes: PALPC_MESSAGE_ATTRIBUTES, InMessageAttributes: PALPC_MESSAGE_ATTRIBUTES, - Timeout: PLARGE_INTEGER, + Timeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn NtAlpcConnectPortEx( - PortHandle: PHANDLE, - ConnectionPortObjectAttributes: POBJECT_ATTRIBUTES, - ClientPortObjectAttributes: POBJECT_ATTRIBUTES, + PortHandle: *mut HANDLE, + ConnectionPortObjectAttributes: *mut OBJECT_ATTRIBUTES, + ClientPortObjectAttributes: *mut OBJECT_ATTRIBUTES, PortAttributes: PALPC_PORT_ATTRIBUTES, - Flags: ULONG, + Flags: c_ulong, ServerSecurityRequirements: PSECURITY_DESCRIPTOR, ConnectionMessage: PPORT_MESSAGE, - BufferLength: PSIZE_T, + BufferLength: *mut usize, OutMessageAttributes: PALPC_MESSAGE_ATTRIBUTES, InMessageAttributes: PALPC_MESSAGE_ATTRIBUTES, - Timeout: PLARGE_INTEGER, + Timeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn NtAlpcAcceptConnectPort( - PortHandle: PHANDLE, + PortHandle: *mut HANDLE, ConnectionPortHandle: HANDLE, - Flags: ULONG, - ObjectAttributes: POBJECT_ATTRIBUTES, + Flags: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, PortAttributes: PALPC_PORT_ATTRIBUTES, - PortContext: PVOID, + PortContext: *mut c_void, ConnectionRequest: PPORT_MESSAGE, ConnectionMessageAttributes: PALPC_MESSAGE_ATTRIBUTES, - AcceptConnection: BOOLEAN, + AcceptConnection: c_uchar, ) -> NTSTATUS; fn NtAlpcSendWaitReceivePort( PortHandle: HANDLE, - Flags: ULONG, + Flags: c_ulong, SendMessageA: PPORT_MESSAGE, SendMessageAttributes: PALPC_MESSAGE_ATTRIBUTES, ReceiveMessage: PPORT_MESSAGE, - BufferLength: PSIZE_T, + BufferLength: *mut usize, ReceiveMessageAttributes: PALPC_MESSAGE_ATTRIBUTES, - Timeout: PLARGE_INTEGER, + Timeout: *mut LARGE_INTEGER, ) -> NTSTATUS; }} -pub const ALPC_CANCELFLG_TRY_CANCEL: ULONG = 0x1; -pub const ALPC_CANCELFLG_NO_CONTEXT_CHECK: ULONG = 0x8; -pub const ALPC_CANCELFLGP_FLUSH: ULONG = 0x10000; -EXTERN!{extern "system" { +pub const ALPC_CANCELFLG_TRY_CANCEL: c_ulong = 0x1; +pub const ALPC_CANCELFLG_NO_CONTEXT_CHECK: c_ulong = 0x8; +pub const ALPC_CANCELFLGP_FLUSH: c_ulong = 0x10000; +EXTERN! {extern "system" { fn NtAlpcCancelMessage( PortHandle: HANDLE, - Flags: ULONG, + Flags: c_ulong, MessageContext: PALPC_CONTEXT_ATTR, ) -> NTSTATUS; fn NtAlpcImpersonateClientOfPort( PortHandle: HANDLE, Message: PPORT_MESSAGE, - Flags: PVOID, + Flags: *mut c_void, ) -> NTSTATUS; fn NtAlpcImpersonateClientContainerOfPort( PortHandle: HANDLE, Message: PPORT_MESSAGE, - Flags: ULONG, + Flags: c_ulong, ) -> NTSTATUS; fn NtAlpcOpenSenderProcess( - ProcessHandle: PHANDLE, + ProcessHandle: *mut HANDLE, PortHandle: HANDLE, PortMessage: PPORT_MESSAGE, - Flags: ULONG, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + Flags: c_ulong, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn NtAlpcOpenSenderThread( - ThreadHandle: PHANDLE, + ThreadHandle: *mut HANDLE, PortHandle: HANDLE, PortMessage: PPORT_MESSAGE, - Flags: ULONG, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + Flags: c_ulong, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; - fn AlpcMaxAllowedMessageLength() -> ULONG; + fn AlpcMaxAllowedMessageLength() -> c_ulong; fn AlpcGetHeaderSize( - Flags: ULONG, - ) -> ULONG; + Flags: c_ulong, + ) -> c_ulong; fn AlpcInitializeMessageAttribute( - AttributeFlags: ULONG, + AttributeFlags: c_ulong, Buffer: PALPC_MESSAGE_ATTRIBUTES, - BufferSize: ULONG, - RequiredBufferSize: PULONG, + BufferSize: c_ulong, + RequiredBufferSize: *mut c_ulong, ) -> NTSTATUS; fn AlpcGetMessageAttribute( Buffer: PALPC_MESSAGE_ATTRIBUTES, - AttributeFlag: ULONG, - ) -> PVOID; + AttributeFlag: c_ulong, + ) -> *mut c_void; fn AlpcRegisterCompletionList( PortHandle: HANDLE, Buffer: PALPC_COMPLETION_LIST_HEADER, - Size: ULONG, - ConcurrencyCount: ULONG, - AttributeFlags: ULONG, + Size: c_ulong, + ConcurrencyCount: c_ulong, + AttributeFlags: c_ulong, ) -> NTSTATUS; fn AlpcUnregisterCompletionList( PortHandle: HANDLE, @@ -661,32 +671,32 @@ EXTERN!{extern "system" { ) -> NTSTATUS; fn AlpcAdjustCompletionListConcurrencyCount( PortHandle: HANDLE, - ConcurrencyCount: ULONG, + ConcurrencyCount: c_ulong, ) -> NTSTATUS; fn AlpcRegisterCompletionListWorkerThread( - CompletionList: PVOID, - ) -> BOOLEAN; + CompletionList: *mut c_void, + ) -> c_uchar; fn AlpcUnregisterCompletionListWorkerThread( - CompletionList: PVOID, - ) -> BOOLEAN; + CompletionList: *mut c_void, + ) -> c_uchar; fn AlpcGetCompletionListLastMessageInformation( - CompletionList: PVOID, - LastMessageId: PULONG, - LastCallbackId: PULONG, + CompletionList: *mut c_void, + LastMessageId: *mut c_ulong, + LastCallbackId: *mut c_ulong, ); fn AlpcGetOutstandingCompletionListMessageCount( - CompletionList: PVOID, - ) -> ULONG; + CompletionList: *mut c_void, + ) -> c_ulong; fn AlpcGetMessageFromCompletionList( - CompletionList: PVOID, + CompletionList: *mut c_void, MessageAttributes: *mut PALPC_MESSAGE_ATTRIBUTES, ) -> PPORT_MESSAGE; fn AlpcFreeCompletionListMessage( - CompletionList: PVOID, + CompletionList: *mut c_void, Message: PPORT_MESSAGE, ); fn AlpcGetCompletionListMessageAttributes( - CompletionList: PVOID, + CompletionList: *mut c_void, Message: PPORT_MESSAGE, ) -> PALPC_MESSAGE_ATTRIBUTES; }} diff --git a/src/ntmisc.rs b/src/ntmisc.rs index 7f57999..d60dc8f 100644 --- a/src/ntmisc.rs +++ b/src/ntmisc.rs @@ -1,8 +1,13 @@ -use winapi::shared::ntdef::{HANDLE, NTSTATUS, PULONG, PVOID, ULONG}; -use winapi::um::winnt::STANDARD_RIGHTS_ALL; +use windows_sys::Win32::{ + Foundation::{HANDLE, NTSTATUS}, + Storage::FileSystem::STANDARD_RIGHTS_ALL, +}; + +use crate::ctypes::{c_ulong, c_void}; + pub const FLT_PORT_CONNECT: u32 = 0x0001; pub const FLT_PORT_ALL_ACCESS: u32 = FLT_PORT_CONNECT | STANDARD_RIGHTS_ALL; -ENUM!{enum VDMSERVICECLASS { +ENUM! {enum VDMSERVICECLASS { VdmStartExecution = 0, VdmQueueInterrupt = 1, VdmDelayInterrupt = 2, @@ -20,23 +25,23 @@ ENUM!{enum VDMSERVICECLASS { VdmQueryVdmProcess = 14, }} pub type PVDMSERVICECLASS = *mut VDMSERVICECLASS; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtVdmControl( Service: VDMSERVICECLASS, - ServiceData: PVOID, + ServiceData: *mut c_void, ) -> NTSTATUS; fn NtTraceEvent( TraceHandle: HANDLE, - Flags: ULONG, - FieldSize: ULONG, - Fields: PVOID, + Flags: c_ulong, + FieldSize: c_ulong, + Fields: *mut c_void, ) -> NTSTATUS; fn NtTraceControl( - FunctionCode: ULONG, - InBuffer: PVOID, - InBufferLen: ULONG, - OutBuffer: PVOID, - OutBufferLen: ULONG, - ReturnLength: PULONG, + FunctionCode: c_ulong, + InBuffer: *mut c_void, + InBufferLen: c_ulong, + OutBuffer: *mut c_void, + OutBufferLen: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; }} diff --git a/src/ntmmapi.rs b/src/ntmmapi.rs index 7cae677..d33b7d3 100644 --- a/src/ntmmapi.rs +++ b/src/ntmmapi.rs @@ -1,13 +1,19 @@ -use crate::winapi_local::um::winnt::PMEM_EXTENDED_PARAMETER; -use winapi::shared::basetsd::{PSIZE_T, PULONG_PTR, SIZE_T, ULONG_PTR}; -use winapi::shared::ntdef::{ - BOOLEAN, HANDLE, LARGE_INTEGER, NTSTATUS, PHANDLE, PLARGE_INTEGER, POBJECT_ATTRIBUTES, PULONG, - PUNICODE_STRING, PVOID, UCHAR, ULONG, ULONGLONG, UNICODE_STRING, USHORT, +use windows_sys::Win32::{ + Foundation::{HANDLE, NTSTATUS, UNICODE_STRING}, + Storage::FileSystem::{STANDARD_RIGHTS_REQUIRED, SYNCHRONIZE}, + System::{ + Memory::CFG_CALL_TARGET_INFO, WindowsProgramming::OBJECT_ATTRIBUTES, + }, }; -use winapi::um::winnt::{ - ACCESS_MASK, PCFG_CALL_TARGET_INFO, STANDARD_RIGHTS_REQUIRED, SYNCHRONIZE, + +use crate::{ + ctypes::{__uint64, c_uchar, c_ulong, c_ushort, c_void}, + windows_local::{ + shared::ntdef::LARGE_INTEGER, um::winnt::PMEM_EXTENDED_PARAMETER, + }, }; -ENUM!{enum MEMORY_INFORMATION_CLASS { + +ENUM! {enum MEMORY_INFORMATION_CLASS { MemoryBasicInformation = 0, MemoryWorkingSetInformation = 1, MemoryMappedFilenameInformation = 2, @@ -20,11 +26,11 @@ ENUM!{enum MEMORY_INFORMATION_CLASS { MemoryEnclaveImageInformation = 9, MemoryBasicInformationCapped = 10, }} -STRUCT!{struct MEMORY_WORKING_SET_BLOCK { - Bitfields: ULONG_PTR, +STRUCT! {struct MEMORY_WORKING_SET_BLOCK { + Bitfields: usize, }} #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] -BITFIELD!{MEMORY_WORKING_SET_BLOCK Bitfields: ULONG_PTR [ +BITFIELD! {MEMORY_WORKING_SET_BLOCK Bitfields: usize [ Protection set_Protection[0..5], ShareCount set_ShareCount[5..8], Shared set_Shared[8..9], @@ -32,7 +38,7 @@ BITFIELD!{MEMORY_WORKING_SET_BLOCK Bitfields: ULONG_PTR [ VirtualPage set_VirtualPage[12..64], ]} #[cfg(target_arch = "x86")] -BITFIELD!{MEMORY_WORKING_SET_BLOCK Bitfields: ULONG_PTR [ +BITFIELD! {MEMORY_WORKING_SET_BLOCK Bitfields: usize [ Protection set_Protection[0..5], ShareCount set_ShareCount[5..8], Shared set_Shared[8..9], @@ -40,19 +46,19 @@ BITFIELD!{MEMORY_WORKING_SET_BLOCK Bitfields: ULONG_PTR [ VirtualPage set_VirtualPage[12..32], ]} pub type PMEMORY_WORKING_SET_BLOCK = *mut MEMORY_WORKING_SET_BLOCK; -STRUCT!{struct MEMORY_WORKING_SET_INFORMATION { - NumberOfEntries: ULONG_PTR, +STRUCT! {struct MEMORY_WORKING_SET_INFORMATION { + NumberOfEntries: usize, WorkingSetInfo: [MEMORY_WORKING_SET_BLOCK; 1], }} pub type PMEMORY_WORKING_SET_INFORMATION = *mut MEMORY_WORKING_SET_INFORMATION; -STRUCT!{struct MEMORY_REGION_INFORMATION { - AllocationBase: PVOID, - AllocationProtect: ULONG, - RegionType: ULONG, - RegionSize: SIZE_T, - CommitSize: SIZE_T, -}} -BITFIELD!{MEMORY_REGION_INFORMATION RegionType: ULONG [ +STRUCT! {struct MEMORY_REGION_INFORMATION { + AllocationBase: *mut c_void, + AllocationProtect: c_ulong, + RegionType: c_ulong, + RegionSize: usize, + CommitSize: usize, +}} +BITFIELD! {MEMORY_REGION_INFORMATION RegionType: c_ulong [ Private set_Private[0..1], MappedDataFile set_MappedDataFile[1..2], MappedImage set_MappedImage[2..3], @@ -65,21 +71,21 @@ BITFIELD!{MEMORY_REGION_INFORMATION RegionType: ULONG [ Reserved set_Reserved[9..32], ]} pub type PMEMORY_REGION_INFORMATION = *mut MEMORY_REGION_INFORMATION; -ENUM!{enum MEMORY_WORKING_SET_EX_LOCATION { +ENUM! {enum MEMORY_WORKING_SET_EX_LOCATION { MemoryLocationInvalid = 0, MemoryLocationResident = 1, MemoryLocationPagefile = 2, MemoryLocationReserved = 3, }} -UNION!{union MEMORY_WORKING_SET_EX_BLOCK_u { - Bitfields: ULONG_PTR, - Invalid: ULONG_PTR, +UNION! {union MEMORY_WORKING_SET_EX_BLOCK_u { + Bitfields: usize, + Invalid: usize, }} -STRUCT!{struct MEMORY_WORKING_SET_EX_BLOCK { +STRUCT! {struct MEMORY_WORKING_SET_EX_BLOCK { u: MEMORY_WORKING_SET_EX_BLOCK_u, }} #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] -BITFIELD!{unsafe MEMORY_WORKING_SET_EX_BLOCK_u Bitfields: ULONG_PTR [ +BITFIELD! {unsafe MEMORY_WORKING_SET_EX_BLOCK_u Bitfields: usize [ Valid set_Valid[0..1], ShareCount set_ShareCount[1..4], Win32Protection set_Win32Protection[4..15], @@ -94,7 +100,7 @@ BITFIELD!{unsafe MEMORY_WORKING_SET_EX_BLOCK_u Bitfields: ULONG_PTR [ ReservedUlong set_ReservedUlong[32..64], ]} #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] -BITFIELD!{unsafe MEMORY_WORKING_SET_EX_BLOCK_u Invalid: ULONG_PTR [ +BITFIELD! {unsafe MEMORY_WORKING_SET_EX_BLOCK_u Invalid: usize [ Invalid_Valid set_Invalid_Valid[0..1], Invalid_Reserved0 set_Invalid_Reserved0[1..15], Invalid_Shared set_Invalid_Shared[15..16], @@ -109,7 +115,7 @@ BITFIELD!{unsafe MEMORY_WORKING_SET_EX_BLOCK_u Invalid: ULONG_PTR [ Invalid_ReservedUlong set_Invalid_ReservedUlong[32..64], ]} #[cfg(target_arch = "x86")] -BITFIELD!{unsafe MEMORY_WORKING_SET_EX_BLOCK_u Bitfields: ULONG_PTR [ +BITFIELD! {unsafe MEMORY_WORKING_SET_EX_BLOCK_u Bitfields: usize [ Valid set_Valid[0..1], ShareCount set_ShareCount[1..4], Win32Protection set_Win32Protection[4..15], @@ -123,7 +129,7 @@ BITFIELD!{unsafe MEMORY_WORKING_SET_EX_BLOCK_u Bitfields: ULONG_PTR [ Bad set_Bad[31..32], ]} #[cfg(target_arch = "x86")] -BITFIELD!{unsafe MEMORY_WORKING_SET_EX_BLOCK_u Invalid: ULONG_PTR [ +BITFIELD! {unsafe MEMORY_WORKING_SET_EX_BLOCK_u Invalid: usize [ Invalid_Valid set_Invalid_Valid[0..1], Invalid_Reserved0 set_Invalid_Reserved0[1..15], Invalid_Shared set_Invalid_Shared[15..16], @@ -137,33 +143,36 @@ BITFIELD!{unsafe MEMORY_WORKING_SET_EX_BLOCK_u Invalid: ULONG_PTR [ Invalid_Bad set_Invalid_Bad[31..32], ]} pub type PMEMORY_WORKING_SET_EX_BLOCK = *mut MEMORY_WORKING_SET_EX_BLOCK; -STRUCT!{struct MEMORY_WORKING_SET_EX_INFORMATION { - VirtualAddress: PVOID, +STRUCT! {struct MEMORY_WORKING_SET_EX_INFORMATION { + VirtualAddress: *mut c_void, VirtualAttributes: MEMORY_WORKING_SET_EX_BLOCK, }} -pub type PMEMORY_WORKING_SET_EX_INFORMATION = *mut MEMORY_WORKING_SET_EX_INFORMATION; -STRUCT!{struct MEMORY_SHARED_COMMIT_INFORMATION { - CommitSize: SIZE_T, +pub type PMEMORY_WORKING_SET_EX_INFORMATION = + *mut MEMORY_WORKING_SET_EX_INFORMATION; +STRUCT! {struct MEMORY_SHARED_COMMIT_INFORMATION { + CommitSize: usize, }} -pub type PMEMORY_SHARED_COMMIT_INFORMATION = *mut MEMORY_SHARED_COMMIT_INFORMATION; -STRUCT!{struct MEMORY_IMAGE_INFORMATION { - ImageBase: PVOID, - SizeOfImage: SIZE_T, - ImageFlags: ULONG, +pub type PMEMORY_SHARED_COMMIT_INFORMATION = + *mut MEMORY_SHARED_COMMIT_INFORMATION; +STRUCT! {struct MEMORY_IMAGE_INFORMATION { + ImageBase: *mut c_void, + SizeOfImage: usize, + ImageFlags: c_ulong, }} -BITFIELD!{MEMORY_IMAGE_INFORMATION ImageFlags: ULONG [ +BITFIELD! {MEMORY_IMAGE_INFORMATION ImageFlags: c_ulong [ ImagePartialMap set_ImagePartialMap[0..1], ImageNotExecutable set_ImageNotExecutable[1..2], ImageSigningLevel set_ImageSigningLevel[2..6], Reserved set_Reserved[6..32], ]} pub type PMEMORY_IMAGE_INFORMATION = *mut MEMORY_IMAGE_INFORMATION; -STRUCT!{struct MEMORY_ENCLAVE_IMAGE_INFORMATION { +STRUCT! {struct MEMORY_ENCLAVE_IMAGE_INFORMATION { ImageInfo: MEMORY_IMAGE_INFORMATION, - UniqueID: [UCHAR; 32], - AuthorID: [UCHAR; 32], + UniqueID: [c_uchar; 32], + AuthorID: [c_uchar; 32], }} -pub type PMEMORY_ENCLAVE_IMAGE_INFORMATION = *mut MEMORY_ENCLAVE_IMAGE_INFORMATION; +pub type PMEMORY_ENCLAVE_IMAGE_INFORMATION = + *mut MEMORY_ENCLAVE_IMAGE_INFORMATION; pub const MMPFNLIST_ZERO: u32 = 0; pub const MMPFNLIST_FREE: u32 = 1; pub const MMPFNLIST_STANDBY: u32 = 2; @@ -184,10 +193,10 @@ pub const MMPFNUSE_METAFILE: u32 = 8; pub const MMPFNUSE_AWEPAGE: u32 = 9; pub const MMPFNUSE_DRIVERLOCKPAGE: u32 = 10; pub const MMPFNUSE_KERNELSTACK: u32 = 11; -STRUCT!{struct MEMORY_FRAME_INFORMATION { - Bitfields: ULONGLONG, +STRUCT! {struct MEMORY_FRAME_INFORMATION { + Bitfields: __uint64, }} -BITFIELD!{MEMORY_FRAME_INFORMATION Bitfields: ULONGLONG [ +BITFIELD! {MEMORY_FRAME_INFORMATION Bitfields: __uint64 [ UseDescription set_UseDescription[0..4], ListDescription set_ListDescription[4..7], Reserved0 set_Reserved0[7..8], @@ -196,61 +205,61 @@ BITFIELD!{MEMORY_FRAME_INFORMATION Bitfields: ULONGLONG [ Priority set_Priority[57..60], Reserved set_Reserved[60..64], ]} -STRUCT!{struct FILEOFFSET_INFORMATION { - Bitfields: ULONGLONG, +STRUCT! {struct FILEOFFSET_INFORMATION { + Bitfields: __uint64, }} -BITFIELD!{FILEOFFSET_INFORMATION Bitfields: ULONGLONG [ +BITFIELD! {FILEOFFSET_INFORMATION Bitfields: __uint64 [ DontUse set_DontUse[0..9], Offset set_Offset[9..57], Reserved set_Reserved[57..64], ]} -STRUCT!{struct PAGEDIR_INFORMATION { - Bitfields: ULONGLONG, +STRUCT! {struct PAGEDIR_INFORMATION { + Bitfields: __uint64, }} -BITFIELD!{PAGEDIR_INFORMATION Bitfields: ULONGLONG [ +BITFIELD! {PAGEDIR_INFORMATION Bitfields: __uint64 [ DontUse set_DontUse[0..9], PageDirectoryBase set_PageDirectoryBase[9..57], Reserved set_Reserved[57..64], ]} -STRUCT!{struct UNIQUE_PROCESS_INFORMATION { - Bitfields: ULONGLONG, +STRUCT! {struct UNIQUE_PROCESS_INFORMATION { + Bitfields: __uint64, }} -BITFIELD!{UNIQUE_PROCESS_INFORMATION Bitfields: ULONGLONG [ +BITFIELD! {UNIQUE_PROCESS_INFORMATION Bitfields: __uint64 [ DontUse set_DontUse[0..9], UniqueProcessKey set_UniqueProcessKey[9..57], Reserved set_Reserved[57..64], ]} pub type PUNIQUE_PROCESS_INFORMATION = *mut UNIQUE_PROCESS_INFORMATION; -UNION!{union MMPFN_IDENTITY_u1 { +UNION! {union MMPFN_IDENTITY_u1 { e1: MEMORY_FRAME_INFORMATION, e2: FILEOFFSET_INFORMATION, e3: PAGEDIR_INFORMATION, e4: UNIQUE_PROCESS_INFORMATION, }} -UNION!{union MMPFN_IDENTITY_u2 { - e1: ULONG_PTR, - e2_CombinedPage: ULONG_PTR, - FileObject: ULONG_PTR, - UniqueFileObjectKey: ULONG_PTR, - ProtoPteAddress: ULONG_PTR, - VirtualAddress: ULONG_PTR, +UNION! {union MMPFN_IDENTITY_u2 { + e1: usize, + e2_CombinedPage: usize, + FileObject: usize, + UniqueFileObjectKey: usize, + ProtoPteAddress: usize, + VirtualAddress: usize, }} -STRUCT!{struct MMPFN_IDENTITY { +STRUCT! {struct MMPFN_IDENTITY { u1: MMPFN_IDENTITY_u1, - PageFrameIndex: ULONG_PTR, + PageFrameIndex: usize, u2: MMPFN_IDENTITY_u2, }} -BITFIELD!{unsafe MMPFN_IDENTITY_u2 e1: ULONG_PTR [ +BITFIELD! {unsafe MMPFN_IDENTITY_u2 e1: usize [ Image set_Image[0..1], Mismatch set_Mismatch[1..2], ]} pub type PMMPFN_IDENTITY = *mut MMPFN_IDENTITY; -STRUCT!{struct MMPFN_MEMSNAP_INFORMATION { - InitialPageFrameIndex: ULONG_PTR, - Count: ULONG_PTR, +STRUCT! {struct MMPFN_MEMSNAP_INFORMATION { + InitialPageFrameIndex: usize, + Count: usize, }} pub type PMMPFN_MEMSNAP_INFORMATION = *mut MMPFN_MEMSNAP_INFORMATION; -ENUM!{enum SECTION_INFORMATION_CLASS { +ENUM! {enum SECTION_INFORMATION_CLASS { SectionBasicInformation = 0, SectionImageInformation = 1, SectionRelocationInformation = 2, @@ -258,46 +267,46 @@ ENUM!{enum SECTION_INFORMATION_CLASS { SectionInternalImageInformation = 4, MaxSectionInfoClass = 5, }} -STRUCT!{struct SECTION_BASIC_INFORMATION { - BaseAddress: PVOID, - AllocationAttributes: ULONG, +STRUCT! {struct SECTION_BASIC_INFORMATION { + BaseAddress: *mut c_void, + AllocationAttributes: c_ulong, MaximumSize: LARGE_INTEGER, }} pub type PSECTION_BASIC_INFORMATION = *mut SECTION_BASIC_INFORMATION; -STRUCT!{struct SECTION_IMAGE_INFORMATION_u1_s { - SubSystemMinorVersion: USHORT, - SubSystemMajorVersion: USHORT, +STRUCT! {struct SECTION_IMAGE_INFORMATION_u1_s { + SubSystemMinorVersion: c_ushort, + SubSystemMajorVersion: c_ushort, }} -UNION!{union SECTION_IMAGE_INFORMATION_u1 { +UNION! {union SECTION_IMAGE_INFORMATION_u1 { s: SECTION_IMAGE_INFORMATION_u1_s, - SubSystemVersion: ULONG, + SubSystemVersion: c_ulong, }} -STRUCT!{struct SECTION_IMAGE_INFORMATION_u2_s { - MajorOperatingSystemVersion: USHORT, - MinorOperatingSystemVersion: USHORT, +STRUCT! {struct SECTION_IMAGE_INFORMATION_u2_s { + MajorOperatingSystemVersion: c_ushort, + MinorOperatingSystemVersion: c_ushort, }} -UNION!{union SECTION_IMAGE_INFORMATION_u2 { +UNION! {union SECTION_IMAGE_INFORMATION_u2 { s: SECTION_IMAGE_INFORMATION_u2_s, - OperatingSystemVersion: ULONG, -}} -STRUCT!{struct SECTION_IMAGE_INFORMATION { - TransferAddress: PVOID, - ZeroBits: ULONG, - MaximumStackSize: SIZE_T, - CommittedStackSize: SIZE_T, - SubSystemType: ULONG, + OperatingSystemVersion: c_ulong, +}} +STRUCT! {struct SECTION_IMAGE_INFORMATION { + TransferAddress: *mut c_void, + ZeroBits: c_ulong, + MaximumStackSize: usize, + CommittedStackSize: usize, + SubSystemType: c_ulong, u1: SECTION_IMAGE_INFORMATION_u1, u2: SECTION_IMAGE_INFORMATION_u2, - ImageCharacteristics: USHORT, - DllCharacteristics: USHORT, - Machine: USHORT, - ImageContainsCode: BOOLEAN, - ImageFlags: UCHAR, - LoaderFlags: ULONG, - ImageFileSize: ULONG, - CheckSum: ULONG, -}} -BITFIELD!{SECTION_IMAGE_INFORMATION ImageFlags: UCHAR [ + ImageCharacteristics: c_ushort, + DllCharacteristics: c_ushort, + Machine: c_ushort, + ImageContainsCode: c_uchar, + ImageFlags: c_uchar, + LoaderFlags: c_ulong, + ImageFileSize: c_ulong, + CheckSum: c_ulong, +}} +BITFIELD! {SECTION_IMAGE_INFORMATION ImageFlags: c_uchar [ ComPlusNativeReady set_ComPlusNativeReady[0..1], ComPlusILOnly set_ComPlusILOnly[1..2], ImageDynamicallyRelocated set_ImageDynamicallyRelocated[2..3], @@ -307,16 +316,17 @@ BITFIELD!{SECTION_IMAGE_INFORMATION ImageFlags: UCHAR [ Reserved set_Reserved[6..8], ]} pub type PSECTION_IMAGE_INFORMATION = *mut SECTION_IMAGE_INFORMATION; -STRUCT!{struct SECTION_INTERNAL_IMAGE_INFORMATION { +STRUCT! {struct SECTION_INTERNAL_IMAGE_INFORMATION { SectionInformation: SECTION_IMAGE_INFORMATION, - ExtendedFlags: ULONG, + ExtendedFlags: c_ulong, }} -BITFIELD!{SECTION_INTERNAL_IMAGE_INFORMATION ExtendedFlags: ULONG [ +BITFIELD! {SECTION_INTERNAL_IMAGE_INFORMATION ExtendedFlags: c_ulong [ ImageExportSuppressionEnabled set_ImageExportSuppressionEnabled[0..1], Reserved set_Reserved[1..32], ]} -pub type PSECTION_INTERNAL_IMAGE_INFORMATION = *mut SECTION_INTERNAL_IMAGE_INFORMATION; -ENUM!{enum SECTION_INHERIT { +pub type PSECTION_INTERNAL_IMAGE_INFORMATION = + *mut SECTION_INTERNAL_IMAGE_INFORMATION; +ENUM! {enum SECTION_INHERIT { ViewShare = 1, ViewUnmap = 2, }} @@ -330,159 +340,162 @@ pub const MEM_EXECUTE_OPTION_PERMANENT: u32 = 0x8; pub const MEM_EXECUTE_OPTION_EXECUTE_DISPATCH_ENABLE: u32 = 0x10; pub const MEM_EXECUTE_OPTION_IMAGE_DISPATCH_ENABLE: u32 = 0x20; pub const MEM_EXECUTE_OPTION_VALID_FLAGS: u32 = 0x3f; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtAllocateVirtualMemory( ProcessHandle: HANDLE, - BaseAddress: *mut PVOID, - ZeroBits: ULONG_PTR, - RegionSize: PSIZE_T, - AllocationType: ULONG, - Protect: ULONG, + BaseAddress: *mut *mut c_void, + ZeroBits: usize, + RegionSize: *mut usize, + AllocationType: c_ulong, + Protect: c_ulong, ) -> NTSTATUS; fn NtFreeVirtualMemory( ProcessHandle: HANDLE, - BaseAddress: *mut PVOID, - RegionSize: PSIZE_T, - FreeType: ULONG, + BaseAddress: *mut *mut c_void, + RegionSize: *mut usize, + FreeType: c_ulong, ) -> NTSTATUS; fn NtReadVirtualMemory( ProcessHandle: HANDLE, - BaseAddress: PVOID, - Buffer: PVOID, - BufferSize: SIZE_T, - NumberOfBytesRead: PSIZE_T, + BaseAddress: *mut c_void, + Buffer: *mut c_void, + BufferSize: usize, + NumberOfBytesRead: *mut usize, ) -> NTSTATUS; fn NtWriteVirtualMemory( ProcessHandle: HANDLE, - BaseAddress: PVOID, - Buffer: PVOID, - BufferSize: SIZE_T, - NumberOfBytesWritten: PSIZE_T, + BaseAddress: *mut c_void, + Buffer: *mut c_void, + BufferSize: usize, + NumberOfBytesWritten: *mut usize, ) -> NTSTATUS; fn NtProtectVirtualMemory( ProcessHandle: HANDLE, - BaseAddress: *mut PVOID, - RegionSize: PSIZE_T, - NewProtect: ULONG, - OldProtect: PULONG, + BaseAddress: *mut *mut c_void, + RegionSize: *mut usize, + NewProtect: c_ulong, + OldProtect: *mut c_ulong, ) -> NTSTATUS; fn NtQueryVirtualMemory( ProcessHandle: HANDLE, - BaseAddress: PVOID, + BaseAddress: *mut c_void, MemoryInformationClass: MEMORY_INFORMATION_CLASS, - MemoryInformation: PVOID, - MemoryInformationLength: SIZE_T, - ReturnLength: PSIZE_T, + MemoryInformation: *mut c_void, + MemoryInformationLength: usize, + ReturnLength: *mut usize, ) -> NTSTATUS; }} -ENUM!{enum VIRTUAL_MEMORY_INFORMATION_CLASS { +ENUM! {enum VIRTUAL_MEMORY_INFORMATION_CLASS { VmPrefetchInformation = 0, VmPagePriorityInformation = 1, VmCfgCallTargetInformation = 2, VmPageDirtyStateInformation = 3, }} -STRUCT!{struct MEMORY_RANGE_ENTRY { - VirtualAddress: PVOID, - NumberOfBytes: SIZE_T, +STRUCT! {struct MEMORY_RANGE_ENTRY { + VirtualAddress: *mut c_void, + NumberOfBytes: usize, }} pub type PMEMORY_RANGE_ENTRY = *mut MEMORY_RANGE_ENTRY; -STRUCT!{struct CFG_CALL_TARGET_LIST_INFORMATION { - NumberOfEntries: ULONG, - Reserved: ULONG, - NumberOfEntriesProcessed: PULONG, - CallTargetInfo: PCFG_CALL_TARGET_INFO, - Section: PVOID, - FileOffset: ULONGLONG, -}} -pub type PCFG_CALL_TARGET_LIST_INFORMATION = *mut CFG_CALL_TARGET_LIST_INFORMATION; -EXTERN!{extern "system" { +STRUCT! {struct CFG_CALL_TARGET_LIST_INFORMATION { + NumberOfEntries: c_ulong, + Reserved: c_ulong, + NumberOfEntriesProcessed: *mut c_ulong, + CallTargetInfo: *mut CFG_CALL_TARGET_INFO, + Section: *mut c_void, + FileOffset: __uint64, +}} +pub type PCFG_CALL_TARGET_LIST_INFORMATION = + *mut CFG_CALL_TARGET_LIST_INFORMATION; +EXTERN! {extern "system" { fn NtSetInformationVirtualMemory( ProcessHandle: HANDLE, VmInformationClass: VIRTUAL_MEMORY_INFORMATION_CLASS, - NumberOfEntries: ULONG_PTR, + NumberOfEntries: usize, VirtualAddresses: PMEMORY_RANGE_ENTRY, - VmInformation: PVOID, - VmInformationLength: ULONG, + VmInformation: *mut c_void, + VmInformationLength: c_ulong, ) -> NTSTATUS; fn NtLockVirtualMemory( ProcessHandle: HANDLE, - BaseAddress: *mut PVOID, - RegionSize: PSIZE_T, - MapType: ULONG, + BaseAddress: *mut *mut c_void, + RegionSize: *mut usize, + MapType: c_ulong, ) -> NTSTATUS; fn NtUnlockVirtualMemory( ProcessHandle: HANDLE, - BaseAddress: *mut PVOID, - RegionSize: PSIZE_T, - MapType: ULONG, + BaseAddress: *mut *mut c_void, + RegionSize: *mut usize, + MapType: c_ulong, ) -> NTSTATUS; fn NtCreateSection( - SectionHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - MaximumSize: PLARGE_INTEGER, - SectionPageProtection: ULONG, - AllocationAttributes: ULONG, + SectionHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + MaximumSize: *mut LARGE_INTEGER, + SectionPageProtection: c_ulong, + AllocationAttributes: c_ulong, FileHandle: HANDLE, ) -> NTSTATUS; fn NtCreateSectionEx( - SectionHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - MaximumSize: PLARGE_INTEGER, - SectionPageProtection: ULONG, - AllocationAttributes: ULONG, + SectionHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + MaximumSize: *mut LARGE_INTEGER, + SectionPageProtection: c_ulong, + AllocationAttributes: c_ulong, FileHandle: HANDLE, ExtendedParameters: PMEM_EXTENDED_PARAMETER, - ExtendedParameterCount: ULONG, + ExtendedParameterCount: c_ulong, ) -> NTSTATUS; fn NtOpenSection( - SectionHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + SectionHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn NtMapViewOfSection( SectionHandle: HANDLE, ProcessHandle: HANDLE, - BaseAddress: *mut PVOID, - ZeroBits: ULONG_PTR, - CommitSize: SIZE_T, - SectionOffset: PLARGE_INTEGER, - ViewSize: PSIZE_T, + BaseAddress: *mut *mut c_void, + ZeroBits: usize, + CommitSize: usize, + SectionOffset: *mut LARGE_INTEGER, + ViewSize: *mut usize, InheritDisposition: SECTION_INHERIT, - AllocationType: ULONG, - Win32Protect: ULONG, + AllocationType: c_ulong, + Win32Protect: c_ulong, ) -> NTSTATUS; fn NtUnmapViewOfSection( ProcessHandle: HANDLE, - BaseAddress: PVOID, + BaseAddress: *mut c_void, ) -> NTSTATUS; fn NtUnmapViewOfSectionEx( ProcessHandle: HANDLE, - BaseAddress: PVOID, - Flags: ULONG, + BaseAddress: *mut c_void, + Flags: c_ulong, ) -> NTSTATUS; fn NtExtendSection( SectionHandle: HANDLE, - NewSectionSize: PLARGE_INTEGER, + NewSectionSize: *mut LARGE_INTEGER, ) -> NTSTATUS; fn NtQuerySection( SectionHandle: HANDLE, SectionInformationClass: SECTION_INFORMATION_CLASS, - SectionInformation: PVOID, - SectionInformationLength: SIZE_T, - ReturnLength: PSIZE_T, + SectionInformation: *mut c_void, + SectionInformationLength: usize, + ReturnLength: *mut usize, ) -> NTSTATUS; fn NtAreMappedFilesTheSame( - File1MappedAsAnImage: PVOID, - File2MappedAsFile: PVOID, + File1MappedAsAnImage: *mut c_void, + File2MappedAsFile: *mut c_void, ) -> NTSTATUS; }} pub const MEMORY_PARTITION_QUERY_ACCESS: u32 = 0x0001; pub const MEMORY_PARTITION_MODIFY_ACCESS: u32 = 0x0002; -pub const MEMORY_PARTITION_ALL_ACCESS: u32 = STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE - | MEMORY_PARTITION_QUERY_ACCESS | MEMORY_PARTITION_MODIFY_ACCESS; -ENUM!{enum MEMORY_PARTITION_INFORMATION_CLASS { +pub const MEMORY_PARTITION_ALL_ACCESS: u32 = STANDARD_RIGHTS_REQUIRED + | SYNCHRONIZE + | MEMORY_PARTITION_QUERY_ACCESS + | MEMORY_PARTITION_MODIFY_ACCESS; +ENUM! {enum MEMORY_PARTITION_INFORMATION_CLASS { SystemMemoryPartitionInformation = 0, SystemMemoryPartitionMoveMemory = 1, SystemMemoryPartitionAddPagefile = 2, @@ -491,140 +504,143 @@ ENUM!{enum MEMORY_PARTITION_INFORMATION_CLASS { SystemMemoryPartitionGetMemoryEvents = 5, SystemMemoryPartitionMax = 6, }} -STRUCT!{struct MEMORY_PARTITION_CONFIGURATION_INFORMATION { - Flags: ULONG, - NumaNode: ULONG, - Channel: ULONG, - NumberOfNumaNodes: ULONG, - ResidentAvailablePages: ULONG_PTR, - CommittedPages: ULONG_PTR, - CommitLimit: ULONG_PTR, - PeakCommitment: ULONG_PTR, - TotalNumberOfPages: ULONG_PTR, - AvailablePages: ULONG_PTR, - ZeroPages: ULONG_PTR, - FreePages: ULONG_PTR, - StandbyPages: ULONG_PTR, - StandbyPageCountByPriority: [ULONG_PTR; 8], - RepurposedPagesByPriority: [ULONG_PTR; 8], - MaximumCommitLimit: ULONG_PTR, - DonatedPagesToPartitions: ULONG_PTR, - PartitionId: ULONG, +STRUCT! {struct MEMORY_PARTITION_CONFIGURATION_INFORMATION { + Flags: c_ulong, + NumaNode: c_ulong, + Channel: c_ulong, + NumberOfNumaNodes: c_ulong, + ResidentAvailablePages: usize, + CommittedPages: usize, + CommitLimit: usize, + PeakCommitment: usize, + TotalNumberOfPages: usize, + AvailablePages: usize, + ZeroPages: usize, + FreePages: usize, + StandbyPages: usize, + StandbyPageCountByPriority: [usize; 8], + RepurposedPagesByPriority: [usize; 8], + MaximumCommitLimit: usize, + DonatedPagesToPartitions: usize, + PartitionId: c_ulong, }} pub type PMEMORY_PARTITION_CONFIGURATION_INFORMATION = *mut MEMORY_PARTITION_CONFIGURATION_INFORMATION; -STRUCT!{struct MEMORY_PARTITION_TRANSFER_INFORMATION { - NumberOfPages: ULONG_PTR, - NumaNode: ULONG, - Flags: ULONG, -}} -pub type PMEMORY_PARTITION_TRANSFER_INFORMATION = *mut MEMORY_PARTITION_TRANSFER_INFORMATION; -STRUCT!{struct MEMORY_PARTITION_PAGEFILE_INFORMATION { +STRUCT! {struct MEMORY_PARTITION_TRANSFER_INFORMATION { + NumberOfPages: usize, + NumaNode: c_ulong, + Flags: c_ulong, +}} +pub type PMEMORY_PARTITION_TRANSFER_INFORMATION = + *mut MEMORY_PARTITION_TRANSFER_INFORMATION; +STRUCT! {struct MEMORY_PARTITION_PAGEFILE_INFORMATION { PageFileName: UNICODE_STRING, MinimumSize: LARGE_INTEGER, MaximumSize: LARGE_INTEGER, - Flags: ULONG, + Flags: c_ulong, }} -pub type PMEMORY_PARTITION_PAGEFILE_INFORMATION = *mut MEMORY_PARTITION_PAGEFILE_INFORMATION; -STRUCT!{struct MEMORY_PARTITION_PAGE_COMBINE_INFORMATION { +pub type PMEMORY_PARTITION_PAGEFILE_INFORMATION = + *mut MEMORY_PARTITION_PAGEFILE_INFORMATION; +STRUCT! {struct MEMORY_PARTITION_PAGE_COMBINE_INFORMATION { StopHandle: HANDLE, - Flags: ULONG, - TotalNumberOfPages: ULONG_PTR, + Flags: c_ulong, + TotalNumberOfPages: usize, }} pub type PMEMORY_PARTITION_PAGE_COMBINE_INFORMATION = *mut MEMORY_PARTITION_PAGE_COMBINE_INFORMATION; -STRUCT!{struct MEMORY_PARTITION_PAGE_RANGE { - StartPage: ULONG_PTR, - NumberOfPages: ULONG_PTR, +STRUCT! {struct MEMORY_PARTITION_PAGE_RANGE { + StartPage: usize, + NumberOfPages: usize, }} pub type PMEMORY_PARTITION_PAGE_RANGE = *mut MEMORY_PARTITION_PAGE_RANGE; -STRUCT!{struct MEMORY_PARTITION_INITIAL_ADD_INFORMATION { - Flags: ULONG, - NumberOfRanges: ULONG, - NumberOfPagesAdded: ULONG_PTR, +STRUCT! {struct MEMORY_PARTITION_INITIAL_ADD_INFORMATION { + Flags: c_ulong, + NumberOfRanges: c_ulong, + NumberOfPagesAdded: usize, PartitionRanges: [MEMORY_PARTITION_PAGE_RANGE; 1], }} -pub type PMEMORY_PARTITION_INITIAL_ADD_INFORMATION = *mut MEMORY_PARTITION_INITIAL_ADD_INFORMATION; -STRUCT!{struct MEMORY_PARTITION_MEMORY_EVENTS_INFORMATION { - Flags: ULONG, - HandleAttributes: ULONG, - DesiredAccess: ULONG, +pub type PMEMORY_PARTITION_INITIAL_ADD_INFORMATION = + *mut MEMORY_PARTITION_INITIAL_ADD_INFORMATION; +STRUCT! {struct MEMORY_PARTITION_MEMORY_EVENTS_INFORMATION { + Flags: c_ulong, + HandleAttributes: c_ulong, + DesiredAccess: c_ulong, LowCommitCondition: HANDLE, HighCommitCondition: HANDLE, MaximumCommitCondition: HANDLE, }} -BITFIELD!{MEMORY_PARTITION_MEMORY_EVENTS_INFORMATION Flags: ULONG [ +BITFIELD! {MEMORY_PARTITION_MEMORY_EVENTS_INFORMATION Flags: c_ulong [ CommitEvents set_CommitEvents[0..1], Spare set_Spare[1..32], ]} pub type PMEMORY_PARTITION_MEMORY_EVENTS_INFORMATION = *mut MEMORY_PARTITION_MEMORY_EVENTS_INFORMATION; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtCreatePartition( - PartitionHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - PreferredNode: ULONG, + PartitionHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + PreferredNode: c_ulong, ) -> NTSTATUS; fn NtOpenPartition( - PartitionHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + PartitionHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn NtManagePartition( PartitionInformationClass: MEMORY_PARTITION_INFORMATION_CLASS, - PartitionInformation: PVOID, - PartitionInformationLength: ULONG, + PartitionInformation: *mut c_void, + PartitionInformationLength: c_ulong, ) -> NTSTATUS; fn NtMapUserPhysicalPages( - VirtualAddress: PVOID, - NumberOfPages: ULONG_PTR, - UserPfnArray: PULONG_PTR, + VirtualAddress: *mut c_void, + NumberOfPages: usize, + UserPfnArray: *mut usize, ) -> NTSTATUS; fn NtMapUserPhysicalPagesScatter( - VirtualAddresses: *mut PVOID, - NumberOfPages: ULONG_PTR, - UserPfnArray: PULONG_PTR, + VirtualAddresses: *mut *mut c_void, + NumberOfPages: usize, + UserPfnArray: *mut usize, ) -> NTSTATUS; fn NtAllocateUserPhysicalPages( ProcessHandle: HANDLE, - NumberOfPages: PULONG_PTR, - UserPfnArray: PULONG_PTR, + NumberOfPages: *mut usize, + UserPfnArray: *mut usize, ) -> NTSTATUS; fn NtFreeUserPhysicalPages( ProcessHandle: HANDLE, - NumberOfPages: PULONG_PTR, - UserPfnArray: PULONG_PTR, + NumberOfPages: *mut usize, + UserPfnArray: *mut usize, ) -> NTSTATUS; fn NtOpenSession( - SessionHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + SessionHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn NtGetWriteWatch( ProcessHandle: HANDLE, - Flags: ULONG, - BaseAddress: PVOID, - RegionSize: SIZE_T, - UserAddressArray: *mut PVOID, - EntriesInUserAddressArray: PULONG_PTR, - Granularity: PULONG, + Flags: c_ulong, + BaseAddress: *mut c_void, + RegionSize: usize, + UserAddressArray: *mut *mut c_void, + EntriesInUserAddressArray: *mut usize, + Granularity: *mut c_ulong, ) -> NTSTATUS; fn NtResetWriteWatch( ProcessHandle: HANDLE, - BaseAddress: PVOID, - RegionSize: SIZE_T, + BaseAddress: *mut c_void, + RegionSize: usize, ) -> NTSTATUS; fn NtCreatePagingFile( - PageFileName: PUNICODE_STRING, - MinimumSize: PLARGE_INTEGER, - MaximumSize: PLARGE_INTEGER, - Priority: ULONG, + PageFileName: *mut UNICODE_STRING, + MinimumSize: *mut LARGE_INTEGER, + MaximumSize: *mut LARGE_INTEGER, + Priority: c_ulong, ) -> NTSTATUS; fn NtFlushInstructionCache( ProcessHandle: HANDLE, - BaseAddress: PVOID, - Length: SIZE_T, + BaseAddress: *mut c_void, + Length: usize, ) -> NTSTATUS; fn NtFlushWriteBuffer() -> NTSTATUS; }} diff --git a/src/ntnls.rs b/src/ntnls.rs index 592a198..d73642f 100644 --- a/src/ntnls.rs +++ b/src/ntnls.rs @@ -1,29 +1,30 @@ -use winapi::shared::ntdef::{BOOLEAN, PUSHORT, PVOID, UCHAR, USHORT}; +use crate::ctypes::{c_uchar, c_ushort, c_void}; + pub const MAXIMUM_LEADBYTES: usize = 12; -STRUCT!{struct CPTABLEINFO { - CodePage: USHORT, - MaximumCharacterSize: USHORT, - DefaultChar: USHORT, - UniDefaultChar: USHORT, - TransDefaultChar: USHORT, - TransUniDefaultChar: USHORT, - DBCSCodePage: USHORT, - LeadByte: [UCHAR; MAXIMUM_LEADBYTES], - MultiByteTable: PUSHORT, - WideCharTable: PVOID, - DBCSRanges: PUSHORT, - DBCSOffsets: PUSHORT, +STRUCT! {struct CPTABLEINFO { + CodePage: c_ushort, + MaximumCharacterSize: c_ushort, + DefaultChar: c_ushort, + UniDefaultChar: c_ushort, + TransDefaultChar: c_ushort, + TransUniDefaultChar: c_ushort, + DBCSCodePage: c_ushort, + LeadByte: [c_uchar; MAXIMUM_LEADBYTES], + MultiByteTable: *mut c_ushort, + WideCharTable: *mut c_void, + DBCSRanges: *mut c_ushort, + DBCSOffsets: *mut c_ushort, }} pub type PCPTABLEINFO = *mut CPTABLEINFO; -STRUCT!{struct NLSTABLEINFO { +STRUCT! {struct NLSTABLEINFO { OemTableInfo: CPTABLEINFO, AnsiTableInfo: CPTABLEINFO, - UpperCaseTable: PUSHORT, - LowerCaseTable: PUSHORT, + UpperCaseTable: *mut c_ushort, + LowerCaseTable: *mut c_ushort, }} pub type PNLSTABLEINFO = *mut NLSTABLEINFO; -EXTERN!{extern "C" { - static mut NlsAnsiCodePage: USHORT; - static mut NlsMbCodePageTag: BOOLEAN; - static mut NlsMbOemCodePageTag: BOOLEAN; +EXTERN! {extern "C" { + static mut NlsAnsiCodePage: c_ushort; + static mut NlsMbCodePageTag: c_uchar; + static mut NlsMbOemCodePageTag: c_uchar; }} diff --git a/src/ntobapi.rs b/src/ntobapi.rs index 388ec61..abb22fb 100644 --- a/src/ntobapi.rs +++ b/src/ntobapi.rs @@ -1,24 +1,28 @@ -use winapi::shared::ntdef::{ - BOOLEAN, CHAR, HANDLE, LARGE_INTEGER, LONG, NTSTATUS, PHANDLE, PLARGE_INTEGER, - POBJECT_ATTRIBUTES, PULONG, PUNICODE_STRING, PVOID, UCHAR, ULONG, UNICODE_STRING, WAIT_TYPE, +use windows_sys::Win32::{ + Foundation::{HANDLE, NTSTATUS, UNICODE_STRING}, + Security::{GENERIC_MAPPING, PSECURITY_DESCRIPTOR}, + Storage::FileSystem::STANDARD_RIGHTS_REQUIRED, + System::{Kernel::WAIT_TYPE, WindowsProgramming::OBJECT_ATTRIBUTES}, }; -use winapi::um::winnt::{ - ACCESS_MASK, GENERIC_MAPPING, PSECURITY_DESCRIPTOR, SECURITY_INFORMATION, - STANDARD_RIGHTS_REQUIRED, + +use crate::{ + ctypes::{c_char, c_long, c_uchar, c_ulong, c_void}, + windows_local::shared::ntdef::LARGE_INTEGER, }; + pub const OBJECT_TYPE_CREATE: u32 = 0x0001; -pub const OBJECT_TYPE_ALL_ACCESS: ACCESS_MASK = STANDARD_RIGHTS_REQUIRED | 0x1; +pub const OBJECT_TYPE_ALL_ACCESS: c_ulong = STANDARD_RIGHTS_REQUIRED | 0x1; pub const DIRECTORY_QUERY: u32 = 0x0001; pub const DIRECTORY_TRAVERSE: u32 = 0x0002; pub const DIRECTORY_CREATE_OBJECT: u32 = 0x0004; pub const DIRECTORY_CREATE_SUBDIRECTORY: u32 = 0x0008; -pub const DIRECTORY_ALL_ACCESS: ACCESS_MASK = STANDARD_RIGHTS_REQUIRED | 0xf; +pub const DIRECTORY_ALL_ACCESS: c_ulong = STANDARD_RIGHTS_REQUIRED | 0xf; pub const SYMBOLIC_LINK_QUERY: u32 = 0x0001; -pub const SYMBOLIC_LINK_ALL_ACCESS: ACCESS_MASK = STANDARD_RIGHTS_REQUIRED | 0x1; +pub const SYMBOLIC_LINK_ALL_ACCESS: c_ulong = STANDARD_RIGHTS_REQUIRED | 0x1; pub const OBJ_PROTECT_CLOSE: u32 = 0x00000001; pub const OBJ_INHERIT: u32 = 0x00000002; pub const OBJ_AUDIT_OBJECT_CLOSE: u32 = 0x00000004; -ENUM!{enum OBJECT_INFORMATION_CLASS { +ENUM! {enum OBJECT_INFORMATION_CLASS { ObjectBasicInformation = 0, ObjectNameInformation = 1, ObjectTypeInformation = 2, @@ -28,86 +32,86 @@ ENUM!{enum OBJECT_INFORMATION_CLASS { ObjectSessionObjectInformation = 6, MaxObjectInfoClass = 7, }} -STRUCT!{struct OBJECT_BASIC_INFORMATION { - Attributes: ULONG, - GrantedAccess: ACCESS_MASK, - HandleCount: ULONG, - PointerCount: ULONG, - PagedPoolCharge: ULONG, - NonPagedPoolCharge: ULONG, - Reserved: [ULONG; 3], - NameInfoSize: ULONG, - TypeInfoSize: ULONG, - SecurityDescriptorSize: ULONG, +STRUCT! {struct OBJECT_BASIC_INFORMATION { + Attributes: c_ulong, + GrantedAccess: c_ulong, + HandleCount: c_ulong, + PointerCount: c_ulong, + PagedPoolCharge: c_ulong, + NonPagedPoolCharge: c_ulong, + Reserved: [c_ulong; 3], + NameInfoSize: c_ulong, + TypeInfoSize: c_ulong, + SecurityDescriptorSize: c_ulong, CreationTime: LARGE_INTEGER, }} pub type POBJECT_BASIC_INFORMATION = *mut OBJECT_BASIC_INFORMATION; -STRUCT!{struct OBJECT_NAME_INFORMATION { +STRUCT! {struct OBJECT_NAME_INFORMATION { Name: UNICODE_STRING, }} pub type POBJECT_NAME_INFORMATION = *mut OBJECT_NAME_INFORMATION; -STRUCT!{struct OBJECT_TYPE_INFORMATION { +STRUCT! {struct OBJECT_TYPE_INFORMATION { TypeName: UNICODE_STRING, - TotalNumberOfObjects: ULONG, - TotalNumberOfHandles: ULONG, - TotalPagedPoolUsage: ULONG, - TotalNonPagedPoolUsage: ULONG, - TotalNamePoolUsage: ULONG, - TotalHandleTableUsage: ULONG, - HighWaterNumberOfObjects: ULONG, - HighWaterNumberOfHandles: ULONG, - HighWaterPagedPoolUsage: ULONG, - HighWaterNonPagedPoolUsage: ULONG, - HighWaterNamePoolUsage: ULONG, - HighWaterHandleTableUsage: ULONG, - InvalidAttributes: ULONG, + TotalNumberOfObjects: c_ulong, + TotalNumberOfHandles: c_ulong, + TotalPagedPoolUsage: c_ulong, + TotalNonPagedPoolUsage: c_ulong, + TotalNamePoolUsage: c_ulong, + TotalHandleTableUsage: c_ulong, + HighWaterNumberOfObjects: c_ulong, + HighWaterNumberOfHandles: c_ulong, + HighWaterPagedPoolUsage: c_ulong, + HighWaterNonPagedPoolUsage: c_ulong, + HighWaterNamePoolUsage: c_ulong, + HighWaterHandleTableUsage: c_ulong, + InvalidAttributes: c_ulong, GenericMapping: GENERIC_MAPPING, - ValidAccessMask: ULONG, - SecurityRequired: BOOLEAN, - MaintainHandleCount: BOOLEAN, - TypeIndex: UCHAR, - ReservedByte: CHAR, - PoolType: ULONG, - DefaultPagedPoolCharge: ULONG, - DefaultNonPagedPoolCharge: ULONG, + ValidAccessMask: c_ulong, + SecurityRequired: c_uchar, + MaintainHandleCount: c_uchar, + TypeIndex: c_uchar, + ReservedByte: c_char, + PoolType: c_ulong, + DefaultPagedPoolCharge: c_ulong, + DefaultNonPagedPoolCharge: c_ulong, }} pub type POBJECT_TYPE_INFORMATION = *mut OBJECT_TYPE_INFORMATION; -STRUCT!{struct OBJECT_TYPES_INFORMATION { - NumberOfTypes: ULONG, +STRUCT! {struct OBJECT_TYPES_INFORMATION { + NumberOfTypes: c_ulong, }} pub type POBJECT_TYPES_INFORMATION = *mut OBJECT_TYPES_INFORMATION; -STRUCT!{struct OBJECT_HANDLE_FLAG_INFORMATION { - Inherit: BOOLEAN, - ProtectFromClose: BOOLEAN, +STRUCT! {struct OBJECT_HANDLE_FLAG_INFORMATION { + Inherit: c_uchar, + ProtectFromClose: c_uchar, }} pub type POBJECT_HANDLE_FLAG_INFORMATION = *mut OBJECT_HANDLE_FLAG_INFORMATION; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtQueryObject( Handle: HANDLE, ObjectInformationClass: OBJECT_INFORMATION_CLASS, - ObjectInformation: PVOID, - ObjectInformationLength: ULONG, - ReturnLength: PULONG, + ObjectInformation: *mut c_void, + ObjectInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn NtSetInformationObject( Handle: HANDLE, ObjectInformationClass: OBJECT_INFORMATION_CLASS, - ObjectInformation: PVOID, - ObjectInformationLength: ULONG, + ObjectInformation: *mut c_void, + ObjectInformationLength: c_ulong, ) -> NTSTATUS; }} pub const DUPLICATE_CLOSE_SOURCE: u32 = 0x00000001; pub const DUPLICATE_SAME_ACCESS: u32 = 0x00000002; pub const DUPLICATE_SAME_ATTRIBUTES: u32 = 0x00000004; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtDuplicateObject( SourceProcessHandle: HANDLE, SourceHandle: HANDLE, TargetProcessHandle: HANDLE, - TargetHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - HandleAttributes: ULONG, - Options: ULONG, + TargetHandle: *mut HANDLE, + DesiredAccess: c_ulong, + HandleAttributes: c_ulong, + Options: c_ulong, ) -> NTSTATUS; fn NtMakeTemporaryObject( Handle: HANDLE, @@ -118,39 +122,39 @@ EXTERN!{extern "system" { fn NtSignalAndWaitForSingleObject( SignalHandle: HANDLE, WaitHandle: HANDLE, - Alertable: BOOLEAN, - Timeout: PLARGE_INTEGER, + Alertable: c_uchar, + Timeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn NtWaitForSingleObject( Handle: HANDLE, - Alertable: BOOLEAN, - Timeout: PLARGE_INTEGER, + Alertable: c_uchar, + Timeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn NtWaitForMultipleObjects( - Count: ULONG, + Count: c_ulong, Handles: *mut HANDLE, WaitType: WAIT_TYPE, - Alertable: BOOLEAN, - Timeout: PLARGE_INTEGER, + Alertable: c_uchar, + Timeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn NtWaitForMultipleObjects32( - Count: ULONG, - Handles: *mut LONG, + Count: c_ulong, + Handles: *mut c_long, WaitType: WAIT_TYPE, - Alertable: BOOLEAN, - Timeout: PLARGE_INTEGER, + Alertable: c_uchar, + Timeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn NtSetSecurityObject( Handle: HANDLE, - SecurityInformation: SECURITY_INFORMATION, + SecurityInformation: c_ulong, SecurityDescriptor: PSECURITY_DESCRIPTOR, ) -> NTSTATUS; fn NtQuerySecurityObject( Handle: HANDLE, - SecurityInformation: SECURITY_INFORMATION, + SecurityInformation: c_ulong, SecurityDescriptor: PSECURITY_DESCRIPTOR, - Length: ULONG, - LengthNeeded: PULONG, + Length: c_ulong, + LengthNeeded: *mut c_ulong, ) -> NTSTATUS; fn NtClose( Handle: HANDLE, @@ -160,67 +164,67 @@ EXTERN!{extern "system" { SecondObjectHandle: HANDLE, ) -> NTSTATUS; fn NtCreateDirectoryObject( - DirectoryHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + DirectoryHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn NtCreateDirectoryObjectEx( - DirectoryHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + DirectoryHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ShadowDirectoryHandle: HANDLE, - Flags: ULONG, + Flags: c_ulong, ) -> NTSTATUS; fn NtOpenDirectoryObject( - DirectoryHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + DirectoryHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; }} -STRUCT!{struct OBJECT_DIRECTORY_INFORMATION { +STRUCT! {struct OBJECT_DIRECTORY_INFORMATION { Name: UNICODE_STRING, TypeName: UNICODE_STRING, }} pub type POBJECT_DIRECTORY_INFORMATION = *mut OBJECT_DIRECTORY_INFORMATION; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtQueryDirectoryObject( DirectoryHandle: HANDLE, - Buffer: PVOID, - Length: ULONG, - ReturnSingleEntry: BOOLEAN, - RestartScan: BOOLEAN, - Context: PULONG, - ReturnLength: PULONG, + Buffer: *mut c_void, + Length: c_ulong, + ReturnSingleEntry: c_uchar, + RestartScan: c_uchar, + Context: *mut c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn NtCreatePrivateNamespace( - NamespaceHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - BoundaryDescriptor: PVOID, + NamespaceHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + BoundaryDescriptor: *mut c_void, ) -> NTSTATUS; fn NtOpenPrivateNamespace( - NamespaceHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - BoundaryDescriptor: PVOID, + NamespaceHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + BoundaryDescriptor: *mut c_void, ) -> NTSTATUS; fn NtDeletePrivateNamespace( NamespaceHandle: HANDLE, ) -> NTSTATUS; fn NtCreateSymbolicLinkObject( - LinkHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - LinkTarget: PUNICODE_STRING, + LinkHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + LinkTarget: *mut UNICODE_STRING, ) -> NTSTATUS; fn NtOpenSymbolicLinkObject( - LinkHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + LinkHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn NtQuerySymbolicLinkObject( LinkHandle: HANDLE, - LinkTarget: PUNICODE_STRING, - ReturnedLength: PULONG, + LinkTarget: *mut UNICODE_STRING, + ReturnedLength: *mut c_ulong, ) -> NTSTATUS; }} diff --git a/src/ntpebteb.rs b/src/ntpebteb.rs index b517058..fc5fe50 100644 --- a/src/ntpebteb.rs +++ b/src/ntpebteb.rs @@ -1,158 +1,170 @@ -use core::mem::size_of; -use crate::ntapi_base::CLIENT_ID; -use crate::ntpsapi::{GDI_HANDLE_BUFFER, PPEB_LDR_DATA}; -use crate::ntrtl::PRTL_USER_PROCESS_PARAMETERS; -use winapi::shared::basetsd::{SIZE_T, ULONG_PTR}; -use winapi::shared::guiddef::GUID; -use winapi::shared::ntdef::{ - BOOLEAN, CHAR, HANDLE, LCID, LIST_ENTRY, LONG, NTSTATUS, PROCESSOR_NUMBER, PSTR, PVOID, UCHAR, - ULARGE_INTEGER, ULONG, ULONGLONG, UNICODE_STRING, USHORT, WCHAR, +use windows_sys::{ + core::GUID, + Win32::{ + Foundation::{HANDLE, NTSTATUS, UNICODE_STRING}, + System::{ + Kernel::{LIST_ENTRY, NT_TIB, PROCESSOR_NUMBER, SLIST_HEADER}, + SystemServices::FLS_MAXIMUM_AVAILABLE, + Threading::RTL_CRITICAL_SECTION, + }, + }, }; -use winapi::um::winnt::{ - ACTIVATION_CONTEXT, FLS_MAXIMUM_AVAILABLE, NT_TIB, PRTL_CRITICAL_SECTION, PSLIST_HEADER, + +use crate::{ + ctypes::{ + __uint64, c_char, c_long, c_uchar, c_ulong, c_ushort, c_void, wchar_t, + }, + ntapi_base::CLIENT_ID, + ntpsapi::{GDI_HANDLE_BUFFER, PPEB_LDR_DATA}, + ntrtl::PRTL_USER_PROCESS_PARAMETERS, + windows_local::{ + shared::ntdef::ULARGE_INTEGER, um::winnt::ACTIVATION_CONTEXT, + }, }; -STRUCT!{struct RTL_ACTIVATION_CONTEXT_STACK_FRAME { + +STRUCT! {struct RTL_ACTIVATION_CONTEXT_STACK_FRAME { Previous: PRTL_ACTIVATION_CONTEXT_STACK_FRAME, ActivationContext: *mut ACTIVATION_CONTEXT, - Flags: ULONG, + Flags: c_ulong, }} -pub type PRTL_ACTIVATION_CONTEXT_STACK_FRAME = *mut RTL_ACTIVATION_CONTEXT_STACK_FRAME; -STRUCT!{struct ACTIVATION_CONTEXT_STACK { +pub type PRTL_ACTIVATION_CONTEXT_STACK_FRAME = + *mut RTL_ACTIVATION_CONTEXT_STACK_FRAME; +STRUCT! {struct ACTIVATION_CONTEXT_STACK { ActiveFrame: *mut RTL_ACTIVATION_CONTEXT_STACK_FRAME, FrameListCache: LIST_ENTRY, - Flags: ULONG, - NextCookieSequenceNumber: ULONG, - StackId: ULONG, + Flags: c_ulong, + NextCookieSequenceNumber: c_ulong, + StackId: c_ulong, }} pub type PACTIVATION_CONTEXT_STACK = *mut ACTIVATION_CONTEXT_STACK; -STRUCT!{struct API_SET_NAMESPACE { - Version: ULONG, - Size: ULONG, - Flags: ULONG, - Count: ULONG, - EntryOffset: ULONG, - HashOffset: ULONG, - HashFactor: ULONG, +STRUCT! {struct API_SET_NAMESPACE { + Version: c_ulong, + Size: c_ulong, + Flags: c_ulong, + Count: c_ulong, + EntryOffset: c_ulong, + HashOffset: c_ulong, + HashFactor: c_ulong, }} pub type PAPI_SET_NAMESPACE = *mut API_SET_NAMESPACE; -STRUCT!{struct API_SET_HASH_ENTRY { - Hash: ULONG, - Index: ULONG, +STRUCT! {struct API_SET_HASH_ENTRY { + Hash: c_ulong, + Index: c_ulong, }} pub type PAPI_SET_HASH_ENTRY = *mut API_SET_HASH_ENTRY; -STRUCT!{struct API_SET_NAMESPACE_ENTRY { - Flags: ULONG, - NameOffset: ULONG, - NameLength: ULONG, - HashedLength: ULONG, - ValueOffset: ULONG, - ValueCount: ULONG, +STRUCT! {struct API_SET_NAMESPACE_ENTRY { + Flags: c_ulong, + NameOffset: c_ulong, + NameLength: c_ulong, + HashedLength: c_ulong, + ValueOffset: c_ulong, + ValueCount: c_ulong, }} pub type PAPI_SET_NAMESPACE_ENTRY = *mut API_SET_NAMESPACE_ENTRY; -STRUCT!{struct API_SET_VALUE_ENTRY { - Flags: ULONG, - NameOffset: ULONG, - NameLength: ULONG, - ValueOffset: ULONG, - ValueLength: ULONG, +STRUCT! {struct API_SET_VALUE_ENTRY { + Flags: c_ulong, + NameOffset: c_ulong, + NameLength: c_ulong, + ValueOffset: c_ulong, + ValueLength: c_ulong, }} pub type PAPI_SET_VALUE_ENTRY = *mut API_SET_VALUE_ENTRY; -UNION!{union PEB_u { - KernelCallbackTable: PVOID, - UserSharedInfoPtr: PVOID, +UNION! {union PEB_u { + KernelCallbackTable: *mut c_void, + UserSharedInfoPtr: *mut c_void, }} #[repr(C)] pub struct LEAP_SECOND_DATA([u8; 0]); //fixme -STRUCT!{struct PEB { - InheritedAddressSpace: BOOLEAN, - ReadImageFileExecOptions: BOOLEAN, - BeingDebugged: BOOLEAN, - BitField: BOOLEAN, +STRUCT! {struct PEB { + InheritedAddressSpace: c_uchar, + ReadImageFileExecOptions: c_uchar, + BeingDebugged: c_uchar, + BitField: c_uchar, Mutant: HANDLE, - ImageBaseAddress: PVOID, + ImageBaseAddress: *mut c_void, Ldr: PPEB_LDR_DATA, ProcessParameters: PRTL_USER_PROCESS_PARAMETERS, - SubSystemData: PVOID, - ProcessHeap: PVOID, - FastPebLock: PRTL_CRITICAL_SECTION, - IFEOKey: PVOID, - AtlThunkSListPtr: PSLIST_HEADER, - CrossProcessFlags: ULONG, + SubSystemData: *mut c_void, + ProcessHeap: *mut c_void, + FastPebLock: *mut RTL_CRITICAL_SECTION, + IFEOKey: *mut c_void, + AtlThunkSListPtr: *mut SLIST_HEADER, + CrossProcessFlags: c_ulong, u: PEB_u, - SystemReserved: [ULONG; 1], - AtlThunkSListPtr32: ULONG, + SystemReserved: [c_ulong; 1], + AtlThunkSListPtr32: c_ulong, ApiSetMap: PAPI_SET_NAMESPACE, - TlsExpansionCounter: ULONG, - TlsBitmap: PVOID, - TlsBitmapBits: [ULONG; 2], - ReadOnlySharedMemoryBase: PVOID, - SharedData: PVOID, - ReadOnlyStaticServerData: *mut PVOID, - AnsiCodePageData: PVOID, - OemCodePageData: PVOID, - UnicodeCaseTableData: PVOID, - NumberOfProcessors: ULONG, - NtGlobalFlag: ULONG, + TlsExpansionCounter: c_ulong, + TlsBitmap: *mut c_void, + TlsBitmapBits: [c_ulong; 2], + ReadOnlySharedMemoryBase: *mut c_void, + SharedData: *mut c_void, + ReadOnlyStaticServerData: *mut *mut c_void, + AnsiCodePageData: *mut c_void, + OemCodePageData: *mut c_void, + UnicodeCaseTableData: *mut c_void, + NumberOfProcessors: c_ulong, + NtGlobalFlag: c_ulong, CriticalSectionTimeout: ULARGE_INTEGER, - HeapSegmentReserve: SIZE_T, - HeapSegmentCommit: SIZE_T, - HeapDeCommitTotalFreeThreshold: SIZE_T, - HeapDeCommitFreeBlockThreshold: SIZE_T, - NumberOfHeaps: ULONG, - MaximumNumberOfHeaps: ULONG, - ProcessHeaps: *mut PVOID, - GdiSharedHandleTable: PVOID, - ProcessStarterHelper: PVOID, - GdiDCAttributeList: ULONG, - LoaderLock: PRTL_CRITICAL_SECTION, - OSMajorVersion: ULONG, - OSMinorVersion: ULONG, - OSBuildNumber: USHORT, - OSCSDVersion: USHORT, - OSPlatformId: ULONG, - ImageSubsystem: ULONG, - ImageSubsystemMajorVersion: ULONG, - ImageSubsystemMinorVersion: ULONG, - ActiveProcessAffinityMask: ULONG_PTR, + HeapSegmentReserve: usize, + HeapSegmentCommit: usize, + HeapDeCommitTotalFreeThreshold: usize, + HeapDeCommitFreeBlockThreshold: usize, + NumberOfHeaps: c_ulong, + MaximumNumberOfHeaps: c_ulong, + ProcessHeaps: *mut *mut c_void, + GdiSharedHandleTable: *mut c_void, + ProcessStarterHelper: *mut c_void, + GdiDCAttributeList: c_ulong, + LoaderLock: *mut RTL_CRITICAL_SECTION, + OSMajorVersion: c_ulong, + OSMinorVersion: c_ulong, + OSBuildNumber: c_ushort, + OSCSDVersion: c_ushort, + OSPlatformId: c_ulong, + ImageSubsystem: c_ulong, + ImageSubsystemMajorVersion: c_ulong, + ImageSubsystemMinorVersion: c_ulong, + ActiveProcessAffinityMask: usize, GdiHandleBuffer: GDI_HANDLE_BUFFER, - PostProcessInitRoutine: PVOID, - TlsExpansionBitmap: PVOID, - TlsExpansionBitmapBits: [ULONG; 32], - SessionId: ULONG, + PostProcessInitRoutine: *mut c_void, + TlsExpansionBitmap: *mut c_void, + TlsExpansionBitmapBits: [c_ulong; 32], + SessionId: c_ulong, AppCompatFlags: ULARGE_INTEGER, AppCompatFlagsUser: ULARGE_INTEGER, - pShimData: PVOID, - AppCompatInfo: PVOID, + pShimData: *mut c_void, + AppCompatInfo: *mut c_void, CSDVersion: UNICODE_STRING, - ActivationContextData: PVOID, - ProcessAssemblyStorageMap: PVOID, - SystemDefaultActivationContextData: PVOID, - SystemAssemblyStorageMap: PVOID, - MinimumStackCommit: SIZE_T, - FlsCallback: *mut PVOID, + ActivationContextData: *mut c_void, + ProcessAssemblyStorageMap: *mut c_void, + SystemDefaultActivationContextData: *mut c_void, + SystemAssemblyStorageMap: *mut c_void, + MinimumStackCommit: usize, + FlsCallback: *mut *mut c_void, FlsListHead: LIST_ENTRY, - FlsBitmap: PVOID, - FlsBitmapBits: [ULONG; FLS_MAXIMUM_AVAILABLE as usize / (size_of::() * 8)], - FlsHighIndex: ULONG, - WerRegistrationData: PVOID, - WerShipAssertPtr: PVOID, - pUnused: PVOID, - pImageHeaderHash: PVOID, - TracingFlags: ULONG, - CsrServerReadOnlySharedMemoryBase: ULONGLONG, - TppWorkerpListLock: PRTL_CRITICAL_SECTION, + FlsBitmap: *mut c_void, + FlsBitmapBits: [c_ulong; FLS_MAXIMUM_AVAILABLE as usize / c_ulong::BITS as usize], + FlsHighIndex: c_ulong, + WerRegistrationData: *mut c_void, + WerShipAssertPtr: *mut c_void, + pUnused: *mut c_void, + pImageHeaderHash: *mut c_void, + TracingFlags: c_ulong, + CsrServerReadOnlySharedMemoryBase: __uint64, + TppWorkerpListLock: *mut RTL_CRITICAL_SECTION, TppWorkerpList: LIST_ENTRY, - WaitOnAddressHashTable: [PVOID; 128], - TelemetryCoverageHeader: PVOID, - CloudFileFlags: ULONG, - CloudFileDiagFlags: ULONG, - PlaceholderCompatibilityMode: CHAR, - PlaceholderCompatibilityModeReserved: [CHAR; 7], + WaitOnAddressHashTable: [*mut c_void; 128], + TelemetryCoverageHeader: *mut c_void, + CloudFileFlags: c_ulong, + CloudFileDiagFlags: c_ulong, + PlaceholderCompatibilityMode: c_char, + PlaceholderCompatibilityModeReserved: [c_char; 7], LeapSecondData: *mut LEAP_SECOND_DATA, - LeapSecondFlags: ULONG, - NtGlobalFlag2: ULONG, + LeapSecondFlags: c_ulong, + NtGlobalFlag2: c_ulong, }} -BITFIELD!{PEB BitField: BOOLEAN [ +BITFIELD! {PEB BitField: c_uchar [ ImageUsesLargePages set_ImageUsesLargePages[0..1], IsProtectedProcess set_IsProtectedProcess[1..2], IsImageDynamicallyRelocated set_IsImageDynamicallyRelocated[2..3], @@ -162,7 +174,7 @@ BITFIELD!{PEB BitField: BOOLEAN [ IsProtectedProcessLight set_IsProtectedProcessLight[6..7], IsLongPathAwareProcess set_IsLongPathAwareProcess[7..8], ]} -BITFIELD!{PEB CrossProcessFlags: ULONG [ +BITFIELD! {PEB CrossProcessFlags: c_ulong [ ProcessInJob set_ProcessInJob[0..1], ProcessInitializing set_ProcessInitializing[1..2], ProcessUsingVEH set_ProcessUsingVEH[2..3], @@ -173,244 +185,244 @@ BITFIELD!{PEB CrossProcessFlags: ULONG [ ProcessImagesHotPatched set_ProcessImagesHotPatched[7..8], ReservedBits0 set_ReservedBits0[8..32], ]} -BITFIELD!{PEB TracingFlags: ULONG [ +BITFIELD! {PEB TracingFlags: c_ulong [ HeapTracingEnabled set_HeapTracingEnabled[0..1], CritSecTracingEnabled set_CritSecTracingEnabled[1..2], LibLoaderTracingEnabled set_LibLoaderTracingEnabled[2..3], SpareTracingBits set_SpareTracingBits[3..32], ]} -BITFIELD!{PEB LeapSecondFlags: ULONG [ +BITFIELD! {PEB LeapSecondFlags: c_ulong [ SixtySecondEnabled set_SixtySecondEnabled[0..1], Reserved set_Reserved[1..32], ]} pub type PPEB = *mut PEB; pub const GDI_BATCH_BUFFER_SIZE: usize = 310; -STRUCT!{struct GDI_TEB_BATCH { - Offset: ULONG, - HDC: ULONG_PTR, - Buffer: [ULONG; GDI_BATCH_BUFFER_SIZE], +STRUCT! {struct GDI_TEB_BATCH { + Offset: c_ulong, + HDC: usize, + Buffer: [c_ulong; GDI_BATCH_BUFFER_SIZE], }} pub type PGDI_TEB_BATCH = *mut GDI_TEB_BATCH; -STRUCT!{struct TEB_ACTIVE_FRAME_CONTEXT { - Flags: ULONG, - FrameName: PSTR, +STRUCT! {struct TEB_ACTIVE_FRAME_CONTEXT { + Flags: c_ulong, + FrameName: *mut c_char, }} pub type PTEB_ACTIVE_FRAME_CONTEXT = *mut TEB_ACTIVE_FRAME_CONTEXT; -STRUCT!{struct TEB_ACTIVE_FRAME { - Flags: ULONG, +STRUCT! {struct TEB_ACTIVE_FRAME { + Flags: c_ulong, Previous: *mut TEB_ACTIVE_FRAME, Context: PTEB_ACTIVE_FRAME_CONTEXT, }} pub type PTEB_ACTIVE_FRAME = *mut TEB_ACTIVE_FRAME; -STRUCT!{struct TEB_u_s { - ReservedPad0: UCHAR, - ReservedPad1: UCHAR, - ReservedPad2: UCHAR, - IdealProcessor: UCHAR, +STRUCT! {struct TEB_u_s { + ReservedPad0: c_uchar, + ReservedPad1: c_uchar, + ReservedPad2: c_uchar, + IdealProcessor: c_uchar, }} -UNION!{union TEB_u { +UNION! {union TEB_u { CurrentIdealProcessor: PROCESSOR_NUMBER, - IdealProcessorValue: ULONG, + IdealProcessorValue: c_ulong, s: TEB_u_s, }} #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] -STRUCT!{struct TEB { +STRUCT! {struct TEB { NtTib: NT_TIB, - EnvironmentPointer: PVOID, + EnvironmentPointer: *mut c_void, ClientId: CLIENT_ID, - ActiveRpcHandle: PVOID, - ThreadLocalStoragePointer: PVOID, + ActiveRpcHandle: *mut c_void, + ThreadLocalStoragePointer: *mut c_void, ProcessEnvironmentBlock: PPEB, - LastErrorValue: ULONG, - CountOfOwnedCriticalSections: ULONG, - CsrClientThread: PVOID, - Win32ThreadInfo: PVOID, - User32Reserved: [ULONG; 26], - UserReserved: [ULONG; 5], - WOW32Reserved: PVOID, - CurrentLocale: LCID, - FpSoftwareStatusRegister: ULONG, - ReservedForDebuggerInstrumentation: [PVOID; 16], - SystemReserved1: [PVOID; 30], - PlaceholderCompatibilityMode: CHAR, - PlaceholderReserved: [CHAR; 11], - ProxiedProcessId: ULONG, + LastErrorValue: c_ulong, + CountOfOwnedCriticalSections: c_ulong, + CsrClientThread: *mut c_void, + Win32ThreadInfo: *mut c_void, + User32Reserved: [c_ulong; 26], + UserReserved: [c_ulong; 5], + WOW32Reserved: *mut c_void, + CurrentLocale: c_ulong, + FpSoftwareStatusRegister: c_ulong, + ReservedForDebuggerInstrumentation: [*mut c_void; 16], + SystemReserved1: [*mut c_void; 30], + PlaceholderCompatibilityMode: c_char, + PlaceholderReserved: [c_char; 11], + ProxiedProcessId: c_ulong, ActivationStack: ACTIVATION_CONTEXT_STACK, - WorkingOnBehalfTicket: [UCHAR; 8], + WorkingOnBehalfTicket: [c_uchar; 8], ExceptionCode: NTSTATUS, ActivationContextStackPointer: PACTIVATION_CONTEXT_STACK, - InstrumentationCallbackSp: ULONG_PTR, - InstrumentationCallbackPreviousPc: ULONG_PTR, - InstrumentationCallbackPreviousSp: ULONG_PTR, - TxFsContext: ULONG, - InstrumentationCallbackDisabled: BOOLEAN, + InstrumentationCallbackSp: usize, + InstrumentationCallbackPreviousPc: usize, + InstrumentationCallbackPreviousSp: usize, + TxFsContext: c_ulong, + InstrumentationCallbackDisabled: c_uchar, GdiTebBatch: GDI_TEB_BATCH, RealClientId: CLIENT_ID, GdiCachedProcessHandle: HANDLE, - GdiClientPID: ULONG, - GdiClientTID: ULONG, - GdiThreadLocalInfo: PVOID, - Win32ClientInfo: [ULONG_PTR; 62], - glDispatchTable: [PVOID; 233], - glReserved1: [ULONG_PTR; 29], - glReserved2: PVOID, - glSectionInfo: PVOID, - glSection: PVOID, - glTable: PVOID, - glCurrentRC: PVOID, - glContext: PVOID, + GdiClientPID: c_ulong, + GdiClientTID: c_ulong, + GdiThreadLocalInfo: *mut c_void, + Win32ClientInfo: [usize; 62], + glDispatchTable: [*mut c_void; 233], + glReserved1: [usize; 29], + glReserved2: *mut c_void, + glSectionInfo: *mut c_void, + glSection: *mut c_void, + glTable: *mut c_void, + glCurrentRC: *mut c_void, + glContext: *mut c_void, LastStatusValue: NTSTATUS, StaticUnicodeString: UNICODE_STRING, - StaticUnicodeBuffer: [WCHAR; 261], - DeallocationStack: PVOID, - TlsSlots: [PVOID; 64], + StaticUnicodeBuffer: [wchar_t; 261], + DeallocationStack: *mut c_void, + TlsSlots: [*mut c_void; 64], TlsLinks: LIST_ENTRY, - Vdm: PVOID, - ReservedForNtRpc: PVOID, - DbgSsReserved: [PVOID; 2], - HardErrorMode: ULONG, - Instrumentation: [PVOID; 11], + Vdm: *mut c_void, + ReservedForNtRpc: *mut c_void, + DbgSsReserved: [*mut c_void; 2], + HardErrorMode: c_ulong, + Instrumentation: [*mut c_void; 11], ActivityId: GUID, - SubProcessTag: PVOID, - PerflibData: PVOID, - EtwTraceData: PVOID, - WinSockData: PVOID, - GdiBatchCount: ULONG, + SubProcessTag: *mut c_void, + PerflibData: *mut c_void, + EtwTraceData: *mut c_void, + WinSockData: *mut c_void, + GdiBatchCount: c_ulong, u: TEB_u, - GuaranteedStackBytes: ULONG, - ReservedForPerf: PVOID, - ReservedForOle: PVOID, - WaitingOnLoaderLock: ULONG, - SavedPriorityState: PVOID, - ReservedForCodeCoverage: ULONG_PTR, - ThreadPoolData: PVOID, - TlsExpansionSlots: *mut PVOID, - DeallocationBStore: PVOID, - BStoreLimit: PVOID, - MuiGeneration: ULONG, - IsImpersonating: ULONG, - NlsCache: PVOID, - pShimData: PVOID, - HeapVirtualAffinity: USHORT, - LowFragHeapDataSlot: USHORT, + GuaranteedStackBytes: c_ulong, + ReservedForPerf: *mut c_void, + ReservedForOle: *mut c_void, + WaitingOnLoaderLock: c_ulong, + SavedPriorityState: *mut c_void, + ReservedForCodeCoverage: usize, + ThreadPoolData: *mut c_void, + TlsExpansionSlots: *mut *mut c_void, + DeallocationBStore: *mut c_void, + BStoreLimit: *mut c_void, + MuiGeneration: c_ulong, + IsImpersonating: c_ulong, + NlsCache: *mut c_void, + pShimData: *mut c_void, + HeapVirtualAffinity: c_ushort, + LowFragHeapDataSlot: c_ushort, CurrentTransactionHandle: HANDLE, ActiveFrame: PTEB_ACTIVE_FRAME, - FlsData: PVOID, - PreferredLanguages: PVOID, - UserPrefLanguages: PVOID, - MergedPrefLanguages: PVOID, - MuiImpersonation: ULONG, - CrossTebFlags: USHORT, - SameTebFlags: USHORT, - TxnScopeEnterCallback: PVOID, - TxnScopeExitCallback: PVOID, - TxnScopeContext: PVOID, - LockCount: ULONG, - WowTebOffset: LONG, - ResourceRetValue: PVOID, - ReservedForWdf: PVOID, - ReservedForCrt: ULONGLONG, + FlsData: *mut c_void, + PreferredLanguages: *mut c_void, + UserPrefLanguages: *mut c_void, + MergedPrefLanguages: *mut c_void, + MuiImpersonation: c_ulong, + CrossTebFlags: c_ushort, + SameTebFlags: c_ushort, + TxnScopeEnterCallback: *mut c_void, + TxnScopeExitCallback: *mut c_void, + TxnScopeContext: *mut c_void, + LockCount: c_ulong, + WowTebOffset: c_long, + ResourceRetValue: *mut c_void, + ReservedForWdf: *mut c_void, + ReservedForCrt: __uint64, EffectiveContainerId: GUID, }} #[cfg(target_arch = "x86")] -STRUCT!{struct TEB { +STRUCT! {struct TEB { NtTib: NT_TIB, - EnvironmentPointer: PVOID, + EnvironmentPointer: *mut c_void, ClientId: CLIENT_ID, - ActiveRpcHandle: PVOID, - ThreadLocalStoragePointer: PVOID, + ActiveRpcHandle: *mut c_void, + ThreadLocalStoragePointer: *mut c_void, ProcessEnvironmentBlock: PPEB, - LastErrorValue: ULONG, - CountOfOwnedCriticalSections: ULONG, - CsrClientThread: PVOID, - Win32ThreadInfo: PVOID, - User32Reserved: [ULONG; 26], - UserReserved: [ULONG; 5], - WOW32Reserved: PVOID, - CurrentLocale: LCID, - FpSoftwareStatusRegister: ULONG, - ReservedForDebuggerInstrumentation: [PVOID; 16], - SystemReserved1: [PVOID; 26], - PlaceholderCompatibilityMode: CHAR, - PlaceholderReserved: [CHAR; 11], - ProxiedProcessId: ULONG, + LastErrorValue: c_ulong, + CountOfOwnedCriticalSections: c_ulong, + CsrClientThread: *mut c_void, + Win32ThreadInfo: *mut c_void, + User32Reserved: [c_ulong; 26], + UserReserved: [c_ulong; 5], + WOW32Reserved: *mut c_void, + CurrentLocale: c_ulong, + FpSoftwareStatusRegister: c_ulong, + ReservedForDebuggerInstrumentation: [*mut c_void; 16], + SystemReserved1: [*mut c_void; 26], + PlaceholderCompatibilityMode: c_char, + PlaceholderReserved: [c_char; 11], + ProxiedProcessId: c_ulong, ActivationStack: ACTIVATION_CONTEXT_STACK, - WorkingOnBehalfTicket: [UCHAR; 8], + WorkingOnBehalfTicket: [c_uchar; 8], ExceptionCode: NTSTATUS, ActivationContextStackPointer: PACTIVATION_CONTEXT_STACK, - InstrumentationCallbackSp: ULONG_PTR, - InstrumentationCallbackPreviousPc: ULONG_PTR, - InstrumentationCallbackPreviousSp: ULONG_PTR, - InstrumentationCallbackDisabled: BOOLEAN, - SpareBytes: [UCHAR; 23], - TxFsContext: ULONG, + InstrumentationCallbackSp: usize, + InstrumentationCallbackPreviousPc: usize, + InstrumentationCallbackPreviousSp: usize, + InstrumentationCallbackDisabled: c_uchar, + SpareBytes: [c_uchar; 23], + TxFsContext: c_ulong, GdiTebBatch: GDI_TEB_BATCH, RealClientId: CLIENT_ID, GdiCachedProcessHandle: HANDLE, - GdiClientPID: ULONG, - GdiClientTID: ULONG, - GdiThreadLocalInfo: PVOID, - Win32ClientInfo: [ULONG_PTR; 62], - glDispatchTable: [PVOID; 233], - glReserved1: [ULONG_PTR; 29], - glReserved2: PVOID, - glSectionInfo: PVOID, - glSection: PVOID, - glTable: PVOID, - glCurrentRC: PVOID, - glContext: PVOID, + GdiClientPID: c_ulong, + GdiClientTID: c_ulong, + GdiThreadLocalInfo: *mut c_void, + Win32ClientInfo: [usize; 62], + glDispatchTable: [*mut c_void; 233], + glReserved1: [usize; 29], + glReserved2: *mut c_void, + glSectionInfo: *mut c_void, + glSection: *mut c_void, + glTable: *mut c_void, + glCurrentRC: *mut c_void, + glContext: *mut c_void, LastStatusValue: NTSTATUS, StaticUnicodeString: UNICODE_STRING, - StaticUnicodeBuffer: [WCHAR; 261], - DeallocationStack: PVOID, - TlsSlots: [PVOID; 64], + StaticUnicodeBuffer: [wchar_t; 261], + DeallocationStack: *mut c_void, + TlsSlots: [*mut c_void; 64], TlsLinks: LIST_ENTRY, - Vdm: PVOID, - ReservedForNtRpc: PVOID, - DbgSsReserved: [PVOID; 2], - HardErrorMode: ULONG, - Instrumentation: [PVOID; 9], + Vdm: *mut c_void, + ReservedForNtRpc: *mut c_void, + DbgSsReserved: [*mut c_void; 2], + HardErrorMode: c_ulong, + Instrumentation: [*mut c_void; 9], ActivityId: GUID, - SubProcessTag: PVOID, - PerflibData: PVOID, - EtwTraceData: PVOID, - WinSockData: PVOID, - GdiBatchCount: ULONG, + SubProcessTag: *mut c_void, + PerflibData: *mut c_void, + EtwTraceData: *mut c_void, + WinSockData: *mut c_void, + GdiBatchCount: c_ulong, u: TEB_u, - GuaranteedStackBytes: ULONG, - ReservedForPerf: PVOID, - ReservedForOle: PVOID, - WaitingOnLoaderLock: ULONG, - SavedPriorityState: PVOID, - ReservedForCodeCoverage: ULONG_PTR, - ThreadPoolData: PVOID, - TlsExpansionSlots: *mut PVOID, - MuiGeneration: ULONG, - IsImpersonating: ULONG, - NlsCache: PVOID, - pShimData: PVOID, - HeapVirtualAffinity: USHORT, - LowFragHeapDataSlot: USHORT, + GuaranteedStackBytes: c_ulong, + ReservedForPerf: *mut c_void, + ReservedForOle: *mut c_void, + WaitingOnLoaderLock: c_ulong, + SavedPriorityState: *mut c_void, + ReservedForCodeCoverage: usize, + ThreadPoolData: *mut c_void, + TlsExpansionSlots: *mut *mut c_void, + MuiGeneration: c_ulong, + IsImpersonating: c_ulong, + NlsCache: *mut c_void, + pShimData: *mut c_void, + HeapVirtualAffinity: c_ushort, + LowFragHeapDataSlot: c_ushort, CurrentTransactionHandle: HANDLE, ActiveFrame: PTEB_ACTIVE_FRAME, - FlsData: PVOID, - PreferredLanguages: PVOID, - UserPrefLanguages: PVOID, - MergedPrefLanguages: PVOID, - MuiImpersonation: ULONG, - CrossTebFlags: USHORT, - SameTebFlags: USHORT, - TxnScopeEnterCallback: PVOID, - TxnScopeExitCallback: PVOID, - TxnScopeContext: PVOID, - LockCount: ULONG, - WowTebOffset: LONG, - ResourceRetValue: PVOID, - ReservedForWdf: PVOID, - ReservedForCrt: ULONGLONG, + FlsData: *mut c_void, + PreferredLanguages: *mut c_void, + UserPrefLanguages: *mut c_void, + MergedPrefLanguages: *mut c_void, + MuiImpersonation: c_ulong, + CrossTebFlags: c_ushort, + SameTebFlags: c_ushort, + TxnScopeEnterCallback: *mut c_void, + TxnScopeExitCallback: *mut c_void, + TxnScopeContext: *mut c_void, + LockCount: c_ulong, + WowTebOffset: c_long, + ResourceRetValue: *mut c_void, + ReservedForWdf: *mut c_void, + ReservedForCrt: __uint64, EffectiveContainerId: GUID, }} -BITFIELD!{TEB SameTebFlags: USHORT [ +BITFIELD! {TEB SameTebFlags: c_ushort [ SafeThunkCall set_SafeThunkCall[0..1], InDebugPrint set_InDebugPrint[1..2], HasFiberData set_HasFiberData[2..3], diff --git a/src/ntpfapi.rs b/src/ntpfapi.rs index d632361..d070f69 100644 --- a/src/ntpfapi.rs +++ b/src/ntpfapi.rs @@ -1,8 +1,10 @@ -use crate::ntexapi::SYSTEM_MEMORY_LIST_INFORMATION; -use crate::ntmmapi::MMPFN_IDENTITY; -use winapi::shared::basetsd::{SIZE_T, ULONG_PTR}; -use winapi::shared::ntdef::{CHAR, LONGLONG, PVOID, ULONG, ULONGLONG, WCHAR}; -ENUM!{enum PF_BOOT_PHASE_ID { +use crate::{ + ctypes::{__int64, __uint64, c_char, c_ulong, c_void, wchar_t}, + ntexapi::SYSTEM_MEMORY_LIST_INFORMATION, + ntmmapi::MMPFN_IDENTITY, +}; + +ENUM! {enum PF_BOOT_PHASE_ID { PfKernelInitPhase = 0, PfBootDriverInitPhase = 90, PfSystemDriverInitPhase = 120, @@ -14,105 +16,106 @@ ENUM!{enum PF_BOOT_PHASE_ID { PfUserShellReadyPhase = 300, PfMaxBootPhaseId = 900, }} -ENUM!{enum PF_ENABLE_STATUS { +ENUM! {enum PF_ENABLE_STATUS { PfSvNotSpecified = 0, PfSvEnabled = 1, PfSvDisabled = 2, PfSvMaxEnableStatus = 3, }} -STRUCT!{struct PF_TRACE_LIMITS { - MaxNumPages: ULONG, - MaxNumSections: ULONG, - TimerPeriod: LONGLONG, +STRUCT! {struct PF_TRACE_LIMITS { + MaxNumPages: c_ulong, + MaxNumSections: c_ulong, + TimerPeriod: __int64, }} pub type PPF_TRACE_LIMITS = *mut PF_TRACE_LIMITS; -STRUCT!{struct PF_SYSTEM_PREFETCH_PARAMETERS { +STRUCT! {struct PF_SYSTEM_PREFETCH_PARAMETERS { EnableStatus: [PF_ENABLE_STATUS; 2], TraceLimits: [PF_TRACE_LIMITS; 2], - MaxNumActiveTraces: ULONG, - MaxNumSavedTraces: ULONG, - RootDirPath: [WCHAR; 32], - HostingApplicationList: [WCHAR; 128], + MaxNumActiveTraces: c_ulong, + MaxNumSavedTraces: c_ulong, + RootDirPath: [wchar_t; 32], + HostingApplicationList: [wchar_t; 128], }} pub type PPF_SYSTEM_PREFETCH_PARAMETERS = *mut PF_SYSTEM_PREFETCH_PARAMETERS; pub const PF_BOOT_CONTROL_VERSION: u32 = 1; -STRUCT!{struct PF_BOOT_CONTROL { - Version: ULONG, - DisableBootPrefetching: ULONG, +STRUCT! {struct PF_BOOT_CONTROL { + Version: c_ulong, + DisableBootPrefetching: c_ulong, }} pub type PPF_BOOT_CONTROL = *mut PF_BOOT_CONTROL; -ENUM!{enum PREFETCHER_INFORMATION_CLASS { +ENUM! {enum PREFETCHER_INFORMATION_CLASS { PrefetcherRetrieveTrace = 1, PrefetcherSystemParameters = 2, PrefetcherBootPhase = 3, PrefetcherRetrieveBootLoaderTrace = 4, PrefetcherBootControl = 5, }} -pub const PREFETCHER_INFORMATION_VERSION: ULONG = 23; -pub const PREFETCHER_INFORMATION_MAGIC: ULONG = 0x6b756843; -STRUCT!{struct PREFETCHER_INFORMATION { - Version: ULONG, - Magic: ULONG, +pub const PREFETCHER_INFORMATION_VERSION: c_ulong = 23; +pub const PREFETCHER_INFORMATION_MAGIC: c_ulong = 0x6b756843; +STRUCT! {struct PREFETCHER_INFORMATION { + Version: c_ulong, + Magic: c_ulong, PrefetcherInformationClass: PREFETCHER_INFORMATION_CLASS, - PrefetcherInformation: PVOID, - PrefetcherInformationLength: ULONG, + PrefetcherInformation: *mut c_void, + PrefetcherInformationLength: c_ulong, }} pub type PPREFETCHER_INFORMATION = *mut PREFETCHER_INFORMATION; -STRUCT!{struct PF_SYSTEM_SUPERFETCH_PARAMETERS { - EnabledComponents: ULONG, - BootID: ULONG, - SavedSectInfoTracesMax: ULONG, - SavedPageAccessTracesMax: ULONG, - ScenarioPrefetchTimeoutStandby: ULONG, - ScenarioPrefetchTimeoutHibernate: ULONG, -}} -pub type PPF_SYSTEM_SUPERFETCH_PARAMETERS = *mut PF_SYSTEM_SUPERFETCH_PARAMETERS; +STRUCT! {struct PF_SYSTEM_SUPERFETCH_PARAMETERS { + EnabledComponents: c_ulong, + BootID: c_ulong, + SavedSectInfoTracesMax: c_ulong, + SavedPageAccessTracesMax: c_ulong, + ScenarioPrefetchTimeoutStandby: c_ulong, + ScenarioPrefetchTimeoutHibernate: c_ulong, +}} +pub type PPF_SYSTEM_SUPERFETCH_PARAMETERS = + *mut PF_SYSTEM_SUPERFETCH_PARAMETERS; pub const PF_PFN_PRIO_REQUEST_VERSION: u32 = 1; pub const PF_PFN_PRIO_REQUEST_QUERY_MEMORY_LIST: u32 = 0x1; pub const PF_PFN_PRIO_REQUEST_VALID_FLAGS: u32 = 0x1; -STRUCT!{struct PF_PFN_PRIO_REQUEST { - Version: ULONG, - RequestFlags: ULONG, - PfnCount: ULONG_PTR, +STRUCT! {struct PF_PFN_PRIO_REQUEST { + Version: c_ulong, + RequestFlags: c_ulong, + PfnCount: usize, MemInfo: SYSTEM_MEMORY_LIST_INFORMATION, PageData: [MMPFN_IDENTITY; 256], }} pub type PPF_PFN_PRIO_REQUEST = *mut PF_PFN_PRIO_REQUEST; -ENUM!{enum PFS_PRIVATE_PAGE_SOURCE_TYPE { +ENUM! {enum PFS_PRIVATE_PAGE_SOURCE_TYPE { PfsPrivateSourceKernel = 0, PfsPrivateSourceSession = 1, PfsPrivateSourceProcess = 2, PfsPrivateSourceMax = 3, }} -UNION!{union PFS_PRIVATE_PAGE_SOURCE_u { - SessionId: ULONG, - ProcessId: ULONG, +UNION! {union PFS_PRIVATE_PAGE_SOURCE_u { + SessionId: c_ulong, + ProcessId: c_ulong, }} -STRUCT!{struct PFS_PRIVATE_PAGE_SOURCE { +STRUCT! {struct PFS_PRIVATE_PAGE_SOURCE { Type: PFS_PRIVATE_PAGE_SOURCE_TYPE, u: PFS_PRIVATE_PAGE_SOURCE_u, - ImagePathHash: ULONG, - UniqueProcessHash: ULONG_PTR, + ImagePathHash: c_ulong, + UniqueProcessHash: usize, }} -UNION!{union PF_PRIVSOURCE_INFO_u { - WsSwapPages: ULONG_PTR, - SessionPagedPoolPages: ULONG_PTR, - StoreSizePages: ULONG_PTR, +UNION! {union PF_PRIVSOURCE_INFO_u { + WsSwapPages: usize, + SessionPagedPoolPages: usize, + StoreSizePages: usize, }} pub type PPFS_PRIVATE_PAGE_SOURCE = *mut PFS_PRIVATE_PAGE_SOURCE; -STRUCT!{struct PF_PRIVSOURCE_INFO { +STRUCT! {struct PF_PRIVSOURCE_INFO { DbInfo: PFS_PRIVATE_PAGE_SOURCE, - EProcess: PVOID, - WsPrivatePages: SIZE_T, - TotalPrivatePages: SIZE_T, - SessionID: ULONG, - ImageName: [CHAR; 16], + EProcess: *mut c_void, + WsPrivatePages: usize, + TotalPrivatePages: usize, + SessionID: c_ulong, + ImageName: [c_char; 16], u: PF_PRIVSOURCE_INFO_u, - WsTotalPages: ULONG_PTR, - DeepFreezeTimeMs: ULONG, - BitFields: ULONG, + WsTotalPages: usize, + DeepFreezeTimeMs: c_ulong, + BitFields: c_ulong, }} -BITFIELD!{PF_PRIVSOURCE_INFO BitFields: ULONG [ +BITFIELD! {PF_PRIVSOURCE_INFO BitFields: c_ulong [ ModernApp set_ModernApp[0..1], DeepFrozen set_DeepFrozen[1..2], Foreground set_Foreground[2..3], @@ -121,14 +124,14 @@ BITFIELD!{PF_PRIVSOURCE_INFO BitFields: ULONG [ ]} pub type PPF_PRIVSOURCE_INFO = *mut PF_PRIVSOURCE_INFO; pub const PF_PRIVSOURCE_QUERY_REQUEST_VERSION: u32 = 3; -STRUCT!{struct PF_PRIVSOURCE_QUERY_REQUEST { - Version: ULONG, - Flags: ULONG, - InfoCount: ULONG, +STRUCT! {struct PF_PRIVSOURCE_QUERY_REQUEST { + Version: c_ulong, + Flags: c_ulong, + InfoCount: c_ulong, InfoArray: [PF_PRIVSOURCE_INFO; 1], }} pub type PPF_PRIVSOURCE_QUERY_REQUEST = *mut PF_PRIVSOURCE_QUERY_REQUEST; -ENUM!{enum PF_PHASED_SCENARIO_TYPE { +ENUM! {enum PF_PHASED_SCENARIO_TYPE { PfScenarioTypeNone = 0, PfScenarioTypeStandby = 1, PfScenarioTypeHibernate = 2, @@ -136,55 +139,55 @@ ENUM!{enum PF_PHASED_SCENARIO_TYPE { PfScenarioTypeMax = 4, }} pub const PF_SCENARIO_PHASE_INFO_VERSION: u32 = 4; -STRUCT!{struct PF_SCENARIO_PHASE_INFO { - Version: ULONG, +STRUCT! {struct PF_SCENARIO_PHASE_INFO { + Version: c_ulong, ScenType: PF_PHASED_SCENARIO_TYPE, - PhaseId: ULONG, - SequenceNumber: ULONG, - Flags: ULONG, - FUSUserId: ULONG, + PhaseId: c_ulong, + SequenceNumber: c_ulong, + Flags: c_ulong, + FUSUserId: c_ulong, }} pub type PPF_SCENARIO_PHASE_INFO = *mut PF_SCENARIO_PHASE_INFO; -STRUCT!{struct PF_MEMORY_LIST_NODE { - Bitfields: ULONGLONG, - StandbyLowPageCount: ULONGLONG, - StandbyMediumPageCount: ULONGLONG, - StandbyHighPageCount: ULONGLONG, - FreePageCount: ULONGLONG, - ModifiedPageCount: ULONGLONG, -}} -BITFIELD!{PF_MEMORY_LIST_NODE Bitfields: ULONGLONG [ +STRUCT! {struct PF_MEMORY_LIST_NODE { + Bitfields: __uint64, + StandbyLowPageCount: __uint64, + StandbyMediumPageCount: __uint64, + StandbyHighPageCount: __uint64, + FreePageCount: __uint64, + ModifiedPageCount: __uint64, +}} +BITFIELD! {PF_MEMORY_LIST_NODE Bitfields: __uint64 [ Node set_Node[0..8], Spare set_Spare[8..64], ]} pub type PPF_MEMORY_LIST_NODE = *mut PF_MEMORY_LIST_NODE; pub const PF_MEMORY_LIST_INFO_VERSION: u32 = 1; -STRUCT!{struct PF_MEMORY_LIST_INFO { - Version: ULONG, - Size: ULONG, - NodeCount: ULONG, +STRUCT! {struct PF_MEMORY_LIST_INFO { + Version: c_ulong, + Size: c_ulong, + NodeCount: c_ulong, Nodes: [PF_MEMORY_LIST_NODE; 1], }} pub type PPF_MEMORY_LIST_INFO = *mut PF_MEMORY_LIST_INFO; -STRUCT!{struct PF_PHYSICAL_MEMORY_RANGE { - BasePfn: ULONG_PTR, - PageCount: ULONG_PTR, +STRUCT! {struct PF_PHYSICAL_MEMORY_RANGE { + BasePfn: usize, + PageCount: usize, }} pub type PPF_PHYSICAL_MEMORY_RANGE = *mut PF_PHYSICAL_MEMORY_RANGE; pub const PF_PHYSICAL_MEMORY_RANGE_INFO_VERSION: u32 = 1; -STRUCT!{struct PF_PHYSICAL_MEMORY_RANGE_INFO { - Version: ULONG, - RangeCount: ULONG, +STRUCT! {struct PF_PHYSICAL_MEMORY_RANGE_INFO { + Version: c_ulong, + RangeCount: c_ulong, Ranges: [PF_PHYSICAL_MEMORY_RANGE; 1], }} pub type PPF_PHYSICAL_MEMORY_RANGE_INFO = *mut PF_PHYSICAL_MEMORY_RANGE_INFO; pub const PF_REPURPOSED_BY_PREFETCH_INFO_VERSION: u32 = 1; -STRUCT!{struct PF_REPURPOSED_BY_PREFETCH_INFO { - Version: ULONG, - RepurposedByPrefetch: ULONG, +STRUCT! {struct PF_REPURPOSED_BY_PREFETCH_INFO { + Version: c_ulong, + RepurposedByPrefetch: c_ulong, }} pub type PPF_REPURPOSED_BY_PREFETCH_INFO = *mut PF_REPURPOSED_BY_PREFETCH_INFO; -ENUM!{enum SUPERFETCH_INFORMATION_CLASS { +ENUM! {enum SUPERFETCH_INFORMATION_CLASS { SuperfetchRetrieveTrace = 1, SuperfetchSystemParameters = 2, SuperfetchLogEvent = 3, @@ -207,13 +210,13 @@ ENUM!{enum SUPERFETCH_INFORMATION_CLASS { SuperfetchRepurposedByPrefetch = 20, SuperfetchInformationMax = 21, }} -pub const SUPERFETCH_INFORMATION_VERSION: ULONG = 45; -pub const SUPERFETCH_INFORMATION_MAGIC: ULONG = 0x6b756843; -STRUCT!{struct SUPERFETCH_INFORMATION { - Version: ULONG, - Magic: ULONG, +pub const SUPERFETCH_INFORMATION_VERSION: c_ulong = 45; +pub const SUPERFETCH_INFORMATION_MAGIC: c_ulong = 0x6b756843; +STRUCT! {struct SUPERFETCH_INFORMATION { + Version: c_ulong, + Magic: c_ulong, InfoClass: SUPERFETCH_INFORMATION_CLASS, - Data: PVOID, - Length: ULONG, + Data: *mut c_void, + Length: c_ulong, }} pub type PSUPERFETCH_INFORMATION = *mut SUPERFETCH_INFORMATION; diff --git a/src/ntpnpapi.rs b/src/ntpnpapi.rs index 0afc698..3852441 100644 --- a/src/ntpnpapi.rs +++ b/src/ntpnpapi.rs @@ -1,7 +1,14 @@ -use winapi::shared::cfg::PNP_VETO_TYPE; -use winapi::shared::guiddef::GUID; -use winapi::shared::ntdef::{HANDLE, NTSTATUS, PULONG, PUNICODE_STRING, PVOID, ULONG, WCHAR}; -ENUM!{enum PLUGPLAY_EVENT_CATEGORY { +use windows_sys::{ + core::GUID, + Win32::{ + Devices::DeviceAndDriverInstallation::PNP_VETO_TYPE, + Foundation::{HANDLE, NTSTATUS, UNICODE_STRING}, + }, +}; + +use crate::ctypes::{c_ulong, c_void, wchar_t}; + +ENUM! {enum PLUGPLAY_EVENT_CATEGORY { HardwareProfileChangeEvent = 0, TargetDeviceChangeEvent = 1, DeviceClassChangeEvent = 2, @@ -15,38 +22,38 @@ ENUM!{enum PLUGPLAY_EVENT_CATEGORY { MaxPlugEventCategory = 10, }} pub type PPLUGPLAY_EVENT_CATEGORY = *mut PLUGPLAY_EVENT_CATEGORY; -STRUCT!{struct PLUGPLAY_EVENT_BLOCK_u_DeviceClass { +STRUCT! {struct PLUGPLAY_EVENT_BLOCK_u_DeviceClass { ClassGuid: GUID, - SymbolicLinkName: [WCHAR; 1], + SymbolicLinkName: [wchar_t; 1], }} -STRUCT!{struct PLUGPLAY_EVENT_BLOCK_u_TargetDevice { - DeviceIds: [WCHAR; 1], +STRUCT! {struct PLUGPLAY_EVENT_BLOCK_u_TargetDevice { + DeviceIds: [wchar_t; 1], }} -STRUCT!{struct PLUGPLAY_EVENT_BLOCK_u_InstallDevice { - DeviceId: [WCHAR; 1], +STRUCT! {struct PLUGPLAY_EVENT_BLOCK_u_InstallDevice { + DeviceId: [wchar_t; 1], }} -STRUCT!{struct PLUGPLAY_EVENT_BLOCK_u_CustomNotification { - NotificationStructure: PVOID, - DeviceIds: [WCHAR; 1], +STRUCT! {struct PLUGPLAY_EVENT_BLOCK_u_CustomNotification { + NotificationStructure: *mut c_void, + DeviceIds: [wchar_t; 1], }} -STRUCT!{struct PLUGPLAY_EVENT_BLOCK_u_ProfileNotification { - Notification: PVOID, +STRUCT! {struct PLUGPLAY_EVENT_BLOCK_u_ProfileNotification { + Notification: *mut c_void, }} -STRUCT!{struct PLUGPLAY_EVENT_BLOCK_u_PowerNotification { - NotificationCode: ULONG, - NotificationData: ULONG, +STRUCT! {struct PLUGPLAY_EVENT_BLOCK_u_PowerNotification { + NotificationCode: c_ulong, + NotificationData: c_ulong, }} -STRUCT!{struct PLUGPLAY_EVENT_BLOCK_u_VetoNotification { +STRUCT! {struct PLUGPLAY_EVENT_BLOCK_u_VetoNotification { VetoType: PNP_VETO_TYPE, - DeviceIdVetoNameBuffer: [WCHAR; 1], + DeviceIdVetoNameBuffer: [wchar_t; 1], }} -STRUCT!{struct PLUGPLAY_EVENT_BLOCK_u_BlockedDriverNotification { +STRUCT! {struct PLUGPLAY_EVENT_BLOCK_u_BlockedDriverNotification { BlockedDriverGuid: GUID, }} -STRUCT!{struct PLUGPLAY_EVENT_BLOCK_u_InvalidIDNotification { - ParentId: [WCHAR; 1], +STRUCT! {struct PLUGPLAY_EVENT_BLOCK_u_InvalidIDNotification { + ParentId: [wchar_t; 1], }} -UNION!{union PLUGPLAY_EVENT_BLOCK_u { +UNION! {union PLUGPLAY_EVENT_BLOCK_u { DeviceClass: PLUGPLAY_EVENT_BLOCK_u_DeviceClass, TargetDevice: PLUGPLAY_EVENT_BLOCK_u_TargetDevice, InstallDevice: PLUGPLAY_EVENT_BLOCK_u_InstallDevice, @@ -57,17 +64,17 @@ UNION!{union PLUGPLAY_EVENT_BLOCK_u { BlockedDriverNotification: PLUGPLAY_EVENT_BLOCK_u_BlockedDriverNotification, InvalidIDNotification: PLUGPLAY_EVENT_BLOCK_u_InvalidIDNotification, }} -STRUCT!{struct PLUGPLAY_EVENT_BLOCK { +STRUCT! {struct PLUGPLAY_EVENT_BLOCK { EventGuid: GUID, EventCategory: PLUGPLAY_EVENT_CATEGORY, - Result: PULONG, - Flags: ULONG, - TotalSize: ULONG, - DeviceObject: PVOID, + Result: *mut c_ulong, + Flags: c_ulong, + TotalSize: c_ulong, + DeviceObject: *mut c_void, u: PLUGPLAY_EVENT_BLOCK_u, }} pub type PPLUGPLAY_EVENT_BLOCK = *mut PLUGPLAY_EVENT_BLOCK; -ENUM!{enum PLUGPLAY_CONTROL_CLASS { +ENUM! {enum PLUGPLAY_CONTROL_CLASS { PlugPlayControlEnumerateDevice = 0, PlugPlayControlRegisterNewDevice = 1, PlugPlayControlDeregisterDevice = 2, @@ -95,24 +102,24 @@ ENUM!{enum PLUGPLAY_CONTROL_CLASS { MaxPlugPlayControl = 24, }} pub type PPLUGPLAY_CONTROL_CLASS = *mut PLUGPLAY_CONTROL_CLASS; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtGetPlugPlayEvent( EventHandle: HANDLE, - Context: PVOID, + Context: *mut c_void, EventBlock: PPLUGPLAY_EVENT_BLOCK, - EventBufferSize: ULONG, + EventBufferSize: c_ulong, ) -> NTSTATUS; fn NtPlugPlayControl( PnPControlClass: PLUGPLAY_CONTROL_CLASS, - PnPControlData: PVOID, - PnPControlDataLength: ULONG, + PnPControlData: *mut c_void, + PnPControlDataLength: c_ulong, ) -> NTSTATUS; fn NtSerializeBoot() -> NTSTATUS; fn NtEnableLastKnownGood() -> NTSTATUS; fn NtDisableLastKnownGood() -> NTSTATUS; fn NtReplacePartitionUnit( - TargetInstancePath: PUNICODE_STRING, - SpareInstancePath: PUNICODE_STRING, - Flags: ULONG, + TargetInstancePath: *mut UNICODE_STRING, + SpareInstancePath: *mut UNICODE_STRING, + Flags: c_ulong, ) -> NTSTATUS; }} diff --git a/src/ntpoapi.rs b/src/ntpoapi.rs index ecc68fc..0d0c3da 100644 --- a/src/ntpoapi.rs +++ b/src/ntpoapi.rs @@ -1,25 +1,27 @@ -use winapi::shared::ntdef::{ - BOOLEAN, HANDLE, LONG, NTSTATUS, PLONG, PUNICODE_STRING, PVOID, UCHAR, ULONG, UNICODE_STRING, - USHORT, +use windows_sys::Win32::{ + Foundation::{HANDLE, NTSTATUS, UNICODE_STRING}, + System::Power::{ + DEVICE_POWER_STATE, EXECUTION_STATE, LATENCY_TIME, POWER_ACTION, + POWER_INFORMATION_LEVEL, SYSTEM_POWER_STATE, + }, }; -use winapi::um::winnt::{ - DEVICE_POWER_STATE, EXECUTION_STATE, LATENCY_TIME, PDEVICE_POWER_STATE, PEXECUTION_STATE, - POWER_ACTION, POWER_INFORMATION_LEVEL, SYSTEM_POWER_STATE, -}; -UNION!{union POWER_STATE { + +use crate::ctypes::{c_long, c_uchar, c_ulong, c_ushort, c_void}; + +UNION! {union POWER_STATE { SystemState: SYSTEM_POWER_STATE, DeviceState: DEVICE_POWER_STATE, }} pub type PPOWER_STATE = *mut POWER_STATE; -ENUM!{enum POWER_STATE_TYPE { +ENUM! {enum POWER_STATE_TYPE { SystemPowerState = 0, DevicePowerState = 1, }} pub type PPOWER_STATE_TYPE = *mut POWER_STATE_TYPE; -STRUCT!{struct SYSTEM_POWER_STATE_CONTEXT { - ContextAsUlong: ULONG, +STRUCT! {struct SYSTEM_POWER_STATE_CONTEXT { + ContextAsUlong: c_ulong, }} -BITFIELD!{SYSTEM_POWER_STATE_CONTEXT ContextAsUlong: ULONG [ +BITFIELD! {SYSTEM_POWER_STATE_CONTEXT ContextAsUlong: c_ulong [ Reserved1 set_Reserved1[0..8], TargetSystemState set_TargetSystemState[8..12], EffectiveSystemState set_EffectiveSystemState[12..16], @@ -29,23 +31,23 @@ BITFIELD!{SYSTEM_POWER_STATE_CONTEXT ContextAsUlong: ULONG [ Reserved2 set_Reserved2[22..32], ]} pub type PSYSTEM_POWER_STATE_CONTEXT = *mut SYSTEM_POWER_STATE_CONTEXT; -STRUCT!{struct COUNTED_REASON_CONTEXT_u_s { +STRUCT! {struct COUNTED_REASON_CONTEXT_u_s { ResourceFileName: UNICODE_STRING, - ResourceReasonId: USHORT, - StringCount: ULONG, - ReasonStrings: PUNICODE_STRING, + ResourceReasonId: c_ushort, + StringCount: c_ulong, + ReasonStrings: *mut UNICODE_STRING, }} -UNION!{union COUNTED_REASON_CONTEXT_u { +UNION! {union COUNTED_REASON_CONTEXT_u { s: COUNTED_REASON_CONTEXT_u_s, SimpleString: UNICODE_STRING, }} -STRUCT!{struct COUNTED_REASON_CONTEXT { - Version: ULONG, - Flags: ULONG, +STRUCT! {struct COUNTED_REASON_CONTEXT { + Version: c_ulong, + Flags: c_ulong, u: COUNTED_REASON_CONTEXT_u, }} pub type PCOUNTED_REASON_CONTEXT = *mut COUNTED_REASON_CONTEXT; -ENUM!{enum POWER_STATE_HANDLER_TYPE { +ENUM! {enum POWER_STATE_HANDLER_TYPE { PowerStateSleeping1 = 0, PowerStateSleeping2 = 1, PowerStateSleeping3 = 2, @@ -56,61 +58,61 @@ ENUM!{enum POWER_STATE_HANDLER_TYPE { PowerStateMaximum = 7, }} pub type PPOWER_STATE_HANDLER_TYPE = *mut POWER_STATE_HANDLER_TYPE; -FN!{stdcall PENTER_STATE_SYSTEM_HANDLER( - SystemContext: PVOID, +FN! {stdcall PENTER_STATE_SYSTEM_HANDLER( + SystemContext: *mut c_void, ) -> NTSTATUS} -FN!{stdcall PENTER_STATE_HANDLER( - Context: PVOID, +FN! {stdcall PENTER_STATE_HANDLER( + Context: *mut c_void, SystemHandler: PENTER_STATE_SYSTEM_HANDLER, - SystemContext: PVOID, - NumberProcessors: LONG, - Number: PLONG, + SystemContext: *mut c_void, + NumberProcessors: c_long, + Number: *mut c_long, ) -> NTSTATUS} -STRUCT!{struct POWER_STATE_HANDLER { +STRUCT! {struct POWER_STATE_HANDLER { Type: POWER_STATE_HANDLER_TYPE, - RtcWake: BOOLEAN, - Spare: [UCHAR; 3], + RtcWake: c_uchar, + Spare: [c_uchar; 3], Handler: PENTER_STATE_HANDLER, - Context: PVOID, + Context: *mut c_void, }} pub type PPOWER_STATE_HANDLER = *mut POWER_STATE_HANDLER; -FN!{stdcall PENTER_STATE_NOTIFY_HANDLER( +FN! {stdcall PENTER_STATE_NOTIFY_HANDLER( State: POWER_STATE_HANDLER_TYPE, - Context: PVOID, - Entering: BOOLEAN, + Context: *mut c_void, + Entering: c_uchar, ) -> NTSTATUS} -STRUCT!{struct POWER_STATE_NOTIFY_HANDLER { +STRUCT! {struct POWER_STATE_NOTIFY_HANDLER { Handler: PENTER_STATE_NOTIFY_HANDLER, - Context: PVOID, + Context: *mut c_void, }} pub type PPOWER_STATE_NOTIFY_HANDLER = *mut POWER_STATE_NOTIFY_HANDLER; -STRUCT!{struct PROCESSOR_POWER_INFORMATION { - Number: ULONG, - MaxMhz: ULONG, - CurrentMhz: ULONG, - MhzLimit: ULONG, - MaxIdleState: ULONG, - CurrentIdleState: ULONG, +STRUCT! {struct PROCESSOR_POWER_INFORMATION { + Number: c_ulong, + MaxMhz: c_ulong, + CurrentMhz: c_ulong, + MhzLimit: c_ulong, + MaxIdleState: c_ulong, + CurrentIdleState: c_ulong, }} pub type PPROCESSOR_POWER_INFORMATION = *mut PROCESSOR_POWER_INFORMATION; -STRUCT!{struct SYSTEM_POWER_INFORMATION { - MaxIdlenessAllowed: ULONG, - Idleness: ULONG, - TimeRemaining: ULONG, - CoolingMode: UCHAR, +STRUCT! {struct SYSTEM_POWER_INFORMATION { + MaxIdlenessAllowed: c_ulong, + Idleness: c_ulong, + TimeRemaining: c_ulong, + CoolingMode: c_uchar, }} pub type PSYSTEM_POWER_INFORMATION = *mut SYSTEM_POWER_INFORMATION; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtPowerInformation( InformationLevel: POWER_INFORMATION_LEVEL, - InputBuffer: PVOID, - InputBufferLength: ULONG, - OutputBuffer: PVOID, - OutputBufferLength: ULONG, + InputBuffer: *mut c_void, + InputBufferLength: c_ulong, + OutputBuffer: *mut c_void, + OutputBufferLength: c_ulong, ) -> NTSTATUS; fn NtSetThreadExecutionState( NewFlags: EXECUTION_STATE, - PreviousFlags: PEXECUTION_STATE, + PreviousFlags: *mut c_ulong, ) -> NTSTATUS; fn NtRequestWakeupLatency( latency: LATENCY_TIME, @@ -118,17 +120,17 @@ EXTERN!{extern "system" { fn NtInitiatePowerAction( SystemAction: POWER_ACTION, LightestSystemState: SYSTEM_POWER_STATE, - Flags: ULONG, - Asynchronous: BOOLEAN, + Flags: c_ulong, + Asynchronous: c_uchar, ) -> NTSTATUS; fn NtSetSystemPowerState( SystemAction: POWER_ACTION, LightestSystemState: SYSTEM_POWER_STATE, - Flags: ULONG, + Flags: c_ulong, ) -> NTSTATUS; fn NtGetDevicePowerState( Device: HANDLE, - State: PDEVICE_POWER_STATE, + State: *mut DEVICE_POWER_STATE, ) -> NTSTATUS; - fn NtIsSystemResumeAutomatic() -> BOOLEAN; + fn NtIsSystemResumeAutomatic() -> c_uchar; }} diff --git a/src/ntpsapi.rs b/src/ntpsapi.rs index 2a0d3cd..4aaec5a 100644 --- a/src/ntpsapi.rs +++ b/src/ntpsapi.rs @@ -1,64 +1,85 @@ -use crate::ntapi_base::{CLIENT_ID, KPRIORITY, PCLIENT_ID}; -use crate::ntexapi::{PROCESS_DISK_COUNTERS, PROCESS_ENERGY_VALUES}; -use crate::ntpebteb::{PPEB, PTEB}; -use winapi::ctypes::c_void; -use winapi::shared::basetsd::{PSIZE_T, SIZE_T, ULONG64, ULONG_PTR}; -use winapi::shared::ntdef::{ - BOOLEAN, HANDLE, LARGE_INTEGER, LIST_ENTRY, LONG, LONGLONG, NTSTATUS, NT_PRODUCT_TYPE, - PHANDLE, PLARGE_INTEGER, POBJECT_ATTRIBUTES, PROCESSOR_NUMBER, PSINGLE_LIST_ENTRY, PULONG, - PVOID, SINGLE_LIST_ENTRY, UCHAR, ULONG, ULONGLONG, UNICODE_STRING, USHORT, WCHAR, -}; -use winapi::um::winnt::{ - ACCESS_MASK, CONTEXT, HARDWARE_COUNTER_TYPE, IO_COUNTERS, JOBOBJECTINFOCLASS, - JOBOBJECT_BASIC_ACCOUNTING_INFORMATION, LDT_ENTRY, MAX_HW_COUNTERS, PCONTEXT, PJOB_SET_ARRAY, - PROCESS_MITIGATION_ASLR_POLICY, PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY, - PROCESS_MITIGATION_CHILD_PROCESS_POLICY, PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY, - PROCESS_MITIGATION_DYNAMIC_CODE_POLICY, PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY, - PROCESS_MITIGATION_FONT_DISABLE_POLICY, PROCESS_MITIGATION_IMAGE_LOAD_POLICY, - PROCESS_MITIGATION_PAYLOAD_RESTRICTION_POLICY, PROCESS_MITIGATION_POLICY, - PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY, PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY, - PROCESS_MITIGATION_SYSTEM_CALL_FILTER_POLICY, PSECURITY_QUALITY_OF_SERVICE, +use windows_sys::Win32::{ + Foundation::{HANDLE, NTSTATUS, UNICODE_STRING}, + Security::SECURITY_QUALITY_OF_SERVICE, + System::{ + Diagnostics::Debug::{CONTEXT, LDT_ENTRY}, + JobObjects::{ + JOBOBJECTINFOCLASS, JOBOBJECT_BASIC_ACCOUNTING_INFORMATION, + JOB_SET_ARRAY, + }, + Kernel::{ + LIST_ENTRY, NT_PRODUCT_TYPE, PROCESSOR_NUMBER, SINGLE_LIST_ENTRY, + }, + Performance::HardwareCounterProfiling::HARDWARE_COUNTER_TYPE, + SystemServices::{ + MAX_HW_COUNTERS, PROCESS_MITIGATION_ASLR_POLICY, + PROCESS_MITIGATION_BINARY_SIGNATURE_POLICY, + PROCESS_MITIGATION_CHILD_PROCESS_POLICY, + PROCESS_MITIGATION_CONTROL_FLOW_GUARD_POLICY, + PROCESS_MITIGATION_DYNAMIC_CODE_POLICY, + PROCESS_MITIGATION_EXTENSION_POINT_DISABLE_POLICY, + PROCESS_MITIGATION_FONT_DISABLE_POLICY, + PROCESS_MITIGATION_IMAGE_LOAD_POLICY, + PROCESS_MITIGATION_PAYLOAD_RESTRICTION_POLICY, + PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY, + PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY, + PROCESS_MITIGATION_SYSTEM_CALL_FILTER_POLICY, + }, + Threading::{IO_COUNTERS, PROCESS_MITIGATION_POLICY}, + WindowsProgramming::OBJECT_ATTRIBUTES, + }, }; + #[cfg(not(target_arch = "aarch64"))] -use crate::winapi_local::um::winnt::NtCurrentTeb; +use crate::windows_local::um::winnt::NtCurrentTeb; +use crate::{ + ctypes::{ + __int64, __uint64, c_long, c_uchar, c_ulong, c_ushort, c_void, wchar_t, + }, + ntapi_base::{CLIENT_ID, KPRIORITY, PCLIENT_ID}, + ntexapi::{PROCESS_DISK_COUNTERS, PROCESS_ENERGY_VALUES}, + ntpebteb::{PPEB, PTEB}, + windows_local::shared::ntdef::LARGE_INTEGER, +}; + pub const GDI_HANDLE_BUFFER_SIZE32: usize = 34; pub const GDI_HANDLE_BUFFER_SIZE64: usize = 60; #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] pub const GDI_HANDLE_BUFFER_SIZE: usize = GDI_HANDLE_BUFFER_SIZE64; #[cfg(target_arch = "x86")] pub const GDI_HANDLE_BUFFER_SIZE: usize = GDI_HANDLE_BUFFER_SIZE32; -pub type GDI_HANDLE_BUFFER = [ULONG; GDI_HANDLE_BUFFER_SIZE]; -pub type GDI_HANDLE_BUFFER32 = [ULONG; GDI_HANDLE_BUFFER_SIZE32]; -pub type GDI_HANDLE_BUFFER64 = [ULONG; GDI_HANDLE_BUFFER_SIZE]; +pub type GDI_HANDLE_BUFFER = [c_ulong; GDI_HANDLE_BUFFER_SIZE]; +pub type GDI_HANDLE_BUFFER32 = [c_ulong; GDI_HANDLE_BUFFER_SIZE32]; +pub type GDI_HANDLE_BUFFER64 = [c_ulong; GDI_HANDLE_BUFFER_SIZE]; pub const TLS_EXPANSION_SLOTS: usize = 1024; -STRUCT!{struct PEB_LDR_DATA { - Length: ULONG, - Initialized: BOOLEAN, +STRUCT! {struct PEB_LDR_DATA { + Length: c_ulong, + Initialized: c_uchar, SsHandle: HANDLE, InLoadOrderModuleList: LIST_ENTRY, InMemoryOrderModuleList: LIST_ENTRY, InInitializationOrderModuleList: LIST_ENTRY, - EntryInProgress: PVOID, - ShutdownInProgress: BOOLEAN, + EntryInProgress: *mut c_void, + ShutdownInProgress: c_uchar, ShutdownThreadId: HANDLE, }} pub type PPEB_LDR_DATA = *mut PEB_LDR_DATA; -STRUCT!{struct INITIAL_TEB_OldInitialTeb { - OldStackBase: PVOID, - OldStackLimit: PVOID, +STRUCT! {struct INITIAL_TEB_OldInitialTeb { + OldStackBase: *mut c_void, + OldStackLimit: *mut c_void, }} -STRUCT!{struct INITIAL_TEB { +STRUCT! {struct INITIAL_TEB { OldInitialTeb: INITIAL_TEB_OldInitialTeb, - StackBase: PVOID, - StackLimit: PVOID, - StackAllocationBase: PVOID, + StackBase: *mut c_void, + StackLimit: *mut c_void, + StackAllocationBase: *mut c_void, }} pub type PINITIAL_TEB = *mut INITIAL_TEB; -STRUCT!{struct WOW64_PROCESS { - Wow64: PVOID, +STRUCT! {struct WOW64_PROCESS { + Wow64: *mut c_void, }} pub type PWOW64_PROCESS = *mut WOW64_PROCESS; -ENUM!{enum PROCESSINFOCLASS { +ENUM! {enum PROCESSINFOCLASS { ProcessBasicInformation = 0, ProcessQuotaLimits = 1, ProcessIoCounters = 2, @@ -159,7 +180,7 @@ ENUM!{enum PROCESSINFOCLASS { ProcessLeapSecondInformation = 97, MaxProcessInfoClass = 98, }} -ENUM!{enum THREADINFOCLASS { +ENUM! {enum THREADINFOCLASS { ThreadBasicInformation = 0, ThreadTimes = 1, ThreadPriority = 2, @@ -213,25 +234,25 @@ ENUM!{enum THREADINFOCLASS { ThreadWorkloadClass = 50, MaxThreadInfoClass = 51, }} -STRUCT!{struct PAGE_PRIORITY_INFORMATION { - PagePriority: ULONG, +STRUCT! {struct PAGE_PRIORITY_INFORMATION { + PagePriority: c_ulong, }} pub type PPAGE_PRIORITY_INFORMATION = *mut PAGE_PRIORITY_INFORMATION; -STRUCT!{struct PROCESS_BASIC_INFORMATION { +STRUCT! {struct PROCESS_BASIC_INFORMATION { ExitStatus: NTSTATUS, PebBaseAddress: PPEB, - AffinityMask: ULONG_PTR, + AffinityMask: usize, BasePriority: KPRIORITY, UniqueProcessId: HANDLE, InheritedFromUniqueProcessId: HANDLE, }} pub type PPROCESS_BASIC_INFORMATION = *mut PROCESS_BASIC_INFORMATION; -STRUCT!{struct PROCESS_EXTENDED_BASIC_INFORMATION { - Size: SIZE_T, +STRUCT! {struct PROCESS_EXTENDED_BASIC_INFORMATION { + Size: usize, BasicInfo: PROCESS_BASIC_INFORMATION, - Flags: ULONG, + Flags: c_ulong, }} -BITFIELD!{PROCESS_EXTENDED_BASIC_INFORMATION Flags: ULONG [ +BITFIELD! {PROCESS_EXTENDED_BASIC_INFORMATION Flags: c_ulong [ IsProtectedProcess set_IsProtectedProcess[0..1], IsWow64Process set_IsWow64Process[1..2], IsProcessDeleting set_IsProcessDeleting[2..3], @@ -243,95 +264,97 @@ BITFIELD!{PROCESS_EXTENDED_BASIC_INFORMATION Flags: ULONG [ IsSubsystemProcess set_IsSubsystemProcess[8..9], SpareBits set_SpareBits[9..32], ]} -pub type PPROCESS_EXTENDED_BASIC_INFORMATION = *mut PROCESS_EXTENDED_BASIC_INFORMATION; -STRUCT!{struct VM_COUNTERS { - PeakVirtualSize: SIZE_T, - VirtualSize: SIZE_T, - PageFaultCount: ULONG, - PeakWorkingSetSize: SIZE_T, - WorkingSetSize: SIZE_T, - QuotaPeakPagedPoolUsage: SIZE_T, - QuotaPagedPoolUsage: SIZE_T, - QuotaPeakNonPagedPoolUsage: SIZE_T, - QuotaNonPagedPoolUsage: SIZE_T, - PagefileUsage: SIZE_T, - PeakPagefileUsage: SIZE_T, +pub type PPROCESS_EXTENDED_BASIC_INFORMATION = + *mut PROCESS_EXTENDED_BASIC_INFORMATION; +STRUCT! {struct VM_COUNTERS { + PeakVirtualSize: usize, + VirtualSize: usize, + PageFaultCount: c_ulong, + PeakWorkingSetSize: usize, + WorkingSetSize: usize, + QuotaPeakPagedPoolUsage: usize, + QuotaPagedPoolUsage: usize, + QuotaPeakNonPagedPoolUsage: usize, + QuotaNonPagedPoolUsage: usize, + PagefileUsage: usize, + PeakPagefileUsage: usize, }} pub type PVM_COUNTERS = *mut VM_COUNTERS; -STRUCT!{struct VM_COUNTERS_EX { - PeakVirtualSize: SIZE_T, - VirtualSize: SIZE_T, - PageFaultCount: ULONG, - PeakWorkingSetSize: SIZE_T, - WorkingSetSize: SIZE_T, - QuotaPeakPagedPoolUsage: SIZE_T, - QuotaPagedPoolUsage: SIZE_T, - QuotaPeakNonPagedPoolUsage: SIZE_T, - QuotaNonPagedPoolUsage: SIZE_T, - PagefileUsage: SIZE_T, - PeakPagefileUsage: SIZE_T, - PrivateUsage: SIZE_T, +STRUCT! {struct VM_COUNTERS_EX { + PeakVirtualSize: usize, + VirtualSize: usize, + PageFaultCount: c_ulong, + PeakWorkingSetSize: usize, + WorkingSetSize: usize, + QuotaPeakPagedPoolUsage: usize, + QuotaPagedPoolUsage: usize, + QuotaPeakNonPagedPoolUsage: usize, + QuotaNonPagedPoolUsage: usize, + PagefileUsage: usize, + PeakPagefileUsage: usize, + PrivateUsage: usize, }} pub type PVM_COUNTERS_EX = *mut VM_COUNTERS_EX; -STRUCT!{struct VM_COUNTERS_EX2 { +STRUCT! {struct VM_COUNTERS_EX2 { CountersEx: VM_COUNTERS_EX, - PrivateWorkingSetSize: SIZE_T, - SharedCommitUsage: SIZE_T, + PrivateWorkingSetSize: usize, + SharedCommitUsage: usize, }} pub type PVM_COUNTERS_EX2 = *mut VM_COUNTERS_EX2; -STRUCT!{struct KERNEL_USER_TIMES { +STRUCT! {struct KERNEL_USER_TIMES { CreateTime: LARGE_INTEGER, ExitTime: LARGE_INTEGER, KernelTime: LARGE_INTEGER, UserTime: LARGE_INTEGER, }} pub type PKERNEL_USER_TIMES = *mut KERNEL_USER_TIMES; -STRUCT!{struct POOLED_USAGE_AND_LIMITS { - PeakPagedPoolUsage: SIZE_T, - PagedPoolUsage: SIZE_T, - PagedPoolLimit: SIZE_T, - PeakNonPagedPoolUsage: SIZE_T, - NonPagedPoolUsage: SIZE_T, - NonPagedPoolLimit: SIZE_T, - PeakPagefileUsage: SIZE_T, - PagefileUsage: SIZE_T, - PagefileLimit: SIZE_T, +STRUCT! {struct POOLED_USAGE_AND_LIMITS { + PeakPagedPoolUsage: usize, + PagedPoolUsage: usize, + PagedPoolLimit: usize, + PeakNonPagedPoolUsage: usize, + NonPagedPoolUsage: usize, + NonPagedPoolLimit: usize, + PeakPagefileUsage: usize, + PagefileUsage: usize, + PagefileLimit: usize, }} pub type PPOOLED_USAGE_AND_LIMITS = *mut POOLED_USAGE_AND_LIMITS; -pub const PROCESS_EXCEPTION_PORT_ALL_STATE_BITS: ULONG_PTR = 0x00000003; -pub const PROCESS_EXCEPTION_PORT_ALL_STATE_FLAGS: ULONG_PTR = +pub const PROCESS_EXCEPTION_PORT_ALL_STATE_BITS: usize = 0x00000003; +pub const PROCESS_EXCEPTION_PORT_ALL_STATE_FLAGS: usize = (1 << PROCESS_EXCEPTION_PORT_ALL_STATE_BITS) - 1; -STRUCT!{struct PROCESS_EXCEPTION_PORT { +STRUCT! {struct PROCESS_EXCEPTION_PORT { ExceptionPortHandle: HANDLE, - StateFlags: ULONG, + StateFlags: c_ulong, }} pub type PPROCESS_EXCEPTION_PORT = *mut PROCESS_EXCEPTION_PORT; -STRUCT!{struct PROCESS_ACCESS_TOKEN { +STRUCT! {struct PROCESS_ACCESS_TOKEN { Token: HANDLE, Thread: HANDLE, }} pub type PPROCESS_ACCESS_TOKEN = *mut PROCESS_ACCESS_TOKEN; -STRUCT!{struct PROCESS_LDT_INFORMATION { - Start: ULONG, - Length: ULONG, +STRUCT! {struct PROCESS_LDT_INFORMATION { + Start: c_ulong, + Length: c_ulong, LdtEntries: [LDT_ENTRY; 1], }} pub type PPROCESS_LDT_INFORMATION = *mut PROCESS_LDT_INFORMATION; -STRUCT!{struct PROCESS_LDT_SIZE { - Length: ULONG, +STRUCT! {struct PROCESS_LDT_SIZE { + Length: c_ulong, }} pub type PPROCESS_LDT_SIZE = *mut PROCESS_LDT_SIZE; -STRUCT!{struct PROCESS_WS_WATCH_INFORMATION { - FaultingPc: PVOID, - FaultingVa: PVOID, +STRUCT! {struct PROCESS_WS_WATCH_INFORMATION { + FaultingPc: *mut c_void, + FaultingVa: *mut c_void, }} pub type PPROCESS_WS_WATCH_INFORMATION = *mut PROCESS_WS_WATCH_INFORMATION; -STRUCT!{struct PROCESS_WS_WATCH_INFORMATION_EX { +STRUCT! {struct PROCESS_WS_WATCH_INFORMATION_EX { BasicInfo: PROCESS_WS_WATCH_INFORMATION, - FaultingThreadId: ULONG_PTR, - Flags: ULONG_PTR, + FaultingThreadId: usize, + Flags: usize, }} -pub type PPROCESS_WS_WATCH_INFORMATION_EX = *mut PROCESS_WS_WATCH_INFORMATION_EX; +pub type PPROCESS_WS_WATCH_INFORMATION_EX = + *mut PROCESS_WS_WATCH_INFORMATION_EX; pub const PROCESS_PRIORITY_CLASS_UNKNOWN: u32 = 0; pub const PROCESS_PRIORITY_CLASS_IDLE: u32 = 1; pub const PROCESS_PRIORITY_CLASS_NORMAL: u32 = 2; @@ -339,171 +362,179 @@ pub const PROCESS_PRIORITY_CLASS_HIGH: u32 = 3; pub const PROCESS_PRIORITY_CLASS_REALTIME: u32 = 4; pub const PROCESS_PRIORITY_CLASS_BELOW_NORMAL: u32 = 5; pub const PROCESS_PRIORITY_CLASS_ABOVE_NORMAL: u32 = 6; -STRUCT!{struct PROCESS_PRIORITY_CLASS { - Foreground: BOOLEAN, - PriorityClass: UCHAR, +STRUCT! {struct PROCESS_PRIORITY_CLASS { + Foreground: c_uchar, + PriorityClass: c_uchar, }} pub type PPROCESS_PRIORITY_CLASS = *mut PROCESS_PRIORITY_CLASS; -STRUCT!{struct PROCESS_FOREGROUND_BACKGROUND { - Foreground: BOOLEAN, +STRUCT! {struct PROCESS_FOREGROUND_BACKGROUND { + Foreground: c_uchar, }} pub type PPROCESS_FOREGROUND_BACKGROUND = *mut PROCESS_FOREGROUND_BACKGROUND; -STRUCT!{struct PROCESS_DEVICEMAP_INFORMATION_Set { +STRUCT! {struct PROCESS_DEVICEMAP_INFORMATION_Set { DirectoryHandle: HANDLE, }} -STRUCT!{struct PROCESS_DEVICEMAP_INFORMATION_Query { - DriveMap: ULONG, - DriveType: [UCHAR; 32], +STRUCT! {struct PROCESS_DEVICEMAP_INFORMATION_Query { + DriveMap: c_ulong, + DriveType: [c_uchar; 32], }} -UNION!{union PROCESS_DEVICEMAP_INFORMATION { +UNION! {union PROCESS_DEVICEMAP_INFORMATION { Set: PROCESS_DEVICEMAP_INFORMATION_Set, Query: PROCESS_DEVICEMAP_INFORMATION_Query, }} pub type PPROCESS_DEVICEMAP_INFORMATION = *mut PROCESS_DEVICEMAP_INFORMATION; -pub const PROCESS_LUID_DOSDEVICES_ONLY: ULONG = 0x00000001; -STRUCT!{struct PROCESS_DEVICEMAP_INFORMATION_EX_u_Set { +pub const PROCESS_LUID_DOSDEVICES_ONLY: c_ulong = 0x00000001; +STRUCT! {struct PROCESS_DEVICEMAP_INFORMATION_EX_u_Set { DirectoryHandle: HANDLE, }} -STRUCT!{struct PROCESS_DEVICEMAP_INFORMATION_EX_u_Query { - DriveMap: ULONG, - DriveType: [UCHAR; 32], +STRUCT! {struct PROCESS_DEVICEMAP_INFORMATION_EX_u_Query { + DriveMap: c_ulong, + DriveType: [c_uchar; 32], }} -UNION!{union PROCESS_DEVICEMAP_INFORMATION_EX_u { +UNION! {union PROCESS_DEVICEMAP_INFORMATION_EX_u { Set: PROCESS_DEVICEMAP_INFORMATION_EX_u_Set, Query: PROCESS_DEVICEMAP_INFORMATION_EX_u_Query, }} -STRUCT!{struct PROCESS_DEVICEMAP_INFORMATION_EX { +STRUCT! {struct PROCESS_DEVICEMAP_INFORMATION_EX { u: PROCESS_DEVICEMAP_INFORMATION_EX_u, - Flags: ULONG, + Flags: c_ulong, }} -pub type PPROCESS_DEVICEMAP_INFORMATION_EX = *mut PROCESS_DEVICEMAP_INFORMATION_EX; -STRUCT!{struct PROCESS_SESSION_INFORMATION { - SessionId: ULONG, +pub type PPROCESS_DEVICEMAP_INFORMATION_EX = + *mut PROCESS_DEVICEMAP_INFORMATION_EX; +STRUCT! {struct PROCESS_SESSION_INFORMATION { + SessionId: c_ulong, }} pub type PPROCESS_SESSION_INFORMATION = *mut PROCESS_SESSION_INFORMATION; -pub const PROCESS_HANDLE_EXCEPTIONS_ENABLED: ULONG = 0x00000001; -pub const PROCESS_HANDLE_RAISE_EXCEPTION_ON_INVALID_HANDLE_CLOSE_DISABLED: ULONG = 0x00000000; -pub const PROCESS_HANDLE_RAISE_EXCEPTION_ON_INVALID_HANDLE_CLOSE_ENABLED: ULONG = 0x00000001; -STRUCT!{struct PROCESS_HANDLE_TRACING_ENABLE { - Flags: ULONG, +pub const PROCESS_HANDLE_EXCEPTIONS_ENABLED: c_ulong = 0x00000001; +pub const PROCESS_HANDLE_RAISE_EXCEPTION_ON_INVALID_HANDLE_CLOSE_DISABLED: + c_ulong = 0x00000000; +pub const PROCESS_HANDLE_RAISE_EXCEPTION_ON_INVALID_HANDLE_CLOSE_ENABLED: + c_ulong = 0x00000001; +STRUCT! {struct PROCESS_HANDLE_TRACING_ENABLE { + Flags: c_ulong, }} pub type PPROCESS_HANDLE_TRACING_ENABLE = *mut PROCESS_HANDLE_TRACING_ENABLE; -pub const PROCESS_HANDLE_TRACING_MAX_SLOTS: ULONG = 0x20000; -STRUCT!{struct PROCESS_HANDLE_TRACING_ENABLE_EX { - Flags: ULONG, - TotalSlots: ULONG, +pub const PROCESS_HANDLE_TRACING_MAX_SLOTS: c_ulong = 0x20000; +STRUCT! {struct PROCESS_HANDLE_TRACING_ENABLE_EX { + Flags: c_ulong, + TotalSlots: c_ulong, }} -pub type PPROCESS_HANDLE_TRACING_ENABLE_EX = *mut PROCESS_HANDLE_TRACING_ENABLE_EX; +pub type PPROCESS_HANDLE_TRACING_ENABLE_EX = + *mut PROCESS_HANDLE_TRACING_ENABLE_EX; pub const PROCESS_HANDLE_TRACING_MAX_STACKS: usize = 16; -pub const PROCESS_HANDLE_TRACE_TYPE_OPEN: ULONG = 1; -pub const PROCESS_HANDLE_TRACE_TYPE_CLOSE: ULONG = 2; -pub const PROCESS_HANDLE_TRACE_TYPE_BADREF: ULONG = 3; -STRUCT!{struct PROCESS_HANDLE_TRACING_ENTRY { +pub const PROCESS_HANDLE_TRACE_TYPE_OPEN: c_ulong = 1; +pub const PROCESS_HANDLE_TRACE_TYPE_CLOSE: c_ulong = 2; +pub const PROCESS_HANDLE_TRACE_TYPE_BADREF: c_ulong = 3; +STRUCT! {struct PROCESS_HANDLE_TRACING_ENTRY { Handle: HANDLE, ClientId: CLIENT_ID, - Type: ULONG, - Stacks: [PVOID; PROCESS_HANDLE_TRACING_MAX_STACKS], + Type: c_ulong, + Stacks: [*mut c_void; PROCESS_HANDLE_TRACING_MAX_STACKS], }} pub type PPROCESS_HANDLE_TRACING_ENTRY = *mut PROCESS_HANDLE_TRACING_ENTRY; -STRUCT!{struct PROCESS_HANDLE_TRACING_QUERY { +STRUCT! {struct PROCESS_HANDLE_TRACING_QUERY { Handle: HANDLE, - TotalTraces: ULONG, + TotalTraces: c_ulong, HandleTrace: [PROCESS_HANDLE_TRACING_ENTRY; 1], }} pub type PPROCESS_HANDLE_TRACING_QUERY = *mut PROCESS_HANDLE_TRACING_QUERY; -STRUCT!{struct THREAD_TLS_INFORMATION { - Flags: ULONG, - NewTlsData: PVOID, - OldTlsData: PVOID, +STRUCT! {struct THREAD_TLS_INFORMATION { + Flags: c_ulong, + NewTlsData: *mut c_void, + OldTlsData: *mut c_void, ThreadId: HANDLE, }} pub type PTHREAD_TLS_INFORMATION = *mut THREAD_TLS_INFORMATION; -ENUM!{enum PROCESS_TLS_INFORMATION_TYPE { +ENUM! {enum PROCESS_TLS_INFORMATION_TYPE { ProcessTlsReplaceIndex = 0, ProcessTlsReplaceVector = 1, MaxProcessTlsOperation = 2, }} pub type PPROCESS_TLS_INFORMATION_TYPE = *mut PROCESS_TLS_INFORMATION_TYPE; -STRUCT!{struct PROCESS_TLS_INFORMATION { - Flags: ULONG, - OperationType: ULONG, - ThreadDataCount: ULONG, - TlsIndex: ULONG, - PreviousCount: ULONG, +STRUCT! {struct PROCESS_TLS_INFORMATION { + Flags: c_ulong, + OperationType: c_ulong, + ThreadDataCount: c_ulong, + TlsIndex: c_ulong, + PreviousCount: c_ulong, ThreadData: [THREAD_TLS_INFORMATION; 1], }} pub type PPROCESS_TLS_INFORMATION = *mut PROCESS_TLS_INFORMATION; -STRUCT!{struct PROCESS_INSTRUMENTATION_CALLBACK_INFORMATION { - Version: ULONG, - Reserved: ULONG, - Callback: PVOID, +STRUCT! {struct PROCESS_INSTRUMENTATION_CALLBACK_INFORMATION { + Version: c_ulong, + Reserved: c_ulong, + Callback: *mut c_void, }} pub type PPROCESS_INSTRUMENTATION_CALLBACK_INFORMATION = *mut PROCESS_INSTRUMENTATION_CALLBACK_INFORMATION; -STRUCT!{struct PROCESS_STACK_ALLOCATION_INFORMATION { - ReserveSize: SIZE_T, - ZeroBits: SIZE_T, - StackBase: PVOID, -}} -pub type PPROCESS_STACK_ALLOCATION_INFORMATION = *mut PROCESS_STACK_ALLOCATION_INFORMATION; -STRUCT!{struct PROCESS_STACK_ALLOCATION_INFORMATION_EX { - PreferredNode: ULONG, - Reserved0: ULONG, - Reserved1: ULONG, - Reserved2: ULONG, +STRUCT! {struct PROCESS_STACK_ALLOCATION_INFORMATION { + ReserveSize: usize, + ZeroBits: usize, + StackBase: *mut c_void, +}} +pub type PPROCESS_STACK_ALLOCATION_INFORMATION = + *mut PROCESS_STACK_ALLOCATION_INFORMATION; +STRUCT! {struct PROCESS_STACK_ALLOCATION_INFORMATION_EX { + PreferredNode: c_ulong, + Reserved0: c_ulong, + Reserved1: c_ulong, + Reserved2: c_ulong, AllocInfo: PROCESS_STACK_ALLOCATION_INFORMATION, }} -pub type PPROCESS_STACK_ALLOCATION_INFORMATION_EX = *mut PROCESS_STACK_ALLOCATION_INFORMATION_EX; -STRUCT!{struct PROCESS_AFFINITY_UPDATE_MODE { - Flags: ULONG, +pub type PPROCESS_STACK_ALLOCATION_INFORMATION_EX = + *mut PROCESS_STACK_ALLOCATION_INFORMATION_EX; +STRUCT! {struct PROCESS_AFFINITY_UPDATE_MODE { + Flags: c_ulong, }} -BITFIELD!{PROCESS_AFFINITY_UPDATE_MODE Flags: ULONG [ +BITFIELD! {PROCESS_AFFINITY_UPDATE_MODE Flags: c_ulong [ EnableAutoUpdate set_EnableAutoUpdate[0..1], Permanent set_Permanent[1..2], Reserved set_Reserved[2..32], ]} pub type PPROCESS_AFFINITY_UPDATE_MODE = *mut PROCESS_AFFINITY_UPDATE_MODE; -STRUCT!{struct PROCESS_MEMORY_ALLOCATION_MODE { - Flags: ULONG, +STRUCT! {struct PROCESS_MEMORY_ALLOCATION_MODE { + Flags: c_ulong, }} -BITFIELD!{PROCESS_MEMORY_ALLOCATION_MODE Flags: ULONG [ +BITFIELD! {PROCESS_MEMORY_ALLOCATION_MODE Flags: c_ulong [ TopDown set_TopDown[0..1], Reserved set_Reserved[1..32], ]} pub type PPROCESS_MEMORY_ALLOCATION_MODE = *mut PROCESS_MEMORY_ALLOCATION_MODE; -STRUCT!{struct PROCESS_HANDLE_INFORMATION { - HandleCount: ULONG, - HandleCountHighWatermark: ULONG, +STRUCT! {struct PROCESS_HANDLE_INFORMATION { + HandleCount: c_ulong, + HandleCountHighWatermark: c_ulong, }} pub type PPROCESS_HANDLE_INFORMATION = *mut PROCESS_HANDLE_INFORMATION; -STRUCT!{struct PROCESS_CYCLE_TIME_INFORMATION { - AccumulatedCycles: ULONGLONG, - CurrentCycleCount: ULONGLONG, +STRUCT! {struct PROCESS_CYCLE_TIME_INFORMATION { + AccumulatedCycles: __uint64, + CurrentCycleCount: __uint64, }} pub type PPROCESS_CYCLE_TIME_INFORMATION = *mut PROCESS_CYCLE_TIME_INFORMATION; -STRUCT!{struct PROCESS_WINDOW_INFORMATION { - WindowFlags: ULONG, - WindowTitleLength: USHORT, - WindowTitle: [WCHAR; 1], +STRUCT! {struct PROCESS_WINDOW_INFORMATION { + WindowFlags: c_ulong, + WindowTitleLength: c_ushort, + WindowTitle: [wchar_t; 1], }} pub type PPROCESS_WINDOW_INFORMATION = *mut PROCESS_WINDOW_INFORMATION; -STRUCT!{struct PROCESS_HANDLE_TABLE_ENTRY_INFO { +STRUCT! {struct PROCESS_HANDLE_TABLE_ENTRY_INFO { HandleValue: HANDLE, - HandleCount: ULONG_PTR, - PointerCount: ULONG_PTR, - GrantedAccess: ULONG, - ObjectTypeIndex: ULONG, - HandleAttributes: ULONG, - Reserved: ULONG, -}} -pub type PPROCESS_HANDLE_TABLE_ENTRY_INFO = *mut PROCESS_HANDLE_TABLE_ENTRY_INFO; -STRUCT!{struct PROCESS_HANDLE_SNAPSHOT_INFORMATION { - NumberOfHandles: ULONG_PTR, - Reserved: ULONG_PTR, + HandleCount: usize, + PointerCount: usize, + GrantedAccess: c_ulong, + ObjectTypeIndex: c_ulong, + HandleAttributes: c_ulong, + Reserved: c_ulong, +}} +pub type PPROCESS_HANDLE_TABLE_ENTRY_INFO = + *mut PROCESS_HANDLE_TABLE_ENTRY_INFO; +STRUCT! {struct PROCESS_HANDLE_SNAPSHOT_INFORMATION { + NumberOfHandles: usize, + Reserved: usize, Handles: [PROCESS_HANDLE_TABLE_ENTRY_INFO; 1], }} -pub type PPROCESS_HANDLE_SNAPSHOT_INFORMATION = *mut PROCESS_HANDLE_SNAPSHOT_INFORMATION; -UNION!{union PROCESS_MITIGATION_POLICY_INFORMATION_u { +pub type PPROCESS_HANDLE_SNAPSHOT_INFORMATION = + *mut PROCESS_HANDLE_SNAPSHOT_INFORMATION; +UNION! {union PROCESS_MITIGATION_POLICY_INFORMATION_u { ASLRPolicy: PROCESS_MITIGATION_ASLR_POLICY, StrictHandleCheckPolicy: PROCESS_MITIGATION_STRICT_HANDLE_CHECK_POLICY, SystemCallDisablePolicy: PROCESS_MITIGATION_SYSTEM_CALL_DISABLE_POLICY, @@ -518,38 +549,41 @@ UNION!{union PROCESS_MITIGATION_POLICY_INFORMATION_u { ChildProcessPolicy: PROCESS_MITIGATION_CHILD_PROCESS_POLICY, // SideChannelIsolationPolicy: PROCESS_MITIGATION_SIDE_CHANNEL_ISOLATION_POLICY, //TODO }} -STRUCT!{struct PROCESS_MITIGATION_POLICY_INFORMATION { +STRUCT! {struct PROCESS_MITIGATION_POLICY_INFORMATION { Policy: PROCESS_MITIGATION_POLICY, u: PROCESS_MITIGATION_POLICY_INFORMATION_u, }} -pub type PPROCESS_MITIGATION_POLICY_INFORMATION = *mut PROCESS_MITIGATION_POLICY_INFORMATION; -STRUCT!{struct PROCESS_KEEPALIVE_COUNT_INFORMATION { - WakeCount: ULONG, - NoWakeCount: ULONG, +pub type PPROCESS_MITIGATION_POLICY_INFORMATION = + *mut PROCESS_MITIGATION_POLICY_INFORMATION; +STRUCT! {struct PROCESS_KEEPALIVE_COUNT_INFORMATION { + WakeCount: c_ulong, + NoWakeCount: c_ulong, }} -pub type PPROCESS_KEEPALIVE_COUNT_INFORMATION = *mut PROCESS_KEEPALIVE_COUNT_INFORMATION; -STRUCT!{struct PROCESS_REVOKE_FILE_HANDLES_INFORMATION { +pub type PPROCESS_KEEPALIVE_COUNT_INFORMATION = + *mut PROCESS_KEEPALIVE_COUNT_INFORMATION; +STRUCT! {struct PROCESS_REVOKE_FILE_HANDLES_INFORMATION { TargetDevicePath: UNICODE_STRING, }} -pub type PPROCESS_REVOKE_FILE_HANDLES_INFORMATION = *mut PROCESS_REVOKE_FILE_HANDLES_INFORMATION; -ENUM!{enum PROCESS_WORKING_SET_OPERATION { +pub type PPROCESS_REVOKE_FILE_HANDLES_INFORMATION = + *mut PROCESS_REVOKE_FILE_HANDLES_INFORMATION; +ENUM! {enum PROCESS_WORKING_SET_OPERATION { ProcessWorkingSetSwap = 0, ProcessWorkingSetEmpty = 1, ProcessWorkingSetOperationMax = 2, }} -STRUCT!{struct PROCESS_WORKING_SET_CONTROL { - Version: ULONG, +STRUCT! {struct PROCESS_WORKING_SET_CONTROL { + Version: c_ulong, Operation: PROCESS_WORKING_SET_OPERATION, - Flags: ULONG, + Flags: c_ulong, }} pub type PPROCESS_WORKING_SET_CONTROL = *mut PROCESS_WORKING_SET_CONTROL; -ENUM!{enum PS_PROTECTED_TYPE { +ENUM! {enum PS_PROTECTED_TYPE { PsProtectedTypeNone = 0, PsProtectedTypeProtectedLight = 1, PsProtectedTypeProtected = 2, PsProtectedTypeMax = 3, }} -ENUM!{enum PS_PROTECTED_SIGNER { +ENUM! {enum PS_PROTECTED_SIGNER { PsProtectedSignerNone = 0, PsProtectedSignerAuthenticode = 1, PsProtectedSignerCodeGen = 2, @@ -561,16 +595,17 @@ ENUM!{enum PS_PROTECTED_SIGNER { PsProtectedSignerApp = 8, PsProtectedSignerMax = 9, }} -pub const PS_PROTECTED_SIGNER_MASK: UCHAR = 0xFF; -pub const PS_PROTECTED_AUDIT_MASK: UCHAR = 0x08; -pub const PS_PROTECTED_TYPE_MASK: UCHAR = 0x07; +pub const PS_PROTECTED_SIGNER_MASK: c_uchar = 0xFF; +pub const PS_PROTECTED_AUDIT_MASK: c_uchar = 0x08; +pub const PS_PROTECTED_TYPE_MASK: c_uchar = 0x07; #[inline] pub const fn PsProtectedValue( aSigner: PS_PROTECTED_SIGNER, aAudit: u8, aType: PS_PROTECTED_TYPE, -) -> UCHAR { - (aSigner as u8 & PS_PROTECTED_SIGNER_MASK) << 4 | (aAudit & PS_PROTECTED_AUDIT_MASK) << 3 +) -> c_uchar { + (aSigner as u8 & PS_PROTECTED_SIGNER_MASK) << 4 + | (aAudit & PS_PROTECTED_AUDIT_MASK) << 3 | (aType as u8 & PS_PROTECTED_TYPE_MASK) } #[inline] @@ -584,89 +619,92 @@ pub fn InitializePsProtection( aProtectionLevelPtr.set_Audit(aAudit); aProtectionLevelPtr.set_Type(aType as u8); } -STRUCT!{struct PS_PROTECTION { - Level: UCHAR, +STRUCT! {struct PS_PROTECTION { + Level: c_uchar, }} pub type PPS_PROTECTION = *mut PS_PROTECTION; -BITFIELD!{PS_PROTECTION Level: UCHAR [ +BITFIELD! {PS_PROTECTION Level: c_uchar [ Type set_Type[0..3], Audit set_Audit[3..4], Signer set_Signer[4..8], ]} -STRUCT!{struct PROCESS_FAULT_INFORMATION { - FaultFlags: ULONG, - AdditionalInfo: ULONG, +STRUCT! {struct PROCESS_FAULT_INFORMATION { + FaultFlags: c_ulong, + AdditionalInfo: c_ulong, }} pub type PPROCESS_FAULT_INFORMATION = *mut PROCESS_FAULT_INFORMATION; -STRUCT!{struct PROCESS_TELEMETRY_ID_INFORMATION { - HeaderSize: ULONG, - ProcessId: ULONG, - ProcessStartKey: ULONGLONG, - CreateTime: ULONGLONG, - CreateInterruptTime: ULONGLONG, - CreateUnbiasedInterruptTime: ULONGLONG, - ProcessSequenceNumber: ULONGLONG, - SessionCreateTime: ULONGLONG, - SessionId: ULONG, - BootId: ULONG, - ImageChecksum: ULONG, - ImageTimeDateStamp: ULONG, - UserSidOffset: ULONG, - ImagePathOffset: ULONG, - PackageNameOffset: ULONG, - RelativeAppNameOffset: ULONG, - CommandLineOffset: ULONG, -}} -pub type PPROCESS_TELEMETRY_ID_INFORMATION = *mut PROCESS_TELEMETRY_ID_INFORMATION; -STRUCT!{struct PROCESS_COMMIT_RELEASE_INFORMATION { - Version: ULONG, - s: ULONG, - CommitDebt: SIZE_T, - CommittedMemResetSize: SIZE_T, - RepurposedMemResetSize: SIZE_T, -}} -BITFIELD!{PROCESS_COMMIT_RELEASE_INFORMATION s: ULONG [ +STRUCT! {struct PROCESS_TELEMETRY_ID_INFORMATION { + HeaderSize: c_ulong, + ProcessId: c_ulong, + ProcessStartKey: __uint64, + CreateTime: __uint64, + CreateInterruptTime: __uint64, + CreateUnbiasedInterruptTime: __uint64, + ProcessSequenceNumber: __uint64, + SessionCreateTime: __uint64, + SessionId: c_ulong, + BootId: c_ulong, + ImageChecksum: c_ulong, + ImageTimeDateStamp: c_ulong, + UserSidOffset: c_ulong, + ImagePathOffset: c_ulong, + PackageNameOffset: c_ulong, + RelativeAppNameOffset: c_ulong, + CommandLineOffset: c_ulong, +}} +pub type PPROCESS_TELEMETRY_ID_INFORMATION = + *mut PROCESS_TELEMETRY_ID_INFORMATION; +STRUCT! {struct PROCESS_COMMIT_RELEASE_INFORMATION { + Version: c_ulong, + s: c_ulong, + CommitDebt: usize, + CommittedMemResetSize: usize, + RepurposedMemResetSize: usize, +}} +BITFIELD! {PROCESS_COMMIT_RELEASE_INFORMATION s: c_ulong [ Eligible set_Eligible[0..1], ReleaseRepurposedMemResetCommit set_ReleaseRepurposedMemResetCommit[1..2], ForceReleaseMemResetCommit set_ForceReleaseMemResetCommit[2..3], Spare set_Spare[3..32], ]} -pub type PPROCESS_COMMIT_RELEASE_INFORMATION = *mut PROCESS_COMMIT_RELEASE_INFORMATION; -STRUCT!{struct PROCESS_JOB_MEMORY_INFO { - SharedCommitUsage: ULONGLONG, - PrivateCommitUsage: ULONGLONG, - PeakPrivateCommitUsage: ULONGLONG, - PrivateCommitLimit: ULONGLONG, - TotalCommitLimit: ULONGLONG, +pub type PPROCESS_COMMIT_RELEASE_INFORMATION = + *mut PROCESS_COMMIT_RELEASE_INFORMATION; +STRUCT! {struct PROCESS_JOB_MEMORY_INFO { + SharedCommitUsage: __uint64, + PrivateCommitUsage: __uint64, + PeakPrivateCommitUsage: __uint64, + PrivateCommitLimit: __uint64, + TotalCommitLimit: __uint64, }} pub type PPROCESS_JOB_MEMORY_INFO = *mut PROCESS_JOB_MEMORY_INFO; -STRUCT!{struct PROCESS_CHILD_PROCESS_INFORMATION { - ProhibitChildProcesses: BOOLEAN, - AlwaysAllowSecureChildProcess: BOOLEAN, - AuditProhibitChildProcesses: BOOLEAN, -}} -pub type PPROCESS_CHILD_PROCESS_INFORMATION = *mut PROCESS_CHILD_PROCESS_INFORMATION; -STRUCT!{struct PROCESS_WAKE_INFORMATION { - NotificationChannel: ULONGLONG, - WakeCounters: [ULONG; 7], +STRUCT! {struct PROCESS_CHILD_PROCESS_INFORMATION { + ProhibitChildProcesses: c_uchar, + AlwaysAllowSecureChildProcess: c_uchar, + AuditProhibitChildProcesses: c_uchar, +}} +pub type PPROCESS_CHILD_PROCESS_INFORMATION = + *mut PROCESS_CHILD_PROCESS_INFORMATION; +STRUCT! {struct PROCESS_WAKE_INFORMATION { + NotificationChannel: __uint64, + WakeCounters: [c_ulong; 7], WakeFilter: *mut JOBOBJECT_WAKE_FILTER, }} pub type PPROCESS_WAKE_INFORMATION = *mut PROCESS_WAKE_INFORMATION; -STRUCT!{struct PROCESS_ENERGY_TRACKING_STATE { - StateUpdateMask: ULONG, - StateDesiredValue: ULONG, - StateSequence: ULONG, - UpdateTag: ULONG, - Tag: [WCHAR; 64], +STRUCT! {struct PROCESS_ENERGY_TRACKING_STATE { + StateUpdateMask: c_ulong, + StateDesiredValue: c_ulong, + StateSequence: c_ulong, + UpdateTag: c_ulong, + Tag: [wchar_t; 64], }} pub type PPROCESS_ENERGY_TRACKING_STATE = *mut PROCESS_ENERGY_TRACKING_STATE; -BITFIELD!{PROCESS_ENERGY_TRACKING_STATE UpdateTag: ULONG [ +BITFIELD! {PROCESS_ENERGY_TRACKING_STATE UpdateTag: c_ulong [ UpdateTag set_UpdateTag[0..1], ]} -STRUCT!{struct MANAGE_WRITES_TO_EXECUTABLE_MEMORY { - BitFields: ULONG, +STRUCT! {struct MANAGE_WRITES_TO_EXECUTABLE_MEMORY { + BitFields: c_ulong, }} -BITFIELD!{MANAGE_WRITES_TO_EXECUTABLE_MEMORY BitFields: ULONG [ +BITFIELD! {MANAGE_WRITES_TO_EXECUTABLE_MEMORY BitFields: c_ulong [ Machine set_Machine[0..16], KernelMode set_KernelMode[16..17], UserMode set_UserMode[17..18], @@ -674,58 +712,62 @@ BITFIELD!{MANAGE_WRITES_TO_EXECUTABLE_MEMORY BitFields: ULONG [ Process set_Process[19..20], ReservedZero0 set_ReservedZero0[20..32], ]} -pub type PMANAGE_WRITES_TO_EXECUTABLE_MEMORY = *mut MANAGE_WRITES_TO_EXECUTABLE_MEMORY; -pub const PROCESS_READWRITEVM_LOGGING_ENABLE_READVM: UCHAR = 1; -pub const PROCESS_READWRITEVM_LOGGING_ENABLE_WRITEVM: UCHAR = 2; -pub const PROCESS_READWRITEVM_LOGGING_ENABLE_READVM_V: UCHAR = 1; -pub const PROCESS_READWRITEVM_LOGGING_ENABLE_WRITEVM_V: UCHAR = 2; -STRUCT!{struct PROCESS_READWRITEVM_LOGGING_INFORMATION { - Flags: UCHAR, -}} -BITFIELD!{PROCESS_READWRITEVM_LOGGING_INFORMATION Flags: UCHAR [ +pub type PMANAGE_WRITES_TO_EXECUTABLE_MEMORY = + *mut MANAGE_WRITES_TO_EXECUTABLE_MEMORY; +pub const PROCESS_READWRITEVM_LOGGING_ENABLE_READVM: c_uchar = 1; +pub const PROCESS_READWRITEVM_LOGGING_ENABLE_WRITEVM: c_uchar = 2; +pub const PROCESS_READWRITEVM_LOGGING_ENABLE_READVM_V: c_uchar = 1; +pub const PROCESS_READWRITEVM_LOGGING_ENABLE_WRITEVM_V: c_uchar = 2; +STRUCT! {struct PROCESS_READWRITEVM_LOGGING_INFORMATION { + Flags: c_uchar, +}} +BITFIELD! {PROCESS_READWRITEVM_LOGGING_INFORMATION Flags: c_uchar [ EnableReadVmLogging set_EnableReadVmLogging[0..1], EnableWriteVmLogging set_EnableWriteVmLogging[1..2], Unused set_Unused[2..8], ]} -UNION!{union PROCESS_UPTIME_INFORMATION_u { - HangCount: ULONG, - GhostCount: ULONG, - Crashed: ULONG, - Terminated: ULONG, -}} -pub type PPROCESS_READWRITEVM_LOGGING_INFORMATION = *mut PROCESS_READWRITEVM_LOGGING_INFORMATION; -STRUCT!{struct PROCESS_UPTIME_INFORMATION { - QueryInterruptTime: ULONGLONG, - QueryUnbiasedTime: ULONGLONG, - EndInterruptTime: ULONGLONG, - TimeSinceCreation: ULONGLONG, - Uptime: ULONGLONG, - SuspendedTime: ULONGLONG, +UNION! {union PROCESS_UPTIME_INFORMATION_u { + HangCount: c_ulong, + GhostCount: c_ulong, + Crashed: c_ulong, + Terminated: c_ulong, +}} +pub type PPROCESS_READWRITEVM_LOGGING_INFORMATION = + *mut PROCESS_READWRITEVM_LOGGING_INFORMATION; +STRUCT! {struct PROCESS_UPTIME_INFORMATION { + QueryInterruptTime: __uint64, + QueryUnbiasedTime: __uint64, + EndInterruptTime: __uint64, + TimeSinceCreation: __uint64, + Uptime: __uint64, + SuspendedTime: __uint64, u: PROCESS_UPTIME_INFORMATION_u, }} pub type PPROCESS_UPTIME_INFORMATION = *mut PROCESS_UPTIME_INFORMATION; -STRUCT!{struct PROCESS_SYSTEM_RESOURCE_MANAGEMENT { - Flags: ULONG, +STRUCT! {struct PROCESS_SYSTEM_RESOURCE_MANAGEMENT { + Flags: c_ulong, }} -pub type PPROCESS_SYSTEM_RESOURCE_MANAGEMENT = *mut PROCESS_SYSTEM_RESOURCE_MANAGEMENT; -BITFIELD!{PROCESS_SYSTEM_RESOURCE_MANAGEMENT Flags: ULONG [ +pub type PPROCESS_SYSTEM_RESOURCE_MANAGEMENT = + *mut PROCESS_SYSTEM_RESOURCE_MANAGEMENT; +BITFIELD! {PROCESS_SYSTEM_RESOURCE_MANAGEMENT Flags: c_ulong [ Foreground set_Foreground[0..1], Reserved set_Reserved[1..32], ]} -STRUCT!{struct PROCESS_SECURITY_DOMAIN_INFORMATION { - SecurityDomain: ULONGLONG, +STRUCT! {struct PROCESS_SECURITY_DOMAIN_INFORMATION { + SecurityDomain: __uint64, }} -pub type PPROCESS_SECURITY_DOMAIN_INFORMATION = *mut PROCESS_SECURITY_DOMAIN_INFORMATION; -STRUCT!{struct PROCESS_COMBINE_SECURITY_DOMAINS_INFORMATION { +pub type PPROCESS_SECURITY_DOMAIN_INFORMATION = + *mut PROCESS_SECURITY_DOMAIN_INFORMATION; +STRUCT! {struct PROCESS_COMBINE_SECURITY_DOMAINS_INFORMATION { ProcessHandle: HANDLE, }} pub type PPROCESS_COMBINE_SECURITY_DOMAINS_INFORMATION = *mut PROCESS_COMBINE_SECURITY_DOMAINS_INFORMATION; -STRUCT!{struct PROCESS_LOGGING_INFORMATION { - Flags: ULONG, - BitFields: ULONG, +STRUCT! {struct PROCESS_LOGGING_INFORMATION { + Flags: c_ulong, + BitFields: c_ulong, }} -BITFIELD!{PROCESS_LOGGING_INFORMATION BitFields: ULONG [ +BITFIELD! {PROCESS_LOGGING_INFORMATION BitFields: c_ulong [ EnableReadVmLogging set_EnableReadVmLogging[0..1], EnableWriteVmLogging set_EnableWriteVmLogging[1..2], EnableProcessSuspendResumeLogging set_EnableProcessSuspendResumeLogging[2..3], @@ -733,186 +775,188 @@ BITFIELD!{PROCESS_LOGGING_INFORMATION BitFields: ULONG [ Reserved set_Reserved[4..32], ]} pub type PPROCESS_LOGGING_INFORMATION = *mut PROCESS_LOGGING_INFORMATION; -STRUCT!{struct PROCESS_LEAP_SECOND_INFORMATION { - Flags: ULONG, - Reserved: ULONG, +STRUCT! {struct PROCESS_LEAP_SECOND_INFORMATION { + Flags: c_ulong, + Reserved: c_ulong, }} -pub type PPROCESS_LEAP_SECOND_INFORMATION = *mut PROCESS_LEAP_SECOND_INFORMATION; -STRUCT!{struct THREAD_BASIC_INFORMATION { +pub type PPROCESS_LEAP_SECOND_INFORMATION = + *mut PROCESS_LEAP_SECOND_INFORMATION; +STRUCT! {struct THREAD_BASIC_INFORMATION { ExitStatus: NTSTATUS, TebBaseAddress: PTEB, ClientId: CLIENT_ID, - AffinityMask: ULONG_PTR, + AffinityMask: usize, Priority: KPRIORITY, - BasePriority: LONG, + BasePriority: c_long, }} pub type PTHREAD_BASIC_INFORMATION = *mut THREAD_BASIC_INFORMATION; -STRUCT!{struct THREAD_LAST_SYSCALL_INFORMATION { - FirstArgument: PVOID, - SystemCallNumber: USHORT, - Pad: [USHORT; 1], - WaitTime: ULONG64, -}} -pub type PTHREAD_LAST_SYSCALL_INFORMATION = *mut THREAD_LAST_SYSCALL_INFORMATION; -STRUCT!{struct THREAD_CYCLE_TIME_INFORMATION { - AccumulatedCycles: ULONGLONG, - CurrentCycleCount: ULONGLONG, +STRUCT! {struct THREAD_LAST_SYSCALL_INFORMATION { + FirstArgument: *mut c_void, + SystemCallNumber: c_ushort, + Pad: [c_ushort; 1], + WaitTime: __uint64, +}} +pub type PTHREAD_LAST_SYSCALL_INFORMATION = + *mut THREAD_LAST_SYSCALL_INFORMATION; +STRUCT! {struct THREAD_CYCLE_TIME_INFORMATION { + AccumulatedCycles: __uint64, + CurrentCycleCount: __uint64, }} pub type PTHREAD_CYCLE_TIME_INFORMATION = *mut THREAD_CYCLE_TIME_INFORMATION; -STRUCT!{struct THREAD_TEB_INFORMATION { - TebInformation: PVOID, - TebOffset: ULONG, - BytesToRead: ULONG, +STRUCT! {struct THREAD_TEB_INFORMATION { + TebInformation: *mut c_void, + TebOffset: c_ulong, + BytesToRead: c_ulong, }} pub type PTHREAD_TEB_INFORMATION = *mut THREAD_TEB_INFORMATION; -STRUCT!{struct COUNTER_READING { +STRUCT! {struct COUNTER_READING { Type: HARDWARE_COUNTER_TYPE, - Index: ULONG, - Start: ULONG64, - Total: ULONG64, + Index: c_ulong, + Start: __uint64, + Total: __uint64, }} pub type PCOUNTER_READING = *mut COUNTER_READING; -STRUCT!{struct THREAD_PERFORMANCE_DATA { - Size: USHORT, - Version: USHORT, +STRUCT! {struct THREAD_PERFORMANCE_DATA { + Size: c_ushort, + Version: c_ushort, ProcessorNumber: PROCESSOR_NUMBER, - ContextSwitches: ULONG, - HwCountersCount: ULONG, - UpdateCount: ULONG64, - WaitReasonBitMap: ULONG64, - HardwareCounters: ULONG64, + ContextSwitches: c_ulong, + HwCountersCount: c_ulong, + UpdateCount: __uint64, + WaitReasonBitMap: __uint64, + HardwareCounters: __uint64, CycleTime: COUNTER_READING, - HwCounters: [COUNTER_READING; MAX_HW_COUNTERS], + HwCounters: [COUNTER_READING; MAX_HW_COUNTERS as usize], }} pub type PTHREAD_PERFORMANCE_DATA = *mut THREAD_PERFORMANCE_DATA; -STRUCT!{struct THREAD_PROFILING_INFORMATION { - HardwareCounters: ULONG64, - Flags: ULONG, - Enable: ULONG, +STRUCT! {struct THREAD_PROFILING_INFORMATION { + HardwareCounters: __uint64, + Flags: c_ulong, + Enable: c_ulong, PerformanceData: PTHREAD_PERFORMANCE_DATA, }} pub type PTHREAD_PROFILING_INFORMATION = *mut THREAD_PROFILING_INFORMATION; #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] -STRUCT!{#[repr(align(16))] struct RTL_UMS_CONTEXT { +STRUCT! {#[repr(align(16))] struct RTL_UMS_CONTEXT { Link: SINGLE_LIST_ENTRY, __padding: u64, Context: CONTEXT, - Teb: PVOID, - UserContext: PVOID, - ScheduledThread: ULONG, - Suspended: ULONG, - VolatileContext: ULONG, - Terminated: ULONG, - DebugActive: ULONG, - RunningOnSelfThread: ULONG, - DenyRunningOnSelfThread: ULONG, - Flags: LONG, - KernelUpdateLock: ULONG64, - PrimaryClientID: ULONG64, - ContextLock: ULONG64, + Teb: *mut c_void, + UserContext: *mut c_void, + ScheduledThread: c_ulong, + Suspended: c_ulong, + VolatileContext: c_ulong, + Terminated: c_ulong, + DebugActive: c_ulong, + RunningOnSelfThread: c_ulong, + DenyRunningOnSelfThread: c_ulong, + Flags: c_long, + KernelUpdateLock: __uint64, + PrimaryClientID: __uint64, + ContextLock: __uint64, PrimaryUmsContext: *mut RTL_UMS_CONTEXT, - SwitchCount: ULONG, - KernelYieldCount: ULONG, - MixedYieldCount: ULONG, - YieldCount: ULONG, + SwitchCount: c_ulong, + KernelYieldCount: c_ulong, + MixedYieldCount: c_ulong, + YieldCount: c_ulong, }} #[cfg(target_arch = "x86")] -STRUCT!{struct RTL_UMS_CONTEXT { +STRUCT! {struct RTL_UMS_CONTEXT { Link: SINGLE_LIST_ENTRY, Context: CONTEXT, - Teb: PVOID, - UserContext: PVOID, - ScheduledThread: ULONG, - Suspended: ULONG, - VolatileContext: ULONG, - Terminated: ULONG, - DebugActive: ULONG, - RunningOnSelfThread: ULONG, - DenyRunningOnSelfThread: ULONG, - Flags: LONG, - KernelUpdateLock: ULONG64, - PrimaryClientID: ULONG64, - ContextLock: ULONG64, + Teb: *mut c_void, + UserContext: *mut c_void, + ScheduledThread: c_ulong, + Suspended: c_ulong, + VolatileContext: c_ulong, + Terminated: c_ulong, + DebugActive: c_ulong, + RunningOnSelfThread: c_ulong, + DenyRunningOnSelfThread: c_ulong, + Flags: c_long, + KernelUpdateLock: __uint64, + PrimaryClientID: __uint64, + ContextLock: __uint64, PrimaryUmsContext: *mut RTL_UMS_CONTEXT, - SwitchCount: ULONG, - KernelYieldCount: ULONG, - MixedYieldCount: ULONG, - YieldCount: ULONG, + SwitchCount: c_ulong, + KernelYieldCount: c_ulong, + MixedYieldCount: c_ulong, + YieldCount: c_ulong, __padding: u32, }} pub type PRTL_UMS_CONTEXT = *mut RTL_UMS_CONTEXT; -ENUM!{enum THREAD_UMS_INFORMATION_COMMAND { +ENUM! {enum THREAD_UMS_INFORMATION_COMMAND { UmsInformationCommandInvalid = 0, UmsInformationCommandAttach = 1, UmsInformationCommandDetach = 2, UmsInformationCommandQuery = 3, }} -STRUCT!{struct RTL_UMS_COMPLETION_LIST { - ThreadListHead: PSINGLE_LIST_ENTRY, - CompletionEvent: PVOID, - CompletionFlags: ULONG, +STRUCT! {struct RTL_UMS_COMPLETION_LIST { + ThreadListHead: *mut SINGLE_LIST_ENTRY, + CompletionEvent: *mut c_void, + CompletionFlags: c_ulong, InternalListHead: SINGLE_LIST_ENTRY, }} pub type PRTL_UMS_COMPLETION_LIST = *mut RTL_UMS_COMPLETION_LIST; -STRUCT!{struct THREAD_UMS_INFORMATION { +STRUCT! {struct THREAD_UMS_INFORMATION { Command: THREAD_UMS_INFORMATION_COMMAND, CompletionList: PRTL_UMS_COMPLETION_LIST, UmsContext: PRTL_UMS_CONTEXT, - Flags: ULONG, + Flags: c_ulong, }} -BITFIELD!{THREAD_UMS_INFORMATION Flags: ULONG [ +BITFIELD! {THREAD_UMS_INFORMATION Flags: c_ulong [ IsUmsSchedulerThread set_IsUmsSchedulerThread[0..1], IsUmsWorkerThread set_IsUmsWorkerThread[1..2], SpareBits set_SpareBits[2..32], ]} pub type PTHREAD_UMS_INFORMATION = *mut THREAD_UMS_INFORMATION; -STRUCT!{struct THREAD_NAME_INFORMATION { +STRUCT! {struct THREAD_NAME_INFORMATION { ThreadName: UNICODE_STRING, }} pub type PTHREAD_NAME_INFORMATION = *mut THREAD_NAME_INFORMATION; -ENUM!{enum SUBSYSTEM_INFORMATION_TYPE { +ENUM! {enum SUBSYSTEM_INFORMATION_TYPE { SubsystemInformationTypeWin32 = 0, SubsystemInformationTypeWSL = 1, MaxSubsystemInformationType = 2, }} -ENUM!{enum THREAD_WORKLOAD_CLASS { +ENUM! {enum THREAD_WORKLOAD_CLASS { ThreadWorkloadClassDefault = 0, ThreadWorkloadClassGraphics = 1, MaxThreadWorkloadClass = 2, }} -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtCreateProcess( - ProcessHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + ProcessHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ParentProcess: HANDLE, - InheritObjectTable: BOOLEAN, + InheritObjectTable: c_uchar, SectionHandle: HANDLE, DebugPort: HANDLE, ExceptionPort: HANDLE, ) -> NTSTATUS; }} -pub const PROCESS_CREATE_FLAGS_BREAKAWAY: ULONG = 0x00000001; -pub const PROCESS_CREATE_FLAGS_NO_DEBUG_INHERIT: ULONG = 0x00000002; -pub const PROCESS_CREATE_FLAGS_INHERIT_HANDLES: ULONG = 0x00000004; -pub const PROCESS_CREATE_FLAGS_OVERRIDE_ADDRESS_SPACE: ULONG = 0x00000008; -pub const PROCESS_CREATE_FLAGS_LARGE_PAGES: ULONG = 0x00000010; -EXTERN!{extern "system" { +pub const PROCESS_CREATE_FLAGS_BREAKAWAY: c_ulong = 0x00000001; +pub const PROCESS_CREATE_FLAGS_NO_DEBUG_INHERIT: c_ulong = 0x00000002; +pub const PROCESS_CREATE_FLAGS_INHERIT_HANDLES: c_ulong = 0x00000004; +pub const PROCESS_CREATE_FLAGS_OVERRIDE_ADDRESS_SPACE: c_ulong = 0x00000008; +pub const PROCESS_CREATE_FLAGS_LARGE_PAGES: c_ulong = 0x00000010; +EXTERN! {extern "system" { fn NtCreateProcessEx( - ProcessHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + ProcessHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ParentProcess: HANDLE, - Flags: ULONG, + Flags: c_ulong, SectionHandle: HANDLE, DebugPort: HANDLE, ExceptionPort: HANDLE, - JobMemberLevel: ULONG, + JobMemberLevel: c_ulong, ) -> NTSTATUS; fn NtOpenProcess( - ProcessHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + ProcessHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ClientId: PCLIENT_ID, ) -> NTSTATUS; fn NtTerminateProcess( @@ -926,72 +970,75 @@ EXTERN!{extern "system" { ProcessHandle: HANDLE, ) -> NTSTATUS; }} -pub const NtCurrentProcess: HANDLE = -1isize as *mut c_void; +pub const NtCurrentProcess: HANDLE = -1; pub const ZwCurrentProcess: HANDLE = NtCurrentProcess; -pub const NtCurrentThread: HANDLE = -2isize as *mut c_void; +pub const NtCurrentThread: HANDLE = -2; pub const ZwCurrentThread: HANDLE = NtCurrentThread; -pub const NtCurrentSession: HANDLE = -3isize as *mut c_void; +pub const NtCurrentSession: HANDLE = -3; pub const ZwCurrentSession: HANDLE = NtCurrentSession; -#[inline] #[cfg(not(target_arch = "aarch64"))] +#[inline] +#[cfg(not(target_arch = "aarch64"))] pub unsafe fn NtCurrentPeb() -> PPEB { (*NtCurrentTeb()).ProcessEnvironmentBlock } -pub const NtCurrentProcessToken: HANDLE = -4isize as *mut c_void; -pub const NtCurrentThreadToken: HANDLE = -5isize as *mut c_void; -pub const NtCurrentEffectiveToken: HANDLE = -6isize as *mut c_void; -pub const NtCurrentSilo: HANDLE = -1isize as *mut c_void; -#[inline] #[cfg(not(target_arch = "aarch64"))] +pub const NtCurrentProcessToken: HANDLE = -4; +pub const NtCurrentThreadToken: HANDLE = -5; +pub const NtCurrentEffectiveToken: HANDLE = -6; +pub const NtCurrentSilo: HANDLE = -1; +#[inline] +#[cfg(not(target_arch = "aarch64"))] pub unsafe fn NtCurrentProcessId() -> HANDLE { (*NtCurrentTeb()).ClientId.UniqueProcess } -#[inline] #[cfg(not(target_arch = "aarch64"))] +#[inline] +#[cfg(not(target_arch = "aarch64"))] pub unsafe fn NtCurrentThreadId() -> HANDLE { (*NtCurrentTeb()).ClientId.UniqueThread } -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtQueryInformationProcess( ProcessHandle: HANDLE, ProcessInformationClass: PROCESSINFOCLASS, - ProcessInformation: PVOID, - ProcessInformationLength: ULONG, - ReturnLength: PULONG, + ProcessInformation: *mut c_void, + ProcessInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn NtGetNextProcess( ProcessHandle: HANDLE, - DesiredAccess: ACCESS_MASK, - HandleAttributes: ULONG, - Flags: ULONG, - NewProcessHandle: PHANDLE, + DesiredAccess: c_ulong, + HandleAttributes: c_ulong, + Flags: c_ulong, + NewProcessHandle: *mut HANDLE, ) -> NTSTATUS; fn NtGetNextThread( ProcessHandle: HANDLE, ThreadHandle: HANDLE, - DesiredAccess: ACCESS_MASK, - HandleAttributes: ULONG, - Flags: ULONG, - NewThreadHandle: PHANDLE, + DesiredAccess: c_ulong, + HandleAttributes: c_ulong, + Flags: c_ulong, + NewThreadHandle: *mut HANDLE, ) -> NTSTATUS; fn NtSetInformationProcess( ProcessHandle: HANDLE, ProcessInformationClass: PROCESSINFOCLASS, - ProcessInformation: PVOID, - ProcessInformationLength: ULONG, + ProcessInformation: *mut c_void, + ProcessInformationLength: c_ulong, ) -> NTSTATUS; fn NtQueryPortInformationProcess() -> NTSTATUS; fn NtCreateThread( - ThreadHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + ThreadHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ProcessHandle: HANDLE, ClientId: PCLIENT_ID, - ThreadContext: PCONTEXT, + ThreadContext: *mut CONTEXT, InitialTeb: PINITIAL_TEB, - CreateSuspended: BOOLEAN, + CreateSuspended: c_uchar, ) -> NTSTATUS; fn NtOpenThread( - ThreadHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + ThreadHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ClientId: PCLIENT_ID, ) -> NTSTATUS; fn NtTerminateThread( @@ -1000,96 +1047,96 @@ EXTERN!{extern "system" { ) -> NTSTATUS; fn NtSuspendThread( ThreadHandle: HANDLE, - PreviousSuspendCount: PULONG, + PreviousSuspendCount: *mut c_ulong, ) -> NTSTATUS; fn NtResumeThread( ThreadHandle: HANDLE, - PreviousSuspendCount: PULONG, + PreviousSuspendCount: *mut c_ulong, ) -> NTSTATUS; - fn NtGetCurrentProcessorNumber() -> ULONG; + fn NtGetCurrentProcessorNumber() -> c_ulong; fn NtGetContextThread( ThreadHandle: HANDLE, - ThreadContext: PCONTEXT, + ThreadContext: *mut CONTEXT, ) -> NTSTATUS; fn NtSetContextThread( ThreadHandle: HANDLE, - ThreadContext: PCONTEXT, + ThreadContext: *mut CONTEXT, ) -> NTSTATUS; fn NtQueryInformationThread( ThreadHandle: HANDLE, ThreadInformationClass: THREADINFOCLASS, - ThreadInformation: PVOID, - ThreadInformationLength: ULONG, - ReturnLength: PULONG, + ThreadInformation: *mut c_void, + ThreadInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn NtSetInformationThread( ThreadHandle: HANDLE, ThreadInformationClass: THREADINFOCLASS, - ThreadInformation: PVOID, - ThreadInformationLength: ULONG, + ThreadInformation: *mut c_void, + ThreadInformationLength: c_ulong, ) -> NTSTATUS; fn NtAlertThread( ThreadHandle: HANDLE, ) -> NTSTATUS; fn NtAlertResumeThread( ThreadHandle: HANDLE, - PreviousSuspendCount: PULONG, + PreviousSuspendCount: *mut c_ulong, ) -> NTSTATUS; fn NtTestAlert() -> NTSTATUS; fn NtImpersonateThread( ServerThreadHandle: HANDLE, ClientThreadHandle: HANDLE, - SecurityQos: PSECURITY_QUALITY_OF_SERVICE, + SecurityQos: *mut SECURITY_QUALITY_OF_SERVICE, ) -> NTSTATUS; fn NtRegisterThreadTerminatePort( PortHandle: HANDLE, ) -> NTSTATUS; fn NtSetLdtEntries( - Selector0: ULONG, - Entry0Low: ULONG, - Entry0Hi: ULONG, - Selector1: ULONG, - Entry1Low: ULONG, - Entry1Hi: ULONG, + Selector0: c_ulong, + Entry0Low: c_ulong, + Entry0Hi: c_ulong, + Selector1: c_ulong, + Entry1Low: c_ulong, + Entry1Hi: c_ulong, ) -> NTSTATUS; }} -FN!{cdecl PPS_APC_ROUTINE( - ApcArgument1: PVOID, - ApcArgument2: PVOID, - ApcArgument3: PVOID, +FN! {cdecl PPS_APC_ROUTINE( + ApcArgument1: *mut c_void, + ApcArgument2: *mut c_void, + ApcArgument3: *mut c_void, ) -> ()} -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtQueueApcThread( ThreadHandle: HANDLE, ApcRoutine: PPS_APC_ROUTINE, - ApcArgument1: PVOID, - ApcArgument2: PVOID, - ApcArgument3: PVOID, + ApcArgument1: *mut c_void, + ApcArgument2: *mut c_void, + ApcArgument3: *mut c_void, ) -> NTSTATUS; }} -pub const APC_FORCE_THREAD_SIGNAL: HANDLE = 1 as *mut c_void; -EXTERN!{extern "system" { +pub const APC_FORCE_THREAD_SIGNAL: HANDLE = 1; +EXTERN! {extern "system" { fn NtQueueApcThreadEx( ThreadHandle: HANDLE, UserApcReserveHandle: HANDLE, ApcRoutine: PPS_APC_ROUTINE, - ApcArgument1: PVOID, - ApcArgument2: PVOID, - ApcArgument3: PVOID, + ApcArgument1: *mut c_void, + ApcArgument2: *mut c_void, + ApcArgument3: *mut c_void, ) -> NTSTATUS; fn NtAlertThreadByThreadId( ThreadId: HANDLE, ) -> NTSTATUS; fn NtWaitForAlertByThreadId( - Address: PVOID, - Timeout: PLARGE_INTEGER, + Address: *mut c_void, + Timeout: *mut LARGE_INTEGER, ) -> NTSTATUS; }} pub const PS_ATTRIBUTE_NUMBER_MASK: u32 = 0x0000ffff; pub const PS_ATTRIBUTE_THREAD: u32 = 0x00010000; pub const PS_ATTRIBUTE_INPUT: u32 = 0x00020000; pub const PS_ATTRIBUTE_ADDITIVE: u32 = 0x00040000; -ENUM!{enum PS_ATTRIBUTE_NUM { +ENUM! {enum PS_ATTRIBUTE_NUM { PsAttributeParentProcess = 0, PsAttributeDebugPort = 1, PsAttributeToken = 2, @@ -1125,7 +1172,7 @@ pub const fn PsAttributeValue( Thread: bool, Input: bool, Additive: bool, -) -> ULONG_PTR { +) -> usize { Number &= PS_ATTRIBUTE_NUMBER_MASK; if Thread { Number |= PS_ATTRIBUTE_THREAD; @@ -1138,54 +1185,54 @@ pub const fn PsAttributeValue( } Number as _ } -pub const PS_ATTRIBUTE_PARENT_PROCESS: ULONG_PTR = 0x00060000; -pub const PS_ATTRIBUTE_DEBUG_PORT: ULONG_PTR = 0x00060001; -pub const PS_ATTRIBUTE_TOKEN: ULONG_PTR = 0x00060002; -pub const PS_ATTRIBUTE_CLIENT_ID: ULONG_PTR = 0x00010003; -pub const PS_ATTRIBUTE_TEB_ADDRESS: ULONG_PTR = 0x00010004; -pub const PS_ATTRIBUTE_IMAGE_NAME: ULONG_PTR = 0x00020005; -pub const PS_ATTRIBUTE_IMAGE_INFO: ULONG_PTR = 0x00000006; -pub const PS_ATTRIBUTE_MEMORY_RESERVE: ULONG_PTR = 0x00020007; -pub const PS_ATTRIBUTE_PRIORITY_CLASS: ULONG_PTR = 0x00020008; -pub const PS_ATTRIBUTE_ERROR_MODE: ULONG_PTR = 0x00020009; -pub const PS_ATTRIBUTE_STD_HANDLE_INFO: ULONG_PTR = 0x0002000a; -pub const PS_ATTRIBUTE_HANDLE_LIST: ULONG_PTR = 0x0002000b; -pub const PS_ATTRIBUTE_GROUP_AFFINITY: ULONG_PTR = 0x0003000c; -pub const PS_ATTRIBUTE_PREFERRED_NODE: ULONG_PTR = 0x0002000d; -pub const PS_ATTRIBUTE_IDEAL_PROCESSOR: ULONG_PTR = 0x0003000e; -pub const PS_ATTRIBUTE_UMS_THREAD: ULONG_PTR = 0x0003000f; -pub const PS_ATTRIBUTE_MITIGATION_OPTIONS: ULONG_PTR = 0x00060010; -pub const PS_ATTRIBUTE_PROTECTION_LEVEL: ULONG_PTR = 0x00060011; -pub const PS_ATTRIBUTE_SECURE_PROCESS: ULONG_PTR = 0x00020012; -pub const PS_ATTRIBUTE_JOB_LIST: ULONG_PTR = 0x00020013; -pub const PS_ATTRIBUTE_CHILD_PROCESS_POLICY: ULONG_PTR = 0x00020014; -pub const PS_ATTRIBUTE_ALL_APPLICATION_PACKAGES_POLICY: ULONG_PTR = 0x00020015; -pub const PS_ATTRIBUTE_WIN32K_FILTER: ULONG_PTR = 0x00020016; -pub const PS_ATTRIBUTE_SAFE_OPEN_PROMPT_ORIGIN_CLAIM: ULONG_PTR = 0x00020017; -pub const PS_ATTRIBUTE_BNO_ISOLATION: ULONG_PTR = 0x00020018; -pub const PS_ATTRIBUTE_DESKTOP_APP_POLICY: ULONG_PTR = 0x00020019; -UNION!{union PS_ATTRIBUTE_u { - Value: ULONG_PTR, - ValuePtr: PVOID, -}} -STRUCT!{struct PS_ATTRIBUTE { - Attribute: ULONG_PTR, - Size: SIZE_T, +pub const PS_ATTRIBUTE_PARENT_PROCESS: usize = 0x00060000; +pub const PS_ATTRIBUTE_DEBUG_PORT: usize = 0x00060001; +pub const PS_ATTRIBUTE_TOKEN: usize = 0x00060002; +pub const PS_ATTRIBUTE_CLIENT_ID: usize = 0x00010003; +pub const PS_ATTRIBUTE_TEB_ADDRESS: usize = 0x00010004; +pub const PS_ATTRIBUTE_IMAGE_NAME: usize = 0x00020005; +pub const PS_ATTRIBUTE_IMAGE_INFO: usize = 0x00000006; +pub const PS_ATTRIBUTE_MEMORY_RESERVE: usize = 0x00020007; +pub const PS_ATTRIBUTE_PRIORITY_CLASS: usize = 0x00020008; +pub const PS_ATTRIBUTE_ERROR_MODE: usize = 0x00020009; +pub const PS_ATTRIBUTE_STD_HANDLE_INFO: usize = 0x0002000a; +pub const PS_ATTRIBUTE_HANDLE_LIST: usize = 0x0002000b; +pub const PS_ATTRIBUTE_GROUP_AFFINITY: usize = 0x0003000c; +pub const PS_ATTRIBUTE_PREFERRED_NODE: usize = 0x0002000d; +pub const PS_ATTRIBUTE_IDEAL_PROCESSOR: usize = 0x0003000e; +pub const PS_ATTRIBUTE_UMS_THREAD: usize = 0x0003000f; +pub const PS_ATTRIBUTE_MITIGATION_OPTIONS: usize = 0x00060010; +pub const PS_ATTRIBUTE_PROTECTION_LEVEL: usize = 0x00060011; +pub const PS_ATTRIBUTE_SECURE_PROCESS: usize = 0x00020012; +pub const PS_ATTRIBUTE_JOB_LIST: usize = 0x00020013; +pub const PS_ATTRIBUTE_CHILD_PROCESS_POLICY: usize = 0x00020014; +pub const PS_ATTRIBUTE_ALL_APPLICATION_PACKAGES_POLICY: usize = 0x00020015; +pub const PS_ATTRIBUTE_WIN32K_FILTER: usize = 0x00020016; +pub const PS_ATTRIBUTE_SAFE_OPEN_PROMPT_ORIGIN_CLAIM: usize = 0x00020017; +pub const PS_ATTRIBUTE_BNO_ISOLATION: usize = 0x00020018; +pub const PS_ATTRIBUTE_DESKTOP_APP_POLICY: usize = 0x00020019; +UNION! {union PS_ATTRIBUTE_u { + Value: usize, + ValuePtr: *mut c_void, +}} +STRUCT! {struct PS_ATTRIBUTE { + Attribute: usize, + Size: usize, u: PS_ATTRIBUTE_u, - ReturnLength: PSIZE_T, + ReturnLength: *mut usize, }} pub type PPS_ATTRIBUTE = *mut PS_ATTRIBUTE; -STRUCT!{struct PS_ATTRIBUTE_LIST { - TotalLength: SIZE_T, +STRUCT! {struct PS_ATTRIBUTE_LIST { + TotalLength: usize, Attributes: [PS_ATTRIBUTE; 1], }} pub type PPS_ATTRIBUTE_LIST = *mut PS_ATTRIBUTE_LIST; -STRUCT!{struct PS_MEMORY_RESERVE { - ReserveAddress: PVOID, - ReserveSize: SIZE_T, +STRUCT! {struct PS_MEMORY_RESERVE { + ReserveAddress: *mut c_void, + ReserveSize: usize, }} pub type PPS_MEMORY_RESERVE = *mut PS_MEMORY_RESERVE; -ENUM!{enum PS_STD_HANDLE_STATE { +ENUM! {enum PS_STD_HANDLE_STATE { PsNeverDuplicate = 0, PsRequestDuplicate = 1, PsAlwaysDuplicate = 2, @@ -1194,23 +1241,23 @@ ENUM!{enum PS_STD_HANDLE_STATE { pub const PS_STD_INPUT_HANDLE: u32 = 0x1; pub const PS_STD_OUTPUT_HANDLE: u32 = 0x2; pub const PS_STD_ERROR_HANDLE: u32 = 0x4; -STRUCT!{struct PS_STD_HANDLE_INFO { - Flags: ULONG, - StdHandleSubsystemType: ULONG, +STRUCT! {struct PS_STD_HANDLE_INFO { + Flags: c_ulong, + StdHandleSubsystemType: c_ulong, }} pub type PPS_STD_HANDLE_INFO = *mut PS_STD_HANDLE_INFO; -BITFIELD!{PS_STD_HANDLE_INFO Flags: ULONG [ +BITFIELD! {PS_STD_HANDLE_INFO Flags: c_ulong [ StdHandleState set_StdHandleState[0..2], PseudoHandleMask set_PseudoHandleMask[2..5], ]} -STRUCT!{struct PS_BNO_ISOLATION_PARAMETERS { +STRUCT! {struct PS_BNO_ISOLATION_PARAMETERS { IsolationPrefix: UNICODE_STRING, - HandleCount: ULONG, - Handles: *mut PVOID, - IsolationEnabled: BOOLEAN, + HandleCount: c_ulong, + Handles: *mut *mut c_void, + IsolationEnabled: c_uchar, }} pub type PPS_BNO_ISOLATION_PARAMETERS = *mut PS_BNO_ISOLATION_PARAMETERS; -ENUM!{enum PS_MITIGATION_OPTION { +ENUM! {enum PS_MITIGATION_OPTION { PS_MITIGATION_OPTION_NX = 0, PS_MITIGATION_OPTION_SEHOP = 1, PS_MITIGATION_OPTION_FORCE_RELOCATE_IMAGES = 2, @@ -1244,7 +1291,7 @@ ENUM!{enum PS_MITIGATION_OPTION { PS_MITIGATION_OPTION_ALLOW_DOWNGRADE_DYNAMIC_CODE_POLICY = 30, PS_MITIGATION_OPTION_CET_SHADOW_STACKS = 31, }} -ENUM!{enum PS_CREATE_STATE { +ENUM! {enum PS_CREATE_STATE { PsCreateInitialState = 0, PsCreateFailOnFileOpen = 1, PsCreateFailOnSectionCreate = 2, @@ -1254,11 +1301,11 @@ ENUM!{enum PS_CREATE_STATE { PsCreateSuccess = 6, PsCreateMaximumStates = 7, }} -STRUCT!{struct PS_CREATE_INFO_u_InitState { - InitFlags: ULONG, - AdditionalFileAccess: ACCESS_MASK, +STRUCT! {struct PS_CREATE_INFO_u_InitState { + InitFlags: c_ulong, + AdditionalFileAccess: c_ulong, }} -BITFIELD!{PS_CREATE_INFO_u_InitState InitFlags: ULONG [ +BITFIELD! {PS_CREATE_INFO_u_InitState InitFlags: c_ulong [ WriteOutputOnExit set_WriteOutputOnExit[0..1], DetectManifest set_DetectManifest[1..2], IFEOSkipDebugger set_IFEOSkipDebugger[2..3], @@ -1267,19 +1314,19 @@ BITFIELD!{PS_CREATE_INFO_u_InitState InitFlags: ULONG [ SpareBits2 set_SpareBits2[8..16], ProhibitedImageCharacteristics set_ProhibitedImageCharacteristics[16..32], ]} -STRUCT!{struct PS_CREATE_INFO_u_SuccessState { - OutputFlags: ULONG, +STRUCT! {struct PS_CREATE_INFO_u_SuccessState { + OutputFlags: c_ulong, FileHandle: HANDLE, SectionHandle: HANDLE, - UserProcessParametersNative: ULONGLONG, - UserProcessParametersWow64: ULONG, - CurrentParameterFlags: ULONG, - PebAddressNative: ULONGLONG, - PebAddressWow64: ULONG, - ManifestAddress: ULONGLONG, - ManifestSize: ULONG, -}} -BITFIELD!{PS_CREATE_INFO_u_SuccessState OutputFlags: ULONG [ + UserProcessParametersNative: __uint64, + UserProcessParametersWow64: c_ulong, + CurrentParameterFlags: c_ulong, + PebAddressNative: __uint64, + PebAddressWow64: c_ulong, + ManifestAddress: __uint64, + ManifestSize: c_ulong, +}} +BITFIELD! {PS_CREATE_INFO_u_SuccessState OutputFlags: c_ulong [ ProtectedProcess set_ProtectedProcess[0..1], AddressSpaceOverride set_AddressSpaceOverride[1..2], DevOverrideEnabled set_DevOverrideEnabled[2..3], @@ -1289,149 +1336,153 @@ BITFIELD!{PS_CREATE_INFO_u_SuccessState OutputFlags: ULONG [ SpareBits2 set_SpareBits2[8..16], SpareBits3 set_SpareBits3[16..32], ]} -UNION!{union PS_CREATE_INFO_u { +UNION! {union PS_CREATE_INFO_u { InitState: PS_CREATE_INFO_u_InitState, FileHandle: HANDLE, - DllCharacteristics: USHORT, + DllCharacteristics: c_ushort, IFEOKey: HANDLE, SuccessState: PS_CREATE_INFO_u_SuccessState, }} -STRUCT!{struct PS_CREATE_INFO { - Size: SIZE_T, +STRUCT! {struct PS_CREATE_INFO { + Size: usize, State: PS_CREATE_STATE, u: PS_CREATE_INFO_u, }} pub type PPS_CREATE_INFO = *mut PS_CREATE_INFO; -pub const PROCESS_CREATE_FLAGS_LARGE_PAGE_SYSTEM_DLL: ULONG = 0x00000020; -pub const PROCESS_CREATE_FLAGS_PROTECTED_PROCESS: ULONG = 0x00000040; -pub const PROCESS_CREATE_FLAGS_CREATE_SESSION: ULONG = 0x00000080; -pub const PROCESS_CREATE_FLAGS_INHERIT_FROM_PARENT: ULONG = 0x00000100; -pub const PROCESS_CREATE_FLAGS_SUSPENDED: ULONG = 0x00000200; -pub const PROCESS_CREATE_FLAGS_EXTENDED_UNKNOWN: ULONG = 0x00000400; -EXTERN!{extern "system" { +pub const PROCESS_CREATE_FLAGS_LARGE_PAGE_SYSTEM_DLL: c_ulong = 0x00000020; +pub const PROCESS_CREATE_FLAGS_PROTECTED_PROCESS: c_ulong = 0x00000040; +pub const PROCESS_CREATE_FLAGS_CREATE_SESSION: c_ulong = 0x00000080; +pub const PROCESS_CREATE_FLAGS_INHERIT_FROM_PARENT: c_ulong = 0x00000100; +pub const PROCESS_CREATE_FLAGS_SUSPENDED: c_ulong = 0x00000200; +pub const PROCESS_CREATE_FLAGS_EXTENDED_UNKNOWN: c_ulong = 0x00000400; +EXTERN! {extern "system" { fn NtCreateUserProcess( - ProcessHandle: PHANDLE, - ThreadHandle: PHANDLE, - ProcessDesiredAccess: ACCESS_MASK, - ThreadDesiredAccess: ACCESS_MASK, - ProcessObjectAttributes: POBJECT_ATTRIBUTES, - ThreadObjectAttributes: POBJECT_ATTRIBUTES, - ProcessFlags: ULONG, - ThreadFlags: ULONG, - ProcessParameters: PVOID, + ProcessHandle: *mut HANDLE, + ThreadHandle: *mut HANDLE, + ProcessDesiredAccess: c_ulong, + ThreadDesiredAccess: c_ulong, + ProcessObjectAttributes: *mut OBJECT_ATTRIBUTES, + ThreadObjectAttributes: *mut OBJECT_ATTRIBUTES, + ProcessFlags: c_ulong, + ThreadFlags: c_ulong, + ProcessParameters: *mut c_void, CreateInfo: PPS_CREATE_INFO, AttributeList: PPS_ATTRIBUTE_LIST, ) -> NTSTATUS; }} -pub const THREAD_CREATE_FLAGS_CREATE_SUSPENDED: ULONG = 0x00000001; -pub const THREAD_CREATE_FLAGS_SKIP_THREAD_ATTACH: ULONG = 0x00000002; -pub const THREAD_CREATE_FLAGS_HIDE_FROM_DEBUGGER: ULONG = 0x00000004; -pub const THREAD_CREATE_FLAGS_HAS_SECURITY_DESCRIPTOR: ULONG = 0x00000010; -pub const THREAD_CREATE_FLAGS_ACCESS_CHECK_IN_TARGET: ULONG = 0x00000020; -pub const THREAD_CREATE_FLAGS_INITIAL_THREAD: ULONG = 0x00000080; -EXTERN!{extern "system" { +pub const THREAD_CREATE_FLAGS_CREATE_SUSPENDED: c_ulong = 0x00000001; +pub const THREAD_CREATE_FLAGS_SKIP_THREAD_ATTACH: c_ulong = 0x00000002; +pub const THREAD_CREATE_FLAGS_HIDE_FROM_DEBUGGER: c_ulong = 0x00000004; +pub const THREAD_CREATE_FLAGS_HAS_SECURITY_DESCRIPTOR: c_ulong = 0x00000010; +pub const THREAD_CREATE_FLAGS_ACCESS_CHECK_IN_TARGET: c_ulong = 0x00000020; +pub const THREAD_CREATE_FLAGS_INITIAL_THREAD: c_ulong = 0x00000080; +EXTERN! {extern "system" { fn NtCreateThreadEx( - ThreadHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + ThreadHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ProcessHandle: HANDLE, - StartRoutine: PVOID, - Argument: PVOID, - CreateFlags: ULONG, - ZeroBits: SIZE_T, - StackSize: SIZE_T, - MaximumStackSize: SIZE_T, + StartRoutine: *mut c_void, + Argument: *mut c_void, + CreateFlags: c_ulong, + ZeroBits: usize, + StackSize: usize, + MaximumStackSize: usize, AttributeList: PPS_ATTRIBUTE_LIST, ) -> NTSTATUS; }} -STRUCT!{struct JOBOBJECT_EXTENDED_ACCOUNTING_INFORMATION { +STRUCT! {struct JOBOBJECT_EXTENDED_ACCOUNTING_INFORMATION { BasicInfo: JOBOBJECT_BASIC_ACCOUNTING_INFORMATION, IoInfo: IO_COUNTERS, DiskIoInfo: PROCESS_DISK_COUNTERS, - ContextSwitches: ULONG64, + ContextSwitches: __uint64, TotalCycleTime: LARGE_INTEGER, - ReadyTime: ULONG64, + ReadyTime: __uint64, EnergyValues: PROCESS_ENERGY_VALUES, }} pub type PJOBOBJECT_EXTENDED_ACCOUNTING_INFORMATION = *mut JOBOBJECT_EXTENDED_ACCOUNTING_INFORMATION; -STRUCT!{struct JOBOBJECT_WAKE_INFORMATION { +STRUCT! {struct JOBOBJECT_WAKE_INFORMATION { NotificationChannel: HANDLE, - WakeCounters: [ULONG64; 7], + WakeCounters: [__uint64; 7], }} pub type PJOBOBJECT_WAKE_INFORMATION = *mut JOBOBJECT_WAKE_INFORMATION; -STRUCT!{struct JOBOBJECT_WAKE_INFORMATION_V1 { +STRUCT! {struct JOBOBJECT_WAKE_INFORMATION_V1 { NotificationChannel: HANDLE, - WakeCounters: [ULONG64; 4], + WakeCounters: [__uint64; 4], }} pub type PJOBOBJECT_WAKE_INFORMATION_V1 = *mut JOBOBJECT_WAKE_INFORMATION_V1; -STRUCT!{struct JOBOBJECT_INTERFERENCE_INFORMATION { - Count: ULONG64, +STRUCT! {struct JOBOBJECT_INTERFERENCE_INFORMATION { + Count: __uint64, }} -pub type PJOBOBJECT_INTERFERENCE_INFORMATION = *mut JOBOBJECT_INTERFERENCE_INFORMATION; -STRUCT!{struct JOBOBJECT_WAKE_FILTER { - HighEdgeFilter: ULONG, - LowEdgeFilter: ULONG, +pub type PJOBOBJECT_INTERFERENCE_INFORMATION = + *mut JOBOBJECT_INTERFERENCE_INFORMATION; +STRUCT! {struct JOBOBJECT_WAKE_FILTER { + HighEdgeFilter: c_ulong, + LowEdgeFilter: c_ulong, }} pub type PJOBOBJECT_WAKE_FILTER = *mut JOBOBJECT_WAKE_FILTER; -STRUCT!{struct JOBOBJECT_FREEZE_INFORMATION { - Flags: ULONG, - Freeze: BOOLEAN, - Swap: BOOLEAN, - Reserved0: [UCHAR; 2], +STRUCT! {struct JOBOBJECT_FREEZE_INFORMATION { + Flags: c_ulong, + Freeze: c_uchar, + Swap: c_uchar, + Reserved0: [c_uchar; 2], WakeFilter: JOBOBJECT_WAKE_FILTER, }} pub type PJOBOBJECT_FREEZE_INFORMATION = *mut JOBOBJECT_FREEZE_INFORMATION; -BITFIELD!{JOBOBJECT_FREEZE_INFORMATION Flags: ULONG [ +BITFIELD! {JOBOBJECT_FREEZE_INFORMATION Flags: c_ulong [ FreezeOperation set_FreezeOperation[0..1], FilterOperation set_FilterOperation[1..2], SwapOperation set_SwapOperation[2..3], Reserved set_Reserved[3..32], ]} -STRUCT!{struct JOBOBJECT_MEMORY_USAGE_INFORMATION { - JobMemory: ULONG64, - PeakJobMemoryUsed: ULONG64, +STRUCT! {struct JOBOBJECT_MEMORY_USAGE_INFORMATION { + JobMemory: __uint64, + PeakJobMemoryUsed: __uint64, }} -pub type PJOBOBJECT_MEMORY_USAGE_INFORMATION = *mut JOBOBJECT_MEMORY_USAGE_INFORMATION; -STRUCT!{struct JOBOBJECT_MEMORY_USAGE_INFORMATION_V2 { +pub type PJOBOBJECT_MEMORY_USAGE_INFORMATION = + *mut JOBOBJECT_MEMORY_USAGE_INFORMATION; +STRUCT! {struct JOBOBJECT_MEMORY_USAGE_INFORMATION_V2 { BasicInfo: JOBOBJECT_MEMORY_USAGE_INFORMATION, - JobSharedMemory: ULONG64, - Reserved: [ULONG64; 2], -}} -pub type PJOBOBJECT_MEMORY_USAGE_INFORMATION_V2 = *mut JOBOBJECT_MEMORY_USAGE_INFORMATION_V2; -STRUCT!{struct SILO_USER_SHARED_DATA { - ServiceSessionId: ULONG64, - ActiveConsoleId: ULONG, - ConsoleSessionForegroundProcessId: LONGLONG, + JobSharedMemory: __uint64, + Reserved: [__uint64; 2], +}} +pub type PJOBOBJECT_MEMORY_USAGE_INFORMATION_V2 = + *mut JOBOBJECT_MEMORY_USAGE_INFORMATION_V2; +STRUCT! {struct SILO_USER_SHARED_DATA { + ServiceSessionId: __uint64, + ActiveConsoleId: c_ulong, + ConsoleSessionForegroundProcessId: __int64, NtProductType: NT_PRODUCT_TYPE, - SuiteMask: ULONG, - SharedUserSessionId: ULONG, - IsMultiSessionSku: BOOLEAN, - NtSystemRoot: [WCHAR; 260], - UserModeGlobalLogger: [USHORT; 16], + SuiteMask: c_ulong, + SharedUserSessionId: c_ulong, + IsMultiSessionSku: c_uchar, + NtSystemRoot: [wchar_t; 260], + UserModeGlobalLogger: [c_ushort; 16], }} pub type PSILO_USER_SHARED_DATA = *mut SILO_USER_SHARED_DATA; -STRUCT!{struct SILOOBJECT_ROOT_DIRECTORY { - ControlFlags: ULONG, +STRUCT! {struct SILOOBJECT_ROOT_DIRECTORY { + ControlFlags: c_ulong, Path: UNICODE_STRING, }} pub type PSILOOBJECT_ROOT_DIRECTORY = *mut SILOOBJECT_ROOT_DIRECTORY; -STRUCT!{struct JOBOBJECT_ENERGY_TRACKING_STATE { - Value: ULONG64, - UpdateMask: ULONG, - DesiredState: ULONG, -}} -pub type PJOBOBJECT_ENERGY_TRACKING_STATE = *mut JOBOBJECT_ENERGY_TRACKING_STATE; -EXTERN!{extern "system" { +STRUCT! {struct JOBOBJECT_ENERGY_TRACKING_STATE { + Value: __uint64, + UpdateMask: c_ulong, + DesiredState: c_ulong, +}} +pub type PJOBOBJECT_ENERGY_TRACKING_STATE = + *mut JOBOBJECT_ENERGY_TRACKING_STATE; +EXTERN! {extern "system" { fn NtCreateJobObject( - JobHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + JobHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn NtOpenJobObject( - JobHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + JobHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn NtAssignProcessToJobObject( JobHandle: HANDLE, @@ -1448,32 +1499,32 @@ EXTERN!{extern "system" { fn NtQueryInformationJobObject( JobHandle: HANDLE, JobObjectInformationClass: JOBOBJECTINFOCLASS, - JobObjectInformation: PVOID, - JobObjectInformationLength: ULONG, - ReturnLength: PULONG, + JobObjectInformation: *mut c_void, + JobObjectInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn NtSetInformationJobObject( JobHandle: HANDLE, JobObjectInformationClass: JOBOBJECTINFOCLASS, - JobObjectInformation: PVOID, - JobObjectInformationLength: ULONG, + JobObjectInformation: *mut c_void, + JobObjectInformationLength: c_ulong, ) -> NTSTATUS; fn NtCreateJobSet( - NumJob: ULONG, - UserJobSet: PJOB_SET_ARRAY, - Flags: ULONG, + NumJob: c_ulong, + UserJobSet: *mut JOB_SET_ARRAY, + Flags: c_ulong, ) -> NTSTATUS; fn NtRevertContainerImpersonation() -> NTSTATUS; }} -ENUM!{enum MEMORY_RESERVE_TYPE { +ENUM! {enum MEMORY_RESERVE_TYPE { MemoryReserveUserApc = 0, MemoryReserveIoCompletion = 1, MemoryReserveTypeMax = 2, }} -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtAllocateReserveObject( - MemoryReserveHandle: PHANDLE, - ObjectAttributes: POBJECT_ATTRIBUTES, + MemoryReserveHandle: *mut HANDLE, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, Type: MEMORY_RESERVE_TYPE, ) -> NTSTATUS; }} diff --git a/src/ntregapi.rs b/src/ntregapi.rs index ccd79b2..7228363 100644 --- a/src/ntregapi.rs +++ b/src/ntregapi.rs @@ -1,16 +1,21 @@ -use crate::ntioapi::{PIO_APC_ROUTINE, PIO_STATUS_BLOCK}; -use winapi::shared::ntdef::{ - BOOLEAN, HANDLE, LARGE_INTEGER, NTSTATUS, OBJECT_ATTRIBUTES, PHANDLE, POBJECT_ATTRIBUTES, - PULONG, PUNICODE_STRING, PVOID, UCHAR, ULONG, UNICODE_STRING, USHORT, WCHAR, +use windows_sys::Win32::{ + Foundation::{HANDLE, NTSTATUS, UNICODE_STRING}, + System::WindowsProgramming::OBJECT_ATTRIBUTES, }; -use winapi::um::winnt::ACCESS_MASK; -pub const REG_INIT_BOOT_SM: USHORT = 0x0000; -pub const REG_INIT_BOOT_SETUP: USHORT = 0x0001; -pub const REG_INIT_BOOT_ACCEPTED_BASE: USHORT = 0x0002; -pub const REG_INIT_BOOT_ACCEPTED_MAX: USHORT = REG_INIT_BOOT_ACCEPTED_BASE; + +use crate::{ + ctypes::{c_uchar, c_ulong, c_ushort, c_void, wchar_t}, + ntioapi::{PIO_APC_ROUTINE, PIO_STATUS_BLOCK}, + windows_local::shared::ntdef::LARGE_INTEGER, +}; + +pub const REG_INIT_BOOT_SM: c_ushort = 0x0000; +pub const REG_INIT_BOOT_SETUP: c_ushort = 0x0001; +pub const REG_INIT_BOOT_ACCEPTED_BASE: c_ushort = 0x0002; +pub const REG_INIT_BOOT_ACCEPTED_MAX: c_ushort = REG_INIT_BOOT_ACCEPTED_BASE; pub const REG_MAX_KEY_VALUE_NAME_LENGTH: u32 = 32767; pub const REG_MAX_KEY_NAME_LENGTH: u32 = 512; -ENUM!{enum KEY_INFORMATION_CLASS { +ENUM! {enum KEY_INFORMATION_CLASS { KeyBasicInformation = 0, KeyNodeInformation = 1, KeyFullInformation = 2, @@ -23,61 +28,61 @@ ENUM!{enum KEY_INFORMATION_CLASS { KeyLayerInformation = 9, MaxKeyInfoClass = 10, }} -STRUCT!{struct KEY_BASIC_INFORMATION { +STRUCT! {struct KEY_BASIC_INFORMATION { LastWriteTime: LARGE_INTEGER, - TitleIndex: ULONG, - NameLength: ULONG, - Name: [WCHAR; 1], + TitleIndex: c_ulong, + NameLength: c_ulong, + Name: [wchar_t; 1], }} pub type PKEY_BASIC_INFORMATION = *mut KEY_BASIC_INFORMATION; -STRUCT!{struct KEY_NODE_INFORMATION { +STRUCT! {struct KEY_NODE_INFORMATION { LastWriteTime: LARGE_INTEGER, - TitleIndex: ULONG, - ClassOffset: ULONG, - ClassLength: ULONG, - NameLength: ULONG, - Name: [WCHAR; 1], + TitleIndex: c_ulong, + ClassOffset: c_ulong, + ClassLength: c_ulong, + NameLength: c_ulong, + Name: [wchar_t; 1], }} pub type PKEY_NODE_INFORMATION = *mut KEY_NODE_INFORMATION; -STRUCT!{struct KEY_FULL_INFORMATION { +STRUCT! {struct KEY_FULL_INFORMATION { LastWriteTime: LARGE_INTEGER, - TitleIndex: ULONG, - ClassOffset: ULONG, - ClassLength: ULONG, - SubKeys: ULONG, - MaxNameLen: ULONG, - MaxClassLen: ULONG, - Values: ULONG, - MaxValueNameLen: ULONG, - MaxValueDataLen: ULONG, - Class: [WCHAR; 1], + TitleIndex: c_ulong, + ClassOffset: c_ulong, + ClassLength: c_ulong, + SubKeys: c_ulong, + MaxNameLen: c_ulong, + MaxClassLen: c_ulong, + Values: c_ulong, + MaxValueNameLen: c_ulong, + MaxValueDataLen: c_ulong, + Class: [wchar_t; 1], }} pub type PKEY_FULL_INFORMATION = *mut KEY_FULL_INFORMATION; -STRUCT!{struct KEY_NAME_INFORMATION { - NameLength: ULONG, - Name: [WCHAR; 1], +STRUCT! {struct KEY_NAME_INFORMATION { + NameLength: c_ulong, + Name: [wchar_t; 1], }} pub type PKEY_NAME_INFORMATION = *mut KEY_NAME_INFORMATION; -STRUCT!{struct KEY_CACHED_INFORMATION { +STRUCT! {struct KEY_CACHED_INFORMATION { LastWriteTime: LARGE_INTEGER, - TitleIndex: ULONG, - SubKeys: ULONG, - MaxNameLen: ULONG, - Values: ULONG, - MaxValueNameLen: ULONG, - MaxValueDataLen: ULONG, - NameLength: ULONG, - Name: [WCHAR; 1], + TitleIndex: c_ulong, + SubKeys: c_ulong, + MaxNameLen: c_ulong, + Values: c_ulong, + MaxValueNameLen: c_ulong, + MaxValueDataLen: c_ulong, + NameLength: c_ulong, + Name: [wchar_t; 1], }} pub type PKEY_CACHED_INFORMATION = *mut KEY_CACHED_INFORMATION; -STRUCT!{struct KEY_FLAGS_INFORMATION { - UserFlags: ULONG, +STRUCT! {struct KEY_FLAGS_INFORMATION { + UserFlags: c_ulong, }} pub type PKEY_FLAGS_INFORMATION = *mut KEY_FLAGS_INFORMATION; -STRUCT!{struct KEY_VIRTUALIZATION_INFORMATION { - Bitfields: ULONG, +STRUCT! {struct KEY_VIRTUALIZATION_INFORMATION { + Bitfields: c_ulong, }} -BITFIELD!{KEY_VIRTUALIZATION_INFORMATION Bitfields: ULONG [ +BITFIELD! {KEY_VIRTUALIZATION_INFORMATION Bitfields: c_ulong [ VirtualizationCandidate set_VirtualizationCandidate[0..1], VirtualizationEnabled set_VirtualizationEnabled[1..2], VirtualTarget set_VirtualTarget[2..3], @@ -86,23 +91,23 @@ BITFIELD!{KEY_VIRTUALIZATION_INFORMATION Bitfields: ULONG [ Reserved set_Reserved[5..32], ]} pub type PKEY_VIRTUALIZATION_INFORMATION = *mut KEY_VIRTUALIZATION_INFORMATION; -STRUCT!{struct KEY_TRUST_INFORMATION { - Bitfields: ULONG, +STRUCT! {struct KEY_TRUST_INFORMATION { + Bitfields: c_ulong, }} -BITFIELD!{KEY_TRUST_INFORMATION Bitfields: ULONG [ +BITFIELD! {KEY_TRUST_INFORMATION Bitfields: c_ulong [ TrustedKey set_TrustedKey[0..1], Reserved set_Reserved[1..32], ]} pub type PKEY_TRUST_INFORMATION = *mut KEY_TRUST_INFORMATION; -STRUCT!{struct KEY_LAYER_INFORMATION { - IsTombstone: ULONG, - IsSupersedeLocal: ULONG, - IsSupersedeTree: ULONG, - ClassIsInherited: ULONG, - Reserved: ULONG, +STRUCT! {struct KEY_LAYER_INFORMATION { + IsTombstone: c_ulong, + IsSupersedeLocal: c_ulong, + IsSupersedeTree: c_ulong, + ClassIsInherited: c_ulong, + Reserved: c_ulong, }} pub type PKEY_LAYER_INFORMATION = *mut KEY_LAYER_INFORMATION; -ENUM!{enum KEY_SET_INFORMATION_CLASS { +ENUM! {enum KEY_SET_INFORMATION_CLASS { KeyWriteTimeInformation = 0, KeyWow64FlagsInformation = 1, KeyControlFlagsInformation = 2, @@ -112,22 +117,22 @@ ENUM!{enum KEY_SET_INFORMATION_CLASS { KeySetLayerInformation = 6, MaxKeySetInfoClass = 7, }} -STRUCT!{struct KEY_WRITE_TIME_INFORMATION { +STRUCT! {struct KEY_WRITE_TIME_INFORMATION { LastWriteTime: LARGE_INTEGER, }} pub type PKEY_WRITE_TIME_INFORMATION = *mut KEY_WRITE_TIME_INFORMATION; -STRUCT!{struct KEY_WOW64_FLAGS_INFORMATION { - UserFlags: ULONG, +STRUCT! {struct KEY_WOW64_FLAGS_INFORMATION { + UserFlags: c_ulong, }} pub type PKEY_WOW64_FLAGS_INFORMATION = *mut KEY_WOW64_FLAGS_INFORMATION; -STRUCT!{struct KEY_HANDLE_TAGS_INFORMATION { - HandleTags: ULONG, +STRUCT! {struct KEY_HANDLE_TAGS_INFORMATION { + HandleTags: c_ulong, }} pub type PKEY_HANDLE_TAGS_INFORMATION = *mut KEY_HANDLE_TAGS_INFORMATION; -STRUCT!{struct KEY_SET_LAYER_INFORMATION { - Bitfields: ULONG, +STRUCT! {struct KEY_SET_LAYER_INFORMATION { + Bitfields: c_ulong, }} -BITFIELD!{KEY_SET_LAYER_INFORMATION Bitfields: ULONG [ +BITFIELD! {KEY_SET_LAYER_INFORMATION Bitfields: c_ulong [ IsTombstone set_IsTombstone[0..1], IsSupersedeLocal set_IsSupersedeLocal[1..2], IsSupersedeTree set_IsSupersedeTree[2..3], @@ -135,21 +140,22 @@ BITFIELD!{KEY_SET_LAYER_INFORMATION Bitfields: ULONG [ Reserved set_Reserved[4..32], ]} pub type PKEY_SET_LAYER_INFORMATION = *mut KEY_SET_LAYER_INFORMATION; -STRUCT!{struct KEY_CONTROL_FLAGS_INFORMATION { - ControlFlags: ULONG, +STRUCT! {struct KEY_CONTROL_FLAGS_INFORMATION { + ControlFlags: c_ulong, }} pub type PKEY_CONTROL_FLAGS_INFORMATION = *mut KEY_CONTROL_FLAGS_INFORMATION; -STRUCT!{struct KEY_SET_VIRTUALIZATION_INFORMATION { - HandleTags: ULONG, +STRUCT! {struct KEY_SET_VIRTUALIZATION_INFORMATION { + HandleTags: c_ulong, }} -BITFIELD!{KEY_SET_VIRTUALIZATION_INFORMATION HandleTags: ULONG [ +BITFIELD! {KEY_SET_VIRTUALIZATION_INFORMATION HandleTags: c_ulong [ VirtualTarget set_VirtualTarget[0..1], VirtualStore set_VirtualStore[1..2], VirtualSource set_VirtualSource[2..3], Reserved set_Reserved[3..32], ]} -pub type PKEY_SET_VIRTUALIZATION_INFORMATION = *mut KEY_SET_VIRTUALIZATION_INFORMATION; -ENUM!{enum KEY_VALUE_INFORMATION_CLASS { +pub type PKEY_SET_VIRTUALIZATION_INFORMATION = + *mut KEY_SET_VIRTUALIZATION_INFORMATION; +ENUM! {enum KEY_VALUE_INFORMATION_CLASS { KeyValueBasicInformation = 0, KeyValueFullInformation = 1, KeyValuePartialInformation = 2, @@ -158,111 +164,112 @@ ENUM!{enum KEY_VALUE_INFORMATION_CLASS { KeyValueLayerInformation = 5, MaxKeyValueInfoClass = 6, }} -STRUCT!{struct KEY_VALUE_BASIC_INFORMATION { - TitleIndex: ULONG, - Type: ULONG, - NameLength: ULONG, - Name: [WCHAR; 1], +STRUCT! {struct KEY_VALUE_BASIC_INFORMATION { + TitleIndex: c_ulong, + Type: c_ulong, + NameLength: c_ulong, + Name: [wchar_t; 1], }} pub type PKEY_VALUE_BASIC_INFORMATION = *mut KEY_VALUE_BASIC_INFORMATION; -STRUCT!{struct KEY_VALUE_FULL_INFORMATION { - TitleIndex: ULONG, - Type: ULONG, - DataOffset: ULONG, - DataLength: ULONG, - NameLength: ULONG, - Name: [WCHAR; 1], +STRUCT! {struct KEY_VALUE_FULL_INFORMATION { + TitleIndex: c_ulong, + Type: c_ulong, + DataOffset: c_ulong, + DataLength: c_ulong, + NameLength: c_ulong, + Name: [wchar_t; 1], }} pub type PKEY_VALUE_FULL_INFORMATION = *mut KEY_VALUE_FULL_INFORMATION; -STRUCT!{struct KEY_VALUE_PARTIAL_INFORMATION { - TitleIndex: ULONG, - Type: ULONG, - DataLength: ULONG, - Data: [UCHAR; 1], +STRUCT! {struct KEY_VALUE_PARTIAL_INFORMATION { + TitleIndex: c_ulong, + Type: c_ulong, + DataLength: c_ulong, + Data: [c_uchar; 1], }} pub type PKEY_VALUE_PARTIAL_INFORMATION = *mut KEY_VALUE_PARTIAL_INFORMATION; -STRUCT!{struct KEY_VALUE_PARTIAL_INFORMATION_ALIGN64 { - Type: ULONG, - DataLength: ULONG, - Data: [UCHAR; 1], +STRUCT! {struct KEY_VALUE_PARTIAL_INFORMATION_ALIGN64 { + Type: c_ulong, + DataLength: c_ulong, + Data: [c_uchar; 1], }} -pub type PKEY_VALUE_PARTIAL_INFORMATION_ALIGN64 = *mut KEY_VALUE_PARTIAL_INFORMATION_ALIGN64; -STRUCT!{struct KEY_VALUE_LAYER_INFORMATION { - IsTombstone: ULONG, - Reserved: ULONG, +pub type PKEY_VALUE_PARTIAL_INFORMATION_ALIGN64 = + *mut KEY_VALUE_PARTIAL_INFORMATION_ALIGN64; +STRUCT! {struct KEY_VALUE_LAYER_INFORMATION { + IsTombstone: c_ulong, + Reserved: c_ulong, }} pub type PKEY_VALUE_LAYER_INFORMATION = *mut KEY_VALUE_LAYER_INFORMATION; -STRUCT!{struct KEY_VALUE_ENTRY { - ValueName: PUNICODE_STRING, - DataLength: ULONG, - DataOffset: ULONG, - Type: ULONG, +STRUCT! {struct KEY_VALUE_ENTRY { + ValueName: *mut UNICODE_STRING, + DataLength: c_ulong, + DataOffset: c_ulong, + Type: c_ulong, }} pub type PKEY_VALUE_ENTRY = *mut KEY_VALUE_ENTRY; -ENUM!{enum REG_ACTION { +ENUM! {enum REG_ACTION { KeyAdded = 0, KeyRemoved = 1, KeyModified = 2, }} -STRUCT!{struct REG_NOTIFY_INFORMATION { - NextEntryOffset: ULONG, +STRUCT! {struct REG_NOTIFY_INFORMATION { + NextEntryOffset: c_ulong, Action: REG_ACTION, - KeyLength: ULONG, - Key: [WCHAR; 1], + KeyLength: c_ulong, + Key: [wchar_t; 1], }} pub type PREG_NOTIFY_INFORMATION = *mut REG_NOTIFY_INFORMATION; -STRUCT!{struct KEY_PID_ARRAY { +STRUCT! {struct KEY_PID_ARRAY { PID: HANDLE, KeyName: UNICODE_STRING, }} pub type PKEY_PID_ARRAY = *mut KEY_PID_ARRAY; -STRUCT!{struct KEY_OPEN_SUBKEYS_INFORMATION { - Count: ULONG, +STRUCT! {struct KEY_OPEN_SUBKEYS_INFORMATION { + Count: c_ulong, KeyArray: [KEY_PID_ARRAY; 1], }} pub type PKEY_OPEN_SUBKEYS_INFORMATION = *mut KEY_OPEN_SUBKEYS_INFORMATION; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtCreateKey( - KeyHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - TitleIndex: ULONG, - Class: PUNICODE_STRING, - CreateOptions: ULONG, - Disposition: PULONG, + KeyHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + TitleIndex: c_ulong, + Class: *mut UNICODE_STRING, + CreateOptions: c_ulong, + Disposition: *mut c_ulong, ) -> NTSTATUS; fn NtCreateKeyTransacted( - KeyHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - TitleIndex: ULONG, - Class: PUNICODE_STRING, - CreateOptions: ULONG, + KeyHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + TitleIndex: c_ulong, + Class: *mut UNICODE_STRING, + CreateOptions: c_ulong, TransactionHandle: HANDLE, - Disposition: PULONG, + Disposition: *mut c_ulong, ) -> NTSTATUS; fn NtOpenKey( - KeyHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + KeyHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn NtOpenKeyTransacted( - KeyHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + KeyHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, TransactionHandle: HANDLE, ) -> NTSTATUS; fn NtOpenKeyEx( - KeyHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - OpenOptions: ULONG, + KeyHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + OpenOptions: c_ulong, ) -> NTSTATUS; fn NtOpenKeyTransactedEx( - KeyHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - OpenOptions: ULONG, + KeyHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + OpenOptions: c_ulong, TransactionHandle: HANDLE, ) -> NTSTATUS; fn NtDeleteKey( @@ -270,98 +277,98 @@ EXTERN!{extern "system" { ) -> NTSTATUS; fn NtRenameKey( KeyHandle: HANDLE, - NewName: PUNICODE_STRING, + NewName: *mut UNICODE_STRING, ) -> NTSTATUS; fn NtDeleteValueKey( KeyHandle: HANDLE, - ValueName: PUNICODE_STRING, + ValueName: *mut UNICODE_STRING, ) -> NTSTATUS; fn NtQueryKey( KeyHandle: HANDLE, KeyInformationClass: KEY_INFORMATION_CLASS, - KeyInformation: PVOID, - Length: ULONG, - ResultLength: PULONG, + KeyInformation: *mut c_void, + Length: c_ulong, + ResultLength: *mut c_ulong, ) -> NTSTATUS; fn NtSetInformationKey( KeyHandle: HANDLE, KeySetInformationClass: KEY_SET_INFORMATION_CLASS, - KeySetInformation: PVOID, - KeySetInformationLength: ULONG, + KeySetInformation: *mut c_void, + KeySetInformationLength: c_ulong, ) -> NTSTATUS; fn NtQueryValueKey( KeyHandle: HANDLE, - ValueName: PUNICODE_STRING, + ValueName: *mut UNICODE_STRING, KeyValueInformationClass: KEY_VALUE_INFORMATION_CLASS, - KeyValueInformation: PVOID, - Length: ULONG, - ResultLength: PULONG, + KeyValueInformation: *mut c_void, + Length: c_ulong, + ResultLength: *mut c_ulong, ) -> NTSTATUS; fn NtSetValueKey( KeyHandle: HANDLE, - ValueName: PUNICODE_STRING, - TitleIndex: ULONG, - Type: ULONG, - Data: PVOID, - DataSize: ULONG, + ValueName: *mut UNICODE_STRING, + TitleIndex: c_ulong, + Type: c_ulong, + Data: *mut c_void, + DataSize: c_ulong, ) -> NTSTATUS; fn NtQueryMultipleValueKey( KeyHandle: HANDLE, ValueEntries: PKEY_VALUE_ENTRY, - EntryCount: ULONG, - ValueBuffer: PVOID, - BufferLength: PULONG, - RequiredBufferLength: PULONG, + EntryCount: c_ulong, + ValueBuffer: *mut c_void, + BufferLength: *mut c_ulong, + RequiredBufferLength: *mut c_ulong, ) -> NTSTATUS; fn NtEnumerateKey( KeyHandle: HANDLE, - Index: ULONG, + Index: c_ulong, KeyInformationClass: KEY_INFORMATION_CLASS, - KeyInformation: PVOID, - Length: ULONG, - ResultLength: PULONG, + KeyInformation: *mut c_void, + Length: c_ulong, + ResultLength: *mut c_ulong, ) -> NTSTATUS; fn NtEnumerateValueKey( KeyHandle: HANDLE, - Index: ULONG, + Index: c_ulong, KeyValueInformationClass: KEY_VALUE_INFORMATION_CLASS, - KeyValueInformation: PVOID, - Length: ULONG, - ResultLength: PULONG, + KeyValueInformation: *mut c_void, + Length: c_ulong, + ResultLength: *mut c_ulong, ) -> NTSTATUS; fn NtFlushKey( KeyHandle: HANDLE, ) -> NTSTATUS; fn NtCompactKeys( - Count: ULONG, + Count: c_ulong, KeyArray: *mut HANDLE, ) -> NTSTATUS; fn NtCompressKey( Key: HANDLE, ) -> NTSTATUS; fn NtLoadKey( - TargetKey: POBJECT_ATTRIBUTES, - SourceFile: POBJECT_ATTRIBUTES, + TargetKey: *mut OBJECT_ATTRIBUTES, + SourceFile: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn NtLoadKey2( - TargetKey: POBJECT_ATTRIBUTES, - SourceFile: POBJECT_ATTRIBUTES, - Flags: ULONG, + TargetKey: *mut OBJECT_ATTRIBUTES, + SourceFile: *mut OBJECT_ATTRIBUTES, + Flags: c_ulong, ) -> NTSTATUS; fn NtLoadKeyEx( - TargetKey: POBJECT_ATTRIBUTES, - SourceFile: POBJECT_ATTRIBUTES, - Flags: ULONG, + TargetKey: *mut OBJECT_ATTRIBUTES, + SourceFile: *mut OBJECT_ATTRIBUTES, + Flags: c_ulong, TrustClassKey: HANDLE, Event: HANDLE, - DesiredAccess: ACCESS_MASK, - RootHandle: PHANDLE, + DesiredAccess: c_ulong, + RootHandle: *mut HANDLE, IoStatus: PIO_STATUS_BLOCK, ) -> NTSTATUS; fn NtReplaceKey( - NewFile: POBJECT_ATTRIBUTES, + NewFile: *mut OBJECT_ATTRIBUTES, TargetHandle: HANDLE, - OldFile: POBJECT_ATTRIBUTES, + OldFile: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn NtSaveKey( KeyHandle: HANDLE, @@ -370,7 +377,7 @@ EXTERN!{extern "system" { fn NtSaveKeyEx( KeyHandle: HANDLE, FileHandle: HANDLE, - Format: ULONG, + Format: c_ulong, ) -> NTSTATUS; fn NtSaveMergedKeys( HighPrecedenceKeyHandle: HANDLE, @@ -380,71 +387,71 @@ EXTERN!{extern "system" { fn NtRestoreKey( KeyHandle: HANDLE, FileHandle: HANDLE, - Flags: ULONG, + Flags: c_ulong, ) -> NTSTATUS; fn NtUnloadKey( - TargetKey: POBJECT_ATTRIBUTES, + TargetKey: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; }} -pub const REG_FORCE_UNLOAD: ULONG = 1; -pub const REG_UNLOAD_LEGAL_FLAGS: ULONG = REG_FORCE_UNLOAD; -EXTERN!{extern "system" { +pub const REG_FORCE_UNLOAD: c_ulong = 1; +pub const REG_UNLOAD_LEGAL_FLAGS: c_ulong = REG_FORCE_UNLOAD; +EXTERN! {extern "system" { fn NtUnloadKey2( - TargetKey: POBJECT_ATTRIBUTES, - Flags: ULONG, + TargetKey: *mut OBJECT_ATTRIBUTES, + Flags: c_ulong, ) -> NTSTATUS; fn NtUnloadKeyEx( - TargetKey: POBJECT_ATTRIBUTES, + TargetKey: *mut OBJECT_ATTRIBUTES, Event: HANDLE, ) -> NTSTATUS; fn NtNotifyChangeKey( KeyHandle: HANDLE, Event: HANDLE, ApcRoutine: PIO_APC_ROUTINE, - ApcContext: PVOID, + ApcContext: *mut c_void, IoStatusBlock: PIO_STATUS_BLOCK, - CompletionFilter: ULONG, - WatchTree: BOOLEAN, - Buffer: PVOID, - BufferSize: ULONG, - Asynchronous: BOOLEAN, + CompletionFilter: c_ulong, + WatchTree: c_uchar, + Buffer: *mut c_void, + BufferSize: c_ulong, + Asynchronous: c_uchar, ) -> NTSTATUS; fn NtNotifyChangeMultipleKeys( MasterKeyHandle: HANDLE, - Count: ULONG, + Count: c_ulong, SubordinateObjects: *mut OBJECT_ATTRIBUTES, Event: HANDLE, ApcRoutine: PIO_APC_ROUTINE, - ApcContext: PVOID, + ApcContext: *mut c_void, IoStatusBlock: PIO_STATUS_BLOCK, - CompletionFilter: ULONG, - WatchTree: BOOLEAN, - Buffer: PVOID, - BufferSize: ULONG, - Asynchronous: BOOLEAN, + CompletionFilter: c_ulong, + WatchTree: c_uchar, + Buffer: *mut c_void, + BufferSize: c_ulong, + Asynchronous: c_uchar, ) -> NTSTATUS; fn NtQueryOpenSubKeys( - TargetKey: POBJECT_ATTRIBUTES, - HandleCount: PULONG, + TargetKey: *mut OBJECT_ATTRIBUTES, + HandleCount: *mut c_ulong, ) -> NTSTATUS; fn NtQueryOpenSubKeysEx( - TargetKey: POBJECT_ATTRIBUTES, - BufferLength: ULONG, - Buffer: PVOID, - RequiredSize: PULONG, + TargetKey: *mut OBJECT_ATTRIBUTES, + BufferLength: c_ulong, + Buffer: *mut c_void, + RequiredSize: *mut c_ulong, ) -> NTSTATUS; fn NtInitializeRegistry( - BootCondition: USHORT, + BootCondition: c_ushort, ) -> NTSTATUS; fn NtLockRegistryKey( KeyHandle: HANDLE, ) -> NTSTATUS; fn NtLockProductActivationKeys( - pPrivateVer: *mut ULONG, - pSafeMode: *mut ULONG, + pPrivateVer: *mut c_ulong, + pSafeMode: *mut c_ulong, ) -> NTSTATUS; fn NtFreezeRegistry( - TimeOutInSeconds: ULONG, + TimeOutInSeconds: c_ulong, ) -> NTSTATUS; fn NtThawRegistry() -> NTSTATUS; }} diff --git a/src/ntrtl.rs b/src/ntrtl.rs index abbc386..8ea021c 100644 --- a/src/ntrtl.rs +++ b/src/ntrtl.rs @@ -1,47 +1,66 @@ -use core::ptr::null_mut; -use crate::ntapi_base::{CLIENT_ID, PCLIENT_ID}; -use crate::ntexapi::{RTL_PROCESS_BACKTRACES, RTL_PROCESS_LOCKS}; -use crate::ntioapi::FILE_INFORMATION_CLASS; -use crate::ntldr::{RTL_PROCESS_MODULES, RTL_PROCESS_MODULE_INFORMATION_EX}; -use crate::ntmmapi::SECTION_IMAGE_INFORMATION; -use crate::ntnls::{PCPTABLEINFO, PNLSTABLEINFO}; -use crate::ntpebteb::{PPEB, PTEB_ACTIVE_FRAME}; -use crate::ntpsapi::{PINITIAL_TEB, PPS_APC_ROUTINE, PS_PROTECTION}; -use crate::ntapi_base::{PRTL_ATOM, RTL_ATOM}; -use crate::string::UTF16Const; -use winapi::ctypes::c_void; -use winapi::shared::basetsd::{PULONG64, ULONG32, ULONG64, PSIZE_T, PULONG_PTR, SIZE_T, ULONG_PTR}; -use winapi::shared::guiddef::GUID; -use winapi::shared::in6addr::in6_addr; -use winapi::shared::inaddr::in_addr; -use winapi::shared::minwindef::{BOOL, DWORD, PBOOL}; +use core::ptr::{eq, null_mut}; + #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] -use winapi::shared::ntdef::{LARGE_INTEGER, RTL_BALANCED_NODE}; -use winapi::shared::ntdef::{ - BOOLEAN, CCHAR, CHAR, CLONG, CSHORT, HANDLE, LCID, LIST_ENTRY, LOGICAL, LONG, LUID, NTSTATUS, - PANSI_STRING, PBOOLEAN, PCANSI_STRING, PCCH, PCH, PCHAR, PCOEM_STRING, PCSZ, PCUNICODE_STRING, - PCWCH, PCWSTR, PHANDLE, PLARGE_INTEGER, PLCID, PLIST_ENTRY, PLONG, PLUID, PNT_PRODUCT_TYPE, - POEM_STRING, PPROCESSOR_NUMBER, PRTL_BALANCED_NODE, PSINGLE_LIST_ENTRY, PSTR, PSTRING, PUCHAR, - PULONG, PULONGLONG, PUNICODE_STRING, PUSHORT, PVOID, PWCH, PWCHAR, PWSTR, SINGLE_LIST_ENTRY, - STRING, UCHAR, ULONG, ULONGLONG, UNICODE_STRING, USHORT, VOID, WCHAR, +use windows_sys::Win32::System::Diagnostics::Debug::{ + IMAGE_RUNTIME_FUNCTION_ENTRY, PGET_RUNTIME_FUNCTION_CALLBACK, WOW64_CONTEXT, }; -use winapi::um::minwinbase::PTHREAD_START_ROUTINE; -#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] -use winapi::um::winnt::{PGET_RUNTIME_FUNCTION_CALLBACK, PRUNTIME_FUNCTION, PWOW64_CONTEXT}; -use winapi::um::winnt::{ - ACCESS_MASK, ACL_INFORMATION_CLASS, APC_CALLBACK_FUNCTION, HEAP_INFORMATION_CLASS, - HEAP_REALLOC_IN_PLACE_ONLY, HEAP_ZERO_MEMORY, OS_DEPLOYEMENT_STATE_VALUES, PACCESS_MASK, PACL, - PCONTEXT, PEXCEPTION_POINTERS, PEXCEPTION_RECORD, PFLS_CALLBACK_FUNCTION, PGENERIC_MAPPING, - PIMAGE_NT_HEADERS, PIMAGE_SECTION_HEADER, PLUID_AND_ATTRIBUTES, PMESSAGE_RESOURCE_ENTRY, - PPERFORMANCE_DATA, PRTL_BARRIER, PRTL_CONDITION_VARIABLE, PRTL_CRITICAL_SECTION, - PRTL_OSVERSIONINFOEXW, PRTL_OSVERSIONINFOW, PRTL_RESOURCE_DEBUG, PRTL_SRWLOCK, - PSECURITY_DESCRIPTOR, PSECURITY_DESCRIPTOR_CONTROL, PSID, PSID_AND_ATTRIBUTES, - PSID_AND_ATTRIBUTES_HASH, PSID_IDENTIFIER_AUTHORITY, PVECTORED_EXCEPTION_HANDLER, - PXSAVE_AREA_HEADER, RTL_CRITICAL_SECTION, RTL_SRWLOCK, SECURITY_DESCRIPTOR_CONTROL, - SECURITY_IMPERSONATION_LEVEL, SECURITY_INFORMATION, WAITORTIMERCALLBACKFUNC, - WORKERCALLBACKFUNC, +use windows_sys::{ + core::GUID, + Win32::{ + Foundation::{HANDLE, LUID, NTSTATUS, PSID, UNICODE_STRING}, + Networking::WinSock::{IN6_ADDR, IN_ADDR}, + Security::{ + ACL, ACL_INFORMATION_CLASS, GENERIC_MAPPING, LUID_AND_ATTRIBUTES, + PSECURITY_DESCRIPTOR, SECURITY_DESCRIPTOR_CONTROL, + SECURITY_IMPERSONATION_LEVEL, SID_AND_ATTRIBUTES, + SID_AND_ATTRIBUTES_HASH, SID_IDENTIFIER_AUTHORITY, + }, + System::{ + Diagnostics::Debug::{ + CONTEXT, EXCEPTION_POINTERS, EXCEPTION_RECORD, + IMAGE_NT_HEADERS64, IMAGE_SECTION_HEADER, + PVECTORED_EXCEPTION_HANDLER, XSAVE_AREA_HEADER, + }, + Kernel::{ + LIST_ENTRY, NT_PRODUCT_TYPE, PROCESSOR_NUMBER, + RTL_BALANCED_NODE, SINGLE_LIST_ENTRY, STRING, + }, + Memory::{ + HEAP_INFORMATION_CLASS, HEAP_REALLOC_IN_PLACE_ONLY, + HEAP_ZERO_MEMORY, + }, + Performance::HardwareCounterProfiling::PERFORMANCE_DATA, + SystemInformation::{ + OSVERSIONINFOEXW, OSVERSIONINFOW, OS_DEPLOYEMENT_STATE_VALUES, + }, + Threading::{ + APC_CALLBACK_FUNCTION, LPTHREAD_START_ROUTINE, + PFLS_CALLBACK_FUNCTION, RTL_BARRIER, RTL_CONDITION_VARIABLE, + RTL_CRITICAL_SECTION, RTL_CRITICAL_SECTION_DEBUG, RTL_SRWLOCK, + WAITORTIMERCALLBACK, WORKERCALLBACKFUNC, + }, + }, + UI::WindowsAndMessaging::MESSAGE_RESOURCE_ENTRY, + }, +}; + +use crate::{ + ctypes::{ + __uint64, c_char, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, + c_ushort, c_void, wchar_t, + }, + ntapi_base::{CLIENT_ID, PCLIENT_ID, PRTL_ATOM, RTL_ATOM}, + ntexapi::{RTL_PROCESS_BACKTRACES, RTL_PROCESS_LOCKS}, + ntioapi::FILE_INFORMATION_CLASS, + ntldr::{RTL_PROCESS_MODULES, RTL_PROCESS_MODULE_INFORMATION_EX}, + ntmmapi::SECTION_IMAGE_INFORMATION, + ntnls::{PCPTABLEINFO, PNLSTABLEINFO}, + ntpebteb::{PPEB, PTEB_ACTIVE_FRAME}, + ntpsapi::{PINITIAL_TEB, PPS_APC_ROUTINE, PS_PROTECTION}, + string::UTF16Const, + windows_local::shared::ntdef::LARGE_INTEGER, }; -use winapi::vc::vadefs::va_list; + #[inline] pub fn InitializeListHead(ListHead: &mut LIST_ENTRY) { ListHead.Flink = ListHead; @@ -49,7 +68,7 @@ pub fn InitializeListHead(ListHead: &mut LIST_ENTRY) { } #[inline] pub fn IsListEmpty(ListHead: &LIST_ENTRY) -> bool { - ListHead.Flink as *const _ == ListHead as *const _ + eq(ListHead.Flink, ListHead) } #[inline] pub unsafe fn RemoveEntryList(Entry: &mut LIST_ENTRY) -> bool { @@ -59,7 +78,7 @@ pub unsafe fn RemoveEntryList(Entry: &mut LIST_ENTRY) -> bool { Flink == Blink } #[inline] -pub unsafe fn RemoveHeadList(ListHead: &mut LIST_ENTRY) -> PLIST_ENTRY { +pub unsafe fn RemoveHeadList(ListHead: &mut LIST_ENTRY) -> *mut LIST_ENTRY { let Entry = ListHead.Flink; let Flink = (*Entry).Flink; ListHead.Flink = Flink; @@ -67,7 +86,7 @@ pub unsafe fn RemoveHeadList(ListHead: &mut LIST_ENTRY) -> PLIST_ENTRY { Entry } #[inline] -pub unsafe fn RemoveTailList(ListHead: &mut LIST_ENTRY) -> PLIST_ENTRY { +pub unsafe fn RemoveTailList(ListHead: &mut LIST_ENTRY) -> *mut LIST_ENTRY { let Entry = ListHead.Blink; let Blink = (*Entry).Blink; ListHead.Blink = Blink; @@ -75,7 +94,10 @@ pub unsafe fn RemoveTailList(ListHead: &mut LIST_ENTRY) -> PLIST_ENTRY { Entry } #[inline] -pub unsafe fn InsertTailList(ListHead: &mut LIST_ENTRY, Entry: &mut LIST_ENTRY) { +pub unsafe fn InsertTailList( + ListHead: &mut LIST_ENTRY, + Entry: &mut LIST_ENTRY, +) { let Blink = ListHead.Blink; Entry.Flink = ListHead; Entry.Blink = Blink; @@ -83,7 +105,10 @@ pub unsafe fn InsertTailList(ListHead: &mut LIST_ENTRY, Entry: &mut LIST_ENTRY) ListHead.Blink = Entry; } #[inline] -pub unsafe fn InsertHeadList(ListHead: &mut LIST_ENTRY, Entry: &mut LIST_ENTRY) { +pub unsafe fn InsertHeadList( + ListHead: &mut LIST_ENTRY, + Entry: &mut LIST_ENTRY, +) { let Flink = ListHead.Flink; Entry.Flink = Flink; Entry.Blink = ListHead; @@ -91,7 +116,10 @@ pub unsafe fn InsertHeadList(ListHead: &mut LIST_ENTRY, Entry: &mut LIST_ENTRY) ListHead.Flink = Entry; } #[inline] -pub unsafe fn AppendTailList(ListHead: &mut LIST_ENTRY, ListToAppend: &mut LIST_ENTRY) { +pub unsafe fn AppendTailList( + ListHead: &mut LIST_ENTRY, + ListToAppend: &mut LIST_ENTRY, +) { let ListEnd = ListHead.Blink; (*ListHead.Blink).Flink = ListToAppend; ListHead.Blink = ListToAppend.Blink; @@ -99,7 +127,9 @@ pub unsafe fn AppendTailList(ListHead: &mut LIST_ENTRY, ListToAppend: &mut LIST_ ListToAppend.Blink = ListEnd; } #[inline] -pub unsafe fn PopEntryList(ListHead: &mut SINGLE_LIST_ENTRY) -> PSINGLE_LIST_ENTRY { +pub unsafe fn PopEntryList( + ListHead: &mut SINGLE_LIST_ENTRY, +) -> *mut SINGLE_LIST_ENTRY { let FirstEntry = ListHead.Next; if !FirstEntry.is_null() { ListHead.Next = (*FirstEntry).Next; @@ -107,131 +137,134 @@ pub unsafe fn PopEntryList(ListHead: &mut SINGLE_LIST_ENTRY) -> PSINGLE_LIST_ENT FirstEntry } #[inline] -pub fn PushEntryList(ListHead: &mut SINGLE_LIST_ENTRY, Entry: &mut SINGLE_LIST_ENTRY) { +pub fn PushEntryList( + ListHead: &mut SINGLE_LIST_ENTRY, + Entry: &mut SINGLE_LIST_ENTRY, +) { Entry.Next = ListHead.Next; ListHead.Next = Entry; } -ENUM!{enum TABLE_SEARCH_RESULT { +ENUM! {enum TABLE_SEARCH_RESULT { TableEmptyTree = 0, TableFoundNode = 1, TableInsertAsLeft = 2, TableInsertAsRight = 3, }} -ENUM!{enum RTL_GENERIC_COMPARE_RESULTS { +ENUM! {enum RTL_GENERIC_COMPARE_RESULTS { GenericLessThan = 0, GenericGreaterThan = 1, GenericEqual = 2, }} -FN!{stdcall PRTL_AVL_COMPARE_ROUTINE( +FN! {stdcall PRTL_AVL_COMPARE_ROUTINE( Table: *mut RTL_AVL_TABLE, - FirstStruct: PVOID, - SecondStruct: PVOID, + FirstStruct: *mut c_void, + SecondStruct: *mut c_void, ) -> RTL_GENERIC_COMPARE_RESULTS} -FN!{stdcall PRTL_AVL_ALLOCATE_ROUTINE( +FN! {stdcall PRTL_AVL_ALLOCATE_ROUTINE( Table: *mut RTL_AVL_TABLE, - ByteSize: CLONG, -) -> PVOID} -FN!{stdcall PRTL_AVL_FREE_ROUTINE( + ByteSize: c_ulong, +) -> *mut c_void} +FN! {stdcall PRTL_AVL_FREE_ROUTINE( Table: *mut RTL_AVL_TABLE, - Buffer: PVOID, + Buffer: *mut c_void, ) -> ()} -FN!{stdcall PRTL_AVL_MATCH_FUNCTION( +FN! {stdcall PRTL_AVL_MATCH_FUNCTION( Table: *mut RTL_AVL_TABLE, - UserData: PVOID, - MatchData: PVOID, + UserData: *mut c_void, + MatchData: *mut c_void, ) -> NTSTATUS} -STRUCT!{struct RTL_BALANCED_LINKS { +STRUCT! {struct RTL_BALANCED_LINKS { Parent: *mut RTL_BALANCED_LINKS, LeftChild: *mut RTL_BALANCED_LINKS, RightChild: *mut RTL_BALANCED_LINKS, - Balance: CHAR, - Reserved: [UCHAR; 3], + Balance: c_char, + Reserved: [c_uchar; 3], }} pub type PRTL_BALANCED_LINKS = *mut RTL_BALANCED_LINKS; -STRUCT!{struct RTL_AVL_TABLE { +STRUCT! {struct RTL_AVL_TABLE { BalancedRoot: RTL_BALANCED_LINKS, - OrderedPointer: PVOID, - WhichOrderedElement: ULONG, - NumberGenericTableElements: ULONG, - DepthOfTree: ULONG, + OrderedPointer: *mut c_void, + WhichOrderedElement: c_ulong, + NumberGenericTableElements: c_ulong, + DepthOfTree: c_ulong, RestartKey: PRTL_BALANCED_LINKS, - DeleteCount: ULONG, + DeleteCount: c_ulong, CompareRoutine: PRTL_AVL_COMPARE_ROUTINE, AllocateRoutine: PRTL_AVL_ALLOCATE_ROUTINE, FreeRoutine: PRTL_AVL_FREE_ROUTINE, - TableContext: PVOID, + TableContext: *mut c_void, }} pub type PRTL_AVL_TABLE = *mut RTL_AVL_TABLE; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlInitializeGenericTableAvl( Table: PRTL_AVL_TABLE, CompareRoutine: PRTL_AVL_COMPARE_ROUTINE, AllocateRoutine: PRTL_AVL_ALLOCATE_ROUTINE, FreeRoutine: PRTL_AVL_FREE_ROUTINE, - TableContext: PVOID, + TableContext: *mut c_void, ); fn RtlInsertElementGenericTableAvl( Table: PRTL_AVL_TABLE, - Buffer: PVOID, - BufferSize: CLONG, - NewElement: PBOOLEAN, - ) -> PVOID; + Buffer: *mut c_void, + BufferSize: c_ulong, + NewElement: *mut c_uchar, + ) -> *mut c_void; fn RtlInsertElementGenericTableFullAvl( Table: PRTL_AVL_TABLE, - Buffer: PVOID, - BufferSize: CLONG, - NewElement: PBOOLEAN, - NodeOrParent: PVOID, + Buffer: *mut c_void, + BufferSize: c_ulong, + NewElement: *mut c_uchar, + NodeOrParent: *mut c_void, SearchResult: TABLE_SEARCH_RESULT, - ) -> PVOID; + ) -> *mut c_void; fn RtlDeleteElementGenericTableAvl( Table: PRTL_AVL_TABLE, - Buffer: PVOID, - ) -> BOOLEAN; + Buffer: *mut c_void, + ) -> c_uchar; fn RtlLookupElementGenericTableAvl( Table: PRTL_AVL_TABLE, - Buffer: PVOID, - ) -> PVOID; + Buffer: *mut c_void, + ) -> *mut c_void; fn RtlLookupElementGenericTableFullAvl( Table: PRTL_AVL_TABLE, - Buffer: PVOID, - NodeOrParent: *mut PVOID, + Buffer: *mut c_void, + NodeOrParent: *mut *mut c_void, SearchResult: *mut TABLE_SEARCH_RESULT, - ) -> PVOID; + ) -> *mut c_void; fn RtlEnumerateGenericTableAvl( Table: PRTL_AVL_TABLE, - Restart: BOOLEAN, - ) -> PVOID; + Restart: c_uchar, + ) -> *mut c_void; fn RtlEnumerateGenericTableWithoutSplayingAvl( Table: PRTL_AVL_TABLE, - RestartKey: *mut PVOID, - ) -> PVOID; + RestartKey: *mut *mut c_void, + ) -> *mut c_void; fn RtlLookupFirstMatchingElementGenericTableAvl( Table: PRTL_AVL_TABLE, - Buffer: PVOID, - RestartKey: *mut PVOID, - ) -> PVOID; + Buffer: *mut c_void, + RestartKey: *mut *mut c_void, + ) -> *mut c_void; fn RtlEnumerateGenericTableLikeADirectory( Table: PRTL_AVL_TABLE, MatchFunction: PRTL_AVL_MATCH_FUNCTION, - MatchData: PVOID, - NextFlag: ULONG, - RestartKey: *mut PVOID, - DeleteCount: PULONG, - Buffer: PVOID, - ) -> PVOID; + MatchData: *mut c_void, + NextFlag: c_ulong, + RestartKey: *mut *mut c_void, + DeleteCount: *mut c_ulong, + Buffer: *mut c_void, + ) -> *mut c_void; fn RtlGetElementGenericTableAvl( Table: PRTL_AVL_TABLE, - I: ULONG, - ) -> PVOID; + I: c_ulong, + ) -> *mut c_void; fn RtlNumberGenericTableElementsAvl( Table: PRTL_AVL_TABLE, - ) -> ULONG; + ) -> c_ulong; fn RtlIsGenericTableEmptyAvl( Table: PRTL_AVL_TABLE, - ) -> BOOLEAN; + ) -> c_uchar; }} -STRUCT!{struct RTL_SPLAY_LINKS { +STRUCT! {struct RTL_SPLAY_LINKS { Parent: *mut RTL_SPLAY_LINKS, LeftChild: *mut RTL_SPLAY_LINKS, RightChild: *mut RTL_SPLAY_LINKS, @@ -283,7 +316,7 @@ pub fn RtlInsertAsRightChild( ParentLinks.RightChild = ChildLinks; ChildLinks.Parent = ParentLinks; } -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlSplay( Links: PRTL_SPLAY_LINKS, ) -> PRTL_SPLAY_LINKS; @@ -307,136 +340,137 @@ EXTERN!{extern "system" { Links: PRTL_SPLAY_LINKS, ) -> PRTL_SPLAY_LINKS; }} -FN!{stdcall PRTL_GENERIC_COMPARE_ROUTINE( +FN! {stdcall PRTL_GENERIC_COMPARE_ROUTINE( Table: *mut RTL_GENERIC_TABLE, - FirstStruct: PVOID, - SecondStruct: PVOID, + FirstStruct: *mut c_void, + SecondStruct: *mut c_void, ) -> RTL_GENERIC_COMPARE_RESULTS} -FN!{stdcall PRTL_GENERIC_ALLOCATE_ROUTINE( +FN! {stdcall PRTL_GENERIC_ALLOCATE_ROUTINE( Table: *mut RTL_GENERIC_TABLE, - ByteSize: CLONG, -) -> PVOID} -FN!{stdcall PRTL_GENERIC_FREE_ROUTINE( + ByteSize: c_ulong, +) -> *mut c_void} +FN! {stdcall PRTL_GENERIC_FREE_ROUTINE( Table: *mut RTL_GENERIC_TABLE, - Buffer: PVOID, + Buffer: *mut c_void, ) -> ()} -STRUCT!{struct RTL_GENERIC_TABLE { +STRUCT! {struct RTL_GENERIC_TABLE { TableRoot: PRTL_SPLAY_LINKS, InsertOrderList: LIST_ENTRY, - OrderedPointer: PLIST_ENTRY, - WhichOrderedElement: ULONG, - NumberGenericTableElements: ULONG, + OrderedPointer: *mut LIST_ENTRY, + WhichOrderedElement: c_ulong, + NumberGenericTableElements: c_ulong, CompareRoutine: PRTL_GENERIC_COMPARE_ROUTINE, AllocateRoutine: PRTL_GENERIC_ALLOCATE_ROUTINE, FreeRoutine: PRTL_GENERIC_FREE_ROUTINE, - TableContext: PVOID, + TableContext: *mut c_void, }} pub type PRTL_GENERIC_TABLE = *mut RTL_GENERIC_TABLE; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlInitializeGenericTable( Table: PRTL_GENERIC_TABLE, CompareRoutine: PRTL_GENERIC_COMPARE_ROUTINE, AllocateRoutine: PRTL_GENERIC_ALLOCATE_ROUTINE, FreeRoutine: PRTL_GENERIC_FREE_ROUTINE, - TableContext: PVOID, + TableContext: *mut c_void, ); fn RtlInsertElementGenericTable( Table: PRTL_GENERIC_TABLE, - Buffer: PVOID, - BufferSize: CLONG, - NewElement: PBOOLEAN, - ) -> PVOID; + Buffer: *mut c_void, + BufferSize: c_ulong, + NewElement: *mut c_uchar, + ) -> *mut c_void; fn RtlInsertElementGenericTableFull( Table: PRTL_GENERIC_TABLE, - Buffer: PVOID, - BufferSize: CLONG, - NewElement: PBOOLEAN, - NodeOrParent: PVOID, + Buffer: *mut c_void, + BufferSize: c_ulong, + NewElement: *mut c_uchar, + NodeOrParent: *mut c_void, SearchResult: TABLE_SEARCH_RESULT, - ) -> PVOID; + ) -> *mut c_void; fn RtlDeleteElementGenericTable( Table: PRTL_GENERIC_TABLE, - Buffer: PVOID, - ) -> BOOLEAN; + Buffer: *mut c_void, + ) -> c_uchar; fn RtlLookupElementGenericTable( Table: PRTL_GENERIC_TABLE, - Buffer: PVOID, - ) -> PVOID; + Buffer: *mut c_void, + ) -> *mut c_void; fn RtlLookupElementGenericTableFull( Table: PRTL_GENERIC_TABLE, - Buffer: PVOID, - NodeOrParent: *mut PVOID, + Buffer: *mut c_void, + NodeOrParent: *mut *mut c_void, SearchResult: *mut TABLE_SEARCH_RESULT, - ) -> PVOID; + ) -> *mut c_void; fn RtlEnumerateGenericTable( Table: PRTL_GENERIC_TABLE, - Restart: BOOLEAN, - ) -> PVOID; + Restart: c_uchar, + ) -> *mut c_void; fn RtlEnumerateGenericTableWithoutSplaying( Table: PRTL_GENERIC_TABLE, - RestartKey: *mut PVOID, - ) -> PVOID; + RestartKey: *mut *mut c_void, + ) -> *mut c_void; fn RtlGetElementGenericTable( Table: PRTL_GENERIC_TABLE, - I: ULONG, - ) -> PVOID; + I: c_ulong, + ) -> *mut c_void; fn RtlNumberGenericTableElements( Table: PRTL_GENERIC_TABLE, - ) -> ULONG; + ) -> c_ulong; fn RtlIsGenericTableEmpty( Table: PRTL_GENERIC_TABLE, - ) -> BOOLEAN; + ) -> c_uchar; }} -STRUCT!{struct RTL_RB_TREE { - Root: PRTL_BALANCED_NODE, - Min: PRTL_BALANCED_NODE, +STRUCT! {struct RTL_RB_TREE { + Root: *mut RTL_BALANCED_NODE, + Min: *mut RTL_BALANCED_NODE, }} pub type PRTL_RB_TREE = *mut RTL_RB_TREE; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlRbInsertNodeEx( Tree: PRTL_RB_TREE, - Parent: PRTL_BALANCED_NODE, - Right: BOOLEAN, - Node: PRTL_BALANCED_NODE, + Parent: *mut RTL_BALANCED_NODE, + Right: c_uchar, + Node: *mut RTL_BALANCED_NODE, ); fn RtlRbRemoveNode( Tree: PRTL_RB_TREE, - Node: PRTL_BALANCED_NODE, + Node: *mut RTL_BALANCED_NODE, ); }} pub const RTL_HASH_ALLOCATED_HEADER: u32 = 0x00000001; pub const RTL_HASH_RESERVED_SIGNATURE: u32 = 0; -STRUCT!{struct RTL_DYNAMIC_HASH_TABLE_ENTRY { +STRUCT! {struct RTL_DYNAMIC_HASH_TABLE_ENTRY { Linkage: LIST_ENTRY, - Signature: ULONG_PTR, + Signature: usize, }} pub type PRTL_DYNAMIC_HASH_TABLE_ENTRY = *mut RTL_DYNAMIC_HASH_TABLE_ENTRY; #[inline] -pub const fn HASH_ENTRY_KEY(x: &RTL_DYNAMIC_HASH_TABLE_ENTRY) -> ULONG_PTR { +pub const fn HASH_ENTRY_KEY(x: &RTL_DYNAMIC_HASH_TABLE_ENTRY) -> usize { x.Signature } -STRUCT!{struct RTL_DYNAMIC_HASH_TABLE_CONTEXT { - ChainHead: PLIST_ENTRY, - PrevLinkage: PLIST_ENTRY, - Signature: ULONG_PTR, +STRUCT! {struct RTL_DYNAMIC_HASH_TABLE_CONTEXT { + ChainHead: *mut LIST_ENTRY, + PrevLinkage: *mut LIST_ENTRY, + Signature: usize, }} pub type PRTL_DYNAMIC_HASH_TABLE_CONTEXT = *mut RTL_DYNAMIC_HASH_TABLE_CONTEXT; -STRUCT!{struct RTL_DYNAMIC_HASH_TABLE_ENUMERATOR { +STRUCT! {struct RTL_DYNAMIC_HASH_TABLE_ENUMERATOR { HashEntry: RTL_DYNAMIC_HASH_TABLE_ENTRY, - ChainHead: PLIST_ENTRY, - BucketIndex: ULONG, -}} -pub type PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR = *mut RTL_DYNAMIC_HASH_TABLE_ENUMERATOR; -STRUCT!{struct RTL_DYNAMIC_HASH_TABLE { - Flags: ULONG, - Shift: ULONG, - TableSize: ULONG, - Pivot: ULONG, - DivisorMask: ULONG, - NumEntries: ULONG, - NonEmptyBuckets: ULONG, - NumEnumerators: ULONG, - Directory: PVOID, + ChainHead: *mut LIST_ENTRY, + BucketIndex: c_ulong, +}} +pub type PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR = + *mut RTL_DYNAMIC_HASH_TABLE_ENUMERATOR; +STRUCT! {struct RTL_DYNAMIC_HASH_TABLE { + Flags: c_ulong, + Shift: c_ulong, + TableSize: c_ulong, + Pivot: c_ulong, + DivisorMask: c_ulong, + NumEntries: c_ulong, + NonEmptyBuckets: c_ulong, + NumEnumerators: c_ulong, + Directory: *mut c_void, }} pub type PRTL_DYNAMIC_HASH_TABLE = *mut RTL_DYNAMIC_HASH_TABLE; #[inline] @@ -454,48 +488,58 @@ pub fn RtlInitHashTableContextFromEnumerator( } // RtlReleaseHashTableContext #[inline] -pub const fn RtlTotalBucketsHashTable(HashTable: &RTL_DYNAMIC_HASH_TABLE) -> ULONG { +pub const fn RtlTotalBucketsHashTable( + HashTable: &RTL_DYNAMIC_HASH_TABLE, +) -> c_ulong { HashTable.TableSize } #[inline] -pub const fn RtlNonEmptyBucketsHashTable(HashTable: &RTL_DYNAMIC_HASH_TABLE) -> ULONG { +pub const fn RtlNonEmptyBucketsHashTable( + HashTable: &RTL_DYNAMIC_HASH_TABLE, +) -> c_ulong { HashTable.NonEmptyBuckets } #[inline] -pub const fn RtlEmptyBucketsHashTable(HashTable: &RTL_DYNAMIC_HASH_TABLE) -> ULONG { +pub const fn RtlEmptyBucketsHashTable( + HashTable: &RTL_DYNAMIC_HASH_TABLE, +) -> c_ulong { HashTable.TableSize - HashTable.NonEmptyBuckets } #[inline] -pub const fn RtlTotalEntriesHashTable(HashTable: &RTL_DYNAMIC_HASH_TABLE) -> ULONG { +pub const fn RtlTotalEntriesHashTable( + HashTable: &RTL_DYNAMIC_HASH_TABLE, +) -> c_ulong { HashTable.NumEntries } #[inline] -pub const fn RtlActiveEnumeratorsHashTable(HashTable: &RTL_DYNAMIC_HASH_TABLE) -> ULONG { +pub const fn RtlActiveEnumeratorsHashTable( + HashTable: &RTL_DYNAMIC_HASH_TABLE, +) -> c_ulong { HashTable.NumEnumerators } -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlCreateHashTable( HashTable: *mut PRTL_DYNAMIC_HASH_TABLE, - Shift: ULONG, - Flags: ULONG, - ) -> BOOLEAN; + Shift: c_ulong, + Flags: c_ulong, + ) -> c_uchar; fn RtlDeleteHashTable( HashTable: PRTL_DYNAMIC_HASH_TABLE, ); fn RtlInsertEntryHashTable( HashTable: PRTL_DYNAMIC_HASH_TABLE, Entry: PRTL_DYNAMIC_HASH_TABLE_ENTRY, - Signature: ULONG_PTR, + Signature: usize, Context: PRTL_DYNAMIC_HASH_TABLE_CONTEXT, - ) -> BOOLEAN; + ) -> c_uchar; fn RtlRemoveEntryHashTable( HashTable: PRTL_DYNAMIC_HASH_TABLE, Entry: PRTL_DYNAMIC_HASH_TABLE_ENTRY, Context: PRTL_DYNAMIC_HASH_TABLE_CONTEXT, - ) -> BOOLEAN; + ) -> c_uchar; fn RtlLookupEntryHashTable( HashTable: PRTL_DYNAMIC_HASH_TABLE, - Signature: ULONG_PTR, + Signature: usize, Context: PRTL_DYNAMIC_HASH_TABLE_CONTEXT, ) -> PRTL_DYNAMIC_HASH_TABLE_ENTRY; fn RtlGetNextEntryHashTable( @@ -505,7 +549,7 @@ EXTERN!{extern "system" { fn RtlInitEnumerationHashTable( HashTable: PRTL_DYNAMIC_HASH_TABLE, Enumerator: PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR, - ) -> BOOLEAN; + ) -> c_uchar; fn RtlEnumerateEntryHashTable( HashTable: PRTL_DYNAMIC_HASH_TABLE, Enumerator: PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR, @@ -517,7 +561,7 @@ EXTERN!{extern "system" { fn RtlInitWeakEnumerationHashTable( HashTable: PRTL_DYNAMIC_HASH_TABLE, Enumerator: PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR, - ) -> BOOLEAN; + ) -> c_uchar; fn RtlWeaklyEnumerateEntryHashTable( HashTable: PRTL_DYNAMIC_HASH_TABLE, Enumerator: PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR, @@ -528,14 +572,14 @@ EXTERN!{extern "system" { ); fn RtlExpandHashTable( HashTable: PRTL_DYNAMIC_HASH_TABLE, - ) -> BOOLEAN; + ) -> c_uchar; fn RtlContractHashTable( HashTable: PRTL_DYNAMIC_HASH_TABLE, - ) -> BOOLEAN; + ) -> c_uchar; fn RtlInitStrongEnumerationHashTable( HashTable: PRTL_DYNAMIC_HASH_TABLE, Enumerator: PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR, - ) -> BOOLEAN; + ) -> c_uchar; fn RtlStronglyEnumerateEntryHashTable( HashTable: PRTL_DYNAMIC_HASH_TABLE, Enumerator: PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR, @@ -545,37 +589,37 @@ EXTERN!{extern "system" { Enumerator: PRTL_DYNAMIC_HASH_TABLE_ENUMERATOR, ); fn RtlInitializeCriticalSection( - CriticalSection: PRTL_CRITICAL_SECTION, + CriticalSection: *mut RTL_CRITICAL_SECTION, ) -> NTSTATUS; fn RtlInitializeCriticalSectionAndSpinCount( - CriticalSection: PRTL_CRITICAL_SECTION, - SpinCount: ULONG, + CriticalSection: *mut RTL_CRITICAL_SECTION, + SpinCount: c_ulong, ) -> NTSTATUS; fn RtlDeleteCriticalSection( - CriticalSection: PRTL_CRITICAL_SECTION, + CriticalSection: *mut RTL_CRITICAL_SECTION, ) -> NTSTATUS; fn RtlEnterCriticalSection( - CriticalSection: PRTL_CRITICAL_SECTION, + CriticalSection: *mut RTL_CRITICAL_SECTION, ) -> NTSTATUS; fn RtlLeaveCriticalSection( - CriticalSection: PRTL_CRITICAL_SECTION, + CriticalSection: *mut RTL_CRITICAL_SECTION, ) -> NTSTATUS; fn RtlTryEnterCriticalSection( - CriticalSection: PRTL_CRITICAL_SECTION, - ) -> LOGICAL; + CriticalSection: *mut RTL_CRITICAL_SECTION, + ) -> c_ulong; fn RtlIsCriticalSectionLocked( - CriticalSection: PRTL_CRITICAL_SECTION, - ) -> LOGICAL; + CriticalSection: *mut RTL_CRITICAL_SECTION, + ) -> c_ulong; fn RtlIsCriticalSectionLockedByThread( - CriticalSection: PRTL_CRITICAL_SECTION, - ) -> LOGICAL; + CriticalSection: *mut RTL_CRITICAL_SECTION, + ) -> c_ulong; fn RtlGetCriticalSectionRecursionCount( - CriticalSection: PRTL_CRITICAL_SECTION, - ) -> ULONG; + CriticalSection: *mut RTL_CRITICAL_SECTION, + ) -> c_ulong; fn RtlSetCriticalSectionSpinCount( - CriticalSection: PRTL_CRITICAL_SECTION, - SpinCount: ULONG, - ) -> ULONG; + CriticalSection: *mut RTL_CRITICAL_SECTION, + SpinCount: c_ulong, + ) -> c_ulong; fn RtlQueryCriticalSectionOwner( EventHandle: HANDLE, ) -> HANDLE; @@ -583,20 +627,20 @@ EXTERN!{extern "system" { ThreadHandle: HANDLE, ); }} -STRUCT!{struct RTL_RESOURCE { +STRUCT! {struct RTL_RESOURCE { CriticalSection: RTL_CRITICAL_SECTION, SharedSemaphore: HANDLE, - NumberOfWaitingShared: ULONG, + NumberOfWaitingShared: c_ulong, ExclusiveSemaphore: HANDLE, - NumberOfWaitingExclusive: ULONG, - NumberOfActive: LONG, + NumberOfWaitingExclusive: c_ulong, + NumberOfActive: c_long, ExclusiveOwnerThread: HANDLE, - Flags: ULONG, - DebugInfo: PRTL_RESOURCE_DEBUG, + Flags: c_ulong, + DebugInfo: *mut RTL_CRITICAL_SECTION_DEBUG, }} pub type PRTL_RESOURCE = *mut RTL_RESOURCE; -pub const RTL_RESOURCE_FLAG_LONG_TERM: ULONG = 0x00000001; -EXTERN!{extern "system" { +pub const RTL_RESOURCE_FLAG_LONG_TERM: c_ulong = 0x00000001; +EXTERN! {extern "system" { fn RtlInitializeResource( Resource: PRTL_RESOURCE, ); @@ -605,12 +649,12 @@ EXTERN!{extern "system" { ); fn RtlAcquireResourceShared( Resource: PRTL_RESOURCE, - Wait: BOOLEAN, - ) -> BOOLEAN; + Wait: c_uchar, + ) -> c_uchar; fn RtlAcquireResourceExclusive( Resource: PRTL_RESOURCE, - Wait: BOOLEAN, - ) -> BOOLEAN; + Wait: c_uchar, + ) -> c_uchar; fn RtlReleaseResource( Resource: PRTL_RESOURCE, ); @@ -621,432 +665,437 @@ EXTERN!{extern "system" { Resource: PRTL_RESOURCE, ); fn RtlInitializeSRWLock( - SRWLock: PRTL_SRWLOCK, + SRWLock: *mut RTL_SRWLOCK, ); fn RtlAcquireSRWLockExclusive( - SRWLock: PRTL_SRWLOCK, + SRWLock: *mut RTL_SRWLOCK, ); fn RtlAcquireSRWLockShared( - SRWLock: PRTL_SRWLOCK, + SRWLock: *mut RTL_SRWLOCK, ); fn RtlReleaseSRWLockExclusive( - SRWLock: PRTL_SRWLOCK, + SRWLock: *mut RTL_SRWLOCK, ); fn RtlReleaseSRWLockShared( - SRWLock: PRTL_SRWLOCK, + SRWLock: *mut RTL_SRWLOCK, ); fn RtlTryAcquireSRWLockExclusive( - SRWLock: PRTL_SRWLOCK, - ) -> BOOLEAN; + SRWLock: *mut RTL_SRWLOCK, + ) -> c_uchar; fn RtlTryAcquireSRWLockShared( - SRWLock: PRTL_SRWLOCK, - ) -> BOOLEAN; + SRWLock: *mut RTL_SRWLOCK, + ) -> c_uchar; fn RtlAcquireReleaseSRWLockExclusive( - SRWLock: PRTL_SRWLOCK, + SRWLock: *mut RTL_SRWLOCK, ); fn RtlInitializeConditionVariable( - ConditionVariable: PRTL_CONDITION_VARIABLE, + ConditionVariable: *mut RTL_CONDITION_VARIABLE, ); fn RtlSleepConditionVariableCS( - ConditionVariable: PRTL_CONDITION_VARIABLE, - CriticalSection: PRTL_CRITICAL_SECTION, - Timeout: PLARGE_INTEGER, + ConditionVariable: *mut RTL_CONDITION_VARIABLE, + CriticalSection: *mut RTL_CRITICAL_SECTION, + Timeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn RtlSleepConditionVariableSRW( - ConditionVariable: PRTL_CONDITION_VARIABLE, - SRWLock: PRTL_SRWLOCK, - Timeout: PLARGE_INTEGER, - Flags: ULONG, + ConditionVariable: *mut RTL_CONDITION_VARIABLE, + SRWLock: *mut RTL_SRWLOCK, + Timeout: *mut LARGE_INTEGER, + Flags: c_ulong, ) -> NTSTATUS; fn RtlWakeConditionVariable( - ConditionVariable: PRTL_CONDITION_VARIABLE, + ConditionVariable: *mut RTL_CONDITION_VARIABLE, ); fn RtlWakeAllConditionVariable( - ConditionVariable: PRTL_CONDITION_VARIABLE, + ConditionVariable: *mut RTL_CONDITION_VARIABLE, ); }} -pub const RTL_BARRIER_FLAGS_SPIN_ONLY: ULONG = 0x00000001; -pub const RTL_BARRIER_FLAGS_BLOCK_ONLY: ULONG = 0x00000002; -pub const RTL_BARRIER_FLAGS_NO_DELETE: ULONG = 0x00000004; -EXTERN!{extern "system" { +pub const RTL_BARRIER_FLAGS_SPIN_ONLY: c_ulong = 0x00000001; +pub const RTL_BARRIER_FLAGS_BLOCK_ONLY: c_ulong = 0x00000002; +pub const RTL_BARRIER_FLAGS_NO_DELETE: c_ulong = 0x00000004; +EXTERN! {extern "system" { fn RtlInitBarrier( - Barrier: PRTL_BARRIER, - TotalThreads: ULONG, - SpinCount: ULONG, + Barrier: *mut RTL_BARRIER, + TotalThreads: c_ulong, + SpinCount: c_ulong, ) -> NTSTATUS; fn RtlDeleteBarrier( - Barrier: PRTL_BARRIER, + Barrier: *mut RTL_BARRIER, ) -> NTSTATUS; fn RtlBarrier( - Barrier: PRTL_BARRIER, - Flags: ULONG, - ) -> BOOLEAN; + Barrier: *mut RTL_BARRIER, + Flags: c_ulong, + ) -> c_uchar; fn RtlBarrierForDelete( - Barrier: PRTL_BARRIER, - Flags: ULONG, - ) -> BOOLEAN; + Barrier: *mut RTL_BARRIER, + Flags: c_ulong, + ) -> c_uchar; fn RtlWaitOnAddress( - Address: *mut VOID, - CompareAddress: PVOID, - AddressSize: SIZE_T, - Timeout: PLARGE_INTEGER, + Address: *mut c_void, + CompareAddress: *mut c_void, + AddressSize: usize, + Timeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn RtlWakeAddressAll( - Address: PVOID, + Address: *mut c_void, ); fn RtlWakeAddressSingle( - Address: PVOID, + Address: *mut c_void, ); fn RtlInitString( - DestinationString: PSTRING, - SourceString: PCSZ, + DestinationString: *mut STRING, + SourceString: *const c_char, ); fn RtlInitStringEx( - DestinationString: PSTRING, - SourceString: PCSZ, + DestinationString: *mut STRING, + SourceString: *const c_char, ) -> NTSTATUS; fn RtlInitAnsiString( - DestinationString: PANSI_STRING, - SourceString: PCSZ, + DestinationString: *mut STRING, + SourceString: *const c_char, ); fn RtlInitAnsiStringEx( - DestinationString: PANSI_STRING, - SourceString: PCSZ, + DestinationString: *mut STRING, + SourceString: *const c_char, ) -> NTSTATUS; fn RtlFreeAnsiString( - AnsiString: PANSI_STRING, + AnsiString: *mut STRING, ); fn RtlFreeOemString( - OemString: POEM_STRING, + OemString: *mut STRING, ); fn RtlCopyString( - DestinationString: PSTRING, + DestinationString: *mut STRING, SourceString: *const STRING, ); fn RtlUpperChar( - Character: CHAR, - ) -> CHAR; + Character: c_char, + ) -> c_char; fn RtlCompareString( String1: *const STRING, String2: *const STRING, - CaseInSensitive: BOOLEAN, - ) -> LONG; + CaseInSensitive: c_uchar, + ) -> c_long; fn RtlEqualString( String1: *const STRING, String2: *const STRING, - CaseInSensitive: BOOLEAN, - ) -> BOOLEAN; + CaseInSensitive: c_uchar, + ) -> c_uchar; fn RtlPrefixString( String1: *const STRING, String2: *const STRING, - CaseInSensitive: BOOLEAN, - ) -> BOOLEAN; + CaseInSensitive: c_uchar, + ) -> c_uchar; fn RtlAppendStringToString( - Destination: PSTRING, + Destination: *mut STRING, Source: *const STRING, ) -> NTSTATUS; fn RtlAppendAsciizToString( - Destination: PSTRING, - Source: PSTR, + Destination: *mut STRING, + Source: *mut c_char, ) -> NTSTATUS; fn RtlUpperString( - DestinationString: PSTRING, + DestinationString: *mut STRING, SourceString: *const STRING, ); }} #[inline] -pub unsafe fn RtlIsNullOrEmptyUnicodeString(String: PUNICODE_STRING) -> bool { +pub unsafe fn RtlIsNullOrEmptyUnicodeString( + String: *mut UNICODE_STRING, +) -> bool { String.is_null() || (*String).Length == 0 } #[inline] pub fn RtlInitEmptyUnicodeString( UnicodeString: &mut UNICODE_STRING, - Buffer: PWCHAR, - MaximumLength: USHORT, + Buffer: *mut wchar_t, + MaximumLength: c_ushort, ) { UnicodeString.Buffer = Buffer; UnicodeString.MaximumLength = MaximumLength; UnicodeString.Length = 0; } -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlInitUnicodeString( - DestinationString: PUNICODE_STRING, - SourceString: PCWSTR, + DestinationString: *mut UNICODE_STRING, + SourceString: *const wchar_t, ); fn RtlInitUnicodeStringEx( - DestinationString: PUNICODE_STRING, - SourceString: PCWSTR, + DestinationString: *mut UNICODE_STRING, + SourceString: *const wchar_t, ) -> NTSTATUS; fn RtlCreateUnicodeString( - DestinationString: PUNICODE_STRING, - SourceString: PCWSTR, - ) -> BOOLEAN; + DestinationString: *mut UNICODE_STRING, + SourceString: *const wchar_t, + ) -> c_uchar; fn RtlCreateUnicodeStringFromAsciiz( - DestinationString: PUNICODE_STRING, - SourceString: PSTR, - ) -> BOOLEAN; + DestinationString: *mut UNICODE_STRING, + SourceString: *mut c_char, + ) -> c_uchar; fn RtlFreeUnicodeString( - UnicodeString: PUNICODE_STRING, + UnicodeString: *mut UNICODE_STRING, ); }} -pub const RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE: ULONG = 0x00000001; -pub const RTL_DUPLICATE_UNICODE_STRING_ALLOCATE_NULL_STRING: ULONG = 0x00000002; -EXTERN!{extern "system" { +pub const RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE: c_ulong = 0x00000001; +pub const RTL_DUPLICATE_UNICODE_STRING_ALLOCATE_NULL_STRING: c_ulong = + 0x00000002; +EXTERN! {extern "system" { fn RtlDuplicateUnicodeString( - Flags: ULONG, - StringIn: PCUNICODE_STRING, - StringOut: PUNICODE_STRING, + Flags: c_ulong, + StringIn: *const UNICODE_STRING, + StringOut: *mut UNICODE_STRING, ) -> NTSTATUS; fn RtlCopyUnicodeString( - DestinationString: PUNICODE_STRING, - SourceString: PCUNICODE_STRING, + DestinationString: *mut UNICODE_STRING, + SourceString: *const UNICODE_STRING, ); fn RtlUpcaseUnicodeChar( - SourceCharacter: WCHAR, - ) -> WCHAR; + SourceCharacter: wchar_t, + ) -> wchar_t; fn RtlDowncaseUnicodeChar( - SourceCharacter: WCHAR, - ) -> WCHAR; + SourceCharacter: wchar_t, + ) -> wchar_t; fn RtlCompareUnicodeString( - String1: PCUNICODE_STRING, - String2: PCUNICODE_STRING, - CaseInSensitive: BOOLEAN, - ) -> LONG; + String1: *const UNICODE_STRING, + String2: *const UNICODE_STRING, + CaseInSensitive: c_uchar, + ) -> c_long; fn RtlCompareUnicodeStrings( - String1: PCWCH, - String1Length: SIZE_T, - String2: PCWCH, - String2Length: SIZE_T, - CaseInSensitive: BOOLEAN, - ) -> LONG; + String1: *const wchar_t, + String1Length: usize, + String2: *const wchar_t, + String2Length: usize, + CaseInSensitive: c_uchar, + ) -> c_long; fn RtlEqualUnicodeString( - String1: PCUNICODE_STRING, - String2: PCUNICODE_STRING, - CaseInSensitive: BOOLEAN, - ) -> BOOLEAN; -}} -pub const HASH_STRING_ALGORITHM_DEFAULT: ULONG = 0; -pub const HASH_STRING_ALGORITHM_X65599: ULONG = 1; -pub const HASH_STRING_ALGORITHM_INVALID: ULONG = 0xffffffff; -EXTERN!{extern "system" { + String1: *const UNICODE_STRING, + String2: *const UNICODE_STRING, + CaseInSensitive: c_uchar, + ) -> c_uchar; +}} +pub const HASH_STRING_ALGORITHM_DEFAULT: c_ulong = 0; +pub const HASH_STRING_ALGORITHM_X65599: c_ulong = 1; +pub const HASH_STRING_ALGORITHM_INVALID: c_ulong = 0xffffffff; +EXTERN! {extern "system" { fn RtlHashUnicodeString( - String: PCUNICODE_STRING, - CaseInSensitive: BOOLEAN, - HashAlgorithm: ULONG, - HashValue: PULONG, + String: *const UNICODE_STRING, + CaseInSensitive: c_uchar, + HashAlgorithm: c_ulong, + HashValue: *mut c_ulong, ) -> NTSTATUS; fn RtlValidateUnicodeString( - Flags: ULONG, - String: PCUNICODE_STRING, + Flags: c_ulong, + String: *const UNICODE_STRING, ) -> NTSTATUS; fn RtlPrefixUnicodeString( - String1: PCUNICODE_STRING, - String2: PCUNICODE_STRING, - CaseInSensitive: BOOLEAN, - ) -> BOOLEAN; + String1: *const UNICODE_STRING, + String2: *const UNICODE_STRING, + CaseInSensitive: c_uchar, + ) -> c_uchar; fn RtlSuffixUnicodeString( - String1: PUNICODE_STRING, - String2: PUNICODE_STRING, - CaseInSensitive: BOOLEAN, - ) -> BOOLEAN; + String1: *mut UNICODE_STRING, + String2: *mut UNICODE_STRING, + CaseInSensitive: c_uchar, + ) -> c_uchar; fn RtlFindUnicodeSubstring( - FullString: PUNICODE_STRING, - SearchString: PUNICODE_STRING, - CaseInSensitive: BOOLEAN, - ) -> PWCHAR; -}} -pub const RTL_FIND_CHAR_IN_UNICODE_STRING_START_AT_END: ULONG = 0x00000001; -pub const RTL_FIND_CHAR_IN_UNICODE_STRING_COMPLEMENT_CHAR_SET: ULONG = 0x00000002; -pub const RTL_FIND_CHAR_IN_UNICODE_STRING_CASE_INSENSITIVE: ULONG = 0x00000004; -EXTERN!{extern "system" { + FullString: *mut UNICODE_STRING, + SearchString: *mut UNICODE_STRING, + CaseInSensitive: c_uchar, + ) -> *mut wchar_t; +}} +pub const RTL_FIND_CHAR_IN_UNICODE_STRING_START_AT_END: c_ulong = 0x00000001; +pub const RTL_FIND_CHAR_IN_UNICODE_STRING_COMPLEMENT_CHAR_SET: c_ulong = + 0x00000002; +pub const RTL_FIND_CHAR_IN_UNICODE_STRING_CASE_INSENSITIVE: c_ulong = + 0x00000004; +EXTERN! {extern "system" { fn RtlFindCharInUnicodeString( - Flags: ULONG, - StringToSearch: PUNICODE_STRING, - CharSet: PUNICODE_STRING, - NonInclusivePrefixLength: PUSHORT, + Flags: c_ulong, + StringToSearch: *mut UNICODE_STRING, + CharSet: *mut UNICODE_STRING, + NonInclusivePrefixLength: *mut c_ushort, ) -> NTSTATUS; fn RtlAppendUnicodeStringToString( - Destination: PUNICODE_STRING, - Source: PCUNICODE_STRING, + Destination: *mut UNICODE_STRING, + Source: *const UNICODE_STRING, ) -> NTSTATUS; fn RtlAppendUnicodeToString( - Destination: PUNICODE_STRING, - Source: PCWSTR, + Destination: *mut UNICODE_STRING, + Source: *const wchar_t, ) -> NTSTATUS; fn RtlUpcaseUnicodeString( - DestinationString: PUNICODE_STRING, - SourceString: PCUNICODE_STRING, - AllocateDestinationString: BOOLEAN, + DestinationString: *mut UNICODE_STRING, + SourceString: *const UNICODE_STRING, + AllocateDestinationString: c_uchar, ) -> NTSTATUS; fn RtlDowncaseUnicodeString( - DestinationString: PUNICODE_STRING, - SourceString: PCUNICODE_STRING, - AllocateDestinationString: BOOLEAN, + DestinationString: *mut UNICODE_STRING, + SourceString: *const UNICODE_STRING, + AllocateDestinationString: c_uchar, ) -> NTSTATUS; fn RtlEraseUnicodeString( - String: PUNICODE_STRING, + String: *mut UNICODE_STRING, ); fn RtlAnsiStringToUnicodeString( - DestinationString: PUNICODE_STRING, - SourceString: PCANSI_STRING, - AllocateDestinationString: BOOLEAN, + DestinationString: *mut UNICODE_STRING, + SourceString: *mut STRING, + AllocateDestinationString: c_uchar, ) -> NTSTATUS; fn RtlUnicodeStringToAnsiString( - DestinationString: PANSI_STRING, - SourceString: PCUNICODE_STRING, - AllocateDestinationString: BOOLEAN, + DestinationString: *mut STRING, + SourceString: *const UNICODE_STRING, + AllocateDestinationString: c_uchar, ) -> NTSTATUS; fn RtlAnsiCharToUnicodeChar( - SourceCharacter: *mut PUCHAR, - ) -> WCHAR; + SourceCharacter: *mut *mut c_uchar, + ) -> wchar_t; fn RtlUpcaseUnicodeStringToAnsiString( - DestinationString: PANSI_STRING, - SourceString: PUNICODE_STRING, - AllocateDestinationString: BOOLEAN, + DestinationString: *mut STRING, + SourceString: *mut UNICODE_STRING, + AllocateDestinationString: c_uchar, ) -> NTSTATUS; fn RtlOemStringToUnicodeString( - DestinationString: PUNICODE_STRING, - SourceString: PCOEM_STRING, - AllocateDestinationString: BOOLEAN, + DestinationString: *mut UNICODE_STRING, + SourceString: *const STRING, + AllocateDestinationString: c_uchar, ) -> NTSTATUS; fn RtlUnicodeStringToOemString( - DestinationString: POEM_STRING, - SourceString: PCUNICODE_STRING, - AllocateDestinationString: BOOLEAN, + DestinationString: *mut STRING, + SourceString: *const UNICODE_STRING, + AllocateDestinationString: c_uchar, ) -> NTSTATUS; fn RtlUpcaseUnicodeStringToOemString( - DestinationString: POEM_STRING, - SourceString: PUNICODE_STRING, - AllocateDestinationString: BOOLEAN, + DestinationString: *mut STRING, + SourceString: *mut UNICODE_STRING, + AllocateDestinationString: c_uchar, ) -> NTSTATUS; fn RtlUnicodeStringToCountedOemString( - DestinationString: POEM_STRING, - SourceString: PCUNICODE_STRING, - AllocateDestinationString: BOOLEAN, + DestinationString: *mut STRING, + SourceString: *const UNICODE_STRING, + AllocateDestinationString: c_uchar, ) -> NTSTATUS; fn RtlUpcaseUnicodeStringToCountedOemString( - DestinationString: POEM_STRING, - SourceString: PCUNICODE_STRING, - AllocateDestinationString: BOOLEAN, + DestinationString: *mut STRING, + SourceString: *const UNICODE_STRING, + AllocateDestinationString: c_uchar, ) -> NTSTATUS; fn RtlMultiByteToUnicodeN( - UnicodeString: PWCH, - MaxBytesInUnicodeString: ULONG, - BytesInUnicodeString: PULONG, - MultiByteString: *const CHAR, - BytesInMultiByteString: ULONG, + UnicodeString: *mut wchar_t, + MaxBytesInUnicodeString: c_ulong, + BytesInUnicodeString: *mut c_ulong, + MultiByteString: *const c_char, + BytesInMultiByteString: c_ulong, ) -> NTSTATUS; fn RtlMultiByteToUnicodeSize( - BytesInUnicodeString: PULONG, - MultiByteString: *const CHAR, - BytesInMultiByteString: ULONG, + BytesInUnicodeString: *mut c_ulong, + MultiByteString: *const c_char, + BytesInMultiByteString: c_ulong, ) -> NTSTATUS; fn RtlUnicodeToMultiByteN( - MultiByteString: PCHAR, - MaxBytesInMultiByteString: ULONG, - BytesInMultiByteString: PULONG, - UnicodeString: PCWCH, - BytesInUnicodeString: ULONG, + MultiByteString: *mut c_char, + MaxBytesInMultiByteString: c_ulong, + BytesInMultiByteString: *mut c_ulong, + UnicodeString: *const wchar_t, + BytesInUnicodeString: c_ulong, ) -> NTSTATUS; fn RtlUnicodeToMultiByteSize( - BytesInMultiByteString: PULONG, - UnicodeString: PCWCH, - BytesInUnicodeString: ULONG, + BytesInMultiByteString: *mut c_ulong, + UnicodeString: *const wchar_t, + BytesInUnicodeString: c_ulong, ) -> NTSTATUS; fn RtlUpcaseUnicodeToMultiByteN( - MultiByteString: PCHAR, - MaxBytesInMultiByteString: ULONG, - BytesInMultiByteString: PULONG, - UnicodeString: PCWCH, - BytesInUnicodeString: ULONG, + MultiByteString: *mut c_char, + MaxBytesInMultiByteString: c_ulong, + BytesInMultiByteString: *mut c_ulong, + UnicodeString: *const wchar_t, + BytesInUnicodeString: c_ulong, ) -> NTSTATUS; fn RtlOemToUnicodeN( - UnicodeString: PWCH, - MaxBytesInUnicodeString: ULONG, - BytesInUnicodeString: PULONG, - OemString: PCCH, - BytesInOemString: ULONG, + UnicodeString: *mut wchar_t, + MaxBytesInUnicodeString: c_ulong, + BytesInUnicodeString: *mut c_ulong, + OemString: *const c_char, + BytesInOemString: c_ulong, ) -> NTSTATUS; fn RtlUnicodeToOemN( - OemString: PCHAR, - MaxBytesInOemString: ULONG, - BytesInOemString: PULONG, - UnicodeString: PCWCH, - BytesInUnicodeString: ULONG, + OemString: *mut c_char, + MaxBytesInOemString: c_ulong, + BytesInOemString: *mut c_ulong, + UnicodeString: *const wchar_t, + BytesInUnicodeString: c_ulong, ) -> NTSTATUS; fn RtlUpcaseUnicodeToOemN( - OemString: PCHAR, - MaxBytesInOemString: ULONG, - BytesInOemString: PULONG, - UnicodeString: PCWCH, - BytesInUnicodeString: ULONG, + OemString: *mut c_char, + MaxBytesInOemString: c_ulong, + BytesInOemString: *mut c_ulong, + UnicodeString: *const wchar_t, + BytesInUnicodeString: c_ulong, ) -> NTSTATUS; fn RtlConsoleMultiByteToUnicodeN( - UnicodeString: PWCH, - MaxBytesInUnicodeString: ULONG, - BytesInUnicodeString: PULONG, - MultiByteString: PCH, - BytesInMultiByteString: ULONG, - pdwSpecialChar: PULONG, + UnicodeString: *mut wchar_t, + MaxBytesInUnicodeString: c_ulong, + BytesInUnicodeString: *mut c_ulong, + MultiByteString: *mut c_char, + BytesInMultiByteString: c_ulong, + pdwSpecialChar: *mut c_ulong, ) -> NTSTATUS; fn RtlUTF8ToUnicodeN( - UnicodeStringDestination: PWSTR, - UnicodeStringMaxByteCount: ULONG, - UnicodeStringActualByteCount: PULONG, - UTF8StringSource: PCCH, - UTF8StringByteCount: ULONG, + UnicodeStringDestination: *mut wchar_t, + UnicodeStringMaxByteCount: c_ulong, + UnicodeStringActualByteCount: *mut c_ulong, + UTF8StringSource: *const c_char, + UTF8StringByteCount: c_ulong, ) -> NTSTATUS; fn RtlUnicodeToUTF8N( - UTF8StringDestination: PCHAR, - UTF8StringMaxByteCount: ULONG, - UTF8StringActualByteCount: PULONG, - UnicodeStringSource: PCWCH, - UnicodeStringByteCount: ULONG, + UTF8StringDestination: *mut c_char, + UTF8StringMaxByteCount: c_ulong, + UTF8StringActualByteCount: *mut c_ulong, + UnicodeStringSource: *const wchar_t, + UnicodeStringByteCount: c_ulong, ) -> NTSTATUS; fn RtlCustomCPToUnicodeN( CustomCP: PCPTABLEINFO, - UnicodeString: PWCH, - MaxBytesInUnicodeString: ULONG, - BytesInUnicodeString: PULONG, - CustomCPString: PCH, - BytesInCustomCPString: ULONG, + UnicodeString: *mut wchar_t, + MaxBytesInUnicodeString: c_ulong, + BytesInUnicodeString: *mut c_ulong, + CustomCPString: *mut c_char, + BytesInCustomCPString: c_ulong, ) -> NTSTATUS; fn RtlUnicodeToCustomCPN( CustomCP: PCPTABLEINFO, - CustomCPString: PCH, - MaxBytesInCustomCPString: ULONG, - BytesInCustomCPString: PULONG, - UnicodeString: PWCH, - BytesInUnicodeString: ULONG, + CustomCPString: *mut c_char, + MaxBytesInCustomCPString: c_ulong, + BytesInCustomCPString: *mut c_ulong, + UnicodeString: *mut wchar_t, + BytesInUnicodeString: c_ulong, ) -> NTSTATUS; fn RtlUpcaseUnicodeToCustomCPN( CustomCP: PCPTABLEINFO, - CustomCPString: PCH, - MaxBytesInCustomCPString: ULONG, - BytesInCustomCPString: PULONG, - UnicodeString: PWCH, - BytesInUnicodeString: ULONG, + CustomCPString: *mut c_char, + MaxBytesInCustomCPString: c_ulong, + BytesInCustomCPString: *mut c_ulong, + UnicodeString: *mut wchar_t, + BytesInUnicodeString: c_ulong, ) -> NTSTATUS; fn RtlInitCodePageTable( - TableBase: PUSHORT, + TableBase: *mut c_ushort, CodePageTable: PCPTABLEINFO, ); fn RtlInitNlsTables( - AnsiNlsBase: PUSHORT, - OemNlsBase: PUSHORT, - LanguageNlsBase: PUSHORT, + AnsiNlsBase: *mut c_ushort, + OemNlsBase: *mut c_ushort, + LanguageNlsBase: *mut c_ushort, TableInfo: PNLSTABLEINFO, ); fn RtlResetRtlTranslations( TableInfo: PNLSTABLEINFO, ); fn RtlIsTextUnicode( - Buffer: PVOID, - Size: ULONG, - Result: PULONG, - ) -> BOOLEAN; + Buffer: *mut c_void, + Size: c_ulong, + Result: *mut c_ulong, + ) -> c_uchar; }} -ENUM!{enum RTL_NORM_FORM { +ENUM! {enum RTL_NORM_FORM { NormOther = 0x0, NormC = 0x1, NormD = 0x2, @@ -1060,320 +1109,320 @@ ENUM!{enum RTL_NORM_FORM { NormKDDisallowUnassigned = 0x106, NormIdnaDisallowUnassigned = 0x10d, }} -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlNormalizeString( - NormForm: ULONG, - SourceString: PCWSTR, - SourceStringLength: LONG, - DestinationString: PWSTR, - DestinationStringLength: PLONG, + NormForm: c_ulong, + SourceString: *const wchar_t, + SourceStringLength: c_long, + DestinationString: *mut wchar_t, + DestinationStringLength: *mut c_long, ) -> NTSTATUS; fn RtlIsNormalizedString( - NormForm: ULONG, - SourceString: PCWSTR, - SourceStringLength: LONG, - Normalized: PBOOLEAN, + NormForm: c_ulong, + SourceString: *const wchar_t, + SourceStringLength: c_long, + Normalized: *mut c_uchar, ) -> NTSTATUS; fn RtlIsNameInExpression( - Expression: PUNICODE_STRING, - Name: PUNICODE_STRING, - IgnoreCase: BOOLEAN, - UpcaseTable: PWCH, - ) -> BOOLEAN; + Expression: *mut UNICODE_STRING, + Name: *mut UNICODE_STRING, + IgnoreCase: c_uchar, + UpcaseTable: *mut wchar_t, + ) -> c_uchar; fn RtlIsNameInUnUpcasedExpression( - Expression: PUNICODE_STRING, - Name: PUNICODE_STRING, - IgnoreCase: BOOLEAN, - UpcaseTable: PWCH, - ) -> BOOLEAN; + Expression: *mut UNICODE_STRING, + Name: *mut UNICODE_STRING, + IgnoreCase: c_uchar, + UpcaseTable: *mut wchar_t, + ) -> c_uchar; fn RtlEqualDomainName( - String1: PUNICODE_STRING, - String2: PUNICODE_STRING, - ) -> BOOLEAN; + String1: *mut UNICODE_STRING, + String2: *mut UNICODE_STRING, + ) -> c_uchar; fn RtlEqualComputerName( - String1: PUNICODE_STRING, - String2: PUNICODE_STRING, - ) -> BOOLEAN; + String1: *mut UNICODE_STRING, + String2: *mut UNICODE_STRING, + ) -> c_uchar; fn RtlDnsHostNameToComputerName( - ComputerNameString: PUNICODE_STRING, - DnsHostNameString: PUNICODE_STRING, - AllocateComputerNameString: BOOLEAN, + ComputerNameString: *mut UNICODE_STRING, + DnsHostNameString: *mut UNICODE_STRING, + AllocateComputerNameString: c_uchar, ) -> NTSTATUS; fn RtlStringFromGUID( Guid: *const GUID, - GuidString: PUNICODE_STRING, + GuidString: *mut UNICODE_STRING, ) -> NTSTATUS; fn RtlStringFromGUIDEx( Guid: *mut GUID, - GuidString: PUNICODE_STRING, - AllocateGuidString: BOOLEAN, + GuidString: *mut UNICODE_STRING, + AllocateGuidString: c_uchar, ) -> NTSTATUS; fn RtlGUIDFromString( - GuidString: PCUNICODE_STRING, + GuidString: *const UNICODE_STRING, Guid: *mut GUID, ) -> NTSTATUS; fn RtlCompareAltitudes( - Altitude1: PCUNICODE_STRING, - Altitude2: PCUNICODE_STRING, - ) -> LONG; + Altitude1: *const UNICODE_STRING, + Altitude2: *const UNICODE_STRING, + ) -> c_long; fn RtlIdnToAscii( - Flags: ULONG, - SourceString: PCWSTR, - SourceStringLength: LONG, - DestinationString: PWSTR, - DestinationStringLength: PLONG, + Flags: c_ulong, + SourceString: *const wchar_t, + SourceStringLength: c_long, + DestinationString: *mut wchar_t, + DestinationStringLength: *mut c_long, ) -> NTSTATUS; fn RtlIdnToUnicode( - Flags: ULONG, - SourceString: PCWSTR, - SourceStringLength: LONG, - DestinationString: PWSTR, - DestinationStringLength: PLONG, + Flags: c_ulong, + SourceString: *const wchar_t, + SourceStringLength: c_long, + DestinationString: *mut wchar_t, + DestinationStringLength: *mut c_long, ) -> NTSTATUS; fn RtlIdnToNameprepUnicode( - Flags: ULONG, - SourceString: PCWSTR, - SourceStringLength: LONG, - DestinationString: PWSTR, - DestinationStringLength: PLONG, + Flags: c_ulong, + SourceString: *const wchar_t, + SourceStringLength: c_long, + DestinationString: *mut wchar_t, + DestinationStringLength: *mut c_long, ) -> NTSTATUS; }} -STRUCT!{struct PREFIX_TABLE_ENTRY { - NodeTypeCode: CSHORT, - NameLength: CSHORT, +STRUCT! {struct PREFIX_TABLE_ENTRY { + NodeTypeCode: c_short, + NameLength: c_short, NextPrefixTree: *mut PREFIX_TABLE_ENTRY, Links: RTL_SPLAY_LINKS, - Prefix: PSTRING, + Prefix: *mut STRING, }} pub type PPREFIX_TABLE_ENTRY = *mut PREFIX_TABLE_ENTRY; -STRUCT!{struct PREFIX_TABLE { - NodeTypeCode: CSHORT, - NameLength: CSHORT, +STRUCT! {struct PREFIX_TABLE { + NodeTypeCode: c_short, + NameLength: c_short, NextPrefixTree: PPREFIX_TABLE_ENTRY, }} pub type PPREFIX_TABLE = *mut PREFIX_TABLE; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn PfxInitialize( PrefixTable: PPREFIX_TABLE, ); fn PfxInsertPrefix( PrefixTable: PPREFIX_TABLE, - Prefix: PSTRING, + Prefix: *mut STRING, PrefixTableEntry: PPREFIX_TABLE_ENTRY, - ) -> BOOLEAN; + ) -> c_uchar; fn PfxRemovePrefix( PrefixTable: PPREFIX_TABLE, PrefixTableEntry: PPREFIX_TABLE_ENTRY, ); fn PfxFindPrefix( PrefixTable: PPREFIX_TABLE, - FullName: PSTRING, + FullName: *mut STRING, ) -> PPREFIX_TABLE_ENTRY; }} -STRUCT!{struct UNICODE_PREFIX_TABLE_ENTRY { - NodeTypeCode: CSHORT, - NameLength: CSHORT, +STRUCT! {struct UNICODE_PREFIX_TABLE_ENTRY { + NodeTypeCode: c_short, + NameLength: c_short, NextPrefixTree: *mut UNICODE_PREFIX_TABLE_ENTRY, CaseMatch: *mut UNICODE_PREFIX_TABLE_ENTRY, Links: RTL_SPLAY_LINKS, - Prefix: PUNICODE_STRING, + Prefix: *mut UNICODE_STRING, }} pub type PUNICODE_PREFIX_TABLE_ENTRY = *mut UNICODE_PREFIX_TABLE_ENTRY; -STRUCT!{struct UNICODE_PREFIX_TABLE { - NodeTypeCode: CSHORT, - NameLength: CSHORT, +STRUCT! {struct UNICODE_PREFIX_TABLE { + NodeTypeCode: c_short, + NameLength: c_short, NextPrefixTree: PUNICODE_PREFIX_TABLE_ENTRY, LastNextEntry: PUNICODE_PREFIX_TABLE_ENTRY, }} pub type PUNICODE_PREFIX_TABLE = *mut UNICODE_PREFIX_TABLE; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlInitializeUnicodePrefix( PrefixTable: PUNICODE_PREFIX_TABLE, ); fn RtlInsertUnicodePrefix( PrefixTable: PUNICODE_PREFIX_TABLE, - Prefix: PUNICODE_STRING, + Prefix: *mut UNICODE_STRING, PrefixTableEntry: PUNICODE_PREFIX_TABLE_ENTRY, - ) -> BOOLEAN; + ) -> c_uchar; fn RtlRemoveUnicodePrefix( PrefixTable: PUNICODE_PREFIX_TABLE, PrefixTableEntry: PUNICODE_PREFIX_TABLE_ENTRY, ); fn RtlFindUnicodePrefix( PrefixTable: PUNICODE_PREFIX_TABLE, - FullName: PCUNICODE_STRING, - CaseInsensitiveIndex: ULONG, + FullName: *const UNICODE_STRING, + CaseInsensitiveIndex: c_ulong, ) -> PUNICODE_PREFIX_TABLE_ENTRY; fn RtlNextUnicodePrefix( PrefixTable: PUNICODE_PREFIX_TABLE, - Restart: BOOLEAN, + Restart: c_uchar, ) -> PUNICODE_PREFIX_TABLE_ENTRY; }} -STRUCT!{struct COMPRESSED_DATA_INFO { - CompressionFormatAndEngine: USHORT, - CompressionUnitShift: UCHAR, - ChunkShift: UCHAR, - ClusterShift: UCHAR, - Reserved: UCHAR, - NumberOfChunks: USHORT, - CompressedChunkSizes: [ULONG; 1], +STRUCT! {struct COMPRESSED_DATA_INFO { + CompressionFormatAndEngine: c_ushort, + CompressionUnitShift: c_uchar, + ChunkShift: c_uchar, + ClusterShift: c_uchar, + Reserved: c_uchar, + NumberOfChunks: c_ushort, + CompressedChunkSizes: [c_ulong; 1], }} pub type PCOMPRESSED_DATA_INFO = *mut COMPRESSED_DATA_INFO; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlGetCompressionWorkSpaceSize( - CompressionFormatAndEngine: USHORT, - CompressBufferWorkSpaceSize: PULONG, - CompressFragmentWorkSpaceSize: PULONG, + CompressionFormatAndEngine: c_ushort, + CompressBufferWorkSpaceSize: *mut c_ulong, + CompressFragmentWorkSpaceSize: *mut c_ulong, ) -> NTSTATUS; fn RtlCompressBuffer( - CompressionFormatAndEngine: USHORT, - UncompressedBuffer: PUCHAR, - UncompressedBufferSize: ULONG, - CompressedBuffer: PUCHAR, - CompressedBufferSize: ULONG, - UncompressedChunkSize: ULONG, - FinalCompressedSize: PULONG, - WorkSpace: PVOID, + CompressionFormatAndEngine: c_ushort, + UncompressedBuffer: *mut c_uchar, + UncompressedBufferSize: c_ulong, + CompressedBuffer: *mut c_uchar, + CompressedBufferSize: c_ulong, + UncompressedChunkSize: c_ulong, + FinalCompressedSize: *mut c_ulong, + WorkSpace: *mut c_void, ) -> NTSTATUS; fn RtlDecompressBuffer( - CompressionFormat: USHORT, - UncompressedBuffer: PUCHAR, - UncompressedBufferSize: ULONG, - CompressedBuffer: PUCHAR, - CompressedBufferSize: ULONG, - FinalUncompressedSize: PULONG, + CompressionFormat: c_ushort, + UncompressedBuffer: *mut c_uchar, + UncompressedBufferSize: c_ulong, + CompressedBuffer: *mut c_uchar, + CompressedBufferSize: c_ulong, + FinalUncompressedSize: *mut c_ulong, ) -> NTSTATUS; fn RtlDecompressBufferEx( - CompressionFormat: USHORT, - UncompressedBuffer: PUCHAR, - UncompressedBufferSize: ULONG, - CompressedBuffer: PUCHAR, - CompressedBufferSize: ULONG, - FinalUncompressedSize: PULONG, - WorkSpace: PVOID, + CompressionFormat: c_ushort, + UncompressedBuffer: *mut c_uchar, + UncompressedBufferSize: c_ulong, + CompressedBuffer: *mut c_uchar, + CompressedBufferSize: c_ulong, + FinalUncompressedSize: *mut c_ulong, + WorkSpace: *mut c_void, ) -> NTSTATUS; fn RtlDecompressFragment( - CompressionFormat: USHORT, - UncompressedFragment: PUCHAR, - UncompressedFragmentSize: ULONG, - CompressedBuffer: PUCHAR, - CompressedBufferSize: ULONG, - FragmentOffset: ULONG, - FinalUncompressedSize: PULONG, - WorkSpace: PVOID, + CompressionFormat: c_ushort, + UncompressedFragment: *mut c_uchar, + UncompressedFragmentSize: c_ulong, + CompressedBuffer: *mut c_uchar, + CompressedBufferSize: c_ulong, + FragmentOffset: c_ulong, + FinalUncompressedSize: *mut c_ulong, + WorkSpace: *mut c_void, ) -> NTSTATUS; fn RtlDescribeChunk( - CompressionFormat: USHORT, - CompressedBuffer: *mut PUCHAR, - EndOfCompressedBufferPlus1: PUCHAR, - ChunkBuffer: *mut PUCHAR, - ChunkSize: PULONG, + CompressionFormat: c_ushort, + CompressedBuffer: *mut *mut c_uchar, + EndOfCompressedBufferPlus1: *mut c_uchar, + ChunkBuffer: *mut *mut c_uchar, + ChunkSize: *mut c_ulong, ) -> NTSTATUS; fn RtlReserveChunk( - CompressionFormat: USHORT, - CompressedBuffer: *mut PUCHAR, - EndOfCompressedBufferPlus1: PUCHAR, - ChunkBuffer: *mut PUCHAR, - ChunkSize: ULONG, + CompressionFormat: c_ushort, + CompressedBuffer: *mut *mut c_uchar, + EndOfCompressedBufferPlus1: *mut c_uchar, + ChunkBuffer: *mut *mut c_uchar, + ChunkSize: c_ulong, ) -> NTSTATUS; fn RtlDecompressChunks( - UncompressedBuffer: PUCHAR, - UncompressedBufferSize: ULONG, - CompressedBuffer: PUCHAR, - CompressedBufferSize: ULONG, - CompressedTail: PUCHAR, - CompressedTailSize: ULONG, + UncompressedBuffer: *mut c_uchar, + UncompressedBufferSize: c_ulong, + CompressedBuffer: *mut c_uchar, + CompressedBufferSize: c_ulong, + CompressedTail: *mut c_uchar, + CompressedTailSize: c_ulong, CompressedDataInfo: PCOMPRESSED_DATA_INFO, ) -> NTSTATUS; fn RtlCompressChunks( - UncompressedBuffer: PUCHAR, - UncompressedBufferSize: ULONG, - CompressedBuffer: PUCHAR, - CompressedBufferSize: ULONG, + UncompressedBuffer: *mut c_uchar, + UncompressedBufferSize: c_ulong, + CompressedBuffer: *mut c_uchar, + CompressedBufferSize: c_ulong, CompressedDataInfo: PCOMPRESSED_DATA_INFO, - CompressedDataInfoLength: ULONG, - WorkSpace: PVOID, + CompressedDataInfoLength: c_ulong, + WorkSpace: *mut c_void, ) -> NTSTATUS; fn RtlConvertLCIDToString( - LcidValue: LCID, - Base: ULONG, - Padding: ULONG, - pResultBuf: PWSTR, - Size: ULONG, + LcidValue: c_ulong, + Base: c_ulong, + Padding: c_ulong, + pResultBuf: *mut wchar_t, + Size: c_ulong, ) -> NTSTATUS; fn RtlIsValidLocaleName( - LocaleName: PWSTR, - Flags: ULONG, - ) -> BOOLEAN; + LocaleName: *mut wchar_t, + Flags: c_ulong, + ) -> c_uchar; fn RtlGetParentLocaleName( - LocaleName: PWSTR, - ParentLocaleName: PUNICODE_STRING, - Flags: ULONG, - AllocateDestinationString: BOOLEAN, + LocaleName: *mut wchar_t, + ParentLocaleName: *mut UNICODE_STRING, + Flags: c_ulong, + AllocateDestinationString: c_uchar, ) -> NTSTATUS; fn RtlLcidToLocaleName( - lcid: LCID, - LocaleName: PUNICODE_STRING, - Flags: ULONG, - AllocateDestinationString: BOOLEAN, + lcid: c_ulong, + LocaleName: *mut UNICODE_STRING, + Flags: c_ulong, + AllocateDestinationString: c_uchar, ) -> NTSTATUS; fn RtlLocaleNameToLcid( - LocaleName: PWSTR, - lcid: PLCID, - Flags: ULONG, + LocaleName: *mut wchar_t, + lcid: *mut c_ulong, + Flags: c_ulong, ) -> NTSTATUS; fn RtlLCIDToCultureName( - Lcid: LCID, - String: PUNICODE_STRING, - ) -> BOOLEAN; + Lcid: c_ulong, + String: *mut UNICODE_STRING, + ) -> c_uchar; fn RtlCultureNameToLCID( - String: PUNICODE_STRING, - Lcid: PLCID, - ) -> BOOLEAN; + String: *mut UNICODE_STRING, + Lcid: *mut c_ulong, + ) -> c_uchar; fn RtlCleanUpTEBLangLists(); fn RtlGetLocaleFileMappingAddress( - BaseAddress: *mut PVOID, - DefaultLocaleId: PLCID, - DefaultCasingTableSize: PLARGE_INTEGER, + BaseAddress: *mut *mut c_void, + DefaultLocaleId: *mut c_ulong, + DefaultCasingTableSize: *mut LARGE_INTEGER, ) -> NTSTATUS; fn RtlGetCurrentPeb() -> PPEB; fn RtlAcquirePebLock(); fn RtlReleasePebLock(); - fn RtlTryAcquirePebLock() -> LOGICAL; + fn RtlTryAcquirePebLock() -> c_ulong; fn RtlAllocateFromPeb( - Size: ULONG, - Block: *mut PVOID, + Size: c_ulong, + Block: *mut *mut c_void, ) -> NTSTATUS; fn RtlFreeToPeb( - Block: PVOID, - Size: ULONG, + Block: *mut c_void, + Size: c_ulong, ) -> NTSTATUS; }} pub const DOS_MAX_COMPONENT_LENGTH: u32 = 255; pub const DOS_MAX_PATH_LENGTH: u32 = DOS_MAX_COMPONENT_LENGTH + 5; -STRUCT!{struct CURDIR { +STRUCT! {struct CURDIR { DosPath: UNICODE_STRING, Handle: HANDLE, }} pub type PCURDIR = *mut CURDIR; pub const RTL_USER_PROC_CURDIR_CLOSE: u32 = 0x00000002; pub const RTL_USER_PROC_CURDIR_INHERIT: u32 = 0x00000003; -STRUCT!{struct RTL_DRIVE_LETTER_CURDIR { - Flags: USHORT, - Length: USHORT, - TimeStamp: ULONG, +STRUCT! {struct RTL_DRIVE_LETTER_CURDIR { + Flags: c_ushort, + Length: c_ushort, + TimeStamp: c_ulong, DosPath: STRING, }} pub type PRTL_DRIVE_LETTER_CURDIR = *mut RTL_DRIVE_LETTER_CURDIR; pub const RTL_MAX_DRIVE_LETTERS: usize = 32; -pub const RTL_DRIVE_LETTER_VALID: USHORT = 0x0001; -STRUCT!{struct RTL_USER_PROCESS_PARAMETERS { - MaximumLength: ULONG, - Length: ULONG, - Flags: ULONG, - DebugFlags: ULONG, +pub const RTL_DRIVE_LETTER_VALID: c_ushort = 0x0001; +STRUCT! {struct RTL_USER_PROCESS_PARAMETERS { + MaximumLength: c_ulong, + Length: c_ulong, + Flags: c_ulong, + DebugFlags: c_ulong, ConsoleHandle: HANDLE, - ConsoleFlags: ULONG, + ConsoleFlags: c_ulong, StandardInput: HANDLE, StandardOutput: HANDLE, StandardError: HANDLE, @@ -1381,65 +1430,65 @@ STRUCT!{struct RTL_USER_PROCESS_PARAMETERS { DllPath: UNICODE_STRING, ImagePathName: UNICODE_STRING, CommandLine: UNICODE_STRING, - Environment: PVOID, - StartingX: ULONG, - StartingY: ULONG, - CountX: ULONG, - CountY: ULONG, - CountCharsX: ULONG, - CountCharsY: ULONG, - FillAttribute: ULONG, - WindowFlags: ULONG, - ShowWindowFlags: ULONG, + Environment: *mut c_void, + StartingX: c_ulong, + StartingY: c_ulong, + CountX: c_ulong, + CountY: c_ulong, + CountCharsX: c_ulong, + CountCharsY: c_ulong, + FillAttribute: c_ulong, + WindowFlags: c_ulong, + ShowWindowFlags: c_ulong, WindowTitle: UNICODE_STRING, DesktopInfo: UNICODE_STRING, ShellInfo: UNICODE_STRING, RuntimeData: UNICODE_STRING, CurrentDirectories: [RTL_DRIVE_LETTER_CURDIR; RTL_MAX_DRIVE_LETTERS], - EnvironmentSize: ULONG_PTR, - EnvironmentVersion: ULONG_PTR, - PackageDependencyData: PVOID, - ProcessGroupId: ULONG, - LoaderThreads: ULONG, + EnvironmentSize: usize, + EnvironmentVersion: usize, + PackageDependencyData: *mut c_void, + ProcessGroupId: c_ulong, + LoaderThreads: c_ulong, }} pub type PRTL_USER_PROCESS_PARAMETERS = *mut RTL_USER_PROCESS_PARAMETERS; -pub const RTL_USER_PROC_PARAMS_NORMALIZED: ULONG = 0x00000001; -pub const RTL_USER_PROC_PROFILE_USER: ULONG = 0x00000002; -pub const RTL_USER_PROC_PROFILE_KERNEL: ULONG = 0x00000004; -pub const RTL_USER_PROC_PROFILE_SERVER: ULONG = 0x00000008; -pub const RTL_USER_PROC_RESERVE_1MB: ULONG = 0x00000020; -pub const RTL_USER_PROC_RESERVE_16MB: ULONG = 0x00000040; -pub const RTL_USER_PROC_CASE_SENSITIVE: ULONG = 0x00000080; -pub const RTL_USER_PROC_DISABLE_HEAP_DECOMMIT: ULONG = 0x00000100; -pub const RTL_USER_PROC_DLL_REDIRECTION_LOCAL: ULONG = 0x00001000; -pub const RTL_USER_PROC_APP_MANIFEST_PRESENT: ULONG = 0x00002000; -pub const RTL_USER_PROC_IMAGE_KEY_MISSING: ULONG = 0x00004000; -pub const RTL_USER_PROC_OPTIN_PROCESS: ULONG = 0x00020000; -EXTERN!{extern "system" { +pub const RTL_USER_PROC_PARAMS_NORMALIZED: c_ulong = 0x00000001; +pub const RTL_USER_PROC_PROFILE_USER: c_ulong = 0x00000002; +pub const RTL_USER_PROC_PROFILE_KERNEL: c_ulong = 0x00000004; +pub const RTL_USER_PROC_PROFILE_SERVER: c_ulong = 0x00000008; +pub const RTL_USER_PROC_RESERVE_1MB: c_ulong = 0x00000020; +pub const RTL_USER_PROC_RESERVE_16MB: c_ulong = 0x00000040; +pub const RTL_USER_PROC_CASE_SENSITIVE: c_ulong = 0x00000080; +pub const RTL_USER_PROC_DISABLE_HEAP_DECOMMIT: c_ulong = 0x00000100; +pub const RTL_USER_PROC_DLL_REDIRECTION_LOCAL: c_ulong = 0x00001000; +pub const RTL_USER_PROC_APP_MANIFEST_PRESENT: c_ulong = 0x00002000; +pub const RTL_USER_PROC_IMAGE_KEY_MISSING: c_ulong = 0x00004000; +pub const RTL_USER_PROC_OPTIN_PROCESS: c_ulong = 0x00020000; +EXTERN! {extern "system" { fn RtlCreateProcessParameters( pProcessParameters: *mut PRTL_USER_PROCESS_PARAMETERS, - ImagePathName: PUNICODE_STRING, - DllPath: PUNICODE_STRING, - CurrentDirectory: PUNICODE_STRING, - CommandLine: PUNICODE_STRING, - Environment: PVOID, - WindowTitle: PUNICODE_STRING, - DesktopInfo: PUNICODE_STRING, - ShellInfo: PUNICODE_STRING, - RuntimeData: PUNICODE_STRING, + ImagePathName: *mut UNICODE_STRING, + DllPath: *mut UNICODE_STRING, + CurrentDirectory: *mut UNICODE_STRING, + CommandLine: *mut UNICODE_STRING, + Environment: *mut c_void, + WindowTitle: *mut UNICODE_STRING, + DesktopInfo: *mut UNICODE_STRING, + ShellInfo: *mut UNICODE_STRING, + RuntimeData: *mut UNICODE_STRING, ) -> NTSTATUS; fn RtlCreateProcessParametersEx( pProcessParameters: *mut PRTL_USER_PROCESS_PARAMETERS, - ImagePathName: PUNICODE_STRING, - DllPath: PUNICODE_STRING, - CurrentDirectory: PUNICODE_STRING, - CommandLine: PUNICODE_STRING, - Environment: PVOID, - WindowTitle: PUNICODE_STRING, - DesktopInfo: PUNICODE_STRING, - ShellInfo: PUNICODE_STRING, - RuntimeData: PUNICODE_STRING, - Flags: ULONG, + ImagePathName: *mut UNICODE_STRING, + DllPath: *mut UNICODE_STRING, + CurrentDirectory: *mut UNICODE_STRING, + CommandLine: *mut UNICODE_STRING, + Environment: *mut c_void, + WindowTitle: *mut UNICODE_STRING, + DesktopInfo: *mut UNICODE_STRING, + ShellInfo: *mut UNICODE_STRING, + RuntimeData: *mut UNICODE_STRING, + Flags: c_ulong, ) -> NTSTATUS; fn RtlDestroyProcessParameters( ProcessParameters: PRTL_USER_PROCESS_PARAMETERS, @@ -1451,139 +1500,139 @@ EXTERN!{extern "system" { ProcessParameters: PRTL_USER_PROCESS_PARAMETERS, ) -> PRTL_USER_PROCESS_PARAMETERS; }} -STRUCT!{struct RTL_USER_PROCESS_INFORMATION { - Length: ULONG, +STRUCT! {struct RTL_USER_PROCESS_INFORMATION { + Length: c_ulong, Process: HANDLE, Thread: HANDLE, ClientId: CLIENT_ID, ImageInformation: SECTION_IMAGE_INFORMATION, }} pub type PRTL_USER_PROCESS_INFORMATION = *mut RTL_USER_PROCESS_INFORMATION; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlCreateUserProcess( - NtImagePathName: PUNICODE_STRING, - AttributesDeprecated: ULONG, + NtImagePathName: *mut UNICODE_STRING, + AttributesDeprecated: c_ulong, ProcessParameters: PRTL_USER_PROCESS_PARAMETERS, ProcessSecurityDescriptor: PSECURITY_DESCRIPTOR, ThreadSecurityDescriptor: PSECURITY_DESCRIPTOR, ParentProcess: HANDLE, - InheritHandles: BOOLEAN, + InheritHandles: c_uchar, DebugPort: HANDLE, TokenHandle: HANDLE, ProcessInformation: PRTL_USER_PROCESS_INFORMATION, ) -> NTSTATUS; fn RtlCreateUserProcessEx( - NtImagePathName: PUNICODE_STRING, + NtImagePathName: *mut UNICODE_STRING, ProcessParameters: PRTL_USER_PROCESS_PARAMETERS, - InheritHandles: BOOLEAN, - Flags: ULONG, + InheritHandles: c_uchar, + Flags: c_ulong, ProcessInformation: PRTL_USER_PROCESS_INFORMATION, ) -> NTSTATUS; fn RtlExitUserProcess( ExitStatus: NTSTATUS, ); }} -pub const RTL_CLONE_PROCESS_FLAGS_CREATE_SUSPENDED: ULONG = 0x00000001; -pub const RTL_CLONE_PROCESS_FLAGS_INHERIT_HANDLES: ULONG = 0x00000002; -pub const RTL_CLONE_PROCESS_FLAGS_NO_SYNCHRONIZE: ULONG = 0x00000004; -EXTERN!{extern "system" { +pub const RTL_CLONE_PROCESS_FLAGS_CREATE_SUSPENDED: c_ulong = 0x00000001; +pub const RTL_CLONE_PROCESS_FLAGS_INHERIT_HANDLES: c_ulong = 0x00000002; +pub const RTL_CLONE_PROCESS_FLAGS_NO_SYNCHRONIZE: c_ulong = 0x00000004; +EXTERN! {extern "system" { fn RtlCloneUserProcess( - ProcessFlags: ULONG, + ProcessFlags: c_ulong, ProcessSecurityDescriptor: PSECURITY_DESCRIPTOR, ThreadSecurityDescriptor: PSECURITY_DESCRIPTOR, DebugPort: HANDLE, ProcessInformation: PRTL_USER_PROCESS_INFORMATION, ) -> NTSTATUS; fn RtlUpdateClonedCriticalSection( - CriticalSection: PRTL_CRITICAL_SECTION, + CriticalSection: *mut RTL_CRITICAL_SECTION, ); fn RtlUpdateClonedSRWLock( - SRWLock: PRTL_SRWLOCK, - Shared: LOGICAL, + SRWLock: *mut RTL_SRWLOCK, + Shared: c_ulong, ); }} -STRUCT!{struct RTLP_PROCESS_REFLECTION_REFLECTION_INFORMATION { +STRUCT! {struct RTLP_PROCESS_REFLECTION_REFLECTION_INFORMATION { ReflectionProcessHandle: HANDLE, ReflectionThreadHandle: HANDLE, ReflectionClientId: CLIENT_ID, }} pub type PRTLP_PROCESS_REFLECTION_REFLECTION_INFORMATION = *mut RTLP_PROCESS_REFLECTION_REFLECTION_INFORMATION; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlCreateProcessReflection( ProcessHandle: HANDLE, - Flags: ULONG, - StartRoutine: PVOID, - StartContext: PVOID, + Flags: c_ulong, + StartRoutine: *mut c_void, + StartContext: *mut c_void, EventHandle: HANDLE, ReflectionInformation: PRTLP_PROCESS_REFLECTION_REFLECTION_INFORMATION, ) -> NTSTATUS; }} -EXTERN!{extern "C" { +EXTERN! {extern "C" { fn RtlSetProcessIsCritical( - NewValue: BOOLEAN, - OldValue: PBOOLEAN, - CheckFlag: BOOLEAN, + NewValue: c_uchar, + OldValue: *mut c_uchar, + CheckFlag: c_uchar, ) -> NTSTATUS; fn RtlSetThreadIsCritical( - NewValue: BOOLEAN, - OldValue: PBOOLEAN, - CheckFlag: BOOLEAN, + NewValue: c_uchar, + OldValue: *mut c_uchar, + CheckFlag: c_uchar, ) -> NTSTATUS; }} -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlValidProcessProtection( ProcessProtection: PS_PROTECTION, - ) -> BOOLEAN; + ) -> c_uchar; fn RtlTestProtectedAccess( Source: PS_PROTECTION, Target: PS_PROTECTION, - ) -> BOOLEAN; + ) -> c_uchar; fn RtlIsCurrentProcess( ProcessHandle: HANDLE, - ) -> BOOLEAN; + ) -> c_uchar; fn RtlIsCurrentThread( ThreadHandle: HANDLE, - ) -> BOOLEAN; + ) -> c_uchar; }} -FN!{stdcall PUSER_THREAD_START_ROUTINE( - ThreadParameter: PVOID, +FN! {stdcall PUSER_THREAD_START_ROUTINE( + ThreadParameter: *mut c_void, ) -> NTSTATUS} -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlCreateUserThread( Process: HANDLE, ThreadSecurityDescriptor: PSECURITY_DESCRIPTOR, - CreateSuspended: BOOLEAN, - ZeroBits: ULONG, - MaximumStackSize: SIZE_T, - CommittedStackSize: SIZE_T, + CreateSuspended: c_uchar, + ZeroBits: c_ulong, + MaximumStackSize: usize, + CommittedStackSize: usize, StartAddress: PUSER_THREAD_START_ROUTINE, - Parameter: PVOID, - Thread: PHANDLE, + Parameter: *mut c_void, + Thread: *mut HANDLE, ClientId: PCLIENT_ID, ) -> NTSTATUS; fn RtlExitUserThread( ExitStatus: NTSTATUS, ); - fn RtlIsCurrentThreadAttachExempt() -> BOOLEAN; + fn RtlIsCurrentThreadAttachExempt() -> c_uchar; fn RtlCreateUserStack( - CommittedStackSize: SIZE_T, - MaximumStackSize: SIZE_T, - ZeroBits: ULONG_PTR, - PageSize: SIZE_T, - ReserveAlignment: ULONG_PTR, + CommittedStackSize: usize, + MaximumStackSize: usize, + ZeroBits: usize, + PageSize: usize, + ReserveAlignment: usize, InitialTeb: PINITIAL_TEB, ) -> NTSTATUS; fn RtlFreeUserStack( - AllocationBase: PVOID, + AllocationBase: *mut c_void, ) -> NTSTATUS; }} -STRUCT!{struct CONTEXT_CHUNK { - Offset: LONG, - Length: ULONG, +STRUCT! {struct CONTEXT_CHUNK { + Offset: c_long, + Length: c_ulong, }} pub type PCONTEXT_CHUNK = *mut CONTEXT_CHUNK; -STRUCT!{struct CONTEXT_EX { +STRUCT! {struct CONTEXT_EX { All: CONTEXT_CHUNK, Legacy: CONTEXT_CHUNK, XState: CONTEXT_CHUNK, @@ -1605,21 +1654,28 @@ macro_rules! RTL_CONTEXT_EX_LENGTH { #[macro_export] macro_rules! RTL_CONTEXT_EX_CHUNK { ($Base:expr, $Layout:expr, $Chunk:ident) => { - ($Base as usize + RTL_CONTEXT_EX_OFFSET!($Layout, $Chunk) as usize) as *mut c_void + ($Base as usize + RTL_CONTEXT_EX_OFFSET!($Layout, $Chunk) as usize) + as *mut c_void }; } #[macro_export] macro_rules! RTL_CONTEXT_OFFSET { ($Context:expr, $Chunk:ident) => { - RTL_CONTEXT_EX_OFFSET!(($Context as *const $crate::winapi::um::winnt::CONTEXT).offset(1) - as *const $crate::ntrtl::CONTEXT_EX, $Chunk) + RTL_CONTEXT_EX_OFFSET!( + ($Context as *const $crate::winapi::um::winnt::CONTEXT).offset(1) + as *const $crate::ntrtl::CONTEXT_EX, + $Chunk + ) }; } #[macro_export] macro_rules! RTL_CONTEXT_LENGTH { ($Context:expr, $Chunk:ident) => { - RTL_CONTEXT_EX_LENGTH!(($Context as *const $crate::winapi::um::winnt::CONTEXT).offset(1) - as *const $crate::ntrtl::CONTEXT_EX, $Chunk) + RTL_CONTEXT_EX_LENGTH!( + ($Context as *const $crate::winapi::um::winnt::CONTEXT).offset(1) + as *const $crate::ntrtl::CONTEXT_EX, + $Chunk + ) }; } #[macro_export] @@ -1634,101 +1690,101 @@ macro_rules! RTL_CONTEXT_CHUNK { ) }; } -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlInitializeContext( Process: HANDLE, - Context: PCONTEXT, - Parameter: PVOID, - InitialPc: PVOID, - InitialSp: PVOID, + Context: *mut CONTEXT, + Parameter: *mut c_void, + InitialPc: *mut c_void, + InitialSp: *mut c_void, ); fn RtlInitializeExtendedContext( - Context: PCONTEXT, - ContextFlags: ULONG, + Context: *mut CONTEXT, + ContextFlags: c_ulong, ContextEx: *mut PCONTEXT_EX, - ) -> ULONG; + ) -> c_ulong; fn RtlCopyExtendedContext( Destination: PCONTEXT_EX, - ContextFlags: ULONG, + ContextFlags: c_ulong, Source: PCONTEXT_EX, - ) -> ULONG; + ) -> c_ulong; fn RtlGetExtendedContextLength( - ContextFlags: ULONG, - ContextLength: PULONG, - ) -> ULONG; + ContextFlags: c_ulong, + ContextLength: *mut c_ulong, + ) -> c_ulong; fn RtlGetExtendedFeaturesMask( ContextEx: PCONTEXT_EX, - ) -> ULONG64; + ) -> __uint64; fn RtlLocateExtendedFeature( ContextEx: PCONTEXT_EX, - FeatureId: ULONG, - Length: PULONG, - ) -> PVOID; + FeatureId: c_ulong, + Length: *mut c_ulong, + ) -> *mut c_void; fn RtlLocateLegacyContext( ContextEx: PCONTEXT_EX, - Length: PULONG, - ) -> PCONTEXT; + Length: *mut c_ulong, + ) -> *mut CONTEXT; fn RtlSetExtendedFeaturesMask( ContextEx: PCONTEXT_EX, - FeatureMask: ULONG64, + FeatureMask: __uint64, ); }} #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlWow64GetThreadContext( ThreadHandle: HANDLE, - ThreadContext: PWOW64_CONTEXT, + ThreadContext: *mut WOW64_CONTEXT, ) -> NTSTATUS; fn RtlWow64SetThreadContext( ThreadHandle: HANDLE, - ThreadContext: PWOW64_CONTEXT, + ThreadContext: *mut WOW64_CONTEXT, ) -> NTSTATUS; }} -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlRemoteCall( Process: HANDLE, Thread: HANDLE, - CallSite: PVOID, - ArgumentCount: ULONG, - Arguments: PULONG_PTR, - PassContext: BOOLEAN, - AlreadySuspended: BOOLEAN, + CallSite: *mut c_void, + ArgumentCount: c_ulong, + Arguments: *mut usize, + PassContext: c_uchar, + AlreadySuspended: c_uchar, ) -> NTSTATUS; fn RtlAddVectoredExceptionHandler( - First: ULONG, + First: c_ulong, Handler: PVECTORED_EXCEPTION_HANDLER, - ) -> PVOID; + ) -> *mut c_void; fn RtlRemoveVectoredExceptionHandler( - Handle: PVOID, - ) -> ULONG; + Handle: *mut c_void, + ) -> c_ulong; fn RtlAddVectoredContinueHandler( - First: ULONG, + First: c_ulong, Handler: PVECTORED_EXCEPTION_HANDLER, - ) -> PVOID; + ) -> *mut c_void; fn RtlRemoveVectoredContinueHandler( - Handle: PVOID, - ) -> ULONG; + Handle: *mut c_void, + ) -> c_ulong; }} -FN!{stdcall PRTLP_UNHANDLED_EXCEPTION_FILTER( - ExceptionInfo: PEXCEPTION_POINTERS, -) -> ULONG} -EXTERN!{extern "system" { +FN! {stdcall PRTLP_UNHANDLED_EXCEPTION_FILTER( + ExceptionInfo: *mut EXCEPTION_POINTERS, +) -> c_ulong} +EXTERN! {extern "system" { fn RtlSetUnhandledExceptionFilter( UnhandledExceptionFilter: PRTLP_UNHANDLED_EXCEPTION_FILTER, ); fn RtlUnhandledExceptionFilter( - ExceptionPointers: PEXCEPTION_POINTERS, - ) -> LONG; + ExceptionPointers: *mut EXCEPTION_POINTERS, + ) -> c_long; fn RtlUnhandledExceptionFilter2( - ExceptionPointers: PEXCEPTION_POINTERS, - Flags: ULONG, - ) -> LONG; + ExceptionPointers: *mut EXCEPTION_POINTERS, + Flags: c_ulong, + ) -> c_long; fn RtlKnownExceptionFilter( - ExceptionPointers: PEXCEPTION_POINTERS, - ) -> LONG; + ExceptionPointers: *mut EXCEPTION_POINTERS, + ) -> c_long; }} #[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))] -IFDEF!{ +IFDEF! { ENUM!{enum FUNCTION_TABLE_TYPE { RF_SORTED = 0, RF_UNSORTED = 1, @@ -1737,164 +1793,164 @@ ENUM!{enum FUNCTION_TABLE_TYPE { }} STRUCT!{struct DYNAMIC_FUNCTION_TABLE { ListEntry: LIST_ENTRY, - FunctionTable: PRUNTIME_FUNCTION, + FunctionTable: *mut IMAGE_RUNTIME_FUNCTION_ENTRY, TimeStamp: LARGE_INTEGER, - MinimumAddress: ULONG64, - MaximumAddress: ULONG64, - BaseAddress: ULONG64, + MinimumAddress: __uint64, + MaximumAddress: __uint64, + BaseAddress: __uint64, Callback: PGET_RUNTIME_FUNCTION_CALLBACK, - Context: PVOID, - OutOfProcessCallbackDll: PWSTR, + Context: *mut c_void, + OutOfProcessCallbackDll: *mut wchar_t, Type: FUNCTION_TABLE_TYPE, - EntryCount: ULONG, + EntryCount: c_ulong, TreeNode: RTL_BALANCED_NODE, }} pub type PDYNAMIC_FUNCTION_TABLE = *mut DYNAMIC_FUNCTION_TABLE; EXTERN!{extern "system" { - fn RtlGetFunctionTableListHead() -> PLIST_ENTRY; + fn RtlGetFunctionTableListHead() -> *mut LIST_ENTRY; }} } -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlImageNtHeader( - BaseOfImage: PVOID, - ) -> PIMAGE_NT_HEADERS; + BaseOfImage: *mut c_void, + ) -> *mut IMAGE_NT_HEADERS64; }} -pub const RTL_IMAGE_NT_HEADER_EX_FLAG_NO_RANGE_CHECK: ULONG = 0x00000001; -EXTERN!{extern "system" { +pub const RTL_IMAGE_NT_HEADER_EX_FLAG_NO_RANGE_CHECK: c_ulong = 0x00000001; +EXTERN! {extern "system" { fn RtlImageNtHeaderEx( - Flags: ULONG, - BaseOfImage: PVOID, - Size: ULONG64, - OutHeaders: *mut PIMAGE_NT_HEADERS, + Flags: c_ulong, + BaseOfImage: *mut c_void, + Size: __uint64, + OutHeaders: *mut *mut IMAGE_NT_HEADERS64, ) -> NTSTATUS; fn RtlAddressInSectionTable( - NtHeaders: PIMAGE_NT_HEADERS, - BaseOfImage: PVOID, - VirtualAddress: ULONG, - ) -> PVOID; + NtHeaders: *mut IMAGE_NT_HEADERS64, + BaseOfImage: *mut c_void, + VirtualAddress: c_ulong, + ) -> *mut c_void; fn RtlSectionTableFromVirtualAddress( - NtHeaders: PIMAGE_NT_HEADERS, - BaseOfImage: PVOID, - VirtualAddress: ULONG, - ) -> PIMAGE_SECTION_HEADER; + NtHeaders: *mut IMAGE_NT_HEADERS64, + BaseOfImage: *mut c_void, + VirtualAddress: c_ulong, + ) -> *mut IMAGE_SECTION_HEADER; fn RtlImageDirectoryEntryToData( - BaseOfImage: PVOID, - MappedAsImage: BOOLEAN, - DirectoryEntry: USHORT, - Size: PULONG, - ) -> PVOID; + BaseOfImage: *mut c_void, + MappedAsImage: c_uchar, + DirectoryEntry: c_ushort, + Size: *mut c_ulong, + ) -> *mut c_void; fn RtlImageRvaToSection( - NtHeaders: PIMAGE_NT_HEADERS, - BaseOfImage: PVOID, - Rva: ULONG, - ) -> PIMAGE_SECTION_HEADER; + NtHeaders: *mut IMAGE_NT_HEADERS64, + BaseOfImage: *mut c_void, + Rva: c_ulong, + ) -> *mut IMAGE_SECTION_HEADER; fn RtlImageRvaToVa( - NtHeaders: PIMAGE_NT_HEADERS, - BaseOfImage: PVOID, - Rva: ULONG, - LastRvaSection: *mut PIMAGE_SECTION_HEADER, - ) -> PVOID; + NtHeaders: *mut IMAGE_NT_HEADERS64, + BaseOfImage: *mut c_void, + Rva: c_ulong, + LastRvaSection: *mut *mut IMAGE_SECTION_HEADER, + ) -> *mut c_void; fn RtlFindExportedRoutineByName( - BaseOfImage: PVOID, - RoutineName: PSTR, - ) -> PVOID; + BaseOfImage: *mut c_void, + RoutineName: *mut c_char, + ) -> *mut c_void; fn RtlGuardCheckLongJumpTarget( - PcValue: PVOID, - IsFastFail: BOOL, - IsLongJumpTarget: PBOOL, + PcValue: *mut c_void, + IsFastFail: c_int, + IsLongJumpTarget: *mut c_int, ) -> NTSTATUS; fn RtlCompareMemoryUlong( - Source: PVOID, - Length: SIZE_T, - Pattern: ULONG, - ) -> SIZE_T; + Source: *mut c_void, + Length: usize, + Pattern: c_ulong, + ) -> usize; fn RtlFillMemoryUlong( - Destination: PVOID, - Length: SIZE_T, - Pattern: ULONG, + Destination: *mut c_void, + Length: usize, + Pattern: c_ulong, ); fn RtlFillMemoryUlonglong( - Destination: PVOID, - Length: SIZE_T, - Pattern: ULONGLONG, + Destination: *mut c_void, + Length: usize, + Pattern: __uint64, ); fn RtlCreateEnvironment( - CloneCurrentEnvironment: BOOLEAN, - Environment: *mut PVOID, + CloneCurrentEnvironment: c_uchar, + Environment: *mut *mut c_void, ) -> NTSTATUS; }} -pub const RTL_CREATE_ENVIRONMENT_TRANSLATE: ULONG = 0x1; -pub const RTL_CREATE_ENVIRONMENT_TRANSLATE_FROM_OEM: ULONG = 0x2; -pub const RTL_CREATE_ENVIRONMENT_EMPTY: ULONG = 0x4; -EXTERN!{extern "system" { +pub const RTL_CREATE_ENVIRONMENT_TRANSLATE: c_ulong = 0x1; +pub const RTL_CREATE_ENVIRONMENT_TRANSLATE_FROM_OEM: c_ulong = 0x2; +pub const RTL_CREATE_ENVIRONMENT_EMPTY: c_ulong = 0x4; +EXTERN! {extern "system" { fn RtlCreateEnvironmentEx( - SourceEnv: PVOID, - Environment: *mut PVOID, - Flags: ULONG, + SourceEnv: *mut c_void, + Environment: *mut *mut c_void, + Flags: c_ulong, ) -> NTSTATUS; fn RtlDestroyEnvironment( - Environment: PVOID, + Environment: *mut c_void, ) -> NTSTATUS; fn RtlSetCurrentEnvironment( - Environment: PVOID, - PreviousEnvironment: *mut PVOID, + Environment: *mut c_void, + PreviousEnvironment: *mut *mut c_void, ) -> NTSTATUS; fn RtlSetEnvironmentVar( - Environment: *mut PWSTR, - Name: PWSTR, - NameLength: SIZE_T, - Value: PWSTR, - ValueLength: SIZE_T, + Environment: *mut *mut wchar_t, + Name: *mut wchar_t, + NameLength: usize, + Value: *mut wchar_t, + ValueLength: usize, ) -> NTSTATUS; fn RtlSetEnvironmentVariable( - Environment: *mut PVOID, - Name: PUNICODE_STRING, - Value: PUNICODE_STRING, + Environment: *mut *mut c_void, + Name: *mut UNICODE_STRING, + Value: *mut UNICODE_STRING, ) -> NTSTATUS; fn RtlQueryEnvironmentVariable( - Environment: PVOID, - Name: PWSTR, - NameLength: SIZE_T, - Value: PWSTR, - ValueLength: SIZE_T, - ReturnLength: PSIZE_T, + Environment: *mut c_void, + Name: *mut wchar_t, + NameLength: usize, + Value: *mut wchar_t, + ValueLength: usize, + ReturnLength: *mut usize, ) -> NTSTATUS; fn RtlQueryEnvironmentVariable_U( - Environment: PVOID, - Name: PUNICODE_STRING, - Value: PUNICODE_STRING, + Environment: *mut c_void, + Name: *mut UNICODE_STRING, + Value: *mut UNICODE_STRING, ) -> NTSTATUS; fn RtlExpandEnvironmentStrings( - Environment: PVOID, - Src: PWSTR, - SrcLength: SIZE_T, - Dst: PWSTR, - DstLength: SIZE_T, - ReturnLength: PSIZE_T, + Environment: *mut c_void, + Src: *mut wchar_t, + SrcLength: usize, + Dst: *mut wchar_t, + DstLength: usize, + ReturnLength: *mut usize, ) -> NTSTATUS; fn RtlExpandEnvironmentStrings_U( - Environment: PVOID, - Source: PUNICODE_STRING, - Destination: PUNICODE_STRING, - ReturnedLength: PULONG, + Environment: *mut c_void, + Source: *mut UNICODE_STRING, + Destination: *mut UNICODE_STRING, + ReturnedLength: *mut c_ulong, ) -> NTSTATUS; fn RtlSetEnvironmentStrings( - NewEnvironment: PWCHAR, - NewEnvironmentSize: SIZE_T, + NewEnvironment: *mut wchar_t, + NewEnvironmentSize: usize, ) -> NTSTATUS; }} -STRUCT!{struct RTLP_CURDIR_REF { - ReferenceCount: LONG, +STRUCT! {struct RTLP_CURDIR_REF { + ReferenceCount: c_long, DirectoryHandle: HANDLE, }} pub type PRTLP_CURDIR_REF = *mut RTLP_CURDIR_REF; -STRUCT!{struct RTL_RELATIVE_NAME_U { +STRUCT! {struct RTL_RELATIVE_NAME_U { RelativeName: UNICODE_STRING, ContainingDirectory: HANDLE, CurDirRef: PRTLP_CURDIR_REF, }} pub type PRTL_RELATIVE_NAME_U = *mut RTL_RELATIVE_NAME_U; -ENUM!{enum RTL_PATH_TYPE { +ENUM! {enum RTL_PATH_TYPE { RtlPathTypeUnknown = 0, RtlPathTypeUncAbsolute = 1, RtlPathTypeDriveAbsolute = 2, @@ -1904,605 +1960,610 @@ ENUM!{enum RTL_PATH_TYPE { RtlPathTypeLocalDevice = 6, RtlPathTypeRootLocalDevice = 7, }} -EXTERN!{extern "C" { +EXTERN! {extern "C" { static mut RtlDosPathSeperatorsString: UNICODE_STRING; static mut RtlAlternateDosPathSeperatorString: UNICODE_STRING; static mut RtlNtPathSeperatorString: UNICODE_STRING; }} /// "ntdll.dll" pub const RtlNtdllName: UTF16Const = UTF16Const(&[ - 0x006E, 0x0074, 0x0064, 0x006C, 0x006C, 0x002E, 0x0064, 0x006C, 0x006C, 0u16, + 0x006E, 0x0074, 0x0064, 0x006C, 0x006C, 0x002E, 0x0064, 0x006C, 0x006C, + 0u16, ]); -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlDetermineDosPathNameType_U( - DosFileName: PWSTR, + DosFileName: *mut wchar_t, ) -> RTL_PATH_TYPE; fn RtlDetermineDosPathNameType_Ustr( - DosFileName: PCUNICODE_STRING, + DosFileName: *const UNICODE_STRING, ) -> RTL_PATH_TYPE; fn RtlIsDosDeviceName_U( - DosFileName: PWSTR, - ) -> ULONG; + DosFileName: *mut wchar_t, + ) -> c_ulong; fn RtlIsDosDeviceName_Ustr( - DosFileName: PUNICODE_STRING, - ) -> ULONG; + DosFileName: *mut UNICODE_STRING, + ) -> c_ulong; fn RtlGetFullPathName_U( - FileName: PWSTR, - BufferLength: ULONG, - Buffer: PWSTR, - FilePart: *mut PWSTR, - ) -> ULONG; + FileName: *mut wchar_t, + BufferLength: c_ulong, + Buffer: *mut wchar_t, + FilePart: *mut *mut wchar_t, + ) -> c_ulong; fn RtlGetFullPathName_UEx( - FileName: PWSTR, - BufferLength: ULONG, - Buffer: PWSTR, - FilePart: *mut PWSTR, - BytesRequired: *mut ULONG, + FileName: *mut wchar_t, + BufferLength: c_ulong, + Buffer: *mut wchar_t, + FilePart: *mut *mut wchar_t, + BytesRequired: *mut c_ulong, ) -> NTSTATUS; fn RtlGetFullPathName_UstrEx( - FileName: PUNICODE_STRING, - StaticString: PUNICODE_STRING, - DynamicString: PUNICODE_STRING, - StringUsed: *mut PUNICODE_STRING, - FilePartPrefixCch: *mut SIZE_T, - NameInvalid: PBOOLEAN, + FileName: *mut UNICODE_STRING, + StaticString: *mut UNICODE_STRING, + DynamicString: *mut UNICODE_STRING, + StringUsed: *mut *mut UNICODE_STRING, + FilePartPrefixCch: *mut usize, + NameInvalid: *mut c_uchar, InputPathType: *mut RTL_PATH_TYPE, - BytesRequired: *mut SIZE_T, + BytesRequired: *mut usize, ) -> NTSTATUS; fn RtlGetCurrentDirectory_U( - BufferLength: ULONG, - Buffer: PWSTR, - ) -> ULONG; + BufferLength: c_ulong, + Buffer: *mut wchar_t, + ) -> c_ulong; fn RtlSetCurrentDirectory_U( - PathName: PUNICODE_STRING, + PathName: *mut UNICODE_STRING, ) -> NTSTATUS; - fn RtlGetLongestNtPathLength() -> ULONG; + fn RtlGetLongestNtPathLength() -> c_ulong; fn RtlDosPathNameToNtPathName_U( - DosFileName: PWSTR, - NtFileName: PUNICODE_STRING, - FilePart: *mut PWSTR, + DosFileName: *mut wchar_t, + NtFileName: *mut UNICODE_STRING, + FilePart: *mut *mut wchar_t, RelativeName: PRTL_RELATIVE_NAME_U, - ) -> BOOLEAN; + ) -> c_uchar; fn RtlDosPathNameToNtPathName_U_WithStatus( - DosFileName: PWSTR, - NtFileName: PUNICODE_STRING, - FilePart: *mut PWSTR, + DosFileName: *mut wchar_t, + NtFileName: *mut UNICODE_STRING, + FilePart: *mut *mut wchar_t, RelativeName: PRTL_RELATIVE_NAME_U, ) -> NTSTATUS; fn RtlDosLongPathNameToNtPathName_U_WithStatus( - DosFileName: PWSTR, - NtFileName: PUNICODE_STRING, - FilePart: *mut PWSTR, + DosFileName: *mut wchar_t, + NtFileName: *mut UNICODE_STRING, + FilePart: *mut *mut wchar_t, RelativeName: PRTL_RELATIVE_NAME_U, ) -> NTSTATUS; fn RtlDosPathNameToRelativeNtPathName_U( - DosFileName: PWSTR, - NtFileName: PUNICODE_STRING, - FilePart: *mut PWSTR, + DosFileName: *mut wchar_t, + NtFileName: *mut UNICODE_STRING, + FilePart: *mut *mut wchar_t, RelativeName: PRTL_RELATIVE_NAME_U, - ) -> BOOLEAN; + ) -> c_uchar; fn RtlDosPathNameToRelativeNtPathName_U_WithStatus( - DosFileName: PWSTR, - NtFileName: PUNICODE_STRING, - FilePart: *mut PWSTR, + DosFileName: *mut wchar_t, + NtFileName: *mut UNICODE_STRING, + FilePart: *mut *mut wchar_t, RelativeName: PRTL_RELATIVE_NAME_U, ) -> NTSTATUS; fn RtlDosLongPathNameToRelativeNtPathName_U_WithStatus( - DosFileName: PWSTR, - NtFileName: PUNICODE_STRING, - FilePart: *mut PWSTR, + DosFileName: *mut wchar_t, + NtFileName: *mut UNICODE_STRING, + FilePart: *mut *mut wchar_t, RelativeName: PRTL_RELATIVE_NAME_U, ) -> NTSTATUS; fn RtlReleaseRelativeName( RelativeName: PRTL_RELATIVE_NAME_U, ); fn RtlDosSearchPath_U( - Path: PWSTR, - FileName: PWSTR, - Extension: PWSTR, - BufferLength: ULONG, - Buffer: PWSTR, - FilePart: *mut PWSTR, - ) -> ULONG; -}} -pub const RTL_DOS_SEARCH_PATH_FLAG_APPLY_ISOLATION_REDIRECTION: ULONG = 0x00000001; -pub const RTL_DOS_SEARCH_PATH_FLAG_DISALLOW_DOT_RELATIVE_PATH_SEARCH: ULONG = 0x00000002; -pub const RTL_DOS_SEARCH_PATH_FLAG_APPLY_DEFAULT_EXTENSION_WHEN_NOT_RELATIVE_PATH_EVEN_IF_FILE_HAS_EXTENSION: ULONG = 0x00000004; -EXTERN!{extern "system" { + Path: *mut wchar_t, + FileName: *mut wchar_t, + Extension: *mut wchar_t, + BufferLength: c_ulong, + Buffer: *mut wchar_t, + FilePart: *mut *mut wchar_t, + ) -> c_ulong; +}} +pub const RTL_DOS_SEARCH_PATH_FLAG_APPLY_ISOLATION_REDIRECTION: c_ulong = + 0x00000001; +pub const RTL_DOS_SEARCH_PATH_FLAG_DISALLOW_DOT_RELATIVE_PATH_SEARCH: c_ulong = + 0x00000002; +pub const RTL_DOS_SEARCH_PATH_FLAG_APPLY_DEFAULT_EXTENSION_WHEN_NOT_RELATIVE_PATH_EVEN_IF_FILE_HAS_EXTENSION: c_ulong = + 0x00000004; +EXTERN! {extern "system" { fn RtlDosSearchPath_Ustr( - Flags: ULONG, - Path: PUNICODE_STRING, - FileName: PUNICODE_STRING, - DefaultExtension: PUNICODE_STRING, - StaticString: PUNICODE_STRING, - DynamicString: PUNICODE_STRING, - FullFileNameOut: *mut PCUNICODE_STRING, - FilePartPrefixCch: *mut SIZE_T, - BytesRequired: *mut SIZE_T, + Flags: c_ulong, + Path: *mut UNICODE_STRING, + FileName: *mut UNICODE_STRING, + DefaultExtension: *mut UNICODE_STRING, + StaticString: *mut UNICODE_STRING, + DynamicString: *mut UNICODE_STRING, + FullFileNameOut: *mut *const UNICODE_STRING, + FilePartPrefixCch: *mut usize, + BytesRequired: *mut usize, ) -> NTSTATUS; fn RtlDoesFileExists_U( - FileName: PWSTR, - ) -> BOOLEAN; + FileName: *mut wchar_t, + ) -> c_uchar; fn RtlGetLengthWithoutLastFullDosOrNtPathElement( - Flags: ULONG, - PathString: PUNICODE_STRING, - Length: PULONG, + Flags: c_ulong, + PathString: *mut UNICODE_STRING, + Length: *mut c_ulong, ) -> NTSTATUS; fn RtlGetLengthWithoutTrailingPathSeperators( - Flags: ULONG, - PathString: PUNICODE_STRING, - Length: PULONG, + Flags: c_ulong, + PathString: *mut UNICODE_STRING, + Length: *mut c_ulong, ) -> NTSTATUS; }} -STRUCT!{struct GENERATE_NAME_CONTEXT { - Checksum: USHORT, - CheckSumInserted: BOOLEAN, - NameLength: UCHAR, - NameBuffer: [WCHAR; 8], - ExtensionLength: ULONG, - ExtensionBuffer: [WCHAR; 4], - LastIndexValue: ULONG, +STRUCT! {struct GENERATE_NAME_CONTEXT { + Checksum: c_ushort, + CheckSumInserted: c_uchar, + NameLength: c_uchar, + NameBuffer: [wchar_t; 8], + ExtensionLength: c_ulong, + ExtensionBuffer: [wchar_t; 4], + LastIndexValue: c_ulong, }} pub type PGENERATE_NAME_CONTEXT = *mut GENERATE_NAME_CONTEXT; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlGenerate8dot3Name( - Name: PCUNICODE_STRING, - AllowExtendedCharacters: BOOLEAN, + Name: *const UNICODE_STRING, + AllowExtendedCharacters: c_uchar, Context: PGENERATE_NAME_CONTEXT, - Name8dot3: PUNICODE_STRING, + Name8dot3: *mut UNICODE_STRING, ) -> NTSTATUS; fn RtlComputePrivatizedDllName_U( - DllName: PUNICODE_STRING, - RealName: PUNICODE_STRING, - LocalName: PUNICODE_STRING, + DllName: *mut UNICODE_STRING, + RealName: *mut UNICODE_STRING, + LocalName: *mut UNICODE_STRING, ) -> NTSTATUS; fn RtlGetSearchPath( - SearchPathA: *mut PWSTR, - ) -> BOOLEAN; + SearchPathA: *mut *mut wchar_t, + ) -> c_uchar; fn RtlSetSearchPathMode( - Flags: ULONG, + Flags: c_ulong, ) -> NTSTATUS; - fn RtlGetExePath() -> PWSTR; - fn RtlGetNtSystemRoot() -> PWSTR; - fn RtlAreLongPathsEnabled() -> BOOLEAN; - fn RtlIsThreadWithinLoaderCallout() -> BOOLEAN; - fn RtlDllShutdownInProgress() -> BOOLEAN; + fn RtlGetExePath() -> *mut wchar_t; + fn RtlGetNtSystemRoot() -> *mut wchar_t; + fn RtlAreLongPathsEnabled() -> c_uchar; + fn RtlIsThreadWithinLoaderCallout() -> c_uchar; + fn RtlDllShutdownInProgress() -> c_uchar; }} -STRUCT!{struct RTL_HEAP_ENTRY_u_s1 { - Settable: SIZE_T, - Tag: ULONG, +STRUCT! {struct RTL_HEAP_ENTRY_u_s1 { + Settable: usize, + Tag: c_ulong, }} -STRUCT!{struct RTL_HEAP_ENTRY_u_s2 { - CommittedSize: SIZE_T, - FirstBlock: PVOID, +STRUCT! {struct RTL_HEAP_ENTRY_u_s2 { + CommittedSize: usize, + FirstBlock: *mut c_void, }} -UNION!{union RTL_HEAP_ENTRY_u { +UNION! {union RTL_HEAP_ENTRY_u { s1: RTL_HEAP_ENTRY_u_s1, s2: RTL_HEAP_ENTRY_u_s2, }} -STRUCT!{struct RTL_HEAP_ENTRY { - Size: SIZE_T, - Flags: USHORT, - AllocatorBackTraceIndex: USHORT, +STRUCT! {struct RTL_HEAP_ENTRY { + Size: usize, + Flags: c_ushort, + AllocatorBackTraceIndex: c_ushort, u: RTL_HEAP_ENTRY_u, }} pub type PRTL_HEAP_ENTRY = *mut RTL_HEAP_ENTRY; -pub const RTL_HEAP_BUSY: USHORT = 0x0001; -pub const RTL_HEAP_SEGMENT: USHORT = 0x0002; -pub const RTL_HEAP_SETTABLE_VALUE: USHORT = 0x0010; -pub const RTL_HEAP_SETTABLE_FLAG1: USHORT = 0x0020; -pub const RTL_HEAP_SETTABLE_FLAG2: USHORT = 0x0040; -pub const RTL_HEAP_SETTABLE_FLAG3: USHORT = 0x0080; -pub const RTL_HEAP_SETTABLE_FLAGS: USHORT = 0x00e0; -pub const RTL_HEAP_UNCOMMITTED_RANGE: USHORT = 0x0100; -pub const RTL_HEAP_PROTECTED_ENTRY: USHORT = 0x0200; -STRUCT!{struct RTL_HEAP_TAG { - NumberOfAllocations: ULONG, - NumberOfFrees: ULONG, - BytesAllocated: SIZE_T, - TagIndex: USHORT, - CreatorBackTraceIndex: USHORT, - TagName: [WCHAR; 24], +pub const RTL_HEAP_BUSY: c_ushort = 0x0001; +pub const RTL_HEAP_SEGMENT: c_ushort = 0x0002; +pub const RTL_HEAP_SETTABLE_VALUE: c_ushort = 0x0010; +pub const RTL_HEAP_SETTABLE_FLAG1: c_ushort = 0x0020; +pub const RTL_HEAP_SETTABLE_FLAG2: c_ushort = 0x0040; +pub const RTL_HEAP_SETTABLE_FLAG3: c_ushort = 0x0080; +pub const RTL_HEAP_SETTABLE_FLAGS: c_ushort = 0x00e0; +pub const RTL_HEAP_UNCOMMITTED_RANGE: c_ushort = 0x0100; +pub const RTL_HEAP_PROTECTED_ENTRY: c_ushort = 0x0200; +STRUCT! {struct RTL_HEAP_TAG { + NumberOfAllocations: c_ulong, + NumberOfFrees: c_ulong, + BytesAllocated: usize, + TagIndex: c_ushort, + CreatorBackTraceIndex: c_ushort, + TagName: [wchar_t; 24], }} pub type PRTL_HEAP_TAG = *mut RTL_HEAP_TAG; -STRUCT!{struct RTL_HEAP_INFORMATION { - BaseAddress: PVOID, - Flags: ULONG, - EntryOverhead: USHORT, - CreatorBackTraceIndex: USHORT, - BytesAllocated: SIZE_T, - BytesCommitted: SIZE_T, - NumberOfTags: ULONG, - NumberOfEntries: ULONG, - NumberOfPseudoTags: ULONG, - PseudoTagGranularity: ULONG, - Reserved: [ULONG; 5], +STRUCT! {struct RTL_HEAP_INFORMATION { + BaseAddress: *mut c_void, + Flags: c_ulong, + EntryOverhead: c_ushort, + CreatorBackTraceIndex: c_ushort, + BytesAllocated: usize, + BytesCommitted: usize, + NumberOfTags: c_ulong, + NumberOfEntries: c_ulong, + NumberOfPseudoTags: c_ulong, + PseudoTagGranularity: c_ulong, + Reserved: [c_ulong; 5], Tags: PRTL_HEAP_TAG, Entries: PRTL_HEAP_ENTRY, }} pub type PRTL_HEAP_INFORMATION = *mut RTL_HEAP_INFORMATION; -STRUCT!{struct RTL_PROCESS_HEAPS { - NumberOfHeaps: ULONG, +STRUCT! {struct RTL_PROCESS_HEAPS { + NumberOfHeaps: c_ulong, Heaps: [RTL_HEAP_INFORMATION; 1], }} pub type PRTL_PROCESS_HEAPS = *mut RTL_PROCESS_HEAPS; -FN!{stdcall PRTL_HEAP_COMMIT_ROUTINE( - Base: PVOID, - CommitAddress: *mut PVOID, - CommitSize: PSIZE_T, +FN! {stdcall PRTL_HEAP_COMMIT_ROUTINE( + Base: *mut c_void, + CommitAddress: *mut *mut c_void, + CommitSize: *mut usize, ) -> NTSTATUS} -STRUCT!{struct RTL_HEAP_PARAMETERS { - Length: ULONG, - SegmentReserve: SIZE_T, - SegmentCommit: SIZE_T, - DeCommitFreeBlockThreshold: SIZE_T, - DeCommitTotalFreeThreshold: SIZE_T, - MaximumAllocationSize: SIZE_T, - VirtualMemoryThreshold: SIZE_T, - InitialCommit: SIZE_T, - InitialReserve: SIZE_T, +STRUCT! {struct RTL_HEAP_PARAMETERS { + Length: c_ulong, + SegmentReserve: usize, + SegmentCommit: usize, + DeCommitFreeBlockThreshold: usize, + DeCommitTotalFreeThreshold: usize, + MaximumAllocationSize: usize, + VirtualMemoryThreshold: usize, + InitialCommit: usize, + InitialReserve: usize, CommitRoutine: PRTL_HEAP_COMMIT_ROUTINE, - Reserved: [SIZE_T; 2], + Reserved: [usize; 2], }} pub type PRTL_HEAP_PARAMETERS = *mut RTL_HEAP_PARAMETERS; -pub const HEAP_SETTABLE_USER_VALUE: ULONG = 0x00000100; -pub const HEAP_SETTABLE_USER_FLAG1: ULONG = 0x00000200; -pub const HEAP_SETTABLE_USER_FLAG2: ULONG = 0x00000400; -pub const HEAP_SETTABLE_USER_FLAG3: ULONG = 0x00000800; -pub const HEAP_SETTABLE_USER_FLAGS: ULONG = 0x00000e00; -pub const HEAP_CLASS_0: ULONG = 0x00000000; -pub const HEAP_CLASS_1: ULONG = 0x00001000; -pub const HEAP_CLASS_2: ULONG = 0x00002000; -pub const HEAP_CLASS_3: ULONG = 0x00003000; -pub const HEAP_CLASS_4: ULONG = 0x00004000; -pub const HEAP_CLASS_5: ULONG = 0x00005000; -pub const HEAP_CLASS_6: ULONG = 0x00006000; -pub const HEAP_CLASS_7: ULONG = 0x00007000; -pub const HEAP_CLASS_8: ULONG = 0x00008000; -pub const HEAP_CLASS_MASK: ULONG = 0x0000f000; -EXTERN!{extern "system" { +pub const HEAP_SETTABLE_USER_VALUE: c_ulong = 0x00000100; +pub const HEAP_SETTABLE_USER_FLAG1: c_ulong = 0x00000200; +pub const HEAP_SETTABLE_USER_FLAG2: c_ulong = 0x00000400; +pub const HEAP_SETTABLE_USER_FLAG3: c_ulong = 0x00000800; +pub const HEAP_SETTABLE_USER_FLAGS: c_ulong = 0x00000e00; +pub const HEAP_CLASS_0: c_ulong = 0x00000000; +pub const HEAP_CLASS_1: c_ulong = 0x00001000; +pub const HEAP_CLASS_2: c_ulong = 0x00002000; +pub const HEAP_CLASS_3: c_ulong = 0x00003000; +pub const HEAP_CLASS_4: c_ulong = 0x00004000; +pub const HEAP_CLASS_5: c_ulong = 0x00005000; +pub const HEAP_CLASS_6: c_ulong = 0x00006000; +pub const HEAP_CLASS_7: c_ulong = 0x00007000; +pub const HEAP_CLASS_8: c_ulong = 0x00008000; +pub const HEAP_CLASS_MASK: c_ulong = 0x0000f000; +EXTERN! {extern "system" { fn RtlCreateHeap( - Flags: ULONG, - HeapBase: PVOID, - ReserveSize: SIZE_T, - CommitSize: SIZE_T, - Lock: PVOID, + Flags: c_ulong, + HeapBase: *mut c_void, + ReserveSize: usize, + CommitSize: usize, + Lock: *mut c_void, Parameters: PRTL_HEAP_PARAMETERS, - ) -> PVOID; + ) -> *mut c_void; fn RtlDestroyHeap( - HeapHandle: PVOID, - ) -> PVOID; + HeapHandle: *mut c_void, + ) -> *mut c_void; fn RtlAllocateHeap( - HeapHandle: PVOID, - Flags: ULONG, - Size: SIZE_T, - ) -> PVOID; + HeapHandle: *mut c_void, + Flags: c_ulong, + Size: usize, + ) -> *mut c_void; fn RtlFreeHeap( - HeapHandle: PVOID, - Flags: ULONG, - BaseAddress: PVOID, - ) -> BOOLEAN; + HeapHandle: *mut c_void, + Flags: c_ulong, + BaseAddress: *mut c_void, + ) -> c_uchar; fn RtlSizeHeap( - HeapHandle: PVOID, - Flags: ULONG, - BaseAddress: PVOID, - ) -> SIZE_T; + HeapHandle: *mut c_void, + Flags: c_ulong, + BaseAddress: *mut c_void, + ) -> usize; fn RtlZeroHeap( - HeapHandle: PVOID, - Flags: ULONG, + HeapHandle: *mut c_void, + Flags: c_ulong, ) -> NTSTATUS; fn RtlProtectHeap( - HeapHandle: PVOID, - MakeReadOnly: BOOLEAN, + HeapHandle: *mut c_void, + MakeReadOnly: c_uchar, ); }} -#[inline] #[cfg(not(target_arch = "aarch64"))] -pub unsafe fn RtlProcessHeap() -> PVOID { +#[inline] +#[cfg(not(target_arch = "aarch64"))] +pub unsafe fn RtlProcessHeap() -> *mut c_void { use crate::ntpsapi::NtCurrentPeb; (*NtCurrentPeb()).ProcessHeap } -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlLockHeap( - HeapHandle: PVOID, - ) -> BOOLEAN; + HeapHandle: *mut c_void, + ) -> c_uchar; fn RtlUnlockHeap( - HeapHandle: PVOID, - ) -> BOOLEAN; + HeapHandle: *mut c_void, + ) -> c_uchar; fn RtlReAllocateHeap( - HeapHandle: PVOID, - Flags: ULONG, - BaseAddress: PVOID, - Size: SIZE_T, - ) -> PVOID; + HeapHandle: *mut c_void, + Flags: c_ulong, + BaseAddress: *mut c_void, + Size: usize, + ) -> *mut c_void; fn RtlGetUserInfoHeap( - HeapHandle: PVOID, - Flags: ULONG, - BaseAddress: PVOID, - UserValue: *mut PVOID, - UserFlags: PULONG, - ) -> BOOLEAN; + HeapHandle: *mut c_void, + Flags: c_ulong, + BaseAddress: *mut c_void, + UserValue: *mut *mut c_void, + UserFlags: *mut c_ulong, + ) -> c_uchar; fn RtlSetUserValueHeap( - HeapHandle: PVOID, - Flags: ULONG, - BaseAddress: PVOID, - UserValue: PVOID, - ) -> BOOLEAN; + HeapHandle: *mut c_void, + Flags: c_ulong, + BaseAddress: *mut c_void, + UserValue: *mut c_void, + ) -> c_uchar; fn RtlSetUserFlagsHeap( - HeapHandle: PVOID, - Flags: ULONG, - BaseAddress: PVOID, - UserFlagsReset: ULONG, - UserFlagsSet: ULONG, - ) -> BOOLEAN; -}} -STRUCT!{struct RTL_HEAP_TAG_INFO { - NumberOfAllocations: ULONG, - NumberOfFrees: ULONG, - BytesAllocated: SIZE_T, + HeapHandle: *mut c_void, + Flags: c_ulong, + BaseAddress: *mut c_void, + UserFlagsReset: c_ulong, + UserFlagsSet: c_ulong, + ) -> c_uchar; +}} +STRUCT! {struct RTL_HEAP_TAG_INFO { + NumberOfAllocations: c_ulong, + NumberOfFrees: c_ulong, + BytesAllocated: usize, }} pub type PRTL_HEAP_TAG_INFO = *mut RTL_HEAP_TAG_INFO; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlCreateTagHeap( - HeapHandle: PVOID, - Flags: ULONG, - TagPrefix: PWSTR, - TagNames: PWSTR, - ) -> ULONG; + HeapHandle: *mut c_void, + Flags: c_ulong, + TagPrefix: *mut wchar_t, + TagNames: *mut wchar_t, + ) -> c_ulong; fn RtlQueryTagHeap( - HeapHandle: PVOID, - Flags: ULONG, - TagIndex: USHORT, - ResetCounters: BOOLEAN, + HeapHandle: *mut c_void, + Flags: c_ulong, + TagIndex: c_ushort, + ResetCounters: c_uchar, TagInfo: PRTL_HEAP_TAG_INFO, - ) -> PWSTR; + ) -> *mut wchar_t; fn RtlExtendHeap( - HeapHandle: PVOID, - Flags: ULONG, - Base: PVOID, - Size: SIZE_T, + HeapHandle: *mut c_void, + Flags: c_ulong, + Base: *mut c_void, + Size: usize, ) -> NTSTATUS; fn RtlCompactHeap( - HeapHandle: PVOID, - Flags: ULONG, - ) -> SIZE_T; + HeapHandle: *mut c_void, + Flags: c_ulong, + ) -> usize; fn RtlValidateHeap( - HeapHandle: PVOID, - Flags: ULONG, - BaseAddress: PVOID, - ) -> BOOLEAN; - fn RtlValidateProcessHeaps() -> BOOLEAN; + HeapHandle: *mut c_void, + Flags: c_ulong, + BaseAddress: *mut c_void, + ) -> c_uchar; + fn RtlValidateProcessHeaps() -> c_uchar; fn RtlGetProcessHeaps( - NumberOfHeaps: ULONG, - ProcessHeaps: *mut PVOID, - ) -> ULONG; + NumberOfHeaps: c_ulong, + ProcessHeaps: *mut *mut c_void, + ) -> c_ulong; }} -FN!{stdcall PRTL_ENUM_HEAPS_ROUTINE( - HeapHandle: PVOID, - Parameter: PVOID, +FN! {stdcall PRTL_ENUM_HEAPS_ROUTINE( + HeapHandle: *mut c_void, + Parameter: *mut c_void, ) -> NTSTATUS} -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlEnumProcessHeaps( EnumRoutine: PRTL_ENUM_HEAPS_ROUTINE, - Parameter: PVOID, + Parameter: *mut c_void, ) -> NTSTATUS; }} -STRUCT!{struct RTL_HEAP_USAGE_ENTRY { +STRUCT! {struct RTL_HEAP_USAGE_ENTRY { Next: *mut RTL_HEAP_USAGE_ENTRY, - Address: PVOID, - Size: SIZE_T, - AllocatorBackTraceIndex: USHORT, - TagIndex: USHORT, + Address: *mut c_void, + Size: usize, + AllocatorBackTraceIndex: c_ushort, + TagIndex: c_ushort, }} pub type PRTL_HEAP_USAGE_ENTRY = *mut RTL_HEAP_USAGE_ENTRY; -STRUCT!{struct RTL_HEAP_USAGE { - Length: ULONG, - BytesAllocated: SIZE_T, - BytesCommitted: SIZE_T, - BytesReserved: SIZE_T, - BytesReservedMaximum: SIZE_T, +STRUCT! {struct RTL_HEAP_USAGE { + Length: c_ulong, + BytesAllocated: usize, + BytesCommitted: usize, + BytesReserved: usize, + BytesReservedMaximum: usize, Entries: PRTL_HEAP_USAGE_ENTRY, AddedEntries: PRTL_HEAP_USAGE_ENTRY, RemovedEntries: PRTL_HEAP_USAGE_ENTRY, - Reserved: [ULONG_PTR; 8], + Reserved: [usize; 8], }} pub type PRTL_HEAP_USAGE = *mut RTL_HEAP_USAGE; -pub const HEAP_USAGE_ALLOCATED_BLOCKS: ULONG = HEAP_REALLOC_IN_PLACE_ONLY; -pub const HEAP_USAGE_FREE_BUFFER: ULONG = HEAP_ZERO_MEMORY; -EXTERN!{extern "system" { +pub const HEAP_USAGE_ALLOCATED_BLOCKS: c_ulong = HEAP_REALLOC_IN_PLACE_ONLY; +pub const HEAP_USAGE_FREE_BUFFER: c_ulong = HEAP_ZERO_MEMORY; +EXTERN! {extern "system" { fn RtlUsageHeap( - HeapHandle: PVOID, - Flags: ULONG, + HeapHandle: *mut c_void, + Flags: c_ulong, Usage: PRTL_HEAP_USAGE, ) -> NTSTATUS; }} -STRUCT!{struct RTL_HEAP_WALK_ENTRY_u_Block { - Settable: SIZE_T, - TagIndex: USHORT, - AllocatorBackTraceIndex: USHORT, - Reserved: [ULONG; 2], +STRUCT! {struct RTL_HEAP_WALK_ENTRY_u_Block { + Settable: usize, + TagIndex: c_ushort, + AllocatorBackTraceIndex: c_ushort, + Reserved: [c_ulong; 2], }} -STRUCT!{struct RTL_HEAP_WALK_ENTRY_u_Segment { - CommittedSize: ULONG, - UnCommittedSize: ULONG, - FirstEntry: PVOID, - LastEntry: PVOID, +STRUCT! {struct RTL_HEAP_WALK_ENTRY_u_Segment { + CommittedSize: c_ulong, + UnCommittedSize: c_ulong, + FirstEntry: *mut c_void, + LastEntry: *mut c_void, }} -UNION!{union RTL_HEAP_WALK_ENTRY_u { +UNION! {union RTL_HEAP_WALK_ENTRY_u { Block: RTL_HEAP_WALK_ENTRY_u_Block, Segment: RTL_HEAP_WALK_ENTRY_u_Segment, }} -STRUCT!{struct RTL_HEAP_WALK_ENTRY { - DataAddress: PVOID, - DataSize: SIZE_T, - OverheadBytes: UCHAR, - SegmentIndex: UCHAR, - Flags: USHORT, +STRUCT! {struct RTL_HEAP_WALK_ENTRY { + DataAddress: *mut c_void, + DataSize: usize, + OverheadBytes: c_uchar, + SegmentIndex: c_uchar, + Flags: c_ushort, u: RTL_HEAP_WALK_ENTRY_u, }} pub type PRTL_HEAP_WALK_ENTRY = *mut RTL_HEAP_WALK_ENTRY; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlWalkHeap( - HeapHandle: PVOID, + HeapHandle: *mut c_void, Entry: PRTL_HEAP_WALK_ENTRY, ) -> NTSTATUS; }} pub const HeapDetailedFailureInformation: u32 = 0x80000001; pub const HeapSetDebuggingInformation: u32 = 0x80000002; -ENUM!{enum HEAP_COMPATIBILITY_MODE { +ENUM! {enum HEAP_COMPATIBILITY_MODE { HEAP_COMPATIBILITY_STANDARD = 0, HEAP_COMPATIBILITY_LAL = 1, HEAP_COMPATIBILITY_LFH = 2, }} -STRUCT!{struct PROCESS_HEAP_INFORMATION { - ReserveSize: ULONG_PTR, - CommitSize: ULONG_PTR, - NumberOfHeaps: ULONG, - FirstHeapInformationOffset: ULONG_PTR, +STRUCT! {struct PROCESS_HEAP_INFORMATION { + ReserveSize: usize, + CommitSize: usize, + NumberOfHeaps: c_ulong, + FirstHeapInformationOffset: usize, }} pub type PPROCESS_HEAP_INFORMATION = *mut PROCESS_HEAP_INFORMATION; -STRUCT!{struct HEAP_INFORMATION { - Address: ULONG_PTR, - Mode: ULONG, - ReserveSize: ULONG_PTR, - CommitSize: ULONG_PTR, - FirstRegionInformationOffset: ULONG_PTR, - NextHeapInformationOffset: ULONG_PTR, +STRUCT! {struct HEAP_INFORMATION { + Address: usize, + Mode: c_ulong, + ReserveSize: usize, + CommitSize: usize, + FirstRegionInformationOffset: usize, + NextHeapInformationOffset: usize, }} pub type PHEAP_INFORMATION = *mut HEAP_INFORMATION; -UNION!{union HEAP_EXTENDED_INFORMATION_u { +UNION! {union HEAP_EXTENDED_INFORMATION_u { ProcessHeapInformation: PROCESS_HEAP_INFORMATION, HeapInformation: HEAP_INFORMATION, }} -STRUCT!{struct HEAP_EXTENDED_INFORMATION { +STRUCT! {struct HEAP_EXTENDED_INFORMATION { Process: HANDLE, - Heap: ULONG_PTR, - Level: ULONG, - CallbackRoutine: PVOID, - CallbackContext: PVOID, + Heap: usize, + Level: c_ulong, + CallbackRoutine: *mut c_void, + CallbackContext: *mut c_void, u: HEAP_EXTENDED_INFORMATION_u, }} pub type PHEAP_EXTENDED_INFORMATION = *mut HEAP_EXTENDED_INFORMATION; -FN!{stdcall PRTL_HEAP_LEAK_ENUMERATION_ROUTINE( - Reserved: LONG, - HeapHandle: PVOID, - BaseAddress: PVOID, - BlockSize: SIZE_T, - StackTraceDepth: ULONG, - StackTrace: *mut PVOID, +FN! {stdcall PRTL_HEAP_LEAK_ENUMERATION_ROUTINE( + Reserved: c_long, + HeapHandle: *mut c_void, + BaseAddress: *mut c_void, + BlockSize: usize, + StackTraceDepth: c_ulong, + StackTrace: *mut *mut c_void, ) -> NTSTATUS} -STRUCT!{struct HEAP_DEBUGGING_INFORMATION { - InterceptorFunction: PVOID, - InterceptorValue: USHORT, - ExtendedOptions: ULONG, - StackTraceDepth: ULONG, - MinTotalBlockSize: SIZE_T, - MaxTotalBlockSize: SIZE_T, +STRUCT! {struct HEAP_DEBUGGING_INFORMATION { + InterceptorFunction: *mut c_void, + InterceptorValue: c_ushort, + ExtendedOptions: c_ulong, + StackTraceDepth: c_ulong, + MinTotalBlockSize: usize, + MaxTotalBlockSize: usize, HeapLeakEnumerationRoutine: PRTL_HEAP_LEAK_ENUMERATION_ROUTINE, }} pub type PHEAP_DEBUGGING_INFORMATION = *mut HEAP_DEBUGGING_INFORMATION; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlQueryHeapInformation( - HeapHandle: PVOID, + HeapHandle: *mut c_void, HeapInformationClass: HEAP_INFORMATION_CLASS, - HeapInformation: PVOID, - HeapInformationLength: SIZE_T, - ReturnLength: PSIZE_T, + HeapInformation: *mut c_void, + HeapInformationLength: usize, + ReturnLength: *mut usize, ) -> NTSTATUS; fn RtlSetHeapInformation( - HeapHandle: PVOID, + HeapHandle: *mut c_void, HeapInformationClass: HEAP_INFORMATION_CLASS, - HeapInformation: PVOID, - HeapInformationLength: SIZE_T, + HeapInformation: *mut c_void, + HeapInformationLength: usize, ) -> NTSTATUS; fn RtlMultipleAllocateHeap( - HeapHandle: PVOID, - Flags: ULONG, - Size: SIZE_T, - Count: ULONG, - Array: *mut PVOID, - ) -> ULONG; + HeapHandle: *mut c_void, + Flags: c_ulong, + Size: usize, + Count: c_ulong, + Array: *mut *mut c_void, + ) -> c_ulong; fn RtlMultipleFreeHeap( - HeapHandle: PVOID, - Flags: ULONG, - Count: ULONG, - Array: *mut PVOID, - ) -> ULONG; + HeapHandle: *mut c_void, + Flags: c_ulong, + Count: c_ulong, + Array: *mut *mut c_void, + ) -> c_ulong; fn RtlDetectHeapLeaks(); fn RtlFlushHeaps(); }} -STRUCT!{struct RTL_MEMORY_ZONE_SEGMENT { +STRUCT! {struct RTL_MEMORY_ZONE_SEGMENT { NextSegment: *mut RTL_MEMORY_ZONE_SEGMENT, - Size: SIZE_T, - Next: PVOID, - Limit: PVOID, + Size: usize, + Next: *mut c_void, + Limit: *mut c_void, }} pub type PRTL_MEMORY_ZONE_SEGMENT = *mut RTL_MEMORY_ZONE_SEGMENT; -STRUCT!{struct RTL_MEMORY_ZONE { +STRUCT! {struct RTL_MEMORY_ZONE { Segment: RTL_MEMORY_ZONE_SEGMENT, Lock: RTL_SRWLOCK, - LockCount: ULONG, + LockCount: c_ulong, FirstSegment: PRTL_MEMORY_ZONE_SEGMENT, }} pub type PRTL_MEMORY_ZONE = *mut RTL_MEMORY_ZONE; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlCreateMemoryZone( - MemoryZone: *mut PVOID, - InitialSize: SIZE_T, - Flags: ULONG, + MemoryZone: *mut *mut c_void, + InitialSize: usize, + Flags: c_ulong, ) -> NTSTATUS; fn RtlDestroyMemoryZone( - MemoryZone: PVOID, + MemoryZone: *mut c_void, ) -> NTSTATUS; fn RtlAllocateMemoryZone( - MemoryZone: PVOID, - BlockSize: SIZE_T, - Block: *mut PVOID, + MemoryZone: *mut c_void, + BlockSize: usize, + Block: *mut *mut c_void, ) -> NTSTATUS; fn RtlResetMemoryZone( - MemoryZone: PVOID, + MemoryZone: *mut c_void, ) -> NTSTATUS; fn RtlLockMemoryZone( - MemoryZone: PVOID, + MemoryZone: *mut c_void, ) -> NTSTATUS; fn RtlUnlockMemoryZone( - MemoryZone: PVOID, + MemoryZone: *mut c_void, ) -> NTSTATUS; fn RtlCreateMemoryBlockLookaside( - MemoryBlockLookaside: *mut PVOID, - Flags: ULONG, - InitialSize: ULONG, - MinimumBlockSize: ULONG, - MaximumBlockSize: ULONG, + MemoryBlockLookaside: *mut *mut c_void, + Flags: c_ulong, + InitialSize: c_ulong, + MinimumBlockSize: c_ulong, + MaximumBlockSize: c_ulong, ) -> NTSTATUS; fn RtlDestroyMemoryBlockLookaside( - MemoryBlockLookaside: PVOID, + MemoryBlockLookaside: *mut c_void, ) -> NTSTATUS; fn RtlAllocateMemoryBlockLookaside( - MemoryBlockLookaside: PVOID, - BlockSize: ULONG, - Block: *mut PVOID, + MemoryBlockLookaside: *mut c_void, + BlockSize: c_ulong, + Block: *mut *mut c_void, ) -> NTSTATUS; fn RtlFreeMemoryBlockLookaside( - MemoryBlockLookaside: PVOID, - Block: PVOID, + MemoryBlockLookaside: *mut c_void, + Block: *mut c_void, ) -> NTSTATUS; fn RtlExtendMemoryBlockLookaside( - MemoryBlockLookaside: PVOID, - Increment: ULONG, + MemoryBlockLookaside: *mut c_void, + Increment: c_ulong, ) -> NTSTATUS; fn RtlResetMemoryBlockLookaside( - MemoryBlockLookaside: PVOID, + MemoryBlockLookaside: *mut c_void, ) -> NTSTATUS; fn RtlLockMemoryBlockLookaside( - MemoryBlockLookaside: PVOID, + MemoryBlockLookaside: *mut c_void, ) -> NTSTATUS; fn RtlUnlockMemoryBlockLookaside( - MemoryBlockLookaside: PVOID, + MemoryBlockLookaside: *mut c_void, ) -> NTSTATUS; fn RtlGetCurrentTransaction() -> HANDLE; fn RtlSetCurrentTransaction( TransactionHandle: HANDLE, - ) -> LOGICAL; + ) -> c_ulong; }} #[inline] pub const fn RtlIsEqualLuid(L1: &LUID, L2: &LUID) -> bool { @@ -2513,122 +2574,128 @@ pub const fn RtlIsZeroLuid(L1: &LUID) -> bool { (L1.LowPart | L1.HighPart as u32) == 0 } #[inline] -pub const fn RtlConvertLongToLuid(Long: LONG) -> LUID { - LUID { LowPart: Long as u32, HighPart: ((Long as i64) >> 32) as i32 } +pub const fn RtlConvertLongToLuid(Long: c_long) -> LUID { + LUID { + LowPart: Long as u32, + HighPart: ((Long as i64) >> 32) as i32, + } } #[inline] -pub const fn RtlConvertUlongToLuid(Ulong: ULONG) -> LUID { - LUID { LowPart: Ulong, HighPart: 0 } +pub const fn RtlConvertUlongToLuid(Ulong: c_ulong) -> LUID { + LUID { + LowPart: Ulong, + HighPart: 0, + } } -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlCopyLuid( - DestinationLuid: PLUID, - SourceLuid: PLUID, + DestinationLuid: *mut LUID, + SourceLuid: *mut LUID, ); fn RtlCopyLuidAndAttributesArray( - Count: ULONG, - Src: PLUID_AND_ATTRIBUTES, - Dest: PLUID_AND_ATTRIBUTES, + Count: c_ulong, + Src: *mut LUID_AND_ATTRIBUTES, + Dest: *mut LUID_AND_ATTRIBUTES, ); }} -STRUCT!{struct RTL_PROCESS_VERIFIER_OPTIONS { - SizeStruct: ULONG, - Option: ULONG, - OptionData: [UCHAR; 1], +STRUCT! {struct RTL_PROCESS_VERIFIER_OPTIONS { + SizeStruct: c_ulong, + Option: c_ulong, + OptionData: [c_uchar; 1], }} pub type PRTL_PROCESS_VERIFIER_OPTIONS = *mut RTL_PROCESS_VERIFIER_OPTIONS; -UNION!{union RTL_DEBUG_INFORMATION_u { +UNION! {union RTL_DEBUG_INFORMATION_u { Modules: *mut RTL_PROCESS_MODULES, ModulesEx: *mut RTL_PROCESS_MODULE_INFORMATION_EX, }} -STRUCT!{struct RTL_DEBUG_INFORMATION { +STRUCT! {struct RTL_DEBUG_INFORMATION { SectionHandleClient: HANDLE, - ViewBaseClient: PVOID, - ViewBaseTarget: PVOID, - ViewBaseDelta: ULONG_PTR, + ViewBaseClient: *mut c_void, + ViewBaseTarget: *mut c_void, + ViewBaseDelta: usize, EventPairClient: HANDLE, EventPairTarget: HANDLE, TargetProcessId: HANDLE, TargetThreadHandle: HANDLE, - Flags: ULONG, - OffsetFree: SIZE_T, - CommitSize: SIZE_T, - ViewSize: SIZE_T, + Flags: c_ulong, + OffsetFree: usize, + CommitSize: usize, + ViewSize: usize, u: RTL_DEBUG_INFORMATION_u, BackTraces: *mut RTL_PROCESS_BACKTRACES, Heaps: *mut RTL_PROCESS_HEAPS, Locks: *mut RTL_PROCESS_LOCKS, - SpecificHeap: PVOID, + SpecificHeap: *mut c_void, TargetProcessHandle: HANDLE, VerifierOptions: PRTL_PROCESS_VERIFIER_OPTIONS, - ProcessHeap: PVOID, + ProcessHeap: *mut c_void, CriticalSectionHandle: HANDLE, CriticalSectionOwnerThread: HANDLE, - Reserved: [PVOID; 4], + Reserved: [*mut c_void; 4], }} pub type PRTL_DEBUG_INFORMATION = *mut RTL_DEBUG_INFORMATION; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlCreateQueryDebugBuffer( - MaximumCommit: ULONG, - UseEventPair: BOOLEAN, + MaximumCommit: c_ulong, + UseEventPair: c_uchar, ) -> PRTL_DEBUG_INFORMATION; fn RtlDestroyQueryDebugBuffer( Buffer: PRTL_DEBUG_INFORMATION, ) -> NTSTATUS; fn RtlCommitDebugInfo( Buffer: PRTL_DEBUG_INFORMATION, - Size: SIZE_T, - ) -> PVOID; + Size: usize, + ) -> *mut c_void; fn RtlDeCommitDebugInfo( Buffer: PRTL_DEBUG_INFORMATION, - p: PVOID, - Size: SIZE_T, + p: *mut c_void, + Size: usize, ); }} -pub const RTL_QUERY_PROCESS_MODULES: ULONG = 0x00000001; -pub const RTL_QUERY_PROCESS_BACKTRACES: ULONG = 0x00000002; -pub const RTL_QUERY_PROCESS_HEAP_SUMMARY: ULONG = 0x00000004; -pub const RTL_QUERY_PROCESS_HEAP_TAGS: ULONG = 0x00000008; -pub const RTL_QUERY_PROCESS_HEAP_ENTRIES: ULONG = 0x00000010; -pub const RTL_QUERY_PROCESS_LOCKS: ULONG = 0x00000020; -pub const RTL_QUERY_PROCESS_MODULES32: ULONG = 0x00000040; -pub const RTL_QUERY_PROCESS_VERIFIER_OPTIONS: ULONG = 0x00000080; -pub const RTL_QUERY_PROCESS_MODULESEX: ULONG = 0x00000100; -pub const RTL_QUERY_PROCESS_HEAP_ENTRIES_EX: ULONG = 0x00000200; -pub const RTL_QUERY_PROCESS_CS_OWNER: ULONG = 0x00000400; -pub const RTL_QUERY_PROCESS_NONINVASIVE: ULONG = 0x80000000; -EXTERN!{extern "system" { +pub const RTL_QUERY_PROCESS_MODULES: c_ulong = 0x00000001; +pub const RTL_QUERY_PROCESS_BACKTRACES: c_ulong = 0x00000002; +pub const RTL_QUERY_PROCESS_HEAP_SUMMARY: c_ulong = 0x00000004; +pub const RTL_QUERY_PROCESS_HEAP_TAGS: c_ulong = 0x00000008; +pub const RTL_QUERY_PROCESS_HEAP_ENTRIES: c_ulong = 0x00000010; +pub const RTL_QUERY_PROCESS_LOCKS: c_ulong = 0x00000020; +pub const RTL_QUERY_PROCESS_MODULES32: c_ulong = 0x00000040; +pub const RTL_QUERY_PROCESS_VERIFIER_OPTIONS: c_ulong = 0x00000080; +pub const RTL_QUERY_PROCESS_MODULESEX: c_ulong = 0x00000100; +pub const RTL_QUERY_PROCESS_HEAP_ENTRIES_EX: c_ulong = 0x00000200; +pub const RTL_QUERY_PROCESS_CS_OWNER: c_ulong = 0x00000400; +pub const RTL_QUERY_PROCESS_NONINVASIVE: c_ulong = 0x80000000; +EXTERN! {extern "system" { fn RtlQueryProcessDebugInformation( UniqueProcessId: HANDLE, - Flags: ULONG, + Flags: c_ulong, Buffer: PRTL_DEBUG_INFORMATION, ) -> NTSTATUS; fn RtlFindMessage( - DllHandle: PVOID, - MessageTableId: ULONG, - MessageLanguageId: ULONG, - MessageId: ULONG, - MessageEntry: *mut PMESSAGE_RESOURCE_ENTRY, + DllHandle: *mut c_void, + MessageTableId: c_ulong, + MessageLanguageId: c_ulong, + MessageId: c_ulong, + MessageEntry: *mut *mut MESSAGE_RESOURCE_ENTRY, ) -> NTSTATUS; fn RtlFormatMessage( - MessageFormat: PWSTR, - MaximumWidth: ULONG, - IgnoreInserts: BOOLEAN, - ArgumentsAreAnsi: BOOLEAN, - ArgumentsAreAnArray: BOOLEAN, - Arguments: *mut va_list, - Buffer: PWSTR, - Length: ULONG, - ReturnLength: PULONG, - ) -> NTSTATUS; -}} -STRUCT!{struct PARSE_MESSAGE_CONTEXT { - fFlags: ULONG, - cwSavColumn: ULONG, - iwSrc: SIZE_T, - iwDst: SIZE_T, - iwDstSpace: SIZE_T, - lpvArgStart: va_list, + MessageFormat: *mut wchar_t, + MaximumWidth: c_ulong, + IgnoreInserts: c_uchar, + ArgumentsAreAnsi: c_uchar, + ArgumentsAreAnArray: c_uchar, + Arguments: *mut *mut c_char, + Buffer: *mut wchar_t, + Length: c_ulong, + ReturnLength: *mut c_ulong, + ) -> NTSTATUS; +}} +STRUCT! {struct PARSE_MESSAGE_CONTEXT { + fFlags: c_ulong, + cwSavColumn: c_ulong, + iwSrc: usize, + iwDst: usize, + iwDstSpace: usize, + lpvArgStart: *mut c_char, }} pub type PPARSE_MESSAGE_CONTEXT = *mut PARSE_MESSAGE_CONTEXT; #[inline] @@ -2636,218 +2703,227 @@ pub fn INIT_PARSE_MESSAGE_CONTEXT(ctx: &mut PARSE_MESSAGE_CONTEXT) { ctx.fFlags = 0; } #[inline] -pub fn TEST_PARSE_MESSAGE_CONTEXT_FLAG(ctx: &mut PARSE_MESSAGE_CONTEXT, flag: ULONG) -> ULONG { +pub fn TEST_PARSE_MESSAGE_CONTEXT_FLAG( + ctx: &mut PARSE_MESSAGE_CONTEXT, + flag: c_ulong, +) -> c_ulong { ctx.fFlags & flag } #[inline] -pub fn SET_PARSE_MESSAGE_CONTEXT_FLAG(ctx: &mut PARSE_MESSAGE_CONTEXT, flag: ULONG) -> ULONG { +pub fn SET_PARSE_MESSAGE_CONTEXT_FLAG( + ctx: &mut PARSE_MESSAGE_CONTEXT, + flag: c_ulong, +) -> c_ulong { ctx.fFlags |= flag; ctx.fFlags } #[inline] -pub fn CLEAR_PARSE_MESSAGE_CONTEXT_FLAG(ctx: &mut PARSE_MESSAGE_CONTEXT, flag: ULONG) -> ULONG { +pub fn CLEAR_PARSE_MESSAGE_CONTEXT_FLAG( + ctx: &mut PARSE_MESSAGE_CONTEXT, + flag: c_ulong, +) -> c_ulong { ctx.fFlags &= !flag; ctx.fFlags } -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlFormatMessageEx( - MessageFormat: PWSTR, - MaximumWidth: ULONG, - IgnoreInserts: BOOLEAN, - ArgumentsAreAnsi: BOOLEAN, - ArgumentsAreAnArray: BOOLEAN, - Arguments: *mut va_list, - Buffer: PWSTR, - Length: ULONG, - ReturnLength: PULONG, + MessageFormat: *mut wchar_t, + MaximumWidth: c_ulong, + IgnoreInserts: c_uchar, + ArgumentsAreAnsi: c_uchar, + ArgumentsAreAnArray: c_uchar, + Arguments: *mut *mut c_char, + Buffer: *mut wchar_t, + Length: c_ulong, + ReturnLength: *mut c_ulong, ParseContext: PPARSE_MESSAGE_CONTEXT, ) -> NTSTATUS; fn RtlNtStatusToDosError( Status: NTSTATUS, - ) -> ULONG; + ) -> c_ulong; fn RtlNtStatusToDosErrorNoTeb( Status: NTSTATUS, - ) -> ULONG; + ) -> c_ulong; fn RtlGetLastNtStatus() -> NTSTATUS; - fn RtlGetLastWin32Error() -> LONG; + fn RtlGetLastWin32Error() -> c_long; fn RtlSetLastWin32ErrorAndNtStatusFromNtStatus( Status: NTSTATUS, ); fn RtlSetLastWin32Error( - Win32Error: LONG, + Win32Error: c_long, ); fn RtlRestoreLastWin32Error( - Win32Error: LONG, + Win32Error: c_long, ); }} -pub const RTL_ERRORMODE_FAILCRITICALERRORS: ULONG = 0x0010; -pub const RTL_ERRORMODE_NOGPFAULTERRORBOX: ULONG = 0x0020; -pub const RTL_ERRORMODE_NOOPENFILEERRORBOX: ULONG = 0x0040; -EXTERN!{extern "system" { - fn RtlGetThreadErrorMode() -> ULONG; +pub const RTL_ERRORMODE_FAILCRITICALERRORS: c_ulong = 0x0010; +pub const RTL_ERRORMODE_NOGPFAULTERRORBOX: c_ulong = 0x0020; +pub const RTL_ERRORMODE_NOOPENFILEERRORBOX: c_ulong = 0x0040; +EXTERN! {extern "system" { + fn RtlGetThreadErrorMode() -> c_ulong; fn RtlSetThreadErrorMode( - NewMode: ULONG, - OldMode: PULONG, + NewMode: c_ulong, + OldMode: *mut c_ulong, ) -> NTSTATUS; fn RtlReportException( - ExceptionRecord: PEXCEPTION_RECORD, - ContextRecord: PCONTEXT, - Flags: ULONG, + ExceptionRecord: *mut EXCEPTION_RECORD, + ContextRecord: *mut CONTEXT, + Flags: c_ulong, ) -> NTSTATUS; fn RtlReportExceptionEx( - ExceptionRecord: PEXCEPTION_RECORD, - ContextRecord: PCONTEXT, - Flags: ULONG, - Timeout: PLARGE_INTEGER, + ExceptionRecord: *mut EXCEPTION_RECORD, + ContextRecord: *mut CONTEXT, + Flags: c_ulong, + Timeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn RtlWerpReportException( - ProcessId: ULONG, + ProcessId: c_ulong, CrashReportSharedMem: HANDLE, - Flags: ULONG, - CrashVerticalProcessHandle: PHANDLE, + Flags: c_ulong, + CrashVerticalProcessHandle: *mut HANDLE, ) -> NTSTATUS; fn RtlReportSilentProcessExit( ProcessHandle: HANDLE, ExitStatus: NTSTATUS, ) -> NTSTATUS; fn RtlUniform( - Seed: PULONG, - ) -> ULONG; + Seed: *mut c_ulong, + ) -> c_ulong; fn RtlRandom( - Seed: PULONG, - ) -> ULONG; + Seed: *mut c_ulong, + ) -> c_ulong; fn RtlRandomEx( - Seed: PULONG, - ) -> ULONG; + Seed: *mut c_ulong, + ) -> c_ulong; fn RtlComputeImportTableHash( FileHandle: HANDLE, - Hash: PCHAR, - ImportTableHashRevision: ULONG, + Hash: *mut c_char, + ImportTableHashRevision: c_ulong, ) -> NTSTATUS; fn RtlIntegerToChar( - Value: ULONG, - Base: ULONG, - OutputLength: LONG, - String: PSTR, + Value: c_ulong, + Base: c_ulong, + OutputLength: c_long, + String: *mut c_char, ) -> NTSTATUS; fn RtlCharToInteger( - String: PCSZ, - Base: ULONG, - Value: PULONG, + String: *const c_char, + Base: c_ulong, + Value: *mut c_ulong, ) -> NTSTATUS; fn RtlLargeIntegerToChar( - Value: PLARGE_INTEGER, - Base: ULONG, - OutputLength: LONG, - String: PSTR, + Value: *mut LARGE_INTEGER, + Base: c_ulong, + OutputLength: c_long, + String: *mut c_char, ) -> NTSTATUS; fn RtlIntegerToUnicodeString( - Value: ULONG, - Base: ULONG, - String: PUNICODE_STRING, + Value: c_ulong, + Base: c_ulong, + String: *mut UNICODE_STRING, ) -> NTSTATUS; fn RtlInt64ToUnicodeString( - Value: ULONGLONG, - Base: ULONG, - String: PUNICODE_STRING, + Value: __uint64, + Base: c_ulong, + String: *mut UNICODE_STRING, ) -> NTSTATUS; fn RtlUnicodeStringToInteger( - String: PCUNICODE_STRING, - Base: ULONG, - Value: PULONG, + String: *const UNICODE_STRING, + Base: c_ulong, + Value: *mut c_ulong, ) -> NTSTATUS; fn RtlIpv4AddressToStringExW( - Address: *const in_addr, - Port: USHORT, - AddressString: PWSTR, - AddressStringLength: PULONG, + Address: *const IN_ADDR, + Port: c_ushort, + AddressString: *mut wchar_t, + AddressStringLength: *mut c_ulong, ) -> NTSTATUS; fn RtlIpv6AddressToStringExW( - Address: *const in6_addr, - ScopeId: ULONG, - Port: USHORT, - AddressString: PWSTR, - AddressStringLength: PULONG, + Address: *const IN6_ADDR, + ScopeId: c_ulong, + Port: c_ushort, + AddressString: *mut wchar_t, + AddressStringLength: *mut c_ulong, ) -> NTSTATUS; fn RtlIpv4StringToAddressExW( - AddressString: PCWSTR, - Strict: BOOLEAN, - Address: *mut in_addr, - Port: PUSHORT, + AddressString: *const wchar_t, + Strict: c_uchar, + Address: *mut IN_ADDR, + Port: *mut c_ushort, ) -> NTSTATUS; fn RtlIpv6StringToAddressExW( - AddressString: PCWSTR, - Address: *mut in6_addr, - ScopeId: PULONG, - Port: PUSHORT, - ) -> NTSTATUS; -}} -STRUCT!{struct TIME_FIELDS { - Year: CSHORT, - Month: CSHORT, - Day: CSHORT, - Hour: CSHORT, - Minute: CSHORT, - Second: CSHORT, - Milliseconds: CSHORT, - Weekday: CSHORT, + AddressString: *const wchar_t, + Address: *mut IN6_ADDR, + ScopeId: *mut c_ulong, + Port: *mut c_ushort, + ) -> NTSTATUS; +}} +STRUCT! {struct TIME_FIELDS { + Year: c_short, + Month: c_short, + Day: c_short, + Hour: c_short, + Minute: c_short, + Second: c_short, + Milliseconds: c_short, + Weekday: c_short, }} pub type PTIME_FIELDS = *mut TIME_FIELDS; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlCutoverTimeToSystemTime( CutoverTime: PTIME_FIELDS, - SystemTime: PLARGE_INTEGER, - CurrentSystemTime: PLARGE_INTEGER, - ThisYear: BOOLEAN, - ) -> BOOLEAN; + SystemTime: *mut LARGE_INTEGER, + CurrentSystemTime: *mut LARGE_INTEGER, + ThisYear: c_uchar, + ) -> c_uchar; fn RtlSystemTimeToLocalTime( - SystemTime: PLARGE_INTEGER, - LocalTime: PLARGE_INTEGER, + SystemTime: *mut LARGE_INTEGER, + LocalTime: *mut LARGE_INTEGER, ) -> NTSTATUS; fn RtlLocalTimeToSystemTime( - LocalTime: PLARGE_INTEGER, - SystemTime: PLARGE_INTEGER, + LocalTime: *mut LARGE_INTEGER, + SystemTime: *mut LARGE_INTEGER, ) -> NTSTATUS; fn RtlTimeToElapsedTimeFields( - Time: PLARGE_INTEGER, + Time: *mut LARGE_INTEGER, TimeFields: PTIME_FIELDS, ); fn RtlTimeToTimeFields( - Time: PLARGE_INTEGER, + Time: *mut LARGE_INTEGER, TimeFields: PTIME_FIELDS, ); fn RtlTimeFieldsToTime( TimeFields: PTIME_FIELDS, - Time: PLARGE_INTEGER, - ) -> BOOLEAN; + Time: *mut LARGE_INTEGER, + ) -> c_uchar; fn RtlTimeToSecondsSince1980( - Time: PLARGE_INTEGER, - ElapsedSeconds: PULONG, - ) -> BOOLEAN; + Time: *mut LARGE_INTEGER, + ElapsedSeconds: *mut c_ulong, + ) -> c_uchar; fn RtlSecondsSince1980ToTime( - ElapsedSeconds: ULONG, - Time: PLARGE_INTEGER, + ElapsedSeconds: c_ulong, + Time: *mut LARGE_INTEGER, ); fn RtlTimeToSecondsSince1970( - Time: PLARGE_INTEGER, - ElapsedSeconds: PULONG, - ) -> BOOLEAN; + Time: *mut LARGE_INTEGER, + ElapsedSeconds: *mut c_ulong, + ) -> c_uchar; fn RtlSecondsSince1970ToTime( - ElapsedSeconds: ULONG, - Time: PLARGE_INTEGER, + ElapsedSeconds: c_ulong, + Time: *mut LARGE_INTEGER, ); }} -STRUCT!{struct RTL_TIME_ZONE_INFORMATION { - Bias: LONG, - StandardName: [WCHAR; 32], +STRUCT! {struct RTL_TIME_ZONE_INFORMATION { + Bias: c_long, + StandardName: [wchar_t; 32], StandardStart: TIME_FIELDS, - StandardBias: LONG, - DaylightName: [WCHAR; 32], + StandardBias: c_long, + DaylightName: [wchar_t; 32], DaylightStart: TIME_FIELDS, - DaylightBias: LONG, + DaylightBias: c_long, }} pub type PRTL_TIME_ZONE_INFORMATION = *mut RTL_TIME_ZONE_INFORMATION; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlQueryTimeZoneInformation( TimeZoneInformation: PRTL_TIME_ZONE_INFORMATION, ) -> NTSTATUS; @@ -2855,29 +2931,29 @@ EXTERN!{extern "system" { TimeZoneInformation: PRTL_TIME_ZONE_INFORMATION, ) -> NTSTATUS; }} -STRUCT!{struct RTL_BITMAP { - SizeOfBitMap: ULONG, - Buffer: PULONG, +STRUCT! {struct RTL_BITMAP { + SizeOfBitMap: c_ulong, + Buffer: *mut c_ulong, }} pub type PRTL_BITMAP = *mut RTL_BITMAP; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlInitializeBitMap( BitMapHeader: PRTL_BITMAP, - BitMapBuffer: PULONG, - SizeOfBitMap: ULONG, + BitMapBuffer: *mut c_ulong, + SizeOfBitMap: c_ulong, ); fn RtlClearBit( BitMapHeader: PRTL_BITMAP, - BitNumber: ULONG, + BitNumber: c_ulong, ); fn RtlSetBit( BitMapHeader: PRTL_BITMAP, - BitNumber: ULONG, + BitNumber: c_ulong, ); fn RtlTestBit( BitMapHeader: PRTL_BITMAP, - BitNumber: ULONG, - ) -> BOOLEAN; + BitNumber: c_ulong, + ) -> c_uchar; fn RtlClearAllBits( BitMapHeader: PRTL_BITMAP, ); @@ -2886,190 +2962,200 @@ EXTERN!{extern "system" { ); fn RtlFindClearBits( BitMapHeader: PRTL_BITMAP, - NumberToFind: ULONG, - HintIndex: ULONG, - ) -> ULONG; + NumberToFind: c_ulong, + HintIndex: c_ulong, + ) -> c_ulong; fn RtlFindSetBits( BitMapHeader: PRTL_BITMAP, - NumberToFind: ULONG, - HintIndex: ULONG, - ) -> ULONG; + NumberToFind: c_ulong, + HintIndex: c_ulong, + ) -> c_ulong; fn RtlFindClearBitsAndSet( BitMapHeader: PRTL_BITMAP, - NumberToFind: ULONG, - HintIndex: ULONG, - ) -> ULONG; + NumberToFind: c_ulong, + HintIndex: c_ulong, + ) -> c_ulong; fn RtlFindSetBitsAndClear( BitMapHeader: PRTL_BITMAP, - NumberToFind: ULONG, - HintIndex: ULONG, - ) -> ULONG; + NumberToFind: c_ulong, + HintIndex: c_ulong, + ) -> c_ulong; fn RtlClearBits( BitMapHeader: PRTL_BITMAP, - StartingIndex: ULONG, - NumberToClear: ULONG, + StartingIndex: c_ulong, + NumberToClear: c_ulong, ); fn RtlSetBits( BitMapHeader: PRTL_BITMAP, - StartingIndex: ULONG, - NumberToSet: ULONG, + StartingIndex: c_ulong, + NumberToSet: c_ulong, ); fn RtlFindMostSignificantBit( - Set: ULONGLONG, - ) -> CCHAR; + Set: __uint64, + ) -> c_char; fn RtlFindLeastSignificantBit( - Set: ULONGLONG, - ) -> CCHAR; + Set: __uint64, + ) -> c_char; }} -STRUCT!{struct RTL_BITMAP_RUN { - StartingIndex: ULONG, - NumberOfBits: ULONG, +STRUCT! {struct RTL_BITMAP_RUN { + StartingIndex: c_ulong, + NumberOfBits: c_ulong, }} pub type PRTL_BITMAP_RUN = *mut RTL_BITMAP_RUN; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlFindClearRuns( BitMapHeader: PRTL_BITMAP, RunArray: PRTL_BITMAP_RUN, - SizeOfRunArray: ULONG, - LocateLongestRuns: BOOLEAN, - ) -> ULONG; + SizeOfRunArray: c_ulong, + LocateLongestRuns: c_uchar, + ) -> c_ulong; fn RtlFindLongestRunClear( BitMapHeader: PRTL_BITMAP, - StartingIndex: PULONG, - ) -> ULONG; + StartingIndex: *mut c_ulong, + ) -> c_ulong; fn RtlFindFirstRunClear( BitMapHeader: PRTL_BITMAP, - StartingIndex: PULONG, - ) -> ULONG; + StartingIndex: *mut c_ulong, + ) -> c_ulong; }} #[inline] -pub unsafe fn RtlCheckBit(BitMapHeader: &RTL_BITMAP, BitPosition: ULONG) -> u8 { - #[cfg(target_arch = "x86_64")] { - core::arch::x86_64::_bittest64(BitMapHeader.Buffer as *const i64, BitPosition as i64) +pub unsafe fn RtlCheckBit( + BitMapHeader: &RTL_BITMAP, + BitPosition: c_ulong, +) -> u8 { + #[cfg(target_arch = "x86_64")] + { + core::arch::x86_64::_bittest64( + BitMapHeader.Buffer as *const i64, + BitPosition as i64, + ) } - #[cfg(any(target_arch = "x86", target_arch = "aarch64"))] { - (*BitMapHeader.Buffer.offset(BitPosition as isize / 32) >> (BitPosition % 32) & 1) as u8 + #[cfg(any(target_arch = "x86", target_arch = "aarch64"))] + { + (*BitMapHeader.Buffer.offset(BitPosition as isize / 32) + >> (BitPosition % 32) + & 1) as u8 } } -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlNumberOfClearBits( BitMapHeader: PRTL_BITMAP, - ) -> ULONG; + ) -> c_ulong; fn RtlNumberOfSetBits( BitMapHeader: PRTL_BITMAP, - ) -> ULONG; + ) -> c_ulong; fn RtlAreBitsClear( BitMapHeader: PRTL_BITMAP, - StartingIndex: ULONG, - Length: ULONG, - ) -> BOOLEAN; + StartingIndex: c_ulong, + Length: c_ulong, + ) -> c_uchar; fn RtlAreBitsSet( BitMapHeader: PRTL_BITMAP, - StartingIndex: ULONG, - Length: ULONG, - ) -> BOOLEAN; + StartingIndex: c_ulong, + Length: c_ulong, + ) -> c_uchar; fn RtlFindNextForwardRunClear( BitMapHeader: PRTL_BITMAP, - FromIndex: ULONG, - StartingRunIndex: PULONG, - ) -> ULONG; + FromIndex: c_ulong, + StartingRunIndex: *mut c_ulong, + ) -> c_ulong; fn RtlFindLastBackwardRunClear( BitMapHeader: PRTL_BITMAP, - FromIndex: ULONG, - StartingRunIndex: PULONG, - ) -> ULONG; + FromIndex: c_ulong, + StartingRunIndex: *mut c_ulong, + ) -> c_ulong; fn RtlNumberOfSetBitsUlongPtr( - Target: ULONG_PTR, - ) -> ULONG; + Target: usize, + ) -> c_ulong; fn RtlInterlockedClearBitRun( BitMapHeader: PRTL_BITMAP, - StartingIndex: ULONG, - NumberToClear: ULONG, + StartingIndex: c_ulong, + NumberToClear: c_ulong, ); fn RtlInterlockedSetBitRun( BitMapHeader: PRTL_BITMAP, - StartingIndex: ULONG, - NumberToSet: ULONG, + StartingIndex: c_ulong, + NumberToSet: c_ulong, ); fn RtlCopyBitMap( Source: PRTL_BITMAP, Destination: PRTL_BITMAP, - TargetBit: ULONG, + TargetBit: c_ulong, ); fn RtlExtractBitMap( Source: PRTL_BITMAP, Destination: PRTL_BITMAP, - TargetBit: ULONG, - NumberOfBits: ULONG, + TargetBit: c_ulong, + NumberOfBits: c_ulong, ); fn RtlNumberOfClearBitsInRange( BitMapHeader: PRTL_BITMAP, - StartingIndex: ULONG, - Length: ULONG, - ) -> ULONG; + StartingIndex: c_ulong, + Length: c_ulong, + ) -> c_ulong; fn RtlNumberOfSetBitsInRange( BitMapHeader: PRTL_BITMAP, - StartingIndex: ULONG, - Length: ULONG, - ) -> ULONG; + StartingIndex: c_ulong, + Length: c_ulong, + ) -> c_ulong; }} -STRUCT!{struct RTL_BITMAP_EX { - SizeOfBitMap: ULONG64, - Buffer: PULONG64, +STRUCT! {struct RTL_BITMAP_EX { + SizeOfBitMap: __uint64, + Buffer: *mut __uint64, }} pub type PRTL_BITMAP_EX = *mut RTL_BITMAP_EX; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlInitializeBitMapEx( BitMapHeader: PRTL_BITMAP_EX, - BitMapBuffer: PULONG64, - SizeOfBitMap: ULONG64, + BitMapBuffer: *mut __uint64, + SizeOfBitMap: __uint64, ); fn RtlTestBitEx( BitMapHeader: PRTL_BITMAP_EX, - BitNumber: ULONG64, - ) -> BOOLEAN; + BitNumber: __uint64, + ) -> c_uchar; fn RtlClearAllBitsEx( BitMapHeader: PRTL_BITMAP_EX, ); fn RtlClearBitEx( BitMapHeader: PRTL_BITMAP_EX, - BitNumber: ULONG64, + BitNumber: __uint64, ); fn RtlSetBitEx( BitMapHeader: PRTL_BITMAP_EX, - BitNumber: ULONG64, + BitNumber: __uint64, ); fn RtlFindSetBitsEx( BitMapHeader: PRTL_BITMAP_EX, - NumberToFind: ULONG64, - HintIndex: ULONG64, - ) -> ULONG64; + NumberToFind: __uint64, + HintIndex: __uint64, + ) -> __uint64; fn RtlFindSetBitsAndClearEx( BitMapHeader: PRTL_BITMAP_EX, - NumberToFind: ULONG64, - HintIndex: ULONG64, - ) -> ULONG64; + NumberToFind: __uint64, + HintIndex: __uint64, + ) -> __uint64; }} -UNION!{union RTL_HANDLE_TABLE_ENTRY { - Flags: ULONG, +UNION! {union RTL_HANDLE_TABLE_ENTRY { + Flags: c_ulong, NextFree: *mut RTL_HANDLE_TABLE_ENTRY, }} pub type PRTL_HANDLE_TABLE_ENTRY = *mut RTL_HANDLE_TABLE_ENTRY; -pub const RTL_HANDLE_ALLOCATED: USHORT = 0x0001; -STRUCT!{struct RTL_HANDLE_TABLE { - MaximumNumberOfHandles: ULONG, - SizeOfHandleTableEntry: ULONG, - Reserved: [ULONG; 2], +pub const RTL_HANDLE_ALLOCATED: c_ushort = 0x0001; +STRUCT! {struct RTL_HANDLE_TABLE { + MaximumNumberOfHandles: c_ulong, + SizeOfHandleTableEntry: c_ulong, + Reserved: [c_ulong; 2], FreeHandles: PRTL_HANDLE_TABLE_ENTRY, CommittedHandles: PRTL_HANDLE_TABLE_ENTRY, UnCommittedHandles: PRTL_HANDLE_TABLE_ENTRY, MaxReservedHandles: PRTL_HANDLE_TABLE_ENTRY, }} pub type PRTL_HANDLE_TABLE = *mut RTL_HANDLE_TABLE; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlInitializeHandleTable( - MaximumNumberOfHandles: ULONG, - SizeOfHandleTableEntry: ULONG, + MaximumNumberOfHandles: c_ulong, + SizeOfHandleTableEntry: c_ulong, HandleTable: PRTL_HANDLE_TABLE, ); fn RtlDestroyHandleTable( @@ -3077,222 +3163,222 @@ EXTERN!{extern "system" { ) -> NTSTATUS; fn RtlAllocateHandle( HandleTable: PRTL_HANDLE_TABLE, - HandleIndex: PULONG, + HandleIndex: *mut c_ulong, ) -> PRTL_HANDLE_TABLE_ENTRY; fn RtlFreeHandle( HandleTable: PRTL_HANDLE_TABLE, Handle: PRTL_HANDLE_TABLE_ENTRY, - ) -> BOOLEAN; + ) -> c_uchar; fn RtlIsValidHandle( HandleTable: PRTL_HANDLE_TABLE, Handle: PRTL_HANDLE_TABLE_ENTRY, - ) -> BOOLEAN; + ) -> c_uchar; fn RtlIsValidIndexHandle( HandleTable: PRTL_HANDLE_TABLE, - HandleIndex: ULONG, + HandleIndex: c_ulong, Handle: *mut PRTL_HANDLE_TABLE_ENTRY, - ) -> BOOLEAN; + ) -> c_uchar; }} pub const RTL_ATOM_MAXIMUM_INTEGER_ATOM: RTL_ATOM = 0xc000; pub const RTL_ATOM_INVALID_ATOM: RTL_ATOM = 0x0000; pub const RTL_ATOM_TABLE_DEFAULT_NUMBER_OF_BUCKETS: u32 = 37; pub const RTL_ATOM_MAXIMUM_NAME_LENGTH: u32 = 255; pub const RTL_ATOM_PINNED: u32 = 0x01; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlCreateAtomTable( - NumberOfBuckets: ULONG, - AtomTableHandle: *mut PVOID, + NumberOfBuckets: c_ulong, + AtomTableHandle: *mut *mut c_void, ) -> NTSTATUS; fn RtlDestroyAtomTable( - AtomTableHandle: PVOID, + AtomTableHandle: *mut c_void, ) -> NTSTATUS; fn RtlEmptyAtomTable( - AtomTableHandle: PVOID, - IncludePinnedAtoms: BOOLEAN, + AtomTableHandle: *mut c_void, + IncludePinnedAtoms: c_uchar, ) -> NTSTATUS; fn RtlAddAtomToAtomTable( - AtomTableHandle: PVOID, - AtomName: PWSTR, + AtomTableHandle: *mut c_void, + AtomName: *mut wchar_t, Atom: PRTL_ATOM, ) -> NTSTATUS; fn RtlLookupAtomInAtomTable( - AtomTableHandle: PVOID, - AtomName: PWSTR, + AtomTableHandle: *mut c_void, + AtomName: *mut wchar_t, Atom: PRTL_ATOM, ) -> NTSTATUS; fn RtlDeleteAtomFromAtomTable( - AtomTableHandle: PVOID, + AtomTableHandle: *mut c_void, Atom: RTL_ATOM, ) -> NTSTATUS; fn RtlPinAtomInAtomTable( - AtomTableHandle: PVOID, + AtomTableHandle: *mut c_void, Atom: RTL_ATOM, ) -> NTSTATUS; fn RtlQueryAtomInAtomTable( - AtomTableHandle: PVOID, + AtomTableHandle: *mut c_void, Atom: RTL_ATOM, - AtomUsage: PULONG, - AtomFlags: PULONG, - AtomName: PWSTR, - AtomNameLength: PULONG, + AtomUsage: *mut c_ulong, + AtomFlags: *mut c_ulong, + AtomName: *mut wchar_t, + AtomNameLength: *mut c_ulong, ) -> NTSTATUS; fn RtlGetIntegerAtom( - AtomName: PWSTR, - IntegerAtom: PUSHORT, - ) -> BOOLEAN; + AtomName: *mut wchar_t, + IntegerAtom: *mut c_ushort, + ) -> c_uchar; fn RtlValidSid( Sid: PSID, - ) -> BOOLEAN; + ) -> c_uchar; fn RtlEqualSid( Sid1: PSID, Sid2: PSID, - ) -> BOOLEAN; + ) -> c_uchar; fn RtlEqualPrefixSid( Sid1: PSID, Sid2: PSID, - ) -> BOOLEAN; + ) -> c_uchar; fn RtlLengthRequiredSid( - SubAuthorityCount: ULONG, - ) -> ULONG; + SubAuthorityCount: c_ulong, + ) -> c_ulong; fn RtlFreeSid( Sid: PSID, - ) -> PVOID; + ) -> *mut c_void; fn RtlAllocateAndInitializeSid( - IdentifierAuthority: PSID_IDENTIFIER_AUTHORITY, - SubAuthorityCount: UCHAR, - SubAuthority0: ULONG, - SubAuthority1: ULONG, - SubAuthority2: ULONG, - SubAuthority3: ULONG, - SubAuthority4: ULONG, - SubAuthority5: ULONG, - SubAuthority6: ULONG, - SubAuthority7: ULONG, + IdentifierAuthority: *mut SID_IDENTIFIER_AUTHORITY, + SubAuthorityCount: c_uchar, + SubAuthority0: c_ulong, + SubAuthority1: c_ulong, + SubAuthority2: c_ulong, + SubAuthority3: c_ulong, + SubAuthority4: c_ulong, + SubAuthority5: c_ulong, + SubAuthority6: c_ulong, + SubAuthority7: c_ulong, Sid: *mut PSID, ) -> NTSTATUS; fn RtlInitializeSid( Sid: PSID, - IdentifierAuthority: PSID_IDENTIFIER_AUTHORITY, - SubAuthorityCount: UCHAR, + IdentifierAuthority: *mut SID_IDENTIFIER_AUTHORITY, + SubAuthorityCount: c_uchar, ) -> NTSTATUS; }} -EXTERN!{extern "C" { +EXTERN! {extern "C" { fn RtlInitializeSidEx( Sid: PSID, - IdentifierAuthority: PSID_IDENTIFIER_AUTHORITY, - SubAuthorityCount: UCHAR, + IdentifierAuthority: *mut SID_IDENTIFIER_AUTHORITY, + SubAuthorityCount: c_uchar, ... ) -> NTSTATUS; }} -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlIdentifierAuthoritySid( Sid: PSID, - ) -> PSID_IDENTIFIER_AUTHORITY; + ) -> *mut SID_IDENTIFIER_AUTHORITY; fn RtlSubAuthoritySid( Sid: PSID, - SubAuthority: ULONG, - ) -> PULONG; + SubAuthority: c_ulong, + ) -> *mut c_ulong; fn RtlSubAuthorityCountSid( Sid: PSID, - ) -> PUCHAR; + ) -> *mut c_uchar; fn RtlLengthSid( Sid: PSID, - ) -> ULONG; + ) -> c_ulong; fn RtlCopySid( - DestinationSidLength: ULONG, + DestinationSidLength: c_ulong, DestinationSid: PSID, SourceSid: PSID, ) -> NTSTATUS; fn RtlCopySidAndAttributesArray( - Count: ULONG, - Src: PSID_AND_ATTRIBUTES, - SidAreaSize: ULONG, - Dest: PSID_AND_ATTRIBUTES, + Count: c_ulong, + Src: *mut SID_AND_ATTRIBUTES, + SidAreaSize: c_ulong, + Dest: *mut SID_AND_ATTRIBUTES, SidArea: PSID, RemainingSidArea: *mut PSID, - RemainingSidAreaSize: PULONG, + RemainingSidAreaSize: *mut c_ulong, ) -> NTSTATUS; fn RtlCreateServiceSid( - ServiceName: PUNICODE_STRING, + ServiceName: *mut UNICODE_STRING, ServiceSid: PSID, - ServiceSidLength: PULONG, + ServiceSidLength: *mut c_ulong, ) -> NTSTATUS; fn RtlSidDominates( Sid1: PSID, Sid2: PSID, - Dominates: PBOOLEAN, + Dominates: *mut c_uchar, ) -> NTSTATUS; fn RtlSidDominatesForTrust( Sid1: PSID, Sid2: PSID, - DominatesTrust: PBOOLEAN, + DominatesTrust: *mut c_uchar, ) -> NTSTATUS; fn RtlSidEqualLevel( Sid1: PSID, Sid2: PSID, - EqualLevel: PBOOLEAN, + EqualLevel: *mut c_uchar, ) -> NTSTATUS; fn RtlSidIsHigherLevel( Sid1: PSID, Sid2: PSID, - HigherLevel: PBOOLEAN, + HigherLevel: *mut c_uchar, ) -> NTSTATUS; fn RtlCreateVirtualAccountSid( - Name: PCUNICODE_STRING, - BaseSubAuthority: ULONG, + Name: *const UNICODE_STRING, + BaseSubAuthority: c_ulong, Sid: PSID, - SidLength: PULONG, + SidLength: *mut c_ulong, ) -> NTSTATUS; fn RtlReplaceSidInSd( SecurityDescriptor: PSECURITY_DESCRIPTOR, OldSid: PSID, NewSid: PSID, - NumChanges: *mut ULONG, + NumChanges: *mut c_ulong, ) -> NTSTATUS; }} pub const MAX_UNICODE_STACK_BUFFER_LENGTH: usize = 256; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlConvertSidToUnicodeString( - UnicodeString: PUNICODE_STRING, + UnicodeString: *mut UNICODE_STRING, Sid: PSID, - AllocateDestinationString: BOOLEAN, + AllocateDestinationString: c_uchar, ) -> NTSTATUS; fn RtlSidHashInitialize( - SidAttr: PSID_AND_ATTRIBUTES, - SidCount: ULONG, - SidAttrHash: PSID_AND_ATTRIBUTES_HASH, + SidAttr: *mut SID_AND_ATTRIBUTES, + SidCount: c_ulong, + SidAttrHash: *mut SID_AND_ATTRIBUTES_HASH, ) -> NTSTATUS; fn RtlSidHashLookup( - SidAttrHash: PSID_AND_ATTRIBUTES_HASH, + SidAttrHash: *mut SID_AND_ATTRIBUTES_HASH, Sid: PSID, - ) -> PSID_AND_ATTRIBUTES; + ) -> *mut SID_AND_ATTRIBUTES; fn RtlIsElevatedRid( - SidAttr: PSID_AND_ATTRIBUTES, - ) -> BOOLEAN; + SidAttr: *mut SID_AND_ATTRIBUTES, + ) -> c_uchar; fn RtlDeriveCapabilitySidsFromName( - UnicodeString: PUNICODE_STRING, + UnicodeString: *mut UNICODE_STRING, CapabilityGroupSid: PSID, CapabilitySid: PSID, ) -> NTSTATUS; fn RtlCreateSecurityDescriptor( SecurityDescriptor: PSECURITY_DESCRIPTOR, - Revision: ULONG, + Revision: c_ulong, ) -> NTSTATUS; fn RtlValidSecurityDescriptor( SecurityDescriptor: PSECURITY_DESCRIPTOR, - ) -> BOOLEAN; + ) -> c_uchar; fn RtlLengthSecurityDescriptor( SecurityDescriptor: PSECURITY_DESCRIPTOR, - ) -> ULONG; + ) -> c_ulong; fn RtlValidRelativeSecurityDescriptor( SecurityDescriptorInput: PSECURITY_DESCRIPTOR, - SecurityDescriptorLength: ULONG, - RequiredInformation: SECURITY_INFORMATION, - ) -> BOOLEAN; + SecurityDescriptorLength: c_ulong, + RequiredInformation: c_ulong, + ) -> c_uchar; fn RtlGetControlSecurityDescriptor( SecurityDescriptor: PSECURITY_DESCRIPTOR, - Control: PSECURITY_DESCRIPTOR_CONTROL, - Revision: PULONG, + Control: *mut c_ushort, + Revision: *mut c_ulong, ) -> NTSTATUS; fn RtlSetControlSecurityDescriptor( SecurityDescriptor: PSECURITY_DESCRIPTOR, @@ -3302,290 +3388,290 @@ EXTERN!{extern "system" { fn RtlSetAttributesSecurityDescriptor( SecurityDescriptor: PSECURITY_DESCRIPTOR, Control: SECURITY_DESCRIPTOR_CONTROL, - Revision: PULONG, + Revision: *mut c_ulong, ) -> NTSTATUS; fn RtlGetSecurityDescriptorRMControl( SecurityDescriptor: PSECURITY_DESCRIPTOR, - RMControl: PUCHAR, - ) -> BOOLEAN; + RMControl: *mut c_uchar, + ) -> c_uchar; fn RtlSetSecurityDescriptorRMControl( SecurityDescriptor: PSECURITY_DESCRIPTOR, - RMControl: PUCHAR, + RMControl: *mut c_uchar, ); fn RtlSetDaclSecurityDescriptor( SecurityDescriptor: PSECURITY_DESCRIPTOR, - DaclPresent: BOOLEAN, - Dacl: PACL, - DaclDefaulted: BOOLEAN, + DaclPresent: c_uchar, + Dacl: *mut ACL, + DaclDefaulted: c_uchar, ) -> NTSTATUS; fn RtlGetDaclSecurityDescriptor( SecurityDescriptor: PSECURITY_DESCRIPTOR, - DaclPresent: PBOOLEAN, - Dacl: *mut PACL, - DaclDefaulted: PBOOLEAN, + DaclPresent: *mut c_uchar, + Dacl: *mut *mut ACL, + DaclDefaulted: *mut c_uchar, ) -> NTSTATUS; fn RtlSetSaclSecurityDescriptor( SecurityDescriptor: PSECURITY_DESCRIPTOR, - SaclPresent: BOOLEAN, - Sacl: PACL, - SaclDefaulted: BOOLEAN, + SaclPresent: c_uchar, + Sacl: *mut ACL, + SaclDefaulted: c_uchar, ) -> NTSTATUS; fn RtlGetSaclSecurityDescriptor( SecurityDescriptor: PSECURITY_DESCRIPTOR, - SaclPresent: PBOOLEAN, - Sacl: *mut PACL, - SaclDefaulted: PBOOLEAN, + SaclPresent: *mut c_uchar, + Sacl: *mut *mut ACL, + SaclDefaulted: *mut c_uchar, ) -> NTSTATUS; fn RtlSetOwnerSecurityDescriptor( SecurityDescriptor: PSECURITY_DESCRIPTOR, Owner: PSID, - OwnerDefaulted: BOOLEAN, + OwnerDefaulted: c_uchar, ) -> NTSTATUS; fn RtlGetOwnerSecurityDescriptor( SecurityDescriptor: PSECURITY_DESCRIPTOR, Owner: *mut PSID, - OwnerDefaulted: PBOOLEAN, + OwnerDefaulted: *mut c_uchar, ) -> NTSTATUS; fn RtlSetGroupSecurityDescriptor( SecurityDescriptor: PSECURITY_DESCRIPTOR, Group: PSID, - GroupDefaulted: BOOLEAN, + GroupDefaulted: c_uchar, ) -> NTSTATUS; fn RtlGetGroupSecurityDescriptor( SecurityDescriptor: PSECURITY_DESCRIPTOR, Group: *mut PSID, - GroupDefaulted: PBOOLEAN, + GroupDefaulted: *mut c_uchar, ) -> NTSTATUS; fn RtlMakeSelfRelativeSD( AbsoluteSecurityDescriptor: PSECURITY_DESCRIPTOR, SelfRelativeSecurityDescriptor: PSECURITY_DESCRIPTOR, - BufferLength: PULONG, + BufferLength: *mut c_ulong, ) -> NTSTATUS; fn RtlAbsoluteToSelfRelativeSD( AbsoluteSecurityDescriptor: PSECURITY_DESCRIPTOR, SelfRelativeSecurityDescriptor: PSECURITY_DESCRIPTOR, - BufferLength: PULONG, + BufferLength: *mut c_ulong, ) -> NTSTATUS; fn RtlSelfRelativeToAbsoluteSD( SelfRelativeSecurityDescriptor: PSECURITY_DESCRIPTOR, AbsoluteSecurityDescriptor: PSECURITY_DESCRIPTOR, - AbsoluteSecurityDescriptorSize: PULONG, - Dacl: PACL, - DaclSize: PULONG, - Sacl: PACL, - SaclSize: PULONG, + AbsoluteSecurityDescriptorSize: *mut c_ulong, + Dacl: *mut ACL, + DaclSize: *mut c_ulong, + Sacl: *mut ACL, + SaclSize: *mut c_ulong, Owner: PSID, - OwnerSize: PULONG, + OwnerSize: *mut c_ulong, PrimaryGroup: PSID, - PrimaryGroupSize: PULONG, + PrimaryGroupSize: *mut c_ulong, ) -> NTSTATUS; fn RtlSelfRelativeToAbsoluteSD2( pSelfRelativeSecurityDescriptor: PSECURITY_DESCRIPTOR, - pBufferSize: PULONG, + pBufferSize: *mut c_ulong, ) -> NTSTATUS; fn RtlAreAllAccessesGranted( - GrantedAccess: ACCESS_MASK, - DesiredAccess: ACCESS_MASK, - ) -> BOOLEAN; + GrantedAccess: c_ulong, + DesiredAccess: c_ulong, + ) -> c_uchar; fn RtlAreAnyAccessesGranted( - GrantedAccess: ACCESS_MASK, - DesiredAccess: ACCESS_MASK, - ) -> BOOLEAN; + GrantedAccess: c_ulong, + DesiredAccess: c_ulong, + ) -> c_uchar; fn RtlMapGenericMask( - AccessMask: PACCESS_MASK, - GenericMapping: PGENERIC_MAPPING, + AccessMask: *mut c_ulong, + GenericMapping: *mut GENERIC_MAPPING, ); fn RtlCreateAcl( - Acl: PACL, - AclLength: ULONG, - AclRevision: ULONG, + Acl: *mut ACL, + AclLength: c_ulong, + AclRevision: c_ulong, ) -> NTSTATUS; fn RtlValidAcl( - Acl: PACL, - ) -> BOOLEAN; + Acl: *mut ACL, + ) -> c_uchar; fn RtlQueryInformationAcl( - Acl: PACL, - AclInformation: PVOID, - AclInformationLength: ULONG, + Acl: *mut ACL, + AclInformation: *mut c_void, + AclInformationLength: c_ulong, AclInformationClass: ACL_INFORMATION_CLASS, ) -> NTSTATUS; fn RtlSetInformationAcl( - Acl: PACL, - AclInformation: PVOID, - AclInformationLength: ULONG, + Acl: *mut ACL, + AclInformation: *mut c_void, + AclInformationLength: c_ulong, AclInformationClass: ACL_INFORMATION_CLASS, ) -> NTSTATUS; fn RtlAddAce( - Acl: PACL, - AceRevision: ULONG, - StartingAceIndex: ULONG, - AceList: PVOID, - AceListLength: ULONG, + Acl: *mut ACL, + AceRevision: c_ulong, + StartingAceIndex: c_ulong, + AceList: *mut c_void, + AceListLength: c_ulong, ) -> NTSTATUS; fn RtlDeleteAce( - Acl: PACL, - AceIndex: ULONG, + Acl: *mut ACL, + AceIndex: c_ulong, ) -> NTSTATUS; fn RtlGetAce( - Acl: PACL, - AceIndex: ULONG, - Ace: *mut PVOID, + Acl: *mut ACL, + AceIndex: c_ulong, + Ace: *mut *mut c_void, ) -> NTSTATUS; fn RtlFirstFreeAce( - Acl: PACL, - FirstFree: *mut PVOID, - ) -> BOOLEAN; + Acl: *mut ACL, + FirstFree: *mut *mut c_void, + ) -> c_uchar; fn RtlFindAceByType( - pAcl: PACL, - AceType: UCHAR, - pIndex: PULONG, - ) -> PVOID; + pAcl: *mut ACL, + AceType: c_uchar, + pIndex: *mut c_ulong, + ) -> *mut c_void; fn RtlOwnerAcesPresent( - pAcl: PACL, - ) -> BOOLEAN; + pAcl: *mut ACL, + ) -> c_uchar; fn RtlAddAccessAllowedAce( - Acl: PACL, - AceRevision: ULONG, - AccessMask: ACCESS_MASK, + Acl: *mut ACL, + AceRevision: c_ulong, + AccessMask: c_ulong, Sid: PSID, ) -> NTSTATUS; fn RtlAddAccessAllowedAceEx( - Acl: PACL, - AceRevision: ULONG, - AceFlags: ULONG, - AccessMask: ACCESS_MASK, + Acl: *mut ACL, + AceRevision: c_ulong, + AceFlags: c_ulong, + AccessMask: c_ulong, Sid: PSID, ) -> NTSTATUS; fn RtlAddAccessDeniedAce( - Acl: PACL, - AceRevision: ULONG, - AccessMask: ACCESS_MASK, + Acl: *mut ACL, + AceRevision: c_ulong, + AccessMask: c_ulong, Sid: PSID, ) -> NTSTATUS; fn RtlAddAccessDeniedAceEx( - Acl: PACL, - AceRevision: ULONG, - AceFlags: ULONG, - AccessMask: ACCESS_MASK, + Acl: *mut ACL, + AceRevision: c_ulong, + AceFlags: c_ulong, + AccessMask: c_ulong, Sid: PSID, ) -> NTSTATUS; fn RtlAddAuditAccessAce( - Acl: PACL, - AceRevision: ULONG, - AccessMask: ACCESS_MASK, + Acl: *mut ACL, + AceRevision: c_ulong, + AccessMask: c_ulong, Sid: PSID, - AuditSuccess: BOOLEAN, - AuditFailure: BOOLEAN, + AuditSuccess: c_uchar, + AuditFailure: c_uchar, ) -> NTSTATUS; fn RtlAddAuditAccessAceEx( - Acl: PACL, - AceRevision: ULONG, - AceFlags: ULONG, - AccessMask: ACCESS_MASK, + Acl: *mut ACL, + AceRevision: c_ulong, + AceFlags: c_ulong, + AccessMask: c_ulong, Sid: PSID, - AuditSuccess: BOOLEAN, - AuditFailure: BOOLEAN, + AuditSuccess: c_uchar, + AuditFailure: c_uchar, ) -> NTSTATUS; fn RtlAddAccessAllowedObjectAce( - Acl: PACL, - AceRevision: ULONG, - AceFlags: ULONG, - AccessMask: ACCESS_MASK, + Acl: *mut ACL, + AceRevision: c_ulong, + AceFlags: c_ulong, + AccessMask: c_ulong, ObjectTypeGuid: *mut GUID, InheritedObjectTypeGuid: *mut GUID, Sid: PSID, ) -> NTSTATUS; fn RtlAddAccessDeniedObjectAce( - Acl: PACL, - AceRevision: ULONG, - AceFlags: ULONG, - AccessMask: ACCESS_MASK, + Acl: *mut ACL, + AceRevision: c_ulong, + AceFlags: c_ulong, + AccessMask: c_ulong, ObjectTypeGuid: *mut GUID, InheritedObjectTypeGuid: *mut GUID, Sid: PSID, ) -> NTSTATUS; fn RtlAddAuditAccessObjectAce( - Acl: PACL, - AceRevision: ULONG, - AceFlags: ULONG, - AccessMask: ACCESS_MASK, + Acl: *mut ACL, + AceRevision: c_ulong, + AceFlags: c_ulong, + AccessMask: c_ulong, ObjectTypeGuid: *mut GUID, InheritedObjectTypeGuid: *mut GUID, Sid: PSID, - AuditSuccess: BOOLEAN, - AuditFailure: BOOLEAN, + AuditSuccess: c_uchar, + AuditFailure: c_uchar, ) -> NTSTATUS; fn RtlAddCompoundAce( - Acl: PACL, - AceRevision: ULONG, - AceType: UCHAR, - AccessMask: ACCESS_MASK, + Acl: *mut ACL, + AceRevision: c_ulong, + AceType: c_uchar, + AccessMask: c_ulong, ServerSid: PSID, ClientSid: PSID, ) -> NTSTATUS; fn RtlAddMandatoryAce( - Acl: PACL, - AceRevision: ULONG, - AceFlags: ULONG, + Acl: *mut ACL, + AceRevision: c_ulong, + AceFlags: c_ulong, Sid: PSID, - AceType: UCHAR, - AccessMask: ACCESS_MASK, + AceType: c_uchar, + AccessMask: c_ulong, ) -> NTSTATUS; fn RtlDefaultNpAcl( - Acl: *mut PACL, + Acl: *mut *mut ACL, ) -> NTSTATUS; fn RtlNewSecurityObject( ParentDescriptor: PSECURITY_DESCRIPTOR, CreatorDescriptor: PSECURITY_DESCRIPTOR, NewDescriptor: *mut PSECURITY_DESCRIPTOR, - IsDirectoryObject: BOOLEAN, + IsDirectoryObject: c_uchar, Token: HANDLE, - GenericMapping: PGENERIC_MAPPING, + GenericMapping: *mut GENERIC_MAPPING, ) -> NTSTATUS; fn RtlNewSecurityObjectEx( ParentDescriptor: PSECURITY_DESCRIPTOR, CreatorDescriptor: PSECURITY_DESCRIPTOR, NewDescriptor: *mut PSECURITY_DESCRIPTOR, ObjectType: *mut GUID, - IsDirectoryObject: BOOLEAN, - AutoInheritFlags: ULONG, + IsDirectoryObject: c_uchar, + AutoInheritFlags: c_ulong, Token: HANDLE, - GenericMapping: PGENERIC_MAPPING, + GenericMapping: *mut GENERIC_MAPPING, ) -> NTSTATUS; fn RtlNewSecurityObjectWithMultipleInheritance( ParentDescriptor: PSECURITY_DESCRIPTOR, CreatorDescriptor: PSECURITY_DESCRIPTOR, NewDescriptor: *mut PSECURITY_DESCRIPTOR, ObjectType: *mut *mut GUID, - GuidCount: ULONG, - IsDirectoryObject: BOOLEAN, - AutoInheritFlags: ULONG, + GuidCount: c_ulong, + IsDirectoryObject: c_uchar, + AutoInheritFlags: c_ulong, Token: HANDLE, - GenericMapping: PGENERIC_MAPPING, + GenericMapping: *mut GENERIC_MAPPING, ) -> NTSTATUS; fn RtlDeleteSecurityObject( ObjectDescriptor: *mut PSECURITY_DESCRIPTOR, ) -> NTSTATUS; fn RtlQuerySecurityObject( ObjectDescriptor: PSECURITY_DESCRIPTOR, - SecurityInformation: SECURITY_INFORMATION, + SecurityInformation: c_ulong, ResultantDescriptor: PSECURITY_DESCRIPTOR, - DescriptorLength: ULONG, - ReturnLength: PULONG, + DescriptorLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn RtlSetSecurityObject( - SecurityInformation: SECURITY_INFORMATION, + SecurityInformation: c_ulong, ModificationDescriptor: PSECURITY_DESCRIPTOR, ObjectsSecurityDescriptor: *mut PSECURITY_DESCRIPTOR, - GenericMapping: PGENERIC_MAPPING, + GenericMapping: *mut GENERIC_MAPPING, Token: HANDLE, ) -> NTSTATUS; fn RtlSetSecurityObjectEx( - SecurityInformation: SECURITY_INFORMATION, + SecurityInformation: c_ulong, ModificationDescriptor: PSECURITY_DESCRIPTOR, ObjectsSecurityDescriptor: *mut PSECURITY_DESCRIPTOR, - AutoInheritFlags: ULONG, - GenericMapping: PGENERIC_MAPPING, + AutoInheritFlags: c_ulong, + GenericMapping: *mut GENERIC_MAPPING, Token: HANDLE, ) -> NTSTATUS; fn RtlConvertToAutoInheritSecurityObject( @@ -3593,113 +3679,113 @@ EXTERN!{extern "system" { CurrentSecurityDescriptor: PSECURITY_DESCRIPTOR, NewSecurityDescriptor: *mut PSECURITY_DESCRIPTOR, ObjectType: *mut GUID, - IsDirectoryObject: BOOLEAN, - GenericMapping: PGENERIC_MAPPING, + IsDirectoryObject: c_uchar, + GenericMapping: *mut GENERIC_MAPPING, ) -> NTSTATUS; fn RtlNewInstanceSecurityObject( - ParentDescriptorChanged: BOOLEAN, - CreatorDescriptorChanged: BOOLEAN, - OldClientTokenModifiedId: PLUID, - NewClientTokenModifiedId: PLUID, + ParentDescriptorChanged: c_uchar, + CreatorDescriptorChanged: c_uchar, + OldClientTokenModifiedId: *mut LUID, + NewClientTokenModifiedId: *mut LUID, ParentDescriptor: PSECURITY_DESCRIPTOR, CreatorDescriptor: PSECURITY_DESCRIPTOR, NewDescriptor: *mut PSECURITY_DESCRIPTOR, - IsDirectoryObject: BOOLEAN, + IsDirectoryObject: c_uchar, Token: HANDLE, - GenericMapping: PGENERIC_MAPPING, + GenericMapping: *mut GENERIC_MAPPING, ) -> NTSTATUS; fn RtlCopySecurityDescriptor( InputSecurityDescriptor: PSECURITY_DESCRIPTOR, OutputSecurityDescriptor: *mut PSECURITY_DESCRIPTOR, ) -> NTSTATUS; fn RtlRunEncodeUnicodeString( - Seed: PUCHAR, - String: PUNICODE_STRING, + Seed: *mut c_uchar, + String: *mut UNICODE_STRING, ); fn RtlRunDecodeUnicodeString( - Seed: UCHAR, - String: PUNICODE_STRING, + Seed: c_uchar, + String: *mut UNICODE_STRING, ); fn RtlImpersonateSelf( ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL, ) -> NTSTATUS; fn RtlImpersonateSelfEx( ImpersonationLevel: SECURITY_IMPERSONATION_LEVEL, - AdditionalAccess: ACCESS_MASK, - ThreadToken: PHANDLE, + AdditionalAccess: c_ulong, + ThreadToken: *mut HANDLE, ) -> NTSTATUS; fn RtlAdjustPrivilege( - Privilege: ULONG, - Enable: BOOLEAN, - Client: BOOLEAN, - WasEnabled: PBOOLEAN, + Privilege: c_ulong, + Enable: c_uchar, + Client: c_uchar, + WasEnabled: *mut c_uchar, ) -> NTSTATUS; }} -pub const RTL_ACQUIRE_PRIVILEGE_REVERT: ULONG = 0x00000001; -pub const RTL_ACQUIRE_PRIVILEGE_PROCESS: ULONG = 0x00000002; -EXTERN!{extern "system" { +pub const RTL_ACQUIRE_PRIVILEGE_REVERT: c_ulong = 0x00000001; +pub const RTL_ACQUIRE_PRIVILEGE_PROCESS: c_ulong = 0x00000002; +EXTERN! {extern "system" { fn RtlAcquirePrivilege( - Privilege: PULONG, - NumPriv: ULONG, - Flags: ULONG, - ReturnedState: *mut PVOID, + Privilege: *mut c_ulong, + NumPriv: c_ulong, + Flags: c_ulong, + ReturnedState: *mut *mut c_void, ) -> NTSTATUS; fn RtlReleasePrivilege( - StatePointer: PVOID, + StatePointer: *mut c_void, ); fn RtlRemovePrivileges( TokenHandle: HANDLE, - PrivilegesToKeep: PULONG, - PrivilegeCount: ULONG, + PrivilegesToKeep: *mut c_ulong, + PrivilegeCount: c_ulong, ) -> NTSTATUS; fn RtlIsUntrustedObject( Handle: HANDLE, - Object: PVOID, - IsUntrustedObject: PBOOLEAN, + Object: *mut c_void, + IsUntrustedObject: *mut c_uchar, ) -> NTSTATUS; fn RtlQueryValidationRunlevel( - ComponentName: PUNICODE_STRING, - ) -> ULONG; + ComponentName: *mut UNICODE_STRING, + ) -> c_ulong; fn RtlCreateBoundaryDescriptor( - Name: PUNICODE_STRING, - Flags: ULONG, - ) -> PVOID; + Name: *mut UNICODE_STRING, + Flags: c_ulong, + ) -> *mut c_void; fn RtlDeleteBoundaryDescriptor( - BoundaryDescriptor: PVOID, + BoundaryDescriptor: *mut c_void, ); fn RtlAddSIDToBoundaryDescriptor( - BoundaryDescriptor: *mut PVOID, + BoundaryDescriptor: *mut *mut c_void, RequiredSid: PSID, ) -> NTSTATUS; fn RtlAddIntegrityLabelToBoundaryDescriptor( - BoundaryDescriptor: *mut PVOID, + BoundaryDescriptor: *mut *mut c_void, IntegrityLabel: PSID, ) -> NTSTATUS; fn RtlGetVersion( - lpVersionInformation: PRTL_OSVERSIONINFOW, + lpVersionInformation: *mut OSVERSIONINFOW, ) -> NTSTATUS; fn RtlVerifyVersionInfo( - VersionInfo: PRTL_OSVERSIONINFOEXW, - TypeMask: ULONG, - ConditionMask: ULONGLONG, + VersionInfo: *mut OSVERSIONINFOEXW, + TypeMask: c_ulong, + ConditionMask: __uint64, ) -> NTSTATUS; fn RtlGetNtVersionNumbers( - NtMajorVersion: PULONG, - NtMinorVersion: PULONG, - NtBuildNumber: PULONG, + NtMajorVersion: *mut c_ulong, + NtMinorVersion: *mut c_ulong, + NtBuildNumber: *mut c_ulong, ); - fn RtlGetNtGlobalFlags() -> ULONG; + fn RtlGetNtGlobalFlags() -> c_ulong; fn RtlGetNtProductType( - NtProductType: PNT_PRODUCT_TYPE, - ) -> BOOLEAN; - fn RtlGetSuiteMask() -> ULONG; + NtProductType: *mut NT_PRODUCT_TYPE, + ) -> c_uchar; + fn RtlGetSuiteMask() -> c_ulong; fn RtlRegisterWait( - WaitHandle: PHANDLE, + WaitHandle: *mut HANDLE, Handle: HANDLE, - Function: WAITORTIMERCALLBACKFUNC, - Context: PVOID, - Milliseconds: ULONG, - Flags: ULONG, + Function: WAITORTIMERCALLBACK, + Context: *mut c_void, + Milliseconds: c_ulong, + Flags: c_ulong, ) -> NTSTATUS; fn RtlDeregisterWait( WaitHandle: HANDLE, @@ -3710,53 +3796,53 @@ EXTERN!{extern "system" { ) -> NTSTATUS; fn RtlQueueWorkItem( Function: WORKERCALLBACKFUNC, - Context: PVOID, - Flags: ULONG, + Context: *mut c_void, + Flags: c_ulong, ) -> NTSTATUS; fn RtlSetIoCompletionCallback( FileHandle: HANDLE, CompletionProc: APC_CALLBACK_FUNCTION, - Flags: ULONG, + Flags: c_ulong, ) -> NTSTATUS; }} -FN!{stdcall PRTL_START_POOL_THREAD( - Function: PTHREAD_START_ROUTINE, - Parameter: PVOID, - ThreadHandle: PHANDLE, +FN! {stdcall PRTL_START_POOL_THREAD( + Function: LPTHREAD_START_ROUTINE, + Parameter: *mut c_void, + ThreadHandle: *mut HANDLE, ) -> NTSTATUS} -FN!{stdcall PRTL_EXIT_POOL_THREAD( +FN! {stdcall PRTL_EXIT_POOL_THREAD( ExitStatus: NTSTATUS, ) -> NTSTATUS} -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlSetThreadPoolStartFunc( StartPoolThread: PRTL_START_POOL_THREAD, ExitPoolThread: PRTL_EXIT_POOL_THREAD, ) -> NTSTATUS; fn RtlUserThreadStart( - Function: PTHREAD_START_ROUTINE, - Parameter: PVOID, + Function: LPTHREAD_START_ROUTINE, + Parameter: *mut c_void, ); fn LdrInitializeThunk( - ContextRecord: PCONTEXT, - Parameter: PVOID, + ContextRecord: *mut CONTEXT, + Parameter: *mut c_void, ); fn RtlCreateTimerQueue( - TimerQueueHandle: PHANDLE, + TimerQueueHandle: *mut HANDLE, ) -> NTSTATUS; fn RtlCreateTimer( TimerQueueHandle: HANDLE, - Handle: PHANDLE, - Function: WAITORTIMERCALLBACKFUNC, - Context: PVOID, - DueTime: ULONG, - Period: ULONG, - Flags: ULONG, + Handle: *mut HANDLE, + Function: WAITORTIMERCALLBACK, + Context: *mut c_void, + DueTime: c_ulong, + Period: c_ulong, + Flags: c_ulong, ) -> NTSTATUS; fn RtlUpdateTimer( TimerQueueHandle: HANDLE, TimerHandle: HANDLE, - DueTime: ULONG, - Period: ULONG, + DueTime: c_ulong, + Period: c_ulong, ) -> NTSTATUS; fn RtlDeleteTimer( TimerQueueHandle: HANDLE, @@ -3771,156 +3857,156 @@ EXTERN!{extern "system" { Event: HANDLE, ) -> NTSTATUS; fn RtlFormatCurrentUserKeyPath( - CurrentUserKeyPath: PUNICODE_STRING, + CurrentUserKeyPath: *mut UNICODE_STRING, ) -> NTSTATUS; fn RtlOpenCurrentUser( - DesiredAccess: ACCESS_MASK, - CurrentUserKey: PHANDLE, - ) -> NTSTATUS; -}} -pub const RTL_REGISTRY_ABSOLUTE: ULONG = 0; -pub const RTL_REGISTRY_SERVICES: ULONG = 1; -pub const RTL_REGISTRY_CONTROL: ULONG = 2; -pub const RTL_REGISTRY_WINDOWS_NT: ULONG = 3; -pub const RTL_REGISTRY_DEVICEMAP: ULONG = 4; -pub const RTL_REGISTRY_USER: ULONG = 5; -pub const RTL_REGISTRY_MAXIMUM: ULONG = 6; -pub const RTL_REGISTRY_HANDLE: ULONG = 0x40000000; -pub const RTL_REGISTRY_OPTIONAL: ULONG = 0x80000000; -EXTERN!{extern "system" { + DesiredAccess: c_ulong, + CurrentUserKey: *mut HANDLE, + ) -> NTSTATUS; +}} +pub const RTL_REGISTRY_ABSOLUTE: c_ulong = 0; +pub const RTL_REGISTRY_SERVICES: c_ulong = 1; +pub const RTL_REGISTRY_CONTROL: c_ulong = 2; +pub const RTL_REGISTRY_WINDOWS_NT: c_ulong = 3; +pub const RTL_REGISTRY_DEVICEMAP: c_ulong = 4; +pub const RTL_REGISTRY_USER: c_ulong = 5; +pub const RTL_REGISTRY_MAXIMUM: c_ulong = 6; +pub const RTL_REGISTRY_HANDLE: c_ulong = 0x40000000; +pub const RTL_REGISTRY_OPTIONAL: c_ulong = 0x80000000; +EXTERN! {extern "system" { fn RtlCreateRegistryKey( - RelativeTo: ULONG, - Path: PWSTR, + RelativeTo: c_ulong, + Path: *mut wchar_t, ) -> NTSTATUS; fn RtlCheckRegistryKey( - RelativeTo: ULONG, - Path: PWSTR, + RelativeTo: c_ulong, + Path: *mut wchar_t, ) -> NTSTATUS; }} -FN!{stdcall PRTL_QUERY_REGISTRY_ROUTINE( - ValueName: PWSTR, - ValueType: ULONG, - ValueData: PVOID, - ValueLength: ULONG, - Context: PVOID, - EntryContext: PVOID, +FN! {stdcall PRTL_QUERY_REGISTRY_ROUTINE( + ValueName: *mut wchar_t, + ValueType: c_ulong, + ValueData: *mut c_void, + ValueLength: c_ulong, + Context: *mut c_void, + EntryContext: *mut c_void, ) -> NTSTATUS} -STRUCT!{struct RTL_QUERY_REGISTRY_TABLE { +STRUCT! {struct RTL_QUERY_REGISTRY_TABLE { QueryRoutine: PRTL_QUERY_REGISTRY_ROUTINE, - Flags: ULONG, - Name: PWSTR, - EntryContext: PVOID, - DefaultType: ULONG, - DefaultData: PVOID, - DefaultLength: ULONG, + Flags: c_ulong, + Name: *mut wchar_t, + EntryContext: *mut c_void, + DefaultType: c_ulong, + DefaultData: *mut c_void, + DefaultLength: c_ulong, }} pub type PRTL_QUERY_REGISTRY_TABLE = *mut RTL_QUERY_REGISTRY_TABLE; -pub const RTL_QUERY_REGISTRY_SUBKEY: ULONG = 0x00000001; -pub const RTL_QUERY_REGISTRY_TOPKEY: ULONG = 0x00000002; -pub const RTL_QUERY_REGISTRY_REQUIRED: ULONG = 0x00000004; -pub const RTL_QUERY_REGISTRY_NOVALUE: ULONG = 0x00000008; -pub const RTL_QUERY_REGISTRY_NOEXPAND: ULONG = 0x00000010; -pub const RTL_QUERY_REGISTRY_DIRECT: ULONG = 0x00000020; -pub const RTL_QUERY_REGISTRY_DELETE: ULONG = 0x00000040; -EXTERN!{extern "system" { +pub const RTL_QUERY_REGISTRY_SUBKEY: c_ulong = 0x00000001; +pub const RTL_QUERY_REGISTRY_TOPKEY: c_ulong = 0x00000002; +pub const RTL_QUERY_REGISTRY_REQUIRED: c_ulong = 0x00000004; +pub const RTL_QUERY_REGISTRY_NOVALUE: c_ulong = 0x00000008; +pub const RTL_QUERY_REGISTRY_NOEXPAND: c_ulong = 0x00000010; +pub const RTL_QUERY_REGISTRY_DIRECT: c_ulong = 0x00000020; +pub const RTL_QUERY_REGISTRY_DELETE: c_ulong = 0x00000040; +EXTERN! {extern "system" { fn RtlQueryRegistryValues( - RelativeTo: ULONG, - Path: PCWSTR, + RelativeTo: c_ulong, + Path: *const wchar_t, QueryTable: PRTL_QUERY_REGISTRY_TABLE, - Context: PVOID, - Environment: PVOID, + Context: *mut c_void, + Environment: *mut c_void, ) -> NTSTATUS; fn RtlQueryRegistryValuesEx( - RelativeTo: ULONG, - Path: PWSTR, + RelativeTo: c_ulong, + Path: *mut wchar_t, QueryTable: PRTL_QUERY_REGISTRY_TABLE, - Context: PVOID, - Environment: PVOID, + Context: *mut c_void, + Environment: *mut c_void, ) -> NTSTATUS; fn RtlWriteRegistryValue( - RelativeTo: ULONG, - Path: PCWSTR, - ValueName: PCWSTR, - ValueType: ULONG, - ValueData: PVOID, - ValueLength: ULONG, + RelativeTo: c_ulong, + Path: *const wchar_t, + ValueName: *const wchar_t, + ValueType: c_ulong, + ValueData: *mut c_void, + ValueLength: c_ulong, ) -> NTSTATUS; fn RtlDeleteRegistryValue( - RelativeTo: ULONG, - Path: PCWSTR, - ValueName: PCWSTR, + RelativeTo: c_ulong, + Path: *const wchar_t, + ValueName: *const wchar_t, ) -> NTSTATUS; fn RtlEnableThreadProfiling( ThreadHandle: HANDLE, - Flags: ULONG, - HardwareCounters: ULONG64, - PerformanceDataHandle: *mut PVOID, + Flags: c_ulong, + HardwareCounters: __uint64, + PerformanceDataHandle: *mut *mut c_void, ) -> NTSTATUS; fn RtlDisableThreadProfiling( - PerformanceDataHandle: PVOID, + PerformanceDataHandle: *mut c_void, ) -> NTSTATUS; fn RtlQueryThreadProfiling( ThreadHandle: HANDLE, - Enabled: PBOOLEAN, + Enabled: *mut c_uchar, ) -> NTSTATUS; fn RtlReadThreadProfilingData( PerformanceDataHandle: HANDLE, - Flags: ULONG, - PerformanceData: PPERFORMANCE_DATA, + Flags: c_ulong, + PerformanceData: *mut PERFORMANCE_DATA, ) -> NTSTATUS; fn RtlGetNativeSystemInformation( - SystemInformationClass: ULONG, - NativeSystemInformation: PVOID, - InformationLength: ULONG, - ReturnLength: PULONG, + SystemInformationClass: c_ulong, + NativeSystemInformation: *mut c_void, + InformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn RtlQueueApcWow64Thread( ThreadHandle: HANDLE, ApcRoutine: PPS_APC_ROUTINE, - ApcArgument1: PVOID, - ApcArgument2: PVOID, - ApcArgument3: PVOID, + ApcArgument1: *mut c_void, + ApcArgument2: *mut c_void, + ApcArgument3: *mut c_void, ) -> NTSTATUS; fn RtlWow64EnableFsRedirection( - Wow64FsEnableRedirection: BOOLEAN, + Wow64FsEnableRedirection: c_uchar, ) -> NTSTATUS; fn RtlWow64EnableFsRedirectionEx( - Wow64FsEnableRedirection: PVOID, - OldFsRedirectionLevel: *mut PVOID, + Wow64FsEnableRedirection: *mut c_void, + OldFsRedirectionLevel: *mut *mut c_void, ) -> NTSTATUS; fn RtlComputeCrc32( - PartialCrc: ULONG32, - Buffer: PVOID, - Length: ULONG, - ) -> ULONG32; + PartialCrc: c_uint, + Buffer: *mut c_void, + Length: c_ulong, + ) -> c_uint; fn RtlEncodePointer( - Ptr: PVOID, - ) -> PVOID; + Ptr: *mut c_void, + ) -> *mut c_void; fn RtlDecodePointer( - Ptr: PVOID, - ) -> PVOID; + Ptr: *mut c_void, + ) -> *mut c_void; fn RtlEncodeSystemPointer( - Ptr: PVOID, - ) -> PVOID; + Ptr: *mut c_void, + ) -> *mut c_void; fn RtlDecodeSystemPointer( - Ptr: PVOID, - ) -> PVOID; + Ptr: *mut c_void, + ) -> *mut c_void; fn RtlEncodeRemotePointer( ProcessHandle: HANDLE, - Pointer: PVOID, - EncodedPointer: *mut PVOID, + Pointer: *mut c_void, + EncodedPointer: *mut *mut c_void, ) -> NTSTATUS; fn RtlDecodeRemotePointer( ProcessHandle: HANDLE, - Pointer: PVOID, - DecodedPointer: *mut PVOID, + Pointer: *mut c_void, + DecodedPointer: *mut *mut c_void, ) -> NTSTATUS; fn RtlIsProcessorFeaturePresent( - ProcessorFeature: ULONG, - ) -> BOOLEAN; - fn RtlGetCurrentProcessorNumber() -> ULONG; + ProcessorFeature: c_ulong, + ) -> c_uchar; + fn RtlGetCurrentProcessorNumber() -> c_ulong; fn RtlGetCurrentProcessorNumberEx( - ProcessorNumber: PPROCESSOR_NUMBER, + ProcessorNumber: *mut PROCESSOR_NUMBER, ); fn RtlPushFrame( Frame: PTEB_ACTIVE_FRAME, @@ -3930,42 +4016,42 @@ EXTERN!{extern "system" { ); fn RtlGetFrame() -> PTEB_ACTIVE_FRAME; }} -pub const RTL_WALK_USER_MODE_STACK: ULONG = 0x00000001; -pub const RTL_WALK_VALID_FLAGS: ULONG = 0x00000001; -pub const RTL_STACK_WALKING_MODE_FRAMES_TO_SKIP_SHIFT: ULONG = 0x00000008; -EXTERN!{extern "system" { +pub const RTL_WALK_USER_MODE_STACK: c_ulong = 0x00000001; +pub const RTL_WALK_VALID_FLAGS: c_ulong = 0x00000001; +pub const RTL_STACK_WALKING_MODE_FRAMES_TO_SKIP_SHIFT: c_ulong = 0x00000008; +EXTERN! {extern "system" { fn RtlWalkFrameChain( - Callers: *mut PVOID, - Count: ULONG, - Flags: ULONG, - ) -> ULONG; + Callers: *mut *mut c_void, + Count: c_ulong, + Flags: c_ulong, + ) -> c_ulong; fn RtlGetCallersAddress( - CallersAddress: *mut PVOID, - CallersCaller: *mut PVOID, + CallersAddress: *mut *mut c_void, + CallersCaller: *mut *mut c_void, ); fn RtlGetEnabledExtendedFeatures( - FeatureMask: ULONG64, - ) -> ULONG64; + FeatureMask: __uint64, + ) -> __uint64; fn RtlGetEnabledExtendedAndSupervisorFeatures( - FeatureMask: ULONG64, - ) -> ULONG64; + FeatureMask: __uint64, + ) -> __uint64; fn RtlLocateSupervisorFeature( - XStateHeader: PXSAVE_AREA_HEADER, - FeatureId: ULONG, - Length: PULONG, - ) -> PVOID; + XStateHeader: *mut XSAVE_AREA_HEADER, + FeatureId: c_ulong, + Length: *mut c_ulong, + ) -> *mut c_void; }} -STRUCT!{struct RTL_ELEVATION_FLAGS { - Flags: ULONG, +STRUCT! {struct RTL_ELEVATION_FLAGS { + Flags: c_ulong, }} -BITFIELD!{RTL_ELEVATION_FLAGS Flags: ULONG [ +BITFIELD! {RTL_ELEVATION_FLAGS Flags: c_ulong [ ElevationEnabled set_ElevationEnabled[0..1], VirtualizationEnabled set_VirtualizationEnabled[1..2], InstallerDetectEnabled set_InstallerDetectEnabled[2..3], ReservedBits set_ReservedBits[3..32], ]} pub type PRTL_ELEVATION_FLAGS = *mut RTL_ELEVATION_FLAGS; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlQueryElevationFlags( Flags: PRTL_ELEVATION_FLAGS, ) -> NTSTATUS; @@ -3973,48 +4059,48 @@ EXTERN!{extern "system" { fn RtlLockCurrentThread() -> NTSTATUS; fn RtlUnlockCurrentThread() -> NTSTATUS; fn RtlLockModuleSection( - Address: PVOID, + Address: *mut c_void, ) -> NTSTATUS; fn RtlUnlockModuleSection( - Address: PVOID, + Address: *mut c_void, ) -> NTSTATUS; }} pub const RTL_UNLOAD_EVENT_TRACE_NUMBER: u32 = 64; -STRUCT!{struct RTL_UNLOAD_EVENT_TRACE { - BaseAddress: PVOID, - SizeOfImage: SIZE_T, - Sequence: ULONG, - TimeDateStamp: ULONG, - CheckSum: ULONG, - ImageName: [WCHAR; 32], - Version: [ULONG; 2], +STRUCT! {struct RTL_UNLOAD_EVENT_TRACE { + BaseAddress: *mut c_void, + SizeOfImage: usize, + Sequence: c_ulong, + TimeDateStamp: c_ulong, + CheckSum: c_ulong, + ImageName: [wchar_t; 32], + Version: [c_ulong; 2], }} pub type PRTL_UNLOAD_EVENT_TRACE = *mut RTL_UNLOAD_EVENT_TRACE; -STRUCT!{struct RTL_UNLOAD_EVENT_TRACE32 { - BaseAddress: ULONG, - SizeOfImage: ULONG, - Sequence: ULONG, - TimeDateStamp: ULONG, - CheckSum: ULONG, - ImageName: [WCHAR; 32], - Version: [ULONG; 2], +STRUCT! {struct RTL_UNLOAD_EVENT_TRACE32 { + BaseAddress: c_ulong, + SizeOfImage: c_ulong, + Sequence: c_ulong, + TimeDateStamp: c_ulong, + CheckSum: c_ulong, + ImageName: [wchar_t; 32], + Version: [c_ulong; 2], }} pub type PRTL_UNLOAD_EVENT_TRACE32 = *mut RTL_UNLOAD_EVENT_TRACE32; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlGetUnloadEventTrace() -> PRTL_UNLOAD_EVENT_TRACE; fn RtlGetUnloadEventTraceEx( - ElementSize: *mut PULONG, - ElementCount: *mut PULONG, - EventTrace: *mut PVOID, + ElementSize: *mut *mut c_ulong, + ElementCount: *mut *mut c_ulong, + EventTrace: *mut *mut c_void, ); fn RtlQueryPerformanceCounter( - PerformanceCounter: PLARGE_INTEGER, - ) -> LOGICAL; + PerformanceCounter: *mut LARGE_INTEGER, + ) -> c_ulong; fn RtlQueryPerformanceFrequency( - PerformanceFrequency: PLARGE_INTEGER, - ) -> LOGICAL; + PerformanceFrequency: *mut LARGE_INTEGER, + ) -> c_ulong; }} -ENUM!{enum IMAGE_MITIGATION_POLICY { +ENUM! {enum IMAGE_MITIGATION_POLICY { ImageDepPolicy = 0, ImageAslrPolicy = 1, ImageDynamicCodePolicy = 2, @@ -4032,75 +4118,80 @@ ENUM!{enum IMAGE_MITIGATION_POLICY { ImageHeapPolicy = 14, MaxImageMitigationPolicy = 15, }} -UNION!{union RTL_IMAGE_MITIGATION_POLICY { - Bitfields1: ULONG64, - Bitfields2: ULONG64, +UNION! {union RTL_IMAGE_MITIGATION_POLICY { + Bitfields1: __uint64, + Bitfields2: __uint64, }} -BITFIELD!{unsafe RTL_IMAGE_MITIGATION_POLICY Bitfields1: ULONG64 [ +BITFIELD! {unsafe RTL_IMAGE_MITIGATION_POLICY Bitfields1: __uint64 [ AuditState set_AuditState[0..2], AuditFlag set_AuditFlag[2..3], EnableAdditionalAuditingOption set_EnableAdditionalAuditingOption[3..4], Reserved set_Reserved[4..64], ]} -BITFIELD!{unsafe RTL_IMAGE_MITIGATION_POLICY Bitfields2: ULONG64 [ +BITFIELD! {unsafe RTL_IMAGE_MITIGATION_POLICY Bitfields2: __uint64 [ PolicyState set_PolicyState[0..2], AlwaysInherit set_AlwaysInherit[2..3], EnableAdditionalPolicyOption set_EnableAdditionalPolicyOption[3..4], AuditReserved set_AuditReserved[4..64], ]} pub type PRTL_IMAGE_MITIGATION_POLICY = *mut RTL_IMAGE_MITIGATION_POLICY; -STRUCT!{struct RTL_IMAGE_MITIGATION_DEP_POLICY { +STRUCT! {struct RTL_IMAGE_MITIGATION_DEP_POLICY { Dep: RTL_IMAGE_MITIGATION_POLICY, }} -pub type PRTL_IMAGE_MITIGATION_DEP_POLICY = *mut RTL_IMAGE_MITIGATION_DEP_POLICY; -STRUCT!{struct RTL_IMAGE_MITIGATION_ASLR_POLICY { +pub type PRTL_IMAGE_MITIGATION_DEP_POLICY = + *mut RTL_IMAGE_MITIGATION_DEP_POLICY; +STRUCT! {struct RTL_IMAGE_MITIGATION_ASLR_POLICY { ForceRelocateImages: RTL_IMAGE_MITIGATION_POLICY, BottomUpRandomization: RTL_IMAGE_MITIGATION_POLICY, HighEntropyRandomization: RTL_IMAGE_MITIGATION_POLICY, }} -pub type PRTL_IMAGE_MITIGATION_ASLR_POLICY = *mut RTL_IMAGE_MITIGATION_ASLR_POLICY; -STRUCT!{struct RTL_IMAGE_MITIGATION_DYNAMIC_CODE_POLICY { +pub type PRTL_IMAGE_MITIGATION_ASLR_POLICY = + *mut RTL_IMAGE_MITIGATION_ASLR_POLICY; +STRUCT! {struct RTL_IMAGE_MITIGATION_DYNAMIC_CODE_POLICY { BlockDynamicCode: RTL_IMAGE_MITIGATION_POLICY, }} -pub type PRTL_IMAGE_MITIGATION_DYNAMIC_CODE_POLICY = *mut RTL_IMAGE_MITIGATION_DYNAMIC_CODE_POLICY; -STRUCT!{struct RTL_IMAGE_MITIGATION_STRICT_HANDLE_CHECK_POLICY { +pub type PRTL_IMAGE_MITIGATION_DYNAMIC_CODE_POLICY = + *mut RTL_IMAGE_MITIGATION_DYNAMIC_CODE_POLICY; +STRUCT! {struct RTL_IMAGE_MITIGATION_STRICT_HANDLE_CHECK_POLICY { StrictHandleChecks: RTL_IMAGE_MITIGATION_POLICY, }} pub type PRTL_IMAGE_MITIGATION_STRICT_HANDLE_CHECK_POLICY = *mut RTL_IMAGE_MITIGATION_STRICT_HANDLE_CHECK_POLICY; -STRUCT!{struct RTL_IMAGE_MITIGATION_SYSTEM_CALL_DISABLE_POLICY { +STRUCT! {struct RTL_IMAGE_MITIGATION_SYSTEM_CALL_DISABLE_POLICY { BlockWin32kSystemCalls: RTL_IMAGE_MITIGATION_POLICY, }} pub type PRTL_IMAGE_MITIGATION_SYSTEM_CALL_DISABLE_POLICY = *mut RTL_IMAGE_MITIGATION_SYSTEM_CALL_DISABLE_POLICY; -STRUCT!{struct RTL_IMAGE_MITIGATION_EXTENSION_POINT_DISABLE_POLICY { +STRUCT! {struct RTL_IMAGE_MITIGATION_EXTENSION_POINT_DISABLE_POLICY { DisableExtensionPoints: RTL_IMAGE_MITIGATION_POLICY, }} pub type PRTL_IMAGE_MITIGATION_EXTENSION_POINT_DISABLE_POLICY = *mut RTL_IMAGE_MITIGATION_EXTENSION_POINT_DISABLE_POLICY; -STRUCT!{struct RTL_IMAGE_MITIGATION_CONTROL_FLOW_GUARD_POLICY { +STRUCT! {struct RTL_IMAGE_MITIGATION_CONTROL_FLOW_GUARD_POLICY { ControlFlowGuard: RTL_IMAGE_MITIGATION_POLICY, StrictControlFlowGuard: RTL_IMAGE_MITIGATION_POLICY, }} pub type PRTL_IMAGE_MITIGATION_CONTROL_FLOW_GUARD_POLICY = *mut RTL_IMAGE_MITIGATION_CONTROL_FLOW_GUARD_POLICY; -STRUCT!{struct RTL_IMAGE_MITIGATION_BINARY_SIGNATURE_POLICY { +STRUCT! {struct RTL_IMAGE_MITIGATION_BINARY_SIGNATURE_POLICY { BlockNonMicrosoftSignedBinaries: RTL_IMAGE_MITIGATION_POLICY, EnforceSigningOnModuleDependencies: RTL_IMAGE_MITIGATION_POLICY, }} pub type PRTL_IMAGE_MITIGATION_BINARY_SIGNATURE_POLICY = *mut RTL_IMAGE_MITIGATION_BINARY_SIGNATURE_POLICY; -STRUCT!{struct RTL_IMAGE_MITIGATION_FONT_DISABLE_POLICY { +STRUCT! {struct RTL_IMAGE_MITIGATION_FONT_DISABLE_POLICY { DisableNonSystemFonts: RTL_IMAGE_MITIGATION_POLICY, }} -pub type PRTL_IMAGE_MITIGATION_FONT_DISABLE_POLICY = *mut RTL_IMAGE_MITIGATION_FONT_DISABLE_POLICY; -STRUCT!{struct RTL_IMAGE_MITIGATION_IMAGE_LOAD_POLICY { +pub type PRTL_IMAGE_MITIGATION_FONT_DISABLE_POLICY = + *mut RTL_IMAGE_MITIGATION_FONT_DISABLE_POLICY; +STRUCT! {struct RTL_IMAGE_MITIGATION_IMAGE_LOAD_POLICY { BlockRemoteImageLoads: RTL_IMAGE_MITIGATION_POLICY, BlockLowLabelImageLoads: RTL_IMAGE_MITIGATION_POLICY, PreferSystem32: RTL_IMAGE_MITIGATION_POLICY, }} -pub type PRTL_IMAGE_MITIGATION_IMAGE_LOAD_POLICY = *mut RTL_IMAGE_MITIGATION_IMAGE_LOAD_POLICY; -STRUCT!{struct RTL_IMAGE_MITIGATION_PAYLOAD_RESTRICTION_POLICY { +pub type PRTL_IMAGE_MITIGATION_IMAGE_LOAD_POLICY = + *mut RTL_IMAGE_MITIGATION_IMAGE_LOAD_POLICY; +STRUCT! {struct RTL_IMAGE_MITIGATION_PAYLOAD_RESTRICTION_POLICY { EnableExportAddressFilter: RTL_IMAGE_MITIGATION_POLICY, EnableExportAddressFilterPlus: RTL_IMAGE_MITIGATION_POLICY, EnableImportAddressFilter: RTL_IMAGE_MITIGATION_POLICY, @@ -4110,56 +4201,58 @@ STRUCT!{struct RTL_IMAGE_MITIGATION_PAYLOAD_RESTRICTION_POLICY { }} pub type PRTL_IMAGE_MITIGATION_PAYLOAD_RESTRICTION_POLICY = *mut RTL_IMAGE_MITIGATION_PAYLOAD_RESTRICTION_POLICY; -STRUCT!{struct RTL_IMAGE_MITIGATION_CHILD_PROCESS_POLICY { +STRUCT! {struct RTL_IMAGE_MITIGATION_CHILD_PROCESS_POLICY { DisallowChildProcessCreation: RTL_IMAGE_MITIGATION_POLICY, }} pub type PRTL_IMAGE_MITIGATION_CHILD_PROCESS_POLICY = *mut RTL_IMAGE_MITIGATION_CHILD_PROCESS_POLICY; -STRUCT!{struct RTL_IMAGE_MITIGATION_SEHOP_POLICY { +STRUCT! {struct RTL_IMAGE_MITIGATION_SEHOP_POLICY { Sehop: RTL_IMAGE_MITIGATION_POLICY, }} -pub type PRTL_IMAGE_MITIGATION_SEHOP_POLICY = *mut RTL_IMAGE_MITIGATION_SEHOP_POLICY; -STRUCT!{struct RTL_IMAGE_MITIGATION_HEAP_POLICY { +pub type PRTL_IMAGE_MITIGATION_SEHOP_POLICY = + *mut RTL_IMAGE_MITIGATION_SEHOP_POLICY; +STRUCT! {struct RTL_IMAGE_MITIGATION_HEAP_POLICY { TerminateOnHeapErrors: RTL_IMAGE_MITIGATION_POLICY, }} -pub type PRTL_IMAGE_MITIGATION_HEAP_POLICY = *mut RTL_IMAGE_MITIGATION_HEAP_POLICY; -ENUM!{enum RTL_IMAGE_MITIGATION_OPTION_STATE { +pub type PRTL_IMAGE_MITIGATION_HEAP_POLICY = + *mut RTL_IMAGE_MITIGATION_HEAP_POLICY; +ENUM! {enum RTL_IMAGE_MITIGATION_OPTION_STATE { RtlMitigationOptionStateNotConfigured = 0, RtlMitigationOptionStateOn = 1, RtlMitigationOptionStateOff = 2, }} -pub const RTL_IMAGE_MITIGATION_FLAG_RESET: ULONG = 0x1; -pub const RTL_IMAGE_MITIGATION_FLAG_REMOVE: ULONG = 0x2; -pub const RTL_IMAGE_MITIGATION_FLAG_OSDEFAULT: ULONG = 0x4; -pub const RTL_IMAGE_MITIGATION_FLAG_AUDIT: ULONG = 0x8; -EXTERN!{extern "system" { +pub const RTL_IMAGE_MITIGATION_FLAG_RESET: c_ulong = 0x1; +pub const RTL_IMAGE_MITIGATION_FLAG_REMOVE: c_ulong = 0x2; +pub const RTL_IMAGE_MITIGATION_FLAG_OSDEFAULT: c_ulong = 0x4; +pub const RTL_IMAGE_MITIGATION_FLAG_AUDIT: c_ulong = 0x8; +EXTERN! {extern "system" { fn RtlQueryImageMitigationPolicy( - ImagePath: PWSTR, + ImagePath: *mut wchar_t, Policy: IMAGE_MITIGATION_POLICY, - Flags: ULONG, - Buffer: PVOID, - BufferSize: ULONG, + Flags: c_ulong, + Buffer: *mut c_void, + BufferSize: c_ulong, ) -> NTSTATUS; fn RtlSetImageMitigationPolicy( - ImagePath: PWSTR, + ImagePath: *mut wchar_t, Policy: IMAGE_MITIGATION_POLICY, - Flags: ULONG, - Buffer: PVOID, - BufferSize: ULONG, + Flags: c_ulong, + Buffer: *mut c_void, + BufferSize: c_ulong, ) -> NTSTATUS; - fn RtlGetCurrentServiceSessionId() -> ULONG; - fn RtlGetActiveConsoleId() -> ULONG; - fn RtlGetConsoleSessionForegroundProcessId() -> ULONGLONG; + fn RtlGetCurrentServiceSessionId() -> c_ulong; + fn RtlGetActiveConsoleId() -> c_ulong; + fn RtlGetConsoleSessionForegroundProcessId() -> __uint64; fn RtlGetTokenNamedObjectPath( Token: HANDLE, Sid: PSID, - ObjectPath: PUNICODE_STRING, + ObjectPath: *mut UNICODE_STRING, ) -> NTSTATUS; fn RtlGetAppContainerNamedObjectPath( Token: HANDLE, AppContainerSid: PSID, - RelativePath: BOOLEAN, - ObjectPath: PUNICODE_STRING, + RelativePath: c_uchar, + ObjectPath: *mut UNICODE_STRING, ) -> NTSTATUS; fn RtlGetAppContainerParent( AppContainerSid: PSID, @@ -4167,28 +4260,28 @@ EXTERN!{extern "system" { ) -> NTSTATUS; fn RtlCheckSandboxedToken( TokenHandle: HANDLE, - IsSandboxed: PBOOLEAN, + IsSandboxed: *mut c_uchar, ) -> NTSTATUS; fn RtlCheckTokenCapability( TokenHandle: HANDLE, CapabilitySidToCheck: PSID, - HasCapability: PBOOLEAN, + HasCapability: *mut c_uchar, ) -> NTSTATUS; fn RtlCapabilityCheck( TokenHandle: HANDLE, - CapabilityName: PUNICODE_STRING, - HasCapability: PBOOLEAN, + CapabilityName: *mut UNICODE_STRING, + HasCapability: *mut c_uchar, ) -> NTSTATUS; fn RtlCheckTokenMembership( TokenHandle: HANDLE, SidToCheck: PSID, - IsMember: PBOOLEAN, + IsMember: *mut c_uchar, ) -> NTSTATUS; fn RtlCheckTokenMembershipEx( TokenHandle: HANDLE, SidToCheck: PSID, - Flags: ULONG, - IsMember: PBOOLEAN, + Flags: c_ulong, + IsMember: *mut c_uchar, ) -> NTSTATUS; fn RtlIsParentOfChildAppContainer( ParentAppContainerSid: PSID, @@ -4196,16 +4289,16 @@ EXTERN!{extern "system" { ) -> NTSTATUS; fn RtlIsCapabilitySid( Sid: PSID, - ) -> BOOLEAN; + ) -> c_uchar; fn RtlIsPackageSid( Sid: PSID, - ) -> BOOLEAN; + ) -> c_uchar; fn RtlIsValidProcessTrustLabelSid( Sid: PSID, - ) -> BOOLEAN; - fn RtlIsStateSeparationEnabled() -> BOOLEAN; + ) -> c_uchar; + fn RtlIsStateSeparationEnabled() -> c_uchar; }} -ENUM!{enum APPCONTAINER_SID_TYPE { +ENUM! {enum APPCONTAINER_SID_TYPE { NotAppContainerSidType = 0, ChildAppContainerSidType = 1, ParentAppContainerSidType = 2, @@ -4213,88 +4306,88 @@ ENUM!{enum APPCONTAINER_SID_TYPE { MaxAppContainerSidType = 4, }} pub type PAPPCONTAINER_SID_TYPE = *mut APPCONTAINER_SID_TYPE; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlGetAppContainerSidType( AppContainerSid: PSID, AppContainerSidType: PAPPCONTAINER_SID_TYPE, ) -> NTSTATUS; fn RtlFlsAlloc( Callback: PFLS_CALLBACK_FUNCTION, - FlsIndex: PULONG, + FlsIndex: *mut c_ulong, ) -> NTSTATUS; fn RtlFlsFree( - FlsIndex: ULONG, + FlsIndex: c_ulong, ) -> NTSTATUS; }} -ENUM!{enum STATE_LOCATION_TYPE { +ENUM! {enum STATE_LOCATION_TYPE { LocationTypeRegistry = 0, LocationTypeFileSystem = 1, LocationTypeMaximum = 2, }} -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlGetPersistedStateLocation( - SourceID: PCWSTR, - CustomValue: PCWSTR, - DefaultPath: PCWSTR, + SourceID: *const wchar_t, + CustomValue: *const wchar_t, + DefaultPath: *const wchar_t, StateLocationType: STATE_LOCATION_TYPE, - TargetPath: PWCHAR, - BufferLengthIn: ULONG, - BufferLengthOut: PULONG, + TargetPath: *mut wchar_t, + BufferLengthIn: c_ulong, + BufferLengthOut: *mut c_ulong, ) -> NTSTATUS; fn RtlIsCloudFilesPlaceholder( - FileAttributes: ULONG, - ReparseTag: ULONG, - ) -> BOOLEAN; + FileAttributes: c_ulong, + ReparseTag: c_ulong, + ) -> c_uchar; fn RtlIsPartialPlaceholder( - FileAttributes: ULONG, - ReparseTag: ULONG, - ) -> BOOLEAN; + FileAttributes: c_ulong, + ReparseTag: c_ulong, + ) -> c_uchar; fn RtlIsPartialPlaceholderFileHandle( FileHandle: HANDLE, - IsPartialPlaceholder: PBOOLEAN, + IsPartialPlaceholder: *mut c_uchar, ) -> NTSTATUS; fn RtlIsPartialPlaceholderFileInfo( InfoBuffer: *const c_void, InfoClass: FILE_INFORMATION_CLASS, - IsPartialPlaceholder: PBOOLEAN, + IsPartialPlaceholder: *mut c_uchar, ) -> NTSTATUS; fn RtlIsNonEmptyDirectoryReparsePointAllowed( - ReparseTag: ULONG, - ) -> BOOLEAN; + ReparseTag: c_ulong, + ) -> c_uchar; fn RtlAppxIsFileOwnedByTrustedInstaller( FileHandle: HANDLE, - IsFileOwnedByTrustedInstaller: PBOOLEAN, + IsFileOwnedByTrustedInstaller: *mut c_uchar, ) -> NTSTATUS; }} -STRUCT!{struct PS_PKG_CLAIM { - Flags: ULONGLONG, - Origin: ULONGLONG, +STRUCT! {struct PS_PKG_CLAIM { + Flags: __uint64, + Origin: __uint64, }} pub type PPS_PKG_CLAIM = *mut PS_PKG_CLAIM; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlQueryPackageClaims( TokenHandle: HANDLE, - PackageFullName: PWSTR, - PackageSize: PSIZE_T, - AppId: PWSTR, - AppIdSize: PSIZE_T, + PackageFullName: *mut wchar_t, + PackageSize: *mut usize, + AppId: *mut wchar_t, + AppIdSize: *mut usize, DynamicId: *mut GUID, PkgClaim: PPS_PKG_CLAIM, - AttributesPresent: PULONG64, + AttributesPresent: *mut __uint64, ) -> NTSTATUS; fn RtlQueryProtectedPolicy( PolicyGuid: *mut GUID, - PolicyValue: PULONG_PTR, + PolicyValue: *mut usize, ) -> NTSTATUS; fn RtlSetProtectedPolicy( PolicyGuid: *mut GUID, - PolicyValue: ULONG_PTR, - OldPolicyValue: PULONG_PTR, + PolicyValue: usize, + OldPolicyValue: *mut usize, ) -> NTSTATUS; - fn RtlIsMultiSessionSku() -> BOOLEAN; - fn RtlIsMultiUsersInSessionSku() -> BOOLEAN; + fn RtlIsMultiSessionSku() -> c_uchar; + fn RtlIsMultiUsersInSessionSku() -> c_uchar; }} -ENUM!{enum RTL_BSD_ITEM_TYPE { +ENUM! {enum RTL_BSD_ITEM_TYPE { RtlBsdItemVersionNumber = 0, RtlBsdItemProductType = 1, RtlBsdItemAabEnabled = 2, @@ -4313,53 +4406,53 @@ ENUM!{enum RTL_BSD_ITEM_TYPE { RtlBsdItemChecksum = 15, RtlBsdItemMax = 16, }} -STRUCT!{struct RTL_BSD_ITEM { +STRUCT! {struct RTL_BSD_ITEM { Type: RTL_BSD_ITEM_TYPE, - DataBuffer: PVOID, - DataLength: ULONG, + DataBuffer: *mut c_void, + DataLength: c_ulong, }} pub type PRTL_BSD_ITEM = *mut RTL_BSD_ITEM; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlCreateBootStatusDataFile() -> NTSTATUS; fn RtlLockBootStatusData( - FileHandle: PHANDLE, + FileHandle: *mut HANDLE, ) -> NTSTATUS; fn RtlUnlockBootStatusData( FileHandle: HANDLE, ) -> NTSTATUS; fn RtlGetSetBootStatusData( FileHandle: HANDLE, - Read: BOOLEAN, + Read: c_uchar, DataClass: RTL_BSD_ITEM_TYPE, - Buffer: PVOID, - BufferSize: ULONG, - ReturnLength: PULONG, + Buffer: *mut c_void, + BufferSize: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn RtlCheckBootStatusIntegrity( FileHandle: HANDLE, - Verified: PBOOLEAN, + Verified: *mut c_uchar, ) -> NTSTATUS; fn RtlCheckPortableOperatingSystem( - IsPortable: PBOOLEAN, + IsPortable: *mut c_uchar, ) -> NTSTATUS; fn RtlSetPortableOperatingSystem( - IsPortable: BOOLEAN, + IsPortable: c_uchar, ) -> NTSTATUS; }} -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlOsDeploymentState( - Flags: DWORD, + Flags: c_ulong, ) -> OS_DEPLOYEMENT_STATE_VALUES; fn RtlFindClosestEncodableLength( - SourceLength: ULONGLONG, - TargetLength: PULONGLONG, + SourceLength: __uint64, + TargetLength: *mut __uint64, ) -> NTSTATUS; }} -FN!{stdcall PRTL_SECURE_MEMORY_CACHE_CALLBACK( - Address: PVOID, - Length: SIZE_T, +FN! {stdcall PRTL_SECURE_MEMORY_CACHE_CALLBACK( + Address: *mut c_void, + Length: usize, ) -> NTSTATUS} -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn RtlRegisterSecureMemoryCacheCallback( Callback: PRTL_SECURE_MEMORY_CACHE_CALLBACK, ) -> NTSTATUS; @@ -4367,7 +4460,7 @@ EXTERN!{extern "system" { Callback: PRTL_SECURE_MEMORY_CACHE_CALLBACK, ) -> NTSTATUS; fn RtlFlushSecureMemoryCache( - MemoryCache: PVOID, - MemoryLength: SIZE_T, - ) -> BOOLEAN; + MemoryCache: *mut c_void, + MemoryLength: usize, + ) -> c_uchar; }} diff --git a/src/ntsam.rs b/src/ntsam.rs index a591f0b..b0c16e3 100644 --- a/src/ntsam.rs +++ b/src/ntsam.rs @@ -1,89 +1,102 @@ -use crate::string::UTF8Const; -use winapi::shared::basetsd::ULONG64; -use winapi::shared::minwindef::DWORD; -use winapi::shared::ntdef::{ - BOOLEAN, HANDLE, LARGE_INTEGER, NTSTATUS, OEM_STRING, PLARGE_INTEGER, POBJECT_ATTRIBUTES, - PUCHAR, PULONG, PUNICODE_STRING, PVOID, PWSTR, ULONG, UNICODE_STRING, USHORT, +use windows_sys::Win32::{ + Foundation::{HANDLE, NTSTATUS, PSID, UNICODE_STRING}, + Security::{ + Authentication::Identity::{DOMAIN_PASSWORD_INFORMATION, LOGON_HOURS}, + PSECURITY_DESCRIPTOR, SID_NAME_USE, + }, + Storage::FileSystem::{ + STANDARD_RIGHTS_EXECUTE, STANDARD_RIGHTS_READ, + STANDARD_RIGHTS_REQUIRED, STANDARD_RIGHTS_WRITE, + }, + System::{Kernel::STRING, WindowsProgramming::OBJECT_ATTRIBUTES}, }; -use winapi::um::ntsecapi::PDOMAIN_PASSWORD_INFORMATION; -use winapi::um::subauth::LOGON_HOURS; -use winapi::um::winnt::{ - ACCESS_MASK, PSECURITY_DESCRIPTOR, PSID, PSID_NAME_USE, SECURITY_INFORMATION, SID_NAME_USE, - STANDARD_RIGHTS_EXECUTE, STANDARD_RIGHTS_READ, STANDARD_RIGHTS_REQUIRED, STANDARD_RIGHTS_WRITE, + +use crate::{ + ctypes::{__uint64, c_uchar, c_ulong, c_ushort, c_void, wchar_t}, + string::UTF8Const, + windows_local::shared::ntdef::LARGE_INTEGER, }; + pub const SAM_MAXIMUM_LOOKUP_COUNT: u32 = 1000; pub const SAM_MAXIMUM_LOOKUP_LENGTH: u32 = 32000; pub const SAM_MAX_PASSWORD_LENGTH: u32 = 256; pub const SAM_PASSWORD_ENCRYPTION_SALT_LEN: u32 = 16; -pub type PSAM_HANDLE = *mut PVOID; -pub type SAM_HANDLE = PVOID; -pub type SAM_ENUMERATE_HANDLE = ULONG; -pub type PSAM_ENUMERATE_HANDLE = *mut ULONG; -STRUCT!{struct SAM_RID_ENUMERATION { - RelativeId: ULONG, +pub type PSAM_HANDLE = *mut *mut c_void; +pub type SAM_HANDLE = *mut c_void; +pub type SAM_ENUMERATE_HANDLE = c_ulong; +pub type PSAM_ENUMERATE_HANDLE = *mut c_ulong; +STRUCT! {struct SAM_RID_ENUMERATION { + RelativeId: c_ulong, Name: UNICODE_STRING, }} pub type PSAM_RID_ENUMERATION = *mut SAM_RID_ENUMERATION; -STRUCT!{struct SAM_SID_ENUMERATION { +STRUCT! {struct SAM_SID_ENUMERATION { Sid: PSID, Name: UNICODE_STRING, }} pub type PSAM_SID_ENUMERATION = *mut SAM_SID_ENUMERATION; -STRUCT!{struct SAM_BYTE_ARRAY { - Size: ULONG, - Data: PUCHAR, +STRUCT! {struct SAM_BYTE_ARRAY { + Size: c_ulong, + Data: *mut c_uchar, }} pub type PSAM_BYTE_ARRAY = *mut SAM_BYTE_ARRAY; -STRUCT!{struct SAM_BYTE_ARRAY_32K { - Size: ULONG, - Data: PUCHAR, +STRUCT! {struct SAM_BYTE_ARRAY_32K { + Size: c_ulong, + Data: *mut c_uchar, }} pub type PSAM_BYTE_ARRAY_32K = *mut SAM_BYTE_ARRAY_32K; pub type PSAM_SHELL_OBJECT_PROPERTIES = *mut SAM_BYTE_ARRAY_32K; pub type SAM_SHELL_OBJECT_PROPERTIES = SAM_BYTE_ARRAY_32K; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn SamFreeMemory( - Buffer: PVOID, + Buffer: *mut c_void, ) -> NTSTATUS; fn SamCloseHandle( SamHandle: SAM_HANDLE, ) -> NTSTATUS; fn SamSetSecurityObject( ObjectHandle: SAM_HANDLE, - SecurityInformation: SECURITY_INFORMATION, + SecurityInformation: c_ulong, SecurityDescriptor: PSECURITY_DESCRIPTOR, ) -> NTSTATUS; fn SamQuerySecurityObject( ObjectHandle: SAM_HANDLE, - SecurityInformation: SECURITY_INFORMATION, + SecurityInformation: c_ulong, SecurityDescriptor: *mut PSECURITY_DESCRIPTOR, ) -> NTSTATUS; fn SamRidToSid( ObjectHandle: SAM_HANDLE, - Rid: ULONG, + Rid: c_ulong, Sid: *mut PSID, ) -> NTSTATUS; }} -pub const SAM_SERVER_CONNECT: ACCESS_MASK = 0x0001; -pub const SAM_SERVER_SHUTDOWN: ACCESS_MASK = 0x0002; -pub const SAM_SERVER_INITIALIZE: ACCESS_MASK = 0x0004; -pub const SAM_SERVER_CREATE_DOMAIN: ACCESS_MASK = 0x0008; -pub const SAM_SERVER_ENUMERATE_DOMAINS: ACCESS_MASK = 0x0010; -pub const SAM_SERVER_LOOKUP_DOMAIN: ACCESS_MASK = 0x0020; -pub const SAM_SERVER_ALL_ACCESS: ACCESS_MASK = STANDARD_RIGHTS_REQUIRED | SAM_SERVER_CONNECT - | SAM_SERVER_INITIALIZE | SAM_SERVER_CREATE_DOMAIN | SAM_SERVER_SHUTDOWN - | SAM_SERVER_ENUMERATE_DOMAINS | SAM_SERVER_LOOKUP_DOMAIN; -pub const SAM_SERVER_READ: ACCESS_MASK = STANDARD_RIGHTS_READ | SAM_SERVER_ENUMERATE_DOMAINS; -pub const SAM_SERVER_WRITE: ACCESS_MASK = - STANDARD_RIGHTS_WRITE | SAM_SERVER_INITIALIZE | SAM_SERVER_CREATE_DOMAIN | SAM_SERVER_SHUTDOWN; -pub const SAM_SERVER_EXECUTE: ACCESS_MASK = +pub const SAM_SERVER_CONNECT: c_ulong = 0x0001; +pub const SAM_SERVER_SHUTDOWN: c_ulong = 0x0002; +pub const SAM_SERVER_INITIALIZE: c_ulong = 0x0004; +pub const SAM_SERVER_CREATE_DOMAIN: c_ulong = 0x0008; +pub const SAM_SERVER_ENUMERATE_DOMAINS: c_ulong = 0x0010; +pub const SAM_SERVER_LOOKUP_DOMAIN: c_ulong = 0x0020; +pub const SAM_SERVER_ALL_ACCESS: c_ulong = STANDARD_RIGHTS_REQUIRED + | SAM_SERVER_CONNECT + | SAM_SERVER_INITIALIZE + | SAM_SERVER_CREATE_DOMAIN + | SAM_SERVER_SHUTDOWN + | SAM_SERVER_ENUMERATE_DOMAINS + | SAM_SERVER_LOOKUP_DOMAIN; +pub const SAM_SERVER_READ: c_ulong = + STANDARD_RIGHTS_READ | SAM_SERVER_ENUMERATE_DOMAINS; +pub const SAM_SERVER_WRITE: c_ulong = STANDARD_RIGHTS_WRITE + | SAM_SERVER_INITIALIZE + | SAM_SERVER_CREATE_DOMAIN + | SAM_SERVER_SHUTDOWN; +pub const SAM_SERVER_EXECUTE: c_ulong = STANDARD_RIGHTS_EXECUTE | SAM_SERVER_CONNECT | SAM_SERVER_LOOKUP_DOMAIN; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn SamConnect( - ServerName: PUNICODE_STRING, + ServerName: *mut UNICODE_STRING, ServerHandle: PSAM_HANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn SamShutdownSamServer( ServerHandle: SAM_HANDLE, @@ -100,19 +113,33 @@ pub const DOMAIN_GET_ALIAS_MEMBERSHIP: u32 = 0x0080; pub const DOMAIN_LIST_ACCOUNTS: u32 = 0x0100; pub const DOMAIN_LOOKUP: u32 = 0x0200; pub const DOMAIN_ADMINISTER_SERVER: u32 = 0x0400; -pub const DOMAIN_ALL_ACCESS: u32 = STANDARD_RIGHTS_REQUIRED | DOMAIN_READ_OTHER_PARAMETERS - | DOMAIN_WRITE_OTHER_PARAMETERS | DOMAIN_WRITE_PASSWORD_PARAMS | DOMAIN_CREATE_USER - | DOMAIN_CREATE_GROUP | DOMAIN_CREATE_ALIAS | DOMAIN_GET_ALIAS_MEMBERSHIP - | DOMAIN_LIST_ACCOUNTS | DOMAIN_READ_PASSWORD_PARAMETERS | DOMAIN_LOOKUP +pub const DOMAIN_ALL_ACCESS: u32 = STANDARD_RIGHTS_REQUIRED + | DOMAIN_READ_OTHER_PARAMETERS + | DOMAIN_WRITE_OTHER_PARAMETERS + | DOMAIN_WRITE_PASSWORD_PARAMS + | DOMAIN_CREATE_USER + | DOMAIN_CREATE_GROUP + | DOMAIN_CREATE_ALIAS + | DOMAIN_GET_ALIAS_MEMBERSHIP + | DOMAIN_LIST_ACCOUNTS + | DOMAIN_READ_PASSWORD_PARAMETERS + | DOMAIN_LOOKUP | DOMAIN_ADMINISTER_SERVER; -pub const DOMAIN_READ: u32 = - STANDARD_RIGHTS_READ | DOMAIN_GET_ALIAS_MEMBERSHIP | DOMAIN_READ_OTHER_PARAMETERS; -pub const DOMAIN_WRITE: u32 = STANDARD_RIGHTS_WRITE | DOMAIN_WRITE_OTHER_PARAMETERS - | DOMAIN_WRITE_PASSWORD_PARAMS | DOMAIN_CREATE_USER | DOMAIN_CREATE_GROUP | DOMAIN_CREATE_ALIAS +pub const DOMAIN_READ: u32 = STANDARD_RIGHTS_READ + | DOMAIN_GET_ALIAS_MEMBERSHIP + | DOMAIN_READ_OTHER_PARAMETERS; +pub const DOMAIN_WRITE: u32 = STANDARD_RIGHTS_WRITE + | DOMAIN_WRITE_OTHER_PARAMETERS + | DOMAIN_WRITE_PASSWORD_PARAMS + | DOMAIN_CREATE_USER + | DOMAIN_CREATE_GROUP + | DOMAIN_CREATE_ALIAS | DOMAIN_ADMINISTER_SERVER; -pub const DOMAIN_EXECUTE: u32 = STANDARD_RIGHTS_EXECUTE | DOMAIN_READ_PASSWORD_PARAMETERS - | DOMAIN_LIST_ACCOUNTS | DOMAIN_LOOKUP; -ENUM!{enum DOMAIN_INFORMATION_CLASS { +pub const DOMAIN_EXECUTE: u32 = STANDARD_RIGHTS_EXECUTE + | DOMAIN_READ_PASSWORD_PARAMETERS + | DOMAIN_LIST_ACCOUNTS + | DOMAIN_LOOKUP; +ENUM! {enum DOMAIN_INFORMATION_CLASS { DomainPasswordInformation = 1, DomainGeneralInformation = 2, DomainLogoffInformation = 3, @@ -127,17 +154,17 @@ ENUM!{enum DOMAIN_INFORMATION_CLASS { DomainLockoutInformation = 12, DomainModifiedInformation2 = 13, }} -ENUM!{enum DOMAIN_SERVER_ENABLE_STATE { +ENUM! {enum DOMAIN_SERVER_ENABLE_STATE { DomainServerEnabled = 1, DomainServerDisabled = 2, }} pub type PDOMAIN_SERVER_ENABLE_STATE = *mut DOMAIN_SERVER_ENABLE_STATE; -ENUM!{enum DOMAIN_SERVER_ROLE { +ENUM! {enum DOMAIN_SERVER_ROLE { DomainServerRoleBackup = 2, DomainServerRolePrimary = 3, }} pub type PDOMAIN_SERVER_ROLE = *mut DOMAIN_SERVER_ROLE; -STRUCT!{#[repr(packed(4))] struct DOMAIN_GENERAL_INFORMATION { +STRUCT! {#[repr(packed(4))] struct DOMAIN_GENERAL_INFORMATION { ForceLogoff: LARGE_INTEGER, OemInformation: UNICODE_STRING, DomainName: UNICODE_STRING, @@ -145,68 +172,68 @@ STRUCT!{#[repr(packed(4))] struct DOMAIN_GENERAL_INFORMATION { DomainModifiedCount: LARGE_INTEGER, DomainServerState: DOMAIN_SERVER_ENABLE_STATE, DomainServerRole: DOMAIN_SERVER_ROLE, - UasCompatibilityRequired: BOOLEAN, - UserCount: ULONG, - GroupCount: ULONG, - AliasCount: ULONG, + UasCompatibilityRequired: c_uchar, + UserCount: c_ulong, + GroupCount: c_ulong, + AliasCount: c_ulong, }} pub type PDOMAIN_GENERAL_INFORMATION = *mut DOMAIN_GENERAL_INFORMATION; -STRUCT!{#[repr(packed(4))] struct DOMAIN_GENERAL_INFORMATION2 { +STRUCT! {#[repr(packed(4))] struct DOMAIN_GENERAL_INFORMATION2 { I1: DOMAIN_GENERAL_INFORMATION, LockoutDuration: LARGE_INTEGER, LockoutObservationWindow: LARGE_INTEGER, - LockoutThreshold: USHORT, + LockoutThreshold: c_ushort, }} pub type PDOMAIN_GENERAL_INFORMATION2 = *mut DOMAIN_GENERAL_INFORMATION2; -STRUCT!{struct DOMAIN_UAS_INFORMATION { - UasCompatibilityRequired: BOOLEAN, +STRUCT! {struct DOMAIN_UAS_INFORMATION { + UasCompatibilityRequired: c_uchar, }} -ENUM!{enum DOMAIN_PASSWORD_CONSTRUCTION { +ENUM! {enum DOMAIN_PASSWORD_CONSTRUCTION { DomainPasswordSimple = 1, DomainPasswordComplex = 2, }} -STRUCT!{struct DOMAIN_LOGOFF_INFORMATION { +STRUCT! {struct DOMAIN_LOGOFF_INFORMATION { ForceLogoff: LARGE_INTEGER, }} pub type PDOMAIN_LOGOFF_INFORMATION = *mut DOMAIN_LOGOFF_INFORMATION; -STRUCT!{struct DOMAIN_OEM_INFORMATION { +STRUCT! {struct DOMAIN_OEM_INFORMATION { OemInformation: UNICODE_STRING, }} pub type PDOMAIN_OEM_INFORMATION = *mut DOMAIN_OEM_INFORMATION; -STRUCT!{struct DOMAIN_NAME_INFORMATION { +STRUCT! {struct DOMAIN_NAME_INFORMATION { DomainName: UNICODE_STRING, }} pub type PDOMAIN_NAME_INFORMATION = *mut DOMAIN_NAME_INFORMATION; -STRUCT!{struct DOMAIN_SERVER_ROLE_INFORMATION { +STRUCT! {struct DOMAIN_SERVER_ROLE_INFORMATION { DomainServerRole: DOMAIN_SERVER_ROLE, }} pub type PDOMAIN_SERVER_ROLE_INFORMATION = *mut DOMAIN_SERVER_ROLE_INFORMATION; -STRUCT!{struct DOMAIN_REPLICATION_INFORMATION { +STRUCT! {struct DOMAIN_REPLICATION_INFORMATION { ReplicaSourceNodeName: UNICODE_STRING, }} pub type PDOMAIN_REPLICATION_INFORMATION = *mut DOMAIN_REPLICATION_INFORMATION; -STRUCT!{struct DOMAIN_MODIFIED_INFORMATION { +STRUCT! {struct DOMAIN_MODIFIED_INFORMATION { DomainModifiedCount: LARGE_INTEGER, CreationTime: LARGE_INTEGER, }} pub type PDOMAIN_MODIFIED_INFORMATION = *mut DOMAIN_MODIFIED_INFORMATION; -STRUCT!{struct DOMAIN_MODIFIED_INFORMATION2 { +STRUCT! {struct DOMAIN_MODIFIED_INFORMATION2 { DomainModifiedCount: LARGE_INTEGER, CreationTime: LARGE_INTEGER, ModifiedCountAtLastPromotion: LARGE_INTEGER, }} pub type PDOMAIN_MODIFIED_INFORMATION2 = *mut DOMAIN_MODIFIED_INFORMATION2; -STRUCT!{struct DOMAIN_STATE_INFORMATION { +STRUCT! {struct DOMAIN_STATE_INFORMATION { DomainServerState: DOMAIN_SERVER_ENABLE_STATE, }} pub type PDOMAIN_STATE_INFORMATION = *mut DOMAIN_STATE_INFORMATION; -STRUCT!{struct DOMAIN_LOCKOUT_INFORMATION { +STRUCT! {struct DOMAIN_LOCKOUT_INFORMATION { LockoutDuration: LARGE_INTEGER, LockoutObservationWindow: LARGE_INTEGER, - LockoutThreshold: USHORT, + LockoutThreshold: c_ushort, }} pub type PDOMAIN_LOCKOUT_INFORMATION = *mut DOMAIN_LOCKOUT_INFORMATION; -ENUM!{enum DOMAIN_DISPLAY_INFORMATION { +ENUM! {enum DOMAIN_DISPLAY_INFORMATION { DomainDisplayUser = 1, DomainDisplayMachine = 2, DomainDisplayGroup = 3, @@ -215,103 +242,107 @@ ENUM!{enum DOMAIN_DISPLAY_INFORMATION { DomainDisplayServer = 6, }} pub type PDOMAIN_DISPLAY_INFORMATION = *mut DOMAIN_DISPLAY_INFORMATION; -STRUCT!{struct DOMAIN_DISPLAY_USER { - Index: ULONG, - Rid: ULONG, - AccountControl: ULONG, +STRUCT! {struct DOMAIN_DISPLAY_USER { + Index: c_ulong, + Rid: c_ulong, + AccountControl: c_ulong, LogonName: UNICODE_STRING, AdminComment: UNICODE_STRING, FullName: UNICODE_STRING, }} pub type PDOMAIN_DISPLAY_USER = *mut DOMAIN_DISPLAY_USER; -STRUCT!{struct DOMAIN_DISPLAY_MACHINE { - Index: ULONG, - Rid: ULONG, - AccountControl: ULONG, +STRUCT! {struct DOMAIN_DISPLAY_MACHINE { + Index: c_ulong, + Rid: c_ulong, + AccountControl: c_ulong, Machine: UNICODE_STRING, Comment: UNICODE_STRING, }} pub type PDOMAIN_DISPLAY_MACHINE = *mut DOMAIN_DISPLAY_MACHINE; -STRUCT!{struct DOMAIN_DISPLAY_GROUP { - Index: ULONG, - Rid: ULONG, - Attributes: ULONG, +STRUCT! {struct DOMAIN_DISPLAY_GROUP { + Index: c_ulong, + Rid: c_ulong, + Attributes: c_ulong, Group: UNICODE_STRING, Comment: UNICODE_STRING, }} pub type PDOMAIN_DISPLAY_GROUP = *mut DOMAIN_DISPLAY_GROUP; -STRUCT!{struct DOMAIN_DISPLAY_OEM_USER { - Index: ULONG, - User: OEM_STRING, +STRUCT! {struct DOMAIN_DISPLAY_OEM_USER { + Index: c_ulong, + User: STRING, }} pub type PDOMAIN_DISPLAY_OEM_USER = *mut DOMAIN_DISPLAY_OEM_USER; -STRUCT!{struct DOMAIN_DISPLAY_OEM_GROUP { - Index: ULONG, - Group: OEM_STRING, +STRUCT! {struct DOMAIN_DISPLAY_OEM_GROUP { + Index: c_ulong, + Group: STRING, }} pub type PDOMAIN_DISPLAY_OEM_GROUP = *mut DOMAIN_DISPLAY_OEM_GROUP; -ENUM!{enum DOMAIN_LOCALIZABLE_ACCOUNTS_INFORMATION { +ENUM! {enum DOMAIN_LOCALIZABLE_ACCOUNTS_INFORMATION { DomainLocalizableAccountsBasic = 1, }} -pub type PDOMAIN_LOCALIZABLE_ACCOUNTS_INFORMATION = *mut DOMAIN_LOCALIZABLE_ACCOUNTS_INFORMATION; -STRUCT!{struct DOMAIN_LOCALIZABLE_ACCOUNT_ENTRY { - Rid: ULONG, +pub type PDOMAIN_LOCALIZABLE_ACCOUNTS_INFORMATION = + *mut DOMAIN_LOCALIZABLE_ACCOUNTS_INFORMATION; +STRUCT! {struct DOMAIN_LOCALIZABLE_ACCOUNT_ENTRY { + Rid: c_ulong, Use: SID_NAME_USE, Name: UNICODE_STRING, AdminComment: UNICODE_STRING, }} -pub type PDOMAIN_LOCALIZABLE_ACCOUNT_ENTRY = *mut DOMAIN_LOCALIZABLE_ACCOUNT_ENTRY; -STRUCT!{struct DOMAIN_LOCALIZABLE_ACCOUNTS_BASIC { - Count: ULONG, +pub type PDOMAIN_LOCALIZABLE_ACCOUNT_ENTRY = + *mut DOMAIN_LOCALIZABLE_ACCOUNT_ENTRY; +STRUCT! {struct DOMAIN_LOCALIZABLE_ACCOUNTS_BASIC { + Count: c_ulong, Entries: *mut DOMAIN_LOCALIZABLE_ACCOUNT_ENTRY, }} -pub type PDOMAIN_LOCALIZABLE_ACCOUNTS_BASIC = *mut DOMAIN_LOCALIZABLE_ACCOUNTS_BASIC; -UNION!{union DOMAIN_LOCALIZABLE_ACCOUNTS_INFO_BUFFER { +pub type PDOMAIN_LOCALIZABLE_ACCOUNTS_BASIC = + *mut DOMAIN_LOCALIZABLE_ACCOUNTS_BASIC; +UNION! {union DOMAIN_LOCALIZABLE_ACCOUNTS_INFO_BUFFER { Basic: DOMAIN_LOCALIZABLE_ACCOUNTS_BASIC, }} -pub type PDOMAIN_LOCALIZABLE_ACCOUNTS_INFO_BUFFER = *mut DOMAIN_LOCALIZABLE_ACCOUNTS_INFO_BUFFER; -EXTERN!{extern "system" { +pub type PDOMAIN_LOCALIZABLE_ACCOUNTS_INFO_BUFFER = + *mut DOMAIN_LOCALIZABLE_ACCOUNTS_INFO_BUFFER; +EXTERN! {extern "system" { fn SamLookupDomainInSamServer( ServerHandle: SAM_HANDLE, - Name: PUNICODE_STRING, + Name: *mut UNICODE_STRING, DomainId: *mut PSID, ) -> NTSTATUS; fn SamEnumerateDomainsInSamServer( ServerHandle: SAM_HANDLE, EnumerationContext: PSAM_ENUMERATE_HANDLE, - Buffer: *mut PVOID, - PreferedMaximumLength: ULONG, - CountReturned: PULONG, + Buffer: *mut *mut c_void, + PreferedMaximumLength: c_ulong, + CountReturned: *mut c_ulong, ) -> NTSTATUS; fn SamOpenDomain( ServerHandle: SAM_HANDLE, - DesiredAccess: ACCESS_MASK, + DesiredAccess: c_ulong, DomainId: PSID, DomainHandle: PSAM_HANDLE, ) -> NTSTATUS; fn SamQueryInformationDomain( DomainHandle: SAM_HANDLE, DomainInformationClass: DOMAIN_INFORMATION_CLASS, - Buffer: *mut PVOID, + Buffer: *mut *mut c_void, ) -> NTSTATUS; fn SamSetInformationDomain( DomainHandle: SAM_HANDLE, DomainInformationClass: DOMAIN_INFORMATION_CLASS, - DomainInformation: PVOID, + DomainInformation: *mut c_void, ) -> NTSTATUS; fn SamLookupNamesInDomain( DomainHandle: SAM_HANDLE, - Count: ULONG, - Names: PUNICODE_STRING, - RelativeIds: *mut PULONG, - Use: *mut PSID_NAME_USE, + Count: c_ulong, + Names: *mut UNICODE_STRING, + RelativeIds: *mut *mut c_ulong, + Use: *mut *mut SID_NAME_USE, ) -> NTSTATUS; fn SamLookupIdsInDomain( DomainHandle: SAM_HANDLE, - Count: ULONG, - RelativeIds: PULONG, - Names: *mut PUNICODE_STRING, - Use: *mut PSID_NAME_USE, + Count: c_ulong, + RelativeIds: *mut c_ulong, + Names: *mut *mut UNICODE_STRING, + Use: *mut *mut SID_NAME_USE, ) -> NTSTATUS; fn SamRemoveMemberFromForeignDomain( DomainHandle: SAM_HANDLE, @@ -319,73 +350,80 @@ EXTERN!{extern "system" { ) -> NTSTATUS; fn SamQueryLocalizableAccountsInDomain( Domain: SAM_HANDLE, - Flags: ULONG, - LanguageId: ULONG, + Flags: c_ulong, + LanguageId: c_ulong, Class: DOMAIN_LOCALIZABLE_ACCOUNTS_INFORMATION, - Buffer: *mut PVOID, + Buffer: *mut *mut c_void, ) -> NTSTATUS; }} -pub const GROUP_READ_INFORMATION: ACCESS_MASK = 0x0001; -pub const GROUP_WRITE_ACCOUNT: ACCESS_MASK = 0x0002; -pub const GROUP_ADD_MEMBER: ACCESS_MASK = 0x0004; -pub const GROUP_REMOVE_MEMBER: ACCESS_MASK = 0x0008; -pub const GROUP_LIST_MEMBERS: ACCESS_MASK = 0x0010; -pub const GROUP_ALL_ACCESS: ACCESS_MASK = STANDARD_RIGHTS_REQUIRED | GROUP_LIST_MEMBERS - | GROUP_WRITE_ACCOUNT | GROUP_ADD_MEMBER | GROUP_REMOVE_MEMBER | GROUP_READ_INFORMATION; -pub const GROUP_READ: ACCESS_MASK = STANDARD_RIGHTS_READ | GROUP_LIST_MEMBERS; -pub const GROUP_WRITE: ACCESS_MASK = - STANDARD_RIGHTS_WRITE | GROUP_WRITE_ACCOUNT | GROUP_ADD_MEMBER | GROUP_REMOVE_MEMBER; -pub const GROUP_EXECUTE: ACCESS_MASK = STANDARD_RIGHTS_EXECUTE | GROUP_READ_INFORMATION; -STRUCT!{struct GROUP_MEMBERSHIP { - RelativeId: ULONG, - Attributes: ULONG, +pub const GROUP_READ_INFORMATION: c_ulong = 0x0001; +pub const GROUP_WRITE_ACCOUNT: c_ulong = 0x0002; +pub const GROUP_ADD_MEMBER: c_ulong = 0x0004; +pub const GROUP_REMOVE_MEMBER: c_ulong = 0x0008; +pub const GROUP_LIST_MEMBERS: c_ulong = 0x0010; +pub const GROUP_ALL_ACCESS: c_ulong = STANDARD_RIGHTS_REQUIRED + | GROUP_LIST_MEMBERS + | GROUP_WRITE_ACCOUNT + | GROUP_ADD_MEMBER + | GROUP_REMOVE_MEMBER + | GROUP_READ_INFORMATION; +pub const GROUP_READ: c_ulong = STANDARD_RIGHTS_READ | GROUP_LIST_MEMBERS; +pub const GROUP_WRITE: c_ulong = STANDARD_RIGHTS_WRITE + | GROUP_WRITE_ACCOUNT + | GROUP_ADD_MEMBER + | GROUP_REMOVE_MEMBER; +pub const GROUP_EXECUTE: c_ulong = + STANDARD_RIGHTS_EXECUTE | GROUP_READ_INFORMATION; +STRUCT! {struct GROUP_MEMBERSHIP { + RelativeId: c_ulong, + Attributes: c_ulong, }} pub type PGROUP_MEMBERSHIP = *mut GROUP_MEMBERSHIP; -ENUM!{enum GROUP_INFORMATION_CLASS { +ENUM! {enum GROUP_INFORMATION_CLASS { GroupGeneralInformation = 1, GroupNameInformation = 2, GroupAttributeInformation = 3, GroupAdminCommentInformation = 4, GroupReplicationInformation = 5, }} -STRUCT!{struct GROUP_GENERAL_INFORMATION { +STRUCT! {struct GROUP_GENERAL_INFORMATION { Name: UNICODE_STRING, - Attributes: ULONG, - MemberCount: ULONG, + Attributes: c_ulong, + MemberCount: c_ulong, AdminComment: UNICODE_STRING, }} pub type PGROUP_GENERAL_INFORMATION = *mut GROUP_GENERAL_INFORMATION; -STRUCT!{struct GROUP_NAME_INFORMATION { +STRUCT! {struct GROUP_NAME_INFORMATION { Name: UNICODE_STRING, }} pub type PGROUP_NAME_INFORMATION = *mut GROUP_NAME_INFORMATION; -STRUCT!{struct GROUP_ATTRIBUTE_INFORMATION { - Attributes: ULONG, +STRUCT! {struct GROUP_ATTRIBUTE_INFORMATION { + Attributes: c_ulong, }} pub type PGROUP_ATTRIBUTE_INFORMATION = *mut GROUP_ATTRIBUTE_INFORMATION; -STRUCT!{struct GROUP_ADM_COMMENT_INFORMATION { +STRUCT! {struct GROUP_ADM_COMMENT_INFORMATION { AdminComment: UNICODE_STRING, }} pub type PGROUP_ADM_COMMENT_INFORMATION = *mut GROUP_ADM_COMMENT_INFORMATION; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn SamEnumerateGroupsInDomain( DomainHandle: SAM_HANDLE, EnumerationContext: PSAM_ENUMERATE_HANDLE, - Buffer: *mut PVOID, - PreferedMaximumLength: ULONG, - CountReturned: PULONG, + Buffer: *mut *mut c_void, + PreferedMaximumLength: c_ulong, + CountReturned: *mut c_ulong, ) -> NTSTATUS; fn SamCreateGroupInDomain( DomainHandle: SAM_HANDLE, - AccountName: PUNICODE_STRING, - DesiredAccess: ACCESS_MASK, + AccountName: *mut UNICODE_STRING, + DesiredAccess: c_ulong, GroupHandle: PSAM_HANDLE, - RelativeId: PULONG, + RelativeId: *mut c_ulong, ) -> NTSTATUS; fn SamOpenGroup( DomainHandle: SAM_HANDLE, - DesiredAccess: ACCESS_MASK, - GroupId: ULONG, + DesiredAccess: c_ulong, + GroupId: c_ulong, GroupHandle: PSAM_HANDLE, ) -> NTSTATUS; fn SamDeleteGroup( @@ -394,94 +432,101 @@ EXTERN!{extern "system" { fn SamQueryInformationGroup( GroupHandle: SAM_HANDLE, GroupInformationClass: GROUP_INFORMATION_CLASS, - Buffer: *mut PVOID, + Buffer: *mut *mut c_void, ) -> NTSTATUS; fn SamSetInformationGroup( GroupHandle: SAM_HANDLE, GroupInformationClass: GROUP_INFORMATION_CLASS, - Buffer: PVOID, + Buffer: *mut c_void, ) -> NTSTATUS; fn SamAddMemberToGroup( GroupHandle: SAM_HANDLE, - MemberId: ULONG, - Attributes: ULONG, + MemberId: c_ulong, + Attributes: c_ulong, ) -> NTSTATUS; fn SamRemoveMemberFromGroup( GroupHandle: SAM_HANDLE, - MemberId: ULONG, + MemberId: c_ulong, ) -> NTSTATUS; fn SamGetMembersInGroup( GroupHandle: SAM_HANDLE, - MemberIds: *mut PULONG, - Attributes: *mut PULONG, - MemberCount: PULONG, + MemberIds: *mut *mut c_ulong, + Attributes: *mut *mut c_ulong, + MemberCount: *mut c_ulong, ) -> NTSTATUS; fn SamSetMemberAttributesOfGroup( GroupHandle: SAM_HANDLE, - MemberId: ULONG, - Attributes: ULONG, + MemberId: c_ulong, + Attributes: c_ulong, ) -> NTSTATUS; }} -pub const ALIAS_ADD_MEMBER: ACCESS_MASK = 0x0001; -pub const ALIAS_REMOVE_MEMBER: ACCESS_MASK = 0x0002; -pub const ALIAS_LIST_MEMBERS: ACCESS_MASK = 0x0004; -pub const ALIAS_READ_INFORMATION: ACCESS_MASK = 0x0008; -pub const ALIAS_WRITE_ACCOUNT: ACCESS_MASK = 0x0010; -pub const ALIAS_ALL_ACCESS: ACCESS_MASK = STANDARD_RIGHTS_REQUIRED | ALIAS_READ_INFORMATION - | ALIAS_WRITE_ACCOUNT | ALIAS_LIST_MEMBERS | ALIAS_ADD_MEMBER | ALIAS_REMOVE_MEMBER; -pub const ALIAS_READ: ACCESS_MASK = STANDARD_RIGHTS_READ | ALIAS_LIST_MEMBERS; -pub const ALIAS_WRITE: ACCESS_MASK = - STANDARD_RIGHTS_WRITE | ALIAS_WRITE_ACCOUNT | ALIAS_ADD_MEMBER | ALIAS_REMOVE_MEMBER; -pub const ALIAS_EXECUTE: ACCESS_MASK = STANDARD_RIGHTS_EXECUTE | ALIAS_READ_INFORMATION; -ENUM!{enum ALIAS_INFORMATION_CLASS { +pub const ALIAS_ADD_MEMBER: c_ulong = 0x0001; +pub const ALIAS_REMOVE_MEMBER: c_ulong = 0x0002; +pub const ALIAS_LIST_MEMBERS: c_ulong = 0x0004; +pub const ALIAS_READ_INFORMATION: c_ulong = 0x0008; +pub const ALIAS_WRITE_ACCOUNT: c_ulong = 0x0010; +pub const ALIAS_ALL_ACCESS: c_ulong = STANDARD_RIGHTS_REQUIRED + | ALIAS_READ_INFORMATION + | ALIAS_WRITE_ACCOUNT + | ALIAS_LIST_MEMBERS + | ALIAS_ADD_MEMBER + | ALIAS_REMOVE_MEMBER; +pub const ALIAS_READ: c_ulong = STANDARD_RIGHTS_READ | ALIAS_LIST_MEMBERS; +pub const ALIAS_WRITE: c_ulong = STANDARD_RIGHTS_WRITE + | ALIAS_WRITE_ACCOUNT + | ALIAS_ADD_MEMBER + | ALIAS_REMOVE_MEMBER; +pub const ALIAS_EXECUTE: c_ulong = + STANDARD_RIGHTS_EXECUTE | ALIAS_READ_INFORMATION; +ENUM! {enum ALIAS_INFORMATION_CLASS { AliasGeneralInformation = 1, AliasNameInformation = 2, AliasAdminCommentInformation = 3, AliasReplicationInformation = 4, AliasExtendedInformation = 5, }} -STRUCT!{struct ALIAS_GENERAL_INFORMATION { +STRUCT! {struct ALIAS_GENERAL_INFORMATION { Name: UNICODE_STRING, - MemberCount: ULONG, + MemberCount: c_ulong, AdminComment: UNICODE_STRING, }} pub type PALIAS_GENERAL_INFORMATION = *mut ALIAS_GENERAL_INFORMATION; -STRUCT!{struct ALIAS_NAME_INFORMATION { +STRUCT! {struct ALIAS_NAME_INFORMATION { Name: UNICODE_STRING, }} pub type PALIAS_NAME_INFORMATION = *mut ALIAS_NAME_INFORMATION; -STRUCT!{struct ALIAS_ADM_COMMENT_INFORMATION { +STRUCT! {struct ALIAS_ADM_COMMENT_INFORMATION { AdminComment: UNICODE_STRING, }} pub type PALIAS_ADM_COMMENT_INFORMATION = *mut ALIAS_ADM_COMMENT_INFORMATION; -pub const ALIAS_ALL_NAME: ULONG = 0x00000001; -pub const ALIAS_ALL_MEMBER_COUNT: ULONG = 0x00000002; -pub const ALIAS_ALL_ADMIN_COMMENT: ULONG = 0x00000004; -pub const ALIAS_ALL_SHELL_ADMIN_OBJECT_PROPERTIES: ULONG = 0x00000008; -STRUCT!{struct ALIAS_EXTENDED_INFORMATION { - WhichFields: ULONG, +pub const ALIAS_ALL_NAME: c_ulong = 0x00000001; +pub const ALIAS_ALL_MEMBER_COUNT: c_ulong = 0x00000002; +pub const ALIAS_ALL_ADMIN_COMMENT: c_ulong = 0x00000004; +pub const ALIAS_ALL_SHELL_ADMIN_OBJECT_PROPERTIES: c_ulong = 0x00000008; +STRUCT! {struct ALIAS_EXTENDED_INFORMATION { + WhichFields: c_ulong, ShellAdminObjectProperties: SAM_SHELL_OBJECT_PROPERTIES, }} pub type PALIAS_EXTENDED_INFORMATION = *mut ALIAS_EXTENDED_INFORMATION; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn SamEnumerateAliasesInDomain( DomainHandle: SAM_HANDLE, EnumerationContext: PSAM_ENUMERATE_HANDLE, - Buffer: *mut PVOID, - PreferedMaximumLength: ULONG, - CountReturned: PULONG, + Buffer: *mut *mut c_void, + PreferedMaximumLength: c_ulong, + CountReturned: *mut c_ulong, ) -> NTSTATUS; fn SamCreateAliasInDomain( DomainHandle: SAM_HANDLE, - AccountName: PUNICODE_STRING, - DesiredAccess: ACCESS_MASK, + AccountName: *mut UNICODE_STRING, + DesiredAccess: c_ulong, AliasHandle: PSAM_HANDLE, - RelativeId: PULONG, + RelativeId: *mut c_ulong, ) -> NTSTATUS; fn SamOpenAlias( DomainHandle: SAM_HANDLE, - DesiredAccess: ACCESS_MASK, - AliasId: ULONG, + DesiredAccess: c_ulong, + AliasId: c_ulong, AliasHandle: PSAM_HANDLE, ) -> NTSTATUS; fn SamDeleteAlias( @@ -490,12 +535,12 @@ EXTERN!{extern "system" { fn SamQueryInformationAlias( AliasHandle: SAM_HANDLE, AliasInformationClass: ALIAS_INFORMATION_CLASS, - Buffer: *mut PVOID, + Buffer: *mut *mut c_void, ) -> NTSTATUS; fn SamSetInformationAlias( AliasHandle: SAM_HANDLE, AliasInformationClass: ALIAS_INFORMATION_CLASS, - Buffer: PVOID, + Buffer: *mut c_void, ) -> NTSTATUS; fn SamAddMemberToAlias( AliasHandle: SAM_HANDLE, @@ -504,7 +549,7 @@ EXTERN!{extern "system" { fn SamAddMultipleMembersToAlias( AliasHandle: SAM_HANDLE, MemberIds: *mut PSID, - MemberCount: ULONG, + MemberCount: c_ulong, ) -> NTSTATUS; fn SamRemoveMemberFromAlias( AliasHandle: SAM_HANDLE, @@ -513,19 +558,19 @@ EXTERN!{extern "system" { fn SamRemoveMultipleMembersFromAlias( AliasHandle: SAM_HANDLE, MemberIds: *mut PSID, - MemberCount: ULONG, + MemberCount: c_ulong, ) -> NTSTATUS; fn SamGetMembersInAlias( AliasHandle: SAM_HANDLE, MemberIds: *mut *mut PSID, - MemberCount: PULONG, + MemberCount: *mut c_ulong, ) -> NTSTATUS; fn SamGetAliasMembership( DomainHandle: SAM_HANDLE, - PassedCount: ULONG, + PassedCount: c_ulong, Sids: *mut PSID, - MembershipCount: PULONG, - Aliases: *mut PULONG, + MembershipCount: *mut c_ulong, + Aliases: *mut *mut c_ulong, ) -> NTSTATUS; }} pub const GROUP_TYPE_BUILTIN_LOCAL_GROUP: u32 = 0x00000001; @@ -535,29 +580,43 @@ pub const GROUP_TYPE_UNIVERSAL_GROUP: u32 = 0x00000008; pub const GROUP_TYPE_APP_BASIC_GROUP: u32 = 0x00000010; pub const GROUP_TYPE_APP_QUERY_GROUP: u32 = 0x00000020; pub const GROUP_TYPE_SECURITY_ENABLED: u32 = 0x80000000; -pub const GROUP_TYPE_RESOURCE_BEHAVOIR: u32 = - GROUP_TYPE_RESOURCE_GROUP | GROUP_TYPE_APP_BASIC_GROUP | GROUP_TYPE_APP_QUERY_GROUP; -pub const USER_READ_GENERAL: DWORD = 0x0001; -pub const USER_READ_PREFERENCES: DWORD = 0x0002; -pub const USER_WRITE_PREFERENCES: DWORD = 0x0004; -pub const USER_READ_LOGON: DWORD = 0x0008; -pub const USER_READ_ACCOUNT: DWORD = 0x0010; -pub const USER_WRITE_ACCOUNT: DWORD = 0x0020; -pub const USER_CHANGE_PASSWORD: DWORD = 0x0040; -pub const USER_FORCE_PASSWORD_CHANGE: DWORD = 0x0080; -pub const USER_LIST_GROUPS: DWORD = 0x0100; -pub const USER_READ_GROUP_INFORMATION: DWORD = 0x0200; -pub const USER_WRITE_GROUP_INFORMATION: DWORD = 0x0400; -pub const USER_ALL_ACCESS: DWORD = STANDARD_RIGHTS_REQUIRED | USER_READ_PREFERENCES - | USER_READ_LOGON | USER_LIST_GROUPS | USER_READ_GROUP_INFORMATION | USER_WRITE_PREFERENCES - | USER_CHANGE_PASSWORD | USER_FORCE_PASSWORD_CHANGE | USER_READ_GENERAL | USER_READ_ACCOUNT - | USER_WRITE_ACCOUNT | USER_WRITE_GROUP_INFORMATION; -pub const USER_READ: DWORD = STANDARD_RIGHTS_READ | USER_READ_PREFERENCES | USER_READ_LOGON - | USER_READ_ACCOUNT | USER_LIST_GROUPS | USER_READ_GROUP_INFORMATION; -pub const USER_WRITE: DWORD = +pub const GROUP_TYPE_RESOURCE_BEHAVOIR: u32 = GROUP_TYPE_RESOURCE_GROUP + | GROUP_TYPE_APP_BASIC_GROUP + | GROUP_TYPE_APP_QUERY_GROUP; +pub const USER_READ_GENERAL: c_ulong = 0x0001; +pub const USER_READ_PREFERENCES: c_ulong = 0x0002; +pub const USER_WRITE_PREFERENCES: c_ulong = 0x0004; +pub const USER_READ_LOGON: c_ulong = 0x0008; +pub const USER_READ_ACCOUNT: c_ulong = 0x0010; +pub const USER_WRITE_ACCOUNT: c_ulong = 0x0020; +pub const USER_CHANGE_PASSWORD: c_ulong = 0x0040; +pub const USER_FORCE_PASSWORD_CHANGE: c_ulong = 0x0080; +pub const USER_LIST_GROUPS: c_ulong = 0x0100; +pub const USER_READ_GROUP_INFORMATION: c_ulong = 0x0200; +pub const USER_WRITE_GROUP_INFORMATION: c_ulong = 0x0400; +pub const USER_ALL_ACCESS: c_ulong = STANDARD_RIGHTS_REQUIRED + | USER_READ_PREFERENCES + | USER_READ_LOGON + | USER_LIST_GROUPS + | USER_READ_GROUP_INFORMATION + | USER_WRITE_PREFERENCES + | USER_CHANGE_PASSWORD + | USER_FORCE_PASSWORD_CHANGE + | USER_READ_GENERAL + | USER_READ_ACCOUNT + | USER_WRITE_ACCOUNT + | USER_WRITE_GROUP_INFORMATION; +pub const USER_READ: c_ulong = STANDARD_RIGHTS_READ + | USER_READ_PREFERENCES + | USER_READ_LOGON + | USER_READ_ACCOUNT + | USER_LIST_GROUPS + | USER_READ_GROUP_INFORMATION; +pub const USER_WRITE: c_ulong = STANDARD_RIGHTS_WRITE | USER_WRITE_PREFERENCES | USER_CHANGE_PASSWORD; -pub const USER_EXECUTE: DWORD = STANDARD_RIGHTS_EXECUTE | USER_READ_GENERAL | USER_CHANGE_PASSWORD; -ENUM!{enum USER_INFORMATION_CLASS { +pub const USER_EXECUTE: c_ulong = + STANDARD_RIGHTS_EXECUTE | USER_READ_GENERAL | USER_CHANGE_PASSWORD; +ENUM! {enum USER_INFORMATION_CLASS { UserGeneralInformation = 1, UserPreferencesInformation = 2, UserLogonInformation = 3, @@ -589,88 +648,121 @@ ENUM!{enum USER_INFORMATION_CLASS { UserLogonUIInformation = 29, }} pub type PUSER_INFORMATION_CLASS = *mut USER_INFORMATION_CLASS; -pub const USER_ALL_USERNAME: ULONG = 0x00000001; -pub const USER_ALL_FULLNAME: ULONG = 0x00000002; -pub const USER_ALL_USERID: ULONG = 0x00000004; -pub const USER_ALL_PRIMARYGROUPID: ULONG = 0x00000008; -pub const USER_ALL_ADMINCOMMENT: ULONG = 0x00000010; -pub const USER_ALL_USERCOMMENT: ULONG = 0x00000020; -pub const USER_ALL_HOMEDIRECTORY: ULONG = 0x00000040; -pub const USER_ALL_HOMEDIRECTORYDRIVE: ULONG = 0x00000080; -pub const USER_ALL_SCRIPTPATH: ULONG = 0x00000100; -pub const USER_ALL_PROFILEPATH: ULONG = 0x00000200; -pub const USER_ALL_WORKSTATIONS: ULONG = 0x00000400; -pub const USER_ALL_LASTLOGON: ULONG = 0x00000800; -pub const USER_ALL_LASTLOGOFF: ULONG = 0x00001000; -pub const USER_ALL_LOGONHOURS: ULONG = 0x00002000; -pub const USER_ALL_BADPASSWORDCOUNT: ULONG = 0x00004000; -pub const USER_ALL_LOGONCOUNT: ULONG = 0x00008000; -pub const USER_ALL_PASSWORDCANCHANGE: ULONG = 0x00010000; -pub const USER_ALL_PASSWORDMUSTCHANGE: ULONG = 0x00020000; -pub const USER_ALL_PASSWORDLASTSET: ULONG = 0x00040000; -pub const USER_ALL_ACCOUNTEXPIRES: ULONG = 0x00080000; -pub const USER_ALL_USERACCOUNTCONTROL: ULONG = 0x00100000; -pub const USER_ALL_PARAMETERS: ULONG = 0x00200000; -pub const USER_ALL_COUNTRYCODE: ULONG = 0x00400000; -pub const USER_ALL_CODEPAGE: ULONG = 0x00800000; -pub const USER_ALL_NTPASSWORDPRESENT: ULONG = 0x01000000; -pub const USER_ALL_LMPASSWORDPRESENT: ULONG = 0x02000000; -pub const USER_ALL_PRIVATEDATA: ULONG = 0x04000000; -pub const USER_ALL_PASSWORDEXPIRED: ULONG = 0x08000000; -pub const USER_ALL_SECURITYDESCRIPTOR: ULONG = 0x10000000; -pub const USER_ALL_OWFPASSWORD: ULONG = 0x20000000; -pub const USER_ALL_UNDEFINED_MASK: ULONG = 0xc0000000; -pub const USER_ALL_READ_GENERAL_MASK: ULONG = USER_ALL_USERNAME | USER_ALL_FULLNAME - | USER_ALL_USERID | USER_ALL_PRIMARYGROUPID | USER_ALL_ADMINCOMMENT | USER_ALL_USERCOMMENT; -pub const USER_ALL_READ_LOGON_MASK: ULONG = USER_ALL_HOMEDIRECTORY | USER_ALL_HOMEDIRECTORYDRIVE - | USER_ALL_SCRIPTPATH | USER_ALL_PROFILEPATH | USER_ALL_WORKSTATIONS | USER_ALL_LASTLOGON - | USER_ALL_LASTLOGOFF | USER_ALL_LOGONHOURS | USER_ALL_BADPASSWORDCOUNT | USER_ALL_LOGONCOUNT - | USER_ALL_PASSWORDCANCHANGE | USER_ALL_PASSWORDMUSTCHANGE; -pub const USER_ALL_READ_ACCOUNT_MASK: ULONG = USER_ALL_PASSWORDLASTSET | USER_ALL_ACCOUNTEXPIRES - | USER_ALL_USERACCOUNTCONTROL | USER_ALL_PARAMETERS; -pub const USER_ALL_READ_PREFERENCES_MASK: ULONG = USER_ALL_COUNTRYCODE | USER_ALL_CODEPAGE; -pub const USER_ALL_READ_TRUSTED_MASK: ULONG = USER_ALL_NTPASSWORDPRESENT - | USER_ALL_LMPASSWORDPRESENT | USER_ALL_PASSWORDEXPIRED | USER_ALL_SECURITYDESCRIPTOR +pub const USER_ALL_USERNAME: c_ulong = 0x00000001; +pub const USER_ALL_FULLNAME: c_ulong = 0x00000002; +pub const USER_ALL_USERID: c_ulong = 0x00000004; +pub const USER_ALL_PRIMARYGROUPID: c_ulong = 0x00000008; +pub const USER_ALL_ADMINCOMMENT: c_ulong = 0x00000010; +pub const USER_ALL_USERCOMMENT: c_ulong = 0x00000020; +pub const USER_ALL_HOMEDIRECTORY: c_ulong = 0x00000040; +pub const USER_ALL_HOMEDIRECTORYDRIVE: c_ulong = 0x00000080; +pub const USER_ALL_SCRIPTPATH: c_ulong = 0x00000100; +pub const USER_ALL_PROFILEPATH: c_ulong = 0x00000200; +pub const USER_ALL_WORKSTATIONS: c_ulong = 0x00000400; +pub const USER_ALL_LASTLOGON: c_ulong = 0x00000800; +pub const USER_ALL_LASTLOGOFF: c_ulong = 0x00001000; +pub const USER_ALL_LOGONHOURS: c_ulong = 0x00002000; +pub const USER_ALL_BADPASSWORDCOUNT: c_ulong = 0x00004000; +pub const USER_ALL_LOGONCOUNT: c_ulong = 0x00008000; +pub const USER_ALL_PASSWORDCANCHANGE: c_ulong = 0x00010000; +pub const USER_ALL_PASSWORDMUSTCHANGE: c_ulong = 0x00020000; +pub const USER_ALL_PASSWORDLASTSET: c_ulong = 0x00040000; +pub const USER_ALL_ACCOUNTEXPIRES: c_ulong = 0x00080000; +pub const USER_ALL_USERACCOUNTCONTROL: c_ulong = 0x00100000; +pub const USER_ALL_PARAMETERS: c_ulong = 0x00200000; +pub const USER_ALL_COUNTRYCODE: c_ulong = 0x00400000; +pub const USER_ALL_CODEPAGE: c_ulong = 0x00800000; +pub const USER_ALL_NTPASSWORDPRESENT: c_ulong = 0x01000000; +pub const USER_ALL_LMPASSWORDPRESENT: c_ulong = 0x02000000; +pub const USER_ALL_PRIVATEDATA: c_ulong = 0x04000000; +pub const USER_ALL_PASSWORDEXPIRED: c_ulong = 0x08000000; +pub const USER_ALL_SECURITYDESCRIPTOR: c_ulong = 0x10000000; +pub const USER_ALL_OWFPASSWORD: c_ulong = 0x20000000; +pub const USER_ALL_UNDEFINED_MASK: c_ulong = 0xc0000000; +pub const USER_ALL_READ_GENERAL_MASK: c_ulong = USER_ALL_USERNAME + | USER_ALL_FULLNAME + | USER_ALL_USERID + | USER_ALL_PRIMARYGROUPID + | USER_ALL_ADMINCOMMENT + | USER_ALL_USERCOMMENT; +pub const USER_ALL_READ_LOGON_MASK: c_ulong = USER_ALL_HOMEDIRECTORY + | USER_ALL_HOMEDIRECTORYDRIVE + | USER_ALL_SCRIPTPATH + | USER_ALL_PROFILEPATH + | USER_ALL_WORKSTATIONS + | USER_ALL_LASTLOGON + | USER_ALL_LASTLOGOFF + | USER_ALL_LOGONHOURS + | USER_ALL_BADPASSWORDCOUNT + | USER_ALL_LOGONCOUNT + | USER_ALL_PASSWORDCANCHANGE + | USER_ALL_PASSWORDMUSTCHANGE; +pub const USER_ALL_READ_ACCOUNT_MASK: c_ulong = USER_ALL_PASSWORDLASTSET + | USER_ALL_ACCOUNTEXPIRES + | USER_ALL_USERACCOUNTCONTROL + | USER_ALL_PARAMETERS; +pub const USER_ALL_READ_PREFERENCES_MASK: c_ulong = + USER_ALL_COUNTRYCODE | USER_ALL_CODEPAGE; +pub const USER_ALL_READ_TRUSTED_MASK: c_ulong = USER_ALL_NTPASSWORDPRESENT + | USER_ALL_LMPASSWORDPRESENT + | USER_ALL_PASSWORDEXPIRED + | USER_ALL_SECURITYDESCRIPTOR | USER_ALL_PRIVATEDATA; -pub const USER_ALL_READ_CANT_MASK: ULONG = USER_ALL_UNDEFINED_MASK; -pub const USER_ALL_WRITE_ACCOUNT_MASK: ULONG = USER_ALL_USERNAME | USER_ALL_FULLNAME - | USER_ALL_PRIMARYGROUPID | USER_ALL_HOMEDIRECTORY | USER_ALL_HOMEDIRECTORYDRIVE - | USER_ALL_SCRIPTPATH | USER_ALL_PROFILEPATH | USER_ALL_ADMINCOMMENT | USER_ALL_WORKSTATIONS - | USER_ALL_LOGONHOURS | USER_ALL_ACCOUNTEXPIRES | USER_ALL_USERACCOUNTCONTROL +pub const USER_ALL_READ_CANT_MASK: c_ulong = USER_ALL_UNDEFINED_MASK; +pub const USER_ALL_WRITE_ACCOUNT_MASK: c_ulong = USER_ALL_USERNAME + | USER_ALL_FULLNAME + | USER_ALL_PRIMARYGROUPID + | USER_ALL_HOMEDIRECTORY + | USER_ALL_HOMEDIRECTORYDRIVE + | USER_ALL_SCRIPTPATH + | USER_ALL_PROFILEPATH + | USER_ALL_ADMINCOMMENT + | USER_ALL_WORKSTATIONS + | USER_ALL_LOGONHOURS + | USER_ALL_ACCOUNTEXPIRES + | USER_ALL_USERACCOUNTCONTROL | USER_ALL_PARAMETERS; -pub const USER_ALL_WRITE_PREFERENCES_MASK: ULONG = +pub const USER_ALL_WRITE_PREFERENCES_MASK: c_ulong = USER_ALL_USERCOMMENT | USER_ALL_COUNTRYCODE | USER_ALL_CODEPAGE; -pub const USER_ALL_WRITE_FORCE_PASSWORD_CHANGE_MASK: ULONG = - USER_ALL_NTPASSWORDPRESENT | USER_ALL_LMPASSWORDPRESENT | USER_ALL_PASSWORDEXPIRED; -pub const USER_ALL_WRITE_TRUSTED_MASK: ULONG = USER_ALL_LASTLOGON | USER_ALL_LASTLOGOFF - | USER_ALL_BADPASSWORDCOUNT | USER_ALL_LOGONCOUNT | USER_ALL_PASSWORDLASTSET - | USER_ALL_SECURITYDESCRIPTOR | USER_ALL_PRIVATEDATA; -pub const USER_ALL_WRITE_CANT_MASK: ULONG = USER_ALL_USERID | USER_ALL_PASSWORDCANCHANGE - | USER_ALL_PASSWORDMUSTCHANGE | USER_ALL_UNDEFINED_MASK; -STRUCT!{struct USER_GENERAL_INFORMATION { +pub const USER_ALL_WRITE_FORCE_PASSWORD_CHANGE_MASK: c_ulong = + USER_ALL_NTPASSWORDPRESENT + | USER_ALL_LMPASSWORDPRESENT + | USER_ALL_PASSWORDEXPIRED; +pub const USER_ALL_WRITE_TRUSTED_MASK: c_ulong = USER_ALL_LASTLOGON + | USER_ALL_LASTLOGOFF + | USER_ALL_BADPASSWORDCOUNT + | USER_ALL_LOGONCOUNT + | USER_ALL_PASSWORDLASTSET + | USER_ALL_SECURITYDESCRIPTOR + | USER_ALL_PRIVATEDATA; +pub const USER_ALL_WRITE_CANT_MASK: c_ulong = USER_ALL_USERID + | USER_ALL_PASSWORDCANCHANGE + | USER_ALL_PASSWORDMUSTCHANGE + | USER_ALL_UNDEFINED_MASK; +STRUCT! {struct USER_GENERAL_INFORMATION { UserName: UNICODE_STRING, FullName: UNICODE_STRING, - PrimaryGroupId: ULONG, + PrimaryGroupId: c_ulong, AdminComment: UNICODE_STRING, UserComment: UNICODE_STRING, }} pub type PUSER_GENERAL_INFORMATION = *mut USER_GENERAL_INFORMATION; -STRUCT!{struct USER_PREFERENCES_INFORMATION { +STRUCT! {struct USER_PREFERENCES_INFORMATION { UserComment: UNICODE_STRING, Reserved1: UNICODE_STRING, - CountryCode: USHORT, - CodePage: USHORT, + CountryCode: c_ushort, + CodePage: c_ushort, }} pub type PUSER_PREFERENCES_INFORMATION = *mut USER_PREFERENCES_INFORMATION; -STRUCT!{struct USER_PARAMETERS_INFORMATION { +STRUCT! {struct USER_PARAMETERS_INFORMATION { Parameters: UNICODE_STRING, }} pub type PUSER_PARAMETERS_INFORMATION = *mut USER_PARAMETERS_INFORMATION; -STRUCT!{#[repr(packed(4))] struct USER_LOGON_INFORMATION { +STRUCT! {#[repr(packed(4))] struct USER_LOGON_INFORMATION { UserName: UNICODE_STRING, FullName: UNICODE_STRING, - UserId: ULONG, - PrimaryGroupId: ULONG, + UserId: c_ulong, + PrimaryGroupId: c_ulong, HomeDirectory: UNICODE_STRING, HomeDirectoryDrive: UNICODE_STRING, ScriptPath: UNICODE_STRING, @@ -682,16 +774,16 @@ STRUCT!{#[repr(packed(4))] struct USER_LOGON_INFORMATION { PasswordCanChange: LARGE_INTEGER, PasswordMustChange: LARGE_INTEGER, LogonHours: LOGON_HOURS, - BadPasswordCount: USHORT, - LogonCount: USHORT, - UserAccountControl: ULONG, + BadPasswordCount: c_ushort, + LogonCount: c_ushort, + UserAccountControl: c_ulong, }} pub type PUSER_LOGON_INFORMATION = *mut USER_LOGON_INFORMATION; -STRUCT!{#[repr(packed(4))] struct USER_ACCOUNT_INFORMATION { +STRUCT! {#[repr(packed(4))] struct USER_ACCOUNT_INFORMATION { UserName: UNICODE_STRING, FullName: UNICODE_STRING, - UserId: ULONG, - PrimaryGroupId: ULONG, + UserId: c_ulong, + PrimaryGroupId: c_ulong, HomeDirectory: UNICODE_STRING, HomeDirectoryDrive: UNICODE_STRING, ScriptPath: UNICODE_STRING, @@ -701,92 +793,94 @@ STRUCT!{#[repr(packed(4))] struct USER_ACCOUNT_INFORMATION { LastLogon: LARGE_INTEGER, LastLogoff: LARGE_INTEGER, LogonHours: LOGON_HOURS, - BadPasswordCount: USHORT, - LogonCount: USHORT, + BadPasswordCount: c_ushort, + LogonCount: c_ushort, PasswordLastSet: LARGE_INTEGER, AccountExpires: LARGE_INTEGER, - UserAccountControl: ULONG, + UserAccountControl: c_ulong, }} pub type PUSER_ACCOUNT_INFORMATION = *mut USER_ACCOUNT_INFORMATION; -STRUCT!{struct USER_ACCOUNT_NAME_INFORMATION { +STRUCT! {struct USER_ACCOUNT_NAME_INFORMATION { UserName: UNICODE_STRING, }} pub type PUSER_ACCOUNT_NAME_INFORMATION = *mut USER_ACCOUNT_NAME_INFORMATION; -STRUCT!{struct USER_FULL_NAME_INFORMATION { +STRUCT! {struct USER_FULL_NAME_INFORMATION { FullName: UNICODE_STRING, }} pub type PUSER_FULL_NAME_INFORMATION = *mut USER_FULL_NAME_INFORMATION; -STRUCT!{struct USER_NAME_INFORMATION { +STRUCT! {struct USER_NAME_INFORMATION { UserName: UNICODE_STRING, FullName: UNICODE_STRING, }} pub type PUSER_NAME_INFORMATION = *mut USER_NAME_INFORMATION; -STRUCT!{struct USER_PRIMARY_GROUP_INFORMATION { - PrimaryGroupId: ULONG, +STRUCT! {struct USER_PRIMARY_GROUP_INFORMATION { + PrimaryGroupId: c_ulong, }} pub type PUSER_PRIMARY_GROUP_INFORMATION = *mut USER_PRIMARY_GROUP_INFORMATION; -STRUCT!{struct USER_HOME_INFORMATION { +STRUCT! {struct USER_HOME_INFORMATION { HomeDirectory: UNICODE_STRING, HomeDirectoryDrive: UNICODE_STRING, }} pub type PUSER_HOME_INFORMATION = *mut USER_HOME_INFORMATION; -STRUCT!{struct USER_SCRIPT_INFORMATION { +STRUCT! {struct USER_SCRIPT_INFORMATION { ScriptPath: UNICODE_STRING, }} pub type PUSER_SCRIPT_INFORMATION = *mut USER_SCRIPT_INFORMATION; -STRUCT!{struct USER_PROFILE_INFORMATION { +STRUCT! {struct USER_PROFILE_INFORMATION { ProfilePath: UNICODE_STRING, }} pub type PUSER_PROFILE_INFORMATION = *mut USER_PROFILE_INFORMATION; -STRUCT!{struct USER_ADMIN_COMMENT_INFORMATION { +STRUCT! {struct USER_ADMIN_COMMENT_INFORMATION { AdminComment: UNICODE_STRING, }} pub type PUSER_ADMIN_COMMENT_INFORMATION = *mut USER_ADMIN_COMMENT_INFORMATION; -STRUCT!{struct USER_WORKSTATIONS_INFORMATION { +STRUCT! {struct USER_WORKSTATIONS_INFORMATION { WorkStations: UNICODE_STRING, }} pub type PUSER_WORKSTATIONS_INFORMATION = *mut USER_WORKSTATIONS_INFORMATION; -STRUCT!{struct USER_SET_PASSWORD_INFORMATION { +STRUCT! {struct USER_SET_PASSWORD_INFORMATION { Password: UNICODE_STRING, - PasswordExpired: BOOLEAN, + PasswordExpired: c_uchar, }} pub type PUSER_SET_PASSWORD_INFORMATION = *mut USER_SET_PASSWORD_INFORMATION; -STRUCT!{struct USER_CONTROL_INFORMATION { - UserAccountControl: ULONG, +STRUCT! {struct USER_CONTROL_INFORMATION { + UserAccountControl: c_ulong, }} pub type PUSER_CONTROL_INFORMATION = *mut USER_CONTROL_INFORMATION; -STRUCT!{struct USER_EXPIRES_INFORMATION { +STRUCT! {struct USER_EXPIRES_INFORMATION { AccountExpires: LARGE_INTEGER, }} pub type PUSER_EXPIRES_INFORMATION = *mut USER_EXPIRES_INFORMATION; -STRUCT!{struct USER_LOGON_HOURS_INFORMATION { +STRUCT! {struct USER_LOGON_HOURS_INFORMATION { LogonHours: LOGON_HOURS, }} pub type PUSER_LOGON_HOURS_INFORMATION = *mut USER_LOGON_HOURS_INFORMATION; pub type SAM_USER_TILE = SAM_BYTE_ARRAY_32K; pub type PSAM_USER_TILE = *mut SAM_BYTE_ARRAY_32K; -pub const USER_EXTENDED_FIELD_USER_TILE: ULONG = 0x00001000; -pub const USER_EXTENDED_FIELD_PASSWORD_HINT: ULONG = 0x00002000; -pub const USER_EXTENDED_FIELD_DONT_SHOW_IN_LOGON_UI: ULONG = 0x00004000; -pub const USER_EXTENDED_FIELD_SHELL_ADMIN_OBJECT_PROPERTIES: ULONG = 0x00008000; -STRUCT!{struct USER_EXTENDED_INFORMATION { - ExtendedWhichFields: ULONG, +pub const USER_EXTENDED_FIELD_USER_TILE: c_ulong = 0x00001000; +pub const USER_EXTENDED_FIELD_PASSWORD_HINT: c_ulong = 0x00002000; +pub const USER_EXTENDED_FIELD_DONT_SHOW_IN_LOGON_UI: c_ulong = 0x00004000; +pub const USER_EXTENDED_FIELD_SHELL_ADMIN_OBJECT_PROPERTIES: c_ulong = + 0x00008000; +STRUCT! {struct USER_EXTENDED_INFORMATION { + ExtendedWhichFields: c_ulong, UserTile: SAM_USER_TILE, PasswordHint: UNICODE_STRING, - DontShowInLogonUI: BOOLEAN, + DontShowInLogonUI: c_uchar, ShellAdminObjectProperties: SAM_SHELL_OBJECT_PROPERTIES, }} pub type PUSER_EXTENDED_INFORMATION = *mut USER_EXTENDED_INFORMATION; -STRUCT!{struct USER_LOGON_UI_INFORMATION { - PasswordIsBlank: BOOLEAN, - AccountIsDisabled: BOOLEAN, +STRUCT! {struct USER_LOGON_UI_INFORMATION { + PasswordIsBlank: c_uchar, + AccountIsDisabled: c_uchar, }} pub type PUSER_LOGON_UI_INFORMATION = *mut USER_LOGON_UI_INFORMATION; -STRUCT!{struct USER_PWD_CHANGE_FAILURE_INFORMATION { - ExtendedFailureReason: ULONG, +STRUCT! {struct USER_PWD_CHANGE_FAILURE_INFORMATION { + ExtendedFailureReason: c_ulong, FilterModuleName: UNICODE_STRING, }} -pub type PUSER_PWD_CHANGE_FAILURE_INFORMATION = *mut USER_PWD_CHANGE_FAILURE_INFORMATION; +pub type PUSER_PWD_CHANGE_FAILURE_INFORMATION = + *mut USER_PWD_CHANGE_FAILURE_INFORMATION; pub const SAM_PWD_CHANGE_NO_ERROR: u32 = 0; pub const SAM_PWD_CHANGE_PASSWORD_TOO_SHORT: u32 = 1; pub const SAM_PWD_CHANGE_PWD_IN_HISTORY: u32 = 2; @@ -797,35 +891,35 @@ pub const SAM_PWD_CHANGE_MACHINE_PASSWORD_NOT_DEFAULT: u32 = 6; pub const SAM_PWD_CHANGE_FAILED_BY_FILTER: u32 = 7; pub const SAM_PWD_CHANGE_PASSWORD_TOO_LONG: u32 = 8; pub const SAM_PWD_CHANGE_FAILURE_REASON_MAX: u32 = 8; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn SamEnumerateUsersInDomain( DomainHandle: SAM_HANDLE, EnumerationContext: PSAM_ENUMERATE_HANDLE, - UserAccountControl: ULONG, - Buffer: *mut PVOID, - PreferedMaximumLength: ULONG, - CountReturned: PULONG, + UserAccountControl: c_ulong, + Buffer: *mut *mut c_void, + PreferedMaximumLength: c_ulong, + CountReturned: *mut c_ulong, ) -> NTSTATUS; fn SamCreateUserInDomain( DomainHandle: SAM_HANDLE, - AccountName: PUNICODE_STRING, - DesiredAccess: ACCESS_MASK, + AccountName: *mut UNICODE_STRING, + DesiredAccess: c_ulong, UserHandle: PSAM_HANDLE, - RelativeId: PULONG, + RelativeId: *mut c_ulong, ) -> NTSTATUS; fn SamCreateUser2InDomain( DomainHandle: SAM_HANDLE, - AccountName: PUNICODE_STRING, - AccountType: ULONG, - DesiredAccess: ACCESS_MASK, + AccountName: *mut UNICODE_STRING, + AccountType: c_ulong, + DesiredAccess: c_ulong, UserHandle: PSAM_HANDLE, - GrantedAccess: PULONG, - RelativeId: PULONG, + GrantedAccess: *mut c_ulong, + RelativeId: *mut c_ulong, ) -> NTSTATUS; fn SamOpenUser( DomainHandle: SAM_HANDLE, - DesiredAccess: ACCESS_MASK, - UserId: ULONG, + DesiredAccess: c_ulong, + UserId: c_ulong, UserHandle: PSAM_HANDLE, ) -> NTSTATUS; fn SamDeleteUser( @@ -834,56 +928,56 @@ EXTERN!{extern "system" { fn SamQueryInformationUser( UserHandle: SAM_HANDLE, UserInformationClass: USER_INFORMATION_CLASS, - Buffer: *mut PVOID, + Buffer: *mut *mut c_void, ) -> NTSTATUS; fn SamSetInformationUser( UserHandle: SAM_HANDLE, UserInformationClass: USER_INFORMATION_CLASS, - Buffer: PVOID, + Buffer: *mut c_void, ) -> NTSTATUS; fn SamGetGroupsForUser( UserHandle: SAM_HANDLE, Groups: *mut PGROUP_MEMBERSHIP, - MembershipCount: PULONG, + MembershipCount: *mut c_ulong, ) -> NTSTATUS; fn SamChangePasswordUser( UserHandle: SAM_HANDLE, - OldPassword: PUNICODE_STRING, - NewPassword: PUNICODE_STRING, + OldPassword: *mut UNICODE_STRING, + NewPassword: *mut UNICODE_STRING, ) -> NTSTATUS; fn SamChangePasswordUser2( - ServerName: PUNICODE_STRING, - UserName: PUNICODE_STRING, - OldPassword: PUNICODE_STRING, - NewPassword: PUNICODE_STRING, + ServerName: *mut UNICODE_STRING, + UserName: *mut UNICODE_STRING, + OldPassword: *mut UNICODE_STRING, + NewPassword: *mut UNICODE_STRING, ) -> NTSTATUS; fn SamChangePasswordUser3( - ServerName: PUNICODE_STRING, - UserName: PUNICODE_STRING, - OldPassword: PUNICODE_STRING, - NewPassword: PUNICODE_STRING, - EffectivePasswordPolicy: *mut PDOMAIN_PASSWORD_INFORMATION, + ServerName: *mut UNICODE_STRING, + UserName: *mut UNICODE_STRING, + OldPassword: *mut UNICODE_STRING, + NewPassword: *mut UNICODE_STRING, + EffectivePasswordPolicy: *mut *mut DOMAIN_PASSWORD_INFORMATION, PasswordChangeFailureInfo: *mut PUSER_PWD_CHANGE_FAILURE_INFORMATION, ) -> NTSTATUS; fn SamQueryDisplayInformation( DomainHandle: SAM_HANDLE, DisplayInformation: DOMAIN_DISPLAY_INFORMATION, - Index: ULONG, - EntryCount: ULONG, - PreferredMaximumLength: ULONG, - TotalAvailable: PULONG, - TotalReturned: PULONG, - ReturnedEntryCount: PULONG, - SortedBuffer: *mut PVOID, + Index: c_ulong, + EntryCount: c_ulong, + PreferredMaximumLength: c_ulong, + TotalAvailable: *mut c_ulong, + TotalReturned: *mut c_ulong, + ReturnedEntryCount: *mut c_ulong, + SortedBuffer: *mut *mut c_void, ) -> NTSTATUS; fn SamGetDisplayEnumerationIndex( DomainHandle: SAM_HANDLE, DisplayInformation: DOMAIN_DISPLAY_INFORMATION, - Prefix: PUNICODE_STRING, - Index: PULONG, + Prefix: *mut UNICODE_STRING, + Index: *mut c_ulong, ) -> NTSTATUS; }} -ENUM!{enum SECURITY_DB_DELTA_TYPE { +ENUM! {enum SECURITY_DB_DELTA_TYPE { SecurityDbNew = 1, SecurityDbRename = 2, SecurityDbDelete = 3, @@ -894,7 +988,7 @@ ENUM!{enum SECURITY_DB_DELTA_TYPE { SecurityDbChangePassword = 8, }} pub type PSECURITY_DB_DELTA_TYPE = *mut SECURITY_DB_DELTA_TYPE; -ENUM!{enum SECURITY_DB_OBJECT_TYPE { +ENUM! {enum SECURITY_DB_OBJECT_TYPE { SecurityDbObjectSamDomain = 1, SecurityDbObjectSamUser = 2, SecurityDbObjectSamGroup = 3, @@ -905,7 +999,7 @@ ENUM!{enum SECURITY_DB_OBJECT_TYPE { SecurityDbObjectLsaSecret = 8, }} pub type PSECURITY_DB_OBJECT_TYPE = *mut SECURITY_DB_OBJECT_TYPE; -ENUM!{enum SAM_ACCOUNT_TYPE { +ENUM! {enum SAM_ACCOUNT_TYPE { SamObjectUser = 1, SamObjectGroup = 2, SamObjectAlias = 3, @@ -914,31 +1008,31 @@ pub type PSAM_ACCOUNT_TYPE = *mut SAM_ACCOUNT_TYPE; pub const SAM_USER_ACCOUNT: u32 = 0x00000001; pub const SAM_GLOBAL_GROUP_ACCOUNT: u32 = 0x00000002; pub const SAM_LOCAL_GROUP_ACCOUNT: u32 = 0x00000004; -STRUCT!{struct SAM_GROUP_MEMBER_ID { - MemberRid: ULONG, +STRUCT! {struct SAM_GROUP_MEMBER_ID { + MemberRid: c_ulong, }} pub type PSAM_GROUP_MEMBER_ID = *mut SAM_GROUP_MEMBER_ID; -STRUCT!{struct SAM_ALIAS_MEMBER_ID { +STRUCT! {struct SAM_ALIAS_MEMBER_ID { MemberSid: PSID, }} pub type PSAM_ALIAS_MEMBER_ID = *mut SAM_ALIAS_MEMBER_ID; -UNION!{union SAM_DELTA_DATA { +UNION! {union SAM_DELTA_DATA { GroupMemberId: SAM_GROUP_MEMBER_ID, AliasMemberId: SAM_ALIAS_MEMBER_ID, - AccountControl: ULONG, + AccountControl: c_ulong, }} pub type PSAM_DELTA_DATA = *mut SAM_DELTA_DATA; -FN!{stdcall PSAM_DELTA_NOTIFICATION_ROUTINE( +FN! {stdcall PSAM_DELTA_NOTIFICATION_ROUTINE( DomainSid: PSID, DeltaType: SECURITY_DB_DELTA_TYPE, ObjectType: SECURITY_DB_OBJECT_TYPE, - ObjectRid: ULONG, - ObjectName: PUNICODE_STRING, - ModifiedCount: PLARGE_INTEGER, + ObjectRid: c_ulong, + ObjectName: *mut UNICODE_STRING, + ModifiedCount: *mut LARGE_INTEGER, DeltaData: PSAM_DELTA_DATA, ) -> NTSTATUS} pub const SAM_DELTA_NOTIFY_ROUTINE: UTF8Const = UTF8Const("DeltaNotify\0"); -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn SamRegisterObjectChangeNotification( ObjectType: SECURITY_DB_OBJECT_TYPE, NotificationEventHandle: HANDLE, @@ -951,20 +1045,20 @@ EXTERN!{extern "system" { pub const SAM_SID_COMPATIBILITY_ALL: u32 = 0; pub const SAM_SID_COMPATIBILITY_LAX: u32 = 1; pub const SAM_SID_COMPATIBILITY_STRICT: u32 = 2; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn SamGetCompatibilityMode( ObjectHandle: SAM_HANDLE, - Mode: *mut ULONG, + Mode: *mut c_ulong, ) -> NTSTATUS; }} -ENUM!{enum PASSWORD_POLICY_VALIDATION_TYPE { +ENUM! {enum PASSWORD_POLICY_VALIDATION_TYPE { SamValidateAuthentication = 1, SamValidatePasswordChange = 2, SamValidatePasswordReset = 3, }} -STRUCT!{struct SAM_VALIDATE_PASSWORD_HASH { - Length: ULONG, - Hash: PUCHAR, +STRUCT! {struct SAM_VALIDATE_PASSWORD_HASH { + Length: c_ulong, + Hash: *mut c_uchar, }} pub type PSAM_VALIDATE_PASSWORD_HASH = *mut SAM_VALIDATE_PASSWORD_HASH; pub const SAM_VALIDATE_PASSWORD_LAST_SET: u32 = 0x00000001; @@ -973,17 +1067,17 @@ pub const SAM_VALIDATE_LOCKOUT_TIME: u32 = 0x00000004; pub const SAM_VALIDATE_BAD_PASSWORD_COUNT: u32 = 0x00000008; pub const SAM_VALIDATE_PASSWORD_HISTORY_LENGTH: u32 = 0x00000010; pub const SAM_VALIDATE_PASSWORD_HISTORY: u32 = 0x00000020; -STRUCT!{struct SAM_VALIDATE_PERSISTED_FIELDS { - PresentFields: ULONG, +STRUCT! {struct SAM_VALIDATE_PERSISTED_FIELDS { + PresentFields: c_ulong, PasswordLastSet: LARGE_INTEGER, BadPasswordTime: LARGE_INTEGER, LockoutTime: LARGE_INTEGER, - BadPasswordCount: ULONG, - PasswordHistoryLength: ULONG, + BadPasswordCount: c_ulong, + PasswordHistoryLength: c_ulong, PasswordHistory: PSAM_VALIDATE_PASSWORD_HASH, }} pub type PSAM_VALIDATE_PERSISTED_FIELDS = *mut SAM_VALIDATE_PERSISTED_FIELDS; -ENUM!{enum SAM_VALIDATE_VALIDATION_STATUS { +ENUM! {enum SAM_VALIDATE_VALIDATION_STATUS { SamValidateSuccess = 0, SamValidatePasswordMustChange = 1, SamValidateAccountLockedOut = 2, @@ -997,79 +1091,83 @@ ENUM!{enum SAM_VALIDATE_VALIDATION_STATUS { SamValidatePasswordFilterError = 10, }} pub type PSAM_VALIDATE_VALIDATION_STATUS = *mut SAM_VALIDATE_VALIDATION_STATUS; -STRUCT!{struct SAM_VALIDATE_STANDARD_OUTPUT_ARG { +STRUCT! {struct SAM_VALIDATE_STANDARD_OUTPUT_ARG { ChangedPersistedFields: SAM_VALIDATE_PERSISTED_FIELDS, ValidationStatus: SAM_VALIDATE_VALIDATION_STATUS, }} -pub type PSAM_VALIDATE_STANDARD_OUTPUT_ARG = *mut SAM_VALIDATE_STANDARD_OUTPUT_ARG; -STRUCT!{struct SAM_VALIDATE_AUTHENTICATION_INPUT_ARG { +pub type PSAM_VALIDATE_STANDARD_OUTPUT_ARG = + *mut SAM_VALIDATE_STANDARD_OUTPUT_ARG; +STRUCT! {struct SAM_VALIDATE_AUTHENTICATION_INPUT_ARG { InputPersistedFields: SAM_VALIDATE_PERSISTED_FIELDS, - PasswordMatched: BOOLEAN, + PasswordMatched: c_uchar, }} -pub type PSAM_VALIDATE_AUTHENTICATION_INPUT_ARG = *mut SAM_VALIDATE_AUTHENTICATION_INPUT_ARG; -STRUCT!{struct SAM_VALIDATE_PASSWORD_CHANGE_INPUT_ARG { +pub type PSAM_VALIDATE_AUTHENTICATION_INPUT_ARG = + *mut SAM_VALIDATE_AUTHENTICATION_INPUT_ARG; +STRUCT! {struct SAM_VALIDATE_PASSWORD_CHANGE_INPUT_ARG { InputPersistedFields: SAM_VALIDATE_PERSISTED_FIELDS, ClearPassword: UNICODE_STRING, UserAccountName: UNICODE_STRING, HashedPassword: SAM_VALIDATE_PASSWORD_HASH, - PasswordMatch: BOOLEAN, + PasswordMatch: c_uchar, }} -pub type PSAM_VALIDATE_PASSWORD_CHANGE_INPUT_ARG = *mut SAM_VALIDATE_PASSWORD_CHANGE_INPUT_ARG; -STRUCT!{struct SAM_VALIDATE_PASSWORD_RESET_INPUT_ARG { +pub type PSAM_VALIDATE_PASSWORD_CHANGE_INPUT_ARG = + *mut SAM_VALIDATE_PASSWORD_CHANGE_INPUT_ARG; +STRUCT! {struct SAM_VALIDATE_PASSWORD_RESET_INPUT_ARG { InputPersistedFields: SAM_VALIDATE_PERSISTED_FIELDS, ClearPassword: UNICODE_STRING, UserAccountName: UNICODE_STRING, HashedPassword: SAM_VALIDATE_PASSWORD_HASH, - PasswordMustChangeAtNextLogon: BOOLEAN, - ClearLockout: BOOLEAN, + PasswordMustChangeAtNextLogon: c_uchar, + ClearLockout: c_uchar, }} -pub type PSAM_VALIDATE_PASSWORD_RESET_INPUT_ARG = *mut SAM_VALIDATE_PASSWORD_RESET_INPUT_ARG; -UNION!{union SAM_VALIDATE_INPUT_ARG { +pub type PSAM_VALIDATE_PASSWORD_RESET_INPUT_ARG = + *mut SAM_VALIDATE_PASSWORD_RESET_INPUT_ARG; +UNION! {union SAM_VALIDATE_INPUT_ARG { ValidateAuthenticationInput: SAM_VALIDATE_AUTHENTICATION_INPUT_ARG, ValidatePasswordChangeInput: SAM_VALIDATE_PASSWORD_CHANGE_INPUT_ARG, ValidatePasswordResetInput: SAM_VALIDATE_PASSWORD_RESET_INPUT_ARG, }} pub type PSAM_VALIDATE_INPUT_ARG = *mut SAM_VALIDATE_INPUT_ARG; -UNION!{union SAM_VALIDATE_OUTPUT_ARG { +UNION! {union SAM_VALIDATE_OUTPUT_ARG { ValidateAuthenticationOutput: SAM_VALIDATE_STANDARD_OUTPUT_ARG, ValidatePasswordChangeOutput: SAM_VALIDATE_STANDARD_OUTPUT_ARG, ValidatePasswordResetOutput: SAM_VALIDATE_STANDARD_OUTPUT_ARG, }} pub type PSAM_VALIDATE_OUTPUT_ARG = *mut SAM_VALIDATE_OUTPUT_ARG; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn SamValidatePassword( - ServerName: PUNICODE_STRING, + ServerName: *mut UNICODE_STRING, ValidationType: PASSWORD_POLICY_VALIDATION_TYPE, InputArg: PSAM_VALIDATE_INPUT_ARG, OutputArg: *mut PSAM_VALIDATE_OUTPUT_ARG, ) -> NTSTATUS; }} -ENUM!{enum SAM_GENERIC_OPERATION_TYPE { +ENUM! {enum SAM_GENERIC_OPERATION_TYPE { SamObjectChangeNotificationOperation = 0, }} pub type PSAM_GENERIC_OPERATION_TYPE = *mut SAM_GENERIC_OPERATION_TYPE; -STRUCT!{struct SAM_OPERATION_OBJCHG_INPUT { - Register: BOOLEAN, - EventHandle: ULONG64, +STRUCT! {struct SAM_OPERATION_OBJCHG_INPUT { + Register: c_uchar, + EventHandle: __uint64, ObjectType: SECURITY_DB_OBJECT_TYPE, - ProcessID: ULONG, + ProcessID: c_ulong, }} pub type PSAM_OPERATION_OBJCHG_INPUT = *mut SAM_OPERATION_OBJCHG_INPUT; -STRUCT!{struct SAM_OPERATION_OBJCHG_OUTPUT { - Reserved: ULONG, +STRUCT! {struct SAM_OPERATION_OBJCHG_OUTPUT { + Reserved: c_ulong, }} pub type PSAM_OPERATION_OBJCHG_OUTPUT = *mut SAM_OPERATION_OBJCHG_OUTPUT; -UNION!{union SAM_GENERIC_OPERATION_INPUT { +UNION! {union SAM_GENERIC_OPERATION_INPUT { ObjChangeIn: SAM_OPERATION_OBJCHG_INPUT, }} pub type PSAM_GENERIC_OPERATION_INPUT = *mut SAM_GENERIC_OPERATION_INPUT; -UNION!{union SAM_GENERIC_OPERATION_OUTPUT { +UNION! {union SAM_GENERIC_OPERATION_OUTPUT { ObjChangeOut: SAM_OPERATION_OBJCHG_OUTPUT, }} pub type PSAM_GENERIC_OPERATION_OUTPUT = *mut SAM_GENERIC_OPERATION_OUTPUT; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn SamPerformGenericOperation( - ServerName: PWSTR, + ServerName: *mut wchar_t, OperationType: SAM_GENERIC_OPERATION_TYPE, OperationIn: PSAM_GENERIC_OPERATION_INPUT, OperationOut: *mut PSAM_GENERIC_OPERATION_OUTPUT, diff --git a/src/ntseapi.rs b/src/ntseapi.rs index 4cac9f4..d614b21 100644 --- a/src/ntseapi.rs +++ b/src/ntseapi.rs @@ -1,439 +1,450 @@ -use winapi::shared::basetsd::{PLONG64, PULONG64, ULONG64}; -use winapi::shared::ntdef::{ - BOOLEAN, HANDLE, LONG, NTSTATUS, PBOOLEAN, PHANDLE, PLARGE_INTEGER, PLUID, PNTSTATUS, - POBJECT_ATTRIBUTES, PUCHAR, PULONG, PUNICODE_STRING, PVOID, ULONG, UNICODE_STRING, USHORT, +use windows_sys::Win32::{ + Foundation::{HANDLE, LUID, NTSTATUS, PSID, UNICODE_STRING}, + Security::{ + AUDIT_EVENT_TYPE, GENERIC_MAPPING, OBJECT_TYPE_LIST, PRIVILEGE_SET, + PSECURITY_DESCRIPTOR, SID_AND_ATTRIBUTES, TOKEN_DEFAULT_DACL, + TOKEN_GROUPS, TOKEN_INFORMATION_CLASS, TOKEN_MANDATORY_POLICY, + TOKEN_OWNER, TOKEN_PRIMARY_GROUP, TOKEN_PRIVILEGES, TOKEN_SOURCE, + TOKEN_TYPE, TOKEN_USER, + }, + System::WindowsProgramming::OBJECT_ATTRIBUTES, }; -use winapi::um::winnt::{ - ACCESS_MASK, AUDIT_EVENT_TYPE, PACCESS_MASK, PGENERIC_MAPPING, POBJECT_TYPE_LIST, - PPRIVILEGE_SET, PSECURITY_DESCRIPTOR, PSE_SIGNING_LEVEL, PSID, PSID_AND_ATTRIBUTES, - PTOKEN_DEFAULT_DACL, PTOKEN_GROUPS, PTOKEN_MANDATORY_POLICY, PTOKEN_OWNER, - PTOKEN_PRIMARY_GROUP, PTOKEN_PRIVILEGES, PTOKEN_SOURCE, PTOKEN_USER, SE_SIGNING_LEVEL, - TOKEN_INFORMATION_CLASS, TOKEN_TYPE, + +use crate::{ + ctypes::{__int64, __uint64, c_long, c_uchar, c_ulong, c_ushort, c_void}, + windows_local::shared::ntdef::LARGE_INTEGER, }; -pub const SE_MIN_WELL_KNOWN_PRIVILEGE: LONG = 2; -pub const SE_CREATE_TOKEN_PRIVILEGE: LONG = 2; -pub const SE_ASSIGNPRIMARYTOKEN_PRIVILEGE: LONG = 3; -pub const SE_LOCK_MEMORY_PRIVILEGE: LONG = 4; -pub const SE_INCREASE_QUOTA_PRIVILEGE: LONG = 5; -pub const SE_MACHINE_ACCOUNT_PRIVILEGE: LONG = 6; -pub const SE_TCB_PRIVILEGE: LONG = 7; -pub const SE_SECURITY_PRIVILEGE: LONG = 8; -pub const SE_TAKE_OWNERSHIP_PRIVILEGE: LONG = 9; -pub const SE_LOAD_DRIVER_PRIVILEGE: LONG = 10; -pub const SE_SYSTEM_PROFILE_PRIVILEGE: LONG = 11; -pub const SE_SYSTEMTIME_PRIVILEGE: LONG = 12; -pub const SE_PROF_SINGLE_PROCESS_PRIVILEGE: LONG = 13; -pub const SE_INC_BASE_PRIORITY_PRIVILEGE: LONG = 14; -pub const SE_CREATE_PAGEFILE_PRIVILEGE: LONG = 15; -pub const SE_CREATE_PERMANENT_PRIVILEGE: LONG = 16; -pub const SE_BACKUP_PRIVILEGE: LONG = 17; -pub const SE_RESTORE_PRIVILEGE: LONG = 18; -pub const SE_SHUTDOWN_PRIVILEGE: LONG = 19; -pub const SE_DEBUG_PRIVILEGE: LONG = 20; -pub const SE_AUDIT_PRIVILEGE: LONG = 21; -pub const SE_SYSTEM_ENVIRONMENT_PRIVILEGE: LONG = 22; -pub const SE_CHANGE_NOTIFY_PRIVILEGE: LONG = 23; -pub const SE_REMOTE_SHUTDOWN_PRIVILEGE: LONG = 24; -pub const SE_UNDOCK_PRIVILEGE: LONG = 25; -pub const SE_SYNC_AGENT_PRIVILEGE: LONG = 26; -pub const SE_ENABLE_DELEGATION_PRIVILEGE: LONG = 27; -pub const SE_MANAGE_VOLUME_PRIVILEGE: LONG = 28; -pub const SE_IMPERSONATE_PRIVILEGE: LONG = 29; -pub const SE_CREATE_GLOBAL_PRIVILEGE: LONG = 30; -pub const SE_TRUSTED_CREDMAN_ACCESS_PRIVILEGE: LONG = 31; -pub const SE_RELABEL_PRIVILEGE: LONG = 32; -pub const SE_INC_WORKING_SET_PRIVILEGE: LONG = 33; -pub const SE_TIME_ZONE_PRIVILEGE: LONG = 34; -pub const SE_CREATE_SYMBOLIC_LINK_PRIVILEGE: LONG = 35; -pub const SE_DELEGATE_SESSION_USER_IMPERSONATE_PRIVILEGE: LONG = 36; -pub const SE_MAX_WELL_KNOWN_PRIVILEGE: LONG = SE_DELEGATE_SESSION_USER_IMPERSONATE_PRIVILEGE; -pub const TOKEN_SECURITY_ATTRIBUTE_TYPE_INVALID: USHORT = 0x00; -pub const TOKEN_SECURITY_ATTRIBUTE_TYPE_INT64: USHORT = 0x01; -pub const TOKEN_SECURITY_ATTRIBUTE_TYPE_UINT64: USHORT = 0x02; -pub const TOKEN_SECURITY_ATTRIBUTE_TYPE_STRING: USHORT = 0x03; -pub const TOKEN_SECURITY_ATTRIBUTE_TYPE_FQBN: USHORT = 0x04; -pub const TOKEN_SECURITY_ATTRIBUTE_TYPE_SID: USHORT = 0x05; -pub const TOKEN_SECURITY_ATTRIBUTE_TYPE_BOOLEAN: USHORT = 0x06; -pub const TOKEN_SECURITY_ATTRIBUTE_TYPE_OCTET_STRING: USHORT = 0x10; -pub const TOKEN_SECURITY_ATTRIBUTE_NON_INHERITABLE: USHORT = 0x0001; -pub const TOKEN_SECURITY_ATTRIBUTE_VALUE_CASE_SENSITIVE: USHORT = 0x0002; -pub const TOKEN_SECURITY_ATTRIBUTE_USE_FOR_DENY_ONLY: USHORT = 0x0004; -pub const TOKEN_SECURITY_ATTRIBUTE_DISABLED_BY_DEFAULT: USHORT = 0x0008; -pub const TOKEN_SECURITY_ATTRIBUTE_DISABLED: USHORT = 0x0010; -pub const TOKEN_SECURITY_ATTRIBUTE_MANDATORY: USHORT = 0x0020; -pub const TOKEN_SECURITY_ATTRIBUTE_COMPARE_IGNORE: USHORT = 0x0040; -pub const TOKEN_SECURITY_ATTRIBUTE_VALID_FLAGS: USHORT = TOKEN_SECURITY_ATTRIBUTE_NON_INHERITABLE - | TOKEN_SECURITY_ATTRIBUTE_VALUE_CASE_SENSITIVE | TOKEN_SECURITY_ATTRIBUTE_USE_FOR_DENY_ONLY - | TOKEN_SECURITY_ATTRIBUTE_DISABLED_BY_DEFAULT | TOKEN_SECURITY_ATTRIBUTE_DISABLED - | TOKEN_SECURITY_ATTRIBUTE_MANDATORY; + +pub const SE_MIN_WELL_KNOWN_PRIVILEGE: c_long = 2; +pub const SE_CREATE_TOKEN_PRIVILEGE: c_long = 2; +pub const SE_ASSIGNPRIMARYTOKEN_PRIVILEGE: c_long = 3; +pub const SE_LOCK_MEMORY_PRIVILEGE: c_long = 4; +pub const SE_INCREASE_QUOTA_PRIVILEGE: c_long = 5; +pub const SE_MACHINE_ACCOUNT_PRIVILEGE: c_long = 6; +pub const SE_TCB_PRIVILEGE: c_long = 7; +pub const SE_SECURITY_PRIVILEGE: c_long = 8; +pub const SE_TAKE_OWNERSHIP_PRIVILEGE: c_long = 9; +pub const SE_LOAD_DRIVER_PRIVILEGE: c_long = 10; +pub const SE_SYSTEM_PROFILE_PRIVILEGE: c_long = 11; +pub const SE_SYSTEMTIME_PRIVILEGE: c_long = 12; +pub const SE_PROF_SINGLE_PROCESS_PRIVILEGE: c_long = 13; +pub const SE_INC_BASE_PRIORITY_PRIVILEGE: c_long = 14; +pub const SE_CREATE_PAGEFILE_PRIVILEGE: c_long = 15; +pub const SE_CREATE_PERMANENT_PRIVILEGE: c_long = 16; +pub const SE_BACKUP_PRIVILEGE: c_long = 17; +pub const SE_RESTORE_PRIVILEGE: c_long = 18; +pub const SE_SHUTDOWN_PRIVILEGE: c_long = 19; +pub const SE_DEBUG_PRIVILEGE: c_long = 20; +pub const SE_AUDIT_PRIVILEGE: c_long = 21; +pub const SE_SYSTEM_ENVIRONMENT_PRIVILEGE: c_long = 22; +pub const SE_CHANGE_NOTIFY_PRIVILEGE: c_long = 23; +pub const SE_REMOTE_SHUTDOWN_PRIVILEGE: c_long = 24; +pub const SE_UNDOCK_PRIVILEGE: c_long = 25; +pub const SE_SYNC_AGENT_PRIVILEGE: c_long = 26; +pub const SE_ENABLE_DELEGATION_PRIVILEGE: c_long = 27; +pub const SE_MANAGE_VOLUME_PRIVILEGE: c_long = 28; +pub const SE_IMPERSONATE_PRIVILEGE: c_long = 29; +pub const SE_CREATE_GLOBAL_PRIVILEGE: c_long = 30; +pub const SE_TRUSTED_CREDMAN_ACCESS_PRIVILEGE: c_long = 31; +pub const SE_RELABEL_PRIVILEGE: c_long = 32; +pub const SE_INC_WORKING_SET_PRIVILEGE: c_long = 33; +pub const SE_TIME_ZONE_PRIVILEGE: c_long = 34; +pub const SE_CREATE_SYMBOLIC_LINK_PRIVILEGE: c_long = 35; +pub const SE_DELEGATE_SESSION_USER_IMPERSONATE_PRIVILEGE: c_long = 36; +pub const SE_MAX_WELL_KNOWN_PRIVILEGE: c_long = + SE_DELEGATE_SESSION_USER_IMPERSONATE_PRIVILEGE; +pub const TOKEN_SECURITY_ATTRIBUTE_TYPE_INVALID: c_ushort = 0x00; +pub const TOKEN_SECURITY_ATTRIBUTE_TYPE_INT64: c_ushort = 0x01; +pub const TOKEN_SECURITY_ATTRIBUTE_TYPE_UINT64: c_ushort = 0x02; +pub const TOKEN_SECURITY_ATTRIBUTE_TYPE_STRING: c_ushort = 0x03; +pub const TOKEN_SECURITY_ATTRIBUTE_TYPE_FQBN: c_ushort = 0x04; +pub const TOKEN_SECURITY_ATTRIBUTE_TYPE_SID: c_ushort = 0x05; +pub const TOKEN_SECURITY_ATTRIBUTE_TYPE_BOOLEAN: c_ushort = 0x06; +pub const TOKEN_SECURITY_ATTRIBUTE_TYPE_OCTET_STRING: c_ushort = 0x10; +pub const TOKEN_SECURITY_ATTRIBUTE_NON_INHERITABLE: c_ushort = 0x0001; +pub const TOKEN_SECURITY_ATTRIBUTE_VALUE_CASE_SENSITIVE: c_ushort = 0x0002; +pub const TOKEN_SECURITY_ATTRIBUTE_USE_FOR_DENY_ONLY: c_ushort = 0x0004; +pub const TOKEN_SECURITY_ATTRIBUTE_DISABLED_BY_DEFAULT: c_ushort = 0x0008; +pub const TOKEN_SECURITY_ATTRIBUTE_DISABLED: c_ushort = 0x0010; +pub const TOKEN_SECURITY_ATTRIBUTE_MANDATORY: c_ushort = 0x0020; +pub const TOKEN_SECURITY_ATTRIBUTE_COMPARE_IGNORE: c_ushort = 0x0040; +pub const TOKEN_SECURITY_ATTRIBUTE_VALID_FLAGS: c_ushort = + TOKEN_SECURITY_ATTRIBUTE_NON_INHERITABLE + | TOKEN_SECURITY_ATTRIBUTE_VALUE_CASE_SENSITIVE + | TOKEN_SECURITY_ATTRIBUTE_USE_FOR_DENY_ONLY + | TOKEN_SECURITY_ATTRIBUTE_DISABLED_BY_DEFAULT + | TOKEN_SECURITY_ATTRIBUTE_DISABLED + | TOKEN_SECURITY_ATTRIBUTE_MANDATORY; pub const TOKEN_SECURITY_ATTRIBUTE_CUSTOM_FLAGS: u32 = 0xffff0000; -STRUCT!{struct TOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE { - Version: ULONG64, +STRUCT! {struct TOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE { + Version: __uint64, Name: UNICODE_STRING, }} -pub type PTOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE = *mut TOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE; -STRUCT!{struct TOKEN_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE { - pValue: PVOID, - ValueLength: ULONG, +pub type PTOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE = + *mut TOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE; +STRUCT! {struct TOKEN_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE { + pValue: *mut c_void, + ValueLength: c_ulong, }} pub type PTOKEN_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE = *mut TOKEN_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE; -UNION!{union TOKEN_SECURITY_ATTRIBUTE_V1_Values { - pInt64: PLONG64, - pUint64: PULONG64, - pString: PUNICODE_STRING, +UNION! {union TOKEN_SECURITY_ATTRIBUTE_V1_Values { + pInt64: *mut __int64, + pUint64: *mut __uint64, + pString: *mut UNICODE_STRING, pFqbn: PTOKEN_SECURITY_ATTRIBUTE_FQBN_VALUE, pOctetString: PTOKEN_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE, }} -STRUCT!{struct TOKEN_SECURITY_ATTRIBUTE_V1 { +STRUCT! {struct TOKEN_SECURITY_ATTRIBUTE_V1 { Name: UNICODE_STRING, - ValueType: USHORT, - Reserved: USHORT, - Flags: ULONG, - ValueCount: ULONG, + ValueType: c_ushort, + Reserved: c_ushort, + Flags: c_ulong, + ValueCount: c_ulong, Values: TOKEN_SECURITY_ATTRIBUTE_V1_Values, }} pub type PTOKEN_SECURITY_ATTRIBUTE_V1 = *mut TOKEN_SECURITY_ATTRIBUTE_V1; -pub const TOKEN_SECURITY_ATTRIBUTES_INFORMATION_VERSION_V1: USHORT = 1; -pub const TOKEN_SECURITY_ATTRIBUTES_INFORMATION_VERSION: USHORT = +pub const TOKEN_SECURITY_ATTRIBUTES_INFORMATION_VERSION_V1: c_ushort = 1; +pub const TOKEN_SECURITY_ATTRIBUTES_INFORMATION_VERSION: c_ushort = TOKEN_SECURITY_ATTRIBUTES_INFORMATION_VERSION_V1; -STRUCT!{struct TOKEN_SECURITY_ATTRIBUTES_INFORMATION { - Version: USHORT, - Reserved: USHORT, - AttributeCount: ULONG, +STRUCT! {struct TOKEN_SECURITY_ATTRIBUTES_INFORMATION { + Version: c_ushort, + Reserved: c_ushort, + AttributeCount: c_ulong, pAttributeV1: PTOKEN_SECURITY_ATTRIBUTE_V1, }} -pub type PTOKEN_SECURITY_ATTRIBUTES_INFORMATION = *mut TOKEN_SECURITY_ATTRIBUTES_INFORMATION; -STRUCT!{struct TOKEN_PROCESS_TRUST_LEVEL { +pub type PTOKEN_SECURITY_ATTRIBUTES_INFORMATION = + *mut TOKEN_SECURITY_ATTRIBUTES_INFORMATION; +STRUCT! {struct TOKEN_PROCESS_TRUST_LEVEL { TrustLevelSid: PSID, }} pub type PTOKEN_PROCESS_TRUST_LEVEL = *mut TOKEN_PROCESS_TRUST_LEVEL; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn NtCreateToken( - TokenHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + TokenHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, TokenType: TOKEN_TYPE, - AuthenticationId: PLUID, - ExpirationTime: PLARGE_INTEGER, - User: PTOKEN_USER, - Groups: PTOKEN_GROUPS, - Privileges: PTOKEN_PRIVILEGES, - Owner: PTOKEN_OWNER, - PrimaryGroup: PTOKEN_PRIMARY_GROUP, - DefaultDacl: PTOKEN_DEFAULT_DACL, - TokenSource: PTOKEN_SOURCE, + AuthenticationId: *mut LUID, + ExpirationTime: *mut LARGE_INTEGER, + User: *mut TOKEN_USER, + Groups: *mut TOKEN_GROUPS, + Privileges: *mut TOKEN_PRIVILEGES, + Owner: *mut TOKEN_OWNER, + PrimaryGroup: *mut TOKEN_PRIMARY_GROUP, + DefaultDacl: *mut TOKEN_DEFAULT_DACL, + TokenSource: *mut TOKEN_SOURCE, ) -> NTSTATUS; fn NtCreateLowBoxToken( - TokenHandle: PHANDLE, + TokenHandle: *mut HANDLE, ExistingTokenHandle: HANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, PackageSid: PSID, - CapabilityCount: ULONG, - Capabilities: PSID_AND_ATTRIBUTES, - HandleCount: ULONG, + CapabilityCount: c_ulong, + Capabilities: *mut SID_AND_ATTRIBUTES, + HandleCount: c_ulong, Handles: *mut HANDLE, ) -> NTSTATUS; fn NtCreateTokenEx( - TokenHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + TokenHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, TokenType: TOKEN_TYPE, - AuthenticationId: PLUID, - ExpirationTime: PLARGE_INTEGER, - User: PTOKEN_USER, - Groups: PTOKEN_GROUPS, - Privileges: PTOKEN_PRIVILEGES, + AuthenticationId: *mut LUID, + ExpirationTime: *mut LARGE_INTEGER, + User: *mut TOKEN_USER, + Groups: *mut TOKEN_GROUPS, + Privileges: *mut TOKEN_PRIVILEGES, UserAttributes: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, DeviceAttributes: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, - DeviceGroups: PTOKEN_GROUPS, - TokenMandatoryPolicy: PTOKEN_MANDATORY_POLICY, - Owner: PTOKEN_OWNER, - PrimaryGroup: PTOKEN_PRIMARY_GROUP, - DefaultDacl: PTOKEN_DEFAULT_DACL, - TokenSource: PTOKEN_SOURCE, + DeviceGroups: *mut TOKEN_GROUPS, + TokenMandatoryPolicy: *mut TOKEN_MANDATORY_POLICY, + Owner: *mut TOKEN_OWNER, + PrimaryGroup: *mut TOKEN_PRIMARY_GROUP, + DefaultDacl: *mut TOKEN_DEFAULT_DACL, + TokenSource: *mut TOKEN_SOURCE, ) -> NTSTATUS; fn NtOpenProcessToken( ProcessHandle: HANDLE, - DesiredAccess: ACCESS_MASK, - TokenHandle: PHANDLE, + DesiredAccess: c_ulong, + TokenHandle: *mut HANDLE, ) -> NTSTATUS; fn NtOpenProcessTokenEx( ProcessHandle: HANDLE, - DesiredAccess: ACCESS_MASK, - HandleAttributes: ULONG, - TokenHandle: PHANDLE, + DesiredAccess: c_ulong, + HandleAttributes: c_ulong, + TokenHandle: *mut HANDLE, ) -> NTSTATUS; fn NtOpenThreadToken( ThreadHandle: HANDLE, - DesiredAccess: ACCESS_MASK, - OpenAsSelf: BOOLEAN, - TokenHandle: PHANDLE, + DesiredAccess: c_ulong, + OpenAsSelf: c_uchar, + TokenHandle: *mut HANDLE, ) -> NTSTATUS; fn NtOpenThreadTokenEx( ThreadHandle: HANDLE, - DesiredAccess: ACCESS_MASK, - OpenAsSelf: BOOLEAN, - HandleAttributes: ULONG, - TokenHandle: PHANDLE, + DesiredAccess: c_ulong, + OpenAsSelf: c_uchar, + HandleAttributes: c_ulong, + TokenHandle: *mut HANDLE, ) -> NTSTATUS; fn NtDuplicateToken( ExistingTokenHandle: HANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - EffectiveOnly: BOOLEAN, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + EffectiveOnly: c_uchar, TokenType: TOKEN_TYPE, - NewTokenHandle: PHANDLE, + NewTokenHandle: *mut HANDLE, ) -> NTSTATUS; fn NtQueryInformationToken( TokenHandle: HANDLE, TokenInformationClass: TOKEN_INFORMATION_CLASS, - TokenInformation: PVOID, - TokenInformationLength: ULONG, - ReturnLength: PULONG, + TokenInformation: *mut c_void, + TokenInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn NtSetInformationToken( TokenHandle: HANDLE, TokenInformationClass: TOKEN_INFORMATION_CLASS, - TokenInformation: PVOID, - TokenInformationLength: ULONG, + TokenInformation: *mut c_void, + TokenInformationLength: c_ulong, ) -> NTSTATUS; fn NtAdjustPrivilegesToken( TokenHandle: HANDLE, - DisableAllPrivileges: BOOLEAN, - NewState: PTOKEN_PRIVILEGES, - BufferLength: ULONG, - PreviousState: PTOKEN_PRIVILEGES, - ReturnLength: PULONG, + DisableAllPrivileges: c_uchar, + NewState: *mut TOKEN_PRIVILEGES, + BufferLength: c_ulong, + PreviousState: *mut TOKEN_PRIVILEGES, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn NtAdjustGroupsToken( TokenHandle: HANDLE, - ResetToDefault: BOOLEAN, - NewState: PTOKEN_GROUPS, - BufferLength: ULONG, - PreviousState: PTOKEN_GROUPS, - ReturnLength: PULONG, + ResetToDefault: c_uchar, + NewState: *mut TOKEN_GROUPS, + BufferLength: c_ulong, + PreviousState: *mut TOKEN_GROUPS, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn NtAdjustTokenClaimsAndDeviceGroups( TokenHandle: HANDLE, - UserResetToDefault: BOOLEAN, - DeviceResetToDefault: BOOLEAN, - DeviceGroupsResetToDefault: BOOLEAN, + UserResetToDefault: c_uchar, + DeviceResetToDefault: c_uchar, + DeviceGroupsResetToDefault: c_uchar, NewUserState: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, NewDeviceState: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, - NewDeviceGroupsState: PTOKEN_GROUPS, - UserBufferLength: ULONG, + NewDeviceGroupsState: *mut TOKEN_GROUPS, + UserBufferLength: c_ulong, PreviousUserState: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, - DeviceBufferLength: ULONG, + DeviceBufferLength: c_ulong, PreviousDeviceState: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, - DeviceGroupsBufferLength: ULONG, - PreviousDeviceGroups: PTOKEN_GROUPS, - UserReturnLength: PULONG, - DeviceReturnLength: PULONG, - DeviceGroupsReturnBufferLength: PULONG, + DeviceGroupsBufferLength: c_ulong, + PreviousDeviceGroups: *mut TOKEN_GROUPS, + UserReturnLength: *mut c_ulong, + DeviceReturnLength: *mut c_ulong, + DeviceGroupsReturnBufferLength: *mut c_ulong, ) -> NTSTATUS; fn NtFilterToken( ExistingTokenHandle: HANDLE, - Flags: ULONG, - SidsToDisable: PTOKEN_GROUPS, - PrivilegesToDelete: PTOKEN_PRIVILEGES, - RestrictedSids: PTOKEN_GROUPS, - NewTokenHandle: PHANDLE, + Flags: c_ulong, + SidsToDisable: *mut TOKEN_GROUPS, + PrivilegesToDelete: *mut TOKEN_PRIVILEGES, + RestrictedSids: *mut TOKEN_GROUPS, + NewTokenHandle: *mut HANDLE, ) -> NTSTATUS; fn NtFilterTokenEx( ExistingTokenHandle: HANDLE, - Flags: ULONG, - SidsToDisable: PTOKEN_GROUPS, - PrivilegesToDelete: PTOKEN_PRIVILEGES, - RestrictedSids: PTOKEN_GROUPS, - DisableUserClaimsCount: ULONG, - UserClaimsToDisable: PUNICODE_STRING, - DisableDeviceClaimsCount: ULONG, - DeviceClaimsToDisable: PUNICODE_STRING, - DeviceGroupsToDisable: PTOKEN_GROUPS, + Flags: c_ulong, + SidsToDisable: *mut TOKEN_GROUPS, + PrivilegesToDelete: *mut TOKEN_PRIVILEGES, + RestrictedSids: *mut TOKEN_GROUPS, + DisableUserClaimsCount: c_ulong, + UserClaimsToDisable: *mut UNICODE_STRING, + DisableDeviceClaimsCount: c_ulong, + DeviceClaimsToDisable: *mut UNICODE_STRING, + DeviceGroupsToDisable: *mut TOKEN_GROUPS, RestrictedUserAttributes: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, RestrictedDeviceAttributes: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, - RestrictedDeviceGroups: PTOKEN_GROUPS, - NewTokenHandle: PHANDLE, + RestrictedDeviceGroups: *mut TOKEN_GROUPS, + NewTokenHandle: *mut HANDLE, ) -> NTSTATUS; fn NtCompareTokens( FirstTokenHandle: HANDLE, SecondTokenHandle: HANDLE, - Equal: PBOOLEAN, + Equal: *mut c_uchar, ) -> NTSTATUS; fn NtPrivilegeCheck( ClientToken: HANDLE, - RequiredPrivileges: PPRIVILEGE_SET, - Result: PBOOLEAN, + RequiredPrivileges: *mut PRIVILEGE_SET, + Result: *mut c_uchar, ) -> NTSTATUS; fn NtImpersonateAnonymousToken( ThreadHandle: HANDLE, ) -> NTSTATUS; fn NtQuerySecurityAttributesToken( TokenHandle: HANDLE, - Attributes: PUNICODE_STRING, - NumberOfAttributes: ULONG, - Buffer: PVOID, - Length: ULONG, - ReturnLength: PULONG, + Attributes: *mut UNICODE_STRING, + NumberOfAttributes: c_ulong, + Buffer: *mut c_void, + Length: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn NtAccessCheck( SecurityDescriptor: PSECURITY_DESCRIPTOR, ClientToken: HANDLE, - DesiredAccess: ACCESS_MASK, - GenericMapping: PGENERIC_MAPPING, - PrivilegeSet: PPRIVILEGE_SET, - PrivilegeSetLength: PULONG, - GrantedAccess: PACCESS_MASK, - AccessStatus: PNTSTATUS, + DesiredAccess: c_ulong, + GenericMapping: *mut GENERIC_MAPPING, + PrivilegeSet: *mut PRIVILEGE_SET, + PrivilegeSetLength: *mut c_ulong, + GrantedAccess: *mut c_ulong, + AccessStatus: *mut NTSTATUS, ) -> NTSTATUS; fn NtAccessCheckByType( SecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, ClientToken: HANDLE, - DesiredAccess: ACCESS_MASK, - ObjectTypeList: POBJECT_TYPE_LIST, - ObjectTypeListLength: ULONG, - GenericMapping: PGENERIC_MAPPING, - PrivilegeSet: PPRIVILEGE_SET, - PrivilegeSetLength: PULONG, - GrantedAccess: PACCESS_MASK, - AccessStatus: PNTSTATUS, + DesiredAccess: c_ulong, + ObjectTypeList: *mut OBJECT_TYPE_LIST, + ObjectTypeListLength: c_ulong, + GenericMapping: *mut GENERIC_MAPPING, + PrivilegeSet: *mut PRIVILEGE_SET, + PrivilegeSetLength: *mut c_ulong, + GrantedAccess: *mut c_ulong, + AccessStatus: *mut NTSTATUS, ) -> NTSTATUS; fn NtAccessCheckByTypeResultList( SecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, ClientToken: HANDLE, - DesiredAccess: ACCESS_MASK, - ObjectTypeList: POBJECT_TYPE_LIST, - ObjectTypeListLength: ULONG, - GenericMapping: PGENERIC_MAPPING, - PrivilegeSet: PPRIVILEGE_SET, - PrivilegeSetLength: PULONG, - GrantedAccess: PACCESS_MASK, - AccessStatus: PNTSTATUS, + DesiredAccess: c_ulong, + ObjectTypeList: *mut OBJECT_TYPE_LIST, + ObjectTypeListLength: c_ulong, + GenericMapping: *mut GENERIC_MAPPING, + PrivilegeSet: *mut PRIVILEGE_SET, + PrivilegeSetLength: *mut c_ulong, + GrantedAccess: *mut c_ulong, + AccessStatus: *mut NTSTATUS, ) -> NTSTATUS; fn NtSetCachedSigningLevel( - Flags: ULONG, - InputSigningLevel: SE_SIGNING_LEVEL, - SourceFiles: PHANDLE, - SourceFileCount: ULONG, + Flags: c_ulong, + InputSigningLevel: c_uchar, + SourceFiles: *mut HANDLE, + SourceFileCount: c_ulong, TargetFile: HANDLE, ) -> NTSTATUS; fn NtGetCachedSigningLevel( File: HANDLE, - Flags: PULONG, - SigningLevel: PSE_SIGNING_LEVEL, - Thumbprint: PUCHAR, - ThumbprintSize: PULONG, - ThumbprintAlgorithm: PULONG, + Flags: *mut c_ulong, + SigningLevel: *mut c_uchar, + Thumbprint: *mut c_uchar, + ThumbprintSize: *mut c_ulong, + ThumbprintAlgorithm: *mut c_ulong, ) -> NTSTATUS; fn NtAccessCheckAndAuditAlarm( - SubsystemName: PUNICODE_STRING, - HandleId: PVOID, - ObjectTypeName: PUNICODE_STRING, - ObjectName: PUNICODE_STRING, + SubsystemName: *mut UNICODE_STRING, + HandleId: *mut c_void, + ObjectTypeName: *mut UNICODE_STRING, + ObjectName: *mut UNICODE_STRING, SecurityDescriptor: PSECURITY_DESCRIPTOR, - DesiredAccess: ACCESS_MASK, - GenericMapping: PGENERIC_MAPPING, - ObjectCreation: BOOLEAN, - GrantedAccess: PACCESS_MASK, - AccessStatus: PNTSTATUS, - GenerateOnClose: PBOOLEAN, + DesiredAccess: c_ulong, + GenericMapping: *mut GENERIC_MAPPING, + ObjectCreation: c_uchar, + GrantedAccess: *mut c_ulong, + AccessStatus: *mut NTSTATUS, + GenerateOnClose: *mut c_uchar, ) -> NTSTATUS; fn NtAccessCheckByTypeAndAuditAlarm( - SubsystemName: PUNICODE_STRING, - HandleId: PVOID, - ObjectTypeName: PUNICODE_STRING, - ObjectName: PUNICODE_STRING, + SubsystemName: *mut UNICODE_STRING, + HandleId: *mut c_void, + ObjectTypeName: *mut UNICODE_STRING, + ObjectName: *mut UNICODE_STRING, SecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, - DesiredAccess: ACCESS_MASK, + DesiredAccess: c_ulong, AuditType: AUDIT_EVENT_TYPE, - Flags: ULONG, - ObjectTypeList: POBJECT_TYPE_LIST, - ObjectTypeListLength: ULONG, - GenericMapping: PGENERIC_MAPPING, - ObjectCreation: BOOLEAN, - GrantedAccess: PACCESS_MASK, - AccessStatus: PNTSTATUS, - GenerateOnClose: PBOOLEAN, + Flags: c_ulong, + ObjectTypeList: *mut OBJECT_TYPE_LIST, + ObjectTypeListLength: c_ulong, + GenericMapping: *mut GENERIC_MAPPING, + ObjectCreation: c_uchar, + GrantedAccess: *mut c_ulong, + AccessStatus: *mut NTSTATUS, + GenerateOnClose: *mut c_uchar, ) -> NTSTATUS; fn NtAccessCheckByTypeResultListAndAuditAlarm( - SubsystemName: PUNICODE_STRING, - HandleId: PVOID, - ObjectTypeName: PUNICODE_STRING, - ObjectName: PUNICODE_STRING, + SubsystemName: *mut UNICODE_STRING, + HandleId: *mut c_void, + ObjectTypeName: *mut UNICODE_STRING, + ObjectName: *mut UNICODE_STRING, SecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, - DesiredAccess: ACCESS_MASK, + DesiredAccess: c_ulong, AuditType: AUDIT_EVENT_TYPE, - Flags: ULONG, - ObjectTypeList: POBJECT_TYPE_LIST, - ObjectTypeListLength: ULONG, - GenericMapping: PGENERIC_MAPPING, - ObjectCreation: BOOLEAN, - GrantedAccess: PACCESS_MASK, - AccessStatus: PNTSTATUS, - GenerateOnClose: PBOOLEAN, + Flags: c_ulong, + ObjectTypeList: *mut OBJECT_TYPE_LIST, + ObjectTypeListLength: c_ulong, + GenericMapping: *mut GENERIC_MAPPING, + ObjectCreation: c_uchar, + GrantedAccess: *mut c_ulong, + AccessStatus: *mut NTSTATUS, + GenerateOnClose: *mut c_uchar, ) -> NTSTATUS; fn NtAccessCheckByTypeResultListAndAuditAlarmByHandle( - SubsystemName: PUNICODE_STRING, - HandleId: PVOID, + SubsystemName: *mut UNICODE_STRING, + HandleId: *mut c_void, ClientToken: HANDLE, - ObjectTypeName: PUNICODE_STRING, - ObjectName: PUNICODE_STRING, + ObjectTypeName: *mut UNICODE_STRING, + ObjectName: *mut UNICODE_STRING, SecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, - DesiredAccess: ACCESS_MASK, + DesiredAccess: c_ulong, AuditType: AUDIT_EVENT_TYPE, - Flags: ULONG, - ObjectTypeList: POBJECT_TYPE_LIST, - ObjectTypeListLength: ULONG, - GenericMapping: PGENERIC_MAPPING, - ObjectCreation: BOOLEAN, - GrantedAccess: PACCESS_MASK, - AccessStatus: PNTSTATUS, - GenerateOnClose: PBOOLEAN, + Flags: c_ulong, + ObjectTypeList: *mut OBJECT_TYPE_LIST, + ObjectTypeListLength: c_ulong, + GenericMapping: *mut GENERIC_MAPPING, + ObjectCreation: c_uchar, + GrantedAccess: *mut c_ulong, + AccessStatus: *mut NTSTATUS, + GenerateOnClose: *mut c_uchar, ) -> NTSTATUS; fn NtOpenObjectAuditAlarm( - SubsystemName: PUNICODE_STRING, - HandleId: PVOID, - ObjectTypeName: PUNICODE_STRING, - ObjectName: PUNICODE_STRING, + SubsystemName: *mut UNICODE_STRING, + HandleId: *mut c_void, + ObjectTypeName: *mut UNICODE_STRING, + ObjectName: *mut UNICODE_STRING, SecurityDescriptor: PSECURITY_DESCRIPTOR, ClientToken: HANDLE, - DesiredAccess: ACCESS_MASK, - GrantedAccess: ACCESS_MASK, - Privileges: PPRIVILEGE_SET, - ObjectCreation: BOOLEAN, - AccessGranted: BOOLEAN, - GenerateOnClose: PBOOLEAN, + DesiredAccess: c_ulong, + GrantedAccess: c_ulong, + Privileges: *mut PRIVILEGE_SET, + ObjectCreation: c_uchar, + AccessGranted: c_uchar, + GenerateOnClose: *mut c_uchar, ) -> NTSTATUS; fn NtPrivilegeObjectAuditAlarm( - SubsystemName: PUNICODE_STRING, - HandleId: PVOID, + SubsystemName: *mut UNICODE_STRING, + HandleId: *mut c_void, ClientToken: HANDLE, - DesiredAccess: ACCESS_MASK, - Privileges: PPRIVILEGE_SET, - AccessGranted: BOOLEAN, + DesiredAccess: c_ulong, + Privileges: *mut PRIVILEGE_SET, + AccessGranted: c_uchar, ) -> NTSTATUS; fn NtCloseObjectAuditAlarm( - SubsystemName: PUNICODE_STRING, - HandleId: PVOID, - GenerateOnClose: BOOLEAN, + SubsystemName: *mut UNICODE_STRING, + HandleId: *mut c_void, + GenerateOnClose: c_uchar, ) -> NTSTATUS; fn NtDeleteObjectAuditAlarm( - SubsystemName: PUNICODE_STRING, - HandleId: PVOID, - GenerateOnClose: BOOLEAN, + SubsystemName: *mut UNICODE_STRING, + HandleId: *mut c_void, + GenerateOnClose: c_uchar, ) -> NTSTATUS; fn NtPrivilegedServiceAuditAlarm( - SubsystemName: PUNICODE_STRING, - ServiceName: PUNICODE_STRING, + SubsystemName: *mut UNICODE_STRING, + ServiceName: *mut UNICODE_STRING, ClientToken: HANDLE, - Privileges: PPRIVILEGE_SET, - AccessGranted: BOOLEAN, + Privileges: *mut PRIVILEGE_SET, + AccessGranted: c_uchar, ) -> NTSTATUS; }} diff --git a/src/ntsmss.rs b/src/ntsmss.rs index b22991f..22b85a6 100644 --- a/src/ntsmss.rs +++ b/src/ntsmss.rs @@ -1,12 +1,13 @@ -use crate::ntlpcapi::PPORT_MESSAGE; -use winapi::shared::minwindef::DWORD; -use winapi::shared::ntdef::{HANDLE, NTSTATUS, PHANDLE, PUNICODE_STRING}; -EXTERN!{extern "system" { +use windows_sys::Win32::Foundation::{HANDLE, NTSTATUS, UNICODE_STRING}; + +use crate::{ctypes::c_ulong, ntlpcapi::PPORT_MESSAGE}; + +EXTERN! {extern "system" { fn RtlConnectToSm( - ApiPortName: PUNICODE_STRING, + ApiPortName: *mut UNICODE_STRING, ApiPortHandle: HANDLE, - ProcessImageType: DWORD, - SmssConnection: PHANDLE, + ProcessImageType: c_ulong, + SmssConnection: *mut HANDLE, ) -> NTSTATUS; fn RtlSendMsgToSm( ApiPortHandle: HANDLE, diff --git a/src/nttmapi.rs b/src/nttmapi.rs index 3ed499a..876eb09 100644 --- a/src/nttmapi.rs +++ b/src/nttmapi.rs @@ -1,39 +1,49 @@ -use winapi::shared::basetsd::ULONG_PTR; -use winapi::shared::guiddef::LPGUID; -use winapi::shared::ktmtypes::{NOTIFICATION_MASK, PCRM_PROTOCOL_ID, PTRANSACTION_NOTIFICATION}; -use winapi::shared::ntdef::{ - BOOLEAN, HANDLE, NTSTATUS, PHANDLE, PLARGE_INTEGER, POBJECT_ATTRIBUTES, PULONG, - PUNICODE_STRING, PVOID, ULONG, +use windows_sys::{ + core::GUID, + Win32::{ + Foundation::{HANDLE, NTSTATUS, UNICODE_STRING}, + Storage::FileSystem::TRANSACTION_NOTIFICATION, + System::{ + SystemServices::{ + ENLISTMENT_INFORMATION_CLASS, KTMOBJECT_CURSOR, KTMOBJECT_TYPE, + RESOURCEMANAGER_INFORMATION_CLASS, + TRANSACTIONMANAGER_INFORMATION_CLASS, + TRANSACTION_INFORMATION_CLASS, + }, + WindowsProgramming::OBJECT_ATTRIBUTES, + }, + }, }; -use winapi::um::winnt::{ - ACCESS_MASK, ENLISTMENT_INFORMATION_CLASS, KTMOBJECT_TYPE, PKTMOBJECT_CURSOR, - RESOURCEMANAGER_INFORMATION_CLASS, TRANSACTIONMANAGER_INFORMATION_CLASS, - TRANSACTION_INFORMATION_CLASS, + +use crate::{ + ctypes::{c_uchar, c_ulong, c_void}, + windows_local::shared::ntdef::LARGE_INTEGER, }; -EXTERN!{extern "system" { + +EXTERN! {extern "system" { fn NtCreateTransactionManager( - TmHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - LogFileName: PUNICODE_STRING, - CreateOptions: ULONG, - CommitStrength: ULONG, + TmHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + LogFileName: *mut UNICODE_STRING, + CreateOptions: c_ulong, + CommitStrength: c_ulong, ) -> NTSTATUS; fn NtOpenTransactionManager( - TmHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - LogFileName: PUNICODE_STRING, - TmIdentity: LPGUID, - OpenOptions: ULONG, + TmHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + LogFileName: *mut UNICODE_STRING, + TmIdentity: *mut GUID, + OpenOptions: c_ulong, ) -> NTSTATUS; fn NtRenameTransactionManager( - LogFileName: PUNICODE_STRING, - ExistingTransactionManagerGuid: LPGUID, + LogFileName: *mut UNICODE_STRING, + ExistingTransactionManagerGuid: *mut GUID, ) -> NTSTATUS; fn NtRollforwardTransactionManager( TransactionManagerHandle: HANDLE, - TmVirtualClock: PLARGE_INTEGER, + TmVirtualClock: *mut LARGE_INTEGER, ) -> NTSTATUS; fn NtRecoverTransactionManager( TransactionManagerHandle: HANDLE, @@ -41,199 +51,199 @@ EXTERN!{extern "system" { fn NtQueryInformationTransactionManager( TransactionManagerHandle: HANDLE, TransactionManagerInformationClass: TRANSACTIONMANAGER_INFORMATION_CLASS, - TransactionManagerInformation: PVOID, - TransactionManagerInformationLength: ULONG, - ReturnLength: PULONG, + TransactionManagerInformation: *mut c_void, + TransactionManagerInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn NtSetInformationTransactionManager( TmHandle: HANDLE, TransactionManagerInformationClass: TRANSACTIONMANAGER_INFORMATION_CLASS, - TransactionManagerInformation: PVOID, - TransactionManagerInformationLength: ULONG, + TransactionManagerInformation: *mut c_void, + TransactionManagerInformationLength: c_ulong, ) -> NTSTATUS; fn NtEnumerateTransactionObject( RootObjectHandle: HANDLE, QueryType: KTMOBJECT_TYPE, - ObjectCursor: PKTMOBJECT_CURSOR, - ObjectCursorLength: ULONG, - ReturnLength: PULONG, + ObjectCursor: *mut KTMOBJECT_CURSOR, + ObjectCursorLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn NtCreateTransaction( - TransactionHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - Uow: LPGUID, + TransactionHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + Uow: *mut GUID, TmHandle: HANDLE, - CreateOptions: ULONG, - IsolationLevel: ULONG, - IsolationFlags: ULONG, - Timeout: PLARGE_INTEGER, - Description: PUNICODE_STRING, + CreateOptions: c_ulong, + IsolationLevel: c_ulong, + IsolationFlags: c_ulong, + Timeout: *mut LARGE_INTEGER, + Description: *mut UNICODE_STRING, ) -> NTSTATUS; fn NtOpenTransaction( - TransactionHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - Uow: LPGUID, + TransactionHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + Uow: *mut GUID, TmHandle: HANDLE, ) -> NTSTATUS; fn NtQueryInformationTransaction( TransactionHandle: HANDLE, TransactionInformationClass: TRANSACTION_INFORMATION_CLASS, - TransactionInformation: PVOID, - TransactionInformationLength: ULONG, - ReturnLength: PULONG, + TransactionInformation: *mut c_void, + TransactionInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn NtSetInformationTransaction( TransactionHandle: HANDLE, TransactionInformationClass: TRANSACTION_INFORMATION_CLASS, - TransactionInformation: PVOID, - TransactionInformationLength: ULONG, + TransactionInformation: *mut c_void, + TransactionInformationLength: c_ulong, ) -> NTSTATUS; fn NtCommitTransaction( TransactionHandle: HANDLE, - Wait: BOOLEAN, + Wait: c_uchar, ) -> NTSTATUS; fn NtRollbackTransaction( TransactionHandle: HANDLE, - Wait: BOOLEAN, + Wait: c_uchar, ) -> NTSTATUS; fn NtCreateEnlistment( - EnlistmentHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, + EnlistmentHandle: *mut HANDLE, + DesiredAccess: c_ulong, ResourceManagerHandle: HANDLE, TransactionHandle: HANDLE, - ObjectAttributes: POBJECT_ATTRIBUTES, - CreateOptions: ULONG, - NotificationMask: NOTIFICATION_MASK, - EnlistmentKey: PVOID, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + CreateOptions: c_ulong, + NotificationMask: c_ulong, + EnlistmentKey: *mut c_void, ) -> NTSTATUS; fn NtOpenEnlistment( - EnlistmentHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, + EnlistmentHandle: *mut HANDLE, + DesiredAccess: c_ulong, ResourceManagerHandle: HANDLE, - EnlistmentGuid: LPGUID, - ObjectAttributes: POBJECT_ATTRIBUTES, + EnlistmentGuid: *mut GUID, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn NtQueryInformationEnlistment( EnlistmentHandle: HANDLE, EnlistmentInformationClass: ENLISTMENT_INFORMATION_CLASS, - EnlistmentInformation: PVOID, - EnlistmentInformationLength: ULONG, - ReturnLength: PULONG, + EnlistmentInformation: *mut c_void, + EnlistmentInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn NtSetInformationEnlistment( EnlistmentHandle: HANDLE, EnlistmentInformationClass: ENLISTMENT_INFORMATION_CLASS, - EnlistmentInformation: PVOID, - EnlistmentInformationLength: ULONG, + EnlistmentInformation: *mut c_void, + EnlistmentInformationLength: c_ulong, ) -> NTSTATUS; fn NtRecoverEnlistment( EnlistmentHandle: HANDLE, - EnlistmentKey: PVOID, + EnlistmentKey: *mut c_void, ) -> NTSTATUS; fn NtPrePrepareEnlistment( EnlistmentHandle: HANDLE, - TmVirtualClock: PLARGE_INTEGER, + TmVirtualClock: *mut LARGE_INTEGER, ) -> NTSTATUS; fn NtPrepareEnlistment( EnlistmentHandle: HANDLE, - TmVirtualClock: PLARGE_INTEGER, + TmVirtualClock: *mut LARGE_INTEGER, ) -> NTSTATUS; fn NtCommitEnlistment( EnlistmentHandle: HANDLE, - TmVirtualClock: PLARGE_INTEGER, + TmVirtualClock: *mut LARGE_INTEGER, ) -> NTSTATUS; fn NtRollbackEnlistment( EnlistmentHandle: HANDLE, - TmVirtualClock: PLARGE_INTEGER, + TmVirtualClock: *mut LARGE_INTEGER, ) -> NTSTATUS; fn NtPrePrepareComplete( EnlistmentHandle: HANDLE, - TmVirtualClock: PLARGE_INTEGER, + TmVirtualClock: *mut LARGE_INTEGER, ) -> NTSTATUS; fn NtPrepareComplete( EnlistmentHandle: HANDLE, - TmVirtualClock: PLARGE_INTEGER, + TmVirtualClock: *mut LARGE_INTEGER, ) -> NTSTATUS; fn NtCommitComplete( EnlistmentHandle: HANDLE, - TmVirtualClock: PLARGE_INTEGER, + TmVirtualClock: *mut LARGE_INTEGER, ) -> NTSTATUS; fn NtReadOnlyEnlistment( EnlistmentHandle: HANDLE, - TmVirtualClock: PLARGE_INTEGER, + TmVirtualClock: *mut LARGE_INTEGER, ) -> NTSTATUS; fn NtRollbackComplete( EnlistmentHandle: HANDLE, - TmVirtualClock: PLARGE_INTEGER, + TmVirtualClock: *mut LARGE_INTEGER, ) -> NTSTATUS; fn NtSinglePhaseReject( EnlistmentHandle: HANDLE, - TmVirtualClock: PLARGE_INTEGER, + TmVirtualClock: *mut LARGE_INTEGER, ) -> NTSTATUS; fn NtCreateResourceManager( - ResourceManagerHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, + ResourceManagerHandle: *mut HANDLE, + DesiredAccess: c_ulong, TmHandle: HANDLE, - RmGuid: LPGUID, - ObjectAttributes: POBJECT_ATTRIBUTES, - CreateOptions: ULONG, - Description: PUNICODE_STRING, + RmGuid: *mut GUID, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + CreateOptions: c_ulong, + Description: *mut UNICODE_STRING, ) -> NTSTATUS; fn NtOpenResourceManager( - ResourceManagerHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, + ResourceManagerHandle: *mut HANDLE, + DesiredAccess: c_ulong, TmHandle: HANDLE, - ResourceManagerGuid: LPGUID, - ObjectAttributes: POBJECT_ATTRIBUTES, + ResourceManagerGuid: *mut GUID, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn NtRecoverResourceManager( ResourceManagerHandle: HANDLE, ) -> NTSTATUS; fn NtGetNotificationResourceManager( ResourceManagerHandle: HANDLE, - TransactionNotification: PTRANSACTION_NOTIFICATION, - NotificationLength: ULONG, - Timeout: PLARGE_INTEGER, - ReturnLength: PULONG, - Asynchronous: ULONG, - AsynchronousContext: ULONG_PTR, + TransactionNotification: *mut TRANSACTION_NOTIFICATION, + NotificationLength: c_ulong, + Timeout: *mut LARGE_INTEGER, + ReturnLength: *mut c_ulong, + Asynchronous: c_ulong, + AsynchronousContext: usize, ) -> NTSTATUS; fn NtQueryInformationResourceManager( ResourceManagerHandle: HANDLE, ResourceManagerInformationClass: RESOURCEMANAGER_INFORMATION_CLASS, - ResourceManagerInformation: PVOID, - ResourceManagerInformationLength: ULONG, - ReturnLength: PULONG, + ResourceManagerInformation: *mut c_void, + ResourceManagerInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn NtSetInformationResourceManager( ResourceManagerHandle: HANDLE, ResourceManagerInformationClass: RESOURCEMANAGER_INFORMATION_CLASS, - ResourceManagerInformation: PVOID, - ResourceManagerInformationLength: ULONG, + ResourceManagerInformation: *mut c_void, + ResourceManagerInformationLength: c_ulong, ) -> NTSTATUS; fn NtRegisterProtocolAddressInformation( ResourceManager: HANDLE, - ProtocolId: PCRM_PROTOCOL_ID, - ProtocolInformationSize: ULONG, - ProtocolInformation: PVOID, - CreateOptions: ULONG, + ProtocolId: *mut GUID, + ProtocolInformationSize: c_ulong, + ProtocolInformation: *mut c_void, + CreateOptions: c_ulong, ) -> NTSTATUS; fn NtPropagationComplete( ResourceManagerHandle: HANDLE, - RequestCookie: ULONG, - BufferLength: ULONG, - Buffer: PVOID, + RequestCookie: c_ulong, + BufferLength: c_ulong, + Buffer: *mut c_void, ) -> NTSTATUS; fn NtPropagationFailed( ResourceManagerHandle: HANDLE, - RequestCookie: ULONG, + RequestCookie: c_ulong, PropStatus: NTSTATUS, ) -> NTSTATUS; fn NtFreezeTransactions( - FreezeTimeout: PLARGE_INTEGER, - ThawTimeout: PLARGE_INTEGER, + FreezeTimeout: *mut LARGE_INTEGER, + ThawTimeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn NtThawTransactions() -> NTSTATUS; }} diff --git a/src/nttp.rs b/src/nttp.rs index a41eb34..bdecc44 100644 --- a/src/nttp.rs +++ b/src/nttp.rs @@ -1,58 +1,70 @@ -use crate::ntioapi::PIO_STATUS_BLOCK; -use winapi::shared::ntdef::{HANDLE, LOGICAL, LONG, NTSTATUS, PLARGE_INTEGER, PVOID}; -use winapi::um::winnt::{ - PRTL_CRITICAL_SECTION, PTP_CALLBACK_ENVIRON, PTP_CALLBACK_INSTANCE, PTP_CLEANUP_GROUP, PTP_IO, - PTP_POOL, PTP_POOL_STACK_INFORMATION, PTP_SIMPLE_CALLBACK, PTP_TIMER, PTP_TIMER_CALLBACK, - PTP_WAIT, PTP_WAIT_CALLBACK, PTP_WORK, PTP_WORK_CALLBACK, +use windows_sys::Win32::{ + Foundation::{HANDLE, NTSTATUS}, + System::{ + SystemServices::TP_CLEANUP_GROUP, + Threading::{ + PTP_CALLBACK_INSTANCE, PTP_IO, PTP_POOL, PTP_SIMPLE_CALLBACK, + PTP_TIMER, PTP_TIMER_CALLBACK, PTP_WAIT, PTP_WAIT_CALLBACK, + PTP_WORK, PTP_WORK_CALLBACK, RTL_CRITICAL_SECTION, + TP_CALLBACK_ENVIRON_V3, TP_POOL_STACK_INFORMATION, + }, + }, }; + +use crate::{ + ctypes::{c_long, c_ulong, c_void}, + ntioapi::PIO_STATUS_BLOCK, + windows_local::shared::ntdef::LARGE_INTEGER, +}; + #[repr(C)] pub struct TP_ALPC([u8; 0]); pub type PTP_ALPC = *mut TP_ALPC; -FN!{stdcall PTP_ALPC_CALLBACK( +FN! {stdcall PTP_ALPC_CALLBACK( Instance: PTP_CALLBACK_INSTANCE, - Context: PVOID, + Context: *mut c_void, Alpc: PTP_ALPC, ) -> ()} -FN!{stdcall PTP_ALPC_CALLBACK_EX( +FN! {stdcall PTP_ALPC_CALLBACK_EX( Instanc: PTP_CALLBACK_INSTANCE, - Contex: PVOID, + Contex: *mut c_void, Alp: PTP_ALPC, - ApcContext: PVOID, + ApcContext: *mut c_void, ) -> ()} -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn TpAllocPool( PoolReturn: *mut PTP_POOL, - Reserved: PVOID, + Reserved: *mut c_void, ) -> NTSTATUS; fn TpReleasePool( Pool: PTP_POOL, ); fn TpSetPoolMaxThreads( Pool: PTP_POOL, - MaxThreads: LONG, + MaxThreads: c_long, ); fn TpSetPoolMinThreads( Pool: PTP_POOL, - MinThreads: LONG, + MinThreads: c_long, ) -> NTSTATUS; fn TpQueryPoolStackInformation( Pool: PTP_POOL, - PoolStackInformation: PTP_POOL_STACK_INFORMATION, + PoolStackInformation: *mut TP_POOL_STACK_INFORMATION, ) -> NTSTATUS; fn TpSetPoolStackInformation( Pool: PTP_POOL, - PoolStackInformation: PTP_POOL_STACK_INFORMATION, + PoolStackInformation: *mut TP_POOL_STACK_INFORMATION, ) -> NTSTATUS; fn TpAllocCleanupGroup( - CleanupGroupReturn: *mut PTP_CLEANUP_GROUP, + CleanupGroupReturn: *mut *mut TP_CLEANUP_GROUP, ) -> NTSTATUS; fn TpReleaseCleanupGroup( - CleanupGroup: PTP_CLEANUP_GROUP, + CleanupGroup: *mut TP_CLEANUP_GROUP, ); fn TpReleaseCleanupGroupMembers( - CleanupGroup: PTP_CLEANUP_GROUP, - CancelPendingCallbacks: LOGICAL, - CleanupParameter: PVOID, + CleanupGroup: *mut TP_CLEANUP_GROUP, + CancelPendingCallbacks: c_ulong, + CleanupParameter: *mut c_void, ); fn TpCallbackSetEventOnCompletion( Instance: PTP_CALLBACK_INSTANCE, @@ -61,7 +73,7 @@ EXTERN!{extern "system" { fn TpCallbackReleaseSemaphoreOnCompletion( Instance: PTP_CALLBACK_INSTANCE, Semaphore: HANDLE, - ReleaseCount: LONG, + ReleaseCount: c_long, ); fn TpCallbackReleaseMutexOnCompletion( Instance: PTP_CALLBACK_INSTANCE, @@ -69,11 +81,11 @@ EXTERN!{extern "system" { ); fn TpCallbackLeaveCriticalSectionOnCompletion( Instance: PTP_CALLBACK_INSTANCE, - CriticalSection: PRTL_CRITICAL_SECTION, + CriticalSection: *mut RTL_CRITICAL_SECTION, ); fn TpCallbackUnloadDllOnCompletion( Instance: PTP_CALLBACK_INSTANCE, - DllHandle: PVOID, + DllHandle: *mut c_void, ); fn TpCallbackMayRunLong( Instance: PTP_CALLBACK_INSTANCE, @@ -83,14 +95,14 @@ EXTERN!{extern "system" { ); fn TpSimpleTryPost( Callback: PTP_SIMPLE_CALLBACK, - Context: PVOID, - CallbackEnviron: PTP_CALLBACK_ENVIRON, + Context: *mut c_void, + CallbackEnviron: *mut TP_CALLBACK_ENVIRON_V3, ) -> NTSTATUS; fn TpAllocWork( WorkReturn: *mut PTP_WORK, Callback: PTP_WORK_CALLBACK, - Context: PVOID, - CallbackEnviron: PTP_CALLBACK_ENVIRON, + Context: *mut c_void, + CallbackEnviron: *mut TP_CALLBACK_ENVIRON_V3, ) -> NTSTATUS; fn TpReleaseWork( Work: PTP_WORK, @@ -100,35 +112,35 @@ EXTERN!{extern "system" { ); fn TpWaitForWork( Work: PTP_WORK, - CancelPendingCallbacks: LOGICAL, + CancelPendingCallbacks: c_ulong, ); fn TpAllocTimer( Timer: *mut PTP_TIMER, Callback: PTP_TIMER_CALLBACK, - Context: PVOID, - CallbackEnviron: PTP_CALLBACK_ENVIRON, + Context: *mut c_void, + CallbackEnviron: *mut TP_CALLBACK_ENVIRON_V3, ) -> NTSTATUS; fn TpReleaseTimer( Timer: PTP_TIMER, ); fn TpSetTimer( Timer: PTP_TIMER, - DueTime: PLARGE_INTEGER, - Period: LONG, - WindowLength: LONG, + DueTime: *mut LARGE_INTEGER, + Period: c_long, + WindowLength: c_long, ); fn TpIsTimerSet( Timer: PTP_TIMER, - ) -> LOGICAL; + ) -> c_ulong; fn TpWaitForTimer( Timer: PTP_TIMER, - CancelPendingCallbacks: LOGICAL, + CancelPendingCallbacks: c_ulong, ); fn TpAllocWait( WaitReturn: *mut PTP_WAIT, Callback: PTP_WAIT_CALLBACK, - Context: PVOID, - CallbackEnviron: PTP_CALLBACK_ENVIRON, + Context: *mut c_void, + CallbackEnviron: *mut TP_CALLBACK_ENVIRON_V3, ) -> NTSTATUS; fn TpReleaseWait( Wait: PTP_WAIT, @@ -136,27 +148,27 @@ EXTERN!{extern "system" { fn TpSetWait( Wait: PTP_WAIT, Handle: HANDLE, - Timeout: PLARGE_INTEGER, + Timeout: *mut LARGE_INTEGER, ); fn TpWaitForWait( Wait: PTP_WAIT, - CancelPendingCallbacks: LOGICAL, + CancelPendingCallbacks: c_ulong, ); }} -FN!{stdcall PTP_IO_CALLBACK( +FN! {stdcall PTP_IO_CALLBACK( Instance: PTP_CALLBACK_INSTANCE, - Context: PVOID, - ApcContext: PVOID, + Context: *mut c_void, + ApcContext: *mut c_void, IoSB: PIO_STATUS_BLOCK, Io: PTP_IO, ) -> ()} -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn TpAllocIoCompletion( IoReturn: *mut PTP_IO, File: HANDLE, Callback: PTP_IO_CALLBACK, - Context: PVOID, - CallbackEnviron: PTP_CALLBACK_ENVIRON, + Context: *mut c_void, + CallbackEnviron: *mut TP_CALLBACK_ENVIRON_V3, ) -> NTSTATUS; fn TpReleaseIoCompletion( Io: PTP_IO, @@ -169,21 +181,21 @@ EXTERN!{extern "system" { ); fn TpWaitForIoCompletion( Io: PTP_IO, - CancelPendingCallbacks: LOGICAL, + CancelPendingCallbacks: c_ulong, ); fn TpAllocAlpcCompletion( AlpcReturn: *mut PTP_ALPC, AlpcPort: HANDLE, Callback: PTP_ALPC_CALLBACK, - Context: PVOID, - CallbackEnviron: PTP_CALLBACK_ENVIRON, + Context: *mut c_void, + CallbackEnviron: *mut TP_CALLBACK_ENVIRON_V3, ) -> NTSTATUS; fn TpAllocAlpcCompletionEx( AlpcReturn: *mut PTP_ALPC, AlpcPort: HANDLE, Callback: PTP_ALPC_CALLBACK_EX, - Context: PVOID, - CallbackEnviron: PTP_CALLBACK_ENVIRON, + Context: *mut c_void, + CallbackEnviron: *mut TP_CALLBACK_ENVIRON_V3, ) -> NTSTATUS; fn TpReleaseAlpcCompletion( Alpc: PTP_ALPC, @@ -192,12 +204,12 @@ EXTERN!{extern "system" { Alpc: PTP_ALPC, ); }} -ENUM!{enum TP_TRACE_TYPE { +ENUM! {enum TP_TRACE_TYPE { TpTraceThreadPriority = 1, TpTraceThreadAffinity = 2, MaxTpTraceType = 3, }} -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn TpCaptureCaller( Type: TP_TRACE_TYPE, ); diff --git a/src/ntwow64.rs b/src/ntwow64.rs index 9a95ae2..b2897a7 100644 --- a/src/ntwow64.rs +++ b/src/ntwow64.rs @@ -1,16 +1,26 @@ -use core::mem::size_of; -use crate::ntapi_base::CLIENT_ID32; -use crate::ntldr::{LDR_DDAG_STATE, LDR_DLL_LOAD_REASON}; -use crate::ntpsapi::GDI_HANDLE_BUFFER32; -use crate::ntrtl::RTL_MAX_DRIVE_LETTERS; -use crate::string::{UTF16Const, UTF8Const}; -use winapi::shared::guiddef::GUID; -use winapi::shared::ntdef::{ - BOOLEAN, CHAR, LARGE_INTEGER, LCID, LIST_ENTRY32, LONG, NTSTATUS, PROCESSOR_NUMBER, - SINGLE_LIST_ENTRY32, STRING32, UCHAR, ULARGE_INTEGER, ULONG, ULONGLONG, UNICODE_STRING, - UNICODE_STRING32, USHORT, WCHAR, +use windows_sys::{ + core::GUID, + Win32::{ + Foundation::{NTSTATUS, UNICODE_STRING}, + System::{ + Kernel::{ + LIST_ENTRY32, PROCESSOR_NUMBER, SINGLE_LIST_ENTRY32, STRING32, + }, + SystemServices::{FLS_MAXIMUM_AVAILABLE, NT_TIB32}, + }, + }, }; -use winapi::um::winnt::{FLS_MAXIMUM_AVAILABLE, NT_TIB32}; + +use crate::{ + ctypes::{__uint64, c_char, c_long, c_uchar, c_ulong, c_ushort, wchar_t}, + ntapi_base::CLIENT_ID32, + ntldr::{LDR_DDAG_STATE, LDR_DLL_LOAD_REASON}, + ntpsapi::GDI_HANDLE_BUFFER32, + ntrtl::RTL_MAX_DRIVE_LETTERS, + string::{UTF16Const, UTF8Const}, + windows_local::shared::ntdef::{LARGE_INTEGER, ULARGE_INTEGER}, +}; + pub const WOW64_SYSTEM_DIRECTORY: UTF8Const = UTF8Const("SysWOW64\0"); /// "SysWOW64" pub const WOW64_SYSTEM_DIRECTORY_U: UTF16Const = UTF16Const(&[ @@ -18,10 +28,9 @@ pub const WOW64_SYSTEM_DIRECTORY_U: UTF16Const = UTF16Const(&[ ]); pub const WOW64_X86_TAG: UTF8Const = UTF8Const(" (x86)\0"); /// " (x86)" -pub const WOW64_X86_TAG_U: UTF16Const = UTF16Const(&[ - 0x0020, 0x0028, 0x0078, 0x0038, 0x0036, 0x0029, 0u16, -]); -ENUM!{enum WOW64_SHARED_INFORMATION { +pub const WOW64_X86_TAG_U: UTF16Const = + UTF16Const(&[0x0020, 0x0028, 0x0078, 0x0038, 0x0036, 0x0029, 0u16]); +ENUM! {enum WOW64_SHARED_INFORMATION { SharedNtdll32LdrInitializeThunk = 0, SharedNtdll32KiUserExceptionDispatcher = 1, SharedNtdll32KiUserApcDispatcher = 2, @@ -35,106 +44,106 @@ ENUM!{enum WOW64_SHARED_INFORMATION { SharedNtdll32LdrSystemDllInitBlock = 10, Wow64SharedPageEntriesCount = 11, }} -STRUCT!{struct RTL_BALANCED_NODE32_u_s { - Left: ULONG, // WOW64_POINTER - Right: ULONG, // WOW64_POINTER +STRUCT! {struct RTL_BALANCED_NODE32_u_s { + Left: c_ulong, // WOW64_POINTER + Right: c_ulong, // WOW64_POINTER }} -UNION!{union RTL_BALANCED_NODE32_u { - Children: [ULONG; 2], // WOW64_POINTER +UNION! {union RTL_BALANCED_NODE32_u { + Children: [c_ulong; 2], // WOW64_POINTER s: RTL_BALANCED_NODE32_u_s, }} -STRUCT!{struct RTL_BALANCED_NODE32 { +STRUCT! {struct RTL_BALANCED_NODE32 { u: RTL_BALANCED_NODE32_u, - ParentValue: ULONG, + ParentValue: c_ulong, }} pub type PRTL_BALANCED_NODE32 = *mut RTL_BALANCED_NODE32; -STRUCT!{struct RTL_RB_TREE32 { - Root: ULONG, // WOW64_POINTER - Min: ULONG, // WOW64_POINTER +STRUCT! {struct RTL_RB_TREE32 { + Root: c_ulong, // WOW64_POINTER + Min: c_ulong, // WOW64_POINTER }} pub type PRTL_RB_TREE32 = *mut RTL_RB_TREE32; -STRUCT!{struct PEB_LDR_DATA32 { - Length: ULONG, - Initialized: BOOLEAN, - SsHandle: ULONG, +STRUCT! {struct PEB_LDR_DATA32 { + Length: c_ulong, + Initialized: c_uchar, + SsHandle: c_ulong, InLoadOrderModuleList: LIST_ENTRY32, InMemoryOrderModuleList: LIST_ENTRY32, InInitializationOrderModuleList: LIST_ENTRY32, - EntryInProgress: ULONG, - ShutdownInProgress: BOOLEAN, - ShutdownThreadId: ULONG, + EntryInProgress: c_ulong, + ShutdownInProgress: c_uchar, + ShutdownThreadId: c_ulong, }} pub type PPEB_LDR_DATA32 = *mut PEB_LDR_DATA32; -STRUCT!{struct LDR_SERVICE_TAG_RECORD32 { - Next: ULONG, - ServiceTag: ULONG, +STRUCT! {struct LDR_SERVICE_TAG_RECORD32 { + Next: c_ulong, + ServiceTag: c_ulong, }} pub type PLDR_SERVICE_TAG_RECORD32 = *mut LDR_SERVICE_TAG_RECORD32; -STRUCT!{struct LDRP_CSLIST32 { - Tail: ULONG, // WOW64_POINTER +STRUCT! {struct LDRP_CSLIST32 { + Tail: c_ulong, // WOW64_POINTER }} pub type PLDRP_CSLIST32 = *mut LDRP_CSLIST32; -UNION!{union LDR_DDAG_NODE32_u { +UNION! {union LDR_DDAG_NODE32_u { Dependencies: LDRP_CSLIST32, RemovalLink: SINGLE_LIST_ENTRY32, }} -STRUCT!{struct LDR_DDAG_NODE32 { +STRUCT! {struct LDR_DDAG_NODE32 { Modules: LIST_ENTRY32, - ServiceTagList: ULONG, // WOW64_POINTER - LoadCount: ULONG, - LoadWhileUnloadingCount: ULONG, - LowestLink: ULONG, + ServiceTagList: c_ulong, // WOW64_POINTER + LoadCount: c_ulong, + LoadWhileUnloadingCount: c_ulong, + LowestLink: c_ulong, u: LDR_DDAG_NODE32_u, IncomingDependencies: LDRP_CSLIST32, State: LDR_DDAG_STATE, CondenseLink: SINGLE_LIST_ENTRY32, - PreorderNumber: ULONG, + PreorderNumber: c_ulong, }} pub type PLDR_DDAG_NODE32 = *mut LDR_DDAG_NODE32; pub const LDR_DATA_TABLE_ENTRY_SIZE_WINXP_32: usize = 80; pub const LDR_DATA_TABLE_ENTRY_SIZE_WIN7_32: usize = 144; pub const LDR_DATA_TABLE_ENTRY_SIZE_WIN8_32: usize = 152; -UNION!{union LDR_DATA_TABLE_ENTRY32_u1 { +UNION! {union LDR_DATA_TABLE_ENTRY32_u1 { InInitializationOrderLinks: LIST_ENTRY32, InProgressLinks: LIST_ENTRY32, }} -UNION!{union LDR_DATA_TABLE_ENTRY32_u2 { - FlagGroup: [UCHAR; 4], - Flags: ULONG, +UNION! {union LDR_DATA_TABLE_ENTRY32_u2 { + FlagGroup: [c_uchar; 4], + Flags: c_ulong, }} -STRUCT!{struct LDR_DATA_TABLE_ENTRY32 { +STRUCT! {struct LDR_DATA_TABLE_ENTRY32 { InLoadOrderLinks: LIST_ENTRY32, InMemoryOrderLinks: LIST_ENTRY32, u1: LDR_DATA_TABLE_ENTRY32_u1, - DllBase: ULONG, // WOW64_POINTER - EntryPoint: ULONG, // WOW64_POINTER - SizeOfImage: ULONG, - FullDllName: UNICODE_STRING32, - BaseDllName: UNICODE_STRING32, + DllBase: c_ulong, // WOW64_POINTER + EntryPoint: c_ulong, // WOW64_POINTER + SizeOfImage: c_ulong, + FullDllName: STRING32, + BaseDllName: STRING32, u2: LDR_DATA_TABLE_ENTRY32_u2, - ObsoleteLoadCount: USHORT, - TlsIndex: USHORT, + ObsoleteLoadCount: c_ushort, + TlsIndex: c_ushort, HashLinks: LIST_ENTRY32, - TimeDateStamp: ULONG, - EntryPointActivationContext: ULONG, // WOW64_POINTER - Lock: ULONG, // WOW64_POINTER - DdagNode: ULONG, // WOW64_POINTER + TimeDateStamp: c_ulong, + EntryPointActivationContext: c_ulong, // WOW64_POINTER + Lock: c_ulong, // WOW64_POINTER + DdagNode: c_ulong, // WOW64_POINTER NodeModuleLink: LIST_ENTRY32, - LoadContext: ULONG, // WOW64_POINTER - ParentDllBase: ULONG, // WOW64_POINTER - SwitchBackContext: ULONG, // WOW64_POINTER + LoadContext: c_ulong, // WOW64_POINTER + ParentDllBase: c_ulong, // WOW64_POINTER + SwitchBackContext: c_ulong, // WOW64_POINTER BaseAddressIndexNode: RTL_BALANCED_NODE32, MappingInfoIndexNode: RTL_BALANCED_NODE32, - OriginalBase: ULONG, + OriginalBase: c_ulong, LoadTime: LARGE_INTEGER, - BaseNameHashValue: ULONG, + BaseNameHashValue: c_ulong, LoadReason: LDR_DLL_LOAD_REASON, - ImplicitPathOptions: ULONG, - ReferenceCount: ULONG, - DependentLoadFlags: ULONG, - SigningLevel: UCHAR, + ImplicitPathOptions: c_ulong, + ReferenceCount: c_ulong, + DependentLoadFlags: c_ulong, + SigningLevel: c_uchar, }} -BITFIELD!{unsafe LDR_DATA_TABLE_ENTRY32_u2 Flags: ULONG [ +BITFIELD! {unsafe LDR_DATA_TABLE_ENTRY32_u2 Flags: c_ulong [ PackagedBinary set_PackagedBinary[0..1], MarkedForRemoval set_MarkedForRemoval[1..2], ImageDll set_ImageDll[2..3], @@ -164,145 +173,145 @@ BITFIELD!{unsafe LDR_DATA_TABLE_ENTRY32_u2 Flags: ULONG [ CompatDatabaseProcessed set_CompatDatabaseProcessed[31..32], ]} pub type PLDR_DATA_TABLE_ENTRY32 = *mut LDR_DATA_TABLE_ENTRY32; -STRUCT!{struct CURDIR32 { - DosPath: UNICODE_STRING32, - Handle: ULONG, // WOW64_POINTER +STRUCT! {struct CURDIR32 { + DosPath: STRING32, + Handle: c_ulong, // WOW64_POINTER }} pub type PCURDIR32 = *mut CURDIR32; -STRUCT!{struct RTL_DRIVE_LETTER_CURDIR32 { - Flags: USHORT, - Length: USHORT, - TimeStamp: ULONG, +STRUCT! {struct RTL_DRIVE_LETTER_CURDIR32 { + Flags: c_ushort, + Length: c_ushort, + TimeStamp: c_ulong, DosPath: STRING32, }} pub type PRTL_DRIVE_LETTER_CURDIR32 = *mut RTL_DRIVE_LETTER_CURDIR32; -STRUCT!{struct RTL_USER_PROCESS_PARAMETERS32 { - MaximumLength: ULONG, - Length: ULONG, - Flags: ULONG, - DebugFlags: ULONG, - ConsoleHandle: ULONG, // WOW64_POINTER - ConsoleFlags: ULONG, - StandardInput: ULONG, // WOW64_POINTER - StandardOutput: ULONG, // WOW64_POINTER - StandardError: ULONG, // WOW64_POINTER +STRUCT! {struct RTL_USER_PROCESS_PARAMETERS32 { + MaximumLength: c_ulong, + Length: c_ulong, + Flags: c_ulong, + DebugFlags: c_ulong, + ConsoleHandle: c_ulong, // WOW64_POINTER + ConsoleFlags: c_ulong, + StandardInput: c_ulong, // WOW64_POINTER + StandardOutput: c_ulong, // WOW64_POINTER + StandardError: c_ulong, // WOW64_POINTER CurrentDirectory: CURDIR32, - DllPath: UNICODE_STRING32, - ImagePathName: UNICODE_STRING32, - CommandLine: UNICODE_STRING32, - Environment: ULONG, // WOW64_POINTER - StartingX: ULONG, - StartingY: ULONG, - CountX: ULONG, - CountY: ULONG, - CountCharsX: ULONG, - CountCharsY: ULONG, - FillAttribute: ULONG, - WindowFlags: ULONG, - ShowWindowFlags: ULONG, - WindowTitle: UNICODE_STRING32, - DesktopInfo: UNICODE_STRING32, - ShellInfo: UNICODE_STRING32, - RuntimeData: UNICODE_STRING32, + DllPath: STRING32, + ImagePathName: STRING32, + CommandLine: STRING32, + Environment: c_ulong, // WOW64_POINTER + StartingX: c_ulong, + StartingY: c_ulong, + CountX: c_ulong, + CountY: c_ulong, + CountCharsX: c_ulong, + CountCharsY: c_ulong, + FillAttribute: c_ulong, + WindowFlags: c_ulong, + ShowWindowFlags: c_ulong, + WindowTitle: STRING32, + DesktopInfo: STRING32, + ShellInfo: STRING32, + RuntimeData: STRING32, CurrentDirectories: [RTL_DRIVE_LETTER_CURDIR32; RTL_MAX_DRIVE_LETTERS], - EnvironmentSize: ULONG, - EnvironmentVersion: ULONG, - PackageDependencyData: ULONG, // WOW64_POINTER - ProcessGroupId: ULONG, - LoaderThreads: ULONG, + EnvironmentSize: c_ulong, + EnvironmentVersion: c_ulong, + PackageDependencyData: c_ulong, // WOW64_POINTER + ProcessGroupId: c_ulong, + LoaderThreads: c_ulong, }} pub type PRTL_USER_PROCESS_PARAMETERS32 = *mut RTL_USER_PROCESS_PARAMETERS32; -UNION!{union PEB32_u { - KernelCallbackTable: ULONG, // WOW64_POINTER - UserSharedInfoPtr: ULONG, // WOW64_POINTER +UNION! {union PEB32_u { + KernelCallbackTable: c_ulong, // WOW64_POINTER + UserSharedInfoPtr: c_ulong, // WOW64_POINTER }} -STRUCT!{struct PEB32 { - InheritedAddressSpace: BOOLEAN, - ReadImageFileExecOptions: BOOLEAN, - BeingDebugged: BOOLEAN, - BitField: BOOLEAN, - Mutant: ULONG, // WOW64_POINTER - ImageBaseAddress: ULONG, // WOW64_POINTER - Ldr: ULONG, // WOW64_POINTER - ProcessParameters: ULONG, // WOW64_POINTER - SubSystemData: ULONG, // WOW64_POINTER - ProcessHeap: ULONG, // WOW64_POINTER - FastPebLock: ULONG, // WOW64_POINTER - AtlThunkSListPtr: ULONG, // WOW64_POINTER - IFEOKey: ULONG, // WOW64_POINTER - CrossProcessFlags: ULONG, +STRUCT! {struct PEB32 { + InheritedAddressSpace: c_uchar, + ReadImageFileExecOptions: c_uchar, + BeingDebugged: c_uchar, + BitField: c_uchar, + Mutant: c_ulong, // WOW64_POINTER + ImageBaseAddress: c_ulong, // WOW64_POINTER + Ldr: c_ulong, // WOW64_POINTER + ProcessParameters: c_ulong, // WOW64_POINTER + SubSystemData: c_ulong, // WOW64_POINTER + ProcessHeap: c_ulong, // WOW64_POINTER + FastPebLock: c_ulong, // WOW64_POINTER + AtlThunkSListPtr: c_ulong, // WOW64_POINTER + IFEOKey: c_ulong, // WOW64_POINTER + CrossProcessFlags: c_ulong, u: PEB32_u, - SystemReserved: [ULONG; 1], - AtlThunkSListPtr32: ULONG, - ApiSetMap: ULONG, // WOW64_POINTER - TlsExpansionCounter: ULONG, - TlsBitmap: ULONG, // WOW64_POINTER - TlsBitmapBits: [ULONG; 2], - ReadOnlySharedMemoryBase: ULONG, // WOW64_POINTER - HotpatchInformation: ULONG, // WOW64_POINTER - ReadOnlyStaticServerData: ULONG, // WOW64_POINTER - AnsiCodePageData: ULONG, // WOW64_POINTER - OemCodePageData: ULONG, // WOW64_POINTER - UnicodeCaseTableData: ULONG, // WOW64_POINTER - NumberOfProcessors: ULONG, - NtGlobalFlag: ULONG, + SystemReserved: [c_ulong; 1], + AtlThunkSListPtr32: c_ulong, + ApiSetMap: c_ulong, // WOW64_POINTER + TlsExpansionCounter: c_ulong, + TlsBitmap: c_ulong, // WOW64_POINTER + TlsBitmapBits: [c_ulong; 2], + ReadOnlySharedMemoryBase: c_ulong, // WOW64_POINTER + HotpatchInformation: c_ulong, // WOW64_POINTER + ReadOnlyStaticServerData: c_ulong, // WOW64_POINTER + AnsiCodePageData: c_ulong, // WOW64_POINTER + OemCodePageData: c_ulong, // WOW64_POINTER + UnicodeCaseTableData: c_ulong, // WOW64_POINTER + NumberOfProcessors: c_ulong, + NtGlobalFlag: c_ulong, CriticalSectionTimeout: LARGE_INTEGER, - HeapSegmentReserve: ULONG, - HeapSegmentCommit: ULONG, - HeapDeCommitTotalFreeThreshold: ULONG, - HeapDeCommitFreeBlockThreshold: ULONG, - NumberOfHeaps: ULONG, - MaximumNumberOfHeaps: ULONG, - ProcessHeaps: ULONG, // WOW64_POINTER - GdiSharedHandleTable: ULONG, // WOW64_POINTER - ProcessStarterHelper: ULONG, // WOW64_POINTER - GdiDCAttributeList: ULONG, - LoaderLock: ULONG, // WOW64_POINTER - OSMajorVersion: ULONG, - OSMinorVersion: ULONG, - OSBuildNumber: USHORT, - OSCSDVersion: USHORT, - OSPlatformId: ULONG, - ImageSubsystem: ULONG, - ImageSubsystemMajorVersion: ULONG, - ImageSubsystemMinorVersion: ULONG, - ActiveProcessAffinityMask: ULONG, + HeapSegmentReserve: c_ulong, + HeapSegmentCommit: c_ulong, + HeapDeCommitTotalFreeThreshold: c_ulong, + HeapDeCommitFreeBlockThreshold: c_ulong, + NumberOfHeaps: c_ulong, + MaximumNumberOfHeaps: c_ulong, + ProcessHeaps: c_ulong, // WOW64_POINTER + GdiSharedHandleTable: c_ulong, // WOW64_POINTER + ProcessStarterHelper: c_ulong, // WOW64_POINTER + GdiDCAttributeList: c_ulong, + LoaderLock: c_ulong, // WOW64_POINTER + OSMajorVersion: c_ulong, + OSMinorVersion: c_ulong, + OSBuildNumber: c_ushort, + OSCSDVersion: c_ushort, + OSPlatformId: c_ulong, + ImageSubsystem: c_ulong, + ImageSubsystemMajorVersion: c_ulong, + ImageSubsystemMinorVersion: c_ulong, + ActiveProcessAffinityMask: c_ulong, GdiHandleBuffer: GDI_HANDLE_BUFFER32, - PostProcessInitRoutine: ULONG, // WOW64_POINTER - TlsExpansionBitmap: ULONG, // WOW64_POINTER - TlsExpansionBitmapBits: [ULONG; 32], - SessionId: ULONG, + PostProcessInitRoutine: c_ulong, // WOW64_POINTER + TlsExpansionBitmap: c_ulong, // WOW64_POINTER + TlsExpansionBitmapBits: [c_ulong; 32], + SessionId: c_ulong, AppCompatFlags: ULARGE_INTEGER, AppCompatFlagsUser: ULARGE_INTEGER, - pShimData: ULONG, // WOW64_POINTER - AppCompatInfo: ULONG, // WOW64_POINTER - CSDVersion: UNICODE_STRING32, - ActivationContextData: ULONG, // WOW64_POINTER - ProcessAssemblyStorageMap: ULONG, // WOW64_POINTER - SystemDefaultActivationContextData: ULONG, // WOW64_POINTER - SystemAssemblyStorageMap: ULONG, // WOW64_POINTER - MinimumStackCommit: ULONG, - FlsCallback: ULONG, // WOW64_POINTER + pShimData: c_ulong, // WOW64_POINTER + AppCompatInfo: c_ulong, // WOW64_POINTER + CSDVersion: STRING32, + ActivationContextData: c_ulong, // WOW64_POINTER + ProcessAssemblyStorageMap: c_ulong, // WOW64_POINTER + SystemDefaultActivationContextData: c_ulong, // WOW64_POINTER + SystemAssemblyStorageMap: c_ulong, // WOW64_POINTER + MinimumStackCommit: c_ulong, + FlsCallback: c_ulong, // WOW64_POINTER FlsListHead: LIST_ENTRY32, - FlsBitmap: ULONG, // WOW64_POINTER - FlsBitmapBits: [ULONG; FLS_MAXIMUM_AVAILABLE as usize / (size_of::() * 8)], - FlsHighIndex: ULONG, - WerRegistrationData: ULONG, // WOW64_POINTER - WerShipAssertPtr: ULONG, // WOW64_POINTER - pContextData: ULONG, // WOW64_POINTER - pImageHeaderHash: ULONG, // WOW64_POINTER - TracingFlags: ULONG, - CsrServerReadOnlySharedMemoryBase: ULONGLONG, - TppWorkerpListLock: ULONG, // WOW64_POINTER + FlsBitmap: c_ulong, // WOW64_POINTER + FlsBitmapBits: [c_ulong; FLS_MAXIMUM_AVAILABLE as usize / c_ulong::BITS as usize], + FlsHighIndex: c_ulong, + WerRegistrationData: c_ulong, // WOW64_POINTER + WerShipAssertPtr: c_ulong, // WOW64_POINTER + pContextData: c_ulong, // WOW64_POINTER + pImageHeaderHash: c_ulong, // WOW64_POINTER + TracingFlags: c_ulong, + CsrServerReadOnlySharedMemoryBase: __uint64, + TppWorkerpListLock: c_ulong, // WOW64_POINTER TppWorkerpList: LIST_ENTRY32, - WaitOnAddressHashTable: [ULONG; 128], // WOW64_POINTER - TelemetryCoverageHeader: ULONG, // WOW64_POINTER - CloudFileFlags: ULONG, - CloudFileDiagFlags: ULONG, - PlaceholderCompatibilityMode: CHAR, - PlaceholderCompatibilityModeReserved: [CHAR; 7], + WaitOnAddressHashTable: [c_ulong; 128], // WOW64_POINTER + TelemetryCoverageHeader: c_ulong, // WOW64_POINTER + CloudFileFlags: c_ulong, + CloudFileDiagFlags: c_ulong, + PlaceholderCompatibilityMode: c_char, + PlaceholderCompatibilityModeReserved: [c_char; 7], }} -BITFIELD!{PEB32 BitField: BOOLEAN [ +BITFIELD! {PEB32 BitField: c_uchar [ ImageUsesLargePages set_ImageUsesLargePages[0..1], IsProtectedProcess set_IsProtectedProcess[1..2], IsImageDynamicallyRelocated set_IsImageDynamicallyRelocated[2..3], @@ -312,7 +321,7 @@ BITFIELD!{PEB32 BitField: BOOLEAN [ IsProtectedProcessLight set_IsProtectedProcessLight[6..7], IsLongPathAwareProcess set_IsLongPathAwareProcess[7..8], ]} -BITFIELD!{PEB32 CrossProcessFlags: ULONG [ +BITFIELD! {PEB32 CrossProcessFlags: c_ulong [ ProcessInJob set_ProcessInJob[0..1], ProcessInitializing set_ProcessInitializing[1..2], ProcessUsingVEH set_ProcessUsingVEH[2..3], @@ -320,7 +329,7 @@ BITFIELD!{PEB32 CrossProcessFlags: ULONG [ ProcessUsingFTH set_ProcessUsingFTH[4..5], ReservedBits0 set_ReservedBits0[5..32], ]} -BITFIELD!{PEB32 TracingFlags: ULONG [ +BITFIELD! {PEB32 TracingFlags: c_ulong [ HeapTracingEnabled set_HeapTracingEnabled[0..1], CritSecTracingEnabled set_CritSecTracingEnabled[1..2], LibLoaderTracingEnabled set_LibLoaderTracingEnabled[2..3], @@ -328,117 +337,117 @@ BITFIELD!{PEB32 TracingFlags: ULONG [ ]} pub type PPEB32 = *mut PEB32; pub const GDI_BATCH_BUFFER_SIZE: usize = 310; -STRUCT!{struct GDI_TEB_BATCH32 { - Offset: ULONG, - HDC: ULONG, - Buffer: [ULONG; GDI_BATCH_BUFFER_SIZE], +STRUCT! {struct GDI_TEB_BATCH32 { + Offset: c_ulong, + HDC: c_ulong, + Buffer: [c_ulong; GDI_BATCH_BUFFER_SIZE], }} pub type PGDI_TEB_BATCH32 = *mut GDI_TEB_BATCH32; -STRUCT!{struct TEB32_u_s { - ReservedPad0: UCHAR, - ReservedPad1: UCHAR, - ReservedPad2: UCHAR, - IdealProcessor: UCHAR, +STRUCT! {struct TEB32_u_s { + ReservedPad0: c_uchar, + ReservedPad1: c_uchar, + ReservedPad2: c_uchar, + IdealProcessor: c_uchar, }} -UNION!{union TEB32_u { +UNION! {union TEB32_u { CurrentIdealProcessor: PROCESSOR_NUMBER, - IdealProcessorValue: ULONG, + IdealProcessorValue: c_ulong, s: TEB32_u_s, }} -STRUCT!{struct TEB32 { +STRUCT! {struct TEB32 { NtTib: NT_TIB32, - EnvironmentPointer: ULONG, // WOW64_POINTER + EnvironmentPointer: c_ulong, // WOW64_POINTER ClientId: CLIENT_ID32, - ActiveRpcHandle: ULONG, // WOW64_POINTER - ThreadLocalStoragePointer: ULONG, // WOW64_POINTER - ProcessEnvironmentBlock: ULONG, // WOW64_POINTER - LastErrorValue: ULONG, - CountOfOwnedCriticalSections: ULONG, - CsrClientThread: ULONG, // WOW64_POINTER - Win32ThreadInfo: ULONG, // WOW64_POINTER - User32Reserved: [ULONG; 26], - UserReserved: [ULONG; 5], - WOW32Reserved: ULONG, // WOW64_POINTER - CurrentLocale: LCID, - FpSoftwareStatusRegister: ULONG, - ReservedForDebuggerInstrumentation: [ULONG; 16], // WOW64_POINTER - SystemReserved1: [ULONG; 36], // WOW64_POINTER - WorkingOnBehalfTicket: [UCHAR; 8], + ActiveRpcHandle: c_ulong, // WOW64_POINTER + ThreadLocalStoragePointer: c_ulong, // WOW64_POINTER + ProcessEnvironmentBlock: c_ulong, // WOW64_POINTER + LastErrorValue: c_ulong, + CountOfOwnedCriticalSections: c_ulong, + CsrClientThread: c_ulong, // WOW64_POINTER + Win32ThreadInfo: c_ulong, // WOW64_POINTER + User32Reserved: [c_ulong; 26], + UserReserved: [c_ulong; 5], + WOW32Reserved: c_ulong, // WOW64_POINTER + CurrentLocale: c_ulong, + FpSoftwareStatusRegister: c_ulong, + ReservedForDebuggerInstrumentation: [c_ulong; 16], // WOW64_POINTER + SystemReserved1: [c_ulong; 36], // WOW64_POINTER + WorkingOnBehalfTicket: [c_uchar; 8], ExceptionCode: NTSTATUS, - ActivationContextStackPointer: ULONG, // WOW64_POINTER - InstrumentationCallbackSp: ULONG, - InstrumentationCallbackPreviousPc: ULONG, - InstrumentationCallbackPreviousSp: ULONG, - InstrumentationCallbackDisabled: BOOLEAN, - SpareBytes: [UCHAR; 23], - TxFsContext: ULONG, + ActivationContextStackPointer: c_ulong, // WOW64_POINTER + InstrumentationCallbackSp: c_ulong, + InstrumentationCallbackPreviousPc: c_ulong, + InstrumentationCallbackPreviousSp: c_ulong, + InstrumentationCallbackDisabled: c_uchar, + SpareBytes: [c_uchar; 23], + TxFsContext: c_ulong, GdiTebBatch: GDI_TEB_BATCH32, RealClientId: CLIENT_ID32, - GdiCachedProcessHandle: ULONG, // WOW64_POINTER - GdiClientPID: ULONG, - GdiClientTID: ULONG, - GdiThreadLocalInfo: ULONG, // WOW64_POINTER - Win32ClientInfo: [ULONG; 62], - glDispatchTable: [ULONG; 233], // WOW64_POINTER - glReserved1: [ULONG; 29], // WOW64_POINTER - glReserved2: ULONG, // WOW64_POINTER - glSectionInfo: ULONG, // WOW64_POINTER - glSection: ULONG, // WOW64_POINTER - glTable: ULONG, // WOW64_POINTER - glCurrentRC: ULONG, // WOW64_POINTER - glContext: ULONG, // WOW64_POINTER + GdiCachedProcessHandle: c_ulong, // WOW64_POINTER + GdiClientPID: c_ulong, + GdiClientTID: c_ulong, + GdiThreadLocalInfo: c_ulong, // WOW64_POINTER + Win32ClientInfo: [c_ulong; 62], + glDispatchTable: [c_ulong; 233], // WOW64_POINTER + glReserved1: [c_ulong; 29], // WOW64_POINTER + glReserved2: c_ulong, // WOW64_POINTER + glSectionInfo: c_ulong, // WOW64_POINTER + glSection: c_ulong, // WOW64_POINTER + glTable: c_ulong, // WOW64_POINTER + glCurrentRC: c_ulong, // WOW64_POINTER + glContext: c_ulong, // WOW64_POINTER LastStatusValue: NTSTATUS, - StaticUnicodeString: UNICODE_STRING32, - StaticUnicodeBuffer: [WCHAR; 261], - DeallocationStack: ULONG, // WOW64_POINTER - TlsSlots: [ULONG; 64], // WOW64_POINTER + StaticUnicodeString: STRING32, + StaticUnicodeBuffer: [wchar_t; 261], + DeallocationStack: c_ulong, // WOW64_POINTER + TlsSlots: [c_ulong; 64], // WOW64_POINTER TlsLinks: LIST_ENTRY32, - Vdm: ULONG, // WOW64_POINTER - ReservedForNtRpc: ULONG, // WOW64_POINTER - DbgSsReserved: [ULONG; 2], // WOW64_POINTER - HardErrorMode: ULONG, - Instrumentation: [ULONG; 9], // WOW64_POINTER + Vdm: c_ulong, // WOW64_POINTER + ReservedForNtRpc: c_ulong, // WOW64_POINTER + DbgSsReserved: [c_ulong; 2], // WOW64_POINTER + HardErrorMode: c_ulong, + Instrumentation: [c_ulong; 9], // WOW64_POINTER ActivityId: GUID, - SubProcessTag: ULONG, // WOW64_POINTER - PerflibData: ULONG, // WOW64_POINTER - EtwTraceData: ULONG, // WOW64_POINTER - WinSockData: ULONG, // WOW64_POINTER - GdiBatchCount: ULONG, + SubProcessTag: c_ulong, // WOW64_POINTER + PerflibData: c_ulong, // WOW64_POINTER + EtwTraceData: c_ulong, // WOW64_POINTER + WinSockData: c_ulong, // WOW64_POINTER + GdiBatchCount: c_ulong, u: TEB32_u, - GuaranteedStackBytes: ULONG, - ReservedForPerf: ULONG, // WOW64_POINTER - ReservedForOle: ULONG, // WOW64_POINTER - WaitingOnLoaderLock: ULONG, - SavedPriorityState: ULONG, // WOW64_POINTER - ReservedForCodeCoverage: ULONG, - ThreadPoolData: ULONG, // WOW64_POINTER - TlsExpansionSlots: ULONG, // WOW64_POINTER - MuiGeneration: ULONG, - IsImpersonating: ULONG, - NlsCache: ULONG, // WOW64_POINTER - pShimData: ULONG, // WOW64_POINTER - HeapVirtualAffinity: USHORT, - LowFragHeapDataSlot: USHORT, - CurrentTransactionHandle: ULONG, // WOW64_POINTER - ActiveFrame: ULONG, // WOW64_POINTER - FlsData: ULONG, // WOW64_POINTER - PreferredLanguages: ULONG, // WOW64_POINTER - UserPrefLanguages: ULONG, // WOW64_POINTER - MergedPrefLanguages: ULONG, // WOW64_POINTER - MuiImpersonation: ULONG, - CrossTebFlags: USHORT, - SameTebFlags: USHORT, - TxnScopeEnterCallback: ULONG, // WOW64_POINTER - TxnScopeExitCallback: ULONG, // WOW64_POINTER - TxnScopeContext: ULONG, // WOW64_POINTER - LockCount: ULONG, - WowTebOffset: LONG, - ResourceRetValue: ULONG, // WOW64_POINTER - ReservedForWdf: ULONG, // WOW64_POINTER - ReservedForCrt: ULONGLONG, + GuaranteedStackBytes: c_ulong, + ReservedForPerf: c_ulong, // WOW64_POINTER + ReservedForOle: c_ulong, // WOW64_POINTER + WaitingOnLoaderLock: c_ulong, + SavedPriorityState: c_ulong, // WOW64_POINTER + ReservedForCodeCoverage: c_ulong, + ThreadPoolData: c_ulong, // WOW64_POINTER + TlsExpansionSlots: c_ulong, // WOW64_POINTER + MuiGeneration: c_ulong, + IsImpersonating: c_ulong, + NlsCache: c_ulong, // WOW64_POINTER + pShimData: c_ulong, // WOW64_POINTER + HeapVirtualAffinity: c_ushort, + LowFragHeapDataSlot: c_ushort, + CurrentTransactionHandle: c_ulong, // WOW64_POINTER + ActiveFrame: c_ulong, // WOW64_POINTER + FlsData: c_ulong, // WOW64_POINTER + PreferredLanguages: c_ulong, // WOW64_POINTER + UserPrefLanguages: c_ulong, // WOW64_POINTER + MergedPrefLanguages: c_ulong, // WOW64_POINTER + MuiImpersonation: c_ulong, + CrossTebFlags: c_ushort, + SameTebFlags: c_ushort, + TxnScopeEnterCallback: c_ulong, // WOW64_POINTER + TxnScopeExitCallback: c_ulong, // WOW64_POINTER + TxnScopeContext: c_ulong, // WOW64_POINTER + LockCount: c_ulong, + WowTebOffset: c_long, + ResourceRetValue: c_ulong, // WOW64_POINTER + ReservedForWdf: c_ulong, // WOW64_POINTER + ReservedForCrt: __uint64, EffectiveContainerId: GUID, }} -BITFIELD!{TEB32 SameTebFlags: USHORT [ +BITFIELD! {TEB32 SameTebFlags: c_ushort [ SafeThunkCall set_SafeThunkCall[0..1], InDebugPrint set_InDebugPrint[1..2], HasFiberData set_HasFiberData[2..3], @@ -457,19 +466,13 @@ BITFIELD!{TEB32 SameTebFlags: USHORT [ ]} pub type PTEB32 = *mut TEB32; #[inline] -pub fn UStr32ToUStr( - Destination: &mut UNICODE_STRING, - Source: &UNICODE_STRING32, -) { +pub fn UStr32ToUStr(Destination: &mut UNICODE_STRING, Source: &STRING32) { Destination.Length = Source.Length; Destination.MaximumLength = Source.MaximumLength; Destination.Buffer = Source.Buffer as *mut u16; } #[inline] -pub fn UStrToUStr32( - Destination: &mut UNICODE_STRING32, - Source: &UNICODE_STRING, -) { +pub fn UStrToUStr32(Destination: &mut STRING32, Source: &UNICODE_STRING) { Destination.Length = Source.Length; Destination.MaximumLength = Source.MaximumLength; Destination.Buffer = Source.Buffer as u32; diff --git a/src/ntxcapi.rs b/src/ntxcapi.rs index 56644dd..d92baac 100644 --- a/src/ntxcapi.rs +++ b/src/ntxcapi.rs @@ -1,29 +1,34 @@ -use winapi::shared::ntdef::{BOOLEAN, NTSTATUS, PSTR, PVOID, ULONG}; -use winapi::um::winnt::{PCONTEXT, PEXCEPTION_RECORD}; -EXTERN!{extern "system" { +use windows_sys::Win32::{ + Foundation::NTSTATUS, + System::Diagnostics::Debug::{CONTEXT, EXCEPTION_RECORD}, +}; + +use crate::ctypes::{c_char, c_uchar, c_ulong, c_void}; + +EXTERN! {extern "system" { fn RtlDispatchException( - ExceptionRecord: PEXCEPTION_RECORD, - ContextRecord: PCONTEXT, - ) -> BOOLEAN; + ExceptionRecord: *mut EXCEPTION_RECORD, + ContextRecord: *mut CONTEXT, + ) -> c_uchar; fn RtlRaiseStatus( Status: NTSTATUS, ); fn RtlRaiseException( - ExceptionRecord: PEXCEPTION_RECORD, + ExceptionRecord: *mut EXCEPTION_RECORD, ); fn NtContinue( - ContextRecord: PCONTEXT, - TestAlert: BOOLEAN, + ContextRecord: *mut CONTEXT, + TestAlert: c_uchar, ) -> NTSTATUS; fn NtRaiseException( - ExceptionRecord: PEXCEPTION_RECORD, - ContextRecord: PCONTEXT, - FirstChance: BOOLEAN, + ExceptionRecord: *mut EXCEPTION_RECORD, + ContextRecord: *mut CONTEXT, + FirstChance: c_uchar, ) -> NTSTATUS; fn RtlAssert( - VoidFailedAssertion: PVOID, - VoidFileName: PVOID, - LineNumber: ULONG, - MutableMessage: PSTR, + VoidFailedAssertion: *mut c_void, + VoidFileName: *mut c_void, + LineNumber: c_ulong, + MutableMessage: *mut c_char, ); }} diff --git a/src/ntzwapi.rs b/src/ntzwapi.rs index 9638bf8..e5c4c23 100644 --- a/src/ntzwapi.rs +++ b/src/ntzwapi.rs @@ -1,239 +1,262 @@ -use crate::ntapi_base::{PCLIENT_ID, PRTL_ATOM, RTL_ATOM}; -use crate::ntdbg::DEBUGOBJECTINFOCLASS; -use crate::ntexapi::{ - ATOM_INFORMATION_CLASS, EVENT_INFORMATION_CLASS, MUTANT_INFORMATION_CLASS, PBOOT_ENTRY, - PBOOT_OPTIONS, PCWNF_TYPE_ID, PEFI_DRIVER_ENTRY, PFILE_PATH, PT2_CANCEL_PARAMETERS, - PT2_SET_PARAMETERS, PTIMER_APC_ROUTINE, PWNF_CHANGE_STAMP, PWNF_DELIVERY_DESCRIPTOR, - SEMAPHORE_INFORMATION_CLASS, SHUTDOWN_ACTION, SYSDBG_COMMAND, SYSTEM_INFORMATION_CLASS, - TIMER_INFORMATION_CLASS, TIMER_SET_INFORMATION_CLASS, WNF_CHANGE_STAMP, WNF_DATA_SCOPE, - WNF_STATE_NAME_INFORMATION, WNF_STATE_NAME_LIFETIME, WORKERFACTORYINFOCLASS, +use windows_sys::{ + core::GUID, + Win32::{ + Foundation::{HANDLE, LUID, NTSTATUS, PSID, UNICODE_STRING}, + Security::{ + AUDIT_EVENT_TYPE, GENERIC_MAPPING, OBJECT_TYPE_LIST, PRIVILEGE_SET, + PSECURITY_DESCRIPTOR, SECURITY_QUALITY_OF_SERVICE, + SID_AND_ATTRIBUTES, TOKEN_DEFAULT_DACL, TOKEN_GROUPS, + TOKEN_INFORMATION_CLASS, TOKEN_MANDATORY_POLICY, TOKEN_OWNER, + TOKEN_PRIMARY_GROUP, TOKEN_PRIVILEGES, TOKEN_SOURCE, TOKEN_TYPE, + TOKEN_USER, + }, + Storage::FileSystem::{FILE_SEGMENT_ELEMENT, TRANSACTION_NOTIFICATION}, + System::{ + Diagnostics::Debug::{CONTEXT, EXCEPTION_RECORD}, + JobObjects::{JOBOBJECTINFOCLASS, JOB_SET_ARRAY}, + Kernel::{EVENT_TYPE, TIMER_TYPE, WAIT_TYPE, WNF_STATE_NAME}, + Power::{ + DEVICE_POWER_STATE, EXECUTION_STATE, LATENCY_TIME, + POWER_ACTION, POWER_INFORMATION_LEVEL, SYSTEM_POWER_STATE, + }, + SystemInformation::GROUP_AFFINITY, + SystemServices::{ + ENLISTMENT_INFORMATION_CLASS, KTMOBJECT_CURSOR, KTMOBJECT_TYPE, + RESOURCEMANAGER_INFORMATION_CLASS, + TRANSACTIONMANAGER_INFORMATION_CLASS, + TRANSACTION_INFORMATION_CLASS, + }, + WindowsProgramming::OBJECT_ATTRIBUTES, + }, + }, }; -use crate::ntioapi::{ - FILE_INFORMATION_CLASS, FILE_IO_COMPLETION_INFORMATION, FS_INFORMATION_CLASS, - IO_COMPLETION_INFORMATION_CLASS, IO_SESSION_EVENT, IO_SESSION_STATE, PFILE_BASIC_INFORMATION, - PFILE_IO_COMPLETION_INFORMATION, PFILE_NETWORK_OPEN_INFORMATION, PIO_APC_ROUTINE, - PIO_STATUS_BLOCK, + +use crate::{ + ctypes::{ + __uint64, c_char, c_long, c_uchar, c_ulong, c_ushort, c_void, wchar_t, + }, + ntapi_base::{PCLIENT_ID, PRTL_ATOM, RTL_ATOM}, + ntdbg::DEBUGOBJECTINFOCLASS, + ntexapi::{ + ATOM_INFORMATION_CLASS, EVENT_INFORMATION_CLASS, + MUTANT_INFORMATION_CLASS, PBOOT_ENTRY, PBOOT_OPTIONS, PCWNF_TYPE_ID, + PEFI_DRIVER_ENTRY, PFILE_PATH, PT2_CANCEL_PARAMETERS, + PT2_SET_PARAMETERS, PTIMER_APC_ROUTINE, PWNF_CHANGE_STAMP, + PWNF_DELIVERY_DESCRIPTOR, SEMAPHORE_INFORMATION_CLASS, SHUTDOWN_ACTION, + SYSDBG_COMMAND, SYSTEM_INFORMATION_CLASS, TIMER_INFORMATION_CLASS, + TIMER_SET_INFORMATION_CLASS, WNF_CHANGE_STAMP, WNF_DATA_SCOPE, + WNF_STATE_NAME_INFORMATION, WNF_STATE_NAME_LIFETIME, + WORKERFACTORYINFOCLASS, + }, + ntioapi::{ + FILE_INFORMATION_CLASS, FILE_IO_COMPLETION_INFORMATION, + FS_INFORMATION_CLASS, IO_COMPLETION_INFORMATION_CLASS, + IO_SESSION_EVENT, IO_SESSION_STATE, PFILE_BASIC_INFORMATION, + PFILE_IO_COMPLETION_INFORMATION, PFILE_NETWORK_OPEN_INFORMATION, + PIO_APC_ROUTINE, PIO_STATUS_BLOCK, + }, + ntkeapi::KPROFILE_SOURCE, + ntlpcapi::{ + ALPC_HANDLE, ALPC_MESSAGE_INFORMATION_CLASS, + ALPC_PORT_INFORMATION_CLASS, PALPC_CONTEXT_ATTR, PALPC_DATA_VIEW_ATTR, + PALPC_HANDLE, PALPC_MESSAGE_ATTRIBUTES, PALPC_PORT_ATTRIBUTES, + PALPC_SECURITY_ATTR, PORT_INFORMATION_CLASS, PPORT_MESSAGE, PPORT_VIEW, + PREMOTE_PORT_VIEW, + }, + ntmisc::VDMSERVICECLASS, + ntmmapi::{ + MEMORY_INFORMATION_CLASS, MEMORY_PARTITION_INFORMATION_CLASS, + PMEMORY_RANGE_ENTRY, SECTION_INFORMATION_CLASS, SECTION_INHERIT, + VIRTUAL_MEMORY_INFORMATION_CLASS, + }, + ntobapi::OBJECT_INFORMATION_CLASS, + ntpnpapi::{PLUGPLAY_CONTROL_CLASS, PPLUGPLAY_EVENT_BLOCK}, + ntpsapi::{ + MEMORY_RESERVE_TYPE, PINITIAL_TEB, PPS_APC_ROUTINE, PPS_ATTRIBUTE_LIST, + PPS_CREATE_INFO, PROCESSINFOCLASS, THREADINFOCLASS, + }, + ntregapi::{ + KEY_INFORMATION_CLASS, KEY_SET_INFORMATION_CLASS, + KEY_VALUE_INFORMATION_CLASS, PKEY_VALUE_ENTRY, + }, + ntseapi::PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, + windows_local::shared::ntdef::{LARGE_INTEGER, ULARGE_INTEGER}, }; -use crate::ntkeapi::KPROFILE_SOURCE; -use crate::ntlpcapi::{ - ALPC_HANDLE, ALPC_MESSAGE_INFORMATION_CLASS, ALPC_PORT_INFORMATION_CLASS, PALPC_CONTEXT_ATTR, - PALPC_DATA_VIEW_ATTR, PALPC_HANDLE, PALPC_MESSAGE_ATTRIBUTES, PALPC_PORT_ATTRIBUTES, - PALPC_SECURITY_ATTR, PORT_INFORMATION_CLASS, PPORT_MESSAGE, PPORT_VIEW, PREMOTE_PORT_VIEW, -}; -use crate::ntmisc::VDMSERVICECLASS; -use crate::ntmmapi::{ - MEMORY_INFORMATION_CLASS, MEMORY_PARTITION_INFORMATION_CLASS, PMEMORY_RANGE_ENTRY, - SECTION_INFORMATION_CLASS, SECTION_INHERIT, VIRTUAL_MEMORY_INFORMATION_CLASS, -}; -use crate::ntobapi::OBJECT_INFORMATION_CLASS; -use crate::ntpnpapi::{PLUGPLAY_CONTROL_CLASS, PPLUGPLAY_EVENT_BLOCK}; -use crate::ntpsapi::{ - MEMORY_RESERVE_TYPE, PINITIAL_TEB, PPS_APC_ROUTINE, PPS_ATTRIBUTE_LIST, PPS_CREATE_INFO, - PROCESSINFOCLASS, THREADINFOCLASS, -}; -use crate::ntregapi::{ - KEY_INFORMATION_CLASS, KEY_SET_INFORMATION_CLASS, KEY_VALUE_INFORMATION_CLASS, - PKEY_VALUE_ENTRY, -}; -use crate::ntseapi::PTOKEN_SECURITY_ATTRIBUTES_INFORMATION; -use winapi::shared::basetsd::{ - KAFFINITY, PSIZE_T, PULONG64, PULONG_PTR, SIZE_T, ULONG64, ULONG_PTR, -}; -use winapi::shared::guiddef::LPGUID; -use winapi::shared::ktmtypes::{NOTIFICATION_MASK, PCRM_PROTOCOL_ID, PTRANSACTION_NOTIFICATION}; -use winapi::shared::ntdef::{ - BOOLEAN, EVENT_TYPE, HANDLE, LANGID, LCID, LOGICAL, LONG, NTSTATUS, OBJECT_ATTRIBUTES, - PBOOLEAN, PCHAR, PCWNF_STATE_NAME, PGROUP_AFFINITY, PHANDLE, PLARGE_INTEGER, PLCID, PLONG, - PLUID, PNTSTATUS, POBJECT_ATTRIBUTES, PUCHAR, PULARGE_INTEGER, PULONG, PULONGLONG, - PUNICODE_STRING, PUSHORT, PVOID, PWNF_STATE_NAME, PWSTR, TIMER_TYPE, ULONG, USHORT, VOID, - WAIT_TYPE, -}; -use winapi::um::winnt::{ - ACCESS_MASK, AUDIT_EVENT_TYPE, ENLISTMENT_INFORMATION_CLASS, EXECUTION_STATE, - JOBOBJECTINFOCLASS, KTMOBJECT_TYPE, LATENCY_TIME, PACCESS_MASK, PCONTEXT, PDEVICE_POWER_STATE, - PEXCEPTION_RECORD, PFILE_SEGMENT_ELEMENT, PGENERIC_MAPPING, PJOB_SET_ARRAY, PKTMOBJECT_CURSOR, - POBJECT_TYPE_LIST, POWER_ACTION, POWER_INFORMATION_LEVEL, PPRIVILEGE_SET, PSECURITY_DESCRIPTOR, - PSECURITY_QUALITY_OF_SERVICE, PSE_SIGNING_LEVEL, PSID, PSID_AND_ATTRIBUTES, - PTOKEN_DEFAULT_DACL, PTOKEN_GROUPS, PTOKEN_MANDATORY_POLICY, PTOKEN_OWNER, - PTOKEN_PRIMARY_GROUP, PTOKEN_PRIVILEGES, PTOKEN_SOURCE, PTOKEN_USER, - RESOURCEMANAGER_INFORMATION_CLASS, SECURITY_INFORMATION, SE_SIGNING_LEVEL, SYSTEM_POWER_STATE, - TOKEN_INFORMATION_CLASS, TOKEN_TYPE, TRANSACTIONMANAGER_INFORMATION_CLASS, - TRANSACTION_INFORMATION_CLASS, -}; -EXTERN!{extern "system" { + +EXTERN! {extern "system" { fn ZwAcceptConnectPort( - PortHandle: PHANDLE, - PortContext: PVOID, + PortHandle: *mut HANDLE, + PortContext: *mut c_void, ConnectionRequest: PPORT_MESSAGE, - AcceptConnection: BOOLEAN, + AcceptConnection: c_uchar, ServerView: PPORT_VIEW, ClientView: PREMOTE_PORT_VIEW, ) -> NTSTATUS; fn ZwAccessCheck( SecurityDescriptor: PSECURITY_DESCRIPTOR, ClientToken: HANDLE, - DesiredAccess: ACCESS_MASK, - GenericMapping: PGENERIC_MAPPING, - PrivilegeSet: PPRIVILEGE_SET, - PrivilegeSetLength: PULONG, - GrantedAccess: PACCESS_MASK, - AccessStatus: PNTSTATUS, + DesiredAccess: c_ulong, + GenericMapping: *mut GENERIC_MAPPING, + PrivilegeSet: *mut PRIVILEGE_SET, + PrivilegeSetLength: *mut c_ulong, + GrantedAccess: *mut c_ulong, + AccessStatus: *mut NTSTATUS, ) -> NTSTATUS; fn ZwAccessCheckAndAuditAlarm( - SubsystemName: PUNICODE_STRING, - HandleId: PVOID, - ObjectTypeName: PUNICODE_STRING, - ObjectName: PUNICODE_STRING, + SubsystemName: *mut UNICODE_STRING, + HandleId: *mut c_void, + ObjectTypeName: *mut UNICODE_STRING, + ObjectName: *mut UNICODE_STRING, SecurityDescriptor: PSECURITY_DESCRIPTOR, - DesiredAccess: ACCESS_MASK, - GenericMapping: PGENERIC_MAPPING, - ObjectCreation: BOOLEAN, - GrantedAccess: PACCESS_MASK, - AccessStatus: PNTSTATUS, - GenerateOnClose: PBOOLEAN, + DesiredAccess: c_ulong, + GenericMapping: *mut GENERIC_MAPPING, + ObjectCreation: c_uchar, + GrantedAccess: *mut c_ulong, + AccessStatus: *mut NTSTATUS, + GenerateOnClose: *mut c_uchar, ) -> NTSTATUS; fn ZwAccessCheckByType( SecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, ClientToken: HANDLE, - DesiredAccess: ACCESS_MASK, - ObjectTypeList: POBJECT_TYPE_LIST, - ObjectTypeListLength: ULONG, - GenericMapping: PGENERIC_MAPPING, - PrivilegeSet: PPRIVILEGE_SET, - PrivilegeSetLength: PULONG, - GrantedAccess: PACCESS_MASK, - AccessStatus: PNTSTATUS, + DesiredAccess: c_ulong, + ObjectTypeList: *mut OBJECT_TYPE_LIST, + ObjectTypeListLength: c_ulong, + GenericMapping: *mut GENERIC_MAPPING, + PrivilegeSet: *mut PRIVILEGE_SET, + PrivilegeSetLength: *mut c_ulong, + GrantedAccess: *mut c_ulong, + AccessStatus: *mut NTSTATUS, ) -> NTSTATUS; fn ZwAccessCheckByTypeAndAuditAlarm( - SubsystemName: PUNICODE_STRING, - HandleId: PVOID, - ObjectTypeName: PUNICODE_STRING, - ObjectName: PUNICODE_STRING, + SubsystemName: *mut UNICODE_STRING, + HandleId: *mut c_void, + ObjectTypeName: *mut UNICODE_STRING, + ObjectName: *mut UNICODE_STRING, SecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, - DesiredAccess: ACCESS_MASK, + DesiredAccess: c_ulong, AuditType: AUDIT_EVENT_TYPE, - Flags: ULONG, - ObjectTypeList: POBJECT_TYPE_LIST, - ObjectTypeListLength: ULONG, - GenericMapping: PGENERIC_MAPPING, - ObjectCreation: BOOLEAN, - GrantedAccess: PACCESS_MASK, - AccessStatus: PNTSTATUS, - GenerateOnClose: PBOOLEAN, + Flags: c_ulong, + ObjectTypeList: *mut OBJECT_TYPE_LIST, + ObjectTypeListLength: c_ulong, + GenericMapping: *mut GENERIC_MAPPING, + ObjectCreation: c_uchar, + GrantedAccess: *mut c_ulong, + AccessStatus: *mut NTSTATUS, + GenerateOnClose: *mut c_uchar, ) -> NTSTATUS; fn ZwAccessCheckByTypeResultList( SecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, ClientToken: HANDLE, - DesiredAccess: ACCESS_MASK, - ObjectTypeList: POBJECT_TYPE_LIST, - ObjectTypeListLength: ULONG, - GenericMapping: PGENERIC_MAPPING, - PrivilegeSet: PPRIVILEGE_SET, - PrivilegeSetLength: PULONG, - GrantedAccess: PACCESS_MASK, - AccessStatus: PNTSTATUS, + DesiredAccess: c_ulong, + ObjectTypeList: *mut OBJECT_TYPE_LIST, + ObjectTypeListLength: c_ulong, + GenericMapping: *mut GENERIC_MAPPING, + PrivilegeSet: *mut PRIVILEGE_SET, + PrivilegeSetLength: *mut c_ulong, + GrantedAccess: *mut c_ulong, + AccessStatus: *mut NTSTATUS, ) -> NTSTATUS; fn ZwAccessCheckByTypeResultListAndAuditAlarm( - SubsystemName: PUNICODE_STRING, - HandleId: PVOID, - ObjectTypeName: PUNICODE_STRING, - ObjectName: PUNICODE_STRING, + SubsystemName: *mut UNICODE_STRING, + HandleId: *mut c_void, + ObjectTypeName: *mut UNICODE_STRING, + ObjectName: *mut UNICODE_STRING, SecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, - DesiredAccess: ACCESS_MASK, + DesiredAccess: c_ulong, AuditType: AUDIT_EVENT_TYPE, - Flags: ULONG, - ObjectTypeList: POBJECT_TYPE_LIST, - ObjectTypeListLength: ULONG, - GenericMapping: PGENERIC_MAPPING, - ObjectCreation: BOOLEAN, - GrantedAccess: PACCESS_MASK, - AccessStatus: PNTSTATUS, - GenerateOnClose: PBOOLEAN, + Flags: c_ulong, + ObjectTypeList: *mut OBJECT_TYPE_LIST, + ObjectTypeListLength: c_ulong, + GenericMapping: *mut GENERIC_MAPPING, + ObjectCreation: c_uchar, + GrantedAccess: *mut c_ulong, + AccessStatus: *mut NTSTATUS, + GenerateOnClose: *mut c_uchar, ) -> NTSTATUS; fn ZwAccessCheckByTypeResultListAndAuditAlarmByHandle( - SubsystemName: PUNICODE_STRING, - HandleId: PVOID, + SubsystemName: *mut UNICODE_STRING, + HandleId: *mut c_void, ClientToken: HANDLE, - ObjectTypeName: PUNICODE_STRING, - ObjectName: PUNICODE_STRING, + ObjectTypeName: *mut UNICODE_STRING, + ObjectName: *mut UNICODE_STRING, SecurityDescriptor: PSECURITY_DESCRIPTOR, PrincipalSelfSid: PSID, - DesiredAccess: ACCESS_MASK, + DesiredAccess: c_ulong, AuditType: AUDIT_EVENT_TYPE, - Flags: ULONG, - ObjectTypeList: POBJECT_TYPE_LIST, - ObjectTypeListLength: ULONG, - GenericMapping: PGENERIC_MAPPING, - ObjectCreation: BOOLEAN, - GrantedAccess: PACCESS_MASK, - AccessStatus: PNTSTATUS, - GenerateOnClose: PBOOLEAN, + Flags: c_ulong, + ObjectTypeList: *mut OBJECT_TYPE_LIST, + ObjectTypeListLength: c_ulong, + GenericMapping: *mut GENERIC_MAPPING, + ObjectCreation: c_uchar, + GrantedAccess: *mut c_ulong, + AccessStatus: *mut NTSTATUS, + GenerateOnClose: *mut c_uchar, ) -> NTSTATUS; fn ZwAcquireCMFViewOwnership( - TimeStamp: PULONGLONG, - tokenTaken: PBOOLEAN, - replaceExisting: BOOLEAN, + TimeStamp: *mut __uint64, + tokenTaken: *mut c_uchar, + replaceExisting: c_uchar, ) -> NTSTATUS; fn ZwAddAtom( - AtomName: PWSTR, - Length: ULONG, + AtomName: *mut wchar_t, + Length: c_ulong, Atom: PRTL_ATOM, ) -> NTSTATUS; fn ZwAddAtomEx( - AtomName: PWSTR, - Length: ULONG, + AtomName: *mut wchar_t, + Length: c_ulong, Atom: PRTL_ATOM, - Flags: ULONG, + Flags: c_ulong, ) -> NTSTATUS; fn ZwAddBootEntry( BootEntry: PBOOT_ENTRY, - Id: PULONG, + Id: *mut c_ulong, ) -> NTSTATUS; fn ZwAddDriverEntry( DriverEntry: PEFI_DRIVER_ENTRY, - Id: PULONG, + Id: *mut c_ulong, ) -> NTSTATUS; fn ZwAdjustGroupsToken( TokenHandle: HANDLE, - ResetToDefault: BOOLEAN, - NewState: PTOKEN_GROUPS, - BufferLength: ULONG, - PreviousState: PTOKEN_GROUPS, - ReturnLength: PULONG, + ResetToDefault: c_uchar, + NewState: *mut TOKEN_GROUPS, + BufferLength: c_ulong, + PreviousState: *mut TOKEN_GROUPS, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn ZwAdjustPrivilegesToken( TokenHandle: HANDLE, - DisableAllPrivileges: BOOLEAN, - NewState: PTOKEN_PRIVILEGES, - BufferLength: ULONG, - PreviousState: PTOKEN_PRIVILEGES, - ReturnLength: PULONG, + DisableAllPrivileges: c_uchar, + NewState: *mut TOKEN_PRIVILEGES, + BufferLength: c_ulong, + PreviousState: *mut TOKEN_PRIVILEGES, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn ZwAdjustTokenClaimsAndDeviceGroups( TokenHandle: HANDLE, - UserResetToDefault: BOOLEAN, - DeviceResetToDefault: BOOLEAN, - DeviceGroupsResetToDefault: BOOLEAN, + UserResetToDefault: c_uchar, + DeviceResetToDefault: c_uchar, + DeviceGroupsResetToDefault: c_uchar, NewUserState: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, NewDeviceState: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, - NewDeviceGroupsState: PTOKEN_GROUPS, - UserBufferLength: ULONG, + NewDeviceGroupsState: *mut TOKEN_GROUPS, + UserBufferLength: c_ulong, PreviousUserState: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, - DeviceBufferLength: ULONG, + DeviceBufferLength: c_ulong, PreviousDeviceState: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, - DeviceGroupsBufferLength: ULONG, - PreviousDeviceGroups: PTOKEN_GROUPS, - UserReturnLength: PULONG, - DeviceReturnLength: PULONG, - DeviceGroupsReturnBufferLength: PULONG, + DeviceGroupsBufferLength: c_ulong, + PreviousDeviceGroups: *mut TOKEN_GROUPS, + UserReturnLength: *mut c_ulong, + DeviceReturnLength: *mut c_ulong, + DeviceGroupsReturnBufferLength: *mut c_ulong, ) -> NTSTATUS; fn ZwAlertResumeThread( ThreadHandle: HANDLE, - PreviousSuspendCount: PULONG, + PreviousSuspendCount: *mut c_ulong, ) -> NTSTATUS; fn ZwAlertThread( ThreadHandle: HANDLE, @@ -242,192 +265,192 @@ EXTERN!{extern "system" { ThreadId: HANDLE, ) -> NTSTATUS; fn ZwAllocateLocallyUniqueId( - Luid: PLUID, + Luid: *mut LUID, ) -> NTSTATUS; fn ZwAllocateReserveObject( - MemoryReserveHandle: PHANDLE, - ObjectAttributes: POBJECT_ATTRIBUTES, + MemoryReserveHandle: *mut HANDLE, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, Type: MEMORY_RESERVE_TYPE, ) -> NTSTATUS; fn ZwAllocateUserPhysicalPages( ProcessHandle: HANDLE, - NumberOfPages: PULONG_PTR, - UserPfnArray: PULONG_PTR, + NumberOfPages: *mut usize, + UserPfnArray: *mut usize, ) -> NTSTATUS; fn ZwAllocateUuids( - Time: PULARGE_INTEGER, - Range: PULONG, - Sequence: PULONG, - Seed: PCHAR, + Time: *mut ULARGE_INTEGER, + Range: *mut c_ulong, + Sequence: *mut c_ulong, + Seed: *mut c_char, ) -> NTSTATUS; fn ZwAllocateVirtualMemory( ProcessHandle: HANDLE, - BaseAddress: *mut PVOID, - ZeroBits: ULONG_PTR, - RegionSize: PSIZE_T, - AllocationType: ULONG, - Protect: ULONG, + BaseAddress: *mut *mut c_void, + ZeroBits: usize, + RegionSize: *mut usize, + AllocationType: c_ulong, + Protect: c_ulong, ) -> NTSTATUS; fn ZwAlpcAcceptConnectPort( - PortHandle: PHANDLE, + PortHandle: *mut HANDLE, ConnectionPortHandle: HANDLE, - Flags: ULONG, - ObjectAttributes: POBJECT_ATTRIBUTES, + Flags: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, PortAttributes: PALPC_PORT_ATTRIBUTES, - PortContext: PVOID, + PortContext: *mut c_void, ConnectionRequest: PPORT_MESSAGE, ConnectionMessageAttributes: PALPC_MESSAGE_ATTRIBUTES, - AcceptConnection: BOOLEAN, + AcceptConnection: c_uchar, ) -> NTSTATUS; fn ZwAlpcCancelMessage( PortHandle: HANDLE, - Flags: ULONG, + Flags: c_ulong, MessageContext: PALPC_CONTEXT_ATTR, ) -> NTSTATUS; fn ZwAlpcConnectPort( - PortHandle: PHANDLE, - PortName: PUNICODE_STRING, - ObjectAttributes: POBJECT_ATTRIBUTES, + PortHandle: *mut HANDLE, + PortName: *mut UNICODE_STRING, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, PortAttributes: PALPC_PORT_ATTRIBUTES, - Flags: ULONG, + Flags: c_ulong, RequiredServerSid: PSID, ConnectionMessage: PPORT_MESSAGE, - BufferLength: PULONG, + BufferLength: *mut c_ulong, OutMessageAttributes: PALPC_MESSAGE_ATTRIBUTES, InMessageAttributes: PALPC_MESSAGE_ATTRIBUTES, - Timeout: PLARGE_INTEGER, + Timeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwAlpcConnectPortEx( - PortHandle: PHANDLE, - ConnectionPortObjectAttributes: POBJECT_ATTRIBUTES, - ClientPortObjectAttributes: POBJECT_ATTRIBUTES, + PortHandle: *mut HANDLE, + ConnectionPortObjectAttributes: *mut OBJECT_ATTRIBUTES, + ClientPortObjectAttributes: *mut OBJECT_ATTRIBUTES, PortAttributes: PALPC_PORT_ATTRIBUTES, - Flags: ULONG, + Flags: c_ulong, ServerSecurityRequirements: PSECURITY_DESCRIPTOR, ConnectionMessage: PPORT_MESSAGE, - BufferLength: PSIZE_T, + BufferLength: *mut usize, OutMessageAttributes: PALPC_MESSAGE_ATTRIBUTES, InMessageAttributes: PALPC_MESSAGE_ATTRIBUTES, - Timeout: PLARGE_INTEGER, + Timeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwAlpcCreatePort( - PortHandle: PHANDLE, - ObjectAttributes: POBJECT_ATTRIBUTES, + PortHandle: *mut HANDLE, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, PortAttributes: PALPC_PORT_ATTRIBUTES, ) -> NTSTATUS; fn ZwAlpcCreatePortSection( PortHandle: HANDLE, - Flags: ULONG, + Flags: c_ulong, SectionHandle: HANDLE, - SectionSize: SIZE_T, + SectionSize: usize, AlpcSectionHandle: PALPC_HANDLE, - ActualSectionSize: PSIZE_T, + ActualSectionSize: *mut usize, ) -> NTSTATUS; fn ZwAlpcCreateResourceReserve( PortHandle: HANDLE, - Flags: ULONG, - MessageSize: SIZE_T, + Flags: c_ulong, + MessageSize: usize, ResourceId: PALPC_HANDLE, ) -> NTSTATUS; fn ZwAlpcCreateSectionView( PortHandle: HANDLE, - Flags: ULONG, + Flags: c_ulong, ViewAttributes: PALPC_DATA_VIEW_ATTR, ) -> NTSTATUS; fn ZwAlpcCreateSecurityContext( PortHandle: HANDLE, - Flags: ULONG, + Flags: c_ulong, SecurityAttribute: PALPC_SECURITY_ATTR, ) -> NTSTATUS; fn ZwAlpcDeletePortSection( PortHandle: HANDLE, - Flags: ULONG, + Flags: c_ulong, SectionHandle: ALPC_HANDLE, ) -> NTSTATUS; fn ZwAlpcDeleteResourceReserve( PortHandle: HANDLE, - Flags: ULONG, + Flags: c_ulong, ResourceId: ALPC_HANDLE, ) -> NTSTATUS; fn ZwAlpcDeleteSectionView( PortHandle: HANDLE, - Flags: ULONG, - ViewBase: PVOID, + Flags: c_ulong, + ViewBase: *mut c_void, ) -> NTSTATUS; fn ZwAlpcDeleteSecurityContext( PortHandle: HANDLE, - Flags: ULONG, + Flags: c_ulong, ContextHandle: ALPC_HANDLE, ) -> NTSTATUS; fn ZwAlpcDisconnectPort( PortHandle: HANDLE, - Flags: ULONG, + Flags: c_ulong, ) -> NTSTATUS; fn ZwAlpcImpersonateClientContainerOfPort( PortHandle: HANDLE, Message: PPORT_MESSAGE, - Flags: ULONG, + Flags: c_ulong, ) -> NTSTATUS; fn ZwAlpcImpersonateClientOfPort( PortHandle: HANDLE, Message: PPORT_MESSAGE, - Flags: PVOID, + Flags: *mut c_void, ) -> NTSTATUS; fn ZwAlpcOpenSenderProcess( - ProcessHandle: PHANDLE, + ProcessHandle: *mut HANDLE, PortHandle: HANDLE, PortMessage: PPORT_MESSAGE, - Flags: ULONG, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + Flags: c_ulong, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn ZwAlpcOpenSenderThread( - ThreadHandle: PHANDLE, + ThreadHandle: *mut HANDLE, PortHandle: HANDLE, PortMessage: PPORT_MESSAGE, - Flags: ULONG, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + Flags: c_ulong, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn ZwAlpcQueryInformation( PortHandle: HANDLE, PortInformationClass: ALPC_PORT_INFORMATION_CLASS, - PortInformation: PVOID, - Length: ULONG, - ReturnLength: PULONG, + PortInformation: *mut c_void, + Length: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn ZwAlpcQueryInformationMessage( PortHandle: HANDLE, PortMessage: PPORT_MESSAGE, MessageInformationClass: ALPC_MESSAGE_INFORMATION_CLASS, - MessageInformation: PVOID, - Length: ULONG, - ReturnLength: PULONG, + MessageInformation: *mut c_void, + Length: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn ZwAlpcRevokeSecurityContext( PortHandle: HANDLE, - Flags: ULONG, + Flags: c_ulong, ContextHandle: ALPC_HANDLE, ) -> NTSTATUS; fn ZwAlpcSendWaitReceivePort( PortHandle: HANDLE, - Flags: ULONG, + Flags: c_ulong, SendMessageA: PPORT_MESSAGE, SendMessageAttributes: PALPC_MESSAGE_ATTRIBUTES, ReceiveMessage: PPORT_MESSAGE, - BufferLength: PSIZE_T, + BufferLength: *mut usize, ReceiveMessageAttributes: PALPC_MESSAGE_ATTRIBUTES, - Timeout: PLARGE_INTEGER, + Timeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwAlpcSetInformation( PortHandle: HANDLE, PortInformationClass: ALPC_PORT_INFORMATION_CLASS, - PortInformation: PVOID, - Length: ULONG, + PortInformation: *mut c_void, + Length: c_ulong, ) -> NTSTATUS; fn ZwAreMappedFilesTheSame( - File1MappedAsAnImage: PVOID, - File2MappedAsFile: PVOID, + File1MappedAsAnImage: *mut c_void, + File2MappedAsFile: *mut c_void, ) -> NTSTATUS; fn ZwAssignProcessToJobObject( JobHandle: HANDLE, @@ -437,15 +460,15 @@ EXTERN!{extern "system" { WaitCompletionPacketHandle: HANDLE, IoCompletionHandle: HANDLE, TargetObjectHandle: HANDLE, - KeyContext: PVOID, - ApcContext: PVOID, + KeyContext: *mut c_void, + ApcContext: *mut c_void, IoStatus: NTSTATUS, - IoStatusInformation: ULONG_PTR, - AlreadySignaled: PBOOLEAN, + IoStatusInformation: usize, + AlreadySignaled: *mut c_uchar, ) -> NTSTATUS; fn ZwCallbackReturn( - OutputBuffer: PVOID, - OutputLength: ULONG, + OutputBuffer: *mut c_void, + OutputLength: c_ulong, Status: NTSTATUS, ) -> NTSTATUS; fn ZwCancelIoFile( @@ -464,7 +487,7 @@ EXTERN!{extern "system" { ) -> NTSTATUS; fn ZwCancelTimer( TimerHandle: HANDLE, - CurrentState: PBOOLEAN, + CurrentState: *mut c_uchar, ) -> NTSTATUS; fn ZwCancelTimer2( TimerHandle: HANDLE, @@ -472,7 +495,7 @@ EXTERN!{extern "system" { ) -> NTSTATUS; fn ZwCancelWaitCompletionPacket( WaitCompletionPacketHandle: HANDLE, - RemoveSignaledPacket: BOOLEAN, + RemoveSignaledPacket: c_uchar, ) -> NTSTATUS; fn ZwClearEvent( EventHandle: HANDLE, @@ -481,24 +504,24 @@ EXTERN!{extern "system" { Handle: HANDLE, ) -> NTSTATUS; fn ZwCloseObjectAuditAlarm( - SubsystemName: PUNICODE_STRING, - HandleId: PVOID, - GenerateOnClose: BOOLEAN, + SubsystemName: *mut UNICODE_STRING, + HandleId: *mut c_void, + GenerateOnClose: c_uchar, ) -> NTSTATUS; fn ZwCommitComplete( EnlistmentHandle: HANDLE, - TmVirtualClock: PLARGE_INTEGER, + TmVirtualClock: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwCommitEnlistment( EnlistmentHandle: HANDLE, - TmVirtualClock: PLARGE_INTEGER, + TmVirtualClock: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwCommitTransaction( TransactionHandle: HANDLE, - Wait: BOOLEAN, + Wait: c_uchar, ) -> NTSTATUS; fn ZwCompactKeys( - Count: ULONG, + Count: c_ulong, KeyArray: *mut HANDLE, ) -> NTSTATUS; fn ZwCompareObjects( @@ -508,7 +531,7 @@ EXTERN!{extern "system" { fn ZwCompareTokens( FirstTokenHandle: HANDLE, SecondTokenHandle: HANDLE, - Equal: PBOOLEAN, + Equal: *mut c_uchar, ) -> NTSTATUS; fn ZwCompleteConnectPort( PortHandle: HANDLE, @@ -517,395 +540,395 @@ EXTERN!{extern "system" { Key: HANDLE, ) -> NTSTATUS; fn ZwConnectPort( - PortHandle: PHANDLE, - PortName: PUNICODE_STRING, - SecurityQos: PSECURITY_QUALITY_OF_SERVICE, + PortHandle: *mut HANDLE, + PortName: *mut UNICODE_STRING, + SecurityQos: *mut SECURITY_QUALITY_OF_SERVICE, ClientView: PPORT_VIEW, ServerView: PREMOTE_PORT_VIEW, - MaxMessageLength: PULONG, - ConnectionInformation: PVOID, - ConnectionInformationLength: PULONG, + MaxMessageLength: *mut c_ulong, + ConnectionInformation: *mut c_void, + ConnectionInformationLength: *mut c_ulong, ) -> NTSTATUS; fn ZwContinue( - ContextRecord: PCONTEXT, - TestAlert: BOOLEAN, + ContextRecord: *mut CONTEXT, + TestAlert: c_uchar, ) -> NTSTATUS; fn ZwCreateDebugObject( - DebugObjectHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - Flags: ULONG, + DebugObjectHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + Flags: c_ulong, ) -> NTSTATUS; fn ZwCreateDirectoryObject( - DirectoryHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + DirectoryHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn ZwCreateDirectoryObjectEx( - DirectoryHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + DirectoryHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ShadowDirectoryHandle: HANDLE, - Flags: ULONG, + Flags: c_ulong, ) -> NTSTATUS; fn ZwCreateEnlistment( - EnlistmentHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, + EnlistmentHandle: *mut HANDLE, + DesiredAccess: c_ulong, ResourceManagerHandle: HANDLE, TransactionHandle: HANDLE, - ObjectAttributes: POBJECT_ATTRIBUTES, - CreateOptions: ULONG, - NotificationMask: NOTIFICATION_MASK, - EnlistmentKey: PVOID, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + CreateOptions: c_ulong, + NotificationMask: c_ulong, + EnlistmentKey: *mut c_void, ) -> NTSTATUS; fn ZwCreateEvent( - EventHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + EventHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, EventType: EVENT_TYPE, - InitialState: BOOLEAN, + InitialState: c_uchar, ) -> NTSTATUS; fn ZwCreateEventPair( - EventPairHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + EventPairHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn ZwCreateFile( - FileHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + FileHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, IoStatusBlock: PIO_STATUS_BLOCK, - AllocationSize: PLARGE_INTEGER, - FileAttributes: ULONG, - ShareAccess: ULONG, - CreateDisposition: ULONG, - CreateOptions: ULONG, - EaBuffer: PVOID, - EaLength: ULONG, + AllocationSize: *mut LARGE_INTEGER, + FileAttributes: c_ulong, + ShareAccess: c_ulong, + CreateDisposition: c_ulong, + CreateOptions: c_ulong, + EaBuffer: *mut c_void, + EaLength: c_ulong, ) -> NTSTATUS; fn ZwCreateIRTimer( - TimerHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, + TimerHandle: *mut HANDLE, + DesiredAccess: c_ulong, ) -> NTSTATUS; fn ZwCreateIoCompletion( - IoCompletionHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - Count: ULONG, + IoCompletionHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + Count: c_ulong, ) -> NTSTATUS; fn ZwCreateJobObject( - JobHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + JobHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn ZwCreateJobSet( - NumJob: ULONG, - UserJobSet: PJOB_SET_ARRAY, - Flags: ULONG, + NumJob: c_ulong, + UserJobSet: *mut JOB_SET_ARRAY, + Flags: c_ulong, ) -> NTSTATUS; fn ZwCreateKey( - KeyHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - TitleIndex: ULONG, - Class: PUNICODE_STRING, - CreateOptions: ULONG, - Disposition: PULONG, + KeyHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + TitleIndex: c_ulong, + Class: *mut UNICODE_STRING, + CreateOptions: c_ulong, + Disposition: *mut c_ulong, ) -> NTSTATUS; fn ZwCreateKeyTransacted( - KeyHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - TitleIndex: ULONG, - Class: PUNICODE_STRING, - CreateOptions: ULONG, + KeyHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + TitleIndex: c_ulong, + Class: *mut UNICODE_STRING, + CreateOptions: c_ulong, TransactionHandle: HANDLE, - Disposition: PULONG, + Disposition: *mut c_ulong, ) -> NTSTATUS; fn ZwCreateKeyedEvent( - KeyedEventHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - Flags: ULONG, + KeyedEventHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + Flags: c_ulong, ) -> NTSTATUS; fn ZwCreateLowBoxToken( - TokenHandle: PHANDLE, + TokenHandle: *mut HANDLE, ExistingTokenHandle: HANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, PackageSid: PSID, - CapabilityCount: ULONG, - Capabilities: PSID_AND_ATTRIBUTES, - HandleCount: ULONG, + CapabilityCount: c_ulong, + Capabilities: *mut SID_AND_ATTRIBUTES, + HandleCount: c_ulong, Handles: *mut HANDLE, ) -> NTSTATUS; fn ZwCreateMailslotFile( - FileHandle: PHANDLE, - DesiredAccess: ULONG, - ObjectAttributes: POBJECT_ATTRIBUTES, + FileHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, IoStatusBlock: PIO_STATUS_BLOCK, - CreateOptions: ULONG, - MailslotQuota: ULONG, - MaximumMessageSize: ULONG, - ReadTimeout: PLARGE_INTEGER, + CreateOptions: c_ulong, + MailslotQuota: c_ulong, + MaximumMessageSize: c_ulong, + ReadTimeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwCreateMutant( - MutantHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - InitialOwner: BOOLEAN, + MutantHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + InitialOwner: c_uchar, ) -> NTSTATUS; fn ZwCreateNamedPipeFile( - FileHandle: PHANDLE, - DesiredAccess: ULONG, - ObjectAttributes: POBJECT_ATTRIBUTES, + FileHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, IoStatusBlock: PIO_STATUS_BLOCK, - ShareAccess: ULONG, - CreateDisposition: ULONG, - CreateOptions: ULONG, - NamedPipeType: ULONG, - ReadMode: ULONG, - CompletionMode: ULONG, - MaximumInstances: ULONG, - InboundQuota: ULONG, - OutboundQuota: ULONG, - DefaultTimeout: PLARGE_INTEGER, + ShareAccess: c_ulong, + CreateDisposition: c_ulong, + CreateOptions: c_ulong, + NamedPipeType: c_ulong, + ReadMode: c_ulong, + CompletionMode: c_ulong, + MaximumInstances: c_ulong, + InboundQuota: c_ulong, + OutboundQuota: c_ulong, + DefaultTimeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwCreatePagingFile( - PageFileName: PUNICODE_STRING, - MinimumSize: PLARGE_INTEGER, - MaximumSize: PLARGE_INTEGER, - Priority: ULONG, + PageFileName: *mut UNICODE_STRING, + MinimumSize: *mut LARGE_INTEGER, + MaximumSize: *mut LARGE_INTEGER, + Priority: c_ulong, ) -> NTSTATUS; fn ZwCreatePartition( - PartitionHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - PreferredNode: ULONG, + PartitionHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + PreferredNode: c_ulong, ) -> NTSTATUS; fn ZwCreatePort( - PortHandle: PHANDLE, - ObjectAttributes: POBJECT_ATTRIBUTES, - MaxConnectionInfoLength: ULONG, - MaxMessageLength: ULONG, - MaxPoolUsage: ULONG, + PortHandle: *mut HANDLE, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + MaxConnectionInfoLength: c_ulong, + MaxMessageLength: c_ulong, + MaxPoolUsage: c_ulong, ) -> NTSTATUS; fn ZwCreatePrivateNamespace( - NamespaceHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - BoundaryDescriptor: PVOID, + NamespaceHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + BoundaryDescriptor: *mut c_void, ) -> NTSTATUS; fn ZwCreateProcess( - ProcessHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + ProcessHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ParentProcess: HANDLE, - InheritObjectTable: BOOLEAN, + InheritObjectTable: c_uchar, SectionHandle: HANDLE, DebugPort: HANDLE, ExceptionPort: HANDLE, ) -> NTSTATUS; fn ZwCreateProcessEx( - ProcessHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + ProcessHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ParentProcess: HANDLE, - Flags: ULONG, + Flags: c_ulong, SectionHandle: HANDLE, DebugPort: HANDLE, ExceptionPort: HANDLE, - JobMemberLevel: ULONG, + JobMemberLevel: c_ulong, ) -> NTSTATUS; fn ZwCreateProfile( - ProfileHandle: PHANDLE, + ProfileHandle: *mut HANDLE, Process: HANDLE, - ProfileBase: PVOID, - ProfileSize: SIZE_T, - BucketSize: ULONG, - Buffer: PULONG, - BufferSize: ULONG, + ProfileBase: *mut c_void, + ProfileSize: usize, + BucketSize: c_ulong, + Buffer: *mut c_ulong, + BufferSize: c_ulong, ProfileSource: KPROFILE_SOURCE, - Affinity: KAFFINITY, + Affinity: usize, ) -> NTSTATUS; fn ZwCreateProfileEx( - ProfileHandle: PHANDLE, + ProfileHandle: *mut HANDLE, Process: HANDLE, - ProfileBase: PVOID, - ProfileSize: SIZE_T, - BucketSize: ULONG, - Buffer: PULONG, - BufferSize: ULONG, + ProfileBase: *mut c_void, + ProfileSize: usize, + BucketSize: c_ulong, + Buffer: *mut c_ulong, + BufferSize: c_ulong, ProfileSource: KPROFILE_SOURCE, - GroupCount: USHORT, - GroupAffinity: PGROUP_AFFINITY, + GroupCount: c_ushort, + GroupAffinity: *mut GROUP_AFFINITY, ) -> NTSTATUS; fn ZwCreateResourceManager( - ResourceManagerHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, + ResourceManagerHandle: *mut HANDLE, + DesiredAccess: c_ulong, TmHandle: HANDLE, - ResourceManagerGuid: LPGUID, - ObjectAttributes: POBJECT_ATTRIBUTES, - CreateOptions: ULONG, - Description: PUNICODE_STRING, + ResourceManagerGuid: *mut GUID, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + CreateOptions: c_ulong, + Description: *mut UNICODE_STRING, ) -> NTSTATUS; fn ZwCreateSection( - SectionHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - MaximumSize: PLARGE_INTEGER, - SectionPageProtection: ULONG, - AllocationAttributes: ULONG, + SectionHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + MaximumSize: *mut LARGE_INTEGER, + SectionPageProtection: c_ulong, + AllocationAttributes: c_ulong, FileHandle: HANDLE, ) -> NTSTATUS; fn ZwCreateSemaphore( - SemaphoreHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - InitialCount: LONG, - MaximumCount: LONG, + SemaphoreHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + InitialCount: c_long, + MaximumCount: c_long, ) -> NTSTATUS; fn ZwCreateSymbolicLinkObject( - LinkHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - LinkTarget: PUNICODE_STRING, + LinkHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + LinkTarget: *mut UNICODE_STRING, ) -> NTSTATUS; fn ZwCreateThread( - ThreadHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + ThreadHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ProcessHandle: HANDLE, ClientId: PCLIENT_ID, - ThreadContext: PCONTEXT, + ThreadContext: *mut CONTEXT, InitialTeb: PINITIAL_TEB, - CreateSuspended: BOOLEAN, + CreateSuspended: c_uchar, ) -> NTSTATUS; fn ZwCreateThreadEx( - ThreadHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + ThreadHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ProcessHandle: HANDLE, - StartRoutine: PVOID, - Argument: PVOID, - CreateFlags: ULONG, - ZeroBits: SIZE_T, - StackSize: SIZE_T, - MaximumStackSize: SIZE_T, + StartRoutine: *mut c_void, + Argument: *mut c_void, + CreateFlags: c_ulong, + ZeroBits: usize, + StackSize: usize, + MaximumStackSize: usize, AttributeList: PPS_ATTRIBUTE_LIST, ) -> NTSTATUS; fn ZwCreateTimer( - TimerHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + TimerHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, TimerType: TIMER_TYPE, ) -> NTSTATUS; fn ZwCreateTimer2( - TimerHandle: PHANDLE, - Reserved1: PVOID, - Reserved2: PVOID, - Attributes: ULONG, - DesiredAccess: ACCESS_MASK, + TimerHandle: *mut HANDLE, + Reserved1: *mut c_void, + Reserved2: *mut c_void, + Attributes: c_ulong, + DesiredAccess: c_ulong, ) -> NTSTATUS; fn ZwCreateToken( - TokenHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + TokenHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, TokenType: TOKEN_TYPE, - AuthenticationId: PLUID, - ExpirationTime: PLARGE_INTEGER, - User: PTOKEN_USER, - Groups: PTOKEN_GROUPS, - Privileges: PTOKEN_PRIVILEGES, - Owner: PTOKEN_OWNER, - PrimaryGroup: PTOKEN_PRIMARY_GROUP, - DefaultDacl: PTOKEN_DEFAULT_DACL, - TokenSource: PTOKEN_SOURCE, + AuthenticationId: *mut LUID, + ExpirationTime: *mut LARGE_INTEGER, + User: *mut TOKEN_USER, + Groups: *mut TOKEN_GROUPS, + Privileges: *mut TOKEN_PRIVILEGES, + Owner: *mut TOKEN_OWNER, + PrimaryGroup: *mut TOKEN_PRIMARY_GROUP, + DefaultDacl: *mut TOKEN_DEFAULT_DACL, + TokenSource: *mut TOKEN_SOURCE, ) -> NTSTATUS; fn ZwCreateTokenEx( - TokenHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + TokenHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, TokenType: TOKEN_TYPE, - AuthenticationId: PLUID, - ExpirationTime: PLARGE_INTEGER, - User: PTOKEN_USER, - Groups: PTOKEN_GROUPS, - Privileges: PTOKEN_PRIVILEGES, + AuthenticationId: *mut LUID, + ExpirationTime: *mut LARGE_INTEGER, + User: *mut TOKEN_USER, + Groups: *mut TOKEN_GROUPS, + Privileges: *mut TOKEN_PRIVILEGES, UserAttributes: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, DeviceAttributes: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, - DeviceGroups: PTOKEN_GROUPS, - TokenMandatoryPolicy: PTOKEN_MANDATORY_POLICY, - Owner: PTOKEN_OWNER, - PrimaryGroup: PTOKEN_PRIMARY_GROUP, - DefaultDacl: PTOKEN_DEFAULT_DACL, - TokenSource: PTOKEN_SOURCE, + DeviceGroups: *mut TOKEN_GROUPS, + TokenMandatoryPolicy: *mut TOKEN_MANDATORY_POLICY, + Owner: *mut TOKEN_OWNER, + PrimaryGroup: *mut TOKEN_PRIMARY_GROUP, + DefaultDacl: *mut TOKEN_DEFAULT_DACL, + TokenSource: *mut TOKEN_SOURCE, ) -> NTSTATUS; fn ZwCreateTransaction( - TransactionHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - Uow: LPGUID, + TransactionHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + Uow: *mut GUID, TmHandle: HANDLE, - CreateOptions: ULONG, - IsolationLevel: ULONG, - IsolationFlags: ULONG, - Timeout: PLARGE_INTEGER, - Description: PUNICODE_STRING, + CreateOptions: c_ulong, + IsolationLevel: c_ulong, + IsolationFlags: c_ulong, + Timeout: *mut LARGE_INTEGER, + Description: *mut UNICODE_STRING, ) -> NTSTATUS; fn ZwCreateTransactionManager( - TmHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - LogFileName: PUNICODE_STRING, - CreateOptions: ULONG, - CommitStrength: ULONG, + TmHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + LogFileName: *mut UNICODE_STRING, + CreateOptions: c_ulong, + CommitStrength: c_ulong, ) -> NTSTATUS; fn ZwCreateUserProcess( - ProcessHandle: PHANDLE, - ThreadHandle: PHANDLE, - ProcessDesiredAccess: ACCESS_MASK, - ThreadDesiredAccess: ACCESS_MASK, - ProcessObjectAttributes: POBJECT_ATTRIBUTES, - ThreadObjectAttributes: POBJECT_ATTRIBUTES, - ProcessFlags: ULONG, - ThreadFlags: ULONG, - ProcessParameters: PVOID, + ProcessHandle: *mut HANDLE, + ThreadHandle: *mut HANDLE, + ProcessDesiredAccess: c_ulong, + ThreadDesiredAccess: c_ulong, + ProcessObjectAttributes: *mut OBJECT_ATTRIBUTES, + ThreadObjectAttributes: *mut OBJECT_ATTRIBUTES, + ProcessFlags: c_ulong, + ThreadFlags: c_ulong, + ProcessParameters: *mut c_void, CreateInfo: PPS_CREATE_INFO, AttributeList: PPS_ATTRIBUTE_LIST, ) -> NTSTATUS; fn ZwCreateWaitCompletionPacket( - WaitCompletionPacketHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + WaitCompletionPacketHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn ZwCreateWaitablePort( - PortHandle: PHANDLE, - ObjectAttributes: POBJECT_ATTRIBUTES, - MaxConnectionInfoLength: ULONG, - MaxMessageLength: ULONG, - MaxPoolUsage: ULONG, + PortHandle: *mut HANDLE, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + MaxConnectionInfoLength: c_ulong, + MaxMessageLength: c_ulong, + MaxPoolUsage: c_ulong, ) -> NTSTATUS; fn ZwCreateWnfStateName( - StateName: PWNF_STATE_NAME, + StateName: *mut WNF_STATE_NAME, NameLifetime: WNF_STATE_NAME_LIFETIME, DataScope: WNF_DATA_SCOPE, - PersistData: BOOLEAN, + PersistData: c_uchar, TypeId: PCWNF_TYPE_ID, - MaximumStateSize: ULONG, + MaximumStateSize: c_ulong, SecurityDescriptor: PSECURITY_DESCRIPTOR, ) -> NTSTATUS; fn ZwCreateWorkerFactory( - WorkerFactoryHandleReturn: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + WorkerFactoryHandleReturn: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, CompletionPortHandle: HANDLE, WorkerProcessHandle: HANDLE, - StartRoutine: PVOID, - StartParameter: PVOID, - MaxThreadCount: ULONG, - StackReserve: SIZE_T, - StackCommit: SIZE_T, + StartRoutine: *mut c_void, + StartParameter: *mut c_void, + MaxThreadCount: c_ulong, + StackReserve: usize, + StackCommit: usize, ) -> NTSTATUS; fn ZwDebugActiveProcess( ProcessHandle: HANDLE, @@ -917,147 +940,147 @@ EXTERN!{extern "system" { ContinueStatus: NTSTATUS, ) -> NTSTATUS; fn ZwDelayExecution( - Alertable: BOOLEAN, - DelayInterval: PLARGE_INTEGER, + Alertable: c_uchar, + DelayInterval: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwDeleteAtom( Atom: RTL_ATOM, ) -> NTSTATUS; fn ZwDeleteBootEntry( - Id: ULONG, + Id: c_ulong, ) -> NTSTATUS; fn ZwDeleteDriverEntry( - Id: ULONG, + Id: c_ulong, ) -> NTSTATUS; fn ZwDeleteFile( - ObjectAttributes: POBJECT_ATTRIBUTES, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn ZwDeleteKey( KeyHandle: HANDLE, ) -> NTSTATUS; fn ZwDeleteObjectAuditAlarm( - SubsystemName: PUNICODE_STRING, - HandleId: PVOID, - GenerateOnClose: BOOLEAN, + SubsystemName: *mut UNICODE_STRING, + HandleId: *mut c_void, + GenerateOnClose: c_uchar, ) -> NTSTATUS; fn ZwDeletePrivateNamespace( NamespaceHandle: HANDLE, ) -> NTSTATUS; fn ZwDeleteValueKey( KeyHandle: HANDLE, - ValueName: PUNICODE_STRING, + ValueName: *mut UNICODE_STRING, ) -> NTSTATUS; fn ZwDeleteWnfStateData( - StateName: PCWNF_STATE_NAME, - ExplicitScope: *const VOID, + StateName: *const WNF_STATE_NAME, + ExplicitScope: *const c_void, ) -> NTSTATUS; fn ZwDeleteWnfStateName( - StateName: PCWNF_STATE_NAME, + StateName: *const WNF_STATE_NAME, ) -> NTSTATUS; fn ZwDeviceIoControlFile( FileHandle: HANDLE, Event: HANDLE, ApcRoutine: PIO_APC_ROUTINE, - ApcContext: PVOID, + ApcContext: *mut c_void, IoStatusBlock: PIO_STATUS_BLOCK, - IoControlCode: ULONG, - InputBuffer: PVOID, - InputBufferLength: ULONG, - OutputBuffer: PVOID, - OutputBufferLength: ULONG, + IoControlCode: c_ulong, + InputBuffer: *mut c_void, + InputBufferLength: c_ulong, + OutputBuffer: *mut c_void, + OutputBufferLength: c_ulong, ) -> NTSTATUS; fn ZwDisableLastKnownGood() -> NTSTATUS; fn ZwDisplayString( - String: PUNICODE_STRING, + String: *mut UNICODE_STRING, ) -> NTSTATUS; fn ZwDrawText( - String: PUNICODE_STRING, + String: *mut UNICODE_STRING, ) -> NTSTATUS; fn ZwDuplicateObject( SourceProcessHandle: HANDLE, SourceHandle: HANDLE, TargetProcessHandle: HANDLE, - TargetHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - HandleAttributes: ULONG, - Options: ULONG, + TargetHandle: *mut HANDLE, + DesiredAccess: c_ulong, + HandleAttributes: c_ulong, + Options: c_ulong, ) -> NTSTATUS; fn ZwDuplicateToken( ExistingTokenHandle: HANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - EffectiveOnly: BOOLEAN, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + EffectiveOnly: c_uchar, TokenType: TOKEN_TYPE, - NewTokenHandle: PHANDLE, + NewTokenHandle: *mut HANDLE, ) -> NTSTATUS; fn ZwEnableLastKnownGood() -> NTSTATUS; fn ZwEnumerateBootEntries( - Buffer: PVOID, - BufferLength: PULONG, + Buffer: *mut c_void, + BufferLength: *mut c_ulong, ) -> NTSTATUS; fn ZwEnumerateDriverEntries( - Buffer: PVOID, - BufferLength: PULONG, + Buffer: *mut c_void, + BufferLength: *mut c_ulong, ) -> NTSTATUS; fn ZwEnumerateKey( KeyHandle: HANDLE, - Index: ULONG, + Index: c_ulong, KeyInformationClass: KEY_INFORMATION_CLASS, - KeyInformation: PVOID, - Length: ULONG, - ResultLength: PULONG, + KeyInformation: *mut c_void, + Length: c_ulong, + ResultLength: *mut c_ulong, ) -> NTSTATUS; fn ZwEnumerateSystemEnvironmentValuesEx( - InformationClass: ULONG, - Buffer: PVOID, - BufferLength: PULONG, + InformationClass: c_ulong, + Buffer: *mut c_void, + BufferLength: *mut c_ulong, ) -> NTSTATUS; fn ZwEnumerateTransactionObject( RootObjectHandle: HANDLE, QueryType: KTMOBJECT_TYPE, - ObjectCursor: PKTMOBJECT_CURSOR, - ObjectCursorLength: ULONG, - ReturnLength: PULONG, + ObjectCursor: *mut KTMOBJECT_CURSOR, + ObjectCursorLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn ZwEnumerateValueKey( KeyHandle: HANDLE, - Index: ULONG, + Index: c_ulong, KeyValueInformationClass: KEY_VALUE_INFORMATION_CLASS, - KeyValueInformation: PVOID, - Length: ULONG, - ResultLength: PULONG, + KeyValueInformation: *mut c_void, + Length: c_ulong, + ResultLength: *mut c_ulong, ) -> NTSTATUS; fn ZwExtendSection( SectionHandle: HANDLE, - NewSectionSize: PLARGE_INTEGER, + NewSectionSize: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwFilterToken( ExistingTokenHandle: HANDLE, - Flags: ULONG, - SidsToDisable: PTOKEN_GROUPS, - PrivilegesToDelete: PTOKEN_PRIVILEGES, - RestrictedSids: PTOKEN_GROUPS, - NewTokenHandle: PHANDLE, + Flags: c_ulong, + SidsToDisable: *mut TOKEN_GROUPS, + PrivilegesToDelete: *mut TOKEN_PRIVILEGES, + RestrictedSids: *mut TOKEN_GROUPS, + NewTokenHandle: *mut HANDLE, ) -> NTSTATUS; fn ZwFilterTokenEx( ExistingTokenHandle: HANDLE, - Flags: ULONG, - SidsToDisable: PTOKEN_GROUPS, - PrivilegesToDelete: PTOKEN_PRIVILEGES, - RestrictedSids: PTOKEN_GROUPS, - DisableUserClaimsCount: ULONG, - UserClaimsToDisable: PUNICODE_STRING, - DisableDeviceClaimsCount: ULONG, - DeviceClaimsToDisable: PUNICODE_STRING, - DeviceGroupsToDisable: PTOKEN_GROUPS, + Flags: c_ulong, + SidsToDisable: *mut TOKEN_GROUPS, + PrivilegesToDelete: *mut TOKEN_PRIVILEGES, + RestrictedSids: *mut TOKEN_GROUPS, + DisableUserClaimsCount: c_ulong, + UserClaimsToDisable: *mut UNICODE_STRING, + DisableDeviceClaimsCount: c_ulong, + DeviceClaimsToDisable: *mut UNICODE_STRING, + DeviceGroupsToDisable: *mut TOKEN_GROUPS, RestrictedUserAttributes: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, RestrictedDeviceAttributes: PTOKEN_SECURITY_ATTRIBUTES_INFORMATION, - RestrictedDeviceGroups: PTOKEN_GROUPS, - NewTokenHandle: PHANDLE, + RestrictedDeviceGroups: *mut TOKEN_GROUPS, + NewTokenHandle: *mut HANDLE, ) -> NTSTATUS; fn ZwFindAtom( - AtomName: PWSTR, - Length: ULONG, + AtomName: *mut wchar_t, + Length: c_ulong, Atom: PRTL_ATOM, ) -> NTSTATUS; fn ZwFlushBuffersFile( @@ -1066,19 +1089,19 @@ EXTERN!{extern "system" { ) -> NTSTATUS; fn ZwFlushBuffersFileEx( FileHandle: HANDLE, - Flags: ULONG, - Parameters: PVOID, - ParametersSize: ULONG, + Flags: c_ulong, + Parameters: *mut c_void, + ParametersSize: c_ulong, IoStatusBlock: PIO_STATUS_BLOCK, ) -> NTSTATUS; fn ZwFlushInstallUILanguage( - InstallUILanguage: LANGID, - SetComittedFlag: ULONG, + InstallUILanguage: c_ushort, + SetComittedFlag: c_ulong, ) -> NTSTATUS; fn ZwFlushInstructionCache( ProcessHandle: HANDLE, - BaseAddress: PVOID, - Length: SIZE_T, + BaseAddress: *mut c_void, + Length: usize, ) -> NTSTATUS; fn ZwFlushKey( KeyHandle: HANDLE, @@ -1087,109 +1110,109 @@ EXTERN!{extern "system" { fn ZwFlushWriteBuffer() -> NTSTATUS; fn ZwFreeUserPhysicalPages( ProcessHandle: HANDLE, - NumberOfPages: PULONG_PTR, - UserPfnArray: PULONG_PTR, + NumberOfPages: *mut usize, + UserPfnArray: *mut usize, ) -> NTSTATUS; fn ZwFreeVirtualMemory( ProcessHandle: HANDLE, - BaseAddress: *mut PVOID, - RegionSize: PSIZE_T, - FreeType: ULONG, + BaseAddress: *mut *mut c_void, + RegionSize: *mut usize, + FreeType: c_ulong, ) -> NTSTATUS; fn ZwFreezeRegistry( - TimeOutInSeconds: ULONG, + TimeOutInSeconds: c_ulong, ) -> NTSTATUS; fn ZwFreezeTransactions( - FreezeTimeout: PLARGE_INTEGER, - ThawTimeout: PLARGE_INTEGER, + FreezeTimeout: *mut LARGE_INTEGER, + ThawTimeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwFsControlFile( FileHandle: HANDLE, Event: HANDLE, ApcRoutine: PIO_APC_ROUTINE, - ApcContext: PVOID, + ApcContext: *mut c_void, IoStatusBlock: PIO_STATUS_BLOCK, - FsControlCode: ULONG, - InputBuffer: PVOID, - InputBufferLength: ULONG, - OutputBuffer: PVOID, - OutputBufferLength: ULONG, + FsControlCode: c_ulong, + InputBuffer: *mut c_void, + InputBufferLength: c_ulong, + OutputBuffer: *mut c_void, + OutputBufferLength: c_ulong, ) -> NTSTATUS; fn ZwGetCachedSigningLevel( File: HANDLE, - Flags: PULONG, - SigningLevel: PSE_SIGNING_LEVEL, - Thumbprint: PUCHAR, - ThumbprintSize: PULONG, - ThumbprintAlgorithm: PULONG, + Flags: *mut c_ulong, + SigningLevel: *mut c_uchar, + Thumbprint: *mut c_uchar, + ThumbprintSize: *mut c_ulong, + ThumbprintAlgorithm: *mut c_ulong, ) -> NTSTATUS; fn ZwGetCompleteWnfStateSubscription( - OldDescriptorStateName: PWNF_STATE_NAME, - OldSubscriptionId: *mut ULONG64, - OldDescriptorEventMask: ULONG, - OldDescriptorStatus: ULONG, + OldDescriptorStateName: *mut WNF_STATE_NAME, + OldSubscriptionId: *mut __uint64, + OldDescriptorEventMask: c_ulong, + OldDescriptorStatus: c_ulong, NewDeliveryDescriptor: PWNF_DELIVERY_DESCRIPTOR, - DescriptorSize: ULONG, + DescriptorSize: c_ulong, ) -> NTSTATUS; fn ZwGetContextThread( ThreadHandle: HANDLE, - ThreadContext: PCONTEXT, + ThreadContext: *mut CONTEXT, ) -> NTSTATUS; - fn ZwGetCurrentProcessorNumber() -> ULONG; + fn ZwGetCurrentProcessorNumber() -> c_ulong; fn ZwGetDevicePowerState( Device: HANDLE, - State: PDEVICE_POWER_STATE, + State: *mut DEVICE_POWER_STATE, ) -> NTSTATUS; fn ZwGetMUIRegistryInfo( - Flags: ULONG, - DataSize: PULONG, - Data: PVOID, + Flags: c_ulong, + DataSize: *mut c_ulong, + Data: *mut c_void, ) -> NTSTATUS; fn ZwGetNextProcess( ProcessHandle: HANDLE, - DesiredAccess: ACCESS_MASK, - HandleAttributes: ULONG, - Flags: ULONG, - NewProcessHandle: PHANDLE, + DesiredAccess: c_ulong, + HandleAttributes: c_ulong, + Flags: c_ulong, + NewProcessHandle: *mut HANDLE, ) -> NTSTATUS; fn ZwGetNextThread( ProcessHandle: HANDLE, ThreadHandle: HANDLE, - DesiredAccess: ACCESS_MASK, - HandleAttributes: ULONG, - Flags: ULONG, - NewThreadHandle: PHANDLE, + DesiredAccess: c_ulong, + HandleAttributes: c_ulong, + Flags: c_ulong, + NewThreadHandle: *mut HANDLE, ) -> NTSTATUS; fn ZwGetNlsSectionPtr( - SectionType: ULONG, - SectionData: ULONG, - ContextData: PVOID, - SectionPointer: *mut PVOID, - SectionSize: PULONG, + SectionType: c_ulong, + SectionData: c_ulong, + ContextData: *mut c_void, + SectionPointer: *mut *mut c_void, + SectionSize: *mut c_ulong, ) -> NTSTATUS; fn ZwGetNotificationResourceManager( ResourceManagerHandle: HANDLE, - TransactionNotification: PTRANSACTION_NOTIFICATION, - NotificationLength: ULONG, - Timeout: PLARGE_INTEGER, - ReturnLength: PULONG, - Asynchronous: ULONG, - AsynchronousContext: ULONG_PTR, + TransactionNotification: *mut TRANSACTION_NOTIFICATION, + NotificationLength: c_ulong, + Timeout: *mut LARGE_INTEGER, + ReturnLength: *mut c_ulong, + Asynchronous: c_ulong, + AsynchronousContext: usize, ) -> NTSTATUS; fn ZwGetPlugPlayEvent( EventHandle: HANDLE, - Context: PVOID, + Context: *mut c_void, EventBlock: PPLUGPLAY_EVENT_BLOCK, - EventBufferSize: ULONG, + EventBufferSize: c_ulong, ) -> NTSTATUS; fn ZwGetWriteWatch( ProcessHandle: HANDLE, - Flags: ULONG, - BaseAddress: PVOID, - RegionSize: SIZE_T, - UserAddressArray: *mut PVOID, - EntriesInUserAddressArray: PULONG_PTR, - Granularity: PULONG, + Flags: c_ulong, + BaseAddress: *mut c_void, + RegionSize: usize, + UserAddressArray: *mut *mut c_void, + EntriesInUserAddressArray: *mut usize, + Granularity: *mut c_ulong, ) -> NTSTATUS; fn ZwImpersonateAnonymousToken( ThreadHandle: HANDLE, @@ -1201,78 +1224,78 @@ EXTERN!{extern "system" { fn ZwImpersonateThread( ServerThreadHandle: HANDLE, ClientThreadHandle: HANDLE, - SecurityQos: PSECURITY_QUALITY_OF_SERVICE, + SecurityQos: *mut SECURITY_QUALITY_OF_SERVICE, ) -> NTSTATUS; fn ZwInitializeNlsFiles( - BaseAddress: *mut PVOID, - DefaultLocaleId: PLCID, - DefaultCasingTableSize: PLARGE_INTEGER, + BaseAddress: *mut *mut c_void, + DefaultLocaleId: *mut c_ulong, + DefaultCasingTableSize: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwInitializeRegistry( - BootCondition: USHORT, + BootCondition: c_ushort, ) -> NTSTATUS; fn ZwInitiatePowerAction( SystemAction: POWER_ACTION, LightestSystemState: SYSTEM_POWER_STATE, - Flags: ULONG, - Asynchronous: BOOLEAN, + Flags: c_ulong, + Asynchronous: c_uchar, ) -> NTSTATUS; fn ZwIsProcessInJob( ProcessHandle: HANDLE, JobHandle: HANDLE, ) -> NTSTATUS; - fn ZwIsSystemResumeAutomatic() -> BOOLEAN; + fn ZwIsSystemResumeAutomatic() -> c_uchar; fn ZwIsUILanguageComitted() -> NTSTATUS; fn ZwListenPort( PortHandle: HANDLE, ConnectionRequest: PPORT_MESSAGE, ) -> NTSTATUS; fn ZwLoadDriver( - DriverServiceName: PUNICODE_STRING, + DriverServiceName: *mut UNICODE_STRING, ) -> NTSTATUS; fn ZwLoadKey( - TargetKey: POBJECT_ATTRIBUTES, - SourceFile: POBJECT_ATTRIBUTES, + TargetKey: *mut OBJECT_ATTRIBUTES, + SourceFile: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn ZwLoadKey2( - TargetKey: POBJECT_ATTRIBUTES, - SourceFile: POBJECT_ATTRIBUTES, - Flags: ULONG, + TargetKey: *mut OBJECT_ATTRIBUTES, + SourceFile: *mut OBJECT_ATTRIBUTES, + Flags: c_ulong, ) -> NTSTATUS; fn ZwLoadKeyEx( - TargetKey: POBJECT_ATTRIBUTES, - SourceFile: POBJECT_ATTRIBUTES, - Flags: ULONG, + TargetKey: *mut OBJECT_ATTRIBUTES, + SourceFile: *mut OBJECT_ATTRIBUTES, + Flags: c_ulong, TrustClassKey: HANDLE, Event: HANDLE, - DesiredAccess: ACCESS_MASK, - RootHandle: PHANDLE, + DesiredAccess: c_ulong, + RootHandle: *mut HANDLE, IoStatus: PIO_STATUS_BLOCK, ) -> NTSTATUS; fn ZwLockFile( FileHandle: HANDLE, Event: HANDLE, ApcRoutine: PIO_APC_ROUTINE, - ApcContext: PVOID, + ApcContext: *mut c_void, IoStatusBlock: PIO_STATUS_BLOCK, - ByteOffset: PLARGE_INTEGER, - Length: PLARGE_INTEGER, - Key: ULONG, - FailImmediately: BOOLEAN, - ExclusiveLock: BOOLEAN, + ByteOffset: *mut LARGE_INTEGER, + Length: *mut LARGE_INTEGER, + Key: c_ulong, + FailImmediately: c_uchar, + ExclusiveLock: c_uchar, ) -> NTSTATUS; fn ZwLockProductActivationKeys( - pPrivateVer: *mut ULONG, - pSafeMode: *mut ULONG, + pPrivateVer: *mut c_ulong, + pSafeMode: *mut c_ulong, ) -> NTSTATUS; fn ZwLockRegistryKey( KeyHandle: HANDLE, ) -> NTSTATUS; fn ZwLockVirtualMemory( ProcessHandle: HANDLE, - BaseAddress: *mut PVOID, - RegionSize: PSIZE_T, - MapType: ULONG, + BaseAddress: *mut *mut c_void, + RegionSize: *mut usize, + MapType: c_ulong, ) -> NTSTATUS; fn ZwMakePermanentObject( Handle: HANDLE, @@ -1282,38 +1305,38 @@ EXTERN!{extern "system" { ) -> NTSTATUS; fn ZwManagePartition( PartitionInformationClass: MEMORY_PARTITION_INFORMATION_CLASS, - PartitionInformation: PVOID, - PartitionInformationLength: ULONG, + PartitionInformation: *mut c_void, + PartitionInformationLength: c_ulong, ) -> NTSTATUS; fn ZwMapCMFModule( - What: ULONG, - Index: ULONG, - CacheIndexOut: PULONG, - CacheFlagsOut: PULONG, - ViewSizeOut: PULONG, - BaseAddress: *mut PVOID, + What: c_ulong, + Index: c_ulong, + CacheIndexOut: *mut c_ulong, + CacheFlagsOut: *mut c_ulong, + ViewSizeOut: *mut c_ulong, + BaseAddress: *mut *mut c_void, ) -> NTSTATUS; fn ZwMapUserPhysicalPages( - VirtualAddress: PVOID, - NumberOfPages: ULONG_PTR, - UserPfnArray: PULONG_PTR, + VirtualAddress: *mut c_void, + NumberOfPages: usize, + UserPfnArray: *mut usize, ) -> NTSTATUS; fn ZwMapUserPhysicalPagesScatter( - VirtualAddresses: *mut PVOID, - NumberOfPages: ULONG_PTR, - UserPfnArray: PULONG_PTR, + VirtualAddresses: *mut *mut c_void, + NumberOfPages: usize, + UserPfnArray: *mut usize, ) -> NTSTATUS; fn ZwMapViewOfSection( SectionHandle: HANDLE, ProcessHandle: HANDLE, - BaseAddress: *mut PVOID, - ZeroBits: ULONG_PTR, - CommitSize: SIZE_T, - SectionOffset: PLARGE_INTEGER, - ViewSize: PSIZE_T, + BaseAddress: *mut *mut c_void, + ZeroBits: usize, + CommitSize: usize, + SectionOffset: *mut LARGE_INTEGER, + ViewSize: *mut usize, InheritDisposition: SECTION_INHERIT, - AllocationType: ULONG, - Win32Protect: ULONG, + AllocationType: c_ulong, + Win32Protect: c_ulong, ) -> NTSTATUS; fn ZwModifyBootEntry( BootEntry: PBOOT_ENTRY, @@ -1325,718 +1348,718 @@ EXTERN!{extern "system" { FileHandle: HANDLE, Event: HANDLE, ApcRoutine: PIO_APC_ROUTINE, - ApcContext: PVOID, + ApcContext: *mut c_void, IoStatusBlock: PIO_STATUS_BLOCK, - Buffer: PVOID, - Length: ULONG, - CompletionFilter: ULONG, - WatchTree: BOOLEAN, + Buffer: *mut c_void, + Length: c_ulong, + CompletionFilter: c_ulong, + WatchTree: c_uchar, ) -> NTSTATUS; fn ZwNotifyChangeKey( KeyHandle: HANDLE, Event: HANDLE, ApcRoutine: PIO_APC_ROUTINE, - ApcContext: PVOID, + ApcContext: *mut c_void, IoStatusBlock: PIO_STATUS_BLOCK, - CompletionFilter: ULONG, - WatchTree: BOOLEAN, - Buffer: PVOID, - BufferSize: ULONG, - Asynchronous: BOOLEAN, + CompletionFilter: c_ulong, + WatchTree: c_uchar, + Buffer: *mut c_void, + BufferSize: c_ulong, + Asynchronous: c_uchar, ) -> NTSTATUS; fn ZwNotifyChangeMultipleKeys( MasterKeyHandle: HANDLE, - Count: ULONG, + Count: c_ulong, SubordinateObjects: *mut OBJECT_ATTRIBUTES, Event: HANDLE, ApcRoutine: PIO_APC_ROUTINE, - ApcContext: PVOID, + ApcContext: *mut c_void, IoStatusBlock: PIO_STATUS_BLOCK, - CompletionFilter: ULONG, - WatchTree: BOOLEAN, - Buffer: PVOID, - BufferSize: ULONG, - Asynchronous: BOOLEAN, + CompletionFilter: c_ulong, + WatchTree: c_uchar, + Buffer: *mut c_void, + BufferSize: c_ulong, + Asynchronous: c_uchar, ) -> NTSTATUS; fn ZwNotifyChangeSession( SessionHandle: HANDLE, - ChangeSequenceNumber: ULONG, - ChangeTimeStamp: PLARGE_INTEGER, + ChangeSequenceNumber: c_ulong, + ChangeTimeStamp: *mut LARGE_INTEGER, Event: IO_SESSION_EVENT, NewState: IO_SESSION_STATE, PreviousState: IO_SESSION_STATE, - Payload: PVOID, - PayloadSize: ULONG, + Payload: *mut c_void, + PayloadSize: c_ulong, ) -> NTSTATUS; fn ZwOpenDirectoryObject( - DirectoryHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + DirectoryHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn ZwOpenEnlistment( - EnlistmentHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, + EnlistmentHandle: *mut HANDLE, + DesiredAccess: c_ulong, RmHandle: HANDLE, - EnlistmentGuid: LPGUID, - ObjectAttributes: POBJECT_ATTRIBUTES, + EnlistmentGuid: *mut GUID, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn ZwOpenEvent( - EventHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + EventHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn ZwOpenEventPair( - EventPairHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + EventPairHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn ZwOpenFile( - FileHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + FileHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, IoStatusBlock: PIO_STATUS_BLOCK, - ShareAccess: ULONG, - OpenOptions: ULONG, + ShareAccess: c_ulong, + OpenOptions: c_ulong, ) -> NTSTATUS; fn ZwOpenIoCompletion( - IoCompletionHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + IoCompletionHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn ZwOpenJobObject( - JobHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + JobHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn ZwOpenKey( - KeyHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + KeyHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn ZwOpenKeyEx( - KeyHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - OpenOptions: ULONG, + KeyHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + OpenOptions: c_ulong, ) -> NTSTATUS; fn ZwOpenKeyTransacted( - KeyHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + KeyHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, TransactionHandle: HANDLE, ) -> NTSTATUS; fn ZwOpenKeyTransactedEx( - KeyHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - OpenOptions: ULONG, + KeyHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + OpenOptions: c_ulong, TransactionHandle: HANDLE, ) -> NTSTATUS; fn ZwOpenKeyedEvent( - KeyedEventHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + KeyedEventHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn ZwOpenMutant( - MutantHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + MutantHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn ZwOpenObjectAuditAlarm( - SubsystemName: PUNICODE_STRING, - HandleId: PVOID, - ObjectTypeName: PUNICODE_STRING, - ObjectName: PUNICODE_STRING, + SubsystemName: *mut UNICODE_STRING, + HandleId: *mut c_void, + ObjectTypeName: *mut UNICODE_STRING, + ObjectName: *mut UNICODE_STRING, SecurityDescriptor: PSECURITY_DESCRIPTOR, ClientToken: HANDLE, - DesiredAccess: ACCESS_MASK, - GrantedAccess: ACCESS_MASK, - Privileges: PPRIVILEGE_SET, - ObjectCreation: BOOLEAN, - AccessGranted: BOOLEAN, - GenerateOnClose: PBOOLEAN, + DesiredAccess: c_ulong, + GrantedAccess: c_ulong, + Privileges: *mut PRIVILEGE_SET, + ObjectCreation: c_uchar, + AccessGranted: c_uchar, + GenerateOnClose: *mut c_uchar, ) -> NTSTATUS; fn ZwOpenPartition( - PartitionHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + PartitionHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn ZwOpenPrivateNamespace( - NamespaceHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - BoundaryDescriptor: PVOID, + NamespaceHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + BoundaryDescriptor: *mut c_void, ) -> NTSTATUS; fn ZwOpenProcess( - ProcessHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + ProcessHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ClientId: PCLIENT_ID, ) -> NTSTATUS; fn ZwOpenProcessToken( ProcessHandle: HANDLE, - DesiredAccess: ACCESS_MASK, - TokenHandle: PHANDLE, + DesiredAccess: c_ulong, + TokenHandle: *mut HANDLE, ) -> NTSTATUS; fn ZwOpenProcessTokenEx( ProcessHandle: HANDLE, - DesiredAccess: ACCESS_MASK, - HandleAttributes: ULONG, - TokenHandle: PHANDLE, + DesiredAccess: c_ulong, + HandleAttributes: c_ulong, + TokenHandle: *mut HANDLE, ) -> NTSTATUS; fn ZwOpenResourceManager( - ResourceManagerHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, + ResourceManagerHandle: *mut HANDLE, + DesiredAccess: c_ulong, TmHandle: HANDLE, - ResourceManagerGuid: LPGUID, - ObjectAttributes: POBJECT_ATTRIBUTES, + ResourceManagerGuid: *mut GUID, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn ZwOpenSection( - SectionHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + SectionHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn ZwOpenSemaphore( - SemaphoreHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + SemaphoreHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn ZwOpenSession( - SessionHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + SessionHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn ZwOpenSymbolicLinkObject( - LinkHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + LinkHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn ZwOpenThread( - ThreadHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + ThreadHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ClientId: PCLIENT_ID, ) -> NTSTATUS; fn ZwOpenThreadToken( ThreadHandle: HANDLE, - DesiredAccess: ACCESS_MASK, - OpenAsSelf: BOOLEAN, - TokenHandle: PHANDLE, + DesiredAccess: c_ulong, + OpenAsSelf: c_uchar, + TokenHandle: *mut HANDLE, ) -> NTSTATUS; fn ZwOpenThreadTokenEx( ThreadHandle: HANDLE, - DesiredAccess: ACCESS_MASK, - OpenAsSelf: BOOLEAN, - HandleAttributes: ULONG, - TokenHandle: PHANDLE, + DesiredAccess: c_ulong, + OpenAsSelf: c_uchar, + HandleAttributes: c_ulong, + TokenHandle: *mut HANDLE, ) -> NTSTATUS; fn ZwOpenTimer( - TimerHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, + TimerHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn ZwOpenTransaction( - TransactionHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - Uow: LPGUID, + TransactionHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + Uow: *mut GUID, TmHandle: HANDLE, ) -> NTSTATUS; fn ZwOpenTransactionManager( - TmHandle: PHANDLE, - DesiredAccess: ACCESS_MASK, - ObjectAttributes: POBJECT_ATTRIBUTES, - LogFileName: PUNICODE_STRING, - TmIdentity: LPGUID, - OpenOptions: ULONG, + TmHandle: *mut HANDLE, + DesiredAccess: c_ulong, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, + LogFileName: *mut UNICODE_STRING, + TmIdentity: *mut GUID, + OpenOptions: c_ulong, ) -> NTSTATUS; fn ZwPlugPlayControl( PnPControlClass: PLUGPLAY_CONTROL_CLASS, - PnPControlData: PVOID, - PnPControlDataLength: ULONG, + PnPControlData: *mut c_void, + PnPControlDataLength: c_ulong, ) -> NTSTATUS; fn ZwPowerInformation( InformationLevel: POWER_INFORMATION_LEVEL, - InputBuffer: PVOID, - InputBufferLength: ULONG, - OutputBuffer: PVOID, - OutputBufferLength: ULONG, + InputBuffer: *mut c_void, + InputBufferLength: c_ulong, + OutputBuffer: *mut c_void, + OutputBufferLength: c_ulong, ) -> NTSTATUS; fn ZwPrePrepareComplete( EnlistmentHandle: HANDLE, - TmVirtualClock: PLARGE_INTEGER, + TmVirtualClock: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwPrePrepareEnlistment( EnlistmentHandle: HANDLE, - TmVirtualClock: PLARGE_INTEGER, + TmVirtualClock: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwPrepareComplete( EnlistmentHandle: HANDLE, - TmVirtualClock: PLARGE_INTEGER, + TmVirtualClock: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwPrepareEnlistment( EnlistmentHandle: HANDLE, - TmVirtualClock: PLARGE_INTEGER, + TmVirtualClock: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwPrivilegeCheck( ClientToken: HANDLE, - RequiredPrivileges: PPRIVILEGE_SET, - Result: PBOOLEAN, + RequiredPrivileges: *mut PRIVILEGE_SET, + Result: *mut c_uchar, ) -> NTSTATUS; fn ZwPrivilegeObjectAuditAlarm( - SubsystemName: PUNICODE_STRING, - HandleId: PVOID, + SubsystemName: *mut UNICODE_STRING, + HandleId: *mut c_void, ClientToken: HANDLE, - DesiredAccess: ACCESS_MASK, - Privileges: PPRIVILEGE_SET, - AccessGranted: BOOLEAN, + DesiredAccess: c_ulong, + Privileges: *mut PRIVILEGE_SET, + AccessGranted: c_uchar, ) -> NTSTATUS; fn ZwPrivilegedServiceAuditAlarm( - SubsystemName: PUNICODE_STRING, - ServiceName: PUNICODE_STRING, + SubsystemName: *mut UNICODE_STRING, + ServiceName: *mut UNICODE_STRING, ClientToken: HANDLE, - Privileges: PPRIVILEGE_SET, - AccessGranted: BOOLEAN, + Privileges: *mut PRIVILEGE_SET, + AccessGranted: c_uchar, ) -> NTSTATUS; fn ZwPropagationComplete( ResourceManagerHandle: HANDLE, - RequestCookie: ULONG, - BufferLength: ULONG, - Buffer: PVOID, + RequestCookie: c_ulong, + BufferLength: c_ulong, + Buffer: *mut c_void, ) -> NTSTATUS; fn ZwPropagationFailed( ResourceManagerHandle: HANDLE, - RequestCookie: ULONG, + RequestCookie: c_ulong, PropStatus: NTSTATUS, ) -> NTSTATUS; fn ZwProtectVirtualMemory( ProcessHandle: HANDLE, - BaseAddress: *mut PVOID, - RegionSize: PSIZE_T, - NewProtect: ULONG, - OldProtect: PULONG, + BaseAddress: *mut *mut c_void, + RegionSize: *mut usize, + NewProtect: c_ulong, + OldProtect: *mut c_ulong, ) -> NTSTATUS; fn ZwPulseEvent( EventHandle: HANDLE, - PreviousState: PLONG, + PreviousState: *mut c_long, ) -> NTSTATUS; fn ZwQueryAttributesFile( - ObjectAttributes: POBJECT_ATTRIBUTES, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, FileInformation: PFILE_BASIC_INFORMATION, ) -> NTSTATUS; fn ZwQueryBootEntryOrder( - Ids: PULONG, - Count: PULONG, + Ids: *mut c_ulong, + Count: *mut c_ulong, ) -> NTSTATUS; fn ZwQueryBootOptions( BootOptions: PBOOT_OPTIONS, - BootOptionsLength: PULONG, + BootOptionsLength: *mut c_ulong, ) -> NTSTATUS; fn ZwQueryDebugFilterState( - ComponentId: ULONG, - Level: ULONG, + ComponentId: c_ulong, + Level: c_ulong, ) -> NTSTATUS; fn ZwQueryDefaultLocale( - UserProfile: BOOLEAN, - DefaultLocaleId: PLCID, + UserProfile: c_uchar, + DefaultLocaleId: *mut c_ulong, ) -> NTSTATUS; fn ZwQueryDefaultUILanguage( - DefaultUILanguageId: *mut LANGID, + DefaultUILanguageId: *mut c_ushort, ) -> NTSTATUS; fn ZwQueryDirectoryFile( FileHandle: HANDLE, Event: HANDLE, ApcRoutine: PIO_APC_ROUTINE, - ApcContext: PVOID, + ApcContext: *mut c_void, IoStatusBlock: PIO_STATUS_BLOCK, - FileInformation: PVOID, - Length: ULONG, + FileInformation: *mut c_void, + Length: c_ulong, FileInformationClass: FILE_INFORMATION_CLASS, - ReturnSingleEntry: BOOLEAN, - FileName: PUNICODE_STRING, - RestartScan: BOOLEAN, + ReturnSingleEntry: c_uchar, + FileName: *mut UNICODE_STRING, + RestartScan: c_uchar, ) -> NTSTATUS; fn ZwQueryDirectoryObject( DirectoryHandle: HANDLE, - Buffer: PVOID, - Length: ULONG, - ReturnSingleEntry: BOOLEAN, - RestartScan: BOOLEAN, - Context: PULONG, - ReturnLength: PULONG, + Buffer: *mut c_void, + Length: c_ulong, + ReturnSingleEntry: c_uchar, + RestartScan: c_uchar, + Context: *mut c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn ZwQueryDriverEntryOrder( - Ids: PULONG, - Count: PULONG, + Ids: *mut c_ulong, + Count: *mut c_ulong, ) -> NTSTATUS; fn ZwQueryEaFile( FileHandle: HANDLE, IoStatusBlock: PIO_STATUS_BLOCK, - Buffer: PVOID, - Length: ULONG, - ReturnSingleEntry: BOOLEAN, - EaList: PVOID, - EaListLength: ULONG, - EaIndex: PULONG, - RestartScan: BOOLEAN, + Buffer: *mut c_void, + Length: c_ulong, + ReturnSingleEntry: c_uchar, + EaList: *mut c_void, + EaListLength: c_ulong, + EaIndex: *mut c_ulong, + RestartScan: c_uchar, ) -> NTSTATUS; fn ZwQueryEvent( EventHandle: HANDLE, EventInformationClass: EVENT_INFORMATION_CLASS, - EventInformation: PVOID, - EventInformationLength: ULONG, - ReturnLength: PULONG, + EventInformation: *mut c_void, + EventInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn ZwQueryFullAttributesFile( - ObjectAttributes: POBJECT_ATTRIBUTES, + ObjectAttributes: *mut OBJECT_ATTRIBUTES, FileInformation: PFILE_NETWORK_OPEN_INFORMATION, ) -> NTSTATUS; fn ZwQueryInformationAtom( Atom: RTL_ATOM, AtomInformationClass: ATOM_INFORMATION_CLASS, - AtomInformation: PVOID, - AtomInformationLength: ULONG, - ReturnLength: PULONG, + AtomInformation: *mut c_void, + AtomInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn ZwQueryInformationEnlistment( EnlistmentHandle: HANDLE, EnlistmentInformationClass: ENLISTMENT_INFORMATION_CLASS, - EnlistmentInformation: PVOID, - EnlistmentInformationLength: ULONG, - ReturnLength: PULONG, + EnlistmentInformation: *mut c_void, + EnlistmentInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn ZwQueryInformationFile( FileHandle: HANDLE, IoStatusBlock: PIO_STATUS_BLOCK, - FileInformation: PVOID, - Length: ULONG, + FileInformation: *mut c_void, + Length: c_ulong, FileInformationClass: FILE_INFORMATION_CLASS, ) -> NTSTATUS; fn ZwQueryInformationJobObject( JobHandle: HANDLE, JobObjectInformationClass: JOBOBJECTINFOCLASS, - JobObjectInformation: PVOID, - JobObjectInformationLength: ULONG, - ReturnLength: PULONG, + JobObjectInformation: *mut c_void, + JobObjectInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn ZwQueryInformationPort( PortHandle: HANDLE, PortInformationClass: PORT_INFORMATION_CLASS, - PortInformation: PVOID, - Length: ULONG, - ReturnLength: PULONG, + PortInformation: *mut c_void, + Length: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn ZwQueryInformationProcess( ProcessHandle: HANDLE, ProcessInformationClass: PROCESSINFOCLASS, - ProcessInformation: PVOID, - ProcessInformationLength: ULONG, - ReturnLength: PULONG, + ProcessInformation: *mut c_void, + ProcessInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn ZwQueryInformationResourceManager( ResourceManagerHandle: HANDLE, ResourceManagerInformationClass: RESOURCEMANAGER_INFORMATION_CLASS, - ResourceManagerInformation: PVOID, - ResourceManagerInformationLength: ULONG, - ReturnLength: PULONG, + ResourceManagerInformation: *mut c_void, + ResourceManagerInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn ZwQueryInformationThread( ThreadHandle: HANDLE, ThreadInformationClass: THREADINFOCLASS, - ThreadInformation: PVOID, - ThreadInformationLength: ULONG, - ReturnLength: PULONG, + ThreadInformation: *mut c_void, + ThreadInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn ZwQueryInformationToken( TokenHandle: HANDLE, TokenInformationClass: TOKEN_INFORMATION_CLASS, - TokenInformation: PVOID, - TokenInformationLength: ULONG, - ReturnLength: PULONG, + TokenInformation: *mut c_void, + TokenInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn ZwQueryInformationTransaction( TransactionHandle: HANDLE, TransactionInformationClass: TRANSACTION_INFORMATION_CLASS, - TransactionInformation: PVOID, - TransactionInformationLength: ULONG, - ReturnLength: PULONG, + TransactionInformation: *mut c_void, + TransactionInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn ZwQueryInformationTransactionManager( TransactionManagerHandle: HANDLE, TransactionManagerInformationClass: TRANSACTIONMANAGER_INFORMATION_CLASS, - TransactionManagerInformation: PVOID, - TransactionManagerInformationLength: ULONG, - ReturnLength: PULONG, + TransactionManagerInformation: *mut c_void, + TransactionManagerInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn ZwQueryInformationWorkerFactory( WorkerFactoryHandle: HANDLE, WorkerFactoryInformationClass: WORKERFACTORYINFOCLASS, - WorkerFactoryInformation: PVOID, - WorkerFactoryInformationLength: ULONG, - ReturnLength: PULONG, + WorkerFactoryInformation: *mut c_void, + WorkerFactoryInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn ZwQueryInstallUILanguage( - InstallUILanguageId: *mut LANGID, + InstallUILanguageId: *mut c_ushort, ) -> NTSTATUS; fn ZwQueryIntervalProfile( ProfileSource: KPROFILE_SOURCE, - Interval: PULONG, + Interval: *mut c_ulong, ) -> NTSTATUS; fn ZwQueryIoCompletion( IoCompletionHandle: HANDLE, IoCompletionInformationClass: IO_COMPLETION_INFORMATION_CLASS, - IoCompletionInformation: PVOID, - IoCompletionInformationLength: ULONG, - ReturnLength: PULONG, + IoCompletionInformation: *mut c_void, + IoCompletionInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn ZwQueryKey( KeyHandle: HANDLE, KeyInformationClass: KEY_INFORMATION_CLASS, - KeyInformation: PVOID, - Length: ULONG, - ResultLength: PULONG, + KeyInformation: *mut c_void, + Length: c_ulong, + ResultLength: *mut c_ulong, ) -> NTSTATUS; fn ZwQueryLicenseValue( - ValueName: PUNICODE_STRING, - Type: PULONG, - Data: PVOID, - DataSize: ULONG, - ResultDataSize: PULONG, + ValueName: *mut UNICODE_STRING, + Type: *mut c_ulong, + Data: *mut c_void, + DataSize: c_ulong, + ResultDataSize: *mut c_ulong, ) -> NTSTATUS; fn ZwQueryMultipleValueKey( KeyHandle: HANDLE, ValueEntries: PKEY_VALUE_ENTRY, - EntryCount: ULONG, - ValueBuffer: PVOID, - BufferLength: PULONG, - RequiredBufferLength: PULONG, + EntryCount: c_ulong, + ValueBuffer: *mut c_void, + BufferLength: *mut c_ulong, + RequiredBufferLength: *mut c_ulong, ) -> NTSTATUS; fn ZwQueryMutant( MutantHandle: HANDLE, MutantInformationClass: MUTANT_INFORMATION_CLASS, - MutantInformation: PVOID, - MutantInformationLength: ULONG, - ReturnLength: PULONG, + MutantInformation: *mut c_void, + MutantInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn ZwQueryObject( Handle: HANDLE, ObjectInformationClass: OBJECT_INFORMATION_CLASS, - ObjectInformation: PVOID, - ObjectInformationLength: ULONG, - ReturnLength: PULONG, + ObjectInformation: *mut c_void, + ObjectInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn ZwQueryOpenSubKeys( - TargetKey: POBJECT_ATTRIBUTES, - HandleCount: PULONG, + TargetKey: *mut OBJECT_ATTRIBUTES, + HandleCount: *mut c_ulong, ) -> NTSTATUS; fn ZwQueryOpenSubKeysEx( - TargetKey: POBJECT_ATTRIBUTES, - BufferLength: ULONG, - Buffer: PVOID, - RequiredSize: PULONG, + TargetKey: *mut OBJECT_ATTRIBUTES, + BufferLength: c_ulong, + Buffer: *mut c_void, + RequiredSize: *mut c_ulong, ) -> NTSTATUS; fn ZwQueryPerformanceCounter( - PerformanceCounter: PLARGE_INTEGER, - PerformanceFrequency: PLARGE_INTEGER, + PerformanceCounter: *mut LARGE_INTEGER, + PerformanceFrequency: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwQueryPortInformationProcess() -> NTSTATUS; fn ZwQueryQuotaInformationFile( FileHandle: HANDLE, IoStatusBlock: PIO_STATUS_BLOCK, - Buffer: PVOID, - Length: ULONG, - ReturnSingleEntry: BOOLEAN, - SidList: PVOID, - SidListLength: ULONG, + Buffer: *mut c_void, + Length: c_ulong, + ReturnSingleEntry: c_uchar, + SidList: *mut c_void, + SidListLength: c_ulong, StartSid: PSID, - RestartScan: BOOLEAN, + RestartScan: c_uchar, ) -> NTSTATUS; fn ZwQuerySection( SectionHandle: HANDLE, SectionInformationClass: SECTION_INFORMATION_CLASS, - SectionInformation: PVOID, - SectionInformationLength: SIZE_T, - ReturnLength: PSIZE_T, + SectionInformation: *mut c_void, + SectionInformationLength: usize, + ReturnLength: *mut usize, ) -> NTSTATUS; fn ZwQuerySecurityAttributesToken( TokenHandle: HANDLE, - Attributes: PUNICODE_STRING, - NumberOfAttributes: ULONG, - Buffer: PVOID, - Length: ULONG, - ReturnLength: PULONG, + Attributes: *mut UNICODE_STRING, + NumberOfAttributes: c_ulong, + Buffer: *mut c_void, + Length: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn ZwQuerySecurityObject( Handle: HANDLE, - SecurityInformation: SECURITY_INFORMATION, + SecurityInformation: c_ulong, SecurityDescriptor: PSECURITY_DESCRIPTOR, - Length: ULONG, - LengthNeeded: PULONG, + Length: c_ulong, + LengthNeeded: *mut c_ulong, ) -> NTSTATUS; fn ZwQuerySemaphore( SemaphoreHandle: HANDLE, SemaphoreInformationClass: SEMAPHORE_INFORMATION_CLASS, - SemaphoreInformation: PVOID, - SemaphoreInformationLength: ULONG, - ReturnLength: PULONG, + SemaphoreInformation: *mut c_void, + SemaphoreInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn ZwQuerySymbolicLinkObject( LinkHandle: HANDLE, - LinkTarget: PUNICODE_STRING, - ReturnedLength: PULONG, + LinkTarget: *mut UNICODE_STRING, + ReturnedLength: *mut c_ulong, ) -> NTSTATUS; fn ZwQuerySystemEnvironmentValue( - VariableName: PUNICODE_STRING, - VariableValue: PWSTR, - ValueLength: USHORT, - ReturnLength: PUSHORT, + VariableName: *mut UNICODE_STRING, + VariableValue: *mut wchar_t, + ValueLength: c_ushort, + ReturnLength: *mut c_ushort, ) -> NTSTATUS; fn ZwQuerySystemEnvironmentValueEx( - VariableName: PUNICODE_STRING, - VendorGuid: LPGUID, - Value: PVOID, - ValueLength: PULONG, - Attributes: PULONG, + VariableName: *mut UNICODE_STRING, + VendorGuid: *mut GUID, + Value: *mut c_void, + ValueLength: *mut c_ulong, + Attributes: *mut c_ulong, ) -> NTSTATUS; fn ZwQuerySystemInformation( SystemInformationClass: SYSTEM_INFORMATION_CLASS, - SystemInformation: PVOID, - SystemInformationLength: ULONG, - ReturnLength: PULONG, + SystemInformation: *mut c_void, + SystemInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn ZwQuerySystemInformationEx( SystemInformationClass: SYSTEM_INFORMATION_CLASS, - InputBuffer: PVOID, - InputBufferLength: ULONG, - SystemInformation: PVOID, - SystemInformationLength: ULONG, - ReturnLength: PULONG, + InputBuffer: *mut c_void, + InputBufferLength: c_ulong, + SystemInformation: *mut c_void, + SystemInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn ZwQuerySystemTime( - SystemTime: PLARGE_INTEGER, + SystemTime: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwQueryTimer( TimerHandle: HANDLE, TimerInformationClass: TIMER_INFORMATION_CLASS, - TimerInformation: PVOID, - TimerInformationLength: ULONG, - ReturnLength: PULONG, + TimerInformation: *mut c_void, + TimerInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn ZwQueryTimerResolution( - MaximumTime: PULONG, - MinimumTime: PULONG, - CurrentTime: PULONG, + MaximumTime: *mut c_ulong, + MinimumTime: *mut c_ulong, + CurrentTime: *mut c_ulong, ) -> NTSTATUS; fn ZwQueryValueKey( KeyHandle: HANDLE, - ValueName: PUNICODE_STRING, + ValueName: *mut UNICODE_STRING, KeyValueInformationClass: KEY_VALUE_INFORMATION_CLASS, - KeyValueInformation: PVOID, - Length: ULONG, - ResultLength: PULONG, + KeyValueInformation: *mut c_void, + Length: c_ulong, + ResultLength: *mut c_ulong, ) -> NTSTATUS; fn ZwQueryVirtualMemory( ProcessHandle: HANDLE, - BaseAddress: PVOID, + BaseAddress: *mut c_void, MemoryInformationClass: MEMORY_INFORMATION_CLASS, - MemoryInformation: PVOID, - MemoryInformationLength: SIZE_T, - ReturnLength: PSIZE_T, + MemoryInformation: *mut c_void, + MemoryInformationLength: usize, + ReturnLength: *mut usize, ) -> NTSTATUS; fn ZwQueryVolumeInformationFile( FileHandle: HANDLE, IoStatusBlock: PIO_STATUS_BLOCK, - FsInformation: PVOID, - Length: ULONG, + FsInformation: *mut c_void, + Length: c_ulong, FsInformationClass: FS_INFORMATION_CLASS, ) -> NTSTATUS; fn ZwQueryWnfStateData( - StateName: PCWNF_STATE_NAME, + StateName: *const WNF_STATE_NAME, TypeId: PCWNF_TYPE_ID, - ExplicitScope: *const VOID, + ExplicitScope: *const c_void, ChangeStamp: PWNF_CHANGE_STAMP, - Buffer: PVOID, - BufferSize: PULONG, + Buffer: *mut c_void, + BufferSize: *mut c_ulong, ) -> NTSTATUS; fn ZwQueryWnfStateNameInformation( - StateName: PCWNF_STATE_NAME, + StateName: *const WNF_STATE_NAME, NameInfoClass: WNF_STATE_NAME_INFORMATION, - ExplicitScope: *const VOID, - InfoBuffer: PVOID, - InfoBufferSize: ULONG, + ExplicitScope: *const c_void, + InfoBuffer: *mut c_void, + InfoBufferSize: c_ulong, ) -> NTSTATUS; fn ZwQueueApcThread( ThreadHandle: HANDLE, ApcRoutine: PPS_APC_ROUTINE, - ApcArgument1: PVOID, - ApcArgument2: PVOID, - ApcArgument3: PVOID, + ApcArgument1: *mut c_void, + ApcArgument2: *mut c_void, + ApcArgument3: *mut c_void, ) -> NTSTATUS; fn ZwQueueApcThreadEx( ThreadHandle: HANDLE, UserApcReserveHandle: HANDLE, ApcRoutine: PPS_APC_ROUTINE, - ApcArgument1: PVOID, - ApcArgument2: PVOID, - ApcArgument3: PVOID, + ApcArgument1: *mut c_void, + ApcArgument2: *mut c_void, + ApcArgument3: *mut c_void, ) -> NTSTATUS; fn ZwRaiseException( - ExceptionRecord: PEXCEPTION_RECORD, - ContextRecord: PCONTEXT, - FirstChance: BOOLEAN, + ExceptionRecord: *mut EXCEPTION_RECORD, + ContextRecord: *mut CONTEXT, + FirstChance: c_uchar, ) -> NTSTATUS; fn ZwRaiseHardError( ErrorStatus: NTSTATUS, - NumberOfParameters: ULONG, - UnicodeStringParameterMask: ULONG, - Parameters: PULONG_PTR, - ValidResponseOptions: ULONG, - Response: PULONG, + NumberOfParameters: c_ulong, + UnicodeStringParameterMask: c_ulong, + Parameters: *mut usize, + ValidResponseOptions: c_ulong, + Response: *mut c_ulong, ) -> NTSTATUS; fn ZwReadFile( FileHandle: HANDLE, Event: HANDLE, ApcRoutine: PIO_APC_ROUTINE, - ApcContext: PVOID, + ApcContext: *mut c_void, IoStatusBlock: PIO_STATUS_BLOCK, - Buffer: PVOID, - Length: ULONG, - ByteOffset: PLARGE_INTEGER, - Key: PULONG, + Buffer: *mut c_void, + Length: c_ulong, + ByteOffset: *mut LARGE_INTEGER, + Key: *mut c_ulong, ) -> NTSTATUS; fn ZwReadFileScatter( FileHandle: HANDLE, Event: HANDLE, ApcRoutine: PIO_APC_ROUTINE, - ApcContext: PVOID, + ApcContext: *mut c_void, IoStatusBlock: PIO_STATUS_BLOCK, - SegmentArray: PFILE_SEGMENT_ELEMENT, - Length: ULONG, - ByteOffset: PLARGE_INTEGER, - Key: PULONG, + SegmentArray: *mut FILE_SEGMENT_ELEMENT, + Length: c_ulong, + ByteOffset: *mut LARGE_INTEGER, + Key: *mut c_ulong, ) -> NTSTATUS; fn ZwReadOnlyEnlistment( EnlistmentHandle: HANDLE, - TmVirtualClock: PLARGE_INTEGER, + TmVirtualClock: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwReadRequestData( PortHandle: HANDLE, Message: PPORT_MESSAGE, - DataEntryIndex: ULONG, - Buffer: PVOID, - BufferSize: SIZE_T, - NumberOfBytesRead: PSIZE_T, + DataEntryIndex: c_ulong, + Buffer: *mut c_void, + BufferSize: usize, + NumberOfBytesRead: *mut usize, ) -> NTSTATUS; fn ZwReadVirtualMemory( ProcessHandle: HANDLE, - BaseAddress: PVOID, - Buffer: PVOID, - BufferSize: SIZE_T, - NumberOfBytesRead: PSIZE_T, + BaseAddress: *mut c_void, + Buffer: *mut c_void, + BufferSize: usize, + NumberOfBytesRead: *mut usize, ) -> NTSTATUS; fn ZwRecoverEnlistment( EnlistmentHandle: HANDLE, - EnlistmentKey: PVOID, + EnlistmentKey: *mut c_void, ) -> NTSTATUS; fn ZwRecoverResourceManager( ResourceManagerHandle: HANDLE, @@ -2046,10 +2069,10 @@ EXTERN!{extern "system" { ) -> NTSTATUS; fn ZwRegisterProtocolAddressInformation( ResourceManager: HANDLE, - ProtocolId: PCRM_PROTOCOL_ID, - ProtocolInformationSize: ULONG, - ProtocolInformation: PVOID, - CreateOptions: ULONG, + ProtocolId: *mut GUID, + ProtocolInformationSize: c_ulong, + ProtocolInformation: *mut c_void, + CreateOptions: c_ulong, ) -> NTSTATUS; fn ZwRegisterThreadTerminatePort( PortHandle: HANDLE, @@ -2057,36 +2080,36 @@ EXTERN!{extern "system" { fn ZwReleaseCMFViewOwnership() -> NTSTATUS; fn ZwReleaseKeyedEvent( KeyedEventHandle: HANDLE, - KeyValue: PVOID, - Alertable: BOOLEAN, - Timeout: PLARGE_INTEGER, + KeyValue: *mut c_void, + Alertable: c_uchar, + Timeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwReleaseMutant( MutantHandle: HANDLE, - PreviousCount: PLONG, + PreviousCount: *mut c_long, ) -> NTSTATUS; fn ZwReleaseSemaphore( SemaphoreHandle: HANDLE, - ReleaseCount: LONG, - PreviousCount: PLONG, + ReleaseCount: c_long, + PreviousCount: *mut c_long, ) -> NTSTATUS; fn ZwReleaseWorkerFactoryWorker( WorkerFactoryHandle: HANDLE, ) -> NTSTATUS; fn ZwRemoveIoCompletion( IoCompletionHandle: HANDLE, - KeyContext: *mut PVOID, - ApcContext: *mut PVOID, + KeyContext: *mut *mut c_void, + ApcContext: *mut *mut c_void, IoStatusBlock: PIO_STATUS_BLOCK, - Timeout: PLARGE_INTEGER, + Timeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwRemoveIoCompletionEx( IoCompletionHandle: HANDLE, IoCompletionInformation: PFILE_IO_COMPLETION_INFORMATION, - Count: ULONG, - NumEntriesRemoved: PULONG, - Timeout: PLARGE_INTEGER, - Alertable: BOOLEAN, + Count: c_ulong, + NumEntriesRemoved: *mut c_ulong, + Timeout: *mut LARGE_INTEGER, + Alertable: c_uchar, ) -> NTSTATUS; fn ZwRemoveProcessDebug( ProcessHandle: HANDLE, @@ -2094,21 +2117,21 @@ EXTERN!{extern "system" { ) -> NTSTATUS; fn ZwRenameKey( KeyHandle: HANDLE, - NewName: PUNICODE_STRING, + NewName: *mut UNICODE_STRING, ) -> NTSTATUS; fn ZwRenameTransactionManager( - LogFileName: PUNICODE_STRING, - ExistingTransactionManagerGuid: LPGUID, + LogFileName: *mut UNICODE_STRING, + ExistingTransactionManagerGuid: *mut GUID, ) -> NTSTATUS; fn ZwReplaceKey( - NewFile: POBJECT_ATTRIBUTES, + NewFile: *mut OBJECT_ATTRIBUTES, TargetHandle: HANDLE, - OldFile: POBJECT_ATTRIBUTES, + OldFile: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn ZwReplacePartitionUnit( - TargetInstancePath: PUNICODE_STRING, - SpareInstancePath: PUNICODE_STRING, - Flags: ULONG, + TargetInstancePath: *mut UNICODE_STRING, + SpareInstancePath: *mut UNICODE_STRING, + Flags: c_ulong, ) -> NTSTATUS; fn ZwReplyPort( PortHandle: HANDLE, @@ -2116,16 +2139,16 @@ EXTERN!{extern "system" { ) -> NTSTATUS; fn ZwReplyWaitReceivePort( PortHandle: HANDLE, - PortContext: *mut PVOID, + PortContext: *mut *mut c_void, ReplyMessage: PPORT_MESSAGE, ReceiveMessage: PPORT_MESSAGE, ) -> NTSTATUS; fn ZwReplyWaitReceivePortEx( PortHandle: HANDLE, - PortContext: *mut PVOID, + PortContext: *mut *mut c_void, ReplyMessage: PPORT_MESSAGE, ReceiveMessage: PPORT_MESSAGE, - Timeout: PLARGE_INTEGER, + Timeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwReplyWaitReplyPort( PortHandle: HANDLE, @@ -2145,41 +2168,41 @@ EXTERN!{extern "system" { ) -> NTSTATUS; fn ZwResetEvent( EventHandle: HANDLE, - PreviousState: PLONG, + PreviousState: *mut c_long, ) -> NTSTATUS; fn ZwResetWriteWatch( ProcessHandle: HANDLE, - BaseAddress: PVOID, - RegionSize: SIZE_T, + BaseAddress: *mut c_void, + RegionSize: usize, ) -> NTSTATUS; fn ZwRestoreKey( KeyHandle: HANDLE, FileHandle: HANDLE, - Flags: ULONG, + Flags: c_ulong, ) -> NTSTATUS; fn ZwResumeProcess( ProcessHandle: HANDLE, ) -> NTSTATUS; fn ZwResumeThread( ThreadHandle: HANDLE, - PreviousSuspendCount: PULONG, + PreviousSuspendCount: *mut c_ulong, ) -> NTSTATUS; fn ZwRevertContainerImpersonation() -> NTSTATUS; fn ZwRollbackComplete( EnlistmentHandle: HANDLE, - TmVirtualClock: PLARGE_INTEGER, + TmVirtualClock: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwRollbackEnlistment( EnlistmentHandle: HANDLE, - TmVirtualClock: PLARGE_INTEGER, + TmVirtualClock: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwRollbackTransaction( TransactionHandle: HANDLE, - Wait: BOOLEAN, + Wait: c_uchar, ) -> NTSTATUS; fn ZwRollforwardTransactionManager( TransactionManagerHandle: HANDLE, - TmVirtualClock: PLARGE_INTEGER, + TmVirtualClock: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwSaveKey( KeyHandle: HANDLE, @@ -2188,7 +2211,7 @@ EXTERN!{extern "system" { fn ZwSaveKeyEx( KeyHandle: HANDLE, FileHandle: HANDLE, - Format: ULONG, + Format: c_ulong, ) -> NTSTATUS; fn ZwSaveMergedKeys( HighPrecedenceKeyHandle: HANDLE, @@ -2196,64 +2219,64 @@ EXTERN!{extern "system" { FileHandle: HANDLE, ) -> NTSTATUS; fn ZwSecureConnectPort( - PortHandle: PHANDLE, - PortName: PUNICODE_STRING, - SecurityQos: PSECURITY_QUALITY_OF_SERVICE, + PortHandle: *mut HANDLE, + PortName: *mut UNICODE_STRING, + SecurityQos: *mut SECURITY_QUALITY_OF_SERVICE, ClientView: PPORT_VIEW, RequiredServerSid: PSID, ServerView: PREMOTE_PORT_VIEW, - MaxMessageLength: PULONG, - ConnectionInformation: PVOID, - ConnectionInformationLength: PULONG, + MaxMessageLength: *mut c_ulong, + ConnectionInformation: *mut c_void, + ConnectionInformationLength: *mut c_ulong, ) -> NTSTATUS; fn ZwSerializeBoot() -> NTSTATUS; fn ZwSetBootEntryOrder( - Ids: PULONG, - Count: ULONG, + Ids: *mut c_ulong, + Count: c_ulong, ) -> NTSTATUS; fn ZwSetBootOptions( BootOptions: PBOOT_OPTIONS, - FieldsToChange: ULONG, + FieldsToChange: c_ulong, ) -> NTSTATUS; fn ZwSetCachedSigningLevel( - Flags: ULONG, - InputSigningLevel: SE_SIGNING_LEVEL, - SourceFiles: PHANDLE, - SourceFileCount: ULONG, + Flags: c_ulong, + InputSigningLevel: c_uchar, + SourceFiles: *mut HANDLE, + SourceFileCount: c_ulong, TargetFile: HANDLE, ) -> NTSTATUS; fn ZwSetContextThread( ThreadHandle: HANDLE, - ThreadContext: PCONTEXT, + ThreadContext: *mut CONTEXT, ) -> NTSTATUS; fn ZwSetDebugFilterState( - ComponentId: ULONG, - Level: ULONG, - State: BOOLEAN, + ComponentId: c_ulong, + Level: c_ulong, + State: c_uchar, ) -> NTSTATUS; fn ZwSetDefaultHardErrorPort( DefaultHardErrorPort: HANDLE, ) -> NTSTATUS; fn ZwSetDefaultLocale( - UserProfile: BOOLEAN, - DefaultLocaleId: LCID, + UserProfile: c_uchar, + DefaultLocaleId: c_ulong, ) -> NTSTATUS; fn ZwSetDefaultUILanguage( - DefaultUILanguageId: LANGID, + DefaultUILanguageId: c_ushort, ) -> NTSTATUS; fn ZwSetDriverEntryOrder( - Ids: PULONG, - Count: ULONG, + Ids: *mut c_ulong, + Count: c_ulong, ) -> NTSTATUS; fn ZwSetEaFile( FileHandle: HANDLE, IoStatusBlock: PIO_STATUS_BLOCK, - Buffer: PVOID, - Length: ULONG, + Buffer: *mut c_void, + Length: c_ulong, ) -> NTSTATUS; fn ZwSetEvent( EventHandle: HANDLE, - PreviousState: PLONG, + PreviousState: *mut c_long, ) -> NTSTATUS; fn ZwSetEventBoostPriority( EventHandle: HANDLE, @@ -2266,122 +2289,122 @@ EXTERN!{extern "system" { ) -> NTSTATUS; fn ZwSetIRTimer( TimerHandle: HANDLE, - DueTime: PLARGE_INTEGER, + DueTime: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwSetInformationDebugObject( DebugObjectHandle: HANDLE, DebugObjectInformationClass: DEBUGOBJECTINFOCLASS, - DebugInformation: PVOID, - DebugInformationLength: ULONG, - ReturnLength: PULONG, + DebugInformation: *mut c_void, + DebugInformationLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn ZwSetInformationEnlistment( EnlistmentHandle: HANDLE, EnlistmentInformationClass: ENLISTMENT_INFORMATION_CLASS, - EnlistmentInformation: PVOID, - EnlistmentInformationLength: ULONG, + EnlistmentInformation: *mut c_void, + EnlistmentInformationLength: c_ulong, ) -> NTSTATUS; fn ZwSetInformationFile( FileHandle: HANDLE, IoStatusBlock: PIO_STATUS_BLOCK, - FileInformation: PVOID, - Length: ULONG, + FileInformation: *mut c_void, + Length: c_ulong, FileInformationClass: FILE_INFORMATION_CLASS, ) -> NTSTATUS; fn ZwSetInformationJobObject( JobHandle: HANDLE, JobObjectInformationClass: JOBOBJECTINFOCLASS, - JobObjectInformation: PVOID, - JobObjectInformationLength: ULONG, + JobObjectInformation: *mut c_void, + JobObjectInformationLength: c_ulong, ) -> NTSTATUS; fn ZwSetInformationKey( KeyHandle: HANDLE, KeySetInformationClass: KEY_SET_INFORMATION_CLASS, - KeySetInformation: PVOID, - KeySetInformationLength: ULONG, + KeySetInformation: *mut c_void, + KeySetInformationLength: c_ulong, ) -> NTSTATUS; fn ZwSetInformationObject( Handle: HANDLE, ObjectInformationClass: OBJECT_INFORMATION_CLASS, - ObjectInformation: PVOID, - ObjectInformationLength: ULONG, + ObjectInformation: *mut c_void, + ObjectInformationLength: c_ulong, ) -> NTSTATUS; fn ZwSetInformationProcess( ProcessHandle: HANDLE, ProcessInformationClass: PROCESSINFOCLASS, - ProcessInformation: PVOID, - ProcessInformationLength: ULONG, + ProcessInformation: *mut c_void, + ProcessInformationLength: c_ulong, ) -> NTSTATUS; fn ZwSetInformationResourceManager( ResourceManagerHandle: HANDLE, ResourceManagerInformationClass: RESOURCEMANAGER_INFORMATION_CLASS, - ResourceManagerInformation: PVOID, - ResourceManagerInformationLength: ULONG, + ResourceManagerInformation: *mut c_void, + ResourceManagerInformationLength: c_ulong, ) -> NTSTATUS; fn ZwSetInformationThread( ThreadHandle: HANDLE, ThreadInformationClass: THREADINFOCLASS, - ThreadInformation: PVOID, - ThreadInformationLength: ULONG, + ThreadInformation: *mut c_void, + ThreadInformationLength: c_ulong, ) -> NTSTATUS; fn ZwSetInformationToken( TokenHandle: HANDLE, TokenInformationClass: TOKEN_INFORMATION_CLASS, - TokenInformation: PVOID, - TokenInformationLength: ULONG, + TokenInformation: *mut c_void, + TokenInformationLength: c_ulong, ) -> NTSTATUS; fn ZwSetInformationTransaction( TransactionHandle: HANDLE, TransactionInformationClass: TRANSACTION_INFORMATION_CLASS, - TransactionInformation: PVOID, - TransactionInformationLength: ULONG, + TransactionInformation: *mut c_void, + TransactionInformationLength: c_ulong, ) -> NTSTATUS; fn ZwSetInformationTransactionManager( TmHandle: HANDLE, TransactionManagerInformationClass: TRANSACTIONMANAGER_INFORMATION_CLASS, - TransactionManagerInformation: PVOID, - TransactionManagerInformationLength: ULONG, + TransactionManagerInformation: *mut c_void, + TransactionManagerInformationLength: c_ulong, ) -> NTSTATUS; fn ZwSetInformationVirtualMemory( ProcessHandle: HANDLE, VmInformationClass: VIRTUAL_MEMORY_INFORMATION_CLASS, - NumberOfEntries: ULONG_PTR, + NumberOfEntries: usize, VirtualAddresses: PMEMORY_RANGE_ENTRY, - VmInformation: PVOID, - VmInformationLength: ULONG, + VmInformation: *mut c_void, + VmInformationLength: c_ulong, ) -> NTSTATUS; fn ZwSetInformationWorkerFactory( WorkerFactoryHandle: HANDLE, WorkerFactoryInformationClass: WORKERFACTORYINFOCLASS, - WorkerFactoryInformation: PVOID, - WorkerFactoryInformationLength: ULONG, + WorkerFactoryInformation: *mut c_void, + WorkerFactoryInformationLength: c_ulong, ) -> NTSTATUS; fn ZwSetIntervalProfile( - Interval: ULONG, + Interval: c_ulong, Source: KPROFILE_SOURCE, ) -> NTSTATUS; fn ZwSetIoCompletion( IoCompletionHandle: HANDLE, - KeyContext: PVOID, - ApcContext: PVOID, + KeyContext: *mut c_void, + ApcContext: *mut c_void, IoStatus: NTSTATUS, - IoStatusInformation: ULONG_PTR, + IoStatusInformation: usize, ) -> NTSTATUS; fn ZwSetIoCompletionEx( IoCompletionHandle: HANDLE, IoCompletionPacketHandle: HANDLE, - KeyContext: PVOID, - ApcContext: PVOID, + KeyContext: *mut c_void, + ApcContext: *mut c_void, IoStatus: NTSTATUS, - IoStatusInformation: ULONG_PTR, + IoStatusInformation: usize, ) -> NTSTATUS; fn ZwSetLdtEntries( - Selector0: ULONG, - Entry0Low: ULONG, - Entry0Hi: ULONG, - Selector1: ULONG, - Entry1Low: ULONG, - Entry1Hi: ULONG, + Selector0: c_ulong, + Entry0Low: c_ulong, + Entry0Hi: c_ulong, + Selector1: c_ulong, + Entry1Low: c_ulong, + Entry1Hi: c_ulong, ) -> NTSTATUS; fn ZwSetLowEventPair( EventPairHandle: HANDLE, @@ -2392,38 +2415,38 @@ EXTERN!{extern "system" { fn ZwSetQuotaInformationFile( FileHandle: HANDLE, IoStatusBlock: PIO_STATUS_BLOCK, - Buffer: PVOID, - Length: ULONG, + Buffer: *mut c_void, + Length: c_ulong, ) -> NTSTATUS; fn ZwSetSecurityObject( Handle: HANDLE, - SecurityInformation: SECURITY_INFORMATION, + SecurityInformation: c_ulong, SecurityDescriptor: PSECURITY_DESCRIPTOR, ) -> NTSTATUS; fn ZwSetSystemEnvironmentValue( - VariableName: PUNICODE_STRING, - VariableValue: PUNICODE_STRING, + VariableName: *mut UNICODE_STRING, + VariableValue: *mut UNICODE_STRING, ) -> NTSTATUS; fn ZwSetSystemEnvironmentValueEx( - VariableName: PUNICODE_STRING, - VendorGuid: LPGUID, - Value: PVOID, - ValueLength: ULONG, - Attributes: ULONG, + VariableName: *mut UNICODE_STRING, + VendorGuid: *mut GUID, + Value: *mut c_void, + ValueLength: c_ulong, + Attributes: c_ulong, ) -> NTSTATUS; fn ZwSetSystemInformation( SystemInformationClass: SYSTEM_INFORMATION_CLASS, - SystemInformation: PVOID, - SystemInformationLength: ULONG, + SystemInformation: *mut c_void, + SystemInformationLength: c_ulong, ) -> NTSTATUS; fn ZwSetSystemPowerState( SystemAction: POWER_ACTION, LightestSystemState: SYSTEM_POWER_STATE, - Flags: ULONG, + Flags: c_ulong, ) -> NTSTATUS; fn ZwSetSystemTime( - SystemTime: PLARGE_INTEGER, - PreviousTime: PLARGE_INTEGER, + SystemTime: *mut LARGE_INTEGER, + PreviousTime: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwSetThreadExecutionState( NewFlags: EXECUTION_STATE, @@ -2431,46 +2454,46 @@ EXTERN!{extern "system" { ) -> NTSTATUS; fn ZwSetTimer( TimerHandle: HANDLE, - DueTime: PLARGE_INTEGER, + DueTime: *mut LARGE_INTEGER, TimerApcRoutine: PTIMER_APC_ROUTINE, - TimerContext: PVOID, - ResumeTimer: BOOLEAN, - Period: LONG, - PreviousState: PBOOLEAN, + TimerContext: *mut c_void, + ResumeTimer: c_uchar, + Period: c_long, + PreviousState: *mut c_uchar, ) -> NTSTATUS; fn ZwSetTimer2( TimerHandle: HANDLE, - DueTime: PLARGE_INTEGER, - Period: PLARGE_INTEGER, + DueTime: *mut LARGE_INTEGER, + Period: *mut LARGE_INTEGER, Parameters: PT2_SET_PARAMETERS, ) -> NTSTATUS; fn ZwSetTimerEx( TimerHandle: HANDLE, TimerSetInformationClass: TIMER_SET_INFORMATION_CLASS, - TimerSetInformation: PVOID, - TimerSetInformationLength: ULONG, + TimerSetInformation: *mut c_void, + TimerSetInformationLength: c_ulong, ) -> NTSTATUS; fn ZwSetTimerResolution( - DesiredTime: ULONG, - SetResolution: BOOLEAN, - ActualTime: PULONG, + DesiredTime: c_ulong, + SetResolution: c_uchar, + ActualTime: *mut c_ulong, ) -> NTSTATUS; fn ZwSetUuidSeed( - Seed: PCHAR, + Seed: *mut c_char, ) -> NTSTATUS; fn ZwSetValueKey( KeyHandle: HANDLE, - ValueName: PUNICODE_STRING, - TitleIndex: ULONG, - Type: ULONG, - Data: PVOID, - DataSize: ULONG, + ValueName: *mut UNICODE_STRING, + TitleIndex: c_ulong, + Type: c_ulong, + Data: *mut c_void, + DataSize: c_ulong, ) -> NTSTATUS; fn ZwSetVolumeInformationFile( FileHandle: HANDLE, IoStatusBlock: PIO_STATUS_BLOCK, - FsInformation: PVOID, - Length: ULONG, + FsInformation: *mut c_void, + Length: c_ulong, FsInformationClass: FS_INFORMATION_CLASS, ) -> NTSTATUS; fn ZwSetWnfProcessNotificationEvent( @@ -2481,17 +2504,17 @@ EXTERN!{extern "system" { ) -> NTSTATUS; fn ZwShutdownWorkerFactory( WorkerFactoryHandle: HANDLE, - PendingWorkerCount: *mut LONG, + PendingWorkerCount: *mut c_long, ) -> NTSTATUS; fn ZwSignalAndWaitForSingleObject( SignalHandle: HANDLE, WaitHandle: HANDLE, - Alertable: BOOLEAN, - Timeout: PLARGE_INTEGER, + Alertable: c_uchar, + Timeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwSinglePhaseReject( EnlistmentHandle: HANDLE, - TmVirtualClock: PLARGE_INTEGER, + TmVirtualClock: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwStartProfile( ProfileHandle: HANDLE, @@ -2500,25 +2523,25 @@ EXTERN!{extern "system" { ProfileHandle: HANDLE, ) -> NTSTATUS; fn ZwSubscribeWnfStateChange( - StateName: PCWNF_STATE_NAME, + StateName: *const WNF_STATE_NAME, ChangeStamp: WNF_CHANGE_STAMP, - EventMask: ULONG, - SubscriptionId: PULONG64, + EventMask: c_ulong, + SubscriptionId: *mut __uint64, ) -> NTSTATUS; fn ZwSuspendProcess( ProcessHandle: HANDLE, ) -> NTSTATUS; fn ZwSuspendThread( ThreadHandle: HANDLE, - PreviousSuspendCount: PULONG, + PreviousSuspendCount: *mut c_ulong, ) -> NTSTATUS; fn ZwSystemDebugControl( Command: SYSDBG_COMMAND, - InputBuffer: PVOID, - InputBufferLength: ULONG, - OutputBuffer: PVOID, - OutputBufferLength: ULONG, - ReturnLength: PULONG, + InputBuffer: *mut c_void, + InputBufferLength: c_ulong, + OutputBuffer: *mut c_void, + OutputBufferLength: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn ZwTerminateJobObject( JobHandle: HANDLE, @@ -2536,114 +2559,114 @@ EXTERN!{extern "system" { fn ZwThawRegistry() -> NTSTATUS; fn ZwThawTransactions() -> NTSTATUS; fn ZwTraceControl( - FunctionCode: ULONG, - InBuffer: PVOID, - InBufferLen: ULONG, - OutBuffer: PVOID, - OutBufferLen: ULONG, - ReturnLength: PULONG, + FunctionCode: c_ulong, + InBuffer: *mut c_void, + InBufferLen: c_ulong, + OutBuffer: *mut c_void, + OutBufferLen: c_ulong, + ReturnLength: *mut c_ulong, ) -> NTSTATUS; fn ZwTraceEvent( TraceHandle: HANDLE, - Flags: ULONG, - FieldSize: ULONG, - Fields: PVOID, + Flags: c_ulong, + FieldSize: c_ulong, + Fields: *mut c_void, ) -> NTSTATUS; fn ZwTranslateFilePath( InputFilePath: PFILE_PATH, - OutputType: ULONG, + OutputType: c_ulong, OutputFilePath: PFILE_PATH, - OutputFilePathLength: PULONG, + OutputFilePathLength: *mut c_ulong, ) -> NTSTATUS; fn ZwUmsThreadYield( - SchedulerParam: PVOID, + SchedulerParam: *mut c_void, ) -> NTSTATUS; fn ZwUnloadDriver( - DriverServiceName: PUNICODE_STRING, + DriverServiceName: *mut UNICODE_STRING, ) -> NTSTATUS; fn ZwUnloadKey( - TargetKey: POBJECT_ATTRIBUTES, + TargetKey: *mut OBJECT_ATTRIBUTES, ) -> NTSTATUS; fn ZwUnloadKey2( - TargetKey: POBJECT_ATTRIBUTES, - Flags: ULONG, + TargetKey: *mut OBJECT_ATTRIBUTES, + Flags: c_ulong, ) -> NTSTATUS; fn ZwUnloadKeyEx( - TargetKey: POBJECT_ATTRIBUTES, + TargetKey: *mut OBJECT_ATTRIBUTES, Event: HANDLE, ) -> NTSTATUS; fn ZwUnlockFile( FileHandle: HANDLE, IoStatusBlock: PIO_STATUS_BLOCK, - ByteOffset: PLARGE_INTEGER, - Length: PLARGE_INTEGER, - Key: ULONG, + ByteOffset: *mut LARGE_INTEGER, + Length: *mut LARGE_INTEGER, + Key: c_ulong, ) -> NTSTATUS; fn ZwUnlockVirtualMemory( ProcessHandle: HANDLE, - BaseAddress: *mut PVOID, - RegionSize: PSIZE_T, - MapType: ULONG, + BaseAddress: *mut *mut c_void, + RegionSize: *mut usize, + MapType: c_ulong, ) -> NTSTATUS; fn ZwUnmapViewOfSection( ProcessHandle: HANDLE, - BaseAddress: PVOID, + BaseAddress: *mut c_void, ) -> NTSTATUS; fn ZwUnmapViewOfSectionEx( ProcessHandle: HANDLE, - BaseAddress: PVOID, - Flags: ULONG, + BaseAddress: *mut c_void, + Flags: c_ulong, ) -> NTSTATUS; fn ZwUnsubscribeWnfStateChange( - StateName: PCWNF_STATE_NAME, + StateName: *const WNF_STATE_NAME, ) -> NTSTATUS; fn ZwUpdateWnfStateData( - StateName: PCWNF_STATE_NAME, - Buffer: *const VOID, - Length: ULONG, + StateName: *const WNF_STATE_NAME, + Buffer: *const c_void, + Length: c_ulong, TypeId: PCWNF_TYPE_ID, - ExplicitScope: *const VOID, + ExplicitScope: *const c_void, MatchingChangeStamp: WNF_CHANGE_STAMP, - CheckStamp: LOGICAL, + CheckStamp: c_ulong, ) -> NTSTATUS; fn ZwVdmControl( Service: VDMSERVICECLASS, - ServiceData: PVOID, + ServiceData: *mut c_void, ) -> NTSTATUS; fn ZwWaitForAlertByThreadId( - Address: PVOID, - Timeout: PLARGE_INTEGER, + Address: *mut c_void, + Timeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwWaitForDebugEvent( DebugObjectHandle: HANDLE, - Alertable: BOOLEAN, - Timeout: PLARGE_INTEGER, - WaitStateChange: PVOID, + Alertable: c_uchar, + Timeout: *mut LARGE_INTEGER, + WaitStateChange: *mut c_void, ) -> NTSTATUS; fn ZwWaitForKeyedEvent( KeyedEventHandle: HANDLE, - KeyValue: PVOID, - Alertable: BOOLEAN, - Timeout: PLARGE_INTEGER, + KeyValue: *mut c_void, + Alertable: c_uchar, + Timeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwWaitForMultipleObjects( - Count: ULONG, + Count: c_ulong, Handles: *mut HANDLE, WaitType: WAIT_TYPE, - Alertable: BOOLEAN, - Timeout: PLARGE_INTEGER, + Alertable: c_uchar, + Timeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwWaitForMultipleObjects32( - Count: ULONG, - Handles: *mut LONG, + Count: c_ulong, + Handles: *mut c_long, WaitType: WAIT_TYPE, - Alertable: BOOLEAN, - Timeout: PLARGE_INTEGER, + Alertable: c_uchar, + Timeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwWaitForSingleObject( Handle: HANDLE, - Alertable: BOOLEAN, - Timeout: PLARGE_INTEGER, + Alertable: c_uchar, + Timeout: *mut LARGE_INTEGER, ) -> NTSTATUS; fn ZwWaitForWorkViaWorkerFactory( WorkerFactoryHandle: HANDLE, @@ -2662,38 +2685,38 @@ EXTERN!{extern "system" { FileHandle: HANDLE, Event: HANDLE, ApcRoutine: PIO_APC_ROUTINE, - ApcContext: PVOID, + ApcContext: *mut c_void, IoStatusBlock: PIO_STATUS_BLOCK, - Buffer: PVOID, - Length: ULONG, - ByteOffset: PLARGE_INTEGER, - Key: PULONG, + Buffer: *mut c_void, + Length: c_ulong, + ByteOffset: *mut LARGE_INTEGER, + Key: *mut c_ulong, ) -> NTSTATUS; fn ZwWriteFileGather( FileHandle: HANDLE, Event: HANDLE, ApcRoutine: PIO_APC_ROUTINE, - ApcContext: PVOID, + ApcContext: *mut c_void, IoStatusBlock: PIO_STATUS_BLOCK, - SegmentArray: PFILE_SEGMENT_ELEMENT, - Length: ULONG, - ByteOffset: PLARGE_INTEGER, - Key: PULONG, + SegmentArray: *mut FILE_SEGMENT_ELEMENT, + Length: c_ulong, + ByteOffset: *mut LARGE_INTEGER, + Key: *mut c_ulong, ) -> NTSTATUS; fn ZwWriteRequestData( PortHandle: HANDLE, Message: PPORT_MESSAGE, - DataEntryIndex: ULONG, - Buffer: PVOID, - BufferSize: SIZE_T, - NumberOfBytesWritten: PSIZE_T, + DataEntryIndex: c_ulong, + Buffer: *mut c_void, + BufferSize: usize, + NumberOfBytesWritten: *mut usize, ) -> NTSTATUS; fn ZwWriteVirtualMemory( ProcessHandle: HANDLE, - BaseAddress: PVOID, - Buffer: PVOID, - BufferSize: SIZE_T, - NumberOfBytesWritten: PSIZE_T, + BaseAddress: *mut c_void, + Buffer: *mut c_void, + BufferSize: usize, + NumberOfBytesWritten: *mut usize, ) -> NTSTATUS; fn ZwYieldExecution() -> NTSTATUS; }} diff --git a/src/string.rs b/src/string.rs index 32bfa50..b0800b2 100644 --- a/src/string.rs +++ b/src/string.rs @@ -23,14 +23,17 @@ impl AsRef<[u16]> for UTF16Const { impl Copy for UTF16Const {} impl Clone for UTF16Const { #[inline] - fn clone(&self) -> UTF16Const { *self } + fn clone(&self) -> UTF16Const { + *self + } } /// A wrapper over UTF8 string constants. pub struct UTF8Const(pub &'static str); impl UTF8Const { #[inline] pub fn as_ptr(&self) -> *const i8 { - self.0.as_ptr() as *const i8 + // self.0.as_ptr() as *const i8 + self.0.as_ptr().cast::() } #[inline] pub fn as_mut_ptr(&self) -> *mut i8 { @@ -54,5 +57,7 @@ impl AsRef for UTF8Const { impl Copy for UTF8Const {} impl Clone for UTF8Const { #[inline] - fn clone(&self) -> UTF8Const { *self } + fn clone(&self) -> UTF8Const { + *self + } } diff --git a/src/subprocesstag.rs b/src/subprocesstag.rs index 7c8d17c..b14aad9 100644 --- a/src/subprocesstag.rs +++ b/src/subprocesstag.rs @@ -1,77 +1,83 @@ -use winapi::shared::minwindef::DWORD; -use winapi::shared::ntdef::{LPCWSTR, LPWSTR, PVOID}; -ENUM!{enum TAG_INFO_LEVEL { +use crate::ctypes::{c_ulong, c_void, wchar_t}; + +ENUM! {enum TAG_INFO_LEVEL { eTagInfoLevelNameFromTag = 1, eTagInfoLevelNamesReferencingModule = 2, eTagInfoLevelNameTagMapping = 3, eTagInfoLevelMax = 4, }} -ENUM!{enum TAG_TYPE { +ENUM! {enum TAG_TYPE { eTagTypeService = 1, eTagTypeMax = 2, }} -STRUCT!{struct TAG_INFO_NAME_FROM_TAG_IN_PARAMS { - dwPid: DWORD, - dwTag: DWORD, +STRUCT! {struct TAG_INFO_NAME_FROM_TAG_IN_PARAMS { + dwPid: c_ulong, + dwTag: c_ulong, }} -pub type PTAG_INFO_NAME_FROM_TAG_IN_PARAMS = *mut TAG_INFO_NAME_FROM_TAG_IN_PARAMS; -STRUCT!{struct TAG_INFO_NAME_FROM_TAG_OUT_PARAMS { - eTagType: DWORD, - pszName: LPWSTR, +pub type PTAG_INFO_NAME_FROM_TAG_IN_PARAMS = + *mut TAG_INFO_NAME_FROM_TAG_IN_PARAMS; +STRUCT! {struct TAG_INFO_NAME_FROM_TAG_OUT_PARAMS { + eTagType: c_ulong, + pszName: *mut wchar_t, }} -pub type PTAG_INFO_NAME_FROM_TAG_OUT_PARAMS = *mut TAG_INFO_NAME_FROM_TAG_OUT_PARAMS; -STRUCT!{struct TAG_INFO_NAME_FROM_TAG { +pub type PTAG_INFO_NAME_FROM_TAG_OUT_PARAMS = + *mut TAG_INFO_NAME_FROM_TAG_OUT_PARAMS; +STRUCT! {struct TAG_INFO_NAME_FROM_TAG { InParams: TAG_INFO_NAME_FROM_TAG_IN_PARAMS, OutParams: TAG_INFO_NAME_FROM_TAG_OUT_PARAMS, }} pub type PTAG_INFO_NAME_FROM_TAG = *mut TAG_INFO_NAME_FROM_TAG; -STRUCT!{struct TAG_INFO_NAMES_REFERENCING_MODULE_IN_PARAMS { - dwPid: DWORD, - pszModule: LPWSTR, +STRUCT! {struct TAG_INFO_NAMES_REFERENCING_MODULE_IN_PARAMS { + dwPid: c_ulong, + pszModule: *mut wchar_t, }} pub type PTAG_INFO_NAMES_REFERENCING_MODULE_IN_PARAMS = *mut TAG_INFO_NAMES_REFERENCING_MODULE_IN_PARAMS; -STRUCT!{struct TAG_INFO_NAMES_REFERENCING_MODULE_OUT_PARAMS { - eTagType: DWORD, - pmszNames: LPWSTR, +STRUCT! {struct TAG_INFO_NAMES_REFERENCING_MODULE_OUT_PARAMS { + eTagType: c_ulong, + pmszNames: *mut wchar_t, }} pub type PTAG_INFO_NAMES_REFERENCING_MODULE_OUT_PARAMS = *mut TAG_INFO_NAMES_REFERENCING_MODULE_OUT_PARAMS; -STRUCT!{struct TAG_INFO_NAMES_REFERENCING_MODULE { +STRUCT! {struct TAG_INFO_NAMES_REFERENCING_MODULE { InParams: TAG_INFO_NAMES_REFERENCING_MODULE_IN_PARAMS, OutParams: TAG_INFO_NAMES_REFERENCING_MODULE_OUT_PARAMS, }} -pub type PTAG_INFO_NAMES_REFERENCING_MODULE = *mut TAG_INFO_NAMES_REFERENCING_MODULE; -STRUCT!{struct TAG_INFO_NAME_TAG_MAPPING_IN_PARAMS { - dwPid: DWORD, +pub type PTAG_INFO_NAMES_REFERENCING_MODULE = + *mut TAG_INFO_NAMES_REFERENCING_MODULE; +STRUCT! {struct TAG_INFO_NAME_TAG_MAPPING_IN_PARAMS { + dwPid: c_ulong, }} -pub type PTAG_INFO_NAME_TAG_MAPPING_IN_PARAMS = *mut TAG_INFO_NAME_TAG_MAPPING_IN_PARAMS; -STRUCT!{struct TAG_INFO_NAME_TAG_MAPPING_ELEMENT { - eTagType: DWORD, - dwTag: DWORD, - pszName: LPWSTR, - pszGroupName: LPWSTR, +pub type PTAG_INFO_NAME_TAG_MAPPING_IN_PARAMS = + *mut TAG_INFO_NAME_TAG_MAPPING_IN_PARAMS; +STRUCT! {struct TAG_INFO_NAME_TAG_MAPPING_ELEMENT { + eTagType: c_ulong, + dwTag: c_ulong, + pszName: *mut wchar_t, + pszGroupName: *mut wchar_t, }} -pub type PTAG_INFO_NAME_TAG_MAPPING_ELEMENT = *mut TAG_INFO_NAME_TAG_MAPPING_ELEMENT; -STRUCT!{struct TAG_INFO_NAME_TAG_MAPPING_OUT_PARAMS { - cElements: DWORD, +pub type PTAG_INFO_NAME_TAG_MAPPING_ELEMENT = + *mut TAG_INFO_NAME_TAG_MAPPING_ELEMENT; +STRUCT! {struct TAG_INFO_NAME_TAG_MAPPING_OUT_PARAMS { + cElements: c_ulong, pNameTagMappingElements: PTAG_INFO_NAME_TAG_MAPPING_ELEMENT, }} -pub type PTAG_INFO_NAME_TAG_MAPPING_OUT_PARAMS = *mut TAG_INFO_NAME_TAG_MAPPING_OUT_PARAMS; -STRUCT!{struct TAG_INFO_NAME_TAG_MAPPING { +pub type PTAG_INFO_NAME_TAG_MAPPING_OUT_PARAMS = + *mut TAG_INFO_NAME_TAG_MAPPING_OUT_PARAMS; +STRUCT! {struct TAG_INFO_NAME_TAG_MAPPING { InParams: TAG_INFO_NAME_TAG_MAPPING_IN_PARAMS, pOutParams: PTAG_INFO_NAME_TAG_MAPPING_OUT_PARAMS, }} pub type PTAG_INFO_NAME_TAG_MAPPING = *mut TAG_INFO_NAME_TAG_MAPPING; -EXTERN!{extern "system" { +EXTERN! {extern "system" { fn I_QueryTagInformation( - pszMachineName: LPCWSTR, + pszMachineName: *const wchar_t, eInfoLevel: TAG_INFO_LEVEL, - pTagInfo: PVOID, - ) -> DWORD; + pTagInfo: *mut c_void, + ) -> c_ulong; }} -FN!{stdcall PQUERY_TAG_INFORMATION( - pszMachineName: LPCWSTR, +FN! {stdcall PQUERY_TAG_INFORMATION( + pszMachineName: *const wchar_t, eInfoLevel: TAG_INFO_LEVEL, - pTagInfo: PVOID, -) -> DWORD} + pTagInfo: *mut c_void, +) -> c_ulong} diff --git a/src/winapi_local.rs b/src/winapi_local.rs deleted file mode 100644 index 2aa6fdd..0000000 --- a/src/winapi_local.rs +++ /dev/null @@ -1 +0,0 @@ -pub mod um; diff --git a/src/winapi_local/um.rs b/src/winapi_local/um.rs deleted file mode 100644 index 5f862d5..0000000 --- a/src/winapi_local/um.rs +++ /dev/null @@ -1,2 +0,0 @@ -pub(crate) mod winioctl; -pub mod winnt; diff --git a/src/winapi_local/um/winioctl.rs b/src/winapi_local/um/winioctl.rs deleted file mode 100644 index da49026..0000000 --- a/src/winapi_local/um/winioctl.rs +++ /dev/null @@ -1,4 +0,0 @@ -#[inline] -pub(crate) const fn CTL_CODE(DeviceType: u32, Function: u32, Method: u32, Access: u32) -> u32 { - (DeviceType << 16) | (Access << 14) | (Function << 2) | Method -} diff --git a/src/winapi_local/um/winnt.rs b/src/winapi_local/um/winnt.rs deleted file mode 100644 index 0c8efb2..0000000 --- a/src/winapi_local/um/winnt.rs +++ /dev/null @@ -1,71 +0,0 @@ -use winapi::shared::basetsd::{DWORD64, SIZE_T, ULONG64}; -use winapi::shared::minwindef::DWORD; -use winapi::um::winnt::{HANDLE, PVOID}; -#[doc(hidden)] -#[inline] -pub const fn UInt32x32To64(a: u32, b: u32) -> u64 { - a as u64 * b as u64 -} -#[cfg(not(target_arch = "aarch64"))] -IFDEF!{ -use core::arch::asm; -use crate::ntpebteb::TEB; -#[inline] -pub unsafe fn __readfsdword(Offset: DWORD) -> DWORD { - let out: u32; - asm!( - "mov {:e}, fs:[{:e}]", - lateout(reg) out, - in(reg) Offset, - options(nostack, pure, readonly), - ); - out -} -#[inline] -#[cfg(target_pointer_width = "64")] -pub unsafe fn __readgsqword(Offset: DWORD) -> DWORD64 { - let out: u64; - asm!( - "mov {}, gs:[{:e}]", - lateout(reg) out, - in(reg) Offset, - options(nostack, pure, readonly), - ); - out -} -#[inline] #[allow(unused_unsafe)] -pub unsafe fn NtCurrentTeb() -> *mut TEB { - use winapi::um::winnt::NT_TIB; - let teb_offset = FIELD_OFFSET!(NT_TIB, _Self) as u32; - #[cfg(target_arch = "x86_64")] { - __readgsqword(teb_offset) as *mut TEB - } - #[cfg(target_arch = "x86")] { - __readfsdword(teb_offset) as *mut TEB - } -} -} -ENUM!{enum MEM_EXTENDED_PARAMETER_TYPE { - MemExtendedParameterInvalidType = 0, - MemExtendedParameterAddressRequirements = 1, - MemExtendedParameterNumaNode = 2, - MemExtendedParameterPartitionHandle = 3, - MemExtendedParameterMax = 4, -}} -pub type PMEM_EXTENDED_PARAMETER_TYPE = *mut MEM_EXTENDED_PARAMETER_TYPE; -UNION!{union MEM_EXTENDED_PARAMETER_u { - ULong64: DWORD64, - Pointer: PVOID, - Size: SIZE_T, - Handle: HANDLE, - ULong: DWORD, -}} -STRUCT!{struct MEM_EXTENDED_PARAMETER { - BitFields: ULONG64, - u: MEM_EXTENDED_PARAMETER_u, -}} -BITFIELD!{MEM_EXTENDED_PARAMETER BitFields: ULONG64 [ - Type set_Type[0..8], - Reserved set_Reserved[8..64], -]} -pub type PMEM_EXTENDED_PARAMETER = *mut MEM_EXTENDED_PARAMETER; diff --git a/src/windows_local/mod.rs b/src/windows_local/mod.rs new file mode 100644 index 0000000..06746ae --- /dev/null +++ b/src/windows_local/mod.rs @@ -0,0 +1,8 @@ +pub mod shared { + pub mod ntdef; +} + +pub mod um { + pub(crate) mod winioctl; + pub mod winnt; +} diff --git a/src/windows_local/shared/ntdef.rs b/src/windows_local/shared/ntdef.rs new file mode 100644 index 0000000..f1215d8 --- /dev/null +++ b/src/windows_local/shared/ntdef.rs @@ -0,0 +1,30 @@ +use crate::ctypes::{c_long, c_longlong, c_ulong, c_ulonglong}; + +UNION! {union LARGE_INTEGER { + [i64; 1], + s s_mut: LARGE_INTEGER_s, + u u_mut: LARGE_INTEGER_u, + QuadPart QuadPart_mut: c_longlong, +}} +STRUCT! {struct LARGE_INTEGER_s { + LowPart: c_ulong, + HighPart: c_long, +}} +STRUCT! {struct LARGE_INTEGER_u { + LowPart: c_ulong, + HighPart: c_long, +}} +UNION! {union ULARGE_INTEGER { + [u64; 1], + s s_mut: ULARGE_INTEGER_s, + u u_mut: ULARGE_INTEGER_s, + QuadPart QuadPart_mut: c_ulonglong, +}} +STRUCT! {struct ULARGE_INTEGER_s { + LowPart: c_ulong, + HighPart: c_ulong, +}} +STRUCT! {struct ULARGE_INTEGER_u { + LowPart: c_ulong, + HighPart: c_ulong, +}} diff --git a/src/windows_local/um/winioctl.rs b/src/windows_local/um/winioctl.rs new file mode 100644 index 0000000..f754161 --- /dev/null +++ b/src/windows_local/um/winioctl.rs @@ -0,0 +1,9 @@ +#[inline] +pub(crate) const fn CTL_CODE( + DeviceType: u32, + Function: u32, + Method: u32, + Access: u32, +) -> u32 { + (DeviceType << 16) | (Access << 14) | (Function << 2) | Method +} diff --git a/src/windows_local/um/winnt.rs b/src/windows_local/um/winnt.rs new file mode 100644 index 0000000..81db2bc --- /dev/null +++ b/src/windows_local/um/winnt.rs @@ -0,0 +1,77 @@ +use windows_sys::Win32::Foundation::HANDLE; + +use crate::ctypes::{__uint64, c_ulong, c_void}; + +#[doc(hidden)] +#[inline] +pub const fn UInt32x32To64(a: u32, b: u32) -> u64 { + a as u64 * b as u64 +} +#[cfg(not(target_arch = "aarch64"))] +IFDEF! { + use core::arch::asm; + use crate::ntpebteb::TEB; + + #[inline] + pub unsafe fn __readfsdword(Offset: c_ulong) -> c_ulong { + let out: u32; + asm!( + "mov {:e}, fs:[{:e}]", + lateout(reg) out, + in(reg) Offset, + options(nostack, pure, readonly), + ); + out + } + #[inline] + #[cfg(target_pointer_width = "64")] + pub unsafe fn __readgsqword(Offset: c_ulong) -> __uint64 { + let out: u64; + asm!( + "mov {}, gs:[{:e}]", + lateout(reg) out, + in(reg) Offset, + options(nostack, pure, readonly), + ); + out + } + #[inline] #[allow(unused_unsafe)] + pub unsafe fn NtCurrentTeb() -> *mut TEB { + use windows_sys::Win32::System::Kernel::NT_TIB; + + let teb_offset = FIELD_OFFSET!(NT_TIB, Self_) as u32; + #[cfg(target_arch = "x86_64")] { + __readgsqword(teb_offset) as *mut TEB + } + #[cfg(target_arch = "x86")] { + __readfsdword(teb_offset) as *mut TEB + } + } +} +STRUCT! {struct ACTIVATION_CONTEXT { + dummy: *mut c_void, +}} +ENUM! {enum MEM_EXTENDED_PARAMETER_TYPE { + MemExtendedParameterInvalidType = 0, + MemExtendedParameterAddressRequirements = 1, + MemExtendedParameterNumaNode = 2, + MemExtendedParameterPartitionHandle = 3, + MemExtendedParameterMax = 4, +}} +pub type PMEM_EXTENDED_PARAMETER_TYPE = *mut MEM_EXTENDED_PARAMETER_TYPE; +UNION! {union MEM_EXTENDED_PARAMETER_u { + ULong64: __uint64, + Pointer: *mut c_void, + Size: usize, + Handle: HANDLE, + ULong: c_ulong, +}} +STRUCT! {struct MEM_EXTENDED_PARAMETER { + BitFields: __uint64, + u: MEM_EXTENDED_PARAMETER_u, +}} +BITFIELD! {MEM_EXTENDED_PARAMETER BitFields: __uint64 [ + Type set_Type[0..8], + Reserved set_Reserved[8..64], +]} +pub type PMEM_EXTENDED_PARAMETER = *mut MEM_EXTENDED_PARAMETER; diff --git a/src/winsta.rs b/src/winsta.rs index 162316d..891c46d 100644 --- a/src/winsta.rs +++ b/src/winsta.rs @@ -1,13 +1,16 @@ use core::ptr::null_mut; -use crate::ntrtl::RTL_TIME_ZONE_INFORMATION; -use winapi::shared::basetsd::SIZE_T; -use winapi::shared::minwindef::{BYTE, DWORD, FILETIME}; -use winapi::shared::ntdef::{ - BOOLEAN, CHAR, HANDLE, LARGE_INTEGER, LONG, PULONG, PVOID, PWSTR, UCHAR, ULONG, UNICODE_STRING, - USHORT, WCHAR, + +use windows_sys::Win32::{ + Foundation::{FILETIME, HANDLE, HWND, PSID, UNICODE_STRING}, + Storage::FileSystem::STANDARD_RIGHTS_REQUIRED, }; -use winapi::shared::windef::HWND; -use winapi::um::winnt::{PSID, STANDARD_RIGHTS_REQUIRED}; + +use crate::{ + ctypes::{c_char, c_long, c_uchar, c_ulong, c_ushort, c_void, wchar_t}, + ntrtl::RTL_TIME_ZONE_INFORMATION, + windows_local::shared::ntdef::LARGE_INTEGER, +}; + pub const WINSTATION_QUERY: u32 = 0x00000001; pub const WINSTATION_SET: u32 = 0x00000002; pub const WINSTATION_RESET: u32 = 0x00000004; @@ -19,14 +22,25 @@ pub const WINSTATION_MSG: u32 = 0x00000080; pub const WINSTATION_CONNECT: u32 = 0x00000100; pub const WINSTATION_DISCONNECT: u32 = 0x00000200; pub const WINSTATION_GUEST_ACCESS: u32 = WINSTATION_LOGON; -pub const WINSTATION_CURRENT_GUEST_ACCESS: u32 = WINSTATION_VIRTUAL | WINSTATION_LOGOFF; +pub const WINSTATION_CURRENT_GUEST_ACCESS: u32 = + WINSTATION_VIRTUAL | WINSTATION_LOGOFF; pub const WINSTATION_USER_ACCESS: u32 = WINSTATION_GUEST_ACCESS | WINSTATION_QUERY | WINSTATION_CONNECT; -pub const WINSTATION_CURRENT_USER_ACCESS: u32 = WINSTATION_SET | WINSTATION_RESET - | WINSTATION_VIRTUAL | WINSTATION_LOGOFF | WINSTATION_DISCONNECT; -pub const WINSTATION_ALL_ACCESS: u32 = STANDARD_RIGHTS_REQUIRED | WINSTATION_QUERY | WINSTATION_SET - | WINSTATION_RESET | WINSTATION_VIRTUAL | WINSTATION_SHADOW | WINSTATION_LOGON | WINSTATION_MSG - | WINSTATION_CONNECT | WINSTATION_DISCONNECT; +pub const WINSTATION_CURRENT_USER_ACCESS: u32 = WINSTATION_SET + | WINSTATION_RESET + | WINSTATION_VIRTUAL + | WINSTATION_LOGOFF + | WINSTATION_DISCONNECT; +pub const WINSTATION_ALL_ACCESS: u32 = STANDARD_RIGHTS_REQUIRED + | WINSTATION_QUERY + | WINSTATION_SET + | WINSTATION_RESET + | WINSTATION_VIRTUAL + | WINSTATION_SHADOW + | WINSTATION_LOGON + | WINSTATION_MSG + | WINSTATION_CONNECT + | WINSTATION_DISCONNECT; pub const WDPREFIX_LENGTH: usize = 12; pub const CALLBACK_LENGTH: usize = 50; pub const DLLNAME_LENGTH: usize = 32; @@ -70,13 +84,13 @@ pub const TERMSRV_CURRENT_TERMINATING_SESSIONS: u32 = 11; pub const TERMSRV_CURRENT_LOGGEDON_SESSIONS: u32 = 12; pub type PTS_TIME_ZONE_INFORMATION = *mut RTL_TIME_ZONE_INFORMATION; pub type TS_TIME_ZONE_INFORMATION = RTL_TIME_ZONE_INFORMATION; -pub type WINSTATIONNAME = [WCHAR; WINSTATIONNAME_LENGTH + 1]; -STRUCT!{struct VARDATA_WIRE { - Size: USHORT, - Offset: USHORT, +pub type WINSTATIONNAME = [wchar_t; WINSTATIONNAME_LENGTH + 1]; +STRUCT! {struct VARDATA_WIRE { + Size: c_ushort, + Offset: c_ushort, }} pub type PVARDATA_WIRE = *mut VARDATA_WIRE; -ENUM!{enum WINSTATIONSTATECLASS { +ENUM! {enum WINSTATIONSTATECLASS { State_Active = 0, State_Connected = 1, State_ConnectQuery = 2, @@ -88,17 +102,17 @@ ENUM!{enum WINSTATIONSTATECLASS { State_Down = 8, State_Init = 9, }} -UNION!{union SESSIONIDW_u { - SessionId: ULONG, - LogonId: ULONG, +UNION! {union SESSIONIDW_u { + SessionId: c_ulong, + LogonId: c_ulong, }} -STRUCT!{struct SESSIONIDW { +STRUCT! {struct SESSIONIDW { u: SESSIONIDW_u, WinStationName: WINSTATIONNAME, State: WINSTATIONSTATECLASS, }} pub type PSESSIONIDW = *mut SESSIONIDW; -ENUM!{enum WINSTATIONINFOCLASS { +ENUM! {enum WINSTATIONINFOCLASS { WinStationCreateData = 0, WinStationConfiguration = 1, WinStationPdParams = 2, @@ -142,56 +156,56 @@ ENUM!{enum WINSTATIONINFOCLASS { WinStationInformationEx = 40, WinStationValidationInfo = 41, }} -STRUCT!{struct WINSTATIONCREATE { - Bitfields: ULONG, - MaxInstanceCount: ULONG, +STRUCT! {struct WINSTATIONCREATE { + Bitfields: c_ulong, + MaxInstanceCount: c_ulong, }} -BITFIELD!{WINSTATIONCREATE Bitfields: ULONG [ +BITFIELD! {WINSTATIONCREATE Bitfields: c_ulong [ fEnableWinStation set_fEnableWinStation[0..1], ]} pub type PWINSTATIONCREATE = *mut WINSTATIONCREATE; -STRUCT!{struct WINSTACONFIGWIRE { - Comment: [WCHAR; 61], - OEMId: [CHAR; 4], +STRUCT! {struct WINSTACONFIGWIRE { + Comment: [wchar_t; 61], + OEMId: [c_char; 4], UserConfig: VARDATA_WIRE, NewFields: VARDATA_WIRE, }} pub type PWINSTACONFIGWIRE = *mut WINSTACONFIGWIRE; -ENUM!{enum CALLBACKCLASS { +ENUM! {enum CALLBACKCLASS { Callback_Disable = 0, Callback_Roving = 1, Callback_Fixed = 2, }} -ENUM!{enum SHADOWCLASS { +ENUM! {enum SHADOWCLASS { Shadow_Disable = 0, Shadow_EnableInputNotify = 1, Shadow_EnableInputNoNotify = 2, Shadow_EnableNoInputNotify = 3, Shadow_EnableNoInputNoNotify = 4, }} -STRUCT!{struct USERCONFIG { - Bitfields: ULONG, - Bitfields2: ULONG, - UserName: [WCHAR; USERNAME_LENGTH + 1], - Domain: [WCHAR; DOMAIN_LENGTH + 1], - Password: [WCHAR; PASSWORD_LENGTH + 1], - WorkDirectory: [WCHAR; DIRECTORY_LENGTH + 1], - InitialProgram: [WCHAR; INITIALPROGRAM_LENGTH + 1], - CallbackNumber: [WCHAR; CALLBACK_LENGTH + 1], +STRUCT! {struct USERCONFIG { + Bitfields: c_ulong, + Bitfields2: c_ulong, + UserName: [wchar_t; USERNAME_LENGTH + 1], + Domain: [wchar_t; DOMAIN_LENGTH + 1], + Password: [wchar_t; PASSWORD_LENGTH + 1], + WorkDirectory: [wchar_t; DIRECTORY_LENGTH + 1], + InitialProgram: [wchar_t; INITIALPROGRAM_LENGTH + 1], + CallbackNumber: [wchar_t; CALLBACK_LENGTH + 1], Callback: CALLBACKCLASS, Shadow: SHADOWCLASS, - MaxConnectionTime: ULONG, - MaxDisconnectionTime: ULONG, - MaxIdleTime: ULONG, - KeyboardLayout: ULONG, - MinEncryptionLevel: BYTE, - NWLogonServer: [WCHAR; NASIFILESERVER_LENGTH + 1], - PublishedName: [WCHAR; MAX_BR_NAME], - WFProfilePath: [WCHAR; DIRECTORY_LENGTH + 1], - WFHomeDir: [WCHAR; DIRECTORY_LENGTH + 1], - WFHomeDirDrive: [WCHAR; 4], -}} -BITFIELD!{USERCONFIG Bitfields: ULONG [ + MaxConnectionTime: c_ulong, + MaxDisconnectionTime: c_ulong, + MaxIdleTime: c_ulong, + KeyboardLayout: c_ulong, + MinEncryptionLevel: c_uchar, + NWLogonServer: [wchar_t; NASIFILESERVER_LENGTH + 1], + PublishedName: [wchar_t; MAX_BR_NAME], + WFProfilePath: [wchar_t; DIRECTORY_LENGTH + 1], + WFHomeDir: [wchar_t; DIRECTORY_LENGTH + 1], + WFHomeDirDrive: [wchar_t; 4], +}} +BITFIELD! {USERCONFIG Bitfields: c_ulong [ fInheritAutoLogon set_fInheritAutoLogon[0..1], fInheritResetBroken set_fInheritResetBroken[1..2], fInheritReconnectSame set_fInheritReconnectSame[2..3], @@ -225,7 +239,7 @@ BITFIELD!{USERCONFIG Bitfields: ULONG [ fDisableCdm set_fDisableCdm[30..31], fDisableCcm set_fDisableCcm[31..32], ]} -BITFIELD!{USERCONFIG Bitfields2: ULONG [ +BITFIELD! {USERCONFIG Bitfields2: c_ulong [ fDisableLPT set_fDisableLPT[0..1], fDisableClip set_fDisableClip[1..2], fDisableExe set_fDisableExe[2..3], @@ -238,47 +252,47 @@ BITFIELD!{USERCONFIG Bitfields2: ULONG [ fDisablePNPRedir set_fDisablePNPRedir[9..10], ]} pub type PUSERCONFIG = *mut USERCONFIG; -ENUM!{enum SDCLASS { +ENUM! {enum SDCLASS { SdNone = 0, SdConsole = 1, SdNetwork = 2, SdAsync = 3, SdOemTransport = 4, }} -pub type DEVICENAME = [WCHAR; DEVICENAME_LENGTH + 1]; -pub type MODEMNAME = [WCHAR; MODEMNAME_LENGTH + 1]; -pub type NASISPECIFICNAME = [WCHAR; NASISPECIFICNAME_LENGTH + 1]; -pub type NASIUSERNAME = [WCHAR; NASIUSERNAME_LENGTH + 1]; -pub type NASIPASSWORD = [WCHAR; NASIPASSWORD_LENGTH + 1]; -pub type NASISESIONNAME = [WCHAR; NASISESSIONNAME_LENGTH + 1]; -pub type NASIFILESERVER = [WCHAR; NASIFILESERVER_LENGTH + 1]; -pub type WDNAME = [WCHAR; WDNAME_LENGTH + 1]; -pub type WDPREFIX = [WCHAR; WDPREFIX_LENGTH + 1]; -pub type CDNAME = [WCHAR; CDNAME_LENGTH + 1]; -pub type DLLNAME = [WCHAR; DLLNAME_LENGTH + 1]; -pub type PDNAME = [WCHAR; PDNAME_LENGTH + 1]; -STRUCT!{struct NETWORKCONFIG { - LanAdapter: LONG, +pub type DEVICENAME = [wchar_t; DEVICENAME_LENGTH + 1]; +pub type MODEMNAME = [wchar_t; MODEMNAME_LENGTH + 1]; +pub type NASISPECIFICNAME = [wchar_t; NASISPECIFICNAME_LENGTH + 1]; +pub type NASIUSERNAME = [wchar_t; NASIUSERNAME_LENGTH + 1]; +pub type NASIPASSWORD = [wchar_t; NASIPASSWORD_LENGTH + 1]; +pub type NASISESIONNAME = [wchar_t; NASISESSIONNAME_LENGTH + 1]; +pub type NASIFILESERVER = [wchar_t; NASIFILESERVER_LENGTH + 1]; +pub type WDNAME = [wchar_t; WDNAME_LENGTH + 1]; +pub type WDPREFIX = [wchar_t; WDPREFIX_LENGTH + 1]; +pub type CDNAME = [wchar_t; CDNAME_LENGTH + 1]; +pub type DLLNAME = [wchar_t; DLLNAME_LENGTH + 1]; +pub type PDNAME = [wchar_t; PDNAME_LENGTH + 1]; +STRUCT! {struct NETWORKCONFIG { + LanAdapter: c_long, NetworkName: DEVICENAME, - Flags: ULONG, + Flags: c_ulong, }} pub type PNETWORKCONFIG = *mut NETWORKCONFIG; -ENUM!{enum FLOWCONTROLCLASS { +ENUM! {enum FLOWCONTROLCLASS { FlowControl_None = 0, FlowControl_Hardware = 1, FlowControl_Software = 2, }} -ENUM!{enum RECEIVEFLOWCONTROLCLASS { +ENUM! {enum RECEIVEFLOWCONTROLCLASS { ReceiveFlowControl_None = 0, ReceiveFlowControl_RTS = 1, ReceiveFlowControl_DTR = 2, }} -ENUM!{enum TRANSMITFLOWCONTROLCLASS { +ENUM! {enum TRANSMITFLOWCONTROLCLASS { TransmitFlowControl_None = 0, TransmitFlowControl_CTS = 1, TransmitFlowControl_DSR = 2, }} -ENUM!{enum ASYNCCONNECTCLASS { +ENUM! {enum ASYNCCONNECTCLASS { Connect_CTS = 0, Connect_DSR = 1, Connect_RI = 2, @@ -286,132 +300,132 @@ ENUM!{enum ASYNCCONNECTCLASS { Connect_FirstChar = 4, Connect_Perm = 5, }} -STRUCT!{struct FLOWCONTROLCONFIG { - Bitfields: ULONG, - XonChar: CHAR, - XoffChar: CHAR, +STRUCT! {struct FLOWCONTROLCONFIG { + Bitfields: c_ulong, + XonChar: c_char, + XoffChar: c_char, Type: FLOWCONTROLCLASS, HardwareReceive: RECEIVEFLOWCONTROLCLASS, HardwareTransmit: TRANSMITFLOWCONTROLCLASS, }} -BITFIELD!{FLOWCONTROLCONFIG Bitfields: ULONG [ +BITFIELD! {FLOWCONTROLCONFIG Bitfields: c_ulong [ fEnableSoftwareTx set_fEnableSoftwareTx[0..1], fEnableSoftwareRx set_fEnableSoftwareRx[1..2], fEnableDTR set_fEnableDTR[2..3], fEnableRTS set_fEnableRTS[3..4], ]} pub type PFLOWCONTROLCONFIG = *mut FLOWCONTROLCONFIG; -STRUCT!{struct CONNECTCONFIG { +STRUCT! {struct CONNECTCONFIG { Type: ASYNCCONNECTCLASS, - Bitfields: ULONG, + Bitfields: c_ulong, }} -BITFIELD!{CONNECTCONFIG Bitfields: ULONG [ +BITFIELD! {CONNECTCONFIG Bitfields: c_ulong [ fEnableBreakDisconnect set_fEnableBreakDisconnect[0..1], ]} pub type PCONNECTCONFIG = *mut CONNECTCONFIG; -STRUCT!{struct ASYNCCONFIG { +STRUCT! {struct ASYNCCONFIG { DeviceName: DEVICENAME, ModemName: MODEMNAME, - BaudRate: ULONG, - Parity: ULONG, - StopBits: ULONG, - ByteSize: ULONG, - Bitfields: ULONG, + BaudRate: c_ulong, + Parity: c_ulong, + StopBits: c_ulong, + ByteSize: c_ulong, + Bitfields: c_ulong, FlowControl: FLOWCONTROLCONFIG, Connect: CONNECTCONFIG, }} -BITFIELD!{ASYNCCONFIG Bitfields: ULONG [ +BITFIELD! {ASYNCCONFIG Bitfields: c_ulong [ fEnableDsrSensitivity set_fEnableDsrSensitivity[0..1], fConnectionDriver set_fConnectionDriver[1..2], ]} pub type PASYNCCONFIG = *mut ASYNCCONFIG; -STRUCT!{struct NASICONFIG { +STRUCT! {struct NASICONFIG { SpecificName: NASISPECIFICNAME, UserName: NASIUSERNAME, PassWord: NASIPASSWORD, SessionName: NASISESIONNAME, FileServer: NASIFILESERVER, - GlobalSession: BOOLEAN, + GlobalSession: c_uchar, }} pub type PNASICONFIG = *mut NASICONFIG; -STRUCT!{struct OEMTDCONFIG { - Adapter: LONG, +STRUCT! {struct OEMTDCONFIG { + Adapter: c_long, DeviceName: DEVICENAME, - Flags: ULONG, + Flags: c_ulong, }} pub type POEMTDCONFIG = *mut OEMTDCONFIG; -UNION!{union PDPARAMS_u { +UNION! {union PDPARAMS_u { Network: NETWORKCONFIG, Async: ASYNCCONFIG, Nasi: NASICONFIG, OemTd: OEMTDCONFIG, }} -STRUCT!{struct PDPARAMS { +STRUCT! {struct PDPARAMS { SdClass: SDCLASS, u: PDPARAMS_u, }} pub type PPDPARAMS = *mut PDPARAMS; -STRUCT!{struct WDCONFIG { +STRUCT! {struct WDCONFIG { WdName: WDNAME, WdDLL: DLLNAME, WsxDLL: DLLNAME, - WdFlag: ULONG, - WdInputBufferLength: ULONG, + WdFlag: c_ulong, + WdInputBufferLength: c_ulong, CfgDLL: DLLNAME, WdPrefix: WDPREFIX, }} pub type PWDCONFIG = *mut WDCONFIG; -STRUCT!{struct PDCONFIG2 { +STRUCT! {struct PDCONFIG2 { PdName: PDNAME, SdClass: SDCLASS, PdDLL: DLLNAME, - PdFlag: ULONG, - OutBufLength: ULONG, - OutBufCount: ULONG, - OutBufDelay: ULONG, - InteractiveDelay: ULONG, - PortNumber: ULONG, - KeepAliveTimeout: ULONG, + PdFlag: c_ulong, + OutBufLength: c_ulong, + OutBufCount: c_ulong, + OutBufDelay: c_ulong, + InteractiveDelay: c_ulong, + PortNumber: c_ulong, + KeepAliveTimeout: c_ulong, }} pub type PPDCONFIG2 = *mut PDCONFIG2; -STRUCT!{struct WINSTATIONCLIENT { - Bitfields: ULONG, - ClientName: [WCHAR; CLIENTNAME_LENGTH + 1], - Domain: [WCHAR; DOMAIN_LENGTH + 1], - UserName: [WCHAR; USERNAME_LENGTH + 1], - Password: [WCHAR; PASSWORD_LENGTH + 1], - WorkDirectory: [WCHAR; DIRECTORY_LENGTH + 1], - InitialProgram: [WCHAR; INITIALPROGRAM_LENGTH + 1], - SerialNumber: ULONG, - EncryptionLevel: BYTE, - ClientAddressFamily: ULONG, - ClientAddress: [WCHAR; CLIENTADDRESS_LENGTH + 1], - HRes: USHORT, - VRes: USHORT, - ColorDepth: USHORT, - ProtocolType: USHORT, - KeyboardLayout: ULONG, - KeyboardType: ULONG, - KeyboardSubType: ULONG, - KeyboardFunctionKey: ULONG, - ImeFileName: [WCHAR; IMEFILENAME_LENGTH + 1], - ClientDirectory: [WCHAR; DIRECTORY_LENGTH + 1], - ClientLicense: [WCHAR; CLIENTLICENSE_LENGTH + 1], - ClientModem: [WCHAR; CLIENTMODEM_LENGTH + 1], - ClientBuildNumber: ULONG, - ClientHardwareId: ULONG, - ClientProductId: USHORT, - OutBufCountHost: USHORT, - OutBufCountClient: USHORT, - OutBufLength: USHORT, - AudioDriverName: [WCHAR; 9], +STRUCT! {struct WINSTATIONCLIENT { + Bitfields: c_ulong, + ClientName: [wchar_t; CLIENTNAME_LENGTH + 1], + Domain: [wchar_t; DOMAIN_LENGTH + 1], + UserName: [wchar_t; USERNAME_LENGTH + 1], + Password: [wchar_t; PASSWORD_LENGTH + 1], + WorkDirectory: [wchar_t; DIRECTORY_LENGTH + 1], + InitialProgram: [wchar_t; INITIALPROGRAM_LENGTH + 1], + SerialNumber: c_ulong, + EncryptionLevel: c_uchar, + ClientAddressFamily: c_ulong, + ClientAddress: [wchar_t; CLIENTADDRESS_LENGTH + 1], + HRes: c_ushort, + VRes: c_ushort, + ColorDepth: c_ushort, + ProtocolType: c_ushort, + KeyboardLayout: c_ulong, + KeyboardType: c_ulong, + KeyboardSubType: c_ulong, + KeyboardFunctionKey: c_ulong, + ImeFileName: [wchar_t; IMEFILENAME_LENGTH + 1], + ClientDirectory: [wchar_t; DIRECTORY_LENGTH + 1], + ClientLicense: [wchar_t; CLIENTLICENSE_LENGTH + 1], + ClientModem: [wchar_t; CLIENTMODEM_LENGTH + 1], + ClientBuildNumber: c_ulong, + ClientHardwareId: c_ulong, + ClientProductId: c_ushort, + OutBufCountHost: c_ushort, + OutBufCountClient: c_ushort, + OutBufLength: c_ushort, + AudioDriverName: [wchar_t; 9], ClientTimeZone: TS_TIME_ZONE_INFORMATION, - ClientSessionId: ULONG, - ClientDigProductId: [WCHAR; CLIENT_PRODUCT_ID_LENGTH], - PerformanceFlags: ULONG, - ActiveInputLocale: ULONG, + ClientSessionId: c_ulong, + ClientDigProductId: [wchar_t; CLIENT_PRODUCT_ID_LENGTH], + PerformanceFlags: c_ulong, + ActiveInputLocale: c_ulong, }} -BITFIELD!{WINSTATIONCLIENT Bitfields: ULONG [ +BITFIELD! {WINSTATIONCLIENT Bitfields: c_ulong [ fTextOnly set_fTextOnly[0..1], fDisableCtrlAltDel set_fDisableCtrlAltDel[1..2], fMouse set_fMouse[2..3], @@ -426,113 +440,113 @@ BITFIELD!{WINSTATIONCLIENT Bitfields: ULONG [ fUsingSavedCreds set_fUsingSavedCreds[11..12], ]} pub type PWINSTATIONCLIENT = *mut WINSTATIONCLIENT; -STRUCT!{struct TSHARE_COUNTERS { - Reserved: ULONG, +STRUCT! {struct TSHARE_COUNTERS { + Reserved: c_ulong, }} pub type PTSHARE_COUNTERS = *mut TSHARE_COUNTERS; -UNION!{union PROTOCOLCOUNTERS_Specific { +UNION! {union PROTOCOLCOUNTERS_Specific { TShareCounters: TSHARE_COUNTERS, - Reserved: [ULONG; 100], -}} -STRUCT!{struct PROTOCOLCOUNTERS { - WdBytes: ULONG, - WdFrames: ULONG, - WaitForOutBuf: ULONG, - Frames: ULONG, - Bytes: ULONG, - CompressedBytes: ULONG, - CompressFlushes: ULONG, - Errors: ULONG, - Timeouts: ULONG, - AsyncFramingError: ULONG, - AsyncOverrunError: ULONG, - AsyncOverflowError: ULONG, - AsyncParityError: ULONG, - TdErrors: ULONG, - ProtocolType: USHORT, - Length: USHORT, + Reserved: [c_ulong; 100], +}} +STRUCT! {struct PROTOCOLCOUNTERS { + WdBytes: c_ulong, + WdFrames: c_ulong, + WaitForOutBuf: c_ulong, + Frames: c_ulong, + Bytes: c_ulong, + CompressedBytes: c_ulong, + CompressFlushes: c_ulong, + Errors: c_ulong, + Timeouts: c_ulong, + AsyncFramingError: c_ulong, + AsyncOverrunError: c_ulong, + AsyncOverflowError: c_ulong, + AsyncParityError: c_ulong, + TdErrors: c_ulong, + ProtocolType: c_ushort, + Length: c_ushort, Specific: PROTOCOLCOUNTERS_Specific, }} pub type PPROTOCOLCOUNTERS = *mut PROTOCOLCOUNTERS; -STRUCT!{struct THINWIRECACHE { - CacheReads: ULONG, - CacheHits: ULONG, +STRUCT! {struct THINWIRECACHE { + CacheReads: c_ulong, + CacheHits: c_ulong, }} pub type PTHINWIRECACHE = *mut THINWIRECACHE; pub const MAX_THINWIRECACHE: usize = 4; -STRUCT!{struct RESERVED_CACHE { +STRUCT! {struct RESERVED_CACHE { ThinWireCache: [THINWIRECACHE; MAX_THINWIRECACHE], }} pub type PRESERVED_CACHE = *mut RESERVED_CACHE; -STRUCT!{struct TSHARE_CACHE { - Reserved: ULONG, +STRUCT! {struct TSHARE_CACHE { + Reserved: c_ulong, }} pub type PTSHARE_CACHE = *mut TSHARE_CACHE; -UNION!{union CACHE_STATISTICS_Specific { +UNION! {union CACHE_STATISTICS_Specific { ReservedCacheStats: RESERVED_CACHE, TShareCacheStats: TSHARE_CACHE, - Reserved: [ULONG; 20], + Reserved: [c_ulong; 20], }} -STRUCT!{struct CACHE_STATISTICS { - ProtocolType: USHORT, - Length: USHORT, +STRUCT! {struct CACHE_STATISTICS { + ProtocolType: c_ushort, + Length: c_ushort, Specific: CACHE_STATISTICS_Specific, }} pub type PCACHE_STATISTICS = *mut CACHE_STATISTICS; -STRUCT!{struct PROTOCOLSTATUS { +STRUCT! {struct PROTOCOLSTATUS { Output: PROTOCOLCOUNTERS, Input: PROTOCOLCOUNTERS, Cache: CACHE_STATISTICS, - AsyncSignal: ULONG, - AsyncSignalMask: ULONG, + AsyncSignal: c_ulong, + AsyncSignalMask: c_ulong, }} pub type PPROTOCOLSTATUS = *mut PROTOCOLSTATUS; -STRUCT!{struct WINSTATIONINFORMATION { +STRUCT! {struct WINSTATIONINFORMATION { ConnectState: WINSTATIONSTATECLASS, WinStationName: WINSTATIONNAME, - LogonId: ULONG, + LogonId: c_ulong, ConnectTime: LARGE_INTEGER, DisconnectTime: LARGE_INTEGER, LastInputTime: LARGE_INTEGER, LogonTime: LARGE_INTEGER, Status: PROTOCOLSTATUS, - Domain: [WCHAR; DOMAIN_LENGTH + 1], - UserName: [WCHAR; USERNAME_LENGTH + 1], + Domain: [wchar_t; DOMAIN_LENGTH + 1], + UserName: [wchar_t; USERNAME_LENGTH + 1], CurrentTime: LARGE_INTEGER, }} pub type PWINSTATIONINFORMATION = *mut WINSTATIONINFORMATION; -STRUCT!{struct WINSTATIONUSERTOKEN { +STRUCT! {struct WINSTATIONUSERTOKEN { ProcessId: HANDLE, ThreadId: HANDLE, UserToken: HANDLE, }} pub type PWINSTATIONUSERTOKEN = *mut WINSTATIONUSERTOKEN; -STRUCT!{struct WINSTATIONVIDEODATA { - HResolution: USHORT, - VResolution: USHORT, - fColorDepth: USHORT, +STRUCT! {struct WINSTATIONVIDEODATA { + HResolution: c_ushort, + VResolution: c_ushort, + fColorDepth: c_ushort, }} pub type PWINSTATIONVIDEODATA = *mut WINSTATIONVIDEODATA; -ENUM!{enum CDCLASS { +ENUM! {enum CDCLASS { CdNone = 0, CdModem = 1, CdClass_Maximum = 2, }} -STRUCT!{struct CDCONFIG { +STRUCT! {struct CDCONFIG { CdClass: CDCLASS, CdName: CDNAME, CdDLL: DLLNAME, - CdFlag: ULONG, + CdFlag: c_ulong, }} pub type PCDCONFIG = *mut CDCONFIG; -pub type CLIENTDATANAME = [CHAR; CLIENTDATANAME_LENGTH + 1]; -pub type PCLIENTDATANAME = *mut CHAR; -STRUCT!{struct WINSTATIONCLIENTDATA { +pub type CLIENTDATANAME = [c_char; CLIENTDATANAME_LENGTH + 1]; +pub type PCLIENTDATANAME = *mut c_char; +STRUCT! {struct WINSTATIONCLIENTDATA { DataName: CLIENTDATANAME, - fUnicodeData: BOOLEAN, + fUnicodeData: c_uchar, }} pub type PWINSTATIONCLIENTDATA = *mut WINSTATIONCLIENTDATA; -ENUM!{enum LOADFACTORTYPE { +ENUM! {enum LOADFACTORTYPE { ErrorConstraint = 0, PagedPoolConstraint = 1, NonPagedPoolConstraint = 2, @@ -540,65 +554,65 @@ ENUM!{enum LOADFACTORTYPE { SystemPtesConstraint = 4, CPUConstraint = 5, }} -STRUCT!{struct WINSTATIONLOADINDICATORDATA { - RemainingSessionCapacity: ULONG, +STRUCT! {struct WINSTATIONLOADINDICATORDATA { + RemainingSessionCapacity: c_ulong, LoadFactor: LOADFACTORTYPE, - TotalSessions: ULONG, - DisconnectedSessions: ULONG, + TotalSessions: c_ulong, + DisconnectedSessions: c_ulong, IdleCPU: LARGE_INTEGER, TotalCPU: LARGE_INTEGER, - RawSessionCapacity: ULONG, - reserved: [ULONG; 9], + RawSessionCapacity: c_ulong, + reserved: [c_ulong; 9], }} pub type PWINSTATIONLOADINDICATORDATA = *mut WINSTATIONLOADINDICATORDATA; -ENUM!{enum SHADOWSTATECLASS { +ENUM! {enum SHADOWSTATECLASS { State_NoShadow = 0, State_Shadowing = 1, State_Shadowed = 2, }} -STRUCT!{struct WINSTATIONSHADOW { +STRUCT! {struct WINSTATIONSHADOW { ShadowState: SHADOWSTATECLASS, ShadowClass: SHADOWCLASS, - SessionId: ULONG, - ProtocolType: ULONG, + SessionId: c_ulong, + ProtocolType: c_ulong, }} pub type PWINSTATIONSHADOW = *mut WINSTATIONSHADOW; -STRUCT!{struct WINSTATIONPRODID { - DigProductId: [WCHAR; CLIENT_PRODUCT_ID_LENGTH], - ClientDigProductId: [WCHAR; CLIENT_PRODUCT_ID_LENGTH], - OuterMostDigProductId: [WCHAR; CLIENT_PRODUCT_ID_LENGTH], - CurrentSessionId: ULONG, - ClientSessionId: ULONG, - OuterMostSessionId: ULONG, +STRUCT! {struct WINSTATIONPRODID { + DigProductId: [wchar_t; CLIENT_PRODUCT_ID_LENGTH], + ClientDigProductId: [wchar_t; CLIENT_PRODUCT_ID_LENGTH], + OuterMostDigProductId: [wchar_t; CLIENT_PRODUCT_ID_LENGTH], + CurrentSessionId: c_ulong, + ClientSessionId: c_ulong, + OuterMostSessionId: c_ulong, }} pub type PWINSTATIONPRODID = *mut WINSTATIONPRODID; -STRUCT!{struct WINSTATIONREMOTEADDRESS_u_ipv4 { - sin_port: USHORT, - sin_addr: ULONG, - sin_zero: [UCHAR; 8], -}} -STRUCT!{struct WINSTATIONREMOTEADDRESS_u_ipv6 { - sin6_port: USHORT, - sin6_flowinfo: ULONG, - sin6_addr: [USHORT; 8], - sin6_scope_id: ULONG, -}} -UNION!{union WINSTATIONREMOTEADDRESS_u { +STRUCT! {struct WINSTATIONREMOTEADDRESS_u_ipv4 { + sin_port: c_ushort, + sin_addr: c_ulong, + sin_zero: [c_uchar; 8], +}} +STRUCT! {struct WINSTATIONREMOTEADDRESS_u_ipv6 { + sin6_port: c_ushort, + sin6_flowinfo: c_ulong, + sin6_addr: [c_ushort; 8], + sin6_scope_id: c_ulong, +}} +UNION! {union WINSTATIONREMOTEADDRESS_u { ipv4: WINSTATIONREMOTEADDRESS_u_ipv4, ipv6: WINSTATIONREMOTEADDRESS_u_ipv6, }} -STRUCT!{struct WINSTATIONREMOTEADDRESS { - sin_family: USHORT, +STRUCT! {struct WINSTATIONREMOTEADDRESS { + sin_family: c_ushort, u: WINSTATIONREMOTEADDRESS_u, }} pub type PWINSTATIONREMOTEADDRESS = *mut WINSTATIONREMOTEADDRESS; -STRUCT!{struct WINSTATIONINFORMATIONEX_LEVEL1 { - SessionId: ULONG, +STRUCT! {struct WINSTATIONINFORMATIONEX_LEVEL1 { + SessionId: c_ulong, SessionState: WINSTATIONSTATECLASS, - SessionFlags: LONG, + SessionFlags: c_long, WinStationName: WINSTATIONNAME, - UserName: [WCHAR; USERNAME_LENGTH + 1], - DomainName: [WCHAR; DOMAIN_LENGTH + 1], + UserName: [wchar_t; USERNAME_LENGTH + 1], + DomainName: [wchar_t; DOMAIN_LENGTH + 1], LogonTime: LARGE_INTEGER, ConnectTime: LARGE_INTEGER, DisconnectTime: LARGE_INTEGER, @@ -607,46 +621,46 @@ STRUCT!{struct WINSTATIONINFORMATIONEX_LEVEL1 { ProtocolStatus: PROTOCOLSTATUS, }} pub type PWINSTATIONINFORMATIONEX_LEVEL1 = *mut WINSTATIONINFORMATIONEX_LEVEL1; -STRUCT!{struct WINSTATIONINFORMATIONEX_LEVEL2 { - SessionId: ULONG, +STRUCT! {struct WINSTATIONINFORMATIONEX_LEVEL2 { + SessionId: c_ulong, SessionState: WINSTATIONSTATECLASS, - SessionFlags: LONG, + SessionFlags: c_long, WinStationName: WINSTATIONNAME, - SamCompatibleUserName: [WCHAR; USERNAME_LENGTH + 1], - SamCompatibleDomainName: [WCHAR; DOMAIN_LENGTH + 1], + SamCompatibleUserName: [wchar_t; USERNAME_LENGTH + 1], + SamCompatibleDomainName: [wchar_t; DOMAIN_LENGTH + 1], LogonTime: LARGE_INTEGER, ConnectTime: LARGE_INTEGER, DisconnectTime: LARGE_INTEGER, LastInputTime: LARGE_INTEGER, CurrentTime: LARGE_INTEGER, ProtocolStatus: PROTOCOLSTATUS, - UserName: [WCHAR; 257], - DomainName: [WCHAR; 256], + UserName: [wchar_t; 257], + DomainName: [wchar_t; 256], }} pub type PWINSTATIONINFORMATIONEX_LEVEL2 = *mut WINSTATIONINFORMATIONEX_LEVEL2; -UNION!{union WINSTATIONINFORMATIONEX_LEVEL { +UNION! {union WINSTATIONINFORMATIONEX_LEVEL { WinStationInfoExLevel1: WINSTATIONINFORMATIONEX_LEVEL1, WinStationInfoExLevel2: WINSTATIONINFORMATIONEX_LEVEL2, }} pub type PWINSTATIONINFORMATIONEX_LEVEL = *mut WINSTATIONINFORMATIONEX_LEVEL; -STRUCT!{struct WINSTATIONINFORMATIONEX { - Level: ULONG, +STRUCT! {struct WINSTATIONINFORMATIONEX { + Level: c_ulong, Data: WINSTATIONINFORMATIONEX_LEVEL, }} pub type PWINSTATIONINFORMATIONEX = *mut WINSTATIONINFORMATIONEX; pub const TS_PROCESS_INFO_MAGIC_NT4: u32 = 0x23495452; -STRUCT!{struct TS_PROCESS_INFORMATION_NT4 { - MagicNumber: ULONG, - LogonId: ULONG, - ProcessSid: PVOID, - Pad: ULONG, +STRUCT! {struct TS_PROCESS_INFORMATION_NT4 { + MagicNumber: c_ulong, + LogonId: c_ulong, + ProcessSid: *mut c_void, + Pad: c_ulong, }} pub type PTS_PROCESS_INFORMATION_NT4 = *mut TS_PROCESS_INFORMATION_NT4; pub const SIZEOF_TS4_SYSTEM_THREAD_INFORMATION: u32 = 64; pub const SIZEOF_TS4_SYSTEM_PROCESS_INFORMATION: u32 = 136; -STRUCT!{struct TS_SYS_PROCESS_INFORMATION { - NextEntryOffset: ULONG, - NumberOfThreads: ULONG, +STRUCT! {struct TS_SYS_PROCESS_INFORMATION { + NextEntryOffset: c_ulong, + NumberOfThreads: c_ulong, SpareLi1: LARGE_INTEGER, SpareLi2: LARGE_INTEGER, SpareLi3: LARGE_INTEGER, @@ -654,195 +668,195 @@ STRUCT!{struct TS_SYS_PROCESS_INFORMATION { UserTime: LARGE_INTEGER, KernelTime: LARGE_INTEGER, ImageName: UNICODE_STRING, - BasePriority: LONG, - UniqueProcessId: ULONG, - InheritedFromUniqueProcessId: ULONG, - HandleCount: ULONG, - SessionId: ULONG, - SpareUl3: ULONG, - PeakVirtualSize: SIZE_T, - VirtualSize: SIZE_T, - PageFaultCount: ULONG, - PeakWorkingSetSize: ULONG, - WorkingSetSize: ULONG, - QuotaPeakPagedPoolUsage: SIZE_T, - QuotaPagedPoolUsage: SIZE_T, - QuotaPeakNonPagedPoolUsage: SIZE_T, - QuotaNonPagedPoolUsage: SIZE_T, - PagefileUsage: SIZE_T, - PeakPagefileUsage: SIZE_T, - PrivatePageCount: SIZE_T, + BasePriority: c_long, + UniqueProcessId: c_ulong, + InheritedFromUniqueProcessId: c_ulong, + HandleCount: c_ulong, + SessionId: c_ulong, + SpareUl3: c_ulong, + PeakVirtualSize: usize, + VirtualSize: usize, + PageFaultCount: c_ulong, + PeakWorkingSetSize: c_ulong, + WorkingSetSize: c_ulong, + QuotaPeakPagedPoolUsage: usize, + QuotaPagedPoolUsage: usize, + QuotaPeakNonPagedPoolUsage: usize, + QuotaNonPagedPoolUsage: usize, + PagefileUsage: usize, + PeakPagefileUsage: usize, + PrivatePageCount: usize, }} pub type PTS_SYS_PROCESS_INFORMATION = *mut TS_SYS_PROCESS_INFORMATION; -STRUCT!{struct TS_ALL_PROCESSES_INFO { +STRUCT! {struct TS_ALL_PROCESSES_INFO { pTsProcessInfo: PTS_SYS_PROCESS_INFORMATION, - SizeOfSid: ULONG, + SizeOfSid: c_ulong, pSid: PSID, }} pub type PTS_ALL_PROCESSES_INFO = *mut TS_ALL_PROCESSES_INFO; -STRUCT!{struct TS_COUNTER_HEADER { - dwCounterID: DWORD, - bResult: BOOLEAN, +STRUCT! {struct TS_COUNTER_HEADER { + dwCounterID: c_ulong, + bResult: c_uchar, }} pub type PTS_COUNTER_HEADER = *mut TS_COUNTER_HEADER; -STRUCT!{struct TS_COUNTER { +STRUCT! {struct TS_COUNTER { CounterHead: TS_COUNTER_HEADER, - dwValue: DWORD, + dwValue: c_ulong, StartTime: LARGE_INTEGER, }} pub type PTS_COUNTER = *mut TS_COUNTER; -pub const WSD_LOGOFF: ULONG = 0x1; -pub const WSD_SHUTDOWN: ULONG = 0x2; -pub const WSD_REBOOT: ULONG = 0x4; -pub const WSD_POWEROFF: ULONG = 0x8; -pub const WEVENT_NONE: ULONG = 0x0; -pub const WEVENT_CREATE: ULONG = 0x1; -pub const WEVENT_DELETE: ULONG = 0x2; -pub const WEVENT_RENAME: ULONG = 0x4; -pub const WEVENT_CONNECT: ULONG = 0x8; -pub const WEVENT_DISCONNECT: ULONG = 0x10; -pub const WEVENT_LOGON: ULONG = 0x20; -pub const WEVENT_LOGOFF: ULONG = 0x40; -pub const WEVENT_STATECHANGE: ULONG = 0x80; -pub const WEVENT_LICENSE: ULONG = 0x100; -pub const WEVENT_ALL: ULONG = 0x7fffffff; -pub const WEVENT_FLUSH: ULONG = 0x80000000; -pub const KBDSHIFT: USHORT = 0x1; -pub const KBDCTRL: USHORT = 0x2; -pub const KBDALT: USHORT = 0x4; -pub const WNOTIFY_ALL_SESSIONS: ULONG = 0x1; +pub const WSD_LOGOFF: c_ulong = 0x1; +pub const WSD_SHUTDOWN: c_ulong = 0x2; +pub const WSD_REBOOT: c_ulong = 0x4; +pub const WSD_POWEROFF: c_ulong = 0x8; +pub const WEVENT_NONE: c_ulong = 0x0; +pub const WEVENT_CREATE: c_ulong = 0x1; +pub const WEVENT_DELETE: c_ulong = 0x2; +pub const WEVENT_RENAME: c_ulong = 0x4; +pub const WEVENT_CONNECT: c_ulong = 0x8; +pub const WEVENT_DISCONNECT: c_ulong = 0x10; +pub const WEVENT_LOGON: c_ulong = 0x20; +pub const WEVENT_LOGOFF: c_ulong = 0x40; +pub const WEVENT_STATECHANGE: c_ulong = 0x80; +pub const WEVENT_LICENSE: c_ulong = 0x100; +pub const WEVENT_ALL: c_ulong = 0x7fffffff; +pub const WEVENT_FLUSH: c_ulong = 0x80000000; +pub const KBDSHIFT: c_ushort = 0x1; +pub const KBDCTRL: c_ushort = 0x2; +pub const KBDALT: c_ushort = 0x4; +pub const WNOTIFY_ALL_SESSIONS: c_ulong = 0x1; pub const LOGONID_CURRENT: i32 = -1; -pub const SERVERNAME_CURRENT: PWSTR = null_mut(); -EXTERN!{extern "system" { +pub const SERVERNAME_CURRENT: *mut wchar_t = null_mut(); +EXTERN! {extern "system" { fn WinStationFreeMemory( - Buffer: PVOID, - ) -> BOOLEAN; + Buffer: *mut c_void, + ) -> c_uchar; fn WinStationOpenServerW( - ServerName: PWSTR, + ServerName: *mut wchar_t, ) -> HANDLE; fn WinStationCloseServer( ServerHandle: HANDLE, - ) -> BOOLEAN; + ) -> c_uchar; fn WinStationServerPing( ServerHandle: HANDLE, - ) -> BOOLEAN; + ) -> c_uchar; fn WinStationGetTermSrvCountersValue( ServerHandle: HANDLE, - Count: ULONG, + Count: c_ulong, Counters: PTS_COUNTER, - ) -> BOOLEAN; + ) -> c_uchar; fn WinStationShutdownSystem( ServerHandle: HANDLE, - ShutdownFlags: ULONG, - ) -> BOOLEAN; + ShutdownFlags: c_ulong, + ) -> c_uchar; fn WinStationWaitSystemEvent( ServerHandle: HANDLE, - EventMask: ULONG, - EventFlags: PULONG, - ) -> BOOLEAN; + EventMask: c_ulong, + EventFlags: *mut c_ulong, + ) -> c_uchar; fn WinStationRegisterConsoleNotification( ServerHandle: HANDLE, WindowHandle: HWND, - Flags: ULONG, - ) -> BOOLEAN; + Flags: c_ulong, + ) -> c_uchar; fn WinStationUnRegisterConsoleNotification( ServerHandle: HANDLE, WindowHandle: HWND, - ) -> BOOLEAN; + ) -> c_uchar; fn WinStationEnumerateW( ServerHandle: HANDLE, SessionIds: *mut PSESSIONIDW, - Count: PULONG, - ) -> BOOLEAN; + Count: *mut c_ulong, + ) -> c_uchar; fn WinStationQueryInformationW( ServerHandle: HANDLE, - SessionId: ULONG, + SessionId: c_ulong, WinStationInformationClass: WINSTATIONINFOCLASS, - pWinStationInformation: PVOID, - WinStationInformationLength: ULONG, - pReturnLength: PULONG, - ) -> BOOLEAN; + pWinStationInformation: *mut c_void, + WinStationInformationLength: c_ulong, + pReturnLength: *mut c_ulong, + ) -> c_uchar; fn WinStationSetInformationW( ServerHandle: HANDLE, - SessionId: ULONG, + SessionId: c_ulong, WinStationInformationClass: WINSTATIONINFOCLASS, - pWinStationInformation: PVOID, - WinStationInformationLength: ULONG, - ) -> BOOLEAN; + pWinStationInformation: *mut c_void, + WinStationInformationLength: c_ulong, + ) -> c_uchar; fn WinStationNameFromLogonIdW( ServerHandle: HANDLE, - SessionId: ULONG, - pWinStationName: PWSTR, - ) -> BOOLEAN; + SessionId: c_ulong, + pWinStationName: *mut wchar_t, + ) -> c_uchar; fn WinStationSendMessageW( ServerHandle: HANDLE, - SessionId: ULONG, - Title: PWSTR, - TitleLength: ULONG, - Message: PWSTR, - MessageLength: ULONG, - Style: ULONG, - Timeout: ULONG, - Response: PULONG, - DoNotWait: BOOLEAN, - ) -> BOOLEAN; + SessionId: c_ulong, + Title: *mut wchar_t, + TitleLength: c_ulong, + Message: *mut wchar_t, + MessageLength: c_ulong, + Style: c_ulong, + Timeout: c_ulong, + Response: *mut c_ulong, + DoNotWait: c_uchar, + ) -> c_uchar; fn WinStationConnectW( ServerHandle: HANDLE, - SessionId: ULONG, - TargetSessionId: ULONG, - pPassword: PWSTR, - bWait: BOOLEAN, - ) -> BOOLEAN; + SessionId: c_ulong, + TargetSessionId: c_ulong, + pPassword: *mut wchar_t, + bWait: c_uchar, + ) -> c_uchar; fn WinStationDisconnect( ServerHandle: HANDLE, - SessionId: ULONG, - bWait: BOOLEAN, - ) -> BOOLEAN; + SessionId: c_ulong, + bWait: c_uchar, + ) -> c_uchar; fn WinStationReset( ServerHandle: HANDLE, - SessionId: ULONG, - bWait: BOOLEAN, - ) -> BOOLEAN; + SessionId: c_ulong, + bWait: c_uchar, + ) -> c_uchar; fn WinStationShadow( ServerHandle: HANDLE, - TargetServerName: PWSTR, - TargetSessionId: ULONG, - HotKeyVk: UCHAR, - HotkeyModifiers: USHORT, - ) -> BOOLEAN; + TargetServerName: *mut wchar_t, + TargetSessionId: c_ulong, + HotKeyVk: c_uchar, + HotkeyModifiers: c_ushort, + ) -> c_uchar; fn WinStationShadowStop( ServerHandle: HANDLE, - SessionId: ULONG, - bWait: BOOLEAN, - ) -> BOOLEAN; + SessionId: c_ulong, + bWait: c_uchar, + ) -> c_uchar; fn WinStationEnumerateProcesses( ServerHandle: HANDLE, - Processes: *mut PVOID, - ) -> BOOLEAN; + Processes: *mut *mut c_void, + ) -> c_uchar; fn WinStationGetAllProcesses( ServerHandle: HANDLE, - Level: ULONG, - NumberOfProcesses: PULONG, + Level: c_ulong, + NumberOfProcesses: *mut c_ulong, Processes: *mut PTS_ALL_PROCESSES_INFO, - ) -> BOOLEAN; + ) -> c_uchar; fn WinStationFreeGAPMemory( - Level: ULONG, + Level: c_ulong, Processes: PTS_ALL_PROCESSES_INFO, - NumberOfProcesses: ULONG, - ) -> BOOLEAN; + NumberOfProcesses: c_ulong, + ) -> c_uchar; fn WinStationTerminateProcess( ServerHandle: HANDLE, - ProcessId: ULONG, - ExitCode: ULONG, - ) -> BOOLEAN; + ProcessId: c_ulong, + ExitCode: c_ulong, + ) -> c_uchar; fn WinStationGetProcessSid( ServerHandle: HANDLE, - ProcessId: ULONG, + ProcessId: c_ulong, ProcessStartTime: FILETIME, - pProcessUserSid: PVOID, - dwSidSize: PULONG, - ) -> BOOLEAN; - fn WinStationSwitchToServicesSession() -> BOOLEAN; - fn WinStationRevertFromServicesSession() -> BOOLEAN; - fn _WinStationWaitForConnect() -> BOOLEAN; + pProcessUserSid: *mut c_void, + dwSidSize: *mut c_ulong, + ) -> c_uchar; + fn WinStationSwitchToServicesSession() -> c_uchar; + fn WinStationRevertFromServicesSession() -> c_uchar; + fn _WinStationWaitForConnect() -> c_uchar; }} diff --git a/tests/layout_aarch64.rs b/tests/layout_aarch64.rs index b99d799..c97b6e3 100644 --- a/tests/layout_aarch64.rs +++ b/tests/layout_aarch64.rs @@ -129,8 +129,14 @@ fn ntexapi() { assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 12); assert_eq!(align_of::(), 4); - assert_eq!(size_of::(), 24); - assert_eq!(align_of::(), 8); + assert_eq!( + size_of::(), + 24 + ); + assert_eq!( + align_of::(), + 8 + ); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 16); @@ -216,15 +222,24 @@ fn ntexapi() { assert_eq!(size_of::(), 24); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 8); - assert_eq!(align_of::(), 8); + assert_eq!( + align_of::(), + 8 + ); assert_eq!(size_of::(), 40); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 24); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 32); assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 8); - assert_eq!(align_of::(), 4); + assert_eq!( + size_of::(), + 8 + ); + assert_eq!( + align_of::(), + 4 + ); assert_eq!(size_of::(), 40); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 16); @@ -235,8 +250,14 @@ fn ntexapi() { assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 4); - assert_eq!(size_of::(), 24); - assert_eq!(align_of::(), 8); + assert_eq!( + size_of::(), + 24 + ); + assert_eq!( + align_of::(), + 8 + ); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 8); @@ -259,8 +280,14 @@ fn ntexapi() { assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 4); assert_eq!(align_of::(), 4); - assert_eq!(size_of::(), 12); - assert_eq!(align_of::(), 4); + assert_eq!( + size_of::(), + 12 + ); + assert_eq!( + align_of::(), + 4 + ); assert_eq!(size_of::(), 32); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 16); @@ -281,8 +308,14 @@ fn ntexapi() { assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 32); assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 8); - assert_eq!(align_of::(), 4); + assert_eq!( + size_of::(), + 8 + ); + assert_eq!( + align_of::(), + 4 + ); assert_eq!(size_of::(), 48); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 32); @@ -315,8 +348,14 @@ fn ntexapi() { assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 368); assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 1); - assert_eq!(align_of::(), 1); + assert_eq!( + size_of::(), + 1 + ); + assert_eq!( + align_of::(), + 1 + ); assert_eq!(size_of::(), 3); assert_eq!(align_of::(), 1); assert_eq!(size_of::(), 8); @@ -351,14 +390,32 @@ fn ntexapi() { assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 16); assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 144); - assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 8); - assert_eq!(align_of::(), 4); + assert_eq!( + size_of::(), + 144 + ); + assert_eq!( + align_of::(), + 8 + ); + assert_eq!( + size_of::(), + 8 + ); + assert_eq!( + align_of::(), + 4 + ); assert_eq!(size_of::(), 56); assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 16); - assert_eq!(align_of::(), 8); + assert_eq!( + size_of::(), + 16 + ); + assert_eq!( + align_of::(), + 8 + ); assert_eq!(size_of::(), 24); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 24); @@ -373,8 +430,14 @@ fn ntexapi() { assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 4); assert_eq!(align_of::(), 4); - assert_eq!(size_of::(), 24); - assert_eq!(align_of::(), 8); + assert_eq!( + size_of::(), + 24 + ); + assert_eq!( + align_of::(), + 8 + ); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 4); @@ -422,20 +485,29 @@ fn ntexapi() { assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, AitSamplingValue), 584); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, AppCompatFlag), 588); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, RNGSeedVersion), 592); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, GlobalValidationRunlevel), 600); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, GlobalValidationRunlevel), + 600 + ); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TimeZoneBiasStamp), 604); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, NtBuildNumber), 608); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, NtProductType), 612); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, ProductTypeIsValid), 616); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, Reserved0), 617); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, NativeProcessorArchitecture), 618); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, NativeProcessorArchitecture), + 618 + ); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, NtMajorVersion), 620); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, NtMinorVersion), 624); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, ProcessorFeatures), 628); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, Reserved1), 692); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, Reserved3), 696); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TimeSlip), 700); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, AlternativeArchitecture), 704); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, AlternativeArchitecture), + 704 + ); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, BootId), 708); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, SystemExpirationDate), 712); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, SuiteMask), 720); @@ -445,7 +517,10 @@ fn ntexapi() { assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, ActiveConsoleId), 728); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, DismountCount), 732); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, ComPlusPackage), 736); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, LastSystemRITEventTickCount), 740); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, LastSystemRITEventTickCount), + 740 + ); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, NumberOfPhysicalPages), 744); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, SafeBootMode), 748); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, VirtualizationFlags), 749); @@ -461,19 +536,46 @@ fn ntexapi() { // assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TickCountPad), 812); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, Cookie), 816); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, CookiePad), 820); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, ConsoleSessionForegroundProcessId), 824); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, ConsoleSessionForegroundProcessId), + 824 + ); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TimeUpdateLock), 832); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, BaselineSystemTimeQpc), 840); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, BaselineInterruptTimeQpc), 848); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, QpcSystemTimeIncrement), 856); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, QpcInterruptTimeIncrement), 864); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, QpcSystemTimeIncrementShift), 872); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, QpcInterruptTimeIncrementShift), 873); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, UnparkedProcessorCount), 874); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, BaselineInterruptTimeQpc), + 848 + ); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, QpcSystemTimeIncrement), + 856 + ); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, QpcInterruptTimeIncrement), + 864 + ); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, QpcSystemTimeIncrementShift), + 872 + ); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, QpcInterruptTimeIncrementShift), + 873 + ); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, UnparkedProcessorCount), + 874 + ); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, EnclaveFeatureMask), 876); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TelemetryCoverageRound), 892); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, TelemetryCoverageRound), + 892 + ); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, UserModeGlobalLogger), 896); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, ImageFileExecutionOptions), 928); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, ImageFileExecutionOptions), + 928 + ); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, LangGenerationCount), 932); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, Reserved4), 936); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, InterruptTimeBias), 944); @@ -482,8 +584,14 @@ fn ntexapi() { assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, ActiveGroupCount), 964); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, Reserved9), 965); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, QpcData), 966); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TimeZoneBiasEffectiveStart), 968); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TimeZoneBiasEffectiveEnd), 976); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, TimeZoneBiasEffectiveStart), + 968 + ); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, TimeZoneBiasEffectiveEnd), + 976 + ); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, XState), 984); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 2); @@ -769,14 +877,29 @@ fn ntlpcapi() { assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, BitmapSize), 24); assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, DataOffset), 28); assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, DataSize), 32); - assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, AttributeFlags), 36); - assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, AttributeSize), 40); + assert_eq!( + FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, AttributeFlags), + 36 + ); + assert_eq!( + FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, AttributeSize), + 40 + ); assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, State), 128); - assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, LastMessageId), 136); - assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, LastCallbackId), 140); + assert_eq!( + FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, LastMessageId), + 136 + ); + assert_eq!( + FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, LastCallbackId), + 140 + ); assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, PostCount), 256); assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, ReturnCount), 384); - assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, LogSequenceNumber), 512); + assert_eq!( + FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, LogSequenceNumber), + 512 + ); assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, UserLock), 640); assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, EndMagic), 648); assert_eq!(size_of::(), 32); @@ -977,7 +1100,10 @@ fn ntpebteb() { assert_eq!(FIELD_OFFSET!(PEB, CloudFileFlags), 1960); assert_eq!(FIELD_OFFSET!(PEB, CloudFileDiagFlags), 1964); assert_eq!(FIELD_OFFSET!(PEB, PlaceholderCompatibilityMode), 1968); - assert_eq!(FIELD_OFFSET!(PEB, PlaceholderCompatibilityModeReserved), 1969); + assert_eq!( + FIELD_OFFSET!(PEB, PlaceholderCompatibilityModeReserved), + 1969 + ); assert_eq!(FIELD_OFFSET!(PEB, LeapSecondData), 1976); assert_eq!(FIELD_OFFSET!(PEB, LeapSecondFlags), 1984); assert_eq!(FIELD_OFFSET!(PEB, NtGlobalFlag2), 1988); @@ -1211,8 +1337,14 @@ fn ntpsapi() { assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 56); assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 16); - assert_eq!(align_of::(), 8); + assert_eq!( + size_of::(), + 16 + ); + assert_eq!( + align_of::(), + 8 + ); assert_eq!(size_of::(), 24); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 40); @@ -1266,7 +1398,10 @@ fn ntpsapi() { assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 8); - assert_eq!(align_of::(), 8); + assert_eq!( + align_of::(), + 8 + ); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 8); @@ -1439,8 +1574,14 @@ fn ntrtl() { assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 104); assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 32); - assert_eq!(align_of::(), 8); + assert_eq!( + size_of::(), + 32 + ); + assert_eq!( + align_of::(), + 8 + ); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 24); @@ -1519,22 +1660,58 @@ fn ntrtl() { assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 8); - assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 8); - assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 8); - assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 16); - assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 16); - assert_eq!(align_of::(), 8); + assert_eq!( + size_of::(), + 8 + ); + assert_eq!( + align_of::(), + 8 + ); + assert_eq!( + size_of::(), + 8 + ); + assert_eq!( + align_of::(), + 8 + ); + assert_eq!( + size_of::(), + 8 + ); + assert_eq!( + align_of::(), + 8 + ); + assert_eq!( + size_of::(), + 16 + ); + assert_eq!( + align_of::(), + 8 + ); + assert_eq!( + size_of::(), + 16 + ); + assert_eq!( + align_of::(), + 8 + ); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 24); assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 48); - assert_eq!(align_of::(), 8); + assert_eq!( + size_of::(), + 48 + ); + assert_eq!( + align_of::(), + 8 + ); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 8); @@ -1562,20 +1739,44 @@ fn ntsam() { assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, ForceLogoff), 0); assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, OemInformation), 8); assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, DomainName), 24); - assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, ReplicaSourceNodeName), 40); - assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, DomainModifiedCount), 56); - assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, DomainServerState), 64); - assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, DomainServerRole), 68); - assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, UasCompatibilityRequired), 72); + assert_eq!( + FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, ReplicaSourceNodeName), + 40 + ); + assert_eq!( + FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, DomainModifiedCount), + 56 + ); + assert_eq!( + FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, DomainServerState), + 64 + ); + assert_eq!( + FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, DomainServerRole), + 68 + ); + assert_eq!( + FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, UasCompatibilityRequired), + 72 + ); assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, UserCount), 76); assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, GroupCount), 80); assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, AliasCount), 84); assert_eq!(size_of::(), 108); assert_eq!(align_of::(), 4); assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION2, I1), 0); - assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION2, LockoutDuration), 88); - assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION2, LockoutObservationWindow), 96); - assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION2, LockoutThreshold), 104); + assert_eq!( + FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION2, LockoutDuration), + 88 + ); + assert_eq!( + FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION2, LockoutObservationWindow), + 96 + ); + assert_eq!( + FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION2, LockoutThreshold), + 104 + ); assert_eq!(size_of::(), 1); assert_eq!(align_of::(), 1); assert_eq!(size_of::(), 8); @@ -1643,19 +1844,31 @@ fn ntsam() { assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, UserId), 32); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, PrimaryGroupId), 36); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, HomeDirectory), 40); - assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, HomeDirectoryDrive), 56); + assert_eq!( + FIELD_OFFSET!(USER_LOGON_INFORMATION, HomeDirectoryDrive), + 56 + ); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, ScriptPath), 72); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, ProfilePath), 88); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, WorkStations), 104); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, LastLogon), 120); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, LastLogoff), 128); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, PasswordLastSet), 136); - assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, PasswordCanChange), 144); - assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, PasswordMustChange), 152); + assert_eq!( + FIELD_OFFSET!(USER_LOGON_INFORMATION, PasswordCanChange), + 144 + ); + assert_eq!( + FIELD_OFFSET!(USER_LOGON_INFORMATION, PasswordMustChange), + 152 + ); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, LogonHours), 160); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, BadPasswordCount), 176); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, LogonCount), 178); - assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, UserAccountControl), 180); + assert_eq!( + FIELD_OFFSET!(USER_LOGON_INFORMATION, UserAccountControl), + 180 + ); assert_eq!(size_of::(), 192); assert_eq!(align_of::(), 4); assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, UserName), 0); @@ -1663,7 +1876,10 @@ fn ntsam() { assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, UserId), 32); assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, PrimaryGroupId), 36); assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, HomeDirectory), 40); - assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, HomeDirectoryDrive), 56); + assert_eq!( + FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, HomeDirectoryDrive), + 56 + ); assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, ScriptPath), 72); assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, ProfilePath), 88); assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, AdminComment), 104); @@ -1671,11 +1887,20 @@ fn ntsam() { assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, LastLogon), 136); assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, LastLogoff), 144); assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, LogonHours), 152); - assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, BadPasswordCount), 168); + assert_eq!( + FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, BadPasswordCount), + 168 + ); assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, LogonCount), 170); - assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, PasswordLastSet), 172); + assert_eq!( + FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, PasswordLastSet), + 172 + ); assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, AccountExpires), 180); - assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, UserAccountControl), 188); + assert_eq!( + FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, UserAccountControl), + 188 + ); assert_eq!(size_of::(), 16); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 16); @@ -1773,7 +1998,10 @@ fn ntwow64() { assert_eq!(FIELD_OFFSET!(PEB_LDR_DATA32, SsHandle), 8); assert_eq!(FIELD_OFFSET!(PEB_LDR_DATA32, InLoadOrderModuleList), 12); assert_eq!(FIELD_OFFSET!(PEB_LDR_DATA32, InMemoryOrderModuleList), 20); - assert_eq!(FIELD_OFFSET!(PEB_LDR_DATA32, InInitializationOrderModuleList), 28); + assert_eq!( + FIELD_OFFSET!(PEB_LDR_DATA32, InInitializationOrderModuleList), + 28 + ); assert_eq!(FIELD_OFFSET!(PEB_LDR_DATA32, EntryInProgress), 36); assert_eq!(FIELD_OFFSET!(PEB_LDR_DATA32, ShutdownInProgress), 40); assert_eq!(FIELD_OFFSET!(PEB_LDR_DATA32, ShutdownThreadId), 44); @@ -1800,8 +2028,14 @@ fn ntwow64() { assert_eq!(align_of::(), 8); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, InLoadOrderLinks), 0); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, InMemoryOrderLinks), 8); - assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, u1.InInitializationOrderLinks), 16); - assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, u1.InProgressLinks), 16); + assert_eq!( + FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, u1.InInitializationOrderLinks), + 16 + ); + assert_eq!( + FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, u1.InProgressLinks), + 16 + ); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, DllBase), 24); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, EntryPoint), 28); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, SizeOfImage), 32); @@ -1813,22 +2047,43 @@ fn ntwow64() { assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, TlsIndex), 58); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, HashLinks), 60); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, TimeDateStamp), 68); - assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, EntryPointActivationContext), 72); + assert_eq!( + FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, EntryPointActivationContext), + 72 + ); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, Lock), 76); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, DdagNode), 80); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, NodeModuleLink), 84); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, LoadContext), 92); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, ParentDllBase), 96); - assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, SwitchBackContext), 100); - assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, BaseAddressIndexNode), 104); - assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, MappingInfoIndexNode), 116); + assert_eq!( + FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, SwitchBackContext), + 100 + ); + assert_eq!( + FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, BaseAddressIndexNode), + 104 + ); + assert_eq!( + FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, MappingInfoIndexNode), + 116 + ); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, OriginalBase), 128); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, LoadTime), 136); - assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, BaseNameHashValue), 144); + assert_eq!( + FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, BaseNameHashValue), + 144 + ); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, LoadReason), 148); - assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, ImplicitPathOptions), 152); + assert_eq!( + FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, ImplicitPathOptions), + 152 + ); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, ReferenceCount), 156); - assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, DependentLoadFlags), 160); + assert_eq!( + FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, DependentLoadFlags), + 160 + ); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, SigningLevel), 164); assert_eq!(size_of::(), 12); assert_eq!(align_of::(), 4); @@ -1842,39 +2097,111 @@ fn ntwow64() { assert_eq!(FIELD_OFFSET!(RTL_DRIVE_LETTER_CURDIR32, DosPath), 8); assert_eq!(size_of::(), 676); assert_eq!(align_of::(), 4); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, MaximumLength), 0); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, MaximumLength), + 0 + ); assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, Length), 4); assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, Flags), 8); assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, DebugFlags), 12); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ConsoleHandle), 16); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ConsoleFlags), 20); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, StandardInput), 24); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, StandardOutput), 28); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, StandardError), 32); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CurrentDirectory), 36); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ConsoleHandle), + 16 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ConsoleFlags), + 20 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, StandardInput), + 24 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, StandardOutput), + 28 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, StandardError), + 32 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CurrentDirectory), + 36 + ); assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, DllPath), 48); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ImagePathName), 56); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CommandLine), 64); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, Environment), 72); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ImagePathName), + 56 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CommandLine), + 64 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, Environment), + 72 + ); assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, StartingX), 76); assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, StartingY), 80); assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CountX), 84); assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CountY), 88); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CountCharsX), 92); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CountCharsY), 96); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, FillAttribute), 100); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, WindowFlags), 104); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ShowWindowFlags), 108); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, WindowTitle), 112); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, DesktopInfo), 120); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CountCharsX), + 92 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CountCharsY), + 96 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, FillAttribute), + 100 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, WindowFlags), + 104 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ShowWindowFlags), + 108 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, WindowTitle), + 112 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, DesktopInfo), + 120 + ); assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ShellInfo), 128); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, RuntimeData), 136); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CurrentDirectories), 144); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, EnvironmentSize), 656); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, EnvironmentVersion), 660); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, PackageDependencyData), 664); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ProcessGroupId), 668); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, LoaderThreads), 672); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, RuntimeData), + 136 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CurrentDirectories), + 144 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, EnvironmentSize), + 656 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, EnvironmentVersion), + 660 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, PackageDependencyData), + 664 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ProcessGroupId), + 668 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, LoaderThreads), + 672 + ); assert_eq!(size_of::(), 1136); assert_eq!(align_of::(), 8); assert_eq!(FIELD_OFFSET!(PEB32, InheritedAddressSpace), 0); @@ -1939,7 +2266,10 @@ fn ntwow64() { assert_eq!(FIELD_OFFSET!(PEB32, CSDVersion), 496); assert_eq!(FIELD_OFFSET!(PEB32, ActivationContextData), 504); assert_eq!(FIELD_OFFSET!(PEB32, ProcessAssemblyStorageMap), 508); - assert_eq!(FIELD_OFFSET!(PEB32, SystemDefaultActivationContextData), 512); + assert_eq!( + FIELD_OFFSET!(PEB32, SystemDefaultActivationContextData), + 512 + ); assert_eq!(FIELD_OFFSET!(PEB32, SystemAssemblyStorageMap), 516); assert_eq!(FIELD_OFFSET!(PEB32, MinimumStackCommit), 520); assert_eq!(FIELD_OFFSET!(PEB32, FlsCallback), 524); @@ -1960,7 +2290,10 @@ fn ntwow64() { assert_eq!(FIELD_OFFSET!(PEB32, CloudFileFlags), 1120); assert_eq!(FIELD_OFFSET!(PEB32, CloudFileDiagFlags), 1124); assert_eq!(FIELD_OFFSET!(PEB32, PlaceholderCompatibilityMode), 1128); - assert_eq!(FIELD_OFFSET!(PEB32, PlaceholderCompatibilityModeReserved), 1129); + assert_eq!( + FIELD_OFFSET!(PEB32, PlaceholderCompatibilityModeReserved), + 1129 + ); assert_eq!(size_of::(), 1248); assert_eq!(align_of::(), 4); assert_eq!(FIELD_OFFSET!(GDI_TEB_BATCH32, Offset), 0); @@ -1983,7 +2316,10 @@ fn ntwow64() { assert_eq!(FIELD_OFFSET!(TEB32, WOW32Reserved), 192); assert_eq!(FIELD_OFFSET!(TEB32, CurrentLocale), 196); assert_eq!(FIELD_OFFSET!(TEB32, FpSoftwareStatusRegister), 200); - assert_eq!(FIELD_OFFSET!(TEB32, ReservedForDebuggerInstrumentation), 204); + assert_eq!( + FIELD_OFFSET!(TEB32, ReservedForDebuggerInstrumentation), + 204 + ); assert_eq!(FIELD_OFFSET!(TEB32, SystemReserved1), 268); assert_eq!(FIELD_OFFSET!(TEB32, WorkingOnBehalfTicket), 412); assert_eq!(FIELD_OFFSET!(TEB32, ExceptionCode), 420); @@ -2075,8 +2411,14 @@ fn subprocesstag() { assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 16); assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 16); - assert_eq!(align_of::(), 8); + assert_eq!( + size_of::(), + 16 + ); + assert_eq!( + align_of::(), + 8 + ); assert_eq!(size_of::(), 32); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 4); @@ -2273,8 +2615,14 @@ fn winsta() { assert_eq!(align_of::(), 4); assert_eq!(FIELD_OFFSET!(CACHE_STATISTICS, ProtocolType), 0); assert_eq!(FIELD_OFFSET!(CACHE_STATISTICS, Length), 2); - assert_eq!(FIELD_OFFSET!(CACHE_STATISTICS, Specific.ReservedCacheStats), 4); - assert_eq!(FIELD_OFFSET!(CACHE_STATISTICS, Specific.TShareCacheStats), 4); + assert_eq!( + FIELD_OFFSET!(CACHE_STATISTICS, Specific.ReservedCacheStats), + 4 + ); + assert_eq!( + FIELD_OFFSET!(CACHE_STATISTICS, Specific.TShareCacheStats), + 4 + ); assert_eq!(FIELD_OFFSET!(CACHE_STATISTICS, Specific.Reserved), 4); assert_eq!(FIELD_OFFSET!(CACHE_STATISTICS, Specific), 4); assert_eq!(size_of::(), 1012); @@ -2319,13 +2667,22 @@ fn winsta() { assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENTDATA, fUnicodeData), 8); assert_eq!(size_of::(), 72); assert_eq!(align_of::(), 8); - assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, RemainingSessionCapacity), 0); + assert_eq!( + FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, RemainingSessionCapacity), + 0 + ); assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, LoadFactor), 4); assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, TotalSessions), 8); - assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, DisconnectedSessions), 12); + assert_eq!( + FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, DisconnectedSessions), + 12 + ); assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, IdleCPU), 16); assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, TotalCPU), 24); - assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, RawSessionCapacity), 32); + assert_eq!( + FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, RawSessionCapacity), + 32 + ); assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, reserved), 36); assert_eq!(size_of::(), 16); assert_eq!(align_of::(), 4); @@ -2348,39 +2705,114 @@ fn winsta() { assert_eq!(FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, u.ipv4.sin_addr), 8); assert_eq!(FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, u.ipv4.sin_zero), 12); assert_eq!(FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, u.ipv6.sin6_port), 4); - assert_eq!(FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, u.ipv6.sin6_flowinfo), 8); + assert_eq!( + FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, u.ipv6.sin6_flowinfo), + 8 + ); assert_eq!(FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, u.ipv6.sin6_addr), 12); - assert_eq!(FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, u.ipv6.sin6_scope_id), 28); + assert_eq!( + FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, u.ipv6.sin6_scope_id), + 28 + ); assert_eq!(size_of::(), 1216); assert_eq!(align_of::(), 8); assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, SessionId), 0); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, SessionState), 4); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, SessionFlags), 8); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, WinStationName), 12); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, SessionState), + 4 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, SessionFlags), + 8 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, WinStationName), + 12 + ); assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, UserName), 78); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, DomainName), 120); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, LogonTime), 160); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, ConnectTime), 168); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, DisconnectTime), 176); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, LastInputTime), 184); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, CurrentTime), 192); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, ProtocolStatus), 200); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, DomainName), + 120 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, LogonTime), + 160 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, ConnectTime), + 168 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, DisconnectTime), + 176 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, LastInputTime), + 184 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, CurrentTime), + 192 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, ProtocolStatus), + 200 + ); assert_eq!(size_of::(), 2240); assert_eq!(align_of::(), 8); assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SessionId), 0); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SessionState), 4); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SessionFlags), 8); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, WinStationName), 12); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SamCompatibleUserName), 78); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SamCompatibleDomainName), 120); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, LogonTime), 160); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, ConnectTime), 168); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, DisconnectTime), 176); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, LastInputTime), 184); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, CurrentTime), 192); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, ProtocolStatus), 200); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, UserName), 1212); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, DomainName), 1726); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SessionState), + 4 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SessionFlags), + 8 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, WinStationName), + 12 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SamCompatibleUserName), + 78 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SamCompatibleDomainName), + 120 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, LogonTime), + 160 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, ConnectTime), + 168 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, DisconnectTime), + 176 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, LastInputTime), + 184 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, CurrentTime), + 192 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, ProtocolStatus), + 200 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, UserName), + 1212 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, DomainName), + 1726 + ); assert_eq!(size_of::(), 2248); assert_eq!(align_of::(), 8); assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX, Level), 0); @@ -2393,8 +2825,14 @@ fn winsta() { assert_eq!(FIELD_OFFSET!(TS_PROCESS_INFORMATION_NT4, Pad), 16); assert_eq!(size_of::(), 184); assert_eq!(align_of::(), 8); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, NextEntryOffset), 0); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, NumberOfThreads), 4); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, NextEntryOffset), + 0 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, NumberOfThreads), + 4 + ); assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, SpareLi1), 8); assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, SpareLi2), 16); assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, SpareLi3), 24); @@ -2403,23 +2841,62 @@ fn winsta() { assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, KernelTime), 48); assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, ImageName), 56); assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, BasePriority), 72); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, UniqueProcessId), 76); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, InheritedFromUniqueProcessId), 80); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, UniqueProcessId), + 76 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, InheritedFromUniqueProcessId), + 80 + ); assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, HandleCount), 84); assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, SessionId), 88); assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, SpareUl3), 92); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PeakVirtualSize), 96); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PeakVirtualSize), + 96 + ); assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, VirtualSize), 104); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PageFaultCount), 112); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PeakWorkingSetSize), 116); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, WorkingSetSize), 120); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, QuotaPeakPagedPoolUsage), 128); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, QuotaPagedPoolUsage), 136); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, QuotaPeakNonPagedPoolUsage), 144); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, QuotaNonPagedPoolUsage), 152); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PagefileUsage), 160); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PeakPagefileUsage), 168); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PrivatePageCount), 176); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PageFaultCount), + 112 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PeakWorkingSetSize), + 116 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, WorkingSetSize), + 120 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, QuotaPeakPagedPoolUsage), + 128 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, QuotaPagedPoolUsage), + 136 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, QuotaPeakNonPagedPoolUsage), + 144 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, QuotaNonPagedPoolUsage), + 152 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PagefileUsage), + 160 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PeakPagefileUsage), + 168 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PrivatePageCount), + 176 + ); assert_eq!(size_of::(), 24); assert_eq!(align_of::(), 8); assert_eq!(FIELD_OFFSET!(TS_ALL_PROCESSES_INFO, pTsProcessInfo), 0); diff --git a/tests/layout_x86.rs b/tests/layout_x86.rs index 9c9c883..7d38af4 100644 --- a/tests/layout_x86.rs +++ b/tests/layout_x86.rs @@ -129,8 +129,14 @@ fn ntexapi() { assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 12); assert_eq!(align_of::(), 4); - assert_eq!(size_of::(), 24); - assert_eq!(align_of::(), 8); + assert_eq!( + size_of::(), + 24 + ); + assert_eq!( + align_of::(), + 8 + ); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 16); @@ -216,15 +222,24 @@ fn ntexapi() { assert_eq!(size_of::(), 12); assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 8); - assert_eq!(align_of::(), 8); + assert_eq!( + align_of::(), + 8 + ); assert_eq!(size_of::(), 20); assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 12); assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 32); assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 8); - assert_eq!(align_of::(), 4); + assert_eq!( + size_of::(), + 8 + ); + assert_eq!( + align_of::(), + 4 + ); assert_eq!(size_of::(), 36); assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 8); @@ -235,8 +250,14 @@ fn ntexapi() { assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 4); - assert_eq!(size_of::(), 24); - assert_eq!(align_of::(), 8); + assert_eq!( + size_of::(), + 24 + ); + assert_eq!( + align_of::(), + 8 + ); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 8); @@ -259,8 +280,14 @@ fn ntexapi() { assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 4); assert_eq!(align_of::(), 4); - assert_eq!(size_of::(), 12); - assert_eq!(align_of::(), 4); + assert_eq!( + size_of::(), + 12 + ); + assert_eq!( + align_of::(), + 4 + ); assert_eq!(size_of::(), 32); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 8); @@ -281,8 +308,14 @@ fn ntexapi() { assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 24); assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 8); - assert_eq!(align_of::(), 4); + assert_eq!( + size_of::(), + 8 + ); + assert_eq!( + align_of::(), + 4 + ); assert_eq!(size_of::(), 28); assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 32); @@ -315,8 +348,14 @@ fn ntexapi() { assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 360); assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 1); - assert_eq!(align_of::(), 1); + assert_eq!( + size_of::(), + 1 + ); + assert_eq!( + align_of::(), + 1 + ); assert_eq!(size_of::(), 3); assert_eq!(align_of::(), 1); assert_eq!(size_of::(), 4); @@ -351,14 +390,29 @@ fn ntexapi() { assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 16); assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 144); - assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 8); - assert_eq!(align_of::(), 4); + assert_eq!( + size_of::(), + 144 + ); + assert_eq!( + align_of::(), + 8 + ); + assert_eq!( + size_of::(), + 8 + ); + assert_eq!( + align_of::(), + 4 + ); assert_eq!(size_of::(), 56); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 8); - assert_eq!(align_of::(), 4); + assert_eq!( + align_of::(), + 4 + ); assert_eq!(size_of::(), 24); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 16); @@ -373,8 +427,14 @@ fn ntexapi() { assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 4); assert_eq!(align_of::(), 4); - assert_eq!(size_of::(), 12); - assert_eq!(align_of::(), 4); + assert_eq!( + size_of::(), + 12 + ); + assert_eq!( + align_of::(), + 4 + ); assert_eq!(size_of::(), 4); assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 4); @@ -422,20 +482,29 @@ fn ntexapi() { assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, AitSamplingValue), 584); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, AppCompatFlag), 588); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, RNGSeedVersion), 592); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, GlobalValidationRunlevel), 600); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, GlobalValidationRunlevel), + 600 + ); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TimeZoneBiasStamp), 604); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, NtBuildNumber), 608); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, NtProductType), 612); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, ProductTypeIsValid), 616); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, Reserved0), 617); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, NativeProcessorArchitecture), 618); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, NativeProcessorArchitecture), + 618 + ); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, NtMajorVersion), 620); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, NtMinorVersion), 624); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, ProcessorFeatures), 628); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, Reserved1), 692); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, Reserved3), 696); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TimeSlip), 700); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, AlternativeArchitecture), 704); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, AlternativeArchitecture), + 704 + ); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, BootId), 708); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, SystemExpirationDate), 712); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, SuiteMask), 720); @@ -445,7 +514,10 @@ fn ntexapi() { assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, ActiveConsoleId), 728); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, DismountCount), 732); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, ComPlusPackage), 736); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, LastSystemRITEventTickCount), 740); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, LastSystemRITEventTickCount), + 740 + ); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, NumberOfPhysicalPages), 744); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, SafeBootMode), 748); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, VirtualizationFlags), 749); @@ -461,19 +533,46 @@ fn ntexapi() { // assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TickCountPad), 812); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, Cookie), 816); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, CookiePad), 820); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, ConsoleSessionForegroundProcessId), 824); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, ConsoleSessionForegroundProcessId), + 824 + ); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TimeUpdateLock), 832); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, BaselineSystemTimeQpc), 840); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, BaselineInterruptTimeQpc), 848); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, QpcSystemTimeIncrement), 856); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, QpcInterruptTimeIncrement), 864); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, QpcSystemTimeIncrementShift), 872); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, QpcInterruptTimeIncrementShift), 873); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, UnparkedProcessorCount), 874); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, BaselineInterruptTimeQpc), + 848 + ); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, QpcSystemTimeIncrement), + 856 + ); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, QpcInterruptTimeIncrement), + 864 + ); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, QpcSystemTimeIncrementShift), + 872 + ); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, QpcInterruptTimeIncrementShift), + 873 + ); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, UnparkedProcessorCount), + 874 + ); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, EnclaveFeatureMask), 876); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TelemetryCoverageRound), 892); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, TelemetryCoverageRound), + 892 + ); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, UserModeGlobalLogger), 896); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, ImageFileExecutionOptions), 928); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, ImageFileExecutionOptions), + 928 + ); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, LangGenerationCount), 932); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, Reserved4), 936); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, InterruptTimeBias), 944); @@ -482,8 +581,14 @@ fn ntexapi() { assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, ActiveGroupCount), 964); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, Reserved9), 965); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, QpcData), 966); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TimeZoneBiasEffectiveStart), 968); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TimeZoneBiasEffectiveEnd), 976); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, TimeZoneBiasEffectiveStart), + 968 + ); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, TimeZoneBiasEffectiveEnd), + 976 + ); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, XState), 984); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 2); @@ -769,14 +874,29 @@ fn ntlpcapi() { assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, BitmapSize), 24); assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, DataOffset), 28); assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, DataSize), 32); - assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, AttributeFlags), 36); - assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, AttributeSize), 40); + assert_eq!( + FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, AttributeFlags), + 36 + ); + assert_eq!( + FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, AttributeSize), + 40 + ); assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, State), 128); - assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, LastMessageId), 136); - assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, LastCallbackId), 140); + assert_eq!( + FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, LastMessageId), + 136 + ); + assert_eq!( + FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, LastCallbackId), + 140 + ); assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, PostCount), 256); assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, ReturnCount), 384); - assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, LogSequenceNumber), 512); + assert_eq!( + FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, LogSequenceNumber), + 512 + ); assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, UserLock), 640); assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, EndMagic), 648); assert_eq!(size_of::(), 20); @@ -977,7 +1097,10 @@ fn ntpebteb() { assert_eq!(FIELD_OFFSET!(PEB, CloudFileFlags), 1120); assert_eq!(FIELD_OFFSET!(PEB, CloudFileDiagFlags), 1124); assert_eq!(FIELD_OFFSET!(PEB, PlaceholderCompatibilityMode), 1128); - assert_eq!(FIELD_OFFSET!(PEB, PlaceholderCompatibilityModeReserved), 1129); + assert_eq!( + FIELD_OFFSET!(PEB, PlaceholderCompatibilityModeReserved), + 1129 + ); assert_eq!(FIELD_OFFSET!(PEB, LeapSecondData), 1136); assert_eq!(FIELD_OFFSET!(PEB, LeapSecondFlags), 1140); assert_eq!(FIELD_OFFSET!(PEB, NtGlobalFlag2), 1144); @@ -1211,8 +1334,14 @@ fn ntpsapi() { assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 36); assert_eq!(align_of::(), 4); - assert_eq!(size_of::(), 12); - assert_eq!(align_of::(), 4); + assert_eq!( + size_of::(), + 12 + ); + assert_eq!( + align_of::(), + 4 + ); assert_eq!(size_of::(), 12); assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 28); @@ -1266,7 +1395,10 @@ fn ntpsapi() { assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 4); - assert_eq!(align_of::(), 4); + assert_eq!( + align_of::(), + 4 + ); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 8); @@ -1439,8 +1571,14 @@ fn ntrtl() { assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 68); assert_eq!(align_of::(), 4); - assert_eq!(size_of::(), 16); - assert_eq!(align_of::(), 4); + assert_eq!( + size_of::(), + 16 + ); + assert_eq!( + align_of::(), + 4 + ); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 24); @@ -1517,22 +1655,58 @@ fn ntrtl() { assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 8); - assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 8); - assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 8); - assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 16); - assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 16); - assert_eq!(align_of::(), 8); + assert_eq!( + size_of::(), + 8 + ); + assert_eq!( + align_of::(), + 8 + ); + assert_eq!( + size_of::(), + 8 + ); + assert_eq!( + align_of::(), + 8 + ); + assert_eq!( + size_of::(), + 8 + ); + assert_eq!( + align_of::(), + 8 + ); + assert_eq!( + size_of::(), + 16 + ); + assert_eq!( + align_of::(), + 8 + ); + assert_eq!( + size_of::(), + 16 + ); + assert_eq!( + align_of::(), + 8 + ); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 24); assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 48); - assert_eq!(align_of::(), 8); + assert_eq!( + size_of::(), + 48 + ); + assert_eq!( + align_of::(), + 8 + ); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 8); @@ -1560,20 +1734,44 @@ fn ntsam() { assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, ForceLogoff), 0); assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, OemInformation), 8); assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, DomainName), 16); - assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, ReplicaSourceNodeName), 24); - assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, DomainModifiedCount), 32); - assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, DomainServerState), 40); - assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, DomainServerRole), 44); - assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, UasCompatibilityRequired), 48); + assert_eq!( + FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, ReplicaSourceNodeName), + 24 + ); + assert_eq!( + FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, DomainModifiedCount), + 32 + ); + assert_eq!( + FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, DomainServerState), + 40 + ); + assert_eq!( + FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, DomainServerRole), + 44 + ); + assert_eq!( + FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, UasCompatibilityRequired), + 48 + ); assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, UserCount), 52); assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, GroupCount), 56); assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, AliasCount), 60); assert_eq!(size_of::(), 84); assert_eq!(align_of::(), 4); assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION2, I1), 0); - assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION2, LockoutDuration), 64); - assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION2, LockoutObservationWindow), 72); - assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION2, LockoutThreshold), 80); + assert_eq!( + FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION2, LockoutDuration), + 64 + ); + assert_eq!( + FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION2, LockoutObservationWindow), + 72 + ); + assert_eq!( + FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION2, LockoutThreshold), + 80 + ); assert_eq!(size_of::(), 1); assert_eq!(align_of::(), 1); assert_eq!(size_of::(), 8); @@ -1641,7 +1839,10 @@ fn ntsam() { assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, UserId), 16); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, PrimaryGroupId), 20); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, HomeDirectory), 24); - assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, HomeDirectoryDrive), 32); + assert_eq!( + FIELD_OFFSET!(USER_LOGON_INFORMATION, HomeDirectoryDrive), + 32 + ); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, ScriptPath), 40); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, ProfilePath), 48); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, WorkStations), 56); @@ -1649,11 +1850,17 @@ fn ntsam() { assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, LastLogoff), 72); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, PasswordLastSet), 80); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, PasswordCanChange), 88); - assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, PasswordMustChange), 96); + assert_eq!( + FIELD_OFFSET!(USER_LOGON_INFORMATION, PasswordMustChange), + 96 + ); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, LogonHours), 104); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, BadPasswordCount), 112); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, LogonCount), 114); - assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, UserAccountControl), 116); + assert_eq!( + FIELD_OFFSET!(USER_LOGON_INFORMATION, UserAccountControl), + 116 + ); assert_eq!(size_of::(), 120); assert_eq!(align_of::(), 4); assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, UserName), 0); @@ -1661,7 +1868,10 @@ fn ntsam() { assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, UserId), 16); assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, PrimaryGroupId), 20); assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, HomeDirectory), 24); - assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, HomeDirectoryDrive), 32); + assert_eq!( + FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, HomeDirectoryDrive), + 32 + ); assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, ScriptPath), 40); assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, ProfilePath), 48); assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, AdminComment), 56); @@ -1669,11 +1879,20 @@ fn ntsam() { assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, LastLogon), 72); assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, LastLogoff), 80); assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, LogonHours), 88); - assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, BadPasswordCount), 96); + assert_eq!( + FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, BadPasswordCount), + 96 + ); assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, LogonCount), 98); - assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, PasswordLastSet), 100); + assert_eq!( + FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, PasswordLastSet), + 100 + ); assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, AccountExpires), 108); - assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, UserAccountControl), 116); + assert_eq!( + FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, UserAccountControl), + 116 + ); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 8); @@ -1771,7 +1990,10 @@ fn ntwow64() { assert_eq!(FIELD_OFFSET!(PEB_LDR_DATA32, SsHandle), 8); assert_eq!(FIELD_OFFSET!(PEB_LDR_DATA32, InLoadOrderModuleList), 12); assert_eq!(FIELD_OFFSET!(PEB_LDR_DATA32, InMemoryOrderModuleList), 20); - assert_eq!(FIELD_OFFSET!(PEB_LDR_DATA32, InInitializationOrderModuleList), 28); + assert_eq!( + FIELD_OFFSET!(PEB_LDR_DATA32, InInitializationOrderModuleList), + 28 + ); assert_eq!(FIELD_OFFSET!(PEB_LDR_DATA32, EntryInProgress), 36); assert_eq!(FIELD_OFFSET!(PEB_LDR_DATA32, ShutdownInProgress), 40); assert_eq!(FIELD_OFFSET!(PEB_LDR_DATA32, ShutdownThreadId), 44); @@ -1798,8 +2020,14 @@ fn ntwow64() { assert_eq!(align_of::(), 8); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, InLoadOrderLinks), 0); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, InMemoryOrderLinks), 8); - assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, u1.InInitializationOrderLinks), 16); - assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, u1.InProgressLinks), 16); + assert_eq!( + FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, u1.InInitializationOrderLinks), + 16 + ); + assert_eq!( + FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, u1.InProgressLinks), + 16 + ); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, DllBase), 24); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, EntryPoint), 28); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, SizeOfImage), 32); @@ -1811,22 +2039,43 @@ fn ntwow64() { assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, TlsIndex), 58); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, HashLinks), 60); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, TimeDateStamp), 68); - assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, EntryPointActivationContext), 72); + assert_eq!( + FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, EntryPointActivationContext), + 72 + ); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, Lock), 76); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, DdagNode), 80); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, NodeModuleLink), 84); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, LoadContext), 92); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, ParentDllBase), 96); - assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, SwitchBackContext), 100); - assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, BaseAddressIndexNode), 104); - assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, MappingInfoIndexNode), 116); + assert_eq!( + FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, SwitchBackContext), + 100 + ); + assert_eq!( + FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, BaseAddressIndexNode), + 104 + ); + assert_eq!( + FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, MappingInfoIndexNode), + 116 + ); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, OriginalBase), 128); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, LoadTime), 136); - assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, BaseNameHashValue), 144); + assert_eq!( + FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, BaseNameHashValue), + 144 + ); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, LoadReason), 148); - assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, ImplicitPathOptions), 152); + assert_eq!( + FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, ImplicitPathOptions), + 152 + ); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, ReferenceCount), 156); - assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, DependentLoadFlags), 160); + assert_eq!( + FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, DependentLoadFlags), + 160 + ); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, SigningLevel), 164); assert_eq!(size_of::(), 12); assert_eq!(align_of::(), 4); @@ -1840,39 +2089,111 @@ fn ntwow64() { assert_eq!(FIELD_OFFSET!(RTL_DRIVE_LETTER_CURDIR32, DosPath), 8); assert_eq!(size_of::(), 676); assert_eq!(align_of::(), 4); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, MaximumLength), 0); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, MaximumLength), + 0 + ); assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, Length), 4); assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, Flags), 8); assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, DebugFlags), 12); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ConsoleHandle), 16); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ConsoleFlags), 20); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, StandardInput), 24); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, StandardOutput), 28); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, StandardError), 32); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CurrentDirectory), 36); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ConsoleHandle), + 16 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ConsoleFlags), + 20 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, StandardInput), + 24 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, StandardOutput), + 28 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, StandardError), + 32 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CurrentDirectory), + 36 + ); assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, DllPath), 48); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ImagePathName), 56); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CommandLine), 64); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, Environment), 72); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ImagePathName), + 56 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CommandLine), + 64 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, Environment), + 72 + ); assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, StartingX), 76); assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, StartingY), 80); assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CountX), 84); assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CountY), 88); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CountCharsX), 92); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CountCharsY), 96); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, FillAttribute), 100); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, WindowFlags), 104); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ShowWindowFlags), 108); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, WindowTitle), 112); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, DesktopInfo), 120); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CountCharsX), + 92 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CountCharsY), + 96 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, FillAttribute), + 100 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, WindowFlags), + 104 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ShowWindowFlags), + 108 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, WindowTitle), + 112 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, DesktopInfo), + 120 + ); assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ShellInfo), 128); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, RuntimeData), 136); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CurrentDirectories), 144); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, EnvironmentSize), 656); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, EnvironmentVersion), 660); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, PackageDependencyData), 664); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ProcessGroupId), 668); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, LoaderThreads), 672); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, RuntimeData), + 136 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CurrentDirectories), + 144 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, EnvironmentSize), + 656 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, EnvironmentVersion), + 660 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, PackageDependencyData), + 664 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ProcessGroupId), + 668 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, LoaderThreads), + 672 + ); assert_eq!(size_of::(), 1136); assert_eq!(align_of::(), 8); assert_eq!(FIELD_OFFSET!(PEB32, InheritedAddressSpace), 0); @@ -1937,7 +2258,10 @@ fn ntwow64() { assert_eq!(FIELD_OFFSET!(PEB32, CSDVersion), 496); assert_eq!(FIELD_OFFSET!(PEB32, ActivationContextData), 504); assert_eq!(FIELD_OFFSET!(PEB32, ProcessAssemblyStorageMap), 508); - assert_eq!(FIELD_OFFSET!(PEB32, SystemDefaultActivationContextData), 512); + assert_eq!( + FIELD_OFFSET!(PEB32, SystemDefaultActivationContextData), + 512 + ); assert_eq!(FIELD_OFFSET!(PEB32, SystemAssemblyStorageMap), 516); assert_eq!(FIELD_OFFSET!(PEB32, MinimumStackCommit), 520); assert_eq!(FIELD_OFFSET!(PEB32, FlsCallback), 524); @@ -1958,7 +2282,10 @@ fn ntwow64() { assert_eq!(FIELD_OFFSET!(PEB32, CloudFileFlags), 1120); assert_eq!(FIELD_OFFSET!(PEB32, CloudFileDiagFlags), 1124); assert_eq!(FIELD_OFFSET!(PEB32, PlaceholderCompatibilityMode), 1128); - assert_eq!(FIELD_OFFSET!(PEB32, PlaceholderCompatibilityModeReserved), 1129); + assert_eq!( + FIELD_OFFSET!(PEB32, PlaceholderCompatibilityModeReserved), + 1129 + ); assert_eq!(size_of::(), 1248); assert_eq!(align_of::(), 4); assert_eq!(FIELD_OFFSET!(GDI_TEB_BATCH32, Offset), 0); @@ -1981,7 +2308,10 @@ fn ntwow64() { assert_eq!(FIELD_OFFSET!(TEB32, WOW32Reserved), 192); assert_eq!(FIELD_OFFSET!(TEB32, CurrentLocale), 196); assert_eq!(FIELD_OFFSET!(TEB32, FpSoftwareStatusRegister), 200); - assert_eq!(FIELD_OFFSET!(TEB32, ReservedForDebuggerInstrumentation), 204); + assert_eq!( + FIELD_OFFSET!(TEB32, ReservedForDebuggerInstrumentation), + 204 + ); assert_eq!(FIELD_OFFSET!(TEB32, SystemReserved1), 268); assert_eq!(FIELD_OFFSET!(TEB32, WorkingOnBehalfTicket), 412); assert_eq!(FIELD_OFFSET!(TEB32, ExceptionCode), 420); @@ -2074,7 +2404,10 @@ fn subprocesstag() { assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 8); - assert_eq!(align_of::(), 4); + assert_eq!( + align_of::(), + 4 + ); assert_eq!(size_of::(), 16); assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 4); @@ -2271,8 +2604,14 @@ fn winsta() { assert_eq!(align_of::(), 4); assert_eq!(FIELD_OFFSET!(CACHE_STATISTICS, ProtocolType), 0); assert_eq!(FIELD_OFFSET!(CACHE_STATISTICS, Length), 2); - assert_eq!(FIELD_OFFSET!(CACHE_STATISTICS, Specific.ReservedCacheStats), 4); - assert_eq!(FIELD_OFFSET!(CACHE_STATISTICS, Specific.TShareCacheStats), 4); + assert_eq!( + FIELD_OFFSET!(CACHE_STATISTICS, Specific.ReservedCacheStats), + 4 + ); + assert_eq!( + FIELD_OFFSET!(CACHE_STATISTICS, Specific.TShareCacheStats), + 4 + ); assert_eq!(FIELD_OFFSET!(CACHE_STATISTICS, Specific.Reserved), 4); assert_eq!(FIELD_OFFSET!(CACHE_STATISTICS, Specific), 4); assert_eq!(size_of::(), 1012); @@ -2317,13 +2656,22 @@ fn winsta() { assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENTDATA, fUnicodeData), 8); assert_eq!(size_of::(), 72); assert_eq!(align_of::(), 8); - assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, RemainingSessionCapacity), 0); + assert_eq!( + FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, RemainingSessionCapacity), + 0 + ); assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, LoadFactor), 4); assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, TotalSessions), 8); - assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, DisconnectedSessions), 12); + assert_eq!( + FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, DisconnectedSessions), + 12 + ); assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, IdleCPU), 16); assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, TotalCPU), 24); - assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, RawSessionCapacity), 32); + assert_eq!( + FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, RawSessionCapacity), + 32 + ); assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, reserved), 36); assert_eq!(size_of::(), 16); assert_eq!(align_of::(), 4); @@ -2346,39 +2694,114 @@ fn winsta() { assert_eq!(FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, u.ipv4.sin_addr), 8); assert_eq!(FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, u.ipv4.sin_zero), 12); assert_eq!(FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, u.ipv6.sin6_port), 4); - assert_eq!(FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, u.ipv6.sin6_flowinfo), 8); + assert_eq!( + FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, u.ipv6.sin6_flowinfo), + 8 + ); assert_eq!(FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, u.ipv6.sin6_addr), 12); - assert_eq!(FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, u.ipv6.sin6_scope_id), 28); + assert_eq!( + FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, u.ipv6.sin6_scope_id), + 28 + ); assert_eq!(size_of::(), 1216); assert_eq!(align_of::(), 8); assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, SessionId), 0); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, SessionState), 4); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, SessionFlags), 8); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, WinStationName), 12); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, SessionState), + 4 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, SessionFlags), + 8 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, WinStationName), + 12 + ); assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, UserName), 78); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, DomainName), 120); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, LogonTime), 160); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, ConnectTime), 168); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, DisconnectTime), 176); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, LastInputTime), 184); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, CurrentTime), 192); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, ProtocolStatus), 200); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, DomainName), + 120 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, LogonTime), + 160 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, ConnectTime), + 168 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, DisconnectTime), + 176 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, LastInputTime), + 184 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, CurrentTime), + 192 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, ProtocolStatus), + 200 + ); assert_eq!(size_of::(), 2240); assert_eq!(align_of::(), 8); assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SessionId), 0); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SessionState), 4); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SessionFlags), 8); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, WinStationName), 12); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SamCompatibleUserName), 78); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SamCompatibleDomainName), 120); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, LogonTime), 160); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, ConnectTime), 168); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, DisconnectTime), 176); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, LastInputTime), 184); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, CurrentTime), 192); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, ProtocolStatus), 200); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, UserName), 1212); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, DomainName), 1726); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SessionState), + 4 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SessionFlags), + 8 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, WinStationName), + 12 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SamCompatibleUserName), + 78 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SamCompatibleDomainName), + 120 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, LogonTime), + 160 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, ConnectTime), + 168 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, DisconnectTime), + 176 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, LastInputTime), + 184 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, CurrentTime), + 192 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, ProtocolStatus), + 200 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, UserName), + 1212 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, DomainName), + 1726 + ); assert_eq!(size_of::(), 2248); assert_eq!(align_of::(), 8); assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX, Level), 0); @@ -2391,8 +2814,14 @@ fn winsta() { assert_eq!(FIELD_OFFSET!(TS_PROCESS_INFORMATION_NT4, Pad), 12); assert_eq!(size_of::(), 136); assert_eq!(align_of::(), 8); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, NextEntryOffset), 0); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, NumberOfThreads), 4); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, NextEntryOffset), + 0 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, NumberOfThreads), + 4 + ); assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, SpareLi1), 8); assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, SpareLi2), 16); assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, SpareLi3), 24); @@ -2401,23 +2830,62 @@ fn winsta() { assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, KernelTime), 48); assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, ImageName), 56); assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, BasePriority), 64); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, UniqueProcessId), 68); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, InheritedFromUniqueProcessId), 72); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, UniqueProcessId), + 68 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, InheritedFromUniqueProcessId), + 72 + ); assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, HandleCount), 76); assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, SessionId), 80); assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, SpareUl3), 84); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PeakVirtualSize), 88); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PeakVirtualSize), + 88 + ); assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, VirtualSize), 92); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PageFaultCount), 96); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PeakWorkingSetSize), 100); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, WorkingSetSize), 104); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, QuotaPeakPagedPoolUsage), 108); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, QuotaPagedPoolUsage), 112); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, QuotaPeakNonPagedPoolUsage), 116); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, QuotaNonPagedPoolUsage), 120); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PagefileUsage), 124); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PeakPagefileUsage), 128); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PrivatePageCount), 132); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PageFaultCount), + 96 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PeakWorkingSetSize), + 100 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, WorkingSetSize), + 104 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, QuotaPeakPagedPoolUsage), + 108 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, QuotaPagedPoolUsage), + 112 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, QuotaPeakNonPagedPoolUsage), + 116 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, QuotaNonPagedPoolUsage), + 120 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PagefileUsage), + 124 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PeakPagefileUsage), + 128 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PrivatePageCount), + 132 + ); assert_eq!(size_of::(), 12); assert_eq!(align_of::(), 4); assert_eq!(FIELD_OFFSET!(TS_ALL_PROCESSES_INFO, pTsProcessInfo), 0); diff --git a/tests/layout_x86_64.rs b/tests/layout_x86_64.rs index e4f32eb..0bca46b 100644 --- a/tests/layout_x86_64.rs +++ b/tests/layout_x86_64.rs @@ -129,8 +129,14 @@ fn ntexapi() { assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 12); assert_eq!(align_of::(), 4); - assert_eq!(size_of::(), 24); - assert_eq!(align_of::(), 8); + assert_eq!( + size_of::(), + 24 + ); + assert_eq!( + align_of::(), + 8 + ); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 16); @@ -216,15 +222,24 @@ fn ntexapi() { assert_eq!(size_of::(), 24); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 8); - assert_eq!(align_of::(), 8); + assert_eq!( + align_of::(), + 8 + ); assert_eq!(size_of::(), 40); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 24); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 32); assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 8); - assert_eq!(align_of::(), 4); + assert_eq!( + size_of::(), + 8 + ); + assert_eq!( + align_of::(), + 4 + ); assert_eq!(size_of::(), 40); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 16); @@ -235,8 +250,14 @@ fn ntexapi() { assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 4); - assert_eq!(size_of::(), 24); - assert_eq!(align_of::(), 8); + assert_eq!( + size_of::(), + 24 + ); + assert_eq!( + align_of::(), + 8 + ); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 8); @@ -259,8 +280,14 @@ fn ntexapi() { assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 4); assert_eq!(align_of::(), 4); - assert_eq!(size_of::(), 12); - assert_eq!(align_of::(), 4); + assert_eq!( + size_of::(), + 12 + ); + assert_eq!( + align_of::(), + 4 + ); assert_eq!(size_of::(), 32); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 16); @@ -281,8 +308,14 @@ fn ntexapi() { assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 32); assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 8); - assert_eq!(align_of::(), 4); + assert_eq!( + size_of::(), + 8 + ); + assert_eq!( + align_of::(), + 4 + ); assert_eq!(size_of::(), 48); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 32); @@ -315,8 +348,14 @@ fn ntexapi() { assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 368); assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 1); - assert_eq!(align_of::(), 1); + assert_eq!( + size_of::(), + 1 + ); + assert_eq!( + align_of::(), + 1 + ); assert_eq!(size_of::(), 3); assert_eq!(align_of::(), 1); assert_eq!(size_of::(), 8); @@ -351,14 +390,32 @@ fn ntexapi() { assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 16); assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 144); - assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 8); - assert_eq!(align_of::(), 4); + assert_eq!( + size_of::(), + 144 + ); + assert_eq!( + align_of::(), + 8 + ); + assert_eq!( + size_of::(), + 8 + ); + assert_eq!( + align_of::(), + 4 + ); assert_eq!(size_of::(), 56); assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 16); - assert_eq!(align_of::(), 8); + assert_eq!( + size_of::(), + 16 + ); + assert_eq!( + align_of::(), + 8 + ); assert_eq!(size_of::(), 24); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 24); @@ -373,8 +430,14 @@ fn ntexapi() { assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 4); assert_eq!(align_of::(), 4); - assert_eq!(size_of::(), 24); - assert_eq!(align_of::(), 8); + assert_eq!( + size_of::(), + 24 + ); + assert_eq!( + align_of::(), + 8 + ); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 4); @@ -422,20 +485,29 @@ fn ntexapi() { assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, AitSamplingValue), 584); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, AppCompatFlag), 588); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, RNGSeedVersion), 592); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, GlobalValidationRunlevel), 600); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, GlobalValidationRunlevel), + 600 + ); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TimeZoneBiasStamp), 604); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, NtBuildNumber), 608); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, NtProductType), 612); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, ProductTypeIsValid), 616); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, Reserved0), 617); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, NativeProcessorArchitecture), 618); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, NativeProcessorArchitecture), + 618 + ); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, NtMajorVersion), 620); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, NtMinorVersion), 624); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, ProcessorFeatures), 628); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, Reserved1), 692); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, Reserved3), 696); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TimeSlip), 700); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, AlternativeArchitecture), 704); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, AlternativeArchitecture), + 704 + ); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, BootId), 708); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, SystemExpirationDate), 712); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, SuiteMask), 720); @@ -445,7 +517,10 @@ fn ntexapi() { assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, ActiveConsoleId), 728); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, DismountCount), 732); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, ComPlusPackage), 736); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, LastSystemRITEventTickCount), 740); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, LastSystemRITEventTickCount), + 740 + ); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, NumberOfPhysicalPages), 744); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, SafeBootMode), 748); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, VirtualizationFlags), 749); @@ -461,19 +536,46 @@ fn ntexapi() { // assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TickCountPad), 812); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, Cookie), 816); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, CookiePad), 820); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, ConsoleSessionForegroundProcessId), 824); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, ConsoleSessionForegroundProcessId), + 824 + ); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TimeUpdateLock), 832); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, BaselineSystemTimeQpc), 840); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, BaselineInterruptTimeQpc), 848); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, QpcSystemTimeIncrement), 856); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, QpcInterruptTimeIncrement), 864); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, QpcSystemTimeIncrementShift), 872); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, QpcInterruptTimeIncrementShift), 873); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, UnparkedProcessorCount), 874); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, BaselineInterruptTimeQpc), + 848 + ); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, QpcSystemTimeIncrement), + 856 + ); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, QpcInterruptTimeIncrement), + 864 + ); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, QpcSystemTimeIncrementShift), + 872 + ); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, QpcInterruptTimeIncrementShift), + 873 + ); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, UnparkedProcessorCount), + 874 + ); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, EnclaveFeatureMask), 876); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TelemetryCoverageRound), 892); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, TelemetryCoverageRound), + 892 + ); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, UserModeGlobalLogger), 896); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, ImageFileExecutionOptions), 928); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, ImageFileExecutionOptions), + 928 + ); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, LangGenerationCount), 932); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, Reserved4), 936); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, InterruptTimeBias), 944); @@ -482,8 +584,14 @@ fn ntexapi() { assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, ActiveGroupCount), 964); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, Reserved9), 965); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, QpcData), 966); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TimeZoneBiasEffectiveStart), 968); - assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TimeZoneBiasEffectiveEnd), 976); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, TimeZoneBiasEffectiveStart), + 968 + ); + assert_eq!( + FIELD_OFFSET!(KUSER_SHARED_DATA, TimeZoneBiasEffectiveEnd), + 976 + ); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, XState), 984); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 2); @@ -769,14 +877,29 @@ fn ntlpcapi() { assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, BitmapSize), 24); assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, DataOffset), 28); assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, DataSize), 32); - assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, AttributeFlags), 36); - assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, AttributeSize), 40); + assert_eq!( + FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, AttributeFlags), + 36 + ); + assert_eq!( + FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, AttributeSize), + 40 + ); assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, State), 128); - assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, LastMessageId), 136); - assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, LastCallbackId), 140); + assert_eq!( + FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, LastMessageId), + 136 + ); + assert_eq!( + FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, LastCallbackId), + 140 + ); assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, PostCount), 256); assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, ReturnCount), 384); - assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, LogSequenceNumber), 512); + assert_eq!( + FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, LogSequenceNumber), + 512 + ); assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, UserLock), 640); assert_eq!(FIELD_OFFSET!(ALPC_COMPLETION_LIST_HEADER, EndMagic), 648); assert_eq!(size_of::(), 32); @@ -977,7 +1100,10 @@ fn ntpebteb() { assert_eq!(FIELD_OFFSET!(PEB, CloudFileFlags), 1960); assert_eq!(FIELD_OFFSET!(PEB, CloudFileDiagFlags), 1964); assert_eq!(FIELD_OFFSET!(PEB, PlaceholderCompatibilityMode), 1968); - assert_eq!(FIELD_OFFSET!(PEB, PlaceholderCompatibilityModeReserved), 1969); + assert_eq!( + FIELD_OFFSET!(PEB, PlaceholderCompatibilityModeReserved), + 1969 + ); assert_eq!(FIELD_OFFSET!(PEB, LeapSecondData), 1976); assert_eq!(FIELD_OFFSET!(PEB, LeapSecondFlags), 1984); assert_eq!(FIELD_OFFSET!(PEB, NtGlobalFlag2), 1988); @@ -1211,8 +1337,14 @@ fn ntpsapi() { assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 56); assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 16); - assert_eq!(align_of::(), 8); + assert_eq!( + size_of::(), + 16 + ); + assert_eq!( + align_of::(), + 8 + ); assert_eq!(size_of::(), 24); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 40); @@ -1266,7 +1398,10 @@ fn ntpsapi() { assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 8); - assert_eq!(align_of::(), 8); + assert_eq!( + align_of::(), + 8 + ); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 8); @@ -1297,7 +1432,10 @@ fn ntpsapi() { assert_eq!(FIELD_OFFSET!(RTL_UMS_CONTEXT, Terminated), 1276); assert_eq!(FIELD_OFFSET!(RTL_UMS_CONTEXT, DebugActive), 1280); assert_eq!(FIELD_OFFSET!(RTL_UMS_CONTEXT, RunningOnSelfThread), 1284); - assert_eq!(FIELD_OFFSET!(RTL_UMS_CONTEXT, DenyRunningOnSelfThread), 1288); + assert_eq!( + FIELD_OFFSET!(RTL_UMS_CONTEXT, DenyRunningOnSelfThread), + 1288 + ); assert_eq!(FIELD_OFFSET!(RTL_UMS_CONTEXT, Flags), 1292); assert_eq!(FIELD_OFFSET!(RTL_UMS_CONTEXT, KernelUpdateLock), 1296); assert_eq!(FIELD_OFFSET!(RTL_UMS_CONTEXT, PrimaryClientID), 1304); @@ -1439,8 +1577,14 @@ fn ntrtl() { assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 104); assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 32); - assert_eq!(align_of::(), 8); + assert_eq!( + size_of::(), + 32 + ); + assert_eq!( + align_of::(), + 8 + ); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 24); @@ -1519,22 +1663,58 @@ fn ntrtl() { assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 8); - assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 8); - assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 8); - assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 16); - assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 16); - assert_eq!(align_of::(), 8); + assert_eq!( + size_of::(), + 8 + ); + assert_eq!( + align_of::(), + 8 + ); + assert_eq!( + size_of::(), + 8 + ); + assert_eq!( + align_of::(), + 8 + ); + assert_eq!( + size_of::(), + 8 + ); + assert_eq!( + align_of::(), + 8 + ); + assert_eq!( + size_of::(), + 16 + ); + assert_eq!( + align_of::(), + 8 + ); + assert_eq!( + size_of::(), + 16 + ); + assert_eq!( + align_of::(), + 8 + ); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 24); assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 48); - assert_eq!(align_of::(), 8); + assert_eq!( + size_of::(), + 48 + ); + assert_eq!( + align_of::(), + 8 + ); assert_eq!(size_of::(), 8); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 8); @@ -1562,20 +1742,44 @@ fn ntsam() { assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, ForceLogoff), 0); assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, OemInformation), 8); assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, DomainName), 24); - assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, ReplicaSourceNodeName), 40); - assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, DomainModifiedCount), 56); - assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, DomainServerState), 64); - assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, DomainServerRole), 68); - assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, UasCompatibilityRequired), 72); + assert_eq!( + FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, ReplicaSourceNodeName), + 40 + ); + assert_eq!( + FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, DomainModifiedCount), + 56 + ); + assert_eq!( + FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, DomainServerState), + 64 + ); + assert_eq!( + FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, DomainServerRole), + 68 + ); + assert_eq!( + FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, UasCompatibilityRequired), + 72 + ); assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, UserCount), 76); assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, GroupCount), 80); assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION, AliasCount), 84); assert_eq!(size_of::(), 108); assert_eq!(align_of::(), 4); assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION2, I1), 0); - assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION2, LockoutDuration), 88); - assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION2, LockoutObservationWindow), 96); - assert_eq!(FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION2, LockoutThreshold), 104); + assert_eq!( + FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION2, LockoutDuration), + 88 + ); + assert_eq!( + FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION2, LockoutObservationWindow), + 96 + ); + assert_eq!( + FIELD_OFFSET!(DOMAIN_GENERAL_INFORMATION2, LockoutThreshold), + 104 + ); assert_eq!(size_of::(), 1); assert_eq!(align_of::(), 1); assert_eq!(size_of::(), 8); @@ -1643,19 +1847,31 @@ fn ntsam() { assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, UserId), 32); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, PrimaryGroupId), 36); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, HomeDirectory), 40); - assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, HomeDirectoryDrive), 56); + assert_eq!( + FIELD_OFFSET!(USER_LOGON_INFORMATION, HomeDirectoryDrive), + 56 + ); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, ScriptPath), 72); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, ProfilePath), 88); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, WorkStations), 104); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, LastLogon), 120); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, LastLogoff), 128); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, PasswordLastSet), 136); - assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, PasswordCanChange), 144); - assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, PasswordMustChange), 152); + assert_eq!( + FIELD_OFFSET!(USER_LOGON_INFORMATION, PasswordCanChange), + 144 + ); + assert_eq!( + FIELD_OFFSET!(USER_LOGON_INFORMATION, PasswordMustChange), + 152 + ); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, LogonHours), 160); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, BadPasswordCount), 176); assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, LogonCount), 178); - assert_eq!(FIELD_OFFSET!(USER_LOGON_INFORMATION, UserAccountControl), 180); + assert_eq!( + FIELD_OFFSET!(USER_LOGON_INFORMATION, UserAccountControl), + 180 + ); assert_eq!(size_of::(), 192); assert_eq!(align_of::(), 4); assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, UserName), 0); @@ -1663,7 +1879,10 @@ fn ntsam() { assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, UserId), 32); assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, PrimaryGroupId), 36); assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, HomeDirectory), 40); - assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, HomeDirectoryDrive), 56); + assert_eq!( + FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, HomeDirectoryDrive), + 56 + ); assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, ScriptPath), 72); assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, ProfilePath), 88); assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, AdminComment), 104); @@ -1671,11 +1890,20 @@ fn ntsam() { assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, LastLogon), 136); assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, LastLogoff), 144); assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, LogonHours), 152); - assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, BadPasswordCount), 168); + assert_eq!( + FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, BadPasswordCount), + 168 + ); assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, LogonCount), 170); - assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, PasswordLastSet), 172); + assert_eq!( + FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, PasswordLastSet), + 172 + ); assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, AccountExpires), 180); - assert_eq!(FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, UserAccountControl), 188); + assert_eq!( + FIELD_OFFSET!(USER_ACCOUNT_INFORMATION, UserAccountControl), + 188 + ); assert_eq!(size_of::(), 16); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 16); @@ -1773,7 +2001,10 @@ fn ntwow64() { assert_eq!(FIELD_OFFSET!(PEB_LDR_DATA32, SsHandle), 8); assert_eq!(FIELD_OFFSET!(PEB_LDR_DATA32, InLoadOrderModuleList), 12); assert_eq!(FIELD_OFFSET!(PEB_LDR_DATA32, InMemoryOrderModuleList), 20); - assert_eq!(FIELD_OFFSET!(PEB_LDR_DATA32, InInitializationOrderModuleList), 28); + assert_eq!( + FIELD_OFFSET!(PEB_LDR_DATA32, InInitializationOrderModuleList), + 28 + ); assert_eq!(FIELD_OFFSET!(PEB_LDR_DATA32, EntryInProgress), 36); assert_eq!(FIELD_OFFSET!(PEB_LDR_DATA32, ShutdownInProgress), 40); assert_eq!(FIELD_OFFSET!(PEB_LDR_DATA32, ShutdownThreadId), 44); @@ -1800,8 +2031,14 @@ fn ntwow64() { assert_eq!(align_of::(), 8); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, InLoadOrderLinks), 0); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, InMemoryOrderLinks), 8); - assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, u1.InInitializationOrderLinks), 16); - assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, u1.InProgressLinks), 16); + assert_eq!( + FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, u1.InInitializationOrderLinks), + 16 + ); + assert_eq!( + FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, u1.InProgressLinks), + 16 + ); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, DllBase), 24); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, EntryPoint), 28); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, SizeOfImage), 32); @@ -1813,22 +2050,43 @@ fn ntwow64() { assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, TlsIndex), 58); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, HashLinks), 60); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, TimeDateStamp), 68); - assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, EntryPointActivationContext), 72); + assert_eq!( + FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, EntryPointActivationContext), + 72 + ); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, Lock), 76); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, DdagNode), 80); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, NodeModuleLink), 84); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, LoadContext), 92); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, ParentDllBase), 96); - assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, SwitchBackContext), 100); - assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, BaseAddressIndexNode), 104); - assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, MappingInfoIndexNode), 116); + assert_eq!( + FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, SwitchBackContext), + 100 + ); + assert_eq!( + FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, BaseAddressIndexNode), + 104 + ); + assert_eq!( + FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, MappingInfoIndexNode), + 116 + ); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, OriginalBase), 128); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, LoadTime), 136); - assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, BaseNameHashValue), 144); + assert_eq!( + FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, BaseNameHashValue), + 144 + ); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, LoadReason), 148); - assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, ImplicitPathOptions), 152); + assert_eq!( + FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, ImplicitPathOptions), + 152 + ); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, ReferenceCount), 156); - assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, DependentLoadFlags), 160); + assert_eq!( + FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, DependentLoadFlags), + 160 + ); assert_eq!(FIELD_OFFSET!(LDR_DATA_TABLE_ENTRY32, SigningLevel), 164); assert_eq!(size_of::(), 12); assert_eq!(align_of::(), 4); @@ -1842,39 +2100,111 @@ fn ntwow64() { assert_eq!(FIELD_OFFSET!(RTL_DRIVE_LETTER_CURDIR32, DosPath), 8); assert_eq!(size_of::(), 676); assert_eq!(align_of::(), 4); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, MaximumLength), 0); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, MaximumLength), + 0 + ); assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, Length), 4); assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, Flags), 8); assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, DebugFlags), 12); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ConsoleHandle), 16); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ConsoleFlags), 20); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, StandardInput), 24); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, StandardOutput), 28); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, StandardError), 32); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CurrentDirectory), 36); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ConsoleHandle), + 16 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ConsoleFlags), + 20 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, StandardInput), + 24 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, StandardOutput), + 28 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, StandardError), + 32 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CurrentDirectory), + 36 + ); assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, DllPath), 48); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ImagePathName), 56); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CommandLine), 64); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, Environment), 72); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ImagePathName), + 56 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CommandLine), + 64 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, Environment), + 72 + ); assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, StartingX), 76); assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, StartingY), 80); assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CountX), 84); assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CountY), 88); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CountCharsX), 92); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CountCharsY), 96); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, FillAttribute), 100); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, WindowFlags), 104); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ShowWindowFlags), 108); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, WindowTitle), 112); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, DesktopInfo), 120); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CountCharsX), + 92 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CountCharsY), + 96 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, FillAttribute), + 100 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, WindowFlags), + 104 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ShowWindowFlags), + 108 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, WindowTitle), + 112 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, DesktopInfo), + 120 + ); assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ShellInfo), 128); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, RuntimeData), 136); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CurrentDirectories), 144); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, EnvironmentSize), 656); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, EnvironmentVersion), 660); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, PackageDependencyData), 664); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ProcessGroupId), 668); - assert_eq!(FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, LoaderThreads), 672); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, RuntimeData), + 136 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, CurrentDirectories), + 144 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, EnvironmentSize), + 656 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, EnvironmentVersion), + 660 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, PackageDependencyData), + 664 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, ProcessGroupId), + 668 + ); + assert_eq!( + FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, LoaderThreads), + 672 + ); assert_eq!(size_of::(), 1136); assert_eq!(align_of::(), 8); assert_eq!(FIELD_OFFSET!(PEB32, InheritedAddressSpace), 0); @@ -1939,7 +2269,10 @@ fn ntwow64() { assert_eq!(FIELD_OFFSET!(PEB32, CSDVersion), 496); assert_eq!(FIELD_OFFSET!(PEB32, ActivationContextData), 504); assert_eq!(FIELD_OFFSET!(PEB32, ProcessAssemblyStorageMap), 508); - assert_eq!(FIELD_OFFSET!(PEB32, SystemDefaultActivationContextData), 512); + assert_eq!( + FIELD_OFFSET!(PEB32, SystemDefaultActivationContextData), + 512 + ); assert_eq!(FIELD_OFFSET!(PEB32, SystemAssemblyStorageMap), 516); assert_eq!(FIELD_OFFSET!(PEB32, MinimumStackCommit), 520); assert_eq!(FIELD_OFFSET!(PEB32, FlsCallback), 524); @@ -1960,7 +2293,10 @@ fn ntwow64() { assert_eq!(FIELD_OFFSET!(PEB32, CloudFileFlags), 1120); assert_eq!(FIELD_OFFSET!(PEB32, CloudFileDiagFlags), 1124); assert_eq!(FIELD_OFFSET!(PEB32, PlaceholderCompatibilityMode), 1128); - assert_eq!(FIELD_OFFSET!(PEB32, PlaceholderCompatibilityModeReserved), 1129); + assert_eq!( + FIELD_OFFSET!(PEB32, PlaceholderCompatibilityModeReserved), + 1129 + ); assert_eq!(size_of::(), 1248); assert_eq!(align_of::(), 4); assert_eq!(FIELD_OFFSET!(GDI_TEB_BATCH32, Offset), 0); @@ -1983,7 +2319,10 @@ fn ntwow64() { assert_eq!(FIELD_OFFSET!(TEB32, WOW32Reserved), 192); assert_eq!(FIELD_OFFSET!(TEB32, CurrentLocale), 196); assert_eq!(FIELD_OFFSET!(TEB32, FpSoftwareStatusRegister), 200); - assert_eq!(FIELD_OFFSET!(TEB32, ReservedForDebuggerInstrumentation), 204); + assert_eq!( + FIELD_OFFSET!(TEB32, ReservedForDebuggerInstrumentation), + 204 + ); assert_eq!(FIELD_OFFSET!(TEB32, SystemReserved1), 268); assert_eq!(FIELD_OFFSET!(TEB32, WorkingOnBehalfTicket), 412); assert_eq!(FIELD_OFFSET!(TEB32, ExceptionCode), 420); @@ -2075,8 +2414,14 @@ fn subprocesstag() { assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 16); assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 16); - assert_eq!(align_of::(), 8); + assert_eq!( + size_of::(), + 16 + ); + assert_eq!( + align_of::(), + 8 + ); assert_eq!(size_of::(), 32); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 4); @@ -2273,8 +2618,14 @@ fn winsta() { assert_eq!(align_of::(), 4); assert_eq!(FIELD_OFFSET!(CACHE_STATISTICS, ProtocolType), 0); assert_eq!(FIELD_OFFSET!(CACHE_STATISTICS, Length), 2); - assert_eq!(FIELD_OFFSET!(CACHE_STATISTICS, Specific.ReservedCacheStats), 4); - assert_eq!(FIELD_OFFSET!(CACHE_STATISTICS, Specific.TShareCacheStats), 4); + assert_eq!( + FIELD_OFFSET!(CACHE_STATISTICS, Specific.ReservedCacheStats), + 4 + ); + assert_eq!( + FIELD_OFFSET!(CACHE_STATISTICS, Specific.TShareCacheStats), + 4 + ); assert_eq!(FIELD_OFFSET!(CACHE_STATISTICS, Specific.Reserved), 4); assert_eq!(FIELD_OFFSET!(CACHE_STATISTICS, Specific), 4); assert_eq!(size_of::(), 1012); @@ -2319,13 +2670,22 @@ fn winsta() { assert_eq!(FIELD_OFFSET!(WINSTATIONCLIENTDATA, fUnicodeData), 8); assert_eq!(size_of::(), 72); assert_eq!(align_of::(), 8); - assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, RemainingSessionCapacity), 0); + assert_eq!( + FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, RemainingSessionCapacity), + 0 + ); assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, LoadFactor), 4); assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, TotalSessions), 8); - assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, DisconnectedSessions), 12); + assert_eq!( + FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, DisconnectedSessions), + 12 + ); assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, IdleCPU), 16); assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, TotalCPU), 24); - assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, RawSessionCapacity), 32); + assert_eq!( + FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, RawSessionCapacity), + 32 + ); assert_eq!(FIELD_OFFSET!(WINSTATIONLOADINDICATORDATA, reserved), 36); assert_eq!(size_of::(), 16); assert_eq!(align_of::(), 4); @@ -2348,39 +2708,114 @@ fn winsta() { assert_eq!(FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, u.ipv4.sin_addr), 8); assert_eq!(FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, u.ipv4.sin_zero), 12); assert_eq!(FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, u.ipv6.sin6_port), 4); - assert_eq!(FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, u.ipv6.sin6_flowinfo), 8); + assert_eq!( + FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, u.ipv6.sin6_flowinfo), + 8 + ); assert_eq!(FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, u.ipv6.sin6_addr), 12); - assert_eq!(FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, u.ipv6.sin6_scope_id), 28); + assert_eq!( + FIELD_OFFSET!(WINSTATIONREMOTEADDRESS, u.ipv6.sin6_scope_id), + 28 + ); assert_eq!(size_of::(), 1216); assert_eq!(align_of::(), 8); assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, SessionId), 0); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, SessionState), 4); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, SessionFlags), 8); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, WinStationName), 12); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, SessionState), + 4 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, SessionFlags), + 8 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, WinStationName), + 12 + ); assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, UserName), 78); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, DomainName), 120); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, LogonTime), 160); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, ConnectTime), 168); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, DisconnectTime), 176); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, LastInputTime), 184); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, CurrentTime), 192); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, ProtocolStatus), 200); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, DomainName), + 120 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, LogonTime), + 160 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, ConnectTime), + 168 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, DisconnectTime), + 176 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, LastInputTime), + 184 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, CurrentTime), + 192 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL1, ProtocolStatus), + 200 + ); assert_eq!(size_of::(), 2240); assert_eq!(align_of::(), 8); assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SessionId), 0); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SessionState), 4); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SessionFlags), 8); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, WinStationName), 12); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SamCompatibleUserName), 78); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SamCompatibleDomainName), 120); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, LogonTime), 160); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, ConnectTime), 168); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, DisconnectTime), 176); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, LastInputTime), 184); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, CurrentTime), 192); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, ProtocolStatus), 200); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, UserName), 1212); - assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, DomainName), 1726); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SessionState), + 4 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SessionFlags), + 8 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, WinStationName), + 12 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SamCompatibleUserName), + 78 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, SamCompatibleDomainName), + 120 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, LogonTime), + 160 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, ConnectTime), + 168 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, DisconnectTime), + 176 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, LastInputTime), + 184 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, CurrentTime), + 192 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, ProtocolStatus), + 200 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, UserName), + 1212 + ); + assert_eq!( + FIELD_OFFSET!(WINSTATIONINFORMATIONEX_LEVEL2, DomainName), + 1726 + ); assert_eq!(size_of::(), 2248); assert_eq!(align_of::(), 8); assert_eq!(FIELD_OFFSET!(WINSTATIONINFORMATIONEX, Level), 0); @@ -2393,8 +2828,14 @@ fn winsta() { assert_eq!(FIELD_OFFSET!(TS_PROCESS_INFORMATION_NT4, Pad), 16); assert_eq!(size_of::(), 184); assert_eq!(align_of::(), 8); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, NextEntryOffset), 0); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, NumberOfThreads), 4); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, NextEntryOffset), + 0 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, NumberOfThreads), + 4 + ); assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, SpareLi1), 8); assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, SpareLi2), 16); assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, SpareLi3), 24); @@ -2403,23 +2844,62 @@ fn winsta() { assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, KernelTime), 48); assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, ImageName), 56); assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, BasePriority), 72); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, UniqueProcessId), 76); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, InheritedFromUniqueProcessId), 80); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, UniqueProcessId), + 76 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, InheritedFromUniqueProcessId), + 80 + ); assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, HandleCount), 84); assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, SessionId), 88); assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, SpareUl3), 92); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PeakVirtualSize), 96); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PeakVirtualSize), + 96 + ); assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, VirtualSize), 104); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PageFaultCount), 112); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PeakWorkingSetSize), 116); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, WorkingSetSize), 120); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, QuotaPeakPagedPoolUsage), 128); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, QuotaPagedPoolUsage), 136); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, QuotaPeakNonPagedPoolUsage), 144); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, QuotaNonPagedPoolUsage), 152); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PagefileUsage), 160); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PeakPagefileUsage), 168); - assert_eq!(FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PrivatePageCount), 176); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PageFaultCount), + 112 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PeakWorkingSetSize), + 116 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, WorkingSetSize), + 120 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, QuotaPeakPagedPoolUsage), + 128 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, QuotaPagedPoolUsage), + 136 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, QuotaPeakNonPagedPoolUsage), + 144 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, QuotaNonPagedPoolUsage), + 152 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PagefileUsage), + 160 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PeakPagefileUsage), + 168 + ); + assert_eq!( + FIELD_OFFSET!(TS_SYS_PROCESS_INFORMATION, PrivatePageCount), + 176 + ); assert_eq!(size_of::(), 24); assert_eq!(align_of::(), 8); assert_eq!(FIELD_OFFSET!(TS_ALL_PROCESSES_INFO, pTsProcessInfo), 0); From a24e3030d4144abf44ed1ebea45da87f4d516d43 Mon Sep 17 00:00:00 2001 From: Arghyadip Chakraborty Date: Mon, 5 Jun 2023 17:22:48 +0530 Subject: [PATCH 2/3] size & align fix --- tests/layout_aarch64.rs | 75 +++++++++++++++++++++-------------------- tests/layout_x86.rs | 75 +++++++++++++++++++++-------------------- tests/layout_x86_64.rs | 75 +++++++++++++++++++++-------------------- 3 files changed, 117 insertions(+), 108 deletions(-) diff --git a/tests/layout_aarch64.rs b/tests/layout_aarch64.rs index c97b6e3..a779e71 100644 --- a/tests/layout_aarch64.rs +++ b/tests/layout_aarch64.rs @@ -468,7 +468,7 @@ fn ntexapi() { assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 64); assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 1800); + assert_eq!(size_of::(), 1824); assert_eq!(align_of::(), 4); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TickCountLowDeprecated), 0); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TickCountMultiplier), 4); @@ -1018,7 +1018,7 @@ fn ntpebteb() { assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 20); assert_eq!(align_of::(), 4); - assert_eq!(size_of::(), 1992); + assert_eq!(size_of::(), 2480); assert_eq!(align_of::(), 8); assert_eq!(FIELD_OFFSET!(PEB, InheritedAddressSpace), 0); assert_eq!(FIELD_OFFSET!(PEB, ReadImageFileExecOptions), 1); @@ -1086,27 +1086,27 @@ fn ntpebteb() { assert_eq!(FIELD_OFFSET!(PEB, FlsListHead), 808); assert_eq!(FIELD_OFFSET!(PEB, FlsBitmap), 824); assert_eq!(FIELD_OFFSET!(PEB, FlsBitmapBits), 832); - assert_eq!(FIELD_OFFSET!(PEB, FlsHighIndex), 848); - assert_eq!(FIELD_OFFSET!(PEB, WerRegistrationData), 856); - assert_eq!(FIELD_OFFSET!(PEB, WerShipAssertPtr), 864); - assert_eq!(FIELD_OFFSET!(PEB, pUnused), 872); - assert_eq!(FIELD_OFFSET!(PEB, pImageHeaderHash), 880); - assert_eq!(FIELD_OFFSET!(PEB, TracingFlags), 888); - assert_eq!(FIELD_OFFSET!(PEB, CsrServerReadOnlySharedMemoryBase), 896); - assert_eq!(FIELD_OFFSET!(PEB, TppWorkerpListLock), 904); - assert_eq!(FIELD_OFFSET!(PEB, TppWorkerpList), 912); - assert_eq!(FIELD_OFFSET!(PEB, WaitOnAddressHashTable), 928); - assert_eq!(FIELD_OFFSET!(PEB, TelemetryCoverageHeader), 1952); - assert_eq!(FIELD_OFFSET!(PEB, CloudFileFlags), 1960); - assert_eq!(FIELD_OFFSET!(PEB, CloudFileDiagFlags), 1964); - assert_eq!(FIELD_OFFSET!(PEB, PlaceholderCompatibilityMode), 1968); + assert_eq!(FIELD_OFFSET!(PEB, FlsHighIndex), 1340); + assert_eq!(FIELD_OFFSET!(PEB, WerRegistrationData), 1344); + assert_eq!(FIELD_OFFSET!(PEB, WerShipAssertPtr), 1352); + assert_eq!(FIELD_OFFSET!(PEB, pUnused), 1360); + assert_eq!(FIELD_OFFSET!(PEB, pImageHeaderHash), 1368); + assert_eq!(FIELD_OFFSET!(PEB, TracingFlags), 1376); + assert_eq!(FIELD_OFFSET!(PEB, CsrServerReadOnlySharedMemoryBase), 1384); + assert_eq!(FIELD_OFFSET!(PEB, TppWorkerpListLock), 1392); + assert_eq!(FIELD_OFFSET!(PEB, TppWorkerpList), 1400); + assert_eq!(FIELD_OFFSET!(PEB, WaitOnAddressHashTable), 1416); + assert_eq!(FIELD_OFFSET!(PEB, TelemetryCoverageHeader), 2440); + assert_eq!(FIELD_OFFSET!(PEB, CloudFileFlags), 2448); + assert_eq!(FIELD_OFFSET!(PEB, CloudFileDiagFlags), 2452); + assert_eq!(FIELD_OFFSET!(PEB, PlaceholderCompatibilityMode), 2456); assert_eq!( FIELD_OFFSET!(PEB, PlaceholderCompatibilityModeReserved), - 1969 + 2457 ); - assert_eq!(FIELD_OFFSET!(PEB, LeapSecondData), 1976); - assert_eq!(FIELD_OFFSET!(PEB, LeapSecondFlags), 1984); - assert_eq!(FIELD_OFFSET!(PEB, NtGlobalFlag2), 1988); + assert_eq!(FIELD_OFFSET!(PEB, LeapSecondData), 2464); + assert_eq!(FIELD_OFFSET!(PEB, LeapSecondFlags), 2472); + assert_eq!(FIELD_OFFSET!(PEB, NtGlobalFlag2), 2476); assert_eq!(size_of::(), 1256); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 16); @@ -2202,7 +2202,7 @@ fn ntwow64() { FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, LoaderThreads), 672 ); - assert_eq!(size_of::(), 1136); + assert_eq!(size_of::(), 1624); assert_eq!(align_of::(), 8); assert_eq!(FIELD_OFFSET!(PEB32, InheritedAddressSpace), 0); assert_eq!(FIELD_OFFSET!(PEB32, ReadImageFileExecOptions), 1); @@ -2276,23 +2276,26 @@ fn ntwow64() { assert_eq!(FIELD_OFFSET!(PEB32, FlsListHead), 528); assert_eq!(FIELD_OFFSET!(PEB32, FlsBitmap), 536); assert_eq!(FIELD_OFFSET!(PEB32, FlsBitmapBits), 540); - assert_eq!(FIELD_OFFSET!(PEB32, FlsHighIndex), 556); - assert_eq!(FIELD_OFFSET!(PEB32, WerRegistrationData), 560); - assert_eq!(FIELD_OFFSET!(PEB32, WerShipAssertPtr), 564); - assert_eq!(FIELD_OFFSET!(PEB32, pContextData), 568); - assert_eq!(FIELD_OFFSET!(PEB32, pImageHeaderHash), 572); - assert_eq!(FIELD_OFFSET!(PEB32, TracingFlags), 576); - assert_eq!(FIELD_OFFSET!(PEB32, CsrServerReadOnlySharedMemoryBase), 584); - assert_eq!(FIELD_OFFSET!(PEB32, TppWorkerpListLock), 592); - assert_eq!(FIELD_OFFSET!(PEB32, TppWorkerpList), 596); - assert_eq!(FIELD_OFFSET!(PEB32, WaitOnAddressHashTable), 604); - assert_eq!(FIELD_OFFSET!(PEB32, TelemetryCoverageHeader), 1116); - assert_eq!(FIELD_OFFSET!(PEB32, CloudFileFlags), 1120); - assert_eq!(FIELD_OFFSET!(PEB32, CloudFileDiagFlags), 1124); - assert_eq!(FIELD_OFFSET!(PEB32, PlaceholderCompatibilityMode), 1128); + assert_eq!(FIELD_OFFSET!(PEB32, FlsHighIndex), 1048); + assert_eq!(FIELD_OFFSET!(PEB32, WerRegistrationData), 1052); + assert_eq!(FIELD_OFFSET!(PEB32, WerShipAssertPtr), 1056); + assert_eq!(FIELD_OFFSET!(PEB32, pContextData), 1060); + assert_eq!(FIELD_OFFSET!(PEB32, pImageHeaderHash), 1064); + assert_eq!(FIELD_OFFSET!(PEB32, TracingFlags), 1068); + assert_eq!( + FIELD_OFFSET!(PEB32, CsrServerReadOnlySharedMemoryBase), + 1072 + ); + assert_eq!(FIELD_OFFSET!(PEB32, TppWorkerpListLock), 1080); + assert_eq!(FIELD_OFFSET!(PEB32, TppWorkerpList), 1084); + assert_eq!(FIELD_OFFSET!(PEB32, WaitOnAddressHashTable), 1092); + assert_eq!(FIELD_OFFSET!(PEB32, TelemetryCoverageHeader), 1604); + assert_eq!(FIELD_OFFSET!(PEB32, CloudFileFlags), 1608); + assert_eq!(FIELD_OFFSET!(PEB32, CloudFileDiagFlags), 1612); + assert_eq!(FIELD_OFFSET!(PEB32, PlaceholderCompatibilityMode), 1616); assert_eq!( FIELD_OFFSET!(PEB32, PlaceholderCompatibilityModeReserved), - 1129 + 1617 ); assert_eq!(size_of::(), 1248); assert_eq!(align_of::(), 4); diff --git a/tests/layout_x86.rs b/tests/layout_x86.rs index 7d38af4..ad72da8 100644 --- a/tests/layout_x86.rs +++ b/tests/layout_x86.rs @@ -465,7 +465,7 @@ fn ntexapi() { assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 40); assert_eq!(align_of::(), 4); - assert_eq!(size_of::(), 1800); + assert_eq!(size_of::(), 1824); assert_eq!(align_of::(), 4); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TickCountLowDeprecated), 0); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TickCountMultiplier), 4); @@ -1015,7 +1015,7 @@ fn ntpebteb() { assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 20); assert_eq!(align_of::(), 4); - assert_eq!(size_of::(), 1152); + assert_eq!(size_of::(), 1640); assert_eq!(align_of::(), 8); assert_eq!(FIELD_OFFSET!(PEB, InheritedAddressSpace), 0); assert_eq!(FIELD_OFFSET!(PEB, ReadImageFileExecOptions), 1); @@ -1083,27 +1083,27 @@ fn ntpebteb() { assert_eq!(FIELD_OFFSET!(PEB, FlsListHead), 528); assert_eq!(FIELD_OFFSET!(PEB, FlsBitmap), 536); assert_eq!(FIELD_OFFSET!(PEB, FlsBitmapBits), 540); - assert_eq!(FIELD_OFFSET!(PEB, FlsHighIndex), 556); - assert_eq!(FIELD_OFFSET!(PEB, WerRegistrationData), 560); - assert_eq!(FIELD_OFFSET!(PEB, WerShipAssertPtr), 564); - assert_eq!(FIELD_OFFSET!(PEB, pUnused), 568); - assert_eq!(FIELD_OFFSET!(PEB, pImageHeaderHash), 572); - assert_eq!(FIELD_OFFSET!(PEB, TracingFlags), 576); - assert_eq!(FIELD_OFFSET!(PEB, CsrServerReadOnlySharedMemoryBase), 584); - assert_eq!(FIELD_OFFSET!(PEB, TppWorkerpListLock), 592); - assert_eq!(FIELD_OFFSET!(PEB, TppWorkerpList), 596); - assert_eq!(FIELD_OFFSET!(PEB, WaitOnAddressHashTable), 604); - assert_eq!(FIELD_OFFSET!(PEB, TelemetryCoverageHeader), 1116); - assert_eq!(FIELD_OFFSET!(PEB, CloudFileFlags), 1120); - assert_eq!(FIELD_OFFSET!(PEB, CloudFileDiagFlags), 1124); - assert_eq!(FIELD_OFFSET!(PEB, PlaceholderCompatibilityMode), 1128); + assert_eq!(FIELD_OFFSET!(PEB, FlsHighIndex), 1048); + assert_eq!(FIELD_OFFSET!(PEB, WerRegistrationData), 1052); + assert_eq!(FIELD_OFFSET!(PEB, WerShipAssertPtr), 1056); + assert_eq!(FIELD_OFFSET!(PEB, pUnused), 1060); + assert_eq!(FIELD_OFFSET!(PEB, pImageHeaderHash), 1064); + assert_eq!(FIELD_OFFSET!(PEB, TracingFlags), 1068); + assert_eq!(FIELD_OFFSET!(PEB, CsrServerReadOnlySharedMemoryBase), 1072); + assert_eq!(FIELD_OFFSET!(PEB, TppWorkerpListLock), 1080); + assert_eq!(FIELD_OFFSET!(PEB, TppWorkerpList), 1084); + assert_eq!(FIELD_OFFSET!(PEB, WaitOnAddressHashTable), 1092); + assert_eq!(FIELD_OFFSET!(PEB, TelemetryCoverageHeader), 1604); + assert_eq!(FIELD_OFFSET!(PEB, CloudFileFlags), 1608); + assert_eq!(FIELD_OFFSET!(PEB, CloudFileDiagFlags), 1612); + assert_eq!(FIELD_OFFSET!(PEB, PlaceholderCompatibilityMode), 1616); assert_eq!( FIELD_OFFSET!(PEB, PlaceholderCompatibilityModeReserved), - 1129 + 1617 ); - assert_eq!(FIELD_OFFSET!(PEB, LeapSecondData), 1136); - assert_eq!(FIELD_OFFSET!(PEB, LeapSecondFlags), 1140); - assert_eq!(FIELD_OFFSET!(PEB, NtGlobalFlag2), 1144); + assert_eq!(FIELD_OFFSET!(PEB, LeapSecondData), 1624); + assert_eq!(FIELD_OFFSET!(PEB, LeapSecondFlags), 1628); + assert_eq!(FIELD_OFFSET!(PEB, NtGlobalFlag2), 1632); assert_eq!(size_of::(), 1248); assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 8); @@ -2194,7 +2194,7 @@ fn ntwow64() { FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, LoaderThreads), 672 ); - assert_eq!(size_of::(), 1136); + assert_eq!(size_of::(), 1624); assert_eq!(align_of::(), 8); assert_eq!(FIELD_OFFSET!(PEB32, InheritedAddressSpace), 0); assert_eq!(FIELD_OFFSET!(PEB32, ReadImageFileExecOptions), 1); @@ -2268,23 +2268,26 @@ fn ntwow64() { assert_eq!(FIELD_OFFSET!(PEB32, FlsListHead), 528); assert_eq!(FIELD_OFFSET!(PEB32, FlsBitmap), 536); assert_eq!(FIELD_OFFSET!(PEB32, FlsBitmapBits), 540); - assert_eq!(FIELD_OFFSET!(PEB32, FlsHighIndex), 556); - assert_eq!(FIELD_OFFSET!(PEB32, WerRegistrationData), 560); - assert_eq!(FIELD_OFFSET!(PEB32, WerShipAssertPtr), 564); - assert_eq!(FIELD_OFFSET!(PEB32, pContextData), 568); - assert_eq!(FIELD_OFFSET!(PEB32, pImageHeaderHash), 572); - assert_eq!(FIELD_OFFSET!(PEB32, TracingFlags), 576); - assert_eq!(FIELD_OFFSET!(PEB32, CsrServerReadOnlySharedMemoryBase), 584); - assert_eq!(FIELD_OFFSET!(PEB32, TppWorkerpListLock), 592); - assert_eq!(FIELD_OFFSET!(PEB32, TppWorkerpList), 596); - assert_eq!(FIELD_OFFSET!(PEB32, WaitOnAddressHashTable), 604); - assert_eq!(FIELD_OFFSET!(PEB32, TelemetryCoverageHeader), 1116); - assert_eq!(FIELD_OFFSET!(PEB32, CloudFileFlags), 1120); - assert_eq!(FIELD_OFFSET!(PEB32, CloudFileDiagFlags), 1124); - assert_eq!(FIELD_OFFSET!(PEB32, PlaceholderCompatibilityMode), 1128); + assert_eq!(FIELD_OFFSET!(PEB32, FlsHighIndex), 1048); + assert_eq!(FIELD_OFFSET!(PEB32, WerRegistrationData), 1052); + assert_eq!(FIELD_OFFSET!(PEB32, WerShipAssertPtr), 1056); + assert_eq!(FIELD_OFFSET!(PEB32, pContextData), 1060); + assert_eq!(FIELD_OFFSET!(PEB32, pImageHeaderHash), 1064); + assert_eq!(FIELD_OFFSET!(PEB32, TracingFlags), 1068); + assert_eq!( + FIELD_OFFSET!(PEB32, CsrServerReadOnlySharedMemoryBase), + 1072 + ); + assert_eq!(FIELD_OFFSET!(PEB32, TppWorkerpListLock), 1080); + assert_eq!(FIELD_OFFSET!(PEB32, TppWorkerpList), 1084); + assert_eq!(FIELD_OFFSET!(PEB32, WaitOnAddressHashTable), 1092); + assert_eq!(FIELD_OFFSET!(PEB32, TelemetryCoverageHeader), 1604); + assert_eq!(FIELD_OFFSET!(PEB32, CloudFileFlags), 1608); + assert_eq!(FIELD_OFFSET!(PEB32, CloudFileDiagFlags), 1612); + assert_eq!(FIELD_OFFSET!(PEB32, PlaceholderCompatibilityMode), 1616); assert_eq!( FIELD_OFFSET!(PEB32, PlaceholderCompatibilityModeReserved), - 1129 + 1617 ); assert_eq!(size_of::(), 1248); assert_eq!(align_of::(), 4); diff --git a/tests/layout_x86_64.rs b/tests/layout_x86_64.rs index 0bca46b..c0eff83 100644 --- a/tests/layout_x86_64.rs +++ b/tests/layout_x86_64.rs @@ -468,7 +468,7 @@ fn ntexapi() { assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 64); assert_eq!(align_of::(), 8); - assert_eq!(size_of::(), 1800); + assert_eq!(size_of::(), 1824); assert_eq!(align_of::(), 4); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TickCountLowDeprecated), 0); assert_eq!(FIELD_OFFSET!(KUSER_SHARED_DATA, TickCountMultiplier), 4); @@ -1018,7 +1018,7 @@ fn ntpebteb() { assert_eq!(align_of::(), 4); assert_eq!(size_of::(), 20); assert_eq!(align_of::(), 4); - assert_eq!(size_of::(), 1992); + assert_eq!(size_of::(), 2480); assert_eq!(align_of::(), 8); assert_eq!(FIELD_OFFSET!(PEB, InheritedAddressSpace), 0); assert_eq!(FIELD_OFFSET!(PEB, ReadImageFileExecOptions), 1); @@ -1086,27 +1086,27 @@ fn ntpebteb() { assert_eq!(FIELD_OFFSET!(PEB, FlsListHead), 808); assert_eq!(FIELD_OFFSET!(PEB, FlsBitmap), 824); assert_eq!(FIELD_OFFSET!(PEB, FlsBitmapBits), 832); - assert_eq!(FIELD_OFFSET!(PEB, FlsHighIndex), 848); - assert_eq!(FIELD_OFFSET!(PEB, WerRegistrationData), 856); - assert_eq!(FIELD_OFFSET!(PEB, WerShipAssertPtr), 864); - assert_eq!(FIELD_OFFSET!(PEB, pUnused), 872); - assert_eq!(FIELD_OFFSET!(PEB, pImageHeaderHash), 880); - assert_eq!(FIELD_OFFSET!(PEB, TracingFlags), 888); - assert_eq!(FIELD_OFFSET!(PEB, CsrServerReadOnlySharedMemoryBase), 896); - assert_eq!(FIELD_OFFSET!(PEB, TppWorkerpListLock), 904); - assert_eq!(FIELD_OFFSET!(PEB, TppWorkerpList), 912); - assert_eq!(FIELD_OFFSET!(PEB, WaitOnAddressHashTable), 928); - assert_eq!(FIELD_OFFSET!(PEB, TelemetryCoverageHeader), 1952); - assert_eq!(FIELD_OFFSET!(PEB, CloudFileFlags), 1960); - assert_eq!(FIELD_OFFSET!(PEB, CloudFileDiagFlags), 1964); - assert_eq!(FIELD_OFFSET!(PEB, PlaceholderCompatibilityMode), 1968); + assert_eq!(FIELD_OFFSET!(PEB, FlsHighIndex), 1340); + assert_eq!(FIELD_OFFSET!(PEB, WerRegistrationData), 1344); + assert_eq!(FIELD_OFFSET!(PEB, WerShipAssertPtr), 1352); + assert_eq!(FIELD_OFFSET!(PEB, pUnused), 1360); + assert_eq!(FIELD_OFFSET!(PEB, pImageHeaderHash), 1368); + assert_eq!(FIELD_OFFSET!(PEB, TracingFlags), 1376); + assert_eq!(FIELD_OFFSET!(PEB, CsrServerReadOnlySharedMemoryBase), 1384); + assert_eq!(FIELD_OFFSET!(PEB, TppWorkerpListLock), 1392); + assert_eq!(FIELD_OFFSET!(PEB, TppWorkerpList), 1400); + assert_eq!(FIELD_OFFSET!(PEB, WaitOnAddressHashTable), 1416); + assert_eq!(FIELD_OFFSET!(PEB, TelemetryCoverageHeader), 2440); + assert_eq!(FIELD_OFFSET!(PEB, CloudFileFlags), 2448); + assert_eq!(FIELD_OFFSET!(PEB, CloudFileDiagFlags), 2452); + assert_eq!(FIELD_OFFSET!(PEB, PlaceholderCompatibilityMode), 2456); assert_eq!( FIELD_OFFSET!(PEB, PlaceholderCompatibilityModeReserved), - 1969 + 2457 ); - assert_eq!(FIELD_OFFSET!(PEB, LeapSecondData), 1976); - assert_eq!(FIELD_OFFSET!(PEB, LeapSecondFlags), 1984); - assert_eq!(FIELD_OFFSET!(PEB, NtGlobalFlag2), 1988); + assert_eq!(FIELD_OFFSET!(PEB, LeapSecondData), 2464); + assert_eq!(FIELD_OFFSET!(PEB, LeapSecondFlags), 2472); + assert_eq!(FIELD_OFFSET!(PEB, NtGlobalFlag2), 2476); assert_eq!(size_of::(), 1256); assert_eq!(align_of::(), 8); assert_eq!(size_of::(), 16); @@ -2205,7 +2205,7 @@ fn ntwow64() { FIELD_OFFSET!(RTL_USER_PROCESS_PARAMETERS32, LoaderThreads), 672 ); - assert_eq!(size_of::(), 1136); + assert_eq!(size_of::(), 1624); assert_eq!(align_of::(), 8); assert_eq!(FIELD_OFFSET!(PEB32, InheritedAddressSpace), 0); assert_eq!(FIELD_OFFSET!(PEB32, ReadImageFileExecOptions), 1); @@ -2279,23 +2279,26 @@ fn ntwow64() { assert_eq!(FIELD_OFFSET!(PEB32, FlsListHead), 528); assert_eq!(FIELD_OFFSET!(PEB32, FlsBitmap), 536); assert_eq!(FIELD_OFFSET!(PEB32, FlsBitmapBits), 540); - assert_eq!(FIELD_OFFSET!(PEB32, FlsHighIndex), 556); - assert_eq!(FIELD_OFFSET!(PEB32, WerRegistrationData), 560); - assert_eq!(FIELD_OFFSET!(PEB32, WerShipAssertPtr), 564); - assert_eq!(FIELD_OFFSET!(PEB32, pContextData), 568); - assert_eq!(FIELD_OFFSET!(PEB32, pImageHeaderHash), 572); - assert_eq!(FIELD_OFFSET!(PEB32, TracingFlags), 576); - assert_eq!(FIELD_OFFSET!(PEB32, CsrServerReadOnlySharedMemoryBase), 584); - assert_eq!(FIELD_OFFSET!(PEB32, TppWorkerpListLock), 592); - assert_eq!(FIELD_OFFSET!(PEB32, TppWorkerpList), 596); - assert_eq!(FIELD_OFFSET!(PEB32, WaitOnAddressHashTable), 604); - assert_eq!(FIELD_OFFSET!(PEB32, TelemetryCoverageHeader), 1116); - assert_eq!(FIELD_OFFSET!(PEB32, CloudFileFlags), 1120); - assert_eq!(FIELD_OFFSET!(PEB32, CloudFileDiagFlags), 1124); - assert_eq!(FIELD_OFFSET!(PEB32, PlaceholderCompatibilityMode), 1128); + assert_eq!(FIELD_OFFSET!(PEB32, FlsHighIndex), 1048); + assert_eq!(FIELD_OFFSET!(PEB32, WerRegistrationData), 1052); + assert_eq!(FIELD_OFFSET!(PEB32, WerShipAssertPtr), 1056); + assert_eq!(FIELD_OFFSET!(PEB32, pContextData), 1060); + assert_eq!(FIELD_OFFSET!(PEB32, pImageHeaderHash), 1064); + assert_eq!(FIELD_OFFSET!(PEB32, TracingFlags), 1068); + assert_eq!( + FIELD_OFFSET!(PEB32, CsrServerReadOnlySharedMemoryBase), + 1072 + ); + assert_eq!(FIELD_OFFSET!(PEB32, TppWorkerpListLock), 1080); + assert_eq!(FIELD_OFFSET!(PEB32, TppWorkerpList), 1084); + assert_eq!(FIELD_OFFSET!(PEB32, WaitOnAddressHashTable), 1092); + assert_eq!(FIELD_OFFSET!(PEB32, TelemetryCoverageHeader), 1604); + assert_eq!(FIELD_OFFSET!(PEB32, CloudFileFlags), 1608); + assert_eq!(FIELD_OFFSET!(PEB32, CloudFileDiagFlags), 1612); + assert_eq!(FIELD_OFFSET!(PEB32, PlaceholderCompatibilityMode), 1616); assert_eq!( FIELD_OFFSET!(PEB32, PlaceholderCompatibilityModeReserved), - 1129 + 1617 ); assert_eq!(size_of::(), 1248); assert_eq!(align_of::(), 4); From a9155c403fca9b91b0c30dc1161b0b6412656daf Mon Sep 17 00:00:00 2001 From: Arghyadip Chakraborty Date: Mon, 5 Jun 2023 17:23:08 +0530 Subject: [PATCH 3/3] ntdll link fix --- appveyor.yml | 8 ++++---- build.rs | 9 +-------- 2 files changed, 5 insertions(+), 12 deletions(-) diff --git a/appveyor.yml b/appveyor.yml index ce32f0b..20799ce 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -12,9 +12,9 @@ environment: - host: i686-pc-windows-gnu channel: nightly - host: x86_64-pc-windows-gnu - channel: 1.64.0 + channel: 1.70.0 - host: i686-pc-windows-gnu - channel: 1.64.0 + channel: 1.70.0 install: - appveyor DownloadFile https://win.rustup.rs/ -FileName rustup-init.exe @@ -24,11 +24,11 @@ install: - rustc -vV - cargo -vV - if defined aarch64 ( - rustup target add aarch64-pc-windows-msvc + rustup target add aarch64-pc-windows-msvc ) build_script: - cargo test --verbose --color always --features "func-types impl-default user" - if defined aarch64 ( - cargo test --verbose --color always --features "func-types impl-default user" --target aarch64-pc-windows-msvc --no-run + cargo test --verbose --color always --features "func-types impl-default user" --target aarch64-pc-windows-msvc --no-run ) diff --git a/build.rs b/build.rs index 0ef7a9b..4602ecb 100644 --- a/build.rs +++ b/build.rs @@ -1,13 +1,6 @@ -use std::env::var; - fn main() { #[cfg(feature = "user")] { - if var("TARGET") - .map(|t| t == "x86_64-pc-windows-gnu" || t == "i686-pc-windows-gnu") - .unwrap_or(false) - { - println!("cargo:rustc-link-lib=ntdll"); - } + println!("cargo:rustc-link-lib=ntdll"); } }