Missing stores

Anderas · Anderas · commit f565a3a98c98 · 2023-03-07T11:47:33.000Z
diff --git a/bindings/matrix-sdk-crypto-ffi/src/lib.rs b/bindings/matrix-sdk-crypto-ffi/src/lib.rs
@@ -701,7 +701,7 @@ mod test {
     use tempfile::tempdir;
 
     use super::MigrationData;
-    use crate::{migrate, OlmMachine, RoomSettings, EventEncryptionAlgorithm};
+    use crate::{migrate, EventEncryptionAlgorithm, OlmMachine, RoomSettings};
 
     #[test]
     fn android_migration() -> Result<()> {
@@ -824,13 +824,25 @@ mod test {
         assert!(backup_keys.is_some());
 
         let settings1 = machine.get_room_settings("!AZkqtjvtwPAuyNOXEt:matrix.org")?;
-        assert_eq!(Some(RoomSettings { algorithm: EventEncryptionAlgorithm::OlmV1Curve25519AesSha2, only_allow_trusted_devices: true }), settings1);
+        assert_eq!(
+            Some(RoomSettings {
+                algorithm: EventEncryptionAlgorithm::OlmV1Curve25519AesSha2,
+                only_allow_trusted_devices: true
+            }),
+            settings1
+        );
 
         let settings2 = machine.get_room_settings("!CWLUCoEWXSFyTCOtfL:matrix.org")?;
-        assert_eq!(Some(RoomSettings { algorithm: EventEncryptionAlgorithm::MegolmV1AesSha2, only_allow_trusted_devices: false }), settings2);
+        assert_eq!(
+            Some(RoomSettings {
+                algorithm: EventEncryptionAlgorithm::MegolmV1AesSha2,
+                only_allow_trusted_devices: false
+            }),
+            settings2
+        );
 
         let settings3 = machine.get_room_settings("!XYZ:matrix.org")?;
-        assert!(settings3.is_none());        
+        assert!(settings3.is_none());
 
         Ok(())
     }
diff --git a/crates/matrix-sdk-indexeddb/src/crypto_store.rs b/crates/matrix-sdk-indexeddb/src/crypto_store.rs
@@ -36,7 +36,6 @@ use matrix_sdk_crypto::{
 use matrix_sdk_store_encryption::StoreCipher;
 use ruma::{DeviceId, OwnedDeviceId, RoomId, TransactionId, UserId};
 use serde::{de::DeserializeOwned, Serialize};
-use tracing::warn;
 use wasm_bindgen::JsValue;
 use web_sys::IdbKeyRange;
 
@@ -63,6 +62,8 @@ mod KEYS {
     pub const SECRET_REQUESTS_BY_INFO: &str = "secret_requests_by_info";
     pub const KEY_REQUEST: &str = "key_request";
 
+    pub const ROOM_SETTINGS: &str = "room_settings";
+
     // KEYS
     pub const STORE_CIPHER: &str = "store_cipher";
     pub const ACCOUNT: &str = "account";
@@ -168,6 +169,8 @@ impl IndexeddbCryptoStore {
                 db.create_object_store(KEYS::SECRET_REQUESTS_BY_INFO)?;
 
                 db.create_object_store(KEYS::BACKUP_KEYS)?;
+
+                db.create_object_store(KEYS::ROOM_SETTINGS)?;
             } else if old_version < 1.1 {
                 // We changed how we store inbound group sessions, the key used to
                 // be a trippled of `(room_id, sender_key, session_id)` now it's a
@@ -369,6 +372,7 @@ impl_crypto_store! {
             (!changes.inbound_group_sessions.is_empty(), KEYS::INBOUND_GROUP_SESSIONS),
             (!changes.outbound_group_sessions.is_empty(), KEYS::OUTBOUND_GROUP_SESSIONS),
             (!changes.message_hashes.is_empty(), KEYS::OLM_HASHES),
+            (!changes.room_settings.is_empty(), KEYS::ROOM_SETTINGS),
         ]
         .iter()
         .filter_map(|(id, key)| if *id { Some(*key) } else { None })
@@ -477,6 +481,7 @@ impl_crypto_store! {
         let identity_changes = changes.identities;
         let olm_hashes = changes.message_hashes;
         let key_requests = changes.key_requests;
+        let room_settings_changes = changes.room_settings;
 
         if !device_changes.new.is_empty() || !device_changes.changed.is_empty() {
             let device_store = tx.object_store(KEYS::DEVICES)?;
@@ -541,6 +546,16 @@ impl_crypto_store! {
             }
         }
 
+        if !room_settings_changes.is_empty() {
+            let settings_store = tx.object_store(KEYS::ROOM_SETTINGS)?;
+
+            for (room_id, settings) in &room_settings_changes {
+                let key = self.encode_key(KEYS::ROOM_SETTINGS, room_id);
+                let value = self.serialize_value(&settings)?;
+                settings_store.put_key_val(&key, &value)?;
+            }
+        }
+
         tx.await.into_result()?;
 
         // all good, let's update our caches:indexeddb
@@ -954,18 +969,35 @@ impl_crypto_store! {
         Ok(key)
     }
 
-    async fn get_room_settings(&self, _room_id: &RoomId) -> Result<Option<RoomSettings>> {
-        warn!("Method not implemented");
-        Ok(None)
+    async fn get_room_settings(&self, room_id: &RoomId) -> Result<Option<RoomSettings>> {
+        let key = self.encode_key(KEYS::ROOM_SETTINGS, room_id);
+        Ok(self
+            .inner
+            .transaction_on_one_with_mode(KEYS::ROOM_SETTINGS, IdbTransactionMode::Readonly)?
+            .object_store(KEYS::ROOM_SETTINGS)?
+            .get(&key)?
+            .await?
+            .map(|v| self.deserialize_value(v))
+            .transpose()?)
     }
 
-    async fn get_custom_value(&self, _key: &str) -> Result<Option<Vec<u8>>> {
-        warn!("Method not implemented");
-        Ok(None)
+    async fn get_custom_value(&self, key: &str) -> Result<Option<Vec<u8>>> {
+        Ok(self
+            .inner
+            .transaction_on_one_with_mode(KEYS::CORE, IdbTransactionMode::Readonly)?
+            .object_store(KEYS::CORE)?
+            .get(&JsValue::from_str(key))?
+            .await?
+            .map(|v| self.deserialize_value(v))
+            .transpose()?)
     }
 
-    async fn set_custom_value(&self, _key: &str, _value: Vec<u8>) -> Result<()> {
-        warn!("Method not implemented");
+    async fn set_custom_value(&self, key: &str, value: Vec<u8>) -> Result<()> {
+        self
+            .inner
+            .transaction_on_one_with_mode(KEYS::CORE, IdbTransactionMode::Readwrite)?
+            .object_store(KEYS::CORE)?
+            .put_key_val(&JsValue::from_str(key), &self.serialize_value(&value)?)?;
         Ok(())
     }
 }
diff --git a/crates/matrix-sdk-sled/src/crypto_store.rs b/crates/matrix-sdk-sled/src/crypto_store.rs
@@ -41,12 +41,12 @@ use sled::{
     transaction::{ConflictableTransactionError, TransactionError},
     Batch, Config, Db, IVec, Transactional, Tree,
 };
-use tracing::{debug, warn};
+use tracing::debug;
 
 use super::OpenStoreError;
 use crate::encode_key::{EncodeKey, ENCODE_SEPARATOR};
 
-const DATABASE_VERSION: u8 = 6;
+const DATABASE_VERSION: u8 = 7;
 
 // Table names that are used to derive a separate key for each tree. This ensure
 // that user ids encoded for different trees won't end up as the same byte
@@ -58,6 +58,7 @@ const INBOUND_GROUP_TABLE_NAME: &str = "crypto-store-inbound-group-sessions";
 const OUTBOUND_GROUP_TABLE_NAME: &str = "crypto-store-outbound-group-sessions";
 const SECRET_REQUEST_BY_INFO_TABLE: &str = "crypto-store-secret-request-by-info";
 const TRACKED_USERS_TABLE: &str = "crypto-store-secret-tracked-users";
+const ROOM_SETTINGS_TABLE: &str = "crypto-store-secret-room-settings";
 
 impl EncodeKey for InboundGroupSession {
     fn encode(&self) -> Vec<u8> {
@@ -185,6 +186,8 @@ pub struct SledCryptoStore {
     identities: Tree,
 
     tracked_users: Tree,
+
+    room_settings: Tree,
 }
 
 impl std::fmt::Debug for SledCryptoStore {
@@ -386,6 +389,8 @@ impl SledCryptoStore {
         let unsent_secret_requests = db.open_tree("unsent_secret_requests")?;
         let secret_requests_by_info = db.open_tree("secret_requests_by_info")?;
 
+        let room_settings = db.open_tree("room_settings")?;
+
         let session_cache = SessionStore::new();
 
         let database = Self {
@@ -406,6 +411,7 @@ impl SledCryptoStore {
             tracked_users,
             olm_hashes,
             identities,
+            room_settings,
         };
 
         database.upgrade().await?;
@@ -499,6 +505,7 @@ impl SledCryptoStore {
         let olm_hashes = changes.message_hashes;
         let key_requests = changes.key_requests;
         let backup_version = changes.backup_version;
+        let room_settings_changes = changes.room_settings;
 
         let ret: Result<(), TransactionError<CryptoStoreError>> = (
             &self.account,
@@ -512,6 +519,7 @@ impl SledCryptoStore {
             &self.outgoing_secret_requests,
             &self.unsent_secret_requests,
             &self.secret_requests_by_info,
+            &self.room_settings,
         )
             .transaction(
                 |(
@@ -526,6 +534,7 @@ impl SledCryptoStore {
                     outgoing_secret_requests,
                     unsent_secret_requests,
                     secret_requests_by_info,
+                    room_settings,
                 )| {
                     if let Some(a) = &account_pickle {
                         account.insert(
@@ -635,6 +644,15 @@ impl SledCryptoStore {
                         }
                     }
 
+                    for (room_id, settings) in &room_settings_changes {
+                        let key = self.encode_key(ROOM_SETTINGS_TABLE, room_id);
+                        room_settings.insert(
+                            key.as_slice(),
+                            self.serialize_value(&settings)
+                                .map_err(ConflictableTransactionError::Abort)?,
+                        )?;
+                    }
+
                     Ok(())
                 },
             );
@@ -1011,18 +1029,22 @@ impl CryptoStore for SledCryptoStore {
         Ok(key)
     }
 
-    async fn get_room_settings(&self, _room_id: &RoomId) -> Result<Option<RoomSettings>> {
-        warn!("Method not implemented");
-        Ok(None)
+    async fn get_room_settings(&self, room_id: &RoomId) -> Result<Option<RoomSettings>> {
+        let key = self.encode_key(ROOM_SETTINGS_TABLE, room_id);
+        self.room_settings
+            .get(key)
+            .map_err(CryptoStoreError::backend)?
+            .map(|p| self.deserialize_value(&p))
+            .transpose()
     }
 
-    async fn get_custom_value(&self, _key: &str) -> Result<Option<Vec<u8>>> {
-        warn!("Method not implemented");
-        Ok(None)
+    async fn get_custom_value(&self, key: &str) -> Result<Option<Vec<u8>>> {
+        let value = self.inner.get(key).map_err(CryptoStoreError::backend)?.map(|v| v.to_vec());
+        Ok(value)
     }
 
-    async fn set_custom_value(&self, _key: &str, _value: Vec<u8>) -> Result<()> {
-        warn!("Method not implemented");
+    async fn set_custom_value(&self, key: &str, value: Vec<u8>) -> Result<()> {
+        self.inner.insert(key, value).map_err(CryptoStoreError::backend)?;
         Ok(())
     }
 }
