Added support to parse ipv6 address

Author: pdhanoyasplunk

src/client/options.rs

@@ -23,6 +23,7 @@ use serde::{de::Unexpected, Deserialize, Deserializer, Serialize};
 use serde_with::skip_serializing_none;
 use strsim::jaro_winkler;
 use typed_builder::TypedBuilder;
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
 
 #[cfg(any(
     feature = "zstd-compression",
@@ -197,60 +198,37 @@ impl ServerAddress {
                 });
             }
         }
-        let mut parts = address.split(':');
-        let hostname = match parts.next() {
-            Some(part) => {
-                if part.is_empty() {
-                    return Err(ErrorKind::InvalidArgument {
-                        message: format!(
-                            "invalid server address: \"{}\"; hostname cannot be empty",
-                            address
-                        ),
-                    }
-                    .into());
-                }
-                part
+
+        // Check if the address is IPv6, indicated by square brackets
+        let (hostname, port_str) = if address.starts_with('[') && address.ends_with(']') {
+            // Strip brackets for IPv6
+            let addr_without_brackets = &address[1..address.len() - 1];
+            match addr_without_brackets.rsplit_once(':') {
+                Some((host, port)) => (host, Some(port)),
+                None => (addr_without_brackets, None),
             }
-            None => {
-                return Err(ErrorKind::InvalidArgument {
-                    message: format!("invalid server address: \"{}\"", address),
-                }
-                .into())
+        } else {
+            match address.rsplit_once(':') {
+                Some((host, port)) => (host, Some(port)),
+                None => (address, None),
             }
         };
 
-        let port = match parts.next() {
-            Some(part) => {
-                let port = u16::from_str(part).map_err(|_| ErrorKind::InvalidArgument {
-                    message: format!(
-                        "port must be valid 16-bit unsigned integer, instead got: {}",
-                        part
-                    ),
-                })?;
-
-                if port == 0 {
-                    return Err(ErrorKind::InvalidArgument {
-                        message: format!(
-                            "invalid server address: \"{}\"; port must be non-zero",
-                            address
-                        ),
-                    }
-                    .into());
-                }
-                if parts.next().is_some() {
-                    return Err(ErrorKind::InvalidArgument {
-                        message: format!(
-                            "address \"{}\" contains more than one unescaped ':'",
-                            address
-                        ),
-                    }
-                    .into());
+        // Validate that the hostname is either a valid IPv4 or IPv6 address
+        print!("Parsing address: {}\n", hostname);
+        let is_ipv4 = Ipv4Addr::from_str(hostname).is_ok();
+        let is_ipv6 = Ipv6Addr::from_str(hostname).is_ok();
+        let localhost_v4 = IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1));
+        let localhost_v6 = IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1));
+        if !is_ipv4 && !is_ipv6 && "127.0.0.1".parse() != Ok(localhost_v4) && "::1".parse() != Ok(localhost_v6) {
+             return Err(ErrorKind::InvalidArgument {
+                    message: format!("invalid hostname: \"{}\"", hostname),
                 }
+                .into())
+        }
 
-                Some(port)
-            }
-            None => None,
-        };
+        // If there's a port, try to parse it
+        let port = port_str.and_then(|port| port.parse::<u16>().ok());
 
         Ok(ServerAddress::Tcp {
             host: hostname.to_lowercase(),