Merge branch 'fixrestrictedjoin' into 'next'

fix: rejoining restricted rooms over federation

See merge request famedly/conduit!431

src/service/pdu.rs

@@ -1,4 +1,4 @@
-use crate::{services, Error};
+use crate::Error;
 use ruma::{
     events::{
         room::member::RoomMemberEventContent, AnyEphemeralRoomEvent, AnyStateEvent,
@@ -7,7 +7,7 @@ use ruma::{
     },
     serde::Raw,
     state_res, CanonicalJsonObject, CanonicalJsonValue, EventId, MilliSecondsSinceUnixEpoch,
-    OwnedEventId, OwnedRoomId, OwnedUserId, RoomId, UInt, UserId,
+    OwnedEventId, OwnedRoomId, OwnedUserId, RoomId, RoomVersionId, UInt, UserId,
 };
 use serde::{Deserialize, Serialize};
 use serde_json::{
@@ -334,23 +334,17 @@ impl Ord for PduEvent {
 /// Returns a tuple of the new `EventId` and the PDU as a `BTreeMap<String, CanonicalJsonValue>`.
 pub(crate) fn gen_event_id_canonical_json(
     pdu: &RawJsonValue,
+    room_version_id: &RoomVersionId,
 ) -> crate::Result<(OwnedEventId, CanonicalJsonObject)> {
     let value: CanonicalJsonObject = serde_json::from_str(pdu.get()).map_err(|e| {
         warn!("Error parsing incoming event {:?}: {:?}", pdu, e);
         Error::BadServerResponse("Invalid PDU in server response")
     })?;
 
-    let room_id = value
-        .get("room_id")
-        .and_then(|id| RoomId::parse(id.as_str()?).ok())
-        .ok_or_else(|| Error::bad_database("PDU in db has invalid room_id."))?;
-
-    let room_version_id = services().rooms.state.get_room_version(&room_id);
-
     let event_id = format!(
         "${}",
         // Anything higher than version3 behaves the same
-        ruma::signatures::reference_hash(&value, &room_version_id?)
+        ruma::signatures::reference_hash(&value, room_version_id)
             .expect("ruma can calculate reference hashes")
     )
     .try_into()

src/service/rooms/event_handler/mod.rs

@@ -76,6 +76,7 @@ impl Service {
         is_timeline_event: bool,
         pub_key_map: &'a RwLock<BTreeMap<String, BTreeMap<String, Base64>>>,
     ) -> Result<Option<Vec<u8>>> {
+        // 0. Check the server is in the room
         if !services().rooms.metadata.exists(room_id)? {
             return Err(Error::BadRequest(
                 ErrorKind::NotFound,
@@ -101,6 +102,13 @@ impl Service {
             .room_state_get(room_id, &StateEventType::RoomCreate, "")?
             .ok_or_else(|| Error::bad_database("Failed to find create event in db."))?;
 
+        let create_event_content: RoomCreateEventContent =
+            serde_json::from_str(create_event.content.get()).map_err(|e| {
+                error!("Invalid create event: {}", e);
+                Error::BadDatabase("Invalid create event in db")
+            })?;
+        let room_version_id = &create_event_content.room_version;
+
         let first_pdu_in_room = services()
             .rooms
             .timeline
@@ -127,6 +135,7 @@ impl Service {
                 origin,
                 &create_event,
                 room_id,
+                room_version_id,
                 pub_key_map,
                 incoming_pdu.prev_events.clone(),
             )
@@ -341,6 +350,7 @@ impl Service {
                     .collect::<Vec<_>>(),
                 create_event,
                 room_id,
+                room_version_id,
                 pub_key_map,
             )
             .await;
@@ -645,6 +655,7 @@ impl Service {
                                 .collect::<Vec<_>>(),
                             create_event,
                             room_id,
+                            room_version_id,
                             pub_key_map,
                         )
                         .await;
@@ -1025,6 +1036,7 @@ impl Service {
         events: &'a [Arc<EventId>],
         create_event: &'a PduEvent,
         room_id: &'a RoomId,
+        room_version_id: &'a RoomVersionId,
         pub_key_map: &'a RwLock<BTreeMap<String, BTreeMap<String, Base64>>>,
     ) -> AsyncRecursiveType<'a, Vec<(Arc<PduEvent>, Option<BTreeMap<String, CanonicalJsonValue>>)>>
     {
@@ -1107,7 +1119,7 @@ impl Service {
                         Ok(res) => {
                             info!("Got {} over federation", next_id);
                             let (calculated_event_id, value) =
-                                match pdu::gen_event_id_canonical_json(&res.pdu) {
+                                match pdu::gen_event_id_canonical_json(&res.pdu, room_version_id) {
                                     Ok(t) => t,
                                     Err(_) => {
                                         back_off((*next_id).to_owned());
@@ -1180,6 +1192,7 @@ impl Service {
         origin: &ServerName,
         create_event: &PduEvent,
         room_id: &RoomId,
+        room_version_id: &RoomVersionId,
         pub_key_map: &RwLock<BTreeMap<String, BTreeMap<String, Base64>>>,
         initial_set: Vec<Arc<EventId>>,
     ) -> Result<(
@@ -1205,6 +1218,7 @@ impl Service {
                     &[prev_event_id.clone()],
                     create_event,
                     room_id,
+                    room_version_id,
                     pub_key_map,
                 )
                 .await