Windows shims for GetCurrentDirectoryW/SetCurrentDirectoryW

Author: JOE1994

src/shims/env.rs

@@ -138,8 +138,8 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                 }
             }
             None => {
-                let envvar_not_found = this.eval_path_scalar(&["std", "sys", "windows", "c", "ERROR_ENVVAR_NOT_FOUND"])?;
-                this.set_last_error(envvar_not_found.not_undef()?)?;
+                let envvar_not_found = this.eval_windows("ERROR_ENVVAR_NOT_FOUND")?;
+                this.set_last_error(envvar_not_found)?;
                 0 // return zero upon failure
             }
         })
@@ -289,6 +289,8 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         size_op: OpTy<'tcx, Tag>,
     ) -> InterpResult<'tcx, Scalar<Tag>> {
         let this = self.eval_context_mut();
+        let target_os = &this.tcx.sess.target.target.target_os;
+        assert!(target_os == "linux" || target_os == "macos", "`getcwd` is only available for the UNIX target family");
 
         this.check_no_isolation("getcwd")?;
 
@@ -308,8 +310,35 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         Ok(Scalar::null_ptr(&*this.tcx))
     }
 
+    #[allow(non_snake_case)]
+    fn GetCurrentDirectoryW(
+        &mut self,
+        size_op: OpTy<'tcx, Tag>, // DWORD
+        buf_op: OpTy<'tcx, Tag>,  // LPTSTR
+    ) -> InterpResult<'tcx, u32> {
+        let this = self.eval_context_mut();
+        this.assert_target_os("windows", "GetCurrentDirectoryW");
+
+        this.check_no_isolation("GetCurrentDirectoryW")?;
+
+        let size = u64::from(this.read_scalar(size_op)?.to_u32()?);
+        let buf = this.read_scalar(buf_op)?.not_undef()?;
+
+        // If we cannot get the current directory, we return 0
+        match env::current_dir() {
+            Ok(cwd) => {
+                let len = this.write_path_to_wide_str(&cwd, buf, size)?.1;
+                return Ok(u32::try_from(len).unwrap())
+            }
+            Err(e) => this.set_last_error_from_io_error(e)?,
+        }
+        Ok(0)
+    }
+
     fn chdir(&mut self, path_op: OpTy<'tcx, Tag>) -> InterpResult<'tcx, i32> {
         let this = self.eval_context_mut();
+        let target_os = &this.tcx.sess.target.target.target_os;
+        assert!(target_os == "linux" || target_os == "macos", "`getcwd` is only available for the UNIX target family");
 
         this.check_no_isolation("chdir")?;
 
@@ -324,6 +353,27 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         }
     }
 
+    #[allow(non_snake_case)]
+    fn SetCurrentDirectoryW (
+        &mut self,
+        path_op: OpTy<'tcx, Tag>   // LPCTSTR
+    ) -> InterpResult<'tcx, i32> { // Returns BOOL(i32 in Windows)
+        let this = self.eval_context_mut();
+        this.assert_target_os("windows", "SetCurrentDirectoryW");
+
+        this.check_no_isolation("SetCurrentDirectoryW")?;
+
+        let path = this.read_path_from_wide_str(this.read_scalar(path_op)?.not_undef()?)?;
+
+        match env::set_current_dir(path) {
+            Ok(()) => Ok(1),
+            Err(e) => {
+                this.set_last_error_from_io_error(e)?;
+                Ok(0)
+            }
+        }
+    }
+
     /// Updates the `environ` static.
     /// The first time it gets called, also initializes `extra.environ`.
     fn update_environ(&mut self) -> InterpResult<'tcx> {

src/shims/foreign_items/windows.rs

@@ -40,6 +40,16 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                 this.write_scalar(Scalar::from_i32(result), dest)?;
             }
 
+            "GetCurrentDirectoryW" => {
+                let result = this.GetCurrentDirectoryW(args[0], args[1])?;
+                this.write_scalar(Scalar::from_u32(result), dest)?;
+            }
+
+            "SetCurrentDirectoryW" => {
+                let result = this.SetCurrentDirectoryW(args[0])?;
+                this.write_scalar(Scalar::from_i32(result), dest)?;
+            }
+
             // File related shims
             "GetStdHandle" => {
                 let which = this.read_scalar(args[0])?.to_i32()?;

src/shims/os_str.rs

@@ -177,72 +177,77 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
         'mir: 'a,
     {
         let this = self.eval_context_ref();
-        let os_str = this.read_os_str_from_c_str(scalar)?;
+        let os_str: &'a OsStr = this.read_os_str_from_c_str(scalar)?;
 
-        #[cfg(windows)]
-        return Ok(if this.tcx.sess.target.target.target_os == "windows" {
-            // Windows-on-Windows, all fine.
-            Cow::Borrowed(Path::new(os_str))
-        } else {
-            // Unix target, Windows host. Need to convert target '/' to host '\'.
-            let converted = os_str
-                .encode_wide()
-                .map(|wchar| if wchar == '/' as u16 { '\\' as u16 } else { wchar })
-                .collect::<Vec<_>>();
-            Cow::Owned(PathBuf::from(OsString::from_wide(&converted)))
-        });
-        #[cfg(unix)]
-        return Ok(if this.tcx.sess.target.target.target_os == "windows" {
-            // Windows target, Unix host. Need to convert target '\' to host '/'.
-            let converted = os_str
-                .as_bytes()
-                .iter()
-                .map(|&wchar| if wchar == '/' as u8 { '\\' as u8 } else { wchar })
-                .collect::<Vec<_>>();
-            Cow::Owned(PathBuf::from(OsString::from_vec(converted)))
-        } else {
-            // Unix-on-Unix, all is fine.
-            Cow::Borrowed(Path::new(os_str))
-        });
+        Ok(match convert_path_separator(os_str, &this.tcx.sess.target.target.target_os) {
+            Cow::Borrowed(x) => Cow::Borrowed(Path::new(x)),
+            Cow::Owned(y) => Cow::Owned(PathBuf::from(y)),
+        })
+    }
+
+    /// Read a null-terminated sequence of `u16`s, and perform path separator conversion if needed.
+    fn read_path_from_wide_str(&self, scalar: Scalar<Tag>) -> InterpResult<'tcx, PathBuf> {
+        let this = self.eval_context_ref();
+        let os_str: OsString = this.read_os_str_from_wide_str(scalar)?;
+
+        Ok(PathBuf::from(&convert_path_separator(&os_str, &this.tcx.sess.target.target.target_os)))
     }
 
-    /// Write a Path to the machine memory, adjusting path separators if needed.
+    /// Write a Path to the machine memory (as a null-terminated sequence of bytes),
+    /// adjusting path separators if needed.
     fn write_path_to_c_str(
         &mut self,
         path: &Path,
         scalar: Scalar<Tag>,
         size: u64,
     ) -> InterpResult<'tcx, (bool, u64)> {
         let this = self.eval_context_mut();
-
-        #[cfg(windows)]
-        let os_str = if this.tcx.sess.target.target.target_os == "windows" {
-            // Windows-on-Windows, all fine.
-            Cow::Borrowed(path.as_os_str())
-        } else {
-            // Unix target, Windows host. Need to convert host '\\' to target '/'.
-            let converted = path
-                .as_os_str()
-                .encode_wide()
-                .map(|wchar| if wchar == '\\' as u16 { '/' as u16 } else { wchar })
-                .collect::<Vec<_>>();
-            Cow::Owned(OsString::from_wide(&converted))
-        };
-        #[cfg(unix)]
-        let os_str = if this.tcx.sess.target.target.target_os == "windows" {
-            // Windows target, Unix host. Need to convert host '/' to target '\'.
-            let converted = path
-                .as_os_str()
-                .as_bytes()
-                .iter()
-                .map(|&wchar| if wchar == '/' as u8 { '\\' as u8 } else { wchar })
-                .collect::<Vec<_>>();
-            Cow::Owned(OsString::from_vec(converted))
-        } else {
-            // Unix-on-Unix, all is fine.
-            Cow::Borrowed(path.as_os_str())
-        };
-
+        let os_str = convert_path_separator(path.as_os_str(), &this.tcx.sess.target.target.target_os);
         this.write_os_str_to_c_str(&os_str, scalar, size)
     }
+
+    /// Write a Path to the machine memory (as a null-terminated sequence of `u16`s),
+    /// adjusting path separators if needed.
+    fn write_path_to_wide_str(
+        &mut self,
+        path: &Path,
+        scalar: Scalar<Tag>,
+        size: u64,
+    ) -> InterpResult<'tcx, (bool, u64)> {
+        let this = self.eval_context_mut();
+        let os_str = convert_path_separator(path.as_os_str(), &this.tcx.sess.target.target.target_os);
+        this.write_os_str_to_wide_str(&os_str, scalar, size)
+    }
+}
+
+/// Perform path separator conversion if needed.
+fn convert_path_separator<'a>(
+    os_str: &'a OsStr,
+    target_os: &str,
+) -> Cow<'a, OsStr> {
+    #[cfg(windows)]
+    return if target_os == "windows" {
+        // Windows-on-Windows, all fine.
+        Cow::Borrowed(os_str)
+    } else {
+        // Unix target, Windows host. Need to convert host '\\' to target '/'.
+        let converted = os_str
+            .encode_wide()
+            .map(|wchar| if wchar == '\\' as u16 { '/' as u16 } else { wchar })
+            .collect::<Vec<_>>();
+        Cow::Owned(OsString::from_wide(&converted))
+    };
+    #[cfg(unix)]
+    return if target_os == "windows" {
+        // Windows target, Unix host. Need to convert host '/' to target '\'.
+        let converted = os_str
+            .as_bytes()
+            .iter()
+            .map(|&wchar| if wchar == '/' as u8 { '\\' as u8 } else { wchar })
+            .collect::<Vec<_>>();
+        Cow::Owned(OsString::from_vec(converted))
+    } else {
+        // Unix-on-Unix, all is fine.
+        Cow::Borrowed(os_str)
+    };
 }

tests/run-pass/current_dir.rs

@@ -1,7 +1,6 @@
-// ignore-windows: TODO the windows hook is not done yet
 // compile-flags: -Zmiri-disable-isolation
 use std::env;
-use std::path::Path;
+use std::io::ErrorKind;
 
 fn main() {
     // Test that `getcwd` is available
@@ -11,7 +10,9 @@ fn main() {
     // keep the current directory equal to `cwd`.
     let parent = cwd.parent().unwrap_or(&cwd);
     // Test that `chdir` is available
-    assert!(env::set_current_dir(&Path::new("..")).is_ok());
+    assert!(env::set_current_dir("..").is_ok());
     // Test that `..` goes to the parent directory
     assert_eq!(env::current_dir().unwrap(), parent);
+    // Test that `chdir` to a non-existing directory returns a proper error
+    assert_eq!(env::set_current_dir("thisdoesnotexist").unwrap_err().kind(), ErrorKind::NotFound);
 }