Merge branch 'membership-knock' into 'next'

Draft: Knocking support

See merge request famedly/conduit!695

src/api/client_server/membership.rs

@@ -2,6 +2,7 @@ use ruma::{
     api::{
         client::{
             error::ErrorKind,
+            knock::{self, knock_room},
             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,
@@ -142,6 +143,53 @@ pub async fn join_room_by_id_or_alias_route(
     })
 }
 
+/// # `POST /_matrix/client/r0/join/{roomIdOrAlias}`
+///
+/// Tries to knock the room to ask permission to join for the sender user.
+pub async fn knock_room_route(
+    body: Ruma<knock_room::v3::Request>,
+) -> Result<knock_room::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) => {
+            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(|s| s.to_owned()))
+                    .filter_map(|sender| UserId::parse(sender).ok())
+                    .map(|user| user.server_name().to_owned()),
+            );
+
+            servers.push(
+                room_id
+                    .server_name()
+                    .expect("Room IDs should always have a server name")
+                    .into(),
+            );
+
+            (servers, room_id)
+        }
+        Err(room_alias) => {
+            let response = get_alias_helper(room_alias).await?;
+
+            (response.servers, response.room_id)
+        }
+    };
+
+    Ok(knock_room_by_id_or_alias::v3::Response {
+        room_id: knock_room_response.room_id,
+    })
+}
+
 /// # `POST /_matrix/client/r0/rooms/{roomId}/leave`
 ///
 /// Tries to leave the sender user from a room.

src/api/server_server.rs

@@ -27,6 +27,7 @@ use ruma::{
             },
             event::{get_event, get_missing_events, get_room_state, get_room_state_ids},
             keys::{claim_keys, get_keys},
+            knock::{create_knock_event_template, send_knock},
             membership::{create_invite, create_join_event, prepare_join_event},
             openid::get_openid_userinfo,
             query::{get_profile_information, get_room_information},
@@ -1542,14 +1543,16 @@ pub async fn create_join_event_template_route(
         .transpose()?;
 
     if let Some(join_rules_event_content) = join_rules_event_content {
-        if matches!(
+        if let JoinRule::Restricted { .. } = join_rules_event_content.join_rule {
-            join_rules_event_content.join_rule,
-            JoinRule::Restricted { .. } | JoinRule::KnockRestricted { .. }
-        ) {
             return Err(Error::BadRequest(
                 ErrorKind::UnableToAuthorizeJoin,
                 "Conduit does not support restricted rooms yet.",
             ));
+        } else if let JoinRule::KnockRestricted { .. } = join_rules_event_content.join_rule {
+            return Err(Error::BadRequest(
+                ErrorKind::UnableToAuthorizeJoin,
+                "This room is restricted but accepts knocking.",
+            ));
         }
     }
 
@@ -1563,17 +1566,8 @@ pub async fn create_join_event_template_route(
         ));
     }
 
-    let content = to_raw_value(&RoomMemberEventContent {
+    let content = to_raw_value(&RoomMemberEventContent::new(MembershipState::Join))
-        avatar_url: None,
+        .expect("member event is valid value");
-        blurhash: None,
-        displayname: None,
-        is_direct: None,
-        membership: MembershipState::Join,
-        third_party_invite: None,
-        reason: None,
-        join_authorized_via_users_server: None,
-    })
-    .expect("member event is valid value");
 
     let (_pdu, mut pdu_json) = services().rooms.timeline.create_hash_and_sign_event(
         PduBuilder {
@@ -1891,6 +1885,123 @@ pub async fn create_invite_route(
     })
 }
 
+/// # `GET /_matrix/federation/v1/make_knock/{roomId}/{userId}`
+///
+/// Creates a knock template.
+pub async fn create_knock_event_template_route(
+    body: Ruma<create_knock_event_template::v1::Request>,
+) -> Result<create_knock_event_template::v1::Response> {
+    if !services().rooms.metadata.exists(&body.room_id)? {
+        return Err(Error::BadRequest(
+            ErrorKind::NotFound,
+            "Room is unknown to this server.",
+        ));
+    }
+
+    let sender_servername = body
+        .sender_servername
+        .as_ref()
+        .expect("server is authenticated");
+
+    services()
+        .rooms
+        .event_handler
+        .acl_check(sender_servername, &body.room_id)?;
+
+    let mutex_state = Arc::clone(
+        services()
+            .globals
+            .roomid_mutex_state
+            .write()
+            .await
+            .entry(body.room_id.to_owned())
+            .or_default(),
+    );
+    let state_lock = mutex_state.lock().await;
+
+    // TODO: Conduit does not implement restricted join rules yet, we always reject
+    let join_rules_event = services().rooms.state_accessor.room_state_get(
+        &body.room_id,
+        &StateEventType::RoomJoinRules,
+        "",
+    )?;
+
+    let join_rules_event_content: Option<RoomJoinRulesEventContent> = join_rules_event
+        .as_ref()
+        .map(|join_rules_event| {
+            serde_json::from_str(join_rules_event.content.get()).map_err(|e| {
+                warn!("Invalid join rules event: {}", e);
+                Error::bad_database("Invalid join rules event in db.")
+            })
+        })
+        .transpose()?;
+
+    // TODO: Return 403 if the user was banned
+    if let Some(join_rules_event_content) = join_rules_event_content {
+        if matches!(
+            join_rules_event_content.join_rule,
+            JoinRule::Restricted { .. }
+        ) {
+            return Err(Error::BadRequest(
+                ErrorKind::UnableToAuthorizeJoin,
+                "Conduit does not support restricted rooms yet.",
+            ));
+        }
+    }
+
+    let room_version = services().rooms.state.get_room_version(&body.room_id)?;
+    if !body.ver.contains(&room_version) {
+        return Err(Error::BadRequest(
+            ErrorKind::IncompatibleRoomVersion { room_version },
+            "Room version not supported.",
+        ));
+    }
+
+    let content = to_raw_value(&RoomMemberEventContent::new(MembershipState::Knock))
+        .expect("member event is valid value");
+
+    let (_pdu, mut pdu_json) = services().rooms.timeline.create_hash_and_sign_event(
+        PduBuilder {
+            event_type: TimelineEventType::RoomMember,
+            content,
+            unsigned: None,
+            state_key: Some(body.user_id.to_string()),
+            redacts: None,
+        },
+        &body.user_id,
+        &body.room_id,
+        &state_lock,
+    )?;
+
+    drop(state_lock);
+
+    pdu_json.remove("event_id");
+
+    Ok(create_knock_event_template::v1::Response {
+        room_version,
+        event: to_raw_value(&pdu_json).expect("CanonicalJson can be serialized to JSON"),
+    })
+}
+
+/// # `PUT /_matrix/federation/v1/send_knock/{roomId}/{eventId}`
+///
+/// Submits a signed knock event.
+pub async fn create_knock_event_route(
+    body: Ruma<send_knock::v1::Request>,
+) -> Result<send_knock::v1::Response> {
+    let sender_servername = body
+        .sender_servername
+        .as_ref()
+        .expect("server is authenticated");
+
+    let create_join_event::v1::RoomState { state, .. } =
+        create_join_event(sender_servername, &body.room_id, &body.pdu).await?;
+
+    let knock_room_state = state.into_iter().map(Raw::from_json).collect();
+
+    Ok(send_knock::v1::Response { knock_room_state })
+}
+
 /// # `GET /_matrix/federation/v1/user/devices/{userId}`
 ///
 /// Gets information on all devices of the user.