split state_accessor

Signed-off-by: Jason Volk <jason@zemos.net>

src/service/rooms/state_accessor/user_can.rs

@@ -0,0 +1,187 @@
+use conduwuit::{error, implement, pdu::PduBuilder, Err, Error, Result};
+use ruma::{
+	events::{
+		room::{
+			history_visibility::{HistoryVisibility, RoomHistoryVisibilityEventContent},
+			member::{MembershipState, RoomMemberEventContent},
+			power_levels::{RoomPowerLevels, RoomPowerLevelsEventContent},
+		},
+		StateEventType, TimelineEventType,
+	},
+	EventId, RoomId, UserId,
+};
+
+use crate::rooms::state::RoomMutexGuard;
+
+/// Checks if a given user can redact a given event
+///
+/// If federation is true, it allows redaction events from any user of the
+/// same server as the original event sender
+#[implement(super::Service)]
+pub async fn user_can_redact(
+	&self,
+	redacts: &EventId,
+	sender: &UserId,
+	room_id: &RoomId,
+	federation: bool,
+) -> Result<bool> {
+	let redacting_event = self.services.timeline.get_pdu(redacts).await;
+
+	if redacting_event
+		.as_ref()
+		.is_ok_and(|pdu| pdu.kind == TimelineEventType::RoomCreate)
+	{
+		return Err!(Request(Forbidden("Redacting m.room.create is not safe, forbidding.")));
+	}
+
+	if redacting_event
+		.as_ref()
+		.is_ok_and(|pdu| pdu.kind == TimelineEventType::RoomServerAcl)
+	{
+		return Err!(Request(Forbidden(
+			"Redacting m.room.server_acl will result in the room being inaccessible for \
+			 everyone (empty allow key), forbidding."
+		)));
+	}
+
+	if let Ok(pl_event_content) = self
+		.room_state_get_content::<RoomPowerLevelsEventContent>(
+			room_id,
+			&StateEventType::RoomPowerLevels,
+			"",
+		)
+		.await
+	{
+		let pl_event: RoomPowerLevels = pl_event_content.into();
+		Ok(pl_event.user_can_redact_event_of_other(sender)
+			|| pl_event.user_can_redact_own_event(sender)
+				&& if let Ok(redacting_event) = redacting_event {
+					if federation {
+						redacting_event.sender.server_name() == sender.server_name()
+					} else {
+						redacting_event.sender == sender
+					}
+				} else {
+					false
+				})
+	} else {
+		// Falling back on m.room.create to judge power level
+		if let Ok(room_create) = self
+			.room_state_get(room_id, &StateEventType::RoomCreate, "")
+			.await
+		{
+			Ok(room_create.sender == sender
+				|| redacting_event
+					.as_ref()
+					.is_ok_and(|redacting_event| redacting_event.sender == sender))
+		} else {
+			Err(Error::bad_database(
+				"No m.room.power_levels or m.room.create events in database for room",
+			))
+		}
+	}
+}
+
+/// Whether a user is allowed to see an event, based on
+/// the room's history_visibility at that event's state.
+#[implement(super::Service)]
+#[tracing::instrument(skip_all, level = "trace")]
+pub async fn user_can_see_event(
+	&self,
+	user_id: &UserId,
+	room_id: &RoomId,
+	event_id: &EventId,
+) -> bool {
+	let Ok(shortstatehash) = self.pdu_shortstatehash(event_id).await else {
+		return true;
+	};
+
+	if let Some(visibility) = self
+		.user_visibility_cache
+		.lock()
+		.expect("locked")
+		.get_mut(&(user_id.to_owned(), shortstatehash))
+	{
+		return *visibility;
+	}
+
+	let currently_member = self.services.state_cache.is_joined(user_id, room_id).await;
+
+	let history_visibility = self
+		.state_get_content(shortstatehash, &StateEventType::RoomHistoryVisibility, "")
+		.await
+		.map_or(HistoryVisibility::Shared, |c: RoomHistoryVisibilityEventContent| {
+			c.history_visibility
+		});
+
+	let visibility = match history_visibility {
+		| HistoryVisibility::WorldReadable => true,
+		| HistoryVisibility::Shared => currently_member,
+		| HistoryVisibility::Invited => {
+			// Allow if any member on requesting server was AT LEAST invited, else deny
+			self.user_was_invited(shortstatehash, user_id).await
+		},
+		| HistoryVisibility::Joined => {
+			// Allow if any member on requested server was joined, else deny
+			self.user_was_joined(shortstatehash, user_id).await
+		},
+		| _ => {
+			error!("Unknown history visibility {history_visibility}");
+			false
+		},
+	};
+
+	self.user_visibility_cache
+		.lock()
+		.expect("locked")
+		.insert((user_id.to_owned(), shortstatehash), visibility);
+
+	visibility
+}
+
+/// Whether a user is allowed to see an event, based on
+/// the room's history_visibility at that event's state.
+#[implement(super::Service)]
+#[tracing::instrument(skip_all, level = "trace")]
+pub async fn user_can_see_state_events(&self, user_id: &UserId, room_id: &RoomId) -> bool {
+	if self.services.state_cache.is_joined(user_id, room_id).await {
+		return true;
+	}
+
+	let history_visibility = self
+		.room_state_get_content(room_id, &StateEventType::RoomHistoryVisibility, "")
+		.await
+		.map_or(HistoryVisibility::Shared, |c: RoomHistoryVisibilityEventContent| {
+			c.history_visibility
+		});
+
+	match history_visibility {
+		| HistoryVisibility::Invited =>
+			self.services.state_cache.is_invited(user_id, room_id).await,
+		| HistoryVisibility::WorldReadable => true,
+		| _ => false,
+	}
+}
+
+#[implement(super::Service)]
+pub async fn user_can_invite(
+	&self,
+	room_id: &RoomId,
+	sender: &UserId,
+	target_user: &UserId,
+	state_lock: &RoomMutexGuard,
+) -> bool {
+	self.services
+		.timeline
+		.create_hash_and_sign_event(
+			PduBuilder::state(
+				target_user.into(),
+				&RoomMemberEventContent::new(MembershipState::Invite),
+			),
+			sender,
+			room_id,
+			state_lock,
+		)
+		.await
+		.is_ok()
+}