hyper_util/client/legacy/connect/
dns.rs

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

hyper_util/client/legacy/connect/
dns.rs
