prepare 1.74 (#3046)

* update changelog for 1.74.0

* bump version to 1.74.0

CHANGELOG.md

@@ -1,21 +1,35 @@
 # Changelog
 
-## Unreleased
+## 1.74.0
+
+### Fixes
+- avoid reconnection loop when message without Message-ID is marked as seen #3044
+
+
+## 1.73.0
+
+### API changes
+- added `only_fetch_mvbox` config #3028
 
 ### Changes
 - don't watch Sent folder by default #3025
 - use webxdc app name in chatlist/quotes/replies etc. #3027
-- refactorings #3023
-- remove direct dependency on `byteorder` crate #3031
 - make it possible to cancel message sending by removing the message #3034,
   this was previosuly removed in 1.71.0 #2939
-- always skip Seen flag synchronization when there are no updates #3039
+- synchronize Seen flags only on watched folders to speed up
+  folder scanning #3041
+- remove direct dependency on `byteorder` crate #3031
+- refactorings #3023 #3013
+- update provider database #3043
+- improve documentation #3017 #3018 #3021
 
 ### Fixes
 - fix splitting off text from webxdc messages #3032
 - call slow `delete_expired_imap_messages()` less often #3037
 - make synchronization of Seen status more robust in case unsolicited FETCH
   result without UID is returned #3022
+- fetch Inbox before scanning folders to ensure iOS does
+  not kill the app before it gets to fetch the Inbox in background #3040
 
 
 ## 1.72.0

Cargo.lock

@@ -1063,7 +1063,7 @@ dependencies = [
 
 [[package]]
 name = "deltachat"
-version = "1.72.0"
+version = "1.74.0"
 dependencies = [
  "ansi_term",
  "anyhow",
@@ -1090,7 +1090,6 @@ dependencies = [
  "hex",
  "humansize",
  "image",
- "imap-proto",
  "kamadak-exif",
  "lettre_email",
  "libc",
@@ -1144,7 +1143,7 @@ dependencies = [
 
 [[package]]
 name = "deltachat_ffi"
-version = "1.72.0"
+version = "1.74.0"
 dependencies = [
  "anyhow",
  "async-std",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "deltachat"
-version = "1.72.0"
+version = "1.74.0"
 authors = ["Delta Chat Developers (ML) <delta@codespeak.net>"]
 edition = "2018"
 license = "MPL-2.0"
@@ -38,7 +38,6 @@ escaper = "0.1"
 futures = "0.3"
 hex = "0.4.0"
 image = { version = "0.23.5", default-features=false, features = ["gif", "jpeg", "ico", "png", "pnm", "webp", "bmp"] }
-imap-proto = "0.14.3"
 kamadak-exif = "0.5"
 lettre_email = { git = "https://github.com/deltachat/lettre", branch = "master" }
 libc = "0.2"

deltachat-ffi/Cargo.toml

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

deltachat-ffi/deltachat.h

@@ -343,6 +343,12 @@ char*           dc_get_blobdir               (const dc_context_t* context);
  *                    and watch the `DeltaChat` folder for updates (default),
  *                    0=do not move chat-messages
  *                    changes require restarting IO by calling dc_stop_io() and then dc_start_io().
+ * - `only_fetch_mvbox` = 1=Do not fetch messages from folders other than the
+ *                    `DeltaChat` folder. Messages will still be fetched from the
+ *                    spam folder and `sendbox_watch` will also still be respected
+ *                    if enabled.
+ *                    0=watch all folders normally (default)
+ *                    changes require restarting IO by calling dc_stop_io() and then dc_start_io().
  * - `show_emails`  = DC_SHOW_EMAILS_OFF (0)=
  *                    show direct replies to chats only (default),
  *                    DC_SHOW_EMAILS_ACCEPTED_CONTACTS (1)=

src/config.rs

@@ -74,6 +74,13 @@ pub enum Config {
     #[strum(props(default = "0"))]
     SentboxMove, // If `MvboxMove` is true, this config is ignored. Currently only used in tests.
 
+    /// Watch for new messages in the "Mvbox" (aka DeltaChat folder) only.
+    ///
+    /// This will not entirely disable other folders, e.g. the spam folder will also still
+    /// be watched for new messages.
+    #[strum(props(default = "0"))]
+    OnlyFetchMvbox,
+
     #[strum(props(default = "0"))] // also change ShowEmails.default() on changes
     ShowEmails,
 
@@ -225,6 +232,11 @@ impl Context {
         Ok(self.get_config_int(key).await? != 0)
     }
 
+    pub(crate) async fn should_watch_mvbox(&self) -> Result<bool> {
+        Ok(self.get_config_bool(Config::MvboxMove).await?
+            || self.get_config_bool(Config::OnlyFetchMvbox).await?)
+    }
+
     /// Gets configured "delete_server_after" value.
     ///
     /// `None` means never delete the message, `Some(0)` means delete
@@ -281,31 +293,25 @@ impl Context {
                     }
                 }
                 self.emit_event(EventType::SelfavatarChanged);
-                Ok(())
             }
             Config::DeleteDeviceAfter => {
-                let ret = self
-                    .sql
-                    .set_raw_config(key, value)
-                    .await
-                    .map_err(Into::into);
+                let ret = self.sql.set_raw_config(key, value).await;
                 // Force chatlist reload to delete old messages immediately.
                 self.emit_event(EventType::MsgsChanged {
                     msg_id: MsgId::new(0),
                     chat_id: ChatId::new(0),
                 });
-                ret
+                ret?
             }
             Config::Displayname => {
                 let value = value.map(improve_single_line_input);
                 self.sql.set_raw_config(key, value.as_deref()).await?;
-                Ok(())
             }
             _ => {
                 self.sql.set_raw_config(key, value).await?;
-                Ok(())
             }
         }
+        Ok(())
     }
 
     pub async fn set_config_bool(&self, key: Config, value: bool) -> Result<()> {

src/configure.rs

@@ -443,7 +443,7 @@ async fn configure(ctx: &Context, param: &mut LoginParam) -> Result<()> {
 
     progress!(ctx, 900);
 
-    let create_mvbox = ctx.get_config_bool(Config::MvboxMove).await?;
+    let create_mvbox = ctx.should_watch_mvbox().await?;
 
     imap.configure_folders(ctx, create_mvbox).await?;
 

src/context.rs

@@ -358,6 +358,7 @@ impl Context {
         let sentbox_watch = self.get_config_int(Config::SentboxWatch).await?;
         let mvbox_move = self.get_config_int(Config::MvboxMove).await?;
         let sentbox_move = self.get_config_int(Config::SentboxMove).await?;
+        let only_fetch_mvbox = self.get_config_int(Config::OnlyFetchMvbox).await?;
         let folders_configured = self
             .sql
             .get_raw_config_int("folders_configured")
@@ -422,6 +423,7 @@ impl Context {
         res.insert("sentbox_watch", sentbox_watch.to_string());
         res.insert("mvbox_move", mvbox_move.to_string());
         res.insert("sentbox_move", sentbox_move.to_string());
+        res.insert("only_fetch_mvbox", only_fetch_mvbox.to_string());
         res.insert("folders_configured", folders_configured.to_string());
         res.insert("configured_sentbox_folder", configured_sentbox_folder);
         res.insert("configured_mvbox_folder", configured_mvbox_folder);

src/imap.rs

@@ -464,9 +464,6 @@ impl Imap {
         self.delete_messages(context, watch_folder)
             .await
             .context("delete_messages")?;
-        self.sync_seen_flags(context, watch_folder)
-            .await
-            .context("sync_seen_flags")?;
 
         Ok(())
     }
@@ -667,6 +664,11 @@ impl Imap {
         folder: &str,
         fetch_existing_msgs: bool,
     ) -> Result<bool> {
+        if should_ignore_folder(context, folder).await? {
+            info!(context, "Not fetching from {}", folder);
+            return Ok(false);
+        }
+
         let new_emails = self.select_with_uidvalidity(context, folder).await?;
 
         if !new_emails && !fetch_existing_msgs {
@@ -1023,33 +1025,23 @@ impl Imap {
             .as_ref()
             .with_context(|| format!("No mailbox selected, folder: {}", folder))?;
 
-        let remote_highest_modseq = if let Some(remote_highest_modseq) = mailbox.highest_modseq {
-            remote_highest_modseq
-        } else {
+        // Check if the mailbox supports MODSEQ.
+        // We are not interested in actual value of HIGHESTMODSEQ.
+        if mailbox.highest_modseq.is_none() {
             info!(
                 context,
                 "Mailbox {} does not support mod-sequences, skipping flag synchronization.", folder
             );
             return Ok(());
-        };
-
-        let mut highest_modseq = get_modseq(context, folder)
-            .await
-            .with_context(|| format!("failed to get MODSEQ for folder {}", folder))?;
-        if highest_modseq >= remote_highest_modseq {
-            info!(
-                context,
-                "MODSEQ {} is already new, HIGHESTMODSEQ={}, skipping seen flag update",
-                highest_modseq,
-                remote_highest_modseq
-            );
-            return Ok(());
         }
 
         let mut updated_chat_ids = BTreeSet::new();
         let uid_validity = get_uidvalidity(context, folder)
             .await
             .with_context(|| format!("failed to get UID validity for folder {}", folder))?;
+        let mut highest_modseq = get_modseq(context, folder)
+            .await
+            .with_context(|| format!("failed to get MODSEQ for folder {}", folder))?;
         let mut list = session
             .uid_fetch("1:*", format!("(FLAGS) (CHANGEDSINCE {})", highest_modseq))
             .await
@@ -1084,10 +1076,6 @@ impl Imap {
             }
         }
 
-        if remote_highest_modseq > highest_modseq {
-            // We haven't seen the message with the highest MODSEQ, maybe it was deleted already.
-            highest_modseq = remote_highest_modseq;
-        }
         set_modseq(context, folder, highest_modseq)
             .await
             .with_context(|| format!("failed to set MODSEQ for folder {}", folder))?;
@@ -1584,23 +1572,6 @@ impl Imap {
         Ok(())
     }
 
-    /// Update HIGHESTMODSEQ on selected mailbox.
-    ///
-    /// Should be called when MODSEQ is seen on the response, such as IDLE response.
-    pub(crate) fn update_modseq(&mut self, modseq: u64) {
-        self.config.selected_mailbox =
-            self.config
-                .selected_mailbox
-                .as_ref()
-                .map(|mailbox| Mailbox {
-                    highest_modseq: Some(std::cmp::max(
-                        mailbox.highest_modseq.unwrap_or_default(),
-                        modseq,
-                    )),
-                    ..mailbox.clone()
-                });
-    }
-
     /// Return whether the server sent an unsolicited EXISTS response.
     /// Drains all responses from `session.unsolicited_responses` in the process.
     /// If this returns `true`, this means that new emails arrived and you should
@@ -1670,7 +1641,11 @@ async fn spam_target_folder(
         }
     }
 
-    if needs_move_to_mvbox(context, headers).await? {
+    if needs_move_to_mvbox(context, headers).await?
+        // We don't want to move the message to the inbox or sentbox where we wouldn't
+        // fetch it again:
+        || context.get_config_bool(Config::OnlyFetchMvbox).await?
+    {
         Ok(Some(Config::ConfiguredMvboxFolder))
     } else if needs_move_to_sentbox(context, folder, headers).await? {
         Ok(Some(Config::ConfiguredSentboxFolder))
@@ -2005,7 +1980,7 @@ async fn mark_seen_by_uid(
         .sql
         .query_row_optional(
             "SELECT id, chat_id FROM msgs
-                 WHERE rfc724_mid IN (
+                 WHERE id > 9 AND rfc724_mid IN (
                    SELECT rfc724_mid FROM imap
                    WHERE folder=?1
                    AND uidvalidity=?2
@@ -2152,6 +2127,21 @@ pub async fn get_config_last_seen_uid(context: &Context, folder: &str) -> Result
     }
 }
 
+/// Whether to ignore fetching messages from a folder.
+///
+/// This caters for the [`Config::OnlyFetchMvbox`] setting which means mails from folders
+/// not explicitly watched should not be fetched.
+async fn should_ignore_folder(context: &Context, folder: &str) -> Result<bool> {
+    if !context.get_config_bool(Config::OnlyFetchMvbox).await? {
+        return Ok(false);
+    }
+    if context.is_sentbox(folder).await? {
+        // Still respect the SentboxWatch setting.
+        return Ok(!context.get_config_bool(Config::SentboxWatch).await?);
+    }
+    Ok(!(context.is_mvbox(folder).await? || context.is_spam_folder(folder).await?))
+}
+
 /// Builds a list of sequence/uid sets. The returned sets have each no more than around 1000
 /// characters because according to <https://tools.ietf.org/html/rfc2683#section-3.2.1.5>
 /// command lines should not be much more than 1000 chars (servers should allow at least 8000 chars)

src/imap/idle.rs

@@ -3,7 +3,6 @@ use super::Imap;
 use anyhow::{bail, Context as _, Result};
 use async_imap::extensions::idle::IdleResponse;
 use async_std::prelude::*;
-use imap_proto::types::{AttributeValue, Response};
 use std::time::{Duration, SystemTime};
 
 use crate::{context::Context, scheduler::InterruptInfo};
@@ -72,13 +71,6 @@ impl Imap {
             match fut.await {
                 Ok(Event::IdleResponse(IdleResponse::NewData(x))) => {
                     info!(context, "Idle has NewData {:?}", x);
-                    if let Response::Fetch(_message, attrs) = x.parsed() {
-                        for attr in attrs {
-                            if let AttributeValue::ModSeq(modseq) = attr {
-                                self.update_modseq(*modseq);
-                            }
-                        }
-                    }
                 }
                 Ok(Event::IdleResponse(IdleResponse::Timeout)) => {
                     info!(context, "Idle-wait timeout or interruption");
@@ -165,7 +157,6 @@ impl Imap {
                     // in anything.  If so, we behave as if IDLE had data but
                     // will have already fetched the messages so perform_*_fetch
                     // will not find any new.
-
                     match self.fetch_new_messages(context, &watch_folder, false).await {
                         Ok(res) => {
                             info!(context, "fetch_new_messages returned {:?}", res);

src/imap/scan_folders.rs

@@ -10,7 +10,8 @@ use async_std::prelude::*;
 use super::{get_folder_meaning, get_folder_meaning_by_name};
 
 impl Imap {
-    pub(crate) async fn scan_folders(&mut self, context: &Context) -> Result<()> {
+    /// Returns true if folders were scanned, false if scanning was postponed.
+    pub(crate) async fn scan_folders(&mut self, context: &Context) -> Result<bool> {
         // First of all, debounce to once per minute:
         let mut last_scan = context.last_full_folder_scan.lock().await;
         if let Some(last_scan) = *last_scan {
@@ -20,7 +21,7 @@ impl Imap {
                 .await?;
 
             if elapsed_secs < debounce_secs {
-                return Ok(());
+                return Ok(false);
             }
         }
         info!(context, "Starting full folder scan");
@@ -98,24 +99,26 @@ impl Imap {
         }
 
         last_scan.replace(Instant::now());
-        Ok(())
+        Ok(true)
     }
 }
 
+pub(crate) async fn get_watched_folder_configs(context: &Context) -> Result<Vec<Config>> {
+    let mut res = vec![Config::ConfiguredInboxFolder];
+    if context.get_config_bool(Config::SentboxWatch).await? {
+        res.push(Config::ConfiguredSentboxFolder);
+    }
+    if context.should_watch_mvbox().await? {
+        res.push(Config::ConfiguredMvboxFolder);
+    }
+    Ok(res)
+}
+
 pub(crate) async fn get_watched_folders(context: &Context) -> Result<Vec<String>> {
     let mut res = Vec::new();
-    if let Some(inbox_folder) = context.get_config(Config::ConfiguredInboxFolder).await? {
-        res.push(inbox_folder);
-    }
-    let folder_watched_configured = &[
-        (Config::SentboxWatch, Config::ConfiguredSentboxFolder),
-        (Config::MvboxMove, Config::ConfiguredMvboxFolder),
-    ];
-    for (watched, configured) in folder_watched_configured {
-        if context.get_config_bool(*watched).await? {
-            if let Some(folder) = context.get_config(*configured).await? {
-                res.push(folder);
-            }
+    for folder_config in get_watched_folder_configs(context).await? {
+        if let Some(folder) = context.get_config(folder_config).await? {
+            res.push(folder);
         }
     }
     Ok(res)

src/provider/data.rs

@@ -366,7 +366,7 @@ static P_EXAMPLE_COM: Lazy<Provider> = Lazy::new(|| {
 }
 });
 
-// fastmail.md: fastmail.com
+// fastmail.md: 123mail.org, 150mail.com, 150ml.com, 16mail.com, 2-mail.com, 4email.net, 50mail.com, airpost.net, allmail.net, bestmail.us, cluemail.com, elitemail.org, emailcorner.net, emailengine.net, emailengine.org, emailgroups.net, emailplus.org, emailuser.net, eml.cc, f-m.fm, fast-email.com, fast-mail.org, fastem.com, fastemail.us, fastemailer.com, fastest.cc, fastimap.com, fastmail.cn, fastmail.co.uk, fastmail.com, fastmail.com.au, fastmail.de, fastmail.es, fastmail.fm, fastmail.fr, fastmail.im, fastmail.in, fastmail.jp, fastmail.mx, fastmail.net, fastmail.nl, fastmail.org, fastmail.se, fastmail.to, fastmail.tw, fastmail.uk, fastmail.us, fastmailbox.net, fastmessaging.com, fea.st, fmail.co.uk, fmailbox.com, fmgirl.com, fmguy.com, ftml.net, h-mail.us, hailmail.net, imap-mail.com, imap.cc, imapmail.org, inoutbox.com, internet-e-mail.com, internet-mail.org, internetemails.net, internetmailing.net, jetemail.net, justemail.net, letterboxes.org, mail-central.com, mail-page.com, mailandftp.com, mailas.com, mailbolt.com, mailc.net, mailcan.com, mailforce.net, mailftp.com, mailhaven.com, mailingaddress.org, mailite.com, mailmight.com, mailnew.com, mailsent.net, mailservice.ms, mailup.net, mailworks.org, ml1.net, mm.st, myfastmail.com, mymacmail.com, nospammail.net, ownmail.net, petml.com, postinbox.com, postpro.net, proinbox.com, promessage.com, realemail.net, reallyfast.biz, reallyfast.info, rushpost.com, sent.as, sent.at, sent.com, speedpost.net, speedymail.org, ssl-mail.com, swift-mail.com, the-fastest.net, the-quickest.com, theinternetemail.com, veryfast.biz, veryspeedy.net, warpmail.net, xsmail.com, yepmail.net, your-mail.com
 static P_FASTMAIL: Lazy<Provider> = Lazy::new(|| Provider {
     id: "fastmail",
     status: Status::Preparation,
@@ -389,13 +389,6 @@ static P_FASTMAIL: Lazy<Provider> = Lazy::new(|| Provider {
             port: 465,
             username_pattern: Email,
         },
-        Server {
-            protocol: Smtp,
-            socket: Starttls,
-            hostname: "smtp.fastmail.com",
-            port: 587,
-            username_pattern: Email,
-        },
     ],
     config_defaults: None,
     strict_tls: true,
@@ -716,8 +709,8 @@ static P_MAIL_DE: Lazy<Provider> = Lazy::new(|| Provider {
 static P_MAIL_RU: Lazy<Provider> = Lazy::new(|| {
     Provider {
     id: "mail.ru",
-    status: Status::Ok,
-    before_login_hint: "Не рекомендуется использовать mail.ru, потому что он разряжает вашу батарею быстрее, чем другие провайдеры.",
+    status: Status::Preparation,
+    before_login_hint: "Вам необходимо сгенерировать \"пароль для внешнего приложения\" в веб-интерфейсе mail.ru, чтобы mail.ru работал с Delta Chat.",
     after_login_hint: "",
     overview_page: "https://providers.delta.chat/mail-ru",
     server: vec![
@@ -905,7 +898,7 @@ static P_NAVER: Lazy<Provider> = Lazy::new(|| Provider {
     oauth2_authorizer: None,
 });
 
-// outlook.com.md: hotmail.com, outlook.com, office365.com, outlook.com.tr, live.com
+// outlook.com.md: hotmail.com, outlook.com, office365.com, outlook.com.tr, live.com, outlook.de
 static P_OUTLOOK_COM: Lazy<Provider> = Lazy::new(|| Provider {
     id: "outlook.com",
     status: Status::Ok,
@@ -1495,7 +1488,123 @@ pub(crate) static PROVIDER_DATA: Lazy<HashMap<&'static str, &'static Provider>>
         ("example.com", &*P_EXAMPLE_COM),
         ("example.org", &*P_EXAMPLE_COM),
         ("example.net", &*P_EXAMPLE_COM),
+        ("123mail.org", &*P_FASTMAIL),
+        ("150mail.com", &*P_FASTMAIL),
+        ("150ml.com", &*P_FASTMAIL),
+        ("16mail.com", &*P_FASTMAIL),
+        ("2-mail.com", &*P_FASTMAIL),
+        ("4email.net", &*P_FASTMAIL),
+        ("50mail.com", &*P_FASTMAIL),
+        ("airpost.net", &*P_FASTMAIL),
+        ("allmail.net", &*P_FASTMAIL),
+        ("bestmail.us", &*P_FASTMAIL),
+        ("cluemail.com", &*P_FASTMAIL),
+        ("elitemail.org", &*P_FASTMAIL),
+        ("emailcorner.net", &*P_FASTMAIL),
+        ("emailengine.net", &*P_FASTMAIL),
+        ("emailengine.org", &*P_FASTMAIL),
+        ("emailgroups.net", &*P_FASTMAIL),
+        ("emailplus.org", &*P_FASTMAIL),
+        ("emailuser.net", &*P_FASTMAIL),
+        ("eml.cc", &*P_FASTMAIL),
+        ("f-m.fm", &*P_FASTMAIL),
+        ("fast-email.com", &*P_FASTMAIL),
+        ("fast-mail.org", &*P_FASTMAIL),
+        ("fastem.com", &*P_FASTMAIL),
+        ("fastemail.us", &*P_FASTMAIL),
+        ("fastemailer.com", &*P_FASTMAIL),
+        ("fastest.cc", &*P_FASTMAIL),
+        ("fastimap.com", &*P_FASTMAIL),
+        ("fastmail.cn", &*P_FASTMAIL),
+        ("fastmail.co.uk", &*P_FASTMAIL),
         ("fastmail.com", &*P_FASTMAIL),
+        ("fastmail.com.au", &*P_FASTMAIL),
+        ("fastmail.de", &*P_FASTMAIL),
+        ("fastmail.es", &*P_FASTMAIL),
+        ("fastmail.fm", &*P_FASTMAIL),
+        ("fastmail.fr", &*P_FASTMAIL),
+        ("fastmail.im", &*P_FASTMAIL),
+        ("fastmail.in", &*P_FASTMAIL),
+        ("fastmail.jp", &*P_FASTMAIL),
+        ("fastmail.mx", &*P_FASTMAIL),
+        ("fastmail.net", &*P_FASTMAIL),
+        ("fastmail.nl", &*P_FASTMAIL),
+        ("fastmail.org", &*P_FASTMAIL),
+        ("fastmail.se", &*P_FASTMAIL),
+        ("fastmail.to", &*P_FASTMAIL),
+        ("fastmail.tw", &*P_FASTMAIL),
+        ("fastmail.uk", &*P_FASTMAIL),
+        ("fastmail.us", &*P_FASTMAIL),
+        ("fastmailbox.net", &*P_FASTMAIL),
+        ("fastmessaging.com", &*P_FASTMAIL),
+        ("fea.st", &*P_FASTMAIL),
+        ("fmail.co.uk", &*P_FASTMAIL),
+        ("fmailbox.com", &*P_FASTMAIL),
+        ("fmgirl.com", &*P_FASTMAIL),
+        ("fmguy.com", &*P_FASTMAIL),
+        ("ftml.net", &*P_FASTMAIL),
+        ("h-mail.us", &*P_FASTMAIL),
+        ("hailmail.net", &*P_FASTMAIL),
+        ("imap-mail.com", &*P_FASTMAIL),
+        ("imap.cc", &*P_FASTMAIL),
+        ("imapmail.org", &*P_FASTMAIL),
+        ("inoutbox.com", &*P_FASTMAIL),
+        ("internet-e-mail.com", &*P_FASTMAIL),
+        ("internet-mail.org", &*P_FASTMAIL),
+        ("internetemails.net", &*P_FASTMAIL),
+        ("internetmailing.net", &*P_FASTMAIL),
+        ("jetemail.net", &*P_FASTMAIL),
+        ("justemail.net", &*P_FASTMAIL),
+        ("letterboxes.org", &*P_FASTMAIL),
+        ("mail-central.com", &*P_FASTMAIL),
+        ("mail-page.com", &*P_FASTMAIL),
+        ("mailandftp.com", &*P_FASTMAIL),
+        ("mailas.com", &*P_FASTMAIL),
+        ("mailbolt.com", &*P_FASTMAIL),
+        ("mailc.net", &*P_FASTMAIL),
+        ("mailcan.com", &*P_FASTMAIL),
+        ("mailforce.net", &*P_FASTMAIL),
+        ("mailftp.com", &*P_FASTMAIL),
+        ("mailhaven.com", &*P_FASTMAIL),
+        ("mailingaddress.org", &*P_FASTMAIL),
+        ("mailite.com", &*P_FASTMAIL),
+        ("mailmight.com", &*P_FASTMAIL),
+        ("mailnew.com", &*P_FASTMAIL),
+        ("mailsent.net", &*P_FASTMAIL),
+        ("mailservice.ms", &*P_FASTMAIL),
+        ("mailup.net", &*P_FASTMAIL),
+        ("mailworks.org", &*P_FASTMAIL),
+        ("ml1.net", &*P_FASTMAIL),
+        ("mm.st", &*P_FASTMAIL),
+        ("myfastmail.com", &*P_FASTMAIL),
+        ("mymacmail.com", &*P_FASTMAIL),
+        ("nospammail.net", &*P_FASTMAIL),
+        ("ownmail.net", &*P_FASTMAIL),
+        ("petml.com", &*P_FASTMAIL),
+        ("postinbox.com", &*P_FASTMAIL),
+        ("postpro.net", &*P_FASTMAIL),
+        ("proinbox.com", &*P_FASTMAIL),
+        ("promessage.com", &*P_FASTMAIL),
+        ("realemail.net", &*P_FASTMAIL),
+        ("reallyfast.biz", &*P_FASTMAIL),
+        ("reallyfast.info", &*P_FASTMAIL),
+        ("rushpost.com", &*P_FASTMAIL),
+        ("sent.as", &*P_FASTMAIL),
+        ("sent.at", &*P_FASTMAIL),
+        ("sent.com", &*P_FASTMAIL),
+        ("speedpost.net", &*P_FASTMAIL),
+        ("speedymail.org", &*P_FASTMAIL),
+        ("ssl-mail.com", &*P_FASTMAIL),
+        ("swift-mail.com", &*P_FASTMAIL),
+        ("the-fastest.net", &*P_FASTMAIL),
+        ("the-quickest.com", &*P_FASTMAIL),
+        ("theinternetemail.com", &*P_FASTMAIL),
+        ("veryfast.biz", &*P_FASTMAIL),
+        ("veryspeedy.net", &*P_FASTMAIL),
+        ("warpmail.net", &*P_FASTMAIL),
+        ("xsmail.com", &*P_FASTMAIL),
+        ("yepmail.net", &*P_FASTMAIL),
+        ("your-mail.com", &*P_FASTMAIL),
         ("firemail.at", &*P_FIREMAIL_DE),
         ("firemail.de", &*P_FIREMAIL_DE),
         ("five.chat", &*P_FIVE_CHAT),
@@ -1539,6 +1648,7 @@ pub(crate) static PROVIDER_DATA: Lazy<HashMap<&'static str, &'static Provider>>
         ("office365.com", &*P_OUTLOOK_COM),
         ("outlook.com.tr", &*P_OUTLOOK_COM),
         ("live.com", &*P_OUTLOOK_COM),
+        ("outlook.de", &*P_OUTLOOK_COM),
         ("posteo.de", &*P_POSTEO),
         ("posteo.af", &*P_POSTEO),
         ("posteo.at", &*P_POSTEO),
@@ -1743,4 +1853,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(2022, 1, 11));
+    Lazy::new(|| chrono::NaiveDate::from_ymd(2022, 1, 31));

src/scheduler.rs

@@ -11,6 +11,7 @@ use crate::dc_tools::maybe_add_time_based_warnings;
 use crate::ephemeral::delete_expired_imap_messages;
 use crate::imap::Imap;
 use crate::job::{self, Thread};
+use crate::log::LogExt;
 use crate::smtp::{send_smtp_messages, Smtp};
 
 use self::connectivity::ConnectivityStore;
@@ -169,25 +170,49 @@ async fn fetch_idle(ctx: &Context, connection: &mut Imap, folder: Config) -> Int
                 warn!(ctx, "{:#}", err);
             }
 
-            // Scan other folders before fetching from watched folder. This may result in the
-            // messages being moved into the watched folder, for example from the Spam folder to
-            // the Inbox folder.
-            if folder == Config::ConfiguredInboxFolder {
-                // Only scan on the Inbox thread in order to prevent parallel scans, which might lead to duplicate messages
-                if let Err(err) = connection.scan_folders(ctx).await {
-                    // Don't reconnect, if there is a problem with the connection we will realize this when IDLEing
-                    // but maybe just one folder can't be selected or something
-                    warn!(ctx, "{}", err);
-                }
-            }
-
-            // fetch
+            // Fetch the watched folder.
             if let Err(err) = connection.fetch_move_delete(ctx, &watch_folder).await {
                 connection.trigger_reconnect(ctx).await;
                 warn!(ctx, "{:#}", err);
                 return InterruptInfo::new(false);
             }
 
+            // Scan additional folders only after finishing fetching the watched folder.
+            //
+            // On iOS the application has strictly limited time to work in background, so we may not
+            // be able to scan all folders before time is up if there are many of them.
+            if folder == Config::ConfiguredInboxFolder {
+                // Only scan on the Inbox thread in order to prevent parallel scans, which might lead to duplicate messages
+                match connection.scan_folders(ctx).await {
+                    Err(err) => {
+                        // Don't reconnect, if there is a problem with the connection we will realize this when IDLEing
+                        // but maybe just one folder can't be selected or something
+                        warn!(ctx, "{}", err);
+                    }
+                    Ok(true) => {
+                        // Fetch the watched folder again in case scanning other folder moved messages
+                        // there.
+                        //
+                        // In most cases this will select the watched folder and return because there are
+                        // no new messages. We want to select the watched folder anyway before going IDLE
+                        // there, so this does not take additional protocol round-trip.
+                        if let Err(err) = connection.fetch_move_delete(ctx, &watch_folder).await {
+                            connection.trigger_reconnect(ctx).await;
+                            warn!(ctx, "{:#}", err);
+                            return InterruptInfo::new(false);
+                        }
+                    }
+                    Ok(false) => {}
+                }
+            }
+
+            // Synchronize Seen flags.
+            connection
+                .sync_seen_flags(ctx, &watch_folder)
+                .await
+                .context("sync_seen_flags")
+                .ok_or_log(ctx);
+
             connection.connectivity.set_connected(ctx).await;
 
             // idle
@@ -350,7 +375,7 @@ impl Scheduler {
             }))
         };
 
-        if ctx.get_config_bool(Config::MvboxMove).await? {
+        if ctx.should_watch_mvbox().await? {
             let ctx = ctx.clone();
             mvbox_handle = Some(task::spawn(async move {
                 simple_imap_loop(

src/scheduler/connectivity.rs

@@ -5,6 +5,7 @@ use async_std::sync::{Mutex, RwLockReadGuard};
 
 use crate::dc_tools::time;
 use crate::events::EventType;
+use crate::imap::scan_folders::get_watched_folder_configs;
 use crate::quota::{
     QUOTA_ERROR_THRESHOLD_PERCENTAGE, QUOTA_MAX_AGE_SECONDS, QUOTA_WARN_THRESHOLD_PERCENTAGE,
 };
@@ -362,17 +363,14 @@ impl Context {
                 [
                     (
                         Config::ConfiguredInboxFolder,
-                        None,
                         inbox.state.connectivity.clone(),
                     ),
                     (
                         Config::ConfiguredMvboxFolder,
-                        Some(Config::MvboxMove),
                         mvbox.state.connectivity.clone(),
                     ),
                     (
                         Config::ConfiguredSentboxFolder,
-                        Some(Config::SentboxWatch),
                         sentbox.state.connectivity.clone(),
                     ),
                 ],
@@ -391,20 +389,12 @@ impl Context {
         //                               - "Sent": Connected
         // =============================================================================================
 
+        let watched_folders = get_watched_folder_configs(self).await?;
         ret += &format!("<h3>{}</h3><ul>", stock_str::incoming_messages(self).await);
-        for (folder, watch, state) in &folders_states {
-            let w = if let Some(watch_config) = *watch {
-                self.get_config(watch_config)
-                    .await
-                    .ok_or_log(self)
-                    .flatten()
-                    == Some("1".to_string())
-            } else {
-                true
-            };
-
+        for (folder, state) in &folders_states {
             let mut folder_added = false;
-            if w {
+
+            if watched_folders.contains(folder) {
                 let f = self.get_config(*folder).await.ok_or_log(self).flatten();
 
                 if let Some(foldername) = f {