src/api/router/args.rs

use std::{mem, ops::Deref};

use async_trait::async_trait;
use axum::{body::Body, extract::FromRequest};
use bytes::{BufMut, Bytes, BytesMut};
use conduwuit::{Error, Result, debug, debug_warn, err, trace, utils::string::EMPTY};
use ruma::{
	CanonicalJsonObject, CanonicalJsonValue, DeviceId, OwnedDeviceId, OwnedServerName,
	OwnedUserId, ServerName, UserId, api::IncomingRequest,
};
use service::Services;

use super::{auth, auth::Auth, request, request::Request};
use crate::{State, service::appservice::RegistrationInfo};

/// Extractor for Ruma request structs
pub(crate) struct Args<T> {
	/// Request struct body
	pub(crate) body: T,

	/// Federation server authentication: X-Matrix origin
	/// None when not a federation server.
	pub(crate) origin: Option<OwnedServerName>,

	/// Local user authentication: user_id.
	/// None when not an authenticated local user.
	pub(crate) sender_user: Option<OwnedUserId>,

	/// Local user authentication: device_id.
	/// None when not an authenticated local user or no device.
	pub(crate) sender_device: Option<OwnedDeviceId>,

	/// Appservice authentication; registration info.
	/// None when not an appservice.
	pub(crate) appservice_info: Option<RegistrationInfo>,

	/// Parsed JSON content.
	/// None when body is not a valid string
	pub(crate) json_body: Option<CanonicalJsonValue>,
}

impl<T> Args<T>
where
	T: IncomingRequest + Send + Sync + 'static,
{
	#[inline]
	pub(crate) fn sender(&self) -> (&UserId, &DeviceId) {
		(self.sender_user(), self.sender_device())
	}

	#[inline]
	pub(crate) fn sender_user(&self) -> &UserId {
		self.sender_user
			.as_deref()
			.expect("user must be authenticated for this handler")
	}

	#[inline]
	pub(crate) fn sender_device(&self) -> &DeviceId {
		self.sender_device
			.as_deref()
			.expect("user must be authenticated and device identified")
	}

	#[inline]
	pub(crate) fn origin(&self) -> &ServerName {
		self.origin
			.as_deref()
			.expect("server must be authenticated for this handler")
	}
}

impl<T> Deref for Args<T>
where
	T: IncomingRequest + Send + Sync + 'static,
{
	type Target = T;

	fn deref(&self) -> &Self::Target { &self.body }
}

#[async_trait]
impl<T> FromRequest<State, Body> for Args<T>
where
	T: IncomingRequest + Send + Sync + 'static,
{
	type Rejection = Error;

	async fn from_request(
		request: hyper::Request<Body>,
		services: &State,
	) -> Result<Self, Self::Rejection> {
		let mut request = request::from(services, request).await?;
		let mut json_body = serde_json::from_slice::<CanonicalJsonValue>(&request.body).ok();

		// while very unusual and really shouldn't be recommended, Synapse accepts POST
		// requests with a completely empty body. very old clients, libraries, and some
		// appservices still call APIs like /join like this. so let's just default to
		// empty object `{}` to copy synapse's behaviour
		if json_body.is_none()
			&& request.parts.method == http::Method::POST
			&& !request.parts.uri.path().contains("/media/")
		{
			trace!("json_body from_request: {:?}", json_body.clone());
			debug_warn!(
				"received a POST request with an empty body, defaulting/assuming to {{}} like \
				 Synapse does"
			);
			json_body = Some(CanonicalJsonValue::Object(CanonicalJsonObject::new()));
		}
		let auth = auth::auth(services, &mut request, json_body.as_ref(), &T::METADATA).await?;
		Ok(Self {
			body: make_body::<T>(services, &mut request, json_body.as_mut(), &auth)?,
			origin: auth.origin,
			sender_user: auth.sender_user,
			sender_device: auth.sender_device,
			appservice_info: auth.appservice_info,
			json_body,
		})
	}
}

fn make_body<T>(
	services: &Services,
	request: &mut Request,
	json_body: Option<&mut CanonicalJsonValue>,
	auth: &Auth,
) -> Result<T>
where
	T: IncomingRequest,
{
	let body = take_body(services, request, json_body, auth);
	let http_request = into_http_request(request, body);
	T::try_from_http_request(http_request, &request.path)
		.map_err(|e| err!(Request(BadJson(debug_warn!("{e}")))))
}

fn into_http_request(request: &Request, body: Bytes) -> hyper::Request<Bytes> {
	let mut http_request = hyper::Request::builder()
		.uri(request.parts.uri.clone())
		.method(request.parts.method.clone());

	*http_request.headers_mut().expect("mutable http headers") = request.parts.headers.clone();

	let http_request = http_request.body(body).expect("http request body");

	let headers = http_request.headers();
	let method = http_request.method();
	let uri = http_request.uri();
	debug!("{method:?} {uri:?} {headers:?}");

	http_request
}

#[allow(clippy::needless_pass_by_value)]
fn take_body(
	services: &Services,
	request: &mut Request,
	json_body: Option<&mut CanonicalJsonValue>,
	auth: &Auth,
) -> Bytes {
	let Some(CanonicalJsonValue::Object(json_body)) = json_body else {
		return mem::take(&mut request.body);
	};

	let user_id = auth.sender_user.clone().unwrap_or_else(|| {
		let server_name = services.globals.server_name();
		UserId::parse_with_server_name(EMPTY, server_name).expect("valid user_id")
	});

	let uiaa_request = json_body
		.get("auth")
		.and_then(CanonicalJsonValue::as_object)
		.and_then(|auth| auth.get("session"))
		.and_then(CanonicalJsonValue::as_str)
		.and_then(|session| {
			services
				.uiaa
				.get_uiaa_request(&user_id, auth.sender_device.as_deref(), session)
		});

	if let Some(CanonicalJsonValue::Object(initial_request)) = uiaa_request {
		for (key, value) in initial_request {
			json_body.entry(key).or_insert(value);
		}
	}

	let mut buf = BytesMut::new().writer();
	serde_json::to_writer(&mut buf, &json_body).expect("value serialization can't fail");
	buf.into_inner().freeze()
}
move impl FromRequest for Ruma up one level; some cleanup 2024-06-06 18:04:29 +00:00			`use std::{mem, ops::Deref};`
add rustfmt.toml, format entire codebase 2024-03-05 19:48:54 -05:00
use async_trait without axum re-export 2025-03-31 04:25:48 +00:00			`use async_trait::async_trait;`
			`use axum::{body::Body, extract::FromRequest};`
split make_body template 2024-11-08 08:21:19 +00:00			`use bytes::{BufMut, Bytes, BytesMut};`
run cargo fix for rust 2024 changes and rustfmt 2025-02-23 01:17:45 -05:00			`use conduwuit::{Error, Result, debug, debug_warn, err, trace, utils::string::EMPTY};`
split send from messages; refactor client/messages; add filters to client/context 2024-10-27 20:13:10 +00:00			`use ruma::{`
run cargo fix for rust 2024 changes and rustfmt 2025-02-23 01:17:45 -05:00			`CanonicalJsonObject, CanonicalJsonValue, DeviceId, OwnedDeviceId, OwnedServerName,`
			`OwnedUserId, ServerName, UserId, api::IncomingRequest,`
split send from messages; refactor client/messages; add filters to client/context 2024-10-27 20:13:10 +00:00			`};`
de-global services() from api 2024-07-16 08:05:25 +00:00			`use service::Services;`
add rustfmt.toml, format entire codebase 2024-03-05 19:48:54 -05:00
move routes into api router top level 2024-07-14 23:46:03 +00:00			`use super::{auth, auth::Auth, request, request::Request};`
run cargo fix for rust 2024 changes and rustfmt 2025-02-23 01:17:45 -05:00			`use crate::{State, service::appservice::RegistrationInfo};`
Initial commit 2020-02-15 22:42:21 +01:00
Port from Rocket to axum 2022-01-20 11:51:31 +01:00			`/// Extractor for Ruma request structs`
add some accessors to Ar for common patterns 2024-10-24 12:03:56 +00:00			`pub(crate) struct Args<T> {`
rename misleading `sender_servername` to `origin` 2024-05-26 14:29:56 -04:00			`/// Request struct body`
make everything pub(crate) instead of pub 2024-04-22 23:48:57 -04:00			`pub(crate) body: T,`
move impl FromRequest for Ruma up one level; some cleanup 2024-06-06 18:04:29 +00:00
			`/// Federation server authentication: X-Matrix origin`
			`/// None when not a federation server.`
			`pub(crate) origin: Option<OwnedServerName>,`

			`/// Local user authentication: user_id.`
			`/// None when not an authenticated local user.`
make everything pub(crate) instead of pub 2024-04-22 23:48:57 -04:00			`pub(crate) sender_user: Option<OwnedUserId>,`
move impl FromRequest for Ruma up one level; some cleanup 2024-06-06 18:04:29 +00:00
			`/// Local user authentication: device_id.`
			`/// None when not an authenticated local user or no device.`
make everything pub(crate) instead of pub 2024-04-22 23:48:57 -04:00			`pub(crate) sender_device: Option<OwnedDeviceId>,`
move impl FromRequest for Ruma up one level; some cleanup 2024-06-06 18:04:29 +00:00
			`/// Appservice authentication; registration info.`
			`/// None when not an appservice.`
make everything pub(crate) instead of pub 2024-04-22 23:48:57 -04:00			`pub(crate) appservice_info: Option<RegistrationInfo>,`
move impl FromRequest for Ruma up one level; some cleanup 2024-06-06 18:04:29 +00:00
			`/// Parsed JSON content.`
			`/// None when body is not a valid string`
			`pub(crate) json_body: Option<CanonicalJsonValue>,`
			`}`

add some accessors to Ar for common patterns 2024-10-24 12:03:56 +00:00			`impl<T> Args<T>`
			`where`
			`T: IncomingRequest + Send + Sync + 'static,`
			`{`
			`#[inline]`
apply new rustfmt.toml changes, fix some clippy lints 2024-12-15 00:05:47 -05:00			`pub(crate) fn sender(&self) -> (&UserId, &DeviceId) {`
			`(self.sender_user(), self.sender_device())`
			`}`
add some accessors to Ar for common patterns 2024-10-24 12:03:56 +00:00
			`#[inline]`
split send from messages; refactor client/messages; add filters to client/context 2024-10-27 20:13:10 +00:00			`pub(crate) fn sender_user(&self) -> &UserId {`
			`self.sender_user`
			`.as_deref()`
			`.expect("user must be authenticated for this handler")`
			`}`

			`#[inline]`
			`pub(crate) fn sender_device(&self) -> &DeviceId {`
			`self.sender_device`
			`.as_deref()`
			`.expect("user must be authenticated and device identified")`
			`}`

			`#[inline]`
			`pub(crate) fn origin(&self) -> &ServerName {`
			`self.origin`
			`.as_deref()`
			`.expect("server must be authenticated for this handler")`
			`}`
add some accessors to Ar for common patterns 2024-10-24 12:03:56 +00:00			`}`

move non-generic code out of generic; reduce codegen 2024-11-12 08:01:23 +00:00			`impl<T> Deref for Args<T>`
			`where`
			`T: IncomingRequest + Send + Sync + 'static,`
			`{`
			`type Target = T;`

			`fn deref(&self) -> &Self::Target { &self.body }`
			`}`

move impl FromRequest for Ruma up one level; some cleanup 2024-06-06 18:04:29 +00:00			`#[async_trait]`
de-global services 2024-07-27 07:17:07 +00:00			`impl<T> FromRequest<State, Body> for Args<T>`
move impl FromRequest for Ruma up one level; some cleanup 2024-06-06 18:04:29 +00:00			`where`
Database Refactor 2024-08-08 17:18:30 +00:00			`T: IncomingRequest + Send + Sync + 'static,`
move impl FromRequest for Ruma up one level; some cleanup 2024-06-06 18:04:29 +00:00			`{`
			`type Rejection = Error;`

apply new rustfmt.toml changes, fix some clippy lints 2024-12-15 00:05:47 -05:00			`async fn from_request(`
			`request: hyper::Request<Body>,`
			`services: &State,`
			`) -> Result<Self, Self::Rejection> {`
de-global services() from api 2024-07-16 08:05:25 +00:00			`let mut request = request::from(services, request).await?;`
move impl FromRequest for Ruma up one level; some cleanup 2024-06-06 18:04:29 +00:00			`let mut json_body = serde_json::from_slice::<CanonicalJsonValue>(&request.body).ok();`
allow empty POST request bodies (synapse behaviour) to improve compatibility 2024-12-11 14:27:08 -05:00
			`// while very unusual and really shouldn't be recommended, Synapse accepts POST`
			`// requests with a completely empty body. very old clients, libraries, and some`
			`// appservices still call APIs like /join like this. so let's just default to`
			// empty object `{}` to copy synapse's behaviour
			`if json_body.is_none()`
			`&& request.parts.method == http::Method::POST`
			`&& !request.parts.uri.path().contains("/media/")`
			`{`
			`trace!("json_body from_request: {:?}", json_body.clone());`
apply new rustfmt.toml changes, fix some clippy lints 2024-12-15 00:05:47 -05:00			`debug_warn!(`
			`"received a POST request with an empty body, defaulting/assuming to {{}} like \`
			`Synapse does"`
			`);`
allow empty POST request bodies (synapse behaviour) to improve compatibility 2024-12-11 14:27:08 -05:00			`json_body = Some(CanonicalJsonValue::Object(CanonicalJsonObject::new()));`
			`}`
Refactor server_keys service/interface and related callsites 2024-10-11 18:57:59 +00:00			`let auth = auth::auth(services, &mut request, json_body.as_ref(), &T::METADATA).await?;`
Fix use-self 2024-06-09 10:23:06 +00:00			`Ok(Self {`
move non-generic code out of generic; reduce codegen 2024-11-12 08:01:23 +00:00			`body: make_body::<T>(services, &mut request, json_body.as_mut(), &auth)?,`
move impl FromRequest for Ruma up one level; some cleanup 2024-06-06 18:04:29 +00:00			`origin: auth.origin,`
			`sender_user: auth.sender_user,`
			`sender_device: auth.sender_device,`
			`appservice_info: auth.appservice_info,`
			`json_body,`
			`})`
			`}`
Better database structure 2020-03-28 18:50:02 +01:00			`}`
Try to impl auth in ruma_wrapper 2020-03-28 23:08:59 +01:00
de-global services() from api 2024-07-16 08:05:25 +00:00			`fn make_body<T>(`
apply new rustfmt.toml changes, fix some clippy lints 2024-12-15 00:05:47 -05:00			`services: &Services,`
			`request: &mut Request,`
			`json_body: Option<&mut CanonicalJsonValue>,`
			`auth: &Auth,`
de-global services() from api 2024-07-16 08:05:25 +00:00			`) -> Result<T>`
move impl FromRequest for Ruma up one level; some cleanup 2024-06-06 18:04:29 +00:00			`where`
move non-generic code out of generic; reduce codegen 2024-11-12 08:01:23 +00:00			`T: IncomingRequest,`
move impl FromRequest for Ruma up one level; some cleanup 2024-06-06 18:04:29 +00:00			`{`
split make_body template 2024-11-08 08:21:19 +00:00			`let body = take_body(services, request, json_body, auth);`
			`let http_request = into_http_request(request, body);`
apply new rustfmt.toml changes, fix some clippy lints 2024-12-15 00:05:47 -05:00			`T::try_from_http_request(http_request, &request.path)`
			`.map_err(\|e\| err!(Request(BadJson(debug_warn!("{e}")))))`
split make_body template 2024-11-08 08:21:19 +00:00			`}`

			`fn into_http_request(request: &Request, body: Bytes) -> hyper::Request<Bytes> {`
			`let mut http_request = hyper::Request::builder()`
			`.uri(request.parts.uri.clone())`
			`.method(request.parts.method.clone());`

			`*http_request.headers_mut().expect("mutable http headers") = request.parts.headers.clone();`

			`let http_request = http_request.body(body).expect("http request body");`

			`let headers = http_request.headers();`
			`let method = http_request.method();`
			`let uri = http_request.uri();`
			`debug!("{method:?} {uri:?} {headers:?}");`

			`http_request`
			`}`

move non-generic code out of generic; reduce codegen 2024-11-12 08:01:23 +00:00			`#[allow(clippy::needless_pass_by_value)]`
split make_body template 2024-11-08 08:21:19 +00:00			`fn take_body(`
apply new rustfmt.toml changes, fix some clippy lints 2024-12-15 00:05:47 -05:00			`services: &Services,`
			`request: &mut Request,`
			`json_body: Option<&mut CanonicalJsonValue>,`
			`auth: &Auth,`
split make_body template 2024-11-08 08:21:19 +00:00			`) -> Bytes {`
move non-generic code out of generic; reduce codegen 2024-11-12 08:01:23 +00:00			`let Some(CanonicalJsonValue::Object(json_body)) = json_body else {`
			`return mem::take(&mut request.body);`
			`};`

			`let user_id = auth.sender_user.clone().unwrap_or_else(\|\| {`
			`let server_name = services.globals.server_name();`
			`UserId::parse_with_server_name(EMPTY, server_name).expect("valid user_id")`
			`});`

			`let uiaa_request = json_body`
			`.get("auth")`
			`.and_then(CanonicalJsonValue::as_object)`
			`.and_then(\|auth\| auth.get("session"))`
			`.and_then(CanonicalJsonValue::as_str)`
			`.and_then(\|session\| {`
			`services`
			`.uiaa`
			`.get_uiaa_request(&user_id, auth.sender_device.as_deref(), session)`
move impl FromRequest for Ruma up one level; some cleanup 2024-06-06 18:04:29 +00:00			`});`

move non-generic code out of generic; reduce codegen 2024-11-12 08:01:23 +00:00			`if let Some(CanonicalJsonValue::Object(initial_request)) = uiaa_request {`
			`for (key, value) in initial_request {`
			`json_body.entry(key).or_insert(value);`
move impl FromRequest for Ruma up one level; some cleanup 2024-06-06 18:04:29 +00:00			`}`
split make_body template 2024-11-08 08:21:19 +00:00			`}`
move non-generic code out of generic; reduce codegen 2024-11-12 08:01:23 +00:00
			`let mut buf = BytesMut::new().writer();`
			`serde_json::to_writer(&mut buf, &json_body).expect("value serialization can't fail");`
			`buf.into_inner().freeze()`
move impl FromRequest for Ruma up one level; some cleanup 2024-06-06 18:04:29 +00:00			`}`