feat: send pre-message on messages with large attachments (#7410)

part of #7367

progress / what's to do:
- [x] send pre-message
- [x] The message's state must be set to MessageState::OutDelivered only
after both messages are sent. If a read receipt is received, the message
can be OutMdnRcvd or OutPending; let's just do whatever is easiest for
now. Take care not to revert from OutMdnReceived to OutDelivered if we
first receive a read receipt and then deliver the full message.
   - this is already the case:
- `OutDelivered` is set when a message is sent out and has no remaining
send jobs in the smtp table for this message id - so already works since
full message and pre message have same msgId in that table.
- `OutMdnRcvd` is a "virtual" state
(#7367 (comment)),
so going back to `OutDelivered` can't happen anymore
- [x] delimit `ChatFullMessageId` with `<` and `>` like the other
message ids
- [x] add tests
	- [x] test that pre message is sent for attachment larger than X
		- test that correct headers are present on both messages
- also test that Autocrypt-gossip and selfavatar should never go into
full-messages
	- [x] test that no pre message is sent for attachment smaller than X
		- no "is full message" header should be present
- [x] test that pre message is not send for large webxdc update or large
text
- [x] fix test
`receive_imf::receive_imf_tests::test_dont_reverify_by_self_on_outgoing_msg`

---------

Co-authored-by: iequidoo <[email protected]>
Co-authored-by: Hocuri <[email protected]>

Author: 3 people

src/chat.rs

@@ -27,15 +27,17 @@ use crate::constants::{
 use crate::contact::{self, Contact, ContactId, Origin};
 use crate::context::Context;
 use crate::debug_logging::maybe_set_logging_xdc;
-use crate::download::DownloadState;
+use crate::download::{
+    DownloadState, PRE_MSG_ATTACHMENT_SIZE_THRESHOLD, PRE_MSG_SIZE_WARNING_THRESHOLD,
+};
 use crate::ephemeral::{Timer as EphemeralTimer, start_chat_ephemeral_timers};
 use crate::events::EventType;
 use crate::key::self_fingerprint;
 use crate::location;
 use crate::log::{LogExt, error, info, warn};
 use crate::logged_debug_assert;
 use crate::message::{self, Message, MessageState, MsgId, Viewtype};
-use crate::mimefactory::MimeFactory;
+use crate::mimefactory::{MimeFactory, RenderedEmail};
 use crate::mimeparser::SystemMessage;
 use crate::param::{Param, Params};
 use crate::receive_imf::ReceivedMsg;
@@ -2733,6 +2735,52 @@ async fn prepare_send_msg(
     Ok(row_ids)
 }
 
+/// Renders the message or Full-Message and Pre-Message.
+///
+/// Pre-Message is a small message with metadata which announces a larger Full-Message.
+/// Full messages are not downloaded in the background.
+///
+/// If pre-message is not nessesary this returns a normal message instead.
+async fn render_mime_message_and_pre_message(
+    context: &Context,
+    msg: &mut Message,
+    mimefactory: MimeFactory,
+) -> Result<(RenderedEmail, Option<RenderedEmail>)> {
+    let needs_pre_message = msg.viewtype.has_file()
+        && mimefactory.will_be_encrypted() // unencrypted is likely email, we don't want to spam by sending multiple messages
+        && msg
+            .get_filebytes(context)
+            .await?
+            .context("filebytes not available, even though message has attachment")?
+            > PRE_MSG_ATTACHMENT_SIZE_THRESHOLD;
+
+    if needs_pre_message {
+        let mut mimefactory_full_msg = mimefactory.clone();
+        mimefactory_full_msg.set_as_full_message();
+        let rendered_msg = mimefactory_full_msg.render(context).await?;
+
+        let mut mimefactory_pre_msg = mimefactory;
+        mimefactory_pre_msg.set_as_pre_message_for(&rendered_msg);
+        let rendered_pre_msg = mimefactory_pre_msg
+            .render(context)
+            .await
+            .context("pre-message failed to render")?;
+
+        if rendered_pre_msg.message.len() > PRE_MSG_SIZE_WARNING_THRESHOLD {
+            warn!(
+                context,
+                "Pre-message for message (MsgId={}) is larger than expected: {}.",
+                msg.id,
+                rendered_pre_msg.message.len()
+            );
+        }
+
+        Ok((rendered_msg, Some(rendered_pre_msg)))
+    } else {
+        Ok((mimefactory.render(context).await?, None))
+    }
+}
+
 /// Constructs jobs for sending a message and inserts them into the appropriate table.
 ///
 /// Updates the message `GuaranteeE2ee` parameter and persists it
@@ -2804,13 +2852,14 @@ pub(crate) async fn create_send_msg_jobs(context: &Context, msg: &mut Message) -
         return Ok(Vec::new());
     }
 
-    let rendered_msg = match mimefactory.render(context).await {
-        Ok(res) => Ok(res),
-        Err(err) => {
-            message::set_msg_failed(context, msg, &err.to_string()).await?;
-            Err(err)
-        }
-    }?;
+    let (rendered_msg, rendered_pre_msg) =
+        match render_mime_message_and_pre_message(context, msg, mimefactory).await {
+            Ok(res) => Ok(res),
+            Err(err) => {
+                message::set_msg_failed(context, msg, &err.to_string()).await?;
+                Err(err)
+            }
+        }?;
 
     if needs_encryption && !rendered_msg.is_encrypted {
         /* unrecoverable */
@@ -2870,12 +2919,26 @@ pub(crate) async fn create_send_msg_jobs(context: &Context, msg: &mut Message) -
         } else {
             for recipients_chunk in recipients.chunks(chunk_size) {
                 let recipients_chunk = recipients_chunk.join(" ");
+                // send pre-message before actual message
+                if let Some(pre_msg) = &rendered_pre_msg {
+                    let row_id = t.execute(
+                        "INSERT INTO smtp (rfc724_mid, recipients, mime, msg_id)
+                        VALUES            (?1,         ?2,         ?3,   ?4)",
+                        (
+                            &pre_msg.rfc724_mid,
+                            &recipients_chunk,
+                            &pre_msg.message,
+                            msg.id,
+                        ),
+                    )?;
+                    row_ids.push(row_id.try_into()?);
+                }
                 let row_id = t.execute(
-                    "INSERT INTO smtp (rfc724_mid, recipients, mime, msg_id) \
+                    "INSERT INTO smtp (rfc724_mid, recipients, mime, msg_id)
                     VALUES            (?1,         ?2,         ?3,   ?4)",
                     (
                         &rendered_msg.rfc724_mid,
-                        recipients_chunk,
+                        &recipients_chunk,
                         &rendered_msg.message,
                         msg.id,
                     ),