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},
		},
		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.",
		));
	}

	if let Some(server) = body.room_id.server_name() {
		if services()
			.globals
			.config
			.forbidden_remote_server_names
			.contains(&server.to_owned())
			&& !services().users.is_admin(sender_user)?
		{
			warn!(
				"User {sender_user} tried joining room ID {} which has a server name that is globally forbidden. \
				 Rejecting.",
				body.room_id
			);
			return Err(Error::BadRequest(
				ErrorKind::forbidden(),
				"This remote server is banned on this homeserver.",
			));
		}
	}

	// There is no body.server_name for /roomId/join
	let mut servers = services()
		.rooms
		.state_cache
		.servers_invite_via(&body.room_id)?
		.unwrap_or(
			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())
				.collect::<Vec<_>>(),
		);

	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.",
				));
			}

			if let Some(server) = room_id.server_name() {
				if services()
					.globals
					.config
					.forbidden_remote_server_names
					.contains(&server.to_owned())
					&& !services().users.is_admin(sender_user)?
				{
					warn!(
						"User {sender_user} tried joining room ID {room_id} which has a server name that is globally \
						 forbidden. Rejecting.",
					);
					return Err(Error::BadRequest(
						ErrorKind::forbidden(),
						"This remote server is banned on this homeserver.",
					));
				}
			}

			let mut servers = body.server_name.clone();

			servers.extend(
				services()
					.rooms
					.state_cache
					.servers_invite_via(&room_id)?
					.unwrap_or(
						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())
							.collect(),
					),
			);

			if let Some(server) = room_id.server_name() {
				servers.push(server.to_owned());
			}

			(servers, room_id)
		},
		Err(room_alias) => {
			let response = get_alias_helper(room_alias.clone()).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.",
				));
			}

			if services()
				.globals
				.config
				.forbidden_remote_server_names
				.contains(&room_alias.server_name().to_owned())
				&& !services().users.is_admin(sender_user)?
			{
				warn!(