src/tools/miri/src/shims/env.rs

   1 use std::env;
   2 use std::ffi::{OsStr, OsString};
   3 use std::io::ErrorKind;
   4 use std::mem;
   5
   6 use rustc_const_eval::interpret::Pointer;
   7 use rustc_data_structures::fx::FxHashMap;
   8 use rustc_middle::ty::layout::LayoutOf;
   9 use rustc_target::abi::Size;
  10
  11 use crate::helpers::target_os_is_unix;
  12 use crate::*;
  13
  14 /// Check whether an operation that writes to a target buffer was successful.
  15 /// Accordingly select return value.
  16 /// Local helper function to be used in Windows shims.
  17 fn windows_check_buffer_size((success, len): (bool, u64)) -> u32 {
  18     if success {
  19         // If the function succeeds, the return value is the number of characters stored in the target buffer,
  20         // not including the terminating null character.
  21         u32::try_from(len.checked_sub(1).unwrap()).unwrap()
  22     } else {
  23         // If the target buffer was not large enough to hold the data, the return value is the buffer size, in characters,
  24         // required to hold the string and its terminating null character.
  25         u32::try_from(len).unwrap()
  26     }
  27 }
  28
  29 #[derive(Default)]
  30 pub struct EnvVars<'tcx> {
  31     /// Stores pointers to the environment variables. These variables must be stored as
  32     /// null-terminated target strings (c_str or wide_str) with the `"{name}={value}"` format.
  33     map: FxHashMap<OsString, Pointer<Option<Provenance>>>,
  34
  35     /// Place where the `environ` static is stored. Lazily initialized, but then never changes.
  36     pub(crate) environ: Option<MPlaceTy<'tcx, Provenance>>,
  37 }
  38
  39 impl VisitTags for EnvVars<'_> {
  40     fn visit_tags(&self, visit: &mut dyn FnMut(SbTag)) {
  41         let EnvVars { map, environ } = self;
  42
  43         environ.visit_tags(visit);
  44         for ptr in map.values() {
  45             ptr.visit_tags(visit);
  46         }
  47     }
  48 }
  49
  50 impl<'tcx> EnvVars<'tcx> {
  51     pub(crate) fn init<'mir>(
  52         ecx: &mut InterpCx<'mir, 'tcx, MiriMachine<'mir, 'tcx>>,
  53         config: &MiriConfig,
  54     ) -> InterpResult<'tcx> {
  55         let target_os = ecx.tcx.sess.target.os.as_ref();
  56
  57         // Skip the loop entirely if we don't want to forward anything.
  58         if ecx.machine.communicate() || !config.forwarded_env_vars.is_empty() {
  59             for (name, value) in &config.env {
  60                 let forward = ecx.machine.communicate()
  61                     || config.forwarded_env_vars.iter().any(|v| **v == *name);
  62                 if forward {
  63                     let var_ptr = match target_os {
  64                         target if target_os_is_unix(target) =>
  65                             alloc_env_var_as_c_str(name.as_ref(), value.as_ref(), ecx)?,
  66                         "windows" => alloc_env_var_as_wide_str(name.as_ref(), value.as_ref(), ecx)?,
  67                         unsupported =>
  68                             throw_unsup_format!(
  69                                 "environment support for target OS `{}` not yet available",
  70                                 unsupported
  71                             ),
  72                     };
  73                     ecx.machine.env_vars.map.insert(name.clone(), var_ptr);
  74                 }
  75             }
  76         }
  77         ecx.update_environ()
  78     }
  79
  80     pub(crate) fn cleanup<'mir>(
  81         ecx: &mut InterpCx<'mir, 'tcx, MiriMachine<'mir, 'tcx>>,
  82     ) -> InterpResult<'tcx> {
  83         // Deallocate individual env vars.
  84         let env_vars = mem::take(&mut ecx.machine.env_vars.map);
  85         for (_name, ptr) in env_vars {
  86             ecx.deallocate_ptr(ptr, None, MiriMemoryKind::Runtime.into())?;
  87         }
  88         // Deallocate environ var list.
  89         let environ = ecx.machine.env_vars.environ.unwrap();
  90         let old_vars_ptr = ecx.read_pointer(&environ.into())?;
  91         ecx.deallocate_ptr(old_vars_ptr, None, MiriMemoryKind::Runtime.into())?;
  92         Ok(())
  93     }
  94 }
  95
  96 fn alloc_env_var_as_c_str<'mir, 'tcx>(
  97     name: &OsStr,
  98     value: &OsStr,
  99     ecx: &mut InterpCx<'mir, 'tcx, MiriMachine<'mir, 'tcx>>,
 100 ) -> InterpResult<'tcx, Pointer<Option<Provenance>>> {
 101     let mut name_osstring = name.to_os_string();
 102     name_osstring.push("=");
 103     name_osstring.push(value);
 104     ecx.alloc_os_str_as_c_str(name_osstring.as_os_str(), MiriMemoryKind::Runtime.into())
 105 }
 106
 107 fn alloc_env_var_as_wide_str<'mir, 'tcx>(
 108     name: &OsStr,
 109     value: &OsStr,
 110     ecx: &mut InterpCx<'mir, 'tcx, MiriMachine<'mir, 'tcx>>,
 111 ) -> InterpResult<'tcx, Pointer<Option<Provenance>>> {
 112     let mut name_osstring = name.to_os_string();
 113     name_osstring.push("=");
 114     name_osstring.push(value);
 115     ecx.alloc_os_str_as_wide_str(name_osstring.as_os_str(), MiriMemoryKind::Runtime.into())
 116 }
 117
 118 impl<'mir, 'tcx: 'mir> EvalContextExt<'mir, 'tcx> for crate::MiriInterpCx<'mir, 'tcx> {}
 119 pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
 120     fn getenv(
 121         &mut self,
 122         name_op: &OpTy<'tcx, Provenance>,
 123     ) -> InterpResult<'tcx, Pointer<Option<Provenance>>> {
 124         let this = self.eval_context_mut();
 125         this.assert_target_os_is_unix("getenv");
 126
 127         let name_ptr = this.read_pointer(name_op)?;
 128         let name = this.read_os_str_from_c_str(name_ptr)?;
 129         Ok(match this.machine.env_vars.map.get(name) {
 130             Some(var_ptr) => {
 131                 // The offset is used to strip the "{name}=" part of the string.
 132                 var_ptr.offset(
 133                     Size::from_bytes(u64::try_from(name.len()).unwrap().checked_add(1).unwrap()),
 134                     this,
 135                 )?
 136             }
 137             None => Pointer::null(),
 138         })
 139     }
 140
 141     #[allow(non_snake_case)]
 142     fn GetEnvironmentVariableW(
 143         &mut self,
 144         name_op: &OpTy<'tcx, Provenance>, // LPCWSTR
 145         buf_op: &OpTy<'tcx, Provenance>,  // LPWSTR
 146         size_op: &OpTy<'tcx, Provenance>, // DWORD
 147     ) -> InterpResult<'tcx, u32> {
 148         // ^ Returns DWORD (u32 on Windows)
 149
 150         let this = self.eval_context_mut();
 151         this.assert_target_os("windows", "GetEnvironmentVariableW");
 152
 153         let name_ptr = this.read_pointer(name_op)?;
 154         let name = this.read_os_str_from_wide_str(name_ptr)?;
 155         Ok(match this.machine.env_vars.map.get(&name) {
 156             Some(var_ptr) => {
 157                 // The offset is used to strip the "{name}=" part of the string.
 158                 #[rustfmt::skip]
 159                 let name_offset_bytes = u64::try_from(name.len()).unwrap()
 160                     .checked_add(1).unwrap()
 161                     .checked_mul(2).unwrap();
 162                 let var_ptr = var_ptr.offset(Size::from_bytes(name_offset_bytes), this)?;
 163                 let var = this.read_os_str_from_wide_str(var_ptr)?;
 164
 165                 let buf_ptr = this.read_pointer(buf_op)?;
 166                 // `buf_size` represents the size in characters.
 167                 let buf_size = u64::from(this.read_scalar(size_op)?.to_u32()?);
 168                 windows_check_buffer_size(this.write_os_str_to_wide_str(&var, buf_ptr, buf_size)?)
 169             }
 170             None => {
 171                 let envvar_not_found = this.eval_windows("c", "ERROR_ENVVAR_NOT_FOUND")?;
 172                 this.set_last_error(envvar_not_found)?;
 173                 0 // return zero upon failure
 174             }
 175         })
 176     }
 177
 178     #[allow(non_snake_case)]
 179     fn GetEnvironmentStringsW(&mut self) -> InterpResult<'tcx, Pointer<Option<Provenance>>> {
 180         let this = self.eval_context_mut();
 181         this.assert_target_os("windows", "GetEnvironmentStringsW");
 182
 183         // Info on layout of environment blocks in Windows:
 184         // https://docs.microsoft.com/en-us/windows/win32/procthread/environment-variables
 185         let mut env_vars = std::ffi::OsString::new();
 186         for &item in this.machine.env_vars.map.values() {
 187             let env_var = this.read_os_str_from_wide_str(item)?;
 188             env_vars.push(env_var);
 189             env_vars.push("\0");
 190         }
 191         // Allocate environment block & Store environment variables to environment block.
 192         // Final null terminator(block terminator) is added by `alloc_os_str_to_wide_str`.
 193         let envblock_ptr =
 194             this.alloc_os_str_as_wide_str(&env_vars, MiriMemoryKind::Runtime.into())?;
 195         // If the function succeeds, the return value is a pointer to the environment block of the current process.
 196         Ok(envblock_ptr)
 197     }
 198
 199     #[allow(non_snake_case)]
 200     fn FreeEnvironmentStringsW(
 201         &mut self,
 202         env_block_op: &OpTy<'tcx, Provenance>,
 203     ) -> InterpResult<'tcx, i32> {
 204         let this = self.eval_context_mut();
 205         this.assert_target_os("windows", "FreeEnvironmentStringsW");
 206
 207         let env_block_ptr = this.read_pointer(env_block_op)?;
 208         let result = this.deallocate_ptr(env_block_ptr, None, MiriMemoryKind::Runtime.into());
 209         // If the function succeeds, the return value is nonzero.
 210         Ok(i32::from(result.is_ok()))
 211     }
 212
 213     fn setenv(
 214         &mut self,
 215         name_op: &OpTy<'tcx, Provenance>,
 216         value_op: &OpTy<'tcx, Provenance>,
 217     ) -> InterpResult<'tcx, i32> {
 218         let this = self.eval_context_mut();
 219         this.assert_target_os_is_unix("setenv");
 220
 221         let name_ptr = this.read_pointer(name_op)?;
 222         let value_ptr = this.read_pointer(value_op)?;
 223
 224         let mut new = None;
 225         if !this.ptr_is_null(name_ptr)? {
 226             let name = this.read_os_str_from_c_str(name_ptr)?;
 227             if !name.is_empty() && !name.to_string_lossy().contains('=') {
 228                 let value = this.read_os_str_from_c_str(value_ptr)?;
 229                 new = Some((name.to_owned(), value.to_owned()));
 230             }
 231         }
 232         if let Some((name, value)) = new {
 233             let var_ptr = alloc_env_var_as_c_str(&name, &value, this)?;
 234             if let Some(var) = this.machine.env_vars.map.insert(name, var_ptr) {
 235                 this.deallocate_ptr(var, None, MiriMemoryKind::Runtime.into())?;
 236             }
 237             this.update_environ()?;
 238             Ok(0) // return zero on success
 239         } else {
 240             // name argument is a null pointer, points to an empty string, or points to a string containing an '=' character.
 241             let einval = this.eval_libc("EINVAL")?;
 242             this.set_last_error(einval)?;
 243             Ok(-1)
 244         }
 245     }
 246
 247     #[allow(non_snake_case)]
 248     fn SetEnvironmentVariableW(
 249         &mut self,
 250         name_op: &OpTy<'tcx, Provenance>,  // LPCWSTR
 251         value_op: &OpTy<'tcx, Provenance>, // LPCWSTR
 252     ) -> InterpResult<'tcx, i32> {
 253         let this = self.eval_context_mut();
 254         this.assert_target_os("windows", "SetEnvironmentVariableW");
 255
 256         let name_ptr = this.read_pointer(name_op)?;
 257         let value_ptr = this.read_pointer(value_op)?;
 258
 259         if this.ptr_is_null(name_ptr)? {
 260             // ERROR CODE is not clearly explained in docs.. For now, throw UB instead.
 261             throw_ub_format!("pointer to environment variable name is NULL");
 262         }
 263
 264         let name = this.read_os_str_from_wide_str(name_ptr)?;
 265         if name.is_empty() {
 266             throw_unsup_format!("environment variable name is an empty string");
 267         } else if name.to_string_lossy().contains('=') {
 268             throw_unsup_format!("environment variable name contains '='");
 269         } else if this.ptr_is_null(value_ptr)? {
 270             // Delete environment variable `{name}`
 271             if let Some(var) = this.machine.env_vars.map.remove(&name) {
 272                 this.deallocate_ptr(var, None, MiriMemoryKind::Runtime.into())?;
 273                 this.update_environ()?;
 274             }
 275             Ok(1) // return non-zero on success
 276         } else {
 277             let value = this.read_os_str_from_wide_str(value_ptr)?;
 278             let var_ptr = alloc_env_var_as_wide_str(&name, &value, this)?;
 279             if let Some(var) = this.machine.env_vars.map.insert(name, var_ptr) {
 280                 this.deallocate_ptr(var, None, MiriMemoryKind::Runtime.into())?;
 281             }
 282             this.update_environ()?;
 283             Ok(1) // return non-zero on success
 284         }
 285     }
 286
 287     fn unsetenv(&mut self, name_op: &OpTy<'tcx, Provenance>) -> InterpResult<'tcx, i32> {
 288         let this = self.eval_context_mut();
 289         this.assert_target_os_is_unix("unsetenv");
 290
 291         let name_ptr = this.read_pointer(name_op)?;
 292         let mut success = None;
 293         if !this.ptr_is_null(name_ptr)? {
 294             let name = this.read_os_str_from_c_str(name_ptr)?.to_owned();
 295             if !name.is_empty() && !name.to_string_lossy().contains('=') {
 296                 success = Some(this.machine.env_vars.map.remove(&name));
 297             }
 298         }
 299         if let Some(old) = success {
 300             if let Some(var) = old {
 301                 this.deallocate_ptr(var, None, MiriMemoryKind::Runtime.into())?;
 302             }
 303             this.update_environ()?;
 304             Ok(0)
 305         } else {
 306             // name argument is a null pointer, points to an empty string, or points to a string containing an '=' character.
 307             let einval = this.eval_libc("EINVAL")?;
 308             this.set_last_error(einval)?;
 309             Ok(-1)
 310         }
 311     }
 312
 313     fn getcwd(
 314         &mut self,
 315         buf_op: &OpTy<'tcx, Provenance>,
 316         size_op: &OpTy<'tcx, Provenance>,
 317     ) -> InterpResult<'tcx, Pointer<Option<Provenance>>> {
 318         let this = self.eval_context_mut();
 319         this.assert_target_os_is_unix("getcwd");
 320
 321         let buf = this.read_pointer(buf_op)?;
 322         let size = this.read_scalar(size_op)?.to_machine_usize(&*this.tcx)?;
 323
 324         if let IsolatedOp::Reject(reject_with) = this.machine.isolated_op {
 325             this.reject_in_isolation("`getcwd`", reject_with)?;
 326             this.set_last_error_from_io_error(ErrorKind::PermissionDenied)?;
 327             return Ok(Pointer::null());
 328         }
 329
 330         // If we cannot get the current directory, we return null
 331         match env::current_dir() {
 332             Ok(cwd) => {
 333                 if this.write_path_to_c_str(&cwd, buf, size)?.0 {
 334                     return Ok(buf);
 335                 }
 336                 let erange = this.eval_libc("ERANGE")?;
 337                 this.set_last_error(erange)?;
 338             }
 339             Err(e) => this.set_last_error_from_io_error(e.kind())?,
 340         }
 341
 342         Ok(Pointer::null())
 343     }
 344
 345     #[allow(non_snake_case)]
 346     fn GetCurrentDirectoryW(
 347         &mut self,
 348         size_op: &OpTy<'tcx, Provenance>, // DWORD
 349         buf_op: &OpTy<'tcx, Provenance>,  // LPTSTR
 350     ) -> InterpResult<'tcx, u32> {
 351         let this = self.eval_context_mut();
 352         this.assert_target_os("windows", "GetCurrentDirectoryW");
 353
 354         let size = u64::from(this.read_scalar(size_op)?.to_u32()?);
 355         let buf = this.read_pointer(buf_op)?;
 356
 357         if let IsolatedOp::Reject(reject_with) = this.machine.isolated_op {
 358             this.reject_in_isolation("`GetCurrentDirectoryW`", reject_with)?;
 359             this.set_last_error_from_io_error(ErrorKind::PermissionDenied)?;
 360             return Ok(0);
 361         }
 362
 363         // If we cannot get the current directory, we return 0
 364         match env::current_dir() {
 365             Ok(cwd) =>
 366                 return Ok(windows_check_buffer_size(this.write_path_to_wide_str(&cwd, buf, size)?)),
 367             Err(e) => this.set_last_error_from_io_error(e.kind())?,
 368         }
 369         Ok(0)
 370     }
 371
 372     fn chdir(&mut self, path_op: &OpTy<'tcx, Provenance>) -> InterpResult<'tcx, i32> {
 373         let this = self.eval_context_mut();
 374         this.assert_target_os_is_unix("chdir");
 375
 376         let path = this.read_path_from_c_str(this.read_pointer(path_op)?)?;
 377
 378         if let IsolatedOp::Reject(reject_with) = this.machine.isolated_op {
 379             this.reject_in_isolation("`chdir`", reject_with)?;
 380             this.set_last_error_from_io_error(ErrorKind::PermissionDenied)?;
 381
 382             return Ok(-1);
 383         }
 384
 385         match env::set_current_dir(path) {
 386             Ok(()) => Ok(0),
 387             Err(e) => {
 388                 this.set_last_error_from_io_error(e.kind())?;
 389                 Ok(-1)
 390             }
 391         }
 392     }
 393
 394     #[allow(non_snake_case)]
 395     fn SetCurrentDirectoryW(
 396         &mut self,
 397         path_op: &OpTy<'tcx, Provenance>, // LPCTSTR
 398     ) -> InterpResult<'tcx, i32> {
 399         // ^ Returns BOOL (i32 on Windows)
 400
 401         let this = self.eval_context_mut();
 402         this.assert_target_os("windows", "SetCurrentDirectoryW");
 403
 404         let path = this.read_path_from_wide_str(this.read_pointer(path_op)?)?;
 405
 406         if let IsolatedOp::Reject(reject_with) = this.machine.isolated_op {
 407             this.reject_in_isolation("`SetCurrentDirectoryW`", reject_with)?;
 408             this.set_last_error_from_io_error(ErrorKind::PermissionDenied)?;
 409
 410             return Ok(0);
 411         }
 412
 413         match env::set_current_dir(path) {
 414             Ok(()) => Ok(1),
 415             Err(e) => {
 416                 this.set_last_error_from_io_error(e.kind())?;
 417                 Ok(0)
 418             }
 419         }
 420     }
 421
 422     /// Updates the `environ` static.
 423     /// The first time it gets called, also initializes `extra.environ`.
 424     fn update_environ(&mut self) -> InterpResult<'tcx> {
 425         let this = self.eval_context_mut();
 426         // Deallocate the old environ list, if any.
 427         if let Some(environ) = this.machine.env_vars.environ {
 428             let old_vars_ptr = this.read_pointer(&environ.into())?;
 429             this.deallocate_ptr(old_vars_ptr, None, MiriMemoryKind::Runtime.into())?;
 430         } else {
 431             // No `environ` allocated yet, let's do that.
 432             // This is memory backing an extern static, hence `ExternStatic`, not `Env`.
 433             let layout = this.machine.layouts.mut_raw_ptr;
 434             let place = this.allocate(layout, MiriMemoryKind::ExternStatic.into())?;
 435             this.machine.env_vars.environ = Some(place);
 436         }
 437
 438         // Collect all the pointers to each variable in a vector.
 439         let mut vars: Vec<Pointer<Option<Provenance>>> =
 440             this.machine.env_vars.map.values().copied().collect();
 441         // Add the trailing null pointer.
 442         vars.push(Pointer::null());
 443         // Make an array with all these pointers inside Miri.
 444         let tcx = this.tcx;
 445         let vars_layout = this.layout_of(
 446             tcx.mk_array(this.machine.layouts.mut_raw_ptr.ty, u64::try_from(vars.len()).unwrap()),
 447         )?;
 448         let vars_place = this.allocate(vars_layout, MiriMemoryKind::Runtime.into())?;
 449         for (idx, var) in vars.into_iter().enumerate() {
 450             let place = this.mplace_field(&vars_place, idx)?;
 451             this.write_pointer(var, &place.into())?;
 452         }
 453         this.write_pointer(vars_place.ptr, &this.machine.env_vars.environ.unwrap().into())?;
 454
 455         Ok(())
 456     }
 457
 458     fn getpid(&mut self) -> InterpResult<'tcx, i32> {
 459         let this = self.eval_context_mut();
 460         this.assert_target_os_is_unix("getpid");
 461
 462         this.check_no_isolation("`getpid`")?;
 463
 464         // The reason we need to do this wacky of a conversion is because
 465         // `libc::getpid` returns an i32, however, `std::process::id()` return an u32.
 466         // So we un-do the conversion that stdlib does and turn it back into an i32.
 467         #[allow(clippy::cast_possible_wrap)]
 468         Ok(std::process::id() as i32)
 469     }
 470
 471     #[allow(non_snake_case)]
 472     fn GetCurrentProcessId(&mut self) -> InterpResult<'tcx, u32> {
 473         let this = self.eval_context_mut();
 474         this.assert_target_os("windows", "GetCurrentProcessId");
 475
 476         this.check_no_isolation("`GetCurrentProcessId`")?;
 477
 478         Ok(std::process::id())
 479     }
 480 }