always handle incoming group-avatars

src/dc_receive_imf.rs

@@ -3,7 +3,6 @@ use sha2::{Digest, Sha256};
 
 use num_traits::FromPrimitive;
 
-use crate::blob::BlobObject;
 use crate::chat::{self, Chat};
 use crate::config::Config;
 use crate::constants::*;
@@ -810,7 +809,6 @@ fn create_or_lookup_group(
     let mut X_MrRemoveFromGrp = None;
     let mut X_MrAddToGrp = None;
     let mut X_MrGrpNameChanged = false;
-    let mut X_MrGrpImageChanged = "".to_string();
     let mut better_msg: String = From::from("");
 
     if mime_parser.is_system_message == SystemMessage::LocationStreamingEnabled {
@@ -877,9 +875,6 @@ fn create_or_lookup_group(
         if let Some(optional_field) = field {
             X_MrAddToGrp = Some(optional_field);
             mime_parser.is_system_message = SystemMessage::MemberAddedToGroup;
-            if let Some(optional_field) = mime_parser.get(HeaderDef::ChatGroupImage).cloned() {
-                X_MrGrpImageChanged = optional_field;
-            }
             better_msg = context.stock_system_msg(
                 StockMessage::MsgAddMember,
                 X_MrAddToGrp.as_ref().unwrap(),
@@ -902,21 +897,23 @@ fn create_or_lookup_group(
                 );
 
                 mime_parser.is_system_message = SystemMessage::GroupNameChanged;
-            } else if let Some(optional_field) = mime_parser.get(HeaderDef::ChatGroupImage).cloned()
+            } else if let Some(value) = mime_parser.get(HeaderDef::ChatContent).cloned() {
-            {
+                if value == "group-avatar-changed" && mime_parser.group_avatar != ImageAction::None
-                // fld_value is a pointer somewhere into mime_parser, must not be freed
+                {
-                X_MrGrpImageChanged = optional_field;
+                    // this is just an explicit message containing the group-avatar,
-                mime_parser.is_system_message = SystemMessage::GroupImageChanged;
+                    // apart from that, the group-avatar is send along with various other messages
-                better_msg = context.stock_system_msg(
+                    mime_parser.is_system_message = SystemMessage::GroupImageChanged;
-                    if X_MrGrpImageChanged == "0" {
+                    better_msg = context.stock_system_msg(
-                        StockMessage::MsgGrpImgDeleted
+                        if mime_parser.group_avatar == ImageAction::Delete {
-                    } else {
+                            StockMessage::MsgGrpImgDeleted
-                        StockMessage::MsgGrpImgChanged
+                        } else {
-                    },
+                            StockMessage::MsgGrpImgChanged
-                    "",
+                        },
-                    "",
+                        "",
-                    from_id as u32,
+                        "",
-                )
+                        from_id as u32,
+                    )
+                }
             }
         }
     }
@@ -1039,44 +1036,22 @@ fn create_or_lookup_group(
             }
         }
     }
-    if !X_MrGrpImageChanged.is_empty() {
+    if mime_parser.group_avatar != ImageAction::None {
-        info!(
+        info!(context, "group-avatar change for {}", chat_id);
-            context,
+        if let Ok(mut chat) = Chat::load_from_db(context, chat_id) {
-            "grp-image-change {} chat {}", X_MrGrpImageChanged, chat_id
+            match &mime_parser.group_avatar {
-        );
+                ImageAction::Change(profile_image) => {
-        let mut changed = false;
+                    chat.param.set(Param::ProfileImage, profile_image);
-        let mut grpimage: Option<BlobObject> = None;
+                    true
-        if X_MrGrpImageChanged == "0" {
-            changed = true;
-        } else {
-            for part in &mut mime_parser.parts {
-                if part.typ == Viewtype::Image {
-                    grpimage = part
-                        .param
-                        .get_blob(Param::File, context, true)
-                        .unwrap_or(None);
-                    info!(context, "found image {:?}", grpimage);
-                    changed = true;
                 }
-            }
+                ImageAction::Delete => {
-        }
+                    chat.param.remove(Param::ProfileImage);
-        if changed {
+                    true
-            info!(
+                }
-                context,
+                ImageAction::None => false,
-                "New group image set to '{}'.",
+            };
-                grpimage
+            chat.update_param(context)?;
-                    .as_ref()
+            send_EVENT_CHAT_MODIFIED = true;
-                    .map(|blob| blob.as_name().to_string())
-                    .unwrap_or_default()
-            );
-            if let Ok(mut chat) = Chat::load_from_db(context, chat_id) {
-                match grpimage {
-                    Some(blob) => chat.param.set(Param::ProfileImage, blob.as_name()),
-                    None => chat.param.remove(Param::ProfileImage),
-                };
-                chat.update_param(context)?;
-                send_EVENT_CHAT_MODIFIED = true;
-            }
         }
     }
 

src/headerdef.rs

@@ -19,7 +19,7 @@ pub enum HeaderDef {
     ChatGroupName,
     ChatGroupNameChanged,
     ChatVerified,
-    ChatGroupImage,
+    ChatGroupAvatar,
     ChatProfileImage,
     ChatVoiceMessage,
     ChatGroupMemberRemoved,

src/mimefactory.rs

@@ -687,10 +687,10 @@ impl<'a, 'b> MimeFactory<'a, 'b> {
                     ));
                 }
                 SystemMessage::GroupImageChanged => {
-                    if grpimage.is_none() {
+                    protected_headers.push(Header::new(
-                        protected_headers
+                        "Chat-Content".to_string(),
-                            .push(Header::new("Chat-Group-Image".to_string(), "0".to_string()));
+                        "group-avatar-changed".to_string(),
-                    }
+                    ));
                 }
                 _ => {}
             }
@@ -758,7 +758,7 @@ impl<'a, 'b> MimeFactory<'a, 'b> {
 
             let (mail, filename_as_sent) = build_body_file(context, &meta, "group-image")?;
             meta_part = Some(mail);
-            protected_headers.push(Header::new("Chat-Group-Image".into(), filename_as_sent));
+            protected_headers.push(Header::new("Chat-Group-Avatar".into(), filename_as_sent));
         }
 
         if self.msg.type_0 == Viewtype::Sticker {

src/mimeparser.rs

@@ -38,6 +38,7 @@ pub struct MimeParser<'a> {
     pub location_kml: Option<location::Kml>,
     pub message_kml: Option<location::Kml>,
     pub profile_image: ImageAction,
+    pub group_avatar: ImageAction,
     reports: Vec<Report>,
     mdns_enabled: bool,
     parsed_protected_headers: bool,
@@ -92,6 +93,7 @@ impl<'a> MimeParser<'a> {
             location_kml: None,
             message_kml: None,
             profile_image: ImageAction::None,
+            group_avatar: ImageAction::None,
             mdns_enabled,
             parsed_protected_headers: false,
         };
@@ -191,14 +193,8 @@ impl<'a> MimeParser<'a> {
             }
         }
 
-        if self.get(HeaderDef::ChatGroupImage).is_some() && !self.parts.is_empty() {
+        if let Some(header_value) = self.get(HeaderDef::ChatGroupAvatar).cloned() {
-            let textpart = &self.parts[0];
+            self.group_avatar = self.image_action_from_header(header_value);
-            if textpart.typ == Viewtype::Text && self.parts.len() >= 2 {
-                let imgpart = &mut self.parts[1];
-                if imgpart.typ == Viewtype::Image {
-                    imgpart.is_meta = true;
-                }
-            }
         }
 
         if let Some(header_value) = self.get(HeaderDef::ChatProfileImage).cloned() {
@@ -1174,16 +1170,19 @@ mod tests {
         let raw = include_bytes!("../test-data/message/mail_attach_txt.eml");
         let mimeparser = MimeParser::from_bytes(&t.ctx, &raw[..]).unwrap();
         assert_eq!(mimeparser.profile_image, ImageAction::None);
+        assert_eq!(mimeparser.group_avatar, ImageAction::None);
 
         let raw = include_bytes!("../test-data/message/mail_with_profile_image.eml");
         let mimeparser = MimeParser::from_bytes(&t.ctx, &raw[..]).unwrap();
         assert_eq!(mimeparser.parts.len(), 1);
         assert_ne!(mimeparser.profile_image, ImageAction::None);
         assert_ne!(mimeparser.profile_image, ImageAction::Delete);
+        assert_eq!(mimeparser.group_avatar, ImageAction::None);
 
         let raw = include_bytes!("../test-data/message/mail_with_profile_image_deleted.eml");
         let mimeparser = MimeParser::from_bytes(&t.ctx, &raw[..]).unwrap();
         assert_eq!(mimeparser.parts.len(), 1);
         assert_eq!(mimeparser.profile_image, ImageAction::Delete);
+        assert_eq!(mimeparser.group_avatar, ImageAction::None);
     }
 }