feat: Disable MDNs for bots by default

- To avoid receiving undecryptable MDNs by bots and replying to them if the bot's key changes.
- MDNs from bots don't look useful in general, usually the user expects some reply from the bot, not
  just that the message is read.

src/config.rs

@@ -129,7 +129,6 @@ pub enum Config {
 
     /// True if Message Delivery Notifications (read receipts) should
     /// be sent and requested.
-    #[strum(props(default = "1"))]
     MdnsEnabled,
 
     /// True if "Sent" folder should be watched for changes.
@@ -515,6 +514,14 @@ impl Context {
             && !self.get_config_bool(Config::Bot).await?)
     }
 
+    /// Returns whether MDNs should be requested and sent.
+    pub(crate) async fn mdns_enabled(&self) -> Result<bool> {
+        match self.get_config_bool_opt(Config::MdnsEnabled).await? {
+            Some(val) => Ok(val),
+            None => Ok(!self.get_config_bool(Config::Bot).await?),
+        }
+    }
+
     /// Gets configured "delete_server_after" value.
     ///
     /// `None` means never delete the message, `Some(0)` means delete
@@ -964,6 +971,15 @@ mod tests {
         Ok(())
     }
 
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn test_mdns_enabled() -> Result<()> {
+        let t = &TestContext::new_alice().await;
+        assert!(t.mdns_enabled().await?);
+        t.set_config_bool(Config::Bot, true).await?;
+        assert!(!t.mdns_enabled().await?);
+        Ok(())
+    }
+
     #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
     async fn test_sync() -> Result<()> {
         let alice0 = TestContext::new_alice().await;
@@ -990,7 +1006,6 @@ mod tests {
         // Reset to default. Test that it's not synced because defaults may differ across client
         // versions.
         alice0.set_config(Config::MdnsEnabled, None).await?;
-        assert_eq!(alice0.get_config_bool(Config::MdnsEnabled).await?, true);
         alice0.set_config_bool(Config::MdnsEnabled, false).await?;
         sync(&alice0, &alice1).await;
         assert_eq!(alice1.get_config_bool(Config::MdnsEnabled).await?, false);

src/message.rs

@@ -1769,19 +1769,17 @@ pub async fn markseen_msgs(context: &Context, msg_ids: Vec<MsgId>) -> Result<()>
             if curr_blocked == Blocked::Not
                 && curr_param.get_bool(Param::WantsMdn).unwrap_or_default()
                 && curr_param.get_cmd() == SystemMessage::Unknown
+                && context.mdns_enabled().await?
             {
-                let mdns_enabled = context.get_config_bool(Config::MdnsEnabled).await?;
+                context
-                if mdns_enabled {
+                    .sql
-                    context
+                    .execute(
-                        .sql
+                        "INSERT INTO smtp_mdns (msg_id, from_id, rfc724_mid) VALUES(?, ?, ?)",
-                        .execute(
+                        (id, curr_from_id, curr_rfc724_mid),
-                            "INSERT INTO smtp_mdns (msg_id, from_id, rfc724_mid) VALUES(?, ?, ?)",
+                    )
-                            (id, curr_from_id, curr_rfc724_mid),
+                    .await
-                        )
+                    .context("failed to insert into smtp_mdns")?;
-                        .await
+                context.scheduler.interrupt_smtp().await;
-                        .context("failed to insert into smtp_mdns")?;
-                    context.scheduler.interrupt_smtp().await;
-                }
             }
             updated_chat_ids.insert(curr_chat_id);
         }

src/mimefactory.rs

@@ -186,7 +186,7 @@ impl MimeFactory {
 
             if !msg.is_system_message()
                 && msg.param.get_int(Param::Reaction).unwrap_or_default() == 0
-                && context.get_config_bool(Config::MdnsEnabled).await?
+                && context.mdns_enabled().await?
             {
                 req_mdn = true;
             }

src/smtp.rs

@@ -631,9 +631,7 @@ async fn send_mdn_rfc724_mid(
 
 /// Tries to send a single MDN. Returns true if more MDNs should be sent.
 async fn send_mdn(context: &Context, smtp: &mut Smtp) -> Result<bool> {
-    let mdns_enabled = context.get_config_bool(Config::MdnsEnabled).await?;
+    if !context.mdns_enabled().await? {
-    if !mdns_enabled {
-        // User has disabled MDNs.
         context.sql.execute("DELETE FROM smtp_mdns", []).await?;
         return Ok(false);
     }