use cfg_if::cfg_if; use crate::{Error, Result}; /// Clear the environment of all name-value pairs. /// /// On platforms where libc provides `clearenv()`, it will be used. libc's /// `clearenv()` is documented to return an error code but not set errno; if the /// return value indicates a failure, this function will return /// `Error::UnsupportedOperation`. /// /// On platforms where libc does not provide `clearenv()`, a fallback /// implementation will be used that iterates over all environment variables and /// removes them one-by-one. /// /// # Safety /// /// This function is not threadsafe and can cause undefined behavior in /// combination with `std::env` or other program components that access the /// environment. See, for example, the discussion on `std::env::remove_var`; this /// function is a case of an "inherently unsafe non-threadsafe API" dealing with /// the environment. /// /// The caller must ensure no other threads access the process environment while /// this function executes and that no raw pointers to an element of libc's /// `environ` is currently held. The latter is not an issue if the only other /// environment access in the program is via `std::env`, but the requirement on /// thread safety must still be upheld. pub unsafe fn clearenv() -> Result<()> { let ret; cfg_if! { if #[cfg(any(target_os = "fuchsia", target_os = "wasi", target_env = "wasi", target_env = "uclibc", target_os = "linux", target_os = "android", target_os = "emscripten"))] { ret = libc::clearenv(); } else { use std::env; for (name, _) in env::vars_os() { env::remove_var(name); } ret = 0; } } if ret == 0 { Ok(()) } else { Err(Error::UnsupportedOperation) } }