Merging upstream version 1.72.1+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

5 files changed, 292 insertions, 39 deletions

diff --git a/vendor/siphasher/src/lib.rs b/vendor/siphasher/src/lib.rs
index c493adc96..71e59deb5 100644
--- a/vendor/siphasher/src/lib.rs
+++ b/vendor/siphasher/src/lib.rs
@@ -1,9 +1,7 @@
 #![cfg_attr(not(test), no_std)]
 #![allow(clippy::unreadable_literal)]
 #![allow(clippy::cast_lossless)]
-
-#[cfg(test)]
-extern crate core;
+#![allow(clippy::many_single_char_names)]
 
 pub mod sip;
 pub mod sip128;
@@ -13,3 +11,14 @@ mod tests;
 
 #[cfg(test)]
 mod tests128;
+
+#[cfg(any(feature = "serde", feature = "serde_std", feature = "serde_no_std"))]
+pub mod reexports {
+    pub use serde;
+}
+
+pub mod prelude {
+    pub use crate::{sip, sip128};
+    pub use core::hash::Hasher as _;
+    pub use sip128::Hasher128 as _;
+}
diff --git a/vendor/siphasher/src/sip.rs b/vendor/siphasher/src/sip.rs
index 046d8eaae..df6be1e79 100644
--- a/vendor/siphasher/src/sip.rs
+++ b/vendor/siphasher/src/sip.rs
@@ -15,10 +15,11 @@ use core::hash;
 use core::marker::PhantomData;
 use core::mem;
 use core::ptr;
+use core::u64;
 
 /// An implementation of SipHash 1-3.
 ///
-/// See: <https://131002.net/siphash/>
+/// See: <https://www.aumasson.jp/siphash/siphash.pdf>
 #[derive(Debug, Clone, Copy, Default)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct SipHasher13 {
@@ -27,7 +28,7 @@ pub struct SipHasher13 {
 
 /// An implementation of SipHash 2-4.
 ///
-/// See: <https://131002.net/siphash/>
+/// See: <https://www.aumasson.jp/siphash/siphash.pdf>
 #[derive(Debug, Clone, Copy, Default)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct SipHasher24 {
@@ -36,7 +37,7 @@ pub struct SipHasher24 {
 
 /// An implementation of SipHash 2-4.
 ///
-/// See: <https://131002.net/siphash/>
+/// See: <https://www.aumasson.jp/siphash/siphash.pdf>
 ///
 /// SipHash is a general-purpose hashing function: it runs at a good
 /// speed (competitive with Spooky and City) and permits strong _keyed_
@@ -107,7 +108,7 @@ macro_rules! load_int_le {
         debug_assert!($i + mem::size_of::<$int_ty>() <= $buf.len());
         let mut data = 0 as $int_ty;
         ptr::copy_nonoverlapping(
-            $buf.get_unchecked($i),
+            $buf.as_ptr().add($i),
             &mut data as *mut _ as *mut u8,
             mem::size_of::<$int_ty>(),
         );
@@ -154,10 +155,29 @@ impl SipHasher {
         SipHasher(SipHasher24::new_with_keys(key0, key1))
     }
 
+    /// Creates a `SipHasher` from a 16 byte key.
+    pub fn new_with_key(key: &[u8; 16]) -> SipHasher {
+        let mut b0 = [0u8; 8];
+        let mut b1 = [0u8; 8];
+        b0.copy_from_slice(&key[0..8]);
+        b1.copy_from_slice(&key[8..16]);
+        let key0 = u64::from_le_bytes(b0);
+        let key1 = u64::from_le_bytes(b1);
+        Self::new_with_keys(key0, key1)
+    }
+
     /// Get the keys used by this hasher
     pub fn keys(&self) -> (u64, u64) {
         (self.0.hasher.k0, self.0.hasher.k1)
     }
+
+    /// Get the key used by this hasher as a 16 byte vector
+    pub fn key(&self) -> [u8; 16] {
+        let mut bytes = [0u8; 16];
+        bytes[0..8].copy_from_slice(&self.0.hasher.k0.to_le_bytes());
+        bytes[8..16].copy_from_slice(&self.0.hasher.k1.to_le_bytes());
+        bytes
+    }
 }
 
 impl SipHasher13 {
@@ -175,10 +195,29 @@ impl SipHasher13 {
         }
     }
 
+    /// Creates a `SipHasher13` from a 16 byte key.
+    pub fn new_with_key(key: &[u8; 16]) -> SipHasher13 {
+        let mut b0 = [0u8; 8];
+        let mut b1 = [0u8; 8];
+        b0.copy_from_slice(&key[0..8]);
+        b1.copy_from_slice(&key[8..16]);
+        let key0 = u64::from_le_bytes(b0);
+        let key1 = u64::from_le_bytes(b1);
+        Self::new_with_keys(key0, key1)
+    }
+
     /// Get the keys used by this hasher
     pub fn keys(&self) -> (u64, u64) {
         (self.hasher.k0, self.hasher.k1)
     }
+
+    /// Get the key used by this hasher as a 16 byte vector
+    pub fn key(&self) -> [u8; 16] {
+        let mut bytes = [0u8; 16];
+        bytes[0..8].copy_from_slice(&self.hasher.k0.to_le_bytes());
+        bytes[8..16].copy_from_slice(&self.hasher.k1.to_le_bytes());
+        bytes
+    }
 }
 
 impl SipHasher24 {
@@ -196,10 +235,29 @@ impl SipHasher24 {
         }
     }
 
+    /// Creates a `SipHasher24` from a 16 byte key.
+    pub fn new_with_key(key: &[u8; 16]) -> SipHasher24 {
+        let mut b0 = [0u8; 8];
+        let mut b1 = [0u8; 8];
+        b0.copy_from_slice(&key[0..8]);
+        b1.copy_from_slice(&key[8..16]);
+        let key0 = u64::from_le_bytes(b0);
+        let key1 = u64::from_le_bytes(b1);
+        Self::new_with_keys(key0, key1)
+    }
+
     /// Get the keys used by this hasher
     pub fn keys(&self) -> (u64, u64) {
         (self.hasher.k0, self.hasher.k1)
     }
+
+    /// Get the key used by this hasher as a 16 byte vector
+    pub fn key(&self) -> [u8; 16] {
+        let mut bytes = [0u8; 16];
+        bytes[0..8].copy_from_slice(&self.hasher.k0.to_le_bytes());
+        bytes[8..16].copy_from_slice(&self.hasher.k1.to_le_bytes());
+        bytes
+    }
 }
 
 impl<S: Sip> Hasher<S> {
@@ -281,6 +339,31 @@ impl hash::Hasher for SipHasher {
     fn finish(&self) -> u64 {
         self.0.finish()
     }
+
+    #[inline]
+    fn write_usize(&mut self, i: usize) {
+        self.0.write_usize(i);
+    }
+
+    #[inline]
+    fn write_u8(&mut self, i: u8) {
+        self.0.write_u8(i);
+    }
+
+    #[inline]
+    fn write_u16(&mut self, i: u16) {
+        self.0.write_u16(i);
+    }
+
+    #[inline]
+    fn write_u32(&mut self, i: u32) {
+        self.0.write_u32(i);
+    }
+
+    #[inline]
+    fn write_u64(&mut self, i: u64) {
+        self.0.write_u64(i);
+    }
 }
 
 impl hash::Hasher for SipHasher13 {
@@ -293,6 +376,31 @@ impl hash::Hasher for SipHasher13 {
     fn finish(&self) -> u64 {
         self.hasher.finish()
     }
+
+    #[inline]
+    fn write_usize(&mut self, i: usize) {
+        self.hasher.write_usize(i);
+    }
+
+    #[inline]
+    fn write_u8(&mut self, i: u8) {
+        self.hasher.write_u8(i);
+    }
+
+    #[inline]
+    fn write_u16(&mut self, i: u16) {
+        self.hasher.write_u16(i);
+    }
+
+    #[inline]
+    fn write_u32(&mut self, i: u32) {
+        self.hasher.write_u32(i);
+    }
+
+    #[inline]
+    fn write_u64(&mut self, i: u64) {
+        self.hasher.write_u64(i);
+    }
 }
 
 impl hash::Hasher for SipHasher24 {
@@ -305,6 +413,31 @@ impl hash::Hasher for SipHasher24 {
     fn finish(&self) -> u64 {
         self.hasher.finish()
     }
+
+    #[inline]
+    fn write_usize(&mut self, i: usize) {
+        self.hasher.write_usize(i);
+    }
+
+    #[inline]
+    fn write_u8(&mut self, i: u8) {
+        self.hasher.write_u8(i);
+    }
+
+    #[inline]
+    fn write_u16(&mut self, i: u16) {
+        self.hasher.write_u16(i);
+    }
+
+    #[inline]
+    fn write_u32(&mut self, i: u32) {
+        self.hasher.write_u32(i);
+    }
+
+    #[inline]
+    fn write_u64(&mut self, i: u64) {
+        self.hasher.write_u64(i);
+    }
 }
 
 impl<S: Sip> hash::Hasher for Hasher<S> {
diff --git a/vendor/siphasher/src/sip128.rs b/vendor/siphasher/src/sip128.rs
index a3ac92f45..cabf8e3a3 100644
--- a/vendor/siphasher/src/sip128.rs
+++ b/vendor/siphasher/src/sip128.rs
@@ -15,6 +15,7 @@ use core::hash;
 use core::marker::PhantomData;
 use core::mem;
 use core::ptr;
+use core::u64;
 
 /// A 128-bit (2x64) hash output
 #[derive(Debug, Clone, Copy, Default)]
@@ -33,9 +34,9 @@ impl From<u128> for Hash128 {
     }
 }
 
-impl Into<u128> for Hash128 {
-    fn into(self) -> u128 {
-        (self.h1 as u128) | ((self.h2 as u128) << 64)
+impl From<Hash128> for u128 {
+    fn from(h: Hash128) -> u128 {
+        (h.h1 as u128) | ((h.h2 as u128) << 64)
     }
 }
 
@@ -123,7 +124,7 @@ macro_rules! load_int_le {
         debug_assert!($i + mem::size_of::<$int_ty>() <= $buf.len());
         let mut data = 0 as $int_ty;
         ptr::copy_nonoverlapping(
-            $buf.get_unchecked($i),
+            $buf.as_ptr().add($i),
             &mut data as *mut _ as *mut u8,
             mem::size_of::<$int_ty>(),
         );
@@ -175,10 +176,29 @@ impl SipHasher {
         SipHasher(SipHasher24::new_with_keys(key0, key1))
     }
 
+    /// Creates a `SipHasher` from a 16 byte key.
+    pub fn new_with_key(key: &[u8; 16]) -> SipHasher {
+        let mut b0 = [0u8; 8];
+        let mut b1 = [0u8; 8];
+        b0.copy_from_slice(&key[0..8]);
+        b1.copy_from_slice(&key[8..16]);
+        let key0 = u64::from_le_bytes(b0);
+        let key1 = u64::from_le_bytes(b1);
+        Self::new_with_keys(key0, key1)
+    }
+
     /// Get the keys used by this hasher
     pub fn keys(&self) -> (u64, u64) {
         (self.0.hasher.k0, self.0.hasher.k1)
     }
+
+    /// Get the key used by this hasher as a 16 byte vector
+    pub fn key(&self) -> [u8; 16] {
+        let mut bytes = [0u8; 16];
+        bytes[0..8].copy_from_slice(&self.0.hasher.k0.to_le_bytes());
+        bytes[8..16].copy_from_slice(&self.0.hasher.k1.to_le_bytes());
+        bytes
+    }
 }
 
 impl Hasher128 for SipHasher {
@@ -204,10 +224,29 @@ impl SipHasher13 {
         }
     }
 
+    /// Creates a `SipHasher13` from a 16 byte key.
+    pub fn new_with_key(key: &[u8; 16]) -> SipHasher13 {
+        let mut b0 = [0u8; 8];
+        let mut b1 = [0u8; 8];
+        b0.copy_from_slice(&key[0..8]);
+        b1.copy_from_slice(&key[8..16]);
+        let key0 = u64::from_le_bytes(b0);
+        let key1 = u64::from_le_bytes(b1);
+        Self::new_with_keys(key0, key1)
+    }
+
     /// Get the keys used by this hasher
     pub fn keys(&self) -> (u64, u64) {
         (self.hasher.k0, self.hasher.k1)
     }
+
+    /// Get the key used by this hasher as a 16 byte vector
+    pub fn key(&self) -> [u8; 16] {
+        let mut bytes = [0u8; 16];
+        bytes[0..8].copy_from_slice(&self.hasher.k0.to_le_bytes());
+        bytes[8..16].copy_from_slice(&self.hasher.k1.to_le_bytes());
+        bytes
+    }
 }
 
 impl Hasher128 for SipHasher13 {
@@ -233,10 +272,29 @@ impl SipHasher24 {
         }
     }
 
+    /// Creates a `SipHasher24` from a 16 byte key.
+    pub fn new_with_key(key: &[u8; 16]) -> SipHasher24 {
+        let mut b0 = [0u8; 8];
+        let mut b1 = [0u8; 8];
+        b0.copy_from_slice(&key[0..8]);
+        b1.copy_from_slice(&key[8..16]);
+        let key0 = u64::from_le_bytes(b0);
+        let key1 = u64::from_le_bytes(b1);
+        Self::new_with_keys(key0, key1)
+    }
+
     /// Get the keys used by this hasher
     pub fn keys(&self) -> (u64, u64) {
         (self.hasher.k0, self.hasher.k1)
     }
+
+    /// Get the key used by this hasher as a 16 byte vector
+    pub fn key(&self) -> [u8; 16] {
+        let mut bytes = [0u8; 16];
+        bytes[0..8].copy_from_slice(&self.hasher.k0.to_le_bytes());
+        bytes[8..16].copy_from_slice(&self.hasher.k1.to_le_bytes());
+        bytes
+    }
 }
 
 impl Hasher128 for SipHasher24 {
@@ -349,6 +407,31 @@ impl hash::Hasher for SipHasher {
     fn finish(&self) -> u64 {
         self.0.finish()
     }
+
+    #[inline]
+    fn write_usize(&mut self, i: usize) {
+        self.0.write_usize(i);
+    }
+
+    #[inline]
+    fn write_u8(&mut self, i: u8) {
+        self.0.write_u8(i);
+    }
+
+    #[inline]
+    fn write_u16(&mut self, i: u16) {
+        self.0.write_u16(i);
+    }
+
+    #[inline]
+    fn write_u32(&mut self, i: u32) {
+        self.0.write_u32(i);
+    }
+
+    #[inline]
+    fn write_u64(&mut self, i: u64) {
+        self.0.write_u64(i);
+    }
 }
 
 impl hash::Hasher for SipHasher13 {
@@ -361,6 +444,31 @@ impl hash::Hasher for SipHasher13 {
     fn finish(&self) -> u64 {
         self.hasher.finish()
     }
+
+    #[inline]
+    fn write_usize(&mut self, i: usize) {
+        self.hasher.write_usize(i);
+    }
+
+    #[inline]
+    fn write_u8(&mut self, i: u8) {
+        self.hasher.write_u8(i);
+    }
+
+    #[inline]
+    fn write_u16(&mut self, i: u16) {
+        self.hasher.write_u16(i);
+    }
+
+    #[inline]
+    fn write_u32(&mut self, i: u32) {
+        self.hasher.write_u32(i);
+    }
+
+    #[inline]
+    fn write_u64(&mut self, i: u64) {
+        self.hasher.write_u64(i);
+    }
 }
 
 impl hash::Hasher for SipHasher24 {
@@ -373,6 +481,31 @@ impl hash::Hasher for SipHasher24 {
     fn finish(&self) -> u64 {
         self.hasher.finish()
     }
+
+    #[inline]
+    fn write_usize(&mut self, i: usize) {
+        self.hasher.write_usize(i);
+    }
+
+    #[inline]
+    fn write_u8(&mut self, i: u8) {
+        self.hasher.write_u8(i);
+    }
+
+    #[inline]
+    fn write_u16(&mut self, i: u16) {
+        self.hasher.write_u16(i);
+    }
+
+    #[inline]
+    fn write_u32(&mut self, i: u32) {
+        self.hasher.write_u32(i);
+    }
+
+    #[inline]
+    fn write_u64(&mut self, i: u64) {
+        self.hasher.write_u64(i);
+    }
 }
 
 impl<S: Sip> hash::Hasher for Hasher<S> {
@@ -514,8 +647,8 @@ impl Hash128 {
         let h1 = self.h1.to_le();
         let h2 = self.h2.to_le();
         unsafe {
-            ptr::copy_nonoverlapping(&h1 as *const _ as *const u8, bytes.get_unchecked_mut(0), 8);
-            ptr::copy_nonoverlapping(&h2 as *const _ as *const u8, bytes.get_unchecked_mut(8), 8);
+            ptr::copy_nonoverlapping(&h1 as *const _ as *const u8, bytes.as_mut_ptr(), 8);
+            ptr::copy_nonoverlapping(&h2 as *const _ as *const u8, bytes.as_mut_ptr().add(8), 8);
         }
         bytes
     }
diff --git a/vendor/siphasher/src/tests.rs b/vendor/siphasher/src/tests.rs
index 480903e59..05d4b6a18 100644
--- a/vendor/siphasher/src/tests.rs
+++ b/vendor/siphasher/src/tests.rs
@@ -241,30 +241,8 @@ fn test_siphash_2_4() {
     }
 }
 #[test]
-#[cfg(target_arch = "arm")]
-fn test_hash_usize() {
-    let val = 0xdeadbeef_deadbeef_u64;
-    assert_ne!(hash(&(val as u64)), hash(&(val as usize)));
-    assert_eq!(hash(&(val as u32)), hash(&(val as usize)));
-}
-#[test]
-#[cfg(target_arch = "x86_64")]
-fn test_hash_usize() {
-    let val = 0xdeadbeef_deadbeef_u64;
-    assert_eq!(hash(&(val as u64)), hash(&(val as usize)));
-    assert_ne!(hash(&(val as u32)), hash(&(val as usize)));
-}
-#[test]
-#[cfg(target_arch = "x86")]
-fn test_hash_usize() {
-    let val = 0xdeadbeef_deadbeef_u64;
-    assert_ne!(hash(&(val as u64)), hash(&(val as usize)));
-    assert_eq!(hash(&(val as u32)), hash(&(val as usize)));
-}
-
-#[test]
 fn test_hash_idempotent() {
-    let val64 = 0xdeadbeef_deadbeef_u64;
+    let val64 = 0xdead_beef_dead_beef_u64;
     assert_eq!(hash(&val64), hash(&val64));
     let val32 = 0xdeadbeef_u32;
     assert_eq!(hash(&val32), hash(&val32));
@@ -272,7 +250,7 @@ fn test_hash_idempotent() {
 
 #[test]
 fn test_hash_no_bytes_dropped_64() {
-    let val = 0xdeadbeef_deadbeef_u64;
+    let val = 0xdead_beef_dead_beef_u64;
 
     assert_ne!(hash(&val), hash(&zero_byte(val, 0)));
     assert_ne!(hash(&val), hash(&zero_byte(val, 1)));
@@ -323,7 +301,7 @@ fn test_hash_no_concat_alias() {
 
 #[test]
 fn test_hash_serde() {
-    let val64 = 0xdeadbeef_deadbeef_u64;
+    let val64 = 0xdead_beef_dead_beef_u64;
     let hash = hash(&val64);
     let serialized = serde_json::to_string(&hash).unwrap();
     let deserialized: u64 = serde_json::from_str(&serialized).unwrap();
diff --git a/vendor/siphasher/src/tests128.rs b/vendor/siphasher/src/tests128.rs
index 9f55a6193..0d9769646 100644
--- a/vendor/siphasher/src/tests128.rs
+++ b/vendor/siphasher/src/tests128.rs
@@ -95,7 +95,7 @@ fn test_siphash128_2_4() {
 
 #[test]
 fn test_siphash128_serde() {
-    let val64 = 0xdeadbeef_deadbeef_u64;
+    let val64 = 0xdead_beef_dead_beef_u64;
     let hash = hash(&val64);
     let serialized = serde_json::to_string(&hash).unwrap();
     let deserialized: [u8; 16] = serde_json::from_str(&serialized).unwrap();