diff --git a/src/peers/client.rs b/src/peers/client.rs index 28f7f37..abb2ef0 100644 --- a/src/peers/client.rs +++ b/src/peers/client.rs @@ -525,6 +525,34 @@ impl Stream for CappedStream { } } +/// Dial the addresses in order until one accepts. A peer name may resolve to +/// an address family the peer does not listen on, so a refusal on the first +/// address must not decide the check. +async fn connect_any( + addrs: &[SocketAddr], + deadline: tokio::time::Instant, +) -> Result { + let mut left = addrs.len(); + let mut last = PeerError::Unreachable; + for &addr in addrs { + // Each address gets its share of what remains, so a blackholed first + // address cannot eat the deadline the others need. + let now = tokio::time::Instant::now(); + let share = deadline.saturating_duration_since(now) / left as u32; + left -= 1; + let started = tokio::time::Instant::now(); + match tokio::time::timeout(share, tokio::net::TcpStream::connect(addr)).await { + Ok(Ok(stream)) => { + drop(stream); + return Ok(started.elapsed()); + } + Ok(Err(err)) => last = map_io(err), + Err(_) => last = PeerError::Timeout, + } + } + Err(last) +} + #[async_trait] impl PeerTransport for ReqwestTransport { async fn tcp_check(&self, peer: &PeerConfig, timeout: Duration) -> Result { @@ -532,25 +560,7 @@ impl PeerTransport for ReqwestTransport { within(deadline, async { let deny = self.deny_list(); let (_, addrs) = resolve_target(peer, &deny).await?; - let mut left = addrs.len(); - let mut last = PeerError::Unreachable; - for addr in addrs { - // Each address gets its share of what remains, so a blackholed - // first address cannot eat the deadline the others need. - let now = tokio::time::Instant::now(); - let share = deadline.saturating_duration_since(now) / left as u32; - left -= 1; - let started = tokio::time::Instant::now(); - match tokio::time::timeout(share, tokio::net::TcpStream::connect(addr)).await { - Ok(Ok(stream)) => { - drop(stream); - return Ok(started.elapsed()); - } - Ok(Err(err)) => last = map_io(err), - Err(_) => last = PeerError::Timeout, - } - } - Err(last) + connect_any(&addrs, deadline).await }) .await } @@ -1245,16 +1255,16 @@ mod tests { } /// A peer declared by name must be reached on the family it listens on: - /// the listener takes one family only, so whichever family the resolver - /// puts first, the other one has to be tried as well. + /// the listener takes one family only, so an address of the other family + /// has to be tried and refused before the reachable one. Driven with an + /// explicit address list, because what `localhost` resolves to depends on + /// /etc/hosts. #[tokio::test] async fn tcp_check_tries_every_resolved_address() { - let token = write_token("t", 0o600); - let transport = ReqwestTransport::new(&limits(4, 8, 1024)).unwrap(); - let mut tried = Vec::new(); + let mut served = Vec::new(); for bind in ["127.0.0.1", "[::1]"] { let Ok(listener) = TcpListener::bind(format!("{bind}:0")).await else { - continue; // this environment has no IPv6 loopback + continue; // this environment has no loopback of that family }; let port = listener.local_addr().unwrap().port(); tokio::spawn(async move { @@ -1267,19 +1277,20 @@ mod tests { .await; } }); - let mut p = peer(0, &token, None); - p.url = url(&format!("http://localhost:{port}")); - assert!( - transport - .tcp_check(&p, Duration::from_secs(2)) - .await - .is_ok(), - "{bind}" - ); - tried.push(bind); + let live: SocketAddr = format!("{bind}:{port}").parse().unwrap(); + // Nothing listens on that port on any other loopback, so a check + // that gave up on the first address would fail here. + let dead: Vec = ["127.0.0.1", "[::1]"] + .iter() + .filter(|other| **other != bind) + .filter_map(|other| format!("{other}:{port}").parse().ok()) + .collect(); + let addrs: Vec = dead.into_iter().chain([live]).collect(); + let deadline = tokio::time::Instant::now() + Duration::from_secs(2); + assert!(connect_any(&addrs, deadline).await.is_ok(), "{addrs:?}"); + served.push(bind); } - assert!(!tried.is_empty(), "no loopback family available"); - let _ = std::fs::remove_file(&token); + assert!(!served.is_empty(), "no loopback address to listen on"); } /// The request timeout bounds preparation, not a follow stream: chunks