impl Display for errors

Author: JPDye

src/client/legacy/connect/proxy/socks/mod.rs

@@ -57,6 +57,27 @@ where
     }
 }
 
+impl<C> std::fmt::Display for SocksError<C> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str("SOCKS error: ")?;
+
+        match self {
+            Self::Inner(_) => f.write_str("failed to create underlying connection"),
+            Self::Io(_) => f.write_str("io error during SOCKS handshake"),
+
+            Self::DnsFailure => f.write_str("could not resolve to acceptable address type"),
+            Self::MissingHost => f.write_str("missing destination host"),
+            Self::MissingPort => f.write_str("missing destination port"),
+
+            Self::Parsing(_) => f.write_str("failed parsing server response"),
+            Self::Serialize(_) => f.write_str("failed serialize request"),
+
+            Self::V4(e) => e.fmt(f),
+            Self::V5(e) => e.fmt(f),
+        }
+    }
+}
+
 impl<C> From<std::io::Error> for SocksError<C> {
     fn from(err: std::io::Error) -> Self {
         Self::Io(err)

src/client/legacy/connect/proxy/socks/v4/errors.rs

@@ -11,3 +11,12 @@ impl From<Status> for SocksV4Error {
         Self::Command(err)
     }
 }
+
+impl std::fmt::Display for SocksV4Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::IpV6 => f.write_str("IPV6 is not supported"),
+            Self::Command(status) => status.fmt(f),
+        }
+    }
+}

src/client/legacy/connect/proxy/socks/v4/messages.rs

@@ -123,3 +123,14 @@ impl TryFrom<u8> for Status {
         })
     }
 }
+
+impl std::fmt::Display for Status {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(match self {
+            Self::Success => "success",
+            Self::Failed => "server failed to execute command",
+            Self::IdentFailure => "server ident service failed",
+            Self::IdentMismatch => "server ident service did not recognise client identifier",
+        })
+    }
+}

src/client/legacy/connect/proxy/socks/v5/errors.rs

@@ -25,3 +25,23 @@ impl From<AuthError> for SocksV5Error {
         Self::Auth(err)
     }
 }
+
+impl std::fmt::Display for SocksV5Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::HostTooLong => f.write_str("host address is more than 255 characters"),
+            Self::Command(e) => e.fmt(f),
+            Self::Auth(e) => e.fmt(f),
+        }
+    }
+}
+
+impl std::fmt::Display for AuthError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(match self {
+            Self::Unsupported => "server does not support user/pass authentication",
+            Self::MethodMismatch => "server implements authentication incorrectly",
+            Self::Failed => "credentials not accepted",
+        })
+    }
+}

src/client/legacy/connect/proxy/socks/v5/messages.rs

@@ -329,3 +329,19 @@ impl TryFrom<u8> for AuthMethod {
         })
     }
 }
+
+impl std::fmt::Display for Status {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(match self {
+            Self::Success => "success",
+            Self::GeneralServerFailure => "general server failure",
+            Self::ConnectionNotAllowed => "connection not allowed",
+            Self::NetworkUnreachable => "network unreachable",
+            Self::HostUnreachable => "host unreachable",
+            Self::ConnectionRefused => "connection refused",
+            Self::TtlExpired => "ttl expired",
+            Self::CommandNotSupported => "command not supported",
+            Self::AddressTypeNotSupported => "address type not supported",
+        })
+    }
+}