Remove all io::Error(String) in favor of io::Error(Error)

harmless-tech · harmless-tech · commit 2c156ffc3693 · 2025-02-09T18:45:47.000-05:00
diff --git a/README.md b/README.md
@@ -6,7 +6,9 @@
 
 SOCKS proxy support for Rust.
 
-Fork of [sfackler/rust-socks](https://github.com/sfackler/rust-socks).
+A fork of [sfackler/rust-socks](https://github.com/sfackler/rust-socks).
+
+See [changes](CHANGELOG.md).
 
 ## Using
 
diff --git a/src/error.rs b/src/error.rs
@@ -1,24 +1,80 @@
-// TODO: Replace all string errors with this!
-
-use std::{fmt::Formatter, io};
+use std::{fmt::Formatter, io, net::SocketAddrV6, string::FromUtf8Error};
 
 /// Errors from socks2
 #[derive(Debug)]
 #[non_exhaustive]
 #[allow(missing_docs)]
 pub enum Error {
-    // TODO: Add docs for all errors?
-    InvalidSocksAddress {
-        addr: String,
-    },
-    InvalidPortValue {
-        addr: String,
-        port: String,
-    },
+    // TargetAddr
+    /// Domain name and port could not be parsed.
+    InvalidSocksAddress { addr: String },
+    /// Port could not be parsed or is over `u16::MAX`.
+    InvalidPortValue { addr: String, port: String },
+
+    // Socks4/Socks5
+    /// Response from server had an invalid version byte.
+    InvalidResponseVersion { version: u8 },
+    /// Unknown response code
+    UnknownResponseCode { code: u8 },
+    /// Connection refused or the request was rejected or failed.
+    ConnectionRefused { code: u8 },
+
+    // Socks4
+    /// Rejected request due to server not connecting to idnetd on the client.
+    /// Rejected request due to idnetd and client program not having a matching userid.
+    RejectedRequestID { code: u8 },
+    /// Socks4 does not support IPv6.
+    Socks4NoIPv6 { addr: SocketAddrV6 },
+
+    // Socks5
+    /// Domain received from server was not valid utf8.
+    MalformedDomain { err: FromUtf8Error },
+    /// Received an invalid address type from the server.
+    SOCKS5InvalidAddressType { code: u8 },
+    /// Unknown error from the server.
+    UnknownServerFailure { code: u8 },
+    /// Server ruleset does not allow connection.
+    ServerRefusedByRuleSet {},
+    /// Network unreachable.
+    ServerNetworkUnreachable {},
+    /// Host unreachable.
+    ServerHostUnreachable {},
+    /// Time to live expired.
+    ServerTTLExpired {},
+    /// Server does not support the sent command.
+    ServerCmdNotSupported {},
+    /// Server does not support the address kind.
+    ServerAddressNotSupported {},
+    /// Reserved byte from server is invalid.
+    InvalidReservedByte { byte: u8 },
+    /// Domains must have a length between 1 and 255 inclusive.
+    InvalidDomainLength { domain: String, length: usize },
+    /// No acceptable auth methods.
+    NoAuthMethods { method: u8 },
+    /// Unknown auth method.
+    UnknownAuthMethod { method: u8 },
+    /// Invalid username.
+    InvalidUsername { username: String, length: usize },
+    /// Invalid password.
+    InvalidPassword { password: (), length: usize },
+    /// Auth with password failed.
+    FailedPasswordAuth {},
+
+    // UDP
+    /// Reserved bytes from server is invalid.
+    InvalidReservedBytes { bytes: u16 },
+    /// Fragment id from the server is invalid.
+    InvalidFragmentID { fid: u8 },
+    /// UDP Bind Client has a limit of 4 GiB for buffers.
     /// Only occurs when using `Socks5Datagram` on windows.
-    WinUDP4GiBLimit {
-        size: usize,
-    },
+    WinUDP4GiBLimit { size: usize },
+}
+
+/// Takes an `std::io::Error` and attempts to unwrap it into a `socks2::Error`.
+/// Returns a `Some(&socks2::Error)` on success.
+#[must_use]
+pub fn unwrap_io_to_socks2_error(e: &io::Error) -> Option<&Error> {
+    e.get_ref().and_then(|i| i.downcast_ref())
 }
 
 impl Error {
@@ -39,7 +95,34 @@ impl PartialEq for Error {
             };
         }
 
-        peq!(InvalidSocksAddress, InvalidPortValue, WinUDP4GiBLimit)
+        peq!(
+            InvalidSocksAddress,
+            InvalidPortValue,
+            InvalidResponseVersion,
+            UnknownResponseCode,
+            ConnectionRefused,
+            RejectedRequestID,
+            Socks4NoIPv6,
+            MalformedDomain,
+            SOCKS5InvalidAddressType,
+            UnknownServerFailure,
+            ServerRefusedByRuleSet,
+            ServerNetworkUnreachable,
+            ServerHostUnreachable,
+            ServerTTLExpired,
+            ServerCmdNotSupported,
+            ServerAddressNotSupported,
+            InvalidReservedByte,
+            InvalidDomainLength,
+            NoAuthMethods,
+            UnknownAuthMethod,
+            InvalidUsername,
+            InvalidPassword,
+            FailedPasswordAuth,
+            InvalidReservedBytes,
+            InvalidFragmentID,
+            WinUDP4GiBLimit
+        )
     }
 }
 
@@ -56,6 +139,29 @@ impl From<Error> for io::Error {
         from_error!(
             (InvalidSocksAddress, InvalidInput),
             (InvalidPortValue, InvalidInput),
+            (InvalidResponseVersion, InvalidData),
+            (UnknownResponseCode, Other),
+            (ConnectionRefused, ConnectionRefused),
+            (RejectedRequestID, PermissionDenied),
+            (Socks4NoIPv6, InvalidInput),
+            (MalformedDomain, InvalidData),
+            (SOCKS5InvalidAddressType, InvalidData),
+            (UnknownServerFailure, Other),
+            (ServerRefusedByRuleSet, ConnectionRefused),
+            (ServerNetworkUnreachable, ConnectionAborted),
+            (ServerHostUnreachable, ConnectionAborted),
+            (ServerTTLExpired, Interrupted),
+            (ServerCmdNotSupported, Unsupported),
+            (ServerAddressNotSupported, Unsupported),
+            (InvalidReservedByte, Other),
+            (InvalidDomainLength, InvalidInput),
+            (NoAuthMethods, Unsupported),
+            (UnknownAuthMethod, Unsupported),
+            (InvalidUsername, InvalidInput),
+            (InvalidPassword, InvalidInput),
+            (FailedPasswordAuth, PermissionDenied),
+            (InvalidReservedBytes, InvalidData),
+            (InvalidFragmentID, InvalidData),
             (WinUDP4GiBLimit, InvalidInput)
         )
     }
@@ -70,6 +176,29 @@ impl std::fmt::Display for Error {
             Self::InvalidPortValue { addr, port } => {
                 write!(f, "invalid port value '{port}' for '{addr}'")
             },
+            Self::InvalidResponseVersion { version } => write!(f, "invalid response version '{version}'"),
+            Self::UnknownResponseCode { code } => write!(f, "unknown response code '{code}'"),
+            Self::ConnectionRefused { code } => write!(f, "connection refused or the request was rejected or failed '{code}'"),
+            Self::RejectedRequestID { code } => write!(f, "request rejected because of idnetd with code '{code}'"),
+            Self::Socks4NoIPv6 { addr } => write!(f, "SOCKS4 does not support IPv6 '{addr}'"),
+            Self::MalformedDomain { err } => write!(f, "malformed domain {err}"),
+            Self::SOCKS5InvalidAddressType { code } => write!(f, "invalid address type {code}"),
+            Self::UnknownServerFailure { code } => write!(f, "unknown server failure {code}"),
+            Self::ServerRefusedByRuleSet {} => write!(f, "connection not allowed by ruleset"),
+            Self::ServerNetworkUnreachable {} => write!(f, "network unreachable"),
+            Self::ServerHostUnreachable {} => write!(f, "host unreachable"),
+            Self::ServerTTLExpired {} => write!(f, "TTL expired"),
+            Self::ServerCmdNotSupported {} => write!(f, "command not supported"),
+            Self::ServerAddressNotSupported {} => write!(f, "address kind not supported"),
+            Self::InvalidReservedByte { byte } => write!(f, "invalid reserved byte '{byte}'"),
+            Self::InvalidDomainLength { domain, length } => write!(f, "domain '{domain}' with length '{length}' is not between 1-255 inclusive"),
+            Self::NoAuthMethods { method } => write!(f, "no acceptable authentication methods '{method}'"),
+            Self::UnknownAuthMethod { method } => write!(f, "unknown authentication method '{method}'"),
+            Self::InvalidUsername {username, length} => write!(f, "invalid username '{username}' with length '{length}'"),
+            Self::InvalidPassword {password, length} => write!(f, "invalid password '{password:?}' with length '{length}'"),
+            Self::FailedPasswordAuth {} => write!(f, "password authentication failed"),
+            Self::InvalidReservedBytes { bytes } => write!(f, "invalid reserved bytes '{bytes}'"),
+            Self::InvalidFragmentID {fid} => write!(f, "invalid fragment ID '{fid}'"),
             Self::WinUDP4GiBLimit {size} => write!(f, "tried to write '{size}' bytes to UDPSocket, but writev/readv has a 4 GiB limit on windows"),
         }
     }
diff --git a/src/lib.rs b/src/lib.rs
@@ -24,7 +24,7 @@ pub use v5::bind::Socks5Listener;
 #[cfg(feature = "udp")]
 pub use v5::udp::Socks5Datagram;
 
-pub use error::Error;
+pub use error::{unwrap_io_to_socks2_error, Error};
 
 mod error;
 #[cfg(feature = "udp")]
@@ -184,18 +184,14 @@ impl ToTargetAddr for &str {
 mod test {
     use super::*;
 
-    fn unwrap_io_error(e: &io::Error) -> Option<&Error> {
-        e.get_ref().and_then(|i| i.downcast_ref())
-    }
-
     #[test]
     fn domains_to_target_addr() {
         assert_eq!(
             "localhost:80".to_target_addr().unwrap(),
             TargetAddr::Domain("localhost".to_owned(), 80)
         );
         assert_eq!(
-            unwrap_io_error(&"localhost:".to_target_addr().unwrap_err()),
+            unwrap_io_to_socks2_error(&"localhost:".to_target_addr().unwrap_err()),
             Some(&Error::InvalidPortValue {
                 addr: String::new(),
                 port: String::new()
diff --git a/src/v4.rs b/src/v4.rs
@@ -1,3 +1,4 @@
+use crate::Error;
 use byteorder::{BigEndian, ReadBytesExt};
 use std::{
     io::{self, Read},
@@ -11,41 +12,19 @@ fn read_response(socket: &mut TcpStream) -> io::Result<SocketAddrV4> {
     socket.read_exact(&mut response)?;
     let mut response = &response[..];
 
-    if response.read_u8()? != 0 {
-        return Err(io::Error::new(
-            io::ErrorKind::InvalidData,
-            "invalid response version",
-        ));
+    {
+        let version = response.read_u8()?;
+        if version != 0 {
+            return Err(Error::InvalidResponseVersion { version }.into_io());
+        }
     }
 
     match response.read_u8()? {
         90 => {}
-        91 => {
-            return Err(io::Error::new(
-                io::ErrorKind::Other,
-                "request rejected or failed",
-            ))
-        }
-        92 => {
-            return Err(io::Error::new(
-                io::ErrorKind::PermissionDenied,
-                "request rejected because SOCKS server cannot connect to \
-                                       idnetd on the client",
-            ))
-        }
-        93 => {
-            return Err(io::Error::new(
-                io::ErrorKind::PermissionDenied,
-                "request rejected because the client program and identd \
-                                       report different user-ids",
-            ))
-        }
-        _ => {
-            return Err(io::Error::new(
-                io::ErrorKind::InvalidData,
-                "invalid response code",
-            ))
-        }
+        91 => return Err(Error::ConnectionRefused { code: 91 }.into_io()),
+        92 => return Err(Error::RejectedRequestID { code: 92 }.into_io()),
+        93 => return Err(Error::RejectedRequestID { code: 93 }.into_io()),
+        code => return Err(Error::UnknownResponseCode { code }.into_io()),
     }
 
     let port = response.read_u16::<BigEndian>()?;
@@ -58,7 +37,7 @@ fn read_response(socket: &mut TcpStream) -> io::Result<SocketAddrV4> {
 pub mod client {
     use crate::{
         v4::{read_response, NULL_BYTE},
-        TargetAddr, ToTargetAddr,
+        Error, TargetAddr, ToTargetAddr,
     };
     use byteorder::{BigEndian, WriteBytesExt};
     use std::{
@@ -85,7 +64,7 @@ pub mod client {
         /// locally and passing a `TargetAddr::Ip`.
         ///
         /// # Errors
-        /// - `io::Error(std::io::ErrorKind::*, socks2::Error::*)`
+        /// - `io::Error(std::io::ErrorKind::*, socks2::Error::*?)`
         pub fn connect<T, U>(proxy: T, target: &U, userid: &str) -> io::Result<Self>
         where
             T: ToSocketAddrs,
@@ -115,11 +94,8 @@ pub mod client {
                 TargetAddr::Ip(addr) => {
                     let addr = match addr {
                         SocketAddr::V4(addr) => addr,
-                        SocketAddr::V6(_) => {
-                            return Err(io::Error::new(
-                                io::ErrorKind::InvalidInput,
-                                "SOCKS4 does not support IPv6",
-                            ));
+                        SocketAddr::V6(addr) => {
+                            return Err(Error::Socks4NoIPv6 { addr }.into_io());
                         }
                     };
                     packet.write_u16::<BigEndian>(addr.port())?;
@@ -223,7 +199,7 @@ pub mod bind {
         /// `target`.
         ///
         /// # Errors
-        /// - `io::Error(std::io::ErrorKind::*, socks2::Error::*)`
+        /// - `io::Error(std::io::ErrorKind::*, socks2::Error::*?)`
         pub fn bind<T, U>(proxy: T, target: &U, userid: &str) -> io::Result<Self>
         where
             T: ToSocketAddrs,
@@ -238,7 +214,7 @@ pub mod bind {
         /// connection to it.
         ///
         /// # Errors
-        /// - `io::Error(std::io::ErrorKind::*, socks2::Error::*)`
+        /// - `io::Error(std::io::ErrorKind::*, socks2::Error::*?)`
         pub fn proxy_addr(&self) -> io::Result<SocketAddr> {
             if self.0.proxy_addr.ip().octets() == [0, 0, 0, 0] {
                 let port = self.0.proxy_addr.port();
@@ -260,7 +236,7 @@ pub mod bind {
         /// before this method is called.
         ///
         /// # Errors
-        /// - `io::Error(std::io::ErrorKind::*, socks2::Error::*)`
+        /// - `io::Error(std::io::ErrorKind::*, socks2::Error::*?)`
         pub fn accept(mut self) -> io::Result<Socks4Stream> {
             self.0.proxy_addr = read_response(&mut self.0.socket)?;
             Ok(self.0)
diff --git a/src/v5.rs b/src/v5.rs
