fast_code_owners 0.0.7 → 0.0.8

data/ext/cargo-vendor/getrandom-0.3.3/README.md

@@ -0,0 +1,390 @@
+# getrandom: system's random number generator
+
+[![Build Status]][GitHub Actions]
+[![Crate]][crates.io]
+[![Documentation]][docs.rs]
+[![Dependency Status]][deps.rs]
+[![Downloads]][crates.io]
+[![License]][LICENSE-MIT]
+
+`getrandom` is a Rust library for retrieving random data from (operating) system sources.
+
+It is assumed that the system always provides high-quality, cryptographically secure random
+data, ideally backed by hardware entropy sources. This crate derives its name from
+the Linux `getrandom` syscall but is cross-platform, roughly supporting the same set
+of platforms as Rust's `std` library.
+
+This is a low-level API. Most users should prefer using a higher-level random-number
+library like [`rand`].
+
+[`rand`]: https://crates.io/crates/rand
+
+## Usage
+
+Add the `getrandom` dependency to your `Cargo.toml` file:
+
+```toml
+[dependencies]
+getrandom = "0.3"
+```
+
+Then invoke the `fill` function on a byte buffer to fill it with random data:
+
+```rust
+fn get_random_u128() -> Result<u128, getrandom::Error> {
+    let mut buf = [0u8; 16];
+    getrandom::fill(&mut buf)?;
+    Ok(u128::from_ne_bytes(buf))
+}
+```
+
+## Supported targets
+
+| 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 7, 8       | `*-win7‑windows‑*` | [`RtlGenRandom`]
+| macOS              | `*‑apple‑darwin`   | [`getentropy`][3]
+| iOS, tvOS, watchOS | `*‑apple‑{ios,tvos,watchos}` | [`CCRandomGenerateBytes`]
+| FreeBSD            | `*‑freebsd`        | [`getrandom`][5]
+| OpenBSD            | `*‑openbsd`        | [`getentropy`][7]
+| NetBSD             | `*‑netbsd`         | [`getrandom`][16] if available, otherwise [`kern.arandom`][8]
+| Dragonfly BSD      | `*‑dragonfly`      | [`getrandom`][9]
+| Solaris            | `*‑solaris`        | [`getrandom`][11] with `GRND_RANDOM`
+| illumos            | `*‑illumos`        | [`getrandom`][12]
+| Fuchsia OS         | `*‑fuchsia`        | [`cprng_draw`]
+| Redox              | `*‑redox`          | `/dev/urandom`
+| Haiku              | `*‑haiku`          | `/dev/urandom` (identical to `/dev/random`)
+| Hermit             | `*-hermit`         | [`sys_read_entropy`]
+| Hurd               | `*-hurd-*`         | [`getrandom`][17]
+| SGX                | `x86_64‑*‑sgx`     | [`RDRAND`]
+| VxWorks            | `*‑wrs‑vxworks‑*`  | `randABytes` after checking entropy pool initialization with `randSecure`
+| Emscripten         | `*‑emscripten`     | [`getentropy`][13]
+| WASI 0.1           | `wasm32‑wasip1`    | [`random_get`]
+| WASI 0.2           | `wasm32‑wasip2`    | [`get-random-u64`]
+| SOLID              | `*-kmc-solid_*`    | `SOLID_RNG_SampleRandomBytes`
+| Nintendo 3DS       | `*-nintendo-3ds`   | [`getrandom`][18]
+| ESP-IDF            | `*‑espidf`         | [`esp_fill_random`] WARNING: see "Early Boot" section below
+| PS Vita            | `*-vita-*`         | [`getentropy`][19]
+| QNX Neutrino       | `*‑nto-qnx*`       | [`/dev/urandom`][14] (identical to `/dev/random`)
+| AIX                | `*-ibm-aix`        | [`/dev/urandom`][15]
+| Cygwin             | `*-cygwin`         | [`getrandom`][20] (based on [`RtlGenRandom`])
+
+Pull Requests that add support for new targets to `getrandom` are always welcome.
+
+### 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`]. Requires feature `wasm_js` ([see below](#webassembly-support)).
+| `efi_rng`         | UEFI                 | `*-unknown‑uefi`         | [`EFI_RNG_PROTOCOL`] with `EFI_RNG_ALGORITHM_RAW` (requires `std` and Nigthly compiler)
+| `custom`          | All targets          | `*`                      | User-provided custom implementation (see [custom backend])
+
+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"']
+```
+
+Or by using the `RUSTFLAGS` environment variable:
+
+```sh
+RUSTFLAGS='--cfg getrandom_backend="linux_getrandom"' cargo build
+```
+
+Enabling an opt-in backend will replace the backend used by default. Doing this for
+an incorrect target (e.g. using `linux_getrandom` while compiling for a Windows target)
+will result in a compilation error. Be extremely careful while using opt-in backends,
+as incorrect configuration may result in vulnerable applications or applications
+that always panic.
+
+Note that using an opt-in backend in a library (e.g. for tests or benchmarks)
+WILL NOT have any effect on its downstream users.
+
+[`.cargo/config.toml`]: https://doc.rust-lang.org/cargo/reference/config.html
+
+### Raw Linux syscall support
+
+Currently the `linux_raw` backend supports only targets with stabilized `asm!` macro,
+i.e. `arm`, `aarch64`, `loongarch64`, `riscv32`, `riscv64`, `s390x`, `x86`, and `x86_64`.
+
+Note that the raw syscall backend may be slower than backends based on `libc::getrandom`,
+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).
+
+To enable `getrandom`'s functionality on `wasm32-unknown-unknown` using the Web
+Crypto methods [described above][opt-in] via [`wasm-bindgen`], do
+*both* of the following:
+
+-   Use the `wasm_js` feature flag, i.e.
+    `getrandom = { version = "0.3", features = ["wasm_js"] }`.
+    On its own, this only makes the backend available. (As a side effect this
+    will make your `Cargo.lock` significantly larger if you are not already
+    using [`wasm-bindgen`], but otherwise enabling this feature is harmless.)
+-   Set `RUSTFLAGS='--cfg getrandom_backend="wasm_js"'` ([see above][opt-in]).
+
+This backend supports both web browsers (main window and Web Workers)
+and Node.js (v19 or later) environments.
+
+WARNING: It is highly recommended to enable the `wasm_js` feature only for
+binary crates and tests, i.e. avoid unconditionally enabling it in library crates.
+
+### Custom backend
+
+If this crate does not support your target out of the box or you have to use
+a non-default entropy source, then you can provide a custom implementation.
+You need to enable the custom backend as described in the
+[opt-in backends][opt-in] section.
+
+Next, you need to define an `extern` function with the following signature:
+
+```rust
+use getrandom::Error;
+
+#[no_mangle]
+unsafe extern "Rust" fn __getrandom_v03_custom(
+    dest: *mut u8,
+    len: usize,
+) -> Result<(), Error> {
+    todo!()
+}
+```
+
+This function should, ideally, be defined in the root crate of your project,
+e.g. in your `main.rs`. This function MUST be defined only once for your
+project, i.e. upstream library crates SHOULD NOT define it outside of
+tests and benchmarks. Improper configuration of this backend may result
+in linking errors.
+
+The function accepts a pointer to a buffer that should be filled with random
+data and its length in bytes. Note that the buffer MAY be uninitialized.
+On success, the function should return `Ok(())` and fully fill the input buffer;
+otherwise, it should return an error value.
+
+While wrapping functions which work with byte slices you should fully initialize
+the buffer before passing it to the function:
+```rust
+use getrandom::Error;
+
+fn my_entropy_source(buf: &mut [u8]) -> Result<(), getrandom::Error> {
+    // ...
+    Ok(())
+}
+
+#[no_mangle]
+unsafe extern "Rust" fn __getrandom_v03_custom(
+    dest: *mut u8,
+    len: usize,
+) -> Result<(), Error> {
+    let buf = unsafe {
+        // fill the buffer with zeros
+        core::ptr::write_bytes(dest, 0, len);
+        // create mutable byte slice
+        core::slice::from_raw_parts_mut(dest, len)
+    };
+    my_entropy_source(buf)
+}
+```
+
+If you are confident that `getrandom` is not used in your project, but
+it gets pulled nevertheless by one of your dependencies, then you can
+use the following custom backend, which always returns the "unsupported" error:
+```rust
+use getrandom::Error;
+
+#[no_mangle]
+unsafe extern "Rust" fn __getrandom_v03_custom(
+    dest: *mut u8,
+    len: usize,
+) -> Result<(), Error> {
+    Err(Error::UNSUPPORTED)
+}
+```
+
+### Platform Support
+
+This crate generally supports the same operating system and platform versions
+that the Rust standard library does. Additional targets may be supported using
+the opt-in custom backend.
+
+This means that as Rust drops support for old versions of operating systems
+(such as old Linux kernel versions, Android API levels, etc.) in stable releases,
+`getrandom` may create new patch releases that remove support for
+outdated platform versions.
+
+### `/dev/urandom` fallback on Linux and Android
+
+On Linux targets, the `/dev/urandom` fallback is present only if either `target_env`
+is `musl`, or `target_arch` is one of the following: `aarch64`, `arm`, `powerpc`,
+`powerpc64`, `s390x`, `x86`, `x86_64`. Other supported targets [require][platform-support]
+kernel versions that support the `getrandom` system call, so the fallback is not needed.
+
+On Android targets the fallback is present only for the following `target_arch`es:
+`aarch64`, `arm`, `x86`, `x86_64`. Other `target_arch`es (e.g. RISC-V) require
+sufficiently high API levels.
+
+The fallback can be disabled by enabling the `linux_getrandom` opt-in backend.
+Note that doing so will bump minimum supported Linux kernel version to 3.17
+and Android API level to 23 (Marshmallow).
+
+### Early boot
+
+Sometimes, early in the boot process, the OS has not collected enough
+entropy to securely seed its RNG. This is especially common on virtual
+machines, where standard "random" events are hard to come by.
+
+Some operating system interfaces always block until the RNG is securely
+seeded. This can take anywhere from a few seconds to more than a minute.
+A few (Linux, NetBSD and Solaris) offer a choice between blocking and
+getting an error; in these cases, we always choose to block.
+
+On Linux (when the `getrandom` system call is not available), reading from
+`/dev/urandom` never blocks, even when the OS hasn't collected enough
+entropy yet. To avoid returning low-entropy bytes, we first poll
+`/dev/random` and only switch to `/dev/urandom` once this has succeeded.
+
+On OpenBSD, this kind of entropy accounting isn't available, and on
+NetBSD, blocking on it is discouraged. On these platforms, nonblocking
+interfaces are used, even when reliable entropy may not be available.
+On the platforms where it is used, the reliability of entropy accounting
+itself isn't free from controversy. This library provides randomness
+sourced according to the platform's best practices, but each platform has
+its own limits on the grade of randomness it can promise in environments
+with few sources of entropy.
+
+On ESP-IDF, if `esp_fill_random` is used before enabling WiFi, BT, or the
+voltage noise entropy source (SAR ADC), the Hardware RNG will only be seeded
+via RC_FAST_CLK. This can occur during early boot unless
+`bootloader_random_enable()` is called. For more information see the
+[ESP-IDF RNG Docs][esp-idf-rng] or the
+[RNG section of the ESP32 Technical Reference Manual][esp-trng-docs].
+
+## Error handling
+
+We always prioritize failure over returning known insecure "random" bytes.
+Generally, on supported platforms, failure is highly unlikely, though not
+impossible. If an error does occur, it is likely that it will occur
+on every call to `getrandom`. Therefore, after the first successful call,
+one can be reasonably confident that no errors will occur.
+
+## Panic handling
+
+We strive to eliminate all potential panics from our backend implementations.
+In other words, when compiled with optimizations enabled, the generated
+binary code for `getrandom` functions should not contain any panic branches.
+Even if the platform misbehaves and returns an unexpected result,
+our code should correctly handle it and return an error, e.g.
+[`Error::UNEXPECTED`].
+
+## Sanitizer support
+
+If your code uses [`fill_uninit`] and you enable
+[MemorySanitizer](https://doc.rust-lang.org/beta/unstable-book/compiler-flags/sanitizer.html#memorysanitizer)
+(i.e. `-Zsanitizer=memory`), we will automatically handle unpoisoning
+of the destination buffer filled by `fill_uninit`.
+
+You can run sanitizer tests for your crate dependent on `getrandom` like this:
+```sh
+RUSTFLAGS="-Zsanitizer=memory" cargo test -Zbuild-std --target=x86_64-unknown-linux-gnu
+```
+
+## Minimum Supported Rust Version
+
+This crate requires Rust 1.63 or later.
+
+## License
+
+The `getrandom` library is distributed under either of
+
+ * [Apache License, Version 2.0][LICENSE-APACHE]
+ * [MIT license][LICENSE-MIT]
+
+at your option.
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
+dual licensed as above, without any additional terms or conditions.
+
+[//]: # (badges)
+
+[GitHub Actions]: https://github.com/rust-random/getrandom/actions?query=branch:master
+[Build Status]: https://github.com/rust-random/getrandom/actions/workflows/tests.yml/badge.svg?branch=master
+[crates.io]: https://crates.io/crates/getrandom
+[Crate]: https://img.shields.io/crates/v/getrandom
+[docs.rs]: https://docs.rs/getrandom
+[Documentation]: https://docs.rs/getrandom/badge.svg
+[deps.rs]: https://deps.rs/repo/github/rust-random/getrandom
+[Dependency Status]: https://deps.rs/repo/github/rust-random/getrandom/status.svg
+[Downloads]: https://img.shields.io/crates/d/getrandom
+[License]: https://img.shields.io/crates/l/getrandom
+
+[//]: # (supported targets)
+
+[1]: https://manned.org/getrandom.2
+[2]: https://manned.org/urandom.4
+[3]: https://www.unix.com/man-page/mojave/2/getentropy/
+[4]: https://www.unix.com/man-page/mojave/4/urandom/
+[5]: https://www.freebsd.org/cgi/man.cgi?query=getrandom&manpath=FreeBSD+12.0-stable
+[7]: https://man.openbsd.org/getentropy.2
+[8]: https://man.netbsd.org/sysctl.7
+[9]: https://leaf.dragonflybsd.org/cgi/web-man?command=getrandom
+[11]: https://docs.oracle.com/cd/E88353_01/html/E37841/getrandom-2.html
+[12]: https://illumos.org/man/2/getrandom
+[13]: https://github.com/emscripten-core/emscripten/pull/12240
+[14]: https://www.qnx.com/developers/docs/7.1/index.html#com.qnx.doc.neutrino.utilities/topic/r/random.html
+[15]: https://www.ibm.com/docs/en/aix/7.3?topic=files-random-urandom-devices
+[16]: https://man.netbsd.org/getrandom.2
+[17]: https://www.gnu.org/software/libc/manual/html_mono/libc.html#index-getrandom
+[18]: https://github.com/rust3ds/shim-3ds/commit/b01d2568836dea2a65d05d662f8e5f805c64389d
+[19]: https://github.com/vitasdk/newlib/blob/2d869fe47aaf02b8e52d04e9a2b79d5b210fd016/newlib/libc/sys/vita/getentropy.c
+[20]: https://github.com/cygwin/cygwin/blob/main/winsup/cygwin/libc/getentropy.cc
+
+[`ProcessPrng`]: https://learn.microsoft.com/en-us/windows/win32/seccng/processprng
+[`RtlGenRandom`]: https://learn.microsoft.com/en-us/windows/win32/api/ntsecapi/nf-ntsecapi-rtlgenrandom
+[`Crypto.getRandomValues`]: https://www.w3.org/TR/WebCryptoAPI/#Crypto-method-getRandomValues
+[`RDRAND`]: https://software.intel.com/en-us/articles/intel-digital-random-number-generator-drng-software-implementation-guide
+[`RNDR`]: https://developer.arm.com/documentation/ddi0601/2024-06/AArch64-Registers/RNDR--Random-Number
+[`CCRandomGenerateBytes`]: https://opensource.apple.com/source/CommonCrypto/CommonCrypto-60074/include/CommonRandom.h.auto.html
+[`cprng_draw`]: https://fuchsia.dev/fuchsia-src/zircon/syscalls/cprng_draw
+[`esp_fill_random`]: https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-reference/system/random.html#functions
+[esp-idf-rng]: https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-reference/system/random.html
+[esp-trng-docs]: https://www.espressif.com/sites/default/files/documentation/esp32_technical_reference_manual_en.pdf#rng
+[`EFI_RNG_PROTOCOL`]: https://uefi.org/specs/UEFI/2.10/37_Secure_Technologies.html#efi-rng-protocol
+[`random_get`]: https://github.com/WebAssembly/WASI/blob/snapshot-01/phases/snapshot/docs.md#-random_getbuf-pointeru8-buf_len-size---errno
+[`get-random-u64`]: https://github.com/WebAssembly/WASI/blob/v0.2.1/wasip2/random/random.wit#L23-L28
+[configuration flags]: #configuration-flags
+[custom backend]: #custom-backend
+[`wasm-bindgen`]: https://github.com/rustwasm/wasm-bindgen
+[`module`]: https://rustwasm.github.io/wasm-bindgen/reference/attributes/on-js-imports/module.html
+[`sys_read_entropy`]: https://github.com/hermit-os/kernel/blob/315f58ff5efc81d9bf0618af85a59963ff55f8b1/src/syscalls/entropy.rs#L47-L55
+[platform-support]: https://doc.rust-lang.org/stable/rustc/platform-support.html
+[WASI]: https://github.com/WebAssembly/WASI
+[Emscripten]: https://emscripten.org
+[opt-in]: #opt-in-backends
+
+[//]: # (licenses)
+
+[LICENSE-APACHE]: https://github.com/rust-random/getrandom/blob/master/LICENSE-APACHE
+[LICENSE-MIT]: https://github.com/rust-random/getrandom/blob/master/LICENSE-MIT
+
+[`Error::UNEXPECTED`]: https://docs.rs/getrandom/latest/getrandom/struct.Error.html#associatedconstant.UNEXPECTED
+[`fill_uninit`]: https://docs.rs/getrandom/latest/getrandom/fn.fill_uninit.html

data/ext/cargo-vendor/getrandom-0.3.3/src/backends/wasi_p1.rs

@@ -0,0 +1,32 @@
+//! Implementation for WASI Preview 1
+use crate::Error;
+use core::mem::MaybeUninit;
+
+pub use crate::util::{inner_u32, inner_u64};
+
+// This linking is vendored from the wasi crate:
+// https://docs.rs/wasi/0.11.0+wasi-snapshot-preview1/src/wasi/lib_generated.rs.html#2344-2350
+#[link(wasm_import_module = "wasi_snapshot_preview1")]
+extern "C" {
+    fn random_get(arg0: i32, arg1: i32) -> i32;
+}
+
+/// WASI p1 uses `u16` for error codes in its witx definitions:
+/// https://github.com/WebAssembly/WASI/blob/38454e9e/legacy/preview1/witx/typenames.witx#L34-L39
+const MAX_ERROR_CODE: i32 = u16::MAX as i32;
+
+#[inline]
+pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
+    // Based on the wasi code:
+    // https://docs.rs/wasi/0.11.0+wasi-snapshot-preview1/src/wasi/lib_generated.rs.html#2046-2062
+    // Note that size of an allocated object can not be bigger than isize::MAX bytes.
+    // WASI 0.1 supports only 32-bit WASM, so casting length to `i32` is safe.
+    #[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
+    let ret = unsafe { random_get(dest.as_mut_ptr() as i32, dest.len() as i32) };
+    match ret {
+        0 => Ok(()),
+        // WASI functions should return positive error codes which are smaller than `MAX_ERROR_CODE`
+        code if code <= MAX_ERROR_CODE => Err(Error::from_neg_error_code(-code)),
+        _ => Err(Error::UNEXPECTED),
+    }
+}

data/ext/cargo-vendor/getrandom-0.3.3/src/backends.rs

@@ -0,0 +1,181 @@
+//! System-specific implementations.
+//!
+//! This module should provide `fill_inner` with the signature
+//! `fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error>`.
+//! The function MUST fully initialize `dest` when `Ok(())` is returned.
+//! The function MUST NOT ever write uninitialized bytes into `dest`,
+//! regardless of what value it returns.
+
+cfg_if! {
+    if #[cfg(getrandom_backend = "custom")] {
+        mod custom;
+        pub use custom::*;
+    } else if #[cfg(getrandom_backend = "linux_getrandom")] {
+        mod getrandom;
+        pub use getrandom::*;
+    } else if #[cfg(getrandom_backend = "linux_raw")] {
+        mod linux_raw;
+        pub use linux_raw::*;
+    } else if #[cfg(getrandom_backend = "rdrand")] {
+        mod rdrand;
+        pub use rdrand::*;
+    } else if #[cfg(getrandom_backend = "rndr")] {
+        mod rndr;
+        pub use rndr::*;
+    } else if #[cfg(getrandom_backend = "efi_rng")] {
+        mod efi_rng;
+        pub use efi_rng::*;
+    } else if #[cfg(all(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(all(target_os = "linux", target_env = ""))] {
+        mod linux_raw;
+        pub use linux_raw::*;
+    } else if #[cfg(target_os = "espidf")] {
+        mod esp_idf;
+        pub use esp_idf::*;
+    } else if #[cfg(any(
+        target_os = "haiku",
+        target_os = "redox",
+        target_os = "nto",
+        target_os = "aix",
+    ))] {
+        mod use_file;
+        pub use use_file::*;
+    } else if #[cfg(any(
+        target_os = "macos",
+        target_os = "openbsd",
+        target_os = "vita",
+        target_os = "emscripten",
+    ))] {
+        mod getentropy;
+        pub use getentropy::*;
+    } else if #[cfg(any(
+        // Rust supports Android API level 19 (KitKat) [0] and the next upgrade targets
+        // level 21 (Lollipop) [1], while `getrandom(2)` was added only in
+        // level 23 (Marshmallow). Note that it applies only to the "old" `target_arch`es,
+        // RISC-V Android targets sufficiently new API level, same will apply for potential
+        // new Android `target_arch`es.
+        // [0]: https://blog.rust-lang.org/2023/01/09/android-ndk-update-r25.html
+        // [1]: https://github.com/rust-lang/rust/pull/120593
+        all(
+            target_os = "android",
+            any(
+                target_arch = "aarch64",
+                target_arch = "arm",
+                target_arch = "x86",
+                target_arch = "x86_64",
+            ),
+        ),
+        // Only on these `target_arch`es Rust supports Linux kernel versions (3.2+)
+        // that precede the version (3.17) in which `getrandom(2)` was added:
+        // https://doc.rust-lang.org/stable/rustc/platform-support.html
+        all(
+            target_os = "linux",
+            any(
+                target_arch = "aarch64",
+                target_arch = "arm",
+                target_arch = "powerpc",
+                target_arch = "powerpc64",
+                target_arch = "s390x",
+                target_arch = "x86",
+                target_arch = "x86_64",
+                // Minimum supported Linux kernel version for MUSL targets
+                // is not specified explicitly (as of Rust 1.77) and they
+                // are used in practice to target pre-3.17 kernels.
+                target_env = "musl",
+            ),
+        )
+    ))] {
+        mod use_file;
+        mod linux_android_with_fallback;
+        pub use linux_android_with_fallback::*;
+    } else if #[cfg(any(
+        target_os = "android",
+        target_os = "linux",
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "hurd",
+        target_os = "illumos",
+        target_os = "cygwin",
+        // Check for target_arch = "arm" to only include the 3DS. Does not
+        // include the Nintendo Switch (which is target_arch = "aarch64").
+        all(target_os = "horizon", target_arch = "arm"),
+    ))] {
+        mod getrandom;
+        pub use getrandom::*;
+    } else if #[cfg(target_os = "solaris")] {
+        mod solaris;
+        pub use solaris::*;
+    } else if #[cfg(target_os = "netbsd")] {
+        mod netbsd;
+        pub use netbsd::*;
+    } else if #[cfg(target_os = "fuchsia")] {
+        mod fuchsia;
+        pub use fuchsia::*;
+    } else if #[cfg(any(
+        target_os = "ios",
+        target_os = "visionos",
+        target_os = "watchos",
+        target_os = "tvos",
+    ))] {
+        mod apple_other;
+        pub use apple_other::*;
+    } else if #[cfg(all(target_arch = "wasm32", target_os = "wasi"))] {
+        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"
+                );
+            }
+        }
+    } else if #[cfg(target_os = "hermit")] {
+        mod hermit;
+        pub use hermit::*;
+    } else if #[cfg(target_os = "vxworks")] {
+        mod vxworks;
+        pub use vxworks::*;
+    } else if #[cfg(target_os = "solid_asp3")] {
+        mod solid;
+        pub use solid::*;
+    } else if #[cfg(all(windows, any(target_vendor = "win7", getrandom_windows_legacy)))] {
+        mod windows7;
+        pub use windows7::*;
+    } else if #[cfg(windows)] {
+        mod windows;
+        pub use windows::*;
+    } else if #[cfg(all(target_arch = "x86_64", target_env = "sgx"))] {
+        mod rdrand;
+        pub use rdrand::*;
+    } else if #[cfg(all(target_arch = "wasm32", any(target_os = "unknown", target_os = "none")))] {
+        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. \
+            For more information see: \
+            https://docs.rs/getrandom/", env!("CARGO_PKG_VERSION"), "/#webassembly-support"
+        ));
+    } else {
+        compile_error!(concat!(
+            "target is not supported. You may need to define a custom backend see: \
+            https://docs.rs/getrandom/", env!("CARGO_PKG_VERSION"), "/#custom-backend"
+        ));
+    }
+}

data/ext/cargo-vendor/glob-0.3.2/.cargo-checksum.json

@@ -1 +1 @@
-{"files":{"CHANGELOG.md":"1d58b475783a53a2c20c8682dd666c0b3d95e3923b85c5b03eb577762178ea90","Cargo.lock":"abbcb507bee36b2f435a6cd1fa25b222903d0cebd44c7eb3a44b1855b6d19d67","Cargo.toml":"b0fe646251875bd2b4ac71d55758fce1a58499a381d889cdec6c294064413410","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"6485b8ed310d3f0340bf1ad1f47645069ce4069dcc6bb46c7d5c6faf41de1fdb","README.md":"8f2d321242fc17deb4e61d9cfbaec7b68ff532e0f458190d01668b37e34bfc2f","src/lib.rs":"eceab024b44237b5960e6c3625a0449c15bcf8409fa52401c83d4287f2c0fbce","tests/glob-std.rs":"83bf0b8371190832e85ed1ab8a335df3d8c03fab529694577d722dd1a0a5f398","triagebot.toml":"a135e10c777cd13459559bdf74fb704c1379af7c9b0f70bc49fa6f5a837daa81"},"package":"a8d1add55171497b4705a648c6b583acafb01d58050a51727785f0b2c8e0a2b2"}
+{"files":{".cargo_vcs_info.json":"0e3229136abc236dd27db80fe6a6bec1c38a334d08bd49cd6fb11c0f0ab44740",".github/dependabot.yml":"8e93631a765d23b8eeabcf3c5da80c850f2cab429c4e5c2c8d81f562f522bb3c",".github/workflows/publish.yml":"1bfb8b9fb856e6dfeaf481d7a440071e3dc8248f32b5c63ef03cb285d7f10b6e",".github/workflows/rust.yml":"271fa6c79d90dafdd6376428048221dffb2275687a1b566378a3631d5a3c9903","CHANGELOG.md":"1d58b475783a53a2c20c8682dd666c0b3d95e3923b85c5b03eb577762178ea90","Cargo.lock":"abbcb507bee36b2f435a6cd1fa25b222903d0cebd44c7eb3a44b1855b6d19d67","Cargo.toml":"b0fe646251875bd2b4ac71d55758fce1a58499a381d889cdec6c294064413410","Cargo.toml.orig":"55c796a3ac0adc58a9deb8a79bac289681ce578500c5a5eba3a0e91b077fd0cd","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"6485b8ed310d3f0340bf1ad1f47645069ce4069dcc6bb46c7d5c6faf41de1fdb","README.md":"8f2d321242fc17deb4e61d9cfbaec7b68ff532e0f458190d01668b37e34bfc2f","src/lib.rs":"eceab024b44237b5960e6c3625a0449c15bcf8409fa52401c83d4287f2c0fbce","tests/glob-std.rs":"83bf0b8371190832e85ed1ab8a335df3d8c03fab529694577d722dd1a0a5f398","triagebot.toml":"a135e10c777cd13459559bdf74fb704c1379af7c9b0f70bc49fa6f5a837daa81"},"package":"a8d1add55171497b4705a648c6b583acafb01d58050a51727785f0b2c8e0a2b2"}

data/ext/cargo-vendor/glob-0.3.2/.cargo_vcs_info.json

@@ -0,0 +1,6 @@
+{
+  "git": {
+    "sha1": "58d0748ead23616834871fe42dce475102f8d895"
+  },
+  "path_in_vcs": ""
+}

data/ext/cargo-vendor/glob-0.3.2/.github/dependabot.yml

@@ -0,0 +1,13 @@
+version: 2
+updates:
+  - package-ecosystem: "cargo"
+    directory: "/"
+    schedule:
+      interval: "monthly"
+    open-pull-requests-limit: 10
+    ignore:
+      - dependency-name: "tempdir"
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "monthly"

data/ext/cargo-vendor/glob-0.3.2/.github/workflows/publish.yml

@@ -0,0 +1,27 @@
+name: Release-plz
+
+permissions:
+  pull-requests: write
+  contents: write
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  release-plz:
+    name: Release-plz
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Install Rust (rustup)
+        run: rustup update nightly --no-self-update && rustup default nightly
+      - name: Run release-plz
+        uses: MarcoIeni/release-plz-action@v0.5
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}