Use winapi instead of PowerShell to discover browser version

Author: bonigarcia

rust/Cargo.lock

@@ -38,6 +38,7 @@ apple-flat-package = "0.20.0"
 which = "7.0.2"
 fs2 = "0.4.3"
 fs_extra = "1.3.0"
+winapi = { version = "0.3.9", features = ["winver", "winnt", "sysinfoapi"] }
 
 [dev-dependencies]
 assert_cmd = "2.0.16"

rust/Cargo.toml

@@ -16,12 +16,12 @@
 // under the License.
 
 use crate::config::OS::{LINUX, MACOS, WINDOWS};
-use crate::shell::{run_powershell_command, run_shell_command_by_os};
+use crate::shell::run_shell_command_by_os;
 use crate::{
     default_cache_folder, format_one_arg, path_to_string, Command, ENV_PROCESSOR_ARCHITECTURE,
     REQUEST_TIMEOUT_SEC, UNAME_COMMAND,
 };
-use crate::{ARCH_AMD64, ARCH_ARM64, ARCH_X86, PS_GET_OS_COMMAND, TTL_SEC};
+use crate::{ARCH_AMD64, ARCH_ARM64, ARCH_X86, TTL_SEC};
 use anyhow::anyhow;
 use anyhow::Error;
 use std::cell::RefCell;
@@ -30,6 +30,11 @@ use std::env::consts::OS;
 use std::fs::read_to_string;
 use std::path::Path;
 use toml::Table;
+use winapi::um::sysinfoapi::{GetNativeSystemInfo, SYSTEM_INFO};
+use winapi::um::winnt::{
+    PROCESSOR_ARCHITECTURE_AMD64, PROCESSOR_ARCHITECTURE_ARM, PROCESSOR_ARCHITECTURE_ARM64,
+    PROCESSOR_ARCHITECTURE_IA64, PROCESSOR_ARCHITECTURE_INTEL,
+};
 
 thread_local!(static CACHE_PATH: RefCell<String> = RefCell::new(path_to_string(&default_cache_folder())));
 
@@ -71,8 +76,7 @@ impl ManagerConfig {
         let self_arch = if WINDOWS.is(self_os) {
             let mut architecture = env::var(ENV_PROCESSOR_ARCHITECTURE).unwrap_or_default();
             if architecture.is_empty() {
-                let get_os_command = Command::new_single(PS_GET_OS_COMMAND.to_string());
-                architecture = run_powershell_command(get_os_command).unwrap_or_default();
+                architecture = get_win_os_architecture();
             }
             if architecture.contains("32") {
                 ARCH_X86.to_string()
@@ -297,3 +301,20 @@ fn read_cache_path() -> String {
     });
     cache_path
 }
+
+fn get_win_os_architecture() -> String {
+    unsafe {
+        let mut system_info: SYSTEM_INFO = std::mem::zeroed();
+        GetNativeSystemInfo(&mut system_info);
+
+        match system_info.u.s() {
+            si if si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64 => "64-bit",
+            si if si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL => "32-bit",
+            si if si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_ARM => "ARM",
+            si if si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_ARM64 => "ARM64",
+            si if si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_IA64 => "Itanium-based",
+            _ => "Unknown",
+        }
+        .to_string()
+    }
+}

rust/src/config.rs

@@ -29,13 +29,18 @@ use directories::BaseDirs;
 use flate2::read::GzDecoder;
 use fs_extra::dir::{move_dir, CopyOptions};
 use regex::Regex;
+use std::ffi::OsStr;
 use std::fs;
 use std::fs::File;
 use std::io;
 use std::io::{BufReader, Cursor, Read};
+use std::os::windows::ffi::OsStrExt;
 use std::path::{Path, PathBuf};
+use std::ptr;
 use tar::Archive;
 use walkdir::{DirEntry, WalkDir};
+use winapi::shared::minwindef::LPVOID;
+use winapi::um::winver::{GetFileVersionInfoSizeW, GetFileVersionInfoW, VerQueryValueW};
 use xz2::read::XzDecoder;
 use zip::ZipArchive;
 
@@ -594,3 +599,80 @@ pub fn capitalize(s: &str) -> String {
         Some(first) => first.to_uppercase().collect::<String>() + chars.as_str(),
     }
 }
+
+pub fn get_win_file_version(file_path: &str) -> Option<String> {
+    unsafe {
+        let wide_path: Vec<u16> = OsStr::new(file_path).encode_wide().chain(Some(0)).collect();
+
+        let mut dummy = 0;
+        let size = GetFileVersionInfoSizeW(wide_path.as_ptr(), &mut dummy);
+        if size == 0 {
+            return None;
+        }
+
+        let mut buffer: Vec<u8> = Vec::with_capacity(size as usize);
+        if GetFileVersionInfoW(wide_path.as_ptr(), 0, size, buffer.as_mut_ptr() as LPVOID) == 0 {
+            return None;
+        }
+        buffer.set_len(size as usize);
+
+        let mut lang_and_codepage_ptr: LPVOID = ptr::null_mut();
+        let mut lang_and_codepage_len: u32 = 0;
+
+        if VerQueryValueW(
+            buffer.as_ptr() as LPVOID,
+            OsStr::new("\\VarFileInfo\\Translation")
+                .encode_wide()
+                .chain(Some(0))
+                .collect::<Vec<u16>>()
+                .as_ptr(),
+            &mut lang_and_codepage_ptr,
+            &mut lang_and_codepage_len,
+        ) == 0
+        {
+            return None;
+        }
+
+        if lang_and_codepage_len == 0 {
+            return None;
+        }
+
+        let lang_and_codepage_slice = std::slice::from_raw_parts(
+            lang_and_codepage_ptr as *const u16,
+            lang_and_codepage_len as usize / 2,
+        );
+        let lang = lang_and_codepage_slice[0];
+        let codepage = lang_and_codepage_slice[1];
+
+        let query = format!(
+            "\\StringFileInfo\\{:04x}{:04x}\\ProductVersion",
+            lang, codepage
+        );
+        let query_wide: Vec<u16> = OsStr::new(&query).encode_wide().chain(Some(0)).collect();
+
+        let mut product_version_ptr: LPVOID = ptr::null_mut();
+        let mut product_version_len: u32 = 0;
+
+        if VerQueryValueW(
+            buffer.as_ptr() as LPVOID,
+            query_wide.as_ptr(),
+            &mut product_version_ptr,
+            &mut product_version_len,
+        ) == 0
+        {
+            return None;
+        }
+
+        if product_version_ptr.is_null() {
+            return None;
+        }
+
+        let product_version_slice = std::slice::from_raw_parts(
+            product_version_ptr as *const u16,
+            product_version_len as usize,
+        );
+        let product_version = String::from_utf16_lossy(product_version_slice);
+
+        Some(product_version.trim_end_matches('\0').to_string())
+    }
+}

rust/src/files.rs

@@ -20,6 +20,7 @@ use crate::config::OS::{MACOS, WINDOWS};
 use crate::config::{str_to_os, ManagerConfig};
 use crate::downloads::download_to_tmp_folder;
 use crate::edge::{EdgeManager, EDGEDRIVER_NAME, EDGE_NAMES, WEBVIEW2_NAME};
+use crate::files::get_win_file_version;
 use crate::files::{
     capitalize, collect_files_from_cache, create_path_if_not_exists, default_cache_folder,
     find_latest_from_cache, get_binary_extension, path_to_string,
@@ -37,8 +38,7 @@ use crate::metadata::{
 use crate::safari::{SafariManager, SAFARIDRIVER_NAME, SAFARI_NAME};
 use crate::safaritp::{SafariTPManager, SAFARITP_NAMES};
 use crate::shell::{
-    run_powershell_command_with_log, run_shell_command, run_shell_command_by_os,
-    run_shell_command_with_log, Command,
+    run_shell_command, run_shell_command_by_os, run_shell_command_with_log, Command,
 };
 use crate::stats::{send_stats_to_plausible, Props};
 use anyhow::anyhow;
@@ -76,8 +76,6 @@ pub const DEV: &str = "dev";
 pub const CANARY: &str = "canary";
 pub const NIGHTLY: &str = "nightly";
 pub const ESR: &str = "esr";
-pub const PS_GET_VERSION_COMMAND: &str = r#"(Get-Item "{}").VersionInfo.ProductVersion"#;
-pub const PS_GET_OS_COMMAND: &str = "(Get-WmiObject Win32_OperatingSystem).OSArchitecture";
 pub const REG_VERSION_ARG: &str = "version";
 pub const REG_CURRENT_VERSION_ARG: &str = "CurrentVersion";
 pub const REG_PV_ARG: &str = "pv";
@@ -448,12 +446,11 @@ pub trait SeleniumManager {
         ));
         let mut browser_version: Option<String> = None;
         for driver_version_command in commands.into_iter() {
-            let command_result = if driver_version_command.display().starts_with("(Get-") {
-                run_powershell_command_with_log(self.get_logger(), driver_version_command)
-            } else {
-                run_shell_command_with_log(self.get_logger(), self.get_os(), driver_version_command)
-            };
-            let output = match command_result {
+            let output = match run_shell_command_with_log(
+                self.get_logger(),
+                self.get_os(),
+                driver_version_command,
+            ) {
                 Ok(out) => out,
                 Err(_) => continue,
             };
@@ -1161,11 +1158,7 @@ pub trait SeleniumManager {
         let mut commands = Vec::new();
         if WINDOWS.is(self.get_os()) {
             if !escaped_browser_path.is_empty() {
-                let get_version_command = Command::new_single(format_one_arg(
-                    PS_GET_VERSION_COMMAND,
-                    &escaped_browser_path,
-                ));
-                commands.push(get_version_command);
+                return Ok(get_win_file_version(&escaped_browser_path));
             }
             if !self.is_browser_version_unstable() {
                 let reg_command =

rust/src/lib.rs

@@ -64,13 +64,6 @@ impl Command {
     }
 }
 
-pub fn run_powershell_command_with_log(log: &Logger, command: Command) -> Result<String, Error> {
-    log.debug(format!("Running ps command: {}", command.display()));
-    let output = run_powershell_command(command)?;
-    log.debug(format!("Output: {:?}", output));
-    Ok(output)
-}
-
 pub fn run_shell_command_with_log(
     log: &Logger,
     os: &str,
@@ -82,10 +75,6 @@ pub fn run_shell_command_with_log(
     Ok(output)
 }
 
-pub fn run_powershell_command(command: Command) -> Result<String, Error> {
-    run_shell_command("powershell", "-c", command)
-}
-
 pub fn run_shell_command_by_os(os: &str, command: Command) -> Result<String, Error> {
     let (shell, flag) = if WINDOWS.is(os) {
         ("cmd", "/c")