membership.rs

use std::{
	collections::{hash_map::Entry, BTreeMap, HashMap, HashSet},
	sync::Arc,
	time::{Duration, Instant},
};

use ruma::{
	api::{
		client::{
			error::ErrorKind,
			membership::{
				ban_user, forget_room, get_member_events, invite_user, join_room_by_id, join_room_by_id_or_alias,
				joined_members, joined_rooms, kick_user, leave_room, unban_user, ThirdPartySigned,
			},
		},
		federation::{self, membership::create_invite},
	},
	canonical_json::to_canonical_value,
	events::{
		room::{
			join_rules::{AllowRule, JoinRule, RoomJoinRulesEventContent},
			member::{MembershipState, RoomMemberEventContent},
			power_levels::RoomPowerLevelsEventContent,
		},
		StateEventType, TimelineEventType,
	},
	serde::Base64,
	state_res, CanonicalJsonObject, CanonicalJsonValue, EventId, OwnedEventId, OwnedRoomId, OwnedServerName,
	OwnedUserId, RoomId, RoomVersionId, UserId,
};
use serde_json::value::{to_raw_value, RawValue as RawJsonValue};
use tokio::sync::RwLock;
use tracing::{debug, error, info, trace, warn};

use super::get_alias_helper;
use crate::{
	service::pdu::{gen_event_id_canonical_json, PduBuilder},
	services, utils, Error, PduEvent, Result, Ruma,
};

/// # `POST /_matrix/client/r0/rooms/{roomId}/join`
///
/// Tries to join the sender user into a room.
///
/// - If the server knowns about this room: creates the join event and does auth
///   rules locally
/// - If the server does not know about the room: asks other servers over
///   federation
pub async fn join_room_by_id_route(body: Ruma<join_room_by_id::v3::Request>) -> Result<join_room_by_id::v3::Response> {
	let sender_user = body.sender_user.as_ref().expect("user is authenticated");

	if services().rooms.metadata.is_banned(&body.room_id)? && !services().users.is_admin(sender_user)? {
		return Err(Error::BadRequest(
			ErrorKind::Forbidden,
			"This room is banned on this homeserver.",
		));
	}

	let mut servers = Vec::new(); // There is no body.server_name for /roomId/join
	servers.extend(
		services()
			.rooms
			.state_cache
			.invite_state(sender_user, &body.room_id)?
			.unwrap_or_default()
			.iter()
			.filter_map(|event| serde_json::from_str(event.json().get()).ok())
			.filter_map(|event: serde_json::Value| event.get("sender").cloned())
			.filter_map(|sender| sender.as_str().map(ToOwned::to_owned))
			.filter_map(|sender| UserId::parse(sender).ok())
			.map(|user| user.server_name().to_owned()),
	);

	// server names being permanently attached to room IDs may be potentally removed
	// in the future (see MSC4051). for future compatibility with this, and just
	// because it makes sense, we shouldn't fail if the room ID doesn't have a
	// server name with it and just use at least the server name from the initial
	// invite above
	if let Some(server) = body.room_id.server_name() {
		servers.push(server.into());
	}

	join_room_by_id_helper(
		body.sender_user.as_deref(),
		&body.room_id,
		body.reason.clone(),
		&servers,
		body.third_party_signed.as_ref(),
	)
	.await
}

/// # `POST /_matrix/client/r0/join/{roomIdOrAlias}`
///
/// Tries to join the sender user into a room.
///
/// - If the server knowns about this room: creates the join event and does auth
///   rules locally
/// - If the server does not know about the room: asks other servers over
///   federation
pub async fn join_room_by_id_or_alias_route(
	body: Ruma<join_room_by_id_or_alias::v3::Request>,
) -> Result<join_room_by_id_or_alias::v3::Response> {
	let sender_user = body.sender_user.as_deref().expect("user is authenticated");
	let body = body.body;

	let (servers, room_id) = match OwnedRoomId::try_from(body.room_id_or_alias) {
		Ok(room_id) => {
			if services().rooms.metadata.is_banned(&room_id)? && !services().users.is_admin(sender_user)? {
				return Err(Error::BadRequest(
					ErrorKind::Forbidden,
					"This room is banned on this homeserver.",
				));
			}

			let mut servers = body.server_name.clone();
			servers.extend(
				services()
					.rooms
					.state_cache
					.invite_state(sender_user, &room_id)?
					.unwrap_or_default()
					.iter()
					.filter_map(|event| serde_json::from_str(event.json().get()).ok())
					.filter_map(|event: serde_json::Value| event.get("sender").cloned())
					.filter_map(|sender| sender.as_str().map(ToOwned::to_owned))
					.filter_map(|sender| UserId::parse(sender).ok())
					.map(|user| user.server_name().to_owned()),
			);

			// server names being permanently attached to room IDs may be potentally removed
			// in the future (see MSC4051). for future compatibility with this, and just
			// because it makes sense, we shouldn't fail if the room ID doesn't have a
			// server name with it and just use at least the server name from the initial
			// invite above
			if let Some(server) = room_id.server_name() {
				servers.push(server.into());
			}

			(servers, room_id)
		},
		Err(room_alias) => {
			let response = get_alias_helper(room_alias).await?;

			if services().rooms.metadata.is_banned(&response.room_id)? && !services().users.is_admin(sender_user)? {
				return Err(Error::BadRequest(
					ErrorKind::Forbidden,
					"This room is banned on this homeserver.",
				));
			}

			(response.servers, response.room_id)
		},
	};

	let join_room_response = join_room_by_id_helper(
		Some(sender_user),
		&room_id,
		body.reason.clone(),
		&servers,
		body.third_party_signed.as_ref(),
	)
	.await?;

	Ok(join_room_by_id_or_alias::v3::Response {
		room_id: join_room_response.room_id,
	})
}

/// # `POST /_matrix/client/v3/rooms/{roomId}/leave`
///
/// Tries to leave the sender user from a room.
///
/// - This should always work if the user is currently joined.
pub async fn leave_room_route(body: Ruma<leave_room::v3::Request>) -> Result<leave_room::v3::Response> {
	let sender_user = body.sender_user.as_ref().expect("user is authenticated");

	leave_room(sender_user, &body.room_id, body.reason.clone()).await?;

	Ok(leave_room::v3::Response::new())
}

/// # `POST /_matrix/client/r0/rooms/{roomId}/invite`
///
/// Tries to send an invite event into the room.
pub async fn invite_user_route(body: Ruma<invite_user::v3::Request>) -> Result<invite_user::v3::Response> {
	let sender_user = body.sender_user.as_ref().expect("user is authenticated");

	if !services().users.is_admin(sender_user)? && services().globals.block_non_admin_invites() {
		info!(
			"User {sender_user} is not an admin and attempted to send an invite to room {}",
			&body.room_id
		);
		return Err(Error::BadRequest(
			ErrorKind::Forbidden,
			"Invites are not allowed on this server.",
		));
	}

	if services().rooms.metadata.is_banned(&body.room_id)? && !services().users.is_admin(sender_user)? {