refactor fed membership endpoints, add missing checks, some cleanup, reduce line width

Signed-off-by: strawberry <strawberry@puppygock.gay>

src/api/server/invite.rs

@@ -145,24 +145,24 @@ pub(crate) async fn create_invite_route(
 				true,
 			)
 			.await?;
-	}
 
-	for appservice in services.appservice.read().await.values() {
-		if appservice.is_user_match(&invited_user) {
-			services
-				.sending
-				.send_appservice_request(
-					appservice.registration.clone(),
-					ruma::api::appservice::event::push_events::v1::Request {
-						events: vec![pdu.to_room_event()],
-						txn_id: general_purpose::URL_SAFE_NO_PAD
-							.encode(sha256::hash(pdu.event_id.as_bytes()))
-							.into(),
-						ephemeral: Vec::new(),
-						to_device: Vec::new(),
-					},
-				)
-				.await?;
+		for appservice in services.appservice.read().await.values() {
+			if appservice.is_user_match(&invited_user) {
+				services
+					.sending
+					.send_appservice_request(
+						appservice.registration.clone(),
+						ruma::api::appservice::event::push_events::v1::Request {
+							events: vec![pdu.to_room_event()],
+							txn_id: general_purpose::URL_SAFE_NO_PAD
+								.encode(sha256::hash(pdu.event_id.as_bytes()))
+								.into(),
+							ephemeral: Vec::new(),
+							to_device: Vec::new(),
+						},
+					)
+					.await?;
+			}
 		}
 	}
 

src/api/server/make_join.rs

@@ -1,8 +1,5 @@
 use axum::extract::State;
-use conduit::{
-	utils::{IterStream, ReadyExt},
-	warn,
-};
+use conduit::{debug_info, utils::IterStream, warn, Err};
 use futures::StreamExt;
 use ruma::{
 	api::{client::error::ErrorKind, federation::membership::prepare_join_event},
@@ -13,7 +10,7 @@ use ruma::{
 		},
 		StateEventType,
 	},
-	CanonicalJsonObject, RoomId, RoomVersionId, UserId,
+	CanonicalJsonObject, OwnedUserId, RoomId, RoomVersionId, UserId,
 };
 use serde_json::value::to_raw_value;
 
@@ -29,14 +26,11 @@ pub(crate) async fn create_join_event_template_route(
 	State(services): State<crate::State>, body: Ruma<prepare_join_event::v1::Request>,
 ) -> Result<prepare_join_event::v1::Response> {
 	if !services.rooms.metadata.exists(&body.room_id).await {
-		return Err(Error::BadRequest(ErrorKind::NotFound, "Room is unknown to this server."));
+		return Err!(Request(NotFound("Room is unknown to this server.")));
 	}
 
 	if body.user_id.server_name() != body.origin() {
-		return Err(Error::BadRequest(
-			ErrorKind::InvalidParam,
-			"Not allowed to join on behalf of another server/user",
-		));
+		return Err!(Request(BadJson("Not allowed to join on behalf of another server/user.")));
 	}
 
 	// ACL check origin server
@@ -59,10 +53,7 @@ pub(crate) async fn create_join_event_template_route(
 			&body.user_id,
 			&body.room_id,
 		);
-		return Err(Error::BadRequest(
-			ErrorKind::forbidden(),
-			"Server is banned on this homeserver.",
-		));
+		return Err!(Request(Forbidden("Server is banned on this homeserver.")));
 	}
 
 	if let Some(server) = body.room_id.server_name() {
@@ -72,10 +63,9 @@ pub(crate) async fn create_join_event_template_route(
 			.forbidden_remote_server_names
 			.contains(&server.to_owned())
 		{
-			return Err(Error::BadRequest(
-				ErrorKind::forbidden(),
-				"Server is banned on this homeserver.",
-			));
+			return Err!(Request(Forbidden(warn!(
+				"Room ID server name {server} is banned on this homeserver."
+			))));
 		}
 	}
 
@@ -91,39 +81,35 @@ pub(crate) async fn create_join_event_template_route(
 
 	let state_lock = services.rooms.state.mutex.lock(&body.room_id).await;
 
-	let join_authorized_via_users_server = if (services
-		.rooms
-		.state_cache
-		.is_left(&body.user_id, &body.room_id)
-		.await)
-		&& user_can_perform_restricted_join(&services, &body.user_id, &body.room_id, &room_version_id).await?
-	{
-		let auth_user = services
-			.rooms
-			.state_cache
-			.room_members(&body.room_id)
-			.ready_filter(|user| user.server_name() == services.globals.server_name())
-			.filter(|user| {
-				services
-					.rooms
-					.state_accessor
-					.user_can_invite(&body.room_id, user, &body.user_id, &state_lock)
-			})
-			.boxed()
-			.next()
-			.await
-			.map(ToOwned::to_owned);
-
-		if auth_user.is_some() {
-			auth_user
+	let join_authorized_via_users_server: Option<OwnedUserId> = {
+		use RoomVersionId::*;
+		if matches!(room_version_id, V1 | V2 | V3 | V4 | V5 | V6 | V7) {
+			// room version does not support restricted join rules
+			None
+		} else if user_can_perform_restricted_join(&services, &body.user_id, &body.room_id, &room_version_id).await? {
+			let Some(auth_user) = services
+				.rooms
+				.state_cache
+				.local_users_in_room(&body.room_id)
+				.filter(|user| {
+					services
+						.rooms
+						.state_accessor
+						.user_can_invite(&body.room_id, user, &body.user_id, &state_lock)
+				})
+				.boxed()
+				.next()
+				.await
+				.map(ToOwned::to_owned)
+			else {
+				return Err!(Request(UnableToGrantJoin(
+					"No user on this server is able to assist in joining."
+				)));
+			};
+			Some(auth_user)
 		} else {
-			return Err(Error::BadRequest(
-				ErrorKind::UnableToGrantJoin,
-				"No user on this server is able to assist in joining.",
-			));
+			None
 		}
-	} else {
-		None
 	};
 
 	let (_pdu, mut pdu_json) = services
@@ -155,37 +141,39 @@ pub(crate) async fn create_join_event_template_route(
 }
 
 /// Checks whether the given user can join the given room via a restricted join.
-/// This doesn't check the current user's membership. This should be done
-/// externally, either by using the state cache or attempting to authorize the
-/// event.
 pub(crate) async fn user_can_perform_restricted_join(
 	services: &Services, user_id: &UserId, room_id: &RoomId, room_version_id: &RoomVersionId,
 ) -> Result<bool> {
 	use RoomVersionId::*;
 
-	let join_rules_event = services
-		.rooms
-		.state_accessor
-		.room_state_get(room_id, &StateEventType::RoomJoinRules, "")
-		.await;
-
-	let Ok(Ok(join_rules_event_content)) = join_rules_event.as_ref().map(|join_rules_event| {
-		serde_json::from_str::<RoomJoinRulesEventContent>(join_rules_event.content.get()).map_err(|e| {
-			warn!("Invalid join rules event in database: {e}");
-			Error::bad_database("Invalid join rules event in database")
-		})
-	}) else {
-		return Ok(false);
-	};
-
+	// restricted rooms are not supported on <=v7
 	if matches!(room_version_id, V1 | V2 | V3 | V4 | V5 | V6 | V7) {
 		return Ok(false);
 	}
 
+	if services.rooms.state_cache.is_joined(user_id, room_id).await {
+		// joining user is already joined, there is nothing we need to do
+		return Ok(false);
+	}
+
+	let Ok(join_rules_event_content) = services
+		.rooms
+		.state_accessor
+		.room_state_get_content::<RoomJoinRulesEventContent>(room_id, &StateEventType::RoomJoinRules, "")
+		.await
+	else {
+		return Ok(false);
+	};
+
 	let (JoinRule::Restricted(r) | JoinRule::KnockRestricted(r)) = join_rules_event_content.join_rule else {
 		return Ok(false);
 	};
 
+	if r.allow.is_empty() {
+		debug_info!("{room_id} is restricted but the allow key is empty");
+		return Ok(false);
+	}
+
 	if r.allow
 		.iter()
 		.filter_map(|rule| {
@@ -201,22 +189,20 @@ pub(crate) async fn user_can_perform_restricted_join(
 	{
 		Ok(true)
 	} else {
-		Err(Error::BadRequest(
-			ErrorKind::UnableToAuthorizeJoin,
-			"User is not known to be in any required room.",
-		))
+		Err!(Request(UnableToAuthorizeJoin(
+			"Joining user is not known to be in any required room."
+		)))
 	}
 }
 
-pub(crate) fn maybe_strip_event_id(pdu_json: &mut CanonicalJsonObject, room_version_id: &RoomVersionId) -> Result<()> {
+pub(crate) fn maybe_strip_event_id(pdu_json: &mut CanonicalJsonObject, room_version_id: &RoomVersionId) -> Result {
 	use RoomVersionId::*;
 
 	match room_version_id {
-		V1 | V2 => {},
+		V1 | V2 => Ok(()),
 		_ => {
 			pdu_json.remove("event_id");
+			Ok(())
 		},
-	};
-
-	Ok(())
+	}
 }

src/api/server/make_knock.rs

@@ -18,14 +18,11 @@ pub(crate) async fn create_knock_event_template_route(
 	State(services): State<crate::State>, body: Ruma<create_knock_event_template::v1::Request>,
 ) -> Result<create_knock_event_template::v1::Response> {
 	if !services.rooms.metadata.exists(&body.room_id).await {
-		return Err(Error::BadRequest(ErrorKind::NotFound, "Room is unknown to this server."));
+		return Err!(Request(NotFound("Room is unknown to this server.")));
 	}
 
 	if body.user_id.server_name() != body.origin() {
-		return Err(Error::BadRequest(
-			ErrorKind::InvalidParam,
-			"Not allowed to knock on behalf of another server/user",
-		));
+		return Err!(Request(BadJson("Not allowed to knock on behalf of another server/user.")));
 	}
 
 	// ACL check origin server

src/api/server/make_leave.rs

@@ -1,7 +1,7 @@
 use axum::extract::State;
-use conduit::{Error, Result};
+use conduit::{Err, Result};
 use ruma::{
-	api::{client::error::ErrorKind, federation::membership::prepare_leave_event},
+	api::federation::membership::prepare_leave_event,
 	events::room::member::{MembershipState, RoomMemberEventContent},
 };
 use serde_json::value::to_raw_value;
@@ -16,14 +16,11 @@ pub(crate) async fn create_leave_event_template_route(
 	State(services): State<crate::State>, body: Ruma<prepare_leave_event::v1::Request>,
 ) -> Result<prepare_leave_event::v1::Response> {
 	if !services.rooms.metadata.exists(&body.room_id).await {
-		return Err(Error::BadRequest(ErrorKind::NotFound, "Room is unknown to this server."));
+		return Err!(Request(NotFound("Room is unknown to this server.")));
 	}
 
 	if body.user_id.server_name() != body.origin() {
-		return Err(Error::BadRequest(
-			ErrorKind::InvalidParam,
-			"Not allowed to leave on behalf of another server/user",
-		));
+		return Err!(Request(BadJson("Not allowed to leave on behalf of another server/user.")));
 	}
 
 	// ACL check origin

src/api/server/send_join.rs

@@ -7,16 +7,16 @@ use conduit::{
 	err,
 	pdu::gen_event_id_canonical_json,
 	utils::stream::{IterStream, TryBroadbandExt},
-	warn, Error, Result,
+	warn, Err, Result,
 };
 use futures::{FutureExt, StreamExt, TryStreamExt};
 use ruma::{
-	api::{client::error::ErrorKind, federation::membership::create_join_event},
+	api::federation::membership::create_join_event,
 	events::{
 		room::member::{MembershipState, RoomMemberEventContent},
 		StateEventType,
 	},
-	CanonicalJsonValue, OwnedEventId, OwnedServerName, OwnedUserId, RoomId, ServerName,
+	CanonicalJsonValue, OwnedEventId, OwnedRoomId, OwnedServerName, OwnedUserId, RoomId, ServerName,
 };
 use serde_json::value::{to_raw_value, RawValue as RawJsonValue};
 use service::Services;
@@ -28,7 +28,7 @@ async fn create_join_event(
 	services: &Services, origin: &ServerName, room_id: &RoomId, pdu: &RawJsonValue,
 ) -> Result<create_join_event::v1::RoomState> {
 	if !services.rooms.metadata.exists(room_id).await {
-		return Err(Error::BadRequest(ErrorKind::NotFound, "Room is unknown to this server."));
+		return Err!(Request(NotFound("Room is unknown to this server.")));
 	}
 
 	// ACL check origin server
@@ -45,7 +45,7 @@ async fn create_join_event(
 		.state
 		.get_room_shortstatehash(room_id)
 		.await
-		.map_err(|_| err!(Request(NotFound("Event state not found."))))?;
+		.map_err(|e| err!(Request(NotFound(error!("Room has no state: {e}")))))?;
 
 	// We do not add the event_id field to the pdu here because of signature and
 	// hashes checks
@@ -53,53 +53,62 @@ async fn create_join_event(
 
 	let Ok((event_id, mut value)) = gen_event_id_canonical_json(pdu, &room_version_id) else {
 		// Event could not be converted to canonical json
-		return Err(Error::BadRequest(
-			ErrorKind::InvalidParam,
-			"Could not convert event to canonical json.",
-		));
+		return Err!(Request(BadJson("Could not convert event to canonical json.")));
 	};
 
+	let event_room_id: OwnedRoomId = serde_json::from_value(
+		serde_json::to_value(
+			value
+				.get("room_id")
+				.ok_or_else(|| err!(Request(BadJson("Event missing room_id property."))))?,
+		)
+		.expect("CanonicalJson is valid json value"),
+	)
+	.map_err(|e| err!(Request(BadJson(warn!("room_id field is not a valid room ID: {e}")))))?;
+
+	if event_room_id != room_id {
+		return Err!(Request(BadJson("Event room_id does not match request path room ID.")));
+	}
+
 	let event_type: StateEventType = serde_json::from_value(
 		value
 			.get("type")
-			.ok_or_else(|| Error::BadRequest(ErrorKind::InvalidParam, "Event missing type property."))?
+			.ok_or_else(|| err!(Request(BadJson("Event missing type property."))))?
 			.clone()
 			.into(),
 	)
-	.map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Event has invalid event type."))?;
+	.map_err(|e| err!(Request(BadJson(warn!("Event has invalid state event type: {e}")))))?;
 
 	if event_type != StateEventType::RoomMember {
-		return Err(Error::BadRequest(
-			ErrorKind::InvalidParam,
-			"Not allowed to send non-membership state event to join endpoint.",
-		));
+		return Err!(Request(BadJson(
+			"Not allowed to send non-membership state event to join endpoint."
+		)));
 	}
 
 	let content: RoomMemberEventContent = serde_json::from_value(
 		value
 			.get("content")
-			.ok_or_else(|| Error::BadRequest(ErrorKind::InvalidParam, "Event missing content property"))?
+			.ok_or_else(|| err!(Request(BadJson("Event missing content property"))))?
 			.clone()
 			.into(),
 	)
-	.map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Event content is empty or invalid"))?;
+	.map_err(|e| err!(Request(BadJson(warn!("Event content is empty or invalid: {e}")))))?;
 
 	if content.membership != MembershipState::Join {
-		return Err(Error::BadRequest(
-			ErrorKind::InvalidParam,
-			"Not allowed to send a non-join membership event to join endpoint.",
-		));
+		return Err!(Request(BadJson(
+			"Not allowed to send a non-join membership event to join endpoint."
+		)));
 	}
 
-	// ACL check sender server name
+	// ACL check sender user server name
 	let sender: OwnedUserId = serde_json::from_value(
 		value
 			.get("sender")
-			.ok_or_else(|| Error::BadRequest(ErrorKind::InvalidParam, "Event missing sender property."))?
+			.ok_or_else(|| err!(Request(BadJson("Event missing sender property."))))?
 			.clone()
 			.into(),
 	)
-	.map_err(|_| Error::BadRequest(ErrorKind::BadJson, "sender is not a valid user ID."))?;
+	.map_err(|e| err!(Request(BadJson(warn!("sender property is not a valid user ID: {e}")))))?;
 
 	services
 		.rooms
@@ -109,50 +118,71 @@ async fn create_join_event(
 
 	// check if origin server is trying to send for another server
 	if sender.server_name() != origin {
-		return Err(Error::BadRequest(
-			ErrorKind::InvalidParam,
-			"Not allowed to join on behalf of another server.",
-		));
+		return Err!(Request(Forbidden("Not allowed to join on behalf of another server.")));
 	}
 
 	let state_key: OwnedUserId = serde_json::from_value(
 		value
 			.get("state_key")
-			.ok_or_else(|| Error::BadRequest(ErrorKind::InvalidParam, "Event missing state_key property."))?
+			.ok_or_else(|| err!(Request(BadJson("Event missing state_key property."))))?
 			.clone()
 			.into(),
 	)
-	.map_err(|_| Error::BadRequest(ErrorKind::BadJson, "state_key is invalid or not a user ID."))?;
+	.map_err(|e| err!(Request(BadJson(warn!("State key is not a valid user ID: {e}")))))?;
 
 	if state_key != sender {
-		return Err(Error::BadRequest(
-			ErrorKind::InvalidParam,
-			"State key does not match sender user",
-		));
+		return Err!(Request(BadJson("State key does not match sender user.")));
 	};
 
-	if content
-		.join_authorized_via_users_server
-		.is_some_and(|user| services.globals.user_is_local(&user))
-		&& super::user_can_perform_restricted_join(services, &sender, room_id, &room_version_id)
+	if let Some(authorising_user) = content.join_authorized_via_users_server {
+		use ruma::RoomVersionId::*;
+
+		if !matches!(room_version_id, V1 | V2 | V3 | V4 | V5 | V6 | V7) {
+			return Err!(Request(InvalidParam(
+				"Room version {room_version_id} does not support restricted rooms but \
+				 join_authorised_via_users_server ({authorising_user}) was found in the event."
+			)));
+		}
+
+		if !services.globals.user_is_local(&authorising_user) {
+			return Err!(Request(InvalidParam(
+				"Cannot authorise membership event through {authorising_user} as they do not belong to this homeserver"
+			)));
+		}
+
+		if !services
+			.rooms
+			.state_cache
+			.is_joined(&authorising_user, room_id)
 			.await
-			.unwrap_or_default()
-	{
-		services
-			.server_keys
-			.hash_and_sign_event(&mut value, &room_version_id)
-			.map_err(|e| err!(Request(InvalidParam("Failed to sign event: {e}"))))?;
+		{
+			return Err!(Request(InvalidParam(
+				"Authorising user {authorising_user} is not in the room you are trying to join, they cannot authorise \
+				 your join."
+			)));
+		}
+
+		if !super::user_can_perform_restricted_join(services, &state_key, room_id, &room_version_id).await? {
+			return Err!(Request(UnableToAuthorizeJoin(
+				"Joining user did not pass restricted room's rules."
+			)));
+		}
 	}
 
+	services
+		.server_keys
+		.hash_and_sign_event(&mut value, &room_version_id)
+		.map_err(|e| err!(Request(InvalidParam(warn!("Failed to sign send_join event: {e}")))))?;
+
 	let origin: OwnedServerName = serde_json::from_value(
 		serde_json::to_value(
 			value
 				.get("origin")
-				.ok_or_else(|| Error::BadRequest(ErrorKind::InvalidParam, "Event missing origin property."))?,
+				.ok_or_else(|| err!(Request(BadJson("Event missing origin property."))))?,
 		)
 		.expect("CanonicalJson is valid json value"),
 	)
-	.map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "origin is not a server name."))?;
+	.map_err(|e| err!(Request(BadJson(warn!("origin field is not a valid server name: {e}")))))?;
 
 	let mutex_lock = services
 		.rooms
@@ -214,7 +244,6 @@ async fn create_join_event(
 	Ok(create_join_event::v1::RoomState {
 		auth_chain,
 		state,
-		// Event field is required if the room version supports restricted join rules.
 		event: to_raw_value(&CanonicalJsonValue::Object(value)).ok(),
 	})
 }
@@ -232,14 +261,12 @@ pub(crate) async fn create_join_event_v1_route(
 		.contains(body.origin())
 	{
 		warn!(
-			"Server {} tried joining room ID {} who has a server name that is globally forbidden. Rejecting.",
+			"Server {} tried joining room ID {} through us who has a server name that is globally forbidden. \
+			 Rejecting.",
 			body.origin(),
 			&body.room_id,
 		);
-		return Err(Error::BadRequest(
-			ErrorKind::forbidden(),
-			"Server is banned on this homeserver.",
-		));
+		return Err!(Request(Forbidden("Server is banned on this homeserver.")));
 	}
 
 	if let Some(server) = body.room_id.server_name() {
@@ -250,14 +277,14 @@ pub(crate) async fn create_join_event_v1_route(
 			.contains(&server.to_owned())
 		{
 			warn!(
-				"Server {} tried joining room ID {} which has a server name that is globally forbidden. Rejecting.",
+				"Server {} tried joining room ID {} through us which has a server name that is globally forbidden. \
+				 Rejecting.",
 				body.origin(),
 				&body.room_id,
 			);
-			return Err(Error::BadRequest(
-				ErrorKind::forbidden(),
-				"Server is banned on this homeserver.",
-			));
+			return Err!(Request(Forbidden(warn!(
+				"Room ID server name {server} is banned on this homeserver."
+			))));
 		}
 	}
 
@@ -282,10 +309,7 @@ pub(crate) async fn create_join_event_v2_route(
 		.forbidden_remote_server_names
 		.contains(body.origin())
 	{
-		return Err(Error::BadRequest(
-			ErrorKind::forbidden(),
-			"Server is banned on this homeserver.",
-		));
+		return Err!(Request(Forbidden("Server is banned on this homeserver.")));
 	}
 
 	if let Some(server) = body.room_id.server_name() {
@@ -295,10 +319,15 @@ pub(crate) async fn create_join_event_v2_route(
 			.forbidden_remote_server_names
 			.contains(&server.to_owned())
 		{
-			return Err(Error::BadRequest(
-				ErrorKind::forbidden(),
-				"Server is banned on this homeserver.",
-			));
+			warn!(
+				"Server {} tried joining room ID {} through us which has a server name that is globally forbidden. \
+				 Rejecting.",
+				body.origin(),
+				&body.room_id,
+			);
+			return Err!(Request(Forbidden(warn!(
+				"Room ID server name {server} is banned on this homeserver."
+			))));
 		}
 	}
 

src/api/server/send_knock.rs

@@ -121,10 +121,7 @@ pub(crate) async fn create_knock_event_v1_route(
 
 	// check if origin server is trying to send for another server
 	if sender.server_name() != body.origin() {
-		return Err(Error::BadRequest(
-			ErrorKind::InvalidParam,
-			"Not allowed to knock on behalf of another server.",
-		));
+		return Err!(Request(BadJson("Not allowed to knock on behalf of another server/user.")));
 	}
 
 	let state_key: OwnedUserId = serde_json::from_value(

src/api/server/send_leave.rs

@@ -1,14 +1,14 @@
 #![allow(deprecated)]
 
 use axum::extract::State;
-use conduit::{err, utils::ReadyExt, Error, Result};
+use conduit::{err, Err, Result};
 use ruma::{
-	api::{client::error::ErrorKind, federation::membership::create_leave_event},
+	api::federation::membership::create_leave_event,
 	events::{
 		room::member::{MembershipState, RoomMemberEventContent},
 		StateEventType,
 	},
-	OwnedUserId, RoomId, ServerName,
+	OwnedRoomId, OwnedUserId, RoomId, ServerName,
 };
 use serde_json::value::RawValue as RawJsonValue;
 
@@ -39,11 +39,9 @@ pub(crate) async fn create_leave_event_v2_route(
 	Ok(create_leave_event::v2::Response::new())
 }
 
-async fn create_leave_event(
-	services: &Services, origin: &ServerName, room_id: &RoomId, pdu: &RawJsonValue,
-) -> Result<()> {
+async fn create_leave_event(services: &Services, origin: &ServerName, room_id: &RoomId, pdu: &RawJsonValue) -> Result {
 	if !services.rooms.metadata.exists(room_id).await {
-		return Err(Error::BadRequest(ErrorKind::NotFound, "Room is unknown to this server."));
+		return Err!(Request(NotFound("Room is unknown to this server.")));
 	}
 
 	// ACL check origin
@@ -58,53 +56,62 @@ async fn create_leave_event(
 	let room_version_id = services.rooms.state.get_room_version(room_id).await?;
 	let Ok((event_id, value)) = gen_event_id_canonical_json(pdu, &room_version_id) else {
 		// Event could not be converted to canonical json
-		return Err(Error::BadRequest(
-			ErrorKind::InvalidParam,
-			"Could not convert event to canonical json.",
-		));
+		return Err!(Request(BadJson("Could not convert event to canonical json.")));
 	};
 
+	let event_room_id: OwnedRoomId = serde_json::from_value(
+		serde_json::to_value(
+			value
+				.get("room_id")
+				.ok_or_else(|| err!(Request(BadJson("Event missing room_id property."))))?,
+		)
+		.expect("CanonicalJson is valid json value"),
+	)
+	.map_err(|e| err!(Request(BadJson(warn!("room_id field is not a valid room ID: {e}")))))?;
+
+	if event_room_id != room_id {
+		return Err!(Request(BadJson("Event room_id does not match request path room ID.")));
+	}
+
 	let content: RoomMemberEventContent = serde_json::from_value(
 		value
 			.get("content")
-			.ok_or_else(|| Error::BadRequest(ErrorKind::InvalidParam, "Event missing content property"))?
+			.ok_or_else(|| err!(Request(BadJson("Event missing content property."))))?
 			.clone()
 			.into(),
 	)
-	.map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Event content is empty or invalid"))?;
+	.map_err(|e| err!(Request(BadJson(warn!("Event content is empty or invalid: {e}")))))?;
 
 	if content.membership != MembershipState::Leave {
-		return Err(Error::BadRequest(
-			ErrorKind::InvalidParam,
-			"Not allowed to send a non-leave membership event to leave endpoint.",
-		));
+		return Err!(Request(BadJson(
+			"Not allowed to send a non-leave membership event to leave endpoint."
+		)));
 	}
 
 	let event_type: StateEventType = serde_json::from_value(
 		value
 			.get("type")
-			.ok_or_else(|| Error::BadRequest(ErrorKind::InvalidParam, "Event missing type property."))?
+			.ok_or_else(|| err!(Request(BadJson("Event missing type property."))))?
 			.clone()
 			.into(),
 	)
-	.map_err(|_| Error::BadRequest(ErrorKind::BadJson, "Event does not have a valid state event type."))?;
+	.map_err(|e| err!(Request(BadJson(warn!("Event has invalid state event type: {e}")))))?;
 
 	if event_type != StateEventType::RoomMember {
-		return Err(Error::BadRequest(
-			ErrorKind::InvalidParam,
-			"Not allowed to send non-membership state event to leave endpoint.",
-		));
+		return Err!(Request(BadJson(
+			"Not allowed to send non-membership state event to leave endpoint."
+		)));
 	}
 
 	// ACL check sender server name
 	let sender: OwnedUserId = serde_json::from_value(
 		value
 			.get("sender")
-			.ok_or_else(|| Error::BadRequest(ErrorKind::InvalidParam, "Event missing sender property."))?
+			.ok_or_else(|| err!(Request(BadJson("Event missing sender property."))))?
 			.clone()
 			.into(),
 	)
-	.map_err(|_| Error::BadRequest(ErrorKind::BadJson, "User ID in sender is invalid."))?;
+	.map_err(|e| err!(Request(BadJson(warn!("sender property is not a valid user ID: {e}")))))?;
 
 	services
 		.rooms
@@ -113,26 +120,20 @@ async fn create_leave_event(
 		.await?;
 
 	if sender.server_name() != origin {
-		return Err(Error::BadRequest(
-			ErrorKind::InvalidParam,
-			"Not allowed to leave on behalf of another server.",
-		));
+		return Err!(Request(BadJson("Not allowed to leave on behalf of another server/user.")));
 	}
 
 	let state_key: OwnedUserId = serde_json::from_value(
 		value
 			.get("state_key")
-			.ok_or_else(|| Error::BadRequest(ErrorKind::InvalidParam, "Event missing state_key property."))?
+			.ok_or_else(|| err!(Request(BadJson("Event missing state_key property."))))?
 			.clone()
 			.into(),
 	)
-	.map_err(|_| Error::BadRequest(ErrorKind::BadJson, "state_key is invalid or not a user ID"))?;
+	.map_err(|e| err!(Request(BadJson(warn!("State key is not a valid user ID: {e}")))))?;
 
 	if state_key != sender {
-		return Err(Error::BadRequest(
-			ErrorKind::InvalidParam,
-			"state_key does not match sender user.",
-		));
+		return Err!(Request(BadJson("State key does not match sender user.")));
 	}
 
 	let mutex_lock = services
@@ -151,11 +152,5 @@ async fn create_leave_event(
 
 	drop(mutex_lock);
 
-	let servers = services
-		.rooms
-		.state_cache
-		.room_servers(room_id)
-		.ready_filter(|server| !services.globals.server_is_ours(server));
-
-	services.sending.send_pdu_servers(servers, &pdu_id).await
+	services.sending.send_pdu_room(room_id, &pdu_id).await
 }