fix(filamento): caps +notify and use hex representation for avatar metadata id

7 files changed, 48 insertions, 27 deletions

diff --git a/README.md b/README.md
index d8fc445..83488a4 100644
--- a/README.md
+++ b/README.md
@@ -150,6 +150,8 @@
 
 #### to write:
 
+- [ ] some xmpp user avatar metadata nodes published as jpeg???
+- [ ] need to specify user avatar id as hexadecimal
 - [ ] advanced message body (for custom emoji, styling, etc.). can opt in to mixed content in message body. base as bold, italic, underline, strikethrough, then extensible with new tags for e.g. emoji, color, size, font, chat effects.
 - [ ] omemo cross-signing verification or something along those lines, with a main device and linked devices. safety numbers.
 - [ ] better stable ids....?
diff --git a/filamento.db b/filamento.db
new file mode 100644
index 0000000..6e17d1c
--- /dev/null
+++ b/filamento.db
diff --git a/filamento/Cargo.toml b/filamento/Cargo.toml
index 92c8370..d1749f4 100644
--- a/filamento/Cargo.toml
+++ b/filamento/Cargo.toml
@@ -20,6 +20,7 @@ sha3 = "0.10.8"
 base64 = "0.22.1"
 sha1 = "0.10.6"
 image = "0.25.6"
+hex = "0.4.3"
 
 [dev-dependencies]
 tracing-subscriber = "0.3.19"
diff --git a/filamento/examples/example.rs b/filamento/examples/example.rs
index 8ebfde0..d7c03e4 100644
--- a/filamento/examples/example.rs
+++ b/filamento/examples/example.rs
@@ -12,21 +12,30 @@ impl FileStore for Files {
     type Err = Arc<io::Error>;
 
     async fn is_stored(&self, name: &str) -> Result<bool, Self::Err> {
-        Ok(tokio::fs::try_exists(format!("files/{}", name))
+        tracing::debug!("checking if {} is stored", name);
+        let res = tokio::fs::try_exists(format!("files/{}", name))
             .await
-            .map_err(|err| Arc::new(err))?)
+            .map_err(|err| Arc::new(err));
+        tracing::debug!("file check res: {:?}", res);
+        res
     }
 
     async fn store(&self, name: &str, data: &[u8]) -> Result<(), Self::Err> {
-        Ok(tokio::fs::write(format!("files/{}", name), data)
+        tracing::debug!("storing {} is stored", name);
+        let res = tokio::fs::write(format!("files/{}", name), data)
             .await
-            .map_err(|err| Arc::new(err))?)
+            .map_err(|err| Arc::new(err));
+        tracing::debug!("file store res: {:?}", res);
+        res
     }
 
     async fn delete(&self, name: &str) -> Result<(), Self::Err> {
-        Ok(tokio::fs::remove_file(format!("files/{}", name))
+        tracing::debug!("deleting {}", name);
+        let res = tokio::fs::remove_file(format!("files/{}", name))
             .await
-            .map_err(|err| Arc::new(err))?)
+            .map_err(|err| Arc::new(err));
+        tracing::debug!("file delete res: {:?}", res);
+        res
     }
 }
 
@@ -37,7 +46,7 @@ async fn main() {
         .await
         .unwrap();
     let (client, mut recv) = Client::new(
-        "test@blos.sm".try_into().unwrap(),
+        "test@blos.sm/testing2".try_into().unwrap(),
         "slayed".to_string(),
         db,
         Files,
diff --git a/filamento/src/caps.rs b/filamento/src/caps.rs
index b3464d1..819e669 100644
--- a/filamento/src/caps.rs
+++ b/filamento/src/caps.rs
@@ -35,13 +35,13 @@ pub fn client_info() -> Info {
     Info {
         node: None,
         features: vec![
-            "http://jabber.org/protocol/disco#items".to_string(),
-            "http://jabber.org/protocol/disco#info".to_string(),
             "http://jabber.org/protocol/caps".to_string(),
-            "http://jabber.org/protocol/nick".to_string(),
+            "http://jabber.org/protocol/disco#info".to_string(),
+            "http://jabber.org/protocol/disco#items".to_string(),
             "http://jabber.org/protocol/nick+notify".to_string(),
             "urn:xmpp:avatar:metadata+notify".to_string(),
         ],
+        // "http://jabber.org/protocol/nick".to_string(),
         identities: vec![Identity {
             name: Some("filamento 0.1.0".to_string()),
             category: Category::Client(identity::Client::PC),
diff --git a/filamento/src/logic/online.rs b/filamento/src/logic/online.rs
index 745adc1..5b57f84 100644
--- a/filamento/src/logic/online.rs
+++ b/filamento/src/logic/online.rs
@@ -906,7 +906,7 @@ pub async fn handle_change_avatar<Fs: FileStore + Clone>(logic: &ClientLogic<Fs>
             let mut sha1 = Sha1::new();
             sha1.update(&data_png);
             let sha1_result = sha1.finalize();
-            let hash = BASE64_STANDARD.encode(sha1_result);
+            let hash = hex::encode(sha1_result);
 
             // encode the image data as base64
             let data_b64 = BASE64_STANDARD.encode(data_png.clone());
diff --git a/filamento/src/logic/process_stanza.rs b/filamento/src/logic/process_stanza.rs
index c383d70..7142144 100644
--- a/filamento/src/logic/process_stanza.rs
+++ b/filamento/src/logic/process_stanza.rs
@@ -268,14 +268,17 @@ pub async fn recv_message<Fs: FileStore + Clone>(
                             match items.items {
                                 ItemsType::Item(items) => {
                                     if let Some(item) = items.first() {
+                                        debug!("found item");
                                         match &item.item {
                                             Some(Content::AvatarMetadata(metadata)) => {
+                                                debug!("found metadata");
                                                 // check if user avatar has been deleted
                                                 if let Some(metadata) = metadata
                                                     .info
                                                     .iter()
                                                     .find(|info| info.url.is_none())
                                                 {
+                                                    debug!("checking if user avatar has changed");
                                                     // check if user avatar has changed
                                                     match logic
                                                         .db()
@@ -296,8 +299,9 @@ pub async fn recv_message<Fs: FileStore + Clone>(
                                                                             logic.handle_error(MessageRecvError::AvatarUpdate(e).into()).await;
                                                                     }
                                                                 }
+                                                            }
 
-                                                                match logic
+                                                            match logic
                                                                     .file_store()
                                                                     .is_stored(&metadata.id)
                                                                     .await
@@ -311,28 +315,32 @@ pub async fn recv_message<Fs: FileStore + Clone>(
                                                                         let pep_item = logic.client().get_pep_item(Some(from.as_bare()), "urn:xmpp:avatar:data".to_string(), metadata.id.clone()).await.map_err(|err| Into::<AvatarUpdateError<Fs>>::into(err))?;
                                                                         match pep_item {
                                                                             crate::pep::Item::AvatarData(data) => {
-                                                                                let data = data.map(|data| data.data_b64).unwrap_or_default();
+                                                                                let data = data.map(|data| data.data_b64).unwrap_or_default().replace("\n", "");
                                                                                 // TODO: these should all be in a separate avatarupdate function
+                                                                                debug!("got avatar data");
                                                                                 match BASE64_STANDARD.decode(data) {
                                                                                     Ok(data) => {
                                                                                         let mut hasher = Sha1::new();
                                                                                         hasher.update(&data);
-                                                                                        let received_data_hash = BASE64_STANDARD.encode(hasher.finalize());
-                                                                                        if received_data_hash == metadata.id {
+                                                                                        let received_data_hash = hex::encode(hasher.finalize());
+                                                                                        debug!("received_data_hash: {}, metadata_id: {}", received_data_hash, metadata.id);
+                                                                                        if received_data_hash.to_lowercase() == metadata.id.to_lowercase() {
                                                                                             if let Err(e) = logic.file_store().store(&received_data_hash, &data).await {
                                                                                                 logic.handle_error(Error::MessageRecv(MessageRecvError::AvatarUpdate(AvatarUpdateError::FileStore(e)))).await;
                                                                                             }
-                                                                                            logic
-                                                                                            .update_sender()
-                                                                                            .send(
-                                                                                                UpdateMessage::AvatarChanged {
-                                                                                                    jid: from.as_bare(),
-                                                                                                    id: Some(
-                                                                                                        metadata.id.clone(),
-                                                                                                    ),
-                                                                                                },
-                                                                                            )
-                                                                                            .await;
+                                                                                            if changed {
+                                                                                                logic
+                                                                                                .update_sender()
+                                                                                                .send(
+                                                                                                    UpdateMessage::AvatarChanged {
+                                                                                                        jid: from.as_bare(),
+                                                                                                        id: Some(
+                                                                                                            metadata.id.clone(),
+                                                                                                        ),
+                                                                                                    },
+                                                                                                )
+                                                                                                .await;
+                                                                                            }
                                                                                         }
                                                                                     },
                                                                                     Err(e) => {
@@ -347,6 +355,7 @@ pub async fn recv_message<Fs: FileStore + Clone>(
                                                                     }
                                                                     Ok(true) => {
                                                                         // just send the update
+                                                                        if changed {
                                                                         logic
                                                                         .update_sender()
                                                                         .send(
@@ -359,10 +368,10 @@ pub async fn recv_message<Fs: FileStore + Clone>(
                                                                         )
                                                                         .await;
                                                                     }
+                                                                    }
                                                                     Err(e) => {
                                                                         logic.handle_error(Error::MessageRecv(MessageRecvError::AvatarUpdate(e))).await;
                                                                     }
-                                                                }
                                                             }
                                                         }
                                                         Err(e) => {