feat(common): Detect cycles when loading last chunk of LinkedChunk.

This patch updates `RelationalLinkedChunk::load_last_chunk` to detect
cycle for the last chunk only.

Author: Hywan

crates/matrix-sdk-common/src/linked_chunk/relational.rs

@@ -15,6 +15,8 @@
 //! Implementation for a _relational linked chunk_, see
 //! [`RelationalLinkedChunk`].
 
+use std::ops::ControlFlow;
+
 use ruma::{OwnedRoomId, RoomId};
 
 use super::{ChunkContent, ChunkIdentifierGenerator, RawChunk};
@@ -345,13 +347,36 @@ where
         };
 
         // Find the last chunk.
-        let Some(chunk_row) = self
-            .chunks
-            .iter()
-            .find(|chunk_row| chunk_row.room_id == room_id && chunk_row.next_chunk.is_none())
-        else {
-            // Chunk is not found.
-            return Ok((None, chunk_identifier_generator));
+        let chunk_row = match self.chunks.iter().try_fold(0, |mut number_of_chunks, chunk_row| {
+            if chunk_row.room_id == room_id {
+                number_of_chunks += 1;
+
+                if chunk_row.next_chunk.is_none() {
+                    return ControlFlow::Break((number_of_chunks, chunk_row));
+                }
+            }
+
+            ControlFlow::Continue(number_of_chunks)
+        }) {
+            // Chunk has been found, all good.
+            ControlFlow::Break((_, chunk_row)) => chunk_row,
+
+            // Chunk is not found and there is zero chunk for this room, this is consistent, all
+            // good.
+            ControlFlow::Continue(0) => {
+                return Ok((None, chunk_identifier_generator));
+            }
+
+            // Chunk is not found **but** there are chunks for this room, this is inconsistent. The
+            // linked chunk is malformed.
+            //
+            // Returning `Ok(None)` would be invalid here: we must return an error.
+            ControlFlow::Continue(_) => {
+                return Err(
+                    "last chunk is not found but chunks exist: the linked chunk contains a cycle"
+                        .to_owned(),
+                );
+            }
         };
 
         // Build the chunk.
@@ -1188,6 +1213,29 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_load_last_chunk_with_a_cycle() {
+        let room_id = room_id!("!r0:matrix.org");
+        let mut relational_linked_chunk = RelationalLinkedChunk::<char, ()>::new();
+
+        relational_linked_chunk.apply_updates(
+            room_id,
+            vec![
+                Update::NewItemsChunk { previous: None, new: CId::new(0), next: None },
+                Update::NewItemsChunk {
+                    // Because `previous` connects to chunk #0, it will create a cycle.
+                    // Chunk #0 will have a `next` set to chunk #1! Consequently, the last chunk
+                    // **does not exist**. We have to detect this cycle.
+                    previous: Some(CId::new(0)),
+                    new: CId::new(1),
+                    next: Some(CId::new(0)),
+                },
+            ],
+        );
+
+        relational_linked_chunk.load_last_chunk(room_id).unwrap_err();
+    }
+
     #[test]
     fn test_load_previous_chunk() {
         let room_id = room_id!("!r0:matrix.org");