Add turmoil::net::lookup_host

teskje · teskje · commit 866c227c53f7 · 2025-12-23T15:32:33.000+01:00
... mirroring `tokio::net::lookup_host`.

The tokio method returns an error if the lookup fails, whereas turmoil's
existing `ToSocketAddrs` implementation panics. To ensure consistent
behavior, this commit thus also changes `ToSocketAddrs::to_socket_addr`
to return an error as well.
diff --git a/src/dns.rs b/src/dns.rs
@@ -1,6 +1,7 @@
 use indexmap::IndexMap;
 #[cfg(feature = "regex")]
 use regex::Regex;
+use std::io;
 use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
 
 use crate::ip::IpVersionAddrIter;
@@ -30,7 +31,7 @@ pub trait ToIpAddrs: sealed::Sealed {
 /// A simulated version of `tokio::net::ToSocketAddrs`.
 pub trait ToSocketAddrs: sealed::Sealed {
     #[doc(hidden)]
-    fn to_socket_addr(&self, dns: &Dns) -> SocketAddr;
+    fn to_socket_addr(&self, dns: &Dns) -> io::Result<SocketAddr>;
 }
 
 impl Dns {
@@ -116,73 +117,76 @@ impl ToIpAddrs for Regex {
 
 // Hostname and port
 impl ToSocketAddrs for (String, u16) {
-    fn to_socket_addr(&self, dns: &Dns) -> SocketAddr {
+    fn to_socket_addr(&self, dns: &Dns) -> io::Result<SocketAddr> {
         (&self.0[..], self.1).to_socket_addr(dns)
     }
 }
 
 impl ToSocketAddrs for (&str, u16) {
-    fn to_socket_addr(&self, dns: &Dns) -> SocketAddr {
+    fn to_socket_addr(&self, dns: &Dns) -> io::Result<SocketAddr> {
         // When IP address is passed directly as a str.
         if let Ok(ip) = self.0.parse::<IpAddr>() {
-            return (ip, self.1).into();
+            return Ok((ip, self.1).into());
         }
 
         match dns.names.get(self.0) {
-            Some(ip) => (*ip, self.1).into(),
-            None => panic!("no ip address found for a hostname: {}", self.0),
+            Some(ip) => Ok((*ip, self.1).into()),
+            None => Err(io::Error::other(format!(
+                "no ip address found for a hostname: {}",
+                self.0
+            ))),
         }
     }
 }
 
 impl ToSocketAddrs for SocketAddr {
-    fn to_socket_addr(&self, _: &Dns) -> SocketAddr {
-        *self
+    fn to_socket_addr(&self, _: &Dns) -> io::Result<SocketAddr> {
+        Ok(*self)
     }
 }
 
 impl ToSocketAddrs for SocketAddrV4 {
-    fn to_socket_addr(&self, _: &Dns) -> SocketAddr {
-        SocketAddr::V4(*self)
+    fn to_socket_addr(&self, _: &Dns) -> io::Result<SocketAddr> {
+        Ok(SocketAddr::V4(*self))
     }
 }
 
 impl ToSocketAddrs for SocketAddrV6 {
-    fn to_socket_addr(&self, _: &Dns) -> SocketAddr {
-        SocketAddr::V6(*self)
+    fn to_socket_addr(&self, _: &Dns) -> io::Result<SocketAddr> {
+        Ok(SocketAddr::V6(*self))
     }
 }
 
 impl ToSocketAddrs for (IpAddr, u16) {
-    fn to_socket_addr(&self, _: &Dns) -> SocketAddr {
-        (*self).into()
+    fn to_socket_addr(&self, _: &Dns) -> io::Result<SocketAddr> {
+        Ok((*self).into())
     }
 }
 
 impl ToSocketAddrs for (Ipv4Addr, u16) {
-    fn to_socket_addr(&self, _: &Dns) -> SocketAddr {
-        (*self).into()
+    fn to_socket_addr(&self, _: &Dns) -> io::Result<SocketAddr> {
+        Ok((*self).into())
     }
 }
 
 impl ToSocketAddrs for (Ipv6Addr, u16) {
-    fn to_socket_addr(&self, _: &Dns) -> SocketAddr {
-        (*self).into()
+    fn to_socket_addr(&self, _: &Dns) -> io::Result<SocketAddr> {
+        Ok((*self).into())
     }
 }
 
 impl<T: ToSocketAddrs + ?Sized> ToSocketAddrs for &T {
-    fn to_socket_addr(&self, dns: &Dns) -> SocketAddr {
+    fn to_socket_addr(&self, dns: &Dns) -> io::Result<SocketAddr> {
         (**self).to_socket_addr(dns)
     }
 }
 
 impl ToSocketAddrs for str {
-    fn to_socket_addr(&self, dns: &Dns) -> SocketAddr {
+    fn to_socket_addr(&self, dns: &Dns) -> io::Result<SocketAddr> {
         let socketaddr: Result<SocketAddr, _> = self.parse();
 
         if let Ok(s) = socketaddr {
-            return s;
+            return Ok(s);
         }
 
         // Borrowed from std
@@ -191,7 +195,7 @@ impl ToSocketAddrs for str {
             ($e:expr, $msg:expr) => {
                 match $e {
                     Some(r) => r,
-                    None => panic!("Unable to parse dns: {}", $msg),
+                    None => return Err(io::Error::new(io::ErrorKind::InvalidInput, $msg)),
                 }
             };
         }
@@ -205,7 +209,7 @@ impl ToSocketAddrs for str {
 }
 
 impl ToSocketAddrs for String {
-    fn to_socket_addr(&self, dns: &Dns) -> SocketAddr {
+    fn to_socket_addr(&self, dns: &Dns) -> io::Result<SocketAddr> {
         self.as_str().to_socket_addr(dns)
     }
 }
@@ -227,16 +231,22 @@ mod tests {
         let mut dns = Dns::new(IpVersionAddrIter::default());
         let generated_addr = dns.lookup("foo");
 
-        let hostname_port = "foo:5000".to_socket_addr(&dns);
+        let hostname_port = "foo:5000";
         let ipv4_port = "127.0.0.1:5000";
         let ipv6_port = "[::1]:5000";
 
         assert_eq!(
-            hostname_port,
+            hostname_port.to_socket_addr(&dns).unwrap(),
             format!("{generated_addr}:5000").parse().unwrap()
         );
-        assert_eq!(ipv4_port.to_socket_addr(&dns), ipv4_port.parse().unwrap());
-        assert_eq!(ipv6_port.to_socket_addr(&dns), ipv6_port.parse().unwrap());
+        assert_eq!(
+            ipv4_port.to_socket_addr(&dns).unwrap(),
+            ipv4_port.parse().unwrap()
+        );
+        assert_eq!(
+            ipv6_port.to_socket_addr(&dns).unwrap(),
+            ipv6_port.parse().unwrap()
+        );
     }
 
     #[test]
@@ -251,7 +261,7 @@ mod tests {
         let addr = dns.lookup("192.168.3.3");
         assert_eq!(addr, Ipv4Addr::new(192, 168, 3, 3));
 
-        let addr = "192.168.3.3:0".to_socket_addr(&dns);
+        let addr = "192.168.3.3:0".to_socket_addr(&dns).unwrap();
         assert_eq!(addr.ip(), Ipv4Addr::new(192, 168, 3, 3));
     }
 }
diff --git a/src/net/mod.rs b/src/net/mod.rs
@@ -4,13 +4,28 @@
 //! a high fidelity implementation.
 
 use std::net::SocketAddr;
+use std::{io, iter};
+
+use crate::world::World;
+use crate::ToSocketAddrs;
 
 pub mod tcp;
 pub use tcp::{listener::TcpListener, stream::TcpStream};
 
 pub(crate) mod udp;
 pub use udp::UdpSocket;
 
+/// Performs a DNS resolution.
+///
+/// Must be called from within a turmoil simulation context.
+pub async fn lookup_host<T>(host: T) -> io::Result<impl Iterator<Item = SocketAddr>>
+where
+    T: ToSocketAddrs,
+{
+    let addr = World::current(|world| host.to_socket_addr(&world.dns))?;
+    Ok(iter::once(addr))
+}
+
 #[derive(Debug, Copy, Clone, Hash, Eq, PartialEq)]
 pub(crate) struct SocketPair {
     pub(crate) local: SocketAddr,
diff --git a/src/net/tcp/listener.rs b/src/net/tcp/listener.rs
@@ -36,7 +36,7 @@ impl TcpListener {
     /// Only `0.0.0.0`, `::`, or localhost are currently supported.
     pub async fn bind<A: ToSocketAddrs>(addr: A) -> Result<TcpListener> {
         World::current(|world| {
-            let mut addr = addr.to_socket_addr(&world.dns);
+            let mut addr = addr.to_socket_addr(&world.dns)?;
             let host = world.current_host_mut();
 
             if !addr.ip().is_unspecified() && !addr.ip().is_loopback() {
diff --git a/src/net/tcp/stream.rs b/src/net/tcp/stream.rs
@@ -63,7 +63,7 @@ impl TcpStream {
         let (ack, syn_ack) = oneshot::channel();
 
         let (pair, rx) = World::current(|world| {
-            let dst = addr.to_socket_addr(&world.dns);
+            let dst = addr.to_socket_addr(&world.dns)?;
 
             let host = world.current_host_mut();
             let mut local_addr = SocketAddr::new(host.addr, host.assign_ephemeral_port());
diff --git a/src/net/udp.rs b/src/net/udp.rs
@@ -156,12 +156,13 @@ impl UdpSocket {
             }),
         }
     }
-    pub async fn connect<A: ToSocketAddrs>(&self, addr: A) {
+    pub async fn connect<A: ToSocketAddrs>(&self, addr: A) -> Result<()> {
         World::current(|world| {
-            let addr = addr.to_socket_addr(&world.dns);
+            let addr = addr.to_socket_addr(&world.dns)?;
             let host = world.current_host_mut();
 
             host.udp.connect(self.local_addr, addr);
+            Ok(())
         })
     }
 
@@ -175,7 +176,7 @@ impl UdpSocket {
     /// Only `0.0.0.0`, `::`, or localhost are currently supported.
     pub async fn bind<A: ToSocketAddrs>(addr: A) -> Result<UdpSocket> {
         World::current(|world| {
-            let mut addr = addr.to_socket_addr(&world.dns);
+            let mut addr = addr.to_socket_addr(&world.dns)?;
             let host = world.current_host_mut();
 
             verify_ipv4_bind_interface(addr.ip(), host.addr)?;
@@ -209,7 +210,7 @@ impl UdpSocket {
     /// completes first, then it is guaranteed that the message was not sent.
     pub async fn send_to<A: ToSocketAddrs>(&self, buf: &[u8], target: A) -> Result<usize> {
         World::current(|world| {
-            let dst = target.to_socket_addr(&world.dns);
+            let dst = target.to_socket_addr(&world.dns)?;
             self.send(world, dst, Datagram(Bytes::copy_from_slice(buf)))?;
             Ok(buf.len())
         })
@@ -231,7 +232,7 @@ impl UdpSocket {
     /// [`ErrorKind::WouldBlock`]: std::io::ErrorKind::WouldBlock
     pub fn try_send_to<A: ToSocketAddrs>(&self, buf: &[u8], target: A) -> Result<usize> {
         World::current(|world| {
-            let dst = target.to_socket_addr(&world.dns);
+            let dst = target.to_socket_addr(&world.dns)?;
             self.send(world, dst, Datagram(Bytes::copy_from_slice(buf)))?;
             Ok(buf.len())
         })
diff --git a/tests/udp.rs b/tests/udp.rs
@@ -1046,7 +1046,7 @@ fn try_recv_connected() -> Result {
     sim.client("server1", async move {
         let sock = UdpSocket::bind((Ipv4Addr::UNSPECIFIED, 1234)).await?;
 
-        sock.connect(("server2", 5678)).await;
+        sock.connect(("server2", 5678)).await?;
 
         sock.readable().await?;
 
@@ -1079,7 +1079,7 @@ fn try_recv_connected_wrong_host() -> Result {
         let sock = UdpSocket::bind((Ipv4Addr::UNSPECIFIED, 1234)).await?;
 
         // Connect to server3, which doesn't send anything.
-        sock.connect(("server3", 6781)).await;
+        sock.connect(("server3", 6781)).await?;
 
         // Datagram from server2 is filtered so sock never becomes readable.
         tokio::time::timeout(Duration::from_secs(5), sock.readable())

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`use indexmap::IndexMap;`
`2`	`2`	`#[cfg(feature = "regex")]`
`3`	`3`	`use regex::Regex;`
	`4`	`+use std::io;`
`4`	`5`	`use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};`
`5`	`6`
`6`	`7`	`use crate::ip::IpVersionAddrIter;`
`@@ -30,7 +31,7 @@ pub trait ToIpAddrs: sealed::Sealed {`
`30`	`31`	/// A simulated version of `tokio::net::ToSocketAddrs`.
`31`	`32`	`pub trait ToSocketAddrs: sealed::Sealed {`
`32`	`33`	`#[doc(hidden)]`
`33`		`- fn to_socket_addr(&self, dns: &Dns) -> SocketAddr;`
	`34`	`+ fn to_socket_addr(&self, dns: &Dns) -> io::Result<SocketAddr>;`
`34`	`35`	`}`
`35`	`36`
`36`	`37`	`impl Dns {`
`@@ -116,73 +117,76 @@ impl ToIpAddrs for Regex {`
`116`	`117`
`117`	`118`	`// Hostname and port`
`118`	`119`	`impl ToSocketAddrs for (String, u16) {`
`119`		`- fn to_socket_addr(&self, dns: &Dns) -> SocketAddr {`
	`120`	`+ fn to_socket_addr(&self, dns: &Dns) -> io::Result<SocketAddr> {`
`120`	`121`	`(&self.0[..], self.1).to_socket_addr(dns)`
`121`	`122`	`}`
`122`	`123`	`}`
`123`	`124`
`124`	`125`	`impl ToSocketAddrs for (&str, u16) {`
`125`		`- fn to_socket_addr(&self, dns: &Dns) -> SocketAddr {`
	`126`	`+ fn to_socket_addr(&self, dns: &Dns) -> io::Result<SocketAddr> {`
`126`	`127`	`// When IP address is passed directly as a str.`
`127`	`128`	`if let Ok(ip) = self.0.parse::<IpAddr>() {`
`128`		`- return (ip, self.1).into();`
	`129`	`+ return Ok((ip, self.1).into());`
`129`	`130`	`}`
`130`	`131`
`131`	`132`	`match dns.names.get(self.0) {`
`132`		`- Some(ip) => (*ip, self.1).into(),`
`133`		`- None => panic!("no ip address found for a hostname: {}", self.0),`
	`133`	`+ Some(ip) => Ok((*ip, self.1).into()),`
	`134`	`+ None => Err(io::Error::other(format!(`
	`135`	`+ "no ip address found for a hostname: {}",`
	`136`	`+ self.0`
	`137`	`+ ))),`
`134`	`138`	`}`
`135`	`139`	`}`
`136`	`140`	`}`
`137`	`141`
`138`	`142`	`impl ToSocketAddrs for SocketAddr {`
`139`		`- fn to_socket_addr(&self, _: &Dns) -> SocketAddr {`
`140`		`- *self`
	`143`	`+ fn to_socket_addr(&self, _: &Dns) -> io::Result<SocketAddr> {`
	`144`	`+ Ok(*self)`
`141`	`145`	`}`
`142`	`146`	`}`
`143`	`147`
`144`	`148`	`impl ToSocketAddrs for SocketAddrV4 {`
`145`		`- fn to_socket_addr(&self, _: &Dns) -> SocketAddr {`
`146`		`- SocketAddr::V4(*self)`
	`149`	`+ fn to_socket_addr(&self, _: &Dns) -> io::Result<SocketAddr> {`
	`150`	`+ Ok(SocketAddr::V4(*self))`
`147`	`151`	`}`
`148`	`152`	`}`
`149`	`153`
`150`	`154`	`impl ToSocketAddrs for SocketAddrV6 {`
`151`		`- fn to_socket_addr(&self, _: &Dns) -> SocketAddr {`
`152`		`- SocketAddr::V6(*self)`
	`155`	`+ fn to_socket_addr(&self, _: &Dns) -> io::Result<SocketAddr> {`
	`156`	`+ Ok(SocketAddr::V6(*self))`
`153`	`157`	`}`
`154`	`158`	`}`
`155`	`159`
`156`	`160`	`impl ToSocketAddrs for (IpAddr, u16) {`
`157`		`- fn to_socket_addr(&self, _: &Dns) -> SocketAddr {`
`158`		`- (*self).into()`
	`161`	`+ fn to_socket_addr(&self, _: &Dns) -> io::Result<SocketAddr> {`
	`162`	`+ Ok((*self).into())`
`159`	`163`	`}`
`160`	`164`	`}`
`161`	`165`
`162`	`166`	`impl ToSocketAddrs for (Ipv4Addr, u16) {`
`163`		`- fn to_socket_addr(&self, _: &Dns) -> SocketAddr {`
`164`		`- (*self).into()`
	`167`	`+ fn to_socket_addr(&self, _: &Dns) -> io::Result<SocketAddr> {`
	`168`	`+ Ok((*self).into())`
`165`	`169`	`}`
`166`	`170`	`}`
`167`	`171`
`168`	`172`	`impl ToSocketAddrs for (Ipv6Addr, u16) {`
`169`		`- fn to_socket_addr(&self, _: &Dns) -> SocketAddr {`
`170`		`- (*self).into()`
	`173`	`+ fn to_socket_addr(&self, _: &Dns) -> io::Result<SocketAddr> {`
	`174`	`+ Ok((*self).into())`
`171`	`175`	`}`
`172`	`176`	`}`
`173`	`177`
`174`	`178`	`impl<T: ToSocketAddrs + ?Sized> ToSocketAddrs for &T {`
`175`		`- fn to_socket_addr(&self, dns: &Dns) -> SocketAddr {`
	`179`	`+ fn to_socket_addr(&self, dns: &Dns) -> io::Result<SocketAddr> {`
`176`	`180`	`(**self).to_socket_addr(dns)`
`177`	`181`	`}`
`178`	`182`	`}`
`179`	`183`
`180`	`184`	`impl ToSocketAddrs for str {`
`181`		`- fn to_socket_addr(&self, dns: &Dns) -> SocketAddr {`
	`185`	`+ fn to_socket_addr(&self, dns: &Dns) -> io::Result<SocketAddr> {`
`182`	`186`	`let socketaddr: Result<SocketAddr, _> = self.parse();`
`183`	`187`
`184`	`188`	`if let Ok(s) = socketaddr {`
`185`		`- return s;`
	`189`	`+ return Ok(s);`
`186`	`190`	`}`
`187`	`191`
`188`	`192`	`// Borrowed from std`
`@@ -191,7 +195,7 @@ impl ToSocketAddrs for str {`
`191`	`195`	`($e:expr, $msg:expr) => {`
`192`	`196`	`match $e {`
`193`	`197`	`Some(r) => r,`
`194`		`- None => panic!("Unable to parse dns: {}", $msg),`
	`198`	`+ None => return Err(io::Error::new(io::ErrorKind::InvalidInput, $msg)),`
`195`	`199`	`}`
`196`	`200`	`};`
`197`	`201`	`}`
`@@ -205,7 +209,7 @@ impl ToSocketAddrs for str {`
`205`	`209`	`}`
`206`	`210`
`207`	`211`	`impl ToSocketAddrs for String {`
`208`		`- fn to_socket_addr(&self, dns: &Dns) -> SocketAddr {`
	`212`	`+ fn to_socket_addr(&self, dns: &Dns) -> io::Result<SocketAddr> {`
`209`	`213`	`self.as_str().to_socket_addr(dns)`
`210`	`214`	`}`
`211`	`215`	`}`
`@@ -227,16 +231,22 @@ mod tests {`
`227`	`231`	`let mut dns = Dns::new(IpVersionAddrIter::default());`
`228`	`232`	`let generated_addr = dns.lookup("foo");`
`229`	`233`
`230`		`- let hostname_port = "foo:5000".to_socket_addr(&dns);`
	`234`	`+ let hostname_port = "foo:5000";`
`231`	`235`	`let ipv4_port = "127.0.0.1:5000";`
`232`	`236`	`let ipv6_port = "[::1]:5000";`
`233`	`237`
`234`	`238`	`assert_eq!(`
`235`		`- hostname_port,`
	`239`	`+ hostname_port.to_socket_addr(&dns).unwrap(),`
`236`	`240`	`format!("{generated_addr}:5000").parse().unwrap()`
`237`	`241`	`);`
`238`		`- assert_eq!(ipv4_port.to_socket_addr(&dns), ipv4_port.parse().unwrap());`
`239`		`- assert_eq!(ipv6_port.to_socket_addr(&dns), ipv6_port.parse().unwrap());`
	`242`	`+ assert_eq!(`
	`243`	`+ ipv4_port.to_socket_addr(&dns).unwrap(),`
	`244`	`+ ipv4_port.parse().unwrap()`
	`245`	`+ );`
	`246`	`+ assert_eq!(`
	`247`	`+ ipv6_port.to_socket_addr(&dns).unwrap(),`
	`248`	`+ ipv6_port.parse().unwrap()`
	`249`	`+ );`
`240`	`250`	`}`
`241`	`251`
`242`	`252`	`#[test]`
`@@ -251,7 +261,7 @@ mod tests {`
`251`	`261`	`let addr = dns.lookup("192.168.3.3");`
`252`	`262`	`assert_eq!(addr, Ipv4Addr::new(192, 168, 3, 3));`
`253`	`263`
`254`		`- let addr = "192.168.3.3:0".to_socket_addr(&dns);`
	`264`	`+ let addr = "192.168.3.3:0".to_socket_addr(&dns).unwrap();`
`255`	`265`	`assert_eq!(addr.ip(), Ipv4Addr::new(192, 168, 3, 3));`
`256`	`266`	`}`
`257`	`267`	`}`