add more details for utf8 errors for debugging

Signed-off-by: Benjamin <5719034+bnjjj@users.noreply.github.com>

Author: bnjjj

examples/autobahn-client.rs

@@ -39,7 +39,7 @@ fn main() {
     for case in 1..=total {
         if let Err(e) = run_test(case) {
             match e {
-                Error::ConnectionClosed | Error::Protocol(_) | Error::Utf8 => (),
+                Error::ConnectionClosed | Error::Protocol(_) | Error::Utf8(_) => (),
                 err => error!("test: {}", err),
             }
         }

examples/autobahn-server.rs

@@ -36,7 +36,7 @@ fn main() {
             Ok(stream) => {
                 if let Err(err) = handle_client(stream) {
                     match err {
-                        Error::ConnectionClosed | Error::Protocol(_) | Error::Utf8 => (),
+                        Error::ConnectionClosed | Error::Protocol(_) | Error::Utf8(_) => (),
                         e => error!("test: {}", e),
                     }
                 }

src/error.rs

@@ -57,8 +57,8 @@ pub enum Error {
     #[error("Write buffer is full")]
     WriteBufferFull(Message),
     /// UTF coding error.
-    #[error("UTF-8 encoding error")]
-    Utf8,
+    #[error("UTF-8 encoding error: {0}")]
+    Utf8(String),
     /// Attack attempt detected.
     #[error("Attack attempt detected")]
     AttackAttempt,
@@ -76,14 +76,14 @@ pub enum Error {
 }
 
 impl From<str::Utf8Error> for Error {
-    fn from(_: str::Utf8Error) -> Self {
-        Error::Utf8
+    fn from(err: str::Utf8Error) -> Self {
+        Error::Utf8(err.to_string())
     }
 }
 
 impl From<string::FromUtf8Error> for Error {
-    fn from(_: string::FromUtf8Error) -> Self {
-        Error::Utf8
+    fn from(err: string::FromUtf8Error) -> Self {
+        Error::Utf8(err.to_string())
     }
 }
 
@@ -103,8 +103,8 @@ impl From<http::header::InvalidHeaderName> for Error {
 
 #[cfg(feature = "handshake")]
 impl From<http::header::ToStrError> for Error {
-    fn from(_: http::header::ToStrError) -> Self {
-        Error::Utf8
+    fn from(err: http::header::ToStrError) -> Self {
+        Error::Utf8(err.to_string())
     }
 }
 

src/handshake/client.rs

@@ -149,7 +149,15 @@ pub fn generate_request(mut request: Request) -> Result<(Vec<u8>, String)> {
                 HeaderName::from_bytes(header.as_bytes()).unwrap(),
             ))
         })?;
-        write!(req, "{header}: {value}\r\n", header = header, value = value.to_str()?).unwrap();
+        write!(
+            req,
+            "{header}: {value}\r\n",
+            header = header,
+            value = value.to_str().map_err(|err| {
+                Error::Utf8(format!("{err} for header name '{header}' with value: {value:?}"))
+            })?
+        )
+        .unwrap();
     }
 
     // Now we must ensure that the headers that we've written once are not anymore present in the map.
@@ -176,7 +184,15 @@ pub fn generate_request(mut request: Request) -> Result<(Vec<u8>, String)> {
             name = "Origin";
         }
 
-        writeln!(req, "{}: {}\r", name, v.to_str()?).unwrap();
+        writeln!(
+            req,
+            "{}: {}\r",
+            name,
+            v.to_str().map_err(|err| {
+                Error::Utf8(format!("{err} for header name '{name}' with value: {v:?}"))
+            })?
+        )
+        .unwrap();
     }
 
     writeln!(req, "\r").unwrap();

src/protocol/message.rs

@@ -33,10 +33,11 @@ mod string_collect {
             if let Some(mut incomplete) = self.incomplete.take() {
                 if let Some((result, rest)) = incomplete.try_complete(input) {
                     input = rest;
-                    if let Ok(text) = result {
-                        self.data.push_str(text);
-                    } else {
-                        return Err(Error::Utf8);
+                    match result {
+                        Ok(text) => self.data.push_str(text),
+                        Err(result_bytes) => {
+                            return Err(Error::Utf8(String::from_utf8_lossy(result_bytes).into()))
+                        }
                     }
                 } else {
                     input = &[];
@@ -55,9 +56,9 @@ mod string_collect {
                         self.incomplete = Some(incomplete_suffix);
                         Ok(())
                     }
-                    Err(DecodeError::Invalid { valid_prefix, .. }) => {
+                    Err(DecodeError::Invalid { valid_prefix, invalid_sequence, .. }) => {
                         self.data.push_str(valid_prefix);
-                        Err(Error::Utf8)
+                        Err(Error::Utf8(String::from_utf8_lossy(invalid_sequence).into()))
                     }
                 }
             } else {
@@ -66,8 +67,8 @@ mod string_collect {
         }
 
         pub fn into_string(self) -> Result<String> {
-            if self.incomplete.is_some() {
-                Err(Error::Utf8)
+            if let Some(incomplete) = self.incomplete {
+                Err(Error::Utf8(format!("incomplete string: {:?}", incomplete)))
             } else {
                 Ok(self.data)
             }