sgx_tstd/src/env.rs - incubator-teaclave-sgx-sdk - Git at Google

 // Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
 // distributed with this work for additional information
 // regarding copyright ownership.  The ASF licenses this file
 // to you under the Apache License, Version 2.0 (the
 // "License"); you may not use this file except in compliance
 // with the License.  You may obtain a copy of the License at
 //
 //   http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing,
 // software distributed under the License is distributed on an
 // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License..

 //! Inspection and manipulation of the process's environment.

 use core::fmt;
 use crate::error::Error;
 use crate::ffi::{OsStr, OsString};
 use crate::path::{Path, PathBuf};
 use crate::sys::os as os_imp;
 use crate::io;

 /// Returns the current working directory as a [`PathBuf`].
 ///
 /// # Errors
 ///
 /// Returns an [`Err`] if the current working directory value is invalid.
 /// Possible cases:
 ///
 /// * Current directory does not exist.
 /// * There are insufficient permissions to access the current directory.
 ///
 /// [`PathBuf`]: ../../std/path/struct.PathBuf.html
 /// [`Err`]: ../../std/result/enum.Result.html#method.err
 ///
 pub fn current_dir() -> io::Result<PathBuf> {
     os_imp::getcwd()
 }

 /// Changes the current working directory to the specified path.
 ///
 /// Returns an [`Err`] if the operation fails.
 ///
 /// [`Err`]: ../../std/result/enum.Result.html#method.err
 ///
 pub fn set_current_dir<P: AsRef<Path>>(path: P) -> io::Result<()> {
     os_imp::chdir(path.as_ref())
 }

 /// An iterator over a snapshot of the environment variables of this process.
 ///
 /// This structure is created by the [`std::env::vars`] function. See its
 /// documentation for more.
 ///
 /// [`std::env::vars`]: fn.vars.html
 pub struct Vars {
     inner: VarsOs,
 }

 /// An iterator over a snapshot of the environment variables of this process.
 ///
 /// This structure is created by the [`std::env::vars_os`] function. See
 /// its documentation for more.
 ///
 /// [`std::env::vars_os`]: fn.vars_os.html
 pub struct VarsOs {
     inner: os_imp::Env,
 }

 /// Returns an iterator of (variable, value) pairs of strings, for all the
 /// environment variables of the current process.
 ///
 /// The returned iterator contains a snapshot of the process's environment
 /// variables at the time of this invocation. Modifications to environment
 /// variables afterwards will not be reflected in the returned iterator.
 ///
 /// # Panics
 ///
 /// While iterating, the returned iterator will panic if any key or value in the
 /// environment is not valid unicode. If this is not desired, consider using the
 /// [`env::vars_os`] function.
 ///
 /// [`env::vars_os`]: fn.vars_os.html
 pub fn vars() -> Vars {
     Vars { inner: vars_os() }
 }

 /// Returns an iterator of (variable, value) pairs of OS strings, for all the
 /// environment variables of the current process.
 ///
 /// The returned iterator contains a snapshot of the process's environment
 /// variables at the time of this invocation. Modifications to environment
 /// variables afterwards will not be reflected in the returned iterator.
 ///
 pub fn vars_os() -> VarsOs {
     VarsOs { inner: os_imp::env() }
 }

 impl Iterator for Vars {
     type Item = (String, String);
     fn next(&mut self) -> Option<(String, String)> {
         self.inner.next().map(|(a, b)| (a.into_string().unwrap(), b.into_string().unwrap()))
     }
     fn size_hint(&self) -> (usize, Option<usize>) {
         self.inner.size_hint()
     }
 }

 impl fmt::Debug for Vars {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.pad("Vars { .. }")
     }
 }

 impl Iterator for VarsOs {
     type Item = (OsString, OsString);
     fn next(&mut self) -> Option<(OsString, OsString)> {
         self.inner.next()
     }
     fn size_hint(&self) -> (usize, Option<usize>) {
         self.inner.size_hint()
     }
 }

 impl fmt::Debug for VarsOs {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.pad("VarsOs { .. }")
     }
 }

 /// Fetches the environment variable `key` from the current process.
 ///
 /// # Errors
 ///
 /// * Environment variable is not present
 /// * Environment variable is not valid unicode
 ///
 /// # Panics
 ///
 /// This function may panic if `key` is empty, contains an ASCII equals sign
 /// `'='` or the NUL character `'\0'`, or when the value contains the NUL
 /// character.
 ///
 pub fn var<K: AsRef<OsStr>>(key: K) -> Result<String, VarError> {
     _var(key.as_ref())
 }

 fn _var(key: &OsStr) -> Result<String, VarError> {
     match var_os(key) {
         Some(s) => s.into_string().map_err(VarError::NotUnicode),
         None => Err(VarError::NotPresent),
     }
 }

 /// Fetches the environment variable `key` from the current process, returning
 /// [`None`] if the variable isn't set.
 ///
 /// [`None`]: ../option/enum.Option.html#variant.None
 ///
 /// # Panics
 ///
 /// This function may panic if `key` is empty, contains an ASCII equals sign
 /// `'='` or the NUL character `'\0'`, or when the value contains the NUL
 /// character.
 ///
 pub fn var_os<K: AsRef<OsStr>>(key: K) -> Option<OsString> {
     _var_os(key.as_ref())
 }

 fn _var_os(key: &OsStr) -> Option<OsString> {
     os_imp::getenv(key)
         .unwrap_or_else(|e| panic!("failed to get environment variable `{:?}`: {}", key, e))
 }

 /// The error type for operations interacting with environment variables.
 /// Possibly returned from the [`env::var`] function.
 ///
 /// [`env::var`]: fn.var.html
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub enum VarError {
     /// The specified environment variable was not present in the current
     /// process's environment.
     NotPresent,

     /// The specified environment variable was found, but it did not contain
     /// valid unicode data. The found data is returned as a payload of this
     /// variant.
     NotUnicode(OsString),
 }

 impl fmt::Display for VarError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
             VarError::NotPresent => write!(f, "environment variable not found"),
             VarError::NotUnicode(ref s) => {
                 write!(f, "environment variable was not valid unicode: {:?}", s)
             }
         }
     }
 }

 impl Error for VarError {
     fn description(&self) -> &str {
         match *self {
             VarError::NotPresent => "environment variable not found",
             VarError::NotUnicode(..) => "environment variable was not valid unicode",
         }
     }
 }

 /// Sets the environment variable `k` to the value `v` for the currently running
 /// process.
 ///
 /// Note that while concurrent access to environment variables is safe in Rust,
 /// some platforms only expose inherently unsafe non-threadsafe APIs for
 /// inspecting the environment. As a result, extra care needs to be taken when
 /// auditing calls to unsafe external FFI functions to ensure that any external
 /// environment accesses are properly synchronized with accesses in Rust.
 ///
 /// Discussion of this unsafety on Unix may be found in:
 ///
 ///  - [Austin Group Bugzilla](http://austingroupbugs.net/view.php?id=188)
 ///  - [GNU C library Bugzilla](https://sourceware.org/bugzilla/show_bug.cgi?id=15607#c2)
 ///
 /// # Panics
 ///
 /// This function may panic if `key` is empty, contains an ASCII equals sign
 /// `'='` or the NUL character `'\0'`, or when the value contains the NUL
 /// character.
 ///
 pub fn set_var<K: AsRef<OsStr>, V: AsRef<OsStr>>(k: K, v: V) {
     _set_var(k.as_ref(), v.as_ref())
 }

 fn _set_var(k: &OsStr, v: &OsStr) {
     os_imp::setenv(k, v).unwrap_or_else(|e| {
         panic!("failed to set environment variable `{:?}` to `{:?}`: {}", k, v, e)
     })
 }

 /// Removes an environment variable from the environment of the currently running process.
 ///
 /// Note that while concurrent access to environment variables is safe in Rust,
 /// some platforms only expose inherently unsafe non-threadsafe APIs for
 /// inspecting the environment. As a result extra care needs to be taken when
 /// auditing calls to unsafe external FFI functions to ensure that any external
 /// environment accesses are properly synchronized with accesses in Rust.
 ///
 /// Discussion of this unsafety on Unix may be found in:
 ///
 ///  - [Austin Group Bugzilla](http://austingroupbugs.net/view.php?id=188)
 ///  - [GNU C library Bugzilla](https://sourceware.org/bugzilla/show_bug.cgi?id=15607#c2)
 ///
 /// # Panics
 ///
 /// This function may panic if `key` is empty, contains an ASCII equals sign
 /// `'='` or the NUL character `'\0'`, or when the value contains the NUL
 /// character.
 ///
 pub fn remove_var<K: AsRef<OsStr>>(k: K) {
     _remove_var(k.as_ref())
 }

 fn _remove_var(k: &OsStr) {
     os_imp::unsetenv(k)
         .unwrap_or_else(|e| panic!("failed to remove environment variable `{:?}`: {}", k, e))
 }

 /// An iterator that splits an environment variable into paths according to
 /// platform-specific conventions.
 ///
 /// The iterator element type is [`PathBuf`].
 ///
 /// This structure is created by the [`std::env::split_paths`] function. See its
 /// documentation for more.
 ///
 /// [`PathBuf`]: ../../std/path/struct.PathBuf.html
 /// [`std::env::split_paths`]: fn.split_paths.html
 pub struct SplitPaths<'a> {
     inner: os_imp::SplitPaths<'a>,
 }

 /// Parses input according to platform conventions for the `PATH`
 /// environment variable.
 ///
 /// Returns an iterator over the paths contained in `unparsed`. The iterator
 /// element type is [`PathBuf`].
 ///
 pub fn split_paths<T: AsRef<OsStr> + ?Sized>(unparsed: &T) -> SplitPaths<'_> {
     SplitPaths { inner: os_imp::split_paths(unparsed.as_ref()) }
 }

 impl<'a> Iterator for SplitPaths<'a> {
     type Item = PathBuf;
     fn next(&mut self) -> Option<PathBuf> {
         self.inner.next()
     }
     fn size_hint(&self) -> (usize, Option<usize>) {
         self.inner.size_hint()
     }
 }

 impl fmt::Debug for SplitPaths<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.pad("SplitPaths { .. }")
     }
 }

 /// The error type for operations on the `PATH` variable. Possibly returned from
 /// the [`env::join_paths`] function.
 ///
 /// [`env::join_paths`]: fn.join_paths.html
 #[derive(Debug)]
 pub struct JoinPathsError {
     inner: os_imp::JoinPathsError,
 }

 /// Joins a collection of [`Path`]s appropriately for the `PATH`
 /// environment variable.
 ///
 /// # Errors
 ///
 /// Returns an [`Err`][err] (containing an error message) if one of the input
 /// [`Path`]s contains an invalid character for constructing the `PATH`
 /// variable (a double quote on Windows or a colon on Unix).
 ///
 /// [`Path`]: ../../std/path/struct.Path.html
 /// [`OsString`]: ../../std/ffi/struct.OsString.html
 /// [err]: ../../std/result/enum.Result.html#variant.Err
 ///
 pub fn join_paths<I, T>(paths: I) -> Result<OsString, JoinPathsError>
 where
     I: IntoIterator<Item = T>,
     T: AsRef<OsStr>,
 {
     os_imp::join_paths(paths.into_iter()).map_err(|e| JoinPathsError { inner: e })
 }

 impl fmt::Display for JoinPathsError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.inner.fmt(f)
     }
 }

 impl Error for JoinPathsError {
     fn description(&self) -> &str {
         self.inner.description()
     }
 }

 /// Returns the path of the current user's home directory if known.
 ///
 /// # Unix
 ///
 /// - Returns the value of the 'HOME' environment variable if it is set
 ///   (including to an empty string).
 /// - Otherwise, it tries to determine the home directory by invoking the `getpwuid_r` function
 ///   using the UID of the current user. An empty home directory field returned from the
 ///   `getpwuid_r` function is considered to be a valid value.
 /// - Returns `None` if the current user has no entry in the /etc/passwd file.
 ///
 /// # Windows
 ///
 /// - Returns the value of the 'HOME' environment variable if it is set
 ///   (including to an empty string).
 /// - Otherwise, returns the value of the 'USERPROFILE' environment variable if it is set
 ///   (including to an empty string).
 /// - If both do not exist, [`GetUserProfileDirectory`][msdn] is used to return the path.
 ///
 /// [msdn]: https://docs.microsoft.com/en-us/windows/win32/api/userenv/nf-userenv-getuserprofiledirectorya
 ///
 pub fn home_dir() -> Option<PathBuf> {
     os_imp::home_dir()
 }

 /// Returns the path of a temporary directory.
 ///
 /// # Unix
 ///
 /// Returns the value of the `TMPDIR` environment variable if it is
 /// set, otherwise for non-Android it returns `/tmp`. If Android, since there
 /// is no global temporary folder (it is usually allocated per-app), it returns
 /// `/data/local/tmp`.
 ///
 /// # Windows
 ///
 /// Returns the value of, in order, the `TMP`, `TEMP`,
 /// `USERPROFILE` environment variable if any are set and not the empty
 /// string. Otherwise, `temp_dir` returns the path of the Windows directory.
 /// This behavior is identical to that of [`GetTempPath`][msdn], which this
 /// function uses internally.
 ///
 /// [msdn]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-gettemppatha
 ///
 pub fn temp_dir() -> PathBuf {
     os_imp::temp_dir()
 }

 /// Returns the full filesystem path of the current running executable.
 ///
 /// # Platform-specific behavior
 ///
 /// If the executable was invoked through a symbolic link, some platforms will
 /// return the path of the symbolic link and other platforms will return the
 /// path of the symbolic link’s target.
 ///
 /// # Errors
 ///
 /// Acquiring the path of the current executable is a platform-specific operation
 /// that can fail for a good number of reasons. Some errors can include, but not
 /// be limited to, filesystem operations failing or general syscall failures.
 ///
 /// # Security
 ///
 /// The output of this function should not be used in anything that might have
 /// security implications. For example:
 ///
 /// ```
 /// fn main() {
 ///     println!("{:?}", std::env::current_exe());
 /// }
 /// ```
 ///
 /// On Linux systems, if this is compiled as `foo`:
 ///
 /// ```bash
 /// $ rustc foo.rs
 /// $ ./foo
 /// Ok("/home/alex/foo")
 /// ```
 ///
 /// And you make a hard link of the program:
 ///
 /// ```bash
 /// $ ln foo bar
 /// ```
 ///
 /// When you run it, you won’t get the path of the original executable, you’ll
 /// get the path of the hard link:
 ///
 /// ```bash
 /// $ ./bar
 /// Ok("/home/alex/bar")
 /// ```
 ///
 /// This sort of behavior has been known to [lead to privilege escalation] when
 /// used incorrectly.
 ///
 /// [lead to privilege escalation]: https://securityvulns.com/Wdocument183.html
 ///
 pub fn current_exe() -> io::Result<PathBuf> {
     os_imp::current_exe()
 }

 /// Constants associated with the current target
 pub mod consts {
     use crate::sys::env::os;

     /// A string describing the architecture of the CPU that is currently
     /// in use.
     ///
     /// Some possible values:
     ///
     /// - x86
     /// - x86_64
     /// - arm
     /// - aarch64
     /// - mips
     /// - mips64
     /// - powerpc
     /// - powerpc64
     /// - riscv64
     /// - s390x
     /// - sparc64
     pub const ARCH: &str = super::arch::ARCH;

     /// The family of the operating system. Example value is `unix`.
     ///
     /// Some possible values:
     ///
     /// - unix
     /// - windows
     pub const FAMILY: &str = os::FAMILY;

     /// A string describing the specific operating system in use.
     /// Example value is `linux`.
     ///
     /// Some possible values:
     ///
     /// - linux
     /// - macos
     /// - ios
     /// - freebsd
     /// - dragonfly
     /// - netbsd
     /// - openbsd
     /// - solaris
     /// - android
     /// - windows
     pub const OS: &str = os::OS;

     /// Specifies the filename prefix used for shared libraries on this
     /// platform. Example value is `lib`.
     ///
     /// Some possible values:
     ///
     /// - lib
     /// - `""` (an empty string)
     pub const DLL_PREFIX: &str = os::DLL_PREFIX;

     /// Specifies the filename suffix used for shared libraries on this
     /// platform. Example value is `.so`.
     ///
     /// Some possible values:
     ///
     /// - .so
     /// - .dylib
     /// - .dll
     pub const DLL_SUFFIX: &str = os::DLL_SUFFIX;

     /// Specifies the file extension used for shared libraries on this
     /// platform that goes after the dot. Example value is `so`.
     ///
     /// Some possible values:
     ///
     /// - so
     /// - dylib
     /// - dll
     pub const DLL_EXTENSION: &str = os::DLL_EXTENSION;

     /// Specifies the filename suffix used for executable binaries on this
     /// platform. Example value is `.exe`.
     ///
     /// Some possible values:
     ///
     /// - .exe
     /// - .nexe
     /// - .pexe
     /// - `""` (an empty string)
     pub const EXE_SUFFIX: &str = os::EXE_SUFFIX;

     /// Specifies the file extension, if any, used for executable binaries
     /// on this platform. Example value is `exe`.
     ///
     /// Some possible values:
     ///
     /// - exe
     /// - `""` (an empty string)
     pub const EXE_EXTENSION: &str = os::EXE_EXTENSION;
 }

 #[cfg(target_arch = "x86")]
 mod arch {
     pub const ARCH: &str = "x86";
 }

 #[cfg(target_arch = "x86_64")]
 mod arch {
     pub const ARCH: &str = "x86_64";
 }
	// Licensed to the Apache Software Foundation (ASF) under one
	// or more contributor license agreements. See the NOTICE file
	// distributed with this work for additional information
	// regarding copyright ownership. The ASF licenses this file
	// to you under the Apache License, Version 2.0 (the
	// "License"); you may not use this file except in compliance
	// with the License. You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing,
	// software distributed under the License is distributed on an
	// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	// KIND, either express or implied. See the License for the
	// specific language governing permissions and limitations
	// under the License..

	//! Inspection and manipulation of the process's environment.

	use core::fmt;
	use crate::error::Error;
	use crate::ffi::{OsStr, OsString};
	use crate::path::{Path, PathBuf};
	use crate::sys::os as os_imp;
	use crate::io;

	/// Returns the current working directory as a [`PathBuf`].
	///
	/// # Errors
	///
	/// Returns an [`Err`] if the current working directory value is invalid.
	/// Possible cases:
	///
	/// * Current directory does not exist.
	/// * There are insufficient permissions to access the current directory.
	///
	/// [`PathBuf`]: ../../std/path/struct.PathBuf.html
	/// [`Err`]: ../../std/result/enum.Result.html#method.err
	///
	pub fn current_dir() -> io::Result<PathBuf> {
	os_imp::getcwd()
	}

	/// Changes the current working directory to the specified path.
	///
	/// Returns an [`Err`] if the operation fails.
	///
	/// [`Err`]: ../../std/result/enum.Result.html#method.err
	///
	pub fn set_current_dir<P: AsRef<Path>>(path: P) -> io::Result<()> {
	os_imp::chdir(path.as_ref())
	}

	/// An iterator over a snapshot of the environment variables of this process.
	///
	/// This structure is created by the [`std::env::vars`] function. See its
	/// documentation for more.
	///
	/// [`std::env::vars`]: fn.vars.html
	pub struct Vars {
	inner: VarsOs,
	}

	/// An iterator over a snapshot of the environment variables of this process.
	///
	/// This structure is created by the [`std::env::vars_os`] function. See
	/// its documentation for more.
	///
	/// [`std::env::vars_os`]: fn.vars_os.html
	pub struct VarsOs {
	inner: os_imp::Env,
	}

	/// Returns an iterator of (variable, value) pairs of strings, for all the
	/// environment variables of the current process.
	///
	/// The returned iterator contains a snapshot of the process's environment
	/// variables at the time of this invocation. Modifications to environment
	/// variables afterwards will not be reflected in the returned iterator.
	///
	/// # Panics
	///
	/// While iterating, the returned iterator will panic if any key or value in the
	/// environment is not valid unicode. If this is not desired, consider using the
	/// [`env::vars_os`] function.
	///
	/// [`env::vars_os`]: fn.vars_os.html
	pub fn vars() -> Vars {
	Vars { inner: vars_os() }
	}

	/// Returns an iterator of (variable, value) pairs of OS strings, for all the
	/// environment variables of the current process.
	///
	/// The returned iterator contains a snapshot of the process's environment
	/// variables at the time of this invocation. Modifications to environment
	/// variables afterwards will not be reflected in the returned iterator.
	///
	pub fn vars_os() -> VarsOs {
	VarsOs { inner: os_imp::env() }
	}

	impl Iterator for Vars {
	type Item = (String, String);
	fn next(&mut self) -> Option<(String, String)> {
	self.inner.next().map(\|(a, b)\| (a.into_string().unwrap(), b.into_string().unwrap()))
	}
	fn size_hint(&self) -> (usize, Option<usize>) {
	self.inner.size_hint()
	}
	}

	impl fmt::Debug for Vars {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
	f.pad("Vars { .. }")
	}
	}

	impl Iterator for VarsOs {
	type Item = (OsString, OsString);
	fn next(&mut self) -> Option<(OsString, OsString)> {
	self.inner.next()
	}
	fn size_hint(&self) -> (usize, Option<usize>) {
	self.inner.size_hint()
	}
	}

	impl fmt::Debug for VarsOs {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
	f.pad("VarsOs { .. }")
	}
	}

	/// Fetches the environment variable `key` from the current process.
	///
	/// # Errors
	///
	/// * Environment variable is not present
	/// * Environment variable is not valid unicode
	///
	/// # Panics
	///
	/// This function may panic if `key` is empty, contains an ASCII equals sign
	/// `'='` or the NUL character `'\0'`, or when the value contains the NUL
	/// character.
	///
	pub fn var<K: AsRef<OsStr>>(key: K) -> Result<String, VarError> {
	_var(key.as_ref())
	}

	fn _var(key: &OsStr) -> Result<String, VarError> {
	match var_os(key) {
	Some(s) => s.into_string().map_err(VarError::NotUnicode),
	None => Err(VarError::NotPresent),
	}
	}

	/// Fetches the environment variable `key` from the current process, returning
	/// [`None`] if the variable isn't set.
	///
	/// [`None`]: ../option/enum.Option.html#variant.None
	///
	/// # Panics
	///
	/// This function may panic if `key` is empty, contains an ASCII equals sign
	/// `'='` or the NUL character `'\0'`, or when the value contains the NUL
	/// character.
	///
	pub fn var_os<K: AsRef<OsStr>>(key: K) -> Option<OsString> {
	_var_os(key.as_ref())
	}

	fn _var_os(key: &OsStr) -> Option<OsString> {
	os_imp::getenv(key)
	.unwrap_or_else(\|e\| panic!("failed to get environment variable `{:?}`: {}", key, e))
	}

	/// The error type for operations interacting with environment variables.
	/// Possibly returned from the [`env::var`] function.
	///
	/// [`env::var`]: fn.var.html
	#[derive(Debug, PartialEq, Eq, Clone)]
	pub enum VarError {
	/// The specified environment variable was not present in the current
	/// process's environment.
	NotPresent,

	/// The specified environment variable was found, but it did not contain
	/// valid unicode data. The found data is returned as a payload of this
	/// variant.
	NotUnicode(OsString),
	}

	impl fmt::Display for VarError {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
	match *self {
	VarError::NotPresent => write!(f, "environment variable not found"),
	VarError::NotUnicode(ref s) => {
	write!(f, "environment variable was not valid unicode: {:?}", s)
	}
	}
	}
	}

	impl Error for VarError {
	fn description(&self) -> &str {
	match *self {
	VarError::NotPresent => "environment variable not found",
	VarError::NotUnicode(..) => "environment variable was not valid unicode",
	}
	}
	}

	/// Sets the environment variable `k` to the value `v` for the currently running
	/// process.
	///
	/// Note that while concurrent access to environment variables is safe in Rust,
	/// some platforms only expose inherently unsafe non-threadsafe APIs for
	/// inspecting the environment. As a result, extra care needs to be taken when
	/// auditing calls to unsafe external FFI functions to ensure that any external
	/// environment accesses are properly synchronized with accesses in Rust.
	///
	/// Discussion of this unsafety on Unix may be found in:
	///
	/// - [Austin Group Bugzilla](http://austingroupbugs.net/view.php?id=188)
	/// - [GNU C library Bugzilla](https://sourceware.org/bugzilla/show_bug.cgi?id=15607#c2)
	///
	/// # Panics
	///
	/// This function may panic if `key` is empty, contains an ASCII equals sign
	/// `'='` or the NUL character `'\0'`, or when the value contains the NUL
	/// character.
	///
	pub fn set_var<K: AsRef<OsStr>, V: AsRef<OsStr>>(k: K, v: V) {
	_set_var(k.as_ref(), v.as_ref())
	}

	fn _set_var(k: &OsStr, v: &OsStr) {
	os_imp::setenv(k, v).unwrap_or_else(\|e\| {
	panic!("failed to set environment variable `{:?}` to `{:?}`: {}", k, v, e)
	})
	}

	/// Removes an environment variable from the environment of the currently running process.
	///
	/// Note that while concurrent access to environment variables is safe in Rust,
	/// some platforms only expose inherently unsafe non-threadsafe APIs for
	/// inspecting the environment. As a result extra care needs to be taken when
	/// auditing calls to unsafe external FFI functions to ensure that any external
	/// environment accesses are properly synchronized with accesses in Rust.
	///
	/// Discussion of this unsafety on Unix may be found in:
	///
	/// - [Austin Group Bugzilla](http://austingroupbugs.net/view.php?id=188)
	/// - [GNU C library Bugzilla](https://sourceware.org/bugzilla/show_bug.cgi?id=15607#c2)
	///
	/// # Panics
	///
	/// This function may panic if `key` is empty, contains an ASCII equals sign
	/// `'='` or the NUL character `'\0'`, or when the value contains the NUL
	/// character.
	///
	pub fn remove_var<K: AsRef<OsStr>>(k: K) {
	_remove_var(k.as_ref())
	}

	fn _remove_var(k: &OsStr) {
	os_imp::unsetenv(k)
	.unwrap_or_else(\|e\| panic!("failed to remove environment variable `{:?}`: {}", k, e))
	}

	/// An iterator that splits an environment variable into paths according to
	/// platform-specific conventions.
	///
	/// The iterator element type is [`PathBuf`].
	///
	/// This structure is created by the [`std::env::split_paths`] function. See its
	/// documentation for more.
	///
	/// [`PathBuf`]: ../../std/path/struct.PathBuf.html
	/// [`std::env::split_paths`]: fn.split_paths.html
	pub struct SplitPaths<'a> {
	inner: os_imp::SplitPaths<'a>,
	}

	/// Parses input according to platform conventions for the `PATH`
	/// environment variable.
	///
	/// Returns an iterator over the paths contained in `unparsed`. The iterator
	/// element type is [`PathBuf`].
	///
	pub fn split_paths<T: AsRef<OsStr> + ?Sized>(unparsed: &T) -> SplitPaths<'_> {
	SplitPaths { inner: os_imp::split_paths(unparsed.as_ref()) }
	}

	impl<'a> Iterator for SplitPaths<'a> {
	type Item = PathBuf;
	fn next(&mut self) -> Option<PathBuf> {
	self.inner.next()
	}
	fn size_hint(&self) -> (usize, Option<usize>) {
	self.inner.size_hint()
	}
	}

	impl fmt::Debug for SplitPaths<'_> {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
	f.pad("SplitPaths { .. }")
	}
	}

	/// The error type for operations on the `PATH` variable. Possibly returned from
	/// the [`env::join_paths`] function.
	///
	/// [`env::join_paths`]: fn.join_paths.html
	#[derive(Debug)]
	pub struct JoinPathsError {
	inner: os_imp::JoinPathsError,
	}

	/// Joins a collection of [`Path`]s appropriately for the `PATH`
	/// environment variable.
	///
	/// # Errors
	///
	/// Returns an [`Err`][err] (containing an error message) if one of the input
	/// [`Path`]s contains an invalid character for constructing the `PATH`
	/// variable (a double quote on Windows or a colon on Unix).
	///
	/// [`Path`]: ../../std/path/struct.Path.html
	/// [`OsString`]: ../../std/ffi/struct.OsString.html
	/// [err]: ../../std/result/enum.Result.html#variant.Err
	///
	pub fn join_paths<I, T>(paths: I) -> Result<OsString, JoinPathsError>
	where
	I: IntoIterator<Item = T>,
	T: AsRef<OsStr>,
	{
	os_imp::join_paths(paths.into_iter()).map_err(\|e\| JoinPathsError { inner: e })
	}

	impl fmt::Display for JoinPathsError {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
	self.inner.fmt(f)
	}
	}

	impl Error for JoinPathsError {
	fn description(&self) -> &str {
	self.inner.description()
	}
	}

	/// Returns the path of the current user's home directory if known.
	///
	/// # Unix
	///
	/// - Returns the value of the 'HOME' environment variable if it is set
	/// (including to an empty string).
	/// - Otherwise, it tries to determine the home directory by invoking the `getpwuid_r` function
	/// using the UID of the current user. An empty home directory field returned from the
	/// `getpwuid_r` function is considered to be a valid value.
	/// - Returns `None` if the current user has no entry in the /etc/passwd file.
	///
	/// # Windows
	///
	/// - Returns the value of the 'HOME' environment variable if it is set
	/// (including to an empty string).
	/// - Otherwise, returns the value of the 'USERPROFILE' environment variable if it is set
	/// (including to an empty string).
	/// - If both do not exist, [`GetUserProfileDirectory`][msdn] is used to return the path.
	///
	/// [msdn]: https://docs.microsoft.com/en-us/windows/win32/api/userenv/nf-userenv-getuserprofiledirectorya
	///
	pub fn home_dir() -> Option<PathBuf> {
	os_imp::home_dir()
	}

	/// Returns the path of a temporary directory.
	///
	/// # Unix
	///
	/// Returns the value of the `TMPDIR` environment variable if it is
	/// set, otherwise for non-Android it returns `/tmp`. If Android, since there
	/// is no global temporary folder (it is usually allocated per-app), it returns
	/// `/data/local/tmp`.
	///
	/// # Windows
	///
	/// Returns the value of, in order, the `TMP`, `TEMP`,
	/// `USERPROFILE` environment variable if any are set and not the empty
	/// string. Otherwise, `temp_dir` returns the path of the Windows directory.
	/// This behavior is identical to that of [`GetTempPath`][msdn], which this
	/// function uses internally.
	///
	/// [msdn]: https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-gettemppatha
	///
	pub fn temp_dir() -> PathBuf {
	os_imp::temp_dir()
	}

	/// Returns the full filesystem path of the current running executable.
	///
	/// # Platform-specific behavior
	///
	/// If the executable was invoked through a symbolic link, some platforms will
	/// return the path of the symbolic link and other platforms will return the
	/// path of the symbolic link’s target.
	///
	/// # Errors
	///
	/// Acquiring the path of the current executable is a platform-specific operation
	/// that can fail for a good number of reasons. Some errors can include, but not
	/// be limited to, filesystem operations failing or general syscall failures.
	///
	/// # Security
	///
	/// The output of this function should not be used in anything that might have
	/// security implications. For example:
	///
	/// ```
	/// fn main() {
	/// println!("{:?}", std::env::current_exe());
	/// }
	/// ```
	///
	/// On Linux systems, if this is compiled as `foo`:
	///
	/// ```bash
	/// $ rustc foo.rs
	/// $ ./foo
	/// Ok("/home/alex/foo")
	/// ```
	///
	/// And you make a hard link of the program:
	///
	/// ```bash
	/// $ ln foo bar
	/// ```
	///
	/// When you run it, you won’t get the path of the original executable, you’ll
	/// get the path of the hard link:
	///
	/// ```bash
	/// $ ./bar
	/// Ok("/home/alex/bar")
	/// ```
	///
	/// This sort of behavior has been known to [lead to privilege escalation] when
	/// used incorrectly.
	///
	/// [lead to privilege escalation]: https://securityvulns.com/Wdocument183.html
	///
	pub fn current_exe() -> io::Result<PathBuf> {
	os_imp::current_exe()
	}

	/// Constants associated with the current target
	pub mod consts {
	use crate::sys::env::os;

	/// A string describing the architecture of the CPU that is currently
	/// in use.
	///
	/// Some possible values:
	///
	/// - x86
	/// - x86_64
	/// - arm
	/// - aarch64
	/// - mips
	/// - mips64
	/// - powerpc
	/// - powerpc64
	/// - riscv64
	/// - s390x
	/// - sparc64
	pub const ARCH: &str = super::arch::ARCH;

	/// The family of the operating system. Example value is `unix`.
	///
	/// Some possible values:
	///
	/// - unix
	/// - windows
	pub const FAMILY: &str = os::FAMILY;

	/// A string describing the specific operating system in use.
	/// Example value is `linux`.
	///
	/// Some possible values:
	///
	/// - linux
	/// - macos
	/// - ios
	/// - freebsd
	/// - dragonfly
	/// - netbsd
	/// - openbsd
	/// - solaris
	/// - android
	/// - windows
	pub const OS: &str = os::OS;

	/// Specifies the filename prefix used for shared libraries on this
	/// platform. Example value is `lib`.
	///
	/// Some possible values:
	///
	/// - lib
	/// - `""` (an empty string)
	pub const DLL_PREFIX: &str = os::DLL_PREFIX;

	/// Specifies the filename suffix used for shared libraries on this
	/// platform. Example value is `.so`.
	///
	/// Some possible values:
	///
	/// - .so
	/// - .dylib
	/// - .dll
	pub const DLL_SUFFIX: &str = os::DLL_SUFFIX;

	/// Specifies the file extension used for shared libraries on this
	/// platform that goes after the dot. Example value is `so`.
	///
	/// Some possible values:
	///
	/// - so
	/// - dylib
	/// - dll
	pub const DLL_EXTENSION: &str = os::DLL_EXTENSION;

	/// Specifies the filename suffix used for executable binaries on this
	/// platform. Example value is `.exe`.
	///
	/// Some possible values:
	///
	/// - .exe
	/// - .nexe
	/// - .pexe
	/// - `""` (an empty string)
	pub const EXE_SUFFIX: &str = os::EXE_SUFFIX;

	/// Specifies the file extension, if any, used for executable binaries
	/// on this platform. Example value is `exe`.
	///
	/// Some possible values:
	///
	/// - exe
	/// - `""` (an empty string)
	pub const EXE_EXTENSION: &str = os::EXE_EXTENSION;
	}

	#[cfg(target_arch = "x86")]
	mod arch {
	pub const ARCH: &str = "x86";
	}

	#[cfg(target_arch = "x86_64")]
	mod arch {
	pub const ARCH: &str = "x86_64";
	}