tuwunel_api_client/room/

summary.rs

use axum::extract::State;
use futures::{
	FutureExt, StreamExt, TryFutureExt,
	future::{join3, join4, join5},
};
use ruma::{
	OwnedServerName, RoomId, UserId,
	api::{
		client::room::get_summary::{self, v1::Response},
		federation::space::get_hierarchy,
	},
	events::room::member::MembershipState,
	room::{JoinRuleSummary, RoomSummary},
};
use tuwunel_core::{
	Err, Result, debug_warn, err, trace,
	utils::{
		BoolExt, FutureBoolExt, IterStream,
		future::{OptionFutureExt, TryExtExt},
		option::OptionExt,
	},
};
use tuwunel_service::{
	Services,
	federation::feds::{Fault, Opts, OutcomeExt, Record},
};

use crate::{ClientIp, Ruma, RumaResponse};

/// # `GET /_matrix/client/unstable/im.nheko.summary/rooms/{roomIdOrAlias}/summary`
///
/// Returns a short description of the state of a room.
///
/// This is the "wrong" endpoint that some implementations/clients may use
/// according to the MSC. Request and response bodies are the same as
/// `get_room_summary`.
///
/// An implementation of [MSC3266](https://github.com/matrix-org/matrix-spec-proposals/pull/3266)
pub(crate) async fn get_room_summary_legacy(
	State(services): State<crate::State>,
	ClientIp(client): ClientIp,
	body: Ruma<get_summary::v1::Request>,
) -> Result<RumaResponse<Response>> {
	get_room_summary(State(services), ClientIp(client), body)
		.await
		.map(RumaResponse)
}

/// # `GET /_matrix/client/unstable/im.nheko.summary/summary/{roomIdOrAlias}`
///
/// Returns a short description of the state of a room.
///
/// An implementation of [MSC3266](https://github.com/matrix-org/matrix-spec-proposals/pull/3266)
#[tracing::instrument(skip_all, fields(%client), name = "room_summary")]
pub(crate) async fn get_room_summary(
	State(services): State<crate::State>,
	ClientIp(client): ClientIp,
	body: Ruma<get_summary::v1::Request>,
) -> Result<Response> {
	let (room_id, servers) = services
		.alias
		.maybe_resolve_with_servers(&body.room_id_or_alias, Some(&body.via))
		.await?;

	if services.metadata.is_banned(&room_id).await {
		return Err!(Request(Forbidden("This room is banned on this homeserver.")));
	}

	room_summary_response(&services, &room_id, &servers, body.sender_user.as_deref()).await
}

async fn room_summary_response(
	services: &Services,
	room_id: &RoomId,
	servers: &[OwnedServerName],
	sender_user: Option<&UserId>,
) -> Result<Response> {
	if services
		.state_cache
		.server_in_room(services.globals.server_name(), room_id)
		.await
	{
		return local_room_summary_response(services, room_id, sender_user)
			.boxed() // size firewall
			.await;
	}

	let summary =
		remote_room_summary_hierarchy_response(services, room_id, servers, sender_user).await?;

	let membership = sender_user
		.map_async(|sender_user| {
			services
				.state_cache
				.is_invited(sender_user, room_id)
				.map(|invited| invited.map_or(MembershipState::Leave, || MembershipState::Invite))
		})
		.await;

	Ok(Response { summary, membership })
}

async fn local_room_summary_response(
	services: &Services,
	room_id: &RoomId,
	sender_user: Option<&UserId>,
) -> Result<Response> {
	trace!(?sender_user, ?room_id, "Sending local room summary response");
	let join_rule = services.state_accessor.get_join_rules(room_id);

	let world_readable = services.state_accessor.is_world_readable(room_id);

	let guest_can_join = services.state_accessor.guest_can_join(room_id);

	let (join_rule, world_readable, guest_can_join) =
		join3(join_rule, world_readable, guest_can_join).await;

	trace!(?join_rule, world_readable, guest_can_join, "Room summary access");
	user_can_see_summary(
		services,
		room_id,
		&join_rule.clone().into(),
		guest_can_join,
		world_readable,
		join_rule.allowed_room_ids(),
		sender_user,
	)
	.await?;

	let canonical_alias = services
		.state_accessor
		.get_canonical_alias(room_id)
		.ok();

	let name = services.state_accessor.get_name(room_id).ok();

	let topic = services
		.state_accessor
		.get_room_topic(room_id)
		.ok();

	let avatar_url = services
		.state_accessor
		.get_avatar(room_id)
		.map_ok(|content| content.url)
		.ok()
		.map(Option::flatten);

	let room_type = services
		.state_accessor
		.get_room_type(room_id)
		.ok();

	let (canonical_alias, name, topic, avatar_url, room_type) =
		join5(canonical_alias, name, topic, avatar_url, room_type).await;

	// Two rounds overlay in the layout; one nine-way join holds every read at once.
	let room_version = services.state.get_room_version(room_id).ok();

	let encryption = services
		.state_accessor
		.get_room_encryption(room_id)
		.ok();

	let num_joined_members = services
		.state_cache
		.room_joined_count(room_id)
		.unwrap_or(0);

	let membership = sender_user.map_async(|sender_user| {
		services
			.state_accessor
			.get_member(room_id, sender_user)
			.map_ok_or(MembershipState::Leave, |content| content.membership)
	});

	let (room_version, encryption, num_joined_members, membership) =
		join4(room_version, encryption, num_joined_members, membership).await;

	Ok(Response {
		summary: RoomSummary {
			room_id: room_id.to_owned(),
			canonical_alias,
			avatar_url,
			guest_can_join,
			name,
			num_joined_members: num_joined_members.try_into().unwrap_or_default(),
			topic,
			world_readable,
			room_type,
			room_version,
			encryption,
			join_rule: join_rule.into(),
		},
		membership,
	})
}

/// used by MSC3266 to fetch a room's info if we do not know about it
async fn remote_room_summary_hierarchy_response(
	services: &Services,
	room_id: &RoomId,
	servers: &[OwnedServerName],
	sender_user: Option<&UserId>,
) -> Result<RoomSummary> {
	trace!(?sender_user, ?servers, ?room_id, "Sending remote room summary response");
	services.config.require_federation()?;

	if services.metadata.is_disabled(room_id).await {
		return Err!(Request(Forbidden(
			"Federation of room {room_id} is currently disabled on this server."
		)));
	}

	if servers.is_empty() {
		return Err!(Request(NotFound(
			"Room is unknown to this server and no servers were provided to fetch it over \
			 federation."
		)));
	}

	let request = get_hierarchy::v1::Request::new(room_id.to_owned());
	let opts = Opts {
		record: Record::Contribute,
		..Default::default()
	};
	let acceptable = |response: &get_hierarchy::v1::Response| {
		trace!(?response, "federation response");
		let returned_room_id = &response.room.summary.room_id;
		let accepted = returned_room_id == room_id;

		if !accepted {
			debug_warn!(
				%returned_room_id,
				requested_room_id = %room_id,
				"federation room hierarchy response did not match request"
			);
		}

		accepted
	};

	let response = services
		.federation
		.fanout_to(servers.iter().cloned().stream(), move |_| request.clone(), opts)
		.inspect(|outcome| match &outcome.result {
			| Ok(_) => {},
			| Err(Fault::Error(e)) => {
				debug_warn!(?e, "Failed to fetch room hierarchy over federation");
			},
			| Err(fault) => {
				debug_warn!(?fault, "Failed to fetch room hierarchy over federation");
			},
		})
		.first_acceptable(acceptable)
		.await;

	let Some((_, response)) = response else {
		return Err!(Request(NotFound(
			"Room is unknown to this server and was unable to fetch over federation with the \
			 provided servers available"
		)));
	};

	let room = response.room;
	let summary = &room.summary;

	user_can_see_summary(
		services,
		room_id,
		&summary.join_rule,
		summary.guest_can_join,
		summary.world_readable,
		summary.join_rule.allowed_room_ids(),
		sender_user,
	)
	.await
	.map(|()| room.summary)
}

async fn user_can_see_summary<'a, I>(
	services: &Services,
	room_id: &RoomId,
	join_rule: &JoinRuleSummary,
	guest_can_join: bool,
	world_readable: bool,
	allowed_room_ids: I,
	sender_user: Option<&UserId>,
) -> Result
where
	I: Iterator<Item = &'a RoomId> + Send,
{
	let is_public_room = matches!(
		join_rule,
		JoinRuleSummary::Public | JoinRuleSummary::Knock | JoinRuleSummary::KnockRestricted(_)
	);

	if is_public_room {
		return Ok(());
	}

	let Some(sender_user) = sender_user else {
		return BoolExt::ok_or_else(world_readable, || {
			err!(Request(Forbidden(
				"Room is not world readable or publicly accessible/joinable, authentication is \
				 required"
			)))
		});
	};

	// The summary shows the room as it is now, which a former member may not see.
	let is_invited = services
		.state_cache
		.is_invited(sender_user, room_id);

	let user_can_peek = services
		.state_accessor
		.user_can_peek(sender_user, room_id);

	let guest_admitted = guest_can_join
		.then_async(|| {
			services
				.users
				.is_deactivated(sender_user)
				.unwrap_or(false)
		})
		.unwrap_or_default();

	let user_in_allowed_restricted_room = services
		.state_cache
		.is_joined_any(sender_user, allowed_room_ids);

	// The allowed-room scan trails; any cheaper check can admit first.
	let can_see = is_invited.or3(user_can_peek, guest_admitted, user_in_allowed_restricted_room);

	BoolExt::ok_or_else(can_see.await, || {
		err!(Request(Forbidden(
			"Room is not world readable, not publicly accessible/joinable, restricted room \
			 conditions not met, and guest access is forbidden. Not allowed to see details of \
			 this room."
		)))
	})
}