bump version to 1.56.0

Use `parse_message_id` on the header contents before using it.

Database still stores the raw value.

CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog 
 
+## 1.56.0
+
+- fix downscaling images #2469
+
+- fix outgoing messages popping up in selfchat #2456
+
+- securejoin: display error reason if there is any #2470
+
+- do not allow deleting contacts with ongoing chats #2458
+
+- fix: ignore drafts folder when scanning #2454
+
+- fix: scan folders also when inbox is not watched #2446
+
+- more robust In-Reply-To parsing #2182
+
+- update dependencies #2441 #2438 #2439 #2440 #2447 #2448 #2449 #2452 #2453 #2460 #2464 #2466
+
+- update provider-database #2471
+
+- refactorings #2459 #2457
+
+- improve tests and ci #2445 #2450 #2451
+
+
 ## 1.55.0
 
 - fix panic when receiving some HTML messages #2434

Cargo.lock

@@ -1108,7 +1108,7 @@ dependencies = [
 
 [[package]]
 name = "deltachat"
-version = "1.55.0"
+version = "1.56.0"
 dependencies = [
  "ansi_term",
  "anyhow",
@@ -1187,7 +1187,7 @@ dependencies = [
 
 [[package]]
 name = "deltachat_ffi"
-version = "1.55.0"
+version = "1.56.0"
 dependencies = [
  "anyhow",
  "async-std",
@@ -1636,9 +1636,9 @@ checksum = "acc499defb3b348f8d8f3f66415835a9131856ff7714bf10dadfc4ec4bdb29a1"
 
 [[package]]
 name = "futures-lite"
-version = "1.11.3"
+version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4481d0cd0de1d204a4fa55e7d45f07b1d958abcb06714b3446438e2eff695fb"
+checksum = "7694489acd39452c77daa48516b894c153f192c3578d5a839b62c58099fcbf48"
 dependencies = [
  "fastrand",
  "futures-core",
@@ -3593,15 +3593,15 @@ checksum = "6446ced80d6c486436db5c078dde11a9f73d42b57fb273121e160b84f63d894c"
 
 [[package]]
 name = "strum"
-version = "0.20.0"
+version = "0.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7318c509b5ba57f18533982607f24070a55d353e90d4cae30c467cdb2ad5ac5c"
+checksum = "aaf86bbcfd1fa9670b7a129f64fc0c9fcbbfe4f1bc4210e9e98fe71ffc12cde2"
 
 [[package]]
 name = "strum_macros"
-version = "0.20.1"
+version = "0.21.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee8bc6b87a5112aeeab1f4a9f7ab634fe6cbefc4850006df31267f4cfb9e3149"
+checksum = "d06aaeeee809dbc59eb4556183dd927df67db1540de5be8d3ec0b6636358a5ec"
 dependencies = [
  "heck",
  "proc-macro2",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat"
-version = "1.55.0"
+version = "1.56.0"
 authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
 edition = "2018"
 license = "MPL-2.0"
@@ -66,8 +66,8 @@ sha-1 = "0.9.6"
 sha2 = "0.9.5"
 smallvec = "1.0.0"
 stop-token = "0.2.0"
-strum = "0.20.0"
-strum_macros = "0.20.1"
+strum = "0.21.0"
+strum_macros = "0.21.1"
 surf = { version = "2.0.0-alpha.4", default-features = false, features = ["h1-client"] }
 thiserror = "1.0.25"
 toml = "0.5.6"
@@ -78,7 +78,7 @@ uuid = { version = "0.8", features = ["serde", "v4"] }
 ansi_term = "0.12.0"
 async-std = { version = "1.9.0", features = ["unstable", "attributes"] }
 criterion = "0.3"
-futures-lite = "1.7.0"
+futures-lite = "1.12.0"
 log = "0.4.11"
 pretty_assertions = "0.7.2"
 pretty_env_logger = "0.4.0"

deltachat-ffi/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat_ffi"
-version = "1.55.0"
+version = "1.56.0"
 description = "Deltachat FFI"
 authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
 edition = "2018"

python/src/deltachat/direct_imap.py

@@ -251,7 +251,16 @@ class DirectImap:
             return res
 
     def append(self, folder, msg):
+        """Upload a message to *folder*.
+        Trailing whitespace or a linebreak at the beginning will be removed automatically.
+        """
         if msg.startswith("\n"):
             msg = msg[1:]
         msg = '\n'.join([s.lstrip() for s in msg.splitlines()])
         self.conn.append(folder, msg)
+
+    def get_uid_by_message_id(self, message_id):
+        msgs = self.conn.search(['HEADER', 'MESSAGE-ID', message_id])
+        if len(msgs) == 0:
+            raise Exception("Did not find message " + message_id + ", maybe you forgot to select the correct folder?")
+        return msgs[0]

python/tests/test_account.py

@@ -1319,9 +1319,11 @@ class TestOnlineAccount:
         assert not device_chat.can_send()
         assert device_chat.get_draft() is None
 
-    def test_dont_show_emails_in_draft_folder(self, acfactory):
+    def test_dont_show_emails_in_draft_folder(self, acfactory, lp):
         """Most mailboxes have a "Drafts" folder where constantly new emails appear but we don't actually want to show them.
-        So: If it's outgoing AND there is no Received header AND it's not in the sentbox, then ignore the email."""
+        So: If it's outgoing AND there is no Received header AND it's not in the sentbox, then ignore the email.
+
+        If the draft email is sent out later (i.e. moved to "Sent"), it must be shown."""
         ac1 = acfactory.get_online_configuring_account()
         ac1.set_config("show_emails", "2")
         ac1.create_contact("alice@example.com").create_chat()
@@ -1342,7 +1344,7 @@ class TestOnlineAccount:
             Message-ID: <aepiors@example.org>
             Content-Type: text/plain; charset=utf-8
 
-            message in Drafts
+            message in Drafts that is moved to Sent later
         """.format(ac1.get_config("configured_addr")))
         ac1.direct_imap.append("Sent", """
             From: ac1 <{}>
@@ -1355,6 +1357,7 @@ class TestOnlineAccount:
         """.format(ac1.get_config("configured_addr")))
 
         ac1.set_config("scan_all_folders_debounce_secs", "0")
+        lp.sec("All prepared, now let DC find the message")
         ac1.start_io()
 
         msg = ac1._evtracker.wait_next_messages_changed()
@@ -1365,6 +1368,18 @@ class TestOnlineAccount:
         assert msg.text == "subj – message in Sent"
         assert len(msg.chat.get_messages()) == 1
 
+        ac1.stop_io()
+        lp.sec("'Send out' the draft, i.e. move it to the Sent folder, and wait for DC to display it this time")
+        ac1.direct_imap.select_folder("Drafts")
+        uid = ac1.direct_imap.get_uid_by_message_id("aepiors@example.org")
+        ac1.direct_imap.conn.move(uid, "Sent")
+
+        ac1.start_io()
+        msg2 = ac1._evtracker.wait_next_messages_changed()
+
+        assert msg2.text == "subj – message in Drafts that is moved to Sent later"
+        assert len(msg.chat.get_messages()) == 2
+
     def test_prefer_encrypt(self, acfactory, lp):
         """Test quorum rule for encryption preference in 1:1 and group chat."""
         ac1, ac2, ac3 = acfactory.get_many_online_accounts(3)

src/blob.rs

@@ -452,7 +452,7 @@ impl<'a> BlobObject<'a> {
             img.write_to(encoded, image::ImageFormat::Jpeg)?;
             Ok(())
         }
-        fn encode_img_exceeds_bytes(
+        fn encoded_img_exceeds_bytes(
             context: &Context,
             img: &DynamicImage,
             max_bytes: Option<usize>,
@@ -477,7 +477,7 @@ impl<'a> BlobObject<'a> {
         let exceeds_width = img.width() > img_wh || img.height() > img_wh;
 
         let do_scale =
-            exceeds_width || encode_img_exceeds_bytes(context, &img, max_bytes, &mut encoded)?;
+            exceeds_width || encoded_img_exceeds_bytes(context, &img, max_bytes, &mut encoded)?;
         let do_rotate = matches!(orientation, Ok(90) | Ok(180) | Ok(270));
 
         if do_scale || do_rotate {
@@ -500,7 +500,7 @@ impl<'a> BlobObject<'a> {
                 loop {
                     let new_img = img.thumbnail(img_wh, img_wh);
 
-                    if encode_img_exceeds_bytes(context, &new_img, max_bytes, &mut encoded)? {
+                    if encoded_img_exceeds_bytes(context, &new_img, max_bytes, &mut encoded)? {
                         if img_wh < 20 {
                             return Err(format_err!(
                                 "Failed to scale image to below {}B",
@@ -511,6 +511,10 @@ impl<'a> BlobObject<'a> {
 
                         img_wh = img_wh * 2 / 3;
                     } else {
+                        if encoded.is_empty() {
+                            encode_img(&new_img, &mut encoded)?;
+                        }
+
                         info!(
                             context,
                             "Final scaled-down image size: {}B ({}px)",
@@ -617,7 +621,7 @@ mod tests {
 
     use super::*;
 
-    use crate::test_utils::TestContext;
+    use crate::{message::Message, test_utils::TestContext};
 
     #[async_std::test]
     async fn test_create() {
@@ -915,4 +919,49 @@ mod tests {
         let avatar_cfg = t.get_config(Config::Selfavatar).await.unwrap();
         assert_eq!(avatar_cfg, avatar_blob.to_str().map(|s| s.to_string()));
     }
+
+    #[async_std::test]
+    async fn test_media_quality() -> anyhow::Result<()> {
+        for (media_quality_config, image_size) in vec![
+            (Some("0"), 1000), // BALANCED_IMAGE_SIZE > 1000, the original image size, so the image is not scaled down
+            (Some("1"), WORSE_IMAGE_SIZE),
+        ]
+        .into_iter()
+        {
+            let alice = TestContext::new_alice().await;
+            let bob = TestContext::new_bob().await;
+            alice
+                .set_config(Config::MediaQuality, media_quality_config)
+                .await?;
+
+            let file = alice.get_blobdir().join("file.jpg");
+            let bytes = include_bytes!("../test-data/image/avatar1000x1000.jpg");
+            File::create(&file).await?.write_all(bytes).await?;
+
+            let img = image::open(&file)?;
+            assert_eq!(img.width(), 1000);
+            assert_eq!(img.height(), 1000);
+
+            let mut msg = Message::new(Viewtype::Image);
+            msg.set_file(file.to_str().unwrap(), None);
+            let chat = alice.create_chat(&bob).await;
+            let sent = alice.send_msg(chat.id, &mut msg).await;
+
+            let alice_msg = alice.get_last_msg().await;
+            assert_eq!(alice_msg.get_width() as u32, image_size);
+            assert_eq!(alice_msg.get_height() as u32, image_size);
+            let img = image::open(alice_msg.get_file(&alice).unwrap())?;
+            assert_eq!(img.width() as u32, image_size);
+            assert_eq!(img.height() as u32, image_size);
+
+            bob.recv_msg(&sent).await;
+            let bob_msg = bob.get_last_msg().await;
+            assert_eq!(bob_msg.get_width() as u32, image_size);
+            assert_eq!(bob_msg.get_height() as u32, image_size);
+            let img = image::open(bob_msg.get_file(&bob).unwrap())?;
+            assert_eq!(img.width() as u32, image_size);
+            assert_eq!(img.height() as u32, image_size);
+        }
+        Ok(())
+    }
 }

src/config.rs

@@ -18,7 +18,18 @@ use crate::stock_str;
 
 /// The available configuration keys.
 #[derive(
-    Debug, Clone, Copy, PartialEq, Eq, Display, EnumString, AsRefStr, EnumIter, EnumProperty,
+    Debug,
+    Clone,
+    Copy,
+    PartialEq,
+    Eq,
+    Display,
+    EnumString,
+    AsRefStr,
+    EnumIter,
+    EnumProperty,
+    PartialOrd,
+    Ord,
 )]
 #[strum(serialize_all = "snake_case")]
 pub enum Config {

src/configure.rs

@@ -345,10 +345,8 @@ async fn configure(ctx: &Context, param: &mut LoginParam) -> Result<()> {
     progress!(ctx, 600);
 
     // Configure IMAP
-    let (_s, r) = async_std::channel::bounded(1);
-    let mut imap = Imap::new(r);
 
-    let mut imap_configured = false;
+    let mut imap: Option<Imap> = None;
     let imap_servers: Vec<&ServerParams> = servers
         .iter()
         .filter(|params| params.protocol == Protocol::Imap)
@@ -361,18 +359,9 @@ async fn configure(ctx: &Context, param: &mut LoginParam) -> Result<()> {
         param.imap.port = imap_server.port;
         param.imap.security = imap_server.socket;
 
-        match try_imap_one_param(
-            ctx,
-            &param.imap,
-            &param.addr,
-            oauth2,
-            provider_strict_tls,
-            &mut imap,
-        )
-        .await
-        {
-            Ok(_) => {
-                imap_configured = true;
+        match try_imap_one_param(ctx, &param.imap, &param.addr, oauth2, provider_strict_tls).await {
+            Ok(configured_imap) => {
+                imap = Some(configured_imap);
                 break;
             }
             Err(e) => errors.push(e),
@@ -382,9 +371,10 @@ async fn configure(ctx: &Context, param: &mut LoginParam) -> Result<()> {
             600 + (800 - 600) * (1 + imap_server_index) / imap_servers_count
         );
     }
-    if !imap_configured {
-        bail!(nicer_configuration_error(ctx, errors).await);
-    }
+    let mut imap = match imap {
+        Some(imap) => imap,
+        None => bail!(nicer_configuration_error(ctx, errors).await),
+    };
 
     progress!(ctx, 850);
 
@@ -520,26 +510,38 @@ async fn try_imap_one_param(
     addr: &str,
     oauth2: bool,
     provider_strict_tls: bool,
-    imap: &mut Imap,
-) -> Result<(), ConfigurationError> {
+) -> Result<Imap, ConfigurationError> {
     let inf = format!(
         "imap: {}@{}:{} security={} certificate_checks={} oauth2={}",
         param.user, param.server, param.port, param.security, param.certificate_checks, oauth2
     );
     info!(context, "Trying: {}", inf);
 
-    if let Err(err) = imap
-        .connect(context, param, addr, oauth2, provider_strict_tls)
-        .await
-    {
-        info!(context, "failure: {}", err);
-        Err(ConfigurationError {
-            config: inf,
-            msg: err.to_string(),
-        })
-    } else {
-        info!(context, "success: {}", inf);
-        Ok(())
+    let (_s, r) = async_std::channel::bounded(1);
+
+    let mut imap = match Imap::new(param, addr, oauth2, provider_strict_tls, r).await {
+        Err(err) => {
+            info!(context, "failure: {}", err);
+            return Err(ConfigurationError {
+                config: inf,
+                msg: err.to_string(),
+            });
+        }
+        Ok(imap) => imap,
+    };
+
+    match imap.connect(context).await {
+        Err(err) => {
+            info!(context, "failure: {}", err);
+            return Err(ConfigurationError {
+                config: inf,
+                msg: err.to_string(),
+            });
+        }
+        Ok(()) => {
+            info!(context, "success: {}", inf);
+            return Ok(imap);
+        }
     }
 }
 

src/contact.rs

@@ -860,7 +860,7 @@ impl Contact {
             "Can not delete special contact"
         );
 
-        let count_contacts = context
+        let count_chats = context
             .sql
             .count(
                 "SELECT COUNT(*) FROM chats_contacts WHERE contact_id=?;",
@@ -868,19 +868,7 @@ impl Contact {
             )
             .await?;
 
-        let count_msgs = if count_contacts > 0 {
-            context
-                .sql
-                .count(
-                    "SELECT COUNT(*) FROM msgs WHERE from_id=? OR to_id=?;",
-                    paramsv![contact_id as i32, contact_id as i32],
-                )
-                .await?
-        } else {
-            0
-        };
-
-        if count_msgs == 0 {
+        if count_chats == 0 {
             match context
                 .sql
                 .execute(
@@ -902,9 +890,9 @@ impl Contact {
 
         info!(
             context,
-            "could not delete contact {}, there are {} messages with it", contact_id, count_msgs
+            "could not delete contact {}, there are {} chats with it", contact_id, count_chats
         );
-        bail!("Could not delete contact with messages in it");
+        bail!("Could not delete contact with ongoing chats");
     }
 
     /// Get a single contact object.  For a list, see eg. dc_get_contacts().
@@ -1618,6 +1606,34 @@ mod tests {
         assert!(!contact.is_blocked());
     }
 
+    #[async_std::test]
+    async fn test_delete() -> Result<()> {
+        let alice = TestContext::new_alice().await;
+
+        assert!(Contact::delete(&alice, DC_CONTACT_ID_SELF).await.is_err());
+
+        // Create Bob contact
+        let (contact_id, _) =
+            Contact::add_or_lookup(&alice, "Bob", "bob@example.net", Origin::ManuallyCreated)
+                .await
+                .unwrap();
+
+        let chat = alice
+            .create_chat_with_contact("Bob", "bob@example.net")
+            .await;
+
+        // Can't delete a contact with ongoing chats.
+        assert!(Contact::delete(&alice, contact_id).await.is_err());
+
+        // Delete chat.
+        chat.get_id().delete(&alice).await?;
+
+        // Can delete contact now.
+        Contact::delete(&alice, contact_id).await?;
+
+        Ok(())
+    }
+
     #[async_std::test]
     async fn test_remote_authnames() {
         let t = TestContext::new().await;

src/context.rs

@@ -161,7 +161,9 @@ impl Context {
 
         {
             let l = &mut *self.inner.scheduler.write().await;
-            l.start(self.clone()).await;
+            if let Err(err) = l.start(self.clone()).await {
+                error!(self, "Failed to start IO: {}", err)
+            }
         }
     }
 
@@ -538,19 +540,16 @@ impl Context {
 
     pub async fn is_sentbox(&self, folder_name: &str) -> Result<bool> {
         let sentbox = self.get_config(Config::ConfiguredSentboxFolder).await?;
-
         Ok(sentbox.as_deref() == Some(folder_name))
     }
 
     pub async fn is_mvbox(&self, folder_name: &str) -> Result<bool> {
         let mvbox = self.get_config(Config::ConfiguredMvboxFolder).await?;
-
         Ok(mvbox.as_deref() == Some(folder_name))
     }
 
     pub async fn is_spam_folder(&self, folder_name: &str) -> Result<bool> {
         let spam = self.get_config(Config::ConfiguredSpamFolder).await?;
-
         Ok(spam.as_deref() == Some(folder_name))
     }
 

src/dc_receive_imf.rs

@@ -2742,11 +2742,14 @@ mod tests {
 
         // Check that the ndn would be downloaded:
         let headers = mailparse::parse_mail(raw_ndn).unwrap().headers;
-        assert!(
-            crate::imap::prefetch_should_download(&t, &headers, ShowEmails::Off)
-                .await
-                .unwrap()
-        );
+        assert!(crate::imap::prefetch_should_download(
+            &t,
+            &headers,
+            std::iter::empty(),
+            ShowEmails::Off
+        )
+        .await
+        .unwrap());
 
         dc_receive_imf(&t, raw_ndn, "INBOX", 1, false)
             .await

src/imap.rs

@@ -8,13 +8,12 @@ use std::{cmp, cmp::max, collections::BTreeMap};
 use anyhow::{bail, format_err, Context as _, Result};
 use async_imap::{
     error::Result as ImapResult,
-    types::{Capability, Fetch, Flag, Mailbox, Name, NameAttribute},
+    types::{Fetch, Flag, Mailbox, Name, NameAttribute},
 };
 use async_std::channel::Receiver;
 use async_std::prelude::*;
 use num_traits::FromPrimitive;
 
-use crate::chat;
 use crate::config::Config;
 use crate::constants::{
     Chattype, ShowEmails, Viewtype, DC_FETCH_EXISTING_MSGS_COUNT, DC_FOLDERS_CONFIGURED_VERSION,
@@ -36,6 +35,7 @@ use crate::param::Params;
 use crate::provider::Socket;
 use crate::scheduler::InterruptInfo;
 use crate::stock_str;
+use crate::{chat, constants::DC_CONTACT_ID_SELF};
 
 mod client;
 mod idle;
@@ -92,6 +92,10 @@ pub struct Imap {
     interrupt: Option<stop_token::StopSource>,
     should_reconnect: bool,
     login_failed_once: bool,
+
+    /// True if CAPABILITY command was run successfully once and config.can_* contain correct
+    /// values.
+    capabilities_determined: bool,
 }
 
 #[derive(Debug)]
@@ -111,14 +115,27 @@ impl async_imap::Authenticator for OAuth2 {
     }
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Clone, Copy)]
 enum FolderMeaning {
     Unknown,
     Spam,
-    SentObjects,
+    Sent,
+    Drafts,
     Other,
 }
 
+impl FolderMeaning {
+    fn to_config(self) -> Option<Config> {
+        match self {
+            FolderMeaning::Unknown => None,
+            FolderMeaning::Spam => Some(Config::ConfiguredSpamFolder),
+            FolderMeaning::Sent => Some(Config::ConfiguredSentboxFolder),
+            FolderMeaning::Drafts => None,
+            FolderMeaning::Other => None,
+        }
+    }
+}
+
 #[derive(Debug)]
 struct ImapConfig {
     pub addr: String,
@@ -128,6 +145,7 @@ struct ImapConfig {
     pub selected_folder: Option<String>,
     pub selected_mailbox: Option<Mailbox>,
     pub selected_folder_needs_expunge: bool,
+
     pub can_idle: bool,
 
     /// True if the server has MOVE capability as defined in
@@ -135,58 +153,93 @@ struct ImapConfig {
     pub can_move: bool,
 }
 
-impl Default for ImapConfig {
-    fn default() -> Self {
-        ImapConfig {
-            addr: "".into(),
-            lp: Default::default(),
-            strict_tls: false,
-            oauth2: false,
+impl Imap {
+    /// Creates new disconnected IMAP client using the specific login parameters.
+    ///
+    /// `addr` is used to renew token if OAuth2 authentication is used.
+    pub async fn new(
+        lp: &ServerLoginParam,
+        addr: &str,
+        oauth2: bool,
+        provider_strict_tls: bool,
+        idle_interrupt: Receiver<InterruptInfo>,
+    ) -> Result<Self> {
+        if lp.server.is_empty() || lp.user.is_empty() || lp.password.is_empty() {
+            bail!("Incomplete IMAP connection parameters");
+        }
+
+        let strict_tls = match lp.certificate_checks {
+            CertificateChecks::Automatic => provider_strict_tls,
+            CertificateChecks::Strict => true,
+            CertificateChecks::AcceptInvalidCertificates
+            | CertificateChecks::AcceptInvalidCertificates2 => false,
+        };
+        let config = ImapConfig {
+            addr: addr.to_string(),
+            lp: lp.clone(),
+            strict_tls,
+            oauth2,
             selected_folder: None,
             selected_mailbox: None,
             selected_folder_needs_expunge: false,
             can_idle: false,
             can_move: false,
-        }
-    }
-}
+        };
 
-impl Imap {
-    pub fn new(idle_interrupt: Receiver<InterruptInfo>) -> Self {
-        Imap {
+        let imap = Imap {
             idle_interrupt,
-            config: Default::default(),
-            session: Default::default(),
-            connected: Default::default(),
-            interrupt: Default::default(),
-            should_reconnect: Default::default(),
-            login_failed_once: Default::default(),
+            config,
+            session: None,
+            connected: false,
+            interrupt: None,
+            should_reconnect: false,
+            login_failed_once: false,
+            capabilities_determined: false,
+        };
+
+        Ok(imap)
+    }
+
+    /// Creates new disconnected IMAP client using configured parameters.
+    pub async fn new_configured(
+        context: &Context,
+        idle_interrupt: Receiver<InterruptInfo>,
+    ) -> Result<Self> {
+        if !context.is_configured().await? {
+            bail!("IMAP Connect without configured params");
         }
-    }
 
-    pub fn is_connected(&self) -> bool {
-        self.connected
-    }
+        let param = LoginParam::from_database(context, "configured_").await?;
+        // the trailing underscore is correct
 
-    pub fn should_reconnect(&self) -> bool {
-        self.should_reconnect
-    }
-
-    pub fn trigger_reconnect(&mut self) {
-        self.should_reconnect = true;
+        let imap = Self::new(
+            &param.imap,
+            &param.addr,
+            param.server_flags & DC_LP_AUTH_OAUTH2 != 0,
+            param.provider.map_or(false, |provider| provider.strict_tls),
+            idle_interrupt,
+        )
+        .await?;
+        Ok(imap)
     }
 
     /// Connects or reconnects if needed.
     ///
-    /// It is safe to call this function if already connected, actions
-    /// are performed only as needed.
-    async fn try_setup_handle(&mut self, context: &Context) -> Result<()> {
+    /// It is safe to call this function if already connected, actions are performed only as needed.
+    ///
+    /// Does not emit network errors, can be used to try various parameters during
+    /// autoconfiguration.
+    ///
+    /// Calling this function is not enough to perform IMAP operations. Use [`Imap::prepare`]
+    /// instead if you are going to actually use connection rather than trying connection
+    /// parameters.
+    pub async fn connect(&mut self, context: &Context) -> Result<()> {
         if self.config.lp.server.is_empty() {
             bail!("IMAP operation attempted while it is torn down");
         }
 
         if self.should_reconnect() {
-            self.unsetup_handle(context).await;
+            self.disconnect(context).await;
             self.should_reconnect = false;
         } else if self.is_connected() {
             return Ok(());
@@ -256,6 +309,10 @@ impl Imap {
                 self.connected = true;
                 self.session = Some(session);
                 self.login_failed_once = false;
+                emit_event!(
+                    context,
+                    EventType::ImapConnected(format!("IMAP-LOGIN as {}", self.config.lp.user))
+                );
                 Ok(())
             }
 
@@ -292,20 +349,49 @@ impl Imap {
         }
     }
 
-    /// Connects or reconnects if not already connected.
+    /// Determine server capabilities if not done yet.
+    async fn determine_capabilities(&mut self) -> Result<()> {
+        if self.capabilities_determined {
+            return Ok(());
+        }
+
+        match &mut self.session {
+            Some(ref mut session) => match session.capabilities().await {
+                Ok(caps) => {
+                    self.config.can_idle = caps.has_str("IDLE");
+                    self.config.can_move = caps.has_str("MOVE");
+                    self.capabilities_determined = true;
+                    Ok(())
+                }
+                Err(err) => {
+                    bail!("CAPABILITY command error: {}", err);
+                }
+            },
+            None => {
+                bail!("Can't determine server capabilities because connection was not established")
+            }
+        }
+    }
+
+    /// Prepare for IMAP operation.
     ///
-    /// This function emits network error if it fails.  It should not
-    /// be used during configuration to avoid showing failed attempt
-    /// errors to the user.
-    async fn setup_handle(&mut self, context: &Context) -> Result<()> {
-        let res = self.try_setup_handle(context).await;
+    /// Ensure that IMAP client is connected, folders are created and IMAP capabilities are
+    /// determined.
+    ///
+    /// This function emits network error if it fails.  It should not be used during configuration
+    /// to avoid showing failed attempt errors to the user.
+    pub async fn prepare(&mut self, context: &Context) -> Result<()> {
+        let res = self.connect(context).await;
         if let Err(ref err) = res {
             emit_event!(context, EventType::ErrorNetwork(err.to_string()));
         }
+
+        self.ensure_configured_folders(context, true).await?;
+        self.determine_capabilities().await?;
         res
     }
 
-    async fn unsetup_handle(&mut self, context: &Context) {
+    async fn disconnect(&mut self, context: &Context) {
         // Close folder if messages should be expunged
         if let Err(err) = self.close_folder(context).await {
             warn!(context, "failed to close folder: {:?}", err);
@@ -318,139 +404,21 @@ impl Imap {
             }
         }
         self.connected = false;
+        self.capabilities_determined = false;
         self.config.selected_folder = None;
         self.config.selected_mailbox = None;
     }
 
-    async fn free_connect_params(&mut self) {
-        let mut cfg = &mut self.config;
-
-        cfg.addr = "".into();
-        cfg.lp = Default::default();
-
-        cfg.can_idle = false;
-        cfg.can_move = false;
+    pub fn is_connected(&self) -> bool {
+        self.connected
     }
 
-    /// Connects to IMAP account using already-configured parameters.
-    ///
-    /// Emits network error if connection fails.
-    pub async fn connect_configured(&mut self, context: &Context) -> Result<()> {
-        if self.is_connected() && !self.should_reconnect() {
-            return Ok(());
-        }
-        if !context.is_configured().await? {
-            bail!("IMAP Connect without configured params");
-        }
-
-        let param = LoginParam::from_database(context, "configured_").await?;
-        // the trailing underscore is correct
-
-        if let Err(err) = self
-            .connect(
-                context,
-                &param.imap,
-                &param.addr,
-                param.server_flags & DC_LP_AUTH_OAUTH2 != 0,
-                param.provider.map_or(false, |provider| provider.strict_tls),
-            )
-            .await
-        {
-            bail!("IMAP Connection Failed with params {}: {}", param, err);
-        } else {
-            self.ensure_configured_folders(context, true).await
-        }
+    pub fn should_reconnect(&self) -> bool {
+        self.should_reconnect
     }
 
-    /// Tries connecting to imap account using the specific login parameters.
-    ///
-    /// `addr` is used to renew token if OAuth2 authentication is used.
-    ///
-    /// Does not emit network errors, can be used to try various
-    /// parameters during autoconfiguration.
-    pub async fn connect(
-        &mut self,
-        context: &Context,
-        lp: &ServerLoginParam,
-        addr: &str,
-        oauth2: bool,
-        provider_strict_tls: bool,
-    ) -> Result<()> {
-        if lp.server.is_empty() || lp.user.is_empty() || lp.password.is_empty() {
-            bail!("Incomplete IMAP connection parameters");
-        }
-
-        {
-            let mut config = &mut self.config;
-            config.addr = addr.to_string();
-            config.lp = lp.clone();
-            config.strict_tls = match lp.certificate_checks {
-                CertificateChecks::Automatic => provider_strict_tls,
-                CertificateChecks::Strict => true,
-                CertificateChecks::AcceptInvalidCertificates
-                | CertificateChecks::AcceptInvalidCertificates2 => false,
-            };
-            config.oauth2 = oauth2;
-        }
-
-        if let Err(err) = self.try_setup_handle(context).await {
-            warn!(context, "try_setup_handle: {}", err);
-            self.free_connect_params().await;
-            return Err(err);
-        }
-
-        let teardown = match &mut self.session {
-            Some(ref mut session) => match session.capabilities().await {
-                Ok(caps) => {
-                    if !context.sql.is_open().await {
-                        warn!(context, "IMAP-LOGIN as {} ok but ABORTING", lp.user,);
-                        true
-                    } else {
-                        let can_idle = caps.has_str("IDLE");
-                        let can_move = caps.has_str("MOVE");
-                        let caps_list = caps.iter().fold(String::new(), |s, c| {
-                            if let Capability::Atom(x) = c {
-                                s + &format!(" {}", x)
-                            } else {
-                                s + &format!(" {:?}", c)
-                            }
-                        });
-
-                        self.config.can_idle = can_idle;
-                        self.config.can_move = can_move;
-                        self.connected = true;
-                        emit_event!(
-                            context,
-                            EventType::ImapConnected(format!(
-                                "IMAP-LOGIN as {}, capabilities: {}",
-                                lp.user, caps_list,
-                            ))
-                        );
-                        false
-                    }
-                }
-                Err(err) => {
-                    info!(context, "CAPABILITY command error: {}", err);
-                    true
-                }
-            },
-            None => true,
-        };
-
-        if teardown {
-            self.disconnect(context).await;
-
-            warn!(
-                context,
-                "IMAP disconnected immediately after connecting due to error"
-            );
-        }
-        Ok(())
-    }
-
-    pub async fn disconnect(&mut self, context: &Context) {
-        self.unsetup_handle(context).await;
-        self.free_connect_params().await;
+    pub fn trigger_reconnect(&mut self) {
+        self.should_reconnect = true;
     }
 
     pub async fn fetch(&mut self, context: &Context, watch_folder: &str) -> Result<()> {
@@ -458,7 +426,7 @@ impl Imap {
             // probably shutdown
             bail!("IMAP operation attempted while it is torn down");
         }
-        self.setup_handle(context).await?;
+        self.prepare(context).await?;
 
         while self
             .fetch_new_messages(context, &watch_folder, false)
@@ -696,6 +664,7 @@ impl Imap {
                 current_uid,
                 &headers,
                 &msg_id,
+                msg.flags(),
                 folder,
                 show_emails,
             )
@@ -974,10 +943,6 @@ impl Imap {
         (last_uid, read_errors)
     }
 
-    pub async fn can_move(&self) -> bool {
-        self.config.can_move
-    }
-
     pub async fn mv(
         &mut self,
         context: &Context,
@@ -1002,7 +967,7 @@ impl Imap {
         let set = format!("{}", uid);
         let display_folder_id = format!("{}/{}", folder, uid);
 
-        if self.can_move().await {
+        if self.config.can_move {
             if let Some(ref mut session) = &mut self.session {
                 match session.uid_mv(&set, &dest_folder).await {
                     Ok(_) => {
@@ -1128,7 +1093,7 @@ impl Imap {
             // TODO: make INBOX/SENT/MVBOX perform the jobs on their
             // respective folders to avoid select_folder network traffic
             // and the involved error states
-            if let Err(err) = self.connect_configured(context).await {
+            if let Err(err) = self.prepare(context).await {
                 warn!(context, "prepare_imap_op failed: {}", err);
                 return Some(ImapActionResult::RetryLater);
             }
@@ -1300,9 +1265,8 @@ impl Imap {
 
             let mut delimiter = ".".to_string();
             let mut delimiter_is_default = true;
-            let mut sentbox_folder = None;
-            let mut spam_folder = None;
             let mut mvbox_folder = None;
+            let mut folder_configs = BTreeMap::new();
             let mut fallback_folder = get_fallback_folder(&delimiter);
 
             while let Some(folder) = folders.next().await {
@@ -1321,31 +1285,26 @@ impl Imap {
                 let folder_meaning = get_folder_meaning(&folder);
                 let folder_name_meaning = get_folder_meaning_by_name(folder.name());
                 if folder.name() == "DeltaChat" {
-                    // Always takes precendent
+                    // Always takes precedence
                     mvbox_folder = Some(folder.name().to_string());
                 } else if folder.name() == fallback_folder {
-                    // only set iff none has been already set
+                    // only set if none has been already set
                     if mvbox_folder.is_none() {
                         mvbox_folder = Some(folder.name().to_string());
                     }
-                } else if folder_meaning == FolderMeaning::SentObjects {
-                    // Always takes precedent
-                    sentbox_folder = Some(folder.name().to_string());
-                } else if folder_meaning == FolderMeaning::Spam {
-                    spam_folder = Some(folder.name().to_string());
-                } else if folder_name_meaning == FolderMeaning::SentObjects {
-                    // only set iff none has been already set
-                    if sentbox_folder.is_none() {
-                        sentbox_folder = Some(folder.name().to_string());
-                    }
-                } else if folder_name_meaning == FolderMeaning::Spam && spam_folder.is_none() {
-                    spam_folder = Some(folder.name().to_string());
+                } else if let Some(config) = folder_meaning.to_config() {
+                    // Always takes precedence
+                    folder_configs.insert(config, folder.name().to_string());
+                } else if let Some(config) = folder_name_meaning.to_config() {
+                    // only set if none has been already set
+                    folder_configs
+                        .entry(config)
+                        .or_insert_with(|| folder.name().to_string());
                 }
             }
             drop(folders);
 
             info!(context, "Using \"{}\" as folder-delimiter.", delimiter);
-            info!(context, "sentbox folder is {:?}", sentbox_folder);
 
             if mvbox_folder.is_none() && create_mvbox {
                 info!(context, "Creating MVBOX-folder \"DeltaChat\"...",);
@@ -1393,15 +1352,8 @@ impl Imap {
                     .set_config(Config::ConfiguredMvboxFolder, Some(mvbox_folder))
                     .await?;
             }
-            if let Some(ref sentbox_folder) = sentbox_folder {
-                context
-                    .set_config(Config::ConfiguredSentboxFolder, Some(sentbox_folder))
-                    .await?;
-            }
-            if let Some(ref spam_folder) = spam_folder {
-                context
-                    .set_config(Config::ConfiguredSpamFolder, Some(spam_folder))
-                    .await?;
+            for (config, name) in folder_configs {
+                context.set_config(config, Some(&name)).await?;
             }
             context
                 .sql
@@ -1474,29 +1426,50 @@ fn get_folder_meaning_by_name(folder_name: &str) -> FolderMeaning {
         "迷惑メール",
         "스팸",
     ];
+    const DRAFT_NAMES: &[&str] = &[
+        "Drafts",
+        "Kladder",
+        "Entw?rfe",
+        "Borradores",
+        "Brouillons",
+        "Bozze",
+        "Concepten",
+        "Wersje robocze",
+        "Rascunhos",
+        "Entwürfe",
+        "Koncepty",
+        "Kopie robocze",
+        "Taslaklar",
+        "Utkast",
+        "Πρόχειρα",
+        "Черновики",
+        "下書き",
+        "草稿",
+        "임시보관함",
+    ];
     let lower = folder_name.to_lowercase();
 
     if SENT_NAMES.iter().any(|s| s.to_lowercase() == lower) {
-        FolderMeaning::SentObjects
+        FolderMeaning::Sent
     } else if SPAM_NAMES.iter().any(|s| s.to_lowercase() == lower) {
         FolderMeaning::Spam
+    } else if DRAFT_NAMES.iter().any(|s| s.to_lowercase() == lower) {
+        FolderMeaning::Drafts
     } else {
         FolderMeaning::Unknown
     }
 }
 
 fn get_folder_meaning(folder_name: &Name) -> FolderMeaning {
-    let special_names = vec!["\\Trash", "\\Drafts"];
-
     for attr in folder_name.attributes() {
         if let NameAttribute::Custom(ref label) = attr {
-            if special_names.iter().any(|s| *s == label) {
-                return FolderMeaning::Other;
-            } else if label == "\\Sent" {
-                return FolderMeaning::SentObjects;
-            } else if label == "\\Spam" || label == "\\Junk" {
-                return FolderMeaning::Spam;
-            }
+            match label.as_ref() {
+                "\\Trash" => return FolderMeaning::Other,
+                "\\Sent" => return FolderMeaning::Sent,
+                "\\Spam" | "\\Junk" => return FolderMeaning::Spam,
+                "\\Drafts" => return FolderMeaning::Drafts,
+                _ => {}
+            };
         }
     }
     FolderMeaning::Unknown
@@ -1614,6 +1587,7 @@ fn prefetch_get_message_id(headers: &[mailparse::MailHeader]) -> Result<String>
 pub(crate) async fn prefetch_should_download(
     context: &Context,
     headers: &[mailparse::MailHeader<'_>],
+    mut flags: impl Iterator<Item = Flag<'_>>,
     show_emails: ShowEmails,
 ) -> Result<bool> {
     let is_chat_message = headers.get_header_value(HeaderDef::ChatVersion).is_some();
@@ -1651,12 +1625,17 @@ pub(crate) async fn prefetch_should_download(
         .get_header_value(HeaderDef::AutocryptSetupMessage)
         .is_some();
 
-    let (_contact_id, blocked_contact, origin) =
+    let (from_id, blocked_contact, origin) =
         from_field_to_contact_id(context, &mimeparser::get_from(headers), true).await?;
     // prevent_rename=true as this might be a mailing list message and in this case it would be bad if we rename the contact.
     // (prevent_rename is the last argument of from_field_to_contact_id())
-    let accepted_contact = origin.is_known();
 
+    if flags.any(|f| f == Flag::Draft) && from_id == DC_CONTACT_ID_SELF {
+        info!(context, "Ignoring draft message");
+        return Ok(false);
+    }
+
+    let accepted_contact = origin.is_known();
     let show = is_autocrypt_setup_message
         || match show_emails {
             ShowEmails::Off => is_chat_message || is_reply_to_chat_message,
@@ -1675,6 +1654,7 @@ async fn message_needs_processing(
     current_uid: u32,
     headers: &[mailparse::MailHeader<'_>],
     msg_id: &str,
+    flags: impl Iterator<Item = Flag<'_>>,
     folder: &str,
     show_emails: ShowEmails,
 ) -> bool {
@@ -1698,7 +1678,7 @@ async fn message_needs_processing(
     // we do not know the message-id
     // or the message-id is missing (in this case, we create one in the further process)
     // or some other error happened
-    let show = match prefetch_should_download(context, headers, show_emails).await {
+    let show = match prefetch_should_download(context, headers, flags, show_emails).await {
         Ok(show) => show,
         Err(err) => {
             warn!(context, "prefetch_should_download error: {}", err);
@@ -1861,25 +1841,16 @@ mod tests {
     use crate::test_utils::TestContext;
     #[test]
     fn test_get_folder_meaning_by_name() {
-        assert_eq!(
-            get_folder_meaning_by_name("Gesendet"),
-            FolderMeaning::SentObjects
-        );
-        assert_eq!(
-            get_folder_meaning_by_name("GESENDET"),
-            FolderMeaning::SentObjects
-        );
-        assert_eq!(
-            get_folder_meaning_by_name("gesendet"),
-            FolderMeaning::SentObjects
-        );
+        assert_eq!(get_folder_meaning_by_name("Gesendet"), FolderMeaning::Sent);
+        assert_eq!(get_folder_meaning_by_name("GESENDET"), FolderMeaning::Sent);
+        assert_eq!(get_folder_meaning_by_name("gesendet"), FolderMeaning::Sent);
         assert_eq!(
             get_folder_meaning_by_name("Messages envoyés"),
-            FolderMeaning::SentObjects
+            FolderMeaning::Sent
         );
         assert_eq!(
             get_folder_meaning_by_name("mEsSaGes envoyÉs"),
-            FolderMeaning::SentObjects
+            FolderMeaning::Sent
         );
         assert_eq!(get_folder_meaning_by_name("xxx"), FolderMeaning::Unknown);
         assert_eq!(get_folder_meaning_by_name("SPAM"), FolderMeaning::Spam);

src/imap/idle.rs

@@ -25,7 +25,7 @@ impl Imap {
         if !self.can_idle() {
             bail!("IMAP server does not have IDLE capability");
         }
-        self.setup_handle(context).await?;
+        self.prepare(context).await?;
 
         self.select_folder(context, watch_folder.as_deref()).await?;
 
@@ -158,7 +158,7 @@ impl Imap {
                     // try to connect with proper login params
                     // (setup_handle_if_needed might not know about them if we
                     // never successfully connected)
-                    if let Err(err) = self.connect_configured(context).await {
+                    if let Err(err) = self.prepare(context).await {
                         warn!(context, "fake_idle: could not connect: {}", err);
                         continue;
                     }

src/imap/scan_folders.rs

@@ -1,13 +1,13 @@
-use std::time::Instant;
+use std::{collections::BTreeMap, time::Instant};
 
 use anyhow::{Context as _, Result};
 
-use crate::config::Config;
-use crate::context::Context;
 use crate::imap::Imap;
+use crate::{config::Config, log::LogExt};
+use crate::{context::Context, imap::FolderMeaning};
 use async_std::prelude::*;
 
-use super::{get_folder_meaning, get_folder_meaning_by_name, FolderMeaning};
+use super::{get_folder_meaning, get_folder_meaning_by_name};
 
 impl Imap {
     pub async fn scan_folders(&mut self, context: &Context) -> Result<()> {
@@ -25,14 +25,13 @@ impl Imap {
         }
         info!(context, "Starting full folder scan");
 
-        self.connect_configured(context).await?;
+        self.prepare(context).await?;
         let session = self.session.as_mut();
         let session = session.context("scan_folders(): IMAP No Connection established")?;
         let folders: Vec<_> = session.list(Some(""), Some("*")).await?.collect().await;
         let watched_folders = get_watched_folders(context).await;
 
-        let mut sentbox_folder = None;
-        let mut spam_folder = None;
+        let mut folder_configs = BTreeMap::new();
 
         for folder in folders {
             let folder = match folder {
@@ -43,38 +42,41 @@ impl Imap {
                 }
             };
 
-            let foldername = folder.name();
             let folder_meaning = get_folder_meaning(&folder);
-            let folder_name_meaning = get_folder_meaning_by_name(foldername);
+            let folder_name_meaning = get_folder_meaning_by_name(folder.name());
 
-            if folder_meaning == FolderMeaning::SentObjects {
-                // Always takes precedent
-                sentbox_folder = Some(folder.name().to_string());
-            } else if folder_meaning == FolderMeaning::Spam {
-                spam_folder = Some(folder.name().to_string());
-            } else if folder_name_meaning == FolderMeaning::SentObjects {
-                // only set iff none has been already set
-                if sentbox_folder.is_none() {
-                    sentbox_folder = Some(folder.name().to_string());
-                }
-            } else if folder_name_meaning == FolderMeaning::Spam && spam_folder.is_none() {
-                spam_folder = Some(folder.name().to_string());
+            if let Some(config) = folder_meaning.to_config() {
+                // Always takes precedence
+                folder_configs.insert(config, folder.name().to_string());
+            } else if let Some(config) = folder_name_meaning.to_config() {
+                // only set if none has been already set
+                folder_configs
+                    .entry(config)
+                    .or_insert_with(|| folder.name().to_string());
             }
 
+            let is_drafts = folder_meaning == FolderMeaning::Drafts
+                || (folder_meaning == FolderMeaning::Unknown
+                    && folder_name_meaning == FolderMeaning::Drafts);
+
             // Don't scan folders that are watched anyway
-            if !watched_folders.contains(&foldername.to_string()) {
-                if let Err(e) = self.fetch_new_messages(context, foldername, false).await {
-                    warn!(context, "Can't fetch new msgs in scanned folder: {:#}", e);
-                }
+            if !watched_folders.contains(&folder.name().to_string()) && !is_drafts {
+                self.fetch_new_messages(context, folder.name(), false)
+                    .await
+                    .ok_or_log_msg(context, "Can't fetch new msgs in scanned folder");
             }
         }
 
-        context
-            .set_config(Config::ConfiguredSentboxFolder, sentbox_folder.as_deref())
-            .await?;
-        context
-            .set_config(Config::ConfiguredSpamFolder, spam_folder.as_deref())
-            .await?;
+        // We iterate over both folder meanings to make sure that if e.g. the "Sent" folder was deleted,
+        // `ConfiguredSentboxFolder` is set to `None`:
+        for config in &[
+            Config::ConfiguredSentboxFolder,
+            Config::ConfiguredSpamFolder,
+        ] {
+            context
+                .set_config(*config, folder_configs.get(config).map(|s| s.as_str()))
+                .await?;
+        }
 
         last_scan.replace(Instant::now());
         Ok(())

src/job.rs

@@ -532,7 +532,7 @@ impl Job {
     }
 
     async fn move_msg(&mut self, context: &Context, imap: &mut Imap) -> Status {
-        if let Err(err) = imap.connect_configured(context).await {
+        if let Err(err) = imap.prepare(context).await {
             warn!(context, "could not connect: {:?}", err);
             return Status::RetryLater;
         }
@@ -594,7 +594,7 @@ impl Job {
     /// records pointing to the same message on the server, the job
     /// also removes the message on the server.
     async fn delete_msg_on_imap(&mut self, context: &Context, imap: &mut Imap) -> Status {
-        if let Err(err) = imap.connect_configured(context).await {
+        if let Err(err) = imap.prepare(context).await {
             warn!(context, "could not connect: {:?}", err);
             return Status::RetryLater;
         }
@@ -682,7 +682,7 @@ impl Job {
         if job_try!(context.get_config_bool(Config::Bot).await) {
             return Status::Finished(Ok(())); // Bots don't want those messages
         }
-        if let Err(err) = imap.connect_configured(context).await {
+        if let Err(err) = imap.prepare(context).await {
             warn!(context, "could not connect: {:?}", err);
             return Status::RetryLater;
         }
@@ -755,7 +755,7 @@ impl Job {
     /// Chat in contrast to the Sent folder, which is normally managed
     /// by the user via webmail or another email client.
     async fn resync_folders(&mut self, context: &Context, imap: &mut Imap) -> Status {
-        if let Err(err) = imap.connect_configured(context).await {
+        if let Err(err) = imap.prepare(context).await {
             warn!(context, "could not connect: {:?}", err);
             return Status::RetryLater;
         }
@@ -779,7 +779,7 @@ impl Job {
     }
 
     async fn markseen_msg_on_imap(&mut self, context: &Context, imap: &mut Imap) -> Status {
-        if let Err(err) = imap.connect_configured(context).await {
+        if let Err(err) = imap.prepare(context).await {
             warn!(context, "could not connect: {:?}", err);
             return Status::RetryLater;
         }

src/message.rs

@@ -27,7 +27,7 @@ use crate::events::EventType;
 use crate::job::{self, Action};
 use crate::log::LogExt;
 use crate::lot::{Lot, LotState, Meaning};
-use crate::mimeparser::{FailureReport, SystemMessage};
+use crate::mimeparser::{parse_message_id, FailureReport, SystemMessage};
 use crate::param::{Param, Params};
 use crate::pgp::split_armored_data;
 use crate::stock_str;
@@ -400,7 +400,9 @@ impl Message {
                     let msg = Message {
                         id: row.get("id")?,
                         rfc724_mid: row.get::<_, String>("rfc724mid")?,
-                        in_reply_to: row.get::<_, Option<String>>("mime_in_reply_to")?,
+                        in_reply_to: row
+                            .get::<_, Option<String>>("mime_in_reply_to")?
+                            .and_then(|in_reply_to| parse_message_id(&in_reply_to).ok()),
                         server_folder: row.get::<_, Option<String>>("server_folder")?,
                         server_uid: row.get("server_uid")?,
                         chat_id: row.get("chat_id")?,

src/mimeparser.rs

@@ -2955,4 +2955,46 @@ On 2020-10-25, Bob wrote:
             Some("Mr.6Dx7ITn4w38.n9j7epIcuQI@outlook.com".to_string())
         );
     }
+
+    #[async_std::test]
+    async fn test_long_in_reply_to() -> Result<()> {
+        let t = TestContext::new_alice().await;
+
+        // A message with a long Message-ID.
+        // Long message-IDs are generated by Mailjet.
+        let raw = br###"Date: Thu, 28 Jan 2021 00:26:57 +0000
+Chat-Version: 1.0\n\
+Message-ID: <ABCDEFGH.1234567_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA@mailjet.com>
+To: Bob <bob@example.org>
+From: Alice <alice@example.org>
+Subject: ...
+
+Some quote.
+"###;
+        dc_receive_imf(&t, raw, "INBOX", 1, false).await?;
+
+        // Delta Chat generates In-Reply-To with a starting tab when Message-ID is too long.
+        let raw = br###"In-Reply-To:
+	<ABCDEFGH.1234567_AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA@mailjet.com>
+Date: Thu, 28 Jan 2021 00:26:57 +0000
+Chat-Version: 1.0\n\
+Message-ID: <foobar@example.org>
+To: Alice <alice@example.org>
+From: Bob <bob@example.org>
+Subject: ...
+
+> Some quote.
+
+Some reply
+"###;
+
+        dc_receive_imf(&t, raw, "INBOX", 2, false).await?;
+
+        let msg = t.get_last_msg().await;
+        assert_eq!(msg.get_text().unwrap(), "Some reply");
+        let quoted_message = msg.quoted_message(&t).await?.unwrap();
+        assert_eq!(quoted_message.get_text().unwrap(), "Some quote.");
+
+        Ok(())
+    }
 }

src/provider/data.rs

@@ -876,6 +876,35 @@ static P_ROGERS_COM: Lazy<Provider> = Lazy::new(|| Provider {
     oauth2_authorizer: None,
 });
 
+// systemausfall.org.md: systemausfall.org, solidaris.me
+static P_SYSTEMAUSFALL_ORG: Lazy<Provider> = Lazy::new(|| Provider {
+    id: "systemausfall.org",
+    status: Status::Ok,
+    before_login_hint: "",
+    after_login_hint: "",
+    overview_page: "https://providers.delta.chat/systemausfall-org",
+    server: vec![
+        Server {
+            protocol: Imap,
+            socket: Ssl,
+            hostname: "mail.systemausfall.org",
+            port: 993,
+            username_pattern: Email,
+        },
+        Server {
+            protocol: Smtp,
+            socket: Ssl,
+            hostname: "mail.systemausfall.org",
+            port: 465,
+            username_pattern: Email,
+        },
+    ],
+    config_defaults: None,
+    strict_tls: true,
+    max_smtp_rcpt_to: None,
+    oauth2_authorizer: None,
+});
+
 // systemli.org.md: systemli.org
 static P_SYSTEMLI_ORG: Lazy<Provider> = Lazy::new(|| Provider {
     id: "systemli.org",
@@ -991,6 +1020,23 @@ static P_TISCALI_IT: Lazy<Provider> = Lazy::new(|| Provider {
     oauth2_authorizer: None,
 });
 
+// tutanota.md: tutanota.com, tutanota.de, tutamail.com, tuta.io, keemail.me
+static P_TUTANOTA: Lazy<Provider> = Lazy::new(|| {
+    Provider {
+    id: "tutanota",
+    status: Status::Broken,
+    before_login_hint: "Tutanota does not offer the standard IMAP e-mail protocol, so you cannot log in with Delta Chat to Tutanota.",
+    after_login_hint: "",
+    overview_page: "https://providers.delta.chat/tutanota",
+    server: vec![
+    ],
+    config_defaults: None,
+    strict_tls: true,
+    max_smtp_rcpt_to: None,
+    oauth2_authorizer: None,
+}
+});
+
 // ukr.net.md: ukr.net
 static P_UKR_NET: Lazy<Provider> = Lazy::new(|| Provider {
     id: "ukr.net",
@@ -1285,11 +1331,18 @@ pub(crate) static PROVIDER_DATA: Lazy<HashMap<&'static str, &'static Provider>>
         ("protonmail.ch", &*P_PROTONMAIL),
         ("riseup.net", &*P_RISEUP_NET),
         ("rogers.com", &*P_ROGERS_COM),
+        ("systemausfall.org", &*P_SYSTEMAUSFALL_ORG),
+        ("solidaris.me", &*P_SYSTEMAUSFALL_ORG),
         ("systemli.org", &*P_SYSTEMLI_ORG),
         ("t-online.de", &*P_T_ONLINE),
         ("magenta.de", &*P_T_ONLINE),
         ("testrun.org", &*P_TESTRUN),
         ("tiscali.it", &*P_TISCALI_IT),
+        ("tutanota.com", &*P_TUTANOTA),
+        ("tutanota.de", &*P_TUTANOTA),
+        ("tutamail.com", &*P_TUTANOTA),
+        ("tuta.io", &*P_TUTANOTA),
+        ("keemail.me", &*P_TUTANOTA),
         ("ukr.net", &*P_UKR_NET),
         ("undernet.uy", &*P_UNDERNET_UY),
         ("vfemail.net", &*P_VFEMAIL),
@@ -1389,10 +1442,12 @@ pub(crate) static PROVIDER_IDS: Lazy<HashMap<&'static str, &'static Provider>> =
         ("protonmail", &*P_PROTONMAIL),
         ("riseup.net", &*P_RISEUP_NET),
         ("rogers.com", &*P_ROGERS_COM),
+        ("systemausfall.org", &*P_SYSTEMAUSFALL_ORG),
         ("systemli.org", &*P_SYSTEMLI_ORG),
         ("t-online", &*P_T_ONLINE),
         ("testrun", &*P_TESTRUN),
         ("tiscali.it", &*P_TISCALI_IT),
+        ("tutanota", &*P_TUTANOTA),
         ("ukr.net", &*P_UKR_NET),
         ("undernet.uy", &*P_UNDERNET_UY),
         ("vfemail", &*P_VFEMAIL),
@@ -1408,4 +1463,4 @@ pub(crate) static PROVIDER_IDS: Lazy<HashMap<&'static str, &'static Provider>> =
 });
 
 pub static PROVIDER_UPDATED: Lazy<chrono::NaiveDate> =
-    Lazy::new(|| chrono::NaiveDate::from_ymd(2021, 4, 10));
+    Lazy::new(|| chrono::NaiveDate::from_ymd(2021, 6, 7));

src/scheduler.rs

@@ -1,3 +1,4 @@
+use anyhow::{bail, Result};
 use async_std::prelude::*;
 use async_std::{
     channel::{self, Receiver, Sender},
@@ -130,7 +131,7 @@ async fn inbox_loop(ctx: Context, started: Sender<()>, inbox_handlers: ImapConne
 async fn fetch(ctx: &Context, connection: &mut Imap) {
     match ctx.get_config(Config::ConfiguredInboxFolder).await {
         Ok(Some(watch_folder)) => {
-            if let Err(err) = connection.connect_configured(ctx).await {
+            if let Err(err) = connection.prepare(ctx).await {
                 error_network!(ctx, "{}", err);
                 return;
             }
@@ -159,7 +160,7 @@ async fn fetch_idle(ctx: &Context, connection: &mut Imap, folder: Config) -> Int
     match ctx.get_config(folder).await {
         Ok(Some(watch_folder)) => {
             // connect and fake idle if unable to connect
-            if let Err(err) = connection.connect_configured(ctx).await {
+            if let Err(err) = connection.prepare(ctx).await {
                 warn!(ctx, "imap connection failed: {}", err);
                 return connection.fake_idle(ctx, Some(watch_folder)).await;
             }
@@ -301,11 +302,11 @@ async fn smtp_loop(ctx: Context, started: Sender<()>, smtp_handlers: SmtpConnect
 
 impl Scheduler {
     /// Start the scheduler, panics if it is already running.
-    pub async fn start(&mut self, ctx: Context) {
-        let (mvbox, mvbox_handlers) = ImapConnectionState::new();
-        let (sentbox, sentbox_handlers) = ImapConnectionState::new();
+    pub async fn start(&mut self, ctx: Context) -> Result<()> {
+        let (mvbox, mvbox_handlers) = ImapConnectionState::new(&ctx).await?;
+        let (sentbox, sentbox_handlers) = ImapConnectionState::new(&ctx).await?;
         let (smtp, smtp_handlers) = SmtpConnectionState::new();
-        let (inbox, inbox_handlers) = ImapConnectionState::new();
+        let (inbox, inbox_handlers) = ImapConnectionState::new(&ctx).await?;
 
         let (inbox_start_send, inbox_start_recv) = channel::bounded(1);
         let (mvbox_start_send, mvbox_start_recv) = channel::bounded(1);
@@ -321,11 +322,7 @@ impl Scheduler {
             }))
         };
 
-        if ctx
-            .get_config_bool(Config::MvboxWatch)
-            .await
-            .unwrap_or_default()
-        {
+        if ctx.get_config_bool(Config::MvboxWatch).await? {
             let ctx = ctx.clone();
             mvbox_handle = Some(task::spawn(async move {
                 simple_imap_loop(
@@ -343,11 +340,7 @@ impl Scheduler {
                 .expect("mvbox start send, missing receiver");
         }
 
-        if ctx
-            .get_config_bool(Config::SentboxWatch)
-            .await
-            .unwrap_or_default()
-        {
+        if ctx.get_config_bool(Config::SentboxWatch).await? {
             let ctx = ctx.clone();
             sentbox_handle = Some(task::spawn(async move {
                 simple_imap_loop(
@@ -391,10 +384,11 @@ impl Scheduler {
             .try_join(smtp_start_recv.recv())
             .await
         {
-            error!(ctx, "failed to start scheduler: {}", err);
+            bail!("failed to start scheduler: {}", err);
         }
 
         info!(ctx, "scheduler is running");
+        Ok(())
     }
 
     async fn maybe_network(&self) {
@@ -588,13 +582,13 @@ pub(crate) struct ImapConnectionState {
 
 impl ImapConnectionState {
     /// Construct a new connection.
-    fn new() -> (Self, ImapConnectionHandlers) {
+    async fn new(context: &Context) -> Result<(Self, ImapConnectionHandlers)> {
         let (stop_sender, stop_receiver) = channel::bounded(1);
         let (shutdown_sender, shutdown_receiver) = channel::bounded(1);
         let (idle_interrupt_sender, idle_interrupt_receiver) = channel::bounded(1);
 
         let handlers = ImapConnectionHandlers {
-            connection: Imap::new(idle_interrupt_receiver),
+            connection: Imap::new_configured(context, idle_interrupt_receiver).await?,
             stop_receiver,
             shutdown_sender,
         };
@@ -607,7 +601,7 @@ impl ImapConnectionState {
 
         let conn = ImapConnectionState { state };
 
-        (conn, handlers)
+        Ok((conn, handlers))
     }
 
     /// Interrupt any form of idle.

src/securejoin.rs

@@ -253,17 +253,17 @@ async fn get_self_fingerprint(context: &Context) -> Option<Fingerprint> {
 
 #[derive(Debug, thiserror::Error)]
 pub enum JoinError {
-    #[error("Unknown QR-code")]
+    #[error("Unknown QR-code: {0}")]
     QrCode(#[from] QrError),
     #[error("A setup-contact/secure-join protocol is already running")]
     AlreadyRunning,
     #[error("An \"ongoing\" process is already running")]
     OngoingRunning,
-    #[error("Failed to send handshake message")]
+    #[error("Failed to send handshake message: {0}")]
     SendMessage(#[from] SendMsgError),
     // Note that this can currently only occur if there is a bug in the QR/Lot code as this
     // is supposed to create a contact for us.
-    #[error("Unknown contact (this is a bug)")]
+    #[error("Unknown contact (this is a bug): {0}")]
     UnknownContact(#[source] anyhow::Error),
     // Note that this can only occur if we failed to create the chat correctly.
     #[error("Ongoing sender dropped (this is a bug)")]