impl Display for SocketAddress

Author: yanganto

lightning/src/ln/msgs.rs

@@ -45,7 +45,7 @@ use core::fmt;
 use core::fmt::Debug;
 use core::ops::Deref;
 #[cfg(feature = "std")]
-use core::str::FromStr;
+use core::{fmt::Display, str::FromStr};
 use crate::io::{self, Cursor, Read};
 use crate::io_extras::read_to_end;
 
@@ -918,6 +918,8 @@ pub enum SocketAddressParseError {
 	InvalidInput,
 	/// Invalid port
 	InvalidPort,
+	/// Invalid onion v2 address
+	InvalidOnionV2,
 	/// Invalid onion v3 address
 	InvalidOnionV3,
 }
@@ -929,6 +931,7 @@ impl fmt::Display for SocketAddressParseError {
 			SocketAddressParseError::InvalidInput => write!(f, "Invalid input format. \
 				Expected: \"<ipv4>:<port>\", \"[<ipv6>]:<port>\", \"<onion address>.onion:<port>\" or \"<hostname>:<port>\""),
 			SocketAddressParseError::InvalidPort => write!(f, "Invalid port"),
+			SocketAddressParseError::InvalidOnionV2 => write!(f, "Invalid onion v2 address"),
 			SocketAddressParseError::InvalidOnionV3 => write!(f, "Invalid onion v3 address"),
 		}
 	}
@@ -958,16 +961,37 @@ impl From<std::net::SocketAddr> for SocketAddress {
 		}
 }
 
+/// Parses an OnionV2 host and port into a [`SocketAddress::OnionV2`].
+///
+/// The host part must end with ".onion".
+pub fn parse_onion_v2_address(host: &str) -> Result<SocketAddress, SocketAddressParseError> {
+	if host.ends_with(".onion") {
+		let domain = &host[..host.len() - ".onion".len()];
+		if domain.len() != 16 {
+			return Err(SocketAddressParseError::InvalidOnionV2);
+		}
+		let onion = base32::Alphabet::RFC4648 { padding: false }.decode(&domain).map_err(|_| SocketAddressParseError::InvalidOnionV2)?;
+		if onion.len() != 12 {
+			return Err(SocketAddressParseError::InvalidOnionV2);
+		}
+		let mut bytes = [0; 12];
+		bytes.copy_from_slice(&onion);
+		return Ok(SocketAddress::OnionV2(bytes));
+	} else {
+		return Err(SocketAddressParseError::InvalidInput);
+	}
+}
+
 /// Parses an OnionV3 host and port into a [`SocketAddress::OnionV3`].
 ///
 /// The host part must end with ".onion".
-pub fn parse_onion_address(host: &str, port: u16) -> Result<SocketAddress, SocketAddressParseError> {
+pub fn parse_onion_v3_address(host: &str, port: u16) -> Result<SocketAddress, SocketAddressParseError> {
 	if host.ends_with(".onion") {
 		let domain = &host[..host.len() - ".onion".len()];
 		if domain.len() != 56 {
 			return Err(SocketAddressParseError::InvalidOnionV3);
 		}
-		let onion =  base32::Alphabet::RFC4648 { padding: false }.decode(&domain).map_err(|_| SocketAddressParseError::InvalidOnionV3)?;
+		let onion = base32::Alphabet::RFC4648 { padding: false }.decode(&domain).map_err(|_| SocketAddressParseError::InvalidOnionV3)?;
 		if onion.len() != 35 {
 			return Err(SocketAddressParseError::InvalidOnionV3);
 		}
@@ -984,6 +1008,40 @@ pub fn parse_onion_address(host: &str, port: u16) -> Result<SocketAddress, Socke
 	}
 }
 
+/// [`SocketAddress::OnionV2`] to onion address string
+pub fn to_onion_v2_string(bytes: &[u8; 12]) -> String {
+	let onion = base32::Alphabet::RFC4648 { padding: false }.encode(&bytes[..]);
+	format!("{}.onion", onion)
+}
+
+/// [`SocketAddress::OnionV3`] to onion address string
+pub fn to_onion_v3_string(key: &[u8; 32], checksum: &u16, version: &u8, port: &u16) -> String{
+	let [first_checksum_flag, second_checksum_flag] = checksum.to_be_bytes();
+	let mut addr = vec![*version, first_checksum_flag, second_checksum_flag];
+	addr.extend_from_slice(key);
+	let onion = base32::Alphabet::RFC4648 { padding: false }.encode(&addr);
+	format!("{}.onion:{}", onion, port)
+}
+
+#[cfg(feature = "std")]
+impl Display for SocketAddress {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		match self {
+			SocketAddress::TcpIpV4{addr, port} => write!(f, "{}:{}", std::net::Ipv4Addr::from(*addr), port)?,
+			SocketAddress::TcpIpV6{addr, port} => write!(f, "[{}]:{}", std::net::Ipv6Addr::from(*addr), port)?,
+			SocketAddress::OnionV2(bytes) => write!(f, "{}", to_onion_v2_string(&bytes))?,
+			SocketAddress::OnionV3 {
+				ed25519_pubkey,
+				checksum,
+				version,
+				port,
+			} => write!(f, "{}", to_onion_v3_string(&ed25519_pubkey, checksum, version, port))?,
+			SocketAddress::Hostname { hostname, port } => write!(f, "{}:{}", hostname, port)?,
+		}
+		Ok(())
+	}
+}
+
 #[cfg(feature = "std")]
 impl FromStr for SocketAddress {
 	type Err = SocketAddressParseError;
@@ -994,12 +1052,13 @@ impl FromStr for SocketAddress {
 			Err(_) => {
 				let trimmed_input = match s.rfind(":") {
 					Some(pos) => pos,
-					None => return Err(SocketAddressParseError::InvalidInput),
+					None if s.ends_with(".onion") => return parse_onion_v2_address(s),
+					_ => return Err(SocketAddressParseError::InvalidInput),
 				};
 				let host = &s[..trimmed_input];
 				let port: u16 = s[trimmed_input + 1..].parse().map_err(|_| SocketAddressParseError::InvalidPort)?;
 				if host.ends_with(".onion") {
-					return parse_onion_address(host, port);
+					return parse_onion_v3_address(host, port);
 				};
 				if let Ok(hostname) = Hostname::try_from(s[..trimmed_input].to_string()) {
 					return Ok(SocketAddress::Hostname { hostname, port });
@@ -4066,32 +4125,41 @@ mod tests {
 	#[test]
 	#[cfg(feature = "std")]
 	fn test_socket_address_from_str() {
-		assert_eq!(SocketAddress::TcpIpV4 {
+		let v4 = SocketAddress::TcpIpV4 {
 			addr: Ipv4Addr::new(127, 0, 0, 1).octets(),
 			port: 1234,
-		}, SocketAddress::from_str("127.0.0.1:1234").unwrap());
+		};
+		assert_eq!(v4, SocketAddress::from_str("127.0.0.1:1234").unwrap());
+		assert_eq!(v4, SocketAddress::from_str(&v4.to_string()).unwrap());
 
-		assert_eq!(SocketAddress::TcpIpV6 {
+		let v6 = SocketAddress::TcpIpV6 {
 			addr: Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).octets(),
 			port: 1234,
-		}, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
-		assert_eq!(
-			SocketAddress::Hostname {
+		};
+		assert_eq!(v6, SocketAddress::from_str("[0:0:0:0:0:0:0:1]:1234").unwrap());
+		assert_eq!(v6, SocketAddress::from_str(&v6.to_string()).unwrap());
+
+		let hostname = SocketAddress::Hostname {
 				hostname: Hostname::try_from("lightning-node.mydomain.com".to_string()).unwrap(),
 				port: 1234,
-			}, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
-		assert_eq!(
-			SocketAddress::Hostname {
-				hostname: Hostname::try_from("example.com".to_string()).unwrap(),
-				port: 1234,
-			}, SocketAddress::from_str("example.com:1234").unwrap());
-		assert_eq!(SocketAddress::OnionV3 {
+		};
+		assert_eq!(hostname, SocketAddress::from_str("lightning-node.mydomain.com:1234").unwrap());
+		assert_eq!(hostname, SocketAddress::from_str(&hostname.to_string()).unwrap());
+
+		let v2 = SocketAddress::OnionV2 ([37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107]);
+		assert_eq!(v2, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
+		assert_eq!(v2, SocketAddress::from_str(&v2.to_string()).unwrap());
+
+		let v3 = SocketAddress::OnionV3 {
 			ed25519_pubkey: [37, 24, 75, 5, 25, 73, 117, 194, 139, 102, 182, 107, 4, 105, 247, 246, 85,
 			111, 177, 172, 49, 137, 167, 155, 64, 221, 163, 47, 31, 33, 71, 3],
 			checksum: 48326,
 			version: 121,
 			port: 1234
-		}, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
+		};
+		assert_eq!(v3, SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6y2ymmju6nubxndf4pscryd.onion:1234").unwrap());
+		assert_eq!(v3, SocketAddress::from_str(&v3.to_string()).unwrap());
+
 		assert_eq!(Err(SocketAddressParseError::InvalidOnionV3), SocketAddress::from_str("pg6mmjiyjmcrsslvykfwnntlaru7p5svn6.onion:1234"));
 		assert_eq!(Err(SocketAddressParseError::InvalidInput), SocketAddress::from_str("127.0.0.1@1234"));
 		assert_eq!(Err(SocketAddressParseError::InvalidInput), "".parse::<SocketAddress>());

lightning/src/util/ser.rs

@@ -1297,6 +1297,13 @@ impl Hostname {
 		(&self.0).len() as u8
 	}
 }
+#[cfg(feature = "std")]
+impl core::fmt::Display for Hostname {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		write!(f, "{}", self.0)?;
+		Ok(())
+	}
+}
 impl Deref for Hostname {
 	type Target = String;