hyper_util/client/legacy/connect/
dns.rs

1//! DNS Resolution used by the `HttpConnector`.
2//!
3//! This module contains:
4//!
5//! - A [`GaiResolver`](GaiResolver) that is the default resolver for the
6//!   `HttpConnector`.
7//! - The `Name` type used as an argument to custom resolvers.
8//!
9//! # Resolvers are `Service`s
10//!
11//! A resolver is just a
12//! `Service<Name, Response = impl Iterator<Item = SocketAddr>>`.
13//!
14//! A simple resolver that ignores the name and always returns a specific
15//! address:
16//!
17//! ```rust,ignore
18//! use std::{convert::Infallible, iter, net::SocketAddr};
19//!
20//! let resolver = tower::service_fn(|_name| async {
21//!     Ok::<_, Infallible>(iter::once(SocketAddr::from(([127, 0, 0, 1], 8080))))
22//! });
23//! ```
24use std::error::Error;
25use std::future::Future;
26use std::net::{Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};
27use std::pin::Pin;
28use std::str::FromStr;
29use std::task::{self, Poll};
30use std::{fmt, io, vec};
31
32use tokio::task::JoinHandle;
33use tower_service::Service;
34use tracing::{debug, debug_span};
35
36pub(super) use self::sealed::Resolve;
37
38/// A domain name to resolve into IP addresses.
39#[derive(Clone, Hash, Eq, PartialEq)]
40pub struct Name {
41    host: Box<str>,
42}
43
44/// A resolver using blocking `getaddrinfo` calls in a threadpool.
45#[derive(Clone)]
46pub struct GaiResolver {
47    _priv: (),
48}
49
50/// An iterator of IP addresses returned from `getaddrinfo`.
51pub struct GaiAddrs {
52    inner: SocketAddrs,
53}
54
55/// A future to resolve a name returned by `GaiResolver`.
56pub struct GaiFuture {
57    inner: JoinHandle<Result<SocketAddrs, io::Error>>,
58}
59
60impl Name {
61    pub(super) fn new(host: Box<str>) -> Name {
62        Name { host }
63    }
64
65    /// View the hostname as a string slice.
66    pub fn as_str(&self) -> &str {
67        &self.host
68    }
69}
70
71impl fmt::Debug for Name {
72    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
73        fmt::Debug::fmt(&self.host, f)
74    }
75}
76
77impl fmt::Display for Name {
78    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
79        fmt::Display::fmt(&self.host, f)
80    }
81}
82
83impl FromStr for Name {
84    type Err = InvalidNameError;
85
86    fn from_str(host: &str) -> Result<Self, Self::Err> {
87        // Possibly add validation later
88        Ok(Name::new(host.into()))
89    }
90}
91
92/// Error indicating a given string was not a valid domain name.
93#[derive(Debug)]
94pub struct InvalidNameError(());
95
96impl fmt::Display for InvalidNameError {
97    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
98        f.write_str("Not a valid domain name")
99    }
100}
101
102impl Error for InvalidNameError {}
103
104impl GaiResolver {
105    /// Construct a new `GaiResolver`.
106    pub fn new() -> Self {
107        GaiResolver { _priv: () }
108    }
109}
110
111impl Service<Name> for GaiResolver {
112    type Response = GaiAddrs;
113    type Error = io::Error;
114    type Future = GaiFuture;
115
116    fn poll_ready(&mut self, _cx: &mut task::Context<'_>) -> Poll<Result<(), io::Error>> {
117        Poll::Ready(Ok(()))
118    }
119
120    fn call(&mut self, name: Name) -> Self::Future {
121        let span = debug_span!("resolve", host = %name.host).or_current();
122        let blocking = tokio::task::spawn_blocking(move || {
123            let _enter = span.enter();
124            debug!(host = name.host, "resolving");
125            (&*name.host, 0)
126                .to_socket_addrs()
127                .map(|i| SocketAddrs { iter: i })
128        });
129
130        GaiFuture { inner: blocking }
131    }
132}
133
134impl fmt::Debug for GaiResolver {
135    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
136        f.pad("GaiResolver")
137    }
138}
139
140impl Future for GaiFuture {
141    type Output = Result<GaiAddrs, io::Error>;
142
143    fn poll(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Self::Output> {
144        Pin::new(&mut self.inner).poll(cx).map(|res| match res {
145            Ok(Ok(addrs)) => Ok(GaiAddrs { inner: addrs }),
146            Ok(Err(err)) => Err(err),
147            Err(join_err) => {
148                if join_err.is_cancelled() {
149                    Err(io::Error::new(io::ErrorKind::Interrupted, join_err))
150                } else {
151                    panic!("gai background task failed: {:?}", join_err)
152                }
153            }
154        })
155    }
156}
157
158impl fmt::Debug for GaiFuture {
159    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
160        f.pad("GaiFuture")
161    }
162}
163
164impl Drop for GaiFuture {
165    fn drop(&mut self) {
166        self.inner.abort();
167    }
168}
169
170impl Iterator for GaiAddrs {
171    type Item = SocketAddr;
172
173    fn next(&mut self) -> Option<Self::Item> {
174        self.inner.next()
175    }
176}
177
178impl fmt::Debug for GaiAddrs {
179    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
180        f.pad("GaiAddrs")
181    }
182}
183
184pub(super) struct SocketAddrs {
185    iter: vec::IntoIter<SocketAddr>,
186}
187
188impl SocketAddrs {
189    pub(super) fn new(addrs: Vec<SocketAddr>) -> Self {
190        SocketAddrs {
191            iter: addrs.into_iter(),
192        }
193    }
194
195    pub(super) fn try_parse(host: &str, port: u16) -> Option<SocketAddrs> {
196        if let Ok(addr) = host.parse::<Ipv4Addr>() {
197            let addr = SocketAddrV4::new(addr, port);
198            return Some(SocketAddrs {
199                iter: vec![SocketAddr::V4(addr)].into_iter(),
200            });
201        }
202        if let Ok(addr) = host.parse::<Ipv6Addr>() {
203            let addr = SocketAddrV6::new(addr, port, 0, 0);
204            return Some(SocketAddrs {
205                iter: vec![SocketAddr::V6(addr)].into_iter(),
206            });
207        }
208        None
209    }
210
211    #[inline]
212    fn filter(self, predicate: impl FnMut(&SocketAddr) -> bool) -> SocketAddrs {
213        SocketAddrs::new(self.iter.filter(predicate).collect())
214    }
215
216    pub(super) fn split_by_preference(
217        self,
218        local_addr_ipv4: Option<Ipv4Addr>,
219        local_addr_ipv6: Option<Ipv6Addr>,
220    ) -> (SocketAddrs, SocketAddrs) {
221        match (local_addr_ipv4, local_addr_ipv6) {
222            (Some(_), None) => (self.filter(SocketAddr::is_ipv4), SocketAddrs::new(vec![])),
223            (None, Some(_)) => (self.filter(SocketAddr::is_ipv6), SocketAddrs::new(vec![])),
224            _ => {
225                let preferring_v6 = self
226                    .iter
227                    .as_slice()
228                    .first()
229                    .map(SocketAddr::is_ipv6)
230                    .unwrap_or(false);
231
232                let (preferred, fallback) = self
233                    .iter
234                    .partition::<Vec<_>, _>(|addr| addr.is_ipv6() == preferring_v6);
235
236                (SocketAddrs::new(preferred), SocketAddrs::new(fallback))
237            }
238        }
239    }
240
241    pub(super) fn is_empty(&self) -> bool {
242        self.iter.as_slice().is_empty()
243    }
244
245    pub(super) fn len(&self) -> usize {
246        self.iter.as_slice().len()
247    }
248}
249
250impl Iterator for SocketAddrs {
251    type Item = SocketAddr;
252    #[inline]
253    fn next(&mut self) -> Option<SocketAddr> {
254        self.iter.next()
255    }
256}
257
258mod sealed {
259    use std::future::Future;
260    use std::task::{self, Poll};
261
262    use super::{Name, SocketAddr};
263    use tower_service::Service;
264
265    // "Trait alias" for `Service<Name, Response = Addrs>`
266    pub trait Resolve {
267        type Addrs: Iterator<Item = SocketAddr>;
268        type Error: Into<Box<dyn std::error::Error + Send + Sync>>;
269        type Future: Future<Output = Result<Self::Addrs, Self::Error>>;
270
271        fn poll_ready(&mut self, cx: &mut task::Context<'_>) -> Poll<Result<(), Self::Error>>;
272        fn resolve(&mut self, name: Name) -> Self::Future;
273    }
274
275    impl<S> Resolve for S
276    where
277        S: Service<Name>,
278        S::Response: Iterator<Item = SocketAddr>,
279        S::Error: Into<Box<dyn std::error::Error + Send + Sync>>,
280    {
281        type Addrs = S::Response;
282        type Error = S::Error;
283        type Future = S::Future;
284
285        fn poll_ready(&mut self, cx: &mut task::Context<'_>) -> Poll<Result<(), Self::Error>> {
286            Service::poll_ready(self, cx)
287        }
288
289        fn resolve(&mut self, name: Name) -> Self::Future {
290            Service::call(self, name)
291        }
292    }
293}
294
295pub(super) async fn resolve<R>(resolver: &mut R, name: Name) -> Result<R::Addrs, R::Error>
296where
297    R: Resolve,
298{
299    futures_util::future::poll_fn(|cx| resolver.poll_ready(cx)).await?;
300    resolver.resolve(name).await
301}
302
303#[cfg(test)]
304mod tests {
305    use super::*;
306    use std::net::{Ipv4Addr, Ipv6Addr};
307
308    #[test]
309    fn test_ip_addrs_split_by_preference() {
310        let ip_v4 = Ipv4Addr::new(127, 0, 0, 1);
311        let ip_v6 = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1);
312        let v4_addr = (ip_v4, 80).into();
313        let v6_addr = (ip_v6, 80).into();
314
315        let (mut preferred, mut fallback) = SocketAddrs {
316            iter: vec![v4_addr, v6_addr].into_iter(),
317        }
318        .split_by_preference(None, None);
319        assert!(preferred.next().unwrap().is_ipv4());
320        assert!(fallback.next().unwrap().is_ipv6());
321
322        let (mut preferred, mut fallback) = SocketAddrs {
323            iter: vec![v6_addr, v4_addr].into_iter(),
324        }
325        .split_by_preference(None, None);
326        assert!(preferred.next().unwrap().is_ipv6());
327        assert!(fallback.next().unwrap().is_ipv4());
328
329        let (mut preferred, mut fallback) = SocketAddrs {
330            iter: vec![v4_addr, v6_addr].into_iter(),
331        }
332        .split_by_preference(Some(ip_v4), Some(ip_v6));
333        assert!(preferred.next().unwrap().is_ipv4());
334        assert!(fallback.next().unwrap().is_ipv6());
335
336        let (mut preferred, mut fallback) = SocketAddrs {
337            iter: vec![v6_addr, v4_addr].into_iter(),
338        }
339        .split_by_preference(Some(ip_v4), Some(ip_v6));
340        assert!(preferred.next().unwrap().is_ipv6());
341        assert!(fallback.next().unwrap().is_ipv4());
342
343        let (mut preferred, fallback) = SocketAddrs {
344            iter: vec![v4_addr, v6_addr].into_iter(),
345        }
346        .split_by_preference(Some(ip_v4), None);
347        assert!(preferred.next().unwrap().is_ipv4());
348        assert!(fallback.is_empty());
349
350        let (mut preferred, fallback) = SocketAddrs {
351            iter: vec![v4_addr, v6_addr].into_iter(),
352        }
353        .split_by_preference(None, Some(ip_v6));
354        assert!(preferred.next().unwrap().is_ipv6());
355        assert!(fallback.is_empty());
356    }
357
358    #[test]
359    fn test_name_from_str() {
360        const DOMAIN: &str = "test.example.com";
361        let name = Name::from_str(DOMAIN).expect("Should be a valid domain");
362        assert_eq!(name.as_str(), DOMAIN);
363        assert_eq!(name.to_string(), DOMAIN);
364    }
365}
hyper_util/client/legacy/connect/dns.rs

hyper_util/client/legacy/connect/
dns.rs
