html-to-markdown 2.24.4 → 2.24.6

data/rust-vendor/getrandom/Cargo.toml

@@ -10,10 +10,10 @@
 # See Cargo.toml.orig for the original contents.
 
 [package]
-edition = "2021"
-rust-version = "1.63"
+edition = "2024"
+rust-version = "1.85"
 name = "getrandom"
-version = "0.3.4"
+version = "0.4.1"
 authors = ["The Rand Project Developers"]
 build = "build.rs"
 exclude = [".*"]
@@ -33,7 +33,14 @@ license = "MIT OR Apache-2.0"
 repository = "https://github.com/rust-random/getrandom"
 
 [package.metadata.docs.rs]
-features = ["std"]
+features = [
+    "std",
+    "sys_rng",
+]
+rustdoc-args = [
+    "--cfg",
+    'getrandom_backend="extern_impl"',
+]
 
 [package.metadata.cross.target.x86_64-unknown-netbsd]
 pre-build = [
@@ -47,6 +54,7 @@ pre-build = [
 
 [features]
 std = []
+sys_rng = ["dep:rand_core"]
 wasm_js = [
     "dep:wasm-bindgen",
     "dep:js-sys",
@@ -60,6 +68,10 @@ path = "src/lib.rs"
 name = "mod"
 path = "tests/mod.rs"
 
+[[test]]
+name = "sys_rng"
+path = "tests/sys_rng.rs"
+
 [[bench]]
 name = "buffer"
 path = "benches/buffer.rs"
@@ -67,6 +79,10 @@ path = "benches/buffer.rs"
 [dependencies.cfg-if]
 version = "1"
 
+[dependencies.rand_core]
+version = "0.10.0"
+optional = true
+
 [target.'cfg(all(any(target_os = "linux", target_os = "android"), not(any(all(target_os = "linux", target_env = ""), getrandom_backend = "custom", getrandom_backend = "linux_raw", getrandom_backend = "rdrand", getrandom_backend = "rndr"))))'.dependencies.libc]
 version = "0.2.154"
 default-features = false
@@ -88,6 +104,9 @@ default-features = false
 version = "1"
 default-features = false
 
+[target.'cfg(all(target_arch = "wasm32", target_os = "wasi", target_env = "p3"))'.dependencies.wasip3]
+version = "0.4"
+
 [target.'cfg(all(target_os = "uefi", getrandom_backend = "efi_rng"))'.dependencies.r-efi]
 version = "5.1"
 default-features = false
@@ -120,14 +139,34 @@ default-features = false
 version = "0.2.154"
 default-features = false
 
+[lints.clippy]
+cast_lossless = "warn"
+cast_possible_truncation = "warn"
+cast_possible_wrap = "warn"
+cast_precision_loss = "warn"
+cast_ptr_alignment = "warn"
+cast_sign_loss = "warn"
+char_lit_as_u8 = "warn"
+checked_conversions = "warn"
+fn_to_numeric_cast = "warn"
+fn_to_numeric_cast_with_truncation = "warn"
+ptr_as_ptr = "warn"
+unnecessary_cast = "warn"
+useless_conversion = "warn"
+
+[lints.rust]
+missing_docs = "warn"
+unused_lifetimes = "warn"
+
 [lints.rust.unexpected_cfgs]
 level = "warn"
 priority = 0
 check-cfg = [
-    'cfg(getrandom_backend, values("custom", "efi_rng", "rdrand", "rndr", "linux_getrandom", "linux_raw", "wasm_js", "windows_legacy", "unsupported"))',
+    'cfg(getrandom_backend, values("custom", "efi_rng", "rdrand", "rndr", "linux_getrandom", "linux_raw", "windows_legacy", "unsupported", "extern_impl"))',
     "cfg(getrandom_msan)",
     "cfg(getrandom_test_linux_fallback)",
     "cfg(getrandom_test_linux_without_fallback)",
     "cfg(getrandom_test_netbsd_fallback)",
     'cfg(target_os, values("cygwin"))',
+    'cfg(target_os, values("motor"))',
 ]

data/rust-vendor/getrandom/Cargo.toml.orig

@@ -1,8 +1,8 @@
 [package]
 name = "getrandom"
-version = "0.3.4"
-edition = "2021"
-rust-version = "1.63" # Sync tests.yml and README.md.
+version = "0.4.1"
+edition = "2024"
+rust-version = "1.85" # Sync tests.yml and README.md.
 authors = ["The Rand Project Developers"]
 license = "MIT OR Apache-2.0"
 description = "A small cross-platform library for retrieving random data from system source"
@@ -11,20 +11,34 @@ repository = "https://github.com/rust-random/getrandom"
 categories = ["os", "no-std"]
 exclude = [".*"]
 
+[package.metadata.docs.rs]
+features = ["std", "sys_rng"]
+rustdoc-args = ["--cfg", "getrandom_backend=\"extern_impl\""]
+
 [features]
-# Implement std::error::Error for getrandom::Error and
+# Implement From<getrandom::Error> for std::io::Error and
 # use std to retrieve OS error descriptions
 std = []
 
 # Optional backend: wasm_js
+#
 # This flag enables the wasm_js backend and uses it by default on wasm32 where
 # the target_os is unknown. The getrandom_backend cfg may override this.
-# WARNING: It is highly recommended to enable this feature only for binary crates and tests,
-# i.e. avoid unconditionally enabling it in library crates.
+#
+# WARNING: We strongly recommend against enabling this feature in libraries (except for tests)
+# since it is known to break non-Web WASM builds and further since the usage of `wasm-bindgen`
+# causes significant bloat to `Cargo.lock` (on all targets).
+#
+# The only exception to this rule: if your crate already unconditionally depends on `wasm-bindgen`
+# or `js-sys` on "unknown" WASM targets then it's acceptable to enable this feature unconditionally.
 wasm_js = ["dep:wasm-bindgen", "dep:js-sys"]
 
+# Provide SysRng over rand_core
+sys_rng = ["dep:rand_core"]
+
 [dependencies]
 cfg-if = "1"
+rand_core = { version = "0.10.0", optional = true }
 
 # getrandom / linux_android_with_fallback
 [target.'cfg(all(any(target_os = "linux", target_os = "android"), not(any(all(target_os = "linux", target_env = ""), getrandom_backend = "custom", getrandom_backend = "linux_raw", getrandom_backend = "rdrand", getrandom_backend = "rndr"))))'.dependencies]
@@ -62,10 +76,14 @@ libc = { version = "0.2.154", default-features = false }
 [target.'cfg(target_os = "vxworks")'.dependencies]
 libc = { version = "0.2.154", default-features = false }
 
-# wasi_p2
+# wasi_p2_3
 [target.'cfg(all(target_arch = "wasm32", target_os = "wasi", target_env = "p2"))'.dependencies]
 wasip2 = { version = "1", default-features = false }
 
+# wasi_p2_3
+[target.'cfg(all(target_arch = "wasm32", target_os = "wasi", target_env = "p3"))'.dependencies]
+wasip3 = "0.4"
+
 # wasm_js
 [target.'cfg(all(target_arch = "wasm32", any(target_os = "unknown", target_os = "none")))'.dependencies]
 wasm-bindgen = { version = "0.2.98", default-features = false, optional = true }
@@ -77,16 +95,33 @@ wasm-bindgen-test = "0.3"
 [lints.rust.unexpected_cfgs]
 level = "warn"
 check-cfg = [
-  'cfg(getrandom_backend, values("custom", "efi_rng", "rdrand", "rndr", "linux_getrandom", "linux_raw", "wasm_js", "windows_legacy", "unsupported"))',
+  'cfg(getrandom_backend, values("custom", "efi_rng", "rdrand", "rndr", "linux_getrandom", "linux_raw", "windows_legacy", "unsupported", "extern_impl"))',
   'cfg(getrandom_msan)',
   'cfg(getrandom_test_linux_fallback)',
   'cfg(getrandom_test_linux_without_fallback)',
   'cfg(getrandom_test_netbsd_fallback)',
   'cfg(target_os, values("cygwin"))', # TODO(MSRV 1.86): Remove this.
+  'cfg(target_os, values("motor"))',
 ]
 
-[package.metadata.docs.rs]
-features = ["std"]
+[lints.rust]
+unused_lifetimes = "warn"
+missing_docs = "warn"
+
+[lints.clippy]
+cast_lossless = "warn"
+cast_possible_truncation = "warn"
+cast_possible_wrap = "warn"
+cast_precision_loss = "warn"
+cast_ptr_alignment = "warn"
+cast_sign_loss = "warn"
+char_lit_as_u8 = "warn"
+checked_conversions = "warn"
+fn_to_numeric_cast = "warn"
+fn_to_numeric_cast_with_truncation = "warn"
+ptr_as_ptr = "warn"
+unnecessary_cast = "warn"
+useless_conversion = "warn"
 
 # workaround for https://github.com/cross-rs/cross/issues/1345
 [package.metadata.cross.target.x86_64-unknown-netbsd]

data/rust-vendor/getrandom/LICENSE-MIT

@@ -1,4 +1,4 @@
-Copyright (c) 2018-2025 The rust-random Project Developers
+Copyright (c) 2018-2026 The rust-random Project Developers
 Copyright (c) 2014 The Rust Project Developers
 
 Permission is hereby granted, free of charge, to any

data/rust-vendor/getrandom/README.md

@@ -43,7 +43,7 @@ fn get_random_u128() -> Result<u128, getrandom::Error> {
 | Target             | Target Triple      | Implementation
 | ------------------ | ------------------ | --------------
 | Linux, Android     | `*‑linux‑*`        | [`getrandom`][1] system call if available, otherwise [`/dev/urandom`][2] after successfully polling `/dev/random`
-| Windows 10+        | `*‑windows‑*`      | [`ProcessPrng`] on Rust 1.78+, [`RtlGenRandom`] otherwise
+| Windows 10+        | `*‑windows‑*`      | [`ProcessPrng`]
 | Windows 7, 8       | `*-win7‑windows‑*` | [`RtlGenRandom`]
 | macOS              | `*‑apple‑darwin`   | [`getentropy`][3]
 | iOS, tvOS, watchOS | `*‑apple‑{ios,tvos,watchos}` | [`CCRandomGenerateBytes`]
@@ -70,32 +70,54 @@ fn get_random_u128() -> Result<u128, getrandom::Error> {
 | QNX Neutrino       | `*‑nto-qnx*`       | [`/dev/urandom`][14] (identical to `/dev/random`)
 | AIX                | `*-ibm-aix`        | [`/dev/urandom`][15]
 | Cygwin             | `*-cygwin`         | [`getrandom`][20] (based on [`RtlGenRandom`])
+| Motor OS           | `x86_64-unknown-motor` | [`RDRAND`]
 
 Pull Requests that add support for new targets to `getrandom` are always welcome.
 
+### WebAssembly support
+
+This crate fully supports the [WASI] and [Emscripten] targets. However,
+the `wasm32-unknown-unknown` target (i.e. the target used by `wasm-pack`)
+is not automatically supported since, from the target name alone, we cannot deduce
+which JavaScript interface should be used (or if JavaScript is available at all).
+
+We do not include support for this target in the default configuration because our JS backend
+(supporting web browsers, web workers and Node.js v19 or later) requires [`wasm-bindgen`],
+**bloating `Cargo.lock`** and **potentially breaking builds** on non-web WASM platforms.
+
+To enable `getrandom`'s functionality on `wasm32-unknown-unknown` using
+[`Crypto.getRandomValues`] via [`wasm-bindgen`], enable the `wasm_js` crate feature.
+
+WARNING: We strongly recommend against enabling this feature in libraries (except for tests)
+since it is known to break non-Web WASM builds and further since the usage of `wasm-bindgen`
+causes significant bloat to `Cargo.lock` (on all targets).
+
+The only exception to this rule: if your crate already unconditionally depends on `wasm-bindgen`
+or `js-sys` on "unknown" WASM targets then it's acceptable to enable this feature unconditionally.
+
 ### Opt-in backends
 
 `getrandom` also provides optional (opt-in) backends, which allow users to customize the source
 of randomness based on their specific needs:
 
-| Backend name      | Target               | Target Triple            | Implementation
-| ----------------- | -------------------- | ------------------------ | --------------
-| `linux_getrandom` | Linux, Android       | `*‑linux‑*`              | [`getrandom`][1] system call (without `/dev/urandom` fallback). Bumps minimum supported Linux kernel version to 3.17 and Android API level to 23 (Marshmallow).
-| `linux_raw`       | Linux, Android       | `*‑linux‑*`              | Same as `linux_getrandom`, but uses raw `asm!`-based syscalls instead of `libc`.
-| `rdrand`          | x86, x86-64          | `x86_64-*`, `i686-*`     | [`RDRAND`] instruction
-| `rndr`            | AArch64              | `aarch64-*`              | [`RNDR`] register
-| `wasm_js`         | Web Browser, Node.js | `wasm32‑unknown‑unknown`, `wasm32v1-none` | [`Crypto.getRandomValues`]. Enabled by the `wasm_js` feature ([see below](#webassembly-support)).
-| `efi_rng`         | UEFI                 | `*-unknown‑uefi`         | [`EFI_RNG_PROTOCOL`] with `EFI_RNG_ALGORITHM_RAW` (requires `std` and Nightly compiler)
-| `windows_legacy`  | Windows              | `*-windows-*`            | [`RtlGenRandom`]
-| `custom`          | All targets          | `*`                      | User-provided custom implementation (see [custom backend])
-| `unsupported`     | All targets          | `*`                      | Always returns `Err(Error::UNSUPPORTED)` (see [unsupported backend])
+| Backend name        | Target               | Target Triple            | Implementation
+| ------------------- | -------------------- | ------------------------ | --------------
+| `linux_getrandom`   | Linux, Android       | `*‑linux‑*`              | [`getrandom`][1] system call (without `/dev/urandom` fallback). Bumps minimum supported Linux kernel version to 3.17 and Android API level to 23 (Marshmallow).
+| `linux_raw`         | Linux, Android       | `*‑linux‑*`              | Same as `linux_getrandom`, but uses raw `asm!`-based syscalls instead of `libc`.
+| `rdrand`            | x86, x86-64          | `x86_64-*`, `i686-*`     | [`RDRAND`] instruction
+| `rndr`              | AArch64              | `aarch64-*`              | [`RNDR`] register
+| `efi_rng`           | UEFI                 | `*-unknown‑uefi`         | [`EFI_RNG_PROTOCOL`] with `EFI_RNG_ALGORITHM_RAW` (requires `std` and Nightly compiler)
+| `windows_legacy`    | Windows              | `*-windows-*`            | [`RtlGenRandom`]
+| `custom`            | All targets          | `*`                      | User-provided custom implementation (see [custom backend])
+| `unsupported`       | All targets          | `*`                      | Always returns `Err(Error::UNSUPPORTED)` (see [unsupported backend])
+| `extern_impl`       | All targets          | `*`                      | Externally-provided custom implementation (see [externally implemented interface])
 
 Opt-in backends can be enabled using the `getrandom_backend` configuration flag.
 The flag can be set either by specifying the `rustflags` field in [`.cargo/config.toml`]:
 ```toml
 # It's recommended to set the flag on a per-target basis:
-[target.wasm32-unknown-unknown]
-rustflags = ['--cfg', 'getrandom_backend="wasm_js"']
+[target.'cfg(target_os = "linux")']
+rustflags = ['--cfg', 'getrandom_backend="linux_getrandom"']
 ```
 
 Or by using the `RUSTFLAGS` environment variable:
@@ -124,29 +146,6 @@ Note that the raw syscall backend may be slower than backends based on `libc::ge
 e.g. it does not implement vDSO optimizations and on `x86` it uses the infamously slow
 `int 0x80` instruction to perform syscall.
 
-### WebAssembly support
-
-This crate fully supports the [WASI] and [Emscripten] targets. However,
-the `wasm32-unknown-unknown` target (i.e. the target used by `wasm-pack`)
-is not automatically supported since, from the target name alone, we cannot deduce
-which JavaScript interface should be used (or if JavaScript is available at all).
-
-We do not include support for this target in the default configuration because
-our JS backend (supporting web browsers, web workers and Node.js v19 or later)
-requires [`wasm-bindgen`], **bloating `Cargo.lock`** and
-**potentially breaking builds** on non-web WASM platforms.
-
-To enable `getrandom`'s functionality on `wasm32-unknown-unknown` using the Web
-Crypto methods [described above][opt-in] via [`wasm-bindgen`], enable the
-`wasm_js` feature flag. Setting `RUSTFLAGS='--cfg getrandom_backend="wasm_js"'`
-is allowed but is no longer required and does nothing (it was required in a
-prior version of this crate).
-
-WARNING: enabling the `wasm_js` feature will bloat `Cargo.lock` on all platforms
-(where [`wasm-bindgen`] is not an existing dependency) and is known to cause
-build issues on some non-web WASM platforms, even when a different backend is
-selected via `getrandom_backend`.
-
 ### Custom backend
 
 If this crate does not support your target out of the box or you have to use
@@ -159,7 +158,7 @@ Next, you need to define an `extern` function with the following signature:
 ```rust
 use getrandom::Error;
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "Rust" fn __getrandom_v03_custom(
     dest: *mut u8,
     len: usize,
@@ -189,7 +188,7 @@ fn my_entropy_source(buf: &mut [u8]) -> Result<(), getrandom::Error> {
     Ok(())
 }
 
-#[no_mangle]
+#[unsafe(no_mangle)]
 unsafe extern "Rust" fn __getrandom_v03_custom(
     dest: *mut u8,
     len: usize,
@@ -204,6 +203,38 @@ unsafe extern "Rust" fn __getrandom_v03_custom(
 }
 ```
 
+### Externally Implemented Interface
+
+Using the nightly-only feature [`extern_item_impls`] it is possible to provide
+a custom backend for `getrandom`, even to override an existing first-party implementation.
+First, enable the `extern_impl` opt-in backend to allow usage of this nightly feature.
+Then, you may provide implementations for `fill_uninit`, `u32`, and/or `u64`
+with an attribute macro from the `implementation` module.
+
+[`extern_item_impls`]: https://github.com/rust-lang/rust/issues/125418
+
+```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> {
+    // ...
+    Ok(())
+}
+```
+
+For further details on what a suitable implementation for `fill_uninit` may look
+like, see [custom backend].
+
+`getrandom` will provide a default implementation for `u32` and `u64`, but does
+not currently provide a default for `fill_uninit`, even if one is normally
+available for the current target. If no implementation is available,
+a compilation error will be raised with instructions for how to provide
+an implementation.
+
 ### Unsupported backend
 
 In some rare scenarios, you might be compiling this crate for an unsupported
@@ -302,7 +333,7 @@ RUSTFLAGS="-Zsanitizer=memory" cargo test -Zbuild-std --target=x86_64-unknown-li
 
 ## Minimum Supported Rust Version
 
-This crate requires Rust 1.63 or later.
+This crate requires Rust 1.85 or later.
 
 ## License
 
@@ -376,6 +407,7 @@ dual licensed as above, without any additional terms or conditions.
 [WASI]: https://github.com/WebAssembly/WASI
 [Emscripten]: https://emscripten.org
 [opt-in]: #opt-in-backends
+[externally implemented interface]: #externally-implemented-interface
 
 [//]: # (licenses)
 

data/rust-vendor/getrandom/benches/buffer.rs

@@ -1,8 +1,9 @@
+//! Basic benchmarks
 #![feature(test, maybe_uninit_uninit_array_transpose)]
 extern crate test;
 
 use std::{
-    mem::{size_of, MaybeUninit},
+    mem::{MaybeUninit, size_of},
     slice,
 };
 
@@ -23,7 +24,7 @@ fn bench_fill_uninit<const N: usize>() {
 }
 
 #[bench]
-pub fn bench_u32(b: &mut test::Bencher) {
+fn bench_u32(b: &mut test::Bencher) {
     #[inline(never)]
     fn inner() -> u32 {
         getrandom::u32().unwrap()
@@ -31,8 +32,9 @@ pub fn bench_u32(b: &mut test::Bencher) {
     b.bytes = 4;
     b.iter(inner);
 }
+
 #[bench]
-pub fn bench_u32_via_fill(b: &mut test::Bencher) {
+fn bench_u32_via_fill(b: &mut test::Bencher) {
     #[inline(never)]
     fn inner() -> u32 {
         let mut res = MaybeUninit::<u32>::uninit();
@@ -46,7 +48,7 @@ pub fn bench_u32_via_fill(b: &mut test::Bencher) {
 }
 
 #[bench]
-pub fn bench_u64(b: &mut test::Bencher) {
+fn bench_u64(b: &mut test::Bencher) {
     #[inline(never)]
     fn inner() -> u64 {
         getrandom::u64().unwrap()
@@ -56,7 +58,7 @@ pub fn bench_u64(b: &mut test::Bencher) {
 }
 
 #[bench]
-pub fn bench_u64_via_fill(b: &mut test::Bencher) {
+fn bench_u64_via_fill(b: &mut test::Bencher) {
     #[inline(never)]
     fn inner() -> u64 {
         let mut res = MaybeUninit::<u64>::uninit();
@@ -78,9 +80,9 @@ pub fn bench_u64_via_fill(b: &mut test::Bencher) {
 //   cargo asm --bench buffer --release buffer::p384::bench_getrandom::inner
 macro_rules! bench {
     ( $name:ident, $size:expr ) => {
-        pub mod $name {
+        mod $name {
             #[bench]
-            pub fn bench_fill(b: &mut test::Bencher) {
+            fn bench_fill(b: &mut test::Bencher) {
                 #[inline(never)]
                 fn inner() {
                     super::bench_fill::<{ $size }>()
@@ -90,7 +92,7 @@ macro_rules! bench {
                 b.iter(inner);
             }
             #[bench]
-            pub fn bench_fill_uninit(b: &mut test::Bencher) {
+            fn bench_fill_uninit(b: &mut test::Bencher) {
                 #[inline(never)]
                 fn inner() {
                     super::bench_fill_uninit::<{ $size }>()

data/rust-vendor/getrandom/build.rs

@@ -1,34 +1,4 @@
-use std::{env, ffi::OsString, process::Command};
-
-/// Tries to get the minor version of the Rust compiler in use.
-/// If it fails for any reason, returns `None`.
-///
-/// Based on the `rustc_version` crate.
-fn rustc_minor_version() -> Option<u64> {
-    let rustc = env::var_os("RUSTC").unwrap_or_else(|| OsString::from("rustc"));
-    let mut cmd = if let Some(wrapper) = env::var_os("RUSTC_WRAPPER").filter(|w| !w.is_empty()) {
-        let mut cmd = Command::new(wrapper);
-        cmd.arg(rustc);
-        cmd
-    } else {
-        Command::new(rustc)
-    };
-
-    let out = cmd.arg("-vV").output().ok()?;
-
-    if !out.status.success() {
-        return None;
-    }
-
-    let stdout = std::str::from_utf8(&out.stdout).ok()?;
-
-    // Assumes that the first line contains "rustc 1.xx.0-channel (abcdef 2025-01-01)"
-    // where "xx" is the minor version which we want to extract
-    let mut lines = stdout.lines();
-    let first_line = lines.next()?;
-    let minor_ver_str = first_line.split('.').nth(1)?;
-    minor_ver_str.parse().ok()
-}
+//! Build script for memory sanitization support
 
 fn main() {
     // Automatically detect cfg(sanitize = "memory") even if cfg(sanitize) isn't
@@ -38,20 +8,4 @@ fn main() {
     if sanitizers.contains("memory") {
         println!("cargo:rustc-cfg=getrandom_msan");
     }
-
-    // Use `RtlGenRandom` on older compiler versions since win7 targets
-    // TODO(MSRV 1.78): Remove this check
-    let target_family = env::var_os("CARGO_CFG_TARGET_FAMILY").and_then(|f| f.into_string().ok());
-    if target_family.as_deref() == Some("windows") {
-        /// Minor version of the Rust compiler in which win7 targets were inroduced
-        const WIN7_INTRODUCED_MINOR_VER: u64 = 78;
-
-        match rustc_minor_version() {
-            Some(minor_ver) if minor_ver < WIN7_INTRODUCED_MINOR_VER => {
-                println!("cargo:rustc-cfg=getrandom_backend=\"windows_legacy\"");
-            }
-            None => println!("cargo:warning=Couldn't detect minor version of the Rust compiler"),
-            _ => {}
-        }
-    }
 }

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

@@ -6,7 +6,7 @@ pub use crate::util::{inner_u32, inner_u64};
 
 #[inline]
 pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
-    extern "Rust" {
+    unsafe extern "Rust" {
         fn __getrandom_v03_custom(dest: *mut u8, len: usize) -> Result<(), Error>;
     }
     unsafe { __getrandom_v03_custom(dest.as_mut_ptr().cast(), dest.len()) }

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

@@ -2,7 +2,7 @@
 use crate::Error;
 use core::{
     mem::MaybeUninit,
-    ptr::{self, null_mut, NonNull},
+    ptr::{self, NonNull, null_mut},
     sync::atomic::{AtomicPtr, Ordering::Relaxed},
 };
 use r_efi::{

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

@@ -4,7 +4,7 @@ use core::{ffi::c_void, mem::MaybeUninit};
 
 pub use crate::util::{inner_u32, inner_u64};
 
-extern "C" {
+unsafe extern "C" {
     fn esp_fill_random(buf: *mut c_void, len: usize) -> u32;
 }
 

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

@@ -0,0 +1,19 @@
+//! An implementation which calls out to an externally defined function.
+use crate::Error;
+use core::mem::MaybeUninit;
+
+/// Declares this function as an external implementation of [`fill_uninit`](crate::fill_uninit).
+#[eii(fill_uninit)]
+pub(crate) fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error>;
+
+/// Declares this function as an external implementation of [`u32`](crate::u32).
+#[eii(u32)]
+pub(crate) fn inner_u32() -> Result<u32, crate::Error> {
+    crate::util::inner_u32()
+}
+
+/// Declares this function as an external implementation of [`u64`](crate::u64).
+#[eii(u64)]
+pub(crate) fn inner_u64() -> Result<u64, crate::Error> {
+    crate::util::inner_u64()
+}

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

@@ -5,7 +5,7 @@ use core::mem::MaybeUninit;
 pub use crate::util::{inner_u32, inner_u64};
 
 #[link(name = "zircon")]
-extern "C" {
+unsafe extern "C" {
     fn zx_cprng_draw(buffer: *mut u8, length: usize);
 }
 

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

@@ -12,15 +12,16 @@ use core::{ffi::c_void, mem::MaybeUninit};
 
 pub use crate::util::{inner_u32, inner_u64};
 
-#[path = "../util_libc.rs"]
-mod util_libc;
+#[path = "../utils/get_errno.rs"]
+mod utils;
 
 #[inline]
 pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
     for chunk in dest.chunks_mut(256) {
         let ret = unsafe { libc::getentropy(chunk.as_mut_ptr().cast::<c_void>(), chunk.len()) };
         if ret != 0 {
-            return Err(util_libc::last_os_error());
+            let errno = utils::get_errno();
+            return Err(Error::from_errno(errno));
         }
     }
     Ok(())

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

@@ -20,20 +20,12 @@ use core::mem::MaybeUninit;
 
 pub use crate::util::{inner_u32, inner_u64};
 
-#[path = "../util_libc.rs"]
-mod util_libc;
+#[path = "../utils/sys_fill_exact.rs"]
+mod utils;
 
 #[inline]
 pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
-    util_libc::sys_fill_exact(dest, |buf| unsafe {
-        let ret = libc::getrandom(buf.as_mut_ptr().cast(), buf.len(), 0);
-
-        #[cfg(any(target_os = "android", target_os = "linux"))]
-        #[allow(unused_unsafe)] // TODO(MSRV 1.65): Remove this.
-        unsafe {
-            super::sanitizer::unpoison_linux_getrandom_result(buf, ret);
-        }
-
-        ret
+    utils::sys_fill_exact(dest, |buf| unsafe {
+        libc::getrandom(buf.as_mut_ptr().cast(), buf.len(), 0)
     })
 }

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

@@ -2,7 +2,7 @@
 use crate::Error;
 use core::mem::MaybeUninit;
 
-extern "C" {
+unsafe extern "C" {
     fn sys_read_entropy(buffer: *mut u8, length: usize, flags: u32) -> isize;
     // Note that `sys_secure_rand32/64` are implemented using `sys_read_entropy`:
     // https://github.com/hermit-os/kernel/blob/430da84/src/syscalls/entropy.rs#L62-L104