1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
use std::{
ffi::OsString,
io, iter,
mem::{self, MaybeUninit},
os::windows::ffi::OsStrExt,
};
use windows_sys::Win32::System::{
LibraryLoader::{GetModuleHandleW, GetProcAddress},
SystemInformation::OSVERSIONINFOEXW,
SystemServices::VER_NT_WORKSTATION,
};
#[allow(non_camel_case_types)]
type RTL_OSVERSIONINFOEXW = OSVERSIONINFOEXW;
pub fn version() -> String {
let (major, build) = WindowsVersion::new()
.map(|version_info| {
(
version_info.windows_version_string(),
version_info.build_number().to_string(),
)
})
.unwrap_or_else(|_| ("N/A".to_owned(), "N/A".to_owned()));
format!("Windows {} Build {}", major, build)
}
pub fn short_version() -> String {
let version_string = WindowsVersion::new()
.map(|version| version.windows_version_string())
.unwrap_or("N/A".into());
format!("Windows {}", version_string)
}
pub fn extra_metadata() -> impl Iterator<Item = (String, String)> {
std::iter::empty()
}
pub struct WindowsVersion {
inner: RTL_OSVERSIONINFOEXW,
}
impl WindowsVersion {
pub fn new() -> Result<WindowsVersion, io::Error> {
let module_name: Vec<u16> = OsString::from("ntdll")
.as_os_str()
.encode_wide()
.chain(iter::once(0u16))
.collect();
let ntdll = unsafe { GetModuleHandleW(module_name.as_ptr()) };
if ntdll == 0 {
return Err(io::Error::last_os_error());
}
let function_address = unsafe { GetProcAddress(ntdll, b"RtlGetVersion\0" as *const u8) }
.ok_or_else(io::Error::last_os_error)?;
let rtl_get_version: extern "stdcall" fn(*mut RTL_OSVERSIONINFOEXW) =
unsafe { *(&function_address as *const _ as *const _) };
let mut version_info: MaybeUninit<RTL_OSVERSIONINFOEXW> = mem::MaybeUninit::zeroed();
unsafe {
(*version_info.as_mut_ptr()).dwOSVersionInfoSize =
mem::size_of_val(&version_info) as u32;
rtl_get_version(version_info.as_mut_ptr());
Ok(WindowsVersion {
inner: version_info.assume_init(),
})
}
}
pub fn windows_version_string(&self) -> String {
// `wProductType != VER_NT_WORKSTATION` implies that OS is Windows Server
// https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/wdm/ns-wdm-_osversioninfoexw
// NOTE: This does not deduce which Windows Server version is running.
if u32::from(self.inner.wProductType) != VER_NT_WORKSTATION {
return "Server".to_owned();
}
match self.release_version() {
(major, 0) => major.to_string(),
(major, minor) => format!("{major}.{minor}"),
}
}
/// Release version. E.g. `(10, 0)` for Windows 10, or `(8, 0)` for Windows 8.1.
pub fn release_version(&self) -> (u32, u32) {
// Check https://en.wikipedia.org/wiki/List_of_Microsoft_Windows_versions#Personal_computer_versions 'Release version' column
// for the correct NT versions for specific windows releases.
match (self.major_version(), self.minor_version()) {
(6, 1) => (7, 0),
(6, 2) => (8, 0),
(6, 3) => (8, 1),
(10, 0) => {
if self.build_number() < 22000 {
(10, 0)
} else {
(11, 0)
}
}
(major, minor) => (major, minor),
}
}
pub fn major_version(&self) -> u32 {
self.inner.dwMajorVersion
}
pub fn minor_version(&self) -> u32 {
self.inner.dwMinorVersion
}
pub fn build_number(&self) -> u32 {
self.inner.dwBuildNumber
}
}
#[cfg(test)]
mod test {
use super::*;
#[test]
fn test_windows_version() {
WindowsVersion::new().unwrap();
}
}
|
