code_ownership 2.1.4 → 2.2.1

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

@@ -1,120 +0,0 @@
-//! Implementations that just need to read from a file
-use crate::{
-    util_libc::{open_readonly, sys_fill_exact},
-    Error,
-};
-use core::{
-    cell::UnsafeCell,
-    mem::MaybeUninit,
-    sync::atomic::{AtomicUsize, Ordering::Relaxed},
-};
-
-/// For all platforms, we use `/dev/urandom` rather than `/dev/random`.
-/// For more information see the linked man pages in lib.rs.
-///   - On Linux, "/dev/urandom is preferred and sufficient in all use cases".
-///   - On Redox, only /dev/urandom is provided.
-///   - On AIX, /dev/urandom will "provide cryptographically secure output".
-///   - On Haiku and QNX Neutrino they are identical.
-const FILE_PATH: &str = "/dev/urandom\0";
-const FD_UNINIT: usize = usize::max_value();
-
-pub fn getrandom_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
-    let fd = get_rng_fd()?;
-    sys_fill_exact(dest, |buf| unsafe {
-        libc::read(fd, buf.as_mut_ptr() as *mut libc::c_void, buf.len())
-    })
-}
-
-// Returns the file descriptor for the device file used to retrieve random
-// bytes. The file will be opened exactly once. All subsequent calls will
-// return the same file descriptor. This file descriptor is never closed.
-fn get_rng_fd() -> Result<libc::c_int, Error> {
-    static FD: AtomicUsize = AtomicUsize::new(FD_UNINIT);
-    fn get_fd() -> Option<libc::c_int> {
-        match FD.load(Relaxed) {
-            FD_UNINIT => None,
-            val => Some(val as libc::c_int),
-        }
-    }
-
-    // Use double-checked locking to avoid acquiring the lock if possible.
-    if let Some(fd) = get_fd() {
-        return Ok(fd);
-    }
-
-    // SAFETY: We use the mutex only in this method, and we always unlock it
-    // before returning, making sure we don't violate the pthread_mutex_t API.
-    static MUTEX: Mutex = Mutex::new();
-    unsafe { MUTEX.lock() };
-    let _guard = DropGuard(|| unsafe { MUTEX.unlock() });
-
-    if let Some(fd) = get_fd() {
-        return Ok(fd);
-    }
-
-    // On Linux, /dev/urandom might return insecure values.
-    #[cfg(any(target_os = "android", target_os = "linux"))]
-    wait_until_rng_ready()?;
-
-    let fd = unsafe { open_readonly(FILE_PATH)? };
-    // The fd always fits in a usize without conflicting with FD_UNINIT.
-    debug_assert!(fd >= 0 && (fd as usize) < FD_UNINIT);
-    FD.store(fd as usize, Relaxed);
-
-    Ok(fd)
-}
-
-// Succeeds once /dev/urandom is safe to read from
-#[cfg(any(target_os = "android", target_os = "linux"))]
-fn wait_until_rng_ready() -> Result<(), Error> {
-    // Poll /dev/random to make sure it is ok to read from /dev/urandom.
-    let fd = unsafe { open_readonly("/dev/random\0")? };
-    let mut pfd = libc::pollfd {
-        fd,
-        events: libc::POLLIN,
-        revents: 0,
-    };
-    let _guard = DropGuard(|| unsafe {
-        libc::close(fd);
-    });
-
-    loop {
-        // A negative timeout means an infinite timeout.
-        let res = unsafe { libc::poll(&mut pfd, 1, -1) };
-        if res >= 0 {
-            debug_assert_eq!(res, 1); // We only used one fd, and cannot timeout.
-            return Ok(());
-        }
-        let err = crate::util_libc::last_os_error();
-        match err.raw_os_error() {
-            Some(libc::EINTR) | Some(libc::EAGAIN) => continue,
-            _ => return Err(err),
-        }
-    }
-}
-
-struct Mutex(UnsafeCell<libc::pthread_mutex_t>);
-
-impl Mutex {
-    const fn new() -> Self {
-        Self(UnsafeCell::new(libc::PTHREAD_MUTEX_INITIALIZER))
-    }
-    unsafe fn lock(&self) {
-        let r = libc::pthread_mutex_lock(self.0.get());
-        debug_assert_eq!(r, 0);
-    }
-    unsafe fn unlock(&self) {
-        let r = libc::pthread_mutex_unlock(self.0.get());
-        debug_assert_eq!(r, 0);
-    }
-}
-
-unsafe impl Sync for Mutex {}
-
-struct DropGuard<F: FnMut()>(F);
-
-impl<F: FnMut()> Drop for DropGuard<F> {
-    fn drop(&mut self) {
-        self.0()
-    }
-}

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

@@ -1,35 +0,0 @@
-#![allow(dead_code)]
-use core::{mem::MaybeUninit, ptr};
-
-/// Polyfill for `maybe_uninit_slice` feature's
-/// `MaybeUninit::slice_assume_init_mut`. Every element of `slice` must have
-/// been initialized.
-#[inline(always)]
-pub unsafe fn slice_assume_init_mut<T>(slice: &mut [MaybeUninit<T>]) -> &mut [T] {
-    // SAFETY: `MaybeUninit<T>` is guaranteed to be layout-compatible with `T`.
-    &mut *(slice as *mut [MaybeUninit<T>] as *mut [T])
-}
-
-#[inline]
-pub fn uninit_slice_fill_zero(slice: &mut [MaybeUninit<u8>]) -> &mut [u8] {
-    unsafe { ptr::write_bytes(slice.as_mut_ptr(), 0, slice.len()) };
-    unsafe { slice_assume_init_mut(slice) }
-}
-
-#[inline(always)]
-pub fn slice_as_uninit<T>(slice: &[T]) -> &[MaybeUninit<T>] {
-    // SAFETY: `MaybeUninit<T>` is guaranteed to be layout-compatible with `T`.
-    // There is no risk of writing a `MaybeUninit<T>` into the result since
-    // the result isn't mutable.
-    unsafe { &*(slice as *const [T] as *const [MaybeUninit<T>]) }
-}
-
-/// View an mutable initialized array as potentially-uninitialized.
-///
-/// This is unsafe because it allows assigning uninitialized values into
-/// `slice`, which would be undefined behavior.
-#[inline(always)]
-pub unsafe fn slice_as_uninit_mut<T>(slice: &mut [T]) -> &mut [MaybeUninit<T>] {
-    // SAFETY: `MaybeUninit<T>` is guaranteed to be layout-compatible with `T`.
-    &mut *(slice as *mut [T] as *mut [MaybeUninit<T>])
-}

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

@@ -1,162 +0,0 @@
-#![allow(dead_code)]
-use crate::Error;
-use core::{
-    mem::MaybeUninit,
-    num::NonZeroU32,
-    ptr::NonNull,
-    sync::atomic::{fence, AtomicPtr, Ordering},
-};
-use libc::c_void;
-
-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(any(target_os = "solaris", 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"))] {
-        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;
-    }
-}
-
-cfg_if! {
-    if #[cfg(target_os = "vxworks")] {
-        use libc::errnoGet as get_errno;
-    } else {
-        unsafe fn get_errno() -> libc::c_int { *errno_location() }
-    }
-}
-
-pub fn last_os_error() -> Error {
-    let errno = unsafe { get_errno() };
-    if errno > 0 {
-        Error::from(NonZeroU32::new(errno as u32).unwrap())
-    } else {
-        Error::ERRNO_NOT_POSITIVE
-    }
-}
-
-// Fill a buffer by repeatedly invoking a system call. The `sys_fill` function:
-//   - should return -1 and set errno on failure
-//   - should return the number of bytes written on success
-pub 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 => buf = buf.get_mut(res as usize..).ok_or(Error::UNEXPECTED)?,
-            -1 => {
-                let err = last_os_error();
-                // We should try again if the call was interrupted.
-                if err.raw_os_error() != Some(libc::EINTR) {
-                    return Err(err);
-                }
-            }
-            // 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(())
-}
-
-// A "weak" binding to a C function that may or may not be present at runtime.
-// Used for supporting newer OS features while still building on older systems.
-// Based off of the DlsymWeak struct in libstd:
-// https://github.com/rust-lang/rust/blob/1.61.0/library/std/src/sys/unix/weak.rs#L84
-// except that the caller must manually cast self.ptr() to a function pointer.
-pub struct Weak {
-    name: &'static str,
-    addr: AtomicPtr<c_void>,
-}
-
-impl Weak {
-    // A non-null pointer value which indicates we are uninitialized. This
-    // constant should ideally not be a valid address of a function pointer.
-    // However, if by chance libc::dlsym does return UNINIT, there will not
-    // be undefined behavior. libc::dlsym will just be called each time ptr()
-    // is called. This would be inefficient, but correct.
-    // TODO: Replace with core::ptr::invalid_mut(1) when that is stable.
-    const UNINIT: *mut c_void = 1 as *mut c_void;
-
-    // Construct a binding to a C function with a given name. This function is
-    // unsafe because `name` _must_ be null terminated.
-    pub const unsafe fn new(name: &'static str) -> Self {
-        Self {
-            name,
-            addr: AtomicPtr::new(Self::UNINIT),
-        }
-    }
-
-    // Return the address of a function if present at runtime. Otherwise,
-    // return None. Multiple callers can call ptr() concurrently. It will
-    // always return _some_ value returned by libc::dlsym. However, the
-    // dlsym function may be called multiple times.
-    pub fn ptr(&self) -> Option<NonNull<c_void>> {
-        // Despite having only a single atomic variable (self.addr), we still
-        // cannot always use Ordering::Relaxed, as we need to make sure a
-        // successful call to dlsym() is "ordered before" any data read through
-        // the returned pointer (which occurs when the function is called).
-        // Our implementation mirrors that of the one in libstd, meaning that
-        // the use of non-Relaxed operations is probably unnecessary.
-        match self.addr.load(Ordering::Relaxed) {
-            Self::UNINIT => {
-                let symbol = self.name.as_ptr() as *const _;
-                let addr = unsafe { libc::dlsym(libc::RTLD_DEFAULT, symbol) };
-                // Synchronizes with the Acquire fence below
-                self.addr.store(addr, Ordering::Release);
-                NonNull::new(addr)
-            }
-            addr => {
-                let func = NonNull::new(addr)?;
-                fence(Ordering::Acquire);
-                Some(func)
-            }
-        }
-    }
-}
-
-// SAFETY: path must be null terminated, FD must be manually closed.
-pub unsafe fn open_readonly(path: &str) -> Result<libc::c_int, Error> {
-    debug_assert_eq!(path.as_bytes().last(), Some(&0));
-    loop {
-        let fd = libc::open(path.as_ptr() as *const _, libc::O_RDONLY | libc::O_CLOEXEC);
-        if fd >= 0 {
-            return Ok(fd);
-        }
-        let err = last_os_error();
-        // We should try again if open() was interrupted.
-        if err.raw_os_error() != Some(libc::EINTR) {
-            return Err(err);
-        }
-    }
-}
-
-/// Thin wrapper around the `getrandom()` Linux system call
-#[cfg(any(target_os = "android", target_os = "linux"))]
-pub fn getrandom_syscall(buf: &mut [MaybeUninit<u8>]) -> libc::ssize_t {
-    unsafe {
-        libc::syscall(
-            libc::SYS_getrandom,
-            buf.as_mut_ptr() as *mut libc::c_void,
-            buf.len(),
-            0,
-        ) as libc::ssize_t
-    }
-}

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

@@ -1,29 +0,0 @@
-//! Implementation for VxWorks
-use crate::{util_libc::last_os_error, Error};
-use core::{
-    mem::MaybeUninit,
-    sync::atomic::{AtomicBool, Ordering::Relaxed},
-};
-
-pub fn getrandom_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
-    static RNG_INIT: AtomicBool = AtomicBool::new(false);
-    while !RNG_INIT.load(Relaxed) {
-        let ret = unsafe { libc::randSecure() };
-        if ret < 0 {
-            return Err(Error::VXWORKS_RAND_SECURE);
-        } else if ret > 0 {
-            RNG_INIT.store(true, Relaxed);
-            break;
-        }
-        unsafe { libc::usleep(10) };
-    }
-
-    // Prevent overflow of i32
-    for chunk in dest.chunks_mut(i32::max_value() as usize) {
-        let ret = unsafe { libc::randABytes(chunk.as_mut_ptr() as *mut u8, chunk.len() as i32) };
-        if ret != 0 {
-            return Err(last_os_error());
-        }
-    }
-    Ok(())
-}

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

@@ -1,17 +0,0 @@
-//! Implementation for WASI
-use crate::Error;
-use core::{
-    mem::MaybeUninit,
-    num::{NonZeroU16, NonZeroU32},
-};
-use wasi::random_get;
-
-pub fn getrandom_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
-    unsafe { random_get(dest.as_mut_ptr() as *mut u8, dest.len()) }.map_err(|e| {
-        // The WASI errno will always be non-zero, but we check just in case.
-        match NonZeroU16::new(e.raw()) {
-            Some(r) => Error::from(NonZeroU32::from(r)),
-            None => Error::ERRNO_NOT_POSITIVE,
-        }
-    })
-}

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

@@ -1,59 +0,0 @@
-//! Implementation for Windows
-use crate::Error;
-use core::{ffi::c_void, mem::MaybeUninit, num::NonZeroU32, ptr};
-
-const BCRYPT_USE_SYSTEM_PREFERRED_RNG: u32 = 0x00000002;
-
-#[link(name = "bcrypt")]
-extern "system" {
-    fn BCryptGenRandom(
-        hAlgorithm: *mut c_void,
-        pBuffer: *mut u8,
-        cbBuffer: u32,
-        dwFlags: u32,
-    ) -> u32;
-}
-
-// Forbidden when targetting UWP
-#[cfg(not(target_vendor = "uwp"))]
-#[link(name = "advapi32")]
-extern "system" {
-    #[link_name = "SystemFunction036"]
-    fn RtlGenRandom(RandomBuffer: *mut c_void, RandomBufferLength: u32) -> u8;
-}
-
-pub fn getrandom_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
-    // Prevent overflow of u32
-    for chunk in dest.chunks_mut(u32::max_value() as usize) {
-        // BCryptGenRandom was introduced in Windows Vista
-        let ret = unsafe {
-            BCryptGenRandom(
-                ptr::null_mut(),
-                chunk.as_mut_ptr() as *mut u8,
-                chunk.len() as u32,
-                BCRYPT_USE_SYSTEM_PREFERRED_RNG,
-            )
-        };
-        // NTSTATUS codes use the two highest bits for severity status.
-        if ret >> 30 == 0b11 {
-            // Failed. Try RtlGenRandom as a fallback.
-            #[cfg(not(target_vendor = "uwp"))]
-            {
-                let ret =
-                    unsafe { RtlGenRandom(chunk.as_mut_ptr() as *mut c_void, chunk.len() as u32) };
-                if ret != 0 {
-                    continue;
-                }
-            }
-            // We zeroize the highest bit, so the error code will reside
-            // inside the range designated for OS codes.
-            let code = ret ^ (1 << 31);
-            // SAFETY: the second highest bit is always equal to one,
-            // so it's impossible to get zero. Unfortunately the type
-            // system does not have a way to express this yet.
-            let code = unsafe { NonZeroU32::new_unchecked(code) };
-            return Err(Error::from(code));
-        }
-    }
-    Ok(())
-}

data/ext/cargo-vendor/getrandom-0.2.16/tests/common/mod.rs

@@ -1,100 +0,0 @@
-use super::getrandom_impl;
-
-#[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
-use wasm_bindgen_test::wasm_bindgen_test as test;
-
-#[cfg(feature = "test-in-browser")]
-wasm_bindgen_test::wasm_bindgen_test_configure!(run_in_browser);
-
-#[test]
-fn test_zero() {
-    // Test that APIs are happy with zero-length requests
-    getrandom_impl(&mut [0u8; 0]).unwrap();
-}
-
-// Return the number of bits in which s1 and s2 differ
-#[cfg(not(feature = "custom"))]
-fn num_diff_bits(s1: &[u8], s2: &[u8]) -> usize {
-    assert_eq!(s1.len(), s2.len());
-    s1.iter()
-        .zip(s2.iter())
-        .map(|(a, b)| (a ^ b).count_ones() as usize)
-        .sum()
-}
-
-// Tests the quality of calling getrandom on two large buffers
-#[test]
-#[cfg(not(feature = "custom"))]
-fn test_diff() {
-    let mut v1 = [0u8; 1000];
-    getrandom_impl(&mut v1).unwrap();
-
-    let mut v2 = [0u8; 1000];
-    getrandom_impl(&mut v2).unwrap();
-
-    // Between 3.5 and 4.5 bits per byte should differ. Probability of failure:
-    // ~ 2^(-94) = 2 * CDF[BinomialDistribution[8000, 0.5], 3500]
-    let d = num_diff_bits(&v1, &v2);
-    assert!(d > 3500);
-    assert!(d < 4500);
-}
-
-// Tests the quality of calling getrandom repeatedly on small buffers
-#[test]
-#[cfg(not(feature = "custom"))]
-fn test_small() {
-    // For each buffer size, get at least 256 bytes and check that between
-    // 3 and 5 bits per byte differ. Probability of failure:
-    // ~ 2^(-91) = 64 * 2 * CDF[BinomialDistribution[8*256, 0.5], 3*256]
-    for size in 1..=64 {
-        let mut num_bytes = 0;
-        let mut diff_bits = 0;
-        while num_bytes < 256 {
-            let mut s1 = vec![0u8; size];
-            getrandom_impl(&mut s1).unwrap();
-            let mut s2 = vec![0u8; size];
-            getrandom_impl(&mut s2).unwrap();
-
-            num_bytes += size;
-            diff_bits += num_diff_bits(&s1, &s2);
-        }
-        assert!(diff_bits > 3 * num_bytes);
-        assert!(diff_bits < 5 * num_bytes);
-    }
-}
-
-#[test]
-fn test_huge() {
-    let mut huge = [0u8; 100_000];
-    getrandom_impl(&mut huge).unwrap();
-}
-
-// On WASM, the thread API always fails/panics
-#[cfg(not(target_arch = "wasm32"))]
-#[test]
-fn test_multithreading() {
-    extern crate std;
-    use std::{sync::mpsc::channel, thread, vec};
-
-    let mut txs = vec![];
-    for _ in 0..20 {
-        let (tx, rx) = channel();
-        txs.push(tx);
-
-        thread::spawn(move || {
-            // wait until all the tasks are ready to go.
-            rx.recv().unwrap();
-            let mut v = [0u8; 1000];
-
-            for _ in 0..100 {
-                getrandom_impl(&mut v).unwrap();
-                thread::yield_now();
-            }
-        });
-    }
-
-    // start all the tasks
-    for tx in txs.iter() {
-        tx.send(()).unwrap();
-    }
-}

data/ext/cargo-vendor/getrandom-0.2.16/tests/custom.rs

@@ -1,54 +0,0 @@
-// Test that a custom handler works on wasm32-unknown-unknown
-#![cfg(all(
-    target_arch = "wasm32",
-    target_os = "unknown",
-    feature = "custom",
-    not(feature = "js")
-))]
-
-use wasm_bindgen_test::wasm_bindgen_test as test;
-
-use core::num::NonZeroU32;
-use getrandom::{getrandom, register_custom_getrandom, Error};
-
-fn len7_err() -> Error {
-    NonZeroU32::new(Error::INTERNAL_START + 7).unwrap().into()
-}
-
-fn super_insecure_rng(buf: &mut [u8]) -> Result<(), Error> {
-    // `getrandom` guarantees it will not call any implementation if the output
-    // buffer is empty.
-    assert!(!buf.is_empty());
-    // Length 7 buffers return a custom error
-    if buf.len() == 7 {
-        return Err(len7_err());
-    }
-    // Otherwise, fill bytes based on input length
-    let mut start = buf.len() as u8;
-    for b in buf {
-        *b = start;
-        start = start.wrapping_mul(3);
-    }
-    Ok(())
-}
-
-register_custom_getrandom!(super_insecure_rng);
-
-use getrandom::getrandom as getrandom_impl;
-mod common;
-
-#[test]
-fn custom_rng_output() {
-    let mut buf = [0u8; 4];
-    assert_eq!(getrandom(&mut buf), Ok(()));
-    assert_eq!(buf, [4, 12, 36, 108]);
-
-    let mut buf = [0u8; 3];
-    assert_eq!(getrandom(&mut buf), Ok(()));
-    assert_eq!(buf, [3, 9, 27]);
-}
-
-#[test]
-fn rng_err_output() {
-    assert_eq!(getrandom(&mut [0; 7]), Err(len7_err()));
-}

data/ext/cargo-vendor/getrandom-0.2.16/tests/normal.rs

@@ -1,11 +0,0 @@
-// Don't test on custom wasm32-unknown-unknown
-#![cfg(not(all(
-    target_arch = "wasm32",
-    target_os = "unknown",
-    feature = "custom",
-    not(feature = "js")
-)))]
-
-// Use the normal getrandom implementation on this architecture.
-use getrandom::getrandom as getrandom_impl;
-mod common;

data/ext/cargo-vendor/getrandom-0.2.16/tests/rdrand.rs

@@ -1,22 +0,0 @@
-// We only test the RDRAND-based RNG source on supported architectures.
-#![cfg(any(target_arch = "x86_64", target_arch = "x86"))]
-
-// rdrand.rs expects to be part of the getrandom main crate, so we need these
-// additional imports to get rdrand.rs to compile.
-use getrandom::Error;
-#[macro_use]
-extern crate cfg_if;
-#[path = "../src/lazy.rs"]
-mod lazy;
-#[path = "../src/rdrand.rs"]
-mod rdrand;
-#[path = "../src/util.rs"]
-mod util;
-
-// The rdrand implementation has the signature of getrandom_uninit(), but our
-// tests expect getrandom_impl() to have the signature of getrandom().
-fn getrandom_impl(dest: &mut [u8]) -> Result<(), Error> {
-    rdrand::getrandom_inner(unsafe { util::slice_as_uninit_mut(dest) })?;
-    Ok(())
-}
-mod common;

data/ext/cargo-vendor/hashbrown-0.12.3/.cargo-checksum.json

@@ -1 +0,0 @@
-{"$comment":"This file only protects against accidental modifications. It is not a security mechanism and does not protect against malicious changes.","files":{".cargo_vcs_info.json":"480bba3005be9515acc4df53efd4060d17fa8560b5f467ad7d6e87c844650019","CHANGELOG.md":"ade49a29d368e16ce508aee91b477ecbad7e2e52eb6fee7b4c1fc86199963f0e","Cargo.toml":"421b3a71d97faf0a7e52c3b2bfbe0f1c036b9dbf6232b4e5b41221bb54358f5a","Cargo.toml.orig":"9f31637058f15f6c44a1d6fb955f3567440d2edf82fa923ec7abd1e48be67739","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"ff8f68cb076caf8cefe7a6430d4ac086ce6af2ca8ce2c4e5a2004d4552ef52a2","README.md":"a536b3bb3f3521e59836080f05a4783150fa8484f759a31468ce3b6dba1f33eb","benches/bench.rs":"aadc39d815eadf094ed9357d946319df2d93194203bbccb7c33cea6951d654df","benches/insert_unique_unchecked.rs":"cb84275f22d5f95a5ac995ac6b2df74ffcf342765b401d27c95f2955c7b7cb9f","clippy.toml":"7535949f908c6d9aea4f9a9f3a7625552c93fc29e963d059d40f4def9d77ea7b","src/external_trait_impls/mod.rs":"d69528827794524cfd9acbeacc1ac4f6131e3c7574311e6d919f818f65fbff07","src/external_trait_impls/rayon/helpers.rs":"ba105bf0853ebc45157f22116ad0f55d3bdab75e721d8e7a677c7b912d0c0c6d","src/external_trait_impls/rayon/map.rs":"2809e2a0071db8101c38789deb955f3830c5c3455eb1794ff64a0cf2ceb53fc7","src/external_trait_impls/rayon/mod.rs":"156de9c1ad0123334ea3b7e5a17444faf1b8bf971aa88a1f23e2f2d1c3021141","src/external_trait_impls/rayon/raw.rs":"e62c5f3ca5fffea47357e64b6f8c34cec94af62d9bd28a2b87934da46c22b66e","src/external_trait_impls/rayon/set.rs":"c4c44d44e56c2f59e9e1355662e29d8744ac96645ca4414127a359fb46cb0fbf","src/external_trait_impls/serde.rs":"0bc1a1f218d1ae7a5262557a5e3737b9334caf7d50c136dbdc75ff75680c223b","src/lib.rs":"c82fbee9684bfff40ef55d5f0c9f855c11f71f9fd1720fb084ef8331bdbc41d8","src/macros.rs":"36fe532656879c80f7753d13354b889f5b45caef451a1bb3a27dbc32d74c9878","src/map.rs":"df39edae67c569378dea9a4d928685cb4d06569712c6ac36a54df76fb5d87fe3","src/raw/alloc.rs":"184a0345bc2c7544b65c28724063be26b1f2b28dbaaa028a0b01192ccac25557","src/raw/bitmask.rs":"820d90b19b7e3433a1048ace008c9526331cd53a576cb0cfc1ff9960b6fe52f8","src/raw/generic.rs":"f5013a50d6d82d5cc8bad8b8c26c24d00fa810197f9f123256c58ac92e0d98f9","src/raw/mod.rs":"fa38247c6b3bd70636be50400debb9966a3446d49ee13e4f4e2dfe4ceed1b201","src/raw/sse2.rs":"838cfdb1daa1e70951ed25f985283b8b7ab4b46fa130f92eda152047ce6086f6","src/rustc_entry.rs":"cdd70972cba5b79ca1cad79869cb5e184d6dc4798ef90822e966ef89679ba011","src/scopeguard.rs":"d13de1b12897add7fe1c3eba6f906c9cc09d86509b6cfe06b95d63803fe9265c","src/set.rs":"6877d4a42eeadd681e3b8881528e4b20f14cfedbc11e9318bfcf425ef96d1546","tests/hasher.rs":"9a8fdf67e4415618e16729969c386eefe71408cded5d46cf7b67d969276a3452","tests/rayon.rs":"83d5289771542203f539a41cccb889fbe7ce70f5adf5b903ac9f051e3ba13cfa","tests/serde.rs":"6bac8054db722dd049901b37a6e006535bac30f425eb5cd91af19b5bc1dfe78e","tests/set.rs":"01cf39efb04646ef4c63a809ebb96dfa63cfec472bf8bdb6c121f6526d40c40e"},"package":"8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"}

data/ext/cargo-vendor/hashbrown-0.12.3/.cargo_vcs_info.json

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