Merge commit '7c7cd9cc8084f0e425b1919b84d5e79ed150d16b~' into HEAD

Merge `stable` up to the mentioned commit.

deltachat-rpc-client/src/deltachat_rpc_client/rpc.py

@@ -89,16 +89,14 @@ class Rpc:
         return await queue.get()
 
     def __getattr__(self, attr: str):
-        async def method(*args, **kwargs) -> Any:
+        async def method(*args) -> Any:
             self.id += 1
             request_id = self.id
 
-            assert not (args and kwargs), "Mixing positional and keyword arguments"
-
             request = {
                 "jsonrpc": "2.0",
                 "method": attr,
-                "params": kwargs or args,
+                "params": args,
                 "id": self.id,
             }
             data = (json.dumps(request) + "\n").encode()

src/decrypt.rs

@@ -28,14 +28,30 @@ pub fn try_decrypt(
     private_keyring: &[SignedSecretKey],
     public_keyring_for_validate: &[SignedPublicKey],
 ) -> Result<Option<(Vec<u8>, HashSet<Fingerprint>)>> {
-    let encrypted_data_part = match get_autocrypt_mime(mail)
-        .or_else(|| get_mixed_up_mime(mail))
-        .or_else(|| get_attachment_mime(mail))
-    {
+    let encrypted_data_part = match {
+        let mime = get_autocrypt_mime(mail);
+        if mime.is_some() {
+            info!(context, "Detected Autocrypt-mime message.");
+        }
+        mime
+    }
+    .or_else(|| {
+        let mime = get_mixed_up_mime(mail);
+        if mime.is_some() {
+            info!(context, "Detected mixed-up mime message.");
+        }
+        mime
+    })
+    .or_else(|| {
+        let mime = get_attachment_mime(mail);
+        if mime.is_some() {
+            info!(context, "Detected attached Autocrypt-mime message.");
+        }
+        mime
+    }) {
         None => return Ok(None),
         Some(res) => res,
     };
-    info!(context, "Detected Autocrypt-mime message");
 
     decrypt_part(
         encrypted_data_part,
@@ -402,4 +418,18 @@ mod tests {
 
         Ok(())
     }
+
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test_mixed_up_mime_long() -> Result<()> {
+        // Long "mixed-up" mail as received when sending an encrypted message using Delta Chat
+        // Desktop via MS Exchange (actually made with TB though).
+        let mixed_up_mime = include_bytes!("../test-data/message/mixed-up-long.eml");
+        let bob = TestContext::new_bob().await;
+        receive_imf(&bob, mixed_up_mime, false).await?;
+        let msg = bob.get_last_msg().await;
+        assert!(!msg.get_text().is_empty());
+        assert!(msg.has_html());
+        assert!(msg.id.get_html(&bob).await?.unwrap().len() > 40000);
+        Ok(())
+    }
 }

src/mimeparser.rs

@@ -12,7 +12,6 @@ use deltachat_derive::{FromSql, ToSql};
 use format_flowed::unformat_flowed;
 use lettre_email::mime::{self, Mime};
 use mailparse::{addrparse_header, DispositionType, MailHeader, MailHeaderMap, SingleInfo};
-use once_cell::sync::Lazy;
 
 use crate::aheader::{Aheader, EncryptPreference};
 use crate::blob::BlobObject;
@@ -1617,25 +1616,21 @@ impl MimeMessage {
             false
         };
         if maybe_ndn && self.delivery_report.is_none() {
-            static RE: Lazy<regex::Regex> =
-                Lazy::new(|| regex::Regex::new(r"Message-ID:(.*)").unwrap());
-            for captures in self
+            for original_message_id in self
                 .parts
                 .iter()
                 .filter_map(|part| part.msg_raw.as_ref())
                 .flat_map(|part| part.lines())
-                .filter_map(|line| RE.captures(line))
+                .filter_map(|line| line.split_once("Message-ID:"))
+                .filter_map(|(_, message_id)| parse_message_id(message_id).ok())
             {
-                if let Ok(original_message_id) = parse_message_id(&captures[1]) {
-                    if let Ok(Some(_)) =
-                        message::rfc724_mid_exists(context, &original_message_id).await
-                    {
-                        self.delivery_report = Some(DeliveryReport {
-                            rfc724_mid: original_message_id,
-                            failed_recipient: None,
-                            failure: true,
-                        })
-                    }
+                if let Ok(Some(_)) = message::rfc724_mid_exists(context, &original_message_id).await
+                {
+                    self.delivery_report = Some(DeliveryReport {
+                        rfc724_mid: original_message_id,
+                        failed_recipient: None,
+                        failure: true,
+                    })
                 }
             }
         }

src/receive_imf.rs

@@ -1095,7 +1095,7 @@ async fn add_parts(
     let mut save_mime_modified = mime_parser.is_mime_modified;
 
     let mime_headers = if save_mime_headers || save_mime_modified {
-        let headers = if mime_parser.was_encrypted() && !mime_parser.decoded_data.is_empty() {
+        let headers = if !mime_parser.decoded_data.is_empty() {
             mime_parser.decoded_data.clone()
         } else {
             imf_raw.to_vec()
@@ -1702,19 +1702,22 @@ async fn apply_group_changes(
         };
 
     // Whether to allow any changes to the member list at all.
-    let allow_member_list_changes =
-        if chat::is_contact_in_chat(context, chat_id, ContactId::SELF).await? || self_added {
-            // Reject old group changes.
-            chat_id
-                .update_timestamp(context, Param::MemberListTimestamp, sent_timestamp)
-                .await?
-        } else {
-            // Member list changes are not allowed if we're not in the group
-            // and are not explicitly added.
-            // This message comes from a Delta Chat that restored an old backup
-            // or the message is a MUA reply to an old message.
-            false
-        };
+    let allow_member_list_changes = if chat::is_contact_in_chat(context, chat_id, ContactId::SELF)
+        .await?
+        || self_added
+        || !mime_parser.has_chat_version()
+    {
+        // Reject old group changes.
+        chat_id
+            .update_timestamp(context, Param::MemberListTimestamp, sent_timestamp)
+            .await?
+    } else {
+        // Member list changes are not allowed if we're not in the group
+        // and are not explicitly added.
+        // This message comes from a Delta Chat that restored an old backup
+        // or the message is a MUA reply to an old message.
+        false
+    };
 
     // Whether to rebuild the member list from scratch.
     let recreate_member_list = if allow_member_list_changes {

src/receive_imf/tests.rs

@@ -3562,3 +3562,52 @@ async fn test_mua_can_add() -> Result<()> {
     );
     Ok(())
 }
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn test_mua_can_readd() -> Result<()> {
+    let alice = TestContext::new_alice().await;
+
+    // Alice creates chat with 3 contacts.
+    let msg = receive_imf(
+        &alice,
+        b"Subject: =?utf-8?q?Message_from_alice=40example=2Eorg?=\r\n\
+            From: alice@example.org\r\n\
+            To: <bob@example.net>, <claire@example.org>, <fiona@example.org> \r\n\
+            Date: Mon, 12 Dec 2022 14:30:39 +0000\r\n\
+            Message-ID: <Mr.alices_original_mail@example.org>\r\n\
+            Chat-Version: 1.0\r\n\
+            \r\n\
+            Hi!\r\n",
+        false,
+    )
+    .await?
+    .unwrap();
+    let alice_chat = Chat::load_from_db(&alice, msg.chat_id).await?;
+    assert_eq!(alice_chat.typ, Chattype::Group);
+    assert!(is_contact_in_chat(&alice, alice_chat.id, ContactId::SELF).await?);
+
+    // And leaves it.
+    remove_contact_from_chat(&alice, alice_chat.id, ContactId::SELF).await?;
+    let alice_chat = Chat::load_from_db(&alice, alice_chat.id).await?;
+    assert!(!is_contact_in_chat(&alice, alice_chat.id, ContactId::SELF).await?);
+
+    // Bob uses a classical MUA to answer, adding Alice back.
+    receive_imf(
+        &alice,
+        b"Subject: Re: Message from alice\r\n\
+            From: <bob@example.net>\r\n\
+            To: <alice@example.org>, <claire@example.org>, <fiona@example.org>\r\n\
+            Date: Mon, 12 Dec 2022 14:32:39 +0000\r\n\
+            Message-ID: <bobs_answer_to_two_recipients@example.net>\r\n\
+            In-Reply-To: <Mr.alices_original_mail@example.org>\r\n\
+            \r\n\
+            Hi back!\r\n",
+        false,
+    )
+    .await?
+    .unwrap();
+
+    let alice_chat = Chat::load_from_db(&alice, alice_chat.id).await?;
+    assert!(is_contact_in_chat(&alice, alice_chat.id, ContactId::SELF).await?);
+    Ok(())
+}