tuwunel_service/appservice/
request.rs1use 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#[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(®istration) 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 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 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
119pub(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}