Raise an EncodingError from Utf8ValidatingReader

Do all of the plumbing necessary to return EncodingError directly from
Utf8ValidatingReader using IoError::InvalidData + error downcasting.

The Utf8 variant of EncodingError now holds an error enum, as we cannot
create instances of Utf8Error ourselves.

Author: dralley

src/encoding.rs

@@ -19,6 +19,52 @@ pub(crate) const UTF16_LE_BOM: &[u8] = &[0xFF, 0xFE];
 #[cfg(feature = "encoding")]
 pub(crate) const UTF16_BE_BOM: &[u8] = &[0xFE, 0xFF];
 
+/// An error type representing UTF-8 validation failure.
+///
+/// Unlike [`std::str::Utf8Error`], instances can be created directly for custom error scenarios.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Utf8ValidationError {
+    /// Error from standard library UTF-8 validation
+    Utf8(Utf8Error),
+    /// Invalid UTF-8 sequence found in the input
+    InvalidSequence {
+        /// Length of the invalid UTF-8 sequence in bytes
+        error_len: usize,
+    },
+    /// Incomplete UTF-8 sequence at end of stream
+    IncompleteSequence,
+}
+
+impl From<Utf8Error> for Utf8ValidationError {
+    #[inline]
+    fn from(e: Utf8Error) -> Self {
+        Self::Utf8(e)
+    }
+}
+
+impl std::fmt::Display for Utf8ValidationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Utf8(e) => write!(f, "{}", e),
+            Self::InvalidSequence { error_len } => {
+                write!(f, "invalid UTF-8 sequence of {} bytes", error_len)
+            }
+            Self::IncompleteSequence => {
+                write!(f, "incomplete UTF-8 sequence at end of stream")
+            }
+        }
+    }
+}
+
+impl std::error::Error for Utf8ValidationError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Self::Utf8(e) => Some(e),
+            _ => None,
+        }
+    }
+}
+
 /// An error when decoding or encoding
 ///
 /// If feature [`encoding`] is disabled, the [`EncodingError`] is always [`EncodingError::Utf8`]
@@ -28,7 +74,7 @@ pub(crate) const UTF16_BE_BOM: &[u8] = &[0xFE, 0xFF];
 #[non_exhaustive]
 pub enum EncodingError {
     /// Input was not valid UTF-8
-    Utf8(Utf8Error),
+    Utf8(Utf8ValidationError),
     /// Input did not adhere to the given encoding
     #[cfg(feature = "encoding")]
     Other(&'static Encoding),
@@ -37,6 +83,13 @@ pub enum EncodingError {
 impl From<Utf8Error> for EncodingError {
     #[inline]
     fn from(e: Utf8Error) -> Self {
+        Self::Utf8(e.into())
+    }
+}
+
+impl From<Utf8ValidationError> for EncodingError {
+    #[inline]
+    fn from(e: Utf8ValidationError) -> Self {
         Self::Utf8(e)
     }
 }
@@ -406,7 +459,7 @@ impl<R: Read> Read for Utf8ValidatingReader<R> {
                             if valid_up_to == 0 {
                                 return Err(io::Error::new(
                                     io::ErrorKind::InvalidData,
-                                    format!("invalid UTF-8 sequence of {} bytes", error_len),
+                                    EncodingError::Utf8(Utf8ValidationError::InvalidSequence { error_len }),
                                 ));
                             }
                             // Write valid portion before the error
@@ -445,7 +498,7 @@ impl<R: Read> Read for Utf8ValidatingReader<R> {
                     // EOF with incomplete UTF-8 sequence
                     return Err(io::Error::new(
                         io::ErrorKind::InvalidData,
-                        "incomplete UTF-8 sequence at end of stream",
+                        EncodingError::Utf8(Utf8ValidationError::IncompleteSequence),
                     ));
                 }
             }

src/errors.rs

@@ -5,7 +5,7 @@ use crate::escape::EscapeError;
 use crate::events::attributes::AttrError;
 use crate::name::{NamespaceError, QName};
 use std::fmt;
-use std::io::Error as IoError;
+use std::io::{Error as IoError, ErrorKind as IoErrorKind};
 use std::sync::Arc;
 
 /// An error returned if parsed document does not correspond to the XML grammar,
@@ -221,7 +221,14 @@ impl From<IoError> for Error {
     /// Creates a new `Error::Io` from the given error
     #[inline]
     fn from(error: IoError) -> Error {
-        Self::Io(Arc::new(error))
+        match error.kind() {
+            IoErrorKind::InvalidData => Self::Encoding(
+                error
+                    .downcast::<EncodingError>()
+                    .expect("Got an IoError::InvalidData, but it wasn't downcastable to EncodingError?"),
+            ),
+            _ => Self::Io(Arc::new(error)),
+        }
     }
 }
 

src/events/attributes.rs

@@ -151,10 +151,10 @@ impl<'a> Attribute<'a> {
         use std::str::from_utf8;
 
         let decoded = match &self.value {
-            Cow::Borrowed(bytes) => Cow::Borrowed(from_utf8(bytes).map_err(EncodingError::Utf8)?),
+            Cow::Borrowed(bytes) => Cow::Borrowed(from_utf8(bytes).map_err(EncodingError::from)?),
             // Convert to owned, because otherwise Cow will be bound with wrong lifetime
             Cow::Owned(bytes) => {
-                Cow::Owned(from_utf8(bytes).map_err(EncodingError::Utf8)?.to_owned())
+                Cow::Owned(from_utf8(bytes).map_err(EncodingError::from)?.to_owned())
             }
         };
 

tests/encodings.rs

@@ -32,34 +32,52 @@ mod decode {
 #[cfg(not(feature = "encoding"))]
 mod validate {
     use super::*;
+    use quick_xml::encoding::{EncodingError, Utf8ValidationError};
+    use quick_xml::errors::Error;
 
     #[test]
-    #[should_panic(expected = "invalid UTF-8")]
     fn test_validation_fails_on_utf16le_input() {
         let src = include_bytes!("documents/encoding/utf16le-bom.xml").as_ref();
         let mut buf = vec![];
         let mut r = Reader::from_reader_validating(src);
         r.config_mut().trim_text(true);
-        loop {
+
+        let result = loop {
             match r.read_event_into(&mut buf) {
-                Ok(_) => break,
-                Err(e) => panic!("Read error: {}", e),
+                Ok(_) => panic!("Expected encoding error, didn't get one"),
+                Err(e) => break e,
+            }
+        };
+
+        // Assert that we got the specific error type
+        match result {
+            Error::Encoding(EncodingError::Utf8(Utf8ValidationError::InvalidSequence { error_len })) => {
+                assert_eq!(error_len, 1, "Expected 1-byte invalid sequence (0xFF)");
             }
+            other => panic!("Expected EncodingError::Utf8(InvalidSequence), got: {:?}", other),
         }
     }
 
     #[test]
-    #[should_panic(expected = "invalid UTF-8")]
     fn test_validation_fails_on_utf16be_input() {
         let src = include_bytes!("documents/encoding/utf16be-bom.xml").as_ref();
         let mut buf = vec![];
         let mut r = Reader::from_reader_validating(src);
         r.config_mut().trim_text(true);
-        loop {
+
+        let result = loop {
             match r.read_event_into(&mut buf) {
-                Ok(_) => break,
-                Err(e) => panic!("Read error: {}", e),
+                Ok(_) => panic!("Expected encoding error, didn't get one"),
+                Err(e) => break e,
+            }
+        };
+
+        // Assert that we got the specific error type
+        match result {
+            Error::Encoding(EncodingError::Utf8(Utf8ValidationError::InvalidSequence { error_len })) => {
+                assert_eq!(error_len, 1, "Expected 1-byte invalid sequence (0xFE)");
             }
+            other => panic!("Expected EncodingError::Utf8(InvalidSequence), got: {:?}", other),
         }
     }
 }