Skip to main content

tuwunel_service/appservice/
request.rs

1use std::{fmt::Debug, mem};
2
3use bytes::{Bytes, BytesMut};
4use reqwest::Request;
5use ruma::api::{
6	IncomingResponse, OutgoingRequest, OutgoingRequestExt,
7	appservice::Registration,
8	auth_scheme::{AuthScheme, SendAccessToken},
9	path_builder::PathBuilder,
10};
11use tuwunel_core::{
12	Err, Result, debug_error, err, implement, trace, utils::string_from_bytes, warn,
13};
14
15use super::destination;
16use crate::client::read_response_capped;
17
18/// Sends a request to an appservice
19///
20/// Only returns Ok(None) if there is no url specified in the appservice
21/// registration file
22#[implement(super::Service)]
23pub async fn send_request<T>(
24	&self,
25	registration: Registration,
26	request: T,
27) -> Result<Option<T::IncomingResponse>>
28where
29	T: OutgoingRequest + Debug + Send,
30	for<'a> T::Authentication: AuthScheme<Input<'a> = SendAccessToken<'a>>,
31	for<'a> T::PathBuilder: PathBuilder<Input<'a> = ()>,
32{
33	let Some(dest) = destination(&registration) else {
34		return Ok(None);
35	};
36
37	trace!("Appservice URL \"{dest}\", Appservice ID: {}", registration.id);
38
39	let (base, client) = self.transport(dest)?;
40	let hs_token = registration.hs_token.as_str();
41	let mut http_request = request
42		.try_into_http_request::<BytesMut>(base, SendAccessToken::IfRequired(hs_token), ())
43		.map_err(|e| {
44			err!(BadServerResponse(
45				warn!(appservice = %registration.id, "Failed to find destination {dest}: {e:?}")
46			))
47		})?
48		.map(BytesMut::freeze);
49
50	add_access_token_query(&mut http_request, hs_token);
51
52	let reqwest_request = Request::try_from(http_request)?;
53
54	let mut response = client
55		.execute(reqwest_request)
56		.await
57		.map_err(|e| {
58			// The URL carries the hs_token in its access_token query.
59			let e = e.without_url();
60
61			warn!(
62				"Could not send request to appservice \"{}\" at {dest}: {e:?}",
63				registration.id
64			);
65			e
66		})?;
67
68	// reqwest::Response -> http::Response conversion
69	let status = response.status();
70	let mut http_response_builder = http::Response::builder()
71		.status(status)
72		.version(response.version());
73
74	mem::swap(
75		response.headers_mut(),
76		http_response_builder
77			.headers_mut()
78			.expect("http::response::Builder is usable"),
79	);
80
81	let limit = self
82		.services
83		.config
84		.network
85		.http
86		.max_response_size;
87
88	let body = read_response_capped(response, limit)
89		.await
90		.map_err(|e| {
91			err!(BadServerResponse(warn!(
92				"Failed reading response from appservice \"{}\" at {dest}: {e}",
93				registration.id
94			)))
95		})?;
96
97	if !status.is_success() {
98		debug_error!("Appservice response bytes: {:?}", string_from_bytes(&body));
99		return Err!(BadServerResponse(warn!(
100			"Appservice \"{}\" returned unsuccessful HTTP response {status} at {dest}",
101			registration.id
102		)));
103	}
104
105	let response = T::IncomingResponse::try_from_http_response(
106		http_response_builder
107			.body(body)
108			.expect("reqwest body is valid http body"),
109	);
110
111	response.map(Some).map_err(|e| {
112		err!(BadServerResponse(warn!(
113			"Appservice \"{}\" returned invalid/malformed response bytes {dest}: {e}",
114			registration.id
115		)))
116	})
117}
118
119/// Appends the `hs_token` as an `access_token` query parameter, the legacy
120/// authentication scheme some appservices still require.
121pub(super) fn add_access_token_query(request: &mut http::Request<Bytes>, hs_token: &str) {
122	let mut parts = request.uri().clone().into_parts();
123	let old_path_and_query = parts
124		.path_and_query
125		.expect("valid request uri path and query")
126		.as_str()
127		.to_owned();
128
129	let symbol = if old_path_and_query.contains('?') { "&" } else { "?" };
130
131	parts.path_and_query = Some(
132		format!("{old_path_and_query}{symbol}access_token={hs_token}")
133			.parse()
134			.expect("valid path and query"),
135	);
136
137	*request.uri_mut() = parts
138		.try_into()
139		.expect("our manipulation is always valid");
140}