code_ownership 2.1.4 → 2.2.1

data/ext/cargo-vendor/getrandom-0.2.16/src/error.rs

@@ -1,189 +0,0 @@
-use core::{fmt, num::NonZeroU32};
-
-/// A small and `no_std` compatible error type
-///
-/// The [`Error::raw_os_error()`] will indicate if the error is from the OS, and
-/// if so, which error code the OS gave the application. If such an error is
-/// encountered, please consult with your system documentation.
-///
-/// Internally this type is a NonZeroU32, with certain values reserved for
-/// certain purposes, see [`Error::INTERNAL_START`] and [`Error::CUSTOM_START`].
-///
-/// *If this crate's `"std"` Cargo feature is enabled*, then:
-/// - [`getrandom::Error`][Error] implements
-///   [`std::error::Error`](https://doc.rust-lang.org/std/error/trait.Error.html)
-/// - [`std::io::Error`](https://doc.rust-lang.org/std/io/struct.Error.html) implements
-///   [`From<getrandom::Error>`](https://doc.rust-lang.org/std/convert/trait.From.html).
-#[derive(Copy, Clone, Eq, PartialEq)]
-pub struct Error(NonZeroU32);
-
-const fn internal_error(n: u16) -> Error {
-    // SAFETY: code > 0 as INTERNAL_START > 0 and adding n won't overflow a u32.
-    let code = Error::INTERNAL_START + (n as u32);
-    Error(unsafe { NonZeroU32::new_unchecked(code) })
-}
-
-impl Error {
-    /// This target/platform is not supported by `getrandom`.
-    pub const UNSUPPORTED: Error = internal_error(0);
-    /// The platform-specific `errno` returned a non-positive value.
-    pub const ERRNO_NOT_POSITIVE: Error = internal_error(1);
-    /// Encountered an unexpected situation which should not happen in practice.
-    pub const UNEXPECTED: Error = internal_error(2);
-    /// Call to [`CCRandomGenerateBytes`](https://opensource.apple.com/source/CommonCrypto/CommonCrypto-60074/include/CommonRandom.h.auto.html) failed
-    /// on iOS, tvOS, or waatchOS.
-    // TODO: Update this constant name in the next breaking release.
-    pub const IOS_SEC_RANDOM: Error = internal_error(3);
-    /// Call to Windows [`RtlGenRandom`](https://docs.microsoft.com/en-us/windows/win32/api/ntsecapi/nf-ntsecapi-rtlgenrandom) failed.
-    pub const WINDOWS_RTL_GEN_RANDOM: Error = internal_error(4);
-    /// RDRAND instruction failed due to a hardware issue.
-    pub const FAILED_RDRAND: Error = internal_error(5);
-    /// RDRAND instruction unsupported on this target.
-    pub const NO_RDRAND: Error = internal_error(6);
-    /// The environment does not support the Web Crypto API.
-    pub const WEB_CRYPTO: Error = internal_error(7);
-    /// Calling Web Crypto API `crypto.getRandomValues` failed.
-    pub const WEB_GET_RANDOM_VALUES: Error = internal_error(8);
-    /// On VxWorks, call to `randSecure` failed (random number generator is not yet initialized).
-    pub const VXWORKS_RAND_SECURE: Error = internal_error(11);
-    /// Node.js does not have the `crypto` CommonJS module.
-    pub const NODE_CRYPTO: Error = internal_error(12);
-    /// Calling Node.js function `crypto.randomFillSync` failed.
-    pub const NODE_RANDOM_FILL_SYNC: Error = internal_error(13);
-    /// Called from an ES module on Node.js. This is unsupported, see:
-    /// <https://docs.rs/getrandom#nodejs-es-module-support>.
-    pub const NODE_ES_MODULE: Error = internal_error(14);
-
-    /// Codes below this point represent OS Errors (i.e. positive i32 values).
-    /// Codes at or above this point, but below [`Error::CUSTOM_START`] are
-    /// reserved for use by the `rand` and `getrandom` crates.
-    pub const INTERNAL_START: u32 = 1 << 31;
-
-    /// Codes at or above this point can be used by users to define their own
-    /// custom errors.
-    pub const CUSTOM_START: u32 = (1 << 31) + (1 << 30);
-
-    /// Extract the raw OS error code (if this error came from the OS)
-    ///
-    /// This method is identical to [`std::io::Error::raw_os_error()`][1], except
-    /// that it works in `no_std` contexts. If this method returns `None`, the
-    /// error value can still be formatted via the `Display` implementation.
-    ///
-    /// [1]: https://doc.rust-lang.org/std/io/struct.Error.html#method.raw_os_error
-    #[inline]
-    pub fn raw_os_error(self) -> Option<i32> {
-        if self.0.get() < Self::INTERNAL_START {
-            match () {
-                #[cfg(target_os = "solid_asp3")]
-                // On SOLID, negate the error code again to obtain the original
-                // error code.
-                () => Some(-(self.0.get() as i32)),
-                #[cfg(not(target_os = "solid_asp3"))]
-                () => Some(self.0.get() as i32),
-            }
-        } else {
-            None
-        }
-    }
-
-    /// Extract the bare error code.
-    ///
-    /// This code can either come from the underlying OS, or be a custom error.
-    /// Use [`Error::raw_os_error()`] to disambiguate.
-    #[inline]
-    pub const fn code(self) -> NonZeroU32 {
-        self.0
-    }
-}
-
-cfg_if! {
-    if #[cfg(unix)] {
-        fn os_err(errno: i32, buf: &mut [u8]) -> Option<&str> {
-            let buf_ptr = buf.as_mut_ptr() as *mut libc::c_char;
-            if unsafe { libc::strerror_r(errno, buf_ptr, buf.len()) } != 0 {
-                return None;
-            }
-
-            // Take up to trailing null byte
-            let n = buf.len();
-            let idx = buf.iter().position(|&b| b == 0).unwrap_or(n);
-            core::str::from_utf8(&buf[..idx]).ok()
-        }
-    } else {
-        fn os_err(_errno: i32, _buf: &mut [u8]) -> Option<&str> {
-            None
-        }
-    }
-}
-
-impl fmt::Debug for Error {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut dbg = f.debug_struct("Error");
-        if let Some(errno) = self.raw_os_error() {
-            dbg.field("os_error", &errno);
-            let mut buf = [0u8; 128];
-            if let Some(err) = os_err(errno, &mut buf) {
-                dbg.field("description", &err);
-            }
-        } else if let Some(desc) = internal_desc(*self) {
-            dbg.field("internal_code", &self.0.get());
-            dbg.field("description", &desc);
-        } else {
-            dbg.field("unknown_code", &self.0.get());
-        }
-        dbg.finish()
-    }
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if let Some(errno) = self.raw_os_error() {
-            let mut buf = [0u8; 128];
-            match os_err(errno, &mut buf) {
-                Some(err) => err.fmt(f),
-                None => write!(f, "OS Error: {}", errno),
-            }
-        } else if let Some(desc) = internal_desc(*self) {
-            f.write_str(desc)
-        } else {
-            write!(f, "Unknown Error: {}", self.0.get())
-        }
-    }
-}
-
-impl From<NonZeroU32> for Error {
-    fn from(code: NonZeroU32) -> Self {
-        Self(code)
-    }
-}
-
-fn internal_desc(error: Error) -> Option<&'static str> {
-    match error {
-        Error::UNSUPPORTED => Some("getrandom: this target is not supported"),
-        Error::ERRNO_NOT_POSITIVE => Some("errno: did not return a positive value"),
-        Error::UNEXPECTED => Some("unexpected situation"),
-        Error::IOS_SEC_RANDOM => Some("SecRandomCopyBytes: iOS Security framework failure"),
-        Error::WINDOWS_RTL_GEN_RANDOM => Some("RtlGenRandom: Windows system function failure"),
-        Error::FAILED_RDRAND => Some("RDRAND: failed multiple times: CPU issue likely"),
-        Error::NO_RDRAND => Some("RDRAND: instruction not supported"),
-        Error::WEB_CRYPTO => Some("Web Crypto API is unavailable"),
-        Error::WEB_GET_RANDOM_VALUES => Some("Calling Web API crypto.getRandomValues failed"),
-        Error::VXWORKS_RAND_SECURE => Some("randSecure: VxWorks RNG module is not initialized"),
-        Error::NODE_CRYPTO => Some("Node.js crypto CommonJS module is unavailable"),
-        Error::NODE_RANDOM_FILL_SYNC => Some("Calling Node.js API crypto.randomFillSync failed"),
-        Error::NODE_ES_MODULE => Some("Node.js ES modules are not directly supported, see https://docs.rs/getrandom#nodejs-es-module-support"),
-        _ => None,
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Error;
-    use core::mem::size_of;
-
-    #[test]
-    fn test_size() {
-        assert_eq!(size_of::<Error>(), 4);
-        assert_eq!(size_of::<Result<(), Error>>(), 4);
-    }
-}

data/ext/cargo-vendor/getrandom-0.2.16/src/error_impls.rs

@@ -1,15 +0,0 @@
-extern crate std;
-
-use crate::Error;
-use std::io;
-
-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),
-        }
-    }
-}
-
-impl std::error::Error for Error {}

data/ext/cargo-vendor/getrandom-0.2.16/src/espidf.rs

@@ -1,18 +0,0 @@
-//! Implementation for ESP-IDF
-use crate::Error;
-use core::{ffi::c_void, mem::MaybeUninit};
-
-extern "C" {
-    fn esp_fill_random(buf: *mut c_void, len: usize) -> u32;
-}
-
-pub fn getrandom_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
-    // Not that NOT enabling WiFi, BT, or the voltage noise entropy source (via `bootloader_random_enable`)
-    // will cause ESP-IDF to return pseudo-random numbers based on the voltage noise entropy, after the initial boot process:
-    // https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/system/random.html
-    //
-    // However tracking if some of these entropy sources is enabled is way too difficult to implement here
-    unsafe { esp_fill_random(dest.as_mut_ptr().cast(), dest.len()) };
-
-    Ok(())
-}

data/ext/cargo-vendor/getrandom-0.2.16/src/fuchsia.rs

@@ -1,13 +0,0 @@
-//! Implementation for Fuchsia Zircon
-use crate::Error;
-use core::mem::MaybeUninit;
-
-#[link(name = "zircon")]
-extern "C" {
-    fn zx_cprng_draw(buffer: *mut u8, length: usize);
-}
-
-pub fn getrandom_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
-    unsafe { zx_cprng_draw(dest.as_mut_ptr() as *mut u8, dest.len()) }
-    Ok(())
-}

data/ext/cargo-vendor/getrandom-0.2.16/src/getentropy.rs

@@ -1,21 +0,0 @@
-//! Implementation using getentropy(2)
-//!
-//! Available since:
-//!   - macOS 10.12
-//!   - OpenBSD 5.6
-//!   - Emscripten 2.0.5
-//!   - vita newlib since Dec 2021
-//!
-//! For these targets, we use getentropy(2) because getrandom(2) doesn't exist.
-use crate::{util_libc::last_os_error, Error};
-use core::mem::MaybeUninit;
-
-pub fn getrandom_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
-    for chunk in dest.chunks_mut(256) {
-        let ret = unsafe { libc::getentropy(chunk.as_mut_ptr() as *mut libc::c_void, chunk.len()) };
-        if ret != 0 {
-            return Err(last_os_error());
-        }
-    }
-    Ok(())
-}

data/ext/cargo-vendor/getrandom-0.2.16/src/getrandom.rs

@@ -1,25 +0,0 @@
-//! Implementation using getrandom(2).
-//!
-//! Available since:
-//!   - Linux Kernel 3.17, Glibc 2.25, Musl 1.1.20
-//!   - Android API level 23 (Marshmallow)
-//!   - NetBSD 10.0
-//!   - FreeBSD 12.0
-//!   - illumos since Dec 2018
-//!   - DragonFly 5.7
-//!   - Hurd Glibc 2.31
-//!   - shim-3ds since Feb 2022
-//!
-//! For these platforms, we always use the default pool and never set the
-//! GRND_RANDOM flag to use the /dev/random pool. On Linux/Android/Hurd, using
-//! GRND_RANDOM is not recommended. On NetBSD/FreeBSD/Dragonfly/3ds, it does
-//! nothing. On illumos, the default pool is used to implement getentropy(2),
-//! so we assume it is acceptable here.
-use crate::{util_libc::sys_fill_exact, Error};
-use core::mem::MaybeUninit;
-
-pub fn getrandom_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
-    sys_fill_exact(dest, |buf| unsafe {
-        libc::getrandom(buf.as_mut_ptr() as *mut libc::c_void, buf.len(), 0)
-    })
-}

data/ext/cargo-vendor/getrandom-0.2.16/src/hermit.rs

@@ -1,29 +0,0 @@
-//! Implementation for Hermit
-use crate::Error;
-use core::{mem::MaybeUninit, num::NonZeroU32};
-
-/// Minimum return value which we should get from syscalls in practice,
-/// because Hermit uses positive `i32`s for error codes:
-/// https://github.com/hermitcore/libhermit-rs/blob/main/src/errno.rs
-const MIN_RET_CODE: isize = -(i32::MAX as isize);
-
-extern "C" {
-    fn sys_read_entropy(buffer: *mut u8, length: usize, flags: u32) -> isize;
-}
-
-pub fn getrandom_inner(mut dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
-    while !dest.is_empty() {
-        let res = unsafe { sys_read_entropy(dest.as_mut_ptr() as *mut u8, dest.len(), 0) };
-        // Positive `isize`s can be safely casted to `usize`
-        if res > 0 && (res as usize) <= dest.len() {
-            dest = &mut dest[res as usize..];
-        } else {
-            let err = match res {
-                MIN_RET_CODE..=-1 => NonZeroU32::new(-res as u32).unwrap().into(),
-                _ => Error::UNEXPECTED,
-            };
-            return Err(err);
-        }
-    }
-    Ok(())
-}

data/ext/cargo-vendor/getrandom-0.2.16/src/js.rs

@@ -1,155 +0,0 @@
-//! Implementation for WASM based on Web and Node.js
-use crate::Error;
-
-extern crate std;
-use std::{mem::MaybeUninit, thread_local};
-
-use js_sys::{global, Function, Uint8Array};
-use wasm_bindgen::{prelude::wasm_bindgen, JsCast, JsValue};
-
-// Size of our temporary Uint8Array buffer used with WebCrypto methods
-// Maximum is 65536 bytes see https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues
-const WEB_CRYPTO_BUFFER_SIZE: usize = 256;
-// Node.js's crypto.randomFillSync requires the size to be less than 2**31.
-const NODE_MAX_BUFFER_SIZE: usize = (1 << 31) - 1;
-
-enum RngSource {
-    Node(NodeCrypto),
-    Web(WebCrypto, Uint8Array),
-}
-
-// JsValues are always per-thread, so we initialize RngSource for each thread.
-//   See: https://github.com/rustwasm/wasm-bindgen/pull/955
-thread_local!(
-    static RNG_SOURCE: Result<RngSource, Error> = getrandom_init();
-);
-
-pub(crate) fn getrandom_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
-    RNG_SOURCE.with(|result| {
-        let source = result.as_ref().map_err(|&e| e)?;
-
-        match source {
-            RngSource::Node(n) => {
-                for chunk in dest.chunks_mut(NODE_MAX_BUFFER_SIZE) {
-                    // SAFETY: chunk is never used directly, the memory is only
-                    // modified via the Uint8Array view, which is passed
-                    // directly to JavaScript. Also, crypto.randomFillSync does
-                    // not resize the buffer. We know the length is less than
-                    // u32::MAX because of the chunking above.
-                    // Note that this uses the fact that JavaScript doesn't
-                    // have a notion of "uninitialized memory", this is purely
-                    // a Rust/C/C++ concept.
-                    let res = n.random_fill_sync(unsafe {
-                        Uint8Array::view_mut_raw(chunk.as_mut_ptr() as *mut u8, chunk.len())
-                    });
-                    if res.is_err() {
-                        return Err(Error::NODE_RANDOM_FILL_SYNC);
-                    }
-                }
-            }
-            RngSource::Web(crypto, buf) => {
-                // getRandomValues does not work with all types of WASM memory,
-                // so we initially write to browser memory to avoid exceptions.
-                for chunk in dest.chunks_mut(WEB_CRYPTO_BUFFER_SIZE) {
-                    // The chunk can be smaller than buf's length, so we call to
-                    // JS to create a smaller view of buf without allocation.
-                    let sub_buf = buf.subarray(0, chunk.len() as u32);
-
-                    if crypto.get_random_values(&sub_buf).is_err() {
-                        return Err(Error::WEB_GET_RANDOM_VALUES);
-                    }
-
-                    // SAFETY: `sub_buf`'s length is the same length as `chunk`
-                    unsafe { sub_buf.raw_copy_to_ptr(chunk.as_mut_ptr() as *mut u8) };
-                }
-            }
-        };
-        Ok(())
-    })
-}
-
-fn getrandom_init() -> Result<RngSource, Error> {
-    let global: Global = global().unchecked_into();
-
-    // Get the Web Crypto interface if we are in a browser, Web Worker, Deno,
-    // or another environment that supports the Web Cryptography API. This
-    // also allows for user-provided polyfills in unsupported environments.
-    let crypto = match global.crypto() {
-        // Standard Web Crypto interface
-        c if c.is_object() => c,
-        // Node.js CommonJS Crypto module
-        _ if is_node(&global) => {
-            // If module.require isn't a valid function, we are in an ES module.
-            match Module::require_fn().and_then(JsCast::dyn_into::<Function>) {
-                Ok(require_fn) => match require_fn.call1(&global, &JsValue::from_str("crypto")) {
-                    Ok(n) => return Ok(RngSource::Node(n.unchecked_into())),
-                    Err(_) => return Err(Error::NODE_CRYPTO),
-                },
-                Err(_) => return Err(Error::NODE_ES_MODULE),
-            }
-        }
-        // IE 11 Workaround
-        _ => match global.ms_crypto() {
-            c if c.is_object() => c,
-            _ => return Err(Error::WEB_CRYPTO),
-        },
-    };
-
-    let buf = Uint8Array::new_with_length(WEB_CRYPTO_BUFFER_SIZE as u32);
-    Ok(RngSource::Web(crypto, buf))
-}
-
-// Taken from https://www.npmjs.com/package/browser-or-node
-fn is_node(global: &Global) -> bool {
-    let process = global.process();
-    if process.is_object() {
-        let versions = process.versions();
-        if versions.is_object() {
-            return versions.node().is_string();
-        }
-    }
-    false
-}
-
-#[wasm_bindgen]
-extern "C" {
-    // Return type of js_sys::global()
-    type Global;
-
-    // Web Crypto API: Crypto interface (https://www.w3.org/TR/WebCryptoAPI/)
-    type WebCrypto;
-    // Getters for the WebCrypto API
-    #[wasm_bindgen(method, getter)]
-    fn crypto(this: &Global) -> WebCrypto;
-    #[wasm_bindgen(method, getter, js_name = msCrypto)]
-    fn ms_crypto(this: &Global) -> WebCrypto;
-    // Crypto.getRandomValues()
-    #[wasm_bindgen(method, js_name = getRandomValues, catch)]
-    fn get_random_values(this: &WebCrypto, buf: &Uint8Array) -> Result<(), JsValue>;
-
-    // Node JS crypto module (https://nodejs.org/api/crypto.html)
-    type NodeCrypto;
-    // crypto.randomFillSync()
-    #[wasm_bindgen(method, js_name = randomFillSync, catch)]
-    fn random_fill_sync(this: &NodeCrypto, buf: Uint8Array) -> Result<(), JsValue>;
-
-    // Ideally, we would just use `fn require(s: &str)` here. However, doing
-    // this causes a Webpack warning. So we instead return the function itself
-    // and manually invoke it using call1. This also lets us to check that the
-    // function actually exists, allowing for better error messages. See:
-    //   https://github.com/rust-random/getrandom/issues/224
-    //   https://github.com/rust-random/getrandom/issues/256
-    type Module;
-    #[wasm_bindgen(getter, static_method_of = Module, js_class = module, js_name = require, catch)]
-    fn require_fn() -> Result<JsValue, JsValue>;
-
-    // Node JS process Object (https://nodejs.org/api/process.html)
-    #[wasm_bindgen(method, getter)]
-    fn process(this: &Global) -> Process;
-    type Process;
-    #[wasm_bindgen(method, getter)]
-    fn versions(this: &Process) -> Versions;
-    type Versions;
-    #[wasm_bindgen(method, getter)]
-    fn node(this: &Versions) -> JsValue;
-}

data/ext/cargo-vendor/getrandom-0.2.16/src/lazy.rs

@@ -1,56 +0,0 @@
-use core::sync::atomic::{AtomicUsize, Ordering::Relaxed};
-
-// 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.
-pub(crate) struct LazyUsize(AtomicUsize);
-
-impl LazyUsize {
-    pub const fn new() -> Self {
-        Self(AtomicUsize::new(Self::UNINIT))
-    }
-
-    // The initialization is not completed.
-    pub const UNINIT: usize = usize::max_value();
-
-    // 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.
-    pub fn unsync_init(&self, init: impl FnOnce() -> usize) -> usize {
-        // Relaxed ordering is fine, as we only have a single atomic variable.
-        let mut val = self.0.load(Relaxed);
-        if val == Self::UNINIT {
-            val = init();
-            self.0.store(val, Relaxed);
-        }
-        val
-    }
-}
-
-// 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(|| init() as usize) != 0
-    }
-}