72a25d05bf
This updates the standard library's documentation to use the new syntax. The documentation is worthwhile to update as it should be more idiomatic (particularly for features like this, which are nice for users to get acquainted with). The general codebase is likely more hassle than benefit to update: it'll hurt git blame, and generally updates can be done by folks updating the code if (and when) that makes things more readable with the new format. A few places in the compiler and library code are updated (mostly just due to already having been done when this commit was first authored).
140 lines
3.4 KiB
Rust
140 lines
3.4 KiB
Rust
use fortanix_sgx_abi::{Error, RESULT_SUCCESS};
|
|
|
|
use crate::collections::HashMap;
|
|
use crate::error::Error as StdError;
|
|
use crate::ffi::{OsStr, OsString};
|
|
use crate::fmt;
|
|
use crate::io;
|
|
use crate::marker::PhantomData;
|
|
use crate::path::{self, PathBuf};
|
|
use crate::str;
|
|
use crate::sync::atomic::{AtomicUsize, Ordering};
|
|
use crate::sync::Mutex;
|
|
use crate::sync::Once;
|
|
use crate::sys::{decode_error_kind, sgx_ineffective, unsupported};
|
|
use crate::vec;
|
|
|
|
pub fn errno() -> i32 {
|
|
RESULT_SUCCESS
|
|
}
|
|
|
|
pub fn error_string(errno: i32) -> String {
|
|
if errno == RESULT_SUCCESS {
|
|
"operation successful".into()
|
|
} else if ((Error::UserRangeStart as _)..=(Error::UserRangeEnd as _)).contains(&errno) {
|
|
format!("user-specified error {errno:08x}")
|
|
} else {
|
|
decode_error_kind(errno).as_str().into()
|
|
}
|
|
}
|
|
|
|
pub fn getcwd() -> io::Result<PathBuf> {
|
|
unsupported()
|
|
}
|
|
|
|
pub fn chdir(_: &path::Path) -> io::Result<()> {
|
|
sgx_ineffective(())
|
|
}
|
|
|
|
pub struct SplitPaths<'a>(!, PhantomData<&'a ()>);
|
|
|
|
pub fn split_paths(_unparsed: &OsStr) -> SplitPaths<'_> {
|
|
panic!("unsupported")
|
|
}
|
|
|
|
impl<'a> Iterator for SplitPaths<'a> {
|
|
type Item = PathBuf;
|
|
fn next(&mut self) -> Option<PathBuf> {
|
|
self.0
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct JoinPathsError;
|
|
|
|
pub fn join_paths<I, T>(_paths: I) -> Result<OsString, JoinPathsError>
|
|
where
|
|
I: Iterator<Item = T>,
|
|
T: AsRef<OsStr>,
|
|
{
|
|
Err(JoinPathsError)
|
|
}
|
|
|
|
impl fmt::Display for JoinPathsError {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
"not supported in SGX yet".fmt(f)
|
|
}
|
|
}
|
|
|
|
impl StdError for JoinPathsError {
|
|
#[allow(deprecated)]
|
|
fn description(&self) -> &str {
|
|
"not supported in SGX yet"
|
|
}
|
|
}
|
|
|
|
pub fn current_exe() -> io::Result<PathBuf> {
|
|
unsupported()
|
|
}
|
|
|
|
#[cfg_attr(test, linkage = "available_externally")]
|
|
#[export_name = "_ZN16__rust_internals3std3sys3sgx2os3ENVE"]
|
|
static ENV: AtomicUsize = AtomicUsize::new(0);
|
|
#[cfg_attr(test, linkage = "available_externally")]
|
|
#[export_name = "_ZN16__rust_internals3std3sys3sgx2os8ENV_INITE"]
|
|
static ENV_INIT: Once = Once::new();
|
|
type EnvStore = Mutex<HashMap<OsString, OsString>>;
|
|
|
|
fn get_env_store() -> Option<&'static EnvStore> {
|
|
unsafe { (ENV.load(Ordering::Relaxed) as *const EnvStore).as_ref() }
|
|
}
|
|
|
|
fn create_env_store() -> &'static EnvStore {
|
|
ENV_INIT.call_once(|| {
|
|
ENV.store(Box::into_raw(Box::new(EnvStore::default())) as _, Ordering::Relaxed)
|
|
});
|
|
unsafe { &*(ENV.load(Ordering::Relaxed) as *const EnvStore) }
|
|
}
|
|
|
|
pub type Env = vec::IntoIter<(OsString, OsString)>;
|
|
|
|
pub fn env() -> Env {
|
|
let clone_to_vec = |map: &HashMap<OsString, OsString>| -> Vec<_> {
|
|
map.iter().map(|(k, v)| (k.clone(), v.clone())).collect()
|
|
};
|
|
|
|
get_env_store().map(|env| clone_to_vec(&env.lock().unwrap())).unwrap_or_default().into_iter()
|
|
}
|
|
|
|
pub fn getenv(k: &OsStr) -> Option<OsString> {
|
|
get_env_store().and_then(|s| s.lock().unwrap().get(k).cloned())
|
|
}
|
|
|
|
pub fn setenv(k: &OsStr, v: &OsStr) -> io::Result<()> {
|
|
let (k, v) = (k.to_owned(), v.to_owned());
|
|
create_env_store().lock().unwrap().insert(k, v);
|
|
Ok(())
|
|
}
|
|
|
|
pub fn unsetenv(k: &OsStr) -> io::Result<()> {
|
|
if let Some(env) = get_env_store() {
|
|
env.lock().unwrap().remove(k);
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn temp_dir() -> PathBuf {
|
|
panic!("no filesystem in SGX")
|
|
}
|
|
|
|
pub fn home_dir() -> Option<PathBuf> {
|
|
None
|
|
}
|
|
|
|
pub fn exit(code: i32) -> ! {
|
|
super::abi::exit_with_code(code as _)
|
|
}
|
|
|
|
pub fn getpid() -> u32 {
|
|
panic!("no pids in SGX")
|
|
}
|