1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88
//! `rsix` provides efficient memory-safe and [I/O-safe] wrappers to //! POSIX-like, Unix-like, and Linux syscalls. //! //! The wrappers perform the following tasks: //! - Error values are translated to [`Result`]s. //! - Buffers are passed as Rust slices. //! - Out-parameters are presented as return values. //! - Path arguments use [`Arg`], so they accept any string type. //! - File descriptors are passed and returned via [`AsFd`] and [`OwnedFd`] //! instead of bare integers, ensuring I/O safety. //! - Constants use `enum`s and [`bitflags`] types. //! - Multiplexed functions (eg. `fcntl`, `ioctl`, etc.) are de-multiplexed. //! - Variadic functions (eg. `openat`, etc.) are presented as non-variadic. //! - Functions and types which need `l` prefixes or `64` suffixes to enable //! large-file support are used automatically, and file sizes and offsets //! are presented as `i64` and `u64`. //! - Behaviors that depend on the sizes of C types like `long` are hidden. //! - In some places, more human-friendly and less historical-accident names //! are used. //! //! Things they don't do include: //! - Detecting whether functions are supported at runtime. //! - Hiding significant differences between platforms. //! - Restricting ambient authorities. //! - Imposing sandboxing features such as filesystem path or network address //! sandboxing. //! //! See [`cap-std`], [`system-interface`], and [`io-streams`] for libraries //! which do hide significant differences between platforms, and [`cap-std`] //! which does perform sandboxing and restricts ambient authorities. //! //! [`cap-std`]: https://crates.io/crates/cap-std //! [`system-interface`]: https://crates.io/crates/system-interface //! [`io-streams`]: https://crates.io/crates/io-streams //! [`std`]: https://doc.rust-lang.org/std/ //! [`getrandom`]: https://crates.io/crates/getrandom //! [`bitflags`]: https://crates.io/crates/bitflags //! [`AsFd`]: https://docs.rs/io-lifetimes/latest/io_lifetimes/trait.AsFd.html //! [`OwnedFd`]: https://docs.rs/io-lifetimes/latest/io_lifetimes/struct.OwnedFd.html //! [io-lifetimes crate]: https://crates.io/crates/io-lifetimes //! [I/O-safe]: https://github.com/rust-lang/rfcs/pull/3128 //! [`Result`]: https://docs.rs/rsix/latest/rsix/io/type.Result.html //! [`Arg`]: https://docs.rs/rsix/latest/rsix/path/trait.Arg.html #![deny(missing_docs)] #![cfg_attr(linux_raw, deny(unsafe_code))] #![cfg_attr(linux_raw_inline_asm, feature(asm))] #![cfg_attr(const_fn_union, feature(const_fn_union))] #![cfg_attr(rustc_attrs, feature(rustc_attrs))] #![cfg_attr(target_os = "wasi", feature(wasi_ext))] #![cfg_attr( all(linux_raw_inline_asm, target_arch = "x86"), feature(naked_functions) )] /// Re-export `io_lifetimes` since we use its types in our public API, so /// that our users don't need to do anything special to use the same version. pub use io_lifetimes; #[macro_use] pub(crate) mod cstr; #[macro_use] pub(crate) mod const_assert; mod imp; pub mod fs; pub mod io; #[cfg(not(any(target_os = "redox", target_os = "wasi")))] // WASI doesn't support `net` yet. pub mod net; pub mod path; pub mod process; pub mod rand; pub mod time; /// Convert a `&T` into a `*const T` without using an `as`. #[inline] #[allow(dead_code)] const fn as_ptr<T>(t: &T) -> *const T { t } /// Convert a `&mut T` into a `*mut T` without using an `as`. #[inline] #[allow(dead_code)] fn as_mut_ptr<T>(t: &mut T) -> *mut T { t }