672ea93652
The `library/std/src/sys_common/net.rs` module is intended to define common implementations of networking-related APIs across a variety of platforms that share similar APIs (e.g. Berkeley-style sockets and all). This module is not included for more fringe targets however such as UEFI or "unknown" targets to libstd (those classified as `restricted-std`). Previously the `sys_common/net.rs` file was set up such that an allow-list indicated it shouldn't be used. This commit inverts the logic to have an allow-list of when it should be used instead. The goal of this commit is to make it a bit easier to experiment with a new Rust target. Currently more esoteric targets are required to get an exception in this `cfg_if` block to use `crate::sys::net` such as for unsupported targets. With this inversion of logic only targets which actually support networking will be listed, where most of those are lumped under `cfg(unix)`. Given that this change is likely to cause some breakage for some target by accident I've attempted to be somewhat robust with this by following these steps to defining the new predicate for inverted logic. 1. Take all supported targets and filter out all `cfg(unix)` ones as these should all support `sys_common/net.rs`. 2. Take remaining targets and filter out `cfg(windows)` ones. 3. The remaining dozen-or-so targets were all audited by hand. Mostly this included `target_os = "hermit"` and `target_os = "solid_asp3"` which required an allow-list entry, but remaining targets were all already excluded (didn't use `sys_common/net.rs` so they were left out. If this causes breakage it should be relatively easy to fix and I'd be happy to follow-up with any PRs necessary.
96 lines
2.7 KiB
Rust
96 lines
2.7 KiB
Rust
//! Platform-independent platform abstraction
|
|
//!
|
|
//! This is the platform-independent portion of the standard library's
|
|
//! platform abstraction layer, whereas `std::sys` is the
|
|
//! platform-specific portion.
|
|
//!
|
|
//! The relationship between `std::sys_common`, `std::sys` and the
|
|
//! rest of `std` is complex, with dependencies going in all
|
|
//! directions: `std` depending on `sys_common`, `sys_common`
|
|
//! depending on `sys`, and `sys` depending on `sys_common` and `std`.
|
|
//! This is because `sys_common` not only contains platform-independent code,
|
|
//! but also code that is shared between the different platforms in `sys`.
|
|
//! Ideally all that shared code should be moved to `sys::common`,
|
|
//! and the dependencies between `std`, `sys_common` and `sys` all would form a dag.
|
|
//! Progress on this is tracked in #84187.
|
|
|
|
#![allow(missing_docs)]
|
|
#![allow(missing_debug_implementations)]
|
|
|
|
#[cfg(test)]
|
|
mod tests;
|
|
|
|
pub mod backtrace;
|
|
pub mod fs;
|
|
pub mod io;
|
|
pub mod lazy_box;
|
|
pub mod memchr;
|
|
pub mod once;
|
|
pub mod process;
|
|
pub mod thread;
|
|
pub mod thread_info;
|
|
pub mod thread_local_dtor;
|
|
pub mod thread_parking;
|
|
pub mod wstr;
|
|
pub mod wtf8;
|
|
|
|
cfg_if::cfg_if! {
|
|
if #[cfg(target_os = "windows")] {
|
|
pub use crate::sys::thread_local_key;
|
|
} else {
|
|
pub mod thread_local_key;
|
|
}
|
|
}
|
|
|
|
cfg_if::cfg_if! {
|
|
if #[cfg(any(
|
|
all(unix, not(target_os = "l4re")),
|
|
windows,
|
|
target_os = "hermit",
|
|
target_os = "solid_asp3"
|
|
))] {
|
|
pub mod net;
|
|
} else {
|
|
pub use crate::sys::net;
|
|
}
|
|
}
|
|
|
|
// common error constructors
|
|
|
|
/// A trait for viewing representations from std types
|
|
#[doc(hidden)]
|
|
pub trait AsInner<Inner: ?Sized> {
|
|
fn as_inner(&self) -> &Inner;
|
|
}
|
|
|
|
/// A trait for viewing representations from std types
|
|
#[doc(hidden)]
|
|
pub trait AsInnerMut<Inner: ?Sized> {
|
|
fn as_inner_mut(&mut self) -> &mut Inner;
|
|
}
|
|
|
|
/// A trait for extracting representations from std types
|
|
#[doc(hidden)]
|
|
pub trait IntoInner<Inner> {
|
|
fn into_inner(self) -> Inner;
|
|
}
|
|
|
|
/// A trait for creating std types from internal representations
|
|
#[doc(hidden)]
|
|
pub trait FromInner<Inner> {
|
|
fn from_inner(inner: Inner) -> Self;
|
|
}
|
|
|
|
// Computes (value*numer)/denom without overflow, as long as both
|
|
// (numer*denom) and the overall result fit into i64 (which is the case
|
|
// for our time conversions).
|
|
#[allow(dead_code)] // not used on all platforms
|
|
pub fn mul_div_u64(value: u64, numer: u64, denom: u64) -> u64 {
|
|
let q = value / denom;
|
|
let r = value % denom;
|
|
// Decompose value as (value/denom*denom + value%denom),
|
|
// substitute into (value*numer)/denom and simplify.
|
|
// r < denom, so (denom*numer) is the upper bound of (r*numer)
|
|
q * numer + r * numer / denom
|
|
}
|