wip: handle GetEnvironmentStringsW/FreeEnvironmentStringsW

Author: JOE1994

src/helpers.rs

@@ -458,7 +458,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
 
     /// Dispatches to appropriate implementations for reading an OsString from Memory,
     /// depending on the interpretation target.
-    fn read_os_str_from_target_str<'a>(&'a self, scalar: Scalar<Tag>) -> InterpResult<'tcx, OsString> {
+    fn read_os_str_from_target_str(&self, scalar: Scalar<Tag>) -> InterpResult<'tcx, OsString> {
         let target_os = self.eval_context_ref().tcx.sess.target.target.target_os.as_str();
         match target_os {
             "linux" | "macos" => self.read_os_str_from_c_str(scalar).map(|x| x.to_os_string()),
@@ -492,7 +492,7 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
 
     /// Helper function to read an OsString from a 0x0000-terminated sequence of u16,
     /// which is what the Windows APIs usually handle.
-    fn read_os_str_from_wide_str<'a>(&'a self, scalar: Scalar<Tag>) -> InterpResult<'tcx, OsString> {
+    fn read_os_str_from_wide_str(&self, scalar: Scalar<Tag>) -> InterpResult<'tcx, OsString> {
         #[cfg(target_os = "windows")]
         fn u16vec_to_osstring<'tcx>(u16_vec: Vec<u16>) -> InterpResult<'tcx, OsString> {
             Ok(std::os::windows::ffi::OsStringExt::from_wide(&u16_vec[..]))

src/shims/env.rs

@@ -1,6 +1,7 @@
 use std::ffi::{OsString, OsStr};
 use std::env;
 use std::convert::TryFrom;
+use std::collections::hash_map::Values;
 
 use crate::stacked_borrows::Tag;
 use crate::rustc_target::abi::LayoutOf;
@@ -36,6 +37,10 @@ impl<'tcx> EnvVars<'tcx> {
         }
         ecx.update_environ()
     }
+
+    pub(super) fn values(&self) -> InterpResult<'tcx, Values<'_, OsString, Pointer<Tag>>> {
+        Ok(self.map.values())
+    }
 }
 
 fn alloc_env_var_as_target_str<'mir, 'tcx>(

src/shims/foreign_items/windows.rs

@@ -1,7 +1,9 @@
 use crate::*;
+use crate::rustc_target::abi::LayoutOf;
 use rustc::mir;
 use rustc::ty::layout::Size;
 use std::iter;
+use std::convert::TryFrom;
 
 impl<'mir, 'tcx> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {}
 pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx> {
@@ -21,18 +23,11 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             // DWORD = ULONG = u32
             // BOOL = i32
 
-            "GetEnvironmentStringsW" => {
-                // this.write_scalar(this.machine.env_vars.environ.unwrap().vtable(), dest)?;
-            }
-
             // Environment related shims
             "GetEnvironmentVariableW" => {
                 let result = this.getenvironmentvariablew(args[0], args[1], args[2])?;
                 if result == 0 {
                     this.set_last_error(Scalar::from_u32(203))?; // ERROR_ENVVAR_NOT_FOUND
-                    // this.write_null(dest)?;
-                } else {
-                    // this.write_scalar(Scalar::from_uint(result, dest.layout.size), dest)?;
                 }
                 this.write_scalar(Scalar::from_uint(result, dest.layout.size), dest)?;
             }
@@ -42,6 +37,35 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                 this.write_scalar(Scalar::from_int(result, dest.layout.size), dest)?;
             }
 
+            "GetEnvironmentStringsW" => {
+                // Info on layout of environment blocks in Windows: 
+                // https://docs.microsoft.com/en-us/windows/win32/procthread/environment-variables
+                let mut env_vars = std::ffi::OsString::new();
+                for &item in this.machine.env_vars.values()? {
+                    let env_var = this.read_os_str_from_target_str(Scalar::from(item))?;
+                    env_vars.push(env_var);
+                    env_vars.push(" ");
+                }
+
+                // Allocate environment block
+                let tcx = this.tcx;
+                let env_block_size = env_vars.len() + 1;
+                let env_block_type = tcx.mk_array(tcx.types.u16, u64::try_from(env_block_size).unwrap());
+                let env_block_place = this.allocate(this.layout_of(env_block_type)?, MiriMemoryKind::Machine.into());
+                
+                // Store environment variables to environment block
+                // Final null terminator(block terminator) is pushed by `write_os_str_to_wide_str`
+                this.write_os_str_to_wide_str(&env_vars, env_block_place, u64::try_from(env_block_size).unwrap())?;
+
+                // If the function succeeds, the return value is a pointer to the environment block of the current process.
+                this.write_scalar(env_block_place.ptr, dest)?;
+            }
+
+            "FreeEnvironmentStringsW" => {
+                // let old_vars_ptr = this.read_scalar(args[0])?.not_undef()?;
+                // this.memory.deallocate(this.force_ptr(old_vars_ptr)?, None, MiriMemoryKind::Machine.into())?;
+            }
+
             // File related shims
             "WriteFile" => {
                 let handle = this.read_scalar(args[0])?.to_machine_isize(this)?;