From 698f8c2f01ea549d77d7dc3338a12e04c11057b9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Wed, 17 Apr 2024 14:02:58 +0200 Subject: Adding upstream version 1.64.0+dfsg1. Signed-off-by: Daniel Baumann --- vendor/io-lifetimes/src/raw.rs | 253 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 253 insertions(+) create mode 100644 vendor/io-lifetimes/src/raw.rs (limited to 'vendor/io-lifetimes/src/raw.rs') diff --git a/vendor/io-lifetimes/src/raw.rs b/vendor/io-lifetimes/src/raw.rs new file mode 100644 index 000000000..0264f4084 --- /dev/null +++ b/vendor/io-lifetimes/src/raw.rs @@ -0,0 +1,253 @@ +//! Portability abstractions over `Raw*`. +//! +//! On Unix, "everything is a file descriptor". On Windows, file/pipe/process +//! handles are distinct from socket descriptors. This file provides a minimal +//! layer of portability over this difference. + +#[cfg(unix)] +use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; +#[cfg(target_os = "wasi")] +use std::os::wasi::io::{AsRawFd, FromRawFd, IntoRawFd, RawFd}; +#[cfg(windows)] +use std::os::windows::io::{ + AsRawHandle, AsRawSocket, FromRawHandle, FromRawSocket, IntoRawHandle, IntoRawSocket, + RawHandle, RawSocket, +}; + +/// A raw filelike object. +/// +/// This is a portability abstraction over Unix-like [`RawFd`] and +/// Windows' `RawHandle`. +#[cfg(any(unix, target_os = "wasi"))] +pub type RawFilelike = RawFd; + +/// A raw filelike object. +/// +/// This is a portability abstraction over Unix-like `RawFd` and +/// Windows' [`RawHandle`]. +#[cfg(windows)] +pub type RawFilelike = RawHandle; + +/// A raw socketlike object. +/// +/// This is a portability abstraction over Unix-like [`RawFd`] and +/// Windows' `RawSocket`. +#[cfg(any(unix, target_os = "wasi"))] +pub type RawSocketlike = RawFd; + +/// A raw socketlike object. +/// +/// This is a portability abstraction over Unix-like `RawFd` and +/// Windows' [`RawSocket`]. +#[cfg(windows)] +pub type RawSocketlike = RawSocket; + +/// A portable trait to obtain the raw value of an underlying filelike object. +/// +/// This is a portability abstraction over Unix-like [`AsRawFd`] and Windows' +/// `AsRawHandle`. +#[cfg(any(unix, target_os = "wasi"))] +pub trait AsRawFilelike: AsRawFd { + /// Returns the raw value. + fn as_raw_filelike(&self) -> RawFilelike; +} + +#[cfg(any(unix, target_os = "wasi"))] +impl AsRawFilelike for T { + #[inline] + fn as_raw_filelike(&self) -> RawFilelike { + self.as_raw_fd() + } +} + +/// This is a portability abstraction over Unix-like `AsRawFd` and Windows' +/// [`AsRawHandle`]. +#[cfg(windows)] +pub trait AsRawFilelike: AsRawHandle { + /// Returns the raw value. + fn as_raw_filelike(&self) -> RawFilelike; +} + +#[cfg(windows)] +impl AsRawFilelike for T { + #[inline] + fn as_raw_filelike(&self) -> RawFilelike { + self.as_raw_handle() + } +} + +/// This is a portability abstraction over Unix-like [`AsRawFd`] and Windows' +/// `AsRawSocket`. +#[cfg(any(unix, target_os = "wasi"))] +pub trait AsRawSocketlike: AsRawFd { + /// Returns the raw value. + fn as_raw_socketlike(&self) -> RawSocketlike; +} + +#[cfg(any(unix, target_os = "wasi"))] +impl AsRawSocketlike for T { + #[inline] + fn as_raw_socketlike(&self) -> RawSocketlike { + self.as_raw_fd() + } +} + +/// This is a portability abstraction over Unix-like `AsRawFd` and Windows' +/// [`AsRawSocket`]. +#[cfg(windows)] +pub trait AsRawSocketlike: AsRawSocket { + /// Returns the raw value. + fn as_raw_socketlike(&self) -> RawSocketlike; +} + +#[cfg(windows)] +impl AsRawSocketlike for T { + #[inline] + fn as_raw_socketlike(&self) -> RawSocketlike { + self.as_raw_socket() + } +} + +/// This is a portability abstraction over Unix-like [`IntoRawFd`] and Windows' +/// `IntoRawHandle`. +#[cfg(any(unix, target_os = "wasi"))] +pub trait IntoRawFilelike: IntoRawFd { + /// Returns the raw value. + fn into_raw_filelike(self) -> RawFilelike; +} + +#[cfg(any(unix, target_os = "wasi"))] +impl IntoRawFilelike for T { + #[inline] + fn into_raw_filelike(self) -> RawFilelike { + self.into_raw_fd() + } +} + +/// This is a portability abstraction over Unix-like `IntoRawFd` and Windows' +/// [`IntoRawHandle`]. +#[cfg(windows)] +pub trait IntoRawFilelike: IntoRawHandle { + /// Returns the raw value. + fn into_raw_filelike(self) -> RawFilelike; +} + +#[cfg(windows)] +impl IntoRawFilelike for T { + #[inline] + fn into_raw_filelike(self) -> RawFilelike { + self.into_raw_handle() + } +} + +/// This is a portability abstraction over Unix-like [`IntoRawFd`] and Windows' +/// `IntoRawSocket`. +#[cfg(any(unix, target_os = "wasi"))] +pub trait IntoRawSocketlike: IntoRawFd { + /// Returns the raw value. + fn into_raw_socketlike(self) -> RawSocketlike; +} + +#[cfg(any(unix, target_os = "wasi"))] +impl IntoRawSocketlike for T { + #[inline] + fn into_raw_socketlike(self) -> RawSocketlike { + self.into_raw_fd() + } +} + +/// This is a portability abstraction over Unix-like `IntoRawFd` and Windows' +/// [`IntoRawSocket`]. +#[cfg(windows)] +pub trait IntoRawSocketlike: IntoRawSocket { + /// Returns the raw value. + fn into_raw_socketlike(self) -> RawSocketlike; +} + +#[cfg(windows)] +impl IntoRawSocketlike for T { + #[inline] + fn into_raw_socketlike(self) -> RawSocketlike { + self.into_raw_socket() + } +} + +/// This is a portability abstraction over Unix-like [`FromRawFd`] and Windows' +/// `FromRawHandle`. +#[cfg(any(unix, target_os = "wasi"))] +pub trait FromRawFilelike: FromRawFd { + /// Constructs `Self` from the raw value. + /// + /// # Safety + /// + /// This is `unsafe` for the same reason as [`from_raw_fd`] and + /// [`from_raw_handle`]. + /// + /// [`from_raw_fd`]: https://doc.rust-lang.org/stable/std/os/unix/io/trait.FromRawFd.html#tymethod.from_raw_fd + /// [`from_raw_handle`]: https://doc.rust-lang.org/stable/std/os/windows/io/trait.FromRawHandle.html#tymethod.from_raw_handle + unsafe fn from_raw_filelike(raw: RawFilelike) -> Self; +} + +#[cfg(any(unix, target_os = "wasi"))] +impl FromRawFilelike for T { + #[inline] + unsafe fn from_raw_filelike(raw: RawFilelike) -> Self { + Self::from_raw_fd(raw) + } +} + +/// This is a portability abstraction over Unix-like `FromRawFd` and Windows' +/// [`FromRawHandle`]. +#[cfg(windows)] +pub trait FromRawFilelike: FromRawHandle { + /// Constructs `Self` from the raw value. + unsafe fn from_raw_filelike(raw: RawFilelike) -> Self; +} + +#[cfg(windows)] +impl FromRawFilelike for T { + #[inline] + unsafe fn from_raw_filelike(raw: RawFilelike) -> Self { + Self::from_raw_handle(raw) + } +} + +/// This is a portability abstraction over Unix-like [`FromRawFd`] and Windows' +/// `FromRawSocket`. +#[cfg(any(unix, target_os = "wasi"))] +pub trait FromRawSocketlike: FromRawFd { + /// Constructs `Self` from the raw value. + /// + /// # Safety + /// + /// This is `unsafe` for the same reason as [`from_raw_fd`] and + /// [`from_raw_socket`]. + /// + /// [`from_raw_fd`]: https://doc.rust-lang.org/stable/std/os/unix/io/trait.FromRawFd.html#tymethod.from_raw_fd + /// [`from_raw_socket`]: https://doc.rust-lang.org/stable/std/os/windows/io/trait.FromRawSocket.html#tymethod.from_raw_socket + unsafe fn from_raw_socketlike(raw: RawSocketlike) -> Self; +} + +#[cfg(any(unix, target_os = "wasi"))] +impl FromRawSocketlike for T { + #[inline] + unsafe fn from_raw_socketlike(raw: RawSocketlike) -> Self { + Self::from_raw_fd(raw) + } +} + +/// This is a portability abstraction over Unix-like `FromRawFd` and Windows' +/// [`FromRawSocket`]. +#[cfg(windows)] +pub trait FromRawSocketlike: FromRawSocket { + /// Constructs `Self` from the raw value. + unsafe fn from_raw_socketlike(raw: RawSocketlike) -> Self; +} + +#[cfg(windows)] +impl FromRawSocketlike for T { + #[inline] + unsafe fn from_raw_socketlike(raw: RawSocketlike) -> Self { + Self::from_raw_socket(raw) + } +} -- cgit v1.2.3