Merge branch 'membership-refactor' into 'next'

feat: leaving over federation & knocking

Closes #54, #56, and #431

See merge request famedly/conduit!728

Cargo.lock

@@ -2190,7 +2190,7 @@ dependencies = [
 [[package]]
 name = "ruma"
 version = "0.12.1"
-source = "git+https://github.com/ruma/ruma.git#afaf132362fe6195556a872351a70337e97ab755"
+source = "git+https://github.com/ruma/ruma.git#9e6099161d4ed295e694fa0d5de2b28a23840a4f"
 dependencies = [
  "assign",
  "js_int",
@@ -2210,7 +2210,7 @@ dependencies = [
 [[package]]
 name = "ruma-appservice-api"
 version = "0.12.1"
-source = "git+https://github.com/ruma/ruma.git#afaf132362fe6195556a872351a70337e97ab755"
+source = "git+https://github.com/ruma/ruma.git#9e6099161d4ed295e694fa0d5de2b28a23840a4f"
 dependencies = [
  "js_int",
  "ruma-common",
@@ -2222,7 +2222,7 @@ dependencies = [
 [[package]]
 name = "ruma-client-api"
 version = "0.20.1"
-source = "git+https://github.com/ruma/ruma.git#afaf132362fe6195556a872351a70337e97ab755"
+source = "git+https://github.com/ruma/ruma.git#9e6099161d4ed295e694fa0d5de2b28a23840a4f"
 dependencies = [
  "as_variant",
  "assign",
@@ -2245,7 +2245,7 @@ dependencies = [
 [[package]]
 name = "ruma-common"
 version = "0.15.1"
-source = "git+https://github.com/ruma/ruma.git#afaf132362fe6195556a872351a70337e97ab755"
+source = "git+https://github.com/ruma/ruma.git#9e6099161d4ed295e694fa0d5de2b28a23840a4f"
 dependencies = [
  "as_variant",
  "base64 0.22.1",
@@ -2276,7 +2276,7 @@ dependencies = [
 [[package]]
 name = "ruma-events"
 version = "0.30.1"
-source = "git+https://github.com/ruma/ruma.git#afaf132362fe6195556a872351a70337e97ab755"
+source = "git+https://github.com/ruma/ruma.git#9e6099161d4ed295e694fa0d5de2b28a23840a4f"
 dependencies = [
  "as_variant",
  "indexmap 2.2.6",
@@ -2299,7 +2299,7 @@ dependencies = [
 [[package]]
 name = "ruma-federation-api"
 version = "0.11.0"
-source = "git+https://github.com/ruma/ruma.git#afaf132362fe6195556a872351a70337e97ab755"
+source = "git+https://github.com/ruma/ruma.git#9e6099161d4ed295e694fa0d5de2b28a23840a4f"
 dependencies = [
  "bytes",
  "http 1.1.0",
@@ -2317,7 +2317,7 @@ dependencies = [
 [[package]]
 name = "ruma-identifiers-validation"
 version = "0.10.1"
-source = "git+https://github.com/ruma/ruma.git#afaf132362fe6195556a872351a70337e97ab755"
+source = "git+https://github.com/ruma/ruma.git#9e6099161d4ed295e694fa0d5de2b28a23840a4f"
 dependencies = [
  "js_int",
  "thiserror 2.0.11",
@@ -2326,7 +2326,7 @@ dependencies = [
 [[package]]
 name = "ruma-macros"
 version = "0.15.1"
-source = "git+https://github.com/ruma/ruma.git#afaf132362fe6195556a872351a70337e97ab755"
+source = "git+https://github.com/ruma/ruma.git#9e6099161d4ed295e694fa0d5de2b28a23840a4f"
 dependencies = [
  "cfg-if",
  "proc-macro-crate",
@@ -2341,7 +2341,7 @@ dependencies = [
 [[package]]
 name = "ruma-push-gateway-api"
 version = "0.11.0"
-source = "git+https://github.com/ruma/ruma.git#afaf132362fe6195556a872351a70337e97ab755"
+source = "git+https://github.com/ruma/ruma.git#9e6099161d4ed295e694fa0d5de2b28a23840a4f"
 dependencies = [
  "js_int",
  "ruma-common",
@@ -2353,7 +2353,7 @@ dependencies = [
 [[package]]
 name = "ruma-server-util"
 version = "0.5.0"
-source = "git+https://github.com/ruma/ruma.git#afaf132362fe6195556a872351a70337e97ab755"
+source = "git+https://github.com/ruma/ruma.git#9e6099161d4ed295e694fa0d5de2b28a23840a4f"
 dependencies = [
  "headers",
  "http 1.1.0",
@@ -2366,7 +2366,7 @@ dependencies = [
 [[package]]
 name = "ruma-signatures"
 version = "0.17.0"
-source = "git+https://github.com/ruma/ruma.git#afaf132362fe6195556a872351a70337e97ab755"
+source = "git+https://github.com/ruma/ruma.git#9e6099161d4ed295e694fa0d5de2b28a23840a4f"
 dependencies = [
  "base64 0.22.1",
  "ed25519-dalek",
@@ -2382,7 +2382,7 @@ dependencies = [
 [[package]]
 name = "ruma-state-res"
 version = "0.13.0"
-source = "git+https://github.com/ruma/ruma.git#afaf132362fe6195556a872351a70337e97ab755"
+source = "git+https://github.com/ruma/ruma.git#9e6099161d4ed295e694fa0d5de2b28a23840a4f"
 dependencies = [
  "js_int",
  "ruma-common",

Cargo.toml

@@ -19,7 +19,7 @@ repository = "https://gitlab.com/famedly/conduit"
 version = "0.10.0-alpha"
 
 # See also `rust-toolchain.toml`
-rust-version = "1.80.0"
+rust-version = "1.81.0"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

complement/Dockerfile

@@ -1,4 +1,4 @@
-FROM rust:1.80.0
+FROM rust:1.81.0
 
 WORKDIR /workdir
 

flake.nix

@@ -59,7 +59,7 @@
             file = ./rust-toolchain.toml;
 
             # See also `rust-toolchain.toml`
-            sha256 = "sha256-6eN/GKzjVSjEhGO9FhWObkRFaE1Jf+uqMSdQnb8lcB4=";
+            sha256 = "sha256-VZZnlyP69+Y3crrLHQyJirqlHrTtGTsyiSnZB8jEvVo=";
           };
       });
     in

rust-toolchain.toml

@@ -9,7 +9,7 @@
 # If you're having trouble making the relevant changes, bug a maintainer.
 
 [toolchain]
-channel = "1.80.0"
+channel = "1.81.0"
 components = [
   # For rust-analyzer
   "rust-src",

src/api/client_server/alias.rs

@@ -1,15 +1,7 @@
 use crate::{services, Error, Result, Ruma};
-use rand::seq::SliceRandom;
+use ruma::api::client::{
-use ruma::{
-    api::{
-        appservice,
-        client::{
     alias::{create_alias, delete_alias, get_alias},
     error::ErrorKind,
-        },
-        federation,
-    },
-    OwnedRoomAliasId,
 };
 
 /// # `PUT /_matrix/client/r0/directory/room/{roomAlias}`
@@ -115,75 +107,9 @@ pub async fn delete_alias_route(
 pub async fn get_alias_route(
     body: Ruma<get_alias::v3::Request>,
 ) -> Result<get_alias::v3::Response> {
-    get_alias_helper(body.body.room_alias).await
-}
-
-pub(crate) async fn get_alias_helper(
-    room_alias: OwnedRoomAliasId,
-) -> Result<get_alias::v3::Response> {
-    if room_alias.server_name() != services().globals.server_name() {
-        let response = services()
-            .sending
-            .send_federation_request(
-                room_alias.server_name(),
-                federation::query::get_room_information::v1::Request {
-                    room_alias: room_alias.to_owned(),
-                },
-            )
-            .await?;
-
-        let mut servers = response.servers;
-        servers.shuffle(&mut rand::thread_rng());
-
-        return Ok(get_alias::v3::Response::new(response.room_id, servers));
-    }
-
-    let mut room_id = None;
-    match services().rooms.alias.resolve_local_alias(&room_alias)? {
-        Some(r) => room_id = Some(r),
-        None => {
-            for appservice in services().appservice.read().await.values() {
-                if appservice.aliases.is_match(room_alias.as_str())
-                    && matches!(
-                        services()
-                            .sending
-                            .send_appservice_request(
-                                appservice.registration.clone(),
-                                appservice::query::query_room_alias::v1::Request {
-                                    room_alias: room_alias.clone(),
-                                },
-                            )
-                            .await,
-                        Ok(Some(_opt_result))
-                    )
-                {
-                    room_id = Some(
     services()
         .rooms
         .alias
-                            .resolve_local_alias(&room_alias)?
+        .get_alias_helper(body.body.room_alias)
-                            .ok_or_else(|| {
+        .await
-                                Error::bad_config("Appservice lied to us. Room does not exist.")
-                            })?,
-                    );
-                    break;
-                }
-            }
-        }
-    };
-
-    let room_id = match room_id {
-        Some(room_id) => room_id,
-        None => {
-            return Err(Error::BadRequest(
-                ErrorKind::NotFound,
-                "Room with alias not found.",
-            ))
-        }
-    };
-
-    Ok(get_alias::v3::Response::new(
-        room_id,
-        vec![services().globals.server_name().to_owned()],
-    ))
 }

src/api/client_server/sync.rs

@@ -10,7 +10,8 @@ use ruma::{
             self,
             v3::{
                 Ephemeral, Filter, GlobalAccountData, InviteState, InvitedRoom, JoinedRoom,
-                LeftRoom, Presence, RoomAccountData, RoomSummary, Rooms, State, Timeline, ToDevice,
+                KnockState, KnockedRoom, LeftRoom, Presence, RoomAccountData, RoomSummary, Rooms,
+                State, Timeline, ToDevice,
             },
             v4::{SlidingOp, SlidingSyncRoomHero},
             DeviceLists, UnreadNotificationsCount,
@@ -503,6 +504,50 @@ async fn sync_helper(
         );
     }
 
+    let mut knocked_rooms = BTreeMap::new();
+    let all_knocked_rooms: Vec<_> = services()
+        .rooms
+        .state_cache
+        .rooms_knocked(&sender_user)
+        .collect();
+    for result in all_knocked_rooms {
+        let (room_id, knock_state_events) = result?;
+
+        {
+            // Get and drop the lock to wait for remaining operations to finish
+            let mutex_insert = Arc::clone(
+                services()
+                    .globals
+                    .roomid_mutex_insert
+                    .write()
+                    .await
+                    .entry(room_id.clone())
+                    .or_default(),
+            );
+            let insert_lock = mutex_insert.lock().await;
+            drop(insert_lock);
+        }
+
+        let knock_count = services()
+            .rooms
+            .state_cache
+            .get_knock_count(&room_id, &sender_user)?;
+
+        // knock before last sync
+        if Some(since) >= knock_count {
+            continue;
+        }
+
+        knocked_rooms.insert(
+            room_id.clone(),
+            KnockedRoom {
+                knock_state: KnockState {
+                    events: knock_state_events,
+                },
+            },
+        );
+    }
+
     for user_id in left_encrypted_users {
         let dont_share_encrypted_room = services()
             .rooms
@@ -538,7 +583,7 @@ async fn sync_helper(
             leave: left_rooms,
             join: joined_rooms,
             invite: invited_rooms,
-            knock: BTreeMap::new(), // TODO
+            knock: knocked_rooms,
         },
         presence: Presence {
             events: presence_updates

src/api/server_server.rs

@@ -31,7 +31,11 @@ use ruma::{
             },
             event::{get_event, get_missing_events, get_room_state, get_room_state_ids},
             keys::{claim_keys, get_keys},
-            membership::{create_invite, create_join_event, prepare_join_event},
+            knock::{create_knock_event_template, send_knock},
+            membership::{
+                create_invite, create_join_event, create_leave_event, prepare_join_event,
+                prepare_leave_event,
+            },
             openid::get_openid_userinfo,
             query::{get_profile_information, get_room_information},
             space::get_hierarchy,
@@ -67,7 +71,7 @@ use std::{
     sync::Arc,
     time::{Duration, Instant, SystemTime},
 };
-use tokio::sync::RwLock;
+use tokio::sync::{Mutex, RwLock};
 
 use tracing::{debug, error, warn};
 
@@ -637,7 +641,7 @@ async fn request_well_known(destination: &str) -> Option<(String, Instant)> {
     let response = services()
         .globals
         .default_client()
-        .get(&format!("https://{destination}/.well-known/matrix/server"))
+        .get(format!("https://{destination}/.well-known/matrix/server"))
         .send()
         .await;
     debug!("Got well known response");
@@ -1494,42 +1498,60 @@ pub async fn get_room_state_ids_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> {
+    let (mutex_state, room_version_id) =
+        member_shake_preamble(&body.sender_servername, &body.room_id).await?;
+    let state_lock = mutex_state.lock().await;
+
+    Ok(create_knock_event_template::v1::Response {
+        room_version: room_version_id,
+        event: create_membership_template(
+            &body.user_id,
+            &body.room_id,
+            None,
+            MembershipState::Knock,
+            state_lock,
+        )?,
+    })
+}
+
+/// # `GET /_matrix/federation/v1/make_leave/{roomId}/{userId}`
+///
+/// Creates a leave template.
+pub async fn create_leave_event_template_route(
+    body: Ruma<prepare_leave_event::v1::Request>,
+) -> Result<prepare_leave_event::v1::Response> {
+    let (mutex_state, room_version_id) =
+        member_shake_preamble(&body.sender_servername, &body.room_id).await?;
+    let state_lock = mutex_state.lock().await;
+
+    Ok(prepare_leave_event::v1::Response {
+        room_version: Some(room_version_id),
+        event: create_membership_template(
+            &body.user_id,
+            &body.room_id,
+            None,
+            MembershipState::Leave,
+            state_lock,
+        )?,
+    })
+}
+
 /// # `GET /_matrix/federation/v1/make_join/{roomId}/{userId}`
 ///
 /// Creates a join template.
 pub async fn create_join_event_template_route(
     body: Ruma<prepare_join_event::v1::Request>,
 ) -> Result<prepare_join_event::v1::Response> {
-    if !services().rooms.metadata.exists(&body.room_id)? {
+    let (mutex_state, room_version_id) =
-        return Err(Error::BadRequest(
+        member_shake_preamble(&body.sender_servername, &body.room_id).await?;
-            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;
 
-    let room_version_id = services().rooms.state.get_room_version(&body.room_id)?;
-
     let join_authorized_via_users_server = if
     // The following two functions check whether the user can "join" without performing a restricted join
     !services()
@@ -1580,12 +1602,32 @@ pub async fn create_join_event_template_route(
         ));
     }
 
+    Ok(prepare_join_event::v1::Response {
+        room_version: Some(room_version_id),
+        event: create_membership_template(
+            &body.user_id,
+            &body.room_id,
+            join_authorized_via_users_server,
+            MembershipState::Join,
+            state_lock,
+        )?,
+    })
+}
+
+/// Creates a template for the given membership state, to return on the `/make_<membership>` endpoints
+fn create_membership_template(
+    user_id: &UserId,
+    room_id: &RoomId,
+    join_authorized_via_users_server: Option<OwnedUserId>,
+    membership: MembershipState,
+    state_lock: tokio::sync::MutexGuard<'_, ()>,
+) -> Result<Box<RawJsonValue>, Error> {
     let content = to_raw_value(&RoomMemberEventContent {
         avatar_url: None,
         blurhash: None,
         displayname: None,
         is_direct: None,
-        membership: MembershipState::Join,
+        membership,
         third_party_invite: None,
         reason: None,
         join_authorized_via_users_server,
@@ -1597,12 +1639,12 @@ pub async fn create_join_event_template_route(
             event_type: TimelineEventType::RoomMember,
             content,
             unsigned: None,
-            state_key: Some(body.user_id.to_string()),
+            state_key: Some(user_id.to_string()),
             redacts: None,
             timestamp: None,
         },
-        &body.user_id,
+        user_id,
-        &body.room_id,
+        room_id,
         &state_lock,
     )?;
 
@@ -1610,17 +1652,13 @@ pub async fn create_join_event_template_route(
 
     pdu_json.remove("event_id");
 
-    Ok(prepare_join_event::v1::Response {
+    let raw_event = to_raw_value(&pdu_json).expect("CanonicalJson can be serialized to JSON");
-        room_version: Some(room_version_id),
+
-        event: to_raw_value(&pdu_json).expect("CanonicalJson can be serialized to JSON"),
+    Ok(raw_event)
-    })
 }
 
-async fn create_join_event(
+/// checks whether the given room exists, and checks whether the specified server is allowed to send events according to the ACL
-    sender_servername: &ServerName,
+fn room_and_acl_check(room_id: &RoomId, sender_servername: &OwnedServerName) -> Result<(), Error> {
-    room_id: &RoomId,
-    pdu: &RawJsonValue,
-) -> Result<create_join_event::v1::RoomState> {
     if !services().rooms.metadata.exists(room_id)? {
         return Err(Error::BadRequest(
             ErrorKind::NotFound,
@@ -1632,6 +1670,40 @@ async fn create_join_event(
         .rooms
         .event_handler
         .acl_check(sender_servername, room_id)?;
+    Ok(())
+}
+
+/// Takes care of common boilerpalte for room membership handshake endpoints.
+/// The returned mutex must be locked by the caller.
+async fn member_shake_preamble(
+    sender_servername: &Option<OwnedServerName>,
+    room_id: &RoomId,
+) -> Result<(Arc<Mutex<()>>, RoomVersionId), Error> {
+    let sender_servername = sender_servername.as_ref().expect("server is authenticated");
+    room_and_acl_check(room_id, sender_servername)?;
+
+    let mutex_state = Arc::clone(
+        services()
+            .globals
+            .roomid_mutex_state
+            .write()
+            .await
+            .entry(room_id.to_owned())
+            .or_default(),
+    );
+
+    let room_version_id = services().rooms.state.get_room_version(room_id)?;
+
+    Ok((mutex_state, room_version_id))
+}
+
+async fn create_join_event(
+    sender_servername: &Option<OwnedServerName>,
+    room_id: &RoomId,
+    pdu: &RawJsonValue,
+) -> Result<create_join_event::v1::RoomState> {
+    let sender_servername = sender_servername.as_ref().expect("server is authenticated");
+    room_and_acl_check(room_id, sender_servername)?;
 
     // We need to return the state prior to joining, let's keep a reference to that here
     let shortstatehash = services()
@@ -1643,8 +1715,44 @@ async fn create_join_event(
             "Pdu state not found.",
         ))?;
 
+    let pdu = append_member_pdu(MembershipState::Join, sender_servername, room_id, pdu).await?;
+
+    let state_ids = services()
+        .rooms
+        .state_accessor
+        .state_full_ids(shortstatehash)
+        .await?;
+    let auth_chain_ids = services()
+        .rooms
+        .auth_chain
+        .get_auth_chain(room_id, state_ids.values().cloned().collect())
+        .await?;
+
+    Ok(create_join_event::v1::RoomState {
+        auth_chain: auth_chain_ids
+            .filter_map(|id| services().rooms.timeline.get_pdu_json(&id).ok().flatten())
+            .map(PduEvent::convert_to_outgoing_federation_event)
+            .collect(),
+        state: state_ids
+            .iter()
+            .filter_map(|(_, id)| services().rooms.timeline.get_pdu_json(id).ok().flatten())
+            .map(PduEvent::convert_to_outgoing_federation_event)
+            .collect(),
+        event: pdu.map(|pdu| {
+            to_raw_value(&CanonicalJsonValue::Object(pdu))
+                .expect("To raw json should not fail since only change was adding signature")
+        }),
+    })
+}
+
+/// Takes the given membership PDU and attempts to append it to the timeline
+async fn append_member_pdu(
+    membership: MembershipState,
+    sender_servername: &OwnedServerName,
+    room_id: &RoomId,
+    pdu: &RawJsonValue,
+) -> Result<Option<BTreeMap<String, CanonicalJsonValue>>, Error> {
     let pub_key_map = RwLock::new(BTreeMap::new());
-    // let mut auth_cache = EventMap::new();
 
     // We do not add the event_id field to the pdu here because of signature and hashes checks
     let room_version_id = services().rooms.state.get_room_version(room_id)?;
@@ -1719,14 +1827,15 @@ async fn create_join_event(
     )
     .map_err(|_| Error::BadRequest(ErrorKind::BadJson, "Invalid event content"))?;
 
-    if event_content.membership != MembershipState::Join {
+    if event_content.membership != membership {
         return Err(Error::BadRequest(
             ErrorKind::BadJson,
             "Membership of sent event does not match that of the endpoint",
         ));
     }
 
-    let sign_join_event = event_content
+    let sign_join_event = membership == MembershipState::Join
+        && event_content
             .join_authorized_via_users_server
             .map(|user| user.server_name() == services().globals.server_name())
             .unwrap_or_default()
@@ -1779,17 +1888,6 @@ async fn create_join_event(
         ))?;
     drop(mutex_lock);
 
-    let state_ids = services()
-        .rooms
-        .state_accessor
-        .state_full_ids(shortstatehash)
-        .await?;
-    let auth_chain_ids = services()
-        .rooms
-        .auth_chain
-        .get_auth_chain(room_id, state_ids.values().cloned().collect())
-        .await?;
-
     let servers = services()
         .rooms
         .state_cache
@@ -1799,26 +1897,7 @@ async fn create_join_event(
 
     services().sending.send_pdu(servers, &pdu_id)?;
 
-    Ok(create_join_event::v1::RoomState {
+    Ok(if sign_join_event { Some(value) } else { None })
-        auth_chain: auth_chain_ids
-            .filter_map(|id| services().rooms.timeline.get_pdu_json(&id).ok().flatten())
-            .map(PduEvent::convert_to_outgoing_federation_event)
-            .collect(),
-        state: state_ids
-            .iter()
-            .filter_map(|(_, id)| services().rooms.timeline.get_pdu_json(id).ok().flatten())
-            .map(PduEvent::convert_to_outgoing_federation_event)
-            .collect(),
-        // Event field is required if we sign the join event.
-        event: if sign_join_event {
-            Some(
-                to_raw_value(&CanonicalJsonValue::Object(value))
-                    .expect("To raw json should not fail since only change was adding signature"),
-            )
-        } else {
-            None
-        },
-    })
 }
 
 /// # `PUT /_matrix/federation/v1/send_join/{roomId}/{eventId}`
@@ -1827,12 +1906,7 @@ async fn create_join_event(
 pub async fn create_join_event_v1_route(
     body: Ruma<create_join_event::v1::Request>,
 ) -> Result<create_join_event::v1::Response> {
-    let sender_servername = body
+    let room_state = create_join_event(&body.sender_servername, &body.room_id, &body.pdu).await?;
-        .sender_servername
-        .as_ref()
-        .expect("server is authenticated");
-
-    let room_state = create_join_event(sender_servername, &body.room_id, &body.pdu).await?;
 
     Ok(create_join_event::v1::Response { room_state })
 }
@@ -1843,16 +1917,11 @@ pub async fn create_join_event_v1_route(
 pub async fn create_join_event_v2_route(
     body: Ruma<create_join_event::v2::Request>,
 ) -> Result<create_join_event::v2::Response> {
-    let sender_servername = body
-        .sender_servername
-        .as_ref()
-        .expect("server is authenticated");
-
     let create_join_event::v1::RoomState {
         auth_chain,
         state,
         event,
-    } = create_join_event(sender_servername, &body.room_id, &body.pdu).await?;
+    } = create_join_event(&body.sender_servername, &body.room_id, &body.pdu).await?;
     let room_state = create_join_event::v2::RoomState {
         members_omitted: false,
         auth_chain,
@@ -1864,6 +1933,54 @@ pub async fn create_join_event_v2_route(
     Ok(create_join_event::v2::Response { room_state })
 }
 
+/// # `PUT /_matrix/federation/v2/send_leave/{roomId}/{eventId}`
+///
+/// Submits a signed leave event.
+pub async fn create_leave_event_route(
+    body: Ruma<create_leave_event::v2::Request>,
+) -> Result<create_leave_event::v2::Response> {
+    let sender_servername = body
+        .sender_servername
+        .as_ref()
+        .expect("server is authenticated");
+    room_and_acl_check(&body.room_id, sender_servername)?;
+
+    append_member_pdu(
+        MembershipState::Leave,
+        sender_servername,
+        &body.room_id,
+        &body.pdu,
+    )
+    .await?;
+
+    Ok(create_leave_event::v2::Response {})
+}
+
+/// # `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");
+    room_and_acl_check(&body.room_id, sender_servername)?;
+
+    append_member_pdu(
+        MembershipState::Knock,
+        sender_servername,
+        &body.room_id,
+        &body.pdu,
+    )
+    .await?;
+
+    Ok(send_knock::v1::Response {
+        knock_room_state: services().rooms.state.stripped_state(&body.room_id)?,
+    })
+}
+
 /// Checks whether the given user can join the given room via a restricted join.
 /// This doesn't check the current user's membership. This should be done externally,
 /// either by using the state cache or attempting to authorize the event.
@@ -1943,44 +2060,54 @@ fn user_can_perform_restricted_join(
 pub async fn create_invite_route(
     body: Ruma<create_invite::v2::Request>,
 ) -> Result<create_invite::v2::Response> {
-    let sender_servername = body
+    let Ruma::<create_invite::v2::Request> {
-        .sender_servername
+        body,
-        .as_ref()
+        sender_servername,
-        .expect("server is authenticated");
+        ..
+    } = body;
+
+    let create_invite::v2::Request {
+        room_id,
+        room_version,
+        event,
+        invite_room_state,
+        ..
+    } = body;
+
+    let sender_servername = sender_servername.expect("server is authenticated");
 
     services()
         .rooms
         .event_handler
-        .acl_check(sender_servername, &body.room_id)?;
+        .acl_check(&sender_servername, &room_id)?;
-
     if !services()
         .globals
         .supported_room_versions()
-        .contains(&body.room_version)
+        .contains(&room_version)
     {
         return Err(Error::BadRequest(
             ErrorKind::IncompatibleRoomVersion {
-                room_version: body.room_version.clone(),
+                room_version: room_version.clone(),
             },
             "Server does not support this room version.",
         ));
     }
 
-    let mut signed_event = utils::to_canonical_object(&body.event)
+    let mut signed_event = utils::to_canonical_object(&event)
         .map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Invite event is invalid."))?;
 
     ruma::signatures::hash_and_sign_event(
         services().globals.server_name().as_str(),
         services().globals.keypair(),
         &mut signed_event,
-        &body.room_version,
+        &room_version,
     )
     .map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Failed to sign event."))?;
 
     // Generate event id
     let event_id = EventId::parse(format!(
         "${}",
-        ruma::signatures::reference_hash(&signed_event, &body.room_version)
+        ruma::signatures::reference_hash(&signed_event, &room_version)
             .expect("Event format validated when event was hashed")
     ))
     .expect("ruma's reference hashes are valid event ids");
@@ -2015,9 +2142,9 @@ pub async fn create_invite_route(
     )
     .map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "state_key is not a user id."))?;
 
-    let mut invite_state = body.invite_room_state.clone();
+    let mut invite_state = invite_room_state.clone();
 
-    let mut event: JsonObject = serde_json::from_str(body.event.get())
+    let mut event: JsonObject = serde_json::from_str(event.get())
         .map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Invalid invite event bytes."))?;
 
     event.insert("event_id".to_owned(), "$dummy".into());
@@ -2033,10 +2160,48 @@ pub async fn create_invite_route(
     if !services()
         .rooms
         .state_cache
-        .server_in_room(services().globals.server_name(), &body.room_id)?
+        .server_in_room(services().globals.server_name(), &room_id)?
     {
+        // If the user has already knocked on the room, we take that as the user wanting to join
+        // the room as soon as their knock is accepted, as recommended by the spec.
+        //
+        // https://spec.matrix.org/v1.13/client-server-api/#knocking-on-rooms
+        if services()
+            .rooms
+            .state_cache
+            .is_knocked(&invited_user, &room_id)
+            .unwrap_or_default()
+        {
+            // We want to try join automatically first, before notifying clients that they were invited.
+            // We also shouldn't block giving the calling server the response on attempting to join the
+            // room, since it's not relevant for the caller.
+            tokio::spawn(async move {
+                if services().rooms.helpers.join_room_by_id(&invited_user, &room_id, None, &invite_state.iter()                        .filter_map(|event| event.deserialize().ok())
+                        .map(|event| event.sender().server_name().to_owned())
+                        .collect::<Vec<_>>()
+, None)
+                    .await
+                    .is_err() &&
+                    // Checking whether the state has changed since we started this join handshake
+                    services()
+                        .rooms
+                        .state_cache
+                        .is_knocked(&invited_user, &room_id)
+                        .unwrap_or_default()
+                {
+                    let _ = services().rooms.state_cache.update_membership(
+                        &room_id,
+                        &invited_user,
+                        MembershipState::Invite,
+                        &sender,
+                        Some(invite_state),
+                        true,
+                    );
+                }
+            });
+        } else {
             services().rooms.state_cache.update_membership(
-            &body.room_id,
+                &room_id,
                 &invited_user,
                 MembershipState::Invite,
                 &sender,
@@ -2044,6 +2209,7 @@ pub async fn create_invite_route(
                 true,
             )?;
         }
+    }
 
     Ok(create_invite::v2::Response {
         event: PduEvent::convert_to_outgoing_federation_event(signed_event),

src/database/key_value/rooms/mod.rs

@@ -16,6 +16,30 @@ mod threads;
 mod timeline;
 mod user;
 
+use ruma::{RoomId, UserId};
+
 use crate::{database::KeyValueDatabase, service};
 
 impl service::rooms::Data for KeyValueDatabase {}
+
+/// Constructs roomuser_id and userroom_id respectively in byte form
+fn get_room_and_user_byte_ids(room_id: &RoomId, user_id: &UserId) -> (Vec<u8>, Vec<u8>) {
+    (
+        get_roomuser_id_bytes(room_id, user_id),
+        get_userroom_id_bytes(user_id, room_id),
+    )
+}
+
+fn get_roomuser_id_bytes(room_id: &RoomId, user_id: &UserId) -> Vec<u8> {
+    let mut roomuser_id = room_id.as_bytes().to_vec();
+    roomuser_id.push(0xff);
+    roomuser_id.extend_from_slice(user_id.as_bytes());
+    roomuser_id
+}
+
+fn get_userroom_id_bytes(user_id: &UserId, room_id: &RoomId) -> Vec<u8> {
+    let mut userroom_id = user_id.as_bytes().to_vec();
+    userroom_id.push(0xff);
+    userroom_id.extend_from_slice(room_id.as_bytes());
+    userroom_id
+}

src/database/key_value/rooms/state_cache.rs

@@ -7,32 +7,28 @@ use ruma::{
 };
 
 use crate::{
-    database::KeyValueDatabase,
+    database::{abstraction::KvTree, KeyValueDatabase},
     service::{self, appservice::RegistrationInfo},
     services, utils, Error, Result,
 };
 
+use super::{get_room_and_user_byte_ids, get_userroom_id_bytes};
+
 impl service::rooms::state_cache::Data for KeyValueDatabase {
     fn mark_as_once_joined(&self, user_id: &UserId, room_id: &RoomId) -> Result<()> {
-        let mut userroom_id = user_id.as_bytes().to_vec();
+        let userroom_id = get_userroom_id_bytes(user_id, room_id);
-        userroom_id.push(0xff);
-        userroom_id.extend_from_slice(room_id.as_bytes());
         self.roomuseroncejoinedids.insert(&userroom_id, &[])
     }
 
     fn mark_as_joined(&self, user_id: &UserId, room_id: &RoomId) -> Result<()> {
-        let mut roomuser_id = room_id.as_bytes().to_vec();
+        let (roomuser_id, userroom_id) = get_room_and_user_byte_ids(room_id, user_id);
-        roomuser_id.push(0xff);
-        roomuser_id.extend_from_slice(user_id.as_bytes());
-
-        let mut userroom_id = user_id.as_bytes().to_vec();
-        userroom_id.push(0xff);
-        userroom_id.extend_from_slice(room_id.as_bytes());
 
         self.userroomid_joined.insert(&userroom_id, &[])?;
         self.roomuserid_joined.insert(&roomuser_id, &[])?;
         self.userroomid_invitestate.remove(&userroom_id)?;
         self.roomuserid_invitecount.remove(&roomuser_id)?;
+        self.userroomid_knockstate.remove(&userroom_id)?;
+        self.roomuserid_knockcount.remove(&roomuser_id)?;
         self.userroomid_leftstate.remove(&userroom_id)?;
         self.roomuserid_leftcount.remove(&roomuser_id)?;
 
@@ -45,13 +41,7 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
         room_id: &RoomId,
         last_state: Option<Vec<Raw<AnyStrippedStateEvent>>>,
     ) -> Result<()> {
-        let mut roomuser_id = room_id.as_bytes().to_vec();
+        let (roomuser_id, userroom_id) = get_room_and_user_byte_ids(room_id, user_id);
-        roomuser_id.push(0xff);
-        roomuser_id.extend_from_slice(user_id.as_bytes());
-
-        let mut userroom_id = user_id.as_bytes().to_vec();
-        userroom_id.push(0xff);
-        userroom_id.extend_from_slice(room_id.as_bytes());
 
         self.userroomid_invitestate.insert(
             &userroom_id,
@@ -64,6 +54,35 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
         )?;
         self.userroomid_joined.remove(&userroom_id)?;
         self.roomuserid_joined.remove(&roomuser_id)?;
+        self.userroomid_knockstate.remove(&userroom_id)?;
+        self.roomuserid_knockcount.remove(&roomuser_id)?;
+        self.userroomid_leftstate.remove(&userroom_id)?;
+        self.roomuserid_leftcount.remove(&roomuser_id)?;
+
+        Ok(())
+    }
+
+    fn mark_as_knocked(
+        &self,
+        user_id: &UserId,
+        room_id: &RoomId,
+        last_state: Option<Vec<Raw<AnyStrippedStateEvent>>>,
+    ) -> Result<()> {
+        let (roomuser_id, userroom_id) = get_room_and_user_byte_ids(room_id, user_id);
+
+        self.userroomid_knockstate.insert(
+            &userroom_id,
+            &serde_json::to_vec(&last_state.unwrap_or_default())
+                .expect("state to bytes always works"),
+        )?;
+        self.roomuserid_knockcount.insert(
+            &roomuser_id,
+            &services().globals.next_count()?.to_be_bytes(),
+        )?;
+        self.userroomid_joined.remove(&userroom_id)?;
+        self.roomuserid_joined.remove(&roomuser_id)?;
+        self.userroomid_invitestate.remove(&userroom_id)?;
+        self.roomuserid_invitecount.remove(&roomuser_id)?;
         self.userroomid_leftstate.remove(&userroom_id)?;
         self.roomuserid_leftcount.remove(&roomuser_id)?;
 
@@ -71,13 +90,7 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
     }
 
     fn mark_as_left(&self, user_id: &UserId, room_id: &RoomId) -> Result<()> {
-        let mut roomuser_id = room_id.as_bytes().to_vec();
+        let (roomuser_id, userroom_id) = get_room_and_user_byte_ids(room_id, user_id);
-        roomuser_id.push(0xff);
-        roomuser_id.extend_from_slice(user_id.as_bytes());
-
-        let mut userroom_id = user_id.as_bytes().to_vec();
-        userroom_id.push(0xff);
-        userroom_id.extend_from_slice(room_id.as_bytes());
 
         self.userroomid_leftstate.insert(
             &userroom_id,
@@ -91,6 +104,8 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
         self.roomuserid_joined.remove(&roomuser_id)?;
         self.userroomid_invitestate.remove(&userroom_id)?;
         self.roomuserid_invitecount.remove(&roomuser_id)?;
+        self.userroomid_knockstate.remove(&userroom_id)?;
+        self.roomuserid_knockcount.remove(&roomuser_id)?;
 
         Ok(())
     }
@@ -225,13 +240,7 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
     /// Makes a user forget a room.
     #[tracing::instrument(skip(self))]
     fn forget(&self, room_id: &RoomId, user_id: &UserId) -> Result<()> {
-        let mut userroom_id = user_id.as_bytes().to_vec();
+        let (roomuser_id, userroom_id) = get_room_and_user_byte_ids(room_id, user_id);
-        userroom_id.push(0xff);
-        userroom_id.extend_from_slice(room_id.as_bytes());
-
-        let mut roomuser_id = room_id.as_bytes().to_vec();
-        roomuser_id.push(0xff);
-        roomuser_id.extend_from_slice(user_id.as_bytes());
 
         self.userroomid_leftstate.remove(&userroom_id)?;
         self.roomuserid_leftcount.remove(&roomuser_id)?;
@@ -413,6 +422,21 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
             })
     }
 
+    #[tracing::instrument(skip(self))]
+    fn get_knock_count(&self, room_id: &RoomId, user_id: &UserId) -> Result<Option<u64>> {
+        let mut key = room_id.as_bytes().to_vec();
+        key.push(0xff);
+        key.extend_from_slice(user_id.as_bytes());
+
+        self.roomuserid_knockcount
+            .get(&key)?
+            .map_or(Ok(None), |bytes| {
+                Ok(Some(utils::u64_from_bytes(&bytes).map_err(|_| {
+                    Error::bad_database("Invalid knockcount in db.")
+                })?))
+            })
+    }
+
     #[tracing::instrument(skip(self))]
     fn get_left_count(&self, room_id: &RoomId, user_id: &UserId) -> Result<Option<u64>> {
         let mut key = room_id.as_bytes().to_vec();
@@ -460,34 +484,17 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
         &'a self,
         user_id: &UserId,
     ) -> Box<dyn Iterator<Item = Result<(OwnedRoomId, Vec<Raw<AnyStrippedStateEvent>>)>> + 'a> {
-        let mut prefix = user_id.as_bytes().to_vec();
+        scan_userroom_id_memberstate_tree(user_id, &self.userroomid_invitestate)
-        prefix.push(0xff);
+    }
 
-        Box::new(
+    /// Returns an iterator over all rooms a user has knocked on.
-            self.userroomid_invitestate
+    #[allow(clippy::type_complexity)]
-                .scan_prefix(prefix)
+    #[tracing::instrument(skip(self))]
-                .map(|(key, state)| {
+    fn rooms_knocked<'a>(
-                    let room_id = RoomId::parse(
+        &'a self,
-                        utils::string_from_bytes(
+        user_id: &UserId,
-                            key.rsplit(|&b| b == 0xff)
+    ) -> Box<dyn Iterator<Item = Result<(OwnedRoomId, Vec<Raw<AnyStrippedStateEvent>>)>> + 'a> {
-                                .next()
+        scan_userroom_id_memberstate_tree(user_id, &self.userroomid_knockstate)
-                                .expect("rsplit always returns an element"),
-                        )
-                        .map_err(|_| {
-                            Error::bad_database("Room ID in userroomid_invited is invalid unicode.")
-                        })?,
-                    )
-                    .map_err(|_| {
-                        Error::bad_database("Room ID in userroomid_invited is invalid.")
-                    })?;
-
-                    let state = serde_json::from_slice(&state).map_err(|_| {
-                        Error::bad_database("Invalid state in userroomid_invitestate.")
-                    })?;
-
-                    Ok((room_id, state))
-                }),
-        )
     }
 
     #[tracing::instrument(skip(self))]
@@ -511,6 +518,27 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
             .transpose()
     }
 
+    #[tracing::instrument(skip(self))]
+    fn knock_state(
+        &self,
+        user_id: &UserId,
+        room_id: &RoomId,
+    ) -> Result<Option<Vec<Raw<AnyStrippedStateEvent>>>> {
+        let mut key = user_id.as_bytes().to_vec();
+        key.push(0xff);
+        key.extend_from_slice(room_id.as_bytes());
+
+        self.userroomid_knockstate
+            .get(&key)?
+            .map(|state| {
+                let state = serde_json::from_slice(&state)
+                    .map_err(|_| Error::bad_database("Invalid state in userroomid_knockstate."))?;
+
+                Ok(state)
+            })
+            .transpose()
+    }
+
     #[tracing::instrument(skip(self))]
     fn left_state(
         &self,
@@ -539,11 +567,57 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
         &'a self,
         user_id: &UserId,
     ) -> Box<dyn Iterator<Item = Result<(OwnedRoomId, Vec<Raw<AnySyncStateEvent>>)>> + 'a> {
+        scan_userroom_id_memberstate_tree(user_id, &self.userroomid_leftstate)
+    }
+
+    #[tracing::instrument(skip(self))]
+    fn once_joined(&self, user_id: &UserId, room_id: &RoomId) -> Result<bool> {
+        let userroom_id = get_userroom_id_bytes(user_id, room_id);
+
+        Ok(self.roomuseroncejoinedids.get(&userroom_id)?.is_some())
+    }
+
+    #[tracing::instrument(skip(self))]
+    fn is_joined(&self, user_id: &UserId, room_id: &RoomId) -> Result<bool> {
+        let userroom_id = get_userroom_id_bytes(user_id, room_id);
+
+        Ok(self.userroomid_joined.get(&userroom_id)?.is_some())
+    }
+
+    #[tracing::instrument(skip(self))]
+    fn is_invited(&self, user_id: &UserId, room_id: &RoomId) -> Result<bool> {
+        let userroom_id = get_userroom_id_bytes(user_id, room_id);
+
+        Ok(self.userroomid_invitestate.get(&userroom_id)?.is_some())
+    }
+
+    #[tracing::instrument(skip(self))]
+    fn is_knocked(&self, user_id: &UserId, room_id: &RoomId) -> Result<bool> {
+        let userroom_id = get_userroom_id_bytes(user_id, room_id);
+
+        Ok(self.userroomid_knockstate.get(&userroom_id)?.is_some())
+    }
+
+    #[tracing::instrument(skip(self))]
+    fn is_left(&self, user_id: &UserId, room_id: &RoomId) -> Result<bool> {
+        let userroom_id = get_userroom_id_bytes(user_id, room_id);
+
+        Ok(self.userroomid_leftstate.get(&userroom_id)?.is_some())
+    }
+}
+
+/// Scans the given userroom_id_`member`state tree for rooms, returning an iterator of room_ids
+/// and a vector of raw state events
+#[allow(clippy::type_complexity)]
+fn scan_userroom_id_memberstate_tree<'a, T>(
+    user_id: &UserId,
+    userroom_id_memberstate_tree: &'a Arc<dyn KvTree>,
+) -> Box<dyn Iterator<Item = Result<(OwnedRoomId, Vec<Raw<T>>)>> + 'a> {
     let mut prefix = user_id.as_bytes().to_vec();
     prefix.push(0xff);
 
     Box::new(
-            self.userroomid_leftstate
+        userroom_id_memberstate_tree
             .scan_prefix(prefix)
             .map(|(key, state)| {
                 let room_id = RoomId::parse(
@@ -553,55 +627,20 @@ impl service::rooms::state_cache::Data for KeyValueDatabase {
                             .expect("rsplit always returns an element"),
                     )
                     .map_err(|_| {
-                            Error::bad_database("Room ID in userroomid_invited is invalid unicode.")
+                        Error::bad_database(
+                            "Room ID in userroomid_<member>state is invalid unicode.",
+                        )
                     })?,
                 )
                 .map_err(|_| {
-                        Error::bad_database("Room ID in userroomid_invited is invalid.")
+                    Error::bad_database("Room ID in userroomid_<member>state is invalid.")
                 })?;
 
                 let state = serde_json::from_slice(&state).map_err(|_| {
-                        Error::bad_database("Invalid state in userroomid_leftstate.")
+                    Error::bad_database("Invalid state in userroomid_<member>state.")
                 })?;
 
                 Ok((room_id, state))
             }),
     )
-    }
-
-    #[tracing::instrument(skip(self))]
-    fn once_joined(&self, user_id: &UserId, room_id: &RoomId) -> Result<bool> {
-        let mut userroom_id = user_id.as_bytes().to_vec();
-        userroom_id.push(0xff);
-        userroom_id.extend_from_slice(room_id.as_bytes());
-
-        Ok(self.roomuseroncejoinedids.get(&userroom_id)?.is_some())
-    }
-
-    #[tracing::instrument(skip(self))]
-    fn is_joined(&self, user_id: &UserId, room_id: &RoomId) -> Result<bool> {
-        let mut userroom_id = user_id.as_bytes().to_vec();
-        userroom_id.push(0xff);
-        userroom_id.extend_from_slice(room_id.as_bytes());
-
-        Ok(self.userroomid_joined.get(&userroom_id)?.is_some())
-    }
-
-    #[tracing::instrument(skip(self))]
-    fn is_invited(&self, user_id: &UserId, room_id: &RoomId) -> Result<bool> {
-        let mut userroom_id = user_id.as_bytes().to_vec();
-        userroom_id.push(0xff);
-        userroom_id.extend_from_slice(room_id.as_bytes());
-
-        Ok(self.userroomid_invitestate.get(&userroom_id)?.is_some())
-    }
-
-    #[tracing::instrument(skip(self))]
-    fn is_left(&self, user_id: &UserId, room_id: &RoomId) -> Result<bool> {
-        let mut userroom_id = user_id.as_bytes().to_vec();
-        userroom_id.push(0xff);
-        userroom_id.extend_from_slice(room_id.as_bytes());
-
-        Ok(self.userroomid_leftstate.get(&userroom_id)?.is_some())
-    }
 }

src/database/key_value/rooms/timeline.rs

@@ -9,6 +9,8 @@ use crate::{database::KeyValueDatabase, service, services, utils, Error, PduEven
 
 use service::rooms::timeline::PduCount;
 
+use super::get_userroom_id_bytes;
+
 impl service::rooms::timeline::Data for KeyValueDatabase {
     fn last_timeline_count(&self, sender_user: &UserId, room_id: &RoomId) -> Result<PduCount> {
         match self
@@ -286,15 +288,11 @@ impl service::rooms::timeline::Data for KeyValueDatabase {
         let mut notifies_batch = Vec::new();
         let mut highlights_batch = Vec::new();
         for user in notifies {
-            let mut userroom_id = user.as_bytes().to_vec();
+            let userroom_id = get_userroom_id_bytes(&user, room_id);
-            userroom_id.push(0xff);
-            userroom_id.extend_from_slice(room_id.as_bytes());
             notifies_batch.push(userroom_id);
         }
         for user in highlights {
-            let mut userroom_id = user.as_bytes().to_vec();
+            let userroom_id = get_userroom_id_bytes(&user, room_id);
-            userroom_id.push(0xff);
-            userroom_id.extend_from_slice(room_id.as_bytes());
             highlights_batch.push(userroom_id);
         }
 

src/database/key_value/rooms/user.rs

@@ -2,14 +2,11 @@ use ruma::{OwnedRoomId, OwnedUserId, RoomId, UserId};
 
 use crate::{database::KeyValueDatabase, service, services, utils, Error, Result};
 
+use super::{get_room_and_user_byte_ids, get_userroom_id_bytes};
+
 impl service::rooms::user::Data for KeyValueDatabase {
     fn reset_notification_counts(&self, user_id: &UserId, room_id: &RoomId) -> Result<()> {
-        let mut userroom_id = user_id.as_bytes().to_vec();
+        let (roomuser_id, userroom_id) = get_room_and_user_byte_ids(room_id, user_id);
-        userroom_id.push(0xff);
-        userroom_id.extend_from_slice(room_id.as_bytes());
-        let mut roomuser_id = room_id.as_bytes().to_vec();
-        roomuser_id.push(0xff);
-        roomuser_id.extend_from_slice(user_id.as_bytes());
 
         self.userroomid_notificationcount
             .insert(&userroom_id, &0_u64.to_be_bytes())?;
@@ -25,9 +22,7 @@ impl service::rooms::user::Data for KeyValueDatabase {
     }
 
     fn notification_count(&self, user_id: &UserId, room_id: &RoomId) -> Result<u64> {
-        let mut userroom_id = user_id.as_bytes().to_vec();
+        let userroom_id = get_userroom_id_bytes(user_id, room_id);
-        userroom_id.push(0xff);
-        userroom_id.extend_from_slice(room_id.as_bytes());
 
         self.userroomid_notificationcount
             .get(&userroom_id)?
@@ -39,9 +34,7 @@ impl service::rooms::user::Data for KeyValueDatabase {
     }
 
     fn highlight_count(&self, user_id: &UserId, room_id: &RoomId) -> Result<u64> {
-        let mut userroom_id = user_id.as_bytes().to_vec();
+        let userroom_id = get_userroom_id_bytes(user_id, room_id);
-        userroom_id.push(0xff);
-        userroom_id.extend_from_slice(room_id.as_bytes());
 
         self.userroomid_highlightcount
             .get(&userroom_id)?

src/database/mod.rs

@@ -97,8 +97,10 @@ pub struct KeyValueDatabase {
     pub(super) roomid_joinedcount: Arc<dyn KvTree>,
     pub(super) roomid_invitedcount: Arc<dyn KvTree>,
     pub(super) roomuseroncejoinedids: Arc<dyn KvTree>,
-    pub(super) userroomid_invitestate: Arc<dyn KvTree>, // InviteState = Vec<Raw<Pdu>>
+    pub(super) userroomid_invitestate: Arc<dyn KvTree>, // InviteState = Vec<Raw<AnyStrippedStateEvent>>
     pub(super) roomuserid_invitecount: Arc<dyn KvTree>, // InviteCount = Count
+    pub(super) userroomid_knockstate: Arc<dyn KvTree>, // KnockState = Vec<Raw<AnyStrippedStateEvent>>
+    pub(super) roomuserid_knockcount: Arc<dyn KvTree>, // KnockCount = Count
     pub(super) userroomid_leftstate: Arc<dyn KvTree>,
     pub(super) roomuserid_leftcount: Arc<dyn KvTree>,
 
@@ -313,6 +315,8 @@ impl KeyValueDatabase {
             roomuseroncejoinedids: builder.open_tree("roomuseroncejoinedids")?,
             userroomid_invitestate: builder.open_tree("userroomid_invitestate")?,
             roomuserid_invitecount: builder.open_tree("roomuserid_invitecount")?,
+            userroomid_knockstate: builder.open_tree("userroomid_knockstate")?,
+            roomuserid_knockcount: builder.open_tree("roomuserid_knockcount")?,
             userroomid_leftstate: builder.open_tree("userroomid_leftstate")?,
             roomuserid_leftcount: builder.open_tree("roomuserid_leftcount")?,
 

src/main.rs

@@ -345,6 +345,7 @@ fn routes(config: &Config) -> Router {
         .ruma_route(client_server::get_alias_route)
         .ruma_route(client_server::join_room_by_id_route)
         .ruma_route(client_server::join_room_by_id_or_alias_route)
+        .ruma_route(client_server::knock_room_route)
         .ruma_route(client_server::joined_members_route)
         .ruma_route(client_server::leave_room_route)
         .ruma_route(client_server::forget_room_route)
@@ -458,6 +459,10 @@ fn routes(config: &Config) -> Router {
             .ruma_route(server_server::create_join_event_template_route)
             .ruma_route(server_server::create_join_event_v1_route)
             .ruma_route(server_server::create_join_event_v2_route)
+            .ruma_route(server_server::create_leave_event_template_route)
+            .ruma_route(server_server::create_leave_event_route)
+            .ruma_route(server_server::create_knock_event_template_route)
+            .ruma_route(server_server::create_knock_event_route)
             .ruma_route(server_server::create_invite_route)
             .ruma_route(server_server::get_devices_route)
             .ruma_route(server_server::get_content_route)

src/service/mod.rs

@@ -73,6 +73,7 @@ impl Services {
                     },
                 },
                 event_handler: rooms::event_handler::Service,
+                helpers: rooms::helpers::Service,
                 lazy_loading: rooms::lazy_loading::Service {
                     db,
                     lazy_load_waiting: Mutex::new(HashMap::new()),

src/service/rooms/alias/mod.rs

@@ -1,11 +1,16 @@
 mod data;
 
 pub use data::Data;
+use rand::seq::SliceRandom;
 use tracing::error;
 
 use crate::{services, Error, Result};
 use ruma::{
-    api::client::error::ErrorKind,
+    api::{
+        appservice,
+        client::{alias::get_alias, error::ErrorKind},
+        federation,
+    },
     events::{
         room::power_levels::{RoomPowerLevels, RoomPowerLevelsEventContent},
         StateEventType,
@@ -98,4 +103,72 @@ impl Service {
     ) -> Box<dyn Iterator<Item = Result<OwnedRoomAliasId>> + 'a> {
         self.db.local_aliases_for_room(room_id)
     }
+
+    /// Resolves an alias to a room id, and a set of servers to join or knock via, either locally or over federation
+    #[tracing::instrument(skip(self))]
+    pub async fn get_alias_helper(
+        &self,
+        room_alias: OwnedRoomAliasId,
+    ) -> Result<get_alias::v3::Response> {
+        if room_alias.server_name() != services().globals.server_name() {
+            let response = services()
+                .sending
+                .send_federation_request(
+                    room_alias.server_name(),
+                    federation::query::get_room_information::v1::Request {
+                        room_alias: room_alias.to_owned(),
+                    },
+                )
+                .await?;
+
+            let mut servers = response.servers;
+            servers.shuffle(&mut rand::thread_rng());
+
+            return Ok(get_alias::v3::Response::new(response.room_id, servers));
+        }
+
+        let mut room_id = None;
+        match services().rooms.alias.resolve_local_alias(&room_alias)? {
+            Some(r) => room_id = Some(r),
+            None => {
+                for appservice in services().appservice.read().await.values() {
+                    if appservice.aliases.is_match(room_alias.as_str())
+                        && matches!(
+                            services()
+                                .sending
+                                .send_appservice_request(
+                                    appservice.registration.clone(),
+                                    appservice::query::query_room_alias::v1::Request {
+                                        room_alias: room_alias.clone(),
+                                    },
+                                )
+                                .await,
+                            Ok(Some(_opt_result))
+                        )
+                    {
+                        room_id =
+                            Some(self.resolve_local_alias(&room_alias)?.ok_or_else(|| {
+                                Error::bad_config("Appservice lied to us. Room does not exist.")
+                            })?);
+                        break;
+                    }
+                }
+            }
+        };
+
+        let room_id = match room_id {
+            Some(room_id) => room_id,
+            None => {
+                return Err(Error::BadRequest(
+                    ErrorKind::NotFound,
+                    "Room with alias not found.",
+                ))
+            }
+        };
+
+        Ok(get_alias::v3::Response::new(
+            room_id,
+            vec![services().globals.server_name().to_owned()],
+        ))
+    }
 }

src/service/rooms/helpers/mod.rs

@@ -0,0 +1,699 @@
+use std::{
+    collections::{hash_map::Entry, BTreeMap, HashMap},
+    sync::Arc,
+    time::{Duration, Instant},
+};
+
+use ruma::{
+    api::{
+        client::{
+            error::ErrorKind,
+            membership::{join_room_by_id, ThirdPartySigned},
+        },
+        federation,
+    },
+    canonical_json::to_canonical_value,
+    events::{
+        room::{
+            join_rules::{AllowRule, JoinRule, RoomJoinRulesEventContent},
+            member::{MembershipState, RoomMemberEventContent},
+        },
+        TimelineEventType,
+    },
+    state_res, CanonicalJsonObject, CanonicalJsonValue, EventId, MilliSecondsSinceUnixEpoch,
+    OwnedEventId, OwnedServerName, OwnedUserId, RoomId, RoomVersionId, UserId,
+};
+use serde_json::value::{to_raw_value, RawValue as RawJsonValue};
+use tokio::sync::RwLock;
+use tracing::{debug, error, info, warn};
+
+use crate::{
+    service::{
+        globals::SigningKeys,
+        pdu::{gen_event_id_canonical_json, PduBuilder},
+    },
+    services, utils, Error, PduEvent, Result,
+};
+
+pub struct Service;
+
+impl Service {
+    /// Attempts to join a room.
+    /// If the room cannot be joined locally, it attempts to join over federation, soley using the
+    /// specified servers
+    #[tracing::instrument(skip(self, reason, servers, _third_party_signed))]
+    pub async fn join_room_by_id(
+        &self,
+        sender_user: &UserId,
+        room_id: &RoomId,
+        reason: Option<String>,
+        servers: &[OwnedServerName],
+        _third_party_signed: Option<&ThirdPartySigned>,
+    ) -> Result<join_room_by_id::v3::Response, Error> {
+        if let Ok(true) = services().rooms.state_cache.is_joined(sender_user, room_id) {
+            return Ok(join_room_by_id::v3::Response {
+                room_id: room_id.into(),
+            });
+        }
+
+        let mutex_state = Arc::clone(
+            services()
+                .globals
+                .roomid_mutex_state
+                .write()
+                .await
+                .entry(room_id.to_owned())
+                .or_default(),
+        );
+        let state_lock = mutex_state.lock().await;
+
+        // Ask a remote server if we are not participating in this room
+        if !services()
+            .rooms
+            .state_cache
+            .server_in_room(services().globals.server_name(), room_id)?
+        {
+            info!("Joining {room_id} over federation.");
+
+            let (make_join_response, remote_server) =
+                make_join_request(sender_user, room_id, servers).await?;
+
+            info!("make_join finished");
+
+            let room_version_id = match make_join_response.room_version {
+                Some(room_version)
+                    if services()
+                        .globals
+                        .supported_room_versions()
+                        .contains(&room_version) =>
+                {
+                    room_version
+                }
+                _ => return Err(Error::BadServerResponse("Room version is not supported")),
+            };
+
+            let (event_id, mut join_event, _) = self.populate_membership_template(
+                &make_join_response.event,
+                sender_user,
+                reason,
+                &room_version_id,
+                MembershipState::Join,
+            )?;
+
+            info!("Asking {remote_server} for send_join");
+            let send_join_response = services()
+                .sending
+                .send_federation_request(
+                    &remote_server,
+                    federation::membership::create_join_event::v2::Request {
+                        room_id: room_id.to_owned(),
+                        event_id: event_id.to_owned(),
+                        pdu: PduEvent::convert_to_outgoing_federation_event(join_event.clone()),
+                        omit_members: false,
+                    },
+                )
+                .await?;
+
+            info!("send_join finished");
+
+            if let Some(signed_raw) = &send_join_response.room_state.event {
+                info!("There is a signed event. This room is probably using restricted joins. Adding signature to our event");
+                let (signed_event_id, signed_value) =
+                    match gen_event_id_canonical_json(signed_raw, &room_version_id) {
+                        Ok(t) => t,
+                        Err(_) => {
+                            // Event could not be converted to canonical json
+                            return Err(Error::BadRequest(
+                                ErrorKind::InvalidParam,
+                                "Could not convert event to canonical json.",
+                            ));
+                        }
+                    };
+
+                if signed_event_id != event_id {
+                    return Err(Error::BadRequest(
+                        ErrorKind::InvalidParam,
+                        "Server sent event with wrong event id",
+                    ));
+                }
+
+                match signed_value["signatures"]
+                    .as_object()
+                    .ok_or(Error::BadRequest(
+                        ErrorKind::InvalidParam,
+                        "Server sent invalid signatures type",
+                    ))
+                    .and_then(|e| {
+                        e.get(remote_server.as_str()).ok_or(Error::BadRequest(
+                            ErrorKind::InvalidParam,
+                            "Server did not send its signature",
+                        ))
+                    }) {
+                    Ok(signature) => {
+                        join_event
+                            .get_mut("signatures")
+                            .expect("we created a valid pdu")
+                            .as_object_mut()
+                            .expect("we created a valid pdu")
+                            .insert(remote_server.to_string(), signature.clone());
+                    }
+                    Err(e) => {
+                        warn!(
+                        "Server {remote_server} sent invalid signature in sendjoin signatures for event {signed_value:?}: {e:?}",
+                    );
+                    }
+                }
+            }
+
+            services().rooms.short.get_or_create_shortroomid(room_id)?;
+
+            info!("Parsing join event");
+            let parsed_join_pdu = PduEvent::from_id_val(&event_id, join_event.clone())
+                .map_err(|_| Error::BadServerResponse("Invalid join event PDU."))?;
+
+            let mut state = HashMap::new();
+            let pub_key_map = RwLock::new(BTreeMap::new());
+
+            info!("Fetching join signing keys");
+            services()
+                .rooms
+                .event_handler
+                .fetch_join_signing_keys(&send_join_response, &room_version_id, &pub_key_map)
+                .await?;
+
+            info!("Going through send_join response room_state");
+            for result in send_join_response
+                .room_state
+                .state
+                .iter()
+                .map(|pdu| validate_and_add_event_id(pdu, &room_version_id, &pub_key_map))
+            {
+                let (event_id, value) = match result.await {
+                    Ok(t) => t,
+                    Err(_) => continue,
+                };
+
+                let pdu = PduEvent::from_id_val(&event_id, value.clone()).map_err(|e| {
+                    warn!("Invalid PDU in send_join response: {} {:?}", e, value);
+                    Error::BadServerResponse("Invalid PDU in send_join response.")
+                })?;
+
+                services()
+                    .rooms
+                    .outlier
+                    .add_pdu_outlier(&event_id, &value)?;
+                if let Some(state_key) = &pdu.state_key {
+                    let shortstatekey = services()
+                        .rooms
+                        .short
+                        .get_or_create_shortstatekey(&pdu.kind.to_string().into(), state_key)?;
+                    state.insert(shortstatekey, pdu.event_id.clone());
+                }
+            }
+
+            info!("Going through send_join response auth_chain");
+            for result in send_join_response
+                .room_state
+                .auth_chain
+                .iter()
+                .map(|pdu| validate_and_add_event_id(pdu, &room_version_id, &pub_key_map))
+            {
+                let (event_id, value) = match result.await {
+                    Ok(t) => t,
+                    Err(_) => continue,
+                };
+
+                services()
+                    .rooms
+                    .outlier
+                    .add_pdu_outlier(&event_id, &value)?;
+            }
+
+            info!("Running send_join auth check");
+            let authenticated = state_res::event_auth::auth_check(
+                &state_res::RoomVersion::new(&room_version_id).expect("room version is supported"),
+                &parsed_join_pdu,
+                None::<PduEvent>, // TODO: third party invite
+                |k, s| {
+                    services()
+                        .rooms
+                        .timeline
+                        .get_pdu(
+                            state.get(
+                                &services()
+                                    .rooms
+                                    .short
+                                    .get_or_create_shortstatekey(&k.to_string().into(), s)
+                                    .ok()?,
+                            )?,
+                        )
+                        .ok()?
+                },
+            )
+            .map_err(|e| {
+                warn!("Auth check failed: {e}");
+                Error::BadRequest(ErrorKind::InvalidParam, "Auth check failed")
+            })?;
+
+            if !authenticated {
+                return Err(Error::BadRequest(
+                    ErrorKind::InvalidParam,
+                    "Auth check failed",
+                ));
+            }
+
+            info!("Saving state from send_join");
+            let (statehash_before_join, new, removed) =
+                services().rooms.state_compressor.save_state(
+                    room_id,
+                    Arc::new(
+                        state
+                            .into_iter()
+                            .map(|(k, id)| {
+                                services()
+                                    .rooms
+                                    .state_compressor
+                                    .compress_state_event(k, &id)
+                            })
+                            .collect::<Result<_>>()?,
+                    ),
+                )?;
+
+            services()
+                .rooms
+                .state
+                .force_state(room_id, statehash_before_join, new, removed, &state_lock)
+                .await?;
+
+            info!("Updating joined counts for new room");
+            services().rooms.state_cache.update_joined_count(room_id)?;
+
+            // We append to state before appending the pdu, so we don't have a moment in time with the
+            // pdu without it's state. This is okay because append_pdu can't fail.
+            let statehash_after_join = services().rooms.state.append_to_state(&parsed_join_pdu)?;
+
+            info!("Appending new room join event");
+            services()
+                .rooms
+                .timeline
+                .append_pdu(
+                    &parsed_join_pdu,
+                    join_event,
+                    vec![(*parsed_join_pdu.event_id).to_owned()],
+                    &state_lock,
+                )
+                .await?;
+
+            info!("Setting final room state for new room");
+            // We set the room state after inserting the pdu, so that we never have a moment in time
+            // where events in the current room state do not exist
+            services()
+                .rooms
+                .state
+                .set_room_state(room_id, statehash_after_join, &state_lock)?;
+        } else {
+            info!("We can join locally");
+
+            let join_rules_event_content =
+                services().rooms.state_accessor.get_join_rules(room_id)?;
+
+            let restriction_rooms = match join_rules_event_content {
+                Some(RoomJoinRulesEventContent {
+                    join_rule: JoinRule::Restricted(restricted),
+                })
+                | Some(RoomJoinRulesEventContent {
+                    join_rule: JoinRule::KnockRestricted(restricted),
+                }) => restricted
+                    .allow
+                    .into_iter()
+                    .filter_map(|a| match a {
+                        AllowRule::RoomMembership(r) => Some(r.room_id),
+                        _ => None,
+                    })
+                    .collect(),
+                _ => Vec::new(),
+            };
+
+            let authorized_user = if restriction_rooms.iter().any(|restriction_room_id| {
+                services()
+                    .rooms
+                    .state_cache
+                    .is_joined(sender_user, restriction_room_id)
+                    .unwrap_or(false)
+            }) {
+                let mut auth_user = None;
+                for user in services()
+                    .rooms
+                    .state_cache
+                    .room_members(room_id)
+                    .filter_map(Result::ok)
+                    .collect::<Vec<_>>()
+                {
+                    if user.server_name() == services().globals.server_name()
+                        && services()
+                            .rooms
+                            .state_accessor
+                            .user_can_invite(room_id, &user, sender_user, &state_lock)
+                            .unwrap_or(false)
+                    {
+                        auth_user = Some(user);
+                        break;
+                    }
+                }
+                auth_user
+            } else {
+                None
+            };
+
+            let event = RoomMemberEventContent {
+                membership: MembershipState::Join,
+                displayname: services().users.displayname(sender_user)?,
+                avatar_url: services().users.avatar_url(sender_user)?,
+                is_direct: None,
+                third_party_invite: None,
+                blurhash: services().users.blurhash(sender_user)?,
+                reason: reason.clone(),
+                join_authorized_via_users_server: authorized_user,
+            };
+
+            // Try normal join first
+            let Err(error) = services()
+                .rooms
+                .timeline
+                .build_and_append_pdu(
+                    PduBuilder {
+                        event_type: TimelineEventType::RoomMember,
+                        content: to_raw_value(&event).expect("event is valid, we just created it"),
+                        unsigned: None,
+                        state_key: Some(sender_user.to_string()),
+                        redacts: None,
+                        timestamp: None,
+                    },
+                    sender_user,
+                    room_id,
+                    &state_lock,
+                )
+                .await
+            else {
+                return Ok(join_room_by_id::v3::Response::new(room_id.to_owned()));
+            };
+
+            if !restriction_rooms.is_empty()
+                && servers
+                    .iter()
+                    .any(|s| *s != services().globals.server_name())
+            {
+                info!(
+                "We couldn't do the join locally, maybe federation can help to satisfy the restricted join requirements"
+            );
+                let (make_join_response, remote_server) =
+                    make_join_request(sender_user, room_id, servers).await?;
+
+                let room_version_id = match make_join_response.room_version {
+                    Some(room_version_id)
+                        if services()
+                            .globals
+                            .supported_room_versions()
+                            .contains(&room_version_id) =>
+                    {
+                        room_version_id
+                    }
+                    _ => return Err(Error::BadServerResponse("Room version is not supported")),
+                };
+
+                let (event_id, join_event, restricted_join) = self.populate_membership_template(
+                    &make_join_response.event,
+                    sender_user,
+                    reason,
+                    &room_version_id,
+                    MembershipState::Join,
+                )?;
+
+                let send_join_response = services()
+                    .sending
+                    .send_federation_request(
+                        &remote_server,
+                        federation::membership::create_join_event::v2::Request {
+                            room_id: room_id.to_owned(),
+                            event_id: event_id.to_owned(),
+                            pdu: PduEvent::convert_to_outgoing_federation_event(join_event.clone()),
+                            omit_members: false,
+                        },
+                    )
+                    .await?;
+
+                let pdu = if let Some(signed_raw) = send_join_response.room_state.event {
+                    let (signed_event_id, signed_pdu) =
+                        gen_event_id_canonical_json(&signed_raw, &room_version_id)?;
+
+                    if signed_event_id != event_id {
+                        return Err(Error::BadServerResponse(
+                            "Server sent event with wrong event id",
+                        ));
+                    }
+
+                    signed_pdu
+                } else if restricted_join {
+                    return Err(Error::BadServerResponse(
+                        "No signed event was returned, despite just performing a restricted join",
+                    ));
+                } else {
+                    join_event
+                };
+
+                drop(state_lock);
+                let pub_key_map = RwLock::new(BTreeMap::new());
+                services()
+                    .rooms
+                    .event_handler
+                    .handle_incoming_pdu(
+                        &remote_server,
+                        &event_id,
+                        room_id,
+                        pdu,
+                        true,
+                        &pub_key_map,
+                    )
+                    .await?;
+            } else {
+                return Err(error);
+            }
+        }
+
+        Ok(join_room_by_id::v3::Response::new(room_id.to_owned()))
+    }
+
+    /// Takes a membership template, as returned from the `/federation/*/make_*` endpoints, and
+    /// populates them to the point as to where they are a full pdu, ready to be appended to the timeline
+    ///
+    /// Returns the event id, the pdu, and whether this event is a restricted join
+    pub fn populate_membership_template(
+        &self,
+        member_template: &RawJsonValue,
+        sender_user: &UserId,
+        reason: Option<String>,
+        room_version_id: &RoomVersionId,
+        membership: MembershipState,
+    ) -> Result<(OwnedEventId, BTreeMap<String, CanonicalJsonValue>, bool), Error> {
+        let mut member_event_stub: CanonicalJsonObject =
+            serde_json::from_str(member_template.get()).map_err(|_| {
+                Error::BadServerResponse("Invalid make_knock event json received from server.")
+            })?;
+
+        let join_authorized_via_users_server = member_event_stub
+            .get("content")
+            .map(|s| {
+                s.as_object()?
+                    .get("join_authorised_via_users_server")?
+                    .as_str()
+            })
+            .and_then(|s| OwnedUserId::try_from(s.unwrap_or_default()).ok());
+
+        let restricted_join = join_authorized_via_users_server.is_some();
+
+        member_event_stub.insert(
+            "origin".to_owned(),
+            CanonicalJsonValue::String(services().globals.server_name().as_str().to_owned()),
+        );
+
+        member_event_stub.insert(
+            "origin_server_ts".to_owned(),
+            CanonicalJsonValue::Integer(
+                utils::millis_since_unix_epoch()
+                    .try_into()
+                    .expect("Timestamp is valid js_int value"),
+            ),
+        );
+
+        member_event_stub.insert(
+            "content".to_owned(),
+            to_canonical_value(RoomMemberEventContent {
+                membership,
+                displayname: services().users.displayname(sender_user)?,
+                avatar_url: services().users.avatar_url(sender_user)?,
+                is_direct: None,
+                third_party_invite: None,
+                blurhash: services().users.blurhash(sender_user)?,
+                reason: reason.clone(),
+                join_authorized_via_users_server,
+            })
+            .expect("event is valid, we just created it"),
+        );
+
+        member_event_stub.remove("event_id");
+
+        ruma::signatures::hash_and_sign_event(
+            services().globals.server_name().as_str(),
+            services().globals.keypair(),
+            &mut member_event_stub,
+            room_version_id,
+        )
+        .expect("event is valid, we just created it");
+
+        let event_id = format!(
+            "${}",
+            ruma::signatures::reference_hash(&member_event_stub, room_version_id)
+                .expect("Event format validated when event was hashed")
+        );
+
+        let event_id = <OwnedEventId>::try_from(event_id)
+            .expect("ruma's reference hashes are valid event ids");
+
+        member_event_stub.insert(
+            "event_id".to_owned(),
+            CanonicalJsonValue::String(event_id.as_str().to_owned()),
+        );
+
+        Ok((event_id, member_event_stub, restricted_join))
+    }
+}
+
+async fn make_join_request(
+    sender_user: &UserId,
+    room_id: &RoomId,
+    servers: &[OwnedServerName],
+) -> Result<(
+    federation::membership::prepare_join_event::v1::Response,
+    OwnedServerName,
+)> {
+    let mut make_join_response_and_server = Err(Error::BadServerResponse(
+        "No server available to assist in joining.",
+    ));
+
+    for remote_server in servers {
+        if remote_server == services().globals.server_name() {
+            continue;
+        }
+        info!("Asking {remote_server} for make_join");
+        let make_join_response = services()
+            .sending
+            .send_federation_request(
+                remote_server,
+                federation::membership::prepare_join_event::v1::Request {
+                    room_id: room_id.to_owned(),
+                    user_id: sender_user.to_owned(),
+                    ver: services().globals.supported_room_versions(),
+                },
+            )
+            .await;
+
+        make_join_response_and_server = make_join_response.map(|r| (r, remote_server.clone()));
+
+        if make_join_response_and_server.is_ok() {
+            break;
+        }
+    }
+
+    make_join_response_and_server
+}
+async fn validate_and_add_event_id(
+    pdu: &RawJsonValue,
+    room_version: &RoomVersionId,
+    pub_key_map: &RwLock<BTreeMap<String, SigningKeys>>,
+) -> Result<(OwnedEventId, CanonicalJsonObject)> {
+    let mut value: CanonicalJsonObject = serde_json::from_str(pdu.get()).map_err(|e| {
+        error!("Invalid PDU in server response: {:?}: {:?}", pdu, e);
+        Error::BadServerResponse("Invalid PDU in server response")
+    })?;
+    let event_id = EventId::parse(format!(
+        "${}",
+        ruma::signatures::reference_hash(&value, room_version)
+            .map_err(|_| Error::BadRequest(ErrorKind::BadJson, "Invalid PDU format"))?
+    ))
+    .expect("ruma's reference hashes are valid event ids");
+
+    let back_off = |id| async {
+        match services()
+            .globals
+            .bad_event_ratelimiter
+            .write()
+            .await
+            .entry(id)
+        {
+            Entry::Vacant(e) => {
+                e.insert((Instant::now(), 1));
+            }
+            Entry::Occupied(mut e) => *e.get_mut() = (Instant::now(), e.get().1 + 1),
+        }
+    };
+
+    if let Some((time, tries)) = services()
+        .globals
+        .bad_event_ratelimiter
+        .read()
+        .await
+        .get(&event_id)
+    {
+        // Exponential backoff
+        let mut min_elapsed_duration = Duration::from_secs(30) * (*tries) * (*tries);
+        if min_elapsed_duration > Duration::from_secs(60 * 60 * 24) {
+            min_elapsed_duration = Duration::from_secs(60 * 60 * 24);
+        }
+
+        if time.elapsed() < min_elapsed_duration {
+            debug!("Backing off from {}", event_id);
+            return Err(Error::BadServerResponse("bad event, still backing off"));
+        }
+    }
+
+    let origin_server_ts = value.get("origin_server_ts").ok_or_else(|| {
+        error!("Invalid PDU, no origin_server_ts field");
+        Error::BadRequest(
+            ErrorKind::MissingParam,
+            "Invalid PDU, no origin_server_ts field",
+        )
+    })?;
+
+    let origin_server_ts: MilliSecondsSinceUnixEpoch = {
+        let ts = origin_server_ts.as_integer().ok_or_else(|| {
+            Error::BadRequest(
+                ErrorKind::InvalidParam,
+                "origin_server_ts must be an integer",
+            )
+        })?;
+
+        MilliSecondsSinceUnixEpoch(i64::from(ts).try_into().map_err(|_| {
+            Error::BadRequest(ErrorKind::InvalidParam, "Time must be after the unix epoch")
+        })?)
+    };
+
+    let unfiltered_keys = (*pub_key_map.read().await).clone();
+
+    let keys =
+        services()
+            .globals
+            .filter_keys_server_map(unfiltered_keys, origin_server_ts, room_version);
+
+    if let Err(e) = ruma::signatures::verify_event(&keys, &value, room_version) {
+        warn!("Event {} failed verification {:?} {}", event_id, pdu, e);
+        back_off(event_id).await;
+        return Err(Error::BadServerResponse("Event failed verification."));
+    }
+
+    value.insert(
+        "event_id".to_owned(),
+        CanonicalJsonValue::String(event_id.as_str().to_owned()),
+    );
+
+    Ok((event_id, value))
+}

src/service/rooms/mod.rs

@@ -3,6 +3,7 @@ pub mod auth_chain;
 pub mod directory;
 pub mod edus;
 pub mod event_handler;
+pub mod helpers;
 pub mod lazy_loading;
 pub mod metadata;
 pub mod outlier;
@@ -45,6 +46,7 @@ pub struct Service {
     pub directory: directory::Service,
     pub edus: edus::Service,
     pub event_handler: event_handler::Service,
+    pub helpers: helpers::Service,
     pub lazy_loading: lazy_loading::Service,
     pub metadata: metadata::Service,
     pub outlier: outlier::Service,

src/service/rooms/state/mod.rs

@@ -10,6 +10,7 @@ use ruma::{
     events::{
         room::{create::RoomCreateEventContent, member::MembershipState},
         AnyStrippedStateEvent, StateEventType, TimelineEventType,
+        RECOMMENDED_STRIPPED_STATE_EVENT_TYPES,
     },
     serde::Raw,
     state_res::{self, StateMap},
@@ -258,58 +259,22 @@ impl Service {
         }
     }
 
-    #[tracing::instrument(skip(self, invite_event))]
+    #[tracing::instrument(skip(self, room_id))]
-    pub fn calculate_invite_state(
+    /// Gets all the [recommended stripped state events] from the given room
-        &self,
+    ///
-        invite_event: &PduEvent,
+    /// [recommended stripped state events]: https://spec.matrix.org/v1.13/client-server-api/#stripped-state
-    ) -> Result<Vec<Raw<AnyStrippedStateEvent>>> {
+    pub fn stripped_state(&self, room_id: &RoomId) -> Result<Vec<Raw<AnyStrippedStateEvent>>> {
-        let mut state = Vec::new();
+        RECOMMENDED_STRIPPED_STATE_EVENT_TYPES
-        // Add recommended events
+            .iter()
-        if let Some(e) = services().rooms.state_accessor.room_state_get(
+            .filter_map(|state_event_type| {
-            &invite_event.room_id,
+                services()
-            &StateEventType::RoomCreate,
+                    .rooms
-            "",
+                    .state_accessor
-        )? {
+                    .room_state_get(room_id, state_event_type, "")
-            state.push(e.to_stripped_state_event());
+                    .transpose()
-        }
+            })
-        if let Some(e) = services().rooms.state_accessor.room_state_get(
+            .map(|e| e.map(|e| e.to_stripped_state_event()))
-            &invite_event.room_id,
+            .collect::<Result<Vec<_>>>()
-            &StateEventType::RoomJoinRules,
-            "",
-        )? {
-            state.push(e.to_stripped_state_event());
-        }
-        if let Some(e) = services().rooms.state_accessor.room_state_get(
-            &invite_event.room_id,
-            &StateEventType::RoomCanonicalAlias,
-            "",
-        )? {
-            state.push(e.to_stripped_state_event());
-        }
-        if let Some(e) = services().rooms.state_accessor.room_state_get(
-            &invite_event.room_id,
-            &StateEventType::RoomAvatar,
-            "",
-        )? {
-            state.push(e.to_stripped_state_event());
-        }
-        if let Some(e) = services().rooms.state_accessor.room_state_get(
-            &invite_event.room_id,
-            &StateEventType::RoomName,
-            "",
-        )? {
-            state.push(e.to_stripped_state_event());
-        }
-        if let Some(e) = services().rooms.state_accessor.room_state_get(
-            &invite_event.room_id,
-            &StateEventType::RoomMember,
-            invite_event.sender.as_str(),
-        )? {
-            state.push(e.to_stripped_state_event());
-        }
-
-        state.push(invite_event.to_stripped_state_event());
-        Ok(state)
     }
 
     /// Set the state hash to a new version, but does not update state_cache.

src/service/rooms/state_accessor/mod.rs

@@ -426,8 +426,8 @@ impl Service {
             })
     }
 
-    /// Returns the join rule for a given room
+    /// Returns the space-room join rule for a given room
-    pub fn get_join_rule(
+    pub fn get_space_room_join_rule(
         &self,
         current_room: &RoomId,
     ) -> Result<(SpaceRoomJoinRule, Vec<OwnedRoomId>), Error> {
@@ -450,6 +450,26 @@ impl Service {
             .unwrap_or((SpaceRoomJoinRule::Invite, vec![])))
     }
 
+    /// Returns the join rules event content of a room, if there are any and we are aware of it locally
+    #[tracing::instrument(skip(self))]
+    pub fn get_join_rules(
+        &self,
+        room_id: &RoomId,
+    ) -> Result<Option<RoomJoinRulesEventContent>, Error> {
+        let join_rules_event = self.room_state_get(room_id, &StateEventType::RoomJoinRules, "")?;
+
+        join_rules_event
+            .as_ref()
+            .map(|join_rules_event| {
+                serde_json::from_str::<RoomJoinRulesEventContent>(join_rules_event.content.get())
+                    .map_err(|e| {
+                        warn!("Invalid join rules event: {}", e);
+                        Error::bad_database("Invalid join rules event in db.")
+                    })
+            })
+            .transpose()
+    }
+
     /// Returns an empty vec if not a restricted room
     pub fn allowed_room_ids(&self, join_rule: JoinRule) -> Vec<OwnedRoomId> {
         let mut room_ids = vec![];

src/service/rooms/state_cache/data.rs

@@ -16,6 +16,12 @@ pub trait Data: Send + Sync {
         room_id: &RoomId,
         last_state: Option<Vec<Raw<AnyStrippedStateEvent>>>,
     ) -> Result<()>;
+    fn mark_as_knocked(
+        &self,
+        user_id: &UserId,
+        room_id: &RoomId,
+        last_state: Option<Vec<Raw<AnyStrippedStateEvent>>>,
+    ) -> Result<()>;
     fn mark_as_left(&self, user_id: &UserId, room_id: &RoomId) -> Result<()>;
 
     fn update_joined_count(&self, room_id: &RoomId) -> Result<()>;
@@ -65,6 +71,8 @@ pub trait Data: Send + Sync {
 
     fn get_invite_count(&self, room_id: &RoomId, user_id: &UserId) -> Result<Option<u64>>;
 
+    fn get_knock_count(&self, room_id: &RoomId, user_id: &UserId) -> Result<Option<u64>>;
+
     fn get_left_count(&self, room_id: &RoomId, user_id: &UserId) -> Result<Option<u64>>;
 
     /// Returns an iterator over all rooms this user joined.
@@ -80,12 +88,25 @@ pub trait Data: Send + Sync {
         user_id: &UserId,
     ) -> Box<dyn Iterator<Item = Result<(OwnedRoomId, Vec<Raw<AnyStrippedStateEvent>>)>> + 'a>;
 
+    /// Returns an iterator over all rooms a user has knocked on.
+    #[allow(clippy::type_complexity)]
+    fn rooms_knocked<'a>(
+        &'a self,
+        user_id: &UserId,
+    ) -> Box<dyn Iterator<Item = Result<(OwnedRoomId, Vec<Raw<AnyStrippedStateEvent>>)>> + 'a>;
+
     fn invite_state(
         &self,
         user_id: &UserId,
         room_id: &RoomId,
     ) -> Result<Option<Vec<Raw<AnyStrippedStateEvent>>>>;
 
+    fn knock_state(
+        &self,
+        user_id: &UserId,
+        room_id: &RoomId,
+    ) -> Result<Option<Vec<Raw<AnyStrippedStateEvent>>>>;
+
     fn left_state(
         &self,
         user_id: &UserId,
@@ -105,5 +126,7 @@ pub trait Data: Send + Sync {
 
     fn is_invited(&self, user_id: &UserId, room_id: &RoomId) -> Result<bool>;
 
+    fn is_knocked(&self, user_id: &UserId, room_id: &RoomId) -> Result<bool>;
+
     fn is_left(&self, user_id: &UserId, room_id: &RoomId) -> Result<bool>;
 }

src/service/rooms/state_cache/mod.rs

@@ -12,7 +12,7 @@ use ruma::{
         RoomAccountDataEventType, StateEventType,
     },
     serde::Raw,
-    OwnedRoomId, OwnedServerName, OwnedUserId, RoomId, ServerName, UserId,
+    OwnedRoomId, OwnedRoomOrAliasId, OwnedServerName, OwnedUserId, RoomId, ServerName, UserId,
 };
 use tracing::warn;
 
@@ -40,6 +40,13 @@ impl Service {
             // TODO: displayname, avatar url
         }
 
+        // We don't need to store stripped state on behalf of remote users, since these events are only used on `/sync`
+        let last_state = if user_id.server_name() == services().globals.server_name() {
+            last_state
+        } else {
+            None
+        };
+
         match &membership {
             MembershipState::Join => {
                 // Check if the user never joined this room
@@ -178,6 +185,9 @@ impl Service {
 
                 self.db.mark_as_invited(user_id, room_id, last_state)?;
             }
+            MembershipState::Knock => {
+                self.db.mark_as_knocked(user_id, room_id, last_state)?;
+            }
             MembershipState::Leave | MembershipState::Ban => {
                 self.db.mark_as_left(user_id, room_id)?;
             }
@@ -283,6 +293,11 @@ impl Service {
         self.db.get_invite_count(room_id, user_id)
     }
 
+    #[tracing::instrument(skip(self))]
+    pub fn get_knock_count(&self, room_id: &RoomId, user_id: &UserId) -> Result<Option<u64>> {
+        self.db.get_knock_count(room_id, user_id)
+    }
+
     #[tracing::instrument(skip(self))]
     pub fn get_left_count(&self, room_id: &RoomId, user_id: &UserId) -> Result<Option<u64>> {
         self.db.get_left_count(room_id, user_id)
@@ -306,6 +321,15 @@ impl Service {
         self.db.rooms_invited(user_id)
     }
 
+    /// Returns an iterator over all rooms a user has knocked on.
+    #[tracing::instrument(skip(self))]
+    pub fn rooms_knocked<'a>(
+        &'a self,
+        user_id: &UserId,
+    ) -> impl Iterator<Item = Result<(OwnedRoomId, Vec<Raw<AnyStrippedStateEvent>>)>> + 'a {
+        self.db.rooms_knocked(user_id)
+    }
+
     #[tracing::instrument(skip(self))]
     pub fn invite_state(
         &self,
@@ -315,6 +339,15 @@ impl Service {
         self.db.invite_state(user_id, room_id)
     }
 
+    #[tracing::instrument(skip(self))]
+    pub fn knock_state(
+        &self,
+        user_id: &UserId,
+        room_id: &RoomId,
+    ) -> Result<Option<Vec<Raw<AnyStrippedStateEvent>>>> {
+        self.db.knock_state(user_id, room_id)
+    }
+
     #[tracing::instrument(skip(self))]
     pub fn left_state(
         &self,
@@ -348,8 +381,60 @@ impl Service {
         self.db.is_invited(user_id, room_id)
     }
 
+    #[tracing::instrument(skip(self))]
+    pub fn is_knocked(&self, user_id: &UserId, room_id: &RoomId) -> Result<bool> {
+        self.db.is_knocked(user_id, room_id)
+    }
+
     #[tracing::instrument(skip(self))]
     pub fn is_left(&self, user_id: &UserId, room_id: &RoomId) -> Result<bool> {
         self.db.is_left(user_id, room_id)
     }
+
+    /// Function to assist performing a membership event that may require help from a remote server
+    ///
+    /// If a room id is provided, the servers returned will consist of:
+    /// - the `via` argument, provided by the client
+    /// - servers of the senders of the stripped state events we are given
+    /// - the server in the room id
+    ///
+    /// Otherwise, the servers returned will come from the response when resolving the alias.
+    #[tracing::instrument(skip(self))]
+    pub async fn get_room_id_and_via_servers(
+        &self,
+        sender_user: &UserId,
+        room_id_or_alias: OwnedRoomOrAliasId,
+        via: Vec<OwnedServerName>,
+    ) -> Result<(Vec<OwnedServerName>, OwnedRoomId), Error> {
+        let (servers, room_id) = match OwnedRoomId::try_from(room_id_or_alias) {
+            Ok(room_id) => {
+                let mut servers = via;
+                servers.extend(
+                    self.invite_state(sender_user, &room_id)
+                        .transpose()
+                        .or_else(|| self.knock_state(sender_user, &room_id).transpose())
+                        .transpose()?
+                        .unwrap_or_default()
+                        .iter()
+                        .filter_map(|event| event.deserialize().ok())
+                        .map(|event| event.sender().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 = services().rooms.alias.get_alias_helper(room_alias).await?;
+
+                (response.servers, response.room_id)
+            }
+        };
+        Ok((servers, room_id))
+    }
 }

src/service/rooms/timeline/mod.rs

@@ -450,22 +450,29 @@ impl Service {
                     let content = serde_json::from_str::<ExtractMembership>(pdu.content.get())
                         .map_err(|_| Error::bad_database("Invalid content in pdu."))?;
 
-                    let invite_state = match content.membership {
+                    let stripped_state = match content.membership {
-                        MembershipState::Invite => {
+                        MembershipState::Invite | MembershipState::Knock => {
-                            let state = services().rooms.state.calculate_invite_state(pdu)?;
+                            let mut state = services().rooms.state.stripped_state(&pdu.room_id)?;
+                            // So that clients can get info about who invitied them (not relevant for knocking), the reason, when, etc.
+                            state.push(pdu.to_stripped_state_event());
                             Some(state)
                         }
                         _ => None,
                     };
 
-                    // Update our membership info, we do this here incase a user is invited
+                    // Here we don't attempt to join if the previous membership was knock and the
-                    // and immediately leaves we need the DB to record the invite event for auth
+                    // new one is join, like we do for `/federation/*/invite`, as not only are there
+                    // implementation difficulties due to callers not implementing `Send`, but
+                    // invites we recieve which aren't over `/invite` must have been due to a
+                    // database reset or switching server implementations, which means we probably
+                    // shouldn't be joining automatically anyways, since it may surprise users to
+                    // suddenly join rooms which clients didn't even show as being knocked on before.
                     services().rooms.state_cache.update_membership(
                         &pdu.room_id,
                         &target_user_id,
                         content.membership,
                         &pdu.sender,
-                        invite_state,
+                        stripped_state,
                         true,
                     )?;
                 }