hyper_util/client/legacy/connect/
dns.rs1use 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#[derive(Clone, Hash, Eq, PartialEq)]
38pub struct Name {
39 host: Box<str>,
40}
41
42#[derive(Clone)]
44pub struct GaiResolver {
45 _priv: (),
46}
47
48pub struct GaiAddrs {
50 inner: SocketAddrs,
51}
52
53pub 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 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 Ok(Name::new(host.into()))
87 }
88}
89
90#[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 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![])),
219 (None, Some(_)) => (self.filter(SocketAddr::is_ipv6), SocketAddrs::new(vec![])),
220 _ => {
221 let (preferred, fallback) = self.iter.partition::<Vec<_>, _>(SocketAddr::is_ipv6);
223
224 (SocketAddrs::new(preferred), SocketAddrs::new(fallback))
225 }
226 }
227 }
228
229 pub(super) fn is_empty(&self) -> bool {
230 self.iter.as_slice().is_empty()
231 }
232
233 pub(super) fn len(&self) -> usize {
234 self.iter.as_slice().len()
235 }
236}
237
238impl Iterator for SocketAddrs {
239 type Item = SocketAddr;
240 #[inline]
241 fn next(&mut self) -> Option<SocketAddr> {
242 self.iter.next()
243 }
244}
245
246mod sealed {
247 use std::future::Future;
248 use std::task::{self, Poll};
249
250 use super::{Name, SocketAddr};
251 use tower_service::Service;
252
253 pub trait Resolve {
255 type Addrs: Iterator<Item = SocketAddr>;
256 type Error: Into<Box<dyn std::error::Error + Send + Sync>>;
257 type Future: Future<Output = Result<Self::Addrs, Self::Error>>;
258
259 fn poll_ready(&mut self, cx: &mut task::Context<'_>) -> Poll<Result<(), Self::Error>>;
260 fn resolve(&mut self, name: Name) -> Self::Future;
261 }
262
263 impl<S> Resolve for S
264 where
265 S: Service<Name>,
266 S::Response: Iterator<Item = SocketAddr>,
267 S::Error: Into<Box<dyn std::error::Error + Send + Sync>>,
268 {
269 type Addrs = S::Response;
270 type Error = S::Error;
271 type Future = S::Future;
272
273 fn poll_ready(&mut self, cx: &mut task::Context<'_>) -> Poll<Result<(), Self::Error>> {
274 Service::poll_ready(self, cx)
275 }
276
277 fn resolve(&mut self, name: Name) -> Self::Future {
278 Service::call(self, name)
279 }
280 }
281}
282
283pub(super) async fn resolve<R>(resolver: &mut R, name: Name) -> Result<R::Addrs, R::Error>
284where
285 R: Resolve,
286{
287 crate::common::future::poll_fn(|cx| resolver.poll_ready(cx)).await?;
288 resolver.resolve(name).await
289}
290
291#[cfg(test)]
292mod tests {
293 use super::*;
294 use std::net::{Ipv4Addr, Ipv6Addr};
295
296 #[test]
297 fn test_ip_addrs_split_by_preference() {
298 let ip_v4 = Ipv4Addr::new(127, 0, 0, 1);
299 let ip_v6 = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1);
300 let v4_addr = (ip_v4, 80).into();
301 let v6_addr = (ip_v6, 80).into();
302
303 let (mut preferred, mut fallback) = SocketAddrs {
305 iter: vec![v4_addr, v6_addr].into_iter(),
306 }
307 .split_by_preference(None, None);
308 assert!(preferred.next().unwrap().is_ipv6());
309 assert!(fallback.next().unwrap().is_ipv4());
310
311 let (mut preferred, mut fallback) = SocketAddrs {
312 iter: vec![v6_addr, v4_addr].into_iter(),
313 }
314 .split_by_preference(None, None);
315 assert!(preferred.next().unwrap().is_ipv6());
316 assert!(fallback.next().unwrap().is_ipv4());
317
318 let (mut preferred, mut fallback) = SocketAddrs {
319 iter: vec![v4_addr, v6_addr].into_iter(),
320 }
321 .split_by_preference(Some(ip_v4), Some(ip_v6));
322 assert!(preferred.next().unwrap().is_ipv6());
323 assert!(fallback.next().unwrap().is_ipv4());
324
325 let (mut preferred, mut fallback) = SocketAddrs {
326 iter: vec![v6_addr, v4_addr].into_iter(),
327 }
328 .split_by_preference(Some(ip_v4), Some(ip_v6));
329 assert!(preferred.next().unwrap().is_ipv6());
330 assert!(fallback.next().unwrap().is_ipv4());
331
332 let (mut preferred, fallback) = SocketAddrs {
333 iter: vec![v4_addr, v6_addr].into_iter(),
334 }
335 .split_by_preference(Some(ip_v4), None);
336 assert!(preferred.next().unwrap().is_ipv4());
337 assert!(fallback.is_empty());
338
339 let (mut preferred, fallback) = SocketAddrs {
340 iter: vec![v4_addr, v6_addr].into_iter(),
341 }
342 .split_by_preference(None, Some(ip_v6));
343 assert!(preferred.next().unwrap().is_ipv6());
344 assert!(fallback.is_empty());
345 }
346
347 #[test]
348 fn test_name_from_str() {
349 const DOMAIN: &str = "test.example.com";
350 let name = Name::from_str(DOMAIN).expect("Should be a valid domain");
351 assert_eq!(name.as_str(), DOMAIN);
352 assert_eq!(name.to_string(), DOMAIN);
353 }
354}