Merge pull request RustPython#2002 from BasixKOR/sys-getwindowsversion

Implement `sys.getwindowsversion`

Author: youknowone

tests/snippets/stdlib_os.py

@@ -491,3 +491,26 @@ def __exit__(self, exc_type, exc_val, exc_tb):
 
     for arg in [None, 1, 1.0, TabError]:
         assert_raises(TypeError, os.system, arg)
+
+if sys.platform.startswith("win"):
+	winver = sys.getwindowsversion()
+
+	# the biggest value of wSuiteMask (https://docs.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-osversioninfoexa#members).
+	all_masks = 0x00000004 | 0x00000400 | 0x00004000 | 0x00000080 | 0x00000002 | 0x00000040 | 0x00000200 | \
+		0x00000100 | 0x00000001 | 0x00000020 | 0x00002000 | 0x00000010 | 0x00008000 | 0x00020000
+
+	# We really can't test if the results are correct, so it just checks for meaningful value
+	assert winver.major > 0
+	assert winver.minor >= 0
+	assert winver.build > 0
+	assert winver.platform == 2
+	assert isinstance(winver.service_pack, str)
+	assert 0 <= winver.suite_mask <= all_masks
+	assert 1 <= winver.product_type <= 3
+
+	# XXX if platform_version is implemented correctly, this'll break on compatiblity mode or a build without manifest
+	assert winver.major == winver.platform_version[0]
+	assert winver.minor == winver.platform_version[1]
+	assert winver.build == winver.platform_version[2]
+
+

vm/src/sysmodule.rs

@@ -231,6 +231,78 @@ fn sys_displayhook(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
     Ok(())
 }
 
+#[pystruct_sequence(module = "sys", name = "getwindowsversion")]
+#[derive(Default, Debug)]
+#[cfg(windows)]
+struct WindowsVersion {
+    major: u32,
+    minor: u32,
+    build: u32,
+    platform: u32,
+    service_pack: String,
+    service_pack_major: u16,
+    service_pack_minor: u16,
+    suite_mask: u16,
+    product_type: u8,
+    platform_version: (u32, u32, u32),
+}
+
+#[cfg(windows)]
+fn sys_getwindowsversion(vm: &VirtualMachine) -> PyResult<crate::obj::objtuple::PyTupleRef> {
+    use std::ffi::OsString;
+    use std::os::windows::ffi::OsStringExt;
+    use winapi::um::{
+        sysinfoapi::GetVersionExW,
+        winnt::{LPOSVERSIONINFOEXW, LPOSVERSIONINFOW, OSVERSIONINFOEXW},
+    };
+
+    let mut version = OSVERSIONINFOEXW::default();
+    version.dwOSVersionInfoSize = std::mem::size_of::<OSVERSIONINFOEXW>() as u32;
+    let result = unsafe {
+        let osvi = &mut version as LPOSVERSIONINFOEXW as LPOSVERSIONINFOW;
+        // SAFE: GetVersionExW accepts a pointer of OSVERSIONINFOW, but winapi crate's type currently doesn't allow to do so.
+        // https://docs.microsoft.com/en-us/windows/win32/api/sysinfoapi/nf-sysinfoapi-getversionexw#parameters
+        GetVersionExW(osvi)
+    };
+
+    if result == 0 {
+        Err(vm.new_os_error("failed to get windows version".to_owned()))
+    } else {
+        let service_pack = {
+            let (last, _) = version
+                .szCSDVersion
+                .iter()
+                .take_while(|&x| x != &0)
+                .enumerate()
+                .last()
+                .unwrap_or((0, &0));
+            let sp = OsString::from_wide(&version.szCSDVersion[..last]);
+            if let Ok(string) = sp.into_string() {
+                string
+            } else {
+                return Err(vm.new_os_error("service pack is not ASCII".to_owned()));
+            }
+        };
+        WindowsVersion {
+            major: version.dwMajorVersion,
+            minor: version.dwMinorVersion,
+            build: version.dwBuildNumber,
+            platform: version.dwPlatformId,
+            service_pack,
+            service_pack_major: version.wServicePackMajor,
+            service_pack_minor: version.wServicePackMinor,
+            suite_mask: version.wSuiteMask,
+            product_type: version.wProductType,
+            platform_version: (
+                version.dwMajorVersion,
+                version.dwMinorVersion,
+                version.dwBuildNumber,
+            ), // TODO Provide accurate version, like CPython impl
+        }
+        .into_struct_sequence(vm, vm.try_class("sys", "_getwindowsversion_type")?)
+    }
+}
+
 const PLATFORM: &str = {
     cfg_if::cfg_if! {
         if #[cfg(any(target_os = "linux", target_os = "android"))] {
@@ -474,6 +546,15 @@ settrace() -- set the global debug tracing function
       "__displayhook__" => ctx.new_function(sys_displayhook),
     });
 
+    #[cfg(windows)]
+    {
+        let getwindowsversion = WindowsVersion::make_class(ctx);
+        extend_module!(vm, module, {
+            "getwindowsversion" => ctx.new_function(sys_getwindowsversion),
+            "_getwindowsversion_type" => getwindowsversion, // XXX: This is not a python spec but required by current RustPython implementation
+        })
+    }
+
     modules.set_item("sys", module.clone(), vm).unwrap();
     modules.set_item("builtins", builtins.clone(), vm).unwrap();
 }