Adding upstream version 1.64.0+dfsg1.upstream/1.64.0+dfsg1

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

1 files changed, 333 insertions, 0 deletions

diff --git a/vendor/snap/src/error.rs b/vendor/snap/src/error.rs
new file mode 100644
index 000000000..8f0b400a6
--- /dev/null
+++ b/vendor/snap/src/error.rs
@@ -0,0 +1,333 @@
+use std::fmt;
+use std::io;
+use std::result;
+
+/// A convenient type alias for `Result<T, snap::Error>`.
+pub type Result<T> = result::Result<T, Error>;
+
+/// `IntoInnerError` occurs when consuming an encoder fails.
+///
+/// Consuming the encoder causes a flush to happen. If the flush fails, then
+/// this error is returned, which contains both the original encoder and the
+/// error that occurred.
+///
+/// The type parameter `W` is the unconsumed writer.
+pub struct IntoInnerError<W> {
+    wtr: W,
+    err: io::Error,
+}
+
+impl<W> IntoInnerError<W> {
+    pub(crate) fn new(wtr: W, err: io::Error) -> IntoInnerError<W> {
+        IntoInnerError { wtr, err }
+    }
+
+    /// Returns the error which caused the call to `into_inner` to fail.
+    ///
+    /// This error was returned when attempting to flush the internal buffer.
+    pub fn error(&self) -> &io::Error {
+        &self.err
+    }
+
+    /// Returns the underlying writer which generated the error.
+    ///
+    /// The returned value can be used for error recovery, such as
+    /// re-inspecting the buffer.
+    pub fn into_inner(self) -> W {
+        self.wtr
+    }
+}
+
+impl<W: std::any::Any> std::error::Error for IntoInnerError<W> {}
+
+impl<W> fmt::Display for IntoInnerError<W> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.err.fmt(f)
+    }
+}
+
+impl<W> fmt::Debug for IntoInnerError<W> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.err.fmt(f)
+    }
+}
+
+/// Error describes all the possible errors that may occur during Snappy
+/// compression or decompression.
+///
+/// Note that it's unlikely that you'll need to care about the specific error
+/// reported since all of them indicate a corrupt Snappy data or a limitation
+/// that cannot be worked around. Therefore,
+/// `From<snap::Error> for std::io::Error` is provided so that any Snappy
+/// errors will be converted to a `std::io::Error` automatically when using
+/// `try!`.
+#[derive(Clone, Debug)]
+pub enum Error {
+    /// This error occurs when the given input is too big. This can happen
+    /// during compression or decompression.
+    TooBig {
+        /// The size of the given input.
+        given: u64,
+        /// The maximum allowed size of an input buffer.
+        max: u64,
+    },
+    /// This error occurs when the given buffer is too small to contain the
+    /// maximum possible compressed bytes or the total number of decompressed
+    /// bytes.
+    BufferTooSmall {
+        /// The size of the given output buffer.
+        given: u64,
+        /// The minimum size of the output buffer.
+        min: u64,
+    },
+    /// This error occurs when trying to decompress a zero length buffer.
+    Empty,
+    /// This error occurs when an invalid header is found during decompression.
+    Header,
+    /// This error occurs when there is a mismatch between the number of
+    /// decompressed bytes reported in the header and the number of
+    /// actual decompressed bytes. In this error case, the number of actual
+    /// decompressed bytes is always less than the number reported in the
+    /// header.
+    HeaderMismatch {
+        /// The total number of decompressed bytes expected (i.e., the header
+        /// value).
+        expected_len: u64,
+        /// The total number of actual decompressed bytes.
+        got_len: u64,
+    },
+    /// This error occurs during decompression when there was a problem
+    /// reading a literal.
+    Literal {
+        /// The expected length of the literal.
+        len: u64,
+        /// The number of remaining bytes in the compressed bytes.
+        src_len: u64,
+        /// The number of remaining slots in the decompression buffer.
+        dst_len: u64,
+    },
+    /// This error occurs during decompression when there was a problem
+    /// reading a copy.
+    CopyRead {
+        /// The expected length of the copy (as encoded in the compressed
+        /// bytes).
+        len: u64,
+        /// The number of remaining bytes in the compressed bytes.
+        src_len: u64,
+    },
+    /// This error occurs during decompression when there was a problem
+    /// writing a copy to the decompression buffer.
+    CopyWrite {
+        /// The length of the copy (i.e., the total number of bytes to be
+        /// produced by this copy in the decompression buffer).
+        len: u64,
+        /// The number of remaining bytes in the decompression buffer.
+        dst_len: u64,
+    },
+    /// This error occurs during decompression when an invalid copy offset
+    /// is found. An offset is invalid if it is zero or if it is out of bounds.
+    Offset {
+        /// The offset that was read.
+        offset: u64,
+        /// The current position in the decompression buffer. If the offset is
+        /// non-zero, then the offset must be greater than this position.
+        dst_pos: u64,
+    },
+    /// This error occurs when a stream header chunk type was expected but got
+    /// a different chunk type.
+    /// This error only occurs when reading a Snappy frame formatted stream.
+    StreamHeader {
+        /// The chunk type byte that was read.
+        byte: u8,
+    },
+    /// This error occurs when the magic stream headers bytes do not match
+    /// what is expected.
+    /// This error only occurs when reading a Snappy frame formatted stream.
+    StreamHeaderMismatch {
+        /// The bytes that were read.
+        bytes: Vec<u8>,
+    },
+    /// This error occurs when an unsupported chunk type is seen.
+    /// This error only occurs when reading a Snappy frame formatted stream.
+    UnsupportedChunkType {
+        /// The chunk type byte that was read.
+        byte: u8,
+    },
+    /// This error occurs when trying to read a chunk with an unexpected or
+    /// incorrect length when reading a Snappy frame formatted stream.
+    /// This error only occurs when reading a Snappy frame formatted stream.
+    UnsupportedChunkLength {
+        /// The length of the chunk encountered.
+        len: u64,
+        /// True when this error occured while reading the stream header.
+        header: bool,
+    },
+    /// This error occurs when a checksum validity check fails.
+    /// This error only occurs when reading a Snappy frame formatted stream.
+    Checksum {
+        /// The expected checksum read from the stream.
+        expected: u32,
+        /// The computed checksum.
+        got: u32,
+    },
+}
+
+impl From<Error> for io::Error {
+    fn from(err: Error) -> io::Error {
+        io::Error::new(io::ErrorKind::Other, err)
+    }
+}
+
+impl Eq for Error {}
+
+impl PartialEq for Error {
+    fn eq(&self, other: &Error) -> bool {
+        use self::Error::*;
+        match (self, other) {
+            (
+                &TooBig { given: given1, max: max1 },
+                &TooBig { given: given2, max: max2 },
+            ) => (given1, max1) == (given2, max2),
+            (
+                &BufferTooSmall { given: given1, min: min1 },
+                &BufferTooSmall { given: given2, min: min2 },
+            ) => (given1, min1) == (given2, min2),
+            (&Empty, &Empty) | (&Header, &Header) => true,
+            (
+                &HeaderMismatch { expected_len: elen1, got_len: glen1 },
+                &HeaderMismatch { expected_len: elen2, got_len: glen2 },
+            ) => (elen1, glen1) == (elen2, glen2),
+            (
+                &Literal { len: len1, src_len: src_len1, dst_len: dst_len1 },
+                &Literal { len: len2, src_len: src_len2, dst_len: dst_len2 },
+            ) => (len1, src_len1, dst_len1) == (len2, src_len2, dst_len2),
+            (
+                &CopyRead { len: len1, src_len: src_len1 },
+                &CopyRead { len: len2, src_len: src_len2 },
+            ) => (len1, src_len1) == (len2, src_len2),
+            (
+                &CopyWrite { len: len1, dst_len: dst_len1 },
+                &CopyWrite { len: len2, dst_len: dst_len2 },
+            ) => (len1, dst_len1) == (len2, dst_len2),
+            (
+                &Offset { offset: offset1, dst_pos: dst_pos1 },
+                &Offset { offset: offset2, dst_pos: dst_pos2 },
+            ) => (offset1, dst_pos1) == (offset2, dst_pos2),
+            (&StreamHeader { byte: byte1 }, &StreamHeader { byte: byte2 }) => {
+                byte1 == byte2
+            }
+            (
+                &StreamHeaderMismatch { bytes: ref bytes1 },
+                &StreamHeaderMismatch { bytes: ref bytes2 },
+            ) => bytes1 == bytes2,
+            (
+                &UnsupportedChunkType { byte: byte1 },
+                &UnsupportedChunkType { byte: byte2 },
+            ) => byte1 == byte2,
+            (
+                &UnsupportedChunkLength { len: len1, header: header1 },
+                &UnsupportedChunkLength { len: len2, header: header2 },
+            ) => (len1, header1) == (len2, header2),
+            (
+                &Checksum { expected: e1, got: g1 },
+                &Checksum { expected: e2, got: g2 },
+            ) => (e1, g1) == (e2, g2),
+            _ => false,
+        }
+    }
+}
+
+impl std::error::Error for Error {}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            Error::TooBig { given, max } => write!(
+                f,
+                "snappy: input buffer (size = {}) is larger than \
+                         allowed (size = {})",
+                given, max
+            ),
+            Error::BufferTooSmall { given, min } => write!(
+                f,
+                "snappy: output buffer (size = {}) is smaller than \
+                         required (size = {})",
+                given, min
+            ),
+            Error::Empty => write!(f, "snappy: corrupt input (empty)"),
+            Error::Header => {
+                write!(f, "snappy: corrupt input (invalid header)")
+            }
+            Error::HeaderMismatch { expected_len, got_len } => write!(
+                f,
+                "snappy: corrupt input (header mismatch; expected \
+                         {} decompressed bytes but got {})",
+                expected_len, got_len
+            ),
+            Error::Literal { len, src_len, dst_len } => write!(
+                f,
+                "snappy: corrupt input (expected literal read of \
+                         length {}; remaining src: {}; remaining dst: {})",
+                len, src_len, dst_len
+            ),
+            Error::CopyRead { len, src_len } => write!(
+                f,
+                "snappy: corrupt input (expected copy read of \
+                         length {}; remaining src: {})",
+                len, src_len
+            ),
+            Error::CopyWrite { len, dst_len } => write!(
+                f,
+                "snappy: corrupt input (expected copy write of \
+                         length {}; remaining dst: {})",
+                len, dst_len
+            ),
+            Error::Offset { offset, dst_pos } => write!(
+                f,
+                "snappy: corrupt input (expected valid offset but \
+                         got offset {}; dst position: {})",
+                offset, dst_pos
+            ),
+            Error::StreamHeader { byte } => write!(
+                f,
+                "snappy: corrupt input (expected stream header but \
+                         got unexpected chunk type byte {})",
+                byte
+            ),
+            Error::StreamHeaderMismatch { ref bytes } => write!(
+                f,
+                "snappy: corrupt input (expected sNaPpY stream \
+                         header but got {})",
+                escape(&**bytes)
+            ),
+            Error::UnsupportedChunkType { byte } => write!(
+                f,
+                "snappy: corrupt input (unsupported chunk type: {})",
+                byte
+            ),
+            Error::UnsupportedChunkLength { len, header: false } => write!(
+                f,
+                "snappy: corrupt input \
+                         (unsupported chunk length: {})",
+                len
+            ),
+            Error::UnsupportedChunkLength { len, header: true } => write!(
+                f,
+                "snappy: corrupt input \
+                         (invalid stream header length: {})",
+                len
+            ),
+            Error::Checksum { expected, got } => write!(
+                f,
+                "snappy: corrupt input (bad checksum; \
+                         expected: {}, got: {})",
+                expected, got
+            ),
+        }
+    }
+}
+
+fn escape(bytes: &[u8]) -> String {
+    use std::ascii::escape_default;
+    bytes.iter().flat_map(|&b| escape_default(b)).map(|b| b as char).collect()
+}