membership.rs

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 std::{
    collections::{hash_map::Entry, BTreeMap, HashMap, HashSet},
    sync::{Arc, RwLock},
    time::{Duration, Instant},
};
use tracing::{debug, error, info, warn};

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

use super::get_alias_helper;

/// # `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(std::borrow::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(std::borrow::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.",