1use std::{fmt::Debug, net::IpAddr};
2
3use futures::{FutureExt, TryFutureExt, future::ready};
4use hickory_resolver::{
5 net::{DnsError, NetError},
6 proto::rr::{Name, RData, rdata::SRV},
7};
8use ruma::ServerName;
9use tuwunel_core::{
10 Err, Result, debug, debug_info, debug_warn, err, error, format_array_string, implement,
11 trace, utils::string::to_small_string,
12};
13
14use super::{
15 DestString, FedDest,
16 cache::{CachedDest, CachedOverride, MAX_IPS},
17 fed::{HostString, PortString, add_port_to_hostname, get_ip_with_port, unbracket},
18};
19
20#[derive(Clone, Debug)]
21pub(crate) struct ActualDest {
22 pub(crate) dest: FedDest,
23 pub(crate) host: DestString,
24 pub(crate) srv: bool,
25}
26
27impl ActualDest {
28 #[inline]
29 pub(crate) fn to_string(&self) -> DestString { self.dest.https_string() }
30}
31
32impl From<CachedDest> for ActualDest {
33 fn from(CachedDest { dest, host, srv, .. }: CachedDest) -> Self { Self { dest, host, srv } }
34}
35
36#[implement(ActualDest)]
37fn direct(dest: FedDest, host: &str) -> Self {
38 Self {
39 dest,
40 host: Self::dest_host(host).uri_string(),
41 srv: false,
42 }
43}
44
45#[implement(ActualDest)]
46fn via_srv(dest: FedDest, host: &str) -> Self { Self { srv: true, ..Self::direct(dest, host) } }
47
48#[implement(ActualDest)]
49fn dest_host(host: &str) -> FedDest {
50 get_ip_with_port(host).unwrap_or_else(|| add_port_to_hostname(host))
51}
52
53#[implement(super::Service)]
54#[tracing::instrument(skip_all, level = "debug", name = "resolve")]
55pub(crate) async fn get_actual_dest(&self, server_name: &ServerName) -> Result<ActualDest> {
56 self.lookup_actual_dest_with_policy(server_name, false)
57 .map_ok(|(cached, _)| cached.into())
58 .await
59}
60
61#[implement(super::Service)]
62#[tracing::instrument(skip_all, level = "debug", name = "resolve")]
63pub(crate) async fn get_actual_dest_allow_self(
64 &self,
65 server_name: &ServerName,
66) -> Result<ActualDest> {
67 self.lookup_actual_dest_with_policy(server_name, true)
68 .map_ok(|(cached, _)| cached.into())
69 .await
70}
71
72#[implement(super::Service)]
73async fn lookup_actual_dest_with_policy(
74 &self,
75 server_name: &ServerName,
76 allow_self: bool,
77) -> Result<(CachedDest, bool)> {
78 self.validate_self_destination(server_name, allow_self)?;
79
80 if let Ok(result) = self.cache.get_destination(server_name).await {
81 return Ok((result, true));
82 }
83
84 let _dedup = self.resolving.lock(server_name).await;
85 if let Ok(result) = self.cache.get_destination(server_name).await {
86 return Ok((result, true));
87 }
88
89 self.validate_dest_address(server_name)?;
90
91 self.resolve_actual_dest_unchecked(server_name, true)
92 .inspect_ok(|result| self.cache.set_destination(server_name, result))
93 .map_ok(|result| (result, false))
94 .boxed() .await
96}
97
98#[implement(super::Service)]
103pub async fn resolve_actual_dest(&self, dest: &ServerName, cache: bool) -> Result<CachedDest> {
104 self.validate_dest(dest, false)?;
105 self.resolve_actual_dest_unchecked(dest, cache)
106 .await
107}
108
109#[implement(super::Service)]
110#[tracing::instrument(name = "actual", level = "debug", skip(self, cache))]
111async fn resolve_actual_dest_unchecked(
112 &self,
113 dest: &ServerName,
114 cache: bool,
115) -> Result<CachedDest> {
116 let ActualDest { dest: actual, host, srv } = self.actual_dest(dest, cache).await?;
117
118 debug!(?actual, ?host, srv, "Actual destination");
119 Ok(CachedDest {
120 dest: actual,
121 host,
122 expire: CachedDest::default_expire(),
123 srv,
124 })
125}
126
127#[implement(super::Service)]
128async fn actual_dest(&self, dest: &ServerName, cache: bool) -> Result<ActualDest> {
129 let name = dest.as_str();
130 let direct = |actual| ActualDest::direct(actual, name);
131
132 match get_ip_with_port(name) {
133 | Some(host_port) => Self::actual_dest_1(host_port).map(direct),
134 | None if name.contains(':') =>
135 self.actual_dest_2(dest, cache)
136 .map_ok(direct)
137 .await,
138 | None => self.actual_dest_named(dest, cache).await,
139 }
140}
141
142#[implement(super::Service)]
143fn actual_dest_1(host_port: FedDest) -> Result<FedDest> {
144 debug!("1: IP literal with provided or default port");
145 Ok(host_port)
146}
147
148#[implement(super::Service)]
149async fn actual_dest_2(&self, dest: &ServerName, cache: bool) -> Result<FedDest> {
150 debug!("2: Hostname with included port");
151 self.direct_route(dest.as_str(), cache).await
152}
153
154#[implement(super::Service)]
155async fn actual_dest_named(&self, dest: &ServerName, cache: bool) -> Result<ActualDest> {
156 let name = dest.as_str();
157
158 self.services.server.check_running()?;
159 match self.request_well_known(name).await? {
160 | Some(delegated) => self.actual_dest_3(cache, &delegated).await,
161 | None => match self.query_srv_record(name).await? {
162 | Some(overrider) =>
163 self.actual_dest_4(name, cache, overrider)
164 .map_ok(|actual| ActualDest::via_srv(actual, name))
165 .await,
166 | None =>
167 self.actual_dest_5(dest, cache)
168 .map_ok(|actual| ActualDest::direct(actual, name))
169 .await,
170 },
171 }
172}
173
174#[implement(super::Service)]
175pub(super) async fn actual_dest_3(&self, cache: bool, delegated: &str) -> Result<ActualDest> {
176 debug!("3: A .well-known file is available");
177 let direct = |actual| ActualDest::direct(actual, delegated);
178
179 match get_ip_with_port(delegated) {
180 | Some(host_and_port) => Self::actual_dest_3_1(host_and_port).map(direct),
181 | None if delegated.contains(':') =>
182 self.actual_dest_3_2(cache, delegated)
183 .map_ok(direct)
184 .await,
185 | None => match self.query_srv_record(delegated).await? {
186 | Some(overrider) =>
187 self.actual_dest_3_3(cache, delegated, overrider)
188 .map_ok(|actual| ActualDest::via_srv(actual, delegated))
189 .await,
190 | None =>
191 self.actual_dest_3_4(cache, delegated)
192 .map_ok(direct)
193 .await,
194 },
195 }
196}
197
198#[cfg(test)]
199#[implement(super::Service)]
200pub(crate) async fn test_delegated_dest(&self, delegated: &str) -> Result<ActualDest> {
201 self.actual_dest_3(false, delegated).await
202}
203
204#[implement(super::Service)]
205fn actual_dest_3_1(host_and_port: FedDest) -> Result<FedDest> {
206 debug!("3.1: IP literal in .well-known file");
207 Ok(host_and_port)
208}
209
210#[implement(super::Service)]
211async fn actual_dest_3_2(&self, cache: bool, delegated: &str) -> Result<FedDest> {
212 debug!("3.2: Hostname with port in .well-known file");
213 self.direct_route(delegated, cache).await
214}
215
216#[implement(super::Service)]
217async fn actual_dest_3_3(
218 &self,
219 cache: bool,
220 delegated: &str,
221 overrider: FedDest,
222) -> Result<FedDest> {
223 debug!("3.3: SRV lookup successful");
224 self.srv_route(delegated, cache, overrider).await
225}
226
227#[implement(super::Service)]
228async fn actual_dest_3_4(&self, cache: bool, delegated: &str) -> Result<FedDest> {
229 debug!("3.4: No SRV records, just use the hostname from .well-known");
230 self.direct_route(delegated, cache).await
231}
232
233#[implement(super::Service)]
234async fn actual_dest_4(&self, host: &str, cache: bool, overrider: FedDest) -> Result<FedDest> {
235 debug!("4: No .well-known; SRV record found");
236 self.srv_route(host, cache, overrider).await
237}
238
239#[implement(super::Service)]
240async fn actual_dest_5(&self, dest: &ServerName, cache: bool) -> Result<FedDest> {
241 debug!("5: No SRV record found");
242 self.direct_route(dest.as_str(), cache).await
243}
244
245#[implement(super::Service)]
246async fn direct_route(&self, name: &str, cache: bool) -> Result<FedDest> {
247 let dest = add_port_to_hostname(name);
248
249 self.query_direct(&dest.hostname(), cache)
250 .map_ok(|()| dest)
251 .await
252}
253
254#[implement(super::Service)]
255async fn srv_route(&self, name: &str, cache: bool, overrider: FedDest) -> Result<FedDest> {
256 let force_port = overrider.port();
257 self.maybe_query_and_cache_override(
258 name,
259 &overrider.hostname(),
260 force_port.unwrap_or(8448),
261 cache,
262 )
263 .await?;
264
265 if let Some(port) = force_port {
266 let port: PortString = format_array_string!(":{port}");
267
268 return Ok(FedDest::Named(name.into(), port));
269 }
270
271 Ok(add_port_to_hostname(name))
272}
273
274#[implement(super::Service)]
275#[tracing::instrument(level = "debug", skip(self))]
276async fn query_direct(&self, hostname: &str, cache: bool) -> Result {
277 if !cache {
278 return Ok(());
279 }
280
281 self.services.server.check_running()?;
282
283 self.resolver
285 .resolver
286 .lookup_ip(hostname)
287 .map_ok(drop)
288 .or_else(|error| ready(Self::handle_resolve_error(&error, hostname)))
289 .await
290}
291
292#[implement(super::Service)]
293#[inline]
294async fn maybe_query_and_cache_override(
295 &self,
296 untername: &str,
297 hostname: &str,
298 port: u16,
299 cache: bool,
300) -> Result {
301 if !cache {
302 return Ok(());
303 }
304
305 if self.cache.has_override(untername, hostname).await {
306 return Ok(());
307 }
308
309 self.query_and_cache_override(untername, hostname, port)
310 .await
311}
312
313#[implement(super::Service)]
314#[tracing::instrument(name = "ip", level = "debug", skip(self))]
315async fn query_and_cache_override(
316 &self,
317 untername: &'_ str,
318 hostname: &'_ str,
319 port: u16,
320) -> Result {
321 self.services.server.check_running()?;
322
323 debug!("querying IP for {untername:?} ({hostname:?}:{port})");
324 match self
325 .resolver
326 .resolver
327 .lookup_ip(hostname.to_owned())
328 .await
329 {
330 | Err(e) => Self::handle_resolve_error(&e, hostname),
331 | Ok(override_ip) => {
332 debug_info!(?untername, ?hostname, "Overriding hostname");
333 self.cache
334 .set_override(untername, &CachedOverride {
335 ips: override_ip.iter().take(MAX_IPS).collect(),
336 port,
337 expire: CachedOverride::default_expire(),
338 overriding: Some(hostname.into()),
339 });
340
341 Ok(())
342 },
343 }
344}
345
346#[implement(super::Service)]
347#[tracing::instrument(name = "srv", level = "debug", skip(self))]
348async fn query_srv_record(&self, hostname: &'_ str) -> Result<Option<FedDest>> {
349 let hostnames =
350 [format!("_matrix-fed._tcp.{hostname}."), format!("_matrix._tcp.{hostname}.")];
351
352 for hostname in hostnames {
353 self.services.server.check_running()?;
354
355 debug!("querying SRV for {hostname:?}");
356 let hostname = hostname.trim_end_matches('.');
357 match self.resolver.resolver.srv_lookup(hostname).await {
358 | Err(e) => Self::handle_resolve_error(&e, hostname)?,
359 | Ok(result) => {
360 let srv = result
361 .answers()
362 .iter()
363 .find_map(|r| match &r.data {
364 | RData::SRV(srv) => Some(srv),
365 | _ => None,
366 });
367
368 return Ok(srv.map(Self::srv_dest));
369 },
370 }
371 }
372
373 Ok(None)
374}
375
376#[implement(super::Service)]
377fn srv_dest(srv: &SRV) -> FedDest {
378 let host: HostString = to_small_string(&srv.target);
379 let port: PortString = format_array_string!(":{}", srv.port);
380
381 FedDest::Named(host.trim_end_matches('.').into(), port)
382}
383
384#[implement(super::Service)]
385fn handle_resolve_error(e: &NetError, host: &'_ str) -> Result {
386 match e {
391 | NetError::Dns(DnsError::NoRecordsFound(_)) => {
392 debug!(%host, "No DNS records found: {e}");
394 Ok(())
395 },
396 | NetError::Dns(_) => {
397 debug_warn!(%host, "DNS response error: {e}");
398 Ok(())
399 },
400 | NetError::Proto(_) if Name::from_utf8(host).is_err() =>
402 Err!(debug_error!(%host, error = %e, "Invalid DNS name")),
403 | NetError::Timeout => Err!(warn!(%host, "DNS {e}")),
404 | NetError::NoConnections => {
405 error!(
406 "Your DNS server is overloaded and has ran out of connections. It is strongly \
407 recommended you remediate this issue to ensure proper federation connectivity."
408 );
409
410 Err!(error!(%host, "DNS error: {e}"))
411 },
412 | _ => Err!(error!(%host, "DNS error: {e}")),
413 }
414}
415
416#[implement(super::Service)]
417fn validate_dest(&self, dest: &ServerName, allow_self: bool) -> Result {
418 self.validate_self_destination(dest, allow_self)?;
419 self.validate_dest_address(dest)
420}
421
422#[implement(super::Service)]
423fn validate_self_destination(&self, dest: &ServerName, allow_self: bool) -> Result {
424 if !allow_self
425 && dest == self.services.server.name
426 && !self.services.server.config.federation.loopback
427 {
428 return Err!("Won't send federation request to ourselves");
429 }
430
431 Ok(())
432}
433
434#[implement(super::Service)]
435fn validate_dest_address(&self, dest: &ServerName) -> Result {
436 if dest.is_ip_literal() || unbracket(dest.host()).parse::<IpAddr>().is_ok() {
437 self.validate_dest_ip_literal(dest)?;
438 }
439
440 Ok(())
441}
442
443#[implement(super::Service)]
444fn validate_dest_ip_literal(&self, dest: &ServerName) -> Result {
445 trace!("Destination is an IP literal, checking against IP range denylist.",);
446 let ip = unbracket(dest.host()).parse().map_err(|e| {
447 err!(BadServerResponse(debug_error!("Failed to parse IP literal from string: {e}")))
448 })?;
449
450 if !self.services.client.valid_cidr_range_ip(ip) {
451 return Err!(BadServerResponse("Not allowed to send requests to this IP"));
452 }
453
454 Ok(())
455}