html-to-markdown 2.24.4 → 2.24.6

data/rust-vendor/getrandom/src/backends/wasi_p2_3.rs

@@ -0,0 +1,61 @@
+//! Implementation for WASIp2 and WASIp3.
+use crate::Error;
+use core::{mem::MaybeUninit, ptr::copy_nonoverlapping};
+
+#[cfg(target_env = "p2")]
+use wasip2 as wasi;
+
+// Workaround to silence `unexpected_cfgs` warning
+// on Rust version between 1.85 and 1.91
+#[cfg(not(target_env = "p2"))]
+#[cfg(target_env = "p3")]
+use wasip3 as wasi;
+
+#[cfg(not(target_env = "p2"))]
+#[cfg(not(target_env = "p3"))]
+compile_error!("Unknown version of WASI (only previews 1, 2 and 3 are supported)");
+
+use wasi::random::random::get_random_u64;
+
+#[inline]
+pub fn inner_u32() -> Result<u32, Error> {
+    let val = get_random_u64();
+    Ok(crate::util::truncate(val))
+}
+
+#[inline]
+pub fn inner_u64() -> Result<u64, Error> {
+    Ok(get_random_u64())
+}
+
+#[inline]
+pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
+    let (prefix, chunks, suffix) = unsafe { dest.align_to_mut::<MaybeUninit<u64>>() };
+
+    // We use `get_random_u64` instead of `get_random_bytes` because the latter creates
+    // an allocation due to the Wit IDL [restrictions][0]. This should be fine since
+    // the main use case of `getrandom` is seed generation.
+    //
+    // [0]: https://github.com/WebAssembly/wasi-random/issues/27
+    if !prefix.is_empty() {
+        let val = get_random_u64();
+        let src = (&val as *const u64).cast();
+        unsafe {
+            copy_nonoverlapping(src, prefix.as_mut_ptr(), prefix.len());
+        }
+    }
+
+    for dst in chunks {
+        dst.write(get_random_u64());
+    }
+
+    if !suffix.is_empty() {
+        let val = get_random_u64();
+        let src = (&val as *const u64).cast();
+        unsafe {
+            copy_nonoverlapping(src, suffix.as_mut_ptr(), suffix.len());
+        }
+    }
+
+    Ok(())
+}

data/rust-vendor/getrandom/src/backends/wasm_js.rs

@@ -56,7 +56,7 @@ pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
 }
 
 #[wasm_bindgen]
-extern "C" {
+unsafe extern "C" {
     // Crypto.getRandomValues()
     #[cfg(not(target_feature = "atomics"))]
     #[wasm_bindgen(js_namespace = ["globalThis", "crypto"], js_name = getRandomValues, catch)]

data/rust-vendor/getrandom/src/backends/windows.rs

@@ -26,9 +26,7 @@ use core::mem::MaybeUninit;
 pub use crate::util::{inner_u32, inner_u64};
 
 // Binding to the Windows.Win32.Security.Cryptography.ProcessPrng API. As
-// bcryptprimitives.dll lacks an import library, we use "raw-dylib". This
-// was added in Rust 1.65 for x86_64/aarch64 and in Rust 1.71 for x86.
-// We don't need MSRV 1.71, as we only use this backend on Rust 1.78 and later.
+// bcryptprimitives.dll lacks an import library, we use "raw-dylib".
 #[cfg_attr(
     target_arch = "x86",
     link(
@@ -41,21 +39,19 @@ pub use crate::util::{inner_u32, inner_u64};
     not(target_arch = "x86"),
     link(name = "bcryptprimitives", kind = "raw-dylib")
 )]
-extern "system" {
+unsafe extern "system" {
     fn ProcessPrng(pbdata: *mut u8, cbdata: usize) -> BOOL;
 }
-#[allow(clippy::upper_case_acronyms, clippy::incompatible_msrv)]
-type BOOL = core::ffi::c_int; // MSRV 1.64, similarly OK for this backend.
+#[expect(clippy::upper_case_acronyms)]
+type BOOL = core::ffi::c_int;
 const TRUE: BOOL = 1;
 
 #[inline]
 pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
     let result = unsafe { ProcessPrng(dest.as_mut_ptr().cast::<u8>(), dest.len()) };
-    // Since Windows 10, calls to the user-mode RNG are guaranteed to never
-    // fail during runtime (rare windows W); `ProcessPrng` will only ever
-    // return 1 (which is how windows represents TRUE).
-    // See the bottom of page 6 of the aforementioned Windows RNG
-    // whitepaper for more information.
+    // `ProcessPrng` is documented to always return TRUE. All potential errors are handled
+    // during loading of `BCryptPrimitive.dll`. See the "Process base PRNG" section
+    // in the aforementioned Windows RNG whitepaper for more information.
     debug_assert!(result == TRUE);
     Ok(())
 }

data/rust-vendor/getrandom/src/backends/windows_legacy.rs

@@ -20,7 +20,7 @@ compile_error!("`windows_legacy` backend can be enabled only for Windows targets
 // Binding to the Windows.Win32.Security.Authentication.Identity.RtlGenRandom
 // API. Don't use windows-targets as it doesn't support Windows 7 targets.
 #[link(name = "advapi32")]
-extern "system" {
+unsafe extern "system" {
     #[link_name = "SystemFunction036"]
     fn RtlGenRandom(randombuffer: *mut c_void, randombufferlength: u32) -> BOOLEAN;
 }

data/rust-vendor/getrandom/src/backends.rs

@@ -13,11 +13,9 @@ cfg_if! {
         pub use custom::*;
     } else if #[cfg(getrandom_backend = "linux_getrandom")] {
         mod getrandom;
-        mod sanitizer;
         pub use getrandom::*;
     } else if #[cfg(getrandom_backend = "linux_raw")] {
         mod linux_raw;
-        mod sanitizer;
         pub use linux_raw::*;
     } else if #[cfg(getrandom_backend = "rdrand")] {
         mod rdrand;
@@ -31,25 +29,14 @@ cfg_if! {
     } else if #[cfg(getrandom_backend = "windows_legacy")] {
         mod windows_legacy;
         pub use windows_legacy::*;
-    } else if #[cfg(getrandom_backend = "wasm_js")] {
-        cfg_if! {
-            if #[cfg(feature = "wasm_js")] {
-                mod wasm_js;
-                pub use wasm_js::*;
-            } else {
-                compile_error!(concat!(
-                    "The \"wasm_js\" backend requires the `wasm_js` feature \
-                    for `getrandom`. For more information see: \
-                    https://docs.rs/getrandom/", env!("CARGO_PKG_VERSION"), "/#webassembly-support"
-                ));
-            }
-        }
     } else if #[cfg(getrandom_backend = "unsupported")] {
         mod unsupported;
         pub use unsupported::*;
+    } else if #[cfg(getrandom_backend = "extern_impl")] {
+        pub(crate) mod extern_impl;
+        pub use extern_impl::*;
     } else if #[cfg(all(target_os = "linux", target_env = ""))] {
         mod linux_raw;
-        mod sanitizer;
         pub use linux_raw::*;
     } else if #[cfg(target_os = "espidf")] {
         mod esp_idf;
@@ -117,7 +104,6 @@ cfg_if! {
     ))] {
         mod use_file;
         mod linux_android_with_fallback;
-        mod sanitizer;
         pub use linux_android_with_fallback::*;
     } else if #[cfg(any(
         target_os = "android",
@@ -132,8 +118,6 @@ cfg_if! {
         all(target_os = "horizon", target_arch = "arm"),
     ))] {
         mod getrandom;
-        #[cfg(any(target_os = "android", target_os = "linux"))]
-        mod sanitizer;
         pub use getrandom::*;
     } else if #[cfg(target_os = "solaris")] {
         mod solaris;
@@ -157,19 +141,17 @@ cfg_if! {
             if #[cfg(target_env = "p1")] {
                 mod wasi_p1;
                 pub use wasi_p1::*;
-            } else if #[cfg(target_env = "p2")] {
-                mod wasi_p2;
-                pub use wasi_p2::*;
             } else {
-                compile_error!(
-                    "Unknown version of WASI (only previews 1 and 2 are supported) \
-                    or Rust version older than 1.80 was used"
-                );
+                mod wasi_p2_3;
+                pub use wasi_p2_3::*;
             }
         }
     } else if #[cfg(target_os = "hermit")] {
         mod hermit;
         pub use hermit::*;
+    } else if #[cfg(all(target_arch = "x86_64", target_os = "motor"))] {
+        mod rdrand;
+        pub use rdrand::*;
     } else if #[cfg(target_os = "vxworks")] {
         mod vxworks;
         pub use vxworks::*;
@@ -193,8 +175,7 @@ cfg_if! {
             } else {
                 compile_error!(concat!(
                     "The wasm32-unknown-unknown targets are not supported by default; \
-                    you may need to enable the \"wasm_js\" configuration flag. Note \
-                    that enabling the `wasm_js` feature flag alone is insufficient. \
+                    you may need to enable the \"wasm_js\" crate feature. \
                     For more information see: \
                     https://docs.rs/getrandom/", env!("CARGO_PKG_VERSION"), "/#webassembly-support"
                 ));

data/rust-vendor/getrandom/src/error.rs

@@ -3,17 +3,26 @@ extern crate std;
 
 use core::fmt;
 
-// This private alias mirrors `std::io::RawOsError`:
-// https://doc.rust-lang.org/std/io/type.RawOsError.html)
 cfg_if::cfg_if!(
     if #[cfg(target_os = "uefi")] {
         // See the UEFI spec for more information:
         // https://uefi.org/specs/UEFI/2.10/Apx_D_Status_Codes.html
-        type RawOsError = usize;
+
+        /// Raw error code.
+        ///
+        /// This alias mirrors unstable [`std::io::RawOsError`].
+        ///
+        /// [`std::io::RawOsError`]: https://doc.rust-lang.org/std/io/type.RawOsError.html
+        pub type RawOsError = usize;
         type NonZeroRawOsError = core::num::NonZeroUsize;
         const UEFI_ERROR_FLAG: RawOsError = 1 << (RawOsError::BITS - 1);
     } else {
-        type RawOsError = i32;
+        /// Raw error code.
+        ///
+        /// This alias mirrors unstable [`std::io::RawOsError`].
+        ///
+        /// [`std::io::RawOsError`]: https://doc.rust-lang.org/std/io/type.RawOsError.html
+        pub type RawOsError = i32;
         type NonZeroRawOsError = core::num::NonZeroI32;
     }
 );
@@ -48,7 +57,25 @@ impl Error {
     /// Custom errors can be in the range of 2^17..(2^17 + 2^16)
     const CUSTOM_START: RawOsError = 1 << 17;
 
-    /// Creates a new instance of an `Error` from a negative error code.
+    /// Creates a new `Error` instance from a positive error code.
+    ///
+    /// Returns [`Error::ERRNO_NOT_POSITIVE`] for zero and negative error codes.
+    #[cfg(not(target_os = "uefi"))]
+    #[allow(dead_code)]
+    pub(super) fn from_errno(errno: i32) -> Self {
+        if errno > 0 {
+            let code = errno
+                .checked_neg()
+                .expect("Positive number can be always negated");
+            Error::from_neg_error_code(code)
+        } else {
+            Error::ERRNO_NOT_POSITIVE
+        }
+    }
+
+    /// Creates a new `Error` instance from a negative error code.
+    ///
+    /// Returns [`Error::UNEXPECTED`] for zero and positive error codes.
     #[cfg(not(target_os = "uefi"))]
     #[allow(dead_code)]
     pub(super) fn from_neg_error_code(code: RawOsError) -> Self {
@@ -150,7 +177,11 @@ impl Error {
             Error::IOS_RANDOM_GEN => "SecRandomCopyBytes: iOS Security framework failure",
             #[cfg(all(windows, target_vendor = "win7"))]
             Error::WINDOWS_RTL_GEN_RANDOM => "RtlGenRandom: Windows system function failure",
-            #[cfg(all(feature = "wasm_js", getrandom_backend = "wasm_js"))]
+            #[cfg(all(
+                feature = "wasm_js",
+                target_arch = "wasm32",
+                any(target_os = "unknown", target_os = "none")
+            ))]
             Error::WEB_CRYPTO => "Web Crypto API is unavailable",
             #[cfg(target_os = "vxworks")]
             Error::VXWORKS_RAND_SECURE => "randSecure: VxWorks RNG module is not initialized",
@@ -176,6 +207,8 @@ impl Error {
     }
 }
 
+impl core::error::Error for Error {}
+
 impl fmt::Debug for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let mut dbg = f.debug_struct("Error");

data/rust-vendor/getrandom/src/error_std_impls.rs

@@ -7,9 +7,7 @@ impl From<Error> for io::Error {
     fn from(err: Error) -> Self {
         match err.raw_os_error() {
             Some(errno) => io::Error::from_raw_os_error(errno),
-            None => io::Error::new(io::ErrorKind::Other, err),
+            None => io::Error::other(err),
         }
     }
 }
-
-impl std::error::Error for Error {}

data/rust-vendor/getrandom/src/lib.rs

@@ -8,24 +8,9 @@
     html_favicon_url = "https://www.rust-lang.org/favicon.ico"
 )]
 #![doc = include_str!("../README.md")]
-#![warn(rust_2018_idioms, unused_lifetimes, missing_docs)]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 #![cfg_attr(getrandom_backend = "efi_rng", feature(uefi_std))]
-#![deny(
-    clippy::cast_lossless,
-    clippy::cast_possible_truncation,
-    clippy::cast_possible_wrap,
-    clippy::cast_precision_loss,
-    clippy::cast_ptr_alignment,
-    clippy::cast_sign_loss,
-    clippy::char_lit_as_u8,
-    clippy::checked_conversions,
-    clippy::fn_to_numeric_cast,
-    clippy::fn_to_numeric_cast_with_truncation,
-    clippy::ptr_as_ptr,
-    clippy::unnecessary_cast,
-    clippy::useless_conversion
-)]
+#![cfg_attr(getrandom_backend = "extern_impl", feature(extern_item_impls))]
 
 #[macro_use]
 extern crate cfg_if;
@@ -39,7 +24,43 @@ mod util;
 #[cfg(feature = "std")]
 mod error_std_impls;
 
-pub use crate::error::Error;
+/// `rand_core` adapter
+#[cfg(feature = "sys_rng")]
+mod sys_rng;
+
+#[cfg(feature = "sys_rng")]
+pub use rand_core;
+#[cfg(feature = "sys_rng")]
+pub use sys_rng::SysRng;
+
+pub use crate::error::{Error, RawOsError};
+
+/// Attribute macros for overwriting the core functionality of this crate.
+///
+/// This allows `getrandom` to provide a default implementation and a common interface
+/// for all crates to use, while giving users a safe way to override that default where required.
+///
+/// Must be enabled via the `extern_impl` opt-in backend, as this functionality
+/// is currently limited to nightly.
+///
+/// # Examples
+///
+/// ```rust
+/// # use core::mem::MaybeUninit;
+/// # #[cfg(getrandom_backend = "extern_impl")]
+/// #[getrandom::implementation::fill_uninit]
+/// fn my_fill_uninit_implementation(
+///     dest: &mut [MaybeUninit<u8>]
+/// ) -> Result<(), getrandom::Error> {
+///     // ...
+/// #   let _ = dest;
+/// #   Err(Error::UNSUPPORTED)
+/// }
+/// ```
+#[cfg(getrandom_backend = "extern_impl")]
+pub mod implementation {
+    pub use crate::backends::extern_impl::{fill_uninit, u32, u64};
+}
 
 /// Fill `dest` with random bytes from the system's preferred random number source.
 ///
@@ -100,7 +121,7 @@ pub fn fill_uninit(dest: &mut [MaybeUninit<u8>]) -> Result<&mut [u8], Error> {
     }
 
     #[cfg(getrandom_msan)]
-    extern "C" {
+    unsafe extern "C" {
         fn __msan_unpoison(a: *mut core::ffi::c_void, size: usize);
     }
 

data/rust-vendor/getrandom/src/sys_rng.rs

@@ -0,0 +1,55 @@
+use crate::Error;
+use rand_core::{TryCryptoRng, TryRng};
+
+/// A [`TryRng`] interface over the system's preferred random number source
+///
+/// This is a zero-sized struct. It can be freely constructed with just `SysRng`.
+///
+/// This struct is also available as [`rand::rngs::SysRng`] when using [rand].
+///
+/// # Usage example
+///
+/// `SysRng` implements [`TryRng`]:
+/// ```
+/// use getrandom::{rand_core::TryRng, SysRng};
+///
+/// let mut key = [0u8; 32];
+/// SysRng.try_fill_bytes(&mut key).unwrap();
+/// ```
+///
+/// Using it as an [`Rng`] is possible using [`UnwrapErr`]:
+/// ```
+/// use getrandom::rand_core::{Rng, UnwrapErr};
+/// use getrandom::SysRng;
+///
+/// let mut rng = UnwrapErr(SysRng);
+/// let random_u64 = rng.next_u64();
+/// ```
+///
+/// [rand]: https://crates.io/crates/rand
+/// [`rand::rngs::SysRng`]: https://docs.rs/rand/latest/rand/rngs/struct.SysRng.html
+/// [`Rng`]: rand_core::Rng
+/// [`UnwrapErr`]: rand_core::UnwrapErr
+#[derive(Clone, Copy, Debug, Default)]
+pub struct SysRng;
+
+impl TryRng for SysRng {
+    type Error = Error;
+
+    #[inline]
+    fn try_next_u32(&mut self) -> Result<u32, Error> {
+        crate::u32()
+    }
+
+    #[inline]
+    fn try_next_u64(&mut self) -> Result<u64, Error> {
+        crate::u64()
+    }
+
+    #[inline]
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
+        crate::fill(dest)
+    }
+}
+
+impl TryCryptoRng for SysRng {}

data/rust-vendor/getrandom/src/util.rs

@@ -6,9 +6,8 @@ use core::{mem::MaybeUninit, ptr, slice};
 /// `MaybeUninit::slice_assume_init_mut`. Every element of `slice` must have
 /// been initialized.
 #[inline(always)]
-#[allow(unused_unsafe)] // TODO(MSRV 1.65): Remove this.
 pub unsafe fn slice_assume_init_mut<T>(slice: &mut [MaybeUninit<T>]) -> &mut [T] {
-    let ptr = ptr_from_mut::<[MaybeUninit<T>]>(slice) as *mut [T];
+    let ptr = ptr::from_mut(slice) as *mut [T];
     // SAFETY: `MaybeUninit<T>` is guaranteed to be layout-compatible with `T`.
     unsafe { &mut *ptr }
 }
@@ -21,7 +20,7 @@ pub fn uninit_slice_fill_zero(slice: &mut [MaybeUninit<u8>]) -> &mut [u8] {
 
 #[inline(always)]
 pub fn slice_as_uninit<T>(slice: &[T]) -> &[MaybeUninit<T>] {
-    let ptr = ptr_from_ref::<[T]>(slice) as *const [MaybeUninit<T>];
+    let ptr = ptr::from_ref(slice) as *const [MaybeUninit<T>];
     // SAFETY: `MaybeUninit<T>` is guaranteed to be layout-compatible with `T`.
     unsafe { &*ptr }
 }
@@ -31,23 +30,12 @@ pub fn slice_as_uninit<T>(slice: &[T]) -> &[MaybeUninit<T>] {
 /// This is unsafe because it allows assigning uninitialized values into
 /// `slice`, which would be undefined behavior.
 #[inline(always)]
-#[allow(unused_unsafe)] // TODO(MSRV 1.65): Remove this.
 pub unsafe fn slice_as_uninit_mut<T>(slice: &mut [T]) -> &mut [MaybeUninit<T>] {
-    let ptr = ptr_from_mut::<[T]>(slice) as *mut [MaybeUninit<T>];
+    let ptr = ptr::from_mut(slice) as *mut [MaybeUninit<T>];
     // SAFETY: `MaybeUninit<T>` is guaranteed to be layout-compatible with `T`.
     unsafe { &mut *ptr }
 }
 
-// TODO: MSRV(1.76.0): Replace with `core::ptr::from_mut`.
-fn ptr_from_mut<T: ?Sized>(r: &mut T) -> *mut T {
-    r
-}
-
-// TODO: MSRV(1.76.0): Replace with `core::ptr::from_ref`.
-fn ptr_from_ref<T: ?Sized>(r: &T) -> *const T {
-    r
-}
-
 /// Default implementation of `inner_u32` on top of `fill_uninit`
 #[inline]
 pub fn inner_u32() -> Result<u32, Error> {

data/rust-vendor/getrandom/src/utils/get_errno.rs

@@ -0,0 +1,29 @@
+cfg_if! {
+    if #[cfg(any(target_os = "netbsd", target_os = "openbsd", target_os = "android", target_os = "cygwin"))] {
+        use libc::__errno as errno_location;
+    } else if #[cfg(any(target_os = "linux", target_os = "emscripten", target_os = "hurd", target_os = "redox", target_os = "dragonfly"))] {
+        use libc::__errno_location as errno_location;
+    } else if #[cfg(target_os = "illumos")] {
+        use libc::___errno as errno_location;
+    } else if #[cfg(any(target_os = "macos", target_os = "freebsd"))] {
+        use libc::__error as errno_location;
+    } else if #[cfg(target_os = "haiku")] {
+        use libc::_errnop as errno_location;
+    } else if #[cfg(target_os = "nto")] {
+        use libc::__get_errno_ptr as errno_location;
+    } else if #[cfg(any(all(target_os = "horizon", target_arch = "arm"), target_os = "vita"))] {
+        unsafe extern "C" {
+            // Not provided by libc: https://github.com/rust-lang/libc/issues/1995
+            fn __errno() -> *mut libc::c_int;
+        }
+        use __errno as errno_location;
+    } else if #[cfg(target_os = "aix")] {
+        use libc::_Errno as errno_location;
+    } else {
+        compile_error!("errno_location is not provided for the target");
+    }
+}
+
+pub(crate) fn get_errno() -> libc::c_int {
+    unsafe { core::ptr::read(errno_location()) }
+}

data/rust-vendor/getrandom/src/utils/lazy.rs

@@ -0,0 +1,64 @@
+//! Helpers built around pointer-sized atomics.
+use core::sync::atomic::{AtomicUsize, Ordering};
+
+// This structure represents a lazily initialized static usize value. Useful
+// when it is preferable to just rerun initialization instead of locking.
+// unsync_init will invoke an init() function until it succeeds, then return the
+// cached value for future calls.
+//
+// unsync_init supports init() "failing". If the init() method returns UNINIT,
+// that value will be returned as normal, but will not be cached.
+//
+// Users should only depend on the _value_ returned by init() functions.
+// Specifically, for the following init() function:
+//      fn init() -> usize {
+//          a();
+//          let v = b();
+//          c();
+//          v
+//      }
+// the effects of c() or writes to shared memory will not necessarily be
+// observed and additional synchronization methods may be needed.
+struct LazyUsize(AtomicUsize);
+
+impl LazyUsize {
+    // The initialization is not completed.
+    const UNINIT: usize = usize::MAX;
+
+    const fn new() -> Self {
+        Self(AtomicUsize::new(Self::UNINIT))
+    }
+
+    // Runs the init() function at most once, returning the value of some run of
+    // init(). Multiple callers can run their init() functions in parallel.
+    // init() should always return the same value, if it succeeds.
+    fn unsync_init(&self, init: impl FnOnce() -> usize) -> usize {
+        #[cold]
+        fn do_init(this: &LazyUsize, init: impl FnOnce() -> usize) -> usize {
+            let val = init();
+            this.0.store(val, Ordering::Relaxed);
+            val
+        }
+
+        // Relaxed ordering is fine, as we only have a single atomic variable.
+        let val = self.0.load(Ordering::Relaxed);
+        if val != Self::UNINIT {
+            val
+        } else {
+            do_init(self, init)
+        }
+    }
+}
+
+// Identical to LazyUsize except with bool instead of usize.
+pub(crate) struct LazyBool(LazyUsize);
+
+impl LazyBool {
+    pub const fn new() -> Self {
+        Self(LazyUsize::new())
+    }
+
+    pub fn unsync_init(&self, init: impl FnOnce() -> bool) -> bool {
+        self.0.unsync_init(|| usize::from(init())) != 0
+    }
+}

data/rust-vendor/getrandom/src/utils/sanitizer.rs

@@ -0,0 +1,28 @@
+use core::mem::MaybeUninit;
+
+/// Unpoisons `buf` if MSAN support is enabled.
+///
+/// Most backends do not need to unpoison their output. Rust language- and
+/// library- provided functionality unpoisons automatically. Similarly, libc
+/// either natively supports MSAN and/or MSAN hooks libc-provided functions
+/// to unpoison outputs on success. Only when all of these things are
+/// bypassed do we need to do it ourselves.
+///
+/// The call to unpoison should be done as close to the write as possible.
+/// For example, if the backend partially fills the output buffer in chunks,
+/// each chunk should be unpoisoned individually. This way, the correctness of
+/// the chunking logic can be validated (in part) using MSAN.
+pub unsafe fn unpoison(buf: &mut [MaybeUninit<u8>]) {
+    cfg_if! {
+        if #[cfg(getrandom_msan)] {
+            unsafe extern "C" {
+                fn __msan_unpoison(a: *mut core::ffi::c_void, size: usize);
+            }
+            let a = buf.as_mut_ptr().cast();
+            let size = buf.len();
+            unsafe { __msan_unpoison(a, size) };
+        } else {
+            let _ = buf;
+        }
+    }
+}

data/rust-vendor/getrandom/src/utils/sys_fill_exact.rs

@@ -0,0 +1,41 @@
+use crate::Error;
+use core::mem::MaybeUninit;
+
+mod get_errno;
+mod sanitizer;
+
+pub(crate) use get_errno::get_errno;
+
+/// Fill a buffer by repeatedly invoking `sys_fill`.
+///
+/// The `sys_fill` function:
+///   - should return -1 and set errno on failure
+///   - should return the number of bytes written on success
+pub(crate) fn sys_fill_exact(
+    mut buf: &mut [MaybeUninit<u8>],
+    sys_fill: impl Fn(&mut [MaybeUninit<u8>]) -> libc::ssize_t,
+) -> Result<(), Error> {
+    while !buf.is_empty() {
+        let res = sys_fill(buf);
+        match res {
+            res if res > 0 => {
+                let len = usize::try_from(res).map_err(|_| Error::UNEXPECTED)?;
+                let (l, r) = buf.split_at_mut_checked(len).ok_or(Error::UNEXPECTED)?;
+                unsafe { sanitizer::unpoison(l) };
+                buf = r;
+            }
+            -1 => {
+                let errno = get_errno();
+                // We should try again if the call was interrupted.
+                if errno != libc::EINTR {
+                    return Err(Error::from_errno(errno));
+                }
+            }
+            // Negative return codes not equal to -1 should be impossible.
+            // EOF (ret = 0) should be impossible, as the data we are reading
+            // should be an infinite stream of random bytes.
+            _ => return Err(Error::UNEXPECTED),
+        }
+    }
+    Ok(())
+}